diff --git a/BOWSER_V2_DESIGN.md b/BOWSER_V2_DESIGN.md
new file mode 100644
index 0000000..87c9bbf
--- /dev/null
+++ b/BOWSER_V2_DESIGN.md
@@ -0,0 +1,988 @@
+# Bowser V2: Design Document
+
+> **Status:** Draft
+> **Date:** 2026-03-22
+> **Authors:** Scott Staniewicz + Claude
+
+---
+
+## Table of Contents
+
+1. [Motivation](#1-motivation)
+2. [Competitive Landscape](#2-competitive-landscape)
+3. [V2 Vision & Principles](#3-v2-vision--principles)
+4. [Data Model](#4-data-model)
+5. [Architecture Overview](#5-architecture-overview)
+6. [Backend Design](#6-backend-design)
+7. [Frontend Design](#7-frontend-design)
+8. [UX Design](#8-ux-design)
+9. [Technology Choices](#9-technology-choices)
+10. [Migration from V1](#10-migration-from-v1)
+11. [Implementation Phases](#11-implementation-phases)
+12. [Open Questions](#12-open-questions)
+
+---
+
+## 1. Motivation
+
+Bowser V1 is a raster-first tool: every pixel on the map is a tile rendered from COGs or xarray datasets. This works well for continuous fields (unwrapped phase, coherence maps, displacement grids), but InSAR increasingly produces **point-based outputs** that don't fit the raster model:
+
+- **Persistent Scatterer (PS) points** — sparse, irregularly-spaced measurement points with per-point time series and attributes (velocity, coherence, height, etc.)
+- **Distributed Scatterer (DS) points** — similar to PS but from different processing pipelines
+- **SBAS pixel subsets** — not every pixel survives temporal coherence thresholds; the result is a sparse point cloud, not a full grid
+- **GPS/GNSS stations** — ground truth reference points with their own time series
+- **OPERA DISP-S1 post-processed results** — velocity, amplitude dispersion, etc. that are per-point
+
+Commercial platforms (IRIS, TRE-MAPS) already handle this well. TRE-MAPS in particular is entirely point-based — users filter, color, select, and export individual measurement points. IRIS offers raster views with point-level inspection. Neither is open source, and both are tightly coupled to their respective processing pipelines.
+
+**Bowser V2 should be the open-source answer**: a viewer that handles both rasters AND points natively, leveraging the huge recent improvements in cloud-native vector data (GeoParquet, DuckDB, deck.gl, PMTiles).
+
+---
+
+## 2. Competitive Landscape
+
+### IRIS (EarthDaily Analytics)
+
+**Strengths:**
+- Multi-panel map comparison (reference image / InSAR overlay / amplitude)
+- Processing sandbox — users can trigger re-processing from the UI
+- Anomaly detection layer
+- Clean dark-themed UI with well-integrated time series chart
+- GPS ground monitoring overlay
+
+**Weaknesses:**
+- Raster-only visualization — no point-level attribute filtering
+- Three-panel layout wastes screen space when you only need one view
+- Heavy, proprietary platform tied to EarthDaily's processing pipeline
+- No export capabilities visible in the UI
+
+**Key takeaway:** The multi-panel comparison and anomaly detection are powerful ideas. The tight integration between spatial view and time series chart is table-stakes.
+
+### TRE-MAPS (TRE-ALTAMIRA)
+
+**Strengths:**
+- Point-based data model with rich per-point attributes (velocity, height, displacement, effective area, perimeter)
+- Three-tier filtering: by attribute, by date range, by symbology
+- Cross-section / profile tool — draw a transect line, see displacement along it
+- Polygon selection for area averaging (up to 10k points)
+- Multi-format export (CSV, Geodatabase, Shapefile, KMZ)
+- Multiple time series in one chart (shift+click)
+
+**Weaknesses:**
+- Dated UI (ArcGIS/ESRI-era design)
+- Limited to 1,000 points per export
+- Data archived after 3 months of inactivity
+- Only Chrome/Firefox supported
+- No raster layer support — can't overlay coherence or amplitude maps
+
+**Key takeaway:** The attribute filtering, symbology control, and cross-section tool are essential for point data. The 300-column CSV problem (like EGMS) shows the need for a clean, opinionated data model.
+
+### EGMS (European Ground Motion Service)
+
+**Relevant context:** EGMS distributes PS/DS point data as massive CSVs with ~300 columns (one per acquisition date for displacement values, plus metadata columns). This is the "data model anti-pattern" we want to avoid.
+
+---
+
+## 3. V2 Vision & Principles
+
+### Vision
+
+Bowser V2 is a **dual-mode InSAR viewer** that treats rasters and point clouds as first-class citizens. A researcher should be able to:
+
+1. Load a displacement raster stack AND a set of PS points over the same AOI
+2. See both layers simultaneously on the map
+3. Click a PS point to see its time series, or click the raster to sample pixel values
+4. Filter points by velocity, coherence, or any attribute
+5. Draw a transect and see a cross-section profile
+6. Export selected points with their full time series
+
+### Design Principles
+
+1. **Rasters + Vectors, unified** — One app, one map, both data types. No mode switching.
+2. **GeoParquet as the canonical point format** — Columnar, cloud-native, typed, self-describing. No 300-column CSVs.
+3. **Server does the heavy lifting, client does the rendering** — DuckDB handles filtering/aggregation on the server; the browser renders the result via WebGL.
+4. **Progressive disclosure** — Simple view by default (map + time series). Power features (filtering, cross-sections, export) available but not in your face.
+5. **URL-driven state** — Every view should be shareable via URL. Dataset, viewport, active filters, selected points — all encoded in the URL.
+6. **Open formats, open source** — No vendor lock-in. Standard formats in, standard formats out.
+
+---
+
+## 4. Data Model
+
+### 4.1 The Problem with Wide CSVs
+
+EGMS and similar services distribute point data as wide-format CSVs:
+
+```
+lon, lat, velocity, coherence, 2016-01-01, 2016-01-13, 2016-01-25, ...
+-118.25, 34.05, -12.3, 0.85, 0.0, -1.2, -2.1, ...
+```
+
+Problems: hundreds of date columns, no type information, no metadata, can't efficiently query a subset of dates, enormous file sizes, hard to extend with new attributes.
+
+### 4.2 Bowser V2 Point Data Model
+
+We adopt a **normalized, long-form model** stored as GeoParquet. The data is split into two logical tables that can live in one or two files:
+
+#### Points Table (`points.parquet`)
+
+One row per measurement point. Stores spatial location and static attributes.
+
+| Column | Type | Required | Description |
+|--------|------|----------|-------------|
+| `point_id` | `uint64` | yes | Unique identifier |
+| `geometry` | `POINT` | yes | WGS84 lon/lat (GeoParquet native) |
+| `velocity` | `float32` | no | Mean velocity (mm/yr), LOS |
+| `velocity_std` | `float32` | no | Velocity uncertainty |
+| `temporal_coherence` | `float32` | no | Temporal coherence [0, 1] |
+| `height` | `float32` | no | Estimated height (m) above reference DEM |
+| `amplitude_dispersion` | `float32` | no | Amplitude dispersion index |
+| `reference_point_id` | `uint64` | no | Which point is the spatial reference |
+
+Design choices:
+- **`point_id` as uint64** rather than a compound key. Simple, fast joins, small index.
+- **Static attributes only** in this table. Anything that varies per date goes in the time series table.
+- **Optional columns are truly optional** — GeoParquet handles missing columns gracefully. A PS dataset might have `amplitude_dispersion`; a SBAS dataset might not. The frontend dynamically discovers available columns via the `/points/{layer}/attributes` endpoint.
+- **No CRS column** — GeoParquet metadata carries the CRS (EPSG:4326 by default). Projections happen at query/render time.
+- **Units stored in Parquet column metadata** — Each column carries a `units` key in its Parquet metadata (e.g., `{"units": "mm/yr"}` for velocity). The backend reads these and passes them to the frontend for axis labels and tooltips.
+
+#### Time Series Table (`timeseries.parquet`)
+
+One row per (point, date) pair. Long-form — the number of columns is fixed regardless of how many dates exist.
+
+| Column | Type | Required | Description |
+|--------|------|----------|-------------|
+| `point_id` | `uint64` | yes | FK to points table |
+| `date` | `date32` | yes | Acquisition date |
+| `displacement` | `float32` | yes | Cumulative displacement (mm), LOS |
+| `displacement_std` | `float32` | no | Per-epoch uncertainty |
+
+Design choices:
+- **Long-form is non-negotiable.** Adding a new acquisition date is appending rows, not adding columns. Queries like "all displacements between 2020-01-01 and 2021-01-01" are a simple `WHERE` clause, not selecting 50 columns by name.
+- **`date32`** not a string. Enables native date arithmetic, range queries, sorting.
+- **Row group layout is critical for performance.** See section 4.5.
+
+#### Why Two Tables?
+
+Joining is cheap (especially in DuckDB). The alternative — embedding the full time series as a nested array column — makes point-level metadata queries fast but time-range queries slow, and prevents columnar compression of the displacement values.
+
+For datasets where separate files are inconvenient, both tables can be stored in a single GeoParquet file using row groups or a single Parquet file with a `table` discriminator column. But logically, they are two relations.
+
+### 4.3 Dataset Manifest
+
+A Bowser V2 dataset is described by a JSON manifest that references both raster and vector sources:
+
+```json
+{
+  "name": "LA Basin PS Analysis",
+  "description": "Sentinel-1 descending, 2016-2023",
+  "satellite": "Sentinel-1",
+  "orbit": "descending",
+  "track": 71,
+  "reference_date": "2016-07-01",
+
+  "layers": {
+    "displacement": {
+      "type": "raster",
+      "source": "s3://bucket/displacement_stack.zarr",
+      "colormap": "RdBu_r",
+      "units": "mm",
+      "vmin": -50,
+      "vmax": 50
+    },
+    "coherence": {
+      "type": "raster",
+      "source": "s3://bucket/temporal_coherence.tif",
+      "colormap": "inferno",
+      "units": "",
+      "vmin": 0,
+      "vmax": 1
+    },
+    "ps_points": {
+      "type": "points",
+      "points_source": "s3://bucket/ps_points.parquet",
+      "timeseries_source": "s3://bucket/ps_timeseries.parquet",
+      "default_color_by": "velocity",
+      "default_colormap": "RdBu_r",
+      "default_vmin": -30,
+      "default_vmax": 30
+    },
+    "gps_stations": {
+      "type": "points",
+      "points_source": "s3://bucket/gps_stations.parquet",
+      "timeseries_source": "s3://bucket/gps_timeseries.parquet",
+      "default_color_by": "velocity",
+      "marker_style": "triangle"
+    }
+  },
+
+  "bounds": [-118.8, 33.5, -117.5, 34.3]
+}
+```
+
+This is deliberately simple:
+- **Flat, no nesting beyond `layers`** — easy to hand-write, easy to generate programmatically
+- **Each layer declares its type** — `raster` or `points` — so the frontend knows how to render it
+- **Defaults are suggestions** — the user can change colormap/range in the UI
+- **Sources can be local paths or S3 URIs** — the backend resolves them
+
+### 4.4 Conversion Utilities
+
+Converters are prioritized by what we can test immediately:
+
+#### Priority 1: Dolphin raster → point cloud (`bowser convert dolphin`)
+
+This is the primary early use case. A dolphin workflow directory contains:
+- `timeseries/YYYYMMDD.tif` — displacement rasters (one per date)
+- `timeseries/velocity.tif` — velocity map
+- `timeseries/velocity_stderr.tif` — velocity uncertainty
+- `interferograms/temporal_coherence_*.tif` — temporal coherence
+- `interferograms/amp_dispersion_looked*.tif` — amplitude dispersion
+- `interferograms/similarity_*.tif` — phase similarity
+- `interferograms/ps_mask_looked*.tif` — PS mask
+
+The converter:
+1. Reads the quality rasters (temporal coherence, amplitude dispersion, etc.)
+2. Applies a mask to select "good" pixels (e.g., `temporal_coherence > threshold`)
+3. Extracts lon/lat for surviving pixels
+4. Reads displacement values at those pixel locations across all dates
+5. Writes `points.parquet` (point_id, geometry, velocity, temporal_coherence, amplitude_dispersion, ...) and `timeseries.parquet` (point_id, date, displacement)
+6. Generates a `bowser_manifest.json` referencing both the original rasters and the new point layers
+
+```bash
+bowser convert dolphin /path/to/dolphin_work_dir \
+  --coherence-threshold 0.5 \
+  --output-dir ./dolphin_points/
+```
+
+#### Priority 2: MintPy HDF5
+
+```bash
+bowser convert mintpy --input timeseries.h5 --output-dir ./mintpy_points/
+```
+
+#### Priority 3 (future): Generic CSV, EGMS, StaMPS
+
+```bash
+# Generic long-form CSV
+bowser convert csv --input points.csv \
+  --lon-col longitude --lat-col latitude \
+  --date-col date --displacement-col disp_mm \
+  --output-dir ./custom/
+
+# EGMS wide-format CSV (someday)
+bowser convert egms --input egms_l3.csv --output-dir ./la_basin/
+```
+
+Each converter produces `points.parquet` + `timeseries.parquet` + a `bowser_manifest.json`.
+
+### 4.5 Parquet Row Group Strategy
+
+Row groups are the unit of I/O in Parquet — each row group is read independently, and column chunks within a row group are contiguous on disk. Row group layout has a major impact on query performance.
+
+#### Points table
+
+Row groups of ~50,000-100,000 points each. Since the points table is relatively small (one row per point, ~10 columns), a single row group often suffices for datasets under 1M points. For larger datasets, row groups sorted by a spatial key (e.g., H3 cell index or Hilbert curve) cluster nearby points together, improving bbox query performance.
+
+```python
+# Write with spatial sorting for bbox query efficiency
+import h3
+points["h3_cell"] = points.geometry.apply(lambda g: h3.latlng_to_cell(g.y, g.x, 6))
+points = points.sort_values("h3_cell").drop(columns=["h3_cell"])
+points.to_parquet("points.parquet", row_group_size=100_000)
+```
+
+#### Time series table
+
+This is where row groups matter most. The time series table can be enormous (1M points × 200 dates = 200M rows). Two layout strategies:
+
+**Option A: Group by point_id (point-access pattern)**
+Each row group contains all dates for a contiguous range of point IDs. This makes "fetch one point's full time series" a single row group read.
+
+```python
+# Sort by point_id, then date within each point
+ts = ts.sort_values(["point_id", "date"])
+# Row group size = num_dates × points_per_group
+# For 200 dates and ~500 points per group: row_group_size = 100_000
+ts.to_parquet("timeseries.parquet", row_group_size=num_dates * 500)
+```
+
+**Option B: Group by date (spatial-access pattern)**
+Each row group contains all points for one or a few dates. This makes "fetch displacement at date X for all points in bbox" fast, which is what the map view needs.
+
+For our use case, **Option A (group by point_id) is the default** because:
+- The most common query is "give me the time series for these N clicked points"
+- DuckDB can still efficiently filter by date within a row group (columnar scan)
+- The map view fetches static attributes (velocity) from the points table, not from the time series table
+
+We may revisit this or support both layouts if the date-access pattern becomes a bottleneck.
+
+---
+
+## 5. Architecture Overview
+
+```
+┌─────────────────────────────────────────────────────────────────┐
+│                    Frontend (React + TypeScript)                 │
+│                                                                 │
+│  ┌──────────────┐  ┌──────────────┐  ┌───────────────────────┐ │
+│  │  MapLibre GL  │  │  deck.gl     │  │  Chart.js / Plotly    │ │
+│  │  (basemaps,   │  │  (point      │  │  (time series,        │ │
+│  │   raster      │  │   cloud      │  │   cross-sections,     │ │
+│  │   tiles)      │  │   rendering) │  │   histograms)         │ │
+│  └──────┬───────┘  └──────┬───────┘  └───────────┬───────────┘ │
+│         │                  │                       │             │
+│         └──────────────────┼───────────────────────┘             │
+│                            │ HTTP / WebSocket                    │
+└────────────────────────────┼────────────────────────────────────┘
+                             │
+┌────────────────────────────┼────────────────────────────────────┐
+│                    Backend (FastAPI)                             │
+│                                                                 │
+│  ┌──────────────┐  ┌──────────────┐  ┌───────────────────────┐ │
+│  │  Raster       │  │  Vector      │  │  Analysis             │ │
+│  │  Server       │  │  Server      │  │  Engine               │ │
+│  │  (titiler)    │  │  (DuckDB +   │  │  (trend fitting,      │ │
+│  │              │  │   GeoParquet) │  │   cross-sections,     │ │
+│  │  COGs, Zarr   │  │              │  │   area averaging)     │ │
+│  └──────────────┘  └──────────────┘  └───────────────────────┘ │
+│                                                                 │
+│  ┌──────────────────────────────────────────────────────────────┤
+│  │  Data Layer                                                  │
+│  │  - Cloud Optimized GeoTIFFs          (existing V1)           │
+│  │  - Zarr / NetCDF xarray datasets     (existing V1)           │
+│  │  - GeoParquet point files            (NEW)                   │
+│  │  - Local filesystem first, S3 later                          │
+│  └──────────────────────────────────────────────────────────────┘
+└─────────────────────────────────────────────────────────────────┘
+```
+
+### What stays from V1
+
+- **titiler** for raster tile serving (COGs, Zarr, xarray) — battle-tested, no reason to replace
+- **FastAPI** as the web framework
+- **React + TypeScript** frontend
+- **CLI for dataset setup** (`bowser run`, `bowser setup-*`)
+
+### What's new in V2
+
+- **DuckDB** as an embedded analytical query engine for point data
+- **GeoParquet** as the canonical point data format
+- **deck.gl** (via `@deck.gl/maplibre`) for WebGL point rendering on the client
+- **MapLibre GL JS** replacing Leaflet for the map (WebGL-native, vector tile support, smoother interaction)
+- **Analysis engine** for cross-sections, area statistics, and trend analysis on point data
+
+---
+
+## 6. Backend Design
+
+### 6.1 Vector Server (New)
+
+The vector server is the centerpiece of V2. It uses DuckDB to query GeoParquet files and returns results as GeoJSON or binary Arrow IPC for large responses.
+
+#### Endpoints
+
+```
+GET  /points/{layer_name}
+     ?bbox=-118.5,33.8,-117.8,34.2     # viewport bounding box
+     &color_by=velocity                  # attribute for coloring
+     &filter=temporal_coherence>0.7      # attribute filter expression
+     &max_points=50000                   # client-requested limit
+     → Returns: GeoJSON or Arrow IPC (based on Accept header)
+       Point geometries + requested attribute columns only
+
+GET  /points/{layer_name}/{point_id}/timeseries
+     ?start_date=2020-01-01
+     &end_date=2023-12-31
+     → Returns: JSON array of {date, displacement, displacement_std}
+
+POST /points/{layer_name}/timeseries
+     Body: {"point_ids": [123, 456, 789]}
+     → Returns: Multi-point time series for charting
+
+GET  /points/{layer_name}/stats
+     ?bbox=...&filter=...
+     → Returns: {count, velocity_mean, velocity_std, velocity_min, velocity_max, ...}
+       Summary statistics for filtered points in viewport
+
+POST /points/{layer_name}/cross_section
+     Body: {
+       "line": [[lon1, lat1], [lon2, lat2]],
+       "width_m": 200,
+       "attribute": "velocity"
+     }
+     → Returns: Array of {distance_along_profile, attribute_value, point_id}
+
+POST /points/{layer_name}/area_average
+     Body: {
+       "polygon": [[lon1, lat1], ...],
+       "max_points": 10000
+     }
+     → Returns: Averaged time series + individual point count
+
+GET  /points/{layer_name}/attributes
+     → Returns: List of available columns with types and value ranges
+       Used by the frontend to build filter UI dynamically
+
+POST /export
+     Body: {
+       "layer_name": "ps_points",
+       "format": "csv" | "geojson" | "geoparquet",
+       "bbox": [...],
+       "filter": "...",
+       "include_timeseries": true
+     }
+     → Returns: File download
+```
+
+#### DuckDB Query Engine
+
+DuckDB runs **in-process** (no separate database server). On startup, the backend registers GeoParquet files as DuckDB views:
+
+```python
+import duckdb
+
+conn = duckdb.connect()
+conn.install_extension("spatial")
+conn.load_extension("spatial")
+
+# Register point sources as views
+conn.execute("""
+    CREATE VIEW ps_points AS
+    SELECT * FROM read_parquet('s3://bucket/ps_points.parquet', spatial=true)
+""")
+conn.execute("""
+    CREATE VIEW ps_timeseries AS
+    SELECT * FROM read_parquet('s3://bucket/ps_timeseries.parquet')
+""")
+```
+
+Filtering translates directly to SQL:
+
+```python
+def query_points(
+    layer: str,
+    bbox: tuple[float, float, float, float],
+    color_by: str,
+    filters: list[str],
+    max_points: int,
+) -> pa.Table:
+    where_clauses = [
+        f"ST_Within(geometry, ST_MakeEnvelope({bbox[0]}, {bbox[1]}, {bbox[2]}, {bbox[3]}))"
+    ]
+    for f in filters:
+        where_clauses.append(sanitize_filter(f))  # parameterized to prevent injection
+
+    sql = f"""
+        SELECT point_id, ST_X(geometry) as lon, ST_Y(geometry) as lat, {color_by}
+        FROM {layer}
+        WHERE {' AND '.join(where_clauses)}
+        LIMIT {max_points}
+    """
+    return conn.execute(sql).fetch_arrow_table()
+```
+
+#### Progressive Loading Strategy
+
+For datasets with millions of points, we can't send them all to the browser at once. Strategy:
+
+1. **Viewport-based loading**: Only query points within the current map bbox + a small buffer
+2. **Zoom-dependent density**: At low zoom, use DuckDB `SAMPLE` or spatial grid aggregation. At high zoom, send individual points.
+3. **Attribute-aware thinning**: When zoomed out, prioritize high-|velocity| points (they're what the user cares about)
+4. **Client-side budget**: The frontend requests at most N points (e.g., 100k). The backend respects this and downsamples if needed.
+
+```
+Zoom level    Strategy               Approx points sent
+────────────────────────────────────────────────────────
+< 10          Grid aggregation       ~1,000 cells
+10-14         Sampled points         ~10,000-50,000
+> 14          All points in bbox     Up to 100,000
+```
+
+### 6.2 Raster Server (Enhanced V1)
+
+The existing titiler-based raster server stays largely unchanged. Enhancements:
+
+- **Unified dataset registry**: Both raster and vector layers registered through the manifest
+- **Raster point sampling**: `GET /raster/{layer_name}/point?lon=...&lat=...` for clicking on raster pixels (existing V1 behavior, new URL prefix)
+- **COG + Zarr**: Continue supporting both modes
+
+### 6.3 Analysis Engine (New)
+
+Server-side computations that operate on point data:
+
+- **Trend fitting**: Linear, piecewise-linear, seasonal decomposition
+- **Cross-section profiles**: Query points within a buffer of a transect line, project onto the line, return distance-vs-attribute
+- **Area averaging**: Mean time series within a polygon, with uncertainty propagation
+- **Spatial reference adjustment**: Subtract a reference point's time series from all others
+- **Anomaly detection**: Flag points with velocity significantly different from neighbors (future)
+
+These are exposed as POST endpoints (see 6.1) and computed on-demand via DuckDB queries + NumPy/SciPy.
+
+---
+
+## 7. Frontend Design
+
+### 7.1 Map Engine: MapLibre GL JS + deck.gl
+
+**Why replace Leaflet with MapLibre:**
+- WebGL-native rendering (Leaflet is DOM-based, struggles past ~10k markers)
+- Native vector tile support
+- Smooth fractional zooming, 3D tilt, rotation
+- deck.gl integrates directly as a MapLibre custom layer
+
+**deck.gl for point rendering:**
+- `ScatterplotLayer` renders 1M+ points at 60fps via WebGL
+- Built-in picking (hover/click identification without spatial index on client)
+- GPU-accelerated color mapping — send attribute values + colormap, GPU does the rest
+- Binary data transport (Arrow IPC → GPU buffer) avoids JSON parsing overhead
+
+```typescript
+import { MapboxOverlay } from '@deck.gl/mapbox';
+import { ScatterplotLayer } from '@deck.gl/layers';
+
+const pointLayer = new ScatterplotLayer({
+  id: 'ps-points',
+  data: arrowTable,  // binary Arrow from backend
+  getPosition: d => [d.lon, d.lat],
+  getFillColor: d => colorScale(d.velocity),
+  getRadius: 3,
+  radiusMinPixels: 2,
+  radiusMaxPixels: 8,
+  pickable: true,
+  onClick: info => selectPoint(info.object.point_id),
+});
+
+map.addControl(new MapboxOverlay({ layers: [pointLayer] }));
+```
+
+### 7.2 Charting: Plotly.js
+
+**Why switch from Chart.js to Plotly:**
+- Better for scientific data: error bars, subplots, annotations built-in
+- Linked brushing (select time range on chart → highlight on map)
+- Better zoom/pan within charts
+- WebGL renderer for large time series (`scattergl` trace type)
+- Export to PNG/SVG built-in
+- Widely used in scientific Python (familiar to our users)
+
+### 7.3 State Management
+
+V1 uses React Context + useReducer. For V2, keep this pattern but formalize URL-driven state:
+
+```typescript
+interface AppState {
+  // Dataset
+  datasetManifest: DatasetManifest;
+  activeLayers: string[];
+
+  // Map viewport
+  center: [number, number];
+  zoom: number;
+  bearing: number;
+  pitch: number;
+
+  // Point layer state
+  colorBy: string;
+  colormap: string;
+  vmin: number;
+  vmax: number;
+  filters: Filter[];
+
+  // Selection
+  selectedPointIds: number[];
+  referencePointId: number | null;
+  hoveredPointId: number | null;
+
+  // Raster layer state
+  rasterTimeIndex: number;
+  rasterColormap: string;
+  rasterVmin: number;
+  rasterVmax: number;
+  rasterOpacity: number;
+
+  // Analysis
+  crossSectionLine: [number, number][] | null;
+  areaSelectionPolygon: [number, number][] | null;
+
+  // UI
+  chartVisible: boolean;
+  panelVisible: boolean;
+  activeTab: 'layers' | 'filter' | 'export';
+}
+```
+
+All of this serializes to URL search params, so `https://bowser.app/?dataset=la_basin&color_by=velocity&filter=coherence>0.7&zoom=12&center=-118.2,34.0` is a shareable, reproducible view.
+
+### 7.4 Component Architecture
+
+```
+App
+├── MapView
+│   ├── MapLibreMap (basemap, raster tile layers)
+│   ├── DeckGLOverlay (point cloud layers)
+│   ├── CrossSectionTool (draw transect line)
+│   ├── AreaSelectTool (draw polygon)
+│   └── MapControls (zoom, basemap picker, 3D tilt)
+│
+├── Sidebar
+│   ├── LayerPanel
+│   │   ├── LayerToggle (per-layer visibility, opacity)
+│   │   ├── RasterControls (time slider, colormap, vmin/vmax)
+│   │   └── PointControls (color-by dropdown, colormap, vmin/vmax)
+│   ├── FilterPanel
+│   │   ├── AttributeFilter (field + operator + value)
+│   │   ├── DateRangeFilter (start/end date pickers)
+│   │   └── ActiveFilters (chips showing current filters)
+│   └── ExportPanel
+│       ├── FormatPicker (CSV, GeoJSON, GeoParquet)
+│       ├── ScopeToggle (viewport / selection / all)
+│       └── ExportButton
+│
+├── BottomPanel (resizable)
+│   ├── TimeSeriesChart (selected points' displacement vs time)
+│   ├── CrossSectionChart (displacement vs distance along profile)
+│   ├── HistogramChart (attribute distribution in viewport)
+│   └── StatsBar (point count, mean velocity, etc.)
+│
+└── Toolbar
+    ├── SelectTool (click to select points)
+    ├── MultiSelectTool (shift+click or box select)
+    ├── CrossSectionTool (draw line)
+    ├── AreaAverageTool (draw polygon)
+    ├── ReferenceTool (set reference point)
+    └── MeasureTool (distance/area)
+```
+
+---
+
+## 8. UX Design
+
+### 8.1 What We Take from IRIS
+
+- **Tight spatial-temporal coupling**: Clicking the map immediately updates the time series chart. This is non-negotiable.
+- **Multiple basemap options**: Satellite, terrain, dark, and OSM.
+- **Colorbar always visible**: Anchored to the map, not buried in a menu.
+
+### 8.2 What We Take from TRE-MAPS
+
+- **Attribute filtering** is the killer feature for point data. Users need to quickly filter to "show me only points with velocity < -10 mm/yr and coherence > 0.7."
+- **Cross-section profiles**: Draw a line, see displacement along it. Essential for visualizing subsidence bowls, fault offsets, etc.
+- **Multi-point time series**: Shift+click to add more points to the chart. Compare trends across locations.
+- **Area averaging**: Select a polygon, get the mean time series with uncertainty. Critical for comparing against GPS.
+- **Export with time series**: Not just point locations — include the full displacement history.
+
+### 8.3 What We Do Differently
+
+**Progressive disclosure instead of modal dialogs:**
+TRE-MAPS uses modal dialog boxes for filtering and symbology. We use an inline sidebar panel that stays open while you interact with the map. No context switches.
+
+**Unified raster + point view:**
+Neither IRIS nor TRE-MAPS does this well. IRIS is raster-only; TRE-MAPS is point-only. Bowser V2 overlays both. Use case: view the displacement raster for spatial context, with PS points on top colored by velocity, to see where the raster and point estimates agree/disagree.
+
+**URL-driven state for collaboration:**
+"Look at this" should be a link, not a screenshot. Every filter, selection, and viewport state encoded in the URL.
+
+**Smart defaults, explicit overrides:**
+- Auto-detect colormap range from data percentiles (not hardcoded)
+- Auto-detect which attribute to color by (velocity if available, else first float column)
+- Auto-detect time series mode (single-ref vs multi-ref, carrying forward V1's hybrid approach)
+- Everything overridable in the manifest or the UI
+
+**Keyboard-driven power user workflow:**
+- `F` — toggle filter panel
+- `T` — toggle time series chart
+- `R` — set reference point mode
+- `C` — cross-section tool
+- `Escape` — clear selection
+- Number keys — switch between layers
+
+### 8.4 Layout
+
+```
+┌──────────────────────────────────────────────────────────────┐
+│  [Bowser]  dataset-name   |  tools: [🔍] [📏] [📐] [📌]     │
+├────────────┬─────────────────────────────────────────────────┤
+│            │                                                 │
+│  Sidebar   │                                                 │
+│  (280px)   │              Map View                           │
+│            │              (MapLibre + deck.gl)                │
+│  Layers    │                                                 │
+│  ├ Disp.   │                       ┌─────────┐              │
+│  ├ Coh.    │                       │ Colorbar│              │
+│  └ PS Pts  │                       └─────────┘              │
+│            │                                                 │
+│  Filters   │                                                 │
+│  ┌────────┐│                                                 │
+│  │vel<-10 ││                                                 │
+│  │coh>0.7 ││                                                 │
+│  └────────┘│                                                 │
+│            │                                                 │
+│  Stats     ├─────────────────────────────────────────────────┤
+│  N: 42,301 │  Time Series Chart                  [minimize] │
+│  v̄: -8.2   │  ╭─────────────────────────────╮                │
+│            │  │  •   •                       │  ← Point 1   │
+│            │  │    •   •  •                  │  ← Point 2   │
+│            │  │         •   •  •             │               │
+│            │  ╰─────────────────────────────╯                │
+│            │  2016    2018    2020    2022                    │
+└────────────┴─────────────────────────────────────────────────┘
+```
+
+Key layout decisions:
+- **Sidebar on the left** (not right) — matches file-browser mental model, keeps the most-used controls close to the eye's starting position
+- **Bottom panel for charts** — resizable, can be minimized. Charts expand horizontally (time axis benefits from width).
+- **No floating panels** — everything docked. Prevents the "lost dialog box" problem.
+- **Stats summary always visible** in the sidebar — point count and mean velocity update live as you filter/pan.
+
+---
+
+## 9. Technology Choices
+
+### 9.1 Strict Choices (High Conviction)
+
+| Component | Choice | Why |
+|-----------|--------|-----|
+| Point data format | **GeoParquet** | Columnar, cloud-native, typed, self-describing. Industry momentum (Overture, STAC, Planetary Computer). Parquet ecosystem (DuckDB, Polars, Arrow) is mature. |
+| Server query engine | **DuckDB** | In-process (no infra), reads Parquet natively, spatial extension for bbox queries, fast analytical queries, Arrow output for zero-copy to client. |
+| Map renderer | **MapLibre GL JS** | WebGL-native, open-source (no Mapbox token), vector tile support, smooth interaction, active community. |
+| Point renderer | **deck.gl** | 1M+ points via WebGL, binary Arrow data path, picking built-in, MapLibre integration via `@deck.gl/mapbox`. |
+| Backend framework | **FastAPI** | Already used in V1, async, OpenAPI docs, Pydantic integration. |
+| Raster tiles | **titiler** | Already used in V1, COG + Zarr support, battle-tested. |
+
+### 9.2 Flexible Choices (Open to Alternatives)
+
+| Component | Current Pick | Alternative | Decision Criteria |
+|-----------|-------------|-------------|-------------------|
+| Charting | Plotly.js | Chart.js (V1), Apache ECharts, Observable Plot | Plotly if we need error bars + linked brushing. Chart.js if we want minimal bundle size. |
+| State management | React Context + URL params | Zustand, Jotai | Upgrade only if Context becomes painful with many consumers. Zustand is lightweight and would be a natural step up. |
+| CSS | Tailwind CSS | CSS Modules (V1), Styled Components | Tailwind for rapid iteration and consistent design tokens. |
+| Bundler | Vite | (keep from V1) | No change needed. |
+| Data transport | Arrow IPC for large responses, JSON for small | All JSON, All Arrow | Arrow IPC for >1k points (avoid JSON parse cost). JSON for metadata endpoints. |
+
+### 9.3 Future Considerations (Not for V2.0)
+
+| Technology | When | Why wait |
+|------------|------|----------|
+| **PMTiles** (pre-tiled vector) | V2.1+ | Useful for static datasets (e.g., EGMS). But V2.0 focuses on dynamic DuckDB-served data. Add PMTiles as an alternative source type later. |
+| **DuckDB-WASM** (client-side queries) | V2.2+ | Run DuckDB in the browser for offline/local analysis. Exciting but adds complexity. Start server-side, move to hybrid later. |
+| **WebGPU** (next-gen rendering) | When browser support is >90% | deck.gl already has WebGPU support. MapLibre is working on it. |
+| **GeoArrow** | When spec stabilizes | Native Arrow geometry type. Currently GeoParquet uses WKB in Arrow, which requires a decode step. GeoArrow would eliminate this. |
+| **3D visualization** | V2.1+ | PS points have estimated heights. 3D view (deck.gl supports this) would let users see the point cloud in 3D. Nice to have, not essential. |
+
+---
+
+## 10. Migration from V1
+
+### What Breaks
+
+Nothing. V2 is a **superset** of V1.
+
+- V1 raster-only datasets (`bowser_rasters.json` or `--stack-file`) continue to work exactly as before
+- V1 URLs continue to work
+- V1 CLI commands (`bowser run`, `bowser setup-*`) are unchanged
+
+### What Changes
+
+- Leaflet → MapLibre GL JS (visual change, same tile sources)
+- Chart.js → Plotly.js (visual change, same data)
+- New `bowser_manifest.json` format for V2 datasets (V1 JSON config still supported via auto-upgrade)
+- New CLI commands: `bowser convert`, `bowser setup-points`
+- New `/points/` endpoints for vector data
+
+### Upgrade Path
+
+1. Existing V1 users: `pip install --upgrade bowser-insar` → everything works, map looks slightly different (MapLibre vs Leaflet)
+2. Users with point data: create a `bowser_manifest.json`, run `bowser convert` to get GeoParquet, `bowser run --manifest bowser_manifest.json`
+3. No data migration required for raster datasets
+
+---
+
+## 11. Implementation Phases
+
+### Phase 1: Foundation
+
+**Goal:** MapLibre + deck.gl rendering a GeoParquet point cloud from a dolphin export, with point click → time series.
+
+- [ ] **Converter:** `bowser convert dolphin` — read dolphin raster stack, mask by quality, export to GeoParquet
+- [ ] **Backend:** DuckDB reads GeoParquet, serves points via `/points/` endpoint
+- [ ] **Backend:** Single-point and multi-point time series endpoints
+- [ ] **Backend:** Point attributes endpoint (discover available columns)
+- [ ] **Frontend:** Replace Leaflet with MapLibre GL JS
+- [ ] **Frontend:** Add deck.gl overlay for point rendering (ScatterplotLayer, colored by velocity)
+- [ ] **Frontend:** Click point → fetch + display time series in Plotly chart
+- [ ] **Data model:** Define `bowser_manifest.json` schema (Pydantic model)
+- [ ] **Data model:** Implement row-group-aware Parquet writing in converter
+
+**Demo:** Run `bowser convert dolphin /path/to/work_dir`, then `bowser run --manifest bowser_manifest.json`. See 1M+ points on map colored by velocity, click one, see its displacement time series.
+
+### Phase 2: Filtering & Interaction (Weeks 4-6)
+
+**Goal:** Attribute filtering, multi-point selection, reference point.
+
+- [ ] Sidebar filter panel (attribute + operator + value)
+- [ ] Backend: Filter expressions in DuckDB queries
+- [ ] Multi-point selection (shift+click, box select)
+- [ ] Multi-point time series chart
+- [ ] Reference point subtraction (spatial referencing)
+- [ ] Dynamic colormap + vmin/vmax controls for point layer
+- [ ] Stats bar (point count, mean velocity in viewport)
+- [ ] URL-driven state (serialize filters, viewport, selection to URL params)
+
+**Demo:** Filter to high-velocity points, select several, compare their time series, set a reference point.
+
+### Phase 3: Analysis Tools (Weeks 7-9)
+
+**Goal:** Cross-sections, area averaging, trend analysis, export.
+
+- [ ] Cross-section tool: draw line on map, server computes profile, display in chart
+- [ ] Area averaging tool: draw polygon, server computes mean time series
+- [ ] Trend fitting (linear + seasonal) on selected point time series
+- [ ] Export panel: CSV, GeoJSON, GeoParquet download with time series
+- [ ] Histogram of attribute values in viewport
+- [ ] Date range filter (restrict time series to a window)
+
+**Demo:** Draw a transect across a subsidence bowl, see the displacement profile. Select an area near a GPS station, compare averaged InSAR time series to GPS.
+
+### Phase 4: Raster + Vector Unification (Weeks 10-12)
+
+**Goal:** Both rasters and points in one view, polish, converters.
+
+- [ ] Unified layer panel (raster + point layers togglable independently)
+- [ ] Raster opacity / point opacity independent controls
+- [ ] Click behavior: if point layer active, click selects point. If only raster, click samples raster.
+- [ ] CLI converter: `bowser convert mintpy`
+- [ ] `bowser setup-points` — interactive CLI for creating point layer config
+- [ ] Performance testing with 1M+ point datasets
+- [ ] Polish: keyboard shortcuts, responsive layout, loading states, error handling
+
+**Demo:** Load a full OPERA DISP-S1 raster stack + PS points from the same area. Toggle between raster and point views. Export a subset of points with time series as GeoParquet.
+
+### Phase 5: Stretch Goals (Post-V2.0)
+
+- [ ] PMTiles support for pre-tiled static point datasets
+- [ ] DuckDB-WASM for client-side queries (offline mode)
+- [ ] 3D point cloud view (deck.gl PointCloudLayer with estimated heights)
+- [ ] Anomaly detection layer (flag outlier points)
+- [ ] GPS time series overlay on InSAR time series chart
+- [ ] Multi-dataset comparison (two PS datasets from different orbits/processors)
+- [ ] Temporal animation (play through time steps)
+- [ ] Collaborative annotations (pin a comment to a location)
+
+---
+
+## 12. Design Decisions (Resolved)
+
+1. **Two-table format** for points + timeseries. Revisit if single-file convenience becomes a pain point.
+2. **Flexible schema** — `velocity`, `temporal_coherence`, etc. are recommended but not enforced. Frontend dynamically discovers available columns. Datasets with recognized columns get better defaults. Early testing will mostly have temporal_coherence; other quality metrics will vary.
+3. **Points only** — no polygon footprints for DS data. Everything renders as points.
+4. **Units in Parquet column metadata** — each column carries `{"units": "mm/yr"}` etc. in its Parquet metadata.
+5. **Local-first for early development** — DuckDB reads local Parquet files. S3 access will be tested later; if cold-start latency is bad, we'll add caching then.
+6. **Client-side point budget** — needs empirical testing with deck.gl. Start without a hard cap, observe performance with 1-10M point datasets.
+7. **Default to Arrow IPC** for point data responses — we'll almost always have >1k points (typically 1-10M from raster export). JSON only for metadata/timeseries endpoints.
+8. **Click prefers points** — when both raster and point layers are visible, clicks prefer nearby points (pixel-distance threshold). Falls back to raster sampling if no point is close.
+9. **No mobile** — desktop-first, no effort on responsive mobile layout.
+10. **Dark mode default** — support both light and dark themes if not a huge lift. Default to dark (satellite basemaps look better on dark backgrounds).
+
+---
+
+## Appendix A: Example DuckDB Queries
+
+```sql
+-- Points in viewport with velocity filter
+SELECT point_id, ST_X(geometry) as lon, ST_Y(geometry) as lat, velocity
+FROM ps_points
+WHERE ST_Within(geometry, ST_MakeEnvelope(-118.5, 33.8, -117.8, 34.2))
+  AND temporal_coherence > 0.7
+  AND velocity < -10
+LIMIT 50000;
+
+-- Time series for selected points
+SELECT t.point_id, t.date, t.displacement
+FROM ps_timeseries t
+WHERE t.point_id IN (123, 456, 789)
+ORDER BY t.point_id, t.date;
+
+-- Cross-section: points within 200m of a transect line
+SELECT
+    point_id,
+    velocity,
+    ST_Distance(
+        geometry,
+        ST_Point(-118.3, 34.0)  -- start of line
+    ) as distance_along,
+FROM ps_points
+WHERE ST_DWithin(
+    geometry,
+    ST_MakeLine(ST_Point(-118.3, 34.0), ST_Point(-118.1, 34.1)),
+    0.002  -- ~200m in degrees at this latitude
+)
+ORDER BY distance_along;
+
+-- Area average time series
+SELECT t.date, AVG(t.displacement) as mean_disp, STDDEV(t.displacement) as std_disp, COUNT(*) as n
+FROM ps_timeseries t
+JOIN ps_points p ON t.point_id = p.point_id
+WHERE ST_Within(p.geometry, ST_GeomFromText('POLYGON((...))'))
+GROUP BY t.date
+ORDER BY t.date;
+
+-- Attribute statistics for filter panel
+SELECT
+    MIN(velocity) as vel_min, MAX(velocity) as vel_max,
+    PERCENTILE_CONT(0.05) WITHIN GROUP (ORDER BY velocity) as vel_p05,
+    PERCENTILE_CONT(0.95) WITHIN GROUP (ORDER BY velocity) as vel_p95,
+    MIN(temporal_coherence) as coh_min, MAX(temporal_coherence) as coh_max,
+    COUNT(*) as total_points
+FROM ps_points;
+```
+
+## Appendix B: GeoParquet File Example
+
+```python
+import geopandas as gpd
+import pandas as pd
+import numpy as np
+
+# Create points table
+n_points = 100_000
+points = gpd.GeoDataFrame({
+    'point_id': np.arange(n_points, dtype=np.uint64),
+    'velocity': np.random.normal(-5, 15, n_points).astype(np.float32),
+    'velocity_std': np.random.uniform(0.5, 3.0, n_points).astype(np.float32),
+    'temporal_coherence': np.random.uniform(0.3, 1.0, n_points).astype(np.float32),
+    'height': np.random.normal(0, 5, n_points).astype(np.float32),
+    'amplitude_dispersion': np.random.uniform(0.1, 0.4, n_points).astype(np.float32),
+}, geometry=gpd.points_from_xy(
+    np.random.uniform(-118.5, -117.8, n_points),
+    np.random.uniform(33.8, 34.2, n_points),
+), crs="EPSG:4326")
+
+points.to_parquet("ps_points.parquet")
+
+# Create time series table
+dates = pd.date_range("2016-01-01", "2023-12-31", freq="12D")
+ts_rows = []
+for pid in range(n_points):
+    vel = points.loc[pid, 'velocity']
+    days = (dates - dates[0]).days.values
+    disp = vel / 365.25 * days + np.random.normal(0, 2, len(dates))
+    for d, v in zip(dates, disp):
+        ts_rows.append({'point_id': np.uint64(pid), 'date': d, 'displacement': np.float32(v)})
+
+ts = pd.DataFrame(ts_rows)
+ts.to_parquet("ps_timeseries.parquet", row_group_size=len(dates))  # one row group per point
+```
+
+## Appendix C: Technology Reference Links
+
+- GeoParquet spec: https://geoparquet.org/
+- DuckDB spatial: https://duckdb.org/docs/extensions/spatial
+- MapLibre GL JS: https://maplibre.org/maplibre-gl-js/docs/
+- deck.gl: https://deck.gl/
+- deck.gl + MapLibre: https://deck.gl/docs/get-started/using-with-maplibre
+- Arrow IPC: https://arrow.apache.org/docs/format/Columnar.html#ipc-streaming-format
+- Plotly.js: https://plotly.com/javascript/
+- titiler: https://developmentseed.org/titiler/
+- Lonboard (reference for Arrow→deck.gl pattern): https://developmentseed.org/lonboard/
+- PMTiles: https://protomaps.com/docs/pmtiles
diff --git a/GPS_EXPLORER_DESIGN.md b/GPS_EXPLORER_DESIGN.md
new file mode 100644
index 0000000..22a0dd7
--- /dev/null
+++ b/GPS_EXPLORER_DESIGN.md
@@ -0,0 +1,230 @@
+# GPS Explorer: Design Document
+
+> **Status:** Proposal
+> **Date:** 2026-03-31
+> **Context:** Spun out from Bowser V2 GPS overlay work. The live GPS overlay in bowser revealed that raw GPS data needs significant preprocessing before it's useful alongside InSAR.
+
+---
+
+## Problem
+
+InSAR researchers need GPS ground truth to validate their displacement results. But the raw GPS data from public sources (UNR, JPL) is not directly comparable to InSAR because:
+
+1. **Different reference frames** — GPS displacements are relative to a tectonic plate model; InSAR is relative to a local reference point
+2. **Different time spans** — GPS stations may have 15+ years of data; an InSAR stack might cover 2 years
+3. **Noisy stations** — UNR processes everything automatically; many stations have gaps, jumps, or equipment changes that make them useless without cleanup
+4. **3D vs 1D** — GPS measures East/North/Up; InSAR measures a single Line-of-Sight component. Projection requires knowing the SAR viewing geometry.
+5. **No curation** — There's no easy way to browse, compare, and select "good" stations for a given area
+
+Currently, researchers write ad-hoc scripts to download GPS data, manually inspect timeseries in matplotlib, pick reference stations, filter bad ones, and export. This takes hours and is repeated for every new study area.
+
+---
+
+## Solution: GPS Explorer
+
+A lightweight web app for interactive GPS station exploration, curation, and export. The output is a clean GeoParquet file of processed GPS timeseries that can be loaded directly into bowser (or any other tool) as a point layer.
+
+### Core Workflow
+
+```
+1. Define AOI (bbox, draw polygon, or auto-detect from InSAR data)
+       ↓
+2. Fetch stations from UNR/JPL → show on map
+       ↓
+3. Browse: click stations to see timeseries, compare multiple
+       ↓
+4. Curate: mark bad stations, note issues (antenna change, etc.)
+       ↓
+5. Set parameters: reference station, time window, smoothing
+       ↓
+6. Process: subtract reference, project to LOS, filter, smooth
+       ↓
+7. Export: GeoParquet with processed timeseries → load in bowser
+```
+
+---
+
+## Where Should It Live?
+
+### Option A: Subcommand of `geepers` (`geepers explore`)
+
+**Pros:**
+- geepers already has the GPS data fetching, reference selection, and LOS projection logic
+- Natural home — geepers is the GPS library, this is the GPS UI
+- Keeps bowser focused on InSAR viewing
+- geepers users who don't use bowser still benefit
+
+**Cons:**
+- geepers is currently a pure Python library with no web dependencies
+- Adding FastAPI/React would significantly change geepers's dependency footprint
+- The web UI code doesn't really belong in a data library
+
+### Option B: Standalone repo (`gps-explorer`)
+
+**Pros:**
+- Clean separation of concerns
+- Can depend on both geepers (data) and borrow UI patterns from bowser (frontend)
+- Independent release cycle
+- Could be published as a standalone tool on PyPI
+
+**Cons:**
+- Yet another repo to maintain
+- Code sharing with bowser is copy-paste rather than import
+
+### Option C: Subcommand of `bowser` (`bowser gps-explore`)
+
+**Pros:**
+- Shares bowser's frontend build system, MapLibre, Plotly, etc.
+- Users who have bowser already have everything they need
+- The output GeoParquet integrates seamlessly with `bowser run --manifest`
+
+**Cons:**
+- Adds GPS data dependencies (geepers, network access) to bowser
+- Muddies bowser's purpose (is it a viewer or a data processing tool?)
+
+### Recommendation: **Option A** (`geepers explore`)
+
+geepers is the natural home. The dependency concern is manageable:
+- Make the web UI an optional extra: `pip install geepers[explorer]`
+- The explorer imports FastAPI/uvicorn/maplibre only when `geepers explore` is run
+- The core geepers library stays lightweight
+
+If `geepers` maintainers prefer to keep it pure-Python, then **Option B** (standalone) is the fallback. Option C (bowser subcommand) is the least preferred because it creates a circular dependency between the viewer and the data source.
+
+---
+
+## Features
+
+### Map View
+- MapLibre GL JS with satellite/OSM basemap toggle
+- Station markers colored by data quality or velocity
+- Click to select, shift+click to multi-select
+- Draw rectangle to select stations in region
+- Station labels (4-char codes) at appropriate zoom levels
+
+### Timeseries View
+- Plotly chart showing E/N/U or LOS-projected timeseries
+- Multi-station comparison (up to ~10 stations overlaid)
+- Trend lines with mm/yr rates
+- Date range selection (drag to zoom on time axis, or input fields)
+- Highlight jumps/gaps automatically (if geepers provides this)
+
+### Station Curation
+- Table or list view of all stations in AOI
+- Columns: name, lon, lat, start date, end date, # observations, data gaps, velocity
+- Sort/filter by any column
+- Checkbox to include/exclude stations
+- Notes field (free text) for documenting why a station was excluded
+- Automatic quality scoring: flag stations with >30% missing data, large jumps, etc.
+
+### Reference Station Selection
+- Manual: click a station to set as reference
+- Auto: use geepers `auto_select_reference` (picks the station with best long-term stability)
+- Visual feedback: show the effect of referencing (before/after toggle)
+
+### Processing Pipeline
+- **Time filter**: restrict to a date range (e.g., matching the InSAR epoch)
+- **Reference subtraction**: subtract reference station's timeseries from all others
+- **LOS projection**: project ENU to radar LOS using a provided LOS vector
+- **Smoothing**: optional median filter or running average
+- **Outlier removal**: optional sigma-clipping per station
+
+### Export
+- **GeoParquet**: primary output format, directly loadable as a bowser point layer
+  - Schema: `station_id, geometry, velocity, velocity_std, [date columns or long-form timeseries]`
+- **CSV**: for quick inspection in Excel/Google Sheets
+- **JSON**: station list with metadata (for programmatic use)
+- **bowser manifest snippet**: auto-generate the GPS layer config for bowser_manifest.json
+
+---
+
+## Technical Architecture
+
+### Backend (Python)
+```
+geepers/explorer/
+    __init__.py
+    app.py          # FastAPI app
+    routes.py       # Endpoints
+    processing.py   # Reference subtraction, LOS projection, smoothing
+```
+
+### Endpoints
+```
+GET  /stations?bbox=...&source=unr     → station list
+GET  /stations/{id}/timeseries         → raw ENU timeseries
+POST /process                          → apply reference, time filter, LOS, smoothing
+GET  /export?format=geoparquet&...     → download processed data
+GET  /auto_reference?bbox=...          → suggest best reference station
+```
+
+### Frontend (TypeScript/React)
+Reuse bowser's patterns:
+- MapLibre map with station markers
+- Plotly chart for timeseries
+- Dark/light theme
+- URL state for shareability
+
+### Dependencies (beyond geepers core)
+```
+fastapi
+uvicorn
+maplibre (frontend)
+plotly (frontend)
+react (frontend)
+```
+
+These would be in `geepers[explorer]` optional extra.
+
+---
+
+## Integration with Bowser
+
+The GPS Explorer outputs a GeoParquet file that bowser loads as a regular point layer. No special GPS code needed in bowser's viewer.
+
+### Workflow
+```bash
+# 1. Explore and curate GPS stations
+geepers explore --bbox -103,31,-102,32 --los '{"east": 0.477, "north": -0.449, "up": 0.755}'
+
+# 2. In the explorer UI: select stations, set reference, set time window, export
+#    → saves processed_gps.parquet
+
+# 3. Add to bowser manifest
+#    (or the explorer auto-generates a manifest snippet)
+
+# 4. View in bowser alongside InSAR
+bowser run --manifest my_manifest.json
+```
+
+### What Bowser Keeps
+The current live GPS overlay in bowser (`/gps` endpoints) stays as a **quick-look preview** — useful for seeing what stations exist in the area, but not for publication-quality comparison. The explorer is where the real work happens.
+
+---
+
+## MVP Scope (v0.1)
+
+For the first version, keep it minimal:
+
+1. **Fetch stations** for a bbox from UNR
+2. **Map + chart** with click-to-plot, multi-select
+3. **Time filter** (date range inputs)
+4. **Reference station** selection (manual click)
+5. **LOS projection** with constant vector
+6. **Export** as GeoParquet + CSV
+
+Skip for v0.1:
+- Automatic quality scoring
+- Smoothing/outlier removal
+- JPL source (start with UNR only)
+- GeoTIFF LOS (constant vector only)
+- Station notes/curation persistence
+
+---
+
+## Open Questions
+
+1. **Where to build it?** geepers subcommand vs standalone repo — depends on geepers maintainer preference
+2. **Frontend build system?** Vite (matching bowser) or simpler (e.g., bundled single HTML file with inline JS)?
+3. **State persistence?** Save curation state (included/excluded stations, reference, time window) to a JSON file so you can resume later?
+4. **Offline mode?** Cache downloaded GPS data locally so you don't need internet after first fetch?
diff --git a/docs/screenshots/v2_points_viridis.png b/docs/screenshots/v2_points_viridis.png
new file mode 100644
index 0000000..812cdef
Binary files /dev/null and b/docs/screenshots/v2_points_viridis.png differ
diff --git a/docs/screenshots/v2_raster_click.png b/docs/screenshots/v2_raster_click.png
new file mode 100644
index 0000000..394fcef
Binary files /dev/null and b/docs/screenshots/v2_raster_click.png differ
diff --git a/docs/screenshots/v2_timeseries.png b/docs/screenshots/v2_timeseries.png
new file mode 100644
index 0000000..d7ae5da
Binary files /dev/null and b/docs/screenshots/v2_timeseries.png differ
diff --git a/index.html b/index.html
index 33c0f99..e06b4f9 100644
--- a/index.html
+++ b/index.html
@@ -11,9 +11,6 @@
   <!-- font awesome-->
   <script src="https://kit.fontawesome.com/acadc5aab9.js" crossorigin="anonymous"></script>
 
-  <link rel="stylesheet" href="https://unpkg.com/leaflet@1.9.4/dist/leaflet.css"
-    integrity="sha256-p4NxAoJBhIIN+hmNHrzRCf9tD/miZyoHS5obTRR9BMY=" crossorigin="" />
-
   <title>Bowser</title>
 </head>
 
diff --git a/package-lock.json b/package-lock.json
index 77e02bf..48350c3 100644
--- a/package-lock.json
+++ b/package-lock.json
@@ -8,15 +8,28 @@
       "name": "bowser-js",
       "version": "0.0.0",
       "dependencies": {
+        "@deck.gl/core": "^9.2.11",
+        "@deck.gl/layers": "^9.2.11",
+        "@deck.gl/mapbox": "^9.2.11",
+        "@loaders.gl/arrow": "^4.3.4",
+        "@types/react-plotly.js": "^2.6.4",
+        "apache-arrow": "^21.1.0",
         "chart.js": "^4.4.1",
         "chartjs-adapter-date-fns": "^3.0.0",
         "leaflet": "^1.9.4",
+        "maplibre-gl": "^5.21.0",
+        "plotly.js-dist-min": "^3.4.0",
         "react": "^18.2.0",
         "react-chartjs-2": "^5.2.0",
         "react-dom": "^18.2.0",
-        "react-leaflet": "^4.2.1"
+        "react-leaflet": "^4.2.1",
+        "react-map-gl": "^8.1.0",
+        "react-plotly.js": "^2.6.0"
       },
       "devDependencies": {
+        "@testing-library/jest-dom": "^6.9.1",
+        "@testing-library/react": "^16.3.0",
+        "@testing-library/user-event": "^14.6.1",
         "@types/leaflet": "^1.9.8",
         "@types/react": "^18.2.66",
         "@types/react-dom": "^18.2.22",
@@ -26,10 +39,19 @@
         "eslint": "^8.57.0",
         "eslint-plugin-react-hooks": "^4.6.0",
         "eslint-plugin-react-refresh": "^0.4.6",
+        "jsdom": "^27.0.1",
         "typescript": "^5.2.2",
-        "vite": "^5.2.0"
+        "vite": "^5.2.0",
+        "vitest": "^3.2.4"
       }
     },
+    "node_modules/@adobe/css-tools": {
+      "version": "4.4.4",
+      "resolved": "https://registry.npmjs.org/@adobe/css-tools/-/css-tools-4.4.4.tgz",
+      "integrity": "sha512-Elp+iwUx5rN5+Y8xLt5/GRoG20WGoDCQ/1Fb+1LiGtvwbDavuSk0jhD/eZdckHAuzcDzccnkv+rEjyWfRx18gg==",
+      "dev": true,
+      "license": "MIT"
+    },
     "node_modules/@ampproject/remapping": {
       "version": "2.3.0",
       "resolved": "https://registry.npmjs.org/@ampproject/remapping/-/remapping-2.3.0.tgz",
@@ -44,6 +66,61 @@
         "node": ">=6.0.0"
       }
     },
+    "node_modules/@asamuzakjp/css-color": {
+      "version": "4.0.5",
+      "resolved": "https://registry.npmjs.org/@asamuzakjp/css-color/-/css-color-4.0.5.tgz",
+      "integrity": "sha512-lMrXidNhPGsDjytDy11Vwlb6OIGrT3CmLg3VWNFyWkLWtijKl7xjvForlh8vuj0SHGjgl4qZEQzUmYTeQA2JFQ==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@csstools/css-calc": "^2.1.4",
+        "@csstools/css-color-parser": "^3.1.0",
+        "@csstools/css-parser-algorithms": "^3.0.5",
+        "@csstools/css-tokenizer": "^3.0.4",
+        "lru-cache": "^11.2.1"
+      }
+    },
+    "node_modules/@asamuzakjp/css-color/node_modules/lru-cache": {
+      "version": "11.2.2",
+      "resolved": "https://registry.npmjs.org/lru-cache/-/lru-cache-11.2.2.tgz",
+      "integrity": "sha512-F9ODfyqML2coTIsQpSkRHnLSZMtkU8Q+mSfcaIyKwy58u+8k5nvAYeiNhsyMARvzNcXJ9QfWVrcPsC9e9rAxtg==",
+      "dev": true,
+      "license": "ISC",
+      "engines": {
+        "node": "20 || >=22"
+      }
+    },
+    "node_modules/@asamuzakjp/dom-selector": {
+      "version": "6.7.4",
+      "resolved": "https://registry.npmjs.org/@asamuzakjp/dom-selector/-/dom-selector-6.7.4.tgz",
+      "integrity": "sha512-buQDjkm+wDPXd6c13534URWZqbz0RP5PAhXZ+LIoa5LgwInT9HVJvGIJivg75vi8I13CxDGdTnz+aY5YUJlIAA==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@asamuzakjp/nwsapi": "^2.3.9",
+        "bidi-js": "^1.0.3",
+        "css-tree": "^3.1.0",
+        "is-potential-custom-element-name": "^1.0.1",
+        "lru-cache": "^11.2.2"
+      }
+    },
+    "node_modules/@asamuzakjp/dom-selector/node_modules/lru-cache": {
+      "version": "11.2.2",
+      "resolved": "https://registry.npmjs.org/lru-cache/-/lru-cache-11.2.2.tgz",
+      "integrity": "sha512-F9ODfyqML2coTIsQpSkRHnLSZMtkU8Q+mSfcaIyKwy58u+8k5nvAYeiNhsyMARvzNcXJ9QfWVrcPsC9e9rAxtg==",
+      "dev": true,
+      "license": "ISC",
+      "engines": {
+        "node": "20 || >=22"
+      }
+    },
+    "node_modules/@asamuzakjp/nwsapi": {
+      "version": "2.3.9",
+      "resolved": "https://registry.npmjs.org/@asamuzakjp/nwsapi/-/nwsapi-2.3.9.tgz",
+      "integrity": "sha512-n8GuYSrI9bF7FFZ/SjhwevlHc8xaVlb/7HmHelnc/PZXBD2ZR49NnN9sMMuDdEGPeeRQ5d0hqlSlEpgCX3Wl0Q==",
+      "dev": true,
+      "license": "MIT"
+    },
     "node_modules/@babel/code-frame": {
       "version": "7.27.1",
       "resolved": "https://registry.npmjs.org/@babel/code-frame/-/code-frame-7.27.1.tgz",
@@ -288,6 +365,16 @@
         "@babel/core": "^7.0.0-0"
       }
     },
+    "node_modules/@babel/runtime": {
+      "version": "7.28.4",
+      "resolved": "https://registry.npmjs.org/@babel/runtime/-/runtime-7.28.4.tgz",
+      "integrity": "sha512-Q/N6JNWvIvPnLDvjlE1OUBLPQHH6l3CltCEsHIujp45zQUSSh8K+gHnaEX45yAT1nyngnINhvWtzN+Nb9D8RAQ==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">=6.9.0"
+      }
+    },
     "node_modules/@babel/template": {
       "version": "7.27.2",
       "resolved": "https://registry.npmjs.org/@babel/template/-/template-7.27.2.tgz",
@@ -336,6 +423,217 @@
         "node": ">=6.9.0"
       }
     },
+    "node_modules/@choojs/findup": {
+      "version": "0.2.1",
+      "resolved": "https://registry.npmjs.org/@choojs/findup/-/findup-0.2.1.tgz",
+      "integrity": "sha512-YstAqNb0MCN8PjdLCDfRsBcGVRN41f3vgLvaI0IrIcBp4AqILRSS0DeWNGkicC+f/zRIPJLc+9RURVSepwvfBw==",
+      "license": "MIT",
+      "peer": true,
+      "dependencies": {
+        "commander": "^2.15.1"
+      },
+      "bin": {
+        "findup": "bin/findup.js"
+      }
+    },
+    "node_modules/@csstools/color-helpers": {
+      "version": "5.1.0",
+      "resolved": "https://registry.npmjs.org/@csstools/color-helpers/-/color-helpers-5.1.0.tgz",
+      "integrity": "sha512-S11EXWJyy0Mz5SYvRmY8nJYTFFd1LCNV+7cXyAgQtOOuzb4EsgfqDufL+9esx72/eLhsRdGZwaldu/h+E4t4BA==",
+      "dev": true,
+      "funding": [
+        {
+          "type": "github",
+          "url": "https://github.com/sponsors/csstools"
+        },
+        {
+          "type": "opencollective",
+          "url": "https://opencollective.com/csstools"
+        }
+      ],
+      "license": "MIT-0",
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/@csstools/css-calc": {
+      "version": "2.1.4",
+      "resolved": "https://registry.npmjs.org/@csstools/css-calc/-/css-calc-2.1.4.tgz",
+      "integrity": "sha512-3N8oaj+0juUw/1H3YwmDDJXCgTB1gKU6Hc/bB502u9zR0q2vd786XJH9QfrKIEgFlZmhZiq6epXl4rHqhzsIgQ==",
+      "dev": true,
+      "funding": [
+        {
+          "type": "github",
+          "url": "https://github.com/sponsors/csstools"
+        },
+        {
+          "type": "opencollective",
+          "url": "https://opencollective.com/csstools"
+        }
+      ],
+      "license": "MIT",
+      "engines": {
+        "node": ">=18"
+      },
+      "peerDependencies": {
+        "@csstools/css-parser-algorithms": "^3.0.5",
+        "@csstools/css-tokenizer": "^3.0.4"
+      }
+    },
+    "node_modules/@csstools/css-color-parser": {
+      "version": "3.1.0",
+      "resolved": "https://registry.npmjs.org/@csstools/css-color-parser/-/css-color-parser-3.1.0.tgz",
+      "integrity": "sha512-nbtKwh3a6xNVIp/VRuXV64yTKnb1IjTAEEh3irzS+HkKjAOYLTGNb9pmVNntZ8iVBHcWDA2Dof0QtPgFI1BaTA==",
+      "dev": true,
+      "funding": [
+        {
+          "type": "github",
+          "url": "https://github.com/sponsors/csstools"
+        },
+        {
+          "type": "opencollective",
+          "url": "https://opencollective.com/csstools"
+        }
+      ],
+      "license": "MIT",
+      "dependencies": {
+        "@csstools/color-helpers": "^5.1.0",
+        "@csstools/css-calc": "^2.1.4"
+      },
+      "engines": {
+        "node": ">=18"
+      },
+      "peerDependencies": {
+        "@csstools/css-parser-algorithms": "^3.0.5",
+        "@csstools/css-tokenizer": "^3.0.4"
+      }
+    },
+    "node_modules/@csstools/css-parser-algorithms": {
+      "version": "3.0.5",
+      "resolved": "https://registry.npmjs.org/@csstools/css-parser-algorithms/-/css-parser-algorithms-3.0.5.tgz",
+      "integrity": "sha512-DaDeUkXZKjdGhgYaHNJTV9pV7Y9B3b644jCLs9Upc3VeNGg6LWARAT6O+Q+/COo+2gg/bM5rhpMAtf70WqfBdQ==",
+      "dev": true,
+      "funding": [
+        {
+          "type": "github",
+          "url": "https://github.com/sponsors/csstools"
+        },
+        {
+          "type": "opencollective",
+          "url": "https://opencollective.com/csstools"
+        }
+      ],
+      "license": "MIT",
+      "engines": {
+        "node": ">=18"
+      },
+      "peerDependencies": {
+        "@csstools/css-tokenizer": "^3.0.4"
+      }
+    },
+    "node_modules/@csstools/css-syntax-patches-for-csstree": {
+      "version": "1.0.16",
+      "resolved": "https://registry.npmjs.org/@csstools/css-syntax-patches-for-csstree/-/css-syntax-patches-for-csstree-1.0.16.tgz",
+      "integrity": "sha512-2SpS4/UaWQaGpBINyG5ZuCHnUDeVByOhvbkARwfmnfxDvTaj80yOI1cD8Tw93ICV5Fx4fnyDKWQZI1CDtcWyUg==",
+      "dev": true,
+      "funding": [
+        {
+          "type": "github",
+          "url": "https://github.com/sponsors/csstools"
+        },
+        {
+          "type": "opencollective",
+          "url": "https://opencollective.com/csstools"
+        }
+      ],
+      "license": "MIT-0",
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/@csstools/css-tokenizer": {
+      "version": "3.0.4",
+      "resolved": "https://registry.npmjs.org/@csstools/css-tokenizer/-/css-tokenizer-3.0.4.tgz",
+      "integrity": "sha512-Vd/9EVDiu6PPJt9yAh6roZP6El1xHrdvIVGjyBsHR0RYwNHgL7FJPyIIW4fANJNG6FtyZfvlRPpFI4ZM/lubvw==",
+      "dev": true,
+      "funding": [
+        {
+          "type": "github",
+          "url": "https://github.com/sponsors/csstools"
+        },
+        {
+          "type": "opencollective",
+          "url": "https://opencollective.com/csstools"
+        }
+      ],
+      "license": "MIT",
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/@deck.gl/core": {
+      "version": "9.2.11",
+      "resolved": "https://registry.npmjs.org/@deck.gl/core/-/core-9.2.11.tgz",
+      "integrity": "sha512-lpdxXQuFSkd6ET7M6QxPI8QMhsLRY6vzLyk83sPGFb7JSb4OhrNHYt9sfIhcA/hxJW7bdBSMWWphf2GvQetVuA==",
+      "license": "MIT",
+      "dependencies": {
+        "@loaders.gl/core": "~4.3.4",
+        "@loaders.gl/images": "~4.3.4",
+        "@luma.gl/constants": "~9.2.6",
+        "@luma.gl/core": "~9.2.6",
+        "@luma.gl/engine": "~9.2.6",
+        "@luma.gl/shadertools": "~9.2.6",
+        "@luma.gl/webgl": "~9.2.6",
+        "@math.gl/core": "^4.1.0",
+        "@math.gl/sun": "^4.1.0",
+        "@math.gl/types": "^4.1.0",
+        "@math.gl/web-mercator": "^4.1.0",
+        "@probe.gl/env": "^4.1.1",
+        "@probe.gl/log": "^4.1.1",
+        "@probe.gl/stats": "^4.1.1",
+        "@types/offscreencanvas": "^2019.6.4",
+        "gl-matrix": "^3.0.0",
+        "mjolnir.js": "^3.0.0"
+      }
+    },
+    "node_modules/@deck.gl/layers": {
+      "version": "9.2.11",
+      "resolved": "https://registry.npmjs.org/@deck.gl/layers/-/layers-9.2.11.tgz",
+      "integrity": "sha512-2FSb0Qa6YR+Rg6GWhYOGTUug3vtZ4uKcFdnrdiJoVXGyibKJMScKZIsivY0r/yQQZsaBjYqty5QuVJvdtEHxSA==",
+      "license": "MIT",
+      "dependencies": {
+        "@loaders.gl/images": "~4.3.4",
+        "@loaders.gl/schema": "~4.3.4",
+        "@luma.gl/shadertools": "~9.2.6",
+        "@mapbox/tiny-sdf": "^2.0.5",
+        "@math.gl/core": "^4.1.0",
+        "@math.gl/polygon": "^4.1.0",
+        "@math.gl/web-mercator": "^4.1.0",
+        "earcut": "^2.2.4"
+      },
+      "peerDependencies": {
+        "@deck.gl/core": "~9.2.0",
+        "@loaders.gl/core": "~4.3.4",
+        "@luma.gl/core": "~9.2.6",
+        "@luma.gl/engine": "~9.2.6"
+      }
+    },
+    "node_modules/@deck.gl/mapbox": {
+      "version": "9.2.11",
+      "resolved": "https://registry.npmjs.org/@deck.gl/mapbox/-/mapbox-9.2.11.tgz",
+      "integrity": "sha512-5OaFZgjyA4Vq6WjHUdcEdl0Phi8dwj8hSCErej0NetW90mctdbxwMt0gSbqcvWBowwhyj2QAhH0P2FcITjKG/A==",
+      "license": "MIT",
+      "dependencies": {
+        "@luma.gl/constants": "~9.2.6",
+        "@math.gl/web-mercator": "^4.1.0"
+      },
+      "peerDependencies": {
+        "@deck.gl/core": "~9.2.0",
+        "@luma.gl/constants": "~9.2.6",
+        "@luma.gl/core": "~9.2.6",
+        "@math.gl/web-mercator": "^4.1.0"
+      }
+    },
     "node_modules/@esbuild/aix-ppc64": {
       "version": "0.21.5",
       "resolved": "https://registry.npmjs.org/@esbuild/aix-ppc64/-/aix-ppc64-0.21.5.tgz",
@@ -928,9 +1226,9 @@
       }
     },
     "node_modules/@jridgewell/sourcemap-codec": {
-      "version": "1.5.0",
-      "resolved": "https://registry.npmjs.org/@jridgewell/sourcemap-codec/-/sourcemap-codec-1.5.0.tgz",
-      "integrity": "sha512-gv3ZRaISU3fjPAgNsriBRqGWQL6quFx04YMPW/zD8XMLsU32mhCCbfbO6KZFLjvYpCZ8zyDEgqsgf+PwPaM7GQ==",
+      "version": "1.5.5",
+      "resolved": "https://registry.npmjs.org/@jridgewell/sourcemap-codec/-/sourcemap-codec-1.5.5.tgz",
+      "integrity": "sha512-cYQ9310grqxueWbl+WuIUIaiUaDcj7WOq5fVhEljNVgRfOUhY9fy2zTvfoqWsnebh8Sl70VScFbICvJnLKB0Og==",
       "dev": true,
       "license": "MIT"
     },
@@ -951,1373 +1249,5174 @@
       "integrity": "sha512-M5UknZPHRu3DEDWoipU6sE8PdkZ6Z/S+v4dD+Ke8IaNlpdSQah50lz1KtcFBa2vsdOnwbbnxJwVM4wty6udA5w==",
       "license": "MIT"
     },
-    "node_modules/@nodelib/fs.scandir": {
-      "version": "2.1.5",
-      "resolved": "https://registry.npmjs.org/@nodelib/fs.scandir/-/fs.scandir-2.1.5.tgz",
-      "integrity": "sha512-vq24Bq3ym5HEQm2NKCr3yXDwjc7vTsEThRDnkp2DK9p1uqLR+DHurm/NOTo0KG7HYHU7eppKZj3MyqYuMBf62g==",
-      "dev": true,
+    "node_modules/@loaders.gl/arrow": {
+      "version": "4.3.4",
+      "resolved": "https://registry.npmjs.org/@loaders.gl/arrow/-/arrow-4.3.4.tgz",
+      "integrity": "sha512-TDEEwsW50/7KTf/Ld3S8+pTqULxznZsoKBmul6cNNDe7ZlOsxeURtJ31FE2V8R/VI0RwkCiJetePWHJ9RCaRww==",
       "license": "MIT",
       "dependencies": {
-        "@nodelib/fs.stat": "2.0.5",
-        "run-parallel": "^1.1.9"
+        "@loaders.gl/gis": "4.3.4",
+        "@loaders.gl/loader-utils": "4.3.4",
+        "@loaders.gl/schema": "4.3.4",
+        "@loaders.gl/wkt": "4.3.4",
+        "@loaders.gl/worker-utils": "4.3.4",
+        "@math.gl/polygon": "^4.1.0",
+        "apache-arrow": ">= 15.0.0"
       },
-      "engines": {
-        "node": ">= 8"
+      "peerDependencies": {
+        "@loaders.gl/core": "^4.3.0"
       }
     },
-    "node_modules/@nodelib/fs.stat": {
-      "version": "2.0.5",
-      "resolved": "https://registry.npmjs.org/@nodelib/fs.stat/-/fs.stat-2.0.5.tgz",
-      "integrity": "sha512-RkhPPp2zrqDAQA/2jNhnztcPAlv64XdhIp7a7454A5ovI7Bukxgt7MX7udwAu3zg1DcpPU0rz3VV1SeaqvY4+A==",
-      "dev": true,
+    "node_modules/@loaders.gl/core": {
+      "version": "4.3.4",
+      "resolved": "https://registry.npmjs.org/@loaders.gl/core/-/core-4.3.4.tgz",
+      "integrity": "sha512-cG0C5fMZ1jyW6WCsf4LoHGvaIAJCEVA/ioqKoYRwoSfXkOf+17KupK1OUQyUCw5XoRn+oWA1FulJQOYlXnb9Gw==",
       "license": "MIT",
-      "engines": {
-        "node": ">= 8"
+      "dependencies": {
+        "@loaders.gl/loader-utils": "4.3.4",
+        "@loaders.gl/schema": "4.3.4",
+        "@loaders.gl/worker-utils": "4.3.4",
+        "@probe.gl/log": "^4.0.2"
       }
     },
-    "node_modules/@nodelib/fs.walk": {
-      "version": "1.2.8",
-      "resolved": "https://registry.npmjs.org/@nodelib/fs.walk/-/fs.walk-1.2.8.tgz",
-      "integrity": "sha512-oGB+UxlgWcgQkgwo8GcEGwemoTFt3FIO9ababBmaGwXIoBKZ+GTy0pP185beGg7Llih/NSHSV2XAs1lnznocSg==",
-      "dev": true,
+    "node_modules/@loaders.gl/gis": {
+      "version": "4.3.4",
+      "resolved": "https://registry.npmjs.org/@loaders.gl/gis/-/gis-4.3.4.tgz",
+      "integrity": "sha512-8xub38lSWW7+ZXWuUcggk7agRHJUy6RdipLNKZ90eE0ZzLNGDstGD1qiBwkvqH0AkG+uz4B7Kkiptyl7w2Oa6g==",
       "license": "MIT",
       "dependencies": {
-        "@nodelib/fs.scandir": "2.1.5",
-        "fastq": "^1.6.0"
+        "@loaders.gl/loader-utils": "4.3.4",
+        "@loaders.gl/schema": "4.3.4",
+        "@mapbox/vector-tile": "^1.3.1",
+        "@math.gl/polygon": "^4.1.0",
+        "pbf": "^3.2.1"
       },
-      "engines": {
-        "node": ">= 8"
+      "peerDependencies": {
+        "@loaders.gl/core": "^4.3.0"
       }
     },
-    "node_modules/@react-leaflet/core": {
-      "version": "2.1.0",
-      "resolved": "https://registry.npmjs.org/@react-leaflet/core/-/core-2.1.0.tgz",
-      "integrity": "sha512-Qk7Pfu8BSarKGqILj4x7bCSZ1pjuAPZ+qmRwH5S7mDS91VSbVVsJSrW4qA+GPrro8t69gFYVMWb1Zc4yFmPiVg==",
-      "license": "Hippocratic-2.1",
-      "peerDependencies": {
-        "leaflet": "^1.9.0",
-        "react": "^18.0.0",
-        "react-dom": "^18.0.0"
+    "node_modules/@loaders.gl/gis/node_modules/@mapbox/point-geometry": {
+      "version": "0.1.0",
+      "resolved": "https://registry.npmjs.org/@mapbox/point-geometry/-/point-geometry-0.1.0.tgz",
+      "integrity": "sha512-6j56HdLTwWGO0fJPlrZtdU/B13q8Uwmo18Ck2GnGgN9PCFyKTZ3UbXeEdRFh18i9XQ92eH2VdtpJHpBD3aripQ==",
+      "license": "ISC"
+    },
+    "node_modules/@loaders.gl/gis/node_modules/@mapbox/vector-tile": {
+      "version": "1.3.1",
+      "resolved": "https://registry.npmjs.org/@mapbox/vector-tile/-/vector-tile-1.3.1.tgz",
+      "integrity": "sha512-MCEddb8u44/xfQ3oD+Srl/tNcQoqTw3goGk2oLsrFxOTc3dUp+kAnby3PvAeeBYSMSjSPD1nd1AJA6W49WnoUw==",
+      "license": "BSD-3-Clause",
+      "dependencies": {
+        "@mapbox/point-geometry": "~0.1.0"
       }
     },
-    "node_modules/@rolldown/pluginutils": {
-      "version": "1.0.0-beta.9",
-      "resolved": "https://registry.npmjs.org/@rolldown/pluginutils/-/pluginutils-1.0.0-beta.9.tgz",
-      "integrity": "sha512-e9MeMtVWo186sgvFFJOPGy7/d2j2mZhLJIdVW0C/xDluuOvymEATqz6zKsP0ZmXGzQtqlyjz5sC1sYQUoJG98w==",
-      "dev": true,
-      "license": "MIT"
+    "node_modules/@loaders.gl/gis/node_modules/pbf": {
+      "version": "3.3.0",
+      "resolved": "https://registry.npmjs.org/pbf/-/pbf-3.3.0.tgz",
+      "integrity": "sha512-XDF38WCH3z5OV/OVa8GKUNtLAyneuzbCisx7QUCF8Q6Nutx0WnJrQe5O+kOtBlLfRNUws98Y58Lblp+NJG5T4Q==",
+      "license": "BSD-3-Clause",
+      "dependencies": {
+        "ieee754": "^1.1.12",
+        "resolve-protobuf-schema": "^2.1.0"
+      },
+      "bin": {
+        "pbf": "bin/pbf"
+      }
     },
-    "node_modules/@rollup/rollup-android-arm-eabi": {
-      "version": "4.41.1",
-      "resolved": "https://registry.npmjs.org/@rollup/rollup-android-arm-eabi/-/rollup-android-arm-eabi-4.41.1.tgz",
-      "integrity": "sha512-NELNvyEWZ6R9QMkiytB4/L4zSEaBC03KIXEghptLGLZWJ6VPrL63ooZQCOnlx36aQPGhzuOMwDerC1Eb2VmrLw==",
-      "cpu": [
-        "arm"
-      ],
-      "dev": true,
+    "node_modules/@loaders.gl/images": {
+      "version": "4.3.4",
+      "resolved": "https://registry.npmjs.org/@loaders.gl/images/-/images-4.3.4.tgz",
+      "integrity": "sha512-qgc33BaNsqN9cWa/xvcGvQ50wGDONgQQdzHCKDDKhV2w/uptZoR5iofJfuG8UUV2vUMMd82Uk9zbopRx2rS4Ag==",
       "license": "MIT",
-      "optional": true,
-      "os": [
-        "android"
-      ]
+      "dependencies": {
+        "@loaders.gl/loader-utils": "4.3.4"
+      },
+      "peerDependencies": {
+        "@loaders.gl/core": "^4.3.0"
+      }
     },
-    "node_modules/@rollup/rollup-android-arm64": {
-      "version": "4.41.1",
-      "resolved": "https://registry.npmjs.org/@rollup/rollup-android-arm64/-/rollup-android-arm64-4.41.1.tgz",
-      "integrity": "sha512-DXdQe1BJ6TK47ukAoZLehRHhfKnKg9BjnQYUu9gzhI8Mwa1d2fzxA1aw2JixHVl403bwp1+/o/NhhHtxWJBgEA==",
-      "cpu": [
-        "arm64"
-      ],
-      "dev": true,
+    "node_modules/@loaders.gl/loader-utils": {
+      "version": "4.3.4",
+      "resolved": "https://registry.npmjs.org/@loaders.gl/loader-utils/-/loader-utils-4.3.4.tgz",
+      "integrity": "sha512-tjMZvlKQSaMl2qmYTAxg+ySR6zd6hQn5n3XaU8+Ehp90TD3WzxvDKOMNDqOa72fFmIV+KgPhcmIJTpq4lAdC4Q==",
       "license": "MIT",
-      "optional": true,
-      "os": [
-        "android"
-      ]
+      "dependencies": {
+        "@loaders.gl/schema": "4.3.4",
+        "@loaders.gl/worker-utils": "4.3.4",
+        "@probe.gl/log": "^4.0.2",
+        "@probe.gl/stats": "^4.0.2"
+      },
+      "peerDependencies": {
+        "@loaders.gl/core": "^4.3.0"
+      }
     },
-    "node_modules/@rollup/rollup-darwin-arm64": {
-      "version": "4.41.1",
-      "resolved": "https://registry.npmjs.org/@rollup/rollup-darwin-arm64/-/rollup-darwin-arm64-4.41.1.tgz",
-      "integrity": "sha512-5afxvwszzdulsU2w8JKWwY8/sJOLPzf0e1bFuvcW5h9zsEg+RQAojdW0ux2zyYAz7R8HvvzKCjLNJhVq965U7w==",
-      "cpu": [
-        "arm64"
-      ],
-      "dev": true,
+    "node_modules/@loaders.gl/schema": {
+      "version": "4.3.4",
+      "resolved": "https://registry.npmjs.org/@loaders.gl/schema/-/schema-4.3.4.tgz",
+      "integrity": "sha512-1YTYoatgzr/6JTxqBLwDiD3AVGwQZheYiQwAimWdRBVB0JAzych7s1yBuE0CVEzj4JDPKOzVAz8KnU1TiBvJGw==",
       "license": "MIT",
-      "optional": true,
-      "os": [
-        "darwin"
-      ]
+      "dependencies": {
+        "@types/geojson": "^7946.0.7"
+      },
+      "peerDependencies": {
+        "@loaders.gl/core": "^4.3.0"
+      }
     },
-    "node_modules/@rollup/rollup-darwin-x64": {
-      "version": "4.41.1",
-      "resolved": "https://registry.npmjs.org/@rollup/rollup-darwin-x64/-/rollup-darwin-x64-4.41.1.tgz",
-      "integrity": "sha512-egpJACny8QOdHNNMZKf8xY0Is6gIMz+tuqXlusxquWu3F833DcMwmGM7WlvCO9sB3OsPjdC4U0wHw5FabzCGZg==",
-      "cpu": [
-        "x64"
-      ],
-      "dev": true,
+    "node_modules/@loaders.gl/wkt": {
+      "version": "4.3.4",
+      "resolved": "https://registry.npmjs.org/@loaders.gl/wkt/-/wkt-4.3.4.tgz",
+      "integrity": "sha512-9ahN3KPSrmLvYU1cn6WkPy4z9CRb9oUzzmojIRhZhZQumHiTwoE4FI/Xffl6ZZEb078JkSzlNX6mEMzChR4Fxg==",
       "license": "MIT",
-      "optional": true,
-      "os": [
-        "darwin"
-      ]
-    },
-    "node_modules/@rollup/rollup-freebsd-arm64": {
-      "version": "4.41.1",
-      "resolved": "https://registry.npmjs.org/@rollup/rollup-freebsd-arm64/-/rollup-freebsd-arm64-4.41.1.tgz",
-      "integrity": "sha512-DBVMZH5vbjgRk3r0OzgjS38z+atlupJ7xfKIDJdZZL6sM6wjfDNo64aowcLPKIx7LMQi8vybB56uh1Ftck/Atg==",
+      "dependencies": {
+        "@loaders.gl/gis": "4.3.4",
+        "@loaders.gl/loader-utils": "4.3.4",
+        "@loaders.gl/schema": "4.3.4"
+      },
+      "peerDependencies": {
+        "@loaders.gl/core": "^4.3.0"
+      }
+    },
+    "node_modules/@loaders.gl/worker-utils": {
+      "version": "4.3.4",
+      "resolved": "https://registry.npmjs.org/@loaders.gl/worker-utils/-/worker-utils-4.3.4.tgz",
+      "integrity": "sha512-EbsszrASgT85GH3B7jkx7YXfQyIYo/rlobwMx6V3ewETapPUwdSAInv+89flnk5n2eu2Lpdeh+2zS6PvqbL2RA==",
+      "license": "MIT",
+      "peerDependencies": {
+        "@loaders.gl/core": "^4.3.0"
+      }
+    },
+    "node_modules/@luma.gl/constants": {
+      "version": "9.2.6",
+      "resolved": "https://registry.npmjs.org/@luma.gl/constants/-/constants-9.2.6.tgz",
+      "integrity": "sha512-rvFFrJuSm5JIWbDHFuR4Q2s4eudO3Ggsv0TsGKn9eqvO7bBiPm/ANugHredvh3KviEyYuMZZxtfJvBdr3kzldg==",
+      "license": "MIT"
+    },
+    "node_modules/@luma.gl/core": {
+      "version": "9.2.6",
+      "resolved": "https://registry.npmjs.org/@luma.gl/core/-/core-9.2.6.tgz",
+      "integrity": "sha512-d8KcH8ZZcjDAodSN/G2nueA9YE2X8kMz7Q0OxDGpCww6to1MZXM3Ydate/Jqsb5DDKVgUF6yD6RL8P5jOki9Yw==",
+      "license": "MIT",
+      "dependencies": {
+        "@math.gl/types": "^4.1.0",
+        "@probe.gl/env": "^4.0.8",
+        "@probe.gl/log": "^4.0.8",
+        "@probe.gl/stats": "^4.0.8",
+        "@types/offscreencanvas": "^2019.6.4"
+      }
+    },
+    "node_modules/@luma.gl/engine": {
+      "version": "9.2.6",
+      "resolved": "https://registry.npmjs.org/@luma.gl/engine/-/engine-9.2.6.tgz",
+      "integrity": "sha512-1AEDs2AUqOWh7Wl4onOhXmQF+Rz1zNdPXF+Kxm4aWl92RQ42Sh2CmTvRt2BJku83VQ91KFIEm/v3qd3Urzf+Uw==",
+      "license": "MIT",
+      "dependencies": {
+        "@math.gl/core": "^4.1.0",
+        "@math.gl/types": "^4.1.0",
+        "@probe.gl/log": "^4.0.8",
+        "@probe.gl/stats": "^4.0.8"
+      },
+      "peerDependencies": {
+        "@luma.gl/core": "~9.2.0",
+        "@luma.gl/shadertools": "~9.2.0"
+      }
+    },
+    "node_modules/@luma.gl/shadertools": {
+      "version": "9.2.6",
+      "resolved": "https://registry.npmjs.org/@luma.gl/shadertools/-/shadertools-9.2.6.tgz",
+      "integrity": "sha512-4+uUbynqPUra9d/z1nQChyHmhLgmKfSMjS7kOwLB6exSnhKnpHL3+Hu9fv55qyaX50nGH3oHawhGtJ6RRvu65w==",
+      "license": "MIT",
+      "dependencies": {
+        "@math.gl/core": "^4.1.0",
+        "@math.gl/types": "^4.1.0",
+        "wgsl_reflect": "^1.2.0"
+      },
+      "peerDependencies": {
+        "@luma.gl/core": "~9.2.0"
+      }
+    },
+    "node_modules/@luma.gl/webgl": {
+      "version": "9.2.6",
+      "resolved": "https://registry.npmjs.org/@luma.gl/webgl/-/webgl-9.2.6.tgz",
+      "integrity": "sha512-NGBTdxJMk7j8Ygr1zuTyAvr1Tw+EpupMIQo7RelFjEsZXg6pujFqiDMM+rgxex8voCeuhWBJc7Rs+MoSqd46UQ==",
+      "license": "MIT",
+      "dependencies": {
+        "@luma.gl/constants": "9.2.6",
+        "@math.gl/types": "^4.1.0",
+        "@probe.gl/env": "^4.0.8"
+      },
+      "peerDependencies": {
+        "@luma.gl/core": "~9.2.0"
+      }
+    },
+    "node_modules/@mapbox/geojson-rewind": {
+      "version": "0.5.2",
+      "resolved": "https://registry.npmjs.org/@mapbox/geojson-rewind/-/geojson-rewind-0.5.2.tgz",
+      "integrity": "sha512-tJaT+RbYGJYStt7wI3cq4Nl4SXxG8W7JDG5DMJu97V25RnbNg3QtQtf+KD+VLjNpWKYsRvXDNmNrBgEETr1ifA==",
+      "license": "ISC",
+      "peer": true,
+      "dependencies": {
+        "get-stream": "^6.0.1",
+        "minimist": "^1.2.6"
+      },
+      "bin": {
+        "geojson-rewind": "geojson-rewind"
+      }
+    },
+    "node_modules/@mapbox/geojson-types": {
+      "version": "1.0.2",
+      "resolved": "https://registry.npmjs.org/@mapbox/geojson-types/-/geojson-types-1.0.2.tgz",
+      "integrity": "sha512-e9EBqHHv3EORHrSfbR9DqecPNn+AmuAoQxV6aL8Xu30bJMJR1o8PZLZzpk1Wq7/NfCbuhmakHTPYRhoqLsXRnw==",
+      "license": "ISC",
+      "peer": true
+    },
+    "node_modules/@mapbox/jsonlint-lines-primitives": {
+      "version": "2.0.2",
+      "resolved": "https://registry.npmjs.org/@mapbox/jsonlint-lines-primitives/-/jsonlint-lines-primitives-2.0.2.tgz",
+      "integrity": "sha512-rY0o9A5ECsTQRVhv7tL/OyDpGAoUB4tTvLiW1DSzQGq4bvTPhNw1VpSNjDJc5GFZ2XuyOtSWSVN05qOtcD71qQ==",
+      "engines": {
+        "node": ">= 0.6"
+      }
+    },
+    "node_modules/@mapbox/mapbox-gl-supported": {
+      "version": "3.0.0",
+      "resolved": "https://registry.npmjs.org/@mapbox/mapbox-gl-supported/-/mapbox-gl-supported-3.0.0.tgz",
+      "integrity": "sha512-2XghOwu16ZwPJLOFVuIOaLbN0iKMn867evzXFyf0P22dqugezfJwLmdanAgU25ITvz1TvOfVP4jsDImlDJzcWg==",
+      "license": "BSD-3-Clause",
+      "optional": true,
+      "peer": true
+    },
+    "node_modules/@mapbox/point-geometry": {
+      "version": "1.1.0",
+      "resolved": "https://registry.npmjs.org/@mapbox/point-geometry/-/point-geometry-1.1.0.tgz",
+      "integrity": "sha512-YGcBz1cg4ATXDCM/71L9xveh4dynfGmcLDqufR+nQQy3fKwsAZsWd/x4621/6uJaeB9mwOHE6hPeDgXz9uViUQ==",
+      "license": "ISC"
+    },
+    "node_modules/@mapbox/tiny-sdf": {
+      "version": "2.0.7",
+      "resolved": "https://registry.npmjs.org/@mapbox/tiny-sdf/-/tiny-sdf-2.0.7.tgz",
+      "integrity": "sha512-25gQLQMcpivjOSA40g3gO6qgiFPDpWRoMfd+G/GoppPIeP6JDaMMkMrEJnMZhKyyS6iKwVt5YKu02vCUyJM3Ug==",
+      "license": "BSD-2-Clause"
+    },
+    "node_modules/@mapbox/unitbezier": {
+      "version": "0.0.1",
+      "resolved": "https://registry.npmjs.org/@mapbox/unitbezier/-/unitbezier-0.0.1.tgz",
+      "integrity": "sha512-nMkuDXFv60aBr9soUG5q+GvZYL+2KZHVvsqFCzqnkGEf46U2fvmytHaEVc1/YZbiLn8X+eR3QzX1+dwDO1lxlw==",
+      "license": "BSD-2-Clause"
+    },
+    "node_modules/@mapbox/vector-tile": {
+      "version": "2.0.4",
+      "resolved": "https://registry.npmjs.org/@mapbox/vector-tile/-/vector-tile-2.0.4.tgz",
+      "integrity": "sha512-AkOLcbgGTdXScosBWwmmD7cDlvOjkg/DetGva26pIRiZPdeJYjYKarIlb4uxVzi6bwHO6EWH82eZ5Nuv4T5DUg==",
+      "license": "BSD-3-Clause",
+      "dependencies": {
+        "@mapbox/point-geometry": "~1.1.0",
+        "@types/geojson": "^7946.0.16",
+        "pbf": "^4.0.1"
+      }
+    },
+    "node_modules/@mapbox/whoots-js": {
+      "version": "3.1.0",
+      "resolved": "https://registry.npmjs.org/@mapbox/whoots-js/-/whoots-js-3.1.0.tgz",
+      "integrity": "sha512-Es6WcD0nO5l+2BOQS4uLfNPYQaNDfbot3X1XUoloz+x0mPDS3eeORZJl06HXjwBG1fOGwCRnzK88LMdxKRrd6Q==",
+      "license": "ISC",
+      "engines": {
+        "node": ">=6.0.0"
+      }
+    },
+    "node_modules/@maplibre/geojson-vt": {
+      "version": "6.0.4",
+      "resolved": "https://registry.npmjs.org/@maplibre/geojson-vt/-/geojson-vt-6.0.4.tgz",
+      "integrity": "sha512-HYv3POhMRCdhP3UPPATM/hfcy6/WuVIf5FKboH8u/ZuFMTnAIcSVlq5nfOqroLokd925w2QtE7YwquFOIacwVQ==",
+      "license": "ISC",
+      "dependencies": {
+        "kdbush": "^4.0.2"
+      }
+    },
+    "node_modules/@maplibre/maplibre-gl-style-spec": {
+      "version": "24.7.0",
+      "resolved": "https://registry.npmjs.org/@maplibre/maplibre-gl-style-spec/-/maplibre-gl-style-spec-24.7.0.tgz",
+      "integrity": "sha512-Ed7rcKYU5iELfablg9Mj+TVCsXsPBgdMyXPRAxb2v7oWg9YJnpQdZ5msDs1LESu/mtXy3Z48Vdppv2t/x5kAhw==",
+      "license": "ISC",
+      "dependencies": {
+        "@mapbox/jsonlint-lines-primitives": "~2.0.2",
+        "@mapbox/unitbezier": "^0.0.1",
+        "json-stringify-pretty-compact": "^4.0.0",
+        "minimist": "^1.2.8",
+        "quickselect": "^3.0.0",
+        "rw": "^1.3.3",
+        "tinyqueue": "^3.0.0"
+      },
+      "bin": {
+        "gl-style-format": "dist/gl-style-format.mjs",
+        "gl-style-migrate": "dist/gl-style-migrate.mjs",
+        "gl-style-validate": "dist/gl-style-validate.mjs"
+      }
+    },
+    "node_modules/@maplibre/mlt": {
+      "version": "1.1.8",
+      "resolved": "https://registry.npmjs.org/@maplibre/mlt/-/mlt-1.1.8.tgz",
+      "integrity": "sha512-8vtfYGidr1rNkv5IwIoU2lfe3Oy+Wa8HluzQYcQi9cveU9K3pweAal/poQj4GJ0K/EW4bTQp2wVAs09g2yDRZg==",
+      "license": "(MIT OR Apache-2.0)",
+      "dependencies": {
+        "@mapbox/point-geometry": "^1.1.0"
+      }
+    },
+    "node_modules/@maplibre/vt-pbf": {
+      "version": "4.3.0",
+      "resolved": "https://registry.npmjs.org/@maplibre/vt-pbf/-/vt-pbf-4.3.0.tgz",
+      "integrity": "sha512-jIvp8F5hQCcreqOOpEt42TJMUlsrEcpf/kI1T2v85YrQRV6PPXUcEXUg5karKtH6oh47XJZ4kHu56pUkOuqA7w==",
+      "license": "MIT",
+      "dependencies": {
+        "@mapbox/point-geometry": "^1.1.0",
+        "@mapbox/vector-tile": "^2.0.4",
+        "@maplibre/geojson-vt": "^5.0.4",
+        "@types/geojson": "^7946.0.16",
+        "@types/supercluster": "^7.1.3",
+        "pbf": "^4.0.1",
+        "supercluster": "^8.0.1"
+      }
+    },
+    "node_modules/@maplibre/vt-pbf/node_modules/@maplibre/geojson-vt": {
+      "version": "5.0.4",
+      "resolved": "https://registry.npmjs.org/@maplibre/geojson-vt/-/geojson-vt-5.0.4.tgz",
+      "integrity": "sha512-KGg9sma45S+stfH9vPCJk1J0lSDLWZgCT9Y8u8qWZJyjFlP8MNP1WGTxIMYJZjDvVT3PDn05kN1C95Sut1HpgQ==",
+      "license": "ISC"
+    },
+    "node_modules/@math.gl/core": {
+      "version": "4.1.0",
+      "resolved": "https://registry.npmjs.org/@math.gl/core/-/core-4.1.0.tgz",
+      "integrity": "sha512-FrdHBCVG3QdrworwrUSzXIaK+/9OCRLscxI2OUy6sLOHyHgBMyfnEGs99/m3KNvs+95BsnQLWklVfpKfQzfwKA==",
+      "license": "MIT",
+      "dependencies": {
+        "@math.gl/types": "4.1.0"
+      }
+    },
+    "node_modules/@math.gl/polygon": {
+      "version": "4.1.0",
+      "resolved": "https://registry.npmjs.org/@math.gl/polygon/-/polygon-4.1.0.tgz",
+      "integrity": "sha512-YA/9PzaCRHbIP5/0E9uTYrqe+jsYTQoqoDWhf6/b0Ixz8bPZBaGDEafLg3z7ffBomZLacUty9U3TlPjqMtzPjA==",
+      "license": "MIT",
+      "dependencies": {
+        "@math.gl/core": "4.1.0"
+      }
+    },
+    "node_modules/@math.gl/sun": {
+      "version": "4.1.0",
+      "resolved": "https://registry.npmjs.org/@math.gl/sun/-/sun-4.1.0.tgz",
+      "integrity": "sha512-i3q6OCBLSZ5wgZVhXg+X7gsjY/TUtuFW/2KBiq/U1ypLso3S4sEykoU/MGjxUv1xiiGtr+v8TeMbO1OBIh/HmA==",
+      "license": "MIT"
+    },
+    "node_modules/@math.gl/types": {
+      "version": "4.1.0",
+      "resolved": "https://registry.npmjs.org/@math.gl/types/-/types-4.1.0.tgz",
+      "integrity": "sha512-clYZdHcmRvMzVK5fjeDkQlHUzXQSNdZ7s4xOqC3nJPgz4C/TZkUecTo9YS4PruZqtDda/ag4erndP0MIn40dGA==",
+      "license": "MIT"
+    },
+    "node_modules/@math.gl/web-mercator": {
+      "version": "4.1.0",
+      "resolved": "https://registry.npmjs.org/@math.gl/web-mercator/-/web-mercator-4.1.0.tgz",
+      "integrity": "sha512-HZo3vO5GCMkXJThxRJ5/QYUYRr3XumfT8CzNNCwoJfinxy5NtKUd7dusNTXn7yJ40UoB8FMIwkVwNlqaiRZZAw==",
+      "license": "MIT",
+      "dependencies": {
+        "@math.gl/core": "4.1.0"
+      }
+    },
+    "node_modules/@nodelib/fs.scandir": {
+      "version": "2.1.5",
+      "resolved": "https://registry.npmjs.org/@nodelib/fs.scandir/-/fs.scandir-2.1.5.tgz",
+      "integrity": "sha512-vq24Bq3ym5HEQm2NKCr3yXDwjc7vTsEThRDnkp2DK9p1uqLR+DHurm/NOTo0KG7HYHU7eppKZj3MyqYuMBf62g==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@nodelib/fs.stat": "2.0.5",
+        "run-parallel": "^1.1.9"
+      },
+      "engines": {
+        "node": ">= 8"
+      }
+    },
+    "node_modules/@nodelib/fs.stat": {
+      "version": "2.0.5",
+      "resolved": "https://registry.npmjs.org/@nodelib/fs.stat/-/fs.stat-2.0.5.tgz",
+      "integrity": "sha512-RkhPPp2zrqDAQA/2jNhnztcPAlv64XdhIp7a7454A5ovI7Bukxgt7MX7udwAu3zg1DcpPU0rz3VV1SeaqvY4+A==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">= 8"
+      }
+    },
+    "node_modules/@nodelib/fs.walk": {
+      "version": "1.2.8",
+      "resolved": "https://registry.npmjs.org/@nodelib/fs.walk/-/fs.walk-1.2.8.tgz",
+      "integrity": "sha512-oGB+UxlgWcgQkgwo8GcEGwemoTFt3FIO9ababBmaGwXIoBKZ+GTy0pP185beGg7Llih/NSHSV2XAs1lnznocSg==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@nodelib/fs.scandir": "2.1.5",
+        "fastq": "^1.6.0"
+      },
+      "engines": {
+        "node": ">= 8"
+      }
+    },
+    "node_modules/@plotly/d3": {
+      "version": "3.8.2",
+      "resolved": "https://registry.npmjs.org/@plotly/d3/-/d3-3.8.2.tgz",
+      "integrity": "sha512-wvsNmh1GYjyJfyEBPKJLTMzgf2c2bEbSIL50lmqVUi+o1NHaLPi1Lb4v7VxXXJn043BhNyrxUrWI85Q+zmjOVA==",
+      "license": "BSD-3-Clause",
+      "peer": true
+    },
+    "node_modules/@plotly/d3-sankey": {
+      "version": "0.7.2",
+      "resolved": "https://registry.npmjs.org/@plotly/d3-sankey/-/d3-sankey-0.7.2.tgz",
+      "integrity": "sha512-2jdVos1N3mMp3QW0k2q1ph7Gd6j5PY1YihBrwpkFnKqO+cqtZq3AdEYUeSGXMeLsBDQYiqTVcihYfk8vr5tqhw==",
+      "license": "BSD-3-Clause",
+      "peer": true,
+      "dependencies": {
+        "d3-array": "1",
+        "d3-collection": "1",
+        "d3-shape": "^1.2.0"
+      }
+    },
+    "node_modules/@plotly/d3-sankey-circular": {
+      "version": "0.33.1",
+      "resolved": "https://registry.npmjs.org/@plotly/d3-sankey-circular/-/d3-sankey-circular-0.33.1.tgz",
+      "integrity": "sha512-FgBV1HEvCr3DV7RHhDsPXyryknucxtfnLwPtCKKxdolKyTFYoLX/ibEfX39iFYIL7DYbVeRtP43dbFcrHNE+KQ==",
+      "license": "MIT",
+      "peer": true,
+      "dependencies": {
+        "d3-array": "^1.2.1",
+        "d3-collection": "^1.0.4",
+        "d3-shape": "^1.2.0",
+        "elementary-circuits-directed-graph": "^1.0.4"
+      }
+    },
+    "node_modules/@plotly/mapbox-gl": {
+      "version": "1.13.4",
+      "resolved": "https://registry.npmjs.org/@plotly/mapbox-gl/-/mapbox-gl-1.13.4.tgz",
+      "integrity": "sha512-sR3/Pe5LqT/fhYgp4rT4aSFf1rTsxMbGiH6Hojc7PH36ny5Bn17iVFUjpzycafETURuFbLZUfjODO8LvSI+5zQ==",
+      "license": "SEE LICENSE IN LICENSE.txt",
+      "peer": true,
+      "dependencies": {
+        "@mapbox/geojson-rewind": "^0.5.2",
+        "@mapbox/geojson-types": "^1.0.2",
+        "@mapbox/jsonlint-lines-primitives": "^2.0.2",
+        "@mapbox/mapbox-gl-supported": "^1.5.0",
+        "@mapbox/point-geometry": "^0.1.0",
+        "@mapbox/tiny-sdf": "^1.1.1",
+        "@mapbox/unitbezier": "^0.0.0",
+        "@mapbox/vector-tile": "^1.3.1",
+        "@mapbox/whoots-js": "^3.1.0",
+        "csscolorparser": "~1.0.3",
+        "earcut": "^2.2.2",
+        "geojson-vt": "^3.2.1",
+        "gl-matrix": "^3.2.1",
+        "grid-index": "^1.1.0",
+        "murmurhash-js": "^1.0.0",
+        "pbf": "^3.2.1",
+        "potpack": "^1.0.1",
+        "quickselect": "^2.0.0",
+        "rw": "^1.3.3",
+        "supercluster": "^7.1.0",
+        "tinyqueue": "^2.0.3",
+        "vt-pbf": "^3.1.1"
+      },
+      "engines": {
+        "node": ">=6.4.0"
+      }
+    },
+    "node_modules/@plotly/mapbox-gl/node_modules/@mapbox/mapbox-gl-supported": {
+      "version": "1.5.0",
+      "resolved": "https://registry.npmjs.org/@mapbox/mapbox-gl-supported/-/mapbox-gl-supported-1.5.0.tgz",
+      "integrity": "sha512-/PT1P6DNf7vjEEiPkVIRJkvibbqWtqnyGaBz3nfRdcxclNSnSdaLU5tfAgcD7I8Yt5i+L19s406YLl1koLnLbg==",
+      "license": "BSD-3-Clause",
+      "peer": true,
+      "peerDependencies": {
+        "mapbox-gl": ">=0.32.1 <2.0.0"
+      }
+    },
+    "node_modules/@plotly/mapbox-gl/node_modules/@mapbox/point-geometry": {
+      "version": "0.1.0",
+      "resolved": "https://registry.npmjs.org/@mapbox/point-geometry/-/point-geometry-0.1.0.tgz",
+      "integrity": "sha512-6j56HdLTwWGO0fJPlrZtdU/B13q8Uwmo18Ck2GnGgN9PCFyKTZ3UbXeEdRFh18i9XQ92eH2VdtpJHpBD3aripQ==",
+      "license": "ISC",
+      "peer": true
+    },
+    "node_modules/@plotly/mapbox-gl/node_modules/@mapbox/tiny-sdf": {
+      "version": "1.2.5",
+      "resolved": "https://registry.npmjs.org/@mapbox/tiny-sdf/-/tiny-sdf-1.2.5.tgz",
+      "integrity": "sha512-cD8A/zJlm6fdJOk6DqPUV8mcpyJkRz2x2R+/fYcWDYG3oWbG7/L7Yl/WqQ1VZCjnL9OTIMAn6c+BC5Eru4sQEw==",
+      "license": "BSD-2-Clause",
+      "peer": true
+    },
+    "node_modules/@plotly/mapbox-gl/node_modules/@mapbox/unitbezier": {
+      "version": "0.0.0",
+      "resolved": "https://registry.npmjs.org/@mapbox/unitbezier/-/unitbezier-0.0.0.tgz",
+      "integrity": "sha512-HPnRdYO0WjFjRTSwO3frz1wKaU649OBFPX3Zo/2WZvuRi6zMiRGui8SnPQiQABgqCf8YikDe5t3HViTVw1WUzA==",
+      "license": "BSD-2-Clause",
+      "peer": true
+    },
+    "node_modules/@plotly/mapbox-gl/node_modules/@mapbox/vector-tile": {
+      "version": "1.3.1",
+      "resolved": "https://registry.npmjs.org/@mapbox/vector-tile/-/vector-tile-1.3.1.tgz",
+      "integrity": "sha512-MCEddb8u44/xfQ3oD+Srl/tNcQoqTw3goGk2oLsrFxOTc3dUp+kAnby3PvAeeBYSMSjSPD1nd1AJA6W49WnoUw==",
+      "license": "BSD-3-Clause",
+      "peer": true,
+      "dependencies": {
+        "@mapbox/point-geometry": "~0.1.0"
+      }
+    },
+    "node_modules/@plotly/mapbox-gl/node_modules/kdbush": {
+      "version": "3.0.0",
+      "resolved": "https://registry.npmjs.org/kdbush/-/kdbush-3.0.0.tgz",
+      "integrity": "sha512-hRkd6/XW4HTsA9vjVpY9tuXJYLSlelnkTmVFu4M9/7MIYQtFcHpbugAU7UbOfjOiVSVYl2fqgBuJ32JUmRo5Ew==",
+      "license": "ISC",
+      "peer": true
+    },
+    "node_modules/@plotly/mapbox-gl/node_modules/mapbox-gl": {
+      "version": "1.13.3",
+      "resolved": "https://registry.npmjs.org/mapbox-gl/-/mapbox-gl-1.13.3.tgz",
+      "integrity": "sha512-p8lJFEiqmEQlyv+DQxFAOG/XPWN0Wp7j/Psq93Zywz7qt9CcUKFYDBOoOEKzqe6gudHVJY8/Bhqw6VDpX2lSBg==",
+      "license": "SEE LICENSE IN LICENSE.txt",
+      "peer": true,
+      "dependencies": {
+        "@mapbox/geojson-rewind": "^0.5.2",
+        "@mapbox/geojson-types": "^1.0.2",
+        "@mapbox/jsonlint-lines-primitives": "^2.0.2",
+        "@mapbox/mapbox-gl-supported": "^1.5.0",
+        "@mapbox/point-geometry": "^0.1.0",
+        "@mapbox/tiny-sdf": "^1.1.1",
+        "@mapbox/unitbezier": "^0.0.0",
+        "@mapbox/vector-tile": "^1.3.1",
+        "@mapbox/whoots-js": "^3.1.0",
+        "csscolorparser": "~1.0.3",
+        "earcut": "^2.2.2",
+        "geojson-vt": "^3.2.1",
+        "gl-matrix": "^3.2.1",
+        "grid-index": "^1.1.0",
+        "murmurhash-js": "^1.0.0",
+        "pbf": "^3.2.1",
+        "potpack": "^1.0.1",
+        "quickselect": "^2.0.0",
+        "rw": "^1.3.3",
+        "supercluster": "^7.1.0",
+        "tinyqueue": "^2.0.3",
+        "vt-pbf": "^3.1.1"
+      },
+      "engines": {
+        "node": ">=6.4.0"
+      }
+    },
+    "node_modules/@plotly/mapbox-gl/node_modules/pbf": {
+      "version": "3.3.0",
+      "resolved": "https://registry.npmjs.org/pbf/-/pbf-3.3.0.tgz",
+      "integrity": "sha512-XDF38WCH3z5OV/OVa8GKUNtLAyneuzbCisx7QUCF8Q6Nutx0WnJrQe5O+kOtBlLfRNUws98Y58Lblp+NJG5T4Q==",
+      "license": "BSD-3-Clause",
+      "peer": true,
+      "dependencies": {
+        "ieee754": "^1.1.12",
+        "resolve-protobuf-schema": "^2.1.0"
+      },
+      "bin": {
+        "pbf": "bin/pbf"
+      }
+    },
+    "node_modules/@plotly/mapbox-gl/node_modules/potpack": {
+      "version": "1.0.2",
+      "resolved": "https://registry.npmjs.org/potpack/-/potpack-1.0.2.tgz",
+      "integrity": "sha512-choctRBIV9EMT9WGAZHn3V7t0Z2pMQyl0EZE6pFc/6ml3ssw7Dlf/oAOvFwjm1HVsqfQN8GfeFyJ+d8tRzqueQ==",
+      "license": "ISC",
+      "peer": true
+    },
+    "node_modules/@plotly/mapbox-gl/node_modules/quickselect": {
+      "version": "2.0.0",
+      "resolved": "https://registry.npmjs.org/quickselect/-/quickselect-2.0.0.tgz",
+      "integrity": "sha512-RKJ22hX8mHe3Y6wH/N3wCM6BWtjaxIyyUIkpHOvfFnxdI4yD4tBXEBKSbriGujF6jnSVkJrffuo6vxACiSSxIw==",
+      "license": "ISC",
+      "peer": true
+    },
+    "node_modules/@plotly/mapbox-gl/node_modules/supercluster": {
+      "version": "7.1.5",
+      "resolved": "https://registry.npmjs.org/supercluster/-/supercluster-7.1.5.tgz",
+      "integrity": "sha512-EulshI3pGUM66o6ZdH3ReiFcvHpM3vAigyK+vcxdjpJyEbIIrtbmBdY23mGgnI24uXiGFvrGq9Gkum/8U7vJWg==",
+      "license": "ISC",
+      "peer": true,
+      "dependencies": {
+        "kdbush": "^3.0.0"
+      }
+    },
+    "node_modules/@plotly/mapbox-gl/node_modules/tinyqueue": {
+      "version": "2.0.3",
+      "resolved": "https://registry.npmjs.org/tinyqueue/-/tinyqueue-2.0.3.tgz",
+      "integrity": "sha512-ppJZNDuKGgxzkHihX8v9v9G5f+18gzaTfrukGrq6ueg0lmH4nqVnA2IPG0AEH3jKEk2GRJCUhDoqpoiw3PHLBA==",
+      "license": "ISC",
+      "peer": true
+    },
+    "node_modules/@plotly/point-cluster": {
+      "version": "3.1.9",
+      "resolved": "https://registry.npmjs.org/@plotly/point-cluster/-/point-cluster-3.1.9.tgz",
+      "integrity": "sha512-MwaI6g9scKf68Orpr1pHZ597pYx9uP8UEFXLPbsCmuw3a84obwz6pnMXGc90VhgDNeNiLEdlmuK7CPo+5PIxXw==",
+      "license": "MIT",
+      "peer": true,
+      "dependencies": {
+        "array-bounds": "^1.0.1",
+        "binary-search-bounds": "^2.0.4",
+        "clamp": "^1.0.1",
+        "defined": "^1.0.0",
+        "dtype": "^2.0.0",
+        "flatten-vertex-data": "^1.0.2",
+        "is-obj": "^1.0.1",
+        "math-log2": "^1.0.1",
+        "parse-rect": "^1.2.0",
+        "pick-by-alias": "^1.2.0"
+      }
+    },
+    "node_modules/@plotly/regl": {
+      "version": "2.1.2",
+      "resolved": "https://registry.npmjs.org/@plotly/regl/-/regl-2.1.2.tgz",
+      "integrity": "sha512-Mdk+vUACbQvjd0m/1JJjOOafmkp/EpmHjISsopEz5Av44CBq7rPC05HHNbYGKVyNUF2zmEoBS/TT0pd0SPFFyw==",
+      "license": "MIT",
+      "peer": true
+    },
+    "node_modules/@probe.gl/env": {
+      "version": "4.1.1",
+      "resolved": "https://registry.npmjs.org/@probe.gl/env/-/env-4.1.1.tgz",
+      "integrity": "sha512-+68seNDMVsEegRB47pFA/Ws1Fjy8agcFYXxzorKToyPcD6zd+gZ5uhwoLd7TzsSw6Ydns//2KEszWn+EnNHTbA==",
+      "license": "MIT"
+    },
+    "node_modules/@probe.gl/log": {
+      "version": "4.1.1",
+      "resolved": "https://registry.npmjs.org/@probe.gl/log/-/log-4.1.1.tgz",
+      "integrity": "sha512-kcZs9BT44pL7hS1OkRGKYRXI/SN9KejUlPD+BY40DguRLzdC5tLG/28WGMyfKdn/51GT4a0p+0P8xvDn1Ez+Kg==",
+      "license": "MIT",
+      "dependencies": {
+        "@probe.gl/env": "4.1.1"
+      }
+    },
+    "node_modules/@probe.gl/stats": {
+      "version": "4.1.1",
+      "resolved": "https://registry.npmjs.org/@probe.gl/stats/-/stats-4.1.1.tgz",
+      "integrity": "sha512-4VpAyMHOqydSvPlEyHwXaE+AkIdR03nX+Qhlxsk2D/IW4OVmDZgIsvJB1cDzyEEtcfKcnaEbfXeiPgejBceT6g==",
+      "license": "MIT"
+    },
+    "node_modules/@react-leaflet/core": {
+      "version": "2.1.0",
+      "resolved": "https://registry.npmjs.org/@react-leaflet/core/-/core-2.1.0.tgz",
+      "integrity": "sha512-Qk7Pfu8BSarKGqILj4x7bCSZ1pjuAPZ+qmRwH5S7mDS91VSbVVsJSrW4qA+GPrro8t69gFYVMWb1Zc4yFmPiVg==",
+      "license": "Hippocratic-2.1",
+      "peerDependencies": {
+        "leaflet": "^1.9.0",
+        "react": "^18.0.0",
+        "react-dom": "^18.0.0"
+      }
+    },
+    "node_modules/@rolldown/pluginutils": {
+      "version": "1.0.0-beta.9",
+      "resolved": "https://registry.npmjs.org/@rolldown/pluginutils/-/pluginutils-1.0.0-beta.9.tgz",
+      "integrity": "sha512-e9MeMtVWo186sgvFFJOPGy7/d2j2mZhLJIdVW0C/xDluuOvymEATqz6zKsP0ZmXGzQtqlyjz5sC1sYQUoJG98w==",
+      "dev": true,
+      "license": "MIT"
+    },
+    "node_modules/@rollup/rollup-android-arm-eabi": {
+      "version": "4.41.1",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-android-arm-eabi/-/rollup-android-arm-eabi-4.41.1.tgz",
+      "integrity": "sha512-NELNvyEWZ6R9QMkiytB4/L4zSEaBC03KIXEghptLGLZWJ6VPrL63ooZQCOnlx36aQPGhzuOMwDerC1Eb2VmrLw==",
+      "cpu": [
+        "arm"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "android"
+      ]
+    },
+    "node_modules/@rollup/rollup-android-arm64": {
+      "version": "4.41.1",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-android-arm64/-/rollup-android-arm64-4.41.1.tgz",
+      "integrity": "sha512-DXdQe1BJ6TK47ukAoZLehRHhfKnKg9BjnQYUu9gzhI8Mwa1d2fzxA1aw2JixHVl403bwp1+/o/NhhHtxWJBgEA==",
       "cpu": [
         "arm64"
       ],
       "dev": true,
       "license": "MIT",
-      "optional": true,
-      "os": [
-        "freebsd"
-      ]
+      "optional": true,
+      "os": [
+        "android"
+      ]
+    },
+    "node_modules/@rollup/rollup-darwin-arm64": {
+      "version": "4.41.1",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-darwin-arm64/-/rollup-darwin-arm64-4.41.1.tgz",
+      "integrity": "sha512-5afxvwszzdulsU2w8JKWwY8/sJOLPzf0e1bFuvcW5h9zsEg+RQAojdW0ux2zyYAz7R8HvvzKCjLNJhVq965U7w==",
+      "cpu": [
+        "arm64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "darwin"
+      ]
+    },
+    "node_modules/@rollup/rollup-darwin-x64": {
+      "version": "4.41.1",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-darwin-x64/-/rollup-darwin-x64-4.41.1.tgz",
+      "integrity": "sha512-egpJACny8QOdHNNMZKf8xY0Is6gIMz+tuqXlusxquWu3F833DcMwmGM7WlvCO9sB3OsPjdC4U0wHw5FabzCGZg==",
+      "cpu": [
+        "x64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "darwin"
+      ]
+    },
+    "node_modules/@rollup/rollup-freebsd-arm64": {
+      "version": "4.41.1",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-freebsd-arm64/-/rollup-freebsd-arm64-4.41.1.tgz",
+      "integrity": "sha512-DBVMZH5vbjgRk3r0OzgjS38z+atlupJ7xfKIDJdZZL6sM6wjfDNo64aowcLPKIx7LMQi8vybB56uh1Ftck/Atg==",
+      "cpu": [
+        "arm64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "freebsd"
+      ]
+    },
+    "node_modules/@rollup/rollup-freebsd-x64": {
+      "version": "4.41.1",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-freebsd-x64/-/rollup-freebsd-x64-4.41.1.tgz",
+      "integrity": "sha512-3FkydeohozEskBxNWEIbPfOE0aqQgB6ttTkJ159uWOFn42VLyfAiyD9UK5mhu+ItWzft60DycIN1Xdgiy8o/SA==",
+      "cpu": [
+        "x64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "freebsd"
+      ]
+    },
+    "node_modules/@rollup/rollup-linux-arm-gnueabihf": {
+      "version": "4.41.1",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-arm-gnueabihf/-/rollup-linux-arm-gnueabihf-4.41.1.tgz",
+      "integrity": "sha512-wC53ZNDgt0pqx5xCAgNunkTzFE8GTgdZ9EwYGVcg+jEjJdZGtq9xPjDnFgfFozQI/Xm1mh+D9YlYtl+ueswNEg==",
+      "cpu": [
+        "arm"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ]
+    },
+    "node_modules/@rollup/rollup-linux-arm-musleabihf": {
+      "version": "4.41.1",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-arm-musleabihf/-/rollup-linux-arm-musleabihf-4.41.1.tgz",
+      "integrity": "sha512-jwKCca1gbZkZLhLRtsrka5N8sFAaxrGz/7wRJ8Wwvq3jug7toO21vWlViihG85ei7uJTpzbXZRcORotE+xyrLA==",
+      "cpu": [
+        "arm"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ]
+    },
+    "node_modules/@rollup/rollup-linux-arm64-gnu": {
+      "version": "4.41.1",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-arm64-gnu/-/rollup-linux-arm64-gnu-4.41.1.tgz",
+      "integrity": "sha512-g0UBcNknsmmNQ8V2d/zD2P7WWfJKU0F1nu0k5pW4rvdb+BIqMm8ToluW/eeRmxCared5dD76lS04uL4UaNgpNA==",
+      "cpu": [
+        "arm64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ]
+    },
+    "node_modules/@rollup/rollup-linux-arm64-musl": {
+      "version": "4.41.1",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-arm64-musl/-/rollup-linux-arm64-musl-4.41.1.tgz",
+      "integrity": "sha512-XZpeGB5TKEZWzIrj7sXr+BEaSgo/ma/kCgrZgL0oo5qdB1JlTzIYQKel/RmhT6vMAvOdM2teYlAaOGJpJ9lahg==",
+      "cpu": [
+        "arm64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ]
+    },
+    "node_modules/@rollup/rollup-linux-loongarch64-gnu": {
+      "version": "4.41.1",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-loongarch64-gnu/-/rollup-linux-loongarch64-gnu-4.41.1.tgz",
+      "integrity": "sha512-bkCfDJ4qzWfFRCNt5RVV4DOw6KEgFTUZi2r2RuYhGWC8WhCA8lCAJhDeAmrM/fdiAH54m0mA0Vk2FGRPyzI+tw==",
+      "cpu": [
+        "loong64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ]
+    },
+    "node_modules/@rollup/rollup-linux-powerpc64le-gnu": {
+      "version": "4.41.1",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-powerpc64le-gnu/-/rollup-linux-powerpc64le-gnu-4.41.1.tgz",
+      "integrity": "sha512-3mr3Xm+gvMX+/8EKogIZSIEF0WUu0HL9di+YWlJpO8CQBnoLAEL/roTCxuLncEdgcfJcvA4UMOf+2dnjl4Ut1A==",
+      "cpu": [
+        "ppc64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ]
+    },
+    "node_modules/@rollup/rollup-linux-riscv64-gnu": {
+      "version": "4.41.1",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-riscv64-gnu/-/rollup-linux-riscv64-gnu-4.41.1.tgz",
+      "integrity": "sha512-3rwCIh6MQ1LGrvKJitQjZFuQnT2wxfU+ivhNBzmxXTXPllewOF7JR1s2vMX/tWtUYFgphygxjqMl76q4aMotGw==",
+      "cpu": [
+        "riscv64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ]
+    },
+    "node_modules/@rollup/rollup-linux-riscv64-musl": {
+      "version": "4.41.1",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-riscv64-musl/-/rollup-linux-riscv64-musl-4.41.1.tgz",
+      "integrity": "sha512-LdIUOb3gvfmpkgFZuccNa2uYiqtgZAz3PTzjuM5bH3nvuy9ty6RGc/Q0+HDFrHrizJGVpjnTZ1yS5TNNjFlklw==",
+      "cpu": [
+        "riscv64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ]
+    },
+    "node_modules/@rollup/rollup-linux-s390x-gnu": {
+      "version": "4.41.1",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-s390x-gnu/-/rollup-linux-s390x-gnu-4.41.1.tgz",
+      "integrity": "sha512-oIE6M8WC9ma6xYqjvPhzZYk6NbobIURvP/lEbh7FWplcMO6gn7MM2yHKA1eC/GvYwzNKK/1LYgqzdkZ8YFxR8g==",
+      "cpu": [
+        "s390x"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ]
+    },
+    "node_modules/@rollup/rollup-linux-x64-gnu": {
+      "version": "4.41.1",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-x64-gnu/-/rollup-linux-x64-gnu-4.41.1.tgz",
+      "integrity": "sha512-cWBOvayNvA+SyeQMp79BHPK8ws6sHSsYnK5zDcsC3Hsxr1dgTABKjMnMslPq1DvZIp6uO7kIWhiGwaTdR4Og9A==",
+      "cpu": [
+        "x64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ]
+    },
+    "node_modules/@rollup/rollup-linux-x64-musl": {
+      "version": "4.41.1",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-x64-musl/-/rollup-linux-x64-musl-4.41.1.tgz",
+      "integrity": "sha512-y5CbN44M+pUCdGDlZFzGGBSKCA4A/J2ZH4edTYSSxFg7ce1Xt3GtydbVKWLlzL+INfFIZAEg1ZV6hh9+QQf9YQ==",
+      "cpu": [
+        "x64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ]
+    },
+    "node_modules/@rollup/rollup-win32-arm64-msvc": {
+      "version": "4.41.1",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-win32-arm64-msvc/-/rollup-win32-arm64-msvc-4.41.1.tgz",
+      "integrity": "sha512-lZkCxIrjlJlMt1dLO/FbpZbzt6J/A8p4DnqzSa4PWqPEUUUnzXLeki/iyPLfV0BmHItlYgHUqJe+3KiyydmiNQ==",
+      "cpu": [
+        "arm64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "win32"
+      ]
+    },
+    "node_modules/@rollup/rollup-win32-ia32-msvc": {
+      "version": "4.41.1",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-win32-ia32-msvc/-/rollup-win32-ia32-msvc-4.41.1.tgz",
+      "integrity": "sha512-+psFT9+pIh2iuGsxFYYa/LhS5MFKmuivRsx9iPJWNSGbh2XVEjk90fmpUEjCnILPEPJnikAU6SFDiEUyOv90Pg==",
+      "cpu": [
+        "ia32"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "win32"
+      ]
+    },
+    "node_modules/@rollup/rollup-win32-x64-msvc": {
+      "version": "4.41.1",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-win32-x64-msvc/-/rollup-win32-x64-msvc-4.41.1.tgz",
+      "integrity": "sha512-Wq2zpapRYLfi4aKxf2Xff0tN+7slj2d4R87WEzqw7ZLsVvO5zwYCIuEGSZYiK41+GlwUo1HiR+GdkLEJnCKTCw==",
+      "cpu": [
+        "x64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "win32"
+      ]
+    },
+    "node_modules/@swc/helpers": {
+      "version": "0.5.19",
+      "resolved": "https://registry.npmjs.org/@swc/helpers/-/helpers-0.5.19.tgz",
+      "integrity": "sha512-QamiFeIK3txNjgUTNppE6MiG3p7TdninpZu0E0PbqVh1a9FNLT2FRhisaa4NcaX52XVhA5l7Pk58Ft7Sqi/2sA==",
+      "license": "Apache-2.0",
+      "dependencies": {
+        "tslib": "^2.8.0"
+      }
+    },
+    "node_modules/@testing-library/dom": {
+      "version": "10.4.1",
+      "resolved": "https://registry.npmjs.org/@testing-library/dom/-/dom-10.4.1.tgz",
+      "integrity": "sha512-o4PXJQidqJl82ckFaXUeoAW+XysPLauYI43Abki5hABd853iMhitooc6znOnczgbTYmEP6U6/y1ZyKAIsvMKGg==",
+      "dev": true,
+      "license": "MIT",
+      "peer": true,
+      "dependencies": {
+        "@babel/code-frame": "^7.10.4",
+        "@babel/runtime": "^7.12.5",
+        "@types/aria-query": "^5.0.1",
+        "aria-query": "5.3.0",
+        "dom-accessibility-api": "^0.5.9",
+        "lz-string": "^1.5.0",
+        "picocolors": "1.1.1",
+        "pretty-format": "^27.0.2"
+      },
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/@testing-library/jest-dom": {
+      "version": "6.9.1",
+      "resolved": "https://registry.npmjs.org/@testing-library/jest-dom/-/jest-dom-6.9.1.tgz",
+      "integrity": "sha512-zIcONa+hVtVSSep9UT3jZ5rizo2BsxgyDYU7WFD5eICBE7no3881HGeb/QkGfsJs6JTkY1aQhT7rIPC7e+0nnA==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@adobe/css-tools": "^4.4.0",
+        "aria-query": "^5.0.0",
+        "css.escape": "^1.5.1",
+        "dom-accessibility-api": "^0.6.3",
+        "picocolors": "^1.1.1",
+        "redent": "^3.0.0"
+      },
+      "engines": {
+        "node": ">=14",
+        "npm": ">=6",
+        "yarn": ">=1"
+      }
+    },
+    "node_modules/@testing-library/jest-dom/node_modules/dom-accessibility-api": {
+      "version": "0.6.3",
+      "resolved": "https://registry.npmjs.org/dom-accessibility-api/-/dom-accessibility-api-0.6.3.tgz",
+      "integrity": "sha512-7ZgogeTnjuHbo+ct10G9Ffp0mif17idi0IyWNVA/wcwcm7NPOD/WEHVP3n7n3MhXqxoIYm8d6MuZohYWIZ4T3w==",
+      "dev": true,
+      "license": "MIT"
+    },
+    "node_modules/@testing-library/react": {
+      "version": "16.3.0",
+      "resolved": "https://registry.npmjs.org/@testing-library/react/-/react-16.3.0.tgz",
+      "integrity": "sha512-kFSyxiEDwv1WLl2fgsq6pPBbw5aWKrsY2/noi1Id0TK0UParSF62oFQFGHXIyaG4pp2tEub/Zlel+fjjZILDsw==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@babel/runtime": "^7.12.5"
+      },
+      "engines": {
+        "node": ">=18"
+      },
+      "peerDependencies": {
+        "@testing-library/dom": "^10.0.0",
+        "@types/react": "^18.0.0 || ^19.0.0",
+        "@types/react-dom": "^18.0.0 || ^19.0.0",
+        "react": "^18.0.0 || ^19.0.0",
+        "react-dom": "^18.0.0 || ^19.0.0"
+      },
+      "peerDependenciesMeta": {
+        "@types/react": {
+          "optional": true
+        },
+        "@types/react-dom": {
+          "optional": true
+        }
+      }
+    },
+    "node_modules/@testing-library/user-event": {
+      "version": "14.6.1",
+      "resolved": "https://registry.npmjs.org/@testing-library/user-event/-/user-event-14.6.1.tgz",
+      "integrity": "sha512-vq7fv0rnt+QTXgPxr5Hjc210p6YKq2kmdziLgnsZGgLJ9e6VAShx1pACLuRjd/AS/sr7phAR58OIIpf0LlmQNw==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">=12",
+        "npm": ">=6"
+      },
+      "peerDependencies": {
+        "@testing-library/dom": ">=7.21.4"
+      }
+    },
+    "node_modules/@turf/area": {
+      "version": "7.3.4",
+      "resolved": "https://registry.npmjs.org/@turf/area/-/area-7.3.4.tgz",
+      "integrity": "sha512-UEQQFw2XwHpozSBAMEtZI3jDsAad4NnHL/poF7/S6zeDCjEBCkt3MYd6DSGH/cvgcOozxH/ky3/rIVSMZdx4vA==",
+      "license": "MIT",
+      "peer": true,
+      "dependencies": {
+        "@turf/helpers": "7.3.4",
+        "@turf/meta": "7.3.4",
+        "@types/geojson": "^7946.0.10",
+        "tslib": "^2.8.1"
+      },
+      "funding": {
+        "url": "https://opencollective.com/turf"
+      }
+    },
+    "node_modules/@turf/bbox": {
+      "version": "7.3.4",
+      "resolved": "https://registry.npmjs.org/@turf/bbox/-/bbox-7.3.4.tgz",
+      "integrity": "sha512-D5ErVWtfQbEPh11yzI69uxqrcJmbPU/9Y59f1uTapgwAwQHQztDWgsYpnL3ns8r1GmPWLP8sGJLVTIk2TZSiYA==",
+      "license": "MIT",
+      "peer": true,
+      "dependencies": {
+        "@turf/helpers": "7.3.4",
+        "@turf/meta": "7.3.4",
+        "@types/geojson": "^7946.0.10",
+        "tslib": "^2.8.1"
+      },
+      "funding": {
+        "url": "https://opencollective.com/turf"
+      }
+    },
+    "node_modules/@turf/centroid": {
+      "version": "7.3.4",
+      "resolved": "https://registry.npmjs.org/@turf/centroid/-/centroid-7.3.4.tgz",
+      "integrity": "sha512-6c3kyTSKBrmiPMe75UkHw6MgedroZ6eR5usEvdlDhXgA3MudFPXIZkMFmMd1h9XeJ9xFfkmq+HPCdF0cOzvztA==",
+      "license": "MIT",
+      "peer": true,
+      "dependencies": {
+        "@turf/helpers": "7.3.4",
+        "@turf/meta": "7.3.4",
+        "@types/geojson": "^7946.0.10",
+        "tslib": "^2.8.1"
+      },
+      "funding": {
+        "url": "https://opencollective.com/turf"
+      }
+    },
+    "node_modules/@turf/helpers": {
+      "version": "7.3.4",
+      "resolved": "https://registry.npmjs.org/@turf/helpers/-/helpers-7.3.4.tgz",
+      "integrity": "sha512-U/S5qyqgx3WTvg4twaH0WxF3EixoTCfDsmk98g1E3/5e2YKp7JKYZdz0vivsS5/UZLJeZDEElOSFH4pUgp+l7g==",
+      "license": "MIT",
+      "peer": true,
+      "dependencies": {
+        "@types/geojson": "^7946.0.10",
+        "tslib": "^2.8.1"
+      },
+      "funding": {
+        "url": "https://opencollective.com/turf"
+      }
+    },
+    "node_modules/@turf/meta": {
+      "version": "7.3.4",
+      "resolved": "https://registry.npmjs.org/@turf/meta/-/meta-7.3.4.tgz",
+      "integrity": "sha512-tlmw9/Hs1p2n0uoHVm1w3ugw1I6L8jv9YZrcdQa4SH5FX5UY0ATrKeIvfA55FlL//PGuYppJp+eyg/0eb4goqw==",
+      "license": "MIT",
+      "peer": true,
+      "dependencies": {
+        "@turf/helpers": "7.3.4",
+        "@types/geojson": "^7946.0.10",
+        "tslib": "^2.8.1"
+      },
+      "funding": {
+        "url": "https://opencollective.com/turf"
+      }
+    },
+    "node_modules/@types/aria-query": {
+      "version": "5.0.4",
+      "resolved": "https://registry.npmjs.org/@types/aria-query/-/aria-query-5.0.4.tgz",
+      "integrity": "sha512-rfT93uj5s0PRL7EzccGMs3brplhcrghnDoV26NqKhCAS1hVo+WdNsPvE/yb6ilfr5hi2MEk6d5EWJTKdxg8jVw==",
+      "dev": true,
+      "license": "MIT",
+      "peer": true
+    },
+    "node_modules/@types/babel__core": {
+      "version": "7.20.5",
+      "resolved": "https://registry.npmjs.org/@types/babel__core/-/babel__core-7.20.5.tgz",
+      "integrity": "sha512-qoQprZvz5wQFJwMDqeseRXWv3rqMvhgpbXFfVyWhbx9X47POIA6i/+dXefEmZKoAgOaTdaIgNSMqMIU61yRyzA==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@babel/parser": "^7.20.7",
+        "@babel/types": "^7.20.7",
+        "@types/babel__generator": "*",
+        "@types/babel__template": "*",
+        "@types/babel__traverse": "*"
+      }
+    },
+    "node_modules/@types/babel__generator": {
+      "version": "7.27.0",
+      "resolved": "https://registry.npmjs.org/@types/babel__generator/-/babel__generator-7.27.0.tgz",
+      "integrity": "sha512-ufFd2Xi92OAVPYsy+P4n7/U7e68fex0+Ee8gSG9KX7eo084CWiQ4sdxktvdl0bOPupXtVJPY19zk6EwWqUQ8lg==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@babel/types": "^7.0.0"
+      }
+    },
+    "node_modules/@types/babel__template": {
+      "version": "7.4.4",
+      "resolved": "https://registry.npmjs.org/@types/babel__template/-/babel__template-7.4.4.tgz",
+      "integrity": "sha512-h/NUaSyG5EyxBIp8YRxo4RMe2/qQgvyowRwVMzhYhBCONbW8PUsg4lkFMrhgZhUe5z3L3MiLDuvyJ/CaPa2A8A==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@babel/parser": "^7.1.0",
+        "@babel/types": "^7.0.0"
+      }
+    },
+    "node_modules/@types/babel__traverse": {
+      "version": "7.20.7",
+      "resolved": "https://registry.npmjs.org/@types/babel__traverse/-/babel__traverse-7.20.7.tgz",
+      "integrity": "sha512-dkO5fhS7+/oos4ciWxyEyjWe48zmG6wbCheo/G2ZnHx4fs3EU6YC6UM8rk56gAjNJ9P3MTH2jo5jb92/K6wbng==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@babel/types": "^7.20.7"
+      }
+    },
+    "node_modules/@types/chai": {
+      "version": "5.2.3",
+      "resolved": "https://registry.npmjs.org/@types/chai/-/chai-5.2.3.tgz",
+      "integrity": "sha512-Mw558oeA9fFbv65/y4mHtXDs9bPnFMZAL/jxdPFUpOHHIXX91mcgEHbS5Lahr+pwZFR8A7GQleRWeI6cGFC2UA==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@types/deep-eql": "*",
+        "assertion-error": "^2.0.1"
+      }
+    },
+    "node_modules/@types/command-line-args": {
+      "version": "5.2.3",
+      "resolved": "https://registry.npmjs.org/@types/command-line-args/-/command-line-args-5.2.3.tgz",
+      "integrity": "sha512-uv0aG6R0Y8WHZLTamZwtfsDLVRnOa+n+n5rEvFWL5Na5gZ8V2Teab/duDPFzIIIhs9qizDpcavCusCLJZu62Kw==",
+      "license": "MIT"
+    },
+    "node_modules/@types/command-line-usage": {
+      "version": "5.0.4",
+      "resolved": "https://registry.npmjs.org/@types/command-line-usage/-/command-line-usage-5.0.4.tgz",
+      "integrity": "sha512-BwR5KP3Es/CSht0xqBcUXS3qCAUVXwpRKsV2+arxeb65atasuXG9LykC9Ab10Cw3s2raH92ZqOeILaQbsB2ACg==",
+      "license": "MIT"
+    },
+    "node_modules/@types/deep-eql": {
+      "version": "4.0.2",
+      "resolved": "https://registry.npmjs.org/@types/deep-eql/-/deep-eql-4.0.2.tgz",
+      "integrity": "sha512-c9h9dVVMigMPc4bwTvC5dxqtqJZwQPePsWjPlpSOnojbor6pGqdk541lfA7AqFQr5pB1BRdq0juY9db81BwyFw==",
+      "dev": true,
+      "license": "MIT"
+    },
+    "node_modules/@types/estree": {
+      "version": "1.0.7",
+      "resolved": "https://registry.npmjs.org/@types/estree/-/estree-1.0.7.tgz",
+      "integrity": "sha512-w28IoSUCJpidD/TGviZwwMJckNESJZXFu7NBZ5YJ4mEUnNraUn9Pm8HSZm/jDF1pDWYKspWE7oVphigUPRakIQ==",
+      "dev": true,
+      "license": "MIT"
+    },
+    "node_modules/@types/geojson": {
+      "version": "7946.0.16",
+      "resolved": "https://registry.npmjs.org/@types/geojson/-/geojson-7946.0.16.tgz",
+      "integrity": "sha512-6C8nqWur3j98U6+lXDfTUWIfgvZU+EumvpHKcYjujKH7woYyLj2sUmff0tRhrqM7BohUw7Pz3ZB1jj2gW9Fvmg==",
+      "license": "MIT"
+    },
+    "node_modules/@types/geojson-vt": {
+      "version": "3.2.5",
+      "resolved": "https://registry.npmjs.org/@types/geojson-vt/-/geojson-vt-3.2.5.tgz",
+      "integrity": "sha512-qDO7wqtprzlpe8FfQ//ClPV9xiuoh2nkIgiouIptON9w5jvD/fA4szvP9GBlDVdJ5dldAl0kX/sy3URbWwLx0g==",
+      "license": "MIT",
+      "peer": true,
+      "dependencies": {
+        "@types/geojson": "*"
+      }
+    },
+    "node_modules/@types/leaflet": {
+      "version": "1.9.18",
+      "resolved": "https://registry.npmjs.org/@types/leaflet/-/leaflet-1.9.18.tgz",
+      "integrity": "sha512-ht2vsoPjezor5Pmzi5hdsA7F++v5UGq9OlUduWHmMZiuQGIpJ2WS5+Gg9HaAA79gNh1AIPtCqhzejcIZ3lPzXQ==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@types/geojson": "*"
+      }
+    },
+    "node_modules/@types/mapbox__point-geometry": {
+      "version": "0.1.4",
+      "resolved": "https://registry.npmjs.org/@types/mapbox__point-geometry/-/mapbox__point-geometry-0.1.4.tgz",
+      "integrity": "sha512-mUWlSxAmYLfwnRBmgYV86tgYmMIICX4kza8YnE/eIlywGe2XoOxlpVnXWwir92xRLjwyarqwpu2EJKD2pk0IUA==",
+      "license": "MIT",
+      "peer": true
+    },
+    "node_modules/@types/mapbox__vector-tile": {
+      "version": "1.3.4",
+      "resolved": "https://registry.npmjs.org/@types/mapbox__vector-tile/-/mapbox__vector-tile-1.3.4.tgz",
+      "integrity": "sha512-bpd8dRn9pr6xKvuEBQup8pwQfD4VUyqO/2deGjfpe6AwC8YRlyEipvefyRJUSiCJTZuCb8Pl1ciVV5ekqJ96Bg==",
+      "license": "MIT",
+      "peer": true,
+      "dependencies": {
+        "@types/geojson": "*",
+        "@types/mapbox__point-geometry": "*",
+        "@types/pbf": "*"
+      }
+    },
+    "node_modules/@types/node": {
+      "version": "24.12.0",
+      "resolved": "https://registry.npmjs.org/@types/node/-/node-24.12.0.tgz",
+      "integrity": "sha512-GYDxsZi3ChgmckRT9HPU0WEhKLP08ev/Yfcq2AstjrDASOYCSXeyjDsHg4v5t4jOj7cyDX3vmprafKlWIG9MXQ==",
+      "license": "MIT",
+      "dependencies": {
+        "undici-types": "~7.16.0"
+      }
+    },
+    "node_modules/@types/offscreencanvas": {
+      "version": "2019.7.3",
+      "resolved": "https://registry.npmjs.org/@types/offscreencanvas/-/offscreencanvas-2019.7.3.tgz",
+      "integrity": "sha512-ieXiYmgSRXUDeOntE1InxjWyvEelZGP63M+cGuquuRLuIKKT1osnkXjxev9B7d1nXSug5vpunx+gNlbVxMlC9A==",
+      "license": "MIT"
+    },
+    "node_modules/@types/pbf": {
+      "version": "3.0.5",
+      "resolved": "https://registry.npmjs.org/@types/pbf/-/pbf-3.0.5.tgz",
+      "integrity": "sha512-j3pOPiEcWZ34R6a6mN07mUkM4o4Lwf6hPNt8eilOeZhTFbxFXmKhvXl9Y28jotFPaI1bpPDJsbCprUoNke6OrA==",
+      "license": "MIT",
+      "peer": true
+    },
+    "node_modules/@types/plotly.js": {
+      "version": "3.0.10",
+      "resolved": "https://registry.npmjs.org/@types/plotly.js/-/plotly.js-3.0.10.tgz",
+      "integrity": "sha512-q+MgO4aajC2HrO7FllTYWzrpdfbTjboSMfjkz/aXKjg1v7HNo1zMEFfAW7quKfk6SL+bH74A5ThBEps/7hZxOA==",
+      "license": "MIT"
+    },
+    "node_modules/@types/prop-types": {
+      "version": "15.7.14",
+      "resolved": "https://registry.npmjs.org/@types/prop-types/-/prop-types-15.7.14.tgz",
+      "integrity": "sha512-gNMvNH49DJ7OJYv+KAKn0Xp45p8PLl6zo2YnvDIbTd4J6MER2BmWN49TG7n9LvkyihINxeKW8+3bfS2yDC9dzQ==",
+      "license": "MIT"
+    },
+    "node_modules/@types/react": {
+      "version": "18.3.23",
+      "resolved": "https://registry.npmjs.org/@types/react/-/react-18.3.23.tgz",
+      "integrity": "sha512-/LDXMQh55EzZQ0uVAZmKKhfENivEvWz6E+EYzh+/MCjMhNsotd+ZHhBGIjFDTi6+fz0OhQQQLbTgdQIxxCsC0w==",
+      "license": "MIT",
+      "dependencies": {
+        "@types/prop-types": "*",
+        "csstype": "^3.0.2"
+      }
+    },
+    "node_modules/@types/react-dom": {
+      "version": "18.3.7",
+      "resolved": "https://registry.npmjs.org/@types/react-dom/-/react-dom-18.3.7.tgz",
+      "integrity": "sha512-MEe3UeoENYVFXzoXEWsvcpg6ZvlrFNlOQ7EOsvhI3CfAXwzPfO8Qwuxd40nepsYKqyyVQnTdEfv68q91yLcKrQ==",
+      "dev": true,
+      "license": "MIT",
+      "peerDependencies": {
+        "@types/react": "^18.0.0"
+      }
+    },
+    "node_modules/@types/react-plotly.js": {
+      "version": "2.6.4",
+      "resolved": "https://registry.npmjs.org/@types/react-plotly.js/-/react-plotly.js-2.6.4.tgz",
+      "integrity": "sha512-AU6w1u3qEGM0NmBA69PaOgNc0KPFA/+qkH6Uu9EBTJ45/WYOUoXi9AF5O15PRM2klpHSiHAAs4WnlI+OZAFmUA==",
+      "license": "MIT",
+      "dependencies": {
+        "@types/plotly.js": "*",
+        "@types/react": "*"
+      }
+    },
+    "node_modules/@types/supercluster": {
+      "version": "7.1.3",
+      "resolved": "https://registry.npmjs.org/@types/supercluster/-/supercluster-7.1.3.tgz",
+      "integrity": "sha512-Z0pOY34GDFl3Q6hUFYf3HkTwKEE02e7QgtJppBt+beEAxnyOpJua+voGFvxINBHa06GwLFFym7gRPY2SiKIfIA==",
+      "license": "MIT",
+      "dependencies": {
+        "@types/geojson": "*"
+      }
+    },
+    "node_modules/@typescript-eslint/eslint-plugin": {
+      "version": "7.18.0",
+      "resolved": "https://registry.npmjs.org/@typescript-eslint/eslint-plugin/-/eslint-plugin-7.18.0.tgz",
+      "integrity": "sha512-94EQTWZ40mzBc42ATNIBimBEDltSJ9RQHCC8vc/PDbxi4k8dVwUAv4o98dk50M1zB+JGFxp43FP7f8+FP8R6Sw==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@eslint-community/regexpp": "^4.10.0",
+        "@typescript-eslint/scope-manager": "7.18.0",
+        "@typescript-eslint/type-utils": "7.18.0",
+        "@typescript-eslint/utils": "7.18.0",
+        "@typescript-eslint/visitor-keys": "7.18.0",
+        "graphemer": "^1.4.0",
+        "ignore": "^5.3.1",
+        "natural-compare": "^1.4.0",
+        "ts-api-utils": "^1.3.0"
+      },
+      "engines": {
+        "node": "^18.18.0 || >=20.0.0"
+      },
+      "funding": {
+        "type": "opencollective",
+        "url": "https://opencollective.com/typescript-eslint"
+      },
+      "peerDependencies": {
+        "@typescript-eslint/parser": "^7.0.0",
+        "eslint": "^8.56.0"
+      },
+      "peerDependenciesMeta": {
+        "typescript": {
+          "optional": true
+        }
+      }
+    },
+    "node_modules/@typescript-eslint/parser": {
+      "version": "7.18.0",
+      "resolved": "https://registry.npmjs.org/@typescript-eslint/parser/-/parser-7.18.0.tgz",
+      "integrity": "sha512-4Z+L8I2OqhZV8qA132M4wNL30ypZGYOQVBfMgxDH/K5UX0PNqTu1c6za9ST5r9+tavvHiTWmBnKzpCJ/GlVFtg==",
+      "dev": true,
+      "license": "BSD-2-Clause",
+      "dependencies": {
+        "@typescript-eslint/scope-manager": "7.18.0",
+        "@typescript-eslint/types": "7.18.0",
+        "@typescript-eslint/typescript-estree": "7.18.0",
+        "@typescript-eslint/visitor-keys": "7.18.0",
+        "debug": "^4.3.4"
+      },
+      "engines": {
+        "node": "^18.18.0 || >=20.0.0"
+      },
+      "funding": {
+        "type": "opencollective",
+        "url": "https://opencollective.com/typescript-eslint"
+      },
+      "peerDependencies": {
+        "eslint": "^8.56.0"
+      },
+      "peerDependenciesMeta": {
+        "typescript": {
+          "optional": true
+        }
+      }
+    },
+    "node_modules/@typescript-eslint/scope-manager": {
+      "version": "7.18.0",
+      "resolved": "https://registry.npmjs.org/@typescript-eslint/scope-manager/-/scope-manager-7.18.0.tgz",
+      "integrity": "sha512-jjhdIE/FPF2B7Z1uzc6i3oWKbGcHb87Qw7AWj6jmEqNOfDFbJWtjt/XfwCpvNkpGWlcJaog5vTR+VV8+w9JflA==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@typescript-eslint/types": "7.18.0",
+        "@typescript-eslint/visitor-keys": "7.18.0"
+      },
+      "engines": {
+        "node": "^18.18.0 || >=20.0.0"
+      },
+      "funding": {
+        "type": "opencollective",
+        "url": "https://opencollective.com/typescript-eslint"
+      }
+    },
+    "node_modules/@typescript-eslint/type-utils": {
+      "version": "7.18.0",
+      "resolved": "https://registry.npmjs.org/@typescript-eslint/type-utils/-/type-utils-7.18.0.tgz",
+      "integrity": "sha512-XL0FJXuCLaDuX2sYqZUUSOJ2sG5/i1AAze+axqmLnSkNEVMVYLF+cbwlB2w8D1tinFuSikHmFta+P+HOofrLeA==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@typescript-eslint/typescript-estree": "7.18.0",
+        "@typescript-eslint/utils": "7.18.0",
+        "debug": "^4.3.4",
+        "ts-api-utils": "^1.3.0"
+      },
+      "engines": {
+        "node": "^18.18.0 || >=20.0.0"
+      },
+      "funding": {
+        "type": "opencollective",
+        "url": "https://opencollective.com/typescript-eslint"
+      },
+      "peerDependencies": {
+        "eslint": "^8.56.0"
+      },
+      "peerDependenciesMeta": {
+        "typescript": {
+          "optional": true
+        }
+      }
+    },
+    "node_modules/@typescript-eslint/types": {
+      "version": "7.18.0",
+      "resolved": "https://registry.npmjs.org/@typescript-eslint/types/-/types-7.18.0.tgz",
+      "integrity": "sha512-iZqi+Ds1y4EDYUtlOOC+aUmxnE9xS/yCigkjA7XpTKV6nCBd3Hp/PRGGmdwnfkV2ThMyYldP1wRpm/id99spTQ==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": "^18.18.0 || >=20.0.0"
+      },
+      "funding": {
+        "type": "opencollective",
+        "url": "https://opencollective.com/typescript-eslint"
+      }
+    },
+    "node_modules/@typescript-eslint/typescript-estree": {
+      "version": "7.18.0",
+      "resolved": "https://registry.npmjs.org/@typescript-eslint/typescript-estree/-/typescript-estree-7.18.0.tgz",
+      "integrity": "sha512-aP1v/BSPnnyhMHts8cf1qQ6Q1IFwwRvAQGRvBFkWlo3/lH29OXA3Pts+c10nxRxIBrDnoMqzhgdwVe5f2D6OzA==",
+      "dev": true,
+      "license": "BSD-2-Clause",
+      "dependencies": {
+        "@typescript-eslint/types": "7.18.0",
+        "@typescript-eslint/visitor-keys": "7.18.0",
+        "debug": "^4.3.4",
+        "globby": "^11.1.0",
+        "is-glob": "^4.0.3",
+        "minimatch": "^9.0.4",
+        "semver": "^7.6.0",
+        "ts-api-utils": "^1.3.0"
+      },
+      "engines": {
+        "node": "^18.18.0 || >=20.0.0"
+      },
+      "funding": {
+        "type": "opencollective",
+        "url": "https://opencollective.com/typescript-eslint"
+      },
+      "peerDependenciesMeta": {
+        "typescript": {
+          "optional": true
+        }
+      }
+    },
+    "node_modules/@typescript-eslint/utils": {
+      "version": "7.18.0",
+      "resolved": "https://registry.npmjs.org/@typescript-eslint/utils/-/utils-7.18.0.tgz",
+      "integrity": "sha512-kK0/rNa2j74XuHVcoCZxdFBMF+aq/vH83CXAOHieC+2Gis4mF8jJXT5eAfyD3K0sAxtPuwxaIOIOvhwzVDt/kw==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@eslint-community/eslint-utils": "^4.4.0",
+        "@typescript-eslint/scope-manager": "7.18.0",
+        "@typescript-eslint/types": "7.18.0",
+        "@typescript-eslint/typescript-estree": "7.18.0"
+      },
+      "engines": {
+        "node": "^18.18.0 || >=20.0.0"
+      },
+      "funding": {
+        "type": "opencollective",
+        "url": "https://opencollective.com/typescript-eslint"
+      },
+      "peerDependencies": {
+        "eslint": "^8.56.0"
+      }
+    },
+    "node_modules/@typescript-eslint/visitor-keys": {
+      "version": "7.18.0",
+      "resolved": "https://registry.npmjs.org/@typescript-eslint/visitor-keys/-/visitor-keys-7.18.0.tgz",
+      "integrity": "sha512-cDF0/Gf81QpY3xYyJKDV14Zwdmid5+uuENhjH2EqFaF0ni+yAyq/LzMaIJdhNJXZI7uLzwIlA+V7oWoyn6Curg==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@typescript-eslint/types": "7.18.0",
+        "eslint-visitor-keys": "^3.4.3"
+      },
+      "engines": {
+        "node": "^18.18.0 || >=20.0.0"
+      },
+      "funding": {
+        "type": "opencollective",
+        "url": "https://opencollective.com/typescript-eslint"
+      }
+    },
+    "node_modules/@ungap/structured-clone": {
+      "version": "1.3.0",
+      "resolved": "https://registry.npmjs.org/@ungap/structured-clone/-/structured-clone-1.3.0.tgz",
+      "integrity": "sha512-WmoN8qaIAo7WTYWbAZuG8PYEhn5fkz7dZrqTBZ7dtt//lL2Gwms1IcnQ5yHqjDfX8Ft5j4YzDM23f87zBfDe9g==",
+      "dev": true,
+      "license": "ISC"
+    },
+    "node_modules/@vis.gl/react-mapbox": {
+      "version": "8.1.0",
+      "resolved": "https://registry.npmjs.org/@vis.gl/react-mapbox/-/react-mapbox-8.1.0.tgz",
+      "integrity": "sha512-FwvH822oxEjWYOr+pP2L8hpv+7cZB2UsQbHHHT0ryrkvvqzmTgt7qHDhamv0EobKw86e1I+B4ojENdJ5G5BkyQ==",
+      "license": "MIT",
+      "peerDependencies": {
+        "mapbox-gl": ">=3.5.0",
+        "react": ">=16.3.0",
+        "react-dom": ">=16.3.0"
+      },
+      "peerDependenciesMeta": {
+        "mapbox-gl": {
+          "optional": true
+        }
+      }
+    },
+    "node_modules/@vis.gl/react-maplibre": {
+      "version": "8.1.0",
+      "resolved": "https://registry.npmjs.org/@vis.gl/react-maplibre/-/react-maplibre-8.1.0.tgz",
+      "integrity": "sha512-PkAK/gp3mUfhCLhUuc+4gc3PN9zCtVGxTF2hB6R5R5yYUw+hdg84OZ770U5MU4tPMTCG6fbduExuIW6RRKN6qQ==",
+      "license": "MIT",
+      "dependencies": {
+        "@maplibre/maplibre-gl-style-spec": "^19.2.1"
+      },
+      "peerDependencies": {
+        "maplibre-gl": ">=4.0.0",
+        "react": ">=16.3.0",
+        "react-dom": ">=16.3.0"
+      },
+      "peerDependenciesMeta": {
+        "maplibre-gl": {
+          "optional": true
+        }
+      }
+    },
+    "node_modules/@vis.gl/react-maplibre/node_modules/@maplibre/maplibre-gl-style-spec": {
+      "version": "19.3.3",
+      "resolved": "https://registry.npmjs.org/@maplibre/maplibre-gl-style-spec/-/maplibre-gl-style-spec-19.3.3.tgz",
+      "integrity": "sha512-cOZZOVhDSulgK0meTsTkmNXb1ahVvmTmWmfx9gRBwc6hq98wS9JP35ESIoNq3xqEan+UN+gn8187Z6E4NKhLsw==",
+      "license": "ISC",
+      "dependencies": {
+        "@mapbox/jsonlint-lines-primitives": "~2.0.2",
+        "@mapbox/unitbezier": "^0.0.1",
+        "json-stringify-pretty-compact": "^3.0.0",
+        "minimist": "^1.2.8",
+        "rw": "^1.3.3",
+        "sort-object": "^3.0.3"
+      },
+      "bin": {
+        "gl-style-format": "dist/gl-style-format.mjs",
+        "gl-style-migrate": "dist/gl-style-migrate.mjs",
+        "gl-style-validate": "dist/gl-style-validate.mjs"
+      }
+    },
+    "node_modules/@vis.gl/react-maplibre/node_modules/json-stringify-pretty-compact": {
+      "version": "3.0.0",
+      "resolved": "https://registry.npmjs.org/json-stringify-pretty-compact/-/json-stringify-pretty-compact-3.0.0.tgz",
+      "integrity": "sha512-Rc2suX5meI0S3bfdZuA7JMFBGkJ875ApfVyq2WHELjBiiG22My/l7/8zPpH/CfFVQHuVLd8NLR0nv6vi0BYYKA==",
+      "license": "MIT"
+    },
+    "node_modules/@vitejs/plugin-react": {
+      "version": "4.5.1",
+      "resolved": "https://registry.npmjs.org/@vitejs/plugin-react/-/plugin-react-4.5.1.tgz",
+      "integrity": "sha512-uPZBqSI0YD4lpkIru6M35sIfylLGTyhGHvDZbNLuMA73lMlwJKz5xweH7FajfcCAc2HnINciejA9qTz0dr0M7A==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@babel/core": "^7.26.10",
+        "@babel/plugin-transform-react-jsx-self": "^7.25.9",
+        "@babel/plugin-transform-react-jsx-source": "^7.25.9",
+        "@rolldown/pluginutils": "1.0.0-beta.9",
+        "@types/babel__core": "^7.20.5",
+        "react-refresh": "^0.17.0"
+      },
+      "engines": {
+        "node": "^14.18.0 || >=16.0.0"
+      },
+      "peerDependencies": {
+        "vite": "^4.2.0 || ^5.0.0 || ^6.0.0"
+      }
+    },
+    "node_modules/@vitest/expect": {
+      "version": "3.2.4",
+      "resolved": "https://registry.npmjs.org/@vitest/expect/-/expect-3.2.4.tgz",
+      "integrity": "sha512-Io0yyORnB6sikFlt8QW5K7slY4OjqNX9jmJQ02QDda8lyM6B5oNgVWoSoKPac8/kgnCUzuHQKrSLtu/uOqqrig==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@types/chai": "^5.2.2",
+        "@vitest/spy": "3.2.4",
+        "@vitest/utils": "3.2.4",
+        "chai": "^5.2.0",
+        "tinyrainbow": "^2.0.0"
+      },
+      "funding": {
+        "url": "https://opencollective.com/vitest"
+      }
+    },
+    "node_modules/@vitest/mocker": {
+      "version": "3.2.4",
+      "resolved": "https://registry.npmjs.org/@vitest/mocker/-/mocker-3.2.4.tgz",
+      "integrity": "sha512-46ryTE9RZO/rfDd7pEqFl7etuyzekzEhUbTW3BvmeO/BcCMEgq59BKhek3dXDWgAj4oMK6OZi+vRr1wPW6qjEQ==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@vitest/spy": "3.2.4",
+        "estree-walker": "^3.0.3",
+        "magic-string": "^0.30.17"
+      },
+      "funding": {
+        "url": "https://opencollective.com/vitest"
+      },
+      "peerDependencies": {
+        "msw": "^2.4.9",
+        "vite": "^5.0.0 || ^6.0.0 || ^7.0.0-0"
+      },
+      "peerDependenciesMeta": {
+        "msw": {
+          "optional": true
+        },
+        "vite": {
+          "optional": true
+        }
+      }
+    },
+    "node_modules/@vitest/pretty-format": {
+      "version": "3.2.4",
+      "resolved": "https://registry.npmjs.org/@vitest/pretty-format/-/pretty-format-3.2.4.tgz",
+      "integrity": "sha512-IVNZik8IVRJRTr9fxlitMKeJeXFFFN0JaB9PHPGQ8NKQbGpfjlTx9zO4RefN8gp7eqjNy8nyK3NZmBzOPeIxtA==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "tinyrainbow": "^2.0.0"
+      },
+      "funding": {
+        "url": "https://opencollective.com/vitest"
+      }
+    },
+    "node_modules/@vitest/runner": {
+      "version": "3.2.4",
+      "resolved": "https://registry.npmjs.org/@vitest/runner/-/runner-3.2.4.tgz",
+      "integrity": "sha512-oukfKT9Mk41LreEW09vt45f8wx7DordoWUZMYdY/cyAk7w5TWkTRCNZYF7sX7n2wB7jyGAl74OxgwhPgKaqDMQ==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@vitest/utils": "3.2.4",
+        "pathe": "^2.0.3",
+        "strip-literal": "^3.0.0"
+      },
+      "funding": {
+        "url": "https://opencollective.com/vitest"
+      }
+    },
+    "node_modules/@vitest/snapshot": {
+      "version": "3.2.4",
+      "resolved": "https://registry.npmjs.org/@vitest/snapshot/-/snapshot-3.2.4.tgz",
+      "integrity": "sha512-dEYtS7qQP2CjU27QBC5oUOxLE/v5eLkGqPE0ZKEIDGMs4vKWe7IjgLOeauHsR0D5YuuycGRO5oSRXnwnmA78fQ==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@vitest/pretty-format": "3.2.4",
+        "magic-string": "^0.30.17",
+        "pathe": "^2.0.3"
+      },
+      "funding": {
+        "url": "https://opencollective.com/vitest"
+      }
+    },
+    "node_modules/@vitest/spy": {
+      "version": "3.2.4",
+      "resolved": "https://registry.npmjs.org/@vitest/spy/-/spy-3.2.4.tgz",
+      "integrity": "sha512-vAfasCOe6AIK70iP5UD11Ac4siNUNJ9i/9PZ3NKx07sG6sUxeag1LWdNrMWeKKYBLlzuK+Gn65Yd5nyL6ds+nw==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "tinyspy": "^4.0.3"
+      },
+      "funding": {
+        "url": "https://opencollective.com/vitest"
+      }
+    },
+    "node_modules/@vitest/utils": {
+      "version": "3.2.4",
+      "resolved": "https://registry.npmjs.org/@vitest/utils/-/utils-3.2.4.tgz",
+      "integrity": "sha512-fB2V0JFrQSMsCo9HiSq3Ezpdv4iYaXRG1Sx8edX3MwxfyNn83mKiGzOcH+Fkxt4MHxr3y42fQi1oeAInqgX2QA==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@vitest/pretty-format": "3.2.4",
+        "loupe": "^3.1.4",
+        "tinyrainbow": "^2.0.0"
+      },
+      "funding": {
+        "url": "https://opencollective.com/vitest"
+      }
+    },
+    "node_modules/abs-svg-path": {
+      "version": "0.1.1",
+      "resolved": "https://registry.npmjs.org/abs-svg-path/-/abs-svg-path-0.1.1.tgz",
+      "integrity": "sha512-d8XPSGjfyzlXC3Xx891DJRyZfqk5JU0BJrDQcsWomFIV1/BIzPW5HDH5iDdWpqWaav0YVIEzT1RHTwWr0FFshA==",
+      "license": "MIT",
+      "peer": true
+    },
+    "node_modules/acorn": {
+      "version": "8.14.1",
+      "resolved": "https://registry.npmjs.org/acorn/-/acorn-8.14.1.tgz",
+      "integrity": "sha512-OvQ/2pUDKmgfCg++xsTX1wGxfTaszcHVcTctW4UJB4hibJx2HXxxO5UmVgyjMa+ZDsiaf5wWLXYpRWMmBI0QHg==",
+      "dev": true,
+      "license": "MIT",
+      "bin": {
+        "acorn": "bin/acorn"
+      },
+      "engines": {
+        "node": ">=0.4.0"
+      }
+    },
+    "node_modules/acorn-jsx": {
+      "version": "5.3.2",
+      "resolved": "https://registry.npmjs.org/acorn-jsx/-/acorn-jsx-5.3.2.tgz",
+      "integrity": "sha512-rq9s+JNhf0IChjtDXxllJ7g41oZk5SlXtp0LHwyA5cejwn7vKmKp4pPri6YEePv2PU65sAsegbXtIinmDFDXgQ==",
+      "dev": true,
+      "license": "MIT",
+      "peerDependencies": {
+        "acorn": "^6.0.0 || ^7.0.0 || ^8.0.0"
+      }
+    },
+    "node_modules/agent-base": {
+      "version": "7.1.4",
+      "resolved": "https://registry.npmjs.org/agent-base/-/agent-base-7.1.4.tgz",
+      "integrity": "sha512-MnA+YT8fwfJPgBx3m60MNqakm30XOkyIoH1y6huTQvC0PwZG7ki8NacLBcrPbNoo8vEZy7Jpuk7+jMO+CUovTQ==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">= 14"
+      }
+    },
+    "node_modules/ajv": {
+      "version": "6.12.6",
+      "resolved": "https://registry.npmjs.org/ajv/-/ajv-6.12.6.tgz",
+      "integrity": "sha512-j3fVLgvTo527anyYyJOGTYJbG+vnnQYvE0m5mmkc1TK+nxAppkCLMIL0aZ4dblVCNoGShhm+kzE4ZUykBoMg4g==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "fast-deep-equal": "^3.1.1",
+        "fast-json-stable-stringify": "^2.0.0",
+        "json-schema-traverse": "^0.4.1",
+        "uri-js": "^4.2.2"
+      },
+      "funding": {
+        "type": "github",
+        "url": "https://github.com/sponsors/epoberezkin"
+      }
+    },
+    "node_modules/ansi-regex": {
+      "version": "5.0.1",
+      "resolved": "https://registry.npmjs.org/ansi-regex/-/ansi-regex-5.0.1.tgz",
+      "integrity": "sha512-quJQXlTSUGL2LH9SUXo8VwsY4soanhgo6LNSm84E1LBcE8s3O0wpdiRzyR9z/ZZJMlMWv37qOOb9pdJlMUEKFQ==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">=8"
+      }
+    },
+    "node_modules/ansi-styles": {
+      "version": "4.3.0",
+      "resolved": "https://registry.npmjs.org/ansi-styles/-/ansi-styles-4.3.0.tgz",
+      "integrity": "sha512-zbB9rCJAT1rbjiVDb2hqKFHNYLxgtk8NURxZ3IZwD3F6NtxbXZQCnnSi1Lkx+IDohdPlFp222wVALIheZJQSEg==",
+      "license": "MIT",
+      "dependencies": {
+        "color-convert": "^2.0.1"
+      },
+      "engines": {
+        "node": ">=8"
+      },
+      "funding": {
+        "url": "https://github.com/chalk/ansi-styles?sponsor=1"
+      }
+    },
+    "node_modules/apache-arrow": {
+      "version": "21.1.0",
+      "resolved": "https://registry.npmjs.org/apache-arrow/-/apache-arrow-21.1.0.tgz",
+      "integrity": "sha512-kQrYLxhC+NTVVZ4CCzGF6L/uPVOzJmD1T3XgbiUnP7oTeVFOFgEUu6IKNwCDkpFoBVqDKQivlX4RUFqqnWFlEA==",
+      "license": "Apache-2.0",
+      "dependencies": {
+        "@swc/helpers": "^0.5.11",
+        "@types/command-line-args": "^5.2.3",
+        "@types/command-line-usage": "^5.0.4",
+        "@types/node": "^24.0.3",
+        "command-line-args": "^6.0.1",
+        "command-line-usage": "^7.0.1",
+        "flatbuffers": "^25.1.24",
+        "json-bignum": "^0.0.3",
+        "tslib": "^2.6.2"
+      },
+      "bin": {
+        "arrow2csv": "bin/arrow2csv.js"
+      }
+    },
+    "node_modules/argparse": {
+      "version": "2.0.1",
+      "resolved": "https://registry.npmjs.org/argparse/-/argparse-2.0.1.tgz",
+      "integrity": "sha512-8+9WqebbFzpX9OR+Wa6O29asIogeRMzcGtAINdpMHHyAg10f05aSFVBbcEqGf/PXw1EjAZ+q2/bEBg3DvurK3Q==",
+      "dev": true,
+      "license": "Python-2.0"
+    },
+    "node_modules/aria-query": {
+      "version": "5.3.0",
+      "resolved": "https://registry.npmjs.org/aria-query/-/aria-query-5.3.0.tgz",
+      "integrity": "sha512-b0P0sZPKtyu8HkeRAfCq0IfURZK+SuwMjY1UXGBU27wpAiTwQAIlq56IbIO+ytk/JjS1fMR14ee5WBBfKi5J6A==",
+      "dev": true,
+      "license": "Apache-2.0",
+      "dependencies": {
+        "dequal": "^2.0.3"
+      }
+    },
+    "node_modules/arr-union": {
+      "version": "3.1.0",
+      "resolved": "https://registry.npmjs.org/arr-union/-/arr-union-3.1.0.tgz",
+      "integrity": "sha512-sKpyeERZ02v1FeCZT8lrfJq5u6goHCtpTAzPwJYe7c8SPFOboNjNg1vz2L4VTn9T4PQxEx13TbXLmYUcS6Ug7Q==",
+      "license": "MIT",
+      "engines": {
+        "node": ">=0.10.0"
+      }
+    },
+    "node_modules/array-back": {
+      "version": "6.2.3",
+      "resolved": "https://registry.npmjs.org/array-back/-/array-back-6.2.3.tgz",
+      "integrity": "sha512-SGDvmg6QTYiTxCBkYVmThcoa67uLl35pyzRHdpCGBOcqFy6BtwnphoFPk7LhJshD+Yk1Kt35WGWeZPTgwR4Fhw==",
+      "license": "MIT",
+      "engines": {
+        "node": ">=12.17"
+      }
+    },
+    "node_modules/array-bounds": {
+      "version": "1.0.1",
+      "resolved": "https://registry.npmjs.org/array-bounds/-/array-bounds-1.0.1.tgz",
+      "integrity": "sha512-8wdW3ZGk6UjMPJx/glyEt0sLzzwAE1bhToPsO1W2pbpR2gULyxe3BjSiuJFheP50T/GgODVPz2fuMUmIywt8cQ==",
+      "license": "MIT",
+      "peer": true
+    },
+    "node_modules/array-find-index": {
+      "version": "1.0.2",
+      "resolved": "https://registry.npmjs.org/array-find-index/-/array-find-index-1.0.2.tgz",
+      "integrity": "sha512-M1HQyIXcBGtVywBt8WVdim+lrNaK7VHp99Qt5pSNziXznKHViIBbXWtfRTpEFpF/c4FdfxNAsCCwPp5phBYJtw==",
+      "license": "MIT",
+      "peer": true,
+      "engines": {
+        "node": ">=0.10.0"
+      }
+    },
+    "node_modules/array-normalize": {
+      "version": "1.1.4",
+      "resolved": "https://registry.npmjs.org/array-normalize/-/array-normalize-1.1.4.tgz",
+      "integrity": "sha512-fCp0wKFLjvSPmCn4F5Tiw4M3lpMZoHlCjfcs7nNzuj3vqQQ1/a8cgB9DXcpDSn18c+coLnaW7rqfcYCvKbyJXg==",
+      "license": "MIT",
+      "peer": true,
+      "dependencies": {
+        "array-bounds": "^1.0.0"
+      }
+    },
+    "node_modules/array-range": {
+      "version": "1.0.1",
+      "resolved": "https://registry.npmjs.org/array-range/-/array-range-1.0.1.tgz",
+      "integrity": "sha512-shdaI1zT3CVNL2hnx9c0JMc0ZogGaxDs5e85akgHWKYa0yVbIyp06Ind3dVkTj/uuFrzaHBOyqFzo+VV6aXgtA==",
+      "license": "MIT",
+      "peer": true
+    },
+    "node_modules/array-rearrange": {
+      "version": "2.2.2",
+      "resolved": "https://registry.npmjs.org/array-rearrange/-/array-rearrange-2.2.2.tgz",
+      "integrity": "sha512-UfobP5N12Qm4Qu4fwLDIi2v6+wZsSf6snYSxAMeKhrh37YGnNWZPRmVEKc/2wfms53TLQnzfpG8wCx2Y/6NG1w==",
+      "license": "MIT",
+      "peer": true
+    },
+    "node_modules/array-union": {
+      "version": "2.1.0",
+      "resolved": "https://registry.npmjs.org/array-union/-/array-union-2.1.0.tgz",
+      "integrity": "sha512-HGyxoOTYUyCM6stUe6EJgnd4EoewAI7zMdfqO+kGjnlZmBDz/cR5pf8r/cR4Wq60sL/p0IkcjUEEPwS3GFrIyw==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">=8"
+      }
+    },
+    "node_modules/assertion-error": {
+      "version": "2.0.1",
+      "resolved": "https://registry.npmjs.org/assertion-error/-/assertion-error-2.0.1.tgz",
+      "integrity": "sha512-Izi8RQcffqCeNVgFigKli1ssklIbpHnCYc6AknXGYoB6grJqyeby7jv12JUQgmTAnIDnbck1uxksT4dzN3PWBA==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">=12"
+      }
+    },
+    "node_modules/assign-symbols": {
+      "version": "1.0.0",
+      "resolved": "https://registry.npmjs.org/assign-symbols/-/assign-symbols-1.0.0.tgz",
+      "integrity": "sha512-Q+JC7Whu8HhmTdBph/Tq59IoRtoy6KAm5zzPv00WdujX82lbAL8K7WVjne7vdCsAmbF4AYaDOPyO3k0kl8qIrw==",
+      "license": "MIT",
+      "engines": {
+        "node": ">=0.10.0"
+      }
+    },
+    "node_modules/balanced-match": {
+      "version": "1.0.2",
+      "resolved": "https://registry.npmjs.org/balanced-match/-/balanced-match-1.0.2.tgz",
+      "integrity": "sha512-3oSeUO0TMV67hN1AmbXsK4yaqU7tjiHlbxRDZOpH0KW9+CeX4bRAaX0Anxt0tx2MrpRpWwQaPwIlISEJhYU5Pw==",
+      "dev": true,
+      "license": "MIT"
+    },
+    "node_modules/base64-arraybuffer": {
+      "version": "1.0.2",
+      "resolved": "https://registry.npmjs.org/base64-arraybuffer/-/base64-arraybuffer-1.0.2.tgz",
+      "integrity": "sha512-I3yl4r9QB5ZRY3XuJVEPfc2XhZO6YweFPI+UovAzn+8/hb3oJ6lnysaFcjVpkCPfVWFUDvoZ8kmVDP7WyRtYtQ==",
+      "license": "MIT",
+      "peer": true,
+      "engines": {
+        "node": ">= 0.6.0"
+      }
+    },
+    "node_modules/bidi-js": {
+      "version": "1.0.3",
+      "resolved": "https://registry.npmjs.org/bidi-js/-/bidi-js-1.0.3.tgz",
+      "integrity": "sha512-RKshQI1R3YQ+n9YJz2QQ147P66ELpa1FQEg20Dk8oW9t2KgLbpDLLp9aGZ7y8WHSshDknG0bknqGw5/tyCs5tw==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "require-from-string": "^2.0.2"
+      }
+    },
+    "node_modules/binary-search-bounds": {
+      "version": "2.0.5",
+      "resolved": "https://registry.npmjs.org/binary-search-bounds/-/binary-search-bounds-2.0.5.tgz",
+      "integrity": "sha512-H0ea4Fd3lS1+sTEB2TgcLoK21lLhwEJzlQv3IN47pJS976Gx4zoWe0ak3q+uYh60ppQxg9F16Ri4tS1sfD4+jA==",
+      "license": "MIT",
+      "peer": true
+    },
+    "node_modules/bit-twiddle": {
+      "version": "1.0.2",
+      "resolved": "https://registry.npmjs.org/bit-twiddle/-/bit-twiddle-1.0.2.tgz",
+      "integrity": "sha512-B9UhK0DKFZhoTFcfvAzhqsjStvGJp9vYWf3+6SNTtdSQnvIgfkHbgHrg/e4+TH71N2GDu8tpmCVoyfrL1d7ntA==",
+      "license": "MIT",
+      "peer": true
+    },
+    "node_modules/bitmap-sdf": {
+      "version": "1.0.4",
+      "resolved": "https://registry.npmjs.org/bitmap-sdf/-/bitmap-sdf-1.0.4.tgz",
+      "integrity": "sha512-1G3U4n5JE6RAiALMxu0p1XmeZkTeCwGKykzsLTCqVzfSDaN6S7fKnkIkfejogz+iwqBWc0UYAIKnKHNN7pSfDg==",
+      "license": "MIT",
+      "peer": true
+    },
+    "node_modules/bl": {
+      "version": "2.2.1",
+      "resolved": "https://registry.npmjs.org/bl/-/bl-2.2.1.tgz",
+      "integrity": "sha512-6Pesp1w0DEX1N550i/uGV/TqucVL4AM/pgThFSN/Qq9si1/DF9aIHs1BxD8V/QU0HoeHO6cQRTAuYnLPKq1e4g==",
+      "license": "MIT",
+      "peer": true,
+      "dependencies": {
+        "readable-stream": "^2.3.5",
+        "safe-buffer": "^5.1.1"
+      }
+    },
+    "node_modules/brace-expansion": {
+      "version": "2.0.1",
+      "resolved": "https://registry.npmjs.org/brace-expansion/-/brace-expansion-2.0.1.tgz",
+      "integrity": "sha512-XnAIvQ8eM+kC6aULx6wuQiwVsnzsi9d3WxzV3FpWTGA19F621kwdbsAcFKXgKUHZWsy+mY6iL1sHTxWEFCytDA==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "balanced-match": "^1.0.0"
+      }
+    },
+    "node_modules/braces": {
+      "version": "3.0.3",
+      "resolved": "https://registry.npmjs.org/braces/-/braces-3.0.3.tgz",
+      "integrity": "sha512-yQbXgO/OSZVD2IsiLlro+7Hf6Q18EJrKSEsdoMzKePKXct3gvD8oLcOQdIzGupr5Fj+EDe8gO/lxc1BzfMpxvA==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "fill-range": "^7.1.1"
+      },
+      "engines": {
+        "node": ">=8"
+      }
+    },
+    "node_modules/browserslist": {
+      "version": "4.25.0",
+      "resolved": "https://registry.npmjs.org/browserslist/-/browserslist-4.25.0.tgz",
+      "integrity": "sha512-PJ8gYKeS5e/whHBh8xrwYK+dAvEj7JXtz6uTucnMRB8OiGTsKccFekoRrjajPBHV8oOY+2tI4uxeceSimKwMFA==",
+      "dev": true,
+      "funding": [
+        {
+          "type": "opencollective",
+          "url": "https://opencollective.com/browserslist"
+        },
+        {
+          "type": "tidelift",
+          "url": "https://tidelift.com/funding/github/npm/browserslist"
+        },
+        {
+          "type": "github",
+          "url": "https://github.com/sponsors/ai"
+        }
+      ],
+      "license": "MIT",
+      "dependencies": {
+        "caniuse-lite": "^1.0.30001718",
+        "electron-to-chromium": "^1.5.160",
+        "node-releases": "^2.0.19",
+        "update-browserslist-db": "^1.1.3"
+      },
+      "bin": {
+        "browserslist": "cli.js"
+      },
+      "engines": {
+        "node": "^6 || ^7 || ^8 || ^9 || ^10 || ^11 || ^12 || >=13.7"
+      }
+    },
+    "node_modules/buffer-from": {
+      "version": "1.1.2",
+      "resolved": "https://registry.npmjs.org/buffer-from/-/buffer-from-1.1.2.tgz",
+      "integrity": "sha512-E+XQCRwSbaaiChtv6k6Dwgc+bx+Bs6vuKJHHl5kox/BaKbhiXzqQOwK4cO22yElGp2OCmjwVhT3HmxgyPGnJfQ==",
+      "license": "MIT",
+      "peer": true
+    },
+    "node_modules/bytewise": {
+      "version": "1.1.0",
+      "resolved": "https://registry.npmjs.org/bytewise/-/bytewise-1.1.0.tgz",
+      "integrity": "sha512-rHuuseJ9iQ0na6UDhnrRVDh8YnWVlU6xM3VH6q/+yHDeUH2zIhUzP+2/h3LIrhLDBtTqzWpE3p3tP/boefskKQ==",
+      "license": "MIT",
+      "dependencies": {
+        "bytewise-core": "^1.2.2",
+        "typewise": "^1.0.3"
+      }
+    },
+    "node_modules/bytewise-core": {
+      "version": "1.2.3",
+      "resolved": "https://registry.npmjs.org/bytewise-core/-/bytewise-core-1.2.3.tgz",
+      "integrity": "sha512-nZD//kc78OOxeYtRlVk8/zXqTB4gf/nlguL1ggWA8FuchMyOxcyHR4QPQZMUmA7czC+YnaBrPUCubqAWe50DaA==",
+      "license": "MIT",
+      "dependencies": {
+        "typewise-core": "^1.2"
+      }
+    },
+    "node_modules/cac": {
+      "version": "6.7.14",
+      "resolved": "https://registry.npmjs.org/cac/-/cac-6.7.14.tgz",
+      "integrity": "sha512-b6Ilus+c3RrdDk+JhLKUAQfzzgLEPy6wcXqS7f/xe1EETvsDP6GORG7SFuOs6cID5YkqchW/LXZbX5bc8j7ZcQ==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">=8"
+      }
+    },
+    "node_modules/callsites": {
+      "version": "3.1.0",
+      "resolved": "https://registry.npmjs.org/callsites/-/callsites-3.1.0.tgz",
+      "integrity": "sha512-P8BjAsXvZS+VIDUI11hHCQEv74YT67YUi5JJFNWIqL235sBmjX4+qx9Muvls5ivyNENctx46xQLQ3aTuE7ssaQ==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">=6"
+      }
+    },
+    "node_modules/caniuse-lite": {
+      "version": "1.0.30001721",
+      "resolved": "https://registry.npmjs.org/caniuse-lite/-/caniuse-lite-1.0.30001721.tgz",
+      "integrity": "sha512-cOuvmUVtKrtEaoKiO0rSc29jcjwMwX5tOHDy4MgVFEWiUXj4uBMJkwI8MDySkgXidpMiHUcviogAvFi4pA2hDQ==",
+      "dev": true,
+      "funding": [
+        {
+          "type": "opencollective",
+          "url": "https://opencollective.com/browserslist"
+        },
+        {
+          "type": "tidelift",
+          "url": "https://tidelift.com/funding/github/npm/caniuse-lite"
+        },
+        {
+          "type": "github",
+          "url": "https://github.com/sponsors/ai"
+        }
+      ],
+      "license": "CC-BY-4.0"
+    },
+    "node_modules/canvas-fit": {
+      "version": "1.5.0",
+      "resolved": "https://registry.npmjs.org/canvas-fit/-/canvas-fit-1.5.0.tgz",
+      "integrity": "sha512-onIcjRpz69/Hx5bB5HGbYKUF2uC6QT6Gp+pfpGm3A7mPfcluSLV5v4Zu+oflDUwLdUw0rLIBhUbi0v8hM4FJQQ==",
+      "license": "MIT",
+      "peer": true,
+      "dependencies": {
+        "element-size": "^1.1.1"
+      }
+    },
+    "node_modules/chai": {
+      "version": "5.3.3",
+      "resolved": "https://registry.npmjs.org/chai/-/chai-5.3.3.tgz",
+      "integrity": "sha512-4zNhdJD/iOjSH0A05ea+Ke6MU5mmpQcbQsSOkgdaUMJ9zTlDTD/GYlwohmIE2u0gaxHYiVHEn1Fw9mZ/ktJWgw==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "assertion-error": "^2.0.1",
+        "check-error": "^2.1.1",
+        "deep-eql": "^5.0.1",
+        "loupe": "^3.1.0",
+        "pathval": "^2.0.0"
+      },
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/chalk": {
+      "version": "4.1.2",
+      "resolved": "https://registry.npmjs.org/chalk/-/chalk-4.1.2.tgz",
+      "integrity": "sha512-oKnbhFyRIXpUuez8iBMmyEa4nbj4IOQyuhc/wy9kY7/WVPcwIO9VA668Pu8RkO7+0G76SLROeyw9CpQ061i4mA==",
+      "license": "MIT",
+      "dependencies": {
+        "ansi-styles": "^4.1.0",
+        "supports-color": "^7.1.0"
+      },
+      "engines": {
+        "node": ">=10"
+      },
+      "funding": {
+        "url": "https://github.com/chalk/chalk?sponsor=1"
+      }
+    },
+    "node_modules/chalk-template": {
+      "version": "0.4.0",
+      "resolved": "https://registry.npmjs.org/chalk-template/-/chalk-template-0.4.0.tgz",
+      "integrity": "sha512-/ghrgmhfY8RaSdeo43hNXxpoHAtxdbskUHjPpfqUWGttFgycUhYPGx3YZBCnUCvOa7Doivn1IZec3DEGFoMgLg==",
+      "license": "MIT",
+      "dependencies": {
+        "chalk": "^4.1.2"
+      },
+      "engines": {
+        "node": ">=12"
+      },
+      "funding": {
+        "url": "https://github.com/chalk/chalk-template?sponsor=1"
+      }
+    },
+    "node_modules/chart.js": {
+      "version": "4.4.9",
+      "resolved": "https://registry.npmjs.org/chart.js/-/chart.js-4.4.9.tgz",
+      "integrity": "sha512-EyZ9wWKgpAU0fLJ43YAEIF8sr5F2W3LqbS40ZJyHIner2lY14ufqv2VMp69MAiZ2rpwxEUxEhIH/0U3xyRynxg==",
+      "license": "MIT",
+      "dependencies": {
+        "@kurkle/color": "^0.3.0"
+      },
+      "engines": {
+        "pnpm": ">=8"
+      }
+    },
+    "node_modules/chartjs-adapter-date-fns": {
+      "version": "3.0.0",
+      "resolved": "https://registry.npmjs.org/chartjs-adapter-date-fns/-/chartjs-adapter-date-fns-3.0.0.tgz",
+      "integrity": "sha512-Rs3iEB3Q5pJ973J93OBTpnP7qoGwvq3nUnoMdtxO+9aoJof7UFcRbWcIDteXuYd1fgAvct/32T9qaLyLuZVwCg==",
+      "license": "MIT",
+      "peerDependencies": {
+        "chart.js": ">=2.8.0",
+        "date-fns": ">=2.0.0"
+      }
+    },
+    "node_modules/cheap-ruler": {
+      "version": "4.0.0",
+      "resolved": "https://registry.npmjs.org/cheap-ruler/-/cheap-ruler-4.0.0.tgz",
+      "integrity": "sha512-0BJa8f4t141BYKQyn9NSQt1PguFQXMXwZiA5shfoaBYHAb2fFk2RAX+tiWMoQU+Agtzt3mdt0JtuyshAXqZ+Vw==",
+      "license": "ISC",
+      "optional": true,
+      "peer": true
+    },
+    "node_modules/check-error": {
+      "version": "2.1.1",
+      "resolved": "https://registry.npmjs.org/check-error/-/check-error-2.1.1.tgz",
+      "integrity": "sha512-OAlb+T7V4Op9OwdkjmguYRqncdlx5JiofwOAUkmTF+jNdHwzTaTs4sRAGpzLF3oOz5xAyDGrPgeIDFQmDOTiJw==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">= 16"
+      }
+    },
+    "node_modules/clamp": {
+      "version": "1.0.1",
+      "resolved": "https://registry.npmjs.org/clamp/-/clamp-1.0.1.tgz",
+      "integrity": "sha512-kgMuFyE78OC6Dyu3Dy7vcx4uy97EIbVxJB/B0eJ3bUNAkwdNcxYzgKltnyADiYwsR7SEqkkUPsEUT//OVS6XMA==",
+      "license": "MIT",
+      "peer": true
+    },
+    "node_modules/color-alpha": {
+      "version": "1.0.4",
+      "resolved": "https://registry.npmjs.org/color-alpha/-/color-alpha-1.0.4.tgz",
+      "integrity": "sha512-lr8/t5NPozTSqli+duAN+x+no/2WaKTeWvxhHGN+aXT6AJ8vPlzLa7UriyjWak0pSC2jHol9JgjBYnnHsGha9A==",
+      "license": "MIT",
+      "peer": true,
+      "dependencies": {
+        "color-parse": "^1.3.8"
+      }
+    },
+    "node_modules/color-alpha/node_modules/color-parse": {
+      "version": "1.4.3",
+      "resolved": "https://registry.npmjs.org/color-parse/-/color-parse-1.4.3.tgz",
+      "integrity": "sha512-BADfVl/FHkQkyo8sRBwMYBqemqsgnu7JZAwUgvBvuwwuNUZAhSvLTbsEErS5bQXzOjDR0dWzJ4vXN2Q+QoPx0A==",
+      "license": "MIT",
+      "peer": true,
+      "dependencies": {
+        "color-name": "^1.0.0"
+      }
+    },
+    "node_modules/color-convert": {
+      "version": "2.0.1",
+      "resolved": "https://registry.npmjs.org/color-convert/-/color-convert-2.0.1.tgz",
+      "integrity": "sha512-RRECPsj7iu/xb5oKYcsFHSppFNnsj/52OVTRKb4zP5onXwVF3zVmmToNcOfGC+CRDpfK/U584fMg38ZHCaElKQ==",
+      "license": "MIT",
+      "dependencies": {
+        "color-name": "~1.1.4"
+      },
+      "engines": {
+        "node": ">=7.0.0"
+      }
+    },
+    "node_modules/color-id": {
+      "version": "1.1.0",
+      "resolved": "https://registry.npmjs.org/color-id/-/color-id-1.1.0.tgz",
+      "integrity": "sha512-2iRtAn6dC/6/G7bBIo0uupVrIne1NsQJvJxZOBCzQOfk7jRq97feaDZ3RdzuHakRXXnHGNwglto3pqtRx1sX0g==",
+      "license": "MIT",
+      "peer": true,
+      "dependencies": {
+        "clamp": "^1.0.1"
+      }
+    },
+    "node_modules/color-name": {
+      "version": "1.1.4",
+      "resolved": "https://registry.npmjs.org/color-name/-/color-name-1.1.4.tgz",
+      "integrity": "sha512-dOy+3AuW3a2wNbZHIuMZpTcgjGuLU/uBL/ubcZF9OXbDo8ff4O8yVp5Bf0efS8uEoYo5q4Fx7dY9OgQGXgAsQA==",
+      "license": "MIT"
+    },
+    "node_modules/color-normalize": {
+      "version": "1.5.0",
+      "resolved": "https://registry.npmjs.org/color-normalize/-/color-normalize-1.5.0.tgz",
+      "integrity": "sha512-rUT/HDXMr6RFffrR53oX3HGWkDOP9goSAQGBkUaAYKjOE2JxozccdGyufageWDlInRAjm/jYPrf/Y38oa+7obw==",
+      "license": "MIT",
+      "peer": true,
+      "dependencies": {
+        "clamp": "^1.0.1",
+        "color-rgba": "^2.1.1",
+        "dtype": "^2.0.0"
+      }
+    },
+    "node_modules/color-normalize/node_modules/color-parse": {
+      "version": "1.4.3",
+      "resolved": "https://registry.npmjs.org/color-parse/-/color-parse-1.4.3.tgz",
+      "integrity": "sha512-BADfVl/FHkQkyo8sRBwMYBqemqsgnu7JZAwUgvBvuwwuNUZAhSvLTbsEErS5bQXzOjDR0dWzJ4vXN2Q+QoPx0A==",
+      "license": "MIT",
+      "peer": true,
+      "dependencies": {
+        "color-name": "^1.0.0"
+      }
+    },
+    "node_modules/color-normalize/node_modules/color-rgba": {
+      "version": "2.4.0",
+      "resolved": "https://registry.npmjs.org/color-rgba/-/color-rgba-2.4.0.tgz",
+      "integrity": "sha512-Nti4qbzr/z2LbUWySr7H9dk3Rl7gZt7ihHAxlgT4Ho90EXWkjtkL1avTleu9yeGuqrt/chxTB6GKK8nZZ6V0+Q==",
+      "license": "MIT",
+      "peer": true,
+      "dependencies": {
+        "color-parse": "^1.4.2",
+        "color-space": "^2.0.0"
+      }
+    },
+    "node_modules/color-parse": {
+      "version": "2.0.0",
+      "resolved": "https://registry.npmjs.org/color-parse/-/color-parse-2.0.0.tgz",
+      "integrity": "sha512-g2Z+QnWsdHLppAbrpcFWo629kLOnOPtpxYV69GCqm92gqSgyXbzlfyN3MXs0412fPBkFmiuS+rXposgBgBa6Kg==",
+      "license": "MIT",
+      "peer": true,
+      "dependencies": {
+        "color-name": "^1.0.0"
+      }
+    },
+    "node_modules/color-rgba": {
+      "version": "3.0.0",
+      "resolved": "https://registry.npmjs.org/color-rgba/-/color-rgba-3.0.0.tgz",
+      "integrity": "sha512-PPwZYkEY3M2THEHHV6Y95sGUie77S7X8v+h1r6LSAPF3/LL2xJ8duUXSrkic31Nzc4odPwHgUbiX/XuTYzQHQg==",
+      "license": "MIT",
+      "peer": true,
+      "dependencies": {
+        "color-parse": "^2.0.0",
+        "color-space": "^2.0.0"
+      }
+    },
+    "node_modules/color-space": {
+      "version": "2.3.2",
+      "resolved": "https://registry.npmjs.org/color-space/-/color-space-2.3.2.tgz",
+      "integrity": "sha512-BcKnbOEsOarCwyoLstcoEztwT0IJxqqQkNwDuA3a65sICvvHL2yoeV13psoDFh5IuiOMnIOKdQDwB4Mk3BypiA==",
+      "license": "Unlicense",
+      "peer": true
+    },
+    "node_modules/command-line-args": {
+      "version": "6.0.1",
+      "resolved": "https://registry.npmjs.org/command-line-args/-/command-line-args-6.0.1.tgz",
+      "integrity": "sha512-Jr3eByUjqyK0qd8W0SGFW1nZwqCaNCtbXjRo2cRJC1OYxWl3MZ5t1US3jq+cO4sPavqgw4l9BMGX0CBe+trepg==",
+      "license": "MIT",
+      "dependencies": {
+        "array-back": "^6.2.2",
+        "find-replace": "^5.0.2",
+        "lodash.camelcase": "^4.3.0",
+        "typical": "^7.2.0"
+      },
+      "engines": {
+        "node": ">=12.20"
+      },
+      "peerDependencies": {
+        "@75lb/nature": "latest"
+      },
+      "peerDependenciesMeta": {
+        "@75lb/nature": {
+          "optional": true
+        }
+      }
+    },
+    "node_modules/command-line-usage": {
+      "version": "7.0.4",
+      "resolved": "https://registry.npmjs.org/command-line-usage/-/command-line-usage-7.0.4.tgz",
+      "integrity": "sha512-85UdvzTNx/+s5CkSgBm/0hzP80RFHAa7PsfeADE5ezZF3uHz3/Tqj9gIKGT9PTtpycc3Ua64T0oVulGfKxzfqg==",
+      "license": "MIT",
+      "dependencies": {
+        "array-back": "^6.2.2",
+        "chalk-template": "^0.4.0",
+        "table-layout": "^4.1.1",
+        "typical": "^7.3.0"
+      },
+      "engines": {
+        "node": ">=12.20.0"
+      }
+    },
+    "node_modules/commander": {
+      "version": "2.20.3",
+      "resolved": "https://registry.npmjs.org/commander/-/commander-2.20.3.tgz",
+      "integrity": "sha512-GpVkmM8vF2vQUkj2LvZmD35JxeJOLCwJ9cUkugyk2nuhbv3+mJvpLYYt+0+USMxE+oj+ey/lJEnhZw75x/OMcQ==",
+      "license": "MIT",
+      "peer": true
+    },
+    "node_modules/concat-map": {
+      "version": "0.0.1",
+      "resolved": "https://registry.npmjs.org/concat-map/-/concat-map-0.0.1.tgz",
+      "integrity": "sha512-/Srv4dswyQNBfohGpz9o6Yb3Gz3SrUDqBH5rTuhGR7ahtlbYKnVxw2bCFMRljaA7EXHaXZ8wsHdodFvbkhKmqg==",
+      "dev": true,
+      "license": "MIT"
+    },
+    "node_modules/concat-stream": {
+      "version": "1.6.2",
+      "resolved": "https://registry.npmjs.org/concat-stream/-/concat-stream-1.6.2.tgz",
+      "integrity": "sha512-27HBghJxjiZtIk3Ycvn/4kbJk/1uZuJFfuPEns6LaEvpvG1f0hTea8lilrouyo9mVc2GWdcEZ8OLoGmSADlrCw==",
+      "engines": [
+        "node >= 0.8"
+      ],
+      "license": "MIT",
+      "peer": true,
+      "dependencies": {
+        "buffer-from": "^1.0.0",
+        "inherits": "^2.0.3",
+        "readable-stream": "^2.2.2",
+        "typedarray": "^0.0.6"
+      }
+    },
+    "node_modules/convert-source-map": {
+      "version": "2.0.0",
+      "resolved": "https://registry.npmjs.org/convert-source-map/-/convert-source-map-2.0.0.tgz",
+      "integrity": "sha512-Kvp459HrV2FEJ1CAsi1Ku+MY3kasH19TFykTz2xWmMeq6bk2NU3XXvfJ+Q61m0xktWwt+1HSYf3JZsTms3aRJg==",
+      "dev": true,
+      "license": "MIT"
+    },
+    "node_modules/core-util-is": {
+      "version": "1.0.3",
+      "resolved": "https://registry.npmjs.org/core-util-is/-/core-util-is-1.0.3.tgz",
+      "integrity": "sha512-ZQBvi1DcpJ4GDqanjucZ2Hj3wEO5pZDS89BWbkcrvdxksJorwUDDZamX9ldFkp9aw2lmBDLgkObEA4DWNJ9FYQ==",
+      "license": "MIT",
+      "peer": true
+    },
+    "node_modules/country-regex": {
+      "version": "1.1.0",
+      "resolved": "https://registry.npmjs.org/country-regex/-/country-regex-1.1.0.tgz",
+      "integrity": "sha512-iSPlClZP8vX7MC3/u6s3lrDuoQyhQukh5LyABJ3hvfzbQ3Yyayd4fp04zjLnfi267B/B2FkumcWWgrbban7sSA==",
+      "license": "MIT",
+      "peer": true
+    },
+    "node_modules/cross-spawn": {
+      "version": "7.0.6",
+      "resolved": "https://registry.npmjs.org/cross-spawn/-/cross-spawn-7.0.6.tgz",
+      "integrity": "sha512-uV2QOWP2nWzsy2aMp8aRibhi9dlzF5Hgh5SHaB9OiTGEyDTiJJyx0uy51QXdyWbtAHNua4XJzUKca3OzKUd3vA==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "path-key": "^3.1.0",
+        "shebang-command": "^2.0.0",
+        "which": "^2.0.1"
+      },
+      "engines": {
+        "node": ">= 8"
+      }
+    },
+    "node_modules/css-font": {
+      "version": "1.2.0",
+      "resolved": "https://registry.npmjs.org/css-font/-/css-font-1.2.0.tgz",
+      "integrity": "sha512-V4U4Wps4dPDACJ4WpgofJ2RT5Yqwe1lEH6wlOOaIxMi0gTjdIijsc5FmxQlZ7ZZyKQkkutqqvULOp07l9c7ssA==",
+      "license": "MIT",
+      "peer": true,
+      "dependencies": {
+        "css-font-size-keywords": "^1.0.0",
+        "css-font-stretch-keywords": "^1.0.1",
+        "css-font-style-keywords": "^1.0.1",
+        "css-font-weight-keywords": "^1.0.0",
+        "css-global-keywords": "^1.0.1",
+        "css-system-font-keywords": "^1.0.0",
+        "pick-by-alias": "^1.2.0",
+        "string-split-by": "^1.0.0",
+        "unquote": "^1.1.0"
+      }
+    },
+    "node_modules/css-font-size-keywords": {
+      "version": "1.0.0",
+      "resolved": "https://registry.npmjs.org/css-font-size-keywords/-/css-font-size-keywords-1.0.0.tgz",
+      "integrity": "sha512-Q+svMDbMlelgCfH/RVDKtTDaf5021O486ZThQPIpahnIjUkMUslC+WuOQSWTgGSrNCH08Y7tYNEmmy0hkfMI8Q==",
+      "license": "MIT",
+      "peer": true
+    },
+    "node_modules/css-font-stretch-keywords": {
+      "version": "1.0.1",
+      "resolved": "https://registry.npmjs.org/css-font-stretch-keywords/-/css-font-stretch-keywords-1.0.1.tgz",
+      "integrity": "sha512-KmugPO2BNqoyp9zmBIUGwt58UQSfyk1X5DbOlkb2pckDXFSAfjsD5wenb88fNrD6fvS+vu90a/tsPpb9vb0SLg==",
+      "license": "MIT",
+      "peer": true
+    },
+    "node_modules/css-font-style-keywords": {
+      "version": "1.0.1",
+      "resolved": "https://registry.npmjs.org/css-font-style-keywords/-/css-font-style-keywords-1.0.1.tgz",
+      "integrity": "sha512-0Fn0aTpcDktnR1RzaBYorIxQily85M2KXRpzmxQPgh8pxUN9Fcn00I8u9I3grNr1QXVgCl9T5Imx0ZwKU973Vg==",
+      "license": "MIT",
+      "peer": true
+    },
+    "node_modules/css-font-weight-keywords": {
+      "version": "1.0.0",
+      "resolved": "https://registry.npmjs.org/css-font-weight-keywords/-/css-font-weight-keywords-1.0.0.tgz",
+      "integrity": "sha512-5So8/NH+oDD+EzsnF4iaG4ZFHQ3vaViePkL1ZbZ5iC/KrsCY+WHq/lvOgrtmuOQ9pBBZ1ADGpaf+A4lj1Z9eYA==",
+      "license": "MIT",
+      "peer": true
+    },
+    "node_modules/css-global-keywords": {
+      "version": "1.0.1",
+      "resolved": "https://registry.npmjs.org/css-global-keywords/-/css-global-keywords-1.0.1.tgz",
+      "integrity": "sha512-X1xgQhkZ9n94WDwntqst5D/FKkmiU0GlJSFZSV3kLvyJ1WC5VeyoXDOuleUD+SIuH9C7W05is++0Woh0CGfKjQ==",
+      "license": "MIT",
+      "peer": true
+    },
+    "node_modules/css-system-font-keywords": {
+      "version": "1.0.0",
+      "resolved": "https://registry.npmjs.org/css-system-font-keywords/-/css-system-font-keywords-1.0.0.tgz",
+      "integrity": "sha512-1umTtVd/fXS25ftfjB71eASCrYhilmEsvDEI6wG/QplnmlfmVM5HkZ/ZX46DT5K3eblFPgLUHt5BRCb0YXkSFA==",
+      "license": "MIT",
+      "peer": true
+    },
+    "node_modules/css-tree": {
+      "version": "3.1.0",
+      "resolved": "https://registry.npmjs.org/css-tree/-/css-tree-3.1.0.tgz",
+      "integrity": "sha512-0eW44TGN5SQXU1mWSkKwFstI/22X2bG1nYzZTYMAWjylYURhse752YgbE4Cx46AC+bAvI+/dYTPRk1LqSUnu6w==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "mdn-data": "2.12.2",
+        "source-map-js": "^1.0.1"
+      },
+      "engines": {
+        "node": "^10 || ^12.20.0 || ^14.13.0 || >=15.0.0"
+      }
+    },
+    "node_modules/css.escape": {
+      "version": "1.5.1",
+      "resolved": "https://registry.npmjs.org/css.escape/-/css.escape-1.5.1.tgz",
+      "integrity": "sha512-YUifsXXuknHlUsmlgyY0PKzgPOr7/FjCePfHNt0jxm83wHZi44VDMQ7/fGNkjY3/jV1MC+1CmZbaHzugyeRtpg==",
+      "dev": true,
+      "license": "MIT"
+    },
+    "node_modules/csscolorparser": {
+      "version": "1.0.3",
+      "resolved": "https://registry.npmjs.org/csscolorparser/-/csscolorparser-1.0.3.tgz",
+      "integrity": "sha512-umPSgYwZkdFoUrH5hIq5kf0wPSXiro51nPw0j2K/c83KflkPSTBGMz6NJvMB+07VlL0y7VPo6QJcDjcgKTTm3w==",
+      "license": "MIT",
+      "peer": true
+    },
+    "node_modules/cssstyle": {
+      "version": "5.3.3",
+      "resolved": "https://registry.npmjs.org/cssstyle/-/cssstyle-5.3.3.tgz",
+      "integrity": "sha512-OytmFH+13/QXONJcC75QNdMtKpceNk3u8ThBjyyYjkEcy/ekBwR1mMAuNvi3gdBPW3N5TlCzQ0WZw8H0lN/bDw==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@asamuzakjp/css-color": "^4.0.3",
+        "@csstools/css-syntax-patches-for-csstree": "^1.0.14",
+        "css-tree": "^3.1.0"
+      },
+      "engines": {
+        "node": ">=20"
+      }
+    },
+    "node_modules/csstype": {
+      "version": "3.1.3",
+      "resolved": "https://registry.npmjs.org/csstype/-/csstype-3.1.3.tgz",
+      "integrity": "sha512-M1uQkMl8rQK/szD0LNhtqxIPLpimGm8sOBwU7lLnCpSbTyY3yeU1Vc7l4KT5zT4s/yOxHH5O7tIuuLOCnLADRw==",
+      "license": "MIT"
+    },
+    "node_modules/d": {
+      "version": "1.0.2",
+      "resolved": "https://registry.npmjs.org/d/-/d-1.0.2.tgz",
+      "integrity": "sha512-MOqHvMWF9/9MX6nza0KgvFH4HpMU0EF5uUDXqX/BtxtU8NfB0QzRtJ8Oe/6SuS4kbhyzVJwjd97EA4PKrzJ8bw==",
+      "license": "ISC",
+      "peer": true,
+      "dependencies": {
+        "es5-ext": "^0.10.64",
+        "type": "^2.7.2"
+      },
+      "engines": {
+        "node": ">=0.12"
+      }
+    },
+    "node_modules/d3-array": {
+      "version": "1.2.4",
+      "resolved": "https://registry.npmjs.org/d3-array/-/d3-array-1.2.4.tgz",
+      "integrity": "sha512-KHW6M86R+FUPYGb3R5XiYjXPq7VzwxZ22buHhAEVG5ztoEcZZMLov530mmccaqA1GghZArjQV46fuc8kUqhhHw==",
+      "license": "BSD-3-Clause",
+      "peer": true
+    },
+    "node_modules/d3-collection": {
+      "version": "1.0.7",
+      "resolved": "https://registry.npmjs.org/d3-collection/-/d3-collection-1.0.7.tgz",
+      "integrity": "sha512-ii0/r5f4sjKNTfh84Di+DpztYwqKhEyUlKoPrzUFfeSkWxjW49xU2QzO9qrPrNkpdI0XJkfzvmTu8V2Zylln6A==",
+      "license": "BSD-3-Clause",
+      "peer": true
+    },
+    "node_modules/d3-color": {
+      "version": "3.1.0",
+      "resolved": "https://registry.npmjs.org/d3-color/-/d3-color-3.1.0.tgz",
+      "integrity": "sha512-zg/chbXyeBtMQ1LbD/WSoW2DpC3I0mpmPdW+ynRTj/x2DAWYrIY7qeZIHidozwV24m4iavr15lNwIwLxRmOxhA==",
+      "license": "ISC",
+      "peer": true,
+      "engines": {
+        "node": ">=12"
+      }
+    },
+    "node_modules/d3-dispatch": {
+      "version": "1.0.6",
+      "resolved": "https://registry.npmjs.org/d3-dispatch/-/d3-dispatch-1.0.6.tgz",
+      "integrity": "sha512-fVjoElzjhCEy+Hbn8KygnmMS7Or0a9sI2UzGwoB7cCtvI1XpVN9GpoYlnb3xt2YV66oXYb1fLJ8GMvP4hdU1RA==",
+      "license": "BSD-3-Clause",
+      "peer": true
+    },
+    "node_modules/d3-force": {
+      "version": "1.2.1",
+      "resolved": "https://registry.npmjs.org/d3-force/-/d3-force-1.2.1.tgz",
+      "integrity": "sha512-HHvehyaiUlVo5CxBJ0yF/xny4xoaxFxDnBXNvNcfW9adORGZfyNF1dj6DGLKyk4Yh3brP/1h3rnDzdIAwL08zg==",
+      "license": "BSD-3-Clause",
+      "peer": true,
+      "dependencies": {
+        "d3-collection": "1",
+        "d3-dispatch": "1",
+        "d3-quadtree": "1",
+        "d3-timer": "1"
+      }
+    },
+    "node_modules/d3-format": {
+      "version": "1.4.5",
+      "resolved": "https://registry.npmjs.org/d3-format/-/d3-format-1.4.5.tgz",
+      "integrity": "sha512-J0piedu6Z8iB6TbIGfZgDzfXxUFN3qQRMofy2oPdXzQibYGqPB/9iMcxr/TGalU+2RsyDO+U4f33id8tbnSRMQ==",
+      "license": "BSD-3-Clause",
+      "peer": true
+    },
+    "node_modules/d3-geo": {
+      "version": "1.12.1",
+      "resolved": "https://registry.npmjs.org/d3-geo/-/d3-geo-1.12.1.tgz",
+      "integrity": "sha512-XG4d1c/UJSEX9NfU02KwBL6BYPj8YKHxgBEw5om2ZnTRSbIcego6dhHwcxuSR3clxh0EpE38os1DVPOmnYtTPg==",
+      "license": "BSD-3-Clause",
+      "peer": true,
+      "dependencies": {
+        "d3-array": "1"
+      }
+    },
+    "node_modules/d3-geo-projection": {
+      "version": "2.9.0",
+      "resolved": "https://registry.npmjs.org/d3-geo-projection/-/d3-geo-projection-2.9.0.tgz",
+      "integrity": "sha512-ZULvK/zBn87of5rWAfFMc9mJOipeSo57O+BBitsKIXmU4rTVAnX1kSsJkE0R+TxY8pGNoM1nbyRRE7GYHhdOEQ==",
+      "license": "BSD-3-Clause",
+      "peer": true,
+      "dependencies": {
+        "commander": "2",
+        "d3-array": "1",
+        "d3-geo": "^1.12.0",
+        "resolve": "^1.1.10"
+      },
+      "bin": {
+        "geo2svg": "bin/geo2svg",
+        "geograticule": "bin/geograticule",
+        "geoproject": "bin/geoproject",
+        "geoquantize": "bin/geoquantize",
+        "geostitch": "bin/geostitch"
+      }
+    },
+    "node_modules/d3-hierarchy": {
+      "version": "1.1.9",
+      "resolved": "https://registry.npmjs.org/d3-hierarchy/-/d3-hierarchy-1.1.9.tgz",
+      "integrity": "sha512-j8tPxlqh1srJHAtxfvOUwKNYJkQuBFdM1+JAUfq6xqH5eAqf93L7oG1NVqDa4CpFZNvnNKtCYEUC8KY9yEn9lQ==",
+      "license": "BSD-3-Clause",
+      "peer": true
+    },
+    "node_modules/d3-interpolate": {
+      "version": "3.0.1",
+      "resolved": "https://registry.npmjs.org/d3-interpolate/-/d3-interpolate-3.0.1.tgz",
+      "integrity": "sha512-3bYs1rOD33uo8aqJfKP3JWPAibgw8Zm2+L9vBKEHJ2Rg+viTR7o5Mmv5mZcieN+FRYaAOWX5SJATX6k1PWz72g==",
+      "license": "ISC",
+      "peer": true,
+      "dependencies": {
+        "d3-color": "1 - 3"
+      },
+      "engines": {
+        "node": ">=12"
+      }
+    },
+    "node_modules/d3-path": {
+      "version": "1.0.9",
+      "resolved": "https://registry.npmjs.org/d3-path/-/d3-path-1.0.9.tgz",
+      "integrity": "sha512-VLaYcn81dtHVTjEHd8B+pbe9yHWpXKZUC87PzoFmsFrJqgFwDe/qxfp5MlfsfM1V5E/iVt0MmEbWQ7FVIXh/bg==",
+      "license": "BSD-3-Clause",
+      "peer": true
+    },
+    "node_modules/d3-quadtree": {
+      "version": "1.0.7",
+      "resolved": "https://registry.npmjs.org/d3-quadtree/-/d3-quadtree-1.0.7.tgz",
+      "integrity": "sha512-RKPAeXnkC59IDGD0Wu5mANy0Q2V28L+fNe65pOCXVdVuTJS3WPKaJlFHer32Rbh9gIo9qMuJXio8ra4+YmIymA==",
+      "license": "BSD-3-Clause",
+      "peer": true
+    },
+    "node_modules/d3-shape": {
+      "version": "1.3.7",
+      "resolved": "https://registry.npmjs.org/d3-shape/-/d3-shape-1.3.7.tgz",
+      "integrity": "sha512-EUkvKjqPFUAZyOlhY5gzCxCeI0Aep04LwIRpsZ/mLFelJiUfnK56jo5JMDSE7yyP2kLSb6LtF+S5chMk7uqPqw==",
+      "license": "BSD-3-Clause",
+      "peer": true,
+      "dependencies": {
+        "d3-path": "1"
+      }
+    },
+    "node_modules/d3-time": {
+      "version": "1.1.0",
+      "resolved": "https://registry.npmjs.org/d3-time/-/d3-time-1.1.0.tgz",
+      "integrity": "sha512-Xh0isrZ5rPYYdqhAVk8VLnMEidhz5aP7htAADH6MfzgmmicPkTo8LhkLxci61/lCB7n7UmE3bN0leRt+qvkLxA==",
+      "license": "BSD-3-Clause",
+      "peer": true
+    },
+    "node_modules/d3-time-format": {
+      "version": "2.3.0",
+      "resolved": "https://registry.npmjs.org/d3-time-format/-/d3-time-format-2.3.0.tgz",
+      "integrity": "sha512-guv6b2H37s2Uq/GefleCDtbe0XZAuy7Wa49VGkPVPMfLL9qObgBST3lEHJBMUp8S7NdLQAGIvr2KXk8Hc98iKQ==",
+      "license": "BSD-3-Clause",
+      "peer": true,
+      "dependencies": {
+        "d3-time": "1"
+      }
+    },
+    "node_modules/d3-timer": {
+      "version": "1.0.10",
+      "resolved": "https://registry.npmjs.org/d3-timer/-/d3-timer-1.0.10.tgz",
+      "integrity": "sha512-B1JDm0XDaQC+uvo4DT79H0XmBskgS3l6Ve+1SBCfxgmtIb1AVrPIoqd+nPSv+loMX8szQ0sVUhGngL7D5QPiXw==",
+      "license": "BSD-3-Clause",
+      "peer": true
+    },
+    "node_modules/data-urls": {
+      "version": "6.0.0",
+      "resolved": "https://registry.npmjs.org/data-urls/-/data-urls-6.0.0.tgz",
+      "integrity": "sha512-BnBS08aLUM+DKamupXs3w2tJJoqU+AkaE/+6vQxi/G/DPmIZFJJp9Dkb1kM03AZx8ADehDUZgsNxju3mPXZYIA==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "whatwg-mimetype": "^4.0.0",
+        "whatwg-url": "^15.0.0"
+      },
+      "engines": {
+        "node": ">=20"
+      }
+    },
+    "node_modules/date-fns": {
+      "version": "4.1.0",
+      "resolved": "https://registry.npmjs.org/date-fns/-/date-fns-4.1.0.tgz",
+      "integrity": "sha512-Ukq0owbQXxa/U3EGtsdVBkR1w7KOQ5gIBqdH2hkvknzZPYvBxb/aa6E8L7tmjFtkwZBu3UXBbjIgPo/Ez4xaNg==",
+      "license": "MIT",
+      "peer": true,
+      "funding": {
+        "type": "github",
+        "url": "https://github.com/sponsors/kossnocorp"
+      }
+    },
+    "node_modules/debug": {
+      "version": "4.4.1",
+      "resolved": "https://registry.npmjs.org/debug/-/debug-4.4.1.tgz",
+      "integrity": "sha512-KcKCqiftBJcZr++7ykoDIEwSa3XWowTfNPo92BYxjXiyYEVrUQh2aLyhxBCwww+heortUFxEJYcRzosstTEBYQ==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "ms": "^2.1.3"
+      },
+      "engines": {
+        "node": ">=6.0"
+      },
+      "peerDependenciesMeta": {
+        "supports-color": {
+          "optional": true
+        }
+      }
+    },
+    "node_modules/decimal.js": {
+      "version": "10.6.0",
+      "resolved": "https://registry.npmjs.org/decimal.js/-/decimal.js-10.6.0.tgz",
+      "integrity": "sha512-YpgQiITW3JXGntzdUmyUR1V812Hn8T1YVXhCu+wO3OpS4eU9l4YdD3qjyiKdV6mvV29zapkMeD390UVEf2lkUg==",
+      "dev": true,
+      "license": "MIT"
+    },
+    "node_modules/deep-eql": {
+      "version": "5.0.2",
+      "resolved": "https://registry.npmjs.org/deep-eql/-/deep-eql-5.0.2.tgz",
+      "integrity": "sha512-h5k/5U50IJJFpzfL6nO9jaaumfjO/f2NjK/oYB2Djzm4p9L+3T9qWpZqZ2hAbLPuuYq9wrU08WQyBTL5GbPk5Q==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">=6"
+      }
+    },
+    "node_modules/deep-is": {
+      "version": "0.1.4",
+      "resolved": "https://registry.npmjs.org/deep-is/-/deep-is-0.1.4.tgz",
+      "integrity": "sha512-oIPzksmTg4/MriiaYGO+okXDT7ztn/w3Eptv/+gSIdMdKsJo0u4CfYNFJPy+4SKMuCqGw2wxnA+URMg3t8a/bQ==",
+      "dev": true,
+      "license": "MIT"
+    },
+    "node_modules/defined": {
+      "version": "1.0.1",
+      "resolved": "https://registry.npmjs.org/defined/-/defined-1.0.1.tgz",
+      "integrity": "sha512-hsBd2qSVCRE+5PmNdHt1uzyrFu5d3RwmFDKzyNZMFq/EwDNJF7Ee5+D5oEKF0hU6LhtoUF1macFvOe4AskQC1Q==",
+      "license": "MIT",
+      "peer": true,
+      "funding": {
+        "url": "https://github.com/sponsors/ljharb"
+      }
+    },
+    "node_modules/dequal": {
+      "version": "2.0.3",
+      "resolved": "https://registry.npmjs.org/dequal/-/dequal-2.0.3.tgz",
+      "integrity": "sha512-0je+qPKHEMohvfRTCEo3CrPG6cAzAYgmzKyxRiYSSDkS6eGJdyVJm7WaYA5ECaAD9wLB2T4EEeymA5aFVcYXCA==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">=6"
+      }
+    },
+    "node_modules/detect-kerning": {
+      "version": "2.1.2",
+      "resolved": "https://registry.npmjs.org/detect-kerning/-/detect-kerning-2.1.2.tgz",
+      "integrity": "sha512-I3JIbrnKPAntNLl1I6TpSQQdQ4AutYzv/sKMFKbepawV/hlH0GmYKhUoOEMd4xqaUHT+Bm0f4127lh5qs1m1tw==",
+      "license": "MIT",
+      "peer": true
+    },
+    "node_modules/dir-glob": {
+      "version": "3.0.1",
+      "resolved": "https://registry.npmjs.org/dir-glob/-/dir-glob-3.0.1.tgz",
+      "integrity": "sha512-WkrWp9GR4KXfKGYzOLmTuGVi1UWFfws377n9cc55/tb6DuqyF6pcQ5AbiHEshaDpY9v6oaSr2XCDidGmMwdzIA==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "path-type": "^4.0.0"
+      },
+      "engines": {
+        "node": ">=8"
+      }
+    },
+    "node_modules/doctrine": {
+      "version": "3.0.0",
+      "resolved": "https://registry.npmjs.org/doctrine/-/doctrine-3.0.0.tgz",
+      "integrity": "sha512-yS+Q5i3hBf7GBkd4KG8a7eBNNWNGLTaEwwYWUijIYM7zrlYDM0BFXHjjPWlWZ1Rg7UaddZeIDmi9jF3HmqiQ2w==",
+      "dev": true,
+      "license": "Apache-2.0",
+      "dependencies": {
+        "esutils": "^2.0.2"
+      },
+      "engines": {
+        "node": ">=6.0.0"
+      }
+    },
+    "node_modules/dom-accessibility-api": {
+      "version": "0.5.16",
+      "resolved": "https://registry.npmjs.org/dom-accessibility-api/-/dom-accessibility-api-0.5.16.tgz",
+      "integrity": "sha512-X7BJ2yElsnOJ30pZF4uIIDfBEVgF4XEBxL9Bxhy6dnrm5hkzqmsWHGTiHqRiITNhMyFLyAiWndIJP7Z1NTteDg==",
+      "dev": true,
+      "license": "MIT",
+      "peer": true
+    },
+    "node_modules/draw-svg-path": {
+      "version": "1.0.0",
+      "resolved": "https://registry.npmjs.org/draw-svg-path/-/draw-svg-path-1.0.0.tgz",
+      "integrity": "sha512-P8j3IHxcgRMcY6sDzr0QvJDLzBnJJqpTG33UZ2Pvp8rw0apCHhJCWqYprqrXjrgHnJ6tuhP1iTJSAodPDHxwkg==",
+      "license": "MIT",
+      "peer": true,
+      "dependencies": {
+        "abs-svg-path": "~0.1.1",
+        "normalize-svg-path": "~0.1.0"
+      }
+    },
+    "node_modules/dtype": {
+      "version": "2.0.0",
+      "resolved": "https://registry.npmjs.org/dtype/-/dtype-2.0.0.tgz",
+      "integrity": "sha512-s2YVcLKdFGS0hpFqJaTwscsyt0E8nNFdmo73Ocd81xNPj4URI4rj6D60A+vFMIw7BXWlb4yRkEwfBqcZzPGiZg==",
+      "license": "MIT",
+      "peer": true,
+      "engines": {
+        "node": ">= 0.8.0"
+      }
+    },
+    "node_modules/dup": {
+      "version": "1.0.0",
+      "resolved": "https://registry.npmjs.org/dup/-/dup-1.0.0.tgz",
+      "integrity": "sha512-Bz5jxMMC0wgp23Zm15ip1x8IhYRqJvF3nFC0UInJUDkN1z4uNPk9jTnfCUJXbOGiQ1JbXLQsiV41Fb+HXcj5BA==",
+      "license": "MIT",
+      "peer": true
+    },
+    "node_modules/duplexify": {
+      "version": "3.7.1",
+      "resolved": "https://registry.npmjs.org/duplexify/-/duplexify-3.7.1.tgz",
+      "integrity": "sha512-07z8uv2wMyS51kKhD1KsdXJg5WQ6t93RneqRxUHnskXVtlYYkLqM0gqStQZ3pj073g687jPCHrqNfCzawLYh5g==",
+      "license": "MIT",
+      "peer": true,
+      "dependencies": {
+        "end-of-stream": "^1.0.0",
+        "inherits": "^2.0.1",
+        "readable-stream": "^2.0.0",
+        "stream-shift": "^1.0.0"
+      }
+    },
+    "node_modules/earcut": {
+      "version": "2.2.4",
+      "resolved": "https://registry.npmjs.org/earcut/-/earcut-2.2.4.tgz",
+      "integrity": "sha512-/pjZsA1b4RPHbeWZQn66SWS8nZZWLQQ23oE3Eam7aroEFGEvwKAsJfZ9ytiEMycfzXWpca4FA9QIOehf7PocBQ==",
+      "license": "ISC"
+    },
+    "node_modules/electron-to-chromium": {
+      "version": "1.5.165",
+      "resolved": "https://registry.npmjs.org/electron-to-chromium/-/electron-to-chromium-1.5.165.tgz",
+      "integrity": "sha512-naiMx1Z6Nb2TxPU6fiFrUrDTjyPMLdTtaOd2oLmG8zVSg2hCWGkhPyxwk+qRmZ1ytwVqUv0u7ZcDA5+ALhaUtw==",
+      "dev": true,
+      "license": "ISC"
+    },
+    "node_modules/element-size": {
+      "version": "1.1.1",
+      "resolved": "https://registry.npmjs.org/element-size/-/element-size-1.1.1.tgz",
+      "integrity": "sha512-eaN+GMOq/Q+BIWy0ybsgpcYImjGIdNLyjLFJU4XsLHXYQao5jCNb36GyN6C2qwmDDYSfIBmKpPpr4VnBdLCsPQ==",
+      "license": "MIT",
+      "peer": true
+    },
+    "node_modules/elementary-circuits-directed-graph": {
+      "version": "1.3.1",
+      "resolved": "https://registry.npmjs.org/elementary-circuits-directed-graph/-/elementary-circuits-directed-graph-1.3.1.tgz",
+      "integrity": "sha512-ZEiB5qkn2adYmpXGnJKkxT8uJHlW/mxmBpmeqawEHzPxh9HkLD4/1mFYX5l0On+f6rcPIt8/EWlRU2Vo3fX6dQ==",
+      "license": "MIT",
+      "peer": true,
+      "dependencies": {
+        "strongly-connected-components": "^1.0.1"
+      }
+    },
+    "node_modules/end-of-stream": {
+      "version": "1.4.5",
+      "resolved": "https://registry.npmjs.org/end-of-stream/-/end-of-stream-1.4.5.tgz",
+      "integrity": "sha512-ooEGc6HP26xXq/N+GCGOT0JKCLDGrq2bQUZrQ7gyrJiZANJ/8YDTxTpQBXGMn+WbIQXNVpyWymm7KYVICQnyOg==",
+      "license": "MIT",
+      "peer": true,
+      "dependencies": {
+        "once": "^1.4.0"
+      }
+    },
+    "node_modules/entities": {
+      "version": "6.0.1",
+      "resolved": "https://registry.npmjs.org/entities/-/entities-6.0.1.tgz",
+      "integrity": "sha512-aN97NXWF6AWBTahfVOIrB/NShkzi5H7F9r1s9mD3cDj4Ko5f2qhhVoYMibXF7GlLveb/D2ioWay8lxI97Ven3g==",
+      "dev": true,
+      "license": "BSD-2-Clause",
+      "engines": {
+        "node": ">=0.12"
+      },
+      "funding": {
+        "url": "https://github.com/fb55/entities?sponsor=1"
+      }
+    },
+    "node_modules/es-module-lexer": {
+      "version": "1.7.0",
+      "resolved": "https://registry.npmjs.org/es-module-lexer/-/es-module-lexer-1.7.0.tgz",
+      "integrity": "sha512-jEQoCwk8hyb2AZziIOLhDqpm5+2ww5uIE6lkO/6jcOCusfk6LhMHpXXfBLXTZ7Ydyt0j4VoUQv6uGNYbdW+kBA==",
+      "dev": true,
+      "license": "MIT"
+    },
+    "node_modules/es5-ext": {
+      "version": "0.10.64",
+      "resolved": "https://registry.npmjs.org/es5-ext/-/es5-ext-0.10.64.tgz",
+      "integrity": "sha512-p2snDhiLaXe6dahss1LddxqEm+SkuDvV8dnIQG0MWjyHpcMNfXKPE+/Cc0y+PhxJX3A4xGNeFCj5oc0BUh6deg==",
+      "hasInstallScript": true,
+      "license": "ISC",
+      "peer": true,
+      "dependencies": {
+        "es6-iterator": "^2.0.3",
+        "es6-symbol": "^3.1.3",
+        "esniff": "^2.0.1",
+        "next-tick": "^1.1.0"
+      },
+      "engines": {
+        "node": ">=0.10"
+      }
+    },
+    "node_modules/es6-iterator": {
+      "version": "2.0.3",
+      "resolved": "https://registry.npmjs.org/es6-iterator/-/es6-iterator-2.0.3.tgz",
+      "integrity": "sha512-zw4SRzoUkd+cl+ZoE15A9o1oQd920Bb0iOJMQkQhl3jNc03YqVjAhG7scf9C5KWRU/R13Orf588uCC6525o02g==",
+      "license": "MIT",
+      "peer": true,
+      "dependencies": {
+        "d": "1",
+        "es5-ext": "^0.10.35",
+        "es6-symbol": "^3.1.1"
+      }
+    },
+    "node_modules/es6-symbol": {
+      "version": "3.1.4",
+      "resolved": "https://registry.npmjs.org/es6-symbol/-/es6-symbol-3.1.4.tgz",
+      "integrity": "sha512-U9bFFjX8tFiATgtkJ1zg25+KviIXpgRvRHS8sau3GfhVzThRQrOeksPeT0BWW2MNZs1OEWJ1DPXOQMn0KKRkvg==",
+      "license": "ISC",
+      "peer": true,
+      "dependencies": {
+        "d": "^1.0.2",
+        "ext": "^1.7.0"
+      },
+      "engines": {
+        "node": ">=0.12"
+      }
+    },
+    "node_modules/es6-weak-map": {
+      "version": "2.0.3",
+      "resolved": "https://registry.npmjs.org/es6-weak-map/-/es6-weak-map-2.0.3.tgz",
+      "integrity": "sha512-p5um32HOTO1kP+w7PRnB+5lQ43Z6muuMuIMffvDN8ZB4GcnjLBV6zGStpbASIMk4DCAvEaamhe2zhyCb/QXXsA==",
+      "license": "ISC",
+      "peer": true,
+      "dependencies": {
+        "d": "1",
+        "es5-ext": "^0.10.46",
+        "es6-iterator": "^2.0.3",
+        "es6-symbol": "^3.1.1"
+      }
+    },
+    "node_modules/esbuild": {
+      "version": "0.21.5",
+      "resolved": "https://registry.npmjs.org/esbuild/-/esbuild-0.21.5.tgz",
+      "integrity": "sha512-mg3OPMV4hXywwpoDxu3Qda5xCKQi+vCTZq8S9J/EpkhB2HzKXq4SNFZE3+NK93JYxc8VMSep+lOUSC/RVKaBqw==",
+      "dev": true,
+      "hasInstallScript": true,
+      "license": "MIT",
+      "bin": {
+        "esbuild": "bin/esbuild"
+      },
+      "engines": {
+        "node": ">=12"
+      },
+      "optionalDependencies": {
+        "@esbuild/aix-ppc64": "0.21.5",
+        "@esbuild/android-arm": "0.21.5",
+        "@esbuild/android-arm64": "0.21.5",
+        "@esbuild/android-x64": "0.21.5",
+        "@esbuild/darwin-arm64": "0.21.5",
+        "@esbuild/darwin-x64": "0.21.5",
+        "@esbuild/freebsd-arm64": "0.21.5",
+        "@esbuild/freebsd-x64": "0.21.5",
+        "@esbuild/linux-arm": "0.21.5",
+        "@esbuild/linux-arm64": "0.21.5",
+        "@esbuild/linux-ia32": "0.21.5",
+        "@esbuild/linux-loong64": "0.21.5",
+        "@esbuild/linux-mips64el": "0.21.5",
+        "@esbuild/linux-ppc64": "0.21.5",
+        "@esbuild/linux-riscv64": "0.21.5",
+        "@esbuild/linux-s390x": "0.21.5",
+        "@esbuild/linux-x64": "0.21.5",
+        "@esbuild/netbsd-x64": "0.21.5",
+        "@esbuild/openbsd-x64": "0.21.5",
+        "@esbuild/sunos-x64": "0.21.5",
+        "@esbuild/win32-arm64": "0.21.5",
+        "@esbuild/win32-ia32": "0.21.5",
+        "@esbuild/win32-x64": "0.21.5"
+      }
+    },
+    "node_modules/escalade": {
+      "version": "3.2.0",
+      "resolved": "https://registry.npmjs.org/escalade/-/escalade-3.2.0.tgz",
+      "integrity": "sha512-WUj2qlxaQtO4g6Pq5c29GTcWGDyd8itL8zTlipgECz3JesAiiOKotd8JU6otB3PACgG6xkJUyVhboMS+bje/jA==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">=6"
+      }
+    },
+    "node_modules/escape-string-regexp": {
+      "version": "4.0.0",
+      "resolved": "https://registry.npmjs.org/escape-string-regexp/-/escape-string-regexp-4.0.0.tgz",
+      "integrity": "sha512-TtpcNJ3XAzx3Gq8sWRzJaVajRs0uVxA2YAkdb1jm2YkPz4G6egUFAyA3n5vtEIZefPk5Wa4UXbKuS5fKkJWdgA==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">=10"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/sindresorhus"
+      }
+    },
+    "node_modules/escodegen": {
+      "version": "2.1.0",
+      "resolved": "https://registry.npmjs.org/escodegen/-/escodegen-2.1.0.tgz",
+      "integrity": "sha512-2NlIDTwUWJN0mRPQOdtQBzbUHvdGY2P1VXSyU83Q3xKxM7WHX2Ql8dKq782Q9TgQUNOLEzEYu9bzLNj1q88I5w==",
+      "license": "BSD-2-Clause",
+      "peer": true,
+      "dependencies": {
+        "esprima": "^4.0.1",
+        "estraverse": "^5.2.0",
+        "esutils": "^2.0.2"
+      },
+      "bin": {
+        "escodegen": "bin/escodegen.js",
+        "esgenerate": "bin/esgenerate.js"
+      },
+      "engines": {
+        "node": ">=6.0"
+      },
+      "optionalDependencies": {
+        "source-map": "~0.6.1"
+      }
+    },
+    "node_modules/eslint": {
+      "version": "8.57.1",
+      "resolved": "https://registry.npmjs.org/eslint/-/eslint-8.57.1.tgz",
+      "integrity": "sha512-ypowyDxpVSYpkXr9WPv2PAZCtNip1Mv5KTW0SCurXv/9iOpcrH9PaqUElksqEB6pChqHGDRCFTyrZlGhnLNGiA==",
+      "deprecated": "This version is no longer supported. Please see https://eslint.org/version-support for other options.",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@eslint-community/eslint-utils": "^4.2.0",
+        "@eslint-community/regexpp": "^4.6.1",
+        "@eslint/eslintrc": "^2.1.4",
+        "@eslint/js": "8.57.1",
+        "@humanwhocodes/config-array": "^0.13.0",
+        "@humanwhocodes/module-importer": "^1.0.1",
+        "@nodelib/fs.walk": "^1.2.8",
+        "@ungap/structured-clone": "^1.2.0",
+        "ajv": "^6.12.4",
+        "chalk": "^4.0.0",
+        "cross-spawn": "^7.0.2",
+        "debug": "^4.3.2",
+        "doctrine": "^3.0.0",
+        "escape-string-regexp": "^4.0.0",
+        "eslint-scope": "^7.2.2",
+        "eslint-visitor-keys": "^3.4.3",
+        "espree": "^9.6.1",
+        "esquery": "^1.4.2",
+        "esutils": "^2.0.2",
+        "fast-deep-equal": "^3.1.3",
+        "file-entry-cache": "^6.0.1",
+        "find-up": "^5.0.0",
+        "glob-parent": "^6.0.2",
+        "globals": "^13.19.0",
+        "graphemer": "^1.4.0",
+        "ignore": "^5.2.0",
+        "imurmurhash": "^0.1.4",
+        "is-glob": "^4.0.0",
+        "is-path-inside": "^3.0.3",
+        "js-yaml": "^4.1.0",
+        "json-stable-stringify-without-jsonify": "^1.0.1",
+        "levn": "^0.4.1",
+        "lodash.merge": "^4.6.2",
+        "minimatch": "^3.1.2",
+        "natural-compare": "^1.4.0",
+        "optionator": "^0.9.3",
+        "strip-ansi": "^6.0.1",
+        "text-table": "^0.2.0"
+      },
+      "bin": {
+        "eslint": "bin/eslint.js"
+      },
+      "engines": {
+        "node": "^12.22.0 || ^14.17.0 || >=16.0.0"
+      },
+      "funding": {
+        "url": "https://opencollective.com/eslint"
+      }
+    },
+    "node_modules/eslint-plugin-react-hooks": {
+      "version": "4.6.2",
+      "resolved": "https://registry.npmjs.org/eslint-plugin-react-hooks/-/eslint-plugin-react-hooks-4.6.2.tgz",
+      "integrity": "sha512-QzliNJq4GinDBcD8gPB5v0wh6g8q3SUi6EFF0x8N/BL9PoVs0atuGc47ozMRyOWAKdwaZ5OnbOEa3WR+dSGKuQ==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">=10"
+      },
+      "peerDependencies": {
+        "eslint": "^3.0.0 || ^4.0.0 || ^5.0.0 || ^6.0.0 || ^7.0.0 || ^8.0.0-0"
+      }
+    },
+    "node_modules/eslint-plugin-react-refresh": {
+      "version": "0.4.20",
+      "resolved": "https://registry.npmjs.org/eslint-plugin-react-refresh/-/eslint-plugin-react-refresh-0.4.20.tgz",
+      "integrity": "sha512-XpbHQ2q5gUF8BGOX4dHe+71qoirYMhApEPZ7sfhF/dNnOF1UXnCMGZf79SFTBO7Bz5YEIT4TMieSlJBWhP9WBA==",
+      "dev": true,
+      "license": "MIT",
+      "peerDependencies": {
+        "eslint": ">=8.40"
+      }
+    },
+    "node_modules/eslint-scope": {
+      "version": "7.2.2",
+      "resolved": "https://registry.npmjs.org/eslint-scope/-/eslint-scope-7.2.2.tgz",
+      "integrity": "sha512-dOt21O7lTMhDM+X9mB4GX+DZrZtCUJPL/wlcTqxyrx5IvO0IYtILdtrQGQp+8n5S0gwSVmOf9NQrjMOgfQZlIg==",
+      "dev": true,
+      "license": "BSD-2-Clause",
+      "dependencies": {
+        "esrecurse": "^4.3.0",
+        "estraverse": "^5.2.0"
+      },
+      "engines": {
+        "node": "^12.22.0 || ^14.17.0 || >=16.0.0"
+      },
+      "funding": {
+        "url": "https://opencollective.com/eslint"
+      }
+    },
+    "node_modules/eslint-visitor-keys": {
+      "version": "3.4.3",
+      "resolved": "https://registry.npmjs.org/eslint-visitor-keys/-/eslint-visitor-keys-3.4.3.tgz",
+      "integrity": "sha512-wpc+LXeiyiisxPlEkUzU6svyS1frIO3Mgxj1fdy7Pm8Ygzguax2N3Fa/D/ag1WqbOprdI+uY6wMUl8/a2G+iag==",
+      "dev": true,
+      "license": "Apache-2.0",
+      "engines": {
+        "node": "^12.22.0 || ^14.17.0 || >=16.0.0"
+      },
+      "funding": {
+        "url": "https://opencollective.com/eslint"
+      }
+    },
+    "node_modules/eslint/node_modules/brace-expansion": {
+      "version": "1.1.11",
+      "resolved": "https://registry.npmjs.org/brace-expansion/-/brace-expansion-1.1.11.tgz",
+      "integrity": "sha512-iCuPHDFgrHX7H2vEI/5xpz07zSHB00TpugqhmYtVmMO6518mCuRMoOYFldEBl0g187ufozdaHgWKcYFb61qGiA==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "balanced-match": "^1.0.0",
+        "concat-map": "0.0.1"
+      }
+    },
+    "node_modules/eslint/node_modules/globals": {
+      "version": "13.24.0",
+      "resolved": "https://registry.npmjs.org/globals/-/globals-13.24.0.tgz",
+      "integrity": "sha512-AhO5QUcj8llrbG09iWhPU2B204J1xnPeL8kQmVorSsy+Sjj1sk8gIyh6cUocGmH4L0UuhAJy+hJMRA4mgA4mFQ==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "type-fest": "^0.20.2"
+      },
+      "engines": {
+        "node": ">=8"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/sindresorhus"
+      }
+    },
+    "node_modules/eslint/node_modules/minimatch": {
+      "version": "3.1.2",
+      "resolved": "https://registry.npmjs.org/minimatch/-/minimatch-3.1.2.tgz",
+      "integrity": "sha512-J7p63hRiAjw1NDEww1W7i37+ByIrOWO5XQQAzZ3VOcL0PNybwpfmV/N05zFAzwQ9USyEcX6t3UO+K5aqBQOIHw==",
+      "dev": true,
+      "license": "ISC",
+      "dependencies": {
+        "brace-expansion": "^1.1.7"
+      },
+      "engines": {
+        "node": "*"
+      }
+    },
+    "node_modules/esniff": {
+      "version": "2.0.1",
+      "resolved": "https://registry.npmjs.org/esniff/-/esniff-2.0.1.tgz",
+      "integrity": "sha512-kTUIGKQ/mDPFoJ0oVfcmyJn4iBDRptjNVIzwIFR7tqWXdVI9xfA2RMwY/gbSpJG3lkdWNEjLap/NqVHZiJsdfg==",
+      "license": "ISC",
+      "peer": true,
+      "dependencies": {
+        "d": "^1.0.1",
+        "es5-ext": "^0.10.62",
+        "event-emitter": "^0.3.5",
+        "type": "^2.7.2"
+      },
+      "engines": {
+        "node": ">=0.10"
+      }
+    },
+    "node_modules/espree": {
+      "version": "9.6.1",
+      "resolved": "https://registry.npmjs.org/espree/-/espree-9.6.1.tgz",
+      "integrity": "sha512-oruZaFkjorTpF32kDSI5/75ViwGeZginGGy2NoOSg3Q9bnwlnmDm4HLnkl0RE3n+njDXR037aY1+x58Z/zFdwQ==",
+      "dev": true,
+      "license": "BSD-2-Clause",
+      "dependencies": {
+        "acorn": "^8.9.0",
+        "acorn-jsx": "^5.3.2",
+        "eslint-visitor-keys": "^3.4.1"
+      },
+      "engines": {
+        "node": "^12.22.0 || ^14.17.0 || >=16.0.0"
+      },
+      "funding": {
+        "url": "https://opencollective.com/eslint"
+      }
+    },
+    "node_modules/esprima": {
+      "version": "4.0.1",
+      "resolved": "https://registry.npmjs.org/esprima/-/esprima-4.0.1.tgz",
+      "integrity": "sha512-eGuFFw7Upda+g4p+QHvnW0RyTX/SVeJBDM/gCtMARO0cLuT2HcEKnTPvhjV6aGeqrCB/sbNop0Kszm0jsaWU4A==",
+      "license": "BSD-2-Clause",
+      "peer": true,
+      "bin": {
+        "esparse": "bin/esparse.js",
+        "esvalidate": "bin/esvalidate.js"
+      },
+      "engines": {
+        "node": ">=4"
+      }
+    },
+    "node_modules/esquery": {
+      "version": "1.6.0",
+      "resolved": "https://registry.npmjs.org/esquery/-/esquery-1.6.0.tgz",
+      "integrity": "sha512-ca9pw9fomFcKPvFLXhBKUK90ZvGibiGOvRJNbjljY7s7uq/5YO4BOzcYtJqExdx99rF6aAcnRxHmcUHcz6sQsg==",
+      "dev": true,
+      "license": "BSD-3-Clause",
+      "dependencies": {
+        "estraverse": "^5.1.0"
+      },
+      "engines": {
+        "node": ">=0.10"
+      }
+    },
+    "node_modules/esrecurse": {
+      "version": "4.3.0",
+      "resolved": "https://registry.npmjs.org/esrecurse/-/esrecurse-4.3.0.tgz",
+      "integrity": "sha512-KmfKL3b6G+RXvP8N1vr3Tq1kL/oCFgn2NYXEtqP8/L3pKapUA4G8cFVaoF3SU323CD4XypR/ffioHmkti6/Tag==",
+      "dev": true,
+      "license": "BSD-2-Clause",
+      "dependencies": {
+        "estraverse": "^5.2.0"
+      },
+      "engines": {
+        "node": ">=4.0"
+      }
+    },
+    "node_modules/estraverse": {
+      "version": "5.3.0",
+      "resolved": "https://registry.npmjs.org/estraverse/-/estraverse-5.3.0.tgz",
+      "integrity": "sha512-MMdARuVEQziNTeJD8DgMqmhwR11BRQ/cBP+pLtYdSTnf3MIO8fFeiINEbX36ZdNlfU/7A9f3gUw49B3oQsvwBA==",
+      "license": "BSD-2-Clause",
+      "engines": {
+        "node": ">=4.0"
+      }
+    },
+    "node_modules/estree-walker": {
+      "version": "3.0.3",
+      "resolved": "https://registry.npmjs.org/estree-walker/-/estree-walker-3.0.3.tgz",
+      "integrity": "sha512-7RUKfXgSMMkzt6ZuXmqapOurLGPPfgj6l9uRZ7lRGolvk0y2yocc35LdcxKC5PQZdn2DMqioAQ2NoWcrTKmm6g==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@types/estree": "^1.0.0"
+      }
+    },
+    "node_modules/esutils": {
+      "version": "2.0.3",
+      "resolved": "https://registry.npmjs.org/esutils/-/esutils-2.0.3.tgz",
+      "integrity": "sha512-kVscqXk4OCp68SZ0dkgEKVi6/8ij300KBWTJq32P/dYeWTSwK41WyTxalN1eRmA5Z9UU/LX9D7FWSmV9SAYx6g==",
+      "license": "BSD-2-Clause",
+      "engines": {
+        "node": ">=0.10.0"
+      }
+    },
+    "node_modules/event-emitter": {
+      "version": "0.3.5",
+      "resolved": "https://registry.npmjs.org/event-emitter/-/event-emitter-0.3.5.tgz",
+      "integrity": "sha512-D9rRn9y7kLPnJ+hMq7S/nhvoKwwvVJahBi2BPmx3bvbsEdK3W9ii8cBSGjP+72/LnM4n6fo3+dkCX5FeTQruXA==",
+      "license": "MIT",
+      "peer": true,
+      "dependencies": {
+        "d": "1",
+        "es5-ext": "~0.10.14"
+      }
+    },
+    "node_modules/events": {
+      "version": "3.3.0",
+      "resolved": "https://registry.npmjs.org/events/-/events-3.3.0.tgz",
+      "integrity": "sha512-mQw+2fkQbALzQ7V0MY0IqdnXNOeTtP4r0lN9z7AAawCXgqea7bDii20AYrIBrFd/Hx0M2Ocz6S111CaFkUcb0Q==",
+      "license": "MIT",
+      "peer": true,
+      "engines": {
+        "node": ">=0.8.x"
+      }
+    },
+    "node_modules/expect-type": {
+      "version": "1.2.2",
+      "resolved": "https://registry.npmjs.org/expect-type/-/expect-type-1.2.2.tgz",
+      "integrity": "sha512-JhFGDVJ7tmDJItKhYgJCGLOWjuK9vPxiXoUFLwLDc99NlmklilbiQJwoctZtt13+xMw91MCk/REan6MWHqDjyA==",
+      "dev": true,
+      "license": "Apache-2.0",
+      "engines": {
+        "node": ">=12.0.0"
+      }
+    },
+    "node_modules/ext": {
+      "version": "1.7.0",
+      "resolved": "https://registry.npmjs.org/ext/-/ext-1.7.0.tgz",
+      "integrity": "sha512-6hxeJYaL110a9b5TEJSj0gojyHQAmA2ch5Os+ySCiA1QGdS697XWY1pzsrSjqA9LDEEgdB/KypIlR59RcLuHYw==",
+      "license": "ISC",
+      "peer": true,
+      "dependencies": {
+        "type": "^2.7.2"
+      }
+    },
+    "node_modules/extend-shallow": {
+      "version": "2.0.1",
+      "resolved": "https://registry.npmjs.org/extend-shallow/-/extend-shallow-2.0.1.tgz",
+      "integrity": "sha512-zCnTtlxNoAiDc3gqY2aYAWFx7XWWiasuF2K8Me5WbN8otHKTUKBwjPtNpRs/rbUZm7KxWAaNj7P1a/p52GbVug==",
+      "license": "MIT",
+      "dependencies": {
+        "is-extendable": "^0.1.0"
+      },
+      "engines": {
+        "node": ">=0.10.0"
+      }
+    },
+    "node_modules/falafel": {
+      "version": "2.2.5",
+      "resolved": "https://registry.npmjs.org/falafel/-/falafel-2.2.5.tgz",
+      "integrity": "sha512-HuC1qF9iTnHDnML9YZAdCDQwT0yKl/U55K4XSUXqGAA2GLoafFgWRqdAbhWJxXaYD4pyoVxAJ8wH670jMpI9DQ==",
+      "license": "MIT",
+      "peer": true,
+      "dependencies": {
+        "acorn": "^7.1.1",
+        "isarray": "^2.0.1"
+      },
+      "engines": {
+        "node": ">=0.4.0"
+      }
+    },
+    "node_modules/falafel/node_modules/acorn": {
+      "version": "7.4.1",
+      "resolved": "https://registry.npmjs.org/acorn/-/acorn-7.4.1.tgz",
+      "integrity": "sha512-nQyp0o1/mNdbTO1PO6kHkwSrmgZ0MT/jCCpNiwbUjGoRN4dlBhqJtoQuCnEOKzgTVwg0ZWiCoQy6SxMebQVh8A==",
+      "license": "MIT",
+      "peer": true,
+      "bin": {
+        "acorn": "bin/acorn"
+      },
+      "engines": {
+        "node": ">=0.4.0"
+      }
+    },
+    "node_modules/fast-deep-equal": {
+      "version": "3.1.3",
+      "resolved": "https://registry.npmjs.org/fast-deep-equal/-/fast-deep-equal-3.1.3.tgz",
+      "integrity": "sha512-f3qQ9oQy9j2AhBe/H9VC91wLmKBCCU/gDOnKNAYG5hswO7BLKj09Hc5HYNz9cGI++xlpDCIgDaitVs03ATR84Q==",
+      "dev": true,
+      "license": "MIT"
+    },
+    "node_modules/fast-glob": {
+      "version": "3.3.3",
+      "resolved": "https://registry.npmjs.org/fast-glob/-/fast-glob-3.3.3.tgz",
+      "integrity": "sha512-7MptL8U0cqcFdzIzwOTHoilX9x5BrNqye7Z/LuC7kCMRio1EMSyqRK3BEAUD7sXRq4iT4AzTVuZdhgQ2TCvYLg==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@nodelib/fs.stat": "^2.0.2",
+        "@nodelib/fs.walk": "^1.2.3",
+        "glob-parent": "^5.1.2",
+        "merge2": "^1.3.0",
+        "micromatch": "^4.0.8"
+      },
+      "engines": {
+        "node": ">=8.6.0"
+      }
+    },
+    "node_modules/fast-glob/node_modules/glob-parent": {
+      "version": "5.1.2",
+      "resolved": "https://registry.npmjs.org/glob-parent/-/glob-parent-5.1.2.tgz",
+      "integrity": "sha512-AOIgSQCepiJYwP3ARnGx+5VnTu2HBYdzbGP45eLw1vr3zB3vZLeyed1sC9hnbcOc9/SrMyM5RPQrkGz4aS9Zow==",
+      "dev": true,
+      "license": "ISC",
+      "dependencies": {
+        "is-glob": "^4.0.1"
+      },
+      "engines": {
+        "node": ">= 6"
+      }
+    },
+    "node_modules/fast-isnumeric": {
+      "version": "1.1.4",
+      "resolved": "https://registry.npmjs.org/fast-isnumeric/-/fast-isnumeric-1.1.4.tgz",
+      "integrity": "sha512-1mM8qOr2LYz8zGaUdmiqRDiuue00Dxjgcb1NQR7TnhLVh6sQyngP9xvLo7Sl7LZpP/sk5eb+bcyWXw530NTBZw==",
+      "license": "MIT",
+      "peer": true,
+      "dependencies": {
+        "is-string-blank": "^1.0.1"
+      }
+    },
+    "node_modules/fast-json-stable-stringify": {
+      "version": "2.1.0",
+      "resolved": "https://registry.npmjs.org/fast-json-stable-stringify/-/fast-json-stable-stringify-2.1.0.tgz",
+      "integrity": "sha512-lhd/wF+Lk98HZoTCtlVraHtfh5XYijIjalXck7saUtuanSDyLMxnHhSXEDJqHxD7msR8D0uCmqlkwjCV8xvwHw==",
+      "dev": true,
+      "license": "MIT"
+    },
+    "node_modules/fast-levenshtein": {
+      "version": "2.0.6",
+      "resolved": "https://registry.npmjs.org/fast-levenshtein/-/fast-levenshtein-2.0.6.tgz",
+      "integrity": "sha512-DCXu6Ifhqcks7TZKY3Hxp3y6qphY5SJZmrWMDrKcERSOXWQdMhU9Ig/PYrzyw/ul9jOIyh0N4M0tbC5hodg8dw==",
+      "dev": true,
+      "license": "MIT"
+    },
+    "node_modules/fastq": {
+      "version": "1.19.1",
+      "resolved": "https://registry.npmjs.org/fastq/-/fastq-1.19.1.tgz",
+      "integrity": "sha512-GwLTyxkCXjXbxqIhTsMI2Nui8huMPtnxg7krajPJAjnEG/iiOS7i+zCtWGZR9G0NBKbXKh6X9m9UIsYX/N6vvQ==",
+      "dev": true,
+      "license": "ISC",
+      "dependencies": {
+        "reusify": "^1.0.4"
+      }
+    },
+    "node_modules/file-entry-cache": {
+      "version": "6.0.1",
+      "resolved": "https://registry.npmjs.org/file-entry-cache/-/file-entry-cache-6.0.1.tgz",
+      "integrity": "sha512-7Gps/XWymbLk2QLYK4NzpMOrYjMhdIxXuIvy2QBsLE6ljuodKvdkWs/cpyJJ3CVIVpH0Oi1Hvg1ovbMzLdFBBg==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "flat-cache": "^3.0.4"
+      },
+      "engines": {
+        "node": "^10.12.0 || >=12.0.0"
+      }
+    },
+    "node_modules/fill-range": {
+      "version": "7.1.1",
+      "resolved": "https://registry.npmjs.org/fill-range/-/fill-range-7.1.1.tgz",
+      "integrity": "sha512-YsGpe3WHLK8ZYi4tWDg2Jy3ebRz2rXowDxnld4bkQB00cc/1Zw9AWnC0i9ztDJitivtQvaI9KaLyKrc+hBW0yg==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "to-regex-range": "^5.0.1"
+      },
+      "engines": {
+        "node": ">=8"
+      }
+    },
+    "node_modules/find-replace": {
+      "version": "5.0.2",
+      "resolved": "https://registry.npmjs.org/find-replace/-/find-replace-5.0.2.tgz",
+      "integrity": "sha512-Y45BAiE3mz2QsrN2fb5QEtO4qb44NcS7en/0y9PEVsg351HsLeVclP8QPMH79Le9sH3rs5RSwJu99W0WPZO43Q==",
+      "license": "MIT",
+      "engines": {
+        "node": ">=14"
+      },
+      "peerDependencies": {
+        "@75lb/nature": "latest"
+      },
+      "peerDependenciesMeta": {
+        "@75lb/nature": {
+          "optional": true
+        }
+      }
+    },
+    "node_modules/find-up": {
+      "version": "5.0.0",
+      "resolved": "https://registry.npmjs.org/find-up/-/find-up-5.0.0.tgz",
+      "integrity": "sha512-78/PXT1wlLLDgTzDs7sjq9hzz0vXD+zn+7wypEe4fXQxCmdmqfGsEPQxmiCSQI3ajFV91bVSsvNtrJRiW6nGng==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "locate-path": "^6.0.0",
+        "path-exists": "^4.0.0"
+      },
+      "engines": {
+        "node": ">=10"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/sindresorhus"
+      }
+    },
+    "node_modules/flat-cache": {
+      "version": "3.2.0",
+      "resolved": "https://registry.npmjs.org/flat-cache/-/flat-cache-3.2.0.tgz",
+      "integrity": "sha512-CYcENa+FtcUKLmhhqyctpclsq7QF38pKjZHsGNiSQF5r4FtoKDWabFDl3hzaEQMvT1LHEysw5twgLvpYYb4vbw==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "flatted": "^3.2.9",
+        "keyv": "^4.5.3",
+        "rimraf": "^3.0.2"
+      },
+      "engines": {
+        "node": "^10.12.0 || >=12.0.0"
+      }
+    },
+    "node_modules/flatbuffers": {
+      "version": "25.9.23",
+      "resolved": "https://registry.npmjs.org/flatbuffers/-/flatbuffers-25.9.23.tgz",
+      "integrity": "sha512-MI1qs7Lo4Syw0EOzUl0xjs2lsoeqFku44KpngfIduHBYvzm8h2+7K8YMQh1JtVVVrUvhLpNwqVi4DERegUJhPQ==",
+      "license": "Apache-2.0"
+    },
+    "node_modules/flatted": {
+      "version": "3.3.3",
+      "resolved": "https://registry.npmjs.org/flatted/-/flatted-3.3.3.tgz",
+      "integrity": "sha512-GX+ysw4PBCz0PzosHDepZGANEuFCMLrnRTiEy9McGjmkCQYwRq4A/X786G/fjM/+OjsWSU1ZrY5qyARZmO/uwg==",
+      "dev": true,
+      "license": "ISC"
+    },
+    "node_modules/flatten-vertex-data": {
+      "version": "1.0.2",
+      "resolved": "https://registry.npmjs.org/flatten-vertex-data/-/flatten-vertex-data-1.0.2.tgz",
+      "integrity": "sha512-BvCBFK2NZqerFTdMDgqfHBwxYWnxeCkwONsw6PvBMcUXqo8U/KDWwmXhqx1x2kLIg7DqIsJfOaJFOmlua3Lxuw==",
+      "license": "MIT",
+      "peer": true,
+      "dependencies": {
+        "dtype": "^2.0.0"
+      }
+    },
+    "node_modules/font-atlas": {
+      "version": "2.1.0",
+      "resolved": "https://registry.npmjs.org/font-atlas/-/font-atlas-2.1.0.tgz",
+      "integrity": "sha512-kP3AmvX+HJpW4w3d+PiPR2X6E1yvsBXt2yhuCw+yReO9F1WYhvZwx3c95DGZGwg9xYzDGrgJYa885xmVA+28Cg==",
+      "license": "MIT",
+      "peer": true,
+      "dependencies": {
+        "css-font": "^1.0.0"
+      }
     },
-    "node_modules/@rollup/rollup-freebsd-x64": {
-      "version": "4.41.1",
-      "resolved": "https://registry.npmjs.org/@rollup/rollup-freebsd-x64/-/rollup-freebsd-x64-4.41.1.tgz",
-      "integrity": "sha512-3FkydeohozEskBxNWEIbPfOE0aqQgB6ttTkJ159uWOFn42VLyfAiyD9UK5mhu+ItWzft60DycIN1Xdgiy8o/SA==",
-      "cpu": [
-        "x64"
-      ],
+    "node_modules/font-measure": {
+      "version": "1.2.2",
+      "resolved": "https://registry.npmjs.org/font-measure/-/font-measure-1.2.2.tgz",
+      "integrity": "sha512-mRLEpdrWzKe9hbfaF3Qpr06TAjquuBVP5cHy4b3hyeNdjc9i0PO6HniGsX5vjL5OWv7+Bd++NiooNpT/s8BvIA==",
+      "license": "MIT",
+      "peer": true,
+      "dependencies": {
+        "css-font": "^1.2.0"
+      }
+    },
+    "node_modules/from2": {
+      "version": "2.3.0",
+      "resolved": "https://registry.npmjs.org/from2/-/from2-2.3.0.tgz",
+      "integrity": "sha512-OMcX/4IC/uqEPVgGeyfN22LJk6AZrMkRZHxcHBMBvHScDGgwTm2GT2Wkgtocyd3JfZffjj2kYUDXXII0Fk9W0g==",
+      "license": "MIT",
+      "peer": true,
+      "dependencies": {
+        "inherits": "^2.0.1",
+        "readable-stream": "^2.0.0"
+      }
+    },
+    "node_modules/fs.realpath": {
+      "version": "1.0.0",
+      "resolved": "https://registry.npmjs.org/fs.realpath/-/fs.realpath-1.0.0.tgz",
+      "integrity": "sha512-OO0pH2lK6a0hZnAdau5ItzHPI6pUlvI7jMVnxUQRtw4owF2wk8lOSabtGDCTP4Ggrg2MbGnWO9X8K1t4+fGMDw==",
+      "dev": true,
+      "license": "ISC"
+    },
+    "node_modules/fsevents": {
+      "version": "2.3.3",
+      "resolved": "https://registry.npmjs.org/fsevents/-/fsevents-2.3.3.tgz",
+      "integrity": "sha512-5xoDfX+fL7faATnagmWPpbFtwh/R77WmMMqqHGS65C3vvB0YHrgF+B1YmZ3441tMj5n63k0212XNoJwzlhffQw==",
       "dev": true,
+      "hasInstallScript": true,
       "license": "MIT",
       "optional": true,
       "os": [
-        "freebsd"
-      ]
-    },
-    "node_modules/@rollup/rollup-linux-arm-gnueabihf": {
-      "version": "4.41.1",
-      "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-arm-gnueabihf/-/rollup-linux-arm-gnueabihf-4.41.1.tgz",
-      "integrity": "sha512-wC53ZNDgt0pqx5xCAgNunkTzFE8GTgdZ9EwYGVcg+jEjJdZGtq9xPjDnFgfFozQI/Xm1mh+D9YlYtl+ueswNEg==",
-      "cpu": [
-        "arm"
+        "darwin"
       ],
+      "engines": {
+        "node": "^8.16.0 || ^10.6.0 || >=11.0.0"
+      }
+    },
+    "node_modules/function-bind": {
+      "version": "1.1.2",
+      "resolved": "https://registry.npmjs.org/function-bind/-/function-bind-1.1.2.tgz",
+      "integrity": "sha512-7XHNxH7qX9xG5mIwxkhumTox/MIRNcOgDrxWsMt2pAr23WHp6MrRlN7FBSFpCpr+oVO0F744iUgR82nJMfG2SA==",
+      "license": "MIT",
+      "peer": true,
+      "funding": {
+        "url": "https://github.com/sponsors/ljharb"
+      }
+    },
+    "node_modules/gensync": {
+      "version": "1.0.0-beta.2",
+      "resolved": "https://registry.npmjs.org/gensync/-/gensync-1.0.0-beta.2.tgz",
+      "integrity": "sha512-3hN7NaskYvMDLQY55gnW3NQ+mesEAepTqlg+VEbj7zzqEMBVNhzcGYYeqFo/TlYz6eQiFcp1HcsCZO+nGgS8zg==",
       "dev": true,
       "license": "MIT",
-      "optional": true,
-      "os": [
-        "linux"
-      ]
+      "engines": {
+        "node": ">=6.9.0"
+      }
     },
-    "node_modules/@rollup/rollup-linux-arm-musleabihf": {
-      "version": "4.41.1",
-      "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-arm-musleabihf/-/rollup-linux-arm-musleabihf-4.41.1.tgz",
-      "integrity": "sha512-jwKCca1gbZkZLhLRtsrka5N8sFAaxrGz/7wRJ8Wwvq3jug7toO21vWlViihG85ei7uJTpzbXZRcORotE+xyrLA==",
-      "cpu": [
-        "arm"
-      ],
+    "node_modules/geojson-vt": {
+      "version": "3.2.1",
+      "resolved": "https://registry.npmjs.org/geojson-vt/-/geojson-vt-3.2.1.tgz",
+      "integrity": "sha512-EvGQQi/zPrDA6zr6BnJD/YhwAkBP8nnJ9emh3EnHQKVMfg/MRVtPbMYdgVy/IaEmn4UfagD2a6fafPDL5hbtwg==",
+      "license": "ISC",
+      "peer": true
+    },
+    "node_modules/get-canvas-context": {
+      "version": "1.0.2",
+      "resolved": "https://registry.npmjs.org/get-canvas-context/-/get-canvas-context-1.0.2.tgz",
+      "integrity": "sha512-LnpfLf/TNzr9zVOGiIY6aKCz8EKuXmlYNV7CM2pUjBa/B+c2I15tS7KLySep75+FuerJdmArvJLcsAXWEy2H0A==",
+      "license": "MIT",
+      "peer": true
+    },
+    "node_modules/get-stream": {
+      "version": "6.0.1",
+      "resolved": "https://registry.npmjs.org/get-stream/-/get-stream-6.0.1.tgz",
+      "integrity": "sha512-ts6Wi+2j3jQjqi70w5AlN8DFnkSwC+MqmxEzdEALB2qXZYV3X/b1CTfgPLGJNMeAWxdPfU8FO1ms3NUfaHCPYg==",
+      "license": "MIT",
+      "peer": true,
+      "engines": {
+        "node": ">=10"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/sindresorhus"
+      }
+    },
+    "node_modules/get-value": {
+      "version": "2.0.6",
+      "resolved": "https://registry.npmjs.org/get-value/-/get-value-2.0.6.tgz",
+      "integrity": "sha512-Ln0UQDlxH1BapMu3GPtf7CuYNwRZf2gwCuPqbyG6pB8WfmFpzqcy4xtAaAMUhnNqjMKTiCPZG2oMT3YSx8U2NA==",
+      "license": "MIT",
+      "engines": {
+        "node": ">=0.10.0"
+      }
+    },
+    "node_modules/gl-mat4": {
+      "version": "1.2.0",
+      "resolved": "https://registry.npmjs.org/gl-mat4/-/gl-mat4-1.2.0.tgz",
+      "integrity": "sha512-sT5C0pwB1/e9G9AvAoLsoaJtbMGjfd/jfxo8jMCKqYYEnjZuFvqV5rehqar0538EmssjdDeiEWnKyBSTw7quoA==",
+      "license": "Zlib",
+      "peer": true
+    },
+    "node_modules/gl-matrix": {
+      "version": "3.4.4",
+      "resolved": "https://registry.npmjs.org/gl-matrix/-/gl-matrix-3.4.4.tgz",
+      "integrity": "sha512-latSnyDNt/8zYUB6VIJ6PCh2jBjJX6gnDsoCZ7LyW7GkqrD51EWwa9qCoGixj8YqBtETQK/xY7OmpTF8xz1DdQ==",
+      "license": "MIT"
+    },
+    "node_modules/gl-text": {
+      "version": "1.4.0",
+      "resolved": "https://registry.npmjs.org/gl-text/-/gl-text-1.4.0.tgz",
+      "integrity": "sha512-o47+XBqLCj1efmuNyCHt7/UEJmB9l66ql7pnobD6p+sgmBUdzfMZXIF0zD2+KRfpd99DJN+QXdvTFAGCKCVSmQ==",
+      "license": "MIT",
+      "peer": true,
+      "dependencies": {
+        "bit-twiddle": "^1.0.2",
+        "color-normalize": "^1.5.0",
+        "css-font": "^1.2.0",
+        "detect-kerning": "^2.1.2",
+        "es6-weak-map": "^2.0.3",
+        "flatten-vertex-data": "^1.0.2",
+        "font-atlas": "^2.1.0",
+        "font-measure": "^1.2.2",
+        "gl-util": "^3.1.2",
+        "is-plain-obj": "^1.1.0",
+        "object-assign": "^4.1.1",
+        "parse-rect": "^1.2.0",
+        "parse-unit": "^1.0.1",
+        "pick-by-alias": "^1.2.0",
+        "regl": "^2.0.0",
+        "to-px": "^1.0.1",
+        "typedarray-pool": "^1.1.0"
+      }
+    },
+    "node_modules/gl-util": {
+      "version": "3.1.3",
+      "resolved": "https://registry.npmjs.org/gl-util/-/gl-util-3.1.3.tgz",
+      "integrity": "sha512-dvRTggw5MSkJnCbh74jZzSoTOGnVYK+Bt+Ckqm39CVcl6+zSsxqWk4lr5NKhkqXHL6qvZAU9h17ZF8mIskY9mA==",
+      "license": "MIT",
+      "peer": true,
+      "dependencies": {
+        "is-browser": "^2.0.1",
+        "is-firefox": "^1.0.3",
+        "is-plain-obj": "^1.1.0",
+        "number-is-integer": "^1.0.1",
+        "object-assign": "^4.1.0",
+        "pick-by-alias": "^1.2.0",
+        "weak-map": "^1.0.5"
+      }
+    },
+    "node_modules/glob": {
+      "version": "7.2.3",
+      "resolved": "https://registry.npmjs.org/glob/-/glob-7.2.3.tgz",
+      "integrity": "sha512-nFR0zLpU2YCaRxwoCJvL6UvCH2JFyFVIvwTLsIf21AuHlMskA1hhTdk+LlYJtOlYt9v6dvszD2BGRqBL+iQK9Q==",
+      "deprecated": "Glob versions prior to v9 are no longer supported",
+      "dev": true,
+      "license": "ISC",
+      "dependencies": {
+        "fs.realpath": "^1.0.0",
+        "inflight": "^1.0.4",
+        "inherits": "2",
+        "minimatch": "^3.1.1",
+        "once": "^1.3.0",
+        "path-is-absolute": "^1.0.0"
+      },
+      "engines": {
+        "node": "*"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/isaacs"
+      }
+    },
+    "node_modules/glob-parent": {
+      "version": "6.0.2",
+      "resolved": "https://registry.npmjs.org/glob-parent/-/glob-parent-6.0.2.tgz",
+      "integrity": "sha512-XxwI8EOhVQgWp6iDL+3b0r86f4d6AX6zSU55HfB4ydCEuXLXc5FcYeOu+nnGftS4TEju/11rt4KJPTMgbfmv4A==",
+      "dev": true,
+      "license": "ISC",
+      "dependencies": {
+        "is-glob": "^4.0.3"
+      },
+      "engines": {
+        "node": ">=10.13.0"
+      }
+    },
+    "node_modules/glob/node_modules/brace-expansion": {
+      "version": "1.1.11",
+      "resolved": "https://registry.npmjs.org/brace-expansion/-/brace-expansion-1.1.11.tgz",
+      "integrity": "sha512-iCuPHDFgrHX7H2vEI/5xpz07zSHB00TpugqhmYtVmMO6518mCuRMoOYFldEBl0g187ufozdaHgWKcYFb61qGiA==",
       "dev": true,
       "license": "MIT",
-      "optional": true,
-      "os": [
-        "linux"
-      ]
+      "dependencies": {
+        "balanced-match": "^1.0.0",
+        "concat-map": "0.0.1"
+      }
     },
-    "node_modules/@rollup/rollup-linux-arm64-gnu": {
-      "version": "4.41.1",
-      "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-arm64-gnu/-/rollup-linux-arm64-gnu-4.41.1.tgz",
-      "integrity": "sha512-g0UBcNknsmmNQ8V2d/zD2P7WWfJKU0F1nu0k5pW4rvdb+BIqMm8ToluW/eeRmxCared5dD76lS04uL4UaNgpNA==",
-      "cpu": [
-        "arm64"
-      ],
+    "node_modules/glob/node_modules/minimatch": {
+      "version": "3.1.2",
+      "resolved": "https://registry.npmjs.org/minimatch/-/minimatch-3.1.2.tgz",
+      "integrity": "sha512-J7p63hRiAjw1NDEww1W7i37+ByIrOWO5XQQAzZ3VOcL0PNybwpfmV/N05zFAzwQ9USyEcX6t3UO+K5aqBQOIHw==",
       "dev": true,
+      "license": "ISC",
+      "dependencies": {
+        "brace-expansion": "^1.1.7"
+      },
+      "engines": {
+        "node": "*"
+      }
+    },
+    "node_modules/global-prefix": {
+      "version": "4.0.0",
+      "resolved": "https://registry.npmjs.org/global-prefix/-/global-prefix-4.0.0.tgz",
+      "integrity": "sha512-w0Uf9Y9/nyHinEk5vMJKRie+wa4kR5hmDbEhGGds/kG1PwGLLHKRoNMeJOyCQjjBkANlnScqgzcFwGHgmgLkVA==",
       "license": "MIT",
-      "optional": true,
-      "os": [
-        "linux"
-      ]
+      "peer": true,
+      "dependencies": {
+        "ini": "^4.1.3",
+        "kind-of": "^6.0.3",
+        "which": "^4.0.0"
+      },
+      "engines": {
+        "node": ">=16"
+      }
     },
-    "node_modules/@rollup/rollup-linux-arm64-musl": {
-      "version": "4.41.1",
-      "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-arm64-musl/-/rollup-linux-arm64-musl-4.41.1.tgz",
-      "integrity": "sha512-XZpeGB5TKEZWzIrj7sXr+BEaSgo/ma/kCgrZgL0oo5qdB1JlTzIYQKel/RmhT6vMAvOdM2teYlAaOGJpJ9lahg==",
-      "cpu": [
-        "arm64"
-      ],
+    "node_modules/global-prefix/node_modules/isexe": {
+      "version": "3.1.5",
+      "resolved": "https://registry.npmjs.org/isexe/-/isexe-3.1.5.tgz",
+      "integrity": "sha512-6B3tLtFqtQS4ekarvLVMZ+X+VlvQekbe4taUkf/rhVO3d/h0M2rfARm/pXLcPEsjjMsFgrFgSrhQIxcSVrBz8w==",
+      "license": "BlueOak-1.0.0",
+      "peer": true,
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/global-prefix/node_modules/which": {
+      "version": "4.0.0",
+      "resolved": "https://registry.npmjs.org/which/-/which-4.0.0.tgz",
+      "integrity": "sha512-GlaYyEb07DPxYCKhKzplCWBJtvxZcZMrL+4UkrTSJHHPyZU4mYYTv3qaOe77H7EODLSSopAUFAc6W8U4yqvscg==",
+      "license": "ISC",
+      "peer": true,
+      "dependencies": {
+        "isexe": "^3.1.1"
+      },
+      "bin": {
+        "node-which": "bin/which.js"
+      },
+      "engines": {
+        "node": "^16.13.0 || >=18.0.0"
+      }
+    },
+    "node_modules/globals": {
+      "version": "11.12.0",
+      "resolved": "https://registry.npmjs.org/globals/-/globals-11.12.0.tgz",
+      "integrity": "sha512-WOBp/EEGUiIsJSp7wcv/y6MO+lV9UoncWqxuFfm8eBwzWNgyfBd6Gz+IeKQ9jCmyhoH99g15M3T+QaVHFjizVA==",
       "dev": true,
       "license": "MIT",
-      "optional": true,
-      "os": [
-        "linux"
-      ]
+      "engines": {
+        "node": ">=4"
+      }
     },
-    "node_modules/@rollup/rollup-linux-loongarch64-gnu": {
-      "version": "4.41.1",
-      "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-loongarch64-gnu/-/rollup-linux-loongarch64-gnu-4.41.1.tgz",
-      "integrity": "sha512-bkCfDJ4qzWfFRCNt5RVV4DOw6KEgFTUZi2r2RuYhGWC8WhCA8lCAJhDeAmrM/fdiAH54m0mA0Vk2FGRPyzI+tw==",
-      "cpu": [
-        "loong64"
-      ],
+    "node_modules/globby": {
+      "version": "11.1.0",
+      "resolved": "https://registry.npmjs.org/globby/-/globby-11.1.0.tgz",
+      "integrity": "sha512-jhIXaOzy1sb8IyocaruWSn1TjmnBVs8Ayhcy83rmxNJ8q2uWKCAj3CnJY+KpGSXCueAPc0i05kVvVKtP1t9S3g==",
       "dev": true,
       "license": "MIT",
-      "optional": true,
-      "os": [
-        "linux"
-      ]
+      "dependencies": {
+        "array-union": "^2.1.0",
+        "dir-glob": "^3.0.1",
+        "fast-glob": "^3.2.9",
+        "ignore": "^5.2.0",
+        "merge2": "^1.4.1",
+        "slash": "^3.0.0"
+      },
+      "engines": {
+        "node": ">=10"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/sindresorhus"
+      }
+    },
+    "node_modules/glsl-inject-defines": {
+      "version": "1.0.3",
+      "resolved": "https://registry.npmjs.org/glsl-inject-defines/-/glsl-inject-defines-1.0.3.tgz",
+      "integrity": "sha512-W49jIhuDtF6w+7wCMcClk27a2hq8znvHtlGnrYkSWEr8tHe9eA2dcnohlcAmxLYBSpSSdzOkRdyPTrx9fw49+A==",
+      "license": "MIT",
+      "peer": true,
+      "dependencies": {
+        "glsl-token-inject-block": "^1.0.0",
+        "glsl-token-string": "^1.0.1",
+        "glsl-tokenizer": "^2.0.2"
+      }
+    },
+    "node_modules/glsl-resolve": {
+      "version": "0.0.1",
+      "resolved": "https://registry.npmjs.org/glsl-resolve/-/glsl-resolve-0.0.1.tgz",
+      "integrity": "sha512-xxFNsfnhZTK9NBhzJjSBGX6IOqYpvBHxxmo+4vapiljyGNCY0Bekzn0firQkQrazK59c1hYxMDxYS8MDlhw4gA==",
+      "license": "MIT",
+      "peer": true,
+      "dependencies": {
+        "resolve": "^0.6.1",
+        "xtend": "^2.1.2"
+      }
+    },
+    "node_modules/glsl-resolve/node_modules/resolve": {
+      "version": "0.6.3",
+      "resolved": "https://registry.npmjs.org/resolve/-/resolve-0.6.3.tgz",
+      "integrity": "sha512-UHBY3viPlJKf85YijDUcikKX6tmF4SokIDp518ZDVT92JNDcG5uKIthaT/owt3Sar0lwtOafsQuwrg22/v2Dwg==",
+      "license": "MIT",
+      "peer": true
     },
-    "node_modules/@rollup/rollup-linux-powerpc64le-gnu": {
-      "version": "4.41.1",
-      "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-powerpc64le-gnu/-/rollup-linux-powerpc64le-gnu-4.41.1.tgz",
-      "integrity": "sha512-3mr3Xm+gvMX+/8EKogIZSIEF0WUu0HL9di+YWlJpO8CQBnoLAEL/roTCxuLncEdgcfJcvA4UMOf+2dnjl4Ut1A==",
-      "cpu": [
-        "ppc64"
-      ],
-      "dev": true,
+    "node_modules/glsl-resolve/node_modules/xtend": {
+      "version": "2.2.0",
+      "resolved": "https://registry.npmjs.org/xtend/-/xtend-2.2.0.tgz",
+      "integrity": "sha512-SLt5uylT+4aoXxXuwtQp5ZnMMzhDb1Xkg4pEqc00WUJCQifPfV9Ub1VrNhp9kXkrjZD2I2Hl8WnjP37jzZLPZw==",
+      "peer": true,
+      "engines": {
+        "node": ">=0.4"
+      }
+    },
+    "node_modules/glsl-token-assignments": {
+      "version": "2.0.2",
+      "resolved": "https://registry.npmjs.org/glsl-token-assignments/-/glsl-token-assignments-2.0.2.tgz",
+      "integrity": "sha512-OwXrxixCyHzzA0U2g4btSNAyB2Dx8XrztY5aVUCjRSh4/D0WoJn8Qdps7Xub3sz6zE73W3szLrmWtQ7QMpeHEQ==",
       "license": "MIT",
-      "optional": true,
-      "os": [
-        "linux"
-      ]
+      "peer": true
     },
-    "node_modules/@rollup/rollup-linux-riscv64-gnu": {
-      "version": "4.41.1",
-      "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-riscv64-gnu/-/rollup-linux-riscv64-gnu-4.41.1.tgz",
-      "integrity": "sha512-3rwCIh6MQ1LGrvKJitQjZFuQnT2wxfU+ivhNBzmxXTXPllewOF7JR1s2vMX/tWtUYFgphygxjqMl76q4aMotGw==",
-      "cpu": [
-        "riscv64"
-      ],
-      "dev": true,
+    "node_modules/glsl-token-defines": {
+      "version": "1.0.0",
+      "resolved": "https://registry.npmjs.org/glsl-token-defines/-/glsl-token-defines-1.0.0.tgz",
+      "integrity": "sha512-Vb5QMVeLjmOwvvOJuPNg3vnRlffscq2/qvIuTpMzuO/7s5kT+63iL6Dfo2FYLWbzuiycWpbC0/KV0biqFwHxaQ==",
       "license": "MIT",
-      "optional": true,
-      "os": [
-        "linux"
-      ]
+      "peer": true,
+      "dependencies": {
+        "glsl-tokenizer": "^2.0.0"
+      }
     },
-    "node_modules/@rollup/rollup-linux-riscv64-musl": {
-      "version": "4.41.1",
-      "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-riscv64-musl/-/rollup-linux-riscv64-musl-4.41.1.tgz",
-      "integrity": "sha512-LdIUOb3gvfmpkgFZuccNa2uYiqtgZAz3PTzjuM5bH3nvuy9ty6RGc/Q0+HDFrHrizJGVpjnTZ1yS5TNNjFlklw==",
-      "cpu": [
-        "riscv64"
-      ],
-      "dev": true,
+    "node_modules/glsl-token-depth": {
+      "version": "1.1.2",
+      "resolved": "https://registry.npmjs.org/glsl-token-depth/-/glsl-token-depth-1.1.2.tgz",
+      "integrity": "sha512-eQnIBLc7vFf8axF9aoi/xW37LSWd2hCQr/3sZui8aBJnksq9C7zMeUYHVJWMhFzXrBU7fgIqni4EhXVW4/krpg==",
       "license": "MIT",
-      "optional": true,
-      "os": [
-        "linux"
-      ]
+      "peer": true
     },
-    "node_modules/@rollup/rollup-linux-s390x-gnu": {
-      "version": "4.41.1",
-      "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-s390x-gnu/-/rollup-linux-s390x-gnu-4.41.1.tgz",
-      "integrity": "sha512-oIE6M8WC9ma6xYqjvPhzZYk6NbobIURvP/lEbh7FWplcMO6gn7MM2yHKA1eC/GvYwzNKK/1LYgqzdkZ8YFxR8g==",
-      "cpu": [
-        "s390x"
-      ],
-      "dev": true,
+    "node_modules/glsl-token-descope": {
+      "version": "1.0.2",
+      "resolved": "https://registry.npmjs.org/glsl-token-descope/-/glsl-token-descope-1.0.2.tgz",
+      "integrity": "sha512-kS2PTWkvi/YOeicVjXGgX5j7+8N7e56srNDEHDTVZ1dcESmbmpmgrnpjPcjxJjMxh56mSXYoFdZqb90gXkGjQw==",
       "license": "MIT",
-      "optional": true,
-      "os": [
-        "linux"
-      ]
+      "peer": true,
+      "dependencies": {
+        "glsl-token-assignments": "^2.0.0",
+        "glsl-token-depth": "^1.1.0",
+        "glsl-token-properties": "^1.0.0",
+        "glsl-token-scope": "^1.1.0"
+      }
     },
-    "node_modules/@rollup/rollup-linux-x64-gnu": {
-      "version": "4.41.1",
-      "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-x64-gnu/-/rollup-linux-x64-gnu-4.41.1.tgz",
-      "integrity": "sha512-cWBOvayNvA+SyeQMp79BHPK8ws6sHSsYnK5zDcsC3Hsxr1dgTABKjMnMslPq1DvZIp6uO7kIWhiGwaTdR4Og9A==",
-      "cpu": [
-        "x64"
-      ],
-      "dev": true,
+    "node_modules/glsl-token-inject-block": {
+      "version": "1.1.0",
+      "resolved": "https://registry.npmjs.org/glsl-token-inject-block/-/glsl-token-inject-block-1.1.0.tgz",
+      "integrity": "sha512-q/m+ukdUBuHCOtLhSr0uFb/qYQr4/oKrPSdIK2C4TD+qLaJvqM9wfXIF/OOBjuSA3pUoYHurVRNao6LTVVUPWA==",
       "license": "MIT",
-      "optional": true,
-      "os": [
-        "linux"
-      ]
+      "peer": true
     },
-    "node_modules/@rollup/rollup-linux-x64-musl": {
-      "version": "4.41.1",
-      "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-x64-musl/-/rollup-linux-x64-musl-4.41.1.tgz",
-      "integrity": "sha512-y5CbN44M+pUCdGDlZFzGGBSKCA4A/J2ZH4edTYSSxFg7ce1Xt3GtydbVKWLlzL+INfFIZAEg1ZV6hh9+QQf9YQ==",
-      "cpu": [
-        "x64"
-      ],
-      "dev": true,
+    "node_modules/glsl-token-properties": {
+      "version": "1.0.1",
+      "resolved": "https://registry.npmjs.org/glsl-token-properties/-/glsl-token-properties-1.0.1.tgz",
+      "integrity": "sha512-dSeW1cOIzbuUoYH0y+nxzwK9S9O3wsjttkq5ij9ZGw0OS41BirKJzzH48VLm8qLg+au6b0sINxGC0IrGwtQUcA==",
       "license": "MIT",
-      "optional": true,
-      "os": [
-        "linux"
-      ]
+      "peer": true
     },
-    "node_modules/@rollup/rollup-win32-arm64-msvc": {
-      "version": "4.41.1",
-      "resolved": "https://registry.npmjs.org/@rollup/rollup-win32-arm64-msvc/-/rollup-win32-arm64-msvc-4.41.1.tgz",
-      "integrity": "sha512-lZkCxIrjlJlMt1dLO/FbpZbzt6J/A8p4DnqzSa4PWqPEUUUnzXLeki/iyPLfV0BmHItlYgHUqJe+3KiyydmiNQ==",
-      "cpu": [
-        "arm64"
-      ],
-      "dev": true,
+    "node_modules/glsl-token-scope": {
+      "version": "1.1.2",
+      "resolved": "https://registry.npmjs.org/glsl-token-scope/-/glsl-token-scope-1.1.2.tgz",
+      "integrity": "sha512-YKyOMk1B/tz9BwYUdfDoHvMIYTGtVv2vbDSLh94PT4+f87z21FVdou1KNKgF+nECBTo0fJ20dpm0B1vZB1Q03A==",
       "license": "MIT",
-      "optional": true,
-      "os": [
-        "win32"
-      ]
+      "peer": true
     },
-    "node_modules/@rollup/rollup-win32-ia32-msvc": {
-      "version": "4.41.1",
-      "resolved": "https://registry.npmjs.org/@rollup/rollup-win32-ia32-msvc/-/rollup-win32-ia32-msvc-4.41.1.tgz",
-      "integrity": "sha512-+psFT9+pIh2iuGsxFYYa/LhS5MFKmuivRsx9iPJWNSGbh2XVEjk90fmpUEjCnILPEPJnikAU6SFDiEUyOv90Pg==",
-      "cpu": [
-        "ia32"
-      ],
-      "dev": true,
+    "node_modules/glsl-token-string": {
+      "version": "1.0.1",
+      "resolved": "https://registry.npmjs.org/glsl-token-string/-/glsl-token-string-1.0.1.tgz",
+      "integrity": "sha512-1mtQ47Uxd47wrovl+T6RshKGkRRCYWhnELmkEcUAPALWGTFe2XZpH3r45XAwL2B6v+l0KNsCnoaZCSnhzKEksg==",
       "license": "MIT",
-      "optional": true,
-      "os": [
-        "win32"
-      ]
+      "peer": true
     },
-    "node_modules/@rollup/rollup-win32-x64-msvc": {
-      "version": "4.41.1",
-      "resolved": "https://registry.npmjs.org/@rollup/rollup-win32-x64-msvc/-/rollup-win32-x64-msvc-4.41.1.tgz",
-      "integrity": "sha512-Wq2zpapRYLfi4aKxf2Xff0tN+7slj2d4R87WEzqw7ZLsVvO5zwYCIuEGSZYiK41+GlwUo1HiR+GdkLEJnCKTCw==",
-      "cpu": [
-        "x64"
-      ],
-      "dev": true,
+    "node_modules/glsl-token-whitespace-trim": {
+      "version": "1.0.0",
+      "resolved": "https://registry.npmjs.org/glsl-token-whitespace-trim/-/glsl-token-whitespace-trim-1.0.0.tgz",
+      "integrity": "sha512-ZJtsPut/aDaUdLUNtmBYhaCmhIjpKNg7IgZSfX5wFReMc2vnj8zok+gB/3Quqs0TsBSX/fGnqUUYZDqyuc2xLQ==",
       "license": "MIT",
-      "optional": true,
-      "os": [
-        "win32"
-      ]
+      "peer": true
     },
-    "node_modules/@types/babel__core": {
-      "version": "7.20.5",
-      "resolved": "https://registry.npmjs.org/@types/babel__core/-/babel__core-7.20.5.tgz",
-      "integrity": "sha512-qoQprZvz5wQFJwMDqeseRXWv3rqMvhgpbXFfVyWhbx9X47POIA6i/+dXefEmZKoAgOaTdaIgNSMqMIU61yRyzA==",
-      "dev": true,
+    "node_modules/glsl-tokenizer": {
+      "version": "2.1.5",
+      "resolved": "https://registry.npmjs.org/glsl-tokenizer/-/glsl-tokenizer-2.1.5.tgz",
+      "integrity": "sha512-XSZEJ/i4dmz3Pmbnpsy3cKh7cotvFlBiZnDOwnj/05EwNp2XrhQ4XKJxT7/pDt4kp4YcpRSKz8eTV7S+mwV6MA==",
       "license": "MIT",
+      "peer": true,
       "dependencies": {
-        "@babel/parser": "^7.20.7",
-        "@babel/types": "^7.20.7",
-        "@types/babel__generator": "*",
-        "@types/babel__template": "*",
-        "@types/babel__traverse": "*"
+        "through2": "^0.6.3"
       }
     },
-    "node_modules/@types/babel__generator": {
-      "version": "7.27.0",
-      "resolved": "https://registry.npmjs.org/@types/babel__generator/-/babel__generator-7.27.0.tgz",
-      "integrity": "sha512-ufFd2Xi92OAVPYsy+P4n7/U7e68fex0+Ee8gSG9KX7eo084CWiQ4sdxktvdl0bOPupXtVJPY19zk6EwWqUQ8lg==",
-      "dev": true,
+    "node_modules/glsl-tokenizer/node_modules/isarray": {
+      "version": "0.0.1",
+      "resolved": "https://registry.npmjs.org/isarray/-/isarray-0.0.1.tgz",
+      "integrity": "sha512-D2S+3GLxWH+uhrNEcoh/fnmYeP8E8/zHl644d/jdA0g2uyXvy3sb0qxotE+ne0LtccHknQzWwZEzhak7oJ0COQ==",
+      "license": "MIT",
+      "peer": true
+    },
+    "node_modules/glsl-tokenizer/node_modules/readable-stream": {
+      "version": "1.0.34",
+      "resolved": "https://registry.npmjs.org/readable-stream/-/readable-stream-1.0.34.tgz",
+      "integrity": "sha512-ok1qVCJuRkNmvebYikljxJA/UEsKwLl2nI1OmaqAu4/UE+h0wKCHok4XkL/gvi39OacXvw59RJUOFUkDib2rHg==",
       "license": "MIT",
+      "peer": true,
       "dependencies": {
-        "@babel/types": "^7.0.0"
+        "core-util-is": "~1.0.0",
+        "inherits": "~2.0.1",
+        "isarray": "0.0.1",
+        "string_decoder": "~0.10.x"
       }
     },
-    "node_modules/@types/babel__template": {
-      "version": "7.4.4",
-      "resolved": "https://registry.npmjs.org/@types/babel__template/-/babel__template-7.4.4.tgz",
-      "integrity": "sha512-h/NUaSyG5EyxBIp8YRxo4RMe2/qQgvyowRwVMzhYhBCONbW8PUsg4lkFMrhgZhUe5z3L3MiLDuvyJ/CaPa2A8A==",
-      "dev": true,
+    "node_modules/glsl-tokenizer/node_modules/string_decoder": {
+      "version": "0.10.31",
+      "resolved": "https://registry.npmjs.org/string_decoder/-/string_decoder-0.10.31.tgz",
+      "integrity": "sha512-ev2QzSzWPYmy9GuqfIVildA4OdcGLeFZQrq5ys6RtiuF+RQQiZWr8TZNyAcuVXyQRYfEO+MsoB/1BuQVhOJuoQ==",
       "license": "MIT",
+      "peer": true
+    },
+    "node_modules/glsl-tokenizer/node_modules/through2": {
+      "version": "0.6.5",
+      "resolved": "https://registry.npmjs.org/through2/-/through2-0.6.5.tgz",
+      "integrity": "sha512-RkK/CCESdTKQZHdmKICijdKKsCRVHs5KsLZ6pACAmF/1GPUQhonHSXWNERctxEp7RmvjdNbZTL5z9V7nSCXKcg==",
+      "license": "MIT",
+      "peer": true,
       "dependencies": {
-        "@babel/parser": "^7.1.0",
-        "@babel/types": "^7.0.0"
+        "readable-stream": ">=1.0.33-1 <1.1.0-0",
+        "xtend": ">=4.0.0 <4.1.0-0"
       }
     },
-    "node_modules/@types/babel__traverse": {
-      "version": "7.20.7",
-      "resolved": "https://registry.npmjs.org/@types/babel__traverse/-/babel__traverse-7.20.7.tgz",
-      "integrity": "sha512-dkO5fhS7+/oos4ciWxyEyjWe48zmG6wbCheo/G2ZnHx4fs3EU6YC6UM8rk56gAjNJ9P3MTH2jo5jb92/K6wbng==",
-      "dev": true,
+    "node_modules/glslify": {
+      "version": "7.1.1",
+      "resolved": "https://registry.npmjs.org/glslify/-/glslify-7.1.1.tgz",
+      "integrity": "sha512-bud98CJ6kGZcP9Yxcsi7Iz647wuDz3oN+IZsjCRi5X1PI7t/xPKeL0mOwXJjo+CRZMqvq0CkSJiywCcY7kVYog==",
       "license": "MIT",
+      "peer": true,
       "dependencies": {
-        "@babel/types": "^7.20.7"
+        "bl": "^2.2.1",
+        "concat-stream": "^1.5.2",
+        "duplexify": "^3.4.5",
+        "falafel": "^2.1.0",
+        "from2": "^2.3.0",
+        "glsl-resolve": "0.0.1",
+        "glsl-token-whitespace-trim": "^1.0.0",
+        "glslify-bundle": "^5.0.0",
+        "glslify-deps": "^1.2.5",
+        "minimist": "^1.2.5",
+        "resolve": "^1.1.5",
+        "stack-trace": "0.0.9",
+        "static-eval": "^2.0.5",
+        "through2": "^2.0.1",
+        "xtend": "^4.0.0"
+      },
+      "bin": {
+        "glslify": "bin.js"
       }
     },
-    "node_modules/@types/estree": {
-      "version": "1.0.7",
-      "resolved": "https://registry.npmjs.org/@types/estree/-/estree-1.0.7.tgz",
-      "integrity": "sha512-w28IoSUCJpidD/TGviZwwMJckNESJZXFu7NBZ5YJ4mEUnNraUn9Pm8HSZm/jDF1pDWYKspWE7oVphigUPRakIQ==",
-      "dev": true,
-      "license": "MIT"
+    "node_modules/glslify-bundle": {
+      "version": "5.1.1",
+      "resolved": "https://registry.npmjs.org/glslify-bundle/-/glslify-bundle-5.1.1.tgz",
+      "integrity": "sha512-plaAOQPv62M1r3OsWf2UbjN0hUYAB7Aph5bfH58VxJZJhloRNbxOL9tl/7H71K7OLJoSJ2ZqWOKk3ttQ6wy24A==",
+      "license": "MIT",
+      "peer": true,
+      "dependencies": {
+        "glsl-inject-defines": "^1.0.1",
+        "glsl-token-defines": "^1.0.0",
+        "glsl-token-depth": "^1.1.1",
+        "glsl-token-descope": "^1.0.2",
+        "glsl-token-scope": "^1.1.1",
+        "glsl-token-string": "^1.0.1",
+        "glsl-token-whitespace-trim": "^1.0.0",
+        "glsl-tokenizer": "^2.0.2",
+        "murmurhash-js": "^1.0.0",
+        "shallow-copy": "0.0.1"
+      }
+    },
+    "node_modules/glslify-deps": {
+      "version": "1.3.2",
+      "resolved": "https://registry.npmjs.org/glslify-deps/-/glslify-deps-1.3.2.tgz",
+      "integrity": "sha512-7S7IkHWygJRjcawveXQjRXLO2FTjijPDYC7QfZyAQanY+yGLCFHYnPtsGT9bdyHiwPTw/5a1m1M9hamT2aBpag==",
+      "license": "ISC",
+      "peer": true,
+      "dependencies": {
+        "@choojs/findup": "^0.2.0",
+        "events": "^3.2.0",
+        "glsl-resolve": "0.0.1",
+        "glsl-tokenizer": "^2.0.0",
+        "graceful-fs": "^4.1.2",
+        "inherits": "^2.0.1",
+        "map-limit": "0.0.1",
+        "resolve": "^1.0.0"
+      }
+    },
+    "node_modules/graceful-fs": {
+      "version": "4.2.11",
+      "resolved": "https://registry.npmjs.org/graceful-fs/-/graceful-fs-4.2.11.tgz",
+      "integrity": "sha512-RbJ5/jmFcNNCcDV5o9eTnBLJ/HszWV0P73bc+Ff4nS/rJj+YaS6IGyiOL0VoBYX+l1Wrl3k63h/KrH+nhJ0XvQ==",
+      "license": "ISC",
+      "peer": true
     },
-    "node_modules/@types/geojson": {
-      "version": "7946.0.16",
-      "resolved": "https://registry.npmjs.org/@types/geojson/-/geojson-7946.0.16.tgz",
-      "integrity": "sha512-6C8nqWur3j98U6+lXDfTUWIfgvZU+EumvpHKcYjujKH7woYyLj2sUmff0tRhrqM7BohUw7Pz3ZB1jj2gW9Fvmg==",
+    "node_modules/graphemer": {
+      "version": "1.4.0",
+      "resolved": "https://registry.npmjs.org/graphemer/-/graphemer-1.4.0.tgz",
+      "integrity": "sha512-EtKwoO6kxCL9WO5xipiHTZlSzBm7WLT627TqC/uVRd0HKmq8NXyebnNYxDoBi7wt8eTWrUrKXCOVaFq9x1kgag==",
       "dev": true,
       "license": "MIT"
     },
-    "node_modules/@types/leaflet": {
-      "version": "1.9.18",
-      "resolved": "https://registry.npmjs.org/@types/leaflet/-/leaflet-1.9.18.tgz",
-      "integrity": "sha512-ht2vsoPjezor5Pmzi5hdsA7F++v5UGq9OlUduWHmMZiuQGIpJ2WS5+Gg9HaAA79gNh1AIPtCqhzejcIZ3lPzXQ==",
-      "dev": true,
+    "node_modules/grid-index": {
+      "version": "1.1.0",
+      "resolved": "https://registry.npmjs.org/grid-index/-/grid-index-1.1.0.tgz",
+      "integrity": "sha512-HZRwumpOGUrHyxO5bqKZL0B0GlUpwtCAzZ42sgxUPniu33R1LSFH5yrIcBCHjkctCAh3mtWKcKd9J4vDDdeVHA==",
+      "license": "ISC",
+      "peer": true
+    },
+    "node_modules/has-flag": {
+      "version": "4.0.0",
+      "resolved": "https://registry.npmjs.org/has-flag/-/has-flag-4.0.0.tgz",
+      "integrity": "sha512-EykJT/Q1KjTWctppgIAgfSO0tKVuZUjhgMr17kqTumMl6Afv3EISleU7qZUzoXDFTAHTDC4NOoG/ZxU3EvlMPQ==",
       "license": "MIT",
-      "dependencies": {
-        "@types/geojson": "*"
+      "engines": {
+        "node": ">=8"
       }
     },
-    "node_modules/@types/prop-types": {
-      "version": "15.7.14",
-      "resolved": "https://registry.npmjs.org/@types/prop-types/-/prop-types-15.7.14.tgz",
-      "integrity": "sha512-gNMvNH49DJ7OJYv+KAKn0Xp45p8PLl6zo2YnvDIbTd4J6MER2BmWN49TG7n9LvkyihINxeKW8+3bfS2yDC9dzQ==",
-      "dev": true,
-      "license": "MIT"
-    },
-    "node_modules/@types/react": {
-      "version": "18.3.23",
-      "resolved": "https://registry.npmjs.org/@types/react/-/react-18.3.23.tgz",
-      "integrity": "sha512-/LDXMQh55EzZQ0uVAZmKKhfENivEvWz6E+EYzh+/MCjMhNsotd+ZHhBGIjFDTi6+fz0OhQQQLbTgdQIxxCsC0w==",
-      "dev": true,
+    "node_modules/has-hover": {
+      "version": "1.0.1",
+      "resolved": "https://registry.npmjs.org/has-hover/-/has-hover-1.0.1.tgz",
+      "integrity": "sha512-0G6w7LnlcpyDzpeGUTuT0CEw05+QlMuGVk1IHNAlHrGJITGodjZu3x8BNDUMfKJSZXNB2ZAclqc1bvrd+uUpfg==",
       "license": "MIT",
+      "peer": true,
       "dependencies": {
-        "@types/prop-types": "*",
-        "csstype": "^3.0.2"
+        "is-browser": "^2.0.1"
       }
     },
-    "node_modules/@types/react-dom": {
-      "version": "18.3.7",
-      "resolved": "https://registry.npmjs.org/@types/react-dom/-/react-dom-18.3.7.tgz",
-      "integrity": "sha512-MEe3UeoENYVFXzoXEWsvcpg6ZvlrFNlOQ7EOsvhI3CfAXwzPfO8Qwuxd40nepsYKqyyVQnTdEfv68q91yLcKrQ==",
-      "dev": true,
+    "node_modules/has-passive-events": {
+      "version": "1.0.0",
+      "resolved": "https://registry.npmjs.org/has-passive-events/-/has-passive-events-1.0.0.tgz",
+      "integrity": "sha512-2vSj6IeIsgvsRMyeQ0JaCX5Q3lX4zMn5HpoVc7MEhQ6pv8Iq9rsXjsp+E5ZwaT7T0xhMT0KmU8gtt1EFVdbJiw==",
       "license": "MIT",
-      "peerDependencies": {
-        "@types/react": "^18.0.0"
+      "peer": true,
+      "dependencies": {
+        "is-browser": "^2.0.1"
       }
     },
-    "node_modules/@typescript-eslint/eslint-plugin": {
-      "version": "7.18.0",
-      "resolved": "https://registry.npmjs.org/@typescript-eslint/eslint-plugin/-/eslint-plugin-7.18.0.tgz",
-      "integrity": "sha512-94EQTWZ40mzBc42ATNIBimBEDltSJ9RQHCC8vc/PDbxi4k8dVwUAv4o98dk50M1zB+JGFxp43FP7f8+FP8R6Sw==",
-      "dev": true,
+    "node_modules/hasown": {
+      "version": "2.0.2",
+      "resolved": "https://registry.npmjs.org/hasown/-/hasown-2.0.2.tgz",
+      "integrity": "sha512-0hJU9SCPvmMzIBdZFqNPXWa6dqh7WdH0cII9y+CyS8rG3nL48Bclra9HmKhVVUHyPWNH5Y7xDwAB7bfgSjkUMQ==",
       "license": "MIT",
-      "dependencies": {
-        "@eslint-community/regexpp": "^4.10.0",
-        "@typescript-eslint/scope-manager": "7.18.0",
-        "@typescript-eslint/type-utils": "7.18.0",
-        "@typescript-eslint/utils": "7.18.0",
-        "@typescript-eslint/visitor-keys": "7.18.0",
-        "graphemer": "^1.4.0",
-        "ignore": "^5.3.1",
-        "natural-compare": "^1.4.0",
-        "ts-api-utils": "^1.3.0"
+      "peer": true,
+      "dependencies": {
+        "function-bind": "^1.1.2"
       },
       "engines": {
-        "node": "^18.18.0 || >=20.0.0"
-      },
-      "funding": {
-        "type": "opencollective",
-        "url": "https://opencollective.com/typescript-eslint"
-      },
-      "peerDependencies": {
-        "@typescript-eslint/parser": "^7.0.0",
-        "eslint": "^8.56.0"
+        "node": ">= 0.4"
+      }
+    },
+    "node_modules/html-encoding-sniffer": {
+      "version": "4.0.0",
+      "resolved": "https://registry.npmjs.org/html-encoding-sniffer/-/html-encoding-sniffer-4.0.0.tgz",
+      "integrity": "sha512-Y22oTqIU4uuPgEemfz7NDJz6OeKf12Lsu+QC+s3BVpda64lTiMYCyGwg5ki4vFxkMwQdeZDl2adZoqUgdFuTgQ==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "whatwg-encoding": "^3.1.1"
       },
-      "peerDependenciesMeta": {
-        "typescript": {
-          "optional": true
-        }
+      "engines": {
+        "node": ">=18"
       }
     },
-    "node_modules/@typescript-eslint/parser": {
-      "version": "7.18.0",
-      "resolved": "https://registry.npmjs.org/@typescript-eslint/parser/-/parser-7.18.0.tgz",
-      "integrity": "sha512-4Z+L8I2OqhZV8qA132M4wNL30ypZGYOQVBfMgxDH/K5UX0PNqTu1c6za9ST5r9+tavvHiTWmBnKzpCJ/GlVFtg==",
+    "node_modules/http-proxy-agent": {
+      "version": "7.0.2",
+      "resolved": "https://registry.npmjs.org/http-proxy-agent/-/http-proxy-agent-7.0.2.tgz",
+      "integrity": "sha512-T1gkAiYYDWYx3V5Bmyu7HcfcvL7mUrTWiM6yOfa3PIphViJ/gFPbvidQ+veqSOHci/PxBcDabeUNCzpOODJZig==",
       "dev": true,
-      "license": "BSD-2-Clause",
+      "license": "MIT",
       "dependencies": {
-        "@typescript-eslint/scope-manager": "7.18.0",
-        "@typescript-eslint/types": "7.18.0",
-        "@typescript-eslint/typescript-estree": "7.18.0",
-        "@typescript-eslint/visitor-keys": "7.18.0",
+        "agent-base": "^7.1.0",
         "debug": "^4.3.4"
       },
       "engines": {
-        "node": "^18.18.0 || >=20.0.0"
-      },
-      "funding": {
-        "type": "opencollective",
-        "url": "https://opencollective.com/typescript-eslint"
-      },
-      "peerDependencies": {
-        "eslint": "^8.56.0"
-      },
-      "peerDependenciesMeta": {
-        "typescript": {
-          "optional": true
-        }
+        "node": ">= 14"
       }
     },
-    "node_modules/@typescript-eslint/scope-manager": {
-      "version": "7.18.0",
-      "resolved": "https://registry.npmjs.org/@typescript-eslint/scope-manager/-/scope-manager-7.18.0.tgz",
-      "integrity": "sha512-jjhdIE/FPF2B7Z1uzc6i3oWKbGcHb87Qw7AWj6jmEqNOfDFbJWtjt/XfwCpvNkpGWlcJaog5vTR+VV8+w9JflA==",
+    "node_modules/https-proxy-agent": {
+      "version": "7.0.6",
+      "resolved": "https://registry.npmjs.org/https-proxy-agent/-/https-proxy-agent-7.0.6.tgz",
+      "integrity": "sha512-vK9P5/iUfdl95AI+JVyUuIcVtd4ofvtrOr3HNtM2yxC9bnMbEdp3x01OhQNnjb8IJYi38VlTE3mBXwcfvywuSw==",
       "dev": true,
       "license": "MIT",
       "dependencies": {
-        "@typescript-eslint/types": "7.18.0",
-        "@typescript-eslint/visitor-keys": "7.18.0"
+        "agent-base": "^7.1.2",
+        "debug": "4"
       },
       "engines": {
-        "node": "^18.18.0 || >=20.0.0"
-      },
-      "funding": {
-        "type": "opencollective",
-        "url": "https://opencollective.com/typescript-eslint"
+        "node": ">= 14"
       }
     },
-    "node_modules/@typescript-eslint/type-utils": {
-      "version": "7.18.0",
-      "resolved": "https://registry.npmjs.org/@typescript-eslint/type-utils/-/type-utils-7.18.0.tgz",
-      "integrity": "sha512-XL0FJXuCLaDuX2sYqZUUSOJ2sG5/i1AAze+axqmLnSkNEVMVYLF+cbwlB2w8D1tinFuSikHmFta+P+HOofrLeA==",
+    "node_modules/iconv-lite": {
+      "version": "0.6.3",
+      "resolved": "https://registry.npmjs.org/iconv-lite/-/iconv-lite-0.6.3.tgz",
+      "integrity": "sha512-4fCk79wshMdzMp2rH06qWrJE4iolqLhCUH+OiuIgU++RB0+94NlDL81atO7GX55uUKueo0txHNtvEyI6D7WdMw==",
       "dev": true,
       "license": "MIT",
       "dependencies": {
-        "@typescript-eslint/typescript-estree": "7.18.0",
-        "@typescript-eslint/utils": "7.18.0",
-        "debug": "^4.3.4",
-        "ts-api-utils": "^1.3.0"
+        "safer-buffer": ">= 2.1.2 < 3.0.0"
       },
       "engines": {
-        "node": "^18.18.0 || >=20.0.0"
-      },
-      "funding": {
-        "type": "opencollective",
-        "url": "https://opencollective.com/typescript-eslint"
-      },
-      "peerDependencies": {
-        "eslint": "^8.56.0"
-      },
-      "peerDependenciesMeta": {
-        "typescript": {
-          "optional": true
-        }
+        "node": ">=0.10.0"
       }
     },
-    "node_modules/@typescript-eslint/types": {
-      "version": "7.18.0",
-      "resolved": "https://registry.npmjs.org/@typescript-eslint/types/-/types-7.18.0.tgz",
-      "integrity": "sha512-iZqi+Ds1y4EDYUtlOOC+aUmxnE9xS/yCigkjA7XpTKV6nCBd3Hp/PRGGmdwnfkV2ThMyYldP1wRpm/id99spTQ==",
+    "node_modules/ieee754": {
+      "version": "1.2.1",
+      "resolved": "https://registry.npmjs.org/ieee754/-/ieee754-1.2.1.tgz",
+      "integrity": "sha512-dcyqhDvX1C46lXZcVqCpK+FtMRQVdIMN6/Df5js2zouUsqG7I6sFxitIC+7KYK29KdXOLHdu9zL4sFnoVQnqaA==",
+      "funding": [
+        {
+          "type": "github",
+          "url": "https://github.com/sponsors/feross"
+        },
+        {
+          "type": "patreon",
+          "url": "https://www.patreon.com/feross"
+        },
+        {
+          "type": "consulting",
+          "url": "https://feross.org/support"
+        }
+      ],
+      "license": "BSD-3-Clause"
+    },
+    "node_modules/ignore": {
+      "version": "5.3.2",
+      "resolved": "https://registry.npmjs.org/ignore/-/ignore-5.3.2.tgz",
+      "integrity": "sha512-hsBTNUqQTDwkWtcdYI2i06Y/nUBEsNEDJKjWdigLvegy8kDuJAS8uRlpkkcQpyEXL0Z/pjDy5HBmMjRCJ2gq+g==",
       "dev": true,
       "license": "MIT",
       "engines": {
-        "node": "^18.18.0 || >=20.0.0"
-      },
-      "funding": {
-        "type": "opencollective",
-        "url": "https://opencollective.com/typescript-eslint"
+        "node": ">= 4"
       }
     },
-    "node_modules/@typescript-eslint/typescript-estree": {
-      "version": "7.18.0",
-      "resolved": "https://registry.npmjs.org/@typescript-eslint/typescript-estree/-/typescript-estree-7.18.0.tgz",
-      "integrity": "sha512-aP1v/BSPnnyhMHts8cf1qQ6Q1IFwwRvAQGRvBFkWlo3/lH29OXA3Pts+c10nxRxIBrDnoMqzhgdwVe5f2D6OzA==",
+    "node_modules/import-fresh": {
+      "version": "3.3.1",
+      "resolved": "https://registry.npmjs.org/import-fresh/-/import-fresh-3.3.1.tgz",
+      "integrity": "sha512-TR3KfrTZTYLPB6jUjfx6MF9WcWrHL9su5TObK4ZkYgBdWKPOFoSoQIdEuTuR82pmtxH2spWG9h6etwfr1pLBqQ==",
       "dev": true,
-      "license": "BSD-2-Clause",
+      "license": "MIT",
       "dependencies": {
-        "@typescript-eslint/types": "7.18.0",
-        "@typescript-eslint/visitor-keys": "7.18.0",
-        "debug": "^4.3.4",
-        "globby": "^11.1.0",
-        "is-glob": "^4.0.3",
-        "minimatch": "^9.0.4",
-        "semver": "^7.6.0",
-        "ts-api-utils": "^1.3.0"
+        "parent-module": "^1.0.0",
+        "resolve-from": "^4.0.0"
       },
       "engines": {
-        "node": "^18.18.0 || >=20.0.0"
+        "node": ">=6"
       },
       "funding": {
-        "type": "opencollective",
-        "url": "https://opencollective.com/typescript-eslint"
-      },
-      "peerDependenciesMeta": {
-        "typescript": {
-          "optional": true
-        }
+        "url": "https://github.com/sponsors/sindresorhus"
       }
     },
-    "node_modules/@typescript-eslint/utils": {
-      "version": "7.18.0",
-      "resolved": "https://registry.npmjs.org/@typescript-eslint/utils/-/utils-7.18.0.tgz",
-      "integrity": "sha512-kK0/rNa2j74XuHVcoCZxdFBMF+aq/vH83CXAOHieC+2Gis4mF8jJXT5eAfyD3K0sAxtPuwxaIOIOvhwzVDt/kw==",
+    "node_modules/imurmurhash": {
+      "version": "0.1.4",
+      "resolved": "https://registry.npmjs.org/imurmurhash/-/imurmurhash-0.1.4.tgz",
+      "integrity": "sha512-JmXMZ6wuvDmLiHEml9ykzqO6lwFbof0GG4IkcGaENdCRDDmMVnny7s5HsIgHCbaq0w2MyPhDqkhTUgS2LU2PHA==",
       "dev": true,
       "license": "MIT",
-      "dependencies": {
-        "@eslint-community/eslint-utils": "^4.4.0",
-        "@typescript-eslint/scope-manager": "7.18.0",
-        "@typescript-eslint/types": "7.18.0",
-        "@typescript-eslint/typescript-estree": "7.18.0"
-      },
       "engines": {
-        "node": "^18.18.0 || >=20.0.0"
-      },
-      "funding": {
-        "type": "opencollective",
-        "url": "https://opencollective.com/typescript-eslint"
-      },
-      "peerDependencies": {
-        "eslint": "^8.56.0"
+        "node": ">=0.8.19"
       }
     },
-    "node_modules/@typescript-eslint/visitor-keys": {
-      "version": "7.18.0",
-      "resolved": "https://registry.npmjs.org/@typescript-eslint/visitor-keys/-/visitor-keys-7.18.0.tgz",
-      "integrity": "sha512-cDF0/Gf81QpY3xYyJKDV14Zwdmid5+uuENhjH2EqFaF0ni+yAyq/LzMaIJdhNJXZI7uLzwIlA+V7oWoyn6Curg==",
+    "node_modules/indent-string": {
+      "version": "4.0.0",
+      "resolved": "https://registry.npmjs.org/indent-string/-/indent-string-4.0.0.tgz",
+      "integrity": "sha512-EdDDZu4A2OyIK7Lr/2zG+w5jmbuk1DVBnEwREQvBzspBJkCEbRa8GxU1lghYcaGJCnRWibjDXlq779X1/y5xwg==",
       "dev": true,
       "license": "MIT",
-      "dependencies": {
-        "@typescript-eslint/types": "7.18.0",
-        "eslint-visitor-keys": "^3.4.3"
-      },
       "engines": {
-        "node": "^18.18.0 || >=20.0.0"
-      },
-      "funding": {
-        "type": "opencollective",
-        "url": "https://opencollective.com/typescript-eslint"
+        "node": ">=8"
       }
     },
-    "node_modules/@ungap/structured-clone": {
-      "version": "1.3.0",
-      "resolved": "https://registry.npmjs.org/@ungap/structured-clone/-/structured-clone-1.3.0.tgz",
-      "integrity": "sha512-WmoN8qaIAo7WTYWbAZuG8PYEhn5fkz7dZrqTBZ7dtt//lL2Gwms1IcnQ5yHqjDfX8Ft5j4YzDM23f87zBfDe9g==",
+    "node_modules/inflight": {
+      "version": "1.0.6",
+      "resolved": "https://registry.npmjs.org/inflight/-/inflight-1.0.6.tgz",
+      "integrity": "sha512-k92I/b08q4wvFscXCLvqfsHCrjrF7yiXsQuIVvVE7N82W3+aqpzuUdBbfhWcy/FZR3/4IgflMgKLOsvPDrGCJA==",
+      "deprecated": "This module is not supported, and leaks memory. Do not use it. Check out lru-cache if you want a good and tested way to coalesce async requests by a key value, which is much more comprehensive and powerful.",
       "dev": true,
+      "license": "ISC",
+      "dependencies": {
+        "once": "^1.3.0",
+        "wrappy": "1"
+      }
+    },
+    "node_modules/inherits": {
+      "version": "2.0.4",
+      "resolved": "https://registry.npmjs.org/inherits/-/inherits-2.0.4.tgz",
+      "integrity": "sha512-k/vGaX4/Yla3WzyMCvTQOXYeIHvqOKtnqBduzTHpzpQZzAskKMhZ2K+EnBiSM9zGSoIFeMpXKxa4dYeZIQqewQ==",
       "license": "ISC"
     },
-    "node_modules/@vitejs/plugin-react": {
-      "version": "4.5.1",
-      "resolved": "https://registry.npmjs.org/@vitejs/plugin-react/-/plugin-react-4.5.1.tgz",
-      "integrity": "sha512-uPZBqSI0YD4lpkIru6M35sIfylLGTyhGHvDZbNLuMA73lMlwJKz5xweH7FajfcCAc2HnINciejA9qTz0dr0M7A==",
-      "dev": true,
+    "node_modules/ini": {
+      "version": "4.1.3",
+      "resolved": "https://registry.npmjs.org/ini/-/ini-4.1.3.tgz",
+      "integrity": "sha512-X7rqawQBvfdjS10YU1y1YVreA3SsLrW9dX2CewP2EbBJM4ypVNLDkO5y04gejPwKIY9lR+7r9gn3rFPt/kmWFg==",
+      "license": "ISC",
+      "peer": true,
+      "engines": {
+        "node": "^14.17.0 || ^16.13.0 || >=18.0.0"
+      }
+    },
+    "node_modules/is-browser": {
+      "version": "2.1.0",
+      "resolved": "https://registry.npmjs.org/is-browser/-/is-browser-2.1.0.tgz",
+      "integrity": "sha512-F5rTJxDQ2sW81fcfOR1GnCXT6sVJC104fCyfj+mjpwNEwaPYSn5fte5jiHmBg3DHsIoL/l8Kvw5VN5SsTRcRFQ==",
+      "license": "MIT",
+      "peer": true
+    },
+    "node_modules/is-core-module": {
+      "version": "2.16.1",
+      "resolved": "https://registry.npmjs.org/is-core-module/-/is-core-module-2.16.1.tgz",
+      "integrity": "sha512-UfoeMA6fIJ8wTYFEUjelnaGI67v6+N7qXJEvQuIGa99l4xsCruSYOVSQ0uPANn4dAzm8lkYPaKLrrijLq7x23w==",
       "license": "MIT",
+      "peer": true,
       "dependencies": {
-        "@babel/core": "^7.26.10",
-        "@babel/plugin-transform-react-jsx-self": "^7.25.9",
-        "@babel/plugin-transform-react-jsx-source": "^7.25.9",
-        "@rolldown/pluginutils": "1.0.0-beta.9",
-        "@types/babel__core": "^7.20.5",
-        "react-refresh": "^0.17.0"
+        "hasown": "^2.0.2"
       },
       "engines": {
-        "node": "^14.18.0 || >=16.0.0"
+        "node": ">= 0.4"
       },
-      "peerDependencies": {
-        "vite": "^4.2.0 || ^5.0.0 || ^6.0.0"
+      "funding": {
+        "url": "https://github.com/sponsors/ljharb"
       }
     },
-    "node_modules/acorn": {
-      "version": "8.14.1",
-      "resolved": "https://registry.npmjs.org/acorn/-/acorn-8.14.1.tgz",
-      "integrity": "sha512-OvQ/2pUDKmgfCg++xsTX1wGxfTaszcHVcTctW4UJB4hibJx2HXxxO5UmVgyjMa+ZDsiaf5wWLXYpRWMmBI0QHg==",
-      "dev": true,
+    "node_modules/is-extendable": {
+      "version": "0.1.1",
+      "resolved": "https://registry.npmjs.org/is-extendable/-/is-extendable-0.1.1.tgz",
+      "integrity": "sha512-5BMULNob1vgFX6EjQw5izWDxrecWK9AM72rugNr0TFldMOi0fj6Jk+zeKIt0xGj4cEfQIJth4w3OKWOJ4f+AFw==",
       "license": "MIT",
-      "bin": {
-        "acorn": "bin/acorn"
-      },
       "engines": {
-        "node": ">=0.4.0"
+        "node": ">=0.10.0"
       }
     },
-    "node_modules/acorn-jsx": {
-      "version": "5.3.2",
-      "resolved": "https://registry.npmjs.org/acorn-jsx/-/acorn-jsx-5.3.2.tgz",
-      "integrity": "sha512-rq9s+JNhf0IChjtDXxllJ7g41oZk5SlXtp0LHwyA5cejwn7vKmKp4pPri6YEePv2PU65sAsegbXtIinmDFDXgQ==",
+    "node_modules/is-extglob": {
+      "version": "2.1.1",
+      "resolved": "https://registry.npmjs.org/is-extglob/-/is-extglob-2.1.1.tgz",
+      "integrity": "sha512-SbKbANkN603Vi4jEZv49LeVJMn4yGwsbzZworEoyEiutsN3nJYdbO36zfhGJ6QEDpOZIFkDtnq5JRxmvl3jsoQ==",
       "dev": true,
       "license": "MIT",
-      "peerDependencies": {
-        "acorn": "^6.0.0 || ^7.0.0 || ^8.0.0"
+      "engines": {
+        "node": ">=0.10.0"
       }
     },
-    "node_modules/ajv": {
-      "version": "6.12.6",
-      "resolved": "https://registry.npmjs.org/ajv/-/ajv-6.12.6.tgz",
-      "integrity": "sha512-j3fVLgvTo527anyYyJOGTYJbG+vnnQYvE0m5mmkc1TK+nxAppkCLMIL0aZ4dblVCNoGShhm+kzE4ZUykBoMg4g==",
-      "dev": true,
+    "node_modules/is-finite": {
+      "version": "1.1.0",
+      "resolved": "https://registry.npmjs.org/is-finite/-/is-finite-1.1.0.tgz",
+      "integrity": "sha512-cdyMtqX/BOqqNBBiKlIVkytNHm49MtMlYyn1zxzvJKWmFMlGzm+ry5BBfYyeY9YmNKbRSo/o7OX9w9ale0wg3w==",
       "license": "MIT",
-      "dependencies": {
-        "fast-deep-equal": "^3.1.1",
-        "fast-json-stable-stringify": "^2.0.0",
-        "json-schema-traverse": "^0.4.1",
-        "uri-js": "^4.2.2"
+      "peer": true,
+      "engines": {
+        "node": ">=0.10.0"
       },
       "funding": {
-        "type": "github",
-        "url": "https://github.com/sponsors/epoberezkin"
+        "url": "https://github.com/sponsors/sindresorhus"
       }
     },
-    "node_modules/ansi-regex": {
-      "version": "5.0.1",
-      "resolved": "https://registry.npmjs.org/ansi-regex/-/ansi-regex-5.0.1.tgz",
-      "integrity": "sha512-quJQXlTSUGL2LH9SUXo8VwsY4soanhgo6LNSm84E1LBcE8s3O0wpdiRzyR9z/ZZJMlMWv37qOOb9pdJlMUEKFQ==",
-      "dev": true,
+    "node_modules/is-firefox": {
+      "version": "1.0.3",
+      "resolved": "https://registry.npmjs.org/is-firefox/-/is-firefox-1.0.3.tgz",
+      "integrity": "sha512-6Q9ITjvWIm0Xdqv+5U12wgOKEM2KoBw4Y926m0OFkvlCxnbG94HKAsVz8w3fWcfAS5YA2fJORXX1dLrkprCCxA==",
       "license": "MIT",
+      "peer": true,
       "engines": {
-        "node": ">=8"
+        "node": ">=0.10.0"
       }
     },
-    "node_modules/ansi-styles": {
-      "version": "4.3.0",
-      "resolved": "https://registry.npmjs.org/ansi-styles/-/ansi-styles-4.3.0.tgz",
-      "integrity": "sha512-zbB9rCJAT1rbjiVDb2hqKFHNYLxgtk8NURxZ3IZwD3F6NtxbXZQCnnSi1Lkx+IDohdPlFp222wVALIheZJQSEg==",
+    "node_modules/is-glob": {
+      "version": "4.0.3",
+      "resolved": "https://registry.npmjs.org/is-glob/-/is-glob-4.0.3.tgz",
+      "integrity": "sha512-xelSayHH36ZgE7ZWhli7pW34hNbNl8Ojv5KVmkJD4hBdD3th8Tfk9vYasLM+mXWOZhFkgZfxhLSnrwRr4elSSg==",
       "dev": true,
       "license": "MIT",
       "dependencies": {
-        "color-convert": "^2.0.1"
+        "is-extglob": "^2.1.1"
       },
       "engines": {
-        "node": ">=8"
-      },
-      "funding": {
-        "url": "https://github.com/chalk/ansi-styles?sponsor=1"
+        "node": ">=0.10.0"
       }
     },
-    "node_modules/argparse": {
-      "version": "2.0.1",
-      "resolved": "https://registry.npmjs.org/argparse/-/argparse-2.0.1.tgz",
-      "integrity": "sha512-8+9WqebbFzpX9OR+Wa6O29asIogeRMzcGtAINdpMHHyAg10f05aSFVBbcEqGf/PXw1EjAZ+q2/bEBg3DvurK3Q==",
-      "dev": true,
-      "license": "Python-2.0"
-    },
-    "node_modules/array-union": {
-      "version": "2.1.0",
-      "resolved": "https://registry.npmjs.org/array-union/-/array-union-2.1.0.tgz",
-      "integrity": "sha512-HGyxoOTYUyCM6stUe6EJgnd4EoewAI7zMdfqO+kGjnlZmBDz/cR5pf8r/cR4Wq60sL/p0IkcjUEEPwS3GFrIyw==",
-      "dev": true,
+    "node_modules/is-iexplorer": {
+      "version": "1.0.0",
+      "resolved": "https://registry.npmjs.org/is-iexplorer/-/is-iexplorer-1.0.0.tgz",
+      "integrity": "sha512-YeLzceuwg3K6O0MLM3UyUUjKAlyULetwryFp1mHy1I5PfArK0AEqlfa+MR4gkJjcbuJXoDJCvXbyqZVf5CR2Sg==",
       "license": "MIT",
+      "peer": true,
       "engines": {
-        "node": ">=8"
+        "node": ">=0.10.0"
       }
     },
-    "node_modules/balanced-match": {
-      "version": "1.0.2",
-      "resolved": "https://registry.npmjs.org/balanced-match/-/balanced-match-1.0.2.tgz",
-      "integrity": "sha512-3oSeUO0TMV67hN1AmbXsK4yaqU7tjiHlbxRDZOpH0KW9+CeX4bRAaX0Anxt0tx2MrpRpWwQaPwIlISEJhYU5Pw==",
-      "dev": true,
-      "license": "MIT"
+    "node_modules/is-mobile": {
+      "version": "4.0.0",
+      "resolved": "https://registry.npmjs.org/is-mobile/-/is-mobile-4.0.0.tgz",
+      "integrity": "sha512-mlcHZA84t1qLSuWkt2v0I2l61PYdyQDt4aG1mLIXF5FDMm4+haBCxCPYSr/uwqQNRk1MiTizn0ypEuRAOLRAew==",
+      "license": "MIT",
+      "peer": true
     },
-    "node_modules/brace-expansion": {
-      "version": "2.0.1",
-      "resolved": "https://registry.npmjs.org/brace-expansion/-/brace-expansion-2.0.1.tgz",
-      "integrity": "sha512-XnAIvQ8eM+kC6aULx6wuQiwVsnzsi9d3WxzV3FpWTGA19F621kwdbsAcFKXgKUHZWsy+mY6iL1sHTxWEFCytDA==",
+    "node_modules/is-number": {
+      "version": "7.0.0",
+      "resolved": "https://registry.npmjs.org/is-number/-/is-number-7.0.0.tgz",
+      "integrity": "sha512-41Cifkg6e8TylSpdtTpeLVMqvSBEVzTttHvERD741+pnZ8ANv0004MRL43QKPDlK9cGvNp6NZWZUBlbGXYxxng==",
       "dev": true,
       "license": "MIT",
-      "dependencies": {
-        "balanced-match": "^1.0.0"
+      "engines": {
+        "node": ">=0.12.0"
       }
     },
-    "node_modules/braces": {
+    "node_modules/is-obj": {
+      "version": "1.0.1",
+      "resolved": "https://registry.npmjs.org/is-obj/-/is-obj-1.0.1.tgz",
+      "integrity": "sha512-l4RyHgRqGN4Y3+9JHVrNqO+tN0rV5My76uW5/nuO4K1b6vw5G8d/cmFjP9tRfEsdhZNt0IFdZuK/c2Vr4Nb+Qg==",
+      "license": "MIT",
+      "peer": true,
+      "engines": {
+        "node": ">=0.10.0"
+      }
+    },
+    "node_modules/is-path-inside": {
       "version": "3.0.3",
-      "resolved": "https://registry.npmjs.org/braces/-/braces-3.0.3.tgz",
-      "integrity": "sha512-yQbXgO/OSZVD2IsiLlro+7Hf6Q18EJrKSEsdoMzKePKXct3gvD8oLcOQdIzGupr5Fj+EDe8gO/lxc1BzfMpxvA==",
+      "resolved": "https://registry.npmjs.org/is-path-inside/-/is-path-inside-3.0.3.tgz",
+      "integrity": "sha512-Fd4gABb+ycGAmKou8eMftCupSir5lRxqf4aD/vd0cD2qc4HL07OjCeuHMr8Ro4CoMaeCKDB0/ECBOVWjTwUvPQ==",
       "dev": true,
       "license": "MIT",
-      "dependencies": {
-        "fill-range": "^7.1.1"
-      },
       "engines": {
         "node": ">=8"
       }
     },
-    "node_modules/browserslist": {
-      "version": "4.25.0",
-      "resolved": "https://registry.npmjs.org/browserslist/-/browserslist-4.25.0.tgz",
-      "integrity": "sha512-PJ8gYKeS5e/whHBh8xrwYK+dAvEj7JXtz6uTucnMRB8OiGTsKccFekoRrjajPBHV8oOY+2tI4uxeceSimKwMFA==",
-      "dev": true,
-      "funding": [
-        {
-          "type": "opencollective",
-          "url": "https://opencollective.com/browserslist"
-        },
-        {
-          "type": "tidelift",
-          "url": "https://tidelift.com/funding/github/npm/browserslist"
-        },
-        {
-          "type": "github",
-          "url": "https://github.com/sponsors/ai"
-        }
-      ],
+    "node_modules/is-plain-obj": {
+      "version": "1.1.0",
+      "resolved": "https://registry.npmjs.org/is-plain-obj/-/is-plain-obj-1.1.0.tgz",
+      "integrity": "sha512-yvkRyxmFKEOQ4pNXCmJG5AEQNlXJS5LaONXo5/cLdTZdWvsZ1ioJEonLGAosKlMWE8lwUy/bJzMjcw8az73+Fg==",
       "license": "MIT",
-      "dependencies": {
-        "caniuse-lite": "^1.0.30001718",
-        "electron-to-chromium": "^1.5.160",
-        "node-releases": "^2.0.19",
-        "update-browserslist-db": "^1.1.3"
-      },
-      "bin": {
-        "browserslist": "cli.js"
-      },
+      "peer": true,
       "engines": {
-        "node": "^6 || ^7 || ^8 || ^9 || ^10 || ^11 || ^12 || >=13.7"
+        "node": ">=0.10.0"
       }
     },
-    "node_modules/callsites": {
-      "version": "3.1.0",
-      "resolved": "https://registry.npmjs.org/callsites/-/callsites-3.1.0.tgz",
-      "integrity": "sha512-P8BjAsXvZS+VIDUI11hHCQEv74YT67YUi5JJFNWIqL235sBmjX4+qx9Muvls5ivyNENctx46xQLQ3aTuE7ssaQ==",
-      "dev": true,
+    "node_modules/is-plain-object": {
+      "version": "2.0.4",
+      "resolved": "https://registry.npmjs.org/is-plain-object/-/is-plain-object-2.0.4.tgz",
+      "integrity": "sha512-h5PpgXkWitc38BBMYawTYMWJHFZJVnBquFE57xFpjB8pJFiF6gZ+bU+WyI/yqXiFR5mdLsgYNaPe8uao6Uv9Og==",
       "license": "MIT",
+      "dependencies": {
+        "isobject": "^3.0.1"
+      },
       "engines": {
-        "node": ">=6"
+        "node": ">=0.10.0"
       }
     },
-    "node_modules/caniuse-lite": {
-      "version": "1.0.30001721",
-      "resolved": "https://registry.npmjs.org/caniuse-lite/-/caniuse-lite-1.0.30001721.tgz",
-      "integrity": "sha512-cOuvmUVtKrtEaoKiO0rSc29jcjwMwX5tOHDy4MgVFEWiUXj4uBMJkwI8MDySkgXidpMiHUcviogAvFi4pA2hDQ==",
+    "node_modules/is-potential-custom-element-name": {
+      "version": "1.0.1",
+      "resolved": "https://registry.npmjs.org/is-potential-custom-element-name/-/is-potential-custom-element-name-1.0.1.tgz",
+      "integrity": "sha512-bCYeRA2rVibKZd+s2625gGnGF/t7DSqDs4dP7CrLA1m7jKWz6pps0LpYLJN8Q64HtmPKJ1hrN3nzPNKFEKOUiQ==",
       "dev": true,
-      "funding": [
-        {
-          "type": "opencollective",
-          "url": "https://opencollective.com/browserslist"
-        },
-        {
-          "type": "tidelift",
-          "url": "https://tidelift.com/funding/github/npm/caniuse-lite"
-        },
-        {
-          "type": "github",
-          "url": "https://github.com/sponsors/ai"
-        }
-      ],
-      "license": "CC-BY-4.0"
+      "license": "MIT"
     },
-    "node_modules/chalk": {
-      "version": "4.1.2",
-      "resolved": "https://registry.npmjs.org/chalk/-/chalk-4.1.2.tgz",
-      "integrity": "sha512-oKnbhFyRIXpUuez8iBMmyEa4nbj4IOQyuhc/wy9kY7/WVPcwIO9VA668Pu8RkO7+0G76SLROeyw9CpQ061i4mA==",
+    "node_modules/is-string-blank": {
+      "version": "1.0.1",
+      "resolved": "https://registry.npmjs.org/is-string-blank/-/is-string-blank-1.0.1.tgz",
+      "integrity": "sha512-9H+ZBCVs3L9OYqv8nuUAzpcT9OTgMD1yAWrG7ihlnibdkbtB850heAmYWxHuXc4CHy4lKeK69tN+ny1K7gBIrw==",
+      "license": "MIT",
+      "peer": true
+    },
+    "node_modules/is-svg-path": {
+      "version": "1.0.2",
+      "resolved": "https://registry.npmjs.org/is-svg-path/-/is-svg-path-1.0.2.tgz",
+      "integrity": "sha512-Lj4vePmqpPR1ZnRctHv8ltSh1OrSxHkhUkd7wi+VQdcdP15/KvQFyk7LhNuM7ZW0EVbJz8kZLVmL9quLrfq4Kg==",
+      "license": "MIT",
+      "peer": true
+    },
+    "node_modules/isarray": {
+      "version": "2.0.5",
+      "resolved": "https://registry.npmjs.org/isarray/-/isarray-2.0.5.tgz",
+      "integrity": "sha512-xHjhDr3cNBK0BzdUJSPXZntQUx/mwMS5Rw4A7lPJ90XGAO6ISP/ePDNuo0vhqOZU+UD5JoodwCAAoZQd3FeAKw==",
+      "license": "MIT",
+      "peer": true
+    },
+    "node_modules/isexe": {
+      "version": "2.0.0",
+      "resolved": "https://registry.npmjs.org/isexe/-/isexe-2.0.0.tgz",
+      "integrity": "sha512-RHxMLp9lnKHGHRng9QFhRCMbYAcVpn69smSGcq3f36xjgVVWThj4qqLbTLlq7Ssj8B+fIQ1EuCEGI2lKsyQeIw==",
       "dev": true,
+      "license": "ISC"
+    },
+    "node_modules/isobject": {
+      "version": "3.0.1",
+      "resolved": "https://registry.npmjs.org/isobject/-/isobject-3.0.1.tgz",
+      "integrity": "sha512-WhB9zCku7EGTj/HQQRz5aUQEUeoQZH2bWcltRErOpymJ4boYE6wL9Tbr23krRPSZ+C5zqNSrSw+Cc7sZZ4b7vg==",
       "license": "MIT",
-      "dependencies": {
-        "ansi-styles": "^4.1.0",
-        "supports-color": "^7.1.0"
-      },
       "engines": {
-        "node": ">=10"
-      },
-      "funding": {
-        "url": "https://github.com/chalk/chalk?sponsor=1"
+        "node": ">=0.10.0"
       }
     },
-    "node_modules/chart.js": {
-      "version": "4.4.9",
-      "resolved": "https://registry.npmjs.org/chart.js/-/chart.js-4.4.9.tgz",
-      "integrity": "sha512-EyZ9wWKgpAU0fLJ43YAEIF8sr5F2W3LqbS40ZJyHIner2lY14ufqv2VMp69MAiZ2rpwxEUxEhIH/0U3xyRynxg==",
+    "node_modules/js-tokens": {
+      "version": "4.0.0",
+      "resolved": "https://registry.npmjs.org/js-tokens/-/js-tokens-4.0.0.tgz",
+      "integrity": "sha512-RdJUflcE3cUzKiMqQgsCu06FPu9UdIJO0beYbPhHN4k6apgJtifcoCtT9bcxOpYBtpD2kCM6Sbzg4CausW/PKQ==",
+      "license": "MIT"
+    },
+    "node_modules/js-yaml": {
+      "version": "4.1.0",
+      "resolved": "https://registry.npmjs.org/js-yaml/-/js-yaml-4.1.0.tgz",
+      "integrity": "sha512-wpxZs9NoxZaJESJGIZTyDEaYpl0FKSA+FB9aJiyemKhMwkxQg63h4T1KJgUGHpTqPDNRcmmYLugrRjJlBtWvRA==",
+      "dev": true,
       "license": "MIT",
       "dependencies": {
-        "@kurkle/color": "^0.3.0"
+        "argparse": "^2.0.1"
       },
-      "engines": {
-        "pnpm": ">=8"
+      "bin": {
+        "js-yaml": "bin/js-yaml.js"
       }
     },
-    "node_modules/chartjs-adapter-date-fns": {
-      "version": "3.0.0",
-      "resolved": "https://registry.npmjs.org/chartjs-adapter-date-fns/-/chartjs-adapter-date-fns-3.0.0.tgz",
-      "integrity": "sha512-Rs3iEB3Q5pJ973J93OBTpnP7qoGwvq3nUnoMdtxO+9aoJof7UFcRbWcIDteXuYd1fgAvct/32T9qaLyLuZVwCg==",
+    "node_modules/jsdom": {
+      "version": "27.0.1",
+      "resolved": "https://registry.npmjs.org/jsdom/-/jsdom-27.0.1.tgz",
+      "integrity": "sha512-SNSQteBL1IlV2zqhwwolaG9CwhIhTvVHWg3kTss/cLE7H/X4644mtPQqYvCfsSrGQWt9hSZcgOXX8bOZaMN+kA==",
+      "dev": true,
       "license": "MIT",
+      "dependencies": {
+        "@asamuzakjp/dom-selector": "^6.7.2",
+        "cssstyle": "^5.3.1",
+        "data-urls": "^6.0.0",
+        "decimal.js": "^10.6.0",
+        "html-encoding-sniffer": "^4.0.0",
+        "http-proxy-agent": "^7.0.2",
+        "https-proxy-agent": "^7.0.6",
+        "is-potential-custom-element-name": "^1.0.1",
+        "parse5": "^8.0.0",
+        "rrweb-cssom": "^0.8.0",
+        "saxes": "^6.0.0",
+        "symbol-tree": "^3.2.4",
+        "tough-cookie": "^6.0.0",
+        "w3c-xmlserializer": "^5.0.0",
+        "webidl-conversions": "^8.0.0",
+        "whatwg-encoding": "^3.1.1",
+        "whatwg-mimetype": "^4.0.0",
+        "whatwg-url": "^15.1.0",
+        "ws": "^8.18.3",
+        "xml-name-validator": "^5.0.0"
+      },
+      "engines": {
+        "node": ">=20"
+      },
       "peerDependencies": {
-        "chart.js": ">=2.8.0",
-        "date-fns": ">=2.0.0"
+        "canvas": "^3.0.0"
+      },
+      "peerDependenciesMeta": {
+        "canvas": {
+          "optional": true
+        }
       }
     },
-    "node_modules/color-convert": {
-      "version": "2.0.1",
-      "resolved": "https://registry.npmjs.org/color-convert/-/color-convert-2.0.1.tgz",
-      "integrity": "sha512-RRECPsj7iu/xb5oKYcsFHSppFNnsj/52OVTRKb4zP5onXwVF3zVmmToNcOfGC+CRDpfK/U584fMg38ZHCaElKQ==",
+    "node_modules/jsesc": {
+      "version": "3.1.0",
+      "resolved": "https://registry.npmjs.org/jsesc/-/jsesc-3.1.0.tgz",
+      "integrity": "sha512-/sM3dO2FOzXjKQhJuo0Q173wf2KOo8t4I8vHy6lF9poUp7bKT0/NHE8fPX23PwfhnykfqnC2xRxOnVw5XuGIaA==",
       "dev": true,
       "license": "MIT",
-      "dependencies": {
-        "color-name": "~1.1.4"
+      "bin": {
+        "jsesc": "bin/jsesc"
       },
       "engines": {
-        "node": ">=7.0.0"
+        "node": ">=6"
       }
     },
-    "node_modules/color-name": {
-      "version": "1.1.4",
-      "resolved": "https://registry.npmjs.org/color-name/-/color-name-1.1.4.tgz",
-      "integrity": "sha512-dOy+3AuW3a2wNbZHIuMZpTcgjGuLU/uBL/ubcZF9OXbDo8ff4O8yVp5Bf0efS8uEoYo5q4Fx7dY9OgQGXgAsQA==",
+    "node_modules/json-bignum": {
+      "version": "0.0.3",
+      "resolved": "https://registry.npmjs.org/json-bignum/-/json-bignum-0.0.3.tgz",
+      "integrity": "sha512-2WHyXj3OfHSgNyuzDbSxI1w2jgw5gkWSWhS7Qg4bWXx1nLk3jnbwfUeS0PSba3IzpTUWdHxBieELUzXRjQB2zg==",
+      "engines": {
+        "node": ">=0.8"
+      }
+    },
+    "node_modules/json-buffer": {
+      "version": "3.0.1",
+      "resolved": "https://registry.npmjs.org/json-buffer/-/json-buffer-3.0.1.tgz",
+      "integrity": "sha512-4bV5BfR2mqfQTJm+V5tPPdf+ZpuhiIvTuAB5g8kcrXOZpTT/QwwVRWBywX1ozr6lEuPdbHxwaJlm9G6mI2sfSQ==",
       "dev": true,
       "license": "MIT"
     },
-    "node_modules/concat-map": {
-      "version": "0.0.1",
-      "resolved": "https://registry.npmjs.org/concat-map/-/concat-map-0.0.1.tgz",
-      "integrity": "sha512-/Srv4dswyQNBfohGpz9o6Yb3Gz3SrUDqBH5rTuhGR7ahtlbYKnVxw2bCFMRljaA7EXHaXZ8wsHdodFvbkhKmqg==",
+    "node_modules/json-schema-traverse": {
+      "version": "0.4.1",
+      "resolved": "https://registry.npmjs.org/json-schema-traverse/-/json-schema-traverse-0.4.1.tgz",
+      "integrity": "sha512-xbbCH5dCYU5T8LcEhhuh7HJ88HXuW3qsI3Y0zOZFKfZEHcpWiHU/Jxzk629Brsab/mMiHQti9wMP+845RPe3Vg==",
       "dev": true,
       "license": "MIT"
     },
-    "node_modules/convert-source-map": {
-      "version": "2.0.0",
-      "resolved": "https://registry.npmjs.org/convert-source-map/-/convert-source-map-2.0.0.tgz",
-      "integrity": "sha512-Kvp459HrV2FEJ1CAsi1Ku+MY3kasH19TFykTz2xWmMeq6bk2NU3XXvfJ+Q61m0xktWwt+1HSYf3JZsTms3aRJg==",
+    "node_modules/json-stable-stringify-without-jsonify": {
+      "version": "1.0.1",
+      "resolved": "https://registry.npmjs.org/json-stable-stringify-without-jsonify/-/json-stable-stringify-without-jsonify-1.0.1.tgz",
+      "integrity": "sha512-Bdboy+l7tA3OGW6FjyFHWkP5LuByj1Tk33Ljyq0axyzdk9//JSi2u3fP1QSmd1KNwq6VOKYGlAu87CisVir6Pw==",
       "dev": true,
       "license": "MIT"
     },
-    "node_modules/cross-spawn": {
-      "version": "7.0.6",
-      "resolved": "https://registry.npmjs.org/cross-spawn/-/cross-spawn-7.0.6.tgz",
-      "integrity": "sha512-uV2QOWP2nWzsy2aMp8aRibhi9dlzF5Hgh5SHaB9OiTGEyDTiJJyx0uy51QXdyWbtAHNua4XJzUKca3OzKUd3vA==",
+    "node_modules/json-stringify-pretty-compact": {
+      "version": "4.0.0",
+      "resolved": "https://registry.npmjs.org/json-stringify-pretty-compact/-/json-stringify-pretty-compact-4.0.0.tgz",
+      "integrity": "sha512-3CNZ2DnrpByG9Nqj6Xo8vqbjT4F6N+tb4Gb28ESAZjYZ5yqvmc56J+/kuIwkaAMOyblTQhUW7PxMkUb8Q36N3Q==",
+      "license": "MIT"
+    },
+    "node_modules/json5": {
+      "version": "2.2.3",
+      "resolved": "https://registry.npmjs.org/json5/-/json5-2.2.3.tgz",
+      "integrity": "sha512-XmOWe7eyHYH14cLdVPoyg+GOH3rYX++KpzrylJwSW98t3Nk+U8XOl8FWKOgwtzdb8lXGf6zYwDUzeHMWfxasyg==",
       "dev": true,
       "license": "MIT",
-      "dependencies": {
-        "path-key": "^3.1.0",
-        "shebang-command": "^2.0.0",
-        "which": "^2.0.1"
+      "bin": {
+        "json5": "lib/cli.js"
       },
       "engines": {
-        "node": ">= 8"
+        "node": ">=6"
       }
     },
-    "node_modules/csstype": {
-      "version": "3.1.3",
-      "resolved": "https://registry.npmjs.org/csstype/-/csstype-3.1.3.tgz",
-      "integrity": "sha512-M1uQkMl8rQK/szD0LNhtqxIPLpimGm8sOBwU7lLnCpSbTyY3yeU1Vc7l4KT5zT4s/yOxHH5O7tIuuLOCnLADRw==",
+    "node_modules/kdbush": {
+      "version": "4.0.2",
+      "resolved": "https://registry.npmjs.org/kdbush/-/kdbush-4.0.2.tgz",
+      "integrity": "sha512-WbCVYJ27Sz8zi9Q7Q0xHC+05iwkm3Znipc2XTlrnJbsHMYktW4hPhXUE8Ys1engBrvffoSCqbil1JQAa7clRpA==",
+      "license": "ISC"
+    },
+    "node_modules/keyv": {
+      "version": "4.5.4",
+      "resolved": "https://registry.npmjs.org/keyv/-/keyv-4.5.4.tgz",
+      "integrity": "sha512-oxVHkHR/EJf2CNXnWxRLW6mg7JyCCUcG0DtEGmL2ctUo1PNTin1PUil+r/+4r5MpVgC/fn1kjsx7mjSujKqIpw==",
       "dev": true,
-      "license": "MIT"
+      "license": "MIT",
+      "dependencies": {
+        "json-buffer": "3.0.1"
+      }
     },
-    "node_modules/date-fns": {
-      "version": "4.1.0",
-      "resolved": "https://registry.npmjs.org/date-fns/-/date-fns-4.1.0.tgz",
-      "integrity": "sha512-Ukq0owbQXxa/U3EGtsdVBkR1w7KOQ5gIBqdH2hkvknzZPYvBxb/aa6E8L7tmjFtkwZBu3UXBbjIgPo/Ez4xaNg==",
+    "node_modules/kind-of": {
+      "version": "6.0.3",
+      "resolved": "https://registry.npmjs.org/kind-of/-/kind-of-6.0.3.tgz",
+      "integrity": "sha512-dcS1ul+9tmeD95T+x28/ehLgd9mENa3LsvDTtzm3vyBEO7RPptvAD+t44WVXaUjTBRcrpFeFlC8WCruUR456hw==",
       "license": "MIT",
       "peer": true,
-      "funding": {
-        "type": "github",
-        "url": "https://github.com/sponsors/kossnocorp"
+      "engines": {
+        "node": ">=0.10.0"
       }
     },
-    "node_modules/debug": {
-      "version": "4.4.1",
-      "resolved": "https://registry.npmjs.org/debug/-/debug-4.4.1.tgz",
-      "integrity": "sha512-KcKCqiftBJcZr++7ykoDIEwSa3XWowTfNPo92BYxjXiyYEVrUQh2aLyhxBCwww+heortUFxEJYcRzosstTEBYQ==",
+    "node_modules/leaflet": {
+      "version": "1.9.4",
+      "resolved": "https://registry.npmjs.org/leaflet/-/leaflet-1.9.4.tgz",
+      "integrity": "sha512-nxS1ynzJOmOlHp+iL3FyWqK89GtNL8U8rvlMOsQdTTssxZwCXh8N2NB3GDQOL+YR3XnWyZAxwQixURb+FA74PA==",
+      "license": "BSD-2-Clause"
+    },
+    "node_modules/levn": {
+      "version": "0.4.1",
+      "resolved": "https://registry.npmjs.org/levn/-/levn-0.4.1.tgz",
+      "integrity": "sha512-+bT2uH4E5LGE7h/n3evcS/sQlJXCpIp6ym8OWJ5eV6+67Dsql/LaaT7qJBAt2rzfoa/5QBGBhxDix1dMt2kQKQ==",
       "dev": true,
       "license": "MIT",
       "dependencies": {
-        "ms": "^2.1.3"
+        "prelude-ls": "^1.2.1",
+        "type-check": "~0.4.0"
       },
       "engines": {
-        "node": ">=6.0"
-      },
-      "peerDependenciesMeta": {
-        "supports-color": {
-          "optional": true
-        }
+        "node": ">= 0.8.0"
       }
     },
-    "node_modules/deep-is": {
-      "version": "0.1.4",
-      "resolved": "https://registry.npmjs.org/deep-is/-/deep-is-0.1.4.tgz",
-      "integrity": "sha512-oIPzksmTg4/MriiaYGO+okXDT7ztn/w3Eptv/+gSIdMdKsJo0u4CfYNFJPy+4SKMuCqGw2wxnA+URMg3t8a/bQ==",
-      "dev": true,
-      "license": "MIT"
-    },
-    "node_modules/dir-glob": {
-      "version": "3.0.1",
-      "resolved": "https://registry.npmjs.org/dir-glob/-/dir-glob-3.0.1.tgz",
-      "integrity": "sha512-WkrWp9GR4KXfKGYzOLmTuGVi1UWFfws377n9cc55/tb6DuqyF6pcQ5AbiHEshaDpY9v6oaSr2XCDidGmMwdzIA==",
+    "node_modules/locate-path": {
+      "version": "6.0.0",
+      "resolved": "https://registry.npmjs.org/locate-path/-/locate-path-6.0.0.tgz",
+      "integrity": "sha512-iPZK6eYjbxRu3uB4/WZ3EsEIMJFMqAoopl3R+zuq0UjcAm/MO6KCweDgPfP3elTztoKP3KtnVHxTn2NHBSDVUw==",
       "dev": true,
       "license": "MIT",
       "dependencies": {
-        "path-type": "^4.0.0"
+        "p-locate": "^5.0.0"
       },
       "engines": {
-        "node": ">=8"
+        "node": ">=10"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/sindresorhus"
       }
     },
-    "node_modules/doctrine": {
-      "version": "3.0.0",
-      "resolved": "https://registry.npmjs.org/doctrine/-/doctrine-3.0.0.tgz",
-      "integrity": "sha512-yS+Q5i3hBf7GBkd4KG8a7eBNNWNGLTaEwwYWUijIYM7zrlYDM0BFXHjjPWlWZ1Rg7UaddZeIDmi9jF3HmqiQ2w==",
-      "dev": true,
-      "license": "Apache-2.0",
+    "node_modules/lodash.camelcase": {
+      "version": "4.3.0",
+      "resolved": "https://registry.npmjs.org/lodash.camelcase/-/lodash.camelcase-4.3.0.tgz",
+      "integrity": "sha512-TwuEnCnxbc3rAvhf/LbG7tJUDzhqXyFnv3dtzLOPgCG/hODL7WFnsbwktkD7yUV0RrreP/l1PALq/YSg6VvjlA==",
+      "license": "MIT"
+    },
+    "node_modules/lodash.merge": {
+      "version": "4.6.2",
+      "resolved": "https://registry.npmjs.org/lodash.merge/-/lodash.merge-4.6.2.tgz",
+      "integrity": "sha512-0KpjqXRVvrYyCsX1swR/XTK0va6VQkQM6MNo7PqW77ByjAhoARA8EfrP1N4+KlKj8YS0ZUCtRT/YUuhyYDujIQ==",
+      "license": "MIT"
+    },
+    "node_modules/loose-envify": {
+      "version": "1.4.0",
+      "resolved": "https://registry.npmjs.org/loose-envify/-/loose-envify-1.4.0.tgz",
+      "integrity": "sha512-lyuxPGr/Wfhrlem2CL/UcnUc1zcqKAImBDzukY7Y5F/yQiNdko6+fRLevlw1HgMySw7f611UIY408EtxRSoK3Q==",
+      "license": "MIT",
       "dependencies": {
-        "esutils": "^2.0.2"
+        "js-tokens": "^3.0.0 || ^4.0.0"
       },
-      "engines": {
-        "node": ">=6.0.0"
+      "bin": {
+        "loose-envify": "cli.js"
       }
     },
-    "node_modules/electron-to-chromium": {
-      "version": "1.5.165",
-      "resolved": "https://registry.npmjs.org/electron-to-chromium/-/electron-to-chromium-1.5.165.tgz",
-      "integrity": "sha512-naiMx1Z6Nb2TxPU6fiFrUrDTjyPMLdTtaOd2oLmG8zVSg2hCWGkhPyxwk+qRmZ1ytwVqUv0u7ZcDA5+ALhaUtw==",
+    "node_modules/loupe": {
+      "version": "3.2.1",
+      "resolved": "https://registry.npmjs.org/loupe/-/loupe-3.2.1.tgz",
+      "integrity": "sha512-CdzqowRJCeLU72bHvWqwRBBlLcMEtIvGrlvef74kMnV2AolS9Y8xUv1I0U/MNAWMhBlKIoyuEgoJ0t/bbwHbLQ==",
       "dev": true,
-      "license": "ISC"
+      "license": "MIT"
     },
-    "node_modules/esbuild": {
-      "version": "0.21.5",
-      "resolved": "https://registry.npmjs.org/esbuild/-/esbuild-0.21.5.tgz",
-      "integrity": "sha512-mg3OPMV4hXywwpoDxu3Qda5xCKQi+vCTZq8S9J/EpkhB2HzKXq4SNFZE3+NK93JYxc8VMSep+lOUSC/RVKaBqw==",
+    "node_modules/lru-cache": {
+      "version": "5.1.1",
+      "resolved": "https://registry.npmjs.org/lru-cache/-/lru-cache-5.1.1.tgz",
+      "integrity": "sha512-KpNARQA3Iwv+jTA0utUVVbrh+Jlrr1Fv0e56GGzAFOXN7dk/FviaDW8LHmK52DlcH4WP2n6gI8vN1aesBFgo9w==",
       "dev": true,
-      "hasInstallScript": true,
-      "license": "MIT",
-      "bin": {
-        "esbuild": "bin/esbuild"
-      },
-      "engines": {
-        "node": ">=12"
-      },
-      "optionalDependencies": {
-        "@esbuild/aix-ppc64": "0.21.5",
-        "@esbuild/android-arm": "0.21.5",
-        "@esbuild/android-arm64": "0.21.5",
-        "@esbuild/android-x64": "0.21.5",
-        "@esbuild/darwin-arm64": "0.21.5",
-        "@esbuild/darwin-x64": "0.21.5",
-        "@esbuild/freebsd-arm64": "0.21.5",
-        "@esbuild/freebsd-x64": "0.21.5",
-        "@esbuild/linux-arm": "0.21.5",
-        "@esbuild/linux-arm64": "0.21.5",
-        "@esbuild/linux-ia32": "0.21.5",
-        "@esbuild/linux-loong64": "0.21.5",
-        "@esbuild/linux-mips64el": "0.21.5",
-        "@esbuild/linux-ppc64": "0.21.5",
-        "@esbuild/linux-riscv64": "0.21.5",
-        "@esbuild/linux-s390x": "0.21.5",
-        "@esbuild/linux-x64": "0.21.5",
-        "@esbuild/netbsd-x64": "0.21.5",
-        "@esbuild/openbsd-x64": "0.21.5",
-        "@esbuild/sunos-x64": "0.21.5",
-        "@esbuild/win32-arm64": "0.21.5",
-        "@esbuild/win32-ia32": "0.21.5",
-        "@esbuild/win32-x64": "0.21.5"
+      "license": "ISC",
+      "dependencies": {
+        "yallist": "^3.0.2"
       }
     },
-    "node_modules/escalade": {
-      "version": "3.2.0",
-      "resolved": "https://registry.npmjs.org/escalade/-/escalade-3.2.0.tgz",
-      "integrity": "sha512-WUj2qlxaQtO4g6Pq5c29GTcWGDyd8itL8zTlipgECz3JesAiiOKotd8JU6otB3PACgG6xkJUyVhboMS+bje/jA==",
+    "node_modules/lz-string": {
+      "version": "1.5.0",
+      "resolved": "https://registry.npmjs.org/lz-string/-/lz-string-1.5.0.tgz",
+      "integrity": "sha512-h5bgJWpxJNswbU7qCrV0tIKQCaS3blPDrqKWx+QxzuzL1zGUzij9XCWLrSLsJPu5t+eWA/ycetzYAO5IOMcWAQ==",
       "dev": true,
       "license": "MIT",
-      "engines": {
-        "node": ">=6"
+      "peer": true,
+      "bin": {
+        "lz-string": "bin/bin.js"
       }
     },
-    "node_modules/escape-string-regexp": {
-      "version": "4.0.0",
-      "resolved": "https://registry.npmjs.org/escape-string-regexp/-/escape-string-regexp-4.0.0.tgz",
-      "integrity": "sha512-TtpcNJ3XAzx3Gq8sWRzJaVajRs0uVxA2YAkdb1jm2YkPz4G6egUFAyA3n5vtEIZefPk5Wa4UXbKuS5fKkJWdgA==",
+    "node_modules/magic-string": {
+      "version": "0.30.21",
+      "resolved": "https://registry.npmjs.org/magic-string/-/magic-string-0.30.21.tgz",
+      "integrity": "sha512-vd2F4YUyEXKGcLHoq+TEyCjxueSeHnFxyyjNp80yg0XV4vUhnDer/lvvlqM/arB5bXQN5K2/3oinyCRyx8T2CQ==",
       "dev": true,
       "license": "MIT",
-      "engines": {
-        "node": ">=10"
-      },
-      "funding": {
-        "url": "https://github.com/sponsors/sindresorhus"
+      "dependencies": {
+        "@jridgewell/sourcemap-codec": "^1.5.5"
       }
     },
-    "node_modules/eslint": {
-      "version": "8.57.1",
-      "resolved": "https://registry.npmjs.org/eslint/-/eslint-8.57.1.tgz",
-      "integrity": "sha512-ypowyDxpVSYpkXr9WPv2PAZCtNip1Mv5KTW0SCurXv/9iOpcrH9PaqUElksqEB6pChqHGDRCFTyrZlGhnLNGiA==",
-      "deprecated": "This version is no longer supported. Please see https://eslint.org/version-support for other options.",
-      "dev": true,
+    "node_modules/map-limit": {
+      "version": "0.0.1",
+      "resolved": "https://registry.npmjs.org/map-limit/-/map-limit-0.0.1.tgz",
+      "integrity": "sha512-pJpcfLPnIF/Sk3taPW21G/RQsEEirGaFpCW3oXRwH9dnFHPHNGjNyvh++rdmC2fNqEaTw2MhYJraoJWAHx8kEg==",
       "license": "MIT",
+      "peer": true,
       "dependencies": {
-        "@eslint-community/eslint-utils": "^4.2.0",
-        "@eslint-community/regexpp": "^4.6.1",
-        "@eslint/eslintrc": "^2.1.4",
-        "@eslint/js": "8.57.1",
-        "@humanwhocodes/config-array": "^0.13.0",
-        "@humanwhocodes/module-importer": "^1.0.1",
-        "@nodelib/fs.walk": "^1.2.8",
-        "@ungap/structured-clone": "^1.2.0",
-        "ajv": "^6.12.4",
-        "chalk": "^4.0.0",
-        "cross-spawn": "^7.0.2",
-        "debug": "^4.3.2",
-        "doctrine": "^3.0.0",
-        "escape-string-regexp": "^4.0.0",
-        "eslint-scope": "^7.2.2",
-        "eslint-visitor-keys": "^3.4.3",
-        "espree": "^9.6.1",
-        "esquery": "^1.4.2",
-        "esutils": "^2.0.2",
-        "fast-deep-equal": "^3.1.3",
-        "file-entry-cache": "^6.0.1",
-        "find-up": "^5.0.0",
-        "glob-parent": "^6.0.2",
-        "globals": "^13.19.0",
-        "graphemer": "^1.4.0",
-        "ignore": "^5.2.0",
-        "imurmurhash": "^0.1.4",
-        "is-glob": "^4.0.0",
-        "is-path-inside": "^3.0.3",
-        "js-yaml": "^4.1.0",
-        "json-stable-stringify-without-jsonify": "^1.0.1",
-        "levn": "^0.4.1",
-        "lodash.merge": "^4.6.2",
-        "minimatch": "^3.1.2",
-        "natural-compare": "^1.4.0",
-        "optionator": "^0.9.3",
-        "strip-ansi": "^6.0.1",
-        "text-table": "^0.2.0"
-      },
-      "bin": {
-        "eslint": "bin/eslint.js"
-      },
-      "engines": {
-        "node": "^12.22.0 || ^14.17.0 || >=16.0.0"
-      },
-      "funding": {
-        "url": "https://opencollective.com/eslint"
+        "once": "~1.3.0"
       }
     },
-    "node_modules/eslint-plugin-react-hooks": {
-      "version": "4.6.2",
-      "resolved": "https://registry.npmjs.org/eslint-plugin-react-hooks/-/eslint-plugin-react-hooks-4.6.2.tgz",
-      "integrity": "sha512-QzliNJq4GinDBcD8gPB5v0wh6g8q3SUi6EFF0x8N/BL9PoVs0atuGc47ozMRyOWAKdwaZ5OnbOEa3WR+dSGKuQ==",
-      "dev": true,
-      "license": "MIT",
-      "engines": {
-        "node": ">=10"
+    "node_modules/map-limit/node_modules/once": {
+      "version": "1.3.3",
+      "resolved": "https://registry.npmjs.org/once/-/once-1.3.3.tgz",
+      "integrity": "sha512-6vaNInhu+CHxtONf3zw3vq4SP2DOQhjBvIa3rNcG0+P7eKWlYH6Peu7rHizSloRU2EwMz6GraLieis9Ac9+p1w==",
+      "license": "ISC",
+      "peer": true,
+      "dependencies": {
+        "wrappy": "1"
+      }
+    },
+    "node_modules/mapbox-gl": {
+      "version": "3.20.0",
+      "resolved": "https://registry.npmjs.org/mapbox-gl/-/mapbox-gl-3.20.0.tgz",
+      "integrity": "sha512-+rVQkf6ymUlAEJiQBZy0OiamJvQN4Uk15mRHI98PRUSmRS40GOoLJyEZEG39LEUtvmzc7qGh+4ygZfJ//O5VnQ==",
+      "license": "SEE LICENSE IN LICENSE.txt",
+      "optional": true,
+      "peer": true,
+      "workspaces": [
+        "src/style-spec",
+        "test/build/vite",
+        "test/build/webpack",
+        "test/build/typings"
+      ],
+      "dependencies": {
+        "@mapbox/jsonlint-lines-primitives": "^2.0.2",
+        "@mapbox/mapbox-gl-supported": "^3.0.0",
+        "@mapbox/point-geometry": "^1.1.0",
+        "@mapbox/tiny-sdf": "^2.0.6",
+        "@mapbox/unitbezier": "^0.0.1",
+        "@mapbox/vector-tile": "^2.0.4",
+        "@types/geojson": "^7946.0.16",
+        "@types/geojson-vt": "^3.2.5",
+        "@types/pbf": "^3.0.5",
+        "@types/supercluster": "^7.1.3",
+        "cheap-ruler": "^4.0.0",
+        "csscolorparser": "~1.0.3",
+        "earcut": "^3.0.1",
+        "geojson-vt": "^4.0.2",
+        "gl-matrix": "^3.4.4",
+        "grid-index": "^1.1.0",
+        "kdbush": "^4.0.2",
+        "martinez-polygon-clipping": "^0.8.1",
+        "murmurhash-js": "^1.0.0",
+        "pbf": "^4.0.1",
+        "potpack": "^2.0.0",
+        "quickselect": "^3.0.0",
+        "supercluster": "^8.0.1",
+        "tinyqueue": "^3.0.0"
+      }
+    },
+    "node_modules/mapbox-gl/node_modules/earcut": {
+      "version": "3.0.2",
+      "resolved": "https://registry.npmjs.org/earcut/-/earcut-3.0.2.tgz",
+      "integrity": "sha512-X7hshQbLyMJ/3RPhyObLARM2sNxxmRALLKx1+NVFFnQ9gKzmCrxm9+uLIAdBcvc8FNLpctqlQ2V6AE92Ol9UDQ==",
+      "license": "ISC",
+      "optional": true,
+      "peer": true
+    },
+    "node_modules/mapbox-gl/node_modules/geojson-vt": {
+      "version": "4.0.2",
+      "resolved": "https://registry.npmjs.org/geojson-vt/-/geojson-vt-4.0.2.tgz",
+      "integrity": "sha512-AV9ROqlNqoZEIJGfm1ncNjEXfkz2hdFlZf0qkVfmkwdKa8vj7H16YUOT81rJw1rdFhyEDlN2Tds91p/glzbl5A==",
+      "license": "ISC",
+      "optional": true,
+      "peer": true
+    },
+    "node_modules/maplibre-gl": {
+      "version": "5.21.0",
+      "resolved": "https://registry.npmjs.org/maplibre-gl/-/maplibre-gl-5.21.0.tgz",
+      "integrity": "sha512-n0v4J/Ge0EG8ix/z3TY3ragtJYMqzbtSnj1riOC0OwQbzwp0lUF2maS1ve1z8HhitQCKtZZiZJhb8to36aMMfQ==",
+      "license": "BSD-3-Clause",
+      "dependencies": {
+        "@mapbox/jsonlint-lines-primitives": "^2.0.2",
+        "@mapbox/point-geometry": "^1.1.0",
+        "@mapbox/tiny-sdf": "^2.0.7",
+        "@mapbox/unitbezier": "^0.0.1",
+        "@mapbox/vector-tile": "^2.0.4",
+        "@mapbox/whoots-js": "^3.1.0",
+        "@maplibre/geojson-vt": "^6.0.4",
+        "@maplibre/maplibre-gl-style-spec": "^24.7.0",
+        "@maplibre/mlt": "^1.1.8",
+        "@maplibre/vt-pbf": "^4.3.0",
+        "@types/geojson": "^7946.0.16",
+        "earcut": "^3.0.2",
+        "gl-matrix": "^3.4.4",
+        "kdbush": "^4.0.2",
+        "murmurhash-js": "^1.0.0",
+        "pbf": "^4.0.1",
+        "potpack": "^2.1.0",
+        "quickselect": "^3.0.0",
+        "tinyqueue": "^3.0.0"
+      },
+      "engines": {
+        "node": ">=16.14.0",
+        "npm": ">=8.1.0"
       },
-      "peerDependencies": {
-        "eslint": "^3.0.0 || ^4.0.0 || ^5.0.0 || ^6.0.0 || ^7.0.0 || ^8.0.0-0"
+      "funding": {
+        "url": "https://github.com/maplibre/maplibre-gl-js?sponsor=1"
       }
     },
-    "node_modules/eslint-plugin-react-refresh": {
-      "version": "0.4.20",
-      "resolved": "https://registry.npmjs.org/eslint-plugin-react-refresh/-/eslint-plugin-react-refresh-0.4.20.tgz",
-      "integrity": "sha512-XpbHQ2q5gUF8BGOX4dHe+71qoirYMhApEPZ7sfhF/dNnOF1UXnCMGZf79SFTBO7Bz5YEIT4TMieSlJBWhP9WBA==",
-      "dev": true,
+    "node_modules/maplibre-gl/node_modules/earcut": {
+      "version": "3.0.2",
+      "resolved": "https://registry.npmjs.org/earcut/-/earcut-3.0.2.tgz",
+      "integrity": "sha512-X7hshQbLyMJ/3RPhyObLARM2sNxxmRALLKx1+NVFFnQ9gKzmCrxm9+uLIAdBcvc8FNLpctqlQ2V6AE92Ol9UDQ==",
+      "license": "ISC"
+    },
+    "node_modules/martinez-polygon-clipping": {
+      "version": "0.8.1",
+      "resolved": "https://registry.npmjs.org/martinez-polygon-clipping/-/martinez-polygon-clipping-0.8.1.tgz",
+      "integrity": "sha512-9PLLMzMPI6ihHox4Ns6LpVBLpRc7sbhULybZ/wyaY8sY3ECNe2+hxm1hA2/9bEEpRrdpjoeduBuZLg2aq1cSIQ==",
       "license": "MIT",
-      "peerDependencies": {
-        "eslint": ">=8.40"
+      "optional": true,
+      "peer": true,
+      "dependencies": {
+        "robust-predicates": "^2.0.4",
+        "splaytree": "^0.1.4",
+        "tinyqueue": "3.0.0"
       }
     },
-    "node_modules/eslint-scope": {
-      "version": "7.2.2",
-      "resolved": "https://registry.npmjs.org/eslint-scope/-/eslint-scope-7.2.2.tgz",
-      "integrity": "sha512-dOt21O7lTMhDM+X9mB4GX+DZrZtCUJPL/wlcTqxyrx5IvO0IYtILdtrQGQp+8n5S0gwSVmOf9NQrjMOgfQZlIg==",
-      "dev": true,
-      "license": "BSD-2-Clause",
-      "dependencies": {
-        "esrecurse": "^4.3.0",
-        "estraverse": "^5.2.0"
-      },
+    "node_modules/math-log2": {
+      "version": "1.0.1",
+      "resolved": "https://registry.npmjs.org/math-log2/-/math-log2-1.0.1.tgz",
+      "integrity": "sha512-9W0yGtkaMAkf74XGYVy4Dqw3YUMnTNB2eeiw9aQbUl4A3KmuCEHTt2DgAB07ENzOYAjsYSAYufkAq0Zd+jU7zA==",
+      "license": "MIT",
+      "peer": true,
       "engines": {
-        "node": "^12.22.0 || ^14.17.0 || >=16.0.0"
-      },
-      "funding": {
-        "url": "https://opencollective.com/eslint"
+        "node": ">=0.10.0"
       }
     },
-    "node_modules/eslint-visitor-keys": {
-      "version": "3.4.3",
-      "resolved": "https://registry.npmjs.org/eslint-visitor-keys/-/eslint-visitor-keys-3.4.3.tgz",
-      "integrity": "sha512-wpc+LXeiyiisxPlEkUzU6svyS1frIO3Mgxj1fdy7Pm8Ygzguax2N3Fa/D/ag1WqbOprdI+uY6wMUl8/a2G+iag==",
+    "node_modules/mdn-data": {
+      "version": "2.12.2",
+      "resolved": "https://registry.npmjs.org/mdn-data/-/mdn-data-2.12.2.tgz",
+      "integrity": "sha512-IEn+pegP1aManZuckezWCO+XZQDplx1366JoVhTpMpBB1sPey/SbveZQUosKiKiGYjg1wH4pMlNgXbCiYgihQA==",
       "dev": true,
-      "license": "Apache-2.0",
-      "engines": {
-        "node": "^12.22.0 || ^14.17.0 || >=16.0.0"
-      },
-      "funding": {
-        "url": "https://opencollective.com/eslint"
-      }
+      "license": "CC0-1.0"
     },
-    "node_modules/eslint/node_modules/brace-expansion": {
-      "version": "1.1.11",
-      "resolved": "https://registry.npmjs.org/brace-expansion/-/brace-expansion-1.1.11.tgz",
-      "integrity": "sha512-iCuPHDFgrHX7H2vEI/5xpz07zSHB00TpugqhmYtVmMO6518mCuRMoOYFldEBl0g187ufozdaHgWKcYFb61qGiA==",
+    "node_modules/merge2": {
+      "version": "1.4.1",
+      "resolved": "https://registry.npmjs.org/merge2/-/merge2-1.4.1.tgz",
+      "integrity": "sha512-8q7VEgMJW4J8tcfVPy8g09NcQwZdbwFEqhe/WZkoIzjn/3TGDwtOCYtXGxA3O8tPzpczCCDgv+P2P5y00ZJOOg==",
       "dev": true,
       "license": "MIT",
-      "dependencies": {
-        "balanced-match": "^1.0.0",
-        "concat-map": "0.0.1"
+      "engines": {
+        "node": ">= 8"
       }
     },
-    "node_modules/eslint/node_modules/globals": {
-      "version": "13.24.0",
-      "resolved": "https://registry.npmjs.org/globals/-/globals-13.24.0.tgz",
-      "integrity": "sha512-AhO5QUcj8llrbG09iWhPU2B204J1xnPeL8kQmVorSsy+Sjj1sk8gIyh6cUocGmH4L0UuhAJy+hJMRA4mgA4mFQ==",
+    "node_modules/micromatch": {
+      "version": "4.0.8",
+      "resolved": "https://registry.npmjs.org/micromatch/-/micromatch-4.0.8.tgz",
+      "integrity": "sha512-PXwfBhYu0hBCPw8Dn0E+WDYb7af3dSLVWKi3HGv84IdF4TyFoC0ysxFd0Goxw7nSv4T/PzEJQxsYsEiFCKo2BA==",
       "dev": true,
       "license": "MIT",
       "dependencies": {
-        "type-fest": "^0.20.2"
+        "braces": "^3.0.3",
+        "picomatch": "^2.3.1"
       },
       "engines": {
-        "node": ">=8"
-      },
-      "funding": {
-        "url": "https://github.com/sponsors/sindresorhus"
+        "node": ">=8.6"
       }
     },
-    "node_modules/eslint/node_modules/minimatch": {
-      "version": "3.1.2",
-      "resolved": "https://registry.npmjs.org/minimatch/-/minimatch-3.1.2.tgz",
-      "integrity": "sha512-J7p63hRiAjw1NDEww1W7i37+ByIrOWO5XQQAzZ3VOcL0PNybwpfmV/N05zFAzwQ9USyEcX6t3UO+K5aqBQOIHw==",
+    "node_modules/min-indent": {
+      "version": "1.0.1",
+      "resolved": "https://registry.npmjs.org/min-indent/-/min-indent-1.0.1.tgz",
+      "integrity": "sha512-I9jwMn07Sy/IwOj3zVkVik2JTvgpaykDZEigL6Rx6N9LbMywwUSMtxET+7lVoDLLd3O3IXwJwvuuns8UB/HeAg==",
       "dev": true,
-      "license": "ISC",
-      "dependencies": {
-        "brace-expansion": "^1.1.7"
-      },
+      "license": "MIT",
       "engines": {
-        "node": "*"
+        "node": ">=4"
       }
     },
-    "node_modules/espree": {
-      "version": "9.6.1",
-      "resolved": "https://registry.npmjs.org/espree/-/espree-9.6.1.tgz",
-      "integrity": "sha512-oruZaFkjorTpF32kDSI5/75ViwGeZginGGy2NoOSg3Q9bnwlnmDm4HLnkl0RE3n+njDXR037aY1+x58Z/zFdwQ==",
+    "node_modules/minimatch": {
+      "version": "9.0.5",
+      "resolved": "https://registry.npmjs.org/minimatch/-/minimatch-9.0.5.tgz",
+      "integrity": "sha512-G6T0ZX48xgozx7587koeX9Ys2NYy6Gmv//P89sEte9V9whIapMNF4idKxnW2QtCcLiTWlb/wfCabAtAFWhhBow==",
       "dev": true,
-      "license": "BSD-2-Clause",
+      "license": "ISC",
       "dependencies": {
-        "acorn": "^8.9.0",
-        "acorn-jsx": "^5.3.2",
-        "eslint-visitor-keys": "^3.4.1"
+        "brace-expansion": "^2.0.1"
       },
       "engines": {
-        "node": "^12.22.0 || ^14.17.0 || >=16.0.0"
+        "node": ">=16 || 14 >=14.17"
       },
       "funding": {
-        "url": "https://opencollective.com/eslint"
+        "url": "https://github.com/sponsors/isaacs"
       }
     },
-    "node_modules/esquery": {
-      "version": "1.6.0",
-      "resolved": "https://registry.npmjs.org/esquery/-/esquery-1.6.0.tgz",
-      "integrity": "sha512-ca9pw9fomFcKPvFLXhBKUK90ZvGibiGOvRJNbjljY7s7uq/5YO4BOzcYtJqExdx99rF6aAcnRxHmcUHcz6sQsg==",
-      "dev": true,
-      "license": "BSD-3-Clause",
-      "dependencies": {
-        "estraverse": "^5.1.0"
-      },
-      "engines": {
-        "node": ">=0.10"
+    "node_modules/minimist": {
+      "version": "1.2.8",
+      "resolved": "https://registry.npmjs.org/minimist/-/minimist-1.2.8.tgz",
+      "integrity": "sha512-2yyAR8qBkN3YuheJanUpWC5U3bb5osDywNB8RzDVlDwDHbocAJveqqj1u8+SVD7jkWT4yvsHCpWqqWqAxb0zCA==",
+      "license": "MIT",
+      "funding": {
+        "url": "https://github.com/sponsors/ljharb"
       }
     },
-    "node_modules/esrecurse": {
-      "version": "4.3.0",
-      "resolved": "https://registry.npmjs.org/esrecurse/-/esrecurse-4.3.0.tgz",
-      "integrity": "sha512-KmfKL3b6G+RXvP8N1vr3Tq1kL/oCFgn2NYXEtqP8/L3pKapUA4G8cFVaoF3SU323CD4XypR/ffioHmkti6/Tag==",
-      "dev": true,
-      "license": "BSD-2-Clause",
+    "node_modules/mjolnir.js": {
+      "version": "3.0.0",
+      "resolved": "https://registry.npmjs.org/mjolnir.js/-/mjolnir.js-3.0.0.tgz",
+      "integrity": "sha512-siX3YCG7N2HnmN1xMH3cK4JkUZJhbkhRFJL+G5N1vH0mh1t5088rJknIoqDFWDIU6NPGvRRgLnYW3ZHjSMEBLA==",
+      "license": "MIT"
+    },
+    "node_modules/mouse-change": {
+      "version": "1.4.0",
+      "resolved": "https://registry.npmjs.org/mouse-change/-/mouse-change-1.4.0.tgz",
+      "integrity": "sha512-vpN0s+zLL2ykyyUDh+fayu9Xkor5v/zRD9jhSqjRS1cJTGS0+oakVZzNm5n19JvvEj0you+MXlYTpNxUDQUjkQ==",
+      "license": "MIT",
+      "peer": true,
       "dependencies": {
-        "estraverse": "^5.2.0"
-      },
-      "engines": {
-        "node": ">=4.0"
+        "mouse-event": "^1.0.0"
       }
     },
-    "node_modules/estraverse": {
-      "version": "5.3.0",
-      "resolved": "https://registry.npmjs.org/estraverse/-/estraverse-5.3.0.tgz",
-      "integrity": "sha512-MMdARuVEQziNTeJD8DgMqmhwR11BRQ/cBP+pLtYdSTnf3MIO8fFeiINEbX36ZdNlfU/7A9f3gUw49B3oQsvwBA==",
-      "dev": true,
-      "license": "BSD-2-Clause",
-      "engines": {
-        "node": ">=4.0"
+    "node_modules/mouse-event": {
+      "version": "1.0.5",
+      "resolved": "https://registry.npmjs.org/mouse-event/-/mouse-event-1.0.5.tgz",
+      "integrity": "sha512-ItUxtL2IkeSKSp9cyaX2JLUuKk2uMoxBg4bbOWVd29+CskYJR9BGsUqtXenNzKbnDshvupjUewDIYVrOB6NmGw==",
+      "license": "MIT",
+      "peer": true
+    },
+    "node_modules/mouse-event-offset": {
+      "version": "3.0.2",
+      "resolved": "https://registry.npmjs.org/mouse-event-offset/-/mouse-event-offset-3.0.2.tgz",
+      "integrity": "sha512-s9sqOs5B1Ykox3Xo8b3Ss2IQju4UwlW6LSR+Q5FXWpprJ5fzMLefIIItr3PH8RwzfGy6gxs/4GAmiNuZScE25w==",
+      "license": "MIT",
+      "peer": true
+    },
+    "node_modules/mouse-wheel": {
+      "version": "1.2.0",
+      "resolved": "https://registry.npmjs.org/mouse-wheel/-/mouse-wheel-1.2.0.tgz",
+      "integrity": "sha512-+OfYBiUOCTWcTECES49neZwL5AoGkXE+lFjIvzwNCnYRlso+EnfvovcBxGoyQ0yQt806eSPjS675K0EwWknXmw==",
+      "license": "MIT",
+      "peer": true,
+      "dependencies": {
+        "right-now": "^1.0.0",
+        "signum": "^1.0.0",
+        "to-px": "^1.0.1"
       }
     },
-    "node_modules/esutils": {
-      "version": "2.0.3",
-      "resolved": "https://registry.npmjs.org/esutils/-/esutils-2.0.3.tgz",
-      "integrity": "sha512-kVscqXk4OCp68SZ0dkgEKVi6/8ij300KBWTJq32P/dYeWTSwK41WyTxalN1eRmA5Z9UU/LX9D7FWSmV9SAYx6g==",
+    "node_modules/ms": {
+      "version": "2.1.3",
+      "resolved": "https://registry.npmjs.org/ms/-/ms-2.1.3.tgz",
+      "integrity": "sha512-6FlzubTLZG3J2a/NVCAleEhjzq5oxgHyaCU9yYXvcLsvoVaHJq/s5xXI6/XXP6tz7R9xAOtHnSO/tXtF3WRTlA==",
+      "license": "MIT"
+    },
+    "node_modules/murmurhash-js": {
+      "version": "1.0.0",
+      "resolved": "https://registry.npmjs.org/murmurhash-js/-/murmurhash-js-1.0.0.tgz",
+      "integrity": "sha512-TvmkNhkv8yct0SVBSy+o8wYzXjE4Zz3PCesbfs8HiCXXdcTuocApFv11UWlNFWKYsP2okqrhb7JNlSm9InBhIw==",
+      "license": "MIT"
+    },
+    "node_modules/nanoid": {
+      "version": "3.3.11",
+      "resolved": "https://registry.npmjs.org/nanoid/-/nanoid-3.3.11.tgz",
+      "integrity": "sha512-N8SpfPUnUp1bK+PMYW8qSWdl9U+wwNWI4QKxOYDy9JAro3WMX7p2OeVRF9v+347pnakNevPmiHhNmZ2HbFA76w==",
       "dev": true,
-      "license": "BSD-2-Clause",
+      "funding": [
+        {
+          "type": "github",
+          "url": "https://github.com/sponsors/ai"
+        }
+      ],
+      "license": "MIT",
+      "bin": {
+        "nanoid": "bin/nanoid.cjs"
+      },
       "engines": {
-        "node": ">=0.10.0"
+        "node": "^10 || ^12 || ^13.7 || ^14 || >=15.0.1"
       }
     },
-    "node_modules/fast-deep-equal": {
-      "version": "3.1.3",
-      "resolved": "https://registry.npmjs.org/fast-deep-equal/-/fast-deep-equal-3.1.3.tgz",
-      "integrity": "sha512-f3qQ9oQy9j2AhBe/H9VC91wLmKBCCU/gDOnKNAYG5hswO7BLKj09Hc5HYNz9cGI++xlpDCIgDaitVs03ATR84Q==",
+    "node_modules/native-promise-only": {
+      "version": "0.8.1",
+      "resolved": "https://registry.npmjs.org/native-promise-only/-/native-promise-only-0.8.1.tgz",
+      "integrity": "sha512-zkVhZUA3y8mbz652WrL5x0fB0ehrBkulWT3TomAQ9iDtyXZvzKeEA6GPxAItBYeNYl5yngKRX612qHOhvMkDeg==",
+      "license": "MIT",
+      "peer": true
+    },
+    "node_modules/natural-compare": {
+      "version": "1.4.0",
+      "resolved": "https://registry.npmjs.org/natural-compare/-/natural-compare-1.4.0.tgz",
+      "integrity": "sha512-OWND8ei3VtNC9h7V60qff3SVobHr996CTwgxubgyQYEpg290h9J0buyECNNJexkFm5sOajh5G116RYA1c8ZMSw==",
       "dev": true,
       "license": "MIT"
     },
-    "node_modules/fast-glob": {
-      "version": "3.3.3",
-      "resolved": "https://registry.npmjs.org/fast-glob/-/fast-glob-3.3.3.tgz",
-      "integrity": "sha512-7MptL8U0cqcFdzIzwOTHoilX9x5BrNqye7Z/LuC7kCMRio1EMSyqRK3BEAUD7sXRq4iT4AzTVuZdhgQ2TCvYLg==",
-      "dev": true,
+    "node_modules/needle": {
+      "version": "2.9.1",
+      "resolved": "https://registry.npmjs.org/needle/-/needle-2.9.1.tgz",
+      "integrity": "sha512-6R9fqJ5Zcmf+uYaFgdIHmLwNldn5HbK8L5ybn7Uz+ylX/rnOsSp1AHcvQSrCaFN+qNM1wpymHqD7mVasEOlHGQ==",
       "license": "MIT",
+      "peer": true,
       "dependencies": {
-        "@nodelib/fs.stat": "^2.0.2",
-        "@nodelib/fs.walk": "^1.2.3",
-        "glob-parent": "^5.1.2",
-        "merge2": "^1.3.0",
-        "micromatch": "^4.0.8"
+        "debug": "^3.2.6",
+        "iconv-lite": "^0.4.4",
+        "sax": "^1.2.4"
+      },
+      "bin": {
+        "needle": "bin/needle"
       },
       "engines": {
-        "node": ">=8.6.0"
+        "node": ">= 4.4.x"
       }
     },
-    "node_modules/fast-glob/node_modules/glob-parent": {
-      "version": "5.1.2",
-      "resolved": "https://registry.npmjs.org/glob-parent/-/glob-parent-5.1.2.tgz",
-      "integrity": "sha512-AOIgSQCepiJYwP3ARnGx+5VnTu2HBYdzbGP45eLw1vr3zB3vZLeyed1sC9hnbcOc9/SrMyM5RPQrkGz4aS9Zow==",
-      "dev": true,
-      "license": "ISC",
+    "node_modules/needle/node_modules/debug": {
+      "version": "3.2.7",
+      "resolved": "https://registry.npmjs.org/debug/-/debug-3.2.7.tgz",
+      "integrity": "sha512-CFjzYYAi4ThfiQvizrFQevTTXHtnCqWfe7x1AhgEscTz6ZbLbfoLRLPugTQyBth6f8ZERVUSyWHFD/7Wu4t1XQ==",
+      "license": "MIT",
+      "peer": true,
       "dependencies": {
-        "is-glob": "^4.0.1"
+        "ms": "^2.1.1"
+      }
+    },
+    "node_modules/needle/node_modules/iconv-lite": {
+      "version": "0.4.24",
+      "resolved": "https://registry.npmjs.org/iconv-lite/-/iconv-lite-0.4.24.tgz",
+      "integrity": "sha512-v3MXnZAcvnywkTUEZomIActle7RXXeedOR31wwl7VlyoXO4Qi9arvSenNQWne1TcRwhCL1HwLI21bEqdpj8/rA==",
+      "license": "MIT",
+      "peer": true,
+      "dependencies": {
+        "safer-buffer": ">= 2.1.2 < 3"
       },
       "engines": {
-        "node": ">= 6"
+        "node": ">=0.10.0"
       }
     },
-    "node_modules/fast-json-stable-stringify": {
-      "version": "2.1.0",
-      "resolved": "https://registry.npmjs.org/fast-json-stable-stringify/-/fast-json-stable-stringify-2.1.0.tgz",
-      "integrity": "sha512-lhd/wF+Lk98HZoTCtlVraHtfh5XYijIjalXck7saUtuanSDyLMxnHhSXEDJqHxD7msR8D0uCmqlkwjCV8xvwHw==",
-      "dev": true,
-      "license": "MIT"
+    "node_modules/next-tick": {
+      "version": "1.1.0",
+      "resolved": "https://registry.npmjs.org/next-tick/-/next-tick-1.1.0.tgz",
+      "integrity": "sha512-CXdUiJembsNjuToQvxayPZF9Vqht7hewsvy2sOWafLvi2awflj9mOC6bHIg50orX8IJvWKY9wYQ/zB2kogPslQ==",
+      "license": "ISC",
+      "peer": true
     },
-    "node_modules/fast-levenshtein": {
-      "version": "2.0.6",
-      "resolved": "https://registry.npmjs.org/fast-levenshtein/-/fast-levenshtein-2.0.6.tgz",
-      "integrity": "sha512-DCXu6Ifhqcks7TZKY3Hxp3y6qphY5SJZmrWMDrKcERSOXWQdMhU9Ig/PYrzyw/ul9jOIyh0N4M0tbC5hodg8dw==",
+    "node_modules/node-releases": {
+      "version": "2.0.19",
+      "resolved": "https://registry.npmjs.org/node-releases/-/node-releases-2.0.19.tgz",
+      "integrity": "sha512-xxOWJsBKtzAq7DY0J+DTzuz58K8e7sJbdgwkbMWQe8UYB6ekmsQ45q0M/tJDsGaZmbC+l7n57UV8Hl5tHxO9uw==",
       "dev": true,
       "license": "MIT"
     },
-    "node_modules/fastq": {
-      "version": "1.19.1",
-      "resolved": "https://registry.npmjs.org/fastq/-/fastq-1.19.1.tgz",
-      "integrity": "sha512-GwLTyxkCXjXbxqIhTsMI2Nui8huMPtnxg7krajPJAjnEG/iiOS7i+zCtWGZR9G0NBKbXKh6X9m9UIsYX/N6vvQ==",
-      "dev": true,
+    "node_modules/normalize-svg-path": {
+      "version": "0.1.0",
+      "resolved": "https://registry.npmjs.org/normalize-svg-path/-/normalize-svg-path-0.1.0.tgz",
+      "integrity": "sha512-1/kmYej2iedi5+ROxkRESL/pI02pkg0OBnaR4hJkSIX6+ORzepwbuUXfrdZaPjysTsJInj0Rj5NuX027+dMBvA==",
+      "license": "MIT",
+      "peer": true
+    },
+    "node_modules/number-is-integer": {
+      "version": "1.0.1",
+      "resolved": "https://registry.npmjs.org/number-is-integer/-/number-is-integer-1.0.1.tgz",
+      "integrity": "sha512-Dq3iuiFBkrbmuQjGFFF3zckXNCQoSD37/SdSbgcBailUx6knDvDwb5CympBgcoWHy36sfS12u74MHYkXyHq6bg==",
+      "license": "MIT",
+      "peer": true,
+      "dependencies": {
+        "is-finite": "^1.0.1"
+      },
+      "engines": {
+        "node": ">=0.10.0"
+      }
+    },
+    "node_modules/object-assign": {
+      "version": "4.1.1",
+      "resolved": "https://registry.npmjs.org/object-assign/-/object-assign-4.1.1.tgz",
+      "integrity": "sha512-rJgTQnkUnH1sFw8yT6VSU3zD3sWmu6sZhIseY8VX+GRu3P6F7Fu+JNDoXfklElbLJSnc3FUQHVe4cU5hj+BcUg==",
+      "license": "MIT",
+      "engines": {
+        "node": ">=0.10.0"
+      }
+    },
+    "node_modules/once": {
+      "version": "1.4.0",
+      "resolved": "https://registry.npmjs.org/once/-/once-1.4.0.tgz",
+      "integrity": "sha512-lNaJgI+2Q5URQBkccEKHTQOPaXdUxnZZElQTZY0MFUAuaEqe1E+Nyvgdz/aIyNi6Z9MzO5dv1H8n58/GELp3+w==",
       "license": "ISC",
       "dependencies": {
-        "reusify": "^1.0.4"
+        "wrappy": "1"
       }
     },
-    "node_modules/file-entry-cache": {
-      "version": "6.0.1",
-      "resolved": "https://registry.npmjs.org/file-entry-cache/-/file-entry-cache-6.0.1.tgz",
-      "integrity": "sha512-7Gps/XWymbLk2QLYK4NzpMOrYjMhdIxXuIvy2QBsLE6ljuodKvdkWs/cpyJJ3CVIVpH0Oi1Hvg1ovbMzLdFBBg==",
+    "node_modules/optionator": {
+      "version": "0.9.4",
+      "resolved": "https://registry.npmjs.org/optionator/-/optionator-0.9.4.tgz",
+      "integrity": "sha512-6IpQ7mKUxRcZNLIObR0hz7lxsapSSIYNZJwXPGeF0mTVqGKFIXj1DQcMoT22S3ROcLyY/rz0PWaWZ9ayWmad9g==",
       "dev": true,
       "license": "MIT",
       "dependencies": {
-        "flat-cache": "^3.0.4"
+        "deep-is": "^0.1.3",
+        "fast-levenshtein": "^2.0.6",
+        "levn": "^0.4.1",
+        "prelude-ls": "^1.2.1",
+        "type-check": "^0.4.0",
+        "word-wrap": "^1.2.5"
       },
       "engines": {
-        "node": "^10.12.0 || >=12.0.0"
+        "node": ">= 0.8.0"
       }
     },
-    "node_modules/fill-range": {
-      "version": "7.1.1",
-      "resolved": "https://registry.npmjs.org/fill-range/-/fill-range-7.1.1.tgz",
-      "integrity": "sha512-YsGpe3WHLK8ZYi4tWDg2Jy3ebRz2rXowDxnld4bkQB00cc/1Zw9AWnC0i9ztDJitivtQvaI9KaLyKrc+hBW0yg==",
+    "node_modules/p-limit": {
+      "version": "3.1.0",
+      "resolved": "https://registry.npmjs.org/p-limit/-/p-limit-3.1.0.tgz",
+      "integrity": "sha512-TYOanM3wGwNGsZN2cVTYPArw454xnXj5qmWF1bEoAc4+cU/ol7GVh7odevjp1FNHduHc3KZMcFduxU5Xc6uJRQ==",
       "dev": true,
       "license": "MIT",
       "dependencies": {
-        "to-regex-range": "^5.0.1"
+        "yocto-queue": "^0.1.0"
       },
       "engines": {
-        "node": ">=8"
+        "node": ">=10"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/sindresorhus"
       }
     },
-    "node_modules/find-up": {
+    "node_modules/p-locate": {
       "version": "5.0.0",
-      "resolved": "https://registry.npmjs.org/find-up/-/find-up-5.0.0.tgz",
-      "integrity": "sha512-78/PXT1wlLLDgTzDs7sjq9hzz0vXD+zn+7wypEe4fXQxCmdmqfGsEPQxmiCSQI3ajFV91bVSsvNtrJRiW6nGng==",
+      "resolved": "https://registry.npmjs.org/p-locate/-/p-locate-5.0.0.tgz",
+      "integrity": "sha512-LaNjtRWUBY++zB5nE/NwcaoMylSPk+S+ZHNB1TzdbMJMny6dynpAGt7X/tl/QYq3TIeE6nxHppbo2LGymrG5Pw==",
       "dev": true,
       "license": "MIT",
       "dependencies": {
-        "locate-path": "^6.0.0",
-        "path-exists": "^4.0.0"
+        "p-limit": "^3.0.2"
       },
       "engines": {
         "node": ">=10"
@@ -2326,969 +6425,1624 @@
         "url": "https://github.com/sponsors/sindresorhus"
       }
     },
-    "node_modules/flat-cache": {
-      "version": "3.2.0",
-      "resolved": "https://registry.npmjs.org/flat-cache/-/flat-cache-3.2.0.tgz",
-      "integrity": "sha512-CYcENa+FtcUKLmhhqyctpclsq7QF38pKjZHsGNiSQF5r4FtoKDWabFDl3hzaEQMvT1LHEysw5twgLvpYYb4vbw==",
+    "node_modules/parent-module": {
+      "version": "1.0.1",
+      "resolved": "https://registry.npmjs.org/parent-module/-/parent-module-1.0.1.tgz",
+      "integrity": "sha512-GQ2EWRpQV8/o+Aw8YqtfZZPfNRWZYkbidE9k5rpl/hC3vtHHBfGm2Ifi6qWV+coDGkrUKZAxE3Lot5kcsRlh+g==",
       "dev": true,
       "license": "MIT",
       "dependencies": {
-        "flatted": "^3.2.9",
-        "keyv": "^4.5.3",
-        "rimraf": "^3.0.2"
+        "callsites": "^3.0.0"
       },
       "engines": {
-        "node": "^10.12.0 || >=12.0.0"
+        "node": ">=6"
       }
     },
-    "node_modules/flatted": {
-      "version": "3.3.3",
-      "resolved": "https://registry.npmjs.org/flatted/-/flatted-3.3.3.tgz",
-      "integrity": "sha512-GX+ysw4PBCz0PzosHDepZGANEuFCMLrnRTiEy9McGjmkCQYwRq4A/X786G/fjM/+OjsWSU1ZrY5qyARZmO/uwg==",
+    "node_modules/parenthesis": {
+      "version": "3.1.8",
+      "resolved": "https://registry.npmjs.org/parenthesis/-/parenthesis-3.1.8.tgz",
+      "integrity": "sha512-KF/U8tk54BgQewkJPvB4s/US3VQY68BRDpH638+7O/n58TpnwiwnOtGIOsT2/i+M78s61BBpeC83STB88d8sqw==",
+      "license": "MIT",
+      "peer": true
+    },
+    "node_modules/parse-rect": {
+      "version": "1.2.0",
+      "resolved": "https://registry.npmjs.org/parse-rect/-/parse-rect-1.2.0.tgz",
+      "integrity": "sha512-4QZ6KYbnE6RTwg9E0HpLchUM9EZt6DnDxajFZZDSV4p/12ZJEvPO702DZpGvRYEPo00yKDys7jASi+/w7aO8LA==",
+      "license": "MIT",
+      "peer": true,
+      "dependencies": {
+        "pick-by-alias": "^1.2.0"
+      }
+    },
+    "node_modules/parse-svg-path": {
+      "version": "0.1.2",
+      "resolved": "https://registry.npmjs.org/parse-svg-path/-/parse-svg-path-0.1.2.tgz",
+      "integrity": "sha512-JyPSBnkTJ0AI8GGJLfMXvKq42cj5c006fnLz6fXy6zfoVjJizi8BNTpu8on8ziI1cKy9d9DGNuY17Ce7wuejpQ==",
+      "license": "MIT",
+      "peer": true
+    },
+    "node_modules/parse-unit": {
+      "version": "1.0.1",
+      "resolved": "https://registry.npmjs.org/parse-unit/-/parse-unit-1.0.1.tgz",
+      "integrity": "sha512-hrqldJHokR3Qj88EIlV/kAyAi/G5R2+R56TBANxNMy0uPlYcttx0jnMW6Yx5KsKPSbC3KddM/7qQm3+0wEXKxg==",
+      "license": "MIT",
+      "peer": true
+    },
+    "node_modules/parse5": {
+      "version": "8.0.0",
+      "resolved": "https://registry.npmjs.org/parse5/-/parse5-8.0.0.tgz",
+      "integrity": "sha512-9m4m5GSgXjL4AjumKzq1Fgfp3Z8rsvjRNbnkVwfu2ImRqE5D0LnY2QfDen18FSY9C573YU5XxSapdHZTZ2WolA==",
       "dev": true,
-      "license": "ISC"
+      "license": "MIT",
+      "dependencies": {
+        "entities": "^6.0.0"
+      },
+      "funding": {
+        "url": "https://github.com/inikulin/parse5?sponsor=1"
+      }
     },
-    "node_modules/fs.realpath": {
-      "version": "1.0.0",
-      "resolved": "https://registry.npmjs.org/fs.realpath/-/fs.realpath-1.0.0.tgz",
-      "integrity": "sha512-OO0pH2lK6a0hZnAdau5ItzHPI6pUlvI7jMVnxUQRtw4owF2wk8lOSabtGDCTP4Ggrg2MbGnWO9X8K1t4+fGMDw==",
+    "node_modules/path-exists": {
+      "version": "4.0.0",
+      "resolved": "https://registry.npmjs.org/path-exists/-/path-exists-4.0.0.tgz",
+      "integrity": "sha512-ak9Qy5Q7jYb2Wwcey5Fpvg2KoAc/ZIhLSLOSBmRmygPsGwkVVt0fZa0qrtMz+m6tJTAHfZQ8FnmB4MG4LWy7/w==",
       "dev": true,
-      "license": "ISC"
+      "license": "MIT",
+      "engines": {
+        "node": ">=8"
+      }
     },
-    "node_modules/fsevents": {
-      "version": "2.3.3",
-      "resolved": "https://registry.npmjs.org/fsevents/-/fsevents-2.3.3.tgz",
-      "integrity": "sha512-5xoDfX+fL7faATnagmWPpbFtwh/R77WmMMqqHGS65C3vvB0YHrgF+B1YmZ3441tMj5n63k0212XNoJwzlhffQw==",
+    "node_modules/path-is-absolute": {
+      "version": "1.0.1",
+      "resolved": "https://registry.npmjs.org/path-is-absolute/-/path-is-absolute-1.0.1.tgz",
+      "integrity": "sha512-AVbw3UJ2e9bq64vSaS9Am0fje1Pa8pbGqTTsmXfaIiMpnr5DlDhfJOuLj9Sf95ZPVDAUerDfEk88MPmPe7UCQg==",
       "dev": true,
-      "hasInstallScript": true,
       "license": "MIT",
-      "optional": true,
-      "os": [
-        "darwin"
-      ],
       "engines": {
-        "node": "^8.16.0 || ^10.6.0 || >=11.0.0"
+        "node": ">=0.10.0"
       }
     },
-    "node_modules/gensync": {
-      "version": "1.0.0-beta.2",
-      "resolved": "https://registry.npmjs.org/gensync/-/gensync-1.0.0-beta.2.tgz",
-      "integrity": "sha512-3hN7NaskYvMDLQY55gnW3NQ+mesEAepTqlg+VEbj7zzqEMBVNhzcGYYeqFo/TlYz6eQiFcp1HcsCZO+nGgS8zg==",
+    "node_modules/path-key": {
+      "version": "3.1.1",
+      "resolved": "https://registry.npmjs.org/path-key/-/path-key-3.1.1.tgz",
+      "integrity": "sha512-ojmeN0qd+y0jszEtoY48r0Peq5dwMEkIlCOu6Q5f41lfkswXuKtYrhgoTpLnyIcHm24Uhqx+5Tqm2InSwLhE6Q==",
       "dev": true,
       "license": "MIT",
       "engines": {
-        "node": ">=6.9.0"
+        "node": ">=8"
       }
     },
-    "node_modules/glob": {
-      "version": "7.2.3",
-      "resolved": "https://registry.npmjs.org/glob/-/glob-7.2.3.tgz",
-      "integrity": "sha512-nFR0zLpU2YCaRxwoCJvL6UvCH2JFyFVIvwTLsIf21AuHlMskA1hhTdk+LlYJtOlYt9v6dvszD2BGRqBL+iQK9Q==",
-      "deprecated": "Glob versions prior to v9 are no longer supported",
+    "node_modules/path-parse": {
+      "version": "1.0.7",
+      "resolved": "https://registry.npmjs.org/path-parse/-/path-parse-1.0.7.tgz",
+      "integrity": "sha512-LDJzPVEEEPR+y48z93A0Ed0yXb8pAByGWo/k5YYdYgpY2/2EsOsksJrq7lOHxryrVOn1ejG6oAp8ahvOIQD8sw==",
+      "license": "MIT",
+      "peer": true
+    },
+    "node_modules/path-type": {
+      "version": "4.0.0",
+      "resolved": "https://registry.npmjs.org/path-type/-/path-type-4.0.0.tgz",
+      "integrity": "sha512-gDKb8aZMDeD/tZWs9P6+q0J9Mwkdl6xMV8TjnGP3qJVJ06bdMgkbBlLU8IdfOsIsFz2BW1rNVT3XuNEl8zPAvw==",
       "dev": true,
-      "license": "ISC",
+      "license": "MIT",
+      "engines": {
+        "node": ">=8"
+      }
+    },
+    "node_modules/pathe": {
+      "version": "2.0.3",
+      "resolved": "https://registry.npmjs.org/pathe/-/pathe-2.0.3.tgz",
+      "integrity": "sha512-WUjGcAqP1gQacoQe+OBJsFA7Ld4DyXuUIjZ5cc75cLHvJ7dtNsTugphxIADwspS+AraAUePCKrSVtPLFj/F88w==",
+      "dev": true,
+      "license": "MIT"
+    },
+    "node_modules/pathval": {
+      "version": "2.0.1",
+      "resolved": "https://registry.npmjs.org/pathval/-/pathval-2.0.1.tgz",
+      "integrity": "sha512-//nshmD55c46FuFw26xV/xFAaB5HF9Xdap7HJBBnrKdAd6/GxDBaNA1870O79+9ueg61cZLSVc+OaFlfmObYVQ==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">= 14.16"
+      }
+    },
+    "node_modules/pbf": {
+      "version": "4.0.1",
+      "resolved": "https://registry.npmjs.org/pbf/-/pbf-4.0.1.tgz",
+      "integrity": "sha512-SuLdBvS42z33m8ejRbInMapQe8n0D3vN/Xd5fmWM3tufNgRQFBpaW2YVJxQZV4iPNqb0vEFvssMEo5w9c6BTIA==",
+      "license": "BSD-3-Clause",
       "dependencies": {
-        "fs.realpath": "^1.0.0",
-        "inflight": "^1.0.4",
-        "inherits": "2",
-        "minimatch": "^3.1.1",
-        "once": "^1.3.0",
-        "path-is-absolute": "^1.0.0"
+        "resolve-protobuf-schema": "^2.1.0"
       },
+      "bin": {
+        "pbf": "bin/pbf"
+      }
+    },
+    "node_modules/performance-now": {
+      "version": "2.1.0",
+      "resolved": "https://registry.npmjs.org/performance-now/-/performance-now-2.1.0.tgz",
+      "integrity": "sha512-7EAHlyLHI56VEIdK57uwHdHKIaAGbnXPiw0yWbarQZOKaKpvUIgW0jWRVLiatnM+XXlSwsanIBH/hzGMJulMow==",
+      "license": "MIT",
+      "peer": true
+    },
+    "node_modules/pick-by-alias": {
+      "version": "1.2.0",
+      "resolved": "https://registry.npmjs.org/pick-by-alias/-/pick-by-alias-1.2.0.tgz",
+      "integrity": "sha512-ESj2+eBxhGrcA1azgHs7lARG5+5iLakc/6nlfbpjcLl00HuuUOIuORhYXN4D1HfvMSKuVtFQjAlnwi1JHEeDIw==",
+      "license": "MIT",
+      "peer": true
+    },
+    "node_modules/picocolors": {
+      "version": "1.1.1",
+      "resolved": "https://registry.npmjs.org/picocolors/-/picocolors-1.1.1.tgz",
+      "integrity": "sha512-xceH2snhtb5M9liqDsmEw56le376mTZkEX/jEb/RxNFyegNul7eNslCXP9FDj/Lcu0X8KEyMceP2ntpaHrDEVA==",
+      "dev": true,
+      "license": "ISC"
+    },
+    "node_modules/picomatch": {
+      "version": "2.3.1",
+      "resolved": "https://registry.npmjs.org/picomatch/-/picomatch-2.3.1.tgz",
+      "integrity": "sha512-JU3teHTNjmE2VCGFzuY8EXzCDVwEqB2a8fsIvwaStHhAWJEeVd1o1QD80CU6+ZdEXXSLbSsuLwJjkCBWqRQUVA==",
+      "dev": true,
+      "license": "MIT",
       "engines": {
-        "node": "*"
+        "node": ">=8.6"
       },
       "funding": {
-        "url": "https://github.com/sponsors/isaacs"
+        "url": "https://github.com/sponsors/jonschlinkert"
       }
     },
-    "node_modules/glob-parent": {
-      "version": "6.0.2",
-      "resolved": "https://registry.npmjs.org/glob-parent/-/glob-parent-6.0.2.tgz",
-      "integrity": "sha512-XxwI8EOhVQgWp6iDL+3b0r86f4d6AX6zSU55HfB4ydCEuXLXc5FcYeOu+nnGftS4TEju/11rt4KJPTMgbfmv4A==",
-      "dev": true,
+    "node_modules/plotly.js": {
+      "version": "3.4.0",
+      "resolved": "https://registry.npmjs.org/plotly.js/-/plotly.js-3.4.0.tgz",
+      "integrity": "sha512-jdWfHLB8AxlGUmVhqJTGEKdwjCKGn9Yi8yg16067/JyqseuSado7F6IOM1XPZspdZyO/cf8IPuy7ROlVhqZZNw==",
+      "license": "MIT",
+      "peer": true,
+      "dependencies": {
+        "@plotly/d3": "3.8.2",
+        "@plotly/d3-sankey": "0.7.2",
+        "@plotly/d3-sankey-circular": "0.33.1",
+        "@plotly/mapbox-gl": "1.13.4",
+        "@plotly/regl": "^2.1.2",
+        "@turf/area": "^7.1.0",
+        "@turf/bbox": "^7.1.0",
+        "@turf/centroid": "^7.1.0",
+        "base64-arraybuffer": "^1.0.2",
+        "canvas-fit": "^1.5.0",
+        "color-alpha": "1.0.4",
+        "color-normalize": "1.5.0",
+        "color-parse": "2.0.0",
+        "color-rgba": "3.0.0",
+        "country-regex": "^1.1.0",
+        "d3-force": "^1.2.1",
+        "d3-format": "^1.4.5",
+        "d3-geo": "^1.12.1",
+        "d3-geo-projection": "^2.9.0",
+        "d3-hierarchy": "^1.1.9",
+        "d3-interpolate": "^3.0.1",
+        "d3-time": "^1.1.0",
+        "d3-time-format": "^2.2.3",
+        "fast-isnumeric": "^1.1.4",
+        "gl-mat4": "^1.2.0",
+        "gl-text": "^1.4.0",
+        "has-hover": "^1.0.1",
+        "has-passive-events": "^1.0.0",
+        "is-mobile": "^4.0.0",
+        "maplibre-gl": "^4.7.1",
+        "mouse-change": "^1.4.0",
+        "mouse-event-offset": "^3.0.2",
+        "mouse-wheel": "^1.2.0",
+        "native-promise-only": "^0.8.1",
+        "parse-svg-path": "^0.1.2",
+        "point-in-polygon": "^1.1.0",
+        "polybooljs": "^1.2.2",
+        "probe-image-size": "^7.2.3",
+        "regl-error2d": "^2.0.12",
+        "regl-line2d": "^3.1.3",
+        "regl-scatter2d": "^3.3.1",
+        "regl-splom": "^1.0.14",
+        "strongly-connected-components": "^1.0.1",
+        "superscript-text": "^1.0.0",
+        "svg-path-sdf": "^1.1.3",
+        "tinycolor2": "^1.4.2",
+        "to-px": "1.0.1",
+        "topojson-client": "^3.1.0",
+        "webgl-context": "^2.2.0",
+        "world-calendars": "^1.0.4"
+      },
+      "engines": {
+        "node": ">=18.0.0"
+      }
+    },
+    "node_modules/plotly.js-dist-min": {
+      "version": "3.4.0",
+      "resolved": "https://registry.npmjs.org/plotly.js-dist-min/-/plotly.js-dist-min-3.4.0.tgz",
+      "integrity": "sha512-eo7xh7oyE9fFoE/wintgmvfOjvTKwCb3wRf9ShQv90du4n+EVkOY7w5qEkmUS9SSkHRnAw8sk/0QI7wEc5U+8Q==",
+      "license": "MIT"
+    },
+    "node_modules/plotly.js/node_modules/@mapbox/point-geometry": {
+      "version": "0.1.0",
+      "resolved": "https://registry.npmjs.org/@mapbox/point-geometry/-/point-geometry-0.1.0.tgz",
+      "integrity": "sha512-6j56HdLTwWGO0fJPlrZtdU/B13q8Uwmo18Ck2GnGgN9PCFyKTZ3UbXeEdRFh18i9XQ92eH2VdtpJHpBD3aripQ==",
       "license": "ISC",
+      "peer": true
+    },
+    "node_modules/plotly.js/node_modules/@mapbox/vector-tile": {
+      "version": "1.3.1",
+      "resolved": "https://registry.npmjs.org/@mapbox/vector-tile/-/vector-tile-1.3.1.tgz",
+      "integrity": "sha512-MCEddb8u44/xfQ3oD+Srl/tNcQoqTw3goGk2oLsrFxOTc3dUp+kAnby3PvAeeBYSMSjSPD1nd1AJA6W49WnoUw==",
+      "license": "BSD-3-Clause",
+      "peer": true,
       "dependencies": {
-        "is-glob": "^4.0.3"
+        "@mapbox/point-geometry": "~0.1.0"
+      }
+    },
+    "node_modules/plotly.js/node_modules/@maplibre/maplibre-gl-style-spec": {
+      "version": "20.4.0",
+      "resolved": "https://registry.npmjs.org/@maplibre/maplibre-gl-style-spec/-/maplibre-gl-style-spec-20.4.0.tgz",
+      "integrity": "sha512-AzBy3095fTFPjDjmWpR2w6HVRAZJ6hQZUCwk5Plz6EyfnfuQW1odeW5i2Ai47Y6TBA2hQnC+azscjBSALpaWgw==",
+      "license": "ISC",
+      "peer": true,
+      "dependencies": {
+        "@mapbox/jsonlint-lines-primitives": "~2.0.2",
+        "@mapbox/unitbezier": "^0.0.1",
+        "json-stringify-pretty-compact": "^4.0.0",
+        "minimist": "^1.2.8",
+        "quickselect": "^2.0.0",
+        "rw": "^1.3.3",
+        "tinyqueue": "^3.0.0"
       },
-      "engines": {
-        "node": ">=10.13.0"
+      "bin": {
+        "gl-style-format": "dist/gl-style-format.mjs",
+        "gl-style-migrate": "dist/gl-style-migrate.mjs",
+        "gl-style-validate": "dist/gl-style-validate.mjs"
       }
     },
-    "node_modules/glob/node_modules/brace-expansion": {
-      "version": "1.1.11",
-      "resolved": "https://registry.npmjs.org/brace-expansion/-/brace-expansion-1.1.11.tgz",
-      "integrity": "sha512-iCuPHDFgrHX7H2vEI/5xpz07zSHB00TpugqhmYtVmMO6518mCuRMoOYFldEBl0g187ufozdaHgWKcYFb61qGiA==",
+    "node_modules/plotly.js/node_modules/@maplibre/maplibre-gl-style-spec/node_modules/quickselect": {
+      "version": "2.0.0",
+      "resolved": "https://registry.npmjs.org/quickselect/-/quickselect-2.0.0.tgz",
+      "integrity": "sha512-RKJ22hX8mHe3Y6wH/N3wCM6BWtjaxIyyUIkpHOvfFnxdI4yD4tBXEBKSbriGujF6jnSVkJrffuo6vxACiSSxIw==",
+      "license": "ISC",
+      "peer": true
+    },
+    "node_modules/plotly.js/node_modules/earcut": {
+      "version": "3.0.2",
+      "resolved": "https://registry.npmjs.org/earcut/-/earcut-3.0.2.tgz",
+      "integrity": "sha512-X7hshQbLyMJ/3RPhyObLARM2sNxxmRALLKx1+NVFFnQ9gKzmCrxm9+uLIAdBcvc8FNLpctqlQ2V6AE92Ol9UDQ==",
+      "license": "ISC",
+      "peer": true
+    },
+    "node_modules/plotly.js/node_modules/geojson-vt": {
+      "version": "4.0.2",
+      "resolved": "https://registry.npmjs.org/geojson-vt/-/geojson-vt-4.0.2.tgz",
+      "integrity": "sha512-AV9ROqlNqoZEIJGfm1ncNjEXfkz2hdFlZf0qkVfmkwdKa8vj7H16YUOT81rJw1rdFhyEDlN2Tds91p/glzbl5A==",
+      "license": "ISC",
+      "peer": true
+    },
+    "node_modules/plotly.js/node_modules/maplibre-gl": {
+      "version": "4.7.1",
+      "resolved": "https://registry.npmjs.org/maplibre-gl/-/maplibre-gl-4.7.1.tgz",
+      "integrity": "sha512-lgL7XpIwsgICiL82ITplfS7IGwrB1OJIw/pCvprDp2dhmSSEBgmPzYRvwYYYvJGJD7fxUv1Tvpih4nZ6VrLuaA==",
+      "license": "BSD-3-Clause",
+      "peer": true,
+      "dependencies": {
+        "@mapbox/geojson-rewind": "^0.5.2",
+        "@mapbox/jsonlint-lines-primitives": "^2.0.2",
+        "@mapbox/point-geometry": "^0.1.0",
+        "@mapbox/tiny-sdf": "^2.0.6",
+        "@mapbox/unitbezier": "^0.0.1",
+        "@mapbox/vector-tile": "^1.3.1",
+        "@mapbox/whoots-js": "^3.1.0",
+        "@maplibre/maplibre-gl-style-spec": "^20.3.1",
+        "@types/geojson": "^7946.0.14",
+        "@types/geojson-vt": "3.2.5",
+        "@types/mapbox__point-geometry": "^0.1.4",
+        "@types/mapbox__vector-tile": "^1.3.4",
+        "@types/pbf": "^3.0.5",
+        "@types/supercluster": "^7.1.3",
+        "earcut": "^3.0.0",
+        "geojson-vt": "^4.0.2",
+        "gl-matrix": "^3.4.3",
+        "global-prefix": "^4.0.0",
+        "kdbush": "^4.0.2",
+        "murmurhash-js": "^1.0.0",
+        "pbf": "^3.3.0",
+        "potpack": "^2.0.0",
+        "quickselect": "^3.0.0",
+        "supercluster": "^8.0.1",
+        "tinyqueue": "^3.0.0",
+        "vt-pbf": "^3.1.3"
+      },
+      "engines": {
+        "node": ">=16.14.0",
+        "npm": ">=8.1.0"
+      },
+      "funding": {
+        "url": "https://github.com/maplibre/maplibre-gl-js?sponsor=1"
+      }
+    },
+    "node_modules/plotly.js/node_modules/pbf": {
+      "version": "3.3.0",
+      "resolved": "https://registry.npmjs.org/pbf/-/pbf-3.3.0.tgz",
+      "integrity": "sha512-XDF38WCH3z5OV/OVa8GKUNtLAyneuzbCisx7QUCF8Q6Nutx0WnJrQe5O+kOtBlLfRNUws98Y58Lblp+NJG5T4Q==",
+      "license": "BSD-3-Clause",
+      "peer": true,
+      "dependencies": {
+        "ieee754": "^1.1.12",
+        "resolve-protobuf-schema": "^2.1.0"
+      },
+      "bin": {
+        "pbf": "bin/pbf"
+      }
+    },
+    "node_modules/point-in-polygon": {
+      "version": "1.1.0",
+      "resolved": "https://registry.npmjs.org/point-in-polygon/-/point-in-polygon-1.1.0.tgz",
+      "integrity": "sha512-3ojrFwjnnw8Q9242TzgXuTD+eKiutbzyslcq1ydfu82Db2y+Ogbmyrkpv0Hgj31qwT3lbS9+QAAO/pIQM35XRw==",
+      "license": "MIT",
+      "peer": true
+    },
+    "node_modules/polybooljs": {
+      "version": "1.2.2",
+      "resolved": "https://registry.npmjs.org/polybooljs/-/polybooljs-1.2.2.tgz",
+      "integrity": "sha512-ziHW/02J0XuNuUtmidBc6GXE8YohYydp3DWPWXYsd7O721TjcmN+k6ezjdwkDqep+gnWnFY+yqZHvzElra2oCg==",
+      "license": "MIT",
+      "peer": true
+    },
+    "node_modules/postcss": {
+      "version": "8.5.4",
+      "resolved": "https://registry.npmjs.org/postcss/-/postcss-8.5.4.tgz",
+      "integrity": "sha512-QSa9EBe+uwlGTFmHsPKokv3B/oEMQZxfqW0QqNCyhpa6mB1afzulwn8hihglqAb2pOw+BJgNlmXQ8la2VeHB7w==",
       "dev": true,
+      "funding": [
+        {
+          "type": "opencollective",
+          "url": "https://opencollective.com/postcss/"
+        },
+        {
+          "type": "tidelift",
+          "url": "https://tidelift.com/funding/github/npm/postcss"
+        },
+        {
+          "type": "github",
+          "url": "https://github.com/sponsors/ai"
+        }
+      ],
       "license": "MIT",
       "dependencies": {
-        "balanced-match": "^1.0.0",
-        "concat-map": "0.0.1"
-      }
-    },
-    "node_modules/glob/node_modules/minimatch": {
-      "version": "3.1.2",
-      "resolved": "https://registry.npmjs.org/minimatch/-/minimatch-3.1.2.tgz",
-      "integrity": "sha512-J7p63hRiAjw1NDEww1W7i37+ByIrOWO5XQQAzZ3VOcL0PNybwpfmV/N05zFAzwQ9USyEcX6t3UO+K5aqBQOIHw==",
-      "dev": true,
-      "license": "ISC",
-      "dependencies": {
-        "brace-expansion": "^1.1.7"
+        "nanoid": "^3.3.11",
+        "picocolors": "^1.1.1",
+        "source-map-js": "^1.2.1"
       },
       "engines": {
-        "node": "*"
+        "node": "^10 || ^12 || >=14"
       }
     },
-    "node_modules/globals": {
-      "version": "11.12.0",
-      "resolved": "https://registry.npmjs.org/globals/-/globals-11.12.0.tgz",
-      "integrity": "sha512-WOBp/EEGUiIsJSp7wcv/y6MO+lV9UoncWqxuFfm8eBwzWNgyfBd6Gz+IeKQ9jCmyhoH99g15M3T+QaVHFjizVA==",
+    "node_modules/potpack": {
+      "version": "2.1.0",
+      "resolved": "https://registry.npmjs.org/potpack/-/potpack-2.1.0.tgz",
+      "integrity": "sha512-pcaShQc1Shq0y+E7GqJqvZj8DTthWV1KeHGdi0Z6IAin2Oi3JnLCOfwnCo84qc+HAp52wT9nK9H7FAJp5a44GQ==",
+      "license": "ISC"
+    },
+    "node_modules/prelude-ls": {
+      "version": "1.2.1",
+      "resolved": "https://registry.npmjs.org/prelude-ls/-/prelude-ls-1.2.1.tgz",
+      "integrity": "sha512-vkcDPrRZo1QZLbn5RLGPpg/WmIQ65qoWWhcGKf/b5eplkkarX0m9z8ppCat4mlOqUsWpyNuYgO3VRyrYHSzX5g==",
       "dev": true,
       "license": "MIT",
       "engines": {
-        "node": ">=4"
+        "node": ">= 0.8.0"
       }
     },
-    "node_modules/globby": {
-      "version": "11.1.0",
-      "resolved": "https://registry.npmjs.org/globby/-/globby-11.1.0.tgz",
-      "integrity": "sha512-jhIXaOzy1sb8IyocaruWSn1TjmnBVs8Ayhcy83rmxNJ8q2uWKCAj3CnJY+KpGSXCueAPc0i05kVvVKtP1t9S3g==",
+    "node_modules/pretty-format": {
+      "version": "27.5.1",
+      "resolved": "https://registry.npmjs.org/pretty-format/-/pretty-format-27.5.1.tgz",
+      "integrity": "sha512-Qb1gy5OrP5+zDf2Bvnzdl3jsTf1qXVMazbvCoKhtKqVs4/YK4ozX4gKQJJVyNe+cajNPn0KoC0MC3FUmaHWEmQ==",
       "dev": true,
       "license": "MIT",
+      "peer": true,
       "dependencies": {
-        "array-union": "^2.1.0",
-        "dir-glob": "^3.0.1",
-        "fast-glob": "^3.2.9",
-        "ignore": "^5.2.0",
-        "merge2": "^1.4.1",
-        "slash": "^3.0.0"
+        "ansi-regex": "^5.0.1",
+        "ansi-styles": "^5.0.0",
+        "react-is": "^17.0.1"
       },
+      "engines": {
+        "node": "^10.13.0 || ^12.13.0 || ^14.15.0 || >=15.0.0"
+      }
+    },
+    "node_modules/pretty-format/node_modules/ansi-styles": {
+      "version": "5.2.0",
+      "resolved": "https://registry.npmjs.org/ansi-styles/-/ansi-styles-5.2.0.tgz",
+      "integrity": "sha512-Cxwpt2SfTzTtXcfOlzGEee8O+c+MmUgGrNiBcXnuWxuFJHe6a5Hz7qwhwe5OgaSYI0IJvkLqWX1ASG+cJOkEiA==",
+      "dev": true,
+      "license": "MIT",
+      "peer": true,
       "engines": {
         "node": ">=10"
       },
       "funding": {
-        "url": "https://github.com/sponsors/sindresorhus"
+        "url": "https://github.com/chalk/ansi-styles?sponsor=1"
       }
     },
-    "node_modules/graphemer": {
-      "version": "1.4.0",
-      "resolved": "https://registry.npmjs.org/graphemer/-/graphemer-1.4.0.tgz",
-      "integrity": "sha512-EtKwoO6kxCL9WO5xipiHTZlSzBm7WLT627TqC/uVRd0HKmq8NXyebnNYxDoBi7wt8eTWrUrKXCOVaFq9x1kgag==",
-      "dev": true,
+    "node_modules/probe-image-size": {
+      "version": "7.2.3",
+      "resolved": "https://registry.npmjs.org/probe-image-size/-/probe-image-size-7.2.3.tgz",
+      "integrity": "sha512-HubhG4Rb2UH8YtV4ba0Vp5bQ7L78RTONYu/ujmCu5nBI8wGv24s4E9xSKBi0N1MowRpxk76pFCpJtW0KPzOK0w==",
+      "license": "MIT",
+      "peer": true,
+      "dependencies": {
+        "lodash.merge": "^4.6.2",
+        "needle": "^2.5.2",
+        "stream-parser": "~0.3.1"
+      }
+    },
+    "node_modules/process-nextick-args": {
+      "version": "2.0.1",
+      "resolved": "https://registry.npmjs.org/process-nextick-args/-/process-nextick-args-2.0.1.tgz",
+      "integrity": "sha512-3ouUOpQhtgrbOa17J7+uxOTpITYWaGP7/AhoR3+A+/1e9skrzelGi/dXzEYyvbxubEF6Wn2ypscTKiKJFFn1ag==",
+      "license": "MIT",
+      "peer": true
+    },
+    "node_modules/prop-types": {
+      "version": "15.8.1",
+      "resolved": "https://registry.npmjs.org/prop-types/-/prop-types-15.8.1.tgz",
+      "integrity": "sha512-oj87CgZICdulUohogVAR7AjlC0327U4el4L6eAvOqCeudMDVU0NThNaV+b9Df4dXgSP1gXMTnPdhfe/2qDH5cg==",
+      "license": "MIT",
+      "dependencies": {
+        "loose-envify": "^1.4.0",
+        "object-assign": "^4.1.1",
+        "react-is": "^16.13.1"
+      }
+    },
+    "node_modules/prop-types/node_modules/react-is": {
+      "version": "16.13.1",
+      "resolved": "https://registry.npmjs.org/react-is/-/react-is-16.13.1.tgz",
+      "integrity": "sha512-24e6ynE2H+OKt4kqsOvNd8kBpV65zoxbA4BVsEOB3ARVWQki/DHzaUoC5KuON/BiccDaCCTZBuOcfZs70kR8bQ==",
       "license": "MIT"
     },
-    "node_modules/has-flag": {
-      "version": "4.0.0",
-      "resolved": "https://registry.npmjs.org/has-flag/-/has-flag-4.0.0.tgz",
-      "integrity": "sha512-EykJT/Q1KjTWctppgIAgfSO0tKVuZUjhgMr17kqTumMl6Afv3EISleU7qZUzoXDFTAHTDC4NOoG/ZxU3EvlMPQ==",
+    "node_modules/protocol-buffers-schema": {
+      "version": "3.6.0",
+      "resolved": "https://registry.npmjs.org/protocol-buffers-schema/-/protocol-buffers-schema-3.6.0.tgz",
+      "integrity": "sha512-TdDRD+/QNdrCGCE7v8340QyuXd4kIWIgapsE2+n/SaGiSSbomYl4TjHlvIoCWRpE7wFt02EpB35VVA2ImcBVqw==",
+      "license": "MIT"
+    },
+    "node_modules/punycode": {
+      "version": "2.3.1",
+      "resolved": "https://registry.npmjs.org/punycode/-/punycode-2.3.1.tgz",
+      "integrity": "sha512-vYt7UD1U9Wg6138shLtLOvdAu+8DsC/ilFtEVHcH+wydcSpNE20AfSOduf6MkRFahL5FY7X1oU7nKVZFtfq8Fg==",
       "dev": true,
       "license": "MIT",
       "engines": {
-        "node": ">=8"
+        "node": ">=6"
       }
     },
-    "node_modules/ignore": {
-      "version": "5.3.2",
-      "resolved": "https://registry.npmjs.org/ignore/-/ignore-5.3.2.tgz",
-      "integrity": "sha512-hsBTNUqQTDwkWtcdYI2i06Y/nUBEsNEDJKjWdigLvegy8kDuJAS8uRlpkkcQpyEXL0Z/pjDy5HBmMjRCJ2gq+g==",
+    "node_modules/queue-microtask": {
+      "version": "1.2.3",
+      "resolved": "https://registry.npmjs.org/queue-microtask/-/queue-microtask-1.2.3.tgz",
+      "integrity": "sha512-NuaNSa6flKT5JaSYQzJok04JzTL1CA6aGhv5rfLW3PgqA+M2ChpZQnAC8h8i4ZFkBS8X5RqkDBHA7r4hej3K9A==",
       "dev": true,
+      "funding": [
+        {
+          "type": "github",
+          "url": "https://github.com/sponsors/feross"
+        },
+        {
+          "type": "patreon",
+          "url": "https://www.patreon.com/feross"
+        },
+        {
+          "type": "consulting",
+          "url": "https://feross.org/support"
+        }
+      ],
+      "license": "MIT"
+    },
+    "node_modules/quickselect": {
+      "version": "3.0.0",
+      "resolved": "https://registry.npmjs.org/quickselect/-/quickselect-3.0.0.tgz",
+      "integrity": "sha512-XdjUArbK4Bm5fLLvlm5KpTFOiOThgfWWI4axAZDWg4E/0mKdZyI9tNEfds27qCi1ze/vwTR16kvmmGhRra3c2g==",
+      "license": "ISC"
+    },
+    "node_modules/raf": {
+      "version": "3.4.1",
+      "resolved": "https://registry.npmjs.org/raf/-/raf-3.4.1.tgz",
+      "integrity": "sha512-Sq4CW4QhwOHE8ucn6J34MqtZCeWFP2aQSmrlroYgqAV1PjStIhJXxYuTgUIfkEk7zTLjmIjLmU5q+fbD1NnOJA==",
       "license": "MIT",
-      "engines": {
-        "node": ">= 4"
+      "peer": true,
+      "dependencies": {
+        "performance-now": "^2.1.0"
       }
     },
-    "node_modules/import-fresh": {
-      "version": "3.3.1",
-      "resolved": "https://registry.npmjs.org/import-fresh/-/import-fresh-3.3.1.tgz",
-      "integrity": "sha512-TR3KfrTZTYLPB6jUjfx6MF9WcWrHL9su5TObK4ZkYgBdWKPOFoSoQIdEuTuR82pmtxH2spWG9h6etwfr1pLBqQ==",
-      "dev": true,
+    "node_modules/react": {
+      "version": "18.3.1",
+      "resolved": "https://registry.npmjs.org/react/-/react-18.3.1.tgz",
+      "integrity": "sha512-wS+hAgJShR0KhEvPJArfuPVN1+Hz1t0Y6n5jLrGQbkb4urgPE/0Rve+1kMB1v/oWgHgm4WIcV+i7F2pTVj+2iQ==",
       "license": "MIT",
       "dependencies": {
-        "parent-module": "^1.0.0",
-        "resolve-from": "^4.0.0"
+        "loose-envify": "^1.1.0"
       },
       "engines": {
-        "node": ">=6"
-      },
-      "funding": {
-        "url": "https://github.com/sponsors/sindresorhus"
+        "node": ">=0.10.0"
       }
     },
-    "node_modules/imurmurhash": {
-      "version": "0.1.4",
-      "resolved": "https://registry.npmjs.org/imurmurhash/-/imurmurhash-0.1.4.tgz",
-      "integrity": "sha512-JmXMZ6wuvDmLiHEml9ykzqO6lwFbof0GG4IkcGaENdCRDDmMVnny7s5HsIgHCbaq0w2MyPhDqkhTUgS2LU2PHA==",
-      "dev": true,
+    "node_modules/react-chartjs-2": {
+      "version": "5.3.0",
+      "resolved": "https://registry.npmjs.org/react-chartjs-2/-/react-chartjs-2-5.3.0.tgz",
+      "integrity": "sha512-UfZZFnDsERI3c3CZGxzvNJd02SHjaSJ8kgW1djn65H1KK8rehwTjyrRKOG3VTMG8wtHZ5rgAO5oTHtHi9GCCmw==",
       "license": "MIT",
-      "engines": {
-        "node": ">=0.8.19"
+      "peerDependencies": {
+        "chart.js": "^4.1.1",
+        "react": "^16.8.0 || ^17.0.0 || ^18.0.0 || ^19.0.0"
       }
     },
-    "node_modules/inflight": {
-      "version": "1.0.6",
-      "resolved": "https://registry.npmjs.org/inflight/-/inflight-1.0.6.tgz",
-      "integrity": "sha512-k92I/b08q4wvFscXCLvqfsHCrjrF7yiXsQuIVvVE7N82W3+aqpzuUdBbfhWcy/FZR3/4IgflMgKLOsvPDrGCJA==",
-      "deprecated": "This module is not supported, and leaks memory. Do not use it. Check out lru-cache if you want a good and tested way to coalesce async requests by a key value, which is much more comprehensive and powerful.",
-      "dev": true,
-      "license": "ISC",
+    "node_modules/react-dom": {
+      "version": "18.3.1",
+      "resolved": "https://registry.npmjs.org/react-dom/-/react-dom-18.3.1.tgz",
+      "integrity": "sha512-5m4nQKp+rZRb09LNH59GM4BxTh9251/ylbKIbpe7TpGxfJ+9kv6BLkLBXIjjspbgbnIBNqlI23tRnTWT0snUIw==",
+      "license": "MIT",
       "dependencies": {
-        "once": "^1.3.0",
-        "wrappy": "1"
+        "loose-envify": "^1.1.0",
+        "scheduler": "^0.23.2"
+      },
+      "peerDependencies": {
+        "react": "^18.3.1"
       }
     },
-    "node_modules/inherits": {
-      "version": "2.0.4",
-      "resolved": "https://registry.npmjs.org/inherits/-/inherits-2.0.4.tgz",
-      "integrity": "sha512-k/vGaX4/Yla3WzyMCvTQOXYeIHvqOKtnqBduzTHpzpQZzAskKMhZ2K+EnBiSM9zGSoIFeMpXKxa4dYeZIQqewQ==",
-      "dev": true,
-      "license": "ISC"
-    },
-    "node_modules/is-extglob": {
-      "version": "2.1.1",
-      "resolved": "https://registry.npmjs.org/is-extglob/-/is-extglob-2.1.1.tgz",
-      "integrity": "sha512-SbKbANkN603Vi4jEZv49LeVJMn4yGwsbzZworEoyEiutsN3nJYdbO36zfhGJ6QEDpOZIFkDtnq5JRxmvl3jsoQ==",
+    "node_modules/react-is": {
+      "version": "17.0.2",
+      "resolved": "https://registry.npmjs.org/react-is/-/react-is-17.0.2.tgz",
+      "integrity": "sha512-w2GsyukL62IJnlaff/nRegPQR94C/XXamvMWmSHRJ4y7Ts/4ocGRmTHvOs8PSE6pB3dWOrD/nueuU5sduBsQ4w==",
       "dev": true,
       "license": "MIT",
-      "engines": {
-        "node": ">=0.10.0"
+      "peer": true
+    },
+    "node_modules/react-leaflet": {
+      "version": "4.2.1",
+      "resolved": "https://registry.npmjs.org/react-leaflet/-/react-leaflet-4.2.1.tgz",
+      "integrity": "sha512-p9chkvhcKrWn/H/1FFeVSqLdReGwn2qmiobOQGO3BifX+/vV/39qhY8dGqbdcPh1e6jxh/QHriLXr7a4eLFK4Q==",
+      "license": "Hippocratic-2.1",
+      "dependencies": {
+        "@react-leaflet/core": "^2.1.0"
+      },
+      "peerDependencies": {
+        "leaflet": "^1.9.0",
+        "react": "^18.0.0",
+        "react-dom": "^18.0.0"
       }
     },
-    "node_modules/is-glob": {
-      "version": "4.0.3",
-      "resolved": "https://registry.npmjs.org/is-glob/-/is-glob-4.0.3.tgz",
-      "integrity": "sha512-xelSayHH36ZgE7ZWhli7pW34hNbNl8Ojv5KVmkJD4hBdD3th8Tfk9vYasLM+mXWOZhFkgZfxhLSnrwRr4elSSg==",
-      "dev": true,
+    "node_modules/react-map-gl": {
+      "version": "8.1.0",
+      "resolved": "https://registry.npmjs.org/react-map-gl/-/react-map-gl-8.1.0.tgz",
+      "integrity": "sha512-vDx/QXR3Tb+8/ap/z6gdMjJQ8ZEyaZf6+uMSPz7jhWF5VZeIsKsGfPvwHVPPwGF43Ryn+YR4bd09uEFNR5OPdg==",
       "license": "MIT",
       "dependencies": {
-        "is-extglob": "^2.1.1"
+        "@vis.gl/react-mapbox": "8.1.0",
+        "@vis.gl/react-maplibre": "8.1.0"
       },
-      "engines": {
-        "node": ">=0.10.0"
+      "peerDependencies": {
+        "mapbox-gl": ">=1.13.0",
+        "maplibre-gl": ">=1.13.0",
+        "react": ">=16.3.0",
+        "react-dom": ">=16.3.0"
+      },
+      "peerDependenciesMeta": {
+        "mapbox-gl": {
+          "optional": true
+        },
+        "maplibre-gl": {
+          "optional": true
+        }
       }
     },
-    "node_modules/is-number": {
-      "version": "7.0.0",
-      "resolved": "https://registry.npmjs.org/is-number/-/is-number-7.0.0.tgz",
-      "integrity": "sha512-41Cifkg6e8TylSpdtTpeLVMqvSBEVzTttHvERD741+pnZ8ANv0004MRL43QKPDlK9cGvNp6NZWZUBlbGXYxxng==",
-      "dev": true,
+    "node_modules/react-plotly.js": {
+      "version": "2.6.0",
+      "resolved": "https://registry.npmjs.org/react-plotly.js/-/react-plotly.js-2.6.0.tgz",
+      "integrity": "sha512-g93xcyhAVCSt9kV1svqG1clAEdL6k3U+jjuSzfTV7owaSU9Go6Ph8bl25J+jKfKvIGAEYpe4qj++WHJuc9IaeA==",
       "license": "MIT",
-      "engines": {
-        "node": ">=0.12.0"
+      "dependencies": {
+        "prop-types": "^15.8.1"
+      },
+      "peerDependencies": {
+        "plotly.js": ">1.34.0",
+        "react": ">0.13.0"
       }
     },
-    "node_modules/is-path-inside": {
-      "version": "3.0.3",
-      "resolved": "https://registry.npmjs.org/is-path-inside/-/is-path-inside-3.0.3.tgz",
-      "integrity": "sha512-Fd4gABb+ycGAmKou8eMftCupSir5lRxqf4aD/vd0cD2qc4HL07OjCeuHMr8Ro4CoMaeCKDB0/ECBOVWjTwUvPQ==",
+    "node_modules/react-refresh": {
+      "version": "0.17.0",
+      "resolved": "https://registry.npmjs.org/react-refresh/-/react-refresh-0.17.0.tgz",
+      "integrity": "sha512-z6F7K9bV85EfseRCp2bzrpyQ0Gkw1uLoCel9XBVWPg/TjRj94SkJzUTGfOa4bs7iJvBWtQG0Wq7wnI0syw3EBQ==",
       "dev": true,
       "license": "MIT",
       "engines": {
-        "node": ">=8"
+        "node": ">=0.10.0"
       }
     },
-    "node_modules/isexe": {
-      "version": "2.0.0",
-      "resolved": "https://registry.npmjs.org/isexe/-/isexe-2.0.0.tgz",
-      "integrity": "sha512-RHxMLp9lnKHGHRng9QFhRCMbYAcVpn69smSGcq3f36xjgVVWThj4qqLbTLlq7Ssj8B+fIQ1EuCEGI2lKsyQeIw==",
-      "dev": true,
-      "license": "ISC"
-    },
-    "node_modules/js-tokens": {
-      "version": "4.0.0",
-      "resolved": "https://registry.npmjs.org/js-tokens/-/js-tokens-4.0.0.tgz",
-      "integrity": "sha512-RdJUflcE3cUzKiMqQgsCu06FPu9UdIJO0beYbPhHN4k6apgJtifcoCtT9bcxOpYBtpD2kCM6Sbzg4CausW/PKQ==",
-      "license": "MIT"
-    },
-    "node_modules/js-yaml": {
-      "version": "4.1.0",
-      "resolved": "https://registry.npmjs.org/js-yaml/-/js-yaml-4.1.0.tgz",
-      "integrity": "sha512-wpxZs9NoxZaJESJGIZTyDEaYpl0FKSA+FB9aJiyemKhMwkxQg63h4T1KJgUGHpTqPDNRcmmYLugrRjJlBtWvRA==",
-      "dev": true,
+    "node_modules/readable-stream": {
+      "version": "2.3.8",
+      "resolved": "https://registry.npmjs.org/readable-stream/-/readable-stream-2.3.8.tgz",
+      "integrity": "sha512-8p0AUk4XODgIewSi0l8Epjs+EVnWiK7NoDIEGU0HhE7+ZyY8D1IMY7odu5lRrFXGg71L15KG8QrPmum45RTtdA==",
       "license": "MIT",
+      "peer": true,
       "dependencies": {
-        "argparse": "^2.0.1"
-      },
-      "bin": {
-        "js-yaml": "bin/js-yaml.js"
+        "core-util-is": "~1.0.0",
+        "inherits": "~2.0.3",
+        "isarray": "~1.0.0",
+        "process-nextick-args": "~2.0.0",
+        "safe-buffer": "~5.1.1",
+        "string_decoder": "~1.1.1",
+        "util-deprecate": "~1.0.1"
       }
     },
-    "node_modules/jsesc": {
-      "version": "3.1.0",
-      "resolved": "https://registry.npmjs.org/jsesc/-/jsesc-3.1.0.tgz",
-      "integrity": "sha512-/sM3dO2FOzXjKQhJuo0Q173wf2KOo8t4I8vHy6lF9poUp7bKT0/NHE8fPX23PwfhnykfqnC2xRxOnVw5XuGIaA==",
+    "node_modules/readable-stream/node_modules/isarray": {
+      "version": "1.0.0",
+      "resolved": "https://registry.npmjs.org/isarray/-/isarray-1.0.0.tgz",
+      "integrity": "sha512-VLghIWNM6ELQzo7zwmcg0NmTVyWKYjvIeM83yjp0wRDTmUnrM678fQbcKBo6n2CJEF0szoG//ytg+TKla89ALQ==",
+      "license": "MIT",
+      "peer": true
+    },
+    "node_modules/readable-stream/node_modules/safe-buffer": {
+      "version": "5.1.2",
+      "resolved": "https://registry.npmjs.org/safe-buffer/-/safe-buffer-5.1.2.tgz",
+      "integrity": "sha512-Gd2UZBJDkXlY7GbJxfsE8/nvKkUEU1G38c1siN6QP6a9PT9MmHB8GnpscSmMJSoF8LOIrt8ud/wPtojys4G6+g==",
+      "license": "MIT",
+      "peer": true
+    },
+    "node_modules/redent": {
+      "version": "3.0.0",
+      "resolved": "https://registry.npmjs.org/redent/-/redent-3.0.0.tgz",
+      "integrity": "sha512-6tDA8g98We0zd0GvVeMT9arEOnTw9qM03L9cJXaCjrip1OO764RDBLBfrB4cwzNGDj5OA5ioymC9GkizgWJDUg==",
       "dev": true,
       "license": "MIT",
-      "bin": {
-        "jsesc": "bin/jsesc"
+      "dependencies": {
+        "indent-string": "^4.0.0",
+        "strip-indent": "^3.0.0"
       },
       "engines": {
-        "node": ">=6"
+        "node": ">=8"
       }
     },
-    "node_modules/json-buffer": {
-      "version": "3.0.1",
-      "resolved": "https://registry.npmjs.org/json-buffer/-/json-buffer-3.0.1.tgz",
-      "integrity": "sha512-4bV5BfR2mqfQTJm+V5tPPdf+ZpuhiIvTuAB5g8kcrXOZpTT/QwwVRWBywX1ozr6lEuPdbHxwaJlm9G6mI2sfSQ==",
-      "dev": true,
-      "license": "MIT"
-    },
-    "node_modules/json-schema-traverse": {
-      "version": "0.4.1",
-      "resolved": "https://registry.npmjs.org/json-schema-traverse/-/json-schema-traverse-0.4.1.tgz",
-      "integrity": "sha512-xbbCH5dCYU5T8LcEhhuh7HJ88HXuW3qsI3Y0zOZFKfZEHcpWiHU/Jxzk629Brsab/mMiHQti9wMP+845RPe3Vg==",
-      "dev": true,
-      "license": "MIT"
+    "node_modules/regl": {
+      "version": "2.1.1",
+      "resolved": "https://registry.npmjs.org/regl/-/regl-2.1.1.tgz",
+      "integrity": "sha512-+IOGrxl3FZ8ZM9ixCWQZzFRiRn7Rzn9bu3iFHwg/yz4tlOUQgbO4PHLgG+1ZT60zcIV8tief6Qrmyl8qcoJP0g==",
+      "license": "MIT",
+      "peer": true
     },
-    "node_modules/json-stable-stringify-without-jsonify": {
-      "version": "1.0.1",
-      "resolved": "https://registry.npmjs.org/json-stable-stringify-without-jsonify/-/json-stable-stringify-without-jsonify-1.0.1.tgz",
-      "integrity": "sha512-Bdboy+l7tA3OGW6FjyFHWkP5LuByj1Tk33Ljyq0axyzdk9//JSi2u3fP1QSmd1KNwq6VOKYGlAu87CisVir6Pw==",
-      "dev": true,
-      "license": "MIT"
+    "node_modules/regl-error2d": {
+      "version": "2.0.12",
+      "resolved": "https://registry.npmjs.org/regl-error2d/-/regl-error2d-2.0.12.tgz",
+      "integrity": "sha512-r7BUprZoPO9AbyqM5qlJesrSRkl+hZnVKWKsVp7YhOl/3RIpi4UDGASGJY0puQ96u5fBYw/OlqV24IGcgJ0McA==",
+      "license": "MIT",
+      "peer": true,
+      "dependencies": {
+        "array-bounds": "^1.0.1",
+        "color-normalize": "^1.5.0",
+        "flatten-vertex-data": "^1.0.2",
+        "object-assign": "^4.1.1",
+        "pick-by-alias": "^1.2.0",
+        "to-float32": "^1.1.0",
+        "update-diff": "^1.1.0"
+      }
     },
-    "node_modules/json5": {
-      "version": "2.2.3",
-      "resolved": "https://registry.npmjs.org/json5/-/json5-2.2.3.tgz",
-      "integrity": "sha512-XmOWe7eyHYH14cLdVPoyg+GOH3rYX++KpzrylJwSW98t3Nk+U8XOl8FWKOgwtzdb8lXGf6zYwDUzeHMWfxasyg==",
-      "dev": true,
+    "node_modules/regl-line2d": {
+      "version": "3.1.3",
+      "resolved": "https://registry.npmjs.org/regl-line2d/-/regl-line2d-3.1.3.tgz",
+      "integrity": "sha512-fkgzW+tTn4QUQLpFKsUIE0sgWdCmXAM3ctXcCgoGBZTSX5FE2A0M7aynz7nrZT5baaftLrk9te54B+MEq4QcSA==",
       "license": "MIT",
-      "bin": {
-        "json5": "lib/cli.js"
-      },
-      "engines": {
-        "node": ">=6"
+      "peer": true,
+      "dependencies": {
+        "array-bounds": "^1.0.1",
+        "array-find-index": "^1.0.2",
+        "array-normalize": "^1.1.4",
+        "color-normalize": "^1.5.0",
+        "earcut": "^2.1.5",
+        "es6-weak-map": "^2.0.3",
+        "flatten-vertex-data": "^1.0.2",
+        "object-assign": "^4.1.1",
+        "parse-rect": "^1.2.0",
+        "pick-by-alias": "^1.2.0",
+        "to-float32": "^1.1.0"
+      }
+    },
+    "node_modules/regl-scatter2d": {
+      "version": "3.3.1",
+      "resolved": "https://registry.npmjs.org/regl-scatter2d/-/regl-scatter2d-3.3.1.tgz",
+      "integrity": "sha512-seOmMIVwaCwemSYz/y4WE0dbSO9svNFSqtTh5RE57I7PjGo3tcUYKtH0MTSoshcAsreoqN8HoCtnn8wfHXXfKQ==",
+      "license": "MIT",
+      "peer": true,
+      "dependencies": {
+        "@plotly/point-cluster": "^3.1.9",
+        "array-range": "^1.0.1",
+        "array-rearrange": "^2.2.2",
+        "clamp": "^1.0.1",
+        "color-id": "^1.1.0",
+        "color-normalize": "^1.5.0",
+        "color-rgba": "^2.1.1",
+        "flatten-vertex-data": "^1.0.2",
+        "glslify": "^7.0.0",
+        "is-iexplorer": "^1.0.0",
+        "object-assign": "^4.1.1",
+        "parse-rect": "^1.2.0",
+        "pick-by-alias": "^1.2.0",
+        "to-float32": "^1.1.0",
+        "update-diff": "^1.1.0"
+      }
+    },
+    "node_modules/regl-scatter2d/node_modules/color-parse": {
+      "version": "1.4.3",
+      "resolved": "https://registry.npmjs.org/color-parse/-/color-parse-1.4.3.tgz",
+      "integrity": "sha512-BADfVl/FHkQkyo8sRBwMYBqemqsgnu7JZAwUgvBvuwwuNUZAhSvLTbsEErS5bQXzOjDR0dWzJ4vXN2Q+QoPx0A==",
+      "license": "MIT",
+      "peer": true,
+      "dependencies": {
+        "color-name": "^1.0.0"
       }
     },
-    "node_modules/keyv": {
-      "version": "4.5.4",
-      "resolved": "https://registry.npmjs.org/keyv/-/keyv-4.5.4.tgz",
-      "integrity": "sha512-oxVHkHR/EJf2CNXnWxRLW6mg7JyCCUcG0DtEGmL2ctUo1PNTin1PUil+r/+4r5MpVgC/fn1kjsx7mjSujKqIpw==",
-      "dev": true,
+    "node_modules/regl-scatter2d/node_modules/color-rgba": {
+      "version": "2.4.0",
+      "resolved": "https://registry.npmjs.org/color-rgba/-/color-rgba-2.4.0.tgz",
+      "integrity": "sha512-Nti4qbzr/z2LbUWySr7H9dk3Rl7gZt7ihHAxlgT4Ho90EXWkjtkL1avTleu9yeGuqrt/chxTB6GKK8nZZ6V0+Q==",
       "license": "MIT",
+      "peer": true,
       "dependencies": {
-        "json-buffer": "3.0.1"
+        "color-parse": "^1.4.2",
+        "color-space": "^2.0.0"
       }
     },
-    "node_modules/leaflet": {
-      "version": "1.9.4",
-      "resolved": "https://registry.npmjs.org/leaflet/-/leaflet-1.9.4.tgz",
-      "integrity": "sha512-nxS1ynzJOmOlHp+iL3FyWqK89GtNL8U8rvlMOsQdTTssxZwCXh8N2NB3GDQOL+YR3XnWyZAxwQixURb+FA74PA==",
-      "license": "BSD-2-Clause"
+    "node_modules/regl-splom": {
+      "version": "1.0.14",
+      "resolved": "https://registry.npmjs.org/regl-splom/-/regl-splom-1.0.14.tgz",
+      "integrity": "sha512-OiLqjmPRYbd7kDlHC6/zDf6L8lxgDC65BhC8JirhP4ykrK4x22ZyS+BnY8EUinXKDeMgmpRwCvUmk7BK4Nweuw==",
+      "license": "MIT",
+      "peer": true,
+      "dependencies": {
+        "array-bounds": "^1.0.1",
+        "array-range": "^1.0.1",
+        "color-alpha": "^1.0.4",
+        "flatten-vertex-data": "^1.0.2",
+        "parse-rect": "^1.2.0",
+        "pick-by-alias": "^1.2.0",
+        "raf": "^3.4.1",
+        "regl-scatter2d": "^3.2.3"
+      }
     },
-    "node_modules/levn": {
-      "version": "0.4.1",
-      "resolved": "https://registry.npmjs.org/levn/-/levn-0.4.1.tgz",
-      "integrity": "sha512-+bT2uH4E5LGE7h/n3evcS/sQlJXCpIp6ym8OWJ5eV6+67Dsql/LaaT7qJBAt2rzfoa/5QBGBhxDix1dMt2kQKQ==",
+    "node_modules/require-from-string": {
+      "version": "2.0.2",
+      "resolved": "https://registry.npmjs.org/require-from-string/-/require-from-string-2.0.2.tgz",
+      "integrity": "sha512-Xf0nWe6RseziFMu+Ap9biiUbmplq6S9/p+7w7YXP/JBHhrUDDUhwa+vANyubuqfZWTveU//DYVGsDG7RKL/vEw==",
       "dev": true,
       "license": "MIT",
-      "dependencies": {
-        "prelude-ls": "^1.2.1",
-        "type-check": "~0.4.0"
-      },
       "engines": {
-        "node": ">= 0.8.0"
+        "node": ">=0.10.0"
       }
     },
-    "node_modules/locate-path": {
-      "version": "6.0.0",
-      "resolved": "https://registry.npmjs.org/locate-path/-/locate-path-6.0.0.tgz",
-      "integrity": "sha512-iPZK6eYjbxRu3uB4/WZ3EsEIMJFMqAoopl3R+zuq0UjcAm/MO6KCweDgPfP3elTztoKP3KtnVHxTn2NHBSDVUw==",
-      "dev": true,
+    "node_modules/resolve": {
+      "version": "1.22.11",
+      "resolved": "https://registry.npmjs.org/resolve/-/resolve-1.22.11.tgz",
+      "integrity": "sha512-RfqAvLnMl313r7c9oclB1HhUEAezcpLjz95wFH4LVuhk9JF/r22qmVP9AMmOU4vMX7Q8pN8jwNg/CSpdFnMjTQ==",
       "license": "MIT",
+      "peer": true,
       "dependencies": {
-        "p-locate": "^5.0.0"
+        "is-core-module": "^2.16.1",
+        "path-parse": "^1.0.7",
+        "supports-preserve-symlinks-flag": "^1.0.0"
+      },
+      "bin": {
+        "resolve": "bin/resolve"
       },
       "engines": {
-        "node": ">=10"
+        "node": ">= 0.4"
       },
       "funding": {
-        "url": "https://github.com/sponsors/sindresorhus"
+        "url": "https://github.com/sponsors/ljharb"
       }
     },
-    "node_modules/lodash.merge": {
-      "version": "4.6.2",
-      "resolved": "https://registry.npmjs.org/lodash.merge/-/lodash.merge-4.6.2.tgz",
-      "integrity": "sha512-0KpjqXRVvrYyCsX1swR/XTK0va6VQkQM6MNo7PqW77ByjAhoARA8EfrP1N4+KlKj8YS0ZUCtRT/YUuhyYDujIQ==",
+    "node_modules/resolve-from": {
+      "version": "4.0.0",
+      "resolved": "https://registry.npmjs.org/resolve-from/-/resolve-from-4.0.0.tgz",
+      "integrity": "sha512-pb/MYmXstAkysRFx8piNI1tGFNQIFA3vkE3Gq4EuA1dF6gHp/+vgZqsCGJapvy8N3Q+4o7FwvquPJcnZ7RYy4g==",
       "dev": true,
-      "license": "MIT"
-    },
-    "node_modules/loose-envify": {
-      "version": "1.4.0",
-      "resolved": "https://registry.npmjs.org/loose-envify/-/loose-envify-1.4.0.tgz",
-      "integrity": "sha512-lyuxPGr/Wfhrlem2CL/UcnUc1zcqKAImBDzukY7Y5F/yQiNdko6+fRLevlw1HgMySw7f611UIY408EtxRSoK3Q==",
       "license": "MIT",
-      "dependencies": {
-        "js-tokens": "^3.0.0 || ^4.0.0"
-      },
-      "bin": {
-        "loose-envify": "cli.js"
+      "engines": {
+        "node": ">=4"
       }
     },
-    "node_modules/lru-cache": {
-      "version": "5.1.1",
-      "resolved": "https://registry.npmjs.org/lru-cache/-/lru-cache-5.1.1.tgz",
-      "integrity": "sha512-KpNARQA3Iwv+jTA0utUVVbrh+Jlrr1Fv0e56GGzAFOXN7dk/FviaDW8LHmK52DlcH4WP2n6gI8vN1aesBFgo9w==",
-      "dev": true,
-      "license": "ISC",
+    "node_modules/resolve-protobuf-schema": {
+      "version": "2.1.0",
+      "resolved": "https://registry.npmjs.org/resolve-protobuf-schema/-/resolve-protobuf-schema-2.1.0.tgz",
+      "integrity": "sha512-kI5ffTiZWmJaS/huM8wZfEMer1eRd7oJQhDuxeCLe3t7N7mX3z94CN0xPxBQxFYQTSNz9T0i+v6inKqSdK8xrQ==",
+      "license": "MIT",
       "dependencies": {
-        "yallist": "^3.0.2"
+        "protocol-buffers-schema": "^3.3.1"
       }
     },
-    "node_modules/merge2": {
-      "version": "1.4.1",
-      "resolved": "https://registry.npmjs.org/merge2/-/merge2-1.4.1.tgz",
-      "integrity": "sha512-8q7VEgMJW4J8tcfVPy8g09NcQwZdbwFEqhe/WZkoIzjn/3TGDwtOCYtXGxA3O8tPzpczCCDgv+P2P5y00ZJOOg==",
+    "node_modules/reusify": {
+      "version": "1.1.0",
+      "resolved": "https://registry.npmjs.org/reusify/-/reusify-1.1.0.tgz",
+      "integrity": "sha512-g6QUff04oZpHs0eG5p83rFLhHeV00ug/Yf9nZM6fLeUrPguBTkTQOdpAWWspMh55TZfVQDPaN3NQJfbVRAxdIw==",
       "dev": true,
       "license": "MIT",
       "engines": {
-        "node": ">= 8"
+        "iojs": ">=1.0.0",
+        "node": ">=0.10.0"
       }
     },
-    "node_modules/micromatch": {
-      "version": "4.0.8",
-      "resolved": "https://registry.npmjs.org/micromatch/-/micromatch-4.0.8.tgz",
-      "integrity": "sha512-PXwfBhYu0hBCPw8Dn0E+WDYb7af3dSLVWKi3HGv84IdF4TyFoC0ysxFd0Goxw7nSv4T/PzEJQxsYsEiFCKo2BA==",
-      "dev": true,
+    "node_modules/right-now": {
+      "version": "1.0.0",
+      "resolved": "https://registry.npmjs.org/right-now/-/right-now-1.0.0.tgz",
+      "integrity": "sha512-DA8+YS+sMIVpbsuKgy+Z67L9Lxb1p05mNxRpDPNksPDEFir4vmBlUtuN9jkTGn9YMMdlBuK7XQgFiz6ws+yhSg==",
       "license": "MIT",
+      "peer": true
+    },
+    "node_modules/rimraf": {
+      "version": "3.0.2",
+      "resolved": "https://registry.npmjs.org/rimraf/-/rimraf-3.0.2.tgz",
+      "integrity": "sha512-JZkJMZkAGFFPP2YqXZXPbMlMBgsxzE8ILs4lMIX/2o0L9UBw9O/Y3o6wFw/i9YLapcUJWwqbi3kdxIPdC62TIA==",
+      "deprecated": "Rimraf versions prior to v4 are no longer supported",
+      "dev": true,
+      "license": "ISC",
       "dependencies": {
-        "braces": "^3.0.3",
-        "picomatch": "^2.3.1"
+        "glob": "^7.1.3"
       },
-      "engines": {
-        "node": ">=8.6"
+      "bin": {
+        "rimraf": "bin.js"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/isaacs"
       }
     },
-    "node_modules/minimatch": {
-      "version": "9.0.5",
-      "resolved": "https://registry.npmjs.org/minimatch/-/minimatch-9.0.5.tgz",
-      "integrity": "sha512-G6T0ZX48xgozx7587koeX9Ys2NYy6Gmv//P89sEte9V9whIapMNF4idKxnW2QtCcLiTWlb/wfCabAtAFWhhBow==",
+    "node_modules/robust-predicates": {
+      "version": "2.0.4",
+      "resolved": "https://registry.npmjs.org/robust-predicates/-/robust-predicates-2.0.4.tgz",
+      "integrity": "sha512-l4NwboJM74Ilm4VKfbAtFeGq7aEjWL+5kVFcmgFA2MrdnQWx9iE/tUGvxY5HyMI7o/WpSIUFLbC5fbeaHgSCYg==",
+      "license": "Unlicense",
+      "optional": true,
+      "peer": true
+    },
+    "node_modules/rollup": {
+      "version": "4.41.1",
+      "resolved": "https://registry.npmjs.org/rollup/-/rollup-4.41.1.tgz",
+      "integrity": "sha512-cPmwD3FnFv8rKMBc1MxWCwVQFxwf1JEmSX3iQXrRVVG15zerAIXRjMFVWnd5Q5QvgKF7Aj+5ykXFhUl+QGnyOw==",
       "dev": true,
-      "license": "ISC",
+      "license": "MIT",
       "dependencies": {
-        "brace-expansion": "^2.0.1"
+        "@types/estree": "1.0.7"
+      },
+      "bin": {
+        "rollup": "dist/bin/rollup"
       },
       "engines": {
-        "node": ">=16 || 14 >=14.17"
+        "node": ">=18.0.0",
+        "npm": ">=8.0.0"
       },
-      "funding": {
-        "url": "https://github.com/sponsors/isaacs"
+      "optionalDependencies": {
+        "@rollup/rollup-android-arm-eabi": "4.41.1",
+        "@rollup/rollup-android-arm64": "4.41.1",
+        "@rollup/rollup-darwin-arm64": "4.41.1",
+        "@rollup/rollup-darwin-x64": "4.41.1",
+        "@rollup/rollup-freebsd-arm64": "4.41.1",
+        "@rollup/rollup-freebsd-x64": "4.41.1",
+        "@rollup/rollup-linux-arm-gnueabihf": "4.41.1",
+        "@rollup/rollup-linux-arm-musleabihf": "4.41.1",
+        "@rollup/rollup-linux-arm64-gnu": "4.41.1",
+        "@rollup/rollup-linux-arm64-musl": "4.41.1",
+        "@rollup/rollup-linux-loongarch64-gnu": "4.41.1",
+        "@rollup/rollup-linux-powerpc64le-gnu": "4.41.1",
+        "@rollup/rollup-linux-riscv64-gnu": "4.41.1",
+        "@rollup/rollup-linux-riscv64-musl": "4.41.1",
+        "@rollup/rollup-linux-s390x-gnu": "4.41.1",
+        "@rollup/rollup-linux-x64-gnu": "4.41.1",
+        "@rollup/rollup-linux-x64-musl": "4.41.1",
+        "@rollup/rollup-win32-arm64-msvc": "4.41.1",
+        "@rollup/rollup-win32-ia32-msvc": "4.41.1",
+        "@rollup/rollup-win32-x64-msvc": "4.41.1",
+        "fsevents": "~2.3.2"
       }
     },
-    "node_modules/ms": {
-      "version": "2.1.3",
-      "resolved": "https://registry.npmjs.org/ms/-/ms-2.1.3.tgz",
-      "integrity": "sha512-6FlzubTLZG3J2a/NVCAleEhjzq5oxgHyaCU9yYXvcLsvoVaHJq/s5xXI6/XXP6tz7R9xAOtHnSO/tXtF3WRTlA==",
+    "node_modules/rrweb-cssom": {
+      "version": "0.8.0",
+      "resolved": "https://registry.npmjs.org/rrweb-cssom/-/rrweb-cssom-0.8.0.tgz",
+      "integrity": "sha512-guoltQEx+9aMf2gDZ0s62EcV8lsXR+0w8915TC3ITdn2YueuNjdAYh/levpU9nFaoChh9RUS5ZdQMrKfVEN9tw==",
       "dev": true,
       "license": "MIT"
     },
-    "node_modules/nanoid": {
-      "version": "3.3.11",
-      "resolved": "https://registry.npmjs.org/nanoid/-/nanoid-3.3.11.tgz",
-      "integrity": "sha512-N8SpfPUnUp1bK+PMYW8qSWdl9U+wwNWI4QKxOYDy9JAro3WMX7p2OeVRF9v+347pnakNevPmiHhNmZ2HbFA76w==",
+    "node_modules/run-parallel": {
+      "version": "1.2.0",
+      "resolved": "https://registry.npmjs.org/run-parallel/-/run-parallel-1.2.0.tgz",
+      "integrity": "sha512-5l4VyZR86LZ/lDxZTR6jqL8AFE2S0IFLMP26AbjsLVADxHdhB/c0GUsH+y39UfCi3dzz8OlQuPmnaJOMoDHQBA==",
       "dev": true,
       "funding": [
         {
           "type": "github",
-          "url": "https://github.com/sponsors/ai"
+          "url": "https://github.com/sponsors/feross"
+        },
+        {
+          "type": "patreon",
+          "url": "https://www.patreon.com/feross"
+        },
+        {
+          "type": "consulting",
+          "url": "https://feross.org/support"
         }
       ],
       "license": "MIT",
-      "bin": {
-        "nanoid": "bin/nanoid.cjs"
-      },
-      "engines": {
-        "node": "^10 || ^12 || ^13.7 || ^14 || >=15.0.1"
+      "dependencies": {
+        "queue-microtask": "^1.2.2"
       }
     },
-    "node_modules/natural-compare": {
-      "version": "1.4.0",
-      "resolved": "https://registry.npmjs.org/natural-compare/-/natural-compare-1.4.0.tgz",
-      "integrity": "sha512-OWND8ei3VtNC9h7V60qff3SVobHr996CTwgxubgyQYEpg290h9J0buyECNNJexkFm5sOajh5G116RYA1c8ZMSw==",
-      "dev": true,
-      "license": "MIT"
+    "node_modules/rw": {
+      "version": "1.3.3",
+      "resolved": "https://registry.npmjs.org/rw/-/rw-1.3.3.tgz",
+      "integrity": "sha512-PdhdWy89SiZogBLaw42zdeqtRJ//zFd2PgQavcICDUgJT5oW10QCRKbJ6bg4r0/UY2M6BWd5tkxuGFRvCkgfHQ==",
+      "license": "BSD-3-Clause"
     },
-    "node_modules/node-releases": {
-      "version": "2.0.19",
-      "resolved": "https://registry.npmjs.org/node-releases/-/node-releases-2.0.19.tgz",
-      "integrity": "sha512-xxOWJsBKtzAq7DY0J+DTzuz58K8e7sJbdgwkbMWQe8UYB6ekmsQ45q0M/tJDsGaZmbC+l7n57UV8Hl5tHxO9uw==",
-      "dev": true,
+    "node_modules/safe-buffer": {
+      "version": "5.2.1",
+      "resolved": "https://registry.npmjs.org/safe-buffer/-/safe-buffer-5.2.1.tgz",
+      "integrity": "sha512-rp3So07KcdmmKbGvgaNxQSJr7bGVSVk5S9Eq1F+ppbRo70+YeaDxkw5Dd8NPN+GD6bjnYm2VuPuCXmpuYvmCXQ==",
+      "funding": [
+        {
+          "type": "github",
+          "url": "https://github.com/sponsors/feross"
+        },
+        {
+          "type": "patreon",
+          "url": "https://www.patreon.com/feross"
+        },
+        {
+          "type": "consulting",
+          "url": "https://feross.org/support"
+        }
+      ],
+      "license": "MIT",
+      "peer": true
+    },
+    "node_modules/safer-buffer": {
+      "version": "2.1.2",
+      "resolved": "https://registry.npmjs.org/safer-buffer/-/safer-buffer-2.1.2.tgz",
+      "integrity": "sha512-YZo3K82SD7Riyi0E1EQPojLz7kpepnSQI9IyPbHHg1XXXevb5dJI7tpyN2ADxGcQbHG7vcyRHk0cbwqcQriUtg==",
       "license": "MIT"
     },
-    "node_modules/once": {
-      "version": "1.4.0",
-      "resolved": "https://registry.npmjs.org/once/-/once-1.4.0.tgz",
-      "integrity": "sha512-lNaJgI+2Q5URQBkccEKHTQOPaXdUxnZZElQTZY0MFUAuaEqe1E+Nyvgdz/aIyNi6Z9MzO5dv1H8n58/GELp3+w==",
-      "dev": true,
-      "license": "ISC",
-      "dependencies": {
-        "wrappy": "1"
+    "node_modules/sax": {
+      "version": "1.6.0",
+      "resolved": "https://registry.npmjs.org/sax/-/sax-1.6.0.tgz",
+      "integrity": "sha512-6R3J5M4AcbtLUdZmRv2SygeVaM7IhrLXu9BmnOGmmACak8fiUtOsYNWUS4uK7upbmHIBbLBeFeI//477BKLBzA==",
+      "license": "BlueOak-1.0.0",
+      "peer": true,
+      "engines": {
+        "node": ">=11.0.0"
       }
     },
-    "node_modules/optionator": {
-      "version": "0.9.4",
-      "resolved": "https://registry.npmjs.org/optionator/-/optionator-0.9.4.tgz",
-      "integrity": "sha512-6IpQ7mKUxRcZNLIObR0hz7lxsapSSIYNZJwXPGeF0mTVqGKFIXj1DQcMoT22S3ROcLyY/rz0PWaWZ9ayWmad9g==",
+    "node_modules/saxes": {
+      "version": "6.0.0",
+      "resolved": "https://registry.npmjs.org/saxes/-/saxes-6.0.0.tgz",
+      "integrity": "sha512-xAg7SOnEhrm5zI3puOOKyy1OMcMlIJZYNJY7xLBwSze0UjhPLnWfj2GF2EpT0jmzaJKIWKHLsaSSajf35bcYnA==",
       "dev": true,
-      "license": "MIT",
+      "license": "ISC",
       "dependencies": {
-        "deep-is": "^0.1.3",
-        "fast-levenshtein": "^2.0.6",
-        "levn": "^0.4.1",
-        "prelude-ls": "^1.2.1",
-        "type-check": "^0.4.0",
-        "word-wrap": "^1.2.5"
+        "xmlchars": "^2.2.0"
       },
       "engines": {
-        "node": ">= 0.8.0"
+        "node": ">=v12.22.7"
       }
     },
-    "node_modules/p-limit": {
-      "version": "3.1.0",
-      "resolved": "https://registry.npmjs.org/p-limit/-/p-limit-3.1.0.tgz",
-      "integrity": "sha512-TYOanM3wGwNGsZN2cVTYPArw454xnXj5qmWF1bEoAc4+cU/ol7GVh7odevjp1FNHduHc3KZMcFduxU5Xc6uJRQ==",
-      "dev": true,
+    "node_modules/scheduler": {
+      "version": "0.23.2",
+      "resolved": "https://registry.npmjs.org/scheduler/-/scheduler-0.23.2.tgz",
+      "integrity": "sha512-UOShsPwz7NrMUqhR6t0hWjFduvOzbtv7toDH1/hIrfRNIDBnnBWd0CwJTGvTpngVlmwGCdP9/Zl/tVrDqcuYzQ==",
       "license": "MIT",
       "dependencies": {
-        "yocto-queue": "^0.1.0"
+        "loose-envify": "^1.1.0"
+      }
+    },
+    "node_modules/semver": {
+      "version": "7.7.2",
+      "resolved": "https://registry.npmjs.org/semver/-/semver-7.7.2.tgz",
+      "integrity": "sha512-RF0Fw+rO5AMf9MAyaRXI4AV0Ulj5lMHqVxxdSgiVbixSCXoEmmX/jk0CuJw4+3SqroYO9VoUh+HcuJivvtJemA==",
+      "dev": true,
+      "license": "ISC",
+      "bin": {
+        "semver": "bin/semver.js"
       },
       "engines": {
         "node": ">=10"
-      },
-      "funding": {
-        "url": "https://github.com/sponsors/sindresorhus"
       }
     },
-    "node_modules/p-locate": {
-      "version": "5.0.0",
-      "resolved": "https://registry.npmjs.org/p-locate/-/p-locate-5.0.0.tgz",
-      "integrity": "sha512-LaNjtRWUBY++zB5nE/NwcaoMylSPk+S+ZHNB1TzdbMJMny6dynpAGt7X/tl/QYq3TIeE6nxHppbo2LGymrG5Pw==",
-      "dev": true,
+    "node_modules/set-value": {
+      "version": "2.0.1",
+      "resolved": "https://registry.npmjs.org/set-value/-/set-value-2.0.1.tgz",
+      "integrity": "sha512-JxHc1weCN68wRY0fhCoXpyK55m/XPHafOmK4UWD7m2CI14GMcFypt4w/0+NV5f/ZMby2F6S2wwA7fgynh9gWSw==",
       "license": "MIT",
       "dependencies": {
-        "p-limit": "^3.0.2"
+        "extend-shallow": "^2.0.1",
+        "is-extendable": "^0.1.1",
+        "is-plain-object": "^2.0.3",
+        "split-string": "^3.0.1"
       },
       "engines": {
-        "node": ">=10"
-      },
-      "funding": {
-        "url": "https://github.com/sponsors/sindresorhus"
+        "node": ">=0.10.0"
       }
     },
-    "node_modules/parent-module": {
-      "version": "1.0.1",
-      "resolved": "https://registry.npmjs.org/parent-module/-/parent-module-1.0.1.tgz",
-      "integrity": "sha512-GQ2EWRpQV8/o+Aw8YqtfZZPfNRWZYkbidE9k5rpl/hC3vtHHBfGm2Ifi6qWV+coDGkrUKZAxE3Lot5kcsRlh+g==",
+    "node_modules/shallow-copy": {
+      "version": "0.0.1",
+      "resolved": "https://registry.npmjs.org/shallow-copy/-/shallow-copy-0.0.1.tgz",
+      "integrity": "sha512-b6i4ZpVuUxB9h5gfCxPiusKYkqTMOjEbBs4wMaFbkfia4yFv92UKZ6Df8WXcKbn08JNL/abvg3FnMAOfakDvUw==",
+      "license": "MIT",
+      "peer": true
+    },
+    "node_modules/shebang-command": {
+      "version": "2.0.0",
+      "resolved": "https://registry.npmjs.org/shebang-command/-/shebang-command-2.0.0.tgz",
+      "integrity": "sha512-kHxr2zZpYtdmrN1qDjrrX/Z1rR1kG8Dx+gkpK1G4eXmvXswmcE1hTWBWYUzlraYw1/yZp6YuDY77YtvbN0dmDA==",
       "dev": true,
       "license": "MIT",
       "dependencies": {
-        "callsites": "^3.0.0"
+        "shebang-regex": "^3.0.0"
       },
       "engines": {
-        "node": ">=6"
+        "node": ">=8"
       }
     },
-    "node_modules/path-exists": {
-      "version": "4.0.0",
-      "resolved": "https://registry.npmjs.org/path-exists/-/path-exists-4.0.0.tgz",
-      "integrity": "sha512-ak9Qy5Q7jYb2Wwcey5Fpvg2KoAc/ZIhLSLOSBmRmygPsGwkVVt0fZa0qrtMz+m6tJTAHfZQ8FnmB4MG4LWy7/w==",
+    "node_modules/shebang-regex": {
+      "version": "3.0.0",
+      "resolved": "https://registry.npmjs.org/shebang-regex/-/shebang-regex-3.0.0.tgz",
+      "integrity": "sha512-7++dFhtcx3353uBaq8DDR4NuxBetBzC7ZQOhmTQInHEd6bSrXdiEyzCvG07Z44UYdLShWUyXt5M/yhz8ekcb1A==",
       "dev": true,
       "license": "MIT",
       "engines": {
         "node": ">=8"
       }
     },
-    "node_modules/path-is-absolute": {
-      "version": "1.0.1",
-      "resolved": "https://registry.npmjs.org/path-is-absolute/-/path-is-absolute-1.0.1.tgz",
-      "integrity": "sha512-AVbw3UJ2e9bq64vSaS9Am0fje1Pa8pbGqTTsmXfaIiMpnr5DlDhfJOuLj9Sf95ZPVDAUerDfEk88MPmPe7UCQg==",
+    "node_modules/siginfo": {
+      "version": "2.0.0",
+      "resolved": "https://registry.npmjs.org/siginfo/-/siginfo-2.0.0.tgz",
+      "integrity": "sha512-ybx0WO1/8bSBLEWXZvEd7gMW3Sn3JFlW3TvX1nREbDLRNQNaeNN8WK0meBwPdAaOI7TtRRRJn/Es1zhrrCHu7g==",
+      "dev": true,
+      "license": "ISC"
+    },
+    "node_modules/signum": {
+      "version": "1.0.0",
+      "resolved": "https://registry.npmjs.org/signum/-/signum-1.0.0.tgz",
+      "integrity": "sha512-yodFGwcyt59XRh7w5W3jPcIQb3Bwi21suEfT7MAWnBX3iCdklJpgDgvGT9o04UonglZN5SNMfJFkHIR/jO8GHw==",
+      "license": "MIT",
+      "peer": true
+    },
+    "node_modules/slash": {
+      "version": "3.0.0",
+      "resolved": "https://registry.npmjs.org/slash/-/slash-3.0.0.tgz",
+      "integrity": "sha512-g9Q1haeby36OSStwb4ntCGGGaKsaVSjQ68fBxoQcutl5fS1vuY18H3wSt3jFyFtrkx+Kz0V1G85A4MyAdDMi2Q==",
       "dev": true,
       "license": "MIT",
+      "engines": {
+        "node": ">=8"
+      }
+    },
+    "node_modules/sort-asc": {
+      "version": "0.2.0",
+      "resolved": "https://registry.npmjs.org/sort-asc/-/sort-asc-0.2.0.tgz",
+      "integrity": "sha512-umMGhjPeHAI6YjABoSTrFp2zaBtXBej1a0yKkuMUyjjqu6FJsTF+JYwCswWDg+zJfk/5npWUUbd33HH/WLzpaA==",
+      "license": "MIT",
       "engines": {
         "node": ">=0.10.0"
       }
     },
-    "node_modules/path-key": {
-      "version": "3.1.1",
-      "resolved": "https://registry.npmjs.org/path-key/-/path-key-3.1.1.tgz",
-      "integrity": "sha512-ojmeN0qd+y0jszEtoY48r0Peq5dwMEkIlCOu6Q5f41lfkswXuKtYrhgoTpLnyIcHm24Uhqx+5Tqm2InSwLhE6Q==",
-      "dev": true,
+    "node_modules/sort-desc": {
+      "version": "0.2.0",
+      "resolved": "https://registry.npmjs.org/sort-desc/-/sort-desc-0.2.0.tgz",
+      "integrity": "sha512-NqZqyvL4VPW+RAxxXnB8gvE1kyikh8+pR+T+CXLksVRN9eiQqkQlPwqWYU0mF9Jm7UnctShlxLyAt1CaBOTL1w==",
       "license": "MIT",
       "engines": {
-        "node": ">=8"
+        "node": ">=0.10.0"
       }
     },
-    "node_modules/path-type": {
-      "version": "4.0.0",
-      "resolved": "https://registry.npmjs.org/path-type/-/path-type-4.0.0.tgz",
-      "integrity": "sha512-gDKb8aZMDeD/tZWs9P6+q0J9Mwkdl6xMV8TjnGP3qJVJ06bdMgkbBlLU8IdfOsIsFz2BW1rNVT3XuNEl8zPAvw==",
-      "dev": true,
+    "node_modules/sort-object": {
+      "version": "3.0.3",
+      "resolved": "https://registry.npmjs.org/sort-object/-/sort-object-3.0.3.tgz",
+      "integrity": "sha512-nK7WOY8jik6zaG9CRwZTaD5O7ETWDLZYMM12pqY8htll+7dYeqGfEUPcUBHOpSJg2vJOrvFIY2Dl5cX2ih1hAQ==",
       "license": "MIT",
+      "dependencies": {
+        "bytewise": "^1.1.0",
+        "get-value": "^2.0.2",
+        "is-extendable": "^0.1.1",
+        "sort-asc": "^0.2.0",
+        "sort-desc": "^0.2.0",
+        "union-value": "^1.0.1"
+      },
       "engines": {
-        "node": ">=8"
+        "node": ">=0.10.0"
       }
     },
-    "node_modules/picocolors": {
-      "version": "1.1.1",
-      "resolved": "https://registry.npmjs.org/picocolors/-/picocolors-1.1.1.tgz",
-      "integrity": "sha512-xceH2snhtb5M9liqDsmEw56le376mTZkEX/jEb/RxNFyegNul7eNslCXP9FDj/Lcu0X8KEyMceP2ntpaHrDEVA==",
-      "dev": true,
-      "license": "ISC"
+    "node_modules/source-map": {
+      "version": "0.6.1",
+      "resolved": "https://registry.npmjs.org/source-map/-/source-map-0.6.1.tgz",
+      "integrity": "sha512-UjgapumWlbMhkBgzT7Ykc5YXUT46F0iKu8SGXq0bcwP5dz/h0Plj6enJqjz1Zbq2l5WaqYnrVbwWOWMyF3F47g==",
+      "license": "BSD-3-Clause",
+      "optional": true,
+      "peer": true,
+      "engines": {
+        "node": ">=0.10.0"
+      }
     },
-    "node_modules/picomatch": {
-      "version": "2.3.1",
-      "resolved": "https://registry.npmjs.org/picomatch/-/picomatch-2.3.1.tgz",
-      "integrity": "sha512-JU3teHTNjmE2VCGFzuY8EXzCDVwEqB2a8fsIvwaStHhAWJEeVd1o1QD80CU6+ZdEXXSLbSsuLwJjkCBWqRQUVA==",
+    "node_modules/source-map-js": {
+      "version": "1.2.1",
+      "resolved": "https://registry.npmjs.org/source-map-js/-/source-map-js-1.2.1.tgz",
+      "integrity": "sha512-UXWMKhLOwVKb728IUtQPXxfYU+usdybtUrK/8uGE8CQMvrhOpwvzDBwj0QhSL7MQc7vIsISBG8VQ8+IDQxpfQA==",
       "dev": true,
-      "license": "MIT",
+      "license": "BSD-3-Clause",
       "engines": {
-        "node": ">=8.6"
+        "node": ">=0.10.0"
+      }
+    },
+    "node_modules/splaytree": {
+      "version": "0.1.4",
+      "resolved": "https://registry.npmjs.org/splaytree/-/splaytree-0.1.4.tgz",
+      "integrity": "sha512-D50hKrjZgBzqD3FT2Ek53f2dcDLAQT8SSGrzj3vidNH5ISRgceeGVJ2dQIthKOuayqFXfFjXheHNo4bbt9LhRQ==",
+      "license": "MIT",
+      "optional": true,
+      "peer": true
+    },
+    "node_modules/split-string": {
+      "version": "3.1.0",
+      "resolved": "https://registry.npmjs.org/split-string/-/split-string-3.1.0.tgz",
+      "integrity": "sha512-NzNVhJDYpwceVVii8/Hu6DKfD2G+NrQHlS/V/qgv763EYudVwEcMQNxd2lh+0VrUByXN/oJkl5grOhYWvQUYiw==",
+      "license": "MIT",
+      "dependencies": {
+        "extend-shallow": "^3.0.0"
       },
-      "funding": {
-        "url": "https://github.com/sponsors/jonschlinkert"
+      "engines": {
+        "node": ">=0.10.0"
       }
     },
-    "node_modules/postcss": {
-      "version": "8.5.4",
-      "resolved": "https://registry.npmjs.org/postcss/-/postcss-8.5.4.tgz",
-      "integrity": "sha512-QSa9EBe+uwlGTFmHsPKokv3B/oEMQZxfqW0QqNCyhpa6mB1afzulwn8hihglqAb2pOw+BJgNlmXQ8la2VeHB7w==",
-      "dev": true,
-      "funding": [
-        {
-          "type": "opencollective",
-          "url": "https://opencollective.com/postcss/"
-        },
-        {
-          "type": "tidelift",
-          "url": "https://tidelift.com/funding/github/npm/postcss"
-        },
-        {
-          "type": "github",
-          "url": "https://github.com/sponsors/ai"
-        }
-      ],
+    "node_modules/split-string/node_modules/extend-shallow": {
+      "version": "3.0.2",
+      "resolved": "https://registry.npmjs.org/extend-shallow/-/extend-shallow-3.0.2.tgz",
+      "integrity": "sha512-BwY5b5Ql4+qZoefgMj2NUmx+tehVTH/Kf4k1ZEtOHNFcm2wSxMRo992l6X3TIgni2eZVTZ85xMOjF31fwZAj6Q==",
       "license": "MIT",
       "dependencies": {
-        "nanoid": "^3.3.11",
-        "picocolors": "^1.1.1",
-        "source-map-js": "^1.2.1"
+        "assign-symbols": "^1.0.0",
+        "is-extendable": "^1.0.1"
       },
       "engines": {
-        "node": "^10 || ^12 || >=14"
+        "node": ">=0.10.0"
       }
     },
-    "node_modules/prelude-ls": {
-      "version": "1.2.1",
-      "resolved": "https://registry.npmjs.org/prelude-ls/-/prelude-ls-1.2.1.tgz",
-      "integrity": "sha512-vkcDPrRZo1QZLbn5RLGPpg/WmIQ65qoWWhcGKf/b5eplkkarX0m9z8ppCat4mlOqUsWpyNuYgO3VRyrYHSzX5g==",
-      "dev": true,
+    "node_modules/split-string/node_modules/is-extendable": {
+      "version": "1.0.1",
+      "resolved": "https://registry.npmjs.org/is-extendable/-/is-extendable-1.0.1.tgz",
+      "integrity": "sha512-arnXMxT1hhoKo9k1LZdmlNyJdDDfy2v0fXjFlmok4+i8ul/6WlbVge9bhM74OpNPQPMGUToDtz+KXa1PneJxOA==",
       "license": "MIT",
+      "dependencies": {
+        "is-plain-object": "^2.0.4"
+      },
       "engines": {
-        "node": ">= 0.8.0"
+        "node": ">=0.10.0"
       }
     },
-    "node_modules/punycode": {
-      "version": "2.3.1",
-      "resolved": "https://registry.npmjs.org/punycode/-/punycode-2.3.1.tgz",
-      "integrity": "sha512-vYt7UD1U9Wg6138shLtLOvdAu+8DsC/ilFtEVHcH+wydcSpNE20AfSOduf6MkRFahL5FY7X1oU7nKVZFtfq8Fg==",
+    "node_modules/stack-trace": {
+      "version": "0.0.9",
+      "resolved": "https://registry.npmjs.org/stack-trace/-/stack-trace-0.0.9.tgz",
+      "integrity": "sha512-vjUc6sfgtgY0dxCdnc40mK6Oftjo9+2K8H/NG81TMhgL392FtiPA9tn9RLyTxXmTLPJPjF3VyzFp6bsWFLisMQ==",
+      "peer": true,
+      "engines": {
+        "node": "*"
+      }
+    },
+    "node_modules/stackback": {
+      "version": "0.0.2",
+      "resolved": "https://registry.npmjs.org/stackback/-/stackback-0.0.2.tgz",
+      "integrity": "sha512-1XMJE5fQo1jGH6Y/7ebnwPOBEkIEnT4QF32d5R1+VXdXveM0IBMJt8zfaxX1P3QhVwrYe+576+jkANtSS2mBbw==",
       "dev": true,
+      "license": "MIT"
+    },
+    "node_modules/static-eval": {
+      "version": "2.1.1",
+      "resolved": "https://registry.npmjs.org/static-eval/-/static-eval-2.1.1.tgz",
+      "integrity": "sha512-MgWpQ/ZjGieSVB3eOJVs4OA2LT/q1vx98KPCTTQPzq/aLr0YUXTsgryTXr4SLfR0ZfUUCiedM9n/ABeDIyy4mA==",
       "license": "MIT",
-      "engines": {
-        "node": ">=6"
+      "peer": true,
+      "dependencies": {
+        "escodegen": "^2.1.0"
       }
     },
-    "node_modules/queue-microtask": {
-      "version": "1.2.3",
-      "resolved": "https://registry.npmjs.org/queue-microtask/-/queue-microtask-1.2.3.tgz",
-      "integrity": "sha512-NuaNSa6flKT5JaSYQzJok04JzTL1CA6aGhv5rfLW3PgqA+M2ChpZQnAC8h8i4ZFkBS8X5RqkDBHA7r4hej3K9A==",
+    "node_modules/std-env": {
+      "version": "3.10.0",
+      "resolved": "https://registry.npmjs.org/std-env/-/std-env-3.10.0.tgz",
+      "integrity": "sha512-5GS12FdOZNliM5mAOxFRg7Ir0pWz8MdpYm6AY6VPkGpbA7ZzmbzNcBJQ0GPvvyWgcY7QAhCgf9Uy89I03faLkg==",
       "dev": true,
-      "funding": [
-        {
-          "type": "github",
-          "url": "https://github.com/sponsors/feross"
-        },
-        {
-          "type": "patreon",
-          "url": "https://www.patreon.com/feross"
-        },
-        {
-          "type": "consulting",
-          "url": "https://feross.org/support"
-        }
-      ],
       "license": "MIT"
     },
-    "node_modules/react": {
-      "version": "18.3.1",
-      "resolved": "https://registry.npmjs.org/react/-/react-18.3.1.tgz",
-      "integrity": "sha512-wS+hAgJShR0KhEvPJArfuPVN1+Hz1t0Y6n5jLrGQbkb4urgPE/0Rve+1kMB1v/oWgHgm4WIcV+i7F2pTVj+2iQ==",
+    "node_modules/stream-parser": {
+      "version": "0.3.1",
+      "resolved": "https://registry.npmjs.org/stream-parser/-/stream-parser-0.3.1.tgz",
+      "integrity": "sha512-bJ/HgKq41nlKvlhccD5kaCr/P+Hu0wPNKPJOH7en+YrJu/9EgqUF+88w5Jb6KNcjOFMhfX4B2asfeAtIGuHObQ==",
       "license": "MIT",
+      "peer": true,
       "dependencies": {
-        "loose-envify": "^1.1.0"
-      },
-      "engines": {
-        "node": ">=0.10.0"
+        "debug": "2"
       }
     },
-    "node_modules/react-chartjs-2": {
-      "version": "5.3.0",
-      "resolved": "https://registry.npmjs.org/react-chartjs-2/-/react-chartjs-2-5.3.0.tgz",
-      "integrity": "sha512-UfZZFnDsERI3c3CZGxzvNJd02SHjaSJ8kgW1djn65H1KK8rehwTjyrRKOG3VTMG8wtHZ5rgAO5oTHtHi9GCCmw==",
+    "node_modules/stream-parser/node_modules/debug": {
+      "version": "2.6.9",
+      "resolved": "https://registry.npmjs.org/debug/-/debug-2.6.9.tgz",
+      "integrity": "sha512-bC7ElrdJaJnPbAP+1EotYvqZsb3ecl5wi6Bfi6BJTUcNowp6cvspg0jXznRTKDjm/E7AdgFBVeAPVMNcKGsHMA==",
       "license": "MIT",
-      "peerDependencies": {
-        "chart.js": "^4.1.1",
-        "react": "^16.8.0 || ^17.0.0 || ^18.0.0 || ^19.0.0"
+      "peer": true,
+      "dependencies": {
+        "ms": "2.0.0"
       }
     },
-    "node_modules/react-dom": {
-      "version": "18.3.1",
-      "resolved": "https://registry.npmjs.org/react-dom/-/react-dom-18.3.1.tgz",
-      "integrity": "sha512-5m4nQKp+rZRb09LNH59GM4BxTh9251/ylbKIbpe7TpGxfJ+9kv6BLkLBXIjjspbgbnIBNqlI23tRnTWT0snUIw==",
+    "node_modules/stream-parser/node_modules/ms": {
+      "version": "2.0.0",
+      "resolved": "https://registry.npmjs.org/ms/-/ms-2.0.0.tgz",
+      "integrity": "sha512-Tpp60P6IUJDTuOq/5Z8cdskzJujfwqfOTkrwIwj7IRISpnkJnT6SyJ4PCPnGMoFjC9ddhal5KVIYtAt97ix05A==",
+      "license": "MIT",
+      "peer": true
+    },
+    "node_modules/stream-shift": {
+      "version": "1.0.3",
+      "resolved": "https://registry.npmjs.org/stream-shift/-/stream-shift-1.0.3.tgz",
+      "integrity": "sha512-76ORR0DO1o1hlKwTbi/DM3EXWGf3ZJYO8cXX5RJwnul2DEg2oyoZyjLNoQM8WsvZiFKCRfC1O0J7iCvie3RZmQ==",
+      "license": "MIT",
+      "peer": true
+    },
+    "node_modules/string_decoder": {
+      "version": "1.1.1",
+      "resolved": "https://registry.npmjs.org/string_decoder/-/string_decoder-1.1.1.tgz",
+      "integrity": "sha512-n/ShnvDi6FHbbVfviro+WojiFzv+s8MPMHBczVePfUpDJLwoLT0ht1l4YwBCbi8pJAveEEdnkHyPyTP/mzRfwg==",
       "license": "MIT",
+      "peer": true,
       "dependencies": {
-        "loose-envify": "^1.1.0",
-        "scheduler": "^0.23.2"
-      },
-      "peerDependencies": {
-        "react": "^18.3.1"
+        "safe-buffer": "~5.1.0"
       }
     },
-    "node_modules/react-leaflet": {
-      "version": "4.2.1",
-      "resolved": "https://registry.npmjs.org/react-leaflet/-/react-leaflet-4.2.1.tgz",
-      "integrity": "sha512-p9chkvhcKrWn/H/1FFeVSqLdReGwn2qmiobOQGO3BifX+/vV/39qhY8dGqbdcPh1e6jxh/QHriLXr7a4eLFK4Q==",
-      "license": "Hippocratic-2.1",
+    "node_modules/string_decoder/node_modules/safe-buffer": {
+      "version": "5.1.2",
+      "resolved": "https://registry.npmjs.org/safe-buffer/-/safe-buffer-5.1.2.tgz",
+      "integrity": "sha512-Gd2UZBJDkXlY7GbJxfsE8/nvKkUEU1G38c1siN6QP6a9PT9MmHB8GnpscSmMJSoF8LOIrt8ud/wPtojys4G6+g==",
+      "license": "MIT",
+      "peer": true
+    },
+    "node_modules/string-split-by": {
+      "version": "1.0.0",
+      "resolved": "https://registry.npmjs.org/string-split-by/-/string-split-by-1.0.0.tgz",
+      "integrity": "sha512-KaJKY+hfpzNyet/emP81PJA9hTVSfxNLS9SFTWxdCnnW1/zOOwiV248+EfoX7IQFcBaOp4G5YE6xTJMF+pLg6A==",
+      "license": "MIT",
+      "peer": true,
       "dependencies": {
-        "@react-leaflet/core": "^2.1.0"
-      },
-      "peerDependencies": {
-        "leaflet": "^1.9.0",
-        "react": "^18.0.0",
-        "react-dom": "^18.0.0"
+        "parenthesis": "^3.1.5"
       }
     },
-    "node_modules/react-refresh": {
-      "version": "0.17.0",
-      "resolved": "https://registry.npmjs.org/react-refresh/-/react-refresh-0.17.0.tgz",
-      "integrity": "sha512-z6F7K9bV85EfseRCp2bzrpyQ0Gkw1uLoCel9XBVWPg/TjRj94SkJzUTGfOa4bs7iJvBWtQG0Wq7wnI0syw3EBQ==",
+    "node_modules/strip-ansi": {
+      "version": "6.0.1",
+      "resolved": "https://registry.npmjs.org/strip-ansi/-/strip-ansi-6.0.1.tgz",
+      "integrity": "sha512-Y38VPSHcqkFrCpFnQ9vuSXmquuv5oXOKpGeT6aGrr3o3Gc9AlVa6JBfUSOCnbxGGZF+/0ooI7KrPuUSztUdU5A==",
       "dev": true,
       "license": "MIT",
+      "dependencies": {
+        "ansi-regex": "^5.0.1"
+      },
       "engines": {
-        "node": ">=0.10.0"
+        "node": ">=8"
       }
     },
-    "node_modules/resolve-from": {
-      "version": "4.0.0",
-      "resolved": "https://registry.npmjs.org/resolve-from/-/resolve-from-4.0.0.tgz",
-      "integrity": "sha512-pb/MYmXstAkysRFx8piNI1tGFNQIFA3vkE3Gq4EuA1dF6gHp/+vgZqsCGJapvy8N3Q+4o7FwvquPJcnZ7RYy4g==",
+    "node_modules/strip-indent": {
+      "version": "3.0.0",
+      "resolved": "https://registry.npmjs.org/strip-indent/-/strip-indent-3.0.0.tgz",
+      "integrity": "sha512-laJTa3Jb+VQpaC6DseHhF7dXVqHTfJPCRDaEbid/drOhgitgYku/letMUqOXFoWV0zIIUbjpdH2t+tYj4bQMRQ==",
       "dev": true,
       "license": "MIT",
+      "dependencies": {
+        "min-indent": "^1.0.0"
+      },
       "engines": {
-        "node": ">=4"
+        "node": ">=8"
       }
     },
-    "node_modules/reusify": {
-      "version": "1.1.0",
-      "resolved": "https://registry.npmjs.org/reusify/-/reusify-1.1.0.tgz",
-      "integrity": "sha512-g6QUff04oZpHs0eG5p83rFLhHeV00ug/Yf9nZM6fLeUrPguBTkTQOdpAWWspMh55TZfVQDPaN3NQJfbVRAxdIw==",
+    "node_modules/strip-json-comments": {
+      "version": "3.1.1",
+      "resolved": "https://registry.npmjs.org/strip-json-comments/-/strip-json-comments-3.1.1.tgz",
+      "integrity": "sha512-6fPc+R4ihwqP6N/aIv2f1gMH8lOVtWQHoqC4yK6oSDVVocumAsfCqjkXnqiYMhmMwS/mEHLp7Vehlt3ql6lEig==",
       "dev": true,
       "license": "MIT",
       "engines": {
-        "iojs": ">=1.0.0",
-        "node": ">=0.10.0"
+        "node": ">=8"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/sindresorhus"
       }
     },
-    "node_modules/rimraf": {
-      "version": "3.0.2",
-      "resolved": "https://registry.npmjs.org/rimraf/-/rimraf-3.0.2.tgz",
-      "integrity": "sha512-JZkJMZkAGFFPP2YqXZXPbMlMBgsxzE8ILs4lMIX/2o0L9UBw9O/Y3o6wFw/i9YLapcUJWwqbi3kdxIPdC62TIA==",
-      "deprecated": "Rimraf versions prior to v4 are no longer supported",
+    "node_modules/strip-literal": {
+      "version": "3.1.0",
+      "resolved": "https://registry.npmjs.org/strip-literal/-/strip-literal-3.1.0.tgz",
+      "integrity": "sha512-8r3mkIM/2+PpjHoOtiAW8Rg3jJLHaV7xPwG+YRGrv6FP0wwk/toTpATxWYOW0BKdWwl82VT2tFYi5DlROa0Mxg==",
       "dev": true,
-      "license": "ISC",
+      "license": "MIT",
       "dependencies": {
-        "glob": "^7.1.3"
-      },
-      "bin": {
-        "rimraf": "bin.js"
+        "js-tokens": "^9.0.1"
       },
       "funding": {
-        "url": "https://github.com/sponsors/isaacs"
+        "url": "https://github.com/sponsors/antfu"
       }
     },
-    "node_modules/rollup": {
-      "version": "4.41.1",
-      "resolved": "https://registry.npmjs.org/rollup/-/rollup-4.41.1.tgz",
-      "integrity": "sha512-cPmwD3FnFv8rKMBc1MxWCwVQFxwf1JEmSX3iQXrRVVG15zerAIXRjMFVWnd5Q5QvgKF7Aj+5ykXFhUl+QGnyOw==",
+    "node_modules/strip-literal/node_modules/js-tokens": {
+      "version": "9.0.1",
+      "resolved": "https://registry.npmjs.org/js-tokens/-/js-tokens-9.0.1.tgz",
+      "integrity": "sha512-mxa9E9ITFOt0ban3j6L5MpjwegGz6lBQmM1IJkWeBZGcMxto50+eWdjC/52xDbS2vy0k7vIMK0Fe2wfL9OQSpQ==",
       "dev": true,
+      "license": "MIT"
+    },
+    "node_modules/strongly-connected-components": {
+      "version": "1.0.1",
+      "resolved": "https://registry.npmjs.org/strongly-connected-components/-/strongly-connected-components-1.0.1.tgz",
+      "integrity": "sha512-i0TFx4wPcO0FwX+4RkLJi1MxmcTv90jNZgxMu9XRnMXMeFUY1VJlIoXpZunPUvUUqbCT1pg5PEkFqqpcaElNaA==",
       "license": "MIT",
+      "peer": true
+    },
+    "node_modules/supercluster": {
+      "version": "8.0.1",
+      "resolved": "https://registry.npmjs.org/supercluster/-/supercluster-8.0.1.tgz",
+      "integrity": "sha512-IiOea5kJ9iqzD2t7QJq/cREyLHTtSmUT6gQsweojg9WH2sYJqZK9SswTu6jrscO6D1G5v5vYZ9ru/eq85lXeZQ==",
+      "license": "ISC",
       "dependencies": {
-        "@types/estree": "1.0.7"
-      },
-      "bin": {
-        "rollup": "dist/bin/rollup"
+        "kdbush": "^4.0.2"
+      }
+    },
+    "node_modules/superscript-text": {
+      "version": "1.0.0",
+      "resolved": "https://registry.npmjs.org/superscript-text/-/superscript-text-1.0.0.tgz",
+      "integrity": "sha512-gwu8l5MtRZ6koO0icVTlmN5pm7Dhh1+Xpe9O4x6ObMAsW+3jPbW14d1DsBq1F4wiI+WOFjXF35pslgec/G8yCQ==",
+      "license": "MIT",
+      "peer": true
+    },
+    "node_modules/supports-color": {
+      "version": "7.2.0",
+      "resolved": "https://registry.npmjs.org/supports-color/-/supports-color-7.2.0.tgz",
+      "integrity": "sha512-qpCAvRl9stuOHveKsn7HncJRvv501qIacKzQlO/+Lwxc9+0q2wLyv4Dfvt80/DPn2pqOBsJdDiogXGR9+OvwRw==",
+      "license": "MIT",
+      "dependencies": {
+        "has-flag": "^4.0.0"
       },
       "engines": {
-        "node": ">=18.0.0",
-        "npm": ">=8.0.0"
+        "node": ">=8"
+      }
+    },
+    "node_modules/supports-preserve-symlinks-flag": {
+      "version": "1.0.0",
+      "resolved": "https://registry.npmjs.org/supports-preserve-symlinks-flag/-/supports-preserve-symlinks-flag-1.0.0.tgz",
+      "integrity": "sha512-ot0WnXS9fgdkgIcePe6RHNk1WA8+muPa6cSjeR3V8K27q9BB1rTE3R1p7Hv0z1ZyAc8s6Vvv8DIyWf681MAt0w==",
+      "license": "MIT",
+      "peer": true,
+      "engines": {
+        "node": ">= 0.4"
       },
-      "optionalDependencies": {
-        "@rollup/rollup-android-arm-eabi": "4.41.1",
-        "@rollup/rollup-android-arm64": "4.41.1",
-        "@rollup/rollup-darwin-arm64": "4.41.1",
-        "@rollup/rollup-darwin-x64": "4.41.1",
-        "@rollup/rollup-freebsd-arm64": "4.41.1",
-        "@rollup/rollup-freebsd-x64": "4.41.1",
-        "@rollup/rollup-linux-arm-gnueabihf": "4.41.1",
-        "@rollup/rollup-linux-arm-musleabihf": "4.41.1",
-        "@rollup/rollup-linux-arm64-gnu": "4.41.1",
-        "@rollup/rollup-linux-arm64-musl": "4.41.1",
-        "@rollup/rollup-linux-loongarch64-gnu": "4.41.1",
-        "@rollup/rollup-linux-powerpc64le-gnu": "4.41.1",
-        "@rollup/rollup-linux-riscv64-gnu": "4.41.1",
-        "@rollup/rollup-linux-riscv64-musl": "4.41.1",
-        "@rollup/rollup-linux-s390x-gnu": "4.41.1",
-        "@rollup/rollup-linux-x64-gnu": "4.41.1",
-        "@rollup/rollup-linux-x64-musl": "4.41.1",
-        "@rollup/rollup-win32-arm64-msvc": "4.41.1",
-        "@rollup/rollup-win32-ia32-msvc": "4.41.1",
-        "@rollup/rollup-win32-x64-msvc": "4.41.1",
-        "fsevents": "~2.3.2"
+      "funding": {
+        "url": "https://github.com/sponsors/ljharb"
       }
     },
-    "node_modules/run-parallel": {
-      "version": "1.2.0",
-      "resolved": "https://registry.npmjs.org/run-parallel/-/run-parallel-1.2.0.tgz",
-      "integrity": "sha512-5l4VyZR86LZ/lDxZTR6jqL8AFE2S0IFLMP26AbjsLVADxHdhB/c0GUsH+y39UfCi3dzz8OlQuPmnaJOMoDHQBA==",
-      "dev": true,
-      "funding": [
-        {
-          "type": "github",
-          "url": "https://github.com/sponsors/feross"
-        },
-        {
-          "type": "patreon",
-          "url": "https://www.patreon.com/feross"
-        },
-        {
-          "type": "consulting",
-          "url": "https://feross.org/support"
-        }
-      ],
+    "node_modules/svg-arc-to-cubic-bezier": {
+      "version": "3.2.0",
+      "resolved": "https://registry.npmjs.org/svg-arc-to-cubic-bezier/-/svg-arc-to-cubic-bezier-3.2.0.tgz",
+      "integrity": "sha512-djbJ/vZKZO+gPoSDThGNpKDO+o+bAeA4XQKovvkNCqnIS2t+S4qnLAGQhyyrulhCFRl1WWzAp0wUDV8PpTVU3g==",
+      "license": "ISC",
+      "peer": true
+    },
+    "node_modules/svg-path-bounds": {
+      "version": "1.0.2",
+      "resolved": "https://registry.npmjs.org/svg-path-bounds/-/svg-path-bounds-1.0.2.tgz",
+      "integrity": "sha512-H4/uAgLWrppIC0kHsb2/dWUYSmb4GE5UqH06uqWBcg6LBjX2fu0A8+JrO2/FJPZiSsNOKZAhyFFgsLTdYUvSqQ==",
       "license": "MIT",
+      "peer": true,
       "dependencies": {
-        "queue-microtask": "^1.2.2"
+        "abs-svg-path": "^0.1.1",
+        "is-svg-path": "^1.0.1",
+        "normalize-svg-path": "^1.0.0",
+        "parse-svg-path": "^0.1.2"
       }
     },
-    "node_modules/scheduler": {
-      "version": "0.23.2",
-      "resolved": "https://registry.npmjs.org/scheduler/-/scheduler-0.23.2.tgz",
-      "integrity": "sha512-UOShsPwz7NrMUqhR6t0hWjFduvOzbtv7toDH1/hIrfRNIDBnnBWd0CwJTGvTpngVlmwGCdP9/Zl/tVrDqcuYzQ==",
+    "node_modules/svg-path-bounds/node_modules/normalize-svg-path": {
+      "version": "1.1.0",
+      "resolved": "https://registry.npmjs.org/normalize-svg-path/-/normalize-svg-path-1.1.0.tgz",
+      "integrity": "sha512-r9KHKG2UUeB5LoTouwDzBy2VxXlHsiM6fyLQvnJa0S5hrhzqElH/CH7TUGhT1fVvIYBIKf3OpY4YJ4CK+iaqHg==",
       "license": "MIT",
+      "peer": true,
       "dependencies": {
-        "loose-envify": "^1.1.0"
+        "svg-arc-to-cubic-bezier": "^3.0.0"
       }
     },
-    "node_modules/semver": {
-      "version": "7.7.2",
-      "resolved": "https://registry.npmjs.org/semver/-/semver-7.7.2.tgz",
-      "integrity": "sha512-RF0Fw+rO5AMf9MAyaRXI4AV0Ulj5lMHqVxxdSgiVbixSCXoEmmX/jk0CuJw4+3SqroYO9VoUh+HcuJivvtJemA==",
+    "node_modules/svg-path-sdf": {
+      "version": "1.1.3",
+      "resolved": "https://registry.npmjs.org/svg-path-sdf/-/svg-path-sdf-1.1.3.tgz",
+      "integrity": "sha512-vJJjVq/R5lSr2KLfVXVAStktfcfa1pNFjFOgyJnzZFXlO/fDZ5DmM8FpnSKKzLPfEYTVeXuVBTHF296TpxuJVg==",
+      "license": "MIT",
+      "peer": true,
+      "dependencies": {
+        "bitmap-sdf": "^1.0.0",
+        "draw-svg-path": "^1.0.0",
+        "is-svg-path": "^1.0.1",
+        "parse-svg-path": "^0.1.2",
+        "svg-path-bounds": "^1.0.1"
+      }
+    },
+    "node_modules/symbol-tree": {
+      "version": "3.2.4",
+      "resolved": "https://registry.npmjs.org/symbol-tree/-/symbol-tree-3.2.4.tgz",
+      "integrity": "sha512-9QNk5KwDF+Bvz+PyObkmSYjI5ksVUYtjW7AU22r2NKcfLJcXp96hkDWU3+XndOsUb+AQ9QhfzfCT2O+CNWT5Tw==",
       "dev": true,
-      "license": "ISC",
-      "bin": {
-        "semver": "bin/semver.js"
+      "license": "MIT"
+    },
+    "node_modules/table-layout": {
+      "version": "4.1.1",
+      "resolved": "https://registry.npmjs.org/table-layout/-/table-layout-4.1.1.tgz",
+      "integrity": "sha512-iK5/YhZxq5GO5z8wb0bY1317uDF3Zjpha0QFFLA8/trAoiLbQD0HUbMesEaxyzUgDxi2QlcbM8IvqOlEjgoXBA==",
+      "license": "MIT",
+      "dependencies": {
+        "array-back": "^6.2.2",
+        "wordwrapjs": "^5.1.0"
       },
       "engines": {
-        "node": ">=10"
+        "node": ">=12.17"
       }
     },
-    "node_modules/shebang-command": {
-      "version": "2.0.0",
-      "resolved": "https://registry.npmjs.org/shebang-command/-/shebang-command-2.0.0.tgz",
-      "integrity": "sha512-kHxr2zZpYtdmrN1qDjrrX/Z1rR1kG8Dx+gkpK1G4eXmvXswmcE1hTWBWYUzlraYw1/yZp6YuDY77YtvbN0dmDA==",
+    "node_modules/text-table": {
+      "version": "0.2.0",
+      "resolved": "https://registry.npmjs.org/text-table/-/text-table-0.2.0.tgz",
+      "integrity": "sha512-N+8UisAXDGk8PFXP4HAzVR9nbfmVJ3zYLAWiTIoqC5v5isinhr+r5uaO8+7r3BMfuNIufIsA7RdpVgacC2cSpw==",
+      "dev": true,
+      "license": "MIT"
+    },
+    "node_modules/through2": {
+      "version": "2.0.5",
+      "resolved": "https://registry.npmjs.org/through2/-/through2-2.0.5.tgz",
+      "integrity": "sha512-/mrRod8xqpA+IHSLyGCQ2s8SPHiCDEeQJSep1jqLYeEUClOFG2Qsh+4FU6G9VeqpZnGW/Su8LQGc4YKni5rYSQ==",
+      "license": "MIT",
+      "peer": true,
+      "dependencies": {
+        "readable-stream": "~2.3.6",
+        "xtend": "~4.0.1"
+      }
+    },
+    "node_modules/tinybench": {
+      "version": "2.9.0",
+      "resolved": "https://registry.npmjs.org/tinybench/-/tinybench-2.9.0.tgz",
+      "integrity": "sha512-0+DUvqWMValLmha6lr4kD8iAMK1HzV0/aKnCtWb9v9641TnP/MFb7Pc2bxoxQjTXAErryXVgUOfv2YqNllqGeg==",
+      "dev": true,
+      "license": "MIT"
+    },
+    "node_modules/tinycolor2": {
+      "version": "1.6.0",
+      "resolved": "https://registry.npmjs.org/tinycolor2/-/tinycolor2-1.6.0.tgz",
+      "integrity": "sha512-XPaBkWQJdsf3pLKJV9p4qN/S+fm2Oj8AIPo1BTUhg5oxkvm9+SVEGFdhyOz7tTdUTfvxMiAs4sp6/eZO2Ew+pw==",
+      "license": "MIT",
+      "peer": true
+    },
+    "node_modules/tinyexec": {
+      "version": "0.3.2",
+      "resolved": "https://registry.npmjs.org/tinyexec/-/tinyexec-0.3.2.tgz",
+      "integrity": "sha512-KQQR9yN7R5+OSwaK0XQoj22pwHoTlgYqmUscPYoknOoWCWfj/5/ABTMRi69FrKU5ffPVh5QcFikpWJI/P1ocHA==",
+      "dev": true,
+      "license": "MIT"
+    },
+    "node_modules/tinyglobby": {
+      "version": "0.2.15",
+      "resolved": "https://registry.npmjs.org/tinyglobby/-/tinyglobby-0.2.15.tgz",
+      "integrity": "sha512-j2Zq4NyQYG5XMST4cbs02Ak8iJUdxRM0XI5QyxXuZOzKOINmWurp3smXu3y5wDcJrptwpSjgXHzIQxR0omXljQ==",
       "dev": true,
       "license": "MIT",
       "dependencies": {
-        "shebang-regex": "^3.0.0"
+        "fdir": "^6.5.0",
+        "picomatch": "^4.0.3"
       },
       "engines": {
-        "node": ">=8"
+        "node": ">=12.0.0"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/SuperchupuDev"
       }
     },
-    "node_modules/shebang-regex": {
-      "version": "3.0.0",
-      "resolved": "https://registry.npmjs.org/shebang-regex/-/shebang-regex-3.0.0.tgz",
-      "integrity": "sha512-7++dFhtcx3353uBaq8DDR4NuxBetBzC7ZQOhmTQInHEd6bSrXdiEyzCvG07Z44UYdLShWUyXt5M/yhz8ekcb1A==",
+    "node_modules/tinyglobby/node_modules/fdir": {
+      "version": "6.5.0",
+      "resolved": "https://registry.npmjs.org/fdir/-/fdir-6.5.0.tgz",
+      "integrity": "sha512-tIbYtZbucOs0BRGqPJkshJUYdL+SDH7dVM8gjy+ERp3WAUjLEFJE+02kanyHtwjWOnwrKYBiwAmM0p4kLJAnXg==",
       "dev": true,
       "license": "MIT",
       "engines": {
-        "node": ">=8"
+        "node": ">=12.0.0"
+      },
+      "peerDependencies": {
+        "picomatch": "^3 || ^4"
+      },
+      "peerDependenciesMeta": {
+        "picomatch": {
+          "optional": true
+        }
       }
     },
-    "node_modules/slash": {
-      "version": "3.0.0",
-      "resolved": "https://registry.npmjs.org/slash/-/slash-3.0.0.tgz",
-      "integrity": "sha512-g9Q1haeby36OSStwb4ntCGGGaKsaVSjQ68fBxoQcutl5fS1vuY18H3wSt3jFyFtrkx+Kz0V1G85A4MyAdDMi2Q==",
+    "node_modules/tinyglobby/node_modules/picomatch": {
+      "version": "4.0.3",
+      "resolved": "https://registry.npmjs.org/picomatch/-/picomatch-4.0.3.tgz",
+      "integrity": "sha512-5gTmgEY/sqK6gFXLIsQNH19lWb4ebPDLA4SdLP7dsWkIXHWlG66oPuVvXSGFPppYZz8ZDZq0dYYrbHfBCVUb1Q==",
       "dev": true,
       "license": "MIT",
       "engines": {
-        "node": ">=8"
+        "node": ">=12"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/jonschlinkert"
       }
     },
-    "node_modules/source-map-js": {
-      "version": "1.2.1",
-      "resolved": "https://registry.npmjs.org/source-map-js/-/source-map-js-1.2.1.tgz",
-      "integrity": "sha512-UXWMKhLOwVKb728IUtQPXxfYU+usdybtUrK/8uGE8CQMvrhOpwvzDBwj0QhSL7MQc7vIsISBG8VQ8+IDQxpfQA==",
+    "node_modules/tinypool": {
+      "version": "1.1.1",
+      "resolved": "https://registry.npmjs.org/tinypool/-/tinypool-1.1.1.tgz",
+      "integrity": "sha512-Zba82s87IFq9A9XmjiX5uZA/ARWDrB03OHlq+Vw1fSdt0I+4/Kutwy8BP4Y/y/aORMo61FQ0vIb5j44vSo5Pkg==",
       "dev": true,
-      "license": "BSD-3-Clause",
+      "license": "MIT",
       "engines": {
-        "node": ">=0.10.0"
+        "node": "^18.0.0 || >=20.0.0"
       }
     },
-    "node_modules/strip-ansi": {
-      "version": "6.0.1",
-      "resolved": "https://registry.npmjs.org/strip-ansi/-/strip-ansi-6.0.1.tgz",
-      "integrity": "sha512-Y38VPSHcqkFrCpFnQ9vuSXmquuv5oXOKpGeT6aGrr3o3Gc9AlVa6JBfUSOCnbxGGZF+/0ooI7KrPuUSztUdU5A==",
+    "node_modules/tinyqueue": {
+      "version": "3.0.0",
+      "resolved": "https://registry.npmjs.org/tinyqueue/-/tinyqueue-3.0.0.tgz",
+      "integrity": "sha512-gRa9gwYU3ECmQYv3lslts5hxuIa90veaEcxDYuu3QGOIAEM2mOZkVHp48ANJuu1CURtRdHKUBY5Lm1tHV+sD4g==",
+      "license": "ISC"
+    },
+    "node_modules/tinyrainbow": {
+      "version": "2.0.0",
+      "resolved": "https://registry.npmjs.org/tinyrainbow/-/tinyrainbow-2.0.0.tgz",
+      "integrity": "sha512-op4nsTR47R6p0vMUUoYl/a+ljLFVtlfaXkLQmqfLR1qHma1h/ysYk4hEXZ880bf2CYgTskvTa/e196Vd5dDQXw==",
       "dev": true,
       "license": "MIT",
-      "dependencies": {
-        "ansi-regex": "^5.0.1"
-      },
       "engines": {
-        "node": ">=8"
+        "node": ">=14.0.0"
       }
     },
-    "node_modules/strip-json-comments": {
-      "version": "3.1.1",
-      "resolved": "https://registry.npmjs.org/strip-json-comments/-/strip-json-comments-3.1.1.tgz",
-      "integrity": "sha512-6fPc+R4ihwqP6N/aIv2f1gMH8lOVtWQHoqC4yK6oSDVVocumAsfCqjkXnqiYMhmMwS/mEHLp7Vehlt3ql6lEig==",
+    "node_modules/tinyspy": {
+      "version": "4.0.4",
+      "resolved": "https://registry.npmjs.org/tinyspy/-/tinyspy-4.0.4.tgz",
+      "integrity": "sha512-azl+t0z7pw/z958Gy9svOTuzqIk6xq+NSheJzn5MMWtWTFywIacg2wUlzKFGtt3cthx0r2SxMK0yzJOR0IES7Q==",
       "dev": true,
       "license": "MIT",
       "engines": {
-        "node": ">=8"
-      },
-      "funding": {
-        "url": "https://github.com/sponsors/sindresorhus"
+        "node": ">=14.0.0"
       }
     },
-    "node_modules/supports-color": {
-      "version": "7.2.0",
-      "resolved": "https://registry.npmjs.org/supports-color/-/supports-color-7.2.0.tgz",
-      "integrity": "sha512-qpCAvRl9stuOHveKsn7HncJRvv501qIacKzQlO/+Lwxc9+0q2wLyv4Dfvt80/DPn2pqOBsJdDiogXGR9+OvwRw==",
+    "node_modules/tldts": {
+      "version": "7.0.18",
+      "resolved": "https://registry.npmjs.org/tldts/-/tldts-7.0.18.tgz",
+      "integrity": "sha512-lCcgTAgMxQ1JKOWrVGo6E69Ukbnx4Gc1wiYLRf6J5NN4HRYJtCby1rPF8rkQ4a6qqoFBK5dvjJ1zJ0F7VfDSvw==",
       "dev": true,
       "license": "MIT",
       "dependencies": {
-        "has-flag": "^4.0.0"
+        "tldts-core": "^7.0.18"
       },
-      "engines": {
-        "node": ">=8"
+      "bin": {
+        "tldts": "bin/cli.js"
       }
     },
-    "node_modules/text-table": {
-      "version": "0.2.0",
-      "resolved": "https://registry.npmjs.org/text-table/-/text-table-0.2.0.tgz",
-      "integrity": "sha512-N+8UisAXDGk8PFXP4HAzVR9nbfmVJ3zYLAWiTIoqC5v5isinhr+r5uaO8+7r3BMfuNIufIsA7RdpVgacC2cSpw==",
+    "node_modules/tldts-core": {
+      "version": "7.0.18",
+      "resolved": "https://registry.npmjs.org/tldts-core/-/tldts-core-7.0.18.tgz",
+      "integrity": "sha512-jqJC13oP4FFAahv4JT/0WTDrCF9Okv7lpKtOZUGPLiAnNbACcSg8Y8T+Z9xthOmRBqi/Sob4yi0TE0miRCvF7Q==",
       "dev": true,
       "license": "MIT"
     },
+    "node_modules/to-float32": {
+      "version": "1.1.0",
+      "resolved": "https://registry.npmjs.org/to-float32/-/to-float32-1.1.0.tgz",
+      "integrity": "sha512-keDnAusn/vc+R3iEiSDw8TOF7gPiTLdK1ArvWtYbJQiVfmRg6i/CAvbKq3uIS0vWroAC7ZecN3DjQKw3aSklUg==",
+      "license": "MIT",
+      "peer": true
+    },
+    "node_modules/to-px": {
+      "version": "1.0.1",
+      "resolved": "https://registry.npmjs.org/to-px/-/to-px-1.0.1.tgz",
+      "integrity": "sha512-2y3LjBeIZYL19e5gczp14/uRWFDtDUErJPVN3VU9a7SJO+RjGRtYR47aMN2bZgGlxvW4ZcEz2ddUPVHXcMfuXw==",
+      "license": "MIT",
+      "peer": true,
+      "dependencies": {
+        "parse-unit": "^1.0.1"
+      }
+    },
     "node_modules/to-regex-range": {
       "version": "5.0.1",
       "resolved": "https://registry.npmjs.org/to-regex-range/-/to-regex-range-5.0.1.tgz",
@@ -3302,6 +8056,47 @@
         "node": ">=8.0"
       }
     },
+    "node_modules/topojson-client": {
+      "version": "3.1.0",
+      "resolved": "https://registry.npmjs.org/topojson-client/-/topojson-client-3.1.0.tgz",
+      "integrity": "sha512-605uxS6bcYxGXw9qi62XyrV6Q3xwbndjachmNxu8HWTtVPxZfEJN9fd/SZS1Q54Sn2y0TMyMxFj/cJINqGHrKw==",
+      "license": "ISC",
+      "peer": true,
+      "dependencies": {
+        "commander": "2"
+      },
+      "bin": {
+        "topo2geo": "bin/topo2geo",
+        "topomerge": "bin/topomerge",
+        "topoquantize": "bin/topoquantize"
+      }
+    },
+    "node_modules/tough-cookie": {
+      "version": "6.0.0",
+      "resolved": "https://registry.npmjs.org/tough-cookie/-/tough-cookie-6.0.0.tgz",
+      "integrity": "sha512-kXuRi1mtaKMrsLUxz3sQYvVl37B0Ns6MzfrtV5DvJceE9bPyspOqk9xxv7XbZWcfLWbFmm997vl83qUWVJA64w==",
+      "dev": true,
+      "license": "BSD-3-Clause",
+      "dependencies": {
+        "tldts": "^7.0.5"
+      },
+      "engines": {
+        "node": ">=16"
+      }
+    },
+    "node_modules/tr46": {
+      "version": "6.0.0",
+      "resolved": "https://registry.npmjs.org/tr46/-/tr46-6.0.0.tgz",
+      "integrity": "sha512-bLVMLPtstlZ4iMQHpFHTR7GAGj2jxi8Dg0s2h2MafAE4uSWF98FC/3MomU51iQAMf8/qDUbKWf5GxuvvVcXEhw==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "punycode": "^2.3.1"
+      },
+      "engines": {
+        "node": ">=20"
+      }
+    },
     "node_modules/ts-api-utils": {
       "version": "1.4.3",
       "resolved": "https://registry.npmjs.org/ts-api-utils/-/ts-api-utils-1.4.3.tgz",
@@ -3315,6 +8110,19 @@
         "typescript": ">=4.2.0"
       }
     },
+    "node_modules/tslib": {
+      "version": "2.8.1",
+      "resolved": "https://registry.npmjs.org/tslib/-/tslib-2.8.1.tgz",
+      "integrity": "sha512-oJFu94HQb+KVduSUQL7wnpmqnfmLsOA/nAh6b6EH0wCEoK0/mPeXU6c3wKDV83MkOuHPRHtSXKKU99IBazS/2w==",
+      "license": "0BSD"
+    },
+    "node_modules/type": {
+      "version": "2.7.3",
+      "resolved": "https://registry.npmjs.org/type/-/type-2.7.3.tgz",
+      "integrity": "sha512-8j+1QmAbPvLZow5Qpi6NCaN8FB60p/6x8/vfNqOk/hC+HuvFZhL4+WfekuhQLiqFZXOgQdrs3B+XxEmCc6b3FQ==",
+      "license": "ISC",
+      "peer": true
+    },
     "node_modules/type-check": {
       "version": "0.4.0",
       "resolved": "https://registry.npmjs.org/type-check/-/type-check-0.4.0.tgz",
@@ -3341,6 +8149,24 @@
         "url": "https://github.com/sponsors/sindresorhus"
       }
     },
+    "node_modules/typedarray": {
+      "version": "0.0.6",
+      "resolved": "https://registry.npmjs.org/typedarray/-/typedarray-0.0.6.tgz",
+      "integrity": "sha512-/aCDEGatGvZ2BIk+HmLf4ifCJFwvKFNb9/JeZPMulfgFracn9QFcAf5GO8B/mweUjSoblS5In0cWhqpfs/5PQA==",
+      "license": "MIT",
+      "peer": true
+    },
+    "node_modules/typedarray-pool": {
+      "version": "1.2.0",
+      "resolved": "https://registry.npmjs.org/typedarray-pool/-/typedarray-pool-1.2.0.tgz",
+      "integrity": "sha512-YTSQbzX43yvtpfRtIDAYygoYtgT+Rpjuxy9iOpczrjpXLgGoyG7aS5USJXV2d3nn8uHTeb9rXDvzS27zUg5KYQ==",
+      "license": "MIT",
+      "peer": true,
+      "dependencies": {
+        "bit-twiddle": "^1.0.0",
+        "dup": "^1.0.0"
+      }
+    },
     "node_modules/typescript": {
       "version": "5.8.3",
       "resolved": "https://registry.npmjs.org/typescript/-/typescript-5.8.3.tgz",
@@ -3355,6 +8181,58 @@
         "node": ">=14.17"
       }
     },
+    "node_modules/typewise": {
+      "version": "1.0.3",
+      "resolved": "https://registry.npmjs.org/typewise/-/typewise-1.0.3.tgz",
+      "integrity": "sha512-aXofE06xGhaQSPzt8hlTY+/YWQhm9P0jYUp1f2XtmW/3Bk0qzXcyFWAtPoo2uTGQj1ZwbDuSyuxicq+aDo8lCQ==",
+      "license": "MIT",
+      "dependencies": {
+        "typewise-core": "^1.2.0"
+      }
+    },
+    "node_modules/typewise-core": {
+      "version": "1.2.0",
+      "resolved": "https://registry.npmjs.org/typewise-core/-/typewise-core-1.2.0.tgz",
+      "integrity": "sha512-2SCC/WLzj2SbUwzFOzqMCkz5amXLlxtJqDKTICqg30x+2DZxcfZN2MvQZmGfXWKNWaKK9pBPsvkcwv8bF/gxKg==",
+      "license": "MIT"
+    },
+    "node_modules/typical": {
+      "version": "7.3.0",
+      "resolved": "https://registry.npmjs.org/typical/-/typical-7.3.0.tgz",
+      "integrity": "sha512-ya4mg/30vm+DOWfBg4YK3j2WD6TWtRkCbasOJr40CseYENzCUby/7rIvXA99JGsQHeNxLbnXdyLLxKSv3tauFw==",
+      "license": "MIT",
+      "engines": {
+        "node": ">=12.17"
+      }
+    },
+    "node_modules/undici-types": {
+      "version": "7.16.0",
+      "resolved": "https://registry.npmjs.org/undici-types/-/undici-types-7.16.0.tgz",
+      "integrity": "sha512-Zz+aZWSj8LE6zoxD+xrjh4VfkIG8Ya6LvYkZqtUQGJPZjYl53ypCaUwWqo7eI0x66KBGeRo+mlBEkMSeSZ38Nw==",
+      "license": "MIT"
+    },
+    "node_modules/union-value": {
+      "version": "1.0.1",
+      "resolved": "https://registry.npmjs.org/union-value/-/union-value-1.0.1.tgz",
+      "integrity": "sha512-tJfXmxMeWYnczCVs7XAEvIV7ieppALdyepWMkHkwciRpZraG/xwT+s2JN8+pr1+8jCRf80FFzvr+MpQeeoF4Xg==",
+      "license": "MIT",
+      "dependencies": {
+        "arr-union": "^3.1.0",
+        "get-value": "^2.0.6",
+        "is-extendable": "^0.1.1",
+        "set-value": "^2.0.1"
+      },
+      "engines": {
+        "node": ">=0.10.0"
+      }
+    },
+    "node_modules/unquote": {
+      "version": "1.1.1",
+      "resolved": "https://registry.npmjs.org/unquote/-/unquote-1.1.1.tgz",
+      "integrity": "sha512-vRCqFv6UhXpWxZPyGDh/F3ZpNv8/qo7w6iufLpQg9aKnQ71qM4B5KiI7Mia9COcjEhrO9LueHpMYjYzsWH3OIg==",
+      "license": "MIT",
+      "peer": true
+    },
     "node_modules/update-browserslist-db": {
       "version": "1.1.3",
       "resolved": "https://registry.npmjs.org/update-browserslist-db/-/update-browserslist-db-1.1.3.tgz",
@@ -3386,6 +8264,13 @@
         "browserslist": ">= 4.21.0"
       }
     },
+    "node_modules/update-diff": {
+      "version": "1.1.0",
+      "resolved": "https://registry.npmjs.org/update-diff/-/update-diff-1.1.0.tgz",
+      "integrity": "sha512-rCiBPiHxZwT4+sBhEbChzpO5hYHjm91kScWgdHf4Qeafs6Ba7MBl+d9GlGv72bcTZQO0sLmtQS1pHSWoCLtN/A==",
+      "license": "MIT",
+      "peer": true
+    },
     "node_modules/uri-js": {
       "version": "4.4.1",
       "resolved": "https://registry.npmjs.org/uri-js/-/uri-js-4.4.1.tgz",
@@ -3396,6 +8281,13 @@
         "punycode": "^2.1.0"
       }
     },
+    "node_modules/util-deprecate": {
+      "version": "1.0.2",
+      "resolved": "https://registry.npmjs.org/util-deprecate/-/util-deprecate-1.0.2.tgz",
+      "integrity": "sha512-EPD5q1uXyFxJpCrLnCc1nHnq3gOa6DZBocAIiI2TaSCA7VCJ1UJDMagCzIkXNsUYfD1daK//LTEQ8xiIbrHtcw==",
+      "license": "MIT",
+      "peer": true
+    },
     "node_modules/vite": {
       "version": "5.4.19",
       "resolved": "https://registry.npmjs.org/vite/-/vite-5.4.19.tgz",
@@ -3456,6 +8348,241 @@
         }
       }
     },
+    "node_modules/vite-node": {
+      "version": "3.2.4",
+      "resolved": "https://registry.npmjs.org/vite-node/-/vite-node-3.2.4.tgz",
+      "integrity": "sha512-EbKSKh+bh1E1IFxeO0pg1n4dvoOTt0UDiXMd/qn++r98+jPO1xtJilvXldeuQ8giIB5IkpjCgMleHMNEsGH6pg==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "cac": "^6.7.14",
+        "debug": "^4.4.1",
+        "es-module-lexer": "^1.7.0",
+        "pathe": "^2.0.3",
+        "vite": "^5.0.0 || ^6.0.0 || ^7.0.0-0"
+      },
+      "bin": {
+        "vite-node": "vite-node.mjs"
+      },
+      "engines": {
+        "node": "^18.0.0 || ^20.0.0 || >=22.0.0"
+      },
+      "funding": {
+        "url": "https://opencollective.com/vitest"
+      }
+    },
+    "node_modules/vitest": {
+      "version": "3.2.4",
+      "resolved": "https://registry.npmjs.org/vitest/-/vitest-3.2.4.tgz",
+      "integrity": "sha512-LUCP5ev3GURDysTWiP47wRRUpLKMOfPh+yKTx3kVIEiu5KOMeqzpnYNsKyOoVrULivR8tLcks4+lga33Whn90A==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@types/chai": "^5.2.2",
+        "@vitest/expect": "3.2.4",
+        "@vitest/mocker": "3.2.4",
+        "@vitest/pretty-format": "^3.2.4",
+        "@vitest/runner": "3.2.4",
+        "@vitest/snapshot": "3.2.4",
+        "@vitest/spy": "3.2.4",
+        "@vitest/utils": "3.2.4",
+        "chai": "^5.2.0",
+        "debug": "^4.4.1",
+        "expect-type": "^1.2.1",
+        "magic-string": "^0.30.17",
+        "pathe": "^2.0.3",
+        "picomatch": "^4.0.2",
+        "std-env": "^3.9.0",
+        "tinybench": "^2.9.0",
+        "tinyexec": "^0.3.2",
+        "tinyglobby": "^0.2.14",
+        "tinypool": "^1.1.1",
+        "tinyrainbow": "^2.0.0",
+        "vite": "^5.0.0 || ^6.0.0 || ^7.0.0-0",
+        "vite-node": "3.2.4",
+        "why-is-node-running": "^2.3.0"
+      },
+      "bin": {
+        "vitest": "vitest.mjs"
+      },
+      "engines": {
+        "node": "^18.0.0 || ^20.0.0 || >=22.0.0"
+      },
+      "funding": {
+        "url": "https://opencollective.com/vitest"
+      },
+      "peerDependencies": {
+        "@edge-runtime/vm": "*",
+        "@types/debug": "^4.1.12",
+        "@types/node": "^18.0.0 || ^20.0.0 || >=22.0.0",
+        "@vitest/browser": "3.2.4",
+        "@vitest/ui": "3.2.4",
+        "happy-dom": "*",
+        "jsdom": "*"
+      },
+      "peerDependenciesMeta": {
+        "@edge-runtime/vm": {
+          "optional": true
+        },
+        "@types/debug": {
+          "optional": true
+        },
+        "@types/node": {
+          "optional": true
+        },
+        "@vitest/browser": {
+          "optional": true
+        },
+        "@vitest/ui": {
+          "optional": true
+        },
+        "happy-dom": {
+          "optional": true
+        },
+        "jsdom": {
+          "optional": true
+        }
+      }
+    },
+    "node_modules/vitest/node_modules/picomatch": {
+      "version": "4.0.3",
+      "resolved": "https://registry.npmjs.org/picomatch/-/picomatch-4.0.3.tgz",
+      "integrity": "sha512-5gTmgEY/sqK6gFXLIsQNH19lWb4ebPDLA4SdLP7dsWkIXHWlG66oPuVvXSGFPppYZz8ZDZq0dYYrbHfBCVUb1Q==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">=12"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/jonschlinkert"
+      }
+    },
+    "node_modules/vt-pbf": {
+      "version": "3.1.3",
+      "resolved": "https://registry.npmjs.org/vt-pbf/-/vt-pbf-3.1.3.tgz",
+      "integrity": "sha512-2LzDFzt0mZKZ9IpVF2r69G9bXaP2Q2sArJCmcCgvfTdCCZzSyz4aCLoQyUilu37Ll56tCblIZrXFIjNUpGIlmA==",
+      "license": "MIT",
+      "peer": true,
+      "dependencies": {
+        "@mapbox/point-geometry": "0.1.0",
+        "@mapbox/vector-tile": "^1.3.1",
+        "pbf": "^3.2.1"
+      }
+    },
+    "node_modules/vt-pbf/node_modules/@mapbox/point-geometry": {
+      "version": "0.1.0",
+      "resolved": "https://registry.npmjs.org/@mapbox/point-geometry/-/point-geometry-0.1.0.tgz",
+      "integrity": "sha512-6j56HdLTwWGO0fJPlrZtdU/B13q8Uwmo18Ck2GnGgN9PCFyKTZ3UbXeEdRFh18i9XQ92eH2VdtpJHpBD3aripQ==",
+      "license": "ISC",
+      "peer": true
+    },
+    "node_modules/vt-pbf/node_modules/@mapbox/vector-tile": {
+      "version": "1.3.1",
+      "resolved": "https://registry.npmjs.org/@mapbox/vector-tile/-/vector-tile-1.3.1.tgz",
+      "integrity": "sha512-MCEddb8u44/xfQ3oD+Srl/tNcQoqTw3goGk2oLsrFxOTc3dUp+kAnby3PvAeeBYSMSjSPD1nd1AJA6W49WnoUw==",
+      "license": "BSD-3-Clause",
+      "peer": true,
+      "dependencies": {
+        "@mapbox/point-geometry": "~0.1.0"
+      }
+    },
+    "node_modules/vt-pbf/node_modules/pbf": {
+      "version": "3.3.0",
+      "resolved": "https://registry.npmjs.org/pbf/-/pbf-3.3.0.tgz",
+      "integrity": "sha512-XDF38WCH3z5OV/OVa8GKUNtLAyneuzbCisx7QUCF8Q6Nutx0WnJrQe5O+kOtBlLfRNUws98Y58Lblp+NJG5T4Q==",
+      "license": "BSD-3-Clause",
+      "peer": true,
+      "dependencies": {
+        "ieee754": "^1.1.12",
+        "resolve-protobuf-schema": "^2.1.0"
+      },
+      "bin": {
+        "pbf": "bin/pbf"
+      }
+    },
+    "node_modules/w3c-xmlserializer": {
+      "version": "5.0.0",
+      "resolved": "https://registry.npmjs.org/w3c-xmlserializer/-/w3c-xmlserializer-5.0.0.tgz",
+      "integrity": "sha512-o8qghlI8NZHU1lLPrpi2+Uq7abh4GGPpYANlalzWxyWteJOCsr/P+oPBA49TOLu5FTZO4d3F9MnWJfiMo4BkmA==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "xml-name-validator": "^5.0.0"
+      },
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/weak-map": {
+      "version": "1.0.8",
+      "resolved": "https://registry.npmjs.org/weak-map/-/weak-map-1.0.8.tgz",
+      "integrity": "sha512-lNR9aAefbGPpHO7AEnY0hCFjz1eTkWCXYvkTRrTHs9qv8zJp+SkVYpzfLIFXQQiG3tVvbNFQgVg2bQS8YGgxyw==",
+      "license": "Apache-2.0",
+      "peer": true
+    },
+    "node_modules/webgl-context": {
+      "version": "2.2.0",
+      "resolved": "https://registry.npmjs.org/webgl-context/-/webgl-context-2.2.0.tgz",
+      "integrity": "sha512-q/fGIivtqTT7PEoF07axFIlHNk/XCPaYpq64btnepopSWvKNFkoORlQYgqDigBIuGA1ExnFd/GnSUnBNEPQY7Q==",
+      "license": "MIT",
+      "peer": true,
+      "dependencies": {
+        "get-canvas-context": "^1.0.1"
+      }
+    },
+    "node_modules/webidl-conversions": {
+      "version": "8.0.0",
+      "resolved": "https://registry.npmjs.org/webidl-conversions/-/webidl-conversions-8.0.0.tgz",
+      "integrity": "sha512-n4W4YFyz5JzOfQeA8oN7dUYpR+MBP3PIUsn2jLjWXwK5ASUzt0Jc/A5sAUZoCYFJRGF0FBKJ+1JjN43rNdsQzA==",
+      "dev": true,
+      "license": "BSD-2-Clause",
+      "engines": {
+        "node": ">=20"
+      }
+    },
+    "node_modules/wgsl_reflect": {
+      "version": "1.2.3",
+      "resolved": "https://registry.npmjs.org/wgsl_reflect/-/wgsl_reflect-1.2.3.tgz",
+      "integrity": "sha512-BQWBIsOn411M+ffBxmA6QRLvAOVbuz3Uk4NusxnqC1H7aeQcVLhdA3k2k/EFFFtqVjhz3z7JOOZF1a9hj2tv4Q==",
+      "license": "MIT"
+    },
+    "node_modules/whatwg-encoding": {
+      "version": "3.1.1",
+      "resolved": "https://registry.npmjs.org/whatwg-encoding/-/whatwg-encoding-3.1.1.tgz",
+      "integrity": "sha512-6qN4hJdMwfYBtE3YBTTHhoeuUrDBPZmbQaxWAqSALV/MeEnR5z1xd8UKud2RAkFoPkmB+hli1TZSnyi84xz1vQ==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "iconv-lite": "0.6.3"
+      },
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/whatwg-mimetype": {
+      "version": "4.0.0",
+      "resolved": "https://registry.npmjs.org/whatwg-mimetype/-/whatwg-mimetype-4.0.0.tgz",
+      "integrity": "sha512-QaKxh0eNIi2mE9p2vEdzfagOKHCcj1pJ56EEHGQOVxp8r9/iszLUUV7v89x9O1p/T+NlTM5W7jW6+cz4Fq1YVg==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/whatwg-url": {
+      "version": "15.1.0",
+      "resolved": "https://registry.npmjs.org/whatwg-url/-/whatwg-url-15.1.0.tgz",
+      "integrity": "sha512-2ytDk0kiEj/yu90JOAp44PVPUkO9+jVhyf+SybKlRHSDlvOOZhdPIrr7xTH64l4WixO2cP+wQIcgujkGBPPz6g==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "tr46": "^6.0.0",
+        "webidl-conversions": "^8.0.0"
+      },
+      "engines": {
+        "node": ">=20"
+      }
+    },
     "node_modules/which": {
       "version": "2.0.2",
       "resolved": "https://registry.npmjs.org/which/-/which-2.0.2.tgz",
@@ -3472,6 +8599,23 @@
         "node": ">= 8"
       }
     },
+    "node_modules/why-is-node-running": {
+      "version": "2.3.0",
+      "resolved": "https://registry.npmjs.org/why-is-node-running/-/why-is-node-running-2.3.0.tgz",
+      "integrity": "sha512-hUrmaWBdVDcxvYqnyh09zunKzROWjbZTiNy8dBEjkS7ehEDQibXJ7XvlmtbwuTclUiIyN+CyXQD4Vmko8fNm8w==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "siginfo": "^2.0.0",
+        "stackback": "0.0.2"
+      },
+      "bin": {
+        "why-is-node-running": "cli.js"
+      },
+      "engines": {
+        "node": ">=8"
+      }
+    },
     "node_modules/word-wrap": {
       "version": "1.2.5",
       "resolved": "https://registry.npmjs.org/word-wrap/-/word-wrap-1.2.5.tgz",
@@ -3482,13 +8626,80 @@
         "node": ">=0.10.0"
       }
     },
+    "node_modules/wordwrapjs": {
+      "version": "5.1.1",
+      "resolved": "https://registry.npmjs.org/wordwrapjs/-/wordwrapjs-5.1.1.tgz",
+      "integrity": "sha512-0yweIbkINJodk27gX9LBGMzyQdBDan3s/dEAiwBOj+Mf0PPyWL6/rikalkv8EeD0E8jm4o5RXEOrFTP3NXbhJg==",
+      "license": "MIT",
+      "engines": {
+        "node": ">=12.17"
+      }
+    },
+    "node_modules/world-calendars": {
+      "version": "1.0.4",
+      "resolved": "https://registry.npmjs.org/world-calendars/-/world-calendars-1.0.4.tgz",
+      "integrity": "sha512-VGRnLJS+xJmGDPodgJRnGIDwGu0s+Cr9V2HB3EzlDZ5n0qb8h5SJtGUEkjrphZYAglEiXZ6kiXdmk0H/h/uu/w==",
+      "license": "MIT",
+      "peer": true,
+      "dependencies": {
+        "object-assign": "^4.1.0"
+      }
+    },
     "node_modules/wrappy": {
       "version": "1.0.2",
       "resolved": "https://registry.npmjs.org/wrappy/-/wrappy-1.0.2.tgz",
       "integrity": "sha512-l4Sp/DRseor9wL6EvV2+TuQn63dMkPjZ/sp9XkghTEbV9KlPS1xUsZ3u7/IQO4wxtcFB4bgpQPRcR3QCvezPcQ==",
-      "dev": true,
       "license": "ISC"
     },
+    "node_modules/ws": {
+      "version": "8.18.3",
+      "resolved": "https://registry.npmjs.org/ws/-/ws-8.18.3.tgz",
+      "integrity": "sha512-PEIGCY5tSlUt50cqyMXfCzX+oOPqN0vuGqWzbcJ2xvnkzkq46oOpz7dQaTDBdfICb4N14+GARUDw2XV2N4tvzg==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">=10.0.0"
+      },
+      "peerDependencies": {
+        "bufferutil": "^4.0.1",
+        "utf-8-validate": ">=5.0.2"
+      },
+      "peerDependenciesMeta": {
+        "bufferutil": {
+          "optional": true
+        },
+        "utf-8-validate": {
+          "optional": true
+        }
+      }
+    },
+    "node_modules/xml-name-validator": {
+      "version": "5.0.0",
+      "resolved": "https://registry.npmjs.org/xml-name-validator/-/xml-name-validator-5.0.0.tgz",
+      "integrity": "sha512-EvGK8EJ3DhaHfbRlETOWAS5pO9MZITeauHKJyb8wyajUfQUenkIg2MvLDTZ4T/TgIcm3HU0TFBgWWboAZ30UHg==",
+      "dev": true,
+      "license": "Apache-2.0",
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/xmlchars": {
+      "version": "2.2.0",
+      "resolved": "https://registry.npmjs.org/xmlchars/-/xmlchars-2.2.0.tgz",
+      "integrity": "sha512-JZnDKK8B0RCDw84FNdDAIpZK+JuJw+s7Lz8nksI7SIuU3UXJJslUthsi+uWBUYOwPFwW7W7PRLRfUKpxjtjFCw==",
+      "dev": true,
+      "license": "MIT"
+    },
+    "node_modules/xtend": {
+      "version": "4.0.2",
+      "resolved": "https://registry.npmjs.org/xtend/-/xtend-4.0.2.tgz",
+      "integrity": "sha512-LKYU1iAXJXUgAXn9URjiu+MWhyUXHsvfp7mcuYm9dSUKK0/CjtrUwFAxD82/mCWbtLsGjFIad0wIsod4zrTAEQ==",
+      "license": "MIT",
+      "peer": true,
+      "engines": {
+        "node": ">=0.4"
+      }
+    },
     "node_modules/yallist": {
       "version": "3.1.1",
       "resolved": "https://registry.npmjs.org/yallist/-/yallist-3.1.1.tgz",
diff --git a/package.json b/package.json
index 39ddbc4..93923db 100644
--- a/package.json
+++ b/package.json
@@ -12,6 +12,9 @@
     "lint": "eslint . --ext ts,tsx --report-unused-disable-directives --max-warnings 0"
   },
   "devDependencies": {
+    "@testing-library/jest-dom": "^6.9.1",
+    "@testing-library/react": "^16.3.0",
+    "@testing-library/user-event": "^14.6.1",
     "@types/leaflet": "^1.9.8",
     "@types/react": "^18.2.66",
     "@types/react-dom": "^18.2.22",
@@ -21,16 +24,28 @@
     "eslint": "^8.57.0",
     "eslint-plugin-react-hooks": "^4.6.0",
     "eslint-plugin-react-refresh": "^0.4.6",
+    "jsdom": "^27.0.1",
     "typescript": "^5.2.2",
-    "vite": "^5.2.0"
+    "vite": "^5.2.0",
+    "vitest": "^3.2.4"
   },
   "dependencies": {
+    "@deck.gl/core": "^9.2.11",
+    "@deck.gl/layers": "^9.2.11",
+    "@deck.gl/mapbox": "^9.2.11",
+    "@loaders.gl/arrow": "^4.3.4",
+    "@types/react-plotly.js": "^2.6.4",
+    "apache-arrow": "^21.1.0",
     "chart.js": "^4.4.1",
     "chartjs-adapter-date-fns": "^3.0.0",
     "leaflet": "^1.9.4",
+    "maplibre-gl": "^5.21.0",
+    "plotly.js-dist-min": "^3.4.0",
     "react": "^18.2.0",
     "react-chartjs-2": "^5.2.0",
     "react-dom": "^18.2.0",
-    "react-leaflet": "^4.2.1"
+    "react-leaflet": "^4.2.1",
+    "react-map-gl": "^8.1.0",
+    "react-plotly.js": "^2.6.0"
   }
 }
diff --git a/pixi.lock b/pixi.lock
index 9672267..1280f4e 100644
--- a/pixi.lock
+++ b/pixi.lock
@@ -5,6 +5,8 @@ environments:
     - url: https://conda.anaconda.org/conda-forge/
     indexes:
     - https://pypi.org/simple
+    options:
+      pypi-prerelease-mode: if-necessary-or-explicit
     packages:
       linux-64:
       - conda: https://conda.anaconda.org/conda-forge/linux-64/_libgcc_mutex-0.1-conda_forge.tar.bz2
@@ -341,11 +343,14 @@ environments:
       - pypi: https://files.pythonhosted.org/packages/37/44/19e02745cae22bf96440141f94e15a69a1afaa3a64ddfc38004668fcdebf/debugpy-1.8.16-cp312-cp312-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl
       - pypi: https://files.pythonhosted.org/packages/4e/8c/f3147f5c4b73e7550fe5f9352eaa956ae838d5c51eb58e7a25b9f3e2643b/decorator-5.2.1-py3-none-any.whl
       - pypi: https://files.pythonhosted.org/packages/07/6c/aa3f2f849e01cb6a001cd8554a88d4c77c5c1a31c95bdf1cf9301e6d9ef4/defusedxml-0.7.1-py2.py3-none-any.whl
+      - pypi: https://files.pythonhosted.org/packages/6f/d6/8f9a6b1fbcc669108ec6a4d625a70be9e480b437ed9b70cd56b78cd577a6/duckdb-1.5.1-cp312-cp312-manylinux_2_26_x86_64.manylinux_2_28_x86_64.whl
       - pypi: https://files.pythonhosted.org/packages/7b/8f/c4d9bafc34ad7ad5d8dc16dd1347ee0e507a52c3adb6bfa8887e1c6a26ba/executing-2.2.0-py2.py3-none-any.whl
       - pypi: https://files.pythonhosted.org/packages/e5/47/d63c60f59a59467fda0f93f46335c9d18526d7071f025cb5b89d5353ea42/fastapi-0.116.1-py3-none-any.whl
       - pypi: https://files.pythonhosted.org/packages/cb/a8/20d0723294217e47de6d9e2e40fd4a9d2f7c4b6ef974babd482a59743694/fastjsonschema-2.21.2-py3-none-any.whl
       - pypi: https://files.pythonhosted.org/packages/cf/58/8acf1b3e91c58313ce5cb67df61001fc9dcd21be4fadb76c1a2d540e09ed/fqdn-1.5.1-py3-none-any.whl
       - pypi: https://files.pythonhosted.org/packages/ba/e1/2926925dfc37287661f755937df99dff399d3aea2163e11cfd08ca6af3b2/geojson_pydantic-2.0.0-py3-none-any.whl
+      - pypi: https://files.pythonhosted.org/packages/3c/78/6a04792ace63a93e162f1305392d500ae8ddcb620e7eb88a22fd622b35bb/geopandas-1.1.3-py3-none-any.whl
+      - pypi: https://files.pythonhosted.org/packages/50/1f/5155f55bd71cabd03765a4aac9ac446be129895271f73872c36ebd4b04b6/greenlet-3.3.2-cp312-cp312-manylinux_2_24_x86_64.manylinux_2_28_x86_64.whl
       - pypi: https://files.pythonhosted.org/packages/7e/f5/f66802a942d491edb555dd61e3a9961140fd64c90bce1eafd741609d334d/httpcore-1.0.9-py3-none-any.whl
       - pypi: https://files.pythonhosted.org/packages/2a/39/e50c7c3a983047577ee07d2a9e53faf5a69493943ec3f6a384bdc792deb2/httpx-0.28.1-py3-none-any.whl
       - pypi: https://files.pythonhosted.org/packages/2c/e1/e6716421ea10d38022b952c159d5161ca1193197fb744506875fbb87ea7b/iniconfig-2.1.0-py3-none-any.whl
@@ -389,14 +394,20 @@ environments:
       - pypi: https://files.pythonhosted.org/packages/ef/af/4fbc8cab944db5d21b7e2a5b8e9211a03a79852b1157e2c102fcc61ac440/pandocfilters-1.5.1-py2.py3-none-any.whl
       - pypi: https://files.pythonhosted.org/packages/c6/ac/dac4a63f978e4dcb3c6d3a78c4d8e0192a113d288502a1216950c41b1027/parso-0.8.4-py2.py3-none-any.whl
       - pypi: https://files.pythonhosted.org/packages/9e/c3/059298687310d527a58bb01f3b1965787ee3b40dce76752eda8b44e9a2c5/pexpect-4.9.0-py2.py3-none-any.whl
+      - pypi: https://files.pythonhosted.org/packages/f1/af/009958cbf23fac551a940d34e3206e6c7eed2b8c940d0c3afd1feb0b0589/playwright-1.58.0-py3-none-manylinux1_x86_64.whl
       - pypi: https://files.pythonhosted.org/packages/54/20/4d324d65cc6d9205fabedc306948156824eb9f0ee1633355a8f7ec5c66bf/pluggy-1.6.0-py3-none-any.whl
       - pypi: https://files.pythonhosted.org/packages/32/ae/ec06af4fe3ee72d16973474f122541746196aaa16cea6f66d18b963c6177/prometheus_client-0.22.1-py3-none-any.whl
       - pypi: https://files.pythonhosted.org/packages/ce/4f/5249960887b1fbe561d9ff265496d170b55a735b76724f10ef19f9e40716/prompt_toolkit-3.0.51-py3-none-any.whl
       - pypi: https://files.pythonhosted.org/packages/22/a6/858897256d0deac81a172289110f31629fc4cee19b6f01283303e18c8db3/ptyprocess-0.7.0-py2.py3-none-any.whl
       - pypi: https://files.pythonhosted.org/packages/8e/37/efad0257dc6e593a18957422533ff0f87ede7c9c6ea010a2177d738fb82f/pure_eval-0.2.3-py3-none-any.whl
+      - pypi: https://files.pythonhosted.org/packages/a0/c4/b4d4827c93ef43c01f599ef31453ccc1c132b353284fc6c87d535c233129/pyee-13.0.1-py3-none-any.whl
+      - pypi: https://files.pythonhosted.org/packages/36/f7/cf8bec9024625947e1a71441906f60a5fa6f9e4c441c4428037e73b1fcc8/pyogrio-0.12.1-cp312-cp312-manylinux_2_28_x86_64.whl
       - pypi: https://files.pythonhosted.org/packages/0f/7c/1b361a24d3087cd922ec1f6dfe02f230507d800ada3f922532f1f906a09e/pystac-1.13.0-py3-none-any.whl
       - pypi: https://files.pythonhosted.org/packages/29/16/c8a903f4c4dffe7a12843191437d7cd8e32751d5de349d45d3fe69544e87/pytest-8.4.1-py3-none-any.whl
+      - pypi: https://files.pythonhosted.org/packages/98/1c/b00940ab9eb8ede7897443b771987f2f4a76f06be02f1b3f01eb7567e24a/pytest_base_url-2.1.0-py3-none-any.whl
+      - pypi: https://files.pythonhosted.org/packages/76/61/4d333d8354ea2bea2c2f01bad0a4aa3c1262de20e1241f78e73360e9b620/pytest_playwright-0.7.2-py3-none-any.whl
       - pypi: https://files.pythonhosted.org/packages/08/20/0f2523b9e50a8052bc6a8b732dfc8568abbdc42010aef03a2d750bdab3b2/python_json_logger-3.3.0-py3-none-any.whl
+      - pypi: https://files.pythonhosted.org/packages/a4/62/02da182e544a51a5c3ccf4b03ab79df279f9c60c5e82d5e8bec7ca26ac11/python_slugify-8.0.4-py2.py3-none-any.whl
       - pypi: https://files.pythonhosted.org/packages/7e/0a/2356305c423a975000867de56888b79e44ec2192c690ff93c3109fd78081/pyzmq-27.0.1-cp312-abi3-manylinux_2_26_x86_64.manylinux_2_28_x86_64.whl
       - pypi: https://files.pythonhosted.org/packages/c1/b1/3baf80dc6d2b7bc27a95a67752d0208e410351e3feb4eb78de5f77454d8d/referencing-0.36.2-py3-none-any.whl
       - pypi: https://files.pythonhosted.org/packages/7b/44/4e421b96b67b2daff264473f7465db72fbdf36a07e05494f50300cc7b0c6/rfc3339_validator-0.1.4-py2.py3-none-any.whl
@@ -412,6 +423,7 @@ environments:
       - pypi: https://files.pythonhosted.org/packages/f7/1f/b876b1f83aef204198a42dc101613fefccb32258e5428b5f9259677864b4/starlette-0.47.2-py3-none-any.whl
       - pypi: https://files.pythonhosted.org/packages/bc/d6/dc0827918b19c836afd58904c8b856b9bba18b4a0ce0b4866f8f6b4cb42b/starlette_cramjam-0.5.0-py3-none-any.whl
       - pypi: https://files.pythonhosted.org/packages/6a/9e/2064975477fdc887e47ad42157e214526dcad8f317a948dee17e1659a62f/terminado-0.18.1-py3-none-any.whl
+      - pypi: https://files.pythonhosted.org/packages/a6/a5/c0b6468d3824fe3fde30dbb5e1f687b291608f9473681bbf7dabbf5a87d7/text_unidecode-1.3-py2.py3-none-any.whl
       - pypi: https://files.pythonhosted.org/packages/e6/34/ebdc18bae6aa14fbee1a08b63c015c72b64868ff7dae68808ab500c492e2/tinycss2-1.4.0-py3-none-any.whl
       - pypi: https://files.pythonhosted.org/packages/10/81/30e176b9ae631ac79e1ad3df3f693f876ffaada7e97d30bbffc97b00185c/titiler_core-0.22.4-py3-none-any.whl
       - pypi: https://files.pythonhosted.org/packages/77/25/1e8bf04e59593367e0fefc78c3f376e78bbdbd9d2fe07ac4dfa41b687745/titiler_xarray-0.22.4-py3-none-any.whl
@@ -695,11 +707,14 @@ environments:
       - pypi: https://files.pythonhosted.org/packages/52/57/ecc9ae29fa5b2d90107cd1d9bf8ed19aacb74b2264d986ae9d44fe9bdf87/debugpy-1.8.16-py2.py3-none-any.whl
       - pypi: https://files.pythonhosted.org/packages/4e/8c/f3147f5c4b73e7550fe5f9352eaa956ae838d5c51eb58e7a25b9f3e2643b/decorator-5.2.1-py3-none-any.whl
       - pypi: https://files.pythonhosted.org/packages/07/6c/aa3f2f849e01cb6a001cd8554a88d4c77c5c1a31c95bdf1cf9301e6d9ef4/defusedxml-0.7.1-py2.py3-none-any.whl
+      - pypi: https://files.pythonhosted.org/packages/87/03/293bccd838a293d42ea26dec7f4eb4f58b57b6c9ffcfabc6518a5f20a24a/duckdb-1.5.1-cp312-cp312-macosx_11_0_arm64.whl
       - pypi: https://files.pythonhosted.org/packages/7b/8f/c4d9bafc34ad7ad5d8dc16dd1347ee0e507a52c3adb6bfa8887e1c6a26ba/executing-2.2.0-py2.py3-none-any.whl
       - pypi: https://files.pythonhosted.org/packages/e5/47/d63c60f59a59467fda0f93f46335c9d18526d7071f025cb5b89d5353ea42/fastapi-0.116.1-py3-none-any.whl
       - pypi: https://files.pythonhosted.org/packages/cb/a8/20d0723294217e47de6d9e2e40fd4a9d2f7c4b6ef974babd482a59743694/fastjsonschema-2.21.2-py3-none-any.whl
       - pypi: https://files.pythonhosted.org/packages/cf/58/8acf1b3e91c58313ce5cb67df61001fc9dcd21be4fadb76c1a2d540e09ed/fqdn-1.5.1-py3-none-any.whl
       - pypi: https://files.pythonhosted.org/packages/ba/e1/2926925dfc37287661f755937df99dff399d3aea2163e11cfd08ca6af3b2/geojson_pydantic-2.0.0-py3-none-any.whl
+      - pypi: https://files.pythonhosted.org/packages/3c/78/6a04792ace63a93e162f1305392d500ae8ddcb620e7eb88a22fd622b35bb/geopandas-1.1.3-py3-none-any.whl
+      - pypi: https://files.pythonhosted.org/packages/ea/ab/1608e5a7578e62113506740b88066bf09888322a311cff602105e619bd87/greenlet-3.3.2-cp312-cp312-macosx_11_0_universal2.whl
       - pypi: https://files.pythonhosted.org/packages/7e/f5/f66802a942d491edb555dd61e3a9961140fd64c90bce1eafd741609d334d/httpcore-1.0.9-py3-none-any.whl
       - pypi: https://files.pythonhosted.org/packages/2a/39/e50c7c3a983047577ee07d2a9e53faf5a69493943ec3f6a384bdc792deb2/httpx-0.28.1-py3-none-any.whl
       - pypi: https://files.pythonhosted.org/packages/2c/e1/e6716421ea10d38022b952c159d5161ca1193197fb744506875fbb87ea7b/iniconfig-2.1.0-py3-none-any.whl
@@ -743,14 +758,20 @@ environments:
       - pypi: https://files.pythonhosted.org/packages/ef/af/4fbc8cab944db5d21b7e2a5b8e9211a03a79852b1157e2c102fcc61ac440/pandocfilters-1.5.1-py2.py3-none-any.whl
       - pypi: https://files.pythonhosted.org/packages/c6/ac/dac4a63f978e4dcb3c6d3a78c4d8e0192a113d288502a1216950c41b1027/parso-0.8.4-py2.py3-none-any.whl
       - pypi: https://files.pythonhosted.org/packages/9e/c3/059298687310d527a58bb01f3b1965787ee3b40dce76752eda8b44e9a2c5/pexpect-4.9.0-py2.py3-none-any.whl
+      - pypi: https://files.pythonhosted.org/packages/e0/40/59d34a756e02f8c670f0fee987d46f7ee53d05447d43cd114ca015cb168c/playwright-1.58.0-py3-none-macosx_11_0_arm64.whl
       - pypi: https://files.pythonhosted.org/packages/54/20/4d324d65cc6d9205fabedc306948156824eb9f0ee1633355a8f7ec5c66bf/pluggy-1.6.0-py3-none-any.whl
       - pypi: https://files.pythonhosted.org/packages/32/ae/ec06af4fe3ee72d16973474f122541746196aaa16cea6f66d18b963c6177/prometheus_client-0.22.1-py3-none-any.whl
       - pypi: https://files.pythonhosted.org/packages/ce/4f/5249960887b1fbe561d9ff265496d170b55a735b76724f10ef19f9e40716/prompt_toolkit-3.0.51-py3-none-any.whl
       - pypi: https://files.pythonhosted.org/packages/22/a6/858897256d0deac81a172289110f31629fc4cee19b6f01283303e18c8db3/ptyprocess-0.7.0-py2.py3-none-any.whl
       - pypi: https://files.pythonhosted.org/packages/8e/37/efad0257dc6e593a18957422533ff0f87ede7c9c6ea010a2177d738fb82f/pure_eval-0.2.3-py3-none-any.whl
+      - pypi: https://files.pythonhosted.org/packages/a0/c4/b4d4827c93ef43c01f599ef31453ccc1c132b353284fc6c87d535c233129/pyee-13.0.1-py3-none-any.whl
+      - pypi: https://files.pythonhosted.org/packages/ad/e0/656b6536549d41b5aec57e0deca1f269b4f17532f0636836f587e581603a/pyogrio-0.12.1-cp312-cp312-macosx_12_0_arm64.whl
       - pypi: https://files.pythonhosted.org/packages/0f/7c/1b361a24d3087cd922ec1f6dfe02f230507d800ada3f922532f1f906a09e/pystac-1.13.0-py3-none-any.whl
       - pypi: https://files.pythonhosted.org/packages/29/16/c8a903f4c4dffe7a12843191437d7cd8e32751d5de349d45d3fe69544e87/pytest-8.4.1-py3-none-any.whl
+      - pypi: https://files.pythonhosted.org/packages/98/1c/b00940ab9eb8ede7897443b771987f2f4a76f06be02f1b3f01eb7567e24a/pytest_base_url-2.1.0-py3-none-any.whl
+      - pypi: https://files.pythonhosted.org/packages/76/61/4d333d8354ea2bea2c2f01bad0a4aa3c1262de20e1241f78e73360e9b620/pytest_playwright-0.7.2-py3-none-any.whl
       - pypi: https://files.pythonhosted.org/packages/08/20/0f2523b9e50a8052bc6a8b732dfc8568abbdc42010aef03a2d750bdab3b2/python_json_logger-3.3.0-py3-none-any.whl
+      - pypi: https://files.pythonhosted.org/packages/a4/62/02da182e544a51a5c3ccf4b03ab79df279f9c60c5e82d5e8bec7ca26ac11/python_slugify-8.0.4-py2.py3-none-any.whl
       - pypi: https://files.pythonhosted.org/packages/0e/9b/c0957041067c7724b310f22c398be46399297c12ed834c3bc42200a2756f/pyzmq-27.0.1-cp312-abi3-macosx_10_15_universal2.whl
       - pypi: https://files.pythonhosted.org/packages/c1/b1/3baf80dc6d2b7bc27a95a67752d0208e410351e3feb4eb78de5f77454d8d/referencing-0.36.2-py3-none-any.whl
       - pypi: https://files.pythonhosted.org/packages/7b/44/4e421b96b67b2daff264473f7465db72fbdf36a07e05494f50300cc7b0c6/rfc3339_validator-0.1.4-py2.py3-none-any.whl
@@ -766,6 +787,7 @@ environments:
       - pypi: https://files.pythonhosted.org/packages/f7/1f/b876b1f83aef204198a42dc101613fefccb32258e5428b5f9259677864b4/starlette-0.47.2-py3-none-any.whl
       - pypi: https://files.pythonhosted.org/packages/bc/d6/dc0827918b19c836afd58904c8b856b9bba18b4a0ce0b4866f8f6b4cb42b/starlette_cramjam-0.5.0-py3-none-any.whl
       - pypi: https://files.pythonhosted.org/packages/6a/9e/2064975477fdc887e47ad42157e214526dcad8f317a948dee17e1659a62f/terminado-0.18.1-py3-none-any.whl
+      - pypi: https://files.pythonhosted.org/packages/a6/a5/c0b6468d3824fe3fde30dbb5e1f687b291608f9473681bbf7dabbf5a87d7/text_unidecode-1.3-py2.py3-none-any.whl
       - pypi: https://files.pythonhosted.org/packages/e6/34/ebdc18bae6aa14fbee1a08b63c015c72b64868ff7dae68808ab500c492e2/tinycss2-1.4.0-py3-none-any.whl
       - pypi: https://files.pythonhosted.org/packages/10/81/30e176b9ae631ac79e1ad3df3f693f876ffaada7e97d30bbffc97b00185c/titiler_core-0.22.4-py3-none-any.whl
       - pypi: https://files.pythonhosted.org/packages/77/25/1e8bf04e59593367e0fefc78c3f376e78bbdbd9d2fe07ac4dfa41b687745/titiler_xarray-0.22.4-py3-none-any.whl
@@ -784,6 +806,8 @@ environments:
     - url: https://conda.anaconda.org/conda-forge/
     indexes:
     - https://pypi.org/simple
+    options:
+      pypi-prerelease-mode: if-necessary-or-explicit
     packages:
       linux-64:
       - conda: https://conda.anaconda.org/conda-forge/linux-64/_libgcc_mutex-0.1-conda_forge.tar.bz2
@@ -1106,12 +1130,15 @@ environments:
       - pypi: https://files.pythonhosted.org/packages/00/f0/2ef431fe4141f5e334759d73e81120492b23b2824336883a91ac04ba710b/cachetools-6.1.0-py3-none-any.whl
       - pypi: https://files.pythonhosted.org/packages/e4/f4/e754800604d6449d895d7118b346bc2f3c5176cb759934b245aae530138d/color_operations-0.2.0-cp312-cp312-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl
       - pypi: https://files.pythonhosted.org/packages/6f/5e/2d9fa4d310c9fa7b1db0ba9f27ea64f2975810bb18ba64f2c13e5e5728c9/cramjam-2.10.0-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl
+      - pypi: https://files.pythonhosted.org/packages/6f/d6/8f9a6b1fbcc669108ec6a4d625a70be9e480b437ed9b70cd56b78cd577a6/duckdb-1.5.1-cp312-cp312-manylinux_2_26_x86_64.manylinux_2_28_x86_64.whl
       - pypi: https://files.pythonhosted.org/packages/e5/47/d63c60f59a59467fda0f93f46335c9d18526d7071f025cb5b89d5353ea42/fastapi-0.116.1-py3-none-any.whl
       - pypi: https://files.pythonhosted.org/packages/ba/e1/2926925dfc37287661f755937df99dff399d3aea2163e11cfd08ca6af3b2/geojson_pydantic-2.0.0-py3-none-any.whl
+      - pypi: https://files.pythonhosted.org/packages/3c/78/6a04792ace63a93e162f1305392d500ae8ddcb620e7eb88a22fd622b35bb/geopandas-1.1.3-py3-none-any.whl
       - pypi: https://files.pythonhosted.org/packages/7e/f5/f66802a942d491edb555dd61e3a9961140fd64c90bce1eafd741609d334d/httpcore-1.0.9-py3-none-any.whl
       - pypi: https://files.pythonhosted.org/packages/2a/39/e50c7c3a983047577ee07d2a9e53faf5a69493943ec3f6a384bdc792deb2/httpx-0.28.1-py3-none-any.whl
       - pypi: https://files.pythonhosted.org/packages/09/6c/6ca6ed6b93c9879e6a804515169faefcd99e02114ef113598de9b71d27be/morecantile-6.2.0-py3-none-any.whl
       - pypi: https://files.pythonhosted.org/packages/70/e8/15e0e077a004db0edd530da96c60c948689c888c464ee5d14b82405ebd86/numexpr-2.11.0-cp312-cp312-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl
+      - pypi: https://files.pythonhosted.org/packages/36/f7/cf8bec9024625947e1a71441906f60a5fa6f9e4c441c4428037e73b1fcc8/pyogrio-0.12.1-cp312-cp312-manylinux_2_28_x86_64.whl
       - pypi: https://files.pythonhosted.org/packages/0f/7c/1b361a24d3087cd922ec1f6dfe02f230507d800ada3f922532f1f906a09e/pystac-1.13.0-py3-none-any.whl
       - pypi: https://files.pythonhosted.org/packages/39/16/8a35212bb8433528e07d52bd1f56f193bed74666019b5e46f6bed9436bb4/rio_tiler-7.8.1-py3-none-any.whl
       - pypi: https://files.pythonhosted.org/packages/e0/bd/400b0bd372a5666addf2540c7358bfc3841b9ce5cdbc5cc4ad2f61627ad8/simplejson-3.20.1-cp312-cp312-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl
@@ -1376,12 +1403,15 @@ environments:
       - pypi: https://files.pythonhosted.org/packages/00/f0/2ef431fe4141f5e334759d73e81120492b23b2824336883a91ac04ba710b/cachetools-6.1.0-py3-none-any.whl
       - pypi: https://files.pythonhosted.org/packages/b1/57/13dbcc9913967489851f0b7d1c8d27840abe86e02d6e2e133d16db16d0d5/color_operations-0.2.0-cp312-cp312-macosx_11_0_arm64.whl
       - pypi: https://files.pythonhosted.org/packages/00/50/09b2cdeee0e757a902cb25559783b0d81aeea2b055034de55f57db64152f/cramjam-2.10.0-cp312-cp312-macosx_10_12_x86_64.macosx_11_0_arm64.macosx_10_12_universal2.whl
+      - pypi: https://files.pythonhosted.org/packages/87/03/293bccd838a293d42ea26dec7f4eb4f58b57b6c9ffcfabc6518a5f20a24a/duckdb-1.5.1-cp312-cp312-macosx_11_0_arm64.whl
       - pypi: https://files.pythonhosted.org/packages/e5/47/d63c60f59a59467fda0f93f46335c9d18526d7071f025cb5b89d5353ea42/fastapi-0.116.1-py3-none-any.whl
       - pypi: https://files.pythonhosted.org/packages/ba/e1/2926925dfc37287661f755937df99dff399d3aea2163e11cfd08ca6af3b2/geojson_pydantic-2.0.0-py3-none-any.whl
+      - pypi: https://files.pythonhosted.org/packages/3c/78/6a04792ace63a93e162f1305392d500ae8ddcb620e7eb88a22fd622b35bb/geopandas-1.1.3-py3-none-any.whl
       - pypi: https://files.pythonhosted.org/packages/7e/f5/f66802a942d491edb555dd61e3a9961140fd64c90bce1eafd741609d334d/httpcore-1.0.9-py3-none-any.whl
       - pypi: https://files.pythonhosted.org/packages/2a/39/e50c7c3a983047577ee07d2a9e53faf5a69493943ec3f6a384bdc792deb2/httpx-0.28.1-py3-none-any.whl
       - pypi: https://files.pythonhosted.org/packages/09/6c/6ca6ed6b93c9879e6a804515169faefcd99e02114ef113598de9b71d27be/morecantile-6.2.0-py3-none-any.whl
       - pypi: https://files.pythonhosted.org/packages/74/46/3a26b84e44f4739ec98de0ede4b95b4b8096f721e22d0e97517eeb02017e/numexpr-2.11.0-cp312-cp312-macosx_11_0_arm64.whl
+      - pypi: https://files.pythonhosted.org/packages/ad/e0/656b6536549d41b5aec57e0deca1f269b4f17532f0636836f587e581603a/pyogrio-0.12.1-cp312-cp312-macosx_12_0_arm64.whl
       - pypi: https://files.pythonhosted.org/packages/0f/7c/1b361a24d3087cd922ec1f6dfe02f230507d800ada3f922532f1f906a09e/pystac-1.13.0-py3-none-any.whl
       - pypi: https://files.pythonhosted.org/packages/39/16/8a35212bb8433528e07d52bd1f56f193bed74666019b5e46f6bed9436bb4/rio_tiler-7.8.1-py3-none-any.whl
       - pypi: https://files.pythonhosted.org/packages/0f/05/2b5ecb33b776c34bb5cace5de5d7669f9b60e3ca13c113037b2ca86edfbd/simplejson-3.20.1-cp312-cp312-macosx_11_0_arm64.whl
@@ -1396,6 +1426,8 @@ environments:
     - url: https://conda.anaconda.org/conda-forge/
     indexes:
     - https://pypi.org/simple
+    options:
+      pypi-prerelease-mode: if-necessary-or-explicit
     packages:
       linux-64:
       - conda: https://conda.anaconda.org/conda-forge/linux-64/_libgcc_mutex-0.1-conda_forge.tar.bz2
@@ -1720,9 +1752,12 @@ environments:
       - pypi: https://files.pythonhosted.org/packages/e4/f4/e754800604d6449d895d7118b346bc2f3c5176cb759934b245aae530138d/color_operations-0.2.0-cp312-cp312-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl
       - pypi: https://files.pythonhosted.org/packages/6f/5e/2d9fa4d310c9fa7b1db0ba9f27ea64f2975810bb18ba64f2c13e5e5728c9/cramjam-2.10.0-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl
       - pypi: https://files.pythonhosted.org/packages/4e/8c/f3147f5c4b73e7550fe5f9352eaa956ae838d5c51eb58e7a25b9f3e2643b/decorator-5.2.1-py3-none-any.whl
+      - pypi: https://files.pythonhosted.org/packages/6f/d6/8f9a6b1fbcc669108ec6a4d625a70be9e480b437ed9b70cd56b78cd577a6/duckdb-1.5.1-cp312-cp312-manylinux_2_26_x86_64.manylinux_2_28_x86_64.whl
       - pypi: https://files.pythonhosted.org/packages/7b/8f/c4d9bafc34ad7ad5d8dc16dd1347ee0e507a52c3adb6bfa8887e1c6a26ba/executing-2.2.0-py2.py3-none-any.whl
       - pypi: https://files.pythonhosted.org/packages/e5/47/d63c60f59a59467fda0f93f46335c9d18526d7071f025cb5b89d5353ea42/fastapi-0.116.1-py3-none-any.whl
       - pypi: https://files.pythonhosted.org/packages/ba/e1/2926925dfc37287661f755937df99dff399d3aea2163e11cfd08ca6af3b2/geojson_pydantic-2.0.0-py3-none-any.whl
+      - pypi: https://files.pythonhosted.org/packages/3c/78/6a04792ace63a93e162f1305392d500ae8ddcb620e7eb88a22fd622b35bb/geopandas-1.1.3-py3-none-any.whl
+      - pypi: https://files.pythonhosted.org/packages/50/1f/5155f55bd71cabd03765a4aac9ac446be129895271f73872c36ebd4b04b6/greenlet-3.3.2-cp312-cp312-manylinux_2_24_x86_64.manylinux_2_28_x86_64.whl
       - pypi: https://files.pythonhosted.org/packages/7e/f5/f66802a942d491edb555dd61e3a9961140fd64c90bce1eafd741609d334d/httpcore-1.0.9-py3-none-any.whl
       - pypi: https://files.pythonhosted.org/packages/2a/39/e50c7c3a983047577ee07d2a9e53faf5a69493943ec3f6a384bdc792deb2/httpx-0.28.1-py3-none-any.whl
       - pypi: https://files.pythonhosted.org/packages/2c/e1/e6716421ea10d38022b952c159d5161ca1193197fb744506875fbb87ea7b/iniconfig-2.1.0-py3-none-any.whl
@@ -1734,18 +1769,25 @@ environments:
       - pypi: https://files.pythonhosted.org/packages/70/e8/15e0e077a004db0edd530da96c60c948689c888c464ee5d14b82405ebd86/numexpr-2.11.0-cp312-cp312-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl
       - pypi: https://files.pythonhosted.org/packages/c6/ac/dac4a63f978e4dcb3c6d3a78c4d8e0192a113d288502a1216950c41b1027/parso-0.8.4-py2.py3-none-any.whl
       - pypi: https://files.pythonhosted.org/packages/9e/c3/059298687310d527a58bb01f3b1965787ee3b40dce76752eda8b44e9a2c5/pexpect-4.9.0-py2.py3-none-any.whl
+      - pypi: https://files.pythonhosted.org/packages/f1/af/009958cbf23fac551a940d34e3206e6c7eed2b8c940d0c3afd1feb0b0589/playwright-1.58.0-py3-none-manylinux1_x86_64.whl
       - pypi: https://files.pythonhosted.org/packages/54/20/4d324d65cc6d9205fabedc306948156824eb9f0ee1633355a8f7ec5c66bf/pluggy-1.6.0-py3-none-any.whl
       - pypi: https://files.pythonhosted.org/packages/ce/4f/5249960887b1fbe561d9ff265496d170b55a735b76724f10ef19f9e40716/prompt_toolkit-3.0.51-py3-none-any.whl
       - pypi: https://files.pythonhosted.org/packages/22/a6/858897256d0deac81a172289110f31629fc4cee19b6f01283303e18c8db3/ptyprocess-0.7.0-py2.py3-none-any.whl
       - pypi: https://files.pythonhosted.org/packages/8e/37/efad0257dc6e593a18957422533ff0f87ede7c9c6ea010a2177d738fb82f/pure_eval-0.2.3-py3-none-any.whl
+      - pypi: https://files.pythonhosted.org/packages/a0/c4/b4d4827c93ef43c01f599ef31453ccc1c132b353284fc6c87d535c233129/pyee-13.0.1-py3-none-any.whl
+      - pypi: https://files.pythonhosted.org/packages/36/f7/cf8bec9024625947e1a71441906f60a5fa6f9e4c441c4428037e73b1fcc8/pyogrio-0.12.1-cp312-cp312-manylinux_2_28_x86_64.whl
       - pypi: https://files.pythonhosted.org/packages/0f/7c/1b361a24d3087cd922ec1f6dfe02f230507d800ada3f922532f1f906a09e/pystac-1.13.0-py3-none-any.whl
       - pypi: https://files.pythonhosted.org/packages/29/16/c8a903f4c4dffe7a12843191437d7cd8e32751d5de349d45d3fe69544e87/pytest-8.4.1-py3-none-any.whl
+      - pypi: https://files.pythonhosted.org/packages/98/1c/b00940ab9eb8ede7897443b771987f2f4a76f06be02f1b3f01eb7567e24a/pytest_base_url-2.1.0-py3-none-any.whl
+      - pypi: https://files.pythonhosted.org/packages/76/61/4d333d8354ea2bea2c2f01bad0a4aa3c1262de20e1241f78e73360e9b620/pytest_playwright-0.7.2-py3-none-any.whl
+      - pypi: https://files.pythonhosted.org/packages/a4/62/02da182e544a51a5c3ccf4b03ab79df279f9c60c5e82d5e8bec7ca26ac11/python_slugify-8.0.4-py2.py3-none-any.whl
       - pypi: https://files.pythonhosted.org/packages/39/16/8a35212bb8433528e07d52bd1f56f193bed74666019b5e46f6bed9436bb4/rio_tiler-7.8.1-py3-none-any.whl
       - pypi: https://files.pythonhosted.org/packages/e0/bd/400b0bd372a5666addf2540c7358bfc3841b9ce5cdbc5cc4ad2f61627ad8/simplejson-3.20.1-cp312-cp312-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl
       - pypi: https://files.pythonhosted.org/packages/e9/44/75a9c9421471a6c4805dbf2356f7c181a29c1879239abab1ea2cc8f38b40/sniffio-1.3.1-py3-none-any.whl
       - pypi: https://files.pythonhosted.org/packages/f1/7b/ce1eafaf1a76852e2ec9b22edecf1daa58175c090266e9f6c64afcd81d91/stack_data-0.6.3-py3-none-any.whl
       - pypi: https://files.pythonhosted.org/packages/f7/1f/b876b1f83aef204198a42dc101613fefccb32258e5428b5f9259677864b4/starlette-0.47.2-py3-none-any.whl
       - pypi: https://files.pythonhosted.org/packages/bc/d6/dc0827918b19c836afd58904c8b856b9bba18b4a0ce0b4866f8f6b4cb42b/starlette_cramjam-0.5.0-py3-none-any.whl
+      - pypi: https://files.pythonhosted.org/packages/a6/a5/c0b6468d3824fe3fde30dbb5e1f687b291608f9473681bbf7dabbf5a87d7/text_unidecode-1.3-py2.py3-none-any.whl
       - pypi: https://files.pythonhosted.org/packages/10/81/30e176b9ae631ac79e1ad3df3f693f876ffaada7e97d30bbffc97b00185c/titiler_core-0.22.4-py3-none-any.whl
       - pypi: https://files.pythonhosted.org/packages/77/25/1e8bf04e59593367e0fefc78c3f376e78bbdbd9d2fe07ac4dfa41b687745/titiler_xarray-0.22.4-py3-none-any.whl
       - pypi: https://files.pythonhosted.org/packages/00/c0/8f5d070730d7836adc9c9b6408dec68c6ced86b304a9b26a14df072a6e8c/traitlets-5.14.3-py3-none-any.whl
@@ -2009,9 +2051,12 @@ environments:
       - pypi: https://files.pythonhosted.org/packages/b1/57/13dbcc9913967489851f0b7d1c8d27840abe86e02d6e2e133d16db16d0d5/color_operations-0.2.0-cp312-cp312-macosx_11_0_arm64.whl
       - pypi: https://files.pythonhosted.org/packages/00/50/09b2cdeee0e757a902cb25559783b0d81aeea2b055034de55f57db64152f/cramjam-2.10.0-cp312-cp312-macosx_10_12_x86_64.macosx_11_0_arm64.macosx_10_12_universal2.whl
       - pypi: https://files.pythonhosted.org/packages/4e/8c/f3147f5c4b73e7550fe5f9352eaa956ae838d5c51eb58e7a25b9f3e2643b/decorator-5.2.1-py3-none-any.whl
+      - pypi: https://files.pythonhosted.org/packages/87/03/293bccd838a293d42ea26dec7f4eb4f58b57b6c9ffcfabc6518a5f20a24a/duckdb-1.5.1-cp312-cp312-macosx_11_0_arm64.whl
       - pypi: https://files.pythonhosted.org/packages/7b/8f/c4d9bafc34ad7ad5d8dc16dd1347ee0e507a52c3adb6bfa8887e1c6a26ba/executing-2.2.0-py2.py3-none-any.whl
       - pypi: https://files.pythonhosted.org/packages/e5/47/d63c60f59a59467fda0f93f46335c9d18526d7071f025cb5b89d5353ea42/fastapi-0.116.1-py3-none-any.whl
       - pypi: https://files.pythonhosted.org/packages/ba/e1/2926925dfc37287661f755937df99dff399d3aea2163e11cfd08ca6af3b2/geojson_pydantic-2.0.0-py3-none-any.whl
+      - pypi: https://files.pythonhosted.org/packages/3c/78/6a04792ace63a93e162f1305392d500ae8ddcb620e7eb88a22fd622b35bb/geopandas-1.1.3-py3-none-any.whl
+      - pypi: https://files.pythonhosted.org/packages/ea/ab/1608e5a7578e62113506740b88066bf09888322a311cff602105e619bd87/greenlet-3.3.2-cp312-cp312-macosx_11_0_universal2.whl
       - pypi: https://files.pythonhosted.org/packages/7e/f5/f66802a942d491edb555dd61e3a9961140fd64c90bce1eafd741609d334d/httpcore-1.0.9-py3-none-any.whl
       - pypi: https://files.pythonhosted.org/packages/2a/39/e50c7c3a983047577ee07d2a9e53faf5a69493943ec3f6a384bdc792deb2/httpx-0.28.1-py3-none-any.whl
       - pypi: https://files.pythonhosted.org/packages/2c/e1/e6716421ea10d38022b952c159d5161ca1193197fb744506875fbb87ea7b/iniconfig-2.1.0-py3-none-any.whl
@@ -2023,18 +2068,25 @@ environments:
       - pypi: https://files.pythonhosted.org/packages/74/46/3a26b84e44f4739ec98de0ede4b95b4b8096f721e22d0e97517eeb02017e/numexpr-2.11.0-cp312-cp312-macosx_11_0_arm64.whl
       - pypi: https://files.pythonhosted.org/packages/c6/ac/dac4a63f978e4dcb3c6d3a78c4d8e0192a113d288502a1216950c41b1027/parso-0.8.4-py2.py3-none-any.whl
       - pypi: https://files.pythonhosted.org/packages/9e/c3/059298687310d527a58bb01f3b1965787ee3b40dce76752eda8b44e9a2c5/pexpect-4.9.0-py2.py3-none-any.whl
+      - pypi: https://files.pythonhosted.org/packages/e0/40/59d34a756e02f8c670f0fee987d46f7ee53d05447d43cd114ca015cb168c/playwright-1.58.0-py3-none-macosx_11_0_arm64.whl
       - pypi: https://files.pythonhosted.org/packages/54/20/4d324d65cc6d9205fabedc306948156824eb9f0ee1633355a8f7ec5c66bf/pluggy-1.6.0-py3-none-any.whl
       - pypi: https://files.pythonhosted.org/packages/ce/4f/5249960887b1fbe561d9ff265496d170b55a735b76724f10ef19f9e40716/prompt_toolkit-3.0.51-py3-none-any.whl
       - pypi: https://files.pythonhosted.org/packages/22/a6/858897256d0deac81a172289110f31629fc4cee19b6f01283303e18c8db3/ptyprocess-0.7.0-py2.py3-none-any.whl
       - pypi: https://files.pythonhosted.org/packages/8e/37/efad0257dc6e593a18957422533ff0f87ede7c9c6ea010a2177d738fb82f/pure_eval-0.2.3-py3-none-any.whl
+      - pypi: https://files.pythonhosted.org/packages/a0/c4/b4d4827c93ef43c01f599ef31453ccc1c132b353284fc6c87d535c233129/pyee-13.0.1-py3-none-any.whl
+      - pypi: https://files.pythonhosted.org/packages/ad/e0/656b6536549d41b5aec57e0deca1f269b4f17532f0636836f587e581603a/pyogrio-0.12.1-cp312-cp312-macosx_12_0_arm64.whl
       - pypi: https://files.pythonhosted.org/packages/0f/7c/1b361a24d3087cd922ec1f6dfe02f230507d800ada3f922532f1f906a09e/pystac-1.13.0-py3-none-any.whl
       - pypi: https://files.pythonhosted.org/packages/29/16/c8a903f4c4dffe7a12843191437d7cd8e32751d5de349d45d3fe69544e87/pytest-8.4.1-py3-none-any.whl
+      - pypi: https://files.pythonhosted.org/packages/98/1c/b00940ab9eb8ede7897443b771987f2f4a76f06be02f1b3f01eb7567e24a/pytest_base_url-2.1.0-py3-none-any.whl
+      - pypi: https://files.pythonhosted.org/packages/76/61/4d333d8354ea2bea2c2f01bad0a4aa3c1262de20e1241f78e73360e9b620/pytest_playwright-0.7.2-py3-none-any.whl
+      - pypi: https://files.pythonhosted.org/packages/a4/62/02da182e544a51a5c3ccf4b03ab79df279f9c60c5e82d5e8bec7ca26ac11/python_slugify-8.0.4-py2.py3-none-any.whl
       - pypi: https://files.pythonhosted.org/packages/39/16/8a35212bb8433528e07d52bd1f56f193bed74666019b5e46f6bed9436bb4/rio_tiler-7.8.1-py3-none-any.whl
       - pypi: https://files.pythonhosted.org/packages/0f/05/2b5ecb33b776c34bb5cace5de5d7669f9b60e3ca13c113037b2ca86edfbd/simplejson-3.20.1-cp312-cp312-macosx_11_0_arm64.whl
       - pypi: https://files.pythonhosted.org/packages/e9/44/75a9c9421471a6c4805dbf2356f7c181a29c1879239abab1ea2cc8f38b40/sniffio-1.3.1-py3-none-any.whl
       - pypi: https://files.pythonhosted.org/packages/f1/7b/ce1eafaf1a76852e2ec9b22edecf1daa58175c090266e9f6c64afcd81d91/stack_data-0.6.3-py3-none-any.whl
       - pypi: https://files.pythonhosted.org/packages/f7/1f/b876b1f83aef204198a42dc101613fefccb32258e5428b5f9259677864b4/starlette-0.47.2-py3-none-any.whl
       - pypi: https://files.pythonhosted.org/packages/bc/d6/dc0827918b19c836afd58904c8b856b9bba18b4a0ce0b4866f8f6b4cb42b/starlette_cramjam-0.5.0-py3-none-any.whl
+      - pypi: https://files.pythonhosted.org/packages/a6/a5/c0b6468d3824fe3fde30dbb5e1f687b291608f9473681bbf7dabbf5a87d7/text_unidecode-1.3-py2.py3-none-any.whl
       - pypi: https://files.pythonhosted.org/packages/10/81/30e176b9ae631ac79e1ad3df3f693f876ffaada7e97d30bbffc97b00185c/titiler_core-0.22.4-py3-none-any.whl
       - pypi: https://files.pythonhosted.org/packages/77/25/1e8bf04e59593367e0fefc78c3f376e78bbdbd9d2fe07ac4dfa41b687745/titiler_xarray-0.22.4-py3-none-any.whl
       - pypi: https://files.pythonhosted.org/packages/00/c0/8f5d070730d7836adc9c9b6408dec68c6ced86b304a9b26a14df072a6e8c/traitlets-5.14.3-py3-none-any.whl
@@ -2046,6 +2098,8 @@ environments:
     - url: https://conda.anaconda.org/conda-forge/
     indexes:
     - https://pypi.org/simple
+    options:
+      pypi-prerelease-mode: if-necessary-or-explicit
     packages:
       linux-64:
       - conda: https://conda.anaconda.org/conda-forge/linux-64/_libgcc_mutex-0.1-conda_forge.tar.bz2
@@ -2382,11 +2436,13 @@ environments:
       - pypi: https://files.pythonhosted.org/packages/37/44/19e02745cae22bf96440141f94e15a69a1afaa3a64ddfc38004668fcdebf/debugpy-1.8.16-cp312-cp312-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl
       - pypi: https://files.pythonhosted.org/packages/4e/8c/f3147f5c4b73e7550fe5f9352eaa956ae838d5c51eb58e7a25b9f3e2643b/decorator-5.2.1-py3-none-any.whl
       - pypi: https://files.pythonhosted.org/packages/07/6c/aa3f2f849e01cb6a001cd8554a88d4c77c5c1a31c95bdf1cf9301e6d9ef4/defusedxml-0.7.1-py2.py3-none-any.whl
+      - pypi: https://files.pythonhosted.org/packages/6f/d6/8f9a6b1fbcc669108ec6a4d625a70be9e480b437ed9b70cd56b78cd577a6/duckdb-1.5.1-cp312-cp312-manylinux_2_26_x86_64.manylinux_2_28_x86_64.whl
       - pypi: https://files.pythonhosted.org/packages/7b/8f/c4d9bafc34ad7ad5d8dc16dd1347ee0e507a52c3adb6bfa8887e1c6a26ba/executing-2.2.0-py2.py3-none-any.whl
       - pypi: https://files.pythonhosted.org/packages/e5/47/d63c60f59a59467fda0f93f46335c9d18526d7071f025cb5b89d5353ea42/fastapi-0.116.1-py3-none-any.whl
       - pypi: https://files.pythonhosted.org/packages/cb/a8/20d0723294217e47de6d9e2e40fd4a9d2f7c4b6ef974babd482a59743694/fastjsonschema-2.21.2-py3-none-any.whl
       - pypi: https://files.pythonhosted.org/packages/cf/58/8acf1b3e91c58313ce5cb67df61001fc9dcd21be4fadb76c1a2d540e09ed/fqdn-1.5.1-py3-none-any.whl
       - pypi: https://files.pythonhosted.org/packages/ba/e1/2926925dfc37287661f755937df99dff399d3aea2163e11cfd08ca6af3b2/geojson_pydantic-2.0.0-py3-none-any.whl
+      - pypi: https://files.pythonhosted.org/packages/3c/78/6a04792ace63a93e162f1305392d500ae8ddcb620e7eb88a22fd622b35bb/geopandas-1.1.3-py3-none-any.whl
       - pypi: https://files.pythonhosted.org/packages/7e/f5/f66802a942d491edb555dd61e3a9961140fd64c90bce1eafd741609d334d/httpcore-1.0.9-py3-none-any.whl
       - pypi: https://files.pythonhosted.org/packages/2a/39/e50c7c3a983047577ee07d2a9e53faf5a69493943ec3f6a384bdc792deb2/httpx-0.28.1-py3-none-any.whl
       - pypi: https://files.pythonhosted.org/packages/fc/c7/b445faca8deb954fe536abebff4ece5b097b923de482b26e78448c89d1dd/ipykernel-6.30.1-py3-none-any.whl
@@ -2433,6 +2489,7 @@ environments:
       - pypi: https://files.pythonhosted.org/packages/ce/4f/5249960887b1fbe561d9ff265496d170b55a735b76724f10ef19f9e40716/prompt_toolkit-3.0.51-py3-none-any.whl
       - pypi: https://files.pythonhosted.org/packages/22/a6/858897256d0deac81a172289110f31629fc4cee19b6f01283303e18c8db3/ptyprocess-0.7.0-py2.py3-none-any.whl
       - pypi: https://files.pythonhosted.org/packages/8e/37/efad0257dc6e593a18957422533ff0f87ede7c9c6ea010a2177d738fb82f/pure_eval-0.2.3-py3-none-any.whl
+      - pypi: https://files.pythonhosted.org/packages/36/f7/cf8bec9024625947e1a71441906f60a5fa6f9e4c441c4428037e73b1fcc8/pyogrio-0.12.1-cp312-cp312-manylinux_2_28_x86_64.whl
       - pypi: https://files.pythonhosted.org/packages/0f/7c/1b361a24d3087cd922ec1f6dfe02f230507d800ada3f922532f1f906a09e/pystac-1.13.0-py3-none-any.whl
       - pypi: https://files.pythonhosted.org/packages/08/20/0f2523b9e50a8052bc6a8b732dfc8568abbdc42010aef03a2d750bdab3b2/python_json_logger-3.3.0-py3-none-any.whl
       - pypi: https://files.pythonhosted.org/packages/7e/0a/2356305c423a975000867de56888b79e44ec2192c690ff93c3109fd78081/pyzmq-27.0.1-cp312-abi3-manylinux_2_26_x86_64.manylinux_2_28_x86_64.whl
@@ -2733,11 +2790,13 @@ environments:
       - pypi: https://files.pythonhosted.org/packages/52/57/ecc9ae29fa5b2d90107cd1d9bf8ed19aacb74b2264d986ae9d44fe9bdf87/debugpy-1.8.16-py2.py3-none-any.whl
       - pypi: https://files.pythonhosted.org/packages/4e/8c/f3147f5c4b73e7550fe5f9352eaa956ae838d5c51eb58e7a25b9f3e2643b/decorator-5.2.1-py3-none-any.whl
       - pypi: https://files.pythonhosted.org/packages/07/6c/aa3f2f849e01cb6a001cd8554a88d4c77c5c1a31c95bdf1cf9301e6d9ef4/defusedxml-0.7.1-py2.py3-none-any.whl
+      - pypi: https://files.pythonhosted.org/packages/87/03/293bccd838a293d42ea26dec7f4eb4f58b57b6c9ffcfabc6518a5f20a24a/duckdb-1.5.1-cp312-cp312-macosx_11_0_arm64.whl
       - pypi: https://files.pythonhosted.org/packages/7b/8f/c4d9bafc34ad7ad5d8dc16dd1347ee0e507a52c3adb6bfa8887e1c6a26ba/executing-2.2.0-py2.py3-none-any.whl
       - pypi: https://files.pythonhosted.org/packages/e5/47/d63c60f59a59467fda0f93f46335c9d18526d7071f025cb5b89d5353ea42/fastapi-0.116.1-py3-none-any.whl
       - pypi: https://files.pythonhosted.org/packages/cb/a8/20d0723294217e47de6d9e2e40fd4a9d2f7c4b6ef974babd482a59743694/fastjsonschema-2.21.2-py3-none-any.whl
       - pypi: https://files.pythonhosted.org/packages/cf/58/8acf1b3e91c58313ce5cb67df61001fc9dcd21be4fadb76c1a2d540e09ed/fqdn-1.5.1-py3-none-any.whl
       - pypi: https://files.pythonhosted.org/packages/ba/e1/2926925dfc37287661f755937df99dff399d3aea2163e11cfd08ca6af3b2/geojson_pydantic-2.0.0-py3-none-any.whl
+      - pypi: https://files.pythonhosted.org/packages/3c/78/6a04792ace63a93e162f1305392d500ae8ddcb620e7eb88a22fd622b35bb/geopandas-1.1.3-py3-none-any.whl
       - pypi: https://files.pythonhosted.org/packages/7e/f5/f66802a942d491edb555dd61e3a9961140fd64c90bce1eafd741609d334d/httpcore-1.0.9-py3-none-any.whl
       - pypi: https://files.pythonhosted.org/packages/2a/39/e50c7c3a983047577ee07d2a9e53faf5a69493943ec3f6a384bdc792deb2/httpx-0.28.1-py3-none-any.whl
       - pypi: https://files.pythonhosted.org/packages/fc/c7/b445faca8deb954fe536abebff4ece5b097b923de482b26e78448c89d1dd/ipykernel-6.30.1-py3-none-any.whl
@@ -2784,6 +2843,7 @@ environments:
       - pypi: https://files.pythonhosted.org/packages/ce/4f/5249960887b1fbe561d9ff265496d170b55a735b76724f10ef19f9e40716/prompt_toolkit-3.0.51-py3-none-any.whl
       - pypi: https://files.pythonhosted.org/packages/22/a6/858897256d0deac81a172289110f31629fc4cee19b6f01283303e18c8db3/ptyprocess-0.7.0-py2.py3-none-any.whl
       - pypi: https://files.pythonhosted.org/packages/8e/37/efad0257dc6e593a18957422533ff0f87ede7c9c6ea010a2177d738fb82f/pure_eval-0.2.3-py3-none-any.whl
+      - pypi: https://files.pythonhosted.org/packages/ad/e0/656b6536549d41b5aec57e0deca1f269b4f17532f0636836f587e581603a/pyogrio-0.12.1-cp312-cp312-macosx_12_0_arm64.whl
       - pypi: https://files.pythonhosted.org/packages/0f/7c/1b361a24d3087cd922ec1f6dfe02f230507d800ada3f922532f1f906a09e/pystac-1.13.0-py3-none-any.whl
       - pypi: https://files.pythonhosted.org/packages/08/20/0f2523b9e50a8052bc6a8b732dfc8568abbdc42010aef03a2d750bdab3b2/python_json_logger-3.3.0-py3-none-any.whl
       - pypi: https://files.pythonhosted.org/packages/0e/9b/c0957041067c7724b310f22c398be46399297c12ed834c3bc42200a2756f/pyzmq-27.0.1-cp312-abi3-macosx_10_15_universal2.whl
@@ -3701,8 +3761,8 @@ packages:
   timestamp: 1755158592822
 - pypi: ./
   name: bowser-insar
-  version: 0.1.0.post1.dev149+gd92e061cd.d20251016
-  sha256: d3752128378155cec22075b06a8bbb22f430c9b5a39089d6adbdf19138ae8163
+  version: 0.1.0.post1.dev185+g0f3093a52.d20260325
+  sha256: 1782e2b51c6e11538434b5d9cbcea785ecbd85c662f3b361cdfa2b79a3c2c66d
   requires_dist:
   - titiler-xarray[http,minimal]
   - starlette-cramjam
@@ -3714,6 +3774,10 @@ packages:
   - rioxarray
   - matplotlib
   - pydantic-settings
+  - geopandas
+  - pyarrow
+  - duckdb
+  - shapely>=2
   - requests ; extra == 'widget'
   - jupyter ; extra == 'widget'
   - matplotlib ; extra == 'widget'
@@ -3725,8 +3789,8 @@ packages:
   - httpx ; extra == 'test'
   - ipython ; extra == 'test'
   - types-python-dateutil ; extra == 'test'
+  - pytest-playwright ; extra == 'test'
   requires_python: '>=3.11'
-  editable: true
 - pypi: https://files.pythonhosted.org/packages/73/03/6b5370fc626e6f480c4a0b4cb25b3459d390745010618b21b4b573423a53/bqplot-0.12.45-py2.py3-none-any.whl
   name: bqplot
   version: 0.12.45
@@ -4416,6 +4480,30 @@ packages:
   purls: []
   size: 69544
   timestamp: 1739569648873
+- pypi: https://files.pythonhosted.org/packages/6f/d6/8f9a6b1fbcc669108ec6a4d625a70be9e480b437ed9b70cd56b78cd577a6/duckdb-1.5.1-cp312-cp312-manylinux_2_26_x86_64.manylinux_2_28_x86_64.whl
+  name: duckdb
+  version: 1.5.1
+  sha256: 8150c569b2aa4573b51ba8475e814aa41fd53a3d510c1ffb96f1139f46faf611
+  requires_dist:
+  - ipython ; extra == 'all'
+  - fsspec ; extra == 'all'
+  - numpy ; extra == 'all'
+  - pandas ; extra == 'all'
+  - pyarrow ; extra == 'all'
+  - adbc-driver-manager ; extra == 'all'
+  requires_python: '>=3.10.0'
+- pypi: https://files.pythonhosted.org/packages/87/03/293bccd838a293d42ea26dec7f4eb4f58b57b6c9ffcfabc6518a5f20a24a/duckdb-1.5.1-cp312-cp312-macosx_11_0_arm64.whl
+  name: duckdb
+  version: 1.5.1
+  sha256: ed6d23a3f806898e69c77430ebd8da0c79c219f97b9acbc9a29a653e09740c59
+  requires_dist:
+  - ipython ; extra == 'all'
+  - fsspec ; extra == 'all'
+  - numpy ; extra == 'all'
+  - pandas ; extra == 'all'
+  - pyarrow ; extra == 'all'
+  - adbc-driver-manager ; extra == 'all'
+  requires_python: '>=3.10.0'
 - conda: https://conda.anaconda.org/conda-forge/noarch/eval_type_backport-0.2.2-pyha770c72_0.conda
   sha256: 2d721421a60676216e10837a240c75e2190e093920a4016a469fa9a62c95ab5f
   md5: 8681d7f876da5e66a1c7fce424509383
@@ -4736,6 +4824,35 @@ packages:
   - pytest-cov ; extra == 'test'
   - shapely ; extra == 'test'
   requires_python: '>=3.9'
+- pypi: https://files.pythonhosted.org/packages/3c/78/6a04792ace63a93e162f1305392d500ae8ddcb620e7eb88a22fd622b35bb/geopandas-1.1.3-py3-none-any.whl
+  name: geopandas
+  version: 1.1.3
+  sha256: 90d62a64f95eaa3be2ccc115c5f3d6e24208bb11983b390fdc0621a3eccd0230
+  requires_dist:
+  - numpy>=1.24
+  - pyogrio>=0.7.2
+  - packaging
+  - pandas>=2.0.0
+  - pyproj>=3.5.0
+  - shapely>=2.0.0
+  - psycopg[binary]>=3.1.0 ; extra == 'all'
+  - sqlalchemy>=2.0 ; extra == 'all'
+  - geopy ; extra == 'all'
+  - matplotlib>=3.7 ; extra == 'all'
+  - mapclassify>=2.5 ; extra == 'all'
+  - xyzservices ; extra == 'all'
+  - folium ; extra == 'all'
+  - geoalchemy2 ; extra == 'all'
+  - pyarrow>=10.0.0 ; extra == 'all'
+  - scipy ; extra == 'all'
+  - pointpats>=2.5.3 ; extra == 'all'
+  - pytest>=3.1.0 ; extra == 'dev'
+  - pytest-cov ; extra == 'dev'
+  - pytest-xdist ; extra == 'dev'
+  - codecov ; extra == 'dev'
+  - pre-commit ; extra == 'dev'
+  - ruff ; extra == 'dev'
+  requires_python: '>=3.10'
 - conda: https://conda.anaconda.org/conda-forge/linux-64/geos-3.13.1-h97f6797_0.conda
   sha256: 3a9c854fa8cf1165015b6ee994d003c3d6a8b0f532ca22b6b29cd6e8d03942ed
   md5: 5bc18c66111bc94532b0d2df00731c66
@@ -4867,6 +4984,28 @@ packages:
   purls: []
   size: 99596
   timestamp: 1755102025473
+- pypi: https://files.pythonhosted.org/packages/50/1f/5155f55bd71cabd03765a4aac9ac446be129895271f73872c36ebd4b04b6/greenlet-3.3.2-cp312-cp312-manylinux_2_24_x86_64.manylinux_2_28_x86_64.whl
+  name: greenlet
+  version: 3.3.2
+  sha256: 43e99d1749147ac21dde49b99c9abffcbc1e2d55c67501465ef0930d6e78e070
+  requires_dist:
+  - sphinx ; extra == 'docs'
+  - furo ; extra == 'docs'
+  - objgraph ; extra == 'test'
+  - psutil ; extra == 'test'
+  - setuptools ; extra == 'test'
+  requires_python: '>=3.10'
+- pypi: https://files.pythonhosted.org/packages/ea/ab/1608e5a7578e62113506740b88066bf09888322a311cff602105e619bd87/greenlet-3.3.2-cp312-cp312-macosx_11_0_universal2.whl
+  name: greenlet
+  version: 3.3.2
+  sha256: ac8d61d4343b799d1e526db579833d72f23759c71e07181c2d2944e429eb09cd
+  requires_dist:
+  - sphinx ; extra == 'docs'
+  - furo ; extra == 'docs'
+  - objgraph ; extra == 'test'
+  - psutil ; extra == 'test'
+  - setuptools ; extra == 'test'
+  requires_python: '>=3.10'
 - conda: https://conda.anaconda.org/conda-forge/noarch/h11-0.16.0-pyhd8ed1ab_0.conda
   sha256: f64b68148c478c3bfc8f8d519541de7d2616bf59d44485a5271041d40c061887
   md5: 4b69232755285701bc86a5afe4d9933a
@@ -8957,6 +9096,22 @@ packages:
   - pkg:pypi/platformdirs?source=hash-mapping
   size: 23531
   timestamp: 1746710438805
+- pypi: https://files.pythonhosted.org/packages/e0/40/59d34a756e02f8c670f0fee987d46f7ee53d05447d43cd114ca015cb168c/playwright-1.58.0-py3-none-macosx_11_0_arm64.whl
+  name: playwright
+  version: 1.58.0
+  sha256: 70c763694739d28df71ed578b9c8202bb83e8fe8fb9268c04dd13afe36301f71
+  requires_dist:
+  - pyee>=13,<14
+  - greenlet>=3.1.1,<4.0.0
+  requires_python: '>=3.9'
+- pypi: https://files.pythonhosted.org/packages/f1/af/009958cbf23fac551a940d34e3206e6c7eed2b8c940d0c3afd1feb0b0589/playwright-1.58.0-py3-none-manylinux1_x86_64.whl
+  name: playwright
+  version: 1.58.0
+  sha256: c95568ba1eda83812598c1dc9be60b4406dffd60b149bc1536180ad108723d6b
+  requires_dist:
+  - pyee>=13,<14
+  - greenlet>=3.1.1,<4.0.0
+  requires_python: '>=3.9'
 - pypi: https://files.pythonhosted.org/packages/54/20/4d324d65cc6d9205fabedc306948156824eb9f0ee1633355a8f7ec5c66bf/pluggy-1.6.0-py3-none-any.whl
   name: pluggy
   version: 1.6.0
@@ -9297,6 +9452,35 @@ packages:
   - pkg:pypi/pydantic-settings?source=hash-mapping
   size: 38816
   timestamp: 1750801673349
+- pypi: https://files.pythonhosted.org/packages/a0/c4/b4d4827c93ef43c01f599ef31453ccc1c132b353284fc6c87d535c233129/pyee-13.0.1-py3-none-any.whl
+  name: pyee
+  version: 13.0.1
+  sha256: af2f8fede4171ef667dfded53f96e2ed0d6e6bd7ee3bb46437f77e3b57689228
+  requires_dist:
+  - typing-extensions
+  - build ; extra == 'dev'
+  - flake8 ; extra == 'dev'
+  - flake8-black ; extra == 'dev'
+  - pytest ; extra == 'dev'
+  - pytest-asyncio ; python_full_version >= '3.4' and extra == 'dev'
+  - pytest-trio ; python_full_version >= '3.7' and extra == 'dev'
+  - black ; extra == 'dev'
+  - isort ; extra == 'dev'
+  - jupyter-console ; extra == 'dev'
+  - mkdocs ; extra == 'dev'
+  - mkdocs-include-markdown-plugin ; extra == 'dev'
+  - mkdocstrings[python] ; extra == 'dev'
+  - mypy ; extra == 'dev'
+  - sphinx ; extra == 'dev'
+  - toml ; extra == 'dev'
+  - tox ; extra == 'dev'
+  - trio ; extra == 'dev'
+  - trio ; python_full_version >= '3.7' and extra == 'dev'
+  - trio-typing ; python_full_version >= '3.7' and extra == 'dev'
+  - twine ; extra == 'dev'
+  - twisted ; extra == 'dev'
+  - validate-pyproject[all] ; extra == 'dev'
+  requires_python: '>=3.8'
 - conda: https://conda.anaconda.org/conda-forge/noarch/pygments-2.19.2-pyhd8ed1ab_0.conda
   sha256: 5577623b9f6685ece2697c6eb7511b4c9ac5fb607c9babc2646c811b428fd46a
   md5: 6b6ece66ebcae2d5f326c77ef2c5a066
@@ -9308,6 +9492,34 @@ packages:
   - pkg:pypi/pygments?source=hash-mapping
   size: 889287
   timestamp: 1750615908735
+- pypi: https://files.pythonhosted.org/packages/36/f7/cf8bec9024625947e1a71441906f60a5fa6f9e4c441c4428037e73b1fcc8/pyogrio-0.12.1-cp312-cp312-manylinux_2_28_x86_64.whl
+  name: pyogrio
+  version: 0.12.1
+  sha256: 8b65be8c4258b27cc8f919b21929cecdadda4c353e3637fa30850339ef4d15c5
+  requires_dist:
+  - certifi
+  - numpy
+  - packaging
+  - cython>=3.1 ; extra == 'dev'
+  - pytest ; extra == 'test'
+  - pytest-cov ; extra == 'test'
+  - pytest-benchmark ; extra == 'benchmark'
+  - geopandas ; extra == 'geopandas'
+  requires_python: '>=3.10'
+- pypi: https://files.pythonhosted.org/packages/ad/e0/656b6536549d41b5aec57e0deca1f269b4f17532f0636836f587e581603a/pyogrio-0.12.1-cp312-cp312-macosx_12_0_arm64.whl
+  name: pyogrio
+  version: 0.12.1
+  sha256: 7a0d5ca39184030aec4cde30f4258f75b227a854530d2659babc8189d76e657d
+  requires_dist:
+  - certifi
+  - numpy
+  - packaging
+  - cython>=3.1 ; extra == 'dev'
+  - pytest ; extra == 'test'
+  - pytest-cov ; extra == 'test'
+  - pytest-benchmark ; extra == 'benchmark'
+  - geopandas ; extra == 'geopandas'
+  requires_python: '>=3.10'
 - conda: https://conda.anaconda.org/conda-forge/noarch/pyparsing-3.2.3-pyhe01879c_2.conda
   sha256: afe32182b1090911b64ac0f29eb47e03a015d142833d8a917defd65d91c99b74
   md5: aa0028616c0750c773698fdc254b2b8d
@@ -9419,6 +9631,29 @@ packages:
   - setuptools ; extra == 'dev'
   - xmlschema ; extra == 'dev'
   requires_python: '>=3.9'
+- pypi: https://files.pythonhosted.org/packages/98/1c/b00940ab9eb8ede7897443b771987f2f4a76f06be02f1b3f01eb7567e24a/pytest_base_url-2.1.0-py3-none-any.whl
+  name: pytest-base-url
+  version: 2.1.0
+  sha256: 3ad15611778764d451927b2a53240c1a7a591b521ea44cebfe45849d2d2812e6
+  requires_dist:
+  - pytest>=7.0.0
+  - requests>=2.9
+  - black>=22.1.0 ; extra == 'test'
+  - flake8>=4.0.1 ; extra == 'test'
+  - pre-commit>=2.17.0 ; extra == 'test'
+  - pytest-localserver>=0.7.1 ; extra == 'test'
+  - tox>=3.24.5 ; extra == 'test'
+  requires_python: '>=3.8'
+- pypi: https://files.pythonhosted.org/packages/76/61/4d333d8354ea2bea2c2f01bad0a4aa3c1262de20e1241f78e73360e9b620/pytest_playwright-0.7.2-py3-none-any.whl
+  name: pytest-playwright
+  version: 0.7.2
+  sha256: 8084e015b2b3ecff483c2160f1c8219b38b66c0d4578b23c0f700d1b0240ea38
+  requires_dist:
+  - playwright>=1.18
+  - pytest>=6.2.4,<10.0.0
+  - pytest-base-url>=1.0.0,<3.0.0
+  - python-slugify>=6.0.0,<9.0.0
+  requires_python: '>=3.10'
 - conda: https://conda.anaconda.org/conda-forge/linux-64/python-3.12.11-h9e4cc4f_0_cpython.conda
   sha256: 6cca004806ceceea9585d4d655059e951152fc774a471593d4f5138e6a54c81d
   md5: 94206474a5608243a10c92cefbe0908f
@@ -9519,6 +9754,14 @@ packages:
   - mkdocs-literate-nav ; extra == 'dev'
   - mike ; extra == 'dev'
   requires_python: '>=3.8'
+- pypi: https://files.pythonhosted.org/packages/a4/62/02da182e544a51a5c3ccf4b03ab79df279f9c60c5e82d5e8bec7ca26ac11/python_slugify-8.0.4-py2.py3-none-any.whl
+  name: python-slugify
+  version: 8.0.4
+  sha256: 276540b79961052b66b7d116620b36518847f52d5fd9e3a70164fc8c50faa6b8
+  requires_dist:
+  - text-unidecode>=1.3
+  - unidecode>=1.1.1 ; extra == 'unidecode'
+  requires_python: '>=3.7'
 - conda: https://conda.anaconda.org/conda-forge/noarch/python-tzdata-2025.2-pyhd8ed1ab_0.conda
   sha256: e8392a8044d56ad017c08fec2b0eb10ae3d1235ac967d0aab8bd7b41c4a5eaf0
   md5: 88476ae6ebd24f39261e0854ac244f33
@@ -10275,6 +10518,10 @@ packages:
   - mypy~=1.6 ; extra == 'typing'
   - traitlets>=5.11.1 ; extra == 'typing'
   requires_python: '>=3.8'
+- pypi: https://files.pythonhosted.org/packages/a6/a5/c0b6468d3824fe3fde30dbb5e1f687b291608f9473681bbf7dabbf5a87d7/text_unidecode-1.3-py2.py3-none-any.whl
+  name: text-unidecode
+  version: '1.3'
+  sha256: 1311f10e8b895935241623731c2ba64f4c455287888b18189350b67134a822e8
 - pypi: https://files.pythonhosted.org/packages/e6/34/ebdc18bae6aa14fbee1a08b63c015c72b64868ff7dae68808ab500c492e2/tinycss2-1.4.0-py3-none-any.whl
   name: tinycss2
   version: 1.4.0
diff --git a/pyproject.toml b/pyproject.toml
index 9917360..5bbe303 100644
--- a/pyproject.toml
+++ b/pyproject.toml
@@ -20,6 +20,11 @@ dependencies = [
   "rioxarray",
   "matplotlib",
   "pydantic-settings",
+  # V2: point cloud support
+  "geopandas",
+  "pyarrow",
+  "duckdb",
+  "shapely>=2",
 ]
 
 classifiers = [
@@ -50,7 +55,8 @@ widget = [
   "ipyleaflet",
   "bqplot>=0.12",
 ]
-test = ["pytest", "httpx", "ipython", "types-python-dateutil"]
+gps = ["geepers"]
+test = ["pytest", "httpx", "ipython", "types-python-dateutil", "pytest-playwright"]
 
 # [project.urls]
 # Homepage = "https://github.com/opera-adt/bowser"
@@ -92,7 +98,8 @@ python-dateutil = ">=2.9.0.post0,<3"
 default = { solve-group = "default" }
 widget = { features = ["widget"], solve-group = "default" }
 test = { features = ["test"], solve-group = "test" }
-all = { features = ["widget", "test"], solve-group = "all" }
+gps = { features = ["gps"], solve-group = "gps" }
+all = { features = ["widget", "gps", "test"], solve-group = "all" }
 
 [tool.pixi.tasks]
 
@@ -144,4 +151,8 @@ plugins = ["pydantic.mypy"]
 
 [tool.pytest.ini_options]
 addopts = "-W ignore::PendingDeprecationWarning "
-filterwarnings = ["error"]
+filterwarnings = [
+  "error",
+  "default::DeprecationWarning:shapely",
+  "default::DeprecationWarning:geopandas",
+]
diff --git a/src/bowser/_convert_dolphin.py b/src/bowser/_convert_dolphin.py
new file mode 100644
index 0000000..bcdfd59
--- /dev/null
+++ b/src/bowser/_convert_dolphin.py
@@ -0,0 +1,488 @@
+"""Convert dolphin raster outputs to GeoParquet point cloud format.
+
+Reads a dolphin workflow directory, masks by quality metrics, and exports
+surviving pixels as two GeoParquet files (points + timeseries) plus a
+bowser_manifest.json.
+"""
+
+from __future__ import annotations
+
+import concurrent.futures
+from datetime import datetime
+from glob import glob
+from pathlib import Path
+from typing import TYPE_CHECKING
+
+import numpy as np
+import pyarrow as pa
+import pyarrow.parquet as pq
+import rasterio as rio
+import rasterio.transform
+from pyproj import Transformer
+
+if TYPE_CHECKING:
+    from rasterio.crs import CRS
+    from rasterio.transform import Affine
+
+from .manifest import DatasetManifest, LosConfig, LosVectorConstant, PointLayerConfig
+
+
+def _find_dolphin_files(work_dir: str) -> dict[str, list[str]]:
+    """Discover dolphin output files in a workflow directory.
+
+    Parameters
+    ----------
+    work_dir : str
+        Path to dolphin workflow directory.
+
+    Returns
+    -------
+    dict[str, list[str]]
+        Mapping of dataset name to list of file paths.
+    """
+    wd = work_dir.rstrip("/")
+    candidates = {
+        # LOS vector files
+        "los_enu_json": glob(f"{wd}/**/los_enu.json", recursive=True),
+        "los_enu_tif": glob(f"{wd}/**/los_enu*.tif", recursive=True),
+        # Timeseries and quality
+        "timeseries": sorted(glob(f"{wd}/timeseries/2*[0-9].tif")),
+        "velocity": glob(f"{wd}/timeseries/velocity.tif"),
+        "velocity_stderr": glob(f"{wd}/timeseries/velocity_stderr.tif"),
+        "temporal_coherence": sorted(
+            glob(f"{wd}/interferograms/temporal_coherence_[0-9]*.tif")
+        ),
+        "temporal_coherence_average": glob(
+            f"{wd}/interferograms/temporal_coherence_average*.tif"
+        ),
+        "amplitude_dispersion": glob(f"{wd}/interferograms/amp_dispersion_looked*.tif"),
+        "phase_similarity": sorted(glob(f"{wd}/interferograms/similarity_[0-9]*.tif")),
+        "ps_mask": glob(f"{wd}/interferograms/ps_mask_looked*.tif"),
+    }
+    return {k: v for k, v in candidates.items() if v}
+
+
+def _detect_los_config(
+    dolphin_files: dict[str, list[str]],
+) -> tuple[str, dict] | None:
+    """Auto-detect LOS vector from dolphin output files.
+
+    Returns
+    -------
+    tuple or None
+        (type, config_dict) for the manifest LOS config, or None if not found.
+    """
+    import json as _json
+
+    # Prefer JSON constant (simpler, smaller)
+    if "los_enu_json" in dolphin_files and dolphin_files["los_enu_json"]:
+        json_path = dolphin_files["los_enu_json"][0]
+        data = _json.loads(Path(json_path).read_text())
+        # Standard format: {"los_enu_ground_to_satellite": {e, n, u}}
+        if "los_enu_ground_to_satellite" in data:
+            vec = data["los_enu_ground_to_satellite"]
+            return (
+                "constant",
+                {"east": vec["east"], "north": vec["north"], "up": vec["up"]},
+            )
+        # Also handle flat format: {"east": ..., "north": ..., "up": ...}
+        if "east" in data and "north" in data and "up" in data:
+            return (
+                "constant",
+                {"east": data["east"], "north": data["north"], "up": data["up"]},
+            )
+
+    # Fall back to GeoTIFF (spatially varying)
+    if "los_enu_tif" in dolphin_files and dolphin_files["los_enu_tif"]:
+        tif_path = dolphin_files["los_enu_tif"][0]
+        return ("geotiff", {"source": str(Path(tif_path).resolve())})
+
+    return None
+
+
+def _read_single_band(path: str) -> tuple[np.ndarray, Affine, CRS]:
+    """Read a single-band raster, returning data + georeference info."""
+    with rio.open(path) as src:
+        data = src.read(1)
+        return data, src.transform, src.crs
+
+
+def _build_mask(
+    dolphin_files: dict[str, list[str]],
+    coherence_threshold: float,
+    amplitude_dispersion_threshold: float | None,
+) -> tuple[np.ndarray, Affine, CRS]:
+    """Build a boolean mask of pixels that pass quality thresholds.
+
+    Parameters
+    ----------
+    dolphin_files : dict
+        Output of `_find_dolphin_files`.
+    coherence_threshold : float
+        Minimum temporal coherence to keep a pixel.
+    amplitude_dispersion_threshold : float or None
+        Maximum amplitude dispersion to keep a pixel (lower = more stable).
+
+    Returns
+    -------
+    mask : np.ndarray
+        Boolean array, True = keep this pixel.
+    transform : Affine
+        Georeferencing transform.
+    crs : CRS
+        Coordinate reference system.
+    """
+    # Use temporal coherence (average if available, else last single-date)
+    if "temporal_coherence_average" in dolphin_files:
+        coh_path = dolphin_files["temporal_coherence_average"][0]
+    elif "temporal_coherence" in dolphin_files:
+        coh_path = dolphin_files["temporal_coherence"][-1]
+    else:
+        msg = (
+            "No temporal coherence file found. "
+            "Cannot build quality mask without coherence data."
+        )
+        raise FileNotFoundError(msg)
+
+    coh_data, transform, crs = _read_single_band(coh_path)
+    mask = (coh_data > coherence_threshold) & np.isfinite(coh_data)
+
+    if (
+        amplitude_dispersion_threshold is not None
+        and "amplitude_dispersion" in dolphin_files
+    ):
+        amp_data, _, _ = _read_single_band(dolphin_files["amplitude_dispersion"][0])
+        amp_mask = (amp_data < amplitude_dispersion_threshold) & (amp_data > 0)
+        mask &= amp_mask
+
+    return mask, transform, crs
+
+
+def _pixel_coords_to_lonlat(
+    rows: np.ndarray,
+    cols: np.ndarray,
+    transform: rio.transform.Affine,
+    crs: rio.crs.CRS,
+) -> tuple[np.ndarray, np.ndarray]:
+    """Convert pixel row/col indices to WGS84 lon/lat arrays."""
+    # Pixel center coordinates in the raster's CRS
+    xs, ys = rio.transform.xy(transform, rows, cols)
+    xs = np.asarray(xs, dtype=np.float64)
+    ys = np.asarray(ys, dtype=np.float64)
+
+    if crs.to_epsg() == 4326:
+        return xs, ys
+
+    transformer = Transformer.from_crs(crs, "EPSG:4326", always_xy=True)
+    lons, lats = transformer.transform(xs, ys)
+    return np.asarray(lons), np.asarray(lats)
+
+
+def _read_static_attribute(path: str, mask: np.ndarray) -> np.ndarray:
+    """Read a single-band raster and extract values at masked pixel locations."""
+    data, _, _ = _read_single_band(path)
+    return data[mask].astype(np.float32)
+
+
+def _parse_dates_from_filenames(file_list: list[str]) -> list[datetime]:
+    """Extract dates from dolphin timeseries filenames like '20210606.tif'."""
+    from opera_utils import get_dates
+
+    dates = []
+    for f in file_list:
+        d = get_dates(f)
+        assert d, f"Could not parse date from {f}"
+        # For timeseries files, take the last date (secondary)
+        dates.append(d[-1])
+    return dates
+
+
+def convert_dolphin(
+    work_dir: str,
+    output_dir: str,
+    coherence_threshold: float = 0.5,
+    amplitude_dispersion_threshold: float | None = None,
+) -> Path:
+    """Convert a dolphin workflow directory to GeoParquet point cloud.
+
+    Parameters
+    ----------
+    work_dir : str
+        Path to dolphin workflow directory.
+    output_dir : str
+        Directory to write output files.
+    coherence_threshold : float
+        Minimum temporal coherence to include a pixel. Default 0.5.
+    amplitude_dispersion_threshold : float or None
+        Maximum amplitude dispersion to include a pixel. None to skip.
+
+    Returns
+    -------
+    Path
+        Path to the generated bowser_manifest.json.
+    """
+    import geopandas as gpd
+
+    output_path = Path(output_dir)
+    output_path.mkdir(parents=True, exist_ok=True)
+
+    print(f"Scanning dolphin outputs in {work_dir}...")
+    dolphin_files = _find_dolphin_files(work_dir)
+
+    assert (
+        "timeseries" in dolphin_files
+    ), f"No timeseries files found in {work_dir}/timeseries/"
+
+    # Build quality mask
+    print(f"Building quality mask (coherence > {coherence_threshold})...")
+    mask, transform, crs = _build_mask(
+        dolphin_files, coherence_threshold, amplitude_dispersion_threshold
+    )
+    n_points = int(mask.sum())
+    print(f"  {n_points:,} pixels pass quality threshold")
+
+    if n_points == 0:
+        print("No pixels pass quality threshold. Writing empty outputs.")
+        # Write empty GeoParquet files
+        import geopandas as gpd
+
+        empty_gdf = gpd.GeoDataFrame(
+            {"point_id": np.array([], dtype=np.uint64)},
+            geometry=[],
+            crs="EPSG:4326",
+        )
+        points_path = output_path / "points.parquet"
+        empty_gdf.to_parquet(points_path)
+
+        ts_table = pa.table(
+            {
+                "point_id": pa.array([], type=pa.uint64()),
+                "date": pa.array([], type=pa.date32()),
+                "displacement": pa.array([], type=pa.float32()),
+            }
+        )
+        ts_path = output_path / "timeseries.parquet"
+        pq.write_table(ts_table, ts_path)
+
+        manifest = DatasetManifest(
+            name=Path(work_dir).name,
+            layers={
+                "ps_points": PointLayerConfig(
+                    points_source=str(points_path),
+                    timeseries_source=str(ts_path),
+                ),
+            },
+        )
+        manifest_path = output_path / "bowser_manifest.json"
+        manifest.save(manifest_path)
+        return manifest_path
+
+    # Get pixel coordinates of surviving points
+    rows, cols = np.where(mask)
+    lons, lats = _pixel_coords_to_lonlat(rows, cols, transform, crs)
+
+    # Assign point IDs
+    point_ids = np.arange(n_points, dtype=np.uint64)
+
+    # Build points table — read static attributes in parallel
+    print("Reading static attributes...")
+    points_data: dict[str, np.ndarray] = {
+        "point_id": point_ids,
+    }
+    col_metadata: dict[str, dict[str, str]] = {
+        "point_id": {},
+    }
+
+    attr_reads: list[tuple[str, str, dict[str, str]]] = []
+    if "velocity" in dolphin_files:
+        attr_reads.append(
+            ("velocity", dolphin_files["velocity"][0], {"units": "mm/yr"})
+        )
+    if "velocity_stderr" in dolphin_files:
+        attr_reads.append(
+            ("velocity_std", dolphin_files["velocity_stderr"][0], {"units": "mm/yr"})
+        )
+    if "temporal_coherence_average" in dolphin_files:
+        attr_reads.append(
+            ("temporal_coherence", dolphin_files["temporal_coherence_average"][0], {})
+        )
+    elif "temporal_coherence" in dolphin_files:
+        attr_reads.append(
+            ("temporal_coherence", dolphin_files["temporal_coherence"][-1], {})
+        )
+    if "amplitude_dispersion" in dolphin_files:
+        attr_reads.append(
+            ("amplitude_dispersion", dolphin_files["amplitude_dispersion"][0], {})
+        )
+
+    with concurrent.futures.ThreadPoolExecutor() as pool:
+        futures = {
+            pool.submit(_read_static_attribute, path, mask): (name, md)
+            for name, path, md in attr_reads
+        }
+        for future in concurrent.futures.as_completed(futures):
+            name, md = futures[future]
+            points_data[name] = future.result()
+            col_metadata[name] = md
+
+    # Create GeoDataFrame using vectorized geometry construction
+    geometry = gpd.points_from_xy(lons, lats, crs="EPSG:4326")
+    gdf = gpd.GeoDataFrame(points_data, geometry=geometry, crs="EPSG:4326")
+
+    # Sort by spatial locality for better bbox query performance
+    # Use a simple Morton/Z-order approximation: interleave quantized lon/lat bits
+    gdf = gdf.sort_values(
+        by=["point_id"],
+        key=lambda _: _morton_key(lons, lats),
+    )
+
+    points_path = output_path / "points.parquet"
+    print(f"Writing {points_path} ({n_points:,} points)...")
+    gdf.to_parquet(points_path, row_group_size=100_000)
+
+    # Build time series table
+    ts_files = dolphin_files["timeseries"]
+    dates = _parse_dates_from_filenames(ts_files)
+    n_dates = len(dates)
+    print(f"Reading displacement time series ({n_dates} dates)...")
+
+    # Pre-allocate arrays for the long-form table
+    total_rows = n_points * n_dates
+    ts_point_ids = np.repeat(point_ids, n_dates)
+    date_list = [d.date() for d in dates]
+    ts_dates = date_list * n_points
+    ts_displacement = np.empty(total_rows, dtype=np.float32)
+
+    # Read each date's raster and extract values at masked pixels (parallel I/O)
+    def _read_masked(ts_file: str) -> np.ndarray:
+        data, _, _ = _read_single_band(ts_file)
+        return data[mask].astype(np.float32)
+
+    with concurrent.futures.ThreadPoolExecutor() as pool:
+        future_to_idx: dict[concurrent.futures.Future[np.ndarray], int] = {
+            pool.submit(_read_masked, f): i for i, f in enumerate(ts_files)
+        }
+        for future in concurrent.futures.as_completed(future_to_idx):
+            idx = future_to_idx[future]
+            ts_displacement[idx::n_dates] = future.result()
+
+    # Write timeseries as Parquet with row groups organized by point_id
+    # Each row group holds `points_per_group * n_dates` rows
+    points_per_group = max(1, 500)
+    row_group_size = points_per_group * n_dates
+
+    ts_table = pa.table(
+        {
+            "point_id": pa.array(ts_point_ids, type=pa.uint64()),
+            "date": pa.array(ts_dates, type=pa.date32()),
+            "displacement": pa.array(ts_displacement, type=pa.float32()),
+        }
+    )
+
+    ts_path = output_path / "timeseries.parquet"
+    print(f"Writing {ts_path} ({total_rows:,} rows, ~{row_group_size:,} rows/group)...")
+
+    # Add column metadata for units
+    ts_col_metadata = {"displacement": {"units": "mm"}}
+    ts_schema = ts_table.schema
+    new_fields = []
+    for field in ts_schema:
+        if field.name in ts_col_metadata:
+            field_md: dict = {
+                k.encode(): v.encode() for k, v in ts_col_metadata[field.name].items()
+            }
+            new_fields.append(field.with_metadata(field_md))
+        else:
+            new_fields.append(field)
+    ts_table = ts_table.cast(pa.schema(new_fields))
+
+    pq.write_table(ts_table, ts_path, row_group_size=row_group_size)
+
+    # Compute bounds
+    bounds = [
+        float(lons.min()),
+        float(lats.min()),
+        float(lons.max()),
+        float(lats.max()),
+    ]
+
+    # Detect LOS vector for GPS overlay
+    los_config = None
+    los_result = _detect_los_config(dolphin_files)
+    if los_result:
+        los_type, los_data = los_result
+        if los_type == "constant":
+            los_config = LosConfig(
+                type="constant",
+                los_enu=LosVectorConstant(**los_data),
+            )
+            e, n, u = los_data["east"], los_data["north"], los_data["up"]
+            print(f"  LOS vector: E={e:.3f}, N={n:.3f}, U={u:.3f}")
+        else:
+            los_config = LosConfig(type="geotiff", source=los_data["source"])
+            print(f"  LOS GeoTIFF: {los_data['source']}")
+    else:
+        print("  No LOS vector found (GPS overlay will not be available)")
+
+    # Generate manifest
+    manifest = DatasetManifest(
+        name=Path(work_dir).name,
+        description=f"Dolphin output converted from {work_dir}",
+        layers={
+            "ps_points": PointLayerConfig(
+                points_source=str(points_path),
+                timeseries_source=str(ts_path),
+                default_color_by="velocity",
+                default_colormap="RdBu_r",
+            ),
+        },
+        bounds=bounds,
+        los=los_config,
+    )
+
+    manifest_path = output_path / "bowser_manifest.json"
+    manifest.save(manifest_path)
+    print(f"Manifest written to {manifest_path}")
+
+    return manifest_path
+
+
+def _morton_key(lons: np.ndarray, lats: np.ndarray, bits: int = 16) -> np.ndarray:
+    """Compute approximate Morton/Z-order curve index for spatial sorting.
+
+    Interleaves quantized longitude and latitude bits to produce a sort key
+    that clusters spatially nearby points together.
+
+    Parameters
+    ----------
+    lons, lats : np.ndarray
+        Coordinate arrays.
+    bits : int
+        Quantization precision.
+
+    Returns
+    -------
+    np.ndarray
+        Integer sort keys (uint64).
+    """
+    # Normalize to [0, 2^bits)
+    lon_min, lon_max = lons.min(), lons.max()
+    lat_min, lat_max = lats.min(), lats.max()
+    lon_range = lon_max - lon_min if lon_max > lon_min else 1.0
+    lat_range = lat_max - lat_min if lat_max > lat_min else 1.0
+    max_val = (1 << bits) - 1
+
+    qlon = ((lons - lon_min) / lon_range * max_val).astype(np.uint64)
+    qlat = ((lats - lat_min) / lat_range * max_val).astype(np.uint64)
+
+    # Vectorized bit interleave using part1by1 (spread bits of x)
+    def _part1by1(x: np.ndarray) -> np.ndarray:
+        """Spread the lower 16 bits of x: insert a 0 bit between each."""
+        x = x & np.uint64(0x0000FFFF)
+        x = (x | (x << np.uint64(8))) & np.uint64(0x00FF00FF)
+        x = (x | (x << np.uint64(4))) & np.uint64(0x0F0F0F0F)
+        x = (x | (x << np.uint64(2))) & np.uint64(0x33333333)
+        x = (x | (x << np.uint64(1))) & np.uint64(0x55555555)
+        return x
+
+    return _part1by1(qlon) | (_part1by1(qlat) << np.uint64(1))
diff --git a/src/bowser/_convert_wide_parquet.py b/src/bowser/_convert_wide_parquet.py
new file mode 100644
index 0000000..ccfed2c
--- /dev/null
+++ b/src/bowser/_convert_wide_parquet.py
@@ -0,0 +1,246 @@
+"""Convert wide-form point cloud parquet to Bowser V2 two-table format.
+
+Handles parquet files where displacement time series are stored as
+wide-form date columns (e.g., from sarlet's export_points_to_parquet).
+"""
+
+from __future__ import annotations
+
+import re
+from datetime import datetime
+from pathlib import Path
+
+import numpy as np
+import pyarrow as pa
+import pyarrow.parquet as pq
+
+from .manifest import DatasetManifest, PointLayerConfig
+
+# Pattern for date-pair columns like "20240626_20240629"
+_DATE_PAIR_RE = re.compile(r"^(\d{8})_(\d{8})$")
+# Pattern for single-date columns like "20240626"
+_SINGLE_DATE_RE = re.compile(r"^(\d{8})$")
+
+
+def _identify_date_columns(
+    columns: list[str],
+) -> tuple[list[str], list[tuple[datetime, datetime | None]]]:
+    """Identify which columns are date/date-pair displacement values.
+
+    Parameters
+    ----------
+    columns : list[str]
+        All column names in the parquet file.
+
+    Returns
+    -------
+    date_cols : list[str]
+        Column names that match date patterns.
+    parsed_dates : list[tuple[datetime, datetime | None]]
+        Parsed (reference_date, secondary_date) pairs.
+        For single-date columns, secondary_date is None.
+    """
+    date_cols: list[str] = []
+    parsed_dates: list[tuple[datetime, datetime | None]] = []
+
+    for col in columns:
+        m = _DATE_PAIR_RE.match(col)
+        if m:
+            ref = datetime.strptime(m.group(1), "%Y%m%d")
+            sec = datetime.strptime(m.group(2), "%Y%m%d")
+            date_cols.append(col)
+            parsed_dates.append((ref, sec))
+            continue
+
+        m = _SINGLE_DATE_RE.match(col)
+        if m:
+            d = datetime.strptime(m.group(1), "%Y%m%d")
+            date_cols.append(col)
+            parsed_dates.append((d, None))
+
+    return date_cols, parsed_dates
+
+
+# Columns that are NOT date columns and NOT geometry/coordinate columns
+# These are static point attributes to keep in the points table
+_COORDINATE_COLS = {"longitude", "latitude", "geometry", "lon", "lat"}
+
+
+def convert_wide_parquet(
+    input_file: str,
+    output_dir: str,
+    layer_name: str = "ps_points",
+) -> Path:
+    """Convert a wide-form point cloud parquet to Bowser V2 two-table format.
+
+    Parameters
+    ----------
+    input_file : str
+        Path to the wide-form GeoParquet file.
+    output_dir : str
+        Directory to write output files.
+    layer_name : str
+        Name for the point layer in the manifest.
+
+    Returns
+    -------
+    Path
+        Path to the generated bowser_manifest.json.
+    """
+    output_path = Path(output_dir)
+    output_path.mkdir(parents=True, exist_ok=True)
+
+    print(f"Reading {input_file}...")
+    table = pq.read_table(input_file)
+    all_columns = table.column_names
+    n_points = len(table)
+    print(f"  {n_points:,} points, {len(all_columns)} columns")
+
+    # Identify date columns vs static attribute columns
+    date_cols, parsed_dates = _identify_date_columns(all_columns)
+    assert date_cols, f"No date columns found in {all_columns}"
+
+    n_dates = len(date_cols)
+    print(f"  {n_dates} date columns: {date_cols[0]} ... {date_cols[-1]}")
+
+    # Check if all date pairs share a reference date (single-reference time series)
+    ref_dates = {d[0] for d in parsed_dates}
+    if len(ref_dates) == 1:
+        ref_date = ref_dates.pop()
+        print(f"  Single reference date: {ref_date.strftime('%Y-%m-%d')}")
+        # For display, use secondary dates
+        display_dates = []
+        for _, sec in parsed_dates:
+            display_dates.append(sec if sec is not None else _)
+    else:
+        ref_date = None
+        # Use the first date in each pair
+        display_dates = [d[0] for d in parsed_dates]
+
+    # Separate static attributes from date columns
+    static_cols = [
+        c for c in all_columns if c not in date_cols and c not in _COORDINATE_COLS
+    ]
+    print(f"  Static attributes: {static_cols}")
+
+    # --- Build points table ---
+    # Add point_id
+    point_ids = np.arange(n_points, dtype=np.uint64)
+
+    # Extract geometry info from the GeoParquet
+    # Try to get lon/lat from explicit columns first, then from geometry
+    if "longitude" in all_columns and "latitude" in all_columns:
+        lons = table.column("longitude").to_numpy()
+        lats = table.column("latitude").to_numpy()
+    elif "lon" in all_columns and "lat" in all_columns:
+        lons = table.column("lon").to_numpy()
+        lats = table.column("lat").to_numpy()
+    else:
+        # Extract from WKB geometry column
+        import geopandas as gpd
+
+        gdf = gpd.read_parquet(input_file, columns=["geometry"])
+        lons = gdf.geometry.x.to_numpy()
+        lats = gdf.geometry.y.to_numpy()
+
+    # Build points Arrow table
+    points_columns = {
+        "point_id": pa.array(point_ids, type=pa.uint64()),
+    }
+    # Add static attributes, upcasting float16 to float32 for DuckDB compatibility
+    for col in static_cols:
+        arr = table.column(col)
+        if pa.types.is_float16(arr.type):
+            arr = arr.cast(pa.float32())
+        points_columns[col] = arr
+
+    # Add geometry as lon/lat (DuckDB will use these for spatial queries)
+    points_columns["longitude"] = pa.array(lons, type=pa.float64())
+    points_columns["latitude"] = pa.array(lats, type=pa.float64())
+
+    # Also preserve the WKB geometry column if present
+    if "geometry" in all_columns:
+        points_columns["geometry"] = table.column("geometry")
+
+    points_table = pa.table(points_columns)
+    points_path = output_path / "points.parquet"
+
+    # Preserve GeoParquet metadata if present
+    geo_meta = table.schema.metadata.get(b"geo") if table.schema.metadata else None
+    if geo_meta:
+        existing_meta = points_table.schema.metadata or {}
+        points_table = points_table.replace_schema_metadata(
+            {**existing_meta, b"geo": geo_meta}
+        )
+
+    print(
+        f"Writing {points_path} ({n_points:,} points, {len(static_cols)} attributes)..."
+    )
+    pq.write_table(points_table, points_path, row_group_size=100_000)
+
+    # --- Build time series table ---
+    # Melt wide format to long format: (point_id, date, displacement)
+    print(f"Melting {n_dates} date columns to long format...")
+
+    total_rows = n_points * n_dates
+    ts_point_ids = np.repeat(point_ids, n_dates)
+    ts_dates = [d.date() for d in display_dates] * n_points
+    ts_displacement = np.empty(total_rows, dtype=np.float32)
+
+    for i, col_name in enumerate(date_cols):
+        arr = table.column(col_name)
+        # float16 → float32 for DuckDB compatibility
+        if pa.types.is_float16(arr.type):
+            arr = arr.cast(pa.float32())
+        col_data = arr.to_numpy()
+        ts_displacement[i::n_dates] = col_data
+
+    # Row group size: ~500 points worth of dates per group
+    points_per_group = 500
+    row_group_size = points_per_group * n_dates
+
+    ts_table = pa.table(
+        {
+            "point_id": pa.array(ts_point_ids, type=pa.uint64()),
+            "date": pa.array(ts_dates, type=pa.date32()),
+            "displacement": pa.array(ts_displacement, type=pa.float32()),
+        }
+    )
+
+    ts_path = output_path / "timeseries.parquet"
+    print(
+        f"Writing {ts_path} ({total_rows:,} rows, "
+        f"~{row_group_size:,} rows/group)..."
+    )
+    pq.write_table(ts_table, ts_path, row_group_size=row_group_size)
+
+    # --- Build manifest ---
+    bounds = [
+        float(lons.min()),
+        float(lats.min()),
+        float(lons.max()),
+        float(lats.max()),
+    ]
+
+    default_color_by = "velocity" if "velocity" in static_cols else static_cols[0]
+
+    manifest = DatasetManifest(
+        name=Path(input_file).stem,
+        description=f"Converted from {input_file}",
+        reference_date=(ref_date.strftime("%Y-%m-%d") if ref_date else None),
+        layers={
+            layer_name: PointLayerConfig(
+                points_source=str(points_path.resolve()),
+                timeseries_source=str(ts_path.resolve()),
+                default_color_by=default_color_by,
+                default_colormap="RdBu_r",
+            ),
+        },
+        bounds=bounds,
+    )
+
+    manifest_path = output_path / "bowser_manifest.json"
+    manifest.save(manifest_path)
+    print(f"Manifest written to {manifest_path}")
+
+    return manifest_path
diff --git a/src/bowser/_generate_testdata.py b/src/bowser/_generate_testdata.py
new file mode 100644
index 0000000..9843f63
--- /dev/null
+++ b/src/bowser/_generate_testdata.py
@@ -0,0 +1,171 @@
+"""Generate synthetic GeoParquet test data for Bowser V2.
+
+Creates realistic-looking point cloud datasets with clustered spatial
+patterns and linear velocity trends, suitable for both automated testing
+and manual UI exploration.
+"""
+
+from __future__ import annotations
+
+from datetime import date, timedelta
+from pathlib import Path
+
+import geopandas as gpd
+import numpy as np
+import pyarrow as pa
+import pyarrow.parquet as pq
+from shapely.geometry import Point
+
+from .manifest import DatasetManifest, PointLayerConfig
+
+
+def generate_testdata(
+    output_dir: str | Path,
+    n_points: int = 50_000,
+    n_dates: int = 20,
+    center_lon: float = -99.13,
+    center_lat: float = 19.43,
+    spread_deg: float = 0.15,
+    layer_name: str = "synthetic",
+    seed: int = 42,
+) -> Path:
+    """Generate synthetic point cloud + timeseries GeoParquet files.
+
+    Parameters
+    ----------
+    output_dir
+        Directory to write output files.
+    n_points
+        Number of measurement points to generate.
+    n_dates
+        Number of SAR acquisition dates.
+    center_lon, center_lat
+        Center of the synthetic AOI.
+    spread_deg
+        Approximate radius of the AOI in degrees.
+    layer_name
+        Name for the point layer in the manifest.
+    seed
+        Random seed for reproducibility.
+
+    Returns
+    -------
+    Path
+        Path to the generated bowser_manifest.json.
+    """
+    rng = np.random.default_rng(seed)
+    out = Path(output_dir)
+    out.mkdir(parents=True, exist_ok=True)
+
+    print(f"Generating {n_points:,} points x {n_dates} dates...")
+
+    # --- Spatial distribution: clustered, not uniform random ---
+    # Create 5-10 clusters to simulate urban areas / subsidence bowls
+    n_clusters = rng.integers(5, 11)
+    cluster_centers = rng.normal(
+        loc=[[center_lon, center_lat]],
+        scale=spread_deg * 0.5,
+        size=(n_clusters, 2),
+    )
+    cluster_sizes = rng.dirichlet(np.ones(n_clusters)) * n_points
+    cluster_sizes = cluster_sizes.astype(int)
+    cluster_sizes[-1] = n_points - cluster_sizes[:-1].sum()  # fix rounding
+
+    lons = np.empty(n_points, dtype=np.float64)
+    lats = np.empty(n_points, dtype=np.float64)
+    cluster_ids = np.empty(n_points, dtype=np.int32)
+    idx = 0
+    for c_idx, (center, size) in enumerate(zip(cluster_centers, cluster_sizes)):
+        cluster_spread = rng.uniform(0.005, 0.03)
+        lons[idx : idx + size] = rng.normal(center[0], cluster_spread, size)
+        lats[idx : idx + size] = rng.normal(center[1], cluster_spread, size)
+        cluster_ids[idx : idx + size] = c_idx
+        idx += size
+
+    # --- Static attributes ---
+    # Velocity: clusters have different mean velocities (some subsiding)
+    cluster_velocities = rng.normal(0, 8, n_clusters)
+    # Make one cluster a clear subsidence bowl
+    cluster_velocities[0] = rng.uniform(-25, -15)
+    velocity = np.empty(n_points, dtype=np.float32)
+    for c_idx in range(n_clusters):
+        mask = cluster_ids == c_idx
+        velocity[mask] = rng.normal(cluster_velocities[c_idx], 2.0, mask.sum()).astype(
+            np.float32
+        )
+
+    temporal_coherence = rng.uniform(0.3, 1.0, n_points).astype(np.float32)
+    amplitude_dispersion = rng.uniform(0.05, 0.5, n_points).astype(np.float32)
+
+    # --- Points GeoParquet ---
+    geometry = [Point(lon, lat) for lon, lat in zip(lons, lats)]
+    gdf = gpd.GeoDataFrame(
+        {
+            "point_id": np.arange(n_points, dtype=np.uint64),
+            "velocity": velocity,
+            "temporal_coherence": temporal_coherence,
+            "amplitude_dispersion": amplitude_dispersion,
+            "longitude": lons.astype(np.float64),
+            "latitude": lats.astype(np.float64),
+        },
+        geometry=geometry,
+        crs="EPSG:4326",
+    )
+
+    points_path = out / "points.parquet"
+    gdf.to_parquet(points_path, row_group_size=min(100_000, n_points))
+    print(f"  Wrote {points_path} ({n_points:,} points)")
+
+    # --- Timeseries ---
+    start_date = date(2020, 1, 1)
+    dates = [start_date + timedelta(days=i * 12) for i in range(n_dates)]
+    date_strings = [d.isoformat() for d in dates]
+
+    total_rows = n_points * n_dates
+    ts_point_ids = np.repeat(np.arange(n_points, dtype=np.uint64), n_dates)
+
+    # Compute displacement: linear velocity * time + noise
+    days_from_start = np.array([(d - start_date).days for d in dates], dtype=np.float32)
+    disp = np.outer(velocity / 365.25, days_from_start)
+    noise = rng.normal(0, 1.5, (n_points, n_dates)).astype(np.float32)
+    disp = (disp + noise).astype(np.float32).ravel()
+
+    ts_dates_repeated = np.tile(date_strings, n_points)
+
+    ts_table = pa.table(
+        {
+            "point_id": pa.array(ts_point_ids, type=pa.uint64()),
+            "date": pa.array(ts_dates_repeated, type=pa.string()),
+            "displacement": pa.array(disp, type=pa.float32()),
+        }
+    )
+
+    ts_path = out / "timeseries.parquet"
+    row_group_size = min(n_points, 500) * n_dates
+    pq.write_table(ts_table, ts_path, row_group_size=row_group_size)
+    print(f"  Wrote {ts_path} ({total_rows:,} rows)")
+
+    # --- Manifest ---
+    manifest = DatasetManifest(
+        name=f"synthetic_{n_points // 1000}k",
+        description=f"Synthetic test data: {n_points:,} points, {n_dates} dates",
+        layers={
+            layer_name: PointLayerConfig(
+                points_source=str(points_path.resolve()),
+                timeseries_source=str(ts_path.resolve()),
+                default_color_by="velocity",
+            ),
+        },
+        bounds=[
+            float(lons.min()),
+            float(lats.min()),
+            float(lons.max()),
+            float(lats.max()),
+        ],
+    )
+
+    manifest_path = out / "bowser_manifest.json"
+    manifest.save(manifest_path)
+    print(f"  Wrote {manifest_path}")
+    print(f"\nTo view:\n  bowser run --manifest {manifest_path}")
+    return manifest_path
diff --git a/src/bowser/cli.py b/src/bowser/cli.py
index b5a8f0d..d95370f 100644
--- a/src/bowser/cli.py
+++ b/src/bowser/cli.py
@@ -23,6 +23,13 @@ def cli_app():
     default="bowser_rasters.json",
     help="Name of JSON file from `bowser set-data`.",
 )
+@click.option(
+    "-m",
+    "--manifest",
+    "manifest_file",
+    default=None,
+    help="Path to bowser_manifest.json (V2 mode with point layer support).",
+)
 @click.option(
     "--port",
     "-p",
@@ -72,9 +79,18 @@ def cli_app():
     is_flag=True,
     help="Don't use recommended mask for `displacement` ",
 )
+@click.option(
+    "--los",
+    default=None,
+    help=(
+        "LOS vector for GPS overlay. Either a path to los_enu.json or inline JSON"
+        ' like \'{"east": 0.477, "north": -0.449, "up": 0.755}\''
+    ),
+)
 def run(
     stack_file,
     rasters_file,
+    manifest_file,
     port,
     reload,
     workers,
@@ -82,6 +98,7 @@ def run(
     ignore_sidecar_files,
     no_spatial_reference,
     no_recommended_mask,
+    los,
 ):
     """Run the web server."""
     import uvicorn
@@ -89,7 +106,11 @@ def run(
     if port is None:
         port = _find_available_port(8000)
     _setup_gdal_env(ignore_sidecar_files)
-    if stack_file:
+    if manifest_file:
+        os.environ["BOWSER_MANIFEST_FILE"] = manifest_file
+    if los:
+        os.environ["BOWSER_LOS_CONFIG"] = los
+    elif stack_file:
         os.environ["BOWSER_STACK_DATA_FILE"] = stack_file
     else:
         os.environ["BOWSER_DATASET_CONFIG_FILE"] = rasters_file
@@ -263,21 +284,35 @@ def _glob(g):
 
     dolphin_outputs = [
         {
-            "name": "time series",
+            "name": "Time series",
             "file_list": _glob(f"{wd}/timeseries/2*[0-9].tif"),
             "uses_spatial_ref": True,
             "algorithm": Algorithm.SHIFT.value,
         },
         {
-            "name": "velocity",
+            "name": "Velocity",
             "file_list": [f"{wd}/timeseries/velocity.tif"],
             "uses_spatial_ref": True,
             "algorithm": Algorithm.SHIFT.value,
         },
+        {
+            "name": "Velocity Std. Err.",
+            "file_list": [f"{wd}/timeseries/velocity_stderr.tif"],
+        },
+        {
+            "name": "Velocity Confidence Interval Margin",
+            "file_list": [f"{wd}/timeseries/velocity_ci_margin.tif"],
+        },
         {
             "name": "Filtered time series",
             "file_list": _glob(f"{wd}/filtered_timeseries*/2*[0-9].tif"),
         },
+        {
+            "name": "Filtered time series (deramped)",
+            "file_list": _glob(f"{wd}/filtered_timeseries*/2*[0-9]_deramped.tif"),
+            "uses_spatial_ref": True,
+            "algorithm": Algorithm.SHIFT.value,
+        },
         {
             "name": "Filtered velocity",
             "file_list": [f"{wd}/filtered_timeseries*/velocity.tif"],
@@ -297,6 +332,10 @@ def _glob(g):
             "name": "Nonzero connected component counts",
             "file_list": _glob(f"{wd}/timeseries/nonzero_conncomp_count_*.tif"),
         },
+        {
+            "name": "Multi-looked coherence",
+            "file_list": _glob(f"{wd}/interferograms/multilooked_coh*.tif"),
+        },
         {
             "name": "Re-wrapped phase",
             "file_list": _glob(f"{wd}/unwrapped/2*[0-9].unw.tif"),
@@ -352,6 +391,14 @@ def _glob(g):
             "name": "Time series residuals",
             "file_list": _glob(f"{wd}/timeseries/residuals_2*[0-9].tif"),
         },
+        {
+            "name": "Point height correction",
+            "file_list": _glob(f"{wd}/timeseries/point_height_correction.tif"),
+        },
+        {
+            "name": "Point height correction std. err.",
+            "file_list": _glob(f"{wd}/timeseries/point_height_correction_stderr.tif"),
+        },
         {
             "name": "Time series residuals (total sum)",
             "file_list": _glob(f"{wd}/timeseries/unw_inversion_residuals.tif"),
@@ -657,3 +704,139 @@ def setup_nisar_gunw(nisar_dir: str, output: str):
         raster_groups.append(rg)
 
     _dump_raster_groups(raster_groups, output=output)
+
+
+@cli_app.command("generate-testdata")
+@click.option(
+    "-o",
+    "--output-dir",
+    required=True,
+    help="Directory to write output GeoParquet and manifest files.",
+)
+@click.option(
+    "-n",
+    "--n-points",
+    default=50_000,
+    type=int,
+    show_default=True,
+    help="Number of synthetic measurement points.",
+)
+@click.option(
+    "--n-dates",
+    default=20,
+    type=int,
+    show_default=True,
+    help="Number of SAR acquisition dates.",
+)
+@click.option("--center-lon", default=-99.13, type=float, show_default=True)
+@click.option("--center-lat", default=19.43, type=float, show_default=True)
+@click.option(
+    "--spread",
+    default=0.15,
+    type=float,
+    show_default=True,
+    help="Approximate AOI radius in degrees.",
+)
+@click.option("--seed", default=42, type=int, show_default=True)
+def generate_testdata(
+    output_dir, n_points, n_dates, center_lon, center_lat, spread, seed
+):
+    """Generate synthetic point cloud data for testing.
+
+    Creates realistic clustered point distributions with velocity trends,
+    suitable for testing the V2 point cloud viewer.
+    """
+    from ._generate_testdata import generate_testdata as _gen
+
+    _gen(
+        output_dir=output_dir,
+        n_points=n_points,
+        n_dates=n_dates,
+        center_lon=center_lon,
+        center_lat=center_lat,
+        spread_deg=spread,
+        seed=seed,
+    )
+
+
+@cli_app.group()
+def convert():
+    """Convert InSAR data to GeoParquet point cloud format."""
+
+
+@convert.command()
+@click.argument(
+    "dolphin_work_dir",
+    type=click.Path(exists=True, file_okay=False, dir_okay=True),
+)
+@click.option(
+    "-o",
+    "--output-dir",
+    required=True,
+    help="Directory to write output GeoParquet and manifest files.",
+)
+@click.option(
+    "--coherence-threshold",
+    default=0.5,
+    type=float,
+    show_default=True,
+    help="Minimum temporal coherence to include a pixel.",
+)
+@click.option(
+    "--amplitude-dispersion-threshold",
+    default=None,
+    type=float,
+    help="Maximum amplitude dispersion to include a pixel (lower = more stable).",
+)
+def dolphin(
+    dolphin_work_dir, output_dir, coherence_threshold, amplitude_dispersion_threshold
+):
+    """Convert dolphin workflow outputs to GeoParquet point cloud.
+
+    Reads raster time series and quality layers from DOLPHIN_WORK_DIR,
+    masks by quality thresholds, and writes points.parquet +
+    timeseries.parquet + bowser_manifest.json to OUTPUT_DIR.
+    """
+    from ._convert_dolphin import convert_dolphin
+
+    manifest_path = convert_dolphin(
+        work_dir=dolphin_work_dir,
+        output_dir=output_dir,
+        coherence_threshold=coherence_threshold,
+        amplitude_dispersion_threshold=amplitude_dispersion_threshold,
+    )
+    click.echo(f"\nDone! To view:\n  bowser run --manifest {manifest_path}")
+
+
+@convert.command()
+@click.argument(
+    "input_file",
+    type=click.Path(exists=True, file_okay=True, dir_okay=False),
+)
+@click.option(
+    "-o",
+    "--output-dir",
+    required=True,
+    help="Directory to write output GeoParquet and manifest files.",
+)
+@click.option(
+    "--layer-name",
+    default="ps_points",
+    show_default=True,
+    help="Name for the point layer in the manifest.",
+)
+def wide_parquet(input_file, output_dir, layer_name):
+    """Convert a wide-form point cloud parquet to Bowser V2 format.
+
+    Handles parquet files where displacement time series are stored as
+    date-named columns (e.g., '20240626_20240629'). Splits into separate
+    points.parquet + timeseries.parquet files.
+    """
+    from ._convert_wide_parquet import convert_wide_parquet
+
+    manifest_path = convert_wide_parquet(
+        input_file=input_file,
+        output_dir=output_dir,
+        layer_name=layer_name,
+    )
+    click.echo(f"\nDone! To view:\n  bowser run --manifest {manifest_path}")
diff --git a/src/bowser/dist/assets/plotly.min-Dxb8YwAJ.js b/src/bowser/dist/assets/plotly.min-Dxb8YwAJ.js
new file mode 100644
index 0000000..7a55625
--- /dev/null
+++ b/src/bowser/dist/assets/plotly.min-Dxb8YwAJ.js
@@ -0,0 +1,111699 @@
+import { g as getDefaultExportFromCjs, c as commonjsGlobal } from "../index.js";
+var plotly_min$2 = { exports: {} };
+(function(module) {
+  var define_process_env_default = {};
+  (function(root, factory) {
+    if (module.exports) {
+      module.exports = factory();
+    } else {
+      root.moduleName = factory();
+    }
+  })(typeof self !== "undefined" ? self : commonjsGlobal, () => {
+    var Plotly = (() => {
+      var ytt = Object.create;
+      var DS = Object.defineProperty, _tt = Object.defineProperties, xtt = Object.getOwnPropertyDescriptor, btt = Object.getOwnPropertyDescriptors, wtt = Object.getOwnPropertyNames, p6 = Object.getOwnPropertySymbols, Ttt = Object.getPrototypeOf, AO = Object.prototype.hasOwnProperty, pee = Object.prototype.propertyIsEnumerable;
+      var vee = (e, t, r) => t in e ? DS(e, t, { enumerable: true, configurable: true, writable: true, value: r }) : e[t] = r, _g = (e, t) => {
+        for (var r in t || (t = {})) AO.call(t, r) && vee(e, r, t[r]);
+        if (p6) for (var r of p6(t)) pee.call(t, r) && vee(e, r, t[r]);
+        return e;
+      }, j1 = (e, t) => _tt(e, btt(t));
+      var gee = (e, t) => {
+        var r = {};
+        for (var n in e) AO.call(e, n) && t.indexOf(n) < 0 && (r[n] = e[n]);
+        if (e != null && p6) for (var n of p6(e)) t.indexOf(n) < 0 && pee.call(e, n) && (r[n] = e[n]);
+        return r;
+      };
+      var gu = (e, t) => () => (e && (t = e(e = 0)), t);
+      var ye = (e, t) => () => (t || e((t = { exports: {} }).exports, t), t.exports), mee = (e, t) => {
+        for (var r in t) DS(e, r, { get: t[r], enumerable: true });
+      }, yee = (e, t, r, n) => {
+        if (t && typeof t == "object" || typeof t == "function") for (let i of wtt(t)) !AO.call(e, i) && i !== r && DS(e, i, { get: () => t[i], enumerable: !(n = xtt(t, i)) || n.enumerable });
+        return e;
+      };
+      var Att = (e, t, r) => (r = e != null ? ytt(Ttt(e)) : {}, yee(DS(r, "default", { value: e, enumerable: true }), e)), pb = (e) => yee(DS({}, "__esModule", { value: true }), e);
+      var g6 = ye((_ee) => {
+        _ee.version = "3.4.0";
+      });
+      var bee = ye((xee, m6) => {
+        (function(t, r, n) {
+          r[t] = r[t] || n(), typeof m6 != "undefined" && m6.exports && (m6.exports = r[t]);
+        })("Promise", typeof window != "undefined" ? window : xee, function() {
+          var t, r, n, i = Object.prototype.toString, a = typeof setImmediate != "undefined" ? function(k) {
+            return setImmediate(k);
+          } : setTimeout;
+          try {
+            Object.defineProperty({}, "x", {}), t = function(k, E, T, L) {
+              return Object.defineProperty(k, E, { value: T, writable: true, configurable: L !== false });
+            };
+          } catch (p) {
+            t = function(E, T, L) {
+              return E[T] = L, E;
+            };
+          }
+          n = /* @__PURE__ */ function() {
+            var k, E, T;
+            function L(x, C) {
+              this.fn = x, this.self = C, this.next = void 0;
+            }
+            return { add: function(C, M) {
+              T = new L(C, M), E ? E.next = T : k = T, E = T, T = void 0;
+            }, drain: function() {
+              var C = k;
+              for (k = E = r = void 0; C; ) C.fn.call(C.self), C = C.next;
+            } };
+          }();
+          function o(p, k) {
+            n.add(p, k), r || (r = a(n.drain));
+          }
+          function s(p) {
+            var k, E = typeof p;
+            return p != null && (E == "object" || E == "function") && (k = p.then), typeof k == "function" ? k : false;
+          }
+          function l() {
+            for (var p = 0; p < this.chain.length; p++) u(this, this.state === 1 ? this.chain[p].success : this.chain[p].failure, this.chain[p]);
+            this.chain.length = 0;
+          }
+          function u(p, k, E) {
+            var T, L;
+            try {
+              k === false ? E.reject(p.msg) : (k === true ? T = p.msg : T = k.call(void 0, p.msg), T === E.promise ? E.reject(TypeError("Promise-chain cycle")) : (L = s(T)) ? L.call(T, E.resolve, E.reject) : E.resolve(T));
+            } catch (x) {
+              E.reject(x);
+            }
+          }
+          function c(p) {
+            var k, E = this;
+            if (!E.triggered) {
+              E.triggered = true, E.def && (E = E.def);
+              try {
+                (k = s(p)) ? o(function() {
+                  var T = new d(E);
+                  try {
+                    k.call(p, function() {
+                      c.apply(T, arguments);
+                    }, function() {
+                      f.apply(T, arguments);
+                    });
+                  } catch (L) {
+                    f.call(T, L);
+                  }
+                }) : (E.msg = p, E.state = 1, E.chain.length > 0 && o(l, E));
+              } catch (T) {
+                f.call(new d(E), T);
+              }
+            }
+          }
+          function f(p) {
+            var k = this;
+            k.triggered || (k.triggered = true, k.def && (k = k.def), k.msg = p, k.state = 2, k.chain.length > 0 && o(l, k));
+          }
+          function h(p, k, E, T) {
+            for (var L = 0; L < k.length; L++) (function(C) {
+              p.resolve(k[C]).then(function(g) {
+                E(C, g);
+              }, T);
+            })(L);
+          }
+          function d(p) {
+            this.def = p, this.triggered = false;
+          }
+          function v(p) {
+            this.promise = p, this.state = 0, this.triggered = false, this.chain = [], this.msg = void 0;
+          }
+          function _(p) {
+            if (typeof p != "function") throw TypeError("Not a function");
+            if (this.__NPO__ !== 0) throw TypeError("Not a promise");
+            this.__NPO__ = 1;
+            var k = new v(this);
+            this.then = function(T, L) {
+              var x = { success: typeof T == "function" ? T : true, failure: typeof L == "function" ? L : false };
+              return x.promise = new this.constructor(function(M, g) {
+                if (typeof M != "function" || typeof g != "function") throw TypeError("Not a function");
+                x.resolve = M, x.reject = g;
+              }), k.chain.push(x), k.state !== 0 && o(l, k), x.promise;
+            }, this.catch = function(T) {
+              return this.then(void 0, T);
+            };
+            try {
+              p.call(void 0, function(T) {
+                c.call(k, T);
+              }, function(T) {
+                f.call(k, T);
+              });
+            } catch (E) {
+              f.call(k, E);
+            }
+          }
+          var b = t({}, "constructor", _, false);
+          return _.prototype = b, t(b, "__NPO__", 0, false), t(_, "resolve", function(k) {
+            var E = this;
+            return k && typeof k == "object" && k.__NPO__ === 1 ? k : new E(function(L, x) {
+              if (typeof L != "function" || typeof x != "function") throw TypeError("Not a function");
+              L(k);
+            });
+          }), t(_, "reject", function(k) {
+            return new this(function(T, L) {
+              if (typeof T != "function" || typeof L != "function") throw TypeError("Not a function");
+              L(k);
+            });
+          }), t(_, "all", function(k) {
+            var E = this;
+            return i.call(k) != "[object Array]" ? E.reject(TypeError("Not an array")) : k.length === 0 ? E.resolve([]) : new E(function(L, x) {
+              if (typeof L != "function" || typeof x != "function") throw TypeError("Not a function");
+              var C = k.length, M = Array(C), g = 0;
+              h(E, k, function(A, z) {
+                M[A] = z, ++g === C && L(M);
+              }, x);
+            });
+          }), t(_, "race", function(k) {
+            var E = this;
+            return i.call(k) != "[object Array]" ? E.reject(TypeError("Not an array")) : new E(function(L, x) {
+              if (typeof L != "function" || typeof x != "function") throw TypeError("Not a function");
+              h(E, k, function(M, g) {
+                L(g);
+              }, x);
+            });
+          }), _;
+        });
+      });
+      var Oa = ye((prr, y6) => {
+        (function() {
+          var e = { version: "3.8.2" }, t = [].slice, r = function(X) {
+            return t.call(X);
+          }, n = self.document;
+          function i(X) {
+            return X && (X.ownerDocument || X.document || X).documentElement;
+          }
+          function a(X) {
+            return X && (X.ownerDocument && X.ownerDocument.defaultView || X.document && X || X.defaultView);
+          }
+          if (n) try {
+            r(n.documentElement.childNodes)[0].nodeType;
+          } catch (X) {
+            r = function(se) {
+              for (var Te = se.length, Ne = new Array(Te); Te--; ) Ne[Te] = se[Te];
+              return Ne;
+            };
+          }
+          if (Date.now || (Date.now = function() {
+            return +/* @__PURE__ */ new Date();
+          }), n) try {
+            n.createElement("DIV").style.setProperty("opacity", 0, "");
+          } catch (X) {
+            var o = this.Element.prototype, s = o.setAttribute, l = o.setAttributeNS, u = this.CSSStyleDeclaration.prototype, c = u.setProperty;
+            o.setAttribute = function(se, Te) {
+              s.call(this, se, Te + "");
+            }, o.setAttributeNS = function(se, Te, Ne) {
+              l.call(this, se, Te, Ne + "");
+            }, u.setProperty = function(se, Te, Ne) {
+              c.call(this, se, Te + "", Ne);
+            };
+          }
+          e.ascending = f;
+          function f(X, se) {
+            return X < se ? -1 : X > se ? 1 : X >= se ? 0 : NaN;
+          }
+          e.descending = function(X, se) {
+            return se < X ? -1 : se > X ? 1 : se >= X ? 0 : NaN;
+          }, e.min = function(X, se) {
+            var Te = -1, Ne = X.length, He, Ye;
+            if (arguments.length === 1) {
+              for (; ++Te < Ne; ) if ((Ye = X[Te]) != null && Ye >= Ye) {
+                He = Ye;
+                break;
+              }
+              for (; ++Te < Ne; ) (Ye = X[Te]) != null && He > Ye && (He = Ye);
+            } else {
+              for (; ++Te < Ne; ) if ((Ye = se.call(X, X[Te], Te)) != null && Ye >= Ye) {
+                He = Ye;
+                break;
+              }
+              for (; ++Te < Ne; ) (Ye = se.call(X, X[Te], Te)) != null && He > Ye && (He = Ye);
+            }
+            return He;
+          }, e.max = function(X, se) {
+            var Te = -1, Ne = X.length, He, Ye;
+            if (arguments.length === 1) {
+              for (; ++Te < Ne; ) if ((Ye = X[Te]) != null && Ye >= Ye) {
+                He = Ye;
+                break;
+              }
+              for (; ++Te < Ne; ) (Ye = X[Te]) != null && Ye > He && (He = Ye);
+            } else {
+              for (; ++Te < Ne; ) if ((Ye = se.call(X, X[Te], Te)) != null && Ye >= Ye) {
+                He = Ye;
+                break;
+              }
+              for (; ++Te < Ne; ) (Ye = se.call(X, X[Te], Te)) != null && Ye > He && (He = Ye);
+            }
+            return He;
+          }, e.extent = function(X, se) {
+            var Te = -1, Ne = X.length, He, Ye, kt;
+            if (arguments.length === 1) {
+              for (; ++Te < Ne; ) if ((Ye = X[Te]) != null && Ye >= Ye) {
+                He = kt = Ye;
+                break;
+              }
+              for (; ++Te < Ne; ) (Ye = X[Te]) != null && (He > Ye && (He = Ye), kt < Ye && (kt = Ye));
+            } else {
+              for (; ++Te < Ne; ) if ((Ye = se.call(X, X[Te], Te)) != null && Ye >= Ye) {
+                He = kt = Ye;
+                break;
+              }
+              for (; ++Te < Ne; ) (Ye = se.call(X, X[Te], Te)) != null && (He > Ye && (He = Ye), kt < Ye && (kt = Ye));
+            }
+            return [He, kt];
+          };
+          function h(X) {
+            return X === null ? NaN : +X;
+          }
+          function d(X) {
+            return !isNaN(X);
+          }
+          e.sum = function(X, se) {
+            var Te = 0, Ne = X.length, He, Ye = -1;
+            if (arguments.length === 1) for (; ++Ye < Ne; ) d(He = +X[Ye]) && (Te += He);
+            else for (; ++Ye < Ne; ) d(He = +se.call(X, X[Ye], Ye)) && (Te += He);
+            return Te;
+          }, e.mean = function(X, se) {
+            var Te = 0, Ne = X.length, He, Ye = -1, kt = Ne;
+            if (arguments.length === 1) for (; ++Ye < Ne; ) d(He = h(X[Ye])) ? Te += He : --kt;
+            else for (; ++Ye < Ne; ) d(He = h(se.call(X, X[Ye], Ye))) ? Te += He : --kt;
+            if (kt) return Te / kt;
+          }, e.quantile = function(X, se) {
+            var Te = (X.length - 1) * se + 1, Ne = Math.floor(Te), He = +X[Ne - 1], Ye = Te - Ne;
+            return Ye ? He + Ye * (X[Ne] - He) : He;
+          }, e.median = function(X, se) {
+            var Te = [], Ne = X.length, He, Ye = -1;
+            if (arguments.length === 1) for (; ++Ye < Ne; ) d(He = h(X[Ye])) && Te.push(He);
+            else for (; ++Ye < Ne; ) d(He = h(se.call(X, X[Ye], Ye))) && Te.push(He);
+            if (Te.length) return e.quantile(Te.sort(f), 0.5);
+          }, e.variance = function(X, se) {
+            var Te = X.length, Ne = 0, He, Ye, kt = 0, nt = -1, jt = 0;
+            if (arguments.length === 1) for (; ++nt < Te; ) d(He = h(X[nt])) && (Ye = He - Ne, Ne += Ye / ++jt, kt += Ye * (He - Ne));
+            else for (; ++nt < Te; ) d(He = h(se.call(X, X[nt], nt))) && (Ye = He - Ne, Ne += Ye / ++jt, kt += Ye * (He - Ne));
+            if (jt > 1) return kt / (jt - 1);
+          }, e.deviation = function() {
+            var X = e.variance.apply(this, arguments);
+            return X && Math.sqrt(X);
+          };
+          function v(X) {
+            return { left: function(se, Te, Ne, He) {
+              for (arguments.length < 3 && (Ne = 0), arguments.length < 4 && (He = se.length); Ne < He; ) {
+                var Ye = Ne + He >>> 1;
+                X(se[Ye], Te) < 0 ? Ne = Ye + 1 : He = Ye;
+              }
+              return Ne;
+            }, right: function(se, Te, Ne, He) {
+              for (arguments.length < 3 && (Ne = 0), arguments.length < 4 && (He = se.length); Ne < He; ) {
+                var Ye = Ne + He >>> 1;
+                X(se[Ye], Te) > 0 ? He = Ye : Ne = Ye + 1;
+              }
+              return Ne;
+            } };
+          }
+          var _ = v(f);
+          e.bisectLeft = _.left, e.bisect = e.bisectRight = _.right, e.bisector = function(X) {
+            return v(X.length === 1 ? function(se, Te) {
+              return f(X(se), Te);
+            } : X);
+          }, e.shuffle = function(X, se, Te) {
+            (Ne = arguments.length) < 3 && (Te = X.length, Ne < 2 && (se = 0));
+            for (var Ne = Te - se, He, Ye; Ne; ) Ye = Math.random() * Ne-- | 0, He = X[Ne + se], X[Ne + se] = X[Ye + se], X[Ye + se] = He;
+            return X;
+          }, e.permute = function(X, se) {
+            for (var Te = se.length, Ne = new Array(Te); Te--; ) Ne[Te] = X[se[Te]];
+            return Ne;
+          }, e.pairs = function(X) {
+            for (var se = 0, Te = X.length - 1, Ne, He = X[0], Ye = new Array(Te < 0 ? 0 : Te); se < Te; ) Ye[se] = [Ne = He, He = X[++se]];
+            return Ye;
+          }, e.transpose = function(X) {
+            if (!(Ye = X.length)) return [];
+            for (var se = -1, Te = e.min(X, b), Ne = new Array(Te); ++se < Te; ) for (var He = -1, Ye, kt = Ne[se] = new Array(Ye); ++He < Ye; ) kt[He] = X[He][se];
+            return Ne;
+          };
+          function b(X) {
+            return X.length;
+          }
+          e.zip = function() {
+            return e.transpose(arguments);
+          }, e.keys = function(X) {
+            var se = [];
+            for (var Te in X) se.push(Te);
+            return se;
+          }, e.values = function(X) {
+            var se = [];
+            for (var Te in X) se.push(X[Te]);
+            return se;
+          }, e.entries = function(X) {
+            var se = [];
+            for (var Te in X) se.push({ key: Te, value: X[Te] });
+            return se;
+          }, e.merge = function(X) {
+            for (var se = X.length, Te, Ne = -1, He = 0, Ye, kt; ++Ne < se; ) He += X[Ne].length;
+            for (Ye = new Array(He); --se >= 0; ) for (kt = X[se], Te = kt.length; --Te >= 0; ) Ye[--He] = kt[Te];
+            return Ye;
+          };
+          var p = Math.abs;
+          e.range = function(X, se, Te) {
+            if (arguments.length < 3 && (Te = 1, arguments.length < 2 && (se = X, X = 0)), (se - X) / Te === 1 / 0) throw new Error("infinite range");
+            var Ne = [], He = k(p(Te)), Ye = -1, kt;
+            if (X *= He, se *= He, Te *= He, Te < 0) for (; (kt = X + Te * ++Ye) > se; ) Ne.push(kt / He);
+            else for (; (kt = X + Te * ++Ye) < se; ) Ne.push(kt / He);
+            return Ne;
+          };
+          function k(X) {
+            for (var se = 1; X * se % 1; ) se *= 10;
+            return se;
+          }
+          function E(X, se) {
+            for (var Te in se) Object.defineProperty(X.prototype, Te, { value: se[Te], enumerable: false });
+          }
+          e.map = function(X, se) {
+            var Te = new T();
+            if (X instanceof T) X.forEach(function(nt, jt) {
+              Te.set(nt, jt);
+            });
+            else if (Array.isArray(X)) {
+              var Ne = -1, He = X.length, Ye;
+              if (arguments.length === 1) for (; ++Ne < He; ) Te.set(Ne, X[Ne]);
+              else for (; ++Ne < He; ) Te.set(se.call(X, Ye = X[Ne], Ne), Ye);
+            } else for (var kt in X) Te.set(kt, X[kt]);
+            return Te;
+          };
+          function T() {
+            this._ = /* @__PURE__ */ Object.create(null);
+          }
+          var L = "__proto__", x = "\0";
+          E(T, { has: g, get: function(X) {
+            return this._[C(X)];
+          }, set: function(X, se) {
+            return this._[C(X)] = se;
+          }, remove: P, keys: A, values: function() {
+            var X = [];
+            for (var se in this._) X.push(this._[se]);
+            return X;
+          }, entries: function() {
+            var X = [];
+            for (var se in this._) X.push({ key: M(se), value: this._[se] });
+            return X;
+          }, size: z, empty: O, forEach: function(X) {
+            for (var se in this._) X.call(this, M(se), this._[se]);
+          } });
+          function C(X) {
+            return (X += "") === L || X[0] === x ? x + X : X;
+          }
+          function M(X) {
+            return (X += "")[0] === x ? X.slice(1) : X;
+          }
+          function g(X) {
+            return C(X) in this._;
+          }
+          function P(X) {
+            return (X = C(X)) in this._ && delete this._[X];
+          }
+          function A() {
+            var X = [];
+            for (var se in this._) X.push(M(se));
+            return X;
+          }
+          function z() {
+            var X = 0;
+            for (var se in this._) ++X;
+            return X;
+          }
+          function O() {
+            for (var X in this._) return false;
+            return true;
+          }
+          e.nest = function() {
+            var X = {}, se = [], Te = [], Ne, He;
+            function Ye(nt, jt, gr) {
+              if (gr >= se.length) return He ? He.call(X, jt) : Ne ? jt.sort(Ne) : jt;
+              for (var yr = -1, Hr = jt.length, qr = se[gr++], _i, bi, Zr, ai = new T(), gi; ++yr < Hr; ) (gi = ai.get(_i = qr(bi = jt[yr]))) ? gi.push(bi) : ai.set(_i, [bi]);
+              return nt ? (bi = nt(), Zr = function(Ii, Si) {
+                bi.set(Ii, Ye(nt, Si, gr));
+              }) : (bi = {}, Zr = function(Ii, Si) {
+                bi[Ii] = Ye(nt, Si, gr);
+              }), ai.forEach(Zr), bi;
+            }
+            function kt(nt, jt) {
+              if (jt >= se.length) return nt;
+              var gr = [], yr = Te[jt++];
+              return nt.forEach(function(Hr, qr) {
+                gr.push({ key: Hr, values: kt(qr, jt) });
+              }), yr ? gr.sort(function(Hr, qr) {
+                return yr(Hr.key, qr.key);
+              }) : gr;
+            }
+            return X.map = function(nt, jt) {
+              return Ye(jt, nt, 0);
+            }, X.entries = function(nt) {
+              return kt(Ye(e.map, nt, 0), 0);
+            }, X.key = function(nt) {
+              return se.push(nt), X;
+            }, X.sortKeys = function(nt) {
+              return Te[se.length - 1] = nt, X;
+            }, X.sortValues = function(nt) {
+              return Ne = nt, X;
+            }, X.rollup = function(nt) {
+              return He = nt, X;
+            }, X;
+          }, e.set = function(X) {
+            var se = new U();
+            if (X) for (var Te = 0, Ne = X.length; Te < Ne; ++Te) se.add(X[Te]);
+            return se;
+          };
+          function U() {
+            this._ = /* @__PURE__ */ Object.create(null);
+          }
+          E(U, { has: g, add: function(X) {
+            return this._[C(X += "")] = true, X;
+          }, remove: P, values: A, size: z, empty: O, forEach: function(X) {
+            for (var se in this._) X.call(this, M(se));
+          } }), e.behavior = {};
+          function G(X) {
+            return X;
+          }
+          e.rebind = function(X, se) {
+            for (var Te = 1, Ne = arguments.length, He; ++Te < Ne; ) X[He = arguments[Te]] = Z(X, se, se[He]);
+            return X;
+          };
+          function Z(X, se, Te) {
+            return function() {
+              var Ne = Te.apply(se, arguments);
+              return Ne === se ? X : Ne;
+            };
+          }
+          function j(X, se) {
+            if (se in X) return se;
+            se = se.charAt(0).toUpperCase() + se.slice(1);
+            for (var Te = 0, Ne = N.length; Te < Ne; ++Te) {
+              var He = N[Te] + se;
+              if (He in X) return He;
+            }
+          }
+          var N = ["webkit", "ms", "moz", "Moz", "o", "O"];
+          function H() {
+          }
+          e.dispatch = function() {
+            for (var X = new re(), se = -1, Te = arguments.length; ++se < Te; ) X[arguments[se]] = oe(X);
+            return X;
+          };
+          function re() {
+          }
+          re.prototype.on = function(X, se) {
+            var Te = X.indexOf("."), Ne = "";
+            if (Te >= 0 && (Ne = X.slice(Te + 1), X = X.slice(0, Te)), X) return arguments.length < 2 ? this[X].on(Ne) : this[X].on(Ne, se);
+            if (arguments.length === 2) {
+              if (se == null) for (X in this) this.hasOwnProperty(X) && this[X].on(Ne, null);
+              return this;
+            }
+          };
+          function oe(X) {
+            var se = [], Te = new T();
+            function Ne() {
+              for (var He = se, Ye = -1, kt = He.length, nt; ++Ye < kt; ) (nt = He[Ye].on) && nt.apply(this, arguments);
+              return X;
+            }
+            return Ne.on = function(He, Ye) {
+              var kt = Te.get(He), nt;
+              return arguments.length < 2 ? kt && kt.on : (kt && (kt.on = null, se = se.slice(0, nt = se.indexOf(kt)).concat(se.slice(nt + 1)), Te.remove(He)), Ye && se.push(Te.set(He, { on: Ye })), X);
+            }, Ne;
+          }
+          e.event = null;
+          function _e() {
+            e.event.preventDefault();
+          }
+          function Ce() {
+            for (var X = e.event, se; se = X.sourceEvent; ) X = se;
+            return X;
+          }
+          function Le(X) {
+            for (var se = new re(), Te = 0, Ne = arguments.length; ++Te < Ne; ) se[arguments[Te]] = oe(se);
+            return se.of = function(He, Ye) {
+              return function(kt) {
+                try {
+                  var nt = kt.sourceEvent = e.event;
+                  kt.target = X, e.event = kt, se[kt.type].apply(He, Ye);
+                } finally {
+                  e.event = nt;
+                }
+              };
+            }, se;
+          }
+          e.requote = function(X) {
+            return X.replace(ge, "\\$&");
+          };
+          var ge = /[\\\^\$\*\+\?\|\[\]\(\)\.\{\}]/g, ie = {}.__proto__ ? function(X, se) {
+            X.__proto__ = se;
+          } : function(X, se) {
+            for (var Te in se) X[Te] = se[Te];
+          };
+          function Se(X) {
+            return ie(X, Pe), X;
+          }
+          var Ee = function(X, se) {
+            return se.querySelector(X);
+          }, Ae = function(X, se) {
+            return se.querySelectorAll(X);
+          }, Be = function(X, se) {
+            var Te = X.matches || X[j(X, "matchesSelector")];
+            return Be = function(Ne, He) {
+              return Te.call(Ne, He);
+            }, Be(X, se);
+          };
+          typeof Sizzle == "function" && (Ee = function(X, se) {
+            return Sizzle(X, se)[0] || null;
+          }, Ae = Sizzle, Be = Sizzle.matchesSelector), e.selection = function() {
+            return e.select(n.documentElement);
+          };
+          var Pe = e.selection.prototype = [];
+          Pe.select = function(X) {
+            var se = [], Te, Ne, He, Ye;
+            X = me(X);
+            for (var kt = -1, nt = this.length; ++kt < nt; ) {
+              se.push(Te = []), Te.parentNode = (He = this[kt]).parentNode;
+              for (var jt = -1, gr = He.length; ++jt < gr; ) (Ye = He[jt]) ? (Te.push(Ne = X.call(Ye, Ye.__data__, jt, kt)), Ne && "__data__" in Ye && (Ne.__data__ = Ye.__data__)) : Te.push(null);
+            }
+            return Se(se);
+          };
+          function me(X) {
+            return typeof X == "function" ? X : function() {
+              return Ee(X, this);
+            };
+          }
+          Pe.selectAll = function(X) {
+            var se = [], Te, Ne;
+            X = De(X);
+            for (var He = -1, Ye = this.length; ++He < Ye; ) for (var kt = this[He], nt = -1, jt = kt.length; ++nt < jt; ) (Ne = kt[nt]) && (se.push(Te = r(X.call(Ne, Ne.__data__, nt, He))), Te.parentNode = Ne);
+            return Se(se);
+          };
+          function De(X) {
+            return typeof X == "function" ? X : function() {
+              return Ae(X, this);
+            };
+          }
+          var ce = "http://www.w3.org/1999/xhtml", je = { svg: "http://www.w3.org/2000/svg", xhtml: ce, xlink: "http://www.w3.org/1999/xlink", xml: "http://www.w3.org/XML/1998/namespace", xmlns: "http://www.w3.org/2000/xmlns/" };
+          e.ns = { prefix: je, qualify: function(X) {
+            var se = X.indexOf(":"), Te = X;
+            return se >= 0 && (Te = X.slice(0, se)) !== "xmlns" && (X = X.slice(se + 1)), je.hasOwnProperty(Te) ? { space: je[Te], local: X } : X;
+          } }, Pe.attr = function(X, se) {
+            if (arguments.length < 2) {
+              if (typeof X == "string") {
+                var Te = this.node();
+                return X = e.ns.qualify(X), X.local ? Te.getAttributeNS(X.space, X.local) : Te.getAttribute(X);
+              }
+              for (se in X) this.each(lt(se, X[se]));
+              return this;
+            }
+            return this.each(lt(X, se));
+          };
+          function lt(X, se) {
+            X = e.ns.qualify(X);
+            function Te() {
+              this.removeAttribute(X);
+            }
+            function Ne() {
+              this.removeAttributeNS(X.space, X.local);
+            }
+            function He() {
+              this.setAttribute(X, se);
+            }
+            function Ye() {
+              this.setAttributeNS(X.space, X.local, se);
+            }
+            function kt() {
+              var jt = se.apply(this, arguments);
+              jt == null ? this.removeAttribute(X) : this.setAttribute(X, jt);
+            }
+            function nt() {
+              var jt = se.apply(this, arguments);
+              jt == null ? this.removeAttributeNS(X.space, X.local) : this.setAttributeNS(X.space, X.local, jt);
+            }
+            return se == null ? X.local ? Ne : Te : typeof se == "function" ? X.local ? nt : kt : X.local ? Ye : He;
+          }
+          function pt(X) {
+            return X.trim().replace(/\s+/g, " ");
+          }
+          Pe.classed = function(X, se) {
+            if (arguments.length < 2) {
+              if (typeof X == "string") {
+                var Te = this.node(), Ne = (X = ot(X)).length, He = -1;
+                if (se = Te.classList) {
+                  for (; ++He < Ne; ) if (!se.contains(X[He])) return false;
+                } else for (se = Te.getAttribute("class"); ++He < Ne; ) if (!Vt(X[He]).test(se)) return false;
+                return true;
+              }
+              for (se in X) this.each(ut(se, X[se]));
+              return this;
+            }
+            return this.each(ut(X, se));
+          };
+          function Vt(X) {
+            return new RegExp("(?:^|\\s+)" + e.requote(X) + "(?:\\s+|$)", "g");
+          }
+          function ot(X) {
+            return (X + "").trim().split(/^|\s+/);
+          }
+          function ut(X, se) {
+            X = ot(X).map(Wt);
+            var Te = X.length;
+            function Ne() {
+              for (var Ye = -1; ++Ye < Te; ) X[Ye](this, se);
+            }
+            function He() {
+              for (var Ye = -1, kt = se.apply(this, arguments); ++Ye < Te; ) X[Ye](this, kt);
+            }
+            return typeof se == "function" ? He : Ne;
+          }
+          function Wt(X) {
+            var se = Vt(X);
+            return function(Te, Ne) {
+              if (He = Te.classList) return Ne ? He.add(X) : He.remove(X);
+              var He = Te.getAttribute("class") || "";
+              Ne ? (se.lastIndex = 0, se.test(He) || Te.setAttribute("class", pt(He + " " + X))) : Te.setAttribute("class", pt(He.replace(se, " ")));
+            };
+          }
+          Pe.style = function(X, se, Te) {
+            var Ne = arguments.length;
+            if (Ne < 3) {
+              if (typeof X != "string") {
+                Ne < 2 && (se = "");
+                for (Te in X) this.each(Nt(Te, X[Te], se));
+                return this;
+              }
+              if (Ne < 2) {
+                var He = this.node();
+                return a(He).getComputedStyle(He, null).getPropertyValue(X);
+              }
+              Te = "";
+            }
+            return this.each(Nt(X, se, Te));
+          };
+          function Nt(X, se, Te) {
+            function Ne() {
+              this.style.removeProperty(X);
+            }
+            function He() {
+              this.style.setProperty(X, se, Te);
+            }
+            function Ye() {
+              var kt = se.apply(this, arguments);
+              kt == null ? this.style.removeProperty(X) : this.style.setProperty(X, kt, Te);
+            }
+            return se == null ? Ne : typeof se == "function" ? Ye : He;
+          }
+          Pe.property = function(X, se) {
+            if (arguments.length < 2) {
+              if (typeof X == "string") return this.node()[X];
+              for (se in X) this.each($t(se, X[se]));
+              return this;
+            }
+            return this.each($t(X, se));
+          };
+          function $t(X, se) {
+            function Te() {
+              delete this[X];
+            }
+            function Ne() {
+              this[X] = se;
+            }
+            function He() {
+              var Ye = se.apply(this, arguments);
+              Ye == null ? delete this[X] : this[X] = Ye;
+            }
+            return se == null ? Te : typeof se == "function" ? He : Ne;
+          }
+          Pe.text = function(X) {
+            return arguments.length ? this.each(typeof X == "function" ? function() {
+              var se = X.apply(this, arguments);
+              this.textContent = se == null ? "" : se;
+            } : X == null ? function() {
+              this.textContent = "";
+            } : function() {
+              this.textContent = X;
+            }) : this.node().textContent;
+          }, Pe.html = function(X) {
+            return arguments.length ? this.each(typeof X == "function" ? function() {
+              var se = X.apply(this, arguments);
+              this.innerHTML = se == null ? "" : se;
+            } : X == null ? function() {
+              this.innerHTML = "";
+            } : function() {
+              this.innerHTML = X;
+            }) : this.node().innerHTML;
+          }, Pe.append = function(X) {
+            return X = sr(X), this.select(function() {
+              return this.appendChild(X.apply(this, arguments));
+            });
+          };
+          function sr(X) {
+            function se() {
+              var Ne = this.ownerDocument, He = this.namespaceURI;
+              return He === ce && Ne.documentElement.namespaceURI === ce ? Ne.createElement(X) : Ne.createElementNS(He, X);
+            }
+            function Te() {
+              return this.ownerDocument.createElementNS(X.space, X.local);
+            }
+            return typeof X == "function" ? X : (X = e.ns.qualify(X)).local ? Te : se;
+          }
+          Pe.insert = function(X, se) {
+            return X = sr(X), se = me(se), this.select(function() {
+              return this.insertBefore(X.apply(this, arguments), se.apply(this, arguments) || null);
+            });
+          }, Pe.remove = function() {
+            return this.each(Tr);
+          };
+          function Tr() {
+            var X = this.parentNode;
+            X && X.removeChild(this);
+          }
+          Pe.data = function(X, se) {
+            var Te = -1, Ne = this.length, He, Ye;
+            if (!arguments.length) {
+              for (X = new Array(Ne = (He = this[0]).length); ++Te < Ne; ) (Ye = He[Te]) && (X[Te] = Ye.__data__);
+              return X;
+            }
+            function kt(yr, Hr) {
+              var qr, _i = yr.length, bi = Hr.length, Zr = Math.min(_i, bi), ai = new Array(bi), gi = new Array(bi), Ii = new Array(_i), Si, ei;
+              if (se) {
+                var Ln = new T(), En = new Array(_i), Un;
+                for (qr = -1; ++qr < _i; ) (Si = yr[qr]) && (Ln.has(Un = se.call(Si, Si.__data__, qr)) ? Ii[qr] = Si : Ln.set(Un, Si), En[qr] = Un);
+                for (qr = -1; ++qr < bi; ) (Si = Ln.get(Un = se.call(Hr, ei = Hr[qr], qr))) ? Si !== true && (ai[qr] = Si, Si.__data__ = ei) : gi[qr] = fr(ei), Ln.set(Un, true);
+                for (qr = -1; ++qr < _i; ) qr in En && Ln.get(En[qr]) !== true && (Ii[qr] = yr[qr]);
+              } else {
+                for (qr = -1; ++qr < Zr; ) Si = yr[qr], ei = Hr[qr], Si ? (Si.__data__ = ei, ai[qr] = Si) : gi[qr] = fr(ei);
+                for (; qr < bi; ++qr) gi[qr] = fr(Hr[qr]);
+                for (; qr < _i; ++qr) Ii[qr] = yr[qr];
+              }
+              gi.update = ai, gi.parentNode = ai.parentNode = Ii.parentNode = yr.parentNode, nt.push(gi), jt.push(ai), gr.push(Ii);
+            }
+            var nt = Gt([]), jt = Se([]), gr = Se([]);
+            if (typeof X == "function") for (; ++Te < Ne; ) kt(He = this[Te], X.call(He, He.parentNode.__data__, Te));
+            else for (; ++Te < Ne; ) kt(He = this[Te], X);
+            return jt.enter = function() {
+              return nt;
+            }, jt.exit = function() {
+              return gr;
+            }, jt;
+          };
+          function fr(X) {
+            return { __data__: X };
+          }
+          Pe.datum = function(X) {
+            return arguments.length ? this.property("__data__", X) : this.property("__data__");
+          }, Pe.filter = function(X) {
+            var se = [], Te, Ne, He;
+            typeof X != "function" && (X = $e(X));
+            for (var Ye = 0, kt = this.length; Ye < kt; Ye++) {
+              se.push(Te = []), Te.parentNode = (Ne = this[Ye]).parentNode;
+              for (var nt = 0, jt = Ne.length; nt < jt; nt++) (He = Ne[nt]) && X.call(He, He.__data__, nt, Ye) && Te.push(He);
+            }
+            return Se(se);
+          };
+          function $e(X) {
+            return function() {
+              return Be(this, X);
+            };
+          }
+          Pe.order = function() {
+            for (var X = -1, se = this.length; ++X < se; ) for (var Te = this[X], Ne = Te.length - 1, He = Te[Ne], Ye; --Ne >= 0; ) (Ye = Te[Ne]) && (He && He !== Ye.nextSibling && He.parentNode.insertBefore(Ye, He), He = Ye);
+            return this;
+          }, Pe.sort = function(X) {
+            X = St.apply(this, arguments);
+            for (var se = -1, Te = this.length; ++se < Te; ) this[se].sort(X);
+            return this.order();
+          };
+          function St(X) {
+            return arguments.length || (X = f), function(se, Te) {
+              return se && Te ? X(se.__data__, Te.__data__) : !se - !Te;
+            };
+          }
+          Pe.each = function(X) {
+            return Qt(this, function(se, Te, Ne) {
+              X.call(se, se.__data__, Te, Ne);
+            });
+          };
+          function Qt(X, se) {
+            for (var Te = 0, Ne = X.length; Te < Ne; Te++) for (var He = X[Te], Ye = 0, kt = He.length, nt; Ye < kt; Ye++) (nt = He[Ye]) && se(nt, Ye, Te);
+            return X;
+          }
+          Pe.call = function(X) {
+            var se = r(arguments);
+            return X.apply(se[0] = this, se), this;
+          }, Pe.empty = function() {
+            return !this.node();
+          }, Pe.node = function() {
+            for (var X = 0, se = this.length; X < se; X++) for (var Te = this[X], Ne = 0, He = Te.length; Ne < He; Ne++) {
+              var Ye = Te[Ne];
+              if (Ye) return Ye;
+            }
+            return null;
+          }, Pe.size = function() {
+            var X = 0;
+            return Qt(this, function() {
+              ++X;
+            }), X;
+          };
+          function Gt(X) {
+            return ie(X, _t), X;
+          }
+          var _t = [];
+          e.selection.enter = Gt, e.selection.enter.prototype = _t, _t.append = Pe.append, _t.empty = Pe.empty, _t.node = Pe.node, _t.call = Pe.call, _t.size = Pe.size, _t.select = function(X) {
+            for (var se = [], Te, Ne, He, Ye, kt, nt = -1, jt = this.length; ++nt < jt; ) {
+              He = (Ye = this[nt]).update, se.push(Te = []), Te.parentNode = Ye.parentNode;
+              for (var gr = -1, yr = Ye.length; ++gr < yr; ) (kt = Ye[gr]) ? (Te.push(He[gr] = Ne = X.call(Ye.parentNode, kt.__data__, gr, nt)), Ne.__data__ = kt.__data__) : Te.push(null);
+            }
+            return Se(se);
+          }, _t.insert = function(X, se) {
+            return arguments.length < 2 && (se = It(this)), Pe.insert.call(this, X, se);
+          };
+          function It(X) {
+            var se, Te;
+            return function(Ne, He, Ye) {
+              var kt = X[Ye].update, nt = kt.length, jt;
+              for (Ye != Te && (Te = Ye, se = 0), He >= se && (se = He + 1); !(jt = kt[se]) && ++se < nt; ) ;
+              return jt;
+            };
+          }
+          e.select = function(X) {
+            var se;
+            return typeof X == "string" ? (se = [Ee(X, n)], se.parentNode = n.documentElement) : (se = [X], se.parentNode = i(X)), Se([se]);
+          }, e.selectAll = function(X) {
+            var se;
+            return typeof X == "string" ? (se = r(Ae(X, n)), se.parentNode = n.documentElement) : (se = r(X), se.parentNode = null), Se([se]);
+          }, Pe.on = function(X, se, Te) {
+            var Ne = arguments.length;
+            if (Ne < 3) {
+              if (typeof X != "string") {
+                Ne < 2 && (se = false);
+                for (Te in X) this.each(mt(Te, X[Te], se));
+                return this;
+              }
+              if (Ne < 2) return (Ne = this.node()["__on" + X]) && Ne._;
+              Te = false;
+            }
+            return this.each(mt(X, se, Te));
+          };
+          function mt(X, se, Te) {
+            var Ne = "__on" + X, He = X.indexOf("."), Ye = lr;
+            He > 0 && (X = X.slice(0, He));
+            var kt = er.get(X);
+            kt && (X = kt, Ye = wr);
+            function nt() {
+              var yr = this[Ne];
+              yr && (this.removeEventListener(X, yr, yr.$), delete this[Ne]);
+            }
+            function jt() {
+              var yr = Ye(se, r(arguments));
+              nt.call(this), this.addEventListener(X, this[Ne] = yr, yr.$ = Te), yr._ = se;
+            }
+            function gr() {
+              var yr = new RegExp("^__on([^.]+)" + e.requote(X) + "$"), Hr;
+              for (var qr in this) if (Hr = qr.match(yr)) {
+                var _i = this[qr];
+                this.removeEventListener(Hr[1], _i, _i.$), delete this[qr];
+              }
+            }
+            return He ? se ? jt : nt : se ? H : gr;
+          }
+          var er = e.map({ mouseenter: "mouseover", mouseleave: "mouseout" });
+          n && er.forEach(function(X) {
+            "on" + X in n && er.remove(X);
+          });
+          function lr(X, se) {
+            return function(Te) {
+              var Ne = e.event;
+              e.event = Te, se[0] = this.__data__;
+              try {
+                X.apply(this, se);
+              } finally {
+                e.event = Ne;
+              }
+            };
+          }
+          function wr(X, se) {
+            var Te = lr(X, se);
+            return function(Ne) {
+              var He = this, Ye = Ne.relatedTarget;
+              (!Ye || Ye !== He && !(Ye.compareDocumentPosition(He) & 8)) && Te.call(He, Ne);
+            };
+          }
+          var Lr, ti = 0;
+          function Br(X) {
+            var se = ".dragsuppress-" + ++ti, Te = "click" + se, Ne = e.select(a(X)).on("touchmove" + se, _e).on("dragstart" + se, _e).on("selectstart" + se, _e);
+            if (Lr == null && (Lr = "onselectstart" in X ? false : j(X.style, "userSelect")), Lr) {
+              var He = i(X).style, Ye = He[Lr];
+              He[Lr] = "none";
+            }
+            return function(kt) {
+              if (Ne.on(se, null), Lr && (He[Lr] = Ye), kt) {
+                var nt = function() {
+                  Ne.on(Te, null);
+                };
+                Ne.on(Te, function() {
+                  _e(), nt();
+                }, true), setTimeout(nt, 0);
+              }
+            };
+          }
+          e.mouse = function(X) {
+            return dt(X, Ce());
+          };
+          var Vr = this.navigator && /WebKit/.test(this.navigator.userAgent) ? -1 : 0;
+          function dt(X, se) {
+            se.changedTouches && (se = se.changedTouches[0]);
+            var Te = X.ownerSVGElement || X;
+            if (Te.createSVGPoint) {
+              var Ne = Te.createSVGPoint();
+              if (Vr < 0) {
+                var He = a(X);
+                if (He.scrollX || He.scrollY) {
+                  Te = e.select("body").append("svg").style({ position: "absolute", top: 0, left: 0, margin: 0, padding: 0, border: "none" }, "important");
+                  var Ye = Te[0][0].getScreenCTM();
+                  Vr = !(Ye.f || Ye.e), Te.remove();
+                }
+              }
+              return Vr ? (Ne.x = se.pageX, Ne.y = se.pageY) : (Ne.x = se.clientX, Ne.y = se.clientY), Ne = Ne.matrixTransform(X.getScreenCTM().inverse()), [Ne.x, Ne.y];
+            }
+            var kt = X.getBoundingClientRect();
+            return [se.clientX - kt.left - X.clientLeft, se.clientY - kt.top - X.clientTop];
+          }
+          e.touch = function(X, se, Te) {
+            if (arguments.length < 3 && (Te = se, se = Ce().changedTouches), se) {
+              for (var Ne = 0, He = se.length, Ye; Ne < He; ++Ne) if ((Ye = se[Ne]).identifier === Te) return dt(X, Ye);
+            }
+          }, e.behavior.drag = function() {
+            var X = Le(He, "drag", "dragstart", "dragend"), se = null, Te = Ye(H, e.mouse, a, "mousemove", "mouseup"), Ne = Ye(Ge, e.touch, G, "touchmove", "touchend");
+            function He() {
+              this.on("mousedown.drag", Te).on("touchstart.drag", Ne);
+            }
+            function Ye(kt, nt, jt, gr, yr) {
+              return function() {
+                var Hr = this, qr = e.event.target.correspondingElement || e.event.target, _i = Hr.parentNode, bi = X.of(Hr, arguments), Zr = 0, ai = kt(), gi = ".drag" + (ai == null ? "" : "-" + ai), Ii, Si = e.select(jt(qr)).on(gr + gi, En).on(yr + gi, Un), ei = Br(qr), Ln = nt(_i, ai);
+                se ? (Ii = se.apply(Hr, arguments), Ii = [Ii.x - Ln[0], Ii.y - Ln[1]]) : Ii = [0, 0], bi({ type: "dragstart" });
+                function En() {
+                  var ia = nt(_i, ai), Ea, Ia;
+                  ia && (Ea = ia[0] - Ln[0], Ia = ia[1] - Ln[1], Zr |= Ea | Ia, Ln = ia, bi({ type: "drag", x: ia[0] + Ii[0], y: ia[1] + Ii[1], dx: Ea, dy: Ia }));
+                }
+                function Un() {
+                  nt(_i, ai) && (Si.on(gr + gi, null).on(yr + gi, null), ei(Zr), bi({ type: "dragend" }));
+                }
+              };
+            }
+            return He.origin = function(kt) {
+              return arguments.length ? (se = kt, He) : se;
+            }, e.rebind(He, X, "on");
+          };
+          function Ge() {
+            return e.event.changedTouches[0].identifier;
+          }
+          e.touches = function(X, se) {
+            return arguments.length < 2 && (se = Ce().touches), se ? r(se).map(function(Te) {
+              var Ne = dt(X, Te);
+              return Ne.identifier = Te.identifier, Ne;
+            }) : [];
+          };
+          var Je = 1e-6, We = Je * Je, tt = Math.PI, xt = 2 * tt, Ie = xt - Je, xe = tt / 2, ke = tt / 180, vt = 180 / tt;
+          function ar(X, se, Te) {
+            return (se[0] - X[0]) * (Te[1] - X[1]) - (se[1] - X[1]) * (Te[0] - X[0]);
+          }
+          function ii(X) {
+            return X > 1 ? xe : X < -1 ? -xe : Math.asin(X);
+          }
+          function pi(X) {
+            return ((X = Math.exp(X)) - 1 / X) / 2;
+          }
+          function $r(X) {
+            return ((X = Math.exp(X)) + 1 / X) / 2;
+          }
+          function di(X) {
+            return ((X = Math.exp(2 * X)) - 1) / (X + 1);
+          }
+          var In = Math.SQRT2, wi = 2, On = 4;
+          e.interpolateZoom = function(X, se) {
+            var Te = X[0], Ne = X[1], He = X[2], Ye = se[0], kt = se[1], nt = se[2], jt = Ye - Te, gr = kt - Ne, yr = jt * jt + gr * gr, Hr, qr;
+            if (yr < We) qr = Math.log(nt / He) / In, Hr = function(Ii) {
+              return [Te + Ii * jt, Ne + Ii * gr, He * Math.exp(In * Ii * qr)];
+            };
+            else {
+              var _i = Math.sqrt(yr), bi = (nt * nt - He * He + On * yr) / (2 * He * wi * _i), Zr = (nt * nt - He * He - On * yr) / (2 * nt * wi * _i), ai = Math.log(Math.sqrt(bi * bi + 1) - bi), gi = Math.log(Math.sqrt(Zr * Zr + 1) - Zr);
+              qr = (gi - ai) / In, Hr = function(Ii) {
+                var Si = Ii * qr, ei = $r(ai), Ln = He / (wi * _i) * (ei * di(In * Si + ai) - pi(ai));
+                return [Te + Ln * jt, Ne + Ln * gr, He * ei / $r(In * Si + ai)];
+              };
+            }
+            return Hr.duration = qr * 1e3, Hr;
+          }, e.behavior.zoom = function() {
+            var X = { x: 0, y: 0, k: 1 }, se, Te, Ne, He = [960, 500], Ye = qn, kt = 250, nt = 0, jt = "mousedown.zoom", gr = "mousemove.zoom", yr = "mouseup.zoom", Hr, qr = "touchstart.zoom", _i, bi = Le(Si, "zoomstart", "zoom", "zoomend"), Zr, ai, gi, Ii;
+            ra || (ra = "onwheel" in n ? (Fn = function() {
+              return -e.event.deltaY * (e.event.deltaMode ? 120 : 1);
+            }, "wheel") : "onmousewheel" in n ? (Fn = function() {
+              return e.event.wheelDelta;
+            }, "mousewheel") : (Fn = function() {
+              return -e.event.detail;
+            }, "MozMousePixelScroll"));
+            function Si(Gn) {
+              Gn.on(jt, go).on(ra + ".zoom", Ms).on("dblclick.zoom", Xs).on(qr, Is);
+            }
+            Si.event = function(Gn) {
+              Gn.each(function() {
+                var ja = bi.of(this, arguments), Fo = X;
+                Bo ? e.select(this).transition().each("start.zoom", function() {
+                  X = this.__chart__ || { x: 0, y: 0, k: 1 }, Ia(ja);
+                }).tween("zoom:zoom", function() {
+                  var Uo = He[0], $s = He[1], Sl = Te ? Te[0] : Uo / 2, bu = Te ? Te[1] : $s / 2, dl = e.interpolateZoom([(Sl - X.x) / X.k, (bu - X.y) / X.k, Uo / X.k], [(Sl - Fo.x) / Fo.k, (bu - Fo.y) / Fo.k, Uo / Fo.k]);
+                  return function(Sc) {
+                    var Me = dl(Sc), bt = Uo / Me[2];
+                    this.__chart__ = X = { x: Sl - Me[0] * bt, y: bu - Me[1] * bt, k: bt }, yo(ja);
+                  };
+                }).each("interrupt.zoom", function() {
+                  Da(ja);
+                }).each("end.zoom", function() {
+                  Da(ja);
+                }) : (this.__chart__ = X, Ia(ja), yo(ja), Da(ja));
+              });
+            }, Si.translate = function(Gn) {
+              return arguments.length ? (X = { x: +Gn[0], y: +Gn[1], k: X.k }, Ea(), Si) : [X.x, X.y];
+            }, Si.scale = function(Gn) {
+              return arguments.length ? (X = { x: X.x, y: X.y, k: null }, En(+Gn), Ea(), Si) : X.k;
+            }, Si.scaleExtent = function(Gn) {
+              return arguments.length ? (Ye = Gn == null ? qn : [+Gn[0], +Gn[1]], Si) : Ye;
+            }, Si.center = function(Gn) {
+              return arguments.length ? (Ne = Gn && [+Gn[0], +Gn[1]], Si) : Ne;
+            }, Si.size = function(Gn) {
+              return arguments.length ? (He = Gn && [+Gn[0], +Gn[1]], Si) : He;
+            }, Si.duration = function(Gn) {
+              return arguments.length ? (kt = +Gn, Si) : kt;
+            }, Si.x = function(Gn) {
+              return arguments.length ? (ai = Gn, Zr = Gn.copy(), X = { x: 0, y: 0, k: 1 }, Si) : ai;
+            }, Si.y = function(Gn) {
+              return arguments.length ? (Ii = Gn, gi = Gn.copy(), X = { x: 0, y: 0, k: 1 }, Si) : Ii;
+            };
+            function ei(Gn) {
+              return [(Gn[0] - X.x) / X.k, (Gn[1] - X.y) / X.k];
+            }
+            function Ln(Gn) {
+              return [Gn[0] * X.k + X.x, Gn[1] * X.k + X.y];
+            }
+            function En(Gn) {
+              X.k = Math.max(Ye[0], Math.min(Ye[1], Gn));
+            }
+            function Un(Gn, ja) {
+              ja = Ln(ja), X.x += Gn[0] - ja[0], X.y += Gn[1] - ja[1];
+            }
+            function ia(Gn, ja, Fo, Uo) {
+              Gn.__chart__ = { x: X.x, y: X.y, k: X.k }, En(Math.pow(2, Uo)), Un(Te = ja, Fo), Gn = e.select(Gn), kt > 0 && (Gn = Gn.transition().duration(kt)), Gn.call(Si.event);
+            }
+            function Ea() {
+              ai && ai.domain(Zr.range().map(function(Gn) {
+                return (Gn - X.x) / X.k;
+              }).map(Zr.invert)), Ii && Ii.domain(gi.range().map(function(Gn) {
+                return (Gn - X.y) / X.k;
+              }).map(gi.invert));
+            }
+            function Ia(Gn) {
+              nt++ || Gn({ type: "zoomstart" });
+            }
+            function yo(Gn) {
+              Ea(), Gn({ type: "zoom", scale: X.k, translate: [X.x, X.y] });
+            }
+            function Da(Gn) {
+              --nt || (Gn({ type: "zoomend" }), Te = null);
+            }
+            function go() {
+              var Gn = this, ja = bi.of(Gn, arguments), Fo = 0, Uo = e.select(a(Gn)).on(gr, bu).on(yr, dl), $s = ei(e.mouse(Gn)), Sl = Br(Gn);
+              fa.call(Gn), Ia(ja);
+              function bu() {
+                Fo = 1, Un(e.mouse(Gn), $s), yo(ja);
+              }
+              function dl() {
+                Uo.on(gr, null).on(yr, null), Sl(Fo), Da(ja);
+              }
+            }
+            function Is() {
+              var Gn = this, ja = bi.of(Gn, arguments), Fo = {}, Uo = 0, $s, Sl = ".zoom-" + e.event.changedTouches[0].identifier, bu = "touchmove" + Sl, dl = "touchend" + Sl, Sc = [], Me = e.select(Gn), bt = Br(Gn);
+              Rr(), Ia(ja), Me.on(jt, null).on(qr, Rr);
+              function zt() {
+                var Gr = e.touches(Gn);
+                return $s = X.k, Gr.forEach(function(mi) {
+                  mi.identifier in Fo && (Fo[mi.identifier] = ei(mi));
+                }), Gr;
+              }
+              function Rr() {
+                var Gr = e.event.target;
+                e.select(Gr).on(bu, jr).on(dl, Nr), Sc.push(Gr);
+                for (var mi = e.event.changedTouches, Ui = 0, qi = mi.length; Ui < qi; ++Ui) Fo[mi[Ui].identifier] = null;
+                var Ei = zt(), Hn = Date.now();
+                if (Ei.length === 1) {
+                  if (Hn - _i < 500) {
+                    var en = Ei[0];
+                    ia(Gn, en, Fo[en.identifier], Math.floor(Math.log(X.k) / Math.LN2) + 1), _e();
+                  }
+                  _i = Hn;
+                } else if (Ei.length > 1) {
+                  var en = Ei[0], Wi = Ei[1], si = en[0] - Wi[0], Mr = en[1] - Wi[1];
+                  Uo = si * si + Mr * Mr;
+                }
+              }
+              function jr() {
+                var Gr = e.touches(Gn), mi, Ui, qi, Ei;
+                fa.call(Gn);
+                for (var Hn = 0, en = Gr.length; Hn < en; ++Hn, Ei = null) if (qi = Gr[Hn], Ei = Fo[qi.identifier]) {
+                  if (Ui) break;
+                  mi = qi, Ui = Ei;
+                }
+                if (Ei) {
+                  var Wi = (Wi = qi[0] - mi[0]) * Wi + (Wi = qi[1] - mi[1]) * Wi, si = Uo && Math.sqrt(Wi / Uo);
+                  mi = [(mi[0] + qi[0]) / 2, (mi[1] + qi[1]) / 2], Ui = [(Ui[0] + Ei[0]) / 2, (Ui[1] + Ei[1]) / 2], En(si * $s);
+                }
+                _i = null, Un(mi, Ui), yo(ja);
+              }
+              function Nr() {
+                if (e.event.touches.length) {
+                  for (var Gr = e.event.changedTouches, mi = 0, Ui = Gr.length; mi < Ui; ++mi) delete Fo[Gr[mi].identifier];
+                  for (var qi in Fo) return void zt();
+                }
+                e.selectAll(Sc).on(Sl, null), Me.on(jt, go).on(qr, Is), bt(), Da(ja);
+              }
+            }
+            function Ms() {
+              var Gn = bi.of(this, arguments);
+              Hr ? clearTimeout(Hr) : (fa.call(this), se = ei(Te = Ne || e.mouse(this)), Ia(Gn)), Hr = setTimeout(function() {
+                Hr = null, Da(Gn);
+              }, 50), _e(), En(Math.pow(2, Fn() * 2e-3) * X.k), Un(Te, se), yo(Gn);
+            }
+            function Xs() {
+              var Gn = e.mouse(this), ja = Math.log(X.k) / Math.LN2;
+              ia(this, Gn, ei(Gn), e.event.shiftKey ? Math.ceil(ja) - 1 : Math.floor(ja) + 1);
+            }
+            return e.rebind(Si, bi, "on");
+          };
+          var qn = [0, 1 / 0], Fn, ra;
+          e.color = la;
+          function la() {
+          }
+          la.prototype.toString = function() {
+            return this.rgb() + "";
+          }, e.hsl = Ut;
+          function Ut(X, se, Te) {
+            return this instanceof Ut ? (this.h = +X, this.s = +se, void (this.l = +Te)) : arguments.length < 2 ? X instanceof Ut ? new Ut(X.h, X.s, X.l) : Ha("" + X, vo, Ut) : new Ut(X, se, Te);
+          }
+          var wt = Ut.prototype = new la();
+          wt.brighter = function(X) {
+            return X = Math.pow(0.7, arguments.length ? X : 1), new Ut(this.h, this.s, this.l / X);
+          }, wt.darker = function(X) {
+            return X = Math.pow(0.7, arguments.length ? X : 1), new Ut(this.h, this.s, X * this.l);
+          }, wt.rgb = function() {
+            return rr(this.h, this.s, this.l);
+          };
+          function rr(X, se, Te) {
+            var Ne, He;
+            X = isNaN(X) ? 0 : (X %= 360) < 0 ? X + 360 : X, se = isNaN(se) || se < 0 ? 0 : se > 1 ? 1 : se, Te = Te < 0 ? 0 : Te > 1 ? 1 : Te, He = Te <= 0.5 ? Te * (1 + se) : Te + se - Te * se, Ne = 2 * Te - He;
+            function Ye(nt) {
+              return nt > 360 ? nt -= 360 : nt < 0 && (nt += 360), nt < 60 ? Ne + (He - Ne) * nt / 60 : nt < 180 ? He : nt < 240 ? Ne + (He - Ne) * (240 - nt) / 60 : Ne;
+            }
+            function kt(nt) {
+              return Math.round(Ye(nt) * 255);
+            }
+            return new Wa(kt(X + 120), kt(X), kt(X - 120));
+          }
+          e.hcl = nr;
+          function nr(X, se, Te) {
+            return this instanceof nr ? (this.h = +X, this.c = +se, void (this.l = +Te)) : arguments.length < 2 ? X instanceof nr ? new nr(X.h, X.c, X.l) : X instanceof ri ? Sn(X.l, X.a, X.b) : Sn((X = jn((X = e.rgb(X)).r, X.g, X.b)).l, X.a, X.b) : new nr(X, se, Te);
+          }
+          var Er = nr.prototype = new la();
+          Er.brighter = function(X) {
+            return new nr(this.h, this.c, Math.min(100, this.l + Qr * (arguments.length ? X : 1)));
+          }, Er.darker = function(X) {
+            return new nr(this.h, this.c, Math.max(0, this.l - Qr * (arguments.length ? X : 1)));
+          }, Er.rgb = function() {
+            return Xr(this.h, this.c, this.l).rgb();
+          };
+          function Xr(X, se, Te) {
+            return isNaN(X) && (X = 0), isNaN(se) && (se = 0), new ri(Te, Math.cos(X *= ke) * se, Math.sin(X) * se);
+          }
+          e.lab = ri;
+          function ri(X, se, Te) {
+            return this instanceof ri ? (this.l = +X, this.a = +se, void (this.b = +Te)) : arguments.length < 2 ? X instanceof ri ? new ri(X.l, X.a, X.b) : X instanceof nr ? Xr(X.h, X.c, X.l) : jn((X = Wa(X)).r, X.g, X.b) : new ri(X, se, Te);
+          }
+          var Qr = 18, Oi = 0.95047, $i = 1, tn = 1.08883, fn = ri.prototype = new la();
+          fn.brighter = function(X) {
+            return new ri(Math.min(100, this.l + Qr * (arguments.length ? X : 1)), this.a, this.b);
+          }, fn.darker = function(X) {
+            return new ri(Math.max(0, this.l - Qr * (arguments.length ? X : 1)), this.a, this.b);
+          }, fn.rgb = function() {
+            return yn(this.l, this.a, this.b);
+          };
+          function yn(X, se, Te) {
+            var Ne = (X + 16) / 116, He = Ne + se / 500, Ye = Ne - Te / 200;
+            return He = Ba(He) * Oi, Ne = Ba(Ne) * $i, Ye = Ba(Ye) * tn, new Wa(ma(3.2404542 * He - 1.5371385 * Ne - 0.4985314 * Ye), ma(-0.969266 * He + 1.8760108 * Ne + 0.041556 * Ye), ma(0.0556434 * He - 0.2040259 * Ne + 1.0572252 * Ye));
+          }
+          function Sn(X, se, Te) {
+            return X > 0 ? new nr(Math.atan2(Te, se) * vt, Math.sqrt(se * se + Te * Te), X) : new nr(NaN, NaN, X);
+          }
+          function Ba(X) {
+            return X > 0.206893034 ? X * X * X : (X - 4 / 29) / 7.787037;
+          }
+          function ua(X) {
+            return X > 8856e-6 ? Math.pow(X, 1 / 3) : 7.787037 * X + 4 / 29;
+          }
+          function ma(X) {
+            return Math.round(255 * (X <= 304e-5 ? 12.92 * X : 1.055 * Math.pow(X, 1 / 2.4) - 0.055));
+          }
+          e.rgb = Wa;
+          function Wa(X, se, Te) {
+            return this instanceof Wa ? (this.r = ~~X, this.g = ~~se, void (this.b = ~~Te)) : arguments.length < 2 ? X instanceof Wa ? new Wa(X.r, X.g, X.b) : Ha("" + X, Wa, rr) : new Wa(X, se, Te);
+          }
+          function Fa(X) {
+            return new Wa(X >> 16, X >> 8 & 255, X & 255);
+          }
+          function Xo(X) {
+            return Fa(X) + "";
+          }
+          var da = Wa.prototype = new la();
+          da.brighter = function(X) {
+            X = Math.pow(0.7, arguments.length ? X : 1);
+            var se = this.r, Te = this.g, Ne = this.b, He = 30;
+            return !se && !Te && !Ne ? new Wa(He, He, He) : (se && se < He && (se = He), Te && Te < He && (Te = He), Ne && Ne < He && (Ne = He), new Wa(Math.min(255, se / X), Math.min(255, Te / X), Math.min(255, Ne / X)));
+          }, da.darker = function(X) {
+            return X = Math.pow(0.7, arguments.length ? X : 1), new Wa(X * this.r, X * this.g, X * this.b);
+          }, da.hsl = function() {
+            return vo(this.r, this.g, this.b);
+          }, da.toString = function() {
+            return "#" + Wn(this.r) + Wn(this.g) + Wn(this.b);
+          };
+          function Wn(X) {
+            return X < 16 ? "0" + Math.max(0, X).toString(16) : Math.min(255, X).toString(16);
+          }
+          function Ha(X, se, Te) {
+            var Ne = 0, He = 0, Ye = 0, kt, nt, jt;
+            if (kt = /([a-z]+)\((.*)\)/.exec(X = X.toLowerCase()), kt) switch (nt = kt[2].split(","), kt[1]) {
+              case "hsl":
+                return Te(parseFloat(nt[0]), parseFloat(nt[1]) / 100, parseFloat(nt[2]) / 100);
+              case "rgb":
+                return se(kr(nt[0]), kr(nt[1]), kr(nt[2]));
+            }
+            return (jt = Jr.get(X)) ? se(jt.r, jt.g, jt.b) : (X != null && X.charAt(0) === "#" && !isNaN(jt = parseInt(X.slice(1), 16)) && (X.length === 4 ? (Ne = (jt & 3840) >> 4, Ne = Ne >> 4 | Ne, He = jt & 240, He = He >> 4 | He, Ye = jt & 15, Ye = Ye << 4 | Ye) : X.length === 7 && (Ne = (jt & 16711680) >> 16, He = (jt & 65280) >> 8, Ye = jt & 255)), se(Ne, He, Ye));
+          }
+          function vo(X, se, Te) {
+            var Ne = Math.min(X /= 255, se /= 255, Te /= 255), He = Math.max(X, se, Te), Ye = He - Ne, kt, nt, jt = (He + Ne) / 2;
+            return Ye ? (nt = jt < 0.5 ? Ye / (He + Ne) : Ye / (2 - He - Ne), X == He ? kt = (se - Te) / Ye + (se < Te ? 6 : 0) : se == He ? kt = (Te - X) / Ye + 2 : kt = (X - se) / Ye + 4, kt *= 60) : (kt = NaN, nt = jt > 0 && jt < 1 ? 0 : kt), new Ut(kt, nt, jt);
+          }
+          function jn(X, se, Te) {
+            X = Mt(X), se = Mt(se), Te = Mt(Te);
+            var Ne = ua((0.4124564 * X + 0.3575761 * se + 0.1804375 * Te) / Oi), He = ua((0.2126729 * X + 0.7151522 * se + 0.072175 * Te) / $i), Ye = ua((0.0193339 * X + 0.119192 * se + 0.9503041 * Te) / tn);
+            return ri(116 * He - 16, 500 * (Ne - He), 200 * (He - Ye));
+          }
+          function Mt(X) {
+            return (X /= 255) <= 0.04045 ? X / 12.92 : Math.pow((X + 0.055) / 1.055, 2.4);
+          }
+          function kr(X) {
+            var se = parseFloat(X);
+            return X.charAt(X.length - 1) === "%" ? Math.round(se * 2.55) : se;
+          }
+          var Jr = e.map({ aliceblue: 15792383, antiquewhite: 16444375, aqua: 65535, aquamarine: 8388564, azure: 15794175, beige: 16119260, bisque: 16770244, black: 0, blanchedalmond: 16772045, blue: 255, blueviolet: 9055202, brown: 10824234, burlywood: 14596231, cadetblue: 6266528, chartreuse: 8388352, chocolate: 13789470, coral: 16744272, cornflowerblue: 6591981, cornsilk: 16775388, crimson: 14423100, cyan: 65535, darkblue: 139, darkcyan: 35723, darkgoldenrod: 12092939, darkgray: 11119017, darkgreen: 25600, darkgrey: 11119017, darkkhaki: 12433259, darkmagenta: 9109643, darkolivegreen: 5597999, darkorange: 16747520, darkorchid: 10040012, darkred: 9109504, darksalmon: 15308410, darkseagreen: 9419919, darkslateblue: 4734347, darkslategray: 3100495, darkslategrey: 3100495, darkturquoise: 52945, darkviolet: 9699539, deeppink: 16716947, deepskyblue: 49151, dimgray: 6908265, dimgrey: 6908265, dodgerblue: 2003199, firebrick: 11674146, floralwhite: 16775920, forestgreen: 2263842, fuchsia: 16711935, gainsboro: 14474460, ghostwhite: 16316671, gold: 16766720, goldenrod: 14329120, gray: 8421504, green: 32768, greenyellow: 11403055, grey: 8421504, honeydew: 15794160, hotpink: 16738740, indianred: 13458524, indigo: 4915330, ivory: 16777200, khaki: 15787660, lavender: 15132410, lavenderblush: 16773365, lawngreen: 8190976, lemonchiffon: 16775885, lightblue: 11393254, lightcoral: 15761536, lightcyan: 14745599, lightgoldenrodyellow: 16448210, lightgray: 13882323, lightgreen: 9498256, lightgrey: 13882323, lightpink: 16758465, lightsalmon: 16752762, lightseagreen: 2142890, lightskyblue: 8900346, lightslategray: 7833753, lightslategrey: 7833753, lightsteelblue: 11584734, lightyellow: 16777184, lime: 65280, limegreen: 3329330, linen: 16445670, magenta: 16711935, maroon: 8388608, mediumaquamarine: 6737322, mediumblue: 205, mediumorchid: 12211667, mediumpurple: 9662683, mediumseagreen: 3978097, mediumslateblue: 8087790, mediumspringgreen: 64154, mediumturquoise: 4772300, mediumvioletred: 13047173, midnightblue: 1644912, mintcream: 16121850, mistyrose: 16770273, moccasin: 16770229, navajowhite: 16768685, navy: 128, oldlace: 16643558, olive: 8421376, olivedrab: 7048739, orange: 16753920, orangered: 16729344, orchid: 14315734, palegoldenrod: 15657130, palegreen: 10025880, paleturquoise: 11529966, palevioletred: 14381203, papayawhip: 16773077, peachpuff: 16767673, peru: 13468991, pink: 16761035, plum: 14524637, powderblue: 11591910, purple: 8388736, rebeccapurple: 6697881, red: 16711680, rosybrown: 12357519, royalblue: 4286945, saddlebrown: 9127187, salmon: 16416882, sandybrown: 16032864, seagreen: 3050327, seashell: 16774638, sienna: 10506797, silver: 12632256, skyblue: 8900331, slateblue: 6970061, slategray: 7372944, slategrey: 7372944, snow: 16775930, springgreen: 65407, steelblue: 4620980, tan: 13808780, teal: 32896, thistle: 14204888, tomato: 16737095, turquoise: 4251856, violet: 15631086, wheat: 16113331, white: 16777215, whitesmoke: 16119285, yellow: 16776960, yellowgreen: 10145074 });
+          Jr.forEach(function(X, se) {
+            Jr.set(X, Fa(se));
+          });
+          function vi(X) {
+            return typeof X == "function" ? X : function() {
+              return X;
+            };
+          }
+          e.functor = vi, e.xhr = hn(G);
+          function hn(X) {
+            return function(se, Te, Ne) {
+              return arguments.length === 2 && typeof Te == "function" && (Ne = Te, Te = null), An(se, Te, X, Ne);
+            };
+          }
+          function An(X, se, Te, Ne) {
+            var He = {}, Ye = e.dispatch("beforesend", "progress", "load", "error"), kt = {}, nt = new XMLHttpRequest(), jt = null;
+            self.XDomainRequest && !("withCredentials" in nt) && /^(http(s)?:)?\/\//.test(X) && (nt = new XDomainRequest()), "onload" in nt ? nt.onload = nt.onerror = gr : nt.onreadystatechange = function() {
+              nt.readyState > 3 && gr();
+            };
+            function gr() {
+              var yr = nt.status, Hr;
+              if (!yr && Li(nt) || yr >= 200 && yr < 300 || yr === 304) {
+                try {
+                  Hr = Te.call(He, nt);
+                } catch (qr) {
+                  Ye.error.call(He, qr);
+                  return;
+                }
+                Ye.load.call(He, Hr);
+              } else Ye.error.call(He, nt);
+            }
+            return nt.onprogress = function(yr) {
+              var Hr = e.event;
+              e.event = yr;
+              try {
+                Ye.progress.call(He, nt);
+              } finally {
+                e.event = Hr;
+              }
+            }, He.header = function(yr, Hr) {
+              return yr = (yr + "").toLowerCase(), arguments.length < 2 ? kt[yr] : (Hr == null ? delete kt[yr] : kt[yr] = Hr + "", He);
+            }, He.mimeType = function(yr) {
+              return arguments.length ? (se = yr == null ? null : yr + "", He) : se;
+            }, He.responseType = function(yr) {
+              return arguments.length ? (jt = yr, He) : jt;
+            }, He.response = function(yr) {
+              return Te = yr, He;
+            }, ["get", "post"].forEach(function(yr) {
+              He[yr] = function() {
+                return He.send.apply(He, [yr].concat(r(arguments)));
+              };
+            }), He.send = function(yr, Hr, qr) {
+              if (arguments.length === 2 && typeof Hr == "function" && (qr = Hr, Hr = null), nt.open(yr, X, true), se != null && !("accept" in kt) && (kt.accept = se + ",*/*"), nt.setRequestHeader) for (var _i in kt) nt.setRequestHeader(_i, kt[_i]);
+              return se != null && nt.overrideMimeType && nt.overrideMimeType(se), jt != null && (nt.responseType = jt), qr != null && He.on("error", qr).on("load", function(bi) {
+                qr(null, bi);
+              }), Ye.beforesend.call(He, nt), nt.send(Hr == null ? null : Hr), He;
+            }, He.abort = function() {
+              return nt.abort(), He;
+            }, e.rebind(He, Ye, "on"), Ne == null ? He : He.get(Mn(Ne));
+          }
+          function Mn(X) {
+            return X.length === 1 ? function(se, Te) {
+              X(se == null ? Te : null);
+            } : X;
+          }
+          function Li(X) {
+            var se = X.responseType;
+            return se && se !== "text" ? X.response : X.responseText;
+          }
+          e.dsv = function(X, se) {
+            var Te = new RegExp('["' + X + `
+]`), Ne = X.charCodeAt(0);
+            function He(gr, yr, Hr) {
+              arguments.length < 3 && (Hr = yr, yr = null);
+              var qr = An(gr, se, yr == null ? Ye : kt(yr), Hr);
+              return qr.row = function(_i) {
+                return arguments.length ? qr.response((yr = _i) == null ? Ye : kt(_i)) : yr;
+              }, qr;
+            }
+            function Ye(gr) {
+              return He.parse(gr.responseText);
+            }
+            function kt(gr) {
+              return function(yr) {
+                return He.parse(yr.responseText, gr);
+              };
+            }
+            He.parse = function(gr, yr) {
+              var Hr;
+              return He.parseRows(gr, function(qr, _i) {
+                if (Hr) return Hr(qr, _i - 1);
+                var bi = function(Zr) {
+                  for (var ai = {}, gi = qr.length, Ii = 0; Ii < gi; ++Ii) ai[qr[Ii]] = Zr[Ii];
+                  return ai;
+                };
+                Hr = yr ? function(Zr, ai) {
+                  return yr(bi(Zr), ai);
+                } : bi;
+              });
+            }, He.parseRows = function(gr, yr) {
+              var Hr = {}, qr = {}, _i = [], bi = gr.length, Zr = 0, ai = 0, gi, Ii;
+              function Si() {
+                if (Zr >= bi) return qr;
+                if (Ii) return Ii = false, Hr;
+                var Ln = Zr;
+                if (gr.charCodeAt(Ln) === 34) {
+                  for (var En = Ln; En++ < bi; ) if (gr.charCodeAt(En) === 34) {
+                    if (gr.charCodeAt(En + 1) !== 34) break;
+                    ++En;
+                  }
+                  Zr = En + 2;
+                  var Un = gr.charCodeAt(En + 1);
+                  return Un === 13 ? (Ii = true, gr.charCodeAt(En + 2) === 10 && ++Zr) : Un === 10 && (Ii = true), gr.slice(Ln + 1, En).replace(/""/g, '"');
+                }
+                for (; Zr < bi; ) {
+                  var Un = gr.charCodeAt(Zr++), ia = 1;
+                  if (Un === 10) Ii = true;
+                  else if (Un === 13) Ii = true, gr.charCodeAt(Zr) === 10 && (++Zr, ++ia);
+                  else if (Un !== Ne) continue;
+                  return gr.slice(Ln, Zr - ia);
+                }
+                return gr.slice(Ln);
+              }
+              for (; (gi = Si()) !== qr; ) {
+                for (var ei = []; gi !== Hr && gi !== qr; ) ei.push(gi), gi = Si();
+                yr && (ei = yr(ei, ai++)) == null || _i.push(ei);
+              }
+              return _i;
+            }, He.format = function(gr) {
+              if (Array.isArray(gr[0])) return He.formatRows(gr);
+              var yr = new U(), Hr = [];
+              return gr.forEach(function(qr) {
+                for (var _i in qr) yr.has(_i) || Hr.push(yr.add(_i));
+              }), [Hr.map(jt).join(X)].concat(gr.map(function(qr) {
+                return Hr.map(function(_i) {
+                  return jt(qr[_i]);
+                }).join(X);
+              })).join(`
+`);
+            }, He.formatRows = function(gr) {
+              return gr.map(nt).join(`
+`);
+            };
+            function nt(gr) {
+              return gr.map(jt).join(X);
+            }
+            function jt(gr) {
+              return Te.test(gr) ? '"' + gr.replace(/\"/g, '""') + '"' : gr;
+            }
+            return He;
+          }, e.csv = e.dsv(",", "text/csv"), e.tsv = e.dsv("	", "text/tab-separated-values");
+          var _n, ya, $n, Ma, _o = this[j(this, "requestAnimationFrame")] || function(X) {
+            setTimeout(X, 17);
+          };
+          e.timer = function() {
+            No.apply(this, arguments);
+          };
+          function No(X, se, Te) {
+            var Ne = arguments.length;
+            Ne < 2 && (se = 0), Ne < 3 && (Te = Date.now());
+            var He = Te + se, Ye = { c: X, t: He, n: null };
+            return ya ? ya.n = Ye : _n = Ye, ya = Ye, $n || (Ma = clearTimeout(Ma), $n = 1, _o(po)), Ye;
+          }
+          function po() {
+            var X = Lo(), se = ko() - X;
+            se > 24 ? (isFinite(se) && (clearTimeout(Ma), Ma = setTimeout(po, se)), $n = 0) : ($n = 1, _o(po));
+          }
+          e.timer.flush = function() {
+            Lo(), ko();
+          };
+          function Lo() {
+            for (var X = Date.now(), se = _n; se; ) X >= se.t && se.c(X - se.t) && (se.c = null), se = se.n;
+            return X;
+          }
+          function ko() {
+            for (var X, se = _n, Te = 1 / 0; se; ) se.c ? (se.t < Te && (Te = se.t), se = (X = se).n) : se = X ? X.n = se.n : _n = se.n;
+            return ya = X, Te;
+          }
+          e.round = function(X, se) {
+            return se ? Math.round(X * (se = Math.pow(10, se))) / se : Math.round(X);
+          }, e.geom = {};
+          function Ds(X) {
+            return X[0];
+          }
+          function Fs(X) {
+            return X[1];
+          }
+          e.geom.hull = function(X) {
+            var se = Ds, Te = Fs;
+            if (arguments.length) return Ne(X);
+            function Ne(He) {
+              if (He.length < 3) return [];
+              var Ye = vi(se), kt = vi(Te), nt, jt = He.length, gr = [], yr = [];
+              for (nt = 0; nt < jt; nt++) gr.push([+Ye.call(this, He[nt], nt), +kt.call(this, He[nt], nt), nt]);
+              for (gr.sort(ul), nt = 0; nt < jt; nt++) yr.push([gr[nt][0], -gr[nt][1]]);
+              var Hr = ll(gr), qr = ll(yr), _i = qr[0] === Hr[0], bi = qr[qr.length - 1] === Hr[Hr.length - 1], Zr = [];
+              for (nt = Hr.length - 1; nt >= 0; --nt) Zr.push(He[gr[Hr[nt]][2]]);
+              for (nt = +_i; nt < qr.length - bi; ++nt) Zr.push(He[gr[qr[nt]][2]]);
+              return Zr;
+            }
+            return Ne.x = function(He) {
+              return arguments.length ? (se = He, Ne) : se;
+            }, Ne.y = function(He) {
+              return arguments.length ? (Te = He, Ne) : Te;
+            }, Ne;
+          };
+          function ll(X) {
+            for (var se = X.length, Te = [0, 1], Ne = 2, He = 2; He < se; He++) {
+              for (; Ne > 1 && ar(X[Te[Ne - 2]], X[Te[Ne - 1]], X[He]) <= 0; ) --Ne;
+              Te[Ne++] = He;
+            }
+            return Te.slice(0, Ne);
+          }
+          function ul(X, se) {
+            return X[0] - se[0] || X[1] - se[1];
+          }
+          e.geom.polygon = function(X) {
+            return ie(X, zl), X;
+          };
+          var zl = e.geom.polygon.prototype = [];
+          zl.area = function() {
+            for (var X = -1, se = this.length, Te, Ne = this[se - 1], He = 0; ++X < se; ) Te = Ne, Ne = this[X], He += Te[1] * Ne[0] - Te[0] * Ne[1];
+            return He * 0.5;
+          }, zl.centroid = function(X) {
+            var se = -1, Te = this.length, Ne = 0, He = 0, Ye, kt = this[Te - 1], nt;
+            for (arguments.length || (X = -1 / (6 * this.area())); ++se < Te; ) Ye = kt, kt = this[se], nt = Ye[0] * kt[1] - kt[0] * Ye[1], Ne += (Ye[0] + kt[0]) * nt, He += (Ye[1] + kt[1]) * nt;
+            return [Ne * X, He * X];
+          }, zl.clip = function(X) {
+            for (var se, Te = As(X), Ne = -1, He = this.length - As(this), Ye, kt, nt = this[He - 1], jt, gr, yr; ++Ne < He; ) {
+              for (se = X.slice(), X.length = 0, jt = this[Ne], gr = se[(kt = se.length - Te) - 1], Ye = -1; ++Ye < kt; ) yr = se[Ye], us(yr, nt, jt) ? (us(gr, nt, jt) || X.push(il(gr, yr, nt, jt)), X.push(yr)) : us(gr, nt, jt) && X.push(il(gr, yr, nt, jt)), gr = yr;
+              Te && X.push(X[0]), nt = jt;
+            }
+            return X;
+          };
+          function us(X, se, Te) {
+            return (Te[0] - se[0]) * (X[1] - se[1]) < (Te[1] - se[1]) * (X[0] - se[0]);
+          }
+          function il(X, se, Te, Ne) {
+            var He = X[0], Ye = Te[0], kt = se[0] - He, nt = Ne[0] - Ye, jt = X[1], gr = Te[1], yr = se[1] - jt, Hr = Ne[1] - gr, qr = (nt * (jt - gr) - Hr * (He - Ye)) / (Hr * kt - nt * yr);
+            return [He + qr * kt, jt + qr * yr];
+          }
+          function As(X) {
+            var se = X[0], Te = X[X.length - 1];
+            return !(se[0] - Te[0] || se[1] - Te[1]);
+          }
+          var cl, Ks, zs, Io = [], ls, Yl, Su = [];
+          function nc() {
+            Os(this), this.edge = this.site = this.circle = null;
+          }
+          function bs(X) {
+            var se = Io.pop() || new nc();
+            return se.site = X, se;
+          }
+          function Rn(X) {
+            Oo(X), zs.remove(X), Io.push(X), Os(X);
+          }
+          function _a(X) {
+            var se = X.circle, Te = se.x, Ne = se.cy, He = { x: Te, y: Ne }, Ye = X.P, kt = X.N, nt = [X];
+            Rn(X);
+            for (var jt = Ye; jt.circle && p(Te - jt.circle.x) < Je && p(Ne - jt.circle.cy) < Je; ) Ye = jt.P, nt.unshift(jt), Rn(jt), jt = Ye;
+            nt.unshift(jt), Oo(jt);
+            for (var gr = kt; gr.circle && p(Te - gr.circle.x) < Je && p(Ne - gr.circle.cy) < Je; ) kt = gr.N, nt.push(gr), Rn(gr), gr = kt;
+            nt.push(gr), Oo(gr);
+            var yr = nt.length, Hr;
+            for (Hr = 1; Hr < yr; ++Hr) gr = nt[Hr], jt = nt[Hr - 1], pl(gr.edge, jt.site, gr.site, He);
+            jt = nt[0], gr = nt[yr - 1], gr.edge = rf(jt.site, gr.site, null, He), aa(jt), aa(gr);
+          }
+          function Vu(X) {
+            for (var se = X.x, Te = X.y, Ne, He, Ye, kt, nt = zs._; nt; ) if (Ye = Ol(nt, Te) - se, Ye > Je) nt = nt.L;
+            else if (kt = se - xo(nt, Te), kt > Je) {
+              if (!nt.R) {
+                Ne = nt;
+                break;
+              }
+              nt = nt.R;
+            } else {
+              Ye > -1e-6 ? (Ne = nt.P, He = nt) : kt > -1e-6 ? (Ne = nt, He = nt.N) : Ne = He = nt;
+              break;
+            }
+            var jt = bs(X);
+            if (zs.insert(Ne, jt), !(!Ne && !He)) {
+              if (Ne === He) {
+                Oo(Ne), He = bs(Ne.site), zs.insert(jt, He), jt.edge = He.edge = rf(Ne.site, jt.site), aa(Ne), aa(He);
+                return;
+              }
+              if (!He) {
+                jt.edge = rf(Ne.site, jt.site);
+                return;
+              }
+              Oo(Ne), Oo(He);
+              var gr = Ne.site, yr = gr.x, Hr = gr.y, qr = X.x - yr, _i = X.y - Hr, bi = He.site, Zr = bi.x - yr, ai = bi.y - Hr, gi = 2 * (qr * ai - _i * Zr), Ii = qr * qr + _i * _i, Si = Zr * Zr + ai * ai, ei = { x: (ai * Ii - _i * Si) / gi + yr, y: (qr * Si - Zr * Ii) / gi + Hr };
+              pl(He.edge, gr, bi, ei), jt.edge = rf(gr, X, null, ei), He.edge = rf(X, bi, null, ei), aa(Ne), aa(He);
+            }
+          }
+          function Ol(X, se) {
+            var Te = X.site, Ne = Te.x, He = Te.y, Ye = He - se;
+            if (!Ye) return Ne;
+            var kt = X.P;
+            if (!kt) return -1 / 0;
+            Te = kt.site;
+            var nt = Te.x, jt = Te.y, gr = jt - se;
+            if (!gr) return nt;
+            var yr = nt - Ne, Hr = 1 / Ye - 1 / gr, qr = yr / gr;
+            return Hr ? (-qr + Math.sqrt(qr * qr - 2 * Hr * (yr * yr / (-2 * gr) - jt + gr / 2 + He - Ye / 2))) / Hr + Ne : (Ne + nt) / 2;
+          }
+          function xo(X, se) {
+            var Te = X.N;
+            if (Te) return Ol(Te, se);
+            var Ne = X.site;
+            return Ne.y === se ? Ne.x : 1 / 0;
+          }
+          function Kl(X) {
+            this.site = X, this.edges = [];
+          }
+          Kl.prototype.prepare = function() {
+            for (var X = this.edges, se = X.length, Te; se--; ) Te = X[se].edge, (!Te.b || !Te.a) && X.splice(se, 1);
+            return X.sort(Hl), X.length;
+          };
+          function Ns(X) {
+            for (var se = X[0][0], Te = X[1][0], Ne = X[0][1], He = X[1][1], Ye, kt, nt, jt, gr = Ks, yr = gr.length, Hr, qr, _i, bi, Zr, ai; yr--; ) if (Hr = gr[yr], !(!Hr || !Hr.prepare())) for (_i = Hr.edges, bi = _i.length, qr = 0; qr < bi; ) ai = _i[qr].end(), nt = ai.x, jt = ai.y, Zr = _i[++qr % bi].start(), Ye = Zr.x, kt = Zr.y, (p(nt - Ye) > Je || p(jt - kt) > Je) && (_i.splice(qr, 0, new Zc(Vf(Hr.site, ai, p(nt - se) < Je && He - jt > Je ? { x: se, y: p(Ye - se) < Je ? kt : He } : p(jt - He) < Je && Te - nt > Je ? { x: p(kt - He) < Je ? Ye : Te, y: He } : p(nt - Te) < Je && jt - Ne > Je ? { x: Te, y: p(Ye - Te) < Je ? kt : Ne } : p(jt - Ne) < Je && nt - se > Je ? { x: p(kt - Ne) < Je ? Ye : se, y: Ne } : null), Hr.site, null)), ++bi);
+          }
+          function Hl(X, se) {
+            return se.angle - X.angle;
+          }
+          function ac() {
+            Os(this), this.x = this.y = this.arc = this.site = this.cy = null;
+          }
+          function aa(X) {
+            var se = X.P, Te = X.N;
+            if (!(!se || !Te)) {
+              var Ne = se.site, He = X.site, Ye = Te.site;
+              if (Ne !== Ye) {
+                var kt = He.x, nt = He.y, jt = Ne.x - kt, gr = Ne.y - nt, yr = Ye.x - kt, ai = Ye.y - nt, Hr = 2 * (jt * ai - gr * yr);
+                if (!(Hr >= -1e-12)) {
+                  var qr = jt * jt + gr * gr, _i = yr * yr + ai * ai, bi = (ai * qr - gr * _i) / Hr, Zr = (jt * _i - yr * qr) / Hr, ai = Zr + nt, gi = Su.pop() || new ac();
+                  gi.arc = X, gi.site = He, gi.x = bi + kt, gi.y = ai + Math.sqrt(bi * bi + Zr * Zr), gi.cy = ai, X.circle = gi;
+                  for (var Ii = null, Si = Yl._; Si; ) if (gi.y < Si.y || gi.y === Si.y && gi.x <= Si.x) if (Si.L) Si = Si.L;
+                  else {
+                    Ii = Si.P;
+                    break;
+                  }
+                  else if (Si.R) Si = Si.R;
+                  else {
+                    Ii = Si;
+                    break;
+                  }
+                  Yl.insert(Ii, gi), Ii || (ls = gi);
+                }
+              }
+            }
+          }
+          function Oo(X) {
+            var se = X.circle;
+            se && (se.P || (ls = se.N), Yl.remove(se), Su.push(se), Os(se), X.circle = null);
+          }
+          function qo(X, se, Te, Ne) {
+            return function(He) {
+              var Ye = He.a, kt = He.b, nt = Ye.x, jt = Ye.y, gr = kt.x, yr = kt.y, Hr = 0, qr = 1, _i = gr - nt, bi = yr - jt, Zr;
+              if (Zr = X - nt, !(!_i && Zr > 0)) {
+                if (Zr /= _i, _i < 0) {
+                  if (Zr < Hr) return;
+                  Zr < qr && (qr = Zr);
+                } else if (_i > 0) {
+                  if (Zr > qr) return;
+                  Zr > Hr && (Hr = Zr);
+                }
+                if (Zr = Te - nt, !(!_i && Zr < 0)) {
+                  if (Zr /= _i, _i < 0) {
+                    if (Zr > qr) return;
+                    Zr > Hr && (Hr = Zr);
+                  } else if (_i > 0) {
+                    if (Zr < Hr) return;
+                    Zr < qr && (qr = Zr);
+                  }
+                  if (Zr = se - jt, !(!bi && Zr > 0)) {
+                    if (Zr /= bi, bi < 0) {
+                      if (Zr < Hr) return;
+                      Zr < qr && (qr = Zr);
+                    } else if (bi > 0) {
+                      if (Zr > qr) return;
+                      Zr > Hr && (Hr = Zr);
+                    }
+                    if (Zr = Ne - jt, !(!bi && Zr < 0)) {
+                      if (Zr /= bi, bi < 0) {
+                        if (Zr > qr) return;
+                        Zr > Hr && (Hr = Zr);
+                      } else if (bi > 0) {
+                        if (Zr < Hr) return;
+                        Zr < qr && (qr = Zr);
+                      }
+                      return Hr > 0 && (He.a = { x: nt + Hr * _i, y: jt + Hr * bi }), qr < 1 && (He.b = { x: nt + qr * _i, y: jt + qr * bi }), He;
+                    }
+                  }
+                }
+              }
+            };
+          }
+          function ql(X) {
+            for (var se = cl, Te = qo(X[0][0], X[0][1], X[1][0], X[1][1]), Ne = se.length, He; Ne--; ) He = se[Ne], (!Pc(He, X) || !Te(He) || p(He.a.x - He.b.x) < Je && p(He.a.y - He.b.y) < Je) && (He.a = He.b = null, se.splice(Ne, 1));
+          }
+          function Pc(X, se) {
+            var Te = X.b;
+            if (Te) return true;
+            var Ne = X.a, He = se[0][0], Ye = se[1][0], kt = se[0][1], nt = se[1][1], jt = X.l, gr = X.r, yr = jt.x, Hr = jt.y, qr = gr.x, _i = gr.y, bi = (yr + qr) / 2, Zr = (Hr + _i) / 2, ai, gi;
+            if (_i === Hr) {
+              if (bi < He || bi >= Ye) return;
+              if (yr > qr) {
+                if (!Ne) Ne = { x: bi, y: kt };
+                else if (Ne.y >= nt) return;
+                Te = { x: bi, y: nt };
+              } else {
+                if (!Ne) Ne = { x: bi, y: nt };
+                else if (Ne.y < kt) return;
+                Te = { x: bi, y: kt };
+              }
+            } else if (ai = (yr - qr) / (_i - Hr), gi = Zr - ai * bi, ai < -1 || ai > 1) if (yr > qr) {
+              if (!Ne) Ne = { x: (kt - gi) / ai, y: kt };
+              else if (Ne.y >= nt) return;
+              Te = { x: (nt - gi) / ai, y: nt };
+            } else {
+              if (!Ne) Ne = { x: (nt - gi) / ai, y: nt };
+              else if (Ne.y < kt) return;
+              Te = { x: (kt - gi) / ai, y: kt };
+            }
+            else if (Hr < _i) {
+              if (!Ne) Ne = { x: He, y: ai * He + gi };
+              else if (Ne.x >= Ye) return;
+              Te = { x: Ye, y: ai * Ye + gi };
+            } else {
+              if (!Ne) Ne = { x: Ye, y: ai * Ye + gi };
+              else if (Ne.x < He) return;
+              Te = { x: He, y: ai * He + gi };
+            }
+            return X.a = Ne, X.b = Te, true;
+          }
+          function Do(X, se) {
+            this.l = X, this.r = se, this.a = this.b = null;
+          }
+          function rf(X, se, Te, Ne) {
+            var He = new Do(X, se);
+            return cl.push(He), Te && pl(He, X, se, Te), Ne && pl(He, se, X, Ne), Ks[X.i].edges.push(new Zc(He, X, se)), Ks[se.i].edges.push(new Zc(He, se, X)), He;
+          }
+          function Vf(X, se, Te) {
+            var Ne = new Do(X, null);
+            return Ne.a = se, Ne.b = Te, cl.push(Ne), Ne;
+          }
+          function pl(X, se, Te, Ne) {
+            !X.a && !X.b ? (X.a = Ne, X.l = se, X.r = Te) : X.l === Te ? X.b = Ne : X.a = Ne;
+          }
+          function Zc(X, se, Te) {
+            var Ne = X.a, He = X.b;
+            this.edge = X, this.site = se, this.angle = Te ? Math.atan2(Te.y - se.y, Te.x - se.x) : X.l === se ? Math.atan2(He.x - Ne.x, Ne.y - He.y) : Math.atan2(Ne.x - He.x, He.y - Ne.y);
+          }
+          Zc.prototype = { start: function() {
+            return this.edge.l === this.site ? this.edge.a : this.edge.b;
+          }, end: function() {
+            return this.edge.l === this.site ? this.edge.b : this.edge.a;
+          } };
+          function Jl() {
+            this._ = null;
+          }
+          function Os(X) {
+            X.U = X.C = X.L = X.R = X.P = X.N = null;
+          }
+          Jl.prototype = { insert: function(X, se) {
+            var Te, Ne, He;
+            if (X) {
+              if (se.P = X, se.N = X.N, X.N && (X.N.P = se), X.N = se, X.R) {
+                for (X = X.R; X.L; ) X = X.L;
+                X.L = se;
+              } else X.R = se;
+              Te = X;
+            } else this._ ? (X = Cf(this._), se.P = null, se.N = X, X.P = X.L = se, Te = X) : (se.P = se.N = null, this._ = se, Te = null);
+            for (se.L = se.R = null, se.U = Te, se.C = true, X = se; Te && Te.C; ) Ne = Te.U, Te === Ne.L ? (He = Ne.R, He && He.C ? (Te.C = He.C = false, Ne.C = true, X = Ne) : (X === Te.R && (yu(this, Te), X = Te, Te = X.U), Te.C = false, Ne.C = true, oc(this, Ne))) : (He = Ne.L, He && He.C ? (Te.C = He.C = false, Ne.C = true, X = Ne) : (X === Te.L && (oc(this, Te), X = Te, Te = X.U), Te.C = false, Ne.C = true, yu(this, Ne))), Te = X.U;
+            this._.C = false;
+          }, remove: function(X) {
+            X.N && (X.N.P = X.P), X.P && (X.P.N = X.N), X.N = X.P = null;
+            var se = X.U, Te, Ne = X.L, He = X.R, Ye, kt;
+            if (Ne ? He ? Ye = Cf(He) : Ye = Ne : Ye = He, se ? se.L === X ? se.L = Ye : se.R = Ye : this._ = Ye, Ne && He ? (kt = Ye.C, Ye.C = X.C, Ye.L = Ne, Ne.U = Ye, Ye !== He ? (se = Ye.U, Ye.U = X.U, X = Ye.R, se.L = X, Ye.R = He, He.U = Ye) : (Ye.U = se, se = Ye, X = Ye.R)) : (kt = X.C, X = Ye), X && (X.U = se), !kt) {
+              if (X && X.C) {
+                X.C = false;
+                return;
+              }
+              do {
+                if (X === this._) break;
+                if (X === se.L) {
+                  if (Te = se.R, Te.C && (Te.C = false, se.C = true, yu(this, se), Te = se.R), Te.L && Te.L.C || Te.R && Te.R.C) {
+                    (!Te.R || !Te.R.C) && (Te.L.C = false, Te.C = true, oc(this, Te), Te = se.R), Te.C = se.C, se.C = Te.R.C = false, yu(this, se), X = this._;
+                    break;
+                  }
+                } else if (Te = se.L, Te.C && (Te.C = false, se.C = true, oc(this, se), Te = se.L), Te.L && Te.L.C || Te.R && Te.R.C) {
+                  (!Te.L || !Te.L.C) && (Te.R.C = false, Te.C = true, yu(this, Te), Te = se.L), Te.C = se.C, se.C = Te.L.C = false, oc(this, se), X = this._;
+                  break;
+                }
+                Te.C = true, X = se, se = se.U;
+              } while (!X.C);
+              X && (X.C = false);
+            }
+          } };
+          function yu(X, se) {
+            var Te = se, Ne = se.R, He = Te.U;
+            He ? He.L === Te ? He.L = Ne : He.R = Ne : X._ = Ne, Ne.U = He, Te.U = Ne, Te.R = Ne.L, Te.R && (Te.R.U = Te), Ne.L = Te;
+          }
+          function oc(X, se) {
+            var Te = se, Ne = se.L, He = Te.U;
+            He ? He.L === Te ? He.L = Ne : He.R = Ne : X._ = Ne, Ne.U = He, Te.U = Ne, Te.L = Ne.R, Te.L && (Te.L.U = Te), Ne.R = Te;
+          }
+          function Cf(X) {
+            for (; X.L; ) X = X.L;
+            return X;
+          }
+          function sc(X, se) {
+            var Te = X.sort(jh).pop(), Ne, He, Ye;
+            for (cl = [], Ks = new Array(X.length), zs = new Jl(), Yl = new Jl(); ; ) if (Ye = ls, Te && (!Ye || Te.y < Ye.y || Te.y === Ye.y && Te.x < Ye.x)) (Te.x !== Ne || Te.y !== He) && (Ks[Te.i] = new Kl(Te), Vu(Te), Ne = Te.x, He = Te.y), Te = X.pop();
+            else if (Ye) _a(Ye.arc);
+            else break;
+            se && (ql(se), Ns(se));
+            var kt = { cells: Ks, edges: cl };
+            return zs = Yl = cl = Ks = null, kt;
+          }
+          function jh(X, se) {
+            return se.y - X.y || se.x - X.x;
+          }
+          e.geom.voronoi = function(X) {
+            var se = Ds, Te = Fs, Ne = se, He = Te, Ye = Lf;
+            if (X) return kt(X);
+            function kt(jt) {
+              var gr = new Array(jt.length), yr = Ye[0][0], Hr = Ye[0][1], qr = Ye[1][0], _i = Ye[1][1];
+              return sc(nt(jt), Ye).cells.forEach(function(bi, Zr) {
+                var ai = bi.edges, gi = bi.site, Ii = gr[Zr] = ai.length ? ai.map(function(Si) {
+                  var ei = Si.start();
+                  return [ei.x, ei.y];
+                }) : gi.x >= yr && gi.x <= qr && gi.y >= Hr && gi.y <= _i ? [[yr, _i], [qr, _i], [qr, Hr], [yr, Hr]] : [];
+                Ii.point = jt[Zr];
+              }), gr;
+            }
+            function nt(jt) {
+              return jt.map(function(gr, yr) {
+                return { x: Math.round(Ne(gr, yr) / Je) * Je, y: Math.round(He(gr, yr) / Je) * Je, i: yr };
+              });
+            }
+            return kt.links = function(jt) {
+              return sc(nt(jt)).edges.filter(function(gr) {
+                return gr.l && gr.r;
+              }).map(function(gr) {
+                return { source: jt[gr.l.i], target: jt[gr.r.i] };
+              });
+            }, kt.triangles = function(jt) {
+              var gr = [];
+              return sc(nt(jt)).cells.forEach(function(yr, Hr) {
+                for (var qr = yr.site, _i = yr.edges.sort(Hl), bi = -1, Zr = _i.length, ai, gi, Ii = _i[Zr - 1].edge, Si = Ii.l === qr ? Ii.r : Ii.l; ++bi < Zr; ) ai = Ii, gi = Si, Ii = _i[bi].edge, Si = Ii.l === qr ? Ii.r : Ii.l, Hr < gi.i && Hr < Si.i && cs(qr, gi, Si) < 0 && gr.push([jt[Hr], jt[gi.i], jt[Si.i]]);
+              }), gr;
+            }, kt.x = function(jt) {
+              return arguments.length ? (Ne = vi(se = jt), kt) : se;
+            }, kt.y = function(jt) {
+              return arguments.length ? (He = vi(Te = jt), kt) : Te;
+            }, kt.clipExtent = function(jt) {
+              return arguments.length ? (Ye = jt == null ? Lf : jt, kt) : Ye === Lf ? null : Ye;
+            }, kt.size = function(jt) {
+              return arguments.length ? kt.clipExtent(jt && [[0, 0], jt]) : Ye === Lf ? null : Ye && Ye[1];
+            }, kt;
+          };
+          var Lf = [[-1e6, -1e6], [1e6, 1e6]];
+          function cs(X, se, Te) {
+            return (X.x - Te.x) * (se.y - X.y) - (X.x - se.x) * (Te.y - X.y);
+          }
+          e.geom.delaunay = function(X) {
+            return e.geom.voronoi().triangles(X);
+          }, e.geom.quadtree = function(X, se, Te, Ne, He) {
+            var Ye = Ds, kt = Fs, nt;
+            if (nt = arguments.length) return Ye = nf, kt = Gf, nt === 3 && (He = Te, Ne = se, Te = se = 0), jt(X);
+            function jt(gr) {
+              var yr, Hr = vi(Ye), qr = vi(kt), _i, bi, Zr, ai, gi, Ii, Si, ei;
+              if (se != null) gi = se, Ii = Te, Si = Ne, ei = He;
+              else if (Si = ei = -(gi = Ii = 1 / 0), _i = [], bi = [], ai = gr.length, nt) for (Zr = 0; Zr < ai; ++Zr) yr = gr[Zr], yr.x < gi && (gi = yr.x), yr.y < Ii && (Ii = yr.y), yr.x > Si && (Si = yr.x), yr.y > ei && (ei = yr.y), _i.push(yr.x), bi.push(yr.y);
+              else for (Zr = 0; Zr < ai; ++Zr) {
+                var Ln = +Hr(yr = gr[Zr], Zr), En = +qr(yr, Zr);
+                Ln < gi && (gi = Ln), En < Ii && (Ii = En), Ln > Si && (Si = Ln), En > ei && (ei = En), _i.push(Ln), bi.push(En);
+              }
+              var Un = Si - gi, ia = ei - Ii;
+              Un > ia ? ei = Ii + Un : Si = gi + ia;
+              function Ea(Da, go, Is, Ms, Xs, Gn, ja, Fo) {
+                if (!(isNaN(Is) || isNaN(Ms))) if (Da.leaf) {
+                  var Uo = Da.x, $s = Da.y;
+                  if (Uo != null) if (p(Uo - Is) + p($s - Ms) < 0.01) Ia(Da, go, Is, Ms, Xs, Gn, ja, Fo);
+                  else {
+                    var Sl = Da.point;
+                    Da.x = Da.y = Da.point = null, Ia(Da, Sl, Uo, $s, Xs, Gn, ja, Fo), Ia(Da, go, Is, Ms, Xs, Gn, ja, Fo);
+                  }
+                  else Da.x = Is, Da.y = Ms, Da.point = go;
+                } else Ia(Da, go, Is, Ms, Xs, Gn, ja, Fo);
+              }
+              function Ia(Da, go, Is, Ms, Xs, Gn, ja, Fo) {
+                var Uo = (Xs + ja) * 0.5, $s = (Gn + Fo) * 0.5, Sl = Is >= Uo, bu = Ms >= $s, dl = bu << 1 | Sl;
+                Da.leaf = false, Da = Da.nodes[dl] || (Da.nodes[dl] = $l()), Sl ? Xs = Uo : ja = Uo, bu ? Gn = $s : Fo = $s, Ea(Da, go, Is, Ms, Xs, Gn, ja, Fo);
+              }
+              var yo = $l();
+              if (yo.add = function(Da) {
+                Ea(yo, Da, +Hr(Da, ++Zr), +qr(Da, Zr), gi, Ii, Si, ei);
+              }, yo.visit = function(Da) {
+                fl(Da, yo, gi, Ii, Si, ei);
+              }, yo.find = function(Da) {
+                return lc(yo, Da[0], Da[1], gi, Ii, Si, ei);
+              }, Zr = -1, se == null) {
+                for (; ++Zr < ai; ) Ea(yo, gr[Zr], _i[Zr], bi[Zr], gi, Ii, Si, ei);
+                --Zr;
+              } else gr.forEach(yo.add);
+              return _i = bi = gr = yr = null, yo;
+            }
+            return jt.x = function(gr) {
+              return arguments.length ? (Ye = gr, jt) : Ye;
+            }, jt.y = function(gr) {
+              return arguments.length ? (kt = gr, jt) : kt;
+            }, jt.extent = function(gr) {
+              return arguments.length ? (gr == null ? se = Te = Ne = He = null : (se = +gr[0][0], Te = +gr[0][1], Ne = +gr[1][0], He = +gr[1][1]), jt) : se == null ? null : [[se, Te], [Ne, He]];
+            }, jt.size = function(gr) {
+              return arguments.length ? (gr == null ? se = Te = Ne = He = null : (se = Te = 0, Ne = +gr[0], He = +gr[1]), jt) : se == null ? null : [Ne - se, He - Te];
+            }, jt;
+          };
+          function nf(X) {
+            return X.x;
+          }
+          function Gf(X) {
+            return X.y;
+          }
+          function $l() {
+            return { leaf: true, nodes: [], point: null, x: null, y: null };
+          }
+          function fl(X, se, Te, Ne, He, Ye) {
+            if (!X(se, Te, Ne, He, Ye)) {
+              var kt = (Te + He) * 0.5, nt = (Ne + Ye) * 0.5, jt = se.nodes;
+              jt[0] && fl(X, jt[0], Te, Ne, kt, nt), jt[1] && fl(X, jt[1], kt, Ne, He, nt), jt[2] && fl(X, jt[2], Te, nt, kt, Ye), jt[3] && fl(X, jt[3], kt, nt, He, Ye);
+            }
+          }
+          function lc(X, se, Te, Ne, He, Ye, kt) {
+            var nt = 1 / 0, jt;
+            return function gr(yr, Hr, qr, _i, bi) {
+              if (!(Hr > Ye || qr > kt || _i < Ne || bi < He)) {
+                if (Zr = yr.point) {
+                  var Zr, ai = se - yr.x, gi = Te - yr.y, Ii = ai * ai + gi * gi;
+                  if (Ii < nt) {
+                    var Si = Math.sqrt(nt = Ii);
+                    Ne = se - Si, He = Te - Si, Ye = se + Si, kt = Te + Si, jt = Zr;
+                  }
+                }
+                for (var ei = yr.nodes, Ln = (Hr + _i) * 0.5, En = (qr + bi) * 0.5, Un = se >= Ln, ia = Te >= En, Ea = ia << 1 | Un, Ia = Ea + 4; Ea < Ia; ++Ea) if (yr = ei[Ea & 3]) switch (Ea & 3) {
+                  case 0:
+                    gr(yr, Hr, qr, Ln, En);
+                    break;
+                  case 1:
+                    gr(yr, Ln, qr, _i, En);
+                    break;
+                  case 2:
+                    gr(yr, Hr, En, Ln, bi);
+                    break;
+                  case 3:
+                    gr(yr, Ln, En, _i, bi);
+                    break;
+                }
+              }
+            }(X, Ne, He, Ye, kt), jt;
+          }
+          e.interpolateRgb = Fu;
+          function Fu(X, se) {
+            X = e.rgb(X), se = e.rgb(se);
+            var Te = X.r, Ne = X.g, He = X.b, Ye = se.r - Te, kt = se.g - Ne, nt = se.b - He;
+            return function(jt) {
+              return "#" + Wn(Math.round(Te + Ye * jt)) + Wn(Math.round(Ne + kt * jt)) + Wn(Math.round(He + nt * jt));
+            };
+          }
+          e.interpolateObject = Es;
+          function Es(X, se) {
+            var Te = {}, Ne = {}, He;
+            for (He in X) He in se ? Te[He] = xl(X[He], se[He]) : Ne[He] = X[He];
+            for (He in se) He in X || (Ne[He] = se[He]);
+            return function(Ye) {
+              for (He in Te) Ne[He] = Te[He](Ye);
+              return Ne;
+            };
+          }
+          e.interpolateNumber = Hs;
+          function Hs(X, se) {
+            return X = +X, se = +se, function(Te) {
+              return X * (1 - Te) + se * Te;
+            };
+          }
+          e.interpolateString = Go;
+          function Go(X, se) {
+            var Te = ps.lastIndex = uc.lastIndex = 0, Ne, He, Ye, kt = -1, nt = [], jt = [];
+            for (X = X + "", se = se + ""; (Ne = ps.exec(X)) && (He = uc.exec(se)); ) (Ye = He.index) > Te && (Ye = se.slice(Te, Ye), nt[kt] ? nt[kt] += Ye : nt[++kt] = Ye), (Ne = Ne[0]) === (He = He[0]) ? nt[kt] ? nt[kt] += He : nt[++kt] = He : (nt[++kt] = null, jt.push({ i: kt, x: Hs(Ne, He) })), Te = uc.lastIndex;
+            return Te < se.length && (Ye = se.slice(Te), nt[kt] ? nt[kt] += Ye : nt[++kt] = Ye), nt.length < 2 ? jt[0] ? (se = jt[0].x, function(gr) {
+              return se(gr) + "";
+            }) : function() {
+              return se;
+            } : (se = jt.length, function(gr) {
+              for (var yr = 0, Hr; yr < se; ++yr) nt[(Hr = jt[yr]).i] = Hr.x(gr);
+              return nt.join("");
+            });
+          }
+          var ps = /[-+]?(?:\d+\.?\d*|\.?\d+)(?:[eE][-+]?\d+)?/g, uc = new RegExp(ps.source, "g");
+          e.interpolate = xl;
+          function xl(X, se) {
+            for (var Te = e.interpolators.length, Ne; --Te >= 0 && !(Ne = e.interpolators[Te](X, se)); ) ;
+            return Ne;
+          }
+          e.interpolators = [function(X, se) {
+            var Te = typeof se;
+            return (Te === "string" ? Jr.has(se.toLowerCase()) || /^(#|rgb\(|hsl\()/i.test(se) ? Fu : Go : se instanceof la ? Fu : Array.isArray(se) ? Gu : Te === "object" && isNaN(se) ? Es : Hs)(X, se);
+          }], e.interpolateArray = Gu;
+          function Gu(X, se) {
+            var Te = [], Ne = [], He = X.length, Ye = se.length, kt = Math.min(X.length, se.length), nt;
+            for (nt = 0; nt < kt; ++nt) Te.push(xl(X[nt], se[nt]));
+            for (; nt < He; ++nt) Ne[nt] = X[nt];
+            for (; nt < Ye; ++nt) Ne[nt] = se[nt];
+            return function(jt) {
+              for (nt = 0; nt < kt; ++nt) Ne[nt] = Te[nt](jt);
+              return Ne;
+            };
+          }
+          var qs = function() {
+            return G;
+          }, od = e.map({ linear: qs, poly: Hf, quad: function() {
+            return af;
+          }, cubic: function() {
+            return Hu;
+          }, sin: function() {
+            return Ic;
+          }, exp: function() {
+            return yf;
+          }, circle: function() {
+            return Bl;
+          }, elastic: Ah, back: Qf, bounce: function() {
+            return _f;
+          } }), Po = e.map({ in: G, out: Ko, "in-out": Pa, "out-in": function(X) {
+            return Pa(Ko(X));
+          } });
+          e.ease = function(X) {
+            var se = X.indexOf("-"), Te = se >= 0 ? X.slice(0, se) : X, Ne = se >= 0 ? X.slice(se + 1) : "in";
+            return Te = od.get(Te) || qs, Ne = Po.get(Ne) || G, sd(Ne(Te.apply(null, t.call(arguments, 1))));
+          };
+          function sd(X) {
+            return function(se) {
+              return se <= 0 ? 0 : se >= 1 ? 1 : X(se);
+            };
+          }
+          function Ko(X) {
+            return function(se) {
+              return 1 - X(1 - se);
+            };
+          }
+          function Pa(X) {
+            return function(se) {
+              return 0.5 * (se < 0.5 ? X(2 * se) : 2 - X(2 - 2 * se));
+            };
+          }
+          function af(X) {
+            return X * X;
+          }
+          function Hu(X) {
+            return X * X * X;
+          }
+          function bl(X) {
+            if (X <= 0) return 0;
+            if (X >= 1) return 1;
+            var se = X * X, Te = se * X;
+            return 4 * (X < 0.5 ? Te : 3 * (X - se) + Te - 0.75);
+          }
+          function Hf(X) {
+            return function(se) {
+              return Math.pow(se, X);
+            };
+          }
+          function Ic(X) {
+            return 1 - Math.cos(X * xe);
+          }
+          function yf(X) {
+            return Math.pow(2, 10 * (X - 1));
+          }
+          function Bl(X) {
+            return 1 - Math.sqrt(1 - X * X);
+          }
+          function Ah(X, se) {
+            var Te;
+            return arguments.length < 2 && (se = 0.45), arguments.length ? Te = se / xt * Math.asin(1 / X) : (X = 1, Te = se / 4), function(Ne) {
+              return 1 + X * Math.pow(2, -10 * Ne) * Math.sin((Ne - Te) * xt / se);
+            };
+          }
+          function Qf(X) {
+            return X || (X = 1.70158), function(se) {
+              return se * se * ((X + 1) * se - X);
+            };
+          }
+          function _f(X) {
+            return X < 1 / 2.75 ? 7.5625 * X * X : X < 2 / 2.75 ? 7.5625 * (X -= 1.5 / 2.75) * X + 0.75 : X < 2.5 / 2.75 ? 7.5625 * (X -= 2.25 / 2.75) * X + 0.9375 : 7.5625 * (X -= 2.625 / 2.75) * X + 0.984375;
+          }
+          e.interpolateHcl = Yc;
+          function Yc(X, se) {
+            X = e.hcl(X), se = e.hcl(se);
+            var Te = X.h, Ne = X.c, He = X.l, Ye = se.h - Te, kt = se.c - Ne, nt = se.l - He;
+            return isNaN(kt) && (kt = 0, Ne = isNaN(Ne) ? se.c : Ne), isNaN(Ye) ? (Ye = 0, Te = isNaN(Te) ? se.h : Te) : Ye > 180 ? Ye -= 360 : Ye < -180 && (Ye += 360), function(jt) {
+              return Xr(Te + Ye * jt, Ne + kt * jt, He + nt * jt) + "";
+            };
+          }
+          e.interpolateHsl = eh;
+          function eh(X, se) {
+            X = e.hsl(X), se = e.hsl(se);
+            var Te = X.h, Ne = X.s, He = X.l, Ye = se.h - Te, kt = se.s - Ne, nt = se.l - He;
+            return isNaN(kt) && (kt = 0, Ne = isNaN(Ne) ? se.s : Ne), isNaN(Ye) ? (Ye = 0, Te = isNaN(Te) ? se.h : Te) : Ye > 180 ? Ye -= 360 : Ye < -180 && (Ye += 360), function(jt) {
+              return rr(Te + Ye * jt, Ne + kt * jt, He + nt * jt) + "";
+            };
+          }
+          e.interpolateLab = th;
+          function th(X, se) {
+            X = e.lab(X), se = e.lab(se);
+            var Te = X.l, Ne = X.a, He = X.b, Ye = se.l - Te, kt = se.a - Ne, nt = se.b - He;
+            return function(jt) {
+              return yn(Te + Ye * jt, Ne + kt * jt, He + nt * jt) + "";
+            };
+          }
+          e.interpolateRound = ju;
+          function ju(X, se) {
+            return se -= X, function(Te) {
+              return Math.round(X + se * Te);
+            };
+          }
+          e.transform = function(X) {
+            var se = n.createElementNS(e.ns.prefix.svg, "g");
+            return (e.transform = function(Te) {
+              if (Te != null) {
+                se.setAttribute("transform", Te);
+                var Ne = se.transform.baseVal.consolidate();
+              }
+              return new jf(Ne ? Ne.matrix : Kc);
+            })(X);
+          };
+          function jf(X) {
+            var se = [X.a, X.b], Te = [X.c, X.d], Ne = of(se), He = cc(se, Te), Ye = of(Nl(Te, se, -He)) || 0;
+            se[0] * Te[1] < Te[0] * se[1] && (se[0] *= -1, se[1] *= -1, Ne *= -1, He *= -1), this.rotate = (Ne ? Math.atan2(se[1], se[0]) : Math.atan2(-Te[0], Te[1])) * vt, this.translate = [X.e, X.f], this.scale = [Ne, Ye], this.skew = Ye ? Math.atan2(He, Ye) * vt : 0;
+          }
+          jf.prototype.toString = function() {
+            return "translate(" + this.translate + ")rotate(" + this.rotate + ")skewX(" + this.skew + ")scale(" + this.scale + ")";
+          };
+          function cc(X, se) {
+            return X[0] * se[0] + X[1] * se[1];
+          }
+          function of(X) {
+            var se = Math.sqrt(cc(X, X));
+            return se && (X[0] /= se, X[1] /= se), se;
+          }
+          function Nl(X, se, Te) {
+            return X[0] += Te * se[0], X[1] += Te * se[1], X;
+          }
+          var Kc = { a: 1, b: 0, c: 0, d: 1, e: 0, f: 0 };
+          e.interpolateTransform = sf;
+          function Rc(X) {
+            return X.length ? X.pop() + "," : "";
+          }
+          function gs(X, se, Te, Ne) {
+            if (X[0] !== se[0] || X[1] !== se[1]) {
+              var He = Te.push("translate(", null, ",", null, ")");
+              Ne.push({ i: He - 4, x: Hs(X[0], se[0]) }, { i: He - 2, x: Hs(X[1], se[1]) });
+            } else (se[0] || se[1]) && Te.push("translate(" + se + ")");
+          }
+          function Wf(X, se, Te, Ne) {
+            X !== se ? (X - se > 180 ? se += 360 : se - X > 180 && (X += 360), Ne.push({ i: Te.push(Rc(Te) + "rotate(", null, ")") - 2, x: Hs(X, se) })) : se && Te.push(Rc(Te) + "rotate(" + se + ")");
+          }
+          function Wh(X, se, Te, Ne) {
+            X !== se ? Ne.push({ i: Te.push(Rc(Te) + "skewX(", null, ")") - 2, x: Hs(X, se) }) : se && Te.push(Rc(Te) + "skewX(" + se + ")");
+          }
+          function rh(X, se, Te, Ne) {
+            if (X[0] !== se[0] || X[1] !== se[1]) {
+              var He = Te.push(Rc(Te) + "scale(", null, ",", null, ")");
+              Ne.push({ i: He - 4, x: Hs(X[0], se[0]) }, { i: He - 2, x: Hs(X[1], se[1]) });
+            } else (se[0] !== 1 || se[1] !== 1) && Te.push(Rc(Te) + "scale(" + se + ")");
+          }
+          function sf(X, se) {
+            var Te = [], Ne = [];
+            return X = e.transform(X), se = e.transform(se), gs(X.translate, se.translate, Te, Ne), Wf(X.rotate, se.rotate, Te, Ne), Wh(X.skew, se.skew, Te, Ne), rh(X.scale, se.scale, Te, Ne), X = se = null, function(He) {
+              for (var Ye = -1, kt = Ne.length, nt; ++Ye < kt; ) Te[(nt = Ne[Ye]).i] = nt.x(He);
+              return Te.join("");
+            };
+          }
+          function Sh(X, se) {
+            return se = (se -= X = +X) || 1 / se, function(Te) {
+              return (Te - X) / se;
+            };
+          }
+          function Mu(X, se) {
+            return se = (se -= X = +X) || 1 / se, function(Te) {
+              return Math.max(0, Math.min(1, (Te - X) / se));
+            };
+          }
+          e.layout = {}, e.layout.bundle = function() {
+            return function(X) {
+              for (var se = [], Te = -1, Ne = X.length; ++Te < Ne; ) se.push(ih(X[Te]));
+              return se;
+            };
+          };
+          function ih(X) {
+            for (var se = X.source, Te = X.target, Ne = Eu(se, Te), He = [se]; se !== Ne; ) se = se.parent, He.push(se);
+            for (var Ye = He.length; Te !== Ne; ) He.splice(Ye, 0, Te), Te = Te.parent;
+            return He;
+          }
+          function js(X) {
+            for (var se = [], Te = X.parent; Te != null; ) se.push(X), X = Te, Te = Te.parent;
+            return se.push(X), se;
+          }
+          function Eu(X, se) {
+            if (X === se) return X;
+            for (var Te = js(X), Ne = js(se), He = Te.pop(), Ye = Ne.pop(), kt = null; He === Ye; ) kt = He, He = Te.pop(), Ye = Ne.pop();
+            return kt;
+          }
+          e.layout.chord = function() {
+            var X = {}, se, Te, Ne, He, Ye = 0, kt, nt, jt;
+            function gr() {
+              var Hr = {}, qr = [], _i = e.range(He), bi = [], Zr, ai, gi, Ii, Si;
+              for (se = [], Te = [], Zr = 0, Ii = -1; ++Ii < He; ) {
+                for (ai = 0, Si = -1; ++Si < He; ) ai += Ne[Ii][Si];
+                qr.push(ai), bi.push(e.range(He)), Zr += ai;
+              }
+              for (kt && _i.sort(function(yo, Da) {
+                return kt(qr[yo], qr[Da]);
+              }), nt && bi.forEach(function(yo, Da) {
+                yo.sort(function(go, Is) {
+                  return nt(Ne[Da][go], Ne[Da][Is]);
+                });
+              }), Zr = (xt - Ye * He) / Zr, ai = 0, Ii = -1; ++Ii < He; ) {
+                for (gi = ai, Si = -1; ++Si < He; ) {
+                  var ei = _i[Ii], Ln = bi[ei][Si], En = Ne[ei][Ln], Un = ai, ia = ai += En * Zr;
+                  Hr[ei + "-" + Ln] = { index: ei, subindex: Ln, startAngle: Un, endAngle: ia, value: En };
+                }
+                Te[ei] = { index: ei, startAngle: gi, endAngle: ai, value: qr[ei] }, ai += Ye;
+              }
+              for (Ii = -1; ++Ii < He; ) for (Si = Ii - 1; ++Si < He; ) {
+                var Ea = Hr[Ii + "-" + Si], Ia = Hr[Si + "-" + Ii];
+                (Ea.value || Ia.value) && se.push(Ea.value < Ia.value ? { source: Ia, target: Ea } : { source: Ea, target: Ia });
+              }
+              jt && yr();
+            }
+            function yr() {
+              se.sort(function(Hr, qr) {
+                return jt((Hr.source.value + Hr.target.value) / 2, (qr.source.value + qr.target.value) / 2);
+              });
+            }
+            return X.matrix = function(Hr) {
+              return arguments.length ? (He = (Ne = Hr) && Ne.length, se = Te = null, X) : Ne;
+            }, X.padding = function(Hr) {
+              return arguments.length ? (Ye = Hr, se = Te = null, X) : Ye;
+            }, X.sortGroups = function(Hr) {
+              return arguments.length ? (kt = Hr, se = Te = null, X) : kt;
+            }, X.sortSubgroups = function(Hr) {
+              return arguments.length ? (nt = Hr, se = null, X) : nt;
+            }, X.sortChords = function(Hr) {
+              return arguments.length ? (jt = Hr, se && yr(), X) : jt;
+            }, X.chords = function() {
+              return se || gr(), se;
+            }, X.groups = function() {
+              return Te || gr(), Te;
+            }, X;
+          }, e.layout.force = function() {
+            var X = {}, se = e.dispatch("start", "tick", "end"), Te, Ne = [1, 1], He, Ye, kt = 0.9, nt = nl, jt = nh, gr = -30, yr = Mh, Hr = 0.1, qr = 0.64, _i = [], bi = [], Zr, ai, gi;
+            function Ii(ei) {
+              return function(Ln, En, Un, ia) {
+                if (Ln.point !== ei) {
+                  var Ea = Ln.cx - ei.x, Ia = Ln.cy - ei.y, yo = ia - En, Da = Ea * Ea + Ia * Ia;
+                  if (yo * yo / qr < Da) {
+                    if (Da < yr) {
+                      var go = Ln.charge / Da;
+                      ei.px -= Ea * go, ei.py -= Ia * go;
+                    }
+                    return true;
+                  }
+                  if (Ln.point && Da && Da < yr) {
+                    var go = Ln.pointCharge / Da;
+                    ei.px -= Ea * go, ei.py -= Ia * go;
+                  }
+                }
+                return !Ln.charge;
+              };
+            }
+            X.tick = function() {
+              if ((Ye *= 0.99) < 5e-3) return Te = null, se.end({ type: "end", alpha: Ye = 0 }), true;
+              var ei = _i.length, Ln = bi.length, En, Un, ia, Ea, Ia, yo, Da, go, Is;
+              for (Un = 0; Un < Ln; ++Un) ia = bi[Un], Ea = ia.source, Ia = ia.target, go = Ia.x - Ea.x, Is = Ia.y - Ea.y, (yo = go * go + Is * Is) && (yo = Ye * ai[Un] * ((yo = Math.sqrt(yo)) - Zr[Un]) / yo, go *= yo, Is *= yo, Ia.x -= go * (Da = Ea.weight + Ia.weight ? Ea.weight / (Ea.weight + Ia.weight) : 0.5), Ia.y -= Is * Da, Ea.x += go * (Da = 1 - Da), Ea.y += Is * Da);
+              if ((Da = Ye * Hr) && (go = Ne[0] / 2, Is = Ne[1] / 2, Un = -1, Da)) for (; ++Un < ei; ) ia = _i[Un], ia.x += (go - ia.x) * Da, ia.y += (Is - ia.y) * Da;
+              if (gr) for (_u(En = e.geom.quadtree(_i), Ye, gi), Un = -1; ++Un < ei; ) (ia = _i[Un]).fixed || En.visit(Ii(ia));
+              for (Un = -1; ++Un < ei; ) ia = _i[Un], ia.fixed ? (ia.x = ia.px, ia.y = ia.py) : (ia.x -= (ia.px - (ia.px = ia.x)) * kt, ia.y -= (ia.py - (ia.py = ia.y)) * kt);
+              se.tick({ type: "tick", alpha: Ye });
+            }, X.nodes = function(ei) {
+              return arguments.length ? (_i = ei, X) : _i;
+            }, X.links = function(ei) {
+              return arguments.length ? (bi = ei, X) : bi;
+            }, X.size = function(ei) {
+              return arguments.length ? (Ne = ei, X) : Ne;
+            }, X.linkDistance = function(ei) {
+              return arguments.length ? (nt = typeof ei == "function" ? ei : +ei, X) : nt;
+            }, X.distance = X.linkDistance, X.linkStrength = function(ei) {
+              return arguments.length ? (jt = typeof ei == "function" ? ei : +ei, X) : jt;
+            }, X.friction = function(ei) {
+              return arguments.length ? (kt = +ei, X) : kt;
+            }, X.charge = function(ei) {
+              return arguments.length ? (gr = typeof ei == "function" ? ei : +ei, X) : gr;
+            }, X.chargeDistance = function(ei) {
+              return arguments.length ? (yr = ei * ei, X) : Math.sqrt(yr);
+            }, X.gravity = function(ei) {
+              return arguments.length ? (Hr = +ei, X) : Hr;
+            }, X.theta = function(ei) {
+              return arguments.length ? (qr = ei * ei, X) : Math.sqrt(qr);
+            }, X.alpha = function(ei) {
+              return arguments.length ? (ei = +ei, Ye ? ei > 0 ? Ye = ei : (Te.c = null, Te.t = NaN, Te = null, se.end({ type: "end", alpha: Ye = 0 })) : ei > 0 && (se.start({ type: "start", alpha: Ye = ei }), Te = No(X.tick)), X) : Ye;
+            }, X.start = function() {
+              var ei, Ln = _i.length, En = bi.length, Un = Ne[0], ia = Ne[1], Ea, Ia;
+              for (ei = 0; ei < Ln; ++ei) (Ia = _i[ei]).index = ei, Ia.weight = 0;
+              for (ei = 0; ei < En; ++ei) Ia = bi[ei], typeof Ia.source == "number" && (Ia.source = _i[Ia.source]), typeof Ia.target == "number" && (Ia.target = _i[Ia.target]), ++Ia.source.weight, ++Ia.target.weight;
+              for (ei = 0; ei < Ln; ++ei) Ia = _i[ei], isNaN(Ia.x) && (Ia.x = yo("x", Un)), isNaN(Ia.y) && (Ia.y = yo("y", ia)), isNaN(Ia.px) && (Ia.px = Ia.x), isNaN(Ia.py) && (Ia.py = Ia.y);
+              if (Zr = [], typeof nt == "function") for (ei = 0; ei < En; ++ei) Zr[ei] = +nt.call(this, bi[ei], ei);
+              else for (ei = 0; ei < En; ++ei) Zr[ei] = nt;
+              if (ai = [], typeof jt == "function") for (ei = 0; ei < En; ++ei) ai[ei] = +jt.call(this, bi[ei], ei);
+              else for (ei = 0; ei < En; ++ei) ai[ei] = jt;
+              if (gi = [], typeof gr == "function") for (ei = 0; ei < Ln; ++ei) gi[ei] = +gr.call(this, _i[ei], ei);
+              else for (ei = 0; ei < Ln; ++ei) gi[ei] = gr;
+              function yo(Da, go) {
+                if (!Ea) {
+                  for (Ea = new Array(Ln), Xs = 0; Xs < Ln; ++Xs) Ea[Xs] = [];
+                  for (Xs = 0; Xs < En; ++Xs) {
+                    var Is = bi[Xs];
+                    Ea[Is.source.index].push(Is.target), Ea[Is.target.index].push(Is.source);
+                  }
+                }
+                for (var Ms = Ea[ei], Xs = -1, Gn = Ms.length, ja; ++Xs < Gn; ) if (!isNaN(ja = Ms[Xs][Da])) return ja;
+                return Math.random() * go;
+              }
+              return X.resume();
+            }, X.resume = function() {
+              return X.alpha(0.1);
+            }, X.stop = function() {
+              return X.alpha(0);
+            }, X.drag = function() {
+              if (He || (He = e.behavior.drag().origin(G).on("dragstart.force", Dc).on("drag.force", Si).on("dragend.force", ks)), !arguments.length) return He;
+              this.on("mouseover.force", bc).on("mouseout.force", hu).call(He);
+            };
+            function Si(ei) {
+              ei.px = e.event.x, ei.py = e.event.y, X.resume();
+            }
+            return e.rebind(X, se, "on");
+          };
+          function Dc(X) {
+            X.fixed |= 2;
+          }
+          function ks(X) {
+            X.fixed &= -7;
+          }
+          function bc(X) {
+            X.fixed |= 4, X.px = X.x, X.py = X.y;
+          }
+          function hu(X) {
+            X.fixed &= -5;
+          }
+          function _u(X, se, Te) {
+            var Ne = 0, He = 0;
+            if (X.charge = 0, !X.leaf) for (var Ye = X.nodes, kt = Ye.length, nt = -1, jt; ++nt < kt; ) jt = Ye[nt], jt != null && (_u(jt, se, Te), X.charge += jt.charge, Ne += jt.charge * jt.cx, He += jt.charge * jt.cy);
+            if (X.point) {
+              X.leaf || (X.point.x += Math.random() - 0.5, X.point.y += Math.random() - 0.5);
+              var gr = se * Te[X.point.index];
+              X.charge += X.pointCharge = gr, Ne += gr * X.point.x, He += gr * X.point.y;
+            }
+            X.cx = Ne / X.charge, X.cy = He / X.charge;
+          }
+          var nl = 20, nh = 1, Mh = 1 / 0;
+          e.layout.hierarchy = function() {
+            var X = Pf, se = bd, Te = xf;
+            function Ne(He) {
+              var Ye = [He], kt = [], nt;
+              for (He.depth = 0; (nt = Ye.pop()) != null; ) if (kt.push(nt), (gr = se.call(Ne, nt, nt.depth)) && (jt = gr.length)) {
+                for (var jt, gr, yr; --jt >= 0; ) Ye.push(yr = gr[jt]), yr.parent = nt, yr.depth = nt.depth + 1;
+                Te && (nt.value = 0), nt.children = gr;
+              } else Te && (nt.value = +Te.call(Ne, nt, nt.depth) || 0), delete nt.children;
+              return wc(He, function(Hr) {
+                var qr, _i;
+                X && (qr = Hr.children) && qr.sort(X), Te && (_i = Hr.parent) && (_i.value += Hr.value);
+              }), kt;
+            }
+            return Ne.sort = function(He) {
+              return arguments.length ? (X = He, Ne) : X;
+            }, Ne.children = function(He) {
+              return arguments.length ? (se = He, Ne) : se;
+            }, Ne.value = function(He) {
+              return arguments.length ? (Te = He, Ne) : Te;
+            }, Ne.revalue = function(He) {
+              return Te && (Fc(He, function(Ye) {
+                Ye.children && (Ye.value = 0);
+              }), wc(He, function(Ye) {
+                var kt;
+                Ye.children || (Ye.value = +Te.call(Ne, Ye, Ye.depth) || 0), (kt = Ye.parent) && (kt.value += Ye.value);
+              })), He;
+            }, Ne;
+          };
+          function zu(X, se) {
+            return e.rebind(X, se, "sort", "children", "value"), X.nodes = X, X.links = Ou, X;
+          }
+          function Fc(X, se) {
+            for (var Te = [X]; (X = Te.pop()) != null; ) if (se(X), (He = X.children) && (Ne = He.length)) for (var Ne, He; --Ne >= 0; ) Te.push(He[Ne]);
+          }
+          function wc(X, se) {
+            for (var Te = [X], Ne = []; (X = Te.pop()) != null; ) if (Ne.push(X), (kt = X.children) && (Ye = kt.length)) for (var He = -1, Ye, kt; ++He < Ye; ) Te.push(kt[He]);
+            for (; (X = Ne.pop()) != null; ) se(X);
+          }
+          function bd(X) {
+            return X.children;
+          }
+          function xf(X) {
+            return X.value;
+          }
+          function Pf(X, se) {
+            return se.value - X.value;
+          }
+          function Ou(X) {
+            return e.merge(X.map(function(se) {
+              return (se.children || []).map(function(Te) {
+                return { source: se, target: Te };
+              });
+            }));
+          }
+          e.layout.partition = function() {
+            var X = e.layout.hierarchy(), se = [1, 1];
+            function Te(Ye, kt, nt, jt) {
+              var gr = Ye.children;
+              if (Ye.x = kt, Ye.y = Ye.depth * jt, Ye.dx = nt, Ye.dy = jt, gr && (Hr = gr.length)) {
+                var yr = -1, Hr, qr, _i;
+                for (nt = Ye.value ? nt / Ye.value : 0; ++yr < Hr; ) Te(qr = gr[yr], kt, _i = qr.value * nt, jt), kt += _i;
+              }
+            }
+            function Ne(Ye) {
+              var kt = Ye.children, nt = 0;
+              if (kt && (gr = kt.length)) for (var jt = -1, gr; ++jt < gr; ) nt = Math.max(nt, Ne(kt[jt]));
+              return 1 + nt;
+            }
+            function He(Ye, kt) {
+              var nt = X.call(this, Ye, kt);
+              return Te(nt[0], 0, se[0], se[1] / Ne(nt[0])), nt;
+            }
+            return He.size = function(Ye) {
+              return arguments.length ? (se = Ye, He) : se;
+            }, zu(He, X);
+          }, e.layout.pie = function() {
+            var X = Number, se = bf, Te = 0, Ne = xt, He = 0;
+            function Ye(kt) {
+              var nt = kt.length, jt = kt.map(function(Ii, Si) {
+                return +X.call(Ye, Ii, Si);
+              }), gr = +(typeof Te == "function" ? Te.apply(this, arguments) : Te), yr = (typeof Ne == "function" ? Ne.apply(this, arguments) : Ne) - gr, Hr = Math.min(Math.abs(yr) / nt, +(typeof He == "function" ? He.apply(this, arguments) : He)), qr = Hr * (yr < 0 ? -1 : 1), _i = e.sum(jt), bi = _i ? (yr - nt * qr) / _i : 0, Zr = e.range(nt), ai = [], gi;
+              return se != null && Zr.sort(se === bf ? function(Ii, Si) {
+                return jt[Si] - jt[Ii];
+              } : function(Ii, Si) {
+                return se(kt[Ii], kt[Si]);
+              }), Zr.forEach(function(Ii) {
+                ai[Ii] = { data: kt[Ii], value: gi = jt[Ii], startAngle: gr, endAngle: gr += gi * bi + qr, padAngle: Hr };
+              }), ai;
+            }
+            return Ye.value = function(kt) {
+              return arguments.length ? (X = kt, Ye) : X;
+            }, Ye.sort = function(kt) {
+              return arguments.length ? (se = kt, Ye) : se;
+            }, Ye.startAngle = function(kt) {
+              return arguments.length ? (Te = kt, Ye) : Te;
+            }, Ye.endAngle = function(kt) {
+              return arguments.length ? (Ne = kt, Ye) : Ne;
+            }, Ye.padAngle = function(kt) {
+              return arguments.length ? (He = kt, Ye) : He;
+            }, Ye;
+          };
+          var bf = {};
+          e.layout.stack = function() {
+            var X = G, se = du, Te = ku, Ne = Xh, He = jl, Ye = lf;
+            function kt(nt, jt) {
+              if (!(bi = nt.length)) return nt;
+              var gr = nt.map(function(Ii, Si) {
+                return X.call(kt, Ii, Si);
+              }), yr = gr.map(function(Ii) {
+                return Ii.map(function(Si, ei) {
+                  return [He.call(kt, Si, ei), Ye.call(kt, Si, ei)];
+                });
+              }), Hr = se.call(kt, yr, jt);
+              gr = e.permute(gr, Hr), yr = e.permute(yr, Hr);
+              var qr = Te.call(kt, yr, jt), _i = gr[0].length, bi, Zr, ai, gi;
+              for (ai = 0; ai < _i; ++ai) for (Ne.call(kt, gr[0][ai], gi = qr[ai], yr[0][ai][1]), Zr = 1; Zr < bi; ++Zr) Ne.call(kt, gr[Zr][ai], gi += yr[Zr - 1][ai][1], yr[Zr][ai][1]);
+              return nt;
+            }
+            return kt.values = function(nt) {
+              return arguments.length ? (X = nt, kt) : X;
+            }, kt.order = function(nt) {
+              return arguments.length ? (se = typeof nt == "function" ? nt : If.get(nt) || du, kt) : se;
+            }, kt.offset = function(nt) {
+              return arguments.length ? (Te = typeof nt == "function" ? nt : Cs.get(nt) || ku, kt) : Te;
+            }, kt.x = function(nt) {
+              return arguments.length ? (He = nt, kt) : He;
+            }, kt.y = function(nt) {
+              return arguments.length ? (Ye = nt, kt) : Ye;
+            }, kt.out = function(nt) {
+              return arguments.length ? (Ne = nt, kt) : Ne;
+            }, kt;
+          };
+          function jl(X) {
+            return X.x;
+          }
+          function lf(X) {
+            return X.y;
+          }
+          function Xh(X, se, Te) {
+            X.y0 = se, X.y = Te;
+          }
+          var If = e.map({ "inside-out": function(X) {
+            var se = X.length, Te, Ne, He = X.map(Xf), Ye = X.map(Us), kt = e.range(se).sort(function(Hr, qr) {
+              return He[Hr] - He[qr];
+            }), nt = 0, jt = 0, gr = [], yr = [];
+            for (Te = 0; Te < se; ++Te) Ne = kt[Te], nt < jt ? (nt += Ye[Ne], gr.push(Ne)) : (jt += Ye[Ne], yr.push(Ne));
+            return yr.reverse().concat(gr);
+          }, reverse: function(X) {
+            return e.range(X.length).reverse();
+          }, default: du }), Cs = e.map({ silhouette: function(X) {
+            var se = X.length, Te = X[0].length, Ne = [], He = 0, Ye, kt, nt, jt = [];
+            for (kt = 0; kt < Te; ++kt) {
+              for (Ye = 0, nt = 0; Ye < se; Ye++) nt += X[Ye][kt][1];
+              nt > He && (He = nt), Ne.push(nt);
+            }
+            for (kt = 0; kt < Te; ++kt) jt[kt] = (He - Ne[kt]) / 2;
+            return jt;
+          }, wiggle: function(X) {
+            var se = X.length, Te = X[0], Ne = Te.length, He, Ye, kt, nt, jt, gr, yr, Hr, qr, _i = [];
+            for (_i[0] = Hr = qr = 0, Ye = 1; Ye < Ne; ++Ye) {
+              for (He = 0, nt = 0; He < se; ++He) nt += X[He][Ye][1];
+              for (He = 0, jt = 0, yr = Te[Ye][0] - Te[Ye - 1][0]; He < se; ++He) {
+                for (kt = 0, gr = (X[He][Ye][1] - X[He][Ye - 1][1]) / (2 * yr); kt < He; ++kt) gr += (X[kt][Ye][1] - X[kt][Ye - 1][1]) / yr;
+                jt += gr * X[He][Ye][1];
+              }
+              _i[Ye] = Hr -= nt ? jt / nt * yr : 0, Hr < qr && (qr = Hr);
+            }
+            for (Ye = 0; Ye < Ne; ++Ye) _i[Ye] -= qr;
+            return _i;
+          }, expand: function(X) {
+            var se = X.length, Te = X[0].length, Ne = 1 / se, He, Ye, kt, nt = [];
+            for (Ye = 0; Ye < Te; ++Ye) {
+              for (He = 0, kt = 0; He < se; He++) kt += X[He][Ye][1];
+              if (kt) for (He = 0; He < se; He++) X[He][Ye][1] /= kt;
+              else for (He = 0; He < se; He++) X[He][Ye][1] = Ne;
+            }
+            for (Ye = 0; Ye < Te; ++Ye) nt[Ye] = 0;
+            return nt;
+          }, zero: ku });
+          function du(X) {
+            return e.range(X.length);
+          }
+          function ku(X) {
+            for (var se = -1, Te = X[0].length, Ne = []; ++se < Te; ) Ne[se] = 0;
+            return Ne;
+          }
+          function Xf(X) {
+            for (var se = 1, Te = 0, Ne = X[0][1], He, Ye = X.length; se < Ye; ++se) (He = X[se][1]) > Ne && (Te = se, Ne = He);
+            return Te;
+          }
+          function Us(X) {
+            return X.reduce(wf, 0);
+          }
+          function wf(X, se) {
+            return X + se[1];
+          }
+          e.layout.histogram = function() {
+            var X = true, se = Number, Te = Rf, Ne = zc;
+            function He(Ye, qr) {
+              for (var nt = [], jt = Ye.map(se, this), gr = Te.call(this, jt, qr), yr = Ne.call(this, gr, jt, qr), Hr, qr = -1, _i = jt.length, bi = yr.length - 1, Zr = X ? 1 : 1 / _i, ai; ++qr < bi; ) Hr = nt[qr] = [], Hr.dx = yr[qr + 1] - (Hr.x = yr[qr]), Hr.y = 0;
+              if (bi > 0) for (qr = -1; ++qr < _i; ) ai = jt[qr], ai >= gr[0] && ai <= gr[1] && (Hr = nt[e.bisect(yr, ai, 1, bi) - 1], Hr.y += Zr, Hr.push(Ye[qr]));
+              return nt;
+            }
+            return He.value = function(Ye) {
+              return arguments.length ? (se = Ye, He) : se;
+            }, He.range = function(Ye) {
+              return arguments.length ? (Te = vi(Ye), He) : Te;
+            }, He.bins = function(Ye) {
+              return arguments.length ? (Ne = typeof Ye == "number" ? function(kt) {
+                return Wu(kt, Ye);
+              } : vi(Ye), He) : Ne;
+            }, He.frequency = function(Ye) {
+              return arguments.length ? (X = !!Ye, He) : X;
+            }, He;
+          };
+          function zc(X, se) {
+            return Wu(X, Math.ceil(Math.log(se.length) / Math.LN2 + 1));
+          }
+          function Wu(X, se) {
+            for (var Te = -1, Ne = +X[0], He = (X[1] - Ne) / se, Ye = []; ++Te <= se; ) Ye[Te] = He * Te + Ne;
+            return Ye;
+          }
+          function Rf(X) {
+            return [e.min(X), e.max(X)];
+          }
+          e.layout.pack = function() {
+            var X = e.layout.hierarchy().sort(Xu), se = 0, Te = [1, 1], Ne;
+            function He(Ye, kt) {
+              var nt = X.call(this, Ye, kt), jt = nt[0], gr = Te[0], yr = Te[1], Hr = Ne == null ? Math.sqrt : typeof Ne == "function" ? Ne : function() {
+                return Ne;
+              };
+              if (jt.x = jt.y = 0, wc(jt, function(_i) {
+                _i.r = +Hr(_i.value);
+              }), wc(jt, ah), se) {
+                var qr = se * (Ne ? 1 : Math.max(2 * jt.r / gr, 2 * jt.r / yr)) / 2;
+                wc(jt, function(_i) {
+                  _i.r += qr;
+                }), wc(jt, ah), wc(jt, function(_i) {
+                  _i.r -= qr;
+                });
+              }
+              return Tc(jt, gr / 2, yr / 2, Ne ? 1 : 1 / Math.max(2 * jt.r / gr, 2 * jt.r / yr)), nt;
+            }
+            return He.size = function(Ye) {
+              return arguments.length ? (Te = Ye, He) : Te;
+            }, He.radius = function(Ye) {
+              return arguments.length ? (Ne = Ye == null || typeof Ye == "function" ? Ye : +Ye, He) : Ne;
+            }, He.padding = function(Ye) {
+              return arguments.length ? (se = +Ye, He) : se;
+            }, zu(He, X);
+          };
+          function Xu(X, se) {
+            return X.value - se.value;
+          }
+          function uf(X, se) {
+            var Te = X._pack_next;
+            X._pack_next = se, se._pack_prev = X, se._pack_next = Te, Te._pack_prev = se;
+          }
+          function Zf(X, se) {
+            X._pack_next = se, se._pack_prev = X;
+          }
+          function Wl(X, se) {
+            var Te = se.x - X.x, Ne = se.y - X.y, He = X.r + se.r;
+            return 0.999 * He * He > Te * Te + Ne * Ne;
+          }
+          function ah(X) {
+            if (!(se = X.children) || !(qr = se.length)) return;
+            var se, Te = 1 / 0, Ne = -1 / 0, He = 1 / 0, Ye = -1 / 0, kt, nt, jt, gr, yr, Hr, qr;
+            function _i(ei) {
+              Te = Math.min(ei.x - ei.r, Te), Ne = Math.max(ei.x + ei.r, Ne), He = Math.min(ei.y - ei.r, He), Ye = Math.max(ei.y + ei.r, Ye);
+            }
+            if (se.forEach(Zu), kt = se[0], kt.x = -kt.r, kt.y = 0, _i(kt), qr > 1 && (nt = se[1], nt.x = nt.r, nt.y = 0, _i(nt), qr > 2)) for (jt = se[2], wl(kt, nt, jt), _i(jt), uf(kt, jt), kt._pack_prev = jt, uf(jt, nt), nt = kt._pack_next, gr = 3; gr < qr; gr++) {
+              wl(kt, nt, jt = se[gr]);
+              var bi = 0, Zr = 1, ai = 1;
+              for (yr = nt._pack_next; yr !== nt; yr = yr._pack_next, Zr++) if (Wl(yr, jt)) {
+                bi = 1;
+                break;
+              }
+              if (bi == 1) for (Hr = kt._pack_prev; Hr !== yr._pack_prev && !Wl(Hr, jt); Hr = Hr._pack_prev, ai++) ;
+              bi ? (Zr < ai || Zr == ai && nt.r < kt.r ? Zf(kt, nt = yr) : Zf(kt = Hr, nt), gr--) : (uf(kt, jt), nt = jt, _i(jt));
+            }
+            var gi = (Te + Ne) / 2, Ii = (He + Ye) / 2, Si = 0;
+            for (gr = 0; gr < qr; gr++) jt = se[gr], jt.x -= gi, jt.y -= Ii, Si = Math.max(Si, jt.r + Math.sqrt(jt.x * jt.x + jt.y * jt.y));
+            X.r = Si, se.forEach(Oc);
+          }
+          function Zu(X) {
+            X._pack_next = X._pack_prev = X;
+          }
+          function Oc(X) {
+            delete X._pack_next, delete X._pack_prev;
+          }
+          function Tc(X, se, Te, Ne) {
+            var He = X.children;
+            if (X.x = se += Ne * X.x, X.y = Te += Ne * X.y, X.r *= Ne, He) for (var Ye = -1, kt = He.length; ++Ye < kt; ) Tc(He[Ye], se, Te, Ne);
+          }
+          function wl(X, se, Te) {
+            var Ne = X.r + Te.r, He = se.x - X.x, Ye = se.y - X.y;
+            if (Ne && (He || Ye)) {
+              var kt = se.r + Te.r, nt = He * He + Ye * Ye;
+              kt *= kt, Ne *= Ne;
+              var jt = 0.5 + (Ne - kt) / (2 * nt), gr = Math.sqrt(Math.max(0, 2 * kt * (Ne + nt) - (Ne -= nt) * Ne - kt * kt)) / (2 * nt);
+              Te.x = X.x + jt * He + gr * Ye, Te.y = X.y + jt * Ye - gr * He;
+            } else Te.x = X.x + Ne, Te.y = X.y;
+          }
+          e.layout.tree = function() {
+            var X = e.layout.hierarchy().sort(null).value(null), se = vu, Te = [1, 1], Ne = null;
+            function He(yr, Hr) {
+              var qr = X.call(this, yr, Hr), _i = qr[0], bi = Ye(_i);
+              if (wc(bi, kt), bi.parent.m = -bi.z, Fc(bi, nt), Ne) Fc(_i, gr);
+              else {
+                var Zr = _i, ai = _i, gi = _i;
+                Fc(_i, function(Ln) {
+                  Ln.x < Zr.x && (Zr = Ln), Ln.x > ai.x && (ai = Ln), Ln.depth > gi.depth && (gi = Ln);
+                });
+                var Ii = se(Zr, ai) / 2 - Zr.x, Si = Te[0] / (ai.x + se(ai, Zr) / 2 + Ii), ei = Te[1] / (gi.depth || 1);
+                Fc(_i, function(Ln) {
+                  Ln.x = (Ln.x + Ii) * Si, Ln.y = Ln.depth * ei;
+                });
+              }
+              return qr;
+            }
+            function Ye(yr) {
+              for (var Hr = { A: null, children: [yr] }, qr = [Hr], _i; (_i = qr.pop()) != null; ) for (var bi = _i.children, Zr, ai = 0, gi = bi.length; ai < gi; ++ai) qr.push((bi[ai] = Zr = { _: bi[ai], parent: _i, children: (Zr = bi[ai].children) && Zr.slice() || [], A: null, a: null, z: 0, m: 0, c: 0, s: 0, t: null, i: ai }).a = Zr);
+              return Hr.children[0];
+            }
+            function kt(yr) {
+              var Hr = yr.children, qr = yr.parent.children, _i = yr.i ? qr[yr.i - 1] : null;
+              if (Hr.length) {
+                Bc(yr);
+                var bi = (Hr[0].z + Hr[Hr.length - 1].z) / 2;
+                _i ? (yr.z = _i.z + se(yr._, _i._), yr.m = yr.z - bi) : yr.z = bi;
+              } else _i && (yr.z = _i.z + se(yr._, _i._));
+              yr.parent.A = jt(yr, _i, yr.parent.A || qr[0]);
+            }
+            function nt(yr) {
+              yr._.x = yr.z + yr.parent.m, yr.m += yr.parent.m;
+            }
+            function jt(yr, Hr, qr) {
+              if (Hr) {
+                for (var _i = yr, bi = yr, Zr = Hr, ai = _i.parent.children[0], gi = _i.m, Ii = bi.m, Si = Zr.m, ei = ai.m, Ln; Zr = cf(Zr), _i = qc(_i), Zr && _i; ) ai = qc(ai), bi = cf(bi), bi.a = yr, Ln = Zr.z + Si - _i.z - gi + se(Zr._, _i._), Ln > 0 && (fc(At(Zr, yr, qr), yr, Ln), gi += Ln, Ii += Ln), Si += Zr.m, gi += _i.m, ei += ai.m, Ii += bi.m;
+                Zr && !cf(bi) && (bi.t = Zr, bi.m += Si - Ii), _i && !qc(ai) && (ai.t = _i, ai.m += gi - ei, qr = yr);
+              }
+              return qr;
+            }
+            function gr(yr) {
+              yr.x *= Te[0], yr.y = yr.depth * Te[1];
+            }
+            return He.separation = function(yr) {
+              return arguments.length ? (se = yr, He) : se;
+            }, He.size = function(yr) {
+              return arguments.length ? (Ne = (Te = yr) == null ? gr : null, He) : Ne ? null : Te;
+            }, He.nodeSize = function(yr) {
+              return arguments.length ? (Ne = (Te = yr) == null ? null : gr, He) : Ne ? Te : null;
+            }, zu(He, X);
+          };
+          function vu(X, se) {
+            return X.parent == se.parent ? 1 : 2;
+          }
+          function qc(X) {
+            var se = X.children;
+            return se.length ? se[0] : X.t;
+          }
+          function cf(X) {
+            var se = X.children, Te;
+            return (Te = se.length) ? se[Te - 1] : X.t;
+          }
+          function fc(X, se, Te) {
+            var Ne = Te / (se.i - X.i);
+            se.c -= Ne, se.s += Te, X.c += Ne, se.z += Te, se.m += Te;
+          }
+          function Bc(X) {
+            for (var se = 0, Te = 0, Ne = X.children, He = Ne.length, Ye; --He >= 0; ) Ye = Ne[He], Ye.z += se, Ye.m += se, se += Ye.s + (Te += Ye.c);
+          }
+          function At(X, se, Te) {
+            return X.a.parent === se.parent ? X.a : Te;
+          }
+          e.layout.cluster = function() {
+            var X = e.layout.hierarchy().sort(null).value(null), se = vu, Te = [1, 1], Ne = false;
+            function He(Ye, kt) {
+              var nt = X.call(this, Ye, kt), jt = nt[0], gr, yr = 0;
+              wc(jt, function(Zr) {
+                var ai = Zr.children;
+                ai && ai.length ? (Zr.x = Cr(ai), Zr.y = Xt(ai)) : (Zr.x = gr ? yr += se(Zr, gr) : 0, Zr.y = 0, gr = Zr);
+              });
+              var Hr = Ar(jt), qr = Kr(jt), _i = Hr.x - se(Hr, qr) / 2, bi = qr.x + se(qr, Hr) / 2;
+              return wc(jt, Ne ? function(Zr) {
+                Zr.x = (Zr.x - jt.x) * Te[0], Zr.y = (jt.y - Zr.y) * Te[1];
+              } : function(Zr) {
+                Zr.x = (Zr.x - _i) / (bi - _i) * Te[0], Zr.y = (1 - (jt.y ? Zr.y / jt.y : 1)) * Te[1];
+              }), nt;
+            }
+            return He.separation = function(Ye) {
+              return arguments.length ? (se = Ye, He) : se;
+            }, He.size = function(Ye) {
+              return arguments.length ? (Ne = (Te = Ye) == null, He) : Ne ? null : Te;
+            }, He.nodeSize = function(Ye) {
+              return arguments.length ? (Ne = (Te = Ye) != null, He) : Ne ? Te : null;
+            }, zu(He, X);
+          };
+          function Xt(X) {
+            return 1 + e.max(X, function(se) {
+              return se.y;
+            });
+          }
+          function Cr(X) {
+            return X.reduce(function(se, Te) {
+              return se + Te.x;
+            }, 0) / X.length;
+          }
+          function Ar(X) {
+            var se = X.children;
+            return se && se.length ? Ar(se[0]) : X;
+          }
+          function Kr(X) {
+            var se = X.children, Te;
+            return se && (Te = se.length) ? Kr(se[Te - 1]) : X;
+          }
+          e.layout.treemap = function() {
+            var X = e.layout.hierarchy(), se = Math.round, Te = [1, 1], Ne = null, He = ki, Ye = false, kt, nt = "squarify", jt = 0.5 * (1 + Math.sqrt(5));
+            function gr(Zr, ai) {
+              for (var gi = -1, Ii = Zr.length, Si, ei; ++gi < Ii; ) ei = (Si = Zr[gi]).value * (ai < 0 ? 0 : ai), Si.area = isNaN(ei) || ei <= 0 ? 0 : ei;
+            }
+            function yr(Zr) {
+              var ai = Zr.children;
+              if (ai && ai.length) {
+                var gi = He(Zr), Ii = [], Si = ai.slice(), ei, Ln = 1 / 0, En, Un = nt === "slice" ? gi.dx : nt === "dice" ? gi.dy : nt === "slice-dice" ? Zr.depth & 1 ? gi.dy : gi.dx : Math.min(gi.dx, gi.dy), ia;
+                for (gr(Si, gi.dx * gi.dy / Zr.value), Ii.area = 0; (ia = Si.length) > 0; ) Ii.push(ei = Si[ia - 1]), Ii.area += ei.area, nt !== "squarify" || (En = qr(Ii, Un)) <= Ln ? (Si.pop(), Ln = En) : (Ii.area -= Ii.pop().area, _i(Ii, Un, gi, false), Un = Math.min(gi.dx, gi.dy), Ii.length = Ii.area = 0, Ln = 1 / 0);
+                Ii.length && (_i(Ii, Un, gi, true), Ii.length = Ii.area = 0), ai.forEach(yr);
+              }
+            }
+            function Hr(Zr) {
+              var ai = Zr.children;
+              if (ai && ai.length) {
+                var gi = He(Zr), Ii = ai.slice(), Si, ei = [];
+                for (gr(Ii, gi.dx * gi.dy / Zr.value), ei.area = 0; Si = Ii.pop(); ) ei.push(Si), ei.area += Si.area, Si.z != null && (_i(ei, Si.z ? gi.dx : gi.dy, gi, !Ii.length), ei.length = ei.area = 0);
+                ai.forEach(Hr);
+              }
+            }
+            function qr(Zr, ai) {
+              for (var gi = Zr.area, Ii, Si = 0, ei = 1 / 0, Ln = -1, En = Zr.length; ++Ln < En; ) (Ii = Zr[Ln].area) && (Ii < ei && (ei = Ii), Ii > Si && (Si = Ii));
+              return gi *= gi, ai *= ai, gi ? Math.max(ai * Si * jt / gi, gi / (ai * ei * jt)) : 1 / 0;
+            }
+            function _i(Zr, ai, gi, Ii) {
+              var Si = -1, ei = Zr.length, Ln = gi.x, En = gi.y, Un = ai ? se(Zr.area / ai) : 0, ia;
+              if (ai == gi.dx) {
+                for ((Ii || Un > gi.dy) && (Un = gi.dy); ++Si < ei; ) ia = Zr[Si], ia.x = Ln, ia.y = En, ia.dy = Un, Ln += ia.dx = Math.min(gi.x + gi.dx - Ln, Un ? se(ia.area / Un) : 0);
+                ia.z = true, ia.dx += gi.x + gi.dx - Ln, gi.y += Un, gi.dy -= Un;
+              } else {
+                for ((Ii || Un > gi.dx) && (Un = gi.dx); ++Si < ei; ) ia = Zr[Si], ia.x = Ln, ia.y = En, ia.dx = Un, En += ia.dy = Math.min(gi.y + gi.dy - En, Un ? se(ia.area / Un) : 0);
+                ia.z = false, ia.dy += gi.y + gi.dy - En, gi.x += Un, gi.dx -= Un;
+              }
+            }
+            function bi(Zr) {
+              var ai = kt || X(Zr), gi = ai[0];
+              return gi.x = gi.y = 0, gi.value ? (gi.dx = Te[0], gi.dy = Te[1]) : gi.dx = gi.dy = 0, kt && X.revalue(gi), gr([gi], gi.dx * gi.dy / gi.value), (kt ? Hr : yr)(gi), Ye && (kt = ai), ai;
+            }
+            return bi.size = function(Zr) {
+              return arguments.length ? (Te = Zr, bi) : Te;
+            }, bi.padding = function(Zr) {
+              if (!arguments.length) return Ne;
+              function ai(Si) {
+                var ei = Zr.call(bi, Si, Si.depth);
+                return ei == null ? ki(Si) : Xi(Si, typeof ei == "number" ? [ei, ei, ei, ei] : ei);
+              }
+              function gi(Si) {
+                return Xi(Si, Zr);
+              }
+              var Ii;
+              return He = (Ne = Zr) == null ? ki : (Ii = typeof Zr) == "function" ? ai : (Ii === "number" && (Zr = [Zr, Zr, Zr, Zr]), gi), bi;
+            }, bi.round = function(Zr) {
+              return arguments.length ? (se = Zr ? Math.round : Number, bi) : se != Number;
+            }, bi.sticky = function(Zr) {
+              return arguments.length ? (Ye = Zr, kt = null, bi) : Ye;
+            }, bi.ratio = function(Zr) {
+              return arguments.length ? (jt = Zr, bi) : jt;
+            }, bi.mode = function(Zr) {
+              return arguments.length ? (nt = Zr + "", bi) : nt;
+            }, zu(bi, X);
+          };
+          function ki(X) {
+            return { x: X.x, y: X.y, dx: X.dx, dy: X.dy };
+          }
+          function Xi(X, se) {
+            var Te = X.x + se[3], Ne = X.y + se[0], He = X.dx - se[1] - se[3], Ye = X.dy - se[0] - se[2];
+            return He < 0 && (Te += He / 2, He = 0), Ye < 0 && (Ne += Ye / 2, Ye = 0), { x: Te, y: Ne, dx: He, dy: Ye };
+          }
+          e.random = { normal: function(X, se) {
+            var Te = arguments.length;
+            return Te < 2 && (se = 1), Te < 1 && (X = 0), function() {
+              var Ne, He, Ye;
+              do
+                Ne = Math.random() * 2 - 1, He = Math.random() * 2 - 1, Ye = Ne * Ne + He * He;
+              while (!Ye || Ye > 1);
+              return X + se * Ne * Math.sqrt(-2 * Math.log(Ye) / Ye);
+            };
+          }, logNormal: function() {
+            var X = e.random.normal.apply(e, arguments);
+            return function() {
+              return Math.exp(X());
+            };
+          }, bates: function(X) {
+            var se = e.random.irwinHall(X);
+            return function() {
+              return se() / X;
+            };
+          }, irwinHall: function(X) {
+            return function() {
+              for (var se = 0, Te = 0; Te < X; Te++) se += Math.random();
+              return se;
+            };
+          } }, e.scale = {};
+          function dn(X) {
+            var se = X[0], Te = X[X.length - 1];
+            return se < Te ? [se, Te] : [Te, se];
+          }
+          function wn(X) {
+            return X.rangeExtent ? X.rangeExtent() : dn(X.range());
+          }
+          function Nn(X, se, Te, Ne) {
+            var He = Te(X[0], X[1]), Ye = Ne(se[0], se[1]);
+            return function(kt) {
+              return Ye(He(kt));
+            };
+          }
+          function Yi(X, se) {
+            var Te = 0, Ne = X.length - 1, He = X[Te], Ye = X[Ne], kt;
+            return Ye < He && (kt = Te, Te = Ne, Ne = kt, kt = He, He = Ye, Ye = kt), X[Te] = se.floor(He), X[Ne] = se.ceil(Ye), X;
+          }
+          function Qi(X) {
+            return X ? { floor: function(se) {
+              return Math.floor(se / X) * X;
+            }, ceil: function(se) {
+              return Math.ceil(se / X) * X;
+            } } : on;
+          }
+          var on = { floor: G, ceil: G };
+          function Fi(X, se, Te, Ne) {
+            var He = [], Ye = [], kt = 0, nt = Math.min(X.length, se.length) - 1;
+            for (X[nt] < X[0] && (X = X.slice().reverse(), se = se.slice().reverse()); ++kt <= nt; ) He.push(Te(X[kt - 1], X[kt])), Ye.push(Ne(se[kt - 1], se[kt]));
+            return function(jt) {
+              var gr = e.bisect(X, jt, 1, nt) - 1;
+              return Ye[gr](He[gr](jt));
+            };
+          }
+          e.scale.linear = function() {
+            return Qn([0, 1], [0, 1], xl, false);
+          };
+          function Qn(X, se, Te, Ne) {
+            var He, Ye;
+            function kt() {
+              var jt = Math.min(X.length, se.length) > 2 ? Fi : Nn, gr = Ne ? Mu : Sh;
+              return He = jt(X, se, gr, Te), Ye = jt(se, X, gr, xl), nt;
+            }
+            function nt(jt) {
+              return He(jt);
+            }
+            return nt.invert = function(jt) {
+              return Ye(jt);
+            }, nt.domain = function(jt) {
+              return arguments.length ? (X = jt.map(Number), kt()) : X;
+            }, nt.range = function(jt) {
+              return arguments.length ? (se = jt, kt()) : se;
+            }, nt.rangeRound = function(jt) {
+              return nt.range(jt).interpolate(ju);
+            }, nt.clamp = function(jt) {
+              return arguments.length ? (Ne = jt, kt()) : Ne;
+            }, nt.interpolate = function(jt) {
+              return arguments.length ? (Te = jt, kt()) : Te;
+            }, nt.ticks = function(jt) {
+              return Na(X, jt);
+            }, nt.tickFormat = function(jt, gr) {
+              return d3_scale_linearTickFormat(X, jt, gr);
+            }, nt.nice = function(jt) {
+              return Ra(X, jt), kt();
+            }, nt.copy = function() {
+              return Qn(X, se, Te, Ne);
+            }, kt();
+          }
+          function Ca(X, se) {
+            return e.rebind(X, se, "range", "rangeRound", "interpolate", "clamp");
+          }
+          function Ra(X, se) {
+            return Yi(X, Qi(La(X, se)[2])), Yi(X, Qi(La(X, se)[2])), X;
+          }
+          function La(X, se) {
+            se == null && (se = 10);
+            var Te = dn(X), Ne = Te[1] - Te[0], He = Math.pow(10, Math.floor(Math.log(Ne / se) / Math.LN10)), Ye = se / Ne * He;
+            return Ye <= 0.15 ? He *= 10 : Ye <= 0.35 ? He *= 5 : Ye <= 0.75 && (He *= 2), Te[0] = Math.ceil(Te[0] / He) * He, Te[1] = Math.floor(Te[1] / He) * He + He * 0.5, Te[2] = He, Te;
+          }
+          function Na(X, se) {
+            return e.range.apply(e, La(X, se));
+          }
+          e.scale.log = function() {
+            return bo(e.scale.linear().domain([0, 1]), 10, true, [1, 10]);
+          };
+          function bo(X, se, Te, Ne) {
+            function He(nt) {
+              return (Te ? Math.log(nt < 0 ? 0 : nt) : -Math.log(nt > 0 ? 0 : -nt)) / Math.log(se);
+            }
+            function Ye(nt) {
+              return Te ? Math.pow(se, nt) : -Math.pow(se, -nt);
+            }
+            function kt(nt) {
+              return X(He(nt));
+            }
+            return kt.invert = function(nt) {
+              return Ye(X.invert(nt));
+            }, kt.domain = function(nt) {
+              return arguments.length ? (Te = nt[0] >= 0, X.domain((Ne = nt.map(Number)).map(He)), kt) : Ne;
+            }, kt.base = function(nt) {
+              return arguments.length ? (se = +nt, X.domain(Ne.map(He)), kt) : se;
+            }, kt.nice = function() {
+              var nt = Yi(Ne.map(He), Te ? Math : Zo);
+              return X.domain(nt), Ne = nt.map(Ye), kt;
+            }, kt.ticks = function() {
+              var nt = dn(Ne), jt = [], gr = nt[0], yr = nt[1], Hr = Math.floor(He(gr)), qr = Math.ceil(He(yr)), _i = se % 1 ? 2 : se;
+              if (isFinite(qr - Hr)) {
+                if (Te) {
+                  for (; Hr < qr; Hr++) for (var bi = 1; bi < _i; bi++) jt.push(Ye(Hr) * bi);
+                  jt.push(Ye(Hr));
+                } else for (jt.push(Ye(Hr)); Hr++ < qr; ) for (var bi = _i - 1; bi > 0; bi--) jt.push(Ye(Hr) * bi);
+                for (Hr = 0; jt[Hr] < gr; Hr++) ;
+                for (qr = jt.length; jt[qr - 1] > yr; qr--) ;
+                jt = jt.slice(Hr, qr);
+              }
+              return jt;
+            }, kt.copy = function() {
+              return bo(X.copy(), se, Te, Ne);
+            }, Ca(kt, X);
+          }
+          var Zo = { floor: function(X) {
+            return -Math.ceil(-X);
+          }, ceil: function(X) {
+            return -Math.floor(-X);
+          } };
+          e.scale.pow = function() {
+            return Ss(e.scale.linear(), 1, [0, 1]);
+          };
+          function Ss(X, se, Te) {
+            var Ne = as(se), He = as(1 / se);
+            function Ye(kt) {
+              return X(Ne(kt));
+            }
+            return Ye.invert = function(kt) {
+              return He(X.invert(kt));
+            }, Ye.domain = function(kt) {
+              return arguments.length ? (X.domain((Te = kt.map(Number)).map(Ne)), Ye) : Te;
+            }, Ye.ticks = function(kt) {
+              return Na(Te, kt);
+            }, Ye.tickFormat = function(kt, nt) {
+              return d3_scale_linearTickFormat(Te, kt, nt);
+            }, Ye.nice = function(kt) {
+              return Ye.domain(Ra(Te, kt));
+            }, Ye.exponent = function(kt) {
+              return arguments.length ? (Ne = as(se = kt), He = as(1 / se), X.domain(Te.map(Ne)), Ye) : se;
+            }, Ye.copy = function() {
+              return Ss(X.copy(), se, Te);
+            }, Ca(Ye, X);
+          }
+          function as(X) {
+            return function(se) {
+              return se < 0 ? -Math.pow(-se, X) : Math.pow(se, X);
+            };
+          }
+          e.scale.sqrt = function() {
+            return e.scale.pow().exponent(0.5);
+          }, e.scale.ordinal = function() {
+            return ws([], { t: "range", a: [[]] });
+          };
+          function ws(X, se) {
+            var Te, Ne, He;
+            function Ye(nt) {
+              return Ne[((Te.get(nt) || (se.t === "range" ? Te.set(nt, X.push(nt)) : NaN)) - 1) % Ne.length];
+            }
+            function kt(nt, jt) {
+              return e.range(X.length).map(function(gr) {
+                return nt + jt * gr;
+              });
+            }
+            return Ye.domain = function(nt) {
+              if (!arguments.length) return X;
+              X = [], Te = new T();
+              for (var jt = -1, gr = nt.length, yr; ++jt < gr; ) Te.has(yr = nt[jt]) || Te.set(yr, X.push(yr));
+              return Ye[se.t].apply(Ye, se.a);
+            }, Ye.range = function(nt) {
+              return arguments.length ? (Ne = nt, He = 0, se = { t: "range", a: arguments }, Ye) : Ne;
+            }, Ye.rangePoints = function(nt, jt) {
+              arguments.length < 2 && (jt = 0);
+              var gr = nt[0], yr = nt[1], Hr = X.length < 2 ? (gr = (gr + yr) / 2, 0) : (yr - gr) / (X.length - 1 + jt);
+              return Ne = kt(gr + Hr * jt / 2, Hr), He = 0, se = { t: "rangePoints", a: arguments }, Ye;
+            }, Ye.rangeRoundPoints = function(nt, jt) {
+              arguments.length < 2 && (jt = 0);
+              var gr = nt[0], yr = nt[1], Hr = X.length < 2 ? (gr = yr = Math.round((gr + yr) / 2), 0) : (yr - gr) / (X.length - 1 + jt) | 0;
+              return Ne = kt(gr + Math.round(Hr * jt / 2 + (yr - gr - (X.length - 1 + jt) * Hr) / 2), Hr), He = 0, se = { t: "rangeRoundPoints", a: arguments }, Ye;
+            }, Ye.rangeBands = function(nt, jt, gr) {
+              arguments.length < 2 && (jt = 0), arguments.length < 3 && (gr = jt);
+              var yr = nt[1] < nt[0], Hr = nt[yr - 0], qr = nt[1 - yr], _i = (qr - Hr) / (X.length - jt + 2 * gr);
+              return Ne = kt(Hr + _i * gr, _i), yr && Ne.reverse(), He = _i * (1 - jt), se = { t: "rangeBands", a: arguments }, Ye;
+            }, Ye.rangeRoundBands = function(nt, jt, gr) {
+              arguments.length < 2 && (jt = 0), arguments.length < 3 && (gr = jt);
+              var yr = nt[1] < nt[0], Hr = nt[yr - 0], qr = nt[1 - yr], _i = Math.floor((qr - Hr) / (X.length - jt + 2 * gr));
+              return Ne = kt(Hr + Math.round((qr - Hr - (X.length - jt) * _i) / 2), _i), yr && Ne.reverse(), He = Math.round(_i * (1 - jt)), se = { t: "rangeRoundBands", a: arguments }, Ye;
+            }, Ye.rangeBand = function() {
+              return He;
+            }, Ye.rangeExtent = function() {
+              return dn(se.a[0]);
+            }, Ye.copy = function() {
+              return ws(X, se);
+            }, Ye.domain(X);
+          }
+          e.scale.category10 = function() {
+            return e.scale.ordinal().range(Ho);
+          }, e.scale.category20 = function() {
+            return e.scale.ordinal().range(ml);
+          }, e.scale.category20b = function() {
+            return e.scale.ordinal().range(Ws);
+          }, e.scale.category20c = function() {
+            return e.scale.ordinal().range(Ls);
+          };
+          var Ho = [2062260, 16744206, 2924588, 14034728, 9725885, 9197131, 14907330, 8355711, 12369186, 1556175].map(Xo), ml = [2062260, 11454440, 16744206, 16759672, 2924588, 10018698, 14034728, 16750742, 9725885, 12955861, 9197131, 12885140, 14907330, 16234194, 8355711, 13092807, 12369186, 14408589, 1556175, 10410725].map(Xo), Ws = [3750777, 5395619, 7040719, 10264286, 6519097, 9216594, 11915115, 13556636, 9202993, 12426809, 15186514, 15190932, 8666169, 11356490, 14049643, 15177372, 8077683, 10834324, 13528509, 14589654].map(Xo), Ls = [3244733, 7057110, 10406625, 13032431, 15095053, 16616764, 16625259, 16634018, 3253076, 7652470, 10607003, 13101504, 7695281, 10394312, 12369372, 14342891, 6513507, 9868950, 12434877, 14277081].map(Xo);
+          e.scale.quantile = function() {
+            return va([], []);
+          };
+          function va(X, se) {
+            var Te;
+            function Ne() {
+              var Ye = 0, kt = se.length;
+              for (Te = []; ++Ye < kt; ) Te[Ye - 1] = e.quantile(X, Ye / kt);
+              return He;
+            }
+            function He(Ye) {
+              if (!isNaN(Ye = +Ye)) return se[e.bisect(Te, Ye)];
+            }
+            return He.domain = function(Ye) {
+              return arguments.length ? (X = Ye.map(h).filter(d).sort(f), Ne()) : X;
+            }, He.range = function(Ye) {
+              return arguments.length ? (se = Ye, Ne()) : se;
+            }, He.quantiles = function() {
+              return Te;
+            }, He.invertExtent = function(Ye) {
+              return Ye = se.indexOf(Ye), Ye < 0 ? [NaN, NaN] : [Ye > 0 ? Te[Ye - 1] : X[0], Ye < Te.length ? Te[Ye] : X[X.length - 1]];
+            }, He.copy = function() {
+              return va(X, se);
+            }, Ne();
+          }
+          e.scale.quantize = function() {
+            return no(0, 1, [0, 1]);
+          };
+          function no(X, se, Te) {
+            var Ne, He;
+            function Ye(nt) {
+              return Te[Math.max(0, Math.min(He, Math.floor(Ne * (nt - X))))];
+            }
+            function kt() {
+              return Ne = Te.length / (se - X), He = Te.length - 1, Ye;
+            }
+            return Ye.domain = function(nt) {
+              return arguments.length ? (X = +nt[0], se = +nt[nt.length - 1], kt()) : [X, se];
+            }, Ye.range = function(nt) {
+              return arguments.length ? (Te = nt, kt()) : Te;
+            }, Ye.invertExtent = function(nt) {
+              return nt = Te.indexOf(nt), nt = nt < 0 ? NaN : nt / Ne + X, [nt, nt + 1 / Ne];
+            }, Ye.copy = function() {
+              return no(X, se, Te);
+            }, kt();
+          }
+          e.scale.threshold = function() {
+            return ys([0.5], [0, 1]);
+          };
+          function ys(X, se) {
+            function Te(Ne) {
+              if (Ne <= Ne) return se[e.bisect(X, Ne)];
+            }
+            return Te.domain = function(Ne) {
+              return arguments.length ? (X = Ne, Te) : X;
+            }, Te.range = function(Ne) {
+              return arguments.length ? (se = Ne, Te) : se;
+            }, Te.invertExtent = function(Ne) {
+              return Ne = se.indexOf(Ne), [X[Ne - 1], X[Ne]];
+            }, Te.copy = function() {
+              return ys(X, se);
+            }, Te;
+          }
+          e.scale.identity = function() {
+            return rs([0, 1]);
+          };
+          function rs(X) {
+            function se(Te) {
+              return +Te;
+            }
+            return se.invert = se, se.domain = se.range = function(Te) {
+              return arguments.length ? (X = Te.map(se), se) : X;
+            }, se.ticks = function(Te) {
+              return Na(X, Te);
+            }, se.tickFormat = function(Te, Ne) {
+              return d3_scale_linearTickFormat(X, Te, Ne);
+            }, se.copy = function() {
+              return rs(X);
+            }, se;
+          }
+          e.svg = {};
+          function Ql() {
+            return 0;
+          }
+          e.svg.arc = function() {
+            var X = Yu, se = Nc, Te = Ql, Ne = Cu, He = pu, Ye = Uc, kt = xu;
+            function nt() {
+              var gr = Math.max(0, +X.apply(this, arguments)), yr = Math.max(0, +se.apply(this, arguments)), Hr = He.apply(this, arguments) - xe, qr = Ye.apply(this, arguments) - xe, _i = Math.abs(qr - Hr), bi = Hr > qr ? 0 : 1;
+              if (yr < gr && (Zr = yr, yr = gr, gr = Zr), _i >= Ie) return jt(yr, bi) + (gr ? jt(gr, 1 - bi) : "") + "Z";
+              var Zr, ai, gi, Ii, Si = 0, ei = 0, Ln, En, Un, ia, Ea, Ia, yo, Da, go = [];
+              if ((Ii = (+kt.apply(this, arguments) || 0) / 2) && (gi = Ne === Cu ? Math.sqrt(gr * gr + yr * yr) : +Ne.apply(this, arguments), bi || (ei *= -1), yr && (ei = ii(gi / yr * Math.sin(Ii))), gr && (Si = ii(gi / gr * Math.sin(Ii)))), yr) {
+                Ln = yr * Math.cos(Hr + ei), En = yr * Math.sin(Hr + ei), Un = yr * Math.cos(qr - ei), ia = yr * Math.sin(qr - ei);
+                var Is = Math.abs(qr - Hr - 2 * ei) <= tt ? 0 : 1;
+                if (ei && Ac(Ln, En, Un, ia) === bi ^ Is) {
+                  var Ms = (Hr + qr) / 2;
+                  Ln = yr * Math.cos(Ms), En = yr * Math.sin(Ms), Un = ia = null;
+                }
+              } else Ln = En = 0;
+              if (gr) {
+                Ea = gr * Math.cos(qr - Si), Ia = gr * Math.sin(qr - Si), yo = gr * Math.cos(Hr + Si), Da = gr * Math.sin(Hr + Si);
+                var Xs = Math.abs(Hr - qr + 2 * Si) <= tt ? 0 : 1;
+                if (Si && Ac(Ea, Ia, yo, Da) === 1 - bi ^ Xs) {
+                  var Gn = (Hr + qr) / 2;
+                  Ea = gr * Math.cos(Gn), Ia = gr * Math.sin(Gn), yo = Da = null;
+                }
+              } else Ea = Ia = 0;
+              if (_i > Je && (Zr = Math.min(Math.abs(yr - gr) / 2, +Te.apply(this, arguments))) > 1e-3) {
+                ai = gr < yr ^ bi ? 0 : 1;
+                var ja = Zr, Fo = Zr;
+                if (_i < tt) {
+                  var Uo = yo == null ? [Ea, Ia] : Un == null ? [Ln, En] : il([Ln, En], [yo, Da], [Un, ia], [Ea, Ia]), $s = Ln - Uo[0], Sl = En - Uo[1], bu = Un - Uo[0], dl = ia - Uo[1], Sc = 1 / Math.sin(Math.acos(($s * bu + Sl * dl) / (Math.sqrt($s * $s + Sl * Sl) * Math.sqrt(bu * bu + dl * dl))) / 2), Me = Math.sqrt(Uo[0] * Uo[0] + Uo[1] * Uo[1]);
+                  Fo = Math.min(Zr, (gr - Me) / (Sc - 1)), ja = Math.min(Zr, (yr - Me) / (Sc + 1));
+                }
+                if (Un != null) {
+                  var bt = Ua(yo == null ? [Ea, Ia] : [yo, Da], [Ln, En], yr, ja, bi), zt = Ua([Un, ia], [Ea, Ia], yr, ja, bi);
+                  Zr === ja ? go.push("M", bt[0], "A", ja, ",", ja, " 0 0,", ai, " ", bt[1], "A", yr, ",", yr, " 0 ", 1 - bi ^ Ac(bt[1][0], bt[1][1], zt[1][0], zt[1][1]), ",", bi, " ", zt[1], "A", ja, ",", ja, " 0 0,", ai, " ", zt[0]) : go.push("M", bt[0], "A", ja, ",", ja, " 0 1,", ai, " ", zt[0]);
+                } else go.push("M", Ln, ",", En);
+                if (yo != null) {
+                  var Rr = Ua([Ln, En], [yo, Da], gr, -Fo, bi), jr = Ua([Ea, Ia], Un == null ? [Ln, En] : [Un, ia], gr, -Fo, bi);
+                  Zr === Fo ? go.push("L", jr[0], "A", Fo, ",", Fo, " 0 0,", ai, " ", jr[1], "A", gr, ",", gr, " 0 ", bi ^ Ac(jr[1][0], jr[1][1], Rr[1][0], Rr[1][1]), ",", 1 - bi, " ", Rr[1], "A", Fo, ",", Fo, " 0 0,", ai, " ", Rr[0]) : go.push("L", jr[0], "A", Fo, ",", Fo, " 0 0,", ai, " ", Rr[0]);
+                } else go.push("L", Ea, ",", Ia);
+              } else go.push("M", Ln, ",", En), Un != null && go.push("A", yr, ",", yr, " 0 ", Is, ",", bi, " ", Un, ",", ia), go.push("L", Ea, ",", Ia), yo != null && go.push("A", gr, ",", gr, " 0 ", Xs, ",", 1 - bi, " ", yo, ",", Da);
+              return go.push("Z"), go.join("");
+            }
+            function jt(gr, yr) {
+              return "M0," + gr + "A" + gr + "," + gr + " 0 1," + yr + " 0," + -gr + "A" + gr + "," + gr + " 0 1," + yr + " 0," + gr;
+            }
+            return nt.innerRadius = function(gr) {
+              return arguments.length ? (X = vi(gr), nt) : X;
+            }, nt.outerRadius = function(gr) {
+              return arguments.length ? (se = vi(gr), nt) : se;
+            }, nt.cornerRadius = function(gr) {
+              return arguments.length ? (Te = vi(gr), nt) : Te;
+            }, nt.padRadius = function(gr) {
+              return arguments.length ? (Ne = gr == Cu ? Cu : vi(gr), nt) : Ne;
+            }, nt.startAngle = function(gr) {
+              return arguments.length ? (He = vi(gr), nt) : He;
+            }, nt.endAngle = function(gr) {
+              return arguments.length ? (Ye = vi(gr), nt) : Ye;
+            }, nt.padAngle = function(gr) {
+              return arguments.length ? (kt = vi(gr), nt) : kt;
+            }, nt.centroid = function() {
+              var gr = (+X.apply(this, arguments) + +se.apply(this, arguments)) / 2, yr = (+He.apply(this, arguments) + +Ye.apply(this, arguments)) / 2 - xe;
+              return [Math.cos(yr) * gr, Math.sin(yr) * gr];
+            }, nt;
+          };
+          var Cu = "auto";
+          function Yu(X) {
+            return X.innerRadius;
+          }
+          function Nc(X) {
+            return X.outerRadius;
+          }
+          function pu(X) {
+            return X.startAngle;
+          }
+          function Uc(X) {
+            return X.endAngle;
+          }
+          function xu(X) {
+            return X && X.padAngle;
+          }
+          function Ac(X, se, Te, Ne) {
+            return (X - Te) * se - (se - Ne) * X > 0 ? 0 : 1;
+          }
+          function Ua(X, se, Te, Ne, He) {
+            var Ye = X[0] - se[0], kt = X[1] - se[1], nt = (He ? Ne : -Ne) / Math.sqrt(Ye * Ye + kt * kt), jt = nt * kt, gr = -nt * Ye, yr = X[0] + jt, Hr = X[1] + gr, qr = se[0] + jt, _i = se[1] + gr, bi = (yr + qr) / 2, Zr = (Hr + _i) / 2, ai = qr - yr, gi = _i - Hr, Ii = ai * ai + gi * gi, Si = Te - Ne, ei = yr * _i - qr * Hr, Ln = (gi < 0 ? -1 : 1) * Math.sqrt(Math.max(0, Si * Si * Ii - ei * ei)), En = (ei * gi - ai * Ln) / Ii, Un = (-ei * ai - gi * Ln) / Ii, ia = (ei * gi + ai * Ln) / Ii, Ea = (-ei * ai + gi * Ln) / Ii, Ia = En - bi, yo = Un - Zr, Da = ia - bi, go = Ea - Zr;
+            return Ia * Ia + yo * yo > Da * Da + go * go && (En = ia, Un = Ea), [[En - jt, Un - gr], [En * Te / Si, Un * Te / Si]];
+          }
+          function oo() {
+            return true;
+          }
+          function Vc(X) {
+            var se = Ds, Te = Fs, Ne = oo, He = Ku, Ye = He.key, kt = 0.7;
+            function nt(jt) {
+              var gr = [], yr = [], Hr = -1, qr = jt.length, _i, bi = vi(se), Zr = vi(Te);
+              function ai() {
+                gr.push("M", He(X(yr), kt));
+              }
+              for (; ++Hr < qr; ) Ne.call(this, _i = jt[Hr], Hr) ? yr.push([+bi.call(this, _i, Hr), +Zr.call(this, _i, Hr)]) : yr.length && (ai(), yr = []);
+              return yr.length && ai(), gr.length ? gr.join("") : null;
+            }
+            return nt.x = function(jt) {
+              return arguments.length ? (se = jt, nt) : se;
+            }, nt.y = function(jt) {
+              return arguments.length ? (Te = jt, nt) : Te;
+            }, nt.defined = function(jt) {
+              return arguments.length ? (Ne = jt, nt) : Ne;
+            }, nt.interpolate = function(jt) {
+              return arguments.length ? (typeof jt == "function" ? Ye = He = jt : Ye = (He = hc.get(jt) || Ku).key, nt) : Ye;
+            }, nt.tension = function(jt) {
+              return arguments.length ? (kt = jt, nt) : kt;
+            }, nt;
+          }
+          e.svg.line = function() {
+            return Vc(G);
+          };
+          var hc = e.map({ linear: Ku, "linear-closed": ue, step: w, "step-before": B, "step-after": Q, basis: Tt, "basis-open": Yt, "basis-closed": Kt, bundle: xr, cardinal: Oe, "cardinal-open": ee, "cardinal-closed": le, monotone: Ft });
+          hc.forEach(function(X, se) {
+            se.key = X, se.closed = /-closed$/.test(X);
+          });
+          function Ku(X) {
+            return X.length > 1 ? X.join("L") : X + "Z";
+          }
+          function ue(X) {
+            return X.join("L") + "Z";
+          }
+          function w(X) {
+            for (var se = 0, Te = X.length, Ne = X[0], He = [Ne[0], ",", Ne[1]]; ++se < Te; ) He.push("H", (Ne[0] + (Ne = X[se])[0]) / 2, "V", Ne[1]);
+            return Te > 1 && He.push("H", Ne[0]), He.join("");
+          }
+          function B(X) {
+            for (var se = 0, Te = X.length, Ne = X[0], He = [Ne[0], ",", Ne[1]]; ++se < Te; ) He.push("V", (Ne = X[se])[1], "H", Ne[0]);
+            return He.join("");
+          }
+          function Q(X) {
+            for (var se = 0, Te = X.length, Ne = X[0], He = [Ne[0], ",", Ne[1]]; ++se < Te; ) He.push("H", (Ne = X[se])[0], "V", Ne[1]);
+            return He.join("");
+          }
+          function ee(X, se) {
+            return X.length < 4 ? Ku(X) : X[1] + Ze(X.slice(1, -1), st(X, se));
+          }
+          function le(X, se) {
+            return X.length < 3 ? ue(X) : X[0] + Ze((X.push(X[0]), X), st([X[X.length - 2]].concat(X, [X[1]]), se));
+          }
+          function Oe(X, se) {
+            return X.length < 3 ? Ku(X) : X[0] + Ze(X, st(X, se));
+          }
+          function Ze(X, se) {
+            if (se.length < 1 || X.length != se.length && X.length != se.length + 2) return Ku(X);
+            var Te = X.length != se.length, Ne = "", He = X[0], Ye = X[1], kt = se[0], nt = kt, jt = 1;
+            if (Te && (Ne += "Q" + (Ye[0] - kt[0] * 2 / 3) + "," + (Ye[1] - kt[1] * 2 / 3) + "," + Ye[0] + "," + Ye[1], He = X[1], jt = 2), se.length > 1) {
+              nt = se[1], Ye = X[jt], jt++, Ne += "C" + (He[0] + kt[0]) + "," + (He[1] + kt[1]) + "," + (Ye[0] - nt[0]) + "," + (Ye[1] - nt[1]) + "," + Ye[0] + "," + Ye[1];
+              for (var gr = 2; gr < se.length; gr++, jt++) Ye = X[jt], nt = se[gr], Ne += "S" + (Ye[0] - nt[0]) + "," + (Ye[1] - nt[1]) + "," + Ye[0] + "," + Ye[1];
+            }
+            if (Te) {
+              var yr = X[jt];
+              Ne += "Q" + (Ye[0] + nt[0] * 2 / 3) + "," + (Ye[1] + nt[1] * 2 / 3) + "," + yr[0] + "," + yr[1];
+            }
+            return Ne;
+          }
+          function st(X, se) {
+            for (var Te = [], Ne = (1 - se) / 2, He, Ye = X[0], kt = X[1], nt = 1, jt = X.length; ++nt < jt; ) He = Ye, Ye = kt, kt = X[nt], Te.push([Ne * (kt[0] - He[0]), Ne * (kt[1] - He[1])]);
+            return Te;
+          }
+          function Tt(X) {
+            if (X.length < 3) return Ku(X);
+            var se = 1, Te = X.length, Ne = X[0], He = Ne[0], Ye = Ne[1], kt = [He, He, He, (Ne = X[1])[0]], nt = [Ye, Ye, Ye, Ne[1]], jt = [He, ",", Ye, "L", Ir(Re, kt), ",", Ir(Re, nt)];
+            for (X.push(X[Te - 1]); ++se <= Te; ) Ne = X[se], kt.shift(), kt.push(Ne[0]), nt.shift(), nt.push(Ne[1]), qe(jt, kt, nt);
+            return X.pop(), jt.push("L", Ne), jt.join("");
+          }
+          function Yt(X) {
+            if (X.length < 4) return Ku(X);
+            for (var se = [], Te = -1, Ne = X.length, He, Ye = [0], kt = [0]; ++Te < 3; ) He = X[Te], Ye.push(He[0]), kt.push(He[1]);
+            for (se.push(Ir(Re, Ye) + "," + Ir(Re, kt)), --Te; ++Te < Ne; ) He = X[Te], Ye.shift(), Ye.push(He[0]), kt.shift(), kt.push(He[1]), qe(se, Ye, kt);
+            return se.join("");
+          }
+          function Kt(X) {
+            for (var se, Te = -1, Ne = X.length, He = Ne + 4, Ye, kt = [], nt = []; ++Te < 4; ) Ye = X[Te % Ne], kt.push(Ye[0]), nt.push(Ye[1]);
+            for (se = [Ir(Re, kt), ",", Ir(Re, nt)], --Te; ++Te < He; ) Ye = X[Te % Ne], kt.shift(), kt.push(Ye[0]), nt.shift(), nt.push(Ye[1]), qe(se, kt, nt);
+            return se.join("");
+          }
+          function xr(X, se) {
+            var Te = X.length - 1;
+            if (Te) for (var Ne = X[0][0], He = X[0][1], Ye = X[Te][0] - Ne, kt = X[Te][1] - He, nt = -1, jt, gr; ++nt <= Te; ) jt = X[nt], gr = nt / Te, jt[0] = se * jt[0] + (1 - se) * (Ne + gr * Ye), jt[1] = se * jt[1] + (1 - se) * (He + gr * kt);
+            return Tt(X);
+          }
+          function Ir(X, se) {
+            return X[0] * se[0] + X[1] * se[1] + X[2] * se[2] + X[3] * se[3];
+          }
+          var ve = [0, 2 / 3, 1 / 3, 0], be = [0, 1 / 3, 2 / 3, 0], Re = [0, 1 / 6, 2 / 3, 1 / 6];
+          function qe(X, se, Te) {
+            X.push("C", Ir(ve, se), ",", Ir(ve, Te), ",", Ir(be, se), ",", Ir(be, Te), ",", Ir(Re, se), ",", Ir(Re, Te));
+          }
+          function et(X, se) {
+            return (se[1] - X[1]) / (se[0] - X[0]);
+          }
+          function Xe(X) {
+            for (var se = 0, Te = X.length - 1, Ne = [], He = X[0], Ye = X[1], kt = Ne[0] = et(He, Ye); ++se < Te; ) Ne[se] = (kt + (kt = et(He = Ye, Ye = X[se + 1]))) / 2;
+            return Ne[se] = kt, Ne;
+          }
+          function it(X) {
+            for (var se = [], Te, Ne, He, Ye, kt = Xe(X), nt = -1, jt = X.length - 1; ++nt < jt; ) Te = et(X[nt], X[nt + 1]), p(Te) < Je ? kt[nt] = kt[nt + 1] = 0 : (Ne = kt[nt] / Te, He = kt[nt + 1] / Te, Ye = Ne * Ne + He * He, Ye > 9 && (Ye = Te * 3 / Math.sqrt(Ye), kt[nt] = Ye * Ne, kt[nt + 1] = Ye * He));
+            for (nt = -1; ++nt <= jt; ) Ye = (X[Math.min(jt, nt + 1)][0] - X[Math.max(0, nt - 1)][0]) / (6 * (1 + kt[nt] * kt[nt])), se.push([Ye || 0, kt[nt] * Ye || 0]);
+            return se;
+          }
+          function Ft(X) {
+            return X.length < 3 ? Ku(X) : X[0] + Ze(X, it(X));
+          }
+          e.svg.line.radial = function() {
+            var X = Vc(Ht);
+            return X.radius = X.x, delete X.x, X.angle = X.y, delete X.y, X;
+          };
+          function Ht(X) {
+            for (var se, Te = -1, Ne = X.length, He, Ye; ++Te < Ne; ) se = X[Te], He = se[0], Ye = se[1] - xe, se[0] = He * Math.cos(Ye), se[1] = He * Math.sin(Ye);
+            return X;
+          }
+          function tr(X) {
+            var se = Ds, Te = Ds, Ne = 0, He = Fs, Ye = oo, kt = Ku, nt = kt.key, jt = kt, gr = "L", yr = 0.7;
+            function Hr(qr) {
+              var _i = [], bi = [], Zr = [], ai = -1, gi = qr.length, Ii, Si = vi(se), ei = vi(Ne), Ln = se === Te ? function() {
+                return Un;
+              } : vi(Te), En = Ne === He ? function() {
+                return ia;
+              } : vi(He), Un, ia;
+              function Ea() {
+                _i.push("M", kt(X(Zr), yr), gr, jt(X(bi.reverse()), yr), "Z");
+              }
+              for (; ++ai < gi; ) Ye.call(this, Ii = qr[ai], ai) ? (bi.push([Un = +Si.call(this, Ii, ai), ia = +ei.call(this, Ii, ai)]), Zr.push([+Ln.call(this, Ii, ai), +En.call(this, Ii, ai)])) : bi.length && (Ea(), bi = [], Zr = []);
+              return bi.length && Ea(), _i.length ? _i.join("") : null;
+            }
+            return Hr.x = function(qr) {
+              return arguments.length ? (se = Te = qr, Hr) : Te;
+            }, Hr.x0 = function(qr) {
+              return arguments.length ? (se = qr, Hr) : se;
+            }, Hr.x1 = function(qr) {
+              return arguments.length ? (Te = qr, Hr) : Te;
+            }, Hr.y = function(qr) {
+              return arguments.length ? (Ne = He = qr, Hr) : He;
+            }, Hr.y0 = function(qr) {
+              return arguments.length ? (Ne = qr, Hr) : Ne;
+            }, Hr.y1 = function(qr) {
+              return arguments.length ? (He = qr, Hr) : He;
+            }, Hr.defined = function(qr) {
+              return arguments.length ? (Ye = qr, Hr) : Ye;
+            }, Hr.interpolate = function(qr) {
+              return arguments.length ? (typeof qr == "function" ? nt = kt = qr : nt = (kt = hc.get(qr) || Ku).key, jt = kt.reverse || kt, gr = kt.closed ? "M" : "L", Hr) : nt;
+            }, Hr.tension = function(qr) {
+              return arguments.length ? (yr = qr, Hr) : yr;
+            }, Hr;
+          }
+          B.reverse = Q, Q.reverse = B, e.svg.area = function() {
+            return tr(G);
+          }, e.svg.area.radial = function() {
+            var X = tr(Ht);
+            return X.radius = X.x, delete X.x, X.innerRadius = X.x0, delete X.x0, X.outerRadius = X.x1, delete X.x1, X.angle = X.y, delete X.y, X.startAngle = X.y0, delete X.y0, X.endAngle = X.y1, delete X.y1, X;
+          };
+          function dr(X) {
+            return X.source;
+          }
+          function Sr(X) {
+            return X.target;
+          }
+          e.svg.chord = function() {
+            var X = dr, se = Sr, Te = Or, Ne = pu, He = Uc;
+            function Ye(yr, Hr) {
+              var qr = kt(this, X, yr, Hr), _i = kt(this, se, yr, Hr);
+              return "M" + qr.p0 + jt(qr.r, qr.p1, qr.a1 - qr.a0) + (nt(qr, _i) ? gr(qr.r, qr.p1, qr.r, qr.p0) : gr(qr.r, qr.p1, _i.r, _i.p0) + jt(_i.r, _i.p1, _i.a1 - _i.a0) + gr(_i.r, _i.p1, qr.r, qr.p0)) + "Z";
+            }
+            function kt(yr, Hr, qr, _i) {
+              var bi = Hr.call(yr, qr, _i), Zr = Te.call(yr, bi, _i), ai = Ne.call(yr, bi, _i) - xe, gi = He.call(yr, bi, _i) - xe;
+              return { r: Zr, a0: ai, a1: gi, p0: [Zr * Math.cos(ai), Zr * Math.sin(ai)], p1: [Zr * Math.cos(gi), Zr * Math.sin(gi)] };
+            }
+            function nt(yr, Hr) {
+              return yr.a0 == Hr.a0 && yr.a1 == Hr.a1;
+            }
+            function jt(yr, Hr, qr) {
+              return "A" + yr + "," + yr + " 0 " + +(qr > tt) + ",1 " + Hr;
+            }
+            function gr(yr, Hr, qr, _i) {
+              return "Q 0,0 " + _i;
+            }
+            return Ye.radius = function(yr) {
+              return arguments.length ? (Te = vi(yr), Ye) : Te;
+            }, Ye.source = function(yr) {
+              return arguments.length ? (X = vi(yr), Ye) : X;
+            }, Ye.target = function(yr) {
+              return arguments.length ? (se = vi(yr), Ye) : se;
+            }, Ye.startAngle = function(yr) {
+              return arguments.length ? (Ne = vi(yr), Ye) : Ne;
+            }, Ye.endAngle = function(yr) {
+              return arguments.length ? (He = vi(yr), Ye) : He;
+            }, Ye;
+          };
+          function Or(X) {
+            return X.radius;
+          }
+          e.svg.diagonal = function() {
+            var X = dr, se = Sr, Te = Wr;
+            function Ne(He, Ye) {
+              var kt = X.call(this, He, Ye), nt = se.call(this, He, Ye), jt = (kt.y + nt.y) / 2, gr = [kt, { x: kt.x, y: jt }, { x: nt.x, y: jt }, nt];
+              return gr = gr.map(Te), "M" + gr[0] + "C" + gr[1] + " " + gr[2] + " " + gr[3];
+            }
+            return Ne.source = function(He) {
+              return arguments.length ? (X = vi(He), Ne) : X;
+            }, Ne.target = function(He) {
+              return arguments.length ? (se = vi(He), Ne) : se;
+            }, Ne.projection = function(He) {
+              return arguments.length ? (Te = He, Ne) : Te;
+            }, Ne;
+          };
+          function Wr(X) {
+            return [X.x, X.y];
+          }
+          e.svg.diagonal.radial = function() {
+            var X = e.svg.diagonal(), se = Wr, Te = X.projection;
+            return X.projection = function(Ne) {
+              return arguments.length ? Te(ni(se = Ne)) : se;
+            }, X;
+          };
+          function ni(X) {
+            return function() {
+              var se = X.apply(this, arguments), Te = se[0], Ne = se[1] - xe;
+              return [Te * Math.cos(Ne), Te * Math.sin(Ne)];
+            };
+          }
+          e.svg.symbol = function() {
+            var X = cn, se = Pi;
+            function Te(Ne, He) {
+              return (Cn.get(X.call(this, Ne, He)) || ln)(se.call(this, Ne, He));
+            }
+            return Te.type = function(Ne) {
+              return arguments.length ? (X = vi(Ne), Te) : X;
+            }, Te.size = function(Ne) {
+              return arguments.length ? (se = vi(Ne), Te) : se;
+            }, Te;
+          };
+          function Pi() {
+            return 64;
+          }
+          function cn() {
+            return "circle";
+          }
+          function ln(X) {
+            var se = Math.sqrt(X / tt);
+            return "M0," + se + "A" + se + "," + se + " 0 1,1 0," + -se + "A" + se + "," + se + " 0 1,1 0," + se + "Z";
+          }
+          var Cn = e.map({ circle: ln, cross: function(X) {
+            var se = Math.sqrt(X / 5) / 2;
+            return "M" + -3 * se + "," + -se + "H" + -se + "V" + -3 * se + "H" + se + "V" + -se + "H" + 3 * se + "V" + se + "H" + se + "V" + 3 * se + "H" + -se + "V" + se + "H" + -3 * se + "Z";
+          }, diamond: function(X) {
+            var se = Math.sqrt(X / (2 * Aa)), Te = se * Aa;
+            return "M0," + -se + "L" + Te + ",0 0," + se + " " + -Te + ",0Z";
+          }, square: function(X) {
+            var se = Math.sqrt(X) / 2;
+            return "M" + -se + "," + -se + "L" + se + "," + -se + " " + se + "," + se + " " + -se + "," + se + "Z";
+          }, "triangle-down": function(X) {
+            var se = Math.sqrt(X / Kn), Te = se * Kn / 2;
+            return "M0," + Te + "L" + se + "," + -Te + " " + -se + "," + -Te + "Z";
+          }, "triangle-up": function(X) {
+            var se = Math.sqrt(X / Kn), Te = se * Kn / 2;
+            return "M0," + -Te + "L" + se + "," + Te + " " + -se + "," + Te + "Z";
+          } });
+          e.svg.symbolTypes = Cn.keys();
+          var Kn = Math.sqrt(3), Aa = Math.tan(30 * ke);
+          Pe.transition = function(X) {
+            for (var se = Bo || ++mo, Te = To(X), Ne = [], He, Ye, kt = Ps || { time: Date.now(), ease: bl, delay: 0, duration: 250 }, nt = -1, jt = this.length; ++nt < jt; ) {
+              Ne.push(He = []);
+              for (var gr = this[nt], yr = -1, Hr = gr.length; ++yr < Hr; ) (Ye = gr[yr]) && hl(Ye, yr, Te, se, kt), He.push(Ye);
+            }
+            return Co(Ne, Te, se);
+          }, Pe.interrupt = function(X) {
+            return this.each(X == null ? fa : $a(To(X)));
+          };
+          var fa = $a(To());
+          function $a(X) {
+            return function() {
+              var se, Te, Ne;
+              (se = this[X]) && (Ne = se[Te = se.active]) && (Ne.timer.c = null, Ne.timer.t = NaN, --se.count ? delete se[Te] : delete this[X], se.active += 0.5, Ne.event && Ne.event.interrupt.call(this, this.__data__, Ne.index));
+            };
+          }
+          function Co(X, se, Te) {
+            return ie(X, Qa), X.namespace = se, X.id = Te, X;
+          }
+          var Qa = [], mo = 0, Bo, Ps;
+          Qa.call = Pe.call, Qa.empty = Pe.empty, Qa.node = Pe.node, Qa.size = Pe.size, e.transition = function(X, se) {
+            return X && X.transition ? Bo ? X.transition(se) : X : e.selection().transition(X);
+          }, e.transition.prototype = Qa, Qa.select = function(X) {
+            var se = this.id, Te = this.namespace, Ne = [], He, Ye, kt;
+            X = me(X);
+            for (var nt = -1, jt = this.length; ++nt < jt; ) {
+              Ne.push(He = []);
+              for (var gr = this[nt], yr = -1, Hr = gr.length; ++yr < Hr; ) (kt = gr[yr]) && (Ye = X.call(kt, kt.__data__, yr, nt)) ? ("__data__" in kt && (Ye.__data__ = kt.__data__), hl(Ye, yr, Te, se, kt[Te][se]), He.push(Ye)) : He.push(null);
+            }
+            return Co(Ne, Te, se);
+          }, Qa.selectAll = function(X) {
+            var se = this.id, Te = this.namespace, Ne = [], He, Ye, kt, nt, jt;
+            X = De(X);
+            for (var gr = -1, yr = this.length; ++gr < yr; ) for (var Hr = this[gr], qr = -1, _i = Hr.length; ++qr < _i; ) if (kt = Hr[qr]) {
+              jt = kt[Te][se], Ye = X.call(kt, kt.__data__, qr, gr), Ne.push(He = []);
+              for (var bi = -1, Zr = Ye.length; ++bi < Zr; ) (nt = Ye[bi]) && hl(nt, bi, Te, se, jt), He.push(nt);
+            }
+            return Co(Ne, Te, se);
+          }, Qa.filter = function(X) {
+            var se = [], Te, Ne, He;
+            typeof X != "function" && (X = $e(X));
+            for (var Ye = 0, kt = this.length; Ye < kt; Ye++) {
+              se.push(Te = []);
+              for (var Ne = this[Ye], nt = 0, jt = Ne.length; nt < jt; nt++) (He = Ne[nt]) && X.call(He, He.__data__, nt, Ye) && Te.push(He);
+            }
+            return Co(se, this.namespace, this.id);
+          }, Qa.tween = function(X, se) {
+            var Te = this.id, Ne = this.namespace;
+            return arguments.length < 2 ? this.node()[Ne][Te].tween.get(X) : Qt(this, se == null ? function(He) {
+              He[Ne][Te].tween.remove(X);
+            } : function(He) {
+              He[Ne][Te].tween.set(X, se);
+            });
+          };
+          function Ts(X, se, Te, Ne) {
+            var He = X.id, Ye = X.namespace;
+            return Qt(X, typeof Te == "function" ? function(kt, nt, jt) {
+              kt[Ye][He].tween.set(se, Ne(Te.call(kt, kt.__data__, nt, jt)));
+            } : (Te = Ne(Te), function(kt) {
+              kt[Ye][He].tween.set(se, Te);
+            }));
+          }
+          Qa.attr = function(X, se) {
+            if (arguments.length < 2) {
+              for (se in X) this.attr(se, X[se]);
+              return this;
+            }
+            var Te = X == "transform" ? sf : xl, Ne = e.ns.qualify(X);
+            function He() {
+              this.removeAttribute(Ne);
+            }
+            function Ye() {
+              this.removeAttributeNS(Ne.space, Ne.local);
+            }
+            function kt(jt) {
+              return jt == null ? He : (jt += "", function() {
+                var gr = this.getAttribute(Ne), yr;
+                return gr !== jt && (yr = Te(gr, jt), function(Hr) {
+                  this.setAttribute(Ne, yr(Hr));
+                });
+              });
+            }
+            function nt(jt) {
+              return jt == null ? Ye : (jt += "", function() {
+                var gr = this.getAttributeNS(Ne.space, Ne.local), yr;
+                return gr !== jt && (yr = Te(gr, jt), function(Hr) {
+                  this.setAttributeNS(Ne.space, Ne.local, yr(Hr));
+                });
+              });
+            }
+            return Ts(this, "attr." + X, se, Ne.local ? nt : kt);
+          }, Qa.attrTween = function(X, se) {
+            var Te = e.ns.qualify(X);
+            function Ne(Ye, kt) {
+              var nt = se.call(this, Ye, kt, this.getAttribute(Te));
+              return nt && function(jt) {
+                this.setAttribute(Te, nt(jt));
+              };
+            }
+            function He(Ye, kt) {
+              var nt = se.call(this, Ye, kt, this.getAttributeNS(Te.space, Te.local));
+              return nt && function(jt) {
+                this.setAttributeNS(Te.space, Te.local, nt(jt));
+              };
+            }
+            return this.tween("attr." + X, Te.local ? He : Ne);
+          }, Qa.style = function(X, se, Te) {
+            var Ne = arguments.length;
+            if (Ne < 3) {
+              if (typeof X != "string") {
+                Ne < 2 && (se = "");
+                for (Te in X) this.style(Te, X[Te], se);
+                return this;
+              }
+              Te = "";
+            }
+            function He() {
+              this.style.removeProperty(X);
+            }
+            function Ye(kt) {
+              return kt == null ? He : (kt += "", function() {
+                var nt = a(this).getComputedStyle(this, null).getPropertyValue(X), jt;
+                return nt !== kt && (jt = xl(nt, kt), function(gr) {
+                  this.style.setProperty(X, jt(gr), Te);
+                });
+              });
+            }
+            return Ts(this, "style." + X, se, Ye);
+          }, Qa.styleTween = function(X, se, Te) {
+            arguments.length < 3 && (Te = "");
+            function Ne(He, Ye) {
+              var kt = se.call(this, He, Ye, a(this).getComputedStyle(this, null).getPropertyValue(X));
+              return kt && function(nt) {
+                this.style.setProperty(X, kt(nt), Te);
+              };
+            }
+            return this.tween("style." + X, Ne);
+          }, Qa.text = function(X) {
+            return Ts(this, "text", X, wo);
+          };
+          function wo(X) {
+            return X == null && (X = ""), function() {
+              this.textContent = X;
+            };
+          }
+          Qa.remove = function() {
+            var X = this.namespace;
+            return this.each("end.transition", function() {
+              var se;
+              this[X].count < 2 && (se = this.parentNode) && se.removeChild(this);
+            });
+          }, Qa.ease = function(X) {
+            var se = this.id, Te = this.namespace;
+            return arguments.length < 1 ? this.node()[Te][se].ease : (typeof X != "function" && (X = e.ease.apply(e, arguments)), Qt(this, function(Ne) {
+              Ne[Te][se].ease = X;
+            }));
+          }, Qa.delay = function(X) {
+            var se = this.id, Te = this.namespace;
+            return arguments.length < 1 ? this.node()[Te][se].delay : Qt(this, typeof X == "function" ? function(Ne, He, Ye) {
+              Ne[Te][se].delay = +X.call(Ne, Ne.__data__, He, Ye);
+            } : (X = +X, function(Ne) {
+              Ne[Te][se].delay = X;
+            }));
+          }, Qa.duration = function(X) {
+            var se = this.id, Te = this.namespace;
+            return arguments.length < 1 ? this.node()[Te][se].duration : Qt(this, typeof X == "function" ? function(Ne, He, Ye) {
+              Ne[Te][se].duration = Math.max(1, X.call(Ne, Ne.__data__, He, Ye));
+            } : (X = Math.max(1, X), function(Ne) {
+              Ne[Te][se].duration = X;
+            }));
+          }, Qa.each = function(X, se) {
+            var Te = this.id, Ne = this.namespace;
+            if (arguments.length < 2) {
+              var He = Ps, Ye = Bo;
+              try {
+                Bo = Te, Qt(this, function(kt, nt, jt) {
+                  Ps = kt[Ne][Te], X.call(kt, kt.__data__, nt, jt);
+                });
+              } finally {
+                Ps = He, Bo = Ye;
+              }
+            } else Qt(this, function(kt) {
+              var nt = kt[Ne][Te];
+              (nt.event || (nt.event = e.dispatch("start", "end", "interrupt"))).on(X, se);
+            });
+            return this;
+          }, Qa.transition = function() {
+            for (var X = this.id, se = ++mo, Te = this.namespace, Ne = [], He, Ye, kt, nt, jt = 0, gr = this.length; jt < gr; jt++) {
+              Ne.push(He = []);
+              for (var Ye = this[jt], yr = 0, Hr = Ye.length; yr < Hr; yr++) (kt = Ye[yr]) && (nt = kt[Te][X], hl(kt, yr, Te, se, { time: nt.time, ease: nt.ease, delay: nt.delay + nt.duration, duration: nt.duration })), He.push(kt);
+            }
+            return Co(Ne, Te, se);
+          };
+          function To(X) {
+            return X == null ? "__transition__" : "__transition_" + X + "__";
+          }
+          function hl(X, se, Te, Ne, He) {
+            var Ye = X[Te] || (X[Te] = { active: 0, count: 0 }), kt = Ye[Ne], nt, jt, gr, yr, Hr;
+            function qr(Zr) {
+              var ai = kt.delay;
+              if (jt.t = ai + nt, ai <= Zr) return _i(Zr - ai);
+              jt.c = _i;
+            }
+            function _i(Zr) {
+              var ai = Ye.active, gi = Ye[ai];
+              gi && (gi.timer.c = null, gi.timer.t = NaN, --Ye.count, delete Ye[ai], gi.event && gi.event.interrupt.call(X, X.__data__, gi.index));
+              for (var Ii in Ye) if (+Ii < Ne) {
+                var Si = Ye[Ii];
+                Si.timer.c = null, Si.timer.t = NaN, --Ye.count, delete Ye[Ii];
+              }
+              jt.c = bi, No(function() {
+                return jt.c && bi(Zr || 1) && (jt.c = null, jt.t = NaN), 1;
+              }, 0, nt), Ye.active = Ne, kt.event && kt.event.start.call(X, X.__data__, se), Hr = [], kt.tween.forEach(function(ei, Ln) {
+                (Ln = Ln.call(X, X.__data__, se)) && Hr.push(Ln);
+              }), yr = kt.ease, gr = kt.duration;
+            }
+            function bi(Zr) {
+              for (var ai = Zr / gr, gi = yr(ai), Ii = Hr.length; Ii > 0; ) Hr[--Ii].call(X, gi);
+              if (ai >= 1) return kt.event && kt.event.end.call(X, X.__data__, se), --Ye.count ? delete Ye[Ne] : delete X[Te], 1;
+            }
+            kt || (nt = He.time, jt = No(qr, 0, nt), kt = Ye[Ne] = { tween: new T(), time: nt, timer: jt, delay: He.delay, duration: He.duration, ease: He.ease, index: se }, He = null, ++Ye.count);
+          }
+          e.svg.axis = function() {
+            var X = e.scale.linear(), se = Ul, Te = 6, Ne = 6, He = 3, Ye = [10], kt = null, nt;
+            function jt(gr) {
+              gr.each(function() {
+                var yr = e.select(this), Hr = this.__chart__ || X, qr = this.__chart__ = X.copy(), _i = kt == null ? qr.ticks ? qr.ticks.apply(qr, Ye) : qr.domain() : kt, bi = nt == null ? qr.tickFormat ? qr.tickFormat.apply(qr, Ye) : G : nt, Zr = yr.selectAll(".tick").data(_i, qr), ai = Zr.enter().insert("g", ".domain").attr("class", "tick").style("opacity", Je), gi = e.transition(Zr.exit()).style("opacity", Je).remove(), Ii = e.transition(Zr.order()).style("opacity", 1), Si = Math.max(Te, 0) + He, ei, Ln = wn(qr), En = yr.selectAll(".domain").data([0]), Un = (En.enter().append("path").attr("class", "domain"), e.transition(En));
+                ai.append("line"), ai.append("text");
+                var ia = ai.select("line"), Ea = Ii.select("line"), Ia = Zr.select("text").text(bi), yo = ai.select("text"), Da = Ii.select("text"), go = se === "top" || se === "left" ? -1 : 1, Is, Ms, Xs, Gn;
+                if (se === "bottom" || se === "top" ? (ei = au, Is = "x", Xs = "y", Ms = "x2", Gn = "y2", Ia.attr("dy", go < 0 ? "0em" : ".71em").style("text-anchor", "middle"), Un.attr("d", "M" + Ln[0] + "," + go * Ne + "V0H" + Ln[1] + "V" + go * Ne)) : (ei = Js, Is = "y", Xs = "x", Ms = "y2", Gn = "x2", Ia.attr("dy", ".32em").style("text-anchor", go < 0 ? "end" : "start"), Un.attr("d", "M" + go * Ne + "," + Ln[0] + "H0V" + Ln[1] + "H" + go * Ne)), ia.attr(Gn, go * Te), yo.attr(Xs, go * Si), Ea.attr(Ms, 0).attr(Gn, go * Te), Da.attr(Is, 0).attr(Xs, go * Si), qr.rangeBand) {
+                  var ja = qr, Fo = ja.rangeBand() / 2;
+                  Hr = qr = function(Uo) {
+                    return ja(Uo) + Fo;
+                  };
+                } else Hr.rangeBand ? Hr = qr : gi.call(ei, qr, Hr);
+                ai.call(ei, Hr, qr), Ii.call(ei, qr, qr);
+              });
+            }
+            return jt.scale = function(gr) {
+              return arguments.length ? (X = gr, jt) : X;
+            }, jt.orient = function(gr) {
+              return arguments.length ? (se = gr in Lu ? gr + "" : Ul, jt) : se;
+            }, jt.ticks = function() {
+              return arguments.length ? (Ye = r(arguments), jt) : Ye;
+            }, jt.tickValues = function(gr) {
+              return arguments.length ? (kt = gr, jt) : kt;
+            }, jt.tickFormat = function(gr) {
+              return arguments.length ? (nt = gr, jt) : nt;
+            }, jt.tickSize = function(gr) {
+              var yr = arguments.length;
+              return yr ? (Te = +gr, Ne = +arguments[yr - 1], jt) : Te;
+            }, jt.innerTickSize = function(gr) {
+              return arguments.length ? (Te = +gr, jt) : Te;
+            }, jt.outerTickSize = function(gr) {
+              return arguments.length ? (Ne = +gr, jt) : Ne;
+            }, jt.tickPadding = function(gr) {
+              return arguments.length ? (He = +gr, jt) : He;
+            }, jt.tickSubdivide = function() {
+              return arguments.length && jt;
+            }, jt;
+          };
+          var Ul = "bottom", Lu = { top: 1, right: 1, bottom: 1, left: 1 };
+          function au(X, se, Te) {
+            X.attr("transform", function(Ne) {
+              var He = se(Ne);
+              return "translate(" + (isFinite(He) ? He : Te(Ne)) + ",0)";
+            });
+          }
+          function Js(X, se, Te) {
+            X.attr("transform", function(Ne) {
+              var He = se(Ne);
+              return "translate(0," + (isFinite(He) ? He : Te(Ne)) + ")";
+            });
+          }
+          e.svg.brush = function() {
+            var X = Le(yr, "brushstart", "brush", "brushend"), se = null, Te = null, Ne = [0, 0], He = [0, 0], Ye, kt, nt = true, jt = true, gr = dc[0];
+            function yr(Zr) {
+              Zr.each(function() {
+                var ai = e.select(this).style("pointer-events", "all").style("-webkit-tap-highlight-color", "rgba(0,0,0,0)").on("mousedown.brush", bi).on("touchstart.brush", bi), gi = ai.selectAll(".background").data([0]);
+                gi.enter().append("rect").attr("class", "background").style("visibility", "hidden").style("cursor", "crosshair"), ai.selectAll(".extent").data([0]).enter().append("rect").attr("class", "extent").style("cursor", "move");
+                var Ii = ai.selectAll(".resize").data(gr, G);
+                Ii.exit().remove(), Ii.enter().append("g").attr("class", function(En) {
+                  return "resize " + En;
+                }).style("cursor", function(En) {
+                  return eu[En];
+                }).append("rect").attr("x", function(En) {
+                  return /[ew]$/.test(En) ? -3 : null;
+                }).attr("y", function(En) {
+                  return /^[ns]/.test(En) ? -3 : null;
+                }).attr("width", 6).attr("height", 6).style("visibility", "hidden"), Ii.style("display", yr.empty() ? "none" : null);
+                var Si = e.transition(ai), ei = e.transition(gi), Ln;
+                se && (Ln = wn(se), ei.attr("x", Ln[0]).attr("width", Ln[1] - Ln[0]), qr(Si)), Te && (Ln = wn(Te), ei.attr("y", Ln[0]).attr("height", Ln[1] - Ln[0]), _i(Si)), Hr(Si);
+              });
+            }
+            yr.event = function(Zr) {
+              Zr.each(function() {
+                var ai = X.of(this, arguments), gi = { x: Ne, y: He, i: Ye, j: kt }, Ii = this.__chart__ || gi;
+                this.__chart__ = gi, Bo ? e.select(this).transition().each("start.brush", function() {
+                  Ye = Ii.i, kt = Ii.j, Ne = Ii.x, He = Ii.y, ai({ type: "brushstart" });
+                }).tween("brush:brush", function() {
+                  var Si = Gu(Ne, gi.x), ei = Gu(He, gi.y);
+                  return Ye = kt = null, function(Ln) {
+                    Ne = gi.x = Si(Ln), He = gi.y = ei(Ln), ai({ type: "brush", mode: "resize" });
+                  };
+                }).each("end.brush", function() {
+                  Ye = gi.i, kt = gi.j, ai({ type: "brush", mode: "resize" }), ai({ type: "brushend" });
+                }) : (ai({ type: "brushstart" }), ai({ type: "brush", mode: "resize" }), ai({ type: "brushend" }));
+              });
+            };
+            function Hr(Zr) {
+              Zr.selectAll(".resize").attr("transform", function(ai) {
+                return "translate(" + Ne[+/e$/.test(ai)] + "," + He[+/^s/.test(ai)] + ")";
+              });
+            }
+            function qr(Zr) {
+              Zr.select(".extent").attr("x", Ne[0]), Zr.selectAll(".extent,.n>rect,.s>rect").attr("width", Ne[1] - Ne[0]);
+            }
+            function _i(Zr) {
+              Zr.select(".extent").attr("y", He[0]), Zr.selectAll(".extent,.e>rect,.w>rect").attr("height", He[1] - He[0]);
+            }
+            function bi() {
+              var Zr = this, ai = e.select(e.event.target), gi = X.of(Zr, arguments), Ii = e.select(Zr), Si = ai.datum(), ei = !/^(n|s)$/.test(Si) && se, Ln = !/^(e|w)$/.test(Si) && Te, En = ai.classed("extent"), Un = Br(Zr), ia, Ea = e.mouse(Zr), Ia, yo = e.select(a(Zr)).on("keydown.brush", Is).on("keyup.brush", Ms);
+              if (e.event.changedTouches ? yo.on("touchmove.brush", Xs).on("touchend.brush", ja) : yo.on("mousemove.brush", Xs).on("mouseup.brush", ja), Ii.interrupt().selectAll("*").interrupt(), En) Ea[0] = Ne[0] - Ea[0], Ea[1] = He[0] - Ea[1];
+              else if (Si) {
+                var Da = +/w$/.test(Si), go = +/^n/.test(Si);
+                Ia = [Ne[1 - Da] - Ea[0], He[1 - go] - Ea[1]], Ea[0] = Ne[Da], Ea[1] = He[go];
+              } else e.event.altKey && (ia = Ea.slice());
+              Ii.style("pointer-events", "none").selectAll(".resize").style("display", null), e.select("body").style("cursor", ai.style("cursor")), gi({ type: "brushstart" }), Xs();
+              function Is() {
+                e.event.keyCode == 32 && (En || (ia = null, Ea[0] -= Ne[1], Ea[1] -= He[1], En = 2), _e());
+              }
+              function Ms() {
+                e.event.keyCode == 32 && En == 2 && (Ea[0] += Ne[1], Ea[1] += He[1], En = 0, _e());
+              }
+              function Xs() {
+                var Fo = e.mouse(Zr), Uo = false;
+                Ia && (Fo[0] += Ia[0], Fo[1] += Ia[1]), En || (e.event.altKey ? (ia || (ia = [(Ne[0] + Ne[1]) / 2, (He[0] + He[1]) / 2]), Ea[0] = Ne[+(Fo[0] < ia[0])], Ea[1] = He[+(Fo[1] < ia[1])]) : ia = null), ei && Gn(Fo, se, 0) && (qr(Ii), Uo = true), Ln && Gn(Fo, Te, 1) && (_i(Ii), Uo = true), Uo && (Hr(Ii), gi({ type: "brush", mode: En ? "move" : "resize" }));
+              }
+              function Gn(Fo, Uo, $s) {
+                var Sl = wn(Uo), bu = Sl[0], dl = Sl[1], Sc = Ea[$s], Me = $s ? He : Ne, bt = Me[1] - Me[0], zt, Rr;
+                if (En && (bu -= Sc, dl -= bt + Sc), zt = ($s ? jt : nt) ? Math.max(bu, Math.min(dl, Fo[$s])) : Fo[$s], En ? Rr = (zt += Sc) + bt : (ia && (Sc = Math.max(bu, Math.min(dl, 2 * ia[$s] - zt))), Sc < zt ? (Rr = zt, zt = Sc) : Rr = Sc), Me[0] != zt || Me[1] != Rr) return $s ? kt = null : Ye = null, Me[0] = zt, Me[1] = Rr, true;
+              }
+              function ja() {
+                Xs(), Ii.style("pointer-events", "all").selectAll(".resize").style("display", yr.empty() ? "none" : null), e.select("body").style("cursor", null), yo.on("mousemove.brush", null).on("mouseup.brush", null).on("touchmove.brush", null).on("touchend.brush", null).on("keydown.brush", null).on("keyup.brush", null), Un(), gi({ type: "brushend" });
+              }
+            }
+            return yr.x = function(Zr) {
+              return arguments.length ? (se = Zr, gr = dc[!se << 1 | !Te], yr) : se;
+            }, yr.y = function(Zr) {
+              return arguments.length ? (Te = Zr, gr = dc[!se << 1 | !Te], yr) : Te;
+            }, yr.clamp = function(Zr) {
+              return arguments.length ? (se && Te ? (nt = !!Zr[0], jt = !!Zr[1]) : se ? nt = !!Zr : Te && (jt = !!Zr), yr) : se && Te ? [nt, jt] : se ? nt : Te ? jt : null;
+            }, yr.extent = function(Zr) {
+              var ai, gi, Ii, Si, ei;
+              return arguments.length ? (se && (ai = Zr[0], gi = Zr[1], Te && (ai = ai[0], gi = gi[0]), Ye = [ai, gi], se.invert && (ai = se(ai), gi = se(gi)), gi < ai && (ei = ai, ai = gi, gi = ei), (ai != Ne[0] || gi != Ne[1]) && (Ne = [ai, gi])), Te && (Ii = Zr[0], Si = Zr[1], se && (Ii = Ii[1], Si = Si[1]), kt = [Ii, Si], Te.invert && (Ii = Te(Ii), Si = Te(Si)), Si < Ii && (ei = Ii, Ii = Si, Si = ei), (Ii != He[0] || Si != He[1]) && (He = [Ii, Si])), yr) : (se && (Ye ? (ai = Ye[0], gi = Ye[1]) : (ai = Ne[0], gi = Ne[1], se.invert && (ai = se.invert(ai), gi = se.invert(gi)), gi < ai && (ei = ai, ai = gi, gi = ei))), Te && (kt ? (Ii = kt[0], Si = kt[1]) : (Ii = He[0], Si = He[1], Te.invert && (Ii = Te.invert(Ii), Si = Te.invert(Si)), Si < Ii && (ei = Ii, Ii = Si, Si = ei))), se && Te ? [[ai, Ii], [gi, Si]] : se ? [ai, gi] : Te && [Ii, Si]);
+            }, yr.clear = function() {
+              return yr.empty() || (Ne = [0, 0], He = [0, 0], Ye = kt = null), yr;
+            }, yr.empty = function() {
+              return !!se && Ne[0] == Ne[1] || !!Te && He[0] == He[1];
+            }, e.rebind(yr, X, "on");
+          };
+          var eu = { n: "ns-resize", e: "ew-resize", s: "ns-resize", w: "ew-resize", nw: "nwse-resize", ne: "nesw-resize", se: "nwse-resize", sw: "nesw-resize" }, dc = [["n", "e", "s", "w", "nw", "ne", "se", "sw"], ["e", "w"], ["n", "s"], []];
+          e.text = hn(function(X) {
+            return X.responseText;
+          }), e.json = function(X, se) {
+            return An(X, "application/json", Tl, se);
+          };
+          function Tl(X) {
+            return JSON.parse(X.responseText);
+          }
+          e.html = function(X, se) {
+            return An(X, "text/html", Al, se);
+          };
+          function Al(X) {
+            var se = n.createRange();
+            return se.selectNode(n.body), se.createContextualFragment(X.responseText);
+          }
+          e.xml = hn(function(X) {
+            return X.responseXML;
+          }), typeof y6 == "object" && y6.exports ? y6.exports = e : this.d3 = e;
+        }).apply(self);
+      });
+      var SO = ye((_6, wee) => {
+        (function(e, t) {
+          typeof _6 == "object" && typeof wee != "undefined" ? t(_6) : (e = e || self, t(e.d3 = e.d3 || {}));
+        })(_6, function(e) {
+          var t = /* @__PURE__ */ new Date(), r = /* @__PURE__ */ new Date();
+          function n($e, St, Qt, Gt) {
+            function _t(It) {
+              return $e(It = arguments.length === 0 ? /* @__PURE__ */ new Date() : /* @__PURE__ */ new Date(+It)), It;
+            }
+            return _t.floor = function(It) {
+              return $e(It = /* @__PURE__ */ new Date(+It)), It;
+            }, _t.ceil = function(It) {
+              return $e(It = new Date(It - 1)), St(It, 1), $e(It), It;
+            }, _t.round = function(It) {
+              var mt = _t(It), er = _t.ceil(It);
+              return It - mt < er - It ? mt : er;
+            }, _t.offset = function(It, mt) {
+              return St(It = /* @__PURE__ */ new Date(+It), mt == null ? 1 : Math.floor(mt)), It;
+            }, _t.range = function(It, mt, er) {
+              var lr = [], wr;
+              if (It = _t.ceil(It), er = er == null ? 1 : Math.floor(er), !(It < mt) || !(er > 0)) return lr;
+              do
+                lr.push(wr = /* @__PURE__ */ new Date(+It)), St(It, er), $e(It);
+              while (wr < It && It < mt);
+              return lr;
+            }, _t.filter = function(It) {
+              return n(function(mt) {
+                if (mt >= mt) for (; $e(mt), !It(mt); ) mt.setTime(mt - 1);
+              }, function(mt, er) {
+                if (mt >= mt) if (er < 0) for (; ++er <= 0; ) for (; St(mt, -1), !It(mt); ) ;
+                else for (; --er >= 0; ) for (; St(mt, 1), !It(mt); ) ;
+              });
+            }, Qt && (_t.count = function(It, mt) {
+              return t.setTime(+It), r.setTime(+mt), $e(t), $e(r), Math.floor(Qt(t, r));
+            }, _t.every = function(It) {
+              return It = Math.floor(It), !isFinite(It) || !(It > 0) ? null : It > 1 ? _t.filter(Gt ? function(mt) {
+                return Gt(mt) % It === 0;
+              } : function(mt) {
+                return _t.count(0, mt) % It === 0;
+              }) : _t;
+            }), _t;
+          }
+          var i = n(function() {
+          }, function($e, St) {
+            $e.setTime(+$e + St);
+          }, function($e, St) {
+            return St - $e;
+          });
+          i.every = function($e) {
+            return $e = Math.floor($e), !isFinite($e) || !($e > 0) ? null : $e > 1 ? n(function(St) {
+              St.setTime(Math.floor(St / $e) * $e);
+            }, function(St, Qt) {
+              St.setTime(+St + Qt * $e);
+            }, function(St, Qt) {
+              return (Qt - St) / $e;
+            }) : i;
+          };
+          var a = i.range, o = 1e3, s = 6e4, l = 36e5, u = 864e5, c = 6048e5, f = n(function($e) {
+            $e.setTime($e - $e.getMilliseconds());
+          }, function($e, St) {
+            $e.setTime(+$e + St * o);
+          }, function($e, St) {
+            return (St - $e) / o;
+          }, function($e) {
+            return $e.getUTCSeconds();
+          }), h = f.range, d = n(function($e) {
+            $e.setTime($e - $e.getMilliseconds() - $e.getSeconds() * o);
+          }, function($e, St) {
+            $e.setTime(+$e + St * s);
+          }, function($e, St) {
+            return (St - $e) / s;
+          }, function($e) {
+            return $e.getMinutes();
+          }), v = d.range, _ = n(function($e) {
+            $e.setTime($e - $e.getMilliseconds() - $e.getSeconds() * o - $e.getMinutes() * s);
+          }, function($e, St) {
+            $e.setTime(+$e + St * l);
+          }, function($e, St) {
+            return (St - $e) / l;
+          }, function($e) {
+            return $e.getHours();
+          }), b = _.range, p = n(function($e) {
+            $e.setHours(0, 0, 0, 0);
+          }, function($e, St) {
+            $e.setDate($e.getDate() + St);
+          }, function($e, St) {
+            return (St - $e - (St.getTimezoneOffset() - $e.getTimezoneOffset()) * s) / u;
+          }, function($e) {
+            return $e.getDate() - 1;
+          }), k = p.range;
+          function E($e) {
+            return n(function(St) {
+              St.setDate(St.getDate() - (St.getDay() + 7 - $e) % 7), St.setHours(0, 0, 0, 0);
+            }, function(St, Qt) {
+              St.setDate(St.getDate() + Qt * 7);
+            }, function(St, Qt) {
+              return (Qt - St - (Qt.getTimezoneOffset() - St.getTimezoneOffset()) * s) / c;
+            });
+          }
+          var T = E(0), L = E(1), x = E(2), C = E(3), M = E(4), g = E(5), P = E(6), A = T.range, z = L.range, O = x.range, U = C.range, G = M.range, Z = g.range, j = P.range, N = n(function($e) {
+            $e.setDate(1), $e.setHours(0, 0, 0, 0);
+          }, function($e, St) {
+            $e.setMonth($e.getMonth() + St);
+          }, function($e, St) {
+            return St.getMonth() - $e.getMonth() + (St.getFullYear() - $e.getFullYear()) * 12;
+          }, function($e) {
+            return $e.getMonth();
+          }), H = N.range, re = n(function($e) {
+            $e.setMonth(0, 1), $e.setHours(0, 0, 0, 0);
+          }, function($e, St) {
+            $e.setFullYear($e.getFullYear() + St);
+          }, function($e, St) {
+            return St.getFullYear() - $e.getFullYear();
+          }, function($e) {
+            return $e.getFullYear();
+          });
+          re.every = function($e) {
+            return !isFinite($e = Math.floor($e)) || !($e > 0) ? null : n(function(St) {
+              St.setFullYear(Math.floor(St.getFullYear() / $e) * $e), St.setMonth(0, 1), St.setHours(0, 0, 0, 0);
+            }, function(St, Qt) {
+              St.setFullYear(St.getFullYear() + Qt * $e);
+            });
+          };
+          var oe = re.range, _e = n(function($e) {
+            $e.setUTCSeconds(0, 0);
+          }, function($e, St) {
+            $e.setTime(+$e + St * s);
+          }, function($e, St) {
+            return (St - $e) / s;
+          }, function($e) {
+            return $e.getUTCMinutes();
+          }), Ce = _e.range, Le = n(function($e) {
+            $e.setUTCMinutes(0, 0, 0);
+          }, function($e, St) {
+            $e.setTime(+$e + St * l);
+          }, function($e, St) {
+            return (St - $e) / l;
+          }, function($e) {
+            return $e.getUTCHours();
+          }), ge = Le.range, ie = n(function($e) {
+            $e.setUTCHours(0, 0, 0, 0);
+          }, function($e, St) {
+            $e.setUTCDate($e.getUTCDate() + St);
+          }, function($e, St) {
+            return (St - $e) / u;
+          }, function($e) {
+            return $e.getUTCDate() - 1;
+          }), Se = ie.range;
+          function Ee($e) {
+            return n(function(St) {
+              St.setUTCDate(St.getUTCDate() - (St.getUTCDay() + 7 - $e) % 7), St.setUTCHours(0, 0, 0, 0);
+            }, function(St, Qt) {
+              St.setUTCDate(St.getUTCDate() + Qt * 7);
+            }, function(St, Qt) {
+              return (Qt - St) / c;
+            });
+          }
+          var Ae = Ee(0), Be = Ee(1), Pe = Ee(2), me = Ee(3), De = Ee(4), ce = Ee(5), je = Ee(6), lt = Ae.range, pt = Be.range, Vt = Pe.range, ot = me.range, ut = De.range, Wt = ce.range, Nt = je.range, $t = n(function($e) {
+            $e.setUTCDate(1), $e.setUTCHours(0, 0, 0, 0);
+          }, function($e, St) {
+            $e.setUTCMonth($e.getUTCMonth() + St);
+          }, function($e, St) {
+            return St.getUTCMonth() - $e.getUTCMonth() + (St.getUTCFullYear() - $e.getUTCFullYear()) * 12;
+          }, function($e) {
+            return $e.getUTCMonth();
+          }), sr = $t.range, Tr = n(function($e) {
+            $e.setUTCMonth(0, 1), $e.setUTCHours(0, 0, 0, 0);
+          }, function($e, St) {
+            $e.setUTCFullYear($e.getUTCFullYear() + St);
+          }, function($e, St) {
+            return St.getUTCFullYear() - $e.getUTCFullYear();
+          }, function($e) {
+            return $e.getUTCFullYear();
+          });
+          Tr.every = function($e) {
+            return !isFinite($e = Math.floor($e)) || !($e > 0) ? null : n(function(St) {
+              St.setUTCFullYear(Math.floor(St.getUTCFullYear() / $e) * $e), St.setUTCMonth(0, 1), St.setUTCHours(0, 0, 0, 0);
+            }, function(St, Qt) {
+              St.setUTCFullYear(St.getUTCFullYear() + Qt * $e);
+            });
+          };
+          var fr = Tr.range;
+          e.timeDay = p, e.timeDays = k, e.timeFriday = g, e.timeFridays = Z, e.timeHour = _, e.timeHours = b, e.timeInterval = n, e.timeMillisecond = i, e.timeMilliseconds = a, e.timeMinute = d, e.timeMinutes = v, e.timeMonday = L, e.timeMondays = z, e.timeMonth = N, e.timeMonths = H, e.timeSaturday = P, e.timeSaturdays = j, e.timeSecond = f, e.timeSeconds = h, e.timeSunday = T, e.timeSundays = A, e.timeThursday = M, e.timeThursdays = G, e.timeTuesday = x, e.timeTuesdays = O, e.timeWednesday = C, e.timeWednesdays = U, e.timeWeek = T, e.timeWeeks = A, e.timeYear = re, e.timeYears = oe, e.utcDay = ie, e.utcDays = Se, e.utcFriday = ce, e.utcFridays = Wt, e.utcHour = Le, e.utcHours = ge, e.utcMillisecond = i, e.utcMilliseconds = a, e.utcMinute = _e, e.utcMinutes = Ce, e.utcMonday = Be, e.utcMondays = pt, e.utcMonth = $t, e.utcMonths = sr, e.utcSaturday = je, e.utcSaturdays = Nt, e.utcSecond = f, e.utcSeconds = h, e.utcSunday = Ae, e.utcSundays = lt, e.utcThursday = De, e.utcThursdays = ut, e.utcTuesday = Pe, e.utcTuesdays = Vt, e.utcWednesday = me, e.utcWednesdays = ot, e.utcWeek = Ae, e.utcWeeks = lt, e.utcYear = Tr, e.utcYears = fr, Object.defineProperty(e, "__esModule", { value: true });
+        });
+      });
+      var f3 = ye((x6, Tee) => {
+        (function(e, t) {
+          typeof x6 == "object" && typeof Tee != "undefined" ? t(x6, SO()) : (e = e || self, t(e.d3 = e.d3 || {}, e.d3));
+        })(x6, function(e, t) {
+          function r(Ge) {
+            if (0 <= Ge.y && Ge.y < 100) {
+              var Je = new Date(-1, Ge.m, Ge.d, Ge.H, Ge.M, Ge.S, Ge.L);
+              return Je.setFullYear(Ge.y), Je;
+            }
+            return new Date(Ge.y, Ge.m, Ge.d, Ge.H, Ge.M, Ge.S, Ge.L);
+          }
+          function n(Ge) {
+            if (0 <= Ge.y && Ge.y < 100) {
+              var Je = new Date(Date.UTC(-1, Ge.m, Ge.d, Ge.H, Ge.M, Ge.S, Ge.L));
+              return Je.setUTCFullYear(Ge.y), Je;
+            }
+            return new Date(Date.UTC(Ge.y, Ge.m, Ge.d, Ge.H, Ge.M, Ge.S, Ge.L));
+          }
+          function i(Ge, Je, We) {
+            return { y: Ge, m: Je, d: We, H: 0, M: 0, S: 0, L: 0 };
+          }
+          function a(Ge) {
+            var Je = Ge.dateTime, We = Ge.date, tt = Ge.time, xt = Ge.periods, Ie = Ge.days, xe = Ge.shortDays, ke = Ge.months, vt = Ge.shortMonths, ir = h(xt), ar = d(xt), vr = h(Ie), ii = d(Ie), pi = h(xe), $r = d(xe), di = h(ke), ji = d(ke), In = h(vt), wi = d(vt), On = { a: $i, A: tn, b: fn, B: yn, c: null, d: N, e: N, f: Ce, H, I: re, j: oe, L: _e, m: Le, M: ge, p: Sn, q: Ba, Q: mt, s: er, S: ie, u: Se, U: Ee, V: Ae, w: Be, W: Pe, x: null, X: null, y: me, Y: De, Z: ce, "%": It }, qn = { a: ua, A: ma, b: Wa, B: Fa, c: null, d: je, e: je, f: ut, H: lt, I: pt, j: Vt, L: ot, m: Wt, M: Nt, p: Xo, q: da, Q: mt, s: er, S: $t, u: sr, U: Tr, V: fr, w: $e, W: St, x: null, X: null, y: Qt, Y: Gt, Z: _t, "%": It }, Fn = { a: rr, A: nr, b: Er, B: Xr, c: ri, d: M, e: M, f: U, H: P, I: P, j: g, L: O, m: C, M: A, p: wt, q: x, Q: Z, s: j, S: z, u: _, U: b, V: p, w: v, W: k, x: Qr, X: Oi, y: T, Y: E, Z: L, "%": G };
+            On.x = ra(We, On), On.X = ra(tt, On), On.c = ra(Je, On), qn.x = ra(We, qn), qn.X = ra(tt, qn), qn.c = ra(Je, qn);
+            function ra(Wn, Ha) {
+              return function(vo) {
+                var jn = [], Mt = -1, kr = 0, Jr = Wn.length, vi, hn, An;
+                for (vo instanceof Date || (vo = /* @__PURE__ */ new Date(+vo)); ++Mt < Jr; ) Wn.charCodeAt(Mt) === 37 && (jn.push(Wn.slice(kr, Mt)), (hn = o[vi = Wn.charAt(++Mt)]) != null ? vi = Wn.charAt(++Mt) : hn = vi === "e" ? " " : "0", (An = Ha[vi]) && (vi = An(vo, hn)), jn.push(vi), kr = Mt + 1);
+                return jn.push(Wn.slice(kr, Mt)), jn.join("");
+              };
+            }
+            function la(Wn, Ha) {
+              return function(vo) {
+                var jn = i(1900, void 0, 1), Mt = Ut(jn, Wn, vo += "", 0), kr, Jr;
+                if (Mt != vo.length) return null;
+                if ("Q" in jn) return new Date(jn.Q);
+                if ("s" in jn) return new Date(jn.s * 1e3 + ("L" in jn ? jn.L : 0));
+                if (Ha && !("Z" in jn) && (jn.Z = 0), "p" in jn && (jn.H = jn.H % 12 + jn.p * 12), jn.m === void 0 && (jn.m = "q" in jn ? jn.q : 0), "V" in jn) {
+                  if (jn.V < 1 || jn.V > 53) return null;
+                  "w" in jn || (jn.w = 1), "Z" in jn ? (kr = n(i(jn.y, 0, 1)), Jr = kr.getUTCDay(), kr = Jr > 4 || Jr === 0 ? t.utcMonday.ceil(kr) : t.utcMonday(kr), kr = t.utcDay.offset(kr, (jn.V - 1) * 7), jn.y = kr.getUTCFullYear(), jn.m = kr.getUTCMonth(), jn.d = kr.getUTCDate() + (jn.w + 6) % 7) : (kr = r(i(jn.y, 0, 1)), Jr = kr.getDay(), kr = Jr > 4 || Jr === 0 ? t.timeMonday.ceil(kr) : t.timeMonday(kr), kr = t.timeDay.offset(kr, (jn.V - 1) * 7), jn.y = kr.getFullYear(), jn.m = kr.getMonth(), jn.d = kr.getDate() + (jn.w + 6) % 7);
+                } else ("W" in jn || "U" in jn) && ("w" in jn || (jn.w = "u" in jn ? jn.u % 7 : "W" in jn ? 1 : 0), Jr = "Z" in jn ? n(i(jn.y, 0, 1)).getUTCDay() : r(i(jn.y, 0, 1)).getDay(), jn.m = 0, jn.d = "W" in jn ? (jn.w + 6) % 7 + jn.W * 7 - (Jr + 5) % 7 : jn.w + jn.U * 7 - (Jr + 6) % 7);
+                return "Z" in jn ? (jn.H += jn.Z / 100 | 0, jn.M += jn.Z % 100, n(jn)) : r(jn);
+              };
+            }
+            function Ut(Wn, Ha, vo, jn) {
+              for (var Mt = 0, kr = Ha.length, Jr = vo.length, vi, hn; Mt < kr; ) {
+                if (jn >= Jr) return -1;
+                if (vi = Ha.charCodeAt(Mt++), vi === 37) {
+                  if (vi = Ha.charAt(Mt++), hn = Fn[vi in o ? Ha.charAt(Mt++) : vi], !hn || (jn = hn(Wn, vo, jn)) < 0) return -1;
+                } else if (vi != vo.charCodeAt(jn++)) return -1;
+              }
+              return jn;
+            }
+            function wt(Wn, Ha, vo) {
+              var jn = ir.exec(Ha.slice(vo));
+              return jn ? (Wn.p = ar[jn[0].toLowerCase()], vo + jn[0].length) : -1;
+            }
+            function rr(Wn, Ha, vo) {
+              var jn = pi.exec(Ha.slice(vo));
+              return jn ? (Wn.w = $r[jn[0].toLowerCase()], vo + jn[0].length) : -1;
+            }
+            function nr(Wn, Ha, vo) {
+              var jn = vr.exec(Ha.slice(vo));
+              return jn ? (Wn.w = ii[jn[0].toLowerCase()], vo + jn[0].length) : -1;
+            }
+            function Er(Wn, Ha, vo) {
+              var jn = In.exec(Ha.slice(vo));
+              return jn ? (Wn.m = wi[jn[0].toLowerCase()], vo + jn[0].length) : -1;
+            }
+            function Xr(Wn, Ha, vo) {
+              var jn = di.exec(Ha.slice(vo));
+              return jn ? (Wn.m = ji[jn[0].toLowerCase()], vo + jn[0].length) : -1;
+            }
+            function ri(Wn, Ha, vo) {
+              return Ut(Wn, Je, Ha, vo);
+            }
+            function Qr(Wn, Ha, vo) {
+              return Ut(Wn, We, Ha, vo);
+            }
+            function Oi(Wn, Ha, vo) {
+              return Ut(Wn, tt, Ha, vo);
+            }
+            function $i(Wn) {
+              return xe[Wn.getDay()];
+            }
+            function tn(Wn) {
+              return Ie[Wn.getDay()];
+            }
+            function fn(Wn) {
+              return vt[Wn.getMonth()];
+            }
+            function yn(Wn) {
+              return ke[Wn.getMonth()];
+            }
+            function Sn(Wn) {
+              return xt[+(Wn.getHours() >= 12)];
+            }
+            function Ba(Wn) {
+              return 1 + ~~(Wn.getMonth() / 3);
+            }
+            function ua(Wn) {
+              return xe[Wn.getUTCDay()];
+            }
+            function ma(Wn) {
+              return Ie[Wn.getUTCDay()];
+            }
+            function Wa(Wn) {
+              return vt[Wn.getUTCMonth()];
+            }
+            function Fa(Wn) {
+              return ke[Wn.getUTCMonth()];
+            }
+            function Xo(Wn) {
+              return xt[+(Wn.getUTCHours() >= 12)];
+            }
+            function da(Wn) {
+              return 1 + ~~(Wn.getUTCMonth() / 3);
+            }
+            return { format: function(Wn) {
+              var Ha = ra(Wn += "", On);
+              return Ha.toString = function() {
+                return Wn;
+              }, Ha;
+            }, parse: function(Wn) {
+              var Ha = la(Wn += "", false);
+              return Ha.toString = function() {
+                return Wn;
+              }, Ha;
+            }, utcFormat: function(Wn) {
+              var Ha = ra(Wn += "", qn);
+              return Ha.toString = function() {
+                return Wn;
+              }, Ha;
+            }, utcParse: function(Wn) {
+              var Ha = la(Wn += "", true);
+              return Ha.toString = function() {
+                return Wn;
+              }, Ha;
+            } };
+          }
+          var o = { "-": "", _: " ", 0: "0" }, s = /^\s*\d+/, l = /^%/, u = /[\\^$*+?|[\]().{}]/g;
+          function c(Ge, Je, We) {
+            var tt = Ge < 0 ? "-" : "", xt = (tt ? -Ge : Ge) + "", Ie = xt.length;
+            return tt + (Ie < We ? new Array(We - Ie + 1).join(Je) + xt : xt);
+          }
+          function f(Ge) {
+            return Ge.replace(u, "\\$&");
+          }
+          function h(Ge) {
+            return new RegExp("^(?:" + Ge.map(f).join("|") + ")", "i");
+          }
+          function d(Ge) {
+            for (var Je = {}, We = -1, tt = Ge.length; ++We < tt; ) Je[Ge[We].toLowerCase()] = We;
+            return Je;
+          }
+          function v(Ge, Je, We) {
+            var tt = s.exec(Je.slice(We, We + 1));
+            return tt ? (Ge.w = +tt[0], We + tt[0].length) : -1;
+          }
+          function _(Ge, Je, We) {
+            var tt = s.exec(Je.slice(We, We + 1));
+            return tt ? (Ge.u = +tt[0], We + tt[0].length) : -1;
+          }
+          function b(Ge, Je, We) {
+            var tt = s.exec(Je.slice(We, We + 2));
+            return tt ? (Ge.U = +tt[0], We + tt[0].length) : -1;
+          }
+          function p(Ge, Je, We) {
+            var tt = s.exec(Je.slice(We, We + 2));
+            return tt ? (Ge.V = +tt[0], We + tt[0].length) : -1;
+          }
+          function k(Ge, Je, We) {
+            var tt = s.exec(Je.slice(We, We + 2));
+            return tt ? (Ge.W = +tt[0], We + tt[0].length) : -1;
+          }
+          function E(Ge, Je, We) {
+            var tt = s.exec(Je.slice(We, We + 4));
+            return tt ? (Ge.y = +tt[0], We + tt[0].length) : -1;
+          }
+          function T(Ge, Je, We) {
+            var tt = s.exec(Je.slice(We, We + 2));
+            return tt ? (Ge.y = +tt[0] + (+tt[0] > 68 ? 1900 : 2e3), We + tt[0].length) : -1;
+          }
+          function L(Ge, Je, We) {
+            var tt = /^(Z)|([+-]\d\d)(?::?(\d\d))?/.exec(Je.slice(We, We + 6));
+            return tt ? (Ge.Z = tt[1] ? 0 : -(tt[2] + (tt[3] || "00")), We + tt[0].length) : -1;
+          }
+          function x(Ge, Je, We) {
+            var tt = s.exec(Je.slice(We, We + 1));
+            return tt ? (Ge.q = tt[0] * 3 - 3, We + tt[0].length) : -1;
+          }
+          function C(Ge, Je, We) {
+            var tt = s.exec(Je.slice(We, We + 2));
+            return tt ? (Ge.m = tt[0] - 1, We + tt[0].length) : -1;
+          }
+          function M(Ge, Je, We) {
+            var tt = s.exec(Je.slice(We, We + 2));
+            return tt ? (Ge.d = +tt[0], We + tt[0].length) : -1;
+          }
+          function g(Ge, Je, We) {
+            var tt = s.exec(Je.slice(We, We + 3));
+            return tt ? (Ge.m = 0, Ge.d = +tt[0], We + tt[0].length) : -1;
+          }
+          function P(Ge, Je, We) {
+            var tt = s.exec(Je.slice(We, We + 2));
+            return tt ? (Ge.H = +tt[0], We + tt[0].length) : -1;
+          }
+          function A(Ge, Je, We) {
+            var tt = s.exec(Je.slice(We, We + 2));
+            return tt ? (Ge.M = +tt[0], We + tt[0].length) : -1;
+          }
+          function z(Ge, Je, We) {
+            var tt = s.exec(Je.slice(We, We + 2));
+            return tt ? (Ge.S = +tt[0], We + tt[0].length) : -1;
+          }
+          function O(Ge, Je, We) {
+            var tt = s.exec(Je.slice(We, We + 3));
+            return tt ? (Ge.L = +tt[0], We + tt[0].length) : -1;
+          }
+          function U(Ge, Je, We) {
+            var tt = s.exec(Je.slice(We, We + 6));
+            return tt ? (Ge.L = Math.floor(tt[0] / 1e3), We + tt[0].length) : -1;
+          }
+          function G(Ge, Je, We) {
+            var tt = l.exec(Je.slice(We, We + 1));
+            return tt ? We + tt[0].length : -1;
+          }
+          function Z(Ge, Je, We) {
+            var tt = s.exec(Je.slice(We));
+            return tt ? (Ge.Q = +tt[0], We + tt[0].length) : -1;
+          }
+          function j(Ge, Je, We) {
+            var tt = s.exec(Je.slice(We));
+            return tt ? (Ge.s = +tt[0], We + tt[0].length) : -1;
+          }
+          function N(Ge, Je) {
+            return c(Ge.getDate(), Je, 2);
+          }
+          function H(Ge, Je) {
+            return c(Ge.getHours(), Je, 2);
+          }
+          function re(Ge, Je) {
+            return c(Ge.getHours() % 12 || 12, Je, 2);
+          }
+          function oe(Ge, Je) {
+            return c(1 + t.timeDay.count(t.timeYear(Ge), Ge), Je, 3);
+          }
+          function _e(Ge, Je) {
+            return c(Ge.getMilliseconds(), Je, 3);
+          }
+          function Ce(Ge, Je) {
+            return _e(Ge, Je) + "000";
+          }
+          function Le(Ge, Je) {
+            return c(Ge.getMonth() + 1, Je, 2);
+          }
+          function ge(Ge, Je) {
+            return c(Ge.getMinutes(), Je, 2);
+          }
+          function ie(Ge, Je) {
+            return c(Ge.getSeconds(), Je, 2);
+          }
+          function Se(Ge) {
+            var Je = Ge.getDay();
+            return Je === 0 ? 7 : Je;
+          }
+          function Ee(Ge, Je) {
+            return c(t.timeSunday.count(t.timeYear(Ge) - 1, Ge), Je, 2);
+          }
+          function Ae(Ge, Je) {
+            var We = Ge.getDay();
+            return Ge = We >= 4 || We === 0 ? t.timeThursday(Ge) : t.timeThursday.ceil(Ge), c(t.timeThursday.count(t.timeYear(Ge), Ge) + (t.timeYear(Ge).getDay() === 4), Je, 2);
+          }
+          function Be(Ge) {
+            return Ge.getDay();
+          }
+          function Pe(Ge, Je) {
+            return c(t.timeMonday.count(t.timeYear(Ge) - 1, Ge), Je, 2);
+          }
+          function me(Ge, Je) {
+            return c(Ge.getFullYear() % 100, Je, 2);
+          }
+          function De(Ge, Je) {
+            return c(Ge.getFullYear() % 1e4, Je, 4);
+          }
+          function ce(Ge) {
+            var Je = Ge.getTimezoneOffset();
+            return (Je > 0 ? "-" : (Je *= -1, "+")) + c(Je / 60 | 0, "0", 2) + c(Je % 60, "0", 2);
+          }
+          function je(Ge, Je) {
+            return c(Ge.getUTCDate(), Je, 2);
+          }
+          function lt(Ge, Je) {
+            return c(Ge.getUTCHours(), Je, 2);
+          }
+          function pt(Ge, Je) {
+            return c(Ge.getUTCHours() % 12 || 12, Je, 2);
+          }
+          function Vt(Ge, Je) {
+            return c(1 + t.utcDay.count(t.utcYear(Ge), Ge), Je, 3);
+          }
+          function ot(Ge, Je) {
+            return c(Ge.getUTCMilliseconds(), Je, 3);
+          }
+          function ut(Ge, Je) {
+            return ot(Ge, Je) + "000";
+          }
+          function Wt(Ge, Je) {
+            return c(Ge.getUTCMonth() + 1, Je, 2);
+          }
+          function Nt(Ge, Je) {
+            return c(Ge.getUTCMinutes(), Je, 2);
+          }
+          function $t(Ge, Je) {
+            return c(Ge.getUTCSeconds(), Je, 2);
+          }
+          function sr(Ge) {
+            var Je = Ge.getUTCDay();
+            return Je === 0 ? 7 : Je;
+          }
+          function Tr(Ge, Je) {
+            return c(t.utcSunday.count(t.utcYear(Ge) - 1, Ge), Je, 2);
+          }
+          function fr(Ge, Je) {
+            var We = Ge.getUTCDay();
+            return Ge = We >= 4 || We === 0 ? t.utcThursday(Ge) : t.utcThursday.ceil(Ge), c(t.utcThursday.count(t.utcYear(Ge), Ge) + (t.utcYear(Ge).getUTCDay() === 4), Je, 2);
+          }
+          function $e(Ge) {
+            return Ge.getUTCDay();
+          }
+          function St(Ge, Je) {
+            return c(t.utcMonday.count(t.utcYear(Ge) - 1, Ge), Je, 2);
+          }
+          function Qt(Ge, Je) {
+            return c(Ge.getUTCFullYear() % 100, Je, 2);
+          }
+          function Gt(Ge, Je) {
+            return c(Ge.getUTCFullYear() % 1e4, Je, 4);
+          }
+          function _t() {
+            return "+0000";
+          }
+          function It() {
+            return "%";
+          }
+          function mt(Ge) {
+            return +Ge;
+          }
+          function er(Ge) {
+            return Math.floor(+Ge / 1e3);
+          }
+          var lr;
+          wr({ dateTime: "%x, %X", date: "%-m/%-d/%Y", time: "%-I:%M:%S %p", periods: ["AM", "PM"], days: ["Sunday", "Monday", "Tuesday", "Wednesday", "Thursday", "Friday", "Saturday"], shortDays: ["Sun", "Mon", "Tue", "Wed", "Thu", "Fri", "Sat"], months: ["January", "February", "March", "April", "May", "June", "July", "August", "September", "October", "November", "December"], shortMonths: ["Jan", "Feb", "Mar", "Apr", "May", "Jun", "Jul", "Aug", "Sep", "Oct", "Nov", "Dec"] });
+          function wr(Ge) {
+            return lr = a(Ge), e.timeFormat = lr.format, e.timeParse = lr.parse, e.utcFormat = lr.utcFormat, e.utcParse = lr.utcParse, lr;
+          }
+          var Lr = "%Y-%m-%dT%H:%M:%S.%LZ";
+          function ti(Ge) {
+            return Ge.toISOString();
+          }
+          var Br = Date.prototype.toISOString ? ti : e.utcFormat(Lr);
+          function Vr(Ge) {
+            var Je = new Date(Ge);
+            return isNaN(Je) ? null : Je;
+          }
+          var dt = +/* @__PURE__ */ new Date("2000-01-01T00:00:00.000Z") ? Vr : e.utcParse(Lr);
+          e.isoFormat = Br, e.isoParse = dt, e.timeFormatDefaultLocale = wr, e.timeFormatLocale = a, Object.defineProperty(e, "__esModule", { value: true });
+        });
+      });
+      var MO = ye((b6, Aee) => {
+        (function(e, t) {
+          typeof b6 == "object" && typeof Aee != "undefined" ? t(b6) : (e = typeof globalThis != "undefined" ? globalThis : e || self, t(e.d3 = e.d3 || {}));
+        })(b6, function(e) {
+          function t(C) {
+            return Math.abs(C = Math.round(C)) >= 1e21 ? C.toLocaleString("en").replace(/,/g, "") : C.toString(10);
+          }
+          function r(C, M) {
+            if ((g = (C = M ? C.toExponential(M - 1) : C.toExponential()).indexOf("e")) < 0) return null;
+            var g, P = C.slice(0, g);
+            return [P.length > 1 ? P[0] + P.slice(2) : P, +C.slice(g + 1)];
+          }
+          function n(C) {
+            return C = r(Math.abs(C)), C ? C[1] : NaN;
+          }
+          function i(C, M) {
+            return function(g, P) {
+              for (var A = g.length, z = [], O = 0, U = C[0], G = 0; A > 0 && U > 0 && (G + U + 1 > P && (U = Math.max(1, P - G)), z.push(g.substring(A -= U, A + U)), !((G += U + 1) > P)); ) U = C[O = (O + 1) % C.length];
+              return z.reverse().join(M);
+            };
+          }
+          function a(C) {
+            return function(M) {
+              return M.replace(/[0-9]/g, function(g) {
+                return C[+g];
+              });
+            };
+          }
+          var o = /^(?:(.)?([<>=^]))?([+\-( ])?([$#])?(0)?(\d+)?(,)?(\.\d+)?(~)?([a-z%])?$/i;
+          function s(C) {
+            if (!(M = o.exec(C))) throw new Error("invalid format: " + C);
+            var M;
+            return new l({ fill: M[1], align: M[2], sign: M[3], symbol: M[4], zero: M[5], width: M[6], comma: M[7], precision: M[8] && M[8].slice(1), trim: M[9], type: M[10] });
+          }
+          s.prototype = l.prototype;
+          function l(C) {
+            this.fill = C.fill === void 0 ? " " : C.fill + "", this.align = C.align === void 0 ? ">" : C.align + "", this.sign = C.sign === void 0 ? "-" : C.sign + "", this.symbol = C.symbol === void 0 ? "" : C.symbol + "", this.zero = !!C.zero, this.width = C.width === void 0 ? void 0 : +C.width, this.comma = !!C.comma, this.precision = C.precision === void 0 ? void 0 : +C.precision, this.trim = !!C.trim, this.type = C.type === void 0 ? "" : C.type + "";
+          }
+          l.prototype.toString = function() {
+            return this.fill + this.align + this.sign + this.symbol + (this.zero ? "0" : "") + (this.width === void 0 ? "" : Math.max(1, this.width | 0)) + (this.comma ? "," : "") + (this.precision === void 0 ? "" : "." + Math.max(0, this.precision | 0)) + (this.trim ? "~" : "") + this.type;
+          };
+          function u(C) {
+            e: for (var M = C.length, g = 1, P = -1, A; g < M; ++g) switch (C[g]) {
+              case ".":
+                P = A = g;
+                break;
+              case "0":
+                P === 0 && (P = g), A = g;
+                break;
+              default:
+                if (!+C[g]) break e;
+                P > 0 && (P = 0);
+                break;
+            }
+            return P > 0 ? C.slice(0, P) + C.slice(A + 1) : C;
+          }
+          var c;
+          function f(C, M) {
+            var g = r(C, M);
+            if (!g) return C + "";
+            var P = g[0], A = g[1], z = A - (c = Math.max(-8, Math.min(8, Math.floor(A / 3))) * 3) + 1, O = P.length;
+            return z === O ? P : z > O ? P + new Array(z - O + 1).join("0") : z > 0 ? P.slice(0, z) + "." + P.slice(z) : "0." + new Array(1 - z).join("0") + r(C, Math.max(0, M + z - 1))[0];
+          }
+          function h(C, M) {
+            var g = r(C, M);
+            if (!g) return C + "";
+            var P = g[0], A = g[1];
+            return A < 0 ? "0." + new Array(-A).join("0") + P : P.length > A + 1 ? P.slice(0, A + 1) + "." + P.slice(A + 1) : P + new Array(A - P.length + 2).join("0");
+          }
+          var d = { "%": function(C, M) {
+            return (C * 100).toFixed(M);
+          }, b: function(C) {
+            return Math.round(C).toString(2);
+          }, c: function(C) {
+            return C + "";
+          }, d: t, e: function(C, M) {
+            return C.toExponential(M);
+          }, f: function(C, M) {
+            return C.toFixed(M);
+          }, g: function(C, M) {
+            return C.toPrecision(M);
+          }, o: function(C) {
+            return Math.round(C).toString(8);
+          }, p: function(C, M) {
+            return h(C * 100, M);
+          }, r: h, s: f, X: function(C) {
+            return Math.round(C).toString(16).toUpperCase();
+          }, x: function(C) {
+            return Math.round(C).toString(16);
+          } };
+          function v(C) {
+            return C;
+          }
+          var _ = Array.prototype.map, b = ["y", "z", "a", "f", "p", "n", "µ", "m", "", "k", "M", "G", "T", "P", "E", "Z", "Y"];
+          function p(C) {
+            var M = C.grouping === void 0 || C.thousands === void 0 ? v : i(_.call(C.grouping, Number), C.thousands + ""), g = C.currency === void 0 ? "" : C.currency[0] + "", P = C.currency === void 0 ? "" : C.currency[1] + "", A = C.decimal === void 0 ? "." : C.decimal + "", z = C.numerals === void 0 ? v : a(_.call(C.numerals, String)), O = C.percent === void 0 ? "%" : C.percent + "", U = C.minus === void 0 ? "-" : C.minus + "", G = C.nan === void 0 ? "NaN" : C.nan + "";
+            function Z(N) {
+              N = s(N);
+              var H = N.fill, re = N.align, oe = N.sign, _e = N.symbol, Ce = N.zero, Le = N.width, ge = N.comma, ie = N.precision, Se = N.trim, Ee = N.type;
+              Ee === "n" ? (ge = true, Ee = "g") : d[Ee] || (ie === void 0 && (ie = 12), Se = true, Ee = "g"), (Ce || H === "0" && re === "=") && (Ce = true, H = "0", re = "=");
+              var Ae = _e === "$" ? g : _e === "#" && /[boxX]/.test(Ee) ? "0" + Ee.toLowerCase() : "", Be = _e === "$" ? P : /[%p]/.test(Ee) ? O : "", Pe = d[Ee], me = /[defgprs%]/.test(Ee);
+              ie = ie === void 0 ? 6 : /[gprs]/.test(Ee) ? Math.max(1, Math.min(21, ie)) : Math.max(0, Math.min(20, ie));
+              function De(ce) {
+                var je = Ae, lt = Be, pt, Vt, ot;
+                if (Ee === "c") lt = Pe(ce) + lt, ce = "";
+                else {
+                  ce = +ce;
+                  var ut = ce < 0 || 1 / ce < 0;
+                  if (ce = isNaN(ce) ? G : Pe(Math.abs(ce), ie), Se && (ce = u(ce)), ut && +ce == 0 && oe !== "+" && (ut = false), je = (ut ? oe === "(" ? oe : U : oe === "-" || oe === "(" ? "" : oe) + je, lt = (Ee === "s" ? b[8 + c / 3] : "") + lt + (ut && oe === "(" ? ")" : ""), me) {
+                    for (pt = -1, Vt = ce.length; ++pt < Vt; ) if (ot = ce.charCodeAt(pt), 48 > ot || ot > 57) {
+                      lt = (ot === 46 ? A + ce.slice(pt + 1) : ce.slice(pt)) + lt, ce = ce.slice(0, pt);
+                      break;
+                    }
+                  }
+                }
+                ge && !Ce && (ce = M(ce, 1 / 0));
+                var Wt = je.length + ce.length + lt.length, Nt = Wt < Le ? new Array(Le - Wt + 1).join(H) : "";
+                switch (ge && Ce && (ce = M(Nt + ce, Nt.length ? Le - lt.length : 1 / 0), Nt = ""), re) {
+                  case "<":
+                    ce = je + ce + lt + Nt;
+                    break;
+                  case "=":
+                    ce = je + Nt + ce + lt;
+                    break;
+                  case "^":
+                    ce = Nt.slice(0, Wt = Nt.length >> 1) + je + ce + lt + Nt.slice(Wt);
+                    break;
+                  default:
+                    ce = Nt + je + ce + lt;
+                    break;
+                }
+                return z(ce);
+              }
+              return De.toString = function() {
+                return N + "";
+              }, De;
+            }
+            function j(N, H) {
+              var re = Z((N = s(N), N.type = "f", N)), oe = Math.max(-8, Math.min(8, Math.floor(n(H) / 3))) * 3, _e = Math.pow(10, -oe), Ce = b[8 + oe / 3];
+              return function(Le) {
+                return re(_e * Le) + Ce;
+              };
+            }
+            return { format: Z, formatPrefix: j };
+          }
+          var k;
+          E({ decimal: ".", thousands: ",", grouping: [3], currency: ["$", ""], minus: "-" });
+          function E(C) {
+            return k = p(C), e.format = k.format, e.formatPrefix = k.formatPrefix, k;
+          }
+          function T(C) {
+            return Math.max(0, -n(Math.abs(C)));
+          }
+          function L(C, M) {
+            return Math.max(0, Math.max(-8, Math.min(8, Math.floor(n(M) / 3))) * 3 - n(Math.abs(C)));
+          }
+          function x(C, M) {
+            return C = Math.abs(C), M = Math.abs(M) - C, Math.max(0, n(M) - n(C)) + 1;
+          }
+          e.FormatSpecifier = l, e.formatDefaultLocale = E, e.formatLocale = p, e.formatSpecifier = s, e.precisionFixed = T, e.precisionPrefix = L, e.precisionRound = x, Object.defineProperty(e, "__esModule", { value: true });
+        });
+      });
+      var Mee = ye((grr, See) => {
+        See.exports = function(e) {
+          for (var t = e.length, r, n = 0; n < t; n++) if (r = e.charCodeAt(n), (r < 9 || r > 13) && r !== 32 && r !== 133 && r !== 160 && r !== 5760 && r !== 6158 && (r < 8192 || r > 8205) && r !== 8232 && r !== 8233 && r !== 8239 && r !== 8287 && r !== 8288 && r !== 12288 && r !== 65279) return false;
+          return true;
+        };
+      });
+      var Eo = ye((mrr, Eee) => {
+        var Stt = Mee();
+        Eee.exports = function(e) {
+          var t = typeof e;
+          if (t === "string") {
+            var r = e;
+            if (e = +e, e === 0 && Stt(r)) return false;
+          } else if (t !== "number") return false;
+          return e - e < 1;
+        };
+      });
+      var fs = ye((yrr, kee) => {
+        kee.exports = { BADNUM: void 0, FP_SAFE: Number.MAX_VALUE * 1e-4, ONEMAXYEAR: 316224e5, ONEAVGYEAR: 315576e5, ONEMINYEAR: 31536e6, ONEMAXQUARTER: 79488e5, ONEAVGQUARTER: 78894e5, ONEMINQUARTER: 76896e5, ONEMAXMONTH: 26784e5, ONEAVGMONTH: 26298e5, ONEMINMONTH: 24192e5, ONEWEEK: 6048e5, ONEDAY: 864e5, ONEHOUR: 36e5, ONEMIN: 6e4, ONESEC: 1e3, ONEMILLI: 1, ONEMICROSEC: 1e-3, EPOCHJD: 24405875e-1, ALMOST_EQUAL: 1 - 1e-6, LOG_CLIP: 10, MINUS_SIGN: "−" };
+      });
+      var EO = ye((w6, Cee) => {
+        (function(e, t) {
+          typeof w6 == "object" && typeof Cee != "undefined" ? t(w6) : (e = typeof globalThis != "undefined" ? globalThis : e || self, t(e["base64-arraybuffer"] = {}));
+        })(w6, function(e) {
+          for (var t = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/", r = typeof Uint8Array == "undefined" ? [] : new Uint8Array(256), n = 0; n < t.length; n++) r[t.charCodeAt(n)] = n;
+          var i = function(o) {
+            var s = new Uint8Array(o), l, u = s.length, c = "";
+            for (l = 0; l < u; l += 3) c += t[s[l] >> 2], c += t[(s[l] & 3) << 4 | s[l + 1] >> 4], c += t[(s[l + 1] & 15) << 2 | s[l + 2] >> 6], c += t[s[l + 2] & 63];
+            return u % 3 === 2 ? c = c.substring(0, c.length - 1) + "=" : u % 3 === 1 && (c = c.substring(0, c.length - 2) + "=="), c;
+          }, a = function(o) {
+            var s = o.length * 0.75, l = o.length, u, c = 0, f, h, d, v;
+            o[o.length - 1] === "=" && (s--, o[o.length - 2] === "=" && s--);
+            var _ = new ArrayBuffer(s), b = new Uint8Array(_);
+            for (u = 0; u < l; u += 4) f = r[o.charCodeAt(u)], h = r[o.charCodeAt(u + 1)], d = r[o.charCodeAt(u + 2)], v = r[o.charCodeAt(u + 3)], b[c++] = f << 2 | h >> 4, b[c++] = (h & 15) << 4 | d >> 2, b[c++] = (d & 3) << 6 | v & 63;
+            return _;
+          };
+          e.decode = a, e.encode = i, Object.defineProperty(e, "__esModule", { value: true });
+        });
+      });
+      var Ty = ye((_rr, Lee) => {
+        Lee.exports = function(t) {
+          return window && window.process && window.process.versions ? Object.prototype.toString.call(t) === "[object Object]" : Object.prototype.toString.call(t) === "[object Object]" && Object.getPrototypeOf(t).hasOwnProperty("hasOwnProperty");
+        };
+      });
+      var vv = ye((xg) => {
+        var Mtt = EO().decode, Ett = Ty(), kO = Array.isArray, ktt = ArrayBuffer, Ctt = DataView;
+        function Pee(e) {
+          return ktt.isView(e) && !(e instanceof Ctt);
+        }
+        xg.isTypedArray = Pee;
+        function T6(e) {
+          return kO(e) || Pee(e);
+        }
+        xg.isArrayOrTypedArray = T6;
+        function Ltt(e) {
+          return !T6(e[0]);
+        }
+        xg.isArray1D = Ltt;
+        xg.ensureArray = function(e, t) {
+          return kO(e) || (e = []), e.length = t, e;
+        };
+        var Ld = { u1c: typeof Uint8ClampedArray == "undefined" ? void 0 : Uint8ClampedArray, i1: typeof Int8Array == "undefined" ? void 0 : Int8Array, u1: typeof Uint8Array == "undefined" ? void 0 : Uint8Array, i2: typeof Int16Array == "undefined" ? void 0 : Int16Array, u2: typeof Uint16Array == "undefined" ? void 0 : Uint16Array, i4: typeof Int32Array == "undefined" ? void 0 : Int32Array, u4: typeof Uint32Array == "undefined" ? void 0 : Uint32Array, f4: typeof Float32Array == "undefined" ? void 0 : Float32Array, f8: typeof Float64Array == "undefined" ? void 0 : Float64Array };
+        Ld.uint8c = Ld.u1c;
+        Ld.uint8 = Ld.u1;
+        Ld.int8 = Ld.i1;
+        Ld.uint16 = Ld.u2;
+        Ld.int16 = Ld.i2;
+        Ld.uint32 = Ld.u4;
+        Ld.int32 = Ld.i4;
+        Ld.float32 = Ld.f4;
+        Ld.float64 = Ld.f8;
+        function CO(e) {
+          return e.constructor === ArrayBuffer;
+        }
+        xg.isArrayBuffer = CO;
+        xg.decodeTypedArraySpec = function(e) {
+          var t = [], r = Ptt(e), n = r.dtype, i = Ld[n];
+          if (!i) throw new Error('Error in dtype: "' + n + '"');
+          var a = i.BYTES_PER_ELEMENT, o = r.bdata;
+          CO(o) || (o = Mtt(o));
+          var s = r.shape === void 0 ? [o.byteLength / a] : ("" + r.shape).split(",");
+          s.reverse();
+          var l = s.length, u, c, f = +s[0], h = a * f, d = 0;
+          if (l === 1) t = new i(o);
+          else if (l === 2) for (u = +s[1], c = 0; c < u; c++) t[c] = new i(o, d, f), d += h;
+          else if (l === 3) {
+            u = +s[1];
+            for (var v = +s[2], _ = 0; _ < v; _++) for (t[_] = [], c = 0; c < u; c++) t[_][c] = new i(o, d, f), d += h;
+          } else throw new Error("ndim: " + l + 'is not supported with the shape:"' + r.shape + '"');
+          return t.bdata = r.bdata, t.dtype = r.dtype, t.shape = s.reverse().join(","), e._inputArray = t, t;
+        };
+        xg.isTypedArraySpec = function(e) {
+          return Ett(e) && e.hasOwnProperty("dtype") && typeof e.dtype == "string" && e.hasOwnProperty("bdata") && (typeof e.bdata == "string" || CO(e.bdata)) && (e.shape === void 0 || e.hasOwnProperty("shape") && (typeof e.shape == "string" || typeof e.shape == "number"));
+        };
+        function Ptt(e) {
+          return { bdata: e.bdata, dtype: e.dtype, shape: e.shape };
+        }
+        xg.concat = function() {
+          var e = [], t = true, r = 0, n, i, a, o, s, l, u, c;
+          for (a = 0; a < arguments.length; a++) o = arguments[a], l = o.length, l && (i ? e.push(o) : (i = o, s = l), kO(o) ? n = false : (t = false, r ? n !== o.constructor && (n = false) : n = o.constructor), r += l);
+          if (!r) return [];
+          if (!e.length) return i;
+          if (t) return i.concat.apply(i, e);
+          if (n) {
+            for (u = new n(r), u.set(i), a = 0; a < e.length; a++) o = e[a], u.set(o, s), s += o.length;
+            return u;
+          }
+          for (u = new Array(r), c = 0; c < i.length; c++) u[c] = i[c];
+          for (a = 0; a < e.length; a++) {
+            for (o = e[a], c = 0; c < o.length; c++) u[s + c] = o[c];
+            s += c;
+          }
+          return u;
+        };
+        xg.maxRowLength = function(e) {
+          return Iee(e, Math.max, 0);
+        };
+        xg.minRowLength = function(e) {
+          return Iee(e, Math.min, 1 / 0);
+        };
+        function Iee(e, t, r) {
+          if (T6(e)) if (T6(e[0])) {
+            for (var n = r, i = 0; i < e.length; i++) n = t(n, e[i].length);
+            return n;
+          } else return e.length;
+          return 0;
+        }
+      });
+      var FS = ye((brr, Oee) => {
+        var Ree = Eo(), PO = vv().isArrayOrTypedArray;
+        Oee.exports = function(t, r) {
+          if (Ree(r)) r = String(r);
+          else if (typeof r != "string" || r.slice(-4) === "[-1]") throw "bad property string";
+          var n = r.split("."), i, a, o, s;
+          for (s = 0; s < n.length; s++) if (String(n[s]).slice(0, 2) === "__") throw "bad property string";
+          for (s = 0; s < n.length; ) {
+            if (i = String(n[s]).match(/^([^\[\]]*)((\[\-?[0-9]*\])+)$/), i) {
+              if (i[1]) n[s] = i[1];
+              else if (s === 0) n.splice(0, 1);
+              else throw "bad property string";
+              for (a = i[2].slice(1, -1).split("]["), o = 0; o < a.length; o++) s++, n.splice(s, 0, Number(a[o]));
+            }
+            s++;
+          }
+          return typeof t != "object" ? Ftt(t, r, n) : { set: Fee(t, n, r), get: Dee(t, n), astr: r, parts: n, obj: t };
+        };
+        function Dee(e, t) {
+          return function(r) {
+            var n = e, i, a, o, s, l;
+            for (s = 0; s < t.length - 1; s++) {
+              if (i = t[s], i === -1) {
+                for (a = true, o = [], l = 0; l < n.length; l++) o[l] = Dee(n[l], t.slice(s + 1))(r), o[l] !== o[0] && (a = false);
+                return a ? o[0] : o;
+              }
+              if (typeof i == "number" && !PO(n) || (n = n[i], typeof n != "object" || n === null)) return;
+            }
+            if (!(typeof n != "object" || n === null) && (o = n[t[s]], !(!r && o === null))) return o;
+          };
+        }
+        var Itt = /(^|\.)args\[/;
+        function LO(e, t) {
+          return e === void 0 || e === null && !t.match(Itt);
+        }
+        function Fee(e, t, r) {
+          return function(n) {
+            var i = e, a = "", s = LO(n, r), l, u;
+            for (u = 0; u < t.length - 1; u++) {
+              if (l = t[u], typeof l == "number" && !PO(i)) throw "array index but container is not an array";
+              if (l === -1) {
+                if (s = !Dtt(i, t.slice(u + 1), n, r), s) break;
+                return;
+              }
+              if (!zee(i, l, t[u + 1], s)) break;
+              if (i = i[l], typeof i != "object" || i === null) throw "container is not an object";
+              a = Rtt(a, l);
+            }
+            if (s) {
+              if (u === t.length - 1 && (delete i[t[u]], Array.isArray(i) && +t[u] === i.length - 1)) for (; i.length && i[i.length - 1] === void 0; ) i.pop();
+            } else i[t[u]] = n;
+          };
+        }
+        function Rtt(e, t) {
+          var r = t;
+          return Ree(t) ? r = "[" + t + "]" : e && (r = "." + t), e + r;
+        }
+        function Dtt(e, t, r, n) {
+          var i = PO(r), a = true, o = r, s = n.replace("-1", 0), l = i ? false : LO(r, s), u = t[0], c;
+          for (c = 0; c < e.length; c++) s = n.replace("-1", c), i && (o = r[c % r.length], l = LO(o, s)), l && (a = false), zee(e, c, u, l) && Fee(e[c], t, n.replace("-1", c))(o);
+          return a;
+        }
+        function zee(e, t, r, n) {
+          if (e[t] === void 0) {
+            if (n) return false;
+            typeof r == "number" ? e[t] = [] : e[t] = {};
+          }
+          return true;
+        }
+        function Ftt(e, t, r) {
+          return { set: function() {
+            throw "bad container";
+          }, get: function() {
+          }, astr: t, parts: r, obj: e };
+        }
+      });
+      var Uee = ye((wrr, Nee) => {
+        var h3 = FS(), ztt = /^\w*$/, Ott = 0, qee = 1, A6 = 2, Bee = 3, gb = 4;
+        Nee.exports = function(t, r, n, i) {
+          n = n || "name", i = i || "value";
+          var a, o, s, l = {};
+          r && r.length ? (s = h3(t, r), o = s.get()) : o = t, r = r || "";
+          var u = {};
+          if (o) for (a = 0; a < o.length; a++) u[o[a][n]] = a;
+          var c = ztt.test(i), f = { set: function(h, d) {
+            var v = d === null ? gb : Ott;
+            if (!o) {
+              if (!s || v === gb) return;
+              o = [], s.set(o);
+            }
+            var _ = u[h];
+            if (_ === void 0) {
+              if (v === gb) return;
+              v = v | Bee, _ = o.length, u[h] = _;
+            } else d !== (c ? o[_][i] : h3(o[_], i).get()) && (v = v | A6);
+            var b = o[_] = o[_] || {};
+            return b[n] = h, c ? b[i] = d : h3(b, i).set(d), d !== null && (v = v & -5), l[_] = l[_] | v, f;
+          }, get: function(h) {
+            if (o) {
+              var d = u[h];
+              if (d !== void 0) return c ? o[d][i] : h3(o[d], i).get();
+            }
+          }, rename: function(h, d) {
+            var v = u[h];
+            return v === void 0 || (l[v] = l[v] | qee, u[d] = v, delete u[h], o[v][n] = d), f;
+          }, remove: function(h) {
+            var d = u[h];
+            if (d === void 0) return f;
+            var v = o[d];
+            if (Object.keys(v).length > 2) return l[d] = l[d] | A6, f.set(h, null);
+            if (c) {
+              for (a = d; a < o.length; a++) l[a] = l[a] | Bee;
+              for (a = d; a < o.length; a++) u[o[a][n]]--;
+              o.splice(d, 1), delete u[h];
+            } else h3(v, i).set(null), l[d] = l[d] | A6 | gb;
+            return f;
+          }, constructUpdate: function() {
+            for (var h, d, v = {}, _ = Object.keys(l), b = 0; b < _.length; b++) d = _[b], h = r + "[" + d + "]", o[d] ? (l[d] & qee && (v[h + "." + n] = o[d][n]), l[d] & A6 && (c ? v[h + "." + i] = l[d] & gb ? null : o[d][i] : v[h + "." + i] = l[d] & gb ? null : h3(o[d], i).get())) : v[h] = null;
+            return v;
+          } };
+          return f;
+        };
+      });
+      var Gee = ye((Trr, Vee) => {
+        var qtt = /^(.*)(\.[^\.\[\]]+|\[\d\])$/, Btt = /^[^\.\[\]]+$/;
+        Vee.exports = function(e, t) {
+          for (; t; ) {
+            var r = e.match(qtt);
+            if (r) e = r[1];
+            else if (e.match(Btt)) e = "";
+            else throw new Error("bad relativeAttr call:" + [e, t]);
+            if (t.charAt(0) === "^") t = t.slice(1);
+            else break;
+          }
+          return e && t.charAt(0) !== "[" ? e + "." + t : e + t;
+        };
+      });
+      var S6 = ye((Arr, Hee) => {
+        var Ntt = Eo();
+        Hee.exports = function(t, r) {
+          if (t > 0) return Math.log(t) / Math.LN10;
+          var n = Math.log(Math.min(r[0], r[1])) / Math.LN10;
+          return Ntt(n) || (n = Math.log(Math.max(r[0], r[1])) / Math.LN10 - 6), n;
+        };
+      });
+      var Xee = ye((Srr, Wee) => {
+        var jee = vv().isArrayOrTypedArray, zS = Ty();
+        Wee.exports = function e(t, r) {
+          for (var n in r) {
+            var i = r[n], a = t[n];
+            if (a !== i) if (n.charAt(0) === "_" || typeof i == "function") {
+              if (n in t) continue;
+              t[n] = i;
+            } else if (jee(i) && jee(a) && zS(i[0])) {
+              if (n === "customdata" || n === "ids") continue;
+              for (var o = Math.min(i.length, a.length), s = 0; s < o; s++) a[s] !== i[s] && zS(i[s]) && zS(a[s]) && e(a[s], i[s]);
+            } else zS(i) && zS(a) && (e(a, i), Object.keys(a).length || delete t[n]);
+          }
+        };
+      });
+      var d3 = ye((Mrr, Zee) => {
+        function Utt(e, t) {
+          var r = e % t;
+          return r < 0 ? r + t : r;
+        }
+        function Vtt(e, t) {
+          return Math.abs(e) > t / 2 ? e - Math.round(e / t) * t : e;
+        }
+        Zee.exports = { mod: Utt, modHalf: Vtt };
+      });
+      var fd = ye((Err, M6) => {
+        (function(e) {
+          var t = /^\s+/, r = /\s+$/, n = 0, i = e.round, a = e.min, o = e.max, s = e.random;
+          function l(me, De) {
+            if (me = me || "", De = De || {}, me instanceof l) return me;
+            if (!(this instanceof l)) return new l(me, De);
+            var ce = u(me);
+            this._originalInput = me, this._r = ce.r, this._g = ce.g, this._b = ce.b, this._a = ce.a, this._roundA = i(100 * this._a) / 100, this._format = De.format || ce.format, this._gradientType = De.gradientType, this._r < 1 && (this._r = i(this._r)), this._g < 1 && (this._g = i(this._g)), this._b < 1 && (this._b = i(this._b)), this._ok = ce.ok, this._tc_id = n++;
+          }
+          l.prototype = { isDark: function() {
+            return this.getBrightness() < 128;
+          }, isLight: function() {
+            return !this.isDark();
+          }, isValid: function() {
+            return this._ok;
+          }, getOriginalInput: function() {
+            return this._originalInput;
+          }, getFormat: function() {
+            return this._format;
+          }, getAlpha: function() {
+            return this._a;
+          }, getBrightness: function() {
+            var me = this.toRgb();
+            return (me.r * 299 + me.g * 587 + me.b * 114) / 1e3;
+          }, getLuminance: function() {
+            var me = this.toRgb(), De, ce, je, lt, pt, Vt;
+            return De = me.r / 255, ce = me.g / 255, je = me.b / 255, De <= 0.03928 ? lt = De / 12.92 : lt = e.pow((De + 0.055) / 1.055, 2.4), ce <= 0.03928 ? pt = ce / 12.92 : pt = e.pow((ce + 0.055) / 1.055, 2.4), je <= 0.03928 ? Vt = je / 12.92 : Vt = e.pow((je + 0.055) / 1.055, 2.4), 0.2126 * lt + 0.7152 * pt + 0.0722 * Vt;
+          }, setAlpha: function(me) {
+            return this._a = N(me), this._roundA = i(100 * this._a) / 100, this;
+          }, toHsv: function() {
+            var me = d(this._r, this._g, this._b);
+            return { h: me.h * 360, s: me.s, v: me.v, a: this._a };
+          }, toHsvString: function() {
+            var me = d(this._r, this._g, this._b), De = i(me.h * 360), ce = i(me.s * 100), je = i(me.v * 100);
+            return this._a == 1 ? "hsv(" + De + ", " + ce + "%, " + je + "%)" : "hsva(" + De + ", " + ce + "%, " + je + "%, " + this._roundA + ")";
+          }, toHsl: function() {
+            var me = f(this._r, this._g, this._b);
+            return { h: me.h * 360, s: me.s, l: me.l, a: this._a };
+          }, toHslString: function() {
+            var me = f(this._r, this._g, this._b), De = i(me.h * 360), ce = i(me.s * 100), je = i(me.l * 100);
+            return this._a == 1 ? "hsl(" + De + ", " + ce + "%, " + je + "%)" : "hsla(" + De + ", " + ce + "%, " + je + "%, " + this._roundA + ")";
+          }, toHex: function(me) {
+            return _(this._r, this._g, this._b, me);
+          }, toHexString: function(me) {
+            return "#" + this.toHex(me);
+          }, toHex8: function(me) {
+            return b(this._r, this._g, this._b, this._a, me);
+          }, toHex8String: function(me) {
+            return "#" + this.toHex8(me);
+          }, toRgb: function() {
+            return { r: i(this._r), g: i(this._g), b: i(this._b), a: this._a };
+          }, toRgbString: function() {
+            return this._a == 1 ? "rgb(" + i(this._r) + ", " + i(this._g) + ", " + i(this._b) + ")" : "rgba(" + i(this._r) + ", " + i(this._g) + ", " + i(this._b) + ", " + this._roundA + ")";
+          }, toPercentageRgb: function() {
+            return { r: i(H(this._r, 255) * 100) + "%", g: i(H(this._g, 255) * 100) + "%", b: i(H(this._b, 255) * 100) + "%", a: this._a };
+          }, toPercentageRgbString: function() {
+            return this._a == 1 ? "rgb(" + i(H(this._r, 255) * 100) + "%, " + i(H(this._g, 255) * 100) + "%, " + i(H(this._b, 255) * 100) + "%)" : "rgba(" + i(H(this._r, 255) * 100) + "%, " + i(H(this._g, 255) * 100) + "%, " + i(H(this._b, 255) * 100) + "%, " + this._roundA + ")";
+          }, toName: function() {
+            return this._a === 0 ? "transparent" : this._a < 1 ? false : Z[_(this._r, this._g, this._b, true)] || false;
+          }, toFilter: function(me) {
+            var De = "#" + p(this._r, this._g, this._b, this._a), ce = De, je = this._gradientType ? "GradientType = 1, " : "";
+            if (me) {
+              var lt = l(me);
+              ce = "#" + p(lt._r, lt._g, lt._b, lt._a);
+            }
+            return "progid:DXImageTransform.Microsoft.gradient(" + je + "startColorstr=" + De + ",endColorstr=" + ce + ")";
+          }, toString: function(me) {
+            var De = !!me;
+            me = me || this._format;
+            var ce = false, je = this._a < 1 && this._a >= 0, lt = !De && je && (me === "hex" || me === "hex6" || me === "hex3" || me === "hex4" || me === "hex8" || me === "name");
+            return lt ? me === "name" && this._a === 0 ? this.toName() : this.toRgbString() : (me === "rgb" && (ce = this.toRgbString()), me === "prgb" && (ce = this.toPercentageRgbString()), (me === "hex" || me === "hex6") && (ce = this.toHexString()), me === "hex3" && (ce = this.toHexString(true)), me === "hex4" && (ce = this.toHex8String(true)), me === "hex8" && (ce = this.toHex8String()), me === "name" && (ce = this.toName()), me === "hsl" && (ce = this.toHslString()), me === "hsv" && (ce = this.toHsvString()), ce || this.toHexString());
+          }, clone: function() {
+            return l(this.toString());
+          }, _applyModification: function(me, De) {
+            var ce = me.apply(null, [this].concat([].slice.call(De)));
+            return this._r = ce._r, this._g = ce._g, this._b = ce._b, this.setAlpha(ce._a), this;
+          }, lighten: function() {
+            return this._applyModification(L, arguments);
+          }, brighten: function() {
+            return this._applyModification(x, arguments);
+          }, darken: function() {
+            return this._applyModification(C, arguments);
+          }, desaturate: function() {
+            return this._applyModification(k, arguments);
+          }, saturate: function() {
+            return this._applyModification(E, arguments);
+          }, greyscale: function() {
+            return this._applyModification(T, arguments);
+          }, spin: function() {
+            return this._applyModification(M, arguments);
+          }, _applyCombination: function(me, De) {
+            return me.apply(null, [this].concat([].slice.call(De)));
+          }, analogous: function() {
+            return this._applyCombination(O, arguments);
+          }, complement: function() {
+            return this._applyCombination(g, arguments);
+          }, monochromatic: function() {
+            return this._applyCombination(U, arguments);
+          }, splitcomplement: function() {
+            return this._applyCombination(z, arguments);
+          }, triad: function() {
+            return this._applyCombination(P, arguments);
+          }, tetrad: function() {
+            return this._applyCombination(A, arguments);
+          } }, l.fromRatio = function(me, De) {
+            if (typeof me == "object") {
+              var ce = {};
+              for (var je in me) me.hasOwnProperty(je) && (je === "a" ? ce[je] = me[je] : ce[je] = ge(me[je]));
+              me = ce;
+            }
+            return l(me, De);
+          };
+          function u(me) {
+            var De = { r: 0, g: 0, b: 0 }, ce = 1, je = null, lt = null, pt = null, Vt = false, ot = false;
+            return typeof me == "string" && (me = Be(me)), typeof me == "object" && (Ae(me.r) && Ae(me.g) && Ae(me.b) ? (De = c(me.r, me.g, me.b), Vt = true, ot = String(me.r).substr(-1) === "%" ? "prgb" : "rgb") : Ae(me.h) && Ae(me.s) && Ae(me.v) ? (je = ge(me.s), lt = ge(me.v), De = v(me.h, je, lt), Vt = true, ot = "hsv") : Ae(me.h) && Ae(me.s) && Ae(me.l) && (je = ge(me.s), pt = ge(me.l), De = h(me.h, je, pt), Vt = true, ot = "hsl"), me.hasOwnProperty("a") && (ce = me.a)), ce = N(ce), { ok: Vt, format: me.format || ot, r: a(255, o(De.r, 0)), g: a(255, o(De.g, 0)), b: a(255, o(De.b, 0)), a: ce };
+          }
+          function c(me, De, ce) {
+            return { r: H(me, 255) * 255, g: H(De, 255) * 255, b: H(ce, 255) * 255 };
+          }
+          function f(me, De, ce) {
+            me = H(me, 255), De = H(De, 255), ce = H(ce, 255);
+            var je = o(me, De, ce), lt = a(me, De, ce), pt, Vt, ot = (je + lt) / 2;
+            if (je == lt) pt = Vt = 0;
+            else {
+              var ut = je - lt;
+              switch (Vt = ot > 0.5 ? ut / (2 - je - lt) : ut / (je + lt), je) {
+                case me:
+                  pt = (De - ce) / ut + (De < ce ? 6 : 0);
+                  break;
+                case De:
+                  pt = (ce - me) / ut + 2;
+                  break;
+                case ce:
+                  pt = (me - De) / ut + 4;
+                  break;
+              }
+              pt /= 6;
+            }
+            return { h: pt, s: Vt, l: ot };
+          }
+          function h(me, De, ce) {
+            var je, lt, pt;
+            me = H(me, 360), De = H(De, 100), ce = H(ce, 100);
+            function Vt(Wt, Nt, $t) {
+              return $t < 0 && ($t += 1), $t > 1 && ($t -= 1), $t < 1 / 6 ? Wt + (Nt - Wt) * 6 * $t : $t < 1 / 2 ? Nt : $t < 2 / 3 ? Wt + (Nt - Wt) * (2 / 3 - $t) * 6 : Wt;
+            }
+            if (De === 0) je = lt = pt = ce;
+            else {
+              var ot = ce < 0.5 ? ce * (1 + De) : ce + De - ce * De, ut = 2 * ce - ot;
+              je = Vt(ut, ot, me + 1 / 3), lt = Vt(ut, ot, me), pt = Vt(ut, ot, me - 1 / 3);
+            }
+            return { r: je * 255, g: lt * 255, b: pt * 255 };
+          }
+          function d(me, De, ce) {
+            me = H(me, 255), De = H(De, 255), ce = H(ce, 255);
+            var je = o(me, De, ce), lt = a(me, De, ce), pt, Vt, ot = je, ut = je - lt;
+            if (Vt = je === 0 ? 0 : ut / je, je == lt) pt = 0;
+            else {
+              switch (je) {
+                case me:
+                  pt = (De - ce) / ut + (De < ce ? 6 : 0);
+                  break;
+                case De:
+                  pt = (ce - me) / ut + 2;
+                  break;
+                case ce:
+                  pt = (me - De) / ut + 4;
+                  break;
+              }
+              pt /= 6;
+            }
+            return { h: pt, s: Vt, v: ot };
+          }
+          function v(me, De, ce) {
+            me = H(me, 360) * 6, De = H(De, 100), ce = H(ce, 100);
+            var je = e.floor(me), lt = me - je, pt = ce * (1 - De), Vt = ce * (1 - lt * De), ot = ce * (1 - (1 - lt) * De), ut = je % 6, Wt = [ce, Vt, pt, pt, ot, ce][ut], Nt = [ot, ce, ce, Vt, pt, pt][ut], $t = [pt, pt, ot, ce, ce, Vt][ut];
+            return { r: Wt * 255, g: Nt * 255, b: $t * 255 };
+          }
+          function _(me, De, ce, je) {
+            var lt = [Le(i(me).toString(16)), Le(i(De).toString(16)), Le(i(ce).toString(16))];
+            return je && lt[0].charAt(0) == lt[0].charAt(1) && lt[1].charAt(0) == lt[1].charAt(1) && lt[2].charAt(0) == lt[2].charAt(1) ? lt[0].charAt(0) + lt[1].charAt(0) + lt[2].charAt(0) : lt.join("");
+          }
+          function b(me, De, ce, je, lt) {
+            var pt = [Le(i(me).toString(16)), Le(i(De).toString(16)), Le(i(ce).toString(16)), Le(ie(je))];
+            return lt && pt[0].charAt(0) == pt[0].charAt(1) && pt[1].charAt(0) == pt[1].charAt(1) && pt[2].charAt(0) == pt[2].charAt(1) && pt[3].charAt(0) == pt[3].charAt(1) ? pt[0].charAt(0) + pt[1].charAt(0) + pt[2].charAt(0) + pt[3].charAt(0) : pt.join("");
+          }
+          function p(me, De, ce, je) {
+            var lt = [Le(ie(je)), Le(i(me).toString(16)), Le(i(De).toString(16)), Le(i(ce).toString(16))];
+            return lt.join("");
+          }
+          l.equals = function(me, De) {
+            return !me || !De ? false : l(me).toRgbString() == l(De).toRgbString();
+          }, l.random = function() {
+            return l.fromRatio({ r: s(), g: s(), b: s() });
+          };
+          function k(me, De) {
+            De = De === 0 ? 0 : De || 10;
+            var ce = l(me).toHsl();
+            return ce.s -= De / 100, ce.s = re(ce.s), l(ce);
+          }
+          function E(me, De) {
+            De = De === 0 ? 0 : De || 10;
+            var ce = l(me).toHsl();
+            return ce.s += De / 100, ce.s = re(ce.s), l(ce);
+          }
+          function T(me) {
+            return l(me).desaturate(100);
+          }
+          function L(me, De) {
+            De = De === 0 ? 0 : De || 10;
+            var ce = l(me).toHsl();
+            return ce.l += De / 100, ce.l = re(ce.l), l(ce);
+          }
+          function x(me, De) {
+            De = De === 0 ? 0 : De || 10;
+            var ce = l(me).toRgb();
+            return ce.r = o(0, a(255, ce.r - i(255 * -(De / 100)))), ce.g = o(0, a(255, ce.g - i(255 * -(De / 100)))), ce.b = o(0, a(255, ce.b - i(255 * -(De / 100)))), l(ce);
+          }
+          function C(me, De) {
+            De = De === 0 ? 0 : De || 10;
+            var ce = l(me).toHsl();
+            return ce.l -= De / 100, ce.l = re(ce.l), l(ce);
+          }
+          function M(me, De) {
+            var ce = l(me).toHsl(), je = (ce.h + De) % 360;
+            return ce.h = je < 0 ? 360 + je : je, l(ce);
+          }
+          function g(me) {
+            var De = l(me).toHsl();
+            return De.h = (De.h + 180) % 360, l(De);
+          }
+          function P(me) {
+            var De = l(me).toHsl(), ce = De.h;
+            return [l(me), l({ h: (ce + 120) % 360, s: De.s, l: De.l }), l({ h: (ce + 240) % 360, s: De.s, l: De.l })];
+          }
+          function A(me) {
+            var De = l(me).toHsl(), ce = De.h;
+            return [l(me), l({ h: (ce + 90) % 360, s: De.s, l: De.l }), l({ h: (ce + 180) % 360, s: De.s, l: De.l }), l({ h: (ce + 270) % 360, s: De.s, l: De.l })];
+          }
+          function z(me) {
+            var De = l(me).toHsl(), ce = De.h;
+            return [l(me), l({ h: (ce + 72) % 360, s: De.s, l: De.l }), l({ h: (ce + 216) % 360, s: De.s, l: De.l })];
+          }
+          function O(me, De, ce) {
+            De = De || 6, ce = ce || 30;
+            var je = l(me).toHsl(), lt = 360 / ce, pt = [l(me)];
+            for (je.h = (je.h - (lt * De >> 1) + 720) % 360; --De; ) je.h = (je.h + lt) % 360, pt.push(l(je));
+            return pt;
+          }
+          function U(me, De) {
+            De = De || 6;
+            for (var ce = l(me).toHsv(), je = ce.h, lt = ce.s, pt = ce.v, Vt = [], ot = 1 / De; De--; ) Vt.push(l({ h: je, s: lt, v: pt })), pt = (pt + ot) % 1;
+            return Vt;
+          }
+          l.mix = function(me, De, ce) {
+            ce = ce === 0 ? 0 : ce || 50;
+            var je = l(me).toRgb(), lt = l(De).toRgb(), pt = ce / 100, Vt = { r: (lt.r - je.r) * pt + je.r, g: (lt.g - je.g) * pt + je.g, b: (lt.b - je.b) * pt + je.b, a: (lt.a - je.a) * pt + je.a };
+            return l(Vt);
+          }, l.readability = function(me, De) {
+            var ce = l(me), je = l(De);
+            return (e.max(ce.getLuminance(), je.getLuminance()) + 0.05) / (e.min(ce.getLuminance(), je.getLuminance()) + 0.05);
+          }, l.isReadable = function(me, De, ce) {
+            var je = l.readability(me, De), lt, pt;
+            switch (pt = false, lt = Pe(ce), lt.level + lt.size) {
+              case "AAsmall":
+              case "AAAlarge":
+                pt = je >= 4.5;
+                break;
+              case "AAlarge":
+                pt = je >= 3;
+                break;
+              case "AAAsmall":
+                pt = je >= 7;
+                break;
+            }
+            return pt;
+          }, l.mostReadable = function(me, De, ce) {
+            var je = null, lt = 0, pt, Vt, ot, ut;
+            ce = ce || {}, Vt = ce.includeFallbackColors, ot = ce.level, ut = ce.size;
+            for (var Wt = 0; Wt < De.length; Wt++) pt = l.readability(me, De[Wt]), pt > lt && (lt = pt, je = l(De[Wt]));
+            return l.isReadable(me, je, { level: ot, size: ut }) || !Vt ? je : (ce.includeFallbackColors = false, l.mostReadable(me, ["#fff", "#000"], ce));
+          };
+          var G = l.names = { aliceblue: "f0f8ff", antiquewhite: "faebd7", aqua: "0ff", aquamarine: "7fffd4", azure: "f0ffff", beige: "f5f5dc", bisque: "ffe4c4", black: "000", blanchedalmond: "ffebcd", blue: "00f", blueviolet: "8a2be2", brown: "a52a2a", burlywood: "deb887", burntsienna: "ea7e5d", cadetblue: "5f9ea0", chartreuse: "7fff00", chocolate: "d2691e", coral: "ff7f50", cornflowerblue: "6495ed", cornsilk: "fff8dc", crimson: "dc143c", cyan: "0ff", darkblue: "00008b", darkcyan: "008b8b", darkgoldenrod: "b8860b", darkgray: "a9a9a9", darkgreen: "006400", darkgrey: "a9a9a9", darkkhaki: "bdb76b", darkmagenta: "8b008b", darkolivegreen: "556b2f", darkorange: "ff8c00", darkorchid: "9932cc", darkred: "8b0000", darksalmon: "e9967a", darkseagreen: "8fbc8f", darkslateblue: "483d8b", darkslategray: "2f4f4f", darkslategrey: "2f4f4f", darkturquoise: "00ced1", darkviolet: "9400d3", deeppink: "ff1493", deepskyblue: "00bfff", dimgray: "696969", dimgrey: "696969", dodgerblue: "1e90ff", firebrick: "b22222", floralwhite: "fffaf0", forestgreen: "228b22", fuchsia: "f0f", gainsboro: "dcdcdc", ghostwhite: "f8f8ff", gold: "ffd700", goldenrod: "daa520", gray: "808080", green: "008000", greenyellow: "adff2f", grey: "808080", honeydew: "f0fff0", hotpink: "ff69b4", indianred: "cd5c5c", indigo: "4b0082", ivory: "fffff0", khaki: "f0e68c", lavender: "e6e6fa", lavenderblush: "fff0f5", lawngreen: "7cfc00", lemonchiffon: "fffacd", lightblue: "add8e6", lightcoral: "f08080", lightcyan: "e0ffff", lightgoldenrodyellow: "fafad2", lightgray: "d3d3d3", lightgreen: "90ee90", lightgrey: "d3d3d3", lightpink: "ffb6c1", lightsalmon: "ffa07a", lightseagreen: "20b2aa", lightskyblue: "87cefa", lightslategray: "789", lightslategrey: "789", lightsteelblue: "b0c4de", lightyellow: "ffffe0", lime: "0f0", limegreen: "32cd32", linen: "faf0e6", magenta: "f0f", maroon: "800000", mediumaquamarine: "66cdaa", mediumblue: "0000cd", mediumorchid: "ba55d3", mediumpurple: "9370db", mediumseagreen: "3cb371", mediumslateblue: "7b68ee", mediumspringgreen: "00fa9a", mediumturquoise: "48d1cc", mediumvioletred: "c71585", midnightblue: "191970", mintcream: "f5fffa", mistyrose: "ffe4e1", moccasin: "ffe4b5", navajowhite: "ffdead", navy: "000080", oldlace: "fdf5e6", olive: "808000", olivedrab: "6b8e23", orange: "ffa500", orangered: "ff4500", orchid: "da70d6", palegoldenrod: "eee8aa", palegreen: "98fb98", paleturquoise: "afeeee", palevioletred: "db7093", papayawhip: "ffefd5", peachpuff: "ffdab9", peru: "cd853f", pink: "ffc0cb", plum: "dda0dd", powderblue: "b0e0e6", purple: "800080", rebeccapurple: "663399", red: "f00", rosybrown: "bc8f8f", royalblue: "4169e1", saddlebrown: "8b4513", salmon: "fa8072", sandybrown: "f4a460", seagreen: "2e8b57", seashell: "fff5ee", sienna: "a0522d", silver: "c0c0c0", skyblue: "87ceeb", slateblue: "6a5acd", slategray: "708090", slategrey: "708090", snow: "fffafa", springgreen: "00ff7f", steelblue: "4682b4", tan: "d2b48c", teal: "008080", thistle: "d8bfd8", tomato: "ff6347", turquoise: "40e0d0", violet: "ee82ee", wheat: "f5deb3", white: "fff", whitesmoke: "f5f5f5", yellow: "ff0", yellowgreen: "9acd32" }, Z = l.hexNames = j(G);
+          function j(me) {
+            var De = {};
+            for (var ce in me) me.hasOwnProperty(ce) && (De[me[ce]] = ce);
+            return De;
+          }
+          function N(me) {
+            return me = parseFloat(me), (isNaN(me) || me < 0 || me > 1) && (me = 1), me;
+          }
+          function H(me, De) {
+            _e(me) && (me = "100%");
+            var ce = Ce(me);
+            return me = a(De, o(0, parseFloat(me))), ce && (me = parseInt(me * De, 10) / 100), e.abs(me - De) < 1e-6 ? 1 : me % De / parseFloat(De);
+          }
+          function re(me) {
+            return a(1, o(0, me));
+          }
+          function oe(me) {
+            return parseInt(me, 16);
+          }
+          function _e(me) {
+            return typeof me == "string" && me.indexOf(".") != -1 && parseFloat(me) === 1;
+          }
+          function Ce(me) {
+            return typeof me == "string" && me.indexOf("%") != -1;
+          }
+          function Le(me) {
+            return me.length == 1 ? "0" + me : "" + me;
+          }
+          function ge(me) {
+            return me <= 1 && (me = me * 100 + "%"), me;
+          }
+          function ie(me) {
+            return e.round(parseFloat(me) * 255).toString(16);
+          }
+          function Se(me) {
+            return oe(me) / 255;
+          }
+          var Ee = function() {
+            var me = "[-\\+]?\\d+%?", De = "[-\\+]?\\d*\\.\\d+%?", ce = "(?:" + De + ")|(?:" + me + ")", je = "[\\s|\\(]+(" + ce + ")[,|\\s]+(" + ce + ")[,|\\s]+(" + ce + ")\\s*\\)?", lt = "[\\s|\\(]+(" + ce + ")[,|\\s]+(" + ce + ")[,|\\s]+(" + ce + ")[,|\\s]+(" + ce + ")\\s*\\)?";
+            return { CSS_UNIT: new RegExp(ce), rgb: new RegExp("rgb" + je), rgba: new RegExp("rgba" + lt), hsl: new RegExp("hsl" + je), hsla: new RegExp("hsla" + lt), hsv: new RegExp("hsv" + je), hsva: new RegExp("hsva" + lt), hex3: /^#?([0-9a-fA-F]{1})([0-9a-fA-F]{1})([0-9a-fA-F]{1})$/, hex6: /^#?([0-9a-fA-F]{2})([0-9a-fA-F]{2})([0-9a-fA-F]{2})$/, hex4: /^#?([0-9a-fA-F]{1})([0-9a-fA-F]{1})([0-9a-fA-F]{1})([0-9a-fA-F]{1})$/, hex8: /^#?([0-9a-fA-F]{2})([0-9a-fA-F]{2})([0-9a-fA-F]{2})([0-9a-fA-F]{2})$/ };
+          }();
+          function Ae(me) {
+            return !!Ee.CSS_UNIT.exec(me);
+          }
+          function Be(me) {
+            me = me.replace(t, "").replace(r, "").toLowerCase();
+            var De = false;
+            if (G[me]) me = G[me], De = true;
+            else if (me == "transparent") return { r: 0, g: 0, b: 0, a: 0, format: "name" };
+            var ce;
+            return (ce = Ee.rgb.exec(me)) ? { r: ce[1], g: ce[2], b: ce[3] } : (ce = Ee.rgba.exec(me)) ? { r: ce[1], g: ce[2], b: ce[3], a: ce[4] } : (ce = Ee.hsl.exec(me)) ? { h: ce[1], s: ce[2], l: ce[3] } : (ce = Ee.hsla.exec(me)) ? { h: ce[1], s: ce[2], l: ce[3], a: ce[4] } : (ce = Ee.hsv.exec(me)) ? { h: ce[1], s: ce[2], v: ce[3] } : (ce = Ee.hsva.exec(me)) ? { h: ce[1], s: ce[2], v: ce[3], a: ce[4] } : (ce = Ee.hex8.exec(me)) ? { r: oe(ce[1]), g: oe(ce[2]), b: oe(ce[3]), a: Se(ce[4]), format: De ? "name" : "hex8" } : (ce = Ee.hex6.exec(me)) ? { r: oe(ce[1]), g: oe(ce[2]), b: oe(ce[3]), format: De ? "name" : "hex" } : (ce = Ee.hex4.exec(me)) ? { r: oe(ce[1] + "" + ce[1]), g: oe(ce[2] + "" + ce[2]), b: oe(ce[3] + "" + ce[3]), a: Se(ce[4] + "" + ce[4]), format: De ? "name" : "hex8" } : (ce = Ee.hex3.exec(me)) ? { r: oe(ce[1] + "" + ce[1]), g: oe(ce[2] + "" + ce[2]), b: oe(ce[3] + "" + ce[3]), format: De ? "name" : "hex" } : false;
+          }
+          function Pe(me) {
+            var De, ce;
+            return me = me || { level: "AA", size: "small" }, De = (me.level || "AA").toUpperCase(), ce = (me.size || "small").toLowerCase(), De !== "AA" && De !== "AAA" && (De = "AA"), ce !== "small" && ce !== "large" && (ce = "small"), { level: De, size: ce };
+          }
+          typeof M6 != "undefined" && M6.exports ? M6.exports = l : window.tinycolor = l;
+        })(Math);
+      });
+      var Ao = ye((BS) => {
+        var Yee = Ty(), OS = Array.isArray;
+        function Gtt(e, t) {
+          var r, n;
+          for (r = 0; r < e.length; r++) {
+            if (n = e[r], n !== null && typeof n == "object") return false;
+            n !== void 0 && (t[r] = n);
+          }
+          return true;
+        }
+        BS.extendFlat = function() {
+          return qS(arguments, false, false, false);
+        };
+        BS.extendDeep = function() {
+          return qS(arguments, true, false, false);
+        };
+        BS.extendDeepAll = function() {
+          return qS(arguments, true, true, false);
+        };
+        BS.extendDeepNoArrays = function() {
+          return qS(arguments, true, false, true);
+        };
+        function qS(e, t, r, n) {
+          var i = e[0], a = e.length, o, s, l, u, c, f, h;
+          if (a === 2 && OS(i) && OS(e[1]) && i.length === 0) {
+            if (h = Gtt(e[1], i), h) return i;
+            i.splice(0, i.length);
+          }
+          for (var d = 1; d < a; d++) {
+            o = e[d];
+            for (s in o) l = i[s], u = o[s], n && OS(u) ? i[s] = u : t && u && (Yee(u) || (c = OS(u))) ? (c ? (c = false, f = l && OS(l) ? l : []) : f = l && Yee(l) ? l : {}, i[s] = qS([f, u], t, r, n)) : (typeof u != "undefined" || r) && (i[s] = u);
+          }
+          return i;
+        }
+      });
+      var ec = ye((Crr, Kee) => {
+        Kee.exports = function(e) {
+          var t = e.variantValues, r = e.editType, n = e.colorEditType;
+          n === void 0 && (n = r);
+          var i = { editType: r, valType: "integer", min: 1, max: 1e3, extras: ["normal", "bold"], dflt: "normal" };
+          e.noNumericWeightValues && (i.valType = "enumerated", i.values = i.extras, i.extras = void 0, i.min = void 0, i.max = void 0);
+          var a = { family: { valType: "string", noBlank: true, strict: true, editType: r }, size: { valType: "number", min: 1, editType: r }, color: { valType: "color", editType: n }, weight: i, style: { editType: r, valType: "enumerated", values: ["normal", "italic"], dflt: "normal" }, variant: e.noFontVariant ? void 0 : { editType: r, valType: "enumerated", values: t || ["normal", "small-caps", "all-small-caps", "all-petite-caps", "petite-caps", "unicase"], dflt: "normal" }, textcase: e.noFontTextcase ? void 0 : { editType: r, valType: "enumerated", values: ["normal", "word caps", "upper", "lower"], dflt: "normal" }, lineposition: e.noFontLineposition ? void 0 : { editType: r, valType: "flaglist", flags: ["under", "over", "through"], extras: ["none"], dflt: "none" }, shadow: e.noFontShadow ? void 0 : { editType: r, valType: "string", dflt: e.autoShadowDflt ? "auto" : "none" }, editType: r };
+          return e.autoSize && (a.size.dflt = "auto"), e.autoColor && (a.color.dflt = "auto"), e.arrayOk && (a.family.arrayOk = true, a.weight.arrayOk = true, a.style.arrayOk = true, e.noFontVariant || (a.variant.arrayOk = true), e.noFontTextcase || (a.textcase.arrayOk = true), e.noFontLineposition || (a.lineposition.arrayOk = true), e.noFontShadow || (a.shadow.arrayOk = true), a.size.arrayOk = true, a.color.arrayOk = true), a;
+        };
+      });
+      var NS = ye((Lrr, Jee) => {
+        Jee.exports = { YANGLE: 60, HOVERARROWSIZE: 6, HOVERTEXTPAD: 3, HOVERFONTSIZE: 13, HOVERFONT: "Arial, sans-serif", HOVERMINTIME: 50, HOVERID: "-hover" };
+      });
+      var W1 = ye((Prr, ete) => {
+        var $ee = NS(), Qee = ec(), IO = Qee({ editType: "none" });
+        IO.family.dflt = $ee.HOVERFONT;
+        IO.size.dflt = $ee.HOVERFONTSIZE;
+        ete.exports = { clickmode: { valType: "flaglist", flags: ["event", "select"], dflt: "event", editType: "plot", extras: ["none"] }, dragmode: { valType: "enumerated", values: ["zoom", "pan", "select", "lasso", "drawclosedpath", "drawopenpath", "drawline", "drawrect", "drawcircle", "orbit", "turntable", false], dflt: "zoom", editType: "modebar" }, hovermode: { valType: "enumerated", values: ["x", "y", "closest", false, "x unified", "y unified"], dflt: "closest", editType: "modebar" }, hoversubplots: { valType: "enumerated", values: ["single", "overlaying", "axis"], dflt: "overlaying", editType: "none" }, hoverdistance: { valType: "integer", min: -1, dflt: 20, editType: "none" }, spikedistance: { valType: "integer", min: -1, dflt: -1, editType: "none" }, hoverlabel: { bgcolor: { valType: "color", editType: "none" }, bordercolor: { valType: "color", editType: "none" }, font: IO, grouptitlefont: Qee({ editType: "none" }), align: { valType: "enumerated", values: ["left", "right", "auto"], dflt: "auto", editType: "none" }, namelength: { valType: "integer", min: -1, dflt: 15, editType: "none" }, showarrow: { valType: "boolean", dflt: true, editType: "none" }, editType: "none" }, selectdirection: { valType: "enumerated", values: ["h", "v", "d", "any"], dflt: "any", editType: "none" } };
+      });
+      var v3 = ye((Irr, tte) => {
+        var Htt = ec(), US = W1().hoverlabel, VS = Ao().extendFlat;
+        tte.exports = { hoverlabel: { bgcolor: VS({}, US.bgcolor, { arrayOk: true }), bordercolor: VS({}, US.bordercolor, { arrayOk: true }), font: Htt({ arrayOk: true, editType: "none" }), align: VS({}, US.align, { arrayOk: true }), namelength: VS({}, US.namelength, { arrayOk: true }), showarrow: VS({}, US.showarrow), editType: "none" } };
+      });
+      var Gl = ye((Rrr, rte) => {
+        var jtt = ec(), Wtt = v3();
+        rte.exports = { type: { valType: "enumerated", values: [], dflt: "scatter", editType: "calc+clearAxisTypes", _noTemplating: true }, visible: { valType: "enumerated", values: [true, false, "legendonly"], dflt: true, editType: "calc" }, showlegend: { valType: "boolean", dflt: true, editType: "style" }, legend: { valType: "subplotid", dflt: "legend", editType: "style" }, legendgroup: { valType: "string", dflt: "", editType: "style" }, legendgrouptitle: { text: { valType: "string", dflt: "", editType: "style" }, font: jtt({ editType: "style" }), editType: "style" }, legendrank: { valType: "number", dflt: 1e3, editType: "style" }, legendwidth: { valType: "number", min: 0, editType: "style" }, opacity: { valType: "number", min: 0, max: 1, dflt: 1, editType: "style" }, name: { valType: "string", editType: "style" }, uid: { valType: "string", editType: "plot", anim: true }, ids: { valType: "data_array", editType: "calc", anim: true }, customdata: { valType: "data_array", editType: "calc" }, meta: { valType: "any", arrayOk: true, editType: "plot" }, selectedpoints: { valType: "any", editType: "calc" }, hoverinfo: { valType: "flaglist", flags: ["x", "y", "z", "text", "name"], extras: ["all", "none", "skip"], arrayOk: true, dflt: "all", editType: "none" }, hoverlabel: Wtt.hoverlabel, stream: { token: { valType: "string", noBlank: true, strict: true, editType: "calc" }, maxpoints: { valType: "number", min: 0, max: 1e4, dflt: 500, editType: "calc" }, editType: "calc" }, uirevision: { valType: "any", editType: "none" } };
+      });
+      var mb = ye((Drr, ate) => {
+        var Xtt = fd(), E6 = { Greys: [[0, "rgb(0,0,0)"], [1, "rgb(255,255,255)"]], YlGnBu: [[0, "rgb(8,29,88)"], [0.125, "rgb(37,52,148)"], [0.25, "rgb(34,94,168)"], [0.375, "rgb(29,145,192)"], [0.5, "rgb(65,182,196)"], [0.625, "rgb(127,205,187)"], [0.75, "rgb(199,233,180)"], [0.875, "rgb(237,248,217)"], [1, "rgb(255,255,217)"]], Greens: [[0, "rgb(0,68,27)"], [0.125, "rgb(0,109,44)"], [0.25, "rgb(35,139,69)"], [0.375, "rgb(65,171,93)"], [0.5, "rgb(116,196,118)"], [0.625, "rgb(161,217,155)"], [0.75, "rgb(199,233,192)"], [0.875, "rgb(229,245,224)"], [1, "rgb(247,252,245)"]], YlOrRd: [[0, "rgb(128,0,38)"], [0.125, "rgb(189,0,38)"], [0.25, "rgb(227,26,28)"], [0.375, "rgb(252,78,42)"], [0.5, "rgb(253,141,60)"], [0.625, "rgb(254,178,76)"], [0.75, "rgb(254,217,118)"], [0.875, "rgb(255,237,160)"], [1, "rgb(255,255,204)"]], Bluered: [[0, "rgb(0,0,255)"], [1, "rgb(255,0,0)"]], RdBu: [[0, "rgb(5,10,172)"], [0.35, "rgb(106,137,247)"], [0.5, "rgb(190,190,190)"], [0.6, "rgb(220,170,132)"], [0.7, "rgb(230,145,90)"], [1, "rgb(178,10,28)"]], Reds: [[0, "rgb(220,220,220)"], [0.2, "rgb(245,195,157)"], [0.4, "rgb(245,160,105)"], [1, "rgb(178,10,28)"]], Blues: [[0, "rgb(5,10,172)"], [0.35, "rgb(40,60,190)"], [0.5, "rgb(70,100,245)"], [0.6, "rgb(90,120,245)"], [0.7, "rgb(106,137,247)"], [1, "rgb(220,220,220)"]], Picnic: [[0, "rgb(0,0,255)"], [0.1, "rgb(51,153,255)"], [0.2, "rgb(102,204,255)"], [0.3, "rgb(153,204,255)"], [0.4, "rgb(204,204,255)"], [0.5, "rgb(255,255,255)"], [0.6, "rgb(255,204,255)"], [0.7, "rgb(255,153,255)"], [0.8, "rgb(255,102,204)"], [0.9, "rgb(255,102,102)"], [1, "rgb(255,0,0)"]], Rainbow: [[0, "rgb(150,0,90)"], [0.125, "rgb(0,0,200)"], [0.25, "rgb(0,25,255)"], [0.375, "rgb(0,152,255)"], [0.5, "rgb(44,255,150)"], [0.625, "rgb(151,255,0)"], [0.75, "rgb(255,234,0)"], [0.875, "rgb(255,111,0)"], [1, "rgb(255,0,0)"]], Portland: [[0, "rgb(12,51,131)"], [0.25, "rgb(10,136,186)"], [0.5, "rgb(242,211,56)"], [0.75, "rgb(242,143,56)"], [1, "rgb(217,30,30)"]], Jet: [[0, "rgb(0,0,131)"], [0.125, "rgb(0,60,170)"], [0.375, "rgb(5,255,255)"], [0.625, "rgb(255,255,0)"], [0.875, "rgb(250,0,0)"], [1, "rgb(128,0,0)"]], Hot: [[0, "rgb(0,0,0)"], [0.3, "rgb(230,0,0)"], [0.6, "rgb(255,210,0)"], [1, "rgb(255,255,255)"]], Blackbody: [[0, "rgb(0,0,0)"], [0.2, "rgb(230,0,0)"], [0.4, "rgb(230,210,0)"], [0.7, "rgb(255,255,255)"], [1, "rgb(160,200,255)"]], Earth: [[0, "rgb(0,0,130)"], [0.1, "rgb(0,180,180)"], [0.2, "rgb(40,210,40)"], [0.4, "rgb(230,230,50)"], [0.6, "rgb(120,70,20)"], [1, "rgb(255,255,255)"]], Electric: [[0, "rgb(0,0,0)"], [0.15, "rgb(30,0,100)"], [0.4, "rgb(120,0,100)"], [0.6, "rgb(160,90,0)"], [0.8, "rgb(230,200,0)"], [1, "rgb(255,250,220)"]], Viridis: [[0, "#440154"], [0.06274509803921569, "#48186a"], [0.12549019607843137, "#472d7b"], [0.18823529411764706, "#424086"], [0.25098039215686274, "#3b528b"], [0.3137254901960784, "#33638d"], [0.3764705882352941, "#2c728e"], [0.4392156862745098, "#26828e"], [0.5019607843137255, "#21918c"], [0.5647058823529412, "#1fa088"], [0.6274509803921569, "#28ae80"], [0.6901960784313725, "#3fbc73"], [0.7529411764705882, "#5ec962"], [0.8156862745098039, "#84d44b"], [0.8784313725490196, "#addc30"], [0.9411764705882353, "#d8e219"], [1, "#fde725"]], Cividis: [[0, "rgb(0,32,76)"], [0.058824, "rgb(0,42,102)"], [0.117647, "rgb(0,52,110)"], [0.176471, "rgb(39,63,108)"], [0.235294, "rgb(60,74,107)"], [0.294118, "rgb(76,85,107)"], [0.352941, "rgb(91,95,109)"], [0.411765, "rgb(104,106,112)"], [0.470588, "rgb(117,117,117)"], [0.529412, "rgb(131,129,120)"], [0.588235, "rgb(146,140,120)"], [0.647059, "rgb(161,152,118)"], [0.705882, "rgb(176,165,114)"], [0.764706, "rgb(192,177,109)"], [0.823529, "rgb(209,191,102)"], [0.882353, "rgb(225,204,92)"], [0.941176, "rgb(243,219,79)"], [1, "rgb(255,233,69)"]] }, ite = E6.RdBu;
+        function Ztt(e, t) {
+          if (t || (t = ite), !e) return t;
+          function r() {
+            try {
+              e = E6[e] || JSON.parse(e);
+            } catch (n) {
+              e = t;
+            }
+          }
+          return typeof e == "string" && (r(), typeof e == "string" && r()), nte(e) ? e : t;
+        }
+        function nte(e) {
+          var t = 0;
+          if (!Array.isArray(e) || e.length < 2 || !e[0] || !e[e.length - 1] || +e[0][0] != 0 || +e[e.length - 1][0] != 1) return false;
+          for (var r = 0; r < e.length; r++) {
+            var n = e[r];
+            if (n.length !== 2 || +n[0] < t || !Xtt(n[1]).isValid()) return false;
+            t = +n[0];
+          }
+          return true;
+        }
+        function Ytt(e) {
+          return E6[e] !== void 0 ? true : nte(e);
+        }
+        ate.exports = { scales: E6, defaultScale: ite, get: Ztt, isValid: Ytt };
+      });
+      var Ih = ye((yb) => {
+        yb.defaults = ["#1f77b4", "#ff7f0e", "#2ca02c", "#d62728", "#9467bd", "#8c564b", "#e377c2", "#7f7f7f", "#bcbd22", "#17becf"];
+        yb.defaultLine = "#444";
+        yb.lightLine = "#eee";
+        yb.background = "#fff";
+        yb.borderLine = "#BEC8D9";
+        yb.lightFraction = 100 * 10 / 11;
+      });
+      var ka = ye((zrr, ote) => {
+        var wp = fd(), Ktt = Eo(), Jtt = vv().isTypedArray, hd = ote.exports = {}, k6 = Ih();
+        hd.defaults = k6.defaults;
+        var $tt = hd.defaultLine = k6.defaultLine;
+        hd.lightLine = k6.lightLine;
+        var DO = hd.background = k6.background;
+        hd.tinyRGB = function(e) {
+          var t = e.toRgb();
+          return "rgb(" + Math.round(t.r) + ", " + Math.round(t.g) + ", " + Math.round(t.b) + ")";
+        };
+        hd.rgb = function(e) {
+          return hd.tinyRGB(wp(e));
+        };
+        hd.opacity = function(e) {
+          return e ? wp(e).getAlpha() : 0;
+        };
+        hd.addOpacity = function(e, t) {
+          var r = wp(e).toRgb();
+          return "rgba(" + Math.round(r.r) + ", " + Math.round(r.g) + ", " + Math.round(r.b) + ", " + t + ")";
+        };
+        hd.combine = function(e, t) {
+          var r = wp(e).toRgb();
+          if (r.a === 1) return wp(e).toRgbString();
+          var n = wp(t || DO).toRgb(), i = n.a === 1 ? n : { r: 255 * (1 - n.a) + n.r * n.a, g: 255 * (1 - n.a) + n.g * n.a, b: 255 * (1 - n.a) + n.b * n.a }, a = { r: i.r * (1 - r.a) + r.r * r.a, g: i.g * (1 - r.a) + r.g * r.a, b: i.b * (1 - r.a) + r.b * r.a };
+          return wp(a).toRgbString();
+        };
+        hd.interpolate = function(e, t, r) {
+          var n = wp(e).toRgb(), i = wp(t).toRgb(), a = { r: r * n.r + (1 - r) * i.r, g: r * n.g + (1 - r) * i.g, b: r * n.b + (1 - r) * i.b };
+          return wp(a).toRgbString();
+        };
+        hd.contrast = function(e, t, r) {
+          var n = wp(e);
+          n.getAlpha() !== 1 && (n = wp(hd.combine(e, DO)));
+          var i = n.isDark() ? t ? n.lighten(t) : DO : r ? n.darken(r) : $tt;
+          return i.toString();
+        };
+        hd.stroke = function(e, t) {
+          var r = wp(t);
+          e.style({ stroke: hd.tinyRGB(r), "stroke-opacity": r.getAlpha() });
+        };
+        hd.fill = function(e, t) {
+          var r = wp(t);
+          e.style({ fill: hd.tinyRGB(r), "fill-opacity": r.getAlpha() });
+        };
+        hd.clean = function(e) {
+          if (!(!e || typeof e != "object")) {
+            var t = Object.keys(e), r, n, i, a;
+            for (r = 0; r < t.length; r++) if (i = t[r], a = e[i], i.slice(-5) === "color") if (Array.isArray(a)) for (n = 0; n < a.length; n++) a[n] = RO(a[n]);
+            else e[i] = RO(a);
+            else if (i.slice(-10) === "colorscale" && Array.isArray(a)) for (n = 0; n < a.length; n++) Array.isArray(a[n]) && (a[n][1] = RO(a[n][1]));
+            else if (Array.isArray(a)) {
+              var o = a[0];
+              if (!Array.isArray(o) && o && typeof o == "object") for (n = 0; n < a.length; n++) hd.clean(a[n]);
+            } else a && typeof a == "object" && !Jtt(a) && hd.clean(a);
+          }
+        };
+        function RO(e) {
+          if (Ktt(e) || typeof e != "string") return e;
+          var t = e.trim();
+          if (t.slice(0, 3) !== "rgb") return e;
+          var r = t.match(/^rgba?\s*\(([^()]*)\)$/);
+          if (!r) return e;
+          var n = r[1].trim().split(/\s*[\s,]\s*/), i = t.charAt(3) === "a" && n.length === 4;
+          if (!i && n.length !== 3) return e;
+          for (var a = 0; a < n.length; a++) {
+            if (!n[a].length || (n[a] = Number(n[a]), !(n[a] >= 0))) return e;
+            if (a === 3) n[a] > 1 && (n[a] = 1);
+            else if (n[a] >= 1) return e;
+          }
+          var o = Math.round(n[0] * 255) + ", " + Math.round(n[1] * 255) + ", " + Math.round(n[2] * 255);
+          return i ? "rgba(" + o + ", " + n[3] + ")" : "rgb(" + o + ")";
+        }
+      });
+      var X1 = ye((Orr, ste) => {
+        ste.exports = { SHOW_PLACEHOLDER: 100, HIDE_PLACEHOLDER: 1e3, DESELECTDIM: 0.2 };
+      });
+      var p3 = ye((lte) => {
+        lte.counter = function(e, t, r, n) {
+          var i = (t || "") + (r ? "" : "$"), a = n === false ? "" : "^";
+          return e === "xy" ? new RegExp(a + "x([2-9]|[1-9][0-9]+)?y([2-9]|[1-9][0-9]+)?" + i) : new RegExp(a + e + "([2-9]|[1-9][0-9]+)?" + i);
+        };
+      });
+      var hte = ye((Tp) => {
+        var FO = Eo(), ute = fd(), cte = Ao().extendFlat, Qtt = Gl(), ert = mb(), trt = ka(), rrt = X1().DESELECTDIM, g3 = FS(), fte = p3().counter, irt = d3().modHalf, bg = vv().isArrayOrTypedArray, Z1 = vv().isTypedArraySpec, Y1 = vv().decodeTypedArraySpec;
+        Tp.valObjectMeta = { data_array: { coerceFunction: function(e, t, r) {
+          t.set(bg(e) ? e : Z1(e) ? Y1(e) : r);
+        } }, enumerated: { coerceFunction: function(e, t, r, n) {
+          n.coerceNumber && (e = +e), n.values.indexOf(e) === -1 ? t.set(r) : t.set(e);
+        }, validateFunction: function(e, t) {
+          t.coerceNumber && (e = +e);
+          for (var r = t.values, n = 0; n < r.length; n++) {
+            var i = String(r[n]);
+            if (i.charAt(0) === "/" && i.charAt(i.length - 1) === "/") {
+              var a = new RegExp(i.slice(1, -1));
+              if (a.test(e)) return true;
+            } else if (e === r[n]) return true;
+          }
+          return false;
+        } }, boolean: { coerceFunction: function(e, t, r, n) {
+          let i = (a) => a === true || a === false;
+          i(e) || n.arrayOk && Array.isArray(e) && e.length > 0 && e.every(i) ? t.set(e) : t.set(r);
+        } }, number: { coerceFunction: function(e, t, r, n) {
+          Z1(e) && (e = Y1(e)), !FO(e) || n.min !== void 0 && e < n.min || n.max !== void 0 && e > n.max ? t.set(r) : t.set(+e);
+        } }, integer: { coerceFunction: function(e, t, r, n) {
+          if ((n.extras || []).indexOf(e) !== -1) {
+            t.set(e);
+            return;
+          }
+          Z1(e) && (e = Y1(e)), e % 1 || !FO(e) || n.min !== void 0 && e < n.min || n.max !== void 0 && e > n.max ? t.set(r) : t.set(+e);
+        } }, string: { coerceFunction: function(e, t, r, n) {
+          if (typeof e != "string") {
+            var i = typeof e == "number";
+            n.strict === true || !i ? t.set(r) : t.set(String(e));
+          } else n.noBlank && !e ? t.set(r) : t.set(e);
+        } }, color: { coerceFunction: function(e, t, r) {
+          Z1(e) && (e = Y1(e)), ute(e).isValid() ? t.set(e) : t.set(r);
+        } }, colorlist: { coerceFunction: function(e, t, r) {
+          function n(i) {
+            return ute(i).isValid();
+          }
+          !Array.isArray(e) || !e.length ? t.set(r) : e.every(n) ? t.set(e) : t.set(r);
+        } }, colorscale: { coerceFunction: function(e, t, r) {
+          t.set(ert.get(e, r));
+        } }, angle: { coerceFunction: function(e, t, r) {
+          Z1(e) && (e = Y1(e)), e === "auto" ? t.set("auto") : FO(e) ? t.set(irt(+e, 360)) : t.set(r);
+        } }, subplotid: { coerceFunction: function(e, t, r, n) {
+          var i = n.regex || fte(r);
+          let a = (o) => typeof o == "string" && i.test(o);
+          a(e) || n.arrayOk && bg(e) && e.length > 0 && e.every(a) ? t.set(e) : t.set(r);
+        }, validateFunction: function(e, t) {
+          var r = t.dflt;
+          return e === r ? true : typeof e != "string" ? false : !!fte(r).test(e);
+        } }, flaglist: { coerceFunction: function(e, t, r, n) {
+          if ((n.extras || []).indexOf(e) !== -1) {
+            t.set(e);
+            return;
+          }
+          if (typeof e != "string") {
+            t.set(r);
+            return;
+          }
+          for (var i = e.split("+"), a = 0; a < i.length; ) {
+            var o = i[a];
+            n.flags.indexOf(o) === -1 || i.indexOf(o) < a ? i.splice(a, 1) : a++;
+          }
+          i.length ? t.set(i.join("+")) : t.set(r);
+        } }, any: { coerceFunction: function(e, t, r) {
+          e === void 0 ? t.set(r) : t.set(Z1(e) ? Y1(e) : e);
+        } }, info_array: { coerceFunction: function(e, t, r, n) {
+          function i(k, E, T) {
+            var L, x = { set: function(C) {
+              L = C;
+            } };
+            return T === void 0 && (T = E.dflt), Tp.valObjectMeta[E.valType].coerceFunction(k, x, T, E), L;
+          }
+          if (Z1(e) && (e = Y1(e)), !bg(e)) {
+            t.set(r);
+            return;
+          }
+          var a = n.dimensions === 2 || n.dimensions === "1-2" && Array.isArray(e) && bg(e[0]), o = n.items, s = [], l = Array.isArray(o), u = l && a && bg(o[0]), c = a && l && !u, f = l && !c ? o.length : e.length, h, d, v, _, b, p;
+          if (r = Array.isArray(r) ? r : [], a) for (h = 0; h < f; h++) for (s[h] = [], v = bg(e[h]) ? e[h] : [], c ? b = o.length : l ? b = o[h].length : b = v.length, d = 0; d < b; d++) c ? _ = o[d] : l ? _ = o[h][d] : _ = o, p = i(v[d], _, (r[h] || [])[d]), p !== void 0 && (s[h][d] = p);
+          else for (h = 0; h < f; h++) p = i(e[h], l ? o[h] : o, r[h]), p !== void 0 && (s[h] = p);
+          t.set(s);
+        }, validateFunction: function(e, t) {
+          if (!bg(e)) return false;
+          var r = t.items, n = Array.isArray(r), i = t.dimensions === 2;
+          if (!t.freeLength && e.length !== r.length) return false;
+          for (var a = 0; a < e.length; a++) if (i) {
+            if (!bg(e[a]) || !t.freeLength && e[a].length !== r[a].length) return false;
+            for (var o = 0; o < e[a].length; o++) if (!C6(e[a][o], n ? r[a][o] : r)) return false;
+          } else if (!C6(e[a], n ? r[a] : r)) return false;
+          return true;
+        } } };
+        Tp.coerce = function(e, t, r, n, i) {
+          var a = g3(r, n).get(), o = g3(e, n), s = g3(t, n), l = o.get(), u = t._template;
+          if (l === void 0 && u && (l = g3(u, n).get(), u = 0), i === void 0 && (i = a.dflt), a.arrayOk) {
+            if (bg(l)) return s.set(l), l;
+            if (Z1(l)) return l = Y1(l), s.set(l), l;
+          }
+          var c = Tp.valObjectMeta[a.valType].coerceFunction;
+          c(l, s, i, a);
+          var f = s.get();
+          return u && f === i && !C6(l, a) && (l = g3(u, n).get(), c(l, s, i, a), f = s.get()), f;
+        };
+        Tp.coerce2 = function(e, t, r, n, i) {
+          var a = g3(e, n), o = Tp.coerce(e, t, r, n, i), s = a.get();
+          return s != null ? o : false;
+        };
+        Tp.coerceFont = function(e, t, r, n) {
+          n || (n = {}), r = cte({}, r), r = cte(r, n.overrideDflt || {});
+          var i = { family: e(t + ".family", r.family), size: e(t + ".size", r.size), color: e(t + ".color", r.color), weight: e(t + ".weight", r.weight), style: e(t + ".style", r.style) };
+          if (n.noFontVariant || (i.variant = e(t + ".variant", r.variant)), n.noFontLineposition || (i.lineposition = e(t + ".lineposition", r.lineposition)), n.noFontTextcase || (i.textcase = e(t + ".textcase", r.textcase)), !n.noFontShadow) {
+            var a = r.shadow;
+            a === "none" && n.autoShadowDflt && (a = "auto"), i.shadow = e(t + ".shadow", a);
+          }
+          return i;
+        };
+        Tp.coercePattern = function(e, t, r, n) {
+          var i = e(t + ".shape"), a;
+          if (i || (a = e(t + ".path")), i || a) {
+            i && e(t + ".solidity"), e(t + ".size");
+            var o = e(t + ".fillmode"), s = o === "overlay";
+            if (!n) {
+              var l = e(t + ".bgcolor", s ? r : void 0);
+              e(t + ".fgcolor", s ? trt.contrast(l) : r);
+            }
+            e(t + ".fgopacity", s ? 0.5 : 1);
+          }
+        };
+        Tp.coerceHoverinfo = function(e, t, r) {
+          var n = t._module.attributes, i = n.hoverinfo ? n : Qtt, a = i.hoverinfo, o;
+          if (r._dataLength === 1) {
+            var s = a.dflt === "all" ? a.flags.slice() : a.dflt.split("+");
+            s.splice(s.indexOf("name"), 1), o = s.join("+");
+          }
+          return Tp.coerce(e, t, i, "hoverinfo", o);
+        };
+        Tp.coerceSelectionMarkerOpacity = function(e, t) {
+          if (e.marker) {
+            var r = e.marker.opacity;
+            if (r !== void 0) {
+              var n, i;
+              !bg(r) && !e.selected && !e.unselected && (n = r, i = rrt * r), t("selected.marker.opacity", n), t("unselected.marker.opacity", i);
+            }
+          }
+        };
+        function C6(e, t) {
+          var r = Tp.valObjectMeta[t.valType];
+          if (t.arrayOk && bg(e)) return true;
+          if (r.validateFunction) return r.validateFunction(e, t);
+          var n = {}, i = n, a = { set: function(o) {
+            i = o;
+          } };
+          return r.coerceFunction(e, a, n, t), i !== n;
+        }
+        Tp.validate = C6;
+      });
+      var _b = ye((Nrr, gte) => {
+        var dte = { staticPlot: { valType: "boolean", dflt: false }, typesetMath: { valType: "boolean", dflt: true }, plotlyServerURL: { valType: "string", dflt: "" }, editable: { valType: "boolean", dflt: false }, edits: { annotationPosition: { valType: "boolean", dflt: false }, annotationTail: { valType: "boolean", dflt: false }, annotationText: { valType: "boolean", dflt: false }, axisTitleText: { valType: "boolean", dflt: false }, colorbarPosition: { valType: "boolean", dflt: false }, colorbarTitleText: { valType: "boolean", dflt: false }, legendPosition: { valType: "boolean", dflt: false }, legendText: { valType: "boolean", dflt: false }, shapePosition: { valType: "boolean", dflt: false }, titleText: { valType: "boolean", dflt: false } }, editSelection: { valType: "boolean", dflt: true }, autosizable: { valType: "boolean", dflt: false }, responsive: { valType: "boolean", dflt: false }, fillFrame: { valType: "boolean", dflt: false }, frameMargins: { valType: "number", dflt: 0, min: 0, max: 0.5 }, scrollZoom: { valType: "flaglist", flags: ["cartesian", "gl3d", "geo", "mapbox", "map"], extras: [true, false], dflt: "gl3d+geo+map" }, doubleClick: { valType: "enumerated", values: [false, "reset", "autosize", "reset+autosize"], dflt: "reset+autosize" }, doubleClickDelay: { valType: "number", dflt: 300, min: 0 }, showAxisDragHandles: { valType: "boolean", dflt: true }, showAxisRangeEntryBoxes: { valType: "boolean", dflt: true }, showTips: { valType: "boolean", dflt: true }, showLink: { valType: "boolean", dflt: false }, linkText: { valType: "string", dflt: "Edit chart", noBlank: true }, sendData: { valType: "boolean", dflt: true }, showSources: { valType: "any", dflt: false }, displayModeBar: { valType: "enumerated", values: ["hover", true, false], dflt: "hover" }, showSendToCloud: { valType: "boolean", dflt: false }, showEditInChartStudio: { valType: "boolean", dflt: false }, modeBarButtonsToRemove: { valType: "any", dflt: [] }, modeBarButtonsToAdd: { valType: "any", dflt: [] }, modeBarButtons: { valType: "any", dflt: false }, toImageButtonOptions: { valType: "any", dflt: {} }, displaylogo: { valType: "boolean", dflt: true }, watermark: { valType: "boolean", dflt: false }, plotGlPixelRatio: { valType: "number", dflt: 2, min: 1, max: 4 }, setBackground: { valType: "any", dflt: "transparent" }, topojsonURL: { valType: "string", noBlank: true, dflt: "https://cdn.plot.ly/un/" }, mapboxAccessToken: { valType: "string", dflt: null }, logging: { valType: "integer", min: 0, max: 2, dflt: 1 }, notifyOnLogging: { valType: "integer", min: 0, max: 2, dflt: 0 }, queueLength: { valType: "integer", min: 0, dflt: 0 }, locale: { valType: "string", dflt: "en-US" }, locales: { valType: "any", dflt: {} } }, vte = {};
+        function pte(e, t) {
+          for (var r in e) {
+            var n = e[r];
+            n.valType ? t[r] = n.dflt : (t[r] || (t[r] = {}), pte(n, t[r]));
+          }
+        }
+        pte(dte, vte);
+        gte.exports = { configAttributes: dte, dfltConfig: vte };
+      });
+      var OO = ye((Urr, mte) => {
+        var zO = Oa(), nrt = Eo(), GS = [];
+        mte.exports = function(e, t) {
+          if (GS.indexOf(e) !== -1) return;
+          GS.push(e);
+          var r = 1e3;
+          nrt(t) ? r = t : t === "long" && (r = 3e3);
+          var n = zO.select("body").selectAll(".plotly-notifier").data([0]);
+          n.enter().append("div").classed("plotly-notifier", true);
+          var i = n.selectAll(".notifier-note").data(GS);
+          function a(o) {
+            o.duration(700).style("opacity", 0).each("end", function(s) {
+              var l = GS.indexOf(s);
+              l !== -1 && GS.splice(l, 1), zO.select(this).remove();
+            });
+          }
+          i.enter().append("div").classed("notifier-note", true).style("opacity", 0).each(function(o) {
+            var s = zO.select(this);
+            s.append("button").classed("notifier-close", true).html("&times;").on("click", function() {
+              s.transition().call(a);
+            });
+            for (var l = s.append("p"), u = o.split(/<br\s*\/?>/g), c = 0; c < u.length; c++) c && l.append("br"), l.append("span").text(u[c]);
+            t === "stick" ? s.transition().duration(350).style("opacity", 1) : s.transition().duration(700).style("opacity", 1).transition().delay(r).call(a);
+          });
+        };
+      });
+      var K1 = ye((Vrr, yte) => {
+        var m3 = _b().dfltConfig, qO = OO(), BO = yte.exports = {};
+        BO.log = function() {
+          var e;
+          if (m3.logging > 1) {
+            var t = ["LOG:"];
+            for (e = 0; e < arguments.length; e++) t.push(arguments[e]);
+            console.trace.apply(console, t);
+          }
+          if (m3.notifyOnLogging > 1) {
+            var r = [];
+            for (e = 0; e < arguments.length; e++) r.push(arguments[e]);
+            qO(r.join("<br>"), "long");
+          }
+        };
+        BO.warn = function() {
+          var e;
+          if (m3.logging > 0) {
+            var t = ["WARN:"];
+            for (e = 0; e < arguments.length; e++) t.push(arguments[e]);
+            console.trace.apply(console, t);
+          }
+          if (m3.notifyOnLogging > 0) {
+            var r = [];
+            for (e = 0; e < arguments.length; e++) r.push(arguments[e]);
+            qO(r.join("<br>"), "stick");
+          }
+        };
+        BO.error = function() {
+          var e;
+          if (m3.logging > 0) {
+            var t = ["ERROR:"];
+            for (e = 0; e < arguments.length; e++) t.push(arguments[e]);
+            console.error.apply(console, t);
+          }
+          if (m3.notifyOnLogging > 0) {
+            var r = [];
+            for (e = 0; e < arguments.length; e++) r.push(arguments[e]);
+            qO(r.join("<br>"), "stick");
+          }
+        };
+      });
+      var L6 = ye((Grr, _te) => {
+        _te.exports = function() {
+        };
+      });
+      var NO = ye((Hrr, xte) => {
+        xte.exports = function(t, r) {
+          if (r instanceof RegExp) {
+            for (var n = r.toString(), i = 0; i < t.length; i++) if (t[i] instanceof RegExp && t[i].toString() === n) return t;
+            t.push(r);
+          } else (r || r === 0) && t.indexOf(r) === -1 && t.push(r);
+          return t;
+        };
+      });
+      var wte = ye((jrr, bte) => {
+        bte.exports = art;
+        function art() {
+          var e = new Float32Array(16);
+          return e[0] = 1, e[1] = 0, e[2] = 0, e[3] = 0, e[4] = 0, e[5] = 1, e[6] = 0, e[7] = 0, e[8] = 0, e[9] = 0, e[10] = 1, e[11] = 0, e[12] = 0, e[13] = 0, e[14] = 0, e[15] = 1, e;
+        }
+      });
+      var Ate = ye((Wrr, Tte) => {
+        Tte.exports = ort;
+        function ort(e) {
+          var t = new Float32Array(16);
+          return t[0] = e[0], t[1] = e[1], t[2] = e[2], t[3] = e[3], t[4] = e[4], t[5] = e[5], t[6] = e[6], t[7] = e[7], t[8] = e[8], t[9] = e[9], t[10] = e[10], t[11] = e[11], t[12] = e[12], t[13] = e[13], t[14] = e[14], t[15] = e[15], t;
+        }
+      });
+      var Mte = ye((Xrr, Ste) => {
+        Ste.exports = srt;
+        function srt(e, t) {
+          return e[0] = t[0], e[1] = t[1], e[2] = t[2], e[3] = t[3], e[4] = t[4], e[5] = t[5], e[6] = t[6], e[7] = t[7], e[8] = t[8], e[9] = t[9], e[10] = t[10], e[11] = t[11], e[12] = t[12], e[13] = t[13], e[14] = t[14], e[15] = t[15], e;
+        }
+      });
+      var UO = ye((Zrr, Ete) => {
+        Ete.exports = lrt;
+        function lrt(e) {
+          return e[0] = 1, e[1] = 0, e[2] = 0, e[3] = 0, e[4] = 0, e[5] = 1, e[6] = 0, e[7] = 0, e[8] = 0, e[9] = 0, e[10] = 1, e[11] = 0, e[12] = 0, e[13] = 0, e[14] = 0, e[15] = 1, e;
+        }
+      });
+      var Cte = ye((Yrr, kte) => {
+        kte.exports = urt;
+        function urt(e, t) {
+          if (e === t) {
+            var r = t[1], n = t[2], i = t[3], a = t[6], o = t[7], s = t[11];
+            e[1] = t[4], e[2] = t[8], e[3] = t[12], e[4] = r, e[6] = t[9], e[7] = t[13], e[8] = n, e[9] = a, e[11] = t[14], e[12] = i, e[13] = o, e[14] = s;
+          } else e[0] = t[0], e[1] = t[4], e[2] = t[8], e[3] = t[12], e[4] = t[1], e[5] = t[5], e[6] = t[9], e[7] = t[13], e[8] = t[2], e[9] = t[6], e[10] = t[10], e[11] = t[14], e[12] = t[3], e[13] = t[7], e[14] = t[11], e[15] = t[15];
+          return e;
+        }
+      });
+      var Pte = ye((Krr, Lte) => {
+        Lte.exports = crt;
+        function crt(e, t) {
+          var r = t[0], n = t[1], i = t[2], a = t[3], o = t[4], s = t[5], l = t[6], u = t[7], c = t[8], f = t[9], h = t[10], d = t[11], v = t[12], _ = t[13], b = t[14], p = t[15], k = r * s - n * o, E = r * l - i * o, T = r * u - a * o, L = n * l - i * s, x = n * u - a * s, C = i * u - a * l, M = c * _ - f * v, g = c * b - h * v, P = c * p - d * v, A = f * b - h * _, z = f * p - d * _, O = h * p - d * b, U = k * O - E * z + T * A + L * P - x * g + C * M;
+          return U ? (U = 1 / U, e[0] = (s * O - l * z + u * A) * U, e[1] = (i * z - n * O - a * A) * U, e[2] = (_ * C - b * x + p * L) * U, e[3] = (h * x - f * C - d * L) * U, e[4] = (l * P - o * O - u * g) * U, e[5] = (r * O - i * P + a * g) * U, e[6] = (b * T - v * C - p * E) * U, e[7] = (c * C - h * T + d * E) * U, e[8] = (o * z - s * P + u * M) * U, e[9] = (n * P - r * z - a * M) * U, e[10] = (v * x - _ * T + p * k) * U, e[11] = (f * T - c * x - d * k) * U, e[12] = (s * g - o * A - l * M) * U, e[13] = (r * A - n * g + i * M) * U, e[14] = (_ * E - v * L - b * k) * U, e[15] = (c * L - f * E + h * k) * U, e) : null;
+        }
+      });
+      var Rte = ye((Jrr, Ite) => {
+        Ite.exports = frt;
+        function frt(e, t) {
+          var r = t[0], n = t[1], i = t[2], a = t[3], o = t[4], s = t[5], l = t[6], u = t[7], c = t[8], f = t[9], h = t[10], d = t[11], v = t[12], _ = t[13], b = t[14], p = t[15];
+          return e[0] = s * (h * p - d * b) - f * (l * p - u * b) + _ * (l * d - u * h), e[1] = -(n * (h * p - d * b) - f * (i * p - a * b) + _ * (i * d - a * h)), e[2] = n * (l * p - u * b) - s * (i * p - a * b) + _ * (i * u - a * l), e[3] = -(n * (l * d - u * h) - s * (i * d - a * h) + f * (i * u - a * l)), e[4] = -(o * (h * p - d * b) - c * (l * p - u * b) + v * (l * d - u * h)), e[5] = r * (h * p - d * b) - c * (i * p - a * b) + v * (i * d - a * h), e[6] = -(r * (l * p - u * b) - o * (i * p - a * b) + v * (i * u - a * l)), e[7] = r * (l * d - u * h) - o * (i * d - a * h) + c * (i * u - a * l), e[8] = o * (f * p - d * _) - c * (s * p - u * _) + v * (s * d - u * f), e[9] = -(r * (f * p - d * _) - c * (n * p - a * _) + v * (n * d - a * f)), e[10] = r * (s * p - u * _) - o * (n * p - a * _) + v * (n * u - a * s), e[11] = -(r * (s * d - u * f) - o * (n * d - a * f) + c * (n * u - a * s)), e[12] = -(o * (f * b - h * _) - c * (s * b - l * _) + v * (s * h - l * f)), e[13] = r * (f * b - h * _) - c * (n * b - i * _) + v * (n * h - i * f), e[14] = -(r * (s * b - l * _) - o * (n * b - i * _) + v * (n * l - i * s)), e[15] = r * (s * h - l * f) - o * (n * h - i * f) + c * (n * l - i * s), e;
+        }
+      });
+      var Fte = ye(($rr, Dte) => {
+        Dte.exports = hrt;
+        function hrt(e) {
+          var t = e[0], r = e[1], n = e[2], i = e[3], a = e[4], o = e[5], s = e[6], l = e[7], u = e[8], c = e[9], f = e[10], h = e[11], d = e[12], v = e[13], _ = e[14], b = e[15], p = t * o - r * a, k = t * s - n * a, E = t * l - i * a, T = r * s - n * o, L = r * l - i * o, x = n * l - i * s, C = u * v - c * d, M = u * _ - f * d, g = u * b - h * d, P = c * _ - f * v, A = c * b - h * v, z = f * b - h * _;
+          return p * z - k * A + E * P + T * g - L * M + x * C;
+        }
+      });
+      var Ote = ye((Qrr, zte) => {
+        zte.exports = drt;
+        function drt(e, t, r) {
+          var n = t[0], i = t[1], a = t[2], o = t[3], s = t[4], l = t[5], u = t[6], c = t[7], f = t[8], h = t[9], d = t[10], v = t[11], _ = t[12], b = t[13], p = t[14], k = t[15], E = r[0], T = r[1], L = r[2], x = r[3];
+          return e[0] = E * n + T * s + L * f + x * _, e[1] = E * i + T * l + L * h + x * b, e[2] = E * a + T * u + L * d + x * p, e[3] = E * o + T * c + L * v + x * k, E = r[4], T = r[5], L = r[6], x = r[7], e[4] = E * n + T * s + L * f + x * _, e[5] = E * i + T * l + L * h + x * b, e[6] = E * a + T * u + L * d + x * p, e[7] = E * o + T * c + L * v + x * k, E = r[8], T = r[9], L = r[10], x = r[11], e[8] = E * n + T * s + L * f + x * _, e[9] = E * i + T * l + L * h + x * b, e[10] = E * a + T * u + L * d + x * p, e[11] = E * o + T * c + L * v + x * k, E = r[12], T = r[13], L = r[14], x = r[15], e[12] = E * n + T * s + L * f + x * _, e[13] = E * i + T * l + L * h + x * b, e[14] = E * a + T * u + L * d + x * p, e[15] = E * o + T * c + L * v + x * k, e;
+        }
+      });
+      var Bte = ye((eir, qte) => {
+        qte.exports = vrt;
+        function vrt(e, t, r) {
+          var n = r[0], i = r[1], a = r[2], o, s, l, u, c, f, h, d, v, _, b, p;
+          return t === e ? (e[12] = t[0] * n + t[4] * i + t[8] * a + t[12], e[13] = t[1] * n + t[5] * i + t[9] * a + t[13], e[14] = t[2] * n + t[6] * i + t[10] * a + t[14], e[15] = t[3] * n + t[7] * i + t[11] * a + t[15]) : (o = t[0], s = t[1], l = t[2], u = t[3], c = t[4], f = t[5], h = t[6], d = t[7], v = t[8], _ = t[9], b = t[10], p = t[11], e[0] = o, e[1] = s, e[2] = l, e[3] = u, e[4] = c, e[5] = f, e[6] = h, e[7] = d, e[8] = v, e[9] = _, e[10] = b, e[11] = p, e[12] = o * n + c * i + v * a + t[12], e[13] = s * n + f * i + _ * a + t[13], e[14] = l * n + h * i + b * a + t[14], e[15] = u * n + d * i + p * a + t[15]), e;
+        }
+      });
+      var Ute = ye((tir, Nte) => {
+        Nte.exports = prt;
+        function prt(e, t, r) {
+          var n = r[0], i = r[1], a = r[2];
+          return e[0] = t[0] * n, e[1] = t[1] * n, e[2] = t[2] * n, e[3] = t[3] * n, e[4] = t[4] * i, e[5] = t[5] * i, e[6] = t[6] * i, e[7] = t[7] * i, e[8] = t[8] * a, e[9] = t[9] * a, e[10] = t[10] * a, e[11] = t[11] * a, e[12] = t[12], e[13] = t[13], e[14] = t[14], e[15] = t[15], e;
+        }
+      });
+      var Gte = ye((rir, Vte) => {
+        Vte.exports = grt;
+        function grt(e, t, r, n) {
+          var i = n[0], a = n[1], o = n[2], s = Math.sqrt(i * i + a * a + o * o), l, u, c, f, h, d, v, _, b, p, k, E, T, L, x, C, M, g, P, A, z, O, U, G;
+          return Math.abs(s) < 1e-6 ? null : (s = 1 / s, i *= s, a *= s, o *= s, l = Math.sin(r), u = Math.cos(r), c = 1 - u, f = t[0], h = t[1], d = t[2], v = t[3], _ = t[4], b = t[5], p = t[6], k = t[7], E = t[8], T = t[9], L = t[10], x = t[11], C = i * i * c + u, M = a * i * c + o * l, g = o * i * c - a * l, P = i * a * c - o * l, A = a * a * c + u, z = o * a * c + i * l, O = i * o * c + a * l, U = a * o * c - i * l, G = o * o * c + u, e[0] = f * C + _ * M + E * g, e[1] = h * C + b * M + T * g, e[2] = d * C + p * M + L * g, e[3] = v * C + k * M + x * g, e[4] = f * P + _ * A + E * z, e[5] = h * P + b * A + T * z, e[6] = d * P + p * A + L * z, e[7] = v * P + k * A + x * z, e[8] = f * O + _ * U + E * G, e[9] = h * O + b * U + T * G, e[10] = d * O + p * U + L * G, e[11] = v * O + k * U + x * G, t !== e && (e[12] = t[12], e[13] = t[13], e[14] = t[14], e[15] = t[15]), e);
+        }
+      });
+      var jte = ye((iir, Hte) => {
+        Hte.exports = mrt;
+        function mrt(e, t, r) {
+          var n = Math.sin(r), i = Math.cos(r), a = t[4], o = t[5], s = t[6], l = t[7], u = t[8], c = t[9], f = t[10], h = t[11];
+          return t !== e && (e[0] = t[0], e[1] = t[1], e[2] = t[2], e[3] = t[3], e[12] = t[12], e[13] = t[13], e[14] = t[14], e[15] = t[15]), e[4] = a * i + u * n, e[5] = o * i + c * n, e[6] = s * i + f * n, e[7] = l * i + h * n, e[8] = u * i - a * n, e[9] = c * i - o * n, e[10] = f * i - s * n, e[11] = h * i - l * n, e;
+        }
+      });
+      var Xte = ye((nir, Wte) => {
+        Wte.exports = yrt;
+        function yrt(e, t, r) {
+          var n = Math.sin(r), i = Math.cos(r), a = t[0], o = t[1], s = t[2], l = t[3], u = t[8], c = t[9], f = t[10], h = t[11];
+          return t !== e && (e[4] = t[4], e[5] = t[5], e[6] = t[6], e[7] = t[7], e[12] = t[12], e[13] = t[13], e[14] = t[14], e[15] = t[15]), e[0] = a * i - u * n, e[1] = o * i - c * n, e[2] = s * i - f * n, e[3] = l * i - h * n, e[8] = a * n + u * i, e[9] = o * n + c * i, e[10] = s * n + f * i, e[11] = l * n + h * i, e;
+        }
+      });
+      var Yte = ye((air, Zte) => {
+        Zte.exports = _rt;
+        function _rt(e, t, r) {
+          var n = Math.sin(r), i = Math.cos(r), a = t[0], o = t[1], s = t[2], l = t[3], u = t[4], c = t[5], f = t[6], h = t[7];
+          return t !== e && (e[8] = t[8], e[9] = t[9], e[10] = t[10], e[11] = t[11], e[12] = t[12], e[13] = t[13], e[14] = t[14], e[15] = t[15]), e[0] = a * i + u * n, e[1] = o * i + c * n, e[2] = s * i + f * n, e[3] = l * i + h * n, e[4] = u * i - a * n, e[5] = c * i - o * n, e[6] = f * i - s * n, e[7] = h * i - l * n, e;
+        }
+      });
+      var Jte = ye((oir, Kte) => {
+        Kte.exports = xrt;
+        function xrt(e, t, r) {
+          var n, i, a, o = r[0], s = r[1], l = r[2], u = Math.sqrt(o * o + s * s + l * l);
+          return Math.abs(u) < 1e-6 ? null : (u = 1 / u, o *= u, s *= u, l *= u, n = Math.sin(t), i = Math.cos(t), a = 1 - i, e[0] = o * o * a + i, e[1] = s * o * a + l * n, e[2] = l * o * a - s * n, e[3] = 0, e[4] = o * s * a - l * n, e[5] = s * s * a + i, e[6] = l * s * a + o * n, e[7] = 0, e[8] = o * l * a + s * n, e[9] = s * l * a - o * n, e[10] = l * l * a + i, e[11] = 0, e[12] = 0, e[13] = 0, e[14] = 0, e[15] = 1, e);
+        }
+      });
+      var Qte = ye((sir, $te) => {
+        $te.exports = brt;
+        function brt(e, t, r) {
+          var n = t[0], i = t[1], a = t[2], o = t[3], s = n + n, l = i + i, u = a + a, c = n * s, f = n * l, h = n * u, d = i * l, v = i * u, _ = a * u, b = o * s, p = o * l, k = o * u;
+          return e[0] = 1 - (d + _), e[1] = f + k, e[2] = h - p, e[3] = 0, e[4] = f - k, e[5] = 1 - (c + _), e[6] = v + b, e[7] = 0, e[8] = h + p, e[9] = v - b, e[10] = 1 - (c + d), e[11] = 0, e[12] = r[0], e[13] = r[1], e[14] = r[2], e[15] = 1, e;
+        }
+      });
+      var tre = ye((lir, ere) => {
+        ere.exports = wrt;
+        function wrt(e, t) {
+          return e[0] = t[0], e[1] = 0, e[2] = 0, e[3] = 0, e[4] = 0, e[5] = t[1], e[6] = 0, e[7] = 0, e[8] = 0, e[9] = 0, e[10] = t[2], e[11] = 0, e[12] = 0, e[13] = 0, e[14] = 0, e[15] = 1, e;
+        }
+      });
+      var ire = ye((uir, rre) => {
+        rre.exports = Trt;
+        function Trt(e, t) {
+          return e[0] = 1, e[1] = 0, e[2] = 0, e[3] = 0, e[4] = 0, e[5] = 1, e[6] = 0, e[7] = 0, e[8] = 0, e[9] = 0, e[10] = 1, e[11] = 0, e[12] = t[0], e[13] = t[1], e[14] = t[2], e[15] = 1, e;
+        }
+      });
+      var are = ye((cir, nre) => {
+        nre.exports = Art;
+        function Art(e, t) {
+          var r = Math.sin(t), n = Math.cos(t);
+          return e[0] = 1, e[1] = 0, e[2] = 0, e[3] = 0, e[4] = 0, e[5] = n, e[6] = r, e[7] = 0, e[8] = 0, e[9] = -r, e[10] = n, e[11] = 0, e[12] = 0, e[13] = 0, e[14] = 0, e[15] = 1, e;
+        }
+      });
+      var sre = ye((fir, ore) => {
+        ore.exports = Srt;
+        function Srt(e, t) {
+          var r = Math.sin(t), n = Math.cos(t);
+          return e[0] = n, e[1] = 0, e[2] = -r, e[3] = 0, e[4] = 0, e[5] = 1, e[6] = 0, e[7] = 0, e[8] = r, e[9] = 0, e[10] = n, e[11] = 0, e[12] = 0, e[13] = 0, e[14] = 0, e[15] = 1, e;
+        }
+      });
+      var ure = ye((hir, lre) => {
+        lre.exports = Mrt;
+        function Mrt(e, t) {
+          var r = Math.sin(t), n = Math.cos(t);
+          return e[0] = n, e[1] = r, e[2] = 0, e[3] = 0, e[4] = -r, e[5] = n, e[6] = 0, e[7] = 0, e[8] = 0, e[9] = 0, e[10] = 1, e[11] = 0, e[12] = 0, e[13] = 0, e[14] = 0, e[15] = 1, e;
+        }
+      });
+      var fre = ye((dir, cre) => {
+        cre.exports = Ert;
+        function Ert(e, t) {
+          var r = t[0], n = t[1], i = t[2], a = t[3], o = r + r, s = n + n, l = i + i, u = r * o, c = n * o, f = n * s, h = i * o, d = i * s, v = i * l, _ = a * o, b = a * s, p = a * l;
+          return e[0] = 1 - f - v, e[1] = c + p, e[2] = h - b, e[3] = 0, e[4] = c - p, e[5] = 1 - u - v, e[6] = d + _, e[7] = 0, e[8] = h + b, e[9] = d - _, e[10] = 1 - u - f, e[11] = 0, e[12] = 0, e[13] = 0, e[14] = 0, e[15] = 1, e;
+        }
+      });
+      var dre = ye((vir, hre) => {
+        hre.exports = krt;
+        function krt(e, t, r, n, i, a, o) {
+          var s = 1 / (r - t), l = 1 / (i - n), u = 1 / (a - o);
+          return e[0] = a * 2 * s, e[1] = 0, e[2] = 0, e[3] = 0, e[4] = 0, e[5] = a * 2 * l, e[6] = 0, e[7] = 0, e[8] = (r + t) * s, e[9] = (i + n) * l, e[10] = (o + a) * u, e[11] = -1, e[12] = 0, e[13] = 0, e[14] = o * a * 2 * u, e[15] = 0, e;
+        }
+      });
+      var pre = ye((pir, vre) => {
+        vre.exports = Crt;
+        function Crt(e, t, r, n, i) {
+          var a = 1 / Math.tan(t / 2), o = 1 / (n - i);
+          return e[0] = a / r, e[1] = 0, e[2] = 0, e[3] = 0, e[4] = 0, e[5] = a, e[6] = 0, e[7] = 0, e[8] = 0, e[9] = 0, e[10] = (i + n) * o, e[11] = -1, e[12] = 0, e[13] = 0, e[14] = 2 * i * n * o, e[15] = 0, e;
+        }
+      });
+      var mre = ye((gir, gre) => {
+        gre.exports = Lrt;
+        function Lrt(e, t, r, n) {
+          var i = Math.tan(t.upDegrees * Math.PI / 180), a = Math.tan(t.downDegrees * Math.PI / 180), o = Math.tan(t.leftDegrees * Math.PI / 180), s = Math.tan(t.rightDegrees * Math.PI / 180), l = 2 / (o + s), u = 2 / (i + a);
+          return e[0] = l, e[1] = 0, e[2] = 0, e[3] = 0, e[4] = 0, e[5] = u, e[6] = 0, e[7] = 0, e[8] = -((o - s) * l * 0.5), e[9] = (i - a) * u * 0.5, e[10] = n / (r - n), e[11] = -1, e[12] = 0, e[13] = 0, e[14] = n * r / (r - n), e[15] = 0, e;
+        }
+      });
+      var _re = ye((mir, yre) => {
+        yre.exports = Prt;
+        function Prt(e, t, r, n, i, a, o) {
+          var s = 1 / (t - r), l = 1 / (n - i), u = 1 / (a - o);
+          return e[0] = -2 * s, e[1] = 0, e[2] = 0, e[3] = 0, e[4] = 0, e[5] = -2 * l, e[6] = 0, e[7] = 0, e[8] = 0, e[9] = 0, e[10] = 2 * u, e[11] = 0, e[12] = (t + r) * s, e[13] = (i + n) * l, e[14] = (o + a) * u, e[15] = 1, e;
+        }
+      });
+      var bre = ye((yir, xre) => {
+        var Irt = UO();
+        xre.exports = Rrt;
+        function Rrt(e, t, r, n) {
+          var i, a, o, s, l, u, c, f, h, d, v = t[0], _ = t[1], b = t[2], p = n[0], k = n[1], E = n[2], T = r[0], L = r[1], x = r[2];
+          return Math.abs(v - T) < 1e-6 && Math.abs(_ - L) < 1e-6 && Math.abs(b - x) < 1e-6 ? Irt(e) : (c = v - T, f = _ - L, h = b - x, d = 1 / Math.sqrt(c * c + f * f + h * h), c *= d, f *= d, h *= d, i = k * h - E * f, a = E * c - p * h, o = p * f - k * c, d = Math.sqrt(i * i + a * a + o * o), d ? (d = 1 / d, i *= d, a *= d, o *= d) : (i = 0, a = 0, o = 0), s = f * o - h * a, l = h * i - c * o, u = c * a - f * i, d = Math.sqrt(s * s + l * l + u * u), d ? (d = 1 / d, s *= d, l *= d, u *= d) : (s = 0, l = 0, u = 0), e[0] = i, e[1] = s, e[2] = c, e[3] = 0, e[4] = a, e[5] = l, e[6] = f, e[7] = 0, e[8] = o, e[9] = u, e[10] = h, e[11] = 0, e[12] = -(i * v + a * _ + o * b), e[13] = -(s * v + l * _ + u * b), e[14] = -(c * v + f * _ + h * b), e[15] = 1, e);
+        }
+      });
+      var Tre = ye((_ir, wre) => {
+        wre.exports = Drt;
+        function Drt(e) {
+          return "mat4(" + e[0] + ", " + e[1] + ", " + e[2] + ", " + e[3] + ", " + e[4] + ", " + e[5] + ", " + e[6] + ", " + e[7] + ", " + e[8] + ", " + e[9] + ", " + e[10] + ", " + e[11] + ", " + e[12] + ", " + e[13] + ", " + e[14] + ", " + e[15] + ")";
+        }
+      });
+      var VO = ye((xir, Are) => {
+        Are.exports = { create: wte(), clone: Ate(), copy: Mte(), identity: UO(), transpose: Cte(), invert: Pte(), adjoint: Rte(), determinant: Fte(), multiply: Ote(), translate: Bte(), scale: Ute(), rotate: Gte(), rotateX: jte(), rotateY: Xte(), rotateZ: Yte(), fromRotation: Jte(), fromRotationTranslation: Qte(), fromScaling: tre(), fromTranslation: ire(), fromXRotation: are(), fromYRotation: sre(), fromZRotation: ure(), fromQuat: fre(), frustum: dre(), perspective: pre(), perspectiveFromFieldOfView: mre(), ortho: _re(), lookAt: bre(), str: Tre() };
+      });
+      var P6 = ye((fh) => {
+        var Frt = VO();
+        fh.init2dArray = function(e, t) {
+          for (var r = new Array(e), n = 0; n < e; n++) r[n] = new Array(t);
+          return r;
+        };
+        fh.transposeRagged = function(e) {
+          var t = 0, r = e.length, n, i;
+          for (n = 0; n < r; n++) t = Math.max(t, e[n].length);
+          var a = new Array(t);
+          for (n = 0; n < t; n++) for (a[n] = new Array(r), i = 0; i < r; i++) a[n][i] = e[i][n];
+          return a;
+        };
+        fh.dot = function(e, t) {
+          if (!(e.length && t.length) || e.length !== t.length) return null;
+          var r = e.length, n, i;
+          if (e[0].length) for (n = new Array(r), i = 0; i < r; i++) n[i] = fh.dot(e[i], t);
+          else if (t[0].length) {
+            var a = fh.transposeRagged(t);
+            for (n = new Array(a.length), i = 0; i < a.length; i++) n[i] = fh.dot(e, a[i]);
+          } else for (n = 0, i = 0; i < r; i++) n += e[i] * t[i];
+          return n;
+        };
+        fh.translationMatrix = function(e, t) {
+          return [[1, 0, e], [0, 1, t], [0, 0, 1]];
+        };
+        fh.rotationMatrix = function(e) {
+          var t = e * Math.PI / 180;
+          return [[Math.cos(t), -Math.sin(t), 0], [Math.sin(t), Math.cos(t), 0], [0, 0, 1]];
+        };
+        fh.rotationXYMatrix = function(e, t, r) {
+          return fh.dot(fh.dot(fh.translationMatrix(t, r), fh.rotationMatrix(e)), fh.translationMatrix(-t, -r));
+        };
+        fh.apply3DTransform = function(e) {
+          return function() {
+            var t = arguments, r = arguments.length === 1 ? t[0] : [t[0], t[1], t[2] || 0];
+            return fh.dot(e, [r[0], r[1], r[2], 1]).slice(0, 3);
+          };
+        };
+        fh.apply2DTransform = function(e) {
+          return function() {
+            var t = arguments;
+            t.length === 3 && (t = t[0]);
+            var r = arguments.length === 1 ? t[0] : [t[0], t[1]];
+            return fh.dot(e, [r[0], r[1], 1]).slice(0, 2);
+          };
+        };
+        fh.apply2DTransform2 = function(e) {
+          var t = fh.apply2DTransform(e);
+          return function(r) {
+            return t(r.slice(0, 2)).concat(t(r.slice(2, 4)));
+          };
+        };
+        fh.convertCssMatrix = function(e) {
+          if (e) {
+            var t = e.length;
+            if (t === 16) return e;
+            if (t === 6) return [e[0], e[1], 0, 0, e[2], e[3], 0, 0, 0, 0, 1, 0, e[4], e[5], 0, 1];
+          }
+          return [1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1];
+        };
+        fh.inverseTransformMatrix = function(e) {
+          var t = [];
+          return Frt.invert(t, e), [[t[0], t[1], t[2], t[3]], [t[4], t[5], t[6], t[7]], [t[8], t[9], t[10], t[11]], [t[12], t[13], t[14], t[15]]];
+        };
+      });
+      var HS = ye((wir, Lre) => {
+        var zrt = Oa(), Sre = K1(), Ort = P6(), qrt = VO();
+        function Brt(e) {
+          var t;
+          if (typeof e == "string") {
+            if (t = document.getElementById(e), t === null) throw new Error("No DOM element with id '" + e + "' exists on the page.");
+            return t;
+          } else if (e == null) throw new Error("DOM element provided is null or undefined");
+          return e;
+        }
+        function Nrt(e) {
+          var t = zrt.select(e);
+          return t.node() instanceof HTMLElement && t.size() && t.classed("js-plotly-plot");
+        }
+        function Mre(e) {
+          var t = e && e.parentNode;
+          t && t.removeChild(e);
+        }
+        function Urt(e, t) {
+          Ere("global", e, t);
+        }
+        function Ere(e, t, r) {
+          var n = "plotly.js-style-" + e, i = document.getElementById(n);
+          if (!(i && i.matches(".no-inline-styles"))) {
+            i || (i = document.createElement("style"), i.setAttribute("id", n), i.appendChild(document.createTextNode("")), document.head.appendChild(i));
+            var a = i.sheet;
+            a ? a.insertRule ? a.insertRule(t + "{" + r + "}", 0) : a.addRule ? a.addRule(t, r, 0) : Sre.warn("addStyleRule failed") : Sre.warn("Cannot addRelatedStyleRule, probably due to strict CSP...");
+          }
+        }
+        function Vrt(e) {
+          var t = "plotly.js-style-" + e, r = document.getElementById(t);
+          r && Mre(r);
+        }
+        function Grt(e, t, r, n, i, a) {
+          var o = n.split(":"), s = i.split(":"), l = "data-btn-style-event-added";
+          a || (a = document), a.querySelectorAll(e).forEach(function(u) {
+            u.getAttribute(l) || (u.addEventListener("mouseenter", function() {
+              var c = this.querySelector(r);
+              c && (c.style[o[0]] = o[1]);
+            }), u.addEventListener("mouseleave", function() {
+              var c = this.querySelector(r);
+              c && (t && this.matches(t) ? c.style[o[0]] = o[1] : c.style[s[0]] = s[1]);
+            }), u.setAttribute(l, true));
+          });
+        }
+        function Hrt(e) {
+          var t = Cre(e), r = [1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1];
+          return t.forEach(function(n) {
+            var i = kre(n);
+            if (i) {
+              var a = Ort.convertCssMatrix(i);
+              r = qrt.multiply(r, r, a);
+            }
+          }), r;
+        }
+        function kre(e) {
+          var t = window.getComputedStyle(e, null), r = t.getPropertyValue("-webkit-transform") || t.getPropertyValue("-moz-transform") || t.getPropertyValue("-ms-transform") || t.getPropertyValue("-o-transform") || t.getPropertyValue("transform");
+          return r === "none" ? null : r.replace("matrix", "").replace("3d", "").slice(1, -1).split(",").map(function(n) {
+            return +n;
+          });
+        }
+        function Cre(e) {
+          for (var t = []; jrt(e); ) t.push(e), e = e.parentNode, typeof ShadowRoot == "function" && e instanceof ShadowRoot && (e = e.host);
+          return t;
+        }
+        function jrt(e) {
+          return e && (e instanceof Element || e instanceof HTMLElement);
+        }
+        function Wrt(e, t) {
+          return e && t && e.top === t.top && e.left === t.left && e.right === t.right && e.bottom === t.bottom;
+        }
+        Lre.exports = { getGraphDiv: Brt, isPlotDiv: Nrt, removeElement: Mre, addStyleRule: Urt, addRelatedStyleRule: Ere, deleteRelatedStyleRule: Vrt, setStyleOnHover: Grt, getFullTransformMatrix: Hrt, getElementTransformMatrix: kre, getElementAndAncestors: Cre, equalDomRects: Wrt };
+      });
+      var jS = ye((Tir, Pre) => {
+        Pre.exports = { mode: { valType: "enumerated", dflt: "afterall", values: ["immediate", "next", "afterall"] }, direction: { valType: "enumerated", values: ["forward", "reverse"], dflt: "forward" }, fromcurrent: { valType: "boolean", dflt: false }, frame: { duration: { valType: "number", min: 0, dflt: 500 }, redraw: { valType: "boolean", dflt: true } }, transition: { duration: { valType: "number", min: 0, dflt: 500, editType: "none" }, easing: { valType: "enumerated", dflt: "cubic-in-out", values: ["linear", "quad", "cubic", "sin", "exp", "circle", "elastic", "back", "bounce", "linear-in", "quad-in", "cubic-in", "sin-in", "exp-in", "circle-in", "elastic-in", "back-in", "bounce-in", "linear-out", "quad-out", "cubic-out", "sin-out", "exp-out", "circle-out", "elastic-out", "back-out", "bounce-out", "linear-in-out", "quad-in-out", "cubic-in-out", "sin-in-out", "exp-in-out", "circle-in-out", "elastic-in-out", "back-in-out", "bounce-in-out"], editType: "none" }, ordering: { valType: "enumerated", values: ["layout first", "traces first"], dflt: "layout first", editType: "none" } } };
+      });
+      var mc = ye((Air, qre) => {
+        var Rre = Ao().extendFlat, Xrt = Ty(), Dre = { valType: "flaglist", extras: ["none"], flags: ["calc", "clearAxisTypes", "plot", "style", "markerSize", "colorbars"] }, Fre = { valType: "flaglist", extras: ["none"], flags: ["calc", "plot", "legend", "ticks", "axrange", "layoutstyle", "modebar", "camera", "arraydraw", "colorbars"] }, Zrt = Dre.flags.slice().concat(["fullReplot"]), Yrt = Fre.flags.slice().concat("layoutReplot");
+        qre.exports = { traces: Dre, layout: Fre, traceFlags: function() {
+          return Ire(Zrt);
+        }, layoutFlags: function() {
+          return Ire(Yrt);
+        }, update: function(e, t) {
+          var r = t.editType;
+          if (r && r !== "none") for (var n = r.split("+"), i = 0; i < n.length; i++) e[n[i]] = true;
+        }, overrideAll: zre };
+        function Ire(e) {
+          for (var t = {}, r = 0; r < e.length; r++) t[e[r]] = false;
+          return t;
+        }
+        function zre(e, t, r) {
+          var n = Rre({}, e);
+          for (var i in n) {
+            var a = n[i];
+            Xrt(a) && (n[i] = Ore(a, t, r, i));
+          }
+          return r === "from-root" && (n.editType = t), n;
+        }
+        function Ore(e, t, r, n) {
+          if (e.valType) {
+            var i = Rre({}, e);
+            if (i.editType = t, Array.isArray(e.items)) {
+              i.items = new Array(e.items.length);
+              for (var a = 0; a < e.items.length; a++) i.items[a] = Ore(e.items[a], t);
+            }
+            return i;
+          } else return zre(e, t, n.charAt(0) === "_" ? "nested" : "from-root");
+        }
+      });
+      var Pd = ye((GO) => {
+        GO.dash = { valType: "string", values: ["solid", "dot", "dash", "longdash", "dashdot", "longdashdot"], dflt: "solid", editType: "style" };
+        GO.pattern = { shape: { valType: "enumerated", values: ["", "/", "\\", "x", "-", "|", "+", "."], dflt: "", arrayOk: true, editType: "style" }, path: { valType: "string", arrayOk: true, editType: "style" }, fillmode: { valType: "enumerated", values: ["replace", "overlay"], dflt: "replace", editType: "style" }, bgcolor: { valType: "color", arrayOk: true, editType: "style" }, fgcolor: { valType: "color", arrayOk: true, editType: "style" }, fgopacity: { valType: "number", editType: "style", min: 0, max: 1 }, size: { valType: "number", min: 0, dflt: 8, arrayOk: true, editType: "style" }, solidity: { valType: "number", min: 0, max: 1, dflt: 0.3, arrayOk: true, editType: "style" }, editType: "style" };
+      });
+      var HO = ye((Mir, Bre) => {
+        Bre.exports = { FORMAT_LINK: "https://github.com/d3/d3-format/tree/v1.4.5#d3-format", DATE_FORMAT_LINK: "https://github.com/d3/d3-time-format/tree/v2.2.3#locale_format" };
+      });
+      var Ll = ye((y3) => {
+        var { DATE_FORMAT_LINK: Krt, FORMAT_LINK: Jrt } = HO(), $rt = ["Variables that can't be found will be replaced with the specifier.", 'For example, a template of "data: %{x}, %{y}" will result in a value of "data: 1, %{y}" if x is 1 and y is missing.', "Variables with an undefined value will be replaced with the fallback value."].join(" ");
+        function Qrt({ supportOther: e } = {}) {
+          return ["Variables are inserted using %{variable},", 'for example "y: %{y}"' + (e ? " as well as %{xother}, {%_xother}, {%_xother_}, {%xother_}. When showing info for several points, *xother* will be added to those with different x positions from the first point. An underscore before or after *(x|y)other* will add a space on that side, only when this field is shown." : "."), `Numbers are formatted using d3-format's syntax %{variable:d3-format}, for example "Price: %{y:$.2f}".`, Jrt, "for details on the formatting syntax.", `Dates are formatted using d3-time-format's syntax %{variable|d3-time-format}, for example "Day: %{2019-01-01|%A}".`, Krt, "for details on the date formatting syntax.", $rt].join(" ");
+        }
+        y3.templateFormatStringDescription = Qrt;
+        y3.hovertemplateAttrs = ({ editType: e = "none", arrayOk: t } = {}, r = {}) => _g({ valType: "string", dflt: "", editType: e }, t !== false ? { arrayOk: true } : {});
+        y3.texttemplateAttrs = ({ editType: e = "calc", arrayOk: t } = {}, r = {}) => _g({ valType: "string", dflt: "", editType: e }, t !== false ? { arrayOk: true } : {});
+        y3.shapeTexttemplateAttrs = ({ editType: e = "arraydraw", newshape: t } = {}, r = {}) => ({ valType: "string", dflt: "", editType: e });
+        y3.templatefallbackAttrs = ({ editType: e = "none" } = {}) => ({ valType: "any", dflt: "-", editType: e });
+      });
+      var D6 = ye((Cir, jre) => {
+        function J1(e, t) {
+          return t ? t.d2l(e) : e;
+        }
+        function Nre(e, t) {
+          return t ? t.l2d(e) : e;
+        }
+        function eit(e) {
+          return e.x0;
+        }
+        function tit(e) {
+          return e.x1;
+        }
+        function rit(e) {
+          return e.y0;
+        }
+        function iit(e) {
+          return e.y1;
+        }
+        function Ure(e) {
+          return e.x0shift || 0;
+        }
+        function Vre(e) {
+          return e.x1shift || 0;
+        }
+        function Gre(e) {
+          return e.y0shift || 0;
+        }
+        function Hre(e) {
+          return e.y1shift || 0;
+        }
+        function I6(e, t) {
+          return J1(e.x1, t) + Vre(e) - J1(e.x0, t) - Ure(e);
+        }
+        function R6(e, t, r) {
+          return J1(e.y1, r) + Hre(e) - J1(e.y0, r) - Gre(e);
+        }
+        function nit(e, t) {
+          return Math.abs(I6(e, t));
+        }
+        function ait(e, t, r) {
+          return Math.abs(R6(e, t, r));
+        }
+        function oit(e, t, r) {
+          return e.type !== "line" ? void 0 : Math.sqrt(Math.pow(I6(e, t), 2) + Math.pow(R6(e, t, r), 2));
+        }
+        function sit(e, t) {
+          return Nre((J1(e.x1, t) + Vre(e) + J1(e.x0, t) + Ure(e)) / 2, t);
+        }
+        function lit(e, t, r) {
+          return Nre((J1(e.y1, r) + Hre(e) + J1(e.y0, r) + Gre(e)) / 2, r);
+        }
+        function uit(e, t, r) {
+          return e.type !== "line" ? void 0 : R6(e, t, r) / I6(e, t);
+        }
+        var cit = ["x0", "x1", "y0", "y1", "dy", "height", "ycenter"], fit = ["x0", "x1", "y0", "y1", "dx", "width", "xcenter"];
+        jre.exports = { x0: eit, x1: tit, y0: rit, y1: iit, slope: uit, dx: I6, dy: R6, width: nit, height: ait, length: oit, xcenter: sit, ycenter: lit, simpleXVariables: cit, simpleYVariables: fit };
+      });
+      var Zre = ye((Lir, Xre) => {
+        var hit = mc().overrideAll, xb = Gl(), Wre = ec(), dit = Pd().dash, $1 = Ao().extendFlat, { shapeTexttemplateAttrs: vit, templatefallbackAttrs: pit } = Ll(), git = D6();
+        Xre.exports = hit({ newshape: { visible: $1({}, xb.visible, {}), showlegend: { valType: "boolean", dflt: false }, legend: $1({}, xb.legend, {}), legendgroup: $1({}, xb.legendgroup, {}), legendgrouptitle: { text: $1({}, xb.legendgrouptitle.text, {}), font: Wre({}) }, legendrank: $1({}, xb.legendrank, {}), legendwidth: $1({}, xb.legendwidth, {}), line: { color: { valType: "color" }, width: { valType: "number", min: 0, dflt: 4 }, dash: $1({}, dit, { dflt: "solid" }) }, fillcolor: { valType: "color", dflt: "rgba(0,0,0,0)" }, fillrule: { valType: "enumerated", values: ["evenodd", "nonzero"], dflt: "evenodd" }, opacity: { valType: "number", min: 0, max: 1, dflt: 1 }, layer: { valType: "enumerated", values: ["below", "above", "between"], dflt: "above" }, drawdirection: { valType: "enumerated", values: ["ortho", "horizontal", "vertical", "diagonal"], dflt: "diagonal" }, name: $1({}, xb.name, {}), label: { text: { valType: "string", dflt: "" }, texttemplate: vit({ newshape: true }, { keys: Object.keys(git) }), texttemplatefallback: pit({ editType: "arraydraw" }), font: Wre({}), textposition: { valType: "enumerated", values: ["top left", "top center", "top right", "middle left", "middle center", "middle right", "bottom left", "bottom center", "bottom right", "start", "middle", "end"] }, textangle: { valType: "angle", dflt: "auto" }, xanchor: { valType: "enumerated", values: ["auto", "left", "center", "right"], dflt: "auto" }, yanchor: { valType: "enumerated", values: ["top", "middle", "bottom"] }, padding: { valType: "number", dflt: 3, min: 0 } } }, activeshape: { fillcolor: { valType: "color", dflt: "rgb(255,0,255)", description: "Sets the color filling the active shape' interior." }, opacity: { valType: "number", min: 0, max: 1, dflt: 0.5 } } }, "none", "from-root");
+      });
+      var Kre = ye((Pir, Yre) => {
+        var mit = Pd().dash, yit = Ao().extendFlat;
+        Yre.exports = { newselection: { mode: { valType: "enumerated", values: ["immediate", "gradual"], dflt: "immediate", editType: "none" }, line: { color: { valType: "color", editType: "none" }, width: { valType: "number", min: 1, dflt: 1, editType: "none" }, dash: yit({}, mit, { dflt: "dot", editType: "none" }), editType: "none" }, editType: "none" }, activeselection: { fillcolor: { valType: "color", dflt: "rgba(0,0,0,0)", editType: "none" }, opacity: { valType: "number", min: 0, max: 1, dflt: 0.5, editType: "none" }, editType: "none" } };
+      });
+      var F6 = ye((Iir, Jre) => {
+        Jre.exports = function(e) {
+          var t = e.editType;
+          return { t: { valType: "number", dflt: 0, editType: t }, r: { valType: "number", dflt: 0, editType: t }, b: { valType: "number", dflt: 0, editType: t }, l: { valType: "number", dflt: 0, editType: t }, editType: t };
+        };
+      });
+      var _3 = ye((Rir, tie) => {
+        var jO = ec(), _it = jS(), z6 = Ih(), $re = Zre(), Qre = Kre(), xit = F6(), eie = Ao().extendFlat, O6 = jO({ editType: "calc" });
+        O6.family.dflt = '"Open Sans", verdana, arial, sans-serif';
+        O6.size.dflt = 12;
+        O6.color.dflt = z6.defaultLine;
+        tie.exports = { font: O6, title: { text: { valType: "string", editType: "layoutstyle" }, font: jO({ editType: "layoutstyle" }), subtitle: { text: { valType: "string", editType: "layoutstyle" }, font: jO({ editType: "layoutstyle" }), editType: "layoutstyle" }, xref: { valType: "enumerated", dflt: "container", values: ["container", "paper"], editType: "layoutstyle" }, yref: { valType: "enumerated", dflt: "container", values: ["container", "paper"], editType: "layoutstyle" }, x: { valType: "number", min: 0, max: 1, dflt: 0.5, editType: "layoutstyle" }, y: { valType: "number", min: 0, max: 1, dflt: "auto", editType: "layoutstyle" }, xanchor: { valType: "enumerated", dflt: "auto", values: ["auto", "left", "center", "right"], editType: "layoutstyle" }, yanchor: { valType: "enumerated", dflt: "auto", values: ["auto", "top", "middle", "bottom"], editType: "layoutstyle" }, pad: eie(xit({ editType: "layoutstyle" }), {}), automargin: { valType: "boolean", dflt: false, editType: "plot" }, editType: "layoutstyle" }, uniformtext: { mode: { valType: "enumerated", values: [false, "hide", "show"], dflt: false, editType: "plot" }, minsize: { valType: "number", min: 0, dflt: 0, editType: "plot" }, editType: "plot" }, autosize: { valType: "boolean", dflt: false, editType: "none" }, width: { valType: "number", min: 10, dflt: 700, editType: "plot" }, height: { valType: "number", min: 10, dflt: 450, editType: "plot" }, minreducedwidth: { valType: "number", min: 2, dflt: 64, editType: "plot" }, minreducedheight: { valType: "number", min: 2, dflt: 64, editType: "plot" }, margin: { l: { valType: "number", min: 0, dflt: 80, editType: "plot" }, r: { valType: "number", min: 0, dflt: 80, editType: "plot" }, t: { valType: "number", min: 0, dflt: 100, editType: "plot" }, b: { valType: "number", min: 0, dflt: 80, editType: "plot" }, pad: { valType: "number", min: 0, dflt: 0, editType: "plot" }, autoexpand: { valType: "boolean", dflt: true, editType: "plot" }, editType: "plot" }, computed: { valType: "any", editType: "none" }, paper_bgcolor: { valType: "color", dflt: z6.background, editType: "plot" }, plot_bgcolor: { valType: "color", dflt: z6.background, editType: "layoutstyle" }, autotypenumbers: { valType: "enumerated", values: ["convert types", "strict"], dflt: "convert types", editType: "calc" }, separators: { valType: "string", editType: "plot" }, hidesources: { valType: "boolean", dflt: false, editType: "plot" }, showlegend: { valType: "boolean", editType: "legend" }, colorway: { valType: "colorlist", dflt: z6.defaults, editType: "calc" }, datarevision: { valType: "any", editType: "calc" }, uirevision: { valType: "any", editType: "none" }, editrevision: { valType: "any", editType: "none" }, selectionrevision: { valType: "any", editType: "none" }, template: { valType: "any", editType: "calc" }, newshape: $re.newshape, activeshape: $re.activeshape, newselection: Qre.newselection, activeselection: Qre.activeselection, meta: { valType: "any", arrayOk: true, editType: "plot" }, transition: eie({}, _it.transition, { editType: "none" }) };
+      });
+      var rie = ye(() => {
+        (function() {
+          if (!document.getElementById("a75c73da1cd7a97e8992659f6aed556255838daadea9ca0c9fc3af7f1ddf63c0")) {
+            var e = document.createElement("style");
+            e.id = "a75c73da1cd7a97e8992659f6aed556255838daadea9ca0c9fc3af7f1ddf63c0", e.textContent = `.maplibregl-map{font:12px/20px Helvetica Neue,Arial,Helvetica,sans-serif;overflow:hidden;position:relative;-webkit-tap-highlight-color:rgb(0 0 0/0)}.maplibregl-canvas{left:0;position:absolute;top:0}.maplibregl-map:fullscreen{height:100%;width:100%}.maplibregl-ctrl-group button.maplibregl-ctrl-compass{touch-action:none}.maplibregl-canvas-container.maplibregl-interactive,.maplibregl-ctrl-group button.maplibregl-ctrl-compass{cursor:grab;-webkit-user-select:none;-moz-user-select:none;user-select:none}.maplibregl-canvas-container.maplibregl-interactive.maplibregl-track-pointer{cursor:pointer}.maplibregl-canvas-container.maplibregl-interactive:active,.maplibregl-ctrl-group button.maplibregl-ctrl-compass:active{cursor:grabbing}.maplibregl-canvas-container.maplibregl-touch-zoom-rotate,.maplibregl-canvas-container.maplibregl-touch-zoom-rotate .maplibregl-canvas{touch-action:pan-x pan-y}.maplibregl-canvas-container.maplibregl-touch-drag-pan,.maplibregl-canvas-container.maplibregl-touch-drag-pan .maplibregl-canvas{touch-action:pinch-zoom}.maplibregl-canvas-container.maplibregl-touch-zoom-rotate.maplibregl-touch-drag-pan,.maplibregl-canvas-container.maplibregl-touch-zoom-rotate.maplibregl-touch-drag-pan .maplibregl-canvas{touch-action:none}.maplibregl-canvas-container.maplibregl-touch-drag-pan.maplibregl-cooperative-gestures,.maplibregl-canvas-container.maplibregl-touch-drag-pan.maplibregl-cooperative-gestures .maplibregl-canvas{touch-action:pan-x pan-y}.maplibregl-ctrl-bottom-left,.maplibregl-ctrl-bottom-right,.maplibregl-ctrl-top-left,.maplibregl-ctrl-top-right{pointer-events:none;position:absolute;z-index:2}.maplibregl-ctrl-top-left{left:0;top:0}.maplibregl-ctrl-top-right{right:0;top:0}.maplibregl-ctrl-bottom-left{bottom:0;left:0}.maplibregl-ctrl-bottom-right{bottom:0;right:0}.maplibregl-ctrl{clear:both;pointer-events:auto;transform:translate(0)}.maplibregl-ctrl-top-left .maplibregl-ctrl{float:left;margin:10px 0 0 10px}.maplibregl-ctrl-top-right .maplibregl-ctrl{float:right;margin:10px 10px 0 0}.maplibregl-ctrl-bottom-left .maplibregl-ctrl{float:left;margin:0 0 10px 10px}.maplibregl-ctrl-bottom-right .maplibregl-ctrl{float:right;margin:0 10px 10px 0}.maplibregl-ctrl-group{background:#fff;border-radius:4px}.maplibregl-ctrl-group:not(:empty){box-shadow:0 0 0 2px rgba(0,0,0,.1)}@media (forced-colors:active){.maplibregl-ctrl-group:not(:empty){box-shadow:0 0 0 2px ButtonText}}.maplibregl-ctrl-group button{background-color:transparent;border:0;box-sizing:border-box;cursor:pointer;display:block;height:29px;outline:none;padding:0;width:29px}.maplibregl-ctrl-group button+button{border-top:1px solid #ddd}.maplibregl-ctrl button .maplibregl-ctrl-icon{background-position:50%;background-repeat:no-repeat;display:block;height:100%;width:100%}@media (forced-colors:active){.maplibregl-ctrl-icon{background-color:transparent}.maplibregl-ctrl-group button+button{border-top:1px solid ButtonText}}.maplibregl-ctrl button::-moz-focus-inner{border:0;padding:0}.maplibregl-ctrl-attrib-button:focus,.maplibregl-ctrl-group button:focus{box-shadow:0 0 2px 2px #0096ff}.maplibregl-ctrl button:disabled{cursor:not-allowed}.maplibregl-ctrl button:disabled .maplibregl-ctrl-icon{opacity:.25}.maplibregl-ctrl button:not(:disabled):hover{background-color:rgb(0 0 0/5%)}.maplibregl-ctrl-group button:focus:focus-visible{box-shadow:0 0 2px 2px #0096ff}.maplibregl-ctrl-group button:focus:not(:focus-visible){box-shadow:none}.maplibregl-ctrl-group button:focus:first-child{border-radius:4px 4px 0 0}.maplibregl-ctrl-group button:focus:last-child{border-radius:0 0 4px 4px}.maplibregl-ctrl-group button:focus:only-child{border-radius:inherit}.maplibregl-ctrl button.maplibregl-ctrl-zoom-out .maplibregl-ctrl-icon{background-image:url("data:image/svg+xml;charset=utf-8,%3Csvg xmlns='http://www.w3.org/2000/svg' width='29' height='29' fill='%23333' viewBox='0 0 29 29'%3E%3Cpath d='M10 13c-.75 0-1.5.75-1.5 1.5S9.25 16 10 16h9c.75 0 1.5-.75 1.5-1.5S19.75 13 19 13z'/%3E%3C/svg%3E")}.maplibregl-ctrl button.maplibregl-ctrl-zoom-in .maplibregl-ctrl-icon{background-image:url("data:image/svg+xml;charset=utf-8,%3Csvg xmlns='http://www.w3.org/2000/svg' width='29' height='29' fill='%23333' viewBox='0 0 29 29'%3E%3Cpath d='M14.5 8.5c-.75 0-1.5.75-1.5 1.5v3h-3c-.75 0-1.5.75-1.5 1.5S9.25 16 10 16h3v3c0 .75.75 1.5 1.5 1.5S16 19.75 16 19v-3h3c.75 0 1.5-.75 1.5-1.5S19.75 13 19 13h-3v-3c0-.75-.75-1.5-1.5-1.5'/%3E%3C/svg%3E")}@media (forced-colors:active){.maplibregl-ctrl button.maplibregl-ctrl-zoom-out .maplibregl-ctrl-icon{background-image:url("data:image/svg+xml;charset=utf-8,%3Csvg xmlns='http://www.w3.org/2000/svg' width='29' height='29' fill='%23fff' viewBox='0 0 29 29'%3E%3Cpath d='M10 13c-.75 0-1.5.75-1.5 1.5S9.25 16 10 16h9c.75 0 1.5-.75 1.5-1.5S19.75 13 19 13z'/%3E%3C/svg%3E")}.maplibregl-ctrl button.maplibregl-ctrl-zoom-in .maplibregl-ctrl-icon{background-image:url("data:image/svg+xml;charset=utf-8,%3Csvg xmlns='http://www.w3.org/2000/svg' width='29' height='29' fill='%23fff' viewBox='0 0 29 29'%3E%3Cpath d='M14.5 8.5c-.75 0-1.5.75-1.5 1.5v3h-3c-.75 0-1.5.75-1.5 1.5S9.25 16 10 16h3v3c0 .75.75 1.5 1.5 1.5S16 19.75 16 19v-3h3c.75 0 1.5-.75 1.5-1.5S19.75 13 19 13h-3v-3c0-.75-.75-1.5-1.5-1.5'/%3E%3C/svg%3E")}}@media (forced-colors:active) and (prefers-color-scheme:light){.maplibregl-ctrl button.maplibregl-ctrl-zoom-out .maplibregl-ctrl-icon{background-image:url("data:image/svg+xml;charset=utf-8,%3Csvg xmlns='http://www.w3.org/2000/svg' width='29' height='29' viewBox='0 0 29 29'%3E%3Cpath d='M10 13c-.75 0-1.5.75-1.5 1.5S9.25 16 10 16h9c.75 0 1.5-.75 1.5-1.5S19.75 13 19 13z'/%3E%3C/svg%3E")}.maplibregl-ctrl button.maplibregl-ctrl-zoom-in .maplibregl-ctrl-icon{background-image:url("data:image/svg+xml;charset=utf-8,%3Csvg xmlns='http://www.w3.org/2000/svg' width='29' height='29' viewBox='0 0 29 29'%3E%3Cpath d='M14.5 8.5c-.75 0-1.5.75-1.5 1.5v3h-3c-.75 0-1.5.75-1.5 1.5S9.25 16 10 16h3v3c0 .75.75 1.5 1.5 1.5S16 19.75 16 19v-3h3c.75 0 1.5-.75 1.5-1.5S19.75 13 19 13h-3v-3c0-.75-.75-1.5-1.5-1.5'/%3E%3C/svg%3E")}}.maplibregl-ctrl button.maplibregl-ctrl-fullscreen .maplibregl-ctrl-icon{background-image:url("data:image/svg+xml;charset=utf-8,%3Csvg xmlns='http://www.w3.org/2000/svg' width='29' height='29' fill='%23333' viewBox='0 0 29 29'%3E%3Cpath d='M24 16v5.5c0 1.75-.75 2.5-2.5 2.5H16v-1l3-1.5-4-5.5 1-1 5.5 4 1.5-3zM6 16l1.5 3 5.5-4 1 1-4 5.5 3 1.5v1H7.5C5.75 24 5 23.25 5 21.5V16zm7-11v1l-3 1.5 4 5.5-1 1-5.5-4L6 13H5V7.5C5 5.75 5.75 5 7.5 5zm11 2.5c0-1.75-.75-2.5-2.5-2.5H16v1l3 1.5-4 5.5 1 1 5.5-4 1.5 3h1z'/%3E%3C/svg%3E")}.maplibregl-ctrl button.maplibregl-ctrl-shrink .maplibregl-ctrl-icon{background-image:url("data:image/svg+xml;charset=utf-8,%3Csvg xmlns='http://www.w3.org/2000/svg' width='29' height='29' viewBox='0 0 29 29'%3E%3Cpath d='M18.5 16c-1.75 0-2.5.75-2.5 2.5V24h1l1.5-3 5.5 4 1-1-4-5.5 3-1.5v-1zM13 18.5c0-1.75-.75-2.5-2.5-2.5H5v1l3 1.5L4 24l1 1 5.5-4 1.5 3h1zm3-8c0 1.75.75 2.5 2.5 2.5H24v-1l-3-1.5L25 5l-1-1-5.5 4L17 5h-1zM10.5 13c1.75 0 2.5-.75 2.5-2.5V5h-1l-1.5 3L5 4 4 5l4 5.5L5 12v1z'/%3E%3C/svg%3E")}@media (forced-colors:active){.maplibregl-ctrl button.maplibregl-ctrl-fullscreen .maplibregl-ctrl-icon{background-image:url("data:image/svg+xml;charset=utf-8,%3Csvg xmlns='http://www.w3.org/2000/svg' width='29' height='29' fill='%23fff' viewBox='0 0 29 29'%3E%3Cpath d='M24 16v5.5c0 1.75-.75 2.5-2.5 2.5H16v-1l3-1.5-4-5.5 1-1 5.5 4 1.5-3zM6 16l1.5 3 5.5-4 1 1-4 5.5 3 1.5v1H7.5C5.75 24 5 23.25 5 21.5V16zm7-11v1l-3 1.5 4 5.5-1 1-5.5-4L6 13H5V7.5C5 5.75 5.75 5 7.5 5zm11 2.5c0-1.75-.75-2.5-2.5-2.5H16v1l3 1.5-4 5.5 1 1 5.5-4 1.5 3h1z'/%3E%3C/svg%3E")}.maplibregl-ctrl button.maplibregl-ctrl-shrink .maplibregl-ctrl-icon{background-image:url("data:image/svg+xml;charset=utf-8,%3Csvg xmlns='http://www.w3.org/2000/svg' width='29' height='29' fill='%23fff' viewBox='0 0 29 29'%3E%3Cpath d='M18.5 16c-1.75 0-2.5.75-2.5 2.5V24h1l1.5-3 5.5 4 1-1-4-5.5 3-1.5v-1zM13 18.5c0-1.75-.75-2.5-2.5-2.5H5v1l3 1.5L4 24l1 1 5.5-4 1.5 3h1zm3-8c0 1.75.75 2.5 2.5 2.5H24v-1l-3-1.5L25 5l-1-1-5.5 4L17 5h-1zM10.5 13c1.75 0 2.5-.75 2.5-2.5V5h-1l-1.5 3L5 4 4 5l4 5.5L5 12v1z'/%3E%3C/svg%3E")}}@media (forced-colors:active) and (prefers-color-scheme:light){.maplibregl-ctrl button.maplibregl-ctrl-fullscreen .maplibregl-ctrl-icon{background-image:url("data:image/svg+xml;charset=utf-8,%3Csvg xmlns='http://www.w3.org/2000/svg' width='29' height='29' viewBox='0 0 29 29'%3E%3Cpath d='M24 16v5.5c0 1.75-.75 2.5-2.5 2.5H16v-1l3-1.5-4-5.5 1-1 5.5 4 1.5-3zM6 16l1.5 3 5.5-4 1 1-4 5.5 3 1.5v1H7.5C5.75 24 5 23.25 5 21.5V16zm7-11v1l-3 1.5 4 5.5-1 1-5.5-4L6 13H5V7.5C5 5.75 5.75 5 7.5 5zm11 2.5c0-1.75-.75-2.5-2.5-2.5H16v1l3 1.5-4 5.5 1 1 5.5-4 1.5 3h1z'/%3E%3C/svg%3E")}.maplibregl-ctrl button.maplibregl-ctrl-shrink .maplibregl-ctrl-icon{background-image:url("data:image/svg+xml;charset=utf-8,%3Csvg xmlns='http://www.w3.org/2000/svg' width='29' height='29' viewBox='0 0 29 29'%3E%3Cpath d='M18.5 16c-1.75 0-2.5.75-2.5 2.5V24h1l1.5-3 5.5 4 1-1-4-5.5 3-1.5v-1zM13 18.5c0-1.75-.75-2.5-2.5-2.5H5v1l3 1.5L4 24l1 1 5.5-4 1.5 3h1zm3-8c0 1.75.75 2.5 2.5 2.5H24v-1l-3-1.5L25 5l-1-1-5.5 4L17 5h-1zM10.5 13c1.75 0 2.5-.75 2.5-2.5V5h-1l-1.5 3L5 4 4 5l4 5.5L5 12v1z'/%3E%3C/svg%3E")}}.maplibregl-ctrl button.maplibregl-ctrl-compass .maplibregl-ctrl-icon{background-image:url("data:image/svg+xml;charset=utf-8,%3Csvg xmlns='http://www.w3.org/2000/svg' width='29' height='29' fill='%23333' viewBox='0 0 29 29'%3E%3Cpath d='m10.5 14 4-8 4 8z'/%3E%3Cpath fill='%23ccc' d='m10.5 16 4 8 4-8z'/%3E%3C/svg%3E")}@media (forced-colors:active){.maplibregl-ctrl button.maplibregl-ctrl-compass .maplibregl-ctrl-icon{background-image:url("data:image/svg+xml;charset=utf-8,%3Csvg xmlns='http://www.w3.org/2000/svg' width='29' height='29' fill='%23fff' viewBox='0 0 29 29'%3E%3Cpath d='m10.5 14 4-8 4 8z'/%3E%3Cpath fill='%23ccc' d='m10.5 16 4 8 4-8z'/%3E%3C/svg%3E")}}@media (forced-colors:active) and (prefers-color-scheme:light){.maplibregl-ctrl button.maplibregl-ctrl-compass .maplibregl-ctrl-icon{background-image:url("data:image/svg+xml;charset=utf-8,%3Csvg xmlns='http://www.w3.org/2000/svg' width='29' height='29' viewBox='0 0 29 29'%3E%3Cpath d='m10.5 14 4-8 4 8z'/%3E%3Cpath fill='%23ccc' d='m10.5 16 4 8 4-8z'/%3E%3C/svg%3E")}}.maplibregl-ctrl button.maplibregl-ctrl-terrain .maplibregl-ctrl-icon{background-image:url("data:image/svg+xml;charset=utf-8,%3Csvg xmlns='http://www.w3.org/2000/svg' width='22' height='22' fill='%23333' viewBox='0 0 22 22'%3E%3Cpath d='m1.754 13.406 4.453-4.851 3.09 3.09 3.281 3.277.969-.969-3.309-3.312 3.844-4.121 6.148 6.886h1.082v-.855l-7.207-8.07-4.84 5.187L6.169 6.57l-5.48 5.965v.871ZM.688 16.844h20.625v1.375H.688Zm0 0'/%3E%3C/svg%3E")}.maplibregl-ctrl button.maplibregl-ctrl-terrain-enabled .maplibregl-ctrl-icon{background-image:url("data:image/svg+xml;charset=utf-8,%3Csvg xmlns='http://www.w3.org/2000/svg' width='22' height='22' fill='%2333b5e5' viewBox='0 0 22 22'%3E%3Cpath d='m1.754 13.406 4.453-4.851 3.09 3.09 3.281 3.277.969-.969-3.309-3.312 3.844-4.121 6.148 6.886h1.082v-.855l-7.207-8.07-4.84 5.187L6.169 6.57l-5.48 5.965v.871ZM.688 16.844h20.625v1.375H.688Zm0 0'/%3E%3C/svg%3E")}.maplibregl-ctrl button.maplibregl-ctrl-geolocate .maplibregl-ctrl-icon{background-image:url("data:image/svg+xml;charset=utf-8,%3Csvg xmlns='http://www.w3.org/2000/svg' width='29' height='29' fill='%23333' viewBox='0 0 20 20'%3E%3Cpath d='M10 4C9 4 9 5 9 5v.1A5 5 0 0 0 5.1 9H5s-1 0-1 1 1 1 1 1h.1A5 5 0 0 0 9 14.9v.1s0 1 1 1 1-1 1-1v-.1a5 5 0 0 0 3.9-3.9h.1s1 0 1-1-1-1-1-1h-.1A5 5 0 0 0 11 5.1V5s0-1-1-1m0 2.5a3.5 3.5 0 1 1 0 7 3.5 3.5 0 1 1 0-7'/%3E%3Ccircle cx='10' cy='10' r='2'/%3E%3C/svg%3E")}.maplibregl-ctrl button.maplibregl-ctrl-geolocate:disabled .maplibregl-ctrl-icon{background-image:url("data:image/svg+xml;charset=utf-8,%3Csvg xmlns='http://www.w3.org/2000/svg' width='29' height='29' fill='%23aaa' viewBox='0 0 20 20'%3E%3Cpath d='M10 4C9 4 9 5 9 5v.1A5 5 0 0 0 5.1 9H5s-1 0-1 1 1 1 1 1h.1A5 5 0 0 0 9 14.9v.1s0 1 1 1 1-1 1-1v-.1a5 5 0 0 0 3.9-3.9h.1s1 0 1-1-1-1-1-1h-.1A5 5 0 0 0 11 5.1V5s0-1-1-1m0 2.5a3.5 3.5 0 1 1 0 7 3.5 3.5 0 1 1 0-7'/%3E%3Ccircle cx='10' cy='10' r='2'/%3E%3Cpath fill='red' d='m14 5 1 1-9 9-1-1z'/%3E%3C/svg%3E")}.maplibregl-ctrl button.maplibregl-ctrl-geolocate.maplibregl-ctrl-geolocate-active .maplibregl-ctrl-icon{background-image:url("data:image/svg+xml;charset=utf-8,%3Csvg xmlns='http://www.w3.org/2000/svg' width='29' height='29' fill='%2333b5e5' viewBox='0 0 20 20'%3E%3Cpath d='M10 4C9 4 9 5 9 5v.1A5 5 0 0 0 5.1 9H5s-1 0-1 1 1 1 1 1h.1A5 5 0 0 0 9 14.9v.1s0 1 1 1 1-1 1-1v-.1a5 5 0 0 0 3.9-3.9h.1s1 0 1-1-1-1-1-1h-.1A5 5 0 0 0 11 5.1V5s0-1-1-1m0 2.5a3.5 3.5 0 1 1 0 7 3.5 3.5 0 1 1 0-7'/%3E%3Ccircle cx='10' cy='10' r='2'/%3E%3C/svg%3E")}.maplibregl-ctrl button.maplibregl-ctrl-geolocate.maplibregl-ctrl-geolocate-active-error .maplibregl-ctrl-icon{background-image:url("data:image/svg+xml;charset=utf-8,%3Csvg xmlns='http://www.w3.org/2000/svg' width='29' height='29' fill='%23e58978' viewBox='0 0 20 20'%3E%3Cpath d='M10 4C9 4 9 5 9 5v.1A5 5 0 0 0 5.1 9H5s-1 0-1 1 1 1 1 1h.1A5 5 0 0 0 9 14.9v.1s0 1 1 1 1-1 1-1v-.1a5 5 0 0 0 3.9-3.9h.1s1 0 1-1-1-1-1-1h-.1A5 5 0 0 0 11 5.1V5s0-1-1-1m0 2.5a3.5 3.5 0 1 1 0 7 3.5 3.5 0 1 1 0-7'/%3E%3Ccircle cx='10' cy='10' r='2'/%3E%3C/svg%3E")}.maplibregl-ctrl button.maplibregl-ctrl-geolocate.maplibregl-ctrl-geolocate-background .maplibregl-ctrl-icon{background-image:url("data:image/svg+xml;charset=utf-8,%3Csvg xmlns='http://www.w3.org/2000/svg' width='29' height='29' fill='%2333b5e5' viewBox='0 0 20 20'%3E%3Cpath d='M10 4C9 4 9 5 9 5v.1A5 5 0 0 0 5.1 9H5s-1 0-1 1 1 1 1 1h.1A5 5 0 0 0 9 14.9v.1s0 1 1 1 1-1 1-1v-.1a5 5 0 0 0 3.9-3.9h.1s1 0 1-1-1-1-1-1h-.1A5 5 0 0 0 11 5.1V5s0-1-1-1m0 2.5a3.5 3.5 0 1 1 0 7 3.5 3.5 0 1 1 0-7'/%3E%3C/svg%3E")}.maplibregl-ctrl button.maplibregl-ctrl-geolocate.maplibregl-ctrl-geolocate-background-error .maplibregl-ctrl-icon{background-image:url("data:image/svg+xml;charset=utf-8,%3Csvg xmlns='http://www.w3.org/2000/svg' width='29' height='29' fill='%23e54e33' viewBox='0 0 20 20'%3E%3Cpath d='M10 4C9 4 9 5 9 5v.1A5 5 0 0 0 5.1 9H5s-1 0-1 1 1 1 1 1h.1A5 5 0 0 0 9 14.9v.1s0 1 1 1 1-1 1-1v-.1a5 5 0 0 0 3.9-3.9h.1s1 0 1-1-1-1-1-1h-.1A5 5 0 0 0 11 5.1V5s0-1-1-1m0 2.5a3.5 3.5 0 1 1 0 7 3.5 3.5 0 1 1 0-7'/%3E%3C/svg%3E")}.maplibregl-ctrl button.maplibregl-ctrl-geolocate.maplibregl-ctrl-geolocate-waiting .maplibregl-ctrl-icon{animation:maplibregl-spin 2s linear infinite}@media (forced-colors:active){.maplibregl-ctrl button.maplibregl-ctrl-geolocate .maplibregl-ctrl-icon{background-image:url("data:image/svg+xml;charset=utf-8,%3Csvg xmlns='http://www.w3.org/2000/svg' width='29' height='29' fill='%23fff' viewBox='0 0 20 20'%3E%3Cpath d='M10 4C9 4 9 5 9 5v.1A5 5 0 0 0 5.1 9H5s-1 0-1 1 1 1 1 1h.1A5 5 0 0 0 9 14.9v.1s0 1 1 1 1-1 1-1v-.1a5 5 0 0 0 3.9-3.9h.1s1 0 1-1-1-1-1-1h-.1A5 5 0 0 0 11 5.1V5s0-1-1-1m0 2.5a3.5 3.5 0 1 1 0 7 3.5 3.5 0 1 1 0-7'/%3E%3Ccircle cx='10' cy='10' r='2'/%3E%3C/svg%3E")}.maplibregl-ctrl button.maplibregl-ctrl-geolocate:disabled .maplibregl-ctrl-icon{background-image:url("data:image/svg+xml;charset=utf-8,%3Csvg xmlns='http://www.w3.org/2000/svg' width='29' height='29' fill='%23999' viewBox='0 0 20 20'%3E%3Cpath d='M10 4C9 4 9 5 9 5v.1A5 5 0 0 0 5.1 9H5s-1 0-1 1 1 1 1 1h.1A5 5 0 0 0 9 14.9v.1s0 1 1 1 1-1 1-1v-.1a5 5 0 0 0 3.9-3.9h.1s1 0 1-1-1-1-1-1h-.1A5 5 0 0 0 11 5.1V5s0-1-1-1m0 2.5a3.5 3.5 0 1 1 0 7 3.5 3.5 0 1 1 0-7'/%3E%3Ccircle cx='10' cy='10' r='2'/%3E%3Cpath fill='red' d='m14 5 1 1-9 9-1-1z'/%3E%3C/svg%3E")}.maplibregl-ctrl button.maplibregl-ctrl-geolocate.maplibregl-ctrl-geolocate-active .maplibregl-ctrl-icon{background-image:url("data:image/svg+xml;charset=utf-8,%3Csvg xmlns='http://www.w3.org/2000/svg' width='29' height='29' fill='%2333b5e5' viewBox='0 0 20 20'%3E%3Cpath d='M10 4C9 4 9 5 9 5v.1A5 5 0 0 0 5.1 9H5s-1 0-1 1 1 1 1 1h.1A5 5 0 0 0 9 14.9v.1s0 1 1 1 1-1 1-1v-.1a5 5 0 0 0 3.9-3.9h.1s1 0 1-1-1-1-1-1h-.1A5 5 0 0 0 11 5.1V5s0-1-1-1m0 2.5a3.5 3.5 0 1 1 0 7 3.5 3.5 0 1 1 0-7'/%3E%3Ccircle cx='10' cy='10' r='2'/%3E%3C/svg%3E")}.maplibregl-ctrl button.maplibregl-ctrl-geolocate.maplibregl-ctrl-geolocate-active-error .maplibregl-ctrl-icon{background-image:url("data:image/svg+xml;charset=utf-8,%3Csvg xmlns='http://www.w3.org/2000/svg' width='29' height='29' fill='%23e58978' viewBox='0 0 20 20'%3E%3Cpath d='M10 4C9 4 9 5 9 5v.1A5 5 0 0 0 5.1 9H5s-1 0-1 1 1 1 1 1h.1A5 5 0 0 0 9 14.9v.1s0 1 1 1 1-1 1-1v-.1a5 5 0 0 0 3.9-3.9h.1s1 0 1-1-1-1-1-1h-.1A5 5 0 0 0 11 5.1V5s0-1-1-1m0 2.5a3.5 3.5 0 1 1 0 7 3.5 3.5 0 1 1 0-7'/%3E%3Ccircle cx='10' cy='10' r='2'/%3E%3C/svg%3E")}.maplibregl-ctrl button.maplibregl-ctrl-geolocate.maplibregl-ctrl-geolocate-background .maplibregl-ctrl-icon{background-image:url("data:image/svg+xml;charset=utf-8,%3Csvg xmlns='http://www.w3.org/2000/svg' width='29' height='29' fill='%2333b5e5' viewBox='0 0 20 20'%3E%3Cpath d='M10 4C9 4 9 5 9 5v.1A5 5 0 0 0 5.1 9H5s-1 0-1 1 1 1 1 1h.1A5 5 0 0 0 9 14.9v.1s0 1 1 1 1-1 1-1v-.1a5 5 0 0 0 3.9-3.9h.1s1 0 1-1-1-1-1-1h-.1A5 5 0 0 0 11 5.1V5s0-1-1-1m0 2.5a3.5 3.5 0 1 1 0 7 3.5 3.5 0 1 1 0-7'/%3E%3C/svg%3E")}.maplibregl-ctrl button.maplibregl-ctrl-geolocate.maplibregl-ctrl-geolocate-background-error .maplibregl-ctrl-icon{background-image:url("data:image/svg+xml;charset=utf-8,%3Csvg xmlns='http://www.w3.org/2000/svg' width='29' height='29' fill='%23e54e33' viewBox='0 0 20 20'%3E%3Cpath d='M10 4C9 4 9 5 9 5v.1A5 5 0 0 0 5.1 9H5s-1 0-1 1 1 1 1 1h.1A5 5 0 0 0 9 14.9v.1s0 1 1 1 1-1 1-1v-.1a5 5 0 0 0 3.9-3.9h.1s1 0 1-1-1-1-1-1h-.1A5 5 0 0 0 11 5.1V5s0-1-1-1m0 2.5a3.5 3.5 0 1 1 0 7 3.5 3.5 0 1 1 0-7'/%3E%3C/svg%3E")}}@media (forced-colors:active) and (prefers-color-scheme:light){.maplibregl-ctrl button.maplibregl-ctrl-geolocate .maplibregl-ctrl-icon{background-image:url("data:image/svg+xml;charset=utf-8,%3Csvg xmlns='http://www.w3.org/2000/svg' width='29' height='29' viewBox='0 0 20 20'%3E%3Cpath d='M10 4C9 4 9 5 9 5v.1A5 5 0 0 0 5.1 9H5s-1 0-1 1 1 1 1 1h.1A5 5 0 0 0 9 14.9v.1s0 1 1 1 1-1 1-1v-.1a5 5 0 0 0 3.9-3.9h.1s1 0 1-1-1-1-1-1h-.1A5 5 0 0 0 11 5.1V5s0-1-1-1m0 2.5a3.5 3.5 0 1 1 0 7 3.5 3.5 0 1 1 0-7'/%3E%3Ccircle cx='10' cy='10' r='2'/%3E%3C/svg%3E")}.maplibregl-ctrl button.maplibregl-ctrl-geolocate:disabled .maplibregl-ctrl-icon{background-image:url("data:image/svg+xml;charset=utf-8,%3Csvg xmlns='http://www.w3.org/2000/svg' width='29' height='29' fill='%23666' viewBox='0 0 20 20'%3E%3Cpath d='M10 4C9 4 9 5 9 5v.1A5 5 0 0 0 5.1 9H5s-1 0-1 1 1 1 1 1h.1A5 5 0 0 0 9 14.9v.1s0 1 1 1 1-1 1-1v-.1a5 5 0 0 0 3.9-3.9h.1s1 0 1-1-1-1-1-1h-.1A5 5 0 0 0 11 5.1V5s0-1-1-1m0 2.5a3.5 3.5 0 1 1 0 7 3.5 3.5 0 1 1 0-7'/%3E%3Ccircle cx='10' cy='10' r='2'/%3E%3Cpath fill='red' d='m14 5 1 1-9 9-1-1z'/%3E%3C/svg%3E")}}@keyframes maplibregl-spin{0%{transform:rotate(0deg)}to{transform:rotate(1turn)}}a.maplibregl-ctrl-logo{background-image:url("data:image/svg+xml;charset=utf-8,%3Csvg xmlns='http://www.w3.org/2000/svg' width='88' height='23' fill='none'%3E%3Cpath fill='%23000' fill-opacity='.4' fill-rule='evenodd' d='M17.408 16.796h-1.827l2.501-12.095h.198l3.324 6.533.988 2.19.988-2.19 3.258-6.533h.181l2.6 12.095h-1.81l-1.218-5.644-.362-1.71-.658 1.71-2.929 5.644h-.098l-2.914-5.644-.757-1.71-.345 1.71zm1.958-3.42-.726 3.663a1.255 1.255 0 0 1-1.232 1.011h-1.827a1.255 1.255 0 0 1-1.229-1.509l2.501-12.095a1.255 1.255 0 0 1 1.23-1.001h.197a1.25 1.25 0 0 1 1.12.685l3.19 6.273 3.125-6.263a1.25 1.25 0 0 1 1.123-.695h.181a1.255 1.255 0 0 1 1.227.991l1.443 6.71a5 5 0 0 1 .314-.787l.009-.016a4.6 4.6 0 0 1 1.777-1.887c.782-.46 1.668-.667 2.611-.667a4.6 4.6 0 0 1 1.7.32l.306.134c.21-.16.474-.256.759-.256h1.694a1.255 1.255 0 0 1 1.212.925 1.255 1.255 0 0 1 1.212-.925h1.711c.284 0 .545.094.755.252.613-.3 1.312-.45 2.075-.45 1.356 0 2.557.445 3.482 1.4q.47.48.763 1.064V4.701a1.255 1.255 0 0 1 1.255-1.255h1.86A1.255 1.255 0 0 1 54.44 4.7v9.194h2.217c.19 0 .37.043.532.118v-4.77c0-.356.147-.678.385-.906a2.42 2.42 0 0 1-.682-1.71c0-.665.267-1.253.735-1.7a2.45 2.45 0 0 1 1.722-.674 2.43 2.43 0 0 1 1.705.675q.318.302.504.683V4.7a1.255 1.255 0 0 1 1.255-1.255h1.744A1.255 1.255 0 0 1 65.812 4.7v3.335a4.8 4.8 0 0 1 1.526-.246c.938 0 1.817.214 2.59.69a4.47 4.47 0 0 1 1.67 1.743v-.98a1.255 1.255 0 0 1 1.256-1.256h1.777c.233 0 .451.064.639.174a3.4 3.4 0 0 1 1.567-.372c.346 0 .861.02 1.285.232a1.25 1.25 0 0 1 .689 1.004 4.7 4.7 0 0 1 .853-.588c.795-.44 1.675-.647 2.61-.647 1.385 0 2.65.39 3.525 1.396.836.938 1.168 2.173 1.168 3.528q-.001.515-.056 1.051a1.255 1.255 0 0 1-.947 1.09l.408.952a1.255 1.255 0 0 1-.477 1.552c-.418.268-.92.463-1.458.612-.613.171-1.304.244-2.049.244-1.06 0-2.043-.207-2.886-.698l-.015-.008c-.798-.48-1.419-1.135-1.818-1.963l-.004-.008a5.8 5.8 0 0 1-.548-2.512q0-.429.053-.843a1.3 1.3 0 0 1-.333-.086l-.166-.004c-.223 0-.426.062-.643.228-.03.024-.142.139-.142.59v3.883a1.255 1.255 0 0 1-1.256 1.256h-1.777a1.255 1.255 0 0 1-1.256-1.256V15.69l-.032.057a4.8 4.8 0 0 1-1.86 1.833 5.04 5.04 0 0 1-2.484.634 4.5 4.5 0 0 1-1.935-.424 1.25 1.25 0 0 1-.764.258h-1.71a1.255 1.255 0 0 1-1.256-1.255V7.687a2.4 2.4 0 0 1-.428.625c.253.23.412.561.412.93v7.553a1.255 1.255 0 0 1-1.256 1.255h-1.843a1.25 1.25 0 0 1-.894-.373c-.228.23-.544.373-.894.373H51.32a1.255 1.255 0 0 1-1.256-1.255v-1.251l-.061.117a4.7 4.7 0 0 1-1.782 1.884 4.77 4.77 0 0 1-2.485.67 5.6 5.6 0 0 1-1.485-.188l.009 2.764a1.255 1.255 0 0 1-1.255 1.259h-1.729a1.255 1.255 0 0 1-1.255-1.255v-3.537a1.255 1.255 0 0 1-1.167.793h-1.679a1.25 1.25 0 0 1-.77-.263 4.5 4.5 0 0 1-1.945.429c-.885 0-1.724-.21-2.495-.632l-.017-.01a5 5 0 0 1-1.081-.836 1.255 1.255 0 0 1-1.254 1.312h-1.81a1.255 1.255 0 0 1-1.228-.99l-.782-3.625-2.044 3.939a1.25 1.25 0 0 1-1.115.676h-.098a1.25 1.25 0 0 1-1.116-.68l-2.061-3.994zM35.92 16.63l.207-.114.223-.15q.493-.356.735-.785l.061-.118.033 1.332h1.678V9.242h-1.694l-.033 1.267q-.133-.329-.526-.658l-.032-.028a3.2 3.2 0 0 0-.668-.428l-.27-.12a3.3 3.3 0 0 0-1.235-.23q-1.136-.001-1.974.493a3.36 3.36 0 0 0-1.3 1.382q-.445.89-.444 2.074 0 1.2.51 2.107a3.8 3.8 0 0 0 1.382 1.381 3.9 3.9 0 0 0 1.893.477q.795 0 1.455-.33zm-2.789-5.38q-.576.675-.575 1.762 0 1.102.559 1.794.576.675 1.645.675a2.25 2.25 0 0 0 .934-.19 2.2 2.2 0 0 0 .468-.29l.178-.161a2.2 2.2 0 0 0 .397-.561q.244-.5.244-1.15v-.115q0-.708-.296-1.267l-.043-.077a2.2 2.2 0 0 0-.633-.709l-.13-.086-.047-.028a2.1 2.1 0 0 0-1.073-.285q-1.052 0-1.629.692zm2.316 2.706c.163-.17.28-.407.28-.83v-.114c0-.292-.06-.508-.15-.68a.96.96 0 0 0-.353-.389.85.85 0 0 0-.464-.127c-.4 0-.56.114-.664.239l-.01.012c-.148.174-.275.45-.275.945 0 .506.122.801.27.99.097.11.266.224.68.224.303 0 .504-.09.687-.269zm7.545 1.705a2.6 2.6 0 0 0 .331.423q.319.33.755.548l.173.074q.65.255 1.49.255 1.02 0 1.844-.493a3.45 3.45 0 0 0 1.316-1.4q.493-.904.493-2.089 0-1.909-.988-2.913-.988-1.02-2.584-1.02-.898 0-1.575.347a3 3 0 0 0-.415.262l-.199.166a3.4 3.4 0 0 0-.64.82V9.242h-1.712v11.553h1.729l-.017-5.134zm.53-1.138q.206.29.48.5l.155.11.053.034q.51.296 1.119.297 1.07 0 1.645-.675.577-.69.576-1.762 0-1.119-.576-1.777-.558-.675-1.645-.675-.435 0-.835.16a2 2 0 0 0-.284.136 2 2 0 0 0-.363.254 2.2 2.2 0 0 0-.46.569l-.082.162a2.6 2.6 0 0 0-.213 1.072v.115q0 .707.296 1.267l.135.211zm.964-.818a1.1 1.1 0 0 0 .367.385.94.94 0 0 0 .476.118c.423 0 .59-.117.687-.23.159-.194.28-.478.28-.95 0-.53-.133-.8-.266-.952l-.021-.025c-.078-.094-.231-.221-.68-.221a1 1 0 0 0-.503.135l-.012.007a.86.86 0 0 0-.335.343c-.073.133-.132.324-.132.614v.115a1.4 1.4 0 0 0 .14.66zm15.7-6.222q.347-.346.346-.856a1.05 1.05 0 0 0-.345-.79 1.18 1.18 0 0 0-.84-.329q-.51 0-.855.33a1.05 1.05 0 0 0-.346.79q0 .51.346.855.345.346.856.346.51 0 .839-.346zm4.337 9.314.033-1.332q.191.403.59.747l.098.081a4 4 0 0 0 .316.224l.223.122a3.2 3.2 0 0 0 1.44.322 3.8 3.8 0 0 0 1.875-.477 3.5 3.5 0 0 0 1.382-1.366q.527-.89.526-2.09 0-1.184-.444-2.073a3.24 3.24 0 0 0-1.283-1.399q-.823-.51-1.942-.51a3.5 3.5 0 0 0-1.527.344l-.086.043-.165.09a3 3 0 0 0-.33.214q-.432.315-.656.707a2 2 0 0 0-.099.198l.082-1.283V4.701h-1.744v12.095zm.473-2.509a2.5 2.5 0 0 0 .566.7q.117.098.245.18l.144.08a2.1 2.1 0 0 0 .975.232q1.07 0 1.645-.675.576-.69.576-1.778 0-1.102-.576-1.777-.56-.691-1.645-.692a2.2 2.2 0 0 0-1.015.235q-.22.113-.415.282l-.15.142a2.1 2.1 0 0 0-.42.594q-.223.479-.223 1.1v.115q0 .705.293 1.26zm2.616-.293c.157-.191.28-.479.28-.967 0-.51-.13-.79-.276-.961l-.021-.026c-.082-.1-.232-.225-.67-.225a.87.87 0 0 0-.681.279l-.012.011c-.154.155-.274.38-.274.807v.115c0 .285.057.499.144.669a1.1 1.1 0 0 0 .367.405c.137.082.28.123.455.123.423 0 .59-.118.686-.23zm8.266-3.013q.345-.13.724-.14l.069-.002q.493 0 .642.099l.247-1.794q-.196-.099-.717-.099a2.3 2.3 0 0 0-.545.063 2 2 0 0 0-.411.148 2.2 2.2 0 0 0-.4.249 2.5 2.5 0 0 0-.485.499 2.7 2.7 0 0 0-.32.581l-.05.137v-1.48h-1.778v7.553h1.777v-3.884q0-.546.159-.943a1.5 1.5 0 0 1 .466-.636 2.5 2.5 0 0 1 .399-.253 2 2 0 0 1 .224-.099zm9.784 2.656.05-.922q0-1.743-.856-2.698-.838-.97-2.584-.97-1.119-.001-2.007.493a3.46 3.46 0 0 0-1.4 1.382q-.493.906-.493 2.106 0 1.07.428 1.975.428.89 1.332 1.432.906.526 2.255.526.973 0 1.668-.185l.044-.012.135-.04q.613-.184.984-.421l-.542-1.267q-.3.162-.642.274l-.297.087q-.51.131-1.3.131-.954 0-1.497-.444a1.6 1.6 0 0 1-.192-.193q-.366-.44-.512-1.234l-.004-.021zm-5.427-1.256-.003.022h3.752v-.138q-.011-.727-.288-1.118a1 1 0 0 0-.156-.176q-.46-.428-1.316-.428-.986 0-1.494.604-.379.45-.494 1.234zm-27.053 2.77V4.7h-1.86v12.095h5.333V15.15zm7.103-5.908v7.553h-1.843V9.242h1.843z'/%3E%3Cpath fill='%23fff' d='m19.63 11.151-.757-1.71-.345 1.71-1.12 5.644h-1.827L18.083 4.7h.197l3.325 6.533.988 2.19.988-2.19L26.839 4.7h.181l2.6 12.095h-1.81l-1.218-5.644-.362-1.71-.658 1.71-2.93 5.644h-.098l-2.913-5.644zm14.836 5.81q-1.02 0-1.893-.478a3.8 3.8 0 0 1-1.381-1.382q-.51-.906-.51-2.106 0-1.185.444-2.074a3.36 3.36 0 0 1 1.3-1.382q.839-.494 1.974-.494a3.3 3.3 0 0 1 1.234.231 3.3 3.3 0 0 1 .97.575q.396.33.527.659l.033-1.267h1.694v7.553H37.18l-.033-1.332q-.279.593-1.02 1.053a3.17 3.17 0 0 1-1.662.444zm.296-1.482q.938 0 1.58-.642.642-.66.642-1.711v-.115q0-.708-.296-1.267a2.2 2.2 0 0 0-.807-.872 2.1 2.1 0 0 0-1.119-.313q-1.053 0-1.629.692-.575.675-.575 1.76 0 1.103.559 1.795.577.675 1.645.675zm6.521-6.237h1.711v1.4q.906-1.597 2.83-1.597 1.596 0 2.584 1.02.988 1.005.988 2.914 0 1.185-.493 2.09a3.46 3.46 0 0 1-1.316 1.399 3.5 3.5 0 0 1-1.844.493q-.954 0-1.662-.329a2.67 2.67 0 0 1-1.086-.97l.017 5.134h-1.728zm4.048 6.22q1.07 0 1.645-.674.577-.69.576-1.762 0-1.119-.576-1.777-.558-.675-1.645-.675-.592 0-1.12.296-.51.28-.822.823-.296.527-.296 1.234v.115q0 .708.296 1.267.313.543.823.855.51.296 1.119.297z'/%3E%3Cpath fill='%23e1e3e9' d='M51.325 4.7h1.86v10.45h3.473v1.646h-5.333zm7.12 4.542h1.843v7.553h-1.843zm.905-1.415a1.16 1.16 0 0 1-.856-.346 1.17 1.17 0 0 1-.346-.856 1.05 1.05 0 0 1 .346-.79q.346-.329.856-.329.494 0 .839.33a1.05 1.05 0 0 1 .345.79 1.16 1.16 0 0 1-.345.855q-.33.346-.84.346zm7.875 9.133a3.17 3.17 0 0 1-1.662-.444q-.723-.46-1.004-1.053l-.033 1.332h-1.71V4.701h1.743v4.657l-.082 1.283q.279-.658 1.086-1.119a3.5 3.5 0 0 1 1.778-.477q1.119 0 1.942.51a3.24 3.24 0 0 1 1.283 1.4q.445.888.444 2.072 0 1.201-.526 2.09a3.5 3.5 0 0 1-1.382 1.366 3.8 3.8 0 0 1-1.876.477zm-.296-1.481q1.069 0 1.645-.675.577-.69.577-1.778 0-1.102-.577-1.776-.56-.691-1.645-.692a2.12 2.12 0 0 0-1.58.659q-.642.641-.642 1.694v.115q0 .71.296 1.267a2.4 2.4 0 0 0 .807.872 2.1 2.1 0 0 0 1.119.313zm5.927-6.237h1.777v1.481q.263-.757.856-1.217a2.14 2.14 0 0 1 1.349-.46q.527 0 .724.098l-.247 1.794q-.149-.099-.642-.099-.774 0-1.416.494-.626.493-.626 1.58v3.883h-1.777V9.242zm9.534 7.718q-1.35 0-2.255-.526-.904-.543-1.332-1.432a4.6 4.6 0 0 1-.428-1.975q0-1.2.493-2.106a3.46 3.46 0 0 1 1.4-1.382q.889-.495 2.007-.494 1.744 0 2.584.97.855.956.856 2.7 0 .444-.05.92h-5.43q.18 1.005.708 1.45.542.443 1.497.443.79 0 1.3-.131a4 4 0 0 0 .938-.362l.542 1.267q-.411.263-1.119.46-.708.198-1.711.197zm1.596-4.558q.016-1.02-.444-1.432-.46-.428-1.316-.428-1.728 0-1.991 1.86z'/%3E%3Cpath d='M5.074 15.948a.484.657 0 0 0-.486.659v1.84a.484.657 0 0 0 .486.659h4.101a.484.657 0 0 0 .486-.659v-1.84a.484.657 0 0 0-.486-.659zm3.56 1.16H5.617v.838h3.017z' style='fill:%23fff;fill-rule:evenodd;stroke-width:1.03600001'/%3E%3Cg style='stroke-width:1.12603545'%3E%3Cpath d='M-9.408-1.416c-3.833-.025-7.056 2.912-7.08 6.615-.02 3.08 1.653 4.832 3.107 6.268.903.892 1.721 1.74 2.32 2.902l-.525-.004c-.543-.003-.992.304-1.24.639a1.87 1.87 0 0 0-.362 1.121l-.011 1.877c-.003.402.104.787.347 1.125.244.338.688.653 1.23.656l4.142.028c.542.003.99-.306 1.238-.641a1.87 1.87 0 0 0 .363-1.121l.012-1.875a1.87 1.87 0 0 0-.348-1.127c-.243-.338-.688-.653-1.23-.656l-.518-.004c.597-1.145 1.425-1.983 2.348-2.87 1.473-1.414 3.18-3.149 3.2-6.226-.016-3.59-2.923-6.684-6.993-6.707m-.006 1.1v.002c3.274.02 5.92 2.532 5.9 5.6-.017 2.706-1.39 4.026-2.863 5.44-1.034.994-2.118 2.033-2.814 3.633-.018.041-.052.055-.075.065q-.013.004-.02.01a.34.34 0 0 1-.226.084.34.34 0 0 1-.224-.086l-.092-.077c-.699-1.615-1.768-2.669-2.781-3.67-1.454-1.435-2.797-2.762-2.78-5.478.02-3.067 2.7-5.545 5.975-5.523m-.02 2.826c-1.62-.01-2.944 1.315-2.955 2.96-.01 1.646 1.295 2.988 2.916 2.999h.002c1.621.01 2.943-1.316 2.953-2.961.011-1.646-1.294-2.988-2.916-2.998m-.005 1.1c1.017.006 1.829.83 1.822 1.89s-.83 1.874-1.848 1.867c-1.018-.006-1.829-.83-1.822-1.89s.83-1.874 1.848-1.868m-2.155 11.857 4.14.025c.271.002.49.305.487.676l-.013 1.875c-.003.37-.224.67-.495.668l-4.14-.025c-.27-.002-.487-.306-.485-.676l.012-1.875c.003-.37.224-.67.494-.668' style='color:%23000;font-style:normal;font-variant:normal;font-weight:400;font-stretch:normal;font-size:medium;line-height:normal;font-family:sans-serif;font-variant-ligatures:normal;font-variant-position:normal;font-variant-caps:normal;font-variant-numeric:normal;font-variant-alternates:normal;font-feature-settings:normal;text-indent:0;text-align:start;text-decoration:none;text-decoration-line:none;text-decoration-style:solid;text-decoration-color:%23000;letter-spacing:normal;word-spacing:normal;text-transform:none;writing-mode:lr-tb;direction:ltr;text-orientation:mixed;dominant-baseline:auto;baseline-shift:baseline;text-anchor:start;white-space:normal;shape-padding:0;clip-rule:evenodd;display:inline;overflow:visible;visibility:visible;opacity:1;isolation:auto;mix-blend-mode:normal;color-interpolation:sRGB;color-interpolation-filters:linearRGB;solid-color:%23000;solid-opacity:1;vector-effect:none;fill:%23000;fill-opacity:.4;fill-rule:evenodd;stroke:none;stroke-width:2.47727823;stroke-linecap:butt;stroke-linejoin:miter;stroke-miterlimit:4;stroke-dasharray:none;stroke-dashoffset:0;stroke-opacity:1;color-rendering:auto;image-rendering:auto;shape-rendering:auto;text-rendering:auto' transform='translate(15.553 2.85)scale(.88807)'/%3E%3Cpath d='M-9.415-.316C-12.69-.338-15.37 2.14-15.39 5.207c-.017 2.716 1.326 4.041 2.78 5.477 1.013 1 2.081 2.055 2.78 3.67l.092.076a.34.34 0 0 0 .225.086.34.34 0 0 0 .227-.083l.019-.01c.022-.009.057-.024.074-.064.697-1.6 1.78-2.64 2.814-3.634 1.473-1.414 2.847-2.733 2.864-5.44.02-3.067-2.627-5.58-5.901-5.601m-.057 8.784c1.621.011 2.944-1.315 2.955-2.96.01-1.646-1.295-2.988-2.916-2.999-1.622-.01-2.945 1.315-2.955 2.96s1.295 2.989 2.916 3' style='clip-rule:evenodd;fill:%23e1e3e9;fill-opacity:1;fill-rule:evenodd;stroke:none;stroke-width:2.47727823;stroke-miterlimit:4;stroke-dasharray:none;stroke-opacity:.4' transform='translate(15.553 2.85)scale(.88807)'/%3E%3Cpath d='M-11.594 15.465c-.27-.002-.492.297-.494.668l-.012 1.876c-.003.371.214.673.485.675l4.14.027c.271.002.492-.298.495-.668l.012-1.877c.003-.37-.215-.672-.485-.674z' style='clip-rule:evenodd;fill:%23fff;fill-opacity:1;fill-rule:evenodd;stroke:none;stroke-width:2.47727823;stroke-miterlimit:4;stroke-dasharray:none;stroke-opacity:.4' transform='translate(15.553 2.85)scale(.88807)'/%3E%3C/g%3E%3C/svg%3E");background-repeat:no-repeat;cursor:pointer;display:block;height:23px;margin:0 0 -4px -4px;overflow:hidden;width:88px}a.maplibregl-ctrl-logo.maplibregl-compact{width:14px}@media (forced-colors:active){a.maplibregl-ctrl-logo{background-color:transparent;background-image:url("data:image/svg+xml;charset=utf-8,%3Csvg xmlns='http://www.w3.org/2000/svg' width='88' height='23' fill='none'%3E%3Cpath fill='%23000' fill-opacity='.4' fill-rule='evenodd' d='M17.408 16.796h-1.827l2.501-12.095h.198l3.324 6.533.988 2.19.988-2.19 3.258-6.533h.181l2.6 12.095h-1.81l-1.218-5.644-.362-1.71-.658 1.71-2.929 5.644h-.098l-2.914-5.644-.757-1.71-.345 1.71zm1.958-3.42-.726 3.663a1.255 1.255 0 0 1-1.232 1.011h-1.827a1.255 1.255 0 0 1-1.229-1.509l2.501-12.095a1.255 1.255 0 0 1 1.23-1.001h.197a1.25 1.25 0 0 1 1.12.685l3.19 6.273 3.125-6.263a1.25 1.25 0 0 1 1.123-.695h.181a1.255 1.255 0 0 1 1.227.991l1.443 6.71a5 5 0 0 1 .314-.787l.009-.016a4.6 4.6 0 0 1 1.777-1.887c.782-.46 1.668-.667 2.611-.667a4.6 4.6 0 0 1 1.7.32l.306.134c.21-.16.474-.256.759-.256h1.694a1.255 1.255 0 0 1 1.212.925 1.255 1.255 0 0 1 1.212-.925h1.711c.284 0 .545.094.755.252.613-.3 1.312-.45 2.075-.45 1.356 0 2.557.445 3.482 1.4q.47.48.763 1.064V4.701a1.255 1.255 0 0 1 1.255-1.255h1.86A1.255 1.255 0 0 1 54.44 4.7v9.194h2.217c.19 0 .37.043.532.118v-4.77c0-.356.147-.678.385-.906a2.42 2.42 0 0 1-.682-1.71c0-.665.267-1.253.735-1.7a2.45 2.45 0 0 1 1.722-.674 2.43 2.43 0 0 1 1.705.675q.318.302.504.683V4.7a1.255 1.255 0 0 1 1.255-1.255h1.744A1.255 1.255 0 0 1 65.812 4.7v3.335a4.8 4.8 0 0 1 1.526-.246c.938 0 1.817.214 2.59.69a4.47 4.47 0 0 1 1.67 1.743v-.98a1.255 1.255 0 0 1 1.256-1.256h1.777c.233 0 .451.064.639.174a3.4 3.4 0 0 1 1.567-.372c.346 0 .861.02 1.285.232a1.25 1.25 0 0 1 .689 1.004 4.7 4.7 0 0 1 .853-.588c.795-.44 1.675-.647 2.61-.647 1.385 0 2.65.39 3.525 1.396.836.938 1.168 2.173 1.168 3.528q-.001.515-.056 1.051a1.255 1.255 0 0 1-.947 1.09l.408.952a1.255 1.255 0 0 1-.477 1.552c-.418.268-.92.463-1.458.612-.613.171-1.304.244-2.049.244-1.06 0-2.043-.207-2.886-.698l-.015-.008c-.798-.48-1.419-1.135-1.818-1.963l-.004-.008a5.8 5.8 0 0 1-.548-2.512q0-.429.053-.843a1.3 1.3 0 0 1-.333-.086l-.166-.004c-.223 0-.426.062-.643.228-.03.024-.142.139-.142.59v3.883a1.255 1.255 0 0 1-1.256 1.256h-1.777a1.255 1.255 0 0 1-1.256-1.256V15.69l-.032.057a4.8 4.8 0 0 1-1.86 1.833 5.04 5.04 0 0 1-2.484.634 4.5 4.5 0 0 1-1.935-.424 1.25 1.25 0 0 1-.764.258h-1.71a1.255 1.255 0 0 1-1.256-1.255V7.687a2.4 2.4 0 0 1-.428.625c.253.23.412.561.412.93v7.553a1.255 1.255 0 0 1-1.256 1.255h-1.843a1.25 1.25 0 0 1-.894-.373c-.228.23-.544.373-.894.373H51.32a1.255 1.255 0 0 1-1.256-1.255v-1.251l-.061.117a4.7 4.7 0 0 1-1.782 1.884 4.77 4.77 0 0 1-2.485.67 5.6 5.6 0 0 1-1.485-.188l.009 2.764a1.255 1.255 0 0 1-1.255 1.259h-1.729a1.255 1.255 0 0 1-1.255-1.255v-3.537a1.255 1.255 0 0 1-1.167.793h-1.679a1.25 1.25 0 0 1-.77-.263 4.5 4.5 0 0 1-1.945.429c-.885 0-1.724-.21-2.495-.632l-.017-.01a5 5 0 0 1-1.081-.836 1.255 1.255 0 0 1-1.254 1.312h-1.81a1.255 1.255 0 0 1-1.228-.99l-.782-3.625-2.044 3.939a1.25 1.25 0 0 1-1.115.676h-.098a1.25 1.25 0 0 1-1.116-.68l-2.061-3.994zM35.92 16.63l.207-.114.223-.15q.493-.356.735-.785l.061-.118.033 1.332h1.678V9.242h-1.694l-.033 1.267q-.133-.329-.526-.658l-.032-.028a3.2 3.2 0 0 0-.668-.428l-.27-.12a3.3 3.3 0 0 0-1.235-.23q-1.136-.001-1.974.493a3.36 3.36 0 0 0-1.3 1.382q-.445.89-.444 2.074 0 1.2.51 2.107a3.8 3.8 0 0 0 1.382 1.381 3.9 3.9 0 0 0 1.893.477q.795 0 1.455-.33zm-2.789-5.38q-.576.675-.575 1.762 0 1.102.559 1.794.576.675 1.645.675a2.25 2.25 0 0 0 .934-.19 2.2 2.2 0 0 0 .468-.29l.178-.161a2.2 2.2 0 0 0 .397-.561q.244-.5.244-1.15v-.115q0-.708-.296-1.267l-.043-.077a2.2 2.2 0 0 0-.633-.709l-.13-.086-.047-.028a2.1 2.1 0 0 0-1.073-.285q-1.052 0-1.629.692zm2.316 2.706c.163-.17.28-.407.28-.83v-.114c0-.292-.06-.508-.15-.68a.96.96 0 0 0-.353-.389.85.85 0 0 0-.464-.127c-.4 0-.56.114-.664.239l-.01.012c-.148.174-.275.45-.275.945 0 .506.122.801.27.99.097.11.266.224.68.224.303 0 .504-.09.687-.269zm7.545 1.705a2.6 2.6 0 0 0 .331.423q.319.33.755.548l.173.074q.65.255 1.49.255 1.02 0 1.844-.493a3.45 3.45 0 0 0 1.316-1.4q.493-.904.493-2.089 0-1.909-.988-2.913-.988-1.02-2.584-1.02-.898 0-1.575.347a3 3 0 0 0-.415.262l-.199.166a3.4 3.4 0 0 0-.64.82V9.242h-1.712v11.553h1.729l-.017-5.134zm.53-1.138q.206.29.48.5l.155.11.053.034q.51.296 1.119.297 1.07 0 1.645-.675.577-.69.576-1.762 0-1.119-.576-1.777-.558-.675-1.645-.675-.435 0-.835.16a2 2 0 0 0-.284.136 2 2 0 0 0-.363.254 2.2 2.2 0 0 0-.46.569l-.082.162a2.6 2.6 0 0 0-.213 1.072v.115q0 .707.296 1.267l.135.211zm.964-.818a1.1 1.1 0 0 0 .367.385.94.94 0 0 0 .476.118c.423 0 .59-.117.687-.23.159-.194.28-.478.28-.95 0-.53-.133-.8-.266-.952l-.021-.025c-.078-.094-.231-.221-.68-.221a1 1 0 0 0-.503.135l-.012.007a.86.86 0 0 0-.335.343c-.073.133-.132.324-.132.614v.115a1.4 1.4 0 0 0 .14.66zm15.7-6.222q.347-.346.346-.856a1.05 1.05 0 0 0-.345-.79 1.18 1.18 0 0 0-.84-.329q-.51 0-.855.33a1.05 1.05 0 0 0-.346.79q0 .51.346.855.345.346.856.346.51 0 .839-.346zm4.337 9.314.033-1.332q.191.403.59.747l.098.081a4 4 0 0 0 .316.224l.223.122a3.2 3.2 0 0 0 1.44.322 3.8 3.8 0 0 0 1.875-.477 3.5 3.5 0 0 0 1.382-1.366q.527-.89.526-2.09 0-1.184-.444-2.073a3.24 3.24 0 0 0-1.283-1.399q-.823-.51-1.942-.51a3.5 3.5 0 0 0-1.527.344l-.086.043-.165.09a3 3 0 0 0-.33.214q-.432.315-.656.707a2 2 0 0 0-.099.198l.082-1.283V4.701h-1.744v12.095zm.473-2.509a2.5 2.5 0 0 0 .566.7q.117.098.245.18l.144.08a2.1 2.1 0 0 0 .975.232q1.07 0 1.645-.675.576-.69.576-1.778 0-1.102-.576-1.777-.56-.691-1.645-.692a2.2 2.2 0 0 0-1.015.235q-.22.113-.415.282l-.15.142a2.1 2.1 0 0 0-.42.594q-.223.479-.223 1.1v.115q0 .705.293 1.26zm2.616-.293c.157-.191.28-.479.28-.967 0-.51-.13-.79-.276-.961l-.021-.026c-.082-.1-.232-.225-.67-.225a.87.87 0 0 0-.681.279l-.012.011c-.154.155-.274.38-.274.807v.115c0 .285.057.499.144.669a1.1 1.1 0 0 0 .367.405c.137.082.28.123.455.123.423 0 .59-.118.686-.23zm8.266-3.013q.345-.13.724-.14l.069-.002q.493 0 .642.099l.247-1.794q-.196-.099-.717-.099a2.3 2.3 0 0 0-.545.063 2 2 0 0 0-.411.148 2.2 2.2 0 0 0-.4.249 2.5 2.5 0 0 0-.485.499 2.7 2.7 0 0 0-.32.581l-.05.137v-1.48h-1.778v7.553h1.777v-3.884q0-.546.159-.943a1.5 1.5 0 0 1 .466-.636 2.5 2.5 0 0 1 .399-.253 2 2 0 0 1 .224-.099zm9.784 2.656.05-.922q0-1.743-.856-2.698-.838-.97-2.584-.97-1.119-.001-2.007.493a3.46 3.46 0 0 0-1.4 1.382q-.493.906-.493 2.106 0 1.07.428 1.975.428.89 1.332 1.432.906.526 2.255.526.973 0 1.668-.185l.044-.012.135-.04q.613-.184.984-.421l-.542-1.267q-.3.162-.642.274l-.297.087q-.51.131-1.3.131-.954 0-1.497-.444a1.6 1.6 0 0 1-.192-.193q-.366-.44-.512-1.234l-.004-.021zm-5.427-1.256-.003.022h3.752v-.138q-.011-.727-.288-1.118a1 1 0 0 0-.156-.176q-.46-.428-1.316-.428-.986 0-1.494.604-.379.45-.494 1.234zm-27.053 2.77V4.7h-1.86v12.095h5.333V15.15zm7.103-5.908v7.553h-1.843V9.242h1.843z'/%3E%3Cpath fill='%23fff' d='m19.63 11.151-.757-1.71-.345 1.71-1.12 5.644h-1.827L18.083 4.7h.197l3.325 6.533.988 2.19.988-2.19L26.839 4.7h.181l2.6 12.095h-1.81l-1.218-5.644-.362-1.71-.658 1.71-2.93 5.644h-.098l-2.913-5.644zm14.836 5.81q-1.02 0-1.893-.478a3.8 3.8 0 0 1-1.381-1.382q-.51-.906-.51-2.106 0-1.185.444-2.074a3.36 3.36 0 0 1 1.3-1.382q.839-.494 1.974-.494a3.3 3.3 0 0 1 1.234.231 3.3 3.3 0 0 1 .97.575q.396.33.527.659l.033-1.267h1.694v7.553H37.18l-.033-1.332q-.279.593-1.02 1.053a3.17 3.17 0 0 1-1.662.444zm.296-1.482q.938 0 1.58-.642.642-.66.642-1.711v-.115q0-.708-.296-1.267a2.2 2.2 0 0 0-.807-.872 2.1 2.1 0 0 0-1.119-.313q-1.053 0-1.629.692-.575.675-.575 1.76 0 1.103.559 1.795.577.675 1.645.675zm6.521-6.237h1.711v1.4q.906-1.597 2.83-1.597 1.596 0 2.584 1.02.988 1.005.988 2.914 0 1.185-.493 2.09a3.46 3.46 0 0 1-1.316 1.399 3.5 3.5 0 0 1-1.844.493q-.954 0-1.662-.329a2.67 2.67 0 0 1-1.086-.97l.017 5.134h-1.728zm4.048 6.22q1.07 0 1.645-.674.577-.69.576-1.762 0-1.119-.576-1.777-.558-.675-1.645-.675-.592 0-1.12.296-.51.28-.822.823-.296.527-.296 1.234v.115q0 .708.296 1.267.313.543.823.855.51.296 1.119.297z'/%3E%3Cpath fill='%23e1e3e9' d='M51.325 4.7h1.86v10.45h3.473v1.646h-5.333zm7.12 4.542h1.843v7.553h-1.843zm.905-1.415a1.16 1.16 0 0 1-.856-.346 1.17 1.17 0 0 1-.346-.856 1.05 1.05 0 0 1 .346-.79q.346-.329.856-.329.494 0 .839.33a1.05 1.05 0 0 1 .345.79 1.16 1.16 0 0 1-.345.855q-.33.346-.84.346zm7.875 9.133a3.17 3.17 0 0 1-1.662-.444q-.723-.46-1.004-1.053l-.033 1.332h-1.71V4.701h1.743v4.657l-.082 1.283q.279-.658 1.086-1.119a3.5 3.5 0 0 1 1.778-.477q1.119 0 1.942.51a3.24 3.24 0 0 1 1.283 1.4q.445.888.444 2.072 0 1.201-.526 2.09a3.5 3.5 0 0 1-1.382 1.366 3.8 3.8 0 0 1-1.876.477zm-.296-1.481q1.069 0 1.645-.675.577-.69.577-1.778 0-1.102-.577-1.776-.56-.691-1.645-.692a2.12 2.12 0 0 0-1.58.659q-.642.641-.642 1.694v.115q0 .71.296 1.267a2.4 2.4 0 0 0 .807.872 2.1 2.1 0 0 0 1.119.313zm5.927-6.237h1.777v1.481q.263-.757.856-1.217a2.14 2.14 0 0 1 1.349-.46q.527 0 .724.098l-.247 1.794q-.149-.099-.642-.099-.774 0-1.416.494-.626.493-.626 1.58v3.883h-1.777V9.242zm9.534 7.718q-1.35 0-2.255-.526-.904-.543-1.332-1.432a4.6 4.6 0 0 1-.428-1.975q0-1.2.493-2.106a3.46 3.46 0 0 1 1.4-1.382q.889-.495 2.007-.494 1.744 0 2.584.97.855.956.856 2.7 0 .444-.05.92h-5.43q.18 1.005.708 1.45.542.443 1.497.443.79 0 1.3-.131a4 4 0 0 0 .938-.362l.542 1.267q-.411.263-1.119.46-.708.198-1.711.197zm1.596-4.558q.016-1.02-.444-1.432-.46-.428-1.316-.428-1.728 0-1.991 1.86z'/%3E%3Cpath d='M5.074 15.948a.484.657 0 0 0-.486.659v1.84a.484.657 0 0 0 .486.659h4.101a.484.657 0 0 0 .486-.659v-1.84a.484.657 0 0 0-.486-.659zm3.56 1.16H5.617v.838h3.017z' style='fill:%23fff;fill-rule:evenodd;stroke-width:1.03600001'/%3E%3Cg style='stroke-width:1.12603545'%3E%3Cpath d='M-9.408-1.416c-3.833-.025-7.056 2.912-7.08 6.615-.02 3.08 1.653 4.832 3.107 6.268.903.892 1.721 1.74 2.32 2.902l-.525-.004c-.543-.003-.992.304-1.24.639a1.87 1.87 0 0 0-.362 1.121l-.011 1.877c-.003.402.104.787.347 1.125.244.338.688.653 1.23.656l4.142.028c.542.003.99-.306 1.238-.641a1.87 1.87 0 0 0 .363-1.121l.012-1.875a1.87 1.87 0 0 0-.348-1.127c-.243-.338-.688-.653-1.23-.656l-.518-.004c.597-1.145 1.425-1.983 2.348-2.87 1.473-1.414 3.18-3.149 3.2-6.226-.016-3.59-2.923-6.684-6.993-6.707m-.006 1.1v.002c3.274.02 5.92 2.532 5.9 5.6-.017 2.706-1.39 4.026-2.863 5.44-1.034.994-2.118 2.033-2.814 3.633-.018.041-.052.055-.075.065q-.013.004-.02.01a.34.34 0 0 1-.226.084.34.34 0 0 1-.224-.086l-.092-.077c-.699-1.615-1.768-2.669-2.781-3.67-1.454-1.435-2.797-2.762-2.78-5.478.02-3.067 2.7-5.545 5.975-5.523m-.02 2.826c-1.62-.01-2.944 1.315-2.955 2.96-.01 1.646 1.295 2.988 2.916 2.999h.002c1.621.01 2.943-1.316 2.953-2.961.011-1.646-1.294-2.988-2.916-2.998m-.005 1.1c1.017.006 1.829.83 1.822 1.89s-.83 1.874-1.848 1.867c-1.018-.006-1.829-.83-1.822-1.89s.83-1.874 1.848-1.868m-2.155 11.857 4.14.025c.271.002.49.305.487.676l-.013 1.875c-.003.37-.224.67-.495.668l-4.14-.025c-.27-.002-.487-.306-.485-.676l.012-1.875c.003-.37.224-.67.494-.668' style='color:%23000;font-style:normal;font-variant:normal;font-weight:400;font-stretch:normal;font-size:medium;line-height:normal;font-family:sans-serif;font-variant-ligatures:normal;font-variant-position:normal;font-variant-caps:normal;font-variant-numeric:normal;font-variant-alternates:normal;font-feature-settings:normal;text-indent:0;text-align:start;text-decoration:none;text-decoration-line:none;text-decoration-style:solid;text-decoration-color:%23000;letter-spacing:normal;word-spacing:normal;text-transform:none;writing-mode:lr-tb;direction:ltr;text-orientation:mixed;dominant-baseline:auto;baseline-shift:baseline;text-anchor:start;white-space:normal;shape-padding:0;clip-rule:evenodd;display:inline;overflow:visible;visibility:visible;opacity:1;isolation:auto;mix-blend-mode:normal;color-interpolation:sRGB;color-interpolation-filters:linearRGB;solid-color:%23000;solid-opacity:1;vector-effect:none;fill:%23000;fill-opacity:.4;fill-rule:evenodd;stroke:none;stroke-width:2.47727823;stroke-linecap:butt;stroke-linejoin:miter;stroke-miterlimit:4;stroke-dasharray:none;stroke-dashoffset:0;stroke-opacity:1;color-rendering:auto;image-rendering:auto;shape-rendering:auto;text-rendering:auto' transform='translate(15.553 2.85)scale(.88807)'/%3E%3Cpath d='M-9.415-.316C-12.69-.338-15.37 2.14-15.39 5.207c-.017 2.716 1.326 4.041 2.78 5.477 1.013 1 2.081 2.055 2.78 3.67l.092.076a.34.34 0 0 0 .225.086.34.34 0 0 0 .227-.083l.019-.01c.022-.009.057-.024.074-.064.697-1.6 1.78-2.64 2.814-3.634 1.473-1.414 2.847-2.733 2.864-5.44.02-3.067-2.627-5.58-5.901-5.601m-.057 8.784c1.621.011 2.944-1.315 2.955-2.96.01-1.646-1.295-2.988-2.916-2.999-1.622-.01-2.945 1.315-2.955 2.96s1.295 2.989 2.916 3' style='clip-rule:evenodd;fill:%23e1e3e9;fill-opacity:1;fill-rule:evenodd;stroke:none;stroke-width:2.47727823;stroke-miterlimit:4;stroke-dasharray:none;stroke-opacity:.4' transform='translate(15.553 2.85)scale(.88807)'/%3E%3Cpath d='M-11.594 15.465c-.27-.002-.492.297-.494.668l-.012 1.876c-.003.371.214.673.485.675l4.14.027c.271.002.492-.298.495-.668l.012-1.877c.003-.37-.215-.672-.485-.674z' style='clip-rule:evenodd;fill:%23fff;fill-opacity:1;fill-rule:evenodd;stroke:none;stroke-width:2.47727823;stroke-miterlimit:4;stroke-dasharray:none;stroke-opacity:.4' transform='translate(15.553 2.85)scale(.88807)'/%3E%3C/g%3E%3C/svg%3E")}}@media (forced-colors:active) and (prefers-color-scheme:light){a.maplibregl-ctrl-logo{background-image:url("data:image/svg+xml;charset=utf-8,%3Csvg xmlns='http://www.w3.org/2000/svg' width='88' height='23' fill='none'%3E%3Cpath fill='%23000' fill-opacity='.4' fill-rule='evenodd' d='M17.408 16.796h-1.827l2.501-12.095h.198l3.324 6.533.988 2.19.988-2.19 3.258-6.533h.181l2.6 12.095h-1.81l-1.218-5.644-.362-1.71-.658 1.71-2.929 5.644h-.098l-2.914-5.644-.757-1.71-.345 1.71zm1.958-3.42-.726 3.663a1.255 1.255 0 0 1-1.232 1.011h-1.827a1.255 1.255 0 0 1-1.229-1.509l2.501-12.095a1.255 1.255 0 0 1 1.23-1.001h.197a1.25 1.25 0 0 1 1.12.685l3.19 6.273 3.125-6.263a1.25 1.25 0 0 1 1.123-.695h.181a1.255 1.255 0 0 1 1.227.991l1.443 6.71a5 5 0 0 1 .314-.787l.009-.016a4.6 4.6 0 0 1 1.777-1.887c.782-.46 1.668-.667 2.611-.667a4.6 4.6 0 0 1 1.7.32l.306.134c.21-.16.474-.256.759-.256h1.694a1.255 1.255 0 0 1 1.212.925 1.255 1.255 0 0 1 1.212-.925h1.711c.284 0 .545.094.755.252.613-.3 1.312-.45 2.075-.45 1.356 0 2.557.445 3.482 1.4q.47.48.763 1.064V4.701a1.255 1.255 0 0 1 1.255-1.255h1.86A1.255 1.255 0 0 1 54.44 4.7v9.194h2.217c.19 0 .37.043.532.118v-4.77c0-.356.147-.678.385-.906a2.42 2.42 0 0 1-.682-1.71c0-.665.267-1.253.735-1.7a2.45 2.45 0 0 1 1.722-.674 2.43 2.43 0 0 1 1.705.675q.318.302.504.683V4.7a1.255 1.255 0 0 1 1.255-1.255h1.744A1.255 1.255 0 0 1 65.812 4.7v3.335a4.8 4.8 0 0 1 1.526-.246c.938 0 1.817.214 2.59.69a4.47 4.47 0 0 1 1.67 1.743v-.98a1.255 1.255 0 0 1 1.256-1.256h1.777c.233 0 .451.064.639.174a3.4 3.4 0 0 1 1.567-.372c.346 0 .861.02 1.285.232a1.25 1.25 0 0 1 .689 1.004 4.7 4.7 0 0 1 .853-.588c.795-.44 1.675-.647 2.61-.647 1.385 0 2.65.39 3.525 1.396.836.938 1.168 2.173 1.168 3.528q-.001.515-.056 1.051a1.255 1.255 0 0 1-.947 1.09l.408.952a1.255 1.255 0 0 1-.477 1.552c-.418.268-.92.463-1.458.612-.613.171-1.304.244-2.049.244-1.06 0-2.043-.207-2.886-.698l-.015-.008c-.798-.48-1.419-1.135-1.818-1.963l-.004-.008a5.8 5.8 0 0 1-.548-2.512q0-.429.053-.843a1.3 1.3 0 0 1-.333-.086l-.166-.004c-.223 0-.426.062-.643.228-.03.024-.142.139-.142.59v3.883a1.255 1.255 0 0 1-1.256 1.256h-1.777a1.255 1.255 0 0 1-1.256-1.256V15.69l-.032.057a4.8 4.8 0 0 1-1.86 1.833 5.04 5.04 0 0 1-2.484.634 4.5 4.5 0 0 1-1.935-.424 1.25 1.25 0 0 1-.764.258h-1.71a1.255 1.255 0 0 1-1.256-1.255V7.687a2.4 2.4 0 0 1-.428.625c.253.23.412.561.412.93v7.553a1.255 1.255 0 0 1-1.256 1.255h-1.843a1.25 1.25 0 0 1-.894-.373c-.228.23-.544.373-.894.373H51.32a1.255 1.255 0 0 1-1.256-1.255v-1.251l-.061.117a4.7 4.7 0 0 1-1.782 1.884 4.77 4.77 0 0 1-2.485.67 5.6 5.6 0 0 1-1.485-.188l.009 2.764a1.255 1.255 0 0 1-1.255 1.259h-1.729a1.255 1.255 0 0 1-1.255-1.255v-3.537a1.255 1.255 0 0 1-1.167.793h-1.679a1.25 1.25 0 0 1-.77-.263 4.5 4.5 0 0 1-1.945.429c-.885 0-1.724-.21-2.495-.632l-.017-.01a5 5 0 0 1-1.081-.836 1.255 1.255 0 0 1-1.254 1.312h-1.81a1.255 1.255 0 0 1-1.228-.99l-.782-3.625-2.044 3.939a1.25 1.25 0 0 1-1.115.676h-.098a1.25 1.25 0 0 1-1.116-.68l-2.061-3.994zM35.92 16.63l.207-.114.223-.15q.493-.356.735-.785l.061-.118.033 1.332h1.678V9.242h-1.694l-.033 1.267q-.133-.329-.526-.658l-.032-.028a3.2 3.2 0 0 0-.668-.428l-.27-.12a3.3 3.3 0 0 0-1.235-.23q-1.136-.001-1.974.493a3.36 3.36 0 0 0-1.3 1.382q-.445.89-.444 2.074 0 1.2.51 2.107a3.8 3.8 0 0 0 1.382 1.381 3.9 3.9 0 0 0 1.893.477q.795 0 1.455-.33zm-2.789-5.38q-.576.675-.575 1.762 0 1.102.559 1.794.576.675 1.645.675a2.25 2.25 0 0 0 .934-.19 2.2 2.2 0 0 0 .468-.29l.178-.161a2.2 2.2 0 0 0 .397-.561q.244-.5.244-1.15v-.115q0-.708-.296-1.267l-.043-.077a2.2 2.2 0 0 0-.633-.709l-.13-.086-.047-.028a2.1 2.1 0 0 0-1.073-.285q-1.052 0-1.629.692zm2.316 2.706c.163-.17.28-.407.28-.83v-.114c0-.292-.06-.508-.15-.68a.96.96 0 0 0-.353-.389.85.85 0 0 0-.464-.127c-.4 0-.56.114-.664.239l-.01.012c-.148.174-.275.45-.275.945 0 .506.122.801.27.99.097.11.266.224.68.224.303 0 .504-.09.687-.269zm7.545 1.705a2.6 2.6 0 0 0 .331.423q.319.33.755.548l.173.074q.65.255 1.49.255 1.02 0 1.844-.493a3.45 3.45 0 0 0 1.316-1.4q.493-.904.493-2.089 0-1.909-.988-2.913-.988-1.02-2.584-1.02-.898 0-1.575.347a3 3 0 0 0-.415.262l-.199.166a3.4 3.4 0 0 0-.64.82V9.242h-1.712v11.553h1.729l-.017-5.134zm.53-1.138q.206.29.48.5l.155.11.053.034q.51.296 1.119.297 1.07 0 1.645-.675.577-.69.576-1.762 0-1.119-.576-1.777-.558-.675-1.645-.675-.435 0-.835.16a2 2 0 0 0-.284.136 2 2 0 0 0-.363.254 2.2 2.2 0 0 0-.46.569l-.082.162a2.6 2.6 0 0 0-.213 1.072v.115q0 .707.296 1.267l.135.211zm.964-.818a1.1 1.1 0 0 0 .367.385.94.94 0 0 0 .476.118c.423 0 .59-.117.687-.23.159-.194.28-.478.28-.95 0-.53-.133-.8-.266-.952l-.021-.025c-.078-.094-.231-.221-.68-.221a1 1 0 0 0-.503.135l-.012.007a.86.86 0 0 0-.335.343c-.073.133-.132.324-.132.614v.115a1.4 1.4 0 0 0 .14.66zm15.7-6.222q.347-.346.346-.856a1.05 1.05 0 0 0-.345-.79 1.18 1.18 0 0 0-.84-.329q-.51 0-.855.33a1.05 1.05 0 0 0-.346.79q0 .51.346.855.345.346.856.346.51 0 .839-.346zm4.337 9.314.033-1.332q.191.403.59.747l.098.081a4 4 0 0 0 .316.224l.223.122a3.2 3.2 0 0 0 1.44.322 3.8 3.8 0 0 0 1.875-.477 3.5 3.5 0 0 0 1.382-1.366q.527-.89.526-2.09 0-1.184-.444-2.073a3.24 3.24 0 0 0-1.283-1.399q-.823-.51-1.942-.51a3.5 3.5 0 0 0-1.527.344l-.086.043-.165.09a3 3 0 0 0-.33.214q-.432.315-.656.707a2 2 0 0 0-.099.198l.082-1.283V4.701h-1.744v12.095zm.473-2.509a2.5 2.5 0 0 0 .566.7q.117.098.245.18l.144.08a2.1 2.1 0 0 0 .975.232q1.07 0 1.645-.675.576-.69.576-1.778 0-1.102-.576-1.777-.56-.691-1.645-.692a2.2 2.2 0 0 0-1.015.235q-.22.113-.415.282l-.15.142a2.1 2.1 0 0 0-.42.594q-.223.479-.223 1.1v.115q0 .705.293 1.26zm2.616-.293c.157-.191.28-.479.28-.967 0-.51-.13-.79-.276-.961l-.021-.026c-.082-.1-.232-.225-.67-.225a.87.87 0 0 0-.681.279l-.012.011c-.154.155-.274.38-.274.807v.115c0 .285.057.499.144.669a1.1 1.1 0 0 0 .367.405c.137.082.28.123.455.123.423 0 .59-.118.686-.23zm8.266-3.013q.345-.13.724-.14l.069-.002q.493 0 .642.099l.247-1.794q-.196-.099-.717-.099a2.3 2.3 0 0 0-.545.063 2 2 0 0 0-.411.148 2.2 2.2 0 0 0-.4.249 2.5 2.5 0 0 0-.485.499 2.7 2.7 0 0 0-.32.581l-.05.137v-1.48h-1.778v7.553h1.777v-3.884q0-.546.159-.943a1.5 1.5 0 0 1 .466-.636 2.5 2.5 0 0 1 .399-.253 2 2 0 0 1 .224-.099zm9.784 2.656.05-.922q0-1.743-.856-2.698-.838-.97-2.584-.97-1.119-.001-2.007.493a3.46 3.46 0 0 0-1.4 1.382q-.493.906-.493 2.106 0 1.07.428 1.975.428.89 1.332 1.432.906.526 2.255.526.973 0 1.668-.185l.044-.012.135-.04q.613-.184.984-.421l-.542-1.267q-.3.162-.642.274l-.297.087q-.51.131-1.3.131-.954 0-1.497-.444a1.6 1.6 0 0 1-.192-.193q-.366-.44-.512-1.234l-.004-.021zm-5.427-1.256-.003.022h3.752v-.138q-.011-.727-.288-1.118a1 1 0 0 0-.156-.176q-.46-.428-1.316-.428-.986 0-1.494.604-.379.45-.494 1.234zm-27.053 2.77V4.7h-1.86v12.095h5.333V15.15zm7.103-5.908v7.553h-1.843V9.242h1.843z'/%3E%3Cpath fill='%23fff' d='m19.63 11.151-.757-1.71-.345 1.71-1.12 5.644h-1.827L18.083 4.7h.197l3.325 6.533.988 2.19.988-2.19L26.839 4.7h.181l2.6 12.095h-1.81l-1.218-5.644-.362-1.71-.658 1.71-2.93 5.644h-.098l-2.913-5.644zm14.836 5.81q-1.02 0-1.893-.478a3.8 3.8 0 0 1-1.381-1.382q-.51-.906-.51-2.106 0-1.185.444-2.074a3.36 3.36 0 0 1 1.3-1.382q.839-.494 1.974-.494a3.3 3.3 0 0 1 1.234.231 3.3 3.3 0 0 1 .97.575q.396.33.527.659l.033-1.267h1.694v7.553H37.18l-.033-1.332q-.279.593-1.02 1.053a3.17 3.17 0 0 1-1.662.444zm.296-1.482q.938 0 1.58-.642.642-.66.642-1.711v-.115q0-.708-.296-1.267a2.2 2.2 0 0 0-.807-.872 2.1 2.1 0 0 0-1.119-.313q-1.053 0-1.629.692-.575.675-.575 1.76 0 1.103.559 1.795.577.675 1.645.675zm6.521-6.237h1.711v1.4q.906-1.597 2.83-1.597 1.596 0 2.584 1.02.988 1.005.988 2.914 0 1.185-.493 2.09a3.46 3.46 0 0 1-1.316 1.399 3.5 3.5 0 0 1-1.844.493q-.954 0-1.662-.329a2.67 2.67 0 0 1-1.086-.97l.017 5.134h-1.728zm4.048 6.22q1.07 0 1.645-.674.577-.69.576-1.762 0-1.119-.576-1.777-.558-.675-1.645-.675-.592 0-1.12.296-.51.28-.822.823-.296.527-.296 1.234v.115q0 .708.296 1.267.313.543.823.855.51.296 1.119.297z'/%3E%3Cpath fill='%23e1e3e9' d='M51.325 4.7h1.86v10.45h3.473v1.646h-5.333zm7.12 4.542h1.843v7.553h-1.843zm.905-1.415a1.16 1.16 0 0 1-.856-.346 1.17 1.17 0 0 1-.346-.856 1.05 1.05 0 0 1 .346-.79q.346-.329.856-.329.494 0 .839.33a1.05 1.05 0 0 1 .345.79 1.16 1.16 0 0 1-.345.855q-.33.346-.84.346zm7.875 9.133a3.17 3.17 0 0 1-1.662-.444q-.723-.46-1.004-1.053l-.033 1.332h-1.71V4.701h1.743v4.657l-.082 1.283q.279-.658 1.086-1.119a3.5 3.5 0 0 1 1.778-.477q1.119 0 1.942.51a3.24 3.24 0 0 1 1.283 1.4q.445.888.444 2.072 0 1.201-.526 2.09a3.5 3.5 0 0 1-1.382 1.366 3.8 3.8 0 0 1-1.876.477zm-.296-1.481q1.069 0 1.645-.675.577-.69.577-1.778 0-1.102-.577-1.776-.56-.691-1.645-.692a2.12 2.12 0 0 0-1.58.659q-.642.641-.642 1.694v.115q0 .71.296 1.267a2.4 2.4 0 0 0 .807.872 2.1 2.1 0 0 0 1.119.313zm5.927-6.237h1.777v1.481q.263-.757.856-1.217a2.14 2.14 0 0 1 1.349-.46q.527 0 .724.098l-.247 1.794q-.149-.099-.642-.099-.774 0-1.416.494-.626.493-.626 1.58v3.883h-1.777V9.242zm9.534 7.718q-1.35 0-2.255-.526-.904-.543-1.332-1.432a4.6 4.6 0 0 1-.428-1.975q0-1.2.493-2.106a3.46 3.46 0 0 1 1.4-1.382q.889-.495 2.007-.494 1.744 0 2.584.97.855.956.856 2.7 0 .444-.05.92h-5.43q.18 1.005.708 1.45.542.443 1.497.443.79 0 1.3-.131a4 4 0 0 0 .938-.362l.542 1.267q-.411.263-1.119.46-.708.198-1.711.197zm1.596-4.558q.016-1.02-.444-1.432-.46-.428-1.316-.428-1.728 0-1.991 1.86z'/%3E%3Cpath d='M5.074 15.948a.484.657 0 0 0-.486.659v1.84a.484.657 0 0 0 .486.659h4.101a.484.657 0 0 0 .486-.659v-1.84a.484.657 0 0 0-.486-.659zm3.56 1.16H5.617v.838h3.017z' style='fill:%23fff;fill-rule:evenodd;stroke-width:1.03600001'/%3E%3Cg style='stroke-width:1.12603545'%3E%3Cpath d='M-9.408-1.416c-3.833-.025-7.056 2.912-7.08 6.615-.02 3.08 1.653 4.832 3.107 6.268.903.892 1.721 1.74 2.32 2.902l-.525-.004c-.543-.003-.992.304-1.24.639a1.87 1.87 0 0 0-.362 1.121l-.011 1.877c-.003.402.104.787.347 1.125.244.338.688.653 1.23.656l4.142.028c.542.003.99-.306 1.238-.641a1.87 1.87 0 0 0 .363-1.121l.012-1.875a1.87 1.87 0 0 0-.348-1.127c-.243-.338-.688-.653-1.23-.656l-.518-.004c.597-1.145 1.425-1.983 2.348-2.87 1.473-1.414 3.18-3.149 3.2-6.226-.016-3.59-2.923-6.684-6.993-6.707m-.006 1.1v.002c3.274.02 5.92 2.532 5.9 5.6-.017 2.706-1.39 4.026-2.863 5.44-1.034.994-2.118 2.033-2.814 3.633-.018.041-.052.055-.075.065q-.013.004-.02.01a.34.34 0 0 1-.226.084.34.34 0 0 1-.224-.086l-.092-.077c-.699-1.615-1.768-2.669-2.781-3.67-1.454-1.435-2.797-2.762-2.78-5.478.02-3.067 2.7-5.545 5.975-5.523m-.02 2.826c-1.62-.01-2.944 1.315-2.955 2.96-.01 1.646 1.295 2.988 2.916 2.999h.002c1.621.01 2.943-1.316 2.953-2.961.011-1.646-1.294-2.988-2.916-2.998m-.005 1.1c1.017.006 1.829.83 1.822 1.89s-.83 1.874-1.848 1.867c-1.018-.006-1.829-.83-1.822-1.89s.83-1.874 1.848-1.868m-2.155 11.857 4.14.025c.271.002.49.305.487.676l-.013 1.875c-.003.37-.224.67-.495.668l-4.14-.025c-.27-.002-.487-.306-.485-.676l.012-1.875c.003-.37.224-.67.494-.668' style='color:%23000;font-style:normal;font-variant:normal;font-weight:400;font-stretch:normal;font-size:medium;line-height:normal;font-family:sans-serif;font-variant-ligatures:normal;font-variant-position:normal;font-variant-caps:normal;font-variant-numeric:normal;font-variant-alternates:normal;font-feature-settings:normal;text-indent:0;text-align:start;text-decoration:none;text-decoration-line:none;text-decoration-style:solid;text-decoration-color:%23000;letter-spacing:normal;word-spacing:normal;text-transform:none;writing-mode:lr-tb;direction:ltr;text-orientation:mixed;dominant-baseline:auto;baseline-shift:baseline;text-anchor:start;white-space:normal;shape-padding:0;clip-rule:evenodd;display:inline;overflow:visible;visibility:visible;opacity:1;isolation:auto;mix-blend-mode:normal;color-interpolation:sRGB;color-interpolation-filters:linearRGB;solid-color:%23000;solid-opacity:1;vector-effect:none;fill:%23000;fill-opacity:.4;fill-rule:evenodd;stroke:none;stroke-width:2.47727823;stroke-linecap:butt;stroke-linejoin:miter;stroke-miterlimit:4;stroke-dasharray:none;stroke-dashoffset:0;stroke-opacity:1;color-rendering:auto;image-rendering:auto;shape-rendering:auto;text-rendering:auto' transform='translate(15.553 2.85)scale(.88807)'/%3E%3Cpath d='M-9.415-.316C-12.69-.338-15.37 2.14-15.39 5.207c-.017 2.716 1.326 4.041 2.78 5.477 1.013 1 2.081 2.055 2.78 3.67l.092.076a.34.34 0 0 0 .225.086.34.34 0 0 0 .227-.083l.019-.01c.022-.009.057-.024.074-.064.697-1.6 1.78-2.64 2.814-3.634 1.473-1.414 2.847-2.733 2.864-5.44.02-3.067-2.627-5.58-5.901-5.601m-.057 8.784c1.621.011 2.944-1.315 2.955-2.96.01-1.646-1.295-2.988-2.916-2.999-1.622-.01-2.945 1.315-2.955 2.96s1.295 2.989 2.916 3' style='clip-rule:evenodd;fill:%23e1e3e9;fill-opacity:1;fill-rule:evenodd;stroke:none;stroke-width:2.47727823;stroke-miterlimit:4;stroke-dasharray:none;stroke-opacity:.4' transform='translate(15.553 2.85)scale(.88807)'/%3E%3Cpath d='M-11.594 15.465c-.27-.002-.492.297-.494.668l-.012 1.876c-.003.371.214.673.485.675l4.14.027c.271.002.492-.298.495-.668l.012-1.877c.003-.37-.215-.672-.485-.674z' style='clip-rule:evenodd;fill:%23fff;fill-opacity:1;fill-rule:evenodd;stroke:none;stroke-width:2.47727823;stroke-miterlimit:4;stroke-dasharray:none;stroke-opacity:.4' transform='translate(15.553 2.85)scale(.88807)'/%3E%3C/g%3E%3C/svg%3E")}}.maplibregl-ctrl.maplibregl-ctrl-attrib{background-color:hsla(0,0%,100%,.5);margin:0;padding:0 5px}@media screen{.maplibregl-ctrl-attrib.maplibregl-compact{background-color:#fff;border-radius:12px;box-sizing:content-box;color:#000;margin:10px;min-height:20px;padding:2px 24px 2px 0;position:relative}.maplibregl-ctrl-attrib.maplibregl-compact-show{padding:2px 28px 2px 8px;visibility:visible}.maplibregl-ctrl-bottom-left>.maplibregl-ctrl-attrib.maplibregl-compact-show,.maplibregl-ctrl-top-left>.maplibregl-ctrl-attrib.maplibregl-compact-show{border-radius:12px;padding:2px 8px 2px 28px}.maplibregl-ctrl-attrib.maplibregl-compact .maplibregl-ctrl-attrib-inner{display:none}.maplibregl-ctrl-attrib-button{background-color:hsla(0,0%,100%,.5);background-image:url("data:image/svg+xml;charset=utf-8,%3Csvg xmlns='http://www.w3.org/2000/svg' width='24' height='24' fill-rule='evenodd' viewBox='0 0 20 20'%3E%3Cpath d='M4 10a6 6 0 1 0 12 0 6 6 0 1 0-12 0m5-3a1 1 0 1 0 2 0 1 1 0 1 0-2 0m0 3a1 1 0 1 1 2 0v3a1 1 0 1 1-2 0'/%3E%3C/svg%3E");border:0;border-radius:12px;box-sizing:border-box;cursor:pointer;display:none;height:24px;outline:none;position:absolute;right:0;top:0;width:24px}.maplibregl-ctrl-attrib summary.maplibregl-ctrl-attrib-button{-webkit-appearance:none;-moz-appearance:none;appearance:none;list-style:none}.maplibregl-ctrl-attrib summary.maplibregl-ctrl-attrib-button::-webkit-details-marker{display:none}.maplibregl-ctrl-bottom-left .maplibregl-ctrl-attrib-button,.maplibregl-ctrl-top-left .maplibregl-ctrl-attrib-button{left:0}.maplibregl-ctrl-attrib.maplibregl-compact .maplibregl-ctrl-attrib-button,.maplibregl-ctrl-attrib.maplibregl-compact-show .maplibregl-ctrl-attrib-inner{display:block}.maplibregl-ctrl-attrib.maplibregl-compact-show .maplibregl-ctrl-attrib-button{background-color:rgb(0 0 0/5%)}.maplibregl-ctrl-bottom-right>.maplibregl-ctrl-attrib.maplibregl-compact:after{bottom:0;right:0}.maplibregl-ctrl-top-right>.maplibregl-ctrl-attrib.maplibregl-compact:after{right:0;top:0}.maplibregl-ctrl-top-left>.maplibregl-ctrl-attrib.maplibregl-compact:after{left:0;top:0}.maplibregl-ctrl-bottom-left>.maplibregl-ctrl-attrib.maplibregl-compact:after{bottom:0;left:0}}@media screen and (forced-colors:active){.maplibregl-ctrl-attrib.maplibregl-compact:after{background-image:url("data:image/svg+xml;charset=utf-8,%3Csvg xmlns='http://www.w3.org/2000/svg' width='24' height='24' fill='%23fff' fill-rule='evenodd' viewBox='0 0 20 20'%3E%3Cpath d='M4 10a6 6 0 1 0 12 0 6 6 0 1 0-12 0m5-3a1 1 0 1 0 2 0 1 1 0 1 0-2 0m0 3a1 1 0 1 1 2 0v3a1 1 0 1 1-2 0'/%3E%3C/svg%3E")}}@media screen and (forced-colors:active) and (prefers-color-scheme:light){.maplibregl-ctrl-attrib.maplibregl-compact:after{background-image:url("data:image/svg+xml;charset=utf-8,%3Csvg xmlns='http://www.w3.org/2000/svg' width='24' height='24' fill-rule='evenodd' viewBox='0 0 20 20'%3E%3Cpath d='M4 10a6 6 0 1 0 12 0 6 6 0 1 0-12 0m5-3a1 1 0 1 0 2 0 1 1 0 1 0-2 0m0 3a1 1 0 1 1 2 0v3a1 1 0 1 1-2 0'/%3E%3C/svg%3E")}}.maplibregl-ctrl-attrib a{color:rgba(0,0,0,.75);text-decoration:none}.maplibregl-ctrl-attrib a:hover{color:inherit;text-decoration:underline}.maplibregl-attrib-empty{display:none}.maplibregl-ctrl-scale{background-color:hsla(0,0%,100%,.75);border:2px solid #333;border-top:#333;box-sizing:border-box;color:#333;font-size:10px;padding:0 5px}.maplibregl-popup{display:flex;left:0;pointer-events:none;position:absolute;top:0;will-change:transform}.maplibregl-popup-anchor-top,.maplibregl-popup-anchor-top-left,.maplibregl-popup-anchor-top-right{flex-direction:column}.maplibregl-popup-anchor-bottom,.maplibregl-popup-anchor-bottom-left,.maplibregl-popup-anchor-bottom-right{flex-direction:column-reverse}.maplibregl-popup-anchor-left{flex-direction:row}.maplibregl-popup-anchor-right{flex-direction:row-reverse}.maplibregl-popup-tip{border:10px solid transparent;height:0;width:0;z-index:1}.maplibregl-popup-anchor-top .maplibregl-popup-tip{align-self:center;border-bottom-color:#fff;border-top:none}.maplibregl-popup-anchor-top-left .maplibregl-popup-tip{align-self:flex-start;border-bottom-color:#fff;border-left:none;border-top:none}.maplibregl-popup-anchor-top-right .maplibregl-popup-tip{align-self:flex-end;border-bottom-color:#fff;border-right:none;border-top:none}.maplibregl-popup-anchor-bottom .maplibregl-popup-tip{align-self:center;border-bottom:none;border-top-color:#fff}.maplibregl-popup-anchor-bottom-left .maplibregl-popup-tip{align-self:flex-start;border-bottom:none;border-left:none;border-top-color:#fff}.maplibregl-popup-anchor-bottom-right .maplibregl-popup-tip{align-self:flex-end;border-bottom:none;border-right:none;border-top-color:#fff}.maplibregl-popup-anchor-left .maplibregl-popup-tip{align-self:center;border-left:none;border-right-color:#fff}.maplibregl-popup-anchor-right .maplibregl-popup-tip{align-self:center;border-left-color:#fff;border-right:none}.maplibregl-popup-close-button{background-color:transparent;border:0;border-radius:0 3px 0 0;cursor:pointer;position:absolute;right:0;top:0}.maplibregl-popup-close-button:hover{background-color:rgb(0 0 0/5%)}.maplibregl-popup-content{background:#fff;border-radius:3px;box-shadow:0 1px 2px rgba(0,0,0,.1);padding:15px 10px;pointer-events:auto;position:relative}.maplibregl-popup-anchor-top-left .maplibregl-popup-content{border-top-left-radius:0}.maplibregl-popup-anchor-top-right .maplibregl-popup-content{border-top-right-radius:0}.maplibregl-popup-anchor-bottom-left .maplibregl-popup-content{border-bottom-left-radius:0}.maplibregl-popup-anchor-bottom-right .maplibregl-popup-content{border-bottom-right-radius:0}.maplibregl-popup-track-pointer{display:none}.maplibregl-popup-track-pointer *{pointer-events:none;-webkit-user-select:none;-moz-user-select:none;user-select:none}.maplibregl-map:hover .maplibregl-popup-track-pointer{display:flex}.maplibregl-map:active .maplibregl-popup-track-pointer{display:none}.maplibregl-marker{left:0;position:absolute;top:0;transition:opacity .2s;will-change:transform}.maplibregl-user-location-dot,.maplibregl-user-location-dot:before{background-color:#1da1f2;border-radius:50%;height:15px;width:15px}.maplibregl-user-location-dot:before{animation:maplibregl-user-location-dot-pulse 2s infinite;content:"";position:absolute}.maplibregl-user-location-dot:after{border:2px solid #fff;border-radius:50%;box-shadow:0 0 3px rgba(0,0,0,.35);box-sizing:border-box;content:"";height:19px;left:-2px;position:absolute;top:-2px;width:19px}@keyframes maplibregl-user-location-dot-pulse{0%{opacity:1;transform:scale(1)}70%{opacity:0;transform:scale(3)}to{opacity:0;transform:scale(1)}}.maplibregl-user-location-dot-stale{background-color:#aaa}.maplibregl-user-location-dot-stale:after{display:none}.maplibregl-user-location-accuracy-circle{background-color:#1da1f233;border-radius:100%;height:1px;width:1px}.maplibregl-crosshair,.maplibregl-crosshair .maplibregl-interactive,.maplibregl-crosshair .maplibregl-interactive:active{cursor:crosshair}.maplibregl-boxzoom{background:#fff;border:2px dotted #202020;height:0;left:0;opacity:.5;position:absolute;top:0;width:0}.maplibregl-cooperative-gesture-screen{align-items:center;background:rgba(0,0,0,.4);color:#fff;display:flex;font-size:1.4em;inset:0;justify-content:center;line-height:1.2;opacity:0;padding:1rem;pointer-events:none;position:absolute;transition:opacity 1s ease 1s;z-index:99999}.maplibregl-cooperative-gesture-screen.maplibregl-show{opacity:1;transition:opacity .05s}.maplibregl-cooperative-gesture-screen .maplibregl-mobile-message{display:none}@media (hover:none),(width <= 480px){.maplibregl-cooperative-gesture-screen .maplibregl-desktop-message{display:none}.maplibregl-cooperative-gesture-screen .maplibregl-mobile-message{display:block}}.maplibregl-pseudo-fullscreen{height:100%!important;left:0!important;position:fixed!important;top:0!important;width:100%!important;z-index:99999}`, document.head.appendChild(e);
+          }
+        })();
+      });
+      var qa = ye((el) => {
+        var x3 = K1(), iie = L6(), nie = NO(), bit = Ty(), wit = HS().addStyleRule, aie = Ao(), Tit = Gl(), Ait = _3(), Sit = aie.extendFlat, WO = aie.extendDeepAll;
+        el.modules = {};
+        el.allCategories = {};
+        el.allTypes = [];
+        el.subplotsRegistry = {};
+        el.componentsRegistry = {};
+        el.layoutArrayContainers = [];
+        el.layoutArrayRegexes = [];
+        el.traceLayoutAttributes = {};
+        el.localeRegistry = {};
+        el.apiMethodRegistry = {};
+        el.collectableSubplotTypes = null;
+        el.register = function(t) {
+          if (el.collectableSubplotTypes = null, t) t && !Array.isArray(t) && (t = [t]);
+          else throw new Error("No argument passed to Plotly.register.");
+          for (var r = 0; r < t.length; r++) {
+            var n = t[r];
+            if (!n) throw new Error("Invalid module was attempted to be registered!");
+            switch (n.moduleType) {
+              case "trace":
+                Mit(n);
+                break;
+              case "transform":
+                Cit(n);
+                break;
+              case "component":
+                kit(n);
+                break;
+              case "locale":
+                Lit(n);
+                break;
+              case "apiMethod":
+                var i = n.name;
+                el.apiMethodRegistry[i] = n.fn;
+                break;
+              default:
+                throw new Error("Invalid module was attempted to be registered!");
+            }
+          }
+        };
+        el.getModule = function(e) {
+          var t = el.modules[uie(e)];
+          return t ? t._module : false;
+        };
+        el.traceIs = function(e, t) {
+          if (e = uie(e), e === "various") return false;
+          var r = el.modules[e];
+          return r || (e && x3.log("Unrecognized trace type " + e + "."), r = el.modules[Tit.type.dflt]), !!r.categories[t];
+        };
+        el.getComponentMethod = function(e, t) {
+          var r = el.componentsRegistry[e];
+          return r && r[t] || iie;
+        };
+        el.call = function() {
+          var e = arguments[0], t = [].slice.call(arguments, 1);
+          return el.apiMethodRegistry[e].apply(null, t);
+        };
+        function Mit(e) {
+          var t = e.name, r = e.categories, n = e.meta;
+          if (el.modules[t]) {
+            x3.log("Type " + t + " already registered");
+            return;
+          }
+          el.subplotsRegistry[e.basePlotModule.name] || Eit(e.basePlotModule);
+          for (var i = {}, a = 0; a < r.length; a++) i[r[a]] = true, el.allCategories[r[a]] = true;
+          el.modules[t] = { _module: e, categories: i }, n && Object.keys(n).length && (el.modules[t].meta = n), el.allTypes.push(t);
+          for (var o in el.componentsRegistry) sie(o, t);
+          e.layoutAttributes && Sit(el.traceLayoutAttributes, e.layoutAttributes);
+          var s = e.basePlotModule, l = s.name;
+          if (l === "mapbox") {
+            var u = s.constants.styleRules;
+            for (var c in u) wit(".js-plotly-plot .plotly .mapboxgl-" + c, u[c]);
+          }
+          l === "map" && rie(), (l === "geo" || l === "mapbox" || l === "map") && window.PlotlyGeoAssets === void 0 && (window.PlotlyGeoAssets = { topojson: {} });
+        }
+        function Eit(e) {
+          var t = e.name;
+          if (el.subplotsRegistry[t]) {
+            x3.log("Plot type " + t + " already registered.");
+            return;
+          }
+          oie(e), el.subplotsRegistry[t] = e;
+          for (var r in el.componentsRegistry) lie(r, e.name);
+        }
+        function kit(e) {
+          if (typeof e.name != "string") throw new Error("Component module *name* must be a string.");
+          var t = e.name;
+          el.componentsRegistry[t] = e, e.layoutAttributes && (e.layoutAttributes._isLinkedToArray && nie(el.layoutArrayContainers, t), oie(e));
+          for (var r in el.modules) sie(t, r);
+          for (var n in el.subplotsRegistry) lie(t, n);
+          e.schema && e.schema.layout && WO(Ait, e.schema.layout);
+        }
+        function Cit(e) {
+          if (typeof e.name != "string") throw new Error("Transform module *name* must be a string.");
+          var t = "Transform module " + e.name, r = typeof e.transform == "function", n = typeof e.calcTransform == "function";
+          if (!r && !n) throw new Error(t + " is missing a *transform* or *calcTransform* method.");
+          r && n && x3.log([t + " has both a *transform* and *calcTransform* methods.", "Please note that all *transform* methods are executed", "before all *calcTransform* methods."].join(" ")), bit(e.attributes) || x3.log(t + " registered without an *attributes* object."), typeof e.supplyDefaults != "function" && x3.log(t + " registered without a *supplyDefaults* method.");
+        }
+        function Lit(e) {
+          var t = e.name, r = t.split("-")[0], n = e.dictionary, i = e.format, a = n && Object.keys(n).length, o = i && Object.keys(i).length, s = el.localeRegistry, l = s[t];
+          if (l || (s[t] = l = {}), r !== t) {
+            var u = s[r];
+            u || (s[r] = u = {}), a && u.dictionary === l.dictionary && (u.dictionary = n), o && u.format === l.format && (u.format = i);
+          }
+          a && (l.dictionary = n), o && (l.format = i);
+        }
+        function oie(e) {
+          if (e.layoutAttributes) {
+            var t = e.layoutAttributes._arrayAttrRegexps;
+            if (t) for (var r = 0; r < t.length; r++) nie(el.layoutArrayRegexes, t[r]);
+          }
+        }
+        function sie(e, t) {
+          var r = el.componentsRegistry[e].schema;
+          if (!(!r || !r.traces)) {
+            var n = r.traces[t];
+            n && WO(el.modules[t]._module.attributes, n);
+          }
+        }
+        function lie(e, t) {
+          var r = el.componentsRegistry[e].schema;
+          if (!(!r || !r.subplots)) {
+            var n = el.subplotsRegistry[t], i = n.layoutAttributes, a = n.attr === "subplot" ? n.name : n.attr;
+            Array.isArray(a) && (a = a[0]);
+            var o = r.subplots[a];
+            i && o && WO(i, o);
+          }
+        }
+        function uie(e) {
+          return typeof e == "object" && (e = e.type), e;
+        }
+      });
+      var yie = ye((hh) => {
+        var Pit = f3().timeFormat, gie = Eo(), XO = K1(), e_ = d3().mod, T3 = fs(), _0 = T3.BADNUM, Ap = T3.ONEDAY, WS = T3.ONEHOUR, Q1 = T3.ONEMIN, w3 = T3.ONESEC, XS = T3.EPOCHJD, Ay = qa(), cie = f3().utcFormat, Iit = /^\s*(-?\d\d\d\d|\d\d)(-(\d?\d)(-(\d?\d)([ Tt]([01]?\d|2[0-3])(:([0-5]\d)(:([0-5]\d(\.\d+)?))?(Z|z|[+\-]\d\d(:?\d\d)?)?)?)?)?)?\s*$/m, Rit = /^\s*(-?\d\d\d\d|\d\d)(-(\d?\di?)(-(\d?\d)([ Tt]([01]?\d|2[0-3])(:([0-5]\d)(:([0-5]\d(\.\d+)?))?(Z|z|[+\-]\d\d(:?\d\d)?)?)?)?)?)?\s*$/m, fie = (/* @__PURE__ */ new Date()).getFullYear() - 70;
+        function Sy(e) {
+          return e && Ay.componentsRegistry.calendars && typeof e == "string" && e !== "gregorian";
+        }
+        hh.dateTick0 = function(e, t) {
+          var r = Dit(e, !!t);
+          if (t < 2) return r;
+          var n = hh.dateTime2ms(r, e);
+          return n += Ap * (t - 1), hh.ms2DateTime(n, 0, e);
+        };
+        function Dit(e, t) {
+          return Sy(e) ? t ? Ay.getComponentMethod("calendars", "CANONICAL_SUNDAY")[e] : Ay.getComponentMethod("calendars", "CANONICAL_TICK")[e] : t ? "2000-01-02" : "2000-01-01";
+        }
+        hh.dfltRange = function(e) {
+          return Sy(e) ? Ay.getComponentMethod("calendars", "DFLTRANGE")[e] : ["2000-01-01", "2001-01-01"];
+        };
+        hh.isJSDate = function(e) {
+          return typeof e == "object" && e !== null && typeof e.getTime == "function";
+        };
+        var B6, N6;
+        hh.dateTime2ms = function(e, t) {
+          if (hh.isJSDate(e)) {
+            var r = e.getTimezoneOffset() * Q1, n = (e.getUTCMinutes() - e.getMinutes()) * Q1 + (e.getUTCSeconds() - e.getSeconds()) * w3 + (e.getUTCMilliseconds() - e.getMilliseconds());
+            if (n) {
+              var i = 3 * Q1;
+              r = r - i / 2 + e_(n - r + i / 2, i);
+            }
+            return e = Number(e) - r, e >= B6 && e <= N6 ? e : _0;
+          }
+          if (typeof e != "string" && typeof e != "number") return _0;
+          e = String(e);
+          var a = Sy(t), o = e.charAt(0);
+          a && (o === "G" || o === "g") && (e = e.slice(1), t = "");
+          var s = a && t.slice(0, 7) === "chinese", l = e.match(s ? Rit : Iit);
+          if (!l) return _0;
+          var u = l[1], c = l[3] || "1", f = Number(l[5] || 1), h = Number(l[7] || 0), d = Number(l[9] || 0), v = Number(l[11] || 0);
+          if (a) {
+            if (u.length === 2) return _0;
+            u = Number(u);
+            var _;
+            try {
+              var b = Ay.getComponentMethod("calendars", "getCal")(t);
+              if (s) {
+                var p = c.charAt(c.length - 1) === "i";
+                c = parseInt(c, 10), _ = b.newDate(u, b.toMonthIndex(u, c, p), f);
+              } else _ = b.newDate(u, Number(c), f);
+            } catch (E) {
+              return _0;
+            }
+            return _ ? (_.toJD() - XS) * Ap + h * WS + d * Q1 + v * w3 : _0;
+          }
+          u.length === 2 ? u = (Number(u) + 2e3 - fie) % 100 + fie : u = Number(u), c -= 1;
+          var k = new Date(Date.UTC(2e3, c, f, h, d));
+          return k.setUTCFullYear(u), k.getUTCMonth() !== c || k.getUTCDate() !== f ? _0 : k.getTime() + v * w3;
+        };
+        B6 = hh.MIN_MS = hh.dateTime2ms("-9999");
+        N6 = hh.MAX_MS = hh.dateTime2ms("9999-12-31 23:59:59.9999");
+        hh.isDateTime = function(e, t) {
+          return hh.dateTime2ms(e, t) !== _0;
+        };
+        function b3(e, t) {
+          return String(e + Math.pow(10, t)).slice(1);
+        }
+        var q6 = 90 * Ap, hie = 3 * WS, die = 5 * Q1;
+        hh.ms2DateTime = function(e, t, r) {
+          if (typeof e != "number" || !(e >= B6 && e <= N6)) return _0;
+          t || (t = 0);
+          var n = Math.floor(e_(e + 0.05, 1) * 10), i = Math.round(e - n / 10), a, o, s, l, u, c;
+          if (Sy(r)) {
+            var f = Math.floor(i / Ap) + XS, h = Math.floor(e_(e, Ap));
+            try {
+              a = Ay.getComponentMethod("calendars", "getCal")(r).fromJD(f).formatDate("yyyy-mm-dd");
+            } catch (d) {
+              a = cie("G%Y-%m-%d")(new Date(i));
+            }
+            if (a.charAt(0) === "-") for (; a.length < 11; ) a = "-0" + a.slice(1);
+            else for (; a.length < 10; ) a = "0" + a;
+            o = t < q6 ? Math.floor(h / WS) : 0, s = t < q6 ? Math.floor(h % WS / Q1) : 0, l = t < hie ? Math.floor(h % Q1 / w3) : 0, u = t < die ? h % w3 * 10 + n : 0;
+          } else c = new Date(i), a = cie("%Y-%m-%d")(c), o = t < q6 ? c.getUTCHours() : 0, s = t < q6 ? c.getUTCMinutes() : 0, l = t < hie ? c.getUTCSeconds() : 0, u = t < die ? c.getUTCMilliseconds() * 10 + n : 0;
+          return mie(a, o, s, l, u);
+        };
+        hh.ms2DateTimeLocal = function(e) {
+          if (!(e >= B6 + Ap && e <= N6 - Ap)) return _0;
+          var t = Math.floor(e_(e + 0.05, 1) * 10), r = new Date(Math.round(e - t / 10)), n = Pit("%Y-%m-%d")(r), i = r.getHours(), a = r.getMinutes(), o = r.getSeconds(), s = r.getUTCMilliseconds() * 10 + t;
+          return mie(n, i, a, o, s);
+        };
+        function mie(e, t, r, n, i) {
+          if ((t || r || n || i) && (e += " " + b3(t, 2) + ":" + b3(r, 2), (n || i) && (e += ":" + b3(n, 2), i))) {
+            for (var a = 4; i % 10 === 0; ) a -= 1, i /= 10;
+            e += "." + b3(i, a);
+          }
+          return e;
+        }
+        hh.cleanDate = function(e, t, r) {
+          if (e === _0) return t;
+          if (hh.isJSDate(e) || typeof e == "number" && isFinite(e)) {
+            if (Sy(r)) return XO.error("JS Dates and milliseconds are incompatible with world calendars", e), t;
+            if (e = hh.ms2DateTimeLocal(+e), !e && t !== void 0) return t;
+          } else if (!hh.isDateTime(e, r)) return XO.error("unrecognized date", e), t;
+          return e;
+        };
+        var Fit = /%\d?f/g, zit = /%h/g, Oit = { 1: "1", 2: "1", 3: "2", 4: "2" };
+        function vie(e, t, r, n) {
+          e = e.replace(Fit, function(a) {
+            var o = Math.min(+a.charAt(1) || 6, 6), s = (t / 1e3 % 1 + 2).toFixed(o).slice(2).replace(/0+$/, "") || "0";
+            return s;
+          });
+          var i = new Date(Math.floor(t + 0.05));
+          if (e = e.replace(zit, function() {
+            return Oit[r("%q")(i)];
+          }), Sy(n)) try {
+            e = Ay.getComponentMethod("calendars", "worldCalFmt")(e, t, n);
+          } catch (a) {
+            return "Invalid";
+          }
+          return r(e)(i);
+        }
+        var qit = [59, 59.9, 59.99, 59.999, 59.9999];
+        function Bit(e, t) {
+          var r = e_(e + 0.05, Ap), n = b3(Math.floor(r / WS), 2) + ":" + b3(e_(Math.floor(r / Q1), 60), 2);
+          if (t !== "M") {
+            gie(t) || (t = 0);
+            var i = Math.min(e_(e / w3, 60), qit[t]), a = (100 + i).toFixed(t).slice(1);
+            t > 0 && (a = a.replace(/0+$/, "").replace(/[\.]$/, "")), n += ":" + a;
+          }
+          return n;
+        }
+        hh.formatDate = function(e, t, r, n, i, a) {
+          if (i = Sy(i) && i, !t) if (r === "y") t = a.year;
+          else if (r === "m") t = a.month;
+          else if (r === "d") t = a.dayMonth + `
+` + a.year;
+          else return Bit(e, r) + `
+` + vie(a.dayMonthYear, e, n, i);
+          return vie(t, e, n, i);
+        };
+        var pie = 3 * Ap;
+        hh.incrementMonth = function(e, t, r) {
+          r = Sy(r) && r;
+          var n = e_(e, Ap);
+          if (e = Math.round(e - n), r) try {
+            var i = Math.round(e / Ap) + XS, a = Ay.getComponentMethod("calendars", "getCal")(r), o = a.fromJD(i);
+            return t % 12 ? a.add(o, t, "m") : a.add(o, t / 12, "y"), (o.toJD() - XS) * Ap + n;
+          } catch (l) {
+            XO.error("invalid ms " + e + " in calendar " + r);
+          }
+          var s = new Date(e + pie);
+          return s.setUTCMonth(s.getUTCMonth() + t) + n - pie;
+        };
+        hh.findExactDates = function(e, t) {
+          for (var r = 0, n = 0, i = 0, a = 0, o, s, l = Sy(t) && Ay.getComponentMethod("calendars", "getCal")(t), u = 0; u < e.length; u++) {
+            if (s = e[u], !gie(s)) {
+              a++;
+              continue;
+            }
+            if (!(s % Ap)) if (l) try {
+              o = l.fromJD(s / Ap + XS), o.day() === 1 ? o.month() === 1 ? r++ : n++ : i++;
+            } catch (f) {
+            }
+            else o = new Date(s), o.getUTCDate() === 1 ? o.getUTCMonth() === 0 ? r++ : n++ : i++;
+          }
+          n += r, i += n;
+          var c = e.length - a;
+          return { exactYears: r / c, exactMonths: n / c, exactDays: i / c };
+        };
+      });
+      var ZS = ye((qir, _ie) => {
+        _ie.exports = function(t) {
+          return t;
+        };
+      });
+      var U6 = ye((My) => {
+        var Nit = Eo(), Uit = K1(), Vit = ZS(), Git = fs().BADNUM, ZO = 1e-9;
+        My.findBin = function(e, t, r) {
+          if (Nit(t.start)) return r ? Math.ceil((e - t.start) / t.size - ZO) - 1 : Math.floor((e - t.start) / t.size + ZO);
+          var n = 0, i = t.length, a = 0, o = i > 1 ? (t[i - 1] - t[0]) / (i - 1) : 1, s, l;
+          for (o >= 0 ? l = r ? Hit : jit : l = r ? Xit : Wit, e += o * ZO * (r ? -1 : 1) * (o >= 0 ? 1 : -1); n < i && a++ < 100; ) s = Math.floor((n + i) / 2), l(t[s], e) ? n = s + 1 : i = s;
+          return a > 90 && Uit.log("Long binary search..."), n - 1;
+        };
+        function Hit(e, t) {
+          return e < t;
+        }
+        function jit(e, t) {
+          return e <= t;
+        }
+        function Wit(e, t) {
+          return e > t;
+        }
+        function Xit(e, t) {
+          return e >= t;
+        }
+        My.sorterAsc = function(e, t) {
+          return e - t;
+        };
+        My.sorterDes = function(e, t) {
+          return t - e;
+        };
+        My.distinctVals = function(e) {
+          var t = e.slice();
+          t.sort(My.sorterAsc);
+          var r;
+          for (r = t.length - 1; r > -1 && t[r] === Git; r--) ;
+          for (var n = t[r] - t[0] || 1, i = n / (r || 1) / 1e4, a = [], o, s = 0; s <= r; s++) {
+            var l = t[s], u = l - o;
+            o === void 0 ? (a.push(l), o = l) : u > i && (n = Math.min(n, u), a.push(l), o = l);
+          }
+          return { vals: a, minDiff: n };
+        };
+        My.roundUp = function(e, t, r) {
+          for (var n = 0, i = t.length - 1, a, o = 0, s = r ? 0 : 1, l = r ? 1 : 0, u = r ? Math.ceil : Math.floor; n < i && o++ < 100; ) a = u((n + i) / 2), t[a] <= e ? n = a + s : i = a - l;
+          return t[n];
+        };
+        My.sort = function(e, t) {
+          for (var r = 0, n = 0, i = 1; i < e.length; i++) {
+            var a = t(e[i], e[i - 1]);
+            if (a < 0 ? r = 1 : a > 0 && (n = 1), r && n) return e.sort(t);
+          }
+          return n ? e : e.reverse();
+        };
+        My.findIndexOfMin = function(e, t) {
+          t = t || Vit;
+          for (var r = 1 / 0, n, i = 0; i < e.length; i++) {
+            var a = t(e[i]);
+            a < r && (r = a, n = i);
+          }
+          return n;
+        };
+      });
+      var t_ = ye((Nir, xie) => {
+        xie.exports = function(t) {
+          return Object.keys(t).sort();
+        };
+      });
+      var bie = ye((dh) => {
+        var YS = Eo(), Zit = vv().isArrayOrTypedArray;
+        dh.aggNums = function(e, t, r, n) {
+          var i, a;
+          if ((!n || n > r.length) && (n = r.length), YS(t) || (t = false), Zit(r[0])) {
+            for (a = new Array(n), i = 0; i < n; i++) a[i] = dh.aggNums(e, t, r[i]);
+            r = a;
+          }
+          for (i = 0; i < n; i++) YS(t) ? YS(r[i]) && (t = e(+t, +r[i])) : t = r[i];
+          return t;
+        };
+        dh.len = function(e) {
+          return dh.aggNums(function(t) {
+            return t + 1;
+          }, 0, e);
+        };
+        dh.mean = function(e, t) {
+          return t || (t = dh.len(e)), dh.aggNums(function(r, n) {
+            return r + n;
+          }, 0, e) / t;
+        };
+        dh.geometricMean = function(e, t) {
+          return t || (t = dh.len(e)), Math.pow(dh.aggNums(function(r, n) {
+            return r * n;
+          }, 1, e), 1 / t);
+        };
+        dh.midRange = function(e) {
+          if (!(e === void 0 || e.length === 0)) return (dh.aggNums(Math.max, null, e) + dh.aggNums(Math.min, null, e)) / 2;
+        };
+        dh.variance = function(e, t, r) {
+          return t || (t = dh.len(e)), YS(r) || (r = dh.mean(e, t)), dh.aggNums(function(n, i) {
+            return n + Math.pow(i - r, 2);
+          }, 0, e) / t;
+        };
+        dh.stdev = function(e, t, r) {
+          return Math.sqrt(dh.variance(e, t, r));
+        };
+        dh.median = function(e) {
+          var t = e.slice().sort();
+          return dh.interp(t, 0.5);
+        };
+        dh.interp = function(e, t) {
+          if (!YS(t)) throw "n should be a finite number";
+          if (t = t * e.length - 0.5, t < 0) return e[0];
+          if (t > e.length - 1) return e[e.length - 1];
+          var r = t % 1;
+          return r * e[Math.ceil(t)] + (1 - r) * e[Math.floor(t)];
+        };
+      });
+      var Mie = ye((Vir, Sie) => {
+        var wie = d3(), YO = wie.mod, Yit = wie.modHalf, KS = Math.PI, r_ = 2 * KS;
+        function Kit(e) {
+          return e / 180 * KS;
+        }
+        function Jit(e) {
+          return e / KS * 180;
+        }
+        function KO(e) {
+          return Math.abs(e[1] - e[0]) > r_ - 1e-14;
+        }
+        function Tie(e, t) {
+          return Yit(t - e, r_);
+        }
+        function $it(e, t) {
+          return Math.abs(Tie(e, t));
+        }
+        function Aie(e, t) {
+          if (KO(t)) return true;
+          var r, n;
+          t[0] < t[1] ? (r = t[0], n = t[1]) : (r = t[1], n = t[0]), r = YO(r, r_), n = YO(n, r_), r > n && (n += r_);
+          var i = YO(e, r_), a = i + r_;
+          return i >= r && i <= n || a >= r && a <= n;
+        }
+        function Qit(e, t, r, n) {
+          if (!Aie(t, n)) return false;
+          var i, a;
+          return r[0] < r[1] ? (i = r[0], a = r[1]) : (i = r[1], a = r[0]), e >= i && e <= a;
+        }
+        function JO(e, t, r, n, i, a, o) {
+          i = i || 0, a = a || 0;
+          var s = KO([r, n]), l, u, c, f, h;
+          s ? (l = 0, u = KS, c = r_) : r < n ? (l = r, c = n) : (l = n, c = r), e < t ? (f = e, h = t) : (f = t, h = e);
+          function d(p, k) {
+            return [p * Math.cos(k) + i, a - p * Math.sin(k)];
+          }
+          var v = Math.abs(c - l) <= KS ? 0 : 1;
+          function _(p, k, E) {
+            return "A" + [p, p] + " " + [0, v, E] + " " + d(p, k);
+          }
+          var b;
+          return s ? f === null ? b = "M" + d(h, l) + _(h, u, 0) + _(h, c, 0) + "Z" : b = "M" + d(f, l) + _(f, u, 0) + _(f, c, 0) + "ZM" + d(h, l) + _(h, u, 1) + _(h, c, 1) + "Z" : f === null ? (b = "M" + d(h, l) + _(h, c, 0), o && (b += "L0,0Z")) : b = "M" + d(f, l) + "L" + d(h, l) + _(h, c, 0) + "L" + d(f, c) + _(f, l, 1) + "Z", b;
+        }
+        function ent(e, t, r, n, i) {
+          return JO(null, e, t, r, n, i, 0);
+        }
+        function tnt(e, t, r, n, i) {
+          return JO(null, e, t, r, n, i, 1);
+        }
+        function rnt(e, t, r, n, i, a) {
+          return JO(e, t, r, n, i, a, 1);
+        }
+        Sie.exports = { deg2rad: Kit, rad2deg: Jit, angleDelta: Tie, angleDist: $it, isFullCircle: KO, isAngleInsideSector: Aie, isPtInsideSector: Qit, pathArc: ent, pathSector: tnt, pathAnnulus: rnt };
+      });
+      var Eie = ye((bb) => {
+        bb.isLeftAnchor = function(t) {
+          return t.xanchor === "left" || t.xanchor === "auto" && t.x <= 1 / 3;
+        };
+        bb.isCenterAnchor = function(t) {
+          return t.xanchor === "center" || t.xanchor === "auto" && t.x > 1 / 3 && t.x < 2 / 3;
+        };
+        bb.isRightAnchor = function(t) {
+          return t.xanchor === "right" || t.xanchor === "auto" && t.x >= 2 / 3;
+        };
+        bb.isTopAnchor = function(t) {
+          return t.yanchor === "top" || t.yanchor === "auto" && t.y >= 2 / 3;
+        };
+        bb.isMiddleAnchor = function(t) {
+          return t.yanchor === "middle" || t.yanchor === "auto" && t.y > 1 / 3 && t.y < 2 / 3;
+        };
+        bb.isBottomAnchor = function(t) {
+          return t.yanchor === "bottom" || t.yanchor === "auto" && t.y <= 1 / 3;
+        };
+      });
+      var Lie = ye((wb) => {
+        var $O = d3().mod;
+        wb.segmentsIntersect = Cie;
+        function Cie(e, t, r, n, i, a, o, s) {
+          var l = r - e, u = i - e, c = o - i, f = n - t, h = a - t, d = s - a, v = l * d - c * f;
+          if (v === 0) return null;
+          var _ = (u * d - c * h) / v, b = (u * f - l * h) / v;
+          return b < 0 || b > 1 || _ < 0 || _ > 1 ? null : { x: e + l * _, y: t + f * _ };
+        }
+        wb.segmentDistance = function(t, r, n, i, a, o, s, l) {
+          if (Cie(t, r, n, i, a, o, s, l)) return 0;
+          var u = n - t, c = i - r, f = s - a, h = l - o, d = u * u + c * c, v = f * f + h * h, _ = Math.min(V6(u, c, d, a - t, o - r), V6(u, c, d, s - t, l - r), V6(f, h, v, t - a, r - o), V6(f, h, v, n - a, i - o));
+          return Math.sqrt(_);
+        };
+        function V6(e, t, r, n, i) {
+          var a = n * e + i * t;
+          if (a < 0) return n * n + i * i;
+          if (a > r) {
+            var o = n - e, s = i - t;
+            return o * o + s * s;
+          } else {
+            var l = n * t - i * e;
+            return l * l / r;
+          }
+        }
+        var G6, QO, kie;
+        wb.getTextLocation = function(t, r, n, i) {
+          if ((t !== QO || i !== kie) && (G6 = {}, QO = t, kie = i), G6[n]) return G6[n];
+          var a = t.getPointAtLength($O(n - i / 2, r)), o = t.getPointAtLength($O(n + i / 2, r)), s = Math.atan((o.y - a.y) / (o.x - a.x)), l = t.getPointAtLength($O(n, r)), u = (l.x * 4 + a.x + o.x) / 6, c = (l.y * 4 + a.y + o.y) / 6, f = { x: u, y: c, theta: s };
+          return G6[n] = f, f;
+        };
+        wb.clearLocationCache = function() {
+          QO = null;
+        };
+        wb.getVisibleSegment = function(t, r, n) {
+          var i = r.left, a = r.right, o = r.top, s = r.bottom, l = 0, u = t.getTotalLength(), c = u, f, h;
+          function d(_) {
+            var b = t.getPointAtLength(_);
+            _ === 0 ? f = b : _ === u && (h = b);
+            var p = b.x < i ? i - b.x : b.x > a ? b.x - a : 0, k = b.y < o ? o - b.y : b.y > s ? b.y - s : 0;
+            return Math.sqrt(p * p + k * k);
+          }
+          for (var v = d(l); v; ) {
+            if (l += v + n, l > c) return;
+            v = d(l);
+          }
+          for (v = d(c); v; ) {
+            if (c -= v + n, l > c) return;
+            v = d(c);
+          }
+          return { min: l, max: c, len: c - l, total: u, isClosed: l === 0 && c === u && Math.abs(f.x - h.x) < 0.1 && Math.abs(f.y - h.y) < 0.1 };
+        };
+        wb.findPointOnPath = function(t, r, n, i) {
+          i = i || {};
+          for (var a = i.pathLength || t.getTotalLength(), o = i.tolerance || 1e-3, s = i.iterationLimit || 30, l = t.getPointAtLength(0)[n] > t.getPointAtLength(a)[n] ? -1 : 1, u = 0, c = 0, f = a, h, d, v; u < s; ) {
+            if (h = (c + f) / 2, d = t.getPointAtLength(h), v = d[n] - r, Math.abs(v) < o) return d;
+            l * v > 0 ? f = h : c = h, u++;
+          }
+          return d;
+        };
+      });
+      var H6 = ye((JS) => {
+        var Ey = {};
+        JS.throttle = function(t, r, n) {
+          var i = Ey[t], a = Date.now();
+          if (!i) {
+            for (var o in Ey) Ey[o].ts < a - 6e4 && delete Ey[o];
+            i = Ey[t] = { ts: 0, timer: null };
+          }
+          Pie(i);
+          function s() {
+            n(), i.ts = Date.now(), i.onDone && (i.onDone(), i.onDone = null);
+          }
+          if (a > i.ts + r) {
+            s();
+            return;
+          }
+          i.timer = setTimeout(function() {
+            s(), i.timer = null;
+          }, r);
+        };
+        JS.done = function(e) {
+          var t = Ey[e];
+          return !t || !t.timer ? Promise.resolve() : new Promise(function(r) {
+            var n = t.onDone;
+            t.onDone = function() {
+              n && n(), r(), t.onDone = null;
+            };
+          });
+        };
+        JS.clear = function(e) {
+          if (e) Pie(Ey[e]), delete Ey[e];
+          else for (var t in Ey) JS.clear(t);
+        };
+        function Pie(e) {
+          e && e.timer !== null && (clearTimeout(e.timer), e.timer = null);
+        }
+      });
+      var Rie = ye((Wir, Iie) => {
+        Iie.exports = function(t) {
+          t._responsiveChartHandler && (window.removeEventListener("resize", t._responsiveChartHandler), delete t._responsiveChartHandler);
+        };
+      });
+      var Die = ye((Xir, j6) => {
+        j6.exports = eq;
+        j6.exports.isMobile = eq;
+        j6.exports.default = eq;
+        var int = /(android|bb\d+|meego).+mobile|armv7l|avantgo|bada\/|blackberry|blazer|compal|elaine|fennec|hiptop|iemobile|ip(hone|od)|iris|kindle|lge |maemo|midp|mmp|mobile.+firefox|netfront|opera m(ob|in)i|palm( os)?|phone|p(ixi|re)\/|plucker|pocket|psp|series[46]0|samsungbrowser.*mobile|symbian|treo|up\.(browser|link)|vodafone|wap|windows (ce|phone)|xda|xiino/i, nnt = /CrOS/, ant = /android|ipad|playbook|silk/i;
+        function eq(e) {
+          e || (e = {});
+          let t = e.ua;
+          if (!t && typeof navigator != "undefined" && (t = navigator.userAgent), t && t.headers && typeof t.headers["user-agent"] == "string" && (t = t.headers["user-agent"]), typeof t != "string") return false;
+          let r = int.test(t) && !nnt.test(t) || !!e.tablet && ant.test(t);
+          return !r && e.tablet && e.featureDetect && navigator && navigator.maxTouchPoints > 1 && t.indexOf("Macintosh") !== -1 && t.indexOf("Safari") !== -1 && (r = true), r;
+        }
+      });
+      var zie = ye((Zir, Fie) => {
+        var ont = Eo(), snt = Die();
+        Fie.exports = function(t) {
+          var r;
+          if (t && t.hasOwnProperty("userAgent") ? r = t.userAgent : r = lnt(), typeof r != "string") return true;
+          var n = snt({ ua: { headers: { "user-agent": r } }, tablet: true, featureDetect: false });
+          if (!n) for (var i = r.split(" "), a = 1; a < i.length; a++) {
+            var o = i[a];
+            if (o.indexOf("Safari") !== -1) for (var s = a - 1; s > -1; s--) {
+              var l = i[s];
+              if (l.slice(0, 8) === "Version/") {
+                var u = l.slice(8).split(".")[0];
+                if (ont(u) && (u = +u), u >= 13) return true;
+              }
+            }
+          }
+          return n;
+        };
+        function lnt() {
+          var e;
+          return typeof navigator != "undefined" && (e = navigator.userAgent), e && e.headers && typeof e.headers["user-agent"] == "string" && (e = e.headers["user-agent"]), e;
+        }
+      });
+      var qie = ye((Yir, Oie) => {
+        var unt = Oa();
+        Oie.exports = function(t, r, n) {
+          var i = t.selectAll("g." + n.replace(/\s/g, ".")).data(r, function(o) {
+            return o[0].trace.uid;
+          });
+          i.exit().remove(), i.enter().append("g").attr("class", n), i.order();
+          var a = t.classed("rangeplot") ? "nodeRangePlot3" : "node3";
+          return i.each(function(o) {
+            o[0][a] = unt.select(this);
+          }), i;
+        };
+      });
+      var Nie = ye((Kir, Bie) => {
+        var cnt = qa();
+        Bie.exports = function(t, r) {
+          for (var n = t._context.locale, i = 0; i < 2; i++) {
+            for (var a = t._context.locales, o = 0; o < 2; o++) {
+              var s = (a[n] || {}).dictionary;
+              if (s) {
+                var l = s[r];
+                if (l) return l;
+              }
+              a = cnt.localeRegistry;
+            }
+            var u = n.split("-")[0];
+            if (u === n) break;
+            n = u;
+          }
+          return r;
+        };
+      });
+      var tq = ye((Jir, Uie) => {
+        Uie.exports = function(t) {
+          for (var r = {}, n = [], i = 0, a = 0; a < t.length; a++) {
+            var o = t[a];
+            r[o] !== 1 && (r[o] = 1, n[i++] = o);
+          }
+          return n;
+        };
+      });
+      var Gie = ye(($ir, Vie) => {
+        Vie.exports = function(t) {
+          for (var r = dnt(t) ? hnt : fnt, n = [], i = 0; i < t.length; i++) {
+            var a = t[i];
+            r(a) && n.push(a);
+          }
+          return n;
+        };
+        function fnt(e) {
+          return e.visible === true;
+        }
+        function hnt(e) {
+          var t = e[0].trace;
+          return t.visible === true && t._length !== 0;
+        }
+        function dnt(e) {
+          return Array.isArray(e) && Array.isArray(e[0]) && e[0][0] && e[0][0].trace;
+        }
+      });
+      var jie = ye((Qir, Hie) => {
+        Hie.exports = function(t, r) {
+          if (!r) return t;
+          var n = 1 / Math.abs(r), i = n > 1 ? (n * t + n * r) / n : t + r, a = String(i).length;
+          if (a > 16) {
+            var o = String(r).length, s = String(t).length;
+            if (a >= s + o) {
+              var l = parseFloat(i).toPrecision(12);
+              l.indexOf("e+") === -1 && (i = +l);
+            }
+          }
+          return i;
+        };
+      });
+      var Xie = ye((enr, Wie) => {
+        var vnt = Eo(), pnt = fs().BADNUM, gnt = /^['"%,$#\s']+|[, ]|['"%,$#\s']+$/g;
+        Wie.exports = function(t) {
+          return typeof t == "string" && (t = t.replace(gnt, "")), vnt(t) ? Number(t) : pnt;
+        };
+      });
+      var Dr = ye((tnr, one) => {
+        var $S = Oa(), mnt = f3().utcFormat, ynt = MO().format, Qie = Eo(), ene = fs(), tne = ene.FP_SAFE, _nt = -tne, Zie = ene.BADNUM, Mi = one.exports = {};
+        Mi.adjustFormat = function(t) {
+          return !t || /^\d[.]\df/.test(t) || /[.]\d%/.test(t) ? t : t === "0.f" ? "~f" : /^\d%/.test(t) ? "~%" : /^\ds/.test(t) ? "~s" : !/^[~,.0$]/.test(t) && /[&fps]/.test(t) ? "~" + t : t;
+        };
+        var Yie = {};
+        Mi.warnBadFormat = function(e) {
+          var t = String(e);
+          Yie[t] || (Yie[t] = 1, Mi.warn('encountered bad format: "' + t + '"'));
+        };
+        Mi.noFormat = function(e) {
+          return String(e);
+        };
+        Mi.numberFormat = function(e) {
+          var t;
+          try {
+            t = ynt(Mi.adjustFormat(e));
+          } catch (r) {
+            return Mi.warnBadFormat(e), Mi.noFormat;
+          }
+          return t;
+        };
+        Mi.nestedProperty = FS();
+        Mi.keyedContainer = Uee();
+        Mi.relativeAttr = Gee();
+        Mi.isPlainObject = Ty();
+        Mi.toLogRange = S6();
+        Mi.relinkPrivateKeys = Xee();
+        var i_ = vv();
+        Mi.isArrayBuffer = i_.isArrayBuffer;
+        Mi.isTypedArray = i_.isTypedArray;
+        Mi.isArrayOrTypedArray = i_.isArrayOrTypedArray;
+        Mi.isArray1D = i_.isArray1D;
+        Mi.ensureArray = i_.ensureArray;
+        Mi.concat = i_.concat;
+        Mi.maxRowLength = i_.maxRowLength;
+        Mi.minRowLength = i_.minRowLength;
+        var rne = d3();
+        Mi.mod = rne.mod;
+        Mi.modHalf = rne.modHalf;
+        var n_ = hte();
+        Mi.valObjectMeta = n_.valObjectMeta;
+        Mi.coerce = n_.coerce;
+        Mi.coerce2 = n_.coerce2;
+        Mi.coerceFont = n_.coerceFont;
+        Mi.coercePattern = n_.coercePattern;
+        Mi.coerceHoverinfo = n_.coerceHoverinfo;
+        Mi.coerceSelectionMarkerOpacity = n_.coerceSelectionMarkerOpacity;
+        Mi.validate = n_.validate;
+        var jp = yie();
+        Mi.dateTime2ms = jp.dateTime2ms;
+        Mi.isDateTime = jp.isDateTime;
+        Mi.ms2DateTime = jp.ms2DateTime;
+        Mi.ms2DateTimeLocal = jp.ms2DateTimeLocal;
+        Mi.cleanDate = jp.cleanDate;
+        Mi.isJSDate = jp.isJSDate;
+        Mi.formatDate = jp.formatDate;
+        Mi.incrementMonth = jp.incrementMonth;
+        Mi.dateTick0 = jp.dateTick0;
+        Mi.dfltRange = jp.dfltRange;
+        Mi.findExactDates = jp.findExactDates;
+        Mi.MIN_MS = jp.MIN_MS;
+        Mi.MAX_MS = jp.MAX_MS;
+        var Tb = U6();
+        Mi.findBin = Tb.findBin;
+        Mi.sorterAsc = Tb.sorterAsc;
+        Mi.sorterDes = Tb.sorterDes;
+        Mi.distinctVals = Tb.distinctVals;
+        Mi.roundUp = Tb.roundUp;
+        Mi.sort = Tb.sort;
+        Mi.findIndexOfMin = Tb.findIndexOfMin;
+        Mi.sortObjectKeys = t_();
+        var ky = bie();
+        Mi.aggNums = ky.aggNums;
+        Mi.len = ky.len;
+        Mi.mean = ky.mean;
+        Mi.geometricMean = ky.geometricMean;
+        Mi.median = ky.median;
+        Mi.midRange = ky.midRange;
+        Mi.variance = ky.variance;
+        Mi.stdev = ky.stdev;
+        Mi.interp = ky.interp;
+        var wg = P6();
+        Mi.init2dArray = wg.init2dArray;
+        Mi.transposeRagged = wg.transposeRagged;
+        Mi.dot = wg.dot;
+        Mi.translationMatrix = wg.translationMatrix;
+        Mi.rotationMatrix = wg.rotationMatrix;
+        Mi.rotationXYMatrix = wg.rotationXYMatrix;
+        Mi.apply3DTransform = wg.apply3DTransform;
+        Mi.apply2DTransform = wg.apply2DTransform;
+        Mi.apply2DTransform2 = wg.apply2DTransform2;
+        Mi.convertCssMatrix = wg.convertCssMatrix;
+        Mi.inverseTransformMatrix = wg.inverseTransformMatrix;
+        var gm = Mie();
+        Mi.deg2rad = gm.deg2rad;
+        Mi.rad2deg = gm.rad2deg;
+        Mi.angleDelta = gm.angleDelta;
+        Mi.angleDist = gm.angleDist;
+        Mi.isFullCircle = gm.isFullCircle;
+        Mi.isAngleInsideSector = gm.isAngleInsideSector;
+        Mi.isPtInsideSector = gm.isPtInsideSector;
+        Mi.pathArc = gm.pathArc;
+        Mi.pathSector = gm.pathSector;
+        Mi.pathAnnulus = gm.pathAnnulus;
+        var S3 = Eie();
+        Mi.isLeftAnchor = S3.isLeftAnchor;
+        Mi.isCenterAnchor = S3.isCenterAnchor;
+        Mi.isRightAnchor = S3.isRightAnchor;
+        Mi.isTopAnchor = S3.isTopAnchor;
+        Mi.isMiddleAnchor = S3.isMiddleAnchor;
+        Mi.isBottomAnchor = S3.isBottomAnchor;
+        var M3 = Lie();
+        Mi.segmentsIntersect = M3.segmentsIntersect;
+        Mi.segmentDistance = M3.segmentDistance;
+        Mi.getTextLocation = M3.getTextLocation;
+        Mi.clearLocationCache = M3.clearLocationCache;
+        Mi.getVisibleSegment = M3.getVisibleSegment;
+        Mi.findPointOnPath = M3.findPointOnPath;
+        var Z6 = Ao();
+        Mi.extendFlat = Z6.extendFlat;
+        Mi.extendDeep = Z6.extendDeep;
+        Mi.extendDeepAll = Z6.extendDeepAll;
+        Mi.extendDeepNoArrays = Z6.extendDeepNoArrays;
+        var rq = K1();
+        Mi.log = rq.log;
+        Mi.warn = rq.warn;
+        Mi.error = rq.error;
+        var xnt = p3();
+        Mi.counterRegex = xnt.counter;
+        var iq = H6();
+        Mi.throttle = iq.throttle;
+        Mi.throttleDone = iq.done;
+        Mi.clearThrottle = iq.clear;
+        var Tg = HS();
+        Mi.getGraphDiv = Tg.getGraphDiv;
+        Mi.isPlotDiv = Tg.isPlotDiv;
+        Mi.removeElement = Tg.removeElement;
+        Mi.addStyleRule = Tg.addStyleRule;
+        Mi.addRelatedStyleRule = Tg.addRelatedStyleRule;
+        Mi.deleteRelatedStyleRule = Tg.deleteRelatedStyleRule;
+        Mi.setStyleOnHover = Tg.setStyleOnHover;
+        Mi.getFullTransformMatrix = Tg.getFullTransformMatrix;
+        Mi.getElementTransformMatrix = Tg.getElementTransformMatrix;
+        Mi.getElementAndAncestors = Tg.getElementAndAncestors;
+        Mi.equalDomRects = Tg.equalDomRects;
+        Mi.clearResponsive = Rie();
+        Mi.preserveDrawingBuffer = zie();
+        Mi.makeTraceGroups = qie();
+        Mi._ = Nie();
+        Mi.notifier = OO();
+        Mi.filterUnique = tq();
+        Mi.filterVisible = Gie();
+        Mi.pushUnique = NO();
+        Mi.increment = jie();
+        Mi.cleanNumber = Xie();
+        Mi.ensureNumber = function(t) {
+          return Qie(t) ? (t = Number(t), t > tne || t < _nt ? Zie : t) : Zie;
+        };
+        Mi.isIndex = function(e, t) {
+          return t !== void 0 && e >= t ? false : Qie(e) && e >= 0 && e % 1 === 0;
+        };
+        Mi.noop = L6();
+        Mi.identity = ZS();
+        Mi.repeat = function(e, t) {
+          for (var r = new Array(t), n = 0; n < t; n++) r[n] = e;
+          return r;
+        };
+        Mi.swapAttrs = function(e, t, r, n) {
+          r || (r = "x"), n || (n = "y");
+          for (var i = 0; i < t.length; i++) {
+            var a = t[i], o = Mi.nestedProperty(e, a.replace("?", r)), s = Mi.nestedProperty(e, a.replace("?", n)), l = o.get();
+            o.set(s.get()), s.set(l);
+          }
+        };
+        Mi.raiseToTop = function(t) {
+          t.parentNode.appendChild(t);
+        };
+        Mi.cancelTransition = function(e) {
+          return e.transition().duration(0);
+        };
+        Mi.constrain = function(e, t, r) {
+          return t > r ? Math.max(r, Math.min(t, e)) : Math.max(t, Math.min(r, e));
+        };
+        Mi.bBoxIntersect = function(e, t, r) {
+          return r = r || 0, e.left <= t.right + r && t.left <= e.right + r && e.top <= t.bottom + r && t.top <= e.bottom + r;
+        };
+        Mi.simpleMap = function(e, t, r, n, i) {
+          for (var a = e.length, o = new Array(a), s = 0; s < a; s++) o[s] = t(e[s], r, n, i);
+          return o;
+        };
+        Mi.randstr = function e(t, r, n, i) {
+          if (n || (n = 16), r === void 0 && (r = 24), r <= 0) return "0";
+          var a = Math.log(Math.pow(2, r)) / Math.log(n), o = "", s, l, u;
+          for (s = 2; a === 1 / 0; s *= 2) a = Math.log(Math.pow(2, r / s)) / Math.log(n) * s;
+          var c = a - Math.floor(a);
+          for (s = 0; s < Math.floor(a); s++) u = Math.floor(Math.random() * n).toString(n), o = u + o;
+          c && (l = Math.pow(n, c), u = Math.floor(Math.random() * l).toString(n), o = u + o);
+          var f = parseInt(o, n);
+          return t && t[o] || f !== 1 / 0 && f >= Math.pow(2, r) ? i > 10 ? (Mi.warn("randstr failed uniqueness"), o) : e(t, r, n, (i || 0) + 1) : o;
+        };
+        Mi.OptionControl = function(e, t) {
+          e || (e = {}), t || (t = "opt");
+          var r = {};
+          return r.optionList = [], r._newoption = function(n) {
+            n[t] = e, r[n.name] = n, r.optionList.push(n);
+          }, r["_" + t] = e, r;
+        };
+        Mi.smooth = function(e, t) {
+          if (t = Math.round(t) || 0, t < 2) return e;
+          var r = e.length, n = 2 * r, i = 2 * t - 1, a = new Array(i), o = new Array(r), s, l, u, c;
+          for (s = 0; s < i; s++) a[s] = (1 - Math.cos(Math.PI * (s + 1) / t)) / (2 * t);
+          for (s = 0; s < r; s++) {
+            for (c = 0, l = 0; l < i; l++) u = s + l + 1 - t, u < -r ? u -= n * Math.round(u / n) : u >= n && (u -= n * Math.floor(u / n)), u < 0 ? u = -1 - u : u >= r && (u = n - 1 - u), c += e[u] * a[l];
+            o[s] = c;
+          }
+          return o;
+        };
+        Mi.syncOrAsync = function(e, t, r) {
+          var n, i;
+          function a() {
+            return Mi.syncOrAsync(e, t, r);
+          }
+          for (; e.length; ) if (i = e.splice(0, 1)[0], n = i(t), n && n.then) return n.then(a);
+          return r && r(t);
+        };
+        Mi.stripTrailingSlash = function(e) {
+          return e.slice(-1) === "/" ? e.slice(0, -1) : e;
+        };
+        Mi.noneOrAll = function(e, t, r) {
+          if (e) {
+            var n = false, i = true, a, o;
+            for (a = 0; a < r.length; a++) o = e[r[a]], o != null ? n = true : i = false;
+            if (n && !i) for (a = 0; a < r.length; a++) e[r[a]] = t[r[a]];
+          }
+        };
+        Mi.mergeArray = function(e, t, r, n) {
+          var i = typeof n == "function";
+          if (Mi.isArrayOrTypedArray(e)) for (var a = Math.min(e.length, t.length), o = 0; o < a; o++) {
+            var s = e[o];
+            t[o][r] = i ? n(s) : s;
+          }
+        };
+        Mi.mergeArrayCastPositive = function(e, t, r) {
+          return Mi.mergeArray(e, t, r, function(n) {
+            var i = +n;
+            return isFinite(i) && i > 0 ? i : 0;
+          });
+        };
+        Mi.fillArray = function(e, t, r, n) {
+          if (n = n || Mi.identity, Mi.isArrayOrTypedArray(e)) for (var i = 0; i < t.length; i++) t[i][r] = n(e[i]);
+        };
+        Mi.castOption = function(e, t, r, n) {
+          n = n || Mi.identity;
+          var i = Mi.nestedProperty(e, r).get();
+          return Mi.isArrayOrTypedArray(i) ? Array.isArray(t) && Mi.isArrayOrTypedArray(i[t[0]]) ? n(i[t[0]][t[1]]) : n(i[t]) : i;
+        };
+        Mi.extractOption = function(e, t, r, n) {
+          if (r in e) return e[r];
+          var i = Mi.nestedProperty(t, n).get();
+          if (!Array.isArray(i)) return i;
+        };
+        function ine(e) {
+          var t = {};
+          for (var r in e) for (var n = e[r], i = 0; i < n.length; i++) t[n[i]] = +r;
+          return t;
+        }
+        Mi.tagSelected = function(e, t, r) {
+          var n = t.selectedpoints, i = t._indexToPoints, a;
+          i && (a = ine(i));
+          function o(f) {
+            return f !== void 0 && f < e.length;
+          }
+          for (var s = 0; s < n.length; s++) {
+            var l = n[s];
+            if (Mi.isIndex(l) || Mi.isArrayOrTypedArray(l) && Mi.isIndex(l[0]) && Mi.isIndex(l[1])) {
+              var u = a ? a[l] : l, c = r ? r[u] : u;
+              o(c) && (e[c].selected = 1);
+            }
+          }
+        };
+        Mi.selIndices2selPoints = function(e) {
+          var t = e.selectedpoints, r = e._indexToPoints;
+          if (r) {
+            for (var n = ine(r), i = [], a = 0; a < t.length; a++) {
+              var o = t[a];
+              if (Mi.isIndex(o)) {
+                var s = n[o];
+                Mi.isIndex(s) && i.push(s);
+              }
+            }
+            return i;
+          } else return t;
+        };
+        Mi.getTargetArray = function(e, t) {
+          var r = t.target;
+          if (typeof r == "string" && r) {
+            var n = Mi.nestedProperty(e, r).get();
+            return Mi.isArrayOrTypedArray(n) ? n : false;
+          } else if (Mi.isArrayOrTypedArray(r)) return r;
+          return false;
+        };
+        function nne(e, t, r) {
+          var n = {};
+          typeof t != "object" && (t = {});
+          var i = r === "pieLike" ? -1 : 3, a = Object.keys(e), o, s, l;
+          for (o = 0; o < a.length; o++) s = a[o], l = e[s], !(s.charAt(0) === "_" || typeof l == "function") && (s === "module" ? n[s] = l : Array.isArray(l) ? s === "colorscale" || i === -1 ? n[s] = l.slice() : n[s] = l.slice(0, i) : Mi.isTypedArray(l) ? i === -1 ? n[s] = l.subarray() : n[s] = l.subarray(0, i) : l && typeof l == "object" ? n[s] = nne(e[s], t[s], r) : n[s] = l);
+          for (a = Object.keys(t), o = 0; o < a.length; o++) s = a[o], l = t[s], (typeof l != "object" || !(s in n) || typeof n[s] != "object") && (n[s] = l);
+          return n;
+        }
+        Mi.minExtend = nne;
+        Mi.titleCase = function(e) {
+          return e.charAt(0).toUpperCase() + e.slice(1);
+        };
+        Mi.containsAny = function(e, t) {
+          for (var r = 0; r < t.length; r++) if (e.indexOf(t[r]) !== -1) return true;
+          return false;
+        };
+        var bnt = /Version\/[\d\.]+.*Safari/;
+        Mi.isSafari = function() {
+          return bnt.test(window.navigator.userAgent);
+        };
+        var wnt = /iPad|iPhone|iPod/;
+        Mi.isIOS = function() {
+          return wnt.test(window.navigator.userAgent);
+        };
+        var Tnt = /Macintosh.+AppleWebKit.+Gecko\)$/;
+        Mi.isMacWKWebView = () => Tnt.test(window.navigator.userAgent);
+        var Ant = /Firefox\/(\d+)\.\d+/;
+        Mi.getFirefoxVersion = function() {
+          var e = Ant.exec(window.navigator.userAgent);
+          if (e && e.length === 2) {
+            var t = parseInt(e[1]);
+            if (!isNaN(t)) return t;
+          }
+          return null;
+        };
+        Mi.isD3Selection = function(e) {
+          return e instanceof $S.selection;
+        };
+        Mi.ensureSingle = function(e, t, r, n) {
+          var i = e.select(t + (r ? "." + r : ""));
+          if (i.size()) return i;
+          var a = e.append(t);
+          return r && a.classed(r, true), n && a.call(n), a;
+        };
+        Mi.ensureSingleById = function(e, t, r, n) {
+          var i = e.select(t + "#" + r);
+          if (i.size()) return i;
+          var a = e.append(t).attr("id", r);
+          return n && a.call(n), a;
+        };
+        Mi.objectFromPath = function(e, t) {
+          for (var r = e.split("."), n, i = n = {}, a = 0; a < r.length; a++) {
+            var o = r[a], s = null, l = r[a].match(/(.*)\[([0-9]+)\]/);
+            l ? (o = l[1], s = l[2], n = n[o] = [], a === r.length - 1 ? n[s] = t : n[s] = {}, n = n[s]) : (a === r.length - 1 ? n[o] = t : n[o] = {}, n = n[o]);
+          }
+          return i;
+        };
+        var Snt = /^([^\[\.]+)\.(.+)?/, Mnt = /^([^\.]+)\[([0-9]+)\](\.)?(.+)?/;
+        function W6(e) {
+          return e.slice(0, 2) === "__";
+        }
+        Mi.expandObjectPaths = function(e) {
+          var t, r, n, i, a, o, s;
+          if (typeof e == "object" && !Array.isArray(e)) {
+            for (r in e) if (e.hasOwnProperty(r)) if (t = r.match(Snt)) {
+              if (i = e[r], n = t[1], W6(n)) continue;
+              delete e[r], e[n] = Mi.extendDeepNoArrays(e[n] || {}, Mi.objectFromPath(r, Mi.expandObjectPaths(i))[n]);
+            } else if (t = r.match(Mnt)) {
+              if (i = e[r], n = t[1], W6(n)) continue;
+              if (a = parseInt(t[2]), delete e[r], e[n] = e[n] || [], t[3] === ".") s = t[4], o = e[n][a] = e[n][a] || {}, Mi.extendDeepNoArrays(o, Mi.objectFromPath(s, Mi.expandObjectPaths(i)));
+              else {
+                if (W6(n)) continue;
+                e[n][a] = Mi.expandObjectPaths(i);
+              }
+            } else {
+              if (W6(r)) continue;
+              e[r] = Mi.expandObjectPaths(e[r]);
+            }
+          }
+          return e;
+        };
+        Mi.numSeparate = function(e, t, r) {
+          if (r || (r = false), typeof t != "string" || t.length === 0) throw new Error("Separator string required for formatting!");
+          typeof e == "number" && (e = String(e));
+          var n = /(\d+)(\d{3})/, i = t.charAt(0), a = t.charAt(1), o = e.split("."), s = o[0], l = o.length > 1 ? i + o[1] : "";
+          if (a && (o.length > 1 || s.length > 4 || r)) for (; n.test(s); ) s = s.replace(n, "$1" + a + "$2");
+          return s + l;
+        };
+        Mi.TEMPLATE_STRING_REGEX = /%{([^\s%{}:]*)([:|\|][^}]*)?}/g;
+        var ane = /^\w*$/;
+        Mi.templateString = function(e, t) {
+          var r = {};
+          return e.replace(Mi.TEMPLATE_STRING_REGEX, function(n, i) {
+            var a;
+            return ane.test(i) ? a = t[i] : (r[i] = r[i] || Mi.nestedProperty(t, i).get, a = r[i](true)), a !== void 0 ? a : "";
+          });
+        };
+        var Ent = { max: 10, count: 0, name: "hovertemplate" };
+        Mi.hovertemplateString = (e) => nq(j1(_g({}, e), { opts: Ent }));
+        var knt = { max: 10, count: 0, name: "texttemplate" };
+        Mi.texttemplateString = (e) => nq(j1(_g({}, e), { opts: knt }));
+        var Cnt = /^(\S+)([\*\/])(-?\d+(\.\d+)?)$/;
+        function Lnt(e) {
+          var t = e.match(Cnt);
+          return t ? { key: t[1], op: t[2], number: Number(t[3]) } : { key: e, op: null, number: null };
+        }
+        var Pnt = { max: 10, count: 0, name: "texttemplate", parseMultDiv: true };
+        Mi.texttemplateStringForShapes = (e) => nq(j1(_g({}, e), { opts: Pnt }));
+        var Kie = /^[:|\|]/;
+        function nq({ data: e = [], locale: t, fallback: r, labels: n = {}, opts: i, template: a }) {
+          return a.replace(Mi.TEMPLATE_STRING_REGEX, (o, s, l) => {
+            let u = ["xother", "yother"].includes(s), c = ["_xother", "_yother"].includes(s), f = ["_xother_", "_yother_"].includes(s), h = ["xother_", "yother_"].includes(s), d = u || c || h || f;
+            (c || f) && (s = s.substring(1)), (h || f) && (s = s.substring(0, s.length - 1));
+            let v = null, _ = null;
+            if (i.parseMultDiv) {
+              var b = Lnt(s);
+              s = b.key, v = b.op, _ = b.number;
+            }
+            let p;
+            if (d) {
+              if (n[s] === void 0) return "";
+              p = n[s];
+            } else for (let L of e) if (L) {
+              if (L.hasOwnProperty(s)) {
+                p = L[s];
+                break;
+              }
+              if (ane.test(s) || (p = Mi.nestedProperty(L, s).get(true)), p !== void 0) break;
+            }
+            if (p === void 0) {
+              let { count: L, max: x, name: C } = i, M = r === false ? o : r;
+              return L < x && Mi.warn([`Variable '${s}' in ${C} could not be found!`, "Please verify that the template is correct.", `Using value: '${M}'.`].join(" ")), L === x && Mi.warn(`Too many '${C}' warnings - additional warnings will be suppressed.`), i.count++, M;
+            }
+            if (v === "*" && (p *= _), v === "/" && (p /= _), l) {
+              var k;
+              if (l[0] === ":" && (k = t ? t.numberFormat : Mi.numberFormat, p !== "" && (p = k(l.replace(Kie, ""))(p))), l[0] === "|") {
+                k = t ? t.timeFormat : mnt;
+                var E = Mi.dateTime2ms(p);
+                p = Mi.formatDate(E, l.replace(Kie, ""), false, k);
+              }
+            } else {
+              var T = s + "Label";
+              n.hasOwnProperty(T) && (p = n[T]);
+            }
+            return d && (p = "(" + p + ")", (c || f) && (p = " " + p), (h || f) && (p = p + " ")), p;
+          });
+        }
+        var X6 = 48, Jie = 57;
+        Mi.subplotSort = function(e, t) {
+          for (var r = Math.min(e.length, t.length) + 1, n = 0, i = 0, a = 0; a < r; a++) {
+            var o = e.charCodeAt(a) || 0, s = t.charCodeAt(a) || 0, l = o >= X6 && o <= Jie, u = s >= X6 && s <= Jie;
+            if (l && (n = 10 * n + o - X6), u && (i = 10 * i + s - X6), !l || !u) {
+              if (n !== i) return n - i;
+              if (o !== s) return o - s;
+            }
+          }
+          return i - n;
+        };
+        var A3 = 2e9;
+        Mi.seedPseudoRandom = function() {
+          A3 = 2e9;
+        };
+        Mi.pseudoRandom = function() {
+          var e = A3;
+          return A3 = (69069 * A3 + 1) % 4294967296, Math.abs(A3 - e) < 429496729 ? Mi.pseudoRandom() : A3 / 4294967296;
+        };
+        Mi.fillText = function(e, t, r) {
+          var n = Array.isArray(r) ? function(o) {
+            r.push(o);
+          } : function(o) {
+            r.text = o;
+          }, i = Mi.extractOption(e, t, "htx", "hovertext");
+          if (Mi.isValidTextValue(i)) return n(i);
+          var a = Mi.extractOption(e, t, "tx", "text");
+          if (Mi.isValidTextValue(a)) return n(a);
+        };
+        Mi.isValidTextValue = function(e) {
+          return e || e === 0;
+        };
+        Mi.formatPercent = function(e, t) {
+          t = t || 0;
+          for (var r = (Math.round(100 * e * Math.pow(10, t)) * Math.pow(0.1, t)).toFixed(t) + "%", n = 0; n < t; n++) r.indexOf(".") !== -1 && (r = r.replace("0%", "%"), r = r.replace(".%", "%"));
+          return r;
+        };
+        Mi.isHidden = function(e) {
+          var t = window.getComputedStyle(e).display;
+          return !t || t === "none";
+        };
+        Mi.strTranslate = function(e, t) {
+          return e || t ? "translate(" + e + "," + t + ")" : "";
+        };
+        Mi.strRotate = function(e) {
+          return e ? "rotate(" + e + ")" : "";
+        };
+        Mi.strScale = function(e) {
+          return e !== 1 ? "scale(" + e + ")" : "";
+        };
+        Mi.getTextTransform = function(e) {
+          var t = e.noCenter, r = e.textX, n = e.textY, i = e.targetX, a = e.targetY, o = e.anchorX || 0, s = e.anchorY || 0, l = e.rotate, u = e.scale;
+          return u ? u > 1 && (u = 1) : u = 0, Mi.strTranslate(i - u * (r + o), a - u * (n + s)) + Mi.strScale(u) + (l ? "rotate(" + l + (t ? "" : " " + r + " " + n) + ")" : "");
+        };
+        Mi.setTransormAndDisplay = function(e, t) {
+          e.attr("transform", Mi.getTextTransform(t)), e.style("display", t.scale ? null : "none");
+        };
+        Mi.ensureUniformFontSize = function(e, t) {
+          var r = Mi.extendFlat({}, t);
+          return r.size = Math.max(t.size, e._fullLayout.uniformtext.minsize || 0), r;
+        };
+        Mi.join2 = function(e, t, r) {
+          var n = e.length;
+          return n > 1 ? e.slice(0, -1).join(t) + r + e[n - 1] : e.join(t);
+        };
+        Mi.bigFont = function(e) {
+          return Math.round(1.2 * e);
+        };
+        var $ie = Mi.getFirefoxVersion(), Int = $ie !== null && $ie < 86;
+        Mi.getPositionFromD3Event = function() {
+          return Int ? [$S.event.layerX, $S.event.layerY] : [$S.event.offsetX, $S.event.offsetY];
+        };
+      });
+      var une = ye(() => {
+        var Rnt = Dr(), sne = { "X,X div": 'direction:ltr;font-family:"Open Sans",verdana,arial,sans-serif;margin:0;padding:0;border:0;', "X input,X button": 'font-family:"Open Sans",verdana,arial,sans-serif;', "X input:focus,X button:focus": "outline:none;", "X a": "text-decoration:none;", "X a:hover": "text-decoration:none;", "X .crisp": "shape-rendering:crispEdges;", "X .user-select-none": "-webkit-user-select:none;-moz-user-select:none;-ms-user-select:none;-o-user-select:none;user-select:none;", "X svg a": "fill:#447adb;", "X svg a:hover": "fill:#3c6dc5;", "X .main-svg": "position:absolute;top:0;left:0;pointer-events:none;", "X .main-svg .draglayer": "pointer-events:all;", "X .cursor-default": "cursor:default;", "X .cursor-pointer": "cursor:pointer;", "X .cursor-crosshair": "cursor:crosshair;", "X .cursor-move": "cursor:move;", "X .cursor-col-resize": "cursor:col-resize;", "X .cursor-row-resize": "cursor:row-resize;", "X .cursor-ns-resize": "cursor:ns-resize;", "X .cursor-ew-resize": "cursor:ew-resize;", "X .cursor-sw-resize": "cursor:sw-resize;", "X .cursor-s-resize": "cursor:s-resize;", "X .cursor-se-resize": "cursor:se-resize;", "X .cursor-w-resize": "cursor:w-resize;", "X .cursor-e-resize": "cursor:e-resize;", "X .cursor-nw-resize": "cursor:nw-resize;", "X .cursor-n-resize": "cursor:n-resize;", "X .cursor-ne-resize": "cursor:ne-resize;", "X .cursor-grab": "cursor:-webkit-grab;cursor:grab;", "X .modebar": "position:absolute;top:2px;right:2px;", "X .ease-bg": "-webkit-transition:background-color .3s ease 0s;-moz-transition:background-color .3s ease 0s;-ms-transition:background-color .3s ease 0s;-o-transition:background-color .3s ease 0s;transition:background-color .3s ease 0s;", "X .modebar--hover>:not(.watermark)": "opacity:0;-webkit-transition:opacity .3s ease 0s;-moz-transition:opacity .3s ease 0s;-ms-transition:opacity .3s ease 0s;-o-transition:opacity .3s ease 0s;transition:opacity .3s ease 0s;", "X:hover .modebar--hover .modebar-group": "opacity:1;", "X:focus-within .modebar--hover .modebar-group": "opacity:1;", "X .modebar-group": "float:left;display:inline-block;box-sizing:border-box;padding-left:8px;position:relative;vertical-align:middle;white-space:nowrap;", "X .modebar-group a": "display:grid;place-content:center;", "X .modebar-btn": "position:relative;font-size:16px;padding:3px 4px;height:22px;cursor:pointer;line-height:normal;box-sizing:border-box;border:none;background:rgba(0,0,0,0);", "X .modebar-btn svg": "position:relative;", "X .modebar-btn:focus-visible": "outline:1px solid #000;outline-offset:1px;border-radius:3px;", "X .modebar.vertical": "display:flex;flex-direction:column;flex-wrap:wrap;align-content:flex-end;max-height:100%;", "X .modebar.vertical svg": "top:-1px;", "X .modebar.vertical .modebar-group": "display:block;float:none;padding-left:0px;padding-bottom:8px;", "X .modebar.vertical .modebar-group .modebar-btn": "display:block;text-align:center;", "X [data-title]:before,X [data-title]:after": "position:absolute;-webkit-transform:translate3d(0, 0, 0);-moz-transform:translate3d(0, 0, 0);-ms-transform:translate3d(0, 0, 0);-o-transform:translate3d(0, 0, 0);transform:translate3d(0, 0, 0);display:none;opacity:0;z-index:1001;pointer-events:none;top:110%;right:50%;", "X [data-title]:hover:before,X [data-title]:hover:after": "display:block;opacity:1;", "X [data-title]:before": 'content:"";position:absolute;background:rgba(0,0,0,0);border:6px solid rgba(0,0,0,0);z-index:1002;margin-top:-12px;border-bottom-color:#69738a;margin-right:-6px;', "X [data-title]:after": "content:attr(data-title);background:#69738a;color:#fff;padding:8px 10px;font-size:12px;line-height:12px;white-space:nowrap;margin-right:-18px;border-radius:2px;", "X .vertical [data-title]:before,X .vertical [data-title]:after": "top:0%;right:200%;", "X .vertical [data-title]:before": "border:6px solid rgba(0,0,0,0);border-left-color:#69738a;margin-top:8px;margin-right:-30px;", Y: 'font-family:"Open Sans",verdana,arial,sans-serif;position:fixed;top:50px;right:20px;z-index:10000;font-size:10pt;max-width:180px;', "Y p": "margin:0;", "Y .notifier-note": "min-width:180px;max-width:250px;border:1px solid #fff;z-index:3000;margin:0;background-color:#8c97af;background-color:rgba(140,151,175,.9);color:#fff;padding:10px;overflow-wrap:break-word;word-wrap:break-word;-ms-hyphens:auto;-webkit-hyphens:auto;hyphens:auto;", "Y .notifier-close": "color:#fff;opacity:.8;float:right;padding:0 5px;background:none;border:none;font-size:20px;font-weight:bold;line-height:20px;", "Y .notifier-close:hover": "color:#444;text-decoration:none;cursor:pointer;" };
+        for (aq in sne) lne = aq.replace(/^,/, " ,").replace(/X/g, ".js-plotly-plot .plotly").replace(/Y/g, ".plotly-notifier"), Rnt.addStyleRule(lne, sne[aq]);
+        var lne, aq;
+      });
+      var oq = ye((anr, cne) => {
+        cne.exports = true;
+      });
+      var lq = ye((onr, fne) => {
+        var Dnt = oq(), sq;
+        typeof window.matchMedia == "function" ? sq = !window.matchMedia("(hover: none)").matches : sq = Dnt;
+        fne.exports = sq;
+      });
+      var Ab = ye((snr, uq) => {
+        var E3 = typeof Reflect == "object" ? Reflect : null, hne = E3 && typeof E3.apply == "function" ? E3.apply : function(t, r, n) {
+          return Function.prototype.apply.call(t, r, n);
+        }, Y6;
+        E3 && typeof E3.ownKeys == "function" ? Y6 = E3.ownKeys : Object.getOwnPropertySymbols ? Y6 = function(t) {
+          return Object.getOwnPropertyNames(t).concat(Object.getOwnPropertySymbols(t));
+        } : Y6 = function(t) {
+          return Object.getOwnPropertyNames(t);
+        };
+        function Fnt(e) {
+          console && console.warn && console.warn(e);
+        }
+        var vne = Number.isNaN || function(t) {
+          return t !== t;
+        };
+        function Jc() {
+          Jc.init.call(this);
+        }
+        uq.exports = Jc;
+        uq.exports.once = Bnt;
+        Jc.EventEmitter = Jc;
+        Jc.prototype._events = void 0;
+        Jc.prototype._eventsCount = 0;
+        Jc.prototype._maxListeners = void 0;
+        var dne = 10;
+        function K6(e) {
+          if (typeof e != "function") throw new TypeError('The "listener" argument must be of type Function. Received type ' + typeof e);
+        }
+        Object.defineProperty(Jc, "defaultMaxListeners", { enumerable: true, get: function() {
+          return dne;
+        }, set: function(e) {
+          if (typeof e != "number" || e < 0 || vne(e)) throw new RangeError('The value of "defaultMaxListeners" is out of range. It must be a non-negative number. Received ' + e + ".");
+          dne = e;
+        } });
+        Jc.init = function() {
+          (this._events === void 0 || this._events === Object.getPrototypeOf(this)._events) && (this._events = /* @__PURE__ */ Object.create(null), this._eventsCount = 0), this._maxListeners = this._maxListeners || void 0;
+        };
+        Jc.prototype.setMaxListeners = function(t) {
+          if (typeof t != "number" || t < 0 || vne(t)) throw new RangeError('The value of "n" is out of range. It must be a non-negative number. Received ' + t + ".");
+          return this._maxListeners = t, this;
+        };
+        function pne(e) {
+          return e._maxListeners === void 0 ? Jc.defaultMaxListeners : e._maxListeners;
+        }
+        Jc.prototype.getMaxListeners = function() {
+          return pne(this);
+        };
+        Jc.prototype.emit = function(t) {
+          for (var r = [], n = 1; n < arguments.length; n++) r.push(arguments[n]);
+          var i = t === "error", a = this._events;
+          if (a !== void 0) i = i && a.error === void 0;
+          else if (!i) return false;
+          if (i) {
+            var o;
+            if (r.length > 0 && (o = r[0]), o instanceof Error) throw o;
+            var s = new Error("Unhandled error." + (o ? " (" + o.message + ")" : ""));
+            throw s.context = o, s;
+          }
+          var l = a[t];
+          if (l === void 0) return false;
+          if (typeof l == "function") hne(l, this, r);
+          else for (var u = l.length, c = xne(l, u), n = 0; n < u; ++n) hne(c[n], this, r);
+          return true;
+        };
+        function gne(e, t, r, n) {
+          var i, a, o;
+          if (K6(r), a = e._events, a === void 0 ? (a = e._events = /* @__PURE__ */ Object.create(null), e._eventsCount = 0) : (a.newListener !== void 0 && (e.emit("newListener", t, r.listener ? r.listener : r), a = e._events), o = a[t]), o === void 0) o = a[t] = r, ++e._eventsCount;
+          else if (typeof o == "function" ? o = a[t] = n ? [r, o] : [o, r] : n ? o.unshift(r) : o.push(r), i = pne(e), i > 0 && o.length > i && !o.warned) {
+            o.warned = true;
+            var s = new Error("Possible EventEmitter memory leak detected. " + o.length + " " + String(t) + " listeners added. Use emitter.setMaxListeners() to increase limit");
+            s.name = "MaxListenersExceededWarning", s.emitter = e, s.type = t, s.count = o.length, Fnt(s);
+          }
+          return e;
+        }
+        Jc.prototype.addListener = function(t, r) {
+          return gne(this, t, r, false);
+        };
+        Jc.prototype.on = Jc.prototype.addListener;
+        Jc.prototype.prependListener = function(t, r) {
+          return gne(this, t, r, true);
+        };
+        function znt() {
+          if (!this.fired) return this.target.removeListener(this.type, this.wrapFn), this.fired = true, arguments.length === 0 ? this.listener.call(this.target) : this.listener.apply(this.target, arguments);
+        }
+        function mne(e, t, r) {
+          var n = { fired: false, wrapFn: void 0, target: e, type: t, listener: r }, i = znt.bind(n);
+          return i.listener = r, n.wrapFn = i, i;
+        }
+        Jc.prototype.once = function(t, r) {
+          return K6(r), this.on(t, mne(this, t, r)), this;
+        };
+        Jc.prototype.prependOnceListener = function(t, r) {
+          return K6(r), this.prependListener(t, mne(this, t, r)), this;
+        };
+        Jc.prototype.removeListener = function(t, r) {
+          var n, i, a, o, s;
+          if (K6(r), i = this._events, i === void 0) return this;
+          if (n = i[t], n === void 0) return this;
+          if (n === r || n.listener === r) --this._eventsCount === 0 ? this._events = /* @__PURE__ */ Object.create(null) : (delete i[t], i.removeListener && this.emit("removeListener", t, n.listener || r));
+          else if (typeof n != "function") {
+            for (a = -1, o = n.length - 1; o >= 0; o--) if (n[o] === r || n[o].listener === r) {
+              s = n[o].listener, a = o;
+              break;
+            }
+            if (a < 0) return this;
+            a === 0 ? n.shift() : Ont(n, a), n.length === 1 && (i[t] = n[0]), i.removeListener !== void 0 && this.emit("removeListener", t, s || r);
+          }
+          return this;
+        };
+        Jc.prototype.off = Jc.prototype.removeListener;
+        Jc.prototype.removeAllListeners = function(t) {
+          var r, n, i;
+          if (n = this._events, n === void 0) return this;
+          if (n.removeListener === void 0) return arguments.length === 0 ? (this._events = /* @__PURE__ */ Object.create(null), this._eventsCount = 0) : n[t] !== void 0 && (--this._eventsCount === 0 ? this._events = /* @__PURE__ */ Object.create(null) : delete n[t]), this;
+          if (arguments.length === 0) {
+            var a = Object.keys(n), o;
+            for (i = 0; i < a.length; ++i) o = a[i], o !== "removeListener" && this.removeAllListeners(o);
+            return this.removeAllListeners("removeListener"), this._events = /* @__PURE__ */ Object.create(null), this._eventsCount = 0, this;
+          }
+          if (r = n[t], typeof r == "function") this.removeListener(t, r);
+          else if (r !== void 0) for (i = r.length - 1; i >= 0; i--) this.removeListener(t, r[i]);
+          return this;
+        };
+        function yne(e, t, r) {
+          var n = e._events;
+          if (n === void 0) return [];
+          var i = n[t];
+          return i === void 0 ? [] : typeof i == "function" ? r ? [i.listener || i] : [i] : r ? qnt(i) : xne(i, i.length);
+        }
+        Jc.prototype.listeners = function(t) {
+          return yne(this, t, true);
+        };
+        Jc.prototype.rawListeners = function(t) {
+          return yne(this, t, false);
+        };
+        Jc.listenerCount = function(e, t) {
+          return typeof e.listenerCount == "function" ? e.listenerCount(t) : _ne.call(e, t);
+        };
+        Jc.prototype.listenerCount = _ne;
+        function _ne(e) {
+          var t = this._events;
+          if (t !== void 0) {
+            var r = t[e];
+            if (typeof r == "function") return 1;
+            if (r !== void 0) return r.length;
+          }
+          return 0;
+        }
+        Jc.prototype.eventNames = function() {
+          return this._eventsCount > 0 ? Y6(this._events) : [];
+        };
+        function xne(e, t) {
+          for (var r = new Array(t), n = 0; n < t; ++n) r[n] = e[n];
+          return r;
+        }
+        function Ont(e, t) {
+          for (; t + 1 < e.length; t++) e[t] = e[t + 1];
+          e.pop();
+        }
+        function qnt(e) {
+          for (var t = new Array(e.length), r = 0; r < t.length; ++r) t[r] = e[r].listener || e[r];
+          return t;
+        }
+        function Bnt(e, t) {
+          return new Promise(function(r, n) {
+            function i(o) {
+              e.removeListener(t, a), n(o);
+            }
+            function a() {
+              typeof e.removeListener == "function" && e.removeListener("error", i), r([].slice.call(arguments));
+            }
+            bne(e, t, a, { once: true }), t !== "error" && Nnt(e, i, { once: true });
+          });
+        }
+        function Nnt(e, t, r) {
+          typeof e.on == "function" && bne(e, "error", t, r);
+        }
+        function bne(e, t, r, n) {
+          if (typeof e.on == "function") n.once ? e.once(t, r) : e.on(t, r);
+          else if (typeof e.addEventListener == "function") e.addEventListener(t, function i(a) {
+            n.once && e.removeEventListener(t, i), r(a);
+          });
+          else throw new TypeError('The "emitter" argument must be of type EventEmitter. Received type ' + typeof e);
+        }
+      });
+      var k3 = ye((lnr, wne) => {
+        var cq = Ab().EventEmitter, Unt = { init: function(e) {
+          if (e._ev instanceof cq) return e;
+          var t = new cq(), r = new cq();
+          return e._ev = t, e._internalEv = r, e.on = t.on.bind(t), e.once = t.once.bind(t), e.removeListener = t.removeListener.bind(t), e.removeAllListeners = t.removeAllListeners.bind(t), e._internalOn = r.on.bind(r), e._internalOnce = r.once.bind(r), e._removeInternalListener = r.removeListener.bind(r), e._removeAllInternalListeners = r.removeAllListeners.bind(r), e.emit = function(n, i) {
+            t.emit(n, i), r.emit(n, i);
+          }, typeof e.addEventListener == "function" && e.addEventListener("wheel", () => {
+          }, { passive: true }), e;
+        }, triggerHandler: function(e, t, r) {
+          var n, i = e._ev;
+          if (!i) return;
+          var a = i._events[t];
+          if (!a) return;
+          function o(l) {
+            if (l.listener) {
+              if (i.removeListener(t, l.listener), !l.fired) return l.fired = true, l.listener.apply(i, [r]);
+            } else return l.apply(i, [r]);
+          }
+          a = Array.isArray(a) ? a : [a];
+          var s;
+          for (s = 0; s < a.length - 1; s++) o(a[s]);
+          return n = o(a[s]), n;
+        }, purge: function(e) {
+          return delete e._ev, delete e.on, delete e.once, delete e.removeListener, delete e.removeAllListeners, delete e.emit, delete e._ev, delete e._internalEv, delete e._internalOn, delete e._internalOnce, delete e._removeInternalListener, delete e._removeAllInternalListeners, e;
+        } };
+        wne.exports = Unt;
+      });
+      var Sne = ye((unr, Ane) => {
+        var Tne = Dr(), Vnt = _b().dfltConfig;
+        function Gnt(e, t) {
+          for (var r = [], n, i = 0; i < t.length; i++) n = t[i], n === e ? r[i] = n : typeof n == "object" ? r[i] = Array.isArray(n) ? Tne.extendDeep([], n) : Tne.extendDeepAll({}, n) : r[i] = n;
+          return r;
+        }
+        var Cy = {};
+        Cy.add = function(e, t, r, n, i) {
+          var a, o;
+          if (e.undoQueue = e.undoQueue || { index: 0, queue: [], sequence: false }, o = e.undoQueue.index, e.autoplay) {
+            e.undoQueue.inSequence || (e.autoplay = false);
+            return;
+          }
+          !e.undoQueue.sequence || e.undoQueue.beginSequence ? (a = { undo: { calls: [], args: [] }, redo: { calls: [], args: [] } }, e.undoQueue.queue.splice(o, e.undoQueue.queue.length - o, a), e.undoQueue.index += 1) : a = e.undoQueue.queue[o - 1], e.undoQueue.beginSequence = false, a && (a.undo.calls.unshift(t), a.undo.args.unshift(r), a.redo.calls.push(n), a.redo.args.push(i)), e.undoQueue.queue.length > Vnt.queueLength && (e.undoQueue.queue.shift(), e.undoQueue.index--);
+        };
+        Cy.startSequence = function(e) {
+          e.undoQueue = e.undoQueue || { index: 0, queue: [], sequence: false }, e.undoQueue.sequence = true, e.undoQueue.beginSequence = true;
+        };
+        Cy.stopSequence = function(e) {
+          e.undoQueue = e.undoQueue || { index: 0, queue: [], sequence: false }, e.undoQueue.sequence = false, e.undoQueue.beginSequence = false;
+        };
+        Cy.undo = function(t) {
+          var r, n;
+          if (!(t.undoQueue === void 0 || isNaN(t.undoQueue.index) || t.undoQueue.index <= 0)) {
+            for (t.undoQueue.index--, r = t.undoQueue.queue[t.undoQueue.index], t.undoQueue.inSequence = true, n = 0; n < r.undo.calls.length; n++) Cy.plotDo(t, r.undo.calls[n], r.undo.args[n]);
+            t.undoQueue.inSequence = false, t.autoplay = false;
+          }
+        };
+        Cy.redo = function(t) {
+          var r, n;
+          if (!(t.undoQueue === void 0 || isNaN(t.undoQueue.index) || t.undoQueue.index >= t.undoQueue.queue.length)) {
+            for (r = t.undoQueue.queue[t.undoQueue.index], t.undoQueue.inSequence = true, n = 0; n < r.redo.calls.length; n++) Cy.plotDo(t, r.redo.calls[n], r.redo.args[n]);
+            t.undoQueue.inSequence = false, t.autoplay = false, t.undoQueue.index++;
+          }
+        };
+        Cy.plotDo = function(e, t, r) {
+          e.autoplay = true, r = Gnt(e, r), t.apply(null, r);
+        };
+        Ane.exports = Cy;
+      });
+      var fq = ye((cnr, Mne) => {
+        Mne.exports = { _isLinkedToArray: "frames_entry", group: { valType: "string" }, name: { valType: "string" }, traces: { valType: "any" }, baseframe: { valType: "string" }, data: { valType: "any" }, layout: { valType: "any" } };
+      });
+      var P3 = ye((ed) => {
+        var x0 = qa(), QS = Dr(), $6 = Gl(), hq = _3(), Hnt = fq(), jnt = jS(), Wnt = _b().configAttributes, Ene = mc(), Ag = QS.extendDeepAll, C3 = QS.isPlainObject, Xnt = QS.isArrayOrTypedArray, Q6 = QS.nestedProperty, Znt = QS.valObjectMeta, dq = "_isSubplotObj", eL = "_isLinkedToArray", Ynt = "_arrayAttrRegexps", Cne = "_deprecated", vq = [dq, eL, Ynt, Cne];
+        ed.IS_SUBPLOT_OBJ = dq;
+        ed.IS_LINKED_TO_ARRAY = eL;
+        ed.DEPRECATED = Cne;
+        ed.UNDERSCORE_ATTRS = vq;
+        ed.get = function() {
+          var e = {};
+          return x0.allTypes.forEach(function(t) {
+            e[t] = Jnt(t);
+          }), { defs: { valObjects: Znt, metaKeys: vq.concat(["description", "role", "editType", "impliedEdits"]), editType: { traces: Ene.traces, layout: Ene.layout }, impliedEdits: {} }, traces: e, layout: $nt(), frames: Qnt(), animation: L3(jnt), config: L3(Wnt) };
+        };
+        ed.crawl = function(e, t, r, n) {
+          var i = r || 0;
+          n = n || "", Object.keys(e).forEach(function(a) {
+            var o = e[a];
+            if (vq.indexOf(a) === -1) {
+              var s = (n ? n + "." : "") + a;
+              t(o, a, e, i, s), !ed.isValObject(o) && C3(o) && a !== "impliedEdits" && ed.crawl(o, t, i + 1, s);
+            }
+          });
+        };
+        ed.isValObject = function(e) {
+          return e && e.valType !== void 0;
+        };
+        ed.findArrayAttributes = function(e) {
+          var t = [], r = [], n = [], i, a;
+          function o(l, u, c, f) {
+            r = r.slice(0, f).concat([u]), n = n.slice(0, f).concat([l && l._isLinkedToArray]);
+            var h = l && (l.valType === "data_array" || l.arrayOk === true) && !(r[f - 1] === "colorbar" && (u === "ticktext" || u === "tickvals"));
+            h && s(i, 0, "");
+          }
+          function s(l, u, c) {
+            var f = l[r[u]], h = c + r[u];
+            if (u === r.length - 1) Xnt(f) && t.push(a + h);
+            else if (n[u]) {
+              if (Array.isArray(f)) for (var d = 0; d < f.length; d++) C3(f[d]) && s(f[d], u + 1, h + "[" + d + "].");
+            } else C3(f) && s(f, u + 1, h + ".");
+          }
+          return i = e, a = "", ed.crawl($6, o), e._module && e._module.attributes && ed.crawl(e._module.attributes, o), t;
+        };
+        ed.getTraceValObject = function(e, t) {
+          var r = t[0], n = 1, i, a, o = e._module;
+          if (o || (o = (x0.modules[e.type || $6.type.dflt] || {})._module), !o) return false;
+          if (i = o.attributes, a = i && i[r], !a) {
+            var s = o.basePlotModule;
+            s && s.attributes && (a = s.attributes[r]);
+          }
+          return a || (a = $6[r]), Lne(a, t, n);
+        };
+        ed.getLayoutValObject = function(e, t) {
+          var r = Knt(e, t[0]);
+          return Lne(r, t, 1);
+        };
+        function Knt(e, t) {
+          var r, n, i, a, o = e._basePlotModules;
+          if (o) {
+            var s;
+            for (r = 0; r < o.length; r++) {
+              if (i = o[r], i.attrRegex && i.attrRegex.test(t)) {
+                if (i.layoutAttrOverrides) return i.layoutAttrOverrides;
+                !s && i.layoutAttributes && (s = i.layoutAttributes);
+              }
+              var l = i.baseLayoutAttrOverrides;
+              if (l && t in l) return l[t];
+            }
+            if (s) return s;
+          }
+          var u = e._modules;
+          if (u) {
+            for (r = 0; r < u.length; r++) if (a = u[r].layoutAttributes, a && t in a) return a[t];
+          }
+          for (n in x0.componentsRegistry) {
+            if (i = x0.componentsRegistry[n], i.name === "colorscale" && t.indexOf("coloraxis") === 0) return i.layoutAttributes[t];
+            if (!i.schema && t === i.name) return i.layoutAttributes;
+          }
+          return t in hq ? hq[t] : false;
+        }
+        function Lne(e, t, r) {
+          if (!e) return false;
+          if (e._isLinkedToArray) {
+            if (J6(t[r])) r++;
+            else if (r < t.length) return false;
+          }
+          for (; r < t.length; r++) {
+            var n = e[t[r]];
+            if (C3(n)) e = n;
+            else break;
+            if (r === t.length - 1) break;
+            if (e._isLinkedToArray) {
+              if (r++, !J6(t[r])) return false;
+            } else if (e.valType === "info_array") {
+              r++;
+              var i = t[r];
+              if (!J6(i)) return false;
+              var a = e.items;
+              if (Array.isArray(a)) {
+                if (i >= a.length) return false;
+                if (e.dimensions === 2) {
+                  if (r++, t.length === r) return e;
+                  var o = t[r];
+                  if (!J6(o)) return false;
+                  e = a[i][o];
+                } else e = a[i];
+              } else e = a;
+            }
+          }
+          return e;
+        }
+        function J6(e) {
+          return e === Math.round(e) && e >= 0;
+        }
+        function Jnt(e) {
+          var t, r;
+          t = x0.modules[e]._module, r = t.basePlotModule;
+          var n = {};
+          n.type = null;
+          var i = Ag({}, $6), a = Ag({}, t.attributes);
+          ed.crawl(a, function(l, u, c, f, h) {
+            Q6(i, h).set(void 0), l === void 0 && Q6(a, h).set(void 0);
+          }), Ag(n, i), x0.traceIs(e, "noOpacity") && delete n.opacity, x0.traceIs(e, "showLegend") || (delete n.showlegend, delete n.legendgroup), x0.traceIs(e, "noHover") && (delete n.hoverinfo, delete n.hoverlabel), t.selectPoints || delete n.selectedpoints, Ag(n, a), r.attributes && Ag(n, r.attributes), n.type = e;
+          var o = { meta: t.meta || {}, categories: t.categories || {}, animatable: !!t.animatable, type: e, attributes: L3(n) };
+          if (t.layoutAttributes) {
+            var s = {};
+            Ag(s, t.layoutAttributes), o.layoutAttributes = L3(s);
+          }
+          return t.animatable || ed.crawl(o, function(l) {
+            ed.isValObject(l) && "anim" in l && delete l.anim;
+          }), o;
+        }
+        function $nt() {
+          var e = {}, t, r;
+          Ag(e, hq);
+          for (t in x0.subplotsRegistry) if (r = x0.subplotsRegistry[t], !!r.layoutAttributes) if (Array.isArray(r.attr)) for (var n = 0; n < r.attr.length; n++) kne(e, r, r.attr[n]);
+          else {
+            var i = r.attr === "subplot" ? r.name : r.attr;
+            kne(e, r, i);
+          }
+          for (t in x0.componentsRegistry) {
+            r = x0.componentsRegistry[t];
+            var a = r.schema;
+            if (a && (a.subplots || a.layout)) {
+              var o = a.subplots;
+              if (o && o.xaxis && !o.yaxis) for (var s in o.xaxis) delete e.yaxis[s];
+              delete e.xaxis.shift, delete e.xaxis.autoshift;
+            } else r.name === "colorscale" ? Ag(e, r.layoutAttributes) : r.layoutAttributes && iat(e, r.layoutAttributes, r.name);
+          }
+          return { layoutAttributes: L3(e) };
+        }
+        function Qnt() {
+          var e = { frames: Ag({}, Hnt) };
+          return L3(e), e.frames;
+        }
+        function L3(e) {
+          return eat(e), tat(e), rat(e), e;
+        }
+        function eat(e) {
+          function t(n) {
+            return { valType: "string", editType: "none" };
+          }
+          function r(n, i, a) {
+            ed.isValObject(n) ? (n.arrayOk === true || n.valType === "data_array") && (a[i + "src"] = t()) : C3(n) && (n.role = "object");
+          }
+          ed.crawl(e, r);
+        }
+        function tat(e) {
+          function t(r, n, i) {
+            if (r) {
+              var a = r[eL];
+              a && (delete r[eL], i[n] = { items: {} }, i[n].items[a] = r, i[n].role = "object");
+            }
+          }
+          ed.crawl(e, t);
+        }
+        function rat(e) {
+          function t(r) {
+            for (var n in r) if (C3(r[n])) t(r[n]);
+            else if (Array.isArray(r[n])) for (var i = 0; i < r[n].length; i++) t(r[n][i]);
+            else r[n] instanceof RegExp && (r[n] = r[n].toString());
+          }
+          t(e);
+        }
+        function kne(e, t, r) {
+          var n = Q6(e, r), i = Ag({}, t.layoutAttributes);
+          i[dq] = true, n.set(i);
+        }
+        function iat(e, t, r) {
+          var n = Q6(e, r);
+          n.set(Ag(n.get() || {}, t));
+        }
+      });
+      var vl = ye((Sb) => {
+        var I3 = Dr(), nat = Gl(), a_ = "templateitemname", pq = { name: { valType: "string", editType: "none" } };
+        pq[a_] = { valType: "string", editType: "calc" };
+        Sb.templatedArray = function(e, t) {
+          return t._isLinkedToArray = e, t.name = pq.name, t[a_] = pq[a_], t;
+        };
+        Sb.traceTemplater = function(e) {
+          var t = {}, r, n;
+          for (r in e) n = e[r], Array.isArray(n) && n.length && (t[r] = 0);
+          function i(a) {
+            r = I3.coerce(a, {}, nat, "type");
+            var o = { type: r, _template: null };
+            if (r in t) {
+              n = e[r];
+              var s = t[r] % n.length;
+              t[r]++, o._template = n[s];
+            }
+            return o;
+          }
+          return { newTrace: i };
+        };
+        Sb.newContainer = function(e, t, r) {
+          var n = e._template, i = n && (n[t] || r && n[r]);
+          I3.isPlainObject(i) || (i = null);
+          var a = e[t] = { _template: i };
+          return a;
+        };
+        Sb.arrayTemplater = function(e, t, r) {
+          var n = e._template, i = n && n[Ine(t)], a = n && n[t];
+          (!Array.isArray(a) || !a.length) && (a = []);
+          var o = {};
+          function s(u) {
+            var c = { name: u.name, _input: u }, f = c[a_] = u[a_];
+            if (!Pne(f)) return c._template = i, c;
+            for (var h = 0; h < a.length; h++) {
+              var d = a[h];
+              if (d.name === f) return o[f] = 1, c._template = d, c;
+            }
+            return c[r] = u[r] || false, c._template = false, c;
+          }
+          function l() {
+            for (var u = [], c = 0; c < a.length; c++) {
+              var f = a[c], h = f.name;
+              if (Pne(h) && !o[h]) {
+                var d = { _template: f, name: h, _input: { _templateitemname: h } };
+                d[a_] = f[a_], u.push(d), o[h] = 1;
+              }
+            }
+            return u;
+          }
+          return { newItem: s, defaultItems: l };
+        };
+        function Pne(e) {
+          return e && typeof e == "string";
+        }
+        function Ine(e) {
+          var t = e.length - 1;
+          return e.charAt(t) !== "s" && I3.warn("bad argument to arrayDefaultKey: " + e), e.slice(0, -1) + "defaults";
+        }
+        Sb.arrayDefaultKey = Ine;
+        Sb.arrayEditor = function(e, t, r) {
+          var n = (I3.nestedProperty(e, t).get() || []).length, i = r._index, a = i >= n && (r._input || {})._templateitemname;
+          a && (i = n);
+          var o = t + "[" + i + "]", s;
+          function l() {
+            s = {}, a && (s[o] = {}, s[o][a_] = a);
+          }
+          l();
+          function u(d, v) {
+            s[d] = v;
+          }
+          function c(d, v) {
+            a ? I3.nestedProperty(s[o], d).set(v) : s[o + "." + d] = v;
+          }
+          function f() {
+            var d = s;
+            return l(), d;
+          }
+          function h(d, v) {
+            d && c(d, v);
+            var _ = f();
+            for (var b in _) I3.nestedProperty(e, b).set(_[b]);
+          }
+          return { modifyBase: u, modifyItem: c, getUpdateObj: f, applyUpdate: h };
+        };
+      });
+      var Rh = ye((dnr, Rne) => {
+        var eM = p3().counter;
+        Rne.exports = { idRegex: { x: eM("x", "( domain)?"), y: eM("y", "( domain)?") }, attrRegex: eM("[xy]axis"), xAxisMatch: eM("xaxis"), yAxisMatch: eM("yaxis"), AX_ID_PATTERN: /^[xyz][0-9]*( domain)?$/, AX_NAME_PATTERN: /^[xyz]axis[0-9]*$/, SUBPLOT_PATTERN: /^x([0-9]*)y([0-9]*)$/, HOUR_PATTERN: "hour", WEEKDAY_PATTERN: "day of week", MINDRAG: 8, MINZOOM: 20, DRAGGERSIZE: 20, REDRAWDELAY: 50, DFLTRANGEX: [-1, 6], DFLTRANGEY: [-1, 4], traceLayerClasses: ["imagelayer", "heatmaplayer", "contourcarpetlayer", "contourlayer", "funnellayer", "waterfalllayer", "barlayer", "carpetlayer", "violinlayer", "boxlayer", "ohlclayer", "scattercarpetlayer", "scatterlayer"], clipOnAxisFalseQuery: [".scatterlayer", ".barlayer", ".funnellayer", ".waterfalllayer"], layerValue2layerClass: { "above traces": "above", "below traces": "below" }, zindexSeparator: "z" };
+      });
+      var hf = ye((Sp) => {
+        var aat = qa(), gq = Rh();
+        Sp.id2name = function(t) {
+          if (!(typeof t != "string" || !t.match(gq.AX_ID_PATTERN))) {
+            var r = t.split(" ")[0].slice(1);
+            return r === "1" && (r = ""), t.charAt(0) + "axis" + r;
+          }
+        };
+        Sp.name2id = function(t) {
+          if (t.match(gq.AX_NAME_PATTERN)) {
+            var r = t.slice(5);
+            return r === "1" && (r = ""), t.charAt(0) + r;
+          }
+        };
+        Sp.cleanId = function(t, r, n) {
+          var i = /( domain)$/.test(t);
+          if (!(typeof t != "string" || !t.match(gq.AX_ID_PATTERN)) && !(r && t.charAt(0) !== r) && !(i && !n)) {
+            var a = t.split(" ")[0].slice(1).replace(/^0+/, "");
+            return a === "1" && (a = ""), t.charAt(0) + a + (i && n ? " domain" : "");
+          }
+        };
+        Sp.list = function(e, t, r) {
+          var n = e._fullLayout;
+          if (!n) return [];
+          var i = Sp.listIds(e, t), a = new Array(i.length), o;
+          for (o = 0; o < i.length; o++) {
+            var s = i[o];
+            a[o] = n[s.charAt(0) + "axis" + s.slice(1)];
+          }
+          if (!r) {
+            var l = n._subplots.gl3d || [];
+            for (o = 0; o < l.length; o++) {
+              var u = n[l[o]];
+              t ? a.push(u[t + "axis"]) : a.push(u.xaxis, u.yaxis, u.zaxis);
+            }
+          }
+          return a;
+        };
+        Sp.listIds = function(e, t) {
+          var r = e._fullLayout;
+          if (!r) return [];
+          var n = r._subplots;
+          return t ? n[t + "axis"] : n.xaxis.concat(n.yaxis);
+        };
+        Sp.getFromId = function(e, t, r) {
+          var n = e._fullLayout;
+          return t = t === void 0 || typeof t != "string" ? t : t.replace(" domain", ""), r === "x" ? t = t.replace(/y[0-9]*/, "") : r === "y" && (t = t.replace(/x[0-9]*/, "")), n[Sp.id2name(t)];
+        };
+        Sp.getFromTrace = function(e, t, r) {
+          var n = e._fullLayout, i = null;
+          if (aat.traceIs(t, "gl3d")) {
+            var a = t.scene;
+            a.slice(0, 5) === "scene" && (i = n[a][r + "axis"]);
+          } else i = Sp.getFromId(e, t[r + "axis"] || r);
+          return i;
+        };
+        Sp.idSort = function(e, t) {
+          var r = e.charAt(0), n = t.charAt(0);
+          return r !== n ? r > n ? 1 : -1 : +(e.slice(1) || 1) - +(t.slice(1) || 1);
+        };
+        Sp.ref2id = function(e) {
+          return /^[xyz]/.test(e) ? e.split(" ")[0] : false;
+        };
+        function Dne(e, t) {
+          if (t && t.length) {
+            for (var r = 0; r < t.length; r++) if (t[r][e]) return true;
+          }
+          return false;
+        }
+        Sp.isLinked = function(e, t) {
+          return Dne(t, e._axisMatchGroups) || Dne(t, e._axisConstraintGroups);
+        };
+      });
+      var o_ = ye((pnr, Fne) => {
+        function oat(e) {
+          var t = e._fullLayout._zoomlayer;
+          t && t.selectAll(".outline-controllers").remove();
+        }
+        function sat(e) {
+          var t = e._fullLayout._zoomlayer;
+          t && t.selectAll(".select-outline").remove(), e._fullLayout._outlining = false;
+        }
+        Fne.exports = { clearOutlineControllers: oat, clearOutline: sat };
+      });
+      var tL = ye((gnr, zne) => {
+        zne.exports = { scattermode: { valType: "enumerated", values: ["group", "overlay"], dflt: "overlay", editType: "calc" }, scattergap: { valType: "number", min: 0, max: 1, editType: "calc" } };
+      });
+      var Id = ye((iL) => {
+        var rL = qa();
+        Rh().SUBPLOT_PATTERN;
+        iL.getSubplotCalcData = function(e, t, r) {
+          var n = rL.subplotsRegistry[t];
+          if (!n) return [];
+          for (var i = n.attr, a = [], o = 0; o < e.length; o++) {
+            var s = e[o], l = s[0].trace;
+            l[i] === r && a.push(s);
+          }
+          return a;
+        };
+        iL.getModuleCalcData = function(e, t, r) {
+          var n = [], i = [], a;
+          if (typeof t == "string" ? a = rL.getModule(t).plot : typeof t == "function" ? a = t : a = t.plot, !a) return [n, e];
+          for (var o = r, s = 0; s < e.length; s++) {
+            var l = e[s], u = l[0].trace, c = u.zorder !== void 0;
+            u.visible !== true || u._length === 0 || (u._module && u._module.plot === a && (!c || u.zorder === o) ? n.push(l) : i.push(l));
+          }
+          return [n, i];
+        };
+        iL.getSubplotData = function(t, r, n) {
+          if (!rL.subplotsRegistry[r]) return [];
+          for (var i = rL.subplotsRegistry[r].attr, a = [], o, s, l, u = 0; u < t.length; u++) o = t[u], o[i] === n && a.push(o);
+          return a;
+        };
+      });
+      var Nne = ye((Mb) => {
+        var lat = qa(), R3 = Dr();
+        Mb.manageCommandObserver = function(e, t, r, n) {
+          var i = {}, a = true;
+          t && t._commandObserver && (i = t._commandObserver), i.cache || (i.cache = {}), i.lookupTable = {};
+          var o = Mb.hasSimpleAPICommandBindings(e, r, i.lookupTable);
+          if (t && t._commandObserver) {
+            if (o) return i;
+            if (t._commandObserver.remove) return t._commandObserver.remove(), t._commandObserver = null, i;
+          }
+          if (o) {
+            One(e, o, i.cache), i.check = function() {
+              if (a) {
+                var c = One(e, o, i.cache);
+                return c.changed && n && i.lookupTable[c.value] !== void 0 && (i.disable(), Promise.resolve(n({ value: c.value, type: o.type, prop: o.prop, traces: o.traces, index: i.lookupTable[c.value] })).then(i.enable, i.enable)), c.changed;
+              }
+            };
+            for (var s = ["plotly_relayout", "plotly_redraw", "plotly_restyle", "plotly_update", "plotly_animatingframe", "plotly_afterplot"], l = 0; l < s.length; l++) e._internalOn(s[l], i.check);
+            i.remove = function() {
+              for (var u = 0; u < s.length; u++) e._removeInternalListener(s[u], i.check);
+            };
+          } else R3.log("Unable to automatically bind plot updates to API command"), i.lookupTable = {}, i.remove = function() {
+          };
+          return i.disable = function() {
+            a = false;
+          }, i.enable = function() {
+            a = true;
+          }, t && (t._commandObserver = i), i;
+        };
+        Mb.hasSimpleAPICommandBindings = function(e, t, r) {
+          var n, i = t.length, a;
+          for (n = 0; n < i; n++) {
+            var o, s = t[n], l = s.method, u = s.args;
+            if (Array.isArray(u) || (u = []), !l) return false;
+            var c = Mb.computeAPICommandBindings(e, l, u);
+            if (c.length !== 1) return false;
+            if (!a) a = c[0], Array.isArray(a.traces) && a.traces.sort();
+            else {
+              if (o = c[0], o.type !== a.type || o.prop !== a.prop) return false;
+              if (Array.isArray(a.traces)) if (Array.isArray(o.traces)) {
+                o.traces.sort();
+                for (var f = 0; f < a.traces.length; f++) if (a.traces[f] !== o.traces[f]) return false;
+              } else return false;
+              else if (o.prop !== a.prop) return false;
+            }
+            o = c[0];
+            var h = o.value;
+            if (Array.isArray(h)) if (h.length === 1) h = h[0];
+            else return false;
+            r && (r[h] = n);
+          }
+          return a;
+        };
+        function One(e, t, r) {
+          var n, i, a, o = false;
+          if (t.type === "data") n = e._fullData[t.traces !== null ? t.traces[0] : 0];
+          else if (t.type === "layout") n = e._fullLayout;
+          else return false;
+          return i = R3.nestedProperty(n, t.prop).get(), a = r[t.type] = r[t.type] || {}, a.hasOwnProperty(t.prop) && a[t.prop] !== i && (o = true), a[t.prop] = i, { changed: o, value: i };
+        }
+        Mb.executeAPICommand = function(e, t, r) {
+          if (t === "skip") return Promise.resolve();
+          var n = lat.apiMethodRegistry[t], i = [e];
+          Array.isArray(r) || (r = []);
+          for (var a = 0; a < r.length; a++) i.push(r[a]);
+          return n.apply(null, i).catch(function(o) {
+            return R3.warn("API call to Plotly." + t + " rejected.", o), Promise.reject(o);
+          });
+        };
+        Mb.computeAPICommandBindings = function(e, t, r) {
+          var n;
+          switch (Array.isArray(r) || (r = []), t) {
+            case "restyle":
+              n = Bne(e, r);
+              break;
+            case "relayout":
+              n = qne(e, r);
+              break;
+            case "update":
+              n = Bne(e, [r[0], r[2]]).concat(qne(e, [r[1]]));
+              break;
+            case "animate":
+              n = uat(e, r);
+              break;
+            default:
+              n = [];
+          }
+          return n;
+        };
+        function uat(e, t) {
+          return Array.isArray(t[0]) && t[0].length === 1 && ["string", "number"].indexOf(typeof t[0][0]) !== -1 ? [{ type: "layout", prop: "_currentFrame", value: t[0][0].toString() }] : [];
+        }
+        function qne(e, t) {
+          var r = [], n = t[0], i = {};
+          if (typeof n == "string") i[n] = t[1];
+          else if (R3.isPlainObject(n)) i = n;
+          else return r;
+          return mq(i, function(a, o, s) {
+            r.push({ type: "layout", prop: a, value: s });
+          }, "", 0), r;
+        }
+        function Bne(e, t) {
+          var r, n, i, a, o = [];
+          if (n = t[0], i = t[1], r = t[2], a = {}, typeof n == "string") a[n] = i;
+          else if (R3.isPlainObject(n)) a = n, r === void 0 && (r = i);
+          else return o;
+          return r === void 0 && (r = null), mq(a, function(s, l, u) {
+            var c, f;
+            if (Array.isArray(u)) {
+              f = u.slice();
+              var h = Math.min(f.length, e.data.length);
+              r && (h = Math.min(h, r.length)), c = [];
+              for (var d = 0; d < h; d++) c[d] = r ? r[d] : d;
+            } else f = u, c = r ? r.slice() : null;
+            if (c === null) Array.isArray(f) && (f = f[0]);
+            else if (Array.isArray(c)) {
+              if (!Array.isArray(f)) {
+                var v = f;
+                f = [];
+                for (var _ = 0; _ < c.length; _++) f[_] = v;
+              }
+              f.length = Math.min(c.length, f.length);
+            }
+            o.push({ type: "data", prop: s, traces: c, value: f });
+          }, "", 0), o;
+        }
+        function mq(e, t, r, n) {
+          Object.keys(e).forEach(function(i) {
+            var a = e[i];
+            if (i[0] !== "_") {
+              var o = r + (n > 0 ? "." : "") + i;
+              R3.isPlainObject(a) ? mq(a, t, o, n + 1) : t(o, i, a);
+            }
+          });
+        }
+      });
+      var Mc = ye((xnr, eae) => {
+        var Xne = Oa(), cat = f3().timeFormatLocale, fat = MO().formatLocale, tM = Eo(), hat = EO(), Xl = qa(), Zne = P3(), dat = vl(), Ga = Dr(), Yne = ka(), Une = fs().BADNUM, Mp = hf(), vat = o_().clearOutline, pat = tL(), yq = jS(), gat = fq(), mat = Id().getModuleCalcData, Vne = Ga.relinkPrivateKeys, Eb = Ga._, xa = eae.exports = {};
+        Ga.extendFlat(xa, Xl);
+        xa.attributes = Gl();
+        xa.attributes.type.values = xa.allTypes;
+        xa.fontAttrs = ec();
+        xa.layoutAttributes = _3();
+        var aL = Nne();
+        xa.executeAPICommand = aL.executeAPICommand;
+        xa.computeAPICommandBindings = aL.computeAPICommandBindings;
+        xa.manageCommandObserver = aL.manageCommandObserver;
+        xa.hasSimpleAPICommandBindings = aL.hasSimpleAPICommandBindings;
+        xa.redrawText = function(e) {
+          return e = Ga.getGraphDiv(e), new Promise(function(t) {
+            setTimeout(function() {
+              e._fullLayout && (Xl.getComponentMethod("annotations", "draw")(e), Xl.getComponentMethod("legend", "draw")(e), Xl.getComponentMethod("colorbar", "draw")(e), t(xa.previousPromises(e)));
+            }, 300);
+          });
+        };
+        xa.resize = function(e) {
+          e = Ga.getGraphDiv(e);
+          var t, r = new Promise(function(n, i) {
+            (!e || Ga.isHidden(e)) && i(new Error("Resize must be passed a displayed plot div element.")), e._redrawTimer && clearTimeout(e._redrawTimer), e._resolveResize && (t = e._resolveResize), e._resolveResize = n, e._redrawTimer = setTimeout(function() {
+              if (!e.layout || e.layout.width && e.layout.height || Ga.isHidden(e)) {
+                n(e);
+                return;
+              }
+              delete e.layout.width, delete e.layout.height;
+              var a = e.changed;
+              e.autoplay = true, Xl.call("relayout", e, { autosize: true }).then(function() {
+                e.changed = a, e._resolveResize === n && (delete e._resolveResize, n(e));
+              });
+            }, 100);
+          });
+          return t && t(r), r;
+        };
+        xa.previousPromises = function(e) {
+          if ((e._promises || []).length) return Promise.all(e._promises).then(function() {
+            e._promises = [];
+          });
+        };
+        xa.addLinks = function(e) {
+          if (!(!e._context.showLink && !e._context.showSources)) {
+            var t = e._fullLayout, r = Ga.ensureSingle(t._paper, "text", "js-plot-link-container", function(l) {
+              l.style({ "font-family": '"Open Sans", Arial, sans-serif', "font-size": "12px", fill: Yne.defaultLine, "pointer-events": "all" }).each(function() {
+                var u = Xne.select(this);
+                u.append("tspan").classed("js-link-to-tool", true), u.append("tspan").classed("js-link-spacer", true), u.append("tspan").classed("js-sourcelinks", true);
+              });
+            }), n = r.node(), i = { y: t._paper.attr("height") - 9 };
+            document.body.contains(n) && n.getComputedTextLength() >= t.width - 20 ? (i["text-anchor"] = "start", i.x = 5) : (i["text-anchor"] = "end", i.x = t._paper.attr("width") - 7), r.attr(i);
+            var a = r.select(".js-link-to-tool"), o = r.select(".js-link-spacer"), s = r.select(".js-sourcelinks");
+            e._context.showSources && e._context.showSources(e), e._context.showLink && yat(e, a), o.text(a.text() && s.text() ? " - " : "");
+          }
+        };
+        function yat(e, t) {
+          t.text("");
+          var r = t.append("a").attr({ "xlink:xlink:href": "#", class: "link--impt link--embedview", "font-weight": "bold" }).text(e._context.linkText + " »");
+          if (e._context.sendData) r.on("click", function() {
+            xa.sendDataToCloud(e);
+          });
+          else {
+            var n = window.location.pathname.split("/"), i = window.location.search;
+            r.attr({ "xlink:xlink:show": "new", "xlink:xlink:href": "/" + n[2].split(".")[0] + "/" + n[1] + i });
+          }
+        }
+        xa.sendDataToCloud = function(e) {
+          var t = (window.PLOTLYENV || {}).BASE_URL || e._context.plotlyServerURL;
+          if (t) {
+            e.emit("plotly_beforeexport");
+            var r = Xne.select(e).append("div").attr("id", "hiddenform").style("display", "none"), n = r.append("form").attr({ action: t + "/external", method: "post", target: "_blank" }), i = n.append("input").attr({ type: "text", name: "data" });
+            return i.node().value = xa.graphJson(e, false, "keepdata"), n.node().submit(), r.remove(), e.emit("plotly_afterexport"), false;
+          }
+        };
+        var _at = ["days", "shortDays", "months", "shortMonths", "periods", "dateTime", "date", "time", "decimal", "thousands", "grouping", "currency"], xat = ["year", "month", "dayMonth", "dayMonthYear"];
+        xa.supplyDefaults = function(e, t) {
+          var r = t && t.skipUpdateCalc, n = e._fullLayout || {};
+          if (n._skipDefaults) {
+            delete n._skipDefaults;
+            return;
+          }
+          var i = e._fullLayout = {}, a = e.layout || {}, o = e._fullData || [], s = e._fullData = [], l = e.data || [], u = e.calcdata || [], c = e._context || {}, f;
+          e._transitionData || xa.createTransitionData(e), i._dfltTitle = { plot: Eb(e, "Click to enter Plot title"), subtitle: Eb(e, "Click to enter Plot subtitle"), x: Eb(e, "Click to enter X axis title"), y: Eb(e, "Click to enter Y axis title"), colorbar: Eb(e, "Click to enter Colorscale title"), annotation: Eb(e, "new text") }, i._traceWord = Eb(e, "trace");
+          var h = Gne(e, _at);
+          if (i._mapboxAccessToken = c.mapboxAccessToken, n._initialAutoSizeIsDone) {
+            var d = n.width, v = n.height;
+            xa.supplyLayoutGlobalDefaults(a, i, h), a.width || (i.width = d), a.height || (i.height = v), xa.sanitizeMargins(i);
+          } else {
+            xa.supplyLayoutGlobalDefaults(a, i, h);
+            var _ = !a.width || !a.height, b = i.autosize, p = c.autosizable, k = _ && (b || p);
+            k ? xa.plotAutoSize(e, a, i) : _ && xa.sanitizeMargins(i), !b && _ && (a.width = i.width, a.height = i.height);
+          }
+          i._d3locale = Tat(h, i.separators), i._extraFormat = Gne(e, xat), i._initialAutoSizeIsDone = true, i._dataLength = l.length, i._modules = [], i._visibleModules = [], i._basePlotModules = [];
+          var E = i._subplots = wat(), T = i._splomAxes = { x: {}, y: {} }, L = i._splomSubplots = {};
+          i._splomGridDflt = {}, i._scatterStackOpts = {}, i._firstScatter = {}, i._alignmentOpts = {}, i._colorAxes = {}, i._requestRangeslider = {}, i._traceUids = bat(o, l), xa.supplyDataDefaults(l, s, a, i);
+          var x = Object.keys(T.x), C = Object.keys(T.y);
+          if (x.length > 1 && C.length > 1) {
+            for (Xl.getComponentMethod("grid", "sizeDefaults")(a, i), f = 0; f < x.length; f++) Ga.pushUnique(E.xaxis, x[f]);
+            for (f = 0; f < C.length; f++) Ga.pushUnique(E.yaxis, C[f]);
+            for (var M in L) Ga.pushUnique(E.cartesian, M);
+          }
+          if (i._has = xa._hasPlotType.bind(i), o.length === s.length) for (f = 0; f < s.length; f++) Vne(s[f], o[f]);
+          xa.supplyLayoutModuleDefaults(a, i, s, e._transitionData);
+          var g = i._visibleModules, P = [];
+          for (f = 0; f < g.length; f++) {
+            var A = g[f].crossTraceDefaults;
+            A && Ga.pushUnique(P, A);
+          }
+          for (f = 0; f < P.length; f++) P[f](s, i);
+          i._hasOnlyLargeSploms = i._basePlotModules.length === 1 && i._basePlotModules[0].name === "splom" && x.length > 15 && C.length > 15 && i.shapes.length === 0 && i.images.length === 0, xa.linkSubplots(s, i, o, n), xa.cleanPlot(s, i, o, n);
+          var z = !!(n._has && n._has("cartesian")), O = !!(i._has && i._has("cartesian")), U = z, G = O;
+          U && !G ? n._bgLayer.remove() : G && !U && (i._shouldCreateBgLayer = true), n._zoomlayer && !e._dragging && vat({ _fullLayout: n }), Aat(s, i), Vne(i, n), Xl.getComponentMethod("colorscale", "crossTraceDefaults")(s, i), i._preGUI || (i._preGUI = {}), i._tracePreGUI || (i._tracePreGUI = {});
+          var Z = i._tracePreGUI, j = {}, N;
+          for (N in Z) j[N] = "old";
+          for (f = 0; f < s.length; f++) N = s[f]._fullInput.uid, j[N] || (Z[N] = {}), j[N] = "new";
+          for (N in j) j[N] === "old" && delete Z[N];
+          Kne(i), Xl.getComponentMethod("rangeslider", "makeData")(i), !r && u.length === s.length && xa.supplyDefaultsUpdateCalc(u, s);
+        };
+        xa.supplyDefaultsUpdateCalc = function(e, t) {
+          for (var r = 0; r < t.length; r++) {
+            var n = t[r], i = (e[r] || [])[0];
+            if (i && i.trace) {
+              var a = i.trace;
+              if (a._hasCalcTransform) {
+                var o = a._arrayAttrs, s, l, u;
+                for (s = 0; s < o.length; s++) l = o[s], u = Ga.nestedProperty(a, l).get().slice(), Ga.nestedProperty(n, l).set(u);
+              }
+              i.trace = n;
+            }
+          }
+        };
+        function bat(e, t) {
+          var r = t.length, n = [], i, a;
+          for (i = 0; i < e.length; i++) {
+            var o = e[i]._fullInput;
+            o !== a && n.push(o), a = o;
+          }
+          var s = n.length, l = new Array(r), u = {};
+          function c(d, v) {
+            l[v] = d, u[d] = 1;
+          }
+          function f(d, v) {
+            if (d && typeof d == "string" && !u[d]) return c(d, v), true;
+          }
+          for (i = 0; i < r; i++) {
+            var h = t[i].uid;
+            typeof h == "number" && (h = String(h)), !f(h, i) && (i < s && f(n[i].uid, i) || c(Ga.randstr(u), i));
+          }
+          return l;
+        }
+        function wat() {
+          var e = Xl.collectableSubplotTypes, t = {}, r, n;
+          if (!e) {
+            e = [];
+            var i = Xl.subplotsRegistry;
+            for (var a in i) {
+              var o = i[a], s = o.attr;
+              if (s && (e.push(a), Array.isArray(s))) for (n = 0; n < s.length; n++) Ga.pushUnique(e, s[n]);
+            }
+          }
+          for (r = 0; r < e.length; r++) t[e[r]] = [];
+          return t;
+        }
+        function Gne(e, t) {
+          var r = e._context.locale;
+          r || (r = "en-US");
+          var n = false, i = {};
+          function a(f) {
+            for (var h = true, d = 0; d < t.length; d++) {
+              var v = t[d];
+              i[v] || (f[v] ? i[v] = f[v] : h = false);
+            }
+            h && (n = true);
+          }
+          for (var o = 0; o < 2; o++) {
+            for (var s = e._context.locales, l = 0; l < 2; l++) {
+              var u = (s[r] || {}).format;
+              if (u && (a(u), n)) break;
+              s = Xl.localeRegistry;
+            }
+            var c = r.split("-")[0];
+            if (n || c === r) break;
+            r = c;
+          }
+          return n || a(Xl.localeRegistry.en.format), i;
+        }
+        function Tat(e, t) {
+          return e.decimal = t.charAt(0), e.thousands = t.charAt(1), { numberFormat: function(r) {
+            try {
+              r = fat(e).format(Ga.adjustFormat(r));
+            } catch (n) {
+              return Ga.warnBadFormat(r), Ga.noFormat;
+            }
+            return r;
+          }, timeFormat: cat(e).utcFormat };
+        }
+        function Aat(e, t) {
+          var r, n = [];
+          t.meta && (r = t._meta = { meta: t.meta, layout: { meta: t.meta } });
+          for (var i = 0; i < e.length; i++) {
+            var a = e[i];
+            a.meta ? n[a.index] = a._meta = { meta: a.meta } : t.meta && (a._meta = { meta: t.meta }), t.meta && (a._meta.layout = { meta: t.meta });
+          }
+          n.length && (r || (r = t._meta = {}), r.data = n);
+        }
+        xa.createTransitionData = function(e) {
+          e._transitionData || (e._transitionData = {}), e._transitionData._frames || (e._transitionData._frames = []), e._transitionData._frameHash || (e._transitionData._frameHash = {}), e._transitionData._counter || (e._transitionData._counter = 0), e._transitionData._interruptCallbacks || (e._transitionData._interruptCallbacks = []);
+        };
+        xa._hasPlotType = function(e) {
+          var t, r = this._basePlotModules || [];
+          for (t = 0; t < r.length; t++) if (r[t].name === e) return true;
+          var n = this._modules || [];
+          for (t = 0; t < n.length; t++) {
+            var i = n[t].name;
+            if (i === e) return true;
+            var a = Xl.modules[i];
+            if (a && a.categories[e]) return true;
+          }
+          return false;
+        };
+        xa.cleanPlot = function(e, t, r, n) {
+          var i, a, o = n._basePlotModules || [];
+          for (i = 0; i < o.length; i++) {
+            var s = o[i];
+            s.clean && s.clean(e, t, r, n);
+          }
+          var l = n._has && n._has("gl"), u = t._has && t._has("gl");
+          l && !u && n._glcontainer !== void 0 && (n._glcontainer.selectAll(".gl-canvas").remove(), n._glcontainer.selectAll(".no-webgl").remove(), n._glcanvas = null);
+          var c = !!n._infolayer;
+          e: for (i = 0; i < r.length; i++) {
+            var f = r[i], h = f.uid;
+            for (a = 0; a < e.length; a++) {
+              var d = e[a];
+              if (h === d.uid) continue e;
+            }
+            c && n._infolayer.select(".cb" + h).remove();
+          }
+        };
+        xa.linkSubplots = function(e, t, r, n) {
+          var i, a, o = n._plots || {}, s = t._plots = {}, l = t._subplots, u = { _fullData: e, _fullLayout: t }, c = l.cartesian || [];
+          for (i = 0; i < c.length; i++) {
+            var f = c[i], h = o[f], d = Mp.getFromId(u, f, "x"), v = Mp.getFromId(u, f, "y"), _;
+            for (h ? _ = s[f] = h : (_ = s[f] = {}, _.id = f), d._counterAxes.push(v._id), v._counterAxes.push(d._id), d._subplotsWith.push(f), v._subplotsWith.push(f), _.xaxis = d, _.yaxis = v, _._hasClipOnAxisFalse = false, a = 0; a < e.length; a++) {
+              var b = e[a];
+              if (b.xaxis === _.xaxis._id && b.yaxis === _.yaxis._id && b.cliponaxis === false) {
+                _._hasClipOnAxisFalse = true;
+                break;
+              }
+            }
+          }
+          var p = Mp.list(u, null, true), k;
+          for (i = 0; i < p.length; i++) {
+            k = p[i];
+            var E = null;
+            k.overlaying && (E = Mp.getFromId(u, k.overlaying), E && E.overlaying && (k.overlaying = false, E = null)), k._mainAxis = E || k, E && (k.domain = E.domain.slice()), k._anchorAxis = k.anchor === "free" ? null : Mp.getFromId(u, k.anchor);
+          }
+          for (i = 0; i < p.length; i++) if (k = p[i], k._counterAxes.sort(Mp.idSort), k._subplotsWith.sort(Ga.subplotSort), k._mainSubplot = Sat(k, t), k._counterAxes.length && (k.spikemode && k.spikemode.indexOf("across") !== -1 || k.automargin && k.mirror && k.anchor !== "free" || Xl.getComponentMethod("rangeslider", "isVisible")(k))) {
+            var T = 1, L = 0;
+            for (a = 0; a < k._counterAxes.length; a++) {
+              var x = Mp.getFromId(u, k._counterAxes[a]);
+              T = Math.min(T, x.domain[0]), L = Math.max(L, x.domain[1]);
+            }
+            T < L && (k._counterDomainMin = T, k._counterDomainMax = L);
+          }
+        };
+        function Sat(e, t) {
+          var r = { _fullLayout: t }, n = e._id.charAt(0) === "x", i = e._mainAxis._anchorAxis, a = "", o = "", s = "";
+          if (i && (s = i._mainAxis._id, a = n ? e._id + s : s + e._id), !a || !t._plots[a]) {
+            a = "";
+            for (var l = e._counterAxes, u = 0; u < l.length; u++) {
+              var c = l[u], f = n ? e._id + c : c + e._id;
+              o || (o = f);
+              var h = Mp.getFromId(r, c);
+              if (s && h.overlaying === s) {
+                a = f;
+                break;
+              }
+            }
+          }
+          return a || o;
+        }
+        xa.clearExpandedTraceDefaultColors = function(e) {
+          var t, r, n;
+          function i(o, s, l, u) {
+            r[u] = s, r.length = u + 1, o.valType === "color" && o.dflt === void 0 && t.push(r.join("."));
+          }
+          for (r = [], t = e._module._colorAttrs, t || (e._module._colorAttrs = t = [], Zne.crawl(e._module.attributes, i)), n = 0; n < t.length; n++) {
+            var a = Ga.nestedProperty(e, "_input." + t[n]);
+            a.get() || Ga.nestedProperty(e, t[n]).set(null);
+          }
+        };
+        xa.supplyDataDefaults = function(e, t, r, n) {
+          var i = n._modules, a = n._visibleModules, o = n._basePlotModules, l = 0, u, c, f;
+          n._transformModules = [];
+          function h(k) {
+            t.push(k);
+            var E = k._module;
+            E && (Ga.pushUnique(i, E), k.visible === true && Ga.pushUnique(a, E), Ga.pushUnique(o, k._module.basePlotModule), k._input.visible !== false && l++);
+          }
+          var d = {}, v = [], _ = (r.template || {}).data || {}, b = dat.traceTemplater(_);
+          for (u = 0; u < e.length; u++) f = e[u], c = b.newTrace(f), c.uid = n._traceUids[u], xa.supplyTraceDefaults(f, c, l, n, u), c.index = u, c._input = f, c._fullInput = c, h(c), Xl.traceIs(c, "carpetAxis") && (d[c.carpet] = c), Xl.traceIs(c, "carpetDependent") && v.push(u);
+          for (u = 0; u < v.length; u++) if (c = t[v[u]], !!c.visible) {
+            var p = d[c.carpet];
+            if (c._carpet = p, !p || !p.visible) {
+              c.visible = false;
+              continue;
+            }
+            c.xaxis = p.xaxis, c.yaxis = p.yaxis;
+          }
+        };
+        xa.supplyAnimationDefaults = function(e) {
+          e = e || {};
+          var t, r = {};
+          function n(i, a) {
+            return Ga.coerce(e || {}, r, yq, i, a);
+          }
+          if (n("mode"), n("direction"), n("fromcurrent"), Array.isArray(e.frame)) for (r.frame = [], t = 0; t < e.frame.length; t++) r.frame[t] = xa.supplyAnimationFrameDefaults(e.frame[t] || {});
+          else r.frame = xa.supplyAnimationFrameDefaults(e.frame || {});
+          if (Array.isArray(e.transition)) for (r.transition = [], t = 0; t < e.transition.length; t++) r.transition[t] = xa.supplyAnimationTransitionDefaults(e.transition[t] || {});
+          else r.transition = xa.supplyAnimationTransitionDefaults(e.transition || {});
+          return r;
+        };
+        xa.supplyAnimationFrameDefaults = function(e) {
+          var t = {};
+          function r(n, i) {
+            return Ga.coerce(e || {}, t, yq.frame, n, i);
+          }
+          return r("duration"), r("redraw"), t;
+        };
+        xa.supplyAnimationTransitionDefaults = function(e) {
+          var t = {};
+          function r(n, i) {
+            return Ga.coerce(e || {}, t, yq.transition, n, i);
+          }
+          return r("duration"), r("easing"), t;
+        };
+        xa.supplyFrameDefaults = function(e) {
+          var t = {};
+          function r(n, i) {
+            return Ga.coerce(e, t, gat, n, i);
+          }
+          return r("group"), r("name"), r("traces"), r("baseframe"), r("data"), r("layout"), t;
+        };
+        xa.supplyTraceDefaults = function(e, t, r, n, i) {
+          var a = n.colorway || Yne.defaults, o = a[r % a.length], s;
+          function l(E, T) {
+            return Ga.coerce(e, t, xa.attributes, E, T);
+          }
+          var u = l("visible");
+          l("type"), l("name", n._traceWord + " " + i), l("uirevision", n.uirevision);
+          var c = xa.getModule(t);
+          if (t._module = c, c) {
+            var f = c.basePlotModule, h = f.attr, d = f.attributes;
+            if (h && d) {
+              var v = n._subplots, _ = "";
+              if (Array.isArray(h)) for (s = 0; s < h.length; s++) {
+                var b = h[s], p = Ga.coerce(e, t, d, b);
+                v[b] && Ga.pushUnique(v[b], p), _ += p;
+              }
+              else _ = Ga.coerce(e, t, d, h);
+              v[f.name] && Ga.pushUnique(v[f.name], _);
+            }
+          }
+          if (u && (l("customdata"), l("ids"), l("meta"), Xl.traceIs(t, "showLegend") ? (Ga.coerce(e, t, c.attributes.showlegend ? c.attributes : xa.attributes, "showlegend"), Ga.coerce(e, t, c.attributes.legend ? c.attributes : xa.attributes, "legend"), l("legendwidth"), l("legendgroup"), l("legendgrouptitle.text"), l("legendrank"), t._dfltShowLegend = true) : t._dfltShowLegend = false, c && c.supplyDefaults(e, t, o, n), Xl.traceIs(t, "noOpacity") || l("opacity"), Xl.traceIs(t, "notLegendIsolatable") && (t.visible = !!t.visible), Xl.traceIs(t, "noHover") || (t.hovertemplate || Ga.coerceHoverinfo(e, t, n), t.type !== "parcats" && Xl.getComponentMethod("fx", "supplyDefaults")(e, t, o, n)), c && c.selectPoints)) {
+            var k = l("selectedpoints");
+            Ga.isTypedArray(k) && (t.selectedpoints = Array.from(k));
+          }
+          return t;
+        };
+        xa.supplyLayoutGlobalDefaults = function(e, t, r) {
+          function n(f, h) {
+            return Ga.coerce(e, t, xa.layoutAttributes, f, h);
+          }
+          var i = e.template;
+          Ga.isPlainObject(i) && (t.template = i, t._template = i.layout, t._dataTemplate = i.data), n("autotypenumbers");
+          var a = Ga.coerceFont(n, "font"), o = a.size;
+          Ga.coerceFont(n, "title.font", a, { overrideDflt: { size: Math.round(o * 1.4) } }), n("title.text", t._dfltTitle.plot), n("title.xref");
+          var s = n("title.yref");
+          n("title.pad.t"), n("title.pad.r"), n("title.pad.b"), n("title.pad.l");
+          var l = n("title.automargin");
+          n("title.x"), n("title.xanchor"), n("title.y"), n("title.yanchor"), n("title.subtitle.text", t._dfltTitle.subtitle), Ga.coerceFont(n, "title.subtitle.font", a, { overrideDflt: { size: Math.round(t.title.font.size * 0.7) } }), l && (s === "paper" && (t.title.y !== 0 && (t.title.y = 1), t.title.yanchor === "auto" && (t.title.yanchor = t.title.y === 0 ? "top" : "bottom")), s === "container" && (t.title.y === "auto" && (t.title.y = 1), t.title.yanchor === "auto" && (t.title.yanchor = t.title.y < 0.5 ? "bottom" : "top")));
+          var u = n("uniformtext.mode");
+          u && n("uniformtext.minsize"), n("autosize", !(e.width && e.height)), n("width"), n("height"), n("minreducedwidth"), n("minreducedheight"), n("margin.l"), n("margin.r"), n("margin.t"), n("margin.b"), n("margin.pad"), n("margin.autoexpand"), e.width && e.height && xa.sanitizeMargins(t), Xl.getComponentMethod("grid", "sizeDefaults")(e, t), n("paper_bgcolor"), n("separators", r.decimal + r.thousands), n("hidesources"), n("colorway"), n("datarevision");
+          var c = n("uirevision");
+          n("editrevision", c), n("selectionrevision", c), Xl.getComponentMethod("modebar", "supplyLayoutDefaults")(e, t), Xl.getComponentMethod("shapes", "supplyDrawNewShapeDefaults")(e, t, n), Xl.getComponentMethod("selections", "supplyDrawNewSelectionDefaults")(e, t, n), n("meta"), Ga.isPlainObject(e.transition) && (n("transition.duration"), n("transition.easing"), n("transition.ordering")), Xl.getComponentMethod("calendars", "handleDefaults")(e, t, "calendar"), Xl.getComponentMethod("fx", "supplyLayoutGlobalDefaults")(e, t, n), Ga.coerce(e, t, pat, "scattermode");
+        };
+        function nL(e) {
+          return typeof e == "string" && e.slice(-2) === "px" && parseFloat(e);
+        }
+        xa.plotAutoSize = function(t, r, n) {
+          var i = t._context || {}, a = i.frameMargins, o, s, l = Ga.isPlotDiv(t);
+          if (l && t.emit("plotly_autosize"), i.fillFrame) o = window.innerWidth, s = window.innerHeight, document.body.style.overflow = "hidden";
+          else {
+            var u = l ? window.getComputedStyle(t) : {};
+            if (o = nL(u.width) || nL(u.maxWidth) || n.width, s = nL(u.height) || nL(u.maxHeight) || n.height, tM(a) && a > 0) {
+              var c = 1 - 2 * a;
+              o = Math.round(c * o), s = Math.round(c * s);
+            }
+          }
+          var f = xa.layoutAttributes.width.min, h = xa.layoutAttributes.height.min;
+          o < f && (o = f), s < h && (s = h);
+          var d = !r.width && Math.abs(n.width - o) > 1, v = !r.height && Math.abs(n.height - s) > 1;
+          (v || d) && (d && (n.width = o), v && (n.height = s)), t._initialAutoSize || (t._initialAutoSize = { width: o, height: s }), xa.sanitizeMargins(n);
+        };
+        xa.supplyLayoutModuleDefaults = function(e, t, r, n) {
+          var i = Xl.componentsRegistry, a = t._basePlotModules, o, s, l, u = Xl.subplotsRegistry.cartesian;
+          for (o in i) l = i[o], l.includeBasePlot && l.includeBasePlot(e, t);
+          a.length || a.push(u), t._has("cartesian") && (Xl.getComponentMethod("grid", "contentDefaults")(e, t), u.finalizeSubplots(e, t));
+          for (var c in t._subplots) t._subplots[c].sort(Ga.subplotSort);
+          for (s = 0; s < a.length; s++) l = a[s], l.supplyLayoutDefaults && l.supplyLayoutDefaults(e, t, r);
+          var f = t._modules;
+          for (s = 0; s < f.length; s++) l = f[s], l.supplyLayoutDefaults && l.supplyLayoutDefaults(e, t, r);
+          var h = t._transformModules;
+          for (s = 0; s < h.length; s++) l = h[s], l.supplyLayoutDefaults && l.supplyLayoutDefaults(e, t, r, n);
+          for (o in i) l = i[o], l.supplyLayoutDefaults && l.supplyLayoutDefaults(e, t, r);
+        };
+        xa.purge = function(e) {
+          var t = e._fullLayout || {};
+          t._glcontainer !== void 0 && (t._glcontainer.selectAll(".gl-canvas").remove(), t._glcontainer.remove(), t._glcanvas = null), t._modeBar && t._modeBar.destroy(), e._transitionData && (e._transitionData._interruptCallbacks && (e._transitionData._interruptCallbacks.length = 0), e._transitionData._animationRaf && window.cancelAnimationFrame(e._transitionData._animationRaf)), Ga.clearThrottle(), Ga.clearResponsive(e), delete e.data, delete e.layout, delete e._fullData, delete e._fullLayout, delete e.calcdata, delete e.empty, delete e.fid, delete e.undoqueue, delete e.undonum, delete e.autoplay, delete e.changed, delete e._promises, delete e._redrawTimer, delete e._hmlumcount, delete e._hmpixcount, delete e._transitionData, delete e._transitioning, delete e._initialAutoSize, delete e._transitioningWithDuration, delete e._dragging, delete e._dragged, delete e._dragdata, delete e._hoverdata, delete e._snapshotInProgress, delete e._editing, delete e._mouseDownTime, delete e._legendMouseDownTime, e.removeAllListeners && e.removeAllListeners();
+        };
+        xa.style = function(e) {
+          var t = e._fullLayout._visibleModules, r = [], n;
+          for (n = 0; n < t.length; n++) {
+            var i = t[n];
+            i.style && Ga.pushUnique(r, i.style);
+          }
+          for (n = 0; n < r.length; n++) r[n](e);
+        };
+        xa.sanitizeMargins = function(e) {
+          if (!(!e || !e.margin)) {
+            var t = e.width, r = e.height, n = e.margin, i = t - (n.l + n.r), a = r - (n.t + n.b), o;
+            i < 0 && (o = (t - 1) / (n.l + n.r), n.l = Math.floor(o * n.l), n.r = Math.floor(o * n.r)), a < 0 && (o = (r - 1) / (n.t + n.b), n.t = Math.floor(o * n.t), n.b = Math.floor(o * n.b));
+          }
+        };
+        xa.clearAutoMarginIds = function(e) {
+          e._fullLayout._pushmarginIds = {};
+        };
+        xa.allowAutoMargin = function(e, t) {
+          e._fullLayout._pushmarginIds[t] = 1;
+        };
+        function Kne(e) {
+          var t = e.margin;
+          if (!e._size) {
+            var r = e._size = { l: Math.round(t.l), r: Math.round(t.r), t: Math.round(t.t), b: Math.round(t.b), p: Math.round(t.pad) };
+            r.w = Math.round(e.width) - r.l - r.r, r.h = Math.round(e.height) - r.t - r.b;
+          }
+          e._pushmargin || (e._pushmargin = {}), e._pushmarginIds || (e._pushmarginIds = {}), e._reservedMargin || (e._reservedMargin = {});
+        }
+        var Jne = 2, $ne = 2;
+        xa.autoMargin = function(e, t, r) {
+          var n = e._fullLayout, i = n.width, a = n.height, o = n.margin, s = n.minreducedwidth, l = n.minreducedheight, u = Ga.constrain(i - o.l - o.r, Jne, s), c = Ga.constrain(a - o.t - o.b, $ne, l), f = Math.max(0, i - u), h = Math.max(0, a - c), d = n._pushmargin, v = n._pushmarginIds;
+          if (o.autoexpand !== false) {
+            if (!r) delete d[t], delete v[t];
+            else {
+              var _ = r.pad;
+              if (_ === void 0 && (_ = Math.min(12, o.l, o.r, o.t, o.b)), f) {
+                var b = (r.l + r.r) / f;
+                b > 1 && (r.l /= b, r.r /= b);
+              }
+              if (h) {
+                var p = (r.t + r.b) / h;
+                p > 1 && (r.t /= p, r.b /= p);
+              }
+              var k = r.xl !== void 0 ? r.xl : r.x, E = r.xr !== void 0 ? r.xr : r.x, T = r.yt !== void 0 ? r.yt : r.y, L = r.yb !== void 0 ? r.yb : r.y;
+              d[t] = { l: { val: k, size: r.l + _ }, r: { val: E, size: r.r + _ }, b: { val: L, size: r.b + _ }, t: { val: T, size: r.t + _ } }, v[t] = 1;
+            }
+            if (!n._replotting) return xa.doAutoMargin(e);
+          }
+        };
+        function Mat(e) {
+          if ("_redrawFromAutoMarginCount" in e._fullLayout) return false;
+          var t = Mp.list(e, "", true);
+          for (var r in t) if (t[r].autoshift || t[r].shift) return true;
+          return false;
+        }
+        xa.doAutoMargin = function(e) {
+          var t = e._fullLayout, r = t.width, n = t.height;
+          t._size || (t._size = {}), Kne(t);
+          var i = t._size, a = t.margin, o = { t: 0, b: 0, l: 0, r: 0 }, s = Ga.extendFlat({}, i), l = a.l, u = a.r, c = a.t, f = a.b, h = t._pushmargin, d = t._pushmarginIds, v = t.minreducedwidth, _ = t.minreducedheight;
+          if (a.autoexpand !== false) {
+            for (var b in h) d[b] || delete h[b];
+            var p = e._fullLayout._reservedMargin;
+            for (var k in p) for (var E in p[k]) {
+              var T = p[k][E];
+              o[E] = Math.max(o[E], T);
+            }
+            h.base = { l: { val: 0, size: l }, r: { val: 1, size: u }, t: { val: 1, size: c }, b: { val: 0, size: f } };
+            for (var L in o) {
+              var x = 0;
+              for (var C in h) C !== "base" && tM(h[C][L].size) && (x = h[C][L].size > x ? h[C][L].size : x);
+              var M = Math.max(0, a[L] - x);
+              o[L] = Math.max(0, o[L] - M);
+            }
+            for (var g in h) {
+              var P = h[g].l || {}, A = h[g].b || {}, z = P.val, O = P.size, U = A.val, G = A.size, Z = r - o.r - o.l, j = n - o.t - o.b;
+              for (var N in h) {
+                if (tM(O) && h[N].r) {
+                  var H = h[N].r.val, re = h[N].r.size;
+                  if (H > z) {
+                    var oe = (O * H + (re - Z) * z) / (H - z), _e = (re * (1 - z) + (O - Z) * (1 - H)) / (H - z);
+                    oe + _e > l + u && (l = oe, u = _e);
+                  }
+                }
+                if (tM(G) && h[N].t) {
+                  var Ce = h[N].t.val, Le = h[N].t.size;
+                  if (Ce > U) {
+                    var ge = (G * Ce + (Le - j) * U) / (Ce - U), ie = (Le * (1 - U) + (G - j) * (1 - Ce)) / (Ce - U);
+                    ge + ie > f + c && (f = ge, c = ie);
+                  }
+                }
+              }
+            }
+          }
+          var Se = Ga.constrain(r - a.l - a.r, Jne, v), Ee = Ga.constrain(n - a.t - a.b, $ne, _), Ae = Math.max(0, r - Se), Be = Math.max(0, n - Ee);
+          if (Ae) {
+            var Pe = (l + u) / Ae;
+            Pe > 1 && (l /= Pe, u /= Pe);
+          }
+          if (Be) {
+            var me = (f + c) / Be;
+            me > 1 && (f /= me, c /= me);
+          }
+          if (i.l = Math.round(l) + o.l, i.r = Math.round(u) + o.r, i.t = Math.round(c) + o.t, i.b = Math.round(f) + o.b, i.p = Math.round(a.pad), i.w = Math.round(r) - i.l - i.r, i.h = Math.round(n) - i.t - i.b, !t._replotting && (xa.didMarginChange(s, i) || Mat(e))) {
+            "_redrawFromAutoMarginCount" in t ? t._redrawFromAutoMarginCount++ : t._redrawFromAutoMarginCount = 1;
+            var De = 3 * (1 + Object.keys(d).length);
+            if (t._redrawFromAutoMarginCount < De) return Xl.call("_doPlot", e);
+            t._size = s, Ga.warn("Too many auto-margin redraws.");
+          }
+          Eat(e);
+        };
+        function Eat(e) {
+          var t = Mp.list(e, "", true);
+          ["_adjustTickLabelsOverflow", "_hideCounterAxisInsideTickLabels"].forEach(function(r) {
+            for (var n = 0; n < t.length; n++) {
+              var i = t[n][r];
+              i && i();
+            }
+          });
+        }
+        var Hne = ["l", "r", "t", "b", "p", "w", "h"];
+        xa.didMarginChange = function(e, t) {
+          for (var r = 0; r < Hne.length; r++) {
+            var n = Hne[r], i = e[n], a = t[n];
+            if (!tM(i) || Math.abs(a - i) > 1) return true;
+          }
+          return false;
+        };
+        xa.graphJson = function(e, t, r, n, i, a) {
+          (i && t && !e._fullData || i && !t && !e._fullLayout) && xa.supplyDefaults(e);
+          var o = i ? e._fullData : e.data, s = i ? e._fullLayout : e.layout, l = (e._transitionData || {})._frames;
+          function u(h, d) {
+            if (typeof h == "function") return d ? "_function_" : null;
+            if (Ga.isPlainObject(h)) {
+              var v = {}, _;
+              return Object.keys(h).sort().forEach(function(E) {
+                if (["_", "["].indexOf(E.charAt(0)) === -1) {
+                  if (typeof h[E] == "function") {
+                    d && (v[E] = "_function");
+                    return;
+                  }
+                  if (r === "keepdata") {
+                    if (E.slice(-3) === "src") return;
+                  } else if (r === "keepstream") {
+                    if (_ = h[E + "src"], typeof _ == "string" && _.indexOf(":") > 0 && !Ga.isPlainObject(h.stream)) return;
+                  } else if (r !== "keepall" && (_ = h[E + "src"], typeof _ == "string" && _.indexOf(":") > 0)) return;
+                  v[E] = u(h[E], d);
+                }
+              }), v;
+            }
+            var b = Array.isArray(h), p = Ga.isTypedArray(h);
+            if ((b || p) && h.dtype && h.shape) {
+              var k = h.bdata;
+              return u({ dtype: h.dtype, shape: h.shape, bdata: Ga.isArrayBuffer(k) ? hat.encode(k) : k }, d);
+            }
+            return b ? h.map(function(E) {
+              return u(E, d);
+            }) : p ? Ga.simpleMap(h, Ga.identity) : Ga.isJSDate(h) ? Ga.ms2DateTimeLocal(+h) : h;
+          }
+          var c = { data: (o || []).map(function(h) {
+            var d = u(h);
+            return t && delete d.fit, d;
+          }) };
+          if (!t && (c.layout = u(s), i)) {
+            var f = s._size;
+            c.layout.computed = { margin: { b: f.b, l: f.l, r: f.r, t: f.t } };
+          }
+          return l && (c.frames = u(l)), a && (c.config = u(e._context, true)), n === "object" ? c : JSON.stringify(c);
+        };
+        xa.modifyFrames = function(e, t) {
+          var r, n, i, a = e._transitionData._frames, o = e._transitionData._frameHash;
+          for (r = 0; r < t.length; r++) switch (n = t[r], n.type) {
+            case "replace":
+              i = n.value;
+              var s = (a[n.index] || {}).name, l = i.name;
+              a[n.index] = o[l] = i, l !== s && (delete o[s], o[l] = i);
+              break;
+            case "insert":
+              i = n.value, o[i.name] = i, a.splice(n.index, 0, i);
+              break;
+            case "delete":
+              i = a[n.index], delete o[i.name], a.splice(n.index, 1);
+              break;
+          }
+          return Promise.resolve();
+        };
+        xa.computeFrame = function(e, t) {
+          var r = e._transitionData._frameHash, n, i, a, o;
+          if (!t) throw new Error("computeFrame must be given a string frame name");
+          var s = r[t.toString()];
+          if (!s) return false;
+          for (var l = [s], u = [s.name]; s.baseframe && (s = r[s.baseframe.toString()]) && u.indexOf(s.name) === -1; ) l.push(s), u.push(s.name);
+          for (var c = {}; s = l.pop(); ) if (s.layout && (c.layout = xa.extendLayout(c.layout, s.layout)), s.data) {
+            if (c.data || (c.data = []), i = s.traces, !i) for (i = [], n = 0; n < s.data.length; n++) i[n] = n;
+            for (c.traces || (c.traces = []), n = 0; n < s.data.length; n++) a = i[n], a != null && (o = c.traces.indexOf(a), o === -1 && (o = c.data.length, c.traces[o] = a), c.data[o] = xa.extendTrace(c.data[o], s.data[n]));
+          }
+          return c;
+        };
+        xa.recomputeFrameHash = function(e) {
+          for (var t = e._transitionData._frameHash = {}, r = e._transitionData._frames, n = 0; n < r.length; n++) {
+            var i = r[n];
+            i && i.name && (t[i.name] = i);
+          }
+        };
+        xa.extendObjectWithContainers = function(e, t, r) {
+          var n, i, a, o, s, l, u, c, f = Ga.extendDeepNoArrays({}, t || {}), h = Ga.expandObjectPaths(f), d = {};
+          if (r && r.length) for (a = 0; a < r.length; a++) n = Ga.nestedProperty(h, r[a]), i = n.get(), i === void 0 ? Ga.nestedProperty(d, r[a]).set(null) : (n.set(null), Ga.nestedProperty(d, r[a]).set(i));
+          if (e = Ga.extendDeepNoArrays(e || {}, h), r && r.length) {
+            for (a = 0; a < r.length; a++) if (s = Ga.nestedProperty(d, r[a]), u = s.get(), !!u) {
+              for (l = Ga.nestedProperty(e, r[a]), c = l.get(), Array.isArray(c) || (c = [], l.set(c)), o = 0; o < u.length; o++) {
+                var v = u[o];
+                v === null ? c[o] = null : c[o] = xa.extendObjectWithContainers(c[o], v);
+              }
+              l.set(c);
+            }
+          }
+          return e;
+        };
+        xa.dataArrayContainers = ["transforms", "dimensions"];
+        xa.layoutArrayContainers = Xl.layoutArrayContainers;
+        xa.extendTrace = function(e, t) {
+          return xa.extendObjectWithContainers(e, t, xa.dataArrayContainers);
+        };
+        xa.extendLayout = function(e, t) {
+          return xa.extendObjectWithContainers(e, t, xa.layoutArrayContainers);
+        };
+        xa.transition = function(e, t, r, n, i, a) {
+          var o = { redraw: i.redraw }, s = {}, l = [];
+          return o.prepareFn = function() {
+            for (var u = Array.isArray(t) ? t.length : 0, c = n.slice(0, u), f = 0; f < c.length; f++) {
+              var h = c[f], d = e._fullData[h], v = d._module;
+              if (v) {
+                if (v.animatable) {
+                  var _ = v.basePlotModule.name;
+                  s[_] || (s[_] = []), s[_].push(h);
+                }
+                e.data[c[f]] = xa.extendTrace(e.data[c[f]], t[f]);
+              }
+            }
+            var b = Ga.expandObjectPaths(Ga.extendDeepNoArrays({}, r)), p = /^[xy]axis[0-9]*$/;
+            for (var k in b) p.test(k) && delete b[k].range;
+            xa.extendLayout(e.layout, b), delete e.calcdata, xa.supplyDefaults(e), xa.doCalcdata(e);
+            var E = Ga.expandObjectPaths(r);
+            if (E) {
+              var T = e._fullLayout._plots;
+              for (var L in T) {
+                var x = T[L], C = x.xaxis, M = x.yaxis, g = C.range.slice(), P = M.range.slice(), A = null, z = null, O = null, U = null;
+                Array.isArray(E[C._name + ".range"]) ? A = E[C._name + ".range"].slice() : Array.isArray((E[C._name] || {}).range) && (A = E[C._name].range.slice()), Array.isArray(E[M._name + ".range"]) ? z = E[M._name + ".range"].slice() : Array.isArray((E[M._name] || {}).range) && (z = E[M._name].range.slice()), g && A && (C.r2l(g[0]) !== C.r2l(A[0]) || C.r2l(g[1]) !== C.r2l(A[1])) && (O = { xr0: g, xr1: A }), P && z && (M.r2l(P[0]) !== M.r2l(z[0]) || M.r2l(P[1]) !== M.r2l(z[1])) && (U = { yr0: P, yr1: z }), (O || U) && l.push(Ga.extendFlat({ plotinfo: x }, O, U));
+              }
+            }
+            return Promise.resolve();
+          }, o.runFn = function(u) {
+            var c, f = e._fullLayout._basePlotModules, h = l.length, d;
+            if (r) for (d = 0; d < f.length; d++) f[d].transitionAxes && f[d].transitionAxes(e, l, a, u);
+            h ? (c = Ga.extendFlat({}, a), c.duration = 0, delete s.cartesian) : c = a;
+            for (var v in s) {
+              var _ = s[v], b = e._fullData[_[0]]._module;
+              b.basePlotModule.plot(e, _, c, u);
+            }
+          }, Qne(e, a, o);
+        };
+        xa.transitionFromReact = function(e, t, r, n) {
+          var i = e._fullLayout, a = i.transition, o = {}, s = [];
+          return o.prepareFn = function() {
+            var l = i._plots;
+            o.redraw = false, t.anim === "some" && (o.redraw = true), r.anim === "some" && (o.redraw = true);
+            for (var u in l) {
+              var c = l[u], f = c.xaxis, h = c.yaxis, d = n[f._name].range.slice(), v = n[h._name].range.slice(), _ = f.range.slice(), b = h.range.slice();
+              f.setScale(), h.setScale();
+              var p = null, k = null;
+              (f.r2l(d[0]) !== f.r2l(_[0]) || f.r2l(d[1]) !== f.r2l(_[1])) && (p = { xr0: d, xr1: _ }), (h.r2l(v[0]) !== h.r2l(b[0]) || h.r2l(v[1]) !== h.r2l(b[1])) && (k = { yr0: v, yr1: b }), (p || k) && s.push(Ga.extendFlat({ plotinfo: c }, p, k));
+            }
+            return Promise.resolve();
+          }, o.runFn = function(l) {
+            for (var u = e._fullData, c = e._fullLayout, f = c._basePlotModules, h, d, v, _ = [], b = 0; b < u.length; b++) _.push(b);
+            function p() {
+              if (e._fullLayout) for (var E = 0; E < f.length; E++) f[E].transitionAxes && f[E].transitionAxes(e, s, h, l);
+            }
+            function k() {
+              if (e._fullLayout) for (var E = 0; E < f.length; E++) f[E].plot(e, v, d, l);
+            }
+            s.length && t.anim ? a.ordering === "traces first" ? (h = Ga.extendFlat({}, a, { duration: 0 }), v = _, d = a, setTimeout(p, a.duration), k()) : (h = a, v = null, d = Ga.extendFlat({}, a, { duration: 0 }), setTimeout(k, h.duration), p()) : s.length ? (h = a, p()) : t.anim && (v = _, d = a, k());
+          }, Qne(e, a, o);
+        };
+        function Qne(e, t, r) {
+          var n = false;
+          function i(f) {
+            var h = Promise.resolve();
+            if (!f) return h;
+            for (; f.length; ) h = h.then(f.shift());
+            return h;
+          }
+          function a(f) {
+            if (f) for (; f.length; ) f.shift();
+          }
+          function o() {
+            return e.emit("plotly_transitioning", []), new Promise(function(f) {
+              e._transitioning = true, t.duration > 0 && (e._transitioningWithDuration = true), e._transitionData._interruptCallbacks.push(function() {
+                n = true;
+              }), r.redraw && e._transitionData._interruptCallbacks.push(function() {
+                return Xl.call("redraw", e);
+              }), e._transitionData._interruptCallbacks.push(function() {
+                e.emit("plotly_transitioninterrupted", []);
+              });
+              var h = 0, d = 0;
+              function v() {
+                return h++, function() {
+                  d++, !n && d === h && s(f);
+                };
+              }
+              r.runFn(v), setTimeout(v());
+            });
+          }
+          function s(f) {
+            if (e._transitionData) return a(e._transitionData._interruptCallbacks), Promise.resolve().then(function() {
+              if (r.redraw) return Xl.call("redraw", e);
+            }).then(function() {
+              e._transitioning = false, e._transitioningWithDuration = false, e.emit("plotly_transitioned", []);
+            }).then(f);
+          }
+          function l() {
+            if (e._transitionData) return e._transitioning = false, i(e._transitionData._interruptCallbacks);
+          }
+          var u = [xa.previousPromises, l, r.prepareFn, xa.rehover, xa.reselect, o], c = Ga.syncOrAsync(u, e);
+          return (!c || !c.then) && (c = Promise.resolve()), c.then(function() {
+            return e;
+          });
+        }
+        xa.doCalcdata = function(e, t) {
+          var r = Mp.list(e), n = e._fullData, i = e._fullLayout, a, o, s, l, u = new Array(n.length), c = (e.calcdata || []).slice();
+          for (e.calcdata = u, i._numBoxes = 0, i._numViolins = 0, i._violinScaleGroupStats = {}, e._hmpixcount = 0, e._hmlumcount = 0, i._piecolormap = {}, i._sunburstcolormap = {}, i._treemapcolormap = {}, i._iciclecolormap = {}, i._funnelareacolormap = {}, s = 0; s < n.length; s++) if (Array.isArray(t) && t.indexOf(s) === -1) {
+            u[s] = c[s];
+            continue;
+          }
+          for (s = 0; s < n.length; s++) a = n[s], a._arrayAttrs = Zne.findArrayAttributes(a), a._extremes = {};
+          var f = i._subplots.polar || [];
+          for (s = 0; s < f.length; s++) r.push(i[f[s]].radialaxis, i[f[s]].angularaxis);
+          for (var h in i._colorAxes) {
+            var d = i[h];
+            d.cauto !== false && (delete d.cmin, delete d.cmax);
+          }
+          var v = false;
+          function _(k) {
+            if (a = n[k], o = a._module, a.visible === true && a.transforms) {
+              if (o && o.calc) {
+                var E = o.calc(e, a);
+                E[0] && E[0].t && E[0].t._scene && delete E[0].t._scene.dirty;
+              }
+              for (l = 0; l < a.transforms.length; l++) {
+                var T = a.transforms[l];
+                o = transformsRegistry[T.type], o && o.calcTransform && (a._hasCalcTransform = true, v = true, o.calcTransform(e, a, T));
+              }
+            }
+          }
+          function b(k, E) {
+            if (a = n[k], o = a._module, !!o.isContainer === E) {
+              var T = [];
+              if (a.visible === true && a._length !== 0) {
+                delete a._indexToPoints;
+                var L = a.transforms || [];
+                for (l = L.length - 1; l >= 0; l--) if (L[l].enabled) {
+                  a._indexToPoints = L[l]._indexToPoints;
+                  break;
+                }
+                o && o.calc && (T = o.calc(e, a));
+              }
+              (!Array.isArray(T) || !T[0]) && (T = [{ x: Une, y: Une }]), T[0].t || (T[0].t = {}), T[0].trace = a, u[k] = T;
+            }
+          }
+          for (jne(r, n, i), s = 0; s < n.length; s++) b(s, true);
+          for (s = 0; s < n.length; s++) _(s);
+          for (v && jne(r, n, i), s = 0; s < n.length; s++) b(s, true);
+          for (s = 0; s < n.length; s++) b(s, false);
+          Wne(e);
+          var p = Cat(r, e);
+          if (p.length) {
+            for (i._numBoxes = 0, i._numViolins = 0, s = 0; s < p.length; s++) b(p[s], true);
+            for (s = 0; s < p.length; s++) b(p[s], false);
+            Wne(e);
+          }
+          Xl.getComponentMethod("fx", "calc")(e), Xl.getComponentMethod("errorbars", "calc")(e);
+        };
+        var kat = /(total|sum|min|max|mean|geometric mean|median) (ascending|descending)/;
+        function Cat(e, t) {
+          var r = [], n, i, a, o, s;
+          function l(N, H, re) {
+            var oe = H._id.charAt(0);
+            if (N === "histogram2dcontour") {
+              var _e = H._counterAxes[0], Ce = Mp.getFromId(t, _e), Le = oe === "x" || _e === "x" && Ce.type === "category", ge = oe === "y" || _e === "y" && Ce.type === "category";
+              return function(ie, Se) {
+                return ie === 0 || Se === 0 || Le && ie === re[Se].length - 1 || ge && Se === re.length - 1 ? -1 : (oe === "y" ? Se : ie) - 1;
+              };
+            } else return function(ie, Se) {
+              return oe === "y" ? Se : ie;
+            };
+          }
+          var u = { min: function(N) {
+            return Ga.aggNums(Math.min, null, N);
+          }, max: function(N) {
+            return Ga.aggNums(Math.max, null, N);
+          }, sum: function(N) {
+            return Ga.aggNums(function(H, re) {
+              return H + re;
+            }, null, N);
+          }, total: function(N) {
+            return Ga.aggNums(function(H, re) {
+              return H + re;
+            }, null, N);
+          }, mean: function(N) {
+            return Ga.mean(N);
+          }, "geometric mean": function(N) {
+            return Ga.geometricMean(N);
+          }, median: function(N) {
+            return Ga.median(N);
+          } };
+          function c(N, H) {
+            return N[1] - H[1];
+          }
+          function f(N, H) {
+            return H[1] - N[1];
+          }
+          for (n = 0; n < e.length; n++) {
+            var h = e[n];
+            if (h.type === "category") {
+              var d = h.categoryorder.match(kat);
+              if (d) {
+                var v = d[1], _ = d[2], b = h._id.charAt(0), p = b === "x", k = [];
+                for (i = 0; i < h._categories.length; i++) k.push([h._categories[i], []]);
+                for (i = 0; i < h._traceIndices.length; i++) {
+                  var E = h._traceIndices[i], T = t._fullData[E];
+                  if (T.visible === true) {
+                    var L = T.type;
+                    Xl.traceIs(T, "histogram") && (delete T._xautoBinFinished, delete T._yautoBinFinished);
+                    var x = L === "splom", C = L === "scattergl", M = t.calcdata[E];
+                    for (a = 0; a < M.length; a++) {
+                      var g = M[a], P, A;
+                      if (x) {
+                        var z = T._axesDim[h._id];
+                        if (!p) {
+                          var O = T._diag[z][0];
+                          O && (h = t._fullLayout[Mp.id2name(O)]);
+                        }
+                        var U = g.trace.dimensions[z].values;
+                        for (o = 0; o < U.length; o++) for (P = h._categoriesMap[U[o]], s = 0; s < g.trace.dimensions.length; s++) if (s !== z) {
+                          var G = g.trace.dimensions[s];
+                          k[P][1].push(G.values[o]);
+                        }
+                      } else if (C) {
+                        for (o = 0; o < g.t.x.length; o++) p ? (P = g.t.x[o], A = g.t.y[o]) : (P = g.t.y[o], A = g.t.x[o]), k[P][1].push(A);
+                        g.t && g.t._scene && delete g.t._scene.dirty;
+                      } else if (g.hasOwnProperty("z")) {
+                        A = g.z;
+                        var Z = l(T.type, h, A);
+                        for (o = 0; o < A.length; o++) for (s = 0; s < A[o].length; s++) P = Z(s, o), P + 1 && k[P][1].push(A[o][s]);
+                      } else for (P = g.p, P === void 0 && (P = g[b]), A = g.s, A === void 0 && (A = g.v), A === void 0 && (A = p ? g.y : g.x), Array.isArray(A) || (A === void 0 ? A = [] : A = [A]), o = 0; o < A.length; o++) k[P][1].push(A[o]);
+                    }
+                  }
+                }
+                h._categoriesValue = k;
+                var j = [];
+                for (i = 0; i < k.length; i++) j.push([k[i][0], u[v](k[i][1])]);
+                j.sort(_ === "descending" ? f : c), h._categoriesAggregatedValue = j, h._initialCategories = j.map(function(N) {
+                  return N[0];
+                }), r = r.concat(h.sortByInitialCategories());
+              }
+            }
+          }
+          return r;
+        }
+        function jne(e, t, r) {
+          var n = {};
+          function i(l) {
+            l.clearCalc(), l.type === "multicategory" && l.setupMultiCategory(t), n[l._id] = 1;
+          }
+          Ga.simpleMap(e, i);
+          for (var a = r._axisMatchGroups || [], o = 0; o < a.length; o++) for (var s in a[o]) n[s] || i(r[Mp.id2name(s)]);
+        }
+        function Wne(e) {
+          var t = e._fullLayout, r = t._visibleModules, n = {}, i, a, o;
+          for (a = 0; a < r.length; a++) {
+            var s = r[a], l = s.crossTraceCalc;
+            if (l) {
+              var u = s.basePlotModule.name;
+              n[u] ? Ga.pushUnique(n[u], l) : n[u] = [l];
+            }
+          }
+          for (o in n) {
+            var c = n[o], f = t._subplots[o];
+            if (Array.isArray(f)) for (i = 0; i < f.length; i++) {
+              var h = f[i], d = o === "cartesian" ? t._plots[h] : t[h];
+              for (a = 0; a < c.length; a++) c[a](e, d, h);
+            }
+            else for (a = 0; a < c.length; a++) c[a](e);
+          }
+        }
+        xa.rehover = function(e) {
+          e._fullLayout._rehover && e._fullLayout._rehover();
+        };
+        xa.redrag = function(e) {
+          e._fullLayout._redrag && e._fullLayout._redrag();
+        };
+        xa.reselect = function(e) {
+          var t = e._fullLayout, r = (e.layout || {}).selections, n = t._previousSelections;
+          t._previousSelections = r;
+          var i = t._reselect || JSON.stringify(r) !== JSON.stringify(n);
+          Xl.getComponentMethod("selections", "reselect")(e, i);
+        };
+        xa.generalUpdatePerTraceModule = function(e, t, r, n) {
+          var i = t.traceHash, a = {}, o;
+          for (o = 0; o < r.length; o++) {
+            var s = r[o], l = s[0].trace;
+            l.visible && (a[l.type] = a[l.type] || [], a[l.type].push(s));
+          }
+          for (var u in i) if (!a[u]) {
+            var c = i[u][0], f = c[0].trace;
+            f.visible = false, a[u] = [c];
+          }
+          for (var h in a) {
+            var d = a[h], v = d[0][0].trace._module;
+            v.plot(e, t, Ga.filterVisible(d), n);
+          }
+          t.traceHash = a;
+        };
+        xa.plotBasePlot = function(e, t, r, n, i) {
+          var a = Xl.getModule(e), o = mat(t.calcdata, a)[0];
+          a.plot(t, o, n, i);
+        };
+        xa.cleanBasePlot = function(e, t, r, n, i) {
+          var a = i._has && i._has(e), o = r._has && r._has(e);
+          a && !o && i["_" + e + "layer"].selectAll("g.trace").remove();
+        };
+      });
+      var Wp = ye((kb) => {
+        kb.xmlns = "http://www.w3.org/2000/xmlns/";
+        kb.svg = "http://www.w3.org/2000/svg";
+        kb.xlink = "http://www.w3.org/1999/xlink";
+        kb.svgAttrs = { xmlns: kb.svg, "xmlns:xlink": kb.xlink };
+      });
+      var Dh = ye((wnr, tae) => {
+        tae.exports = { FROM_BL: { left: 0, center: 0.5, right: 1, bottom: 0, middle: 0.5, top: 1 }, FROM_TL: { left: 0, center: 0.5, right: 1, bottom: 1, middle: 0.5, top: 0 }, FROM_BR: { left: 1, center: 0.5, right: 0, bottom: 0, middle: 0.5, top: 1 }, LINE_SPACING: 1.3, CAP_SHIFT: 0.7, MID_SHIFT: 0.35, OPPOSITE_SIDE: { left: "right", right: "left", top: "bottom", bottom: "top" } };
+      });
+      var Zl = ye((b0) => {
+        var Fh = Oa(), Ly = Dr(), Lat = Ly.strTranslate, _q = Wp(), Pat = Dh().LINE_SPACING, Iat = /([^$]*)([$]+[^$]*[$]+)([^$]*)/;
+        b0.convertToTspans = function(e, t, r) {
+          var n = e.text(), i = !e.attr("data-notex") && t && t._context.typesetMath && typeof MathJax != "undefined" && n.match(Iat), a = Fh.select(e.node().parentNode);
+          if (a.empty()) return;
+          var o = e.attr("class") ? e.attr("class").split(" ")[0] : "text";
+          o += "-math", a.selectAll("svg." + o).remove(), a.selectAll("g." + o + "-group").remove(), e.style("display", null).attr({ "data-unformatted": n, "data-math": "N" });
+          function s() {
+            a.empty() || (o = e.attr("class") + "-math", a.select("svg." + o).remove()), e.text("").style("white-space", "pre");
+            var l = jat(e.node(), n);
+            l && e.style("pointer-events", "all"), b0.positionText(e), r && r.call(e);
+          }
+          return i ? (t && t._promises || []).push(new Promise(function(l) {
+            e.style("display", "none");
+            var u = parseInt(e.node().style.fontSize, 10), c = { fontSize: u };
+            zat(i[2], c, function(f, h, d) {
+              a.selectAll("svg." + o).remove(), a.selectAll("g." + o + "-group").remove();
+              var v = f && f.select("svg");
+              if (!v || !v.node()) {
+                s(), l();
+                return;
+              }
+              var _ = a.append("g").classed(o + "-group", true).attr({ "pointer-events": "none", "data-unformatted": n, "data-math": "Y" });
+              _.node().appendChild(v.node()), h && h.node() && v.node().insertBefore(h.node().cloneNode(true), v.node().firstChild);
+              var b = d.width, p = d.height;
+              v.attr({ class: o, height: p, preserveAspectRatio: "xMinYMin meet" }).style({ overflow: "visible", "pointer-events": "none" });
+              var k = e.node().style.fill || "black", E = v.select("g");
+              E.attr({ fill: k, stroke: k });
+              var T = E.node().getBoundingClientRect(), L = T.width, x = T.height;
+              (L > b || x > p) && (v.style("overflow", "hidden"), T = v.node().getBoundingClientRect(), L = T.width, x = T.height);
+              var C = +e.attr("x"), M = +e.attr("y"), g = u || e.node().getBoundingClientRect().height, P = -g / 4;
+              if (o[0] === "y") _.attr({ transform: "rotate(" + [-90, C, M] + ")" + Lat(-L / 2, P - x / 2) });
+              else if (o[0] === "l") M = P - x / 2;
+              else if (o[0] === "a" && o.indexOf("atitle") !== 0) C = 0, M = P;
+              else {
+                var A = e.attr("text-anchor");
+                C = C - L * (A === "middle" ? 0.5 : A === "end" ? 1 : 0), M = M + P - x / 2;
+              }
+              v.attr({ x: C, y: M }), r && r.call(e, _), l(_);
+            });
+          })) : s(), e;
+        };
+        var Rat = /(<|&lt;|&#60;)/g, Dat = /(>|&gt;|&#62;)/g;
+        function Fat(e) {
+          return e.replace(Rat, "\\lt ").replace(Dat, "\\gt ");
+        }
+        var rae = [["$", "$"], ["\\(", "\\)"]];
+        function zat(e, t, r) {
+          var n = parseInt((MathJax.version || "").split(".")[0]);
+          if (n !== 2 && n !== 3) {
+            Ly.warn("No MathJax version:", MathJax.version);
+            return;
+          }
+          var i, a, o, s, l = function() {
+            return a = Ly.extendDeepAll({}, MathJax.Hub.config), o = MathJax.Hub.processSectionDelay, MathJax.Hub.processSectionDelay !== void 0 && (MathJax.Hub.processSectionDelay = 0), MathJax.Hub.Config({ messageStyle: "none", tex2jax: { inlineMath: rae }, displayAlign: "left" });
+          }, u = function() {
+            a = Ly.extendDeepAll({}, MathJax.config), MathJax.config.tex || (MathJax.config.tex = {}), MathJax.config.tex.inlineMath = rae;
+          }, c = function() {
+            if (i = MathJax.Hub.config.menuSettings.renderer, i !== "SVG") return MathJax.Hub.setRenderer("SVG");
+          }, f = function() {
+            i = MathJax.config.startup.output, i !== "svg" && (MathJax.config.startup.output = "svg");
+          }, h = function() {
+            var k = "math-output-" + Ly.randstr({}, 64);
+            s = Fh.select("body").append("div").attr({ id: k }).style({ visibility: "hidden", position: "absolute", "font-size": t.fontSize + "px" }).text(Fat(e));
+            var E = s.node();
+            return n === 2 ? MathJax.Hub.Typeset(E) : MathJax.typeset([E]);
+          }, d = function() {
+            var k = s.select(n === 2 ? ".MathJax_SVG" : ".MathJax"), E = !k.empty() && s.select("svg").node();
+            if (!E) Ly.log("There was an error in the tex syntax.", e), r();
+            else {
+              var T = E.getBoundingClientRect(), L;
+              n === 2 ? L = Fh.select("body").select("#MathJax_SVG_glyphs") : L = k.select("defs"), r(k, L, T);
+            }
+            s.remove();
+          }, v = function() {
+            if (i !== "SVG") return MathJax.Hub.setRenderer(i);
+          }, _ = function() {
+            i !== "svg" && (MathJax.config.startup.output = i);
+          }, b = function() {
+            return o !== void 0 && (MathJax.Hub.processSectionDelay = o), MathJax.Hub.Config(a);
+          }, p = function() {
+            MathJax.config = a;
+          };
+          n === 2 ? MathJax.Hub.Queue(l, c, h, d, v, b) : n === 3 && (u(), f(), MathJax.startup.defaultReady(), MathJax.startup.promise.then(function() {
+            h(), d(), _(), p();
+          }));
+        }
+        var oae = { sup: "font-size:70%", sub: "font-size:70%", s: "text-decoration:line-through", u: "text-decoration:underline", b: "font-weight:bold", i: "font-style:italic", a: "cursor:pointer", span: "", em: "font-style:italic;font-weight:bold" }, Oat = { sub: "0.3em", sup: "-0.6em" }, qat = { sub: "-0.21em", sup: "0.42em" }, iae = "​", nae = ["http:", "https:", "mailto:", "", void 0, ":"], sae = b0.NEWLINES = /(\r\n?|\n)/g, bq = /(<[^<>]*>)/, wq = /<(\/?)([^ >]*)(\s+(.*))?>/i, Bat = /<br(\s+.*)?>/i;
+        b0.BR_TAG_ALL = /<br(\s+.*)?>/gi;
+        var lae = /(^|[\s"'])style\s*=\s*("([^"]*);?"|'([^']*);?')/i, uae = /(^|[\s"'])href\s*=\s*("([^"]*)"|'([^']*)')/i, cae = /(^|[\s"'])target\s*=\s*("([^"\s]*)"|'([^'\s]*)')/i, Nat = /(^|[\s"'])popup\s*=\s*("([\w=,]*)"|'([\w=,]*)')/i;
+        function Cb(e, t) {
+          if (!e) return null;
+          var r = e.match(t), n = r && (r[3] || r[4]);
+          return n && oL(n);
+        }
+        var Uat = /(^|;)\s*color:/;
+        b0.plainText = function(e, t) {
+          t = t || {};
+          for (var r = t.len !== void 0 && t.len !== -1 ? t.len : 1 / 0, n = t.allowedTags !== void 0 ? t.allowedTags : ["br"], i = "...", a = i.length, o = e.split(bq), s = [], l = "", u = 0, c = 0; c < o.length; c++) {
+            var f = o[c], h = f.match(wq), d = h && h[2].toLowerCase();
+            if (d) n.indexOf(d) !== -1 && (s.push(f), l = d);
+            else {
+              var v = f.length;
+              if (u + v < r) s.push(f), u += v;
+              else if (u < r) {
+                var _ = r - u;
+                l && (l !== "br" || _ <= a || v <= a) && s.pop(), r > a ? s.push(f.slice(0, Math.max(0, _ - a)) + i) : s.push(f.slice(0, _));
+                break;
+              }
+              l = "";
+            }
+          }
+          return s.join("");
+        };
+        var Vat = { mu: "μ", amp: "&", lt: "<", gt: ">", nbsp: " ", times: "×", plusmn: "±", deg: "°" }, Gat = /&(#\d+|#x[\da-fA-F]+|[a-z]+);/g;
+        function oL(e) {
+          return e.replace(Gat, function(t, r) {
+            var n;
+            return r.charAt(0) === "#" ? n = Hat(r.charAt(1) === "x" ? parseInt(r.slice(2), 16) : parseInt(r.slice(1), 10)) : n = Vat[r], n || t;
+          });
+        }
+        b0.convertEntities = oL;
+        function Hat(e) {
+          if (!(e > 1114111)) {
+            var t = String.fromCodePoint;
+            if (t) return t(e);
+            var r = String.fromCharCode;
+            return e <= 65535 ? r(e) : r((e >> 10) + 55232, e % 1024 + 56320);
+          }
+        }
+        function jat(e, t) {
+          t = t.replace(sae, " ");
+          var r = false, n = [], i, a = -1;
+          function o() {
+            a++;
+            var x = document.createElementNS(_q.svg, "tspan");
+            Fh.select(x).attr({ class: "line", dy: a * Pat + "em" }), e.appendChild(x), i = x;
+            var C = n;
+            if (n = [{ node: x }], C.length > 1) for (var M = 1; M < C.length; M++) s(C[M]);
+          }
+          function s(x) {
+            var C = x.type, M = {}, g;
+            if (C === "a") {
+              g = "a";
+              var P = x.target, A = x.href, z = x.popup;
+              A && (M = { "xlink:xlink:show": P === "_blank" || P.charAt(0) !== "_" ? "new" : "replace", target: P, "xlink:xlink:href": A }, z && (M.onclick = 'window.open(this.href.baseVal,this.target.baseVal,"' + z + '");return false;'));
+            } else g = "tspan";
+            x.style && (M.style = x.style);
+            var O = document.createElementNS(_q.svg, g);
+            if (C === "sup" || C === "sub") {
+              l(i, iae), i.appendChild(O);
+              var U = document.createElementNS(_q.svg, "tspan");
+              l(U, iae), Fh.select(U).attr("dy", qat[C]), M.dy = Oat[C], i.appendChild(O), i.appendChild(U);
+            } else i.appendChild(O);
+            Fh.select(O).attr(M), i = x.node = O, n.push(x);
+          }
+          function l(x, C) {
+            x.appendChild(document.createTextNode(C));
+          }
+          function u(x) {
+            if (n.length === 1) {
+              Ly.log("Ignoring unexpected end tag </" + x + ">.", t);
+              return;
+            }
+            var C = n.pop();
+            x !== C.type && Ly.log("Start tag <" + C.type + "> doesnt match end tag <" + x + ">. Pretending it did match.", t), i = n[n.length - 1].node;
+          }
+          var c = Bat.test(t);
+          c ? o() : (i = e, n = [{ node: e }]);
+          for (var f = t.split(bq), h = 0; h < f.length; h++) {
+            var d = f[h], v = d.match(wq), _ = v && v[2].toLowerCase(), b = oae[_];
+            if (_ === "br") o();
+            else if (b === void 0) l(i, oL(d));
+            else if (v[1]) u(_);
+            else {
+              var p = v[4], k = { type: _ }, E = Cb(p, lae);
+              if (E ? (E = E.replace(Uat, "$1 fill:"), b && (E += ";" + b)) : b && (E = b), E && (k.style = E), _ === "a") {
+                r = true;
+                var T = Cb(p, uae);
+                if (T) {
+                  var L = fae(T);
+                  L && (k.href = L, k.target = Cb(p, cae) || "_blank", k.popup = Cb(p, Nat));
+                }
+              }
+              s(k);
+            }
+          }
+          return r;
+        }
+        function fae(e) {
+          var t = encodeURI(decodeURI(e)), r = document.createElement("a"), n = document.createElement("a");
+          r.href = e, n.href = t;
+          var i = r.protocol, a = n.protocol;
+          return nae.indexOf(i) !== -1 && nae.indexOf(a) !== -1 ? t : "";
+        }
+        b0.sanitizeHTML = function(t) {
+          t = t.replace(sae, " ");
+          for (var r = document.createElement("p"), n = r, i = [], a = t.split(bq), o = 0; o < a.length; o++) {
+            var s = a[o], l = s.match(wq), u = l && l[2].toLowerCase();
+            if (u in oae) if (l[1]) i.length && (n = i.pop());
+            else {
+              var c = l[4], f = Cb(c, lae), h = f ? { style: f } : {};
+              if (u === "a") {
+                var d = Cb(c, uae);
+                if (d) {
+                  var v = fae(d);
+                  if (v) {
+                    h.href = v;
+                    var _ = Cb(c, cae);
+                    _ && (h.target = _);
+                  }
+                }
+              }
+              var b = document.createElement(u);
+              n.appendChild(b), Fh.select(b).attr(h), n = b, i.push(b);
+            }
+            else n.appendChild(document.createTextNode(oL(s)));
+          }
+          var p = "innerHTML";
+          return r[p];
+        };
+        b0.lineCount = function(t) {
+          return t.selectAll("tspan.line").size() || 1;
+        };
+        b0.positionText = function(t, r, n) {
+          return t.each(function() {
+            var i = Fh.select(this);
+            function a(l, u) {
+              return u === void 0 ? (u = i.attr(l), u === null && (i.attr(l, 0), u = 0)) : i.attr(l, u), u;
+            }
+            var o = a("x", r), s = a("y", n);
+            this.nodeName === "text" && i.selectAll("tspan.line").attr({ x: o, y: s });
+          });
+        };
+        function aae(e, t, r) {
+          var n = r.horizontalAlign, i = r.verticalAlign || "top", a = e.node().getBoundingClientRect(), o = t.node().getBoundingClientRect(), s, l, u;
+          return i === "bottom" ? l = function() {
+            return a.bottom - s.height;
+          } : i === "middle" ? l = function() {
+            return a.top + (a.height - s.height) / 2;
+          } : l = function() {
+            return a.top;
+          }, n === "right" ? u = function() {
+            return a.right - s.width;
+          } : n === "center" ? u = function() {
+            return a.left + (a.width - s.width) / 2;
+          } : u = function() {
+            return a.left;
+          }, function() {
+            s = this.node().getBoundingClientRect();
+            var c = u() - o.left, f = l() - o.top, h = r.gd || {};
+            if (r.gd) {
+              h._fullLayout._calcInverseTransform(h);
+              var d = Ly.apply3DTransform(h._fullLayout._invTransform)(c, f);
+              c = d[0], f = d[1];
+            }
+            return this.style({ top: f + "px", left: c + "px", "z-index": 1e3 }), this;
+          };
+        }
+        var xq = "1px ";
+        b0.makeTextShadow = function(e) {
+          var t = xq, r = xq, n = xq;
+          return t + r + n + e + ", -" + t + "-" + r + n + e + ", " + t + "-" + r + n + e + ", -" + t + r + n + e;
+        };
+        b0.makeEditable = function(e, t) {
+          var r = t.gd, n = t.delegate, i = Fh.dispatch("edit", "input", "cancel"), a = n || e;
+          if (e.style({ "pointer-events": n ? "none" : "all" }), e.size() !== 1) throw new Error("boo");
+          function o() {
+            l(), e.style({ opacity: 0 });
+            var u = a.attr("class"), c;
+            u ? c = "." + u.split(" ")[0] + "-math-group" : c = "[class*=-math-group]", c && Fh.select(e.node().parentNode).select(c).style({ opacity: 0 });
+          }
+          function s(u) {
+            var c = u.node(), f = document.createRange();
+            f.selectNodeContents(c);
+            var h = window.getSelection();
+            h.removeAllRanges(), h.addRange(f), c.focus();
+          }
+          function l() {
+            var u = Fh.select(r), c = u.select(".svg-container"), f = c.append("div"), h = e.node().style, d = parseFloat(h.fontSize || 12), v = t.text;
+            v === void 0 && (v = e.attr("data-unformatted")), f.classed("plugin-editable editable", true).style({ position: "absolute", "font-family": h.fontFamily || "Arial", "font-size": d, color: t.fill || h.fill || "black", opacity: 1, "background-color": t.background || "transparent", outline: "#ffffff33 1px solid", margin: [-d / 8 + 1, 0, 0, -1].join("px ") + "px", padding: "0", "box-sizing": "border-box" }).attr({ contenteditable: true }).text(v).call(aae(e, c, t)).on("blur", function() {
+              r._editing = false, e.text(this.textContent).style({ opacity: 1 });
+              var _ = Fh.select(this).attr("class"), b;
+              _ ? b = "." + _.split(" ")[0] + "-math-group" : b = "[class*=-math-group]", b && Fh.select(e.node().parentNode).select(b).style({ opacity: 0 });
+              var p = this.textContent;
+              Fh.select(this).transition().duration(0).remove(), Fh.select(document).on("mouseup", null), i.edit.call(e, p);
+            }).on("focus", function() {
+              var _ = this;
+              r._editing = true, Fh.select(document).on("mouseup", function() {
+                if (Fh.event.target === _) return false;
+                document.activeElement === f.node() && f.node().blur();
+              });
+            }).on("keyup", function() {
+              Fh.event.which === 27 ? (r._editing = false, e.style({ opacity: 1 }), Fh.select(this).style({ opacity: 0 }).on("blur", function() {
+                return false;
+              }).transition().remove(), i.cancel.call(e, this.textContent)) : (i.input.call(e, this.textContent), Fh.select(this).call(aae(e, c, t)));
+            }).on("keydown", function() {
+              Fh.event.which === 13 && this.blur();
+            }).call(s);
+          }
+          return t.immediate ? o() : a.on("click", o), Fh.rebind(e, i, "on");
+        };
+      });
+      var pv = ye((Anr, _ae) => {
+        var Wat = Oa(), lL = fd(), iM = Eo(), sL = Dr(), hae = ka(), Xat = mb().isValid;
+        function Zat(e, t, r) {
+          var n = t ? sL.nestedProperty(e, t).get() || {} : e, i = n[r || "color"];
+          i && i._inputArray && (i = i._inputArray);
+          var a = false;
+          if (sL.isArrayOrTypedArray(i)) {
+            for (var o = 0; o < i.length; o++) if (iM(i[o])) {
+              a = true;
+              break;
+            }
+          }
+          return sL.isPlainObject(n) && (a || n.showscale === true || iM(n.cmin) && iM(n.cmax) || Xat(n.colorscale) || sL.isPlainObject(n.colorbar));
+        }
+        var dae = ["showscale", "autocolorscale", "colorscale", "reversescale", "colorbar"], rM = ["min", "max", "mid", "auto"];
+        function pae(e) {
+          var t = e._colorAx, r = t || e, n = {}, i, a, o;
+          for (a = 0; a < dae.length; a++) o = dae[a], n[o] = r[o];
+          if (t) for (i = "c", a = 0; a < rM.length; a++) o = rM[a], n[o] = r["c" + o];
+          else {
+            var s;
+            for (a = 0; a < rM.length; a++) {
+              if (o = rM[a], s = "c" + o, s in r) {
+                n[o] = r[s];
+                continue;
+              }
+              s = "z" + o, s in r && (n[o] = r[s]);
+            }
+            i = s.charAt(0);
+          }
+          return n._sync = function(l, u) {
+            var c = rM.indexOf(l) !== -1 ? i + l : l;
+            r[c] = r["_" + c] = u;
+          }, n;
+        }
+        function gae(e) {
+          for (var t = pae(e), r = t.min, n = t.max, i = t.reversescale ? mae(t.colorscale) : t.colorscale, a = i.length, o = new Array(a), s = new Array(a), l = 0; l < a; l++) {
+            var u = i[l];
+            o[l] = r + u[0] * (n - r), s[l] = u[1];
+          }
+          return { domain: o, range: s };
+        }
+        function mae(e) {
+          for (var t = e.length, r = new Array(t), n = t - 1, i = 0; n >= 0; n--, i++) {
+            var a = e[n];
+            r[i] = [1 - a[0], a[1]];
+          }
+          return r;
+        }
+        function yae(e, t) {
+          t = t || {};
+          for (var r = e.domain, n = e.range, i = n.length, a = new Array(i), o = 0; o < i; o++) {
+            var s = lL(n[o]).toRgb();
+            a[o] = [s.r, s.g, s.b, s.a];
+          }
+          var l = Wat.scale.linear().domain(r).range(a).clamp(true), u = t.noNumericCheck, c = t.returnArray, f;
+          return u && c ? f = l : u ? f = function(h) {
+            return vae(l(h));
+          } : c ? f = function(h) {
+            return iM(h) ? l(h) : lL(h).isValid() ? h : hae.defaultLine;
+          } : f = function(h) {
+            return iM(h) ? vae(l(h)) : lL(h).isValid() ? h : hae.defaultLine;
+          }, f.domain = l.domain, f.range = function() {
+            return n;
+          }, f;
+        }
+        function Yat(e, t) {
+          return yae(gae(e), t);
+        }
+        function vae(e) {
+          var t = { r: e[0], g: e[1], b: e[2], a: e[3] };
+          return lL(t).toRgbString();
+        }
+        _ae.exports = { hasColorscale: Zat, extractOpts: pae, extractScale: gae, flipScale: mae, makeColorScaleFunc: yae, makeColorScaleFuncFromTrace: Yat };
+      });
+      var df = ye((Snr, wae) => {
+        var xae = HO(), Kat = xae.FORMAT_LINK, Jat = xae.DATE_FORMAT_LINK;
+        function $at(e, t) {
+          return { valType: "string", dflt: "", editType: "none", description: (t ? Tq : bae)("hover text", e) + ["By default the values are formatted using " + (t ? "generic number format" : "`" + e + "axis.hoverformat`") + "."].join(" ") };
+        }
+        function Tq(e, t) {
+          return ["Sets the " + e + " formatting rule" + (t ? "for `" + t + "` " : ""), "using d3 formatting mini-languages", "which are very similar to those in Python. For numbers, see: " + Kat + "."].join(" ");
+        }
+        function bae(e, t) {
+          return Tq(e, t) + [" And for dates see: " + Jat + ".", "We add two items to d3's date formatter:", "*%h* for half of the year as a decimal number as well as", "*%{n}f* for fractional seconds", "with n digits. For example, *2016-10-13 09:15:23.456* with tickformat", "*%H~%M~%S.%2f* would display *09~15~23.46*"].join(" ");
+        }
+        wae.exports = { axisHoverFormat: $at, descriptionOnlyNumbers: Tq, descriptionWithDates: bae };
+      });
+      var Rd = ye((Enr, Bae) => {
+        var Tae = ec(), D3 = Ih(), qae = Pd().dash, Sq = Ao().extendFlat, Aae = vl().templatedArray;
+        Ll().templateFormatStringDescription;
+        var Sae = df().descriptionWithDates, Qat = fs().ONEDAY, mm = Rh(), eot = mm.HOUR_PATTERN, tot = mm.WEEKDAY_PATTERN, Aq = { valType: "enumerated", values: ["auto", "linear", "array"], editType: "ticks", impliedEdits: { tick0: void 0, dtick: void 0 } }, rot = Sq({}, Aq, { values: Aq.values.slice().concat(["sync"]) });
+        function Mae(e) {
+          return { valType: "integer", min: 0, dflt: e ? 5 : 0, editType: "ticks" };
+        }
+        var Eae = { valType: "any", editType: "ticks", impliedEdits: { tickmode: "linear" } }, kae = { valType: "any", editType: "ticks", impliedEdits: { tickmode: "linear" } }, Cae = { valType: "data_array", editType: "ticks" }, Lae = { valType: "enumerated", values: ["outside", "inside", ""], editType: "ticks" };
+        function Pae(e) {
+          var t = { valType: "number", min: 0, editType: "ticks" };
+          return e || (t.dflt = 5), t;
+        }
+        function Iae(e) {
+          var t = { valType: "number", min: 0, editType: "ticks" };
+          return e || (t.dflt = 1), t;
+        }
+        var Rae = { valType: "color", dflt: D3.defaultLine, editType: "ticks" }, Dae = { valType: "color", dflt: D3.lightLine, editType: "ticks" };
+        function Fae(e) {
+          var t = { valType: "number", min: 0, editType: "ticks" };
+          return e || (t.dflt = 1), t;
+        }
+        var zae = Sq({}, qae, { editType: "ticks" }), Oae = { valType: "boolean", editType: "ticks" };
+        Bae.exports = { visible: { valType: "boolean", editType: "plot" }, color: { valType: "color", dflt: D3.defaultLine, editType: "ticks" }, title: { text: { valType: "string", editType: "ticks" }, font: Tae({ editType: "ticks" }), standoff: { valType: "number", min: 0, editType: "ticks" }, editType: "ticks" }, type: { valType: "enumerated", values: ["-", "linear", "log", "date", "category", "multicategory"], dflt: "-", editType: "calc", _noTemplating: true }, autotypenumbers: { valType: "enumerated", values: ["convert types", "strict"], dflt: "convert types", editType: "calc" }, autorange: { valType: "enumerated", values: [true, false, "reversed", "min reversed", "max reversed", "min", "max"], dflt: true, editType: "axrange", impliedEdits: { "range[0]": void 0, "range[1]": void 0 } }, autorangeoptions: { minallowed: { valType: "any", editType: "plot", impliedEdits: { "range[0]": void 0, "range[1]": void 0 } }, maxallowed: { valType: "any", editType: "plot", impliedEdits: { "range[0]": void 0, "range[1]": void 0 } }, clipmin: { valType: "any", editType: "plot", impliedEdits: { "range[0]": void 0, "range[1]": void 0 } }, clipmax: { valType: "any", editType: "plot", impliedEdits: { "range[0]": void 0, "range[1]": void 0 } }, include: { valType: "any", arrayOk: true, editType: "plot", impliedEdits: { "range[0]": void 0, "range[1]": void 0 } }, editType: "plot" }, rangemode: { valType: "enumerated", values: ["normal", "tozero", "nonnegative"], dflt: "normal", editType: "plot" }, range: { valType: "info_array", items: [{ valType: "any", editType: "axrange", impliedEdits: { "^autorange": false }, anim: true }, { valType: "any", editType: "axrange", impliedEdits: { "^autorange": false }, anim: true }], editType: "axrange", impliedEdits: { autorange: false }, anim: true }, minallowed: { valType: "any", editType: "plot", impliedEdits: { "^autorange": false } }, maxallowed: { valType: "any", editType: "plot", impliedEdits: { "^autorange": false } }, fixedrange: { valType: "boolean", dflt: false, editType: "calc" }, modebardisable: { valType: "flaglist", flags: ["autoscale", "zoominout"], extras: ["none"], dflt: "none", editType: "modebar" }, insiderange: { valType: "info_array", items: [{ valType: "any", editType: "plot" }, { valType: "any", editType: "plot" }], editType: "plot" }, scaleanchor: { valType: "enumerated", values: [mm.idRegex.x.toString(), mm.idRegex.y.toString(), false], editType: "plot" }, scaleratio: { valType: "number", min: 0, dflt: 1, editType: "plot" }, constrain: { valType: "enumerated", values: ["range", "domain"], editType: "plot" }, constraintoward: { valType: "enumerated", values: ["left", "center", "right", "top", "middle", "bottom"], editType: "plot" }, matches: { valType: "enumerated", values: [mm.idRegex.x.toString(), mm.idRegex.y.toString()], editType: "calc" }, rangebreaks: Aae("rangebreak", { enabled: { valType: "boolean", dflt: true, editType: "calc" }, bounds: { valType: "info_array", items: [{ valType: "any", editType: "calc" }, { valType: "any", editType: "calc" }], editType: "calc" }, pattern: { valType: "enumerated", values: [tot, eot, ""], editType: "calc" }, values: { valType: "info_array", freeLength: true, editType: "calc", items: { valType: "any", editType: "calc" } }, dvalue: { valType: "number", editType: "calc", min: 0, dflt: Qat }, editType: "calc" }), tickmode: rot, nticks: Mae(), tick0: Eae, dtick: kae, ticklabelstep: { valType: "integer", min: 1, dflt: 1, editType: "ticks" }, tickvals: Cae, ticktext: { valType: "data_array", editType: "ticks" }, ticks: Lae, tickson: { valType: "enumerated", values: ["labels", "boundaries"], dflt: "labels", editType: "ticks" }, ticklabelmode: { valType: "enumerated", values: ["instant", "period"], dflt: "instant", editType: "ticks" }, ticklabelposition: { valType: "enumerated", values: ["outside", "inside", "outside top", "inside top", "outside left", "inside left", "outside right", "inside right", "outside bottom", "inside bottom"], dflt: "outside", editType: "calc" }, ticklabeloverflow: { valType: "enumerated", values: ["allow", "hide past div", "hide past domain"], editType: "calc" }, ticklabelshift: { valType: "integer", dflt: 0, editType: "ticks" }, ticklabelstandoff: { valType: "integer", dflt: 0, editType: "ticks" }, ticklabelindex: { valType: "integer", arrayOk: true, editType: "calc" }, mirror: { valType: "enumerated", values: [true, "ticks", false, "all", "allticks"], dflt: false, editType: "ticks+layoutstyle" }, ticklen: Pae(), tickwidth: Iae(), tickcolor: Rae, showticklabels: { valType: "boolean", dflt: true, editType: "ticks" }, labelalias: { valType: "any", dflt: false, editType: "ticks" }, automargin: { valType: "flaglist", flags: ["height", "width", "left", "right", "top", "bottom"], extras: [true, false], dflt: false, editType: "ticks" }, showspikes: { valType: "boolean", dflt: false, editType: "modebar" }, spikecolor: { valType: "color", dflt: null, editType: "none" }, spikethickness: { valType: "number", dflt: 3, editType: "none" }, spikedash: Sq({}, qae, { dflt: "dash", editType: "none" }), spikemode: { valType: "flaglist", flags: ["toaxis", "across", "marker"], dflt: "toaxis", editType: "none" }, spikesnap: { valType: "enumerated", values: ["data", "cursor", "hovered data"], dflt: "hovered data", editType: "none" }, tickfont: Tae({ editType: "ticks" }), tickangle: { valType: "angle", dflt: "auto", editType: "ticks" }, autotickangles: { valType: "info_array", freeLength: true, items: { valType: "angle" }, dflt: [0, 30, 90], editType: "ticks" }, tickprefix: { valType: "string", dflt: "", editType: "ticks" }, showtickprefix: { valType: "enumerated", values: ["all", "first", "last", "none"], dflt: "all", editType: "ticks" }, ticksuffix: { valType: "string", dflt: "", editType: "ticks" }, showticksuffix: { valType: "enumerated", values: ["all", "first", "last", "none"], dflt: "all", editType: "ticks" }, showexponent: { valType: "enumerated", values: ["all", "first", "last", "none"], dflt: "all", editType: "ticks" }, exponentformat: { valType: "enumerated", values: ["none", "e", "E", "power", "SI", "B", "SI extended"], dflt: "B", editType: "ticks" }, minexponent: { valType: "number", dflt: 3, min: 0, editType: "ticks" }, separatethousands: { valType: "boolean", dflt: false, editType: "ticks" }, tickformat: { valType: "string", dflt: "", editType: "ticks", description: Sae("tick label") }, tickformatstops: Aae("tickformatstop", { enabled: { valType: "boolean", dflt: true, editType: "ticks" }, dtickrange: { valType: "info_array", items: [{ valType: "any", editType: "ticks" }, { valType: "any", editType: "ticks" }], editType: "ticks" }, value: { valType: "string", dflt: "", editType: "ticks" }, editType: "ticks" }), hoverformat: { valType: "string", dflt: "", editType: "none", description: Sae("hover text") }, unifiedhovertitle: { text: { valType: "string", dflt: "", editType: "none" }, editType: "none" }, showline: { valType: "boolean", dflt: false, editType: "ticks+layoutstyle" }, linecolor: { valType: "color", dflt: D3.defaultLine, editType: "layoutstyle" }, linewidth: { valType: "number", min: 0, dflt: 1, editType: "ticks+layoutstyle" }, showgrid: Oae, gridcolor: Dae, gridwidth: Fae(), griddash: zae, zeroline: { valType: "boolean", editType: "ticks" }, zerolinecolor: { valType: "color", dflt: D3.defaultLine, editType: "ticks" }, zerolinelayer: { valType: "enumerated", values: ["above traces", "below traces"], dflt: "below traces", editType: "plot" }, zerolinewidth: { valType: "number", dflt: 1, editType: "ticks" }, showdividers: { valType: "boolean", dflt: true, editType: "ticks" }, dividercolor: { valType: "color", dflt: D3.defaultLine, editType: "ticks" }, dividerwidth: { valType: "number", dflt: 1, editType: "ticks" }, anchor: { valType: "enumerated", values: ["free", mm.idRegex.x.toString(), mm.idRegex.y.toString()], editType: "plot" }, side: { valType: "enumerated", values: ["top", "bottom", "left", "right"], editType: "plot" }, overlaying: { valType: "enumerated", values: ["free", mm.idRegex.x.toString(), mm.idRegex.y.toString()], editType: "plot" }, minor: { tickmode: Aq, nticks: Mae("minor"), tick0: Eae, dtick: kae, tickvals: Cae, ticks: Lae, ticklen: Pae("minor"), tickwidth: Iae("minor"), tickcolor: Rae, gridcolor: Dae, gridwidth: Fae("minor"), griddash: zae, showgrid: Oae, editType: "ticks" }, minorloglabels: { valType: "enumerated", values: ["small digits", "complete", "none"], dflt: "small digits", editType: "calc" }, layer: { valType: "enumerated", values: ["above traces", "below traces"], dflt: "above traces", editType: "plot" }, domain: { valType: "info_array", items: [{ valType: "number", min: 0, max: 1, editType: "plot" }, { valType: "number", min: 0, max: 1, editType: "plot" }], dflt: [0, 1], editType: "plot" }, position: { valType: "number", min: 0, max: 1, dflt: 0, editType: "plot" }, autoshift: { valType: "boolean", dflt: false, editType: "plot" }, shift: { valType: "number", editType: "plot" }, categoryorder: { valType: "enumerated", values: ["trace", "category ascending", "category descending", "array", "total ascending", "total descending", "min ascending", "min descending", "max ascending", "max descending", "sum ascending", "sum descending", "mean ascending", "mean descending", "geometric mean ascending", "geometric mean descending", "median ascending", "median descending"], dflt: "trace", editType: "calc" }, categoryarray: { valType: "data_array", editType: "calc" }, uirevision: { valType: "any", editType: "none" }, editType: "calc" };
+      });
+      var uL = ye((knr, Vae) => {
+        var $c = Rd(), Nae = ec(), Uae = Ao().extendFlat, iot = mc().overrideAll;
+        Vae.exports = iot({ orientation: { valType: "enumerated", values: ["h", "v"], dflt: "v" }, thicknessmode: { valType: "enumerated", values: ["fraction", "pixels"], dflt: "pixels" }, thickness: { valType: "number", min: 0, dflt: 30 }, lenmode: { valType: "enumerated", values: ["fraction", "pixels"], dflt: "fraction" }, len: { valType: "number", min: 0, dflt: 1 }, x: { valType: "number" }, xref: { valType: "enumerated", dflt: "paper", values: ["container", "paper"], editType: "layoutstyle" }, xanchor: { valType: "enumerated", values: ["left", "center", "right"] }, xpad: { valType: "number", min: 0, dflt: 10 }, y: { valType: "number" }, yref: { valType: "enumerated", dflt: "paper", values: ["container", "paper"], editType: "layoutstyle" }, yanchor: { valType: "enumerated", values: ["top", "middle", "bottom"] }, ypad: { valType: "number", min: 0, dflt: 10 }, outlinecolor: $c.linecolor, outlinewidth: $c.linewidth, bordercolor: $c.linecolor, borderwidth: { valType: "number", min: 0, dflt: 0 }, bgcolor: { valType: "color", dflt: "rgba(0,0,0,0)" }, tickmode: $c.minor.tickmode, nticks: $c.nticks, tick0: $c.tick0, dtick: $c.dtick, tickvals: $c.tickvals, ticktext: $c.ticktext, ticks: Uae({}, $c.ticks, { dflt: "" }), ticklabeloverflow: Uae({}, $c.ticklabeloverflow, {}), ticklabelposition: { valType: "enumerated", values: ["outside", "inside", "outside top", "inside top", "outside left", "inside left", "outside right", "inside right", "outside bottom", "inside bottom"], dflt: "outside" }, ticklen: $c.ticklen, tickwidth: $c.tickwidth, tickcolor: $c.tickcolor, ticklabelstep: $c.ticklabelstep, showticklabels: $c.showticklabels, labelalias: $c.labelalias, tickfont: Nae({}), tickangle: $c.tickangle, tickformat: $c.tickformat, tickformatstops: $c.tickformatstops, tickprefix: $c.tickprefix, showtickprefix: $c.showtickprefix, ticksuffix: $c.ticksuffix, showticksuffix: $c.showticksuffix, separatethousands: $c.separatethousands, exponentformat: $c.exponentformat, minexponent: $c.minexponent, showexponent: $c.showexponent, title: { text: { valType: "string" }, font: Nae({}), side: { valType: "enumerated", values: ["right", "top", "bottom"] } } }, "colorbars", "from-root");
+      });
+      var Tu = ye((Lnr, Hae) => {
+        var not = uL(), aot = p3().counter, oot = t_(), Gae = mb().scales;
+        oot(Gae);
+        function cL(e) {
+          return "`" + e + "`";
+        }
+        Hae.exports = function(t, r) {
+          t = t || "", r = r || {};
+          var n = r.cLetter || "c";
+          "onlyIfNumerical" in r ? r.onlyIfNumerical : !!t;
+          var a = "noScale" in r ? r.noScale : t === "marker.line", o = "showScaleDflt" in r ? r.showScaleDflt : n === "z", s = typeof r.colorscaleDflt == "string" ? Gae[r.colorscaleDflt] : null, l = r.editTypeOverride || "", u = t ? t + "." : "", c;
+          "colorAttr" in r ? (c = r.colorAttr, r.colorAttr) : (c = { z: "z", c: "color" }[n], "in " + cL(u + c));
+          var d = n + "auto", v = n + "min", _ = n + "max", b = n + "mid", L = {};
+          L[v] = L[_] = void 0;
+          var x = {};
+          x[d] = false;
+          var C = {};
+          return c === "color" && (C.color = { valType: "color", arrayOk: true, editType: l || "style" }, r.anim && (C.color.anim = true)), C[d] = { valType: "boolean", dflt: true, editType: "calc", impliedEdits: L }, C[v] = { valType: "number", dflt: null, editType: l || "plot", impliedEdits: x }, C[_] = { valType: "number", dflt: null, editType: l || "plot", impliedEdits: x }, C[b] = { valType: "number", dflt: null, editType: "calc", impliedEdits: L }, C.colorscale = { valType: "colorscale", editType: "calc", dflt: s, impliedEdits: { autocolorscale: false } }, C.autocolorscale = { valType: "boolean", dflt: r.autoColorDflt !== false, editType: "calc", impliedEdits: { colorscale: void 0 } }, C.reversescale = { valType: "boolean", dflt: false, editType: "plot" }, a || (C.showscale = { valType: "boolean", dflt: o, editType: "calc" }, C.colorbar = not), r.noColorAxis || (C.coloraxis = { valType: "subplotid", regex: aot("coloraxis"), dflt: null, editType: "calc" }), C;
+        };
+      });
+      var Eq = ye((Pnr, jae) => {
+        var sot = Ao().extendFlat, lot = Tu(), Mq = mb().scales;
+        jae.exports = { editType: "calc", colorscale: { editType: "calc", sequential: { valType: "colorscale", dflt: Mq.Reds, editType: "calc" }, sequentialminus: { valType: "colorscale", dflt: Mq.Blues, editType: "calc" }, diverging: { valType: "colorscale", dflt: Mq.RdBu, editType: "calc" } }, coloraxis: sot({ _isSubplotObj: true, editType: "calc" }, lot("", { colorAttr: "corresponding trace color array(s)", noColorAxis: true, showScaleDflt: true })) };
+      });
+      var kq = ye((Inr, Wae) => {
+        var uot = Dr();
+        Wae.exports = function(t) {
+          return uot.isPlainObject(t.colorbar);
+        };
+      });
+      var Pq = ye((Lq) => {
+        var Cq = Eo(), Xae = Dr(), Zae = fs(), cot = Zae.ONEDAY, fot = Zae.ONEWEEK;
+        Lq.dtick = function(e, t) {
+          var r = t === "log", n = t === "date", i = t === "category", a = n ? cot : 1;
+          if (!e) return a;
+          if (Cq(e)) return e = Number(e), e <= 0 ? a : i ? Math.max(1, Math.round(e)) : n ? Math.max(0.1, e) : e;
+          if (typeof e != "string" || !(n || r)) return a;
+          var o = e.charAt(0), s = e.slice(1);
+          return s = Cq(s) ? Number(s) : 0, s <= 0 || !(n && o === "M" && s === Math.round(s) || r && o === "L" || r && o === "D" && (s === 1 || s === 2)) ? a : e;
+        };
+        Lq.tick0 = function(e, t, r, n) {
+          if (t === "date") return Xae.cleanDate(e, Xae.dateTick0(r, n % fot === 0 ? 1 : 0));
+          if (!(n === "D1" || n === "D2")) return Cq(e) ? Number(e) : 0;
+        };
+      });
+      var Lb = ye((Dnr, Kae) => {
+        var Yae = Pq(), hot = Dr().isArrayOrTypedArray, dot = vv().isTypedArraySpec, vot = vv().decodeTypedArraySpec;
+        Kae.exports = function(t, r, n, i, a) {
+          a || (a = {});
+          var o = a.isMinor, s = o ? t.minor || {} : t, l = o ? r.minor : r, u = o ? "minor." : "";
+          function c(k) {
+            var E = s[k];
+            return dot(E) && (E = vot(E)), E !== void 0 ? E : (l._template || {})[k];
+          }
+          var f = c("tick0"), h = c("dtick"), d = c("tickvals"), v = hot(d) ? "array" : h ? "linear" : "auto", _ = n(u + "tickmode", v);
+          if (_ === "auto" || _ === "sync") n(u + "nticks");
+          else if (_ === "linear") {
+            var b = l.dtick = Yae.dtick(h, i);
+            l.tick0 = Yae.tick0(f, i, r.calendar, b);
+          } else if (i !== "multicategory") {
+            var p = n(u + "tickvals");
+            p === void 0 ? l.tickmode = "auto" : o || n("ticktext");
+          }
+        };
+      });
+      var F3 = ye((Fnr, $ae) => {
+        var Iq = Dr(), Jae = Rd();
+        $ae.exports = function(t, r, n, i) {
+          var a = i.isMinor, o = a ? t.minor || {} : t, s = a ? r.minor : r, l = a ? Jae.minor : Jae, u = a ? "minor." : "", c = Iq.coerce2(o, s, l, "ticklen", a ? (r.ticklen || 5) * 0.6 : void 0), f = Iq.coerce2(o, s, l, "tickwidth", a ? r.tickwidth || 1 : void 0), h = Iq.coerce2(o, s, l, "tickcolor", (a ? r.tickcolor : void 0) || s.color), d = n(u + "ticks", !a && i.outerTicks || c || f || h ? "outside" : "");
+          d || (delete s.ticklen, delete s.tickwidth, delete s.tickcolor);
+        };
+      });
+      var Rq = ye((znr, Qae) => {
+        Qae.exports = function(t) {
+          var r = ["showexponent", "showtickprefix", "showticksuffix"], n = r.filter(function(a) {
+            return t[a] !== void 0;
+          }), i = function(a) {
+            return t[a] === t[n[0]];
+          };
+          if (n.every(i) || n.length === 1) return t[n[0]];
+        };
+      });
+      var Zd = ye((Onr, eoe) => {
+        var fL = Dr(), pot = vl();
+        eoe.exports = function(t, r, n) {
+          var i = n.name, a = n.inclusionAttr || "visible", o = r[i], s = fL.isArrayOrTypedArray(t[i]) ? t[i] : [], l = r[i] = [], u = pot.arrayTemplater(r, i, a), c, f;
+          for (c = 0; c < s.length; c++) {
+            var h = s[c];
+            fL.isPlainObject(h) ? f = u.newItem(h) : (f = u.newItem({}), f[a] = false), f._index = c, f[a] !== false && n.handleItemDefaults(h, f, r, n), l.push(f);
+          }
+          var d = u.defaultItems();
+          for (c = 0; c < d.length; c++) f = d[c], f._index = l.length, n.handleItemDefaults({}, f, r, n, {}), l.push(f);
+          if (fL.isArrayOrTypedArray(o)) {
+            var v = Math.min(o.length, l.length);
+            for (c = 0; c < v; c++) fL.relinkPrivateKeys(l[c], o[c]);
+          }
+          return l;
+        };
+      });
+      var s_ = ye((qnr, roe) => {
+        var Dq = Dr(), got = ka().contrast, toe = Rd(), mot = Rq(), yot = Zd();
+        roe.exports = function(t, r, n, i, a) {
+          a || (a = {});
+          var o = n("labelalias");
+          Dq.isPlainObject(o) || delete r.labelalias;
+          var s = mot(t), l = n("showticklabels");
+          if (l) {
+            a.noTicklabelshift || n("ticklabelshift"), a.noTicklabelstandoff || n("ticklabelstandoff");
+            var u = a.font || {}, c = r.color, f = r.ticklabelposition || "", h = f.indexOf("inside") !== -1 ? got(a.bgColor) : c && c !== toe.color.dflt ? c : u.color;
+            if (Dq.coerceFont(n, "tickfont", u, { overrideDflt: { color: h } }), !a.noTicklabelstep && i !== "multicategory" && i !== "log" && n("ticklabelstep"), !a.noAng) {
+              var d = n("tickangle");
+              !a.noAutotickangles && d === "auto" && n("autotickangles");
+            }
+            if (i !== "category") {
+              var v = n("tickformat");
+              yot(t, r, { name: "tickformatstops", inclusionAttr: "enabled", handleItemDefaults: _ot }), r.tickformatstops.length || delete r.tickformatstops, !a.noExp && !v && i !== "date" && (n("showexponent", s), n("exponentformat"), n("minexponent"), n("separatethousands"));
+            }
+            !a.noMinorloglabels && i === "log" && n("minorloglabels");
+          }
+        };
+        function _ot(e, t) {
+          function r(i, a) {
+            return Dq.coerce(e, t, toe.tickformatstops, i, a);
+          }
+          var n = r("enabled");
+          n && (r("dtickrange"), r("value"));
+        }
+      });
+      var l_ = ye((Bnr, ioe) => {
+        var xot = Rq();
+        ioe.exports = function(t, r, n, i, a) {
+          a || (a = {});
+          var o = a.tickSuffixDflt, s = xot(t), l = n("tickprefix");
+          l && n("showtickprefix", s);
+          var u = n("ticksuffix", o);
+          u && n("showticksuffix", s);
+        };
+      });
+      var Fq = ye((Nnr, noe) => {
+        var u_ = Dr(), bot = vl(), wot = Lb(), Tot = F3(), Aot = s_(), Sot = l_(), Mot = uL();
+        noe.exports = function(t, r, n) {
+          var i = bot.newContainer(r, "colorbar"), a = t.colorbar || {};
+          function o(A, z) {
+            return u_.coerce(a, i, Mot, A, z);
+          }
+          var s = n.margin || { t: 0, b: 0, l: 0, r: 0 }, l = n.width - s.l - s.r, u = n.height - s.t - s.b, c = o("orientation"), f = c === "v", h = o("thicknessmode");
+          o("thickness", h === "fraction" ? 30 / (f ? l : u) : 30);
+          var d = o("lenmode");
+          o("len", d === "fraction" ? 1 : f ? u : l);
+          var v = o("yref"), _ = o("xref"), b = v === "paper", p = _ === "paper", k, E, T, L = "left";
+          f ? (T = "middle", L = p ? "left" : "right", k = p ? 1.02 : 1, E = 0.5) : (T = b ? "bottom" : "top", L = "center", k = 0.5, E = b ? 1.02 : 1), u_.coerce(a, i, { x: { valType: "number", min: p ? -2 : 0, max: p ? 3 : 1, dflt: k } }, "x"), u_.coerce(a, i, { y: { valType: "number", min: b ? -2 : 0, max: b ? 3 : 1, dflt: E } }, "y"), o("xanchor", L), o("xpad"), o("yanchor", T), o("ypad"), u_.noneOrAll(a, i, ["x", "y"]), o("outlinecolor"), o("outlinewidth"), o("bordercolor"), o("borderwidth"), o("bgcolor");
+          var x = u_.coerce(a, i, { ticklabelposition: { valType: "enumerated", dflt: "outside", values: f ? ["outside", "inside", "outside top", "inside top", "outside bottom", "inside bottom"] : ["outside", "inside", "outside left", "inside left", "outside right", "inside right"] } }, "ticklabelposition");
+          o("ticklabeloverflow", x.indexOf("inside") !== -1 ? "hide past domain" : "hide past div"), wot(a, i, o, "linear");
+          var C = n.font, M = { noAutotickangles: true, noTicklabelshift: true, noTicklabelstandoff: true, outerTicks: false, font: C };
+          x.indexOf("inside") !== -1 && (M.bgColor = "black"), Sot(a, i, o, "linear", M), Aot(a, i, o, "linear", M), Tot(a, i, o, "linear", M), o("title.text", n._dfltTitle.colorbar);
+          var g = i.showticklabels ? i.tickfont : C, P = u_.extendFlat({}, C, { family: g.family, size: u_.bigFont(g.size) });
+          u_.coerceFont(o, "title.font", P), o("title.side", f ? "top" : "right");
+        };
+      });
+      var td = ye((Unr, soe) => {
+        var aoe = Eo(), Oq = Dr(), Eot = kq(), kot = Fq(), ooe = mb().isValid, Cot = qa().traceIs;
+        function zq(e, t) {
+          var r = t.slice(0, t.length - 1);
+          return t ? Oq.nestedProperty(e, r).get() || {} : e;
+        }
+        soe.exports = function e(t, r, n, i, a) {
+          var o = a.prefix, s = a.cLetter, l = "_module" in r, u = zq(t, o), c = zq(r, o), f = zq(r._template || {}, o) || {}, h = function() {
+            return delete t.coloraxis, delete r.coloraxis, e(t, r, n, i, a);
+          };
+          if (l) {
+            var d = n._colorAxes || {}, v = i(o + "coloraxis");
+            if (v) {
+              var _ = Cot(r, "contour") && Oq.nestedProperty(r, "contours.coloring").get() || "heatmap", b = d[v];
+              b ? (b[2].push(h), b[0] !== _ && (b[0] = false, Oq.warn(["Ignoring coloraxis:", v, "setting", "as it is linked to incompatible colorscales."].join(" ")))) : d[v] = [_, r, [h]];
+              return;
+            }
+          }
+          var p = u[s + "min"], k = u[s + "max"], E = aoe(p) && aoe(k) && p < k, T = i(o + s + "auto", !E);
+          T ? i(o + s + "mid") : (i(o + s + "min"), i(o + s + "max"));
+          var L = u.colorscale, x = f.colorscale, C;
+          if (L !== void 0 && (C = !ooe(L)), x !== void 0 && (C = !ooe(x)), i(o + "autocolorscale", C), i(o + "colorscale"), i(o + "reversescale"), o !== "marker.line.") {
+            var M;
+            o && l && (M = Eot(u));
+            var g = i(o + "showscale", M);
+            g && (o && f && (c._template = f), kot(u, c, n));
+          }
+        };
+      });
+      var foe = ye((Vnr, coe) => {
+        var loe = Dr(), Lot = vl(), uoe = Eq(), Pot = td();
+        coe.exports = function(t, r) {
+          function n(f, h) {
+            return loe.coerce(t, r, uoe, f, h);
+          }
+          n("colorscale.sequential"), n("colorscale.sequentialminus"), n("colorscale.diverging");
+          var i = r._colorAxes, a, o;
+          function s(f, h) {
+            return loe.coerce(a, o, uoe.coloraxis, f, h);
+          }
+          for (var l in i) {
+            var u = i[l];
+            if (u[0]) a = t[l] || {}, o = Lot.newContainer(r, l, "coloraxis"), o._name = l, Pot(a, o, r, s, { prefix: "", cLetter: "c" });
+            else {
+              for (var c = 0; c < u[2].length; c++) u[2][c]();
+              delete r._colorAxes[l];
+            }
+          }
+        };
+      });
+      var doe = ye((Gnr, hoe) => {
+        var Iot = Dr(), Rot = pv().hasColorscale, Dot = pv().extractOpts;
+        hoe.exports = function(t, r) {
+          function n(c, f) {
+            var h = c["_" + f];
+            h !== void 0 && (c[f] = h);
+          }
+          function i(c, f) {
+            var h = f.container ? Iot.nestedProperty(c, f.container).get() : c;
+            if (h) if (h.coloraxis) h._colorAx = r[h.coloraxis];
+            else {
+              var d = Dot(h), v = d.auto;
+              (v || d.min === void 0) && n(h, f.min), (v || d.max === void 0) && n(h, f.max), d.autocolorscale && n(h, "colorscale");
+            }
+          }
+          for (var a = 0; a < t.length; a++) {
+            var o = t[a], s = o._module.colorbar;
+            if (s) if (Array.isArray(s)) for (var l = 0; l < s.length; l++) i(o, s[l]);
+            else i(o, s);
+            Rot(o, "marker.line") && i(o, { container: "marker.line", min: "cmin", max: "cmax" });
+          }
+          for (var u in r._colorAxes) i(r[u], { min: "cmin", max: "cmax" });
+        };
+      });
+      var gv = ye((Hnr, poe) => {
+        var voe = Eo(), qq = Dr(), Fot = pv().extractOpts;
+        poe.exports = function(t, r, n) {
+          var i = t._fullLayout, a = n.vals, o = n.containerStr, s = o ? qq.nestedProperty(r, o).get() : r, l = Fot(s), u = l.auto !== false, c = l.min, f = l.max, h = l.mid, d = function() {
+            return qq.aggNums(Math.min, null, a);
+          }, v = function() {
+            return qq.aggNums(Math.max, null, a);
+          };
+          if (c === void 0 ? c = d() : u && (s._colorAx && voe(c) ? c = Math.min(c, d()) : c = d()), f === void 0 ? f = v() : u && (s._colorAx && voe(f) ? f = Math.max(f, v()) : f = v()), u && h !== void 0 && (f - h > h - c ? c = h - (f - h) : f - h < h - c && (f = h + (h - c))), c === f && (c -= 0.5, f += 0.5), l._sync("min", c), l._sync("max", f), l.autocolorscale) {
+            var _;
+            c * f < 0 ? _ = i.colorscale.diverging : c >= 0 ? _ = i.colorscale.sequential : _ = i.colorscale.sequentialminus, l._sync("colorscale", _);
+          }
+        };
+      });
+      var tc = ye((jnr, goe) => {
+        var hL = mb(), z3 = pv();
+        goe.exports = { moduleType: "component", name: "colorscale", attributes: Tu(), layoutAttributes: Eq(), supplyLayoutDefaults: foe(), handleDefaults: td(), crossTraceDefaults: doe(), calc: gv(), scales: hL.scales, defaultScale: hL.defaultScale, getScale: hL.get, isValidScale: hL.isValid, hasColorscale: z3.hasColorscale, extractOpts: z3.extractOpts, extractScale: z3.extractScale, flipScale: z3.flipScale, makeColorScaleFunc: z3.makeColorScaleFunc, makeColorScaleFuncFromTrace: z3.makeColorScaleFuncFromTrace };
+      });
+      var Ru = ye((Wnr, yoe) => {
+        var moe = Dr(), zot = vv().isTypedArraySpec;
+        yoe.exports = { hasLines: function(e) {
+          return e.visible && e.mode && e.mode.indexOf("lines") !== -1;
+        }, hasMarkers: function(e) {
+          return e.visible && (e.mode && e.mode.indexOf("markers") !== -1 || e.type === "splom");
+        }, hasText: function(e) {
+          return e.visible && e.mode && e.mode.indexOf("text") !== -1;
+        }, isBubble: function(e) {
+          var t = e.marker;
+          return moe.isPlainObject(t) && (moe.isArrayOrTypedArray(t.size) || zot(t.size));
+        } };
+      });
+      var O3 = ye((Xnr, _oe) => {
+        var Oot = Eo();
+        _oe.exports = function(t, r) {
+          r || (r = 2);
+          var n = t.marker, i = n.sizeref || 1, a = n.sizemin || 0, o = n.sizemode === "area" ? function(s) {
+            return Math.sqrt(s / i);
+          } : function(s) {
+            return s / i;
+          };
+          return function(s) {
+            var l = o(s / r);
+            return Oot(l) && l > 0 ? Math.max(l, a) : 0;
+          };
+        };
+      });
+      var ip = ye((mv) => {
+        var dL = Dr();
+        mv.getSubplot = function(e) {
+          return e.subplot || e.xaxis + e.yaxis || e.geo;
+        };
+        mv.isTraceInSubplots = function(e, t) {
+          if (e.type === "splom") {
+            for (var r = e.xaxes || [], n = e.yaxes || [], i = 0; i < r.length; i++) for (var a = 0; a < n.length; a++) if (t.indexOf(r[i] + n[a]) !== -1) return true;
+            return false;
+          }
+          return t.indexOf(mv.getSubplot(e)) !== -1;
+        };
+        mv.flat = function(e, t) {
+          for (var r = new Array(e.length), n = 0; n < e.length; n++) r[n] = t;
+          return r;
+        };
+        mv.p2c = function(e, t) {
+          for (var r = new Array(e.length), n = 0; n < e.length; n++) r[n] = e[n].p2c(t);
+          return r;
+        };
+        mv.getDistanceFunction = function(e, t, r, n) {
+          return e === "closest" ? n || mv.quadrature(t, r) : e.charAt(0) === "x" ? t : r;
+        };
+        mv.getClosest = function(e, t, r) {
+          if (r.index !== false) r.index >= 0 && r.index < e.length ? r.distance = 0 : r.index = false;
+          else for (var n = 1 / 0, i = e.length, a = 0; a < i; a++) n = t(e[a]), n <= r.distance && (r.index = a, r.distance = n);
+          return r;
+        };
+        mv.inbox = function(e, t, r) {
+          return e * t < 0 || e === 0 ? r : 1 / 0;
+        };
+        mv.quadrature = function(e, t) {
+          return function(r) {
+            var n = e(r), i = t(r);
+            return Math.sqrt(n * n + i * i);
+          };
+        };
+        mv.makeEventData = function(e, t, r) {
+          var n = "index" in e ? e.index : e.pointNumber, i = { data: t._input, fullData: t, curveNumber: t.index, pointNumber: n };
+          if (t._indexToPoints) {
+            var a = t._indexToPoints[n];
+            a.length === 1 ? i.pointIndex = a[0] : i.pointIndices = a;
+          } else i.pointIndex = n;
+          return t._module.eventData ? i = t._module.eventData(i, e, t, r, n) : ("xVal" in e ? i.x = e.xVal : "x" in e && (i.x = e.x), "yVal" in e ? i.y = e.yVal : "y" in e && (i.y = e.y), e.xa && (i.xaxis = e.xa), e.ya && (i.yaxis = e.ya), e.zLabelVal !== void 0 && (i.z = e.zLabelVal)), mv.appendArrayPointValue(i, t, n), i;
+        };
+        mv.appendArrayPointValue = function(e, t, r) {
+          var n = t._arrayAttrs;
+          if (n) for (var i = 0; i < n.length; i++) {
+            var a = n[i], o = xoe(a);
+            if (e[o] === void 0) {
+              var s = dL.nestedProperty(t, a).get(), l = boe(s, r);
+              l !== void 0 && (e[o] = l);
+            }
+          }
+        };
+        mv.appendArrayMultiPointValues = function(e, t, r) {
+          var n = t._arrayAttrs;
+          if (n) for (var i = 0; i < n.length; i++) {
+            var a = n[i], o = xoe(a);
+            if (e[o] === void 0) {
+              for (var s = dL.nestedProperty(t, a).get(), l = new Array(r.length), u = 0; u < r.length; u++) l[u] = boe(s, r[u]);
+              e[o] = l;
+            }
+          }
+        };
+        var qot = { ids: "id", locations: "location", labels: "label", values: "value", "marker.colors": "color", parents: "parent" };
+        function xoe(e) {
+          return qot[e] || e;
+        }
+        function boe(e, t) {
+          if (Array.isArray(t)) {
+            if (dL.isArrayOrTypedArray(e) && dL.isArrayOrTypedArray(e[t[0]])) return e[t[0]][t[1]];
+          } else return e[t];
+        }
+        var Bot = { x: true, y: true }, Not = { "x unified": true, "y unified": true };
+        mv.isUnifiedHover = function(e) {
+          return typeof e != "string" ? false : !!Not[e];
+        };
+        mv.isXYhover = function(e) {
+          return typeof e != "string" ? false : !!Bot[e];
+        };
+      });
+      var nM = ye((Ynr, woe) => {
+        woe.exports = Vot;
+        var Bq = { a: 7, c: 6, h: 1, l: 2, m: 2, q: 4, s: 4, t: 2, v: 1, z: 0 }, Uot = /([astvzqmhlc])([^astvzqmhlc]*)/ig;
+        function Vot(e) {
+          var t = [];
+          return e.replace(Uot, function(r, n, i) {
+            var a = n.toLowerCase();
+            for (i = Hot(i), a == "m" && i.length > 2 && (t.push([n].concat(i.splice(0, 2))), a = "l", n = n == "m" ? "l" : "L"); ; ) {
+              if (i.length == Bq[a]) return i.unshift(n), t.push(i);
+              if (i.length < Bq[a]) throw new Error("malformed path data");
+              t.push([n].concat(i.splice(0, Bq[a])));
+            }
+          }), t;
+        }
+        var Got = /-?[0-9]*\.?[0-9]+(?:e[-+]?\d+)?/ig;
+        function Hot(e) {
+          var t = e.match(Got);
+          return t ? t.map(Number) : [];
+        }
+      });
+      var Coe = ye((Knr, koe) => {
+        var jot = nM(), ca = function(e, t) {
+          return t ? Math.round(e * (t = Math.pow(10, t))) / t : Math.round(e);
+        }, hs = "M0,0Z", Toe = Math.sqrt(2), c_ = Math.sqrt(3), Nq = Math.PI, Uq = Math.cos, Vq = Math.sin;
+        koe.exports = { circle: { n: 0, f: function(e, t, r) {
+          if (ds(t)) return hs;
+          var n = ca(e, 2), i = "M" + n + ",0A" + n + "," + n + " 0 1,1 0,-" + n + "A" + n + "," + n + " 0 0,1 " + n + ",0Z";
+          return r ? vs(t, r, i) : i;
+        } }, square: { n: 1, f: function(e, t, r) {
+          if (ds(t)) return hs;
+          var n = ca(e, 2);
+          return vs(t, r, "M" + n + "," + n + "H-" + n + "V-" + n + "H" + n + "Z");
+        } }, diamond: { n: 2, f: function(e, t, r) {
+          if (ds(t)) return hs;
+          var n = ca(e * 1.3, 2);
+          return vs(t, r, "M" + n + ",0L0," + n + "L-" + n + ",0L0,-" + n + "Z");
+        } }, cross: { n: 3, f: function(e, t, r) {
+          if (ds(t)) return hs;
+          var n = ca(e * 0.4, 2), i = ca(e * 1.2, 2);
+          return vs(t, r, "M" + i + "," + n + "H" + n + "V" + i + "H-" + n + "V" + n + "H-" + i + "V-" + n + "H-" + n + "V-" + i + "H" + n + "V-" + n + "H" + i + "Z");
+        } }, x: { n: 4, f: function(e, t, r) {
+          if (ds(t)) return hs;
+          var n = ca(e * 0.8 / Toe, 2), i = "l" + n + "," + n, a = "l" + n + ",-" + n, o = "l-" + n + ",-" + n, s = "l-" + n + "," + n;
+          return vs(t, r, "M0," + n + i + a + o + a + o + s + o + s + i + s + i + "Z");
+        } }, "triangle-up": { n: 5, f: function(e, t, r) {
+          if (ds(t)) return hs;
+          var n = ca(e * 2 / c_, 2), i = ca(e / 2, 2), a = ca(e, 2);
+          return vs(t, r, "M-" + n + "," + i + "H" + n + "L0,-" + a + "Z");
+        } }, "triangle-down": { n: 6, f: function(e, t, r) {
+          if (ds(t)) return hs;
+          var n = ca(e * 2 / c_, 2), i = ca(e / 2, 2), a = ca(e, 2);
+          return vs(t, r, "M-" + n + ",-" + i + "H" + n + "L0," + a + "Z");
+        } }, "triangle-left": { n: 7, f: function(e, t, r) {
+          if (ds(t)) return hs;
+          var n = ca(e * 2 / c_, 2), i = ca(e / 2, 2), a = ca(e, 2);
+          return vs(t, r, "M" + i + ",-" + n + "V" + n + "L-" + a + ",0Z");
+        } }, "triangle-right": { n: 8, f: function(e, t, r) {
+          if (ds(t)) return hs;
+          var n = ca(e * 2 / c_, 2), i = ca(e / 2, 2), a = ca(e, 2);
+          return vs(t, r, "M-" + i + ",-" + n + "V" + n + "L" + a + ",0Z");
+        } }, "triangle-ne": { n: 9, f: function(e, t, r) {
+          if (ds(t)) return hs;
+          var n = ca(e * 0.6, 2), i = ca(e * 1.2, 2);
+          return vs(t, r, "M-" + i + ",-" + n + "H" + n + "V" + i + "Z");
+        } }, "triangle-se": { n: 10, f: function(e, t, r) {
+          if (ds(t)) return hs;
+          var n = ca(e * 0.6, 2), i = ca(e * 1.2, 2);
+          return vs(t, r, "M" + n + ",-" + i + "V" + n + "H-" + i + "Z");
+        } }, "triangle-sw": { n: 11, f: function(e, t, r) {
+          if (ds(t)) return hs;
+          var n = ca(e * 0.6, 2), i = ca(e * 1.2, 2);
+          return vs(t, r, "M" + i + "," + n + "H-" + n + "V-" + i + "Z");
+        } }, "triangle-nw": { n: 12, f: function(e, t, r) {
+          if (ds(t)) return hs;
+          var n = ca(e * 0.6, 2), i = ca(e * 1.2, 2);
+          return vs(t, r, "M-" + n + "," + i + "V-" + n + "H" + i + "Z");
+        } }, pentagon: { n: 13, f: function(e, t, r) {
+          if (ds(t)) return hs;
+          var n = ca(e * 0.951, 2), i = ca(e * 0.588, 2), a = ca(-e, 2), o = ca(e * -0.309, 2), s = ca(e * 0.809, 2);
+          return vs(t, r, "M" + n + "," + o + "L" + i + "," + s + "H-" + i + "L-" + n + "," + o + "L0," + a + "Z");
+        } }, hexagon: { n: 14, f: function(e, t, r) {
+          if (ds(t)) return hs;
+          var n = ca(e, 2), i = ca(e / 2, 2), a = ca(e * c_ / 2, 2);
+          return vs(t, r, "M" + a + ",-" + i + "V" + i + "L0," + n + "L-" + a + "," + i + "V-" + i + "L0,-" + n + "Z");
+        } }, hexagon2: { n: 15, f: function(e, t, r) {
+          if (ds(t)) return hs;
+          var n = ca(e, 2), i = ca(e / 2, 2), a = ca(e * c_ / 2, 2);
+          return vs(t, r, "M-" + i + "," + a + "H" + i + "L" + n + ",0L" + i + ",-" + a + "H-" + i + "L-" + n + ",0Z");
+        } }, octagon: { n: 16, f: function(e, t, r) {
+          if (ds(t)) return hs;
+          var n = ca(e * 0.924, 2), i = ca(e * 0.383, 2);
+          return vs(t, r, "M-" + i + ",-" + n + "H" + i + "L" + n + ",-" + i + "V" + i + "L" + i + "," + n + "H-" + i + "L-" + n + "," + i + "V-" + i + "Z");
+        } }, star: { n: 17, f: function(e, t, r) {
+          if (ds(t)) return hs;
+          var n = e * 1.4, i = ca(n * 0.225, 2), a = ca(n * 0.951, 2), o = ca(n * 0.363, 2), s = ca(n * 0.588, 2), l = ca(-n, 2), u = ca(n * -0.309, 2), c = ca(n * 0.118, 2), f = ca(n * 0.809, 2), h = ca(n * 0.382, 2);
+          return vs(t, r, "M" + i + "," + u + "H" + a + "L" + o + "," + c + "L" + s + "," + f + "L0," + h + "L-" + s + "," + f + "L-" + o + "," + c + "L-" + a + "," + u + "H-" + i + "L0," + l + "Z");
+        } }, hexagram: { n: 18, f: function(e, t, r) {
+          if (ds(t)) return hs;
+          var n = ca(e * 0.66, 2), i = ca(e * 0.38, 2), a = ca(e * 0.76, 2);
+          return vs(t, r, "M-" + a + ",0l-" + i + ",-" + n + "h" + a + "l" + i + ",-" + n + "l" + i + "," + n + "h" + a + "l-" + i + "," + n + "l" + i + "," + n + "h-" + a + "l-" + i + "," + n + "l-" + i + ",-" + n + "h-" + a + "Z");
+        } }, "star-triangle-up": { n: 19, f: function(e, t, r) {
+          if (ds(t)) return hs;
+          var n = ca(e * c_ * 0.8, 2), i = ca(e * 0.8, 2), a = ca(e * 1.6, 2), o = ca(e * 4, 2), s = "A " + o + "," + o + " 0 0 1 ";
+          return vs(t, r, "M-" + n + "," + i + s + n + "," + i + s + "0,-" + a + s + "-" + n + "," + i + "Z");
+        } }, "star-triangle-down": { n: 20, f: function(e, t, r) {
+          if (ds(t)) return hs;
+          var n = ca(e * c_ * 0.8, 2), i = ca(e * 0.8, 2), a = ca(e * 1.6, 2), o = ca(e * 4, 2), s = "A " + o + "," + o + " 0 0 1 ";
+          return vs(t, r, "M" + n + ",-" + i + s + "-" + n + ",-" + i + s + "0," + a + s + n + ",-" + i + "Z");
+        } }, "star-square": { n: 21, f: function(e, t, r) {
+          if (ds(t)) return hs;
+          var n = ca(e * 1.1, 2), i = ca(e * 2, 2), a = "A " + i + "," + i + " 0 0 1 ";
+          return vs(t, r, "M-" + n + ",-" + n + a + "-" + n + "," + n + a + n + "," + n + a + n + ",-" + n + a + "-" + n + ",-" + n + "Z");
+        } }, "star-diamond": { n: 22, f: function(e, t, r) {
+          if (ds(t)) return hs;
+          var n = ca(e * 1.4, 2), i = ca(e * 1.9, 2), a = "A " + i + "," + i + " 0 0 1 ";
+          return vs(t, r, "M-" + n + ",0" + a + "0," + n + a + n + ",0" + a + "0,-" + n + a + "-" + n + ",0Z");
+        } }, "diamond-tall": { n: 23, f: function(e, t, r) {
+          if (ds(t)) return hs;
+          var n = ca(e * 0.7, 2), i = ca(e * 1.4, 2);
+          return vs(t, r, "M0," + i + "L" + n + ",0L0,-" + i + "L-" + n + ",0Z");
+        } }, "diamond-wide": { n: 24, f: function(e, t, r) {
+          if (ds(t)) return hs;
+          var n = ca(e * 1.4, 2), i = ca(e * 0.7, 2);
+          return vs(t, r, "M0," + i + "L" + n + ",0L0,-" + i + "L-" + n + ",0Z");
+        } }, hourglass: { n: 25, f: function(e, t, r) {
+          if (ds(t)) return hs;
+          var n = ca(e, 2);
+          return vs(t, r, "M" + n + "," + n + "H-" + n + "L" + n + ",-" + n + "H-" + n + "Z");
+        }, noDot: true }, bowtie: { n: 26, f: function(e, t, r) {
+          if (ds(t)) return hs;
+          var n = ca(e, 2);
+          return vs(t, r, "M" + n + "," + n + "V-" + n + "L-" + n + "," + n + "V-" + n + "Z");
+        }, noDot: true }, "circle-cross": { n: 27, f: function(e, t, r) {
+          if (ds(t)) return hs;
+          var n = ca(e, 2);
+          return vs(t, r, "M0," + n + "V-" + n + "M" + n + ",0H-" + n + "M" + n + ",0A" + n + "," + n + " 0 1,1 0,-" + n + "A" + n + "," + n + " 0 0,1 " + n + ",0Z");
+        }, needLine: true, noDot: true }, "circle-x": { n: 28, f: function(e, t, r) {
+          if (ds(t)) return hs;
+          var n = ca(e, 2), i = ca(e / Toe, 2);
+          return vs(t, r, "M" + i + "," + i + "L-" + i + ",-" + i + "M" + i + ",-" + i + "L-" + i + "," + i + "M" + n + ",0A" + n + "," + n + " 0 1,1 0,-" + n + "A" + n + "," + n + " 0 0,1 " + n + ",0Z");
+        }, needLine: true, noDot: true }, "square-cross": { n: 29, f: function(e, t, r) {
+          if (ds(t)) return hs;
+          var n = ca(e, 2);
+          return vs(t, r, "M0," + n + "V-" + n + "M" + n + ",0H-" + n + "M" + n + "," + n + "H-" + n + "V-" + n + "H" + n + "Z");
+        }, needLine: true, noDot: true }, "square-x": { n: 30, f: function(e, t, r) {
+          if (ds(t)) return hs;
+          var n = ca(e, 2);
+          return vs(t, r, "M" + n + "," + n + "L-" + n + ",-" + n + "M" + n + ",-" + n + "L-" + n + "," + n + "M" + n + "," + n + "H-" + n + "V-" + n + "H" + n + "Z");
+        }, needLine: true, noDot: true }, "diamond-cross": { n: 31, f: function(e, t, r) {
+          if (ds(t)) return hs;
+          var n = ca(e * 1.3, 2);
+          return vs(t, r, "M" + n + ",0L0," + n + "L-" + n + ",0L0,-" + n + "ZM0,-" + n + "V" + n + "M-" + n + ",0H" + n);
+        }, needLine: true, noDot: true }, "diamond-x": { n: 32, f: function(e, t, r) {
+          if (ds(t)) return hs;
+          var n = ca(e * 1.3, 2), i = ca(e * 0.65, 2);
+          return vs(t, r, "M" + n + ",0L0," + n + "L-" + n + ",0L0,-" + n + "ZM-" + i + ",-" + i + "L" + i + "," + i + "M-" + i + "," + i + "L" + i + ",-" + i);
+        }, needLine: true, noDot: true }, "cross-thin": { n: 33, f: function(e, t, r) {
+          if (ds(t)) return hs;
+          var n = ca(e * 1.4, 2);
+          return vs(t, r, "M0," + n + "V-" + n + "M" + n + ",0H-" + n);
+        }, needLine: true, noDot: true, noFill: true }, "x-thin": { n: 34, f: function(e, t, r) {
+          if (ds(t)) return hs;
+          var n = ca(e, 2);
+          return vs(t, r, "M" + n + "," + n + "L-" + n + ",-" + n + "M" + n + ",-" + n + "L-" + n + "," + n);
+        }, needLine: true, noDot: true, noFill: true }, asterisk: { n: 35, f: function(e, t, r) {
+          if (ds(t)) return hs;
+          var n = ca(e * 1.2, 2), i = ca(e * 0.85, 2);
+          return vs(t, r, "M0," + n + "V-" + n + "M" + n + ",0H-" + n + "M" + i + "," + i + "L-" + i + ",-" + i + "M" + i + ",-" + i + "L-" + i + "," + i);
+        }, needLine: true, noDot: true, noFill: true }, hash: { n: 36, f: function(e, t, r) {
+          if (ds(t)) return hs;
+          var n = ca(e / 2, 2), i = ca(e, 2);
+          return vs(t, r, "M" + n + "," + i + "V-" + i + "M" + (n - i) + ",-" + i + "V" + i + "M" + i + "," + n + "H-" + i + "M-" + i + "," + (n - i) + "H" + i);
+        }, needLine: true, noFill: true }, "y-up": { n: 37, f: function(e, t, r) {
+          if (ds(t)) return hs;
+          var n = ca(e * 1.2, 2), i = ca(e * 1.6, 2), a = ca(e * 0.8, 2);
+          return vs(t, r, "M-" + n + "," + a + "L0,0M" + n + "," + a + "L0,0M0,-" + i + "L0,0");
+        }, needLine: true, noDot: true, noFill: true }, "y-down": { n: 38, f: function(e, t, r) {
+          if (ds(t)) return hs;
+          var n = ca(e * 1.2, 2), i = ca(e * 1.6, 2), a = ca(e * 0.8, 2);
+          return vs(t, r, "M-" + n + ",-" + a + "L0,0M" + n + ",-" + a + "L0,0M0," + i + "L0,0");
+        }, needLine: true, noDot: true, noFill: true }, "y-left": { n: 39, f: function(e, t, r) {
+          if (ds(t)) return hs;
+          var n = ca(e * 1.2, 2), i = ca(e * 1.6, 2), a = ca(e * 0.8, 2);
+          return vs(t, r, "M" + a + "," + n + "L0,0M" + a + ",-" + n + "L0,0M-" + i + ",0L0,0");
+        }, needLine: true, noDot: true, noFill: true }, "y-right": { n: 40, f: function(e, t, r) {
+          if (ds(t)) return hs;
+          var n = ca(e * 1.2, 2), i = ca(e * 1.6, 2), a = ca(e * 0.8, 2);
+          return vs(t, r, "M-" + a + "," + n + "L0,0M-" + a + ",-" + n + "L0,0M" + i + ",0L0,0");
+        }, needLine: true, noDot: true, noFill: true }, "line-ew": { n: 41, f: function(e, t, r) {
+          if (ds(t)) return hs;
+          var n = ca(e * 1.4, 2);
+          return vs(t, r, "M" + n + ",0H-" + n);
+        }, needLine: true, noDot: true, noFill: true }, "line-ns": { n: 42, f: function(e, t, r) {
+          if (ds(t)) return hs;
+          var n = ca(e * 1.4, 2);
+          return vs(t, r, "M0," + n + "V-" + n);
+        }, needLine: true, noDot: true, noFill: true }, "line-ne": { n: 43, f: function(e, t, r) {
+          if (ds(t)) return hs;
+          var n = ca(e, 2);
+          return vs(t, r, "M" + n + ",-" + n + "L-" + n + "," + n);
+        }, needLine: true, noDot: true, noFill: true }, "line-nw": { n: 44, f: function(e, t, r) {
+          if (ds(t)) return hs;
+          var n = ca(e, 2);
+          return vs(t, r, "M" + n + "," + n + "L-" + n + ",-" + n);
+        }, needLine: true, noDot: true, noFill: true }, "arrow-up": { n: 45, f: function(e, t, r) {
+          if (ds(t)) return hs;
+          var n = ca(e, 2), i = ca(e * 2, 2);
+          return vs(t, r, "M0,0L-" + n + "," + i + "H" + n + "Z");
+        }, backoff: 1, noDot: true }, "arrow-down": { n: 46, f: function(e, t, r) {
+          if (ds(t)) return hs;
+          var n = ca(e, 2), i = ca(e * 2, 2);
+          return vs(t, r, "M0,0L-" + n + ",-" + i + "H" + n + "Z");
+        }, noDot: true }, "arrow-left": { n: 47, f: function(e, t, r) {
+          if (ds(t)) return hs;
+          var n = ca(e * 2, 2), i = ca(e, 2);
+          return vs(t, r, "M0,0L" + n + ",-" + i + "V" + i + "Z");
+        }, noDot: true }, "arrow-right": { n: 48, f: function(e, t, r) {
+          if (ds(t)) return hs;
+          var n = ca(e * 2, 2), i = ca(e, 2);
+          return vs(t, r, "M0,0L-" + n + ",-" + i + "V" + i + "Z");
+        }, noDot: true }, "arrow-bar-up": { n: 49, f: function(e, t, r) {
+          if (ds(t)) return hs;
+          var n = ca(e, 2), i = ca(e * 2, 2);
+          return vs(t, r, "M-" + n + ",0H" + n + "M0,0L-" + n + "," + i + "H" + n + "Z");
+        }, backoff: 1, needLine: true, noDot: true }, "arrow-bar-down": { n: 50, f: function(e, t, r) {
+          if (ds(t)) return hs;
+          var n = ca(e, 2), i = ca(e * 2, 2);
+          return vs(t, r, "M-" + n + ",0H" + n + "M0,0L-" + n + ",-" + i + "H" + n + "Z");
+        }, needLine: true, noDot: true }, "arrow-bar-left": { n: 51, f: function(e, t, r) {
+          if (ds(t)) return hs;
+          var n = ca(e * 2, 2), i = ca(e, 2);
+          return vs(t, r, "M0,-" + i + "V" + i + "M0,0L" + n + ",-" + i + "V" + i + "Z");
+        }, needLine: true, noDot: true }, "arrow-bar-right": { n: 52, f: function(e, t, r) {
+          if (ds(t)) return hs;
+          var n = ca(e * 2, 2), i = ca(e, 2);
+          return vs(t, r, "M0,-" + i + "V" + i + "M0,0L-" + n + ",-" + i + "V" + i + "Z");
+        }, needLine: true, noDot: true }, arrow: { n: 53, f: function(e, t, r) {
+          if (ds(t)) return hs;
+          var n = Nq / 2.5, i = 2 * e * Uq(n), a = 2 * e * Vq(n);
+          return vs(t, r, "M0,0L" + -i + "," + a + "L" + i + "," + a + "Z");
+        }, backoff: 0.9, noDot: true }, "arrow-wide": { n: 54, f: function(e, t, r) {
+          if (ds(t)) return hs;
+          var n = Nq / 4, i = 2 * e * Uq(n), a = 2 * e * Vq(n);
+          return vs(t, r, "M0,0L" + -i + "," + a + "A " + 2 * e + "," + 2 * e + " 0 0 1 " + i + "," + a + "Z");
+        }, backoff: 0.4, noDot: true } };
+        function ds(e) {
+          return e === null;
+        }
+        var Aoe, Soe, Moe, Eoe;
+        function vs(e, t, r) {
+          if ((!e || e % 360 === 0) && !t) return r;
+          if (Moe === e && Eoe === t && Aoe === r) return Soe;
+          Moe = e, Eoe = t, Aoe = r;
+          function n(b, p) {
+            var k = Uq(b), E = Vq(b), T = p[0], L = p[1] + (t || 0);
+            return [T * k - L * E, T * E + L * k];
+          }
+          for (var i = e / 180 * Nq, a = 0, o = 0, s = jot(r), l = "", u = 0; u < s.length; u++) {
+            var c = s[u], f = c[0], h = a, d = o;
+            if (f === "M" || f === "L") a = +c[1], o = +c[2];
+            else if (f === "m" || f === "l") a += +c[1], o += +c[2];
+            else if (f === "H") a = +c[1];
+            else if (f === "h") a += +c[1];
+            else if (f === "V") o = +c[1];
+            else if (f === "v") o += +c[1];
+            else if (f === "A") {
+              a = +c[1], o = +c[2];
+              var v = n(i, [+c[6], +c[7]]);
+              c[6] = v[0], c[7] = v[1], c[3] = +c[3] + e;
+            }
+            (f === "H" || f === "V") && (f = "L"), (f === "h" || f === "v") && (f = "l"), (f === "m" || f === "l") && (a -= h, o -= d);
+            var _ = n(i, [a, o]);
+            (f === "H" || f === "V") && (f = "L"), (f === "M" || f === "L" || f === "m" || f === "l") && (c[1] = _[0], c[2] = _[1]), c[0] = f, l += c[0] + c.slice(1).join(",");
+          }
+          return Soe = l, l;
+        }
+      });
+      var So = ye((Jnr, Yoe) => {
+        var dd = Oa(), Du = Dr(), Wot = Du.numberFormat, Db = Eo(), Zq = fd(), pL = qa(), Yd = ka(), Xot = tc(), oM = Du.strTranslate, gL = Zl(), Zot = Wp(), Yot = Dh(), Kot = Yot.LINE_SPACING, Boe = X1().DESELECTDIM, Jot = Ru(), $ot = O3(), Qot = ip().appendArrayPointValue, Ta = Yoe.exports = {};
+        Ta.font = function(e, t) {
+          var r = t.variant, n = t.style, i = t.weight, a = t.color, o = t.size, s = t.family, l = t.shadow, u = t.lineposition, c = t.textcase;
+          s && e.style("font-family", s), o + 1 && e.style("font-size", o + "px"), a && e.call(Yd.fill, a), i && e.style("font-weight", i), n && e.style("font-style", n), r && e.style("font-variant", r), c && e.style("text-transform", Gq(tst(c))), l && e.style("text-shadow", l === "auto" ? gL.makeTextShadow(Yd.contrast(a)) : Gq(l)), u && e.style("text-decoration-line", Gq(rst(u)));
+        };
+        function Gq(e) {
+          return e === "none" ? void 0 : e;
+        }
+        var est = { normal: "none", lower: "lowercase", upper: "uppercase", "word caps": "capitalize" };
+        function tst(e) {
+          return est[e];
+        }
+        function rst(e) {
+          return e.replace("under", "underline").replace("over", "overline").replace("through", "line-through").split("+").join(" ");
+        }
+        Ta.setPosition = function(e, t, r) {
+          e.attr("x", t).attr("y", r);
+        };
+        Ta.setSize = function(e, t, r) {
+          e.attr("width", t).attr("height", r);
+        };
+        Ta.setRect = function(e, t, r, n, i) {
+          e.call(Ta.setPosition, t, r).call(Ta.setSize, n, i);
+        };
+        Ta.translatePoint = function(e, t, r, n) {
+          var i = r.c2p(e.x), a = n.c2p(e.y);
+          if (Db(i) && Db(a) && t.node()) t.node().nodeName === "text" ? t.attr("x", i).attr("y", a) : t.attr("transform", oM(i, a));
+          else return false;
+          return true;
+        };
+        Ta.translatePoints = function(e, t, r) {
+          e.each(function(n) {
+            var i = dd.select(this);
+            Ta.translatePoint(n, i, t, r);
+          });
+        };
+        Ta.hideOutsideRangePoint = function(e, t, r, n, i, a) {
+          t.attr("display", r.isPtWithinRange(e, i) && n.isPtWithinRange(e, a) ? null : "none");
+        };
+        Ta.hideOutsideRangePoints = function(e, t) {
+          if (t._hasClipOnAxisFalse) {
+            var r = t.xaxis, n = t.yaxis;
+            e.each(function(i) {
+              var a = i[0].trace, o = a.xcalendar, s = a.ycalendar, l = pL.traceIs(a, "bar-like") ? ".bartext" : ".point,.textpoint";
+              e.selectAll(l).each(function(u) {
+                Ta.hideOutsideRangePoint(u, dd.select(this), r, n, o, s);
+              });
+            });
+          }
+        };
+        Ta.crispRound = function(e, t, r) {
+          return !t || !Db(t) ? r || 0 : e._context.staticPlot ? t : t < 1 ? 1 : Math.round(t);
+        };
+        Ta.singleLineStyle = function(e, t, r, n, i) {
+          t.style("fill", "none");
+          var a = (((e || [])[0] || {}).trace || {}).line || {}, o = r || a.width || 0, s = i || a.dash || "";
+          Yd.stroke(t, n || a.color), Ta.dashLine(t, s, o);
+        };
+        Ta.lineGroupStyle = function(e, t, r, n) {
+          e.style("fill", "none").each(function(i) {
+            var a = (((i || [])[0] || {}).trace || {}).line || {}, o = t || a.width || 0, s = n || a.dash || "";
+            dd.select(this).call(Yd.stroke, r || a.color).call(Ta.dashLine, s, o);
+          });
+        };
+        Ta.dashLine = function(e, t, r) {
+          r = +r || 0, t = Ta.dashStyle(t, r), e.style({ "stroke-dasharray": t, "stroke-width": r + "px" });
+        };
+        Ta.dashStyle = function(e, t) {
+          t = +t || 1;
+          var r = Math.max(t, 3);
+          return e === "solid" ? e = "" : e === "dot" ? e = r + "px," + r + "px" : e === "dash" ? e = 3 * r + "px," + 3 * r + "px" : e === "longdash" ? e = 5 * r + "px," + 5 * r + "px" : e === "dashdot" ? e = 3 * r + "px," + r + "px," + r + "px," + r + "px" : e === "longdashdot" && (e = 5 * r + "px," + 2 * r + "px," + r + "px," + 2 * r + "px"), e;
+        };
+        function Noe(e, t, r, n) {
+          var i = t.fillpattern, a = t.fillgradient, o = Ta.getPatternAttr, s = i && (o(i.shape, 0, "") || o(i.path, 0, ""));
+          if (s) {
+            var l = o(i.bgcolor, 0, null), u = o(i.fgcolor, 0, null), c = i.fgopacity, f = o(i.size, 0, 8), h = o(i.solidity, 0, 0.3), d = t.uid;
+            Ta.pattern(e, "point", r, d, s, f, h, void 0, i.fillmode, l, u, c);
+          } else if (a && a.type !== "none") {
+            var v = a.type, _ = "scatterfill-" + t.uid;
+            if (n && (_ = "legendfill-" + t.uid), !n && (a.start !== void 0 || a.stop !== void 0)) {
+              var b, p;
+              v === "horizontal" ? (b = { x: a.start, y: 0 }, p = { x: a.stop, y: 0 }) : v === "vertical" && (b = { x: 0, y: a.start }, p = { x: 0, y: a.stop }), b.x = t._xA.c2p(b.x === void 0 ? t._extremes.x.min[0].val : b.x, true), b.y = t._yA.c2p(b.y === void 0 ? t._extremes.y.min[0].val : b.y, true), p.x = t._xA.c2p(p.x === void 0 ? t._extremes.x.max[0].val : p.x, true), p.y = t._yA.c2p(p.y === void 0 ? t._extremes.y.max[0].val : p.y, true), e.call(Goe, r, _, "linear", a.colorscale, "fill", b, p, true, false);
+            } else v === "horizontal" && (v = v + "reversed"), e.call(Ta.gradient, r, _, v, a.colorscale, "fill");
+          } else t.fillcolor && e.call(Yd.fill, t.fillcolor);
+        }
+        Ta.singleFillStyle = function(e, t) {
+          var r = dd.select(e.node()), n = r.data(), i = ((n[0] || [])[0] || {}).trace || {};
+          Noe(e, i, t, false);
+        };
+        Ta.fillGroupStyle = function(e, t, r) {
+          e.style("stroke-width", 0).each(function(n) {
+            var i = dd.select(this);
+            n[0].trace && Noe(i, n[0].trace, t, r);
+          });
+        };
+        var Loe = Coe();
+        Ta.symbolNames = [];
+        Ta.symbolFuncs = [];
+        Ta.symbolBackOffs = [];
+        Ta.symbolNeedLines = {};
+        Ta.symbolNoDot = {};
+        Ta.symbolNoFill = {};
+        Ta.symbolList = [];
+        Object.keys(Loe).forEach(function(e) {
+          var t = Loe[e], r = t.n;
+          Ta.symbolList.push(r, String(r), e, r + 100, String(r + 100), e + "-open"), Ta.symbolNames[r] = e, Ta.symbolFuncs[r] = t.f, Ta.symbolBackOffs[r] = t.backoff || 0, t.needLine && (Ta.symbolNeedLines[r] = true), t.noDot ? Ta.symbolNoDot[r] = true : Ta.symbolList.push(r + 200, String(r + 200), e + "-dot", r + 300, String(r + 300), e + "-open-dot"), t.noFill && (Ta.symbolNoFill[r] = true);
+        });
+        var ist = Ta.symbolNames.length, nst = "M0,0.5L0.5,0L0,-0.5L-0.5,0Z";
+        Ta.symbolNumber = function(e) {
+          if (Db(e)) e = +e;
+          else if (typeof e == "string") {
+            var t = 0;
+            e.indexOf("-open") > 0 && (t = 100, e = e.replace("-open", "")), e.indexOf("-dot") > 0 && (t += 200, e = e.replace("-dot", "")), e = Ta.symbolNames.indexOf(e), e >= 0 && (e += t);
+          }
+          return e % 100 >= ist || e >= 400 ? 0 : Math.floor(Math.max(e, 0));
+        };
+        function Uoe(e, t, r, n) {
+          var i = e % 100;
+          return Ta.symbolFuncs[i](t, r, n) + (e >= 200 ? nst : "");
+        }
+        var Poe = Wot("~f"), Voe = { radial: { type: "radial" }, radialreversed: { type: "radial", reversed: true }, horizontal: { type: "linear", start: { x: 1, y: 0 }, stop: { x: 0, y: 0 } }, horizontalreversed: { type: "linear", start: { x: 1, y: 0 }, stop: { x: 0, y: 0 }, reversed: true }, vertical: { type: "linear", start: { x: 0, y: 1 }, stop: { x: 0, y: 0 } }, verticalreversed: { type: "linear", start: { x: 0, y: 1 }, stop: { x: 0, y: 0 }, reversed: true } };
+        Ta.gradient = function(e, t, r, n, i, a) {
+          var o = Voe[n];
+          return Goe(e, t, r, o.type, i, a, o.start, o.stop, false, o.reversed);
+        };
+        function Goe(e, t, r, n, i, a, o, s, l, u) {
+          var c = i.length, f;
+          n === "linear" ? f = { node: "linearGradient", attrs: { x1: o.x, y1: o.y, x2: s.x, y2: s.y, gradientUnits: l ? "userSpaceOnUse" : "objectBoundingBox" }, reversed: u } : n === "radial" && (f = { node: "radialGradient", reversed: u });
+          for (var h = new Array(c), d = 0; d < c; d++) f.reversed ? h[c - 1 - d] = [Poe((1 - i[d][0]) * 100), i[d][1]] : h[d] = [Poe(i[d][0] * 100), i[d][1]];
+          var v = t._fullLayout, _ = "g" + v._uid + "-" + r, b = v._defs.select(".gradients").selectAll("#" + _).data([n + h.join(";")], Du.identity);
+          b.exit().remove(), b.enter().append(f.node).each(function() {
+            var p = dd.select(this);
+            f.attrs && p.attr(f.attrs), p.attr("id", _);
+            var k = p.selectAll("stop").data(h);
+            k.exit().remove(), k.enter().append("stop"), k.each(function(E) {
+              var T = Zq(E[1]);
+              dd.select(this).attr({ offset: E[0] + "%", "stop-color": Yd.tinyRGB(T), "stop-opacity": T.getAlpha() });
+            });
+          }), e.style(a, Yq(_, t)).style(a + "-opacity", null), e.classed("gradient_filled", true);
+        }
+        Ta.pattern = function(e, t, r, n, i, a, o, s, l, u, c, f) {
+          var h = t === "legend";
+          s && (l === "overlay" ? (u = s, c = Yd.contrast(u)) : (u = void 0, c = s));
+          var d = r._fullLayout, v = "p" + d._uid + "-" + n, _, b, p = function(O, U, G, Z, j) {
+            return Z + (j - Z) * (O - U) / (G - U);
+          }, k, E, T, L, x = {}, C = Zq(c), M = Yd.tinyRGB(C), g = C.getAlpha(), P = f * g;
+          switch (i) {
+            case "/":
+              _ = a * Math.sqrt(2), b = a * Math.sqrt(2), k = "M-" + _ / 4 + "," + b / 4 + "l" + _ / 2 + ",-" + b / 2 + "M0," + b + "L" + _ + ",0M" + _ / 4 * 3 + "," + b / 4 * 5 + "l" + _ / 2 + ",-" + b / 2, E = o * a, L = "path", x = { d: k, opacity: P, stroke: M, "stroke-width": E + "px" };
+              break;
+            case "\\":
+              _ = a * Math.sqrt(2), b = a * Math.sqrt(2), k = "M" + _ / 4 * 3 + ",-" + b / 4 + "l" + _ / 2 + "," + b / 2 + "M0,0L" + _ + "," + b + "M-" + _ / 4 + "," + b / 4 * 3 + "l" + _ / 2 + "," + b / 2, E = o * a, L = "path", x = { d: k, opacity: P, stroke: M, "stroke-width": E + "px" };
+              break;
+            case "x":
+              _ = a * Math.sqrt(2), b = a * Math.sqrt(2), k = "M-" + _ / 4 + "," + b / 4 + "l" + _ / 2 + ",-" + b / 2 + "M0," + b + "L" + _ + ",0M" + _ / 4 * 3 + "," + b / 4 * 5 + "l" + _ / 2 + ",-" + b / 2 + "M" + _ / 4 * 3 + ",-" + b / 4 + "l" + _ / 2 + "," + b / 2 + "M0,0L" + _ + "," + b + "M-" + _ / 4 + "," + b / 4 * 3 + "l" + _ / 2 + "," + b / 2, E = a - a * Math.sqrt(1 - o), L = "path", x = { d: k, opacity: P, stroke: M, "stroke-width": E + "px" };
+              break;
+            case "|":
+              _ = a, b = a, L = "path", k = "M" + _ / 2 + ",0L" + _ / 2 + "," + b, E = o * a, L = "path", x = { d: k, opacity: P, stroke: M, "stroke-width": E + "px" };
+              break;
+            case "-":
+              _ = a, b = a, L = "path", k = "M0," + b / 2 + "L" + _ + "," + b / 2, E = o * a, L = "path", x = { d: k, opacity: P, stroke: M, "stroke-width": E + "px" };
+              break;
+            case "+":
+              _ = a, b = a, L = "path", k = "M" + _ / 2 + ",0L" + _ / 2 + "," + b + "M0," + b / 2 + "L" + _ + "," + b / 2, E = a - a * Math.sqrt(1 - o), L = "path", x = { d: k, opacity: P, stroke: M, "stroke-width": E + "px" };
+              break;
+            case ".":
+              _ = a, b = a, o < Math.PI / 4 ? T = Math.sqrt(o * a * a / Math.PI) : T = p(o, Math.PI / 4, 1, a / 2, a / Math.sqrt(2)), L = "circle", x = { cx: _ / 2, cy: b / 2, r: T, opacity: P, fill: M };
+              break;
+            default:
+              _ = a, b = a, L = "path", x = { d: i, opacity: P, fill: M };
+              break;
+          }
+          var A = [i || "noSh", u || "noBg", c || "noFg", a, o].join(";"), z = d._defs.select(".patterns").selectAll("#" + v).data([A], Du.identity);
+          z.exit().remove(), z.enter().append("pattern").each(function() {
+            var O = dd.select(this);
+            if (O.attr({ id: v, width: _ + "px", height: b + "px", patternUnits: "userSpaceOnUse", patternTransform: h ? "scale(0.8)" : "" }), u) {
+              var U = Zq(u), G = Yd.tinyRGB(U), Z = U.getAlpha(), j = O.selectAll("rect").data([0]);
+              j.exit().remove(), j.enter().append("rect").attr({ width: _ + "px", height: b + "px", fill: G, "fill-opacity": Z });
+            }
+            var N = O.selectAll(L).data([0]);
+            N.exit().remove(), N.enter().append(L).attr(x);
+          }), e.style("fill", Yq(v, r)).style("fill-opacity", null), e.classed("pattern_filled", true);
+        };
+        Ta.initGradients = function(e) {
+          var t = e._fullLayout, r = Du.ensureSingle(t._defs, "g", "gradients");
+          r.selectAll("linearGradient,radialGradient").remove(), dd.select(e).selectAll(".gradient_filled").classed("gradient_filled", false);
+        };
+        Ta.initPatterns = function(e) {
+          var t = e._fullLayout, r = Du.ensureSingle(t._defs, "g", "patterns");
+          r.selectAll("pattern").remove(), dd.select(e).selectAll(".pattern_filled").classed("pattern_filled", false);
+        };
+        Ta.getPatternAttr = function(e, t, r) {
+          return e && Du.isArrayOrTypedArray(e) ? t < e.length ? e[t] : r : e;
+        };
+        Ta.pointStyle = function(e, t, r, n) {
+          if (e.size()) {
+            var i = Ta.makePointStyleFns(t);
+            e.each(function(a) {
+              Ta.singlePointStyle(a, dd.select(this), t, i, r, n);
+            });
+          }
+        };
+        Ta.singlePointStyle = function(e, t, r, n, i, a) {
+          var o = r.marker, s = o.line;
+          if (a && a.i >= 0 && e.i === void 0 && (e.i = a.i), t.style("opacity", n.selectedOpacityFn ? n.selectedOpacityFn(e) : e.mo === void 0 ? o.opacity : e.mo), n.ms2mrc) {
+            var l;
+            e.ms === "various" || o.size === "various" ? l = 3 : l = n.ms2mrc(e.ms), e.mrc = l, n.selectedSizeFn && (l = e.mrc = n.selectedSizeFn(e));
+            var u = Ta.symbolNumber(e.mx || o.symbol) || 0;
+            e.om = u % 200 >= 100;
+            var c = Jq(e, r), f = Kq(e, r);
+            t.attr("d", Uoe(u, l, c, f));
+          }
+          var h = false, d, v, _;
+          if (e.so) _ = s.outlierwidth, v = s.outliercolor, d = o.outliercolor;
+          else {
+            var b = (s || {}).width;
+            _ = (e.mlw + 1 || b + 1 || (e.trace ? (e.trace.marker.line || {}).width : 0) + 1) - 1 || 0, "mlc" in e ? v = e.mlcc = n.lineScale(e.mlc) : Du.isArrayOrTypedArray(s.color) ? v = Yd.defaultLine : v = s.color, Du.isArrayOrTypedArray(o.color) && (d = Yd.defaultLine, h = true), "mc" in e ? d = e.mcc = n.markerScale(e.mc) : d = o.color || o.colors || "rgba(0,0,0,0)", n.selectedColorFn && (d = n.selectedColorFn(e));
+          }
+          let p = e.mld || (s || {}).dash;
+          if (p && Ta.dashLine(t, p, _), e.om) t.call(Yd.stroke, d).style({ "stroke-width": (_ || 1) + "px", fill: "none" });
+          else {
+            t.style("stroke-width", (e.isBlank ? 0 : _) + "px");
+            var k = o.gradient, E = e.mgt;
+            E ? h = true : E = k && k.type, Du.isArrayOrTypedArray(E) && (E = E[0], Voe[E] || (E = 0));
+            var T = o.pattern, L = Ta.getPatternAttr, x = T && (L(T.shape, e.i, "") || L(T.path, e.i, ""));
+            if (E && E !== "none") {
+              var C = e.mgc;
+              C ? h = true : C = k.color;
+              var M = r.uid;
+              h && (M += "-" + e.i), Ta.gradient(t, i, M, E, [[0, C], [1, d]], "fill");
+            } else if (x) {
+              var g = false, P = T.fgcolor;
+              !P && a && a.color && (P = a.color, g = true);
+              var A = L(P, e.i, a && a.color || null), z = L(T.bgcolor, e.i, null), O = T.fgopacity, U = L(T.size, e.i, 8), G = L(T.solidity, e.i, 0.3);
+              g = g || e.mcc || Du.isArrayOrTypedArray(T.shape) || Du.isArrayOrTypedArray(T.path) || Du.isArrayOrTypedArray(T.bgcolor) || Du.isArrayOrTypedArray(T.fgcolor) || Du.isArrayOrTypedArray(T.size) || Du.isArrayOrTypedArray(T.solidity);
+              var Z = r.uid;
+              g && (Z += "-" + e.i), Ta.pattern(t, "point", i, Z, x, U, G, e.mcc, T.fillmode, z, A, O);
+            } else Du.isArrayOrTypedArray(d) ? Yd.fill(t, d[e.i]) : Yd.fill(t, d);
+            _ && Yd.stroke(t, v);
+          }
+        };
+        Ta.makePointStyleFns = function(e) {
+          var t = {}, r = e.marker;
+          return t.markerScale = Ta.tryColorscale(r, ""), t.lineScale = Ta.tryColorscale(r, "line"), pL.traceIs(e, "symbols") && (t.ms2mrc = Jot.isBubble(e) ? $ot(e) : function() {
+            return (r.size || 6) / 2;
+          }), e.selectedpoints && Du.extendFlat(t, Ta.makeSelectedPointStyleFns(e)), t;
+        };
+        Ta.makeSelectedPointStyleFns = function(e) {
+          var t = {}, r = e.selected || {}, n = e.unselected || {}, i = e.marker || {}, a = r.marker || {}, o = n.marker || {}, s = i.opacity, l = a.opacity, u = o.opacity, c = l !== void 0, f = u !== void 0;
+          (Du.isArrayOrTypedArray(s) || c || f) && (t.selectedOpacityFn = function(T) {
+            var L = T.mo === void 0 ? i.opacity : T.mo;
+            return T.selected ? c ? l : L : f ? u : Boe * L;
+          });
+          var h = i.color, d = a.color, v = o.color;
+          (d || v) && (t.selectedColorFn = function(T) {
+            var L = T.mcc || h;
+            return T.selected ? d || L : v || L;
+          });
+          var _ = i.size, b = a.size, p = o.size, k = b !== void 0, E = p !== void 0;
+          return pL.traceIs(e, "symbols") && (k || E) && (t.selectedSizeFn = function(T) {
+            var L = T.mrc || _ / 2;
+            return T.selected ? k ? b / 2 : L : E ? p / 2 : L;
+          }), t;
+        };
+        Ta.makeSelectedTextStyleFns = function(e) {
+          var t = {}, r = e.selected || {}, n = e.unselected || {}, i = e.textfont || {}, a = r.textfont || {}, o = n.textfont || {}, s = i.color, l = a.color, u = o.color;
+          return t.selectedTextColorFn = function(c) {
+            var f = c.tc || s;
+            return c.selected ? l || f : u || (l ? f : Yd.addOpacity(f, Boe));
+          }, t;
+        };
+        Ta.selectedPointStyle = function(e, t) {
+          if (!(!e.size() || !t.selectedpoints)) {
+            var r = Ta.makeSelectedPointStyleFns(t), n = t.marker || {}, i = [];
+            r.selectedOpacityFn && i.push(function(a, o) {
+              a.style("opacity", r.selectedOpacityFn(o));
+            }), r.selectedColorFn && i.push(function(a, o) {
+              Yd.fill(a, r.selectedColorFn(o));
+            }), r.selectedSizeFn && i.push(function(a, o) {
+              var s = o.mx || n.symbol || 0, l = r.selectedSizeFn(o);
+              a.attr("d", Uoe(Ta.symbolNumber(s), l, Jq(o, t), Kq(o, t))), o.mrc2 = l;
+            }), i.length && e.each(function(a) {
+              for (var o = dd.select(this), s = 0; s < i.length; s++) i[s](o, a);
+            });
+          }
+        };
+        Ta.tryColorscale = function(e, t) {
+          var r = t ? Du.nestedProperty(e, t).get() : e;
+          if (r) {
+            var n = r.color;
+            if ((r.colorscale || r._colorAx) && Du.isArrayOrTypedArray(n)) return Xot.makeColorScaleFuncFromTrace(r);
+          }
+          return Du.identity;
+        };
+        var Hq = { start: 1, end: -1, middle: 0, bottom: 1, top: -1 };
+        function Hoe(e, t, r, n, i) {
+          var a = dd.select(e.node().parentNode), o = t.indexOf("top") !== -1 ? "top" : t.indexOf("bottom") !== -1 ? "bottom" : "middle", s = t.indexOf("left") !== -1 ? "end" : t.indexOf("right") !== -1 ? "start" : "middle", l = n ? n / 0.8 + 1 : 0, u = (gL.lineCount(e) - 1) * Kot + 1, c = Hq[s] * l, f = r * 0.75 + Hq[o] * l + (Hq[o] - 1) * u * r / 2;
+          e.attr("text-anchor", s), i || a.attr("transform", oM(c, f));
+        }
+        function joe(e, t) {
+          var r = e.ts || t.textfont.size;
+          return Db(r) && r > 0 ? r : 0;
+        }
+        Ta.textPointStyle = function(e, t, r) {
+          if (e.size()) {
+            var n;
+            if (t.selectedpoints) {
+              var i = Ta.makeSelectedTextStyleFns(t);
+              n = i.selectedTextColorFn;
+            }
+            var a = t.texttemplate, o = r._fullLayout;
+            e.each(function(s) {
+              var l = dd.select(this), u = a ? Du.extractOption(s, t, "txt", "texttemplate") : Du.extractOption(s, t, "tx", "text");
+              if (!u && u !== 0) {
+                l.remove();
+                return;
+              }
+              if (a) {
+                var c = t._module.formatLabels, f = c ? c(s, t, o) : {}, h = {};
+                Qot(h, t, s.i), u = Du.texttemplateString({ data: [h, s, t._meta], fallback: t.texttemplatefallback, labels: f, locale: o._d3locale, template: u });
+              }
+              var d = s.tp || t.textposition, v = joe(s, t), _ = n ? n(s) : s.tc || t.textfont.color;
+              l.call(Ta.font, { family: s.tf || t.textfont.family, weight: s.tw || t.textfont.weight, style: s.ty || t.textfont.style, variant: s.tv || t.textfont.variant, textcase: s.tC || t.textfont.textcase, lineposition: s.tE || t.textfont.lineposition, shadow: s.tS || t.textfont.shadow, size: v, color: _ }).text(u).call(gL.convertToTspans, r).call(Hoe, d, v, s.mrc);
+            });
+          }
+        };
+        Ta.selectedTextStyle = function(e, t) {
+          if (!(!e.size() || !t.selectedpoints)) {
+            var r = Ta.makeSelectedTextStyleFns(t);
+            e.each(function(n) {
+              var i = dd.select(this), a = r.selectedTextColorFn(n), o = n.tp || t.textposition, s = joe(n, t);
+              Yd.fill(i, a);
+              var l = pL.traceIs(t, "bar-like");
+              Hoe(i, o, s, n.mrc2 || n.mrc, l);
+            });
+          }
+        };
+        var Ioe = 0.5;
+        Ta.smoothopen = function(e, t) {
+          if (e.length < 3) return "M" + e.join("L");
+          var r = "M" + e[0], n = [], i;
+          for (i = 1; i < e.length - 1; i++) n.push(vL(e[i - 1], e[i], e[i + 1], t));
+          for (r += "Q" + n[0][0] + " " + e[1], i = 2; i < e.length - 1; i++) r += "C" + n[i - 2][1] + " " + n[i - 1][0] + " " + e[i];
+          return r += "Q" + n[e.length - 3][1] + " " + e[e.length - 1], r;
+        };
+        Ta.smoothclosed = function(e, t) {
+          if (e.length < 3) return "M" + e.join("L") + "Z";
+          var r = "M" + e[0], n = e.length - 1, i = [vL(e[n], e[0], e[1], t)], a;
+          for (a = 1; a < n; a++) i.push(vL(e[a - 1], e[a], e[a + 1], t));
+          for (i.push(vL(e[n - 1], e[n], e[0], t)), a = 1; a <= n; a++) r += "C" + i[a - 1][1] + " " + i[a][0] + " " + e[a];
+          return r += "C" + i[n][1] + " " + i[0][0] + " " + e[0] + "Z", r;
+        };
+        var Woe, Xoe;
+        function q3(e, t, r) {
+          return r && (e = Zoe(e)), t ? Rb(e[1]) : Ib(e[0]);
+        }
+        function Ib(e) {
+          var t = dd.round(e, 2);
+          return Woe = t, t;
+        }
+        function Rb(e) {
+          var t = dd.round(e, 2);
+          return Xoe = t, t;
+        }
+        function vL(e, t, r, n) {
+          var i = e[0] - t[0], a = e[1] - t[1], o = r[0] - t[0], s = r[1] - t[1], l = Math.pow(i * i + a * a, Ioe / 2), u = Math.pow(o * o + s * s, Ioe / 2), c = (u * u * i - l * l * o) * n, f = (u * u * a - l * l * s) * n, h = 3 * u * (l + u), d = 3 * l * (l + u);
+          return [[Ib(t[0] + (h && c / h)), Rb(t[1] + (h && f / h))], [Ib(t[0] - (d && c / d)), Rb(t[1] - (d && f / d))]];
+        }
+        var ast = { hv: function(e, t, r) {
+          return "H" + Ib(t[0]) + "V" + q3(t, 1, r);
+        }, vh: function(e, t, r) {
+          return "V" + Rb(t[1]) + "H" + q3(t, 0, r);
+        }, hvh: function(e, t, r) {
+          return "H" + Ib((e[0] + t[0]) / 2) + "V" + Rb(t[1]) + "H" + q3(t, 0, r);
+        }, vhv: function(e, t, r) {
+          return "V" + Rb((e[1] + t[1]) / 2) + "H" + Ib(t[0]) + "V" + q3(t, 1, r);
+        } }, ost = function(e, t, r) {
+          return "L" + q3(t, 0, r) + "," + q3(t, 1, r);
+        };
+        Ta.steps = function(e) {
+          var t = ast[e] || ost;
+          return function(r) {
+            for (var n = "M" + Ib(r[0][0]) + "," + Rb(r[0][1]), i = r.length, a = 1; a < i; a++) n += t(r[a - 1], r[a], a === i - 1);
+            return n;
+          };
+        };
+        function Zoe(e, t) {
+          var r = e.backoff, n = e.trace, i = e.d, a = e.i;
+          if (r && n && n.marker && n.marker.angle % 360 === 0 && n.line && n.line.shape !== "spline") {
+            var o = Du.isArrayOrTypedArray(r), s = e, l = t ? t[0] : Woe || 0, u = t ? t[1] : Xoe || 0, c = s[0], f = s[1], h = c - l, d = f - u, v = Math.atan2(d, h), _ = o ? r[a] : r;
+            if (_ === "auto") {
+              var b = s.i;
+              n.type === "scatter" && b--;
+              var p = s.marker, k = p.symbol;
+              Du.isArrayOrTypedArray(k) && (k = k[b]);
+              var E = p.size;
+              Du.isArrayOrTypedArray(E) && (E = E[b]), _ = p ? Ta.symbolBackOffs[Ta.symbolNumber(k)] * E : 0, _ += Ta.getMarkerStandoff(i[b], n) || 0;
+            }
+            var T = c - _ * Math.cos(v), L = f - _ * Math.sin(v);
+            (T <= c && T >= l || T >= c && T <= l) && (L <= f && L >= u || L >= f && L <= u) && (e = [T, L]);
+          }
+          return e;
+        }
+        Ta.applyBackoff = Zoe;
+        Ta.makeTester = function() {
+          var e = Du.ensureSingleById(dd.select("body"), "svg", "js-plotly-tester", function(r) {
+            r.attr(Zot.svgAttrs).style({ position: "absolute", left: "-10000px", top: "-10000px", width: "9000px", height: "9000px", "z-index": "1" });
+          }), t = Du.ensureSingle(e, "path", "js-reference-point", function(r) {
+            r.attr("d", "M0,0H1V1H0Z").style({ "stroke-width": 0, fill: "black" });
+          });
+          Ta.tester = e, Ta.testref = t;
+        };
+        Ta.savedBBoxes = {};
+        var jq = 0, sst = 1e4;
+        Ta.bBox = function(e, t, r) {
+          r || (r = Roe(e));
+          var n;
+          if (r) {
+            if (n = Ta.savedBBoxes[r], n) return Du.extendFlat({}, n);
+          } else if (e.childNodes.length === 1) {
+            var i = e.childNodes[0];
+            if (r = Roe(i), r) {
+              var a = +i.getAttribute("x") || 0, o = +i.getAttribute("y") || 0, s = i.getAttribute("transform");
+              if (!s) {
+                var l = Ta.bBox(i, false, r);
+                return a && (l.left += a, l.right += a), o && (l.top += o, l.bottom += o), l;
+              }
+              if (r += "~" + a + "~" + o + "~" + s, n = Ta.savedBBoxes[r], n) return Du.extendFlat({}, n);
+            }
+          }
+          var u, c;
+          t ? u = e : (c = Ta.tester.node(), u = e.cloneNode(true), c.appendChild(u)), dd.select(u).attr("transform", null).call(gL.positionText, 0, 0);
+          var f = u.getBoundingClientRect(), h = Ta.testref.node().getBoundingClientRect();
+          t || c.removeChild(u);
+          var d = { height: f.height, width: f.width, left: f.left - h.left, top: f.top - h.top, right: f.right - h.left, bottom: f.bottom - h.top };
+          return jq >= sst && (Ta.savedBBoxes = {}, jq = 0), r && (Ta.savedBBoxes[r] = d), jq++, Du.extendFlat({}, d);
+        };
+        function Roe(e) {
+          var t = e.getAttribute("data-unformatted");
+          if (t !== null) return t + e.getAttribute("data-math") + e.getAttribute("text-anchor") + e.getAttribute("style");
+        }
+        Ta.setClipUrl = function(e, t, r) {
+          e.attr("clip-path", Yq(t, r));
+        };
+        function Yq(e, t) {
+          if (!e) return null;
+          var r = t._context, n = r._exportedPlot ? "" : r._baseUrl || "";
+          return n ? "url('" + n + "#" + e + "')" : "url(#" + e + ")";
+        }
+        Ta.getTranslate = function(e) {
+          var t = /.*\btranslate\((-?\d*\.?\d*)[^-\d]*(-?\d*\.?\d*)[^\d].*/, r = e.attr ? "attr" : "getAttribute", n = e[r]("transform") || "", i = n.replace(t, function(a, o, s) {
+            return [o, s].join(" ");
+          }).split(" ");
+          return { x: +i[0] || 0, y: +i[1] || 0 };
+        };
+        Ta.setTranslate = function(e, t, r) {
+          var n = /(\btranslate\(.*?\);?)/, i = e.attr ? "attr" : "getAttribute", a = e.attr ? "attr" : "setAttribute", o = e[i]("transform") || "";
+          return t = t || 0, r = r || 0, o = o.replace(n, "").trim(), o += oM(t, r), o = o.trim(), e[a]("transform", o), o;
+        };
+        Ta.getScale = function(e) {
+          var t = /.*\bscale\((\d*\.?\d*)[^\d]*(\d*\.?\d*)[^\d].*/, r = e.attr ? "attr" : "getAttribute", n = e[r]("transform") || "", i = n.replace(t, function(a, o, s) {
+            return [o, s].join(" ");
+          }).split(" ");
+          return { x: +i[0] || 1, y: +i[1] || 1 };
+        };
+        Ta.setScale = function(e, t, r) {
+          var n = /(\bscale\(.*?\);?)/, i = e.attr ? "attr" : "getAttribute", a = e.attr ? "attr" : "setAttribute", o = e[i]("transform") || "";
+          return t = t || 1, r = r || 1, o = o.replace(n, "").trim(), o += "scale(" + t + "," + r + ")", o = o.trim(), e[a]("transform", o), o;
+        };
+        var lst = /\s*sc.*/;
+        Ta.setPointGroupScale = function(e, t, r) {
+          if (t = t || 1, r = r || 1, !!e) {
+            var n = t === 1 && r === 1 ? "" : "scale(" + t + "," + r + ")";
+            e.each(function() {
+              var i = (this.getAttribute("transform") || "").replace(lst, "");
+              i += n, i = i.trim(), this.setAttribute("transform", i);
+            });
+          }
+        };
+        var ust = /translate\([^)]*\)\s*$/;
+        Ta.setTextPointsScale = function(e, t, r) {
+          e && e.each(function() {
+            var n, i = dd.select(this), a = i.select("text");
+            if (a.node()) {
+              var o = parseFloat(a.attr("x") || 0), s = parseFloat(a.attr("y") || 0), l = (i.attr("transform") || "").match(ust);
+              t === 1 && r === 1 ? n = [] : n = [oM(o, s), "scale(" + t + "," + r + ")", oM(-o, -s)], l && n.push(l), i.attr("transform", n.join(""));
+            }
+          });
+        };
+        function Kq(e, t) {
+          var r;
+          return e && (r = e.mf), r === void 0 && (r = t.marker && t.marker.standoff || 0), !t._geo && !t._xA ? -r : r;
+        }
+        Ta.getMarkerStandoff = Kq;
+        var aM = Math.atan2, Pb = Math.cos, B3 = Math.sin;
+        function Doe(e, t) {
+          var r = t[0], n = t[1];
+          return [r * Pb(e) - n * B3(e), r * B3(e) + n * Pb(e)];
+        }
+        var Foe, zoe, Ooe, qoe, Wq, Xq;
+        function Jq(e, t) {
+          var r = e.ma;
+          r === void 0 && (r = t.marker.angle, (!r || Du.isArrayOrTypedArray(r)) && (r = 0));
+          var n, i, a = t.marker.angleref;
+          if (a === "previous" || a === "north") {
+            if (t._geo) {
+              var o = t._geo.project(e.lonlat);
+              n = o[0], i = o[1];
+            } else {
+              var s = t._xA, l = t._yA;
+              if (s && l) n = s.c2p(e.x), i = l.c2p(e.y);
+              else return 90;
+            }
+            if (t._geo) {
+              var u = e.lonlat[0], c = e.lonlat[1], f = t._geo.project([u, c + 1e-5]), h = t._geo.project([u + 1e-5, c]), d = aM(h[1] - i, h[0] - n), v = aM(f[1] - i, f[0] - n), _;
+              if (a === "north") _ = r / 180 * Math.PI;
+              else if (a === "previous") {
+                var b = u / 180 * Math.PI, p = c / 180 * Math.PI, k = Foe / 180 * Math.PI, E = zoe / 180 * Math.PI, T = k - b, L = Pb(E) * B3(T), x = B3(E) * Pb(p) - Pb(E) * B3(p) * Pb(T);
+                _ = -aM(L, x) - Math.PI, Foe = u, zoe = c;
+              }
+              var C = Doe(d, [Pb(_), 0]), M = Doe(v, [B3(_), 0]);
+              r = aM(C[1] + M[1], C[0] + M[0]) / Math.PI * 180, a === "previous" && !(Xq === t.uid && e.i === Wq + 1) && (r = null);
+            }
+            if (a === "previous" && !t._geo) if (Xq === t.uid && e.i === Wq + 1 && Db(n) && Db(i)) {
+              var g = n - Ooe, P = i - qoe, A = t.line && t.line.shape || "", z = A.slice(A.length - 1);
+              z === "h" && (P = 0), z === "v" && (g = 0), r += aM(P, g) / Math.PI * 180 + 90;
+            } else r = null;
+          }
+          return Ooe = n, qoe = i, Wq = e.i, Xq = t.uid, r;
+        }
+        Ta.getMarkerAngle = Jq;
+      });
+      var zb = ye(($nr, Qoe) => {
+        var N3 = Oa(), cst = Eo(), fst = Mc(), $q = qa(), Fb = Dr(), Koe = Fb.strTranslate, mL = So(), yL = ka(), U3 = Zl(), Joe = X1(), hst = Dh().OPPOSITE_SIDE, $oe = / [XY][0-9]* /, Qq = 1.6, eB = 1.6;
+        function dst(e, t, r) {
+          var n = e._fullLayout, i = r.propContainer, a = r.propName, o = r.placeholder, s = r.traceIndex, l = r.avoid || {}, u = r.attributes, c = r.transform, f = r.containerGroup, h = 1, d = i.title, v = (d && d.text ? d.text : "").trim(), _ = false, b = d && d.font ? d.font : {}, p = b.family, k = b.size, E = b.color, T = b.weight, L = b.style, x = b.variant, C = b.textcase, M = b.lineposition, g = b.shadow, P = r.subtitlePropName, A = !!P, z = r.subtitlePlaceholder, O = (i.title || {}).subtitle || { text: "", font: {} }, U = (O.text || "").trim(), G = false, Z = 1, j = O.font, N = j.family, H = j.size, re = j.color, oe = j.weight, _e = j.style, Ce = j.variant, Le = j.textcase, ge = j.lineposition, ie = j.shadow, Se;
+          a === "title.text" ? Se = "titleText" : a.indexOf("axis") !== -1 ? Se = "axisTitleText" : a.indexOf("colorbar") !== -1 && (Se = "colorbarTitleText");
+          var Ee = e._context.edits[Se];
+          function Ae(Nt, $t) {
+            return Nt === void 0 || $t === void 0 ? false : Nt.replace($oe, " % ") === $t.replace($oe, " % ");
+          }
+          v === "" ? h = 0 : Ae(v, o) && (Ee || (v = ""), h = 0.2, _ = true), A && (U === "" ? Z = 0 : Ae(U, z) && (Ee || (U = ""), Z = 0.2, G = true)), r._meta ? v = Fb.templateString(v, r._meta) : n._meta && (v = Fb.templateString(v, n._meta));
+          var Be = v || U || Ee, Pe;
+          f || (f = Fb.ensureSingle(n._infolayer, "g", "g-" + t), Pe = n._hColorbarMoveTitle);
+          var me = f.selectAll("text." + t).data(Be ? [0] : []);
+          me.enter().append("text"), me.text(v).attr("class", t), me.exit().remove();
+          var De = null, ce = t + "-subtitle", je = U || Ee;
+          if (A && (De = f.selectAll("text." + ce).data(je ? [0] : []), De.enter().append("text"), De.text(U).attr("class", ce), De.exit().remove()), !Be) return f;
+          function lt(Nt, $t) {
+            Fb.syncOrAsync([pt, Vt], { title: Nt, subtitle: $t });
+          }
+          function pt(Nt) {
+            var $t = Nt.title, sr = Nt.subtitle, Tr;
+            !c && Pe && (c = {}), c ? (Tr = "", c.rotate && (Tr += "rotate(" + [c.rotate, u.x, u.y] + ")"), (c.offset || Pe) && (Tr += Koe(0, (c.offset || 0) - (Pe || 0)))) : Tr = null, $t.attr("transform", Tr);
+            function fr(It) {
+              if (It) {
+                var mt = N3.select(It.node().parentNode).select("." + ce);
+                if (!mt.empty()) {
+                  var er = It.node().getBBox();
+                  if (er.height) {
+                    var lr = er.y + er.height + Qq * H;
+                    mt.attr("y", lr);
+                  }
+                }
+              }
+            }
+            if ($t.style("opacity", h * yL.opacity(E)).call(mL.font, { color: yL.rgb(E), size: N3.round(k, 2), family: p, weight: T, style: L, variant: x, textcase: C, shadow: g, lineposition: M }).attr(u).call(U3.convertToTspans, e, fr), sr && !sr.empty()) {
+              var $e = f.select("." + t + "-math-group"), St = $t.node().getBBox(), Qt = $e.node() ? $e.node().getBBox() : void 0, Gt = Qt ? Qt.y + Qt.height + Qq * H : St.y + St.height + eB * H, _t = Fb.extendFlat({}, u, { y: Gt });
+              sr.attr("transform", Tr), sr.style("opacity", Z * yL.opacity(re)).call(mL.font, { color: yL.rgb(re), size: N3.round(H, 2), family: N, weight: oe, style: _e, variant: Ce, textcase: Le, shadow: ie, lineposition: ge }).attr(_t).call(U3.convertToTspans, e);
+            }
+            return fst.previousPromises(e);
+          }
+          function Vt(Nt) {
+            var $t = Nt.title, sr = N3.select($t.node().parentNode);
+            if (l && l.selection && l.side && v) {
+              sr.attr("transform", null);
+              var Tr = hst[l.side], fr = l.side === "left" || l.side === "top" ? -1 : 1, $e = cst(l.pad) ? l.pad : 2, St = mL.bBox(sr.node()), Qt = { t: 0, b: 0, l: 0, r: 0 }, Gt = e._fullLayout._reservedMargin;
+              for (var _t in Gt) for (var It in Gt[_t]) {
+                var mt = Gt[_t][It];
+                Qt[It] = Math.max(Qt[It], mt);
+              }
+              var er = { left: Qt.l, top: Qt.t, right: n.width - Qt.r, bottom: n.height - Qt.b }, lr = l.maxShift || fr * (er[l.side] - St[l.side]), wr = 0;
+              if (lr < 0) wr = lr;
+              else {
+                var Lr = l.offsetLeft || 0, ti = l.offsetTop || 0;
+                St.left -= Lr, St.right -= Lr, St.top -= ti, St.bottom -= ti, l.selection.each(function() {
+                  var Vr = mL.bBox(this);
+                  Fb.bBoxIntersect(St, Vr, $e) && (wr = Math.max(wr, fr * (Vr[l.side] - St[Tr]) + $e));
+                }), wr = Math.min(lr, wr), i._titleScoot = Math.abs(wr);
+              }
+              if (wr > 0 || lr < 0) {
+                var Br = { left: [-wr, 0], right: [wr, 0], top: [0, -wr], bottom: [0, wr] }[l.side];
+                sr.attr("transform", Koe(Br[0], Br[1]));
+              }
+            }
+          }
+          me.call(lt, De);
+          function ot(Nt, $t) {
+            Nt.text($t).on("mouseover.opacity", function() {
+              N3.select(this).transition().duration(Joe.SHOW_PLACEHOLDER).style("opacity", 1);
+            }).on("mouseout.opacity", function() {
+              N3.select(this).transition().duration(Joe.HIDE_PLACEHOLDER).style("opacity", 0);
+            });
+          }
+          if (Ee && (v ? me.on(".opacity", null) : (ot(me, o), _ = true), me.call(U3.makeEditable, { gd: e }).on("edit", function(Nt) {
+            s !== void 0 ? $q.call("_guiRestyle", e, a, Nt, s) : $q.call("_guiRelayout", e, a, Nt);
+          }).on("cancel", function() {
+            this.text(this.attr("data-unformatted")).call(lt);
+          }).on("input", function(Nt) {
+            this.text(Nt || " ").call(U3.positionText, u.x, u.y);
+          }), A)) {
+            if (A && !v) {
+              var ut = me.node().getBBox(), Wt = ut.y + ut.height + eB * H;
+              De.attr("y", Wt);
+            }
+            U ? De.on(".opacity", null) : (ot(De, z), G = true), De.call(U3.makeEditable, { gd: e }).on("edit", function(Nt) {
+              $q.call("_guiRelayout", e, "title.subtitle.text", Nt);
+            }).on("cancel", function() {
+              this.text(this.attr("data-unformatted")).call(lt);
+            }).on("input", function(Nt) {
+              this.text(Nt || " ").call(U3.positionText, De.attr("x"), De.attr("y"));
+            });
+          }
+          return me.classed("js-placeholder", _), De && !De.empty() && De.classed("js-placeholder", G), f;
+        }
+        Qoe.exports = { draw: dst, SUBTITLE_PADDING_EM: eB, SUBTITLE_PADDING_MATHJAX_EM: Qq };
+      });
+      var xm = ye((Qnr, nse) => {
+        var vst = Oa(), pst = f3().utcFormat, yc = Dr(), gst = yc.numberFormat, ym = Eo(), f_ = yc.cleanNumber, mst = yc.ms2DateTime, ese = yc.dateTime2ms, _m = yc.ensureNumber, tse = yc.isArrayOrTypedArray, h_ = fs(), _L = h_.FP_SAFE, Sg = h_.BADNUM, yst = h_.LOG_CLIP, _st = h_.ONEWEEK, xL = h_.ONEDAY, bL = h_.ONEHOUR, rse = h_.ONEMIN, ise = h_.ONESEC, wL = hf(), SL = Rh(), TL = SL.HOUR_PATTERN, AL = SL.WEEKDAY_PATTERN;
+        function sM(e) {
+          return Math.pow(10, e);
+        }
+        function tB(e) {
+          return e != null;
+        }
+        nse.exports = function(t, r) {
+          r = r || {};
+          var n = t._id || "x", i = n.charAt(0);
+          function a(T, L) {
+            if (T > 0) return Math.log(T) / Math.LN10;
+            if (T <= 0 && L && t.range && t.range.length === 2) {
+              var x = t.range[0], C = t.range[1];
+              return 0.5 * (x + C - 2 * yst * Math.abs(x - C));
+            } else return Sg;
+          }
+          function o(T, L, x, C) {
+            if ((C || {}).msUTC && ym(T)) return +T;
+            var M = ese(T, x || t.calendar);
+            if (M === Sg) if (ym(T)) {
+              T = +T;
+              var g = Math.floor(yc.mod(T + 0.05, 1) * 10), P = Math.round(T - g / 10);
+              M = ese(new Date(P)) + g / 10;
+            } else return Sg;
+            return M;
+          }
+          function s(T, L, x) {
+            return mst(T, L, x || t.calendar);
+          }
+          function l(T) {
+            return t._categories[Math.round(T)];
+          }
+          function u(T) {
+            if (tB(T)) {
+              if (t._categoriesMap === void 0 && (t._categoriesMap = {}), t._categoriesMap[T] !== void 0) return t._categoriesMap[T];
+              t._categories.push(typeof T == "number" ? String(T) : T);
+              var L = t._categories.length - 1;
+              return t._categoriesMap[T] = L, L;
+            }
+            return Sg;
+          }
+          function c(T, L) {
+            for (var x = new Array(L), C = 0; C < L; C++) {
+              var M = (T[0] || [])[C], g = (T[1] || [])[C];
+              x[C] = f([M, g]);
+            }
+            return x;
+          }
+          function f(T) {
+            if (t._categoriesMap) return t._categoriesMap[T];
+          }
+          function h(T) {
+            var L = f(T);
+            if (L !== void 0) return L;
+            if (ym(T)) return +T;
+          }
+          function d(T) {
+            return ym(T) ? +T : f(T);
+          }
+          function v(T, L, x) {
+            return vst.round(x + L * T, 2);
+          }
+          function _(T, L, x) {
+            return (T - x) / L;
+          }
+          var b = function(L) {
+            return ym(L) ? v(L, t._m, t._b) : Sg;
+          }, p = function(T) {
+            return _(T, t._m, t._b);
+          };
+          if (t.rangebreaks) {
+            var k = i === "y";
+            b = function(T) {
+              if (!ym(T)) return Sg;
+              var L = t._rangebreaks.length;
+              if (!L) return v(T, t._m, t._b);
+              var x = k;
+              t.range[0] > t.range[1] && (x = !x);
+              for (var C = x ? -1 : 1, M = C * T, g = 0, P = 0; P < L; P++) {
+                var A = C * t._rangebreaks[P].min, z = C * t._rangebreaks[P].max;
+                if (M < A) break;
+                if (M > z) g = P + 1;
+                else {
+                  g = M < (A + z) / 2 ? P : P + 1;
+                  break;
+                }
+              }
+              var O = t._B[g] || 0;
+              return isFinite(O) ? v(T, t._m2, O) : 0;
+            }, p = function(T) {
+              var L = t._rangebreaks.length;
+              if (!L) return _(T, t._m, t._b);
+              for (var x = 0, C = 0; C < L && !(T < t._rangebreaks[C].pmin); C++) T > t._rangebreaks[C].pmax && (x = C + 1);
+              return _(T, t._m2, t._B[x]);
+            };
+          }
+          t.c2l = t.type === "log" ? a : _m, t.l2c = t.type === "log" ? sM : _m, t.l2p = b, t.p2l = p, t.c2p = t.type === "log" ? function(T, L) {
+            return b(a(T, L));
+          } : b, t.p2c = t.type === "log" ? function(T) {
+            return sM(p(T));
+          } : p, ["linear", "-"].indexOf(t.type) !== -1 ? (t.d2r = t.r2d = t.d2c = t.r2c = t.d2l = t.r2l = f_, t.c2d = t.c2r = t.l2d = t.l2r = _m, t.d2p = t.r2p = function(T) {
+            return t.l2p(f_(T));
+          }, t.p2d = t.p2r = p, t.cleanPos = _m) : t.type === "log" ? (t.d2r = t.d2l = function(T, L) {
+            return a(f_(T), L);
+          }, t.r2d = t.r2c = function(T) {
+            return sM(f_(T));
+          }, t.d2c = t.r2l = f_, t.c2d = t.l2r = _m, t.c2r = a, t.l2d = sM, t.d2p = function(T, L) {
+            return t.l2p(t.d2r(T, L));
+          }, t.p2d = function(T) {
+            return sM(p(T));
+          }, t.r2p = function(T) {
+            return t.l2p(f_(T));
+          }, t.p2r = p, t.cleanPos = _m) : t.type === "date" ? (t.d2r = t.r2d = yc.identity, t.d2c = t.r2c = t.d2l = t.r2l = o, t.c2d = t.c2r = t.l2d = t.l2r = s, t.d2p = t.r2p = function(T, L, x) {
+            return t.l2p(o(T, 0, x));
+          }, t.p2d = t.p2r = function(T, L, x) {
+            return s(p(T), L, x);
+          }, t.cleanPos = function(T) {
+            return yc.cleanDate(T, Sg, t.calendar);
+          }) : t.type === "category" ? (t.d2c = t.d2l = u, t.r2d = t.c2d = t.l2d = l, t.d2r = t.d2l_noadd = h, t.r2c = function(T) {
+            var L = d(T);
+            return L !== void 0 ? L : t.fraction2r(0.5);
+          }, t.l2r = t.c2r = _m, t.r2l = d, t.d2p = function(T) {
+            return t.l2p(t.r2c(T));
+          }, t.p2d = function(T) {
+            return l(p(T));
+          }, t.r2p = t.d2p, t.p2r = p, t.cleanPos = function(T) {
+            return typeof T == "string" && T !== "" ? T : _m(T);
+          }) : t.type === "multicategory" && (t.r2d = t.c2d = t.l2d = l, t.d2r = t.d2l_noadd = h, t.r2c = function(T) {
+            var L = h(T);
+            return L !== void 0 ? L : t.fraction2r(0.5);
+          }, t.r2c_just_indices = f, t.l2r = t.c2r = _m, t.r2l = h, t.d2p = function(T) {
+            return t.l2p(t.r2c(T));
+          }, t.p2d = function(T) {
+            return l(p(T));
+          }, t.r2p = t.d2p, t.p2r = p, t.cleanPos = function(T) {
+            return Array.isArray(T) || typeof T == "string" && T !== "" ? T : _m(T);
+          }, t.setupMultiCategory = function(T) {
+            var L = t._traceIndices, x, C, M = t._matchGroup;
+            if (M && t._categories.length === 0) {
+              for (var g in M) if (g !== n) {
+                var P = r[wL.id2name(g)];
+                L = L.concat(P._traceIndices);
+              }
+            }
+            var A = [[0, {}], [0, {}]], z = [];
+            for (x = 0; x < L.length; x++) {
+              var O = T[L[x]];
+              if (i in O) {
+                var U = O[i], G = O._length || yc.minRowLength(U);
+                if (tse(U[0]) && tse(U[1])) for (C = 0; C < G; C++) {
+                  var Z = U[0][C], j = U[1][C];
+                  tB(Z) && tB(j) && (z.push([Z, j]), Z in A[0][1] || (A[0][1][Z] = A[0][0]++), j in A[1][1] || (A[1][1][j] = A[1][0]++));
+                }
+              }
+            }
+            for (z.sort(function(N, H) {
+              var re = A[0][1], oe = re[N[0]] - re[H[0]];
+              if (oe) return oe;
+              var _e = A[1][1];
+              return _e[N[1]] - _e[H[1]];
+            }), x = 0; x < z.length; x++) u(z[x]);
+          }), t.fraction2r = function(T) {
+            var L = t.r2l(t.range[0]), x = t.r2l(t.range[1]);
+            return t.l2r(L + T * (x - L));
+          }, t.r2fraction = function(T) {
+            var L = t.r2l(t.range[0]), x = t.r2l(t.range[1]);
+            return (t.r2l(T) - L) / (x - L);
+          }, t.limitRange = function(T) {
+            var L = t.minallowed, x = t.maxallowed;
+            if (!(L === void 0 && x === void 0)) {
+              T || (T = "range");
+              var C = yc.nestedProperty(t, T).get(), M = yc.simpleMap(C, t.r2l), g = M[1] < M[0];
+              g && M.reverse();
+              var P = yc.simpleMap([L, x], t.r2l);
+              if (L !== void 0 && M[0] < P[0] && (C[g ? 1 : 0] = L), x !== void 0 && M[1] > P[1] && (C[g ? 0 : 1] = x), C[0] === C[1]) {
+                var A = t.l2r(L), z = t.l2r(x);
+                if (L !== void 0) {
+                  var O = A + 1;
+                  x !== void 0 && (O = Math.min(O, z)), C[g ? 1 : 0] = O;
+                }
+                if (x !== void 0) {
+                  var U = z + 1;
+                  L !== void 0 && (U = Math.max(U, A)), C[g ? 0 : 1] = U;
+                }
+              }
+            }
+          }, t.cleanRange = function(T, L) {
+            t._cleanRange(T, L), t.limitRange(T);
+          }, t._cleanRange = function(T, L) {
+            L || (L = {}), T || (T = "range");
+            var x = yc.nestedProperty(t, T).get(), C, M;
+            if (t.type === "date" ? M = yc.dfltRange(t.calendar) : i === "y" ? M = SL.DFLTRANGEY : t._name === "realaxis" ? M = [0, 1] : M = L.dfltRange || SL.DFLTRANGEX, M = M.slice(), (t.rangemode === "tozero" || t.rangemode === "nonnegative") && (M[0] = 0), !x || x.length !== 2) {
+              yc.nestedProperty(t, T).set(M);
+              return;
+            }
+            var g = x[0] === null, P = x[1] === null;
+            for (t.type === "date" && !t.autorange && (x[0] = yc.cleanDate(x[0], Sg, t.calendar), x[1] = yc.cleanDate(x[1], Sg, t.calendar)), C = 0; C < 2; C++) if (t.type === "date") {
+              if (!yc.isDateTime(x[C], t.calendar)) {
+                t[T] = M;
+                break;
+              }
+              if (t.r2l(x[0]) === t.r2l(x[1])) {
+                var A = yc.constrain(t.r2l(x[0]), yc.MIN_MS + 1e3, yc.MAX_MS - 1e3);
+                x[0] = t.l2r(A - 1e3), x[1] = t.l2r(A + 1e3);
+                break;
+              }
+            } else {
+              if (!ym(x[C])) if (!(g || P) && ym(x[1 - C])) x[C] = x[1 - C] * (C ? 10 : 0.1);
+              else {
+                t[T] = M;
+                break;
+              }
+              if (x[C] < -_L ? x[C] = -_L : x[C] > _L && (x[C] = _L), x[0] === x[1]) {
+                var z = Math.max(1, Math.abs(x[0] * 1e-6));
+                x[0] -= z, x[1] += z;
+              }
+            }
+          }, t.setScale = function(T) {
+            var L = r._size;
+            if (t.overlaying) {
+              var x = wL.getFromId({ _fullLayout: r }, t.overlaying);
+              t.domain = x.domain;
+            }
+            var C = T && t._r ? "_r" : "range", M = t.calendar;
+            t.cleanRange(C);
+            var g = t.r2l(t[C][0], M), P = t.r2l(t[C][1], M), A = i === "y";
+            if (A ? (t._offset = L.t + (1 - t.domain[1]) * L.h, t._length = L.h * (t.domain[1] - t.domain[0]), t._m = t._length / (g - P), t._b = -t._m * P) : (t._offset = L.l + t.domain[0] * L.w, t._length = L.w * (t.domain[1] - t.domain[0]), t._m = t._length / (P - g), t._b = -t._m * g), t._rangebreaks = [], t._lBreaks = 0, t._m2 = 0, t._B = [], t.rangebreaks) {
+              var z, O;
+              if (t._rangebreaks = t.locateBreaks(Math.min(g, P), Math.max(g, P)), t._rangebreaks.length) {
+                for (z = 0; z < t._rangebreaks.length; z++) O = t._rangebreaks[z], t._lBreaks += Math.abs(O.max - O.min);
+                var U = A;
+                g > P && (U = !U), U && t._rangebreaks.reverse();
+                var G = U ? -1 : 1;
+                for (t._m2 = G * t._length / (Math.abs(P - g) - t._lBreaks), t._B.push(-t._m2 * (A ? P : g)), z = 0; z < t._rangebreaks.length; z++) O = t._rangebreaks[z], t._B.push(t._B[t._B.length - 1] - G * t._m2 * (O.max - O.min));
+                for (z = 0; z < t._rangebreaks.length; z++) O = t._rangebreaks[z], O.pmin = b(O.min), O.pmax = b(O.max);
+              }
+            }
+            if (!isFinite(t._m) || !isFinite(t._b) || t._length < 0) throw r._replotting = false, new Error("Something went wrong with axis scaling");
+          }, t.maskBreaks = function(T) {
+            var L = t.rangebreaks || [], x, C, M, g, P;
+            L._cachedPatterns || (L._cachedPatterns = L.map(function(re) {
+              return re.enabled && re.bounds ? yc.simpleMap(re.bounds, re.pattern ? f_ : t.d2c) : null;
+            })), L._cachedValues || (L._cachedValues = L.map(function(re) {
+              return re.enabled && re.values ? yc.simpleMap(re.values, t.d2c).sort(yc.sorterAsc) : null;
+            }));
+            for (var A = 0; A < L.length; A++) {
+              var z = L[A];
+              if (z.enabled) {
+                if (z.bounds) {
+                  var O = z.pattern;
+                  switch (x = L._cachedPatterns[A], C = x[0], M = x[1], O) {
+                    case AL:
+                      P = new Date(T), g = P.getUTCDay(), C > M && (M += 7, g < C && (g += 7));
+                      break;
+                    case TL:
+                      P = new Date(T);
+                      var U = P.getUTCHours(), G = P.getUTCMinutes(), Z = P.getUTCSeconds(), j = P.getUTCMilliseconds();
+                      g = U + (G / 60 + Z / 3600 + j / 36e5), C > M && (M += 24, g < C && (g += 24));
+                      break;
+                    case "":
+                      g = T;
+                      break;
+                  }
+                  if (g >= C && g < M) return Sg;
+                } else for (var N = L._cachedValues[A], H = 0; H < N.length; H++) if (C = N[H], M = C + z.dvalue, T >= C && T < M) return Sg;
+              }
+            }
+            return T;
+          }, t.locateBreaks = function(T, L) {
+            var x, C, M, g, P = [];
+            if (!t.rangebreaks) return P;
+            var A = t.rangebreaks.slice().sort(function(_e, Ce) {
+              return _e.pattern === AL && Ce.pattern === TL ? -1 : Ce.pattern === AL && _e.pattern === TL ? 1 : 0;
+            }), z = function(_e, Ce) {
+              if (_e = yc.constrain(_e, T, L), Ce = yc.constrain(Ce, T, L), _e !== Ce) {
+                for (var Le = true, ge = 0; ge < P.length; ge++) {
+                  var ie = P[ge];
+                  _e < ie.max && Ce >= ie.min && (_e < ie.min && (ie.min = _e), Ce > ie.max && (ie.max = Ce), Le = false);
+                }
+                Le && P.push({ min: _e, max: Ce });
+              }
+            };
+            for (x = 0; x < A.length; x++) {
+              var O = A[x];
+              if (O.enabled) if (O.bounds) {
+                var U = T, G = L;
+                O.pattern && (U = Math.floor(U)), C = yc.simpleMap(O.bounds, O.pattern ? f_ : t.r2l), M = C[0], g = C[1];
+                var Z = new Date(U), j, N;
+                switch (O.pattern) {
+                  case AL:
+                    N = _st, j = ((g < M ? 7 : 0) + (g - M)) * xL, U += M * xL - (Z.getUTCDay() * xL + Z.getUTCHours() * bL + Z.getUTCMinutes() * rse + Z.getUTCSeconds() * ise + Z.getUTCMilliseconds());
+                    break;
+                  case TL:
+                    N = xL, j = ((g < M ? 24 : 0) + (g - M)) * bL, U += M * bL - (Z.getUTCHours() * bL + Z.getUTCMinutes() * rse + Z.getUTCSeconds() * ise + Z.getUTCMilliseconds());
+                    break;
+                  default:
+                    U = Math.min(C[0], C[1]), G = Math.max(C[0], C[1]), N = G - U, j = N;
+                }
+                for (var H = U; H < G; H += N) z(H, H + j);
+              } else for (var re = yc.simpleMap(O.values, t.d2c), oe = 0; oe < re.length; oe++) M = re[oe], g = M + O.dvalue, z(M, g);
+            }
+            return P.sort(function(_e, Ce) {
+              return _e.min - Ce.min;
+            }), P;
+          }, t.makeCalcdata = function(T, L, x) {
+            var C, M, g, P, A = t.type, z = A === "date" && T[L + "calendar"];
+            if (L in T) {
+              if (C = T[L], P = T._length || yc.minRowLength(C), yc.isTypedArray(C) && (A === "linear" || A === "log")) {
+                if (P === C.length) return C;
+                if (C.subarray) return C.subarray(0, P);
+              }
+              if (A === "multicategory") return c(C, P);
+              for (M = new Array(P), g = 0; g < P; g++) M[g] = t.d2c(C[g], 0, z, x);
+            } else {
+              var O = L + "0" in T ? t.d2c(T[L + "0"], 0, z) : 0, U = T["d" + L] ? Number(T["d" + L]) : 1;
+              for (C = T[{ x: "y", y: "x" }[L]], P = T._length || C.length, M = new Array(P), g = 0; g < P; g++) M[g] = O + g * U;
+            }
+            if (t.rangebreaks) for (g = 0; g < P; g++) M[g] = t.maskBreaks(M[g]);
+            return M;
+          }, t.isValidRange = function(T, L) {
+            return Array.isArray(T) && T.length === 2 && (L && T[0] === null || ym(t.r2l(T[0]))) && (L && T[1] === null || ym(t.r2l(T[1])));
+          }, t.getAutorangeDflt = function(T, L) {
+            var x = !t.isValidRange(T, "nullOk");
+            return x && L && L.reverseDflt ? x = "reversed" : T && (T[0] === null && T[1] === null ? x = true : T[0] === null && T[1] !== null ? x = "min" : T[0] !== null && T[1] === null && (x = "max")), x;
+          }, t.isReversed = function() {
+            var T = t.autorange;
+            return T === "reversed" || T === "min reversed" || T === "max reversed";
+          }, t.isPtWithinRange = function(T, L) {
+            var x = t.c2l(T[i], null, L), C = t.r2l(t.range[0]), M = t.r2l(t.range[1]);
+            return C < M ? C <= x && x <= M : M <= x && x <= C;
+          }, t._emptyCategories = function() {
+            t._categories = [], t._categoriesMap = {};
+          }, t.clearCalc = function() {
+            var T = t._matchGroup;
+            if (T) {
+              var L = null, x = null;
+              for (var C in T) {
+                var M = r[wL.id2name(C)];
+                if (M._categories) {
+                  L = M._categories, x = M._categoriesMap;
+                  break;
+                }
+              }
+              L && x ? (t._categories = L, t._categoriesMap = x) : t._emptyCategories();
+            } else t._emptyCategories();
+            if (t._initialCategories) for (var g = 0; g < t._initialCategories.length; g++) u(t._initialCategories[g]);
+          }, t.sortByInitialCategories = function() {
+            var T = [];
+            if (t._emptyCategories(), t._initialCategories) for (var L = 0; L < t._initialCategories.length; L++) u(t._initialCategories[L]);
+            T = T.concat(t._traceIndices);
+            var x = t._matchGroup;
+            for (var C in x) if (n !== C) {
+              var M = r[wL.id2name(C)];
+              M._categories = t._categories, M._categoriesMap = t._categoriesMap, T = T.concat(M._traceIndices);
+            }
+            return T;
+          };
+          var E = r._d3locale;
+          t.type === "date" && (t._dateFormat = E ? E.timeFormat : pst, t._extraFormat = r._extraFormat), t._separators = r.separators, t._numFormat = E ? E.numberFormat : gst, delete t._minDtick, delete t._forceTick0;
+        };
+      });
+      var V3 = ye((ear, lse) => {
+        var ase = Eo(), rB = Dr(), xst = fs().BADNUM, ML = rB.isArrayOrTypedArray, bst = rB.isDateTime, wst = rB.cleanNumber, ose = Math.round;
+        lse.exports = function(t, r, n) {
+          var i = t, a = n.noMultiCategory;
+          if (ML(i) && !i.length) return "-";
+          if (!a && Est(i)) return "multicategory";
+          if (a && Array.isArray(i[0])) {
+            for (var o = [], s = 0; s < i.length; s++) if (ML(i[s])) for (var l = 0; l < i[s].length; l++) o.push(i[s][l]);
+            i = o;
+          }
+          if (Sst(i, r)) return "date";
+          var u = n.autotypenumbers !== "strict";
+          return Mst(i, u) ? "category" : Ast(i, u) ? "linear" : "-";
+        };
+        function Tst(e, t) {
+          return t ? ase(e) : typeof e == "number";
+        }
+        function Ast(e, t) {
+          for (var r = e.length, n = 0; n < r; n++) if (Tst(e[n], t)) return true;
+          return false;
+        }
+        function Sst(e, t) {
+          for (var r = e.length, n = sse(r), i = 0, a = 0, o = {}, s = 0; s < r; s += n) {
+            var l = ose(s), u = e[l], c = String(u);
+            o[c] || (o[c] = 1, bst(u, t) && i++, ase(u) && a++);
+          }
+          return i > a * 2;
+        }
+        function sse(e) {
+          return Math.max(1, (e - 1) / 1e3);
+        }
+        function Mst(e, t) {
+          for (var r = e.length, n = sse(r), i = 0, a = 0, o = {}, s = 0; s < r; s += n) {
+            var l = ose(s), u = e[l], c = String(u);
+            if (!o[c]) {
+              o[c] = 1;
+              var f = typeof u;
+              f === "boolean" ? a++ : (t ? wst(u) !== xst : f === "number") ? i++ : f === "string" && a++;
+            }
+          }
+          return a > i * 2;
+        }
+        function Est(e) {
+          return ML(e[0]) && ML(e[1]);
+        }
+      });
+      var Mg = ye((tar, gse) => {
+        var kst = Oa(), hse = Eo(), d_ = Dr(), EL = fs().FP_SAFE, Cst = qa(), Lst = So(), dse = hf(), Pst = dse.getFromId, Ist = dse.isLinked;
+        gse.exports = { applyAutorangeOptions: pse, getAutoRange: iB, makePadFn: nB, doAutoRange: Dst, findExtremes: Fst, concatExtremes: sB };
+        function iB(e, t) {
+          var r, n, i = [], a = e._fullLayout, o = nB(a, t, 0), s = nB(a, t, 1), l = sB(e, t), u = l.min, c = l.max;
+          if (u.length === 0 || c.length === 0) return d_.simpleMap(t.range, t.r2l);
+          var f = u[0].val, h = c[0].val;
+          for (r = 1; r < u.length && f === h; r++) f = Math.min(f, u[r].val);
+          for (r = 1; r < c.length && f === h; r++) h = Math.max(h, c[r].val);
+          var d = t.autorange, v = d === "reversed" || d === "min reversed" || d === "max reversed";
+          if (!v && t.range) {
+            var _ = d_.simpleMap(t.range, t.r2l);
+            v = _[1] < _[0];
+          }
+          t.autorange === "reversed" && (t.autorange = true);
+          var b = t.rangemode, p = b === "tozero", k = b === "nonnegative", E = t._length, T = E / 10, L = 0, x, C, M, g, P, A;
+          for (r = 0; r < u.length; r++) for (x = u[r], n = 0; n < c.length; n++) C = c[n], A = C.val - x.val - use(t, x.val, C.val), A > 0 && (P = E - o(x) - s(C), P > T ? A / P > L && (M = x, g = C, L = A / P) : A / E > L && (M = { val: x.val, nopad: 1 }, g = { val: C.val, nopad: 1 }, L = A / E));
+          function z(j, N) {
+            return Math.max(j, s(N));
+          }
+          if (f === h) {
+            var O = f - 1, U = f + 1;
+            if (p) if (f === 0) i = [0, 1];
+            else {
+              var G = (f > 0 ? c : u).reduce(z, 0), Z = f / (1 - Math.min(0.5, G / E));
+              i = f > 0 ? [0, Z] : [Z, 0];
+            }
+            else k ? i = [Math.max(0, O), Math.max(1, U)] : i = [O, U];
+          } else p ? (M.val >= 0 && (M = { val: 0, nopad: 1 }), g.val <= 0 && (g = { val: 0, nopad: 1 })) : k && (M.val - L * o(M) < 0 && (M = { val: 0, nopad: 1 }), g.val <= 0 && (g = { val: 1, nopad: 1 })), L = (g.val - M.val - use(t, x.val, C.val)) / (E - o(M) - s(g)), i = [M.val - L * o(M), g.val + L * s(g)];
+          return i = pse(i, t), t.limitRange && t.limitRange(), v && i.reverse(), d_.simpleMap(i, t.l2r || Number);
+        }
+        function use(e, t, r) {
+          var n = 0;
+          if (e.rangebreaks) for (var i = e.locateBreaks(t, r), a = 0; a < i.length; a++) {
+            var o = i[a];
+            n += o.max - o.min;
+          }
+          return n;
+        }
+        function nB(e, t, r) {
+          var n = 0.05 * t._length, i = t._anchorAxis || {};
+          if ((t.ticklabelposition || "").indexOf("inside") !== -1 || (i.ticklabelposition || "").indexOf("inside") !== -1) {
+            var a = t.isReversed();
+            if (!a) {
+              var o = d_.simpleMap(t.range, t.r2l);
+              a = o[1] < o[0];
+            }
+            a && (r = !r);
+          }
+          var s = 0;
+          return Ist(e, t._id) || (s = Rst(e, t, r)), n = Math.max(s, n), t.constrain === "domain" && t._inputDomain && (n *= (t._inputDomain[1] - t._inputDomain[0]) / (t.domain[1] - t.domain[0])), function(u) {
+            return u.nopad ? 0 : u.pad + (u.extrapad ? n : s);
+          };
+        }
+        var cse = 3;
+        function Rst(e, t, r) {
+          var n = 0, i = t._id.charAt(0) === "x";
+          for (var a in e._plots) {
+            var o = e._plots[a];
+            if (!(t._id !== o.xaxis._id && t._id !== o.yaxis._id)) {
+              var s = (i ? o.yaxis : o.xaxis) || {};
+              if ((s.ticklabelposition || "").indexOf("inside") !== -1 && (!r && (s.side === "left" || s.side === "bottom") || r && (s.side === "top" || s.side === "right"))) {
+                if (s._vals) {
+                  var l = d_.deg2rad(s._tickAngles[s._id + "tick"] || 0), u = Math.abs(Math.cos(l)), c = Math.abs(Math.sin(l));
+                  if (!s._vals[0].bb) {
+                    var f = s._id + "tick", h = s._selections[f];
+                    h.each(function(k) {
+                      var E = kst.select(this), T = E.select(".text-math-group");
+                      T.empty() && (k.bb = Lst.bBox(E.node()));
+                    });
+                  }
+                  for (var d = 0; d < s._vals.length; d++) {
+                    var v = s._vals[d], _ = v.bb;
+                    if (_) {
+                      var b = 2 * cse + _.width, p = 2 * cse + _.height;
+                      n = Math.max(n, i ? Math.max(b * u, p * c) : Math.max(p * u, b * c));
+                    }
+                  }
+                }
+                s.ticks === "inside" && s.ticklabelposition === "inside" && (n += s.ticklen || 0);
+              }
+            }
+          }
+          return n;
+        }
+        function sB(e, t, r) {
+          var n = t._id, i = e._fullData, a = e._fullLayout, o = [], s = [], l, u, c;
+          function f(b, p) {
+            for (l = 0; l < p.length; l++) {
+              var k = b[p[l]], E = (k._extremes || {})[n];
+              if (k.visible === true && E) {
+                for (u = 0; u < E.min.length; u++) c = E.min[u], aB(o, c.val, c.pad, { extrapad: c.extrapad });
+                for (u = 0; u < E.max.length; u++) c = E.max[u], oB(s, c.val, c.pad, { extrapad: c.extrapad });
+              }
+            }
+          }
+          if (f(i, t._traceIndices), f(a.annotations || [], t._annIndices || []), f(a.shapes || [], t._shapeIndices || []), t._matchGroup && !r) {
+            for (var h in t._matchGroup) if (h !== t._id) {
+              var d = Pst(e, h), v = sB(e, d, true), _ = t._length / d._length;
+              for (u = 0; u < v.min.length; u++) c = v.min[u], aB(o, c.val, c.pad * _, { extrapad: c.extrapad });
+              for (u = 0; u < v.max.length; u++) c = v.max[u], oB(s, c.val, c.pad * _, { extrapad: c.extrapad });
+            }
+          }
+          return { min: o, max: s };
+        }
+        function Dst(e, t, r) {
+          if (t.setScale(), t.autorange) {
+            t.range = r ? r.slice() : iB(e, t), t._r = t.range.slice(), t._rl = d_.simpleMap(t._r, t.r2l);
+            var n = t._input, i = {};
+            i[t._attr + ".range"] = t.range, i[t._attr + ".autorange"] = t.autorange, Cst.call("_storeDirectGUIEdit", e.layout, e._fullLayout._preGUI, i), n.range = t.range.slice(), n.autorange = t.autorange;
+          }
+          var a = t._anchorAxis;
+          if (a && a.rangeslider) {
+            var o = a.rangeslider[t._name];
+            o && o.rangemode === "auto" && (o.range = iB(e, t)), a._input.rangeslider[t._name] = d_.extendFlat({}, o);
+          }
+        }
+        function Fst(e, t, r) {
+          r || (r = {}), e._m || e.setScale();
+          var n = [], i = [], a = t.length, o = r.padded || false, s = r.tozero && (e.type === "linear" || e.type === "-"), l = e.type === "log", u = false, c = r.vpadLinearized || false, f, h, d, v, _, b, p, k, E;
+          function T(z) {
+            if (Array.isArray(z)) return u = true, function(U) {
+              return Math.max(Number(z[U] || 0), 0);
+            };
+            var O = Math.max(Number(z || 0), 0);
+            return function() {
+              return O;
+            };
+          }
+          var L = T((e._m > 0 ? r.ppadplus : r.ppadminus) || r.ppad || 0), x = T((e._m > 0 ? r.ppadminus : r.ppadplus) || r.ppad || 0), C = T(r.vpadplus || r.vpad), M = T(r.vpadminus || r.vpad);
+          if (!u) {
+            if (k = 1 / 0, E = -1 / 0, l) for (f = 0; f < a; f++) h = t[f], h < k && h > 0 && (k = h), h > E && h < EL && (E = h);
+            else for (f = 0; f < a; f++) h = t[f], h < k && h > -EL && (k = h), h > E && h < EL && (E = h);
+            t = [k, E], a = 2;
+          }
+          var g = { tozero: s, extrapad: o };
+          function P(z) {
+            d = t[z], hse(d) && (b = L(z), p = x(z), c ? (v = e.c2l(d) - M(z), _ = e.c2l(d) + C(z)) : (k = d - M(z), E = d + C(z), l && k < E / 10 && (k = E / 10), v = e.c2l(k), _ = e.c2l(E)), s && (v = Math.min(0, v), _ = Math.max(0, _)), fse(v) && aB(n, v, p, g), fse(_) && oB(i, _, b, g));
+          }
+          var A = Math.min(6, a);
+          for (f = 0; f < A; f++) P(f);
+          for (f = a - 1; f >= A; f--) P(f);
+          return { min: n, max: i, opts: r };
+        }
+        function aB(e, t, r, n) {
+          vse(e, t, r, n, zst);
+        }
+        function oB(e, t, r, n) {
+          vse(e, t, r, n, Ost);
+        }
+        function vse(e, t, r, n, i) {
+          for (var a = n.tozero, o = n.extrapad, s = true, l = 0; l < e.length && s; l++) {
+            var u = e[l];
+            if (i(u.val, t) && u.pad >= r && (u.extrapad || !o)) {
+              s = false;
+              break;
+            } else i(t, u.val) && u.pad <= r && (o || !u.extrapad) && (e.splice(l, 1), l--);
+          }
+          if (s) {
+            var c = a && t === 0;
+            e.push({ val: t, pad: c ? 0 : r, extrapad: c ? false : o });
+          }
+        }
+        function fse(e) {
+          return hse(e) && Math.abs(e) < EL;
+        }
+        function zst(e, t) {
+          return e <= t;
+        }
+        function Ost(e, t) {
+          return e >= t;
+        }
+        function qst(e, t) {
+          var r = t.autorangeoptions;
+          return r && r.minallowed !== void 0 && kL(t, r.minallowed, r.maxallowed) ? r.minallowed : r && r.clipmin !== void 0 && kL(t, r.clipmin, r.clipmax) ? Math.max(e, t.d2l(r.clipmin)) : e;
+        }
+        function Bst(e, t) {
+          var r = t.autorangeoptions;
+          return r && r.maxallowed !== void 0 && kL(t, r.minallowed, r.maxallowed) ? r.maxallowed : r && r.clipmax !== void 0 && kL(t, r.clipmin, r.clipmax) ? Math.min(e, t.d2l(r.clipmax)) : e;
+        }
+        function kL(e, t, r) {
+          return t !== void 0 && r !== void 0 ? (t = e.d2l(t), r = e.d2l(r), t < r) : true;
+        }
+        function pse(e, t) {
+          if (!t || !t.autorangeoptions) return e;
+          var r = e[0], n = e[1], i = t.autorangeoptions.include;
+          if (i !== void 0) {
+            var a = t.d2l(r), o = t.d2l(n);
+            d_.isArrayOrTypedArray(i) || (i = [i]);
+            for (var s = 0; s < i.length; s++) {
+              var l = t.d2l(i[s]);
+              a >= l && (a = l, r = l), o <= l && (o = l, n = l);
+            }
+          }
+          return r = qst(r, t), n = Bst(n, t), [r, n];
+        }
+      });
+      var ho = ye((iar, Bse) => {
+        var w0 = Oa(), zh = Eo(), G3 = Mc(), uM = qa(), Wo = Dr(), H3 = Wo.strTranslate, Ob = Zl(), Nst = zb(), cM = ka(), Xp = So(), Ust = Rd(), mse = Pq();
+        Rh();
+        var Kd = fs(), Vst = Kd.ONEMAXYEAR, PL = Kd.ONEAVGYEAR, IL = Kd.ONEMINYEAR, Gst = Kd.ONEMAXQUARTER, fB = Kd.ONEAVGQUARTER, RL = Kd.ONEMINQUARTER, Hst = Kd.ONEMAXMONTH, j3 = Kd.ONEAVGMONTH, DL = Kd.ONEMINMONTH, Zp = Kd.ONEWEEK, Ov = Kd.ONEDAY, v_ = Ov / 2, wm = Kd.ONEHOUR, fM = Kd.ONEMIN, FL = Kd.ONESEC, jst = Kd.ONEMILLI, Wst = Kd.ONEMICROSEC, qb = Kd.MINUS_SIGN, OL = Kd.BADNUM, hB = { K: "zeroline" }, dB = { K: "gridline", L: "path" }, vB = { K: "minor-gridline", L: "path" }, kse = { K: "tick", L: "path" }, yse = { K: "tick", L: "text" }, _se = { width: ["x", "r", "l", "xl", "xr"], height: ["y", "t", "b", "yt", "yb"], right: ["r", "xr"], left: ["l", "xl"], top: ["t", "yt"], bottom: ["b", "yb"] }, qL = Dh(), lM = qL.MID_SHIFT, Bb = qL.CAP_SHIFT, hM = qL.LINE_SPACING, Xst = qL.OPPOSITE_SIDE, zL = 3, Jn = Bse.exports = {};
+        Jn.setConvert = xm();
+        var Zst = V3(), Tm = hf(), Yst = Tm.idSort, Kst = Tm.isLinked;
+        Jn.id2name = Tm.id2name;
+        Jn.name2id = Tm.name2id;
+        Jn.cleanId = Tm.cleanId;
+        Jn.list = Tm.list;
+        Jn.listIds = Tm.listIds;
+        Jn.getFromId = Tm.getFromId;
+        Jn.getFromTrace = Tm.getFromTrace;
+        var Cse = Mg();
+        Jn.getAutoRange = Cse.getAutoRange;
+        Jn.findExtremes = Cse.findExtremes;
+        var Jst = 1e-4;
+        function yB(e) {
+          var t = (e[1] - e[0]) * Jst;
+          return [e[0] - t, e[1] + t];
+        }
+        Jn.coerceRef = function(e, t, r, n, i, a) {
+          var o = n.charAt(n.length - 1), s = r._fullLayout._subplots[o + "axis"], l = n + "ref", u = {};
+          return i || (i = s[0] || (typeof a == "string" ? a : a[0])), a || (a = i), s = s.concat(s.map(function(c) {
+            return c + " domain";
+          })), u[l] = { valType: "enumerated", values: s.concat(a ? typeof a == "string" ? [a] : a : []), dflt: i }, Wo.coerce(e, t, u, l);
+        };
+        Jn.coerceRefArray = function(e, t, r, n, i, a, o) {
+          let s = n.charAt(n.length - 1);
+          var l = r._fullLayout._subplots[s + "axis"];
+          let u = n + "ref";
+          var c = e[u];
+          i || (i = l[0] || (typeof a == "string" ? a : a[0])), l = l.concat(l.map((h) => h + " domain")), l = l.concat(a || []), c.length > o ? (Wo.warn("Array attribute " + u + " has more entries than expected, truncating to " + o), c = c.slice(0, o)) : c.length < o && (Wo.warn("Array attribute " + u + " has fewer entries than expected, extending with default value"), c = c.concat(Array(o - c.length).fill(i)));
+          for (var f = 0; f < c.length; f++) c[f] = Tm.cleanId(c[f], s, true) || c[f], l.includes(c[f]) || (c[f] = i);
+          return t[u] = c, c;
+        };
+        Jn.getRefType = function(e) {
+          return e === void 0 ? e : Array.isArray(e) ? "array" : e === "paper" ? "paper" : e === "pixel" ? "pixel" : /( domain)$/.test(e) ? "domain" : "range";
+        };
+        Jn.coercePosition = function(e, t, r, n, i, a) {
+          var o, s, l = Jn.getRefType(n);
+          if (l !== "range") o = Wo.ensureNumber, s = r(i, a);
+          else {
+            var u = Jn.getFromId(t, n);
+            a = u.fraction2r(a), s = r(i, a), o = u.cleanPos;
+          }
+          e[i] = o(s);
+        };
+        Jn.cleanPosition = function(e, t, r) {
+          var n = r === "paper" || r === "pixel" ? Wo.ensureNumber : Jn.getFromId(t, r).cleanPos;
+          return n(e);
+        };
+        Jn.redrawComponents = function(e, t) {
+          t = t || Jn.listIds(e);
+          var r = e._fullLayout;
+          function n(i, a, o, s) {
+            for (var l = uM.getComponentMethod(i, a), u = {}, c = 0; c < t.length; c++) for (var f = r[Jn.id2name(t[c])], h = f[o], d = 0; d < h.length; d++) {
+              var v = h[d];
+              if (!u[v] && (l(e, v), u[v] = 1, s)) return;
+            }
+          }
+          n("annotations", "drawOne", "_annIndices"), n("shapes", "drawOne", "_shapeIndices"), n("images", "draw", "_imgIndices", true), n("selections", "drawOne", "_selectionIndices");
+        };
+        var $st = Jn.getDataConversions = function(e, t, r, n) {
+          var i, a = r === "x" || r === "y" || r === "z" ? r : n;
+          if (Wo.isArrayOrTypedArray(a)) {
+            if (i = { type: Zst(n, void 0, { autotypenumbers: e._fullLayout.autotypenumbers }), _categories: [] }, Jn.setConvert(i), i.type === "category") for (var o = 0; o < n.length; o++) i.d2c(n[o]);
+          } else i = Jn.getFromTrace(e, t, a);
+          return i ? { d2c: i.d2c, c2d: i.c2d } : a === "ids" ? { d2c: bse, c2d: bse } : { d2c: xse, c2d: xse };
+        };
+        function xse(e) {
+          return +e;
+        }
+        function bse(e) {
+          return String(e);
+        }
+        Jn.getDataToCoordFunc = function(e, t, r, n) {
+          return $st(e, t, r, n).d2c;
+        };
+        Jn.counterLetter = function(e) {
+          var t = e.charAt(0);
+          if (t === "x") return "y";
+          if (t === "y") return "x";
+        };
+        Jn.minDtick = function(e, t, r, n) {
+          ["log", "category", "multicategory"].indexOf(e.type) !== -1 || !n ? e._minDtick = 0 : e._minDtick === void 0 ? (e._minDtick = t, e._forceTick0 = r) : e._minDtick && ((e._minDtick / t + 1e-6) % 1 < 2e-6 && ((r - e._forceTick0) / t % 1 + 1.000001) % 1 < 2e-6 ? (e._minDtick = t, e._forceTick0 = r) : ((t / e._minDtick + 1e-6) % 1 > 2e-6 || ((r - e._forceTick0) / e._minDtick % 1 + 1.000001) % 1 > 2e-6) && (e._minDtick = 0));
+        };
+        Jn.saveRangeInitial = function(e, t) {
+          for (var r = Jn.list(e, "", true), n = false, i = 0; i < r.length; i++) {
+            var a = r[i], o = a._rangeInitial0 === void 0 && a._rangeInitial1 === void 0, s = o || a.range[0] !== a._rangeInitial0 || a.range[1] !== a._rangeInitial1, l = a.autorange;
+            (o && l !== true || t && s) && (a._rangeInitial0 = l === "min" || l === "max reversed" ? void 0 : a.range[0], a._rangeInitial1 = l === "max" || l === "min reversed" ? void 0 : a.range[1], a._autorangeInitial = l, n = true);
+          }
+          return n;
+        };
+        Jn.saveShowSpikeInitial = function(e, t) {
+          for (var r = Jn.list(e, "", true), n = false, i = "on", a = 0; a < r.length; a++) {
+            var o = r[a], s = o._showSpikeInitial === void 0, l = s || o.showspikes !== o._showspikes;
+            (s || t && l) && (o._showSpikeInitial = o.showspikes, n = true), i === "on" && !o.showspikes && (i = "off");
+          }
+          return e._fullLayout._cartesianSpikesEnabled = i, n;
+        };
+        Jn.autoBin = function(e, t, r, n, i, a) {
+          var o = Wo.aggNums(Math.min, null, e), s = Wo.aggNums(Math.max, null, e);
+          if (t.type === "category" || t.type === "multicategory") return { start: o - 0.5, end: s + 0.5, size: Math.max(1, Math.round(a) || 1), _dataSpan: s - o };
+          i || (i = t.calendar);
+          var l;
+          if (t.type === "log" ? l = { type: "linear", range: [o, s] } : l = { type: t.type, range: Wo.simpleMap([o, s], t.c2r, 0, i), calendar: i }, Jn.setConvert(l), a = a && mse.dtick(a, l.type), a) l.dtick = a, l.tick0 = mse.tick0(void 0, l.type, i);
+          else {
+            var u;
+            if (r) u = (s - o) / r;
+            else {
+              var c = Wo.distinctVals(e), f = Math.pow(10, Math.floor(Math.log(c.minDiff) / Math.LN10)), h = f * Wo.roundUp(c.minDiff / f, [0.9, 1.9, 4.9, 9.9], true);
+              u = Math.max(h, 2 * Wo.stdev(e) / Math.pow(e.length, n ? 0.25 : 0.4)), zh(u) || (u = 1);
+            }
+            Jn.autoTicks(l, u);
+          }
+          var d = l.dtick, v = Jn.tickIncrement(Jn.tickFirst(l), d, "reverse", i), _, b;
+          if (typeof d == "number") v = Qst(v, e, l, o, s), b = 1 + Math.floor((s - v) / d), _ = v + b * d;
+          else for (l.dtick.charAt(0) === "M" && (v = elt(v, e, d, o, i)), _ = v, b = 0; _ <= s; ) _ = Jn.tickIncrement(_, d, false, i), b++;
+          return { start: t.c2r(v, 0, i), end: t.c2r(_, 0, i), size: d, _dataSpan: s - o };
+        };
+        function Qst(e, t, r, n, i) {
+          var a = 0, o = 0, s = 0, l = 0;
+          function u(d) {
+            return (1 + (d - e) * 100 / r.dtick) % 100 < 2;
+          }
+          for (var c = 0; c < t.length; c++) t[c] % 1 === 0 ? s++ : zh(t[c]) || l++, u(t[c]) && a++, u(t[c] + r.dtick / 2) && o++;
+          var f = t.length - l;
+          if (s === f && r.type !== "date") r.dtick < 1 ? e = n - 0.5 * r.dtick : (e -= 0.5, e + r.dtick < n && (e += r.dtick));
+          else if (o < f * 0.1 && (a > f * 0.3 || u(n) || u(i))) {
+            var h = r.dtick / 2;
+            e += e + h < n ? h : -h;
+          }
+          return e;
+        }
+        function elt(e, t, r, n, i) {
+          var a = Wo.findExactDates(t, i), o = 0.8;
+          if (a.exactDays > o) {
+            var s = Number(r.slice(1));
+            a.exactYears > o && s % 12 === 0 ? e = Jn.tickIncrement(e, "M6", "reverse") + Ov * 1.5 : a.exactMonths > o ? e = Jn.tickIncrement(e, "M1", "reverse") + Ov * 15.5 : e -= v_;
+            var l = Jn.tickIncrement(e, r);
+            if (l <= n) return l;
+          }
+          return e;
+        }
+        Jn.prepMinorTicks = function(e, t, r) {
+          if (!t.minor.dtick) {
+            delete e.dtick;
+            var n = t.dtick && zh(t._tmin), i;
+            if (n) {
+              var a = Jn.tickIncrement(t._tmin, t.dtick, true);
+              i = [t._tmin, a * 0.99 + t._tmin * 0.01];
+            } else {
+              var o = Wo.simpleMap(t.range, t.r2l);
+              i = [o[0], 0.8 * o[0] + 0.2 * o[1]];
+            }
+            if (e.range = Wo.simpleMap(i, t.l2r), e._isMinor = true, Jn.prepTicks(e, r), n) {
+              var s = zh(t.dtick), l = zh(e.dtick), u = s ? t.dtick : +t.dtick.substring(1), c = l ? e.dtick : +e.dtick.substring(1);
+              s && l ? lB(u, c) ? u === 2 * Zp && c === 2 * Ov && (e.dtick = Zp) : u === 2 * Zp && c === 3 * Ov ? e.dtick = Zp : u === Zp && !(t._input.minor || {}).nticks ? e.dtick = Ov : wse(u / c, 2.5) ? e.dtick = u / 2 : e.dtick = u : String(t.dtick).charAt(0) === "M" ? l ? e.dtick = "M1" : lB(u, c) ? u >= 12 && c === 2 && (e.dtick = "M3") : e.dtick = t.dtick : String(e.dtick).charAt(0) === "L" ? String(t.dtick).charAt(0) === "L" ? lB(u, c) || (e.dtick = wse(u / c, 2.5) ? t.dtick / 2 : t.dtick) : e.dtick = "D1" : e.dtick === "D2" && +t.dtick > 1 && (e.dtick = 1);
+            }
+            e.range = t.range;
+          }
+          t.minor._tick0Init === void 0 && (e.tick0 = t.tick0);
+        };
+        function lB(e, t) {
+          return Math.abs((e / t + 0.5) % 1 - 0.5) < 1e-3;
+        }
+        function wse(e, t) {
+          return Math.abs(e / t - 1) < 1e-3;
+        }
+        Jn.prepTicks = function(e, t) {
+          var r = Wo.simpleMap(e.range, e.r2l, void 0, void 0, t);
+          if (e.tickmode === "auto" || !e.dtick) {
+            var n = e.nticks, i;
+            n || (e.type === "category" || e.type === "multicategory" ? (i = e.tickfont ? Wo.bigFont(e.tickfont.size || 12) : 15, n = e._length / i) : (i = e._id.charAt(0) === "y" ? 40 : 80, n = Wo.constrain(e._length / i, 4, 9) + 1), e._name === "radialaxis" && (n *= 2)), e.minor && e.minor.tickmode !== "array" || e.tickmode === "array" && (n *= 100), e._roughDTick = Math.abs(r[1] - r[0]) / n, Jn.autoTicks(e, e._roughDTick), e._minDtick > 0 && e.dtick < e._minDtick * 2 && (e.dtick = e._minDtick, e.tick0 = e.l2r(e._forceTick0));
+          }
+          e.ticklabelmode === "period" && tlt(e), e.tick0 || (e.tick0 = e.type === "date" ? "2000-01-01" : 0), e.type === "date" && e.dtick < 0.1 && (e.dtick = 0.1), Rse(e);
+        };
+        function uB(e) {
+          return +e.substring(1);
+        }
+        function tlt(e) {
+          var t;
+          function r() {
+            return !(zh(e.dtick) || e.dtick.charAt(0) !== "M");
+          }
+          var n = r(), i = Jn.getTickFormat(e);
+          if (i) {
+            var a = e._dtickInit !== e.dtick;
+            /%[fLQsSMX]/.test(i) || (/%[HI]/.test(i) ? (t = wm, a && !n && e.dtick < wm && (e.dtick = wm)) : /%p/.test(i) ? (t = v_, a && !n && e.dtick < v_ && (e.dtick = v_)) : /%[Aadejuwx]/.test(i) ? (t = Ov, a && !n && e.dtick < Ov && (e.dtick = Ov)) : /%[UVW]/.test(i) ? (t = Zp, a && !n && e.dtick < Zp && (e.dtick = Zp)) : /%[Bbm]/.test(i) ? (t = j3, a && (n ? uB(e.dtick) < 1 : e.dtick < DL) && (e.dtick = "M1")) : /%[q]/.test(i) ? (t = fB, a && (n ? uB(e.dtick) < 3 : e.dtick < RL) && (e.dtick = "M3")) : /%[Yy]/.test(i) && (t = PL, a && (n ? uB(e.dtick) < 12 : e.dtick < IL) && (e.dtick = "M12")));
+          }
+          n = r(), n && e.tick0 === e._dowTick0 && (e.tick0 = e._rawTick0), e._definedDelta = t;
+        }
+        function rlt(e, t, r) {
+          for (var n = 0; n < e.length; n++) {
+            var i = e[n].value, a = n, o = n + 1;
+            n < e.length - 1 ? (a = n, o = n + 1) : n > 0 ? (a = n - 1, o = n) : (a = n, o = n);
+            var s = e[a].value, l = e[o].value, u = Math.abs(l - s), c = r || u, f = 0;
+            c >= IL ? u >= IL && u <= Vst ? f = u : f = PL : r === fB && c >= RL ? u >= RL && u <= Gst ? f = u : f = fB : c >= DL ? u >= DL && u <= Hst ? f = u : f = j3 : r === Zp && c >= Zp ? f = Zp : c >= Ov ? f = Ov : r === v_ && c >= v_ ? f = v_ : r === wm && c >= wm && (f = wm);
+            var h;
+            f >= u && (f = u, h = true);
+            var d = i + f;
+            if (t.rangebreaks && f > 0) {
+              for (var v = 84, _ = 0, b = 0; b < v; b++) {
+                var p = (b + 0.5) / v;
+                t.maskBreaks(i * (1 - p) + p * d) !== OL && _++;
+              }
+              f *= _ / v, f || (e[n].drop = true), h && u > Zp && (f = u);
+            }
+            (f > 0 || n === 0) && (e[n].periodX = i + f / 2);
+          }
+        }
+        Jn.calcTicks = function(t, r) {
+          for (var n = t.type, i = t.calendar, a = t.ticklabelstep, o = t.ticklabelmode === "period", s = t.range[0] > t.range[1], l = !t.ticklabelindex || Wo.isArrayOrTypedArray(t.ticklabelindex) ? t.ticklabelindex : [t.ticklabelindex], u = Wo.simpleMap(t.range, t.r2l, void 0, void 0, r), c = u[1] < u[0], f = Math.min(u[0], u[1]), h = Math.max(u[0], u[1]), d = Math.max(1e3, t._length || 0), v = [], _ = [], b = [], p = [], k = [], E = t.minor && (t.minor.ticks || t.minor.showgrid), T = 1; T >= (E ? 0 : 1); T--) {
+            var L = !T;
+            T ? (t._dtickInit = t.dtick, t._tick0Init = t.tick0) : (t.minor._dtickInit = t.minor.dtick, t.minor._tick0Init = t.minor.tick0);
+            var x = T ? t : Wo.extendFlat({}, t, t.minor);
+            if (L ? Jn.prepMinorTicks(x, t, r) : Jn.prepTicks(x, r), x.tickmode === "array") {
+              T ? (b = [], v = Tse(t, !L)) : (p = [], _ = Tse(t, !L));
+              continue;
+            }
+            if (x.tickmode === "sync") {
+              b = [], v = ilt(t);
+              continue;
+            }
+            var C = yB(u), M = C[0], g = C[1], P = zh(x.dtick), A = n === "log" && !(P || x.dtick.charAt(0) === "L"), z = Jn.tickFirst(x, r);
+            if (T) {
+              if (t._tmin = z, z < M !== c) break;
+              (n === "category" || n === "multicategory") && (g = c ? Math.max(-0.5, g) : Math.min(t._categories.length - 0.5, g));
+            }
+            var O = null, U = z, G;
+            if (T) {
+              var Z;
+              P ? Z = t.dtick : n === "date" ? typeof t.dtick == "string" && t.dtick.charAt(0) === "M" && (Z = j3 * t.dtick.substring(1)) : Z = t._roughDTick, G = Math.round((t.r2l(U) - t.r2l(t.tick0)) / Z) - 1;
+            }
+            var j = x.dtick;
+            for (x.rangebreaks && x._tick0Init !== x.tick0 && (U = cB(U, t), c || (U = Jn.tickIncrement(U, j, !c, i))), T && o && (U = Jn.tickIncrement(U, j, !c, i), G--); c ? U >= g : U <= g; U = Jn.tickIncrement(U, j, c, i)) {
+              if (T && G++, x.rangebreaks && !c) {
+                if (U < M) continue;
+                if (x.maskBreaks(U) === OL && cB(U, x) >= h) break;
+              }
+              if (b.length > d || U === O) break;
+              O = U;
+              var N = { value: U };
+              T ? (A && U !== (U | 0) && (N.simpleLabel = true), a > 1 && G % a && (N.skipLabel = true), b.push(N)) : (N.minor = true, p.push(N));
+            }
+          }
+          if (!p || p.length < 2) l = false;
+          else {
+            var H = (p[1].value - p[0].value) * (s ? -1 : 1);
+            klt(H, t.tickformat) || (l = false);
+          }
+          if (!l) k = b;
+          else {
+            var re = b.concat(p);
+            o && b.length && (re = re.slice(1)), re = re.sort(function(Wt, Nt) {
+              return Wt.value - Nt.value;
+            }).filter(function(Wt, Nt, $t) {
+              return Nt === 0 || Wt.value !== $t[Nt - 1].value;
+            });
+            var oe = re.map(function(Wt, Nt) {
+              return Wt.minor === void 0 && !Wt.skipLabel ? Nt : null;
+            }).filter(function(Wt) {
+              return Wt !== null;
+            });
+            oe.forEach(function(Wt) {
+              l.map(function(Nt) {
+                var $t = Wt + Nt;
+                $t >= 0 && $t < re.length && Wo.pushUnique(k, re[$t]);
+              });
+            });
+          }
+          if (E) {
+            var _e = t.minor.ticks === "inside" && t.ticks === "outside" || t.minor.ticks === "outside" && t.ticks === "inside";
+            if (!_e) {
+              for (var Ce = b.map(function(Wt) {
+                return Wt.value;
+              }), Le = [], ge = 0; ge < p.length; ge++) {
+                var ie = p[ge], Se = ie.value;
+                if (Ce.indexOf(Se) === -1) {
+                  for (var Ee = false, Ae = 0; !Ee && Ae < b.length; Ae++) 1e7 + b[Ae].value === 1e7 + Se && (Ee = true);
+                  Ee || Le.push(ie);
+                }
+              }
+              p = Le;
+            }
+          }
+          o && rlt(k, t, t._definedDelta);
+          var Be;
+          if (t.rangebreaks) {
+            var Pe = t._id.charAt(0) === "y", me = 1;
+            t.tickmode === "auto" && (me = t.tickfont ? t.tickfont.size : 12);
+            var De = NaN;
+            for (Be = b.length - 1; Be > -1; Be--) {
+              if (b[Be].drop) {
+                b.splice(Be, 1);
+                continue;
+              }
+              b[Be].value = cB(b[Be].value, t);
+              var ce = t.c2p(b[Be].value);
+              (Pe ? De > ce - me : De < ce + me) ? b.splice(c ? Be + 1 : Be, 1) : De = ce;
+            }
+          }
+          wB(t) && Math.abs(u[1] - u[0]) === 360 && b.pop(), t._tmax = (b[b.length - 1] || {}).value, t._prevDateHead = "", t._inCalcTicks = true;
+          var je, lt = function(Wt) {
+            Wt.text = "", t._prevDateHead = je;
+          };
+          b = b.concat(p);
+          function pt(Wt, Nt) {
+            var $t = Jn.tickText(Wt, Nt.value, false, Nt.simpleLabel), sr = Nt.periodX;
+            return sr !== void 0 && ($t.periodX = sr, (sr > h || sr < f) && (sr > h && ($t.periodX = h), sr < f && ($t.periodX = f), lt($t))), $t;
+          }
+          var Vt;
+          for (Be = 0; Be < b.length; Be++) {
+            var ot = b[Be].minor, ut = b[Be].value;
+            ot ? (l && k.indexOf(b[Be]) !== -1 ? Vt = pt(t, b[Be]) : Vt = { x: ut }, Vt.minor = true, _.push(Vt)) : (je = t._prevDateHead, Vt = pt(t, b[Be]), (b[Be].skipLabel || l && k.indexOf(b[Be]) === -1) && lt(Vt), v.push(Vt));
+          }
+          return v = v.concat(_), t._inCalcTicks = false, o && v.length && (v[0].noTick = true), v;
+        };
+        function Lse(e, t) {
+          return e.rangebreaks && (t = t.filter(function(r) {
+            return e.maskBreaks(r.x) !== OL;
+          })), t;
+        }
+        function ilt(e) {
+          var t = e._mainAxis, r = [];
+          if (t._vals) {
+            for (var n = 0; n < t._vals.length; n++) if (!t._vals[n].noTick) {
+              var i = t.l2p(t._vals[n].x), a = e.p2l(i), o = Jn.tickText(e, a);
+              t._vals[n].minor && (o.minor = true, o.text = ""), r.push(o);
+            }
+          }
+          return r = Lse(e, r), r;
+        }
+        function Tse(e, t) {
+          var r = Wo.simpleMap(e.range, e.r2l), n = yB(r), i = Math.min(n[0], n[1]), a = Math.max(n[0], n[1]), o = e.type === "category" ? e.d2l_noadd : e.d2l;
+          e.type === "log" && String(e.dtick).charAt(0) !== "L" && (e.dtick = "L" + Math.pow(10, Math.floor(Math.min(e.range[0], e.range[1])) - 1));
+          for (var s = [], l = 0; l <= 1; l++) if (!(t !== void 0 && (t && l || t === false && !l)) && !(l && !e.minor)) {
+            var u = l ? e.minor.tickvals : e.tickvals, c = l ? [] : e.ticktext;
+            if (u) {
+              Wo.isArrayOrTypedArray(c) || (c = []);
+              for (var f = 0; f < u.length; f++) {
+                var h = o(u[f]);
+                if (h > i && h < a) {
+                  var d = Jn.tickText(e, h, false, String(c[f]));
+                  l && (d.minor = true, d.text = ""), s.push(d);
+                }
+              }
+            }
+          }
+          return s = Lse(e, s), s;
+        }
+        var CL = [2, 5, 10], Ase = [1, 2, 3, 6, 12], Sse = [1, 2, 5, 10, 15, 30], nlt = [1, 2, 3, 7, 14], Pse = [-0.046, 0, 0.301, 0.477, 0.602, 0.699, 0.778, 0.845, 0.903, 0.954, 1], Ise = [-0.301, 0, 0.301, 0.699, 1], alt = [15, 30, 45, 90, 180];
+        function bm(e, t, r) {
+          return t * Wo.roundUp(e / t, r);
+        }
+        Jn.autoTicks = function(e, t, r) {
+          var n;
+          function i(f) {
+            return Math.pow(f, Math.floor(Math.log(t) / Math.LN10));
+          }
+          if (e.type === "date") {
+            e.tick0 = Wo.dateTick0(e.calendar, 0);
+            var a = 2 * t;
+            if (a > PL) t /= PL, n = i(10), e.dtick = "M" + 12 * bm(t, n, CL);
+            else if (a > j3) t /= j3, e.dtick = "M" + bm(t, 1, Ase);
+            else if (a > Ov) {
+              if (e.dtick = bm(t, Ov, e._hasDayOfWeekBreaks ? [1, 2, 7, 14] : nlt), !r) {
+                var o = Jn.getTickFormat(e), s = e.ticklabelmode === "period";
+                s && (e._rawTick0 = e.tick0), /%[uVW]/.test(o) ? e.tick0 = Wo.dateTick0(e.calendar, 2) : e.tick0 = Wo.dateTick0(e.calendar, 1), s && (e._dowTick0 = e.tick0);
+              }
+            } else a > wm ? e.dtick = bm(t, wm, Ase) : a > fM ? e.dtick = bm(t, fM, Sse) : a > FL ? e.dtick = bm(t, FL, Sse) : (n = i(10), e.dtick = bm(t, n, CL));
+          } else if (e.type === "log") {
+            e.tick0 = 0;
+            var l = Wo.simpleMap(e.range, e.r2l);
+            if (e._isMinor && (t *= 1.5), t > 0.7) e.dtick = Math.ceil(t);
+            else if (Math.abs(l[1] - l[0]) < 1) {
+              var u = 1.5 * Math.abs((l[1] - l[0]) / t);
+              t = Math.abs(Math.pow(10, l[1]) - Math.pow(10, l[0])) / u, n = i(10), e.dtick = "L" + bm(t, n, CL);
+            } else e.dtick = t > 0.3 ? "D2" : "D1";
+          } else e.type === "category" || e.type === "multicategory" ? (e.tick0 = 0, e.dtick = Math.ceil(Math.max(t, 1))) : wB(e) ? (e.tick0 = 0, n = 1, e.dtick = bm(t, n, alt)) : (e.tick0 = 0, n = i(10), e.dtick = bm(t, n, CL));
+          if (e.dtick === 0 && (e.dtick = 1), !zh(e.dtick) && typeof e.dtick != "string") {
+            var c = e.dtick;
+            throw e.dtick = 1, "ax.dtick error: " + String(c);
+          }
+        };
+        function Rse(e) {
+          var t = e.dtick;
+          if (e._tickexponent = 0, !zh(t) && typeof t != "string" && (t = 1), (e.type === "category" || e.type === "multicategory") && (e._tickround = null), e.type === "date") {
+            var r = e.r2l(e.tick0), n = e.l2r(r).replace(/(^-|i)/g, ""), i = n.length;
+            if (String(t).charAt(0) === "M") i > 10 || n.slice(5) !== "01-01" ? e._tickround = "d" : e._tickround = +t.slice(1) % 12 === 0 ? "y" : "m";
+            else if (t >= Ov && i <= 10 || t >= Ov * 15) e._tickround = "d";
+            else if (t >= fM && i <= 16 || t >= wm) e._tickround = "M";
+            else if (t >= FL && i <= 19 || t >= fM) e._tickround = "S";
+            else {
+              var a = e.l2r(r + t).replace(/^-/, "").length;
+              e._tickround = Math.max(i, a) - 20, e._tickround < 0 && (e._tickround = 4);
+            }
+          } else if (zh(t) || t.charAt(0) === "L") {
+            var o = e.range.map(e.r2d || Number);
+            zh(t) || (t = Number(t.slice(1))), e._tickround = 2 - Math.floor(Math.log(t) / Math.LN10 + 0.01);
+            var s = Math.max(Math.abs(o[0]), Math.abs(o[1])), l = Math.floor(Math.log(s) / Math.LN10 + 0.01), u = e.minexponent === void 0 ? 3 : e.minexponent;
+            Math.abs(l) > u && (W3(e.exponentformat) && e.exponentformat !== "SI extended" && !_B(l) || W3(e.exponentformat) && e.exponentformat === "SI extended" && !xB(l) ? e._tickexponent = 3 * Math.round((l - 1) / 3) : e._tickexponent = l);
+          } else e._tickround = null;
+        }
+        Jn.tickIncrement = function(e, t, r, n) {
+          var i = r ? -1 : 1;
+          if (zh(t)) return Wo.increment(e, i * t);
+          var a = t.charAt(0), o = i * Number(t.slice(1));
+          if (a === "M") return Wo.incrementMonth(e, o, n);
+          if (a === "L") return Math.log(Math.pow(10, e) + o) / Math.LN10;
+          if (a === "D") {
+            var s = t === "D2" ? Ise : Pse, l = e + i * 0.01, u = Wo.roundUp(Wo.mod(l, 1), s, r);
+            return Math.floor(l) + Math.log(w0.round(Math.pow(10, u), 1)) / Math.LN10;
+          }
+          throw "unrecognized dtick " + String(t);
+        };
+        Jn.tickFirst = function(e, t) {
+          var r = e.r2l || Number, n = Wo.simpleMap(e.range, r, void 0, void 0, t), i = n[1] < n[0], a = i ? Math.floor : Math.ceil, o = yB(n)[0], s = e.dtick, l = r(e.tick0);
+          if (zh(s)) {
+            var u = a((o - l) / s) * s + l;
+            return (e.type === "category" || e.type === "multicategory") && (u = Wo.constrain(u, 0, e._categories.length - 1)), u;
+          }
+          var c = s.charAt(0), f = Number(s.slice(1));
+          if (c === "M") {
+            for (var h = 0, d = l, v, _, b; h < 10; ) {
+              if (v = Jn.tickIncrement(d, s, i, e.calendar), (v - o) * (d - o) <= 0) return i ? Math.min(d, v) : Math.max(d, v);
+              _ = (o - (d + v) / 2) / (v - d), b = c + (Math.abs(Math.round(_)) || 1) * f, d = Jn.tickIncrement(d, b, _ < 0 ? !i : i, e.calendar), h++;
+            }
+            return Wo.error("tickFirst did not converge", e), d;
+          } else {
+            if (c === "L") return Math.log(a((Math.pow(10, o) - l) / f) * f + l) / Math.LN10;
+            if (c === "D") {
+              var p = s === "D2" ? Ise : Pse, k = Wo.roundUp(Wo.mod(o, 1), p, i);
+              return Math.floor(o) + Math.log(w0.round(Math.pow(10, k), 1)) / Math.LN10;
+            } else throw "unrecognized dtick " + String(s);
+          }
+        };
+        Jn.tickText = function(e, t, r, n) {
+          var i = Dse(e, t), a = e.tickmode === "array", o = r || a, s = e.type, l = s === "category" ? e.d2l_noadd : e.d2l, u, c = function(b) {
+            var p = e.l2p(b);
+            return p >= 0 && p <= e._length ? b : null;
+          };
+          if (a && Wo.isArrayOrTypedArray(e.ticktext)) {
+            var f = Wo.simpleMap(e.range, e.r2l), h = (Math.abs(f[1] - f[0]) - (e._lBreaks || 0)) / 1e4;
+            for (u = 0; u < e.ticktext.length && !(Math.abs(t - l(e.tickvals[u])) < h); u++) ;
+            if (u < e.ticktext.length) return i.text = String(e.ticktext[u]), i.xbnd = [c(i.x - 0.5), c(i.x + e.dtick - 0.5)], i;
+          }
+          function d(b) {
+            if (b === void 0) return true;
+            if (r) return b === "none";
+            var p = { first: e._tmin, last: e._tmax }[b];
+            return b !== "all" && t !== p;
+          }
+          var v = r ? "never" : e.exponentformat !== "none" && d(e.showexponent) ? "hide" : "";
+          if (s === "date" ? olt(e, i, r, o) : s === "log" ? slt(e, i, r, o, v) : s === "category" ? llt(e, i) : s === "multicategory" ? ult(e, i, r) : wB(e) ? flt(e, i, r, o, v) : clt(e, i, r, o, v), n || (e.tickprefix && !d(e.showtickprefix) && (i.text = e.tickprefix + i.text), e.ticksuffix && !d(e.showticksuffix) && (i.text += e.ticksuffix)), e.labelalias && e.labelalias.hasOwnProperty(i.text)) {
+            var _ = e.labelalias[i.text];
+            typeof _ == "string" && (i.text = _);
+          }
+          return (e.tickson === "boundaries" || e.showdividers) && (i.xbnd = [c(i.x - 0.5), c(i.x + e.dtick - 0.5)]), i;
+        };
+        Jn.hoverLabelText = function(e, t, r) {
+          r && (e = Wo.extendFlat({}, e, { hoverformat: r }));
+          var n = Wo.isArrayOrTypedArray(t) ? t[0] : t, i = Wo.isArrayOrTypedArray(t) ? t[1] : void 0;
+          if (i !== void 0 && i !== n) return Jn.hoverLabelText(e, n, r) + " - " + Jn.hoverLabelText(e, i, r);
+          var a = e.type === "log" && n <= 0, o = Jn.tickText(e, e.c2l(a ? -n : n), "hover").text;
+          return a ? n === 0 ? "0" : qb + o : o;
+        };
+        function Dse(e, t, r) {
+          var n = e.tickfont || {};
+          return { x: t, dx: 0, dy: 0, text: r || "", fontSize: n.size, font: n.family, fontWeight: n.weight, fontStyle: n.style, fontVariant: n.variant, fontTextcase: n.textcase, fontLineposition: n.lineposition, fontShadow: n.shadow, fontColor: n.color };
+        }
+        function olt(e, t, r, n) {
+          var i = e._tickround, a = r && e.hoverformat || Jn.getTickFormat(e);
+          n = !a && n, n && (zh(i) ? i = 4 : i = { y: "m", m: "d", d: "M", M: "S", S: 4 }[i]);
+          var o = Wo.formatDate(t.x, a, i, e._dateFormat, e.calendar, e._extraFormat), s, l = o.indexOf(`
+`);
+          if (l !== -1 && (s = o.slice(l + 1), o = o.slice(0, l)), n && (s !== void 0 && (o === "00:00:00" || o === "00:00") ? (o = s, s = "") : o.length === 8 && (o = o.replace(/:00$/, ""))), s) if (r) i === "d" ? o += ", " + s : o = s + (o ? ", " + o : "");
+          else if (!e._inCalcTicks || e._prevDateHead !== s) e._prevDateHead = s, o += "<br>" + s;
+          else {
+            var u = vM(e), c = e._trueSide || e.side;
+            (!u && c === "top" || u && c === "bottom") && (o += "<br> ");
+          }
+          t.text = o;
+        }
+        function slt(e, t, r, n, i) {
+          var a = e.dtick, o = t.x, s = e.tickformat, l = typeof a == "string" && a.charAt(0);
+          if (i === "never" && (i = ""), n && l !== "L" && (a = "L3", l = "L"), s || l === "L") t.text = dM(Math.pow(10, o), e, i, n);
+          else if (zh(a) || l === "D" && (e.minorloglabels === "complete" || Wo.mod(o + 0.01, 1) < 0.1)) {
+            e.minorloglabels === "complete" && !(Wo.mod(o + 0.01, 1) < 0.1) && (t.fontSize *= 0.75);
+            var c = Math.pow(10, o).toExponential(0), f = c.split("e"), h = +f[1], d = Math.abs(h), v = e.exponentformat;
+            v === "power" || W3(v) && v !== "SI extended" && _B(h) || W3(v) && v === "SI extended" && xB(h) ? (t.text = f[0], d > 0 && (t.text += "x10"), t.text === "1x10" && (t.text = "10"), h !== 0 && h !== 1 && (t.text += "<sup>" + (h > 0 ? "" : qb) + d + "</sup>"), t.fontSize *= 1.25) : (v === "e" || v === "E") && d > 2 ? t.text = f[0] + v + (h > 0 ? "+" : qb) + d : (t.text = dM(Math.pow(10, o), e, "", "fakehover"), a === "D1" && e._id.charAt(0) === "y" && (t.dy -= t.fontSize / 6));
+          } else if (l === "D") t.text = e.minorloglabels === "none" ? "" : String(Math.round(Math.pow(10, Wo.mod(o, 1)))), t.fontSize *= 0.75;
+          else throw "unrecognized dtick " + String(a);
+          if (e.dtick === "D1") {
+            var _ = String(t.text).charAt(0);
+            (_ === "0" || _ === "1") && (e._id.charAt(0) === "y" ? t.dx -= t.fontSize / 4 : (t.dy += t.fontSize / 2, t.dx += (e.range[1] > e.range[0] ? 1 : -1) * t.fontSize * (o < 0 ? 0.5 : 0.25)));
+          }
+        }
+        function llt(e, t) {
+          var r = e._categories[Math.round(t.x)];
+          r === void 0 && (r = ""), t.text = String(r);
+        }
+        function ult(e, t, r) {
+          var n = Math.round(t.x), i = e._categories[n] || [], a = i[1] === void 0 ? "" : String(i[1]), o = i[0] === void 0 ? "" : String(i[0]);
+          r ? t.text = o + " - " + a : (t.text = a, t.text2 = o);
+        }
+        function clt(e, t, r, n, i) {
+          i === "never" ? i = "" : e.showexponent === "all" && Math.abs(t.x / e.dtick) < 1e-6 && (i = "hide"), t.text = dM(t.x, e, i, n);
+        }
+        function flt(e, t, r, n, i) {
+          if (e.thetaunit === "radians" && !r) {
+            var a = t.x / 180;
+            if (a === 0) t.text = "0";
+            else {
+              var o = hlt(a);
+              if (o[1] >= 100) t.text = dM(Wo.deg2rad(t.x), e, i, n);
+              else {
+                var s = t.x < 0;
+                o[1] === 1 ? o[0] === 1 ? t.text = "π" : t.text = o[0] + "π" : t.text = ["<sup>", o[0], "</sup>", "⁄", "<sub>", o[1], "</sub>", "π"].join(""), s && (t.text = qb + t.text);
+              }
+            }
+          } else t.text = dM(t.x, e, i, n);
+        }
+        function hlt(e) {
+          function t(s, l) {
+            return Math.abs(s - l) <= 1e-6;
+          }
+          function r(s, l) {
+            return t(l, 0) ? s : r(l, s % l);
+          }
+          function n(s) {
+            for (var l = 1; !t(Math.round(s * l) / l, s); ) l *= 10;
+            return l;
+          }
+          var i = n(e), a = e * i, o = Math.abs(r(a, i));
+          return [Math.round(a / o), Math.round(i / o)];
+        }
+        var Fse = ["f", "p", "n", "μ", "m", "", "k", "M", "G", "T"], dlt = ["q", "r", "y", "z", "a", ...Fse, "P", "E", "Z", "Y", "R", "Q"], W3 = (e) => ["SI", "SI extended", "B"].includes(e);
+        function _B(e) {
+          return e > 14 || e < -15;
+        }
+        function xB(e) {
+          return e > 32 || e < -30;
+        }
+        function vlt(e, t) {
+          return W3(t) ? !!(t === "SI extended" && xB(e) || t !== "SI extended" && _B(e)) : false;
+        }
+        function dM(e, t, r, n) {
+          var i = e < 0, a = t._tickround, o = r || t.exponentformat || "B", s = t._tickexponent, l = Jn.getTickFormat(t), u = t.separatethousands;
+          if (n) {
+            var c = { exponentformat: o, minexponent: t.minexponent, dtick: t.showexponent === "none" ? t.dtick : zh(e) && Math.abs(e) || 1, range: t.showexponent === "none" ? t.range.map(t.r2d) : [0, e || 1] };
+            Rse(c), a = (Number(c._tickround) || 0) + 4, s = c._tickexponent, t.hoverformat && (l = t.hoverformat);
+          }
+          if (l) return t._numFormat(l)(e).replace(/-/g, qb);
+          var f = Math.pow(10, -a) / 2;
+          if (o === "none" && (s = 0), e = Math.abs(e), e < f) e = "0", i = false;
+          else {
+            if (e += f, s && (e *= Math.pow(10, -s), a += s), a === 0) e = String(Math.floor(e));
+            else if (a < 0) {
+              e = String(Math.round(e)), e = e.slice(0, Math.max(0, e.length + a));
+              for (var h = a; h < 0; h++) e += "0";
+            } else {
+              e = String(e);
+              var d = e.indexOf(".") + 1;
+              d && (e = e.slice(0, d + a).replace(/\.?0+$/, ""));
+            }
+            e = Wo.numSeparate(e, t._separators, u);
+          }
+          if (s && o !== "hide") {
+            vlt(s, o) && (o = "power");
+            var v;
+            s < 0 ? v = qb + -s : o !== "power" ? v = "+" + s : v = String(s), o === "e" || o === "E" ? e += o + v : o === "power" ? e += "×10<sup>" + v + "</sup>" : o === "B" && s === 9 ? e += "B" : W3(o) && (e += o === "SI extended" ? dlt[s / 3 + 10] : Fse[s / 3 + 5]);
+          }
+          return i ? qb + e : e;
+        }
+        Jn.getTickFormat = function(e) {
+          var t;
+          function r(l) {
+            return typeof l != "string" ? l : Number(l.replace("M", "")) * j3;
+          }
+          function n(l, u) {
+            var c = ["L", "D"];
+            if (typeof l == typeof u) {
+              if (typeof l == "number") return l - u;
+              var f = c.indexOf(l.charAt(0)), h = c.indexOf(u.charAt(0));
+              return f === h ? Number(l.replace(/(L|D)/g, "")) - Number(u.replace(/(L|D)/g, "")) : f - h;
+            } else return typeof l == "number" ? 1 : -1;
+          }
+          function i(l, u, c) {
+            var f = c || function(v) {
+              return v;
+            }, h = u[0], d = u[1];
+            return (!h && typeof h != "number" || f(h) <= f(l)) && (!d && typeof d != "number" || f(d) >= f(l));
+          }
+          function a(l, u) {
+            var c = u[0] === null, f = u[1] === null, h = n(l, u[0]) >= 0, d = n(l, u[1]) <= 0;
+            return (c || h) && (f || d);
+          }
+          var o, s;
+          if (e.tickformatstops && e.tickformatstops.length > 0) switch (e.type) {
+            case "date":
+            case "linear": {
+              for (t = 0; t < e.tickformatstops.length; t++) if (s = e.tickformatstops[t], s.enabled && i(e.dtick, s.dtickrange, r)) {
+                o = s;
+                break;
+              }
+              break;
+            }
+            case "log": {
+              for (t = 0; t < e.tickformatstops.length; t++) if (s = e.tickformatstops[t], s.enabled && a(e.dtick, s.dtickrange)) {
+                o = s;
+                break;
+              }
+              break;
+            }
+          }
+          return o ? o.value : e.tickformat;
+        };
+        Jn.getSubplots = function(e, t) {
+          var r = e._fullLayout._subplots, n = r.cartesian.concat(r.gl2d || []), i = t ? Jn.findSubplotsWithAxis(n, t) : n;
+          return i.sort(function(a, o) {
+            var s = a.slice(1).split("y"), l = o.slice(1).split("y");
+            return s[0] === l[0] ? +s[1] - +l[1] : +s[0] - +l[0];
+          }), i;
+        };
+        Jn.findSubplotsWithAxis = function(e, t) {
+          for (var r = new RegExp(t._id.charAt(0) === "x" ? "^" + t._id + "y" : t._id + "$"), n = [], i = 0; i < e.length; i++) {
+            var a = e[i];
+            r.test(a) && n.push(a);
+          }
+          return n;
+        };
+        Jn.makeClipPaths = function(e) {
+          var t = e._fullLayout;
+          if (!t._hasOnlyLargeSploms) {
+            var r = { _offset: 0, _length: t.width, _id: "" }, n = { _offset: 0, _length: t.height, _id: "" }, i = Jn.list(e, "x", true), a = Jn.list(e, "y", true), o = [], s, l;
+            for (s = 0; s < i.length; s++) for (o.push({ x: i[s], y: n }), l = 0; l < a.length; l++) s === 0 && o.push({ x: r, y: a[l] }), o.push({ x: i[s], y: a[l] });
+            var u = t._clips.selectAll(".axesclip").data(o, function(c) {
+              return c.x._id + c.y._id;
+            });
+            u.enter().append("clipPath").classed("axesclip", true).attr("id", function(c) {
+              return "clip" + t._uid + c.x._id + c.y._id;
+            }).append("rect"), u.exit().remove(), u.each(function(c) {
+              w0.select(this).select("rect").attr({ x: c.x._offset || 0, y: c.y._offset || 0, width: c.x._length || 1, height: c.y._length || 1 });
+            });
+          }
+        };
+        Jn.draw = function(e, t, r) {
+          var n = e._fullLayout;
+          t === "redraw" && n._paper.selectAll("g.subplot").each(function(l) {
+            var u = l[0], c = n._plots[u];
+            if (c) {
+              var f = c.xaxis, h = c.yaxis;
+              c.xaxislayer.selectAll("." + f._id + "tick").remove(), c.yaxislayer.selectAll("." + h._id + "tick").remove(), c.xaxislayer.selectAll("." + f._id + "tick2").remove(), c.yaxislayer.selectAll("." + h._id + "tick2").remove(), c.xaxislayer.selectAll("." + f._id + "divider").remove(), c.yaxislayer.selectAll("." + h._id + "divider").remove(), c.minorGridlayer && c.minorGridlayer.selectAll("path").remove(), c.gridlayer && c.gridlayer.selectAll("path").remove(), c.zerolinelayer && c.zerolinelayer.selectAll("path").remove(), c.zerolinelayerAbove && c.zerolinelayerAbove.selectAll("path").remove(), n._infolayer.select(".g-" + f._id + "title").remove(), n._infolayer.select(".g-" + h._id + "title").remove();
+            }
+          });
+          var i = !t || t === "redraw" ? Jn.listIds(e) : t, a = Jn.list(e), o = a.filter(function(l) {
+            return l.autoshift;
+          }).map(function(l) {
+            return l.overlaying;
+          });
+          i.map(function(l) {
+            var u = Jn.getFromId(e, l);
+            if (u.tickmode === "sync" && u.overlaying) {
+              var c = i.findIndex(function(f) {
+                return f === u.overlaying;
+              });
+              c >= 0 && i.unshift(i.splice(c, 1).shift());
+            }
+          });
+          var s = { false: { left: 0, right: 0 } };
+          return Wo.syncOrAsync(i.map(function(l) {
+            return function() {
+              if (l) {
+                var u = Jn.getFromId(e, l);
+                r || (r = {}), r.axShifts = s, r.overlayingShiftedAx = o;
+                var c = Jn.drawOne(e, u, r);
+                return u._shiftPusher && mB(u, u._fullDepth || 0, s, true), u._r = u.range.slice(), u._rl = Wo.simpleMap(u._r, u.r2l), c;
+              }
+            };
+          }));
+        };
+        Jn.drawOne = function(e, t, r) {
+          r = r || {};
+          var n = r.axShifts || {}, i = r.overlayingShiftedAx || [], a, o, s;
+          t.setScale();
+          var l = e._fullLayout, u = t._id, c = u.charAt(0), f = Jn.counterLetter(u), h = l._plots[t._mainSubplot], d = t.zerolinelayer === "above traces";
+          if (!h) return;
+          if (t._shiftPusher = t.autoshift || i.indexOf(t._id) !== -1 || i.indexOf(t.overlaying) !== -1, t._shiftPusher & t.anchor === "free") {
+            var v = t.linewidth / 2 || 0;
+            t.ticks === "inside" && (v += t.ticklen), mB(t, v, n, true), mB(t, t.shift || 0, n, false);
+          }
+          (r.skipTitle !== true || t._shift === void 0) && (t._shift = Elt(t, n));
+          var _ = h[c + "axislayer"], b = t._mainLinePosition, p = b += t._shift, k = t._mainMirrorPosition, E = t._vals = Jn.calcTicks(t), T = [t.mirror, p, k].join("_");
+          for (a = 0; a < E.length; a++) E[a].axInfo = T;
+          t._selections = {}, t._tickAngles && (t._prevTickAngles = t._tickAngles), t._tickAngles = {}, t._depth = null;
+          var L = {};
+          function x(ut) {
+            var Wt = u + (ut || "tick");
+            return L[Wt] || (L[Wt] = ylt(t, Wt, p)), L[Wt];
+          }
+          if (t.visible) {
+            var C = Jn.makeTransTickFn(t), M = Jn.makeTransTickLabelFn(t), g, P, A = t.ticks === "inside", z = t.ticks === "outside";
+            if (t.tickson === "boundaries") {
+              var O = plt(t, E);
+              P = Jn.clipEnds(t, O), g = A ? P : O;
+            } else P = Jn.clipEnds(t, E), g = A && t.ticklabelmode !== "period" ? P : E;
+            var U = t._gridVals = P, G = mlt(t, E);
+            if (!l._hasOnlyLargeSploms) {
+              var Z = t._subplotsWith, j = {};
+              for (a = 0; a < Z.length; a++) {
+                o = Z[a], s = l._plots[o];
+                var N = s[f + "axis"], H = N._mainAxis._id;
+                if (!j[H]) {
+                  j[H] = 1;
+                  var re = c === "x" ? "M0," + N._offset + "v" + N._length : "M" + N._offset + ",0h" + N._length;
+                  Jn.drawGrid(e, t, { vals: U, counterAxis: N, layer: s.gridlayer.select("." + u), minorLayer: s.minorGridlayer.select("." + u), path: re, transFn: C }), Jn.drawZeroLine(e, t, { counterAxis: N, layer: d ? s.zerolinelayerAbove : s.zerolinelayer, path: re, transFn: C });
+                }
+              }
+            }
+            var oe, _e = Jn.getTickSigns(t), Ce = Jn.getTickSigns(t, "minor");
+            if (t.ticks || t.minor && t.minor.ticks) {
+              var Le = Jn.makeTickPath(t, p, _e[2]), ge = Jn.makeTickPath(t, p, Ce[2], { minor: true }), ie, Se, Ee, Ae;
+              if (t._anchorAxis && t.mirror && t.mirror !== true ? (ie = Jn.makeTickPath(t, k, _e[3]), Se = Jn.makeTickPath(t, k, Ce[3], { minor: true }), Ee = Le + ie, Ae = ge + Se) : (ie = "", Se = "", Ee = Le, Ae = ge), t.showdividers && z && t.tickson === "boundaries") {
+                var Be = {};
+                for (a = 0; a < G.length; a++) Be[G[a].x] = 1;
+                oe = function(ut) {
+                  return Be[ut.x] ? ie : Ee;
+                };
+              } else oe = function(ut) {
+                return ut.minor ? Ae : Ee;
+              };
+            }
+            if (Jn.drawTicks(e, t, { vals: g, layer: _, path: oe, transFn: C }), t.mirror === "allticks") {
+              var Pe = Object.keys(t._linepositions || {});
+              for (a = 0; a < Pe.length; a++) {
+                o = Pe[a], s = l._plots[o];
+                var me = t._linepositions[o] || [], De = me[0], ce = me[1], je = me[2], lt = Jn.makeTickPath(t, De, je ? _e[0] : Ce[0], { minor: je }) + Jn.makeTickPath(t, ce, je ? _e[1] : Ce[1], { minor: je });
+                Jn.drawTicks(e, t, { vals: g, layer: s[c + "axislayer"], path: lt, transFn: C });
+              }
+            }
+            var pt = [];
+            if (pt.push(function() {
+              return Jn.drawLabels(e, t, { vals: E, layer: _, plotinfo: s, transFn: M, labelFns: Jn.makeLabelFns(t, p) });
+            }), t.type === "multicategory") {
+              var Vt = { x: 2, y: 10 }[c];
+              pt.push(function() {
+                var ut = { x: "height", y: "width" }[c], Wt = x()[ut] + Vt + (t._tickAngles[u + "tick"] ? t.tickfont.size * hM : 0);
+                return Jn.drawLabels(e, t, { vals: glt(t, E), layer: _, cls: u + "tick2", repositionOnUpdate: true, secondary: true, transFn: C, labelFns: Jn.makeLabelFns(t, p + Wt * _e[4]) });
+              }), pt.push(function() {
+                return t._depth = _e[4] * (x("tick2")[t.side] - p), xlt(e, t, { vals: G, layer: _, path: Jn.makeTickPath(t, p, _e[4], { len: t._depth }), transFn: C });
+              });
+            } else t.title.hasOwnProperty("standoff") && pt.push(function() {
+              t._depth = _e[4] * (x()[t.side] - p);
+            });
+            var ot = uM.getComponentMethod("rangeslider", "isVisible")(t);
+            return !r.skipTitle && !(ot && t.side === "bottom") && pt.push(function() {
+              return blt(e, t);
+            }), pt.push(function() {
+              var ut = t.side.charAt(0), Wt = Xst[t.side].charAt(0), Nt = Jn.getPxPosition(e, t), $t = z ? t.ticklen : 0, sr, Tr, fr, $e;
+              (t.automargin || ot || t._shiftPusher) && (t.type === "multicategory" ? sr = x("tick2") : (sr = x(), c === "x" && ut === "b" && (t._depth = Math.max(sr.width > 0 ? sr.bottom - Nt : 0, $t))));
+              var St = 0, Qt = 0;
+              if (t._shiftPusher && (St = Math.max($t, sr.height > 0 ? ut === "l" ? Nt - sr.left : sr.right - Nt : 0), t.title.text !== l._dfltTitle[c] && (Qt = (t._titleStandoff || 0) + (t._titleScoot || 0), ut === "l" && (Qt += Ese(t))), t._fullDepth = Math.max(St, Qt)), t.automargin) {
+                Tr = { x: 0, y: 0, r: 0, l: 0, t: 0, b: 0 };
+                var Gt = [0, 1], _t = typeof t._shift == "number" ? t._shift : 0;
+                if (c === "x") {
+                  if (ut === "b" ? Tr[ut] = t._depth : (Tr[ut] = t._depth = Math.max(sr.width > 0 ? Nt - sr.top : 0, $t), Gt.reverse()), sr.width > 0) {
+                    var It = sr.right - (t._offset + t._length);
+                    It > 0 && (Tr.xr = 1, Tr.r = It);
+                    var mt = t._offset - sr.left;
+                    mt > 0 && (Tr.xl = 0, Tr.l = mt);
+                  }
+                } else if (ut === "l" ? (t._depth = Math.max(sr.height > 0 ? Nt - sr.left : 0, $t), Tr[ut] = t._depth - _t) : (t._depth = Math.max(sr.height > 0 ? sr.right - Nt : 0, $t), Tr[ut] = t._depth + _t, Gt.reverse()), sr.height > 0) {
+                  var er = sr.bottom - (t._offset + t._length);
+                  er > 0 && (Tr.yb = 0, Tr.b = er);
+                  var lr = t._offset - sr.top;
+                  lr > 0 && (Tr.yt = 1, Tr.t = lr);
+                }
+                Tr[f] = t.anchor === "free" ? t.position : t._anchorAxis.domain[Gt[0]], t.title.text !== l._dfltTitle[c] && (Tr[ut] += Ese(t) + (t.title.standoff || 0)), t.mirror && t.anchor !== "free" && (fr = { x: 0, y: 0, r: 0, l: 0, t: 0, b: 0 }, fr[Wt] = t.linewidth, t.mirror && t.mirror !== true && (fr[Wt] += $t), t.mirror === true || t.mirror === "ticks" ? fr[f] = t._anchorAxis.domain[Gt[1]] : (t.mirror === "all" || t.mirror === "allticks") && (fr[f] = [t._counterDomainMin, t._counterDomainMax][Gt[1]]));
+              }
+              ot && ($e = uM.getComponentMethod("rangeslider", "autoMarginOpts")(e, t)), typeof t.automargin == "string" && (Mse(Tr, t.automargin), Mse(fr, t.automargin)), G3.autoMargin(e, bB(t), Tr), G3.autoMargin(e, Ose(t), fr), G3.autoMargin(e, qse(t), $e);
+            }), Wo.syncOrAsync(pt);
+          }
+        };
+        function Mse(e, t) {
+          if (e) {
+            var r = Object.keys(_se).reduce(function(n, i) {
+              return t.indexOf(i) !== -1 && _se[i].forEach(function(a) {
+                n[a] = 1;
+              }), n;
+            }, {});
+            Object.keys(e).forEach(function(n) {
+              r[n] || (n.length === 1 ? e[n] = 0 : delete e[n]);
+            });
+          }
+        }
+        function plt(e, t) {
+          var r = [], n, i = function(a, o) {
+            var s = a.xbnd[o];
+            s !== null && r.push(Wo.extendFlat({}, a, { x: s }));
+          };
+          if (t.length) {
+            for (n = 0; n < t.length; n++) i(t[n], 0);
+            i(t[n - 1], 1);
+          }
+          return r;
+        }
+        function glt(e, t) {
+          for (var r = [], n = {}, i = 0; i < t.length; i++) {
+            var a = t[i];
+            n[a.text2] ? n[a.text2].push(a.x) : n[a.text2] = [a.x];
+          }
+          for (var o in n) r.push(Dse(e, Wo.interp(n[o], 0.5), o));
+          return r;
+        }
+        function mlt(e, t) {
+          var r = [], n, i, a = t.length && t[t.length - 1].x < t[0].x, o = function(l, u) {
+            var c = l.xbnd[u];
+            c !== null && r.push(Wo.extendFlat({}, l, { x: c }));
+          };
+          if (e.showdividers && t.length) {
+            for (n = 0; n < t.length; n++) {
+              var s = t[n];
+              s.text2 !== i && o(s, a ? 1 : 0), i = s.text2;
+            }
+            o(t[n - 1], a ? 0 : 1);
+          }
+          return r;
+        }
+        function ylt(e, t, r) {
+          var n, i, a, o;
+          if (e._selections[t].size()) n = 1 / 0, i = -1 / 0, a = 1 / 0, o = -1 / 0, e._selections[t].each(function() {
+            var l = gB(this);
+            if (l.node().style.display !== "none") {
+              var u = Xp.bBox(l.node().parentNode);
+              n = Math.min(n, u.top), i = Math.max(i, u.bottom), a = Math.min(a, u.left), o = Math.max(o, u.right);
+            }
+          });
+          else {
+            var s = Jn.makeLabelFns(e, r);
+            n = i = s.yFn({ dx: 0, dy: 0, fontSize: 0 }), a = o = s.xFn({ dx: 0, dy: 0, fontSize: 0 });
+          }
+          return { top: n, bottom: i, left: a, right: o, height: i - n, width: o - a };
+        }
+        Jn.getTickSigns = function(e, t) {
+          var r = e._id.charAt(0), n = { x: "top", y: "right" }[r], i = e.side === n ? 1 : -1, a = [-1, 1, i, -i], o = t ? (e.minor || {}).ticks : e.ticks;
+          return o !== "inside" == (r === "x") && (a = a.map(function(s) {
+            return -s;
+          })), e.side && a.push({ l: -1, t: -1, r: 1, b: 1 }[e.side.charAt(0)]), a;
+        };
+        Jn.makeTransTickFn = function(e) {
+          return e._id.charAt(0) === "x" ? function(t) {
+            return H3(e._offset + e.l2p(t.x), 0);
+          } : function(t) {
+            return H3(0, e._offset + e.l2p(t.x));
+          };
+        };
+        Jn.makeTransTickLabelFn = function(e) {
+          var t = _lt(e), r = e.ticklabelshift || 0, n = e.ticklabelstandoff || 0, i = t[0], a = t[1], o = e.range[0] > e.range[1], s = e.ticklabelposition && e.ticklabelposition.indexOf("inside") !== -1, l = !s;
+          if (r) {
+            var u = o ? -1 : 1;
+            r = r * u;
+          }
+          if (n) {
+            var c = e.side, f = s && (c === "top" || c === "left") || l && (c === "bottom" || c === "right") ? 1 : -1;
+            n = n * f;
+          }
+          return e._id.charAt(0) === "x" ? function(h) {
+            return H3(i + e._offset + e.l2p(pB(h)) + r, a + n);
+          } : function(h) {
+            return H3(a + n, i + e._offset + e.l2p(pB(h)) + r);
+          };
+        };
+        function pB(e) {
+          return e.periodX !== void 0 ? e.periodX : e.x;
+        }
+        function _lt(e) {
+          var t = e.ticklabelposition || "", r = e.tickson || "", n = function(v) {
+            return t.indexOf(v) !== -1;
+          }, i = n("top"), a = n("left"), o = n("right"), s = n("bottom"), l = n("inside"), u = r !== "boundaries" && (s || a || i || o);
+          if (!u && !l) return [0, 0];
+          var c = e.side, f = u ? (e.tickwidth || 0) / 2 : 0, h = zL, d = e.tickfont ? e.tickfont.size : 12;
+          return (s || i) && (f += d * Bb, h += (e.linewidth || 0) / 2), (a || o) && (f += (e.linewidth || 0) / 2, h += zL), l && c === "top" && (h -= d * (1 - Bb)), (a || i) && (f = -f), (c === "bottom" || c === "right") && (h = -h), [u ? f : 0, l ? h : 0];
+        }
+        Jn.makeTickPath = function(e, t, r, n) {
+          n || (n = {});
+          var i = n.minor;
+          if (i && !e.minor) return "";
+          var a = n.len !== void 0 ? n.len : i ? e.minor.ticklen : e.ticklen, o = e._id.charAt(0), s = (e.linewidth || 1) / 2;
+          return o === "x" ? "M0," + (t + s * r) + "v" + a * r : "M" + (t + s * r) + ",0h" + a * r;
+        };
+        Jn.makeLabelFns = function(e, t, r) {
+          var n = e.ticklabelposition || "", i = e.tickson || "", a = function(O) {
+            return n.indexOf(O) !== -1;
+          }, o = a("top"), s = a("left"), l = a("right"), u = a("bottom"), c = i !== "boundaries" && (u || s || o || l), f = a("inside"), h = n === "inside" && e.ticks === "inside" || !f && e.ticks === "outside" && i !== "boundaries", d = 0, v = 0, _ = h ? e.ticklen : 0;
+          if (f ? _ *= -1 : c && (_ = 0), h && (d += _, r)) {
+            var b = Wo.deg2rad(r);
+            d = _ * Math.cos(b) + 1, v = _ * Math.sin(b);
+          }
+          e.showticklabels && (h || e.showline) && (d += 0.2 * e.tickfont.size), d += (e.linewidth || 1) / 2 * (f ? -1 : 1);
+          var p = { labelStandoff: d, labelShift: v }, k, E, T, L, x = 0, C = e.side, M = e._id.charAt(0), g = e.tickangle, P;
+          if (M === "x") P = !f && C === "bottom" || f && C === "top", L = P ? 1 : -1, f && (L *= -1), k = v * L, E = t + d * L, T = P ? 1 : -0.2, Math.abs(g) === 90 && (f ? T += lM : g === -90 && C === "bottom" ? T = Bb : g === 90 && C === "top" ? T = lM : T = 0.5, x = lM / 2 * (g / 90)), p.xFn = function(O) {
+            return O.dx + k + x * O.fontSize;
+          }, p.yFn = function(O) {
+            return O.dy + E + O.fontSize * T;
+          }, p.anchorFn = function(O, U) {
+            if (c) {
+              if (s) return "end";
+              if (l) return "start";
+            }
+            return !zh(U) || U === 0 || U === 180 ? "middle" : U * L < 0 !== f ? "end" : "start";
+          }, p.heightFn = function(O, U, G) {
+            return U < -60 || U > 60 ? -0.5 * G : e.side === "top" !== f ? -G : 0;
+          };
+          else if (M === "y") {
+            if (P = !f && C === "left" || f && C === "right", L = P ? 1 : -1, f && (L *= -1), k = d, E = v * L, T = 0, !f && Math.abs(g) === 90 && (g === -90 && C === "left" || g === 90 && C === "right" ? T = Bb : T = 0.5), f) {
+              var A = zh(g) ? +g : 0;
+              if (A !== 0) {
+                var z = Wo.deg2rad(A);
+                x = Math.abs(Math.sin(z)) * Bb * L, T = 0;
+              }
+            }
+            p.xFn = function(O) {
+              return O.dx + t - (k + O.fontSize * T) * L + x * O.fontSize;
+            }, p.yFn = function(O) {
+              return O.dy + E + O.fontSize * lM;
+            }, p.anchorFn = function(O, U) {
+              return zh(U) && Math.abs(U) === 90 ? "middle" : P ? "end" : "start";
+            }, p.heightFn = function(O, U, G) {
+              return e.side === "right" && (U *= -1), U < -30 ? -G : U < 30 ? -0.5 * G : 0;
+            };
+          }
+          return p;
+        };
+        function BL(e) {
+          return [e.text, e.x, e.axInfo, e.font, e.fontSize, e.fontColor].join("_");
+        }
+        Jn.drawTicks = function(e, t, r) {
+          r = r || {};
+          var n = t._id + "tick", i = [].concat(t.minor && t.minor.ticks ? r.vals.filter(function(o) {
+            return o.minor && !o.noTick;
+          }) : []).concat(t.ticks ? r.vals.filter(function(o) {
+            return !o.minor && !o.noTick;
+          }) : []), a = r.layer.selectAll("path." + n).data(i, BL);
+          a.exit().remove(), a.enter().append("path").classed(n, 1).classed("ticks", 1).classed("crisp", r.crisp !== false).each(function(o) {
+            return cM.stroke(w0.select(this), o.minor ? t.minor.tickcolor : t.tickcolor);
+          }).style("stroke-width", function(o) {
+            return Xp.crispRound(e, o.minor ? t.minor.tickwidth : t.tickwidth, 1) + "px";
+          }).attr("d", r.path).style("display", null), NL(t, [kse]), a.attr("transform", r.transFn);
+        };
+        Jn.drawGrid = function(e, t, r) {
+          if (r = r || {}, t.tickmode !== "sync") {
+            var n = t._id + "grid", i = t.minor && t.minor.showgrid, a = i ? r.vals.filter(function(p) {
+              return p.minor;
+            }) : [], o = t.showgrid ? r.vals.filter(function(p) {
+              return !p.minor;
+            }) : [], s = r.counterAxis;
+            if (s && Jn.shouldShowZeroLine(e, t, s)) for (var l = t.tickmode === "array", u = 0; u < o.length; u++) {
+              var c = o[u].x;
+              if (l ? !c : Math.abs(c) < t.dtick / 100) if (o = o.slice(0, u).concat(o.slice(u + 1)), l) u--;
+              else break;
+            }
+            t._gw = Xp.crispRound(e, t.gridwidth, 1);
+            for (var f = i ? Xp.crispRound(e, t.minor.gridwidth, 1) : 0, h = r.layer, d = r.minorLayer, v = 1; v >= 0; v--) {
+              var _ = v ? h : d;
+              if (_) {
+                var b = _.selectAll("path." + n).data(v ? o : a, BL);
+                b.exit().remove(), b.enter().append("path").classed(n, 1).classed("crisp", r.crisp !== false), b.attr("transform", r.transFn).attr("d", r.path).each(function(p) {
+                  return cM.stroke(w0.select(this), p.minor ? t.minor.gridcolor : t.gridcolor || "#ddd");
+                }).style("stroke-dasharray", function(p) {
+                  return Xp.dashStyle(p.minor ? t.minor.griddash : t.griddash, p.minor ? t.minor.gridwidth : t.gridwidth);
+                }).style("stroke-width", function(p) {
+                  return (p.minor ? f : t._gw) + "px";
+                }).style("display", null), typeof r.path == "function" && b.attr("d", r.path);
+              }
+            }
+            NL(t, [dB, vB]);
+          }
+        };
+        Jn.drawZeroLine = function(e, t, r) {
+          r = r || r;
+          var n = t._id + "zl", i = Jn.shouldShowZeroLine(e, t, r.counterAxis), a = r.layer.selectAll("path." + n).data(i ? [{ x: 0, id: t._id }] : []);
+          a.exit().remove(), a.enter().append("path").classed(n, 1).classed("zl", 1).classed("crisp", r.crisp !== false).each(function() {
+            r.layer.selectAll("path").sort(function(o, s) {
+              return Yst(o.id, s.id);
+            });
+          }), a.attr("transform", r.transFn).attr("d", r.path).call(cM.stroke, t.zerolinecolor || cM.defaultLine).style("stroke-width", Xp.crispRound(e, t.zerolinewidth, t._gw || 1) + "px").style("display", null), NL(t, [hB]);
+        };
+        Jn.drawLabels = function(e, t, r) {
+          r = r || {};
+          var n = e._fullLayout, i = t._id, a = t.zerolinelayer === "above traces", o = r.cls || i + "tick", s = r.vals.filter(function(H) {
+            return H.text;
+          }), l = r.labelFns, u = r.secondary ? 0 : t.tickangle, c = (t._prevTickAngles || {})[o], f = r.layer.selectAll("g." + o).data(t.showticklabels ? s : [], BL), h = [];
+          f.enter().append("g").classed(o, 1).append("text").attr("text-anchor", "middle").each(function(H) {
+            var re = w0.select(this), oe = e._promises.length;
+            re.call(Ob.positionText, l.xFn(H), l.yFn(H)).call(Xp.font, { family: H.font, size: H.fontSize, color: H.fontColor, weight: H.fontWeight, style: H.fontStyle, variant: H.fontVariant, textcase: H.fontTextcase, lineposition: H.fontLineposition, shadow: H.fontShadow }).text(H.text).call(Ob.convertToTspans, e), e._promises[oe] ? h.push(e._promises.pop().then(function() {
+              d(re, u);
+            })) : d(re, u);
+          }), NL(t, [yse]), f.exit().remove(), r.repositionOnUpdate && f.each(function(H) {
+            w0.select(this).select("text").call(Ob.positionText, l.xFn(H), l.yFn(H));
+          });
+          function d(H, re) {
+            H.each(function(oe) {
+              var _e = w0.select(this), Ce = _e.select(".text-math-group"), Le = l.anchorFn(oe, re), ge = r.transFn.call(_e.node(), oe) + (zh(re) && +re != 0 ? " rotate(" + re + "," + l.xFn(oe) + "," + (l.yFn(oe) - oe.fontSize / 2) + ")" : ""), ie = Ob.lineCount(_e), Se = hM * oe.fontSize, Ee = l.heightFn(oe, zh(re) ? +re : 0, (ie - 1) * Se);
+              if (Ee && (ge += H3(0, Ee)), Ce.empty()) {
+                var Ae = _e.select("text");
+                Ae.attr({ transform: ge, "text-anchor": Le }), Ae.style("display", null), t._adjustTickLabelsOverflow && t._adjustTickLabelsOverflow();
+              } else {
+                var Be = Xp.bBox(Ce.node()).width, Pe = Be * { end: -0.5, start: 0.5 }[Le];
+                Ce.attr("transform", ge + H3(Pe, 0));
+              }
+            });
+          }
+          t._adjustTickLabelsOverflow = function() {
+            var H = t.ticklabeloverflow;
+            if (!(!H || H === "allow")) {
+              var re = H.indexOf("hide") !== -1, oe = t._id.charAt(0) === "x", _e = 0, Ce = oe ? e._fullLayout.width : e._fullLayout.height;
+              if (H.indexOf("domain") !== -1) {
+                var Le = Wo.simpleMap(t.range, t.r2l);
+                _e = t.l2p(Le[0]) + t._offset, Ce = t.l2p(Le[1]) + t._offset;
+              }
+              var ge = Math.min(_e, Ce), ie = Math.max(_e, Ce), Se = t.side, Ee = 1 / 0, Ae = -1 / 0;
+              f.each(function(De) {
+                var ce = w0.select(this), je = ce.select(".text-math-group");
+                if (je.empty()) {
+                  var lt = Xp.bBox(ce.node()), pt = 0;
+                  oe ? (lt.right > ie || lt.left < ge) && (pt = 1) : (lt.bottom > ie || lt.top + (t.tickangle ? 0 : De.fontSize / 4) < ge) && (pt = 1);
+                  var Vt = ce.select("text");
+                  pt ? re && Vt.style("display", "none") : Vt.node().style.display !== "none" && (Vt.style("display", null), Se === "bottom" || Se === "right" ? Ee = Math.min(Ee, oe ? lt.top : lt.left) : Ee = -1 / 0, Se === "top" || Se === "left" ? Ae = Math.max(Ae, oe ? lt.bottom : lt.right) : Ae = 1 / 0);
+                }
+              });
+              for (var Be in n._plots) {
+                var Pe = n._plots[Be];
+                if (!(t._id !== Pe.xaxis._id && t._id !== Pe.yaxis._id)) {
+                  var me = oe ? Pe.yaxis : Pe.xaxis;
+                  me && (me["_visibleLabelMin_" + t._id] = Ee, me["_visibleLabelMax_" + t._id] = Ae);
+                }
+              }
+            }
+          }, t._hideCounterAxisInsideTickLabels = function(H) {
+            var re = t._id.charAt(0) === "x", oe = [];
+            for (var _e in n._plots) {
+              var Ce = n._plots[_e];
+              t._id !== Ce.xaxis._id && t._id !== Ce.yaxis._id || oe.push(re ? Ce.yaxis : Ce.xaxis);
+            }
+            oe.forEach(function(Le, ge) {
+              Le && vM(Le) && (H || [hB, vB, dB, kse, yse]).forEach(function(ie) {
+                var Se = ie.K === "tick" && ie.L === "text" && t.ticklabelmode === "period", Ee = n._plots[t._mainSubplot], Ae;
+                if (ie.K === hB.K) {
+                  var Be = a ? Ee.zerolinelayerAbove : Ee.zerolinelayer;
+                  Ae = Be.selectAll("." + t._id + "zl");
+                } else ie.K === vB.K ? Ae = Ee.minorGridlayer.selectAll("." + t._id) : ie.K === dB.K ? Ae = Ee.gridlayer.selectAll("." + t._id) : Ae = Ee[t._id.charAt(0) + "axislayer"];
+                Ae.each(function() {
+                  var Pe = w0.select(this);
+                  ie.L && (Pe = Pe.selectAll(ie.L)), Pe.each(function(me) {
+                    var De = t.l2p(Se ? pB(me) : me.x) + t._offset, ce = w0.select(this);
+                    De < t["_visibleLabelMax_" + Le._id] && De > t["_visibleLabelMin_" + Le._id] ? ce.style("display", "none") : ie.K === "tick" && !ge && ce.node().style.display !== "none" && ce.style("display", null);
+                  });
+                });
+              });
+            });
+          }, d(f, c + 1 ? c : u);
+          function v() {
+            return h.length && Promise.all(h);
+          }
+          var _ = null;
+          function b() {
+            if (d(f, u), s.length && t.autotickangles && (t.type !== "log" || String(t.dtick).charAt(0) !== "D")) {
+              _ = t.autotickangles[0];
+              var H = 0, re = [], oe, _e = 1;
+              f.each(function(Tr) {
+                H = Math.max(H, Tr.fontSize);
+                var fr = t.l2p(Tr.x), $e = gB(this), St = Xp.bBox($e.node());
+                _e = Math.max(_e, Ob.lineCount($e)), re.push({ top: 0, bottom: 10, height: 10, left: fr - St.width / 2, right: fr + St.width / 2 + 2, width: St.width + 2 });
+              });
+              var Ce = (t.tickson === "boundaries" || t.showdividers) && !r.secondary, Le = s.length, ge = Math.abs((s[Le - 1].x - s[0].x) * t._m) / (Le - 1), ie = Ce ? ge / 2 : ge, Se = Ce ? t.ticklen : H * 1.25 * _e, Ee = Math.sqrt(Math.pow(ie, 2) + Math.pow(Se, 2)), Ae = ie / Ee, Be = t.autotickangles.map(function(Tr) {
+                return Tr * Math.PI / 180;
+              }), Pe = Be.find(function(Tr) {
+                return Math.abs(Math.cos(Tr)) <= Ae;
+              });
+              Pe === void 0 && (Pe = Be.reduce(function(Tr, fr) {
+                return Math.abs(Math.cos(Tr)) < Math.abs(Math.cos(fr)) ? Tr : fr;
+              }, Be[0]));
+              var me = Pe * (180 / Math.PI);
+              if (Ce) {
+                var De = 2;
+                for (t.ticks && (De += t.tickwidth / 2), oe = 0; oe < re.length; oe++) {
+                  var ce = s[oe].xbnd, je = re[oe];
+                  if (ce[0] !== null && je.left - t.l2p(ce[0]) < De || ce[1] !== null && t.l2p(ce[1]) - je.right < De) {
+                    _ = me;
+                    break;
+                  }
+                }
+              } else {
+                var lt = t.ticklabelposition || "", pt = t.tickson || "", Vt = function(Tr) {
+                  return lt.indexOf(Tr) !== -1;
+                }, ot = Vt("top"), ut = Vt("left"), Wt = Vt("right"), Nt = Vt("bottom"), $t = pt !== "boundaries" && (Nt || ut || ot || Wt), sr = $t ? (t.tickwidth || 0) + 2 * zL : 0;
+                for (oe = 0; oe < re.length - 1; oe++) if (Wo.bBoxIntersect(re[oe], re[oe + 1], sr)) {
+                  _ = me;
+                  break;
+                }
+              }
+              _ && d(f, _);
+            }
+          }
+          t._selections && (t._selections[o] = f);
+          var p = [v];
+          t.automargin && n._redrawFromAutoMarginCount && c === 90 ? (_ = c, p.push(function() {
+            d(f, c);
+          })) : p.push(b), t._tickAngles && p.push(function() {
+            t._tickAngles[o] = _ === null ? zh(u) ? u : 0 : _;
+          });
+          var k = function() {
+            var H = 0, re = 0;
+            return f.each(function(oe, _e) {
+              var Ce = gB(this), Le = Ce.select(".text-math-group");
+              if (Le.empty()) {
+                var ge;
+                t._vals[_e] && (ge = t._vals[_e].bb || Xp.bBox(Ce.node()), t._vals[_e].bb = ge), H = Math.max(H, ge.width), re = Math.max(re, ge.height);
+              }
+            }), { labelsMaxW: H, labelsMaxH: re };
+          }, E = t._anchorAxis;
+          if (E && (E.autorange || E.insiderange) && vM(t) && !Kst(n, t._id) && (n._insideTickLabelsUpdaterange || (n._insideTickLabelsUpdaterange = {}), E.autorange && (n._insideTickLabelsUpdaterange[E._name + ".autorange"] = E.autorange, p.push(k)), E.insiderange)) {
+            var T = k(), L = t._id.charAt(0) === "y" ? T.labelsMaxW : T.labelsMaxH;
+            L += 2 * zL, t.ticklabelposition === "inside" && (L += t.ticklen || 0);
+            var x = t.side === "right" || t.side === "top" ? 1 : -1, C = x === 1 ? 1 : 0, M = x === 1 ? 0 : 1, g = [];
+            g[M] = E.range[M];
+            var P = E.range, A = E.r2p(P[C]), z = E.r2p(P[M]), O = n._insideTickLabelsUpdaterange[E._name + ".range"];
+            if (O) {
+              var U = E.r2p(O[C]), G = E.r2p(O[M]), Z = x * (t._id.charAt(0) === "y" ? 1 : -1);
+              Z * A < Z * U && (A = U, g[C] = P[C] = O[C]), Z * z > Z * G && (z = G, g[M] = P[M] = O[M]);
+            }
+            var j = Math.abs(z - A);
+            j - L > 0 ? (j -= L, L *= 1 + L / j) : L = 0, t._id.charAt(0) !== "y" && (L = -L), g[C] = E.p2r(E.r2p(P[C]) + x * L), E.autorange === "min" || E.autorange === "max reversed" ? (g[0] = null, E._rangeInitial0 = void 0, E._rangeInitial1 = void 0) : (E.autorange === "max" || E.autorange === "min reversed") && (g[1] = null, E._rangeInitial0 = void 0, E._rangeInitial1 = void 0), n._insideTickLabelsUpdaterange[E._name + ".range"] = g;
+          }
+          var N = Wo.syncOrAsync(p);
+          return N && N.then && e._promises.push(N), N;
+        };
+        function xlt(e, t, r) {
+          var n = t._id + "divider", i = r.vals, a = r.layer.selectAll("path." + n).data(i, BL);
+          a.exit().remove(), a.enter().insert("path", ":first-child").classed(n, 1).classed("crisp", 1).call(cM.stroke, t.dividercolor).style("stroke-width", Xp.crispRound(e, t.dividerwidth, 1) + "px"), a.attr("transform", r.transFn).attr("d", r.path);
+        }
+        Jn.getPxPosition = function(e, t) {
+          var r = e._fullLayout._size, n = t._id.charAt(0), i = t.side, a;
+          if (t.anchor !== "free" ? a = t._anchorAxis : n === "x" ? a = { _offset: r.t + (1 - (t.position || 0)) * r.h, _length: 0 } : n === "y" && (a = { _offset: r.l + (t.position || 0) * r.w + t._shift, _length: 0 }), i === "top" || i === "left") return a._offset;
+          if (i === "bottom" || i === "right") return a._offset + a._length;
+        };
+        function Ese(e) {
+          var t = e.title.font.size, r = (e.title.text.match(Ob.BR_TAG_ALL) || []).length;
+          return e.title.hasOwnProperty("standoff") ? t * (Bb + r * hM) : r ? t * (r + 1) * hM : t;
+        }
+        function blt(e, t) {
+          var r = e._fullLayout, n = t._id, i = n.charAt(0), a = t.title.font.size, o, s = (t.title.text.match(Ob.BR_TAG_ALL) || []).length;
+          if (t.title.hasOwnProperty("standoff")) t.side === "bottom" || t.side === "right" ? o = t._depth + t.title.standoff + a * Bb : (t.side === "top" || t.side === "left") && (o = t._depth + t.title.standoff + a * (lM + s * hM));
+          else {
+            var l = vM(t);
+            if (t.type === "multicategory") o = t._depth;
+            else {
+              var u = 1.5 * a;
+              l && (u = 0.5 * a, t.ticks === "outside" && (u += t.ticklen)), o = 10 + u + (t.linewidth ? t.linewidth - 1 : 0);
+            }
+            l || (i === "x" ? o += t.side === "top" ? a * (t.showticklabels ? 1 : 0) : a * (t.showticklabels ? 1.5 : 0.5) : o += t.side === "right" ? a * (t.showticklabels ? 1 : 0.5) : a * (t.showticklabels ? 0.5 : 0));
+          }
+          var c = Jn.getPxPosition(e, t), f, h, d;
+          i === "x" ? (h = t._offset + t._length / 2, d = t.side === "top" ? c - o : c + o) : (d = t._offset + t._length / 2, h = t.side === "right" ? c + o : c - o, f = { rotate: "-90", offset: 0 });
+          var v;
+          if (t.type !== "multicategory") {
+            var _ = t._selections[t._id + "tick"];
+            if (v = { selection: _, side: t.side }, _ && _.node() && _.node().parentNode) {
+              var b = Xp.getTranslate(_.node().parentNode);
+              v.offsetLeft = b.x, v.offsetTop = b.y;
+            }
+            t.title.hasOwnProperty("standoff") && (v.pad = 0);
+          }
+          return t._titleStandoff = o, Nst.draw(e, n + "title", { propContainer: t, propName: t._name + ".title.text", placeholder: r._dfltTitle[i], avoid: v, transform: f, attributes: { x: h, y: d, "text-anchor": "middle" } });
+        }
+        Jn.shouldShowZeroLine = function(e, t, r) {
+          var n = Wo.simpleMap(t.range, t.r2l);
+          return n[0] * n[1] <= 0 && t.zeroline && (t.type === "linear" || t.type === "-") && !(t.rangebreaks && t.maskBreaks(0) === OL) && (zse(t, 0) || !wlt(e, t, r, n) || Tlt(e, t));
+        };
+        Jn.clipEnds = function(e, t) {
+          return t.filter(function(r) {
+            return zse(e, r.x);
+          });
+        };
+        function zse(e, t) {
+          var r = e.l2p(t);
+          return r > 1 && r < e._length - 1;
+        }
+        function wlt(e, t, r, n) {
+          var i = r._mainAxis;
+          if (!i) return;
+          var a = e._fullLayout, o = t._id.charAt(0), s = Jn.counterLetter(t._id), l = t._offset + (Math.abs(n[0]) < Math.abs(n[1]) == (o === "x") ? 0 : t._length);
+          function u(v) {
+            if (!v.showline || !v.linewidth) return false;
+            var _ = Math.max((v.linewidth + t.zerolinewidth) / 2, 1);
+            function b(E) {
+              return typeof E == "number" && Math.abs(E - l) < _;
+            }
+            if (b(v._mainLinePosition) || b(v._mainMirrorPosition)) return true;
+            var p = v._linepositions || {};
+            for (var k in p) if (b(p[k][0]) || b(p[k][1])) return true;
+          }
+          var c = a._plots[r._mainSubplot];
+          if (!(c.mainplotinfo || c).overlays.length) return u(r);
+          for (var f = Jn.list(e, s), h = 0; h < f.length; h++) {
+            var d = f[h];
+            if (d._mainAxis === i && u(d)) return true;
+          }
+        }
+        function Tlt(e, t) {
+          for (var r = e._fullData, n = t._mainSubplot, i = t._id.charAt(0), a = 0; a < r.length; a++) {
+            var o = r[a];
+            if (o.visible === true && o.xaxis + o.yaxis === n && (uM.traceIs(o, "bar-like") && o.orientation === { x: "h", y: "v" }[i] || o.fill && o.fill.charAt(o.fill.length - 1) === i)) return true;
+          }
+          return false;
+        }
+        function gB(e) {
+          var t = w0.select(e), r = t.select(".text-math-group");
+          return r.empty() ? t.select("text") : r;
+        }
+        Jn.allowAutoMargin = function(e) {
+          for (var t = Jn.list(e, "", true), r = 0; r < t.length; r++) {
+            var n = t[r];
+            n.automargin && (G3.allowAutoMargin(e, bB(n)), n.mirror && G3.allowAutoMargin(e, Ose(n))), uM.getComponentMethod("rangeslider", "isVisible")(n) && G3.allowAutoMargin(e, qse(n));
+          }
+        };
+        function bB(e) {
+          return e._id + ".automargin";
+        }
+        function Ose(e) {
+          return bB(e) + ".mirror";
+        }
+        function qse(e) {
+          return e._id + ".rangeslider";
+        }
+        Jn.swap = function(e, t) {
+          for (var r = Alt(e, t), n = 0; n < r.length; n++) Slt(e, r[n].x, r[n].y);
+        };
+        function Alt(e, t) {
+          var r = [], n, i;
+          for (n = 0; n < t.length; n++) {
+            var a = [], o = e._fullData[t[n]].xaxis, s = e._fullData[t[n]].yaxis;
+            if (!(!o || !s)) {
+              for (i = 0; i < r.length; i++) (r[i].x.indexOf(o) !== -1 || r[i].y.indexOf(s) !== -1) && a.push(i);
+              if (!a.length) {
+                r.push({ x: [o], y: [s] });
+                continue;
+              }
+              var l = r[a[0]], u;
+              if (a.length > 1) for (i = 1; i < a.length; i++) u = r[a[i]], LL(l.x, u.x), LL(l.y, u.y);
+              LL(l.x, [o]), LL(l.y, [s]);
+            }
+          }
+          return r;
+        }
+        function LL(e, t) {
+          for (var r = 0; r < t.length; r++) e.indexOf(t[r]) === -1 && e.push(t[r]);
+        }
+        function Slt(e, t, r) {
+          var n = [], i = [], a = e.layout, o, s;
+          for (o = 0; o < t.length; o++) n.push(Jn.getFromId(e, t[o]));
+          for (o = 0; o < r.length; o++) i.push(Jn.getFromId(e, r[o]));
+          var l = Object.keys(Ust), u = ["anchor", "domain", "overlaying", "position", "side", "tickangle", "editType"], c = ["linear", "log"];
+          for (o = 0; o < l.length; o++) {
+            var f = l[o], h = n[0][f], d = i[0][f], v = true, _ = false, b = false;
+            if (!(f.charAt(0) === "_" || typeof h == "function" || u.indexOf(f) !== -1)) {
+              for (s = 1; s < n.length && v; s++) {
+                var p = n[s][f];
+                f === "type" && c.indexOf(h) !== -1 && c.indexOf(p) !== -1 && h !== p ? _ = true : p !== h && (v = false);
+              }
+              for (s = 1; s < i.length && v; s++) {
+                var k = i[s][f];
+                f === "type" && c.indexOf(d) !== -1 && c.indexOf(k) !== -1 && d !== k ? b = true : i[s][f] !== d && (v = false);
+              }
+              v && (_ && (a[n[0]._name].type = "linear"), b && (a[i[0]._name].type = "linear"), Mlt(a, f, n, i, e._fullLayout._dfltTitle));
+            }
+          }
+          for (o = 0; o < e._fullLayout.annotations.length; o++) {
+            var E = e._fullLayout.annotations[o];
+            t.indexOf(E.xref) !== -1 && r.indexOf(E.yref) !== -1 && Wo.swapAttrs(a.annotations[o], ["?"]);
+          }
+        }
+        function Mlt(e, t, r, n, i) {
+          var a = Wo.nestedProperty, o = a(e[r[0]._name], t).get(), s = a(e[n[0]._name], t).get(), l;
+          for (t === "title" && (o && o.text === i.x && (o.text = i.y), s && s.text === i.y && (s.text = i.x)), l = 0; l < r.length; l++) a(e, r[l]._name + "." + t).set(s);
+          for (l = 0; l < n.length; l++) a(e, n[l]._name + "." + t).set(o);
+        }
+        function wB(e) {
+          return e._id === "angularaxis";
+        }
+        function cB(e, t) {
+          for (var r = t._rangebreaks.length, n = 0; n < r; n++) {
+            var i = t._rangebreaks[n];
+            if (e >= i.min && e < i.max) return i.max;
+          }
+          return e;
+        }
+        function vM(e) {
+          return (e.ticklabelposition || "").indexOf("inside") !== -1;
+        }
+        function NL(e, t) {
+          vM(e._anchorAxis || {}) && e._hideCounterAxisInsideTickLabels && e._hideCounterAxisInsideTickLabels(t);
+        }
+        function mB(e, t, r, n) {
+          var i = e.anchor !== "free" && (e.overlaying === void 0 || e.overlaying === false) ? e._id : e.overlaying, a;
+          n ? a = e.side === "right" ? t : -t : a = t, i in r || (r[i] = {}), e.side in r[i] || (r[i][e.side] = 0), r[i][e.side] += a;
+        }
+        function Elt(e, t) {
+          return e.autoshift ? t[e.overlaying][e.side] : e.shift || 0;
+        }
+        function klt(e, t) {
+          return /%f/.test(t) ? e >= Wst : /%L/.test(t) ? e >= jst : /%[SX]/.test(t) ? e >= FL : /%M/.test(t) ? e >= fM : /%[HI]/.test(t) ? e >= wm : /%p/.test(t) ? e >= v_ : /%[Aadejuwx]/.test(t) ? e >= Ov : /%[UVW]/.test(t) ? e >= Zp : /%[Bbm]/.test(t) ? e >= DL : /%[q]/.test(t) ? e >= RL : /%[Yy]/.test(t) ? e >= IL : true;
+        }
+      });
+      var TB = ye((nar, Nse) => {
+        Nse.exports = function(t, r, n) {
+          var i, a;
+          if (n) {
+            var o = r === "reversed" || r === "min reversed" || r === "max reversed";
+            i = n[o ? 1 : 0], a = n[o ? 0 : 1];
+          }
+          var s = t("autorangeoptions.minallowed", a === null ? i : void 0), l = t("autorangeoptions.maxallowed", i === null ? a : void 0);
+          s === void 0 && t("autorangeoptions.clipmin"), l === void 0 && t("autorangeoptions.clipmax"), t("autorangeoptions.include");
+        };
+      });
+      var AB = ye((aar, Use) => {
+        var Clt = TB();
+        Use.exports = function(t, r, n, i) {
+          var a = r._template || {}, o = r.type || a.type || "-";
+          n("minallowed"), n("maxallowed");
+          var s = n("range");
+          if (!s) {
+            var l;
+            !i.noInsiderange && o !== "log" && (l = n("insiderange"), l && (l[0] === null || l[1] === null) && (r.insiderange = false, l = void 0), l && (s = n("range", l)));
+          }
+          var u = r.getAutorangeDflt(s, i), c = n("autorange", u), f;
+          s && (s[0] === null && s[1] === null || (s[0] === null || s[1] === null) && (c === "reversed" || c === true) || s[0] !== null && (c === "min" || c === "max reversed") || s[1] !== null && (c === "max" || c === "min reversed")) && (s = void 0, delete r.range, r.autorange = true, f = true), f || (u = r.getAutorangeDflt(s, i), c = n("autorange", u)), c && (Clt(n, c, s), (o === "linear" || o === "-") && n("rangemode")), r.cleanRange();
+        };
+      });
+      var Gse = ye((oar, Vse) => {
+        var Llt = { left: 0, top: 0 };
+        Vse.exports = Plt;
+        function Plt(e, t, r) {
+          t = t || e.currentTarget || e.srcElement, Array.isArray(r) || (r = [0, 0]);
+          var n = e.clientX || 0, i = e.clientY || 0, a = Ilt(t);
+          return r[0] = n - a.left, r[1] = i - a.top, r;
+        }
+        function Ilt(e) {
+          return e === window || e === document || e === document.body ? Llt : e.getBoundingClientRect();
+        }
+      });
+      var UL = ye((sar, Hse) => {
+        var Rlt = oq();
+        function Dlt() {
+          var e = false;
+          try {
+            var t = Object.defineProperty({}, "passive", { get: function() {
+              e = true;
+            } });
+            window.addEventListener("test", null, t), window.removeEventListener("test", null, t);
+          } catch (r) {
+            e = false;
+          }
+          return e;
+        }
+        Hse.exports = Rlt && Dlt();
+      });
+      var Wse = ye((lar, jse) => {
+        jse.exports = function(t, r, n, i, a) {
+          var o = (t - n) / (i - n), s = o + r / (i - n), l = (o + s) / 2;
+          return a === "left" || a === "bottom" ? o : a === "center" || a === "middle" ? l : a === "right" || a === "top" ? s : o < 2 / 3 - l ? o : s > 4 / 3 - l ? s : l;
+        };
+      });
+      var Yse = ye((uar, Zse) => {
+        var Xse = Dr(), Flt = [["sw-resize", "s-resize", "se-resize"], ["w-resize", "move", "e-resize"], ["nw-resize", "n-resize", "ne-resize"]];
+        Zse.exports = function(t, r, n, i) {
+          return n === "left" ? t = 0 : n === "center" ? t = 1 : n === "right" ? t = 2 : t = Xse.constrain(Math.floor(t * 3), 0, 2), i === "bottom" ? r = 0 : i === "middle" ? r = 1 : i === "top" ? r = 2 : r = Xse.constrain(Math.floor(r * 3), 0, 2), Flt[r][t];
+        };
+      });
+      var Jse = ye((car, Kse) => {
+        var zlt = k3(), Olt = H6(), qlt = HS().getGraphDiv, Blt = NS(), SB = Kse.exports = {};
+        SB.wrapped = function(e, t, r) {
+          e = qlt(e), e._fullLayout && Olt.clear(e._fullLayout._uid + Blt.HOVERID), SB.raw(e, t, r);
+        };
+        SB.raw = function(t, r) {
+          var n = t._fullLayout, i = t._hoverdata;
+          r || (r = {}), !(r.target && !t._dragged && zlt.triggerHandler(t, "plotly_beforehover", r) === false) && (n._hoverlayer.selectAll("g").remove(), n._hoverlayer.selectAll("line").remove(), n._hoverlayer.selectAll("circle").remove(), t._hoverdata = void 0, r.target && i && t.emit("plotly_unhover", { event: r, points: i }));
+        };
+      });
+      var yv = ye((far, tle) => {
+        var Nlt = Gse(), MB = lq(), Ult = UL(), Vlt = Dr().removeElement, Glt = Rh(), Nb = tle.exports = {};
+        Nb.align = Wse();
+        Nb.getCursor = Yse();
+        var Qse = Jse();
+        Nb.unhover = Qse.wrapped;
+        Nb.unhoverRaw = Qse.raw;
+        Nb.init = function(t) {
+          var r = t.gd, n = 1, i = r._context.doubleClickDelay, a = t.element, o, s, l, u, c, f, h, d;
+          r._mouseDownTime || (r._mouseDownTime = 0), a.style.pointerEvents = "all", a.onmousedown = b, Ult ? (a._ontouchstart && a.removeEventListener("touchstart", a._ontouchstart), a._ontouchstart = b, a.addEventListener("touchstart", b, { passive: false })) : a.ontouchstart = b;
+          function v(E, T, L) {
+            return Math.abs(E) < L && (E = 0), Math.abs(T) < L && (T = 0), [E, T];
+          }
+          var _ = t.clampFn || v;
+          function b(E) {
+            r._dragged = false, r._dragging = true;
+            var T = $se(E);
+            o = T[0], s = T[1], h = E.target, f = E, d = E.buttons === 2 || E.ctrlKey, typeof E.clientX == "undefined" && typeof E.clientY == "undefined" && (E.clientX = o, E.clientY = s), l = (/* @__PURE__ */ new Date()).getTime(), l - r._mouseDownTime < i ? n += 1 : (n = 1, r._mouseDownTime = l), t.prepFn && t.prepFn(E, o, s), MB && !d ? (c = ele(), c.style.cursor = window.getComputedStyle(a).cursor) : MB || (c = document, u = window.getComputedStyle(document.documentElement).cursor, document.documentElement.style.cursor = window.getComputedStyle(a).cursor), document.addEventListener("mouseup", k), document.addEventListener("touchend", k), t.dragmode !== false && (E.preventDefault(), document.addEventListener("mousemove", p), document.addEventListener("touchmove", p, { passive: false }));
+          }
+          function p(E) {
+            E.preventDefault();
+            var T = $se(E), L = t.minDrag || Glt.MINDRAG, x = _(T[0] - o, T[1] - s, L), C = x[0], M = x[1];
+            (C || M) && (r._dragged = true, Nb.unhover(r, E)), r._dragged && t.moveFn && !d && (r._dragdata = { element: a, dx: C, dy: M }, t.moveFn(C, M));
+          }
+          function k(E) {
+            if (delete r._dragdata, t.dragmode !== false && (E.preventDefault(), document.removeEventListener("mousemove", p), document.removeEventListener("touchmove", p)), document.removeEventListener("mouseup", k), document.removeEventListener("touchend", k), MB ? Vlt(c) : u && (c.documentElement.style.cursor = u, u = null), !r._dragging) {
+              r._dragged = false;
+              return;
+            }
+            if (r._dragging = false, (/* @__PURE__ */ new Date()).getTime() - r._mouseDownTime > i && (n = Math.max(n - 1, 1)), r._dragged) t.doneFn && t.doneFn();
+            else {
+              var T;
+              f.target === h ? T = f : (T = { target: h, srcElement: h, toElement: h }, Object.keys(f).concat(Object.keys(f.__proto__)).forEach((L) => {
+                var x = f[L];
+                !T[L] && typeof x != "function" && (T[L] = x);
+              })), t.clickFn && t.clickFn(n, T), d || h.dispatchEvent(new MouseEvent("click", E));
+            }
+            r._dragging = false, r._dragged = false;
+          }
+        };
+        function ele() {
+          var e = document.createElement("div");
+          e.className = "dragcover";
+          var t = e.style;
+          return t.position = "fixed", t.left = 0, t.right = 0, t.top = 0, t.bottom = 0, t.zIndex = 999999999, t.background = "none", document.body.appendChild(e), e;
+        }
+        Nb.coverSlip = ele;
+        function $se(e) {
+          return Nlt(e.changedTouches ? e.changedTouches[0] : e, document.body);
+        }
+      });
+      var Eg = ye((har, rle) => {
+        rle.exports = function(t, r) {
+          (t.attr("class") || "").split(" ").forEach(function(n) {
+            n.indexOf("cursor-") === 0 && t.classed(n, false);
+          }), r && t.classed("cursor-" + r, true);
+        };
+      });
+      var ale = ye((dar, nle) => {
+        var EB = Eg(), pM = "data-savedcursor", ile = "!!";
+        nle.exports = function(t, r) {
+          var n = t.attr(pM);
+          if (r) {
+            if (!n) {
+              for (var i = (t.attr("class") || "").split(" "), a = 0; a < i.length; a++) {
+                var o = i[a];
+                o.indexOf("cursor-") === 0 && t.attr(pM, o.slice(7)).classed(o, false);
+              }
+              t.attr(pM) || t.attr(pM, ile);
+            }
+            EB(t, r);
+          } else n && (t.attr(pM, null), n === ile ? EB(t) : EB(t, n));
+        };
+      });
+      var CB = ye((par, ole) => {
+        var kB = ec(), Hlt = Ih();
+        ole.exports = { _isSubplotObj: true, visible: { valType: "boolean", dflt: true, editType: "legend" }, bgcolor: { valType: "color", editType: "legend" }, bordercolor: { valType: "color", dflt: Hlt.defaultLine, editType: "legend" }, maxheight: { valType: "number", min: 0, editType: "legend" }, borderwidth: { valType: "number", min: 0, dflt: 0, editType: "legend" }, font: kB({ editType: "legend" }), grouptitlefont: kB({ editType: "legend" }), orientation: { valType: "enumerated", values: ["v", "h"], dflt: "v", editType: "legend" }, traceorder: { valType: "flaglist", flags: ["reversed", "grouped"], extras: ["normal"], editType: "legend" }, tracegroupgap: { valType: "number", min: 0, dflt: 10, editType: "legend" }, entrywidth: { valType: "number", min: 0, editType: "legend" }, entrywidthmode: { valType: "enumerated", values: ["fraction", "pixels"], dflt: "pixels", editType: "legend" }, indentation: { valType: "number", min: -15, dflt: 0, editType: "legend" }, itemsizing: { valType: "enumerated", values: ["trace", "constant"], dflt: "trace", editType: "legend" }, itemwidth: { valType: "number", min: 30, dflt: 30, editType: "legend" }, itemclick: { valType: "enumerated", values: ["toggle", "toggleothers", false], dflt: "toggle", editType: "legend" }, itemdoubleclick: { valType: "enumerated", values: ["toggle", "toggleothers", false], dflt: "toggleothers", editType: "legend" }, groupclick: { valType: "enumerated", values: ["toggleitem", "togglegroup"], dflt: "togglegroup", editType: "legend" }, titleclick: { valType: "enumerated", values: ["toggle", "toggleothers", false], editType: "legend" }, titledoubleclick: { valType: "enumerated", values: ["toggle", "toggleothers", false], editType: "legend" }, x: { valType: "number", editType: "legend" }, xref: { valType: "enumerated", dflt: "paper", values: ["container", "paper"], editType: "layoutstyle" }, xanchor: { valType: "enumerated", values: ["auto", "left", "center", "right"], dflt: "left", editType: "legend" }, y: { valType: "number", editType: "legend" }, yref: { valType: "enumerated", dflt: "paper", values: ["container", "paper"], editType: "layoutstyle" }, yanchor: { valType: "enumerated", values: ["auto", "top", "middle", "bottom"], editType: "legend" }, uirevision: { valType: "any", editType: "none" }, valign: { valType: "enumerated", values: ["top", "middle", "bottom"], dflt: "middle", editType: "legend" }, title: { text: { valType: "string", dflt: "", editType: "legend" }, font: kB({ editType: "legend" }), side: { valType: "enumerated", values: ["top", "left", "top left", "top center", "top right"], editType: "legend" }, editType: "legend" }, editType: "legend" };
+      });
+      var mM = ye((gM) => {
+        gM.isGrouped = function(t) {
+          return (t.traceorder || "").indexOf("grouped") !== -1;
+        };
+        gM.isVertical = function(t) {
+          return t.orientation !== "h";
+        };
+        gM.isReversed = function(t) {
+          return (t.traceorder || "").indexOf("reversed") !== -1;
+        };
+        gM.getId = function(t) {
+          return t._id || "legend";
+        };
+      });
+      var PB = ye((mar, sle) => {
+        var VL = qa(), Yp = Dr(), jlt = vl(), Wlt = Gl(), Xlt = CB(), Zlt = _3(), LB = mM();
+        function Ylt(e, t, r, n, i) {
+          var a = t[e] || {}, o = jlt.newContainer(r, e);
+          function s(H, re) {
+            return Yp.coerce(a, o, Xlt, H, re);
+          }
+          var l = Yp.coerceFont(s, "font", r.font);
+          s("bgcolor", r.paper_bgcolor), s("bordercolor");
+          var u = s("visible");
+          if (!u) return;
+          var c, f = function(H, re) {
+            var oe = c._input, _e = c;
+            return Yp.coerce(oe, _e, Wlt, H, re);
+          }, h = r.font || {}, d = Yp.coerceFont(s, "grouptitlefont", h, { overrideDflt: { size: Math.round(h.size * 1.1) } }), v = 0, _ = false, b = "normal", p = (r.shapes || []).filter(function(H) {
+            return H.showlegend;
+          });
+          function k(H) {
+            return VL.traceIs(H, "pie-like") && H._length != null && (Array.isArray(H.legend) || Array.isArray(H.showlegend));
+          }
+          n.filter(k).forEach(function(H) {
+            H.visible && v++;
+            for (var re = 0; re < H._length; re++) {
+              var oe = (Array.isArray(H.legend) ? H.legend[re] : H.legend) || "legend";
+              oe === e && ((Array.isArray(H.showlegend) ? H.showlegend[re] : H.showlegend) || H._dfltShowLegend) && (_ = true, v++);
+            }
+            if (e === "legend" && H._length > H.legend.length) for (var _e = H.legend.length; _e < H._length; _e++) _ = true, v++;
+          });
+          for (var E = n.concat(p).filter(function(H) {
+            return !k(c) && e === (H.legend || "legend");
+          }), T = 0; T < E.length; T++) if (c = E[T], !!c.visible) {
+            var L = c._isShape;
+            (c.showlegend || c._dfltShowLegend && !(c._module && c._module.attributes && c._module.attributes.showlegend && c._module.attributes.showlegend.dflt === false)) && (v++, c.showlegend && (_ = true, (!L && VL.traceIs(c, "pie-like") || c._input.showlegend === true) && v++), Yp.coerceFont(f, "legendgrouptitle.font", d)), (!L && VL.traceIs(c, "bar") && r.barmode === "stack" || ["tonextx", "tonexty"].indexOf(c.fill) !== -1) && (b = LB.isGrouped({ traceorder: b }) ? "grouped+reversed" : "reversed"), c.legendgroup !== void 0 && c.legendgroup !== "" && (b = LB.isReversed({ traceorder: b }) ? "reversed+grouped" : "grouped");
+          }
+          var x = Yp.coerce(t, r, Zlt, "showlegend", r.showlegend || _ && v > (e === "legend" ? 1 : 0));
+          if (x === false && (r[e] = void 0), !(x === false && !a.uirevision) && (s("uirevision", r.uirevision), x !== false)) {
+            s("borderwidth");
+            var C = s("orientation"), M = s("yref"), g = s("xref"), P = C === "h", A = M === "paper", z = g === "paper", O, U, G, Z = "left";
+            P ? (O = 0, VL.getComponentMethod("rangeslider", "isVisible")(t.xaxis) ? A ? (U = 1.1, G = "bottom") : (U = 1, G = "top") : A ? (U = -0.1, G = "top") : (U = 0, G = "bottom")) : (U = 1, G = "auto", z ? O = 1.02 : (O = 1, Z = "right")), Yp.coerce(a, o, { x: { valType: "number", editType: "legend", min: z ? -2 : 0, max: z ? 3 : 1, dflt: O } }, "x"), Yp.coerce(a, o, { y: { valType: "number", editType: "legend", min: A ? -2 : 0, max: A ? 3 : 1, dflt: U } }, "y"), s("traceorder", b), LB.isGrouped(r[e]) && s("tracegroupgap"), s("entrywidth"), s("entrywidthmode"), s("indentation"), s("itemsizing"), s("itemwidth"), s("itemclick"), s("itemdoubleclick"), s("groupclick"), s("xanchor", Z), s("yanchor", G), s("maxheight"), s("valign"), Yp.noneOrAll(a, o, ["x", "y"]);
+            var j = s("title.text");
+            if (j) {
+              s("title.side", P ? "left" : "top");
+              var N = Yp.extendFlat({}, l, { size: Yp.bigFont(l.size) });
+              Yp.coerceFont(s, "title.font", N);
+              let H = i > 1;
+              s("titleclick", H ? "toggle" : false), s("titledoubleclick", H ? "toggleothers" : false);
+            }
+          }
+        }
+        sle.exports = function(t, r, n) {
+          var i, a = n.slice(), o = r.shapes;
+          if (o) for (i = 0; i < o.length; i++) {
+            var s = o[i];
+            if (s.showlegend) {
+              var l = { _input: s._input, visible: s.visible, showlegend: s.showlegend, legend: s.legend };
+              a.push(l);
+            }
+          }
+          var u = ["legend"];
+          for (i = 0; i < a.length; i++) Array.isArray(a[i].legend) ? u = u.concat(a[i].legend) : Yp.pushUnique(u, a[i].legend);
+          for (r._legends = [], i = 0; i < u.length; i++) {
+            var c = u[i];
+            Ylt(c, t, r, a, u.length), r[c] && (r[c]._id = c), r._legends.push(c);
+          }
+        };
+      });
+      var DB = ye((RB) => {
+        var p_ = qa(), IB = Dr(), Klt = IB.pushUnique, Jlt = mM(), lle = true;
+        RB.handleItemClick = function(t, r, n, i) {
+          var a = r._fullLayout;
+          if (r._dragged || r._editing) return;
+          var o = t.data()[0][0];
+          if (o.groupTitle && o.noClick) return;
+          var s = n.groupclick;
+          i === "toggle" && n.itemdoubleclick === "toggleothers" && lle && r.data && r._context.showTips && (IB.notifier(IB._(r, "Double-click on legend to isolate one trace"), "long"), lle = false);
+          var l = s === "togglegroup", u = a.hiddenlabels ? a.hiddenlabels.slice() : [], c = r._fullData, f = (a.shapes || []).filter(function(ot) {
+            return ot.showlegend;
+          }), h = c.concat(f), d = o.trace;
+          d._isShape && (d = d._fullInput);
+          var v = d.legendgroup, _, b, p, k, E, T, L = {}, x = [], C = [], M = [];
+          function g(ot, ut) {
+            var Wt = x.indexOf(ot), Nt = L.visible;
+            return Nt || (Nt = L.visible = []), x.indexOf(ot) === -1 && (x.push(ot), Wt = x.length - 1), Nt[Wt] = ut, Wt;
+          }
+          var P = (a.shapes || []).map(function(ot) {
+            return ot._input;
+          }), A = false;
+          function z(ot, ut) {
+            P[ot].visible = ut, A = true;
+          }
+          function O(ot, ut) {
+            if (!(o.groupTitle && !l)) {
+              var Wt = ot._fullInput || ot, Nt = Wt._isShape, $t = Wt.index;
+              $t === void 0 && ($t = Wt._index);
+              var sr = Wt.visible === false ? false : ut;
+              Nt ? z($t, sr) : g($t, sr);
+            }
+          }
+          var U = d.legend, G = d._fullInput, Z = G && G._isShape;
+          if (!Z && p_.traceIs(d, "pie-like")) {
+            var j = o.label, N = u.indexOf(j);
+            if (i === "toggle") N === -1 ? u.push(j) : u.splice(N, 1);
+            else if (i === "toggleothers") {
+              var H = N !== -1, re = [];
+              for (_ = 0; _ < r.calcdata.length; _++) {
+                var oe = r.calcdata[_];
+                for (b = 0; b < oe.length; b++) {
+                  var _e = oe[b], Ce = _e.label;
+                  U === oe[0].trace.legend && j !== Ce && (u.indexOf(Ce) === -1 && (H = true), Klt(u, Ce), re.push(Ce));
+                }
+              }
+              if (!H) for (var Le = 0; Le < re.length; Le++) {
+                var ge = u.indexOf(re[Le]);
+                ge !== -1 && u.splice(ge, 1);
+              }
+            }
+            p_.call("_guiRelayout", r, "hiddenlabels", u);
+          } else {
+            var ie = v && v.length, Se = [], Ee;
+            if (ie) for (_ = 0; _ < h.length; _++) Ee = h[_], Ee.visible && Ee.legendgroup === v && Se.push(_);
+            if (i === "toggle") {
+              var Ae;
+              switch (d.visible) {
+                case true:
+                  Ae = "legendonly";
+                  break;
+                case false:
+                  Ae = false;
+                  break;
+                case "legendonly":
+                  Ae = true;
+                  break;
+              }
+              if (ie) if (l) for (_ = 0; _ < h.length; _++) {
+                var Be = h[_];
+                Be.visible !== false && Be.legendgroup === v && O(Be, Ae);
+              }
+              else O(d, Ae);
+              else O(d, Ae);
+            } else if (i === "toggleothers") {
+              var Pe, me, De, ce, je, lt = true;
+              for (_ = 0; _ < h.length; _++) if (je = h[_], Pe = je === d, De = je.showlegend !== true, !(Pe || De) && (me = ie && je.legendgroup === v, !me && je.legend === U && je.visible === true && !p_.traceIs(je, "notLegendIsolatable"))) {
+                lt = false;
+                break;
+              }
+              for (_ = 0; _ < h.length; _++) if (je = h[_], !(je.visible === false || je.legend !== U) && !p_.traceIs(je, "notLegendIsolatable")) switch (d.visible) {
+                case "legendonly":
+                  O(je, true);
+                  break;
+                case true:
+                  ce = lt ? true : "legendonly", Pe = je === d, De = je.showlegend !== true && !je.legendgroup, me = Pe || ie && je.legendgroup === v, O(je, me || De ? true : ce);
+                  break;
+              }
+            }
+            for (_ = 0; _ < C.length; _++) if (p = C[_], !!p) {
+              var pt = p.constructUpdate(), Vt = Object.keys(pt);
+              for (b = 0; b < Vt.length; b++) k = Vt[b], T = L[k] = L[k] || [], T[M[_]] = pt[k];
+            }
+            for (E = Object.keys(L), _ = 0; _ < E.length; _++) for (k = E[_], b = 0; b < x.length; b++) L[k].hasOwnProperty(b) || (L[k][b] = void 0);
+            A ? p_.call("_guiUpdate", r, L, { shapes: P }, x) : p_.call("_guiRestyle", r, L, x);
+          }
+        };
+        RB.handleTitleClick = function(t, r, n) {
+          let i = t._fullLayout, a = t._fullData, o = Jlt.getId(r), s = (i.shapes || []).filter(function(p) {
+            return p.showlegend;
+          }), l = a.concat(s);
+          function u(p) {
+            return (p.legend || "legend") === o;
+          }
+          var c, f;
+          if (n === "toggle") c = !l.some(function(k) {
+            return u(k) && k.visible === true;
+          }), f = false;
+          else {
+            let p = l.some(function(k) {
+              return !u(k) && k.visible === true && k.showlegend !== false;
+            });
+            c = true, f = !p;
+          }
+          let h = { visible: [] }, d = [], v = (i.shapes || []).map(function(p) {
+            return p._input;
+          });
+          for (var _ = false, b = 0; b < l.length; b++) {
+            let p = l[b], k = u(p);
+            if (!k) {
+              let L = p.showlegend !== true && !p.legendgroup;
+              if (n === "toggle" || L) continue;
+            }
+            let T = (k ? c : f) ? true : "legendonly";
+            p.visible !== false && p.visible !== T && (p._isShape ? (v[p._index].visible = T, _ = true) : (d.push(p.index), h.visible.push(T)));
+          }
+          _ ? p_.call("_guiUpdate", t, h, { shapes: v }, d) : d.length && p_.call("_guiRestyle", t, h, d);
+        };
+      });
+      var FB = ye((_ar, ule) => {
+        ule.exports = { scrollBarWidth: 6, scrollBarMinHeight: 20, scrollBarColor: "#808BA4", scrollBarMargin: 4, scrollBarEnterAttrs: { rx: 20, ry: 3, width: 0, height: 0 }, titlePad: 2, itemGap: 5 };
+      });
+      var hle = ye((xar, fle) => {
+        var cle = qa(), zB = mM();
+        fle.exports = function(t, r, n) {
+          var i = r._inHover, a = zB.isGrouped(r), o = zB.isReversed(r), s = {}, l = [], u = false, c = {}, f = 0, h = 0, d, v;
+          function _(H, re, oe) {
+            if (r.visible !== false && !(n && H !== r._id)) if (re === "" || !zB.isGrouped(r)) {
+              var _e = "~~i" + f;
+              l.push(_e), s[_e] = [oe], f++;
+            } else l.indexOf(re) === -1 ? (l.push(re), u = true, s[re] = [oe]) : s[re].push(oe);
+          }
+          for (d = 0; d < t.length; d++) {
+            var b = t[d], p = b[0], k = p.trace, E = k.legend, T = k.legendgroup;
+            if (!(!i && (!k.visible || !k.showlegend))) if (cle.traceIs(k, "pie-like")) {
+              var L = Array.isArray(k.legend), x = Array.isArray(k.showlegend);
+              for (c[T] || (c[T] = {}), v = 0; v < b.length; v++) if (!(x && k.showlegend[b[v].i] === false)) {
+                L && (E = k.legend[b[v].i] || "legend");
+                var C = b[v].label;
+                c[T][C] || (_(E, T, { label: C, color: b[v].color, i: b[v].i, trace: k, pts: b[v].pts }), c[T][C] = true, h = Math.max(h, (C || "").length));
+              }
+            } else _(E, T, p), h = Math.max(h, (k.name || "").length);
+          }
+          if (!l.length) return [];
+          var M = !u || !a, g = [];
+          for (d = 0; d < l.length; d++) {
+            var P = s[l[d]];
+            M ? g.push(P[0]) : g.push(P);
+          }
+          for (M && (g = [g]), d = 0; d < g.length; d++) {
+            var A = 1 / 0;
+            for (v = 0; v < g[d].length; v++) {
+              var z = g[d][v].trace.legendrank;
+              A > z && (A = z);
+            }
+            g[d][0]._groupMinRank = A, g[d][0]._preGroupSort = d;
+          }
+          var O = function(H, re) {
+            return H[0]._groupMinRank - re[0]._groupMinRank || H[0]._preGroupSort - re[0]._preGroupSort;
+          }, U = function(H, re) {
+            return H.trace.legendrank - re.trace.legendrank || H._preSort - re._preSort;
+          };
+          for (g.forEach(function(H, re) {
+            H[0]._preGroupSort = re;
+          }), g.sort(O), d = 0; d < g.length; d++) {
+            g[d].forEach(function(H, re) {
+              H._preSort = re;
+            }), g[d].sort(U);
+            var G = g[d][0].trace, Z = null;
+            for (v = 0; v < g[d].length; v++) {
+              var j = g[d][v].trace.legendgrouptitle;
+              if (j && j.text) {
+                Z = j, i && (j.font = r._groupTitleFont);
+                break;
+              }
+            }
+            if (o && g[d].reverse(), Z) {
+              var N = false;
+              for (v = 0; v < g[d].length; v++) if (cle.traceIs(g[d][v].trace, "pie-like")) {
+                N = true;
+                break;
+              }
+              g[d].unshift({ i: -1, groupTitle: Z, noClick: N, trace: { showlegend: G.showlegend, legendgroup: G.legendgroup, legend: G.legend, visible: r.groupclick === "toggleitem" ? true : G.visible } });
+            }
+            for (v = 0; v < g[d].length; v++) g[d][v] = [g[d][v]];
+          }
+          return r._lgroupsLength = g.length, r._maxNameLength = h, g;
+        };
+      });
+      var g_ = ye((Ub) => {
+        var GL = Dr();
+        function dle(e) {
+          return e.indexOf("e") !== -1 ? e.replace(/[.]?0+e/, "e") : e.indexOf(".") !== -1 ? e.replace(/[.]?0+$/, "") : e;
+        }
+        Ub.formatPiePercent = function(t, r) {
+          var n = dle((t * 100).toPrecision(3));
+          return GL.numSeparate(n, r) + "%";
+        };
+        Ub.formatPieValue = function(t, r) {
+          var n = dle(t.toPrecision(10));
+          return GL.numSeparate(n, r);
+        };
+        Ub.getFirstFilled = function(t, r) {
+          if (GL.isArrayOrTypedArray(t)) for (var n = 0; n < r.length; n++) {
+            var i = t[r[n]];
+            if (i || i === 0 || i === "") return i;
+          }
+        };
+        Ub.castOption = function(t, r) {
+          if (GL.isArrayOrTypedArray(t)) return Ub.getFirstFilled(t, r);
+          if (t) return t;
+        };
+        Ub.getRotationAngle = function(e) {
+          return (e === "auto" ? 0 : e) * Math.PI / 180;
+        };
+      });
+      var ple = ye((war, vle) => {
+        var $lt = So(), Qlt = ka();
+        vle.exports = function(t, r, n, i) {
+          var a = n.marker.pattern;
+          a && a.shape ? $lt.pointStyle(t, n, i, r) : Qlt.fill(t, r.color);
+        };
+      });
+      var X3 = ye((Tar, yle) => {
+        var gle = ka(), mle = g_().castOption, eut = ple();
+        yle.exports = function(t, r, n, i) {
+          var a = n.marker.line, o = mle(a.color, r.pts) || gle.defaultLine, s = mle(a.width, r.pts) || 0;
+          t.call(eut, r, n, i).style("stroke-width", s).call(gle.stroke, o);
+        };
+      });
+      var NB = ye((Aar, Ale) => {
+        var qv = Oa(), OB = qa(), _v = Dr(), _le = _v.strTranslate, Kp = So(), T0 = ka(), qB = pv().extractOpts, HL = Ru(), tut = X3(), rut = g_().castOption, iut = FB(), xle = 12, ble = 5, Vb = 2, nut = 10, Z3 = 5;
+        Ale.exports = function(t, r, n) {
+          var i = r._fullLayout;
+          n || (n = i.legend);
+          var a = n.itemsizing === "constant", o = n.itemwidth, s = (o + iut.itemGap * 2) / 2, l = _le(s, 0), u = function(C, M, g, P) {
+            var A;
+            if (C + 1) A = C;
+            else if (M && M.width > 0) A = M.width;
+            else return 0;
+            return a ? P : Math.min(A, g);
+          };
+          t.each(function(C) {
+            var M = qv.select(this), g = _v.ensureSingle(M, "g", "layers");
+            g.style("opacity", C[0].trace.opacity);
+            var P = n.indentation, A = n.valign, z = C[0].lineHeight, O = C[0].height;
+            if (A === "middle" && P === 0 || !z || !O) g.attr("transform", null);
+            else {
+              var U = { top: 1, bottom: -1 }[A], G = U * (0.5 * (z - O + 3)) || 0, Z = n.indentation;
+              g.attr("transform", _le(Z, G));
+            }
+            var j = g.selectAll("g.legendfill").data([C]);
+            j.enter().append("g").classed("legendfill", true);
+            var N = g.selectAll("g.legendlines").data([C]);
+            N.enter().append("g").classed("legendlines", true);
+            var H = g.selectAll("g.legendsymbols").data([C]);
+            H.enter().append("g").classed("legendsymbols", true), H.selectAll("g.legendpoints").data([C]).enter().append("g").classed("legendpoints", true);
+          }).each(x).each(h).each(v).each(d).each(b).each(T).each(E).each(c).each(f).each(p).each(k);
+          function c(C) {
+            var M = wle(C), g = M.showFill, P = M.showLine, A = M.showGradientLine, z = M.showGradientFill, O = M.anyFill, U = M.anyLine, G = C[0], Z = G.trace, j, N, H = qB(Z), re = H.colorscale, oe = H.reversescale, _e = function(Ae) {
+              if (Ae.size()) if (g) Kp.fillGroupStyle(Ae, r, true);
+              else {
+                var Be = "legendfill-" + Z.uid;
+                Kp.gradient(Ae, r, Be, BB(oe), re, "fill");
+              }
+            }, Ce = function(Ae) {
+              if (Ae.size()) {
+                var Be = "legendline-" + Z.uid;
+                Kp.lineGroupStyle(Ae), Kp.gradient(Ae, r, Be, BB(oe), re, "stroke");
+              }
+            }, Le = HL.hasMarkers(Z) || !O ? "M5,0" : U ? "M5,-2" : "M5,-3", ge = qv.select(this), ie = ge.select(".legendfill").selectAll("path").data(g || z ? [C] : []);
+            if (ie.enter().append("path").classed("js-fill", true), ie.exit().remove(), ie.attr("d", Le + "h" + o + "v6h-" + o + "z").call(_e), P || A) {
+              var Se = u(void 0, Z.line, nut, ble);
+              N = _v.minExtend(Z, { line: { width: Se } }), j = [_v.minExtend(G, { trace: N })];
+            }
+            var Ee = ge.select(".legendlines").selectAll("path").data(P || A ? [j] : []);
+            Ee.enter().append("path").classed("js-line", true), Ee.exit().remove(), Ee.attr("d", Le + (A ? "l" + o + ",0.0001" : "h" + o)).call(P ? Kp.lineGroupStyle : Ce);
+          }
+          function f(C) {
+            var M = wle(C), g = M.anyFill, P = M.anyLine, A = M.showLine, z = M.showMarker, O = C[0], U = O.trace, G = !z && !P && !g && HL.hasText(U), Z, j;
+            function N(ie, Se, Ee, Ae) {
+              var Be = _v.nestedProperty(U, ie).get(), Pe = _v.isArrayOrTypedArray(Be) && Se ? Se(Be) : Be;
+              if (a && Pe && Ae !== void 0 && (Pe = Ae), Ee) {
+                if (Pe < Ee[0]) return Ee[0];
+                if (Pe > Ee[1]) return Ee[1];
+              }
+              return Pe;
+            }
+            function H(ie) {
+              return O._distinct && O.index && ie[O.index] ? ie[O.index] : ie[0];
+            }
+            if (z || G || A) {
+              var re = {}, oe = {};
+              if (z) {
+                re.mc = N("marker.color", H), re.mx = N("marker.symbol", H), re.mo = N("marker.opacity", _v.mean, [0.2, 1]), re.mlc = N("marker.line.color", H), re.mlw = N("marker.line.width", _v.mean, [0, 5], Vb), re.mld = U._isShape ? "solid" : N("marker.line.dash", H), oe.marker = { sizeref: 1, sizemin: 1, sizemode: "diameter" };
+                var _e = N("marker.size", _v.mean, [2, 16], xle);
+                re.ms = _e, oe.marker.size = _e;
+              }
+              A && (oe.line = { width: N("line.width", H, [0, 10], ble) }), G && (re.tx = "Aa", re.tp = N("textposition", H), re.ts = 10, re.tc = N("textfont.color", H), re.tf = N("textfont.family", H), re.tw = N("textfont.weight", H), re.ty = N("textfont.style", H), re.tv = N("textfont.variant", H), re.tC = N("textfont.textcase", H), re.tE = N("textfont.lineposition", H), re.tS = N("textfont.shadow", H)), Z = [_v.minExtend(O, re)], j = _v.minExtend(U, oe), j.selectedpoints = null, j.texttemplate = null;
+            }
+            var Ce = qv.select(this).select("g.legendpoints"), Le = Ce.selectAll("path.scatterpts").data(z ? Z : []);
+            Le.enter().insert("path", ":first-child").classed("scatterpts", true).attr("transform", l), Le.exit().remove(), Le.call(Kp.pointStyle, j, r), z && (Z[0].mrc = 3);
+            var ge = Ce.selectAll("g.pointtext").data(G ? Z : []);
+            ge.enter().append("g").classed("pointtext", true).append("text").attr("transform", l), ge.exit().remove(), ge.selectAll("text").call(Kp.textPointStyle, j, r);
+          }
+          function h(C) {
+            var M = C[0].trace, g = M.type === "waterfall";
+            if (C[0]._distinct && g) {
+              var P = C[0].trace[C[0].dir].marker;
+              return C[0].mc = P.color, C[0].mlw = P.line.width, C[0].mlc = P.line.color, _(C, this, "waterfall");
+            }
+            var A = [];
+            M.visible && g && (A = C[0].hasTotals ? [["increasing", "M-6,-6V6H0Z"], ["totals", "M6,6H0L-6,-6H-0Z"], ["decreasing", "M6,6V-6H0Z"]] : [["increasing", "M-6,-6V6H6Z"], ["decreasing", "M6,6V-6H-6Z"]]);
+            var z = qv.select(this).select("g.legendpoints").selectAll("path.legendwaterfall").data(A);
+            z.enter().append("path").classed("legendwaterfall", true).attr("transform", l).style("stroke-miterlimit", 1), z.exit().remove(), z.each(function(O) {
+              var U = qv.select(this), G = M[O[0]].marker, Z = u(void 0, G.line, Z3, Vb);
+              U.attr("d", O[1]).style("stroke-width", Z + "px").call(T0.fill, G.color), Z && U.call(T0.stroke, G.line.color);
+            });
+          }
+          function d(C) {
+            _(C, this);
+          }
+          function v(C) {
+            _(C, this, "funnel");
+          }
+          function _(C, M, g) {
+            var P = C[0].trace, A = P.marker || {}, z = A.line || {}, O = A.cornerradius ? "M6,3a3,3,0,0,1-3,3H-3a3,3,0,0,1-3-3V-3a3,3,0,0,1,3-3H3a3,3,0,0,1,3,3Z" : "M6,6H-6V-6H6Z", U = g ? P.visible && P.type === g : OB.traceIs(P, "bar"), G = qv.select(M).select("g.legendpoints").selectAll("path.legend" + g).data(U ? [C] : []);
+            G.enter().append("path").classed("legend" + g, true).attr("d", O).attr("transform", l), G.exit().remove(), G.each(function(Z) {
+              var j = qv.select(this), N = Z[0], H = u(N.mlw, A.line, Z3, Vb);
+              j.style("stroke-width", H + "px");
+              var re = N.mcc;
+              if (!n._inHover && "mc" in N) {
+                var oe = qB(A), _e = oe.mid;
+                _e === void 0 && (_e = (oe.max + oe.min) / 2), re = Kp.tryColorscale(A, "")(_e);
+              }
+              var Ce = re || N.mc || A.color, Le = A.pattern, ge = Kp.getPatternAttr, ie = Le && (ge(Le.shape, 0, "") || ge(Le.path, 0, ""));
+              if (ie) {
+                var Se = ge(Le.bgcolor, 0, null), Ee = ge(Le.fgcolor, 0, null), Ae = Le.fgopacity, Be = Tle(Le.size, 8, 10), Pe = Tle(Le.solidity, 0.5, 1), me = "legend-" + P.uid;
+                j.call(Kp.pattern, "legend", r, me, ie, Be, Pe, re, Le.fillmode, Se, Ee, Ae);
+              } else j.call(T0.fill, Ce);
+              H && T0.stroke(j, N.mlc || z.color);
+            });
+          }
+          function b(C) {
+            var M = C[0].trace, g = qv.select(this).select("g.legendpoints").selectAll("path.legendbox").data(M.visible && OB.traceIs(M, "box-violin") ? [C] : []);
+            g.enter().append("path").classed("legendbox", true).attr("d", "M6,6H-6V-6H6Z").attr("transform", l), g.exit().remove(), g.each(function() {
+              var P = qv.select(this);
+              if ((M.boxpoints === "all" || M.points === "all") && T0.opacity(M.fillcolor) === 0 && T0.opacity((M.line || {}).color) === 0) {
+                var A = _v.minExtend(M, { marker: { size: a ? xle : _v.constrain(M.marker.size, 2, 16), sizeref: 1, sizemin: 1, sizemode: "diameter" } });
+                g.call(Kp.pointStyle, A, r);
+              } else {
+                var z = u(void 0, M.line, Z3, Vb);
+                P.style("stroke-width", z + "px").call(T0.fill, M.fillcolor), z && T0.stroke(P, M.line.color);
+              }
+            });
+          }
+          function p(C) {
+            var M = C[0].trace, g = qv.select(this).select("g.legendpoints").selectAll("path.legendcandle").data(M.visible && M.type === "candlestick" ? [C, C] : []);
+            g.enter().append("path").classed("legendcandle", true).attr("d", function(P, A) {
+              return A ? "M-15,0H-8M-8,6V-6H8Z" : "M15,0H8M8,-6V6H-8Z";
+            }).attr("transform", l).style("stroke-miterlimit", 1), g.exit().remove(), g.each(function(P, A) {
+              var z = qv.select(this), O = M[A ? "increasing" : "decreasing"], U = u(void 0, O.line, Z3, Vb);
+              z.style("stroke-width", U + "px").call(T0.fill, O.fillcolor), U && T0.stroke(z, O.line.color);
+            });
+          }
+          function k(C) {
+            var M = C[0].trace, g = qv.select(this).select("g.legendpoints").selectAll("path.legendohlc").data(M.visible && M.type === "ohlc" ? [C, C] : []);
+            g.enter().append("path").classed("legendohlc", true).attr("d", function(P, A) {
+              return A ? "M-15,0H0M-8,-6V0" : "M15,0H0M8,6V0";
+            }).attr("transform", l).style("stroke-miterlimit", 1), g.exit().remove(), g.each(function(P, A) {
+              var z = qv.select(this), O = M[A ? "increasing" : "decreasing"], U = u(void 0, O.line, Z3, Vb);
+              z.style("fill", "none").call(Kp.dashLine, O.line.dash, U), U && T0.stroke(z, O.line.color);
+            });
+          }
+          function E(C) {
+            L(C, this, "pie");
+          }
+          function T(C) {
+            L(C, this, "funnelarea");
+          }
+          function L(C, M, g) {
+            var P = C[0], A = P.trace, z = g ? A.visible && A.type === g : OB.traceIs(A, g), O = qv.select(M).select("g.legendpoints").selectAll("path.legend" + g).data(z ? [C] : []);
+            if (O.enter().append("path").classed("legend" + g, true).attr("d", "M6,6H-6V-6H6Z").attr("transform", l), O.exit().remove(), O.size()) {
+              var U = A.marker || {}, G = u(rut(U.line.width, P.pts), U.line, Z3, Vb), Z = "pieLike", j = _v.minExtend(A, { marker: { line: { width: G } } }, Z), N = _v.minExtend(P, { trace: j }, Z);
+              tut(O, N, j, r);
+            }
+          }
+          function x(C) {
+            var M = C[0].trace, g, P = [];
+            if (M.visible) switch (M.type) {
+              case "histogram2d":
+              case "heatmap":
+                P = [["M-15,-2V4H15V-2Z"]], g = true;
+                break;
+              case "choropleth":
+              case "choroplethmapbox":
+              case "choroplethmap":
+                P = [["M-6,-6V6H6V-6Z"]], g = true;
+                break;
+              case "densitymapbox":
+              case "densitymap":
+                P = [["M-6,0 a6,6 0 1,0 12,0 a 6,6 0 1,0 -12,0"]], g = "radial";
+                break;
+              case "cone":
+                P = [["M-6,2 A2,2 0 0,0 -6,6 V6L6,4Z"], ["M-6,-6 A2,2 0 0,0 -6,-2 L6,-4Z"], ["M-6,-2 A2,2 0 0,0 -6,2 L6,0Z"]], g = false;
+                break;
+              case "streamtube":
+                P = [["M-6,2 A2,2 0 0,0 -6,6 H6 A2,2 0 0,1 6,2 Z"], ["M-6,-6 A2,2 0 0,0 -6,-2 H6 A2,2 0 0,1 6,-6 Z"], ["M-6,-2 A2,2 0 0,0 -6,2 H6 A2,2 0 0,1 6,-2 Z"]], g = false;
+                break;
+              case "surface":
+                P = [["M-6,-6 A2,3 0 0,0 -6,0 H6 A2,3 0 0,1 6,-6 Z"], ["M-6,1 A2,3 0 0,1 -6,6 H6 A2,3 0 0,0 6,0 Z"]], g = true;
+                break;
+              case "mesh3d":
+                P = [["M-6,6H0L-6,-6Z"], ["M6,6H0L6,-6Z"], ["M-6,-6H6L0,6Z"]], g = false;
+                break;
+              case "volume":
+                P = [["M-6,6H0L-6,-6Z"], ["M6,6H0L6,-6Z"], ["M-6,-6H6L0,6Z"]], g = true;
+                break;
+              case "isosurface":
+                P = [["M-6,6H0L-6,-6Z"], ["M6,6H0L6,-6Z"], ["M-6,-6 A12,24 0 0,0 6,-6 L0,6Z"]], g = false;
+                break;
+            }
+            var A = qv.select(this).select("g.legendpoints").selectAll("path.legend3dandfriends").data(P);
+            A.enter().append("path").classed("legend3dandfriends", true).attr("transform", l).style("stroke-miterlimit", 1), A.exit().remove(), A.each(function(z, O) {
+              var U = qv.select(this), G = qB(M), Z = G.colorscale, j = G.reversescale, N = function(_e) {
+                if (_e.size()) {
+                  var Ce = "legendfill-" + M.uid;
+                  Kp.gradient(_e, r, Ce, BB(j, g === "radial"), Z, "fill");
+                }
+              }, H;
+              if (Z) {
+                if (!g) {
+                  var oe = Z.length;
+                  H = O === 0 ? Z[j ? oe - 1 : 0][1] : O === 1 ? Z[j ? 0 : oe - 1][1] : Z[Math.floor((oe - 1) / 2)][1];
+                }
+              } else {
+                var re = M.vertexcolor || M.facecolor || M.color;
+                H = _v.isArrayOrTypedArray(re) ? re[O] || re[0] : re;
+              }
+              U.attr("d", z[0]), H ? U.call(T0.fill, H) : U.call(N);
+            });
+          }
+        };
+        function BB(e, t) {
+          var r = t ? "radial" : "horizontal";
+          return r + (e ? "" : "reversed");
+        }
+        function wle(e) {
+          var t = e[0].trace, r = t.contours, n = HL.hasLines(t), i = HL.hasMarkers(t), a = t.visible && t.fill && t.fill !== "none", o = false, s = false;
+          if (r) {
+            var l = r.coloring;
+            l === "lines" ? o = true : n = l === "none" || l === "heatmap" || r.showlines, r.type === "constraint" ? a = r._operation !== "=" : (l === "fill" || l === "heatmap") && (s = true);
+          }
+          return { showMarker: i, showLine: n, showFill: a, showGradientLine: o, showGradientFill: s, anyLine: n || o, anyFill: a || s };
+        }
+        function Tle(e, t, r) {
+          return e && _v.isArrayOrTypedArray(e) ? t : e > r ? r : e;
+        }
+      });
+      var HB = ye((Sar, Rle) => {
+        var np = Oa(), vh = Dr(), VB = Mc(), Gb = qa(), XL = k3(), UB = yv(), ph = So(), yM = ka(), Hb = Zl(), Sle = DB().handleItemClick, Mle = DB().handleTitleClick, Oh = FB(), GB = Dh(), Ple = GB.LINE_SPACING, K3 = GB.FROM_TL, Ele = GB.FROM_BR, kle = hle(), aut = NB(), J3 = mM(), Y3 = 1, out = /^legend[0-9]*$/;
+        Rle.exports = function(t, r) {
+          if (r) Cle(t, r);
+          else {
+            var n = t._fullLayout, i = n._legends, a = n._infolayer.selectAll('[class^="legend"]');
+            a.each(function() {
+              var u = np.select(this), c = u.attr("class"), f = c.split(" ")[0];
+              f.match(out) && i.indexOf(f) === -1 && u.remove();
+            });
+            for (var o = 0; o < i.length; o++) {
+              var s = i[o], l = t._fullLayout[s];
+              Cle(t, l);
+            }
+          }
+        };
+        function sut(e, t, r) {
+          if (!(t.title.side !== "top center" && t.title.side !== "top right")) {
+            var n = t.title.font, i = n.size * Ple, a = 0, o = e.node(), s = ph.bBox(o).width;
+            t.title.side === "top center" ? a = 0.5 * (t._width - 2 * r - 2 * Oh.titlePad - s) : t.title.side === "top right" && (a = t._width - 2 * r - 2 * Oh.titlePad - s), Hb.positionText(e, r + Oh.titlePad + a, r + i);
+          }
+        }
+        function Cle(e, t) {
+          var r = t || {}, n = e._fullLayout, i = J3.getId(r), a, o, s = r._inHover;
+          if (s ? (o = r.layer, a = "hover") : (o = n._infolayer, a = i), !!o) {
+            a += n._uid, e._legendMouseDownTime || (e._legendMouseDownTime = 0);
+            var l;
+            if (s) {
+              if (!r.entries) return;
+              l = kle(r.entries, r);
+            } else {
+              for (var u = (e.calcdata || []).slice(), c = n.shapes, f = 0; f < c.length; f++) {
+                var h = c[f];
+                if (h.showlegend) {
+                  var d = { _isShape: true, _fullInput: h, index: h._index, name: h.name || h.label.text || "shape " + h._index, legend: h.legend, legendgroup: h.legendgroup, legendgrouptitle: h.legendgrouptitle, legendrank: h.legendrank, legendwidth: h.legendwidth, showlegend: h.showlegend, visible: h.visible, opacity: h.opacity, mode: h.type === "line" ? "lines" : "markers", line: h.line, marker: { line: h.line, color: h.fillcolor, size: 12, symbol: h.type === "rect" ? "square" : h.type === "circle" ? "circle" : "hexagon2" } };
+                  u.push([{ trace: d }]);
+                }
+              }
+              l = n.showlegend && kle(u, r, n._legends.length > 1);
+            }
+            var v = n.hiddenlabels || [];
+            if (!s && (!n.showlegend || !l.length)) return o.selectAll("." + i).remove(), n._topdefs.select("#" + a).remove(), VB.autoMargin(e, i);
+            var _ = vh.ensureSingle(o, "g", i, function(M) {
+              s || M.attr("pointer-events", "all");
+            }), b = vh.ensureSingleById(n._topdefs, "clipPath", a, function(M) {
+              M.append("rect");
+            }), p = vh.ensureSingle(_, "rect", "bg", function(M) {
+              M.attr("shape-rendering", "crispEdges");
+            });
+            p.call(yM.stroke, r.bordercolor).call(yM.fill, r.bgcolor).style("stroke-width", r.borderwidth + "px");
+            var k = vh.ensureSingle(_, "g", "scrollbox"), E = r.title;
+            r._titleWidth = 0, r._titleHeight = 0;
+            var T;
+            E.text ? (T = vh.ensureSingle(k, "text", i + "titletext"), T.attr("text-anchor", "start").call(ph.font, E.font).text(E.text), WL(T, k, e, r, Y3), !s && (r.titleclick || r.titledoubleclick) && cut(k, e, r, i)) : (k.selectAll("." + i + "titletext").remove(), k.selectAll("." + i + "titletoggle").remove());
+            var L = vh.ensureSingle(_, "rect", "scrollbar", function(M) {
+              M.attr(Oh.scrollBarEnterAttrs).call(yM.fill, Oh.scrollBarColor);
+            }), x = k.selectAll("g.groups").data(l);
+            x.enter().append("g").attr("class", "groups"), x.exit().remove();
+            var C = x.selectAll("g.traces").data(vh.identity);
+            C.enter().append("g").attr("class", "traces"), C.exit().remove(), C.style("opacity", function(M) {
+              let g = M[0], P = g.trace;
+              if (g.groupTitle) {
+                let A = P.legendgroup, z = (n.shapes || []).filter(function(U) {
+                  return U.showlegend;
+                });
+                return e._fullData.concat(z).some(function(U) {
+                  return U.legendgroup === A && (U.legend || "legend") === i && U.visible === true;
+                }) ? 1 : 0.5;
+              }
+              return Gb.traceIs(P, "pie-like") ? v.indexOf(M[0].label) !== -1 ? 0.5 : 1 : P.visible === "legendonly" ? 0.5 : 1;
+            }).each(function() {
+              np.select(this).call(lut, e, r);
+            }).call(aut, e, r).each(function(M) {
+              s || M[0].groupTitle && r.groupclick === "toggleitem" || np.select(this).call(uut, e, i);
+            }), vh.syncOrAsync([VB.previousPromises, function() {
+              return dut(e, x, C, r, k);
+            }, function() {
+              var M = n._size, g = r.borderwidth, P = r.xref === "paper", A = r.yref === "paper";
+              if (E.text) {
+                let je = (n.shapes || []).filter(function(pt) {
+                  return pt.showlegend;
+                }), lt = e._fullData.concat(je).some(function(pt) {
+                  let Vt = pt.legend || "legend";
+                  var ot = Array.isArray(Vt) ? Vt.includes(i) : Vt === i;
+                  return ot && pt.visible === true;
+                });
+                T.style("opacity", lt ? 1 : 0.5);
+              }
+              if (!s) {
+                var z, O;
+                P ? z = M.l + M.w * r.x - K3[ZL(r)] * r._width : z = n.width * r.x - K3[ZL(r)] * r._width, A ? O = M.t + M.h * (1 - r.y) - K3[YL(r)] * r._effHeight : O = n.height * (1 - r.y) - K3[YL(r)] * r._effHeight;
+                var U = vut(e, i, z, O);
+                if (U) return;
+                if (n.margin.autoexpand) {
+                  var G = z, Z = O;
+                  z = P ? vh.constrain(z, 0, n.width - r._width) : G, O = A ? vh.constrain(O, 0, n.height - r._effHeight) : Z, z !== G && vh.log("Constrain " + i + ".x to make legend fit inside graph"), O !== Z && vh.log("Constrain " + i + ".y to make legend fit inside graph");
+                }
+                ph.setTranslate(_, z, O);
+              }
+              if (L.on(".drag", null), _.on("wheel", null), s || r._height <= r._maxHeight || e._context.staticPlot) {
+                var j = r._effHeight;
+                s && (j = r._height), p.attr({ width: r._width - g, height: j - g, x: g / 2, y: g / 2 }), ph.setTranslate(k, 0, 0), b.select("rect").attr({ width: r._width - 2 * g, height: j - 2 * g, x: g, y: g }), ph.setClipUrl(k, a, e), ph.setRect(L, 0, 0, 0, 0), delete r._scrollY;
+              } else {
+                var N = Math.max(Oh.scrollBarMinHeight, r._effHeight * r._effHeight / r._height), H = r._effHeight - N - 2 * Oh.scrollBarMargin, re = r._height - r._effHeight, oe = H / re, _e = Math.min(r._scrollY || 0, re);
+                p.attr({ width: r._width - 2 * g + Oh.scrollBarWidth + Oh.scrollBarMargin, height: r._effHeight - g, x: g / 2, y: g / 2 }), b.select("rect").attr({ width: r._width - 2 * g + Oh.scrollBarWidth + Oh.scrollBarMargin, height: r._effHeight - 2 * g, x: g, y: g + _e }), ph.setClipUrl(k, a, e), Be(_e, N, oe), _.on("wheel", function() {
+                  _e = vh.constrain(r._scrollY + np.event.deltaY / re * H, 0, re), Be(_e, N, oe), _e !== 0 && _e !== re && np.event.preventDefault();
+                });
+                var Ce, Le, ge, ie = function(je, lt, pt) {
+                  var Vt = (pt - lt) / oe + je;
+                  return vh.constrain(Vt, 0, re);
+                }, Se = function(je, lt, pt) {
+                  var Vt = (lt - pt) / oe + je;
+                  return vh.constrain(Vt, 0, re);
+                }, Ee = np.behavior.drag().on("dragstart", function() {
+                  var je = np.event.sourceEvent;
+                  je.type === "touchstart" ? Ce = je.changedTouches[0].clientY : Ce = je.clientY, ge = _e;
+                }).on("drag", function() {
+                  var je = np.event.sourceEvent;
+                  je.buttons === 2 || je.ctrlKey || (je.type === "touchmove" ? Le = je.changedTouches[0].clientY : Le = je.clientY, _e = ie(ge, Ce, Le), Be(_e, N, oe));
+                });
+                L.call(Ee);
+                var Ae = np.behavior.drag().on("dragstart", function() {
+                  var je = np.event.sourceEvent;
+                  je.type === "touchstart" && (Ce = je.changedTouches[0].clientY, ge = _e);
+                }).on("drag", function() {
+                  var je = np.event.sourceEvent;
+                  je.type === "touchmove" && (Le = je.changedTouches[0].clientY, _e = Se(ge, Ce, Le), Be(_e, N, oe));
+                });
+                k.call(Ae);
+              }
+              function Be(je, lt, pt) {
+                r._scrollY = e._fullLayout[i]._scrollY = je, ph.setTranslate(k, 0, -je), ph.setRect(L, r._width, Oh.scrollBarMargin + je * pt, Oh.scrollBarWidth, lt), b.select("rect").attr("y", g + je);
+              }
+              if (e._context.edits.legendPosition) {
+                var Pe, me, De, ce;
+                _.classed("cursor-move", true), UB.init({ element: _.node(), gd: e, prepFn: function(je) {
+                  if (je.target !== L.node()) {
+                    var lt = ph.getTranslate(_);
+                    De = lt.x, ce = lt.y;
+                  }
+                }, moveFn: function(je, lt) {
+                  if (De !== void 0 && ce !== void 0) {
+                    var pt = De + je, Vt = ce + lt;
+                    ph.setTranslate(_, pt, Vt), Pe = UB.align(pt, r._width, M.l, M.l + M.w, r.xanchor), me = UB.align(Vt + r._height, -r._height, M.t + M.h, M.t, r.yanchor);
+                  }
+                }, doneFn: function() {
+                  if (Pe !== void 0 && me !== void 0) {
+                    var je = {};
+                    je[i + ".x"] = Pe, je[i + ".y"] = me, Gb.call("_guiRelayout", e, je);
+                  }
+                }, clickFn: function(je, lt) {
+                  var pt = o.selectAll("g.traces").filter(function() {
+                    var Vt = this.getBoundingClientRect();
+                    return lt.clientX >= Vt.left && lt.clientX <= Vt.right && lt.clientY >= Vt.top && lt.clientY <= Vt.bottom;
+                  });
+                  pt.size() > 0 && Ile(e, r, pt, je, lt);
+                } });
+              }
+            }], e);
+          }
+        }
+        function jL(e, t, r) {
+          var n = e[0], i = n.width, a = t.entrywidthmode, o = n.trace.legendwidth || t.entrywidth;
+          return a === "fraction" ? t._maxWidth * o : r + (o || i);
+        }
+        function Ile(e, t, r, n, i) {
+          var a = e._fullLayout, o = r.data()[0][0].trace, s = t.itemclick, l = t.itemdoubleclick, u = { event: i, node: r.node(), curveNumber: o.index, expandedIndex: o.index, data: e.data, layout: e.layout, frames: e._transitionData._frames, config: e._context, fullData: e._fullData, fullLayout: a };
+          o._group && (u.group = o._group), Gb.traceIs(o, "pie-like") && (u.label = r.datum()[0].label);
+          var c = XL.triggerHandler(e, "plotly_legendclick", u);
+          if (n === 1) {
+            if (c === false) return;
+            t._clickTimeout = setTimeout(function() {
+              e._fullLayout && s && Sle(r, e, t, s);
+            }, e._context.doubleClickDelay);
+          } else if (n === 2) {
+            t._clickTimeout && clearTimeout(t._clickTimeout), e._legendMouseDownTime = 0;
+            var f = XL.triggerHandler(e, "plotly_legenddoubleclick", u);
+            f !== false && c !== false && l && Sle(r, e, t, l);
+          }
+        }
+        function lut(e, t, r) {
+          var n = J3.getId(r), i = e.data()[0][0], a = i.trace, o = Gb.traceIs(a, "pie-like"), s = !r._inHover && t._context.edits.legendText && !o, l = r._maxNameLength, u, c;
+          i.groupTitle ? (u = i.groupTitle.text, c = i.groupTitle.font) : (c = r.font, r.entries ? u = i.text : (u = o ? i.label : a.name, a._meta && (u = vh.templateString(u, a._meta))));
+          var f = vh.ensureSingle(e, "text", n + "text");
+          f.attr("text-anchor", "start").call(ph.font, c).text(s ? Lle(u, l) : u);
+          var h = r.indentation + r.itemwidth + Oh.itemGap * 2;
+          Hb.positionText(f, h, 0), s ? f.call(Hb.makeEditable, { gd: t, text: u }).call(WL, e, t, r).on("edit", function(d) {
+            this.text(Lle(d, l)).call(WL, e, t, r);
+            var v = i.trace._fullInput || {}, _ = {};
+            return _.name = d, v._isShape ? Gb.call("_guiRelayout", t, "shapes[" + a.index + "].name", _.name) : Gb.call("_guiRestyle", t, _, a.index);
+          }) : WL(f, e, t, r);
+        }
+        function Lle(e, t) {
+          var r = Math.max(4, t);
+          if (e && e.trim().length >= r / 2) return e;
+          e = e || "";
+          for (var n = r - e.length; n > 0; n--) e += " ";
+          return e;
+        }
+        function uut(e, t, r) {
+          var n = t._context.doubleClickDelay, i, a = 1, o = vh.ensureSingle(e, "rect", r + "toggle", function(s) {
+            t._context.staticPlot || s.style("cursor", "pointer").attr("pointer-events", "all"), s.call(yM.fill, "rgba(0,0,0,0)");
+          });
+          t._context.staticPlot || (o.on("mousedown", function() {
+            i = (/* @__PURE__ */ new Date()).getTime(), i - t._legendMouseDownTime < n ? a += 1 : (a = 1, t._legendMouseDownTime = i);
+          }), o.on("mouseup", function() {
+            if (!(t._dragged || t._editing)) {
+              var s = t._fullLayout[r];
+              (/* @__PURE__ */ new Date()).getTime() - t._legendMouseDownTime > n && (a = Math.max(a - 1, 1)), Ile(t, s, e, a, np.event);
+            }
+          }));
+        }
+        function cut(e, t, r, n) {
+          if (t._fullData.some(function(u) {
+            let c = u.legend || "legend";
+            return (Array.isArray(c) ? c.includes(n) : c === n) && Gb.traceIs(u, "pie-like");
+          })) return;
+          let a = t._context.doubleClickDelay;
+          var o, s = 1;
+          let l = vh.ensureSingle(e, "rect", n + "titletoggle", function(u) {
+            t._context.staticPlot || u.style("cursor", "pointer").attr("pointer-events", "all"), u.call(yM.fill, "rgba(0,0,0,0)");
+          });
+          t._context.staticPlot || (l.on("mousedown", function() {
+            o = (/* @__PURE__ */ new Date()).getTime(), o - t._legendMouseDownTime < a ? s += 1 : (s = 1, t._legendMouseDownTime = o);
+          }), l.on("mouseup", function() {
+            if (t._dragged || t._editing) return;
+            (/* @__PURE__ */ new Date()).getTime() - t._legendMouseDownTime > a && (s = Math.max(s - 1, 1));
+            let u = { event: np.event, legendId: n, data: t.data, layout: t.layout, fullData: t._fullData, fullLayout: t._fullLayout };
+            if (s === 1 && r.titleclick) {
+              if (XL.triggerHandler(t, "plotly_legendtitleclick", u) === false) return;
+              r._titleClickTimeout = setTimeout(function() {
+                t._fullLayout && Mle(t, r, r.titleclick);
+              }, a);
+            } else s === 2 && (r._titleClickTimeout && clearTimeout(r._titleClickTimeout), t._legendMouseDownTime = 0, XL.triggerHandler(t, "plotly_legendtitledoubleclick", u) !== false && r.titledoubleclick && Mle(t, r, r.titledoubleclick));
+          }));
+        }
+        function WL(e, t, r, n, i) {
+          n._inHover && e.attr("data-notex", true), Hb.convertToTspans(e, r, function() {
+            fut(t, r, n, i);
+          });
+        }
+        function fut(e, t, r, n) {
+          var i = e.data()[0][0], a = i && i.trace.showlegend;
+          if (Array.isArray(a) && (a = a[i.i] !== false), !r._inHover && i && !a) {
+            e.remove();
+            return;
+          }
+          var o = e.select("g[class*=math-group]"), s = o.node(), l = J3.getId(r);
+          r || (r = t._fullLayout[l]);
+          var u = r.borderwidth, c;
+          n === Y3 ? c = r.title.font : i.groupTitle ? c = i.groupTitle.font : c = r.font;
+          var f = c.size * Ple, h, d;
+          if (s) {
+            var v = ph.bBox(s);
+            h = v.height, d = v.width, n === Y3 ? ph.setTranslate(o, u, u + h * 0.75) : ph.setTranslate(o, 0, h * 0.25);
+          } else {
+            var _ = "." + l + (n === Y3 ? "title" : "") + "text", b = e.select(_), p = Hb.lineCount(b), k = b.node();
+            if (h = f * p, d = k ? ph.bBox(k).width : 0, n === Y3) r.title.side === "left" && (d += Oh.itemGap * 2), Hb.positionText(b, u + Oh.titlePad, u + f);
+            else {
+              var E = Oh.itemGap * 2 + r.indentation + r.itemwidth;
+              i.groupTitle && (E = Oh.itemGap, d -= r.indentation + r.itemwidth), Hb.positionText(b, E, -f * ((p - 1) / 2 - 0.3));
+            }
+          }
+          n === Y3 ? (r._titleWidth = d, r._titleHeight = h) : (i.lineHeight = f, i.height = Math.max(h, 16) + 3, i.width = d);
+        }
+        function hut(e) {
+          var t = 0, r = 0, n = e.title.side;
+          return n && (n.indexOf("left") !== -1 && (t = e._titleWidth), n.indexOf("top") !== -1 && (r = e._titleHeight)), [t, r];
+        }
+        function dut(e, t, r, n, i) {
+          var a = e._fullLayout, o = J3.getId(n);
+          n || (n = a[o]);
+          var s = a._size, l = J3.isVertical(n), u = J3.isGrouped(n), c = n.entrywidthmode === "fraction", f = n.borderwidth, h = 2 * f, d = Oh.itemGap, v = n.indentation + n.itemwidth + d * 2, _ = 2 * (f + d), b = YL(n), p = n.y < 0 || n.y === 0 && b === "top", k = n.y > 1 || n.y === 1 && b === "bottom", E = n.tracegroupgap, T = {};
+          let { orientation: L, yref: x } = n, { maxheight: C } = n, M = p || k || L !== "v" || x !== "paper";
+          C || (C = M ? 0.5 : 1);
+          let g = M ? a.height : s.h;
+          n._maxHeight = Math.max(C > 1 ? C : C * g, 30);
+          var P = 0;
+          n._width = 0, n._height = 0;
+          var A = hut(n);
+          if (l) r.each(function(je) {
+            var lt = je[0].height;
+            ph.setTranslate(this, f + A[0], f + A[1] + n._height + lt / 2 + d), n._height += lt, n._width = Math.max(n._width, je[0].width);
+          }), P = v + n._width, n._width += d + v + h, n._height += _, u && (t.each(function(je, lt) {
+            ph.setTranslate(this, 0, lt * n.tracegroupgap);
+          }), n._height += (n._lgroupsLength - 1) * n.tracegroupgap);
+          else {
+            var z = ZL(n), O = n.x < 0 || n.x === 0 && z === "right", U = n.x > 1 || n.x === 1 && z === "left", G = k || p, Z = a.width / 2;
+            n._maxWidth = Math.max(O ? G && z === "left" ? s.l + s.w : Z : U ? G && z === "right" ? s.r + s.w : Z : s.w, 2 * v);
+            var j = 0, N = 0;
+            r.each(function(je) {
+              var lt = jL(je, n, v);
+              j = Math.max(j, lt), N += lt;
+            }), P = null;
+            var H = 0;
+            if (u) {
+              var re = 0, oe = 0, _e = 0;
+              t.each(function() {
+                var je = 0, lt = 0;
+                np.select(this).selectAll("g.traces").each(function(Vt) {
+                  var ot = jL(Vt, n, v), ut = Vt[0].height;
+                  ph.setTranslate(this, A[0], A[1] + f + d + ut / 2 + lt), lt += ut, je = Math.max(je, ot), T[Vt[0].trace.legendgroup] = je;
+                });
+                var pt = je + d;
+                oe > 0 && pt + f + oe > n._maxWidth ? (H = Math.max(H, oe), oe = 0, _e += re + E, re = lt) : re = Math.max(re, lt), ph.setTranslate(this, oe, _e), oe += pt;
+              }), n._width = Math.max(H, oe) + f, n._height = _e + re + _;
+            } else {
+              var Ce = r.size(), Le = N + h + (Ce - 1) * d < n._maxWidth, ge = 0, ie = 0, Se = 0, Ee = 0;
+              r.each(function(je) {
+                var lt = je[0].height, pt = jL(je, n, v), Vt = Le ? pt : j;
+                c || (Vt += d), Vt + f + ie - d >= n._maxWidth && (H = Math.max(H, Ee), ie = 0, Se += ge, n._height += ge, ge = 0), ph.setTranslate(this, A[0] + f + ie, A[1] + f + Se + lt / 2 + d), Ee = ie + pt + d, ie += Vt, ge = Math.max(ge, lt);
+              }), Le ? (n._width = ie + h, n._height = ge + _) : (n._width = Math.max(H, Ee) + h, n._height += ge + _);
+            }
+          }
+          n._width = Math.ceil(Math.max(n._width + A[0], n._titleWidth + 2 * (f + Oh.titlePad))), n._height = Math.ceil(Math.max(n._height + A[1], n._titleHeight + 2 * (f + Oh.itemGap))), n._effHeight = Math.min(n._height, n._maxHeight);
+          var Ae = e._context.edits, Be = Ae.legendText || Ae.legendPosition;
+          r.each(function(je) {
+            var lt = np.select(this).select("." + o + "toggle"), pt = je[0].height, Vt = je[0].trace.legendgroup, ot = jL(je, n, v);
+            u && Vt !== "" && (ot = T[Vt]);
+            var ut = Be ? v : P || ot;
+            !l && !c && (ut += d / 2), ph.setRect(lt, 0, -pt / 2, ut, pt);
+          });
+          var Pe = i.select("." + o + "titletext");
+          Pe.node() && sut(Pe, n, f);
+          var me = i.select("." + o + "titletoggle");
+          if (me.size() && Pe.node()) {
+            var De = Pe.attr("x") || 0, ce = Oh.titlePad;
+            ph.setRect(me, De - ce, f, n._titleWidth + 2 * ce, n._titleHeight + 2 * ce);
+          }
+        }
+        function vut(e, t, r, n) {
+          var i = e._fullLayout, a = i[t], o = ZL(a), s = YL(a), l = a.xref === "paper", u = a.yref === "paper";
+          e._fullLayout._reservedMargin[t] = {};
+          var c = a.y < 0.5 ? "b" : "t", f = a.x < 0.5 ? "l" : "r", h = { r: i.width - r, l: r + a._width, b: i.height - n, t: n + a._effHeight };
+          if (l && u) return VB.autoMargin(e, t, { x: a.x, y: a.y, l: a._width * K3[o], r: a._width * Ele[o], b: a._effHeight * Ele[s], t: a._effHeight * K3[s] });
+          l ? e._fullLayout._reservedMargin[t][c] = h[c] : u || a.orientation === "v" ? e._fullLayout._reservedMargin[t][f] = h[f] : e._fullLayout._reservedMargin[t][c] = h[c];
+        }
+        function ZL(e) {
+          return vh.isRightAnchor(e) ? "right" : vh.isCenterAnchor(e) ? "center" : "left";
+        }
+        function YL(e) {
+          return vh.isBottomAnchor(e) ? "bottom" : vh.isMiddleAnchor(e) ? "middle" : "top";
+        }
+      });
+      var ZB = ye((XB) => {
+        var jb = Oa(), Py = Eo(), Dle = fd(), zf = Dr(), put = zf.pushUnique, jB = zf.strTranslate, gut = zf.strRotate, mut = k3(), A0 = Zl(), yut = ale(), Am = So(), vd = ka(), KL = yv(), Sm = ho(), _ut = Rh().zindexSeparator, Q3 = qa(), kg = ip(), Wb = NS(), xut = PB(), but = HB(), Vle = Wb.YANGLE, WB = Math.PI * Vle / 180, wut = 1 / Math.sin(WB), Tut = Math.cos(WB), Aut = Math.sin(WB), Qc = Wb.HOVERARROWSIZE, sl = Wb.HOVERTEXTPAD, Fle = { box: true, ohlc: true, violin: true, candlestick: true }, Sut = { scatter: true, scattergl: true, splom: true };
+        function zle(e, t) {
+          return e.distance - t.distance;
+        }
+        XB.hover = function(t, r, n, i) {
+          t = zf.getGraphDiv(t);
+          var a = r.target;
+          zf.throttle(t._fullLayout._uid + Wb.HOVERID, Wb.HOVERMINTIME, function() {
+            Mut(t, r, n, i, a);
+          });
+        };
+        XB.loneHover = function(t, r) {
+          var n = true;
+          Array.isArray(t) || (n = false, t = [t]);
+          var i = r.gd, a = Xle(i), o = Zle(i), s = t.map(function(b) {
+            var p = b._x0 || b.x0 || b.x || 0, k = b._x1 || b.x1 || b.x || 0, E = b._y0 || b.y0 || b.y || 0, T = b._y1 || b.y1 || b.y || 0, L = b.eventData;
+            if (L) {
+              var x = Math.min(p, k), C = Math.max(p, k), M = Math.min(E, T), g = Math.max(E, T), P = b.trace;
+              if (Q3.traceIs(P, "gl3d")) {
+                var A = i._fullLayout[P.scene]._scene.container, z = A.offsetLeft, O = A.offsetTop;
+                x += z, C += z, M += O, g += O;
+              }
+              L.bbox = { x0: x + o, x1: C + o, y0: M + a, y1: g + a }, r.inOut_bbox && r.inOut_bbox.push(L.bbox);
+            } else L = false;
+            return { color: b.color || vd.defaultLine, x0: b.x0 || b.x || 0, x1: b.x1 || b.x || 0, y0: b.y0 || b.y || 0, y1: b.y1 || b.y || 0, xLabel: b.xLabel, yLabel: b.yLabel, zLabel: b.zLabel, text: b.text, name: b.name, idealAlign: b.idealAlign, borderColor: b.borderColor, fontFamily: b.fontFamily, fontSize: b.fontSize, fontColor: b.fontColor, fontWeight: b.fontWeight, fontStyle: b.fontStyle, fontVariant: b.fontVariant, nameLength: b.nameLength, textAlign: b.textAlign, trace: b.trace || { index: 0, hoverinfo: "" }, xa: { _offset: 0 }, ya: { _offset: 0 }, index: 0, hovertemplate: b.hovertemplate || false, hovertemplateLabels: b.hovertemplateLabels || false, eventData: L };
+          }), l = false, u = Hle(s, { gd: i, hovermode: "closest", rotateLabels: l, bgColor: r.bgColor || vd.background, container: jb.select(r.container), outerContainer: r.outerContainer || r.container }), c = u.hoverLabels, f = 5, h = 0, d = 0;
+          c.sort(function(b, p) {
+            return b.y0 - p.y0;
+          }).each(function(b, p) {
+            var k = b.y0 - b.by / 2;
+            k - f < h ? b.offset = h - k + f : b.offset = 0, h = k + b.by + b.offset, p === r.anchorIndex && (d = b.offset);
+          }).each(function(b) {
+            b.offset -= d;
+          });
+          var v = i._fullLayout._invScaleX, _ = i._fullLayout._invScaleY;
+          return Wle(c, l, v, _), n ? c : c.node();
+        };
+        function Mut(e, t, r, n, i) {
+          r || (r = "xy"), typeof r == "string" && (r = r.split(_ut)[0]);
+          var a = Array.isArray(r) ? r : [r], o, s = e._fullLayout, l = s.hoversubplots, u = s._plots || [], c = u[r], f = s._has("cartesian"), h = t.hovermode || s.hovermode, d = (h || "").charAt(0) === "x", v = (h || "").charAt(0) === "y", _, b;
+          if (f && (d || v) && l === "axis") {
+            for (var p = a.length, k = 0; k < p; k++) if (o = a[k], u[o]) {
+              _ = Sm.getFromId(e, o, "x"), b = Sm.getFromId(e, o, "y");
+              var E = (d ? _ : b)._subplotsWith;
+              if (E && E.length) for (var T = 0; T < E.length; T++) put(a, E[T]);
+            }
+          }
+          if (c && l !== "single") {
+            var L = c.overlays.map(function(wi) {
+              return wi.id;
+            });
+            a = a.concat(L);
+          }
+          for (var x = a.length, C = new Array(x), M = new Array(x), g = false, P = 0; P < x; P++) if (o = a[P], u[o]) g = true, C[P] = u[o].xaxis, M[P] = u[o].yaxis;
+          else if (s[o] && s[o]._subplot) {
+            var A = s[o]._subplot;
+            C[P] = A.xaxis, M[P] = A.yaxis;
+          } else {
+            zf.warn("Unrecognized subplot: " + o);
+            return;
+          }
+          if (h && !g && (h = "closest"), ["x", "y", "closest", "x unified", "y unified"].indexOf(h) === -1 || !e.calcdata || e.querySelector(".zoombox") || e._dragging) return KL.unhoverRaw(e, t);
+          var z = s.hoverdistance;
+          z === -1 && (z = 1 / 0);
+          var O = s.spikedistance;
+          O === -1 && (O = 1 / 0);
+          var U = [], G = [], Z, j, N, H, re, oe, _e, Ce, Le, ge, ie, Se, Ee, Ae = { hLinePoint: null, vLinePoint: null }, Be = false;
+          if (Array.isArray(t)) for (h = "array", N = 0; N < t.length; N++) re = e.calcdata[t[N].curveNumber || 0], re && (oe = re[0].trace, re[0].trace.hoverinfo !== "skip" && (G.push(re), oe.orientation === "h" && (Be = true)));
+          else {
+            var Pe = e.calcdata.slice();
+            for (Pe.sort(function(wi, On) {
+              var qn = wi[0].trace.zorder || 0, Fn = On[0].trace.zorder || 0;
+              return qn - Fn;
+            }), H = 0; H < Pe.length; H++) re = Pe[H], oe = re[0].trace, oe.hoverinfo !== "skip" && kg.isTraceInSubplots(oe, a) && (G.push(re), oe.orientation === "h" && (Be = true));
+            var me = !i, De, ce;
+            if (me) "xpx" in t ? De = t.xpx : De = C[0]._length / 2, "ypx" in t ? ce = t.ypx : ce = M[0]._length / 2;
+            else {
+              if (mut.triggerHandler(e, "plotly_beforehover", t) === false) return;
+              var je = i.getBoundingClientRect();
+              De = t.clientX - je.left, ce = t.clientY - je.top, s._calcInverseTransform(e);
+              var lt = zf.apply3DTransform(s._invTransform)(De, ce);
+              if (De = lt[0], ce = lt[1], De < 0 || De > C[0]._length || ce < 0 || ce > M[0]._length) return KL.unhoverRaw(e, t);
+            }
+            if (t.pointerX = De + C[0]._offset, t.pointerY = ce + M[0]._offset, "xval" in t ? Z = kg.flat(a, t.xval) : Z = kg.p2c(C, De), "yval" in t ? j = kg.flat(a, t.yval) : j = kg.p2c(M, ce), !Py(Z[0]) || !Py(j[0])) return zf.warn("Fx.hover failed", t, e), KL.unhoverRaw(e, t);
+          }
+          var pt = 1 / 0;
+          function Vt(wi, On) {
+            for (H = 0; H < G.length; H++) if (re = G[H], !(!re || !re[0] || !re[0].trace) && (oe = re[0].trace, !(oe.visible !== true || oe._length === 0) && ["carpet", "contourcarpet"].indexOf(oe._module.name) === -1)) {
+              if (Le = h, kg.isUnifiedHover(Le) && (Le = Le.charAt(0)), oe.type === "splom" ? (Ce = 0, _e = a[Ce]) : (_e = kg.getSubplot(oe), Ce = a.indexOf(_e)), Se = { cd: re, trace: oe, xa: C[Ce], ya: M[Ce], maxHoverDistance: z, maxSpikeDistance: O, index: false, distance: Math.min(pt, z), spikeDistance: 1 / 0, xSpike: void 0, ySpike: void 0, color: vd.defaultLine, name: oe.name, x0: void 0, x1: void 0, y0: void 0, y1: void 0, xLabelVal: void 0, yLabelVal: void 0, zLabelVal: void 0, text: void 0 }, s[_e] && (Se.subplot = s[_e]._subplot), s._splomScenes && s._splomScenes[oe.uid] && (Se.scene = s._splomScenes[oe.uid]), Le === "array") {
+                var qn = t[H];
+                "pointNumber" in qn ? (Se.index = qn.pointNumber, Le = "closest") : (Le = "", "xval" in qn && (ge = qn.xval, Le = "x"), "yval" in qn && (ie = qn.yval, Le = Le ? "closest" : "y"));
+              } else wi !== void 0 && On !== void 0 ? (ge = wi, ie = On) : (ge = Z[Ce], ie = j[Ce]);
+              if (Ee = U.length, z !== 0) if (oe._module && oe._module.hoverPoints) {
+                var Fn = oe._module.hoverPoints(Se, ge, ie, Le, { finiteRange: true, hoverLayer: s._hoverlayer, hoversubplots: l, gd: e });
+                if (Fn) for (var ra, la = 0; la < Fn.length; la++) ra = Fn[la], Py(ra.x0) && Py(ra.y0) && U.push(Lut(ra, h));
+              } else zf.log("Unrecognized trace type in hover:", oe);
+              if (h === "closest" && U.length > Ee && (U.splice(0, Ee), pt = U[0].distance), f && O !== 0 && U.length === 0) {
+                Se.distance = O, Se.index = false;
+                var Ut = oe._module.hoverPoints(Se, ge, ie, "closest", { hoverLayer: s._hoverlayer });
+                if (Ut && (Ut = Ut.filter(function(ri) {
+                  return ri.spikeDistance <= O;
+                })), Ut && Ut.length) {
+                  var wt, rr = Ut.filter(function(ri) {
+                    return ri.xa.showspikes && ri.xa.spikesnap !== "hovered data";
+                  });
+                  if (rr.length) {
+                    var nr = rr[0];
+                    Py(nr.x0) && Py(nr.y0) && (wt = ut(nr), (!Ae.vLinePoint || Ae.vLinePoint.spikeDistance > wt.spikeDistance) && (Ae.vLinePoint = wt));
+                  }
+                  var Er = Ut.filter(function(ri) {
+                    return ri.ya.showspikes && ri.ya.spikesnap !== "hovered data";
+                  });
+                  if (Er.length) {
+                    var Xr = Er[0];
+                    Py(Xr.x0) && Py(Xr.y0) && (wt = ut(Xr), (!Ae.hLinePoint || Ae.hLinePoint.spikeDistance > wt.spikeDistance) && (Ae.hLinePoint = wt));
+                  }
+                }
+              }
+            }
+          }
+          Vt();
+          function ot(wi, On, qn) {
+            for (var Fn = null, ra = 1 / 0, la, Ut = 0; Ut < wi.length; Ut++) _ && _._id !== wi[Ut].xa._id || b && b._id !== wi[Ut].ya._id || (la = wi[Ut].spikeDistance, qn && Ut === 0 && (la = -1 / 0), la <= ra && la <= On && (Fn = wi[Ut], ra = la));
+            return Fn;
+          }
+          function ut(wi) {
+            return wi ? { xa: wi.xa, ya: wi.ya, x: wi.xSpike !== void 0 ? wi.xSpike : (wi.x0 + wi.x1) / 2, y: wi.ySpike !== void 0 ? wi.ySpike : (wi.y0 + wi.y1) / 2, distance: wi.distance, spikeDistance: wi.spikeDistance, curveNumber: wi.trace.index, color: wi.color, pointNumber: wi.index } : null;
+          }
+          var Wt = { fullLayout: s, container: s._hoverlayer, event: t };
+          e._spikepoints;
+          var $t = { vLinePoint: Ae.vLinePoint, hLinePoint: Ae.hLinePoint };
+          e._spikepoints = $t;
+          var sr = function() {
+            var wi = U.filter(function(qn) {
+              return _ && _._id === qn.xa._id && b && b._id === qn.ya._id;
+            }), On = U.filter(function(qn) {
+              return !(_ && _._id === qn.xa._id && b && b._id === qn.ya._id);
+            });
+            wi.sort(zle), On.sort(zle), U = wi.concat(On), U = Iut(U, h);
+          };
+          sr();
+          var Tr = h.charAt(0), fr = (Tr === "x" || Tr === "y") && U[0] && Sut[U[0].trace.type];
+          if (f && O !== 0 && U.length !== 0) {
+            var $e = U.filter(function(wi) {
+              return wi.ya.showspikes;
+            }), St = ot($e, O, fr);
+            Ae.hLinePoint = ut(St);
+            var Qt = U.filter(function(wi) {
+              return wi.xa.showspikes;
+            }), Gt = ot(Qt, O, fr);
+            Ae.vLinePoint = ut(Gt);
+          }
+          if (U.length === 0) {
+            var _t = KL.unhoverRaw(e, t);
+            return f && (Ae.hLinePoint !== null || Ae.vLinePoint !== null) && Ble() && qle(e, Ae, Wt), _t;
+          }
+          if (f && Ble() && qle(e, Ae, Wt), kg.isXYhover(Le) && U[0].length !== 0 && U[0].trace.type !== "splom") {
+            var It = U[0];
+            Fle[It.trace.type] ? U = U.filter((wi) => wi.trace.index === It.trace.index) : U = [It];
+            var mt = U.length, er = Ule("x", It, s), lr = Ule("y", It, s);
+            Vt(er, lr);
+            var wr = [], Lr = {}, ti = 0, Br = function(wi) {
+              var On = Fle[wi.trace.type] ? Gle(wi) : wi.trace.index;
+              if (!Lr[On]) ti++, Lr[On] = ti, wr.push(wi);
+              else {
+                var qn = Lr[On] - 1, Fn = wr[qn];
+                qn > 0 && Math.abs(wi.distance) < Math.abs(Fn.distance) && (wr[qn] = wi);
+              }
+            }, Vr;
+            for (Vr = 0; Vr < mt; Vr++) Br(U[Vr]);
+            for (Vr = U.length - 1; Vr > mt - 1; Vr--) Br(U[Vr]);
+            U = wr, sr();
+          }
+          var dt = e._hoverdata, Ge = [], Je = Xle(e), We = Zle(e);
+          for (let wi of U) {
+            var tt = kg.makeEventData(wi, wi.trace, wi.cd);
+            if (wi.hovertemplate !== false) {
+              var xt = false;
+              wi.cd[wi.index] && wi.cd[wi.index].ht && (xt = wi.cd[wi.index].ht), wi.hovertemplate = xt || wi.trace.hovertemplate || false;
+            }
+            if (wi.xa && wi.ya) {
+              var Ie = wi.x0 + wi.xa._offset, xe = wi.x1 + wi.xa._offset, ke = wi.y0 + wi.ya._offset, vt = wi.y1 + wi.ya._offset, ir = Math.min(Ie, xe), ar = Math.max(Ie, xe), vr = Math.min(ke, vt), ii = Math.max(ke, vt);
+              tt.bbox = { x0: ir + We, x1: ar + We, y0: vr + Je, y1: ii + Je };
+            }
+            wi.eventData = [tt], Ge.push(tt);
+          }
+          e._hoverdata = Ge;
+          var pi = h === "y" && (G.length > 1 || U.length > 1) || h === "closest" && Be && U.length > 1, $r = vd.combine(s.plot_bgcolor || vd.background, s.paper_bgcolor), di = Hle(U, { gd: e, hovermode: h, rotateLabels: pi, bgColor: $r, container: s._hoverlayer, outerContainer: s._paper.node(), commonLabelOpts: s.hoverlabel, hoverdistance: s.hoverdistance }), ji = di.hoverLabels;
+          if (kg.isUnifiedHover(h) || (kut(ji, pi, s, di.commonLabelBoundingBox), Wle(ji, pi, s._invScaleX, s._invScaleY)), i && i.tagName) {
+            var In = Q3.getComponentMethod("annotations", "hasClickToShow")(e, Ge);
+            yut(jb.select(i), In ? "pointer" : "");
+          }
+          !i || n || !Put(e, t, dt) || (dt && e.emit("plotly_unhover", { event: t, points: dt }), e.emit("plotly_hover", { event: t, points: e._hoverdata, xaxes: C, yaxes: M, xvals: Z, yvals: j }));
+        }
+        function Gle(e) {
+          return [e.trace.index, e.index, e.x0, e.y0, e.name, e.attr, e.xa ? e.xa._id : "", e.ya ? e.ya._id : ""].join(",");
+        }
+        var Eut = /<extra>([\s\S]*)<\/extra>/;
+        function Hle(e, t) {
+          var r = t.gd, n = r._fullLayout, i = t.hovermode, a = t.rotateLabels, o = t.bgColor, s = t.container, l = t.outerContainer, u = t.commonLabelOpts || {};
+          if (e.length === 0) return [[]];
+          var c = t.fontFamily || Wb.HOVERFONT, f = t.fontSize || Wb.HOVERFONTSIZE, h = t.fontWeight || n.font.weight, d = t.fontStyle || n.font.style, v = t.fontVariant || n.font.variant, _ = t.fontTextcase || n.font.textcase, b = t.fontLineposition || n.font.lineposition, p = t.fontShadow || n.font.shadow, k = e[0], E = k.xa, T = k.ya, L = i.charAt(0), x = L + "Label", C = k[x];
+          if (C === void 0 && E.type === "multicategory") for (var M = 0; M < e.length && (C = e[M][x], C === void 0); M++) ;
+          var g = $3(r, l), P = g.top, A = g.width, z = g.height, O = C !== void 0 && k.distance <= t.hoverdistance && (i === "x" || i === "y");
+          if (O) {
+            var U = true, G, Z;
+            for (G = 0; G < e.length; G++) if (U && e[G].zLabel === void 0 && (U = false), Z = e[G].hoverinfo || e[G].trace.hoverinfo, Z) {
+              var j = Array.isArray(Z) ? Z : Z.split("+");
+              if (j.indexOf("all") === -1 && j.indexOf(i) === -1) {
+                O = false;
+                break;
+              }
+            }
+            U && (O = false);
+          }
+          var N = s.selectAll("g.axistext").data(O ? [0] : []);
+          N.enter().append("g").classed("axistext", true), N.exit().remove();
+          var H = { minX: 0, maxX: 0, minY: 0, maxY: 0 };
+          if (N.each(function() {
+            var _t = jb.select(this), It = zf.ensureSingle(_t, "path", "", function(ii) {
+              ii.style({ "stroke-width": "1px" });
+            }), mt = zf.ensureSingle(_t, "text", "", function(ii) {
+              ii.attr("data-notex", 1);
+            }), er = u.bgcolor || vd.defaultLine, lr = u.bordercolor || vd.contrast(er), wr = vd.contrast(er), Lr = u.font, ti = { weight: Lr.weight || h, style: Lr.style || d, variant: Lr.variant || v, textcase: Lr.textcase || _, lineposition: Lr.lineposition || b, shadow: Lr.shadow || p, family: Lr.family || c, size: Lr.size || f, color: Lr.color || wr };
+            It.style({ fill: er, stroke: lr }), mt.text(C).call(Am.font, ti).call(A0.positionText, 0, 0).call(A0.convertToTspans, r), _t.attr("transform", "");
+            var Br = $3(r, mt.node()), Vr, dt;
+            if (i === "x") {
+              var Ge = E.side === "top" ? "-" : "";
+              mt.attr("text-anchor", "middle").call(A0.positionText, 0, E.side === "top" ? P - Br.bottom - Qc - sl : P - Br.top + Qc + sl), Vr = E._offset + (k.x0 + k.x1) / 2, dt = T._offset + (E.side === "top" ? 0 : T._length);
+              var Je = Br.width / 2 + sl, We = Vr;
+              Vr < Je ? We = Je : Vr > n.width - Je && (We = n.width - Je), It.attr("d", "M" + (Vr - We) + ",0L" + (Vr - We + Qc) + "," + Ge + Qc + "H" + Je + "v" + Ge + (sl * 2 + Br.height) + "H" + -Je + "V" + Ge + Qc + "H" + (Vr - We - Qc) + "Z"), Vr = We, H.minX = Vr - Je, H.maxX = Vr + Je, E.side === "top" ? (H.minY = dt - (sl * 2 + Br.height), H.maxY = dt - sl) : (H.minY = dt + sl, H.maxY = dt + (sl * 2 + Br.height));
+            } else {
+              var tt, xt, Ie;
+              T.side === "right" ? (tt = "start", xt = 1, Ie = "", Vr = E._offset + E._length) : (tt = "end", xt = -1, Ie = "-", Vr = E._offset), dt = T._offset + (k.y0 + k.y1) / 2, mt.attr("text-anchor", tt), It.attr("d", "M0,0L" + Ie + Qc + "," + Qc + "V" + (sl + Br.height / 2) + "h" + Ie + (sl * 2 + Br.width) + "V-" + (sl + Br.height / 2) + "H" + Ie + Qc + "V-" + Qc + "Z"), H.minY = dt - (sl + Br.height / 2), H.maxY = dt + (sl + Br.height / 2), T.side === "right" ? (H.minX = Vr + Qc, H.maxX = Vr + Qc + (sl * 2 + Br.width)) : (H.minX = Vr - Qc - (sl * 2 + Br.width), H.maxX = Vr - Qc);
+              var xe = Br.height / 2, ke = P - Br.top - xe, vt = "clip" + n._uid + "commonlabel" + T._id, ir;
+              if (Vr < Br.width + 2 * sl + Qc) {
+                ir = "M-" + (Qc + sl) + "-" + xe + "h-" + (Br.width - sl) + "V" + xe + "h" + (Br.width - sl) + "Z";
+                var ar = Br.width - Vr + sl;
+                A0.positionText(mt, ar, ke), tt === "end" && mt.selectAll("tspan").each(function() {
+                  var ii = jb.select(this), pi = Am.tester.append("text").text(ii.text()).call(Am.font, ti), $r = $3(r, pi.node());
+                  Math.round($r.width) < Math.round(Br.width) && ii.attr("x", ar - $r.width), pi.remove();
+                });
+              } else A0.positionText(mt, xt * (sl + Qc), ke), ir = null;
+              var vr = n._topclips.selectAll("#" + vt).data(ir ? [0] : []);
+              vr.enter().append("clipPath").attr("id", vt).append("path"), vr.exit().remove(), vr.select("path").attr("d", ir), Am.setClipUrl(mt, ir ? vt : null, r);
+            }
+            _t.attr("transform", jB(Vr, dt));
+          }), kg.isUnifiedHover(i)) {
+            s.selectAll("g.hovertext").remove();
+            let _t = e.filter((It) => It.hoverinfo !== "none");
+            if (_t.length === 0) return [];
+            var re = n.hoverlabel, oe = re.font, _e = _t[0], Ce = ((i === "x unified" ? _e.xa : _e.ya).unifiedhovertitle || {}).text, Le = Ce ? zf.hovertemplateString({ data: i === "x unified" ? [{ xa: _e.xa, x: _e.xVal }] : [{ ya: _e.ya, y: _e.yVal }], fallback: _e.trace.hovertemplatefallback, locale: n._d3locale, template: Ce }) : C, ge = { showlegend: true, legend: { title: { text: Le, font: oe }, font: oe, bgcolor: re.bgcolor, bordercolor: re.bordercolor, borderwidth: 1, tracegroupgap: 7, traceorder: n.legend ? n.legend.traceorder : void 0, orientation: "v" } }, ie = { font: oe };
+            xut(ge, ie, r._fullData);
+            var Se = ie.legend;
+            Se.entries = [];
+            for (var Ee = 0; Ee < _t.length; Ee++) {
+              var Ae = _t[Ee];
+              if (Ae.hoverinfo !== "none") {
+                var Be = Ole(Ae, true, i, n, C), Pe = Be[0], me = Be[1];
+                Ae.name = me, me !== "" ? Ae.text = me + " : " + Pe : Ae.text = Pe;
+                var De = Ae.cd[Ae.index];
+                De && (De.mc && (Ae.mc = De.mc), De.mcc && (Ae.mc = De.mcc), De.mlc && (Ae.mlc = De.mlc), De.mlcc && (Ae.mlc = De.mlcc), De.mlw && (Ae.mlw = De.mlw), De.mrc && (Ae.mrc = De.mrc), De.dir && (Ae.dir = De.dir)), Ae._distinct = true, Se.entries.push([Ae]);
+              }
+            }
+            Se.entries.sort(function(It, mt) {
+              return It[0].trace.index - mt[0].trace.index;
+            }), Se.layer = s, Se._inHover = true, Se._groupTitleFont = re.grouptitlefont, but(r, Se);
+            var ce = s.select("g.legend"), je = $3(r, ce.node()), lt = je.width + 2 * sl, pt = je.height + 2 * sl, Vt = _t[0], ot = (Vt.x0 + Vt.x1) / 2, ut = (Vt.y0 + Vt.y1) / 2, Wt = !(Q3.traceIs(Vt.trace, "bar-like") || Q3.traceIs(Vt.trace, "box-violin")), Nt, $t;
+            L === "y" ? Wt ? ($t = ut - sl, Nt = ut + sl) : ($t = Math.min.apply(null, _t.map(function(It) {
+              return Math.min(It.y0, It.y1);
+            })), Nt = Math.max.apply(null, _t.map(function(It) {
+              return Math.max(It.y0, It.y1);
+            }))) : $t = Nt = zf.mean(_t.map(function(It) {
+              return (It.y0 + It.y1) / 2;
+            })) - pt / 2;
+            var sr, Tr;
+            L === "x" ? Wt ? (sr = ot + sl, Tr = ot - sl) : (sr = Math.max.apply(null, _t.map(function(It) {
+              return Math.max(It.x0, It.x1);
+            })), Tr = Math.min.apply(null, _t.map(function(It) {
+              return Math.min(It.x0, It.x1);
+            }))) : sr = Tr = zf.mean(_t.map(function(It) {
+              return (It.x0 + It.x1) / 2;
+            })) - lt / 2;
+            var fr = E._offset, $e = T._offset;
+            Nt += $e, sr += fr, Tr += fr - lt, $t += $e - pt;
+            var St, Qt;
+            return sr + lt < A && sr >= 0 ? St = sr : Tr + lt < A && Tr >= 0 ? St = Tr : fr + lt < A ? St = fr : sr - ot < ot - Tr + lt ? St = A - lt : St = 0, St += sl, Nt + pt < z && Nt >= 0 ? Qt = Nt : $t + pt < z && $t >= 0 ? Qt = $t : $e + pt < z ? Qt = $e : Nt - ut < ut - $t + pt ? Qt = z - pt : Qt = 0, Qt += sl, ce.attr("transform", jB(St - 1, Qt - 1)), ce;
+          }
+          var Gt = s.selectAll("g.hovertext").data(e, function(_t) {
+            return Gle(_t);
+          });
+          return Gt.enter().append("g").classed("hovertext", true).each(function() {
+            var _t = jb.select(this);
+            _t.append("rect").call(vd.fill, vd.addOpacity(o, 0.8)), _t.append("text").classed("name", true), _t.append("path").style("stroke-width", "1px"), _t.append("text").classed("nums", true).call(Am.font, { weight: h, style: d, variant: v, textcase: _, lineposition: b, shadow: p, family: c, size: f });
+          }), Gt.exit().remove(), Gt.each(function(_t) {
+            var It = jb.select(this).attr("transform", ""), mt = _t.color;
+            Array.isArray(mt) && (mt = mt[_t.eventData[0].pointNumber]);
+            var er = _t.bgcolor || mt, lr = vd.combine(vd.opacity(er) ? er : vd.defaultLine, o), wr = vd.combine(vd.opacity(mt) ? mt : vd.defaultLine, o), Lr = _t.borderColor || vd.contrast(lr), ti = Ole(_t, O, i, n, C, It), Br = ti[0], Vr = ti[1], dt = It.select("text.nums").call(Am.font, { family: _t.fontFamily || c, size: _t.fontSize || f, color: _t.fontColor || Lr, weight: _t.fontWeight || h, style: _t.fontStyle || d, variant: _t.fontVariant || v, textcase: _t.fontTextcase || _, lineposition: _t.fontLineposition || b, shadow: _t.fontShadow || p }).text(Br).attr("data-notex", 1).call(A0.positionText, 0, 0).call(A0.convertToTspans, r), Ge = It.select("text.name"), Je = 0, We = 0;
+            if (Vr && Vr !== Br) {
+              Ge.call(Am.font, { family: _t.fontFamily || c, size: _t.fontSize || f, color: wr, weight: _t.fontWeight || h, style: _t.fontStyle || d, variant: _t.fontVariant || v, textcase: _t.fontTextcase || _, lineposition: _t.fontLineposition || b, shadow: _t.fontShadow || p }).text(Vr).attr("data-notex", 1).call(A0.positionText, 0, 0).call(A0.convertToTspans, r);
+              var tt = $3(r, Ge.node());
+              Je = tt.width + 2 * sl, We = tt.height + 2 * sl;
+            } else Ge.remove(), It.select("rect").remove();
+            It.select("path").style({ fill: lr, stroke: Lr });
+            var xt = _t.xa._offset + (_t.x0 + _t.x1) / 2, Ie = _t.ya._offset + (_t.y0 + _t.y1) / 2, xe = Math.abs(_t.x1 - _t.x0), ke = Math.abs(_t.y1 - _t.y0), vt = $3(r, dt.node()), ir = vt.width / n._invScaleX, ar = vt.height / n._invScaleY;
+            _t.ty0 = (P - vt.top) / n._invScaleY, _t.bx = ir + 2 * sl, _t.by = Math.max(ar + 2 * sl, We), _t.anchor = "start", _t.txwidth = ir, _t.tx2width = Je, _t.offset = 0;
+            var vr = (ir + Qc + sl + Je) * n._invScaleX, ii, pi;
+            if (a) _t.pos = xt, ii = Ie + ke / 2 + vr <= z, pi = Ie - ke / 2 - vr >= 0, (_t.idealAlign === "top" || !ii) && pi ? (Ie -= ke / 2, _t.anchor = "end") : ii ? (Ie += ke / 2, _t.anchor = "start") : _t.anchor = "middle", _t.crossPos = Ie;
+            else {
+              if (_t.pos = Ie, ii = xt + xe / 2 + vr <= A, pi = xt - xe / 2 - vr >= 0, (_t.idealAlign === "left" || !ii) && pi) xt -= xe / 2, _t.anchor = "end";
+              else if (ii) xt += xe / 2, _t.anchor = "start";
+              else {
+                _t.anchor = "middle";
+                var $r = vr / 2, di = xt + $r - A, ji = xt - $r;
+                di > 0 && (xt -= di), ji < 0 && (xt += -ji);
+              }
+              _t.crossPos = xt;
+            }
+            dt.attr("text-anchor", _t.anchor), Je && Ge.attr("text-anchor", _t.anchor), It.attr("transform", jB(xt, Ie) + (a ? gut(Vle) : ""));
+          }), { hoverLabels: Gt, commonLabelBoundingBox: H };
+        }
+        function Ole(e, t, r, n, i, a) {
+          var f, h;
+          var o = "", s = "";
+          e.nameOverride !== void 0 && (e.name = e.nameOverride), e.name && (e.trace._meta && (e.name = zf.templateString(e.name, e.trace._meta)), o = Nle(e.name, e.nameLength));
+          var l = r.charAt(0), u = l === "x" ? "y" : "x";
+          e.zLabel !== void 0 ? (e.xLabel !== void 0 && (s += "x: " + e.xLabel + "<br>"), e.yLabel !== void 0 && (s += "y: " + e.yLabel + "<br>"), e.trace.type !== "choropleth" && e.trace.type !== "choroplethmapbox" && e.trace.type !== "choroplethmap" && (s += (s ? "z: " : "") + e.zLabel)) : t && e[l + "Label"] === i ? s = e[u + "Label"] || "" : e.xLabel === void 0 ? e.yLabel !== void 0 && e.trace.type !== "scattercarpet" && (s = e.yLabel) : e.yLabel === void 0 ? s = e.xLabel : s = "(" + e.xLabel + ", " + e.yLabel + ")", (e.text || e.text === 0) && !Array.isArray(e.text) && (s += (s ? "<br>" : "") + e.text), e.extraText !== void 0 && (s += (s ? "<br>" : "") + e.extraText), a && s === "" && !e.hovertemplate && (o === "" && a.remove(), s = o), (h = (f = e.trace) == null ? void 0 : f.hoverlabel) != null && h.split && (e.hovertemplate = "");
+          let { hovertemplate: c = false } = e;
+          if (c) {
+            let d = e.hovertemplateLabels || e;
+            e[l + "Label"] !== i && (d[l + "other"] = d[l + "Val"], d[l + "otherLabel"] = d[l + "Label"]), s = zf.hovertemplateString({ data: [e.eventData[0] || {}, e.trace._meta], fallback: e.trace.hovertemplatefallback, labels: d, locale: n._d3locale, template: c }), s = s.replace(Eut, (v, _) => (o = Nle(_, e.nameLength), ""));
+          }
+          return [s, o];
+        }
+        function kut(e, t, r, n) {
+          var i = t ? "xa" : "ya", a = t ? "ya" : "xa", o = 0, s = 1, l = e.size(), u = new Array(l), c = 0, f = n.minX, h = n.maxX, d = n.minY, v = n.maxY, _ = function(Z) {
+            return Z * r._invScaleX;
+          }, b = function(Z) {
+            return Z * r._invScaleY;
+          };
+          e.each(function(Z) {
+            var j = Z[i], N = Z[a], H = j._id.charAt(0) === "x", re = j.range;
+            c === 0 && re && re[0] > re[1] !== H && (s = -1);
+            var oe = 0, _e = H ? r.width : r.height;
+            if (r.hovermode === "x" || r.hovermode === "y") {
+              var Ce = jle(Z, t), Le = Z.anchor, ge = Le === "end" ? -1 : 1, ie, Se;
+              if (Le === "middle") ie = Z.crossPos + (H ? b(Ce.y - Z.by / 2) : _(Z.bx / 2 + Z.tx2width / 2)), Se = ie + (H ? b(Z.by) : _(Z.bx));
+              else if (H) ie = Z.crossPos + b(Qc + Ce.y) - b(Z.by / 2 - Qc), Se = ie + b(Z.by);
+              else {
+                var Ee = _(ge * Qc + Ce.x), Ae = Ee + _(ge * Z.bx);
+                ie = Z.crossPos + Math.min(Ee, Ae), Se = Z.crossPos + Math.max(Ee, Ae);
+              }
+              H ? d !== void 0 && v !== void 0 && Math.min(Se, v) - Math.max(ie, d) > 1 && (N.side === "left" ? (oe = N._mainLinePosition, _e = r.width) : _e = N._mainLinePosition) : f !== void 0 && h !== void 0 && Math.min(Se, h) - Math.max(ie, f) > 1 && (N.side === "top" ? (oe = N._mainLinePosition, _e = r.height) : _e = N._mainLinePosition);
+            }
+            u[c++] = [{ datum: Z, traceIndex: Z.trace.index, dp: 0, pos: Z.pos, posref: Z.posref, size: Z.by * (H ? wut : 1) / 2, pmin: oe, pmax: _e }];
+          }), u.sort(function(Z, j) {
+            return Z[0].posref - j[0].posref || s * (j[0].traceIndex - Z[0].traceIndex);
+          });
+          var p, k, E, T, L, x, C;
+          function M(Z) {
+            var j = Z[0], N = Z[Z.length - 1];
+            if (k = j.pmin - j.pos - j.dp + j.size, E = N.pos + N.dp + N.size - j.pmax, k > 0.01) {
+              for (L = Z.length - 1; L >= 0; L--) Z[L].dp += k;
+              p = false;
+            }
+            if (!(E < 0.01)) {
+              if (k < -0.01) {
+                for (L = Z.length - 1; L >= 0; L--) Z[L].dp -= E;
+                p = false;
+              }
+              if (p) {
+                var H = 0;
+                for (T = 0; T < Z.length; T++) x = Z[T], x.pos + x.dp + x.size > j.pmax && H++;
+                for (T = Z.length - 1; T >= 0 && !(H <= 0); T--) x = Z[T], x.pos > j.pmax - 1 && (x.del = true, H--);
+                for (T = 0; T < Z.length && !(H <= 0); T++) if (x = Z[T], x.pos < j.pmin + 1) for (x.del = true, H--, E = x.size * 2, L = Z.length - 1; L >= 0; L--) Z[L].dp -= E;
+                for (T = Z.length - 1; T >= 0 && !(H <= 0); T--) x = Z[T], x.pos + x.dp + x.size > j.pmax && (x.del = true, H--);
+              }
+            }
+          }
+          for (; !p && o <= l; ) {
+            for (o++, p = true, T = 0; T < u.length - 1; ) {
+              var g = u[T], P = u[T + 1], A = g[g.length - 1], z = P[0];
+              if (k = A.pos + A.dp + A.size - z.pos - z.dp + z.size, k > 0.01) {
+                for (L = P.length - 1; L >= 0; L--) P[L].dp += k;
+                for (g.push.apply(g, P), u.splice(T + 1, 1), C = 0, L = g.length - 1; L >= 0; L--) C += g[L].dp;
+                for (E = C / g.length, L = g.length - 1; L >= 0; L--) g[L].dp -= E;
+                p = false;
+              } else T++;
+            }
+            u.forEach(M);
+          }
+          for (T = u.length - 1; T >= 0; T--) {
+            var O = u[T];
+            for (L = O.length - 1; L >= 0; L--) {
+              var U = O[L], G = U.datum;
+              G.offset = U.dp, G.del = U.del;
+            }
+          }
+        }
+        function jle(e, t) {
+          var r = 0, n = e.offset;
+          return t && (n *= -Aut, r = e.offset * Tut), { x: r, y: n };
+        }
+        function Cut(e) {
+          var t = { start: 1, end: -1, middle: 0 }[e.anchor], r = t * (Qc + sl), n = r + t * (e.txwidth + sl), i = e.anchor === "middle";
+          return i && (r -= e.tx2width / 2, n += e.txwidth / 2 + sl), { alignShift: t, textShiftX: r, text2ShiftX: n };
+        }
+        function Wle(e, t, r, n) {
+          var i = function(o) {
+            return o * r;
+          }, a = function(o) {
+            return o * n;
+          };
+          e.each(function(o) {
+            var s = jb.select(this);
+            if (o.del) return s.remove();
+            var l = s.select("text.nums"), u = o.anchor, c = u === "end" ? -1 : 1, f = Cut(o), h = jle(o, t), d = h.x, v = h.y, _ = u === "middle", b = "hoverlabel" in o.trace ? o.trace.hoverlabel.showarrow : true, p;
+            _ ? p = "M-" + i(o.bx / 2 + o.tx2width / 2) + "," + a(v - o.by / 2) + "h" + i(o.bx) + "v" + a(o.by) + "h-" + i(o.bx) + "Z" : b ? p = "M0,0L" + i(c * Qc + d) + "," + a(Qc + v) + "v" + a(o.by / 2 - Qc) + "h" + i(c * o.bx) + "v-" + a(o.by) + "H" + i(c * Qc + d) + "V" + a(v - Qc) + "Z" : p = "M" + i(c * Qc + d) + "," + a(v - o.by / 2) + "h" + i(c * o.bx) + "v" + a(o.by) + "h" + i(-c * o.bx) + "Z", s.select("path").attr("d", p);
+            var k = d + f.textShiftX, E = v + o.ty0 - o.by / 2 + sl, T = o.textAlign || "auto";
+            T !== "auto" && (T === "left" && u !== "start" ? (l.attr("text-anchor", "start"), k = _ ? -o.bx / 2 - o.tx2width / 2 + sl : -o.bx - sl) : T === "right" && u !== "end" && (l.attr("text-anchor", "end"), k = _ ? o.bx / 2 - o.tx2width / 2 - sl : o.bx + sl)), l.call(A0.positionText, i(k), a(E)), o.tx2width && (s.select("text.name").call(A0.positionText, i(f.text2ShiftX + f.alignShift * sl + d), a(v + o.ty0 - o.by / 2 + sl)), s.select("rect").call(Am.setRect, i(f.text2ShiftX + (f.alignShift - 1) * o.tx2width / 2 + d), a(v - o.by / 2 - 1), i(o.tx2width), a(o.by + 2)));
+          });
+        }
+        function Lut(e, t) {
+          var r = e.index, n = e.trace || {}, i = e.cd[0], a = e.cd[r] || {};
+          function o(h) {
+            return h || Py(h) && h === 0;
+          }
+          var s = Array.isArray(r) ? function(h, d) {
+            var v = zf.castOption(i, r, h);
+            return o(v) ? v : zf.extractOption({}, n, "", d);
+          } : function(h, d) {
+            return zf.extractOption(a, n, h, d);
+          };
+          function l(h, d, v) {
+            var _ = s(d, v);
+            o(_) && (e[h] = _);
+          }
+          if (l("hoverinfo", "hi", "hoverinfo"), l("bgcolor", "hbg", "hoverlabel.bgcolor"), l("borderColor", "hbc", "hoverlabel.bordercolor"), l("fontFamily", "htf", "hoverlabel.font.family"), l("fontSize", "hts", "hoverlabel.font.size"), l("fontColor", "htc", "hoverlabel.font.color"), l("fontWeight", "htw", "hoverlabel.font.weight"), l("fontStyle", "hty", "hoverlabel.font.style"), l("fontVariant", "htv", "hoverlabel.font.variant"), l("nameLength", "hnl", "hoverlabel.namelength"), l("textAlign", "hta", "hoverlabel.align"), e.posref = t === "y" || t === "closest" && n.orientation === "h" ? e.xa._offset + (e.x0 + e.x1) / 2 : e.ya._offset + (e.y0 + e.y1) / 2, e.x0 = zf.constrain(e.x0, 0, e.xa._length), e.x1 = zf.constrain(e.x1, 0, e.xa._length), e.y0 = zf.constrain(e.y0, 0, e.ya._length), e.y1 = zf.constrain(e.y1, 0, e.ya._length), e.xLabelVal !== void 0 && (e.xLabel = "xLabel" in e ? e.xLabel : Sm.hoverLabelText(e.xa, e.xLabelVal, n.xhoverformat), e.xVal = e.xa.c2d(e.xLabelVal)), e.yLabelVal !== void 0 && (e.yLabel = "yLabel" in e ? e.yLabel : Sm.hoverLabelText(e.ya, e.yLabelVal, n.yhoverformat), e.yVal = e.ya.c2d(e.yLabelVal)), e.zLabelVal !== void 0 && e.zLabel === void 0 && (e.zLabel = String(e.zLabelVal)), !isNaN(e.xerr) && !(e.xa.type === "log" && e.xerr <= 0)) {
+            var u = Sm.tickText(e.xa, e.xa.c2l(e.xerr), "hover").text;
+            e.xerrneg !== void 0 ? e.xLabel += " +" + u + " / -" + Sm.tickText(e.xa, e.xa.c2l(e.xerrneg), "hover").text : e.xLabel += " ± " + u, t === "x" && (e.distance += 1);
+          }
+          if (!isNaN(e.yerr) && !(e.ya.type === "log" && e.yerr <= 0)) {
+            var c = Sm.tickText(e.ya, e.ya.c2l(e.yerr), "hover").text;
+            e.yerrneg !== void 0 ? e.yLabel += " +" + c + " / -" + Sm.tickText(e.ya, e.ya.c2l(e.yerrneg), "hover").text : e.yLabel += " ± " + c, t === "y" && (e.distance += 1);
+          }
+          var f = e.hoverinfo || e.trace.hoverinfo;
+          return f && f !== "all" && (f = Array.isArray(f) ? f : f.split("+"), f.indexOf("x") === -1 && (e.xLabel = void 0), f.indexOf("y") === -1 && (e.yLabel = void 0), f.indexOf("z") === -1 && (e.zLabel = void 0), f.indexOf("text") === -1 && (e.text = void 0), f.indexOf("name") === -1 && (e.name = void 0)), e;
+        }
+        function qle(e, t, r) {
+          var n = r.container, i = r.fullLayout, a = i._size, o = r.event, s = !!t.hLinePoint, l = !!t.vLinePoint, u, c;
+          if (n.selectAll(".spikeline").remove(), !!(l || s)) {
+            var f = vd.combine(i.plot_bgcolor, i.paper_bgcolor);
+            if (s) {
+              var h = t.hLinePoint, d, v;
+              u = h && h.xa, c = h && h.ya;
+              var _ = c.spikesnap;
+              _ === "cursor" ? (d = o.pointerX, v = o.pointerY) : (d = u._offset + h.x, v = c._offset + h.y);
+              var b = Dle.readability(h.color, f) < 1.5 ? vd.contrast(f) : h.color, p = c.spikemode, k = c.spikethickness, E = c.spikecolor || b, T = Sm.getPxPosition(e, c), L, x;
+              if (p.indexOf("toaxis") !== -1 || p.indexOf("across") !== -1) {
+                if (p.indexOf("toaxis") !== -1 && (L = T, x = d), p.indexOf("across") !== -1) {
+                  var C = c._counterDomainMin, M = c._counterDomainMax;
+                  c.anchor === "free" && (C = Math.min(C, c.position), M = Math.max(M, c.position)), L = a.l + C * a.w, x = a.l + M * a.w;
+                }
+                n.insert("line", ":first-child").attr({ x1: L, x2: x, y1: v, y2: v, "stroke-width": k, stroke: E, "stroke-dasharray": Am.dashStyle(c.spikedash, k) }).classed("spikeline", true).classed("crisp", true), n.insert("line", ":first-child").attr({ x1: L, x2: x, y1: v, y2: v, "stroke-width": k + 2, stroke: f }).classed("spikeline", true).classed("crisp", true);
+              }
+              p.indexOf("marker") !== -1 && n.insert("circle", ":first-child").attr({ cx: T + (c.side !== "right" ? k : -k), cy: v, r: k, fill: E }).classed("spikeline", true);
+            }
+            if (l) {
+              var g = t.vLinePoint, P, A;
+              u = g && g.xa, c = g && g.ya;
+              var z = u.spikesnap;
+              z === "cursor" ? (P = o.pointerX, A = o.pointerY) : (P = u._offset + g.x, A = c._offset + g.y);
+              var O = Dle.readability(g.color, f) < 1.5 ? vd.contrast(f) : g.color, U = u.spikemode, G = u.spikethickness, Z = u.spikecolor || O, j = Sm.getPxPosition(e, u), N, H;
+              if (U.indexOf("toaxis") !== -1 || U.indexOf("across") !== -1) {
+                if (U.indexOf("toaxis") !== -1 && (N = j, H = A), U.indexOf("across") !== -1) {
+                  var re = u._counterDomainMin, oe = u._counterDomainMax;
+                  u.anchor === "free" && (re = Math.min(re, u.position), oe = Math.max(oe, u.position)), N = a.t + (1 - oe) * a.h, H = a.t + (1 - re) * a.h;
+                }
+                n.insert("line", ":first-child").attr({ x1: P, x2: P, y1: N, y2: H, "stroke-width": G, stroke: Z, "stroke-dasharray": Am.dashStyle(u.spikedash, G) }).classed("spikeline", true).classed("crisp", true), n.insert("line", ":first-child").attr({ x1: P, x2: P, y1: N, y2: H, "stroke-width": G + 2, stroke: f }).classed("spikeline", true).classed("crisp", true);
+              }
+              U.indexOf("marker") !== -1 && n.insert("circle", ":first-child").attr({ cx: P, cy: j - (u.side !== "top" ? G : -G), r: G, fill: Z }).classed("spikeline", true);
+            }
+          }
+        }
+        function Put(e, t, r) {
+          if (!r || r.length !== e._hoverdata.length) return true;
+          for (var n = r.length - 1; n >= 0; n--) {
+            var i = r[n], a = e._hoverdata[n];
+            if (i.curveNumber !== a.curveNumber || String(i.pointNumber) !== String(a.pointNumber) || String(i.pointNumbers) !== String(a.pointNumbers) || i.binNumber !== a.binNumber) return true;
+          }
+          return false;
+        }
+        function Ble(e, t) {
+          return true;
+        }
+        function Nle(e, t) {
+          return A0.plainText(e || "", { len: t, allowedTags: ["br", "sub", "sup", "b", "i", "em", "s", "u"] });
+        }
+        function Iut(e, t) {
+          for (var r = t.charAt(0), n = [], i = [], a = [], o = 0; o < e.length; o++) {
+            var s = e[o];
+            Q3.traceIs(s.trace, "bar-like") || Q3.traceIs(s.trace, "box-violin") ? a.push(s) : s.trace[r + "period"] ? i.push(s) : n.push(s);
+          }
+          return n.concat(i).concat(a);
+        }
+        function Ule(e, t, r) {
+          var n = t[e + "a"], i = t[e + "Val"], a = t.cd[0];
+          if (n.type === "category" || n.type === "multicategory") i = n._categoriesMap[i];
+          else if (n.type === "date") {
+            var o = t.trace[e + "periodalignment"];
+            if (o) {
+              var s = t.cd[t.index], l = s[e + "Start"];
+              l === void 0 && (l = s[e]);
+              var u = s[e + "End"];
+              u === void 0 && (u = s[e]);
+              var c = u - l;
+              o === "end" ? i += c : o === "middle" && (i += c / 2);
+            }
+            i = n.d2c(i);
+          }
+          return a && a.t && a.t.posLetter === n._id && (r.boxmode === "group" || r.violinmode === "group") && (i += a.t.dPos), i;
+        }
+        var Xle = (e) => e.offsetTop + e.clientTop, Zle = (e) => e.offsetLeft + e.clientLeft;
+        function $3(e, t) {
+          var r = e._fullLayout, n = t.getBoundingClientRect(), i = n.left, a = n.top, o = i + n.width, s = a + n.height, l = zf.apply3DTransform(r._invTransform)(i, a), u = zf.apply3DTransform(r._invTransform)(o, s), c = l[0], f = l[1], h = u[0], d = u[1];
+          return { x: c, y: f, width: h - c, height: d - f, top: Math.min(f, d), left: Math.min(c, h), right: Math.max(c, h), bottom: Math.max(f, d) };
+        }
+      });
+      var _M = ye((Ear, Yle) => {
+        var Rut = Dr(), Dut = ka(), Fut = ip().isUnifiedHover;
+        Yle.exports = function(t, r, n, i) {
+          i = i || {};
+          var a = r.legend;
+          function o(s) {
+            i.font[s] || (i.font[s] = a ? r.legend.font[s] : r.font[s]);
+          }
+          r && Fut(r.hovermode) && (i.font || (i.font = {}), o("size"), o("family"), o("color"), o("weight"), o("style"), o("variant"), a ? (i.bgcolor || (i.bgcolor = Dut.combine(r.legend.bgcolor, r.paper_bgcolor)), i.bordercolor || (i.bordercolor = r.legend.bordercolor)) : i.bgcolor || (i.bgcolor = r.paper_bgcolor)), n("hoverlabel.bgcolor", i.bgcolor), n("hoverlabel.bordercolor", i.bordercolor), n("hoverlabel.namelength", i.namelength), n("hoverlabel.showarrow", i.showarrow), Rut.coerceFont(n, "hoverlabel.font", i.font), n("hoverlabel.align", i.align);
+        };
+      });
+      var Jle = ye((kar, Kle) => {
+        var zut = Dr(), Out = _M(), qut = W1();
+        Kle.exports = function(t, r) {
+          function n(i, a) {
+            return zut.coerce(t, r, qut, i, a);
+          }
+          Out(t, r, n);
+        };
+      });
+      var eue = ye((Car, Qle) => {
+        var $le = Dr(), But = v3(), Nut = _M();
+        Qle.exports = function(t, r, n, i) {
+          function a(s, l) {
+            return $le.coerce(t, r, But, s, l);
+          }
+          var o = $le.extendFlat({}, i.hoverlabel);
+          r.hovertemplate && (o.namelength = -1), Nut(t, r, a, o);
+        };
+      });
+      var YB = ye((Lar, tue) => {
+        var Uut = Dr(), Vut = W1();
+        tue.exports = function(t, r) {
+          function n(i, a) {
+            return r[i] !== void 0 ? r[i] : Uut.coerce(t, r, Vut, i, a);
+          }
+          return n("clickmode"), n("hoversubplots"), n("hovermode");
+        };
+      });
+      var nue = ye((Par, iue) => {
+        var rue = Dr(), Gut = W1(), Hut = YB(), jut = _M();
+        iue.exports = function(t, r) {
+          function n(c, f) {
+            return rue.coerce(t, r, Gut, c, f);
+          }
+          var i = Hut(t, r);
+          i && (n("hoverdistance"), n("spikedistance"));
+          var a = n("dragmode");
+          a === "select" && n("selectdirection");
+          var o = r._has("mapbox"), s = r._has("map"), l = r._has("geo"), u = r._basePlotModules.length;
+          r.dragmode === "zoom" && ((o || s || l) && u === 1 || (o || s) && l && u === 2) && (r.dragmode = "pan"), jut(t, r, n), rue.coerceFont(n, "hoverlabel.grouptitlefont", r.hoverlabel.font);
+        };
+      });
+      var sue = ye((Iar, oue) => {
+        var KB = Dr(), aue = qa();
+        oue.exports = function(t) {
+          var r = t.calcdata, n = t._fullLayout;
+          function i(u) {
+            return function(c) {
+              return KB.coerceHoverinfo({ hoverinfo: c }, { _module: u._module }, n);
+            };
+          }
+          for (var a = 0; a < r.length; a++) {
+            var o = r[a], s = o[0].trace;
+            if (!aue.traceIs(s, "pie-like")) {
+              var l = aue.traceIs(s, "2dMap") ? Wut : KB.fillArray;
+              l(s.hoverinfo, o, "hi", i(s)), s.hovertemplate && l(s.hovertemplate, o, "ht"), s.hoverlabel && (l(s.hoverlabel.bgcolor, o, "hbg"), l(s.hoverlabel.bordercolor, o, "hbc"), l(s.hoverlabel.font.size, o, "hts"), l(s.hoverlabel.font.color, o, "htc"), l(s.hoverlabel.font.family, o, "htf"), l(s.hoverlabel.font.weight, o, "htw"), l(s.hoverlabel.font.style, o, "hty"), l(s.hoverlabel.font.variant, o, "htv"), l(s.hoverlabel.namelength, o, "hnl"), l(s.hoverlabel.align, o, "hta"), l(s.hoverlabel.showarrow, o, "htsa"));
+            }
+          }
+        };
+        function Wut(e, t, r, n) {
+          n = n || KB.identity, Array.isArray(e) && (t[0][r] = n(e));
+        }
+      });
+      var uue = ye((Rar, lue) => {
+        var Xut = qa(), Zut = ZB().hover;
+        lue.exports = function(t, r, n) {
+          var i = Xut.getComponentMethod("annotations", "onClick")(t, t._hoverdata);
+          n !== void 0 && Zut(t, r, n, true);
+          function a() {
+            t.emit("plotly_click", { points: t._hoverdata, event: r });
+          }
+          t._hoverdata && r && r.target && (i && i.then ? i.then(a) : a(), r.stopImmediatePropagation && r.stopImmediatePropagation());
+        };
+      });
+      var vf = ye((Dar, hue) => {
+        var Yut = Oa(), JL = Dr(), Kut = yv(), xM = ip(), cue = W1(), fue = ZB();
+        hue.exports = { moduleType: "component", name: "fx", constants: NS(), schema: { layout: cue }, attributes: v3(), layoutAttributes: cue, supplyLayoutGlobalDefaults: Jle(), supplyDefaults: eue(), supplyLayoutDefaults: nue(), calc: sue(), getDistanceFunction: xM.getDistanceFunction, getClosest: xM.getClosest, inbox: xM.inbox, quadrature: xM.quadrature, appendArrayPointValue: xM.appendArrayPointValue, castHoverOption: $ut, castHoverinfo: Qut, hover: fue.hover, unhover: Kut.unhover, loneHover: fue.loneHover, loneUnhover: Jut, click: uue() };
+        function Jut(e) {
+          var t = JL.isD3Selection(e) ? e : Yut.select(e);
+          t.selectAll("g.hovertext").remove(), t.selectAll(".spikeline").remove();
+        }
+        function $ut(e, t, r) {
+          return JL.castOption(e, t, "hoverlabel." + r);
+        }
+        function Qut(e, t, r) {
+          function n(i) {
+            return JL.coerceHoverinfo({ hoverinfo: i }, { _module: e._module }, t);
+          }
+          return JL.castOption(e, r, "hoverinfo", n);
+        }
+      });
+      var Cg = ye((Iy) => {
+        Iy.selectMode = function(e) {
+          return e === "lasso" || e === "select";
+        };
+        Iy.drawMode = function(e) {
+          return e === "drawclosedpath" || e === "drawopenpath" || e === "drawline" || e === "drawrect" || e === "drawcircle";
+        };
+        Iy.openMode = function(e) {
+          return e === "drawline" || e === "drawopenpath";
+        };
+        Iy.rectMode = function(e) {
+          return e === "select" || e === "drawline" || e === "drawrect" || e === "drawcircle";
+        };
+        Iy.freeMode = function(e) {
+          return e === "lasso" || e === "drawclosedpath" || e === "drawopenpath";
+        };
+        Iy.selectingOrDrawing = function(e) {
+          return Iy.freeMode(e) || Iy.rectMode(e);
+        };
+      });
+      var bM = ye((zar, due) => {
+        due.exports = function(t) {
+          var r = t._fullLayout;
+          r._glcanvas && r._glcanvas.size() && r._glcanvas.each(function(n) {
+            n.regl && n.regl.clear({ color: true, depth: true });
+          });
+        };
+      });
+      var $L = ye((Oar, vue) => {
+        vue.exports = { undo: { width: 857.1, height: 1e3, path: "m857 350q0-87-34-166t-91-137-137-92-166-34q-96 0-183 41t-147 114q-4 6-4 13t5 11l76 77q6 5 14 5 9-1 13-7 41-53 100-82t126-29q58 0 110 23t92 61 61 91 22 111-22 111-61 91-92 61-110 23q-55 0-105-20t-90-57l77-77q17-16 8-38-10-23-33-23h-250q-15 0-25 11t-11 25v250q0 24 22 33 22 10 39-8l72-72q60 57 137 88t159 31q87 0 166-34t137-92 91-137 34-166z", transform: "matrix(1 0 0 -1 0 850)" }, home: { width: 928.6, height: 1e3, path: "m786 296v-267q0-15-11-26t-25-10h-214v214h-143v-214h-214q-15 0-25 10t-11 26v267q0 1 0 2t0 2l321 264 321-264q1-1 1-4z m124 39l-34-41q-5-5-12-6h-2q-7 0-12 3l-386 322-386-322q-7-4-13-4-7 2-12 7l-35 41q-4 5-3 13t6 12l401 334q18 15 42 15t43-15l136-114v109q0 8 5 13t13 5h107q8 0 13-5t5-13v-227l122-102q5-5 6-12t-4-13z", transform: "matrix(1 0 0 -1 0 850)" }, "camera-retro": { width: 1e3, height: 1e3, path: "m518 386q0 8-5 13t-13 5q-37 0-63-27t-26-63q0-8 5-13t13-5 12 5 5 13q0 23 16 38t38 16q8 0 13 5t5 13z m125-73q0-59-42-101t-101-42-101 42-42 101 42 101 101 42 101-42 42-101z m-572-320h858v71h-858v-71z m643 320q0 89-62 152t-152 62-151-62-63-152 63-151 151-63 152 63 62 151z m-571 358h214v72h-214v-72z m-72-107h858v143h-462l-36-71h-360v-72z m929 143v-714q0-30-21-51t-50-21h-858q-29 0-50 21t-21 51v714q0 30 21 51t50 21h858q29 0 50-21t21-51z", transform: "matrix(1 0 0 -1 0 850)" }, zoombox: { width: 1e3, height: 1e3, path: "m1000-25l-250 251c40 63 63 138 63 218 0 224-182 406-407 406-224 0-406-182-406-406s183-406 407-406c80 0 155 22 218 62l250-250 125 125z m-812 250l0 438 437 0 0-438-437 0z m62 375l313 0 0-312-313 0 0 312z", transform: "matrix(1 0 0 -1 0 850)" }, pan: { width: 1e3, height: 1e3, path: "m1000 350l-187 188 0-125-250 0 0 250 125 0-188 187-187-187 125 0 0-250-250 0 0 125-188-188 186-187 0 125 252 0 0-250-125 0 187-188 188 188-125 0 0 250 250 0 0-126 187 188z", transform: "matrix(1 0 0 -1 0 850)" }, zoom_plus: { width: 875, height: 1e3, path: "m1 787l0-875 875 0 0 875-875 0z m687-500l-187 0 0-187-125 0 0 187-188 0 0 125 188 0 0 187 125 0 0-187 187 0 0-125z", transform: "matrix(1 0 0 -1 0 850)" }, zoom_minus: { width: 875, height: 1e3, path: "m0 788l0-876 875 0 0 876-875 0z m688-500l-500 0 0 125 500 0 0-125z", transform: "matrix(1 0 0 -1 0 850)" }, autoscale: { width: 1e3, height: 1e3, path: "m250 850l-187 0-63 0 0-62 0-188 63 0 0 188 187 0 0 62z m688 0l-188 0 0-62 188 0 0-188 62 0 0 188 0 62-62 0z m-875-938l0 188-63 0 0-188 0-62 63 0 187 0 0 62-187 0z m875 188l0-188-188 0 0-62 188 0 62 0 0 62 0 188-62 0z m-125 188l-1 0-93-94-156 156 156 156 92-93 2 0 0 250-250 0 0-2 93-92-156-156-156 156 94 92 0 2-250 0 0-250 0 0 93 93 157-156-157-156-93 94 0 0 0-250 250 0 0 0-94 93 156 157 156-157-93-93 0 0 250 0 0 250z", transform: "matrix(1 0 0 -1 0 850)" }, tooltip_basic: { width: 1500, height: 1e3, path: "m375 725l0 0-375-375 375-374 0-1 1125 0 0 750-1125 0z", transform: "matrix(1 0 0 -1 0 850)" }, tooltip_compare: { width: 1125, height: 1e3, path: "m187 786l0 2-187-188 188-187 0 0 937 0 0 373-938 0z m0-499l0 1-187-188 188-188 0 0 937 0 0 376-938-1z", transform: "matrix(1 0 0 -1 0 850)" }, plotlylogo: { width: 1542, height: 1e3, path: "m0-10h182v-140h-182v140z m228 146h183v-286h-183v286z m225 714h182v-1000h-182v1000z m225-285h182v-715h-182v715z m225 142h183v-857h-183v857z m231-428h182v-429h-182v429z m225-291h183v-138h-183v138z", transform: "matrix(1 0 0 -1 0 850)" }, "z-axis": { width: 1e3, height: 1e3, path: "m833 5l-17 108v41l-130-65 130-66c0 0 0 38 0 39 0-1 36-14 39-25 4-15-6-22-16-30-15-12-39-16-56-20-90-22-187-23-279-23-261 0-341 34-353 59 3 60 228 110 228 110-140-8-351-35-351-116 0-120 293-142 474-142 155 0 477 22 477 142 0 50-74 79-163 96z m-374 94c-58-5-99-21-99-40 0-24 65-43 144-43 79 0 143 19 143 43 0 19-42 34-98 40v216h87l-132 135-133-135h88v-216z m167 515h-136v1c16 16 31 34 46 52l84 109v54h-230v-71h124v-1c-16-17-28-32-44-51l-89-114v-51h245v72z", transform: "matrix(1 0 0 -1 0 850)" }, "3d_rotate": { width: 1e3, height: 1e3, path: "m922 660c-5 4-9 7-14 11-359 263-580-31-580-31l-102 28 58-400c0 1 1 1 2 2 118 108 351 249 351 249s-62 27-100 42c88 83 222 183 347 122 16-8 30-17 44-27-2 1-4 2-6 4z m36-329c0 0 64 229-88 296-62 27-124 14-175-11 157-78 225-208 249-266 8-19 11-31 11-31 2 5 6 15 11 32-5-13-8-20-8-20z m-775-239c70-31 117-50 198-32-121 80-199 346-199 346l-96-15-58-12c0 0 55-226 155-287z m603 133l-317-139c0 0 4-4 19-14 7-5 24-15 24-15s-177-147-389 4c235-287 536-112 536-112l31-22 100 299-4-1z m-298-153c6-4 14-9 24-15 0 0-17 10-24 15z", transform: "matrix(1 0 0 -1 0 850)" }, camera: { width: 1e3, height: 1e3, path: "m500 450c-83 0-150-67-150-150 0-83 67-150 150-150 83 0 150 67 150 150 0 83-67 150-150 150z m400 150h-120c-16 0-34 13-39 29l-31 93c-6 15-23 28-40 28h-340c-16 0-34-13-39-28l-31-94c-6-15-23-28-40-28h-120c-55 0-100-45-100-100v-450c0-55 45-100 100-100h800c55 0 100 45 100 100v450c0 55-45 100-100 100z m-400-550c-138 0-250 112-250 250 0 138 112 250 250 250 138 0 250-112 250-250 0-138-112-250-250-250z m365 380c-19 0-35 16-35 35 0 19 16 35 35 35 19 0 35-16 35-35 0-19-16-35-35-35z", transform: "matrix(1 0 0 -1 0 850)" }, movie: { width: 1e3, height: 1e3, path: "m938 413l-188-125c0 37-17 71-44 94 64 38 107 107 107 187 0 121-98 219-219 219-121 0-219-98-219-219 0-61 25-117 66-156h-115c30 33 49 76 49 125 0 103-84 187-187 187s-188-84-188-187c0-57 26-107 65-141-38-22-65-62-65-109v-250c0-70 56-126 125-126h500c69 0 125 56 125 126l188-126c34 0 62 28 62 63v375c0 35-28 63-62 63z m-750 0c-69 0-125 56-125 125s56 125 125 125 125-56 125-125-56-125-125-125z m406-1c-87 0-157 70-157 157 0 86 70 156 157 156s156-70 156-156-70-157-156-157z", transform: "matrix(1 0 0 -1 0 850)" }, question: { width: 857.1, height: 1e3, path: "m500 82v107q0 8-5 13t-13 5h-107q-8 0-13-5t-5-13v-107q0-8 5-13t13-5h107q8 0 13 5t5 13z m143 375q0 49-31 91t-77 65-95 23q-136 0-207-119-9-14 4-24l74-55q4-4 10-4 9 0 14 7 30 38 48 51 19 14 48 14 27 0 48-15t21-33q0-21-11-34t-38-25q-35-16-65-48t-29-70v-20q0-8 5-13t13-5h107q8 0 13 5t5 13q0 10 12 27t30 28q18 10 28 16t25 19 25 27 16 34 7 45z m214-107q0-117-57-215t-156-156-215-58-216 58-155 156-58 215 58 215 155 156 216 58 215-58 156-156 57-215z", transform: "matrix(1 0 0 -1 0 850)" }, disk: { width: 857.1, height: 1e3, path: "m214-7h429v214h-429v-214z m500 0h72v500q0 8-6 21t-11 20l-157 156q-5 6-19 12t-22 5v-232q0-22-15-38t-38-16h-322q-22 0-37 16t-16 38v232h-72v-714h72v232q0 22 16 38t37 16h465q22 0 38-16t15-38v-232z m-214 518v178q0 8-5 13t-13 5h-107q-7 0-13-5t-5-13v-178q0-8 5-13t13-5h107q7 0 13 5t5 13z m357-18v-518q0-22-15-38t-38-16h-750q-23 0-38 16t-16 38v750q0 22 16 38t38 16h517q23 0 50-12t42-26l156-157q16-15 27-42t11-49z", transform: "matrix(1 0 0 -1 0 850)" }, drawopenpath: { width: 70, height: 70, path: "M33.21,85.65a7.31,7.31,0,0,1-2.59-.48c-8.16-3.11-9.27-19.8-9.88-41.3-.1-3.58-.19-6.68-.35-9-.15-2.1-.67-3.48-1.43-3.79-2.13-.88-7.91,2.32-12,5.86L3,32.38c1.87-1.64,11.55-9.66,18.27-6.9,2.13.87,4.75,3.14,5.17,9,.17,2.43.26,5.59.36,9.25a224.17,224.17,0,0,0,1.5,23.4c1.54,10.76,4,12.22,4.48,12.4.84.32,2.79-.46,5.76-3.59L43,80.07C41.53,81.57,37.68,85.64,33.21,85.65ZM74.81,69a11.34,11.34,0,0,0,6.09-6.72L87.26,44.5,74.72,32,56.9,38.35c-2.37.86-5.57,3.42-6.61,6L38.65,72.14l8.42,8.43ZM55,46.27a7.91,7.91,0,0,1,3.64-3.17l14.8-5.3,8,8L76.11,60.6l-.06.19a6.37,6.37,0,0,1-3,3.43L48.25,74.59,44.62,71Zm16.57,7.82A6.9,6.9,0,1,0,64.64,61,6.91,6.91,0,0,0,71.54,54.09Zm-4.05,0a2.85,2.85,0,1,1-2.85-2.85A2.86,2.86,0,0,1,67.49,54.09Zm-4.13,5.22L60.5,56.45,44.26,72.7l2.86,2.86ZM97.83,35.67,84.14,22l-8.57,8.57L89.26,44.24Zm-13.69-8,8,8-2.85,2.85-8-8Z", transform: "matrix(1 0 0 1 -15 -15)" }, drawclosedpath: { width: 90, height: 90, path: "M88.41,21.12a26.56,26.56,0,0,0-36.18,0l-2.07,2-2.07-2a26.57,26.57,0,0,0-36.18,0,23.74,23.74,0,0,0,0,34.8L48,90.12a3.22,3.22,0,0,0,4.42,0l36-34.21a23.73,23.73,0,0,0,0-34.79ZM84,51.24,50.16,83.35,16.35,51.25a17.28,17.28,0,0,1,0-25.47,20,20,0,0,1,27.3,0l4.29,4.07a3.23,3.23,0,0,0,4.44,0l4.29-4.07a20,20,0,0,1,27.3,0,17.27,17.27,0,0,1,0,25.46ZM66.76,47.68h-33v6.91h33ZM53.35,35H46.44V68h6.91Z", transform: "matrix(1 0 0 1 -5 -5)" }, lasso: { width: 1031, height: 1e3, path: "m1018 538c-36 207-290 336-568 286-277-48-473-256-436-463 10-57 36-108 76-151-13-66 11-137 68-183 34-28 75-41 114-42l-55-70 0 0c-2-1-3-2-4-3-10-14-8-34 5-45 14-11 34-8 45 4 1 1 2 3 2 5l0 0 113 140c16 11 31 24 45 40 4 3 6 7 8 11 48-3 100 0 151 9 278 48 473 255 436 462z m-624-379c-80 14-149 48-197 96 42 42 109 47 156 9 33-26 47-66 41-105z m-187-74c-19 16-33 37-39 60 50-32 109-55 174-68-42-25-95-24-135 8z m360 75c-34-7-69-9-102-8 8 62-16 128-68 170-73 59-175 54-244-5-9 20-16 40-20 61-28 159 121 317 333 354s407-60 434-217c28-159-121-318-333-355z", transform: "matrix(1 0 0 -1 0 850)" }, selectbox: { width: 1e3, height: 1e3, path: "m0 850l0-143 143 0 0 143-143 0z m286 0l0-143 143 0 0 143-143 0z m285 0l0-143 143 0 0 143-143 0z m286 0l0-143 143 0 0 143-143 0z m-857-286l0-143 143 0 0 143-143 0z m857 0l0-143 143 0 0 143-143 0z m-857-285l0-143 143 0 0 143-143 0z m857 0l0-143 143 0 0 143-143 0z m-857-286l0-143 143 0 0 143-143 0z m286 0l0-143 143 0 0 143-143 0z m285 0l0-143 143 0 0 143-143 0z m286 0l0-143 143 0 0 143-143 0z", transform: "matrix(1 0 0 -1 0 850)" }, drawline: { width: 70, height: 70, path: "M60.64,62.3a11.29,11.29,0,0,0,6.09-6.72l6.35-17.72L60.54,25.31l-17.82,6.4c-2.36.86-5.57,3.41-6.6,6L24.48,65.5l8.42,8.42ZM40.79,39.63a7.89,7.89,0,0,1,3.65-3.17l14.79-5.31,8,8L61.94,54l-.06.19a6.44,6.44,0,0,1-3,3.43L34.07,68l-3.62-3.63Zm16.57,7.81a6.9,6.9,0,1,0-6.89,6.9A6.9,6.9,0,0,0,57.36,47.44Zm-4,0a2.86,2.86,0,1,1-2.85-2.85A2.86,2.86,0,0,1,53.32,47.44Zm-4.13,5.22L46.33,49.8,30.08,66.05l2.86,2.86ZM83.65,29,70,15.34,61.4,23.9,75.09,37.59ZM70,21.06l8,8-2.84,2.85-8-8ZM87,80.49H10.67V87H87Z", transform: "matrix(1 0 0 1 -15 -15)" }, drawrect: { width: 80, height: 80, path: "M78,22V79H21V22H78m9-9H12V88H87V13ZM68,46.22H31V54H68ZM53,32H45.22V69H53Z", transform: "matrix(1 0 0 1 -10 -10)" }, drawcircle: { width: 80, height: 80, path: "M50,84.72C26.84,84.72,8,69.28,8,50.3S26.84,15.87,50,15.87,92,31.31,92,50.3,73.16,84.72,50,84.72Zm0-60.59c-18.6,0-33.74,11.74-33.74,26.17S31.4,76.46,50,76.46,83.74,64.72,83.74,50.3,68.6,24.13,50,24.13Zm17.15,22h-34v7.11h34Zm-13.8-13H46.24v34h7.11Z", transform: "matrix(1 0 0 1 -10 -10)" }, eraseshape: { width: 80, height: 80, path: "M82.77,78H31.85L6,49.57,31.85,21.14H82.77a8.72,8.72,0,0,1,8.65,8.77V69.24A8.72,8.72,0,0,1,82.77,78ZM35.46,69.84H82.77a.57.57,0,0,0,.49-.6V29.91a.57.57,0,0,0-.49-.61H35.46L17,49.57Zm32.68-34.7-24,24,5,5,24-24Zm-19,.53-5,5,24,24,5-5Z", transform: "matrix(1 0 0 1 -10 -10)" }, spikeline: { width: 1e3, height: 1e3, path: "M512 409c0-57-46-104-103-104-57 0-104 47-104 104 0 57 47 103 104 103 57 0 103-46 103-103z m-327-39l92 0 0 92-92 0z m-185 0l92 0 0 92-92 0z m370-186l92 0 0 93-92 0z m0-184l92 0 0 92-92 0z", transform: "matrix(1.5 0 0 -1.5 0 850)" }, pencil: { width: 1792, height: 1792, path: "M491 1536l91-91-235-235-91 91v107h128v128h107zm523-928q0-22-22-22-10 0-17 7l-542 542q-7 7-7 17 0 22 22 22 10 0 17-7l542-542q7-7 7-17zm-54-192l416 416-832 832h-416v-416zm683 96q0 53-37 90l-166 166-416-416 166-165q36-38 90-38 53 0 91 38l235 234q37 39 37 91z", transform: "matrix(1 0 0 1 0 1)" }, newplotlylogo: { name: "newplotlylogo", svg: ["<svg xmlns='http://www.w3.org/2000/svg' viewBox='0 0 132 132'>", " <title>plotly-logomark</title>", " <g id='symbol'>", "  <rect fill='#000' x='0' y='0' width='132' height='132' rx='18' ry='18'/>", "  <circle fill='#9EF' cx='102' cy='30' r='6'/>", "  <circle fill='#BAC' cx='78' cy='30' r='6'/>", "  <circle fill='#BAC' cx='78' cy='54' r='6'/>", "  <circle fill='#D69' cx='54' cy='30' r='6'/>", "  <circle fill='#F26' cx='30' cy='30' r='6'/>", "  <circle fill='#F26' cx='30' cy='54' r='6'/>", "  <path fill='#FFF' d='M30,72a6,6,0,0,0-6,6v24a6,6,0,0,0,12,0V78A6,6,0,0,0,30,72Z'/>", "  <path fill='#FFF' d='M78,72a6,6,0,0,0-6,6v24a6,6,0,0,0,12,0V78A6,6,0,0,0,78,72Z'/>", "  <path fill='#FFF' d='M54,48a6,6,0,0,0-6,6v48a6,6,0,0,0,12,0V54A6,6,0,0,0,54,48Z'/>", "  <path fill='#FFF' d='M102,48a6,6,0,0,0-6,6v48a6,6,0,0,0,12,0V54A6,6,0,0,0,102,48Z'/>", " </g>", "</svg>"].join("") } };
+      });
+      var eP = ye((qar, pue) => {
+        var QL = 32;
+        pue.exports = { CIRCLE_SIDES: QL, i000: 0, i090: QL / 4, i180: QL / 2, i270: QL / 4 * 3, cos45: Math.cos(Math.PI / 4), sin45: Math.sin(Math.PI / 4), SQRT2: Math.sqrt(2) };
+      });
+      var tP = ye((Bar, mue) => {
+        var ect = Dr().strTranslate;
+        function gue(e, t) {
+          switch (e.type) {
+            case "log":
+              return e.p2d(t);
+            case "date":
+              return e.p2r(t, 0, e.calendar);
+            default:
+              return e.p2r(t);
+          }
+        }
+        function tct(e, t) {
+          switch (e.type) {
+            case "log":
+              return e.d2p(t);
+            case "date":
+              return e.r2p(t, 0, e.calendar);
+            default:
+              return e.r2p(t);
+          }
+        }
+        function rct(e) {
+          var t = e._id.charAt(0) === "y" ? 1 : 0;
+          return function(r) {
+            return gue(e, r[t]);
+          };
+        }
+        function ict(e) {
+          return ect(e.xaxis._offset, e.yaxis._offset);
+        }
+        mue.exports = { p2r: gue, r2p: tct, axValue: rct, getTransform: ict };
+      });
+      var m_ = ye((Ry) => {
+        var nct = nM(), xue = eP(), eT = xue.CIRCLE_SIDES, JB = xue.SQRT2, bue = tP(), yue = bue.p2r, _ue = bue.r2p, act = [0, 3, 4, 5, 6, 1, 2], oct = [0, 3, 4, 1, 2];
+        Ry.writePaths = function(e) {
+          var t = e.length;
+          if (!t) return "M0,0Z";
+          for (var r = "", n = 0; n < t; n++) for (var i = e[n].length, a = 0; a < i; a++) {
+            var o = e[n][a][0];
+            if (o === "Z") r += "Z";
+            else for (var s = e[n][a].length, l = 0; l < s; l++) {
+              var u = l;
+              o === "Q" || o === "S" ? u = oct[l] : o === "C" && (u = act[l]), r += e[n][a][u], l > 0 && l < s - 1 && (r += ",");
+            }
+          }
+          return r;
+        };
+        Ry.readPaths = function(e, t, r, n) {
+          var i = nct(e), a = [], o = -1, s = function() {
+            o++, a[o] = [];
+          }, l, u = 0, c = 0, f, h, d = function() {
+            f = u, h = c;
+          };
+          d();
+          for (var v = 0; v < i.length; v++) {
+            var _ = [], b, p, k, E, T = i[v][0], L = T;
+            switch (T) {
+              case "M":
+                s(), u = +i[v][1], c = +i[v][2], _.push([L, u, c]), d();
+                break;
+              case "Q":
+              case "S":
+                b = +i[v][1], k = +i[v][2], u = +i[v][3], c = +i[v][4], _.push([L, u, c, b, k]);
+                break;
+              case "C":
+                b = +i[v][1], k = +i[v][2], p = +i[v][3], E = +i[v][4], u = +i[v][5], c = +i[v][6], _.push([L, u, c, b, k, p, E]);
+                break;
+              case "T":
+              case "L":
+                u = +i[v][1], c = +i[v][2], _.push([L, u, c]);
+                break;
+              case "H":
+                L = "L", u = +i[v][1], _.push([L, u, c]);
+                break;
+              case "V":
+                L = "L", c = +i[v][1], _.push([L, u, c]);
+                break;
+              case "A":
+                L = "L";
+                var x = +i[v][1], C = +i[v][2];
+                +i[v][4] || (x = -x, C = -C);
+                var M = u - x, g = c;
+                for (l = 1; l <= eT / 2; l++) {
+                  var P = 2 * Math.PI * l / eT;
+                  _.push([L, M + x * Math.cos(P), g + C * Math.sin(P)]);
+                }
+                break;
+              case "Z":
+                (u !== f || c !== h) && (u = f, c = h, _.push([L, u, c]));
+                break;
+            }
+            for (var A = (r || {}).domain, z = t._fullLayout._size, O = r && r.xsizemode === "pixel", U = r && r.ysizemode === "pixel", G = n === false, Z = 0; Z < _.length; Z++) {
+              for (l = 0; l + 2 < 7; l += 2) {
+                var j = _[Z][l + 1], N = _[Z][l + 2];
+                j === void 0 || N === void 0 || (u = j, c = N, r && (r.xaxis && r.xaxis.p2r ? (G && (j -= r.xaxis._offset), O ? j = _ue(r.xaxis, r.xanchor) + j : j = yue(r.xaxis, j)) : (G && (j -= z.l), A ? j = A.x[0] + j / z.w : j = j / z.w), r.yaxis && r.yaxis.p2r ? (G && (N -= r.yaxis._offset), U ? N = _ue(r.yaxis, r.yanchor) - N : N = yue(r.yaxis, N)) : (G && (N -= z.t), A ? N = A.y[1] - N / z.h : N = 1 - N / z.h)), _[Z][l + 1] = j, _[Z][l + 2] = N);
+              }
+              a[o].push(_[Z].slice());
+            }
+          }
+          return a;
+        };
+        function wM(e, t) {
+          return Math.abs(e - t) <= 1e-6;
+        }
+        function rP(e, t) {
+          var r = t[1] - e[1], n = t[2] - e[2];
+          return Math.sqrt(r * r + n * n);
+        }
+        Ry.pointsOnRectangle = function(e) {
+          var t = e.length;
+          if (t !== 5) return false;
+          for (var r = 1; r < 3; r++) {
+            var n = e[0][r] - e[1][r], i = e[3][r] - e[2][r];
+            if (!wM(n, i)) return false;
+            var a = e[0][r] - e[3][r], o = e[1][r] - e[2][r];
+            if (!wM(a, o)) return false;
+          }
+          return !wM(e[0][1], e[1][1]) && !wM(e[0][1], e[3][1]) ? false : !!(rP(e[0], e[1]) * rP(e[0], e[3]));
+        };
+        Ry.pointsOnEllipse = function(e) {
+          var t = e.length;
+          if (t !== eT + 1) return false;
+          t = eT;
+          for (var r = 0; r < t; r++) {
+            var n = (t * 2 - r) % t, i = (t / 2 + n) % t, a = (t / 2 + r) % t;
+            if (!wM(rP(e[r], e[a]), rP(e[n], e[i]))) return false;
+          }
+          return true;
+        };
+        Ry.handleEllipse = function(e, t, r) {
+          if (!e) return [t, r];
+          var n = Ry.ellipseOver({ x0: t[0], y0: t[1], x1: r[0], y1: r[1] }), i = (n.x1 + n.x0) / 2, a = (n.y1 + n.y0) / 2, o = (n.x1 - n.x0) / 2, s = (n.y1 - n.y0) / 2;
+          o || (o = s = s / JB), s || (s = o = o / JB);
+          for (var l = [], u = 0; u < eT; u++) {
+            var c = u * 2 * Math.PI / eT;
+            l.push([i + o * Math.cos(c), a + s * Math.sin(c)]);
+          }
+          return l;
+        };
+        Ry.ellipseOver = function(e) {
+          var t = e.x0, r = e.y0, n = e.x1, i = e.y1, a = n - t, o = i - r;
+          t -= a, r -= o;
+          var s = (t + n) / 2, l = (r + i) / 2, u = JB;
+          return a *= u, o *= u, { x0: s - a, y0: l - o, x1: s + a, y1: l + o };
+        };
+        Ry.fixDatesForPaths = function(e, t, r) {
+          var n = t.type === "date", i = r.type === "date";
+          if (!n && !i) return e;
+          for (var a = 0; a < e.length; a++) for (var o = 0; o < e[a].length; o++) for (var s = 0; s + 2 < e[a][o].length; s += 2) n && (e[a][o][s + 1] = e[a][o][s + 1].replace(" ", "_")), i && (e[a][o][s + 2] = e[a][o][s + 2].replace(" ", "_"));
+          return e;
+        };
+      });
+      var aP = ye((Uar, Lue) => {
+        var wue = hf(), Eue = Cg(), sct = Eue.drawMode, lct = Eue.openMode, tT = eP(), Tue = tT.i000, Aue = tT.i090, Sue = tT.i180, Mue = tT.i270, uct = tT.cos45, cct = tT.sin45, kue = tP(), iP = kue.p2r, y_ = kue.r2p, fct = o_(), hct = fct.clearOutline, nP = m_(), dct = nP.readPaths, vct = nP.writePaths, pct = nP.ellipseOver, gct = nP.fixDatesForPaths;
+        function mct(e, t) {
+          if (e.length) {
+            var r = e[0][0];
+            if (r) {
+              var n = t.gd, i = t.isActiveShape, a = t.dragmode, o = (n.layout || {}).shapes || [];
+              if (!sct(a) && i !== void 0) {
+                var s = n._fullLayout._activeShapeIndex;
+                if (s < o.length) switch (n._fullLayout.shapes[s].type) {
+                  case "rect":
+                    a = "drawrect";
+                    break;
+                  case "circle":
+                    a = "drawcircle";
+                    break;
+                  case "line":
+                    a = "drawline";
+                    break;
+                  case "path":
+                    var l = o[s].path || "";
+                    l[l.length - 1] === "Z" ? a = "drawclosedpath" : a = "drawopenpath";
+                    break;
+                }
+              }
+              var u = Cue(e, t, a);
+              hct(n);
+              for (var c = t.editHelpers, f = (c || {}).modifyItem, h = [], d = 0; d < o.length; d++) {
+                var v = n._fullLayout.shapes[d];
+                if (h[d] = v._input, i !== void 0 && d === n._fullLayout._activeShapeIndex) {
+                  var _ = u;
+                  switch (v.type) {
+                    case "line":
+                    case "rect":
+                    case "circle":
+                      var b = wue.getFromId(n, v.xref);
+                      v.xref.charAt(0) === "x" && b.type.includes("category") ? (f("x0", _.x0 - (v.x0shift || 0)), f("x1", _.x1 - (v.x1shift || 0))) : (f("x0", _.x0), f("x1", _.x1));
+                      var p = wue.getFromId(n, v.yref);
+                      v.yref.charAt(0) === "y" && p.type.includes("category") ? (f("y0", _.y0 - (v.y0shift || 0)), f("y1", _.y1 - (v.y1shift || 0))) : (f("y0", _.y0), f("y1", _.y1));
+                      break;
+                    case "path":
+                      f("path", _.path);
+                      break;
+                  }
+                }
+              }
+              return i === void 0 ? (h.push(u), h) : c ? c.getUpdateObj() : {};
+            }
+          }
+        }
+        function Cue(e, t, r) {
+          var n = e[0][0], i = t.gd, a = n.getAttribute("d"), o = i._fullLayout.newshape, s = t.plotinfo, l = t.isActiveShape, u = s.xaxis, c = s.yaxis, f = !!s.domain || !s.xaxis, h = !!s.domain || !s.yaxis, d = lct(r), v = dct(a, i, s, l), _ = { editable: true, visible: o.visible, name: o.name, showlegend: o.showlegend, legend: o.legend, legendwidth: o.legendwidth, legendgroup: o.legendgroup, legendgrouptitle: { text: o.legendgrouptitle.text, font: o.legendgrouptitle.font }, legendrank: o.legendrank, label: o.label, xref: f ? "paper" : u._id, yref: h ? "paper" : c._id, layer: o.layer, opacity: o.opacity, line: { color: o.line.color, width: o.line.width, dash: o.line.dash } };
+          d || (_.fillcolor = o.fillcolor, _.fillrule = o.fillrule);
+          var b;
+          if (v.length === 1 && (b = v[0]), b && b.length === 5 && r === "drawrect") _.type = "rect", _.x0 = b[0][1], _.y0 = b[0][2], _.x1 = b[2][1], _.y1 = b[2][2];
+          else if (b && r === "drawline") _.type = "line", _.x0 = b[0][1], _.y0 = b[0][2], _.x1 = b[1][1], _.y1 = b[1][2];
+          else if (b && r === "drawcircle") {
+            _.type = "circle";
+            var p = b[Tue][1], k = b[Aue][1], E = b[Sue][1], T = b[Mue][1], L = b[Tue][2], x = b[Aue][2], C = b[Sue][2], M = b[Mue][2], g = s.xaxis && (s.xaxis.type === "date" || s.xaxis.type === "log"), P = s.yaxis && (s.yaxis.type === "date" || s.yaxis.type === "log");
+            g && (p = y_(s.xaxis, p), k = y_(s.xaxis, k), E = y_(s.xaxis, E), T = y_(s.xaxis, T)), P && (L = y_(s.yaxis, L), x = y_(s.yaxis, x), C = y_(s.yaxis, C), M = y_(s.yaxis, M));
+            var A = (k + T) / 2, z = (L + C) / 2, O = (T - k + E - p) / 2, U = (M - x + C - L) / 2, G = pct({ x0: A, y0: z, x1: A + O * uct, y1: z + U * cct });
+            g && (G.x0 = iP(s.xaxis, G.x0), G.x1 = iP(s.xaxis, G.x1)), P && (G.y0 = iP(s.yaxis, G.y0), G.y1 = iP(s.yaxis, G.y1)), _.x0 = G.x0, _.y0 = G.y0, _.x1 = G.x1, _.y1 = G.y1;
+          } else _.type = "path", u && c && gct(v, u, c), _.path = vct(v), b = null;
+          return _;
+        }
+        Lue.exports = { newShapes: mct, createShapeObj: Cue };
+      });
+      var QB = ye((Var, Pue) => {
+        var yct = Cg(), _ct = yct.selectMode, xct = o_(), bct = xct.clearOutline, $B = m_(), wct = $B.readPaths, Tct = $B.writePaths, Act = $B.fixDatesForPaths;
+        Pue.exports = function(t, r) {
+          if (t.length) {
+            var n = t[0][0];
+            if (n) {
+              var i = n.getAttribute("d"), a = r.gd, o = a._fullLayout.newselection, s = r.plotinfo, l = s.xaxis, u = s.yaxis, c = r.isActiveSelection, f = r.dragmode, h = (a.layout || {}).selections || [];
+              if (!_ct(f) && c !== void 0) {
+                var d = a._fullLayout._activeSelectionIndex;
+                if (d < h.length) switch (a._fullLayout.selections[d].type) {
+                  case "rect":
+                    f = "select";
+                    break;
+                  case "path":
+                    f = "lasso";
+                    break;
+                }
+              }
+              var v = wct(i, a, s, c), _ = { xref: l._id, yref: u._id, opacity: o.opacity, line: { color: o.line.color, width: o.line.width, dash: o.line.dash } }, b;
+              v.length === 1 && (b = v[0]), b && b.length === 5 && f === "select" ? (_.type = "rect", _.x0 = b[0][1], _.y0 = b[0][2], _.x1 = b[2][1], _.y1 = b[2][2]) : (_.type = "path", l && u && Act(v, l, u), _.path = Tct(v), b = null), bct(a);
+              for (var p = r.editHelpers, k = (p || {}).modifyItem, E = [], T = 0; T < h.length; T++) {
+                var L = a._fullLayout.selections[T];
+                if (!L) {
+                  E[T] = L;
+                  continue;
+                }
+                if (E[T] = L._input, c !== void 0 && T === a._fullLayout._activeSelectionIndex) {
+                  var x = _;
+                  switch (L.type) {
+                    case "rect":
+                      k("x0", x.x0), k("x1", x.x1), k("y0", x.y0), k("y1", x.y1);
+                      break;
+                    case "path":
+                      k("path", x.path);
+                      break;
+                  }
+                }
+              }
+              return c === void 0 ? (E.push(_), E) : p ? p.getUpdateObj() : {};
+            }
+          }
+        };
+      });
+      var TM = ye((Gar, Iue) => {
+        Iue.exports = { segmentRE: /[MLHVQCTSZ][^MLHVQCTSZ]*/g, paramRE: /[^\s,]+/g, paramIsX: { M: { 0: true, drawn: 0 }, L: { 0: true, drawn: 0 }, H: { 0: true, drawn: 0 }, V: {}, Q: { 0: true, 2: true, drawn: 2 }, C: { 0: true, 2: true, 4: true, drawn: 4 }, T: { 0: true, drawn: 0 }, S: { 0: true, 2: true, drawn: 2 }, Z: {} }, paramIsY: { M: { 1: true, drawn: 1 }, L: { 1: true, drawn: 1 }, H: {}, V: { 0: true, drawn: 0 }, Q: { 1: true, 3: true, drawn: 3 }, C: { 1: true, 3: true, 5: true, drawn: 5 }, T: { 1: true, drawn: 1 }, S: { 1: true, 3: true, drawn: 3 }, Z: {} }, numParams: { M: 2, L: 2, H: 1, V: 1, Q: 4, C: 6, T: 2, S: 4, Z: 0 } };
+      });
+      var x_ = ye((Jd) => {
+        var Mm = TM(), Rue = Dr(), __ = ho();
+        Jd.rangeToShapePosition = function(e) {
+          return e.type === "log" ? e.r2d : function(t) {
+            return t;
+          };
+        };
+        Jd.shapePositionToRange = function(e) {
+          return e.type === "log" ? e.d2r : function(t) {
+            return t;
+          };
+        };
+        Jd.decodeDate = function(e) {
+          return function(t) {
+            return t.replace && (t = t.replace("_", " ")), e(t);
+          };
+        };
+        Jd.encodeDate = function(e) {
+          return function(t) {
+            return e(t).replace(" ", "_");
+          };
+        };
+        Jd.extractPathCoords = function(e, t, r) {
+          var n = [], i = e.match(Mm.segmentRE);
+          return i.forEach(function(a) {
+            var o = t[a.charAt(0)].drawn;
+            if (o !== void 0) {
+              var s = a.slice(1).match(Mm.paramRE);
+              if (!(!s || s.length < o)) {
+                var l = s[o], u = r ? l : Rue.cleanNumber(l);
+                n.push(u);
+              }
+            }
+          }), n;
+        };
+        Jd.countDefiningCoords = function(e, t, r) {
+          if (e !== "path") return 2;
+          if (!t) return 0;
+          let n = t.match(Mm.segmentRE);
+          if (!n) return 0;
+          let i = r === "x" ? Mm.paramIsX : Mm.paramIsY;
+          return n.reduce((a, o) => {
+            let s = o.charAt(0), l = i[s].drawn !== void 0;
+            return a + (l ? 1 : 0);
+          }, 0);
+        };
+        Jd.getDataToPixel = function(e, t, r, n, i) {
+          var a = e._fullLayout._size, o;
+          if (t) if (i === "domain") o = function(l) {
+            return t._length * (n ? 1 - l : l) + t._offset;
+          };
+          else {
+            var s = Jd.shapePositionToRange(t);
+            o = function(l) {
+              var u = Dy(t, r);
+              return t._offset + t.r2p(s(l, true)) + u;
+            }, t.type === "date" && (o = Jd.decodeDate(o));
+          }
+          else n ? o = function(l) {
+            return a.t + a.h * (1 - l);
+          } : o = function(l) {
+            return a.l + a.w * l;
+          };
+          return o;
+        };
+        Jd.getPixelToData = function(e, t, r, n) {
+          var i = e._fullLayout._size, a;
+          if (t) if (n === "domain") a = function(s) {
+            var l = (s - t._offset) / t._length;
+            return r ? 1 - l : l;
+          };
+          else {
+            var o = Jd.rangeToShapePosition(t);
+            a = function(s) {
+              return o(t.p2r(s - t._offset));
+            };
+          }
+          else r ? a = function(s) {
+            return 1 - (s - i.t) / i.h;
+          } : a = function(s) {
+            return (s - i.l) / i.w;
+          };
+          return a;
+        };
+        Jd.roundPositionForSharpStrokeRendering = function(e, t) {
+          var r = Math.round(t % 2) === 1, n = Math.round(e);
+          return r ? n + 0.5 : n;
+        };
+        Jd.makeShapesOptionsAndPlotinfo = function(e, t) {
+          var r = e._fullLayout.shapes[t] || {}, n = e._fullLayout._plots[r.xref + r.yref], i = !!n;
+          return i ? n._hadPlotinfo = true : (n = {}, r.xref && r.xref !== "paper" && (n.xaxis = e._fullLayout[r.xref + "axis"]), r.yref && r.yref !== "paper" && (n.yaxis = e._fullLayout[r.yref + "axis"])), n.xsizemode = r.xsizemode, n.ysizemode = r.ysizemode, n.xanchor = r.xanchor, n.yanchor = r.yanchor, { options: r, plotinfo: n };
+        };
+        Jd.makeSelectionsOptionsAndPlotinfo = function(e, t) {
+          var r = e._fullLayout.selections[t] || {}, n = e._fullLayout._plots[r.xref + r.yref], i = !!n;
+          return i ? n._hadPlotinfo = true : (n = {}, r.xref && (n.xaxis = e._fullLayout[r.xref + "axis"]), r.yref && (n.yaxis = e._fullLayout[r.yref + "axis"])), { options: r, plotinfo: n };
+        };
+        Jd.getPathString = function(e, t) {
+          let r = t.type, n = __.getRefType(t.xref), i = __.getRefType(t.yref), a = e._fullLayout._size;
+          var o, s, l, u, c, f, h, d, v, _, b, p;
+          function k(P, A, z, O) {
+            var U;
+            if (P) if (A === "domain") O ? U = function(G) {
+              return P._offset + P._length * (1 - G);
+            } : U = function(G) {
+              return P._offset + P._length * G;
+            };
+            else {
+              let G = Jd.shapePositionToRange(P);
+              U = function(Z) {
+                return P._offset + P.r2p(G(Z, true));
+              }, z === "path" && P.type === "date" && (U = Jd.decodeDate(U));
+            }
+            else O ? U = function(G) {
+              return a.t + a.h * (1 - G);
+            } : U = function(G) {
+              return a.l + a.w * G;
+            };
+            return U;
+          }
+          if (n === "array" ? (h = [], o = t.xref.map(function(P) {
+            return __.getFromId(e, P);
+          }), h = t.xref.map(function(P, A) {
+            return k(o[A], __.getRefType(P), r, false);
+          })) : (o = __.getFromId(e, t.xref), h = k(o, n, r, false)), i === "array" ? (d = [], s = t.yref.map(function(P) {
+            return __.getFromId(e, P);
+          }), d = t.yref.map(function(P, A) {
+            return k(s[A], __.getRefType(P), r, true);
+          })) : (s = __.getFromId(e, t.yref), d = k(s, i, r, true)), r === "path") return Sct(t, h, d);
+          if (n === "array") l = Dy(o[0], t.x0shift), u = Dy(o[1], t.x1shift), v = h[0](t.x0) + l, _ = h[1](t.x1) + u;
+          else if (l = Dy(o, t.x0shift), u = Dy(o, t.x1shift), t.xsizemode === "pixel") {
+            let P = h(t.xanchor);
+            v = P + t.x0 + l, _ = P + t.x1 + u;
+          } else v = h(t.x0) + l, _ = h(t.x1) + u;
+          if (i === "array") c = Dy(s[0], t.y0shift), f = Dy(s[1], t.y1shift), b = d[0](t.y0) + c, p = d[1](t.y1) + f;
+          else if (c = Dy(s, t.y0shift), f = Dy(s, t.y1shift), t.ysizemode === "pixel") {
+            let P = d(t.yanchor);
+            b = P - t.y0 + c, p = P - t.y1 + f;
+          } else b = d(t.y0) + c, p = d(t.y1) + f;
+          if (r === "line") return "M" + v + "," + b + "L" + _ + "," + p;
+          if (r === "rect") return "M" + v + "," + b + "H" + _ + "V" + p + "H" + v + "Z";
+          var E = (v + _) / 2, T = (b + p) / 2, L = Math.abs(E - v), x = Math.abs(T - b), C = "A" + L + "," + x, M = E + L + "," + T, g = E + "," + (T - x);
+          return "M" + M + C + " 0 1,1 " + g + C + " 0 0,1 " + M + "Z";
+        };
+        function Sct(e, t, r) {
+          let n = e.path, i = e.xsizemode, a = e.ysizemode, o = e.xanchor, s = e.yanchor, l = Array.isArray(e.xref), u = Array.isArray(e.yref);
+          var c = 0, f = 0;
+          return n.replace(Mm.segmentRE, function(h) {
+            var d = 0, v = h.charAt(0), _ = Mm.paramIsX[v], b = Mm.paramIsY[v], p = Mm.numParams[v];
+            let k = _.drawn !== void 0, E = b.drawn !== void 0, T = l ? t[c] : t, L = u ? r[f] : r;
+            var x = h.slice(1).replace(Mm.paramRE, function(C) {
+              return _[d] ? i === "pixel" ? C = T(o) + Number(C) : C = T(C) : b[d] && (a === "pixel" ? C = L(s) - Number(C) : C = L(C)), d++, d > p && (C = "X"), C;
+            });
+            return d > p && (x = x.replace(/[\s,]*X.*/, ""), Rue.log("Ignoring extra params in segment " + h)), k && c++, E && f++, v + x;
+          });
+        }
+        function Dy(e, t) {
+          t = t || 0;
+          var r = 0;
+          return t && e && (e.type === "category" || e.type === "multicategory") && (r = (e.r2p(1) - e.r2p(0)) * t), r;
+        }
+      });
+      var tN = ye((jar, zue) => {
+        var Mct = Dr(), Em = ho(), Due = Zl(), Fue = So(), Ect = m_().readPaths, eN = x_(), kct = eN.getPathString, AM = D6(), Cct = Dh().FROM_TL;
+        zue.exports = function(t, r, n, i) {
+          if (i.selectAll(".shape-label").remove(), !!(n.label.text || n.label.texttemplate)) {
+            var a;
+            if (n.label.texttemplate) {
+              var o = {};
+              if (n.type !== "path") {
+                var s = Em.getFromId(t, n.xref), l = Em.getFromId(t, n.yref);
+                let oe = Array.isArray(n.xref), _e = Array.isArray(n.yref);
+                for (var u in AM) {
+                  var c = typeof AM[u] == "function", f = !oe || AM.simpleXVariables.includes(u), h = !_e || AM.simpleYVariables.includes(u);
+                  if (c && f && h) {
+                    var d = AM[u](n, s, l);
+                    d !== void 0 && (o[u] = d);
+                  }
+                }
+              }
+              a = Mct.texttemplateStringForShapes({ data: [o], fallback: n.label.texttemplatefallback, locale: t._fullLayout._d3locale, template: n.label.texttemplate });
+            } else a = n.label.text;
+            var v = { "data-index": r }, _ = n.label.font, b = { "data-notex": 1 }, p = i.append("g").attr(v).classed("shape-label", true), k = p.append("text").attr(b).classed("shape-label-text", true).text(a), E, T, L, x;
+            if (n.path) {
+              var C = kct(t, n), M = Ect(C, t);
+              E = 1 / 0, L = 1 / 0, T = -1 / 0, x = -1 / 0;
+              for (var g = 0; g < M.length; g++) for (var P = 0; P < M[g].length; P++) for (var A = M[g][P], z = 1; z < A.length; z += 2) {
+                var O = A[z], U = A[z + 1];
+                E = Math.min(E, O), T = Math.max(T, O), L = Math.min(L, U), x = Math.max(x, U);
+              }
+            } else {
+              let oe = Array.isArray(n.xref), _e = Array.isArray(n.yref), Ce = Em.getFromId(t, oe ? n.xref[0] : n.xref), Le = Em.getFromId(t, oe ? n.xref[1] : n.xref), ge = Em.getFromId(t, _e ? n.yref[0] : n.yref), ie = Em.getFromId(t, _e ? n.yref[1] : n.yref), Se = Em.getRefType(oe ? n.xref[0] : n.xref), Ee = Em.getRefType(oe ? n.xref[1] : n.xref), Ae = Em.getRefType(_e ? n.yref[0] : n.yref), Be = Em.getRefType(_e ? n.yref[1] : n.yref), Pe = function(De, ce, je, lt) {
+                return eN.getDataToPixel(t, je, ce, false, lt)(De);
+              }, me = function(De, ce, je, lt) {
+                return eN.getDataToPixel(t, je, ce, true, lt)(De);
+              };
+              E = Pe(n.x0, n.x0shift, Ce, Se), T = Pe(n.x1, n.x1shift, Le, Ee), L = me(n.y0, n.y0shift, ge, Ae), x = me(n.y1, n.y1shift, ie, Be);
+            }
+            var G = n.label.textangle;
+            G === "auto" && (n.type === "line" ? G = Lct(E, L, T, x) : G = 0), k.call(function(oe) {
+              return oe.call(Fue.font, _).attr({}), Due.convertToTspans(oe, t), oe;
+            });
+            var Z = Fue.bBox(k.node()), j = Pct(E, L, T, x, n, G, Z), N = j.textx, H = j.texty, re = j.xanchor;
+            k.attr({ "text-anchor": { left: "start", center: "middle", right: "end" }[re], y: H, x: N, transform: "rotate(" + G + "," + N + "," + H + ")" }).call(Due.positionText, N, H);
+          }
+        };
+        function Lct(e, t, r, n) {
+          var i, a;
+          return a = Math.abs(r - e), r >= e ? i = t - n : i = n - t, -180 / Math.PI * Math.atan2(i, a);
+        }
+        function Pct(e, t, r, n, i, a, o) {
+          var s = i.label.textposition, l = i.label.textangle, u = i.label.padding, c = i.type, f = Math.PI / 180 * a, h = Math.sin(f), d = Math.cos(f), v = i.label.xanchor, _ = i.label.yanchor, b, p, k, E;
+          if (c === "line") {
+            s === "start" ? (b = e, p = t) : s === "end" ? (b = r, p = n) : (b = (e + r) / 2, p = (t + n) / 2), v === "auto" && (s === "start" ? l === "auto" ? r > e ? v = "left" : r < e ? v = "right" : v = "center" : r > e ? v = "right" : r < e ? v = "left" : v = "center" : s === "end" ? l === "auto" ? r > e ? v = "right" : r < e ? v = "left" : v = "center" : r > e ? v = "left" : r < e ? v = "right" : v = "center" : v = "center");
+            var T = { left: 1, center: 0, right: -1 }, L = { bottom: -1, middle: 0, top: 1 };
+            if (l === "auto") {
+              var x = L[_];
+              k = -u * h * x, E = u * d * x;
+            } else {
+              var C = T[v], M = L[_];
+              k = u * C, E = u * M;
+            }
+            b = b + k, p = p + E;
+          } else k = u + 3, s.indexOf("right") !== -1 ? (b = Math.max(e, r) - k, v === "auto" && (v = "right")) : s.indexOf("left") !== -1 ? (b = Math.min(e, r) + k, v === "auto" && (v = "left")) : (b = (e + r) / 2, v === "auto" && (v = "center")), s.indexOf("top") !== -1 ? p = Math.min(t, n) : s.indexOf("bottom") !== -1 ? p = Math.max(t, n) : p = (t + n) / 2, E = u, _ === "bottom" ? p = p - E : _ === "top" && (p = p + E);
+          var g = Cct[_], P = i.label.font.size, A = o.height, z = (A * g - P) * h, O = -(A * g - P) * d;
+          return { textx: b + z, texty: p + O, xanchor: v };
+        }
+      });
+      var lP = ye((War, Hue) => {
+        var Ict = Dr(), Rct = Ict.strTranslate, Oue = yv(), Nue = Cg(), Dct = Nue.drawMode, Uue = Nue.selectMode, Vue = qa(), que = ka(), sP = eP(), Fct = sP.i000, zct = sP.i090, Oct = sP.i180, qct = sP.i270, Bct = o_(), Gue = Bct.clearOutlineControllers, iN = m_(), oP = iN.pointsOnRectangle, rN = iN.pointsOnEllipse, Nct = iN.writePaths, Uct = aP().newShapes, Vct = aP().createShapeObj, Gct = QB(), Hct = tN();
+        Hue.exports = function e(t, r, n, i) {
+          i || (i = 0);
+          var a = n.gd;
+          function o() {
+            e(t, r, n, i++), (rN(t[0]) || n.hasText) && s({ redrawing: true });
+          }
+          function s(j) {
+            var N = {};
+            n.isActiveShape !== void 0 && (n.isActiveShape = false, N = Uct(r, n)), n.isActiveSelection !== void 0 && (n.isActiveSelection = false, N = Gct(r, n), a._fullLayout._reselect = true), Object.keys(N).length && Vue.call((j || {}).redrawing ? "relayout" : "_guiRelayout", a, N);
+          }
+          var l = a._fullLayout, u = l._zoomlayer, c = n.dragmode, f = Dct(c), h = Uue(c);
+          (f || h) && (a._fullLayout._outlining = true), Gue(a), r.attr("d", Nct(t));
+          var d, v, _, b, p;
+          if (!i && (n.isActiveShape || n.isActiveSelection)) {
+            p = jct([], t);
+            var k = u.append("g").attr("class", "outline-controllers");
+            P(k), Z();
+          }
+          if (f && n.hasText) {
+            var E = u.select(".label-temp"), T = Vct(r, n, n.dragmode);
+            Hct(a, "label-temp", T, E);
+          }
+          function L(j) {
+            _ = +j.srcElement.getAttribute("data-i"), b = +j.srcElement.getAttribute("data-j"), d[_][b].moveFn = x;
+          }
+          function x(j, N) {
+            if (t.length) {
+              var H = p[_][b][1], re = p[_][b][2], oe = t[_], _e = oe.length;
+              if (oP(oe)) {
+                var Ce = j, Le = N;
+                if (n.isActiveSelection) {
+                  var ge = Bue(oe, b);
+                  ge[1] === oe[b][1] ? Le = 0 : Ce = 0;
+                }
+                for (var ie = 0; ie < _e; ie++) if (ie !== b) {
+                  var Se = oe[ie];
+                  Se[1] === oe[b][1] && (Se[1] = H + Ce), Se[2] === oe[b][2] && (Se[2] = re + Le);
+                }
+                if (oe[b][1] = H + Ce, oe[b][2] = re + Le, !oP(oe)) for (var Ee = 0; Ee < _e; Ee++) for (var Ae = 0; Ae < oe[Ee].length; Ae++) oe[Ee][Ae] = p[_][Ee][Ae];
+              } else oe[b][1] = H + j, oe[b][2] = re + N;
+              o();
+            }
+          }
+          function C() {
+            s();
+          }
+          function M() {
+            if (t.length && t[_] && t[_].length) {
+              for (var j = [], N = 0; N < t[_].length; N++) N !== b && j.push(t[_][N]);
+              j.length > 1 && !(j.length === 2 && j[1][0] === "Z") && (b === 0 && (j[0][0] = "M"), t[_] = j, o(), s());
+            }
+          }
+          function g(j, N) {
+            if (j === 2) {
+              _ = +N.srcElement.getAttribute("data-i"), b = +N.srcElement.getAttribute("data-j");
+              var H = t[_];
+              !oP(H) && !rN(H) && M();
+            }
+          }
+          function P(j) {
+            d = [];
+            for (var N = 0; N < t.length; N++) {
+              var H = t[N], re = oP(H), oe = !re && rN(H);
+              d[N] = [];
+              for (var _e = H.length, Ce = 0; Ce < _e; Ce++) if (H[Ce][0] !== "Z" && !(oe && Ce !== Fct && Ce !== zct && Ce !== Oct && Ce !== qct)) {
+                var Le = re && n.isActiveSelection, ge;
+                Le && (ge = Bue(H, Ce));
+                var ie = H[Ce][1], Se = H[Ce][2], Ee = j.append(Le ? "rect" : "circle").attr("data-i", N).attr("data-j", Ce).style({ fill: que.background, stroke: que.defaultLine, "stroke-width": 1, "shape-rendering": "crispEdges" });
+                if (Le) {
+                  var Ae = ge[1] - ie, Be = ge[2] - Se, Pe = Be ? 5 : Math.max(Math.min(25, Math.abs(Ae) - 5), 5), me = Ae ? 5 : Math.max(Math.min(25, Math.abs(Be) - 5), 5);
+                  Ee.classed(Be ? "cursor-ew-resize" : "cursor-ns-resize", true).attr("width", Pe).attr("height", me).attr("x", ie - Pe / 2).attr("y", Se - me / 2).attr("transform", Rct(Ae / 2, Be / 2));
+                } else Ee.classed("cursor-grab", true).attr("r", 5).attr("cx", ie).attr("cy", Se);
+                d[N][Ce] = { element: Ee.node(), gd: a, prepFn: L, doneFn: C, clickFn: g }, Oue.init(d[N][Ce]);
+              }
+            }
+          }
+          function A(j, N) {
+            if (t.length) for (var H = 0; H < t.length; H++) for (var re = 0; re < t[H].length; re++) for (var oe = 0; oe + 2 < t[H][re].length; oe += 2) t[H][re][oe + 1] = p[H][re][oe + 1] + j, t[H][re][oe + 2] = p[H][re][oe + 2] + N;
+          }
+          function z(j, N) {
+            A(j, N), o();
+          }
+          function O(j) {
+            _ = +j.srcElement.getAttribute("data-i"), _ || (_ = 0), v[_].moveFn = z;
+          }
+          function U() {
+            s();
+          }
+          function G(j) {
+            j === 2 && Wct(a);
+          }
+          function Z() {
+            if (v = [], !!t.length) {
+              var j = 0;
+              v[j] = { element: r[0][0], gd: a, prepFn: O, doneFn: U, clickFn: G }, Oue.init(v[j]);
+            }
+          }
+        };
+        function jct(e, t) {
+          for (var r = 0; r < t.length; r++) {
+            var n = t[r];
+            e[r] = [];
+            for (var i = 0; i < n.length; i++) {
+              e[r][i] = [];
+              for (var a = 0; a < n[i].length; a++) e[r][i][a] = n[i][a];
+            }
+          }
+          return e;
+        }
+        function Bue(e, t) {
+          var r = e[t][1], n = e[t][2], i = e.length, a, o, s;
+          return a = (t + 1) % i, o = e[a][1], s = e[a][2], o === r && s === n && (a = (t + 2) % i, o = e[a][1], s = e[a][2]), [a, o, s];
+        }
+        function Wct(e) {
+          if (Uue(e._fullLayout.dragmode)) {
+            Gue(e);
+            var t = e._fullLayout._activeSelectionIndex, r = (e.layout || {}).selections || [];
+            if (t < r.length) {
+              for (var n = [], i = 0; i < r.length; i++) i !== t && n.push(r[i]);
+              delete e._fullLayout._activeSelectionIndex;
+              var a = e._fullLayout.selections[t];
+              e._fullLayout._deselect = { xref: a.xref, yref: a.yref }, Vue.call("_guiRelayout", e, { selections: n });
+            }
+          }
+        }
+      });
+      var dP = ye((Xar, Que) => {
+        var Xct = Oa(), Yue = qa(), aN = Dr(), Xb = ho(), Zct = m_().readPaths, Yct = lP(), cP = tN(), Kue = o_().clearOutlineControllers, nN = ka(), fP = So(), Kct = vl().arrayEditor, jue = yv(), Wue = Eg(), Zb = TM(), Ep = x_(), oN = Ep.getPathString;
+        Que.exports = { draw: sN, drawOne: Jue, eraseActiveShape: eft, drawLabel: cP };
+        function sN(e) {
+          var t = e._fullLayout;
+          t._shapeUpperLayer.selectAll("path").remove(), t._shapeLowerLayer.selectAll("path").remove(), t._shapeUpperLayer.selectAll("text").remove(), t._shapeLowerLayer.selectAll("text").remove();
+          for (var r in t._plots) {
+            var n = t._plots[r].shapelayer;
+            n && (n.selectAll("path").remove(), n.selectAll("text").remove());
+          }
+          for (var i = 0; i < t.shapes.length; i++) t.shapes[i].visible === true && Jue(e, i);
+        }
+        function uP(e) {
+          return !!e._fullLayout._outlining;
+        }
+        function hP(e) {
+          return !e._context.edits.shapePosition;
+        }
+        function Jue(e, t) {
+          e._fullLayout._paperdiv.selectAll('.shapelayer [data-index="' + t + '"]').remove();
+          var r = Ep.makeShapesOptionsAndPlotinfo(e, t), n = r.options, i = r.plotinfo;
+          if (!n._input || n.visible !== true) return;
+          let a = Array.isArray(n.xref) || Array.isArray(n.yref);
+          if (n.layer === "above") s(e._fullLayout._shapeUpperLayer);
+          else if (n.xref.includes("paper") || n.yref.includes("paper")) s(e._fullLayout._shapeLowerLayer);
+          else if (n.layer === "between" && !a) s(i.shapelayerBetween);
+          else if (i._hadPlotinfo) {
+            var o = i.mainplotinfo || i;
+            s(o.shapelayer);
+          } else s(e._fullLayout._shapeLowerLayer);
+          function s(l) {
+            var u = oN(e, n), c = { "data-index": t, "fill-rule": n.fillrule, d: u }, f = n.opacity, h = n.fillcolor, d = n.line.width ? n.line.color : "rgba(0,0,0,0)", v = n.line.width, _ = n.line.dash;
+            !v && n.editable === true && (v = 5, _ = "solid");
+            var b = u[u.length - 1] !== "Z", p = hP(e) && n.editable && e._fullLayout._activeShapeIndex === t;
+            p && (h = b ? "rgba(0,0,0,0)" : e._fullLayout.activeshape.fillcolor, f = e._fullLayout.activeshape.opacity);
+            var k = l.append("g").classed("shape-group", true).attr({ "data-index": t }), E = k.append("path").attr(c).style("opacity", f).call(nN.stroke, d).call(nN.fill, h).call(fP.dashLine, _, v);
+            $ue(k, e, n), cP(e, t, n, k);
+            var T;
+            if ((p || e._context.edits.shapePosition) && (T = Kct(e.layout, "shapes", n)), p) {
+              E.style({ cursor: "move" });
+              var L = { element: E.node(), plotinfo: i, gd: e, editHelpers: T, hasText: n.label.text || n.label.texttemplate, isActiveShape: true }, x = Zct(u, e);
+              Yct(x, E, L);
+            } else e._context.edits.shapePosition ? $ct(e, E, n, t, l, T) : n.editable === true && E.style("pointer-events", b || nN.opacity(h) * f <= 0.5 ? "stroke" : "all");
+            E.node().addEventListener("click", function() {
+              return Qct(e, E);
+            });
+          }
+        }
+        function $ue(e, t, r) {
+          let n = r.xref, i = r.yref;
+          if (Array.isArray(n) || Array.isArray(i)) {
+            let a = "clip" + t._fullLayout._uid + "shape" + r._index, o = Jct(t, n, i);
+            aN.ensureSingleById(t._fullLayout._clips, "clipPath", a, function(s) {
+              s.append("rect");
+            }).select("rect").attr(o), fP.setClipUrl(e, a, t);
+          } else {
+            let a = (n + i).replace(/paper/g, "").replace(/[xyz][0-9]* *domain/g, "");
+            fP.setClipUrl(e, a ? "clip" + t._fullLayout._uid + a : null, t);
+          }
+        }
+        function Jct(e, t, r) {
+          let n = e._fullLayout._size;
+          function i(s, l) {
+            let u = (Array.isArray(s) ? s : [s]).map((h) => Xb.getFromId(e, h)).filter(Boolean);
+            if (!u.length) return l ? [n.t, n.t + n.h] : [n.l, n.l + n.w];
+            let c = u.map(function(h) {
+              return h._offset;
+            }), f = u.map(function(h) {
+              return h._offset + h._length;
+            });
+            return [Math.min(...c), Math.max(...f)];
+          }
+          let a = i(t, false), o = i(r, true);
+          return { x: a[0], y: o[0], width: a[1] - a[0], height: o[1] - o[0] };
+        }
+        function $ct(e, t, r, n, i, a) {
+          var o = 10, s = 10, l = r.xsizemode === "pixel", u = r.ysizemode === "pixel", c = r.type === "line", f = r.type === "path", h = a.modifyItem, d, v, _, b, p, k, E, T, L, x, C, M, g, P, A, z = Xct.select(t.node().parentNode), O = Xb.getFromId(e, r.xref), U = Xb.getRefType(r.xref), G = Xb.getFromId(e, r.yref), Z = Xb.getRefType(r.yref), j = r.x0shift, N = r.x1shift, H = r.y0shift, re = r.y1shift, oe = function(ot, ut) {
+            var Wt = Ep.getDataToPixel(e, O, ut, false, U);
+            return Wt(ot);
+          }, _e = function(ot, ut) {
+            var Wt = Ep.getDataToPixel(e, G, ut, true, Z);
+            return Wt(ot);
+          }, Ce = Ep.getPixelToData(e, O, false, U), Le = Ep.getPixelToData(e, G, true, Z), ge = Ee(), ie = { element: ge.node(), gd: e, prepFn: Pe, doneFn: me, clickFn: De }, Se;
+          jue.init(ie), ge.node().onmousemove = Be;
+          function Ee() {
+            return c ? Ae() : t;
+          }
+          function Ae() {
+            var ot = 10, ut = Math.max(r.line.width, ot), Wt = i.append("g").attr("data-index", n).attr("drag-helper", true);
+            Wt.append("path").attr("d", t.attr("d")).style({ cursor: "move", "stroke-width": ut, "stroke-opacity": "0" });
+            var Nt = { "fill-opacity": "0" }, $t = Math.max(ut / 2, ot);
+            return Wt.append("circle").attr({ "data-line-point": "start-point", cx: l ? oe(r.xanchor) + r.x0 : oe(r.x0, j), cy: u ? _e(r.yanchor) - r.y0 : _e(r.y0, H), r: $t }).style(Nt).classed("cursor-grab", true), Wt.append("circle").attr({ "data-line-point": "end-point", cx: l ? oe(r.xanchor) + r.x1 : oe(r.x1, N), cy: u ? _e(r.yanchor) - r.y1 : _e(r.y1, re), r: $t }).style(Nt).classed("cursor-grab", true), Wt;
+          }
+          function Be(ot) {
+            if (uP(e)) {
+              Se = null;
+              return;
+            }
+            if (c) ot.target.tagName === "path" ? Se = "move" : Se = ot.target.attributes["data-line-point"].value === "start-point" ? "resize-over-start-point" : "resize-over-end-point";
+            else {
+              var ut = ie.element.getBoundingClientRect(), Wt = ut.right - ut.left, Nt = ut.bottom - ut.top, $t = ot.clientX - ut.left, sr = ot.clientY - ut.top, Tr = !f && Wt > o && Nt > s && !ot.shiftKey ? jue.getCursor($t / Wt, 1 - sr / Nt) : "move";
+              Wue(t, Tr), Se = Tr.split("-")[0];
+            }
+          }
+          function Pe(ot) {
+            uP(e) || (l && (p = oe(r.xanchor)), u && (k = _e(r.yanchor)), r.type === "path" ? A = r.path : (d = l ? r.x0 : oe(r.x0), v = u ? r.y0 : _e(r.y0), _ = l ? r.x1 : oe(r.x1), b = u ? r.y1 : _e(r.y1)), d < _ ? (L = d, g = "x0", x = _, P = "x1") : (L = _, g = "x1", x = d, P = "x0"), !u && v < b || u && v > b ? (E = v, C = "y0", T = b, M = "y1") : (E = b, C = "y1", T = v, M = "y0"), Be(ot), lt(i, r), Vt(t, r, e), ie.moveFn = Se === "move" ? ce : je, ie.altKey = ot.altKey);
+          }
+          function me() {
+            uP(e) || (Wue(t), pt(i), $ue(t, e, r), Yue.call("_guiRelayout", e, a.getUpdateObj()));
+          }
+          function De() {
+            uP(e) || pt(i);
+          }
+          function ce(ot, ut) {
+            if (r.type === "path") {
+              var Wt = function(sr) {
+                return sr;
+              }, Nt = Wt, $t = Wt;
+              l ? h("xanchor", r.xanchor = Ce(p + ot)) : (Nt = function(Tr) {
+                return Ce(oe(Tr) + ot);
+              }, O && O.type === "date" && (Nt = Ep.encodeDate(Nt))), u ? h("yanchor", r.yanchor = Le(k + ut)) : ($t = function(Tr) {
+                return Le(_e(Tr) + ut);
+              }, G && G.type === "date" && ($t = Ep.encodeDate($t))), h("path", r.path = Xue(A, Nt, $t));
+            } else l ? h("xanchor", r.xanchor = Ce(p + ot)) : (h("x0", r.x0 = Ce(d + ot)), h("x1", r.x1 = Ce(_ + ot))), u ? h("yanchor", r.yanchor = Le(k + ut)) : (h("y0", r.y0 = Le(v + ut)), h("y1", r.y1 = Le(b + ut)));
+            t.attr("d", oN(e, r)), lt(i, r), cP(e, n, r, z);
+          }
+          function je(ot, ut) {
+            if (f) {
+              var Wt = function(Lr) {
+                return Lr;
+              }, Nt = Wt, $t = Wt;
+              l ? h("xanchor", r.xanchor = Ce(p + ot)) : (Nt = function(ti) {
+                return Ce(oe(ti) + ot);
+              }, O && O.type === "date" && (Nt = Ep.encodeDate(Nt))), u ? h("yanchor", r.yanchor = Le(k + ut)) : ($t = function(ti) {
+                return Le(_e(ti) + ut);
+              }, G && G.type === "date" && ($t = Ep.encodeDate($t))), h("path", r.path = Xue(A, Nt, $t));
+            } else if (c) {
+              if (Se === "resize-over-start-point") {
+                var sr = d + ot, Tr = u ? v - ut : v + ut;
+                h("x0", r.x0 = l ? sr : Ce(sr)), h("y0", r.y0 = u ? Tr : Le(Tr));
+              } else if (Se === "resize-over-end-point") {
+                var fr = _ + ot, $e = u ? b - ut : b + ut;
+                h("x1", r.x1 = l ? fr : Ce(fr)), h("y1", r.y1 = u ? $e : Le($e));
+              }
+            } else {
+              var St = function(Lr) {
+                return Se.indexOf(Lr) !== -1;
+              }, Qt = St("n"), Gt = St("s"), _t = St("w"), It = St("e"), mt = Qt ? E + ut : E, er = Gt ? T + ut : T, lr = _t ? L + ot : L, wr = It ? x + ot : x;
+              u && (Qt && (mt = E - ut), Gt && (er = T - ut)), (!u && er - mt > s || u && mt - er > s) && (h(C, r[C] = u ? mt : Le(mt)), h(M, r[M] = u ? er : Le(er))), wr - lr > o && (h(g, r[g] = l ? lr : Ce(lr)), h(P, r[P] = l ? wr : Ce(wr)));
+            }
+            t.attr("d", oN(e, r)), lt(i, r), cP(e, n, r, z);
+          }
+          function lt(ot, ut) {
+            (l || u) && Wt();
+            function Wt() {
+              var Nt = ut.type !== "path", $t = ot.selectAll(".visual-cue").data([0]), sr = 1;
+              $t.enter().append("path").attr({ fill: "#fff", "fill-rule": "evenodd", stroke: "#000", "stroke-width": sr }).classed("visual-cue", true);
+              var Tr = oe(l ? ut.xanchor : aN.midRange(Nt ? [ut.x0, ut.x1] : Ep.extractPathCoords(ut.path, Zb.paramIsX))), fr = _e(u ? ut.yanchor : aN.midRange(Nt ? [ut.y0, ut.y1] : Ep.extractPathCoords(ut.path, Zb.paramIsY)));
+              if (Tr = Ep.roundPositionForSharpStrokeRendering(Tr, sr), fr = Ep.roundPositionForSharpStrokeRendering(fr, sr), l && u) {
+                var $e = "M" + (Tr - 1 - sr) + "," + (fr - 1 - sr) + "h-8v2h8 v8h2v-8 h8v-2h-8 v-8h-2 Z";
+                $t.attr("d", $e);
+              } else if (l) {
+                var St = "M" + (Tr - 1 - sr) + "," + (fr - 9 - sr) + "v18 h2 v-18 Z";
+                $t.attr("d", St);
+              } else {
+                var Qt = "M" + (Tr - 9 - sr) + "," + (fr - 1 - sr) + "h18 v2 h-18 Z";
+                $t.attr("d", Qt);
+              }
+            }
+          }
+          function pt(ot) {
+            ot.selectAll(".visual-cue").remove();
+          }
+          function Vt(ot, ut, Wt) {
+            var Nt = ut.xref, $t = ut.yref, sr = Xb.getFromId(Wt, Nt), Tr = Xb.getFromId(Wt, $t), fr = "";
+            Nt !== "paper" && !sr.autorange && (fr += Nt), $t !== "paper" && !Tr.autorange && (fr += $t), fP.setClipUrl(ot, fr ? "clip" + Wt._fullLayout._uid + fr : null, Wt);
+          }
+        }
+        function Xue(e, t, r) {
+          return e.replace(Zb.segmentRE, function(n) {
+            var i = 0, a = n.charAt(0), o = Zb.paramIsX[a], s = Zb.paramIsY[a], l = Zb.numParams[a], u = n.slice(1).replace(Zb.paramRE, function(c) {
+              return i >= l || (o[i] ? c = t(c) : s[i] && (c = r(c)), i++), c;
+            });
+            return a + u;
+          });
+        }
+        function Qct(e, t) {
+          if (hP(e)) {
+            var r = t.node(), n = +r.getAttribute("data-index");
+            if (n >= 0) {
+              if (n === e._fullLayout._activeShapeIndex) {
+                Zue(e);
+                return;
+              }
+              e._fullLayout._activeShapeIndex = n, e._fullLayout._deactivateShape = Zue, sN(e);
+            }
+          }
+        }
+        function Zue(e) {
+          if (hP(e)) {
+            var t = e._fullLayout._activeShapeIndex;
+            t >= 0 && (Kue(e), delete e._fullLayout._activeShapeIndex, sN(e));
+          }
+        }
+        function eft(e) {
+          if (hP(e)) {
+            Kue(e);
+            var t = e._fullLayout._activeShapeIndex, r = (e.layout || {}).shapes || [];
+            if (t < r.length) {
+              for (var n = [], i = 0; i < r.length; i++) i !== t && n.push(r[i]);
+              return delete e._fullLayout._activeShapeIndex, Yue.call("_guiRelayout", e, { shapes: n });
+            }
+          }
+        }
+      });
+      var cN = ye((Zar, lce) => {
+        var S0 = qa(), ece = Mc(), tce = hf(), Pl = $L(), tft = dP().eraseActiveShape, vP = Dr(), tl = vP._, Il = lce.exports = {};
+        Il.toImage = { name: "toImage", title: function(e) {
+          var t = e._context.toImageButtonOptions || {}, r = t.format || "png";
+          return r === "png" ? tl(e, "Download plot as a PNG") : tl(e, "Download plot");
+        }, icon: Pl.camera, click: function(e) {
+          var t = e._context.toImageButtonOptions, r = { format: t.format || "png" };
+          vP.notifier(tl(e, "Taking snapshot - this may take a few seconds"), "long"), ["filename", "width", "height", "scale"].forEach(function(n) {
+            n in t && (r[n] = t[n]);
+          }), S0.call("downloadImage", e, r).then(function(n) {
+            vP.notifier(tl(e, "Snapshot succeeded") + " - " + n, "long");
+          }).catch(function() {
+            vP.notifier(tl(e, "Sorry, there was a problem downloading your snapshot!"), "long");
+          });
+        } };
+        Il.sendDataToCloud = { name: "sendDataToCloud", title: function(e) {
+          return tl(e, "Edit in Chart Studio");
+        }, icon: Pl.disk, click: function(e) {
+          ece.sendDataToCloud(e);
+        } };
+        Il.editInChartStudio = { name: "editInChartStudio", title: function(e) {
+          return tl(e, "Edit in Chart Studio");
+        }, icon: Pl.pencil, click: function(e) {
+          ece.sendDataToCloud(e);
+        } };
+        Il.zoom2d = { name: "zoom2d", _cat: "zoom", title: function(e) {
+          return tl(e, "Zoom");
+        }, attr: "dragmode", val: "zoom", icon: Pl.zoombox, click: Bv };
+        Il.pan2d = { name: "pan2d", _cat: "pan", title: function(e) {
+          return tl(e, "Pan");
+        }, attr: "dragmode", val: "pan", icon: Pl.pan, click: Bv };
+        Il.select2d = { name: "select2d", _cat: "select", title: function(e) {
+          return tl(e, "Box Select");
+        }, attr: "dragmode", val: "select", icon: Pl.selectbox, click: Bv };
+        Il.lasso2d = { name: "lasso2d", _cat: "lasso", title: function(e) {
+          return tl(e, "Lasso Select");
+        }, attr: "dragmode", val: "lasso", icon: Pl.lasso, click: Bv };
+        Il.drawclosedpath = { name: "drawclosedpath", title: function(e) {
+          return tl(e, "Draw closed freeform");
+        }, attr: "dragmode", val: "drawclosedpath", icon: Pl.drawclosedpath, click: Bv };
+        Il.drawopenpath = { name: "drawopenpath", title: function(e) {
+          return tl(e, "Draw open freeform");
+        }, attr: "dragmode", val: "drawopenpath", icon: Pl.drawopenpath, click: Bv };
+        Il.drawline = { name: "drawline", title: function(e) {
+          return tl(e, "Draw line");
+        }, attr: "dragmode", val: "drawline", icon: Pl.drawline, click: Bv };
+        Il.drawrect = { name: "drawrect", title: function(e) {
+          return tl(e, "Draw rectangle");
+        }, attr: "dragmode", val: "drawrect", icon: Pl.drawrect, click: Bv };
+        Il.drawcircle = { name: "drawcircle", title: function(e) {
+          return tl(e, "Draw circle");
+        }, attr: "dragmode", val: "drawcircle", icon: Pl.drawcircle, click: Bv };
+        Il.eraseshape = { name: "eraseshape", title: function(e) {
+          return tl(e, "Erase active shape");
+        }, icon: Pl.eraseshape, click: tft };
+        Il.zoomIn2d = { name: "zoomIn2d", _cat: "zoomin", title: function(e) {
+          return tl(e, "Zoom in");
+        }, attr: "zoom", val: "in", icon: Pl.zoom_plus, click: Bv };
+        Il.zoomOut2d = { name: "zoomOut2d", _cat: "zoomout", title: function(e) {
+          return tl(e, "Zoom out");
+        }, attr: "zoom", val: "out", icon: Pl.zoom_minus, click: Bv };
+        Il.autoScale2d = { name: "autoScale2d", _cat: "autoscale", title: function(e) {
+          return tl(e, "Autoscale");
+        }, attr: "zoom", val: "auto", icon: Pl.autoscale, click: Bv };
+        Il.resetScale2d = { name: "resetScale2d", _cat: "resetscale", title: function(e) {
+          return tl(e, "Reset axes");
+        }, attr: "zoom", val: "reset", icon: Pl.home, click: Bv };
+        Il.hoverClosestCartesian = { name: "hoverClosestCartesian", _cat: "hoverclosest", title: function(e) {
+          return tl(e, "Show closest data on hover");
+        }, attr: "hovermode", val: "closest", icon: Pl.tooltip_basic, gravity: "ne", click: Bv };
+        Il.hoverCompareCartesian = { name: "hoverCompareCartesian", _cat: "hoverCompare", title: function(e) {
+          return tl(e, "Compare data on hover");
+        }, attr: "hovermode", val: function(e) {
+          return e._fullLayout._isHoriz ? "y" : "x";
+        }, icon: Pl.tooltip_compare, gravity: "ne", click: Bv };
+        function Bv(e, t) {
+          var r = t.currentTarget, n = r.getAttribute("data-attr"), i = r.getAttribute("data-val") || true, a = e._fullLayout, o = {}, s = tce.list(e, null, true), l = a._cartesianSpikesEnabled, u, c;
+          if (n === "zoom") {
+            var f = i === "in" ? 0.5 : 2, h = (1 + f) / 2, d = (1 - f) / 2, v, _;
+            for (c = 0; c < s.length; c++) if (u = s[c], _ = u.modebardisable === "none" || u.modebardisable.indexOf(i === "auto" || i === "reset" ? "autoscale" : "zoominout") === -1, _ && !u.fixedrange) if (v = u._name, i === "auto") o[v + ".autorange"] = true;
+            else if (i === "reset") u._rangeInitial0 === void 0 && u._rangeInitial1 === void 0 ? o[v + ".autorange"] = true : u._rangeInitial0 === void 0 ? (o[v + ".autorange"] = u._autorangeInitial, o[v + ".range"] = [null, u._rangeInitial1]) : u._rangeInitial1 === void 0 ? (o[v + ".range"] = [u._rangeInitial0, null], o[v + ".autorange"] = u._autorangeInitial) : o[v + ".range"] = [u._rangeInitial0, u._rangeInitial1], u._showSpikeInitial !== void 0 && (o[v + ".showspikes"] = u._showSpikeInitial, l === "on" && !u._showSpikeInitial && (l = "off"));
+            else {
+              var b = [u.r2l(u.range[0]), u.r2l(u.range[1])], p = [h * b[0] + d * b[1], h * b[1] + d * b[0]];
+              o[v + ".range[0]"] = u.l2r(p[0]), o[v + ".range[1]"] = u.l2r(p[1]);
+            }
+          } else n === "hovermode" && (i === "x" || i === "y") && (i = a._isHoriz ? "y" : "x", r.setAttribute("data-val", i)), o[n] = i;
+          a._cartesianSpikesEnabled = l, S0.call("_guiRelayout", e, o);
+        }
+        Il.zoom3d = { name: "zoom3d", _cat: "zoom", title: function(e) {
+          return tl(e, "Zoom");
+        }, attr: "scene.dragmode", val: "zoom", icon: Pl.zoombox, click: pP };
+        Il.pan3d = { name: "pan3d", _cat: "pan", title: function(e) {
+          return tl(e, "Pan");
+        }, attr: "scene.dragmode", val: "pan", icon: Pl.pan, click: pP };
+        Il.orbitRotation = { name: "orbitRotation", title: function(e) {
+          return tl(e, "Orbital rotation");
+        }, attr: "scene.dragmode", val: "orbit", icon: Pl["3d_rotate"], click: pP };
+        Il.tableRotation = { name: "tableRotation", title: function(e) {
+          return tl(e, "Turntable rotation");
+        }, attr: "scene.dragmode", val: "turntable", icon: Pl["z-axis"], click: pP };
+        function pP(e, t) {
+          for (var r = t.currentTarget, n = r.getAttribute("data-attr"), i = r.getAttribute("data-val") || true, a = e._fullLayout._subplots.gl3d || [], o = {}, s = n.split("."), l = 0; l < a.length; l++) o[a[l] + "." + s[1]] = i;
+          var u = i === "pan" ? i : "zoom";
+          o.dragmode = u, S0.call("_guiRelayout", e, o);
+        }
+        Il.resetCameraDefault3d = { name: "resetCameraDefault3d", _cat: "resetCameraDefault", title: function(e) {
+          return tl(e, "Reset camera to default");
+        }, attr: "resetDefault", icon: Pl.home, click: lN };
+        Il.resetCameraLastSave3d = { name: "resetCameraLastSave3d", _cat: "resetCameraLastSave", title: function(e) {
+          return tl(e, "Reset camera to last save");
+        }, attr: "resetLastSave", icon: Pl.movie, click: lN };
+        function lN(e, t) {
+          for (var r = t.currentTarget, n = r.getAttribute("data-attr"), i = n === "resetLastSave", a = n === "resetDefault", o = e._fullLayout, s = o._subplots.gl3d || [], l = {}, u = 0; u < s.length; u++) {
+            var c = s[u], f = c + ".camera", h = c + ".aspectratio", d = c + ".aspectmode", v = o[c]._scene, _;
+            i ? (l[f + ".up"] = v.viewInitial.up, l[f + ".eye"] = v.viewInitial.eye, l[f + ".center"] = v.viewInitial.center, _ = true) : a && (l[f + ".up"] = null, l[f + ".eye"] = null, l[f + ".center"] = null, _ = true), _ && (l[h + ".x"] = v.viewInitial.aspectratio.x, l[h + ".y"] = v.viewInitial.aspectratio.y, l[h + ".z"] = v.viewInitial.aspectratio.z, l[d] = v.viewInitial.aspectmode);
+          }
+          S0.call("_guiRelayout", e, l);
+        }
+        Il.hoverClosest3d = { name: "hoverClosest3d", _cat: "hoverclosest", title: function(e) {
+          return tl(e, "Toggle show closest data on hover");
+        }, attr: "hovermode", val: null, toggle: true, icon: Pl.tooltip_basic, gravity: "ne", click: rft };
+        function rce(e, t) {
+          var r = t.currentTarget, n = r._previousVal, i = e._fullLayout, a = i._subplots.gl3d || [], o = ["xaxis", "yaxis", "zaxis"], s = {}, l = {};
+          if (n) l = n, r._previousVal = null;
+          else {
+            for (var u = 0; u < a.length; u++) {
+              var c = a[u], f = i[c], h = c + ".hovermode";
+              s[h] = f.hovermode, l[h] = false;
+              for (var d = 0; d < 3; d++) {
+                var v = o[d], _ = c + "." + v + ".showspikes";
+                l[_] = false, s[_] = f[v].showspikes;
+              }
+            }
+            r._previousVal = s;
+          }
+          return l;
+        }
+        function rft(e, t) {
+          var r = rce(e, t);
+          S0.call("_guiRelayout", e, r);
+        }
+        Il.zoomInGeo = { name: "zoomInGeo", _cat: "zoomin", title: function(e) {
+          return tl(e, "Zoom in");
+        }, attr: "zoom", val: "in", icon: Pl.zoom_plus, click: uN };
+        Il.zoomOutGeo = { name: "zoomOutGeo", _cat: "zoomout", title: function(e) {
+          return tl(e, "Zoom out");
+        }, attr: "zoom", val: "out", icon: Pl.zoom_minus, click: uN };
+        Il.resetGeo = { name: "resetGeo", _cat: "reset", title: function(e) {
+          return tl(e, "Reset");
+        }, attr: "reset", val: null, icon: Pl.autoscale, click: uN };
+        Il.hoverClosestGeo = { name: "hoverClosestGeo", _cat: "hoverclosest", title: function(e) {
+          return tl(e, "Toggle show closest data on hover");
+        }, attr: "hovermode", val: null, toggle: true, icon: Pl.tooltip_basic, gravity: "ne", click: nce };
+        function uN(e, t) {
+          for (var r = t.currentTarget, n = r.getAttribute("data-attr"), i = r.getAttribute("data-val") || true, a = e._fullLayout, o = a._subplots.geo || [], s = 0; s < o.length; s++) {
+            var l = o[s], u = a[l];
+            if (n === "zoom") {
+              var c = u.projection.scale, f = i === "in" ? 2 * c : 0.5 * c;
+              S0.call("_guiRelayout", e, l + ".projection.scale", f);
+            }
+          }
+          n === "reset" && rT(e, "geo");
+        }
+        Il.hoverClosestPie = { name: "hoverClosestPie", _cat: "hoverclosest", title: function(e) {
+          return tl(e, "Toggle show closest data on hover");
+        }, attr: "hovermode", val: "closest", icon: Pl.tooltip_basic, gravity: "ne", click: nce };
+        function ice(e) {
+          var t = e._fullLayout;
+          return t.hovermode ? false : t._has("cartesian") ? t._isHoriz ? "y" : "x" : "closest";
+        }
+        function nce(e) {
+          var t = ice(e);
+          S0.call("_guiRelayout", e, "hovermode", t);
+        }
+        Il.resetViewSankey = { name: "resetSankeyGroup", title: function(e) {
+          return tl(e, "Reset view");
+        }, icon: Pl.home, click: function(e) {
+          for (var t = { "node.groups": [], "node.x": [], "node.y": [] }, r = 0; r < e._fullData.length; r++) {
+            var n = e._fullData[r]._viewInitial;
+            t["node.groups"].push(n.node.groups.slice()), t["node.x"].push(n.node.x.slice()), t["node.y"].push(n.node.y.slice());
+          }
+          S0.call("restyle", e, t);
+        } };
+        Il.toggleHover = { name: "toggleHover", title: function(e) {
+          return tl(e, "Toggle show closest data on hover");
+        }, attr: "hovermode", val: null, toggle: true, icon: Pl.tooltip_basic, gravity: "ne", click: function(e, t) {
+          var r = rce(e, t);
+          r.hovermode = ice(e), S0.call("_guiRelayout", e, r);
+        } };
+        Il.resetViews = { name: "resetViews", title: function(e) {
+          return tl(e, "Reset views");
+        }, icon: Pl.home, click: function(e, t) {
+          var r = t.currentTarget;
+          r.setAttribute("data-attr", "zoom"), r.setAttribute("data-val", "reset"), Bv(e, t), r.setAttribute("data-attr", "resetLastSave"), lN(e, t), rT(e, "geo"), rT(e, "mapbox"), rT(e, "map");
+        } };
+        Il.toggleSpikelines = { name: "toggleSpikelines", title: function(e) {
+          return tl(e, "Toggle Spike Lines");
+        }, icon: Pl.spikeline, attr: "_cartesianSpikesEnabled", val: "on", click: function(e) {
+          var t = e._fullLayout, r = t._cartesianSpikesEnabled;
+          t._cartesianSpikesEnabled = r === "on" ? "off" : "on", S0.call("_guiRelayout", e, ift(e));
+        } };
+        function ift(e) {
+          for (var t = e._fullLayout, r = t._cartesianSpikesEnabled === "on", n = tce.list(e, null, true), i = {}, a = 0; a < n.length; a++) {
+            var o = n[a];
+            i[o._name + ".showspikes"] = r ? true : o._showSpikeInitial;
+          }
+          return i;
+        }
+        Il.resetViewMapbox = { name: "resetViewMapbox", _cat: "resetView", title: function(e) {
+          return tl(e, "Reset view");
+        }, attr: "reset", icon: Pl.home, click: function(e) {
+          rT(e, "mapbox");
+        } };
+        Il.resetViewMap = { name: "resetViewMap", _cat: "resetView", title: function(e) {
+          return tl(e, "Reset view");
+        }, attr: "reset", icon: Pl.home, click: function(e) {
+          rT(e, "map");
+        } };
+        Il.zoomInMapbox = { name: "zoomInMapbox", _cat: "zoomin", title: function(e) {
+          return tl(e, "Zoom in");
+        }, attr: "zoom", val: "in", icon: Pl.zoom_plus, click: ace };
+        Il.zoomInMap = { name: "zoomInMap", _cat: "zoomin", title: function(e) {
+          return tl(e, "Zoom in");
+        }, attr: "zoom", val: "in", icon: Pl.zoom_plus, click: oce };
+        Il.zoomOutMapbox = { name: "zoomOutMapbox", _cat: "zoomout", title: function(e) {
+          return tl(e, "Zoom out");
+        }, attr: "zoom", val: "out", icon: Pl.zoom_minus, click: ace };
+        Il.zoomOutMap = { name: "zoomOutMap", _cat: "zoomout", title: function(e) {
+          return tl(e, "Zoom out");
+        }, attr: "zoom", val: "out", icon: Pl.zoom_minus, click: oce };
+        function ace(e, t) {
+          sce(e, t, "mapbox");
+        }
+        function oce(e, t) {
+          sce(e, t, "map");
+        }
+        function sce(e, t, r) {
+          for (var n = t.currentTarget, i = n.getAttribute("data-val"), a = e._fullLayout, o = a._subplots[r] || [], s = 1.05, l = {}, u = 0; u < o.length; u++) {
+            var c = o[u], f = a[c].zoom, h = i === "in" ? s * f : f / s;
+            l[c + ".zoom"] = h;
+          }
+          S0.call("_guiRelayout", e, l);
+        }
+        function rT(e, t) {
+          for (var r = e._fullLayout, n = r._subplots[t] || [], i = {}, a = 0; a < n.length; a++) for (var o = n[a], s = r[o]._subplot, l = s.viewInitial, u = Object.keys(l), c = 0; c < u.length; c++) {
+            var f = u[c];
+            i[o + "." + f] = l[f];
+          }
+          S0.call("_guiRelayout", e, i);
+        }
+      });
+      var fN = ye((Yar, hce) => {
+        var uce = cN(), nft = Object.keys(uce), cce = ["drawline", "drawopenpath", "drawclosedpath", "drawcircle", "drawrect", "eraseshape"], fce = ["v1hovermode", "hoverclosest", "hovercompare", "togglehover", "togglespikelines"].concat(cce), iT = [], aft = function(e) {
+          if (fce.indexOf(e._cat || e.name) === -1) {
+            var t = e.name, r = (e._cat || e.name).toLowerCase();
+            iT.indexOf(t) === -1 && iT.push(t), iT.indexOf(r) === -1 && iT.push(r);
+          }
+        };
+        nft.forEach(function(e) {
+          aft(uce[e]);
+        });
+        iT.sort();
+        hce.exports = { DRAW_MODES: cce, backButtons: fce, foreButtons: iT };
+      });
+      var hN = ye((Jar, dce) => {
+        fN();
+        dce.exports = { editType: "modebar", orientation: { valType: "enumerated", values: ["v", "h"], dflt: "h", editType: "modebar" }, bgcolor: { valType: "color", editType: "modebar" }, color: { valType: "color", editType: "modebar" }, activecolor: { valType: "color", editType: "modebar" }, uirevision: { valType: "any", editType: "none" }, add: { valType: "string", arrayOk: true, dflt: "", editType: "modebar" }, remove: { valType: "string", arrayOk: true, dflt: "", editType: "modebar" } };
+      });
+      var pce = ye(($ar, vce) => {
+        var oft = Dr(), SM = ka(), sft = vl(), lft = hN();
+        vce.exports = function(t, r) {
+          var n = t.modebar || {}, i = sft.newContainer(r, "modebar");
+          function a(s, l) {
+            return oft.coerce(n, i, lft, s, l);
+          }
+          a("orientation"), a("bgcolor", SM.addOpacity(r.paper_bgcolor, 0.5));
+          var o = SM.contrast(SM.rgb(r.modebar.bgcolor));
+          a("color", SM.addOpacity(o, 0.3)), a("activecolor", SM.addOpacity(o, 0.7)), a("uirevision", r.uirevision), a("add"), a("remove");
+        };
+      });
+      var _ce = ye((Qar, yce) => {
+        var dN = Oa(), uft = Eo(), gP = Dr(), gce = $L(), cft = g6().version, fft = new DOMParser();
+        function mce(e) {
+          this.container = e.container, this.element = document.createElement("div"), this.update(e.graphInfo, e.buttons), this.container.appendChild(this.element);
+        }
+        var km = mce.prototype;
+        km.update = function(e, t) {
+          this.graphInfo = e;
+          var r = this.graphInfo._context, n = this.graphInfo._fullLayout, i = "modebar-" + n._uid;
+          this.element.setAttribute("id", i), this.element.setAttribute("role", "toolbar"), this._uid = i, this.element.className = "modebar modebar--custom", r.displayModeBar === "hover" && (this.element.className += " modebar--hover ease-bg"), n.modebar.orientation === "v" && (this.element.className += " vertical", t = t.reverse());
+          var a = n.modebar, o = "#" + i + " .modebar-group";
+          document.querySelectorAll(o).forEach(function(f) {
+            f.style.backgroundColor = a.bgcolor;
+          });
+          var s = !this.hasButtons(t), l = this.hasLogo !== r.displaylogo, u = this.locale !== r.locale;
+          if (this.locale = r.locale, (s || l || u) && (this.removeAllButtons(), this.updateButtons(t), r.watermark || r.displaylogo)) {
+            var c = this.getLogo();
+            r.watermark && (c.className = c.className + " watermark"), n.modebar.orientation === "v" ? this.element.insertBefore(c, this.element.childNodes[0]) : this.element.appendChild(c), this.hasLogo = true;
+          }
+          this.updateActiveButton(), gP.setStyleOnHover("#" + i + " .modebar-btn", ".active", ".icon path", "fill: " + a.activecolor, "fill: " + a.color, this.element);
+        };
+        km.updateButtons = function(e) {
+          var t = this;
+          this.buttons = e, this.buttonElements = [], this.buttonsNames = [], this.buttons.forEach(function(r) {
+            var n = t.createGroup();
+            r.forEach(function(i) {
+              var a = i.name;
+              if (!a) throw new Error("must provide button 'name' in button config");
+              if (t.buttonsNames.indexOf(a) !== -1) throw new Error("button name '" + a + "' is taken");
+              t.buttonsNames.push(a);
+              var o = t.createButton(i);
+              t.buttonElements.push(o), n.appendChild(o);
+            }), t.element.appendChild(n);
+          });
+        };
+        km.createGroup = function() {
+          var e = document.createElement("div");
+          e.className = "modebar-group";
+          var t = this.graphInfo._fullLayout.modebar;
+          return e.style.backgroundColor = t.bgcolor, e;
+        };
+        km.createButton = function(e) {
+          var t = this, r = document.createElement("button");
+          r.setAttribute("type", "button"), r.setAttribute("rel", "tooltip"), r.className = "modebar-btn";
+          var n = e.title;
+          n === void 0 ? n = e.name : typeof n == "function" && (n = n(this.graphInfo)), (n || n === 0) && (r.setAttribute("data-title", n), r.setAttribute("aria-label", n)), e.attr !== void 0 && r.setAttribute("data-attr", e.attr);
+          var i = e.val;
+          i !== void 0 && (typeof i == "function" && (i = i(this.graphInfo)), r.setAttribute("data-val", i));
+          var a = e.click;
+          if (typeof a != "function") throw new Error("must provide button 'click' function in button config");
+          r.addEventListener("click", function(s) {
+            e.click(t.graphInfo, s), t.updateActiveButton(s.currentTarget);
+          }), r.setAttribute("data-toggle", e.toggle || false), e.toggle && dN.select(r).classed("active", true);
+          var o = e.icon;
+          return typeof o == "function" ? r.appendChild(o()) : r.appendChild(this.createIcon(o || gce.question)), r.setAttribute("data-gravity", e.gravity || "n"), r;
+        };
+        km.createIcon = function(e) {
+          var t = uft(e.height) ? Number(e.height) : e.ascent - e.descent, r = "http://www.w3.org/2000/svg", n;
+          if (e.path) {
+            n = document.createElementNS(r, "svg"), n.setAttribute("viewBox", [0, 0, e.width, t].join(" ")), n.setAttribute("class", "icon");
+            var i = document.createElementNS(r, "path");
+            i.setAttribute("d", e.path), e.transform ? i.setAttribute("transform", e.transform) : e.ascent !== void 0 && i.setAttribute("transform", "matrix(1 0 0 -1 0 " + e.ascent + ")"), n.appendChild(i);
+          }
+          if (e.svg) {
+            var a = fft.parseFromString(e.svg, "application/xml");
+            n = a.childNodes[0];
+          }
+          return n.setAttribute("height", "1em"), n.setAttribute("width", "1em"), n;
+        };
+        km.updateActiveButton = function(e) {
+          var t = this.graphInfo._fullLayout, r = e !== void 0 ? e.getAttribute("data-attr") : null;
+          this.buttonElements.forEach(function(n) {
+            var i = n.getAttribute("data-val") || true, a = n.getAttribute("data-attr"), o = n.getAttribute("data-toggle") === "true", s = dN.select(n), l = function(f, h) {
+              var d = t.modebar, v = f.querySelector(".icon path");
+              v && (h || f.matches(":hover") ? v.style.fill = d.activecolor : v.style.fill = d.color);
+            };
+            if (o) {
+              if (a === r) {
+                var u = !s.classed("active");
+                s.classed("active", u), l(n, u);
+              }
+            } else {
+              var c = a === null ? a : gP.nestedProperty(t, a).get();
+              s.classed("active", c === i), l(n, c === i);
+            }
+          });
+        };
+        km.hasButtons = function(e) {
+          var t = this.buttons;
+          if (!t || e.length !== t.length) return false;
+          for (var r = 0; r < e.length; ++r) {
+            if (e[r].length !== t[r].length) return false;
+            for (var n = 0; n < e[r].length; n++) if (e[r][n].name !== t[r][n].name) return false;
+          }
+          return true;
+        };
+        function hft(e) {
+          return e + " (v" + cft + ")";
+        }
+        km.getLogo = function() {
+          var e = this.createGroup(), t = document.createElement("a");
+          return t.href = "https://plotly.com/", t.target = "_blank", t.setAttribute("data-title", hft(gP._(this.graphInfo, "Produced with Plotly.js"))), t.className = "modebar-btn plotlyjsicon modebar-btn--logo", t.appendChild(this.createIcon(gce.newplotlylogo)), e.appendChild(t), e;
+        };
+        km.removeAllButtons = function() {
+          for (; this.element.firstChild; ) this.element.removeChild(this.element.firstChild);
+          this.hasLogo = false;
+        };
+        km.destroy = function() {
+          gP.removeElement(this.container.querySelector(".modebar"));
+        };
+        function dft(e, t) {
+          var r = e._fullLayout, n = new mce({ graphInfo: e, container: r._modebardiv.node(), buttons: t });
+          return r._privateplot && dN.select(n.element).append("span").classed("badge-private float--left", true).text("PRIVATE"), n;
+        }
+        yce.exports = dft;
+      });
+      var wce = ye((eor, bce) => {
+        var vft = hf(), xce = Ru(), vN = qa(), pft = ip().isUnifiedHover, gft = _ce(), mP = cN(), mft = fN().DRAW_MODES, yft = Dr().extendDeep;
+        bce.exports = function(t) {
+          var r = t._fullLayout, n = t._context, i = r._modeBar;
+          if (!n.displayModeBar && !n.watermark) {
+            i && (i.destroy(), delete r._modeBar);
+            return;
+          }
+          if (!Array.isArray(n.modeBarButtonsToRemove)) throw new Error(["*modeBarButtonsToRemove* configuration options", "must be an array."].join(" "));
+          if (!Array.isArray(n.modeBarButtonsToAdd)) throw new Error(["*modeBarButtonsToAdd* configuration options", "must be an array."].join(" "));
+          var a = n.modeBarButtons, o;
+          Array.isArray(a) && a.length ? o = Aft(a) : !n.displayModeBar && n.watermark ? o = [] : o = _ft(t), i ? i.update(t, o) : r._modeBar = gft(t, o);
+        };
+        function _ft(e) {
+          var t = e._fullLayout, r = e._fullData, n = e._context;
+          function i(N, H) {
+            if (typeof H == "string") {
+              if (H.toLowerCase() === N.toLowerCase()) return true;
+            } else {
+              var re = H.name, oe = H._cat || H.name;
+              if (re === N || oe === N.toLowerCase()) return true;
+            }
+            return false;
+          }
+          var a = t.modebar.add;
+          typeof a == "string" && (a = [a]);
+          var o = t.modebar.remove;
+          typeof o == "string" && (o = [o]);
+          var s = n.modeBarButtonsToAdd.concat(a.filter(function(N) {
+            for (var H = 0; H < n.modeBarButtonsToRemove.length; H++) if (i(N, n.modeBarButtonsToRemove[H])) return false;
+            return true;
+          })), l = n.modeBarButtonsToRemove.concat(o.filter(function(N) {
+            for (var H = 0; H < n.modeBarButtonsToAdd.length; H++) if (i(N, n.modeBarButtonsToAdd[H])) return false;
+            return true;
+          })), u = t._has("cartesian"), c = t._has("gl3d"), f = t._has("geo"), h = t._has("pie"), d = t._has("funnelarea"), v = t._has("ternary"), _ = t._has("mapbox"), b = t._has("map"), p = t._has("polar"), k = t._has("smith"), E = t._has("sankey"), T = xft(t), L = pft(t.hovermode), x = [];
+          function C(N) {
+            if (N.length) {
+              for (var H = [], re = 0; re < N.length; re++) {
+                for (var oe = N[re], _e = mP[oe], Ce = _e.name.toLowerCase(), Le = (_e._cat || _e.name).toLowerCase(), ge = false, ie = 0; ie < l.length; ie++) {
+                  var Se = l[ie].toLowerCase();
+                  if (Se === Ce || Se === Le) {
+                    ge = true;
+                    break;
+                  }
+                }
+                ge || H.push(mP[oe]);
+              }
+              x.push(H);
+            }
+          }
+          var M = ["toImage"];
+          n.showEditInChartStudio ? M.push("editInChartStudio") : n.showSendToCloud && M.push("sendDataToCloud"), C(M);
+          var g = [], P = [], A = [], z = [];
+          (u || h || d || v) + f + c + _ + b + p + k > 1 ? (P = ["toggleHover"], A = ["resetViews"]) : f ? (g = ["zoomInGeo", "zoomOutGeo"], P = ["hoverClosestGeo"], A = ["resetGeo"]) : c ? (P = ["hoverClosest3d"], A = ["resetCameraDefault3d", "resetCameraLastSave3d"]) : _ ? (g = ["zoomInMapbox", "zoomOutMapbox"], P = ["toggleHover"], A = ["resetViewMapbox"]) : b ? (g = ["zoomInMap", "zoomOutMap"], P = ["toggleHover"], A = ["resetViewMap"]) : h ? P = ["hoverClosestPie"] : E ? (P = ["hoverClosestCartesian", "hoverCompareCartesian"], A = ["resetViewSankey"]) : P = ["toggleHover"], u && P.push("toggleSpikelines", "hoverClosestCartesian", "hoverCompareCartesian"), (wft(r) || L) && (P = []), u && !T && (g = ["zoomIn2d", "zoomOut2d", "autoScale2d"], A[0] !== "resetViews" && (A = ["resetScale2d"])), c ? z = ["zoom3d", "pan3d", "orbitRotation", "tableRotation"] : u && !T || v ? z = ["zoom2d", "pan2d"] : _ || b || f ? z = ["pan2d"] : p && (z = ["zoom2d"]), bft(r) && z.push("select2d", "lasso2d");
+          var O = [], U = function(N) {
+            O.indexOf(N) === -1 && P.indexOf(N) !== -1 && O.push(N);
+          };
+          if (Array.isArray(s)) {
+            for (var G = [], Z = 0; Z < s.length; Z++) {
+              var j = s[Z];
+              typeof j == "string" ? (j = j.toLowerCase(), mft.indexOf(j) !== -1 ? (t._has("mapbox") || t._has("map") || t._has("cartesian")) && z.push(j) : j === "togglespikelines" ? U("toggleSpikelines") : j === "togglehover" ? U("toggleHover") : j === "hovercompare" ? U("hoverCompareCartesian") : j === "hoverclosest" ? (U("hoverClosestCartesian"), U("hoverClosestGeo"), U("hoverClosest3d"), U("hoverClosestPie")) : j === "v1hovermode" && (U("hoverClosestCartesian"), U("hoverCompareCartesian"), U("hoverClosestGeo"), U("hoverClosest3d"), U("hoverClosestPie"))) : G.push(j);
+            }
+            s = G;
+          }
+          return C(z), C(g.concat(A)), C(O), Tft(x, s);
+        }
+        function xft(e) {
+          for (var t = vft.list({ _fullLayout: e }, null, true), r = 0; r < t.length; r++) {
+            var n = t[r].modebardisable;
+            if (!t[r].fixedrange && n !== "autoscale+zoominout" && n !== "zoominout+autoscale") return false;
+          }
+          return true;
+        }
+        function bft(e) {
+          for (var t = false, r = 0; r < e.length && !t; r++) {
+            var n = e[r];
+            !n._module || !n._module.selectPoints || (vN.traceIs(n, "scatter-like") ? (xce.hasMarkers(n) || xce.hasText(n)) && (t = true) : vN.traceIs(n, "box-violin") ? (n.boxpoints === "all" || n.points === "all") && (t = true) : t = true);
+          }
+          return t;
+        }
+        function wft(e) {
+          for (var t = 0; t < e.length; t++) if (!vN.traceIs(e[t], "noHover")) return false;
+          return true;
+        }
+        function Tft(e, t) {
+          if (t.length) if (Array.isArray(t[0])) for (var r = 0; r < t.length; r++) e.push(t[r]);
+          else e.push(t);
+          return e;
+        }
+        function Aft(e) {
+          for (var t = yft([], e), r = 0; r < t.length; r++) for (var n = t[r], i = 0; i < n.length; i++) {
+            var a = n[i];
+            if (typeof a == "string") if (mP[a] !== void 0) t[r][i] = mP[a];
+            else throw new Error(["*modeBarButtons* configuration options", "invalid button name"].join(" "));
+          }
+          return t;
+        }
+      });
+      var pN = ye((tor, Tce) => {
+        Tce.exports = { moduleType: "component", name: "modebar", layoutAttributes: hN(), supplyLayoutDefaults: pce(), manage: wce() };
+      });
+      var gN = ye((ror, Ace) => {
+        var Sft = Dh().FROM_BL;
+        Ace.exports = function(t, r, n) {
+          n === void 0 && (n = Sft[t.constraintoward || "center"]);
+          var i = [t.r2l(t.range[0]), t.r2l(t.range[1])], a = i[0] + (i[1] - i[0]) * n;
+          t.range = t._input.range = [t.l2r(a + (i[0] - a) * r), t.l2r(a + (i[1] - a) * r)], t.setScale();
+        };
+      });
+      var Kb = ye((MM) => {
+        var Yb = Dr(), mN = Mg(), Lg = hf().id2name, Mft = Rd(), Sce = gN(), Eft = xm(), kft = fs().ALMOST_EQUAL, Cft = Dh().FROM_BL;
+        MM.handleDefaults = function(e, t, r) {
+          var n = r.axIds, i = r.axHasImage, a = t._axisConstraintGroups = [], o = t._axisMatchGroups = [], s, l, u, c, f, h, d, v;
+          for (s = 0; s < n.length; s++) c = Lg(n[s]), f = e[c], h = t[c], Lft(f, h, { axIds: n, layoutOut: t, hasImage: i[c] });
+          function _(M, g) {
+            for (s = 0; s < M.length; s++) {
+              l = M[s];
+              for (u in l) t[Lg(u)][g] = l;
+            }
+          }
+          for (_(o, "_matchGroup"), s = 0; s < a.length; s++) {
+            l = a[s];
+            for (u in l) if (h = t[Lg(u)], h.fixedrange) {
+              for (var b in l) {
+                var p = Lg(b);
+                (e[p] || {}).fixedrange === false && Yb.warn("fixedrange was specified as false for axis " + p + " but was overridden because another axis in its constraint group has fixedrange true"), t[p].fixedrange = true;
+              }
+              break;
+            }
+          }
+          for (s = 0; s < a.length; ) {
+            l = a[s];
+            for (u in l) {
+              h = t[Lg(u)], h._matchGroup && Object.keys(h._matchGroup).length === Object.keys(l).length && (a.splice(s, 1), s--);
+              break;
+            }
+            s++;
+          }
+          _(a, "_constraintGroup");
+          var k = ["constrain", "range", "autorange", "rangemode", "rangebreaks", "categoryorder", "categoryarray"], E = false, T = false;
+          function L() {
+            v = h[d], d === "rangebreaks" && (T = h._hasDayOfWeekBreaks);
+          }
+          for (s = 0; s < o.length; s++) {
+            l = o[s];
+            for (var x = 0; x < k.length; x++) {
+              d = k[x], v = null;
+              var C;
+              for (u in l) if (c = Lg(u), f = e[c], h = t[c], d in h) {
+                if (!h.matches && (C = h, d in f)) {
+                  L();
+                  break;
+                }
+                v === null && d in f && L();
+              }
+              if (d === "range" && v && f.range && f.range.length === 2 && f.range[0] !== null && f.range[1] !== null && (E = true), d === "autorange" && v === null && E && (v = false), v === null && d in C && (v = C[d]), v !== null) for (u in l) h = t[Lg(u)], h[d] = d === "range" ? v.slice() : v, d === "rangebreaks" && (h._hasDayOfWeekBreaks = T, Eft(h, t));
+            }
+          }
+        };
+        function Lft(e, t, r) {
+          var n = r.axIds, i = r.layoutOut, a = r.hasImage, o = i._axisConstraintGroups, s = i._axisMatchGroups, l = t._id, u = l.charAt(0), c = ((i._splomAxes || {})[u] || {})[l] || {}, f = t._id, h = f.charAt(0) === "x";
+          t._matchGroup = null, t._constraintGroup = null;
+          function d(z, O) {
+            return Yb.coerce(e, t, Mft, z, O);
+          }
+          d("constrain", a ? "domain" : "range"), Yb.coerce(e, t, { constraintoward: { valType: "enumerated", values: h ? ["left", "center", "right"] : ["bottom", "middle", "top"], dflt: h ? "center" : "middle" } }, "constraintoward");
+          var v = t.type, _, b, p = [];
+          for (_ = 0; _ < n.length; _++) if (b = n[_], b !== f) {
+            var k = i[Lg(b)];
+            k.type === v && p.push(b);
+          }
+          var E = kce(o, f);
+          if (E) {
+            var T = [];
+            for (_ = 0; _ < p.length; _++) b = p[_], E[b] || T.push(b);
+            p = T;
+          }
+          var L = p.length, x, C;
+          L && (e.matches || c.matches) && (x = Yb.coerce(e, t, { matches: { valType: "enumerated", values: p, dflt: p.indexOf(c.matches) !== -1 ? c.matches : void 0 } }, "matches"));
+          var M = a && !h ? t.anchor : void 0;
+          if (L && !x && (e.scaleanchor || M) && (C = Yb.coerce(e, t, { scaleanchor: { valType: "enumerated", values: p.concat([false]) } }, "scaleanchor", M)), x) {
+            t._matchGroup = yN(s, f, x, 1);
+            var g = i[Lg(x)], P = Mce(i, t) / Mce(i, g);
+            h !== (x.charAt(0) === "x") && (P = (h ? "x" : "y") + P), yN(o, f, x, P);
+          } else e.matches && n.indexOf(e.matches) !== -1 && Yb.warn("ignored " + t._name + '.matches: "' + e.matches + '" to avoid an infinite loop');
+          if (C) {
+            var A = d("scaleratio");
+            A || (A = t.scaleratio = 1), yN(o, f, C, A);
+          } else e.scaleanchor && n.indexOf(e.scaleanchor) !== -1 && Yb.warn("ignored " + t._name + '.scaleanchor: "' + e.scaleanchor + '" to avoid either an infinite loop and possibly inconsistent scaleratios, or because this axis declares a *matches* constraint.');
+        }
+        function Mce(e, t) {
+          var r = t.domain;
+          return r || (r = e[Lg(t.overlaying)].domain), r[1] - r[0];
+        }
+        function kce(e, t) {
+          for (var r = 0; r < e.length; r++) if (e[r][t]) return e[r];
+          return null;
+        }
+        function yN(e, t, r, n) {
+          var i, a, o, s, l, u = kce(e, t);
+          u === null ? (u = {}, u[t] = 1, l = e.length, e.push(u)) : l = e.indexOf(u);
+          var c = Object.keys(u);
+          for (i = 0; i < e.length; i++) if (o = e[i], i !== l && o[r]) {
+            var f = o[r];
+            for (a = 0; a < c.length; a++) s = c[a], o[s] = _N(f, _N(n, u[s]));
+            e.splice(l, 1);
+            return;
+          }
+          if (n !== 1) for (a = 0; a < c.length; a++) {
+            var h = c[a];
+            u[h] = _N(n, u[h]);
+          }
+          u[r] = 1;
+        }
+        function _N(e, t) {
+          var r = "", n = "", i, a;
+          typeof e == "string" && (r = e.match(/^[xy]*/)[0], i = r.length, e = +e.slice(i)), typeof t == "string" && (n = t.match(/^[xy]*/)[0], a = n.length, t = +t.slice(a));
+          var o = e * t;
+          return !i && !a ? o : !i || !a || r.charAt(0) === n.charAt(0) ? r + n + e * t : i === a ? o : (i > a ? r.slice(a) : n.slice(i)) + o;
+        }
+        function Pft(e, t) {
+          for (var r = t._size, n = r.h / r.w, i = {}, a = Object.keys(e), o = 0; o < a.length; o++) {
+            var s = a[o], l = e[s];
+            if (typeof l == "string") {
+              var u = l.match(/^[xy]*/)[0], c = u.length;
+              l = +l.slice(c);
+              for (var f = u.charAt(0) === "y" ? n : 1 / n, h = 0; h < c; h++) l *= f;
+            }
+            i[s] = l;
+          }
+          return i;
+        }
+        MM.enforce = function(t) {
+          var r = t._fullLayout, n = r._axisConstraintGroups || [], i, a, o, s, l, u, c, f;
+          for (i = 0; i < n.length; i++) {
+            o = Pft(n[i], r);
+            var h = Object.keys(o), d = 1 / 0, v = 0, _ = 1 / 0, b = {}, p = {}, k = false;
+            for (a = 0; a < h.length; a++) s = h[a], p[s] = l = r[Lg(s)], l._inputDomain ? l.domain = l._inputDomain.slice() : l._inputDomain = l.domain.slice(), l._inputRange || (l._inputRange = l.range.slice()), l.setScale(), b[s] = u = Math.abs(l._m) / o[s], d = Math.min(d, u), (l.constrain === "domain" || !l._constraintShrinkable) && (_ = Math.min(_, u)), delete l._constraintShrinkable, v = Math.max(v, u), l.constrain === "domain" && (k = true);
+            if (!(d > kft * v && !k)) {
+              for (a = 0; a < h.length; a++) if (s = h[a], u = b[s], l = p[s], c = l.constrain, u !== _ || c === "domain") if (f = u / _, c === "range") Sce(l, f);
+              else {
+                var E = l._inputDomain, T = (l.domain[1] - l.domain[0]) / (E[1] - E[0]), L = (l.r2l(l.range[1]) - l.r2l(l.range[0])) / (l.r2l(l._inputRange[1]) - l.r2l(l._inputRange[0]));
+                if (f /= T, f * L < 1) {
+                  l.domain = l._input.domain = E.slice(), Sce(l, f);
+                  continue;
+                }
+                if (L < 1 && (l.range = l._input.range = l._inputRange.slice(), f *= L), l.autorange) {
+                  var x = l.r2l(l.range[0]), C = l.r2l(l.range[1]), M = (x + C) / 2, g = M, P = M, A = Math.abs(C - M), z = M - A * f * 1.0001, O = M + A * f * 1.0001, U = mN.makePadFn(r, l, 0), G = mN.makePadFn(r, l, 1);
+                  Ece(l, f);
+                  var Z = Math.abs(l._m), j = mN.concatExtremes(t, l), N = j.min, H = j.max, re, oe;
+                  for (oe = 0; oe < N.length; oe++) re = N[oe].val - U(N[oe]) / Z, re > z && re < g && (g = re);
+                  for (oe = 0; oe < H.length; oe++) re = H[oe].val + G(H[oe]) / Z, re < O && re > P && (P = re);
+                  var _e = (P - g) / (2 * A);
+                  f /= _e, g = l.l2r(g), P = l.l2r(P), l.range = l._input.range = x < C ? [g, P] : [P, g];
+                }
+                Ece(l, f);
+              }
+            }
+          }
+        };
+        MM.getAxisGroup = function(t, r) {
+          for (var n = t._axisMatchGroups, i = 0; i < n.length; i++) {
+            var a = n[i];
+            if (a[r]) return "g" + i;
+          }
+          return r;
+        };
+        MM.clean = function(t, r) {
+          if (r._inputDomain) {
+            for (var n = false, i = r._id, a = t._fullLayout._axisConstraintGroups, o = 0; o < a.length; o++) if (a[o][i]) {
+              n = true;
+              break;
+            }
+            (!n || r.constrain !== "domain") && (r._input.domain = r.domain = r._inputDomain, delete r._inputDomain);
+          }
+        };
+        function Ece(e, t) {
+          var r = e._inputDomain, n = Cft[e.constraintoward], i = r[0] + (r[1] - r[0]) * n;
+          e.domain = e._input.domain = [i + (r[0] - i) / t, i + (r[1] - i) / t], e.setScale();
+        }
+      });
+      var CM = ye((pd) => {
+        var _P = Oa(), Nv = qa(), Jp = Mc(), M0 = Dr(), xN = Zl(), bN = bM(), EM = ka(), nT = So(), Cce = zb(), Dce = pN(), kM = ho(), Fy = Dh(), Fce = Kb(), Ift = Fce.enforce, Rft = Fce.clean, Lce = Mg().doAutoRange, zce = "start", Dft = "middle", Oce = "end", Fft = Rh().zindexSeparator;
+        pd.layoutStyles = function(e) {
+          return M0.syncOrAsync([Jp.doAutoMargin, Oft], e);
+        };
+        function zft(e, t, r) {
+          for (var n = 0; n < r.length; n++) {
+            var i = r[n][0], a = r[n][1];
+            if (!(i[0] >= e[1] || i[1] <= e[0]) && a[0] < t[1] && a[1] > t[0]) return true;
+          }
+          return false;
+        }
+        function Oft(e) {
+          var t = e._fullLayout, r = t._size, n = r.p, i = kM.list(e, "", true), a, o, s, l, u, c;
+          if (t._paperdiv.style({ width: e._context.responsive && t.autosize && !e._context._hasZeroWidth && !e.layout.width ? "100%" : t.width + "px", height: e._context.responsive && t.autosize && !e._context._hasZeroHeight && !e.layout.height ? "100%" : t.height + "px" }).selectAll(".main-svg").call(nT.setSize, t.width, t.height), e._context.setBackground(e, t.paper_bgcolor), pd.drawMainTitle(e), Dce.manage(e), !t._has("cartesian")) return Jp.previousPromises(e);
+          function f(Pe, me, De) {
+            var ce = Pe._lw / 2;
+            if (Pe._id.charAt(0) === "x") {
+              if (me) {
+                if (De === "top") return me._offset - n - ce;
+              } else return r.t + r.h * (1 - (Pe.position || 0)) + ce % 1;
+              return me._offset + me._length + n + ce;
+            }
+            if (me) {
+              if (De === "right") return me._offset + me._length + n + ce;
+            } else return r.l + r.w * (Pe.position || 0) + ce % 1;
+            return me._offset - n - ce;
+          }
+          for (a = 0; a < i.length; a++) {
+            l = i[a];
+            var h = l._anchorAxis;
+            l._linepositions = {}, l._lw = nT.crispRound(e, l.linewidth, 1), l._mainLinePosition = f(l, h, l.side), l._mainMirrorPosition = l.mirror && h ? f(l, h, Fy.OPPOSITE_SIDE[l.side]) : null;
+          }
+          var d = [], v = [], _ = [], b = EM.opacity(t.paper_bgcolor) === 1 && EM.opacity(t.plot_bgcolor) === 1 && t.paper_bgcolor === t.plot_bgcolor;
+          for (o in t._plots) if (s = t._plots[o], s.mainplot) s.bg && s.bg.remove(), s.bg = void 0;
+          else {
+            var p = s.xaxis.domain, k = s.yaxis.domain, E = s.plotgroup;
+            if (zft(p, k, _) && o.indexOf(Fft) === -1) {
+              var T = E.node(), L = s.bg = M0.ensureSingle(E, "rect", "bg");
+              T.insertBefore(L.node(), T.childNodes[0]), v.push(o);
+            } else E.select("rect.bg").remove(), _.push([p, k]), b || (d.push(o), v.push(o));
+          }
+          var x = t._bgLayer.selectAll(".bg").data(d);
+          for (x.enter().append("rect").classed("bg", true), x.exit().remove(), x.each(function(Pe) {
+            t._plots[Pe].bg = _P.select(this);
+          }), a = 0; a < v.length; a++) s = t._plots[v[a]], u = s.xaxis, c = s.yaxis, s.bg && u._offset !== void 0 && c._offset !== void 0 && s.bg.call(nT.setRect, u._offset - n, c._offset - n, u._length + 2 * n, c._length + 2 * n).call(EM.fill, t.plot_bgcolor).style("stroke-width", 0);
+          if (!t._hasOnlyLargeSploms) for (o in t._plots) {
+            s = t._plots[o], u = s.xaxis, c = s.yaxis;
+            var C = s.clipId = "clip" + t._uid + o + "plot", M = M0.ensureSingleById(t._clips, "clipPath", C, function(Pe) {
+              Pe.classed("plotclip", true).append("rect");
+            });
+            s.clipRect = M.select("rect").attr({ width: u._length, height: c._length }), nT.setTranslate(s.plot, u._offset, c._offset);
+            var g, P;
+            s._hasClipOnAxisFalse ? (g = null, P = C) : (g = C, P = null), nT.setClipUrl(s.plot, g, e), s.layerClipId = P;
+          }
+          var A, z, O, U, G, Z, j, N, H, re, oe, _e, Ce;
+          function Le(Pe) {
+            return "M" + A + "," + Pe + "H" + z;
+          }
+          function ge(Pe) {
+            return "M" + u._offset + "," + Pe + "h" + u._length;
+          }
+          function ie(Pe) {
+            return "M" + Pe + "," + N + "V" + j;
+          }
+          function Se(Pe) {
+            return c._shift !== void 0 && (Pe += c._shift), "M" + Pe + "," + c._offset + "v" + c._length;
+          }
+          function Ee(Pe, me, De) {
+            if (!Pe.showline || o !== Pe._mainSubplot) return "";
+            if (!Pe._anchorAxis) return De(Pe._mainLinePosition);
+            var ce = me(Pe._mainLinePosition);
+            return Pe.mirror && (ce += me(Pe._mainMirrorPosition)), ce;
+          }
+          for (o in t._plots) {
+            s = t._plots[o], u = s.xaxis, c = s.yaxis;
+            var Ae = "M0,0";
+            Pce(u, o) && (G = yP(u, "left", c, i), A = u._offset - (G ? n + G : 0), Z = yP(u, "right", c, i), z = u._offset + u._length + (Z ? n + Z : 0), O = f(u, c, "bottom"), U = f(u, c, "top"), Ce = !u._anchorAxis || o !== u._mainSubplot, Ce && (u.mirror === "allticks" || u.mirror === "all") && (u._linepositions[o] = [O, U]), Ae = Ee(u, Le, ge), Ce && u.showline && (u.mirror === "all" || u.mirror === "allticks") && (Ae += Le(O) + Le(U)), s.xlines.style("stroke-width", u._lw + "px").call(EM.stroke, u.showline ? u.linecolor : "rgba(0,0,0,0)")), s.xlines.attr("d", Ae);
+            var Be = "M0,0";
+            Pce(c, o) && (oe = yP(c, "bottom", u, i), j = c._offset + c._length + (oe ? n : 0), _e = yP(c, "top", u, i), N = c._offset - (_e ? n : 0), H = f(c, u, "left"), re = f(c, u, "right"), Ce = !c._anchorAxis || o !== c._mainSubplot, Ce && (c.mirror === "allticks" || c.mirror === "all") && (c._linepositions[o] = [H, re]), Be = Ee(c, ie, Se), Ce && c.showline && (c.mirror === "all" || c.mirror === "allticks") && (Be += ie(H) + ie(re)), s.ylines.style("stroke-width", c._lw + "px").call(EM.stroke, c.showline ? c.linecolor : "rgba(0,0,0,0)")), s.ylines.attr("d", Be);
+          }
+          return kM.makeClipPaths(e), Jp.previousPromises(e);
+        }
+        function Pce(e, t) {
+          return (e.ticks || e.showline) && (t === e._mainSubplot || e.mirror === "all" || e.mirror === "allticks");
+        }
+        function Ice(e, t, r) {
+          if (!r.showline || !r._lw) return false;
+          if (r.mirror === "all" || r.mirror === "allticks") return true;
+          var n = r._anchorAxis;
+          if (!n) return false;
+          var i = Fy.FROM_BL[t];
+          return r.side === t ? n.domain[i] === e.domain[i] : r.mirror && n.domain[1 - i] === e.domain[1 - i];
+        }
+        function yP(e, t, r, n) {
+          if (Ice(e, t, r)) return r._lw;
+          for (var i = 0; i < n.length; i++) {
+            var a = n[i];
+            if (a._mainAxis === r._mainAxis && Ice(e, t, a)) return a._lw;
+          }
+          return 0;
+        }
+        pd.drawMainTitle = function(e) {
+          var t = e._fullLayout.title, r = e._fullLayout, n = Hft(r), i = jft(r), a = Gft(r, i), o = Vft(r, n);
+          if (Cce.draw(e, "gtitle", { propContainer: r, propName: "title.text", subtitlePropName: "title.subtitle.text", placeholder: r._dfltTitle.plot, subtitlePlaceholder: r._dfltTitle.subtitle, attributes: { x: o, y: a, "text-anchor": n, dy: i } }), t.text && t.automargin) {
+            var s = _P.select(e).selectAll(".gtitle"), l = nT.bBox(_P.select(e).selectAll(".g-gtitle").node()).height, u = Nft(e, t, l);
+            if (u > 0) {
+              Uft(e, a, u, l), s.attr({ x: o, y: a, "text-anchor": n, dy: Rce(t.yanchor) }).call(xN.positionText, o, a);
+              var c = (t.text.match(xN.BR_TAG_ALL) || []).length;
+              if (c) {
+                var f = Fy.LINE_SPACING * c + Fy.MID_SHIFT;
+                t.y === 0 && (f = -f), s.selectAll(".line").each(function() {
+                  var b = +this.getAttribute("dy").slice(0, -2) - f + "em";
+                  this.setAttribute("dy", b);
+                });
+              }
+              var h = _P.select(e).selectAll(".gtitle-subtitle");
+              if (h.node()) {
+                var d = s.node().getBBox(), v = d.y + d.height, _ = v + Cce.SUBTITLE_PADDING_EM * t.subtitle.font.size;
+                h.attr({ x: o, y: _, "text-anchor": n, dy: Rce(t.yanchor) }).call(xN.positionText, o, _);
+              }
+            }
+          }
+        };
+        function qft(e, t, r, n, i) {
+          var a = t.yref === "paper" ? e._fullLayout._size.h : e._fullLayout.height, o = M0.isTopAnchor(t) ? n : n - i, s = r === "b" ? a - o : o;
+          return M0.isTopAnchor(t) && r === "t" || M0.isBottomAnchor(t) && r === "b" ? false : s < i;
+        }
+        function Bft(e, t, r, n, i) {
+          var a = 0;
+          return r === "middle" && (a += i / 2), e === "t" ? (r === "top" && (a += i), a += n - t * n) : (r === "bottom" && (a += i), a += t * n), a;
+        }
+        function Nft(e, t, r) {
+          var n = t.y, i = t.yanchor, a = n > 0.5 ? "t" : "b", o = e._fullLayout.margin[a], s = 0;
+          return t.yref === "paper" ? s = r + t.pad.t + t.pad.b : t.yref === "container" && (s = Bft(a, n, i, e._fullLayout.height, r) + t.pad.t + t.pad.b), s > o ? s : 0;
+        }
+        function Uft(e, t, r, n) {
+          var i = "title.automargin", a = e._fullLayout.title, o = a.y > 0.5 ? "t" : "b", s = { x: a.x, y: a.y, t: 0, b: 0 }, l = {};
+          a.yref === "paper" && qft(e, a, o, t, n) ? s[o] = r : a.yref === "container" && (l[o] = r, e._fullLayout._reservedMargin[i] = l), Jp.allowAutoMargin(e, i), Jp.autoMargin(e, i, s);
+        }
+        function Vft(e, t) {
+          var r = e.title, n = e._size, i = 0;
+          switch (t === zce ? i = r.pad.l : t === Oce && (i = -r.pad.r), r.xref) {
+            case "paper":
+              return n.l + n.w * r.x + i;
+            case "container":
+            default:
+              return e.width * r.x + i;
+          }
+        }
+        function Gft(e, t) {
+          var r = e.title, n = e._size, i = 0;
+          if (t === "0em" || !t ? i = -r.pad.b : t === Fy.CAP_SHIFT + "em" && (i = r.pad.t), r.y === "auto") return n.t / 2;
+          switch (r.yref) {
+            case "paper":
+              return n.t + n.h - n.h * r.y + i;
+            case "container":
+            default:
+              return e.height - e.height * r.y + i;
+          }
+        }
+        function Rce(e) {
+          return e === "top" ? Fy.CAP_SHIFT + 0.3 + "em" : e === "bottom" ? "-0.3em" : Fy.MID_SHIFT + "em";
+        }
+        function Hft(e) {
+          var t = e.title, r = Dft;
+          return M0.isRightAnchor(t) ? r = Oce : M0.isLeftAnchor(t) && (r = zce), r;
+        }
+        function jft(e) {
+          var t = e.title, r = "0em";
+          return M0.isTopAnchor(t) ? r = Fy.CAP_SHIFT + "em" : M0.isMiddleAnchor(t) && (r = Fy.MID_SHIFT + "em"), r;
+        }
+        pd.doTraceStyle = function(e) {
+          var t = e.calcdata, r = [], n;
+          for (n = 0; n < t.length; n++) {
+            var i = t[n], a = i[0] || {}, o = a.trace || {}, s = o._module || {}, l = s.arraysToCalcdata;
+            l && l(i, o);
+            var u = s.editStyle;
+            u && r.push({ fn: u, cd0: a });
+          }
+          if (r.length) {
+            for (n = 0; n < r.length; n++) {
+              var c = r[n];
+              c.fn(e, c.cd0);
+            }
+            bN(e), pd.redrawReglTraces(e);
+          }
+          return Jp.style(e), Nv.getComponentMethod("legend", "draw")(e), Jp.previousPromises(e);
+        };
+        pd.doColorBars = function(e) {
+          return Nv.getComponentMethod("colorbar", "draw")(e), Jp.previousPromises(e);
+        };
+        pd.layoutReplot = function(e) {
+          var t = e.layout;
+          return e.layout = void 0, Nv.call("_doPlot", e, "", t);
+        };
+        pd.doLegend = function(e) {
+          return Nv.getComponentMethod("legend", "draw")(e), Jp.previousPromises(e);
+        };
+        pd.doTicksRelayout = function(e) {
+          return kM.draw(e, "redraw"), e._fullLayout._hasOnlyLargeSploms && (Nv.subplotsRegistry.splom.updateGrid(e), bN(e), pd.redrawReglTraces(e)), pd.drawMainTitle(e), Jp.previousPromises(e);
+        };
+        pd.doModeBar = function(e) {
+          var t = e._fullLayout;
+          Dce.manage(e);
+          for (var r = 0; r < t._basePlotModules.length; r++) {
+            var n = t._basePlotModules[r].updateFx;
+            n && n(e);
+          }
+          return Jp.previousPromises(e);
+        };
+        pd.doCamera = function(e) {
+          for (var t = e._fullLayout, r = t._subplots.gl3d, n = 0; n < r.length; n++) {
+            var i = t[r[n]], a = i._scene;
+            a.setViewport(i);
+          }
+        };
+        pd.drawData = function(e) {
+          var t = e._fullLayout;
+          bN(e);
+          for (var r = t._basePlotModules, n = 0; n < r.length; n++) r[n].plot(e);
+          return pd.redrawReglTraces(e), Jp.style(e), Nv.getComponentMethod("selections", "draw")(e), Nv.getComponentMethod("shapes", "draw")(e), Nv.getComponentMethod("annotations", "draw")(e), Nv.getComponentMethod("images", "draw")(e), t._replotting = false, Jp.previousPromises(e);
+        };
+        pd.redrawReglTraces = function(e) {
+          var t = e._fullLayout;
+          if (t._has("regl")) {
+            var r = e._fullData, n = [], i = [], a, o;
+            for (t._hasOnlyLargeSploms && t._splomGrid.draw(), a = 0; a < r.length; a++) {
+              var s = r[a];
+              s.visible === true && s._length !== 0 && (s.type === "splom" ? t._splomScenes[s.uid].draw() : s.type === "scattergl" ? M0.pushUnique(n, s.xaxis + s.yaxis) : s.type === "scatterpolargl" && M0.pushUnique(i, s.subplot));
+            }
+            for (a = 0; a < n.length; a++) o = t._plots[n[a]], o._scene && o._scene.draw();
+            for (a = 0; a < i.length; a++) o = t[i[a]]._subplot, o._scene && o._scene.draw();
+          }
+        };
+        pd.doAutoRangeAndConstraints = function(e) {
+          for (var t = kM.list(e, "", true), r, n = {}, i = 0; i < t.length; i++) if (r = t[i], !n[r._id]) {
+            n[r._id] = 1, Rft(e, r), Lce(e, r);
+            var a = r._matchGroup;
+            if (a) for (var o in a) {
+              var s = kM.getFromId(e, o);
+              Lce(e, s, r.range), n[o] = 1;
+            }
+          }
+          Ift(e);
+        };
+        pd.finalDraw = function(e) {
+          Nv.getComponentMethod("rangeslider", "draw")(e), Nv.getComponentMethod("rangeselector", "draw")(e);
+        };
+        pd.drawMarginPushers = function(e) {
+          Nv.getComponentMethod("legend", "draw")(e), Nv.getComponentMethod("rangeselector", "draw")(e), Nv.getComponentMethod("sliders", "draw")(e), Nv.getComponentMethod("updatemenus", "draw")(e), Nv.getComponentMethod("colorbar", "draw")(e);
+        };
+      });
+      var AN = ye((aor, Vce) => {
+        var Wft = m_().readPaths, Xft = lP(), qce = o_().clearOutlineControllers, wN = ka(), Bce = So(), Zft = vl().arrayEditor, Nce = x_(), Yft = Nce.getPathString;
+        Vce.exports = { draw: xP, drawOne: Uce, activateLastSelection: $ft };
+        function xP(e) {
+          var t = e._fullLayout;
+          qce(e), t._selectionLayer.selectAll("path").remove();
+          for (var r in t._plots) {
+            var n = t._plots[r].selectionLayer;
+            n && n.selectAll("path").remove();
+          }
+          for (var i = 0; i < t.selections.length; i++) Uce(e, i);
+        }
+        function bP(e) {
+          return e._context.editSelection;
+        }
+        function Uce(e, t) {
+          e._fullLayout._paperdiv.selectAll('.selectionlayer [data-index="' + t + '"]').remove();
+          var r = Nce.makeSelectionsOptionsAndPlotinfo(e, t), n = r.options, i = r.plotinfo;
+          if (!n._input) return;
+          a(e._fullLayout._selectionLayer);
+          function a(o) {
+            var s = Yft(e, n), l = { "data-index": t, "fill-rule": "evenodd", d: s }, u = n.opacity, c = "rgba(0,0,0,0)", f = n.line.color || wN.contrast(e._fullLayout.plot_bgcolor), h = n.line.width, d = n.line.dash;
+            h || (h = 5, d = "solid");
+            var v = bP(e) && e._fullLayout._activeSelectionIndex === t;
+            v && (c = e._fullLayout.activeselection.fillcolor, u = e._fullLayout.activeselection.opacity);
+            for (var _ = [], b = 1; b >= 0; b--) {
+              var p = o.append("path").attr(l).style("opacity", b ? 0.1 : u).call(wN.stroke, f).call(wN.fill, c).call(Bce.dashLine, b ? "solid" : d, b ? 4 + h : h);
+              if (Kft(p, e, n), v) {
+                var k = Zft(e.layout, "selections", n);
+                p.style({ cursor: "move" });
+                var E = { element: p.node(), plotinfo: i, gd: e, editHelpers: k, isActiveSelection: true }, T = Wft(s, e);
+                Xft(T, p, E);
+              } else p.style("pointer-events", b ? "all" : "none");
+              _[b] = p;
+            }
+            var L = _[0], x = _[1];
+            x.node().addEventListener("click", function() {
+              return Jft(e, L);
+            });
+          }
+        }
+        function Kft(e, t, r) {
+          var n = r.xref + r.yref;
+          Bce.setClipUrl(e, "clip" + t._fullLayout._uid + n, t);
+        }
+        function Jft(e, t) {
+          if (bP(e)) {
+            var r = t.node(), n = +r.getAttribute("data-index");
+            if (n >= 0) {
+              if (n === e._fullLayout._activeSelectionIndex) {
+                TN(e);
+                return;
+              }
+              e._fullLayout._activeSelectionIndex = n, e._fullLayout._deactivateSelection = TN, xP(e);
+            }
+          }
+        }
+        function $ft(e) {
+          if (bP(e)) {
+            var t = e._fullLayout.selections.length - 1;
+            e._fullLayout._activeSelectionIndex = t, e._fullLayout._deactivateSelection = TN, xP(e);
+          }
+        }
+        function TN(e) {
+          if (bP(e)) {
+            var t = e._fullLayout._activeSelectionIndex;
+            t >= 0 && (qce(e), delete e._fullLayout._activeSelectionIndex, xP(e));
+          }
+        }
+      });
+      var Hce = ye((oor, Gce) => {
+        function Qft() {
+          var e, t = 0, r = false;
+          function n(i, a) {
+            return e.list.push({ type: i, data: a ? JSON.parse(JSON.stringify(a)) : void 0 }), e;
+          }
+          return e = { list: [], segmentId: function() {
+            return t++;
+          }, checkIntersection: function(i, a) {
+            return n("check", { seg1: i, seg2: a });
+          }, segmentChop: function(i, a) {
+            return n("div_seg", { seg: i, pt: a }), n("chop", { seg: i, pt: a });
+          }, statusRemove: function(i) {
+            return n("pop_seg", { seg: i });
+          }, segmentUpdate: function(i) {
+            return n("seg_update", { seg: i });
+          }, segmentNew: function(i, a) {
+            return n("new_seg", { seg: i, primary: a });
+          }, segmentRemove: function(i) {
+            return n("rem_seg", { seg: i });
+          }, tempStatus: function(i, a, o) {
+            return n("temp_status", { seg: i, above: a, below: o });
+          }, rewind: function(i) {
+            return n("rewind", { seg: i });
+          }, status: function(i, a, o) {
+            return n("status", { seg: i, above: a, below: o });
+          }, vert: function(i) {
+            return i === r ? e : (r = i, n("vert", { x: i }));
+          }, log: function(i) {
+            return typeof i != "string" && (i = JSON.stringify(i, false, "  ")), n("log", { txt: i });
+          }, reset: function() {
+            return n("reset");
+          }, selected: function(i) {
+            return n("selected", { segs: i });
+          }, chainStart: function(i) {
+            return n("chain_start", { seg: i });
+          }, chainRemoveHead: function(i, a) {
+            return n("chain_rem_head", { index: i, pt: a });
+          }, chainRemoveTail: function(i, a) {
+            return n("chain_rem_tail", { index: i, pt: a });
+          }, chainNew: function(i, a) {
+            return n("chain_new", { pt1: i, pt2: a });
+          }, chainMatch: function(i) {
+            return n("chain_match", { index: i });
+          }, chainClose: function(i) {
+            return n("chain_close", { index: i });
+          }, chainAddHead: function(i, a) {
+            return n("chain_add_head", { index: i, pt: a });
+          }, chainAddTail: function(i, a) {
+            return n("chain_add_tail", { index: i, pt: a });
+          }, chainConnect: function(i, a) {
+            return n("chain_con", { index1: i, index2: a });
+          }, chainReverse: function(i) {
+            return n("chain_rev", { index: i });
+          }, chainJoin: function(i, a) {
+            return n("chain_join", { index1: i, index2: a });
+          }, done: function() {
+            return n("done");
+          } }, e;
+        }
+        Gce.exports = Qft;
+      });
+      var Wce = ye((sor, jce) => {
+        function eht(e) {
+          typeof e != "number" && (e = 1e-10);
+          var t = { epsilon: function(r) {
+            return typeof r == "number" && (e = r), e;
+          }, pointAboveOrOnLine: function(r, n, i) {
+            var a = n[0], o = n[1], s = i[0], l = i[1], u = r[0], c = r[1];
+            return (s - a) * (c - o) - (l - o) * (u - a) >= -e;
+          }, pointBetween: function(r, n, i) {
+            var a = r[1] - n[1], o = i[0] - n[0], s = r[0] - n[0], l = i[1] - n[1], u = s * o + a * l;
+            if (u < e) return false;
+            var c = o * o + l * l;
+            return !(u - c > -e);
+          }, pointsSameX: function(r, n) {
+            return Math.abs(r[0] - n[0]) < e;
+          }, pointsSameY: function(r, n) {
+            return Math.abs(r[1] - n[1]) < e;
+          }, pointsSame: function(r, n) {
+            return t.pointsSameX(r, n) && t.pointsSameY(r, n);
+          }, pointsCompare: function(r, n) {
+            return t.pointsSameX(r, n) ? t.pointsSameY(r, n) ? 0 : r[1] < n[1] ? -1 : 1 : r[0] < n[0] ? -1 : 1;
+          }, pointsCollinear: function(r, n, i) {
+            var a = r[0] - n[0], o = r[1] - n[1], s = n[0] - i[0], l = n[1] - i[1];
+            return Math.abs(a * l - s * o) < e;
+          }, linesIntersect: function(r, n, i, a) {
+            var o = n[0] - r[0], s = n[1] - r[1], l = a[0] - i[0], u = a[1] - i[1], c = o * u - s * l;
+            if (Math.abs(c) < e) return false;
+            var f = r[0] - i[0], h = r[1] - i[1], d = (l * h - u * f) / c, v = (o * h - s * f) / c, _ = { alongA: 0, alongB: 0, pt: [r[0] + d * o, r[1] + d * s] };
+            return d <= -e ? _.alongA = -2 : d < e ? _.alongA = -1 : d - 1 <= -e ? _.alongA = 0 : d - 1 < e ? _.alongA = 1 : _.alongA = 2, v <= -e ? _.alongB = -2 : v < e ? _.alongB = -1 : v - 1 <= -e ? _.alongB = 0 : v - 1 < e ? _.alongB = 1 : _.alongB = 2, _;
+          }, pointInsideRegion: function(r, n) {
+            for (var i = r[0], a = r[1], o = n[n.length - 1][0], s = n[n.length - 1][1], l = false, u = 0; u < n.length; u++) {
+              var c = n[u][0], f = n[u][1];
+              f - a > e != s - a > e && (o - c) * (a - f) / (s - f) + c - i > e && (l = !l), o = c, s = f;
+            }
+            return l;
+          } };
+          return t;
+        }
+        jce.exports = eht;
+      });
+      var Zce = ye((lor, Xce) => {
+        var tht = { create: function() {
+          var e = { root: { root: true, next: null }, exists: function(t) {
+            return !(t === null || t === e.root);
+          }, isEmpty: function() {
+            return e.root.next === null;
+          }, getHead: function() {
+            return e.root.next;
+          }, insertBefore: function(t, r) {
+            for (var n = e.root, i = e.root.next; i !== null; ) {
+              if (r(i)) {
+                t.prev = i.prev, t.next = i, i.prev.next = t, i.prev = t;
+                return;
+              }
+              n = i, i = i.next;
+            }
+            n.next = t, t.prev = n, t.next = null;
+          }, findTransition: function(t) {
+            for (var r = e.root, n = e.root.next; n !== null && !t(n); ) r = n, n = n.next;
+            return { before: r === e.root ? null : r, after: n, insert: function(i) {
+              return i.prev = r, i.next = n, r.next = i, n !== null && (n.prev = i), i;
+            } };
+          } };
+          return e;
+        }, node: function(e) {
+          return e.prev = null, e.next = null, e.remove = function() {
+            e.prev.next = e.next, e.next && (e.next.prev = e.prev), e.prev = null, e.next = null;
+          }, e;
+        } };
+        Xce.exports = tht;
+      });
+      var Kce = ye((uor, Yce) => {
+        var LM = Zce();
+        function rht(e, t, r) {
+          function n(v, _) {
+            return { id: r ? r.segmentId() : -1, start: v, end: _, myFill: { above: null, below: null }, otherFill: null };
+          }
+          function i(v, _, b) {
+            return { id: r ? r.segmentId() : -1, start: v, end: _, myFill: { above: b.myFill.above, below: b.myFill.below }, otherFill: null };
+          }
+          var a = LM.create();
+          function o(v, _, b, p, k, E) {
+            var T = t.pointsCompare(_, k);
+            return T !== 0 ? T : t.pointsSame(b, E) ? 0 : v !== p ? v ? 1 : -1 : t.pointAboveOrOnLine(b, p ? k : E, p ? E : k) ? 1 : -1;
+          }
+          function s(v, _) {
+            a.insertBefore(v, function(b) {
+              var p = o(v.isStart, v.pt, _, b.isStart, b.pt, b.other.pt);
+              return p < 0;
+            });
+          }
+          function l(v, _) {
+            var b = LM.node({ isStart: true, pt: v.start, seg: v, primary: _, other: null, status: null });
+            return s(b, v.end), b;
+          }
+          function u(v, _, b) {
+            var p = LM.node({ isStart: false, pt: _.end, seg: _, primary: b, other: v, status: null });
+            v.other = p, s(p, v.pt);
+          }
+          function c(v, _) {
+            var b = l(v, _);
+            return u(b, v, _), b;
+          }
+          function f(v, _) {
+            r && r.segmentChop(v.seg, _), v.other.remove(), v.seg.end = _, v.other.pt = _, s(v.other, v.pt);
+          }
+          function h(v, _) {
+            var b = i(_, v.seg.end, v.seg);
+            return f(v, _), c(b, v.primary);
+          }
+          function d(v, _) {
+            var b = LM.create();
+            function p(G, Z) {
+              var j = G.seg.start, N = G.seg.end, H = Z.seg.start, re = Z.seg.end;
+              return t.pointsCollinear(j, H, re) ? t.pointsCollinear(N, H, re) || t.pointAboveOrOnLine(N, H, re) ? 1 : -1 : t.pointAboveOrOnLine(j, H, re) ? 1 : -1;
+            }
+            function k(G) {
+              return b.findTransition(function(Z) {
+                var j = p(G, Z.ev);
+                return j > 0;
+              });
+            }
+            function E(G, Z) {
+              var j = G.seg, N = Z.seg, H = j.start, re = j.end, oe = N.start, _e = N.end;
+              r && r.checkIntersection(j, N);
+              var Ce = t.linesIntersect(H, re, oe, _e);
+              if (Ce === false) {
+                if (!t.pointsCollinear(H, re, oe) || t.pointsSame(H, _e) || t.pointsSame(re, oe)) return false;
+                var Le = t.pointsSame(H, oe), ge = t.pointsSame(re, _e);
+                if (Le && ge) return Z;
+                var ie = !Le && t.pointBetween(H, oe, _e), Se = !ge && t.pointBetween(re, oe, _e);
+                if (Le) return Se ? h(Z, re) : h(G, _e), Z;
+                ie && (ge || (Se ? h(Z, re) : h(G, _e)), h(Z, H));
+              } else Ce.alongA === 0 && (Ce.alongB === -1 ? h(G, oe) : Ce.alongB === 0 ? h(G, Ce.pt) : Ce.alongB === 1 && h(G, _e)), Ce.alongB === 0 && (Ce.alongA === -1 ? h(Z, H) : Ce.alongA === 0 ? h(Z, Ce.pt) : Ce.alongA === 1 && h(Z, re));
+              return false;
+            }
+            for (var T = []; !a.isEmpty(); ) {
+              var L = a.getHead();
+              if (r && r.vert(L.pt[0]), L.isStart) {
+                let G = function() {
+                  if (C) {
+                    var Z = E(L, C);
+                    if (Z) return Z;
+                  }
+                  return M ? E(L, M) : false;
+                };
+                r && r.segmentNew(L.seg, L.primary);
+                var x = k(L), C = x.before ? x.before.ev : null, M = x.after ? x.after.ev : null;
+                r && r.tempStatus(L.seg, C ? C.seg : false, M ? M.seg : false);
+                var g = G();
+                if (g) {
+                  if (e) {
+                    var P;
+                    L.seg.myFill.below === null ? P = true : P = L.seg.myFill.above !== L.seg.myFill.below, P && (g.seg.myFill.above = !g.seg.myFill.above);
+                  } else g.seg.otherFill = L.seg.myFill;
+                  r && r.segmentUpdate(g.seg), L.other.remove(), L.remove();
+                }
+                if (a.getHead() !== L) {
+                  r && r.rewind(L.seg);
+                  continue;
+                }
+                if (e) {
+                  var P;
+                  L.seg.myFill.below === null ? P = true : P = L.seg.myFill.above !== L.seg.myFill.below, M ? L.seg.myFill.below = M.seg.myFill.above : L.seg.myFill.below = v, P ? L.seg.myFill.above = !L.seg.myFill.below : L.seg.myFill.above = L.seg.myFill.below;
+                } else if (L.seg.otherFill === null) {
+                  var A;
+                  M ? L.primary === M.primary ? A = M.seg.otherFill.above : A = M.seg.myFill.above : A = L.primary ? _ : v, L.seg.otherFill = { above: A, below: A };
+                }
+                r && r.status(L.seg, C ? C.seg : false, M ? M.seg : false), L.other.status = x.insert(LM.node({ ev: L }));
+              } else {
+                var z = L.status;
+                if (z === null) throw new Error("PolyBool: Zero-length segment detected; your epsilon is probably too small or too large");
+                if (b.exists(z.prev) && b.exists(z.next) && E(z.prev.ev, z.next.ev), r && r.statusRemove(z.ev.seg), z.remove(), !L.primary) {
+                  var O = L.seg.myFill;
+                  L.seg.myFill = L.seg.otherFill, L.seg.otherFill = O;
+                }
+                T.push(L.seg);
+              }
+              a.getHead().remove();
+            }
+            return r && r.done(), T;
+          }
+          return e ? { addRegion: function(v) {
+            for (var _, b = v[v.length - 1], p = 0; p < v.length; p++) {
+              _ = b, b = v[p];
+              var k = t.pointsCompare(_, b);
+              k !== 0 && c(n(k < 0 ? _ : b, k < 0 ? b : _), true);
+            }
+          }, calculate: function(v) {
+            return d(v, false);
+          } } : { calculate: function(v, _, b, p) {
+            return v.forEach(function(k) {
+              c(i(k.start, k.end, k), true);
+            }), b.forEach(function(k) {
+              c(i(k.start, k.end, k), false);
+            }), d(_, p);
+          } };
+        }
+        Yce.exports = rht;
+      });
+      var $ce = ye((cor, Jce) => {
+        function iht(e, t, r) {
+          var n = [], i = [];
+          return e.forEach(function(a) {
+            var o = a.start, s = a.end;
+            if (t.pointsSame(o, s)) {
+              console.warn("PolyBool: Warning: Zero-length segment detected; your epsilon is probably too small or too large");
+              return;
+            }
+            r && r.chainStart(a);
+            var l = { index: 0, matches_head: false, matches_pt1: false }, u = { index: 0, matches_head: false, matches_pt1: false }, c = l;
+            function f(U, G, Z) {
+              return c.index = U, c.matches_head = G, c.matches_pt1 = Z, c === l ? (c = u, false) : (c = null, true);
+            }
+            for (var h = 0; h < n.length; h++) {
+              var d = n[h], v = d[0];
+              d[1];
+              var b = d[d.length - 1];
+              d[d.length - 2];
+              if (t.pointsSame(v, o)) {
+                if (f(h, true, true)) break;
+              } else if (t.pointsSame(v, s)) {
+                if (f(h, true, false)) break;
+              } else if (t.pointsSame(b, o)) {
+                if (f(h, false, true)) break;
+              } else if (t.pointsSame(b, s) && f(h, false, false)) break;
+            }
+            if (c === l) {
+              n.push([o, s]), r && r.chainNew(o, s);
+              return;
+            }
+            if (c === u) {
+              r && r.chainMatch(l.index);
+              var k = l.index, E = l.matches_pt1 ? s : o, T = l.matches_head, d = n[k], L = T ? d[0] : d[d.length - 1], x = T ? d[1] : d[d.length - 2], C = T ? d[d.length - 1] : d[0], M = T ? d[d.length - 2] : d[1];
+              if (t.pointsCollinear(x, L, E) && (T ? (r && r.chainRemoveHead(l.index, E), d.shift()) : (r && r.chainRemoveTail(l.index, E), d.pop()), L = x), t.pointsSame(C, E)) {
+                n.splice(k, 1), t.pointsCollinear(M, C, L) && (T ? (r && r.chainRemoveTail(l.index, L), d.pop()) : (r && r.chainRemoveHead(l.index, L), d.shift())), r && r.chainClose(l.index), i.push(d);
+                return;
+              }
+              T ? (r && r.chainAddHead(l.index, E), d.unshift(E)) : (r && r.chainAddTail(l.index, E), d.push(E));
+              return;
+            }
+            function g(U) {
+              r && r.chainReverse(U), n[U].reverse();
+            }
+            function P(U, G) {
+              var Z = n[U], j = n[G], N = Z[Z.length - 1], H = Z[Z.length - 2], re = j[0], oe = j[1];
+              t.pointsCollinear(H, N, re) && (r && r.chainRemoveTail(U, N), Z.pop(), N = H), t.pointsCollinear(N, re, oe) && (r && r.chainRemoveHead(G, re), j.shift()), r && r.chainJoin(U, G), n[U] = Z.concat(j), n.splice(G, 1);
+            }
+            var A = l.index, z = u.index;
+            r && r.chainConnect(A, z);
+            var O = n[A].length < n[z].length;
+            l.matches_head ? u.matches_head ? O ? (g(A), P(A, z)) : (g(z), P(z, A)) : P(z, A) : u.matches_head ? P(A, z) : O ? (g(A), P(z, A)) : (g(z), P(A, z));
+          }), i;
+        }
+        Jce.exports = iht;
+      });
+      var efe = ye((hor, Qce) => {
+        function PM(e, t, r) {
+          var n = [];
+          return e.forEach(function(i) {
+            var a = (i.myFill.above ? 8 : 0) + (i.myFill.below ? 4 : 0) + (i.otherFill && i.otherFill.above ? 2 : 0) + (i.otherFill && i.otherFill.below ? 1 : 0);
+            t[a] !== 0 && n.push({ id: r ? r.segmentId() : -1, start: i.start, end: i.end, myFill: { above: t[a] === 1, below: t[a] === 2 }, otherFill: null });
+          }), r && r.selected(n), n;
+        }
+        var nht = { union: function(e, t) {
+          return PM(e, [0, 2, 1, 0, 2, 2, 0, 0, 1, 0, 1, 0, 0, 0, 0, 0], t);
+        }, intersect: function(e, t) {
+          return PM(e, [0, 0, 0, 0, 0, 2, 0, 2, 0, 0, 1, 1, 0, 2, 1, 0], t);
+        }, difference: function(e, t) {
+          return PM(e, [0, 0, 0, 0, 2, 0, 2, 0, 1, 1, 0, 0, 0, 1, 2, 0], t);
+        }, differenceRev: function(e, t) {
+          return PM(e, [0, 2, 1, 0, 0, 0, 1, 1, 0, 2, 0, 2, 0, 0, 0, 0], t);
+        }, xor: function(e, t) {
+          return PM(e, [0, 2, 1, 0, 2, 0, 0, 1, 1, 0, 0, 2, 0, 1, 2, 0], t);
+        } };
+        Qce.exports = nht;
+      });
+      var rfe = ye((dor, tfe) => {
+        var aht = { toPolygon: function(e, t) {
+          function r(a) {
+            if (a.length <= 0) return e.segments({ inverted: false, regions: [] });
+            function o(u) {
+              var c = u.slice(0, u.length - 1);
+              return e.segments({ inverted: false, regions: [c] });
+            }
+            for (var s = o(a[0]), l = 1; l < a.length; l++) s = e.selectDifference(e.combine(s, o(a[l])));
+            return s;
+          }
+          if (t.type === "Polygon") return e.polygon(r(t.coordinates));
+          if (t.type === "MultiPolygon") {
+            for (var n = e.segments({ inverted: false, regions: [] }), i = 0; i < t.coordinates.length; i++) n = e.selectUnion(e.combine(n, r(t.coordinates[i])));
+            return e.polygon(n);
+          }
+          throw new Error("PolyBool: Cannot convert GeoJSON object to PolyBool polygon");
+        }, fromPolygon: function(e, t, r) {
+          r = e.polygon(e.segments(r));
+          function n(d, v) {
+            return t.pointInsideRegion([(d[0][0] + d[1][0]) * 0.5, (d[0][1] + d[1][1]) * 0.5], v);
+          }
+          function i(d) {
+            return { region: d, children: [] };
+          }
+          var a = i(null);
+          function o(d, v) {
+            for (var _ = 0; _ < d.children.length; _++) {
+              var b = d.children[_];
+              if (n(v, b.region)) {
+                o(b, v);
+                return;
+              }
+            }
+            for (var p = i(v), _ = 0; _ < d.children.length; _++) {
+              var b = d.children[_];
+              n(b.region, v) && (p.children.push(b), d.children.splice(_, 1), _--);
+            }
+            d.children.push(p);
+          }
+          for (var s = 0; s < r.regions.length; s++) {
+            var l = r.regions[s];
+            l.length < 3 || o(a, l);
+          }
+          function u(d, v) {
+            for (var _ = 0, b = d[d.length - 1][0], p = d[d.length - 1][1], k = [], E = 0; E < d.length; E++) {
+              var T = d[E][0], L = d[E][1];
+              k.push([T, L]), _ += L * b - T * p, b = T, p = L;
+            }
+            var x = _ < 0;
+            return x !== v && k.reverse(), k.push([k[0][0], k[0][1]]), k;
+          }
+          var c = [];
+          function f(d) {
+            var v = [u(d.region, false)];
+            c.push(v);
+            for (var _ = 0; _ < d.children.length; _++) v.push(h(d.children[_]));
+          }
+          function h(d) {
+            for (var v = 0; v < d.children.length; v++) f(d.children[v]);
+            return u(d.region, true);
+          }
+          for (var s = 0; s < a.children.length; s++) f(a.children[s]);
+          return c.length <= 0 ? { type: "Polygon", coordinates: [] } : c.length == 1 ? { type: "Polygon", coordinates: c[0] } : { type: "MultiPolygon", coordinates: c };
+        } };
+        tfe.exports = aht;
+      });
+      var ofe = ye((vor, afe) => {
+        var oht = Hce(), sht = Wce(), ife = Kce(), lht = $ce(), IM = efe(), nfe = rfe(), E0 = false, RM = sht(), kp;
+        kp = { buildLog: function(e) {
+          return e === true ? E0 = oht() : e === false && (E0 = false), E0 === false ? false : E0.list;
+        }, epsilon: function(e) {
+          return RM.epsilon(e);
+        }, segments: function(e) {
+          var t = ife(true, RM, E0);
+          return e.regions.forEach(t.addRegion), { segments: t.calculate(e.inverted), inverted: e.inverted };
+        }, combine: function(e, t) {
+          var r = ife(false, RM, E0);
+          return { combined: r.calculate(e.segments, e.inverted, t.segments, t.inverted), inverted1: e.inverted, inverted2: t.inverted };
+        }, selectUnion: function(e) {
+          return { segments: IM.union(e.combined, E0), inverted: e.inverted1 || e.inverted2 };
+        }, selectIntersect: function(e) {
+          return { segments: IM.intersect(e.combined, E0), inverted: e.inverted1 && e.inverted2 };
+        }, selectDifference: function(e) {
+          return { segments: IM.difference(e.combined, E0), inverted: e.inverted1 && !e.inverted2 };
+        }, selectDifferenceRev: function(e) {
+          return { segments: IM.differenceRev(e.combined, E0), inverted: !e.inverted1 && e.inverted2 };
+        }, selectXor: function(e) {
+          return { segments: IM.xor(e.combined, E0), inverted: e.inverted1 !== e.inverted2 };
+        }, polygon: function(e) {
+          return { regions: lht(e.segments, RM, E0), inverted: e.inverted };
+        }, polygonFromGeoJSON: function(e) {
+          return nfe.toPolygon(kp, e);
+        }, polygonToGeoJSON: function(e) {
+          return nfe.fromPolygon(kp, RM, e);
+        }, union: function(e, t) {
+          return DM(e, t, kp.selectUnion);
+        }, intersect: function(e, t) {
+          return DM(e, t, kp.selectIntersect);
+        }, difference: function(e, t) {
+          return DM(e, t, kp.selectDifference);
+        }, differenceRev: function(e, t) {
+          return DM(e, t, kp.selectDifferenceRev);
+        }, xor: function(e, t) {
+          return DM(e, t, kp.selectXor);
+        } };
+        function DM(e, t, r) {
+          var n = kp.segments(e), i = kp.segments(t), a = kp.combine(n, i), o = r(a);
+          return kp.polygon(o);
+        }
+        typeof window == "object" && (window.PolyBool = kp);
+        afe.exports = kp;
+      });
+      var lfe = ye((por, sfe) => {
+        sfe.exports = function(t, r, n, i) {
+          var a = t[0], o = t[1], s = false;
+          n === void 0 && (n = 0), i === void 0 && (i = r.length);
+          for (var l = i - n, u = 0, c = l - 1; u < l; c = u++) {
+            var f = r[u + n][0], h = r[u + n][1], d = r[c + n][0], v = r[c + n][1], _ = h > o != v > o && a < (d - f) * (o - h) / (v - h) + f;
+            _ && (s = !s);
+          }
+          return s;
+        };
+      });
+      var FM = ye((gor, ufe) => {
+        var SN = P6().dot, wP = fs().BADNUM, TP = ufe.exports = {};
+        TP.tester = function(t) {
+          var r = t.slice(), n = r[0][0], i = n, a = r[0][1], o = a, s;
+          for ((r[r.length - 1][0] !== r[0][0] || r[r.length - 1][1] !== r[0][1]) && r.push(r[0]), s = 1; s < r.length; s++) n = Math.min(n, r[s][0]), i = Math.max(i, r[s][0]), a = Math.min(a, r[s][1]), o = Math.max(o, r[s][1]);
+          var l = false, u;
+          r.length === 5 && (r[0][0] === r[1][0] ? r[2][0] === r[3][0] && r[0][1] === r[3][1] && r[1][1] === r[2][1] && (l = true, u = function(v) {
+            return v[0] === r[0][0];
+          }) : r[0][1] === r[1][1] && r[2][1] === r[3][1] && r[0][0] === r[3][0] && r[1][0] === r[2][0] && (l = true, u = function(v) {
+            return v[1] === r[0][1];
+          }));
+          function c(v, _) {
+            var b = v[0], p = v[1];
+            return !(b === wP || b < n || b > i || p === wP || p < a || p > o || _ && u(v));
+          }
+          function f(v, _) {
+            var b = v[0], p = v[1];
+            if (b === wP || b < n || b > i || p === wP || p < a || p > o) return false;
+            var k = r.length, E = r[0][0], T = r[0][1], L = 0, x, C, M, g, P;
+            for (x = 1; x < k; x++) if (C = E, M = T, E = r[x][0], T = r[x][1], g = Math.min(C, E), !(b < g || b > Math.max(C, E) || p > Math.max(M, T))) if (p < Math.min(M, T)) b !== g && L++;
+            else {
+              if (E === C ? P = p : P = M + (b - C) * (T - M) / (E - C), p === P) return !(x === 1 && _);
+              p <= P && b !== g && L++;
+            }
+            return L % 2 === 1;
+          }
+          var h = true, d = r[0];
+          for (s = 1; s < r.length; s++) if (d[0] !== r[s][0] || d[1] !== r[s][1]) {
+            h = false;
+            break;
+          }
+          return { xmin: n, xmax: i, ymin: a, ymax: o, pts: r, contains: l ? c : f, isRect: l, degenerate: h };
+        };
+        TP.isSegmentBent = function(t, r, n, i) {
+          var a = t[r], o = [t[n][0] - a[0], t[n][1] - a[1]], s = SN(o, o), l = Math.sqrt(s), u = [-o[1] / l, o[0] / l], c, f, h;
+          for (c = r + 1; c < n; c++) if (f = [t[c][0] - a[0], t[c][1] - a[1]], h = SN(f, o), h < 0 || h > s || Math.abs(SN(f, u)) > i) return true;
+          return false;
+        };
+        TP.filter = function(t, r) {
+          var n = [t[0]], i = 0, a = 0;
+          function o(l) {
+            t.push(l);
+            var u = n.length, c = i;
+            n.splice(a + 1);
+            for (var f = c + 1; f < t.length; f++) (f === t.length - 1 || TP.isSegmentBent(t, c, f + 1, r)) && (n.push(t[f]), n.length < u - 2 && (i = f, a = n.length - 1), c = f);
+          }
+          if (t.length > 1) {
+            var s = t.pop();
+            o(s);
+          }
+          return { addPt: o, raw: t, filtered: n };
+        };
+      });
+      var ffe = ye((mor, cfe) => {
+        cfe.exports = { BENDPX: 1.5, MINSELECT: 12, SELECTDELAY: 100, SELECTID: "-select" };
+      });
+      var Rfe = ye((yor, Ife) => {
+        var hfe = ofe(), uht = lfe(), qM = qa(), cht = So().dashStyle, zM = ka(), fht = vf(), hht = ip().makeEventData, GM = Cg(), dht = GM.freeMode, vht = GM.rectMode, BM = GM.drawMode, CN = GM.openMode, LN = GM.selectMode, dfe = x_(), vfe = TM(), _fe = lP(), xfe = o_().clearOutline, bfe = m_(), MN = bfe.handleEllipse, pht = bfe.readPaths, ght = aP().newShapes, mht = QB(), yht = AN().activateLastSelection, SP = Dr(), _ht = SP.sorterAsc, wfe = FM(), OM = H6(), k0 = hf().getFromId, xht = bM(), bht = CM().redrawReglTraces, MP = ffe(), Cm = MP.MINSELECT, wht = wfe.filter, PN = wfe.tester, IN = tP(), pfe = IN.p2r, Tht = IN.axValue, Aht = IN.getTransform;
+        function RN(e) {
+          return e.subplot !== void 0;
+        }
+        function Sht(e, t, r, n, i) {
+          var a = !RN(n), o = dht(i), s = vht(i), l = CN(i), u = BM(i), c = LN(i), f = i === "drawline", h = i === "drawcircle", d = f || h, v = n.gd, _ = v._fullLayout, b = c && _.newselection.mode === "immediate" && a, p = _._zoomlayer, k = n.element.getBoundingClientRect(), E = n.plotinfo, T = Aht(E), L = t - k.left, x = r - k.top;
+          _._calcInverseTransform(v);
+          var C = SP.apply3DTransform(_._invTransform)(L, x);
+          L = C[0], x = C[1];
+          var M = _._invScaleX, g = _._invScaleY, P = L, A = x, z = "M" + L + "," + x, O = n.xaxes[0], U = n.yaxes[0], G = O._length, Z = U._length, j = e.altKey && !(BM(i) && l), N, H, re, oe, _e, Ce, Le;
+          Afe(e, v, n), o && (N = wht([[L, x]], MP.BENDPX));
+          var ge = p.selectAll("path.select-outline-" + E.id).data([1]), ie = u ? _.newshape : _.newselection;
+          u && (n.hasText = ie.label.text || ie.label.texttemplate);
+          var Se = u && !l ? ie.fillcolor : "rgba(0,0,0,0)", Ee = ie.line.color || (a ? zM.contrast(v._fullLayout.plot_bgcolor) : "#7f7f7f");
+          ge.enter().append("path").attr("class", "select-outline select-outline-" + E.id).style({ opacity: u ? ie.opacity / 2 : 1, "stroke-dasharray": cht(ie.line.dash, ie.line.width), "stroke-width": ie.line.width + "px", "shape-rendering": "crispEdges" }).call(zM.stroke, Ee).call(zM.fill, Se).attr("fill-rule", "evenodd").classed("cursor-move", !!u).attr("transform", T).attr("d", z + "Z");
+          var Ae = p.append("path").attr("class", "zoombox-corners").style({ fill: zM.background, stroke: zM.defaultLine, "stroke-width": 1 }).attr("transform", T).attr("d", "M0,0Z");
+          if (u && n.hasText) {
+            var Be = p.select(".label-temp");
+            Be.empty() && (Be = p.append("g").classed("label-temp", true).classed("select-outline", true).style({ opacity: 0.8 }));
+          }
+          var Pe = _._uid + MP.SELECTID, me = [], De = EP(v, n.xaxes, n.yaxes, n.subplot);
+          b && !e.shiftKey && (n._clearSubplotSelections = function() {
+            if (a) {
+              var je = O._id, lt = U._id;
+              Cfe(v, je, lt, De);
+              for (var pt = (v.layout || {}).selections || [], Vt = [], ot = false, ut = 0; ut < pt.length; ut++) {
+                var Wt = _.selections[ut];
+                !Wt || Wt.xref !== je || Wt.yref !== lt ? Vt.push(pt[ut]) : ot = true;
+              }
+              ot && (v._fullLayout._noEmitSelectedAtStart = true, qM.call("_guiRelayout", v, { selections: Vt }));
+            }
+          });
+          var ce = Bht(n);
+          n.moveFn = function(je, lt) {
+            n._clearSubplotSelections && (n._clearSubplotSelections(), n._clearSubplotSelections = void 0), P = Math.max(0, Math.min(G, M * je + L)), A = Math.max(0, Math.min(Z, g * lt + x));
+            var pt = Math.abs(P - L), Vt = Math.abs(A - x);
+            if (s) {
+              var ot, ut, Wt;
+              if (c) {
+                var Nt = _.selectdirection;
+                switch (Nt === "any" ? Vt < Math.min(pt * 0.6, Cm) ? ot = "h" : pt < Math.min(Vt * 0.6, Cm) ? ot = "v" : ot = "d" : ot = Nt, ot) {
+                  case "h":
+                    ut = h ? Z / 2 : 0, Wt = Z;
+                    break;
+                  case "v":
+                    ut = h ? G / 2 : 0, Wt = G;
+                    break;
+                }
+              }
+              if (u) switch (_.newshape.drawdirection) {
+                case "vertical":
+                  ot = "h", ut = h ? Z / 2 : 0, Wt = Z;
+                  break;
+                case "horizontal":
+                  ot = "v", ut = h ? G / 2 : 0, Wt = G;
+                  break;
+                case "ortho":
+                  pt < Vt ? (ot = "h", ut = x, Wt = A) : (ot = "v", ut = L, Wt = P);
+                  break;
+                default:
+                  ot = "d";
+              }
+              ot === "h" ? (oe = d ? MN(h, [P, ut], [P, Wt]) : [[L, ut], [L, Wt], [P, Wt], [P, ut]], oe.xmin = d ? P : Math.min(L, P), oe.xmax = d ? P : Math.max(L, P), oe.ymin = Math.min(ut, Wt), oe.ymax = Math.max(ut, Wt), Ae.attr("d", "M" + oe.xmin + "," + (x - Cm) + "h-4v" + 2 * Cm + "h4ZM" + (oe.xmax - 1) + "," + (x - Cm) + "h4v" + 2 * Cm + "h-4Z")) : ot === "v" ? (oe = d ? MN(h, [ut, A], [Wt, A]) : [[ut, x], [ut, A], [Wt, A], [Wt, x]], oe.xmin = Math.min(ut, Wt), oe.xmax = Math.max(ut, Wt), oe.ymin = d ? A : Math.min(x, A), oe.ymax = d ? A : Math.max(x, A), Ae.attr("d", "M" + (L - Cm) + "," + oe.ymin + "v-4h" + 2 * Cm + "v4ZM" + (L - Cm) + "," + (oe.ymax - 1) + "v4h" + 2 * Cm + "v-4Z")) : ot === "d" && (oe = d ? MN(h, [L, x], [P, A]) : [[L, x], [L, A], [P, A], [P, x]], oe.xmin = Math.min(L, P), oe.xmax = Math.max(L, P), oe.ymin = Math.min(x, A), oe.ymax = Math.max(x, A), Ae.attr("d", "M0,0Z"));
+            } else o && (N.addPt([P, A]), oe = N.filtered);
+            if (n.selectionDefs && n.selectionDefs.length ? (re = Sfe(n.mergedPolygons, oe, j), oe.subtract = j, H = DN(n.selectionDefs.concat([oe]))) : (re = [oe], H = PN(oe)), _fe(Efe(re, l), ge, n), c) {
+              var $t = kN(v, false), sr = $t.eventData ? $t.eventData.points.slice() : [];
+              $t = kN(v, false, H, De, n), H = $t.selectionTesters, Le = $t.eventData;
+              var Tr;
+              N ? Tr = N.filtered : Tr = Lfe(re), OM.throttle(Pe, MP.SELECTDELAY, function() {
+                me = kfe(H, De);
+                for (var fr = me.slice(), $e = 0; $e < sr.length; $e++) {
+                  for (var St = sr[$e], Qt = false, Gt = 0; Gt < fr.length; Gt++) if (fr[Gt].curveNumber === St.curveNumber && fr[Gt].pointNumber === St.pointNumber) {
+                    Qt = true;
+                    break;
+                  }
+                  Qt || fr.push(St);
+                }
+                fr.length && (Le || (Le = {}), Le.points = fr), ce(Le, Tr), Nht(v, Le);
+              });
+            }
+          }, n.clickFn = function(je, lt) {
+            if (Ae.remove(), v._fullLayout._activeShapeIndex >= 0) {
+              v._fullLayout._deactivateShape(v);
+              return;
+            }
+            if (!u) {
+              var pt = _.clickmode;
+              OM.done(Pe).then(function() {
+                if (OM.clear(Pe), je === 2) {
+                  for (ge.remove(), _e = 0; _e < De.length; _e++) Ce = De[_e], Ce._module.selectPoints(Ce, false);
+                  if (UM(v, De), NM(n), zN(v), De.length) {
+                    var Vt = De[0].xaxis, ot = De[0].yaxis;
+                    if (Vt && ot) {
+                      for (var ut = [], Wt = v._fullLayout.selections, Nt = 0; Nt < Wt.length; Nt++) {
+                        var $t = Wt[Nt];
+                        $t && ($t.xref !== Vt._id || $t.yref !== ot._id) && ut.push($t);
+                      }
+                      ut.length < Wt.length && (v._fullLayout._noEmitSelectedAtStart = true, qM.call("_guiRelayout", v, { selections: ut }));
+                    }
+                  }
+                } else pt.indexOf("select") > -1 && Tfe(lt, v, n.xaxes, n.yaxes, n.subplot, n, ge), pt === "event" && VM(v, void 0);
+                fht.click(v, lt, E.id);
+              }).catch(SP.error);
+            }
+          }, n.doneFn = function() {
+            Ae.remove(), OM.done(Pe).then(function() {
+              OM.clear(Pe), !b && oe && n.selectionDefs && (oe.subtract = j, n.selectionDefs.push(oe), n.mergedPolygons.length = 0, [].push.apply(n.mergedPolygons, re)), (b || u) && NM(n, b), n.doneFnCompleted && n.doneFnCompleted(me), c && VM(v, Le);
+            }).catch(SP.error);
+          };
+        }
+        function Tfe(e, t, r, n, i, a, o) {
+          var s = t._hoverdata, l = t._fullLayout, u = l.clickmode, c = u.indexOf("event") > -1, f = [], h, d, v, _, b, p, k, E, T, L;
+          if (Lht(s)) {
+            Afe(e, t, a), h = EP(t, r, n, i);
+            var x = Pht(s, h), C = x.pointNumbers.length > 0;
+            if (C ? Iht(h, x) : Rht(h) && (k = mfe(x))) {
+              for (o && o.remove(), L = 0; L < h.length; L++) d = h[L], d._module.selectPoints(d, false);
+              UM(t, h), NM(a), c && zN(t);
+            } else {
+              E = e.shiftKey && (k !== void 0 ? k : mfe(x)), v = Mht(x.pointNumber, x.searchInfo, E);
+              var M = a.selectionDefs.concat([v]);
+              for (_ = DN(M), L = 0; L < h.length; L++) if (b = h[L]._module.selectPoints(h[L], _), p = Mfe(b, h[L]), f.length) for (var g = 0; g < p.length; g++) f.push(p[g]);
+              else f = p;
+              if (T = { points: f }, UM(t, h, T), v && a && a.selectionDefs.push(v), o) {
+                var P = a.mergedPolygons, A = CN(a.dragmode);
+                _fe(Efe(P, A), o, a);
+              }
+              c && VM(t, T);
+            }
+          }
+        }
+        function Mht(e, t, r) {
+          return { pointNumber: e, searchInfo: t, subtract: !!r };
+        }
+        function EN(e) {
+          return "pointNumber" in e && "searchInfo" in e;
+        }
+        function Eht(e) {
+          return { xmin: 0, xmax: 0, ymin: 0, ymax: 0, pts: [], contains: function(t, r, n, i) {
+            var a = e.searchInfo.cd[0].trace.index, o = i.cd[0].trace.index;
+            return o === a && n === e.pointNumber;
+          }, isRect: false, degenerate: false, subtract: !!e.subtract };
+        }
+        function DN(e) {
+          if (!e.length) return;
+          for (var t = [], r = EN(e[0]) ? 0 : e[0][0][0], n = r, i = EN(e[0]) ? 0 : e[0][0][1], a = i, o = 0; o < e.length; o++) if (EN(e[o])) t.push(Eht(e[o]));
+          else {
+            var s = PN(e[o]);
+            s.subtract = !!e[o].subtract, t.push(s), r = Math.min(r, s.xmin), n = Math.max(n, s.xmax), i = Math.min(i, s.ymin), a = Math.max(a, s.ymax);
+          }
+          function l(u, c, f, h) {
+            for (var d = false, v = 0; v < t.length; v++) t[v].contains(u, c, f, h) && (d = !t[v].subtract);
+            return d;
+          }
+          return { xmin: r, xmax: n, ymin: i, ymax: a, pts: [], contains: l, isRect: false, degenerate: false };
+        }
+        function Afe(e, t, r) {
+          var n = t._fullLayout, i = r.plotinfo, a = r.dragmode, o = n._lastSelectedSubplot && n._lastSelectedSubplot === i.id, s = (e.shiftKey || e.altKey) && !(BM(a) && CN(a));
+          o && s && i.selection && i.selection.selectionDefs && !r.selectionDefs ? (r.selectionDefs = i.selection.selectionDefs, r.mergedPolygons = i.selection.mergedPolygons) : (!s || !i.selection) && NM(r), o || (xfe(t), n._lastSelectedSubplot = i.id);
+        }
+        function kht(e) {
+          return e._fullLayout._activeShapeIndex >= 0;
+        }
+        function Cht(e) {
+          return e._fullLayout._activeSelectionIndex >= 0;
+        }
+        function NM(e, t) {
+          var r = e.dragmode, n = e.plotinfo, i = e.gd;
+          kht(i) && i._fullLayout._deactivateShape(i), Cht(i) && i._fullLayout._deactivateSelection(i);
+          var a = i._fullLayout, o = a._zoomlayer, s = BM(r), l = LN(r);
+          if (s || l) {
+            var u = o.selectAll(".select-outline-" + n.id);
+            if (u && i._fullLayout._outlining) {
+              var c;
+              s && (c = ght(u, e)), c && qM.call("_guiRelayout", i, { shapes: c });
+              var f;
+              l && !RN(e) && (f = mht(u, e)), f && (i._fullLayout._noEmitSelectedAtStart = true, qM.call("_guiRelayout", i, { selections: f }).then(function() {
+                t && yht(i);
+              })), i._fullLayout._outlining = false;
+            }
+          }
+          n.selection = {}, n.selection.selectionDefs = e.selectionDefs = [], n.selection.mergedPolygons = e.mergedPolygons = [];
+        }
+        function gfe(e) {
+          return e._id;
+        }
+        function EP(e, t, r, n) {
+          if (!e.calcdata) return [];
+          var i = [], a = t.map(gfe), o = r.map(gfe), s, l, u;
+          for (u = 0; u < e.calcdata.length; u++) if (s = e.calcdata[u], l = s[0].trace, !(l.visible !== true || !l._module || !l._module.selectPoints)) if (RN({ subplot: n }) && (l.subplot === n || l.geo === n)) i.push(AP(l._module, s, t[0], r[0]));
+          else if (l.type === "splom") {
+            if (l._xaxes[a[0]] && l._yaxes[o[0]]) {
+              var c = AP(l._module, s, t[0], r[0]);
+              c.scene = e._fullLayout._splomScenes[l.uid], i.push(c);
+            }
+          } else if (l.type === "sankey") {
+            var f = AP(l._module, s, t[0], r[0]);
+            i.push(f);
+          } else {
+            if (a.indexOf(l.xaxis) === -1 && (!l._xA || !l._xA.overlaying) || o.indexOf(l.yaxis) === -1 && (!l._yA || !l._yA.overlaying)) continue;
+            i.push(AP(l._module, s, k0(e, l.xaxis), k0(e, l.yaxis)));
+          }
+          return i;
+        }
+        function AP(e, t, r, n) {
+          return { _module: e, cd: t, xaxis: r, yaxis: n };
+        }
+        function Lht(e) {
+          return e && Array.isArray(e) && e[0].hoverOnBox !== true;
+        }
+        function Pht(e, t) {
+          var r = e[0], n = -1, i = [], a, o;
+          for (o = 0; o < t.length; o++) if (a = t[o], r.fullData.index === a.cd[0].trace.index) {
+            if (r.hoverOnBox === true) break;
+            r.pointNumber !== void 0 ? n = r.pointNumber : r.binNumber !== void 0 && (n = r.binNumber, i = r.pointNumbers);
+            break;
+          }
+          return { pointNumber: n, pointNumbers: i, searchInfo: a };
+        }
+        function mfe(e) {
+          var t = e.searchInfo.cd[0].trace, r = e.pointNumber, n = e.pointNumbers, i = n.length > 0, a = i ? n[0] : r;
+          return t.selectedpoints ? t.selectedpoints.indexOf(a) > -1 : false;
+        }
+        function Iht(e, t) {
+          var r = [], n, i, a, o;
+          for (o = 0; o < e.length; o++) n = e[o], n.cd[0].trace.selectedpoints && n.cd[0].trace.selectedpoints.length > 0 && r.push(n);
+          if (r.length === 1 && (a = r[0] === t.searchInfo, a && (i = t.searchInfo.cd[0].trace, i.selectedpoints.length === t.pointNumbers.length))) {
+            for (o = 0; o < t.pointNumbers.length; o++) if (i.selectedpoints.indexOf(t.pointNumbers[o]) < 0) return false;
+            return true;
+          }
+          return false;
+        }
+        function Rht(e) {
+          var t = 0, r, n, i;
+          for (i = 0; i < e.length; i++) if (r = e[i], n = r.cd[0].trace, n.selectedpoints && (n.selectedpoints.length > 1 || (t += n.selectedpoints.length, t > 1))) return false;
+          return t === 1;
+        }
+        function UM(e, t, r) {
+          var n;
+          for (n = 0; n < t.length; n++) {
+            var i = t[n].cd[0].trace._fullInput, a = e._fullLayout._tracePreGUI[i.uid] || {};
+            a.selectedpoints === void 0 && (a.selectedpoints = i._input.selectedpoints || null);
+          }
+          var o;
+          if (r) {
+            var s = r.points || [];
+            for (n = 0; n < t.length; n++) o = t[n].cd[0].trace, o._input.selectedpoints = o._fullInput.selectedpoints = [], o._fullInput !== o && (o.selectedpoints = []);
+            for (var l = 0; l < s.length; l++) {
+              var u = s[l], c = u.data, f = u.fullData, h = u.pointIndex, d = u.pointIndices;
+              d ? ([].push.apply(c.selectedpoints, d), o._fullInput !== o && [].push.apply(f.selectedpoints, d)) : (c.selectedpoints.push(h), o._fullInput !== o && f.selectedpoints.push(h));
+            }
+          } else for (n = 0; n < t.length; n++) o = t[n].cd[0].trace, delete o.selectedpoints, delete o._input.selectedpoints, o._fullInput !== o && delete o._fullInput.selectedpoints;
+          Dht(e, t);
+        }
+        function Dht(e, t) {
+          for (var r = false, n = 0; n < t.length; n++) {
+            var i = t[n], a = i.cd;
+            qM.traceIs(a[0].trace, "regl") && (r = true);
+            var o = i._module, s = o.styleOnSelect || o.style;
+            s && (s(e, a, a[0].node3), a[0].nodeRangePlot3 && s(e, a, a[0].nodeRangePlot3));
+          }
+          r && (xht(e), bht(e));
+        }
+        function Sfe(e, t, r) {
+          for (var n = r ? hfe.difference : hfe.union, i = n({ regions: e }, { regions: [t] }), a = i.regions.reverse(), o = 0; o < a.length; o++) {
+            var s = a[o];
+            s.subtract = FN(s, a.slice(0, o));
+          }
+          return a;
+        }
+        function Mfe(e, t) {
+          if (Array.isArray(e)) for (var r = t.cd, n = t.cd[0].trace, i = 0; i < e.length; i++) e[i] = hht(e[i], n, r);
+          return e;
+        }
+        function Efe(e, t) {
+          for (var r = [], n = 0; n < e.length; n++) {
+            r[n] = [];
+            for (var i = 0; i < e[n].length; i++) {
+              r[n][i] = [], r[n][i][0] = i ? "L" : "M";
+              for (var a = 0; a < e[n][i].length; a++) r[n][i].push(e[n][i][a]);
+            }
+            t || r[n].push(["Z", r[n][0][1], r[n][0][2]]);
+          }
+          return r;
+        }
+        function kfe(e, t) {
+          for (var r = [], n, i = [], a, o = 0; o < t.length; o++) {
+            var s = t[o];
+            a = s._module.selectPoints(s, e), i.push(a), n = Mfe(a, s), r = r.concat(n);
+          }
+          return r;
+        }
+        function kN(e, t, r, n, i) {
+          var a = !!n, o, s, l;
+          i && (o = i.plotinfo, s = i.xaxes[0]._id, l = i.yaxes[0]._id);
+          var u = [], c = [], f = yfe(e), h = e._fullLayout;
+          if (o) {
+            var d = h._zoomlayer, v = h.dragmode, _ = BM(v), b = LN(v);
+            if (_ || b) {
+              var p = k0(e, s, "x"), k = k0(e, l, "y");
+              if (p && k) {
+                var E = d.selectAll(".select-outline-" + o.id);
+                if (E && e._fullLayout._outlining && E.length) {
+                  for (var T = E[0][0], L = T.getAttribute("d"), x = pht(L, e, o), C = [], M = 0; M < x.length; M++) {
+                    for (var g = x[M], P = [], A = 0; A < g.length; A++) P.push([b_(p, g[A][1]), b_(k, g[A][2])]);
+                    P.xref = s, P.yref = l, P.subtract = FN(P, C), C.push(P);
+                  }
+                  f = f.concat(C);
+                }
+              }
+            }
+          }
+          var z = s && l ? [s + l] : h._subplots.cartesian;
+          Fht(e);
+          for (var O = {}, U = 0; U < z.length; U++) {
+            var G = z[U], Z = G.indexOf("y"), j = G.slice(0, Z), N = G.slice(Z), H = s && l ? r : void 0;
+            if (H = Oht(f, j, N, H), H) {
+              var re = n;
+              if (!a) {
+                var oe = k0(e, j, "x"), _e = k0(e, N, "y");
+                re = EP(e, [oe], [_e], G);
+                for (var Ce = 0; Ce < re.length; Ce++) {
+                  var Le = re[Ce], ge = Le.cd[0], ie = ge.trace;
+                  if (Le._module.name === "scattergl" && !ge.t.xpx) {
+                    var Se = ie.x, Ee = ie.y, Ae = ie._length;
+                    ge.t.xpx = [], ge.t.ypx = [];
+                    for (var Be = 0; Be < Ae; Be++) ge.t.xpx[Be] = oe.c2p(Se[Be]), ge.t.ypx[Be] = _e.c2p(Ee[Be]);
+                  }
+                  Le._module.name === "splom" && (O[ie.uid] || (O[ie.uid] = true));
+                }
+              }
+              var Pe = kfe(H, re);
+              u = u.concat(Pe), c = c.concat(re);
+            }
+          }
+          var me = { points: u };
+          UM(e, c, me);
+          var De = h.clickmode, ce = De.indexOf("event") > -1 && t;
+          if (!o && t) {
+            var je = yfe(e, true);
+            if (je.length) {
+              var lt = je[0].xref, pt = je[0].yref;
+              if (lt && pt) {
+                var Vt = Lfe(je), ot = Pfe([k0(e, lt, "x"), k0(e, pt, "y")]);
+                ot(me, Vt);
+              }
+            }
+            e._fullLayout._noEmitSelectedAtStart ? e._fullLayout._noEmitSelectedAtStart = false : ce && VM(e, me), h._reselect = false;
+          }
+          if (!o && h._deselect) {
+            var ut = h._deselect;
+            s = ut.xref, l = ut.yref, zht(s, l, c) || Cfe(e, s, l, n), ce && (me.points.length ? VM(e, me) : zN(e)), h._deselect = false;
+          }
+          return { eventData: me, selectionTesters: r };
+        }
+        function Fht(e) {
+          var t = e.calcdata;
+          if (t) for (var r = 0; r < t.length; r++) {
+            var n = t[r][0], i = n.trace, a = e._fullLayout._splomScenes;
+            if (a) {
+              var o = a[i.uid];
+              o && (o.selectBatch = []);
+            }
+          }
+        }
+        function zht(e, t, r) {
+          for (var n = 0; n < r.length; n++) {
+            var i = r[n];
+            if (i.xaxis && i.xaxis._id === e && i.yaxis && i.yaxis._id === t) return true;
+          }
+          return false;
+        }
+        function Cfe(e, t, r, n) {
+          n = EP(e, [k0(e, t, "x")], [k0(e, r, "y")], t + r);
+          for (var i = 0; i < n.length; i++) {
+            var a = n[i];
+            a._module.selectPoints(a, false);
+          }
+          UM(e, n);
+        }
+        function Oht(e, t, r, n) {
+          for (var i, a = 0; a < e.length; a++) {
+            var o = e[a];
+            if (!(t !== o.xref || r !== o.yref)) if (i) {
+              var s = !!o.subtract;
+              i = Sfe(i, o, s), n = DN(i);
+            } else i = [o], n = PN(o);
+          }
+          return n;
+        }
+        function yfe(e, t) {
+          for (var r = [], n = e._fullLayout, i = n.selections, a = i.length, o = 0; o < a; o++) if (!(t && o !== n._activeSelectionIndex)) {
+            var s = i[o];
+            if (s) {
+              var l = s.xref, u = s.yref, c = k0(e, l, "x"), f = k0(e, u, "y"), h, d, v, _, b;
+              if (s.type === "rect") {
+                b = [];
+                var p = b_(c, s.x0), k = b_(c, s.x1), E = b_(f, s.y0), T = b_(f, s.y1);
+                b = [[p, E], [p, T], [k, T], [k, E]], h = Math.min(p, k), d = Math.max(p, k), v = Math.min(E, T), _ = Math.max(E, T), b.xmin = h, b.xmax = d, b.ymin = v, b.ymax = _, b.xref = l, b.yref = u, b.subtract = false, b.isRect = true, r.push(b);
+              } else if (s.type === "path") for (var L = s.path.split("Z"), x = [], C = 0; C < L.length; C++) {
+                var M = L[C];
+                if (M) {
+                  M += "Z";
+                  var g = dfe.extractPathCoords(M, vfe.paramIsX, "raw"), P = dfe.extractPathCoords(M, vfe.paramIsY, "raw");
+                  h = 1 / 0, d = -1 / 0, v = 1 / 0, _ = -1 / 0, b = [];
+                  for (var A = 0; A < g.length; A++) {
+                    var z = b_(c, g[A]), O = b_(f, P[A]);
+                    b.push([z, O]), h = Math.min(z, h), d = Math.max(z, d), v = Math.min(O, v), _ = Math.max(O, _);
+                  }
+                  b.xmin = h, b.xmax = d, b.ymin = v, b.ymax = _, b.xref = l, b.yref = u, b.subtract = FN(b, x), x.push(b), r.push(b);
+                }
+              }
+            }
+          }
+          return r;
+        }
+        function FN(e, t) {
+          for (var r = false, n = 0; n < t.length; n++) for (var i = t[n], a = 0; a < e.length; a++) if (uht(e[a], i)) {
+            r = !r;
+            break;
+          }
+          return r;
+        }
+        function b_(e, t) {
+          return e.type === "date" && (t = t.replace("_", " ")), e.type === "log" ? e.c2p(t) : e.r2p(t, null, e.calendar);
+        }
+        function Lfe(e) {
+          for (var t = e.length, r = [], n = 0; n < t; n++) {
+            var i = e[n];
+            r = r.concat(i), r = r.concat([i[0]]);
+          }
+          return qht(r);
+        }
+        function qht(e) {
+          return e.isRect = e.length === 5 && e[0][0] === e[4][0] && e[0][1] === e[4][1] && e[0][0] === e[1][0] && e[2][0] === e[3][0] && e[0][1] === e[3][1] && e[1][1] === e[2][1] || e[0][1] === e[1][1] && e[2][1] === e[3][1] && e[0][0] === e[3][0] && e[1][0] === e[2][0], e.isRect && (e.xmin = Math.min(e[0][0], e[2][0]), e.xmax = Math.max(e[0][0], e[2][0]), e.ymin = Math.min(e[0][1], e[2][1]), e.ymax = Math.max(e[0][1], e[2][1])), e;
+        }
+        function Pfe(e) {
+          return function(t, r) {
+            for (var n, i, a = 0; a < e.length; a++) {
+              var o = e[a], s = o._id, l = s.charAt(0);
+              if (r.isRect) {
+                n || (n = {});
+                var u = r[l + "min"], c = r[l + "max"];
+                u !== void 0 && c !== void 0 && (n[s] = [pfe(o, u), pfe(o, c)].sort(_ht));
+              } else i || (i = {}), i[s] = r.map(Tht(o));
+            }
+            n && (t.range = n), i && (t.lassoPoints = i);
+          };
+        }
+        function Bht(e) {
+          var t = e.plotinfo;
+          return t.fillRangeItems || Pfe(e.xaxes.concat(e.yaxes));
+        }
+        function Nht(e, t) {
+          e.emit("plotly_selecting", t);
+        }
+        function VM(e, t) {
+          t && (t.selections = (e.layout || {}).selections || []), e.emit("plotly_selected", t);
+        }
+        function zN(e) {
+          e.emit("plotly_deselect", null);
+        }
+        Ife.exports = { reselect: kN, prepSelect: Sht, clearOutline: xfe, clearSelectionsCache: NM, selectOnClick: Tfe };
+      });
+      var ON = ye((_or, Dfe) => {
+        Dfe.exports = [{ path: "", backoff: 0 }, { path: "M-2.4,-3V3L0.6,0Z", backoff: 0.6 }, { path: "M-3.7,-2.5V2.5L1.3,0Z", backoff: 1.3 }, { path: "M-4.45,-3L-1.65,-0.2V0.2L-4.45,3L1.55,0Z", backoff: 1.55 }, { path: "M-2.2,-2.2L-0.2,-0.2V0.2L-2.2,2.2L-1.4,3L1.6,0L-1.4,-3Z", backoff: 1.6 }, { path: "M-4.4,-2.1L-0.6,-0.2V0.2L-4.4,2.1L-4,3L2,0L-4,-3Z", backoff: 2 }, { path: "M2,0A2,2 0 1,1 0,-2A2,2 0 0,1 2,0Z", backoff: 0, noRotate: true }, { path: "M2,2V-2H-2V2Z", backoff: 0, noRotate: true }];
+      });
+      var HM = ye((xor, Ffe) => {
+        Ffe.exports = { axisRefDescription: function(e, t, r) {
+          return ["If set to a", e, "axis id (e.g. *" + e + "* or", "*" + e + "2*), the `" + e + "` position refers to a", e, "coordinate. If set to *paper*, the `" + e + "`", "position refers to the distance from the", t, "of the plotting", "area in normalized coordinates where *0* (*1*) corresponds to the", t, "(" + r + "). If set to a", e, "axis ID followed by", "*domain* (separated by a space), the position behaves like for", "*paper*, but refers to the distance in fractions of the domain", "length from the", t, "of the domain of that axis: e.g.,", "*" + e + "2 domain* refers to the domain of the second", e, " axis and a", e, "position of 0.5 refers to the", "point between the", t, "and the", r, "of the domain of the", "second", e, "axis."].join(" ");
+        } };
+      });
+      var Jb = ye((wor, qfe) => {
+        var zfe = ON(), Ofe = ec(), kP = Rh(), Uht = vl().templatedArray;
+        HM();
+        qfe.exports = Uht("annotation", { visible: { valType: "boolean", dflt: true, editType: "calc+arraydraw" }, text: { valType: "string", editType: "calc+arraydraw" }, textangle: { valType: "angle", dflt: 0, editType: "calc+arraydraw" }, font: Ofe({ editType: "calc+arraydraw", colorEditType: "arraydraw" }), width: { valType: "number", min: 1, dflt: null, editType: "calc+arraydraw" }, height: { valType: "number", min: 1, dflt: null, editType: "calc+arraydraw" }, opacity: { valType: "number", min: 0, max: 1, dflt: 1, editType: "arraydraw" }, align: { valType: "enumerated", values: ["left", "center", "right"], dflt: "center", editType: "arraydraw" }, valign: { valType: "enumerated", values: ["top", "middle", "bottom"], dflt: "middle", editType: "arraydraw" }, bgcolor: { valType: "color", dflt: "rgba(0,0,0,0)", editType: "arraydraw" }, bordercolor: { valType: "color", dflt: "rgba(0,0,0,0)", editType: "arraydraw" }, borderpad: { valType: "number", min: 0, dflt: 1, editType: "calc+arraydraw" }, borderwidth: { valType: "number", min: 0, dflt: 1, editType: "calc+arraydraw" }, showarrow: { valType: "boolean", dflt: true, editType: "calc+arraydraw" }, arrowcolor: { valType: "color", editType: "arraydraw" }, arrowhead: { valType: "integer", min: 0, max: zfe.length, dflt: 1, editType: "arraydraw" }, startarrowhead: { valType: "integer", min: 0, max: zfe.length, dflt: 1, editType: "arraydraw" }, arrowside: { valType: "flaglist", flags: ["end", "start"], extras: ["none"], dflt: "end", editType: "arraydraw" }, arrowsize: { valType: "number", min: 0.3, dflt: 1, editType: "calc+arraydraw" }, startarrowsize: { valType: "number", min: 0.3, dflt: 1, editType: "calc+arraydraw" }, arrowwidth: { valType: "number", min: 0.1, editType: "calc+arraydraw" }, standoff: { valType: "number", min: 0, dflt: 0, editType: "calc+arraydraw" }, startstandoff: { valType: "number", min: 0, dflt: 0, editType: "calc+arraydraw" }, ax: { valType: "any", editType: "calc+arraydraw" }, ay: { valType: "any", editType: "calc+arraydraw" }, axref: { valType: "enumerated", dflt: "pixel", values: ["pixel", kP.idRegex.x.toString()], editType: "calc" }, ayref: { valType: "enumerated", dflt: "pixel", values: ["pixel", kP.idRegex.y.toString()], editType: "calc" }, xref: { valType: "enumerated", values: ["paper", kP.idRegex.x.toString()], editType: "calc" }, x: { valType: "any", editType: "calc+arraydraw" }, xanchor: { valType: "enumerated", values: ["auto", "left", "center", "right"], dflt: "auto", editType: "calc+arraydraw" }, xshift: { valType: "number", dflt: 0, editType: "calc+arraydraw" }, yref: { valType: "enumerated", values: ["paper", kP.idRegex.y.toString()], editType: "calc" }, y: { valType: "any", editType: "calc+arraydraw" }, yanchor: { valType: "enumerated", values: ["auto", "top", "middle", "bottom"], dflt: "auto", editType: "calc+arraydraw" }, yshift: { valType: "number", dflt: 0, editType: "calc+arraydraw" }, clicktoshow: { valType: "enumerated", values: [false, "onoff", "onout"], dflt: false, editType: "arraydraw" }, xclick: { valType: "any", editType: "arraydraw" }, yclick: { valType: "any", editType: "arraydraw" }, hovertext: { valType: "string", editType: "arraydraw" }, hoverlabel: { bgcolor: { valType: "color", editType: "arraydraw" }, bordercolor: { valType: "color", editType: "arraydraw" }, font: Ofe({ editType: "arraydraw" }), editType: "arraydraw" }, captureevents: { valType: "boolean", editType: "arraydraw" }, editType: "calc" });
+      });
+      var Lm = ye((Tor, Bfe) => {
+        Bfe.exports = { PTS_LINESONLY: 20, minTolerance: 0.2, toleranceGrowth: 10, maxScreensAway: 20, eventDataKeys: [] };
+      });
+      var Pg = ye((Aor, Nfe) => {
+        Nfe.exports = function(t) {
+          return { valType: "color", editType: "style", anim: true };
+        };
+      });
+      var pf = ye((Sor, Zfe) => {
+        var Ufe = df().axisHoverFormat, { hovertemplateAttrs: Vht, texttemplateAttrs: Ght, templatefallbackAttrs: Vfe } = Ll(), Gfe = Tu(), Hht = ec(), Hfe = Pd().dash, jht = Pd().pattern, Wht = So(), Xht = Lm(), jM = Ao().extendFlat, Zht = Pg();
+        function jfe(e) {
+          return { valType: "any", dflt: 0, editType: "calc" };
+        }
+        function Wfe(e) {
+          return { valType: "any", editType: "calc" };
+        }
+        function Xfe(e) {
+          return { valType: "enumerated", values: ["start", "middle", "end"], dflt: "middle", editType: "calc" };
+        }
+        Zfe.exports = { x: { valType: "data_array", editType: "calc+clearAxisTypes", anim: true }, x0: { valType: "any", dflt: 0, editType: "calc+clearAxisTypes", anim: true }, dx: { valType: "number", dflt: 1, editType: "calc", anim: true }, y: { valType: "data_array", editType: "calc+clearAxisTypes", anim: true }, y0: { valType: "any", dflt: 0, editType: "calc+clearAxisTypes", anim: true }, dy: { valType: "number", dflt: 1, editType: "calc", anim: true }, xperiod: jfe(), yperiod: jfe(), xperiod0: Wfe(), yperiod0: Wfe(), xperiodalignment: Xfe(), yperiodalignment: Xfe(), xhoverformat: Ufe("x"), yhoverformat: Ufe("y"), offsetgroup: { valType: "string", dflt: "", editType: "calc" }, alignmentgroup: { valType: "string", dflt: "", editType: "calc" }, stackgroup: { valType: "string", dflt: "", editType: "calc" }, orientation: { valType: "enumerated", values: ["v", "h"], editType: "calc" }, groupnorm: { valType: "enumerated", values: ["", "fraction", "percent"], dflt: "", editType: "calc" }, stackgaps: { valType: "enumerated", values: ["infer zero", "interpolate"], dflt: "infer zero", editType: "calc" }, text: { valType: "string", dflt: "", arrayOk: true, editType: "calc" }, texttemplate: Ght(), texttemplatefallback: Vfe({ editType: "calc" }), hovertext: { valType: "string", dflt: "", arrayOk: true, editType: "style" }, mode: { valType: "flaglist", flags: ["lines", "markers", "text"], extras: ["none"], editType: "calc" }, hoveron: { valType: "flaglist", flags: ["points", "fills"], editType: "style" }, hovertemplate: Vht({}, { keys: Xht.eventDataKeys }), hovertemplatefallback: Vfe(), line: { color: { valType: "color", editType: "style", anim: true }, width: { valType: "number", min: 0, dflt: 2, editType: "style", anim: true }, shape: { valType: "enumerated", values: ["linear", "spline", "hv", "vh", "hvh", "vhv"], dflt: "linear", editType: "plot" }, smoothing: { valType: "number", min: 0, max: 1.3, dflt: 1, editType: "plot" }, dash: jM({}, Hfe, { editType: "style" }), backoff: { valType: "number", min: 0, dflt: "auto", arrayOk: true, editType: "plot" }, simplify: { valType: "boolean", dflt: true, editType: "plot" }, editType: "plot" }, connectgaps: { valType: "boolean", dflt: false, editType: "calc" }, cliponaxis: { valType: "boolean", dflt: true, editType: "plot" }, fill: { valType: "enumerated", values: ["none", "tozeroy", "tozerox", "tonexty", "tonextx", "toself", "tonext"], editType: "calc" }, fillcolor: Zht(true), fillgradient: jM({ type: { valType: "enumerated", values: ["radial", "horizontal", "vertical", "none"], dflt: "none", editType: "calc" }, start: { valType: "number", editType: "calc" }, stop: { valType: "number", editType: "calc" }, colorscale: { valType: "colorscale", editType: "style" }, editType: "calc" }), fillpattern: jht, marker: jM({ symbol: { valType: "enumerated", values: Wht.symbolList, dflt: "circle", arrayOk: true, editType: "style" }, opacity: { valType: "number", min: 0, max: 1, arrayOk: true, editType: "style", anim: true }, angle: { valType: "angle", dflt: 0, arrayOk: true, editType: "plot", anim: false }, angleref: { valType: "enumerated", values: ["previous", "up"], dflt: "up", editType: "plot", anim: false }, standoff: { valType: "number", min: 0, dflt: 0, arrayOk: true, editType: "plot", anim: true }, size: { valType: "number", min: 0, dflt: 6, arrayOk: true, editType: "calc", anim: true }, maxdisplayed: { valType: "number", min: 0, dflt: 0, editType: "plot" }, sizeref: { valType: "number", dflt: 1, editType: "calc" }, sizemin: { valType: "number", min: 0, dflt: 0, editType: "calc" }, sizemode: { valType: "enumerated", values: ["diameter", "area"], dflt: "diameter", editType: "calc" }, line: jM({ width: { valType: "number", min: 0, arrayOk: true, editType: "style", anim: true }, dash: jM({}, Hfe, { arrayOk: true }), editType: "calc" }, Gfe("marker.line", { anim: true })), gradient: { type: { valType: "enumerated", values: ["radial", "horizontal", "vertical", "none"], arrayOk: true, dflt: "none", editType: "calc" }, color: { valType: "color", arrayOk: true, editType: "calc" }, editType: "calc" }, editType: "calc" }, Gfe("marker", { anim: true })), selected: { marker: { opacity: { valType: "number", min: 0, max: 1, editType: "style" }, color: { valType: "color", editType: "style" }, size: { valType: "number", min: 0, editType: "style" }, editType: "style" }, textfont: { color: { valType: "color", editType: "style" }, editType: "style" }, editType: "style" }, unselected: { marker: { opacity: { valType: "number", min: 0, max: 1, editType: "style" }, color: { valType: "color", editType: "style" }, size: { valType: "number", min: 0, editType: "style" }, editType: "style" }, textfont: { color: { valType: "color", editType: "style" }, editType: "style" }, editType: "style" }, textposition: { valType: "enumerated", values: ["top left", "top center", "top right", "middle left", "middle center", "middle right", "bottom left", "bottom center", "bottom right"], dflt: "middle center", arrayOk: true, editType: "calc" }, textfont: Hht({ editType: "calc", colorEditType: "style", arrayOk: true }), zorder: { valType: "integer", dflt: 0, editType: "plot" } };
+      });
+      var qN = ye((Eor, Jfe) => {
+        var Yfe = Jb(), Kfe = pf().line, Yht = Pd().dash, CP = Ao().extendFlat, Kht = mc().overrideAll, Jht = vl().templatedArray;
+        HM();
+        Jfe.exports = Kht(Jht("selection", { type: { valType: "enumerated", values: ["rect", "path"] }, xref: CP({}, Yfe.xref, {}), yref: CP({}, Yfe.yref, {}), x0: { valType: "any" }, x1: { valType: "any" }, y0: { valType: "any" }, y1: { valType: "any" }, path: { valType: "string", editType: "arraydraw" }, opacity: { valType: "number", min: 0, max: 1, dflt: 0.7, editType: "arraydraw" }, line: { color: Kfe.color, width: CP({}, Kfe.width, { min: 1, dflt: 1 }), dash: CP({}, Yht, { dflt: "dot" }) } }), "arraydraw", "from-root");
+      });
+      var the = ye((kor, ehe) => {
+        var $fe = Dr(), LP = ho(), $ht = Zd(), Qht = qN(), Qfe = x_();
+        ehe.exports = function(t, r) {
+          $ht(t, r, { name: "selections", handleItemDefaults: edt });
+          for (var n = r.selections, i = 0; i < n.length; i++) {
+            var a = n[i];
+            a && a.path === void 0 && (a.x0 === void 0 || a.x1 === void 0 || a.y0 === void 0 || a.y1 === void 0) && (r.selections[i] = null);
+          }
+        };
+        function edt(e, t, r) {
+          function n(x, C) {
+            return $fe.coerce(e, t, Qht, x, C);
+          }
+          var i = n("path"), a = i ? "path" : "rect", o = n("type", a), s = o !== "path";
+          s && delete t.path, n("opacity"), n("line.color"), n("line.width"), n("line.dash");
+          for (var l = ["x", "y"], u = 0; u < 2; u++) {
+            var c = l[u], f = { _fullLayout: r }, h, d, v, _ = LP.coerceRef(e, t, f, c);
+            if (h = LP.getFromId(f, _), h._selectionIndices.push(t._index), v = Qfe.rangeToShapePosition(h), d = Qfe.shapePositionToRange(h), s) {
+              var b = c + "0", p = c + "1", k = e[b], E = e[p];
+              e[b] = d(e[b], true), e[p] = d(e[p], true), LP.coercePosition(t, f, n, _, b), LP.coercePosition(t, f, n, _, p);
+              var T = t[b], L = t[p];
+              T !== void 0 && L !== void 0 && (t[b] = v(T), t[p] = v(L), e[b] = k, e[p] = E);
+            }
+          }
+          s && $fe.noneOrAll(e, t, ["x0", "x1", "y0", "y1"]);
+        }
+      });
+      var ihe = ye((Cor, rhe) => {
+        rhe.exports = function(t, r, n) {
+          n("newselection.mode");
+          var i = n("newselection.line.width");
+          i && (n("newselection.line.color"), n("newselection.line.dash")), n("activeselection.fillcolor"), n("activeselection.opacity");
+        };
+      });
+      var WM = ye((Lor, ohe) => {
+        var tdt = qa(), nhe = Dr(), ahe = hf();
+        ohe.exports = function(t) {
+          return function(n, i) {
+            var a = n[t];
+            if (Array.isArray(a)) for (var o = tdt.subplotsRegistry.cartesian, s = o.idRegex, l = i._subplots, u = l.xaxis, c = l.yaxis, f = l.cartesian, h = i._has("cartesian"), d = 0; d < a.length; d++) {
+              var v = a[d];
+              if (nhe.isPlainObject(v)) {
+                var _ = ahe.cleanId(v.xref, "x", false), b = ahe.cleanId(v.yref, "y", false), p = s.x.test(_), k = s.y.test(b);
+                if (p || k) {
+                  h || nhe.pushUnique(i._basePlotModules, o);
+                  var E = false;
+                  p && u.indexOf(_) === -1 && (u.push(_), E = true), k && c.indexOf(b) === -1 && (c.push(b), E = true), E && p && k && f.push(_ + b);
+                }
+              }
+            }
+          };
+        };
+      });
+      var Of = ye((Por, lhe) => {
+        var she = AN(), XM = Rfe();
+        lhe.exports = { moduleType: "component", name: "selections", layoutAttributes: qN(), supplyLayoutDefaults: the(), supplyDrawNewSelectionDefaults: ihe(), includeBasePlot: WM()("selections"), draw: she.draw, drawOne: she.drawOne, reselect: XM.reselect, prepSelect: XM.prepSelect, clearOutline: XM.clearOutline, clearSelectionsCache: XM.clearSelectionsCache, selectOnClick: XM.selectOnClick };
+      });
+      var jN = ye((Ior, khe) => {
+        var GN = Oa(), C0 = Dr(), uhe = C0.numberFormat, rdt = fd(), idt = UL(), PP = qa(), yhe = C0.strTranslate, ndt = Zl(), che = ka(), w_ = So(), adt = vf(), fhe = ho(), odt = Eg(), sdt = yv(), _he = Cg(), IP = _he.selectingOrDrawing, ldt = _he.freeMode, udt = Dh().FROM_TL, cdt = bM(), fdt = CM().redrawReglTraces, hdt = Mc(), NN = hf().getFromId, ddt = Of().prepSelect, vdt = Of().clearOutline, pdt = Of().selectOnClick, BN = gN(), HN = Rh(), hhe = HN.MINDRAG, ap = HN.MINZOOM, dhe = true;
+        function gdt(e, t, r, n, i, a, o, s) {
+          var l = e._fullLayout._zoomlayer, u = o + s === "nsew", c = (o + s).length === 1, f, h, d, v, _, b, p, k, E, T, L, x, C, M, g, P, A, z, O, U, G, Z, j;
+          r += t.yaxis._shift;
+          function N() {
+            if (f = t.xaxis, h = t.yaxis, E = f._length, T = h._length, p = f._offset, k = h._offset, d = {}, d[f._id] = f, v = {}, v[h._id] = h, o && s) for (var It = t.overlays, mt = 0; mt < It.length; mt++) {
+              var er = It[mt].xaxis;
+              d[er._id] = er;
+              var lr = It[mt].yaxis;
+              v[lr._id] = lr;
+            }
+            _ = mhe(d), b = mhe(v), C = vhe(_, s), M = vhe(b, o), g = !M && !C, x = ghe(e, e._fullLayout._axisMatchGroups, d, v), L = ghe(e, e._fullLayout._axisConstraintGroups, d, v, x);
+            var wr = L.isSubplotConstrained || x.isSubplotConstrained;
+            P = s || wr, A = o || wr;
+            var Lr = e._fullLayout;
+            z = Lr._has("scattergl"), O = Lr._has("splom"), U = Lr._has("svg");
+          }
+          N();
+          var H = _dt(M + C, e._fullLayout.dragmode, u), re = bhe(t, o + s + "drag", H, r, n, i, a);
+          if (g && !u) return re.onmousedown = null, re.style.pointerEvents = "none", re;
+          var oe = { element: re, gd: e, plotinfo: t };
+          oe.prepFn = function(It, mt, er) {
+            var lr = oe.dragmode, wr = e._fullLayout.dragmode;
+            wr !== lr && (oe.dragmode = wr), N(), Z = e._fullLayout._invScaleX, j = e._fullLayout._invScaleY, g || (u ? It.shiftKey ? wr === "pan" ? wr = "zoom" : IP(wr) || (wr = "pan") : It.ctrlKey && (wr = "pan") : wr = "pan"), ldt(wr) ? oe.minDrag = 1 : oe.minDrag = void 0, IP(wr) ? (oe.xaxes = _, oe.yaxes = b, ddt(It, mt, er, oe, wr)) : (oe.clickFn = Ce, IP(lr) && _e(), g || (wr === "zoom" ? (oe.moveFn = je, oe.doneFn = pt, oe.minDrag = 1, ce(It, mt, er)) : wr === "pan" && (oe.moveFn = $t, oe.doneFn = $e))), e._fullLayout._redrag = function() {
+              var Lr = e._dragdata;
+              if (Lr && Lr.element === re) {
+                var ti = e._fullLayout.dragmode;
+                IP(ti) || (N(), St([0, 0, E, T]), oe.moveFn(Lr.dx, Lr.dy));
+              }
+            };
+          };
+          function _e() {
+            oe.plotinfo.selection = false, vdt(e);
+          }
+          function Ce(It, mt) {
+            var er = oe.gd;
+            if (er._fullLayout._activeShapeIndex >= 0) {
+              er._fullLayout._deactivateShape(er);
+              return;
+            }
+            var lr = er._fullLayout.clickmode;
+            if (VN(er), It === 2 && !c && fr(), u) lr.indexOf("select") > -1 && pdt(mt, er, _, b, t.id, oe), lr.indexOf("event") > -1 && adt.click(er, mt, t.id);
+            else if (It === 1 && c) {
+              var wr = o ? h : f, Lr = o === "s" || s === "w" ? 0 : 1, ti = wr._name + ".range[" + Lr + "]", Br = mdt(wr, Lr), Vr = "left", dt = "middle";
+              if (wr.fixedrange) return;
+              o ? (dt = o === "n" ? "top" : "bottom", wr.side === "right" && (Vr = "right")) : s === "e" && (Vr = "right"), er._context.showAxisRangeEntryBoxes && GN.select(re).call(ndt.makeEditable, { gd: er, immediate: true, background: er._fullLayout.paper_bgcolor, text: String(Br), fill: wr.tickfont ? wr.tickfont.color : "#444", horizontalAlign: Vr, verticalAlign: dt }).on("edit", function(Ge) {
+                var Je = wr.d2r(Ge);
+                Je !== void 0 && PP.call("_guiRelayout", er, ti, Je);
+              });
+            }
+          }
+          sdt.init(oe);
+          var Le, ge, ie, Se, Ee, Ae, Be, Pe, me, De;
+          function ce(It, mt, er) {
+            var lr = re.getBoundingClientRect();
+            Le = mt - lr.left, ge = er - lr.top, e._fullLayout._calcInverseTransform(e);
+            var wr = C0.apply3DTransform(e._fullLayout._invTransform)(Le, ge);
+            Le = wr[0], ge = wr[1], ie = { l: Le, r: Le, w: 0, t: ge, b: ge, h: 0 }, Se = e._hmpixcount ? e._hmlumcount / e._hmpixcount : rdt(e._fullLayout.plot_bgcolor).getLuminance(), Ee = "M0,0H" + E + "V" + T + "H0V0", Ae = false, Be = "xy", De = false, Pe = whe(l, Se, p, k, Ee), me = The(l, p, k);
+          }
+          function je(It, mt) {
+            if (e._transitioningWithDuration) return false;
+            var er = Math.max(0, Math.min(E, Z * It + Le)), lr = Math.max(0, Math.min(T, j * mt + ge)), wr = Math.abs(er - Le), Lr = Math.abs(lr - ge);
+            ie.l = Math.min(Le, er), ie.r = Math.max(Le, er), ie.t = Math.min(ge, lr), ie.b = Math.max(ge, lr);
+            function ti() {
+              Be = "", ie.r = ie.l, ie.t = ie.b, me.attr("d", "M0,0Z");
+            }
+            if (L.isSubplotConstrained) wr > ap || Lr > ap ? (Be = "xy", wr / E > Lr / T ? (Lr = wr * T / E, ge > lr ? ie.t = ge - Lr : ie.b = ge + Lr) : (wr = Lr * E / T, Le > er ? ie.l = Le - wr : ie.r = Le + wr), me.attr("d", RP(ie))) : ti();
+            else if (x.isSubplotConstrained) if (wr > ap || Lr > ap) {
+              Be = "xy";
+              var Br = Math.min(ie.l / E, (T - ie.b) / T), Vr = Math.max(ie.r / E, (T - ie.t) / T);
+              ie.l = Br * E, ie.r = Vr * E, ie.b = (1 - Br) * T, ie.t = (1 - Vr) * T, me.attr("d", RP(ie));
+            } else ti();
+            else !M || Lr < Math.min(Math.max(wr * 0.6, hhe), ap) ? wr < hhe || !C ? ti() : (ie.t = 0, ie.b = T, Be = "x", me.attr("d", xdt(ie, ge))) : !C || wr < Math.min(Lr * 0.6, ap) ? (ie.l = 0, ie.r = E, Be = "y", me.attr("d", bdt(ie, Le))) : (Be = "xy", me.attr("d", RP(ie)));
+            ie.w = ie.r - ie.l, ie.h = ie.b - ie.t, Be && (De = true), e._dragged = De, Ahe(Pe, me, ie, Ee, Ae, Se), lt(), e.emit("plotly_relayouting", G), Ae = true;
+          }
+          function lt() {
+            G = {}, (Be === "xy" || Be === "x") && (UN(_, ie.l / E, ie.r / E, G, L.xaxes), sr("x", G)), (Be === "xy" || Be === "y") && (UN(b, (T - ie.b) / T, (T - ie.t) / T, G, L.yaxes), sr("y", G));
+          }
+          function pt() {
+            lt(), VN(e), $e(), Mhe(e);
+          }
+          var Vt = [0, 0, E, T], ot = null, ut = HN.REDRAWDELAY, Wt = t.mainplot ? e._fullLayout._plots[t.mainplot] : t;
+          function Nt(It) {
+            if (!e._context._scrollZoom.cartesian && !e._fullLayout._enablescrollzoom) return;
+            if (_e(), e._transitioningWithDuration) {
+              It.preventDefault(), It.stopPropagation();
+              return;
+            }
+            N(), clearTimeout(ot);
+            var mt = -It.deltaY;
+            if (isFinite(mt) || (mt = It.wheelDelta / 10), !isFinite(mt)) {
+              C0.log("Did not find wheel motion attributes: ", It);
+              return;
+            }
+            var er = Math.exp(-Math.min(Math.max(mt, -20), 20) / 200), lr = Wt.draglayer.select(".nsewdrag").node().getBoundingClientRect(), wr = (It.clientX - lr.left) / lr.width, Lr = (lr.bottom - It.clientY) / lr.height, ti;
+            function Br(Vr, dt, Ge) {
+              if (Vr.fixedrange) return;
+              var Je = C0.simpleMap(Vr.range, Vr.r2l), We = Je[0] + (Je[1] - Je[0]) * dt;
+              function tt(xt) {
+                return Vr.l2r(We + (xt - We) * Ge);
+              }
+              Vr.range = Je.map(tt);
+            }
+            if (P) {
+              for (s || (wr = 0.5), ti = 0; ti < _.length; ti++) Br(_[ti], wr, er);
+              sr("x"), Vt[2] *= er, Vt[0] += Vt[2] * wr * (1 / er - 1);
+            }
+            if (A) {
+              for (o || (Lr = 0.5), ti = 0; ti < b.length; ti++) Br(b[ti], Lr, er);
+              sr("y"), Vt[3] *= er, Vt[1] += Vt[3] * (1 - Lr) * (1 / er - 1);
+            }
+            St(Vt), Tr(), e.emit("plotly_relayouting", G), ot = setTimeout(function() {
+              e._fullLayout && (Vt = [0, 0, E, T], $e());
+            }, ut), It.preventDefault();
+          }
+          o.length * s.length !== 1 && Ehe(re, Nt);
+          function $t(It, mt) {
+            if (It = It * Z, mt = mt * j, e._transitioningWithDuration) return;
+            if (e._fullLayout._replotting = true, C === "ew" || M === "ns") {
+              var er = C ? -It : 0, lr = M ? -mt : 0;
+              if (x.isSubplotConstrained) {
+                if (C && M) {
+                  var wr = (It / E - mt / T) / 2;
+                  It = wr * E, mt = -wr * T, er = -It, lr = -mt;
+                }
+                M ? er = -lr * E / T : lr = -er * T / E;
+              }
+              C && (phe(_, It), sr("x")), M && (phe(b, mt), sr("y")), St([er, lr, E, T]), Tr(), e.emit("plotly_relayouting", G);
+              return;
+            }
+            function Lr(tt, xt, Ie) {
+              for (var xe = 1 - xt, ke, vt, ir = 0; ir < tt.length; ir++) {
+                var ar = tt[ir];
+                if (!ar.fixedrange) {
+                  ke = ar, vt = ar._rl[xe] + (ar._rl[xt] - ar._rl[xe]) / ydt(Ie / ar._length);
+                  var vr = ar.l2r(vt);
+                  vr !== false && vr !== void 0 && (ar.range[xt] = vr);
+                }
+              }
+              return ke._length * (ke._rl[xt] - vt) / (ke._rl[xt] - ke._rl[xe]);
+            }
+            var ti = C === "w" == (M === "n") ? 1 : -1;
+            if (C && M && (L.isSubplotConstrained || x.isSubplotConstrained)) {
+              var Br = (It / E + ti * mt / T) / 2;
+              It = Br * E, mt = ti * Br * T;
+            }
+            var Vr, dt;
+            if (C === "w" ? It = Lr(_, 0, It) : C === "e" ? It = Lr(_, 1, -It) : C || (It = 0), M === "n" ? mt = Lr(b, 1, mt) : M === "s" ? mt = Lr(b, 0, -mt) : M || (mt = 0), Vr = C === "w" ? It : 0, dt = M === "n" ? mt : 0, L.isSubplotConstrained && !x.isSubplotConstrained || x.isSubplotConstrained && C && M && ti > 0) {
+              var Ge;
+              if (x.isSubplotConstrained || !C && M.length === 1) {
+                for (Ge = 0; Ge < _.length; Ge++) _[Ge].range = _[Ge]._r.slice(), BN(_[Ge], 1 - mt / T);
+                It = mt * E / T, Vr = It / 2;
+              }
+              if (x.isSubplotConstrained || !M && C.length === 1) {
+                for (Ge = 0; Ge < b.length; Ge++) b[Ge].range = b[Ge]._r.slice(), BN(b[Ge], 1 - It / E);
+                mt = It * T / E, dt = mt / 2;
+              }
+            }
+            (!x.isSubplotConstrained || !M) && sr("x"), (!x.isSubplotConstrained || !C) && sr("y");
+            var Je = E - It, We = T - mt;
+            x.isSubplotConstrained && !(C && M) && (C ? (dt = Vr ? 0 : It * T / E, We = Je * T / E) : (Vr = dt ? 0 : mt * E / T, Je = We * E / T)), St([Vr, dt, Je, We]), Tr(), e.emit("plotly_relayouting", G);
+          }
+          function sr(It, mt) {
+            for (var er = x.isSubplotConstrained ? { x: b, y: _ }[It] : x[It + "axes"], lr = x.isSubplotConstrained ? { x: _, y: b }[It] : [], wr = 0; wr < er.length; wr++) {
+              var Lr = er[wr], ti = Lr._id, Br = x.xLinks[ti] || x.yLinks[ti], Vr = lr[0] || d[Br] || v[Br];
+              Vr && (mt ? (mt[Lr._name + ".range[0]"] = mt[Vr._name + ".range[0]"], mt[Lr._name + ".range[1]"] = mt[Vr._name + ".range[1]"]) : Lr.range = Vr.range.slice());
+            }
+          }
+          function Tr() {
+            var It = [], mt;
+            function er(ti) {
+              for (mt = 0; mt < ti.length; mt++) ti[mt].fixedrange || It.push(ti[mt]._id);
+            }
+            function lr(ti, Br) {
+              for (mt = 0; mt < ti.length; mt++) {
+                var Vr = ti[mt], dt = Vr[Br];
+                !Vr.fixedrange && dt.tickmode === "sync" && It.push(dt._id);
+              }
+            }
+            for (P && (er(_), er(L.xaxes), er(x.xaxes), lr(t.overlays, "xaxis")), A && (er(b), er(L.yaxes), er(x.yaxes), lr(t.overlays, "yaxis")), G = {}, mt = 0; mt < It.length; mt++) {
+              var wr = It[mt], Lr = NN(e, wr);
+              fhe.drawOne(e, Lr, { skipTitle: true }), G[Lr._name + ".range[0]"] = Lr.range[0], G[Lr._name + ".range[1]"] = Lr.range[1];
+            }
+            fhe.redrawComponents(e, It);
+          }
+          function fr() {
+            if (!e._transitioningWithDuration) {
+              var It = e._context.doubleClick, mt = [];
+              C && (mt = mt.concat(_)), M && (mt = mt.concat(b)), x.xaxes && (mt = mt.concat(x.xaxes)), x.yaxes && (mt = mt.concat(x.yaxes));
+              var er = {}, lr, wr;
+              if (It === "reset+autosize") for (It = "autosize", wr = 0; wr < mt.length; wr++) {
+                lr = mt[wr];
+                var Lr = lr._rangeInitial0, ti = lr._rangeInitial1, Br = Lr !== void 0 || ti !== void 0;
+                if (Br && (Lr !== void 0 && Lr !== lr.range[0] || ti !== void 0 && ti !== lr.range[1]) || !Br && lr.autorange !== true) {
+                  It = "reset";
+                  break;
+                }
+              }
+              if (It === "autosize") for (wr = 0; wr < mt.length; wr++) lr = mt[wr], lr.fixedrange || (er[lr._name + ".autorange"] = true);
+              else if (It === "reset") {
+                for ((C || L.isSubplotConstrained) && (mt = mt.concat(L.xaxes)), M && !L.isSubplotConstrained && (mt = mt.concat(L.yaxes)), L.isSubplotConstrained && (C ? M || (mt = mt.concat(b)) : mt = mt.concat(_)), wr = 0; wr < mt.length; wr++) if (lr = mt[wr], !lr.fixedrange) {
+                  var Vr = lr._name, dt = lr._autorangeInitial;
+                  lr._rangeInitial0 === void 0 && lr._rangeInitial1 === void 0 ? er[Vr + ".autorange"] = true : lr._rangeInitial0 === void 0 ? (er[Vr + ".autorange"] = dt, er[Vr + ".range"] = [null, lr._rangeInitial1]) : lr._rangeInitial1 === void 0 ? (er[Vr + ".range"] = [lr._rangeInitial0, null], er[Vr + ".autorange"] = dt) : er[Vr + ".range"] = [lr._rangeInitial0, lr._rangeInitial1];
+                }
+              }
+              e.emit("plotly_doubleclick", null), PP.call("_guiRelayout", e, er);
+            }
+          }
+          function $e() {
+            St([0, 0, E, T]), C0.syncOrAsync([hdt.previousPromises, function() {
+              e._fullLayout._replotting = false, PP.call("_guiRelayout", e, G);
+            }], e);
+          }
+          function St(It) {
+            var mt = e._fullLayout, er = mt._plots, lr = mt._subplots.cartesian, wr, Lr, ti, Br;
+            if (O && PP.subplotsRegistry.splom.drag(e), z) {
+              for (wr = 0; wr < lr.length; wr++) if (Lr = er[lr[wr]], ti = Lr.xaxis, Br = Lr.yaxis, Lr._scene) {
+                ti.limitRange && ti.limitRange(), Br.limitRange && Br.limitRange();
+                var Vr = C0.simpleMap(ti.range, ti.r2l), dt = C0.simpleMap(Br.range, Br.r2l);
+                Lr._scene.update({ range: [Vr[0], dt[0], Vr[1], dt[1]] });
+              }
+            }
+            if ((O || z) && (cdt(e), fdt(e)), U) {
+              var Ge = It[2] / f._length, Je = It[3] / h._length;
+              for (wr = 0; wr < lr.length; wr++) {
+                Lr = er[lr[wr]], ti = Lr.xaxis, Br = Lr.yaxis;
+                var We = (P || x.isSubplotConstrained) && !ti.fixedrange && d[ti._id], tt = (A || x.isSubplotConstrained) && !Br.fixedrange && v[Br._id], xt, Ie, xe, ke;
+                if (We ? (xt = Ge, xe = s || x.isSubplotConstrained ? It[0] : _t(ti, xt)) : x.xaHash[ti._id] ? (xt = Ge, xe = It[0] * ti._length / f._length) : x.yaHash[ti._id] ? (xt = Je, xe = M === "ns" ? -It[1] * ti._length / h._length : _t(ti, xt, { n: "top", s: "bottom" }[M])) : (xt = Qt(ti, Ge, Je), xe = Gt(ti, xt)), xt > 1 && (ti.maxallowed !== void 0 && P === (ti.range[0] < ti.range[1] ? "e" : "w") || ti.minallowed !== void 0 && P === (ti.range[0] < ti.range[1] ? "w" : "e")) && (xt = 1, xe = 0), tt ? (Ie = Je, ke = o || x.isSubplotConstrained ? It[1] : _t(Br, Ie)) : x.yaHash[Br._id] ? (Ie = Je, ke = It[1] * Br._length / h._length) : x.xaHash[Br._id] ? (Ie = Ge, ke = C === "ew" ? -It[0] * Br._length / f._length : _t(Br, Ie, { e: "right", w: "left" }[C])) : (Ie = Qt(Br, Ge, Je), ke = Gt(Br, Ie)), Ie > 1 && (Br.maxallowed !== void 0 && A === (Br.range[0] < Br.range[1] ? "n" : "s") || Br.minallowed !== void 0 && A === (Br.range[0] < Br.range[1] ? "s" : "n")) && (Ie = 1, ke = 0), !(!xt && !Ie)) {
+                  xt || (xt = 1), Ie || (Ie = 1);
+                  var vt = ti._offset - xe / xt, ir = Br._offset - ke / Ie;
+                  Lr.clipRect.call(w_.setTranslate, xe, ke).call(w_.setScale, xt, Ie), Lr.plot.call(w_.setTranslate, vt, ir).call(w_.setScale, 1 / xt, 1 / Ie), (xt !== Lr.xScaleFactor || Ie !== Lr.yScaleFactor) && (w_.setPointGroupScale(Lr.zoomScalePts, xt, Ie), w_.setTextPointsScale(Lr.zoomScaleTxt, xt, Ie)), w_.hideOutsideRangePoints(Lr.clipOnAxisFalseTraces, Lr), Lr.xScaleFactor = xt, Lr.yScaleFactor = Ie;
+                }
+              }
+            }
+          }
+          function Qt(It, mt, er) {
+            return It.fixedrange ? 0 : P && L.xaHash[It._id] ? mt : A && (L.isSubplotConstrained ? L.xaHash : L.yaHash)[It._id] ? er : 0;
+          }
+          function Gt(It, mt) {
+            return mt ? (It.range = It._r.slice(), BN(It, mt), _t(It, mt)) : 0;
+          }
+          function _t(It, mt, er) {
+            return It._length * (1 - mt) * udt[er || It.constraintoward || "middle"];
+          }
+          return re;
+        }
+        function xhe(e, t, r, n) {
+          var i = C0.ensureSingle(e.draglayer, t, r, function(a) {
+            a.classed("drag", true).style({ fill: "transparent", "stroke-width": 0 }).attr("data-subplot", e.id);
+          });
+          return i.call(odt, n), i.node();
+        }
+        function bhe(e, t, r, n, i, a, o) {
+          var s = xhe(e, "rect", t, r);
+          return GN.select(s).call(w_.setRect, n, i, a, o), s;
+        }
+        function vhe(e, t) {
+          for (var r = 0; r < e.length; r++) if (!e[r].fixedrange) return t;
+          return "";
+        }
+        function mdt(e, t) {
+          var r = e.range[t], n = Math.abs(r - e.range[1 - t]), i;
+          return e.type === "date" ? r : e.type === "log" ? (i = Math.ceil(Math.max(0, -Math.log(n) / Math.LN10)) + 3, uhe("." + i + "g")(Math.pow(10, r))) : (i = Math.floor(Math.log(Math.abs(r)) / Math.LN10) - Math.floor(Math.log(n) / Math.LN10) + 4, uhe("." + String(i) + "g")(r));
+        }
+        function UN(e, t, r, n, i) {
+          for (var a = 0; a < e.length; a++) {
+            var o = e[a];
+            if (!o.fixedrange) if (o.rangebreaks) {
+              var s = o._id.charAt(0) === "y", l = s ? 1 - t : t, u = s ? 1 - r : r;
+              n[o._name + ".range[0]"] = o.l2r(o.p2l(l * o._length)), n[o._name + ".range[1]"] = o.l2r(o.p2l(u * o._length));
+            } else {
+              var c = o._rl[0], f = o._rl[1] - c;
+              n[o._name + ".range[0]"] = o.l2r(c + f * t), n[o._name + ".range[1]"] = o.l2r(c + f * r);
+            }
+          }
+          if (i && i.length) {
+            var h = (t + (1 - r)) / 2;
+            UN(i, h, 1 - h, n, []);
+          }
+        }
+        function phe(e, t) {
+          for (var r = 0; r < e.length; r++) {
+            var n = e[r];
+            if (!n.fixedrange) {
+              if (n.rangebreaks) {
+                var i = 0, a = n._length, o = n.p2l(i + t) - n.p2l(i), s = n.p2l(a + t) - n.p2l(a), l = (o + s) / 2;
+                n.range = [n.l2r(n._rl[0] - l), n.l2r(n._rl[1] - l)];
+              } else n.range = [n.l2r(n._rl[0] - t / n._m), n.l2r(n._rl[1] - t / n._m)];
+              n.limitRange && n.limitRange();
+            }
+          }
+        }
+        function ydt(e) {
+          return 1 - (e >= 0 ? Math.min(e, 0.9) : 1 / (1 / Math.max(e, -0.3) + 3.222));
+        }
+        function _dt(e, t, r) {
+          return e ? e === "nsew" ? r ? "" : t === "pan" ? "move" : "crosshair" : e.toLowerCase() + "-resize" : "pointer";
+        }
+        function whe(e, t, r, n, i) {
+          return e.append("path").attr("class", "zoombox").style({ fill: t > 0.2 ? "rgba(0,0,0,0)" : "rgba(255,255,255,0)", "stroke-width": 0 }).attr("transform", yhe(r, n)).attr("d", i + "Z");
+        }
+        function The(e, t, r) {
+          return e.append("path").attr("class", "zoombox-corners").style({ fill: che.background, stroke: che.defaultLine, "stroke-width": 1, opacity: 0 }).attr("transform", yhe(t, r)).attr("d", "M0,0Z");
+        }
+        function Ahe(e, t, r, n, i, a) {
+          e.attr("d", n + "M" + r.l + "," + r.t + "v" + r.h + "h" + r.w + "v-" + r.h + "h-" + r.w + "Z"), She(e, t, i, a);
+        }
+        function She(e, t, r, n) {
+          r || (e.transition().style("fill", n > 0.2 ? "rgba(0,0,0,0.4)" : "rgba(255,255,255,0.3)").duration(200), t.transition().style("opacity", 1).duration(200));
+        }
+        function VN(e) {
+          GN.select(e).selectAll(".zoombox,.js-zoombox-backdrop,.js-zoombox-menu,.zoombox-corners").remove();
+        }
+        function Mhe(e) {
+          dhe && e.data && e._context.showTips && (C0.notifier(C0._(e, "Double-click to zoom back out"), "long"), dhe = false);
+        }
+        function xdt(e, t) {
+          return "M" + (e.l - 0.5) + "," + (t - ap - 0.5) + "h-3v" + (2 * ap + 1) + "h3ZM" + (e.r + 0.5) + "," + (t - ap - 0.5) + "h3v" + (2 * ap + 1) + "h-3Z";
+        }
+        function bdt(e, t) {
+          return "M" + (t - ap - 0.5) + "," + (e.t - 0.5) + "v-3h" + (2 * ap + 1) + "v3ZM" + (t - ap - 0.5) + "," + (e.b + 0.5) + "v3h" + (2 * ap + 1) + "v-3Z";
+        }
+        function RP(e) {
+          var t = Math.floor(Math.min(e.b - e.t, e.r - e.l, ap) / 2);
+          return "M" + (e.l - 3.5) + "," + (e.t - 0.5 + t) + "h3v" + -t + "h" + t + "v-3h-" + (t + 3) + "ZM" + (e.r + 3.5) + "," + (e.t - 0.5 + t) + "h-3v" + -t + "h" + -t + "v-3h" + (t + 3) + "ZM" + (e.r + 3.5) + "," + (e.b + 0.5 - t) + "h-3v" + t + "h" + -t + "v3h" + (t + 3) + "ZM" + (e.l - 3.5) + "," + (e.b + 0.5 - t) + "h3v" + t + "h" + t + "v3h-" + (t + 3) + "Z";
+        }
+        function ghe(e, t, r, n, i) {
+          for (var a = false, o = {}, s = {}, l, u, c, f, h = (i || {}).xaHash, d = (i || {}).yaHash, v = 0; v < t.length; v++) {
+            var _ = t[v];
+            for (l in r) if (_[l]) {
+              for (c in _) !(i && (h[c] || d[c])) && !(c.charAt(0) === "x" ? r : n)[c] && (o[c] = l);
+              for (u in n) !(i && (h[u] || d[u])) && _[u] && (a = true);
+            }
+            for (u in n) if (_[u]) for (f in _) !(i && (h[f] || d[f])) && !(f.charAt(0) === "x" ? r : n)[f] && (s[f] = u);
+          }
+          a && (C0.extendFlat(o, s), s = {});
+          var b = {}, p = [];
+          for (c in o) {
+            var k = NN(e, c);
+            p.push(k), b[k._id] = k;
+          }
+          var E = {}, T = [];
+          for (f in s) {
+            var L = NN(e, f);
+            T.push(L), E[L._id] = L;
+          }
+          return { xaHash: b, yaHash: E, xaxes: p, yaxes: T, xLinks: o, yLinks: s, isSubplotConstrained: a };
+        }
+        function Ehe(e, t) {
+          if (!idt) e.onwheel !== void 0 ? e.onwheel = t : e.onmousewheel !== void 0 ? e.onmousewheel = t : e.isAddedWheelEvent || (e.isAddedWheelEvent = true, e.addEventListener("wheel", t, { passive: false }));
+          else {
+            var r = e.onwheel !== void 0 ? "wheel" : "mousewheel";
+            e._onwheel && e.removeEventListener(r, e._onwheel), e._onwheel = t, e.addEventListener(r, t, { passive: false });
+          }
+        }
+        function mhe(e) {
+          var t = [];
+          for (var r in e) t.push(e[r]);
+          return t;
+        }
+        khe.exports = { makeDragBox: gdt, makeDragger: xhe, makeRectDragger: bhe, makeZoombox: whe, makeCorners: The, updateZoombox: Ahe, xyCorners: RP, transitionZoombox: She, removeZoombox: VN, showDoubleClickNotifier: Mhe, attachWheelEventHandler: Ehe };
+      });
+      var WN = ye((FP) => {
+        var wdt = Oa(), DP = vf(), Tdt = yv(), Adt = Eg(), Ig = jN().makeDragBox, gd = Rh().DRAGGERSIZE;
+        FP.initInteractions = function(t) {
+          var r = t._fullLayout;
+          if (t._context.staticPlot) {
+            wdt.select(t).selectAll(".drag").remove();
+            return;
+          }
+          if (!(!r._has("cartesian") && !r._has("splom"))) {
+            var n = Object.keys(r._plots || {}).sort(function(a, o) {
+              if ((r._plots[a].mainplot && true) === (r._plots[o].mainplot && true)) {
+                var s = a.split("y"), l = o.split("y");
+                return s[0] === l[0] ? Number(s[1] || 1) - Number(l[1] || 1) : Number(s[0] || 1) - Number(l[0] || 1);
+              }
+              return r._plots[a].mainplot ? 1 : -1;
+            });
+            n.forEach(function(a) {
+              var o = r._plots[a], s = o.xaxis, l = o.yaxis;
+              if (!o.mainplot) {
+                var u = Ig(t, o, s._offset, l._offset, s._length, l._length, "ns", "ew");
+                u.onmousemove = function(h) {
+                  t._fullLayout._rehover = function() {
+                    t._fullLayout._hoversubplot === a && t._fullLayout._plots[a] && DP.hover(t, h, a);
+                  }, DP.hover(t, h, a), t._fullLayout._lasthover = u, t._fullLayout._hoversubplot = a;
+                }, u.onmouseout = function(h) {
+                  t._dragging || (t._fullLayout._hoversubplot = null, Tdt.unhover(t, h));
+                }, t._context.showAxisDragHandles && (Ig(t, o, s._offset - gd, l._offset - gd, gd, gd, "n", "w"), Ig(t, o, s._offset + s._length, l._offset - gd, gd, gd, "n", "e"), Ig(t, o, s._offset - gd, l._offset + l._length, gd, gd, "s", "w"), Ig(t, o, s._offset + s._length, l._offset + l._length, gd, gd, "s", "e"));
+              }
+              if (t._context.showAxisDragHandles) {
+                if (a === s._mainSubplot) {
+                  var c = s._mainLinePosition;
+                  s.side === "top" && (c -= gd), Ig(t, o, s._offset + s._length * 0.1, c, s._length * 0.8, gd, "", "ew"), Ig(t, o, s._offset, c, s._length * 0.1, gd, "", "w"), Ig(t, o, s._offset + s._length * 0.9, c, s._length * 0.1, gd, "", "e");
+                }
+                if (a === l._mainSubplot) {
+                  var f = l._mainLinePosition;
+                  l.side !== "right" && (f -= gd), Ig(t, o, f, l._offset + l._length * 0.1, gd, l._length * 0.8, "ns", ""), Ig(t, o, f, l._offset + l._length * 0.9, gd, l._length * 0.1, "s", ""), Ig(t, o, f, l._offset, gd, l._length * 0.1, "n", "");
+                }
+              }
+            });
+            var i = r._hoverlayer.node();
+            i.onmousemove = function(a) {
+              a.target = t._fullLayout._lasthover, DP.hover(t, a, r._hoversubplot);
+            }, i.onclick = function(a) {
+              a.target = t._fullLayout._lasthover, DP.click(t, a);
+            }, i.onmousedown = function(a) {
+              t._fullLayout._lasthover.onmousedown(a);
+            }, FP.updateFx(t);
+          }
+        };
+        FP.updateFx = function(e) {
+          var t = e._fullLayout, r = t.dragmode === "pan" ? "move" : "crosshair";
+          Adt(t._draggers, r);
+        };
+      });
+      var Phe = ye((Dor, Lhe) => {
+        var Che = qa();
+        Lhe.exports = function(t) {
+          for (var r = Che.layoutArrayContainers, n = Che.layoutArrayRegexes, i = t.split("[")[0], a, o, s = 0; s < n.length; s++) if (o = t.match(n[s]), o && o.index === 0) {
+            a = o[0];
+            break;
+          }
+          if (a || (a = r[r.indexOf(i)]), !a) return false;
+          var l = t.slice(a.length);
+          return l ? (o = l.match(/^\[(0|[1-9][0-9]*)\](\.(.+))?$/), o ? { array: a, index: Number(o[1]), property: o[3] || "" } : false) : { array: a, index: "", property: "" };
+        };
+      });
+      var Rhe = ye((YM) => {
+        var Sdt = Ty(), XN = L6(), ZM = K1(), Mdt = U6().sorterAsc, ZN = qa();
+        YM.containerArrayMatch = Phe();
+        var Edt = YM.isAddVal = function(t) {
+          return t === "add" || Sdt(t);
+        }, Ihe = YM.isRemoveVal = function(t) {
+          return t === null || t === "remove";
+        };
+        YM.applyContainerArrayChanges = function(t, r, n, i, a) {
+          var o = r.astr, s = ZN.getComponentMethod(o, "supplyLayoutDefaults"), l = ZN.getComponentMethod(o, "draw"), u = ZN.getComponentMethod(o, "drawOne"), c = i.replot || i.recalc || s === XN || l === XN, f = t.layout, h = t._fullLayout;
+          if (n[""]) {
+            Object.keys(n).length > 1 && ZM.warn("Full array edits are incompatible with other edits", o);
+            var d = n[""][""];
+            if (Ihe(d)) r.set(null);
+            else if (Array.isArray(d)) r.set(d);
+            else return ZM.warn("Unrecognized full array edit value", o, d), true;
+            return c ? false : (s(f, h), l(t), true);
+          }
+          var v = Object.keys(n).map(Number).sort(Mdt), _ = r.get(), b = _ || [], p = a(h, o).get(), k = [], E = -1, T = b.length, L, x, C, M, g, P, A, z;
+          for (L = 0; L < v.length; L++) {
+            if (C = v[L], M = n[C], g = Object.keys(M), P = M[""], A = Edt(P), C < 0 || C > b.length - (A ? 0 : 1)) {
+              ZM.warn("index out of range", o, C);
+              continue;
+            }
+            if (P !== void 0) g.length > 1 && ZM.warn("Insertion & removal are incompatible with edits to the same index.", o, C), Ihe(P) ? k.push(C) : A ? (P === "add" && (P = {}), b.splice(C, 0, P), p && p.splice(C, 0, {})) : ZM.warn("Unrecognized full object edit value", o, C, P), E === -1 && (E = C);
+            else for (x = 0; x < g.length; x++) z = o + "[" + C + "].", a(b[C], g[x], z).set(M[g[x]]);
+          }
+          for (L = k.length - 1; L >= 0; L--) b.splice(k[L], 1), p && p.splice(k[L], 1);
+          if (b.length ? _ || r.set(b) : r.set(null), c) return false;
+          if (s(f, h), u !== XN) {
+            var O;
+            if (E === -1) O = v;
+            else {
+              for (T = Math.max(b.length, T), O = [], L = 0; L < v.length && (C = v[L], !(C >= E)); L++) O.push(C);
+              for (L = E; L < T; L++) O.push(L);
+            }
+            for (L = 0; L < O.length; L++) u(t, O[L]);
+          } else l(t);
+          return true;
+        };
+      });
+      var Uhe = ye((L0) => {
+        var Ohe = Eo(), qhe = qa(), Uv = Dr(), KM = Mc(), Bhe = hf(), Nhe = ka(), JM = Bhe.cleanId, kdt = Bhe.getFromTrace, YN = qhe.traceIs, Cdt = ["x", "y", "z"];
+        L0.clearPromiseQueue = function(e) {
+          Array.isArray(e._promises) && e._promises.length > 0 && Uv.log("Clearing previous rejected promises from queue."), e._promises = [];
+        };
+        L0.cleanLayout = function(e) {
+          var t;
+          e || (e = {}), e.xaxis1 && (e.xaxis || (e.xaxis = e.xaxis1), delete e.xaxis1), e.yaxis1 && (e.yaxis || (e.yaxis = e.yaxis1), delete e.yaxis1), e.scene1 && (e.scene || (e.scene = e.scene1), delete e.scene1);
+          var n = (KM.subplotsRegistry.cartesian || {}).attrRegex;
+          (KM.subplotsRegistry.polar || {}).attrRegex;
+          (KM.subplotsRegistry.ternary || {}).attrRegex;
+          (KM.subplotsRegistry.gl3d || {}).attrRegex;
+          var s = Object.keys(e);
+          for (t = 0; t < s.length; t++) {
+            var l = s[t];
+            if (n && n.test(l)) {
+              var u = e[l];
+              u.anchor && u.anchor !== "free" && (u.anchor = JM(u.anchor)), u.overlaying && (u.overlaying = JM(u.overlaying)), u.type || (u.isdate ? u.type = "date" : u.islog ? u.type = "log" : u.isdate === false && u.islog === false && (u.type = "linear")), (u.autorange === "withzero" || u.autorange === "tozero") && (u.autorange = true, u.rangemode = "tozero"), u.insiderange && delete u.range, delete u.islog, delete u.isdate, delete u.categories, zP(u, "domain") && delete u.domain;
+            }
+          }
+          var c = Array.isArray(e.annotations) ? e.annotations.length : 0;
+          for (t = 0; t < c; t++) {
+            var f = e.annotations[t];
+            Uv.isPlainObject(f) && (aT(f, "xref"), aT(f, "yref"));
+          }
+          var h = Array.isArray(e.shapes) ? e.shapes.length : 0;
+          for (t = 0; t < h; t++) {
+            var d = e.shapes[t];
+            Uv.isPlainObject(d) && (aT(d, "xref", true), aT(d, "yref", true));
+          }
+          var v = Array.isArray(e.images) ? e.images.length : 0;
+          for (t = 0; t < v; t++) {
+            var _ = e.images[t];
+            Uv.isPlainObject(_) && (aT(_, "xref"), aT(_, "yref"));
+          }
+          var b = e.legend;
+          return b && (b.x > 3 ? (b.x = 1.02, b.xanchor = "left") : b.x < -2 && (b.x = -0.02, b.xanchor = "right"), b.y > 3 ? (b.y = 1.02, b.yanchor = "bottom") : b.y < -2 && (b.y = -0.02, b.yanchor = "top")), e.dragmode === "rotate" && (e.dragmode = "orbit"), Nhe.clean(e), e.template && e.template.layout && L0.cleanLayout(e.template.layout), e;
+        };
+        function aT(e, t, r = false) {
+          var n = e[t], i = t.charAt(0);
+          r && Array.isArray(n) || n && n !== "paper" && (e[t] = JM(n, i, true));
+        }
+        L0.cleanData = function(e) {
+          for (var t = 0; t < e.length; t++) {
+            var r = e[t], n;
+            if (r.type === "histogramy" && "xbins" in r && !("ybins" in r) && (r.ybins = r.xbins, delete r.xbins), r.type === "histogramy" && L0.swapXYData(r), (r.type === "histogramx" || r.type === "histogramy") && (r.type = "histogram"), "scl" in r && !("colorscale" in r) && (r.colorscale = r.scl, delete r.scl), "reversescl" in r && !("reversescale" in r) && (r.reversescale = r.reversescl, delete r.reversescl), r.xaxis && (r.xaxis = JM(r.xaxis, "x")), r.yaxis && (r.yaxis = JM(r.yaxis, "y")), YN(r, "gl3d") && r.scene && (r.scene = KM.subplotsRegistry.gl3d.cleanId(r.scene)), !YN(r, "pie-like") && !YN(r, "bar-like")) if (Array.isArray(r.textposition)) for (n = 0; n < r.textposition.length; n++) r.textposition[n] = Fhe(r.textposition[n]);
+            else r.textposition && (r.textposition = Fhe(r.textposition));
+            var i = qhe.getModule(r);
+            if (i && i.colorbar) {
+              var a = i.colorbar.container, o = a ? r[a] : r;
+              o && o.colorscale && (o.colorscale === "YIGnBu" && (o.colorscale = "YlGnBu"), o.colorscale === "YIOrRd" && (o.colorscale = "YlOrRd"));
+            }
+            if (r.type === "surface" && Uv.isPlainObject(r.contours)) {
+              var s = ["x", "y", "z"];
+              for (n = 0; n < s.length; n++) {
+                var l = r.contours[s[n]];
+                Uv.isPlainObject(l) && (l.highlightColor && (l.highlightcolor = l.highlightColor, delete l.highlightColor), l.highlightWidth && (l.highlightwidth = l.highlightWidth, delete l.highlightWidth));
+              }
+            }
+            if (r.type === "candlestick" || r.type === "ohlc") {
+              var u = (r.increasing || {}).showlegend !== false, c = (r.decreasing || {}).showlegend !== false, f = Dhe(r.increasing), h = Dhe(r.decreasing);
+              if (f !== false && h !== false) {
+                var d = Ldt(f, h, u, c);
+                d && (r.name = d);
+              } else (f || h) && !r.name && (r.name = f || h);
+            }
+            zP(r, "line") && delete r.line, "marker" in r && (zP(r.marker, "line") && delete r.marker.line, zP(r, "marker") && delete r.marker), Nhe.clean(r), r.autobinx && (delete r.autobinx, delete r.xbins), r.autobiny && (delete r.autobiny, delete r.ybins);
+          }
+        };
+        function Dhe(e) {
+          if (!Uv.isPlainObject(e)) return false;
+          var t = e.name;
+          return delete e.name, delete e.showlegend, (typeof t == "string" || typeof t == "number") && String(t);
+        }
+        function Ldt(e, t, r, n) {
+          if (r && !n) return e;
+          if (n && !r || !e.trim()) return t;
+          if (!t.trim()) return e;
+          var i = Math.min(e.length, t.length), a;
+          for (a = 0; a < i && e.charAt(a) === t.charAt(a); a++) ;
+          var o = e.slice(0, a);
+          return o.trim();
+        }
+        function Fhe(e) {
+          var t = "middle", r = "center";
+          return typeof e == "string" && (e.indexOf("top") !== -1 ? t = "top" : e.indexOf("bottom") !== -1 && (t = "bottom"), e.indexOf("left") !== -1 ? r = "left" : e.indexOf("right") !== -1 && (r = "right")), t + " " + r;
+        }
+        function zP(e, t) {
+          return t in e && typeof e[t] == "object" && Object.keys(e[t]).length === 0;
+        }
+        L0.swapXYData = function(e) {
+          var t;
+          if (Uv.swapAttrs(e, ["?", "?0", "d?", "?bins", "nbins?", "autobin?", "?src", "error_?"]), Array.isArray(e.z) && Array.isArray(e.z[0]) && (e.transpose ? delete e.transpose : e.transpose = true), e.error_x && e.error_y) {
+            var r = e.error_y, n = "copy_ystyle" in r ? r.copy_ystyle : !(r.color || r.thickness || r.width);
+            Uv.swapAttrs(e, ["error_?.copy_ystyle"]), n && Uv.swapAttrs(e, ["error_?.color", "error_?.thickness", "error_?.width"]);
+          }
+          if (typeof e.hoverinfo == "string") {
+            var i = e.hoverinfo.split("+");
+            for (t = 0; t < i.length; t++) i[t] === "x" ? i[t] = "y" : i[t] === "y" && (i[t] = "x");
+            e.hoverinfo = i.join("+");
+          }
+        };
+        L0.coerceTraceIndices = function(e, t) {
+          if (Ohe(t)) return [t];
+          if (!Array.isArray(t) || !t.length) return e.data.map(function(i, a) {
+            return a;
+          });
+          if (Array.isArray(t)) {
+            for (var r = [], n = 0; n < t.length; n++) Uv.isIndex(t[n], e.data.length) ? r.push(t[n]) : Uv.warn("trace index (", t[n], ") is not a number or is out of bounds");
+            return r;
+          }
+          return t;
+        };
+        L0.manageArrayContainers = function(e, t, r) {
+          var n = e.obj, i = e.parts, a = i.length, o = i[a - 1], s = Ohe(o);
+          if (s && t === null) {
+            var l = i.slice(0, a - 1).join("."), u = Uv.nestedProperty(n, l).get();
+            u.splice(o, 1);
+          } else s && e.get() === void 0 && e.get() === void 0 && (r[e.astr] = null), e.set(t);
+        };
+        var Pdt = /(\.[^\[\]\.]+|\[[^\[\]\.]+\])$/;
+        function zhe(e) {
+          var t = e.search(Pdt);
+          if (t > 0) return e.slice(0, t);
+        }
+        L0.hasParent = function(e, t) {
+          for (var r = zhe(t); r; ) {
+            if (r in e) return true;
+            r = zhe(r);
+          }
+          return false;
+        };
+        L0.clearAxisTypes = function(e, t, r) {
+          for (var n = 0; n < t.length; n++) for (var i = e._fullData[n], a = 0; a < 3; a++) {
+            var o = kdt(e, i, Cdt[a]);
+            if (o && o.type !== "log") {
+              var s = o._name, l = o._id.slice(1);
+              if (l.slice(0, 5) === "scene") {
+                if (r[l] !== void 0) continue;
+                s = l + "." + s;
+              }
+              var u = s + ".type";
+              r[s] === void 0 && r[u] === void 0 && Uv.nestedProperty(e.layout, u).set(null);
+            }
+          }
+        };
+        var KN = (e, t) => {
+          let r = (...n) => n.every((i) => Uv.isPlainObject(i)) || n.every((i) => Array.isArray(i));
+          if ([e, t].every((n) => Array.isArray(n))) {
+            if (e.length !== t.length) return false;
+            for (let n = 0; n < e.length; n++) {
+              let i = e[n], a = t[n];
+              if (i !== a && !(r(i, a) ? KN(i, a) : false)) return false;
+            }
+            return true;
+          } else if ([e, t].every((n) => Uv.isPlainObject(n))) {
+            if (Object.keys(e).length !== Object.keys(t).length) return false;
+            for (let n in e) {
+              if (n.startsWith("_")) continue;
+              let i = e[n], a = t[n];
+              if (i !== a && !(r(i, a) ? KN(i, a) : false)) return false;
+            }
+            return true;
+          }
+          return false;
+        };
+        L0.collectionsAreEqual = KN;
+      });
+      var ZP = ye((_l) => {
+        var BP = Oa(), Idt = Eo(), Rdt = lq(), Sa = Dr(), Ec = Sa.nestedProperty, QN = k3(), op = Sne(), P0 = qa(), WP = P3(), Qo = Mc(), Vv = ho(), Ddt = AB(), Fdt = Rd(), JN = So(), zdt = ka(), Odt = WN().initInteractions, qdt = Wp(), Bdt = Of().clearOutline, Whe = _b().dfltConfig, OP = Rhe(), gh = Uhe(), Au = CM(), T_ = mc(), Ndt = Rh().AX_NAME_PATTERN, $N = 0, Vhe = 5;
+        function Udt(e, t, r, n) {
+          var i;
+          if (e = Sa.getGraphDiv(e), QN.init(e), Sa.isPlainObject(t)) {
+            var a = t;
+            t = a.data, r = a.layout, n = a.config, i = a.frames;
+          }
+          var o = QN.triggerHandler(e, "plotly_beforeplot", [t, r, n]);
+          if (o === false) return Promise.reject();
+          !t && !r && !Sa.isPlotDiv(e) && Sa.warn("Calling _doPlot as if redrawing but this container doesn't yet have a plot.", e);
+          function s() {
+            if (i) return _l.addFrames(e, i);
+          }
+          Zhe(e, n), r || (r = {}), BP.select(e).classed("js-plotly-plot", true), JN.makeTester(), Array.isArray(e._promises) || (e._promises = []);
+          var l = (e.data || []).length === 0 && Array.isArray(t);
+          Array.isArray(t) && (gh.cleanData(t), l ? e.data = t : e.data.push.apply(e.data, t), e.empty = false), (!e.layout || l) && (e.layout = gh.cleanLayout(r)), Qo.supplyDefaults(e);
+          var u = e._fullLayout, c = u._has("cartesian");
+          u._replotting = true, (l || u._shouldCreateBgLayer) && (cvt(e), u._shouldCreateBgLayer && delete u._shouldCreateBgLayer), JN.initGradients(e), JN.initPatterns(e), l && Vv.saveShowSpikeInitial(e);
+          var f = !e.calcdata || e.calcdata.length !== (e._fullData || []).length;
+          f && Qo.doCalcdata(e);
+          for (var h = 0; h < e.calcdata.length; h++) e.calcdata[h][0].trace = e._fullData[h];
+          e._context.responsive ? e._responsiveChartHandler || (e._responsiveChartHandler = function() {
+            Sa.isHidden(e) || Qo.resize(e);
+          }, window.addEventListener("resize", e._responsiveChartHandler)) : Sa.clearResponsive(e);
+          var d = Sa.extendFlat({}, u._size), v = 0;
+          function _() {
+            for (var C = u._basePlotModules, M = 0; M < C.length; M++) C[M].drawFramework && C[M].drawFramework(e);
+            !u._glcanvas && u._has("gl") && (u._glcanvas = u._glcontainer.selectAll(".gl-canvas").data([{ key: "contextLayer", context: true, pick: false }, { key: "focusLayer", context: false, pick: false }, { key: "pickLayer", context: false, pick: true }], function(z) {
+              return z.key;
+            }), u._glcanvas.enter().append("canvas").attr("class", function(z) {
+              return "gl-canvas gl-canvas-" + z.key.replace("Layer", "");
+            }).style({ position: "absolute", top: 0, left: 0, overflow: "visible", "pointer-events": "none" }));
+            var g = e._context.plotGlPixelRatio;
+            if (u._glcanvas) {
+              u._glcanvas.attr("width", u.width * g).attr("height", u.height * g).style("width", u.width + "px").style("height", u.height + "px");
+              var P = u._glcanvas.data()[0].regl;
+              if (P && (Math.floor(u.width * g) !== P._gl.drawingBufferWidth || Math.floor(u.height * g) !== P._gl.drawingBufferHeight)) {
+                var A = "WebGL context buffer and canvas dimensions do not match due to browser/WebGL bug.";
+                if (v) Sa.error(A);
+                else return Sa.log(A + " Clearing graph and plotting again."), Qo.cleanPlot([], {}, e._fullData, u), Qo.supplyDefaults(e), u = e._fullLayout, Qo.doCalcdata(e), v++, _();
+              }
+            }
+            return u.modebar.orientation === "h" ? u._modebardiv.style("height", null).style("width", "100%") : u._modebardiv.style("width", null).style("height", u.height + "px"), Qo.previousPromises(e);
+          }
+          function b() {
+            if (Qo.clearAutoMarginIds(e), Au.drawMarginPushers(e), Vv.allowAutoMargin(e), e._fullLayout.title.text && e._fullLayout.title.automargin && Qo.allowAutoMargin(e, "title.automargin"), u._has("pie")) for (var C = e._fullData, M = 0; M < C.length; M++) {
+              var g = C[M];
+              g.type === "pie" && g.automargin && Qo.allowAutoMargin(e, "pie." + g.uid + ".automargin");
+            }
+            return Qo.doAutoMargin(e), Qo.previousPromises(e);
+          }
+          function p() {
+            if (Qo.didMarginChange(d, u._size)) return Sa.syncOrAsync([b, Au.layoutStyles], e);
+          }
+          function k() {
+            if (!f) {
+              E();
+              return;
+            }
+            return Sa.syncOrAsync([P0.getComponentMethod("shapes", "calcAutorange"), P0.getComponentMethod("annotations", "calcAutorange"), E], e);
+          }
+          function E() {
+            e._transitioning || (Au.doAutoRangeAndConstraints(e), l && Vv.saveRangeInitial(e), P0.getComponentMethod("rangeslider", "calcAutorange")(e));
+          }
+          function T() {
+            return Vv.draw(e, l ? "" : "redraw");
+          }
+          var L = [Qo.previousPromises, s, _, b, p];
+          c && L.push(k), L.push(Au.layoutStyles), c && L.push(T, function(M) {
+            var g = M._fullLayout._insideTickLabelsUpdaterange;
+            if (g) return M._fullLayout._insideTickLabelsUpdaterange = void 0, $M(M, g).then(function() {
+              Vv.saveRangeInitial(M, true);
+            });
+          }), L.push(Au.drawData, Au.finalDraw, Odt, Qo.addLinks, Qo.rehover, Qo.redrag, Qo.reselect, Qo.doAutoMargin, Qo.previousPromises);
+          var x = Sa.syncOrAsync(L, e);
+          return (!x || !x.then) && (x = Promise.resolve()), x.then(function() {
+            return QM(e), e;
+          });
+        }
+        function QM(e) {
+          var t = e._fullLayout;
+          t._redrawFromAutoMarginCount ? t._redrawFromAutoMarginCount-- : e.emit("plotly_afterplot");
+        }
+        function Vdt(e) {
+          return Sa.extendFlat(Whe, e);
+        }
+        function Xhe(e, t) {
+          try {
+            e._fullLayout._paper.style("background", t);
+          } catch (r) {
+            Sa.error(r);
+          }
+        }
+        function Gdt(e, t) {
+          var r = zdt.combine(t, "white");
+          Xhe(e, r);
+        }
+        function Zhe(e, t) {
+          if (!e._context) {
+            e._context = Sa.extendDeep({}, Whe);
+            var r = BP.select("base");
+            e._context._baseUrl = r.size() && r.attr("href") ? window.location.href.split("#")[0] : "";
+          }
+          var n = e._context, i, a, o;
+          if (t) {
+            for (a = Object.keys(t), i = 0; i < a.length; i++) o = a[i], !(o === "editable" || o === "edits") && o in n && (o === "setBackground" && t[o] === "opaque" ? n[o] = Gdt : n[o] = t[o]);
+            var s = t.editable;
+            if (s !== void 0) for (n.editable = s, a = Object.keys(n.edits), i = 0; i < a.length; i++) n.edits[a[i]] = s;
+            if (t.edits) for (a = Object.keys(t.edits), i = 0; i < a.length; i++) o = a[i], o in n.edits && (n.edits[o] = t.edits[o]);
+            n._exportedPlot = t._exportedPlot;
+          }
+          n.staticPlot && (n.editable = false, n.edits = {}, n.autosizable = false, n.scrollZoom = false, n.doubleClick = false, n.showTips = false, n.showLink = false, n.displayModeBar = false), n.displayModeBar === "hover" && !Rdt && (n.displayModeBar = true), (n.setBackground === "transparent" || typeof n.setBackground != "function") && (n.setBackground = Xhe), n._hasZeroHeight = n._hasZeroHeight || e.clientHeight === 0, n._hasZeroWidth = n._hasZeroWidth || e.clientWidth === 0;
+          var l = n.scrollZoom, u = n._scrollZoom = {};
+          if (l === true) u.cartesian = 1, u.gl3d = 1, u.geo = 1, u.mapbox = 1, u.map = 1;
+          else if (typeof l == "string") {
+            var c = l.split("+");
+            for (i = 0; i < c.length; i++) u[c[i]] = 1;
+          } else l !== false && (u.gl3d = 1, u.geo = 1, u.mapbox = 1, u.map = 1);
+        }
+        function Hdt(e) {
+          if (e = Sa.getGraphDiv(e), !Sa.isPlotDiv(e)) throw new Error("This element is not a Plotly plot: " + e);
+          return gh.cleanData(e.data), gh.cleanLayout(e.layout), e.calcdata = void 0, _l._doPlot(e).then(function() {
+            return e.emit("plotly_redraw"), e;
+          });
+        }
+        function jdt(e, t, r, n) {
+          return e = Sa.getGraphDiv(e), Qo.cleanPlot([], {}, e._fullData || [], e._fullLayout || {}), Qo.purge(e), _l._doPlot(e, t, r, n);
+        }
+        function NP(e, t) {
+          var r = t + 1, n = [], i, a;
+          for (i = 0; i < e.length; i++) a = e[i], a < 0 ? n.push(r + a) : n.push(a);
+          return n;
+        }
+        function UP(e, t, r) {
+          var n, i;
+          for (n = 0; n < t.length; n++) {
+            if (i = t[n], i !== parseInt(i, 10)) throw new Error("all values in " + r + " must be integers");
+            if (i >= e.data.length || i < -e.data.length) throw new Error(r + " must be valid indices for gd.data.");
+            if (t.indexOf(i, n + 1) > -1 || i >= 0 && t.indexOf(-e.data.length + i) > -1 || i < 0 && t.indexOf(e.data.length + i) > -1) throw new Error("each index in " + r + " must be unique.");
+          }
+        }
+        function Yhe(e, t, r) {
+          if (!Array.isArray(e.data)) throw new Error("gd.data must be an array.");
+          if (typeof t == "undefined") throw new Error("currentIndices is a required argument.");
+          if (Array.isArray(t) || (t = [t]), UP(e, t, "currentIndices"), typeof r != "undefined" && !Array.isArray(r) && (r = [r]), typeof r != "undefined" && UP(e, r, "newIndices"), typeof r != "undefined" && t.length !== r.length) throw new Error("current and new indices must be of equal length.");
+        }
+        function Wdt(e, t, r) {
+          var n, i;
+          if (!Array.isArray(e.data)) throw new Error("gd.data must be an array.");
+          if (typeof t == "undefined") throw new Error("traces must be defined.");
+          for (Array.isArray(t) || (t = [t]), n = 0; n < t.length; n++) if (i = t[n], typeof i != "object" || Array.isArray(i) || i === null) throw new Error("all values in traces array must be non-array objects");
+          if (typeof r != "undefined" && !Array.isArray(r) && (r = [r]), typeof r != "undefined" && r.length !== t.length) throw new Error("if indices is specified, traces.length must equal indices.length");
+        }
+        function Xdt(e, t, r, n) {
+          var i = Sa.isPlainObject(n);
+          if (!Array.isArray(e.data)) throw new Error("gd.data must be an array");
+          if (!Sa.isPlainObject(t)) throw new Error("update must be a key:value object");
+          if (typeof r == "undefined") throw new Error("indices must be an integer or array of integers");
+          UP(e, r, "indices");
+          for (var a in t) {
+            if (!Array.isArray(t[a]) || t[a].length !== r.length) throw new Error("attribute " + a + " must be an array of length equal to indices array length");
+            if (i && (!(a in n) || !Array.isArray(n[a]) || n[a].length !== t[a].length)) throw new Error("when maxPoints is set as a key:value object it must contain a 1:1 correspondence with the keys and number of traces in the update object");
+          }
+        }
+        function Zdt(e, t, r, n) {
+          var i = Sa.isPlainObject(n), a = [], o, s, l, u, c;
+          Array.isArray(r) || (r = [r]), r = NP(r, e.data.length - 1);
+          for (var f in t) for (var h = 0; h < r.length; h++) {
+            if (o = e.data[r[h]], l = Ec(o, f), s = l.get(), u = t[f][h], !Sa.isArrayOrTypedArray(u)) throw new Error("attribute: " + f + " index: " + h + " must be an array");
+            if (!Sa.isArrayOrTypedArray(s)) throw new Error("cannot extend missing or non-array attribute: " + f);
+            if (s.constructor !== u.constructor) throw new Error("cannot extend array with an array of a different type: " + f);
+            c = i ? n[f][h] : n, Idt(c) || (c = -1), a.push({ prop: l, target: s, insert: u, maxp: Math.floor(c) });
+          }
+          return a;
+        }
+        function Khe(e, t, r, n, i) {
+          Xdt(e, t, r, n);
+          for (var a = Zdt(e, t, r, n), o = {}, s = {}, l = 0; l < a.length; l++) {
+            var u = a[l].prop, c = a[l].maxp, f = i(a[l].target, a[l].insert, c);
+            u.set(f[0]), Array.isArray(o[u.astr]) || (o[u.astr] = []), o[u.astr].push(f[1]), Array.isArray(s[u.astr]) || (s[u.astr] = []), s[u.astr].push(a[l].target.length);
+          }
+          return { update: o, maxPoints: s };
+        }
+        function Jhe(e, t) {
+          var r = new e.constructor(e.length + t.length);
+          return r.set(e), r.set(t, e.length), r;
+        }
+        function $he(e, t, r, n) {
+          e = Sa.getGraphDiv(e);
+          function i(l, u, c) {
+            var f, h;
+            if (Sa.isTypedArray(l)) if (c < 0) {
+              var d = new l.constructor(0), v = Jhe(l, u);
+              c < 0 ? (f = v, h = d) : (f = d, h = v);
+            } else if (f = new l.constructor(c), h = new l.constructor(l.length + u.length - c), c === u.length) f.set(u), h.set(l);
+            else if (c < u.length) {
+              var _ = u.length - c;
+              f.set(u.subarray(_)), h.set(l), h.set(u.subarray(0, _), l.length);
+            } else {
+              var b = c - u.length, p = l.length - b;
+              f.set(l.subarray(p)), f.set(u, b), h.set(l.subarray(0, p));
+            }
+            else f = l.concat(u), h = c >= 0 && c < f.length ? f.splice(0, f.length - c) : [];
+            return [f, h];
+          }
+          var a = Khe(e, t, r, n, i), o = _l.redraw(e), s = [e, a.update, r, a.maxPoints];
+          return op.add(e, _l.prependTraces, s, $he, arguments), o;
+        }
+        function Qhe(e, t, r, n) {
+          e = Sa.getGraphDiv(e);
+          function i(l, u, c) {
+            var f, h;
+            if (Sa.isTypedArray(l)) if (c <= 0) {
+              var d = new l.constructor(0), v = Jhe(u, l);
+              c < 0 ? (f = v, h = d) : (f = d, h = v);
+            } else if (f = new l.constructor(c), h = new l.constructor(l.length + u.length - c), c === u.length) f.set(u), h.set(l);
+            else if (c < u.length) {
+              var _ = u.length - c;
+              f.set(u.subarray(0, _)), h.set(u.subarray(_)), h.set(l, _);
+            } else {
+              var b = c - u.length;
+              f.set(u), f.set(l.subarray(0, b), u.length), h.set(l.subarray(b));
+            }
+            else f = u.concat(l), h = c >= 0 && c < f.length ? f.splice(c, f.length) : [];
+            return [f, h];
+          }
+          var a = Khe(e, t, r, n, i), o = _l.redraw(e), s = [e, a.update, r, a.maxPoints];
+          return op.add(e, _l.extendTraces, s, Qhe, arguments), o;
+        }
+        function ede(e, t, r) {
+          e = Sa.getGraphDiv(e);
+          var n = [], i = _l.deleteTraces, a = ede, o = [e, n], s = [e, t], l, u;
+          for (Wdt(e, t, r), Array.isArray(t) || (t = [t]), t = t.map(function(c) {
+            return Sa.extendFlat({}, c);
+          }), gh.cleanData(t), l = 0; l < t.length; l++) e.data.push(t[l]);
+          for (l = 0; l < t.length; l++) n.push(-t.length + l);
+          if (typeof r == "undefined") return u = _l.redraw(e), op.add(e, i, o, a, s), u;
+          Array.isArray(r) || (r = [r]);
+          try {
+            Yhe(e, n, r);
+          } catch (c) {
+            throw e.data.splice(e.data.length - t.length, t.length), c;
+          }
+          return op.startSequence(e), op.add(e, i, o, a, s), u = _l.moveTraces(e, n, r), op.stopSequence(e), u;
+        }
+        function tde(e, t) {
+          e = Sa.getGraphDiv(e);
+          var r = [], n = _l.addTraces, i = tde, a = [e, r, t], o = [e, t], s, l;
+          if (typeof t == "undefined") throw new Error("indices must be an integer or array of integers.");
+          for (Array.isArray(t) || (t = [t]), UP(e, t, "indices"), t = NP(t, e.data.length - 1), t.sort(Sa.sorterDes), s = 0; s < t.length; s += 1) l = e.data.splice(t[s], 1)[0], r.push(l);
+          var u = _l.redraw(e);
+          return op.add(e, n, a, i, o), u;
+        }
+        function eU(e, t, r) {
+          e = Sa.getGraphDiv(e);
+          var n = [], i = [], a = eU, o = eU, s = [e, r, t], l = [e, t, r], u;
+          if (Yhe(e, t, r), t = Array.isArray(t) ? t : [t], typeof r == "undefined") for (r = [], u = 0; u < t.length; u++) r.push(-t.length + u);
+          for (r = Array.isArray(r) ? r : [r], t = NP(t, e.data.length - 1), r = NP(r, e.data.length - 1), u = 0; u < e.data.length; u++) t.indexOf(u) === -1 && n.push(e.data[u]);
+          for (u = 0; u < t.length; u++) i.push({ newIndex: r[u], trace: e.data[t[u]] });
+          for (i.sort(function(f, h) {
+            return f.newIndex - h.newIndex;
+          }), u = 0; u < i.length; u += 1) n.splice(i[u].newIndex, 0, i[u].trace);
+          e.data = n;
+          var c = _l.redraw(e);
+          return op.add(e, a, s, o, l), c;
+        }
+        function VP(e, t, r, n) {
+          e = Sa.getGraphDiv(e), gh.clearPromiseQueue(e);
+          var i = {};
+          if (typeof t == "string") i[t] = r;
+          else if (Sa.isPlainObject(t)) i = Sa.extendFlat({}, t), n === void 0 && (n = r);
+          else return Sa.warn("Restyle fail.", t, r, n), Promise.reject();
+          Object.keys(i).length && (e.changed = true);
+          var a = gh.coerceTraceIndices(e, n), o = rde(e, i, a), s = o.flags;
+          s.calc && (e.calcdata = void 0), s.clearAxisTypes && gh.clearAxisTypes(e, a, {});
+          var l = [];
+          s.fullReplot ? l.push(_l._doPlot) : (l.push(Qo.previousPromises), Qo.supplyDefaults(e), s.markerSize && (Qo.doCalcdata(e), XP(l)), s.style && l.push(Au.doTraceStyle), s.colorbars && l.push(Au.doColorBars), l.push(QM)), l.push(Qo.rehover, Qo.redrag, Qo.reselect), op.add(e, VP, [e, o.undoit, o.traces], VP, [e, o.redoit, o.traces]);
+          var u = Sa.syncOrAsync(l, e);
+          return (!u || !u.then) && (u = Promise.resolve()), u.then(function() {
+            return e.emit("plotly_restyle", o.eventData), e;
+          });
+        }
+        function zy(e) {
+          return e === void 0 ? null : e;
+        }
+        function qP(e, t) {
+          return t ? function(r, n, i) {
+            var a = Ec(r, n), o = a.set;
+            return a.set = function(s) {
+              var l = (i || "") + n;
+              GP(l, a.get(), s, e), o(s);
+            }, a;
+          } : Ec;
+        }
+        function GP(e, t, r, n) {
+          if (Array.isArray(t) || Array.isArray(r)) for (var i = Array.isArray(t) ? t : [], a = Array.isArray(r) ? r : [], o = Math.max(i.length, a.length), s = 0; s < o; s++) GP(e + "[" + s + "]", i[s], a[s], n);
+          else if (Sa.isPlainObject(t) || Sa.isPlainObject(r)) {
+            var l = Sa.isPlainObject(t) ? t : {}, u = Sa.isPlainObject(r) ? r : {}, c = Sa.extendFlat({}, l, u);
+            for (var f in c) GP(e + "." + f, l[f], u[f], n);
+          } else n[e] === void 0 && (n[e] = zy(t));
+        }
+        function Ydt(e, t, r) {
+          for (var n in r) {
+            var i = Ec(e, n);
+            GP(n, i.get(), r[n], t);
+          }
+        }
+        function rde(e, t, r) {
+          var n = e._fullLayout, i = e._fullData, a = e.data, o = n._guiEditing, s = qP(n._preGUI, o), l = Sa.extendDeepAll({}, t), u, c = T_.traceFlags(), f = {}, h = {}, d;
+          function v() {
+            return r.map(function() {
+            });
+          }
+          function _(me) {
+            var De = Vv.id2name(me);
+            d.indexOf(De) === -1 && d.push(De);
+          }
+          function b(me) {
+            return "LAYOUT" + me + ".autorange";
+          }
+          function p(me) {
+            return "LAYOUT" + me + ".range";
+          }
+          function k(me) {
+            for (var De = me; De < i.length; De++) if (i[De]._input === a[me]) return i[De];
+          }
+          function E(me, De, ce) {
+            if (Array.isArray(me)) {
+              me.forEach(function(Vt) {
+                E(Vt, De, ce);
+              });
+              return;
+            }
+            if (!(me in t || gh.hasParent(t, me))) {
+              var je;
+              if (me.slice(0, 6) === "LAYOUT") je = s(e.layout, me.replace("LAYOUT", ""));
+              else {
+                var lt = r[ce], pt = n._tracePreGUI[k(lt)._fullInput.uid];
+                je = qP(pt, o)(a[lt], me);
+              }
+              me in h || (h[me] = v()), h[me][ce] === void 0 && (h[me][ce] = zy(je.get())), De !== void 0 && je.set(De);
+            }
+          }
+          function T(me) {
+            return function(De) {
+              return i[De][me];
+            };
+          }
+          function L(me) {
+            return function(De, ce) {
+              return De === false ? i[r[ce]][me] : null;
+            };
+          }
+          for (var x in t) {
+            if (gh.hasParent(t, x)) throw new Error("cannot set " + x + " and a parent attribute simultaneously");
+            var C = t[x], M, g, P, A, z, O;
+            if ((x === "autobinx" || x === "autobiny") && (x = x.charAt(x.length - 1) + "bins", Array.isArray(C) ? C = C.map(L(x)) : C === false ? C = r.map(T(x)) : C = null), f[x] = C, x.slice(0, 6) === "LAYOUT") {
+              P = s(e.layout, x.replace("LAYOUT", "")), h[x] = [zy(P.get())], P.set(Array.isArray(C) ? C[0] : C), c.calc = true;
+              continue;
+            }
+            for (h[x] = v(), u = 0; u < r.length; u++) {
+              M = a[r[u]], g = k(r[u]);
+              var U = n._tracePreGUI[g._fullInput.uid];
+              if (P = qP(U, o)(M, x), A = P.get(), z = Array.isArray(C) ? C[u % C.length] : C, z !== void 0) {
+                var G = P.parts[P.parts.length - 1], Z = x.slice(0, x.length - G.length - 1), j = Z ? Z + "." : "", N = Z ? Ec(g, Z).get() : g;
+                if (O = WP.getTraceValObject(g, P.parts), O && O.impliedEdits && z !== null) for (var H in O.impliedEdits) E(Sa.relativeAttr(x, H), O.impliedEdits[H], u);
+                else if ((G === "thicknessmode" || G === "lenmode") && A !== z && (z === "fraction" || z === "pixels") && N) {
+                  var re = n._size, oe = N.orient, _e = oe === "top" || oe === "bottom";
+                  if (G === "thicknessmode") {
+                    var Ce = _e ? re.h : re.w;
+                    E(j + "thickness", N.thickness * (z === "fraction" ? 1 / Ce : Ce), u);
+                  } else {
+                    var Le = _e ? re.w : re.h;
+                    E(j + "len", N.len * (z === "fraction" ? 1 / Le : Le), u);
+                  }
+                } else if (x === "type" && (z === "pie" != (A === "pie") || z === "funnelarea" != (A === "funnelarea"))) {
+                  var ge = "x", ie = "y";
+                  (z === "bar" || A === "bar") && M.orientation === "h" && (ge = "y", ie = "x"), Sa.swapAttrs(M, ["?", "?src"], "labels", ge), Sa.swapAttrs(M, ["d?", "?0"], "label", ge), Sa.swapAttrs(M, ["?", "?src"], "values", ie), A === "pie" || A === "funnelarea" ? (Ec(M, "marker.color").set(Ec(M, "marker.colors").get()), n._pielayer.selectAll("g.trace").remove()) : P0.traceIs(M, "cartesian") && Ec(M, "marker.colors").set(Ec(M, "marker.color").get());
+                }
+                h[x][u] = zy(A);
+                var Se = ["swapxy", "swapxyaxes", "orientation", "orientationaxes"];
+                if (Se.indexOf(x) !== -1) {
+                  if (x === "orientation") {
+                    P.set(z);
+                    var Ee = M.x && !M.y ? "h" : "v";
+                    if ((P.get() || Ee) === g.orientation) continue;
+                  } else x === "orientationaxes" && (M.orientation = { v: "h", h: "v" }[g.orientation]);
+                  gh.swapXYData(M), c.calc = c.clearAxisTypes = true;
+                } else Qo.dataArrayContainers.indexOf(P.parts[0]) !== -1 ? (gh.manageArrayContainers(P, z, h), c.calc = true) : (O ? O.arrayOk && !P0.traceIs(g, "regl") && (Sa.isArrayOrTypedArray(z) || Sa.isArrayOrTypedArray(A)) ? c.calc = true : T_.update(c, O) : c.calc = true, P.set(z));
+              }
+            }
+            if (["swapxyaxes", "orientationaxes"].indexOf(x) !== -1 && Vv.swap(e, r), x === "orientationaxes") {
+              var Ae = Ec(e.layout, "hovermode"), Be = Ae.get();
+              Be === "x" ? Ae.set("y") : Be === "y" ? Ae.set("x") : Be === "x unified" ? Ae.set("y unified") : Be === "y unified" && Ae.set("x unified");
+            }
+            if (["orientation", "type"].indexOf(x) !== -1) {
+              for (d = [], u = 0; u < r.length; u++) {
+                var Pe = a[r[u]];
+                P0.traceIs(Pe, "cartesian") && (_(Pe.xaxis || "x"), _(Pe.yaxis || "y"));
+              }
+              E(d.map(b), true, 0), E(d.map(p), [0, 1], 0);
+            }
+          }
+          return (c.calc || c.plot) && (c.fullReplot = true), { flags: c, undoit: h, redoit: f, traces: r, eventData: Sa.extendDeepNoArrays([], [l, r]) };
+        }
+        function $M(e, t, r) {
+          e = Sa.getGraphDiv(e), gh.clearPromiseQueue(e);
+          var n = {};
+          if (typeof t == "string") n[t] = r;
+          else if (Sa.isPlainObject(t)) n = Sa.extendFlat({}, t);
+          else return Sa.warn("Relayout fail.", t, r), Promise.reject();
+          Object.keys(n).length && (e.changed = true);
+          var i = ode(e, n), a = i.flags;
+          a.calc && (e.calcdata = void 0);
+          var o = [Qo.previousPromises];
+          a.layoutReplot ? o.push(Au.layoutReplot) : Object.keys(n).length && (ide(e, a, i) || Qo.supplyDefaults(e), a.legend && o.push(Au.doLegend), a.layoutstyle && o.push(Au.layoutStyles), a.axrange && XP(o, i.rangesAltered), a.ticks && o.push(Au.doTicksRelayout), a.modebar && o.push(Au.doModeBar), a.camera && o.push(Au.doCamera), a.colorbars && o.push(Au.doColorBars), o.push(QM)), o.push(Qo.rehover, Qo.redrag, Qo.reselect), op.add(e, $M, [e, i.undoit], $M, [e, i.redoit]);
+          var s = Sa.syncOrAsync(o, e);
+          return (!s || !s.then) && (s = Promise.resolve(e)), s.then(function() {
+            return e.emit("plotly_relayout", i.eventData), e;
+          });
+        }
+        function ide(e, t, r) {
+          var n = e._fullLayout;
+          if (!t.axrange) return false;
+          for (var i in t) if (i !== "axrange" && t[i]) return false;
+          var a, o, s = function(d, v) {
+            return Sa.coerce(a, o, Fdt, d, v);
+          }, l = {};
+          for (var u in r.rangesAltered) {
+            var c = Vv.id2name(u);
+            if (a = e.layout[c], o = n[c], Ddt(a, o, s, l), o._matchGroup) {
+              for (var f in o._matchGroup) if (f !== u) {
+                var h = n[Vv.id2name(f)];
+                h.autorange = o.autorange, h.range = o.range.slice(), h._input.range = o.range.slice();
+              }
+            }
+          }
+          return true;
+        }
+        function XP(e, t) {
+          var r = t ? function(n) {
+            var i = [], a = true;
+            for (var o in t) {
+              var s = Vv.getFromId(n, o);
+              if (i.push(o), (s.ticklabelposition || "").indexOf("inside") !== -1 && s._anchorAxis && i.push(s._anchorAxis._id), s._matchGroup) for (var l in s._matchGroup) t[l] || i.push(l);
+            }
+            return Vv.draw(n, i, { skipTitle: a });
+          } : function(n) {
+            return Vv.draw(n, "redraw");
+          };
+          e.push(Bdt, Au.doAutoRangeAndConstraints, r, Au.drawData, Au.finalDraw);
+        }
+        var nde = /^[xyz]axis[0-9]*\.range(\[[0|1]\])?$/, ade = /^[xyz]axis[0-9]*\.autorange$/, Kdt = /^[xyz]axis[0-9]*\.domain(\[[0|1]\])?$/;
+        function ode(e, t) {
+          var r = e.layout, n = e._fullLayout, i = n._guiEditing, a = qP(n._preGUI, i), o = Object.keys(t), s = Vv.list(e), l = Sa.extendDeepAll({}, t), u = {}, c, f, h;
+          for (o = Object.keys(t), f = 0; f < o.length; f++) if (o[f].indexOf("allaxes") === 0) {
+            for (h = 0; h < s.length; h++) {
+              var d = s[h]._id.slice(1), v = d.indexOf("scene") !== -1 ? d + "." : "", _ = o[f].replace("allaxes", v + s[h]._name);
+              t[_] || (t[_] = t[o[f]]);
+            }
+            delete t[o[f]];
+          }
+          var b = T_.layoutFlags(), p = {}, k = {};
+          function E(pt, Vt) {
+            if (Array.isArray(pt)) {
+              pt.forEach(function(ut) {
+                E(ut, Vt);
+              });
+              return;
+            }
+            if (!(pt in t || gh.hasParent(t, pt))) {
+              var ot = a(r, pt);
+              pt in k || (k[pt] = zy(ot.get())), Vt !== void 0 && ot.set(Vt);
+            }
+          }
+          var T = {}, L;
+          function x(pt) {
+            var Vt = Vv.name2id(pt.split(".")[0]);
+            return T[Vt] = 1, Vt;
+          }
+          for (var C in t) {
+            if (gh.hasParent(t, C)) throw new Error("cannot set " + C + " and a parent attribute simultaneously");
+            for (var M = a(r, C), g = t[C], P = M.parts.length, A = P - 1; A > 0 && typeof M.parts[A] != "string"; ) A--;
+            var z = M.parts[A], O = M.parts[A - 1] + "." + z, U = M.parts.slice(0, A).join("."), G = Ec(e.layout, U).get(), Z = Ec(n, U).get(), j = M.get();
+            if (g !== void 0) {
+              p[C] = g, k[C] = z === "reverse" ? g : zy(j);
+              var N = WP.getLayoutValObject(n, M.parts);
+              if (N && N.impliedEdits && g !== null) for (var H in N.impliedEdits) E(Sa.relativeAttr(C, H), N.impliedEdits[H]);
+              if (["width", "height"].indexOf(C) !== -1) if (g) {
+                E("autosize", null);
+                var re = C === "height" ? "width" : "height";
+                E(re, n[re]);
+              } else n[C] = e._initialAutoSize[C];
+              else if (C === "autosize") E("width", g ? null : n.width), E("height", g ? null : n.height);
+              else if (O.match(nde)) x(O), Ec(n, U + "._inputRange").set(null);
+              else if (O.match(ade)) {
+                x(O), Ec(n, U + "._inputRange").set(null);
+                var oe = Ec(n, U).get();
+                oe._inputDomain && (oe._input.domain = oe._inputDomain.slice());
+              } else O.match(Kdt) && Ec(n, U + "._inputDomain").set(null);
+              if (z === "type") {
+                L = G;
+                var _e = Z.type === "linear" && g === "log", Ce = Z.type === "log" && g === "linear";
+                if (_e || Ce) {
+                  if (!L || !L.range) E(U + ".autorange", true);
+                  else if (Z.autorange) _e && (L.range = L.range[1] > L.range[0] ? [1, 2] : [2, 1]);
+                  else {
+                    var Le = L.range[0], ge = L.range[1];
+                    _e ? (Le <= 0 && ge <= 0 && E(U + ".autorange", true), Le <= 0 ? Le = ge / 1e6 : ge <= 0 && (ge = Le / 1e6), E(U + ".range[0]", Math.log(Le) / Math.LN10), E(U + ".range[1]", Math.log(ge) / Math.LN10)) : (E(U + ".range[0]", Math.pow(10, Le)), E(U + ".range[1]", Math.pow(10, ge)));
+                  }
+                  Array.isArray(n._subplots.polar) && n._subplots.polar.length && n[M.parts[0]] && M.parts[1] === "radialaxis" && delete n[M.parts[0]]._subplot.viewInitial["radialaxis.range"], P0.getComponentMethod("annotations", "convertCoords")(e, Z, g, E), P0.getComponentMethod("images", "convertCoords")(e, Z, g, E);
+                } else E(U + ".autorange", true), E(U + ".range", null);
+                Ec(n, U + "._inputRange").set(null);
+              } else if (z.match(Ndt)) {
+                var ie = Ec(n, C).get(), Se = (g || {}).type;
+                (!Se || Se === "-") && (Se = "linear"), P0.getComponentMethod("annotations", "convertCoords")(e, ie, Se, E), P0.getComponentMethod("images", "convertCoords")(e, ie, Se, E);
+              }
+              var Ee = OP.containerArrayMatch(C);
+              if (Ee) {
+                c = Ee.array, f = Ee.index;
+                var Ae = Ee.property, Be = N || { editType: "calc" };
+                f !== "" && Ae === "" && (OP.isAddVal(g) ? k[C] = null : OP.isRemoveVal(g) ? k[C] = (Ec(r, c).get() || [])[f] : Sa.warn("unrecognized full object value", t)), T_.update(b, Be), u[c] || (u[c] = {});
+                var Pe = u[c][f];
+                Pe || (Pe = u[c][f] = {}), Pe[Ae] = g, delete t[C];
+              } else z === "reverse" ? (G.range ? G.range.reverse() : (E(U + ".autorange", true), G.range = [1, 0]), Z.autorange ? b.calc = true : b.plot = true) : (C === "dragmode" && (g === false && j !== false || g !== false && j === false) || n._has("scatter-like") && n._has("regl") && C === "dragmode" && (g === "lasso" || g === "select") && !(j === "lasso" || j === "select") ? b.plot = true : N ? T_.update(b, N) : b.calc = true, M.set(g));
+            }
+          }
+          for (c in u) {
+            var me = OP.applyContainerArrayChanges(e, a(r, c), u[c], b, a);
+            me || (b.plot = true);
+          }
+          for (var De in T) {
+            L = Vv.getFromId(e, De);
+            var ce = L && L._constraintGroup;
+            if (ce) {
+              b.calc = true;
+              for (var je in ce) T[je] || (Vv.getFromId(e, je)._constraintShrinkable = true);
+            }
+          }
+          (sde(e) || t.height || t.width) && (b.plot = true);
+          var lt = n.shapes;
+          for (f = 0; f < lt.length; f++) if (lt[f].showlegend) {
+            b.calc = true;
+            break;
+          }
+          return (b.plot || b.calc) && (b.layoutReplot = true), { flags: b, rangesAltered: T, undoit: k, redoit: p, eventData: l };
+        }
+        function sde(e) {
+          var t = e._fullLayout, r = t.width, n = t.height;
+          return e.layout.autosize && Qo.plotAutoSize(e, e.layout, t), t.width !== r || t.height !== n;
+        }
+        function HP(e, t, r, n) {
+          e = Sa.getGraphDiv(e), gh.clearPromiseQueue(e), Sa.isPlainObject(t) || (t = {}), Sa.isPlainObject(r) || (r = {}), Object.keys(t).length && (e.changed = true), Object.keys(r).length && (e.changed = true);
+          var i = gh.coerceTraceIndices(e, n), a = rde(e, Sa.extendFlat({}, t), i), o = a.flags, s = ode(e, Sa.extendFlat({}, r)), l = s.flags;
+          (o.calc || l.calc) && (e.calcdata = void 0), o.clearAxisTypes && gh.clearAxisTypes(e, i, r);
+          var u = [];
+          l.layoutReplot ? u.push(Au.layoutReplot) : o.fullReplot ? u.push(_l._doPlot) : (u.push(Qo.previousPromises), ide(e, l, s) || Qo.supplyDefaults(e), o.style && u.push(Au.doTraceStyle), (o.colorbars || l.colorbars) && u.push(Au.doColorBars), l.legend && u.push(Au.doLegend), l.layoutstyle && u.push(Au.layoutStyles), l.axrange && XP(u, s.rangesAltered), l.ticks && u.push(Au.doTicksRelayout), l.modebar && u.push(Au.doModeBar), l.camera && u.push(Au.doCamera), u.push(QM)), u.push(Qo.rehover, Qo.redrag, Qo.reselect), op.add(e, HP, [e, a.undoit, s.undoit, a.traces], HP, [e, a.redoit, s.redoit, a.traces]);
+          var c = Sa.syncOrAsync(u, e);
+          return (!c || !c.then) && (c = Promise.resolve(e)), c.then(function() {
+            return e.emit("plotly_update", { data: a.eventData, layout: s.eventData }), e;
+          });
+        }
+        function tU(e) {
+          return function(r) {
+            r._fullLayout._guiEditing = true;
+            var n = e.apply(null, arguments);
+            return r._fullLayout._guiEditing = false, n;
+          };
+        }
+        var Jdt = [{ pattern: /^hiddenlabels/, attr: "legend.uirevision" }, { pattern: /^((x|y)axis\d*)\.((auto)?range|title\.text)/ }, { pattern: /axis\d*\.showspikes$/, attr: "modebar.uirevision" }, { pattern: /(hover|drag)mode$/, attr: "modebar.uirevision" }, { pattern: /^(scene\d*)\.camera/ }, { pattern: /^(geo\d*)\.(projection|center|fitbounds)/ }, { pattern: /^(ternary\d*\.[abc]axis)\.(min|title\.text)$/ }, { pattern: /^(polar\d*\.radialaxis)\.((auto)?range|angle|title\.text)/ }, { pattern: /^(polar\d*\.angularaxis)\.rotation/ }, { pattern: /^(mapbox\d*)\.(center|zoom|bearing|pitch)/ }, { pattern: /^(map\d*)\.(center|zoom|bearing|pitch)/ }, { pattern: /^legend\.(x|y)$/, attr: "editrevision" }, { pattern: /^(shapes|annotations)/, attr: "editrevision" }, { pattern: /^title\.text$/, attr: "editrevision" }], $dt = [{ pattern: /^selectedpoints$/, attr: "selectionrevision" }, { pattern: /(^|value\.)visible$/, attr: "legend.uirevision" }, { pattern: /^dimensions\[\d+\]\.constraintrange/ }, { pattern: /^node\.(x|y|groups)/ }, { pattern: /^level$/ }, { pattern: /(^|value\.)name$/ }, { pattern: /colorbar\.title\.text$/ }, { pattern: /colorbar\.(x|y)$/, attr: "editrevision" }];
+        function Ghe(e, t) {
+          for (var r = 0; r < t.length; r++) {
+            var n = t[r], i = e.match(n.pattern);
+            if (i) {
+              var a = i[1] || "";
+              return { head: a, tail: e.slice(a.length + 1), attr: n.attr };
+            }
+          }
+        }
+        function Hhe(e, t) {
+          var r = Ec(t, e).get();
+          if (r !== void 0) return r;
+          var n = e.split(".");
+          for (n.pop(); n.length > 1; ) if (n.pop(), r = Ec(t, n.join(".") + ".uirevision").get(), r !== void 0) return r;
+          return t.uirevision;
+        }
+        function Qdt(e, t) {
+          for (var r = 0; r < t.length; r++) if (t[r]._fullInput.uid === e) return r;
+          return -1;
+        }
+        function evt(e, t, r) {
+          for (var n = 0; n < t.length; n++) if (t[n].uid === e) return n;
+          return !t[r] || t[r].uid ? -1 : r;
+        }
+        function jhe(e, t) {
+          var r = Sa.isPlainObject(e), n = Array.isArray(e);
+          return r || n ? (r && Sa.isPlainObject(t) || n && Array.isArray(t)) && JSON.stringify(e) === JSON.stringify(t) : e === t;
+        }
+        function tvt(e, t, r, n) {
+          var i = n._preGUI, a, o, s, l, u, c, f, h, d, v, _ = [], b = {}, p = {};
+          for (a in i) {
+            if (u = Ghe(a, Jdt), u) {
+              if (d = u.head, v = u.tail, o = u.attr || d + ".uirevision", s = Ec(n, o).get(), l = s && Hhe(o, t), l && l === s) {
+                if (c = i[a], c === null && (c = void 0), f = Ec(t, a), h = f.get(), jhe(h, c)) {
+                  h === void 0 && v === "autorange" && _.push(d), f.set(zy(Ec(n, a).get()));
+                  continue;
+                } else if (v === "autorange" || v.slice(0, 6) === "range[") {
+                  var k = i[d + ".range[0]"], E = i[d + ".range[1]"], T = i[d + ".autorange"];
+                  if (T || T === null && k === null && E === null) {
+                    if (!(d in b)) {
+                      var L = Ec(t, d).get();
+                      b[d] = L && (L.autorange || L.autorange !== false && (!L.range || L.range.length !== 2));
+                    }
+                    if (b[d]) {
+                      f.set(zy(Ec(n, a).get()));
+                      continue;
+                    }
+                  }
+                }
+              }
+            } else Sa.warn("unrecognized GUI edit: " + a);
+            delete i[a], u && u.tail.slice(0, 6) === "range[" && (p[u.head] = 1);
+          }
+          for (var x = 0; x < _.length; x++) {
+            var C = _[x];
+            if (p[C]) {
+              var M = Ec(t, C).get();
+              M && delete M.autorange;
+            }
+          }
+          var g = n._tracePreGUI;
+          for (var P in g) {
+            var A = g[P], z = null, O;
+            for (a in A) {
+              if (!z) {
+                var U = Qdt(P, r);
+                if (U < 0) {
+                  delete g[P];
+                  break;
+                }
+                var G = r[U];
+                O = G._fullInput;
+                var Z = evt(P, e, O.index);
+                if (Z < 0) {
+                  delete g[P];
+                  break;
+                }
+                z = e[Z];
+              }
+              if (u = Ghe(a, $dt), u) {
+                if (u.attr ? (s = Ec(n, u.attr).get(), l = s && Hhe(u.attr, t)) : (s = O.uirevision, l = z.uirevision, l === void 0 && (l = t.uirevision)), l && l === s && (c = A[a], c === null && (c = void 0), f = Ec(z, a), h = f.get(), jhe(h, c))) {
+                  f.set(zy(Ec(O, a).get()));
+                  continue;
+                }
+              } else Sa.warn("unrecognized GUI edit: " + a + " in trace uid " + P);
+              delete A[a];
+            }
+          }
+        }
+        function rvt(e, t, r, n) {
+          var i, a;
+          function o() {
+            return _l.addFrames(e, i);
+          }
+          e = Sa.getGraphDiv(e), gh.clearPromiseQueue(e);
+          var s = e._fullData, l = e._fullLayout;
+          if (!Sa.isPlotDiv(e) || !s || !l) a = _l.newPlot(e, t, r, n);
+          else {
+            if (Sa.isPlainObject(t)) {
+              var u = t;
+              t = u.data, r = u.layout, n = u.config, i = u.frames;
+            }
+            var c = false;
+            if (n) {
+              let O = Sa.extendDeepAll({}, e._context);
+              e._context = void 0, Zhe(e, n), c = !gh.collectionsAreEqual(O, e._context);
+            }
+            if (c) {
+              let O = e._ev.eventNames().map((U) => [U, e._ev.listeners(U)]);
+              a = _l.newPlot(e, t, r, n).then(() => {
+                for (let [U, G] of O) G.forEach((Z) => e.on(U, Z));
+                return _l.react(e, t, r, n);
+              });
+            } else {
+              e.data = t || [], gh.cleanData(e.data), e.layout = r || {}, gh.cleanLayout(e.layout), tvt(e.data, e.layout, s, l), Qo.supplyDefaults(e, { skipUpdateCalc: true });
+              var f = e._fullData, h = e._fullLayout, d = h.datarevision === void 0, v = h.transition, _ = nvt(e, l, h, d, v), b = _.newDataRevision, p = ivt(e, s, f, d, v, b);
+              if (sde(e) && (_.layoutReplot = true), p.calc || _.calc) {
+                e.calcdata = void 0;
+                for (var k = Object.getOwnPropertyNames(h), E = 0; E < k.length; E++) {
+                  var T = k[E], L = T.substring(0, 5);
+                  if (L === "xaxis" || L === "yaxis") {
+                    var x = h[T]._emptyCategories;
+                    x && x();
+                  }
+                }
+              } else Qo.supplyDefaultsUpdateCalc(e.calcdata, f);
+              var C = [];
+              if (i && (e._transitionData = {}, Qo.createTransitionData(e), C.push(o)), h.transition && (p.anim || _.anim)) _.ticks && C.push(Au.doTicksRelayout), Qo.doCalcdata(e), Au.doAutoRangeAndConstraints(e), C.push(function() {
+                return Qo.transitionFromReact(e, p, _, l);
+              });
+              else if (p.fullReplot || _.layoutReplot) e._fullLayout._skipDefaults = true, C.push(_l._doPlot);
+              else {
+                for (var M in _.arrays) {
+                  var g = _.arrays[M];
+                  if (g.length) {
+                    var P = P0.getComponentMethod(M, "drawOne");
+                    if (P !== Sa.noop) for (var A = 0; A < g.length; A++) P(e, g[A]);
+                    else {
+                      var z = P0.getComponentMethod(M, "draw");
+                      if (z === Sa.noop) throw new Error("cannot draw components: " + M);
+                      z(e);
+                    }
+                  }
+                }
+                C.push(Qo.previousPromises), p.style && C.push(Au.doTraceStyle), (p.colorbars || _.colorbars) && C.push(Au.doColorBars), _.legend && C.push(Au.doLegend), _.layoutstyle && C.push(Au.layoutStyles), _.axrange && XP(C), _.ticks && C.push(Au.doTicksRelayout), _.modebar && C.push(Au.doModeBar), _.camera && C.push(Au.doCamera), C.push(QM);
+              }
+              C.push(Qo.rehover, Qo.redrag, Qo.reselect), a = Sa.syncOrAsync(C, e), (!a || !a.then) && (a = Promise.resolve(e));
+            }
+          }
+          return a.then(() => (c || e.emit("plotly_react", { config: n, data: t, layout: r }), e));
+        }
+        function ivt(e, t, r, n, i, a) {
+          var o = t.length === r.length;
+          if (!i && !o) return { fullReplot: true, calc: true };
+          var s = T_.traceFlags();
+          s.arrays = {}, s.nChanges = 0, s.nChangesAnim = 0;
+          var l, u;
+          function c(d) {
+            var v = WP.getTraceValObject(u, d);
+            return !u._module.animatable && v.anim && (v.anim = false), v;
+          }
+          var f = { getValObject: c, flags: s, immutable: n, transition: i, newDataRevision: a, gd: e }, h = {};
+          for (l = 0; l < t.length; l++) if (r[l]) {
+            if (u = r[l]._fullInput, h[u.uid]) continue;
+            h[u.uid] = 1, jP(t[l]._fullInput, u, [], f);
+          }
+          return (s.calc || s.plot) && (s.fullReplot = true), i && s.nChanges && s.nChangesAnim && (s.anim = s.nChanges === s.nChangesAnim && o ? "all" : "some"), s;
+        }
+        function nvt(e, t, r, n, i) {
+          var a = T_.layoutFlags();
+          a.arrays = {}, a.rangesAltered = {}, a.nChanges = 0, a.nChangesAnim = 0;
+          function o(h) {
+            return WP.getLayoutValObject(r, h);
+          }
+          for (var s in r) if (!(!s.startsWith("xaxis") && !s.startsWith("yaxis")) && t[s]) {
+            var l = r[s].domain, u = t[s].domain, c = t[s]._inputDomain;
+            t[s]._inputDomain && (l[0] === c[0] && l[1] === c[1] ? r[s].domain = t[s].domain : (l[0] !== u[0] || l[1] !== u[1]) && (r[s]._inputDomain = null));
+          }
+          var f = { getValObject: o, flags: a, immutable: n, transition: i, gd: e };
+          return jP(t, r, [], f), (a.plot || a.calc) && (a.layoutReplot = true), i && a.nChanges && a.nChangesAnim && (a.anim = a.nChanges === a.nChangesAnim ? "all" : "some"), a;
+        }
+        function jP(e, t, r, n) {
+          var i, a, o, s = n.getValObject, l = n.flags, u = n.immutable, c = n.inArray, f = n.arrayIndex;
+          function h() {
+            var U = i.editType;
+            if (c && U.indexOf("arraydraw") !== -1) {
+              Sa.pushUnique(l.arrays[c], f);
+              return;
+            }
+            T_.update(l, i), U !== "none" && l.nChanges++, n.transition && i.anim && l.nChangesAnim++, (nde.test(o) || ade.test(o)) && (l.rangesAltered[r[0]] = 1), a === "datarevision" && (l.newDataRevision = 1);
+          }
+          function d(U) {
+            return U.valType === "data_array" || U.arrayOk;
+          }
+          for (a in e) {
+            if (l.calc && !n.transition) return;
+            var v = e[a], _ = t[a], b = r.concat(a);
+            if (o = b.join("."), !(a.charAt(0) === "_" || typeof v == "function" || v === _)) {
+              if ((a === "tick0" || a === "dtick") && r[0] !== "geo") {
+                var p = t.tickmode;
+                if (p === "auto" || p === "array" || !p) continue;
+              }
+              if (!(a === "range" && t.autorange) && !((a === "zmin" || a === "zmax") && t.type === "contourcarpet") && (i = s(b), !!i && !(i._compareAsJSON && JSON.stringify(v) === JSON.stringify(_)))) {
+                var k = i.valType, E, T = d(i), L = Array.isArray(v), x = Array.isArray(_);
+                if (L && x) {
+                  var C = "_input_" + a, M = e[C], g = t[C];
+                  if (Array.isArray(M) && M === g) continue;
+                }
+                if (_ === void 0) T && L ? l.calc = true : h();
+                else if (i._isLinkedToArray) {
+                  var P = [], A = false;
+                  c || (l.arrays[a] = P);
+                  var z = Math.min(v.length, _.length), O = Math.max(v.length, _.length);
+                  if (z !== O) if (i.editType === "arraydraw") A = true;
+                  else {
+                    h();
+                    continue;
+                  }
+                  for (E = 0; E < z; E++) jP(v[E], _[E], b.concat(E), Sa.extendFlat({ inArray: a, arrayIndex: E }, n));
+                  if (A) for (E = z; E < O; E++) P.push(E);
+                } else !k && Sa.isPlainObject(v) ? jP(v, _, b, n) : T ? L && x ? (u && (l.calc = true), (u || n.newDataRevision) && h()) : L !== x ? l.calc = true : h() : L && x ? (v.length !== _.length || String(v) !== String(_)) && h() : h();
+              }
+            }
+          }
+          for (a in t) if (!(a in e || a.charAt(0) === "_" || typeof t[a] == "function")) if (i = s(r.concat(a)), d(i) && Array.isArray(t[a])) {
+            l.calc = true;
+            return;
+          } else h();
+        }
+        function avt(e, t, r) {
+          if (e = Sa.getGraphDiv(e), !Sa.isPlotDiv(e)) throw new Error("This element is not a Plotly plot: " + e + ". It's likely that you've failed to create a plot before animating it. For more details, see https://plotly.com/javascript/animations/");
+          var n = e._transitionData;
+          n._frameQueue || (n._frameQueue = []), r = Qo.supplyAnimationDefaults(r);
+          var i = r.transition, a = r.frame;
+          n._frameWaitingCnt === void 0 && (n._frameWaitingCnt = 0);
+          function o(u) {
+            return Array.isArray(i) ? u >= i.length ? i[0] : i[u] : i;
+          }
+          function s(u) {
+            return Array.isArray(a) ? u >= a.length ? a[0] : a[u] : a;
+          }
+          function l(u, c) {
+            var f = 0;
+            return function() {
+              if (u && ++f === c) return u();
+            };
+          }
+          return new Promise(function(u, c) {
+            function f() {
+              if (n._frameQueue.length !== 0) {
+                for (; n._frameQueue.length; ) {
+                  var z = n._frameQueue.pop();
+                  z.onInterrupt && z.onInterrupt();
+                }
+                e.emit("plotly_animationinterrupted", []);
+              }
+            }
+            function h(z) {
+              if (z.length !== 0) {
+                for (var O = 0; O < z.length; O++) {
+                  var U;
+                  z[O].type === "byname" ? U = Qo.computeFrame(e, z[O].name) : U = z[O].data;
+                  var G = s(O), Z = o(O);
+                  Z.duration = Math.min(Z.duration, G.duration);
+                  var j = { frame: U, name: z[O].name, frameOpts: G, transitionOpts: Z };
+                  O === z.length - 1 && (j.onComplete = l(u, 2), j.onInterrupt = c), n._frameQueue.push(j);
+                }
+                r.mode === "immediate" && (n._lastFrameAt = -1 / 0), n._animationRaf || _();
+              }
+            }
+            function d() {
+              e.emit("plotly_animated"), window.cancelAnimationFrame(n._animationRaf), n._animationRaf = null;
+            }
+            function v() {
+              n._currentFrame && n._currentFrame.onComplete && n._currentFrame.onComplete();
+              var z = n._currentFrame = n._frameQueue.shift();
+              if (z) {
+                var O = z.name ? z.name.toString() : null;
+                e._fullLayout._currentFrame = O, n._lastFrameAt = Date.now(), n._timeToNext = z.frameOpts.duration, Qo.transition(e, z.frame.data, z.frame.layout, gh.coerceTraceIndices(e, z.frame.traces), z.frameOpts, z.transitionOpts).then(function() {
+                  z.onComplete && z.onComplete();
+                }), e.emit("plotly_animatingframe", { name: O, frame: z.frame, animation: { frame: z.frameOpts, transition: z.transitionOpts } });
+              } else d();
+            }
+            function _() {
+              e.emit("plotly_animating"), n._lastFrameAt = -1 / 0, n._timeToNext = 0, n._runningTransitions = 0, n._currentFrame = null;
+              var z = function() {
+                n._animationRaf = window.requestAnimationFrame(z), Date.now() - n._lastFrameAt > n._timeToNext && v();
+              };
+              z();
+            }
+            var b = 0;
+            function p(z) {
+              return Array.isArray(i) ? b >= i.length ? z.transitionOpts = i[b] : z.transitionOpts = i[0] : z.transitionOpts = i, b++, z;
+            }
+            var k, E, T = [], L = t == null, x = Array.isArray(t), C = !L && !x && Sa.isPlainObject(t);
+            if (C) T.push({ type: "object", data: p(Sa.extendFlat({}, t)) });
+            else if (L || ["string", "number"].indexOf(typeof t) !== -1) for (k = 0; k < n._frames.length; k++) E = n._frames[k], E && (L || String(E.group) === String(t)) && T.push({ type: "byname", name: String(E.name), data: p({ name: E.name }) });
+            else if (x) for (k = 0; k < t.length; k++) {
+              var M = t[k];
+              ["number", "string"].indexOf(typeof M) !== -1 ? (M = String(M), T.push({ type: "byname", name: M, data: p({ name: M }) })) : Sa.isPlainObject(M) && T.push({ type: "object", data: p(Sa.extendFlat({}, M)) });
+            }
+            for (k = 0; k < T.length; k++) if (E = T[k], E.type === "byname" && !n._frameHash[E.data.name]) {
+              Sa.warn('animate failure: frame not found: "' + E.data.name + '"'), c();
+              return;
+            }
+            ["next", "immediate"].indexOf(r.mode) !== -1 && f(), r.direction === "reverse" && T.reverse();
+            var g = e._fullLayout._currentFrame;
+            if (g && r.fromcurrent) {
+              var P = -1;
+              for (k = 0; k < T.length; k++) if (E = T[k], E.type === "byname" && E.name === g) {
+                P = k;
+                break;
+              }
+              if (P > 0 && P < T.length - 1) {
+                var A = [];
+                for (k = 0; k < T.length; k++) E = T[k], (T[k].type !== "byname" || k > P) && A.push(E);
+                T = A;
+              }
+            }
+            T.length > 0 ? h(T) : (e.emit("plotly_animated"), u());
+          });
+        }
+        function ovt(e, t, r) {
+          if (e = Sa.getGraphDiv(e), t == null) return Promise.resolve();
+          if (!Sa.isPlotDiv(e)) throw new Error("This element is not a Plotly plot: " + e + ". It's likely that you've failed to create a plot before adding frames. For more details, see https://plotly.com/javascript/animations/");
+          var n, i, a, o, s = e._transitionData._frames, l = e._transitionData._frameHash;
+          if (!Array.isArray(t)) throw new Error("addFrames failure: frameList must be an Array of frame definitions" + t);
+          var u = s.length + t.length * 2, c = [], f = {};
+          for (n = t.length - 1; n >= 0; n--) if (Sa.isPlainObject(t[n])) {
+            var h = t[n].name, d = (l[h] || f[h] || {}).name, v = t[n].name, _ = l[d] || f[d];
+            d && v && typeof v == "number" && _ && $N < Vhe && ($N++, Sa.warn('addFrames: overwriting frame "' + (l[d] || f[d]).name + '" with a frame whose name of type "number" also equates to "' + d + '". This is valid but may potentially lead to unexpected behavior since all plotly.js frame names are stored internally as strings.'), $N === Vhe && Sa.warn("addFrames: This API call has yielded too many of these warnings. For the rest of this call, further warnings about numeric frame names will be suppressed.")), f[h] = { name: h }, c.push({ frame: Qo.supplyFrameDefaults(t[n]), index: r && r[n] !== void 0 && r[n] !== null ? r[n] : u + n });
+          }
+          c.sort(function(C, M) {
+            return C.index > M.index ? -1 : C.index < M.index ? 1 : 0;
+          });
+          var b = [], p = [], k = s.length;
+          for (n = c.length - 1; n >= 0; n--) {
+            if (i = c[n].frame, typeof i.name == "number" && Sa.warn("Warning: addFrames accepts frames with numeric names, but the numbers areimplicitly cast to strings"), !i.name) for (; l[i.name = "frame " + e._transitionData._counter++]; ) ;
+            if (l[i.name]) {
+              for (a = 0; a < s.length && (s[a] || {}).name !== i.name; a++) ;
+              b.push({ type: "replace", index: a, value: i }), p.unshift({ type: "replace", index: a, value: s[a] });
+            } else o = Math.max(0, Math.min(c[n].index, k)), b.push({ type: "insert", index: o, value: i }), p.unshift({ type: "delete", index: o }), k++;
+          }
+          var E = Qo.modifyFrames, T = Qo.modifyFrames, L = [e, p], x = [e, b];
+          return op && op.add(e, E, L, T, x), Qo.modifyFrames(e, b);
+        }
+        function svt(e, t) {
+          if (e = Sa.getGraphDiv(e), !Sa.isPlotDiv(e)) throw new Error("This element is not a Plotly plot: " + e);
+          var r, n, i = e._transitionData._frames, a = [], o = [];
+          if (!t) for (t = [], r = 0; r < i.length; r++) t.push(r);
+          for (t = t.slice(), t.sort(), r = t.length - 1; r >= 0; r--) n = t[r], a.push({ type: "delete", index: n }), o.unshift({ type: "insert", index: n, value: i[n] });
+          var s = Qo.modifyFrames, l = Qo.modifyFrames, u = [e, o], c = [e, a];
+          return op && op.add(e, s, u, l, c), Qo.modifyFrames(e, a);
+        }
+        function lvt(e) {
+          e = Sa.getGraphDiv(e);
+          var t = e._fullLayout || {}, r = e._fullData || [];
+          return Qo.cleanPlot([], {}, r, t), Qo.purge(e), QN.purge(e), t._container && t._container.remove(), delete e._context, e;
+        }
+        function uvt(e) {
+          var t = e._fullLayout, r = e.getBoundingClientRect();
+          if (!Sa.equalDomRects(r, t._lastBBox)) {
+            var n = t._invTransform = Sa.inverseTransformMatrix(Sa.getFullTransformMatrix(e));
+            t._invScaleX = Math.sqrt(n[0][0] * n[0][0] + n[0][1] * n[0][1] + n[0][2] * n[0][2]), t._invScaleY = Math.sqrt(n[1][0] * n[1][0] + n[1][1] * n[1][1] + n[1][2] * n[1][2]), t._lastBBox = r;
+          }
+        }
+        function cvt(e) {
+          var t = BP.select(e), r = e._fullLayout;
+          if (r._calcInverseTransform = uvt, r._calcInverseTransform(e), r._container = t.selectAll(".plot-container").data([0]), r._container.enter().insert("div", ":first-child").classed("plot-container", true).classed("plotly", true).style({ width: "100%", height: "100%" }), r._paperdiv = r._container.selectAll(".svg-container").data([0]), r._paperdiv.enter().append("div").classed("user-select-none", true).classed("svg-container", true).style("position", "relative"), r._glcontainer = r._paperdiv.selectAll(".gl-container").data([{}]), r._glcontainer.enter().append("div").classed("gl-container", true), r._paperdiv.selectAll(".main-svg").remove(), r._paperdiv.select(".modebar-container").remove(), r._paper = r._paperdiv.insert("svg", ":first-child").classed("main-svg", true), r._toppaper = r._paperdiv.append("svg").classed("main-svg", true), r._modebardiv = r._paperdiv.append("div"), delete r._modeBar, r._hoverpaper = r._paperdiv.append("svg").classed("main-svg", true), !r._uid) {
+            var n = {};
+            BP.selectAll("defs").each(function() {
+              this.id && (n[this.id.split("-")[1]] = 1);
+            }), r._uid = Sa.randstr(n);
+          }
+          r._paperdiv.selectAll(".main-svg").attr(qdt.svgAttrs), r._defs = r._paper.append("defs").attr("id", "defs-" + r._uid), r._clips = r._defs.append("g").classed("clips", true), r._topdefs = r._toppaper.append("defs").attr("id", "topdefs-" + r._uid), r._topclips = r._topdefs.append("g").classed("clips", true), r._bgLayer = r._paper.append("g").classed("bglayer", true), r._draggers = r._paper.append("g").classed("draglayer", true);
+          var i = r._paper.append("g").classed("layer-below", true);
+          r._imageLowerLayer = i.append("g").classed("imagelayer", true), r._shapeLowerLayer = i.append("g").classed("shapelayer", true), r._cartesianlayer = r._paper.append("g").classed("cartesianlayer", true), r._polarlayer = r._paper.append("g").classed("polarlayer", true), r._smithlayer = r._paper.append("g").classed("smithlayer", true), r._ternarylayer = r._paper.append("g").classed("ternarylayer", true), r._geolayer = r._paper.append("g").classed("geolayer", true), r._funnelarealayer = r._paper.append("g").classed("funnelarealayer", true), r._pielayer = r._paper.append("g").classed("pielayer", true), r._iciclelayer = r._paper.append("g").classed("iciclelayer", true), r._treemaplayer = r._paper.append("g").classed("treemaplayer", true), r._sunburstlayer = r._paper.append("g").classed("sunburstlayer", true), r._indicatorlayer = r._toppaper.append("g").classed("indicatorlayer", true), r._glimages = r._paper.append("g").classed("glimages", true);
+          var a = r._toppaper.append("g").classed("layer-above", true);
+          r._imageUpperLayer = a.append("g").classed("imagelayer", true), r._shapeUpperLayer = a.append("g").classed("shapelayer", true), r._selectionLayer = r._toppaper.append("g").classed("selectionlayer", true), r._infolayer = r._toppaper.append("g").classed("infolayer", true), r._menulayer = r._toppaper.append("g").classed("menulayer", true), r._zoomlayer = r._toppaper.append("g").classed("zoomlayer", true), r._hoverlayer = r._hoverpaper.append("g").classed("hoverlayer", true), r._modebardiv.classed("modebar-container", true).style("position", "absolute").style("top", "0px").style("right", "0px"), e.emit("plotly_framework");
+        }
+        _l.animate = avt;
+        _l.addFrames = ovt;
+        _l.deleteFrames = svt;
+        _l.addTraces = ede;
+        _l.deleteTraces = tde;
+        _l.extendTraces = $he;
+        _l.moveTraces = eU;
+        _l.prependTraces = Qhe;
+        _l.newPlot = jdt;
+        _l._doPlot = Udt;
+        _l.purge = lvt;
+        _l.react = rvt;
+        _l.redraw = Hdt;
+        _l.relayout = $M;
+        _l.restyle = VP;
+        _l.setPlotConfig = Vdt;
+        _l.update = HP;
+        _l._guiRelayout = tU($M);
+        _l._guiRestyle = tU(VP);
+        _l._guiUpdate = tU(HP);
+        _l._storeDirectGUIEdit = Ydt;
+      });
+      var Oy = ye((Pm) => {
+        var fvt = qa();
+        Pm.getDelay = function(e) {
+          return e._has && (e._has("gl3d") || e._has("mapbox") || e._has("map")) ? 500 : 0;
+        };
+        Pm.getRedrawFunc = function(e) {
+          return function() {
+            fvt.getComponentMethod("colorbar", "draw")(e);
+          };
+        };
+        Pm.encodeSVG = function(e) {
+          return "data:image/svg+xml," + encodeURIComponent(e);
+        };
+        Pm.encodeJSON = function(e) {
+          return "data:application/json," + encodeURIComponent(e);
+        };
+        var lde = window.URL || window.webkitURL;
+        Pm.createObjectURL = function(e) {
+          return lde.createObjectURL(e);
+        };
+        Pm.revokeObjectURL = function(e) {
+          return lde.revokeObjectURL(e);
+        };
+        Pm.createBlob = function(e, t) {
+          if (t === "svg") return new window.Blob([e], { type: "image/svg+xml;charset=utf-8" });
+          if (t === "full-json") return new window.Blob([e], { type: "application/json;charset=utf-8" });
+          var r = hvt(window.atob(e));
+          return new window.Blob([r], { type: "image/" + t });
+        };
+        Pm.octetStream = function(e) {
+          document.location.href = "data:application/octet-stream" + e;
+        };
+        function hvt(e) {
+          for (var t = e.length, r = new ArrayBuffer(t), n = new Uint8Array(r), i = 0; i < t; i++) n[i] = e.charCodeAt(i);
+          return r;
+        }
+        Pm.IMAGE_URL_PREFIX = /^data:image\/\w+;base64,/;
+      });
+      var YP = ye((Uor, ude) => {
+        var iU = Oa();
+        Dr();
+        var dvt = So(), vvt = ka();
+        Wp();
+        var rU = /"/g, e4 = "TOBESTRIPPED", pvt = new RegExp('("' + e4 + ")|(" + e4 + '")', "g");
+        function gvt(e) {
+          var t = iU.select("body").append("div").style({ display: "none" }).html(""), r = e.replace(/(&[^;]*;)/gi, function(n) {
+            return n === "&lt;" ? "&#60;" : n === "&rt;" ? "&#62;" : n.indexOf("<") !== -1 || n.indexOf(">") !== -1 ? "" : t.html(n).text();
+          });
+          return t.remove(), r;
+        }
+        function mvt(e) {
+          return e.replace(/&(?!\w+;|\#[0-9]+;| \#x[0-9A-F]+;)/g, "&amp;");
+        }
+        ude.exports = function(t, r, n) {
+          var i = t._fullLayout, a = i._paper, o = i._toppaper, s = i.width, l = i.height, u;
+          a.insert("rect", ":first-child").call(dvt.setRect, 0, 0, s, l).call(vvt.fill, i.paper_bgcolor);
+          var c = i._basePlotModules || [];
+          for (u = 0; u < c.length; u++) {
+            var f = c[u];
+            f.toSVG && f.toSVG(t);
+          }
+          if (o) {
+            var h = o.node().childNodes, d = Array.prototype.slice.call(h);
+            for (u = 0; u < d.length; u++) {
+              var v = d[u];
+              v.childNodes.length && a.node().appendChild(v);
+            }
+          }
+          i._draggers && i._draggers.remove(), a.node().style.background = "", a.selectAll("text").attr({ "data-unformatted": null, "data-math": null }).each(function() {
+            var b = iU.select(this);
+            if (this.style.visibility === "hidden" || this.style.display === "none") {
+              b.remove();
+              return;
+            } else b.style({ visibility: null, display: null });
+            var p = this.style.fontFamily;
+            p && p.indexOf('"') !== -1 && b.style("font-family", p.replace(rU, e4));
+            var k = this.style.fontWeight;
+            k && (k === "normal" || k === "400") && b.style("font-weight", void 0);
+            var E = this.style.fontStyle;
+            E && E === "normal" && b.style("font-style", void 0);
+            var T = this.style.fontVariant;
+            T && T === "normal" && b.style("font-variant", void 0);
+          }), a.selectAll(".gradient_filled,.pattern_filled").each(function() {
+            var b = iU.select(this), p = this.style.fill;
+            p && p.indexOf("url(") !== -1 && b.style("fill", p.replace(rU, e4));
+            var k = this.style.stroke;
+            k && k.indexOf("url(") !== -1 && b.style("stroke", k.replace(rU, e4));
+          }), (r === "pdf" || r === "eps") && a.selectAll("#MathJax_SVG_glyphs path").attr("stroke-width", 0), r === "svg" && n && (a.attr("width", n * s), a.attr("height", n * l), a.attr("viewBox", "0 0 " + s + " " + l));
+          var _ = new window.XMLSerializer().serializeToString(a.node());
+          return _ = gvt(_), _ = mvt(_), _ = _.replace(pvt, "'"), _;
+        };
+      });
+      var KP = ye((Vor, cde) => {
+        var yvt = Dr(), _vt = Ab().EventEmitter, t4 = Oy();
+        function xvt(e) {
+          var t = e.emitter || new _vt(), r = new Promise(function(n, i) {
+            var a = window.Image, o = e.svg, s = e.format || "png", l = e.canvas, u = e.scale || 1, c = e.width || 300, f = e.height || 150, h = u * c, d = u * f, v = l.getContext("2d", { willReadFrequently: true }), _ = new a(), b, p;
+            s === "svg" || yvt.isSafari() ? p = t4.encodeSVG(o) : (b = t4.createBlob(o, "svg"), p = t4.createObjectURL(b)), l.width = h, l.height = d, _.onload = function() {
+              var k;
+              switch (b = null, t4.revokeObjectURL(p), s !== "svg" && v.drawImage(_, 0, 0, h, d), s) {
+                case "jpeg":
+                  k = l.toDataURL("image/jpeg");
+                  break;
+                case "png":
+                  k = l.toDataURL("image/png");
+                  break;
+                case "webp":
+                  k = l.toDataURL("image/webp");
+                  break;
+                case "svg":
+                  k = p;
+                  break;
+                default:
+                  var E = "Image format is not jpeg, png, svg or webp.";
+                  if (i(new Error(E)), !e.promise) return t.emit("error", E);
+              }
+              n(k), e.promise || t.emit("success", k);
+            }, _.onerror = function(k) {
+              if (b = null, t4.revokeObjectURL(p), i(k), !e.promise) return t.emit("error", k);
+            }, _.src = p;
+          });
+          return e.promise ? r : t;
+        }
+        cde.exports = xvt;
+      });
+      var aU = ye((Gor, dde) => {
+        var fde = Eo(), hde = ZP(), bvt = Mc(), Im = Dr(), r4 = Oy(), wvt = YP(), Tvt = KP(), Avt = g6().version, nU = { format: { valType: "enumerated", values: ["png", "jpeg", "webp", "svg", "full-json"], dflt: "png" }, width: { valType: "number", min: 1 }, height: { valType: "number", min: 1 }, scale: { valType: "number", min: 0, dflt: 1 }, setBackground: { valType: "any", dflt: false }, imageDataOnly: { valType: "boolean", dflt: false } };
+        function Svt(e, t) {
+          t = t || {};
+          var r, n, i, a;
+          Im.isPlainObject(e) ? (r = e.data || [], n = e.layout || {}, i = e.config || {}, a = {}) : (e = Im.getGraphDiv(e), r = Im.extendDeep([], e.data), n = Im.extendDeep({}, e.layout), i = e._context, a = e._fullLayout || {});
+          function o(x) {
+            return !(x in t) || Im.validate(t[x], nU[x]);
+          }
+          if (!o("width") && t.width !== null || !o("height") && t.height !== null) throw new Error("Height and width should be pixel values.");
+          if (!o("format")) throw new Error("Export format is not " + Im.join2(nU.format.values, ", ", " or ") + ".");
+          var s = {};
+          function l(x, C) {
+            return Im.coerce(t, s, nU, x, C);
+          }
+          var u = l("format"), c = l("width"), f = l("height"), h = l("scale"), d = l("setBackground"), v = l("imageDataOnly"), _ = document.createElement("div");
+          _.style.position = "absolute", _.style.left = "-5000px", document.body.appendChild(_);
+          var b = Im.extendFlat({}, n);
+          c ? b.width = c : t.width === null && fde(a.width) && (b.width = a.width), f ? b.height = f : t.height === null && fde(a.height) && (b.height = a.height);
+          var p = Im.extendFlat({}, i, { _exportedPlot: true, staticPlot: true, setBackground: d }), k = r4.getRedrawFunc(_);
+          function E() {
+            return new Promise(function(x) {
+              setTimeout(x, r4.getDelay(_._fullLayout));
+            });
+          }
+          function T() {
+            return new Promise(function(x, C) {
+              var M = wvt(_, u, h), g = _._fullLayout.width, P = _._fullLayout.height;
+              function A() {
+                hde.purge(_), document.body.removeChild(_);
+              }
+              if (u === "full-json") {
+                var z = bvt.graphJson(_, false, "keepdata", "object", true, true);
+                return z.version = Avt, z = JSON.stringify(z), A(), x(v ? z : r4.encodeJSON(z));
+              }
+              if (A(), u === "svg") return x(v ? M : r4.encodeSVG(M));
+              var O = document.createElement("canvas");
+              O.id = Im.randstr(), Tvt({ format: u, width: g, height: P, scale: h, canvas: O, svg: M, promise: true }).then(x).catch(C);
+            });
+          }
+          function L(x) {
+            return v ? x.replace(r4.IMAGE_URL_PREFIX, "") : x;
+          }
+          return new Promise(function(x, C) {
+            hde.newPlot(_, r, b, p).then(k).then(E).then(T).then(function(M) {
+              x(L(M));
+            }).catch(function(M) {
+              C(M);
+            });
+          });
+        }
+        dde.exports = Svt;
+      });
+      var gde = ye((Hor, pde) => {
+        var I0 = Dr(), Mvt = Mc(), Evt = P3(), kvt = _b().dfltConfig, Rg = I0.isPlainObject, Qb = Array.isArray, oU = I0.isArrayOrTypedArray;
+        pde.exports = function(t, r) {
+          t === void 0 && (t = []), r === void 0 && (r = {});
+          var n = Evt.get(), i = [], a = { _context: I0.extendFlat({}, kvt) }, o, s;
+          Qb(t) ? (a.data = I0.extendDeep([], t), o = t) : (a.data = [], o = [], i.push(md("array", "data"))), Rg(r) ? (a.layout = I0.extendDeep({}, r), s = r) : (a.layout = {}, s = {}, arguments.length > 1 && i.push(md("object", "layout"))), Mvt.supplyDefaults(a);
+          for (var l = a._fullData, u = o.length, c = 0; c < u; c++) {
+            var f = o[c], h = ["data", c];
+            if (!Rg(f)) {
+              i.push(md("object", h));
+              continue;
+            }
+            var d = l[c], v = d.type, _ = n.traces[v].attributes;
+            _.type = { valType: "enumerated", values: [v] }, d.visible === false && f.visible !== false && i.push(md("invisible", h)), JP(f, d, _, i, h);
+          }
+          var b = a._fullLayout, p = Cvt(n, l);
+          return JP(s, b, p, i, "layout"), i.length === 0 ? void 0 : i;
+        };
+        function JP(e, t, r, n, i, a) {
+          a = a || [];
+          for (var o = Object.keys(e), s = 0; s < o.length; s++) {
+            var l = o[s], u = a.slice();
+            u.push(l);
+            var c = e[l], f = t[l], h = Ivt(r, l), d = (h || {}).valType, v = d === "info_array", _ = d === "colorscale", b = (h || {}).items;
+            if (!Pvt(r, l)) n.push(md("schema", i, u));
+            else if (Rg(c) && Rg(f) && d !== "any") JP(c, f, h, n, i, u);
+            else if (v && Qb(c)) {
+              c.length > f.length && n.push(md("unused", i, u.concat(f.length)));
+              var p = f.length, k = Array.isArray(b);
+              k && (p = Math.min(p, b.length));
+              var E, T, L, x, C;
+              if (h.dimensions === 2) for (T = 0; T < p; T++) if (Qb(c[T])) {
+                c[T].length > f[T].length && n.push(md("unused", i, u.concat(T, f[T].length)));
+                var M = f[T].length;
+                for (E = 0; E < (k ? Math.min(M, b[T].length) : M); E++) L = k ? b[T][E] : b, x = c[T][E], C = f[T][E], I0.validate(x, L) ? C !== x && C !== +x && n.push(md("dynamic", i, u.concat(T, E), x, C)) : n.push(md("value", i, u.concat(T, E), x));
+              } else n.push(md("array", i, u.concat(T), c[T]));
+              else for (T = 0; T < p; T++) L = k ? b[T] : b, x = c[T], C = f[T], I0.validate(x, L) ? C !== x && C !== +x && n.push(md("dynamic", i, u.concat(T), x, C)) : n.push(md("value", i, u.concat(T), x));
+            } else if (h.items && !v && Qb(c)) {
+              var g = b[Object.keys(b)[0]], P = [], A, z;
+              for (A = 0; A < f.length; A++) {
+                var O = f[A]._index || A;
+                if (z = u.slice(), z.push(O), Rg(c[O]) && Rg(f[A])) {
+                  P.push(O);
+                  var U = c[O], G = f[A];
+                  Rg(U) && U.visible !== false && G.visible === false ? n.push(md("invisible", i, z)) : JP(U, G, g, n, i, z);
+                }
+              }
+              for (A = 0; A < c.length; A++) z = u.slice(), z.push(A), Rg(c[A]) ? P.indexOf(A) === -1 && n.push(md("unused", i, z)) : n.push(md("object", i, z, c[A]));
+            } else !Rg(c) && Rg(f) ? n.push(md("object", i, u, c)) : !oU(c) && oU(f) && !v && !_ ? n.push(md("array", i, u, c)) : l in t ? I0.validate(c, h) ? h.valType === "enumerated" && (h.coerceNumber && c !== +f || !oU(c) && c !== f || String(c) !== String(f)) && n.push(md("dynamic", i, u, c, f)) : n.push(md("value", i, u, c)) : n.push(md("unused", i, u, c));
+          }
+          return n;
+        }
+        function Cvt(e, t) {
+          for (var r = e.layout.layoutAttributes, n = 0; n < t.length; n++) {
+            var i = t[n], a = e.traces[i.type], o = a.layoutAttributes;
+            o && (i.subplot ? I0.extendFlat(r[a.attributes.subplot.dflt], o) : I0.extendFlat(r, o));
+          }
+          return r;
+        }
+        var Lvt = { object: function(e, t) {
+          var r;
+          return e === "layout" && t === "" ? r = "The layout argument" : e[0] === "data" && t === "" ? r = "Trace " + e[1] + " in the data argument" : r = $b(e) + "key " + t, r + " must be linked to an object container";
+        }, array: function(e, t) {
+          var r;
+          return e === "data" ? r = "The data argument" : r = $b(e) + "key " + t, r + " must be linked to an array container";
+        }, schema: function(e, t) {
+          return $b(e) + "key " + t + " is not part of the schema";
+        }, unused: function(e, t, r) {
+          var n = Rg(r) ? "container" : "key";
+          return $b(e) + n + " " + t + " did not get coerced";
+        }, dynamic: function(e, t, r, n) {
+          return [$b(e) + "key", t, "(set to '" + r + "')", "got reset to", "'" + n + "'", "during defaults."].join(" ");
+        }, invisible: function(e, t) {
+          return (t ? $b(e) + "item " + t : "Trace " + e[1]) + " got defaulted to be not visible";
+        }, value: function(e, t, r) {
+          return [$b(e) + "key " + t, "is set to an invalid value (" + r + ")"].join(" ");
+        } };
+        function $b(e) {
+          return Qb(e) ? "In data trace " + e[1] + ", " : "In " + e + ", ";
+        }
+        function md(e, t, r, n, i) {
+          r = r || "";
+          var a, o;
+          Qb(t) ? (a = t[0], o = t[1]) : (a = t, o = null);
+          var s = Dvt(r), l = Lvt[e](t, s, n, i);
+          return I0.log(l), { code: e, container: a, trace: o, path: r, astr: s, msg: l };
+        }
+        function Pvt(e, t) {
+          var r = vde(t), n = r.keyMinusId, i = r.id;
+          return n in e && e[n]._isSubplotObj && i ? true : t in e;
+        }
+        function Ivt(e, t) {
+          if (t in e) return e[t];
+          var r = vde(t);
+          return e[r.keyMinusId];
+        }
+        var Rvt = I0.counterRegex("([a-z]+)");
+        function vde(e) {
+          var t = e.match(Rvt);
+          return { keyMinusId: t && t[1], id: t && t[2] };
+        }
+        function Dvt(e) {
+          if (!Qb(e)) return String(e);
+          for (var t = "", r = 0; r < e.length; r++) {
+            var n = e[r];
+            typeof n == "number" ? t = t.slice(0, -1) + "[" + n + "]" : t += n, r < e.length - 1 && (t += ".");
+          }
+          return t;
+        }
+      });
+      var yde = ye((jor, mde) => {
+        var Fvt = Dr(), $P = Oy();
+        function zvt(e, t, r) {
+          var n = document.createElement("a"), i = "download" in n, a = new Promise(function(o, s) {
+            var l, u;
+            if (i) return l = $P.createBlob(e, r), u = $P.createObjectURL(l), n.href = u, n.download = t, document.body.appendChild(n), n.click(), document.body.removeChild(n), $P.revokeObjectURL(u), l = null, o(t);
+            if (Fvt.isSafari()) {
+              var c = r === "svg" ? "," : ";base64,";
+              return $P.octetStream(c + encodeURIComponent(e)), o(t);
+            }
+            s(new Error("download error"));
+          });
+          return a;
+        }
+        mde.exports = zvt;
+      });
+      var sU = ye((Xor, xde) => {
+        var _de = Dr(), Ovt = aU(), qvt = yde();
+        Oy();
+        function Bvt(e, t) {
+          var r;
+          return _de.isPlainObject(e) || (r = _de.getGraphDiv(e)), t = t || {}, t.format = t.format || "png", t.width = t.width || null, t.height = t.height || null, t.imageDataOnly = true, new Promise(function(n, i) {
+            r && r._snapshotInProgress && i(new Error("Snapshotting already in progress.")), r && (r._snapshotInProgress = true);
+            var a = Ovt(e, t), o = t.filename || e.fn || "newplot";
+            o += "." + t.format.replace("-", "."), a.then(function(s) {
+              return r && (r._snapshotInProgress = false), qvt(s, o, t.format);
+            }).then(function(s) {
+              n(s);
+            }).catch(function(s) {
+              r && (r._snapshotInProgress = false), i(s);
+            });
+          });
+        }
+        xde.exports = Bvt;
+      });
+      var Sde = ye((lU) => {
+        var Cp = Dr(), Lp = Cp.isPlainObject, bde = P3(), wde = Mc(), Nvt = Gl(), Tde = vl(), Ade = _b().dfltConfig;
+        lU.makeTemplate = function(e) {
+          e = Cp.isPlainObject(e) ? e : Cp.getGraphDiv(e), e = Cp.extendDeep({ _context: Ade }, { data: e.data, layout: e.layout }), wde.supplyDefaults(e);
+          var t = e.data || [], r = e.layout || {};
+          r._basePlotModules = e._fullLayout._basePlotModules, r._modules = e._fullLayout._modules;
+          var n = { data: {}, layout: {} };
+          t.forEach(function(d) {
+            var v = {};
+            i4(d, v, Vvt.bind(null, d));
+            var _ = Cp.coerce(d, {}, Nvt, "type"), b = n.data[_];
+            b || (b = n.data[_] = []), b.push(v);
+          }), i4(r, n.layout, Uvt.bind(null, r)), delete n.layout.template;
+          var i = r.template;
+          if (Lp(i)) {
+            var a = i.layout, o, s, l, u, c, f;
+            Lp(a) && QP(a, n.layout);
+            var h = i.data;
+            if (Lp(h)) {
+              for (s in n.data) if (l = h[s], Array.isArray(l)) {
+                for (c = n.data[s], f = c.length, u = l.length, o = 0; o < f; o++) QP(l[o % u], c[o]);
+                for (o = f; o < u; o++) c.push(Cp.extendDeep({}, l[o]));
+              }
+              for (s in h) s in n.data || (n.data[s] = Cp.extendDeep([], h[s]));
+            }
+          }
+          return n;
+        };
+        function QP(e, t) {
+          e = Cp.extendDeep({}, e);
+          var r = Object.keys(e).sort(), n, i;
+          function a(c, f, h) {
+            if (Lp(f) && Lp(c)) QP(c, f);
+            else if (Array.isArray(f) && Array.isArray(c)) {
+              var d = Tde.arrayTemplater({ _template: e }, h);
+              for (i = 0; i < f.length; i++) {
+                var v = f[i], _ = d.newItem(v)._template;
+                _ && QP(_, v);
+              }
+              var b = d.defaultItems();
+              for (i = 0; i < b.length; i++) f.push(b[i]._template);
+              for (i = 0; i < f.length; i++) delete f[i].templateitemname;
+            }
+          }
+          for (n = 0; n < r.length; n++) {
+            var o = r[n], s = e[o];
+            if (o in t ? a(s, t[o], o) : t[o] = s, eI(o) === o) for (var l in t) {
+              var u = eI(l);
+              l !== u && u === o && !(l in e) && a(s, t[l], o);
+            }
+          }
+        }
+        function eI(e) {
+          return e.replace(/[0-9]+$/, "");
+        }
+        function i4(e, t, r, n, i) {
+          var a = i && r(i);
+          for (var o in e) {
+            var s = e[o], l = R0(e, o, n), u = R0(e, o, i), c = r(u);
+            if (!c) {
+              var f = eI(o);
+              f !== o && (u = R0(e, f, i), c = r(u));
+            }
+            if (!(a && a === c) && !(!c || c._noTemplating || c.valType === "data_array" || c.arrayOk && Array.isArray(s))) if (!c.valType && Lp(s)) i4(s, t, r, l, u);
+            else if (c._isLinkedToArray && Array.isArray(s)) for (var h = false, d = 0, v = {}, _ = 0; _ < s.length; _++) {
+              var b = s[_];
+              if (Lp(b)) {
+                var p = b.name;
+                if (p) v[p] || (i4(b, t, r, R0(s, d, l), R0(s, d, u)), d++, v[p] = 1);
+                else if (!h) {
+                  var k = Tde.arrayDefaultKey(o), E = R0(e, k, n), T = R0(s, d, l);
+                  i4(b, t, r, T, R0(s, d, u));
+                  var L = Cp.nestedProperty(t, T), x = Cp.nestedProperty(t, E);
+                  x.set(L.get()), L.set(null), h = true;
+                }
+              }
+            }
+            else {
+              var C = Cp.nestedProperty(t, l);
+              C.set(s);
+            }
+          }
+        }
+        function Uvt(e, t) {
+          return bde.getLayoutValObject(e, Cp.nestedProperty({}, t).parts);
+        }
+        function Vvt(e, t) {
+          return bde.getTraceValObject(e, Cp.nestedProperty({}, t).parts);
+        }
+        function R0(e, t, r) {
+          var n;
+          return r ? Array.isArray(e) ? n = r + "[" + t + "]" : n = r + "." + t : n = t, n;
+        }
+        lU.validateTemplate = function(e, t) {
+          var r = Cp.extendDeep({}, { _context: Ade, data: e.data, layout: e.layout }), n = r.layout || {};
+          Lp(t) || (t = n.template || {});
+          var i = t.layout, a = t.data, o = [];
+          r.layout = n, r.layout.template = t, wde.supplyDefaults(r);
+          var s = r._fullLayout, l = r._fullData, u = {};
+          function c(E, T) {
+            for (var L in E) if (L.charAt(0) !== "_" && Lp(E[L])) {
+              var x = eI(L), C = [], M;
+              for (M = 0; M < T.length; M++) C.push(R0(E, L, T[M])), x !== L && C.push(R0(E, x, T[M]));
+              for (M = 0; M < C.length; M++) u[C[M]] = 1;
+              c(E[L], C);
+            }
+          }
+          function f(E, T) {
+            for (var L in E) if (L.indexOf("defaults") === -1 && Lp(E[L])) {
+              var x = R0(E, L, T);
+              u[x] ? f(E[L], x) : o.push({ code: "unused", path: x });
+            }
+          }
+          if (Lp(i) ? (c(s, ["layout"]), f(i, "layout")) : o.push({ code: "layout" }), !Lp(a)) o.push({ code: "data" });
+          else {
+            for (var h = {}, d, v = 0; v < l.length; v++) {
+              var _ = l[v];
+              d = _.type, h[d] = (h[d] || 0) + 1, _._fullInput._template || o.push({ code: "missing", index: _.index, traceType: d });
+            }
+            for (d in a) {
+              var b = a[d].length, p = h[d] || 0;
+              b > p ? o.push({ code: "unused", traceType: d, templateCount: b, dataCount: p }) : p > b && o.push({ code: "reused", traceType: d, templateCount: b, dataCount: p });
+            }
+          }
+          function k(E, T) {
+            for (var L in E) if (L.charAt(0) !== "_") {
+              var x = E[L], C = R0(E, L, T);
+              Lp(x) ? (Array.isArray(E) && x._template === false && x.templateitemname && o.push({ code: "missing", path: C, templateitemname: x.templateitemname }), k(x, C)) : Array.isArray(x) && Gvt(x) && k(x, C);
+            }
+          }
+          if (k({ data: l, layout: s }, ""), o.length) return o.map(Hvt);
+        };
+        function Gvt(e) {
+          for (var t = 0; t < e.length; t++) if (Lp(e[t])) return true;
+        }
+        function Hvt(e) {
+          var t;
+          switch (e.code) {
+            case "data":
+              t = "The template has no key data.";
+              break;
+            case "layout":
+              t = "The template has no key layout.";
+              break;
+            case "missing":
+              e.path ? t = "There are no templates for item " + e.path + " with name " + e.templateitemname : t = "There are no templates for trace " + e.index + ", of type " + e.traceType + ".";
+              break;
+            case "unused":
+              e.path ? t = "The template item at " + e.path + " was not used in constructing the plot." : e.dataCount ? t = "Some of the templates of type " + e.traceType + " were not used. The template has " + e.templateCount + " traces, the data only has " + e.dataCount + " of this type." : t = "The template has " + e.templateCount + " traces of type " + e.traceType + " but there are none in the data.";
+              break;
+            case "reused":
+              t = "Some of the templates of type " + e.traceType + " were used more than once. The template has " + e.templateCount + " traces, the data has " + e.dataCount + " of this type.";
+              break;
+          }
+          return e.msg = t, e;
+        }
+      });
+      var Ede = ye((ef) => {
+        var rd = ZP();
+        ef._doPlot = rd._doPlot;
+        ef.newPlot = rd.newPlot;
+        ef.restyle = rd.restyle;
+        ef.relayout = rd.relayout;
+        ef.redraw = rd.redraw;
+        ef.update = rd.update;
+        ef._guiRestyle = rd._guiRestyle;
+        ef._guiRelayout = rd._guiRelayout;
+        ef._guiUpdate = rd._guiUpdate;
+        ef._storeDirectGUIEdit = rd._storeDirectGUIEdit;
+        ef.react = rd.react;
+        ef.extendTraces = rd.extendTraces;
+        ef.prependTraces = rd.prependTraces;
+        ef.addTraces = rd.addTraces;
+        ef.deleteTraces = rd.deleteTraces;
+        ef.moveTraces = rd.moveTraces;
+        ef.purge = rd.purge;
+        ef.addFrames = rd.addFrames;
+        ef.deleteFrames = rd.deleteFrames;
+        ef.animate = rd.animate;
+        ef.setPlotConfig = rd.setPlotConfig;
+        var jvt = HS().getGraphDiv, Wvt = dP().eraseActiveShape;
+        ef.deleteActiveShape = function(e) {
+          return Wvt(jvt(e));
+        };
+        ef.toImage = aU();
+        ef.validate = gde();
+        ef.downloadImage = sU();
+        var Mde = Sde();
+        ef.makeTemplate = Mde.makeTemplate;
+        ef.validateTemplate = Mde.validateTemplate;
+      });
+      var oT = ye((Kor, kde) => {
+        var uU = Dr(), Xvt = qa();
+        kde.exports = function(t, r, n, i) {
+          var a = i("x"), o = i("y"), s, l = Xvt.getComponentMethod("calendars", "handleTraceDefaults");
+          if (l(t, r, ["x", "y"], n), a) {
+            var u = uU.minRowLength(a);
+            o ? s = Math.min(u, uU.minRowLength(o)) : (s = u, i("y0"), i("dy"));
+          } else {
+            if (!o) return 0;
+            s = uU.minRowLength(o), i("x0"), i("dx");
+          }
+          return r._length = s, s;
+        };
+      });
+      var Dg = ye((Jor, Pde) => {
+        var Cde = Dr().dateTick0, Zvt = fs(), Yvt = Zvt.ONEWEEK;
+        function Lde(e, t) {
+          return e % Yvt === 0 ? Cde(t, 1) : Cde(t, 0);
+        }
+        Pde.exports = function(t, r, n, i, a) {
+          if (a || (a = { x: true, y: true }), a.x) {
+            var o = i("xperiod");
+            o && (i("xperiod0", Lde(o, r.xcalendar)), i("xperiodalignment"));
+          }
+          if (a.y) {
+            var s = i("yperiod");
+            s && (i("yperiod0", Lde(s, r.ycalendar)), i("yperiodalignment"));
+          }
+        };
+      });
+      var Dde = ye(($or, Rde) => {
+        var Ide = ["orientation", "groupnorm", "stackgaps"];
+        Rde.exports = function(t, r, n, i) {
+          var a = n._scatterStackOpts, o = i("stackgroup");
+          if (o) {
+            var s = r.xaxis + r.yaxis, l = a[s];
+            l || (l = a[s] = {});
+            var u = l[o], c = false;
+            u ? u.traces.push(r) : (u = l[o] = { traceIndices: [], traces: [r] }, c = true);
+            for (var f = { orientation: r.x && !r.y ? "h" : "v" }, h = 0; h < Ide.length; h++) {
+              var d = Ide[h], v = d + "Found";
+              if (!u[v]) {
+                var _ = t[d] !== void 0, b = d === "orientation";
+                if ((_ || c) && (u[d] = i(d, f[d]), b && (u.fillDflt = u[d] === "h" ? "tonextx" : "tonexty"), _ && (u[v] = true, !c && (delete u.traces[0][d], b)))) for (var p = 0; p < u.traces.length - 1; p++) {
+                  var k = u.traces[p];
+                  k._input.fill !== k.fill && (k.fill = u.fillDflt);
+                }
+              }
+            }
+            return u;
+          }
+        };
+      });
+      var $p = ye((Qor, qde) => {
+        var Fde = ka(), zde = pv().hasColorscale, Ode = td(), Kvt = Ru();
+        qde.exports = function(t, r, n, i, a, o = {}) {
+          var s = Kvt.isBubble(t), l = (t.line || {}).color, u;
+          if (l && (n = l), a("marker.symbol"), a("marker.opacity", s ? 0.7 : 1), a("marker.size"), o.noAngle || (a("marker.angle"), o.noAngleRef || a("marker.angleref"), o.noStandOff || a("marker.standoff")), a("marker.color", n), zde(t, "marker") && Ode(t, r, i, a, { prefix: "marker.", cLetter: "c" }), o.noSelect || (a("selected.marker.color"), a("unselected.marker.color"), a("selected.marker.size"), a("unselected.marker.size")), o.noLine || (l && !Array.isArray(l) && r.marker.color !== l ? u = l : s ? u = Fde.background : u = Fde.defaultLine, a("marker.line.color", u), zde(t, "marker.line") && Ode(t, r, i, a, { prefix: "marker.line.", cLetter: "c" }), a("marker.line.width", s ? 1 : 0), o.noLineDash || a("marker.line.dash")), s && (a("marker.sizeref"), a("marker.sizemin"), a("marker.sizemode")), o.gradient) {
+            var c = a("marker.gradient.type");
+            c !== "none" && a("marker.gradient.color");
+          }
+        };
+      });
+      var D0 = ye((esr, Bde) => {
+        var Jvt = Dr().isArrayOrTypedArray, $vt = pv().hasColorscale, Qvt = td();
+        Bde.exports = function(t, r, n, i, a, o) {
+          o || (o = {});
+          var s = (t.marker || {}).color;
+          if (s && s._inputArray && (s = s._inputArray), a("line.color", n), $vt(t, "line")) Qvt(t, r, i, a, { prefix: "line.", cLetter: "c" });
+          else {
+            var l = (Jvt(s) ? false : s) || n;
+            a("line.color", l);
+          }
+          a("line.width"), o.noDash || a("line.dash"), o.backoff && a("line.backoff");
+        };
+      });
+      var sT = ye((tsr, Nde) => {
+        Nde.exports = function(t, r, n) {
+          var i = n("line.shape");
+          i === "spline" && n("line.smoothing");
+        };
+      });
+      var F0 = ye((rsr, Ude) => {
+        var ept = Dr();
+        Ude.exports = function(e, t, r, n, i) {
+          i = i || {}, n("textposition"), ept.coerceFont(n, "textfont", i.font || r.font, i), i.noSelect || (n("selected.textfont.color"), n("unselected.textfont.color"));
+        };
+      });
+      var Fg = ye((isr, Gde) => {
+        var tI = ka(), Vde = Dr().isArrayOrTypedArray;
+        function tpt(e) {
+          for (var t = tI.interpolate(e[0][1], e[1][1], 0.5), r = 2; r < e.length; r++) {
+            var n = tI.interpolate(e[r - 1][1], e[r][1], 0.5);
+            t = tI.interpolate(t, n, e[r - 1][0] / e[r][0]);
+          }
+          return t;
+        }
+        Gde.exports = function(t, r, n, i, a) {
+          a || (a = {});
+          var o = false;
+          if (r.marker) {
+            var s = r.marker.color, l = (r.marker.line || {}).color;
+            s && !Vde(s) ? o = s : l && !Vde(l) && (o = l);
+          }
+          var u;
+          if (a.moduleHasFillgradient) {
+            var c = i("fillgradient.type");
+            if (c !== "none") {
+              i("fillgradient.start"), i("fillgradient.stop");
+              var f = i("fillgradient.colorscale");
+              f && (u = tpt(f));
+            }
+          }
+          i("fillcolor", tI.addOpacity((r.line || {}).color || o || u || n, 0.5));
+        };
+      });
+      var Xde = ye((nsr, Wde) => {
+        var Hde = Dr(), rpt = qa(), ipt = pf(), npt = Lm(), lT = Ru(), apt = oT(), opt = Dg(), spt = Dde(), lpt = $p(), upt = D0(), jde = sT(), cpt = F0(), fpt = Fg(), hpt = Dr().coercePattern;
+        Wde.exports = function(t, r, n, i) {
+          function a(d, v) {
+            return Hde.coerce(t, r, ipt, d, v);
+          }
+          var o = apt(t, r, i, a);
+          if (o || (r.visible = false), !!r.visible) {
+            opt(t, r, i, a), a("xhoverformat"), a("yhoverformat"), a("zorder");
+            var s = spt(t, r, i, a);
+            i.scattermode === "group" && r.orientation === void 0 && a("orientation", "v");
+            var l = !s && o < npt.PTS_LINESONLY ? "lines+markers" : "lines";
+            a("text"), a("hovertext"), a("mode", l), lT.hasMarkers(r) && lpt(t, r, n, i, a, { gradient: true }), lT.hasLines(r) && (upt(t, r, n, i, a, { backoff: true }), jde(t, r, a), a("connectgaps"), a("line.simplify")), lT.hasText(r) && (a("texttemplate"), a("texttemplatefallback"), cpt(t, r, i, a));
+            var u = [];
+            (lT.hasMarkers(r) || lT.hasText(r)) && (a("cliponaxis"), a("marker.maxdisplayed"), u.push("points")), a("fill", s ? s.fillDflt : "none"), r.fill !== "none" && (fpt(t, r, n, a, { moduleHasFillgradient: true }), lT.hasLines(r) || jde(t, r, a), hpt(a, "fillpattern", r.fillcolor, false));
+            var c = (r.line || {}).color, f = (r.marker || {}).color;
+            (r.fill === "tonext" || r.fill === "toself") && u.push("fills"), a("hoveron", u.join("+") || "points"), r.hoveron !== "fills" && (a("hovertemplate"), a("hovertemplatefallback"));
+            var h = rpt.getComponentMethod("errorbars", "supplyDefaults");
+            h(t, r, c || f || n, { axis: "y" }), h(t, r, c || f || n, { axis: "x", inherit: "y" }), Hde.coerceSelectionMarkerOpacity(r, a);
+          }
+        };
+      });
+      var e2 = ye((asr, Zde) => {
+        var dpt = Kb().getAxisGroup;
+        Zde.exports = function(t, r, n, i, a) {
+          var o = r.orientation, s = r[{ v: "x", h: "y" }[o] + "axis"], l = dpt(n, s) + o, u = n._alignmentOpts || {}, c = i("alignmentgroup"), f = u[l];
+          f || (f = u[l] = {});
+          var h = f[c];
+          h ? h.traces.push(r) : h = f[c] = { traces: [r], alignmentIndex: Object.keys(f).length, offsetGroups: {} };
+          var d = i("offsetgroup") || "", v = h.offsetGroups, _ = v[d];
+          r._offsetIndex = 0, (a !== "group" || d) && (_ || (_ = v[d] = { offsetIndex: Object.keys(v).length }), r._offsetIndex = _.offsetIndex);
+        };
+      });
+      var cU = ye((osr, Yde) => {
+        var vpt = Dr(), ppt = e2(), gpt = pf();
+        Yde.exports = function(t, r) {
+          var n, i, a, o = r.scattermode;
+          function s(h) {
+            return vpt.coerce(i._input, i, gpt, h);
+          }
+          if (r.scattermode === "group") for (a = 0; a < t.length; a++) i = t[a], i.type === "scatter" && (n = i._input, ppt(n, i, r, s, o));
+          for (a = 0; a < t.length; a++) {
+            var l = t[a];
+            if (l.type === "scatter") {
+              var u = l.fill;
+              if (!(u === "none" || u === "toself") && (l.opacity = void 0, u === "tonexty" || u === "tonextx")) for (var c = a - 1; c >= 0; c--) {
+                var f = t[c];
+                if (f.type === "scatter" && f.xaxis === l.xaxis && f.yaxis === l.yaxis) {
+                  f.opacity = void 0;
+                  break;
+                }
+              }
+            }
+          }
+        };
+      });
+      var Jde = ye((ssr, Kde) => {
+        var mpt = Dr(), ypt = tL();
+        Kde.exports = function(e, t) {
+          function r(i, a) {
+            return mpt.coerce(e, t, ypt, i, a);
+          }
+          var n = t.barmode === "group";
+          t.scattermode === "group" && r("scattergap", n ? t.bargap : 0.2);
+        };
+      });
+      var zg = ye((lsr, Qde) => {
+        var _pt = Eo(), $de = Dr(), xpt = $de.dateTime2ms, rI = $de.incrementMonth, bpt = fs(), wpt = bpt.ONEAVGMONTH;
+        Qde.exports = function(t, r, n, i) {
+          if (r.type !== "date") return { vals: i };
+          var a = t[n + "periodalignment"];
+          if (!a) return { vals: i };
+          var o = t[n + "period"], s;
+          if (_pt(o)) {
+            if (o = +o, o <= 0) return { vals: i };
+          } else if (typeof o == "string" && o.charAt(0) === "M") {
+            var l = +o.substring(1);
+            if (l > 0 && Math.round(l) === l) s = l;
+            else return { vals: i };
+          }
+          for (var u = r.calendar, c = a === "start", f = a === "end", h = t[n + "period0"], d = xpt(h, u) || 0, v = [], _ = [], b = [], p = i.length, k = 0; k < p; k++) {
+            var E = i[k], T, L, x;
+            if (s) {
+              for (T = Math.round((E - d) / (s * wpt)), x = rI(d, s * T, u); x > E; ) x = rI(x, -s, u);
+              for (; x <= E; ) x = rI(x, s, u);
+              L = rI(x, -s, u);
+            } else {
+              for (T = Math.round((E - d) / o), x = d + T * o; x > E; ) x -= o;
+              for (; x <= E; ) x += o;
+              L = x - o;
+            }
+            v[k] = c ? L : f ? x : (L + x) / 2, _[k] = L, b[k] = x;
+          }
+          return { vals: v, starts: _, ends: b };
+        };
+      });
+      var z0 = ye((usr, tve) => {
+        var fU = pv().hasColorscale, hU = gv(), eve = Ru();
+        tve.exports = function(t, r) {
+          eve.hasLines(r) && fU(r, "line") && hU(t, r, { vals: r.line.color, containerStr: "line", cLetter: "c" }), eve.hasMarkers(r) && (fU(r, "marker") && hU(t, r, { vals: r.marker.color, containerStr: "marker", cLetter: "c" }), fU(r, "marker.line") && hU(t, r, { vals: r.marker.line.color, containerStr: "marker.line", cLetter: "c" }));
+        };
+      });
+      var Rm = ye((csr, rve) => {
+        var qf = Dr();
+        rve.exports = function(t, r) {
+          for (var n = 0; n < t.length; n++) t[n].i = n;
+          qf.mergeArray(r.text, t, "tx"), qf.mergeArray(r.texttemplate, t, "txt"), qf.mergeArray(r.hovertext, t, "htx"), qf.mergeArray(r.customdata, t, "data"), qf.mergeArray(r.textposition, t, "tp"), r.textfont && (qf.mergeArrayCastPositive(r.textfont.size, t, "ts"), qf.mergeArray(r.textfont.color, t, "tc"), qf.mergeArray(r.textfont.family, t, "tf"), qf.mergeArray(r.textfont.weight, t, "tw"), qf.mergeArray(r.textfont.style, t, "ty"), qf.mergeArray(r.textfont.variant, t, "tv"), qf.mergeArray(r.textfont.textcase, t, "tC"), qf.mergeArray(r.textfont.lineposition, t, "tE"), qf.mergeArray(r.textfont.shadow, t, "tS"));
+          var i = r.marker;
+          if (i) {
+            qf.mergeArrayCastPositive(i.size, t, "ms"), qf.mergeArrayCastPositive(i.opacity, t, "mo"), qf.mergeArray(i.symbol, t, "mx"), qf.mergeArray(i.angle, t, "ma"), qf.mergeArray(i.standoff, t, "mf"), qf.mergeArray(i.color, t, "mc");
+            var a = i.line;
+            i.line && (qf.mergeArray(a.color, t, "mlc"), qf.mergeArrayCastPositive(a.width, t, "mlw"), qf.mergeArray(a.dash, t, "mld"));
+            var o = i.gradient;
+            o && o.type !== "none" && (qf.mergeArray(o.type, t, "mgt"), qf.mergeArray(o.color, t, "mgc"));
+          }
+        };
+      });
+      var O0 = ye((fsr, nve) => {
+        var ive = Dr();
+        nve.exports = function(t, r) {
+          ive.isArrayOrTypedArray(r.selectedpoints) && ive.tagSelected(t, r);
+        };
+      });
+      var q0 = ye((hsr, fve) => {
+        var ave = Eo(), vU = Dr(), n4 = ho(), ove = zg(), dU = fs().BADNUM, pU = Ru(), Tpt = z0(), Apt = Rm(), Spt = O0();
+        function Mpt(e, t) {
+          var r = e._fullLayout, n = t._xA = n4.getFromId(e, t.xaxis || "x", "x"), i = t._yA = n4.getFromId(e, t.yaxis || "y", "y"), a = n.makeCalcdata(t, "x"), o = i.makeCalcdata(t, "y"), s = ove(t, n, "x", a), l = ove(t, i, "y", o), u = s.vals, c = l.vals, f = t._length, h = new Array(f), d = t.ids, v = gU(t, r, n, i), _ = false, b, p, k, E, T, L;
+          uve(r, t);
+          var x = "x", C = "y", M;
+          if (v) vU.pushUnique(v.traceIndices, t.index), b = v.orientation === "v", b ? (C = "s", M = "x") : (x = "s", M = "y"), T = v.stackgaps === "interpolate";
+          else {
+            var g = lve(t, f);
+            sve(e, t, n, i, u, c, g);
+          }
+          var P = !!t.xperiodalignment, A = !!t.yperiodalignment;
+          for (p = 0; p < f; p++) {
+            var z = h[p] = {}, O = ave(u[p]), U = ave(c[p]);
+            O && U ? (z[x] = u[p], z[C] = c[p], P && (z.orig_x = a[p], z.xEnd = s.ends[p], z.xStart = s.starts[p]), A && (z.orig_y = o[p], z.yEnd = l.ends[p], z.yStart = l.starts[p])) : v && (b ? O : U) ? (z[M] = b ? u[p] : c[p], z.gap = true, T ? (z.s = dU, _ = true) : z.s = 0) : z[x] = z[C] = dU, d && (z.id = String(d[p]));
+          }
+          if (Apt(h, t), Tpt(e, t), Spt(h, t), v) {
+            for (p = 0; p < h.length; ) h[p][M] === dU ? h.splice(p, 1) : p++;
+            if (vU.sort(h, function(N, H) {
+              return N[M] - H[M] || N.i - H.i;
+            }), _) {
+              for (p = 0; p < h.length - 1 && h[p].gap; ) p++;
+              for (L = h[p].s, L || (L = h[p].s = 0), k = 0; k < p; k++) h[k].s = L;
+              for (E = h.length - 1; E > p && h[E].gap; ) E--;
+              for (L = h[E].s, k = h.length - 1; k > E; k--) h[k].s = L;
+              for (; p < E; ) if (p++, h[p].gap) {
+                for (k = p + 1; h[k].gap; ) k++;
+                for (var G = h[p - 1][M], Z = h[p - 1].s, j = (h[k].s - Z) / (h[k][M] - G); p < k; ) h[p].s = Z + (h[p][M] - G) * j, p++;
+              }
+            }
+          }
+          return h;
+        }
+        function sve(e, t, r, n, i, a, o) {
+          var s = t._length, l = e._fullLayout, u = r._id, c = n._id, f = l._firstScatter[cve(t)] === t.uid, h = (gU(t, l, r, n) || {}).orientation, d = t.fill;
+          r._minDtick = 0, n._minDtick = 0;
+          var v = { padded: true }, _ = { padded: true };
+          o && (v.ppad = _.ppad = o);
+          var b = s < 2 || i[0] !== i[s - 1] || a[0] !== a[s - 1];
+          b && (d === "tozerox" || d === "tonextx" && (f || h === "h")) ? v.tozero = true : !(t.error_y || {}).visible && (d === "tonexty" || d === "tozeroy" || !pU.hasMarkers(t) && !pU.hasText(t)) && (v.padded = false, v.ppad = 0), b && (d === "tozeroy" || d === "tonexty" && (f || h === "v")) ? _.tozero = true : (d === "tonextx" || d === "tozerox") && (_.padded = false), u && (t._extremes[u] = n4.findExtremes(r, i, v)), c && (t._extremes[c] = n4.findExtremes(n, a, _));
+        }
+        function lve(e, t) {
+          if (pU.hasMarkers(e)) {
+            var r = e.marker, n = 1.6 * (e.marker.sizeref || 1), i;
+            if (e.marker.sizemode === "area" ? i = function(u) {
+              return Math.max(Math.sqrt((u || 0) / n), 3);
+            } : i = function(u) {
+              return Math.max((u || 0) / n, 3);
+            }, vU.isArrayOrTypedArray(r.size)) {
+              var a = { type: "linear" };
+              n4.setConvert(a);
+              for (var o = a.makeCalcdata(e.marker, "size"), s = new Array(t), l = 0; l < t; l++) s[l] = i(o[l]);
+              return s;
+            } else return i(r.size);
+          }
+        }
+        function uve(e, t) {
+          var r = cve(t), n = e._firstScatter;
+          n[r] || (n[r] = t.uid);
+        }
+        function cve(e) {
+          var t = e.stackgroup;
+          return e.xaxis + e.yaxis + e.type + (t ? "-" + t : "");
+        }
+        function gU(e, t, r, n) {
+          var i = e.stackgroup;
+          if (i) {
+            var a = t._scatterStackOpts[r._id + n._id][i], o = a.orientation === "v" ? n : r;
+            if (o.type === "linear" || o.type === "log") return a;
+          }
+        }
+        fve.exports = { calc: Mpt, calcMarkerSize: lve, calcAxisExpansion: sve, setFirstScatter: uve, getStackOpts: gU };
+      });
+      var dve = ye((dsr, hve) => {
+        hve.exports = iI;
+        var Ept = Dr().distinctVals;
+        function iI(e, t) {
+          this.traces = e, this.sepNegVal = t.sepNegVal, this.overlapNoMerge = t.overlapNoMerge;
+          for (var r = 1 / 0, n = t.posAxis._id.charAt(0), i = [], a = 0; a < e.length; a++) {
+            for (var o = e[a], s = 0; s < o.length; s++) {
+              var l = o[s], u = l.p;
+              u === void 0 && (u = l[n]), u !== void 0 && i.push(u);
+            }
+            o[0] && o[0].width1 && (r = Math.min(o[0].width1, r));
+          }
+          this.positions = i;
+          var c = Ept(i);
+          this.distinctPositions = c.vals, c.vals.length === 1 && r !== 1 / 0 ? this.minDiff = r : this.minDiff = Math.min(c.minDiff, r);
+          var f = (t.posAxis || {}).type;
+          (f === "category" || f === "multicategory") && (this.minDiff = 1), this.binWidth = this.minDiff, this.bins = {};
+        }
+        iI.prototype.put = function(t, r, n) {
+          var i = this.getLabel(t, r, n), a = this.bins[i] || 0;
+          return this.bins[i] = a + n, a;
+        };
+        iI.prototype.get = function(t, r, n) {
+          var i = this.getLabel(t, r, n);
+          return this.bins[i] || 0;
+        };
+        iI.prototype.getLabel = function(t, r, n) {
+          var i = n < 0 && this.sepNegVal ? "v" : "^", a = this.overlapNoMerge ? t : Math.round(t / this.binWidth);
+          return i + a + "g" + r;
+        };
+      });
+      var A_ = ye((vsr, vve) => {
+        vve.exports = { TEXTPAD: 3, eventDataKeys: ["value", "label"] };
+      });
+      var t2 = ye((psr, yve) => {
+        var B0 = Eo(), { isArrayOrTypedArray: qy } = Dr(), { BADNUM: uT } = fs(), kpt = qa(), a4 = ho(), { getAxisGroup: Cpt } = Kb(), nI = dve(), { TEXTPAD: Lpt } = A_(), { LINE_SPACING: Ppt } = Dh(), { BR_TAG_ALL: Ipt } = Zl();
+        function Rpt(e, t) {
+          for (var r = t.xaxis, n = t.yaxis, i = e._fullLayout, a = e._fullData, o = e.calcdata, s = [], l = [], u = 0; u < a.length; u++) {
+            var c = a[u];
+            if (c.visible === true && kpt.traceIs(c, "bar") && c.xaxis === r._id && c.yaxis === n._id && (c.orientation === "h" ? s.push(o[u]) : l.push(o[u]), c._computePh)) for (var f = e.calcdata[u], h = 0; h < f.length; h++) typeof f[h].ph0 == "function" && (f[h].ph0 = f[h].ph0()), typeof f[h].ph1 == "function" && (f[h].ph1 = f[h].ph1());
+          }
+          var d = { xCat: r.type === "category" || r.type === "multicategory", yCat: n.type === "category" || n.type === "multicategory", mode: i.barmode, norm: i.barnorm, gap: i.bargap, groupgap: i.bargroupgap };
+          yU(e, r, n, l, d), yU(e, n, r, s, d);
+        }
+        function yU(e, t, r, n, i) {
+          if (n.length) {
+            var a, o, s, l, u;
+            switch (zpt(r, n), i.mode) {
+              case "overlay":
+                mU(e, t, r, n, i);
+                break;
+              case "group":
+                for (a = [], o = [], s = 0; s < n.length; s++) l = n[s], u = l[0].trace, u.offset === void 0 ? o.push(l) : a.push(l);
+                o.length && Opt(e, t, r, o, i), a.length && mU(e, t, r, a, i);
+                break;
+              case "stack":
+              case "relative":
+                for (a = [], o = [], s = 0; s < n.length; s++) l = n[s], u = l[0].trace, u.base === void 0 ? o.push(l) : a.push(l);
+                Fpt(o), o.length && qpt(e, t, r, o, i), a.length && mU(e, t, r, a, i);
+                break;
+            }
+            Dpt(n), Hpt(n, t);
+          }
+        }
+        function Dpt(e) {
+          var t, r, n, i, a, o, s;
+          for (t = 0; t < e.length; t++) r = e[t], n = r[0].trace, i = r[0].t, i.cornerradiusvalue === void 0 && (a = n.marker ? n.marker.cornerradius : void 0, a !== void 0 && (o = B0(a) ? +a : +a.slice(0, -1), s = B0(a) ? "px" : "%", i.cornerradiusvalue = o, i.cornerradiusform = s));
+        }
+        function Fpt(e) {
+          if (!(e.length < 2)) {
+            var t, r, n, i, a, o, s;
+            for (t = 0; t < e.length && (r = e[t], n = r[0].trace, a = n.marker ? n.marker.cornerradius : void 0, a === void 0); t++) ;
+            if (a !== void 0) for (o = B0(a) ? +a : +a.slice(0, -1), s = B0(a) ? "px" : "%", t = 0; t < e.length; t++) r = e[t], i = r[0].t, i.cornerradiusvalue = o, i.cornerradiusform = s;
+          }
+        }
+        function zpt(e, t) {
+          var r, n;
+          for (r = 0; r < t.length; r++) {
+            var i = t[r], a = i[0].trace, o = a.type === "funnel" ? a._base : a.base, s, l = a.orientation === "h" ? a.xcalendar : a.ycalendar, u = e.type === "category" || e.type === "multicategory" ? function() {
+              return null;
+            } : e.d2c;
+            if (qy(o)) {
+              for (n = 0; n < Math.min(o.length, i.length); n++) s = u(o[n], 0, l), B0(s) ? (i[n].b = +s, i[n].hasB = 1) : i[n].b = 0;
+              for (; n < i.length; n++) i[n].b = 0;
+            } else {
+              s = u(o, 0, l);
+              var c = B0(s);
+              for (s = c ? s : 0, n = 0; n < i.length; n++) i[n].b = s, c && (i[n].hasB = 1);
+            }
+          }
+        }
+        function mU(e, t, r, n, i) {
+          for (var a = 0; a < n.length; a++) {
+            var o = n[a], s = new nI([o], { posAxis: t, sepNegVal: false, overlapNoMerge: !i.norm });
+            _U(e, t, s, i), i.norm ? (mve(s), xU(r, s, i)) : gve(r, s);
+          }
+        }
+        function Opt(e, t, r, n, i) {
+          var a = new nI(n, { posAxis: t, sepNegVal: false, overlapNoMerge: !i.norm });
+          _U(e, t, a, i), Vpt(a, t), i.norm ? (mve(a), xU(r, a, i)) : gve(r, a);
+        }
+        function qpt(e, t, r, n, i) {
+          var a = new nI(n, { posAxis: t, sepNegVal: i.mode === "relative", overlapNoMerge: !(i.norm || i.mode === "stack" || i.mode === "relative") });
+          _U(e, t, a, i), Upt(r, a, i);
+          for (var o = 0; o < n.length; o++) for (var s = n[o], l = s[0].t.offsetindex, u = 0; u < s.length; u++) {
+            var c = s[u];
+            if (c.s !== uT) {
+              var f = c.b + c.s === a.get(c.p, l, c.s);
+              f && (c._outmost = true);
+            }
+          }
+          i.norm && xU(r, a, i);
+        }
+        function _U(e, t, r, n) {
+          var i = e._fullLayout, a = r.positions, o = r.distinctPositions, s = r.minDiff, l = r.traces, u = l.length, c = a.length !== o.length, f = s * (1 - n.gap), h, d, v, _;
+          if (t._id === "angularaxis") h = f, d = h * (1 - (n.groupgap || 0)), v = -d / 2;
+          else {
+            var b = Cpt(i, t._id) + l[0][0].trace.orientation;
+            _ = i._alignmentOpts[b] || {};
+          }
+          for (var p = 0; p < u; p++) {
+            var k = l[p], E = k[0].trace;
+            if (t._id !== "angularaxis") {
+              var T = _[E.alignmentgroup] || {}, L = Object.keys(T.offsetGroups || {}).length;
+              L ? h = f / L : h = c ? f / u : f, d = h * (1 - (n.groupgap || 0)), L ? v = ((2 * E._offsetIndex + 1 - L) * h - d) / 2 : v = c ? ((2 * p + 1 - u) * h - d) / 2 : -d / 2;
+            }
+            var x = k[0].t;
+            x.barwidth = d, x.offsetindex = E._offsetIndex || 0, x.poffset = v, x.bargroupwidth = f, x.bardelta = s;
+          }
+          r.binWidth = l[0][0].t.barwidth / 100, Bpt(r), Npt(t, r), t._id === "angularaxis" ? pve(t, r) : pve(t, r, c);
+        }
+        function Bpt(e) {
+          var t = e.traces, r, n;
+          for (r = 0; r < t.length; r++) {
+            var i = t[r], a = i[0], o = a.trace, s = a.t, l = o._offset || o.offset, u = s.poffset, c;
+            if (qy(l)) {
+              for (c = Array.prototype.slice.call(l, 0, i.length), n = 0; n < c.length; n++) B0(c[n]) || (c[n] = u);
+              for (n = c.length; n < i.length; n++) c.push(u);
+              s.poffset = c;
+            } else l !== void 0 && (s.poffset = l);
+            var f = o._width || o.width, h = s.barwidth;
+            if (qy(f)) {
+              var d = Array.prototype.slice.call(f, 0, i.length);
+              for (n = 0; n < d.length; n++) B0(d[n]) || (d[n] = h);
+              for (n = d.length; n < i.length; n++) d.push(h);
+              if (s.barwidth = d, l === void 0) {
+                for (c = [], n = 0; n < i.length; n++) c.push(u + (h - d[n]) / 2);
+                s.poffset = c;
+              }
+            } else f !== void 0 && (s.barwidth = f, l === void 0 && (s.poffset = u + (h - f) / 2));
+          }
+        }
+        function Npt(e, t) {
+          for (var r = t.traces, n = cT(e), i = 0; i < r.length; i++) for (var a = r[i], o = a[0].t, s = o.poffset, l = qy(s), u = o.barwidth, c = qy(u), f = 0; f < a.length; f++) {
+            var h = a[f], d = h.w = c ? u[f] : u;
+            h.p === void 0 && (h.p = h[n], h["orig_" + n] = h[n]);
+            var v = (l ? s[f] : s) + d / 2;
+            h[n] = h.p + v;
+          }
+        }
+        function pve(e, t, r) {
+          var n = t.traces, i = t.minDiff, a = i / 2;
+          a4.minDtick(e, t.minDiff, t.distinctPositions[0], r);
+          for (var o = 0; o < n.length; o++) {
+            var s = n[o], l = s[0], u = l.trace, c = [], f, h, d, v;
+            for (v = 0; v < s.length; v++) f = s[v], h = f.p - a, d = f.p + a, c.push(h, d);
+            if (u.width || u.offset) {
+              var _ = l.t, b = _.poffset, p = _.barwidth, k = qy(b), E = qy(p);
+              for (v = 0; v < s.length; v++) {
+                f = s[v];
+                var T = k ? b[v] : b, L = E ? p[v] : p;
+                h = f.p + T, d = h + L, c.push(h, d);
+              }
+            }
+            u._extremes[e._id] = a4.findExtremes(e, c, { padded: false });
+          }
+        }
+        function gve(e, t) {
+          for (var r = t.traces, n = cT(e), i = 0; i < r.length; i++) {
+            for (var a = r[i], o = a[0].trace, s = o.type === "scatter", l = o.orientation === "v", u = [], c = false, f = 0; f < a.length; f++) {
+              var h = a[f], d = s ? 0 : h.b, v = s ? l ? h.y : h.x : d + h.s;
+              h[n] = v, u.push(v), h.hasB && u.push(d), (!h.hasB || !h.b) && (c = true);
+            }
+            let { ppadminus: _, ppadplus: b } = bU(o, a);
+            o._extremes[e._id] = a4.findExtremes(e, u, { tozero: c, padded: true, ppadplus: b, ppadminus: _ });
+          }
+        }
+        function Upt(e, t, r) {
+          var n = cT(e), i = t.traces, a, o, s, l, u, c, f;
+          for (l = 0; l < i.length; l++) if (a = i[l], o = a[0].trace, o.type === "funnel") for (f = a[0].t.offsetindex, u = 0; u < a.length; u++) c = a[u], c.s !== uT && t.put(c.p, f, -0.5 * c.s);
+          for (l = 0; l < i.length; l++) {
+            a = i[l], o = a[0].trace, s = o.type === "funnel", f = o.type === "barpolar" ? 0 : a[0].t.offsetindex;
+            var h = [];
+            for (u = 0; u < a.length; u++) if (c = a[u], c.s !== uT) {
+              var d;
+              s ? d = c.s : d = c.s + c.b;
+              var v = t.put(c.p, f, d), _ = v + d;
+              c.b = v, c[n] = _, r.norm || (h.push(_), c.hasB && h.push(v));
+            }
+            if (!r.norm) {
+              let { ppadminus: b, ppadplus: p } = bU(o, a);
+              o._extremes[e._id] = a4.findExtremes(e, h, { tozero: true, padded: true, ppadplus: p, ppadminus: b });
+            }
+          }
+        }
+        function mve(e) {
+          for (var t = e.traces, r = 0; r < t.length; r++) for (var n = t[r], i = n[0].t.offsetindex, a = 0; a < n.length; a++) {
+            var o = n[a];
+            o.s !== uT && e.put(o.p, i, o.b + o.s);
+          }
+        }
+        function Vpt(e, t) {
+          for (var r = e.traces, n = 0; n < r.length; n++) {
+            var i = r[n], a = i[0].trace, o = i[0].t.offsetindex;
+            if (a.base === void 0) for (var s = new nI([i], { posAxis: t, sepNegVal: true, overlapNoMerge: true }), l = 0; l < i.length; l++) {
+              var u = i[l];
+              if (u.p !== uT) {
+                var c = s.put(u.p, o, u.b + u.s);
+                c && (u.b = c);
+              }
+            }
+          }
+        }
+        function xU(e, t, r) {
+          var n = t.traces, i = cT(e), a = r.norm === "fraction" ? 1 : 100, o = a / 1e9, s = e.l2c(e.c2l(0)), l = r.mode === "stack" ? a : s;
+          function u(x) {
+            return B0(e.c2l(x)) && (x < s - o || x > l + o || !B0(s));
+          }
+          for (var c = 0; c < n.length; c++) {
+            for (var f = n[c], h = f[0].t.offsetindex, d = f[0].trace, v = [], _ = false, b = false, p = 0; p < f.length; p++) {
+              var k = f[p];
+              if (k.s !== uT) {
+                var E = Math.abs(a / t.get(k.p, h, k.s));
+                k.b *= E, k.s *= E;
+                var T = k.b, L = T + k.s;
+                k[i] = L, v.push(L), b = b || u(L), k.hasB && (v.push(T), b = b || u(T)), (!k.hasB || !k.b) && (_ = true);
+              }
+            }
+            let { ppadminus: x, ppadplus: C } = bU(d, f);
+            d._extremes[e._id] = a4.findExtremes(e, v, { tozero: _, padded: b, ppadplus: C, ppadminus: x });
+          }
+        }
+        function bU(e, t) {
+          if (e.orientation === "v" && (e.text || e.texttemplate) && e.textposition === "outside" && (e.textangle === "auto" || e.textangle === 0)) {
+            let n = function(a) {
+              return !a || typeof a != "string" ? 0 : (a.match(Ipt) || []).length + 1;
+            };
+            var r;
+            e.texttemplate ? r = n(e.texttemplate) : r = qy(e.text) ? Math.max(...e.text.map((a) => n(a))) : n(e.text);
+            let i = e.outsidetextfont.size * Ppt * r + Lpt;
+            return { ppadplus: t.some((a) => a.s < 0) ? i : 0, ppadminus: t.some((a) => a.s >= 0) ? i : 0 };
+          }
+          return { ppadplus: void 0, ppadminus: void 0 };
+        }
+        function Gpt(e, t, r, n) {
+          for (var i = cT(n), a = 0; a < e.length; a++) for (var o = e[a], s = 0; s < o.length; s++) {
+            var l = o[s], u = l[i];
+            l._sMin = t[u], l._sMax = r[u];
+          }
+        }
+        function Hpt(e, t) {
+          var r = cT(t), n = {}, i, a, o, s = 1 / 0, l = -1 / 0;
+          for (i = 0; i < e.length; i++) for (o = e[i], a = 0; a < o.length; a++) {
+            var u = o[a].p;
+            B0(u) && (s = Math.min(s, u), l = Math.max(l, u));
+          }
+          var c = 1e4 / (l - s), f = n.round = function(M) {
+            return String(Math.round(c * (M - s)));
+          }, h = {}, d = {}, v = e.some(function(M) {
+            var g = M[0].trace;
+            return "marker" in g && g.marker.cornerradius;
+          });
+          for (i = 0; i < e.length; i++) {
+            o = e[i], o[0].t.extents = n;
+            var _ = o[0].t.poffset, b = qy(_);
+            for (a = 0; a < o.length; a++) {
+              var p = o[a], k = p[r] - p.w / 2;
+              if (B0(k)) {
+                var E = p[r] + p.w / 2, T = f(p.p);
+                n[T] ? n[T] = [Math.min(k, n[T][0]), Math.max(E, n[T][1])] : n[T] = [k, E];
+              }
+              if (p.p0 = p.p + (b ? _[a] : _), p.p1 = p.p0 + p.w, p.s0 = p.b, p.s1 = p.s0 + p.s, v) {
+                var L = Math.min(p.s0, p.s1) || 0, x = Math.max(p.s0, p.s1) || 0, C = p[r];
+                h[C] = C in h ? Math.min(h[C], L) : L, d[C] = C in d ? Math.max(d[C], x) : x;
+              }
+            }
+          }
+          v && Gpt(e, h, d, t);
+        }
+        function cT(e) {
+          return e._id.charAt(0);
+        }
+        yve.exports = { crossTraceCalc: Rpt, setGroupPositions: yU };
+      });
+      var wve = ye((gsr, bve) => {
+        var _ve = q0(), xve = t2().setGroupPositions;
+        function jpt(e, t) {
+          for (var r = t.xaxis, n = t.yaxis, i = e._fullLayout, a = e._fullData, o = e.calcdata, s = [], l = [], u = 0; u < a.length; u++) {
+            var c = a[u];
+            c.visible === true && c.type === "scatter" && c.xaxis === r._id && c.yaxis === n._id && (c.orientation === "h" ? s.push(o[u]) : c.orientation === "v" && l.push(o[u]));
+          }
+          var f = { mode: i.scattermode, gap: i.scattergap };
+          xve(e, r, n, l, f), xve(e, n, r, s, f);
+        }
+        bve.exports = function(t, r) {
+          t._fullLayout.scattermode === "group" && jpt(t, r);
+          var n = r.xaxis, i = r.yaxis, a = n._id + i._id, o = t._fullLayout._scatterStackOpts[a];
+          if (o) {
+            var s = t.calcdata, l, u, c, f, h, d, v, _, b, p, k, E, T, L, x;
+            for (var C in o) {
+              p = o[C];
+              var M = p.traceIndices;
+              if (M.length) {
+                for (k = p.stackgaps === "interpolate", E = p.groupnorm, p.orientation === "v" ? (T = "x", L = "y") : (T = "y", L = "x"), x = new Array(M.length), l = 0; l < x.length; l++) x[l] = false;
+                d = s[M[0]];
+                var g = new Array(d.length);
+                for (l = 0; l < d.length; l++) g[l] = d[l][T];
+                for (l = 1; l < M.length; l++) {
+                  for (h = s[M[l]], u = c = 0; u < h.length; u++) {
+                    for (v = h[u][T]; v > g[c] && c < g.length; c++) wU(h, u, g[c], l, x, k, T), u++;
+                    if (v !== g[c]) {
+                      for (f = 0; f < l; f++) wU(s[M[f]], c, v, f, x, k, T);
+                      g.splice(c, 0, v);
+                    }
+                    c++;
+                  }
+                  for (; c < g.length; c++) wU(h, u, g[c], l, x, k, T), u++;
+                }
+                var P = g.length;
+                for (u = 0; u < d.length; u++) {
+                  for (_ = d[u][L] = d[u].s, l = 1; l < M.length; l++) h = s[M[l]], h[0].trace._rawLength = h[0].trace._length, h[0].trace._length = P, _ += h[u].s, h[u][L] = _;
+                  if (E) for (b = (E === "fraction" ? _ : _ / 100) || 1, l = 0; l < M.length; l++) {
+                    var A = s[M[l]][u];
+                    A[L] /= b, A.sNorm = A.s / b;
+                  }
+                }
+                for (l = 0; l < M.length; l++) {
+                  h = s[M[l]];
+                  var z = h[0].trace, O = _ve.calcMarkerSize(z, z._rawLength), U = Array.isArray(O);
+                  if (O && x[l] || U) {
+                    var G = O;
+                    for (O = new Array(P), u = 0; u < P; u++) O[u] = h[u].gap ? 0 : U ? G[h[u].i] : G;
+                  }
+                  var Z = new Array(P), j = new Array(P);
+                  for (u = 0; u < P; u++) Z[u] = h[u].x, j[u] = h[u].y;
+                  _ve.calcAxisExpansion(t, z, n, i, Z, j, O), h[0].t.orientation = p.orientation;
+                }
+              }
+            }
+          }
+        };
+        function wU(e, t, r, n, i, a, o) {
+          i[n] = true;
+          var s = { i: null, gap: true, s: 0 };
+          if (s[o] = r, e.splice(t, 0, s), t && r === e[t - 1][o]) {
+            var l = e[t - 1];
+            s.s = l.s, s.i = l.i, s.gap = l.gap;
+          } else a && (s.s = Wpt(e, t, r, o));
+          t || (e[0].t = e[1].t, e[0].trace = e[1].trace, delete e[1].t, delete e[1].trace);
+        }
+        function Wpt(e, t, r, n) {
+          var i = e[t - 1], a = e[t + 1];
+          return a ? i ? i.s + (a.s - i.s) * (r - i[n]) / (a[n] - i[n]) : a.s : i.s;
+        }
+      });
+      var AU = ye((msr, kve) => {
+        var Xpt = So(), Mve = fs(), o4 = Mve.BADNUM, Eve = Mve.LOG_CLIP, Tve = Eve + 0.5, Ave = Eve - 0.5, aI = Dr(), Zpt = aI.segmentsIntersect, Sve = aI.constrain, TU = Lm();
+        kve.exports = function(t, r) {
+          var n = r.trace || {}, i = r.xaxis, a = r.yaxis, o = i.type === "log", s = a.type === "log", l = i._length, u = a._length, c = r.backoff, f = n.marker, h = r.connectGaps, d = r.baseTolerance, v = r.shape, _ = v === "linear", b = n.fill && n.fill !== "none", p = [], k = TU.minTolerance, E = t.length, T = new Array(E), L = 0, x, C, M, g, P, A, z, O, U, G, Z, j, N, H, re, oe;
+          function _e(dt) {
+            var Ge = t[dt];
+            if (!Ge) return false;
+            var Je = r.linearized ? i.l2p(Ge.x) : i.c2p(Ge.x), We = r.linearized ? a.l2p(Ge.y) : a.c2p(Ge.y);
+            if (Je === o4) {
+              if (o && (Je = i.c2p(Ge.x, true)), Je === o4) return false;
+              s && We === o4 && (Je *= Math.abs(i._m * u * (i._m > 0 ? Tve : Ave) / (a._m * l * (a._m > 0 ? Tve : Ave)))), Je *= 1e3;
+            }
+            if (We === o4) {
+              if (s && (We = a.c2p(Ge.y, true)), We === o4) return false;
+              We *= 1e3;
+            }
+            return [Je, We];
+          }
+          function Ce(dt, Ge, Je, We) {
+            var tt = Je - dt, xt = We - Ge, Ie = 0.5 - dt, xe = 0.5 - Ge, ke = tt * tt + xt * xt, vt = tt * Ie + xt * xe;
+            if (vt > 0 && vt < ke) {
+              var ir = Ie * xt - xe * tt;
+              if (ir * ir < ke) return true;
+            }
+          }
+          var Le, ge;
+          function ie(dt, Ge) {
+            var Je = dt[0] / l, We = dt[1] / u, tt = Math.max(0, -Je, Je - 1, -We, We - 1);
+            return tt && Le !== void 0 && Ce(Je, We, Le, ge) && (tt = 0), tt && Ge && Ce(Je, We, Ge[0] / l, Ge[1] / u) && (tt = 0), (1 + TU.toleranceGrowth * tt) * d;
+          }
+          function Se(dt, Ge) {
+            var Je = dt[0] - Ge[0], We = dt[1] - Ge[1];
+            return Math.sqrt(Je * Je + We * We);
+          }
+          var Ee = TU.maxScreensAway, Ae = -l * Ee, Be = l * (1 + Ee), Pe = -u * Ee, me = u * (1 + Ee), De = [[Ae, Pe, Be, Pe], [Be, Pe, Be, me], [Be, me, Ae, me], [Ae, me, Ae, Pe]], ce, je, lt, pt, Vt, ot;
+          function ut(dt, Ge) {
+            for (var Je = [], We = 0, tt = 0; tt < 4; tt++) {
+              var xt = De[tt], Ie = Zpt(dt[0], dt[1], Ge[0], Ge[1], xt[0], xt[1], xt[2], xt[3]);
+              Ie && (!We || Math.abs(Ie.x - Je[0][0]) > 1 || Math.abs(Ie.y - Je[0][1]) > 1) && (Ie = [Ie.x, Ie.y], We && Se(Ie, dt) < Se(Je[0], dt) ? Je.unshift(Ie) : Je.push(Ie), We++);
+            }
+            return Je;
+          }
+          function Wt(dt) {
+            if (dt[0] < Ae || dt[0] > Be || dt[1] < Pe || dt[1] > me) return [Sve(dt[0], Ae, Be), Sve(dt[1], Pe, me)];
+          }
+          function Nt(dt, Ge) {
+            if (dt[0] === Ge[0] && (dt[0] === Ae || dt[0] === Be) || dt[1] === Ge[1] && (dt[1] === Pe || dt[1] === me)) return true;
+          }
+          function $t(dt, Ge) {
+            var Je = [], We = Wt(dt), tt = Wt(Ge);
+            return We && tt && Nt(We, tt) || (We && Je.push(We), tt && Je.push(tt)), Je;
+          }
+          function sr(dt, Ge, Je) {
+            return function(We, tt) {
+              var xt = Wt(We), Ie = Wt(tt), xe = [];
+              if (xt && Ie && Nt(xt, Ie)) return xe;
+              xt && xe.push(xt), Ie && xe.push(Ie);
+              var ke = 2 * aI.constrain((We[dt] + tt[dt]) / 2, Ge, Je) - ((xt || We)[dt] + (Ie || tt)[dt]);
+              if (ke) {
+                var vt;
+                xt && Ie ? vt = ke > 0 == xt[dt] > Ie[dt] ? xt : Ie : vt = xt || Ie, vt[dt] += ke;
+              }
+              return xe;
+            };
+          }
+          var Tr;
+          v === "linear" || v === "spline" ? Tr = ut : v === "hv" || v === "vh" ? Tr = $t : v === "hvh" ? Tr = sr(0, Ae, Be) : v === "vhv" && (Tr = sr(1, Pe, me));
+          function fr(dt, Ge) {
+            var Je = Ge[0] - dt[0], We = (Ge[1] - dt[1]) / Je, tt = (dt[1] * Ge[0] - Ge[1] * dt[0]) / Je;
+            return tt > 0 ? [We > 0 ? Ae : Be, me] : [We > 0 ? Be : Ae, Pe];
+          }
+          function $e(dt) {
+            var Ge = dt[0], Je = dt[1], We = Ge === T[L - 1][0], tt = Je === T[L - 1][1];
+            if (!(We && tt)) if (L > 1) {
+              var xt = Ge === T[L - 2][0], Ie = Je === T[L - 2][1];
+              We && (Ge === Ae || Ge === Be) && xt ? Ie ? L-- : T[L - 1] = dt : tt && (Je === Pe || Je === me) && Ie ? xt ? L-- : T[L - 1] = dt : T[L++] = dt;
+            } else T[L++] = dt;
+          }
+          function St(dt) {
+            T[L - 1][0] !== dt[0] && T[L - 1][1] !== dt[1] && $e([lt, pt]), $e(dt), Vt = null, lt = pt = 0;
+          }
+          var Qt = aI.isArrayOrTypedArray(f);
+          function Gt(dt) {
+            if (dt && c && (dt.i = x, dt.d = t, dt.trace = n, dt.marker = Qt ? f[dt.i] : f, dt.backoff = c), Le = dt[0] / l, ge = dt[1] / u, ce = dt[0] < Ae ? Ae : dt[0] > Be ? Be : 0, je = dt[1] < Pe ? Pe : dt[1] > me ? me : 0, ce || je) {
+              if (!L) T[L++] = [ce || dt[0], je || dt[1]];
+              else if (Vt) {
+                var Ge = Tr(Vt, dt);
+                Ge.length > 1 && (St(Ge[0]), T[L++] = Ge[1]);
+              } else ot = Tr(T[L - 1], dt)[0], T[L++] = ot;
+              var Je = T[L - 1];
+              ce && je && (Je[0] !== ce || Je[1] !== je) ? (Vt && (lt !== ce && pt !== je ? $e(lt && pt ? fr(Vt, dt) : [lt || ce, pt || je]) : lt && pt && $e([lt, pt])), $e([ce, je])) : lt - ce && pt - je && $e([ce || lt, je || pt]), Vt = dt, lt = ce, pt = je;
+            } else Vt && St(Tr(Vt, dt)[0]), T[L++] = dt;
+          }
+          for (x = 0; x < E; x++) if (C = _e(x), !!C) {
+            for (L = 0, Vt = null, Gt(C), x++; x < E; x++) {
+              if (g = _e(x), !g) {
+                if (h) continue;
+                break;
+              }
+              if (!_ || !r.simplify) {
+                Gt(g);
+                continue;
+              }
+              var _t = _e(x + 1);
+              if (G = Se(g, C), !(!(b && (L === 0 || L === E - 1)) && G < ie(g, _t) * k)) {
+                for (O = [(g[0] - C[0]) / G, (g[1] - C[1]) / G], P = C, Z = G, j = H = re = 0, z = false, M = g, x++; x < t.length; x++) {
+                  if (A = _t, _t = _e(x + 1), !A) {
+                    if (h) continue;
+                    break;
+                  }
+                  if (U = [A[0] - C[0], A[1] - C[1]], oe = U[0] * O[1] - U[1] * O[0], H = Math.min(H, oe), re = Math.max(re, oe), re - H > ie(A, _t)) break;
+                  M = A, N = U[0] * O[0] + U[1] * O[1], N > Z ? (Z = N, g = A, z = false) : N < j && (j = N, P = A, z = true);
+                }
+                if (z ? (Gt(g), M !== P && Gt(P)) : (P !== C && Gt(P), M !== g && Gt(g)), Gt(M), x >= t.length || !A) break;
+                Gt(A), C = A;
+              }
+            }
+            Vt && $e([lt || Vt[0], pt || Vt[1]]), p.push(T.slice(0, L));
+          }
+          var It = v.slice(v.length - 1);
+          if (c && It !== "h" && It !== "v") {
+            for (var mt = false, er = -1, lr = [], wr = 0; wr < p.length; wr++) for (var Lr = 0; Lr < p[wr].length - 1; Lr++) {
+              var ti = p[wr][Lr], Br = p[wr][Lr + 1], Vr = Xpt.applyBackoff(Br, ti);
+              (Vr[0] !== Br[0] || Vr[1] !== Br[1]) && (mt = true), lr[er + 1] || (er++, lr[er] = [ti, [Vr[0], Vr[1]]]);
+            }
+            return mt ? lr : p;
+          }
+          return p;
+        };
+      });
+      var SU = ye((ysr, Lve) => {
+        var Cve = { tonextx: 1, tonexty: 1, tonext: 1 };
+        Lve.exports = function(t, r, n) {
+          var i, a, o, s, l, u = {}, c = false, f = -1, h = 0, d = -1;
+          for (a = 0; a < n.length; a++) i = n[a][0].trace, o = i.stackgroup || "", o ? o in u ? l = u[o] : (l = u[o] = h, h++) : i.fill in Cve && d >= 0 ? l = d : (l = d = h, h++), l < f && (c = true), i._groupIndex = f = l;
+          var v = n.slice();
+          c && v.sort(function(b, p) {
+            var k = b[0].trace, E = p[0].trace;
+            return k._groupIndex - E._groupIndex || k.index - E.index;
+          });
+          var _ = {};
+          for (a = 0; a < v.length; a++) i = v[a][0].trace, o = i.stackgroup || "", i.visible === true ? (i._nexttrace = null, i.fill in Cve && (s = _[o], i._prevtrace = s || null, s && (s._nexttrace = i)), i._ownfill = i.fill && (i.fill.slice(0, 6) === "tozero" || i.fill === "toself" || i.fill.slice(0, 2) === "to" && !i._prevtrace), _[o] = i) : i._prevtrace = i._nexttrace = i._ownfill = null;
+          return v;
+        };
+      });
+      var dT = ye((_sr, Rve) => {
+        var Og = Oa(), Ypt = qa(), s4 = Dr(), fT = s4.ensureSingle, Ive = s4.identity, Kf = So(), hT = Ru(), Kpt = AU(), Jpt = SU(), oI = FM().tester;
+        Rve.exports = function(t, r, n, i, a, o) {
+          var s, l, u = !a, c = !!a && a.duration > 0, f = Jpt(t, r, n);
+          if (s = i.selectAll("g.trace").data(f, function(d) {
+            return d[0].trace.uid;
+          }), s.enter().append("g").attr("class", function(d) {
+            return "trace scatter trace" + d[0].trace.uid;
+          }).style("stroke-miterlimit", 2), s.order(), $pt(t, s, r), c) {
+            o && (l = o());
+            var h = Og.transition().duration(a.duration).ease(a.easing).each("end", function() {
+              l && l();
+            }).each("interrupt", function() {
+              l && l();
+            });
+            h.each(function() {
+              i.selectAll("g.trace").each(function(d, v) {
+                Pve(t, v, r, d, f, this, a);
+              });
+            });
+          } else s.each(function(d, v) {
+            Pve(t, v, r, d, f, this, a);
+          });
+          u && s.exit().remove(), i.selectAll("path:not([d])").remove();
+        };
+        function $pt(e, t, r) {
+          t.each(function(n) {
+            var i = fT(Og.select(this), "g", "fills");
+            Kf.setClipUrl(i, r.layerClipId, e);
+            var a = n[0].trace;
+            a._ownFill = null, a._nextFill = null;
+            var o = [];
+            a._ownfill && o.push("_ownFill"), a._nexttrace && o.push("_nextFill");
+            var s = i.selectAll("g").data(o, Ive);
+            s.enter().append("g"), s.exit().remove(), s.order().each(function(l) {
+              a[l] = fT(Og.select(this), "path", "js-fill");
+            });
+          });
+        }
+        function Pve(e, t, r, n, i, a, o) {
+          var s = e._context.staticPlot, l;
+          Qpt(e, t, r, n, i);
+          var u = !!o && o.duration > 0;
+          function c(sr) {
+            return u ? sr.transition() : sr;
+          }
+          var f = r.xaxis, h = r.yaxis, d = n[0].trace, v = d.line, _ = Og.select(a), b = fT(_, "g", "errorbars"), p = fT(_, "g", "lines"), k = fT(_, "g", "points"), E = fT(_, "g", "text");
+          if (Ypt.getComponentMethod("errorbars", "plot")(e, b, r, o), d.visible !== true) return;
+          c(_).style("opacity", d.opacity);
+          var T, L, x = d.fill.charAt(d.fill.length - 1);
+          x !== "x" && x !== "y" && (x = "");
+          var C, M;
+          x === "y" ? (C = 1, M = h.c2p(0, true)) : x === "x" && (C = 0, M = f.c2p(0, true)), n[0][r.isRangePlot ? "nodeRangePlot3" : "node3"] = _;
+          var g = "", P = [], A = d._prevtrace, z = null, O = null;
+          A && (g = A._prevRevpath || "", L = A._nextFill, P = A._ownPolygons, z = A._fillsegments, O = A._fillElement);
+          var U, G, Z = "", j = "", N, H, re, oe, _e, Ce, Le = [];
+          d._polygons = [];
+          var ge = [], ie = [], Se = s4.noop;
+          if (T = d._ownFill, hT.hasLines(d) || d.fill !== "none") {
+            L && L.datum(n), ["hv", "vh", "hvh", "vhv"].indexOf(v.shape) !== -1 ? (N = Kf.steps(v.shape), H = Kf.steps(v.shape.split("").reverse().join(""))) : v.shape === "spline" ? N = H = function(sr) {
+              var Tr = sr[sr.length - 1];
+              return sr.length > 1 && sr[0][0] === Tr[0] && sr[0][1] === Tr[1] ? Kf.smoothclosed(sr.slice(1), v.smoothing) : Kf.smoothopen(sr, v.smoothing);
+            } : N = H = function(sr) {
+              return "M" + sr.join("L");
+            }, re = function(sr) {
+              return H(sr.reverse());
+            }, ie = Kpt(n, { xaxis: f, yaxis: h, trace: d, connectGaps: d.connectgaps, baseTolerance: Math.max(v.width || 1, 3) / 4, shape: v.shape, backoff: v.backoff, simplify: v.simplify, fill: d.fill }), ge = new Array(ie.length);
+            var Ee = 0;
+            for (l = 0; l < ie.length; l++) {
+              var Ae, Be = ie[l];
+              !Ae || !x ? (Ae = Be.slice(), ge[Ee] = Ae, Ee++) : Ae.push.apply(Ae, Be);
+            }
+            d._fillElement = null, d._fillExclusionElement = O, d._fillsegments = ge.slice(0, Ee), ge = d._fillsegments, ie.length && (oe = ie[0][0].slice(), _e = ie[ie.length - 1], Ce = _e[_e.length - 1].slice()), Se = function(sr) {
+              return function(Tr) {
+                if (U = N(Tr), G = re(Tr), Z ? x ? (Z += "L" + U.slice(1), j = G + ("L" + j.slice(1))) : (Z += "Z" + U, j = G + "Z" + j) : (Z = U, j = G), hT.hasLines(d)) {
+                  var fr = Og.select(this);
+                  if (fr.datum(n), sr) c(fr.style("opacity", 0).attr("d", U).call(Kf.lineGroupStyle)).style("opacity", 1);
+                  else {
+                    var $e = c(fr);
+                    $e.attr("d", U), Kf.singleLineStyle(n, $e);
+                  }
+                }
+              };
+            };
+          }
+          var Pe = p.selectAll(".js-line").data(ie);
+          c(Pe.exit()).style("opacity", 0).remove(), Pe.each(Se(false)), Pe.enter().append("path").classed("js-line", true).style("vector-effect", s ? "none" : "non-scaling-stroke").call(Kf.lineGroupStyle).each(Se(true)), Kf.setClipUrl(Pe, r.layerClipId, e);
+          function me(sr) {
+            c(sr).attr("d", "M0,0Z");
+          }
+          var De = function() {
+            var sr = new Array(ge.length);
+            for (l = 0; l < ge.length; l++) sr[l] = oI(ge[l]);
+            return sr;
+          }, ce = function(sr) {
+            var Tr, fr;
+            if (!sr || sr.length === 0) for (Tr = new Array(ge.length), fr = 0; fr < ge.length; fr++) {
+              var $e = ge[fr][0].slice(), St = ge[fr][ge[fr].length - 1].slice();
+              $e[C] = St[C] = M;
+              var Qt = [St, $e], Gt = Qt.concat(ge[fr]);
+              Tr[fr] = oI(Gt);
+            }
+            else {
+              for (Tr = new Array(sr.length - 1 + ge.length), fr = 0; fr < sr.length - 1; fr++) Tr[fr] = oI(sr[fr]);
+              var _t = sr[sr.length - 1].slice();
+              for (_t.reverse(), fr = 0; fr < ge.length; fr++) Tr[sr.length - 1 + fr] = oI(ge[fr].concat(_t));
+            }
+            return Tr;
+          };
+          ie.length ? (T ? (T.datum(n), oe && Ce && (x ? (oe[C] = Ce[C] = M, c(T).attr("d", "M" + Ce + "L" + oe + "L" + Z.slice(1)).call(Kf.singleFillStyle, e), Le = ce(null)) : (c(T).attr("d", Z + "Z").call(Kf.singleFillStyle, e), Le = De())), d._polygons = Le, d._fillElement = T) : L && (d.fill.slice(0, 6) === "tonext" && Z && g ? (d.fill === "tonext" ? (c(L).attr("d", Z + "Z" + g + "Z").call(Kf.singleFillStyle, e), Le = De(), d._polygons = Le.concat(P)) : (c(L).attr("d", Z + "L" + g.slice(1) + "Z").call(Kf.singleFillStyle, e), Le = ce(z), d._polygons = Le), d._fillElement = L) : me(L)), d._prevRevpath = j) : (T ? me(T) : L && me(L), d._prevRevpath = null), d._ownPolygons = Le;
+          function je(sr) {
+            return sr.filter(function(Tr) {
+              return !Tr.gap && Tr.vis;
+            });
+          }
+          function lt(sr) {
+            return sr.filter(function(Tr) {
+              return Tr.vis;
+            });
+          }
+          function pt(sr) {
+            return sr.filter(function(Tr) {
+              return !Tr.gap;
+            });
+          }
+          function Vt(sr) {
+            return sr.id;
+          }
+          function ot(sr) {
+            if (sr.ids) return Vt;
+          }
+          function ut() {
+            return false;
+          }
+          function Wt(sr, Tr, fr) {
+            var $e, St, Qt, Gt = fr[0].trace, _t = hT.hasMarkers(Gt), It = hT.hasText(Gt), mt = ot(Gt), er = ut, lr = ut;
+            if (_t || It) {
+              var wr = Ive, Lr = Gt.stackgroup, ti = Lr && e._fullLayout._scatterStackOpts[f._id + h._id][Lr].stackgaps === "infer zero";
+              Gt.marker.maxdisplayed || Gt._needsCull ? wr = ti ? lt : je : Lr && !ti && (wr = pt), _t && (er = wr), It && (lr = wr);
+            }
+            St = sr.selectAll("path.point"), $e = St.data(er, mt);
+            var Br = $e.enter().append("path").classed("point", true);
+            u && Br.call(Kf.pointStyle, Gt, e).call(Kf.translatePoints, f, h).style("opacity", 0).transition().style("opacity", 1), $e.order();
+            var Vr;
+            _t && (Vr = Kf.makePointStyleFns(Gt)), $e.each(function(dt) {
+              var Ge = Og.select(this), Je = c(Ge);
+              Qt = Kf.translatePoint(dt, Je, f, h), Qt ? (Kf.singlePointStyle(dt, Je, Gt, Vr, e), r.layerClipId && Kf.hideOutsideRangePoint(dt, Je, f, h, Gt.xcalendar, Gt.ycalendar), Gt.customdata && Ge.classed("plotly-customdata", dt.data !== null && dt.data !== void 0)) : Je.remove();
+            }), u ? $e.exit().transition().style("opacity", 0).remove() : $e.exit().remove(), St = Tr.selectAll("g"), $e = St.data(lr, mt), $e.enter().append("g").classed("textpoint", true).append("text"), $e.order(), $e.each(function(dt) {
+              var Ge = Og.select(this), Je = c(Ge.select("text"));
+              Qt = Kf.translatePoint(dt, Je, f, h), Qt ? r.layerClipId && Kf.hideOutsideRangePoint(dt, Ge, f, h, Gt.xcalendar, Gt.ycalendar) : Ge.remove();
+            }), $e.selectAll("text").call(Kf.textPointStyle, Gt, e).each(function(dt) {
+              var Ge = f.c2p(dt.x), Je = h.c2p(dt.y);
+              Og.select(this).selectAll("tspan.line").each(function() {
+                c(Og.select(this)).attr({ x: Ge, y: Je });
+              });
+            }), $e.exit().remove();
+          }
+          k.datum(n), E.datum(n), Wt(k, E, n);
+          var Nt = d.cliponaxis === false, $t = Nt ? null : r.layerClipId;
+          Kf.setClipUrl(k, $t, e), Kf.setClipUrl(E, $t, e);
+        }
+        function Qpt(e, t, r, n, i) {
+          var a = r.xaxis, o = r.yaxis, s = Og.extent(s4.simpleMap(a.range, a.r2c)), l = Og.extent(s4.simpleMap(o.range, o.r2c)), u = n[0].trace;
+          if (hT.hasMarkers(u)) {
+            var c = u.marker.maxdisplayed;
+            if (c !== 0) {
+              var f = n.filter(function(_) {
+                return _.x >= s[0] && _.x <= s[1] && _.y >= l[0] && _.y <= l[1];
+              }), h = Math.ceil(f.length / c), d = 0;
+              i.forEach(function(_, b) {
+                var p = _[0].trace;
+                hT.hasMarkers(p) && p.marker.maxdisplayed > 0 && b < t && d++;
+              });
+              var v = Math.round(d * h / 3 + Math.floor(d / 3) * h / 7.1);
+              n.forEach(function(_) {
+                delete _.vis;
+              }), f.forEach(function(_, b) {
+                Math.round((b + v) % h) === 0 && (_.vis = true);
+              });
+            }
+          }
+        }
+      });
+      var $d = ye((xsr, Dve) => {
+        Dve.exports = { container: "marker", min: "cmin", max: "cmax" };
+      });
+      var lI = ye((bsr, Fve) => {
+        var sI = ho();
+        Fve.exports = function(t, r, n) {
+          var i = {}, a = { _fullLayout: n }, o = sI.getFromTrace(a, r, "x"), s = sI.getFromTrace(a, r, "y"), l = t.orig_x;
+          l === void 0 && (l = t.x);
+          var u = t.orig_y;
+          return u === void 0 && (u = t.y), i.xLabel = sI.tickText(o, o.c2l(l), true).text, i.yLabel = sI.tickText(s, s.c2l(u), true).text, i;
+        };
+      });
+      var sp = ye((wsr, zve) => {
+        var MU = Oa(), vT = So(), e0t = qa();
+        function t0t(e) {
+          var t = MU.select(e).selectAll("g.trace.scatter");
+          t.style("opacity", function(r) {
+            return r[0].trace.opacity;
+          }), t.selectAll("g.points").each(function(r) {
+            var n = MU.select(this), i = r.trace || r[0].trace;
+            EU(n, i, e);
+          }), t.selectAll("g.text").each(function(r) {
+            var n = MU.select(this), i = r.trace || r[0].trace;
+            kU(n, i, e);
+          }), t.selectAll("g.trace path.js-line").call(vT.lineGroupStyle), t.selectAll("g.trace path.js-fill").call(vT.fillGroupStyle, e, false), e0t.getComponentMethod("errorbars", "style")(t);
+        }
+        function EU(e, t, r) {
+          vT.pointStyle(e.selectAll("path.point"), t, r);
+        }
+        function kU(e, t, r) {
+          vT.textPointStyle(e.selectAll("text"), t, r);
+        }
+        function r0t(e, t, r) {
+          var n = t[0].trace;
+          n.selectedpoints ? (vT.selectedPointStyle(r.selectAll("path.point"), n), vT.selectedTextStyle(r.selectAll("text"), n)) : (EU(r, n, e), kU(r, n, e));
+        }
+        zve.exports = { style: t0t, stylePoints: EU, styleText: kU, styleOnSelect: r0t };
+      });
+      var gT = ye((Tsr, Ove) => {
+        var pT = ka(), i0t = Ru();
+        Ove.exports = function(t, r) {
+          var n, i;
+          if (t.mode === "lines") return n = t.line.color, n && pT.opacity(n) ? n : t.fillcolor;
+          if (t.mode === "none") return t.fill ? t.fillcolor : "";
+          var a = r.mcc || (t.marker || {}).color, o = r.mlcc || ((t.marker || {}).line || {}).color;
+          return i = a && pT.opacity(a) ? a : o && pT.opacity(o) && (r.mlw || ((t.marker || {}).line || {}).width) ? o : "", i ? pT.opacity(i) < 0.3 ? pT.addOpacity(i, 0.3) : i : (n = (t.line || {}).color, n && pT.opacity(n) && i0t.hasLines(t) && t.line.width ? n : t.fillcolor);
+        };
+      });
+      var mT = ye((Asr, Bve) => {
+        var uI = Dr(), qve = vf(), n0t = qa(), a0t = gT(), CU = ka(), o0t = uI.fillText;
+        Bve.exports = function(t, r, n, i) {
+          var a = t.cd, o = a[0].trace, s = t.xa, l = t.ya, u = s.c2p(r), c = l.c2p(n), f = [u, c], h = o.hoveron || "", d = o.mode.indexOf("markers") !== -1 ? 3 : 0.5, v = !!o.xperiodalignment, _ = !!o.yperiodalignment;
+          if (h.indexOf("points") !== -1) {
+            var b = function(j) {
+              if (v) {
+                var N = s.c2p(j.xStart), H = s.c2p(j.xEnd);
+                return u >= Math.min(N, H) && u <= Math.max(N, H) ? 0 : 1 / 0;
+              }
+              var re = Math.max(3, j.mrc || 0), oe = 1 - 1 / re, _e = Math.abs(s.c2p(j.x) - u);
+              return _e < re ? oe * _e / re : _e - re + oe;
+            }, p = function(j) {
+              if (_) {
+                var N = l.c2p(j.yStart), H = l.c2p(j.yEnd);
+                return c >= Math.min(N, H) && c <= Math.max(N, H) ? 0 : 1 / 0;
+              }
+              var re = Math.max(3, j.mrc || 0), oe = 1 - 1 / re, _e = Math.abs(l.c2p(j.y) - c);
+              return _e < re ? oe * _e / re : _e - re + oe;
+            }, k = function(j) {
+              var N = Math.max(d, j.mrc || 0), H = s.c2p(j.x) - u, re = l.c2p(j.y) - c;
+              return Math.max(Math.sqrt(H * H + re * re) - N, 1 - d / N);
+            }, E = qve.getDistanceFunction(i, b, p, k);
+            if (qve.getClosest(a, E, t), t.index !== false) {
+              var T = a[t.index], L = s.c2p(T.x, true), x = l.c2p(T.y, true), C = T.mrc || 1;
+              t.index = T.i;
+              var M = a[0].t.orientation, g = M && (T.sNorm || T.s), P = M === "h" ? g : T.orig_x !== void 0 ? T.orig_x : T.x, A = M === "v" ? g : T.orig_y !== void 0 ? T.orig_y : T.y;
+              return uI.extendFlat(t, { color: a0t(o, T), x0: L - C, x1: L + C, xLabelVal: P, y0: x - C, y1: x + C, yLabelVal: A, spikeDistance: k(T), hovertemplate: o.hovertemplate }), o0t(T, o, t), n0t.getComponentMethod("errorbars", "hoverInfo")(T, o, t), [t];
+            }
+          }
+          function z(j) {
+            if (!j) return false;
+            var N = j.node();
+            try {
+              var H = new DOMPoint(f[0], f[1]);
+              return N.isPointInFill(H);
+            } catch (oe) {
+              var re = N.ownerSVGElement.createSVGPoint();
+              return re.x = f[0], re.y = f[1], N.isPointInFill(re);
+            }
+          }
+          function O(j) {
+            var N, H = [], re = 1 / 0, oe = -1 / 0, _e = 1 / 0, Ce = -1 / 0, Le;
+            for (N = 0; N < j.length; N++) {
+              var ge = j[N];
+              ge.contains(f) && (H.push(ge), _e = Math.min(_e, ge.ymin), Ce = Math.max(Ce, ge.ymax));
+            }
+            if (H.length === 0) return null;
+            _e = Math.max(_e, 0), Ce = Math.min(Ce, l._length), Le = (_e + Ce) / 2;
+            var ie, Se, Ee, Ae, Be, Pe, me;
+            for (N = 0; N < H.length; N++) for (Se = H[N].pts, ie = 1; ie < Se.length; ie++) Pe = Se[ie - 1][1], me = Se[ie][1], Pe > Le != me >= Le && (Ae = Se[ie - 1][0], Be = Se[ie][0], me - Pe && (Ee = Ae + (Be - Ae) * (Le - Pe) / (me - Pe), re = Math.min(re, Ee), oe = Math.max(oe, Ee)));
+            return re = Math.max(re, 0), oe = Math.min(oe, s._length), { x0: re, x1: oe, y0: Le, y1: Le };
+          }
+          if (h.indexOf("fills") !== -1 && o._fillElement) {
+            var U = z(o._fillElement) && !z(o._fillExclusionElement);
+            if (U) {
+              var G = O(o._polygons);
+              G === null && (G = { x0: f[0], x1: f[0], y0: f[1], y1: f[1] });
+              var Z = CU.defaultLine;
+              return CU.opacity(o.fillcolor) ? Z = o.fillcolor : CU.opacity((o.line || {}).color) && (Z = o.line.color), uI.extendFlat(t, { distance: t.maxHoverDistance, x0: G.x0, x1: G.x1, y0: G.y0, y1: G.y1, color: Z, hovertemplate: false }), delete t.index, o.text && !uI.isArrayOrTypedArray(o.text) ? t.text = String(o.text) : t.text = o.name, [t];
+            }
+          }
+        };
+      });
+      var yT = ye((Ssr, Uve) => {
+        var Nve = Ru();
+        Uve.exports = function(t, r) {
+          var n = t.cd, i = t.xaxis, a = t.yaxis, o = [], s = n[0].trace, l, u, c, f, h = !Nve.hasMarkers(s) && !Nve.hasText(s);
+          if (h) return [];
+          if (r === false) for (l = 0; l < n.length; l++) n[l].selected = 0;
+          else for (l = 0; l < n.length; l++) u = n[l], c = i.c2p(u.x), f = a.c2p(u.y), u.i !== null && r.contains([c, f], false, l, t) ? (o.push({ pointNumber: u.i, x: i.c2d(u.x), y: a.c2d(u.y) }), u.selected = 1) : u.selected = 0;
+          return o;
+        };
+      });
+      var Gve = ye((Msr, Vve) => {
+        Vve.exports = { xaxis: { valType: "subplotid", dflt: "x", editType: "calc+clearAxisTypes" }, yaxis: { valType: "subplotid", dflt: "y", editType: "calc+clearAxisTypes" } };
+      });
+      var PU = ye((Esr, Wve) => {
+        var l4 = qa().traceIs, LU = V3();
+        Wve.exports = function(t, r, n, i) {
+          n("autotypenumbers", i.autotypenumbersDflt);
+          var a = n("type", (i.splomStash || {}).type);
+          a === "-" && (s0t(r, i.data), r.type === "-" ? r.type = "linear" : t.type = r.type);
+        };
+        function s0t(e, t) {
+          if (e.type === "-") {
+            var r = e._id, n = r.charAt(0), i;
+            r.indexOf("scene") !== -1 && (r = n);
+            var a = l0t(t, r, n);
+            if (a) {
+              if (a.type === "histogram" && n === { v: "y", h: "x" }[a.orientation || "v"]) {
+                e.type = "linear";
+                return;
+              }
+              var o = n + "calendar", s = a[o], l = { noMultiCategory: !l4(a, "cartesian") || l4(a, "noMultiCategory") };
+              if (a.type === "box" && a._hasPreCompStats && n === { h: "x", v: "y" }[a.orientation || "v"] && (l.noMultiCategory = true), l.autotypenumbers = e.autotypenumbers, jve(a, n)) {
+                var u = Hve(a), c = [];
+                for (i = 0; i < t.length; i++) {
+                  var f = t[i];
+                  !l4(f, "box-violin") || (f[n + "axis"] || n) !== r || (f[u] !== void 0 ? c.push(f[u][0]) : f.name !== void 0 ? c.push(f.name) : c.push("text"), f[o] !== s && (s = void 0));
+                }
+                e.type = LU(c, s, l);
+              } else if (a.type === "splom") {
+                var h = a.dimensions, d = h[a._axesDim[r]];
+                d.visible && (e.type = LU(d.values, s, l));
+              } else e.type = LU(a[n] || [a[n + "0"]], s, l);
+            }
+          }
+        }
+        function l0t(e, t, r) {
+          for (var n = 0; n < e.length; n++) {
+            var i = e[n];
+            if (i.type === "splom" && i._length > 0 && (i["_" + r + "axes"] || {})[t]) return i;
+            if ((i[r + "axis"] || r) === t) {
+              if (jve(i, r)) return i;
+              if ((i[r] || []).length || i[r + "0"]) return i;
+            }
+          }
+        }
+        function Hve(e) {
+          return { v: "x", h: "y" }[e.orientation || "v"];
+        }
+        function jve(e, t) {
+          var r = Hve(e), n = l4(e, "box-violin"), i = l4(e._fullInput || {}, "candlestick");
+          return n && !i && t === r && e[r] === void 0 && e[r + "0"] === void 0;
+        }
+      });
+      var cI = ye((ksr, Xve) => {
+        var u0t = vv().isTypedArraySpec;
+        function c0t(e, t) {
+          var r = t.dataAttr || e._id.charAt(0), n = {}, i, a, o;
+          if (t.axData) i = t.axData;
+          else for (i = [], a = 0; a < t.data.length; a++) {
+            var s = t.data[a];
+            s[r + "axis"] === e._id && i.push(s);
+          }
+          for (a = 0; a < i.length; a++) {
+            var l = i[a][r];
+            for (o = 0; o < l.length; o++) {
+              var u = l[o];
+              u != null && (n[u] = 1);
+            }
+          }
+          return Object.keys(n);
+        }
+        Xve.exports = function(t, r, n, i) {
+          if (r.type === "category") {
+            var a = t.categoryarray, o = Array.isArray(a) && a.length > 0 || u0t(a), s;
+            o && (s = "array");
+            var l = n("categoryorder", s), u;
+            l === "array" && (u = n("categoryarray")), !o && l === "array" && (l = r.categoryorder = "trace"), l === "trace" ? r._initialCategories = [] : l === "array" ? r._initialCategories = u.slice() : (u = c0t(r, i).sort(), l === "category ascending" ? r._initialCategories = u : l === "category descending" && (r._initialCategories = u.reverse()));
+          }
+        };
+      });
+      var u4 = ye((Csr, Yve) => {
+        var Zve = fd().mix, f0t = Ih(), h0t = Dr();
+        Yve.exports = function(t, r, n, i) {
+          i = i || {};
+          var a = i.dfltColor;
+          function o(M, g) {
+            return h0t.coerce2(t, r, i.attributes, M, g);
+          }
+          var s = o("linecolor", a), l = o("linewidth"), u = n("showline", i.showLine || !!s || !!l);
+          u || (delete r.linecolor, delete r.linewidth);
+          var c = Zve(a, i.bgColor, i.blend || f0t.lightFraction).toRgbString(), f = o("gridcolor", c), h = o("gridwidth"), d = o("griddash"), v = n("showgrid", i.showGrid || !!f || !!h || !!d);
+          if (v || (delete r.gridcolor, delete r.gridwidth, delete r.griddash), i.hasMinor) {
+            var _ = Zve(r.gridcolor, i.bgColor, 67).toRgbString(), b = o("minor.gridcolor", _), p = o("minor.gridwidth", r.gridwidth || 1), k = o("minor.griddash", r.griddash || "solid"), E = n("minor.showgrid", !!b || !!p || !!k);
+            E || (delete r.minor.gridcolor, delete r.minor.gridwidth, delete r.minor.griddash);
+          }
+          if (!i.noZeroLine) {
+            o("zerolinelayer");
+            var L = o("zerolinecolor", a), x = o("zerolinewidth"), C = n("zeroline", i.showGrid || !!L || !!x);
+            C || (delete r.zerolinelayer, delete r.zerolinecolor, delete r.zerolinewidth);
+          }
+        };
+      });
+      var f4 = ye((Lsr, tpe) => {
+        var Kve = Eo(), d0t = qa(), c4 = Dr(), v0t = vl(), p0t = Zd(), IU = Rd(), Jve = Lb(), $ve = F3(), g0t = s_(), m0t = l_(), y0t = cI(), _0t = u4(), x0t = AB(), Qve = xm(), fI = Rh().WEEKDAY_PATTERN, b0t = Rh().HOUR_PATTERN;
+        tpe.exports = function(t, r, n, i, a) {
+          var o = i.letter, s = i.font || {}, l = i.splomStash || {}, u = n("visible", !i.visibleDflt), c = r._template || {}, f = r.type || c.type || "-", h;
+          if (f === "date") {
+            var d = d0t.getComponentMethod("calendars", "handleDefaults");
+            d(t, r, "calendar", i.calendar), i.noTicklabelmode || (h = n("ticklabelmode"));
+          }
+          !i.noTicklabelindex && (f === "date" || f === "linear") && n("ticklabelindex");
+          var v = "";
+          (!i.noTicklabelposition || f === "multicategory") && (v = c4.coerce(t, r, { ticklabelposition: { valType: "enumerated", dflt: "outside", values: h === "period" ? ["outside", "inside"] : o === "x" ? ["outside", "inside", "outside left", "inside left", "outside right", "inside right"] : ["outside", "inside", "outside top", "inside top", "outside bottom", "inside bottom"] } }, "ticklabelposition")), i.noTicklabeloverflow || n("ticklabeloverflow", v.indexOf("inside") !== -1 ? "hide past domain" : f === "category" || f === "multicategory" ? "allow" : "hide past div"), Qve(r, a), x0t(t, r, n, i), y0t(t, r, n, i), i.noHover || (f !== "category" && n("hoverformat"), i.noUnifiedhovertitle || n("unifiedhovertitle.text"));
+          var _ = n("color"), b = _ !== IU.color.dflt ? _ : s.color, p = l.label || a._dfltTitle[o];
+          if (m0t(t, r, n, f, i), !u) return r;
+          n("title.text", p), c4.coerceFont(n, "title.font", s, { overrideDflt: { size: c4.bigFont(s.size), color: b } }), Jve(t, r, n, f);
+          var k = i.hasMinor;
+          if (k && (v0t.newContainer(r, "minor"), Jve(t, r, n, f, { isMinor: true })), g0t(t, r, n, f, i), $ve(t, r, n, i), k) {
+            var E = i.isMinor;
+            i.isMinor = true, $ve(t, r, n, i), i.isMinor = E;
+          }
+          _0t(t, r, n, { dfltColor: _, bgColor: i.bgColor, showGrid: i.showGrid, hasMinor: k, attributes: IU }), k && !r.minor.ticks && !r.minor.showgrid && delete r.minor, (r.showline || r.ticks) && n("mirror");
+          var T = f === "multicategory";
+          if (!i.noTickson && (f === "category" || T) && (r.ticks || r.showgrid) && (T ? (n("tickson", "boundaries"), delete r.ticklabelposition) : n("tickson")), T) {
+            var L = n("showdividers");
+            L && (n("dividercolor"), n("dividerwidth"));
+          }
+          if (f === "date") if (p0t(t, r, { name: "rangebreaks", inclusionAttr: "enabled", handleItemDefaults: w0t }), !r.rangebreaks.length) delete r.rangebreaks;
+          else {
+            for (var x = 0; x < r.rangebreaks.length; x++) if (r.rangebreaks[x].pattern === fI) {
+              r._hasDayOfWeekBreaks = true;
+              break;
+            }
+            if (Qve(r, a), a._has("scattergl") || a._has("splom")) for (var C = 0; C < i.data.length; C++) {
+              var M = i.data[C];
+              (M.type === "scattergl" || M.type === "splom") && (M.visible = false, c4.warn(M.type + " traces do not work on axes with rangebreaks. Setting trace " + M.index + " to `visible: false`."));
+            }
+          }
+          return r;
+        };
+        function w0t(e, t, r) {
+          function n(h, d) {
+            return c4.coerce(e, t, IU.rangebreaks, h, d);
+          }
+          var i = n("enabled");
+          if (i) {
+            var a = n("bounds");
+            if (a && a.length >= 2) {
+              var o = "", s, l;
+              if (a.length === 2) {
+                for (s = 0; s < 2; s++) if (l = epe(a[s]), l) {
+                  o = fI;
+                  break;
+                }
+              }
+              var u = n("pattern", o);
+              if (u === fI) for (s = 0; s < 2; s++) l = epe(a[s]), l && (t.bounds[s] = a[s] = l - 1);
+              if (u) for (s = 0; s < 2; s++) switch (l = a[s], u) {
+                case fI:
+                  if (!Kve(l)) {
+                    t.enabled = false;
+                    return;
+                  }
+                  if (l = +l, l !== Math.floor(l) || l < 0 || l >= 7) {
+                    t.enabled = false;
+                    return;
+                  }
+                  t.bounds[s] = a[s] = l;
+                  break;
+                case b0t:
+                  if (!Kve(l)) {
+                    t.enabled = false;
+                    return;
+                  }
+                  if (l = +l, l < 0 || l > 24) {
+                    t.enabled = false;
+                    return;
+                  }
+                  t.bounds[s] = a[s] = l;
+                  break;
+              }
+              if (r.autorange === false) {
+                var c = r.range;
+                if (c[0] < c[1]) {
+                  if (a[0] < c[0] && a[1] > c[1]) {
+                    t.enabled = false;
+                    return;
+                  }
+                } else if (a[0] > c[0] && a[1] < c[1]) {
+                  t.enabled = false;
+                  return;
+                }
+              }
+            } else {
+              var f = n("values");
+              if (f && f.length) n("dvalue");
+              else {
+                t.enabled = false;
+                return;
+              }
+            }
+          }
+        }
+        var T0t = { sun: 1, mon: 2, tue: 3, wed: 4, thu: 5, fri: 6, sat: 7 };
+        function epe(e) {
+          if (typeof e == "string") return T0t[e.slice(0, 3).toLowerCase()];
+        }
+      });
+      var dI = ye((Psr, rpe) => {
+        var A0t = Eo(), hI = Dr();
+        rpe.exports = function(t, r, n, i) {
+          var a = i.counterAxes || [], o = i.overlayableAxes || [], s = i.letter, l = i.grid, u = i.overlayingDomain, c, f, h, d, v, _;
+          l && (f = l._domains[s][l._axisMap[r._id]], c = l._anchors[r._id], f && (h = l[s + "side"].split(" ")[0], d = l.domain[s][h === "right" || h === "top" ? 1 : 0])), f = f || [0, 1], c = c || (A0t(t.position) ? "free" : a[0] || "free"), h = h || (s === "x" ? "bottom" : "left"), d = d || 0, v = 0, _ = false;
+          var b = hI.coerce(t, r, { anchor: { valType: "enumerated", values: ["free"].concat(a), dflt: c } }, "anchor"), p = hI.coerce(t, r, { side: { valType: "enumerated", values: s === "x" ? ["bottom", "top"] : ["left", "right"], dflt: h } }, "side");
+          if (b === "free") {
+            if (s === "y") {
+              var k = n("autoshift");
+              k && (d = p === "left" ? u[0] : u[1], _ = r.automargin ? r.automargin : true, v = p === "left" ? -3 : 3), n("shift", v);
+            }
+            n("position", d);
+          }
+          n("automargin", _);
+          var E = false;
+          if (o.length && (E = hI.coerce(t, r, { overlaying: { valType: "enumerated", values: [false].concat(o), dflt: false } }, "overlaying")), !E) {
+            var T = n("domain", f);
+            T[0] > T[1] - 1 / 4096 && (r.domain = f), hI.noneOrAll(t.domain, r.domain, f), r.tickmode === "sync" && (r.tickmode = "auto");
+          }
+          return n("layer"), r;
+        };
+      });
+      var fpe = ye((Isr, cpe) => {
+        var r2 = Dr(), ipe = ka(), S0t = ip().isUnifiedHover, M0t = YB(), npe = vl(), E0t = _3(), ape = Rd(), k0t = PU(), ope = f4(), C0t = Kb(), spe = dI(), DU = hf(), Dm = DU.id2name, lpe = DU.name2id, L0t = Rh().AX_ID_PATTERN, upe = qa(), vI = upe.traceIs, RU = upe.getComponentMethod;
+        function pI(e, t, r) {
+          Array.isArray(e[t]) ? e[t].push(r) : e[t] = [r];
+        }
+        cpe.exports = function(t, r, n) {
+          var i = r.autotypenumbers, a = {}, o = {}, s = {}, l = {}, u = {}, c = {}, f = {}, h = {}, d = {}, v = {}, _, b;
+          for (_ = 0; _ < n.length; _++) {
+            var p = n[_];
+            if (vI(p, "cartesian")) {
+              var k;
+              if (p.xaxis) k = Dm(p.xaxis), pI(a, k, p);
+              else if (p.xaxes) for (b = 0; b < p.xaxes.length; b++) pI(a, Dm(p.xaxes[b]), p);
+              var E;
+              if (p.yaxis) E = Dm(p.yaxis), pI(a, E, p);
+              else if (p.yaxes) for (b = 0; b < p.yaxes.length; b++) pI(a, Dm(p.yaxes[b]), p);
+              if (p.type === "funnel" ? p.orientation === "h" ? (k && (o[k] = true), E && (f[E] = true)) : E && (s[E] = true) : p.type === "image" ? (E && (h[E] = true), k && (h[k] = true)) : (E && (u[E] = true, c[E] = true), (!vI(p, "carpet") || p.type === "carpet" && !p._cheater) && k && (l[k] = true)), p.type === "carpet" && p._cheater && k && (o[k] = true), vI(p, "2dMap") && (d[k] = true, d[E] = true), vI(p, "oriented")) {
+                var T = p.orientation === "h" ? E : k;
+                v[T] = true;
+              }
+            }
+          }
+          var L = r._subplots, x = L.xaxis, C = L.yaxis, M = r2.simpleMap(x, Dm), g = r2.simpleMap(C, Dm), P = M.concat(g), A = ipe.background;
+          x.length && C.length && (A = r2.coerce(t, r, E0t, "plot_bgcolor"));
+          var z = ipe.combine(A, r.paper_bgcolor), O, U, G, Z, j;
+          function N() {
+            var St = a[O] || [];
+            j._traceIndices = St.map(function(Qt) {
+              return Qt.index;
+            }), j._annIndices = [], j._shapeIndices = [], j._selectionIndices = [], j._imgIndices = [], j._subplotsWith = [], j._counterAxes = [], j._name = j._attr = O, j._id = U;
+          }
+          function H(St, Qt) {
+            return r2.coerce(Z, j, ape, St, Qt);
+          }
+          function re(St, Qt) {
+            return r2.coerce2(Z, j, ape, St, Qt);
+          }
+          function oe(St) {
+            return St === "x" ? C : x;
+          }
+          function _e(St, Qt) {
+            for (var Gt = St === "x" ? M : g, _t = [], It = 0; It < Gt.length; It++) {
+              var mt = Gt[It];
+              mt !== Qt && !(t[mt] || {}).overlaying && _t.push(lpe(mt));
+            }
+            return _t;
+          }
+          var Ce = { x: oe("x"), y: oe("y") }, Le = Ce.x.concat(Ce.y), ge = {}, ie = [];
+          function Se() {
+            var St = Z.matches;
+            L0t.test(St) && Le.indexOf(St) === -1 && (ge[St] = Z.type, ie = Object.keys(ge));
+          }
+          var Ee = M0t(t, r), Ae = S0t(Ee);
+          for (_ = 0; _ < P.length; _++) {
+            O = P[_], U = lpe(O), G = O.charAt(0), r2.isPlainObject(t[O]) || (t[O] = {}), Z = t[O], j = npe.newContainer(r, O, G + "axis"), N();
+            var Be = G === "x" && !l[O] && o[O] || G === "y" && !u[O] && s[O], Pe = G === "y" && (!c[O] && f[O] || h[O]), me = { hasMinor: true, letter: G, font: r.font, outerTicks: d[O], showGrid: !v[O], data: a[O] || [], bgColor: z, calendar: r.calendar, automargin: true, visibleDflt: Be, reverseDflt: Pe, autotypenumbersDflt: i, splomStash: ((r._splomAxes || {})[G] || {})[U], noAutotickangles: G === "y" };
+            H("uirevision", r.uirevision), k0t(Z, j, H, me), ope(Z, j, H, me, r);
+            var De = Ae && G === Ee.charAt(0), ce = re("spikecolor", Ae ? j.color : void 0), je = re("spikethickness", Ae ? 1.5 : void 0), lt = re("spikedash", Ae ? "dot" : void 0), pt = re("spikemode", Ae ? "across" : void 0), Vt = re("spikesnap"), ot = H("showspikes", !!De || !!ce || !!je || !!lt || !!pt || !!Vt);
+            ot || (delete j.spikecolor, delete j.spikethickness, delete j.spikedash, delete j.spikemode, delete j.spikesnap);
+            var ut = Dm(Z.overlaying), Wt = [0, 1];
+            if (r[ut] !== void 0) {
+              var Nt = Dm(r[ut].anchor);
+              r[Nt] !== void 0 && (Wt = r[Nt].domain);
+            }
+            spe(Z, j, H, { letter: G, counterAxes: Ce[G], overlayableAxes: _e(G, O), grid: r.grid, overlayingDomain: Wt }), H("title.standoff"), Se(), j._input = Z;
+          }
+          for (_ = 0; _ < ie.length; ) {
+            U = ie[_++], O = Dm(U), G = O.charAt(0), r2.isPlainObject(t[O]) || (t[O] = {}), Z = t[O], j = npe.newContainer(r, O, G + "axis"), N();
+            var $t = { letter: G, font: r.font, outerTicks: d[O], showGrid: !v[O], data: [], bgColor: z, calendar: r.calendar, automargin: true, visibleDflt: false, reverseDflt: false, autotypenumbersDflt: i, splomStash: ((r._splomAxes || {})[G] || {})[U] };
+            H("uirevision", r.uirevision), j.type = ge[U] || "linear", ope(Z, j, H, $t, r), spe(Z, j, H, { letter: G, counterAxes: Ce[G], overlayableAxes: _e(G, O), grid: r.grid }), H("fixedrange"), H("modebardisable"), Se(), j._input = Z;
+          }
+          var sr = RU("rangeslider", "handleDefaults"), Tr = RU("rangeselector", "handleDefaults");
+          for (_ = 0; _ < M.length; _++) O = M[_], Z = t[O], j = r[O], sr(t, r, O), j.type === "date" && Tr(Z, j, r, g, j.calendar), H("fixedrange"), H("modebardisable");
+          for (_ = 0; _ < g.length; _++) {
+            O = g[_], Z = t[O], j = r[O];
+            var fr = r[Dm(j.anchor)], $e = RU("rangeslider", "isVisible")(fr);
+            H("fixedrange", $e), H("modebardisable");
+          }
+          C0t.handleDefaults(t, r, { axIds: Le.concat(ie).sort(DU.idSort), axHasImage: h });
+        };
+      });
+      var vpe = ye((Rsr, dpe) => {
+        var P0t = Oa(), hpe = qa(), gI = Dr(), Qp = So(), mI = ho();
+        dpe.exports = function(t, r, n, i) {
+          var a = t._fullLayout;
+          if (r.length === 0) {
+            mI.redrawComponents(t);
+            return;
+          }
+          function o(b) {
+            var p = b.xaxis, k = b.yaxis;
+            a._defs.select("#" + b.clipId + "> rect").call(Qp.setTranslate, 0, 0).call(Qp.setScale, 1, 1), b.plot.call(Qp.setTranslate, p._offset, k._offset).call(Qp.setScale, 1, 1);
+            var E = b.plot.selectAll(".scatterlayer .trace");
+            E.selectAll(".point").call(Qp.setPointGroupScale, 1, 1), E.selectAll(".textpoint").call(Qp.setTextPointsScale, 1, 1), E.call(Qp.hideOutsideRangePoints, b);
+          }
+          function s(b, p) {
+            var k = b.plotinfo, E = k.xaxis, T = k.yaxis, L = E._length, x = T._length, C = !!b.xr1, M = !!b.yr1, g = [];
+            if (C) {
+              var P = gI.simpleMap(b.xr0, E.r2l), A = gI.simpleMap(b.xr1, E.r2l), z = P[1] - P[0], O = A[1] - A[0];
+              g[0] = (P[0] * (1 - p) + p * A[0] - P[0]) / (P[1] - P[0]) * L, g[2] = L * (1 - p + p * O / z), E.range[0] = E.l2r(P[0] * (1 - p) + p * A[0]), E.range[1] = E.l2r(P[1] * (1 - p) + p * A[1]);
+            } else g[0] = 0, g[2] = L;
+            if (M) {
+              var U = gI.simpleMap(b.yr0, T.r2l), G = gI.simpleMap(b.yr1, T.r2l), Z = U[1] - U[0], j = G[1] - G[0];
+              g[1] = (U[1] * (1 - p) + p * G[1] - U[1]) / (U[0] - U[1]) * x, g[3] = x * (1 - p + p * j / Z), T.range[0] = E.l2r(U[0] * (1 - p) + p * G[0]), T.range[1] = T.l2r(U[1] * (1 - p) + p * G[1]);
+            } else g[1] = 0, g[3] = x;
+            mI.drawOne(t, E, { skipTitle: true }), mI.drawOne(t, T, { skipTitle: true }), mI.redrawComponents(t, [E._id, T._id]);
+            var N = C ? L / g[2] : 1, H = M ? x / g[3] : 1, re = C ? g[0] : 0, oe = M ? g[1] : 0, _e = C ? g[0] / g[2] * L : 0, Ce = M ? g[1] / g[3] * x : 0, Le = E._offset - _e, ge = T._offset - Ce;
+            k.clipRect.call(Qp.setTranslate, re, oe).call(Qp.setScale, 1 / N, 1 / H), k.plot.call(Qp.setTranslate, Le, ge).call(Qp.setScale, N, H), Qp.setPointGroupScale(k.zoomScalePts, 1 / N, 1 / H), Qp.setTextPointsScale(k.zoomScaleTxt, 1 / N, 1 / H);
+          }
+          var l;
+          i && (l = i());
+          function u() {
+            for (var b = {}, p = 0; p < r.length; p++) {
+              var k = r[p], E = k.plotinfo.xaxis, T = k.plotinfo.yaxis;
+              k.xr1 && (b[E._name + ".range"] = k.xr1.slice()), k.yr1 && (b[T._name + ".range"] = k.yr1.slice());
+            }
+            return l && l(), hpe.call("relayout", t, b).then(function() {
+              for (var L = 0; L < r.length; L++) o(r[L].plotinfo);
+            });
+          }
+          function c() {
+            for (var b = {}, p = 0; p < r.length; p++) {
+              var k = r[p], E = k.plotinfo.xaxis, T = k.plotinfo.yaxis;
+              k.xr0 && (b[E._name + ".range"] = k.xr0.slice()), k.yr0 && (b[T._name + ".range"] = k.yr0.slice());
+            }
+            return hpe.call("relayout", t, b).then(function() {
+              for (var L = 0; L < r.length; L++) o(r[L].plotinfo);
+            });
+          }
+          var f, h, d, v = P0t.ease(n.easing);
+          t._transitionData._interruptCallbacks.push(function() {
+            return window.cancelAnimationFrame(d), d = null, c();
+          });
+          function _() {
+            h = Date.now();
+            for (var b = Math.min(1, (h - f) / n.duration), p = v(b), k = 0; k < r.length; k++) s(r[k], p);
+            h - f > n.duration ? (u(), d = window.cancelAnimationFrame(_)) : d = window.requestAnimationFrame(_);
+          }
+          return f = Date.now(), d = window.requestAnimationFrame(_), Promise.resolve();
+        };
+      });
+      var mh = ye((xv) => {
+        var _I = Oa(), ppe = qa(), i2 = Dr(), I0t = Mc(), R0t = So(), gpe = Id().getModuleCalcData, S_ = hf(), qg = Rh(), D0t = Wp(), iu = i2.ensureSingle;
+        function yI(e, t, r) {
+          return i2.ensureSingle(e, t, r, function(n) {
+            n.datum(r);
+          });
+        }
+        var n2 = qg.zindexSeparator;
+        xv.name = "cartesian";
+        xv.attr = ["xaxis", "yaxis"];
+        xv.idRoot = ["x", "y"];
+        xv.idRegex = qg.idRegex;
+        xv.attrRegex = qg.attrRegex;
+        xv.attributes = Gve();
+        xv.layoutAttributes = Rd();
+        xv.supplyLayoutDefaults = fpe();
+        xv.transitionAxes = vpe();
+        xv.finalizeSubplots = function(e, t) {
+          var r = t._subplots, n = r.xaxis, i = r.yaxis, a = r.cartesian, o = a, s = {}, l = {}, u, c, f;
+          for (u = 0; u < o.length; u++) {
+            var h = o[u].split("y");
+            s[h[0]] = 1, l["y" + h[1]] = 1;
+          }
+          for (u = 0; u < n.length; u++) c = n[u], s[c] || (f = (e[S_.id2name(c)] || {}).anchor, qg.idRegex.y.test(f) || (f = "y"), a.push(c + f), o.push(c + f), l[f] || (l[f] = 1, i2.pushUnique(i, f)));
+          for (u = 0; u < i.length; u++) f = i[u], l[f] || (c = (e[S_.id2name(f)] || {}).anchor, qg.idRegex.x.test(c) || (c = "x"), a.push(c + f), o.push(c + f), s[c] || (s[c] = 1, i2.pushUnique(n, c)));
+          if (!o.length) {
+            c = "", f = "";
+            for (var d in e) if (qg.attrRegex.test(d)) {
+              var v = d.charAt(0);
+              v === "x" ? (!c || +d.slice(5) < +c.slice(5)) && (c = d) : (!f || +d.slice(5) < +f.slice(5)) && (f = d);
+            }
+            c = c ? S_.name2id(c) : "x", f = f ? S_.name2id(f) : "y", n.push(c), i.push(f), a.push(c + f);
+          }
+        };
+        xv.plot = function(e, t, r, n) {
+          var i = e._fullLayout, a = i._subplots.cartesian, o = e.calcdata, s;
+          if (!Array.isArray(t)) for (t = [], s = 0; s < o.length; s++) t.push(s);
+          for (var l = i._zindices, u = 0; u < l.length; u++) {
+            var c = l[u];
+            for (s = 0; s < a.length; s++) {
+              var f = a[s], h = i._plots[f];
+              if (u > 0) {
+                var d = h.id;
+                if (d.indexOf(n2) !== -1) continue;
+                d += n2 + (u + 1), h = i2.extendFlat({}, h, { id: d, plot: i._cartesianlayer.selectAll(".subplot").select("." + d) });
+              }
+              for (var v = [], _, b = 0; b < o.length; b++) {
+                var p = o[b], k = p[0].trace;
+                c === (k.zorder || 0) && k.xaxis + k.yaxis === f && ((t.indexOf(k.index) !== -1 || k.carpet) && (_ && _[0].trace.xaxis + _[0].trace.yaxis === f && ["tonextx", "tonexty", "tonext"].indexOf(k.fill) !== -1 && v.indexOf(_) === -1 && v.push(_), v.push(p)), _ = p);
+              }
+              mpe(e, h, v, r, n);
+            }
+          }
+        };
+        function mpe(e, t, r, n, i) {
+          for (var a = qg.traceLayerClasses, o = e._fullLayout, s = o._zindices, l = o._modules, u, c, f, h = [], d = [], v = 0; v < s.length; v++) for (var _ = s[v], b = 0; b < l.length; b++) {
+            u = l[b];
+            var p = u.name, k = ppe.modules[p].categories;
+            if (k.svg) {
+              var E = u.layerName || p + "layer", T = E + (v ? Number(v) + 1 : ""), L = u.plot;
+              c = gpe(r, L, _), f = c[0], r = c[1], f.length && h.push({ i: a.indexOf(E), zindex: v, className: T, plotMethod: L, cdModule: f }), k.zoomScale && d.push("." + T);
+            }
+          }
+          h.sort(function(M, g) {
+            return (M.zindex || 0) - (g.zindex || 0) || M.i - g.i;
+          });
+          var x = t.plot.selectAll("g.mlayer").data(h, function(M) {
+            return M.className;
+          });
+          if (x.enter().append("g").attr("class", function(M) {
+            return M.className;
+          }).classed("mlayer", true).classed("rangeplot", t.isRangePlot), x.exit().remove(), x.order(), x.each(function(M) {
+            var g = _I.select(this), P = M.className;
+            M.plotMethod(e, t, M.cdModule, g, n, i), qg.clipOnAxisFalseQuery.indexOf("." + P) === -1 && R0t.setClipUrl(g, t.layerClipId, e);
+          }), o._has("scattergl") && (u = ppe.getModule("scattergl"), f = gpe(r, u)[0], u.plot(e, t, f)), !e._context.staticPlot && (t._hasClipOnAxisFalse && (t.clipOnAxisFalseTraces = t.plot.selectAll(qg.clipOnAxisFalseQuery.join(",")).selectAll(".trace")), d.length)) {
+            var C = t.plot.selectAll(d.join(",")).selectAll(".trace");
+            t.zoomScalePts = C.selectAll("path.point"), t.zoomScaleTxt = C.selectAll(".textpoint");
+          }
+        }
+        xv.clean = function(e, t, r, n) {
+          var i = n._plots || {}, a = t._plots || {}, o = n._subplots || {}, s, l, u;
+          if (n._hasOnlyLargeSploms && !t._hasOnlyLargeSploms) for (u in i) s = i[u], s.plotgroup && s.plotgroup.remove();
+          var c = n._has && n._has("gl"), f = t._has && t._has("gl");
+          if (c && !f) for (u in i) s = i[u], s._scene && s._scene.destroy();
+          if (o.xaxis && o.yaxis) {
+            var h = S_.listIds({ _fullLayout: n });
+            for (l = 0; l < h.length; l++) {
+              var d = h[l];
+              t[S_.id2name(d)] || n._infolayer.selectAll(".g-" + d + "title").remove();
+            }
+          }
+          var v = n._has && n._has("cartesian"), _ = t._has && t._has("cartesian");
+          if (v && !_) _pe(n._cartesianlayer.selectAll(".subplot"), n), n._defs.selectAll(".axesclip").remove(), delete n._axisConstraintGroups, delete n._axisMatchGroups;
+          else if (o.cartesian) for (l = 0; l < o.cartesian.length; l++) {
+            var b = o.cartesian[l];
+            if (b.indexOf(n2) === -1 && !a[b]) {
+              var p = "." + b + ",." + b + "-x,." + b + "-y";
+              n._cartesianlayer.selectAll(p).remove(), xpe(b, n);
+            }
+          }
+        };
+        xv.drawFramework = function(e) {
+          var t = e._fullLayout, r = e.calcdata, n, i = {};
+          for (n = 0; n < r.length; n++) {
+            var a = r[n][0], o = a.trace, s = o.zorder || 0;
+            i[s] || (i[s] = []), i[s].push(a);
+          }
+          var l = Object.keys(i).map(Number).sort(i2.sorterAsc);
+          l.length || (l = [0]), t._zindices = l;
+          var u = F0t(e), c = u.length, f = [];
+          for (n = 0; n < c; n++) f[n] = u[n].slice();
+          for (var h = 1; h < l.length; h++) {
+            var d = [];
+            for (n = 0; n < c; n++) d[n] = u[n].slice(), d[n][0] += n2 + (h + 1);
+            f = f.concat(d);
+          }
+          var v = t._cartesianlayer.selectAll(".subplot").data(f, String);
+          v.enter().append("g").attr("class", function(_) {
+            return "subplot " + _[0];
+          }), v.order(), v.exit().call(_pe, t), v.each(function(_) {
+            var b = _[0], p = b.indexOf(n2), k = p !== -1, E = k ? b.slice(0, p) : b, T = t._plots[b];
+            T || (T = i2.extendFlat({}, t._plots[E]), T && (T.id = b, t._plots[b] = T, t._subplots.cartesian.push(b))), T && (T.plotgroup = _I.select(this), ype(e, T), k || (T.draglayer = iu(t._draggers, "g", b)));
+          });
+        };
+        xv.rangePlot = function(e, t, r) {
+          ype(e, t), mpe(e, t, r), I0t.style(e);
+        };
+        function F0t(e) {
+          var t = e._fullLayout, r = t._zindices.length, n = t._subplots.cartesian, i = n.length, a, o, s, l, u, c, f = [], h = [];
+          for (a = 0; a < i; a++) {
+            s = n[a], l = t._plots[s], u = l.xaxis, c = l.yaxis;
+            var d = u._mainAxis, v = c._mainAxis, _ = d._id + v._id, b = t._plots[_];
+            l.overlays = [], _ !== s && b ? (l.mainplot = _, l.mainplotinfo = b, h.push(s)) : (l.mainplot = void 0, l.mainplotinfo = void 0, f.push(s));
+          }
+          for (a = 0; a < h.length; a++) s = h[a], l = t._plots[s], l.mainplotinfo.overlays.push(l);
+          var p = f.concat(h), k = [];
+          for (a = 0; a < i; a++) {
+            s = p[a], l = t._plots[s], u = l.xaxis, c = l.yaxis;
+            for (var E = [], T = 1; T <= r; T++) {
+              var L = "";
+              for (T > 1 && (L += n2 + T), E.push(s + L), o = 0; o < l.overlays.length; o++) E.push(l.overlays[o].id + L);
+            }
+            E = E.concat([u.layer, c.layer, u.overlaying || "", c.overlaying || ""]), k.push(E);
+          }
+          return k;
+        }
+        function ype(e, t) {
+          var r = e._fullLayout, n = t.plotgroup, i = t.id, a = i.indexOf(n2), o = a !== -1, s = qg.layerValue2layerClass[t.xaxis.layer], l = qg.layerValue2layerClass[t.yaxis.layer], u = r._hasOnlyLargeSploms, c = r._zindices.length > 1, f = t.mainplotinfo;
+          if (!t.mainplot || c) if (u) t.xlines = iu(n, "path", "xlines-above"), t.ylines = iu(n, "path", "ylines-above"), t.xaxislayer = iu(n, "g", "xaxislayer-above"), t.yaxislayer = iu(n, "g", "yaxislayer-above");
+          else {
+            if (!o) {
+              var h = iu(n, "g", "layer-subplot");
+              t.shapelayer = iu(h, "g", "shapelayer"), t.imagelayer = iu(h, "g", "imagelayer"), f && c ? (t.minorGridlayer = f.minorGridlayer, t.gridlayer = f.gridlayer, t.zerolinelayer = f.zerolinelayer) : (t.minorGridlayer = iu(n, "g", "minor-gridlayer"), t.gridlayer = iu(n, "g", "gridlayer"), t.zerolinelayer = iu(n, "g", "zerolinelayer"));
+              var d = iu(n, "g", "layer-between");
+              t.shapelayerBetween = iu(d, "g", "shapelayer"), t.imagelayerBetween = iu(d, "g", "imagelayer"), iu(n, "path", "xlines-below"), iu(n, "path", "ylines-below"), t.overlinesBelow = iu(n, "g", "overlines-below"), iu(n, "g", "xaxislayer-below"), iu(n, "g", "yaxislayer-below"), t.overaxesBelow = iu(n, "g", "overaxes-below");
+            }
+            t.overplot = iu(n, "g", "overplot"), t.plot = iu(t.overplot, "g", i), f && c ? t.zerolinelayerAbove = f.zerolinelayerAbove : t.zerolinelayerAbove = iu(n, "g", "zerolinelayer-above"), o || (t.xlines = iu(n, "path", "xlines-above"), t.ylines = iu(n, "path", "ylines-above"), t.overlinesAbove = iu(n, "g", "overlines-above"), iu(n, "g", "xaxislayer-above"), iu(n, "g", "yaxislayer-above"), t.overaxesAbove = iu(n, "g", "overaxes-above"), t.xlines = n.select(".xlines-" + s), t.ylines = n.select(".ylines-" + l), t.xaxislayer = n.select(".xaxislayer-" + s), t.yaxislayer = n.select(".yaxislayer-" + l));
+          }
+          else {
+            var v = f.plotgroup, _ = i + "-x", b = i + "-y";
+            t.minorGridlayer = f.minorGridlayer, t.gridlayer = f.gridlayer, t.zerolinelayer = f.zerolinelayer, t.zerolinelayerAbove = f.zerolinelayerAbove, iu(f.overlinesBelow, "path", _), iu(f.overlinesBelow, "path", b), iu(f.overaxesBelow, "g", _), iu(f.overaxesBelow, "g", b), t.plot = iu(f.overplot, "g", i), iu(f.overlinesAbove, "path", _), iu(f.overlinesAbove, "path", b), iu(f.overaxesAbove, "g", _), iu(f.overaxesAbove, "g", b), t.xlines = v.select(".overlines-" + s).select("." + _), t.ylines = v.select(".overlines-" + l).select("." + b), t.xaxislayer = v.select(".overaxes-" + s).select("." + _), t.yaxislayer = v.select(".overaxes-" + l).select("." + b);
+          }
+          o || (u || (yI(t.minorGridlayer, "g", t.xaxis._id), yI(t.minorGridlayer, "g", t.yaxis._id), t.minorGridlayer.selectAll("g").map(function(p) {
+            return p[0];
+          }).sort(S_.idSort), yI(t.gridlayer, "g", t.xaxis._id), yI(t.gridlayer, "g", t.yaxis._id), t.gridlayer.selectAll("g").map(function(p) {
+            return p[0];
+          }).sort(S_.idSort)), t.xlines.style("fill", "none").classed("crisp", true), t.ylines.style("fill", "none").classed("crisp", true));
+        }
+        function _pe(e, t) {
+          if (e) {
+            var r = {};
+            e.each(function(l) {
+              var u = l[0], c = _I.select(this);
+              c.remove(), xpe(u, t), r[u] = true;
+            });
+            for (var n in t._plots) for (var i = t._plots[n], a = i.overlays || [], o = 0; o < a.length; o++) {
+              var s = a[o];
+              r[s.id] && s.plot.selectAll(".trace").remove();
+            }
+          }
+        }
+        function xpe(e, t) {
+          t._draggers.selectAll("g." + e).remove(), t._defs.select("#clip" + t._uid + e + "plot").remove();
+        }
+        xv.toSVG = function(e) {
+          var t = e._fullLayout._glimages, r = _I.select(e).selectAll(".svg-container"), n = r.filter(function(a, o) {
+            return o === r.size() - 1;
+          }).selectAll(".gl-canvas-context, .gl-canvas-focus");
+          function i() {
+            var a = this, o = a.toDataURL("image/png"), s = t.append("svg:image");
+            s.attr({ xmlns: D0t.svg, "xlink:href": o, preserveAspectRatio: "none", x: 0, y: 0, width: a.style.width, height: a.style.height });
+          }
+          n.each(i);
+        };
+        xv.updateFx = WN().updateFx;
+      });
+      var wpe = ye((Fsr, bpe) => {
+        var xI = Ru();
+        bpe.exports = { hasLines: xI.hasLines, hasMarkers: xI.hasMarkers, hasText: xI.hasText, isBubble: xI.isBubble, attributes: pf(), layoutAttributes: tL(), supplyDefaults: Xde(), crossTraceDefaults: cU(), supplyLayoutDefaults: Jde(), calc: q0().calc, crossTraceCalc: wve(), arraysToCalcdata: Rm(), plot: dT(), colorbar: $d(), formatLabels: lI(), style: sp().style, styleOnSelect: sp().styleOnSelect, hoverPoints: mT(), selectPoints: yT(), animatable: true, moduleType: "trace", name: "scatter", basePlotModule: mh(), categories: ["cartesian", "svg", "symbols", "errorBarsOK", "showLegend", "scatter-like", "zoomScale"], meta: {} };
+      });
+      var Spe = ye((zsr, Ape) => {
+        var z0t = Oa(), O0t = ka(), Tpe = ON(), FU = Dr(), q0t = FU.strScale, B0t = FU.strRotate, N0t = FU.strTranslate;
+        Ape.exports = function(t, r, n) {
+          var i = t.node(), a = Tpe[n.arrowhead || 0], o = Tpe[n.startarrowhead || 0], s = (n.arrowwidth || 1) * (n.arrowsize || 1), l = (n.arrowwidth || 1) * (n.startarrowsize || 1), u = r.indexOf("start") >= 0, c = r.indexOf("end") >= 0, f = a.backoff * s + n.standoff, h = o.backoff * l + n.startstandoff, d, v, _, b;
+          if (i.nodeName === "line") {
+            d = { x: +t.attr("x1"), y: +t.attr("y1") }, v = { x: +t.attr("x2"), y: +t.attr("y2") };
+            var p = d.x - v.x, k = d.y - v.y;
+            if (_ = Math.atan2(k, p), b = _ + Math.PI, f && h && f + h > Math.sqrt(p * p + k * k)) {
+              U();
+              return;
+            }
+            if (f) {
+              if (f * f > p * p + k * k) {
+                U();
+                return;
+              }
+              var E = f * Math.cos(_), T = f * Math.sin(_);
+              v.x += E, v.y += T, t.attr({ x2: v.x, y2: v.y });
+            }
+            if (h) {
+              if (h * h > p * p + k * k) {
+                U();
+                return;
+              }
+              var L = h * Math.cos(_), x = h * Math.sin(_);
+              d.x -= L, d.y -= x, t.attr({ x1: d.x, y1: d.y });
+            }
+          } else if (i.nodeName === "path") {
+            var C = i.getTotalLength(), M = "";
+            if (C < f + h) {
+              U();
+              return;
+            }
+            var g = i.getPointAtLength(0), P = i.getPointAtLength(0.1);
+            _ = Math.atan2(g.y - P.y, g.x - P.x), d = i.getPointAtLength(Math.min(h, C)), M = "0px," + h + "px,";
+            var A = i.getPointAtLength(C), z = i.getPointAtLength(C - 0.1);
+            b = Math.atan2(A.y - z.y, A.x - z.x), v = i.getPointAtLength(Math.max(0, C - f));
+            var O = M ? h + f : f;
+            M += C - O + "px," + C + "px", t.style("stroke-dasharray", M);
+          }
+          function U() {
+            t.style("stroke-dasharray", "0px,100px");
+          }
+          function G(Z, j, N, H) {
+            Z.path && (Z.noRotate && (N = 0), z0t.select(i.parentNode).append("path").attr({ class: t.attr("class"), d: Z.path, transform: N0t(j.x, j.y) + B0t(N * 180 / Math.PI) + q0t(H) }).style({ fill: O0t.rgb(n.arrowcolor), "stroke-width": 0 }));
+          }
+          u && G(o, d, _, l), c && G(a, v, b, s);
+        };
+      });
+      var bI = ye((Osr, Lpe) => {
+        var Mpe = Oa(), zU = qa(), U0t = Mc(), E_ = Dr(), OU = E_.strTranslate, d4 = ho(), a2 = ka(), By = So(), Epe = vf(), qU = Zl(), BU = Eg(), h4 = yv(), V0t = vl().arrayEditor, G0t = Spe();
+        Lpe.exports = { draw: H0t, drawOne: kpe, drawRaw: Cpe };
+        function H0t(e) {
+          var t = e._fullLayout;
+          t._infolayer.selectAll(".annotation").remove();
+          for (var r = 0; r < t.annotations.length; r++) t.annotations[r].visible && kpe(e, r);
+          return U0t.previousPromises(e);
+        }
+        function kpe(e, t) {
+          var r = e._fullLayout, n = r.annotations[t] || {}, i = d4.getFromId(e, n.xref), a = d4.getFromId(e, n.yref);
+          i && i.setScale(), a && a.setScale(), Cpe(e, n, t, false, i, a);
+        }
+        function M_(e, t, r, n, i) {
+          var a = i[r], o = i[r + "ref"], s = r.indexOf("y") !== -1, l = d4.getRefType(o) === "domain", u = s ? n.h : n.w;
+          return e ? l ? a + (s ? -t : t) / e._length : e.p2r(e.r2p(a) + t) : a + (s ? -t : t) / u;
+        }
+        function Cpe(e, t, r, n, i, a) {
+          var o = e._fullLayout, s = e._fullLayout._size, l = e._context.edits, u, c;
+          n ? (u = "annotation-" + n, c = n + ".annotations") : (u = "annotation", c = "annotations");
+          var f = V0t(e.layout, c, t), h = f.modifyBase, d = f.modifyItem, v = f.getUpdateObj;
+          o._infolayer.selectAll("." + u + '[data-index="' + r + '"]').remove();
+          var _ = "clip" + o._uid + "_ann" + r;
+          if (!t._input || t.visible === false) {
+            Mpe.selectAll("#" + _).remove();
+            return;
+          }
+          var b = { x: {}, y: {} }, p = +t.textangle || 0, k = o._infolayer.append("g").classed(u, true).attr("data-index", String(r)).style("opacity", t.opacity), E = k.append("g").classed("annotation-text-g", true), T = l[t.showarrow ? "annotationTail" : "annotationPosition"], L = t.captureevents || l.annotationText || T;
+          function x(H) {
+            var re = { index: r, annotation: t._input, fullAnnotation: t, event: H };
+            return n && (re.subplotId = n), re;
+          }
+          var C = E.append("g").style("pointer-events", L ? "all" : null).call(BU, "pointer").on("click", function() {
+            e._dragging = false, e.emit("plotly_clickannotation", x(Mpe.event));
+          });
+          t.hovertext && C.on("mouseover", function() {
+            var H = t.hoverlabel, re = H.font, oe = this.getBoundingClientRect(), _e = e.getBoundingClientRect();
+            Epe.loneHover({ x0: oe.left - _e.left, x1: oe.right - _e.left, y: (oe.top + oe.bottom) / 2 - _e.top, text: t.hovertext, color: H.bgcolor, borderColor: H.bordercolor, fontFamily: re.family, fontSize: re.size, fontColor: re.color, fontWeight: re.weight, fontStyle: re.style, fontVariant: re.variant, fontShadow: re.fontShadow, fontLineposition: re.fontLineposition, fontTextcase: re.fontTextcase }, { container: o._hoverlayer.node(), outerContainer: o._paper.node(), gd: e });
+          }).on("mouseout", function() {
+            Epe.loneUnhover(o._hoverlayer.node());
+          });
+          var M = t.borderwidth, g = t.borderpad, P = M + g, A = C.append("rect").attr("class", "bg").style("stroke-width", M + "px").call(a2.stroke, t.bordercolor).call(a2.fill, t.bgcolor), z = t.width || t.height, O = o._topclips.selectAll("#" + _).data(z ? [0] : []);
+          O.enter().append("clipPath").classed("annclip", true).attr("id", _).append("rect"), O.exit().remove();
+          var U = t.font, G = o._meta ? E_.templateString(t.text, o._meta) : t.text, Z = C.append("text").classed("annotation-text", true).text(G);
+          function j(H) {
+            return H.call(By.font, U).attr({ "text-anchor": { left: "start", right: "end" }[t.align] || "middle" }), qU.convertToTspans(H, e, N), H;
+          }
+          function N() {
+            var H = Z.selectAll("a");
+            if (H.size() === 1 && H.text() === Z.text()) {
+              var re = C.insert("a", ":first-child").attr({ "xlink:xlink:href": H.attr("xlink:href"), "xlink:xlink:show": H.attr("xlink:show") }).style({ cursor: "pointer" });
+              re.node().appendChild(A.node());
+            }
+            var oe = C.select(".annotation-text-math-group"), _e = !oe.empty(), Ce = By.bBox((_e ? oe : Z).node()), Le = Ce.width, ge = Ce.height, ie = t.width || Le, Se = t.height || ge, Ee = Math.round(ie + 2 * P), Ae = Math.round(Se + 2 * P);
+            function Be(We, tt) {
+              return tt === "auto" && (We < 1 / 3 ? tt = "left" : We > 2 / 3 ? tt = "right" : tt = "center"), { center: 0, middle: 0, left: 0.5, bottom: -0.5, right: -0.5, top: 0.5 }[tt];
+            }
+            for (var Pe = false, me = ["x", "y"], De = 0; De < me.length; De++) {
+              var ce = me[De], je = t[ce + "ref"] || ce, lt = t["a" + ce + "ref"], pt = { x: i, y: a }[ce], Vt = (p + (ce === "x" ? 0 : -90)) * Math.PI / 180, ot = Ee * Math.cos(Vt), ut = Ae * Math.sin(Vt), Wt = Math.abs(ot) + Math.abs(ut), Nt = t[ce + "anchor"], $t = t[ce + "shift"] * (ce === "x" ? 1 : -1), sr = b[ce], Tr, fr, $e, St, Qt, Gt = d4.getRefType(je);
+              if (pt && Gt !== "domain") {
+                var _t = pt.r2fraction(t[ce]);
+                (_t < 0 || _t > 1) && (lt === je ? (_t = pt.r2fraction(t["a" + ce]), (_t < 0 || _t > 1) && (Pe = true)) : Pe = true), Tr = pt._offset + pt.r2p(t[ce]), St = 0.5;
+              } else {
+                var It = Gt === "domain";
+                ce === "x" ? ($e = t[ce], Tr = It ? pt._offset + pt._length * $e : Tr = s.l + s.w * $e) : ($e = 1 - t[ce], Tr = It ? pt._offset + pt._length * $e : Tr = s.t + s.h * $e), St = t.showarrow ? 0.5 : $e;
+              }
+              if (t.showarrow) {
+                sr.head = Tr;
+                var mt = t["a" + ce];
+                if (Qt = ot * Be(0.5, t.xanchor) - ut * Be(0.5, t.yanchor), lt === je) {
+                  var er = d4.getRefType(lt);
+                  er === "domain" ? (ce === "y" && (mt = 1 - mt), sr.tail = pt._offset + pt._length * mt) : er === "paper" ? ce === "y" ? (mt = 1 - mt, sr.tail = s.t + s.h * mt) : sr.tail = s.l + s.w * mt : sr.tail = pt._offset + pt.r2p(mt), fr = Qt;
+                } else sr.tail = Tr + mt, fr = Qt + mt;
+                sr.text = sr.tail + Qt;
+                var lr = o[ce === "x" ? "width" : "height"];
+                if (je === "paper" && (sr.head = E_.constrain(sr.head, 1, lr - 1)), lt === "pixel") {
+                  var wr = -Math.max(sr.tail - 3, sr.text), Lr = Math.min(sr.tail + 3, sr.text) - lr;
+                  wr > 0 ? (sr.tail += wr, sr.text += wr) : Lr > 0 && (sr.tail -= Lr, sr.text -= Lr);
+                }
+                sr.tail += $t, sr.head += $t;
+              } else Qt = Wt * Be(St, Nt), fr = Qt, sr.text = Tr + Qt;
+              sr.text += $t, Qt += $t, fr += $t, t["_" + ce + "padplus"] = Wt / 2 + fr, t["_" + ce + "padminus"] = Wt / 2 - fr, t["_" + ce + "size"] = Wt, t["_" + ce + "shift"] = Qt;
+            }
+            if (Pe) {
+              C.remove();
+              return;
+            }
+            var ti = 0, Br = 0;
+            if (t.align !== "left" && (ti = (ie - Le) * (t.align === "center" ? 0.5 : 1)), t.valign !== "top" && (Br = (Se - ge) * (t.valign === "middle" ? 0.5 : 1)), _e) oe.select("svg").attr({ x: P + ti - 1, y: P + Br }).call(By.setClipUrl, z ? _ : null, e);
+            else {
+              var Vr = P + Br - Ce.top, dt = P + ti - Ce.left;
+              Z.call(qU.positionText, dt, Vr).call(By.setClipUrl, z ? _ : null, e);
+            }
+            O.select("rect").call(By.setRect, P, P, ie, Se), A.call(By.setRect, M / 2, M / 2, Ee - M, Ae - M), C.call(By.setTranslate, Math.round(b.x.text - Ee / 2), Math.round(b.y.text - Ae / 2)), E.attr({ transform: "rotate(" + p + "," + b.x.text + "," + b.y.text + ")" });
+            var Ge = function(We, tt) {
+              k.selectAll(".annotation-arrow-g").remove();
+              var xt = b.x.head, Ie = b.y.head, xe = b.x.tail + We, ke = b.y.tail + tt, vt = b.x.text + We, ir = b.y.text + tt, ar = E_.rotationXYMatrix(p, vt, ir), vr = E_.apply2DTransform(ar), ii = E_.apply2DTransform2(ar), pi = +A.attr("width"), $r = +A.attr("height"), di = vt - 0.5 * pi, ji = di + pi, In = ir - 0.5 * $r, wi = In + $r, On = [[di, In, di, wi], [di, wi, ji, wi], [ji, wi, ji, In], [ji, In, di, In]].map(ii);
+              if (!On.reduce(function(Qr, Oi) {
+                return Qr ^ !!E_.segmentsIntersect(xt, Ie, xt + 1e6, Ie + 1e6, Oi[0], Oi[1], Oi[2], Oi[3]);
+              }, false)) {
+                On.forEach(function(Qr) {
+                  var Oi = E_.segmentsIntersect(xe, ke, xt, Ie, Qr[0], Qr[1], Qr[2], Qr[3]);
+                  Oi && (xe = Oi.x, ke = Oi.y);
+                });
+                var qn = t.arrowwidth, Fn = t.arrowcolor, ra = t.arrowside, la = k.append("g").style({ opacity: a2.opacity(Fn) }).classed("annotation-arrow-g", true), Ut = la.append("path").attr("d", "M" + xe + "," + ke + "L" + xt + "," + Ie).style("stroke-width", qn + "px").call(a2.stroke, a2.rgb(Fn));
+                if (G0t(Ut, ra, t), l.annotationPosition && Ut.node().parentNode && !n) {
+                  var wt = xt, rr = Ie;
+                  if (t.standoff) {
+                    var nr = Math.sqrt(Math.pow(xt - xe, 2) + Math.pow(Ie - ke, 2));
+                    wt += t.standoff * (xe - xt) / nr, rr += t.standoff * (ke - Ie) / nr;
+                  }
+                  var Er = la.append("path").classed("annotation-arrow", true).classed("anndrag", true).classed("cursor-move", true).attr({ d: "M3,3H-3V-3H3ZM0,0L" + (xe - wt) + "," + (ke - rr), transform: OU(wt, rr) }).style("stroke-width", qn + 6 + "px").call(a2.stroke, "rgba(0,0,0,0)").call(a2.fill, "rgba(0,0,0,0)"), Xr, ri;
+                  h4.init({ element: Er.node(), gd: e, prepFn: function() {
+                    var Qr = By.getTranslate(C);
+                    Xr = Qr.x, ri = Qr.y, i && i.autorange && h(i._name + ".autorange", true), a && a.autorange && h(a._name + ".autorange", true);
+                  }, moveFn: function(Qr, Oi) {
+                    var $i = vr(Xr, ri), tn = $i[0] + Qr, fn = $i[1] + Oi;
+                    C.call(By.setTranslate, tn, fn), d("x", M_(i, Qr, "x", s, t)), d("y", M_(a, Oi, "y", s, t)), t.axref === t.xref && d("ax", M_(i, Qr, "ax", s, t)), t.ayref === t.yref && d("ay", M_(a, Oi, "ay", s, t)), la.attr("transform", OU(Qr, Oi)), E.attr({ transform: "rotate(" + p + "," + tn + "," + fn + ")" });
+                  }, doneFn: function() {
+                    zU.call("_guiRelayout", e, v());
+                    var Qr = document.querySelector(".js-notes-box-panel");
+                    Qr && Qr.redraw(Qr.selectedObj);
+                  } });
+                }
+              }
+            };
+            if (t.showarrow && Ge(0, 0), T) {
+              var Je;
+              h4.init({ element: C.node(), gd: e, prepFn: function() {
+                Je = E.attr("transform");
+              }, moveFn: function(We, tt) {
+                var xt = "pointer";
+                if (t.showarrow) t.axref === t.xref ? d("ax", M_(i, We, "ax", s, t)) : d("ax", t.ax + We), t.ayref === t.yref ? d("ay", M_(a, tt, "ay", s.w, t)) : d("ay", t.ay + tt), Ge(We, tt);
+                else {
+                  if (n) return;
+                  var Ie, xe;
+                  if (i) Ie = M_(i, We, "x", s, t);
+                  else {
+                    var ke = t._xsize / s.w, vt = t.x + (t._xshift - t.xshift) / s.w - ke / 2;
+                    Ie = h4.align(vt + We / s.w, ke, 0, 1, t.xanchor);
+                  }
+                  if (a) xe = M_(a, tt, "y", s, t);
+                  else {
+                    var ir = t._ysize / s.h, ar = t.y - (t._yshift + t.yshift) / s.h - ir / 2;
+                    xe = h4.align(ar - tt / s.h, ir, 0, 1, t.yanchor);
+                  }
+                  d("x", Ie), d("y", xe), (!i || !a) && (xt = h4.getCursor(i ? 0.5 : Ie, a ? 0.5 : xe, t.xanchor, t.yanchor));
+                }
+                E.attr({ transform: OU(We, tt) + Je }), BU(C, xt);
+              }, clickFn: function(We, tt) {
+                t.captureevents && e.emit("plotly_clickannotation", x(tt));
+              }, doneFn: function() {
+                BU(C), zU.call("_guiRelayout", e, v());
+                var We = document.querySelector(".js-notes-box-panel");
+                We && We.redraw(We.selectedObj);
+              } });
+            }
+          }
+          l.annotationText ? Z.call(qU.makeEditable, { delegate: C, gd: e }).call(j).on("edit", function(H) {
+            t.text = H, this.call(j), d("text", H), i && i.autorange && h(i._name + ".autorange", true), a && a.autorange && h(a._name + ".autorange", true), zU.call("_guiRelayout", e, v());
+          }) : Z.call(j);
+        }
+      });
+      var zpe = ye((qsr, Fpe) => {
+        var Ppe = Dr(), j0t = qa(), Ipe = vl().arrayEditor;
+        Fpe.exports = { hasClickToShow: W0t, onClick: X0t };
+        function W0t(e, t) {
+          var r = Dpe(e, t);
+          return r.on.length > 0 || r.explicitOff.length > 0;
+        }
+        function X0t(e, t) {
+          var r = Dpe(e, t), n = r.on, i = r.off.concat(r.explicitOff), a = {}, o = e._fullLayout.annotations, s, l;
+          if (n.length || i.length) {
+            for (s = 0; s < n.length; s++) l = Ipe(e.layout, "annotations", o[n[s]]), l.modifyItem("visible", true), Ppe.extendFlat(a, l.getUpdateObj());
+            for (s = 0; s < i.length; s++) l = Ipe(e.layout, "annotations", o[i[s]]), l.modifyItem("visible", false), Ppe.extendFlat(a, l.getUpdateObj());
+            return j0t.call("update", e, {}, a);
+          }
+        }
+        function Dpe(e, t) {
+          var r = e._fullLayout.annotations, n = [], i = [], a = [], o = (t || []).length, s, l, u, c, f, h, d, v;
+          for (s = 0; s < r.length; s++) if (u = r[s], c = u.clicktoshow, c) {
+            for (l = 0; l < o; l++) if (f = t[l], h = f.xaxis, d = f.yaxis, h._id === u.xref && d._id === u.yref && h.d2r(f.x) === Rpe(u._xclick, h) && d.d2r(f.y) === Rpe(u._yclick, d)) {
+              u.visible ? c === "onout" ? v = i : v = a : v = n, v.push(s);
+              break;
+            }
+            l === o && u.visible && c === "onout" && i.push(s);
+          }
+          return { on: n, off: i, explicitOff: a };
+        }
+        function Rpe(e, t) {
+          return t.type === "log" ? t.l2r(e) : t.d2r(e);
+        }
+      });
+      var UU = ye((Bsr, Ope) => {
+        var NU = Dr(), _T = ka();
+        Ope.exports = function(t, r, n, i) {
+          i("opacity");
+          var a = i("bgcolor"), o = i("bordercolor"), s = _T.opacity(o);
+          i("borderpad");
+          var l = i("borderwidth"), u = i("showarrow");
+          i("text", u ? " " : n._dfltTitle.annotation), i("textangle"), NU.coerceFont(i, "font", n.font), i("width"), i("align");
+          var c = i("height");
+          if (c && i("valign"), u) {
+            var f = i("arrowside"), h, d;
+            f.indexOf("end") !== -1 && (h = i("arrowhead"), d = i("arrowsize")), f.indexOf("start") !== -1 && (i("startarrowhead", h), i("startarrowsize", d)), i("arrowcolor", s ? r.bordercolor : _T.defaultLine), i("arrowwidth", (s && l || 1) * 2), i("standoff"), i("startstandoff");
+          }
+          var v = i("hovertext"), _ = n.hoverlabel || {};
+          if (v) {
+            var b = i("hoverlabel.bgcolor", _.bgcolor || (_T.opacity(a) ? _T.rgb(a) : _T.defaultLine)), p = i("hoverlabel.bordercolor", _.bordercolor || _T.contrast(b)), k = NU.extendFlat({}, _.font);
+            k.color || (k.color = p), NU.coerceFont(i, "hoverlabel.font", k);
+          }
+          i("captureevents", !!v);
+        };
+      });
+      var Bpe = ye((Nsr, qpe) => {
+        var VU = Dr(), o2 = ho(), Z0t = Zd(), Y0t = UU(), K0t = Jb();
+        qpe.exports = function(t, r) {
+          Z0t(t, r, { name: "annotations", handleItemDefaults: J0t });
+        };
+        function J0t(e, t, r) {
+          function n(E, T) {
+            return VU.coerce(e, t, K0t, E, T);
+          }
+          var i = n("visible"), a = n("clicktoshow");
+          if (i || a) {
+            Y0t(e, t, r, n);
+            for (var o = t.showarrow, s = ["x", "y"], l = [-10, -30], u = { _fullLayout: r }, c = 0; c < 2; c++) {
+              var f = s[c], h = o2.coerceRef(e, t, u, f, "", "paper");
+              if (h !== "paper") {
+                var d = o2.getFromId(u, h);
+                d._annIndices.push(t._index);
+              }
+              if (o2.coercePosition(t, u, n, h, f, 0.5), o) {
+                var v = "a" + f, _ = o2.coerceRef(e, t, u, v, "pixel", ["pixel", "paper"]);
+                _ !== "pixel" && _ !== h && (_ = t[v] = "pixel");
+                var b = _ === "pixel" ? l[c] : 0.4;
+                o2.coercePosition(t, u, n, _, v, b);
+              }
+              n(f + "anchor"), n(f + "shift");
+            }
+            if (VU.noneOrAll(e, t, ["x", "y"]), o && VU.noneOrAll(e, t, ["ax", "ay"]), a) {
+              var p = n("xclick"), k = n("yclick");
+              t._xclick = p === void 0 ? t.x : o2.cleanPosition(p, u, t.xref), t._yclick = k === void 0 ? t.y : o2.cleanPosition(k, u, t.yref);
+            }
+          }
+        }
+      });
+      var Vpe = ye((Usr, Upe) => {
+        var GU = Dr(), s2 = ho(), $0t = bI().draw;
+        Upe.exports = function(t) {
+          var r = t._fullLayout, n = GU.filterVisible(r.annotations);
+          if (n.length && t._fullData.length) return GU.syncOrAsync([$0t, Q0t], t);
+        };
+        function Q0t(e) {
+          var t = e._fullLayout;
+          GU.filterVisible(t.annotations).forEach(function(r) {
+            var n = s2.getFromId(e, r.xref), i = s2.getFromId(e, r.yref), a = s2.getRefType(r.xref), o = s2.getRefType(r.yref);
+            r._extremes = {}, a === "range" && Npe(r, n), o === "range" && Npe(r, i);
+          });
+        }
+        function Npe(e, t) {
+          var r = t._id, n = r.charAt(0), i = e[n], a = e["a" + n], o = e[n + "ref"], s = e["a" + n + "ref"], l = e["_" + n + "padplus"], u = e["_" + n + "padminus"], c = { x: 1, y: -1 }[n] * e[n + "shift"], f = 3 * e.arrowsize * e.arrowwidth || 0, h = f + c, d = f - c, v = 3 * e.startarrowsize * e.arrowwidth || 0, _ = v + c, b = v - c, p;
+          if (s === o) {
+            var k = s2.findExtremes(t, [t.r2c(i)], { ppadplus: h, ppadminus: d }), E = s2.findExtremes(t, [t.r2c(a)], { ppadplus: Math.max(l, _), ppadminus: Math.max(u, b) });
+            p = { min: [k.min[0], E.min[0]], max: [k.max[0], E.max[0]] };
+          } else _ = a ? _ + a : _, b = a ? b - a : b, p = s2.findExtremes(t, [t.r2c(i)], { ppadplus: Math.max(l, h, _), ppadminus: Math.max(u, d, b) });
+          e._extremes[r] = p;
+        }
+      });
+      var Hpe = ye((Vsr, Gpe) => {
+        var egt = Eo(), tgt = S6();
+        Gpe.exports = function(t, r, n, i) {
+          r = r || {};
+          var a = n === "log" && r.type === "linear", o = n === "linear" && r.type === "log";
+          if (!(a || o)) return;
+          var s = t._fullLayout.annotations, l = r._id.charAt(0), u, c;
+          function f(d) {
+            var v = u[d], _ = null;
+            a ? _ = tgt(v, r.range) : _ = Math.pow(10, v), egt(_) || (_ = null), i(c + d, _);
+          }
+          for (var h = 0; h < s.length; h++) u = s[h], c = "annotations[" + h + "].", u[l + "ref"] === r._id && f(l), u["a" + l + "ref"] === r._id && f("a" + l);
+        };
+      });
+      var Xpe = ye((Gsr, Wpe) => {
+        var HU = bI(), jpe = zpe();
+        Wpe.exports = { moduleType: "component", name: "annotations", layoutAttributes: Jb(), supplyLayoutDefaults: Bpe(), includeBasePlot: WM()("annotations"), calcAutorange: Vpe(), draw: HU.draw, drawOne: HU.drawOne, drawRaw: HU.drawRaw, hasClickToShow: jpe.hasClickToShow, onClick: jpe.onClick, convertCoords: Hpe() };
+      });
+      var wI = ye((Hsr, Zpe) => {
+        var kc = Jb(), rgt = mc().overrideAll, igt = vl().templatedArray;
+        Zpe.exports = rgt(igt("annotation", { visible: kc.visible, x: { valType: "any" }, y: { valType: "any" }, z: { valType: "any" }, ax: { valType: "number" }, ay: { valType: "number" }, xanchor: kc.xanchor, xshift: kc.xshift, yanchor: kc.yanchor, yshift: kc.yshift, text: kc.text, textangle: kc.textangle, font: kc.font, width: kc.width, height: kc.height, opacity: kc.opacity, align: kc.align, valign: kc.valign, bgcolor: kc.bgcolor, bordercolor: kc.bordercolor, borderpad: kc.borderpad, borderwidth: kc.borderwidth, showarrow: kc.showarrow, arrowcolor: kc.arrowcolor, arrowhead: kc.arrowhead, startarrowhead: kc.startarrowhead, arrowside: kc.arrowside, arrowsize: kc.arrowsize, startarrowsize: kc.startarrowsize, arrowwidth: kc.arrowwidth, standoff: kc.standoff, startstandoff: kc.startstandoff, hovertext: kc.hovertext, hoverlabel: kc.hoverlabel, captureevents: kc.captureevents }), "calc", "from-root");
+      });
+      var Kpe = ye((jsr, Ype) => {
+        var jU = Dr(), ngt = ho(), agt = Zd(), ogt = UU(), sgt = wI();
+        Ype.exports = function(t, r, n) {
+          agt(t, r, { name: "annotations", handleItemDefaults: lgt, fullLayout: n.fullLayout });
+        };
+        function lgt(e, t, r, n) {
+          function i(s, l) {
+            return jU.coerce(e, t, sgt, s, l);
+          }
+          function a(s) {
+            var l = s + "axis", u = { _fullLayout: {} };
+            return u._fullLayout[l] = r[l], ngt.coercePosition(t, u, i, s, s, 0.5);
+          }
+          var o = i("visible");
+          o && (ogt(e, t, n.fullLayout, i), a("x"), a("y"), a("z"), jU.noneOrAll(e, t, ["x", "y", "z"]), t.xref = "x", t.yref = "y", t.zref = "z", i("xanchor"), i("yanchor"), i("xshift"), i("yshift"), t.showarrow && (t.axref = "pixel", t.ayref = "pixel", i("ax", -10), i("ay", -30), jU.noneOrAll(e, t, ["ax", "ay"])));
+        }
+      });
+      var e0e = ye((Wsr, Qpe) => {
+        var Jpe = Dr(), $pe = ho();
+        Qpe.exports = function(t) {
+          for (var r = t.fullSceneLayout, n = r.annotations, i = 0; i < n.length; i++) ugt(n[i], t);
+          t.fullLayout._infolayer.selectAll(".annotation-" + t.id).remove();
+        };
+        function ugt(e, t) {
+          var r = t.fullSceneLayout, n = r.domain, i = t.fullLayout._size, a = { pdata: null, type: "linear", autorange: false, range: [-1 / 0, 1 / 0] };
+          e._xa = {}, Jpe.extendFlat(e._xa, a), $pe.setConvert(e._xa), e._xa._offset = i.l + n.x[0] * i.w, e._xa.l2p = function() {
+            return 0.5 * (1 + e._pdata[0] / e._pdata[3]) * i.w * (n.x[1] - n.x[0]);
+          }, e._ya = {}, Jpe.extendFlat(e._ya, a), $pe.setConvert(e._ya), e._ya._offset = i.t + (1 - n.y[1]) * i.h, e._ya.l2p = function() {
+            return 0.5 * (1 - e._pdata[1] / e._pdata[3]) * i.h * (n.y[1] - n.y[0]);
+          };
+        }
+      });
+      var XU = ye((Xsr, t0e) => {
+        function WU(e, t) {
+          var r = [0, 0, 0, 0], n, i;
+          for (n = 0; n < 4; ++n) for (i = 0; i < 4; ++i) r[i] += e[4 * n + i] * t[n];
+          return r;
+        }
+        function cgt(e, t) {
+          var r = WU(e.projection, WU(e.view, WU(e.model, [t[0], t[1], t[2], 1])));
+          return r;
+        }
+        t0e.exports = cgt;
+      });
+      var i0e = ye((Zsr, r0e) => {
+        var fgt = bI().drawRaw, hgt = XU(), dgt = ["x", "y", "z"];
+        r0e.exports = function(t) {
+          for (var r = t.fullSceneLayout, n = t.dataScale, i = r.annotations, a = 0; a < i.length; a++) {
+            for (var o = i[a], s = false, l = 0; l < 3; l++) {
+              var u = dgt[l], c = o[u], f = r[u + "axis"], h = f.r2fraction(c);
+              if (h < 0 || h > 1) {
+                s = true;
+                break;
+              }
+            }
+            s ? t.fullLayout._infolayer.select(".annotation-" + t.id + '[data-index="' + a + '"]').remove() : (o._pdata = hgt(t.glplot.cameraParams, [r.xaxis.r2l(o.x) * n[0], r.yaxis.r2l(o.y) * n[1], r.zaxis.r2l(o.z) * n[2]]), fgt(t.graphDiv, o, a, t.id, o._xa, o._ya));
+          }
+        };
+      });
+      var o0e = ye((Ysr, a0e) => {
+        var vgt = qa(), n0e = Dr();
+        a0e.exports = { moduleType: "component", name: "annotations3d", schema: { subplots: { scene: { annotations: wI() } } }, layoutAttributes: wI(), handleDefaults: Kpe(), includeBasePlot: pgt, convert: e0e(), draw: i0e() };
+        function pgt(e, t) {
+          var r = vgt.subplotsRegistry.gl3d;
+          if (r) for (var n = r.attrRegex, i = Object.keys(e), a = 0; a < i.length; a++) {
+            var o = i[a];
+            n.test(o) && (e[o].annotations || []).length && (n0e.pushUnique(t._basePlotModules, r), n0e.pushUnique(t._subplots.gl3d, o));
+          }
+        }
+      });
+      var ZU = ye(($sr, c0e) => {
+        Rh();
+        var s0e = ec(), l0e = pf().line, ggt = Pd().dash, Bg = Ao().extendFlat, mgt = vl().templatedArray;
+        HM();
+        var xT = Gl(), u0e = Jb(), { shapeTexttemplateAttrs: ygt, templatefallbackAttrs: _gt } = Ll(), xgt = D6();
+        c0e.exports = mgt("shape", { visible: Bg({}, xT.visible, { editType: "calc+arraydraw" }), showlegend: { valType: "boolean", dflt: false, editType: "calc+arraydraw" }, legend: Bg({}, xT.legend, { editType: "calc+arraydraw" }), legendgroup: Bg({}, xT.legendgroup, { editType: "calc+arraydraw" }), legendgrouptitle: { text: Bg({}, xT.legendgrouptitle.text, { editType: "calc+arraydraw" }), font: s0e({ editType: "calc+arraydraw" }), editType: "calc+arraydraw" }, legendrank: Bg({}, xT.legendrank, { editType: "calc+arraydraw" }), legendwidth: Bg({}, xT.legendwidth, { editType: "calc+arraydraw" }), type: { valType: "enumerated", values: ["circle", "rect", "path", "line"], editType: "calc+arraydraw" }, layer: { valType: "enumerated", values: ["below", "above", "between"], dflt: "above", editType: "arraydraw" }, xref: Bg({}, u0e.xref, { arrayOk: true }), xsizemode: { valType: "enumerated", values: ["scaled", "pixel"], dflt: "scaled", editType: "calc+arraydraw" }, xanchor: { valType: "any", editType: "calc+arraydraw" }, x0: { valType: "any", editType: "calc+arraydraw" }, x1: { valType: "any", editType: "calc+arraydraw" }, x0shift: { valType: "number", dflt: 0, min: -1, max: 1, editType: "calc" }, x1shift: { valType: "number", dflt: 0, min: -1, max: 1, editType: "calc" }, yref: Bg({}, u0e.yref, { arrayOk: true }), ysizemode: { valType: "enumerated", values: ["scaled", "pixel"], dflt: "scaled", editType: "calc+arraydraw" }, yanchor: { valType: "any", editType: "calc+arraydraw" }, y0: { valType: "any", editType: "calc+arraydraw" }, y1: { valType: "any", editType: "calc+arraydraw" }, y0shift: { valType: "number", dflt: 0, min: -1, max: 1, editType: "calc" }, y1shift: { valType: "number", dflt: 0, min: -1, max: 1, editType: "calc" }, path: { valType: "string", editType: "calc+arraydraw" }, opacity: { valType: "number", min: 0, max: 1, dflt: 1, editType: "arraydraw" }, line: { color: Bg({}, l0e.color, { editType: "arraydraw" }), width: Bg({}, l0e.width, { editType: "calc+arraydraw" }), dash: Bg({}, ggt, { editType: "arraydraw" }), editType: "calc+arraydraw" }, fillcolor: { valType: "color", dflt: "rgba(0,0,0,0)", editType: "arraydraw" }, fillrule: { valType: "enumerated", values: ["evenodd", "nonzero"], dflt: "evenodd", editType: "arraydraw" }, editable: { valType: "boolean", dflt: false, editType: "calc+arraydraw" }, label: { text: { valType: "string", dflt: "", editType: "arraydraw" }, texttemplate: ygt({}, { keys: Object.keys(xgt) }), texttemplatefallback: _gt({ editType: "arraydraw" }), font: s0e({ editType: "calc+arraydraw", colorEditType: "arraydraw" }), textposition: { valType: "enumerated", values: ["top left", "top center", "top right", "middle left", "middle center", "middle right", "bottom left", "bottom center", "bottom right", "start", "middle", "end"], editType: "arraydraw" }, textangle: { valType: "angle", dflt: "auto", editType: "calc+arraydraw" }, xanchor: { valType: "enumerated", values: ["auto", "left", "center", "right"], dflt: "auto", editType: "calc+arraydraw" }, yanchor: { valType: "enumerated", values: ["top", "middle", "bottom"], editType: "calc+arraydraw" }, padding: { valType: "number", dflt: 3, min: 0, editType: "arraydraw" }, editType: "arraydraw" }, editType: "arraydraw" });
+      });
+      var h0e = ye((Qsr, f0e) => {
+        var bT = Dr(), e0 = ho(), bgt = Zd(), wgt = ZU(), v4 = x_();
+        f0e.exports = function(t, r) {
+          bgt(t, r, { name: "shapes", handleItemDefaults: Agt });
+        };
+        function Tgt(e, t) {
+          return e ? "bottom" : t.indexOf("top") !== -1 ? "top" : t.indexOf("bottom") !== -1 ? "bottom" : "middle";
+        }
+        function Agt(e, t, r) {
+          function n(E, T) {
+            return bT.coerce(e, t, wgt, E, T);
+          }
+          t._isShape = true;
+          var i = n("visible");
+          if (!i) return;
+          var a = n("showlegend");
+          a && (n("legend"), n("legendwidth"), n("legendgroup"), n("legendgrouptitle.text"), bT.coerceFont(n, "legendgrouptitle.font"), n("legendrank"));
+          var o = n("path"), s = o ? "path" : "rect", l = n("type", s), u = l !== "path";
+          u && delete t.path, n("editable"), n("layer"), n("opacity"), n("fillcolor"), n("fillrule");
+          var c = n("line.width");
+          c && (n("line.color"), n("line.dash"));
+          var f = n("xsizemode"), h = n("ysizemode");
+          let d = [0.25, 0.75], v = [0, 10];
+          ["x", "y"].forEach((E) => {
+            var T = E + "anchor", L = E === "x" ? f : h, x = { _fullLayout: r }, C, M, g, P;
+            let A = E + "ref", z = e[A];
+            if (Array.isArray(z) && z.length > 0) {
+              let O = v4.countDefiningCoords(l, o, E);
+              P = e0.coerceRefArray(e, t, x, E, void 0, "paper", O), t["_" + E + "refArray"] = true;
+            } else P = e0.coerceRef(e, t, x, E, void 0, "paper");
+            if (Array.isArray(P)) P.forEach(function(O) {
+              e0.getRefType(O) === "range" && (C = e0.getFromId(x, O), C && C._shapeIndices.indexOf(t._index) === -1 && C._shapeIndices.push(t._index));
+            }), u && [0, 1].forEach(function(O) {
+              let U = P[O];
+              e0.getRefType(U) === "range" ? (C = e0.getFromId(x, U), M = v4.shapePositionToRange(C), g = v4.rangeToShapePosition(C), (C.type === "category" || C.type === "multicategory") && n(E + O + "shift")) : M = g = bT.identity;
+              let Z = E + O, j = e[Z];
+              if (e[Z] = M(e[Z], true), L === "pixel" ? n(Z, v[O]) : e0.coercePosition(t, x, n, U, Z, d[O]), t[Z] = g(t[Z]), e[Z] = j, O === 0 && L === "pixel") {
+                let N = e[T];
+                e[T] = M(e[T], true), e0.coercePosition(t, x, n, U, T, 0.25), t[T] = g(t[T]), e[T] = N;
+              }
+            });
+            else {
+              if (e0.getRefType(P) === "range" ? (C = e0.getFromId(x, P), C._shapeIndices.push(t._index), g = v4.rangeToShapePosition(C), M = v4.shapePositionToRange(C), u && (C.type === "category" || C.type === "multicategory") && (n(E + "0shift"), n(E + "1shift"))) : M = g = bT.identity, u) {
+                let U = E + "0", G = E + "1", Z = e[U], j = e[G];
+                e[U] = M(e[U], true), e[G] = M(e[G], true), L === "pixel" ? (n(U, v[0]), n(G, v[1])) : (e0.coercePosition(t, x, n, P, U, d[0]), e0.coercePosition(t, x, n, P, G, d[1])), t[U] = g(t[U]), t[G] = g(t[G]), e[U] = Z, e[G] = j;
+              }
+              if (L === "pixel") {
+                let U = e[T];
+                e[T] = M(e[T], true), e0.coercePosition(t, x, n, P, T, 0.25), t[T] = g(t[T]), e[T] = U;
+              }
+            }
+          }), u && bT.noneOrAll(e, t, ["x0", "x1", "y0", "y1"]);
+          var _ = l === "line", b, p;
+          if (u && (b = n("label.texttemplate"), n("label.texttemplatefallback")), b || (p = n("label.text")), p || b) {
+            n("label.textangle");
+            var k = n("label.textposition", _ ? "middle" : "middle center");
+            n("label.xanchor"), n("label.yanchor", Tgt(_, k)), n("label.padding"), bT.coerceFont(n, "label.font", r.font);
+          }
+        }
+      });
+      var p0e = ye((elr, v0e) => {
+        var Sgt = ka(), d0e = Dr();
+        function Mgt(e, t) {
+          return e ? "bottom" : t.indexOf("top") !== -1 ? "top" : t.indexOf("bottom") !== -1 ? "bottom" : "middle";
+        }
+        v0e.exports = function(t, r, n) {
+          n("newshape.visible"), n("newshape.name"), n("newshape.showlegend"), n("newshape.legend"), n("newshape.legendwidth"), n("newshape.legendgroup"), n("newshape.legendgrouptitle.text"), d0e.coerceFont(n, "newshape.legendgrouptitle.font"), n("newshape.legendrank"), n("newshape.drawdirection"), n("newshape.layer"), n("newshape.fillcolor"), n("newshape.fillrule"), n("newshape.opacity");
+          var i = n("newshape.line.width");
+          if (i) {
+            var a = (t || {}).plot_bgcolor || "#FFF";
+            n("newshape.line.color", Sgt.contrast(a)), n("newshape.line.dash");
+          }
+          var o = t.dragmode === "drawline", s = n("newshape.label.text"), l = n("newshape.label.texttemplate");
+          if (n("newshape.label.texttemplatefallback"), s || l) {
+            n("newshape.label.textangle");
+            var u = n("newshape.label.textposition", o ? "middle" : "middle center");
+            n("newshape.label.xanchor"), n("newshape.label.yanchor", Mgt(o, u)), n("newshape.label.padding"), d0e.coerceFont(n, "newshape.label.font", r.font);
+          }
+          n("activeshape.fillcolor"), n("activeshape.opacity");
+        };
+      });
+      var w0e = ye((tlr, b0e) => {
+        var YU = Dr(), N0 = ho(), Fm = TM(), KU = x_();
+        b0e.exports = function(t) {
+          var r = t._fullLayout, n = YU.filterVisible(r.shapes);
+          if (!(!n.length || !t._fullData.length)) for (var i = 0; i < n.length; i++) {
+            var a = n[i];
+            a._extremes = {};
+            var o, s, l = N0.getRefType(a.xref), u = N0.getRefType(a.yref);
+            if (l === "array") {
+              let c = g0e(t, a, "x");
+              Object.entries(c).forEach(([f, h]) => {
+                o = N0.getFromId(t, f), a._extremes[o._id] = N0.findExtremes(o, h, m0e(a));
+              });
+            } else a.xref !== "paper" && l !== "domain" && (o = N0.getFromId(t, a.xref), s = _0e(o, a, Fm.paramIsX), s && (a._extremes[o._id] = N0.findExtremes(o, s, m0e(a))));
+            if (u === "array") {
+              let c = g0e(t, a, "y");
+              Object.entries(c).forEach(([f, h]) => {
+                o = N0.getFromId(t, f), a._extremes[o._id] = N0.findExtremes(o, h, y0e(a));
+              });
+            } else a.yref !== "paper" && u !== "domain" && (o = N0.getFromId(t, a.yref), s = _0e(o, a, Fm.paramIsY), s && (a._extremes[o._id] = N0.findExtremes(o, s, y0e(a))));
+          }
+        };
+        function g0e(e, t, r) {
+          let n = t[r + "ref"], i = r === "x" ? Fm.paramIsX : Fm.paramIsY;
+          function a(f, h) {
+            f === "paper" || N0.getRefType(f) === "domain" || (o[f] || (o[f] = []), o[f].push(h));
+          }
+          let o = {};
+          if (t.type === "path" && t.path) {
+            let f = t.path.match(Fm.segmentRE) || [];
+            for (var s = 0, l = 0; l < f.length; l++) {
+              let h = f[l], d = h.charAt(0), v = i[d].drawn;
+              if (v === void 0) continue;
+              let _ = h.slice(1).match(Fm.paramRE);
+              _ && _.length > v && (a(n[s], _[v]), s++);
+            }
+          } else a(n[0], t[r + "0"]), a(n[1], t[r + "1"]);
+          let u = {};
+          for (let f in o) {
+            let h = N0.getFromId(e, f);
+            if (h) {
+              var c = h.type === "category" || h.type === "multicategory" ? h.r2c : h.d2c;
+              h.type === "date" && (c = KU.decodeDate(c)), u[h._id] = o[f].map(c);
+            }
+          }
+          return u;
+        }
+        function m0e(e) {
+          return x0e(e.line.width, e.xsizemode, e.x0, e.x1, e.path, false);
+        }
+        function y0e(e) {
+          return x0e(e.line.width, e.ysizemode, e.y0, e.y1, e.path, true);
+        }
+        function x0e(e, t, r, n, i, a) {
+          var o = e / 2, s = a;
+          if (t === "pixel") {
+            var l = i ? KU.extractPathCoords(i, a ? Fm.paramIsY : Fm.paramIsX) : [r, n], u = YU.aggNums(Math.max, null, l), c = YU.aggNums(Math.min, null, l), f = c < 0 ? Math.abs(c) + o : o, h = u > 0 ? u + o : o;
+            return { ppad: o, ppadplus: s ? f : h, ppadminus: s ? h : f };
+          } else return { ppad: o };
+        }
+        function _0e(e, t, r) {
+          var n = e._id.charAt(0) === "x" ? "x" : "y", i = e.type === "category" || e.type === "multicategory", a, o, s = 0, l = 0, u = i ? e.r2c : e.d2c, c = t[n + "sizemode"] === "scaled";
+          if (c ? (a = t[n + "0"], o = t[n + "1"], i && (s = t[n + "0shift"], l = t[n + "1shift"])) : (a = t[n + "anchor"], o = t[n + "anchor"]), a !== void 0) return [u(a) + s, u(o) + l];
+          if (t.path) {
+            var f = 1 / 0, h = -1 / 0, d = t.path.match(Fm.segmentRE), v, _, b, p, k;
+            for (e.type === "date" && (u = KU.decodeDate(u)), v = 0; v < d.length; v++) _ = d[v], b = r[_.charAt(0)].drawn, b !== void 0 && (p = d[v].slice(1).match(Fm.paramRE), !(!p || p.length < b) && (k = u(p[b]), k < f && (f = k), k > h && (h = k)));
+            if (h >= f) return [f, h];
+          }
+        }
+      });
+      var S0e = ye((rlr, A0e) => {
+        var T0e = dP();
+        A0e.exports = { moduleType: "component", name: "shapes", layoutAttributes: ZU(), supplyLayoutDefaults: h0e(), supplyDrawNewShapeDefaults: p0e(), includeBasePlot: WM()("shapes"), calcAutorange: w0e(), draw: T0e.draw, drawOne: T0e.drawOne };
+      });
+      var JU = ye((nlr, E0e) => {
+        var M0e = Rh(), Egt = vl().templatedArray;
+        HM();
+        E0e.exports = Egt("image", { visible: { valType: "boolean", dflt: true, editType: "arraydraw" }, source: { valType: "string", editType: "arraydraw" }, layer: { valType: "enumerated", values: ["below", "above"], dflt: "above", editType: "arraydraw" }, sizex: { valType: "number", dflt: 0, editType: "arraydraw" }, sizey: { valType: "number", dflt: 0, editType: "arraydraw" }, sizing: { valType: "enumerated", values: ["fill", "contain", "stretch"], dflt: "contain", editType: "arraydraw" }, opacity: { valType: "number", min: 0, max: 1, dflt: 1, editType: "arraydraw" }, x: { valType: "any", dflt: 0, editType: "arraydraw" }, y: { valType: "any", dflt: 0, editType: "arraydraw" }, xanchor: { valType: "enumerated", values: ["left", "center", "right"], dflt: "left", editType: "arraydraw" }, yanchor: { valType: "enumerated", values: ["top", "middle", "bottom"], dflt: "top", editType: "arraydraw" }, xref: { valType: "enumerated", values: ["paper", M0e.idRegex.x.toString()], dflt: "paper", editType: "arraydraw" }, yref: { valType: "enumerated", values: ["paper", M0e.idRegex.y.toString()], dflt: "paper", editType: "arraydraw" }, editType: "arraydraw" });
+      });
+      var C0e = ye((alr, k0e) => {
+        var kgt = Dr(), $U = ho(), Cgt = Zd(), Lgt = JU(), Pgt = "images";
+        k0e.exports = function(t, r) {
+          var n = { name: Pgt, handleItemDefaults: Igt };
+          Cgt(t, r, n);
+        };
+        function Igt(e, t, r) {
+          function n(h, d) {
+            return kgt.coerce(e, t, Lgt, h, d);
+          }
+          var i = n("source"), a = n("visible", !!i);
+          if (!a) return t;
+          n("layer"), n("xanchor"), n("yanchor"), n("sizex"), n("sizey"), n("sizing"), n("opacity");
+          for (var o = { _fullLayout: r }, s = ["x", "y"], l = 0; l < 2; l++) {
+            var u = s[l], c = $U.coerceRef(e, t, o, u, "paper", void 0);
+            if (c !== "paper") {
+              var f = $U.getFromId(o, c);
+              f._imgIndices.push(t._index);
+            }
+            $U.coercePosition(t, o, n, c, u, 0);
+          }
+          return t;
+        }
+      });
+      var R0e = ye((olr, I0e) => {
+        var L0e = Oa(), Rgt = So(), wT = ho(), P0e = hf(), Dgt = Wp();
+        I0e.exports = function(t) {
+          var r = t._fullLayout, n = [], i = {}, a = [], o, s;
+          for (s = 0; s < r.images.length; s++) {
+            var l = r.images[s];
+            if (l.visible) if (l.layer === "below" && l.xref !== "paper" && l.yref !== "paper") {
+              o = P0e.ref2id(l.xref) + P0e.ref2id(l.yref);
+              var u = r._plots[o];
+              if (!u) {
+                a.push(l);
+                continue;
+              }
+              u.mainplot && (o = u.mainplot.id), i[o] || (i[o] = []), i[o].push(l);
+            } else l.layer === "above" ? n.push(l) : a.push(l);
+          }
+          var c = { x: { left: { sizing: "xMin", offset: 0 }, center: { sizing: "xMid", offset: -1 / 2 }, right: { sizing: "xMax", offset: -1 } }, y: { top: { sizing: "YMin", offset: 0 }, middle: { sizing: "YMid", offset: -1 / 2 }, bottom: { sizing: "YMax", offset: -1 } } };
+          function f(T) {
+            var L = L0e.select(this);
+            if (this._imgSrc !== T.source) if (L.attr("xmlns", Dgt.svg), !t._context.staticPlot || T.source && T.source.slice(0, 5) === "data:") L.attr("xlink:href", T.source), this._imgSrc = T.source;
+            else {
+              var x = new Promise((function(C) {
+                var M = new Image();
+                this.img = M, M.setAttribute("crossOrigin", "anonymous"), M.onerror = g, M.onload = function() {
+                  var P = document.createElement("canvas");
+                  P.width = this.width, P.height = this.height;
+                  var A = P.getContext("2d", { willReadFrequently: true });
+                  A.drawImage(this, 0, 0);
+                  var z = P.toDataURL("image/png");
+                  L.attr("xlink:href", z), C();
+                }, L.on("error", g), M.src = T.source, this._imgSrc = T.source;
+                function g() {
+                  L.remove(), C();
+                }
+              }).bind(this));
+              t._promises.push(x);
+            }
+          }
+          function h(T) {
+            var L = L0e.select(this), x = wT.getFromId(t, T.xref), C = wT.getFromId(t, T.yref), M = wT.getRefType(T.xref) === "domain", g = wT.getRefType(T.yref) === "domain", P = r._size, A, z;
+            x !== void 0 ? A = typeof T.xref == "string" && M ? x._length * T.sizex : Math.abs(x.l2p(T.sizex) - x.l2p(0)) : A = T.sizex * P.w, C !== void 0 ? z = typeof T.yref == "string" && g ? C._length * T.sizey : Math.abs(C.l2p(T.sizey) - C.l2p(0)) : z = T.sizey * P.h;
+            var O = A * c.x[T.xanchor].offset, U = z * c.y[T.yanchor].offset, G = c.x[T.xanchor].sizing + c.y[T.yanchor].sizing, Z, j;
+            switch (x !== void 0 ? Z = typeof T.xref == "string" && M ? x._length * T.x + x._offset : x.r2p(T.x) + x._offset : Z = T.x * P.w + P.l, Z += O, C !== void 0 ? j = typeof T.yref == "string" && g ? C._length * (1 - T.y) + C._offset : C.r2p(T.y) + C._offset : j = P.h - T.y * P.h + P.t, j += U, T.sizing) {
+              case "fill":
+                G += " slice";
+                break;
+              case "stretch":
+                G = "none";
+                break;
+            }
+            L.attr({ x: Z, y: j, width: A, height: z, preserveAspectRatio: G, opacity: T.opacity });
+            var N = x && wT.getRefType(T.xref) !== "domain" ? x._id : "", H = C && wT.getRefType(T.yref) !== "domain" ? C._id : "", re = N + H;
+            Rgt.setClipUrl(L, re ? "clip" + r._uid + re : null, t);
+          }
+          function d(T) {
+            return [T.xref, T.x, T.sizex, T.yref, T.y, T.sizey].join("_");
+          }
+          function v(T, L) {
+            return T._index - L._index;
+          }
+          var _ = r._imageLowerLayer.selectAll("image").data(a, d), b = r._imageUpperLayer.selectAll("image").data(n, d);
+          _.enter().append("image"), b.enter().append("image"), _.exit().remove(), b.exit().remove(), _.each(function(T) {
+            f.bind(this)(T), h.bind(this)(T);
+          }), b.each(function(T) {
+            f.bind(this)(T), h.bind(this)(T);
+          }), _.sort(v), b.sort(v);
+          var p = Object.keys(r._plots);
+          for (s = 0; s < p.length; s++) {
+            o = p[s];
+            var k = r._plots[o];
+            if (k.imagelayer) {
+              var E = k.imagelayer.selectAll("image").data(i[o] || [], d);
+              E.enter().append("image"), E.exit().remove(), E.each(function(T) {
+                f.bind(this)(T), h.bind(this)(T);
+              }), E.sort(v);
+            }
+          }
+        };
+      });
+      var z0e = ye((slr, F0e) => {
+        var D0e = Eo(), Fgt = S6();
+        F0e.exports = function(t, r, n, i) {
+          r = r || {};
+          var a = n === "log" && r.type === "linear", o = n === "linear" && r.type === "log";
+          if (a || o) {
+            for (var s = t._fullLayout.images, l = r._id.charAt(0), u, c, f = 0; f < s.length; f++) if (u = s[f], c = "images[" + f + "].", u[l + "ref"] === r._id) {
+              var h = u[l], d = u["size" + l], v = null, _ = null;
+              if (a) {
+                v = Fgt(h, r.range);
+                var b = d / Math.pow(10, v) / 2;
+                _ = 2 * Math.log(b + Math.sqrt(1 + b * b)) / Math.LN10;
+              } else v = Math.pow(10, h), _ = v * (Math.pow(10, d / 2) - Math.pow(10, -d / 2));
+              D0e(v) ? D0e(_) || (_ = null) : (v = null, _ = null), i(c + l, v), i(c + "size" + l, _);
+            }
+          }
+        };
+      });
+      var q0e = ye((llr, O0e) => {
+        O0e.exports = { moduleType: "component", name: "images", layoutAttributes: JU(), supplyLayoutDefaults: C0e(), includeBasePlot: WM()("images"), draw: R0e(), convertCoords: z0e() };
+      });
+      var TI = ye((ulr, B0e) => {
+        B0e.exports = { name: "updatemenus", containerClassName: "updatemenu-container", headerGroupClassName: "updatemenu-header-group", headerClassName: "updatemenu-header", headerArrowClassName: "updatemenu-header-arrow", dropdownButtonGroupClassName: "updatemenu-dropdown-button-group", dropdownButtonClassName: "updatemenu-dropdown-button", buttonClassName: "updatemenu-button", itemRectClassName: "updatemenu-item-rect", itemTextClassName: "updatemenu-item-text", menuIndexAttrName: "updatemenu-active-index", autoMarginIdRoot: "updatemenu-", blankHeaderOpts: { label: "  " }, minWidth: 30, minHeight: 30, textPadX: 24, arrowPadX: 16, rx: 2, ry: 2, textOffsetX: 12, textOffsetY: 3, arrowOffsetX: 4, gapButtonHeader: 5, gapButton: 2, activeColor: "#F4FAFF", hoverColor: "#F4FAFF", arrowSymbol: { left: "◄", right: "►", up: "▲", down: "▼" } };
+      });
+      var QU = ye((clr, U0e) => {
+        var zgt = ec(), Ogt = Ih(), qgt = Ao().extendFlat, Bgt = mc().overrideAll, Ngt = F6(), N0e = vl().templatedArray, Ugt = N0e("button", { visible: { valType: "boolean" }, method: { valType: "enumerated", values: ["restyle", "relayout", "animate", "update", "skip"], dflt: "restyle" }, args: { valType: "info_array", freeLength: true, items: [{ valType: "any" }, { valType: "any" }, { valType: "any" }] }, args2: { valType: "info_array", freeLength: true, items: [{ valType: "any" }, { valType: "any" }, { valType: "any" }] }, label: { valType: "string", dflt: "" }, execute: { valType: "boolean", dflt: true } });
+        U0e.exports = Bgt(N0e("updatemenu", { _arrayAttrRegexps: [/^updatemenus\[(0|[1-9][0-9]+)\]\.buttons/], visible: { valType: "boolean" }, type: { valType: "enumerated", values: ["dropdown", "buttons"], dflt: "dropdown" }, direction: { valType: "enumerated", values: ["left", "right", "up", "down"], dflt: "down" }, active: { valType: "integer", min: -1, dflt: 0 }, showactive: { valType: "boolean", dflt: true }, buttons: Ugt, x: { valType: "number", min: -2, max: 3, dflt: -0.05 }, xanchor: { valType: "enumerated", values: ["auto", "left", "center", "right"], dflt: "right" }, y: { valType: "number", min: -2, max: 3, dflt: 1 }, yanchor: { valType: "enumerated", values: ["auto", "top", "middle", "bottom"], dflt: "top" }, pad: qgt(Ngt({ editType: "arraydraw" }), {}), font: zgt({}), bgcolor: { valType: "color" }, bordercolor: { valType: "color", dflt: Ogt.borderLine }, borderwidth: { valType: "number", min: 0, dflt: 1, editType: "arraydraw" } }), "arraydraw", "from-root");
+      });
+      var j0e = ye((flr, H0e) => {
+        var AI = Dr(), V0e = Zd(), G0e = QU(), Vgt = TI(), Ggt = Vgt.name, Hgt = G0e.buttons;
+        H0e.exports = function(t, r) {
+          var n = { name: Ggt, handleItemDefaults: jgt };
+          V0e(t, r, n);
+        };
+        function jgt(e, t, r) {
+          function n(o, s) {
+            return AI.coerce(e, t, G0e, o, s);
+          }
+          var i = V0e(e, t, { name: "buttons", handleItemDefaults: Wgt }), a = n("visible", i.length > 0);
+          a && (n("active"), n("direction"), n("type"), n("showactive"), n("x"), n("y"), AI.noneOrAll(e, t, ["x", "y"]), n("xanchor"), n("yanchor"), n("pad.t"), n("pad.r"), n("pad.b"), n("pad.l"), AI.coerceFont(n, "font", r.font), n("bgcolor", r.paper_bgcolor), n("bordercolor"), n("borderwidth"));
+        }
+        function Wgt(e, t) {
+          function r(i, a) {
+            return AI.coerce(e, t, Hgt, i, a);
+          }
+          var n = r("visible", e.method === "skip" || Array.isArray(e.args));
+          n && (r("method"), r("args"), r("args2"), r("label"), r("execute"));
+        }
+      });
+      var Z0e = ye((hlr, X0e) => {
+        X0e.exports = Mf;
+        var Ng = Oa(), W0e = ka(), TT = So(), SI = Dr();
+        function Mf(e, t, r) {
+          this.gd = e, this.container = t, this.id = r, this.position = null, this.translateX = null, this.translateY = null, this.hbar = null, this.vbar = null, this.bg = this.container.selectAll("rect.scrollbox-bg").data([0]), this.bg.exit().on(".drag", null).on("wheel", null).remove(), this.bg.enter().append("rect").classed("scrollbox-bg", true).style("pointer-events", "all").attr({ opacity: 0, x: 0, y: 0, width: 0, height: 0 });
+        }
+        Mf.barWidth = 2;
+        Mf.barLength = 20;
+        Mf.barRadius = 2;
+        Mf.barPad = 1;
+        Mf.barColor = "#808BA4";
+        Mf.prototype.enable = function(t, r, n) {
+          var i = this.gd._fullLayout, a = i.width, o = i.height;
+          this.position = t;
+          var s = this.position.l, l = this.position.w, u = this.position.t, c = this.position.h, f = this.position.direction, h = f === "down", d = f === "left", v = f === "right", _ = f === "up", b = l, p = c, k, E, T, L;
+          !h && !d && !v && !_ && (this.position.direction = "down", h = true);
+          var x = h || _;
+          x ? (k = s, E = k + b, h ? (T = u, L = Math.min(T + p, o), p = L - T) : (L = u + p, T = Math.max(L - p, 0), p = L - T)) : (T = u, L = T + p, d ? (E = s + b, k = Math.max(E - b, 0), b = E - k) : (k = s, E = Math.min(k + b, a), b = E - k)), this._box = { l: k, t: T, w: b, h: p };
+          var C = l > b, M = Mf.barLength + 2 * Mf.barPad, g = Mf.barWidth + 2 * Mf.barPad, P = s, A = u + c;
+          A + g > o && (A = o - g);
+          var z = this.container.selectAll("rect.scrollbar-horizontal").data(C ? [0] : []);
+          z.exit().on(".drag", null).remove(), z.enter().append("rect").classed("scrollbar-horizontal", true).call(W0e.fill, Mf.barColor), C ? (this.hbar = z.attr({ rx: Mf.barRadius, ry: Mf.barRadius, x: P, y: A, width: M, height: g }), this._hbarXMin = P + M / 2, this._hbarTranslateMax = b - M) : (delete this.hbar, delete this._hbarXMin, delete this._hbarTranslateMax);
+          var O = c > p, U = Mf.barWidth + 2 * Mf.barPad, G = Mf.barLength + 2 * Mf.barPad, Z = s + l, j = u;
+          Z + U > a && (Z = a - U);
+          var N = this.container.selectAll("rect.scrollbar-vertical").data(O ? [0] : []);
+          N.exit().on(".drag", null).remove(), N.enter().append("rect").classed("scrollbar-vertical", true).call(W0e.fill, Mf.barColor), O ? (this.vbar = N.attr({ rx: Mf.barRadius, ry: Mf.barRadius, x: Z, y: j, width: U, height: G }), this._vbarYMin = j + G / 2, this._vbarTranslateMax = p - G) : (delete this.vbar, delete this._vbarYMin, delete this._vbarTranslateMax);
+          var H = this.id, re = k - 0.5, oe = O ? E + U + 0.5 : E + 0.5, _e = T - 0.5, Ce = C ? L + g + 0.5 : L + 0.5, Le = i._topdefs.selectAll("#" + H).data(C || O ? [0] : []);
+          if (Le.exit().remove(), Le.enter().append("clipPath").attr("id", H).append("rect"), C || O ? (this._clipRect = Le.select("rect").attr({ x: Math.floor(re), y: Math.floor(_e), width: Math.ceil(oe) - Math.floor(re), height: Math.ceil(Ce) - Math.floor(_e) }), this.container.call(TT.setClipUrl, H, this.gd), this.bg.attr({ x: s, y: u, width: l, height: c })) : (this.bg.attr({ width: 0, height: 0 }), this.container.on("wheel", null).on(".drag", null).call(TT.setClipUrl, null), delete this._clipRect), C || O) {
+            var ge = Ng.behavior.drag().on("dragstart", function() {
+              Ng.event.sourceEvent.preventDefault();
+            }).on("drag", this._onBoxDrag.bind(this));
+            this.container.on("wheel", null).on("wheel", this._onBoxWheel.bind(this)).on(".drag", null).call(ge);
+            var ie = Ng.behavior.drag().on("dragstart", function() {
+              Ng.event.sourceEvent.preventDefault(), Ng.event.sourceEvent.stopPropagation();
+            }).on("drag", this._onBarDrag.bind(this));
+            C && this.hbar.on(".drag", null).call(ie), O && this.vbar.on(".drag", null).call(ie);
+          }
+          this.setTranslate(r, n);
+        };
+        Mf.prototype.disable = function() {
+          (this.hbar || this.vbar) && (this.bg.attr({ width: 0, height: 0 }), this.container.on("wheel", null).on(".drag", null).call(TT.setClipUrl, null), delete this._clipRect), this.hbar && (this.hbar.on(".drag", null), this.hbar.remove(), delete this.hbar, delete this._hbarXMin, delete this._hbarTranslateMax), this.vbar && (this.vbar.on(".drag", null), this.vbar.remove(), delete this.vbar, delete this._vbarYMin, delete this._vbarTranslateMax);
+        };
+        Mf.prototype._onBoxDrag = function() {
+          var t = this.translateX, r = this.translateY;
+          this.hbar && (t -= Ng.event.dx), this.vbar && (r -= Ng.event.dy), this.setTranslate(t, r);
+        };
+        Mf.prototype._onBoxWheel = function() {
+          var t = this.translateX, r = this.translateY;
+          this.hbar && (t += Ng.event.deltaY), this.vbar && (r += Ng.event.deltaY), this.setTranslate(t, r);
+        };
+        Mf.prototype._onBarDrag = function() {
+          var t = this.translateX, r = this.translateY;
+          if (this.hbar) {
+            var n = t + this._hbarXMin, i = n + this._hbarTranslateMax, a = SI.constrain(Ng.event.x, n, i), o = (a - n) / (i - n), s = this.position.w - this._box.w;
+            t = o * s;
+          }
+          if (this.vbar) {
+            var l = r + this._vbarYMin, u = l + this._vbarTranslateMax, c = SI.constrain(Ng.event.y, l, u), f = (c - l) / (u - l), h = this.position.h - this._box.h;
+            r = f * h;
+          }
+          this.setTranslate(t, r);
+        };
+        Mf.prototype.setTranslate = function(t, r) {
+          var n = this.position.w - this._box.w, i = this.position.h - this._box.h;
+          if (t = SI.constrain(t || 0, 0, n), r = SI.constrain(r || 0, 0, i), this.translateX = t, this.translateY = r, this.container.call(TT.setTranslate, this._box.l - this.position.l - t, this._box.t - this.position.t - r), this._clipRect && this._clipRect.attr({ x: Math.floor(this.position.l + t - 0.5), y: Math.floor(this.position.t + r - 0.5) }), this.hbar) {
+            var a = t / n;
+            this.hbar.call(TT.setTranslate, t + a * this._hbarTranslateMax, r);
+          }
+          if (this.vbar) {
+            var o = r / i;
+            this.vbar.call(TT.setTranslate, t, r + o * this._vbarTranslateMax);
+          }
+        };
+      });
+      var nge = ye((dlr, ige) => {
+        var AT = Oa(), p4 = Mc(), g4 = ka(), ST = So(), t0 = Dr(), MI = Zl(), Xgt = vl().arrayEditor, K0e = Dh().LINE_SPACING, es = TI(), Zgt = Z0e();
+        ige.exports = function(t) {
+          var r = t._fullLayout, n = t0.filterVisible(r[es.name]);
+          function i(h) {
+            p4.autoMargin(t, tge(h));
+          }
+          var a = r._menulayer.selectAll("g." + es.containerClassName).data(n.length > 0 ? [0] : []);
+          if (a.enter().append("g").classed(es.containerClassName, true).style("cursor", "pointer"), a.exit().each(function() {
+            AT.select(this).selectAll("g." + es.headerGroupClassName).each(i);
+          }).remove(), n.length !== 0) {
+            var o = a.selectAll("g." + es.headerGroupClassName).data(n, Ygt);
+            o.enter().append("g").classed(es.headerGroupClassName, true);
+            for (var s = t0.ensureSingle(a, "g", es.dropdownButtonGroupClassName, function(h) {
+              h.style("pointer-events", "all");
+            }), l = 0; l < n.length; l++) {
+              var u = n[l];
+              tmt(t, u);
+            }
+            var c = "updatemenus" + r._uid, f = new Zgt(t, s, c);
+            o.enter().size() && (s.node().parentNode.appendChild(s.node()), s.call(tV)), o.exit().each(function(h) {
+              s.call(tV), i(h);
+            }).remove(), o.each(function(h) {
+              var d = AT.select(this), v = h.type === "dropdown" ? s : null;
+              p4.manageCommandObserver(t, h, h.buttons, function(_) {
+                eV(t, h, h.buttons[_.index], d, v, f, _.index, true);
+              }), h.type === "dropdown" ? ($0e(t, d, s, f, h), J0e(s, h) && m4(t, d, s, f, h)) : m4(t, d, null, null, h);
+            });
+          }
+        };
+        function Ygt(e) {
+          return e._index;
+        }
+        function Kgt(e) {
+          return +e.attr(es.menuIndexAttrName) == -1;
+        }
+        function J0e(e, t) {
+          return +e.attr(es.menuIndexAttrName) === t._index;
+        }
+        function eV(e, t, r, n, i, a, o, s) {
+          t.active = o, Xgt(e.layout, es.name, t).applyUpdate("active", o), t.type === "buttons" ? m4(e, n, null, null, t) : t.type === "dropdown" && (i.attr(es.menuIndexAttrName, "-1"), $0e(e, n, i, a, t), s || m4(e, n, i, a, t));
+        }
+        function $0e(e, t, r, n, i) {
+          var a = t0.ensureSingle(t, "g", es.headerClassName, function(h) {
+            h.style("pointer-events", "all");
+          }), o = i._dims, s = i.active, l = i.buttons[s] || es.blankHeaderOpts, u = { y: i.pad.t, yPad: 0, x: i.pad.l, xPad: 0, index: 0 }, c = { width: o.headerWidth, height: o.headerHeight };
+          a.call(rV, i, l, e).call(rge, i, u, c);
+          var f = t0.ensureSingle(t, "text", es.headerArrowClassName, function(h) {
+            h.attr("text-anchor", "end").call(ST.font, i.font).text(es.arrowSymbol[i.direction]);
+          });
+          f.attr({ x: o.headerWidth - es.arrowOffsetX + i.pad.l, y: o.headerHeight / 2 + es.textOffsetY + i.pad.t }), a.on("click", function() {
+            r.call(tV, String(J0e(r, i) ? -1 : i._index)), m4(e, t, r, n, i);
+          }), a.on("mouseover", function() {
+            a.call(Q0e);
+          }), a.on("mouseout", function() {
+            a.call(ege, i);
+          }), ST.setTranslate(t, o.lx, o.ly);
+        }
+        function m4(e, t, r, n, i) {
+          r || (r = t, r.attr("pointer-events", "all"));
+          var a = !Kgt(r) || i.type === "buttons" ? i.buttons : [], o = i.type === "dropdown" ? es.dropdownButtonClassName : es.buttonClassName, s = r.selectAll("g." + o).data(t0.filterVisible(a)), l = s.enter().append("g").classed(o, true), u = s.exit();
+          i.type === "dropdown" ? (l.attr("opacity", "0").transition().attr("opacity", "1"), u.transition().attr("opacity", "0").remove()) : u.remove();
+          var c = 0, f = 0, h = i._dims, d = ["up", "down"].indexOf(i.direction) !== -1;
+          i.type === "dropdown" && (d ? f = h.headerHeight + es.gapButtonHeader : c = h.headerWidth + es.gapButtonHeader), i.type === "dropdown" && i.direction === "up" && (f = -es.gapButtonHeader + es.gapButton - h.openHeight), i.type === "dropdown" && i.direction === "left" && (c = -es.gapButtonHeader + es.gapButton - h.openWidth);
+          var v = { x: h.lx + c + i.pad.l, y: h.ly + f + i.pad.t, yPad: es.gapButton, xPad: es.gapButton, index: 0 }, _ = { l: v.x + i.borderwidth, t: v.y + i.borderwidth };
+          s.each(function(b, p) {
+            var k = AT.select(this);
+            k.call(rV, i, b, e).call(rge, i, v), k.on("click", function() {
+              AT.event.defaultPrevented || (b.execute && (b.args2 && i.active === p ? (eV(e, i, b, t, r, n, -1), p4.executeAPICommand(e, b.method, b.args2)) : (eV(e, i, b, t, r, n, p), p4.executeAPICommand(e, b.method, b.args))), e.emit("plotly_buttonclicked", { menu: i, button: b, active: i.active }));
+            }), k.on("mouseover", function() {
+              k.call(Q0e);
+            }), k.on("mouseout", function() {
+              k.call(ege, i), s.call(Y0e, i);
+            });
+          }), s.call(Y0e, i), d ? (_.w = Math.max(h.openWidth, h.headerWidth), _.h = v.y - _.t) : (_.w = v.x - _.l, _.h = Math.max(h.openHeight, h.headerHeight)), _.direction = i.direction, n && (s.size() ? Jgt(e, t, r, n, i, _) : $gt(n));
+        }
+        function Jgt(e, t, r, n, i, a) {
+          var o = i.direction, s = o === "up" || o === "down", l = i._dims, u = i.active, c, f, h;
+          if (s) for (f = 0, h = 0; h < u; h++) f += l.heights[h] + es.gapButton;
+          else for (c = 0, h = 0; h < u; h++) c += l.widths[h] + es.gapButton;
+          n.enable(a, c, f), n.hbar && n.hbar.attr("opacity", "0").transition().attr("opacity", "1"), n.vbar && n.vbar.attr("opacity", "0").transition().attr("opacity", "1");
+        }
+        function $gt(e) {
+          var t = !!e.hbar, r = !!e.vbar;
+          t && e.hbar.transition().attr("opacity", "0").each("end", function() {
+            t = false, r || e.disable();
+          }), r && e.vbar.transition().attr("opacity", "0").each("end", function() {
+            r = false, t || e.disable();
+          });
+        }
+        function rV(e, t, r, n) {
+          e.call(Qgt, t).call(emt, t, r, n);
+        }
+        function Qgt(e, t) {
+          var r = t0.ensureSingle(e, "rect", es.itemRectClassName, function(n) {
+            n.attr({ rx: es.rx, ry: es.ry, "shape-rendering": "crispEdges" });
+          });
+          r.call(g4.stroke, t.bordercolor).call(g4.fill, t.bgcolor).style("stroke-width", t.borderwidth + "px");
+        }
+        function emt(e, t, r, n) {
+          var i = t0.ensureSingle(e, "text", es.itemTextClassName, function(s) {
+            s.attr({ "text-anchor": "start", "data-notex": 1 });
+          }), a = r.label, o = n._fullLayout._meta;
+          o && (a = t0.templateString(a, o)), i.call(ST.font, t.font).text(a).call(MI.convertToTspans, n);
+        }
+        function Y0e(e, t) {
+          var r = t.active;
+          e.each(function(n, i) {
+            var a = AT.select(this);
+            i === r && t.showactive && a.select("rect." + es.itemRectClassName).call(g4.fill, es.activeColor);
+          });
+        }
+        function Q0e(e) {
+          e.select("rect." + es.itemRectClassName).call(g4.fill, es.hoverColor);
+        }
+        function ege(e, t) {
+          e.select("rect." + es.itemRectClassName).call(g4.fill, t.bgcolor);
+        }
+        function tmt(e, t) {
+          var r = t._dims = { width1: 0, height1: 0, heights: [], widths: [], totalWidth: 0, totalHeight: 0, openWidth: 0, openHeight: 0, lx: 0, ly: 0 }, n = ST.tester.selectAll("g." + es.dropdownButtonClassName).data(t0.filterVisible(t.buttons));
+          n.enter().append("g").classed(es.dropdownButtonClassName, true);
+          var i = ["up", "down"].indexOf(t.direction) !== -1;
+          n.each(function(c, f) {
+            var h = AT.select(this);
+            h.call(rV, t, c, e);
+            var d = h.select("." + es.itemTextClassName), v = d.node() && ST.bBox(d.node()).width, _ = Math.max(v + es.textPadX, es.minWidth), b = t.font.size * K0e, p = MI.lineCount(d), k = Math.max(b * p, es.minHeight) + es.textOffsetY;
+            k = Math.ceil(k), _ = Math.ceil(_), r.widths[f] = _, r.heights[f] = k, r.height1 = Math.max(r.height1, k), r.width1 = Math.max(r.width1, _), i ? (r.totalWidth = Math.max(r.totalWidth, _), r.openWidth = r.totalWidth, r.totalHeight += k + es.gapButton, r.openHeight += k + es.gapButton) : (r.totalWidth += _ + es.gapButton, r.openWidth += _ + es.gapButton, r.totalHeight = Math.max(r.totalHeight, k), r.openHeight = r.totalHeight);
+          }), i ? r.totalHeight -= es.gapButton : r.totalWidth -= es.gapButton, r.headerWidth = r.width1 + es.arrowPadX, r.headerHeight = r.height1, t.type === "dropdown" && (i ? (r.width1 += es.arrowPadX, r.totalHeight = r.height1) : r.totalWidth = r.width1, r.totalWidth += es.arrowPadX), n.remove();
+          var a = r.totalWidth + t.pad.l + t.pad.r, o = r.totalHeight + t.pad.t + t.pad.b, s = e._fullLayout._size;
+          r.lx = s.l + s.w * t.x, r.ly = s.t + s.h * (1 - t.y);
+          var l = "left";
+          t0.isRightAnchor(t) && (r.lx -= a, l = "right"), t0.isCenterAnchor(t) && (r.lx -= a / 2, l = "center");
+          var u = "top";
+          t0.isBottomAnchor(t) && (r.ly -= o, u = "bottom"), t0.isMiddleAnchor(t) && (r.ly -= o / 2, u = "middle"), r.totalWidth = Math.ceil(r.totalWidth), r.totalHeight = Math.ceil(r.totalHeight), r.lx = Math.round(r.lx), r.ly = Math.round(r.ly), p4.autoMargin(e, tge(t), { x: t.x, y: t.y, l: a * ({ right: 1, center: 0.5 }[l] || 0), r: a * ({ left: 1, center: 0.5 }[l] || 0), b: o * ({ top: 1, middle: 0.5 }[u] || 0), t: o * ({ bottom: 1, middle: 0.5 }[u] || 0) });
+        }
+        function tge(e) {
+          return es.autoMarginIdRoot + e._index;
+        }
+        function rge(e, t, r, n) {
+          n = n || {};
+          var i = e.select("." + es.itemRectClassName), a = e.select("." + es.itemTextClassName), o = t.borderwidth, s = r.index, l = t._dims;
+          ST.setTranslate(e, o + r.x, o + r.y);
+          var u = ["up", "down"].indexOf(t.direction) !== -1, c = n.height || (u ? l.heights[s] : l.height1);
+          i.attr({ x: 0, y: 0, width: n.width || (u ? l.width1 : l.widths[s]), height: c });
+          var f = t.font.size * K0e, h = MI.lineCount(a), d = (h - 1) * f / 2;
+          MI.positionText(a, es.textOffsetX, c / 2 - d + es.textOffsetY), u ? r.y += l.heights[s] + r.yPad : r.x += l.widths[s] + r.xPad, r.index++;
+        }
+        function tV(e, t) {
+          e.attr(es.menuIndexAttrName, t || "-1").selectAll("g." + es.dropdownButtonClassName).remove();
+        }
+      });
+      var oge = ye((vlr, age) => {
+        var rmt = TI();
+        age.exports = { moduleType: "component", name: rmt.name, layoutAttributes: QU(), supplyLayoutDefaults: j0e(), draw: nge() };
+      });
+      var y4 = ye((plr, sge) => {
+        sge.exports = { name: "sliders", containerClassName: "slider-container", groupClassName: "slider-group", inputAreaClass: "slider-input-area", railRectClass: "slider-rail-rect", railTouchRectClass: "slider-rail-touch-rect", gripRectClass: "slider-grip-rect", tickRectClass: "slider-tick-rect", inputProxyClass: "slider-input-proxy", labelsClass: "slider-labels", labelGroupClass: "slider-label-group", labelClass: "slider-label", currentValueClass: "slider-current-value", railHeight: 5, menuIndexAttrName: "slider-active-index", autoMarginIdRoot: "slider-", minWidth: 30, minHeight: 30, textPadX: 40, arrowOffsetX: 4, railRadius: 2, railWidth: 5, railBorder: 4, railBorderWidth: 1, railBorderColor: "#bec8d9", railBgColor: "#f8fafc", railInset: 8, stepInset: 10, gripRadius: 10, gripWidth: 20, gripHeight: 20, gripBorder: 20, gripBorderWidth: 1, gripBorderColor: "#bec8d9", gripBgColor: "#f6f8fa", gripBgActiveColor: "#dbdde0", labelPadding: 8, labelOffset: 0, tickWidth: 1, tickColor: "#333", tickOffset: 25, tickLength: 7, minorTickOffset: 25, minorTickColor: "#333", minorTickLength: 4, currentValuePadding: 8, currentValueInset: 0 };
+      });
+      var iV = ye((glr, cge) => {
+        var lge = ec(), imt = F6(), nmt = Ao().extendDeepAll, amt = mc().overrideAll, omt = jS(), uge = vl().templatedArray, l2 = y4(), smt = uge("step", { visible: { valType: "boolean", dflt: true }, method: { valType: "enumerated", values: ["restyle", "relayout", "animate", "update", "skip"], dflt: "restyle" }, args: { valType: "info_array", freeLength: true, items: [{ valType: "any" }, { valType: "any" }, { valType: "any" }] }, label: { valType: "string" }, value: { valType: "string" }, execute: { valType: "boolean", dflt: true } });
+        cge.exports = amt(uge("slider", { visible: { valType: "boolean", dflt: true }, active: { valType: "number", min: 0, dflt: 0 }, steps: smt, lenmode: { valType: "enumerated", values: ["fraction", "pixels"], dflt: "fraction" }, len: { valType: "number", min: 0, dflt: 1 }, x: { valType: "number", min: -2, max: 3, dflt: 0 }, pad: nmt(imt({ editType: "arraydraw" }), {}, { t: { dflt: 20 } }), xanchor: { valType: "enumerated", values: ["auto", "left", "center", "right"], dflt: "left" }, y: { valType: "number", min: -2, max: 3, dflt: 0 }, yanchor: { valType: "enumerated", values: ["auto", "top", "middle", "bottom"], dflt: "top" }, transition: { duration: { valType: "number", min: 0, dflt: 150 }, easing: { valType: "enumerated", values: omt.transition.easing.values, dflt: "cubic-in-out" } }, currentvalue: { visible: { valType: "boolean", dflt: true }, xanchor: { valType: "enumerated", values: ["left", "center", "right"], dflt: "left" }, offset: { valType: "number", dflt: 10 }, prefix: { valType: "string" }, suffix: { valType: "string" }, font: lge({}) }, font: lge({}), activebgcolor: { valType: "color", dflt: l2.gripBgActiveColor }, bgcolor: { valType: "color", dflt: l2.railBgColor }, bordercolor: { valType: "color", dflt: l2.railBorderColor }, borderwidth: { valType: "number", min: 0, dflt: l2.railBorderWidth }, ticklen: { valType: "number", min: 0, dflt: l2.tickLength }, tickcolor: { valType: "color", dflt: l2.tickColor }, tickwidth: { valType: "number", min: 0, dflt: 1 }, minorticklen: { valType: "number", min: 0, dflt: l2.minorTickLength } }), "arraydraw", "from-root");
+      });
+      var vge = ye((mlr, dge) => {
+        var MT = Dr(), fge = Zd(), hge = iV(), lmt = y4(), umt = lmt.name, cmt = hge.steps;
+        dge.exports = function(t, r) {
+          fge(t, r, { name: umt, handleItemDefaults: fmt });
+        };
+        function fmt(e, t, r) {
+          function n(f, h) {
+            return MT.coerce(e, t, hge, f, h);
+          }
+          for (var i = fge(e, t, { name: "steps", handleItemDefaults: hmt }), a = 0, o = 0; o < i.length; o++) i[o].visible && a++;
+          var s;
+          if (a < 2 ? s = t.visible = false : s = n("visible"), !!s) {
+            t._stepCount = a;
+            var l = t._visibleSteps = MT.filterVisible(i), u = n("active");
+            (i[u] || {}).visible || (t.active = l[0]._index), n("x"), n("y"), MT.noneOrAll(e, t, ["x", "y"]), n("xanchor"), n("yanchor"), n("len"), n("lenmode"), n("pad.t"), n("pad.r"), n("pad.b"), n("pad.l"), MT.coerceFont(n, "font", r.font);
+            var c = n("currentvalue.visible");
+            c && (n("currentvalue.xanchor"), n("currentvalue.prefix"), n("currentvalue.suffix"), n("currentvalue.offset"), MT.coerceFont(n, "currentvalue.font", t.font)), n("transition.duration"), n("transition.easing"), n("bgcolor"), n("activebgcolor"), n("bordercolor"), n("borderwidth"), n("ticklen"), n("tickwidth"), n("tickcolor"), n("minorticklen");
+          }
+        }
+        function hmt(e, t) {
+          function r(a, o) {
+            return MT.coerce(e, t, cmt, a, o);
+          }
+          var n;
+          if (e.method !== "skip" && !Array.isArray(e.args) ? n = t.visible = false : n = r("visible"), n) {
+            r("method"), r("args");
+            var i = r("label", "step-" + t._index);
+            r("value", i), r("execute");
+          }
+        }
+      });
+      var Age = ye((ylr, Tge) => {
+        var Ug = Oa(), EI = Mc(), k_ = ka(), Vg = So(), r0 = Dr(), dmt = r0.strTranslate, _4 = Zl(), vmt = vl().arrayEditor, Rs = y4(), oV = Dh(), mge = oV.LINE_SPACING, nV = oV.FROM_TL, aV = oV.FROM_BR;
+        Tge.exports = function(t) {
+          var r = t._context.staticPlot, n = t._fullLayout, i = pmt(n, t), a = n._infolayer.selectAll("g." + Rs.containerClassName).data(i.length > 0 ? [0] : []);
+          a.enter().append("g").classed(Rs.containerClassName, true).style("cursor", r ? null : "ew-resize");
+          function o(c) {
+            c._commandObserver && (c._commandObserver.remove(), delete c._commandObserver), EI.autoMargin(t, yge(c));
+          }
+          if (a.exit().each(function() {
+            Ug.select(this).selectAll("g." + Rs.groupClassName).each(o);
+          }).remove(), i.length !== 0) {
+            var s = a.selectAll("g." + Rs.groupClassName).data(i, gmt);
+            s.enter().append("g").classed(Rs.groupClassName, true), s.exit().each(o).remove();
+            for (var l = 0; l < i.length; l++) {
+              var u = i[l];
+              mmt(t, u);
+            }
+            s.each(function(c) {
+              var f = Ug.select(this);
+              wmt(c), EI.manageCommandObserver(t, c, c._visibleSteps, function(h) {
+                var d = f.data()[0];
+                d.active !== h.index && (d._dragging || xge(t, f, d, h.index, false, true));
+              }), ymt(t, Ug.select(this), c);
+            });
+          }
+        };
+        function yge(e) {
+          return Rs.autoMarginIdRoot + e._index;
+        }
+        function pmt(e, t) {
+          for (var r = e[Rs.name], n = [], i = 0; i < r.length; i++) {
+            var a = r[i];
+            a.visible && (a._gd = t, n.push(a));
+          }
+          return n;
+        }
+        function gmt(e) {
+          return e._index;
+        }
+        function mmt(e, t) {
+          var r = Vg.tester.selectAll("g." + Rs.labelGroupClass).data(t._visibleSteps);
+          r.enter().append("g").classed(Rs.labelGroupClass, true);
+          var n = 0, i = 0;
+          r.each(function(v) {
+            var _ = Ug.select(this), b = _ge(_, { step: v }, t), p = b.node();
+            if (p) {
+              var k = Vg.bBox(p);
+              i = Math.max(i, k.height), n = Math.max(n, k.width);
+            }
+          }), r.remove();
+          var a = t._dims = {};
+          a.inputAreaWidth = Math.max(Rs.railWidth, Rs.gripHeight);
+          var o = e._fullLayout._size;
+          a.lx = o.l + o.w * t.x, a.ly = o.t + o.h * (1 - t.y), t.lenmode === "fraction" ? a.outerLength = Math.round(o.w * t.len) : a.outerLength = t.len, a.inputAreaStart = 0, a.inputAreaLength = Math.round(a.outerLength - t.pad.l - t.pad.r);
+          var s = a.inputAreaLength - 2 * Rs.stepInset, l = s / (t._stepCount - 1), u = n + Rs.labelPadding;
+          if (a.labelStride = Math.max(1, Math.ceil(u / l)), a.labelHeight = i, a.currentValueMaxWidth = 0, a.currentValueHeight = 0, a.currentValueTotalHeight = 0, a.currentValueMaxLines = 1, t.currentvalue.visible) {
+            var c = Vg.tester.append("g");
+            r.each(function(v) {
+              var _ = kI(c, t, v.label), b = _.node() && Vg.bBox(_.node()) || { width: 0, height: 0 }, p = _4.lineCount(_);
+              a.currentValueMaxWidth = Math.max(a.currentValueMaxWidth, Math.ceil(b.width)), a.currentValueHeight = Math.max(a.currentValueHeight, Math.ceil(b.height)), a.currentValueMaxLines = Math.max(a.currentValueMaxLines, p);
+            }), a.currentValueTotalHeight = a.currentValueHeight + t.currentvalue.offset, c.remove();
+          }
+          a.height = a.currentValueTotalHeight + Rs.tickOffset + t.ticklen + Rs.labelOffset + a.labelHeight + t.pad.t + t.pad.b;
+          var f = "left";
+          r0.isRightAnchor(t) && (a.lx -= a.outerLength, f = "right"), r0.isCenterAnchor(t) && (a.lx -= a.outerLength / 2, f = "center");
+          var h = "top";
+          r0.isBottomAnchor(t) && (a.ly -= a.height, h = "bottom"), r0.isMiddleAnchor(t) && (a.ly -= a.height / 2, h = "middle"), a.outerLength = Math.ceil(a.outerLength), a.height = Math.ceil(a.height), a.lx = Math.round(a.lx), a.ly = Math.round(a.ly);
+          var d = { y: t.y, b: a.height * aV[h], t: a.height * nV[h] };
+          t.lenmode === "fraction" ? (d.l = 0, d.xl = t.x - t.len * nV[f], d.r = 0, d.xr = t.x + t.len * aV[f]) : (d.x = t.x, d.l = a.outerLength * nV[f], d.r = a.outerLength * aV[f]), EI.autoMargin(e, yge(t), d);
+        }
+        function ymt(e, t, r) {
+          (r.steps[r.active] || {}).visible || (r.active = r._visibleSteps[0]._index), t.call(kI, r).call(Amt, r).call(xmt, r).call(bmt, r).call(Tmt, e, r).call(_mt, e, r);
+          var n = r._dims;
+          Vg.setTranslate(t, n.lx + r.pad.l, n.ly + r.pad.t), t.call(wge, r, false), t.call(kI, r);
+        }
+        function kI(e, t, r) {
+          if (t.currentvalue.visible) {
+            var n = t._dims, i, a;
+            switch (t.currentvalue.xanchor) {
+              case "right":
+                i = n.inputAreaLength - Rs.currentValueInset - n.currentValueMaxWidth, a = "left";
+                break;
+              case "center":
+                i = n.inputAreaLength * 0.5, a = "middle";
+                break;
+              default:
+                i = Rs.currentValueInset, a = "left";
+            }
+            var o = r0.ensureSingle(e, "text", Rs.labelClass, function(h) {
+              h.attr({ "text-anchor": a, "data-notex": 1 });
+            }), s = t.currentvalue.prefix ? t.currentvalue.prefix : "";
+            if (typeof r == "string") s += r;
+            else {
+              var l = t.steps[t.active].label, u = t._gd._fullLayout._meta;
+              u && (l = r0.templateString(l, u)), s += l;
+            }
+            t.currentvalue.suffix && (s += t.currentvalue.suffix), o.call(Vg.font, t.currentvalue.font).text(s).call(_4.convertToTspans, t._gd);
+            var c = _4.lineCount(o), f = (n.currentValueMaxLines + 1 - c) * t.currentvalue.font.size * mge;
+            return _4.positionText(o, i, f), o;
+          }
+        }
+        function _mt(e, t, r) {
+          var n = r0.ensureSingle(e, "rect", Rs.gripRectClass, function(i) {
+            i.call(bge, t, e, r).style("pointer-events", "all");
+          });
+          n.attr({ width: Rs.gripWidth, height: Rs.gripHeight, rx: Rs.gripRadius, ry: Rs.gripRadius }).call(k_.stroke, r.bordercolor).call(k_.fill, r.bgcolor).style("stroke-width", r.borderwidth + "px");
+        }
+        function _ge(e, t, r) {
+          var n = r0.ensureSingle(e, "text", Rs.labelClass, function(o) {
+            o.attr({ "text-anchor": "middle", "data-notex": 1 });
+          }), i = t.step.label, a = r._gd._fullLayout._meta;
+          return a && (i = r0.templateString(i, a)), n.call(Vg.font, r.font).text(i).call(_4.convertToTspans, r._gd), n;
+        }
+        function xmt(e, t) {
+          var r = r0.ensureSingle(e, "g", Rs.labelsClass), n = t._dims, i = r.selectAll("g." + Rs.labelGroupClass).data(n.labelSteps);
+          i.enter().append("g").classed(Rs.labelGroupClass, true), i.exit().remove(), i.each(function(a) {
+            var o = Ug.select(this);
+            o.call(_ge, a, t), Vg.setTranslate(o, sV(t, a.fraction), Rs.tickOffset + t.ticklen + t.font.size * mge + Rs.labelOffset + n.currentValueTotalHeight);
+          });
+        }
+        function pge(e, t, r, n, i) {
+          var a = Math.round(n * (r._stepCount - 1)), o = r._visibleSteps[a]._index;
+          o !== r.active && xge(e, t, r, o, true, i);
+        }
+        function xge(e, t, r, n, i, a) {
+          var o = r.active;
+          r.active = n, vmt(e.layout, Rs.name, r).applyUpdate("active", n);
+          var s = r.steps[r.active];
+          t.call(wge, r, a), t.call(kI, r), e.emit("plotly_sliderchange", { slider: r, step: r.steps[r.active], interaction: i, previousActive: o }), s && s.method && i && (t._nextMethod ? (t._nextMethod.step = s, t._nextMethod.doCallback = i, t._nextMethod.doTransition = a) : (t._nextMethod = { step: s, doCallback: i, doTransition: a }, t._nextMethodRaf = window.requestAnimationFrame(function() {
+            var l = t._nextMethod.step;
+            l.method && (l.execute && EI.executeAPICommand(e, l.method, l.args), t._nextMethod = null, t._nextMethodRaf = null);
+          })));
+        }
+        function bge(e, t, r) {
+          if (t._context.staticPlot) return;
+          var n = r.node(), i = Ug.select(t);
+          function a() {
+            return r.data()[0];
+          }
+          function o() {
+            var s = a();
+            t.emit("plotly_sliderstart", { slider: s });
+            var l = r.select("." + Rs.gripRectClass);
+            Ug.event.stopPropagation(), Ug.event.preventDefault(), l.call(k_.fill, s.activebgcolor);
+            var u = gge(s, Ug.mouse(n)[0]);
+            pge(t, r, s, u, true), s._dragging = true;
+            function c() {
+              var h = a(), d = gge(h, Ug.mouse(n)[0]);
+              pge(t, r, h, d, false);
+            }
+            i.on("mousemove", c), i.on("touchmove", c);
+            function f() {
+              var h = a();
+              h._dragging = false, l.call(k_.fill, h.bgcolor), i.on("mouseup", null), i.on("mousemove", null), i.on("touchend", null), i.on("touchmove", null), t.emit("plotly_sliderend", { slider: h, step: h.steps[h.active] });
+            }
+            i.on("mouseup", f), i.on("touchend", f);
+          }
+          e.on("mousedown", o), e.on("touchstart", o);
+        }
+        function bmt(e, t) {
+          var r = e.selectAll("rect." + Rs.tickRectClass).data(t._visibleSteps), n = t._dims;
+          r.enter().append("rect").classed(Rs.tickRectClass, true), r.exit().remove(), r.attr({ width: t.tickwidth + "px", "shape-rendering": "crispEdges" }), r.each(function(i, a) {
+            var o = a % n.labelStride === 0, s = Ug.select(this);
+            s.attr({ height: o ? t.ticklen : t.minorticklen }).call(k_.fill, t.tickcolor), Vg.setTranslate(s, sV(t, a / (t._stepCount - 1)) - 0.5 * t.tickwidth, (o ? Rs.tickOffset : Rs.minorTickOffset) + n.currentValueTotalHeight);
+          });
+        }
+        function wmt(e) {
+          var t = e._dims;
+          t.labelSteps = [];
+          for (var r = e._stepCount, n = 0; n < r; n += t.labelStride) t.labelSteps.push({ fraction: n / (r - 1), step: e._visibleSteps[n] });
+        }
+        function wge(e, t, r) {
+          for (var n = e.select("rect." + Rs.gripRectClass), i = 0, a = 0; a < t._stepCount; a++) if (t._visibleSteps[a]._index === t.active) {
+            i = a;
+            break;
+          }
+          var o = sV(t, i / (t._stepCount - 1));
+          if (!t._invokingCommand) {
+            var s = n;
+            r && t.transition.duration > 0 && (s = s.transition().duration(t.transition.duration).ease(t.transition.easing)), s.attr("transform", dmt(o - Rs.gripWidth * 0.5, t._dims.currentValueTotalHeight));
+          }
+        }
+        function sV(e, t) {
+          var r = e._dims;
+          return r.inputAreaStart + Rs.stepInset + (r.inputAreaLength - 2 * Rs.stepInset) * Math.min(1, Math.max(0, t));
+        }
+        function gge(e, t) {
+          var r = e._dims;
+          return Math.min(1, Math.max(0, (t - Rs.stepInset - r.inputAreaStart) / (r.inputAreaLength - 2 * Rs.stepInset - 2 * r.inputAreaStart)));
+        }
+        function Tmt(e, t, r) {
+          var n = r._dims, i = r0.ensureSingle(e, "rect", Rs.railTouchRectClass, function(a) {
+            a.call(bge, t, e, r).style("pointer-events", "all");
+          });
+          i.attr({ width: n.inputAreaLength, height: Math.max(n.inputAreaWidth, Rs.tickOffset + r.ticklen + n.labelHeight) }).call(k_.fill, r.bgcolor).attr("opacity", 0), Vg.setTranslate(i, 0, n.currentValueTotalHeight);
+        }
+        function Amt(e, t) {
+          var r = t._dims, n = r.inputAreaLength - Rs.railInset * 2, i = r0.ensureSingle(e, "rect", Rs.railRectClass);
+          i.attr({ width: n, height: Rs.railWidth, rx: Rs.railRadius, ry: Rs.railRadius, "shape-rendering": "crispEdges" }).call(k_.stroke, t.bordercolor).call(k_.fill, t.bgcolor).style("stroke-width", t.borderwidth + "px"), Vg.setTranslate(i, Rs.railInset, (r.inputAreaWidth - Rs.railWidth) * 0.5 + r.currentValueTotalHeight);
+        }
+      });
+      var Mge = ye((_lr, Sge) => {
+        var Smt = y4();
+        Sge.exports = { moduleType: "component", name: Smt.name, layoutAttributes: iV(), supplyLayoutDefaults: vge(), draw: Age() };
+      });
+      var CI = ye((xlr, kge) => {
+        var Ege = Ih();
+        kge.exports = { bgcolor: { valType: "color", dflt: Ege.background, editType: "plot" }, bordercolor: { valType: "color", dflt: Ege.defaultLine, editType: "plot" }, borderwidth: { valType: "integer", dflt: 0, min: 0, editType: "plot" }, autorange: { valType: "boolean", dflt: true, editType: "calc", impliedEdits: { "range[0]": void 0, "range[1]": void 0 } }, range: { valType: "info_array", items: [{ valType: "any", editType: "calc", impliedEdits: { "^autorange": false } }, { valType: "any", editType: "calc", impliedEdits: { "^autorange": false } }], editType: "calc", impliedEdits: { autorange: false } }, thickness: { valType: "number", dflt: 0.15, min: 0, max: 1, editType: "plot" }, visible: { valType: "boolean", dflt: true, editType: "calc" }, editType: "calc" };
+      });
+      var lV = ye((blr, Cge) => {
+        Cge.exports = { _isSubplotObj: true, rangemode: { valType: "enumerated", values: ["auto", "fixed", "match"], dflt: "match", editType: "calc" }, range: { valType: "info_array", items: [{ valType: "any", editType: "plot" }, { valType: "any", editType: "plot" }], editType: "plot" }, editType: "calc" };
+      });
+      var LI = ye((wlr, Lge) => {
+        Lge.exports = { name: "rangeslider", containerClassName: "rangeslider-container", bgClassName: "rangeslider-bg", rangePlotClassName: "rangeslider-rangeplot", maskMinClassName: "rangeslider-mask-min", maskMaxClassName: "rangeslider-mask-max", slideBoxClassName: "rangeslider-slidebox", grabberMinClassName: "rangeslider-grabber-min", grabAreaMinClassName: "rangeslider-grabarea-min", handleMinClassName: "rangeslider-handle-min", grabberMaxClassName: "rangeslider-grabber-max", grabAreaMaxClassName: "rangeslider-grabarea-max", handleMaxClassName: "rangeslider-handle-max", maskMinOppAxisClassName: "rangeslider-mask-min-opp-axis", maskMaxOppAxisClassName: "rangeslider-mask-max-opp-axis", maskColor: "rgba(0,0,0,0.4)", maskOppAxisColor: "rgba(0,0,0,0.2)", slideBoxFill: "transparent", slideBoxCursor: "ew-resize", grabAreaFill: "transparent", grabAreaCursor: "col-resize", grabAreaWidth: 10, handleWidth: 4, handleRadius: 1, handleStrokeWidth: 1, extraPad: 15 };
+      });
+      var Rge = ye((II) => {
+        var Mmt = hf(), Emt = Zl(), Pge = LI(), kmt = Dh().LINE_SPACING, PI = Pge.name;
+        function Ige(e) {
+          var t = e && e[PI];
+          return t && t.visible;
+        }
+        II.isVisible = Ige;
+        II.makeData = function(e) {
+          for (var t = Mmt.list({ _fullLayout: e }, "x", true), r = e.margin, n = [], i = 0; i < t.length; i++) {
+            var a = t[i];
+            if (Ige(a)) {
+              n.push(a);
+              var o = a[PI];
+              o._id = PI + a._id, o._height = (e.height - r.b - r.t) * o.thickness, o._offsetShift = Math.floor(o.borderwidth / 2);
+            }
+          }
+          e._rangeSliderData = n;
+        };
+        II.autoMarginOpts = function(e, t) {
+          var r = e._fullLayout, n = t[PI], i = t._id.charAt(0), a = 0, o = 0;
+          if (t.side === "bottom" && (a = t._depth, t.title.text !== r._dfltTitle[i])) {
+            o = 1.5 * t.title.font.size + 10 + n._offsetShift;
+            var s = (t.title.text.match(Emt.BR_TAG_ALL) || []).length;
+            o += s * t.title.font.size * kmt;
+          }
+          return { x: 0, y: t._counterDomainMin, l: 0, r: 0, t: 0, b: n._height + a + Math.max(r.margin.b, o), pad: Pge.extraPad + n._offsetShift * 2 };
+        };
+      });
+      var Oge = ye((Alr, zge) => {
+        var RI = Dr(), Dge = vl(), Fge = hf(), Cmt = CI(), Lmt = lV();
+        zge.exports = function(t, r, n) {
+          var i = t[n], a = r[n];
+          if (!(i.rangeslider || r._requestRangeslider[a._id])) return;
+          RI.isPlainObject(i.rangeslider) || (i.rangeslider = {});
+          var o = i.rangeslider, s = Dge.newContainer(a, "rangeslider");
+          function l(L, x) {
+            return RI.coerce(o, s, Cmt, L, x);
+          }
+          var u, c;
+          function f(L, x) {
+            return RI.coerce(u, c, Lmt, L, x);
+          }
+          var h = l("visible");
+          if (h) {
+            l("bgcolor", r.plot_bgcolor), l("bordercolor"), l("borderwidth"), l("thickness"), l("autorange", !a.isValidRange(o.range)), l("range");
+            var d = r._subplots;
+            if (d) for (var v = d.cartesian.filter(function(L) {
+              return L.slice(0, Math.max(0, L.indexOf("y"))) === Fge.name2id(n);
+            }).map(function(L) {
+              return L.slice(L.indexOf("y"), L.length);
+            }), _ = RI.simpleMap(v, Fge.id2name), b = 0; b < _.length; b++) {
+              var p = _[b];
+              u = o[p] || {}, c = Dge.newContainer(s, p, "yaxis");
+              var k = r[p], E;
+              u.range && k.isValidRange(u.range) && (E = "fixed");
+              var T = f("rangemode", E);
+              T !== "match" && f("range", k.range.slice());
+            }
+            s._input = o;
+          }
+        };
+      });
+      var Bge = ye((Slr, qge) => {
+        var Pmt = hf().list, Imt = Mg().getAutoRange, Rmt = LI();
+        qge.exports = function(t) {
+          for (var r = Pmt(t, "x", true), n = 0; n < r.length; n++) {
+            var i = r[n], a = i[Rmt.name];
+            a && a.visible && a.autorange && (a._input.autorange = true, a._input.range = a.range = Imt(t, i));
+          }
+        };
+      });
+      var Gge = ye((Mlr, Vge) => {
+        var DI = Oa(), Dmt = qa(), Fmt = Mc(), Jf = Dr(), FI = Jf.strTranslate, Uge = So(), C_ = ka(), zmt = zb(), Omt = mh(), uV = hf(), qmt = yv(), Bmt = Eg(), rl = LI();
+        Vge.exports = function(e) {
+          for (var t = e._fullLayout, r = t._rangeSliderData, n = 0; n < r.length; n++) {
+            var i = r[n][rl.name];
+            i._clipId = i._id + "-" + t._uid;
+          }
+          function a(s) {
+            return s._name;
+          }
+          var o = t._infolayer.selectAll("g." + rl.containerClassName).data(r, a);
+          o.exit().each(function(s) {
+            var l = s[rl.name];
+            t._topdefs.select("#" + l._clipId).remove();
+          }).remove(), r.length !== 0 && (o.enter().append("g").classed(rl.containerClassName, true).attr("pointer-events", "all"), o.each(function(s) {
+            var l = DI.select(this), u = s[rl.name], c = t[uV.id2name(s.anchor)], f = u[uV.id2name(s.anchor)];
+            if (u.range) {
+              var h = Jf.simpleMap(u.range, s.r2l), d = Jf.simpleMap(s.range, s.r2l), v;
+              d[0] < d[1] ? v = [Math.min(h[0], d[0]), Math.max(h[1], d[1])] : v = [Math.max(h[0], d[0]), Math.min(h[1], d[1])], u.range = u._input.range = Jf.simpleMap(v, s.l2r);
+            }
+            s.cleanRange("rangeslider.range");
+            var _ = t._size, b = s.domain;
+            u._width = _.w * (b[1] - b[0]);
+            var p = Math.round(_.l + _.w * b[0]), k = Math.round(_.t + _.h * (1 - s._counterDomainMin) + (s.side === "bottom" ? s._depth : 0) + u._offsetShift + rl.extraPad);
+            l.attr("transform", FI(p, k)), u._rl = Jf.simpleMap(u.range, s.r2l);
+            var E = u._rl[0], T = u._rl[1], L = T - E;
+            if (u.p2d = function(G) {
+              return G / u._width * L + E;
+            }, u.d2p = function(G) {
+              return (G - E) / L * u._width;
+            }, s.rangebreaks) {
+              var x = s.locateBreaks(E, T);
+              if (x.length) {
+                var C, M, g = 0;
+                for (C = 0; C < x.length; C++) M = x[C], g += M.max - M.min;
+                var P = u._width / (T - E - g), A = [-P * E];
+                for (C = 0; C < x.length; C++) M = x[C], A.push(A[A.length - 1] - P * (M.max - M.min));
+                for (u.d2p = function(G) {
+                  for (var Z = A[0], j = 0; j < x.length; j++) {
+                    var N = x[j];
+                    if (G >= N.max) Z = A[j + 1];
+                    else if (G < N.min) break;
+                  }
+                  return Z + P * G;
+                }, C = 0; C < x.length; C++) M = x[C], M.pmin = u.d2p(M.min), M.pmax = u.d2p(M.max);
+                u.p2d = function(G) {
+                  for (var Z = A[0], j = 0; j < x.length; j++) {
+                    var N = x[j];
+                    if (G >= N.pmax) Z = A[j + 1];
+                    else if (G < N.pmin) break;
+                  }
+                  return (G - Z) / P;
+                };
+              }
+            }
+            if (f.rangemode !== "match") {
+              var z = c.r2l(f.range[0]), O = c.r2l(f.range[1]), U = O - z;
+              u.d2pOppAxis = function(G) {
+                return (G - z) / U * u._height;
+              };
+            }
+            l.call(Gmt, e, s, u).call(Hmt, e, s, u).call(jmt, e, s, u).call(Xmt, e, s, u, f).call(Zmt, e, s, u).call(Ymt, e, s, u), Nmt(l, e, s, u), Vmt(l, e, s, u, c, f), s.side === "bottom" && zmt.draw(e, s._id + "title", { propContainer: s, propName: s._name + ".title.text", placeholder: t._dfltTitle.x, attributes: { x: s._offset + s._length / 2, y: k + u._height + u._offsetShift + 10 + 1.5 * s.title.font.size, "text-anchor": "middle" } });
+          }));
+        };
+        function Nge(e) {
+          return typeof e.clientX == "number" ? e.clientX : e.touches && e.touches.length > 0 ? e.touches[0].clientX : 0;
+        }
+        function Nmt(e, t, r, n) {
+          if (t._context.staticPlot) return;
+          var i = e.select("rect." + rl.slideBoxClassName).node(), a = e.select("rect." + rl.grabAreaMinClassName).node(), o = e.select("rect." + rl.grabAreaMaxClassName).node();
+          function s() {
+            var l = DI.event, u = l.target, c = Nge(l), f = c - e.node().getBoundingClientRect().left, h = n.d2p(r._rl[0]), d = n.d2p(r._rl[1]), v = qmt.coverSlip();
+            this.addEventListener("touchmove", _), this.addEventListener("touchend", b), v.addEventListener("mousemove", _), v.addEventListener("mouseup", b);
+            function _(p) {
+              var k = Nge(p), E = +k - c, T, L, x;
+              switch (u) {
+                case i:
+                  if (x = "ew-resize", h + E > r._length || d + E < 0) return;
+                  T = h + E, L = d + E;
+                  break;
+                case a:
+                  if (x = "col-resize", h + E > r._length) return;
+                  T = h + E, L = d;
+                  break;
+                case o:
+                  if (x = "col-resize", d + E < 0) return;
+                  T = h, L = d + E;
+                  break;
+                default:
+                  x = "ew-resize", T = f, L = f + E;
+                  break;
+              }
+              if (L < T) {
+                var C = L;
+                L = T, T = C;
+              }
+              n._pixelMin = T, n._pixelMax = L, Bmt(DI.select(v), x), Umt(e, t, r, n);
+            }
+            function b() {
+              v.removeEventListener("mousemove", _), v.removeEventListener("mouseup", b), this.removeEventListener("touchmove", _), this.removeEventListener("touchend", b), Jf.removeElement(v);
+            }
+          }
+          e.on("mousedown", s), e.on("touchstart", s);
+        }
+        function Umt(e, t, r, n) {
+          function i(s) {
+            return r.l2r(Jf.constrain(s, n._rl[0], n._rl[1]));
+          }
+          var a = i(n.p2d(n._pixelMin)), o = i(n.p2d(n._pixelMax));
+          window.requestAnimationFrame(function() {
+            Dmt.call("_guiRelayout", t, r._name + ".range", [a, o]);
+          });
+        }
+        function Vmt(e, t, r, n, i, a) {
+          var o = rl.handleWidth / 2;
+          function s(p) {
+            return Jf.constrain(p, 0, n._width);
+          }
+          function l(p) {
+            return Jf.constrain(p, 0, n._height);
+          }
+          function u(p) {
+            return Jf.constrain(p, -o, n._width + o);
+          }
+          var c = s(n.d2p(r._rl[0])), f = s(n.d2p(r._rl[1]));
+          if (e.select("rect." + rl.slideBoxClassName).attr("x", c).attr("width", f - c), e.select("rect." + rl.maskMinClassName).attr("width", c), e.select("rect." + rl.maskMaxClassName).attr("x", f).attr("width", n._width - f), a.rangemode !== "match") {
+            var h = n._height - l(n.d2pOppAxis(i._rl[1])), d = n._height - l(n.d2pOppAxis(i._rl[0]));
+            e.select("rect." + rl.maskMinOppAxisClassName).attr("x", c).attr("height", h).attr("width", f - c), e.select("rect." + rl.maskMaxOppAxisClassName).attr("x", c).attr("y", d).attr("height", n._height - d).attr("width", f - c), e.select("rect." + rl.slideBoxClassName).attr("y", h).attr("height", d - h);
+          }
+          var v = 0.5, _ = Math.round(u(c - o)) - v, b = Math.round(u(f - o)) + v;
+          e.select("g." + rl.grabberMinClassName).attr("transform", FI(_, v)), e.select("g." + rl.grabberMaxClassName).attr("transform", FI(b, v));
+        }
+        function Gmt(e, t, r, n) {
+          var i = Jf.ensureSingle(e, "rect", rl.bgClassName, function(l) {
+            l.attr({ x: 0, y: 0, "shape-rendering": "crispEdges" });
+          }), a = n.borderwidth % 2 === 0 ? n.borderwidth : n.borderwidth - 1, o = -n._offsetShift, s = Uge.crispRound(t, n.borderwidth);
+          i.attr({ width: n._width + a, height: n._height + a, transform: FI(o, o), "stroke-width": s }).call(C_.stroke, n.bordercolor).call(C_.fill, n.bgcolor);
+        }
+        function Hmt(e, t, r, n) {
+          var i = t._fullLayout, a = Jf.ensureSingleById(i._topdefs, "clipPath", n._clipId, function(o) {
+            o.append("rect").attr({ x: 0, y: 0 });
+          });
+          a.select("rect").attr({ width: n._width, height: n._height });
+        }
+        function jmt(e, t, r, n) {
+          var i = t.calcdata, a = e.selectAll("g." + rl.rangePlotClassName).data(r._subplotsWith, Jf.identity);
+          a.enter().append("g").attr("class", function(s) {
+            return rl.rangePlotClassName + " " + s;
+          }).call(Uge.setClipUrl, n._clipId, t), a.order(), a.exit().remove();
+          var o;
+          a.each(function(s, l) {
+            var u = DI.select(this), c = l === 0, f = uV.getFromId(t, s, "y"), h = f._name, d = n[h], v = { data: [], layout: { xaxis: { type: r.type, domain: [0, 1], range: n.range.slice(), calendar: r.calendar }, width: n._width, height: n._height, margin: { t: 0, b: 0, l: 0, r: 0 } }, _context: t._context };
+            r.rangebreaks && (v.layout.xaxis.rangebreaks = r.rangebreaks), v.layout[h] = { type: f.type, domain: [0, 1], range: d.rangemode !== "match" ? d.range.slice() : f.range.slice(), calendar: f.calendar }, f.rangebreaks && (v.layout[h].rangebreaks = f.rangebreaks), Fmt.supplyDefaults(v);
+            var _ = v._fullLayout.xaxis, b = v._fullLayout[h];
+            _.clearCalc(), _.setScale(), b.clearCalc(), b.setScale();
+            var p = { id: s, plotgroup: u, xaxis: _, yaxis: b, isRangePlot: true };
+            c ? o = p : (p.mainplot = "xy", p.mainplotinfo = o), Omt.rangePlot(t, p, Wmt(i, s));
+          });
+        }
+        function Wmt(e, t) {
+          for (var r = [], n = 0; n < e.length; n++) {
+            var i = e[n], a = i[0].trace;
+            a.xaxis + a.yaxis === t && r.push(i);
+          }
+          return r;
+        }
+        function Xmt(e, t, r, n, i) {
+          var a = Jf.ensureSingle(e, "rect", rl.maskMinClassName, function(u) {
+            u.attr({ x: 0, y: 0, "shape-rendering": "crispEdges" });
+          });
+          a.attr("height", n._height).call(C_.fill, rl.maskColor);
+          var o = Jf.ensureSingle(e, "rect", rl.maskMaxClassName, function(u) {
+            u.attr({ y: 0, "shape-rendering": "crispEdges" });
+          });
+          if (o.attr("height", n._height).call(C_.fill, rl.maskColor), i.rangemode !== "match") {
+            var s = Jf.ensureSingle(e, "rect", rl.maskMinOppAxisClassName, function(u) {
+              u.attr({ y: 0, "shape-rendering": "crispEdges" });
+            });
+            s.attr("width", n._width).call(C_.fill, rl.maskOppAxisColor);
+            var l = Jf.ensureSingle(e, "rect", rl.maskMaxOppAxisClassName, function(u) {
+              u.attr({ y: 0, "shape-rendering": "crispEdges" });
+            });
+            l.attr("width", n._width).style("border-top", rl.maskOppBorder).call(C_.fill, rl.maskOppAxisColor);
+          }
+        }
+        function Zmt(e, t, r, n) {
+          if (!t._context.staticPlot) {
+            var i = Jf.ensureSingle(e, "rect", rl.slideBoxClassName, function(a) {
+              a.attr({ y: 0, cursor: rl.slideBoxCursor, "shape-rendering": "crispEdges" });
+            });
+            i.attr({ height: n._height, fill: rl.slideBoxFill });
+          }
+        }
+        function Ymt(e, t, r, n) {
+          var i = Jf.ensureSingle(e, "g", rl.grabberMinClassName), a = Jf.ensureSingle(e, "g", rl.grabberMaxClassName), o = { x: 0, width: rl.handleWidth, rx: rl.handleRadius, fill: C_.background, stroke: C_.defaultLine, "stroke-width": rl.handleStrokeWidth, "shape-rendering": "crispEdges" }, s = { y: Math.round(n._height / 4), height: Math.round(n._height / 2) }, l = Jf.ensureSingle(i, "rect", rl.handleMinClassName, function(d) {
+            d.attr(o);
+          });
+          l.attr(s);
+          var u = Jf.ensureSingle(a, "rect", rl.handleMaxClassName, function(d) {
+            d.attr(o);
+          });
+          u.attr(s);
+          var c = { width: rl.grabAreaWidth, x: 0, y: 0, fill: rl.grabAreaFill, cursor: t._context.staticPlot ? void 0 : rl.grabAreaCursor }, f = Jf.ensureSingle(i, "rect", rl.grabAreaMinClassName, function(d) {
+            d.attr(c);
+          });
+          f.attr("height", n._height);
+          var h = Jf.ensureSingle(a, "rect", rl.grabAreaMaxClassName, function(d) {
+            d.attr(c);
+          });
+          h.attr("height", n._height);
+        }
+      });
+      var jge = ye((Elr, Hge) => {
+        var Kmt = Dr(), Jmt = CI(), $mt = lV(), cV = Rge();
+        Hge.exports = { moduleType: "component", name: "rangeslider", schema: { subplots: { xaxis: { rangeslider: Kmt.extendFlat({}, Jmt, { yaxis: $mt }) } } }, layoutAttributes: CI(), handleDefaults: Oge(), calcAutorange: Bge(), draw: Gge(), isVisible: cV.isVisible, makeData: cV.makeData, autoMarginOpts: cV.autoMarginOpts };
+      });
+      var zI = ye((klr, Xge) => {
+        var Qmt = ec(), Wge = Ih(), eyt = vl().templatedArray, tyt = eyt("button", { visible: { valType: "boolean", dflt: true, editType: "plot" }, step: { valType: "enumerated", values: ["month", "year", "day", "hour", "minute", "second", "all"], dflt: "month", editType: "plot" }, stepmode: { valType: "enumerated", values: ["backward", "todate"], dflt: "backward", editType: "plot" }, count: { valType: "number", min: 0, dflt: 1, editType: "plot" }, label: { valType: "string", editType: "plot" }, editType: "plot" });
+        Xge.exports = { visible: { valType: "boolean", editType: "plot" }, buttons: tyt, x: { valType: "number", min: -2, max: 3, editType: "plot" }, xanchor: { valType: "enumerated", values: ["auto", "left", "center", "right"], dflt: "left", editType: "plot" }, y: { valType: "number", min: -2, max: 3, editType: "plot" }, yanchor: { valType: "enumerated", values: ["auto", "top", "middle", "bottom"], dflt: "bottom", editType: "plot" }, font: Qmt({ editType: "plot" }), bgcolor: { valType: "color", dflt: Wge.lightLine, editType: "plot" }, activecolor: { valType: "color", editType: "plot" }, bordercolor: { valType: "color", dflt: Wge.defaultLine, editType: "plot" }, borderwidth: { valType: "number", min: 0, dflt: 0, editType: "plot" }, editType: "plot" };
+      });
+      var fV = ye((Clr, Zge) => {
+        Zge.exports = { yPad: 0.02, minButtonWidth: 30, rx: 3, ry: 3, lightAmount: 25, darkAmount: 10 };
+      });
+      var Jge = ye((Llr, Kge) => {
+        var OI = Dr(), ryt = ka(), iyt = vl(), nyt = Zd(), Yge = zI(), hV = fV();
+        Kge.exports = function(t, r, n, i, a) {
+          var o = t.rangeselector || {}, s = iyt.newContainer(r, "rangeselector");
+          function l(d, v) {
+            return OI.coerce(o, s, Yge, d, v);
+          }
+          var u = nyt(o, s, { name: "buttons", handleItemDefaults: ayt, calendar: a }), c = l("visible", u.length > 0);
+          if (c) {
+            var f = oyt(r, n, i);
+            l("x", f[0]), l("y", f[1]), OI.noneOrAll(t, r, ["x", "y"]), l("xanchor"), l("yanchor"), OI.coerceFont(l, "font", n.font);
+            var h = l("bgcolor");
+            l("activecolor", ryt.contrast(h, hV.lightAmount, hV.darkAmount)), l("bordercolor"), l("borderwidth");
+          }
+        };
+        function ayt(e, t, r, n) {
+          var i = n.calendar;
+          function a(l, u) {
+            return OI.coerce(e, t, Yge.buttons, l, u);
+          }
+          var o = a("visible");
+          if (o) {
+            var s = a("step");
+            s !== "all" && (i && i !== "gregorian" && (s === "month" || s === "year") ? t.stepmode = "backward" : a("stepmode"), a("count")), a("label");
+          }
+        }
+        function oyt(e, t, r) {
+          for (var n = r.filter(function(s) {
+            return t[s].anchor === e._id;
+          }), i = 0, a = 0; a < n.length; a++) {
+            var o = t[n[a]].domain;
+            o && (i = Math.max(o[1], i));
+          }
+          return [e.domain[0], i + hV.yPad];
+        }
+      });
+      var Qge = ye((Plr, $ge) => {
+        var syt = SO(), lyt = Dr().titleCase;
+        $ge.exports = function(t, r) {
+          var n = t._name, i = {};
+          if (r.step === "all") i[n + ".autorange"] = true;
+          else {
+            var a = uyt(t, r);
+            i[n + ".range[0]"] = a[0], i[n + ".range[1]"] = a[1];
+          }
+          return i;
+        };
+        function uyt(e, t) {
+          var r = e.range, n = new Date(e.r2l(r[1])), i = t.step, a = syt["utc" + lyt(i)], o = t.count, s;
+          switch (t.stepmode) {
+            case "backward":
+              s = e.l2r(+a.offset(n, -o));
+              break;
+            case "todate":
+              var l = a.offset(n, -o);
+              s = e.l2r(+a.ceil(l));
+              break;
+          }
+          var u = r[1];
+          return [s, u];
+        }
+      });
+      var sme = ye((Ilr, ome) => {
+        var BI = Oa(), cyt = qa(), fyt = Mc(), eme = ka(), ame = So(), Ny = Dr(), tme = Ny.strTranslate, qI = Zl(), hyt = hf(), pV = Dh(), rme = pV.LINE_SPACING, ime = pV.FROM_TL, nme = pV.FROM_BR, vV = fV(), dyt = Qge();
+        ome.exports = function(t) {
+          var r = t._fullLayout, n = r._infolayer.selectAll(".rangeselector").data(vyt(t), pyt);
+          n.enter().append("g").classed("rangeselector", true), n.exit().remove(), n.style({ cursor: "pointer", "pointer-events": "all" }), n.each(function(i) {
+            var a = BI.select(this), o = i, s = o.rangeselector, l = a.selectAll("g.button").data(Ny.filterVisible(s.buttons));
+            l.enter().append("g").classed("button", true), l.exit().remove(), l.each(function(u) {
+              var c = BI.select(this), f = dyt(o, u);
+              u._isActive = gyt(o, u, f), c.call(dV, s, u), c.call(yyt, s, u, t), c.on("click", function() {
+                t._dragged || cyt.call("_guiRelayout", t, f);
+              }), c.on("mouseover", function() {
+                u._isHovered = true, c.call(dV, s, u);
+              }), c.on("mouseout", function() {
+                u._isHovered = false, c.call(dV, s, u);
+              });
+            }), xyt(t, l, s, o._name, a);
+          });
+        };
+        function vyt(e) {
+          for (var t = hyt.list(e, "x", true), r = [], n = 0; n < t.length; n++) {
+            var i = t[n];
+            i.rangeselector && i.rangeselector.visible && r.push(i);
+          }
+          return r;
+        }
+        function pyt(e) {
+          return e._id;
+        }
+        function gyt(e, t, r) {
+          if (t.step === "all") return e.autorange === true;
+          var n = Object.keys(r);
+          return e.range[0] === r[n[0]] && e.range[1] === r[n[1]];
+        }
+        function dV(e, t, r) {
+          var n = Ny.ensureSingle(e, "rect", "selector-rect", function(i) {
+            i.attr("shape-rendering", "crispEdges");
+          });
+          n.attr({ rx: vV.rx, ry: vV.ry }), n.call(eme.stroke, t.bordercolor).call(eme.fill, myt(t, r)).style("stroke-width", t.borderwidth + "px");
+        }
+        function myt(e, t) {
+          return t._isActive || t._isHovered ? e.activecolor : e.bgcolor;
+        }
+        function yyt(e, t, r, n) {
+          function i(o) {
+            qI.convertToTspans(o, n);
+          }
+          var a = Ny.ensureSingle(e, "text", "selector-text", function(o) {
+            o.attr("text-anchor", "middle");
+          });
+          a.call(ame.font, t.font).text(_yt(r, n._fullLayout._meta)).call(i);
+        }
+        function _yt(e, t) {
+          return e.label ? t ? Ny.templateString(e.label, t) : e.label : e.step === "all" ? "all" : e.count + e.step.charAt(0);
+        }
+        function xyt(e, t, r, n, i) {
+          var a = 0, o = 0, s = r.borderwidth;
+          t.each(function() {
+            var d = BI.select(this), v = d.select(".selector-text"), _ = r.font.size * rme, b = Math.max(_ * qI.lineCount(v), 16) + 3;
+            o = Math.max(o, b);
+          }), t.each(function() {
+            var d = BI.select(this), v = d.select(".selector-rect"), _ = d.select(".selector-text"), b = _.node() && ame.bBox(_.node()).width, p = r.font.size * rme, k = qI.lineCount(_), E = Math.max(b + 10, vV.minButtonWidth);
+            d.attr("transform", tme(s + a, s)), v.attr({ x: 0, y: 0, width: E, height: o }), qI.positionText(_, E / 2, o / 2 - (k - 1) * p / 2 + 3), a += E + 5;
+          });
+          var l = e._fullLayout._size, u = l.l + l.w * r.x, c = l.t + l.h * (1 - r.y), f = "left";
+          Ny.isRightAnchor(r) && (u -= a, f = "right"), Ny.isCenterAnchor(r) && (u -= a / 2, f = "center");
+          var h = "top";
+          Ny.isBottomAnchor(r) && (c -= o, h = "bottom"), Ny.isMiddleAnchor(r) && (c -= o / 2, h = "middle"), a = Math.ceil(a), o = Math.ceil(o), u = Math.round(u), c = Math.round(c), fyt.autoMargin(e, n + "-range-selector", { x: r.x, y: r.y, l: a * ime[f], r: a * nme[f], b: o * nme[h], t: o * ime[h] }), i.attr("transform", tme(u, c));
+        }
+      });
+      var ume = ye((Rlr, lme) => {
+        lme.exports = { moduleType: "component", name: "rangeselector", schema: { subplots: { xaxis: { rangeselector: zI() } } }, layoutAttributes: zI(), handleDefaults: Jge(), draw: sme() };
+      });
+      var Cc = ye((gV) => {
+        var cme = Ao().extendFlat;
+        gV.attributes = function(e, t) {
+          e = e || {}, t = t || {};
+          var r = { valType: "info_array", editType: e.editType, items: [{ valType: "number", min: 0, max: 1, editType: e.editType }, { valType: "number", min: 0, max: 1, editType: e.editType }], dflt: [0, 1] };
+          e.name ? e.name + " " : "";
+          e.trace ? "trace " : "subplot ";
+          t.description ? " " + t.description : "";
+          var o = { x: cme({}, r, {}), y: cme({}, r, {}), editType: e.editType };
+          return e.noGridCell || (o.row = { valType: "integer", min: 0, dflt: 0, editType: e.editType }, o.column = { valType: "integer", min: 0, dflt: 0, editType: e.editType }), o;
+        };
+        gV.defaults = function(e, t, r, n) {
+          var i = n && n.x || [0, 1], a = n && n.y || [0, 1], o = t.grid;
+          if (o) {
+            var s = r("domain.column");
+            s !== void 0 && (s < o.columns ? i = o._domains.x[s] : delete e.domain.column);
+            var l = r("domain.row");
+            l !== void 0 && (l < o.rows ? a = o._domains.y[l] : delete e.domain.row);
+          }
+          var u = r("domain.x", i), c = r("domain.y", a);
+          u[0] < u[1] || (e.domain.x = i.slice()), c[0] < c[1] || (e.domain.y = a.slice());
+        };
+      });
+      var yV = ye((Flr, vme) => {
+        var byt = Dr(), wyt = p3().counter, Tyt = Cc().attributes, fme = Rh().idRegex, Ayt = vl(), mV = { rows: { valType: "integer", min: 1, editType: "plot" }, roworder: { valType: "enumerated", values: ["top to bottom", "bottom to top"], dflt: "top to bottom", editType: "plot" }, columns: { valType: "integer", min: 1, editType: "plot" }, subplots: { valType: "info_array", freeLength: true, dimensions: 2, items: { valType: "enumerated", values: [wyt("xy").toString(), ""], editType: "plot" }, editType: "plot" }, xaxes: { valType: "info_array", freeLength: true, items: { valType: "enumerated", values: [fme.x.toString(), ""], editType: "plot" }, editType: "plot" }, yaxes: { valType: "info_array", freeLength: true, items: { valType: "enumerated", values: [fme.y.toString(), ""], editType: "plot" }, editType: "plot" }, pattern: { valType: "enumerated", values: ["independent", "coupled"], dflt: "coupled", editType: "plot" }, xgap: { valType: "number", min: 0, max: 1, editType: "plot" }, ygap: { valType: "number", min: 0, max: 1, editType: "plot" }, domain: Tyt({ name: "grid", editType: "plot", noGridCell: true }, {}), xside: { valType: "enumerated", values: ["bottom", "bottom plot", "top plot", "top"], dflt: "bottom plot", editType: "plot" }, yside: { valType: "enumerated", values: ["left", "left plot", "right plot", "right"], dflt: "left plot", editType: "plot" }, editType: "plot" };
+        function NI(e, t, r) {
+          var n = t[r + "axes"], i = Object.keys((e._splomAxes || {})[r] || {});
+          if (Array.isArray(n)) return n;
+          if (i.length) return i;
+        }
+        function Syt(e, t) {
+          var r = e.grid || {}, n = NI(t, r, "x"), i = NI(t, r, "y");
+          if (!e.grid && !n && !i) return;
+          var a = Array.isArray(r.subplots) && Array.isArray(r.subplots[0]), o = Array.isArray(n), s = Array.isArray(i), l = o && n !== r.xaxes && s && i !== r.yaxes, u, c;
+          a ? (u = r.subplots.length, c = r.subplots[0].length) : (s && (u = i.length), o && (c = n.length));
+          var f = Ayt.newContainer(t, "grid");
+          function h(x, C) {
+            return byt.coerce(r, f, mV, x, C);
+          }
+          var d = h("rows", u), v = h("columns", c);
+          if (!(d * v > 1)) {
+            delete t.grid;
+            return;
+          }
+          if (!a && !o && !s) {
+            var _ = h("pattern") === "independent";
+            _ && (a = true);
+          }
+          f._hasSubplotGrid = a;
+          var b = h("roworder"), p = b === "top to bottom", k = a ? 0.2 : 0.1, E = a ? 0.3 : 0.1, T, L;
+          l && t._splomGridDflt && (T = t._splomGridDflt.xside, L = t._splomGridDflt.yside), f._domains = { x: hme("x", h, k, T, v), y: hme("y", h, E, L, d, p) };
+        }
+        function hme(e, t, r, n, i, a) {
+          var o = t(e + "gap", r), s = t("domain." + e);
+          t(e + "side", n);
+          for (var l = new Array(i), u = s[0], c = (s[1] - u) / (i - o), f = c * (1 - o), h = 0; h < i; h++) {
+            var d = u + c * h;
+            l[a ? i - 1 - h : h] = [d, d + f];
+          }
+          return l;
+        }
+        function Myt(e, t) {
+          var r = t.grid;
+          if (!(!r || !r._domains)) {
+            var n = e.grid || {}, i = t._subplots, a = r._hasSubplotGrid, o = r.rows, s = r.columns, l = r.pattern === "independent", u, c, f, h, d, v, _, b = r._axisMap = {};
+            if (a) {
+              var p = n.subplots || [];
+              v = r.subplots = new Array(o);
+              var k = 1;
+              for (u = 0; u < o; u++) {
+                var E = v[u] = new Array(s), T = p[u] || [];
+                for (c = 0; c < s; c++) if (l ? (d = k === 1 ? "xy" : "x" + k + "y" + k, k++) : d = T[c], E[c] = "", i.cartesian.indexOf(d) !== -1) {
+                  if (_ = d.indexOf("y"), f = d.slice(0, _), h = d.slice(_), b[f] !== void 0 && b[f] !== c || b[h] !== void 0 && b[h] !== u) continue;
+                  E[c] = d, b[f] = c, b[h] = u;
+                }
+              }
+            } else {
+              var L = NI(t, n, "x"), x = NI(t, n, "y");
+              r.xaxes = dme(L, i.xaxis, s, b, "x"), r.yaxes = dme(x, i.yaxis, o, b, "y");
+            }
+            var C = r._anchors = {}, M = r.roworder === "top to bottom";
+            for (var g in b) {
+              var P = g.charAt(0), A = r[P + "side"], z, O, U;
+              if (A.length < 8) C[g] = "free";
+              else if (P === "x") {
+                if (A.charAt(0) === "t" === M ? (z = 0, O = 1, U = o) : (z = o - 1, O = -1, U = -1), a) {
+                  var G = b[g];
+                  for (u = z; u !== U; u += O) if (d = v[u][G], !!d && (_ = d.indexOf("y"), d.slice(0, _) === g)) {
+                    C[g] = d.slice(_);
+                    break;
+                  }
+                } else for (u = z; u !== U; u += O) if (h = r.yaxes[u], i.cartesian.indexOf(g + h) !== -1) {
+                  C[g] = h;
+                  break;
+                }
+              } else if (A.charAt(0) === "l" ? (z = 0, O = 1, U = s) : (z = s - 1, O = -1, U = -1), a) {
+                var Z = b[g];
+                for (u = z; u !== U; u += O) if (d = v[Z][u], !!d && (_ = d.indexOf("y"), d.slice(_) === g)) {
+                  C[g] = d.slice(0, _);
+                  break;
+                }
+              } else for (u = z; u !== U; u += O) if (f = r.xaxes[u], i.cartesian.indexOf(f + g) !== -1) {
+                C[g] = f;
+                break;
+              }
+            }
+          }
+        }
+        function dme(e, t, r, n, i) {
+          var a = new Array(r), o;
+          function s(l, u) {
+            t.indexOf(u) !== -1 && n[u] === void 0 ? (a[l] = u, n[u] = l) : a[l] = "";
+          }
+          if (Array.isArray(e)) for (o = 0; o < r; o++) s(o, e[o]);
+          else for (s(0, i), o = 1; o < r; o++) s(o, i + (o + 1));
+          return a;
+        }
+        vme.exports = { moduleType: "component", name: "grid", schema: { layout: { grid: mV } }, layoutAttributes: mV, sizeDefaults: Syt, contentDefaults: Myt };
+      });
+      var _V = ye((zlr, pme) => {
+        pme.exports = { visible: { valType: "boolean", editType: "calc" }, type: { valType: "enumerated", values: ["percent", "constant", "sqrt", "data"], editType: "calc" }, symmetric: { valType: "boolean", editType: "calc" }, array: { valType: "data_array", editType: "calc" }, arrayminus: { valType: "data_array", editType: "calc" }, value: { valType: "number", min: 0, dflt: 10, editType: "calc" }, valueminus: { valType: "number", min: 0, dflt: 10, editType: "calc" }, traceref: { valType: "integer", min: 0, dflt: 0, editType: "style" }, tracerefminus: { valType: "integer", min: 0, dflt: 0, editType: "style" }, copy_ystyle: { valType: "boolean", editType: "plot" }, copy_zstyle: { valType: "boolean", editType: "style" }, color: { valType: "color", editType: "style" }, thickness: { valType: "number", min: 0, dflt: 2, editType: "style" }, width: { valType: "number", min: 0, editType: "plot" }, editType: "calc" };
+      });
+      var yme = ye((Olr, mme) => {
+        var gme = Eo(), Eyt = qa(), kyt = Dr(), Cyt = vl(), Lyt = _V();
+        mme.exports = function(e, t, r, n) {
+          var i = "error_" + n.axis, a = Cyt.newContainer(t, i), o = e[i] || {};
+          function s(v, _) {
+            return kyt.coerce(o, a, Lyt, v, _);
+          }
+          var l = o.array !== void 0 || o.value !== void 0 || o.type === "sqrt", u = s("visible", l);
+          if (u !== false) {
+            var c = s("type", "array" in o ? "data" : "percent"), f = true;
+            c !== "sqrt" && (f = s("symmetric", !((c === "data" ? "arrayminus" : "valueminus") in o))), c === "data" ? (s("array"), s("traceref"), f || (s("arrayminus"), s("tracerefminus"))) : (c === "percent" || c === "constant") && (s("value"), f || s("valueminus"));
+            var h = "copy_" + n.inherit + "style";
+            if (n.inherit) {
+              var d = t["error_" + n.inherit];
+              (d || {}).visible && s(h, !(o.color || gme(o.thickness) || gme(o.width)));
+            }
+            (!n.inherit || !a[h]) && (s("color", r), s("thickness"), s("width", Eyt.traceIs(t, "gl3d") ? 0 : 4));
+          }
+        };
+      });
+      var xV = ye((qlr, xme) => {
+        xme.exports = function(t) {
+          var r = t.type, n = t.symmetric;
+          if (r === "data") {
+            var i = t.array || [];
+            if (n) return function(u, c) {
+              var f = +i[c];
+              return [f, f];
+            };
+            var a = t.arrayminus || [];
+            return function(u, c) {
+              var f = +i[c], h = +a[c];
+              return !isNaN(f) || !isNaN(h) ? [h || 0, f || 0] : [NaN, NaN];
+            };
+          } else {
+            var o = _me(r, t.value), s = _me(r, t.valueminus);
+            return n || t.valueminus === void 0 ? function(u) {
+              var c = o(u);
+              return [c, c];
+            } : function(u) {
+              return [s(u), o(u)];
+            };
+          }
+        };
+        function _me(e, t) {
+          if (e === "percent") return function(r) {
+            return Math.abs(r * t / 100);
+          };
+          if (e === "constant") return function() {
+            return Math.abs(t);
+          };
+          if (e === "sqrt") return function(r) {
+            return Math.sqrt(Math.abs(r));
+          };
+        }
+      });
+      var Tme = ye((Blr, wme) => {
+        var bV = Eo(), Pyt = qa(), wV = ho(), Iyt = Dr(), Ryt = xV();
+        wme.exports = function(t) {
+          for (var r = t.calcdata, n = 0; n < r.length; n++) {
+            var i = r[n], a = i[0].trace;
+            if (a.visible === true && Pyt.traceIs(a, "errorBarsOK")) {
+              var o = wV.getFromId(t, a.xaxis), s = wV.getFromId(t, a.yaxis);
+              bme(i, a, o, "x"), bme(i, a, s, "y");
+            }
+          }
+        };
+        function bme(e, t, r, n) {
+          var i = t["error_" + n] || {}, a = i.visible && ["linear", "log"].indexOf(r.type) !== -1, o = [];
+          if (a) {
+            for (var s = Ryt(i), l = 0; l < e.length; l++) {
+              var u = e[l], c = u.i;
+              if (c === void 0) c = l;
+              else if (c === null) continue;
+              var f = u[n];
+              if (bV(r.c2l(f))) {
+                var h = s(f, c);
+                if (bV(h[0]) && bV(h[1])) {
+                  var d = u[n + "s"] = f - h[0], v = u[n + "h"] = f + h[1];
+                  o.push(d, v);
+                }
+              }
+            }
+            var _ = r._id, b = t._extremes[_], p = wV.findExtremes(r, o, Iyt.extendFlat({ tozero: b.opts.tozero }, { padded: true }));
+            b.min = b.min.concat(p.min), b.max = b.max.concat(p.max);
+          }
+        }
+      });
+      var Mme = ye((Nlr, Sme) => {
+        var Ame = Oa(), L_ = Eo(), Dyt = So(), Fyt = Ru();
+        Sme.exports = function(t, r, n, i) {
+          var a, o = n.xaxis, s = n.yaxis, l = i && i.duration > 0, u = t._context.staticPlot;
+          r.each(function(c) {
+            var f = c[0].trace, h = f.error_x || {}, d = f.error_y || {}, v;
+            f.ids && (v = function(k) {
+              return k.id;
+            });
+            var _ = Fyt.hasMarkers(f) && f.marker.maxdisplayed > 0;
+            !d.visible && !h.visible && (c = []);
+            var b = Ame.select(this).selectAll("g.errorbar").data(c, v);
+            if (b.exit().remove(), !!c.length) {
+              h.visible || b.selectAll("path.xerror").remove(), d.visible || b.selectAll("path.yerror").remove(), b.style("opacity", 1);
+              var p = b.enter().append("g").classed("errorbar", true);
+              l && p.style("opacity", 0).transition().duration(i.duration).style("opacity", 1), Dyt.setClipUrl(b, n.layerClipId, t), b.each(function(k) {
+                var E = Ame.select(this), T = zyt(k, o, s);
+                if (!(_ && !k.vis)) {
+                  var L, x = E.select("path.yerror");
+                  if (d.visible && L_(T.x) && L_(T.yh) && L_(T.ys)) {
+                    var C = d.width;
+                    L = "M" + (T.x - C) + "," + T.yh + "h" + 2 * C + "m-" + C + ",0V" + T.ys, T.noYS || (L += "m-" + C + ",0h" + 2 * C), a = !x.size(), a ? x = E.append("path").style("vector-effect", u ? "none" : "non-scaling-stroke").classed("yerror", true) : l && (x = x.transition().duration(i.duration).ease(i.easing)), x.attr("d", L);
+                  } else x.remove();
+                  var M = E.select("path.xerror");
+                  if (h.visible && L_(T.y) && L_(T.xh) && L_(T.xs)) {
+                    var g = (h.copy_ystyle ? d : h).width;
+                    L = "M" + T.xh + "," + (T.y - g) + "v" + 2 * g + "m0,-" + g + "H" + T.xs, T.noXS || (L += "m0,-" + g + "v" + 2 * g), a = !M.size(), a ? M = E.append("path").style("vector-effect", u ? "none" : "non-scaling-stroke").classed("xerror", true) : l && (M = M.transition().duration(i.duration).ease(i.easing)), M.attr("d", L);
+                  } else M.remove();
+                }
+              });
+            }
+          });
+        };
+        function zyt(e, t, r) {
+          var n = { x: t.c2p(e.x), y: r.c2p(e.y) };
+          return e.yh !== void 0 && (n.yh = r.c2p(e.yh), n.ys = r.c2p(e.ys), L_(n.ys) || (n.noYS = true, n.ys = r.c2p(e.ys, true))), e.xh !== void 0 && (n.xh = t.c2p(e.xh), n.xs = t.c2p(e.xs), L_(n.xs) || (n.noXS = true, n.xs = t.c2p(e.xs, true))), n;
+        }
+      });
+      var Cme = ye((Ulr, kme) => {
+        var Oyt = Oa(), Eme = ka();
+        kme.exports = function(t) {
+          t.each(function(r) {
+            var n = r[0].trace, i = n.error_y || {}, a = n.error_x || {}, o = Oyt.select(this);
+            o.selectAll("path.yerror").style("stroke-width", i.thickness + "px").call(Eme.stroke, i.color), a.copy_ystyle && (a = i), o.selectAll("path.xerror").style("stroke-width", a.thickness + "px").call(Eme.stroke, a.color);
+          });
+        };
+      });
+      var Ime = ye((Vlr, Pme) => {
+        var x4 = Dr(), Lme = mc().overrideAll, b4 = _V(), u2 = { error_x: x4.extendFlat({}, b4), error_y: x4.extendFlat({}, b4) };
+        delete u2.error_x.copy_zstyle;
+        delete u2.error_y.copy_zstyle;
+        delete u2.error_y.copy_ystyle;
+        var w4 = { error_x: x4.extendFlat({}, b4), error_y: x4.extendFlat({}, b4), error_z: x4.extendFlat({}, b4) };
+        delete w4.error_x.copy_ystyle;
+        delete w4.error_y.copy_ystyle;
+        delete w4.error_z.copy_ystyle;
+        delete w4.error_z.copy_zstyle;
+        Pme.exports = { moduleType: "component", name: "errorbars", schema: { traces: { scatter: u2, bar: u2, histogram: u2, scatter3d: Lme(w4, "calc", "nested"), scattergl: Lme(u2, "calc", "nested") } }, supplyDefaults: yme(), calc: Tme(), makeComputeError: xV(), plot: Mme(), style: Cme(), hoverInfo: qyt };
+        function qyt(e, t, r) {
+          (t.error_y || {}).visible && (r.yerr = e.yh - e.y, t.error_y.symmetric || (r.yerrneg = e.y - e.ys)), (t.error_x || {}).visible && (r.xerr = e.xh - e.x, t.error_x.symmetric || (r.xerrneg = e.x - e.xs));
+        }
+      });
+      var Dme = ye((Glr, Rme) => {
+        Rme.exports = { cn: { colorbar: "colorbar", cbbg: "cbbg", cbfill: "cbfill", cbfills: "cbfills", cbline: "cbline", cblines: "cblines", cbaxis: "cbaxis", cbtitleunshift: "cbtitleunshift", cbtitle: "cbtitle", cboutline: "cboutline", crisp: "crisp", jsPlaceholder: "js-placeholder" } };
+      });
+      var Ume = ye((Hlr, Nme) => {
+        var P_ = Oa(), TV = fd(), VI = Mc(), Fme = qa(), Uy = ho(), UI = yv(), U0 = Dr(), Hg = U0.strTranslate, Bme = Ao().extendFlat, AV = Eg(), Gg = So(), SV = ka(), Byt = zb(), Nyt = Zl(), Uyt = pv().flipScale, Vyt = f4(), Gyt = dI(), Hyt = Rd(), MV = Dh(), zme = MV.LINE_SPACING, Ome = MV.FROM_TL, qme = MV.FROM_BR, gf = Dme().cn;
+        function jyt(e) {
+          var t = e._fullLayout, r = t._infolayer.selectAll("g." + gf.colorbar).data(Wyt(e), function(n) {
+            return n._id;
+          });
+          r.enter().append("g").attr("class", function(n) {
+            return n._id;
+          }).classed(gf.colorbar, true), r.each(function(n) {
+            var i = P_.select(this);
+            U0.ensureSingle(i, "rect", gf.cbbg), U0.ensureSingle(i, "g", gf.cbfills), U0.ensureSingle(i, "g", gf.cblines), U0.ensureSingle(i, "g", gf.cbaxis, function(o) {
+              o.classed(gf.crisp, true);
+            }), U0.ensureSingle(i, "g", gf.cbtitleunshift, function(o) {
+              o.append("g").classed(gf.cbtitle, true);
+            }), U0.ensureSingle(i, "rect", gf.cboutline);
+            var a = Xyt(i, n, e);
+            a && a.then && (e._promises || []).push(a), e._context.edits.colorbarPosition && Zyt(i, n, e);
+          }), r.exit().each(function(n) {
+            VI.autoMargin(e, n._id);
+          }).remove(), r.order();
+        }
+        function Wyt(e) {
+          var t = e._fullLayout, r = e.calcdata, n = [], i, a, o, s;
+          function l(E) {
+            return Bme(E, { _fillcolor: null, _line: { color: null, width: null, dash: null }, _levels: { start: null, end: null, size: null }, _filllevels: null, _fillgradient: null, _zrange: null });
+          }
+          function u() {
+            typeof s.calc == "function" ? s.calc(e, o, i) : (i._fillgradient = a.reversescale ? Uyt(a.colorscale) : a.colorscale, i._zrange = [a[s.min], a[s.max]]);
+          }
+          for (var c = 0; c < r.length; c++) {
+            var f = r[c];
+            if (o = f[0].trace, !!o._module) {
+              var h = o._module.colorbar;
+              if (o.visible === true && h) for (var d = Array.isArray(h), v = d ? h : [h], _ = 0; _ < v.length; _++) {
+                s = v[_];
+                var b = s.container;
+                a = b ? o[b] : o, a && a.showscale && (i = l(a.colorbar), i._id = "cb" + o.uid + (d && b ? "-" + b : ""), i._traceIndex = o.index, i._propPrefix = (b ? b + "." : "") + "colorbar.", i._meta = o._meta, u(), n.push(i));
+              }
+            }
+          }
+          for (var p in t._colorAxes) if (a = t[p], a.showscale) {
+            var k = t._colorAxes[p];
+            i = l(a.colorbar), i._id = "cb" + p, i._propPrefix = p + ".colorbar.", i._meta = t._meta, s = { min: "cmin", max: "cmax" }, k[0] !== "heatmap" && (o = k[1], s.calc = o._module.colorbar.calc), u(), n.push(i);
+          }
+          return n;
+        }
+        function Xyt(e, t, r) {
+          var n = t.orientation === "v", i = t.len, a = t.lenmode, o = t.thickness, s = t.thicknessmode, l = t.outlinewidth, u = t.borderwidth, c = t.bgcolor, f = t.xanchor, h = t.yanchor, d = t.xpad, v = t.ypad, _ = t.x, b = n ? t.y : 1 - t.y, p = t.yref === "paper", k = t.xref === "paper", E = r._fullLayout, T = E._size, L = t._fillcolor, x = t._line, C = t.title, M = C.side, g = t._zrange || P_.extent((typeof L == "function" ? L : x.color).domain()), P = typeof x.color == "function" ? x.color : function() {
+            return x.color;
+          }, A = typeof L == "function" ? L : function() {
+            return L;
+          }, z = t._levels, O = Yyt(r, t, g), U = O.fill, G = O.line, Z = Math.round(o * (s === "fraction" ? n ? T.w : T.h : 1)), j = Z / (n ? T.w : T.h), N = Math.round(i * (a === "fraction" ? n ? T.h : T.w : 1)), H = N / (n ? T.h : T.w), re = k ? T.w : r._fullLayout.width, oe = p ? T.h : r._fullLayout.height, _e = Math.round(n ? _ * re + d : b * oe + v), Ce = { center: 0.5, right: 1 }[f] || 0, Le = { top: 1, middle: 0.5 }[h] || 0, ge = n ? _ - Ce * j : b - Le * j, ie = n ? b - Le * H : _ - Ce * H, Se = Math.round(n ? oe * (1 - ie) : re * ie);
+          t._lenFrac = H, t._thickFrac = j, t._uFrac = ge, t._vFrac = ie;
+          var Ee = t._axis = Kyt(r, t, g);
+          Ee.position = j + (n ? _ + d / T.w : b + v / T.h);
+          var Ae = ["top", "bottom"].indexOf(M) !== -1;
+          if (n && Ae && (Ee.title.side = M, Ee.titlex = _ + d / T.w, Ee.titley = ie + (C.side === "top" ? H - v / T.h : v / T.h)), !n && !Ae && (Ee.title.side = M, Ee.titley = b + v / T.h, Ee.titlex = ie + d / T.w), x.color && t.tickmode === "auto") {
+            Ee.tickmode = "linear", Ee.tick0 = z.start;
+            var Be = z.size, Pe = U0.constrain(N / 50, 4, 15) + 1, me = (g[1] - g[0]) / ((t.nticks || Pe) * Be);
+            if (me > 1) {
+              var De = Math.pow(10, Math.floor(Math.log(me) / Math.LN10));
+              Be *= De * U0.roundUp(me / De, [2, 5, 10]), (Math.abs(z.start) / z.size + 1e-6) % 1 < 2e-6 && (Ee.tick0 = 0);
+            }
+            Ee.dtick = Be;
+          }
+          Ee.domain = n ? [ie + v / T.h, ie + H - v / T.h] : [ie + d / T.w, ie + H - d / T.w], Ee.setScale(), e.attr("transform", Hg(Math.round(T.l), Math.round(T.t)));
+          var ce = e.select("." + gf.cbtitleunshift).attr("transform", Hg(-Math.round(T.l), -Math.round(T.t))), je = Ee.ticklabelposition, lt = Ee.title.font.size, pt = e.select("." + gf.cbaxis), Vt, ot = 0, ut = 0;
+          function Wt(fr, $e) {
+            var St = { propContainer: Ee, propName: t._propPrefix + "title.text", traceIndex: t._traceIndex, _meta: t._meta, placeholder: E._dfltTitle.colorbar, containerGroup: e.select("." + gf.cbtitle) }, Qt = fr.charAt(0) === "h" ? fr.slice(1) : "h" + fr;
+            e.selectAll("." + Qt + ",." + Qt + "-math-group").remove(), Byt.draw(r, fr, Bme(St, $e || {}));
+          }
+          function Nt() {
+            if (n && Ae || !n && !Ae) {
+              var fr, $e;
+              M === "top" && (fr = d + T.l + re * _, $e = v + T.t + oe * (1 - ie - H) + 3 + lt * 0.75), M === "bottom" && (fr = d + T.l + re * _, $e = v + T.t + oe * (1 - ie) - 3 - lt * 0.25), M === "right" && ($e = v + T.t + oe * b + 3 + lt * 0.75, fr = d + T.l + re * ie), Wt(Ee._id + "title", { attributes: { x: fr, y: $e, "text-anchor": n ? "start" : "middle" } });
+            }
+          }
+          function $t() {
+            if (n && !Ae || !n && Ae) {
+              var fr = Ee.position || 0, $e = Ee._offset + Ee._length / 2, St, Qt;
+              if (M === "right") Qt = $e, St = T.l + re * fr + 10 + lt * (Ee.showticklabels ? 1 : 0.5);
+              else if (St = $e, M === "bottom" && (Qt = T.t + oe * fr + 10 + (je.indexOf("inside") === -1 ? Ee.tickfont.size : 0) + (Ee.ticks !== "inside" && t.ticklen || 0)), M === "top") {
+                var Gt = C.text.split("<br>").length;
+                Qt = T.t + oe * fr + 10 - Z - zme * lt * Gt;
+              }
+              Wt((n ? "h" : "v") + Ee._id + "title", { avoid: { selection: P_.select(r).selectAll("g." + Ee._id + "tick"), side: M, offsetTop: n ? 0 : T.t, offsetLeft: n ? T.l : 0, maxShift: n ? E.width : E.height }, attributes: { x: St, y: Qt, "text-anchor": "middle" }, transform: { rotate: n ? -90 : 0, offset: 0 } });
+            }
+          }
+          function sr() {
+            if (!n && !Ae || n && Ae) {
+              var fr = e.select("." + gf.cbtitle), $e = fr.select("text"), St = [-l / 2, l / 2], Qt = fr.select(".h" + Ee._id + "title-math-group").node(), Gt = 15.6;
+              $e.node() && (Gt = parseInt($e.node().style.fontSize, 10) * zme);
+              var _t;
+              if (Qt ? (_t = Gg.bBox(Qt), ut = _t.width, ot = _t.height, ot > Gt && (St[1] -= (ot - Gt) / 2)) : $e.node() && !$e.classed(gf.jsPlaceholder) && (_t = Gg.bBox($e.node()), ut = _t.width, ot = _t.height), n) {
+                if (ot) {
+                  if (ot += 5, M === "top") Ee.domain[1] -= ot / T.h, St[1] *= -1;
+                  else {
+                    Ee.domain[0] += ot / T.h;
+                    var It = Nyt.lineCount($e);
+                    St[1] += (1 - It) * Gt;
+                  }
+                  fr.attr("transform", Hg(St[0], St[1])), Ee.setScale();
+                }
+              } else ut && (M === "right" && (Ee.domain[0] += (ut + lt / 2) / T.w), fr.attr("transform", Hg(St[0], St[1])), Ee.setScale());
+            }
+            e.selectAll("." + gf.cbfills + ",." + gf.cblines).attr("transform", n ? Hg(0, Math.round(T.h * (1 - Ee.domain[1]))) : Hg(Math.round(T.w * Ee.domain[0]), 0)), pt.attr("transform", n ? Hg(0, Math.round(-T.t)) : Hg(Math.round(-T.l), 0));
+            var mt = e.select("." + gf.cbfills).selectAll("rect." + gf.cbfill).attr("style", "").data(U);
+            mt.enter().append("rect").classed(gf.cbfill, true).attr("style", ""), mt.exit().remove();
+            var er = g.map(Ee.c2p).map(Math.round).sort(function(Br, Vr) {
+              return Br - Vr;
+            });
+            mt.each(function(Br, Vr) {
+              var dt = [Vr === 0 ? g[0] : (U[Vr] + U[Vr - 1]) / 2, Vr === U.length - 1 ? g[1] : (U[Vr] + U[Vr + 1]) / 2].map(Ee.c2p).map(Math.round);
+              n && (dt[1] = U0.constrain(dt[1] + (dt[1] > dt[0]) ? 1 : -1, er[0], er[1]));
+              var Ge = P_.select(this).attr(n ? "x" : "y", _e).attr(n ? "y" : "x", P_.min(dt)).attr(n ? "width" : "height", Math.max(Z, 2)).attr(n ? "height" : "width", Math.max(P_.max(dt) - P_.min(dt), 2));
+              if (t._fillgradient) Gg.gradient(Ge, r, t._id, n ? "vertical" : "horizontalreversed", t._fillgradient, "fill");
+              else {
+                var Je = A(Br).replace("e-", "");
+                Ge.attr("fill", TV(Je).toHexString());
+              }
+            });
+            var lr = e.select("." + gf.cblines).selectAll("path." + gf.cbline).data(x.color && x.width ? G : []);
+            lr.enter().append("path").classed(gf.cbline, true), lr.exit().remove(), lr.each(function(Br) {
+              var Vr = _e, dt = Math.round(Ee.c2p(Br)) + x.width / 2 % 1;
+              P_.select(this).attr("d", "M" + (n ? Vr + "," + dt : dt + "," + Vr) + (n ? "h" : "v") + Z).call(Gg.lineGroupStyle, x.width, P(Br), x.dash);
+            }), pt.selectAll("g." + Ee._id + "tick,path").remove();
+            var wr = _e + Z + (l || 0) / 2 - (t.ticks === "outside" ? 1 : 0), Lr = Uy.calcTicks(Ee), ti = Uy.getTickSigns(Ee)[2];
+            return Uy.drawTicks(r, Ee, { vals: Ee.ticks === "inside" ? Uy.clipEnds(Ee, Lr) : Lr, layer: pt, path: Uy.makeTickPath(Ee, wr, ti), transFn: Uy.makeTransTickFn(Ee) }), Uy.drawLabels(r, Ee, { vals: Lr, layer: pt, transFn: Uy.makeTransTickLabelFn(Ee), labelFns: Uy.makeLabelFns(Ee, wr) });
+          }
+          function Tr() {
+            var fr, $e = Z + l / 2;
+            je.indexOf("inside") === -1 && (fr = Gg.bBox(pt.node()), $e += n ? fr.width : fr.height), Vt = ce.select("text");
+            var St = 0, Qt = n && M === "top", Gt = !n && M === "right", _t = 0;
+            if (Vt.node() && !Vt.classed(gf.jsPlaceholder)) {
+              var It, mt = ce.select(".h" + Ee._id + "title-math-group").node();
+              mt && (n && Ae || !n && !Ae) ? (fr = Gg.bBox(mt), St = fr.width, It = fr.height) : (fr = Gg.bBox(ce.node()), St = fr.right - T.l - (n ? _e : Se), It = fr.bottom - T.t - (n ? Se : _e), !n && M === "top" && ($e += fr.height, _t = fr.height)), Gt && (Vt.attr("transform", Hg(St / 2 + lt / 2, 0)), St *= 2), $e = Math.max($e, n ? St : It);
+            }
+            var er = (n ? d : v) * 2 + $e + u + l / 2, lr = 0;
+            !n && C.text && h === "bottom" && b <= 0 && (lr = er / 2, er += lr, _t += lr), E._hColorbarMoveTitle = lr, E._hColorbarMoveCBTitle = _t;
+            var wr = u + l, Lr = (n ? _e : Se) - wr / 2 - (n ? d : 0), ti = (n ? Se : _e) - (n ? N : v + _t - lr);
+            e.select("." + gf.cbbg).attr("x", Lr).attr("y", ti).attr(n ? "width" : "height", Math.max(er - lr, 2)).attr(n ? "height" : "width", Math.max(N + wr, 2)).call(SV.fill, c).call(SV.stroke, t.bordercolor).style("stroke-width", u);
+            var Br = Gt ? Math.max(St - 10, 0) : 0;
+            e.selectAll("." + gf.cboutline).attr("x", (n ? _e : Se + d) + Br).attr("y", (n ? Se + v - N : _e) + (Qt ? ot : 0)).attr(n ? "width" : "height", Math.max(Z, 2)).attr(n ? "height" : "width", Math.max(N - (n ? 2 * v + ot : 2 * d + Br), 2)).call(SV.stroke, t.outlinecolor).style({ fill: "none", "stroke-width": l });
+            var Vr = n ? Ce * er : 0, dt = n ? 0 : (1 - Le) * er - _t;
+            if (Vr = k ? T.l - Vr : -Vr, dt = p ? T.t - dt : -dt, e.attr("transform", Hg(Vr, dt)), !n && (u || TV(c).getAlpha() && !TV.equals(E.paper_bgcolor, c))) {
+              var Ge = pt.selectAll("text"), Je = Ge[0].length, We = e.select("." + gf.cbbg).node(), tt = Gg.bBox(We), xt = Gg.getTranslate(e), Ie = 2;
+              Ge.each(function(di, ji) {
+                var In = 0, wi = Je - 1;
+                if (ji === In || ji === wi) {
+                  var On = Gg.bBox(this), qn = Gg.getTranslate(this), Fn;
+                  if (ji === wi) {
+                    var ra = On.right + qn.x, la = tt.right + xt.x + Se - u - Ie + _;
+                    Fn = la - ra, Fn > 0 && (Fn = 0);
+                  } else if (ji === In) {
+                    var Ut = On.left + qn.x, wt = tt.left + xt.x + Se + u + Ie;
+                    Fn = wt - Ut, Fn < 0 && (Fn = 0);
+                  }
+                  Fn && (Je < 3 ? this.setAttribute("transform", "translate(" + Fn + ",0) " + this.getAttribute("transform")) : this.setAttribute("visibility", "hidden"));
+                }
+              });
+            }
+            var xe = {}, ke = Ome[f], vt = qme[f], ir = Ome[h], ar = qme[h], vr = er - Z;
+            n ? (a === "pixels" ? (xe.y = b, xe.t = N * ir, xe.b = N * ar) : (xe.t = xe.b = 0, xe.yt = b + i * ir, xe.yb = b - i * ar), s === "pixels" ? (xe.x = _, xe.l = er * ke, xe.r = er * vt) : (xe.l = vr * ke, xe.r = vr * vt, xe.xl = _ - o * ke, xe.xr = _ + o * vt)) : (a === "pixels" ? (xe.x = _, xe.l = N * ke, xe.r = N * vt) : (xe.l = xe.r = 0, xe.xl = _ + i * ke, xe.xr = _ - i * vt), s === "pixels" ? (xe.y = 1 - b, xe.t = er * ir, xe.b = er * ar) : (xe.t = vr * ir, xe.b = vr * ar, xe.yt = b - o * ir, xe.yb = b + o * ar));
+            var ii = t.y < 0.5 ? "b" : "t", pi = t.x < 0.5 ? "l" : "r";
+            r._fullLayout._reservedMargin[t._id] = {};
+            var $r = { r: E.width - Lr - Vr, l: Lr + xe.r, b: E.height - ti - dt, t: ti + xe.b };
+            k && p ? VI.autoMargin(r, t._id, xe) : k ? r._fullLayout._reservedMargin[t._id][ii] = $r[ii] : p || n ? r._fullLayout._reservedMargin[t._id][pi] = $r[pi] : r._fullLayout._reservedMargin[t._id][ii] = $r[ii];
+          }
+          return U0.syncOrAsync([VI.previousPromises, Nt, sr, $t, VI.previousPromises, Tr], r);
+        }
+        function Zyt(e, t, r) {
+          var n = t.orientation === "v", i = r._fullLayout, a = i._size, o, s, l;
+          UI.init({ element: e.node(), gd: r, prepFn: function() {
+            o = e.attr("transform"), AV(e);
+          }, moveFn: function(u, c) {
+            e.attr("transform", o + Hg(u, c)), s = UI.align((n ? t._uFrac : t._vFrac) + u / a.w, n ? t._thickFrac : t._lenFrac, 0, 1, t.xanchor), l = UI.align((n ? t._vFrac : 1 - t._uFrac) - c / a.h, n ? t._lenFrac : t._thickFrac, 0, 1, t.yanchor);
+            var f = UI.getCursor(s, l, t.xanchor, t.yanchor);
+            AV(e, f);
+          }, doneFn: function() {
+            if (AV(e), s !== void 0 && l !== void 0) {
+              var u = {};
+              u[t._propPrefix + "x"] = s, u[t._propPrefix + "y"] = l, t._traceIndex !== void 0 ? Fme.call("_guiRestyle", r, u, t._traceIndex) : Fme.call("_guiRelayout", r, u);
+            }
+          } });
+        }
+        function Yyt(e, t, r) {
+          var n = t._levels, i = [], a = [], o, s, l = n.end + n.size / 100, u = n.size, c = 1.001 * r[0] - 1e-3 * r[1], f = 1.001 * r[1] - 1e-3 * r[0];
+          for (s = 0; s < 1e5 && (o = n.start + s * u, !(u > 0 ? o >= l : o <= l)); s++) o > c && o < f && i.push(o);
+          if (t._fillgradient) a = [0];
+          else if (typeof t._fillcolor == "function") {
+            var h = t._filllevels;
+            if (h) for (l = h.end + h.size / 100, u = h.size, s = 0; s < 1e5 && (o = h.start + s * u, !(u > 0 ? o >= l : o <= l)); s++) o > r[0] && o < r[1] && a.push(o);
+            else a = i.map(function(d) {
+              return d - n.size / 2;
+            }), a.push(a[a.length - 1] + n.size);
+          } else t._fillcolor && typeof t._fillcolor == "string" && (a = [0]);
+          return n.size < 0 && (i.reverse(), a.reverse()), { line: i, fill: a };
+        }
+        function Kyt(e, t, r) {
+          var n = e._fullLayout, i = t.orientation === "v", a = { type: "linear", range: r, tickmode: t.tickmode, nticks: t.nticks, tick0: t.tick0, dtick: t.dtick, tickvals: t.tickvals, ticktext: t.ticktext, ticks: t.ticks, ticklen: t.ticklen, tickwidth: t.tickwidth, tickcolor: t.tickcolor, showticklabels: t.showticklabels, labelalias: t.labelalias, ticklabelposition: t.ticklabelposition, ticklabeloverflow: t.ticklabeloverflow, ticklabelstep: t.ticklabelstep, tickfont: t.tickfont, tickangle: t.tickangle, tickformat: t.tickformat, exponentformat: t.exponentformat, minexponent: t.minexponent, separatethousands: t.separatethousands, showexponent: t.showexponent, showtickprefix: t.showtickprefix, tickprefix: t.tickprefix, showticksuffix: t.showticksuffix, ticksuffix: t.ticksuffix, title: t.title, showline: true, anchor: "free", side: i ? "right" : "bottom", position: 1 }, o = i ? "y" : "x", s = { type: "linear", _id: o + t._id }, l = { letter: o, font: n.font, noAutotickangles: o === "y", noHover: true, noTickson: true, noTicklabelmode: true, noInsideRange: true, calendar: n.calendar };
+          function u(c, f) {
+            return U0.coerce(a, s, Hyt, c, f);
+          }
+          return Vyt(a, s, u, l, n), Gyt(a, s, u, l), s;
+        }
+        Nme.exports = { draw: jyt };
+      });
+      var Gme = ye((jlr, Vme) => {
+        Vme.exports = { moduleType: "component", name: "colorbar", attributes: uL(), supplyDefaults: Fq(), draw: Ume().draw, hasColorbar: kq() };
+      });
+      var jme = ye((Wlr, Hme) => {
+        Hme.exports = { moduleType: "component", name: "legend", layoutAttributes: CB(), supplyLayoutDefaults: PB(), draw: HB(), style: NB() };
+      });
+      var Xme = ye((Xlr, Wme) => {
+        Wme.exports = { moduleType: "locale", name: "en", dictionary: { "Click to enter Colorscale title": "Click to enter Colourscale title" }, format: { days: ["Sunday", "Monday", "Tuesday", "Wednesday", "Thursday", "Friday", "Saturday"], shortDays: ["Sun", "Mon", "Tue", "Wed", "Thu", "Fri", "Sat"], months: ["January", "February", "March", "April", "May", "June", "July", "August", "September", "October", "November", "December"], shortMonths: ["Jan", "Feb", "Mar", "Apr", "May", "Jun", "Jul", "Aug", "Sep", "Oct", "Nov", "Dec"], periods: ["AM", "PM"], dateTime: "%a %b %e %X %Y", date: "%d/%m/%Y", time: "%H:%M:%S", decimal: ".", thousands: ",", grouping: [3], currency: ["$", ""], year: "%Y", month: "%b %Y", dayMonth: "%b %-d", dayMonthYear: "%b %-d, %Y" } };
+      });
+      var Yme = ye((Zlr, Zme) => {
+        Zme.exports = { moduleType: "locale", name: "en-US", dictionary: { "Click to enter Colorscale title": "Click to enter Colorscale title" }, format: { date: "%m/%d/%Y" } };
+      });
+      var kV = ye((Ylr, Qme) => {
+        var Jyt = qa(), $me = Dr(), EV = $me.extendFlat, Kme = $me.extendDeep;
+        function Jme(e) {
+          var t;
+          switch (e) {
+            case "themes__thumb":
+              t = { autosize: true, width: 150, height: 150, title: { text: "" }, showlegend: false, margin: { l: 5, r: 5, t: 5, b: 5, pad: 0 }, annotations: [] };
+              break;
+            case "thumbnail":
+              t = { title: { text: "" }, hidesources: true, showlegend: false, borderwidth: 0, bordercolor: "", margin: { l: 1, r: 1, t: 1, b: 1, pad: 0 }, annotations: [] };
+              break;
+            default:
+              t = {};
+          }
+          return t;
+        }
+        function $yt(e) {
+          var t = ["xaxis", "yaxis", "zaxis"];
+          return t.indexOf(e.slice(0, 5)) > -1;
+        }
+        Qme.exports = function(t, r) {
+          var n, i = t.data, a = t.layout, o = Kme([], i), s = Kme({}, a, Jme(r.tileClass)), l = t._context || {};
+          if (r.width && (s.width = r.width), r.height && (s.height = r.height), r.tileClass === "thumbnail" || r.tileClass === "themes__thumb") {
+            s.annotations = [];
+            var u = Object.keys(s);
+            for (n = 0; n < u.length; n++) $yt(u[n]) && (s[u[n]].title = { text: "" });
+            for (n = 0; n < o.length; n++) {
+              var c = o[n];
+              c.showscale = false, c.marker && (c.marker.showscale = false), Jyt.traceIs(c, "pie-like") && (c.textposition = "none");
+            }
+          }
+          if (Array.isArray(r.annotations)) for (n = 0; n < r.annotations.length; n++) s.annotations.push(r.annotations[n]);
+          var f = Object.keys(s).filter(function(b) {
+            return b.match(/^scene\d*$/);
+          });
+          if (f.length) {
+            var h = {};
+            for (r.tileClass === "thumbnail" && (h = { title: { text: "" }, showaxeslabels: false, showticklabels: false, linetickenable: false }), n = 0; n < f.length; n++) {
+              var d = s[f[n]];
+              d.xaxis || (d.xaxis = {}), d.yaxis || (d.yaxis = {}), d.zaxis || (d.zaxis = {}), EV(d.xaxis, h), EV(d.yaxis, h), EV(d.zaxis, h), d._scene = null;
+            }
+          }
+          var v = document.createElement("div");
+          r.tileClass && (v.className = r.tileClass);
+          var _ = { gd: v, td: v, layout: s, data: o, config: { staticPlot: r.staticPlot === void 0 ? true : r.staticPlot, plotGlPixelRatio: r.plotGlPixelRatio === void 0 ? 2 : r.plotGlPixelRatio, displaylogo: r.displaylogo || false, showLink: r.showLink || false, showTips: r.showTips || false, mapboxAccessToken: l.mapboxAccessToken } };
+          return r.setBackground !== "transparent" && (_.config.setBackground = r.setBackground || "opaque"), _.gd.defaultLayout = Jme(r.tileClass), _;
+        };
+      });
+      var rye = ye((Klr, tye) => {
+        var Qyt = Ab().EventEmitter, e1t = qa(), t1t = Dr(), eye = Oy(), r1t = kV(), i1t = YP(), n1t = KP();
+        function a1t(e, t) {
+          var r = new Qyt(), n = r1t(e, { format: "png" }), i = n.gd;
+          i.style.position = "absolute", i.style.left = "-5000px", document.body.appendChild(i);
+          function a() {
+            var s = eye.getDelay(i._fullLayout);
+            setTimeout(function() {
+              var l = i1t(i), u = document.createElement("canvas");
+              u.id = t1t.randstr(), r = n1t({ format: t.format, width: i._fullLayout.width, height: i._fullLayout.height, canvas: u, emitter: r, svg: l }), r.clean = function() {
+                i && document.body.removeChild(i);
+              };
+            }, s);
+          }
+          var o = eye.getRedrawFunc(i);
+          return e1t.call("_doPlot", i, n.data, n.layout, n.config).then(o).then(a).catch(function(s) {
+            r.emit("error", s);
+          }), r;
+        }
+        tye.exports = a1t;
+      });
+      var aye = ye((Jlr, nye) => {
+        var iye = Oy(), o1t = { getDelay: iye.getDelay, getRedrawFunc: iye.getRedrawFunc, clone: kV(), toSVG: YP(), svgToImg: KP(), toImage: rye(), downloadImage: sU() };
+        nye.exports = o1t;
+      });
+      var sye = ye((Vy) => {
+        Vy.version = g6().version;
+        bee();
+        une();
+        var s1t = qa(), T4 = Vy.register = s1t.register, LV = Ede(), oye = Object.keys(LV);
+        for (GI = 0; GI < oye.length; GI++) ET = oye[GI], ET.charAt(0) !== "_" && (Vy[ET] = LV[ET]), T4({ moduleType: "apiMethod", name: ET, fn: LV[ET] });
+        var ET, GI;
+        T4(wpe());
+        T4([Xpe(), o0e(), Of(), S0e(), q0e(), oge(), Mge(), jge(), ume(), yV(), Ime(), tc(), Gme(), jme(), vf(), pN()]);
+        T4([Xme(), Yme()]);
+        window.PlotlyLocales && Array.isArray(window.PlotlyLocales) && (T4(window.PlotlyLocales), delete window.PlotlyLocales);
+        Vy.Icons = $L();
+        var HI = vf(), CV = Mc();
+        Vy.Plots = { resize: CV.resize, graphJson: CV.graphJson, sendDataToCloud: CV.sendDataToCloud };
+        Vy.Fx = { hover: HI.hover, unhover: HI.unhover, loneHover: HI.loneHover, loneUnhover: HI.loneUnhover };
+        Vy.Snapshot = aye();
+        Vy.PlotSchema = P3();
+      });
+      var uye = ye((Qlr, lye) => {
+        lye.exports = sye();
+      });
+      var zm = ye((eur, vye) => {
+        var Bf = pf(), cye = df().axisHoverFormat, { hovertemplateAttrs: l1t, texttemplateAttrs: u1t, templatefallbackAttrs: fye } = Ll(), dye = Tu(), c1t = ec(), hye = A_(), f1t = Pd().pattern, c2 = Ao().extendFlat, PV = c1t({ editType: "calc", arrayOk: true, colorEditType: "style" }), h1t = Bf.marker, d1t = h1t.line, v1t = c2({}, d1t.width, { dflt: 0 }), p1t = c2({ width: v1t, editType: "calc" }, dye("marker.line")), g1t = c2({ line: p1t, editType: "calc" }, dye("marker"), { opacity: { valType: "number", arrayOk: true, dflt: 1, min: 0, max: 1, editType: "style" }, pattern: f1t, cornerradius: { valType: "any", editType: "calc" } });
+        vye.exports = { x: Bf.x, x0: Bf.x0, dx: Bf.dx, y: Bf.y, y0: Bf.y0, dy: Bf.dy, xperiod: Bf.xperiod, yperiod: Bf.yperiod, xperiod0: Bf.xperiod0, yperiod0: Bf.yperiod0, xperiodalignment: Bf.xperiodalignment, yperiodalignment: Bf.yperiodalignment, xhoverformat: cye("x"), yhoverformat: cye("y"), text: Bf.text, texttemplate: u1t({ editType: "plot" }, { keys: hye.eventDataKeys }), texttemplatefallback: fye({ editType: "plot" }), hovertext: Bf.hovertext, hovertemplate: l1t({}, { keys: hye.eventDataKeys }), hovertemplatefallback: fye(), textposition: { valType: "enumerated", values: ["inside", "outside", "auto", "none"], dflt: "auto", arrayOk: true, editType: "calc" }, insidetextanchor: { valType: "enumerated", values: ["end", "middle", "start"], dflt: "end", editType: "plot" }, textangle: { valType: "angle", dflt: "auto", editType: "plot" }, textfont: c2({}, PV, {}), insidetextfont: c2({}, PV, {}), outsidetextfont: c2({}, PV, {}), constraintext: { valType: "enumerated", values: ["inside", "outside", "both", "none"], dflt: "both", editType: "calc" }, cliponaxis: c2({}, Bf.cliponaxis, {}), orientation: { valType: "enumerated", values: ["v", "h"], editType: "calc+clearAxisTypes" }, base: { valType: "any", dflt: null, arrayOk: true, editType: "calc" }, offset: { valType: "number", dflt: null, arrayOk: true, editType: "calc" }, width: { valType: "number", dflt: null, min: 0, arrayOk: true, editType: "calc" }, marker: g1t, offsetgroup: Bf.offsetgroup, alignmentgroup: Bf.alignmentgroup, selected: { marker: { opacity: Bf.selected.marker.opacity, color: Bf.selected.marker.color, editType: "style" }, textfont: Bf.selected.textfont, editType: "style" }, unselected: { marker: { opacity: Bf.unselected.marker.opacity, color: Bf.unselected.marker.color, editType: "style" }, textfont: Bf.unselected.textfont, editType: "style" }, zorder: Bf.zorder };
+      });
+      var jI = ye((tur, pye) => {
+        pye.exports = { barmode: { valType: "enumerated", values: ["stack", "group", "overlay", "relative"], dflt: "group", editType: "calc" }, barnorm: { valType: "enumerated", values: ["", "fraction", "percent"], dflt: "", editType: "calc" }, bargap: { valType: "number", min: 0, max: 1, editType: "calc" }, bargroupgap: { valType: "number", min: 0, max: 1, dflt: 0, editType: "calc" }, barcornerradius: { valType: "any", editType: "calc" } };
+      });
+      var WI = ye((rur, yye) => {
+        var m1t = ka(), gye = pv().hasColorscale, mye = td(), y1t = Dr().coercePattern;
+        yye.exports = function(t, r, n, i, a) {
+          var o = n("marker.color", i), s = gye(t, "marker");
+          s && mye(t, r, a, n, { prefix: "marker.", cLetter: "c" }), n("marker.line.color", m1t.defaultLine), gye(t, "marker.line") && mye(t, r, a, n, { prefix: "marker.line.", cLetter: "c" }), n("marker.line.width"), n("marker.opacity"), y1t(n, "marker.pattern", o, s), n("selected.marker.color"), n("unselected.marker.color");
+        };
+      });
+      var i0 = ye((iur, Aye) => {
+        var _ye = Eo(), kT = Dr(), xye = ka(), _1t = qa(), x1t = oT(), b1t = Dg(), w1t = WI(), T1t = e2(), bye = zm(), XI = kT.coerceFont;
+        function A1t(e, t, r, n) {
+          function i(u, c) {
+            return kT.coerce(e, t, bye, u, c);
+          }
+          var a = x1t(e, t, n, i);
+          if (!a) {
+            t.visible = false;
+            return;
+          }
+          b1t(e, t, n, i), i("xhoverformat"), i("yhoverformat"), i("zorder"), i("orientation", t.x && !t.y ? "h" : "v"), i("base"), i("offset"), i("width"), i("text"), i("hovertext"), i("hovertemplate"), i("hovertemplatefallback");
+          var o = i("textposition");
+          Tye(e, t, n, i, o, { moduleHasSelected: true, moduleHasUnselected: true, moduleHasConstrain: true, moduleHasCliponaxis: true, moduleHasTextangle: true, moduleHasInsideanchor: true }), w1t(e, t, i, r, n);
+          var s = (t.marker.line || {}).color, l = _1t.getComponentMethod("errorbars", "supplyDefaults");
+          l(e, t, s || xye.defaultLine, { axis: "y" }), l(e, t, s || xye.defaultLine, { axis: "x", inherit: "y" }), kT.coerceSelectionMarkerOpacity(t, i);
+        }
+        function S1t(e, t) {
+          var r, n;
+          function i(s, l) {
+            return kT.coerce(n._input, n, bye, s, l);
+          }
+          for (var a = 0; a < e.length; a++) if (n = e[a], n.type === "bar") {
+            r = n._input;
+            var o = i("marker.cornerradius", t.barcornerradius);
+            n.marker && (n.marker.cornerradius = wye(o)), T1t(r, n, t, i, t.barmode);
+          }
+        }
+        function wye(e) {
+          if (_ye(e)) {
+            if (e = +e, e >= 0) return e;
+          } else if (typeof e == "string" && (e = e.trim(), e.slice(-1) === "%" && _ye(e.slice(0, -1)) && (e = +e.slice(0, -1), e >= 0))) return e + "%";
+        }
+        function Tye(e, t, r, n, i, a) {
+          a = a || {};
+          var o = a.moduleHasSelected !== false, s = a.moduleHasUnselected !== false, l = a.moduleHasConstrain !== false, u = a.moduleHasCliponaxis !== false, c = a.moduleHasTextangle !== false, f = a.moduleHasInsideanchor !== false, h = !!a.hasPathbar, d = Array.isArray(i) || i === "auto", v = d || i === "inside", _ = d || i === "outside";
+          if (v || _) {
+            var b = XI(n, "textfont", r.font), p = kT.extendFlat({}, b), k = e.textfont && e.textfont.color, E = !k;
+            if (E && delete p.color, XI(n, "insidetextfont", p), h) {
+              var T = kT.extendFlat({}, b);
+              E && delete T.color, XI(n, "pathbar.textfont", T);
+            }
+            _ && XI(n, "outsidetextfont", b), o && n("selected.textfont.color"), s && n("unselected.textfont.color"), l && n("constraintext"), u && n("cliponaxis"), c && n("textangle"), n("texttemplate"), n("texttemplatefallback");
+          }
+          v && f && n("insidetextanchor");
+        }
+        Aye.exports = { supplyDefaults: A1t, crossTraceDefaults: S1t, handleText: Tye, validateCornerradius: wye };
+      });
+      var IV = ye((nur, Sye) => {
+        var M1t = qa(), E1t = ho(), k1t = Dr(), C1t = jI(), L1t = i0().validateCornerradius;
+        Sye.exports = function(e, t, r) {
+          function n(_, b) {
+            return k1t.coerce(e, t, C1t, _, b);
+          }
+          for (var i = false, a = false, o = false, s = {}, l = n("barmode"), u = l === "group", c = 0; c < r.length; c++) {
+            var f = r[c];
+            if (M1t.traceIs(f, "bar") && f.visible) i = true;
+            else continue;
+            var h = f.xaxis + f.yaxis;
+            if (u ? (s[h] && (o = true), s[h] = true) : (h += f._input.offsetgroup, s.length > 0 && !s[h] && (o = true), s[h] = true), f.visible && f.type === "histogram") {
+              var d = E1t.getFromId({ _fullLayout: t }, f[f.orientation === "v" ? "xaxis" : "yaxis"]);
+              d.type !== "category" && (a = true);
+            }
+          }
+          if (!i) {
+            delete t.barmode;
+            return;
+          }
+          l !== "overlay" && n("barnorm"), n("bargap", a && !o ? 0 : 0.2), n("bargroupgap");
+          var v = n("barcornerradius");
+          t.barcornerradius = L1t(v);
+        };
+      });
+      var A4 = ye((aur, Mye) => {
+        var CT = Dr();
+        Mye.exports = function(t, r) {
+          for (var n = 0; n < t.length; n++) t[n].i = n;
+          CT.mergeArray(r.text, t, "tx"), CT.mergeArray(r.hovertext, t, "htx");
+          var i = r.marker;
+          if (i) {
+            CT.mergeArray(i.opacity, t, "mo", true), CT.mergeArray(i.color, t, "mc");
+            var a = i.line;
+            a && (CT.mergeArray(a.color, t, "mlc"), CT.mergeArrayCastPositive(a.width, t, "mlw"));
+          }
+        };
+      });
+      var Iye = ye((our, Pye) => {
+        var Eye = ho(), kye = zg(), Cye = pv().hasColorscale, Lye = gv(), P1t = A4(), I1t = O0();
+        Pye.exports = function(t, r) {
+          var n = Eye.getFromId(t, r.xaxis || "x"), i = Eye.getFromId(t, r.yaxis || "y"), a, o, s, l, u, c, f = { msUTC: !!(r.base || r.base === 0) };
+          r.orientation === "h" ? (a = n.makeCalcdata(r, "x", f), s = i.makeCalcdata(r, "y"), l = kye(r, i, "y", s), u = !!r.yperiodalignment, c = "y") : (a = i.makeCalcdata(r, "y", f), s = n.makeCalcdata(r, "x"), l = kye(r, n, "x", s), u = !!r.xperiodalignment, c = "x"), o = l.vals;
+          for (var h = Math.min(o.length, a.length), d = new Array(h), v = 0; v < h; v++) d[v] = { p: o[v], s: a[v] }, u && (d[v].orig_p = s[v], d[v][c + "End"] = l.ends[v], d[v][c + "Start"] = l.starts[v]), r.ids && (d[v].id = String(r.ids[v]));
+          return Cye(r, "marker") && Lye(t, r, { vals: r.marker.color, containerStr: "marker", cLetter: "c" }), Cye(r, "marker.line") && Lye(t, r, { vals: r.marker.line.color, containerStr: "marker.line", cLetter: "c" }), P1t(d, r), I1t(d, r), d;
+        };
+      });
+      var bv = ye((sur, Dye) => {
+        var R1t = Oa(), D1t = Dr();
+        function F1t(e, t, r) {
+          var n = e._fullLayout, i = n["_" + r + "Text_minsize"];
+          if (i) {
+            var a = n.uniformtext.mode === "hide", o;
+            switch (r) {
+              case "funnelarea":
+              case "pie":
+              case "sunburst":
+                o = "g.slice";
+                break;
+              case "treemap":
+              case "icicle":
+                o = "g.slice, g.pathbar";
+                break;
+              default:
+                o = "g.points > g.point";
+            }
+            t.selectAll(o).each(function(s) {
+              var l = s.transform;
+              if (l) {
+                l.scale = a && l.hide ? 0 : i / l.fontSize;
+                var u = R1t.select(this).select("text");
+                D1t.setTransormAndDisplay(u, l);
+              }
+            });
+          }
+        }
+        function z1t(e, t, r) {
+          if (r.uniformtext.mode) {
+            var n = Rye(e), i = r.uniformtext.minsize, a = t.scale * t.fontSize;
+            t.hide = a < i, r[n] = r[n] || 1 / 0, t.hide || (r[n] = Math.min(r[n], Math.max(a, i)));
+          }
+        }
+        function O1t(e, t) {
+          var r = Rye(e);
+          t[r] = void 0;
+        }
+        function Rye(e) {
+          return "_" + e + "Text_minsize";
+        }
+        Dye.exports = { recordMinTextSize: z1t, clearMinTextSize: O1t, resizeText: F1t };
+      });
+      var ZI = ye((f2) => {
+        var q1t = Eo(), B1t = fd(), Fye = Dr().isArrayOrTypedArray;
+        f2.coerceString = function(e, t, r) {
+          if (typeof t == "string") {
+            if (t || !e.noBlank) return t;
+          } else if ((typeof t == "number" || t === true) && !e.strict) return String(t);
+          return r !== void 0 ? r : e.dflt;
+        };
+        f2.coerceNumber = function(e, t, r) {
+          if (q1t(t)) {
+            t = +t;
+            var n = e.min, i = e.max, a = n !== void 0 && t < n || i !== void 0 && t > i;
+            if (!a) return t;
+          }
+          return r !== void 0 ? r : e.dflt;
+        };
+        f2.coerceColor = function(e, t, r) {
+          return B1t(t).isValid() ? t : r !== void 0 ? r : e.dflt;
+        };
+        f2.coerceEnumerated = function(e, t, r) {
+          return e.coerceNumber && (t = +t), e.values.indexOf(t) !== -1 ? t : r !== void 0 ? r : e.dflt;
+        };
+        f2.getValue = function(e, t) {
+          var r;
+          return Fye(e) ? t < e.length && (r = e[t]) : r = e, r;
+        };
+        f2.getLineWidth = function(e, t) {
+          var r = 0 < t.mlw ? t.mlw : Fye(e.marker.line.width) ? 0 : e.marker.line.width;
+          return r;
+        };
+      });
+      var V0 = ye((uur, Wye) => {
+        var S4 = Oa(), N1t = ka(), M4 = So(), zye = Dr(), Oye = qa(), qye = bv().resizeText, RV = zm(), U1t = RV.textfont, V1t = RV.insidetextfont, G1t = RV.outsidetextfont, Qd = ZI();
+        function H1t(e) {
+          var t = S4.select(e).selectAll('g[class^="barlayer"]').selectAll("g.trace");
+          qye(e, t, "bar");
+          var r = t.size(), n = e._fullLayout;
+          t.style("opacity", function(i) {
+            return i[0].trace.opacity;
+          }).each(function(i) {
+            (n.barmode === "stack" && r > 1 || n.bargap === 0 && n.bargroupgap === 0 && !i[0].trace.marker.line.width) && S4.select(this).attr("shape-rendering", "crispEdges");
+          }), t.selectAll("g.points").each(function(i) {
+            var a = S4.select(this), o = i[0].trace;
+            Bye(a, o, e);
+          }), Oye.getComponentMethod("errorbars", "style")(t);
+        }
+        function Bye(e, t, r) {
+          M4.pointStyle(e.selectAll("path"), t, r), Nye(e, t, r);
+        }
+        function Nye(e, t, r) {
+          e.selectAll("text").each(function(n) {
+            var i = S4.select(this), a = zye.ensureUniformFontSize(r, Uye(i, n, t, r));
+            M4.font(i, a);
+          });
+        }
+        function j1t(e, t, r) {
+          var n = t[0].trace;
+          n.selectedpoints ? W1t(r, n, e) : (Bye(r, n, e), Oye.getComponentMethod("errorbars", "style")(r));
+        }
+        function W1t(e, t, r) {
+          M4.selectedPointStyle(e.selectAll("path"), t), X1t(e.selectAll("text"), t, r);
+        }
+        function X1t(e, t, r) {
+          e.each(function(n) {
+            var i = S4.select(this), a;
+            if (n.selected) {
+              a = zye.ensureUniformFontSize(r, Uye(i, n, t, r));
+              var o = t.selected.textfont && t.selected.textfont.color;
+              o && (a.color = o), M4.font(i, a);
+            } else M4.selectedTextStyle(i, t);
+          });
+        }
+        function Uye(e, t, r, n) {
+          var i = n._fullLayout.font, a = r.textfont;
+          if (e.classed("bartext-inside")) {
+            var o = jye(t, r);
+            a = Gye(r, t.i, i, o);
+          } else e.classed("bartext-outside") && (a = Hye(r, t.i, i));
+          return a;
+        }
+        function Vye(e, t, r) {
+          return DV(U1t, e.textfont, t, r);
+        }
+        function Gye(e, t, r, n) {
+          var i = Vye(e, t, r), a = e._input.textfont === void 0 || e._input.textfont.color === void 0 || Array.isArray(e.textfont.color) && e.textfont.color[t] === void 0;
+          return a && (i = { color: N1t.contrast(n), family: i.family, size: i.size, weight: i.weight, style: i.style, variant: i.variant, textcase: i.textcase, lineposition: i.lineposition, shadow: i.shadow }), DV(V1t, e.insidetextfont, t, i);
+        }
+        function Hye(e, t, r) {
+          var n = Vye(e, t, r);
+          return DV(G1t, e.outsidetextfont, t, n);
+        }
+        function DV(e, t, r, n) {
+          t = t || {};
+          var i = Qd.getValue(t.family, r), a = Qd.getValue(t.size, r), o = Qd.getValue(t.color, r), s = Qd.getValue(t.weight, r), l = Qd.getValue(t.style, r), u = Qd.getValue(t.variant, r), c = Qd.getValue(t.textcase, r), f = Qd.getValue(t.lineposition, r), h = Qd.getValue(t.shadow, r);
+          return { family: Qd.coerceString(e.family, i, n.family), size: Qd.coerceNumber(e.size, a, n.size), color: Qd.coerceColor(e.color, o, n.color), weight: Qd.coerceString(e.weight, s, n.weight), style: Qd.coerceString(e.style, l, n.style), variant: Qd.coerceString(e.variant, u, n.variant), textcase: Qd.coerceString(e.variant, c, n.textcase), lineposition: Qd.coerceString(e.variant, f, n.lineposition), shadow: Qd.coerceString(e.variant, h, n.shadow) };
+        }
+        function jye(e, t) {
+          return t.type === "waterfall" ? t[e.dir].marker.color : e.mcc || e.mc || t.marker.color;
+        }
+        Wye.exports = { style: H1t, styleTextPoints: Nye, styleOnSelect: j1t, getInsideTextFont: Gye, getOutsideTextFont: Hye, getBarColor: jye, resizeText: qye };
+      });
+      var d2 = ye((cur, e1e) => {
+        var YI = Oa(), KI = Eo(), Dd = Dr(), Z1t = Zl(), Y1t = ka(), I_ = So(), K1t = qa(), JI = ho().tickText, Xye = bv(), J1t = Xye.recordMinTextSize, $1t = Xye.clearMinTextSize, FV = V0(), LT = ZI(), Q1t = A_(), Zye = zm(), e_t = Zye.text, t_t = Zye.textposition, r_t = ip().appendArrayPointValue, Gv = Q1t.TEXTPAD;
+        function i_t(e) {
+          return e.id;
+        }
+        function n_t(e) {
+          if (e.ids) return i_t;
+        }
+        function zV(e) {
+          return (e > 0) - (e < 0);
+        }
+        function Om(e, t) {
+          return e < t ? 1 : -1;
+        }
+        function a_t(e, t, r, n) {
+          var i = [], a = [], o = n ? t : r, s = n ? r : t;
+          return i[0] = o.c2p(e.s0, true), a[0] = s.c2p(e.p0, true), i[1] = o.c2p(e.s1, true), a[1] = s.c2p(e.p1, true), n ? [i, a] : [a, i];
+        }
+        function Yye(e, t, r, n) {
+          if (!t.uniformtext.mode && Kye(r)) {
+            var i;
+            return n && (i = n()), e.transition().duration(r.duration).ease(r.easing).each("end", function() {
+              i && i();
+            }).each("interrupt", function() {
+              i && i();
+            });
+          } else return e;
+        }
+        function Kye(e) {
+          return e && e.duration > 0;
+        }
+        function o_t(e, t, r, n, i, a) {
+          var o = t.xaxis, s = t.yaxis, l = e._fullLayout, u = e._context.staticPlot;
+          i || (i = { mode: l.barmode, norm: l.barmode, gap: l.bargap, groupgap: l.bargroupgap }, $1t("bar", l));
+          var c = Dd.makeTraceGroups(n, r, "trace bars").each(function(f) {
+            var h = YI.select(this), d = f[0].trace, v = f[0].t, _ = d.type === "waterfall", b = d.type === "funnel", p = d.type === "histogram", k = d.type === "bar", E = k || b, T = 0;
+            _ && d.connector.visible && d.connector.mode === "between" && (T = d.connector.line.width / 2);
+            var L = d.orientation === "h", x = Kye(i), C = Dd.ensureSingle(h, "g", "points"), M = n_t(d), g = C.selectAll("g.point").data(Dd.identity, M);
+            g.enter().append("g").classed("point", true), g.exit().remove(), g.each(function(A, z) {
+              var O = YI.select(this), U = a_t(A, o, s, L), G = U[0][0], Z = U[0][1], j = U[1][0], N = U[1][1], H = (L ? Z - G : N - j) === 0;
+              H && E && LT.getLineWidth(d, A) && (H = false), H || (H = !KI(G) || !KI(Z) || !KI(j) || !KI(N)), A.isBlank = H, H && (L ? Z = G : N = j), T && !H && (L ? (G -= Om(G, Z) * T, Z += Om(G, Z) * T) : (j -= Om(j, N) * T, N += Om(j, N) * T));
+              var re, oe;
+              if (d.type === "waterfall") {
+                if (!H) {
+                  var _e = d[A.dir].marker;
+                  re = _e.line.width, oe = _e.color;
+                }
+              } else re = LT.getLineWidth(d, A), oe = A.mc || d.marker.color;
+              function Ce($e) {
+                var St = YI.round(re / 2 % 1, 2);
+                return i.gap === 0 && i.groupgap === 0 ? YI.round(Math.round($e) - St, 2) : $e;
+              }
+              function Le($e, St, Qt) {
+                return Qt && $e === St ? $e : Math.abs($e - St) >= 2 ? Ce($e) : $e > St ? Math.ceil($e) : Math.floor($e);
+              }
+              var ge = Y1t.opacity(oe), ie = ge < 1 || re > 0.01 ? Ce : Le;
+              e._context.staticPlot || (G = ie(G, Z, L), Z = ie(Z, G, L), j = ie(j, N, !L), N = ie(N, j, !L));
+              var Se = L ? o.c2p : s.c2p, Ee;
+              A.s0 > 0 ? Ee = A._sMax : A.s0 < 0 ? Ee = A._sMin : Ee = A.s1 > 0 ? A._sMax : A._sMin;
+              function Ae($e, St) {
+                if (!$e) return 0;
+                var Qt = Math.abs(L ? N - j : Z - G), Gt = Math.abs(L ? Z - G : N - j), _t = ie(Math.abs(Se(Ee, true) - Se(0, true))), It = A.hasB ? Math.min(Qt / 2, Gt / 2) : Math.min(Qt / 2, _t), mt;
+                if (St === "%") {
+                  var er = Math.min(50, $e);
+                  mt = Qt * (er / 100);
+                } else mt = $e;
+                return ie(Math.max(Math.min(mt, It), 0));
+              }
+              var Be = k || p ? Ae(v.cornerradiusvalue, v.cornerradiusform) : 0, Pe, me, De = "M" + G + "," + j + "V" + N + "H" + Z + "V" + j + "Z", ce = 0;
+              if (Be && A.s) {
+                var je = zV(A.s0) === 0 || zV(A.s) === zV(A.s0) ? A.s1 : A.s0;
+                if (ce = ie(A.hasB ? 0 : Math.abs(Se(Ee, true) - Se(je, true))), ce < Be) {
+                  var lt = Om(G, Z), pt = Om(j, N), Vt = lt === -pt ? 1 : 0;
+                  if (L) if (A.hasB) Pe = "M" + (G + Be * lt) + "," + j + "A " + Be + "," + Be + " 0 0 " + Vt + " " + G + "," + (j + Be * pt) + "V" + (N - Be * pt) + "A " + Be + "," + Be + " 0 0 " + Vt + " " + (G + Be * lt) + "," + N + "H" + (Z - Be * lt) + "A " + Be + "," + Be + " 0 0 " + Vt + " " + Z + "," + (N - Be * pt) + "V" + (j + Be * pt) + "A " + Be + "," + Be + " 0 0 " + Vt + " " + (Z - Be * lt) + "," + j + "Z";
+                  else {
+                    me = Math.abs(Z - G) + ce;
+                    var ot = me < Be ? Be - Math.sqrt(me * (2 * Be - me)) : 0, ut = ce > 0 ? Math.sqrt(ce * (2 * Be - ce)) : 0, Wt = lt > 0 ? Math.max : Math.min;
+                    Pe = "M" + G + "," + j + "V" + (N - ot * pt) + "H" + Wt(Z - (Be - ce) * lt, G) + "A " + Be + "," + Be + " 0 0 " + Vt + " " + Z + "," + (N - Be * pt - ut) + "V" + (j + Be * pt + ut) + "A " + Be + "," + Be + " 0 0 " + Vt + " " + Wt(Z - (Be - ce) * lt, G) + "," + (j + ot * pt) + "Z";
+                  }
+                  else if (A.hasB) Pe = "M" + (G + Be * lt) + "," + j + "A " + Be + "," + Be + " 0 0 " + Vt + " " + G + "," + (j + Be * pt) + "V" + (N - Be * pt) + "A " + Be + "," + Be + " 0 0 " + Vt + " " + (G + Be * lt) + "," + N + "H" + (Z - Be * lt) + "A " + Be + "," + Be + " 0 0 " + Vt + " " + Z + "," + (N - Be * pt) + "V" + (j + Be * pt) + "A " + Be + "," + Be + " 0 0 " + Vt + " " + (Z - Be * lt) + "," + j + "Z";
+                  else {
+                    me = Math.abs(N - j) + ce;
+                    var Nt = me < Be ? Be - Math.sqrt(me * (2 * Be - me)) : 0, $t = ce > 0 ? Math.sqrt(ce * (2 * Be - ce)) : 0, sr = pt > 0 ? Math.max : Math.min;
+                    Pe = "M" + (G + Nt * lt) + "," + j + "V" + sr(N - (Be - ce) * pt, j) + "A " + Be + "," + Be + " 0 0 " + Vt + " " + (G + Be * lt - $t) + "," + N + "H" + (Z - Be * lt + $t) + "A " + Be + "," + Be + " 0 0 " + Vt + " " + (Z - Nt * lt) + "," + sr(N - (Be - ce) * pt, j) + "V" + j + "Z";
+                  }
+                } else Pe = De;
+              } else Pe = De;
+              var Tr = Yye(Dd.ensureSingle(O, "path"), l, i, a);
+              if (Tr.style("vector-effect", u ? "none" : "non-scaling-stroke").attr("d", isNaN((Z - G) * (N - j)) || H && e._context.staticPlot ? "M0,0Z" : Pe).call(I_.setClipUrl, t.layerClipId, e), !l.uniformtext.mode && x) {
+                var fr = I_.makePointStyleFns(d);
+                I_.singlePointStyle(A, Tr, d, fr, e);
+              }
+              s_t(e, t, O, f, z, G, Z, j, N, Be, ce, i, a), t.layerClipId && I_.hideOutsideRangePoint(A, O.select("text"), o, s, d.xcalendar, d.ycalendar);
+            });
+            var P = d.cliponaxis === false;
+            I_.setClipUrl(h, P ? null : t.layerClipId, e);
+          });
+          K1t.getComponentMethod("errorbars", "plot")(e, c, t, i);
+        }
+        function s_t(e, t, r, n, i, a, o, s, l, u, c, f, h) {
+          var d = t.xaxis, v = t.yaxis, _ = e._fullLayout, b;
+          function p(me, De, ce) {
+            var je = Dd.ensureSingle(me, "text").text(De).attr({ class: "bartext bartext-" + b, "text-anchor": "middle", "data-notex": 1 }).call(I_.font, ce).call(Z1t.convertToTspans, e);
+            return je;
+          }
+          var k = n[0].trace, E = k.orientation === "h", T = c_t(_, n, i, d, v);
+          b = f_t(k, i);
+          var L = f.mode === "stack" || f.mode === "relative", x = n[i], C = !L || x._outmost, M = x.hasB, g = u && u - c > Gv;
+          if (!T || b === "none" || (x.isBlank || a === o || s === l) && (b === "auto" || b === "inside")) {
+            r.select("text").remove();
+            return;
+          }
+          var P = _.font, A = FV.getBarColor(n[i], k), z = FV.getInsideTextFont(k, i, P, A), O = FV.getOutsideTextFont(k, i, P), U = k.insidetextanchor || "end", G = r.datum();
+          E ? d.type === "log" && G.s0 <= 0 && (d.range[0] < d.range[1] ? a = 0 : a = d._length) : v.type === "log" && G.s0 <= 0 && (v.range[0] < v.range[1] ? s = v._length : s = 0);
+          var Z = Math.abs(o - a), j = Math.abs(l - s), N = Z - 2 * Gv, H = j - 2 * Gv, re, oe, _e, Ce, Le;
+          if (b === "outside" && !C && !x.hasB && (b = "inside"), b === "auto") if (C) {
+            b = "inside", Le = Dd.ensureUniformFontSize(e, z), re = p(r, T, Le), oe = I_.bBox(re.node()), _e = oe.width, Ce = oe.height;
+            var ge = _e > 0 && Ce > 0, ie;
+            g ? M ? ie = h2(N - 2 * u, H, _e, Ce, E) || h2(N, H - 2 * u, _e, Ce, E) : E ? ie = h2(N - (u - c), H, _e, Ce, E) || h2(N, H - 2 * (u - c), _e, Ce, E) : ie = h2(N, H - (u - c), _e, Ce, E) || h2(N - 2 * (u - c), H, _e, Ce, E) : ie = h2(N, H, _e, Ce, E), ge && ie ? b = "inside" : (b = "outside", re.remove(), re = null);
+          } else b = "inside";
+          if (!re) {
+            Le = Dd.ensureUniformFontSize(e, b === "outside" ? O : z), re = p(r, T, Le);
+            var Se = re.attr("transform");
+            if (re.attr("transform", ""), oe = I_.bBox(re.node()), _e = oe.width, Ce = oe.height, re.attr("transform", Se), _e <= 0 || Ce <= 0) {
+              re.remove();
+              return;
+            }
+          }
+          var Ee = k.textangle, Ae, Be;
+          b === "outside" ? (Be = k.constraintext === "both" || k.constraintext === "outside", Ae = u_t(a, o, s, l, oe, { isHorizontal: E, constrained: Be, angle: Ee })) : (Be = k.constraintext === "both" || k.constraintext === "inside", Ae = Qye(a, o, s, l, oe, { isHorizontal: E, constrained: Be, angle: Ee, anchor: U, hasB: M, r: u, overhead: c })), Ae.fontSize = Le.size, J1t(k.type === "histogram" ? "bar" : k.type, Ae, _), x.transform = Ae;
+          var Pe = Yye(re, _, f, h);
+          Dd.setTransormAndDisplay(Pe, Ae);
+        }
+        function h2(e, t, r, n, i) {
+          if (e < 0 || t < 0) return false;
+          var a = r <= e && n <= t, o = r <= t && n <= e, s = i ? e >= r * (t / n) : t >= n * (e / r);
+          return a || o || s;
+        }
+        function Jye(e) {
+          return e === "auto" ? 0 : e;
+        }
+        function $ye(e, t) {
+          var r = Math.PI / 180 * t, n = Math.abs(Math.sin(r)), i = Math.abs(Math.cos(r));
+          return { x: e.width * i + e.height * n, y: e.width * n + e.height * i };
+        }
+        function Qye(e, t, r, n, i, a) {
+          var o = !!a.isHorizontal, s = !!a.constrained, l = a.angle || 0, u = a.anchor, c = u === "end", f = u === "start", h = a.leftToRight || 0, d = (h + 1) / 2, v = 1 - d, _ = a.hasB, b = a.r, p = a.overhead, k = i.width, E = i.height, T = Math.abs(t - e), L = Math.abs(n - r), x = T > 2 * Gv && L > 2 * Gv ? Gv : 0;
+          T -= 2 * x, L -= 2 * x;
+          var C = Jye(l);
+          l === "auto" && !(k <= T && E <= L) && (k > T || E > L) && (!(k > L || E > T) || k < E != T < L) && (C += 90);
+          var M = $ye(i, C), g, P;
+          if (b && b - p > Gv) {
+            var A = l_t(e, t, r, n, M, b, p, o, _);
+            g = A.scale, P = A.pad;
+          } else g = 1, s && (g = Math.min(1, T / M.x, L / M.y)), P = 0;
+          var z = i.left * v + i.right * d, O = (i.top + i.bottom) / 2, U = (e + Gv) * v + (t - Gv) * d, G = (r + n) / 2, Z = 0, j = 0;
+          if (f || c) {
+            var N = (o ? M.x : M.y) / 2;
+            b && (c || _) && (x += P);
+            var H = o ? Om(e, t) : Om(r, n);
+            o ? f ? (U = e + H * x, Z = -H * N) : (U = t - H * x, Z = H * N) : f ? (G = r + H * x, j = -H * N) : (G = n - H * x, j = H * N);
+          }
+          return { textX: z, textY: O, targetX: U, targetY: G, anchorX: Z, anchorY: j, scale: g, rotate: C };
+        }
+        function l_t(e, t, r, n, i, a, o, s, l) {
+          var u = Math.max(0, Math.abs(t - e) - 2 * Gv), c = Math.max(0, Math.abs(n - r) - 2 * Gv), f = a - Gv, h = o ? f - Math.sqrt(f * f - (f - o) * (f - o)) : f, d = l ? f * 2 : s ? f - o : 2 * h, v = l ? f * 2 : s ? 2 * h : f - o, _, b, p, k, E;
+          return i.y / i.x >= c / (u - d) ? k = c / i.y : i.y / i.x <= (c - v) / u ? k = u / i.x : !l && s ? (_ = i.x * i.x + i.y * i.y / 4, b = -2 * i.x * (u - f) - i.y * (c / 2 - f), p = (u - f) * (u - f) + (c / 2 - f) * (c / 2 - f) - f * f, k = (-b + Math.sqrt(b * b - 4 * _ * p)) / (2 * _)) : l ? (_ = (i.x * i.x + i.y * i.y) / 4, b = -i.x * (u / 2 - f) - i.y * (c / 2 - f), p = (u / 2 - f) * (u / 2 - f) + (c / 2 - f) * (c / 2 - f) - f * f, k = (-b + Math.sqrt(b * b - 4 * _ * p)) / (2 * _)) : (_ = i.x * i.x / 4 + i.y * i.y, b = -i.x * (u / 2 - f) - 2 * i.y * (c - f), p = (u / 2 - f) * (u / 2 - f) + (c - f) * (c - f) - f * f, k = (-b + Math.sqrt(b * b - 4 * _ * p)) / (2 * _)), k = Math.min(1, k), s ? E = Math.max(0, f - Math.sqrt(Math.max(0, f * f - (f - (c - i.y * k) / 2) * (f - (c - i.y * k) / 2))) - o) : E = Math.max(0, f - Math.sqrt(Math.max(0, f * f - (f - (u - i.x * k) / 2) * (f - (u - i.x * k) / 2))) - o), { scale: k, pad: E };
+        }
+        function u_t(e, t, r, n, i, a) {
+          var o = !!a.isHorizontal, s = !!a.constrained, l = a.angle || 0, u = i.width, c = i.height, f = Math.abs(t - e), h = Math.abs(n - r), d;
+          o ? d = h > 2 * Gv ? Gv : 0 : d = f > 2 * Gv ? Gv : 0;
+          var v = 1;
+          s && (v = o ? Math.min(1, h / c) : Math.min(1, f / u));
+          var _ = Jye(l), b = $ye(i, _), p = (o ? b.x : b.y) / 2, k = (i.left + i.right) / 2, E = (i.top + i.bottom) / 2, T = (e + t) / 2, L = (r + n) / 2, x = 0, C = 0, M = o ? Om(t, e) : Om(r, n);
+          return o ? (T = t - M * d, x = M * p) : (L = n + M * d, C = -M * p), { textX: k, textY: E, targetX: T, targetY: L, anchorX: x, anchorY: C, scale: v, rotate: _ };
+        }
+        function c_t(e, t, r, n, i) {
+          var a = t[0].trace, o = a.texttemplate, s;
+          return o ? s = h_t(e, t, r, n, i) : a.textinfo ? s = d_t(t, r, n, i) : s = LT.getValue(a.text, r), LT.coerceString(e_t, s);
+        }
+        function f_t(e, t) {
+          var r = LT.getValue(e.textposition, t);
+          return LT.coerceEnumerated(t_t, r);
+        }
+        function h_t(e, t, r, n, i) {
+          var a = t[0].trace, o = Dd.castOption(a, r, "texttemplate");
+          if (!o) return "";
+          var s = a.type === "histogram", l = a.type === "waterfall", u = a.type === "funnel", c = a.orientation === "h", f, h, d, v;
+          c ? (f = "y", h = i, d = "x", v = n) : (f = "x", h = n, d = "y", v = i);
+          function _(x) {
+            return JI(h, h.c2l(x), true).text;
+          }
+          function b(x) {
+            return JI(v, v.c2l(x), true).text;
+          }
+          var p = t[r], k = {};
+          k.label = p.p, k.labelLabel = k[f + "Label"] = _(p.p);
+          var E = Dd.castOption(a, p.i, "text");
+          (E === 0 || E) && (k.text = E), k.value = p.s, k.valueLabel = k[d + "Label"] = b(p.s);
+          var T = {};
+          r_t(T, a, p.i), (s || T.x === void 0) && (T.x = c ? k.value : k.label), (s || T.y === void 0) && (T.y = c ? k.label : k.value), (s || T.xLabel === void 0) && (T.xLabel = c ? k.valueLabel : k.labelLabel), (s || T.yLabel === void 0) && (T.yLabel = c ? k.labelLabel : k.valueLabel), l && (k.delta = +p.rawS || p.s, k.deltaLabel = b(k.delta), k.final = p.v, k.finalLabel = b(k.final), k.initial = k.final - k.delta, k.initialLabel = b(k.initial)), u && (k.value = p.s, k.valueLabel = b(k.value), k.percentInitial = p.begR, k.percentInitialLabel = Dd.formatPercent(p.begR), k.percentPrevious = p.difR, k.percentPreviousLabel = Dd.formatPercent(p.difR), k.percentTotal = p.sumR, k.percenTotalLabel = Dd.formatPercent(p.sumR));
+          var L = Dd.castOption(a, p.i, "customdata");
+          return L && (k.customdata = L), Dd.texttemplateString({ data: [T, k, a._meta], fallback: a.texttemplatefallback, labels: k, locale: e._d3locale, template: o });
+        }
+        function d_t(e, t, r, n) {
+          var i = e[0].trace, a = i.orientation === "h", o = i.type === "waterfall", s = i.type === "funnel";
+          function l(L) {
+            var x = a ? n : r;
+            return JI(x, L, true).text;
+          }
+          function u(L) {
+            var x = a ? r : n;
+            return JI(x, +L, true).text;
+          }
+          var c = i.textinfo, f = e[t], h = c.split("+"), d = [], v, _ = function(L) {
+            return h.indexOf(L) !== -1;
+          };
+          if (_("label") && d.push(l(e[t].p)), _("text") && (v = Dd.castOption(i, f.i, "text"), (v === 0 || v) && d.push(v)), o) {
+            var b = +f.rawS || f.s, p = f.v, k = p - b;
+            _("initial") && d.push(u(k)), _("delta") && d.push(u(b)), _("final") && d.push(u(p));
+          }
+          if (s) {
+            _("value") && d.push(u(f.s));
+            var E = 0;
+            _("percent initial") && E++, _("percent previous") && E++, _("percent total") && E++;
+            var T = E > 1;
+            _("percent initial") && (v = Dd.formatPercent(f.begR), T && (v += " of initial"), d.push(v)), _("percent previous") && (v = Dd.formatPercent(f.difR), T && (v += " of previous"), d.push(v)), _("percent total") && (v = Dd.formatPercent(f.sumR), T && (v += " of total"), d.push(v));
+          }
+          return d.join("<br>");
+        }
+        e1e.exports = { plot: o_t, toMoveInsideBar: Qye };
+      });
+      var PT = ye((fur, n1e) => {
+        var E4 = vf(), v_t = qa(), t1e = ka(), p_t = Dr().fillText, g_t = ZI().getLineWidth, OV = ho().hoverLabelText, m_t = fs().BADNUM;
+        function y_t(e, t, r, n, i) {
+          var a = r1e(e, t, r, n, i);
+          if (a) {
+            var o = a.cd, s = o[0].trace, l = o[a.index];
+            return a.color = i1e(s, l), v_t.getComponentMethod("errorbars", "hoverInfo")(l, s, a), [a];
+          }
+        }
+        function r1e(e, t, r, n, i) {
+          var a = e.cd, o = a[0].trace, s = a[0].t, l = n === "closest", u = o.type === "waterfall", c = e.maxHoverDistance, f = e.maxSpikeDistance, h, d, v, _, b, p, k;
+          o.orientation === "h" ? (h = r, d = t, v = "y", _ = "x", b = G, p = z) : (h = t, d = r, v = "x", _ = "y", p = G, b = z);
+          var E = o[v + "period"], T = l || E;
+          function L(ie) {
+            return C(ie, -1);
+          }
+          function x(ie) {
+            return C(ie, 1);
+          }
+          function C(ie, Se) {
+            var Ee = ie.w;
+            return ie[v] + Se * Ee / 2;
+          }
+          function M(ie) {
+            return ie[v + "End"] - ie[v + "Start"];
+          }
+          var g = l ? L : E ? function(ie) {
+            return ie.p - M(ie) / 2;
+          } : function(ie) {
+            return Math.min(L(ie), ie.p - s.bardelta / 2);
+          }, P = l ? x : E ? function(ie) {
+            return ie.p + M(ie) / 2;
+          } : function(ie) {
+            return Math.max(x(ie), ie.p + s.bardelta / 2);
+          };
+          function A(ie, Se, Ee) {
+            return i.finiteRange && (Ee = 0), E4.inbox(ie - h, Se - h, Ee + Math.min(1, Math.abs(Se - ie) / k) - 1);
+          }
+          function z(ie) {
+            return A(g(ie), P(ie), c);
+          }
+          function O(ie) {
+            return A(L(ie), x(ie), f);
+          }
+          function U(ie) {
+            var Se = ie[_];
+            if (u) {
+              var Ee = Math.abs(ie.rawS) || 0;
+              d > 0 ? Se += Ee : d < 0 && (Se -= Ee);
+            }
+            return Se;
+          }
+          function G(ie) {
+            var Se = d, Ee = ie.b, Ae = U(ie);
+            return E4.inbox(Ee - Se, Ae - Se, c + (Ae - Se) / (Ae - Ee) - 1);
+          }
+          function Z(ie) {
+            var Se = d, Ee = ie.b, Ae = U(ie);
+            return E4.inbox(Ee - Se, Ae - Se, f + (Ae - Se) / (Ae - Ee) - 1);
+          }
+          var j = e[v + "a"], N = e[_ + "a"];
+          k = Math.abs(j.r2c(j.range[1]) - j.r2c(j.range[0]));
+          function H(ie) {
+            return (b(ie) + p(ie)) / 2;
+          }
+          var re = E4.getDistanceFunction(n, b, p, H);
+          if (E4.getClosest(a, re, e), e.index !== false && a[e.index].p !== m_t) {
+            T || (g = function(ie) {
+              return Math.min(L(ie), ie.p - s.bargroupwidth / 2);
+            }, P = function(ie) {
+              return Math.max(x(ie), ie.p + s.bargroupwidth / 2);
+            });
+            var oe = e.index, _e = a[oe], Ce = o.base ? _e.b + _e.s : _e.s;
+            e[_ + "0"] = e[_ + "1"] = N.c2p(_e[_], true), e[_ + "LabelVal"] = Ce;
+            var Le = s.extents[s.extents.round(_e.p)];
+            e[v + "0"] = j.c2p(l ? g(_e) : Le[0], true), e[v + "1"] = j.c2p(l ? P(_e) : Le[1], true);
+            var ge = _e.orig_p !== void 0;
+            return e[v + "LabelVal"] = ge ? _e.orig_p : _e.p, e.labelLabel = OV(j, e[v + "LabelVal"], o[v + "hoverformat"]), e.valueLabel = OV(N, e[_ + "LabelVal"], o[_ + "hoverformat"]), e.baseLabel = OV(N, _e.b, o[_ + "hoverformat"]), e.spikeDistance = (Z(_e) + O(_e)) / 2, e[v + "Spike"] = j.c2p(_e.p, true), p_t(_e, o, e), e.hovertemplate = o.hovertemplate, e;
+          }
+        }
+        function i1e(e, t) {
+          var r = t.mcc || e.marker.color, n = t.mlcc || e.marker.line.color, i = g_t(e, t);
+          if (t1e.opacity(r)) return r;
+          if (t1e.opacity(n) && i) return n;
+        }
+        n1e.exports = { hoverPoints: y_t, hoverOnBars: r1e, getTraceColor: i1e };
+      });
+      var o1e = ye((hur, a1e) => {
+        a1e.exports = function(t, r, n) {
+          return t.x = "xVal" in r ? r.xVal : r.x, t.y = "yVal" in r ? r.yVal : r.y, r.xa && (t.xaxis = r.xa), r.ya && (t.yaxis = r.ya), n.orientation === "h" ? (t.label = t.y, t.value = t.x) : (t.label = t.x, t.value = t.y), t;
+        };
+      });
+      var IT = ye((dur, s1e) => {
+        s1e.exports = function(t, r) {
+          var n = t.cd, i = t.xaxis, a = t.yaxis, o = n[0].trace, s = o.type === "funnel", l = o.orientation === "h", u = [], c;
+          if (r === false) for (c = 0; c < n.length; c++) n[c].selected = 0;
+          else for (c = 0; c < n.length; c++) {
+            var f = n[c], h = "ct" in f ? f.ct : __t(f, i, a, l, s);
+            r.contains(h, false, c, t) ? (u.push({ pointNumber: c, x: i.c2d(f.x), y: a.c2d(f.y) }), f.selected = 1) : f.selected = 0;
+          }
+          return u;
+        };
+        function __t(e, t, r, n, i) {
+          var a = t.c2p(n ? e.s0 : e.p0, true), o = t.c2p(n ? e.s1 : e.p1, true), s = r.c2p(n ? e.p0 : e.s0, true), l = r.c2p(n ? e.p1 : e.s1, true);
+          return i ? [(a + o) / 2, (s + l) / 2] : n ? [o, (s + l) / 2] : [(a + o) / 2, l];
+        }
+      });
+      var u1e = ye((vur, l1e) => {
+        l1e.exports = { attributes: zm(), layoutAttributes: jI(), supplyDefaults: i0().supplyDefaults, crossTraceDefaults: i0().crossTraceDefaults, supplyLayoutDefaults: IV(), calc: Iye(), crossTraceCalc: t2().crossTraceCalc, colorbar: $d(), arraysToCalcdata: A4(), plot: d2().plot, style: V0().style, styleOnSelect: V0().styleOnSelect, hoverPoints: PT().hoverPoints, eventData: o1e(), selectPoints: IT(), moduleType: "trace", name: "bar", basePlotModule: mh(), categories: ["bar-like", "cartesian", "svg", "bar", "oriented", "errorBarsOK", "showLegend", "zoomScale"], animatable: true, meta: {} };
+      });
+      var f1e = ye((pur, c1e) => {
+        c1e.exports = u1e();
+      });
+      var k4 = ye((gur, p1e) => {
+        var x_t = Pg(), G0 = pf(), h1e = zm(), b_t = Ih(), d1e = df().axisHoverFormat, { hovertemplateAttrs: w_t, templatefallbackAttrs: T_t } = Ll(), Gy = Ao().extendFlat, RT = G0.marker, v1e = RT.line;
+        p1e.exports = { y: { valType: "data_array", editType: "calc+clearAxisTypes" }, x: { valType: "data_array", editType: "calc+clearAxisTypes" }, x0: { valType: "any", editType: "calc+clearAxisTypes" }, y0: { valType: "any", editType: "calc+clearAxisTypes" }, dx: { valType: "number", editType: "calc" }, dy: { valType: "number", editType: "calc" }, xperiod: G0.xperiod, yperiod: G0.yperiod, xperiod0: G0.xperiod0, yperiod0: G0.yperiod0, xperiodalignment: G0.xperiodalignment, yperiodalignment: G0.yperiodalignment, xhoverformat: d1e("x"), yhoverformat: d1e("y"), name: { valType: "string", editType: "calc+clearAxisTypes" }, q1: { valType: "data_array", editType: "calc+clearAxisTypes" }, median: { valType: "data_array", editType: "calc+clearAxisTypes" }, q3: { valType: "data_array", editType: "calc+clearAxisTypes" }, lowerfence: { valType: "data_array", editType: "calc" }, upperfence: { valType: "data_array", editType: "calc" }, notched: { valType: "boolean", editType: "calc" }, notchwidth: { valType: "number", min: 0, max: 0.5, dflt: 0.25, editType: "calc" }, notchspan: { valType: "data_array", editType: "calc" }, boxpoints: { valType: "enumerated", values: ["all", "outliers", "suspectedoutliers", false], editType: "calc" }, jitter: { valType: "number", min: 0, max: 1, editType: "calc" }, pointpos: { valType: "number", min: -2, max: 2, editType: "calc" }, sdmultiple: { valType: "number", min: 0, editType: "calc", dflt: 1 }, sizemode: { valType: "enumerated", values: ["quartiles", "sd"], editType: "calc", dflt: "quartiles" }, boxmean: { valType: "enumerated", values: [true, "sd", false], editType: "calc" }, mean: { valType: "data_array", editType: "calc" }, sd: { valType: "data_array", editType: "calc" }, orientation: { valType: "enumerated", values: ["v", "h"], editType: "calc+clearAxisTypes" }, quartilemethod: { valType: "enumerated", values: ["linear", "exclusive", "inclusive"], dflt: "linear", editType: "calc" }, width: { valType: "number", min: 0, dflt: 0, editType: "calc" }, marker: { outliercolor: { valType: "color", dflt: "rgba(0, 0, 0, 0)", editType: "style" }, symbol: Gy({}, RT.symbol, { arrayOk: false, editType: "plot" }), opacity: Gy({}, RT.opacity, { arrayOk: false, dflt: 1, editType: "style" }), angle: Gy({}, RT.angle, { arrayOk: false, editType: "calc" }), size: Gy({}, RT.size, { arrayOk: false, editType: "calc" }), color: Gy({}, RT.color, { arrayOk: false, editType: "style" }), line: { color: Gy({}, v1e.color, { arrayOk: false, dflt: b_t.defaultLine, editType: "style" }), width: Gy({}, v1e.width, { arrayOk: false, dflt: 0, editType: "style" }), outliercolor: { valType: "color", editType: "style" }, outlierwidth: { valType: "number", min: 0, dflt: 1, editType: "style" }, editType: "style" }, editType: "plot" }, line: { color: { valType: "color", editType: "style" }, width: { valType: "number", min: 0, dflt: 2, editType: "style" }, editType: "plot" }, fillcolor: x_t(), whiskerwidth: { valType: "number", min: 0, max: 1, dflt: 0.5, editType: "calc" }, showwhiskers: { valType: "boolean", editType: "calc" }, offsetgroup: h1e.offsetgroup, alignmentgroup: h1e.alignmentgroup, selected: { marker: G0.selected.marker, editType: "style" }, unselected: { marker: G0.unselected.marker, editType: "style" }, text: Gy({}, G0.text, {}), hovertext: Gy({}, G0.hovertext, {}), hovertemplate: w_t({}), hovertemplatefallback: T_t(), hoveron: { valType: "flaglist", flags: ["boxes", "points"], dflt: "boxes+points", editType: "style" }, zorder: G0.zorder };
+      });
+      var C4 = ye((mur, g1e) => {
+        g1e.exports = { boxmode: { valType: "enumerated", values: ["group", "overlay"], dflt: "overlay", editType: "calc" }, boxgap: { valType: "number", min: 0, max: 1, dflt: 0.3, editType: "calc" }, boxgroupgap: { valType: "number", min: 0, max: 1, dflt: 0.3, editType: "calc" } };
+      });
+      var P4 = ye((yur, x1e) => {
+        var H0 = Dr(), A_t = qa(), S_t = ka(), M_t = Dg(), E_t = e2(), m1e = V3(), L4 = k4();
+        function k_t(e, t, r, n) {
+          function i(v, _) {
+            return H0.coerce(e, t, L4, v, _);
+          }
+          if (y1e(e, t, i, n), t.visible !== false) {
+            M_t(e, t, n, i), i("xhoverformat"), i("yhoverformat");
+            var a = t._hasPreCompStats;
+            a && (i("lowerfence"), i("upperfence")), i("line.color", (e.marker || {}).color || r), i("line.width"), i("fillcolor", S_t.addOpacity(t.line.color, 0.5));
+            var o = false;
+            if (a) {
+              var s = i("mean"), l = i("sd");
+              s && s.length && (o = true, l && l.length && (o = "sd"));
+            }
+            i("whiskerwidth");
+            var u = i("sizemode"), c;
+            u === "quartiles" && (c = i("boxmean", o)), i("showwhiskers", u === "quartiles"), (u === "sd" || c === "sd") && i("sdmultiple"), i("width"), i("quartilemethod");
+            var f = false;
+            if (a) {
+              var h = i("notchspan");
+              h && h.length && (f = true);
+            } else H0.validate(e.notchwidth, L4.notchwidth) && (f = true);
+            var d = i("notched", f);
+            d && i("notchwidth"), _1e(e, t, i, { prefix: "box" }), i("zorder");
+          }
+        }
+        function y1e(e, t, r, n) {
+          function i(P) {
+            var A = 0;
+            return P && P.length && (A += 1, H0.isArrayOrTypedArray(P[0]) && P[0].length && (A += 1)), A;
+          }
+          function a(P) {
+            return H0.validate(e[P], L4[P]);
+          }
+          var o = r("y"), s = r("x"), l;
+          if (t.type === "box") {
+            var u = r("q1"), c = r("median"), f = r("q3");
+            t._hasPreCompStats = u && u.length && c && c.length && f && f.length, l = Math.min(H0.minRowLength(u), H0.minRowLength(c), H0.minRowLength(f));
+          }
+          var h = i(o), d = i(s), v = h && H0.minRowLength(o), _ = d && H0.minRowLength(s), b = n.calendar, p = { autotypenumbers: n.autotypenumbers }, k, E;
+          if (t._hasPreCompStats) switch (String(d) + String(h)) {
+            case "00":
+              var T = a("x0") || a("dx"), L = a("y0") || a("dy");
+              L && !T ? k = "h" : k = "v", E = l;
+              break;
+            case "10":
+              k = "v", E = Math.min(l, _);
+              break;
+            case "20":
+              k = "h", E = Math.min(l, s.length);
+              break;
+            case "01":
+              k = "h", E = Math.min(l, v);
+              break;
+            case "02":
+              k = "v", E = Math.min(l, o.length);
+              break;
+            case "12":
+              k = "v", E = Math.min(l, _, o.length);
+              break;
+            case "21":
+              k = "h", E = Math.min(l, s.length, v);
+              break;
+            case "11":
+              E = 0;
+              break;
+            case "22":
+              var x = false, C;
+              for (C = 0; C < s.length; C++) if (m1e(s[C], b, p) === "category") {
+                x = true;
+                break;
+              }
+              if (x) k = "v", E = Math.min(l, _, o.length);
+              else {
+                for (C = 0; C < o.length; C++) if (m1e(o[C], b, p) === "category") {
+                  x = true;
+                  break;
+                }
+                x ? (k = "h", E = Math.min(l, s.length, v)) : (k = "v", E = Math.min(l, _, o.length));
+              }
+              break;
+          }
+          else h > 0 ? (k = "v", d > 0 ? E = Math.min(_, v) : E = Math.min(v)) : d > 0 ? (k = "h", E = Math.min(_)) : E = 0;
+          if (!E) {
+            t.visible = false;
+            return;
+          }
+          t._length = E;
+          var M = r("orientation", k);
+          t._hasPreCompStats ? M === "v" && d === 0 ? (r("x0", 0), r("dx", 1)) : M === "h" && h === 0 && (r("y0", 0), r("dy", 1)) : M === "v" && d === 0 ? r("x0") : M === "h" && h === 0 && r("y0");
+          var g = A_t.getComponentMethod("calendars", "handleTraceDefaults");
+          g(e, t, ["x", "y"], n);
+        }
+        function _1e(e, t, r, n) {
+          var i = n.prefix, a = H0.coerce2(e, t, L4, "marker.outliercolor"), o = r("marker.line.outliercolor"), s = "outliers";
+          t._hasPreCompStats ? s = "all" : (a || o) && (s = "suspectedoutliers");
+          var l = r(i + "points", s);
+          l ? (r("jitter", l === "all" ? 0.3 : 0), r("pointpos", l === "all" ? -1.5 : 0), r("marker.symbol"), r("marker.opacity"), r("marker.size"), r("marker.angle"), r("marker.color", t.line.color), r("marker.line.color"), r("marker.line.width"), l === "suspectedoutliers" && (r("marker.line.outliercolor", t.marker.color), r("marker.line.outlierwidth")), r("selected.marker.color"), r("unselected.marker.color"), r("selected.marker.size"), r("unselected.marker.size"), r("text"), r("hovertext")) : delete t.marker;
+          var u = r("hoveron");
+          (u === "all" || u.indexOf("points") !== -1) && (r("hovertemplate"), r("hovertemplatefallback")), H0.coerceSelectionMarkerOpacity(t, r);
+        }
+        function C_t(e, t) {
+          var r, n;
+          function i(l) {
+            return H0.coerce(n._input, n, L4, l);
+          }
+          for (var a = 0; a < e.length; a++) {
+            n = e[a];
+            var o = n.type;
+            if (o === "box" || o === "violin") {
+              r = n._input;
+              var s = t[o + "mode"];
+              s === "group" && E_t(r, n, t, i, s);
+            }
+          }
+        }
+        x1e.exports = { supplyDefaults: k_t, crossTraceDefaults: C_t, handleSampleDefaults: y1e, handlePointsDefaults: _1e };
+      });
+      var $I = ye((_ur, w1e) => {
+        var L_t = qa(), P_t = Dr(), I_t = C4();
+        function b1e(e, t, r, n, i) {
+          for (var a = i + "Layout", o = false, s = 0; s < r.length; s++) {
+            var l = r[s];
+            if (L_t.traceIs(l, a)) {
+              o = true;
+              break;
+            }
+          }
+          o && (n(i + "mode"), n(i + "gap"), n(i + "groupgap"));
+        }
+        function R_t(e, t, r) {
+          function n(i, a) {
+            return P_t.coerce(e, t, I_t, i, a);
+          }
+          b1e(e, t, r, n, "box");
+        }
+        w1e.exports = { supplyLayoutDefaults: R_t, _supply: b1e };
+      });
+      var NV = ye((xur, P1e) => {
+        var BV = Eo(), QI = ho(), D_t = zg(), yh = Dr(), n0 = fs().BADNUM, Hy = yh._;
+        P1e.exports = function(t, r) {
+          var n = t._fullLayout, i = QI.getFromId(t, r.xaxis || "x"), a = QI.getFromId(t, r.yaxis || "y"), o = [], s = r.type === "violin" ? "_numViolins" : "_numBoxes", l, u, c, f, h, d, v;
+          r.orientation === "h" ? (c = i, f = "x", h = a, d = "y", v = !!r.yperiodalignment) : (c = a, f = "y", h = i, d = "x", v = !!r.xperiodalignment);
+          var _ = F_t(r, d, h, n[s]), b = _[0], p = _[1], k = yh.distinctVals(b, h), E = k.vals, T = k.minDiff / 2, L, x, C, M, g, P, A = (r.boxpoints || r.points) === "all" ? yh.identity : function(Vt) {
+            return Vt.v < L.lf || Vt.v > L.uf;
+          };
+          if (r._hasPreCompStats) {
+            var z = r[f], O = function(Vt) {
+              return c.d2c((r[Vt] || [])[l]);
+            }, U = 1 / 0, G = -1 / 0;
+            for (l = 0; l < r._length; l++) {
+              var Z = b[l];
+              if (BV(Z)) {
+                if (L = {}, L.pos = L[d] = Z, v && p && (L.orig_p = p[l]), L.q1 = O("q1"), L.med = O("median"), L.q3 = O("q3"), x = [], z && yh.isArrayOrTypedArray(z[l])) for (u = 0; u < z[l].length; u++) P = c.d2c(z[l][u]), P !== n0 && (g = { v: P, i: [l, u] }, T1e(g, r, [l, u]), x.push(g));
+                if (L.pts = x.sort(A1e), C = L[f] = x.map(S1e), M = C.length, L.med !== n0 && L.q1 !== n0 && L.q3 !== n0 && L.med >= L.q1 && L.q3 >= L.med) {
+                  var j = O("lowerfence");
+                  L.lf = j !== n0 && j <= L.q1 ? j : M1e(L, C, M);
+                  var N = O("upperfence");
+                  L.uf = N !== n0 && N >= L.q3 ? N : E1e(L, C, M);
+                  var H = O("mean");
+                  L.mean = H !== n0 ? H : M ? yh.mean(C, M) : (L.q1 + L.q3) / 2;
+                  var re = O("sd");
+                  L.sd = H !== n0 && re >= 0 ? re : M ? yh.stdev(C, M, L.mean) : L.q3 - L.q1, L.lo = k1e(L), L.uo = C1e(L);
+                  var oe = O("notchspan");
+                  oe = oe !== n0 && oe > 0 ? oe : L1e(L, M), L.ln = L.med - oe, L.un = L.med + oe;
+                  var _e = L.lf, Ce = L.uf;
+                  r.boxpoints && C.length && (_e = Math.min(_e, C[0]), Ce = Math.max(Ce, C[M - 1])), r.notched && (_e = Math.min(_e, L.ln), Ce = Math.max(Ce, L.un)), L.min = _e, L.max = Ce;
+                } else {
+                  yh.warn(["Invalid input - make sure that q1 <= median <= q3", "q1 = " + L.q1, "median = " + L.med, "q3 = " + L.q3].join(`
+`));
+                  var Le;
+                  L.med !== n0 ? Le = L.med : L.q1 !== n0 ? L.q3 !== n0 ? Le = (L.q1 + L.q3) / 2 : Le = L.q1 : L.q3 !== n0 ? Le = L.q3 : Le = 0, L.med = Le, L.q1 = L.q3 = Le, L.lf = L.uf = Le, L.mean = L.sd = Le, L.ln = L.un = Le, L.min = L.max = Le;
+                }
+                U = Math.min(U, L.min), G = Math.max(G, L.max), L.pts2 = x.filter(A), o.push(L);
+              }
+            }
+            r._extremes[c._id] = QI.findExtremes(c, [U, G], { padded: true });
+          } else {
+            var ge = c.makeCalcdata(r, f), ie = z_t(E, T), Se = E.length, Ee = O_t(Se);
+            for (l = 0; l < r._length; l++) if (P = ge[l], !!BV(P)) {
+              var Ae = yh.findBin(b[l], ie);
+              Ae >= 0 && Ae < Se && (g = { v: P, i: l }, T1e(g, r, l), Ee[Ae].push(g));
+            }
+            var Be = 1 / 0, Pe = -1 / 0, me = r.quartilemethod, De = me === "exclusive", ce = me === "inclusive";
+            for (l = 0; l < Se; l++) if (Ee[l].length > 0) {
+              if (L = {}, L.pos = L[d] = E[l], x = L.pts = Ee[l].sort(A1e), C = L[f] = x.map(S1e), M = C.length, L.min = C[0], L.max = C[M - 1], L.mean = yh.mean(C, M), L.sd = yh.stdev(C, M, L.mean) * r.sdmultiple, L.med = yh.interp(C, 0.5), M % 2 && (De || ce)) {
+                var je, lt;
+                De ? (je = C.slice(0, M / 2), lt = C.slice(M / 2 + 1)) : ce && (je = C.slice(0, M / 2 + 1), lt = C.slice(M / 2)), L.q1 = yh.interp(je, 0.5), L.q3 = yh.interp(lt, 0.5);
+              } else L.q1 = yh.interp(C, 0.25), L.q3 = yh.interp(C, 0.75);
+              L.lf = M1e(L, C, M), L.uf = E1e(L, C, M), L.lo = k1e(L), L.uo = C1e(L);
+              var pt = L1e(L, M);
+              L.ln = L.med - pt, L.un = L.med + pt, Be = Math.min(Be, L.ln), Pe = Math.max(Pe, L.un), L.pts2 = x.filter(A), o.push(L);
+            }
+            r.notched && yh.isTypedArray(ge) && (ge = Array.from(ge)), r._extremes[c._id] = QI.findExtremes(c, r.notched ? ge.concat([Be, Pe]) : ge, { padded: true });
+          }
+          return q_t(o, r), o.length > 0 ? (o[0].t = { num: n[s], dPos: T, posLetter: d, valLetter: f, labels: { med: Hy(t, "median:"), min: Hy(t, "min:"), q1: Hy(t, "q1:"), q3: Hy(t, "q3:"), max: Hy(t, "max:"), mean: r.boxmean === "sd" || r.sizemode === "sd" ? Hy(t, "mean ± σ:").replace("σ", r.sdmultiple === 1 ? "σ" : r.sdmultiple + "σ") : Hy(t, "mean:"), lf: Hy(t, "lower fence:"), uf: Hy(t, "upper fence:") } }, n[s]++, o) : [{ t: { empty: true } }];
+        };
+        function F_t(e, t, r, n) {
+          var i = t in e, a = t + "0" in e, o = "d" + t in e;
+          if (i || a && o) {
+            var s = r.makeCalcdata(e, t), l = D_t(e, r, t, s).vals;
+            return [l, s];
+          }
+          var u;
+          a ? u = e[t + "0"] : "name" in e && (r.type === "category" || BV(e.name) && ["linear", "log"].indexOf(r.type) !== -1 || yh.isDateTime(e.name) && r.type === "date") ? u = e.name : u = n;
+          for (var c = r.type === "multicategory" ? r.r2c_just_indices(u) : r.d2c(u, 0, e[t + "calendar"]), f = e._length, h = new Array(f), d = 0; d < f; d++) h[d] = c;
+          return [h];
+        }
+        function z_t(e, t) {
+          for (var r = e.length, n = new Array(r + 1), i = 0; i < r; i++) n[i] = e[i] - t;
+          return n[r] = e[r - 1] + t, n;
+        }
+        function O_t(e) {
+          for (var t = new Array(e), r = 0; r < e; r++) t[r] = [];
+          return t;
+        }
+        var qV = { text: "tx", hovertext: "htx" };
+        function T1e(e, t, r) {
+          for (var n in qV) yh.isArrayOrTypedArray(t[n]) && (Array.isArray(r) ? yh.isArrayOrTypedArray(t[n][r[0]]) && (e[qV[n]] = t[n][r[0]][r[1]]) : e[qV[n]] = t[n][r]);
+        }
+        function q_t(e, t) {
+          if (yh.isArrayOrTypedArray(t.selectedpoints)) for (var r = 0; r < e.length; r++) {
+            for (var n = e[r].pts || [], i = {}, a = 0; a < n.length; a++) i[n[a].i] = a;
+            yh.tagSelected(n, t, i);
+          }
+        }
+        function A1e(e, t) {
+          return e.v - t.v;
+        }
+        function S1e(e) {
+          return e.v;
+        }
+        function M1e(e, t, r) {
+          return r === 0 ? e.q1 : Math.min(e.q1, t[Math.min(yh.findBin(2.5 * e.q1 - 1.5 * e.q3, t, true) + 1, r - 1)]);
+        }
+        function E1e(e, t, r) {
+          return r === 0 ? e.q3 : Math.max(e.q3, t[Math.max(yh.findBin(2.5 * e.q3 - 1.5 * e.q1, t), 0)]);
+        }
+        function k1e(e) {
+          return 4 * e.q1 - 3 * e.q3;
+        }
+        function C1e(e) {
+          return 4 * e.q3 - 3 * e.q1;
+        }
+        function L1e(e, t) {
+          return t === 0 ? 0 : 1.57 * (e.q3 - e.q1) / Math.sqrt(t);
+        }
+      });
+      var e8 = ye((bur, F1e) => {
+        var I1e = ho(), B_t = Dr(), N_t = Kb().getAxisGroup, R1e = ["v", "h"];
+        function U_t(e, t) {
+          for (var r = e.calcdata, n = t.xaxis, i = t.yaxis, a = 0; a < R1e.length; a++) {
+            for (var o = R1e[a], s = o === "h" ? i : n, l = [], u = 0; u < r.length; u++) {
+              var c = r[u], f = c[0].t, h = c[0].trace;
+              h.visible === true && (h.type === "box" || h.type === "candlestick") && !f.empty && (h.orientation || "v") === o && h.xaxis === n._id && h.yaxis === i._id && l.push(u);
+            }
+            D1e("box", e, l, s);
+          }
+        }
+        function D1e(e, t, r, n) {
+          var i = t.calcdata, a = t._fullLayout, o = n._id, s = o.charAt(0), l, u, c, f = [], h = 0;
+          for (l = 0; l < r.length; l++) for (c = i[r[l]], u = 0; u < c.length; u++) f.push(n.c2l(c[u].pos, true)), h += (c[u].pts2 || []).length;
+          if (f.length) {
+            var d = B_t.distinctVals(f);
+            (n.type === "category" || n.type === "multicategory") && (d.minDiff = 1);
+            var v = d.minDiff / 2;
+            I1e.minDtick(n, d.minDiff, d.vals[0], true);
+            var _ = e === "violin" ? "_numViolins" : "_numBoxes", b = a[_], p = a[e + "mode"] === "group" && b > 1, k = 1 - a[e + "gap"], E = 1 - a[e + "groupgap"];
+            for (l = 0; l < r.length; l++) {
+              c = i[r[l]];
+              var T = c[0].trace, L = c[0].t, x = T.width, C = T.side, M, g, P, A;
+              if (x) M = g = A = x / 2, P = 0;
+              else if (M = v, p) {
+                var z = N_t(a, n._id) + T.orientation, O = a._alignmentOpts[z] || {}, U = O[T.alignmentgroup] || {}, G = Object.keys(U.offsetGroups || {}).length, Z = G || b, j = G ? T._offsetIndex : L.num;
+                g = M * k * E / Z, P = 2 * M * (-0.5 + (j + 0.5) / Z) * k, A = M * k / Z;
+              } else g = M * k * E, P = 0, A = M;
+              L.dPos = M, L.bPos = P, L.bdPos = g, L.wHover = A;
+              var N, H, re = P + g, oe, _e, Ce, Le, ge, ie, Se = !!x, Ee = (T.boxpoints || T.points) && h > 0;
+              if (C === "positive" ? (N = M * (x ? 1 : 0.5), oe = re, H = oe = P) : C === "negative" ? (N = oe = P, H = M * (x ? 1 : 0.5), _e = re) : (N = H = M, oe = _e = re), Ee) {
+                var Ae = T.pointpos, Be = T.jitter, Pe = T.marker.size / 2, me = 0;
+                Ae + Be >= 0 && (me = re * (Ae + Be), me > N ? (Se = true, ge = Pe, Ce = me) : me > oe && (ge = Pe, Ce = N)), me <= N && (Ce = N);
+                var De = 0;
+                Ae - Be <= 0 && (De = -re * (Ae - Be), De > H ? (Se = true, ie = Pe, Le = De) : De > _e && (ie = Pe, Le = H)), De <= H && (Le = H);
+              } else Ce = N, Le = H;
+              var ce = new Array(c.length);
+              for (u = 0; u < c.length; u++) ce[u] = c[u].pos;
+              T._extremes[o] = I1e.findExtremes(n, ce, { padded: Se, vpadminus: Le, vpadplus: Ce, vpadLinearized: true, ppadminus: { x: ie, y: ge }[s], ppadplus: { x: ge, y: ie }[s] });
+            }
+          }
+        }
+        F1e.exports = { crossTraceCalc: U_t, setPositionOffset: D1e };
+      });
+      var t8 = ye((wur, N1e) => {
+        var DT = Oa(), v2 = Dr(), V_t = So(), z1e = 5, G_t = 0.01;
+        function H_t(e, t, r, n) {
+          var i = e._context.staticPlot, a = t.xaxis, o = t.yaxis;
+          v2.makeTraceGroups(n, r, "trace boxes").each(function(s) {
+            var l = DT.select(this), u = s[0], c = u.t, f = u.trace;
+            if (c.wdPos = c.bdPos * f.whiskerwidth, f.visible !== true || c.empty) {
+              l.remove();
+              return;
+            }
+            var h, d;
+            f.orientation === "h" ? (h = o, d = a) : (h = a, d = o), O1e(l, { pos: h, val: d }, f, c, i), q1e(l, { x: a, y: o }, f, c), B1e(l, { pos: h, val: d }, f, c);
+          });
+        }
+        function O1e(e, t, r, n, i) {
+          var a = r.orientation === "h", o = t.val, s = t.pos, l = !!s.rangebreaks, u = n.bPos, c = n.wdPos || 0, f = n.bPosPxOffset || 0, h = r.whiskerwidth || 0, d = r.showwhiskers !== false, v = r.notched || false, _ = v ? 1 - 2 * r.notchwidth : 1, b, p;
+          Array.isArray(n.bdPos) ? (b = n.bdPos[0], p = n.bdPos[1]) : (b = n.bdPos, p = n.bdPos);
+          var k = e.selectAll("path.box").data(r.type !== "violin" || r.box.visible ? v2.identity : []);
+          k.enter().append("path").style("vector-effect", i ? "none" : "non-scaling-stroke").attr("class", "box"), k.exit().remove(), k.each(function(E) {
+            if (E.empty) return DT.select(this).attr("d", "M0,0Z");
+            var T = s.c2l(E.pos + u, true), L = s.l2p(T - b) + f, x = s.l2p(T + p) + f, C = l ? (L + x) / 2 : s.l2p(T) + f, M = r.whiskerwidth, g = l ? L * M + (1 - M) * C : s.l2p(T - c) + f, P = l ? x * M + (1 - M) * C : s.l2p(T + c) + f, A = s.l2p(T - b * _) + f, z = s.l2p(T + p * _) + f, O = r.sizemode === "sd", U = o.c2p(O ? E.mean - E.sd : E.q1, true), G = O ? o.c2p(E.mean + E.sd, true) : o.c2p(E.q3, true), Z = v2.constrain(O ? o.c2p(E.mean, true) : o.c2p(E.med, true), Math.min(U, G) + 1, Math.max(U, G) - 1), j = E.lf === void 0 || r.boxpoints === false || O, N = o.c2p(j ? E.min : E.lf, true), H = o.c2p(j ? E.max : E.uf, true), re = o.c2p(E.ln, true), oe = o.c2p(E.un, true);
+            a ? DT.select(this).attr("d", "M" + Z + "," + A + "V" + z + "M" + U + "," + L + "V" + x + (v ? "H" + re + "L" + Z + "," + z + "L" + oe + "," + x : "") + "H" + G + "V" + L + (v ? "H" + oe + "L" + Z + "," + A + "L" + re + "," + L : "") + "Z" + (d ? "M" + U + "," + C + "H" + N + "M" + G + "," + C + "H" + H + (h === 0 ? "" : "M" + N + "," + g + "V" + P + "M" + H + "," + g + "V" + P) : "")) : DT.select(this).attr("d", "M" + A + "," + Z + "H" + z + "M" + L + "," + U + "H" + x + (v ? "V" + re + "L" + z + "," + Z + "L" + x + "," + oe : "") + "V" + G + "H" + L + (v ? "V" + oe + "L" + A + "," + Z + "L" + L + "," + re : "") + "Z" + (d ? "M" + C + "," + U + "V" + N + "M" + C + "," + G + "V" + H + (h === 0 ? "" : "M" + g + "," + N + "H" + P + "M" + g + "," + H + "H" + P) : ""));
+          });
+        }
+        function q1e(e, t, r, n) {
+          var i = t.x, a = t.y, o = n.bdPos, s = n.bPos, l = r.boxpoints || r.points;
+          v2.seedPseudoRandom();
+          var u = function(h) {
+            return h.forEach(function(d) {
+              d.t = n, d.trace = r;
+            }), h;
+          }, c = e.selectAll("g.points").data(l ? u : []);
+          c.enter().append("g").attr("class", "points"), c.exit().remove();
+          var f = c.selectAll("path").data(function(h) {
+            var d, v = h.pts2, _ = Math.max((h.max - h.min) / 10, h.q3 - h.q1), b = _ * 1e-9, p = _ * G_t, k = [], E = 0, T;
+            if (r.jitter) {
+              if (_ === 0) for (E = 1, k = new Array(v.length), d = 0; d < v.length; d++) k[d] = 1;
+              else for (d = 0; d < v.length; d++) {
+                var L = Math.max(0, d - z1e), x = v[L].v, C = Math.min(v.length - 1, d + z1e), M = v[C].v;
+                l !== "all" && (v[d].v < h.lf ? M = Math.min(M, h.lf) : x = Math.max(x, h.uf));
+                var g = Math.sqrt(p * (C - L) / (M - x + b)) || 0;
+                g = v2.constrain(Math.abs(g), 0, 1), k.push(g), E = Math.max(g, E);
+              }
+              T = r.jitter * 2 / (E || 1);
+            }
+            for (d = 0; d < v.length; d++) {
+              var P = v[d], A = P.v, z = r.jitter ? T * k[d] * (v2.pseudoRandom() - 0.5) : 0, O = h.pos + s + o * (r.pointpos + z);
+              r.orientation === "h" ? (P.y = O, P.x = A) : (P.x = O, P.y = A), l === "suspectedoutliers" && A < h.uo && A > h.lo && (P.so = true);
+            }
+            return v;
+          });
+          f.enter().append("path").classed("point", true), f.exit().remove(), f.call(V_t.translatePoints, i, a);
+        }
+        function B1e(e, t, r, n) {
+          var i = t.val, a = t.pos, o = !!a.rangebreaks, s = n.bPos, l = n.bPosPxOffset || 0, u = r.boxmean || (r.meanline || {}).visible, c, f;
+          Array.isArray(n.bdPos) ? (c = n.bdPos[0], f = n.bdPos[1]) : (c = n.bdPos, f = n.bdPos);
+          var h = e.selectAll("path.mean").data(r.type === "box" && r.boxmean || r.type === "violin" && r.box.visible && r.meanline.visible ? v2.identity : []);
+          h.enter().append("path").attr("class", "mean").style({ fill: "none", "vector-effect": "non-scaling-stroke" }), h.exit().remove(), h.each(function(d) {
+            var v = a.c2l(d.pos + s, true), _ = a.l2p(v - c) + l, b = a.l2p(v + f) + l, p = o ? (_ + b) / 2 : a.l2p(v) + l, k = i.c2p(d.mean, true), E = i.c2p(d.mean - d.sd, true), T = i.c2p(d.mean + d.sd, true);
+            r.orientation === "h" ? DT.select(this).attr("d", "M" + k + "," + _ + "V" + b + (u === "sd" ? "m0,0L" + E + "," + p + "L" + k + "," + _ + "L" + T + "," + p + "Z" : "")) : DT.select(this).attr("d", "M" + _ + "," + k + "H" + b + (u === "sd" ? "m0,0L" + p + "," + E + "L" + _ + "," + k + "L" + p + "," + T + "Z" : ""));
+          });
+        }
+        N1e.exports = { plot: H_t, plotBoxAndWhiskers: O1e, plotPoints: q1e, plotBoxMean: B1e };
+      });
+      var r8 = ye((Tur, U1e) => {
+        var UV = Oa(), VV = ka(), GV = So();
+        function j_t(e, t, r) {
+          var n = r || UV.select(e).selectAll("g.trace.boxes");
+          n.style("opacity", function(i) {
+            return i[0].trace.opacity;
+          }), n.each(function(i) {
+            var a = UV.select(this), o = i[0].trace, s = o.line.width;
+            function l(f, h, d, v) {
+              f.style("stroke-width", h + "px").call(VV.stroke, d).call(VV.fill, v);
+            }
+            var u = a.selectAll("path.box");
+            if (o.type === "candlestick") u.each(function(f) {
+              if (!f.empty) {
+                var h = UV.select(this), d = o[f.dir];
+                l(h, d.line.width, d.line.color, d.fillcolor), h.style("opacity", o.selectedpoints && !f.selected ? 0.3 : 1);
+              }
+            });
+            else {
+              l(u, s, o.line.color, o.fillcolor), a.selectAll("path.mean").style({ "stroke-width": s, "stroke-dasharray": 2 * s + "px," + s + "px" }).call(VV.stroke, o.line.color);
+              var c = a.selectAll("path.point");
+              GV.pointStyle(c, o, e);
+            }
+          });
+        }
+        function W_t(e, t, r) {
+          var n = t[0].trace, i = r.selectAll("path.point");
+          n.selectedpoints ? GV.selectedPointStyle(i, n) : GV.pointStyle(i, n, e);
+        }
+        U1e.exports = { style: j_t, styleOnSelect: W_t };
+      });
+      var jV = ye((Aur, j1e) => {
+        var X_t = ho(), HV = Dr(), R_ = vf(), V1e = ka(), Z_t = HV.fillText;
+        function Y_t(e, t, r, n) {
+          var i = e.cd, a = i[0].trace, o = a.hoveron, s = [], l;
+          return o.indexOf("boxes") !== -1 && (s = s.concat(G1e(e, t, r, n))), o.indexOf("points") !== -1 && (l = H1e(e, t, r)), n === "closest" ? l ? [l] : s : (l && s.push(l), s);
+        }
+        function G1e(e, t, r, n) {
+          var i = e.cd, a = e.xa, o = e.ya, s = i[0].trace, l = i[0].t, u = s.type === "violin", c, f, h, d, v, _, b, p, k, E, T, L = l.bdPos, x, C, M = l.wHover, g = function(Pe) {
+            return h.c2l(Pe.pos) + l.bPos - h.c2l(_);
+          };
+          u && s.side !== "both" ? (s.side === "positive" && (k = function(Pe) {
+            var me = g(Pe);
+            return R_.inbox(me, me + M, E);
+          }, x = L, C = 0), s.side === "negative" && (k = function(Pe) {
+            var me = g(Pe);
+            return R_.inbox(me - M, me, E);
+          }, x = 0, C = L)) : (k = function(Pe) {
+            var me = g(Pe);
+            return R_.inbox(me - M, me + M, E);
+          }, x = C = L);
+          var P;
+          u ? P = function(Pe) {
+            return R_.inbox(Pe.span[0] - v, Pe.span[1] - v, E);
+          } : P = function(Pe) {
+            return R_.inbox(Pe.min - v, Pe.max - v, E);
+          }, s.orientation === "h" ? (v = t, _ = r, b = P, p = k, c = "y", h = o, f = "x", d = a) : (v = r, _ = t, b = k, p = P, c = "x", h = a, f = "y", d = o);
+          var A = Math.min(1, L / Math.abs(h.r2c(h.range[1]) - h.r2c(h.range[0])));
+          E = e.maxHoverDistance - A, T = e.maxSpikeDistance - A;
+          function z(Pe) {
+            return (b(Pe) + p(Pe)) / 2;
+          }
+          var O = R_.getDistanceFunction(n, b, p, z);
+          if (R_.getClosest(i, O, e), e.index === false) return [];
+          var U = i[e.index], G = s.line.color, Z = (s.marker || {}).color;
+          V1e.opacity(G) && s.line.width ? e.color = G : V1e.opacity(Z) && s.boxpoints ? e.color = Z : e.color = s.fillcolor, e[c + "0"] = h.c2p(U.pos + l.bPos - C, true), e[c + "1"] = h.c2p(U.pos + l.bPos + x, true), e[c + "LabelVal"] = U.orig_p !== void 0 ? U.orig_p : U.pos;
+          var j = c + "Spike";
+          e.spikeDistance = z(U) * T / E, e[j] = h.c2p(U.pos, true);
+          var N = s.boxmean || s.sizemode === "sd" || (s.meanline || {}).visible, H = s.boxpoints || s.points, re = H && N ? ["max", "uf", "q3", "med", "mean", "q1", "lf", "min"] : H && !N ? ["max", "uf", "q3", "med", "q1", "lf", "min"] : !H && N ? ["max", "q3", "med", "mean", "q1", "min"] : ["max", "q3", "med", "q1", "min"], oe = d.range[1] < d.range[0];
+          s.orientation === (oe ? "v" : "h") && re.reverse();
+          for (var _e = e.spikeDistance, Ce = e[j], Le = [], ge = 0; ge < re.length; ge++) {
+            var ie = re[ge];
+            if (ie in U) {
+              var Se = U[ie], Ee = d.c2p(Se, true), Ae = HV.extendFlat({}, e);
+              Ae.attr = ie, Ae[f + "0"] = Ae[f + "1"] = Ee, Ae[f + "LabelVal"] = Se, Ae[f + "Label"] = (l.labels ? l.labels[ie] + " " : "") + X_t.hoverLabelText(d, Se, s[f + "hoverformat"]), Ae.hoverOnBox = true, ie === "mean" && "sd" in U && (s.boxmean === "sd" || s.sizemode === "sd") && (Ae[f + "err"] = U.sd), Ae.hovertemplate = false, Le.push(Ae);
+            }
+          }
+          e.name = "", e.spikeDistance = void 0, e[j] = void 0;
+          for (var Be = 0; Be < Le.length; Be++) Le[Be].attr !== "med" ? (Le[Be].name = "", Le[Be].spikeDistance = void 0, Le[Be][j] = void 0) : (Le[Be].spikeDistance = _e, Le[Be][j] = Ce);
+          return Le;
+        }
+        function H1e(e, t, r) {
+          for (var n = e.cd, i = e.xa, a = e.ya, o = n[0].trace, s = i.c2p(t), l = a.c2p(r), u, c = function(P) {
+            var A = Math.max(3, P.mrc || 0);
+            return Math.max(Math.abs(i.c2p(P.x) - s) - A, 1 - 3 / A);
+          }, f = function(P) {
+            var A = Math.max(3, P.mrc || 0);
+            return Math.max(Math.abs(a.c2p(P.y) - l) - A, 1 - 3 / A);
+          }, h = R_.quadrature(c, f), d = false, v, _, b = 0; b < n.length; b++) {
+            v = n[b];
+            for (var p = 0; p < (v.pts || []).length; p++) {
+              _ = v.pts[p];
+              var k = h(_);
+              k <= e.distance && (e.distance = k, d = [b, p]);
+            }
+          }
+          if (!d) return false;
+          v = n[d[0]], _ = v.pts[d[1]];
+          var E = i.c2p(_.x, true), T = a.c2p(_.y, true), L = _.mrc || 1;
+          u = HV.extendFlat({}, e, { index: _.i, color: (o.marker || {}).color, name: o.name, x0: E - L, x1: E + L, y0: T - L, y1: T + L, spikeDistance: e.distance, hovertemplate: o.hovertemplate });
+          var x = v.orig_p, C = x !== void 0 ? x : v.pos, M;
+          o.orientation === "h" ? (M = a, u.xLabelVal = _.x, u.yLabelVal = C) : (M = i, u.xLabelVal = C, u.yLabelVal = _.y);
+          var g = M._id.charAt(0);
+          return u[g + "Spike"] = M.c2p(v.pos, true), Z_t(_, o, u), u;
+        }
+        j1e.exports = { hoverPoints: Y_t, hoverOnBoxes: G1e, hoverOnPoints: H1e };
+      });
+      var X1e = ye((Sur, W1e) => {
+        W1e.exports = function(t, r) {
+          return r.hoverOnBox && (t.hoverOnBox = r.hoverOnBox), "xVal" in r && (t.x = r.xVal), "yVal" in r && (t.y = r.yVal), r.xa && (t.xaxis = r.xa), r.ya && (t.yaxis = r.ya), t;
+        };
+      });
+      var WV = ye((Mur, Z1e) => {
+        Z1e.exports = function(t, r) {
+          var n = t.cd, i = t.xaxis, a = t.yaxis, o = [], s, l;
+          if (r === false) for (s = 0; s < n.length; s++) for (l = 0; l < (n[s].pts || []).length; l++) n[s].pts[l].selected = 0;
+          else for (s = 0; s < n.length; s++) for (l = 0; l < (n[s].pts || []).length; l++) {
+            var u = n[s].pts[l], c = i.c2p(u.x), f = a.c2p(u.y);
+            r.contains([c, f], null, u.i, t) ? (o.push({ pointNumber: u.i, x: i.c2d(u.x), y: a.c2d(u.y) }), u.selected = 1) : u.selected = 0;
+          }
+          return o;
+        };
+      });
+      var K1e = ye((Eur, Y1e) => {
+        Y1e.exports = { attributes: k4(), layoutAttributes: C4(), supplyDefaults: P4().supplyDefaults, crossTraceDefaults: P4().crossTraceDefaults, supplyLayoutDefaults: $I().supplyLayoutDefaults, calc: NV(), crossTraceCalc: e8().crossTraceCalc, plot: t8().plot, style: r8().style, styleOnSelect: r8().styleOnSelect, hoverPoints: jV().hoverPoints, eventData: X1e(), selectPoints: WV(), moduleType: "trace", name: "box", basePlotModule: mh(), categories: ["cartesian", "svg", "symbols", "oriented", "box-violin", "showLegend", "boxLayout", "zoomScale"], meta: {} };
+      });
+      var $1e = ye((kur, J1e) => {
+        J1e.exports = K1e();
+      });
+      var FT = ye((Cur, e_e) => {
+        var K_t = Tu(), { extendFlat: Pp } = Ao(), J_t = Gl(), { axisHoverFormat: XV } = df(), $_t = ec(), { hovertemplateAttrs: Q_t, templatefallbackAttrs: Q1e, texttemplateAttrs: ext } = Ll(), a0 = pf();
+        e_e.exports = Pp({ z: { valType: "data_array", editType: "calc" }, x: Pp({}, a0.x, { impliedEdits: { xtype: "array" } }), x0: Pp({}, a0.x0, { impliedEdits: { xtype: "scaled" } }), dx: Pp({}, a0.dx, { impliedEdits: { xtype: "scaled" } }), y: Pp({}, a0.y, { impliedEdits: { ytype: "array" } }), y0: Pp({}, a0.y0, { impliedEdits: { ytype: "scaled" } }), dy: Pp({}, a0.dy, { impliedEdits: { ytype: "scaled" } }), xperiod: Pp({}, a0.xperiod, { impliedEdits: { xtype: "scaled" } }), yperiod: Pp({}, a0.yperiod, { impliedEdits: { ytype: "scaled" } }), xperiod0: Pp({}, a0.xperiod0, { impliedEdits: { xtype: "scaled" } }), yperiod0: Pp({}, a0.yperiod0, { impliedEdits: { ytype: "scaled" } }), xperiodalignment: Pp({}, a0.xperiodalignment, { impliedEdits: { xtype: "scaled" } }), yperiodalignment: Pp({}, a0.yperiodalignment, { impliedEdits: { ytype: "scaled" } }), text: { valType: "data_array", editType: "calc" }, hovertext: { valType: "data_array", editType: "calc" }, transpose: { valType: "boolean", dflt: false, editType: "calc" }, xtype: { valType: "enumerated", values: ["array", "scaled"], editType: "calc+clearAxisTypes" }, ytype: { valType: "enumerated", values: ["array", "scaled"], editType: "calc+clearAxisTypes" }, zsmooth: { valType: "enumerated", values: ["fast", "best", false], dflt: false, editType: "calc" }, hoverongaps: { valType: "boolean", dflt: true, editType: "none" }, connectgaps: { valType: "boolean", editType: "calc" }, xgap: { valType: "number", dflt: 0, min: 0, editType: "plot" }, ygap: { valType: "number", dflt: 0, min: 0, editType: "plot" }, xhoverformat: XV("x"), yhoverformat: XV("y"), zhoverformat: XV("z", 1), hovertemplate: Q_t(), hovertemplatefallback: Q1e(), texttemplate: ext({ arrayOk: false, editType: "plot" }, { keys: ["x", "y", "z", "text"] }), texttemplatefallback: Q1e({ editType: "plot" }), textfont: $_t({ editType: "plot", autoSize: true, autoColor: true, colorEditType: "style" }), showlegend: Pp({}, J_t.showlegend, { dflt: false }), zorder: a0.zorder }, K_t("", { cLetter: "z", autoColorDflt: false }));
+      });
+      var n8 = ye((Lur, r_e) => {
+        var txt = Eo(), i8 = Dr(), rxt = qa();
+        r_e.exports = function(t, r, n, i, a, o) {
+          var s = n("z");
+          a = a || "x", o = o || "y";
+          var l, u;
+          if (s === void 0 || !s.length) return 0;
+          if (i8.isArray1D(s)) {
+            l = n(a), u = n(o);
+            var c = i8.minRowLength(l), f = i8.minRowLength(u);
+            if (c === 0 || f === 0) return 0;
+            r._length = Math.min(c, f, s.length);
+          } else {
+            if (l = t_e(a, n), u = t_e(o, n), !ixt(s)) return 0;
+            n("transpose"), r._length = null;
+          }
+          var h = rxt.getComponentMethod("calendars", "handleTraceDefaults");
+          return h(t, r, [a, o], i), true;
+        };
+        function t_e(e, t) {
+          var r = t(e), n = r ? t(e + "type", "array") : "scaled";
+          return n === "scaled" && (t(e + "0"), t("d" + e)), r;
+        }
+        function ixt(e) {
+          for (var t = true, r = false, n = false, i, a = 0; a < e.length; a++) {
+            if (i = e[a], !i8.isArrayOrTypedArray(i)) {
+              t = false;
+              break;
+            }
+            i.length > 0 && (r = true);
+            for (var o = 0; o < i.length; o++) if (txt(i[o])) {
+              n = true;
+              break;
+            }
+          }
+          return t && r && n;
+        }
+      });
+      var I4 = ye((Pur, n_e) => {
+        var i_e = Dr();
+        n_e.exports = function(t, r) {
+          t("texttemplate"), t("texttemplatefallback");
+          var n = i_e.extendFlat({}, r.font, { color: "auto", size: "auto" });
+          i_e.coerceFont(t, "textfont", n);
+        };
+      });
+      var ZV = ye((Iur, a_e) => {
+        a_e.exports = function(t, r, n) {
+          var i = n("zsmooth");
+          i === false && (n("xgap"), n("ygap")), n("zhoverformat");
+        };
+      });
+      var l_e = ye((Rur, s_e) => {
+        var o_e = Dr(), nxt = n8(), axt = I4(), oxt = Dg(), sxt = ZV(), lxt = td(), uxt = FT();
+        s_e.exports = function(t, r, n, i) {
+          function a(s, l) {
+            return o_e.coerce(t, r, uxt, s, l);
+          }
+          var o = nxt(t, r, a, i);
+          if (!o) {
+            r.visible = false;
+            return;
+          }
+          oxt(t, r, i, a), a("xhoverformat"), a("yhoverformat"), a("text"), a("hovertext"), a("hovertemplate"), a("hovertemplatefallback"), axt(a, i), sxt(t, r, a, i), a("hoverongaps"), a("connectgaps", o_e.isArray1D(r.z) && r.zsmooth !== false), lxt(t, r, i, a, { prefix: "", cLetter: "z" }), a("zorder");
+        };
+      });
+      var YV = ye((Dur, u_e) => {
+        var zT = Eo();
+        u_e.exports = { count: function(e, t, r) {
+          return r[e]++, 1;
+        }, sum: function(e, t, r, n) {
+          var i = n[t];
+          return zT(i) ? (i = Number(i), r[e] += i, i) : 0;
+        }, avg: function(e, t, r, n, i) {
+          var a = n[t];
+          return zT(a) && (a = Number(a), r[e] += a, i[e]++), 0;
+        }, min: function(e, t, r, n) {
+          var i = n[t];
+          if (zT(i)) if (i = Number(i), zT(r[e])) {
+            if (r[e] > i) {
+              var a = i - r[e];
+              return r[e] = i, a;
+            }
+          } else return r[e] = i, i;
+          return 0;
+        }, max: function(e, t, r, n) {
+          var i = n[t];
+          if (zT(i)) if (i = Number(i), zT(r[e])) {
+            if (r[e] < i) {
+              var a = i - r[e];
+              return r[e] = i, a;
+            }
+          } else return r[e] = i, i;
+          return 0;
+        } };
+      });
+      var KV = ye((Fur, c_e) => {
+        c_e.exports = { percent: function(e, t) {
+          for (var r = e.length, n = 100 / t, i = 0; i < r; i++) e[i] *= n;
+        }, probability: function(e, t) {
+          for (var r = e.length, n = 0; n < r; n++) e[n] /= t;
+        }, density: function(e, t, r, n) {
+          var i = e.length;
+          n = n || 1;
+          for (var a = 0; a < i; a++) e[a] *= r[a] * n;
+        }, "probability density": function(e, t, r, n) {
+          var i = e.length;
+          n && (t /= n);
+          for (var a = 0; a < i; a++) e[a] *= r[a] / t;
+        } };
+      });
+      var JV = ye((zur, f_e) => {
+        f_e.exports = function(t, r) {
+          for (var n = t.length, i = 0, a = 0; a < n; a++) r[a] ? (t[a] /= r[a], i += t[a]) : t[a] = null;
+          return i;
+        };
+      });
+      var $V = ye((Our, __e) => {
+        var OT = fs(), p2 = OT.ONEAVGYEAR, h_e = OT.ONEAVGMONTH, o8 = OT.ONEDAY, d_e = OT.ONEHOUR, v_e = OT.ONEMIN, p_e = OT.ONESEC, g_e = ho().tickIncrement;
+        __e.exports = function(t, r, n, i, a) {
+          var o = -1.1 * r, s = -0.1 * r, l = t - s, u = n[0], c = n[1], f = Math.min(a8(u + s, u + l, i, a), a8(c + s, c + l, i, a)), h = Math.min(a8(u + o, u + s, i, a), a8(c + o, c + s, i, a)), d, v;
+          if (f > h && h < Math.abs(c - u) / 4e3 ? (d = f, v = false) : (d = Math.min(f, h), v = true), i.type === "date" && d > o8) {
+            var _ = d === p2 ? 1 : 6, b = d === p2 ? "M12" : "M1";
+            return function(p, k) {
+              var E = i.c2d(p, p2, a), T = E.indexOf("-", _);
+              T > 0 && (E = E.slice(0, T));
+              var L = i.d2c(E, 0, a);
+              if (L < p) {
+                var x = g_e(L, b, false, a);
+                (L + x) / 2 < p + t && (L = x);
+              }
+              return k && v ? g_e(L, b, true, a) : L;
+            };
+          }
+          return function(p, k) {
+            var E = d * Math.round(p / d);
+            return E + d / 10 < p && E + d * 0.9 < p + t && (E += d), k && v && (E -= d), E;
+          };
+        };
+        function a8(e, t, r, n) {
+          if (e * t <= 0) return 1 / 0;
+          for (var i = Math.abs(t - e), a = r.type === "date", o = m_e(i, a), s = 0; s < 10; s++) {
+            var l = m_e(o * 80, a);
+            if (o === l) break;
+            if (cxt(l, e, t, a, r, n)) o = l;
+            else break;
+          }
+          return o;
+        }
+        function m_e(e, t) {
+          return t && e > p_e ? e > o8 ? e > p2 * 1.1 ? p2 : e > h_e * 1.1 ? h_e : o8 : e > d_e ? d_e : e > v_e ? v_e : p_e : Math.pow(10, Math.floor(Math.log(e) / Math.LN10));
+        }
+        function cxt(e, t, r, n, i, a) {
+          if (n && e > o8) {
+            var o = y_e(t, i, a), s = y_e(r, i, a), l = e === p2 ? 0 : 1;
+            return o[l] !== s[l];
+          }
+          return Math.floor(r / e) - Math.floor(t / e) > 0.1;
+        }
+        function y_e(e, t, r) {
+          var n = t.c2d(e, p2, r).split("-");
+          return n[0] === "" && (n.unshift(), n[0] = "-" + n[0]), n;
+        }
+      });
+      var tG = ye((qur, A_e) => {
+        var QV = Eo(), Hv = Dr(), x_e = qa(), j0 = ho(), { hasColorscale: b_e } = pv(), w_e = gv(), fxt = A4(), T_e = YV(), hxt = KV(), dxt = JV(), vxt = $V();
+        function pxt(e, t) {
+          var r = [], n = [], i = t.orientation === "h", a = j0.getFromId(e, i ? t.yaxis : t.xaxis), o = i ? "y" : "x", s = { x: "y", y: "x" }[o], l = t[o + "calendar"], u = t.cumulative, c, f = eG(e, t, a, o), h = f[0], d = f[1], v = typeof h.size == "string", _ = [], b = v ? _ : h, p = [], k = [], E = [], T = 0, L = t.histnorm, x = t.histfunc, C = L.indexOf("density") !== -1, M, g, P;
+          u.enabled && C && (L = L.replace(/ ?density$/, ""), C = false);
+          var A = x === "max" || x === "min", z = A ? null : 0, O = T_e.count, U = hxt[L], G = false, Z = function(me) {
+            return a.r2c(me, 0, l);
+          }, j;
+          for (Hv.isArrayOrTypedArray(t[s]) && x !== "count" && (j = t[s], G = x === "avg", O = T_e[x]), c = Z(h.start), g = Z(h.end) + (c - j0.tickIncrement(c, h.size, false, l)) / 1e6; c < g && r.length < 1e6 && (M = j0.tickIncrement(c, h.size, false, l), r.push((c + M) / 2), n.push(z), E.push([]), _.push(c), C && p.push(1 / (M - c)), G && k.push(0), !(M <= c)); ) c = M;
+          _.push(c), !v && a.type === "date" && (b = { start: Z(b.start), end: Z(b.end), size: b.size }), e._fullLayout._roundFnOpts || (e._fullLayout._roundFnOpts = {});
+          var N = t["_" + o + "bingroup"], H = { leftGap: 1 / 0, rightGap: 1 / 0 };
+          N && (e._fullLayout._roundFnOpts[N] || (e._fullLayout._roundFnOpts[N] = H), H = e._fullLayout._roundFnOpts[N]);
+          var re = n.length, oe = true, _e = H.leftGap, Ce = H.rightGap, Le = {};
+          for (c = 0; c < d.length; c++) {
+            var ge = d[c];
+            P = Hv.findBin(ge, b), P >= 0 && P < re && (T += O(P, c, n, j, k), oe && E[P].length && ge !== d[E[P][0]] && (oe = false), E[P].push(c), Le[c] = P, _e = Math.min(_e, ge - _[P]), Ce = Math.min(Ce, _[P + 1] - ge));
+          }
+          H.leftGap = _e, H.rightGap = Ce;
+          var ie;
+          oe || (ie = function(me, De) {
+            return function() {
+              var ce = e._fullLayout._roundFnOpts[N];
+              return vxt(ce.leftGap, ce.rightGap, _, a, l)(me, De);
+            };
+          }), G && (T = dxt(n, k)), U && U(n, T, p), u.enabled && yxt(n, u.direction, u.currentbin);
+          var Se = Math.min(r.length, n.length), Ee = [], Ae = 0, Be = Se - 1;
+          for (c = 0; c < Se; c++) if (n[c]) {
+            Ae = c;
+            break;
+          }
+          for (c = Se - 1; c >= Ae; c--) if (n[c]) {
+            Be = c;
+            break;
+          }
+          for (c = Ae; c <= Be; c++) if (QV(r[c]) && QV(n[c])) {
+            var Pe = { p: r[c], s: n[c], b: 0 };
+            u.enabled || (Pe.pts = E[c], oe ? Pe.ph0 = Pe.ph1 = E[c].length ? d[E[c][0]] : r[c] : (t._computePh = true, Pe.ph0 = ie(_[c]), Pe.ph1 = ie(_[c + 1], true))), Ee.push(Pe);
+          }
+          return Ee.length === 1 && (Ee[0].width1 = j0.tickIncrement(Ee[0].p, h.size, false, l) - Ee[0].p), b_e(t, "marker") && w_e(e, t, { vals: t.marker.color, containerStr: "marker", cLetter: "c" }), b_e(t, "marker.line") && w_e(e, t, { vals: t.marker.line.color, containerStr: "marker.line", cLetter: "c" }), fxt(Ee, t), Hv.isArrayOrTypedArray(t.selectedpoints) && Hv.tagSelected(Ee, t, Le), Ee;
+        }
+        function eG(e, t, r, n, i) {
+          var a = n + "bins", o = e._fullLayout, s = t["_" + n + "bingroup"], l = o._histogramBinOpts[s], u = o.barmode === "overlay", c, f, h, d, v, _, b, p = function(ge) {
+            return r.r2c(ge, 0, d);
+          }, k = function(ge) {
+            return r.c2r(ge, 0, d);
+          }, E = r.type === "date" ? function(ge) {
+            return ge || ge === 0 ? Hv.cleanDate(ge, null, d) : null;
+          } : function(ge) {
+            return QV(ge) ? Number(ge) : null;
+          };
+          function T(ge, ie, Se) {
+            ie[ge + "Found"] ? (ie[ge] = E(ie[ge]), ie[ge] === null && (ie[ge] = Se[ge])) : (_[ge] = ie[ge] = Se[ge], Hv.nestedProperty(f[0], a + "." + ge).set(Se[ge]));
+          }
+          if (t["_" + n + "autoBinFinished"]) delete t["_" + n + "autoBinFinished"];
+          else {
+            f = l.traces;
+            var L = [], x = true, C = false, M = false;
+            for (c = 0; c < f.length; c++) if (h = f[c], h.visible) {
+              var g = l.dirs[c];
+              v = h["_" + g + "pos0"] = r.makeCalcdata(h, g), L = Hv.concat(L, v), delete h["_" + n + "autoBinFinished"], t.visible === true && (x ? x = false : (delete h._autoBin, h["_" + n + "autoBinFinished"] = 1), x_e.traceIs(h, "2dMap") && (C = true), h.type === "histogram2dcontour" && (M = true));
+            }
+            d = f[0][n + "calendar"];
+            var P = j0.autoBin(L, r, l.nbins, C, d, l.sizeFound && l.size), A = f[0]._autoBin = {};
+            if (_ = A[l.dirs[0]] = {}, M && (l.size || (P.start = k(j0.tickIncrement(p(P.start), P.size, true, d))), l.end === void 0 && (P.end = k(j0.tickIncrement(p(P.end), P.size, false, d)))), u && !x_e.traceIs(t, "2dMap") && P._dataSpan === 0 && r.type !== "category" && r.type !== "multicategory" && t.bingroup === "" && typeof t.xbins == "undefined") {
+              if (i) return [P, v, true];
+              P = gxt(e, t, r, n, a);
+            }
+            b = h.cumulative || {}, b.enabled && b.currentbin !== "include" && (b.direction === "decreasing" ? P.start = k(j0.tickIncrement(p(P.start), P.size, true, d)) : P.end = k(j0.tickIncrement(p(P.end), P.size, false, d))), l.size = P.size, l.sizeFound || (_.size = P.size, Hv.nestedProperty(f[0], a + ".size").set(P.size)), T("start", l, P), T("end", l, P);
+          }
+          v = t["_" + n + "pos0"], delete t["_" + n + "pos0"];
+          var z = t._input[a] || {}, O = Hv.extendFlat({}, l), U = l.start, G = r.r2l(z.start), Z = G !== void 0;
+          if ((l.startFound || Z) && G !== r.r2l(U)) {
+            var j = Z ? G : Hv.aggNums(Math.min, null, v), N = { type: r.type === "category" || r.type === "multicategory" ? "linear" : r.type, r2l: r.r2l, dtick: l.size, tick0: U, calendar: d, range: [j, j0.tickIncrement(j, l.size, false, d)].map(r.l2r) }, H = j0.tickFirst(N);
+            H > r.r2l(j) && (H = j0.tickIncrement(H, l.size, true, d)), O.start = r.l2r(H), Z || Hv.nestedProperty(t, a + ".start").set(O.start);
+          }
+          var re = l.end, oe = r.r2l(z.end), _e = oe !== void 0;
+          if ((l.endFound || _e) && oe !== r.r2l(re)) {
+            var Ce = _e ? oe : Hv.aggNums(Math.max, null, v);
+            O.end = r.l2r(Ce), _e || Hv.nestedProperty(t, a + ".start").set(O.end);
+          }
+          var Le = "autobin" + n;
+          return t._input[Le] === false && (t._input[a] = Hv.extendFlat({}, t[a] || {}), delete t._input[Le], delete t[Le]), [O, v];
+        }
+        function gxt(e, t, r, n, i) {
+          var a = e._fullLayout, o = mxt(e, t), s = false, l = 1 / 0, u = [t], c, f, h;
+          for (c = 0; c < o.length; c++) if (f = o[c], f === t) s = true;
+          else if (!s) h = a._histogramBinOpts[f["_" + n + "bingroup"]], l = Math.min(l, h.size || f[i].size);
+          else {
+            var d = eG(e, f, r, n, true), v = d[0], _ = d[2];
+            f["_" + n + "autoBinFinished"] = 1, f["_" + n + "pos0"] = d[1], _ ? u.push(f) : l = Math.min(l, v.size);
+          }
+          var b = new Array(u.length);
+          for (c = 0; c < u.length; c++) for (var p = u[c]["_" + n + "pos0"], k = 0; k < p.length; k++) if (p[k] !== void 0) {
+            b[c] = p[k];
+            break;
+          }
+          for (isFinite(l) || (l = Hv.distinctVals(b).minDiff), c = 0; c < u.length; c++) {
+            f = u[c];
+            var E = f[n + "calendar"], T = { start: r.c2r(b[c] - l / 2, 0, E), end: r.c2r(b[c] + l / 2, 0, E), size: l };
+            f._input[i] = f[i] = T, h = a._histogramBinOpts[f["_" + n + "bingroup"]], h && Hv.extendFlat(h, T);
+          }
+          return t[i];
+        }
+        function mxt(e, t) {
+          for (var r = t.xaxis, n = t.yaxis, i = t.orientation, a = [], o = e._fullData, s = 0; s < o.length; s++) {
+            var l = o[s];
+            l.type === "histogram" && l.visible === true && l.orientation === i && l.xaxis === r && l.yaxis === n && a.push(l);
+          }
+          return a;
+        }
+        function yxt(e, t, r) {
+          var n, i, a;
+          function o(l) {
+            a = e[l], e[l] /= 2;
+          }
+          function s(l) {
+            i = e[l], e[l] = a + i / 2, a += i;
+          }
+          if (r === "half") if (t === "increasing") for (o(0), n = 1; n < e.length; n++) s(n);
+          else for (o(e.length - 1), n = e.length - 2; n >= 0; n--) s(n);
+          else if (t === "increasing") {
+            for (n = 1; n < e.length; n++) e[n] += e[n - 1];
+            r === "exclude" && (e.unshift(0), e.pop());
+          } else {
+            for (n = e.length - 2; n >= 0; n--) e[n] += e[n + 1];
+            r === "exclude" && (e.push(0), e.shift());
+          }
+        }
+        A_e.exports = { calc: pxt, calcAllAutoBins: eG };
+      });
+      var I_e = ye((Bur, P_e) => {
+        var S_e = Dr(), qT = ho(), M_e = YV(), _xt = KV(), xxt = JV(), bxt = $V(), E_e = tG().calcAllAutoBins;
+        P_e.exports = function(t, r) {
+          var n = qT.getFromId(t, r.xaxis), i = qT.getFromId(t, r.yaxis), a = r.xcalendar, o = r.ycalendar, s = function(It) {
+            return n.r2c(It, 0, a);
+          }, l = function(It) {
+            return i.r2c(It, 0, o);
+          }, u = function(It) {
+            return n.c2r(It, 0, a);
+          }, c = function(It) {
+            return i.c2r(It, 0, o);
+          }, f, h, d, v, _ = E_e(t, r, n, "x"), b = _[0], p = _[1], k = E_e(t, r, i, "y"), E = k[0], T = k[1], L = r._length;
+          p.length > L && p.splice(L, p.length - L), T.length > L && T.splice(L, T.length - L);
+          var x = [], C = [], M = [], g = typeof b.size == "string", P = typeof E.size == "string", A = [], z = [], O = g ? A : b, U = P ? z : E, G = 0, Z = [], j = [], N = r.histnorm, H = r.histfunc, re = N.indexOf("density") !== -1, oe = H === "max" || H === "min", _e = oe ? null : 0, Ce = M_e.count, Le = _xt[N], ge = false, ie = [], Se = [], Ee = "z" in r ? r.z : "marker" in r && Array.isArray(r.marker.color) ? r.marker.color : "";
+          Ee && H !== "count" && (ge = H === "avg", Ce = M_e[H]);
+          var Ae = b.size, Be = s(b.start), Pe = s(b.end) + (Be - qT.tickIncrement(Be, Ae, false, a)) / 1e6;
+          for (f = Be; f < Pe; f = qT.tickIncrement(f, Ae, false, a)) C.push(_e), A.push(f), ge && M.push(0);
+          A.push(f);
+          var me = C.length, De = (f - Be) / me, ce = u(Be + De / 2), je = E.size, lt = l(E.start), pt = l(E.end) + (lt - qT.tickIncrement(lt, je, false, o)) / 1e6;
+          for (f = lt; f < pt; f = qT.tickIncrement(f, je, false, o)) {
+            x.push(C.slice()), z.push(f);
+            var Vt = new Array(me);
+            for (h = 0; h < me; h++) Vt[h] = [];
+            j.push(Vt), ge && Z.push(M.slice());
+          }
+          z.push(f);
+          var ot = x.length, ut = (f - lt) / ot, Wt = c(lt + ut / 2);
+          re && (ie = k_e(C.length, O, De, g), Se = k_e(x.length, U, ut, P)), !g && n.type === "date" && (O = C_e(s, O)), !P && i.type === "date" && (U = C_e(l, U));
+          var Nt = true, $t = true, sr = new Array(me), Tr = new Array(ot), fr = 1 / 0, $e = 1 / 0, St = 1 / 0, Qt = 1 / 0;
+          for (f = 0; f < L; f++) {
+            var Gt = p[f], _t = T[f];
+            d = S_e.findBin(Gt, O), v = S_e.findBin(_t, U), d >= 0 && d < me && v >= 0 && v < ot && (G += Ce(d, f, x[v], Ee, Z[v]), j[v][d].push(f), Nt && (sr[d] === void 0 ? sr[d] = Gt : sr[d] !== Gt && (Nt = false)), $t && (Tr[v] === void 0 ? Tr[v] = _t : Tr[v] !== _t && ($t = false)), fr = Math.min(fr, Gt - A[d]), $e = Math.min($e, A[d + 1] - Gt), St = Math.min(St, _t - z[v]), Qt = Math.min(Qt, z[v + 1] - _t));
+          }
+          if (ge) for (v = 0; v < ot; v++) G += xxt(x[v], Z[v]);
+          if (Le) for (v = 0; v < ot; v++) Le(x[v], G, ie, Se[v]);
+          return { x: p, xRanges: L_e(A, Nt && sr, fr, $e, n, a), x0: ce, dx: De, y: T, yRanges: L_e(z, $t && Tr, St, Qt, i, o), y0: Wt, dy: ut, z: x, pts: j };
+        };
+        function k_e(e, t, r, n) {
+          var i = new Array(e), a;
+          if (n) for (a = 0; a < e; a++) i[a] = 1 / (t[a + 1] - t[a]);
+          else {
+            var o = 1 / r;
+            for (a = 0; a < e; a++) i[a] = o;
+          }
+          return i;
+        }
+        function C_e(e, t) {
+          return { start: e(t.start), end: e(t.end), size: t.size };
+        }
+        function L_e(e, t, r, n, i, a) {
+          var o, s = e.length - 1, l = new Array(s), u = bxt(r, n, e, i, a);
+          for (o = 0; o < s; o++) {
+            var c = (t || [])[o];
+            l[o] = c === void 0 ? [u(e[o]), u(e[o + 1], true)] : [c, c];
+          }
+          return l;
+        }
+      });
+      var s8 = ye((Nur, F_e) => {
+        var qm = Dr(), R_e = fs().BADNUM, D_e = zg();
+        F_e.exports = function(t, r, n, i, a, o) {
+          var s = t._length, l = r.makeCalcdata(t, i), u = n.makeCalcdata(t, a);
+          l = D_e(t, r, i, l).vals, u = D_e(t, n, a, u).vals;
+          var c = t.text, f = c !== void 0 && qm.isArray1D(c), h = t.hovertext, d = h !== void 0 && qm.isArray1D(h), v, _, b = qm.distinctVals(l), p = b.vals, k = qm.distinctVals(u), E = k.vals, T = [], L, x, C = E.length, M = p.length;
+          for (v = 0; v < o.length; v++) T[v] = qm.init2dArray(C, M);
+          f && (L = qm.init2dArray(C, M)), d && (x = qm.init2dArray(C, M));
+          var g = qm.init2dArray(C, M);
+          for (v = 0; v < s; v++) if (l[v] !== R_e && u[v] !== R_e) {
+            var P = qm.findBin(l[v] + b.minDiff / 2, p), A = qm.findBin(u[v] + k.minDiff / 2, E);
+            for (_ = 0; _ < o.length; _++) {
+              var z = o[_], O = t[z], U = T[_];
+              U[A][P] = O[v], g[A][P] = v;
+            }
+            f && (L[A][P] = c[v]), d && (x[A][P] = h[v]);
+          }
+          for (t["_" + i] = p, t["_" + a] = E, _ = 0; _ < o.length; _++) t["_" + o[_]] = T[_];
+          f && (t._text = L), d && (t._hovertext = x), r && r.type === "category" && (t["_" + i + "CategoryMap"] = p.map(function(G) {
+            return r._categories[G];
+          })), n && n.type === "category" && (t["_" + a + "CategoryMap"] = E.map(function(G) {
+            return n._categories[G];
+          })), t._after2before = g;
+        };
+      });
+      var u8 = ye((Uur, z_e) => {
+        var wxt = Eo(), Txt = Dr(), l8 = fs().BADNUM;
+        z_e.exports = function(t, r, n, i) {
+          var a, o, s, l, u, c;
+          function f(p) {
+            if (wxt(p)) return +p;
+          }
+          if (r && r.transpose) {
+            for (a = 0, u = 0; u < t.length; u++) a = Math.max(a, t[u].length);
+            if (a === 0) return false;
+            s = function(p) {
+              return p.length;
+            }, l = function(p, k, E) {
+              return (p[E] || [])[k];
+            };
+          } else a = t.length, s = function(p, k) {
+            return p[k].length;
+          }, l = function(p, k, E) {
+            return (p[k] || [])[E];
+          };
+          var h = function(p, k, E) {
+            return k === l8 || E === l8 ? l8 : l(p, k, E);
+          };
+          function d(p) {
+            if (r && r.type !== "carpet" && r.type !== "contourcarpet" && p && p.type === "category" && r["_" + p._id.charAt(0)].length) {
+              var k = p._id.charAt(0), E = {}, T = r["_" + k + "CategoryMap"] || r[k];
+              for (u = 0; u < T.length; u++) E[T[u]] = u;
+              return function(L) {
+                var x = E[p._categories[L]];
+                return x + 1 ? x : l8;
+              };
+            } else return Txt.identity;
+          }
+          var v = d(n), _ = d(i);
+          i && i.type === "category" && (a = i._categories.length);
+          var b = new Array(a);
+          for (u = 0; u < a; u++) for (n && n.type === "category" ? o = n._categories.length : o = s(t, u), b[u] = new Array(o), c = 0; c < o; c++) b[u][c] = f(h(t, _(u), v(c)));
+          return b;
+        };
+      });
+      var c8 = ye((Vur, B_e) => {
+        var Axt = Dr(), O_e = 0.01, Sxt = [[-1, 0], [1, 0], [0, -1], [0, 1]];
+        function Mxt(e) {
+          return 0.5 - 0.25 * Math.min(1, e * 0.5);
+        }
+        B_e.exports = function(t, r) {
+          var n = 1, i;
+          for (q_e(t, r), i = 0; i < r.length && !(r[i][2] < 4); i++) ;
+          for (r = r.slice(i), i = 0; i < 100 && n > O_e; i++) n = q_e(t, r, Mxt(n));
+          return n > O_e && Axt.log("interp2d didn't converge quickly", n), t;
+        };
+        function q_e(e, t, r) {
+          var n = 0, i, a, o, s, l, u, c, f, h, d, v, _, b;
+          for (s = 0; s < t.length; s++) {
+            for (i = t[s], a = i[0], o = i[1], v = e[a][o], d = 0, h = 0, l = 0; l < 4; l++) u = Sxt[l], c = e[a + u[0]], c && (f = c[o + u[1]], f !== void 0 && (d === 0 ? _ = b = f : (_ = Math.min(_, f), b = Math.max(b, f)), h++, d += f));
+            if (h === 0) throw "iterateInterp2d order is wrong: no defined neighbors";
+            e[a][o] = d / h, v === void 0 ? h < 4 && (n = 1) : (e[a][o] = (1 + r) * e[a][o] - r * v, b > _ && (n = Math.max(n, Math.abs(e[a][o] - v) / (b - _))));
+          }
+          return n;
+        }
+      });
+      var f8 = ye((Gur, N_e) => {
+        var Ext = Dr().maxRowLength;
+        N_e.exports = function(t) {
+          var r = [], n = {}, i = [], a = t[0], o = [], s = [0, 0, 0], l = Ext(t), u, c, f, h, d, v, _, b;
+          for (c = 0; c < t.length; c++) for (u = o, o = a, a = t[c + 1] || [], f = 0; f < l; f++) o[f] === void 0 && (v = (o[f - 1] !== void 0 ? 1 : 0) + (o[f + 1] !== void 0 ? 1 : 0) + (u[f] !== void 0 ? 1 : 0) + (a[f] !== void 0 ? 1 : 0), v ? (c === 0 && v++, f === 0 && v++, c === t.length - 1 && v++, f === o.length - 1 && v++, v < 4 && (n[[c, f]] = [c, f, v]), r.push([c, f, v])) : i.push([c, f]));
+          for (; i.length; ) {
+            for (_ = {}, b = false, d = i.length - 1; d >= 0; d--) h = i[d], c = h[0], f = h[1], v = ((n[[c - 1, f]] || s)[2] + (n[[c + 1, f]] || s)[2] + (n[[c, f - 1]] || s)[2] + (n[[c, f + 1]] || s)[2]) / 20, v && (_[h] = [c, f, v], i.splice(d, 1), b = true);
+            if (!b) throw "findEmpties iterated with no new neighbors";
+            for (h in _) n[h] = _[h], r.push(_[h]);
+          }
+          return r.sort(function(p, k) {
+            return k[2] - p[2];
+          });
+        };
+      });
+      var rG = ye((Hur, G_e) => {
+        var U_e = qa(), V_e = Dr().isArrayOrTypedArray;
+        G_e.exports = function(t, r, n, i, a, o) {
+          var s = [], l = U_e.traceIs(t, "contour"), u = U_e.traceIs(t, "histogram"), c, f, h, d = V_e(r) && r.length > 1;
+          if (d && !u && o.type !== "category") {
+            var v = r.length;
+            if (v <= a) {
+              if (l) s = Array.from(r).slice(0, a);
+              else if (a === 1) o.type === "log" ? s = [0.5 * r[0], 2 * r[0]] : s = [r[0] - 0.5, r[0] + 0.5];
+              else if (o.type === "log") {
+                for (s = [Math.pow(r[0], 1.5) / Math.pow(r[1], 0.5)], h = 1; h < v; h++) s.push(Math.sqrt(r[h - 1] * r[h]));
+                s.push(Math.pow(r[v - 1], 1.5) / Math.pow(r[v - 2], 0.5));
+              } else {
+                for (s = [1.5 * r[0] - 0.5 * r[1]], h = 1; h < v; h++) s.push((r[h - 1] + r[h]) * 0.5);
+                s.push(1.5 * r[v - 1] - 0.5 * r[v - 2]);
+              }
+              if (v < a) {
+                var _ = s[s.length - 1], b;
+                if (o.type === "log") for (b = _ / s[s.length - 2], h = v; h < a; h++) _ *= b, s.push(_);
+                else for (b = _ - s[s.length - 2], h = v; h < a; h++) _ += b, s.push(_);
+              }
+            } else return l ? r.slice(0, a) : r.slice(0, a + 1);
+          } else {
+            var p = t[o._id.charAt(0) + "calendar"];
+            if (u) c = o.r2c(n, 0, p);
+            else if (V_e(r) && r.length === 1) c = r[0];
+            else if (n === void 0) c = 0;
+            else {
+              var k = o.type === "log" ? o.d2c : o.r2c;
+              c = k(n, 0, p);
+            }
+            for (f = i || 1, h = l ? 0 : -0.5; h < a; h++) s.push(c + f * h);
+          }
+          return s;
+        };
+      });
+      var v8 = ye((jur, X_e) => {
+        var H_e = qa(), iG = Dr(), h8 = ho(), j_e = zg(), kxt = I_e(), Cxt = gv(), Lxt = s8(), Pxt = u8(), Ixt = c8(), Rxt = f8(), d8 = rG(), nG = fs().BADNUM;
+        X_e.exports = function(t, r) {
+          var n = h8.getFromId(t, r.xaxis || "x"), i = h8.getFromId(t, r.yaxis || "y"), a = H_e.traceIs(r, "contour"), o = H_e.traceIs(r, "histogram"), s = a ? "best" : r.zsmooth, l, u, c, f, h, d, v, _, b, p, k;
+          if (n._minDtick = 0, i._minDtick = 0, o) k = kxt(t, r), f = k.orig_x, l = k.x, u = k.x0, c = k.dx, _ = k.orig_y, h = k.y, d = k.y0, v = k.dy, b = k.z;
+          else {
+            var E = r.z;
+            iG.isArray1D(E) ? (Lxt(r, n, i, "x", "y", ["z"]), l = r._x, h = r._y, E = r._z) : (f = r.x ? n.makeCalcdata(r, "x") : [], _ = r.y ? i.makeCalcdata(r, "y") : [], l = j_e(r, n, "x", f).vals, h = j_e(r, i, "y", _).vals, r._x = l, r._y = h), u = r.x0, c = r.dx, d = r.y0, v = r.dy, b = Pxt(E, r, n, i);
+          }
+          (n.rangebreaks || i.rangebreaks) && (b = Dxt(l, h, b), o || (l = W_e(l), h = W_e(h), r._x = l, r._y = h)), !o && (a || r.connectgaps) && (r._emptypoints = Rxt(b), Ixt(b, r._emptypoints));
+          function T(O) {
+            s = r._input.zsmooth = r.zsmooth = false, iG.warn('cannot use zsmooth: "fast": ' + O);
+          }
+          function L(O) {
+            if (O.length > 1) {
+              var U = (O[O.length - 1] - O[0]) / (O.length - 1), G = Math.abs(U / 100);
+              for (p = 0; p < O.length - 1; p++) if (Math.abs(O[p + 1] - O[p] - U) > G) return false;
+            }
+            return true;
+          }
+          r._islinear = false, n.type === "log" || i.type === "log" ? s === "fast" && T("log axis found") : L(l) ? L(h) ? r._islinear = true : s === "fast" && T("y scale is not linear") : s === "fast" && T("x scale is not linear");
+          var x = iG.maxRowLength(b), C = r.xtype === "scaled" ? "" : l, M = d8(r, C, u, c, x, n), g = r.ytype === "scaled" ? "" : h, P = d8(r, g, d, v, b.length, i);
+          r._extremes[n._id] = h8.findExtremes(n, M), r._extremes[i._id] = h8.findExtremes(i, P);
+          var A = { x: M, y: P, z: b, text: r._text || r.text, hovertext: r._hovertext || r.hovertext };
+          if (r.xperiodalignment && f && (A.orig_x = f), r.yperiodalignment && _ && (A.orig_y = _), C && C.length === M.length - 1 && (A.xCenter = C), g && g.length === P.length - 1 && (A.yCenter = g), o && (A.xRanges = k.xRanges, A.yRanges = k.yRanges, A.pts = k.pts), a || Cxt(t, r, { vals: b, cLetter: "z" }), a && r.contours && r.contours.coloring === "heatmap") {
+            var z = { type: r.type === "contour" ? "heatmap" : "histogram2d", xcalendar: r.xcalendar, ycalendar: r.ycalendar };
+            A.xfill = d8(z, C, u, c, x, n), A.yfill = d8(z, g, d, v, b.length, i);
+          }
+          return [A];
+        };
+        function W_e(e) {
+          for (var t = [], r = e.length, n = 0; n < r; n++) {
+            var i = e[n];
+            i !== nG && t.push(i);
+          }
+          return t;
+        }
+        function Dxt(e, t, r) {
+          for (var n = [], i = -1, a = 0; a < r.length; a++) if (t[a] !== nG) {
+            i++, n[i] = [];
+            for (var o = 0; o < r[a].length; o++) e[o] !== nG && n[i].push(r[a][o]);
+          }
+          return n;
+        }
+      });
+      var g8 = ye((p8) => {
+        p8.CSS_DECLARATIONS = [["image-rendering", "optimizeSpeed"], ["image-rendering", "-moz-crisp-edges"], ["image-rendering", "-o-crisp-edges"], ["image-rendering", "-webkit-optimize-contrast"], ["image-rendering", "optimize-contrast"], ["image-rendering", "crisp-edges"], ["image-rendering", "pixelated"]];
+        p8.STYLE = p8.CSS_DECLARATIONS.map(function(e) {
+          return e.join(": ") + "; ";
+        }).join("");
+      });
+      var oG = ye((Xur, Y_e) => {
+        var Z_e = g8(), Fxt = So(), aG = Dr(), BT = null;
+        function zxt() {
+          if (BT !== null) return BT;
+          BT = false;
+          var e = aG.isSafari() || aG.isMacWKWebView() || aG.isIOS();
+          if (window.navigator.userAgent && !e) {
+            var t = Array.from(Z_e.CSS_DECLARATIONS).reverse(), r = window.CSS && window.CSS.supports || window.supportsCSS;
+            if (typeof r == "function") BT = t.some(function(o) {
+              return r.apply(null, o);
+            });
+            else {
+              var n = Fxt.tester.append("image").attr("style", Z_e.STYLE), i = window.getComputedStyle(n.node()), a = i.imageRendering;
+              BT = t.some(function(o) {
+                var s = o[1];
+                return a === s || a === s.toLowerCase();
+              }), n.remove();
+            }
+          }
+          return BT;
+        }
+        Y_e.exports = zxt;
+      });
+      var m8 = ye((Zur, nxe) => {
+        var K_e = Oa(), Oxt = fd(), qxt = qa(), Bxt = So(), Nxt = ho(), W0 = Dr(), J_e = Zl(), Uxt = lI(), Vxt = ka(), Gxt = tc().extractOpts, Hxt = tc().makeColorScaleFuncFromTrace, jxt = Wp(), Wxt = Dh(), sG = Wxt.LINE_SPACING, Xxt = oG(), Zxt = g8().STYLE, rxe = "heatmap-label";
+        function ixe(e) {
+          return e.selectAll("g." + rxe);
+        }
+        function $_e(e) {
+          ixe(e).remove();
+        }
+        nxe.exports = function(e, t, r, n) {
+          var i = t.xaxis, a = t.yaxis;
+          W0.makeTraceGroups(n, r, "hm").each(function(o) {
+            var s = K_e.select(this), l = o[0], u = l.trace, c = u.xgap || 0, f = u.ygap || 0, h = l.z, d = l.x, v = l.y, _ = l.xCenter, b = l.yCenter, p = qxt.traceIs(u, "contour"), k = p ? "best" : u.zsmooth, E = h.length, T = W0.maxRowLength(h), L = false, x = false, C, M, g, P, A, z, O, U;
+            for (z = 0; C === void 0 && z < d.length - 1; ) C = i.c2p(d[z]), z++;
+            for (z = d.length - 1; M === void 0 && z > 0; ) M = i.c2p(d[z]), z--;
+            for (M < C && (g = M, M = C, C = g, L = true), z = 0; P === void 0 && z < v.length - 1; ) P = a.c2p(v[z]), z++;
+            for (z = v.length - 1; A === void 0 && z > 0; ) A = a.c2p(v[z]), z--;
+            A < P && (g = P, P = A, A = g, x = true), p && (_ = d, b = v, d = l.xfill, v = l.yfill);
+            var G = "default";
+            if (k ? G = k === "best" ? "smooth" : "fast" : u._islinear && c === 0 && f === 0 && Xxt() && (G = "fast"), G !== "fast") {
+              var Z = k === "best" ? 0 : 0.5;
+              C = Math.max(-Z * i._length, C), M = Math.min((1 + Z) * i._length, M), P = Math.max(-Z * a._length, P), A = Math.min((1 + Z) * a._length, A);
+            }
+            var j = Math.round(M - C), N = Math.round(A - P), H = C >= i._length || M <= 0 || P >= a._length || A <= 0;
+            if (H) {
+              var re = s.selectAll("image").data([]);
+              re.exit().remove(), $_e(s);
+              return;
+            }
+            var oe, _e;
+            G === "fast" ? (oe = T, _e = E) : (oe = j, _e = N);
+            var Ce = document.createElement("canvas");
+            Ce.width = oe, Ce.height = _e;
+            var Le = Ce.getContext("2d", { willReadFrequently: true }), ge = Hxt(u, { noNumericCheck: true, returnArray: true }), ie, Se;
+            G === "fast" ? (ie = L ? function(fn) {
+              return T - 1 - fn;
+            } : W0.identity, Se = x ? function(fn) {
+              return E - 1 - fn;
+            } : W0.identity) : (ie = function(fn) {
+              return W0.constrain(Math.round(i.c2p(d[fn]) - C), 0, j);
+            }, Se = function(fn) {
+              return W0.constrain(Math.round(a.c2p(v[fn]) - P), 0, N);
+            });
+            var Ee = Se(0), Ae = [Ee, Ee], Be = L ? 0 : 1, Pe = x ? 0 : 1, me = 0, De = 0, ce = 0, je = 0, lt, pt, Vt, ot, ut;
+            function Wt(fn, yn) {
+              if (fn !== void 0) {
+                var Sn = ge(fn);
+                return Sn[0] = Math.round(Sn[0]), Sn[1] = Math.round(Sn[1]), Sn[2] = Math.round(Sn[2]), me += yn, De += Sn[0] * yn, ce += Sn[1] * yn, je += Sn[2] * yn, Sn;
+              }
+              return [0, 0, 0, 0];
+            }
+            function Nt(fn, yn, Sn, Ba) {
+              var ua = fn[Sn.bin0];
+              if (ua === void 0) return Wt(void 0, 1);
+              var ma = fn[Sn.bin1], Wa = yn[Sn.bin0], Fa = yn[Sn.bin1], Xo = ma - ua || 0, da = Wa - ua || 0, Wn;
+              return ma === void 0 ? Fa === void 0 ? Wn = 0 : Wa === void 0 ? Wn = 2 * (Fa - ua) : Wn = (2 * Fa - Wa - ua) * 2 / 3 : Fa === void 0 ? Wa === void 0 ? Wn = 0 : Wn = (2 * ua - ma - Wa) * 2 / 3 : Wa === void 0 ? Wn = (2 * Fa - ma - ua) * 2 / 3 : Wn = Fa + ua - ma - Wa, Wt(ua + Sn.frac * Xo + Ba.frac * (da + Sn.frac * Wn));
+            }
+            if (G !== "default") {
+              var $t = 0, sr;
+              try {
+                sr = new Uint8Array(oe * _e * 4);
+              } catch (fn) {
+                sr = new Array(oe * _e * 4);
+              }
+              if (G === "smooth") {
+                var Tr = _ || d, fr = b || v, $e = new Array(Tr.length), St = new Array(fr.length), Qt = new Array(j), Gt = _ ? exe : Q_e, _t = b ? exe : Q_e, It, mt, er;
+                for (z = 0; z < Tr.length; z++) $e[z] = Math.round(i.c2p(Tr[z]) - C);
+                for (z = 0; z < fr.length; z++) St[z] = Math.round(a.c2p(fr[z]) - P);
+                for (z = 0; z < j; z++) Qt[z] = Gt(z, $e);
+                for (O = 0; O < N; O++) for (It = _t(O, St), mt = h[It.bin0], er = h[It.bin1], z = 0; z < j; z++, $t += 4) ut = Nt(mt, er, Qt[z], It), txe(sr, $t, ut);
+              } else for (O = 0; O < E; O++) for (ot = h[O], Ae = Se(O), z = 0; z < T; z++) ut = Wt(ot[z], 1), $t = (Ae * T + ie(z)) * 4, txe(sr, $t, ut);
+              var lr = Le.createImageData(oe, _e);
+              try {
+                lr.data.set(sr);
+              } catch (fn) {
+                var wr = lr.data, Lr = wr.length;
+                for (O = 0; O < Lr; O++) wr[O] = sr[O];
+              }
+              Le.putImageData(lr, 0, 0);
+            } else {
+              var ti = Math.floor(c / 2), Br = Math.floor(f / 2);
+              for (O = 0; O < E; O++) if (ot = h[O], Ae.reverse(), Ae[Pe] = Se(O + 1), !(Ae[0] === Ae[1] || Ae[0] === void 0 || Ae[1] === void 0)) for (pt = ie(0), lt = [pt, pt], z = 0; z < T; z++) lt.reverse(), lt[Be] = ie(z + 1), !(lt[0] === lt[1] || lt[0] === void 0 || lt[1] === void 0) && (Vt = ot[z], ut = Wt(Vt, (lt[1] - lt[0]) * (Ae[1] - Ae[0])), Le.fillStyle = "rgba(" + ut.join(",") + ")", Le.fillRect(lt[0] + ti, Ae[0] + Br, lt[1] - lt[0] - c, Ae[1] - Ae[0] - f));
+            }
+            De = Math.round(De / me), ce = Math.round(ce / me), je = Math.round(je / me);
+            var Vr = Oxt("rgb(" + De + "," + ce + "," + je + ")");
+            e._hmpixcount = (e._hmpixcount || 0) + me, e._hmlumcount = (e._hmlumcount || 0) + me * Vr.getLuminance();
+            var dt = s.selectAll("image").data(o);
+            dt.enter().append("svg:image").attr({ xmlns: jxt.svg, preserveAspectRatio: "none" }), dt.attr({ height: N, width: j, x: C, y: P, "xlink:href": Ce.toDataURL("image/png") }), G === "fast" && !k && dt.attr("style", Zxt), $_e(s);
+            var Ge = u.texttemplate;
+            if (Ge) {
+              var Je = Gxt(u), We = { type: "linear", range: [Je.min, Je.max], _separators: i._separators, _numFormat: i._numFormat }, tt = u.type === "histogram2dcontour", xt = u.type === "contour", Ie = xt ? 1 : 0, xe = xt ? E - 1 : E, ke = xt ? 1 : 0, vt = xt ? T - 1 : T, ir = [];
+              for (z = Ie; z < xe; z++) {
+                var ar;
+                if (xt) ar = l.y[z];
+                else if (tt) {
+                  if (z === 0 || z === E - 1) continue;
+                  ar = l.y[z];
+                } else if (l.yCenter) ar = l.yCenter[z];
+                else {
+                  if (z + 1 === E && l.y[z + 1] === void 0) continue;
+                  ar = (l.y[z] + l.y[z + 1]) / 2;
+                }
+                var vr = Math.round(a.c2p(ar));
+                if (!(0 > vr || vr > a._length)) for (O = ke; O < vt; O++) {
+                  var ii;
+                  if (xt) ii = l.x[O];
+                  else if (tt) {
+                    if (O === 0 || O === T - 1) continue;
+                    ii = l.x[O];
+                  } else if (l.xCenter) ii = l.xCenter[O];
+                  else {
+                    if (O + 1 === T && l.x[O + 1] === void 0) continue;
+                    ii = (l.x[O] + l.x[O + 1]) / 2;
+                  }
+                  var pi = Math.round(i.c2p(ii));
+                  if (!(0 > pi || pi > i._length)) {
+                    var $r = Uxt({ x: ii, y: ar }, u, e._fullLayout);
+                    $r.x = ii, $r.y = ar;
+                    var di = l.z[z][O];
+                    di === void 0 ? ($r.z = "", $r.zLabel = "") : ($r.z = di, $r.zLabel = Nxt.tickText(We, di, "hover").text);
+                    var ji = l.text && l.text[z] && l.text[z][O];
+                    (ji === void 0 || ji === false) && (ji = ""), $r.text = ji;
+                    var In = W0.texttemplateString({ data: [$r, u._meta], fallback: u.texttemplatefallback, labels: $r, locale: e._fullLayout._d3locale, template: Ge });
+                    if (In) {
+                      var wi = In.split("<br>"), On = wi.length, qn = 0;
+                      for (U = 0; U < On; U++) qn = Math.max(qn, wi[U].length);
+                      ir.push({ l: On, c: qn, t: In, x: pi, y: vr, z: di });
+                    }
+                  }
+                }
+              }
+              var Fn = u.textfont, ra = Fn.size, la = e._fullLayout.font.size;
+              if (!ra || ra === "auto") {
+                var Ut = 1 / 0, wt = 1 / 0, rr = 0, nr = 0;
+                for (U = 0; U < ir.length; U++) {
+                  var Er = ir[U];
+                  if (rr = Math.max(rr, Er.l), nr = Math.max(nr, Er.c), U < ir.length - 1) {
+                    var Xr = ir[U + 1], ri = Math.abs(Xr.x - Er.x), Qr = Math.abs(Xr.y - Er.y);
+                    ri && (Ut = Math.min(Ut, ri)), Qr && (wt = Math.min(wt, Qr));
+                  }
+                }
+                !isFinite(Ut) || !isFinite(wt) ? ra = la : (Ut -= c, wt -= f, Ut /= nr, wt /= rr, Ut /= sG / 2, wt /= sG, ra = Math.min(Math.floor(Ut), Math.floor(wt), la));
+              }
+              if (ra <= 0 || !isFinite(ra)) return;
+              var Oi = function(fn) {
+                return fn.x;
+              }, $i = function(fn) {
+                return fn.y - ra * (fn.l * sG / 2 - 1);
+              }, tn = ixe(s).data(ir);
+              tn.enter().append("g").classed(rxe, 1).append("text").attr("text-anchor", "middle").each(function(fn) {
+                var yn = K_e.select(this), Sn = Fn.color;
+                (!Sn || Sn === "auto") && (Sn = Vxt.contrast(fn.z === void 0 ? e._fullLayout.plot_bgcolor : "rgba(" + ge(fn.z).join() + ")")), yn.attr("data-notex", 1).call(J_e.positionText, Oi(fn), $i(fn)).call(Bxt.font, { family: Fn.family, size: ra, color: Sn, weight: Fn.weight, style: Fn.style, variant: Fn.variant, textcase: Fn.textcase, lineposition: Fn.lineposition, shadow: Fn.shadow }).text(fn.t).call(J_e.convertToTspans, e);
+              });
+            }
+          });
+        };
+        function Q_e(e, t) {
+          var r = t.length - 2, n = W0.constrain(W0.findBin(e, t), 0, r), i = t[n], a = t[n + 1], o = W0.constrain(n + (e - i) / (a - i) - 0.5, 0, r), s = Math.round(o), l = Math.abs(o - s);
+          return !o || o === r || !l ? { bin0: s, bin1: s, frac: 0 } : { bin0: s, frac: l, bin1: Math.round(s + l / (o - s)) };
+        }
+        function exe(e, t) {
+          var r = t.length - 1, n = W0.constrain(W0.findBin(e, t), 0, r), i = t[n], a = t[n + 1], o = (e - i) / (a - i) || 0;
+          return o <= 0 ? { bin0: n, bin1: n, frac: 0 } : o < 0.5 ? { bin0: n, bin1: n + 1, frac: o } : { bin0: n + 1, bin1: n, frac: 1 - o };
+        }
+        function txe(e, t, r) {
+          e[t] = r[0], e[t + 1] = r[1], e[t + 2] = r[2], e[t + 3] = Math.round(r[3] * 255);
+        }
+      });
+      var D_ = ye((Yur, axe) => {
+        axe.exports = { min: "zmin", max: "zmax" };
+      });
+      var y8 = ye((Kur, oxe) => {
+        var Yxt = Oa();
+        oxe.exports = function(t) {
+          Yxt.select(t).selectAll(".hm image").style("opacity", function(r) {
+            return r.trace.opacity;
+          });
+        };
+      });
+      var x8 = ye((Jur, lxe) => {
+        var sxe = vf(), R4 = Dr(), _8 = R4.isArrayOrTypedArray, Kxt = ho(), Jxt = tc().extractOpts;
+        lxe.exports = function(t, r, n, i, a) {
+          a || (a = {});
+          var o = a.isContour, s = t.cd[0], l = s.trace, u = t.xa, c = t.ya, f = s.x, h = s.y, d = s.z, v = s.xCenter, _ = s.yCenter, b = s.zmask, p = l.zhoverformat, k = f, E = h, T, L, x, C;
+          if (t.index !== false) {
+            try {
+              x = Math.round(t.index[1]), C = Math.round(t.index[0]);
+            } catch (re) {
+              R4.error("Error hovering on heatmap, pointNumber must be [row,col], found:", t.index);
+              return;
+            }
+            if (x < 0 || x >= d[0].length || C < 0 || C > d.length) return;
+          } else {
+            if (sxe.inbox(r - f[0], r - f[f.length - 1], 0) > 0 || sxe.inbox(n - h[0], n - h[h.length - 1], 0) > 0) return;
+            if (o) {
+              var M;
+              for (k = [2 * f[0] - f[1]], M = 1; M < f.length; M++) k.push((f[M] + f[M - 1]) / 2);
+              for (k.push([2 * f[f.length - 1] - f[f.length - 2]]), E = [2 * h[0] - h[1]], M = 1; M < h.length; M++) E.push((h[M] + h[M - 1]) / 2);
+              E.push([2 * h[h.length - 1] - h[h.length - 2]]);
+            }
+            x = Math.max(0, Math.min(k.length - 2, R4.findBin(r, k))), C = Math.max(0, Math.min(E.length - 2, R4.findBin(n, E)));
+          }
+          var g = u.c2p(f[x]), P = u.c2p(f[x + 1]), A = c.c2p(h[C]), z = c.c2p(h[C + 1]), O, U;
+          o ? (O = s.orig_x || f, U = s.orig_y || h, P = g, T = O[x], z = A, L = U[C]) : (O = s.orig_x || v || f, U = s.orig_y || _ || h, T = v ? O[x] : (O[x] + O[x + 1]) / 2, L = _ ? U[C] : (U[C] + U[C + 1]) / 2, u && u.type === "category" && (T = f[x]), c && c.type === "category" && (L = h[C]), l.zsmooth && (g = P = u.c2p(T), A = z = c.c2p(L)));
+          var G = d[C][x];
+          if (b && !b[C][x] && (G = void 0), !(G === void 0 && !l.hoverongaps)) {
+            var Z;
+            _8(s.hovertext) && _8(s.hovertext[C]) ? Z = s.hovertext[C][x] : _8(s.text) && _8(s.text[C]) && (Z = s.text[C][x]);
+            var j = Jxt(l), N = { type: "linear", range: [j.min, j.max], hoverformat: p, _separators: u._separators, _numFormat: u._numFormat }, H = Kxt.tickText(N, G, "hover").text;
+            return [R4.extendFlat(t, { index: l._after2before ? l._after2before[C][x] : [C, x], distance: t.maxHoverDistance, spikeDistance: t.maxSpikeDistance, x0: g, x1: P, y0: A, y1: z, xLabelVal: T, yLabelVal: L, zLabelVal: G, zLabel: H, text: Z })];
+          }
+        };
+      });
+      var cxe = ye(($ur, uxe) => {
+        uxe.exports = { attributes: FT(), supplyDefaults: l_e(), calc: v8(), plot: m8(), colorbar: D_(), style: y8(), hoverPoints: x8(), moduleType: "trace", name: "heatmap", basePlotModule: mh(), categories: ["cartesian", "svg", "2dMap", "showLegend"], meta: {} };
+      });
+      var hxe = ye((Qur, fxe) => {
+        fxe.exports = cxe();
+      });
+      var lG = ye((ecr, dxe) => {
+        dxe.exports = function(t, r) {
+          return { start: { valType: "any", editType: "calc" }, end: { valType: "any", editType: "calc" }, size: { valType: "any", editType: "calc" }, editType: "calc" };
+        };
+      });
+      var pxe = ye((tcr, vxe) => {
+        vxe.exports = { eventDataKeys: ["binNumber"] };
+      });
+      var b8 = ye((rcr, _xe) => {
+        var Ip = zm(), gxe = df().axisHoverFormat, { hovertemplateAttrs: $xt, texttemplateAttrs: Qxt, templatefallbackAttrs: mxe } = Ll(), uG = ec(), yxe = lG(), ebt = pxe(), cG = Ao().extendFlat;
+        _xe.exports = { x: { valType: "data_array", editType: "calc+clearAxisTypes" }, y: { valType: "data_array", editType: "calc+clearAxisTypes" }, xhoverformat: gxe("x"), yhoverformat: gxe("y"), text: cG({}, Ip.text, {}), hovertext: cG({}, Ip.hovertext, {}), orientation: Ip.orientation, histfunc: { valType: "enumerated", values: ["count", "sum", "avg", "min", "max"], dflt: "count", editType: "calc" }, histnorm: { valType: "enumerated", values: ["", "percent", "probability", "density", "probability density"], dflt: "", editType: "calc" }, cumulative: { enabled: { valType: "boolean", dflt: false, editType: "calc" }, direction: { valType: "enumerated", values: ["increasing", "decreasing"], dflt: "increasing", editType: "calc" }, currentbin: { valType: "enumerated", values: ["include", "exclude", "half"], dflt: "include", editType: "calc" }, editType: "calc" }, nbinsx: { valType: "integer", min: 0, dflt: 0, editType: "calc" }, xbins: yxe("x", true), nbinsy: { valType: "integer", min: 0, dflt: 0, editType: "calc" }, ybins: yxe("y", true), autobinx: { valType: "boolean", dflt: null, editType: "calc" }, autobiny: { valType: "boolean", dflt: null, editType: "calc" }, bingroup: { valType: "string", dflt: "", editType: "calc" }, hovertemplate: $xt({}, { keys: ebt.eventDataKeys }), hovertemplatefallback: mxe(), texttemplate: Qxt({ arrayOk: false, editType: "plot" }, { keys: ["label", "value"] }), texttemplatefallback: mxe({ editType: "plot" }), textposition: cG({}, Ip.textposition, { arrayOk: false }), textfont: uG({ arrayOk: false, editType: "plot", colorEditType: "style" }), outsidetextfont: uG({ arrayOk: false, editType: "plot", colorEditType: "style" }), insidetextfont: uG({ arrayOk: false, editType: "plot", colorEditType: "style" }), insidetextanchor: Ip.insidetextanchor, textangle: Ip.textangle, cliponaxis: Ip.cliponaxis, constraintext: Ip.constraintext, marker: Ip.marker, offsetgroup: Ip.offsetgroup, alignmentgroup: Ip.alignmentgroup, selected: Ip.selected, unselected: Ip.unselected, zorder: Ip.zorder };
+      });
+      var Txe = ye((icr, wxe) => {
+        var xxe = qa(), D4 = Dr(), bxe = ka(), tbt = i0().handleText, rbt = WI(), ibt = b8();
+        wxe.exports = function(t, r, n, i) {
+          function a(k, E) {
+            return D4.coerce(t, r, ibt, k, E);
+          }
+          var o = a("x"), s = a("y"), l = a("cumulative.enabled");
+          l && (a("cumulative.direction"), a("cumulative.currentbin")), a("text");
+          var u = a("textposition");
+          tbt(t, r, i, a, u, { moduleHasSelected: true, moduleHasUnselected: true, moduleHasConstrain: true, moduleHasCliponaxis: true, moduleHasTextangle: true, moduleHasInsideanchor: true }), a("hovertext"), a("hovertemplate"), a("hovertemplatefallback"), a("xhoverformat"), a("yhoverformat");
+          var c = a("orientation", s && !o ? "h" : "v"), f = c === "v" ? "x" : "y", h = c === "v" ? "y" : "x", d = o && s ? Math.min(D4.minRowLength(o) && D4.minRowLength(s)) : D4.minRowLength(r[f] || []);
+          if (!d) {
+            r.visible = false;
+            return;
+          }
+          r._length = d;
+          var v = xxe.getComponentMethod("calendars", "handleTraceDefaults");
+          v(t, r, ["x", "y"], i);
+          var _ = r[h];
+          _ && a("histfunc"), a("histnorm"), a("autobin" + f), rbt(t, r, a, n, i), D4.coerceSelectionMarkerOpacity(r, a);
+          var b = (r.marker.line || {}).color, p = xxe.getComponentMethod("errorbars", "supplyDefaults");
+          p(t, r, b || bxe.defaultLine, { axis: "y" }), p(t, r, b || bxe.defaultLine, { axis: "x", inherit: "y" }), a("zorder");
+        };
+      });
+      var T8 = ye((ncr, Mxe) => {
+        var F4 = Dr(), nbt = hf(), w8 = qa().traceIs, abt = e2(), obt = i0().validateCornerradius, Axe = F4.nestedProperty, fG = Kb().getAxisGroup, Sxe = [{ aStr: { x: "xbins.start", y: "ybins.start" }, name: "start" }, { aStr: { x: "xbins.end", y: "ybins.end" }, name: "end" }, { aStr: { x: "xbins.size", y: "ybins.size" }, name: "size" }, { aStr: { x: "nbinsx", y: "nbinsy" }, name: "nbins" }], sbt = ["x", "y"];
+        Mxe.exports = function(t, r) {
+          var n = r._histogramBinOpts = {}, i = [], a = {}, o = [], s, l, u, c, f, h, d;
+          function v(G, Z) {
+            return F4.coerce(s._input, s, s._module.attributes, G, Z);
+          }
+          function _(G) {
+            return G.orientation === "v" ? "x" : "y";
+          }
+          function b(G, Z) {
+            var j = nbt.getFromTrace({ _fullLayout: r }, G, Z);
+            return j.type;
+          }
+          function p(G, Z, j) {
+            var N = G.uid + "__" + j;
+            Z || (Z = N);
+            var H = b(G, j), re = G[j + "calendar"] || "", oe = n[Z], _e = true;
+            oe && (H === oe.axType && re === oe.calendar ? (_e = false, oe.traces.push(G), oe.dirs.push(j)) : (Z = N, H !== oe.axType && F4.warn(["Attempted to group the bins of trace", G.index, "set on a", "type:" + H, "axis", "with bins on", "type:" + oe.axType, "axis."].join(" ")), re !== oe.calendar && F4.warn(["Attempted to group the bins of trace", G.index, "set with a", re, "calendar", "with bins", oe.calendar ? "on a " + oe.calendar + " calendar" : "w/o a set calendar"].join(" ")))), _e && (n[Z] = { traces: [G], dirs: [j], axType: H, calendar: G[j + "calendar"] || "" }), G["_" + j + "bingroup"] = Z;
+          }
+          for (f = 0; f < t.length; f++) if (s = t[f], w8(s, "histogram")) {
+            if (i.push(s), delete s._xautoBinFinished, delete s._yautoBinFinished, s.type === "histogram") {
+              var k = v("marker.cornerradius", r.barcornerradius);
+              s.marker && (s.marker.cornerradius = obt(k));
+            }
+            w8(s, "2dMap") || abt(s._input, s, r, v, r.barmode);
+          }
+          var E = r._alignmentOpts || {};
+          for (f = 0; f < i.length; f++) {
+            if (s = i[f], u = "", !w8(s, "2dMap")) {
+              if (c = _(s), r.barmode === "group" && s.alignmentgroup) {
+                var T = s[c + "axis"], L = fG(r, T) + s.orientation;
+                (E[L] || {})[s.alignmentgroup] && (u = L);
+              }
+              !u && r.barmode !== "overlay" && (u = fG(r, s.xaxis) + fG(r, s.yaxis) + _(s));
+            }
+            u ? (a[u] || (a[u] = []), a[u].push(s)) : o.push(s);
+          }
+          for (u in a) {
+            if (l = a[u], l.length === 1) {
+              o.push(l[0]);
+              continue;
+            }
+            var x = false;
+            for (l.length && (s = l[0], x = v("bingroup")), u = x || u, f = 0; f < l.length; f++) {
+              s = l[f];
+              var C = s._input.bingroup;
+              C && C !== u && F4.warn(["Trace", s.index, "must match", "within bingroup", u + ".", "Ignoring its bingroup:", C, "setting."].join(" ")), s.bingroup = u, p(s, u, _(s));
+            }
+          }
+          for (f = 0; f < o.length; f++) {
+            s = o[f];
+            var M = v("bingroup");
+            if (w8(s, "2dMap")) for (d = 0; d < 2; d++) {
+              c = sbt[d];
+              var g = v(c + "bingroup", M ? M + "__" + c : null);
+              p(s, g, c);
+            }
+            else p(s, M, _(s));
+          }
+          for (u in n) {
+            var P = n[u];
+            for (l = P.traces, h = 0; h < Sxe.length; h++) {
+              var A = Sxe[h], z = A.name, O, U;
+              if (!(z === "nbins" && P.sizeFound)) {
+                for (f = 0; f < l.length; f++) {
+                  if (s = l[f], c = P.dirs[f], O = A.aStr[c], Axe(s._input, O).get() !== void 0) {
+                    P[z] = v(O), P[z + "Found"] = true;
+                    break;
+                  }
+                  U = (s._autoBin || {})[c] || {}, U[z] && Axe(s, O).set(U[z]);
+                }
+                if (z === "start" || z === "end") for (; f < l.length; f++) s = l[f], s["_" + c + "bingroup"] && (U = (s._autoBin || {})[c] || {}, v(O, U[z]));
+                z === "nbins" && !P.sizeFound && !P.nbinsFound && (s = l[0], P[z] = v(O));
+              }
+            }
+          }
+        };
+      });
+      var kxe = ye((acr, Exe) => {
+        var lbt = PT().hoverPoints, ubt = ho().hoverLabelText;
+        Exe.exports = function(t, r, n, i, a) {
+          var o = lbt(t, r, n, i, a);
+          if (o) {
+            t = o[0];
+            var s = t.cd[t.index], l = t.cd[0].trace;
+            if (!l.cumulative.enabled) {
+              var u = l.orientation === "h" ? "y" : "x";
+              t[u + "Label"] = ubt(t[u + "a"], [s.ph0, s.ph1], l[u + "hoverformat"]);
+            }
+            return o;
+          }
+        };
+      });
+      var hG = ye((ocr, Cxe) => {
+        Cxe.exports = function(t, r, n, i, a) {
+          if (t.x = "xVal" in r ? r.xVal : r.x, t.y = "yVal" in r ? r.yVal : r.y, "zLabelVal" in r && (t.z = r.zLabelVal), r.xa && (t.xaxis = r.xa), r.ya && (t.yaxis = r.ya), !(n.cumulative || {}).enabled) {
+            var o = Array.isArray(a) ? i[0].pts[a[0]][a[1]] : i[a].pts;
+            t.pointNumbers = o, t.binNumber = t.pointNumber, delete t.pointNumber, delete t.pointIndex;
+            var s;
+            if (n._indexToPoints) {
+              s = [];
+              for (var l = 0; l < o.length; l++) s = s.concat(n._indexToPoints[o[l]]);
+            } else s = o;
+            t.pointIndices = s;
+          }
+          return t;
+        };
+      });
+      var Pxe = ye((scr, Lxe) => {
+        Lxe.exports = { attributes: b8(), layoutAttributes: jI(), supplyDefaults: Txe(), crossTraceDefaults: T8(), supplyLayoutDefaults: IV(), calc: tG().calc, crossTraceCalc: t2().crossTraceCalc, plot: d2().plot, layerName: "barlayer", style: V0().style, styleOnSelect: V0().styleOnSelect, colorbar: $d(), hoverPoints: kxe(), selectPoints: IT(), eventData: hG(), moduleType: "trace", name: "histogram", basePlotModule: mh(), categories: ["bar-like", "cartesian", "svg", "bar", "histogram", "oriented", "errorBarsOK", "showLegend"], meta: {} };
+      });
+      var Rxe = ye((lcr, Ixe) => {
+        Ixe.exports = Pxe();
+      });
+      var S8 = ye((ucr, zxe) => {
+        var jg = b8(), Dxe = lG(), A8 = FT(), cbt = Gl(), dG = df().axisHoverFormat, { hovertemplateAttrs: fbt, texttemplateAttrs: hbt, templatefallbackAttrs: Fxe } = Ll(), dbt = Tu(), z4 = Ao().extendFlat;
+        zxe.exports = z4({ x: jg.x, y: jg.y, z: { valType: "data_array", editType: "calc" }, marker: { color: { valType: "data_array", editType: "calc" }, editType: "calc" }, histnorm: jg.histnorm, histfunc: jg.histfunc, nbinsx: jg.nbinsx, xbins: Dxe("x"), nbinsy: jg.nbinsy, ybins: Dxe("y"), autobinx: jg.autobinx, autobiny: jg.autobiny, bingroup: z4({}, jg.bingroup, {}), xbingroup: z4({}, jg.bingroup, {}), ybingroup: z4({}, jg.bingroup, {}), xgap: A8.xgap, ygap: A8.ygap, zsmooth: A8.zsmooth, xhoverformat: dG("x"), yhoverformat: dG("y"), zhoverformat: dG("z", 1), hovertemplate: fbt({}, { keys: ["z"] }), hovertemplatefallback: Fxe(), texttemplate: hbt({ arrayOk: false, editType: "plot" }, { keys: ["z"] }), texttemplatefallback: Fxe({ editType: "plot" }), textfont: A8.textfont, showlegend: z4({}, cbt.showlegend, { dflt: false }) }, dbt("", { cLetter: "z", autoColorDflt: false }));
+      });
+      var vG = ye((ccr, qxe) => {
+        var vbt = qa(), Oxe = Dr();
+        qxe.exports = function(t, r, n, i) {
+          var a = n("x"), o = n("y"), s = Oxe.minRowLength(a), l = Oxe.minRowLength(o);
+          if (!s || !l) {
+            r.visible = false;
+            return;
+          }
+          r._length = Math.min(s, l);
+          var u = vbt.getComponentMethod("calendars", "handleTraceDefaults");
+          u(t, r, ["x", "y"], i);
+          var c = n("z") || n("marker.color");
+          c && n("histfunc"), n("histnorm"), n("autobinx"), n("autobiny");
+        };
+      });
+      var Nxe = ye((fcr, Bxe) => {
+        var pbt = Dr(), gbt = vG(), mbt = ZV(), ybt = td(), _bt = I4(), xbt = S8();
+        Bxe.exports = function(t, r, n, i) {
+          function a(o, s) {
+            return pbt.coerce(t, r, xbt, o, s);
+          }
+          gbt(t, r, a, i), r.visible !== false && (mbt(t, r, a, i), ybt(t, r, i, a, { prefix: "", cLetter: "z" }), a("hovertemplate"), a("hovertemplatefallback"), _bt(a, i), a("xhoverformat"), a("yhoverformat"));
+        };
+      });
+      var Gxe = ye((hcr, Vxe) => {
+        var bbt = x8(), Uxe = ho().hoverLabelText;
+        Vxe.exports = function(t, r, n, i, a) {
+          var o = bbt(t, r, n, i, a);
+          if (o) {
+            t = o[0];
+            var s = t.index, l = s[0], u = s[1], c = t.cd[0], f = c.trace, h = c.xRanges[u], d = c.yRanges[l];
+            return t.xLabel = Uxe(t.xa, [h[0], h[1]], f.xhoverformat), t.yLabel = Uxe(t.ya, [d[0], d[1]], f.yhoverformat), o;
+          }
+        };
+      });
+      var jxe = ye((dcr, Hxe) => {
+        Hxe.exports = { attributes: S8(), supplyDefaults: Nxe(), crossTraceDefaults: T8(), calc: v8(), plot: m8(), layerName: "heatmaplayer", colorbar: D_(), style: y8(), hoverPoints: Gxe(), eventData: hG(), moduleType: "trace", name: "histogram2d", basePlotModule: mh(), categories: ["cartesian", "svg", "2dMap", "histogram", "showLegend"], meta: {} };
+      });
+      var Xxe = ye((vcr, Wxe) => {
+        Wxe.exports = jxe();
+      });
+      var M8 = ye((pcr, Zxe) => {
+        Zxe.exports = { COMPARISON_OPS: ["=", "!=", "<", ">=", ">", "<="], COMPARISON_OPS2: ["=", "<", ">=", ">", "<="], INTERVAL_OPS: ["[]", "()", "[)", "(]", "][", ")(", "](", ")["], SET_OPS: ["{}", "}{"], CONSTRAINT_REDUCTION: { "=": "=", "<": "<", "<=": "<", ">": ">", ">=": ">", "[]": "[]", "()": "[]", "[)": "[]", "(]": "[]", "][": "][", ")(": "][", "](": "][", ")[": "][" } };
+      });
+      var O4 = ye((gcr, $xe) => {
+        var _h = FT(), E8 = pf(), Kxe = df(), pG = Kxe.axisHoverFormat, wbt = Kxe.descriptionOnlyNumbers, Tbt = Tu(), Abt = Pd().dash, Sbt = ec(), NT = Ao().extendFlat, Jxe = M8(), Mbt = Jxe.COMPARISON_OPS2, Ebt = Jxe.INTERVAL_OPS, Yxe = E8.line;
+        $xe.exports = NT({ z: _h.z, x: _h.x, x0: _h.x0, dx: _h.dx, y: _h.y, y0: _h.y0, dy: _h.dy, xperiod: _h.xperiod, yperiod: _h.yperiod, xperiod0: E8.xperiod0, yperiod0: E8.yperiod0, xperiodalignment: _h.xperiodalignment, yperiodalignment: _h.yperiodalignment, text: _h.text, hovertext: _h.hovertext, transpose: _h.transpose, xtype: _h.xtype, ytype: _h.ytype, xhoverformat: pG("x"), yhoverformat: pG("y"), zhoverformat: pG("z", 1), hovertemplate: _h.hovertemplate, hovertemplatefallback: _h.hovertemplatefallback, texttemplate: NT({}, _h.texttemplate, {}), texttemplatefallback: _h.texttemplatefallback, textfont: NT({}, _h.textfont, {}), hoverongaps: _h.hoverongaps, connectgaps: NT({}, _h.connectgaps, {}), fillcolor: { valType: "color", editType: "calc" }, autocontour: { valType: "boolean", dflt: true, editType: "calc", impliedEdits: { "contours.start": void 0, "contours.end": void 0, "contours.size": void 0 } }, ncontours: { valType: "integer", dflt: 15, min: 1, editType: "calc" }, contours: { type: { valType: "enumerated", values: ["levels", "constraint"], dflt: "levels", editType: "calc" }, start: { valType: "number", dflt: null, editType: "plot", impliedEdits: { "^autocontour": false } }, end: { valType: "number", dflt: null, editType: "plot", impliedEdits: { "^autocontour": false } }, size: { valType: "number", dflt: null, min: 0, editType: "plot", impliedEdits: { "^autocontour": false } }, coloring: { valType: "enumerated", values: ["fill", "heatmap", "lines", "none"], dflt: "fill", editType: "calc" }, showlines: { valType: "boolean", dflt: true, editType: "plot" }, showlabels: { valType: "boolean", dflt: false, editType: "plot" }, labelfont: Sbt({ editType: "plot", colorEditType: "style" }), labelformat: { valType: "string", dflt: "", editType: "plot", description: wbt("contour label") }, operation: { valType: "enumerated", values: [].concat(Mbt).concat(Ebt), dflt: "=", editType: "calc" }, value: { valType: "any", dflt: 0, editType: "calc" }, editType: "calc", impliedEdits: { autocontour: false } }, line: { color: NT({}, Yxe.color, { editType: "style+colorbars" }), width: { valType: "number", min: 0, editType: "style+colorbars" }, dash: Abt, smoothing: NT({}, Yxe.smoothing, {}), editType: "plot" }, zorder: E8.zorder }, Tbt("", { cLetter: "z", autoColorDflt: false, editTypeOverride: "calc" }));
+      });
+      var mG = ye((mcr, ebe) => {
+        var wv = S8(), Bm = O4(), kbt = Tu(), gG = df().axisHoverFormat, Qxe = Ao().extendFlat;
+        ebe.exports = Qxe({ x: wv.x, y: wv.y, z: wv.z, marker: wv.marker, histnorm: wv.histnorm, histfunc: wv.histfunc, nbinsx: wv.nbinsx, xbins: wv.xbins, nbinsy: wv.nbinsy, ybins: wv.ybins, autobinx: wv.autobinx, autobiny: wv.autobiny, bingroup: wv.bingroup, xbingroup: wv.xbingroup, ybingroup: wv.ybingroup, autocontour: Bm.autocontour, ncontours: Bm.ncontours, contours: Bm.contours, line: { color: Bm.line.color, width: Qxe({}, Bm.line.width, { dflt: 0.5 }), dash: Bm.line.dash, smoothing: Bm.line.smoothing, editType: "plot" }, xhoverformat: gG("x"), yhoverformat: gG("y"), zhoverformat: gG("z", 1), hovertemplate: wv.hovertemplate, hovertemplatefallback: wv.hovertemplatefallback, texttemplate: Bm.texttemplate, texttemplatefallback: Bm.texttemplatefallback, textfont: Bm.textfont }, kbt("", { cLetter: "z", editTypeOverride: "calc" }));
+      });
+      var k8 = ye((ycr, tbe) => {
+        tbe.exports = function(t, r, n, i) {
+          var a = i("contours.start"), o = i("contours.end"), s = a === false || o === false, l = n("contours.size"), u;
+          s ? u = r.autocontour = true : u = n("autocontour", false), (u || !l) && n("ncontours");
+        };
+      });
+      var yG = ye((_cr, rbe) => {
+        var Cbt = Dr();
+        rbe.exports = function(t, r, n, i) {
+          i || (i = {});
+          var a = t("contours.showlabels");
+          if (a) {
+            var o = r.font;
+            Cbt.coerceFont(t, "contours.labelfont", o, { overrideDflt: { color: n } }), t("contours.labelformat");
+          }
+          i.hasHover !== false && t("zhoverformat");
+        };
+      });
+      var C8 = ye((xcr, ibe) => {
+        var Lbt = td(), Pbt = yG();
+        ibe.exports = function(t, r, n, i, a) {
+          var o = n("contours.coloring"), s, l = "";
+          o === "fill" && (s = n("contours.showlines")), s !== false && (o !== "lines" && (l = n("line.color", "#000")), n("line.width", 0.5), n("line.dash")), o !== "none" && (t.showlegend !== true && (r.showlegend = false), r._dfltShowLegend = false, Lbt(t, r, i, n, { prefix: "", cLetter: "z" })), n("line.smoothing"), Pbt(n, i, l, a);
+        };
+      });
+      var sbe = ye((bcr, obe) => {
+        var nbe = Dr(), Ibt = vG(), Rbt = k8(), Dbt = C8(), Fbt = I4(), abe = mG();
+        obe.exports = function(t, r, n, i) {
+          function a(s, l) {
+            return nbe.coerce(t, r, abe, s, l);
+          }
+          function o(s) {
+            return nbe.coerce2(t, r, abe, s);
+          }
+          Ibt(t, r, a, i), r.visible !== false && (Rbt(t, r, a, o), Dbt(t, r, a, i), a("xhoverformat"), a("yhoverformat"), a("hovertemplate"), a("hovertemplatefallback"), r.contours && r.contours.coloring === "heatmap" && Fbt(a, i));
+        };
+      });
+      var bG = ye((wcr, ube) => {
+        var xG = ho(), _G = Dr();
+        ube.exports = function(t, r) {
+          var n = t.contours;
+          if (t.autocontour) {
+            var i = t.zmin, a = t.zmax;
+            (t.zauto || i === void 0) && (i = _G.aggNums(Math.min, null, r)), (t.zauto || a === void 0) && (a = _G.aggNums(Math.max, null, r));
+            var o = lbe(i, a, t.ncontours);
+            n.size = o.dtick, n.start = xG.tickFirst(o), o.range.reverse(), n.end = xG.tickFirst(o), n.start === i && (n.start += n.size), n.end === a && (n.end -= n.size), n.start > n.end && (n.start = n.end = (n.start + n.end) / 2), t._input.contours || (t._input.contours = {}), _G.extendFlat(t._input.contours, { start: n.start, end: n.end, size: n.size }), t._input.autocontour = true;
+          } else if (n.type !== "constraint") {
+            var s = n.start, l = n.end, u = t._input.contours;
+            if (s > l && (n.start = u.start = l, l = n.end = u.end = s, s = n.start), !(n.size > 0)) {
+              var c;
+              s === l ? c = 1 : c = lbe(s, l, t.ncontours).dtick, u.size = n.size = c;
+            }
+          }
+        };
+        function lbe(e, t, r) {
+          var n = { type: "linear", range: [e, t] };
+          return xG.autoTicks(n, (t - e) / (r || 15)), n;
+        }
+      });
+      var q4 = ye((Tcr, cbe) => {
+        cbe.exports = function(t) {
+          return t.end + t.size / 1e6;
+        };
+      });
+      var wG = ye((Acr, hbe) => {
+        var fbe = tc(), zbt = v8(), Obt = bG(), qbt = q4();
+        hbe.exports = function(t, r) {
+          var n = zbt(t, r), i = n[0].z;
+          Obt(r, i);
+          var a = r.contours, o = fbe.extractOpts(r), s;
+          if (a.coloring === "heatmap" && o.auto && r.autocontour === false) {
+            var l = a.start, u = qbt(a), c = a.size || 1, f = Math.floor((u - l) / c) + 1;
+            isFinite(c) || (c = 1, f = 1);
+            var h = l - c / 2, d = h + f * c;
+            s = [h, d];
+          } else s = i;
+          return fbe.calc(t, r, { vals: s, cLetter: "z" }), n;
+        };
+      });
+      var B4 = ye((Scr, dbe) => {
+        dbe.exports = { BOTTOMSTART: [1, 9, 13, 104, 713], TOPSTART: [4, 6, 7, 104, 713], LEFTSTART: [8, 12, 14, 208, 1114], RIGHTSTART: [2, 3, 11, 208, 1114], NEWDELTA: [null, [-1, 0], [0, -1], [-1, 0], [1, 0], null, [0, -1], [-1, 0], [0, 1], [0, 1], null, [0, 1], [1, 0], [1, 0], [0, -1]], CHOOSESADDLE: { 104: [4, 1], 208: [2, 8], 713: [7, 13], 1114: [11, 14] }, SADDLEREMAINDER: { 1: 4, 2: 8, 4: 1, 7: 13, 8: 2, 11: 14, 13: 7, 14: 11 }, LABELDISTANCE: 2, LABELINCREASE: 10, LABELMIN: 3, LABELMAX: 10, LABELOPTIMIZER: { EDGECOST: 1, ANGLECOST: 1, NEIGHBORCOST: 5, SAMELEVELFACTOR: 10, SAMELEVELDISTANCE: 5, MAXCOST: 100, INITIALSEARCHPOINTS: 10, ITERATIONS: 5 } };
+      });
+      var TG = ye((Mcr, vbe) => {
+        var L8 = B4();
+        vbe.exports = function(t) {
+          var r = t[0].z, n = r.length, i = r[0].length, a = n === 2 || i === 2, o, s, l, u, c, f, h, d, v;
+          for (s = 0; s < n - 1; s++) for (u = [], s === 0 && (u = u.concat(L8.BOTTOMSTART)), s === n - 2 && (u = u.concat(L8.TOPSTART)), o = 0; o < i - 1; o++) for (l = u.slice(), o === 0 && (l = l.concat(L8.LEFTSTART)), o === i - 2 && (l = l.concat(L8.RIGHTSTART)), c = o + "," + s, f = [[r[s][o], r[s][o + 1]], [r[s + 1][o], r[s + 1][o + 1]]], v = 0; v < t.length; v++) d = t[v], h = Bbt(d.level, f), h && (d.crossings[c] = h, l.indexOf(h) !== -1 && (d.starts.push([o, s]), a && l.indexOf(h, l.indexOf(h) + 1) !== -1 && d.starts.push([o, s])));
+        };
+        function Bbt(e, t) {
+          var r = (t[0][0] > e ? 0 : 1) + (t[0][1] > e ? 0 : 2) + (t[1][1] > e ? 0 : 4) + (t[1][0] > e ? 0 : 8);
+          if (r === 5 || r === 10) {
+            var n = (t[0][0] + t[0][1] + t[1][0] + t[1][1]) / 4;
+            return e > n ? r === 5 ? 713 : 1114 : r === 5 ? 104 : 208;
+          }
+          return r === 15 ? 0 : r;
+        }
+      });
+      var AG = ye((Ecr, mbe) => {
+        var P8 = Dr(), UT = B4();
+        mbe.exports = function(t, r, n) {
+          var i, a, o, s, l;
+          for (r = r || 0.01, n = n || 0.01, o = 0; o < t.length; o++) {
+            for (s = t[o], l = 0; l < s.starts.length; l++) a = s.starts[l], pbe(s, a, "edge", r, n);
+            for (i = 0; Object.keys(s.crossings).length && i < 1e4; ) i++, a = Object.keys(s.crossings)[0].split(",").map(Number), pbe(s, a, void 0, r, n);
+            i === 1e4 && P8.log("Infinite loop in contour?");
+          }
+        };
+        function N4(e, t, r, n) {
+          return Math.abs(e[0] - t[0]) < r && Math.abs(e[1] - t[1]) < n;
+        }
+        function Nbt(e, t) {
+          var r = e[2] - t[2], n = e[3] - t[3];
+          return Math.sqrt(r * r + n * n);
+        }
+        function pbe(e, t, r, n, i) {
+          var a = t.join(","), o = e.crossings[a], s = Ubt(o, r, t), l = [gbe(e, t, [-s[0], -s[1]])], u = e.z.length, c = e.z[0].length, f = t.slice(), h = s.slice(), d;
+          for (d = 0; d < 1e4; d++) {
+            if (o > 20 ? (o = UT.CHOOSESADDLE[o][(s[0] || s[1]) < 0 ? 0 : 1], e.crossings[a] = UT.SADDLEREMAINDER[o]) : delete e.crossings[a], s = UT.NEWDELTA[o], !s) {
+              P8.log("Found bad marching index:", o, t, e.level);
+              break;
+            }
+            l.push(gbe(e, t, s)), t[0] += s[0], t[1] += s[1], a = t.join(","), N4(l[l.length - 1], l[l.length - 2], n, i) && l.pop();
+            var v = s[0] && (t[0] < 0 || t[0] > c - 2) || s[1] && (t[1] < 0 || t[1] > u - 2), _ = t[0] === f[0] && t[1] === f[1] && s[0] === h[0] && s[1] === h[1];
+            if (_ || r && v) break;
+            o = e.crossings[a];
+          }
+          d === 1e4 && P8.log("Infinite loop in contour?");
+          var b = N4(l[0], l[l.length - 1], n, i), p = 0, k = 0.2 * e.smoothing, E = [], T = 0, L, x, C, M, g, P, A, z, O, U, G;
+          for (d = 1; d < l.length; d++) A = Nbt(l[d], l[d - 1]), p += A, E.push(A);
+          var Z = p / E.length * k;
+          function j(re) {
+            return l[re % l.length];
+          }
+          for (d = l.length - 2; d >= T; d--) if (L = E[d], L < Z) {
+            for (C = 0, x = d - 1; x >= T && L + E[x] < Z; x--) L += E[x];
+            if (b && d === l.length - 2) for (C = 0; C < x && L + E[C] < Z; C++) L += E[C];
+            g = d - x + C + 1, P = Math.floor((d + x + C + 2) / 2), !b && d === l.length - 2 ? M = l[l.length - 1] : !b && x === -1 ? M = l[0] : g % 2 ? M = j(P) : M = [(j(P)[0] + j(P + 1)[0]) / 2, (j(P)[1] + j(P + 1)[1]) / 2], l.splice(x + 1, d - x + 1, M), d = x + 1, C && (T = C), b && (d === l.length - 2 ? l[C] = l[l.length - 1] : d === 0 && (l[l.length - 1] = l[0]));
+          }
+          for (l.splice(0, T), d = 0; d < l.length; d++) l[d].length = 2;
+          if (!(l.length < 2)) if (b) l.pop(), e.paths.push(l);
+          else {
+            r || P8.log("Unclosed interior contour?", e.level, f.join(","), l.join("L"));
+            var N = false;
+            for (z = 0; z < e.edgepaths.length; z++) if (U = e.edgepaths[z], !N && N4(U[0], l[l.length - 1], n, i)) {
+              l.pop(), N = true;
+              var H = false;
+              for (O = 0; O < e.edgepaths.length; O++) if (G = e.edgepaths[O], N4(G[G.length - 1], l[0], n, i)) {
+                H = true, l.shift(), e.edgepaths.splice(z, 1), O === z ? e.paths.push(l.concat(G)) : (O > z && O--, e.edgepaths[O] = G.concat(l, U));
+                break;
+              }
+              H || (e.edgepaths[z] = l.concat(U));
+            }
+            for (z = 0; z < e.edgepaths.length && !N; z++) U = e.edgepaths[z], N4(U[U.length - 1], l[0], n, i) && (l.shift(), e.edgepaths[z] = U.concat(l), N = true);
+            N || e.edgepaths.push(l);
+          }
+        }
+        function Ubt(e, t, r) {
+          var n = 0, i = 0;
+          return e > 20 && t ? e === 208 || e === 1114 ? n = r[0] === 0 ? 1 : -1 : i = r[1] === 0 ? 1 : -1 : UT.BOTTOMSTART.indexOf(e) !== -1 ? i = 1 : UT.LEFTSTART.indexOf(e) !== -1 ? n = 1 : UT.TOPSTART.indexOf(e) !== -1 ? i = -1 : n = -1, [n, i];
+        }
+        function gbe(e, t, r) {
+          var n = t[0] + Math.max(r[0], 0), i = t[1] + Math.max(r[1], 0), a = e.z[i][n], o = e.xaxis, s = e.yaxis;
+          if (r[1]) {
+            var l = (e.level - a) / (e.z[i][n + 1] - a), u = (l !== 1 ? (1 - l) * o.c2l(e.x[n]) : 0) + (l !== 0 ? l * o.c2l(e.x[n + 1]) : 0);
+            return [o.c2p(o.l2c(u), true), s.c2p(e.y[i], true), n + l, i];
+          } else {
+            var c = (e.level - a) / (e.z[i + 1][n] - a), f = (c !== 1 ? (1 - c) * s.c2l(e.y[i]) : 0) + (c !== 0 ? c * s.c2l(e.y[i + 1]) : 0);
+            return [o.c2p(e.x[n], true), s.c2p(s.l2c(f), true), n, i + c];
+          }
+        }
+      });
+      var bbe = ye((kcr, xbe) => {
+        var SG = M8(), Vbt = Eo();
+        xbe.exports = { "[]": ybe("[]"), "][": ybe("]["), ">": MG(">"), "<": MG("<"), "=": MG("=") };
+        function _be(e, t) {
+          var r = Array.isArray(t), n;
+          function i(a) {
+            return Vbt(a) ? +a : null;
+          }
+          return SG.COMPARISON_OPS2.indexOf(e) !== -1 ? n = i(r ? t[0] : t) : SG.INTERVAL_OPS.indexOf(e) !== -1 ? n = r ? [i(t[0]), i(t[1])] : [i(t), i(t)] : SG.SET_OPS.indexOf(e) !== -1 && (n = r ? t.map(i) : [i(t)]), n;
+        }
+        function ybe(e) {
+          return function(t) {
+            t = _be(e, t);
+            var r = Math.min(t[0], t[1]), n = Math.max(t[0], t[1]);
+            return { start: r, end: n, size: n - r };
+          };
+        }
+        function MG(e) {
+          return function(t) {
+            return t = _be(e, t), { start: t, end: 1 / 0, size: 1 / 0 };
+          };
+        }
+      });
+      var EG = ye((Ccr, Tbe) => {
+        var wbe = Dr(), Gbt = bbe(), Hbt = q4();
+        Tbe.exports = function(t, r, n) {
+          for (var i = t.type === "constraint" ? Gbt[t._operation](t.value) : t, a = i.size, o = [], s = Hbt(i), l = n.trace._carpetTrace, u = l ? { xaxis: l.aaxis, yaxis: l.baxis, x: n.a, y: n.b } : { xaxis: r.xaxis, yaxis: r.yaxis, x: n.x, y: n.y }, c = i.start; c < s; c += a) if (o.push(wbe.extendFlat({ level: c, crossings: {}, starts: [], edgepaths: [], paths: [], z: n.z, smoothing: n.trace.line.smoothing }, u)), o.length > 1e3) {
+            wbe.warn("Too many contours, clipping at 1000", t);
+            break;
+          }
+          return o;
+        };
+      });
+      var kG = ye((Lcr, Sbe) => {
+        var VT = Dr();
+        Sbe.exports = function(e, t) {
+          var r, n, i, a = function(l) {
+            return l.reverse();
+          }, o = function(l) {
+            return l;
+          };
+          switch (t) {
+            case "=":
+            case "<":
+              return e;
+            case ">":
+              for (e.length !== 1 && VT.warn("Contour data invalid for the specified inequality operation."), n = e[0], r = 0; r < n.edgepaths.length; r++) n.edgepaths[r] = a(n.edgepaths[r]);
+              for (r = 0; r < n.paths.length; r++) n.paths[r] = a(n.paths[r]);
+              for (r = 0; r < n.starts.length; r++) n.starts[r] = a(n.starts[r]);
+              return e;
+            case "][":
+              var s = a;
+              a = o, o = s;
+            case "[]":
+              for (e.length !== 2 && VT.warn("Contour data invalid for the specified inequality range operation."), n = Abe(e[0]), i = Abe(e[1]), r = 0; r < n.edgepaths.length; r++) n.edgepaths[r] = a(n.edgepaths[r]);
+              for (r = 0; r < n.paths.length; r++) n.paths[r] = a(n.paths[r]);
+              for (r = 0; r < n.starts.length; r++) n.starts[r] = a(n.starts[r]);
+              for (; i.edgepaths.length; ) n.edgepaths.push(o(i.edgepaths.shift()));
+              for (; i.paths.length; ) n.paths.push(o(i.paths.shift()));
+              for (; i.starts.length; ) n.starts.push(o(i.starts.shift()));
+              return [n];
+          }
+        };
+        function Abe(e) {
+          return VT.extendFlat({}, e, { edgepaths: VT.extendDeep([], e.edgepaths), paths: VT.extendDeep([], e.paths), starts: VT.extendDeep([], e.starts) });
+        }
+      });
+      var CG = ye((Pcr, Mbe) => {
+        Mbe.exports = function(e, t) {
+          var r = e[0], n = r.z, i;
+          switch (t.type) {
+            case "levels":
+              var a = Math.min(n[0][0], n[0][1]);
+              for (i = 0; i < e.length; i++) {
+                var o = e[i];
+                o.prefixBoundary = !o.edgepaths.length && (a > o.level || o.starts.length && a === o.level);
+              }
+              break;
+            case "constraint":
+              if (r.prefixBoundary = false, r.edgepaths.length) return;
+              var s = r.x.length, l = r.y.length, u = -1 / 0, c = 1 / 0;
+              for (i = 0; i < l; i++) c = Math.min(c, n[i][0]), c = Math.min(c, n[i][s - 1]), u = Math.max(u, n[i][0]), u = Math.max(u, n[i][s - 1]);
+              for (i = 1; i < s - 1; i++) c = Math.min(c, n[0][i]), c = Math.min(c, n[l - 1][i]), u = Math.max(u, n[0][i]), u = Math.max(u, n[l - 1][i]);
+              var f = t.value, h, d;
+              switch (t._operation) {
+                case ">":
+                  f > u && (r.prefixBoundary = true);
+                  break;
+                case "<":
+                  (f < c || r.starts.length && f === c) && (r.prefixBoundary = true);
+                  break;
+                case "[]":
+                  h = Math.min(f[0], f[1]), d = Math.max(f[0], f[1]), (d < c || h > u || r.starts.length && d === c) && (r.prefixBoundary = true);
+                  break;
+                case "][":
+                  h = Math.min(f[0], f[1]), d = Math.max(f[0], f[1]), h < c && d > u && (r.prefixBoundary = true);
+                  break;
+              }
+              break;
+          }
+        };
+      });
+      var I8 = ye((jv) => {
+        var V4 = Oa(), Fd = Dr(), jy = So(), jbt = tc(), Cbe = Zl(), Ebe = ho(), kbe = xm(), Wbt = m8(), Lbe = TG(), Pbe = AG(), Xbt = EG(), Zbt = kG(), Ibe = CG(), U4 = B4(), Nm = U4.LABELOPTIMIZER;
+        jv.plot = function(t, r, n, i) {
+          var a = r.xaxis, o = r.yaxis;
+          Fd.makeTraceGroups(i, n, "contour").each(function(s) {
+            var l = V4.select(this), u = s[0], c = u.trace, f = u.x, h = u.y, d = c.contours, v = Xbt(d, r, u), _ = Fd.ensureSingle(l, "g", "heatmapcoloring"), b = [];
+            d.coloring === "heatmap" && (b = [s]), Wbt(t, r, b, _), Lbe(v), Pbe(v);
+            var p = a.c2p(f[0], true), k = a.c2p(f[f.length - 1], true), E = o.c2p(h[0], true), T = o.c2p(h[h.length - 1], true), L = [[p, T], [k, T], [k, E], [p, E]], x = v;
+            d.type === "constraint" && (x = Zbt(v, d._operation)), Ybt(l, L, d), Kbt(l, x, L, d), Jbt(l, v, t, u, d), Qbt(l, r, t, u, L);
+          });
+        };
+        function Ybt(e, t, r) {
+          var n = Fd.ensureSingle(e, "g", "contourbg"), i = n.selectAll("path").data(r.coloring === "fill" ? [0] : []);
+          i.enter().append("path"), i.exit().remove(), i.attr("d", "M" + t.join("L") + "Z").style("stroke", "none");
+        }
+        function Kbt(e, t, r, n) {
+          var i = n.coloring === "fill" || n.type === "constraint" && n._operation !== "=", a = "M" + r.join("L") + "Z";
+          i && Ibe(t, n);
+          var o = Fd.ensureSingle(e, "g", "contourfill"), s = o.selectAll("path").data(i ? t : []);
+          s.enter().append("path"), s.exit().remove(), s.each(function(l) {
+            var u = (l.prefixBoundary ? a : "") + Rbe(l, r);
+            u ? V4.select(this).attr("d", u).style("stroke", "none") : V4.select(this).remove();
+          });
+        }
+        function Rbe(e, t) {
+          var r = "", n = 0, i = e.edgepaths.map(function(p, k) {
+            return k;
+          }), a = true, o, s, l, u, c, f;
+          function h(p) {
+            return Math.abs(p[1] - t[0][1]) < 0.01;
+          }
+          function d(p) {
+            return Math.abs(p[1] - t[2][1]) < 0.01;
+          }
+          function v(p) {
+            return Math.abs(p[0] - t[0][0]) < 0.01;
+          }
+          function _(p) {
+            return Math.abs(p[0] - t[2][0]) < 0.01;
+          }
+          for (; i.length; ) {
+            for (f = jy.smoothopen(e.edgepaths[n], e.smoothing), r += a ? f : f.replace(/^M/, "L"), i.splice(i.indexOf(n), 1), o = e.edgepaths[n][e.edgepaths[n].length - 1], u = -1, l = 0; l < 4; l++) {
+              if (!o) {
+                Fd.log("Missing end?", n, e);
+                break;
+              }
+              for (h(o) && !_(o) ? s = t[1] : v(o) ? s = t[0] : d(o) ? s = t[3] : _(o) && (s = t[2]), c = 0; c < e.edgepaths.length; c++) {
+                var b = e.edgepaths[c][0];
+                Math.abs(o[0] - s[0]) < 0.01 ? Math.abs(o[0] - b[0]) < 0.01 && (b[1] - o[1]) * (s[1] - b[1]) >= 0 && (s = b, u = c) : Math.abs(o[1] - s[1]) < 0.01 ? Math.abs(o[1] - b[1]) < 0.01 && (b[0] - o[0]) * (s[0] - b[0]) >= 0 && (s = b, u = c) : Fd.log("endpt to newendpt is not vert. or horz.", o, s, b);
+              }
+              if (o = s, u >= 0) break;
+              r += "L" + s;
+            }
+            if (u === e.edgepaths.length) {
+              Fd.log("unclosed perimeter path");
+              break;
+            }
+            n = u, a = i.indexOf(n) === -1, a && (n = i[0], r += "Z");
+          }
+          for (n = 0; n < e.paths.length; n++) r += jy.smoothclosed(e.paths[n], e.smoothing);
+          return r;
+        }
+        function Jbt(e, t, r, n, i) {
+          var a = r._context.staticPlot, o = Fd.ensureSingle(e, "g", "contourlines"), s = i.showlines !== false, l = i.showlabels, u = s && l, c = jv.createLines(o, s || l, t, a), f = jv.createLineClip(o, u, r, n.trace.uid), h = e.selectAll("g.contourlabels").data(l ? [0] : []);
+          if (h.exit().remove(), h.enter().append("g").classed("contourlabels", true), l) {
+            var d = [], v = [];
+            Fd.clearLocationCache();
+            var _ = jv.labelFormatter(r, n), b = jy.tester.append("text").attr("data-notex", 1).call(jy.font, i.labelfont), p = t[0].xaxis, k = t[0].yaxis, E = p._length, T = k._length, L = p.range, x = k.range, C = Fd.aggNums(Math.min, null, n.x), M = Fd.aggNums(Math.max, null, n.x), g = Fd.aggNums(Math.min, null, n.y), P = Fd.aggNums(Math.max, null, n.y), A = Math.max(p.c2p(C, true), 0), z = Math.min(p.c2p(M, true), E), O = Math.max(k.c2p(P, true), 0), U = Math.min(k.c2p(g, true), T), G = {};
+            L[0] < L[1] ? (G.left = A, G.right = z) : (G.left = z, G.right = A), x[0] < x[1] ? (G.top = O, G.bottom = U) : (G.top = U, G.bottom = O), G.middle = (G.top + G.bottom) / 2, G.center = (G.left + G.right) / 2, d.push([[G.left, G.top], [G.right, G.top], [G.right, G.bottom], [G.left, G.bottom]]);
+            var Z = Math.sqrt(E * E + T * T), j = U4.LABELDISTANCE * Z / Math.max(1, t.length / U4.LABELINCREASE);
+            c.each(function(N) {
+              var H = jv.calcTextOpts(N.level, _, b, r);
+              V4.select(this).selectAll("path").each(function() {
+                var re = this, oe = Fd.getVisibleSegment(re, G, H.height / 2);
+                if (oe && !(oe.len < (H.width + H.height) * U4.LABELMIN)) for (var _e = Math.min(Math.ceil(oe.len / j), U4.LABELMAX), Ce = 0; Ce < _e; Ce++) {
+                  var Le = jv.findBestTextLocation(re, oe, H, v, G);
+                  if (!Le) break;
+                  jv.addLabelData(Le, H, v, d);
+                }
+              });
+            }), b.remove(), jv.drawLabels(h, v, r, f, u ? d : null);
+          }
+          l && !s && c.remove();
+        }
+        jv.createLines = function(e, t, r, n) {
+          var i = r[0].smoothing, a = e.selectAll("g.contourlevel").data(t ? r : []);
+          if (a.exit().remove(), a.enter().append("g").classed("contourlevel", true), t) {
+            var o = a.selectAll("path.openline").data(function(l) {
+              return l.pedgepaths || l.edgepaths;
+            });
+            o.exit().remove(), o.enter().append("path").classed("openline", true), o.attr("d", function(l) {
+              return jy.smoothopen(l, i);
+            }).style("stroke-miterlimit", 1).style("vector-effect", n ? "none" : "non-scaling-stroke");
+            var s = a.selectAll("path.closedline").data(function(l) {
+              return l.ppaths || l.paths;
+            });
+            s.exit().remove(), s.enter().append("path").classed("closedline", true), s.attr("d", function(l) {
+              return jy.smoothclosed(l, i);
+            }).style("stroke-miterlimit", 1).style("vector-effect", n ? "none" : "non-scaling-stroke");
+          }
+          return a;
+        };
+        jv.createLineClip = function(e, t, r, n) {
+          var i = r._fullLayout._clips, a = t ? "clipline" + n : null, o = i.selectAll("#" + a).data(t ? [0] : []);
+          return o.exit().remove(), o.enter().append("clipPath").classed("contourlineclip", true).attr("id", a), jy.setClipUrl(e, a, r), o;
+        };
+        jv.labelFormatter = function(e, t) {
+          var r = e._fullLayout, n = t.trace, i = n.contours, a = { type: "linear", _id: "ycontour", showexponent: "all", exponentformat: "B" };
+          if (i.labelformat) a.tickformat = i.labelformat, kbe(a, r);
+          else {
+            var o = jbt.extractOpts(n);
+            if (o && o.colorbar && o.colorbar._axis) a = o.colorbar._axis;
+            else {
+              if (i.type === "constraint") {
+                var s = i.value;
+                Fd.isArrayOrTypedArray(s) ? a.range = [s[0], s[s.length - 1]] : a.range = [s, s];
+              } else a.range = [i.start, i.end], a.nticks = (i.end - i.start) / i.size;
+              a.range[0] === a.range[1] && (a.range[1] += a.range[0] || 1), a.nticks || (a.nticks = 1e3), kbe(a, r), Ebe.prepTicks(a), a._tmin = null, a._tmax = null;
+            }
+          }
+          return function(l) {
+            return Ebe.tickText(a, l).text;
+          };
+        };
+        jv.calcTextOpts = function(e, t, r, n) {
+          var i = t(e);
+          r.text(i).call(Cbe.convertToTspans, n);
+          var a = r.node(), o = jy.bBox(a, true);
+          return { text: i, width: o.width, height: o.height, fontSize: +a.style["font-size"].replace("px", ""), level: e, dy: (o.top + o.bottom) / 2 };
+        };
+        jv.findBestTextLocation = function(e, t, r, n, i) {
+          var a = r.width, o, s, l, u, c;
+          t.isClosed ? (s = t.len / Nm.INITIALSEARCHPOINTS, o = t.min + s / 2, l = t.max) : (s = (t.len - a) / (Nm.INITIALSEARCHPOINTS + 1), o = t.min + s + a / 2, l = t.max - (s + a) / 2);
+          for (var f = 1 / 0, h = 0; h < Nm.ITERATIONS; h++) {
+            for (var d = o; d < l; d += s) {
+              var v = Fd.getTextLocation(e, t.total, d, a), _ = $bt(v, r, n, i);
+              _ < f && (f = _, c = v, u = d);
+            }
+            if (f > Nm.MAXCOST * 2) break;
+            h && (s /= 2), o = u - s / 2, l = o + s * 1.5;
+          }
+          if (f <= Nm.MAXCOST) return c;
+        };
+        function $bt(e, t, r, n) {
+          var i = t.width / 2, a = t.height / 2, o = e.x, s = e.y, l = e.theta, u = Math.cos(l) * i, c = Math.sin(l) * i, f = (o > n.center ? n.right - o : o - n.left) / (u + Math.abs(Math.sin(l) * a)), h = (s > n.middle ? n.bottom - s : s - n.top) / (Math.abs(c) + Math.cos(l) * a);
+          if (f < 1 || h < 1) return 1 / 0;
+          var d = Nm.EDGECOST * (1 / (f - 1) + 1 / (h - 1));
+          d += Nm.ANGLECOST * l * l;
+          for (var v = o - u, _ = s - c, b = o + u, p = s + c, k = 0; k < r.length; k++) {
+            var E = r[k], T = Math.cos(E.theta) * E.width / 2, L = Math.sin(E.theta) * E.width / 2, x = Fd.segmentDistance(v, _, b, p, E.x - T, E.y - L, E.x + T, E.y + L) * 2 / (t.height + E.height), C = E.level === t.level, M = C ? Nm.SAMELEVELDISTANCE : 1;
+            if (x <= M) return 1 / 0;
+            var g = Nm.NEIGHBORCOST * (C ? Nm.SAMELEVELFACTOR : 1);
+            d += g / (x - M);
+          }
+          return d;
+        }
+        jv.addLabelData = function(e, t, r, n) {
+          var i = t.fontSize, a = t.width + i / 3, o = Math.max(0, t.height - i / 3), s = e.x, l = e.y, u = e.theta, c = Math.sin(u), f = Math.cos(u), h = function(v, _) {
+            return [s + v * f - _ * c, l + v * c + _ * f];
+          }, d = [h(-a / 2, -o / 2), h(-a / 2, o / 2), h(a / 2, o / 2), h(a / 2, -o / 2)];
+          r.push({ text: t.text, x: s, y: l, dy: t.dy, theta: u, level: t.level, width: a, height: o }), n.push(d);
+        };
+        jv.drawLabels = function(e, t, r, n, i) {
+          var a = e.selectAll("text").data(t, function(u) {
+            return u.text + "," + u.x + "," + u.y + "," + u.theta;
+          });
+          if (a.exit().remove(), a.enter().append("text").attr({ "data-notex": 1, "text-anchor": "middle" }).each(function(u) {
+            var c = u.x + Math.sin(u.theta) * u.dy, f = u.y - Math.cos(u.theta) * u.dy;
+            V4.select(this).text(u.text).attr({ x: c, y: f, transform: "rotate(" + 180 * u.theta / Math.PI + " " + c + " " + f + ")" }).call(Cbe.convertToTspans, r);
+          }), i) {
+            for (var o = "", s = 0; s < i.length; s++) o += "M" + i[s].join("L") + "Z";
+            var l = Fd.ensureSingle(n, "path", "");
+            l.attr("d", o);
+          }
+        };
+        function Qbt(e, t, r, n, i) {
+          var a = n.trace, o = r._fullLayout._clips, s = "clip" + a.uid, l = o.selectAll("#" + s).data(a.connectgaps ? [] : [0]);
+          if (l.enter().append("clipPath").classed("contourclip", true).attr("id", s), l.exit().remove(), a.connectgaps === false) {
+            var u = { level: 0.9, crossings: {}, starts: [], edgepaths: [], paths: [], xaxis: t.xaxis, yaxis: t.yaxis, x: n.x, y: n.y, z: e2t(n), smoothing: 0 };
+            Lbe([u]), Pbe([u]), Ibe([u], { type: "levels" });
+            var c = Fd.ensureSingle(l, "path", "");
+            c.attr("d", (u.prefixBoundary ? "M" + i.join("L") + "Z" : "") + Rbe(u, i));
+          } else s = null;
+          jy.setClipUrl(e, s, r);
+        }
+        function e2t(e) {
+          var t = e.trace._emptypoints, r = [], n = e.z.length, i = e.z[0].length, a, o = [], s;
+          for (a = 0; a < i; a++) o.push(1);
+          for (a = 0; a < n; a++) r.push(o.slice());
+          for (a = 0; a < t.length; a++) s = t[a], r[s[0]][s[1]] = 0;
+          return e.zmask = r, r;
+        }
+      });
+      var PG = ye((Rcr, Dbe) => {
+        var t2t = Oa(), LG = tc(), r2t = q4();
+        Dbe.exports = function(t) {
+          var r = t.contours, n = r.start, i = r2t(r), a = r.size || 1, o = Math.floor((i - n) / a) + 1, s = r.coloring === "lines" ? 0 : 1, l = LG.extractOpts(t);
+          isFinite(a) || (a = 1, o = 1);
+          var u = l.reversescale ? LG.flipScale(l.colorscale) : l.colorscale, c = u.length, f = new Array(c), h = new Array(c), d, v, _ = l.min, b = l.max;
+          if (r.coloring === "heatmap") {
+            for (v = 0; v < c; v++) d = u[v], f[v] = d[0] * (b - _) + _, h[v] = d[1];
+            var p = t2t.extent([_, b, r.start, r.start + a * (o - 1)]), k = p[_ < b ? 0 : 1], E = p[_ < b ? 1 : 0];
+            k !== _ && (f.splice(0, 0, k), h.splice(0, 0, h[0])), E !== b && (f.push(E), h.push(h[h.length - 1]));
+          } else {
+            var T = t._input && typeof t._input.zmin == "number" && typeof t._input.zmax == "number";
+            for (T && (n <= _ || i >= b) && (n <= _ && (n = _), i >= b && (i = b), o = Math.floor((i - n) / a) + 1, s = 0), v = 0; v < c; v++) d = u[v], f[v] = (d[0] * (o + s - 1) - s / 2) * a + n, h[v] = d[1];
+            (T || t.autocontour) && (f[0] > _ && (f.unshift(_), h.unshift(h[0])), f[f.length - 1] < b && (f.push(b), h.push(h[h.length - 1])));
+          }
+          return LG.makeColorScaleFunc({ domain: f, range: h }, { noNumericCheck: true });
+        };
+      });
+      var D8 = ye((Dcr, zbe) => {
+        var R8 = Oa(), Fbe = So(), i2t = y8(), n2t = PG();
+        zbe.exports = function(t) {
+          var r = R8.select(t).selectAll("g.contour");
+          r.style("opacity", function(n) {
+            return n[0].trace.opacity;
+          }), r.each(function(n) {
+            var i = R8.select(this), a = n[0].trace, o = a.contours, s = a.line, l = o.size || 1, u = o.start, c = o.type === "constraint", f = !c && o.coloring === "lines", h = !c && o.coloring === "fill", d = f || h ? n2t(a) : null;
+            i.selectAll("g.contourlevel").each(function(b) {
+              R8.select(this).selectAll("path").call(Fbe.lineGroupStyle, s.width, f ? d(b.level) : s.color, s.dash);
+            });
+            var v = o.labelfont;
+            if (i.selectAll("g.contourlabels text").each(function(b) {
+              Fbe.font(R8.select(this), { weight: v.weight, style: v.style, variant: v.variant, textcase: v.textcase, lineposition: v.lineposition, shadow: v.shadow, family: v.family, size: v.size, color: v.color || (f ? d(b.level) : s.color) });
+            }), c) i.selectAll("g.contourfill path").style("fill", a.fillcolor);
+            else if (h) {
+              var _;
+              i.selectAll("g.contourfill path").style("fill", function(b) {
+                return _ === void 0 && (_ = b.level), d(b.level + 0.5 * l);
+              }), _ === void 0 && (_ = u), i.selectAll("g.contourbg path").style("fill", d(_ - 0.5 * l));
+            }
+          }), i2t(t);
+        };
+      });
+      var F8 = ye((Fcr, qbe) => {
+        var Obe = tc(), a2t = PG(), o2t = q4();
+        function s2t(e, t, r) {
+          var n = t.contours, i = t.line, a = n.size || 1, o = n.coloring, s = a2t(t, { isColorbar: true });
+          if (o === "heatmap") {
+            var l = Obe.extractOpts(t);
+            r._fillgradient = l.reversescale ? Obe.flipScale(l.colorscale) : l.colorscale, r._zrange = [l.min, l.max];
+          } else o === "fill" && (r._fillcolor = s);
+          r._line = { color: o === "lines" ? s : i.color, width: n.showlines !== false ? i.width : 0, dash: i.dash }, r._levels = { start: n.start, end: o2t(n), size: a };
+        }
+        qbe.exports = { min: "zmin", max: "zmax", calc: s2t };
+      });
+      var IG = ye((zcr, Bbe) => {
+        var z8 = ka(), l2t = x8();
+        Bbe.exports = function(t, r, n, i, a) {
+          a || (a = {}), a.isContour = true;
+          var o = l2t(t, r, n, i, a);
+          return o && o.forEach(function(s) {
+            var l = s.trace;
+            l.contours.type === "constraint" && (l.fillcolor && z8.opacity(l.fillcolor) ? s.color = z8.addOpacity(l.fillcolor, 1) : l.contours.showlines && z8.opacity(l.line.color) && (s.color = z8.addOpacity(l.line.color, 1)));
+          }), o;
+        };
+      });
+      var Ube = ye((Ocr, Nbe) => {
+        Nbe.exports = { attributes: mG(), supplyDefaults: sbe(), crossTraceDefaults: T8(), calc: wG(), plot: I8().plot, layerName: "contourlayer", style: D8(), colorbar: F8(), hoverPoints: IG(), moduleType: "trace", name: "histogram2dcontour", basePlotModule: mh(), categories: ["cartesian", "svg", "2dMap", "contour", "histogram", "showLegend"], meta: {} };
+      });
+      var Gbe = ye((qcr, Vbe) => {
+        Vbe.exports = Ube();
+      });
+      var RG = ye((Bcr, Ybe) => {
+        var Hbe = Eo(), u2t = yG(), Xbe = ka(), jbe = Xbe.addOpacity, c2t = Xbe.opacity, Zbe = M8(), Wbe = Dr().isArrayOrTypedArray, f2t = Zbe.CONSTRAINT_REDUCTION, h2t = Zbe.COMPARISON_OPS2;
+        Ybe.exports = function(t, r, n, i, a, o) {
+          var s = r.contours, l, u, c, f = n("contours.operation");
+          if (s._operation = f2t[f], d2t(n, s), f === "=" ? l = s.showlines = true : (l = n("contours.showlines"), c = n("fillcolor", jbe((t.line || {}).color || a, 0.5))), l) {
+            var h = c && c2t(c) ? jbe(r.fillcolor, 1) : a;
+            u = n("line.color", h), n("line.width", 2), n("line.dash");
+          }
+          n("line.smoothing"), u2t(n, i, u, o);
+        };
+        function d2t(e, t) {
+          var r;
+          h2t.indexOf(t.operation) === -1 ? (e("contours.value", [0, 1]), Wbe(t.value) ? t.value.length > 2 ? t.value = t.value.slice(2) : t.length === 0 ? t.value = [0, 1] : t.length < 2 ? (r = parseFloat(t.value[0]), t.value = [r, r + 1]) : t.value = [parseFloat(t.value[0]), parseFloat(t.value[1])] : Hbe(t.value) && (r = parseFloat(t.value), t.value = [r, r + 1])) : (e("contours.value", 0), Hbe(t.value) || (Wbe(t.value) ? t.value = parseFloat(t.value[0]) : t.value = 0));
+        }
+      });
+      var $be = ye((Ncr, Jbe) => {
+        var DG = Dr(), v2t = n8(), p2t = Dg(), g2t = RG(), m2t = k8(), y2t = C8(), _2t = I4(), Kbe = O4();
+        Jbe.exports = function(t, r, n, i) {
+          function a(u, c) {
+            return DG.coerce(t, r, Kbe, u, c);
+          }
+          function o(u) {
+            return DG.coerce2(t, r, Kbe, u);
+          }
+          var s = v2t(t, r, a, i);
+          if (!s) {
+            r.visible = false;
+            return;
+          }
+          p2t(t, r, i, a), a("xhoverformat"), a("yhoverformat"), a("text"), a("hovertext"), a("hoverongaps"), a("hovertemplate"), a("hovertemplatefallback");
+          var l = a("contours.type") === "constraint";
+          a("connectgaps", DG.isArray1D(r.z)), l ? g2t(t, r, a, i, n) : (m2t(t, r, a, o), y2t(t, r, a, i)), r.contours && r.contours.coloring === "heatmap" && _2t(a, i), a("zorder");
+        };
+      });
+      var e2e = ye((Ucr, Qbe) => {
+        Qbe.exports = { attributes: O4(), supplyDefaults: $be(), calc: wG(), plot: I8().plot, style: D8(), colorbar: F8(), hoverPoints: IG(), moduleType: "trace", name: "contour", basePlotModule: mh(), categories: ["cartesian", "svg", "2dMap", "contour", "showLegend"], meta: {} };
+      });
+      var r2e = ye((Vcr, t2e) => {
+        t2e.exports = e2e();
+      });
+      var FG = ye((Gcr, o2e) => {
+        var { hovertemplateAttrs: x2t, texttemplateAttrs: b2t, templatefallbackAttrs: i2e } = Ll(), w2t = Pg(), o0 = pf(), T2t = Gl(), n2e = Tu(), A2t = Pd().dash, F_ = Ao().extendFlat, X0 = o0.marker, G4 = o0.line, a2e = X0.line;
+        o2e.exports = { a: { valType: "data_array", editType: "calc" }, b: { valType: "data_array", editType: "calc" }, c: { valType: "data_array", editType: "calc" }, sum: { valType: "number", dflt: 0, min: 0, editType: "calc" }, mode: F_({}, o0.mode, { dflt: "markers" }), text: F_({}, o0.text, {}), texttemplate: b2t({ editType: "plot" }, { keys: ["a", "b", "c", "text"] }), texttemplatefallback: i2e({ editType: "plot" }), hovertext: F_({}, o0.hovertext, {}), line: { color: G4.color, width: G4.width, dash: A2t, backoff: G4.backoff, shape: F_({}, G4.shape, { values: ["linear", "spline"] }), smoothing: G4.smoothing, editType: "calc" }, connectgaps: o0.connectgaps, cliponaxis: o0.cliponaxis, fill: F_({}, o0.fill, { values: ["none", "toself", "tonext"], dflt: "none" }), fillcolor: w2t(), marker: F_({ symbol: X0.symbol, opacity: X0.opacity, angle: X0.angle, angleref: X0.angleref, standoff: X0.standoff, maxdisplayed: X0.maxdisplayed, size: X0.size, sizeref: X0.sizeref, sizemin: X0.sizemin, sizemode: X0.sizemode, line: F_({ width: a2e.width, dash: a2e.dash, editType: "calc" }, n2e("marker.line")), gradient: X0.gradient, editType: "calc" }, n2e("marker")), textfont: o0.textfont, textposition: o0.textposition, selected: o0.selected, unselected: o0.unselected, hoverinfo: F_({}, T2t.hoverinfo, { flags: ["a", "b", "c", "text", "name"] }), hoveron: o0.hoveron, hovertemplate: x2t(), hovertemplatefallback: i2e() };
+      });
+      var c2e = ye((Hcr, u2e) => {
+        var s2e = Dr(), S2t = Lm(), GT = Ru(), M2t = $p(), E2t = D0(), l2e = sT(), k2t = F0(), C2t = Fg(), L2t = FG();
+        u2e.exports = function(t, r, n, i) {
+          function a(h, d) {
+            return s2e.coerce(t, r, L2t, h, d);
+          }
+          var o = a("a"), s = a("b"), l = a("c"), u;
+          if (o ? (u = o.length, s ? (u = Math.min(u, s.length), l && (u = Math.min(u, l.length))) : l ? u = Math.min(u, l.length) : u = 0) : s && l && (u = Math.min(s.length, l.length)), !u) {
+            r.visible = false;
+            return;
+          }
+          r._length = u, a("sum"), a("text"), a("hovertext"), r.hoveron !== "fills" && (a("hovertemplate"), a("hovertemplatefallback"));
+          var c = u < S2t.PTS_LINESONLY ? "lines+markers" : "lines";
+          a("mode", c), GT.hasMarkers(r) && M2t(t, r, n, i, a, { gradient: true }), GT.hasLines(r) && (E2t(t, r, n, i, a, { backoff: true }), l2e(t, r, a), a("connectgaps")), GT.hasText(r) && (a("texttemplate"), a("texttemplatefallback"), k2t(t, r, i, a));
+          var f = [];
+          (GT.hasMarkers(r) || GT.hasText(r)) && (a("cliponaxis"), a("marker.maxdisplayed"), f.push("points")), a("fill"), r.fill !== "none" && (C2t(t, r, n, a), GT.hasLines(r) || l2e(t, r, a)), (r.fill === "tonext" || r.fill === "toself") && f.push("fills"), a("hoveron", f.join("+") || "points"), s2e.coerceSelectionMarkerOpacity(r, a);
+        };
+      });
+      var h2e = ye((jcr, f2e) => {
+        var zG = ho();
+        f2e.exports = function(t, r, n) {
+          var i = {}, a = n[r.subplot]._subplot;
+          return i.aLabel = zG.tickText(a.aaxis, t.a, true).text, i.bLabel = zG.tickText(a.baxis, t.b, true).text, i.cLabel = zG.tickText(a.caxis, t.c, true).text, i;
+        };
+      });
+      var g2e = ye((Wcr, p2e) => {
+        var OG = Eo(), P2t = z0(), I2t = Rm(), R2t = O0(), D2t = q0().calcMarkerSize, d2e = ["a", "b", "c"], v2e = { a: ["b", "c"], b: ["a", "c"], c: ["a", "b"] };
+        p2e.exports = function(t, r) {
+          var n = t._fullLayout[r.subplot], i = n.sum, a = r.sum || i, o = { a: r.a, b: r.b, c: r.c }, s = r.ids, l, u, c, f, h, d;
+          for (l = 0; l < d2e.length; l++) if (c = d2e[l], !o[c]) {
+            for (h = o[v2e[c][0]], d = o[v2e[c][1]], f = new Array(h.length), u = 0; u < h.length; u++) f[u] = a - h[u] - d[u];
+            o[c] = f;
+          }
+          var v = r._length, _ = new Array(v), b, p, k, E, T, L;
+          for (l = 0; l < v; l++) b = o.a[l], p = o.b[l], k = o.c[l], OG(b) && OG(p) && OG(k) ? (b = +b, p = +p, k = +k, E = i / (b + p + k), E !== 1 && (b *= E, p *= E, k *= E), L = b, T = k - p, _[l] = { x: T, y: L, a: b, b: p, c: k }, s && (_[l].id = s[l])) : _[l] = { x: false, y: false };
+          return D2t(r, v), P2t(t, r), I2t(_, r), R2t(_, r), _;
+        };
+      });
+      var y2e = ye((Xcr, m2e) => {
+        var F2t = dT();
+        m2e.exports = function(t, r, n) {
+          var i = r.plotContainer;
+          i.select(".scatterlayer").selectAll("*").remove();
+          for (var a = r.xaxis, o = r.yaxis, s = { xaxis: a, yaxis: o, plot: i, layerClipId: r._hasClipOnAxisFalse ? r.clipIdRelative : null }, l = r.layers.frontplot.select("g.scatterlayer"), u = 0; u < n.length; u++) {
+            var c = n[u];
+            c.length && (c[0].trace._xA = a, c[0].trace._yA = o);
+          }
+          F2t(t, s, n, l);
+        };
+      });
+      var x2e = ye((Zcr, _2e) => {
+        var z2t = mT();
+        _2e.exports = function(t, r, n, i) {
+          var a = z2t(t, r, n, i);
+          if (!a || a[0].index === false) return;
+          var o = a[0];
+          if (o.index === void 0) {
+            var s = 1 - o.y0 / t.ya._length, l = t.xa._length, u = l * s / 2, c = l - u;
+            return o.x0 = Math.max(Math.min(o.x0, c), u), o.x1 = Math.max(Math.min(o.x1, c), u), a;
+          }
+          var f = o.cd[o.index], h = o.trace, d = o.subplot;
+          o.a = f.a, o.b = f.b, o.c = f.c, o.xLabelVal = void 0, o.yLabelVal = void 0;
+          var v = {};
+          v[h.subplot] = { _subplot: d };
+          var _ = h._module.formatLabels(f, h, v);
+          o.aLabel = _.aLabel, o.bLabel = _.bLabel, o.cLabel = _.cLabel;
+          var b = f.hi || h.hoverinfo, p = [];
+          function k(T, L) {
+            p.push(T._hovertitle + ": " + L);
+          }
+          if (!h.hovertemplate) {
+            var E = b.split("+");
+            E.indexOf("all") !== -1 && (E = ["a", "b", "c"]), E.indexOf("a") !== -1 && k(d.aaxis, o.aLabel), E.indexOf("b") !== -1 && k(d.baxis, o.bLabel), E.indexOf("c") !== -1 && k(d.caxis, o.cLabel);
+          }
+          return o.extraText = p.join("<br>"), o.hovertemplate = h.hovertemplate, a;
+        };
+      });
+      var w2e = ye((Ycr, b2e) => {
+        b2e.exports = function(t, r, n, i, a) {
+          if (r.xa && (t.xaxis = r.xa), r.ya && (t.yaxis = r.ya), i[a]) {
+            var o = i[a];
+            t.a = o.a, t.b = o.b, t.c = o.c;
+          } else t.a = r.a, t.b = r.b, t.c = r.c;
+          return t;
+        };
+      });
+      var R2e = ye((Kcr, I2e) => {
+        var k2e = Oa(), O2t = fd(), qG = qa(), Wy = Dr(), Um = Wy.strTranslate, O8 = Wy._, jT = ka(), q8 = So(), H4 = xm(), BG = Ao().extendFlat, q2t = Mc(), z_ = ho(), T2e = yv(), A2e = vf(), C2e = Cg(), S2e = C2e.freeMode, B2t = C2e.rectMode, NG = zb(), N2t = Of().prepSelect, U2t = Of().selectOnClick, V2t = Of().clearOutline, G2t = Of().clearSelectionsCache, L2e = Rh();
+        function P2e(e, t) {
+          this.id = e.id, this.graphDiv = e.graphDiv, this.init(t), this.makeFramework(t), this.updateFx(t), this.aTickLayout = null, this.bTickLayout = null, this.cTickLayout = null;
+        }
+        I2e.exports = P2e;
+        var Vm = P2e.prototype;
+        Vm.init = function(e) {
+          this.container = e._ternarylayer, this.defs = e._defs, this.layoutId = e._uid, this.traceHash = {}, this.layers = {};
+        };
+        Vm.plot = function(e, t) {
+          var r = this, n = t[r.id], i = t._size;
+          r._hasClipOnAxisFalse = false;
+          for (var a = 0; a < e.length; a++) {
+            var o = e[a][0].trace;
+            if (o.cliponaxis === false) {
+              r._hasClipOnAxisFalse = true;
+              break;
+            }
+          }
+          r.updateLayers(n), r.adjustLayout(n, i), q2t.generalUpdatePerTraceModule(r.graphDiv, r, e, n), r.layers.plotbg.select("path").call(jT.fill, n.bgcolor);
+        };
+        Vm.makeFramework = function(e) {
+          var t = this, r = t.graphDiv, n = e[t.id], i = t.clipId = "clip" + t.layoutId + t.id, a = t.clipIdRelative = "clip-relative" + t.layoutId + t.id;
+          t.clipDef = Wy.ensureSingleById(e._clips, "clipPath", i, function(o) {
+            o.append("path").attr("d", "M0,0Z");
+          }), t.clipDefRelative = Wy.ensureSingleById(e._clips, "clipPath", a, function(o) {
+            o.append("path").attr("d", "M0,0Z");
+          }), t.plotContainer = Wy.ensureSingle(t.container, "g", t.id), t.updateLayers(n), q8.setClipUrl(t.layers.backplot, i, r), q8.setClipUrl(t.layers.grids, i, r);
+        };
+        Vm.updateFx = function(e) {
+          e._ternarylayer.selectAll("g.toplevel").style("cursor", e.dragmode === "pan" ? "move" : "crosshair");
+        };
+        Vm.updateLayers = function(e) {
+          var t = this, r = t.layers, n = ["draglayer", "plotbg", "backplot", "grids"];
+          e.aaxis.layer === "below traces" && n.push("aaxis", "aline"), e.baxis.layer === "below traces" && n.push("baxis", "bline"), e.caxis.layer === "below traces" && n.push("caxis", "cline"), n.push("frontplot"), e.aaxis.layer === "above traces" && n.push("aaxis", "aline"), e.baxis.layer === "above traces" && n.push("baxis", "bline"), e.caxis.layer === "above traces" && n.push("caxis", "cline");
+          var i = t.plotContainer.selectAll("g.toplevel").data(n, String), a = ["agrid", "bgrid", "cgrid"];
+          i.enter().append("g").attr("class", function(o) {
+            return "toplevel " + o;
+          }).each(function(o) {
+            var s = k2e.select(this);
+            r[o] = s, o === "frontplot" ? s.append("g").classed("scatterlayer", true) : o === "backplot" ? s.append("g").classed("maplayer", true) : o === "plotbg" ? s.append("path").attr("d", "M0,0Z") : o === "aline" || o === "bline" || o === "cline" ? s.append("path") : o === "grids" && a.forEach(function(l) {
+              r[l] = s.append("g").classed("grid " + l, true);
+            });
+          }), i.order();
+        };
+        var HT = Math.sqrt(4 / 3);
+        Vm.adjustLayout = function(e, t) {
+          var r = this, n = e.domain, i = (n.x[0] + n.x[1]) / 2, a = (n.y[0] + n.y[1]) / 2, o = n.x[1] - n.x[0], s = n.y[1] - n.y[0], l = o * t.w, u = s * t.h, c = e.sum, f = e.aaxis.min, h = e.baxis.min, d = e.caxis.min, v, _, b, p, k, E;
+          l > HT * u ? (p = u, b = p * HT) : (b = l, p = b / HT), k = o * b / l, E = s * p / u, v = t.l + t.w * i - b / 2, _ = t.t + t.h * (1 - a) - p / 2, r.x0 = v, r.y0 = _, r.w = b, r.h = p, r.sum = c, r.xaxis = { type: "linear", range: [f + 2 * d - c, c - f - 2 * h], domain: [i - k / 2, i + k / 2], _id: "x" }, H4(r.xaxis, r.graphDiv._fullLayout), r.xaxis.setScale(), r.xaxis.isPtWithinRange = function(U) {
+            return U.a >= r.aaxis.range[0] && U.a <= r.aaxis.range[1] && U.b >= r.baxis.range[1] && U.b <= r.baxis.range[0] && U.c >= r.caxis.range[1] && U.c <= r.caxis.range[0];
+          }, r.yaxis = { type: "linear", range: [f, c - h - d], domain: [a - E / 2, a + E / 2], _id: "y" }, H4(r.yaxis, r.graphDiv._fullLayout), r.yaxis.setScale(), r.yaxis.isPtWithinRange = function() {
+            return true;
+          };
+          var T = r.yaxis.domain[0], L = r.aaxis = BG({}, e.aaxis, { range: [f, c - h - d], side: "left", tickangle: (+e.aaxis.tickangle || 0) - 30, domain: [T, T + E * HT], anchor: "free", position: 0, _id: "y", _length: b });
+          H4(L, r.graphDiv._fullLayout), L.setScale();
+          var x = r.baxis = BG({}, e.baxis, { range: [c - f - d, h], side: "bottom", domain: r.xaxis.domain, anchor: "free", position: 0, _id: "x", _length: b });
+          H4(x, r.graphDiv._fullLayout), x.setScale();
+          var C = r.caxis = BG({}, e.caxis, { range: [c - f - h, d], side: "right", tickangle: (+e.caxis.tickangle || 0) + 30, domain: [T, T + E * HT], anchor: "free", position: 0, _id: "y", _length: b });
+          H4(C, r.graphDiv._fullLayout), C.setScale();
+          var M = "M" + v + "," + (_ + p) + "h" + b + "l-" + b / 2 + ",-" + p + "Z";
+          r.clipDef.select("path").attr("d", M), r.layers.plotbg.select("path").attr("d", M);
+          var g = "M0," + p + "h" + b + "l-" + b / 2 + ",-" + p + "Z";
+          r.clipDefRelative.select("path").attr("d", g);
+          var P = Um(v, _);
+          r.plotContainer.selectAll(".scatterlayer,.maplayer").attr("transform", P), r.clipDefRelative.select("path").attr("transform", null);
+          var A = Um(v - x._offset, _ + p);
+          r.layers.baxis.attr("transform", A), r.layers.bgrid.attr("transform", A);
+          var z = Um(v + b / 2, _) + "rotate(30)" + Um(0, -L._offset);
+          r.layers.aaxis.attr("transform", z), r.layers.agrid.attr("transform", z);
+          var O = Um(v + b / 2, _) + "rotate(-30)" + Um(0, -C._offset);
+          r.layers.caxis.attr("transform", O), r.layers.cgrid.attr("transform", O), r.drawAxes(true), r.layers.aline.select("path").attr("d", L.showline ? "M" + v + "," + (_ + p) + "l" + b / 2 + ",-" + p : "M0,0").call(jT.stroke, L.linecolor || "#000").style("stroke-width", (L.linewidth || 0) + "px"), r.layers.bline.select("path").attr("d", x.showline ? "M" + v + "," + (_ + p) + "h" + b : "M0,0").call(jT.stroke, x.linecolor || "#000").style("stroke-width", (x.linewidth || 0) + "px"), r.layers.cline.select("path").attr("d", C.showline ? "M" + (v + b / 2) + "," + _ + "l" + b / 2 + "," + p : "M0,0").call(jT.stroke, C.linecolor || "#000").style("stroke-width", (C.linewidth || 0) + "px"), r.graphDiv._context.staticPlot || r.initInteractions(), q8.setClipUrl(r.layers.frontplot, r._hasClipOnAxisFalse ? null : r.clipId, r.graphDiv);
+        };
+        Vm.drawAxes = function(e) {
+          var t = this, r = t.graphDiv, n = t.id.slice(7) + "title", i = t.layers, a = t.aaxis, o = t.baxis, s = t.caxis;
+          if (t.drawAx(a), t.drawAx(o), t.drawAx(s), e) {
+            var l = Math.max(a.showticklabels ? a.tickfont.size / 2 : 0, (s.showticklabels ? s.tickfont.size * 0.75 : 0) + (s.ticks === "outside" ? s.ticklen * 0.87 : 0)), u = (o.showticklabels ? o.tickfont.size : 0) + (o.ticks === "outside" ? o.ticklen : 0) + 3;
+            i["a-title"] = NG.draw(r, "a" + n, { propContainer: a, propName: t.id + ".aaxis.title.text", placeholder: O8(r, "Click to enter Component A title"), attributes: { x: t.x0 + t.w / 2, y: t.y0 - a.title.font.size / 3 - l, "text-anchor": "middle" } }), i["b-title"] = NG.draw(r, "b" + n, { propContainer: o, propName: t.id + ".baxis.title.text", placeholder: O8(r, "Click to enter Component B title"), attributes: { x: t.x0 - u, y: t.y0 + t.h + o.title.font.size * 0.83 + u, "text-anchor": "middle" } }), i["c-title"] = NG.draw(r, "c" + n, { propContainer: s, propName: t.id + ".caxis.title.text", placeholder: O8(r, "Click to enter Component C title"), attributes: { x: t.x0 + t.w + u, y: t.y0 + t.h + s.title.font.size * 0.83 + u, "text-anchor": "middle" } });
+          }
+        };
+        Vm.drawAx = function(e) {
+          var t = this, r = t.graphDiv, n = e._name, i = n.charAt(0), a = e._id, o = t.layers[n], s = 30, l = i + "tickLayout", u = H2t(e);
+          t[l] !== u && (o.selectAll("." + a + "tick").remove(), t[l] = u), e.setScale();
+          var c = z_.calcTicks(e), f = z_.clipEnds(e, c), h = z_.makeTransTickFn(e), d = z_.getTickSigns(e)[2], v = Wy.deg2rad(s), _ = d * (e.linewidth || 1) / 2, b = d * e.ticklen, p = t.w, k = t.h, E = i === "b" ? "M0," + _ + "l" + Math.sin(v) * b + "," + Math.cos(v) * b : "M" + _ + ",0l" + Math.cos(v) * b + "," + -Math.sin(v) * b, T = { a: "M0,0l" + k + ",-" + p / 2, b: "M0,0l-" + p / 2 + ",-" + k, c: "M0,0l-" + k + "," + p / 2 }[i];
+          z_.drawTicks(r, e, { vals: e.ticks === "inside" ? f : c, layer: o, path: E, transFn: h, crisp: false }), z_.drawGrid(r, e, { vals: f, layer: t.layers[i + "grid"], path: T, transFn: h, crisp: false }), z_.drawLabels(r, e, { vals: c, layer: o, transFn: h, labelFns: z_.makeLabelFns(e, 0, s) });
+        };
+        function H2t(e) {
+          return e.ticks + String(e.ticklen) + String(e.showticklabels);
+        }
+        var yd = L2e.MINZOOM / 2 + 0.87, j2t = "m-0.87,.5h" + yd + "v3h-" + (yd + 5.2) + "l" + (yd / 2 + 2.6) + ",-" + (yd * 0.87 + 4.5) + "l2.6,1.5l-" + yd / 2 + "," + yd * 0.87 + "Z", W2t = "m0.87,.5h-" + yd + "v3h" + (yd + 5.2) + "l-" + (yd / 2 + 2.6) + ",-" + (yd * 0.87 + 4.5) + "l-2.6,1.5l" + yd / 2 + "," + yd * 0.87 + "Z", X2t = "m0,1l" + yd / 2 + "," + yd * 0.87 + "l2.6,-1.5l-" + (yd / 2 + 2.6) + ",-" + (yd * 0.87 + 4.5) + "l-" + (yd / 2 + 2.6) + "," + (yd * 0.87 + 4.5) + "l2.6,1.5l" + yd / 2 + ",-" + yd * 0.87 + "Z", Z2t = "m0.5,0.5h5v-2h-5v-5h-2v5h-5v2h5v5h2Z", M2e = true;
+        Vm.clearOutline = function() {
+          G2t(this.dragOptions), V2t(this.dragOptions.gd);
+        };
+        Vm.initInteractions = function() {
+          var e = this, t = e.layers.plotbg.select("path").node(), r = e.graphDiv, n = r._fullLayout._zoomlayer, i, a;
+          this.dragOptions = { element: t, gd: r, plotinfo: { id: e.id, domain: r._fullLayout[e.id].domain, xaxis: e.xaxis, yaxis: e.yaxis }, subplot: e.id, prepFn: function(A, z, O) {
+            e.dragOptions.xaxes = [e.xaxis], e.dragOptions.yaxes = [e.yaxis], i = r._fullLayout._invScaleX, a = r._fullLayout._invScaleY;
+            var U = e.dragOptions.dragmode = r._fullLayout.dragmode;
+            S2e(U) ? e.dragOptions.minDrag = 1 : e.dragOptions.minDrag = void 0, U === "zoom" ? (e.dragOptions.moveFn = x, e.dragOptions.clickFn = p, e.dragOptions.doneFn = C, k(A, z, O)) : U === "pan" ? (e.dragOptions.moveFn = g, e.dragOptions.clickFn = p, e.dragOptions.doneFn = P, M(), e.clearOutline(r)) : (B2t(U) || S2e(U)) && N2t(A, z, O, e.dragOptions, U);
+          } };
+          var o, s, l, u, c, f, h, d, v, _;
+          function b(A) {
+            var z = {};
+            return z[e.id + ".aaxis.min"] = A.a, z[e.id + ".baxis.min"] = A.b, z[e.id + ".caxis.min"] = A.c, z;
+          }
+          function p(A, z) {
+            var O = r._fullLayout.clickmode;
+            E2e(r), A === 2 && (r.emit("plotly_doubleclick", null), qG.call("_guiRelayout", r, b({ a: 0, b: 0, c: 0 }))), O.indexOf("select") > -1 && A === 1 && U2t(z, r, [e.xaxis], [e.yaxis], e.id, e.dragOptions), O.indexOf("event") > -1 && A2e.click(r, z, e.id);
+          }
+          function k(A, z, O) {
+            var U = t.getBoundingClientRect();
+            o = z - U.left, s = O - U.top, r._fullLayout._calcInverseTransform(r);
+            var G = r._fullLayout._invTransform, Z = Wy.apply3DTransform(G)(o, s);
+            o = Z[0], s = Z[1], l = { a: e.aaxis.range[0], b: e.baxis.range[1], c: e.caxis.range[1] }, c = l, u = e.aaxis.range[1] - l.a, f = O2t(e.graphDiv._fullLayout[e.id].bgcolor).getLuminance(), h = "M0," + e.h + "L" + e.w / 2 + ", 0L" + e.w + "," + e.h + "Z", d = false, v = n.append("path").attr("class", "zoombox").attr("transform", Um(e.x0, e.y0)).style({ fill: f > 0.2 ? "rgba(0,0,0,0)" : "rgba(255,255,255,0)", "stroke-width": 0 }).attr("d", h), _ = n.append("path").attr("class", "zoombox-corners").attr("transform", Um(e.x0, e.y0)).style({ fill: jT.background, stroke: jT.defaultLine, "stroke-width": 1, opacity: 0 }).attr("d", "M0,0Z"), e.clearOutline(r);
+          }
+          function E(A, z) {
+            return 1 - z / e.h;
+          }
+          function T(A, z) {
+            return 1 - (A + (e.h - z) / Math.sqrt(3)) / e.w;
+          }
+          function L(A, z) {
+            return (A - (e.h - z) / Math.sqrt(3)) / e.w;
+          }
+          function x(A, z) {
+            var O = o + A * i, U = s + z * a, G = Math.max(0, Math.min(1, E(o, s), E(O, U))), Z = Math.max(0, Math.min(1, T(o, s), T(O, U))), j = Math.max(0, Math.min(1, L(o, s), L(O, U))), N = (G / 2 + j) * e.w, H = (1 - G / 2 - Z) * e.w, re = (N + H) / 2, oe = H - N, _e = (1 - G) * e.h, Ce = _e - oe / HT;
+            oe < L2e.MINZOOM ? (c = l, v.attr("d", h), _.attr("d", "M0,0Z")) : (c = { a: l.a + G * u, b: l.b + Z * u, c: l.c + j * u }, v.attr("d", h + "M" + N + "," + _e + "H" + H + "L" + re + "," + Ce + "L" + N + "," + _e + "Z"), _.attr("d", "M" + o + "," + s + Z2t + "M" + N + "," + _e + j2t + "M" + H + "," + _e + W2t + "M" + re + "," + Ce + X2t)), d || (v.transition().style("fill", f > 0.2 ? "rgba(0,0,0,0.4)" : "rgba(255,255,255,0.3)").duration(200), _.transition().style("opacity", 1).duration(200), d = true), r.emit("plotly_relayouting", b(c));
+          }
+          function C() {
+            E2e(r), c !== l && (qG.call("_guiRelayout", r, b(c)), M2e && r.data && r._context.showTips && (Wy.notifier(O8(r, "Double-click to zoom back out"), "long"), M2e = false));
+          }
+          function M() {
+            l = { a: e.aaxis.range[0], b: e.baxis.range[1], c: e.caxis.range[1] }, c = l;
+          }
+          function g(A, z) {
+            var O = A / e.xaxis._m, U = z / e.yaxis._m;
+            c = { a: l.a - U, b: l.b + (O + U) / 2, c: l.c - (O - U) / 2 };
+            var G = [c.a, c.b, c.c].sort(Wy.sorterAsc), Z = { a: G.indexOf(c.a), b: G.indexOf(c.b), c: G.indexOf(c.c) };
+            G[0] < 0 && (G[1] + G[0] / 2 < 0 ? (G[2] += G[0] + G[1], G[0] = G[1] = 0) : (G[2] += G[0] / 2, G[1] += G[0] / 2, G[0] = 0), c = { a: G[Z.a], b: G[Z.b], c: G[Z.c] }, z = (l.a - c.a) * e.yaxis._m, A = (l.c - c.c - l.b + c.b) * e.xaxis._m);
+            var j = Um(e.x0 + A, e.y0 + z);
+            e.plotContainer.selectAll(".scatterlayer,.maplayer").attr("transform", j);
+            var N = Um(-A, -z);
+            e.clipDefRelative.select("path").attr("transform", N), e.aaxis.range = [c.a, e.sum - c.b - c.c], e.baxis.range = [e.sum - c.a - c.c, c.b], e.caxis.range = [e.sum - c.a - c.b, c.c], e.drawAxes(false), e._hasClipOnAxisFalse && e.plotContainer.select(".scatterlayer").selectAll(".trace").call(q8.hideOutsideRangePoints, e), r.emit("plotly_relayouting", b(c));
+          }
+          function P() {
+            qG.call("_guiRelayout", r, b(c));
+          }
+          t.onmousemove = function(A) {
+            A2e.hover(r, A, e.id), r._fullLayout._lasthover = t, r._fullLayout._hoversubplot = e.id;
+          }, t.onmouseout = function(A) {
+            r._dragging || T2e.unhover(r, A);
+          }, T2e.init(this.dragOptions);
+        };
+        function E2e(e) {
+          k2e.select(e).selectAll(".zoombox,.js-zoombox-backdrop,.js-zoombox-menu,.zoombox-corners").remove();
+        }
+      });
+      var GG = ye((Jcr, D2e) => {
+        var Y2t = Ih(), K2t = Cc().attributes, su = Rd(), J2t = mc().overrideAll, UG = Ao().extendFlat, VG = { title: { text: su.title.text, font: su.title.font }, color: su.color, tickmode: su.minor.tickmode, nticks: UG({}, su.nticks, { dflt: 6, min: 1 }), tick0: su.tick0, dtick: su.dtick, tickvals: su.tickvals, ticktext: su.ticktext, ticks: su.ticks, ticklen: su.ticklen, tickwidth: su.tickwidth, tickcolor: su.tickcolor, ticklabelstep: su.ticklabelstep, showticklabels: su.showticklabels, labelalias: su.labelalias, showtickprefix: su.showtickprefix, tickprefix: su.tickprefix, showticksuffix: su.showticksuffix, ticksuffix: su.ticksuffix, showexponent: su.showexponent, exponentformat: su.exponentformat, minexponent: su.minexponent, separatethousands: su.separatethousands, tickfont: su.tickfont, tickangle: su.tickangle, tickformat: su.tickformat, tickformatstops: su.tickformatstops, hoverformat: su.hoverformat, showline: UG({}, su.showline, { dflt: true }), linecolor: su.linecolor, linewidth: su.linewidth, showgrid: UG({}, su.showgrid, { dflt: true }), gridcolor: su.gridcolor, gridwidth: su.gridwidth, griddash: su.griddash, layer: su.layer, min: { valType: "number", dflt: 0, min: 0 } }, B8 = D2e.exports = J2t({ domain: K2t({ name: "ternary" }), bgcolor: { valType: "color", dflt: Y2t.background }, sum: { valType: "number", dflt: 1, min: 0 }, aaxis: VG, baxis: VG, caxis: VG }, "plot", "from-root");
+        B8.uirevision = { valType: "any", editType: "none" };
+        B8.aaxis.uirevision = B8.baxis.uirevision = B8.caxis.uirevision = { valType: "any", editType: "none" };
+      });
+      var O_ = ye(($cr, F2e) => {
+        var $2t = Dr(), Q2t = vl(), ewt = Cc().defaults;
+        F2e.exports = function(t, r, n, i) {
+          var a = i.type, o = i.attributes, s = i.handleDefaults, l = i.partition || "x", u = r._subplots[a], c = u.length, f = c && u[0].replace(/\d+$/, ""), h, d;
+          function v(k, E) {
+            return $2t.coerce(h, d, o, k, E);
+          }
+          for (var _ = 0; _ < c; _++) {
+            var b = u[_];
+            t[b] ? h = t[b] : h = t[b] = {}, d = Q2t.newContainer(r, b, f), i.noUirevision || v("uirevision", r.uirevision);
+            var p = {};
+            p[l] = [_ / c, (_ + 1) / c], ewt(d, r, v, p), i.id = b, s(h, d, v, i);
+          }
+        };
+      });
+      var B2e = ye((Qcr, q2e) => {
+        var twt = ka(), rwt = vl(), N8 = Dr(), iwt = O_(), nwt = s_(), awt = l_(), owt = F3(), swt = Lb(), lwt = u4(), O2e = GG(), z2e = ["aaxis", "baxis", "caxis"];
+        q2e.exports = function(t, r, n) {
+          iwt(t, r, n, { type: "ternary", attributes: O2e, handleDefaults: uwt, font: r.font, paper_bgcolor: r.paper_bgcolor });
+        };
+        function uwt(e, t, r, n) {
+          var i = r("bgcolor"), a = r("sum");
+          n.bgColor = twt.combine(i, n.paper_bgcolor);
+          for (var o, s, l, u = 0; u < z2e.length; u++) o = z2e[u], s = e[o] || {}, l = rwt.newContainer(t, o), l._name = o, cwt(s, l, n, t);
+          var c = t.aaxis, f = t.baxis, h = t.caxis;
+          c.min + f.min + h.min >= a && (c.min = 0, f.min = 0, h.min = 0, e.aaxis && delete e.aaxis.min, e.baxis && delete e.baxis.min, e.caxis && delete e.caxis.min);
+        }
+        function cwt(e, t, r, n) {
+          var i = O2e[t._name];
+          function a(d, v) {
+            return N8.coerce(e, t, i, d, v);
+          }
+          a("uirevision", n.uirevision), t.type = "linear";
+          var o = a("color"), s = o !== i.color.dflt ? o : r.font.color, l = t._name, u = l.charAt(0).toUpperCase(), c = "Component " + u, f = a("title.text", c);
+          t._hovertitle = f === c ? f : u, N8.coerceFont(a, "title.font", r.font, { overrideDflt: { size: N8.bigFont(r.font.size), color: s } }), a("min"), swt(e, t, a, "linear"), awt(e, t, a, "linear"), nwt(e, t, a, "linear", { noAutotickangles: true, noTicklabelshift: true, noTicklabelstandoff: true }), owt(e, t, a, { outerTicks: true });
+          var h = a("showticklabels");
+          h && (N8.coerceFont(a, "tickfont", r.font, { overrideDflt: { color: s } }), a("tickangle"), a("tickformat")), lwt(e, t, a, { dfltColor: o, bgColor: r.bgColor, blend: 60, showLine: true, showGrid: true, noZeroLine: true, attributes: i }), a("hoverformat"), a("layer");
+        }
+      });
+      var N2e = ye((Z0) => {
+        var fwt = R2e(), hwt = Id().getSubplotCalcData, dwt = Dr().counterRegex, WT = "ternary";
+        Z0.name = WT;
+        var vwt = Z0.attr = "subplot";
+        Z0.idRoot = WT;
+        Z0.idRegex = Z0.attrRegex = dwt(WT);
+        var pwt = Z0.attributes = {};
+        pwt[vwt] = { valType: "subplotid", dflt: "ternary", editType: "calc" };
+        Z0.layoutAttributes = GG();
+        Z0.supplyLayoutDefaults = B2e();
+        Z0.plot = function(t) {
+          for (var r = t._fullLayout, n = t.calcdata, i = r._subplots[WT], a = 0; a < i.length; a++) {
+            var o = i[a], s = hwt(n, WT, o), l = r[o]._subplot;
+            l || (l = new fwt({ id: o, graphDiv: t, container: r._ternarylayer.node() }, r), r[o]._subplot = l), l.plot(s, r, t._promises);
+          }
+        };
+        Z0.clean = function(e, t, r, n) {
+          for (var i = n._subplots[WT] || [], a = 0; a < i.length; a++) {
+            var o = i[a], s = n[o]._subplot;
+            !t[o] && s && (s.plotContainer.remove(), s.clipDef.remove(), s.clipDefRelative.remove(), s.layers["a-title"].remove(), s.layers["b-title"].remove(), s.layers["c-title"].remove());
+          }
+        };
+        Z0.updateFx = function(e) {
+          var t = e._fullLayout;
+          t._ternarylayer.selectAll("g.toplevel").style("cursor", t.dragmode === "pan" ? "move" : "crosshair");
+        };
+      });
+      var V2e = ye((tfr, U2e) => {
+        U2e.exports = { attributes: FG(), supplyDefaults: c2e(), colorbar: $d(), formatLabels: h2e(), calc: g2e(), plot: y2e(), style: sp().style, styleOnSelect: sp().styleOnSelect, hoverPoints: x2e(), selectPoints: yT(), eventData: w2e(), moduleType: "trace", name: "scatterternary", basePlotModule: N2e(), categories: ["ternary", "symbols", "showLegend", "scatter-like"], meta: {} };
+      });
+      var H2e = ye((rfr, G2e) => {
+        G2e.exports = V2e();
+      });
+      var HG = ye((ifr, W2e) => {
+        var qh = k4(), XT = Ao().extendFlat, j2e = df().axisHoverFormat;
+        W2e.exports = { y: qh.y, x: qh.x, x0: qh.x0, y0: qh.y0, xhoverformat: j2e("x"), yhoverformat: j2e("y"), name: XT({}, qh.name, {}), orientation: XT({}, qh.orientation, {}), bandwidth: { valType: "number", min: 0, editType: "calc" }, scalegroup: { valType: "string", dflt: "", editType: "calc" }, scalemode: { valType: "enumerated", values: ["width", "count"], dflt: "width", editType: "calc" }, spanmode: { valType: "enumerated", values: ["soft", "hard", "manual"], dflt: "soft", editType: "calc" }, span: { valType: "info_array", items: [{ valType: "any", editType: "calc" }, { valType: "any", editType: "calc" }], editType: "calc" }, line: { color: { valType: "color", editType: "style" }, width: { valType: "number", min: 0, dflt: 2, editType: "style" }, editType: "plot" }, fillcolor: qh.fillcolor, points: XT({}, qh.boxpoints, {}), jitter: XT({}, qh.jitter, {}), pointpos: XT({}, qh.pointpos, {}), width: XT({}, qh.width, {}), marker: qh.marker, text: qh.text, hovertext: qh.hovertext, hovertemplate: qh.hovertemplate, hovertemplatefallback: qh.hovertemplatefallback, quartilemethod: qh.quartilemethod, box: { visible: { valType: "boolean", dflt: false, editType: "plot" }, width: { valType: "number", min: 0, max: 1, dflt: 0.25, editType: "plot" }, fillcolor: { valType: "color", editType: "style" }, line: { color: { valType: "color", editType: "style" }, width: { valType: "number", min: 0, editType: "style" }, editType: "style" }, editType: "plot" }, meanline: { visible: { valType: "boolean", dflt: false, editType: "plot" }, color: { valType: "color", editType: "style" }, width: { valType: "number", min: 0, editType: "style" }, editType: "plot" }, side: { valType: "enumerated", values: ["both", "positive", "negative"], dflt: "both", editType: "calc" }, offsetgroup: qh.offsetgroup, alignmentgroup: qh.alignmentgroup, selected: qh.selected, unselected: qh.unselected, hoveron: { valType: "flaglist", flags: ["violins", "points", "kde"], dflt: "violins+points+kde", extras: ["all"], editType: "style" }, zorder: qh.zorder };
+      });
+      var XG = ye((nfr, X2e) => {
+        var jG = C4(), WG = Dr().extendFlat;
+        X2e.exports = { violinmode: WG({}, jG.boxmode, {}), violingap: WG({}, jG.boxgap, {}), violingroupgap: WG({}, jG.boxgroupgap, {}) };
+      });
+      var $2e = ye((afr, J2e) => {
+        var Z2e = Dr(), gwt = ka(), Y2e = P4(), K2e = HG();
+        J2e.exports = function(t, r, n, i) {
+          function a(L, x) {
+            return Z2e.coerce(t, r, K2e, L, x);
+          }
+          function o(L, x) {
+            return Z2e.coerce2(t, r, K2e, L, x);
+          }
+          if (Y2e.handleSampleDefaults(t, r, a, i), r.visible !== false) {
+            a("bandwidth"), a("side");
+            var s = a("width");
+            s || (a("scalegroup", r.name), a("scalemode"));
+            var l = a("span"), u;
+            Array.isArray(l) && (u = "manual"), a("spanmode", u);
+            var c = a("line.color", (t.marker || {}).color || n), f = a("line.width"), h = a("fillcolor", gwt.addOpacity(r.line.color, 0.5));
+            Y2e.handlePointsDefaults(t, r, a, { prefix: "" });
+            var d = o("box.width"), v = o("box.fillcolor", h), _ = o("box.line.color", c), b = o("box.line.width", f), p = a("box.visible", !!(d || v || _ || b));
+            p || (r.box = { visible: false });
+            var k = o("meanline.color", c), E = o("meanline.width", f), T = a("meanline.visible", !!(k || E));
+            T || (r.meanline = { visible: false }), a("quartilemethod"), a("zorder");
+          }
+        };
+      });
+      var ewe = ye((ofr, Q2e) => {
+        var mwt = Dr(), ywt = XG(), _wt = $I();
+        Q2e.exports = function(t, r, n) {
+          function i(a, o) {
+            return mwt.coerce(t, r, ywt, a, o);
+          }
+          _wt._supply(t, r, n, i, "violin");
+        };
+      });
+      var U8 = ye((g2) => {
+        var xwt = Dr(), bwt = { gaussian: function(e) {
+          return 1 / Math.sqrt(2 * Math.PI) * Math.exp(-0.5 * e * e);
+        } };
+        g2.makeKDE = function(e, t, r) {
+          var n = r.length, i = bwt.gaussian, a = e.bandwidth, o = 1 / (n * a);
+          return function(s) {
+            for (var l = 0, u = 0; u < n; u++) l += i((s - r[u]) / a);
+            return o * l;
+          };
+        };
+        g2.getPositionOnKdePath = function(e, t, r) {
+          var n, i;
+          t.orientation === "h" ? (n = "y", i = "x") : (n = "x", i = "y");
+          var a = xwt.findPointOnPath(e.path, r, i, { pathLength: e.pathLength }), o = e.posCenterPx, s = a[n], l = t.side === "both" ? 2 * o - s : o;
+          return [s, l];
+        };
+        g2.getKdeValue = function(e, t, r) {
+          var n = e.pts.map(g2.extractVal), i = g2.makeKDE(e, t, n);
+          return i(r) / e.posDensityScale;
+        };
+        g2.extractVal = function(e) {
+          return e.v;
+        };
+      });
+      var iwe = ye((lfr, rwe) => {
+        var ZG = Dr(), YG = ho(), wwt = NV(), twe = U8(), Twt = fs().BADNUM;
+        rwe.exports = function(t, r) {
+          var n = wwt(t, r);
+          if (n[0].t.empty) return n;
+          for (var i = t._fullLayout, a = YG.getFromId(t, r[r.orientation === "h" ? "xaxis" : "yaxis"]), o = 1 / 0, s = -1 / 0, l = 0, u = 0, c = 0; c < n.length; c++) {
+            var f = n[c], h = f.pts.map(twe.extractVal), d = f.bandwidth = Swt(r, f, h), v = f.span = Mwt(r, f, a, d);
+            if (f.min === f.max && d === 0) v = f.span = [f.min, f.max], f.density = [{ v: 1, t: v[0] }], f.bandwidth = d, l = Math.max(l, 1);
+            else {
+              var _ = v[1] - v[0], b = Math.ceil(_ / (d / 3)), p = _ / b;
+              if (!isFinite(p) || !isFinite(b)) return ZG.error("Something went wrong with computing the violin span"), n[0].t.empty = true, n;
+              var k = twe.makeKDE(f, r, h);
+              f.density = new Array(b + 1);
+              for (var E = 0; E < f.density.length; E++) {
+                var T = v[0] + E * p, L = k(T);
+                f.density[E] = { v: L, t: T }, l = Math.max(l, L);
+              }
+            }
+            u = Math.max(u, h.length), o = Math.min(o, v[0]), s = Math.max(s, v[1]);
+          }
+          var x = YG.findExtremes(a, [o, s], { padded: true });
+          if (r._extremes[a._id] = x, r.width) n[0].t.maxKDE = l;
+          else {
+            var C = i._violinScaleGroupStats, M = r.scalegroup, g = C[M];
+            g ? (g.maxKDE = Math.max(g.maxKDE, l), g.maxCount = Math.max(g.maxCount, u)) : C[M] = { maxKDE: l, maxCount: u };
+          }
+          return n[0].t.labels.kde = ZG._(t, "kde:"), n;
+        };
+        function Awt(e, t, r) {
+          var n = Math.min(t, r / 1.349);
+          return 1.059 * n * Math.pow(e, -0.2);
+        }
+        function Swt(e, t, r) {
+          var n = t.max - t.min;
+          if (!n) return e.bandwidth ? e.bandwidth : 0;
+          if (e.bandwidth) return Math.max(e.bandwidth, n / 1e4);
+          var i = r.length, a = ZG.stdev(r, i - 1, t.mean);
+          return Math.max(Awt(i, a, t.q3 - t.q1), n / 100);
+        }
+        function Mwt(e, t, r, n) {
+          var i = e.spanmode, a = e.span || [], o = [t.min, t.max], s = [t.min - 2 * n, t.max + 2 * n], l;
+          function u(f) {
+            var h = a[f], d = r.type === "multicategory" ? r.r2c(h) : r.d2c(h, 0, e[t.valLetter + "calendar"]);
+            return d === Twt ? s[f] : d;
+          }
+          i === "soft" ? l = s : i === "hard" ? l = o : l = [u(0), u(1)];
+          var c = { type: "linear", range: l };
+          return YG.setConvert(c), c.cleanRange(), l;
+        }
+      });
+      var owe = ye((ufr, awe) => {
+        var Ewt = e8().setPositionOffset, nwe = ["v", "h"];
+        awe.exports = function(t, r) {
+          for (var n = t.calcdata, i = r.xaxis, a = r.yaxis, o = 0; o < nwe.length; o++) {
+            for (var s = nwe[o], l = s === "h" ? a : i, u = [], c = 0; c < n.length; c++) {
+              var f = n[c], h = f[0].t, d = f[0].trace;
+              d.visible === true && d.type === "violin" && !h.empty && d.orientation === s && d.xaxis === i._id && d.yaxis === a._id && u.push(c);
+            }
+            Ewt("violin", t, u, l);
+          }
+        };
+      });
+      var lwe = ye((cfr, swe) => {
+        var KG = Oa(), JG = Dr(), kwt = So(), $G = t8(), Cwt = AU(), Lwt = U8();
+        swe.exports = function(t, r, n, i) {
+          var a = t._context.staticPlot, o = t._fullLayout, s = r.xaxis, l = r.yaxis;
+          function u(c, f) {
+            var h = Cwt(c, { xaxis: s, yaxis: l, trace: f, connectGaps: true, baseTolerance: 0.75, shape: "spline", simplify: true, linearized: true });
+            return kwt.smoothopen(h[0], 1);
+          }
+          JG.makeTraceGroups(i, n, "trace violins").each(function(c) {
+            var f = KG.select(this), h = c[0], d = h.t, v = h.trace;
+            if (v.visible !== true || d.empty) {
+              f.remove();
+              return;
+            }
+            var _ = d.bPos, b = d.bdPos, p = r[d.valLetter + "axis"], k = r[d.posLetter + "axis"], E = v.side === "both", T = E || v.side === "positive", L = E || v.side === "negative", x = f.selectAll("path.violin").data(JG.identity);
+            x.enter().append("path").style("vector-effect", a ? "none" : "non-scaling-stroke").attr("class", "violin"), x.exit().remove(), x.each(function(U) {
+              var G = KG.select(this), Z = U.density, j = Z.length, N = k.c2l(U.pos + _, true), H = k.l2p(N), re;
+              if (v.width) re = d.maxKDE / b;
+              else {
+                var oe = o._violinScaleGroupStats[v.scalegroup];
+                re = v.scalemode === "count" ? oe.maxKDE / b * (oe.maxCount / U.pts.length) : oe.maxKDE / b;
+              }
+              var _e, Ce, Le, ge, ie, Se, Ee;
+              if (T) {
+                for (Se = new Array(j), ge = 0; ge < j; ge++) Ee = Se[ge] = {}, Ee[d.posLetter] = N + Z[ge].v / re, Ee[d.valLetter] = p.c2l(Z[ge].t, true);
+                _e = u(Se, v);
+              }
+              if (L) {
+                for (Se = new Array(j), ie = 0, ge = j - 1; ie < j; ie++, ge--) Ee = Se[ie] = {}, Ee[d.posLetter] = N - Z[ge].v / re, Ee[d.valLetter] = p.c2l(Z[ge].t, true);
+                Ce = u(Se, v);
+              }
+              if (E) Le = _e + "L" + Ce.slice(1) + "Z";
+              else {
+                var Ae = [H, p.c2p(Z[0].t)], Be = [H, p.c2p(Z[j - 1].t)];
+                v.orientation === "h" && (Ae.reverse(), Be.reverse()), T ? Le = "M" + Ae + "L" + _e.slice(1) + "L" + Be : Le = "M" + Be + "L" + Ce.slice(1) + "L" + Ae;
+              }
+              G.attr("d", Le), U.posCenterPx = H, U.posDensityScale = re * b, U.path = G.node(), U.pathLength = U.path.getTotalLength() / (E ? 2 : 1);
+            });
+            var C = v.box, M = C.width, g = (C.line || {}).width, P, A;
+            E ? (P = b * M, A = 0) : T ? (P = [0, b * M / 2], A = g * { x: 1, y: -1 }[d.posLetter]) : (P = [b * M / 2, 0], A = g * { x: -1, y: 1 }[d.posLetter]), $G.plotBoxAndWhiskers(f, { pos: k, val: p }, v, { bPos: _, bdPos: P, bPosPxOffset: A }), $G.plotBoxMean(f, { pos: k, val: p }, v, { bPos: _, bdPos: P, bPosPxOffset: A });
+            var z;
+            !v.box.visible && v.meanline.visible && (z = JG.identity);
+            var O = f.selectAll("path.meanline").data(z || []);
+            O.enter().append("path").attr("class", "meanline").style("fill", "none").style("vector-effect", a ? "none" : "non-scaling-stroke"), O.exit().remove(), O.each(function(U) {
+              var G = p.c2p(U.mean, true), Z = Lwt.getPositionOnKdePath(U, v, G);
+              KG.select(this).attr("d", v.orientation === "h" ? "M" + G + "," + Z[0] + "V" + Z[1] : "M" + Z[0] + "," + G + "H" + Z[1]);
+            }), $G.plotPoints(f, { x: s, y: l }, v, d);
+          });
+        };
+      });
+      var fwe = ye((ffr, cwe) => {
+        var uwe = Oa(), ZT = ka(), Pwt = sp().stylePoints;
+        cwe.exports = function(t) {
+          var r = uwe.select(t).selectAll("g.trace.violins");
+          r.style("opacity", function(n) {
+            return n[0].trace.opacity;
+          }), r.each(function(n) {
+            var i = n[0].trace, a = uwe.select(this), o = i.box || {}, s = o.line || {}, l = i.meanline || {}, u = l.width;
+            a.selectAll("path.violin").style("stroke-width", i.line.width + "px").call(ZT.stroke, i.line.color).call(ZT.fill, i.fillcolor), a.selectAll("path.box").style("stroke-width", s.width + "px").call(ZT.stroke, s.color).call(ZT.fill, o.fillcolor);
+            var c = { "stroke-width": u + "px", "stroke-dasharray": 2 * u + "px," + u + "px" };
+            a.selectAll("path.mean").style(c).call(ZT.stroke, l.color), a.selectAll("path.meanline").style(c).call(ZT.stroke, l.color), Pwt(a, i, t);
+          });
+        };
+      });
+      var pwe = ye((hfr, vwe) => {
+        var Iwt = ka(), QG = Dr(), Rwt = ho(), hwe = jV(), dwe = U8();
+        vwe.exports = function(t, r, n, i, a) {
+          a || (a = {});
+          var o = a.hoverLayer, s = t.cd, l = s[0].trace, u = l.hoveron, c = u.indexOf("violins") !== -1, f = u.indexOf("kde") !== -1, h = [], d, v;
+          if (c || f) {
+            var _ = hwe.hoverOnBoxes(t, r, n, i);
+            if (f && _.length > 0) {
+              var b = t.xa, p = t.ya, k, E, T, L, x;
+              l.orientation === "h" ? (x = r, k = "y", T = p, E = "x", L = b) : (x = n, k = "x", T = b, E = "y", L = p);
+              var C = s[t.index];
+              if (x >= C.span[0] && x <= C.span[1]) {
+                var M = QG.extendFlat({}, t), g = L.c2p(x, true), P = dwe.getKdeValue(C, l, x), A = dwe.getPositionOnKdePath(C, l, g), z = T._offset, O = T._length;
+                M[k + "0"] = A[0], M[k + "1"] = A[1], M[E + "0"] = M[E + "1"] = g, M[E + "Label"] = E + ": " + Rwt.hoverLabelText(L, x, l[E + "hoverformat"]) + ", " + s[0].t.labels.kde + " " + P.toFixed(3);
+                for (var U = 0, G = 0; G < _.length; G++) if (_[G].attr === "med") {
+                  U = G;
+                  break;
+                }
+                M.spikeDistance = _[U].spikeDistance;
+                var Z = k + "Spike";
+                M[Z] = _[U][Z], _[U].spikeDistance = void 0, _[U][Z] = void 0, M.hovertemplate = false, h.push(M), v = {}, v[k + "1"] = QG.constrain(z + A[0], z, z + O), v[k + "2"] = QG.constrain(z + A[1], z, z + O), v[E + "1"] = v[E + "2"] = L._offset + g;
+              }
+            }
+            c && (h = h.concat(_));
+          }
+          u.indexOf("points") !== -1 && (d = hwe.hoverOnPoints(t, r, n));
+          var j = o.selectAll(".violinline-" + l.uid).data(v ? [0] : []);
+          return j.enter().append("line").classed("violinline-" + l.uid, true).attr("stroke-width", 1.5), j.exit().remove(), j.attr(v).call(Iwt.stroke, t.color), i === "closest" ? d ? [d] : h : (d && h.push(d), h);
+        };
+      });
+      var mwe = ye((dfr, gwe) => {
+        gwe.exports = { attributes: HG(), layoutAttributes: XG(), supplyDefaults: $2e(), crossTraceDefaults: P4().crossTraceDefaults, supplyLayoutDefaults: ewe(), calc: iwe(), crossTraceCalc: owe(), plot: lwe(), style: fwe(), styleOnSelect: sp().styleOnSelect, hoverPoints: pwe(), selectPoints: WV(), moduleType: "trace", name: "violin", basePlotModule: mh(), categories: ["cartesian", "svg", "symbols", "oriented", "box-violin", "showLegend", "violinLayout", "zoomScale"], meta: {} };
+      });
+      var _we = ye((vfr, ywe) => {
+        ywe.exports = mwe();
+      });
+      var bwe = ye((pfr, xwe) => {
+        xwe.exports = { eventDataKeys: ["percentInitial", "percentPrevious", "percentTotal"] };
+      });
+      var tH = ye((gfr, Swe) => {
+        var jc = zm(), eH = pf().line, Dwt = Gl(), wwe = df().axisHoverFormat, { hovertemplateAttrs: Fwt, texttemplateAttrs: zwt, templatefallbackAttrs: Twe } = Ll(), Awe = bwe(), Xy = Ao().extendFlat, Owt = ka();
+        Swe.exports = { x: jc.x, x0: jc.x0, dx: jc.dx, y: jc.y, y0: jc.y0, dy: jc.dy, xperiod: jc.xperiod, yperiod: jc.yperiod, xperiod0: jc.xperiod0, yperiod0: jc.yperiod0, xperiodalignment: jc.xperiodalignment, yperiodalignment: jc.yperiodalignment, xhoverformat: wwe("x"), yhoverformat: wwe("y"), hovertext: jc.hovertext, hovertemplate: Fwt({}, { keys: Awe.eventDataKeys }), hovertemplatefallback: Twe(), hoverinfo: Xy({}, Dwt.hoverinfo, { flags: ["name", "x", "y", "text", "percent initial", "percent previous", "percent total"] }), textinfo: { valType: "flaglist", flags: ["label", "text", "percent initial", "percent previous", "percent total", "value"], extras: ["none"], editType: "plot", arrayOk: false }, texttemplate: zwt({ editType: "plot" }, { keys: Awe.eventDataKeys.concat(["label", "value"]) }), texttemplatefallback: Twe({ editType: "plot" }), text: jc.text, textposition: jc.textposition, insidetextanchor: Xy({}, jc.insidetextanchor, { dflt: "middle" }), textangle: Xy({}, jc.textangle, { dflt: 0 }), textfont: jc.textfont, insidetextfont: jc.insidetextfont, outsidetextfont: jc.outsidetextfont, constraintext: jc.constraintext, cliponaxis: jc.cliponaxis, orientation: Xy({}, jc.orientation, {}), offset: Xy({}, jc.offset, { arrayOk: false }), width: Xy({}, jc.width, { arrayOk: false }), marker: qwt(), connector: { fillcolor: { valType: "color", editType: "style" }, line: { color: Xy({}, eH.color, { dflt: Owt.defaultLine }), width: Xy({}, eH.width, { dflt: 0, editType: "plot" }), dash: eH.dash, editType: "style" }, visible: { valType: "boolean", dflt: true, editType: "plot" }, editType: "plot" }, offsetgroup: jc.offsetgroup, alignmentgroup: jc.alignmentgroup, zorder: jc.zorder };
+        function qwt() {
+          var e = Xy({}, jc.marker);
+          return delete e.pattern, delete e.cornerradius, e;
+        }
+      });
+      var rH = ye((mfr, Mwe) => {
+        Mwe.exports = { funnelmode: { valType: "enumerated", values: ["stack", "group", "overlay"], dflt: "stack", editType: "calc" }, funnelgap: { valType: "number", min: 0, max: 1, editType: "calc" }, funnelgroupgap: { valType: "number", min: 0, max: 1, dflt: 0, editType: "calc" } };
+      });
+      var nH = ye((yfr, kwe) => {
+        var V8 = Dr(), Bwt = e2(), Nwt = i0().handleText, Uwt = oT(), Vwt = Dg(), Ewe = tH(), iH = ka();
+        function Gwt(e, t, r, n) {
+          function i(f, h) {
+            return V8.coerce(e, t, Ewe, f, h);
+          }
+          var a = Uwt(e, t, n, i);
+          if (!a) {
+            t.visible = false;
+            return;
+          }
+          Vwt(e, t, n, i), i("xhoverformat"), i("yhoverformat"), i("orientation", t.y && !t.x ? "v" : "h"), i("offset"), i("width");
+          var o = i("text");
+          i("hovertext"), i("hovertemplate"), i("hovertemplatefallback");
+          var s = i("textposition");
+          Nwt(e, t, n, i, s, { moduleHasSelected: false, moduleHasUnselected: false, moduleHasConstrain: true, moduleHasCliponaxis: true, moduleHasTextangle: true, moduleHasInsideanchor: true }), t.textposition !== "none" && !t.texttemplate && i("textinfo", V8.isArrayOrTypedArray(o) ? "text+value" : "value");
+          var l = i("marker.color", r);
+          i("marker.line.color", iH.defaultLine), i("marker.line.width");
+          var u = i("connector.visible");
+          if (u) {
+            i("connector.fillcolor", Hwt(l));
+            var c = i("connector.line.width");
+            c && (i("connector.line.color"), i("connector.line.dash"));
+          }
+          i("zorder");
+        }
+        function Hwt(e) {
+          var t = V8.isArrayOrTypedArray(e) ? "#000" : e;
+          return iH.addOpacity(t, 0.5 * iH.opacity(t));
+        }
+        function jwt(e, t) {
+          var r, n;
+          function i(o) {
+            return V8.coerce(n._input, n, Ewe, o);
+          }
+          for (var a = 0; a < e.length; a++) n = e[a], n.type === "funnel" && (r = n._input, Bwt(r, n, t, i, t.funnelmode));
+        }
+        kwe.exports = { supplyDefaults: Gwt, crossTraceDefaults: jwt };
+      });
+      var Lwe = ye((_fr, Cwe) => {
+        var Wwt = Dr(), Xwt = rH();
+        Cwe.exports = function(e, t, r) {
+          var n = false;
+          function i(s, l) {
+            return Wwt.coerce(e, t, Xwt, s, l);
+          }
+          for (var a = 0; a < r.length; a++) {
+            var o = r[a];
+            if (o.visible && o.type === "funnel") {
+              n = true;
+              break;
+            }
+          }
+          n && (i("funnelmode"), i("funnelgap", 0.2), i("funnelgroupgap"));
+        };
+      });
+      var Iwe = ye((xfr, Pwe) => {
+        var YT = Dr();
+        Pwe.exports = function(t, r) {
+          for (var n = 0; n < t.length; n++) t[n].i = n;
+          YT.mergeArray(r.text, t, "tx"), YT.mergeArray(r.hovertext, t, "htx");
+          var i = r.marker;
+          if (i) {
+            YT.mergeArray(i.opacity, t, "mo"), YT.mergeArray(i.color, t, "mc");
+            var a = i.line;
+            a && (YT.mergeArray(a.color, t, "mlc"), YT.mergeArrayCastPositive(a.width, t, "mlw"));
+          }
+        };
+      });
+      var zwe = ye((bfr, Fwe) => {
+        var Rwe = ho(), Dwe = zg(), Zwt = Iwe(), Ywt = O0(), j4 = fs().BADNUM;
+        Fwe.exports = function(t, r) {
+          var n = Rwe.getFromId(t, r.xaxis || "x"), i = Rwe.getFromId(t, r.yaxis || "y"), a, o, s, l, u, c, f, h;
+          r.orientation === "h" ? (a = n.makeCalcdata(r, "x"), s = i.makeCalcdata(r, "y"), l = Dwe(r, i, "y", s), u = !!r.yperiodalignment, c = "y") : (a = i.makeCalcdata(r, "y"), s = n.makeCalcdata(r, "x"), l = Dwe(r, n, "x", s), u = !!r.xperiodalignment, c = "x"), o = l.vals;
+          var d = Math.min(o.length, a.length), v = new Array(d);
+          for (r._base = [], f = 0; f < d; f++) {
+            a[f] < 0 && (a[f] = j4);
+            var _ = false;
+            a[f] !== j4 && f + 1 < d && a[f + 1] !== j4 && (_ = true), h = v[f] = { p: o[f], s: a[f], cNext: _ }, r._base[f] = -0.5 * h.s, u && (v[f].orig_p = s[f], v[f][c + "End"] = l.ends[f], v[f][c + "Start"] = l.starts[f]), r.ids && (h.id = String(r.ids[f])), f === 0 && (v[0].vTotal = 0), v[0].vTotal += aH(h.s), h.begR = aH(h.s) / aH(v[0].s);
+          }
+          var b;
+          for (f = 0; f < d; f++) h = v[f], h.s !== j4 && (h.sumR = h.s / v[0].vTotal, h.difR = b !== void 0 ? h.s / b : 1, b = h.s);
+          return Zwt(v, r), Ywt(v, r), v;
+        };
+        function aH(e) {
+          return e === j4 ? 0 : e;
+        }
+      });
+      var Bwe = ye((wfr, qwe) => {
+        var Owe = t2().setGroupPositions;
+        qwe.exports = function(t, r) {
+          var n = t._fullLayout, i = t._fullData, a = t.calcdata, o = r.xaxis, s = r.yaxis, l = [], u = [], c = [], f, h;
+          for (h = 0; h < i.length; h++) {
+            var d = i[h], v = d.orientation === "h";
+            d.visible === true && d.xaxis === o._id && d.yaxis === s._id && d.type === "funnel" && (f = a[h], v ? c.push(f) : u.push(f), l.push(f));
+          }
+          var _ = { mode: n.funnelmode, norm: n.funnelnorm, gap: n.funnelgap, groupgap: n.funnelgroupgap };
+          for (Owe(t, o, s, u, _), Owe(t, s, o, c, _), h = 0; h < l.length; h++) {
+            f = l[h];
+            for (var b = 0; b < f.length; b++) b + 1 < f.length && (f[b].nextP0 = f[b + 1].p0, f[b].nextS0 = f[b + 1].s0, f[b].nextP1 = f[b + 1].p1, f[b].nextS1 = f[b + 1].s1);
+          }
+        };
+      });
+      var Gwe = ye((Tfr, Vwe) => {
+        var G8 = Oa(), B_ = Dr(), Nwe = So(), q_ = fs().BADNUM, Kwt = d2(), Jwt = bv().clearMinTextSize;
+        Vwe.exports = function(t, r, n, i) {
+          var a = t._fullLayout;
+          Jwt("funnel", a), $wt(t, r, n, i), Qwt(t, r, n, i), Kwt.plot(t, r, n, i, { mode: a.funnelmode, norm: a.funnelmode, gap: a.funnelgap, groupgap: a.funnelgroupgap });
+        };
+        function $wt(e, t, r, n) {
+          var i = t.xaxis, a = t.yaxis;
+          B_.makeTraceGroups(n, r, "trace bars").each(function(o) {
+            var s = G8.select(this), l = o[0].trace, u = B_.ensureSingle(s, "g", "regions");
+            if (!l.connector || !l.connector.visible) {
+              u.remove();
+              return;
+            }
+            var c = l.orientation === "h", f = u.selectAll("g.region").data(B_.identity);
+            f.enter().append("g").classed("region", true), f.exit().remove();
+            var h = f.size();
+            f.each(function(d, v) {
+              if (!(v !== h - 1 && !d.cNext)) {
+                var _ = Uwe(d, i, a, c), b = _[0], p = _[1], k = "";
+                b[0] !== q_ && p[0] !== q_ && b[1] !== q_ && p[1] !== q_ && b[2] !== q_ && p[2] !== q_ && b[3] !== q_ && p[3] !== q_ && (c ? k += "M" + b[0] + "," + p[1] + "L" + b[2] + "," + p[2] + "H" + b[3] + "L" + b[1] + "," + p[1] + "Z" : k += "M" + b[1] + "," + p[1] + "L" + b[2] + "," + p[3] + "V" + p[2] + "L" + b[1] + "," + p[0] + "Z"), k === "" && (k = "M0,0Z"), B_.ensureSingle(G8.select(this), "path").attr("d", k).call(Nwe.setClipUrl, t.layerClipId, e);
+              }
+            });
+          });
+        }
+        function Qwt(e, t, r, n) {
+          var i = t.xaxis, a = t.yaxis;
+          B_.makeTraceGroups(n, r, "trace bars").each(function(o) {
+            var s = G8.select(this), l = o[0].trace, u = B_.ensureSingle(s, "g", "lines");
+            if (!l.connector || !l.connector.visible || !l.connector.line.width) {
+              u.remove();
+              return;
+            }
+            var c = l.orientation === "h", f = u.selectAll("g.line").data(B_.identity);
+            f.enter().append("g").classed("line", true), f.exit().remove();
+            var h = f.size();
+            f.each(function(d, v) {
+              if (!(v !== h - 1 && !d.cNext)) {
+                var _ = Uwe(d, i, a, c), b = _[0], p = _[1], k = "";
+                b[3] !== void 0 && p[3] !== void 0 && (c ? (k += "M" + b[0] + "," + p[1] + "L" + b[2] + "," + p[2], k += "M" + b[1] + "," + p[1] + "L" + b[3] + "," + p[2]) : (k += "M" + b[1] + "," + p[1] + "L" + b[2] + "," + p[3], k += "M" + b[1] + "," + p[0] + "L" + b[2] + "," + p[2])), k === "" && (k = "M0,0Z"), B_.ensureSingle(G8.select(this), "path").attr("d", k).call(Nwe.setClipUrl, t.layerClipId, e);
+              }
+            });
+          });
+        }
+        function Uwe(e, t, r, n) {
+          var i = [], a = [], o = n ? t : r, s = n ? r : t;
+          return i[0] = o.c2p(e.s0, true), a[0] = s.c2p(e.p0, true), i[1] = o.c2p(e.s1, true), a[1] = s.c2p(e.p1, true), i[2] = o.c2p(e.nextS0, true), a[2] = s.c2p(e.nextP0, true), i[3] = o.c2p(e.nextS1, true), a[3] = s.c2p(e.nextP1, true), n ? [i, a] : [a, i];
+        }
+      });
+      var Wwe = ye((Afr, jwe) => {
+        var W4 = Oa(), Hwe = So(), oH = ka(), e3t = X1().DESELECTDIM, t3t = V0(), r3t = bv().resizeText, i3t = t3t.styleTextPoints;
+        function n3t(e, t, r) {
+          var n = r || W4.select(e).selectAll('g[class^="funnellayer"]').selectAll("g.trace");
+          r3t(e, n, "funnel"), n.style("opacity", function(i) {
+            return i[0].trace.opacity;
+          }), n.each(function(i) {
+            var a = W4.select(this), o = i[0].trace;
+            a.selectAll(".point > path").each(function(s) {
+              if (!s.isBlank) {
+                var l = o.marker;
+                W4.select(this).call(oH.fill, s.mc || l.color).call(oH.stroke, s.mlc || l.line.color).call(Hwe.dashLine, l.line.dash, s.mlw || l.line.width).style("opacity", o.selectedpoints && !s.selected ? e3t : 1);
+              }
+            }), i3t(a, o, e), a.selectAll(".regions").each(function() {
+              W4.select(this).selectAll("path").style("stroke-width", 0).call(oH.fill, o.connector.fillcolor);
+            }), a.selectAll(".lines").each(function() {
+              var s = o.connector.line;
+              Hwe.lineGroupStyle(W4.select(this).selectAll("path"), s.width, s.color, s.dash);
+            });
+          });
+        }
+        jwe.exports = { style: n3t };
+      });
+      var Ywe = ye((Sfr, Zwe) => {
+        var Xwe = ka().opacity, a3t = PT().hoverOnBars, sH = Dr().formatPercent;
+        Zwe.exports = function(t, r, n, i, a) {
+          var o = a3t(t, r, n, i, a);
+          if (o) {
+            var s = o.cd, l = s[0].trace, u = l.orientation === "h", c = o.index, f = s[c], h = u ? "x" : "y";
+            o[h + "LabelVal"] = f.s, o.percentInitial = f.begR, o.percentInitialLabel = sH(f.begR, 1), o.percentPrevious = f.difR, o.percentPreviousLabel = sH(f.difR, 1), o.percentTotal = f.sumR, o.percentTotalLabel = sH(f.sumR, 1);
+            var d = f.hi || l.hoverinfo, v = [];
+            if (d && d !== "none" && d !== "skip") {
+              var _ = d === "all", b = d.split("+"), p = function(k) {
+                return _ || b.indexOf(k) !== -1;
+              };
+              p("percent initial") && v.push(o.percentInitialLabel + " of initial"), p("percent previous") && v.push(o.percentPreviousLabel + " of previous"), p("percent total") && v.push(o.percentTotalLabel + " of total");
+            }
+            return o.extraText = v.join("<br>"), o.color = o3t(l, f), [o];
+          }
+        };
+        function o3t(e, t) {
+          var r = e.marker, n = t.mc || r.color, i = t.mlc || r.line.color, a = t.mlw || r.line.width;
+          if (Xwe(n)) return n;
+          if (Xwe(i) && a) return i;
+        }
+      });
+      var Jwe = ye((Mfr, Kwe) => {
+        Kwe.exports = function(t, r) {
+          return t.x = "xVal" in r ? r.xVal : r.x, t.y = "yVal" in r ? r.yVal : r.y, "percentInitial" in r && (t.percentInitial = r.percentInitial), "percentPrevious" in r && (t.percentPrevious = r.percentPrevious), "percentTotal" in r && (t.percentTotal = r.percentTotal), r.xa && (t.xaxis = r.xa), r.ya && (t.yaxis = r.ya), t;
+        };
+      });
+      var Qwe = ye((Efr, $we) => {
+        $we.exports = { attributes: tH(), layoutAttributes: rH(), supplyDefaults: nH().supplyDefaults, crossTraceDefaults: nH().crossTraceDefaults, supplyLayoutDefaults: Lwe(), calc: zwe(), crossTraceCalc: Bwe(), plot: Gwe(), style: Wwe().style, hoverPoints: Ywe(), eventData: Jwe(), selectPoints: IT(), moduleType: "trace", name: "funnel", basePlotModule: mh(), categories: ["bar-like", "cartesian", "svg", "oriented", "showLegend", "zoomScale"], meta: {} };
+      });
+      var t3e = ye((kfr, e3e) => {
+        e3e.exports = Qwe();
+      });
+      var i3e = ye((Cfr, r3e) => {
+        r3e.exports = { eventDataKeys: ["initial", "delta", "final"] };
+      });
+      var cH = ye((Lfr, s3e) => {
+        var _c = zm(), lH = pf().line, s3t = Gl(), n3e = df().axisHoverFormat, { hovertemplateAttrs: l3t, texttemplateAttrs: u3t, templatefallbackAttrs: a3e } = Ll(), o3e = i3e(), KT = Ao().extendFlat, c3t = ka();
+        function uH(e) {
+          return { marker: { color: KT({}, _c.marker.color, { arrayOk: false, editType: "style" }), line: { color: KT({}, _c.marker.line.color, { arrayOk: false, editType: "style" }), width: KT({}, _c.marker.line.width, { arrayOk: false, editType: "style" }), editType: "style" }, editType: "style" }, editType: "style" };
+        }
+        s3e.exports = { measure: { valType: "data_array", dflt: [], editType: "calc" }, base: { valType: "number", dflt: null, arrayOk: false, editType: "calc" }, x: _c.x, x0: _c.x0, dx: _c.dx, y: _c.y, y0: _c.y0, dy: _c.dy, xperiod: _c.xperiod, yperiod: _c.yperiod, xperiod0: _c.xperiod0, yperiod0: _c.yperiod0, xperiodalignment: _c.xperiodalignment, yperiodalignment: _c.yperiodalignment, xhoverformat: n3e("x"), yhoverformat: n3e("y"), hovertext: _c.hovertext, hovertemplate: l3t({}, { keys: o3e.eventDataKeys }), hovertemplatefallback: a3e(), hoverinfo: KT({}, s3t.hoverinfo, { flags: ["name", "x", "y", "text", "initial", "delta", "final"] }), textinfo: { valType: "flaglist", flags: ["label", "text", "initial", "delta", "final"], extras: ["none"], editType: "plot", arrayOk: false }, texttemplate: u3t({ editType: "plot" }, { keys: o3e.eventDataKeys.concat(["label"]) }), texttemplatefallback: a3e({ editType: "plot" }), text: _c.text, textposition: _c.textposition, insidetextanchor: _c.insidetextanchor, textangle: _c.textangle, textfont: _c.textfont, insidetextfont: _c.insidetextfont, outsidetextfont: _c.outsidetextfont, constraintext: _c.constraintext, cliponaxis: _c.cliponaxis, orientation: _c.orientation, offset: _c.offset, width: _c.width, increasing: uH(), decreasing: uH(), totals: uH(), connector: { line: { color: KT({}, lH.color, { dflt: c3t.defaultLine }), width: KT({}, lH.width, { editType: "plot" }), dash: lH.dash, editType: "plot" }, mode: { valType: "enumerated", values: ["spanning", "between"], dflt: "between", editType: "plot" }, visible: { valType: "boolean", dflt: true, editType: "plot" }, editType: "plot" }, offsetgroup: _c.offsetgroup, alignmentgroup: _c.alignmentgroup, zorder: _c.zorder };
+      });
+      var fH = ye((Pfr, l3e) => {
+        l3e.exports = { waterfallmode: { valType: "enumerated", values: ["group", "overlay"], dflt: "group", editType: "calc" }, waterfallgap: { valType: "number", min: 0, max: 1, editType: "calc" }, waterfallgroupgap: { valType: "number", min: 0, max: 1, dflt: 0, editType: "calc" } };
+      });
+      var JT = ye((Ifr, u3e) => {
+        u3e.exports = { INCREASING: { COLOR: "#3D9970", SYMBOL: "▲" }, DECREASING: { COLOR: "#FF4136", SYMBOL: "▼" } };
+      });
+      var dH = ye((Rfr, d3e) => {
+        var c3e = Dr(), f3t = e2(), h3t = i0().handleText, d3t = oT(), v3t = Dg(), f3e = cH(), p3t = ka(), h3e = JT(), g3t = h3e.INCREASING.COLOR, m3t = h3e.DECREASING.COLOR, y3t = "#4499FF";
+        function hH(e, t, r) {
+          e(t + ".marker.color", r), e(t + ".marker.line.color", p3t.defaultLine), e(t + ".marker.line.width");
+        }
+        function _3t(e, t, r, n) {
+          function i(u, c) {
+            return c3e.coerce(e, t, f3e, u, c);
+          }
+          var a = d3t(e, t, n, i);
+          if (!a) {
+            t.visible = false;
+            return;
+          }
+          v3t(e, t, n, i), i("xhoverformat"), i("yhoverformat"), i("measure"), i("orientation", t.x && !t.y ? "h" : "v"), i("base"), i("offset"), i("width"), i("text"), i("hovertext"), i("hovertemplate"), i("hovertemplatefallback");
+          var o = i("textposition");
+          h3t(e, t, n, i, o, { moduleHasSelected: false, moduleHasUnselected: false, moduleHasConstrain: true, moduleHasCliponaxis: true, moduleHasTextangle: true, moduleHasInsideanchor: true }), t.textposition !== "none" && (i("texttemplate"), i("texttemplatefallback"), t.texttemplate || i("textinfo")), hH(i, "increasing", g3t), hH(i, "decreasing", m3t), hH(i, "totals", y3t);
+          var s = i("connector.visible");
+          if (s) {
+            i("connector.mode");
+            var l = i("connector.line.width");
+            l && (i("connector.line.color"), i("connector.line.dash"));
+          }
+          i("zorder");
+        }
+        function x3t(e, t) {
+          var r, n;
+          function i(o) {
+            return c3e.coerce(n._input, n, f3e, o);
+          }
+          if (t.waterfallmode === "group") for (var a = 0; a < e.length; a++) n = e[a], r = n._input, f3t(r, n, t, i, t.waterfallmode);
+        }
+        d3e.exports = { supplyDefaults: _3t, crossTraceDefaults: x3t };
+      });
+      var p3e = ye((Dfr, v3e) => {
+        var b3t = Dr(), w3t = fH();
+        v3e.exports = function(e, t, r) {
+          var n = false;
+          function i(s, l) {
+            return b3t.coerce(e, t, w3t, s, l);
+          }
+          for (var a = 0; a < r.length; a++) {
+            var o = r[a];
+            if (o.visible && o.type === "waterfall") {
+              n = true;
+              break;
+            }
+          }
+          n && (i("waterfallmode"), i("waterfallgap", 0.2), i("waterfallgroupgap"));
+        };
+      });
+      var b3e = ye((Ffr, x3e) => {
+        var g3e = ho(), m3e = zg(), y3e = Dr().mergeArray, T3t = O0(), _3e = fs().BADNUM;
+        function vH(e) {
+          return e === "a" || e === "absolute";
+        }
+        function pH(e) {
+          return e === "t" || e === "total";
+        }
+        x3e.exports = function(t, r) {
+          var n = g3e.getFromId(t, r.xaxis || "x"), i = g3e.getFromId(t, r.yaxis || "y"), a, o, s, l, u, c;
+          r.orientation === "h" ? (a = n.makeCalcdata(r, "x"), s = i.makeCalcdata(r, "y"), l = m3e(r, i, "y", s), u = !!r.yperiodalignment, c = "y") : (a = i.makeCalcdata(r, "y"), s = n.makeCalcdata(r, "x"), l = m3e(r, n, "x", s), u = !!r.xperiodalignment, c = "x"), o = l.vals;
+          for (var f = Math.min(o.length, a.length), h = new Array(f), d = 0, v, _ = false, b = 0; b < f; b++) {
+            var p = a[b] || 0, k = false;
+            (a[b] !== _3e || pH(r.measure[b]) || vH(r.measure[b])) && b + 1 < f && (a[b + 1] !== _3e || pH(r.measure[b + 1]) || vH(r.measure[b + 1])) && (k = true);
+            var E = h[b] = { i: b, p: o[b], s: p, rawS: p, cNext: k };
+            vH(r.measure[b]) ? (d = E.s, E.isSum = true, E.dir = "totals", E.s = d) : pH(r.measure[b]) ? (E.isSum = true, E.dir = "totals", E.s = d) : (E.isSum = false, E.dir = E.rawS < 0 ? "decreasing" : "increasing", v = E.s, E.s = d + v, d += v), E.dir === "totals" && (_ = true), u && (h[b].orig_p = s[b], h[b][c + "End"] = l.ends[b], h[b][c + "Start"] = l.starts[b]), r.ids && (E.id = String(r.ids[b])), E.v = (r.base || 0) + d;
+          }
+          return h.length && (h[0].hasTotals = _), y3e(r.text, h, "tx"), y3e(r.hovertext, h, "htx"), T3t(h, r), h;
+        };
+      });
+      var A3e = ye((zfr, T3e) => {
+        var w3e = t2().setGroupPositions;
+        T3e.exports = function(t, r) {
+          var n = t._fullLayout, i = t._fullData, a = t.calcdata, o = r.xaxis, s = r.yaxis, l = [], u = [], c = [], f, h;
+          for (h = 0; h < i.length; h++) {
+            var d = i[h];
+            d.visible === true && d.xaxis === o._id && d.yaxis === s._id && d.type === "waterfall" && (f = a[h], d.orientation === "h" ? c.push(f) : u.push(f), l.push(f));
+          }
+          var v = { mode: n.waterfallmode, norm: n.waterfallnorm, gap: n.waterfallgap, groupgap: n.waterfallgroupgap };
+          for (w3e(t, o, s, u, v), w3e(t, s, o, c, v), h = 0; h < l.length; h++) {
+            f = l[h];
+            for (var _ = 0; _ < f.length; _++) {
+              var b = f[_];
+              b.isSum === false && (b.s0 += _ === 0 ? 0 : f[_ - 1].s), _ + 1 < f.length && (f[_].nextP0 = f[_ + 1].p0, f[_].nextS0 = f[_ + 1].s0);
+            }
+          }
+        };
+      });
+      var E3e = ye((Ofr, M3e) => {
+        var S3e = Oa(), H8 = Dr(), A3t = So(), $T = fs().BADNUM, S3t = d2(), M3t = bv().clearMinTextSize;
+        M3e.exports = function(t, r, n, i) {
+          var a = t._fullLayout;
+          M3t("waterfall", a), S3t.plot(t, r, n, i, { mode: a.waterfallmode, norm: a.waterfallmode, gap: a.waterfallgap, groupgap: a.waterfallgroupgap }), E3t(t, r, n, i);
+        };
+        function E3t(e, t, r, n) {
+          var i = t.xaxis, a = t.yaxis;
+          H8.makeTraceGroups(n, r, "trace bars").each(function(o) {
+            var s = S3e.select(this), l = o[0].trace, u = H8.ensureSingle(s, "g", "lines");
+            if (!l.connector || !l.connector.visible) {
+              u.remove();
+              return;
+            }
+            var c = l.orientation === "h", f = l.connector.mode, h = u.selectAll("g.line").data(H8.identity);
+            h.enter().append("g").classed("line", true), h.exit().remove();
+            var d = h.size();
+            h.each(function(v, _) {
+              if (!(_ !== d - 1 && !v.cNext)) {
+                var b = k3t(v, i, a, c), p = b[0], k = b[1], E = "";
+                p[0] !== $T && k[0] !== $T && p[1] !== $T && k[1] !== $T && (f === "spanning" && !v.isSum && _ > 0 && (c ? E += "M" + p[0] + "," + k[1] + "V" + k[0] : E += "M" + p[1] + "," + k[0] + "H" + p[0]), f !== "between" && (v.isSum || _ < d - 1) && (c ? E += "M" + p[1] + "," + k[0] + "V" + k[1] : E += "M" + p[0] + "," + k[1] + "H" + p[1]), p[2] !== $T && k[2] !== $T && (c ? E += "M" + p[1] + "," + k[1] + "V" + k[2] : E += "M" + p[1] + "," + k[1] + "H" + p[2])), E === "" && (E = "M0,0Z"), H8.ensureSingle(S3e.select(this), "path").attr("d", E).call(A3t.setClipUrl, t.layerClipId, e);
+              }
+            });
+          });
+        }
+        function k3t(e, t, r, n) {
+          var i = [], a = [], o = n ? t : r, s = n ? r : t;
+          return i[0] = o.c2p(e.s0, true), a[0] = s.c2p(e.p0, true), i[1] = o.c2p(e.s1, true), a[1] = s.c2p(e.p1, true), i[2] = o.c2p(e.nextS0, true), a[2] = s.c2p(e.nextP0, true), n ? [i, a] : [a, i];
+        }
+      });
+      var P3e = ye((qfr, L3e) => {
+        var j8 = Oa(), k3e = So(), C3e = ka(), C3t = X1().DESELECTDIM, L3t = V0(), P3t = bv().resizeText, I3t = L3t.styleTextPoints;
+        function R3t(e, t, r) {
+          var n = r || j8.select(e).selectAll('g[class^="waterfalllayer"]').selectAll("g.trace");
+          P3t(e, n, "waterfall"), n.style("opacity", function(i) {
+            return i[0].trace.opacity;
+          }), n.each(function(i) {
+            var a = j8.select(this), o = i[0].trace;
+            a.selectAll(".point > path").each(function(s) {
+              if (!s.isBlank) {
+                var l = o[s.dir].marker;
+                j8.select(this).call(C3e.fill, l.color).call(C3e.stroke, l.line.color).call(k3e.dashLine, l.line.dash, l.line.width).style("opacity", o.selectedpoints && !s.selected ? C3t : 1);
+              }
+            }), I3t(a, o, e), a.selectAll(".lines").each(function() {
+              var s = o.connector.line;
+              k3e.lineGroupStyle(j8.select(this).selectAll("path"), s.width, s.color, s.dash);
+            });
+          });
+        }
+        L3e.exports = { style: R3t };
+      });
+      var z3e = ye((Bfr, F3e) => {
+        var D3t = ho().hoverLabelText, I3e = ka().opacity, F3t = PT().hoverOnBars, R3e = JT(), D3e = { increasing: R3e.INCREASING.SYMBOL, decreasing: R3e.DECREASING.SYMBOL };
+        F3e.exports = function(t, r, n, i, a) {
+          var o = F3t(t, r, n, i, a);
+          if (!o) return;
+          var s = o.cd, l = s[0].trace, u = l.orientation === "h", c = u ? "x" : "y", f = u ? t.xa : t.ya;
+          function h(x) {
+            return D3t(f, x, l[c + "hoverformat"]);
+          }
+          var d = o.index, v = s[d], _ = v.isSum ? v.b + v.s : v.rawS;
+          o.initial = v.b + v.s - _, o.delta = _, o.final = o.initial + o.delta;
+          var b = h(Math.abs(o.delta));
+          o.deltaLabel = _ < 0 ? "(" + b + ")" : b, o.finalLabel = h(o.final), o.initialLabel = h(o.initial);
+          var p = v.hi || l.hoverinfo, k = [];
+          if (p && p !== "none" && p !== "skip") {
+            var E = p === "all", T = p.split("+"), L = function(x) {
+              return E || T.indexOf(x) !== -1;
+            };
+            v.isSum || (L("final") && (u ? !L("x") : !L("y")) && k.push(o.finalLabel), L("delta") && (_ < 0 ? k.push(o.deltaLabel + " " + D3e.decreasing) : k.push(o.deltaLabel + " " + D3e.increasing)), L("initial") && k.push("Initial: " + o.initialLabel));
+          }
+          return k.length && (o.extraText = k.join("<br>")), o.color = z3t(l, v), [o];
+        };
+        function z3t(e, t) {
+          var r = e[t.dir].marker, n = r.color, i = r.line.color, a = r.line.width;
+          if (I3e(n)) return n;
+          if (I3e(i) && a) return i;
+        }
+      });
+      var q3e = ye((Nfr, O3e) => {
+        O3e.exports = function(t, r) {
+          return t.x = "xVal" in r ? r.xVal : r.x, t.y = "yVal" in r ? r.yVal : r.y, "initial" in r && (t.initial = r.initial), "delta" in r && (t.delta = r.delta), "final" in r && (t.final = r.final), r.xa && (t.xaxis = r.xa), r.ya && (t.yaxis = r.ya), t;
+        };
+      });
+      var N3e = ye((Ufr, B3e) => {
+        B3e.exports = { attributes: cH(), layoutAttributes: fH(), supplyDefaults: dH().supplyDefaults, crossTraceDefaults: dH().crossTraceDefaults, supplyLayoutDefaults: p3e(), calc: b3e(), crossTraceCalc: A3e(), plot: E3e(), style: P3e().style, hoverPoints: z3e(), eventData: q3e(), selectPoints: IT(), moduleType: "trace", name: "waterfall", basePlotModule: mh(), categories: ["bar-like", "cartesian", "svg", "oriented", "showLegend", "zoomScale"], meta: {} };
+      });
+      var V3e = ye((Vfr, U3e) => {
+        U3e.exports = N3e();
+      });
+      var QT = ye((Gfr, G3e) => {
+        G3e.exports = { colormodel: { rgb: { min: [0, 0, 0], max: [255, 255, 255], fmt: function(e) {
+          return e.slice(0, 3);
+        }, suffix: ["", "", ""] }, rgba: { min: [0, 0, 0, 0], max: [255, 255, 255, 1], fmt: function(e) {
+          return e.slice(0, 4);
+        }, suffix: ["", "", "", ""] }, rgba256: { colormodel: "rgba", zminDflt: [0, 0, 0, 0], zmaxDflt: [255, 255, 255, 255], min: [0, 0, 0, 0], max: [255, 255, 255, 1], fmt: function(e) {
+          return e.slice(0, 4);
+        }, suffix: ["", "", "", ""] }, hsl: { min: [0, 0, 0], max: [360, 100, 100], fmt: function(e) {
+          var t = e.slice(0, 3);
+          return t[1] = t[1] + "%", t[2] = t[2] + "%", t;
+        }, suffix: ["°", "%", "%"] }, hsla: { min: [0, 0, 0, 0], max: [360, 100, 100, 1], fmt: function(e) {
+          var t = e.slice(0, 4);
+          return t[1] = t[1] + "%", t[2] = t[2] + "%", t;
+        }, suffix: ["°", "%", "%", ""] } } };
+      });
+      var gH = ye((Hfr, j3e) => {
+        var O3t = Gl(), q3t = pf().zorder, { hovertemplateAttrs: B3t, templatefallbackAttrs: N3t } = Ll(), H3e = Ao().extendFlat, U3t = QT().colormodel, Z4 = ["rgb", "rgba", "rgba256", "hsl", "hsla"], V3t = [], G3t = [];
+        for (eA = 0; eA < Z4.length; eA++) X4 = U3t[Z4[eA]], V3t.push("For the `" + Z4[eA] + "` colormodel, it is [" + (X4.zminDflt || X4.min).join(", ") + "]."), G3t.push("For the `" + Z4[eA] + "` colormodel, it is [" + (X4.zmaxDflt || X4.max).join(", ") + "].");
+        var X4, eA;
+        j3e.exports = H3e({ source: { valType: "string", editType: "calc" }, z: { valType: "data_array", editType: "calc" }, colormodel: { valType: "enumerated", values: Z4, editType: "calc" }, zsmooth: { valType: "enumerated", values: ["fast", false], dflt: false, editType: "plot" }, zmin: { valType: "info_array", items: [{ valType: "number", editType: "calc" }, { valType: "number", editType: "calc" }, { valType: "number", editType: "calc" }, { valType: "number", editType: "calc" }], editType: "calc" }, zmax: { valType: "info_array", items: [{ valType: "number", editType: "calc" }, { valType: "number", editType: "calc" }, { valType: "number", editType: "calc" }, { valType: "number", editType: "calc" }], editType: "calc" }, x0: { valType: "any", dflt: 0, editType: "calc+clearAxisTypes" }, y0: { valType: "any", dflt: 0, editType: "calc+clearAxisTypes" }, dx: { valType: "number", dflt: 1, editType: "calc", description: "Set the pixel's horizontal size." }, dy: { valType: "number", dflt: 1, editType: "calc", description: "Set the pixel's vertical size" }, text: { valType: "data_array", editType: "plot" }, hovertext: { valType: "data_array", editType: "plot" }, hoverinfo: H3e({}, O3t.hoverinfo, { flags: ["x", "y", "z", "color", "name", "text"], dflt: "x+y+z+text+name" }), hovertemplate: B3t({}, { keys: ["z", "color", "colormodel"] }), hovertemplatefallback: N3t(), zorder: q3t });
+      });
+      var Z3e = ye((jfr, X3e) => {
+        var H3t = Dr(), j3t = gH(), W3e = QT(), W3t = Oy().IMAGE_URL_PREFIX;
+        X3e.exports = function(t, r) {
+          function n(o, s) {
+            return H3t.coerce(t, r, j3t, o, s);
+          }
+          n("source"), r.source && !r.source.match(W3t) && delete r.source, r._hasSource = !!r.source;
+          var i = n("z");
+          if (r._hasZ = !(i === void 0 || !i.length || !i[0] || !i[0].length), !r._hasZ && !r._hasSource) {
+            r.visible = false;
+            return;
+          }
+          n("x0"), n("y0"), n("dx"), n("dy");
+          var a;
+          r._hasZ ? (n("colormodel", "rgb"), a = W3e.colormodel[r.colormodel], n("zmin", a.zminDflt || a.min), n("zmax", a.zmaxDflt || a.max)) : r._hasSource && (r.colormodel = "rgba256", a = W3e.colormodel[r.colormodel], r.zmin = a.zminDflt, r.zmax = a.zmaxDflt), n("zsmooth"), n("text"), n("hovertext"), n("hovertemplate"), n("hovertemplatefallback"), r._length = null, n("zorder");
+        };
+      });
+      var Zy = ye((Wfr, mH) => {
+        typeof Object.create == "function" ? mH.exports = function(t, r) {
+          r && (t.super_ = r, t.prototype = Object.create(r.prototype, { constructor: { value: t, enumerable: false, writable: true, configurable: true } }));
+        } : mH.exports = function(t, r) {
+          if (r) {
+            t.super_ = r;
+            var n = function() {
+            };
+            n.prototype = r.prototype, t.prototype = new n(), t.prototype.constructor = t;
+          }
+        };
+      });
+      var yH = ye((Xfr, Y3e) => {
+        Y3e.exports = Ab().EventEmitter;
+      });
+      var $3e = ye((W8) => {
+        W8.byteLength = Z3t;
+        W8.toByteArray = K3t;
+        W8.fromByteArray = Q3t;
+        var Gm = [], Y0 = [], X3t = typeof Uint8Array != "undefined" ? Uint8Array : Array, _H = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
+        for (m2 = 0, K3e = _H.length; m2 < K3e; ++m2) Gm[m2] = _H[m2], Y0[_H.charCodeAt(m2)] = m2;
+        var m2, K3e;
+        Y0[45] = 62;
+        Y0[95] = 63;
+        function J3e(e) {
+          var t = e.length;
+          if (t % 4 > 0) throw new Error("Invalid string. Length must be a multiple of 4");
+          var r = e.indexOf("=");
+          r === -1 && (r = t);
+          var n = r === t ? 0 : 4 - r % 4;
+          return [r, n];
+        }
+        function Z3t(e) {
+          var t = J3e(e), r = t[0], n = t[1];
+          return (r + n) * 3 / 4 - n;
+        }
+        function Y3t(e, t, r) {
+          return (t + r) * 3 / 4 - r;
+        }
+        function K3t(e) {
+          var t, r = J3e(e), n = r[0], i = r[1], a = new X3t(Y3t(e, n, i)), o = 0, s = i > 0 ? n - 4 : n, l;
+          for (l = 0; l < s; l += 4) t = Y0[e.charCodeAt(l)] << 18 | Y0[e.charCodeAt(l + 1)] << 12 | Y0[e.charCodeAt(l + 2)] << 6 | Y0[e.charCodeAt(l + 3)], a[o++] = t >> 16 & 255, a[o++] = t >> 8 & 255, a[o++] = t & 255;
+          return i === 2 && (t = Y0[e.charCodeAt(l)] << 2 | Y0[e.charCodeAt(l + 1)] >> 4, a[o++] = t & 255), i === 1 && (t = Y0[e.charCodeAt(l)] << 10 | Y0[e.charCodeAt(l + 1)] << 4 | Y0[e.charCodeAt(l + 2)] >> 2, a[o++] = t >> 8 & 255, a[o++] = t & 255), a;
+        }
+        function J3t(e) {
+          return Gm[e >> 18 & 63] + Gm[e >> 12 & 63] + Gm[e >> 6 & 63] + Gm[e & 63];
+        }
+        function $3t(e, t, r) {
+          for (var n, i = [], a = t; a < r; a += 3) n = (e[a] << 16 & 16711680) + (e[a + 1] << 8 & 65280) + (e[a + 2] & 255), i.push(J3t(n));
+          return i.join("");
+        }
+        function Q3t(e) {
+          for (var t, r = e.length, n = r % 3, i = [], a = 16383, o = 0, s = r - n; o < s; o += a) i.push($3t(e, o, o + a > s ? s : o + a));
+          return n === 1 ? (t = e[r - 1], i.push(Gm[t >> 2] + Gm[t << 4 & 63] + "==")) : n === 2 && (t = (e[r - 2] << 8) + e[r - 1], i.push(Gm[t >> 10] + Gm[t >> 4 & 63] + Gm[t << 2 & 63] + "=")), i.join("");
+        }
+      });
+      var Q3e = ye((xH) => {
+        xH.read = function(e, t, r, n, i) {
+          var a, o, s = i * 8 - n - 1, l = (1 << s) - 1, u = l >> 1, c = -7, f = r ? i - 1 : 0, h = r ? -1 : 1, d = e[t + f];
+          for (f += h, a = d & (1 << -c) - 1, d >>= -c, c += s; c > 0; a = a * 256 + e[t + f], f += h, c -= 8) ;
+          for (o = a & (1 << -c) - 1, a >>= -c, c += n; c > 0; o = o * 256 + e[t + f], f += h, c -= 8) ;
+          if (a === 0) a = 1 - u;
+          else {
+            if (a === l) return o ? NaN : (d ? -1 : 1) * (1 / 0);
+            o = o + Math.pow(2, n), a = a - u;
+          }
+          return (d ? -1 : 1) * o * Math.pow(2, a - n);
+        };
+        xH.write = function(e, t, r, n, i, a) {
+          var o, s, l, u = a * 8 - i - 1, c = (1 << u) - 1, f = c >> 1, h = i === 23 ? Math.pow(2, -24) - Math.pow(2, -77) : 0, d = n ? 0 : a - 1, v = n ? 1 : -1, _ = t < 0 || t === 0 && 1 / t < 0 ? 1 : 0;
+          for (t = Math.abs(t), isNaN(t) || t === 1 / 0 ? (s = isNaN(t) ? 1 : 0, o = c) : (o = Math.floor(Math.log(t) / Math.LN2), t * (l = Math.pow(2, -o)) < 1 && (o--, l *= 2), o + f >= 1 ? t += h / l : t += h * Math.pow(2, 1 - f), t * l >= 2 && (o++, l /= 2), o + f >= c ? (s = 0, o = c) : o + f >= 1 ? (s = (t * l - 1) * Math.pow(2, i), o = o + f) : (s = t * Math.pow(2, f - 1) * Math.pow(2, i), o = 0)); i >= 8; e[r + d] = s & 255, d += v, s /= 256, i -= 8) ;
+          for (o = o << i | s, u += i; u > 0; e[r + d] = o & 255, d += v, o /= 256, u -= 8) ;
+          e[r + d - v] |= _ * 128;
+        };
+      });
+      var _2 = ye((nA) => {
+        var bH = $3e(), rA = Q3e(), eTe = typeof Symbol == "function" && typeof Symbol.for == "function" ? Symbol.for("nodejs.util.inspect.custom") : null;
+        nA.Buffer = ea;
+        nA.SlowBuffer = aTt;
+        nA.INSPECT_MAX_BYTES = 50;
+        var X8 = 2147483647;
+        nA.kMaxLength = X8;
+        ea.TYPED_ARRAY_SUPPORT = eTt();
+        !ea.TYPED_ARRAY_SUPPORT && typeof console != "undefined" && typeof console.error == "function" && console.error("This browser lacks typed array (Uint8Array) support which is required by `buffer` v5.x. Use `buffer` v4.x if you require old browser support.");
+        function eTt() {
+          try {
+            let e = new Uint8Array(1), t = { foo: function() {
+              return 42;
+            } };
+            return Object.setPrototypeOf(t, Uint8Array.prototype), Object.setPrototypeOf(e, t), e.foo() === 42;
+          } catch (e) {
+            return false;
+          }
+        }
+        Object.defineProperty(ea.prototype, "parent", { enumerable: true, get: function() {
+          if (ea.isBuffer(this)) return this.buffer;
+        } });
+        Object.defineProperty(ea.prototype, "offset", { enumerable: true, get: function() {
+          if (ea.isBuffer(this)) return this.byteOffset;
+        } });
+        function Yy(e) {
+          if (e > X8) throw new RangeError('The value "' + e + '" is invalid for option "size"');
+          let t = new Uint8Array(e);
+          return Object.setPrototypeOf(t, ea.prototype), t;
+        }
+        function ea(e, t, r) {
+          if (typeof e == "number") {
+            if (typeof t == "string") throw new TypeError('The "string" argument must be of type string. Received type number');
+            return SH(e);
+          }
+          return nTe(e, t, r);
+        }
+        ea.poolSize = 8192;
+        function nTe(e, t, r) {
+          if (typeof e == "string") return rTt(e, t);
+          if (ArrayBuffer.isView(e)) return iTt(e);
+          if (e == null) throw new TypeError("The first argument must be one of type string, Buffer, ArrayBuffer, Array, or Array-like Object. Received type " + typeof e);
+          if (Hm(e, ArrayBuffer) || e && Hm(e.buffer, ArrayBuffer) || typeof SharedArrayBuffer != "undefined" && (Hm(e, SharedArrayBuffer) || e && Hm(e.buffer, SharedArrayBuffer))) return TH(e, t, r);
+          if (typeof e == "number") throw new TypeError('The "value" argument must not be of type number. Received type number');
+          let n = e.valueOf && e.valueOf();
+          if (n != null && n !== e) return ea.from(n, t, r);
+          let i = nTt(e);
+          if (i) return i;
+          if (typeof Symbol != "undefined" && Symbol.toPrimitive != null && typeof e[Symbol.toPrimitive] == "function") return ea.from(e[Symbol.toPrimitive]("string"), t, r);
+          throw new TypeError("The first argument must be one of type string, Buffer, ArrayBuffer, Array, or Array-like Object. Received type " + typeof e);
+        }
+        ea.from = function(e, t, r) {
+          return nTe(e, t, r);
+        };
+        Object.setPrototypeOf(ea.prototype, Uint8Array.prototype);
+        Object.setPrototypeOf(ea, Uint8Array);
+        function aTe(e) {
+          if (typeof e != "number") throw new TypeError('"size" argument must be of type number');
+          if (e < 0) throw new RangeError('The value "' + e + '" is invalid for option "size"');
+        }
+        function tTt(e, t, r) {
+          return aTe(e), e <= 0 ? Yy(e) : t !== void 0 ? typeof r == "string" ? Yy(e).fill(t, r) : Yy(e).fill(t) : Yy(e);
+        }
+        ea.alloc = function(e, t, r) {
+          return tTt(e, t, r);
+        };
+        function SH(e) {
+          return aTe(e), Yy(e < 0 ? 0 : MH(e) | 0);
+        }
+        ea.allocUnsafe = function(e) {
+          return SH(e);
+        };
+        ea.allocUnsafeSlow = function(e) {
+          return SH(e);
+        };
+        function rTt(e, t) {
+          if ((typeof t != "string" || t === "") && (t = "utf8"), !ea.isEncoding(t)) throw new TypeError("Unknown encoding: " + t);
+          let r = oTe(e, t) | 0, n = Yy(r), i = n.write(e, t);
+          return i !== r && (n = n.slice(0, i)), n;
+        }
+        function wH(e) {
+          let t = e.length < 0 ? 0 : MH(e.length) | 0, r = Yy(t);
+          for (let n = 0; n < t; n += 1) r[n] = e[n] & 255;
+          return r;
+        }
+        function iTt(e) {
+          if (Hm(e, Uint8Array)) {
+            let t = new Uint8Array(e);
+            return TH(t.buffer, t.byteOffset, t.byteLength);
+          }
+          return wH(e);
+        }
+        function TH(e, t, r) {
+          if (t < 0 || e.byteLength < t) throw new RangeError('"offset" is outside of buffer bounds');
+          if (e.byteLength < t + (r || 0)) throw new RangeError('"length" is outside of buffer bounds');
+          let n;
+          return t === void 0 && r === void 0 ? n = new Uint8Array(e) : r === void 0 ? n = new Uint8Array(e, t) : n = new Uint8Array(e, t, r), Object.setPrototypeOf(n, ea.prototype), n;
+        }
+        function nTt(e) {
+          if (ea.isBuffer(e)) {
+            let t = MH(e.length) | 0, r = Yy(t);
+            return r.length === 0 || e.copy(r, 0, 0, t), r;
+          }
+          if (e.length !== void 0) return typeof e.length != "number" || kH(e.length) ? Yy(0) : wH(e);
+          if (e.type === "Buffer" && Array.isArray(e.data)) return wH(e.data);
+        }
+        function MH(e) {
+          if (e >= X8) throw new RangeError("Attempt to allocate Buffer larger than maximum size: 0x" + X8.toString(16) + " bytes");
+          return e | 0;
+        }
+        function aTt(e) {
+          return +e != e && (e = 0), ea.alloc(+e);
+        }
+        ea.isBuffer = function(t) {
+          return t != null && t._isBuffer === true && t !== ea.prototype;
+        };
+        ea.compare = function(t, r) {
+          if (Hm(t, Uint8Array) && (t = ea.from(t, t.offset, t.byteLength)), Hm(r, Uint8Array) && (r = ea.from(r, r.offset, r.byteLength)), !ea.isBuffer(t) || !ea.isBuffer(r)) throw new TypeError('The "buf1", "buf2" arguments must be one of type Buffer or Uint8Array');
+          if (t === r) return 0;
+          let n = t.length, i = r.length;
+          for (let a = 0, o = Math.min(n, i); a < o; ++a) if (t[a] !== r[a]) {
+            n = t[a], i = r[a];
+            break;
+          }
+          return n < i ? -1 : i < n ? 1 : 0;
+        };
+        ea.isEncoding = function(t) {
+          switch (String(t).toLowerCase()) {
+            case "hex":
+            case "utf8":
+            case "utf-8":
+            case "ascii":
+            case "latin1":
+            case "binary":
+            case "base64":
+            case "ucs2":
+            case "ucs-2":
+            case "utf16le":
+            case "utf-16le":
+              return true;
+            default:
+              return false;
+          }
+        };
+        ea.concat = function(t, r) {
+          if (!Array.isArray(t)) throw new TypeError('"list" argument must be an Array of Buffers');
+          if (t.length === 0) return ea.alloc(0);
+          let n;
+          if (r === void 0) for (r = 0, n = 0; n < t.length; ++n) r += t[n].length;
+          let i = ea.allocUnsafe(r), a = 0;
+          for (n = 0; n < t.length; ++n) {
+            let o = t[n];
+            if (Hm(o, Uint8Array)) a + o.length > i.length ? (ea.isBuffer(o) || (o = ea.from(o)), o.copy(i, a)) : Uint8Array.prototype.set.call(i, o, a);
+            else if (ea.isBuffer(o)) o.copy(i, a);
+            else throw new TypeError('"list" argument must be an Array of Buffers');
+            a += o.length;
+          }
+          return i;
+        };
+        function oTe(e, t) {
+          if (ea.isBuffer(e)) return e.length;
+          if (ArrayBuffer.isView(e) || Hm(e, ArrayBuffer)) return e.byteLength;
+          if (typeof e != "string") throw new TypeError('The "string" argument must be one of type string, Buffer, or ArrayBuffer. Received type ' + typeof e);
+          let r = e.length, n = arguments.length > 2 && arguments[2] === true;
+          if (!n && r === 0) return 0;
+          let i = false;
+          for (; ; ) switch (t) {
+            case "ascii":
+            case "latin1":
+            case "binary":
+              return r;
+            case "utf8":
+            case "utf-8":
+              return AH(e).length;
+            case "ucs2":
+            case "ucs-2":
+            case "utf16le":
+            case "utf-16le":
+              return r * 2;
+            case "hex":
+              return r >>> 1;
+            case "base64":
+              return pTe(e).length;
+            default:
+              if (i) return n ? -1 : AH(e).length;
+              t = ("" + t).toLowerCase(), i = true;
+          }
+        }
+        ea.byteLength = oTe;
+        function oTt(e, t, r) {
+          let n = false;
+          if ((t === void 0 || t < 0) && (t = 0), t > this.length || ((r === void 0 || r > this.length) && (r = this.length), r <= 0) || (r >>>= 0, t >>>= 0, r <= t)) return "";
+          for (e || (e = "utf8"); ; ) switch (e) {
+            case "hex":
+              return gTt(this, t, r);
+            case "utf8":
+            case "utf-8":
+              return lTe(this, t, r);
+            case "ascii":
+              return vTt(this, t, r);
+            case "latin1":
+            case "binary":
+              return pTt(this, t, r);
+            case "base64":
+              return hTt(this, t, r);
+            case "ucs2":
+            case "ucs-2":
+            case "utf16le":
+            case "utf-16le":
+              return mTt(this, t, r);
+            default:
+              if (n) throw new TypeError("Unknown encoding: " + e);
+              e = (e + "").toLowerCase(), n = true;
+          }
+        }
+        ea.prototype._isBuffer = true;
+        function y2(e, t, r) {
+          let n = e[t];
+          e[t] = e[r], e[r] = n;
+        }
+        ea.prototype.swap16 = function() {
+          let t = this.length;
+          if (t % 2 !== 0) throw new RangeError("Buffer size must be a multiple of 16-bits");
+          for (let r = 0; r < t; r += 2) y2(this, r, r + 1);
+          return this;
+        };
+        ea.prototype.swap32 = function() {
+          let t = this.length;
+          if (t % 4 !== 0) throw new RangeError("Buffer size must be a multiple of 32-bits");
+          for (let r = 0; r < t; r += 4) y2(this, r, r + 3), y2(this, r + 1, r + 2);
+          return this;
+        };
+        ea.prototype.swap64 = function() {
+          let t = this.length;
+          if (t % 8 !== 0) throw new RangeError("Buffer size must be a multiple of 64-bits");
+          for (let r = 0; r < t; r += 8) y2(this, r, r + 7), y2(this, r + 1, r + 6), y2(this, r + 2, r + 5), y2(this, r + 3, r + 4);
+          return this;
+        };
+        ea.prototype.toString = function() {
+          let t = this.length;
+          return t === 0 ? "" : arguments.length === 0 ? lTe(this, 0, t) : oTt.apply(this, arguments);
+        };
+        ea.prototype.toLocaleString = ea.prototype.toString;
+        ea.prototype.equals = function(t) {
+          if (!ea.isBuffer(t)) throw new TypeError("Argument must be a Buffer");
+          return this === t ? true : ea.compare(this, t) === 0;
+        };
+        ea.prototype.inspect = function() {
+          let t = "", r = nA.INSPECT_MAX_BYTES;
+          return t = this.toString("hex", 0, r).replace(/(.{2})/g, "$1 ").trim(), this.length > r && (t += " ... "), "<Buffer " + t + ">";
+        };
+        eTe && (ea.prototype[eTe] = ea.prototype.inspect);
+        ea.prototype.compare = function(t, r, n, i, a) {
+          if (Hm(t, Uint8Array) && (t = ea.from(t, t.offset, t.byteLength)), !ea.isBuffer(t)) throw new TypeError('The "target" argument must be one of type Buffer or Uint8Array. Received type ' + typeof t);
+          if (r === void 0 && (r = 0), n === void 0 && (n = t ? t.length : 0), i === void 0 && (i = 0), a === void 0 && (a = this.length), r < 0 || n > t.length || i < 0 || a > this.length) throw new RangeError("out of range index");
+          if (i >= a && r >= n) return 0;
+          if (i >= a) return -1;
+          if (r >= n) return 1;
+          if (r >>>= 0, n >>>= 0, i >>>= 0, a >>>= 0, this === t) return 0;
+          let o = a - i, s = n - r, l = Math.min(o, s), u = this.slice(i, a), c = t.slice(r, n);
+          for (let f = 0; f < l; ++f) if (u[f] !== c[f]) {
+            o = u[f], s = c[f];
+            break;
+          }
+          return o < s ? -1 : s < o ? 1 : 0;
+        };
+        function sTe(e, t, r, n, i) {
+          if (e.length === 0) return -1;
+          if (typeof r == "string" ? (n = r, r = 0) : r > 2147483647 ? r = 2147483647 : r < -2147483648 && (r = -2147483648), r = +r, kH(r) && (r = i ? 0 : e.length - 1), r < 0 && (r = e.length + r), r >= e.length) {
+            if (i) return -1;
+            r = e.length - 1;
+          } else if (r < 0) if (i) r = 0;
+          else return -1;
+          if (typeof t == "string" && (t = ea.from(t, n)), ea.isBuffer(t)) return t.length === 0 ? -1 : tTe(e, t, r, n, i);
+          if (typeof t == "number") return t = t & 255, typeof Uint8Array.prototype.indexOf == "function" ? i ? Uint8Array.prototype.indexOf.call(e, t, r) : Uint8Array.prototype.lastIndexOf.call(e, t, r) : tTe(e, [t], r, n, i);
+          throw new TypeError("val must be string, number or Buffer");
+        }
+        function tTe(e, t, r, n, i) {
+          let a = 1, o = e.length, s = t.length;
+          if (n !== void 0 && (n = String(n).toLowerCase(), n === "ucs2" || n === "ucs-2" || n === "utf16le" || n === "utf-16le")) {
+            if (e.length < 2 || t.length < 2) return -1;
+            a = 2, o /= 2, s /= 2, r /= 2;
+          }
+          function l(c, f) {
+            return a === 1 ? c[f] : c.readUInt16BE(f * a);
+          }
+          let u;
+          if (i) {
+            let c = -1;
+            for (u = r; u < o; u++) if (l(e, u) === l(t, c === -1 ? 0 : u - c)) {
+              if (c === -1 && (c = u), u - c + 1 === s) return c * a;
+            } else c !== -1 && (u -= u - c), c = -1;
+          } else for (r + s > o && (r = o - s), u = r; u >= 0; u--) {
+            let c = true;
+            for (let f = 0; f < s; f++) if (l(e, u + f) !== l(t, f)) {
+              c = false;
+              break;
+            }
+            if (c) return u;
+          }
+          return -1;
+        }
+        ea.prototype.includes = function(t, r, n) {
+          return this.indexOf(t, r, n) !== -1;
+        };
+        ea.prototype.indexOf = function(t, r, n) {
+          return sTe(this, t, r, n, true);
+        };
+        ea.prototype.lastIndexOf = function(t, r, n) {
+          return sTe(this, t, r, n, false);
+        };
+        function sTt(e, t, r, n) {
+          r = Number(r) || 0;
+          let i = e.length - r;
+          n ? (n = Number(n), n > i && (n = i)) : n = i;
+          let a = t.length;
+          n > a / 2 && (n = a / 2);
+          let o;
+          for (o = 0; o < n; ++o) {
+            let s = parseInt(t.substr(o * 2, 2), 16);
+            if (kH(s)) return o;
+            e[r + o] = s;
+          }
+          return o;
+        }
+        function lTt(e, t, r, n) {
+          return Z8(AH(t, e.length - r), e, r, n);
+        }
+        function uTt(e, t, r, n) {
+          return Z8(bTt(t), e, r, n);
+        }
+        function cTt(e, t, r, n) {
+          return Z8(pTe(t), e, r, n);
+        }
+        function fTt(e, t, r, n) {
+          return Z8(wTt(t, e.length - r), e, r, n);
+        }
+        ea.prototype.write = function(t, r, n, i) {
+          if (r === void 0) i = "utf8", n = this.length, r = 0;
+          else if (n === void 0 && typeof r == "string") i = r, n = this.length, r = 0;
+          else if (isFinite(r)) r = r >>> 0, isFinite(n) ? (n = n >>> 0, i === void 0 && (i = "utf8")) : (i = n, n = void 0);
+          else throw new Error("Buffer.write(string, encoding, offset[, length]) is no longer supported");
+          let a = this.length - r;
+          if ((n === void 0 || n > a) && (n = a), t.length > 0 && (n < 0 || r < 0) || r > this.length) throw new RangeError("Attempt to write outside buffer bounds");
+          i || (i = "utf8");
+          let o = false;
+          for (; ; ) switch (i) {
+            case "hex":
+              return sTt(this, t, r, n);
+            case "utf8":
+            case "utf-8":
+              return lTt(this, t, r, n);
+            case "ascii":
+            case "latin1":
+            case "binary":
+              return uTt(this, t, r, n);
+            case "base64":
+              return cTt(this, t, r, n);
+            case "ucs2":
+            case "ucs-2":
+            case "utf16le":
+            case "utf-16le":
+              return fTt(this, t, r, n);
+            default:
+              if (o) throw new TypeError("Unknown encoding: " + i);
+              i = ("" + i).toLowerCase(), o = true;
+          }
+        };
+        ea.prototype.toJSON = function() {
+          return { type: "Buffer", data: Array.prototype.slice.call(this._arr || this, 0) };
+        };
+        function hTt(e, t, r) {
+          return t === 0 && r === e.length ? bH.fromByteArray(e) : bH.fromByteArray(e.slice(t, r));
+        }
+        function lTe(e, t, r) {
+          r = Math.min(e.length, r);
+          let n = [], i = t;
+          for (; i < r; ) {
+            let a = e[i], o = null, s = a > 239 ? 4 : a > 223 ? 3 : a > 191 ? 2 : 1;
+            if (i + s <= r) {
+              let l, u, c, f;
+              switch (s) {
+                case 1:
+                  a < 128 && (o = a);
+                  break;
+                case 2:
+                  l = e[i + 1], (l & 192) === 128 && (f = (a & 31) << 6 | l & 63, f > 127 && (o = f));
+                  break;
+                case 3:
+                  l = e[i + 1], u = e[i + 2], (l & 192) === 128 && (u & 192) === 128 && (f = (a & 15) << 12 | (l & 63) << 6 | u & 63, f > 2047 && (f < 55296 || f > 57343) && (o = f));
+                  break;
+                case 4:
+                  l = e[i + 1], u = e[i + 2], c = e[i + 3], (l & 192) === 128 && (u & 192) === 128 && (c & 192) === 128 && (f = (a & 15) << 18 | (l & 63) << 12 | (u & 63) << 6 | c & 63, f > 65535 && f < 1114112 && (o = f));
+              }
+            }
+            o === null ? (o = 65533, s = 1) : o > 65535 && (o -= 65536, n.push(o >>> 10 & 1023 | 55296), o = 56320 | o & 1023), n.push(o), i += s;
+          }
+          return dTt(n);
+        }
+        var rTe = 4096;
+        function dTt(e) {
+          let t = e.length;
+          if (t <= rTe) return String.fromCharCode.apply(String, e);
+          let r = "", n = 0;
+          for (; n < t; ) r += String.fromCharCode.apply(String, e.slice(n, n += rTe));
+          return r;
+        }
+        function vTt(e, t, r) {
+          let n = "";
+          r = Math.min(e.length, r);
+          for (let i = t; i < r; ++i) n += String.fromCharCode(e[i] & 127);
+          return n;
+        }
+        function pTt(e, t, r) {
+          let n = "";
+          r = Math.min(e.length, r);
+          for (let i = t; i < r; ++i) n += String.fromCharCode(e[i]);
+          return n;
+        }
+        function gTt(e, t, r) {
+          let n = e.length;
+          (!t || t < 0) && (t = 0), (!r || r < 0 || r > n) && (r = n);
+          let i = "";
+          for (let a = t; a < r; ++a) i += TTt[e[a]];
+          return i;
+        }
+        function mTt(e, t, r) {
+          let n = e.slice(t, r), i = "";
+          for (let a = 0; a < n.length - 1; a += 2) i += String.fromCharCode(n[a] + n[a + 1] * 256);
+          return i;
+        }
+        ea.prototype.slice = function(t, r) {
+          let n = this.length;
+          t = ~~t, r = r === void 0 ? n : ~~r, t < 0 ? (t += n, t < 0 && (t = 0)) : t > n && (t = n), r < 0 ? (r += n, r < 0 && (r = 0)) : r > n && (r = n), r < t && (r = t);
+          let i = this.subarray(t, r);
+          return Object.setPrototypeOf(i, ea.prototype), i;
+        };
+        function ev(e, t, r) {
+          if (e % 1 !== 0 || e < 0) throw new RangeError("offset is not uint");
+          if (e + t > r) throw new RangeError("Trying to access beyond buffer length");
+        }
+        ea.prototype.readUintLE = ea.prototype.readUIntLE = function(t, r, n) {
+          t = t >>> 0, r = r >>> 0, n || ev(t, r, this.length);
+          let i = this[t], a = 1, o = 0;
+          for (; ++o < r && (a *= 256); ) i += this[t + o] * a;
+          return i;
+        };
+        ea.prototype.readUintBE = ea.prototype.readUIntBE = function(t, r, n) {
+          t = t >>> 0, r = r >>> 0, n || ev(t, r, this.length);
+          let i = this[t + --r], a = 1;
+          for (; r > 0 && (a *= 256); ) i += this[t + --r] * a;
+          return i;
+        };
+        ea.prototype.readUint8 = ea.prototype.readUInt8 = function(t, r) {
+          return t = t >>> 0, r || ev(t, 1, this.length), this[t];
+        };
+        ea.prototype.readUint16LE = ea.prototype.readUInt16LE = function(t, r) {
+          return t = t >>> 0, r || ev(t, 2, this.length), this[t] | this[t + 1] << 8;
+        };
+        ea.prototype.readUint16BE = ea.prototype.readUInt16BE = function(t, r) {
+          return t = t >>> 0, r || ev(t, 2, this.length), this[t] << 8 | this[t + 1];
+        };
+        ea.prototype.readUint32LE = ea.prototype.readUInt32LE = function(t, r) {
+          return t = t >>> 0, r || ev(t, 4, this.length), (this[t] | this[t + 1] << 8 | this[t + 2] << 16) + this[t + 3] * 16777216;
+        };
+        ea.prototype.readUint32BE = ea.prototype.readUInt32BE = function(t, r) {
+          return t = t >>> 0, r || ev(t, 4, this.length), this[t] * 16777216 + (this[t + 1] << 16 | this[t + 2] << 8 | this[t + 3]);
+        };
+        ea.prototype.readBigUInt64LE = N_(function(t) {
+          t = t >>> 0, iA(t, "offset");
+          let r = this[t], n = this[t + 7];
+          (r === void 0 || n === void 0) && Y4(t, this.length - 8);
+          let i = r + this[++t] * 2 ** 8 + this[++t] * 2 ** 16 + this[++t] * 2 ** 24, a = this[++t] + this[++t] * 2 ** 8 + this[++t] * 2 ** 16 + n * 2 ** 24;
+          return BigInt(i) + (BigInt(a) << BigInt(32));
+        });
+        ea.prototype.readBigUInt64BE = N_(function(t) {
+          t = t >>> 0, iA(t, "offset");
+          let r = this[t], n = this[t + 7];
+          (r === void 0 || n === void 0) && Y4(t, this.length - 8);
+          let i = r * 2 ** 24 + this[++t] * 2 ** 16 + this[++t] * 2 ** 8 + this[++t], a = this[++t] * 2 ** 24 + this[++t] * 2 ** 16 + this[++t] * 2 ** 8 + n;
+          return (BigInt(i) << BigInt(32)) + BigInt(a);
+        });
+        ea.prototype.readIntLE = function(t, r, n) {
+          t = t >>> 0, r = r >>> 0, n || ev(t, r, this.length);
+          let i = this[t], a = 1, o = 0;
+          for (; ++o < r && (a *= 256); ) i += this[t + o] * a;
+          return a *= 128, i >= a && (i -= Math.pow(2, 8 * r)), i;
+        };
+        ea.prototype.readIntBE = function(t, r, n) {
+          t = t >>> 0, r = r >>> 0, n || ev(t, r, this.length);
+          let i = r, a = 1, o = this[t + --i];
+          for (; i > 0 && (a *= 256); ) o += this[t + --i] * a;
+          return a *= 128, o >= a && (o -= Math.pow(2, 8 * r)), o;
+        };
+        ea.prototype.readInt8 = function(t, r) {
+          return t = t >>> 0, r || ev(t, 1, this.length), this[t] & 128 ? (255 - this[t] + 1) * -1 : this[t];
+        };
+        ea.prototype.readInt16LE = function(t, r) {
+          t = t >>> 0, r || ev(t, 2, this.length);
+          let n = this[t] | this[t + 1] << 8;
+          return n & 32768 ? n | 4294901760 : n;
+        };
+        ea.prototype.readInt16BE = function(t, r) {
+          t = t >>> 0, r || ev(t, 2, this.length);
+          let n = this[t + 1] | this[t] << 8;
+          return n & 32768 ? n | 4294901760 : n;
+        };
+        ea.prototype.readInt32LE = function(t, r) {
+          return t = t >>> 0, r || ev(t, 4, this.length), this[t] | this[t + 1] << 8 | this[t + 2] << 16 | this[t + 3] << 24;
+        };
+        ea.prototype.readInt32BE = function(t, r) {
+          return t = t >>> 0, r || ev(t, 4, this.length), this[t] << 24 | this[t + 1] << 16 | this[t + 2] << 8 | this[t + 3];
+        };
+        ea.prototype.readBigInt64LE = N_(function(t) {
+          t = t >>> 0, iA(t, "offset");
+          let r = this[t], n = this[t + 7];
+          (r === void 0 || n === void 0) && Y4(t, this.length - 8);
+          let i = this[t + 4] + this[t + 5] * 2 ** 8 + this[t + 6] * 2 ** 16 + (n << 24);
+          return (BigInt(i) << BigInt(32)) + BigInt(r + this[++t] * 2 ** 8 + this[++t] * 2 ** 16 + this[++t] * 2 ** 24);
+        });
+        ea.prototype.readBigInt64BE = N_(function(t) {
+          t = t >>> 0, iA(t, "offset");
+          let r = this[t], n = this[t + 7];
+          (r === void 0 || n === void 0) && Y4(t, this.length - 8);
+          let i = (r << 24) + this[++t] * 2 ** 16 + this[++t] * 2 ** 8 + this[++t];
+          return (BigInt(i) << BigInt(32)) + BigInt(this[++t] * 2 ** 24 + this[++t] * 2 ** 16 + this[++t] * 2 ** 8 + n);
+        });
+        ea.prototype.readFloatLE = function(t, r) {
+          return t = t >>> 0, r || ev(t, 4, this.length), rA.read(this, t, true, 23, 4);
+        };
+        ea.prototype.readFloatBE = function(t, r) {
+          return t = t >>> 0, r || ev(t, 4, this.length), rA.read(this, t, false, 23, 4);
+        };
+        ea.prototype.readDoubleLE = function(t, r) {
+          return t = t >>> 0, r || ev(t, 8, this.length), rA.read(this, t, true, 52, 8);
+        };
+        ea.prototype.readDoubleBE = function(t, r) {
+          return t = t >>> 0, r || ev(t, 8, this.length), rA.read(this, t, false, 52, 8);
+        };
+        function Rp(e, t, r, n, i, a) {
+          if (!ea.isBuffer(e)) throw new TypeError('"buffer" argument must be a Buffer instance');
+          if (t > i || t < a) throw new RangeError('"value" argument is out of bounds');
+          if (r + n > e.length) throw new RangeError("Index out of range");
+        }
+        ea.prototype.writeUintLE = ea.prototype.writeUIntLE = function(t, r, n, i) {
+          if (t = +t, r = r >>> 0, n = n >>> 0, !i) {
+            let s = Math.pow(2, 8 * n) - 1;
+            Rp(this, t, r, n, s, 0);
+          }
+          let a = 1, o = 0;
+          for (this[r] = t & 255; ++o < n && (a *= 256); ) this[r + o] = t / a & 255;
+          return r + n;
+        };
+        ea.prototype.writeUintBE = ea.prototype.writeUIntBE = function(t, r, n, i) {
+          if (t = +t, r = r >>> 0, n = n >>> 0, !i) {
+            let s = Math.pow(2, 8 * n) - 1;
+            Rp(this, t, r, n, s, 0);
+          }
+          let a = n - 1, o = 1;
+          for (this[r + a] = t & 255; --a >= 0 && (o *= 256); ) this[r + a] = t / o & 255;
+          return r + n;
+        };
+        ea.prototype.writeUint8 = ea.prototype.writeUInt8 = function(t, r, n) {
+          return t = +t, r = r >>> 0, n || Rp(this, t, r, 1, 255, 0), this[r] = t & 255, r + 1;
+        };
+        ea.prototype.writeUint16LE = ea.prototype.writeUInt16LE = function(t, r, n) {
+          return t = +t, r = r >>> 0, n || Rp(this, t, r, 2, 65535, 0), this[r] = t & 255, this[r + 1] = t >>> 8, r + 2;
+        };
+        ea.prototype.writeUint16BE = ea.prototype.writeUInt16BE = function(t, r, n) {
+          return t = +t, r = r >>> 0, n || Rp(this, t, r, 2, 65535, 0), this[r] = t >>> 8, this[r + 1] = t & 255, r + 2;
+        };
+        ea.prototype.writeUint32LE = ea.prototype.writeUInt32LE = function(t, r, n) {
+          return t = +t, r = r >>> 0, n || Rp(this, t, r, 4, 4294967295, 0), this[r + 3] = t >>> 24, this[r + 2] = t >>> 16, this[r + 1] = t >>> 8, this[r] = t & 255, r + 4;
+        };
+        ea.prototype.writeUint32BE = ea.prototype.writeUInt32BE = function(t, r, n) {
+          return t = +t, r = r >>> 0, n || Rp(this, t, r, 4, 4294967295, 0), this[r] = t >>> 24, this[r + 1] = t >>> 16, this[r + 2] = t >>> 8, this[r + 3] = t & 255, r + 4;
+        };
+        function uTe(e, t, r, n, i) {
+          vTe(t, n, i, e, r, 7);
+          let a = Number(t & BigInt(4294967295));
+          e[r++] = a, a = a >> 8, e[r++] = a, a = a >> 8, e[r++] = a, a = a >> 8, e[r++] = a;
+          let o = Number(t >> BigInt(32) & BigInt(4294967295));
+          return e[r++] = o, o = o >> 8, e[r++] = o, o = o >> 8, e[r++] = o, o = o >> 8, e[r++] = o, r;
+        }
+        function cTe(e, t, r, n, i) {
+          vTe(t, n, i, e, r, 7);
+          let a = Number(t & BigInt(4294967295));
+          e[r + 7] = a, a = a >> 8, e[r + 6] = a, a = a >> 8, e[r + 5] = a, a = a >> 8, e[r + 4] = a;
+          let o = Number(t >> BigInt(32) & BigInt(4294967295));
+          return e[r + 3] = o, o = o >> 8, e[r + 2] = o, o = o >> 8, e[r + 1] = o, o = o >> 8, e[r] = o, r + 8;
+        }
+        ea.prototype.writeBigUInt64LE = N_(function(t, r = 0) {
+          return uTe(this, t, r, BigInt(0), BigInt("0xffffffffffffffff"));
+        });
+        ea.prototype.writeBigUInt64BE = N_(function(t, r = 0) {
+          return cTe(this, t, r, BigInt(0), BigInt("0xffffffffffffffff"));
+        });
+        ea.prototype.writeIntLE = function(t, r, n, i) {
+          if (t = +t, r = r >>> 0, !i) {
+            let l = Math.pow(2, 8 * n - 1);
+            Rp(this, t, r, n, l - 1, -l);
+          }
+          let a = 0, o = 1, s = 0;
+          for (this[r] = t & 255; ++a < n && (o *= 256); ) t < 0 && s === 0 && this[r + a - 1] !== 0 && (s = 1), this[r + a] = (t / o >> 0) - s & 255;
+          return r + n;
+        };
+        ea.prototype.writeIntBE = function(t, r, n, i) {
+          if (t = +t, r = r >>> 0, !i) {
+            let l = Math.pow(2, 8 * n - 1);
+            Rp(this, t, r, n, l - 1, -l);
+          }
+          let a = n - 1, o = 1, s = 0;
+          for (this[r + a] = t & 255; --a >= 0 && (o *= 256); ) t < 0 && s === 0 && this[r + a + 1] !== 0 && (s = 1), this[r + a] = (t / o >> 0) - s & 255;
+          return r + n;
+        };
+        ea.prototype.writeInt8 = function(t, r, n) {
+          return t = +t, r = r >>> 0, n || Rp(this, t, r, 1, 127, -128), t < 0 && (t = 255 + t + 1), this[r] = t & 255, r + 1;
+        };
+        ea.prototype.writeInt16LE = function(t, r, n) {
+          return t = +t, r = r >>> 0, n || Rp(this, t, r, 2, 32767, -32768), this[r] = t & 255, this[r + 1] = t >>> 8, r + 2;
+        };
+        ea.prototype.writeInt16BE = function(t, r, n) {
+          return t = +t, r = r >>> 0, n || Rp(this, t, r, 2, 32767, -32768), this[r] = t >>> 8, this[r + 1] = t & 255, r + 2;
+        };
+        ea.prototype.writeInt32LE = function(t, r, n) {
+          return t = +t, r = r >>> 0, n || Rp(this, t, r, 4, 2147483647, -2147483648), this[r] = t & 255, this[r + 1] = t >>> 8, this[r + 2] = t >>> 16, this[r + 3] = t >>> 24, r + 4;
+        };
+        ea.prototype.writeInt32BE = function(t, r, n) {
+          return t = +t, r = r >>> 0, n || Rp(this, t, r, 4, 2147483647, -2147483648), t < 0 && (t = 4294967295 + t + 1), this[r] = t >>> 24, this[r + 1] = t >>> 16, this[r + 2] = t >>> 8, this[r + 3] = t & 255, r + 4;
+        };
+        ea.prototype.writeBigInt64LE = N_(function(t, r = 0) {
+          return uTe(this, t, r, -BigInt("0x8000000000000000"), BigInt("0x7fffffffffffffff"));
+        });
+        ea.prototype.writeBigInt64BE = N_(function(t, r = 0) {
+          return cTe(this, t, r, -BigInt("0x8000000000000000"), BigInt("0x7fffffffffffffff"));
+        });
+        function fTe(e, t, r, n, i, a) {
+          if (r + n > e.length) throw new RangeError("Index out of range");
+          if (r < 0) throw new RangeError("Index out of range");
+        }
+        function hTe(e, t, r, n, i) {
+          return t = +t, r = r >>> 0, i || fTe(e, t, r, 4), rA.write(e, t, r, n, 23, 4), r + 4;
+        }
+        ea.prototype.writeFloatLE = function(t, r, n) {
+          return hTe(this, t, r, true, n);
+        };
+        ea.prototype.writeFloatBE = function(t, r, n) {
+          return hTe(this, t, r, false, n);
+        };
+        function dTe(e, t, r, n, i) {
+          return t = +t, r = r >>> 0, i || fTe(e, t, r, 8), rA.write(e, t, r, n, 52, 8), r + 8;
+        }
+        ea.prototype.writeDoubleLE = function(t, r, n) {
+          return dTe(this, t, r, true, n);
+        };
+        ea.prototype.writeDoubleBE = function(t, r, n) {
+          return dTe(this, t, r, false, n);
+        };
+        ea.prototype.copy = function(t, r, n, i) {
+          if (!ea.isBuffer(t)) throw new TypeError("argument should be a Buffer");
+          if (n || (n = 0), !i && i !== 0 && (i = this.length), r >= t.length && (r = t.length), r || (r = 0), i > 0 && i < n && (i = n), i === n || t.length === 0 || this.length === 0) return 0;
+          if (r < 0) throw new RangeError("targetStart out of bounds");
+          if (n < 0 || n >= this.length) throw new RangeError("Index out of range");
+          if (i < 0) throw new RangeError("sourceEnd out of bounds");
+          i > this.length && (i = this.length), t.length - r < i - n && (i = t.length - r + n);
+          let a = i - n;
+          return this === t && typeof Uint8Array.prototype.copyWithin == "function" ? this.copyWithin(r, n, i) : Uint8Array.prototype.set.call(t, this.subarray(n, i), r), a;
+        };
+        ea.prototype.fill = function(t, r, n, i) {
+          if (typeof t == "string") {
+            if (typeof r == "string" ? (i = r, r = 0, n = this.length) : typeof n == "string" && (i = n, n = this.length), i !== void 0 && typeof i != "string") throw new TypeError("encoding must be a string");
+            if (typeof i == "string" && !ea.isEncoding(i)) throw new TypeError("Unknown encoding: " + i);
+            if (t.length === 1) {
+              let o = t.charCodeAt(0);
+              (i === "utf8" && o < 128 || i === "latin1") && (t = o);
+            }
+          } else typeof t == "number" ? t = t & 255 : typeof t == "boolean" && (t = Number(t));
+          if (r < 0 || this.length < r || this.length < n) throw new RangeError("Out of range index");
+          if (n <= r) return this;
+          r = r >>> 0, n = n === void 0 ? this.length : n >>> 0, t || (t = 0);
+          let a;
+          if (typeof t == "number") for (a = r; a < n; ++a) this[a] = t;
+          else {
+            let o = ea.isBuffer(t) ? t : ea.from(t, i), s = o.length;
+            if (s === 0) throw new TypeError('The value "' + t + '" is invalid for argument "value"');
+            for (a = 0; a < n - r; ++a) this[a + r] = o[a % s];
+          }
+          return this;
+        };
+        var tA = {};
+        function EH(e, t, r) {
+          tA[e] = class extends r {
+            constructor() {
+              super(), Object.defineProperty(this, "message", { value: t.apply(this, arguments), writable: true, configurable: true }), this.name = `${this.name} [${e}]`, this.stack, delete this.name;
+            }
+            get code() {
+              return e;
+            }
+            set code(i) {
+              Object.defineProperty(this, "code", { configurable: true, enumerable: true, value: i, writable: true });
+            }
+            toString() {
+              return `${this.name} [${e}]: ${this.message}`;
+            }
+          };
+        }
+        EH("ERR_BUFFER_OUT_OF_BOUNDS", function(e) {
+          return e ? `${e} is outside of buffer bounds` : "Attempt to access memory outside buffer bounds";
+        }, RangeError);
+        EH("ERR_INVALID_ARG_TYPE", function(e, t) {
+          return `The "${e}" argument must be of type number. Received type ${typeof t}`;
+        }, TypeError);
+        EH("ERR_OUT_OF_RANGE", function(e, t, r) {
+          let n = `The value of "${e}" is out of range.`, i = r;
+          return Number.isInteger(r) && Math.abs(r) > 2 ** 32 ? i = iTe(String(r)) : typeof r == "bigint" && (i = String(r), (r > BigInt(2) ** BigInt(32) || r < -(BigInt(2) ** BigInt(32))) && (i = iTe(i)), i += "n"), n += ` It must be ${t}. Received ${i}`, n;
+        }, RangeError);
+        function iTe(e) {
+          let t = "", r = e.length, n = e[0] === "-" ? 1 : 0;
+          for (; r >= n + 4; r -= 3) t = `_${e.slice(r - 3, r)}${t}`;
+          return `${e.slice(0, r)}${t}`;
+        }
+        function yTt(e, t, r) {
+          iA(t, "offset"), (e[t] === void 0 || e[t + r] === void 0) && Y4(t, e.length - (r + 1));
+        }
+        function vTe(e, t, r, n, i, a) {
+          if (e > r || e < t) {
+            let o = typeof t == "bigint" ? "n" : "", s;
+            throw t === 0 || t === BigInt(0) ? s = `>= 0${o} and < 2${o} ** ${(a + 1) * 8}${o}` : s = `>= -(2${o} ** ${(a + 1) * 8 - 1}${o}) and < 2 ** ${(a + 1) * 8 - 1}${o}`, new tA.ERR_OUT_OF_RANGE("value", s, e);
+          }
+          yTt(n, i, a);
+        }
+        function iA(e, t) {
+          if (typeof e != "number") throw new tA.ERR_INVALID_ARG_TYPE(t, "number", e);
+        }
+        function Y4(e, t, r) {
+          throw Math.floor(e) !== e ? (iA(e, r), new tA.ERR_OUT_OF_RANGE("offset", "an integer", e)) : t < 0 ? new tA.ERR_BUFFER_OUT_OF_BOUNDS() : new tA.ERR_OUT_OF_RANGE("offset", `>= ${0} and <= ${t}`, e);
+        }
+        var _Tt = /[^+/0-9A-Za-z-_]/g;
+        function xTt(e) {
+          if (e = e.split("=")[0], e = e.trim().replace(_Tt, ""), e.length < 2) return "";
+          for (; e.length % 4 !== 0; ) e = e + "=";
+          return e;
+        }
+        function AH(e, t) {
+          t = t || 1 / 0;
+          let r, n = e.length, i = null, a = [];
+          for (let o = 0; o < n; ++o) {
+            if (r = e.charCodeAt(o), r > 55295 && r < 57344) {
+              if (!i) {
+                if (r > 56319) {
+                  (t -= 3) > -1 && a.push(239, 191, 189);
+                  continue;
+                } else if (o + 1 === n) {
+                  (t -= 3) > -1 && a.push(239, 191, 189);
+                  continue;
+                }
+                i = r;
+                continue;
+              }
+              if (r < 56320) {
+                (t -= 3) > -1 && a.push(239, 191, 189), i = r;
+                continue;
+              }
+              r = (i - 55296 << 10 | r - 56320) + 65536;
+            } else i && (t -= 3) > -1 && a.push(239, 191, 189);
+            if (i = null, r < 128) {
+              if ((t -= 1) < 0) break;
+              a.push(r);
+            } else if (r < 2048) {
+              if ((t -= 2) < 0) break;
+              a.push(r >> 6 | 192, r & 63 | 128);
+            } else if (r < 65536) {
+              if ((t -= 3) < 0) break;
+              a.push(r >> 12 | 224, r >> 6 & 63 | 128, r & 63 | 128);
+            } else if (r < 1114112) {
+              if ((t -= 4) < 0) break;
+              a.push(r >> 18 | 240, r >> 12 & 63 | 128, r >> 6 & 63 | 128, r & 63 | 128);
+            } else throw new Error("Invalid code point");
+          }
+          return a;
+        }
+        function bTt(e) {
+          let t = [];
+          for (let r = 0; r < e.length; ++r) t.push(e.charCodeAt(r) & 255);
+          return t;
+        }
+        function wTt(e, t) {
+          let r, n, i, a = [];
+          for (let o = 0; o < e.length && !((t -= 2) < 0); ++o) r = e.charCodeAt(o), n = r >> 8, i = r % 256, a.push(i), a.push(n);
+          return a;
+        }
+        function pTe(e) {
+          return bH.toByteArray(xTt(e));
+        }
+        function Z8(e, t, r, n) {
+          let i;
+          for (i = 0; i < n && !(i + r >= t.length || i >= e.length); ++i) t[i + r] = e[i];
+          return i;
+        }
+        function Hm(e, t) {
+          return e instanceof t || e != null && e.constructor != null && e.constructor.name != null && e.constructor.name === t.name;
+        }
+        function kH(e) {
+          return e !== e;
+        }
+        var TTt = function() {
+          let e = "0123456789abcdef", t = new Array(256);
+          for (let r = 0; r < 16; ++r) {
+            let n = r * 16;
+            for (let i = 0; i < 16; ++i) t[n + i] = e[r] + e[i];
+          }
+          return t;
+        }();
+        function N_(e) {
+          return typeof BigInt == "undefined" ? ATt : e;
+        }
+        function ATt() {
+          throw new Error("BigInt not supported");
+        }
+      });
+      var Y8 = ye(($fr, gTe) => {
+        gTe.exports = function() {
+          if (typeof Symbol != "function" || typeof Object.getOwnPropertySymbols != "function") return false;
+          if (typeof Symbol.iterator == "symbol") return true;
+          var t = {}, r = Symbol("test"), n = Object(r);
+          if (typeof r == "string" || Object.prototype.toString.call(r) !== "[object Symbol]" || Object.prototype.toString.call(n) !== "[object Symbol]") return false;
+          var i = 42;
+          t[r] = i;
+          for (var a in t) return false;
+          if (typeof Object.keys == "function" && Object.keys(t).length !== 0 || typeof Object.getOwnPropertyNames == "function" && Object.getOwnPropertyNames(t).length !== 0) return false;
+          var o = Object.getOwnPropertySymbols(t);
+          if (o.length !== 1 || o[0] !== r || !Object.prototype.propertyIsEnumerable.call(t, r)) return false;
+          if (typeof Object.getOwnPropertyDescriptor == "function") {
+            var s = Object.getOwnPropertyDescriptor(t, r);
+            if (s.value !== i || s.enumerable !== true) return false;
+          }
+          return true;
+        };
+      });
+      var K4 = ye((Qfr, mTe) => {
+        var STt = Y8();
+        mTe.exports = function() {
+          return STt() && !!Symbol.toStringTag;
+        };
+      });
+      var CH = ye((ehr, yTe) => {
+        yTe.exports = Object;
+      });
+      var xTe = ye((thr, _Te) => {
+        _Te.exports = Error;
+      });
+      var wTe = ye((rhr, bTe) => {
+        bTe.exports = EvalError;
+      });
+      var ATe = ye((ihr, TTe) => {
+        TTe.exports = RangeError;
+      });
+      var MTe = ye((nhr, STe) => {
+        STe.exports = ReferenceError;
+      });
+      var LH = ye((ahr, ETe) => {
+        ETe.exports = SyntaxError;
+      });
+      var aA = ye((ohr, kTe) => {
+        kTe.exports = TypeError;
+      });
+      var LTe = ye((shr, CTe) => {
+        CTe.exports = URIError;
+      });
+      var ITe = ye((lhr, PTe) => {
+        PTe.exports = Math.abs;
+      });
+      var DTe = ye((uhr, RTe) => {
+        RTe.exports = Math.floor;
+      });
+      var zTe = ye((chr, FTe) => {
+        FTe.exports = Math.max;
+      });
+      var qTe = ye((fhr, OTe) => {
+        OTe.exports = Math.min;
+      });
+      var NTe = ye((hhr, BTe) => {
+        BTe.exports = Math.pow;
+      });
+      var VTe = ye((dhr, UTe) => {
+        UTe.exports = Math.round;
+      });
+      var HTe = ye((vhr, GTe) => {
+        GTe.exports = Number.isNaN || function(t) {
+          return t !== t;
+        };
+      });
+      var WTe = ye((phr, jTe) => {
+        var MTt = HTe();
+        jTe.exports = function(t) {
+          return MTt(t) || t === 0 ? t : t < 0 ? -1 : 1;
+        };
+      });
+      var ZTe = ye((ghr, XTe) => {
+        XTe.exports = Object.getOwnPropertyDescriptor;
+      });
+      var x2 = ye((mhr, YTe) => {
+        var K8 = ZTe();
+        if (K8) try {
+          K8([], "length");
+        } catch (e) {
+          K8 = null;
+        }
+        YTe.exports = K8;
+      });
+      var J4 = ye((yhr, KTe) => {
+        var J8 = Object.defineProperty || false;
+        if (J8) try {
+          J8({}, "a", { value: 1 });
+        } catch (e) {
+          J8 = false;
+        }
+        KTe.exports = J8;
+      });
+      var QTe = ye((_hr, $Te) => {
+        var JTe = typeof Symbol != "undefined" && Symbol, ETt = Y8();
+        $Te.exports = function() {
+          return typeof JTe != "function" || typeof Symbol != "function" || typeof JTe("foo") != "symbol" || typeof Symbol("bar") != "symbol" ? false : ETt();
+        };
+      });
+      var PH = ye((xhr, eAe) => {
+        eAe.exports = typeof Reflect != "undefined" && Reflect.getPrototypeOf || null;
+      });
+      var IH = ye((bhr, tAe) => {
+        var kTt = CH();
+        tAe.exports = kTt.getPrototypeOf || null;
+      });
+      var nAe = ye((whr, iAe) => {
+        var CTt = "Function.prototype.bind called on incompatible ", LTt = Object.prototype.toString, PTt = Math.max, ITt = "[object Function]", rAe = function(t, r) {
+          for (var n = [], i = 0; i < t.length; i += 1) n[i] = t[i];
+          for (var a = 0; a < r.length; a += 1) n[a + t.length] = r[a];
+          return n;
+        }, RTt = function(t, r) {
+          for (var n = [], i = r, a = 0; i < t.length; i += 1, a += 1) n[a] = t[i];
+          return n;
+        }, DTt = function(e, t) {
+          for (var r = "", n = 0; n < e.length; n += 1) r += e[n], n + 1 < e.length && (r += t);
+          return r;
+        };
+        iAe.exports = function(t) {
+          var r = this;
+          if (typeof r != "function" || LTt.apply(r) !== ITt) throw new TypeError(CTt + r);
+          for (var n = RTt(arguments, 1), i, a = function() {
+            if (this instanceof i) {
+              var c = r.apply(this, rAe(n, arguments));
+              return Object(c) === c ? c : this;
+            }
+            return r.apply(t, rAe(n, arguments));
+          }, o = PTt(0, r.length - n.length), s = [], l = 0; l < o; l++) s[l] = "$" + l;
+          if (i = Function("binder", "return function (" + DTt(s, ",") + "){ return binder.apply(this,arguments); }")(a), r.prototype) {
+            var u = function() {
+            };
+            u.prototype = r.prototype, i.prototype = new u(), u.prototype = null;
+          }
+          return i;
+        };
+      });
+      var oA = ye((Thr, aAe) => {
+        var FTt = nAe();
+        aAe.exports = Function.prototype.bind || FTt;
+      });
+      var $8 = ye((Ahr, oAe) => {
+        oAe.exports = Function.prototype.call;
+      });
+      var RH = ye((Shr, sAe) => {
+        sAe.exports = Function.prototype.apply;
+      });
+      var uAe = ye((Mhr, lAe) => {
+        lAe.exports = typeof Reflect != "undefined" && Reflect && Reflect.apply;
+      });
+      var fAe = ye((Ehr, cAe) => {
+        var zTt = oA(), OTt = RH(), qTt = $8(), BTt = uAe();
+        cAe.exports = BTt || zTt.call(qTt, OTt);
+      });
+      var dAe = ye((khr, hAe) => {
+        var NTt = oA(), UTt = aA(), VTt = $8(), GTt = fAe();
+        hAe.exports = function(t) {
+          if (t.length < 1 || typeof t[0] != "function") throw new UTt("a function is required");
+          return GTt(NTt, VTt, t);
+        };
+      });
+      var _Ae = ye((Chr, yAe) => {
+        var HTt = dAe(), vAe = x2(), gAe;
+        try {
+          gAe = [].__proto__ === Array.prototype;
+        } catch (e) {
+          if (!e || typeof e != "object" || !("code" in e) || e.code !== "ERR_PROTO_ACCESS") throw e;
+        }
+        var DH = !!gAe && vAe && vAe(Object.prototype, "__proto__"), mAe = Object, pAe = mAe.getPrototypeOf;
+        yAe.exports = DH && typeof DH.get == "function" ? HTt([DH.get]) : typeof pAe == "function" ? function(t) {
+          return pAe(t == null ? t : mAe(t));
+        } : false;
+      });
+      var AAe = ye((Lhr, TAe) => {
+        var xAe = PH(), bAe = IH(), wAe = _Ae();
+        TAe.exports = xAe ? function(t) {
+          return xAe(t);
+        } : bAe ? function(t) {
+          if (!t || typeof t != "object" && typeof t != "function") throw new TypeError("getProto: not an object");
+          return bAe(t);
+        } : wAe ? function(t) {
+          return wAe(t);
+        } : null;
+      });
+      var MAe = ye((Phr, SAe) => {
+        var jTt = Function.prototype.call, WTt = Object.prototype.hasOwnProperty, XTt = oA();
+        SAe.exports = XTt.call(jTt, WTt);
+      });
+      var tR = ye((Ihr, IAe) => {
+        var lu, ZTt = CH(), YTt = xTe(), KTt = wTe(), JTt = ATe(), $Tt = MTe(), cA = LH(), uA = aA(), QTt = LTe(), eAt = ITe(), tAt = DTe(), rAt = zTe(), iAt = qTe(), nAt = NTe(), aAt = VTe(), oAt = WTe(), LAe = Function, FH = function(e) {
+          try {
+            return LAe('"use strict"; return (' + e + ").constructor;")();
+          } catch (t) {
+          }
+        }, $4 = x2(), sAt = J4(), zH = function() {
+          throw new uA();
+        }, lAt = $4 ? function() {
+          try {
+            return arguments.callee, zH;
+          } catch (e) {
+            try {
+              return $4(arguments, "callee").get;
+            } catch (t) {
+              return zH;
+            }
+          }
+        }() : zH, sA = QTe()(), tv = AAe(), uAt = IH(), cAt = PH(), PAe = RH(), Q4 = $8(), lA = {}, fAt = typeof Uint8Array == "undefined" || !tv ? lu : tv(Uint8Array), b2 = { __proto__: null, "%AggregateError%": typeof AggregateError == "undefined" ? lu : AggregateError, "%Array%": Array, "%ArrayBuffer%": typeof ArrayBuffer == "undefined" ? lu : ArrayBuffer, "%ArrayIteratorPrototype%": sA && tv ? tv([][Symbol.iterator]()) : lu, "%AsyncFromSyncIteratorPrototype%": lu, "%AsyncFunction%": lA, "%AsyncGenerator%": lA, "%AsyncGeneratorFunction%": lA, "%AsyncIteratorPrototype%": lA, "%Atomics%": typeof Atomics == "undefined" ? lu : Atomics, "%BigInt%": typeof BigInt == "undefined" ? lu : BigInt, "%BigInt64Array%": typeof BigInt64Array == "undefined" ? lu : BigInt64Array, "%BigUint64Array%": typeof BigUint64Array == "undefined" ? lu : BigUint64Array, "%Boolean%": Boolean, "%DataView%": typeof DataView == "undefined" ? lu : DataView, "%Date%": Date, "%decodeURI%": decodeURI, "%decodeURIComponent%": decodeURIComponent, "%encodeURI%": encodeURI, "%encodeURIComponent%": encodeURIComponent, "%Error%": YTt, "%eval%": eval, "%EvalError%": KTt, "%Float16Array%": typeof Float16Array == "undefined" ? lu : Float16Array, "%Float32Array%": typeof Float32Array == "undefined" ? lu : Float32Array, "%Float64Array%": typeof Float64Array == "undefined" ? lu : Float64Array, "%FinalizationRegistry%": typeof FinalizationRegistry == "undefined" ? lu : FinalizationRegistry, "%Function%": LAe, "%GeneratorFunction%": lA, "%Int8Array%": typeof Int8Array == "undefined" ? lu : Int8Array, "%Int16Array%": typeof Int16Array == "undefined" ? lu : Int16Array, "%Int32Array%": typeof Int32Array == "undefined" ? lu : Int32Array, "%isFinite%": isFinite, "%isNaN%": isNaN, "%IteratorPrototype%": sA && tv ? tv(tv([][Symbol.iterator]())) : lu, "%JSON%": typeof JSON == "object" ? JSON : lu, "%Map%": typeof Map == "undefined" ? lu : Map, "%MapIteratorPrototype%": typeof Map == "undefined" || !sA || !tv ? lu : tv((/* @__PURE__ */ new Map())[Symbol.iterator]()), "%Math%": Math, "%Number%": Number, "%Object%": ZTt, "%Object.getOwnPropertyDescriptor%": $4, "%parseFloat%": parseFloat, "%parseInt%": parseInt, "%Promise%": typeof Promise == "undefined" ? lu : Promise, "%Proxy%": typeof Proxy == "undefined" ? lu : Proxy, "%RangeError%": JTt, "%ReferenceError%": $Tt, "%Reflect%": typeof Reflect == "undefined" ? lu : Reflect, "%RegExp%": RegExp, "%Set%": typeof Set == "undefined" ? lu : Set, "%SetIteratorPrototype%": typeof Set == "undefined" || !sA || !tv ? lu : tv((/* @__PURE__ */ new Set())[Symbol.iterator]()), "%SharedArrayBuffer%": typeof SharedArrayBuffer == "undefined" ? lu : SharedArrayBuffer, "%String%": String, "%StringIteratorPrototype%": sA && tv ? tv(""[Symbol.iterator]()) : lu, "%Symbol%": sA ? Symbol : lu, "%SyntaxError%": cA, "%ThrowTypeError%": lAt, "%TypedArray%": fAt, "%TypeError%": uA, "%Uint8Array%": typeof Uint8Array == "undefined" ? lu : Uint8Array, "%Uint8ClampedArray%": typeof Uint8ClampedArray == "undefined" ? lu : Uint8ClampedArray, "%Uint16Array%": typeof Uint16Array == "undefined" ? lu : Uint16Array, "%Uint32Array%": typeof Uint32Array == "undefined" ? lu : Uint32Array, "%URIError%": QTt, "%WeakMap%": typeof WeakMap == "undefined" ? lu : WeakMap, "%WeakRef%": typeof WeakRef == "undefined" ? lu : WeakRef, "%WeakSet%": typeof WeakSet == "undefined" ? lu : WeakSet, "%Function.prototype.call%": Q4, "%Function.prototype.apply%": PAe, "%Object.defineProperty%": sAt, "%Object.getPrototypeOf%": uAt, "%Math.abs%": eAt, "%Math.floor%": tAt, "%Math.max%": rAt, "%Math.min%": iAt, "%Math.pow%": nAt, "%Math.round%": aAt, "%Math.sign%": oAt, "%Reflect.getPrototypeOf%": cAt };
+        if (tv) try {
+          null.error;
+        } catch (e) {
+          EAe = tv(tv(e)), b2["%Error.prototype%"] = EAe;
+        }
+        var EAe, hAt = function e(t) {
+          var r;
+          if (t === "%AsyncFunction%") r = FH("async function () {}");
+          else if (t === "%GeneratorFunction%") r = FH("function* () {}");
+          else if (t === "%AsyncGeneratorFunction%") r = FH("async function* () {}");
+          else if (t === "%AsyncGenerator%") {
+            var n = e("%AsyncGeneratorFunction%");
+            n && (r = n.prototype);
+          } else if (t === "%AsyncIteratorPrototype%") {
+            var i = e("%AsyncGenerator%");
+            i && tv && (r = tv(i.prototype));
+          }
+          return b2[t] = r, r;
+        }, kAe = { __proto__: null, "%ArrayBufferPrototype%": ["ArrayBuffer", "prototype"], "%ArrayPrototype%": ["Array", "prototype"], "%ArrayProto_entries%": ["Array", "prototype", "entries"], "%ArrayProto_forEach%": ["Array", "prototype", "forEach"], "%ArrayProto_keys%": ["Array", "prototype", "keys"], "%ArrayProto_values%": ["Array", "prototype", "values"], "%AsyncFunctionPrototype%": ["AsyncFunction", "prototype"], "%AsyncGenerator%": ["AsyncGeneratorFunction", "prototype"], "%AsyncGeneratorPrototype%": ["AsyncGeneratorFunction", "prototype", "prototype"], "%BooleanPrototype%": ["Boolean", "prototype"], "%DataViewPrototype%": ["DataView", "prototype"], "%DatePrototype%": ["Date", "prototype"], "%ErrorPrototype%": ["Error", "prototype"], "%EvalErrorPrototype%": ["EvalError", "prototype"], "%Float32ArrayPrototype%": ["Float32Array", "prototype"], "%Float64ArrayPrototype%": ["Float64Array", "prototype"], "%FunctionPrototype%": ["Function", "prototype"], "%Generator%": ["GeneratorFunction", "prototype"], "%GeneratorPrototype%": ["GeneratorFunction", "prototype", "prototype"], "%Int8ArrayPrototype%": ["Int8Array", "prototype"], "%Int16ArrayPrototype%": ["Int16Array", "prototype"], "%Int32ArrayPrototype%": ["Int32Array", "prototype"], "%JSONParse%": ["JSON", "parse"], "%JSONStringify%": ["JSON", "stringify"], "%MapPrototype%": ["Map", "prototype"], "%NumberPrototype%": ["Number", "prototype"], "%ObjectPrototype%": ["Object", "prototype"], "%ObjProto_toString%": ["Object", "prototype", "toString"], "%ObjProto_valueOf%": ["Object", "prototype", "valueOf"], "%PromisePrototype%": ["Promise", "prototype"], "%PromiseProto_then%": ["Promise", "prototype", "then"], "%Promise_all%": ["Promise", "all"], "%Promise_reject%": ["Promise", "reject"], "%Promise_resolve%": ["Promise", "resolve"], "%RangeErrorPrototype%": ["RangeError", "prototype"], "%ReferenceErrorPrototype%": ["ReferenceError", "prototype"], "%RegExpPrototype%": ["RegExp", "prototype"], "%SetPrototype%": ["Set", "prototype"], "%SharedArrayBufferPrototype%": ["SharedArrayBuffer", "prototype"], "%StringPrototype%": ["String", "prototype"], "%SymbolPrototype%": ["Symbol", "prototype"], "%SyntaxErrorPrototype%": ["SyntaxError", "prototype"], "%TypedArrayPrototype%": ["TypedArray", "prototype"], "%TypeErrorPrototype%": ["TypeError", "prototype"], "%Uint8ArrayPrototype%": ["Uint8Array", "prototype"], "%Uint8ClampedArrayPrototype%": ["Uint8ClampedArray", "prototype"], "%Uint16ArrayPrototype%": ["Uint16Array", "prototype"], "%Uint32ArrayPrototype%": ["Uint32Array", "prototype"], "%URIErrorPrototype%": ["URIError", "prototype"], "%WeakMapPrototype%": ["WeakMap", "prototype"], "%WeakSetPrototype%": ["WeakSet", "prototype"] }, eE = oA(), Q8 = MAe(), dAt = eE.call(Q4, Array.prototype.concat), vAt = eE.call(PAe, Array.prototype.splice), CAe = eE.call(Q4, String.prototype.replace), eR = eE.call(Q4, String.prototype.slice), pAt = eE.call(Q4, RegExp.prototype.exec), gAt = /[^%.[\]]+|\[(?:(-?\d+(?:\.\d+)?)|(["'])((?:(?!\2)[^\\]|\\.)*?)\2)\]|(?=(?:\.|\[\])(?:\.|\[\]|%$))/g, mAt = /\\(\\)?/g, yAt = function(t) {
+          var r = eR(t, 0, 1), n = eR(t, -1);
+          if (r === "%" && n !== "%") throw new cA("invalid intrinsic syntax, expected closing `%`");
+          if (n === "%" && r !== "%") throw new cA("invalid intrinsic syntax, expected opening `%`");
+          var i = [];
+          return CAe(t, gAt, function(a, o, s, l) {
+            i[i.length] = s ? CAe(l, mAt, "$1") : o || a;
+          }), i;
+        }, _At = function(t, r) {
+          var n = t, i;
+          if (Q8(kAe, n) && (i = kAe[n], n = "%" + i[0] + "%"), Q8(b2, n)) {
+            var a = b2[n];
+            if (a === lA && (a = hAt(n)), typeof a == "undefined" && !r) throw new uA("intrinsic " + t + " exists, but is not available. Please file an issue!");
+            return { alias: i, name: n, value: a };
+          }
+          throw new cA("intrinsic " + t + " does not exist!");
+        };
+        IAe.exports = function(t, r) {
+          if (typeof t != "string" || t.length === 0) throw new uA("intrinsic name must be a non-empty string");
+          if (arguments.length > 1 && typeof r != "boolean") throw new uA('"allowMissing" argument must be a boolean');
+          if (pAt(/^%?[^%]*%?$/, t) === null) throw new cA("`%` may not be present anywhere but at the beginning and end of the intrinsic name");
+          var n = yAt(t), i = n.length > 0 ? n[0] : "", a = _At("%" + i + "%", r), o = a.name, s = a.value, l = false, u = a.alias;
+          u && (i = u[0], vAt(n, dAt([0, 1], u)));
+          for (var c = 1, f = true; c < n.length; c += 1) {
+            var h = n[c], d = eR(h, 0, 1), v = eR(h, -1);
+            if ((d === '"' || d === "'" || d === "`" || v === '"' || v === "'" || v === "`") && d !== v) throw new cA("property names with quotes must have matching quotes");
+            if ((h === "constructor" || !f) && (l = true), i += "." + h, o = "%" + i + "%", Q8(b2, o)) s = b2[o];
+            else if (s != null) {
+              if (!(h in s)) {
+                if (!r) throw new uA("base intrinsic for " + t + " exists, but the property is not available.");
+                return;
+              }
+              if ($4 && c + 1 >= n.length) {
+                var _ = $4(s, h);
+                f = !!_, f && "get" in _ && !("originalValue" in _.get) ? s = _.get : s = s[h];
+              } else f = Q8(s, h), s = s[h];
+              f && !l && (b2[o] = s);
+            }
+          }
+          return s;
+        };
+      });
+      var zAe = ye((Rhr, FAe) => {
+        var RAe = J4(), xAt = LH(), fA = aA(), DAe = x2();
+        FAe.exports = function(t, r, n) {
+          if (!t || typeof t != "object" && typeof t != "function") throw new fA("`obj` must be an object or a function`");
+          if (typeof r != "string" && typeof r != "symbol") throw new fA("`property` must be a string or a symbol`");
+          if (arguments.length > 3 && typeof arguments[3] != "boolean" && arguments[3] !== null) throw new fA("`nonEnumerable`, if provided, must be a boolean or null");
+          if (arguments.length > 4 && typeof arguments[4] != "boolean" && arguments[4] !== null) throw new fA("`nonWritable`, if provided, must be a boolean or null");
+          if (arguments.length > 5 && typeof arguments[5] != "boolean" && arguments[5] !== null) throw new fA("`nonConfigurable`, if provided, must be a boolean or null");
+          if (arguments.length > 6 && typeof arguments[6] != "boolean") throw new fA("`loose`, if provided, must be a boolean");
+          var i = arguments.length > 3 ? arguments[3] : null, a = arguments.length > 4 ? arguments[4] : null, o = arguments.length > 5 ? arguments[5] : null, s = arguments.length > 6 ? arguments[6] : false, l = !!DAe && DAe(t, r);
+          if (RAe) RAe(t, r, { configurable: o === null && l ? l.configurable : !o, enumerable: i === null && l ? l.enumerable : !i, value: n, writable: a === null && l ? l.writable : !a });
+          else if (s || !i && !a && !o) t[r] = n;
+          else throw new xAt("This environment does not support defining a property as non-configurable, non-writable, or non-enumerable.");
+        };
+      });
+      var qH = ye((Dhr, qAe) => {
+        var OH = J4(), OAe = function() {
+          return !!OH;
+        };
+        OAe.hasArrayLengthDefineBug = function() {
+          if (!OH) return null;
+          try {
+            return OH([], "length", { value: 1 }).length !== 1;
+          } catch (t) {
+            return true;
+          }
+        };
+        qAe.exports = OAe;
+      });
+      var GAe = ye((Fhr, VAe) => {
+        var bAt = tR(), BAe = zAe(), wAt = qH()(), NAe = x2(), UAe = aA(), TAt = bAt("%Math.floor%");
+        VAe.exports = function(t, r) {
+          if (typeof t != "function") throw new UAe("`fn` is not a function");
+          if (typeof r != "number" || r < 0 || r > 4294967295 || TAt(r) !== r) throw new UAe("`length` must be a positive 32-bit integer");
+          var n = arguments.length > 2 && !!arguments[2], i = true, a = true;
+          if ("length" in t && NAe) {
+            var o = NAe(t, "length");
+            o && !o.configurable && (i = false), o && !o.writable && (a = false);
+          }
+          return (i || a || !n) && (wAt ? BAe(t, "length", r, true, true) : BAe(t, "length", r)), t;
+        };
+      });
+      var tE = ye((zhr, rR) => {
+        var BH = oA(), iR = tR(), AAt = GAe(), SAt = aA(), WAe = iR("%Function.prototype.apply%"), XAe = iR("%Function.prototype.call%"), ZAe = iR("%Reflect.apply%", true) || BH.call(XAe, WAe), HAe = J4(), MAt = iR("%Math.max%");
+        rR.exports = function(t) {
+          if (typeof t != "function") throw new SAt("a function is required");
+          var r = ZAe(BH, XAe, arguments);
+          return AAt(r, 1 + MAt(0, t.length - (arguments.length - 1)), true);
+        };
+        var jAe = function() {
+          return ZAe(BH, WAe, arguments);
+        };
+        HAe ? HAe(rR.exports, "apply", { value: jAe }) : rR.exports.apply = jAe;
+      });
+      var hA = ye((Ohr, JAe) => {
+        var YAe = tR(), KAe = tE(), EAt = KAe(YAe("String.prototype.indexOf"));
+        JAe.exports = function(t, r) {
+          var n = YAe(t, !!r);
+          return typeof n == "function" && EAt(t, ".prototype.") > -1 ? KAe(n) : n;
+        };
+      });
+      var e5e = ye((qhr, QAe) => {
+        var kAt = K4()(), CAt = hA(), NH = CAt("Object.prototype.toString"), nR = function(t) {
+          return kAt && t && typeof t == "object" && Symbol.toStringTag in t ? false : NH(t) === "[object Arguments]";
+        }, $Ae = function(t) {
+          return nR(t) ? true : t !== null && typeof t == "object" && typeof t.length == "number" && t.length >= 0 && NH(t) !== "[object Array]" && NH(t.callee) === "[object Function]";
+        }, LAt = function() {
+          return nR(arguments);
+        }();
+        nR.isLegacyArguments = $Ae;
+        QAe.exports = LAt ? nR : $Ae;
+      });
+      var i5e = ye((Bhr, r5e) => {
+        var PAt = Object.prototype.toString, IAt = Function.prototype.toString, RAt = /^\s*(?:function)?\*/, t5e = K4()(), UH = Object.getPrototypeOf, DAt = function() {
+          if (!t5e) return false;
+          try {
+            return Function("return function*() {}")();
+          } catch (e) {
+          }
+        }, VH;
+        r5e.exports = function(t) {
+          if (typeof t != "function") return false;
+          if (RAt.test(IAt.call(t))) return true;
+          if (!t5e) {
+            var r = PAt.call(t);
+            return r === "[object GeneratorFunction]";
+          }
+          if (!UH) return false;
+          if (typeof VH == "undefined") {
+            var n = DAt();
+            VH = n ? UH(n) : false;
+          }
+          return UH(t) === VH;
+        };
+      });
+      var s5e = ye((Nhr, o5e) => {
+        var a5e = Function.prototype.toString, dA = typeof Reflect == "object" && Reflect !== null && Reflect.apply, HH, aR;
+        if (typeof dA == "function" && typeof Object.defineProperty == "function") try {
+          HH = Object.defineProperty({}, "length", { get: function() {
+            throw aR;
+          } }), aR = {}, dA(function() {
+            throw 42;
+          }, null, HH);
+        } catch (e) {
+          e !== aR && (dA = null);
+        }
+        else dA = null;
+        var FAt = /^\s*class\b/, jH = function(t) {
+          try {
+            var r = a5e.call(t);
+            return FAt.test(r);
+          } catch (n) {
+            return false;
+          }
+        }, GH = function(t) {
+          try {
+            return jH(t) ? false : (a5e.call(t), true);
+          } catch (r) {
+            return false;
+          }
+        }, oR = Object.prototype.toString, zAt = "[object Object]", OAt = "[object Function]", qAt = "[object GeneratorFunction]", BAt = "[object HTMLAllCollection]", NAt = "[object HTML document.all class]", UAt = "[object HTMLCollection]", VAt = typeof Symbol == "function" && !!Symbol.toStringTag, GAt = !(0 in [,]), WH = function() {
+          return false;
+        };
+        typeof document == "object" && (n5e = document.all, oR.call(n5e) === oR.call(document.all) && (WH = function(t) {
+          if ((GAt || !t) && (typeof t == "undefined" || typeof t == "object")) try {
+            var r = oR.call(t);
+            return (r === BAt || r === NAt || r === UAt || r === zAt) && t("") == null;
+          } catch (n) {
+          }
+          return false;
+        }));
+        var n5e;
+        o5e.exports = dA ? function(t) {
+          if (WH(t)) return true;
+          if (!t || typeof t != "function" && typeof t != "object") return false;
+          try {
+            dA(t, null, HH);
+          } catch (r) {
+            if (r !== aR) return false;
+          }
+          return !jH(t) && GH(t);
+        } : function(t) {
+          if (WH(t)) return true;
+          if (!t || typeof t != "function" && typeof t != "object") return false;
+          if (VAt) return GH(t);
+          if (jH(t)) return false;
+          var r = oR.call(t);
+          return r !== OAt && r !== qAt && !/^\[object HTML/.test(r) ? false : GH(t);
+        };
+      });
+      var XH = ye((Uhr, u5e) => {
+        var HAt = s5e(), jAt = Object.prototype.toString, l5e = Object.prototype.hasOwnProperty, WAt = function(t, r, n) {
+          for (var i = 0, a = t.length; i < a; i++) l5e.call(t, i) && (n == null ? r(t[i], i, t) : r.call(n, t[i], i, t));
+        }, XAt = function(t, r, n) {
+          for (var i = 0, a = t.length; i < a; i++) n == null ? r(t.charAt(i), i, t) : r.call(n, t.charAt(i), i, t);
+        }, ZAt = function(t, r, n) {
+          for (var i in t) l5e.call(t, i) && (n == null ? r(t[i], i, t) : r.call(n, t[i], i, t));
+        }, YAt = function(t, r, n) {
+          if (!HAt(r)) throw new TypeError("iterator must be a function");
+          var i;
+          arguments.length >= 3 && (i = n), jAt.call(t) === "[object Array]" ? WAt(t, r, i) : typeof t == "string" ? XAt(t, r, i) : ZAt(t, r, i);
+        };
+        u5e.exports = YAt;
+      });
+      var YH = ye((Vhr, c5e) => {
+        var ZH = ["BigInt64Array", "BigUint64Array", "Float32Array", "Float64Array", "Int16Array", "Int32Array", "Int8Array", "Uint16Array", "Uint32Array", "Uint8Array", "Uint8ClampedArray"], KAt = typeof globalThis == "undefined" ? window : globalThis;
+        c5e.exports = function() {
+          for (var t = [], r = 0; r < ZH.length; r++) typeof KAt[ZH[r]] == "function" && (t[t.length] = ZH[r]);
+          return t;
+        };
+      });
+      var p5e = ye((Ghr, v5e) => {
+        var lR = XH(), JAt = YH(), f5e = tE(), $H = hA(), sR = x2(), $At = $H("Object.prototype.toString"), d5e = K4()(), h5e = typeof globalThis == "undefined" ? window : globalThis, JH = JAt(), QH = $H("String.prototype.slice"), KH = Object.getPrototypeOf, QAt = $H("Array.prototype.indexOf", true) || function(t, r) {
+          for (var n = 0; n < t.length; n += 1) if (t[n] === r) return n;
+          return -1;
+        }, uR = { __proto__: null };
+        d5e && sR && KH ? lR(JH, function(e) {
+          var t = new h5e[e]();
+          if (Symbol.toStringTag in t) {
+            var r = KH(t), n = sR(r, Symbol.toStringTag);
+            if (!n) {
+              var i = KH(r);
+              n = sR(i, Symbol.toStringTag);
+            }
+            uR["$" + e] = f5e(n.get);
+          }
+        }) : lR(JH, function(e) {
+          var t = new h5e[e](), r = t.slice || t.set;
+          r && (uR["$" + e] = f5e(r));
+        });
+        var e5t = function(t) {
+          var r = false;
+          return lR(uR, function(n, i) {
+            if (!r) try {
+              "$" + n(t) === i && (r = QH(i, 1));
+            } catch (a) {
+            }
+          }), r;
+        }, t5t = function(t) {
+          var r = false;
+          return lR(uR, function(n, i) {
+            if (!r) try {
+              n(t), r = QH(i, 1);
+            } catch (a) {
+            }
+          }), r;
+        };
+        v5e.exports = function(t) {
+          if (!t || typeof t != "object") return false;
+          if (!d5e) {
+            var r = QH($At(t), 8, -1);
+            return QAt(JH, r) > -1 ? r : r !== "Object" ? false : t5t(t);
+          }
+          return sR ? e5t(t) : null;
+        };
+      });
+      var b5e = ye((Hhr, x5e) => {
+        var g5e = XH(), r5t = YH(), tj = hA(), i5t = tj("Object.prototype.toString"), m5e = K4()(), cR = x2(), n5t = typeof globalThis == "undefined" ? window : globalThis, y5e = r5t(), a5t = tj("Array.prototype.indexOf", true) || function(t, r) {
+          for (var n = 0; n < t.length; n += 1) if (t[n] === r) return n;
+          return -1;
+        }, o5t = tj("String.prototype.slice"), _5e = {}, ej = Object.getPrototypeOf;
+        m5e && cR && ej && g5e(y5e, function(e) {
+          var t = new n5t[e]();
+          if (Symbol.toStringTag in t) {
+            var r = ej(t), n = cR(r, Symbol.toStringTag);
+            if (!n) {
+              var i = ej(r);
+              n = cR(i, Symbol.toStringTag);
+            }
+            _5e[e] = n.get;
+          }
+        });
+        var s5t = function(t) {
+          var r = false;
+          return g5e(_5e, function(n, i) {
+            if (!r) try {
+              r = n.call(t) === i;
+            } catch (a) {
+            }
+          }), r;
+        };
+        x5e.exports = function(t) {
+          if (!t || typeof t != "object") return false;
+          if (!m5e || !(Symbol.toStringTag in t)) {
+            var r = o5t(i5t(t), 8, -1);
+            return a5t(y5e, r) > -1;
+          }
+          return cR ? s5t(t) : false;
+        };
+      });
+      var nj = ye((uu) => {
+        var l5t = e5e(), u5t = i5e(), Wg = p5e(), w5e = b5e();
+        function vA(e) {
+          return e.call.bind(e);
+        }
+        var T5e = typeof BigInt != "undefined", A5e = typeof Symbol != "undefined", K0 = vA(Object.prototype.toString), c5t = vA(Number.prototype.valueOf), f5t = vA(String.prototype.valueOf), h5t = vA(Boolean.prototype.valueOf);
+        T5e && (S5e = vA(BigInt.prototype.valueOf));
+        var S5e;
+        A5e && (M5e = vA(Symbol.prototype.valueOf));
+        var M5e;
+        function iE(e, t) {
+          if (typeof e != "object") return false;
+          try {
+            return t(e), true;
+          } catch (r) {
+            return false;
+          }
+        }
+        uu.isArgumentsObject = l5t;
+        uu.isGeneratorFunction = u5t;
+        uu.isTypedArray = w5e;
+        function d5t(e) {
+          return typeof Promise != "undefined" && e instanceof Promise || e !== null && typeof e == "object" && typeof e.then == "function" && typeof e.catch == "function";
+        }
+        uu.isPromise = d5t;
+        function v5t(e) {
+          return typeof ArrayBuffer != "undefined" && ArrayBuffer.isView ? ArrayBuffer.isView(e) : w5e(e) || k5e(e);
+        }
+        uu.isArrayBufferView = v5t;
+        function p5t(e) {
+          return Wg(e) === "Uint8Array";
+        }
+        uu.isUint8Array = p5t;
+        function g5t(e) {
+          return Wg(e) === "Uint8ClampedArray";
+        }
+        uu.isUint8ClampedArray = g5t;
+        function m5t(e) {
+          return Wg(e) === "Uint16Array";
+        }
+        uu.isUint16Array = m5t;
+        function y5t(e) {
+          return Wg(e) === "Uint32Array";
+        }
+        uu.isUint32Array = y5t;
+        function _5t(e) {
+          return Wg(e) === "Int8Array";
+        }
+        uu.isInt8Array = _5t;
+        function x5t(e) {
+          return Wg(e) === "Int16Array";
+        }
+        uu.isInt16Array = x5t;
+        function b5t(e) {
+          return Wg(e) === "Int32Array";
+        }
+        uu.isInt32Array = b5t;
+        function w5t(e) {
+          return Wg(e) === "Float32Array";
+        }
+        uu.isFloat32Array = w5t;
+        function T5t(e) {
+          return Wg(e) === "Float64Array";
+        }
+        uu.isFloat64Array = T5t;
+        function A5t(e) {
+          return Wg(e) === "BigInt64Array";
+        }
+        uu.isBigInt64Array = A5t;
+        function S5t(e) {
+          return Wg(e) === "BigUint64Array";
+        }
+        uu.isBigUint64Array = S5t;
+        function fR(e) {
+          return K0(e) === "[object Map]";
+        }
+        fR.working = typeof Map != "undefined" && fR(/* @__PURE__ */ new Map());
+        function M5t(e) {
+          return typeof Map == "undefined" ? false : fR.working ? fR(e) : e instanceof Map;
+        }
+        uu.isMap = M5t;
+        function hR(e) {
+          return K0(e) === "[object Set]";
+        }
+        hR.working = typeof Set != "undefined" && hR(/* @__PURE__ */ new Set());
+        function E5t(e) {
+          return typeof Set == "undefined" ? false : hR.working ? hR(e) : e instanceof Set;
+        }
+        uu.isSet = E5t;
+        function dR(e) {
+          return K0(e) === "[object WeakMap]";
+        }
+        dR.working = typeof WeakMap != "undefined" && dR(/* @__PURE__ */ new WeakMap());
+        function k5t(e) {
+          return typeof WeakMap == "undefined" ? false : dR.working ? dR(e) : e instanceof WeakMap;
+        }
+        uu.isWeakMap = k5t;
+        function ij(e) {
+          return K0(e) === "[object WeakSet]";
+        }
+        ij.working = typeof WeakSet != "undefined" && ij(/* @__PURE__ */ new WeakSet());
+        function C5t(e) {
+          return ij(e);
+        }
+        uu.isWeakSet = C5t;
+        function vR(e) {
+          return K0(e) === "[object ArrayBuffer]";
+        }
+        vR.working = typeof ArrayBuffer != "undefined" && vR(new ArrayBuffer());
+        function E5e(e) {
+          return typeof ArrayBuffer == "undefined" ? false : vR.working ? vR(e) : e instanceof ArrayBuffer;
+        }
+        uu.isArrayBuffer = E5e;
+        function pR(e) {
+          return K0(e) === "[object DataView]";
+        }
+        pR.working = typeof ArrayBuffer != "undefined" && typeof DataView != "undefined" && pR(new DataView(new ArrayBuffer(1), 0, 1));
+        function k5e(e) {
+          return typeof DataView == "undefined" ? false : pR.working ? pR(e) : e instanceof DataView;
+        }
+        uu.isDataView = k5e;
+        var rj = typeof SharedArrayBuffer != "undefined" ? SharedArrayBuffer : void 0;
+        function rE(e) {
+          return K0(e) === "[object SharedArrayBuffer]";
+        }
+        function C5e(e) {
+          return typeof rj == "undefined" ? false : (typeof rE.working == "undefined" && (rE.working = rE(new rj())), rE.working ? rE(e) : e instanceof rj);
+        }
+        uu.isSharedArrayBuffer = C5e;
+        function L5t(e) {
+          return K0(e) === "[object AsyncFunction]";
+        }
+        uu.isAsyncFunction = L5t;
+        function P5t(e) {
+          return K0(e) === "[object Map Iterator]";
+        }
+        uu.isMapIterator = P5t;
+        function I5t(e) {
+          return K0(e) === "[object Set Iterator]";
+        }
+        uu.isSetIterator = I5t;
+        function R5t(e) {
+          return K0(e) === "[object Generator]";
+        }
+        uu.isGeneratorObject = R5t;
+        function D5t(e) {
+          return K0(e) === "[object WebAssembly.Module]";
+        }
+        uu.isWebAssemblyCompiledModule = D5t;
+        function L5e(e) {
+          return iE(e, c5t);
+        }
+        uu.isNumberObject = L5e;
+        function P5e(e) {
+          return iE(e, f5t);
+        }
+        uu.isStringObject = P5e;
+        function I5e(e) {
+          return iE(e, h5t);
+        }
+        uu.isBooleanObject = I5e;
+        function R5e(e) {
+          return T5e && iE(e, S5e);
+        }
+        uu.isBigIntObject = R5e;
+        function D5e(e) {
+          return A5e && iE(e, M5e);
+        }
+        uu.isSymbolObject = D5e;
+        function F5t(e) {
+          return L5e(e) || P5e(e) || I5e(e) || R5e(e) || D5e(e);
+        }
+        uu.isBoxedPrimitive = F5t;
+        function z5t(e) {
+          return typeof Uint8Array != "undefined" && (E5e(e) || C5e(e));
+        }
+        uu.isAnyArrayBuffer = z5t;
+        ["isProxy", "isExternal", "isModuleNamespaceObject"].forEach(function(e) {
+          Object.defineProperty(uu, e, { enumerable: false, value: function() {
+            throw new Error(e + " is not supported in userland");
+          } });
+        });
+      });
+      var aj = ye((Whr, F5e) => {
+        F5e.exports = function(t) {
+          return t && typeof t == "object" && typeof t.copy == "function" && typeof t.fill == "function" && typeof t.readUInt8 == "function";
+        };
+      });
+      var fj = ye((cu) => {
+        var z5e = Object.getOwnPropertyDescriptors || function(t) {
+          for (var r = Object.keys(t), n = {}, i = 0; i < r.length; i++) n[r[i]] = Object.getOwnPropertyDescriptor(t, r[i]);
+          return n;
+        }, O5t = /%[sdj%]/g;
+        cu.format = function(e) {
+          if (!wR(e)) {
+            for (var t = [], r = 0; r < arguments.length; r++) t.push(U_(arguments[r]));
+            return t.join(" ");
+          }
+          for (var r = 1, n = arguments, i = n.length, a = String(e).replace(O5t, function(s) {
+            if (s === "%%") return "%";
+            if (r >= i) return s;
+            switch (s) {
+              case "%s":
+                return String(n[r++]);
+              case "%d":
+                return Number(n[r++]);
+              case "%j":
+                try {
+                  return JSON.stringify(n[r++]);
+                } catch (l) {
+                  return "[Circular]";
+                }
+              default:
+                return s;
+            }
+          }), o = n[r]; r < i; o = n[++r]) bR(o) || !pA(o) ? a += " " + o : a += " " + U_(o);
+          return a;
+        };
+        cu.deprecate = function(e, t) {
+          if (typeof process != "undefined" && process.noDeprecation === true) return e;
+          if (typeof process == "undefined") return function() {
+            return cu.deprecate(e, t).apply(this, arguments);
+          };
+          var r = false;
+          function n() {
+            if (!r) {
+              if (process.throwDeprecation) throw new Error(t);
+              process.traceDeprecation ? console.trace(t) : console.error(t), r = true;
+            }
+            return e.apply(this, arguments);
+          }
+          return n;
+        };
+        var gR = {}, O5e = /^$/;
+        mR = "false", mR = mR.replace(/[|\\{}()[\]^$+?.]/g, "\\$&").replace(/\*/g, ".*").replace(/,/g, "$|^").toUpperCase(), O5e = new RegExp("^" + mR + "$", "i");
+        var mR;
+        cu.debuglog = function(e) {
+          if (e = e.toUpperCase(), !gR[e]) if (O5e.test(e)) {
+            var t = process.pid;
+            gR[e] = function() {
+              var r = cu.format.apply(cu, arguments);
+              console.error("%s %d: %s", e, t, r);
+            };
+          } else gR[e] = function() {
+          };
+          return gR[e];
+        };
+        function U_(e, t) {
+          var r = { seen: [], stylize: B5t };
+          return arguments.length >= 3 && (r.depth = arguments[2]), arguments.length >= 4 && (r.colors = arguments[3]), uj(t) ? r.showHidden = t : t && cu._extend(r, t), T2(r.showHidden) && (r.showHidden = false), T2(r.depth) && (r.depth = 2), T2(r.colors) && (r.colors = false), T2(r.customInspect) && (r.customInspect = true), r.colors && (r.stylize = q5t), _R(r, e, r.depth);
+        }
+        cu.inspect = U_;
+        U_.colors = { bold: [1, 22], italic: [3, 23], underline: [4, 24], inverse: [7, 27], white: [37, 39], grey: [90, 39], black: [30, 39], blue: [34, 39], cyan: [36, 39], green: [32, 39], magenta: [35, 39], red: [31, 39], yellow: [33, 39] };
+        U_.styles = { special: "cyan", number: "yellow", boolean: "yellow", undefined: "grey", null: "bold", string: "green", date: "magenta", regexp: "red" };
+        function q5t(e, t) {
+          var r = U_.styles[t];
+          return r ? "\x1B[" + U_.colors[r][0] + "m" + e + "\x1B[" + U_.colors[r][1] + "m" : e;
+        }
+        function B5t(e, t) {
+          return e;
+        }
+        function N5t(e) {
+          var t = {};
+          return e.forEach(function(r, n) {
+            t[r] = true;
+          }), t;
+        }
+        function _R(e, t, r) {
+          if (e.customInspect && t && yR(t.inspect) && t.inspect !== cu.inspect && !(t.constructor && t.constructor.prototype === t)) {
+            var n = t.inspect(r, e);
+            return wR(n) || (n = _R(e, n, r)), n;
+          }
+          var i = U5t(e, t);
+          if (i) return i;
+          var a = Object.keys(t), o = N5t(a);
+          if (e.showHidden && (a = Object.getOwnPropertyNames(t)), aE(t) && (a.indexOf("message") >= 0 || a.indexOf("description") >= 0)) return oj(t);
+          if (a.length === 0) {
+            if (yR(t)) {
+              var s = t.name ? ": " + t.name : "";
+              return e.stylize("[Function" + s + "]", "special");
+            }
+            if (nE(t)) return e.stylize(RegExp.prototype.toString.call(t), "regexp");
+            if (xR(t)) return e.stylize(Date.prototype.toString.call(t), "date");
+            if (aE(t)) return oj(t);
+          }
+          var l = "", u = false, c = ["{", "}"];
+          if (q5e(t) && (u = true, c = ["[", "]"]), yR(t)) {
+            var f = t.name ? ": " + t.name : "";
+            l = " [Function" + f + "]";
+          }
+          if (nE(t) && (l = " " + RegExp.prototype.toString.call(t)), xR(t) && (l = " " + Date.prototype.toUTCString.call(t)), aE(t) && (l = " " + oj(t)), a.length === 0 && (!u || t.length == 0)) return c[0] + l + c[1];
+          if (r < 0) return nE(t) ? e.stylize(RegExp.prototype.toString.call(t), "regexp") : e.stylize("[Object]", "special");
+          e.seen.push(t);
+          var h;
+          return u ? h = V5t(e, t, r, o, a) : h = a.map(function(d) {
+            return lj(e, t, r, o, d, u);
+          }), e.seen.pop(), G5t(h, l, c);
+        }
+        function U5t(e, t) {
+          if (T2(t)) return e.stylize("undefined", "undefined");
+          if (wR(t)) {
+            var r = "'" + JSON.stringify(t).replace(/^"|"$/g, "").replace(/'/g, "\\'").replace(/\\"/g, '"') + "'";
+            return e.stylize(r, "string");
+          }
+          if (B5e(t)) return e.stylize("" + t, "number");
+          if (uj(t)) return e.stylize("" + t, "boolean");
+          if (bR(t)) return e.stylize("null", "null");
+        }
+        function oj(e) {
+          return "[" + Error.prototype.toString.call(e) + "]";
+        }
+        function V5t(e, t, r, n, i) {
+          for (var a = [], o = 0, s = t.length; o < s; ++o) N5e(t, String(o)) ? a.push(lj(e, t, r, n, String(o), true)) : a.push("");
+          return i.forEach(function(l) {
+            l.match(/^\d+$/) || a.push(lj(e, t, r, n, l, true));
+          }), a;
+        }
+        function lj(e, t, r, n, i, a) {
+          var o, s, l;
+          if (l = Object.getOwnPropertyDescriptor(t, i) || { value: t[i] }, l.get ? l.set ? s = e.stylize("[Getter/Setter]", "special") : s = e.stylize("[Getter]", "special") : l.set && (s = e.stylize("[Setter]", "special")), N5e(n, i) || (o = "[" + i + "]"), s || (e.seen.indexOf(l.value) < 0 ? (bR(r) ? s = _R(e, l.value, null) : s = _R(e, l.value, r - 1), s.indexOf(`
+`) > -1 && (a ? s = s.split(`
+`).map(function(u) {
+            return "  " + u;
+          }).join(`
+`).slice(2) : s = `
+` + s.split(`
+`).map(function(u) {
+            return "   " + u;
+          }).join(`
+`))) : s = e.stylize("[Circular]", "special")), T2(o)) {
+            if (a && i.match(/^\d+$/)) return s;
+            o = JSON.stringify("" + i), o.match(/^"([a-zA-Z_][a-zA-Z_0-9]*)"$/) ? (o = o.slice(1, -1), o = e.stylize(o, "name")) : (o = o.replace(/'/g, "\\'").replace(/\\"/g, '"').replace(/(^"|"$)/g, "'"), o = e.stylize(o, "string"));
+          }
+          return o + ": " + s;
+        }
+        function G5t(e, t, r) {
+          var n = 0, i = e.reduce(function(a, o) {
+            return n++, o.indexOf(`
+`) >= 0 && n++, a + o.replace(/\u001b\[\d\d?m/g, "").length + 1;
+          }, 0);
+          return i > 60 ? r[0] + (t === "" ? "" : t + `
+ `) + " " + e.join(`,
+  `) + " " + r[1] : r[0] + t + " " + e.join(", ") + " " + r[1];
+        }
+        cu.types = nj();
+        function q5e(e) {
+          return Array.isArray(e);
+        }
+        cu.isArray = q5e;
+        function uj(e) {
+          return typeof e == "boolean";
+        }
+        cu.isBoolean = uj;
+        function bR(e) {
+          return e === null;
+        }
+        cu.isNull = bR;
+        function H5t(e) {
+          return e == null;
+        }
+        cu.isNullOrUndefined = H5t;
+        function B5e(e) {
+          return typeof e == "number";
+        }
+        cu.isNumber = B5e;
+        function wR(e) {
+          return typeof e == "string";
+        }
+        cu.isString = wR;
+        function j5t(e) {
+          return typeof e == "symbol";
+        }
+        cu.isSymbol = j5t;
+        function T2(e) {
+          return e === void 0;
+        }
+        cu.isUndefined = T2;
+        function nE(e) {
+          return pA(e) && cj(e) === "[object RegExp]";
+        }
+        cu.isRegExp = nE;
+        cu.types.isRegExp = nE;
+        function pA(e) {
+          return typeof e == "object" && e !== null;
+        }
+        cu.isObject = pA;
+        function xR(e) {
+          return pA(e) && cj(e) === "[object Date]";
+        }
+        cu.isDate = xR;
+        cu.types.isDate = xR;
+        function aE(e) {
+          return pA(e) && (cj(e) === "[object Error]" || e instanceof Error);
+        }
+        cu.isError = aE;
+        cu.types.isNativeError = aE;
+        function yR(e) {
+          return typeof e == "function";
+        }
+        cu.isFunction = yR;
+        function W5t(e) {
+          return e === null || typeof e == "boolean" || typeof e == "number" || typeof e == "string" || typeof e == "symbol" || typeof e == "undefined";
+        }
+        cu.isPrimitive = W5t;
+        cu.isBuffer = aj();
+        function cj(e) {
+          return Object.prototype.toString.call(e);
+        }
+        function sj(e) {
+          return e < 10 ? "0" + e.toString(10) : e.toString(10);
+        }
+        var X5t = ["Jan", "Feb", "Mar", "Apr", "May", "Jun", "Jul", "Aug", "Sep", "Oct", "Nov", "Dec"];
+        function Z5t() {
+          var e = /* @__PURE__ */ new Date(), t = [sj(e.getHours()), sj(e.getMinutes()), sj(e.getSeconds())].join(":");
+          return [e.getDate(), X5t[e.getMonth()], t].join(" ");
+        }
+        cu.log = function() {
+          console.log("%s - %s", Z5t(), cu.format.apply(cu, arguments));
+        };
+        cu.inherits = Zy();
+        cu._extend = function(e, t) {
+          if (!t || !pA(t)) return e;
+          for (var r = Object.keys(t), n = r.length; n--; ) e[r[n]] = t[r[n]];
+          return e;
+        };
+        function N5e(e, t) {
+          return Object.prototype.hasOwnProperty.call(e, t);
+        }
+        var w2 = typeof Symbol != "undefined" ? Symbol("util.promisify.custom") : void 0;
+        cu.promisify = function(t) {
+          if (typeof t != "function") throw new TypeError('The "original" argument must be of type Function');
+          if (w2 && t[w2]) {
+            var r = t[w2];
+            if (typeof r != "function") throw new TypeError('The "util.promisify.custom" argument must be of type Function');
+            return Object.defineProperty(r, w2, { value: r, enumerable: false, writable: false, configurable: true }), r;
+          }
+          function r() {
+            for (var n, i, a = new Promise(function(l, u) {
+              n = l, i = u;
+            }), o = [], s = 0; s < arguments.length; s++) o.push(arguments[s]);
+            o.push(function(l, u) {
+              l ? i(l) : n(u);
+            });
+            try {
+              t.apply(this, o);
+            } catch (l) {
+              i(l);
+            }
+            return a;
+          }
+          return Object.setPrototypeOf(r, Object.getPrototypeOf(t)), w2 && Object.defineProperty(r, w2, { value: r, enumerable: false, writable: false, configurable: true }), Object.defineProperties(r, z5e(t));
+        };
+        cu.promisify.custom = w2;
+        function Y5t(e, t) {
+          if (!e) {
+            var r = new Error("Promise was rejected with a falsy value");
+            r.reason = e, e = r;
+          }
+          return t(e);
+        }
+        function K5t(e) {
+          if (typeof e != "function") throw new TypeError('The "original" argument must be of type Function');
+          function t() {
+            for (var r = [], n = 0; n < arguments.length; n++) r.push(arguments[n]);
+            var i = r.pop();
+            if (typeof i != "function") throw new TypeError("The last argument must be of type Function");
+            var a = this, o = function() {
+              return i.apply(a, arguments);
+            };
+            e.apply(this, r).then(function(s) {
+              process.nextTick(o.bind(null, null, s));
+            }, function(s) {
+              process.nextTick(Y5t.bind(null, s, o));
+            });
+          }
+          return Object.setPrototypeOf(t, Object.getPrototypeOf(e)), Object.defineProperties(t, z5e(e)), t;
+        }
+        cu.callbackify = K5t;
+      });
+      var H5e = ye((Zhr, G5e) => {
+        function U5e(e, t) {
+          var r = Object.keys(e);
+          if (Object.getOwnPropertySymbols) {
+            var n = Object.getOwnPropertySymbols(e);
+            t && (n = n.filter(function(i) {
+              return Object.getOwnPropertyDescriptor(e, i).enumerable;
+            })), r.push.apply(r, n);
+          }
+          return r;
+        }
+        function J5t(e) {
+          for (var t = 1; t < arguments.length; t++) {
+            var r = arguments[t] != null ? arguments[t] : {};
+            t % 2 ? U5e(Object(r), true).forEach(function(n) {
+              $5t(e, n, r[n]);
+            }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(r)) : U5e(Object(r)).forEach(function(n) {
+              Object.defineProperty(e, n, Object.getOwnPropertyDescriptor(r, n));
+            });
+          }
+          return e;
+        }
+        function $5t(e, t, r) {
+          return t in e ? Object.defineProperty(e, t, { value: r, enumerable: true, configurable: true, writable: true }) : e[t] = r, e;
+        }
+        function Q5t(e, t) {
+          if (!(e instanceof t)) throw new TypeError("Cannot call a class as a function");
+        }
+        function V5e(e, t) {
+          for (var r = 0; r < t.length; r++) {
+            var n = t[r];
+            n.enumerable = n.enumerable || false, n.configurable = true, "value" in n && (n.writable = true), Object.defineProperty(e, n.key, n);
+          }
+        }
+        function eSt(e, t, r) {
+          return t && V5e(e.prototype, t), e;
+        }
+        var tSt = _2(), TR = tSt.Buffer, rSt = fj(), hj = rSt.inspect, iSt = hj && hj.custom || "inspect";
+        function nSt(e, t, r) {
+          TR.prototype.copy.call(e, t, r);
+        }
+        G5e.exports = function() {
+          function e() {
+            Q5t(this, e), this.head = null, this.tail = null, this.length = 0;
+          }
+          return eSt(e, [{ key: "push", value: function(r) {
+            var n = { data: r, next: null };
+            this.length > 0 ? this.tail.next = n : this.head = n, this.tail = n, ++this.length;
+          } }, { key: "unshift", value: function(r) {
+            var n = { data: r, next: this.head };
+            this.length === 0 && (this.tail = n), this.head = n, ++this.length;
+          } }, { key: "shift", value: function() {
+            if (this.length !== 0) {
+              var r = this.head.data;
+              return this.length === 1 ? this.head = this.tail = null : this.head = this.head.next, --this.length, r;
+            }
+          } }, { key: "clear", value: function() {
+            this.head = this.tail = null, this.length = 0;
+          } }, { key: "join", value: function(r) {
+            if (this.length === 0) return "";
+            for (var n = this.head, i = "" + n.data; n = n.next; ) i += r + n.data;
+            return i;
+          } }, { key: "concat", value: function(r) {
+            if (this.length === 0) return TR.alloc(0);
+            for (var n = TR.allocUnsafe(r >>> 0), i = this.head, a = 0; i; ) nSt(i.data, n, a), a += i.data.length, i = i.next;
+            return n;
+          } }, { key: "consume", value: function(r, n) {
+            var i;
+            return r < this.head.data.length ? (i = this.head.data.slice(0, r), this.head.data = this.head.data.slice(r)) : r === this.head.data.length ? i = this.shift() : i = n ? this._getString(r) : this._getBuffer(r), i;
+          } }, { key: "first", value: function() {
+            return this.head.data;
+          } }, { key: "_getString", value: function(r) {
+            var n = this.head, i = 1, a = n.data;
+            for (r -= a.length; n = n.next; ) {
+              var o = n.data, s = r > o.length ? o.length : r;
+              if (s === o.length ? a += o : a += o.slice(0, r), r -= s, r === 0) {
+                s === o.length ? (++i, n.next ? this.head = n.next : this.head = this.tail = null) : (this.head = n, n.data = o.slice(s));
+                break;
+              }
+              ++i;
+            }
+            return this.length -= i, a;
+          } }, { key: "_getBuffer", value: function(r) {
+            var n = TR.allocUnsafe(r), i = this.head, a = 1;
+            for (i.data.copy(n), r -= i.data.length; i = i.next; ) {
+              var o = i.data, s = r > o.length ? o.length : r;
+              if (o.copy(n, n.length - r, 0, s), r -= s, r === 0) {
+                s === o.length ? (++a, i.next ? this.head = i.next : this.head = this.tail = null) : (this.head = i, i.data = o.slice(s));
+                break;
+              }
+              ++a;
+            }
+            return this.length -= a, n;
+          } }, { key: iSt, value: function(r, n) {
+            return hj(this, J5t({}, n, { depth: 0, customInspect: false }));
+          } }]), e;
+        }();
+      });
+      var vj = ye((Yhr, W5e) => {
+        function aSt(e, t) {
+          var r = this, n = this._readableState && this._readableState.destroyed, i = this._writableState && this._writableState.destroyed;
+          return n || i ? (t ? t(e) : e && (this._writableState ? this._writableState.errorEmitted || (this._writableState.errorEmitted = true, process.nextTick(dj, this, e)) : process.nextTick(dj, this, e)), this) : (this._readableState && (this._readableState.destroyed = true), this._writableState && (this._writableState.destroyed = true), this._destroy(e || null, function(a) {
+            !t && a ? r._writableState ? r._writableState.errorEmitted ? process.nextTick(AR, r) : (r._writableState.errorEmitted = true, process.nextTick(j5e, r, a)) : process.nextTick(j5e, r, a) : t ? (process.nextTick(AR, r), t(a)) : process.nextTick(AR, r);
+          }), this);
+        }
+        function j5e(e, t) {
+          dj(e, t), AR(e);
+        }
+        function AR(e) {
+          e._writableState && !e._writableState.emitClose || e._readableState && !e._readableState.emitClose || e.emit("close");
+        }
+        function oSt() {
+          this._readableState && (this._readableState.destroyed = false, this._readableState.reading = false, this._readableState.ended = false, this._readableState.endEmitted = false), this._writableState && (this._writableState.destroyed = false, this._writableState.ended = false, this._writableState.ending = false, this._writableState.finalCalled = false, this._writableState.prefinished = false, this._writableState.finished = false, this._writableState.errorEmitted = false);
+        }
+        function dj(e, t) {
+          e.emit("error", t);
+        }
+        function sSt(e, t) {
+          var r = e._readableState, n = e._writableState;
+          r && r.autoDestroy || n && n.autoDestroy ? e.destroy(t) : e.emit("error", t);
+        }
+        W5e.exports = { destroy: aSt, undestroy: oSt, errorOrDestroy: sSt };
+      });
+      var A2 = ye((Khr, Y5e) => {
+        function lSt(e, t) {
+          e.prototype = Object.create(t.prototype), e.prototype.constructor = e, e.__proto__ = t;
+        }
+        var Z5e = {};
+        function J0(e, t, r) {
+          r || (r = Error);
+          function n(a, o, s) {
+            return typeof t == "string" ? t : t(a, o, s);
+          }
+          var i = function(a) {
+            lSt(o, a);
+            function o(s, l, u) {
+              return a.call(this, n(s, l, u)) || this;
+            }
+            return o;
+          }(r);
+          i.prototype.name = r.name, i.prototype.code = e, Z5e[e] = i;
+        }
+        function X5e(e, t) {
+          if (Array.isArray(e)) {
+            var r = e.length;
+            return e = e.map(function(n) {
+              return String(n);
+            }), r > 2 ? "one of ".concat(t, " ").concat(e.slice(0, r - 1).join(", "), ", or ") + e[r - 1] : r === 2 ? "one of ".concat(t, " ").concat(e[0], " or ").concat(e[1]) : "of ".concat(t, " ").concat(e[0]);
+          } else return "of ".concat(t, " ").concat(String(e));
+        }
+        function uSt(e, t, r) {
+          return e.substr(0, t.length) === t;
+        }
+        function cSt(e, t, r) {
+          return (r === void 0 || r > e.length) && (r = e.length), e.substring(r - t.length, r) === t;
+        }
+        function fSt(e, t, r) {
+          return typeof r != "number" && (r = 0), r + t.length > e.length ? false : e.indexOf(t, r) !== -1;
+        }
+        J0("ERR_INVALID_OPT_VALUE", function(e, t) {
+          return 'The value "' + t + '" is invalid for option "' + e + '"';
+        }, TypeError);
+        J0("ERR_INVALID_ARG_TYPE", function(e, t, r) {
+          var n;
+          typeof t == "string" && uSt(t, "not ") ? (n = "must not be", t = t.replace(/^not /, "")) : n = "must be";
+          var i;
+          if (cSt(e, " argument")) i = "The ".concat(e, " ").concat(n, " ").concat(X5e(t, "type"));
+          else {
+            var a = fSt(e, ".") ? "property" : "argument";
+            i = 'The "'.concat(e, '" ').concat(a, " ").concat(n, " ").concat(X5e(t, "type"));
+          }
+          return i += ". Received type ".concat(typeof r), i;
+        }, TypeError);
+        J0("ERR_STREAM_PUSH_AFTER_EOF", "stream.push() after EOF");
+        J0("ERR_METHOD_NOT_IMPLEMENTED", function(e) {
+          return "The " + e + " method is not implemented";
+        });
+        J0("ERR_STREAM_PREMATURE_CLOSE", "Premature close");
+        J0("ERR_STREAM_DESTROYED", function(e) {
+          return "Cannot call " + e + " after a stream was destroyed";
+        });
+        J0("ERR_MULTIPLE_CALLBACK", "Callback called multiple times");
+        J0("ERR_STREAM_CANNOT_PIPE", "Cannot pipe, not readable");
+        J0("ERR_STREAM_WRITE_AFTER_END", "write after end");
+        J0("ERR_STREAM_NULL_VALUES", "May not write null values to stream", TypeError);
+        J0("ERR_UNKNOWN_ENCODING", function(e) {
+          return "Unknown encoding: " + e;
+        }, TypeError);
+        J0("ERR_STREAM_UNSHIFT_AFTER_END_EVENT", "stream.unshift() after end event");
+        Y5e.exports.codes = Z5e;
+      });
+      var pj = ye((Jhr, K5e) => {
+        var hSt = A2().codes.ERR_INVALID_OPT_VALUE;
+        function dSt(e, t, r) {
+          return e.highWaterMark != null ? e.highWaterMark : t ? e[r] : null;
+        }
+        function vSt(e, t, r, n) {
+          var i = dSt(t, n, r);
+          if (i != null) {
+            if (!(isFinite(i) && Math.floor(i) === i) || i < 0) {
+              var a = n ? r : "highWaterMark";
+              throw new hSt(a, i);
+            }
+            return Math.floor(i);
+          }
+          return e.objectMode ? 16 : 16 * 1024;
+        }
+        K5e.exports = { getHighWaterMark: vSt };
+      });
+      var $5e = ye(($hr, J5e) => {
+        J5e.exports = pSt;
+        function pSt(e, t) {
+          if (gj("noDeprecation")) return e;
+          var r = false;
+          function n() {
+            if (!r) {
+              if (gj("throwDeprecation")) throw new Error(t);
+              gj("traceDeprecation") ? console.trace(t) : console.warn(t), r = true;
+            }
+            return e.apply(this, arguments);
+          }
+          return n;
+        }
+        function gj(e) {
+          try {
+            if (!window.localStorage) return false;
+          } catch (r) {
+            return false;
+          }
+          var t = window.localStorage[e];
+          return t == null ? false : String(t).toLowerCase() === "true";
+        }
+      });
+      var _j = ye((Qhr, nSe) => {
+        nSe.exports = Bh;
+        function eSe(e) {
+          var t = this;
+          this.next = null, this.entry = null, this.finish = function() {
+            VSt(t, e);
+          };
+        }
+        var gA;
+        Bh.WritableState = sE;
+        var gSt = { deprecate: $5e() }, tSe = yH(), MR = _2().Buffer, mSt = window.Uint8Array || function() {
+        };
+        function ySt(e) {
+          return MR.from(e);
+        }
+        function _St(e) {
+          return MR.isBuffer(e) || e instanceof mSt;
+        }
+        var yj = vj(), xSt = pj(), bSt = xSt.getHighWaterMark, V_ = A2().codes, wSt = V_.ERR_INVALID_ARG_TYPE, TSt = V_.ERR_METHOD_NOT_IMPLEMENTED, ASt = V_.ERR_MULTIPLE_CALLBACK, SSt = V_.ERR_STREAM_CANNOT_PIPE, MSt = V_.ERR_STREAM_DESTROYED, ESt = V_.ERR_STREAM_NULL_VALUES, kSt = V_.ERR_STREAM_WRITE_AFTER_END, CSt = V_.ERR_UNKNOWN_ENCODING, mA = yj.errorOrDestroy;
+        Zy()(Bh, tSe);
+        function LSt() {
+        }
+        function sE(e, t, r) {
+          gA = gA || S2(), e = e || {}, typeof r != "boolean" && (r = t instanceof gA), this.objectMode = !!e.objectMode, r && (this.objectMode = this.objectMode || !!e.writableObjectMode), this.highWaterMark = bSt(this, e, "writableHighWaterMark", r), this.finalCalled = false, this.needDrain = false, this.ending = false, this.ended = false, this.finished = false, this.destroyed = false;
+          var n = e.decodeStrings === false;
+          this.decodeStrings = !n, this.defaultEncoding = e.defaultEncoding || "utf8", this.length = 0, this.writing = false, this.corked = 0, this.sync = true, this.bufferProcessing = false, this.onwrite = function(i) {
+            OSt(t, i);
+          }, this.writecb = null, this.writelen = 0, this.bufferedRequest = null, this.lastBufferedRequest = null, this.pendingcb = 0, this.prefinished = false, this.errorEmitted = false, this.emitClose = e.emitClose !== false, this.autoDestroy = !!e.autoDestroy, this.bufferedRequestCount = 0, this.corkedRequestsFree = new eSe(this);
+        }
+        sE.prototype.getBuffer = function() {
+          for (var t = this.bufferedRequest, r = []; t; ) r.push(t), t = t.next;
+          return r;
+        };
+        (function() {
+          try {
+            Object.defineProperty(sE.prototype, "buffer", { get: gSt.deprecate(function() {
+              return this.getBuffer();
+            }, "_writableState.buffer is deprecated. Use _writableState.getBuffer instead.", "DEP0003") });
+          } catch (e) {
+          }
+        })();
+        var SR;
+        typeof Symbol == "function" && Symbol.hasInstance && typeof Function.prototype[Symbol.hasInstance] == "function" ? (SR = Function.prototype[Symbol.hasInstance], Object.defineProperty(Bh, Symbol.hasInstance, { value: function(t) {
+          return SR.call(this, t) ? true : this !== Bh ? false : t && t._writableState instanceof sE;
+        } })) : SR = function(t) {
+          return t instanceof this;
+        };
+        function Bh(e) {
+          gA = gA || S2();
+          var t = this instanceof gA;
+          if (!t && !SR.call(Bh, this)) return new Bh(e);
+          this._writableState = new sE(e, this, t), this.writable = true, e && (typeof e.write == "function" && (this._write = e.write), typeof e.writev == "function" && (this._writev = e.writev), typeof e.destroy == "function" && (this._destroy = e.destroy), typeof e.final == "function" && (this._final = e.final)), tSe.call(this);
+        }
+        Bh.prototype.pipe = function() {
+          mA(this, new SSt());
+        };
+        function PSt(e, t) {
+          var r = new kSt();
+          mA(e, r), process.nextTick(t, r);
+        }
+        function ISt(e, t, r, n) {
+          var i;
+          return r === null ? i = new ESt() : typeof r != "string" && !t.objectMode && (i = new wSt("chunk", ["string", "Buffer"], r)), i ? (mA(e, i), process.nextTick(n, i), false) : true;
+        }
+        Bh.prototype.write = function(e, t, r) {
+          var n = this._writableState, i = false, a = !n.objectMode && _St(e);
+          return a && !MR.isBuffer(e) && (e = ySt(e)), typeof t == "function" && (r = t, t = null), a ? t = "buffer" : t || (t = n.defaultEncoding), typeof r != "function" && (r = LSt), n.ending ? PSt(this, r) : (a || ISt(this, n, e, r)) && (n.pendingcb++, i = DSt(this, n, a, e, t, r)), i;
+        };
+        Bh.prototype.cork = function() {
+          this._writableState.corked++;
+        };
+        Bh.prototype.uncork = function() {
+          var e = this._writableState;
+          e.corked && (e.corked--, !e.writing && !e.corked && !e.bufferProcessing && e.bufferedRequest && rSe(this, e));
+        };
+        Bh.prototype.setDefaultEncoding = function(t) {
+          if (typeof t == "string" && (t = t.toLowerCase()), !(["hex", "utf8", "utf-8", "ascii", "binary", "base64", "ucs2", "ucs-2", "utf16le", "utf-16le", "raw"].indexOf((t + "").toLowerCase()) > -1)) throw new CSt(t);
+          return this._writableState.defaultEncoding = t, this;
+        };
+        Object.defineProperty(Bh.prototype, "writableBuffer", { enumerable: false, get: function() {
+          return this._writableState && this._writableState.getBuffer();
+        } });
+        function RSt(e, t, r) {
+          return !e.objectMode && e.decodeStrings !== false && typeof t == "string" && (t = MR.from(t, r)), t;
+        }
+        Object.defineProperty(Bh.prototype, "writableHighWaterMark", { enumerable: false, get: function() {
+          return this._writableState.highWaterMark;
+        } });
+        function DSt(e, t, r, n, i, a) {
+          if (!r) {
+            var o = RSt(t, n, i);
+            n !== o && (r = true, i = "buffer", n = o);
+          }
+          var s = t.objectMode ? 1 : n.length;
+          t.length += s;
+          var l = t.length < t.highWaterMark;
+          if (l || (t.needDrain = true), t.writing || t.corked) {
+            var u = t.lastBufferedRequest;
+            t.lastBufferedRequest = { chunk: n, encoding: i, isBuf: r, callback: a, next: null }, u ? u.next = t.lastBufferedRequest : t.bufferedRequest = t.lastBufferedRequest, t.bufferedRequestCount += 1;
+          } else mj(e, t, false, s, n, i, a);
+          return l;
+        }
+        function mj(e, t, r, n, i, a, o) {
+          t.writelen = n, t.writecb = o, t.writing = true, t.sync = true, t.destroyed ? t.onwrite(new MSt("write")) : r ? e._writev(i, t.onwrite) : e._write(i, a, t.onwrite), t.sync = false;
+        }
+        function FSt(e, t, r, n, i) {
+          --t.pendingcb, r ? (process.nextTick(i, n), process.nextTick(oE, e, t), e._writableState.errorEmitted = true, mA(e, n)) : (i(n), e._writableState.errorEmitted = true, mA(e, n), oE(e, t));
+        }
+        function zSt(e) {
+          e.writing = false, e.writecb = null, e.length -= e.writelen, e.writelen = 0;
+        }
+        function OSt(e, t) {
+          var r = e._writableState, n = r.sync, i = r.writecb;
+          if (typeof i != "function") throw new ASt();
+          if (zSt(r), t) FSt(e, r, n, t, i);
+          else {
+            var a = iSe(r) || e.destroyed;
+            !a && !r.corked && !r.bufferProcessing && r.bufferedRequest && rSe(e, r), n ? process.nextTick(Q5e, e, r, a, i) : Q5e(e, r, a, i);
+          }
+        }
+        function Q5e(e, t, r, n) {
+          r || qSt(e, t), t.pendingcb--, n(), oE(e, t);
+        }
+        function qSt(e, t) {
+          t.length === 0 && t.needDrain && (t.needDrain = false, e.emit("drain"));
+        }
+        function rSe(e, t) {
+          t.bufferProcessing = true;
+          var r = t.bufferedRequest;
+          if (e._writev && r && r.next) {
+            var n = t.bufferedRequestCount, i = new Array(n), a = t.corkedRequestsFree;
+            a.entry = r;
+            for (var o = 0, s = true; r; ) i[o] = r, r.isBuf || (s = false), r = r.next, o += 1;
+            i.allBuffers = s, mj(e, t, true, t.length, i, "", a.finish), t.pendingcb++, t.lastBufferedRequest = null, a.next ? (t.corkedRequestsFree = a.next, a.next = null) : t.corkedRequestsFree = new eSe(t), t.bufferedRequestCount = 0;
+          } else {
+            for (; r; ) {
+              var l = r.chunk, u = r.encoding, c = r.callback, f = t.objectMode ? 1 : l.length;
+              if (mj(e, t, false, f, l, u, c), r = r.next, t.bufferedRequestCount--, t.writing) break;
+            }
+            r === null && (t.lastBufferedRequest = null);
+          }
+          t.bufferedRequest = r, t.bufferProcessing = false;
+        }
+        Bh.prototype._write = function(e, t, r) {
+          r(new TSt("_write()"));
+        };
+        Bh.prototype._writev = null;
+        Bh.prototype.end = function(e, t, r) {
+          var n = this._writableState;
+          return typeof e == "function" ? (r = e, e = null, t = null) : typeof t == "function" && (r = t, t = null), e != null && this.write(e, t), n.corked && (n.corked = 1, this.uncork()), n.ending || USt(this, n, r), this;
+        };
+        Object.defineProperty(Bh.prototype, "writableLength", { enumerable: false, get: function() {
+          return this._writableState.length;
+        } });
+        function iSe(e) {
+          return e.ending && e.length === 0 && e.bufferedRequest === null && !e.finished && !e.writing;
+        }
+        function BSt(e, t) {
+          e._final(function(r) {
+            t.pendingcb--, r && mA(e, r), t.prefinished = true, e.emit("prefinish"), oE(e, t);
+          });
+        }
+        function NSt(e, t) {
+          !t.prefinished && !t.finalCalled && (typeof e._final == "function" && !t.destroyed ? (t.pendingcb++, t.finalCalled = true, process.nextTick(BSt, e, t)) : (t.prefinished = true, e.emit("prefinish")));
+        }
+        function oE(e, t) {
+          var r = iSe(t);
+          if (r && (NSt(e, t), t.pendingcb === 0 && (t.finished = true, e.emit("finish"), t.autoDestroy))) {
+            var n = e._readableState;
+            (!n || n.autoDestroy && n.endEmitted) && e.destroy();
+          }
+          return r;
+        }
+        function USt(e, t, r) {
+          t.ending = true, oE(e, t), r && (t.finished ? process.nextTick(r) : e.once("finish", r)), t.ended = true, e.writable = false;
+        }
+        function VSt(e, t, r) {
+          var n = e.entry;
+          for (e.entry = null; n; ) {
+            var i = n.callback;
+            t.pendingcb--, i(r), n = n.next;
+          }
+          t.corkedRequestsFree.next = e;
+        }
+        Object.defineProperty(Bh.prototype, "destroyed", { enumerable: false, get: function() {
+          return this._writableState === void 0 ? false : this._writableState.destroyed;
+        }, set: function(t) {
+          this._writableState && (this._writableState.destroyed = t);
+        } });
+        Bh.prototype.destroy = yj.destroy;
+        Bh.prototype._undestroy = yj.undestroy;
+        Bh.prototype._destroy = function(e, t) {
+          t(e);
+        };
+      });
+      var S2 = ye((edr, oSe) => {
+        var GSt = Object.keys || function(e) {
+          var t = [];
+          for (var r in e) t.push(r);
+          return t;
+        };
+        oSe.exports = jm;
+        var aSe = wj(), bj = _j();
+        Zy()(jm, aSe);
+        for (xj = GSt(bj.prototype), ER = 0; ER < xj.length; ER++) kR = xj[ER], jm.prototype[kR] || (jm.prototype[kR] = bj.prototype[kR]);
+        var xj, kR, ER;
+        function jm(e) {
+          if (!(this instanceof jm)) return new jm(e);
+          aSe.call(this, e), bj.call(this, e), this.allowHalfOpen = true, e && (e.readable === false && (this.readable = false), e.writable === false && (this.writable = false), e.allowHalfOpen === false && (this.allowHalfOpen = false, this.once("end", HSt)));
+        }
+        Object.defineProperty(jm.prototype, "writableHighWaterMark", { enumerable: false, get: function() {
+          return this._writableState.highWaterMark;
+        } });
+        Object.defineProperty(jm.prototype, "writableBuffer", { enumerable: false, get: function() {
+          return this._writableState && this._writableState.getBuffer();
+        } });
+        Object.defineProperty(jm.prototype, "writableLength", { enumerable: false, get: function() {
+          return this._writableState.length;
+        } });
+        function HSt() {
+          this._writableState.ended || process.nextTick(jSt, this);
+        }
+        function jSt(e) {
+          e.end();
+        }
+        Object.defineProperty(jm.prototype, "destroyed", { enumerable: false, get: function() {
+          return this._readableState === void 0 || this._writableState === void 0 ? false : this._readableState.destroyed && this._writableState.destroyed;
+        }, set: function(t) {
+          this._readableState === void 0 || this._writableState === void 0 || (this._readableState.destroyed = t, this._writableState.destroyed = t);
+        } });
+      });
+      var uSe = ye((Tj, lSe) => {
+        var CR = _2(), Wm = CR.Buffer;
+        function sSe(e, t) {
+          for (var r in e) t[r] = e[r];
+        }
+        Wm.from && Wm.alloc && Wm.allocUnsafe && Wm.allocUnsafeSlow ? lSe.exports = CR : (sSe(CR, Tj), Tj.Buffer = M2);
+        function M2(e, t, r) {
+          return Wm(e, t, r);
+        }
+        M2.prototype = Object.create(Wm.prototype);
+        sSe(Wm, M2);
+        M2.from = function(e, t, r) {
+          if (typeof e == "number") throw new TypeError("Argument must not be a number");
+          return Wm(e, t, r);
+        };
+        M2.alloc = function(e, t, r) {
+          if (typeof e != "number") throw new TypeError("Argument must be a number");
+          var n = Wm(e);
+          return t !== void 0 ? typeof r == "string" ? n.fill(t, r) : n.fill(t) : n.fill(0), n;
+        };
+        M2.allocUnsafe = function(e) {
+          if (typeof e != "number") throw new TypeError("Argument must be a number");
+          return Wm(e);
+        };
+        M2.allocUnsafeSlow = function(e) {
+          if (typeof e != "number") throw new TypeError("Argument must be a number");
+          return CR.SlowBuffer(e);
+        };
+      });
+      var Mj = ye((fSe) => {
+        var Sj = uSe().Buffer, cSe = Sj.isEncoding || function(e) {
+          switch (e = "" + e, e && e.toLowerCase()) {
+            case "hex":
+            case "utf8":
+            case "utf-8":
+            case "ascii":
+            case "binary":
+            case "base64":
+            case "ucs2":
+            case "ucs-2":
+            case "utf16le":
+            case "utf-16le":
+            case "raw":
+              return true;
+            default:
+              return false;
+          }
+        };
+        function WSt(e) {
+          if (!e) return "utf8";
+          for (var t; ; ) switch (e) {
+            case "utf8":
+            case "utf-8":
+              return "utf8";
+            case "ucs2":
+            case "ucs-2":
+            case "utf16le":
+            case "utf-16le":
+              return "utf16le";
+            case "latin1":
+            case "binary":
+              return "latin1";
+            case "base64":
+            case "ascii":
+            case "hex":
+              return e;
+            default:
+              if (t) return;
+              e = ("" + e).toLowerCase(), t = true;
+          }
+        }
+        function XSt(e) {
+          var t = WSt(e);
+          if (typeof t != "string" && (Sj.isEncoding === cSe || !cSe(e))) throw new Error("Unknown encoding: " + e);
+          return t || e;
+        }
+        fSe.StringDecoder = lE;
+        function lE(e) {
+          this.encoding = XSt(e);
+          var t;
+          switch (this.encoding) {
+            case "utf16le":
+              this.text = QSt, this.end = eMt, t = 4;
+              break;
+            case "utf8":
+              this.fillLast = KSt, t = 4;
+              break;
+            case "base64":
+              this.text = tMt, this.end = rMt, t = 3;
+              break;
+            default:
+              this.write = iMt, this.end = nMt;
+              return;
+          }
+          this.lastNeed = 0, this.lastTotal = 0, this.lastChar = Sj.allocUnsafe(t);
+        }
+        lE.prototype.write = function(e) {
+          if (e.length === 0) return "";
+          var t, r;
+          if (this.lastNeed) {
+            if (t = this.fillLast(e), t === void 0) return "";
+            r = this.lastNeed, this.lastNeed = 0;
+          } else r = 0;
+          return r < e.length ? t ? t + this.text(e, r) : this.text(e, r) : t || "";
+        };
+        lE.prototype.end = $St;
+        lE.prototype.text = JSt;
+        lE.prototype.fillLast = function(e) {
+          if (this.lastNeed <= e.length) return e.copy(this.lastChar, this.lastTotal - this.lastNeed, 0, this.lastNeed), this.lastChar.toString(this.encoding, 0, this.lastTotal);
+          e.copy(this.lastChar, this.lastTotal - this.lastNeed, 0, e.length), this.lastNeed -= e.length;
+        };
+        function Aj(e) {
+          return e <= 127 ? 0 : e >> 5 === 6 ? 2 : e >> 4 === 14 ? 3 : e >> 3 === 30 ? 4 : e >> 6 === 2 ? -1 : -2;
+        }
+        function ZSt(e, t, r) {
+          var n = t.length - 1;
+          if (n < r) return 0;
+          var i = Aj(t[n]);
+          return i >= 0 ? (i > 0 && (e.lastNeed = i - 1), i) : --n < r || i === -2 ? 0 : (i = Aj(t[n]), i >= 0 ? (i > 0 && (e.lastNeed = i - 2), i) : --n < r || i === -2 ? 0 : (i = Aj(t[n]), i >= 0 ? (i > 0 && (i === 2 ? i = 0 : e.lastNeed = i - 3), i) : 0));
+        }
+        function YSt(e, t, r) {
+          if ((t[0] & 192) !== 128) return e.lastNeed = 0, "�";
+          if (e.lastNeed > 1 && t.length > 1) {
+            if ((t[1] & 192) !== 128) return e.lastNeed = 1, "�";
+            if (e.lastNeed > 2 && t.length > 2 && (t[2] & 192) !== 128) return e.lastNeed = 2, "�";
+          }
+        }
+        function KSt(e) {
+          var t = this.lastTotal - this.lastNeed, r = YSt(this, e);
+          if (r !== void 0) return r;
+          if (this.lastNeed <= e.length) return e.copy(this.lastChar, t, 0, this.lastNeed), this.lastChar.toString(this.encoding, 0, this.lastTotal);
+          e.copy(this.lastChar, t, 0, e.length), this.lastNeed -= e.length;
+        }
+        function JSt(e, t) {
+          var r = ZSt(this, e, t);
+          if (!this.lastNeed) return e.toString("utf8", t);
+          this.lastTotal = r;
+          var n = e.length - (r - this.lastNeed);
+          return e.copy(this.lastChar, 0, n), e.toString("utf8", t, n);
+        }
+        function $St(e) {
+          var t = e && e.length ? this.write(e) : "";
+          return this.lastNeed ? t + "�" : t;
+        }
+        function QSt(e, t) {
+          if ((e.length - t) % 2 === 0) {
+            var r = e.toString("utf16le", t);
+            if (r) {
+              var n = r.charCodeAt(r.length - 1);
+              if (n >= 55296 && n <= 56319) return this.lastNeed = 2, this.lastTotal = 4, this.lastChar[0] = e[e.length - 2], this.lastChar[1] = e[e.length - 1], r.slice(0, -1);
+            }
+            return r;
+          }
+          return this.lastNeed = 1, this.lastTotal = 2, this.lastChar[0] = e[e.length - 1], e.toString("utf16le", t, e.length - 1);
+        }
+        function eMt(e) {
+          var t = e && e.length ? this.write(e) : "";
+          if (this.lastNeed) {
+            var r = this.lastTotal - this.lastNeed;
+            return t + this.lastChar.toString("utf16le", 0, r);
+          }
+          return t;
+        }
+        function tMt(e, t) {
+          var r = (e.length - t) % 3;
+          return r === 0 ? e.toString("base64", t) : (this.lastNeed = 3 - r, this.lastTotal = 3, r === 1 ? this.lastChar[0] = e[e.length - 1] : (this.lastChar[0] = e[e.length - 2], this.lastChar[1] = e[e.length - 1]), e.toString("base64", t, e.length - r));
+        }
+        function rMt(e) {
+          var t = e && e.length ? this.write(e) : "";
+          return this.lastNeed ? t + this.lastChar.toString("base64", 0, 3 - this.lastNeed) : t;
+        }
+        function iMt(e) {
+          return e.toString(this.encoding);
+        }
+        function nMt(e) {
+          return e && e.length ? this.write(e) : "";
+        }
+      });
+      var LR = ye((rdr, vSe) => {
+        var hSe = A2().codes.ERR_STREAM_PREMATURE_CLOSE;
+        function aMt(e) {
+          var t = false;
+          return function() {
+            if (!t) {
+              t = true;
+              for (var r = arguments.length, n = new Array(r), i = 0; i < r; i++) n[i] = arguments[i];
+              e.apply(this, n);
+            }
+          };
+        }
+        function oMt() {
+        }
+        function sMt(e) {
+          return e.setHeader && typeof e.abort == "function";
+        }
+        function dSe(e, t, r) {
+          if (typeof t == "function") return dSe(e, null, t);
+          t || (t = {}), r = aMt(r || oMt);
+          var n = t.readable || t.readable !== false && e.readable, i = t.writable || t.writable !== false && e.writable, a = function() {
+            e.writable || s();
+          }, o = e._writableState && e._writableState.finished, s = function() {
+            i = false, o = true, n || r.call(e);
+          }, l = e._readableState && e._readableState.endEmitted, u = function() {
+            n = false, l = true, i || r.call(e);
+          }, c = function(v) {
+            r.call(e, v);
+          }, f = function() {
+            var v;
+            if (n && !l) return (!e._readableState || !e._readableState.ended) && (v = new hSe()), r.call(e, v);
+            if (i && !o) return (!e._writableState || !e._writableState.ended) && (v = new hSe()), r.call(e, v);
+          }, h = function() {
+            e.req.on("finish", s);
+          };
+          return sMt(e) ? (e.on("complete", s), e.on("abort", f), e.req ? h() : e.on("request", h)) : i && !e._writableState && (e.on("end", a), e.on("close", a)), e.on("end", u), e.on("finish", s), t.error !== false && e.on("error", c), e.on("close", f), function() {
+            e.removeListener("complete", s), e.removeListener("abort", f), e.removeListener("request", h), e.req && e.req.removeListener("finish", s), e.removeListener("end", a), e.removeListener("close", a), e.removeListener("finish", s), e.removeListener("end", u), e.removeListener("error", c), e.removeListener("close", f);
+          };
+        }
+        vSe.exports = dSe;
+      });
+      var gSe = ye((idr, pSe) => {
+        var PR;
+        function G_(e, t, r) {
+          return t in e ? Object.defineProperty(e, t, { value: r, enumerable: true, configurable: true, writable: true }) : e[t] = r, e;
+        }
+        var lMt = LR(), H_ = Symbol("lastResolve"), E2 = Symbol("lastReject"), uE = Symbol("error"), IR = Symbol("ended"), k2 = Symbol("lastPromise"), Ej = Symbol("handlePromise"), C2 = Symbol("stream");
+        function j_(e, t) {
+          return { value: e, done: t };
+        }
+        function uMt(e) {
+          var t = e[H_];
+          if (t !== null) {
+            var r = e[C2].read();
+            r !== null && (e[k2] = null, e[H_] = null, e[E2] = null, t(j_(r, false)));
+          }
+        }
+        function cMt(e) {
+          process.nextTick(uMt, e);
+        }
+        function fMt(e, t) {
+          return function(r, n) {
+            e.then(function() {
+              if (t[IR]) {
+                r(j_(void 0, true));
+                return;
+              }
+              t[Ej](r, n);
+            }, n);
+          };
+        }
+        var hMt = Object.getPrototypeOf(function() {
+        }), dMt = Object.setPrototypeOf((PR = { get stream() {
+          return this[C2];
+        }, next: function() {
+          var t = this, r = this[uE];
+          if (r !== null) return Promise.reject(r);
+          if (this[IR]) return Promise.resolve(j_(void 0, true));
+          if (this[C2].destroyed) return new Promise(function(o, s) {
+            process.nextTick(function() {
+              t[uE] ? s(t[uE]) : o(j_(void 0, true));
+            });
+          });
+          var n = this[k2], i;
+          if (n) i = new Promise(fMt(n, this));
+          else {
+            var a = this[C2].read();
+            if (a !== null) return Promise.resolve(j_(a, false));
+            i = new Promise(this[Ej]);
+          }
+          return this[k2] = i, i;
+        } }, G_(PR, Symbol.asyncIterator, function() {
+          return this;
+        }), G_(PR, "return", function() {
+          var t = this;
+          return new Promise(function(r, n) {
+            t[C2].destroy(null, function(i) {
+              if (i) {
+                n(i);
+                return;
+              }
+              r(j_(void 0, true));
+            });
+          });
+        }), PR), hMt), vMt = function(t) {
+          var r, n = Object.create(dMt, (r = {}, G_(r, C2, { value: t, writable: true }), G_(r, H_, { value: null, writable: true }), G_(r, E2, { value: null, writable: true }), G_(r, uE, { value: null, writable: true }), G_(r, IR, { value: t._readableState.endEmitted, writable: true }), G_(r, Ej, { value: function(a, o) {
+            var s = n[C2].read();
+            s ? (n[k2] = null, n[H_] = null, n[E2] = null, a(j_(s, false))) : (n[H_] = a, n[E2] = o);
+          }, writable: true }), r));
+          return n[k2] = null, lMt(t, function(i) {
+            if (i && i.code !== "ERR_STREAM_PREMATURE_CLOSE") {
+              var a = n[E2];
+              a !== null && (n[k2] = null, n[H_] = null, n[E2] = null, a(i)), n[uE] = i;
+              return;
+            }
+            var o = n[H_];
+            o !== null && (n[k2] = null, n[H_] = null, n[E2] = null, o(j_(void 0, true))), n[IR] = true;
+          }), t.on("readable", cMt.bind(null, n)), n;
+        };
+        pSe.exports = vMt;
+      });
+      var ySe = ye((ndr, mSe) => {
+        mSe.exports = function() {
+          throw new Error("Readable.from is not available in the browser");
+        };
+      });
+      var wj = ye((odr, kSe) => {
+        kSe.exports = Bu;
+        var yA;
+        Bu.ReadableState = wSe;
+        Ab().EventEmitter;
+        var bSe = function(t, r) {
+          return t.listeners(r).length;
+        }, fE = yH(), RR = _2().Buffer, pMt = window.Uint8Array || function() {
+        };
+        function gMt(e) {
+          return RR.from(e);
+        }
+        function mMt(e) {
+          return RR.isBuffer(e) || e instanceof pMt;
+        }
+        var kj = fj(), nu;
+        kj && kj.debuglog ? nu = kj.debuglog("stream") : nu = function() {
+        };
+        var yMt = H5e(), Fj = vj(), _Mt = pj(), xMt = _Mt.getHighWaterMark, DR = A2().codes, bMt = DR.ERR_INVALID_ARG_TYPE, wMt = DR.ERR_STREAM_PUSH_AFTER_EOF, TMt = DR.ERR_METHOD_NOT_IMPLEMENTED, AMt = DR.ERR_STREAM_UNSHIFT_AFTER_END_EVENT, _A, Cj, Lj;
+        Zy()(Bu, fE);
+        var cE = Fj.errorOrDestroy, Pj = ["error", "close", "destroy", "pause", "resume"];
+        function SMt(e, t, r) {
+          if (typeof e.prependListener == "function") return e.prependListener(t, r);
+          !e._events || !e._events[t] ? e.on(t, r) : Array.isArray(e._events[t]) ? e._events[t].unshift(r) : e._events[t] = [r, e._events[t]];
+        }
+        function wSe(e, t, r) {
+          yA = yA || S2(), e = e || {}, typeof r != "boolean" && (r = t instanceof yA), this.objectMode = !!e.objectMode, r && (this.objectMode = this.objectMode || !!e.readableObjectMode), this.highWaterMark = xMt(this, e, "readableHighWaterMark", r), this.buffer = new yMt(), this.length = 0, this.pipes = null, this.pipesCount = 0, this.flowing = null, this.ended = false, this.endEmitted = false, this.reading = false, this.sync = true, this.needReadable = false, this.emittedReadable = false, this.readableListening = false, this.resumeScheduled = false, this.paused = true, this.emitClose = e.emitClose !== false, this.autoDestroy = !!e.autoDestroy, this.destroyed = false, this.defaultEncoding = e.defaultEncoding || "utf8", this.awaitDrain = 0, this.readingMore = false, this.decoder = null, this.encoding = null, e.encoding && (_A || (_A = Mj().StringDecoder), this.decoder = new _A(e.encoding), this.encoding = e.encoding);
+        }
+        function Bu(e) {
+          if (yA = yA || S2(), !(this instanceof Bu)) return new Bu(e);
+          var t = this instanceof yA;
+          this._readableState = new wSe(e, this, t), this.readable = true, e && (typeof e.read == "function" && (this._read = e.read), typeof e.destroy == "function" && (this._destroy = e.destroy)), fE.call(this);
+        }
+        Object.defineProperty(Bu.prototype, "destroyed", { enumerable: false, get: function() {
+          return this._readableState === void 0 ? false : this._readableState.destroyed;
+        }, set: function(t) {
+          this._readableState && (this._readableState.destroyed = t);
+        } });
+        Bu.prototype.destroy = Fj.destroy;
+        Bu.prototype._undestroy = Fj.undestroy;
+        Bu.prototype._destroy = function(e, t) {
+          t(e);
+        };
+        Bu.prototype.push = function(e, t) {
+          var r = this._readableState, n;
+          return r.objectMode ? n = true : typeof e == "string" && (t = t || r.defaultEncoding, t !== r.encoding && (e = RR.from(e, t), t = ""), n = true), TSe(this, e, t, false, n);
+        };
+        Bu.prototype.unshift = function(e) {
+          return TSe(this, e, null, true, false);
+        };
+        function TSe(e, t, r, n, i) {
+          nu("readableAddChunk", t);
+          var a = e._readableState;
+          if (t === null) a.reading = false, kMt(e, a);
+          else {
+            var o;
+            if (i || (o = MMt(a, t)), o) cE(e, o);
+            else if (a.objectMode || t && t.length > 0) if (typeof t != "string" && !a.objectMode && Object.getPrototypeOf(t) !== RR.prototype && (t = gMt(t)), n) a.endEmitted ? cE(e, new AMt()) : Ij(e, a, t, true);
+            else if (a.ended) cE(e, new wMt());
+            else {
+              if (a.destroyed) return false;
+              a.reading = false, a.decoder && !r ? (t = a.decoder.write(t), a.objectMode || t.length !== 0 ? Ij(e, a, t, false) : Dj(e, a)) : Ij(e, a, t, false);
+            }
+            else n || (a.reading = false, Dj(e, a));
+          }
+          return !a.ended && (a.length < a.highWaterMark || a.length === 0);
+        }
+        function Ij(e, t, r, n) {
+          t.flowing && t.length === 0 && !t.sync ? (t.awaitDrain = 0, e.emit("data", r)) : (t.length += t.objectMode ? 1 : r.length, n ? t.buffer.unshift(r) : t.buffer.push(r), t.needReadable && FR(e)), Dj(e, t);
+        }
+        function MMt(e, t) {
+          var r;
+          return !mMt(t) && typeof t != "string" && t !== void 0 && !e.objectMode && (r = new bMt("chunk", ["string", "Buffer", "Uint8Array"], t)), r;
+        }
+        Bu.prototype.isPaused = function() {
+          return this._readableState.flowing === false;
+        };
+        Bu.prototype.setEncoding = function(e) {
+          _A || (_A = Mj().StringDecoder);
+          var t = new _A(e);
+          this._readableState.decoder = t, this._readableState.encoding = this._readableState.decoder.encoding;
+          for (var r = this._readableState.buffer.head, n = ""; r !== null; ) n += t.write(r.data), r = r.next;
+          return this._readableState.buffer.clear(), n !== "" && this._readableState.buffer.push(n), this._readableState.length = n.length, this;
+        };
+        var _Se = 1073741824;
+        function EMt(e) {
+          return e >= _Se ? e = _Se : (e--, e |= e >>> 1, e |= e >>> 2, e |= e >>> 4, e |= e >>> 8, e |= e >>> 16, e++), e;
+        }
+        function xSe(e, t) {
+          return e <= 0 || t.length === 0 && t.ended ? 0 : t.objectMode ? 1 : e !== e ? t.flowing && t.length ? t.buffer.head.data.length : t.length : (e > t.highWaterMark && (t.highWaterMark = EMt(e)), e <= t.length ? e : t.ended ? t.length : (t.needReadable = true, 0));
+        }
+        Bu.prototype.read = function(e) {
+          nu("read", e), e = parseInt(e, 10);
+          var t = this._readableState, r = e;
+          if (e !== 0 && (t.emittedReadable = false), e === 0 && t.needReadable && ((t.highWaterMark !== 0 ? t.length >= t.highWaterMark : t.length > 0) || t.ended)) return nu("read: emitReadable", t.length, t.ended), t.length === 0 && t.ended ? Rj(this) : FR(this), null;
+          if (e = xSe(e, t), e === 0 && t.ended) return t.length === 0 && Rj(this), null;
+          var n = t.needReadable;
+          nu("need readable", n), (t.length === 0 || t.length - e < t.highWaterMark) && (n = true, nu("length less than watermark", n)), t.ended || t.reading ? (n = false, nu("reading or ended", n)) : n && (nu("do read"), t.reading = true, t.sync = true, t.length === 0 && (t.needReadable = true), this._read(t.highWaterMark), t.sync = false, t.reading || (e = xSe(r, t)));
+          var i;
+          return e > 0 ? i = MSe(e, t) : i = null, i === null ? (t.needReadable = t.length <= t.highWaterMark, e = 0) : (t.length -= e, t.awaitDrain = 0), t.length === 0 && (t.ended || (t.needReadable = true), r !== e && t.ended && Rj(this)), i !== null && this.emit("data", i), i;
+        };
+        function kMt(e, t) {
+          if (nu("onEofChunk"), !t.ended) {
+            if (t.decoder) {
+              var r = t.decoder.end();
+              r && r.length && (t.buffer.push(r), t.length += t.objectMode ? 1 : r.length);
+            }
+            t.ended = true, t.sync ? FR(e) : (t.needReadable = false, t.emittedReadable || (t.emittedReadable = true, ASe(e)));
+          }
+        }
+        function FR(e) {
+          var t = e._readableState;
+          nu("emitReadable", t.needReadable, t.emittedReadable), t.needReadable = false, t.emittedReadable || (nu("emitReadable", t.flowing), t.emittedReadable = true, process.nextTick(ASe, e));
+        }
+        function ASe(e) {
+          var t = e._readableState;
+          nu("emitReadable_", t.destroyed, t.length, t.ended), !t.destroyed && (t.length || t.ended) && (e.emit("readable"), t.emittedReadable = false), t.needReadable = !t.flowing && !t.ended && t.length <= t.highWaterMark, zj(e);
+        }
+        function Dj(e, t) {
+          t.readingMore || (t.readingMore = true, process.nextTick(CMt, e, t));
+        }
+        function CMt(e, t) {
+          for (; !t.reading && !t.ended && (t.length < t.highWaterMark || t.flowing && t.length === 0); ) {
+            var r = t.length;
+            if (nu("maybeReadMore read 0"), e.read(0), r === t.length) break;
+          }
+          t.readingMore = false;
+        }
+        Bu.prototype._read = function(e) {
+          cE(this, new TMt("_read()"));
+        };
+        Bu.prototype.pipe = function(e, t) {
+          var r = this, n = this._readableState;
+          switch (n.pipesCount) {
+            case 0:
+              n.pipes = e;
+              break;
+            case 1:
+              n.pipes = [n.pipes, e];
+              break;
+            default:
+              n.pipes.push(e);
+              break;
+          }
+          n.pipesCount += 1, nu("pipe count=%d opts=%j", n.pipesCount, t);
+          var i = (!t || t.end !== false) && e !== process.stdout && e !== process.stderr, a = i ? s : _;
+          n.endEmitted ? process.nextTick(a) : r.once("end", a), e.on("unpipe", o);
+          function o(b, p) {
+            nu("onunpipe"), b === r && p && p.hasUnpiped === false && (p.hasUnpiped = true, c());
+          }
+          function s() {
+            nu("onend"), e.end();
+          }
+          var l = LMt(r);
+          e.on("drain", l);
+          var u = false;
+          function c() {
+            nu("cleanup"), e.removeListener("close", d), e.removeListener("finish", v), e.removeListener("drain", l), e.removeListener("error", h), e.removeListener("unpipe", o), r.removeListener("end", s), r.removeListener("end", _), r.removeListener("data", f), u = true, n.awaitDrain && (!e._writableState || e._writableState.needDrain) && l();
+          }
+          r.on("data", f);
+          function f(b) {
+            nu("ondata");
+            var p = e.write(b);
+            nu("dest.write", p), p === false && ((n.pipesCount === 1 && n.pipes === e || n.pipesCount > 1 && ESe(n.pipes, e) !== -1) && !u && (nu("false write response, pause", n.awaitDrain), n.awaitDrain++), r.pause());
+          }
+          function h(b) {
+            nu("onerror", b), _(), e.removeListener("error", h), bSe(e, "error") === 0 && cE(e, b);
+          }
+          SMt(e, "error", h);
+          function d() {
+            e.removeListener("finish", v), _();
+          }
+          e.once("close", d);
+          function v() {
+            nu("onfinish"), e.removeListener("close", d), _();
+          }
+          e.once("finish", v);
+          function _() {
+            nu("unpipe"), r.unpipe(e);
+          }
+          return e.emit("pipe", r), n.flowing || (nu("pipe resume"), r.resume()), e;
+        };
+        function LMt(e) {
+          return function() {
+            var r = e._readableState;
+            nu("pipeOnDrain", r.awaitDrain), r.awaitDrain && r.awaitDrain--, r.awaitDrain === 0 && bSe(e, "data") && (r.flowing = true, zj(e));
+          };
+        }
+        Bu.prototype.unpipe = function(e) {
+          var t = this._readableState, r = { hasUnpiped: false };
+          if (t.pipesCount === 0) return this;
+          if (t.pipesCount === 1) return e && e !== t.pipes ? this : (e || (e = t.pipes), t.pipes = null, t.pipesCount = 0, t.flowing = false, e && e.emit("unpipe", this, r), this);
+          if (!e) {
+            var n = t.pipes, i = t.pipesCount;
+            t.pipes = null, t.pipesCount = 0, t.flowing = false;
+            for (var a = 0; a < i; a++) n[a].emit("unpipe", this, { hasUnpiped: false });
+            return this;
+          }
+          var o = ESe(t.pipes, e);
+          return o === -1 ? this : (t.pipes.splice(o, 1), t.pipesCount -= 1, t.pipesCount === 1 && (t.pipes = t.pipes[0]), e.emit("unpipe", this, r), this);
+        };
+        Bu.prototype.on = function(e, t) {
+          var r = fE.prototype.on.call(this, e, t), n = this._readableState;
+          return e === "data" ? (n.readableListening = this.listenerCount("readable") > 0, n.flowing !== false && this.resume()) : e === "readable" && !n.endEmitted && !n.readableListening && (n.readableListening = n.needReadable = true, n.flowing = false, n.emittedReadable = false, nu("on readable", n.length, n.reading), n.length ? FR(this) : n.reading || process.nextTick(PMt, this)), r;
+        };
+        Bu.prototype.addListener = Bu.prototype.on;
+        Bu.prototype.removeListener = function(e, t) {
+          var r = fE.prototype.removeListener.call(this, e, t);
+          return e === "readable" && process.nextTick(SSe, this), r;
+        };
+        Bu.prototype.removeAllListeners = function(e) {
+          var t = fE.prototype.removeAllListeners.apply(this, arguments);
+          return (e === "readable" || e === void 0) && process.nextTick(SSe, this), t;
+        };
+        function SSe(e) {
+          var t = e._readableState;
+          t.readableListening = e.listenerCount("readable") > 0, t.resumeScheduled && !t.paused ? t.flowing = true : e.listenerCount("data") > 0 && e.resume();
+        }
+        function PMt(e) {
+          nu("readable nexttick read 0"), e.read(0);
+        }
+        Bu.prototype.resume = function() {
+          var e = this._readableState;
+          return e.flowing || (nu("resume"), e.flowing = !e.readableListening, IMt(this, e)), e.paused = false, this;
+        };
+        function IMt(e, t) {
+          t.resumeScheduled || (t.resumeScheduled = true, process.nextTick(RMt, e, t));
+        }
+        function RMt(e, t) {
+          nu("resume", t.reading), t.reading || e.read(0), t.resumeScheduled = false, e.emit("resume"), zj(e), t.flowing && !t.reading && e.read(0);
+        }
+        Bu.prototype.pause = function() {
+          return nu("call pause flowing=%j", this._readableState.flowing), this._readableState.flowing !== false && (nu("pause"), this._readableState.flowing = false, this.emit("pause")), this._readableState.paused = true, this;
+        };
+        function zj(e) {
+          var t = e._readableState;
+          for (nu("flow", t.flowing); t.flowing && e.read() !== null; ) ;
+        }
+        Bu.prototype.wrap = function(e) {
+          var t = this, r = this._readableState, n = false;
+          e.on("end", function() {
+            if (nu("wrapped end"), r.decoder && !r.ended) {
+              var o = r.decoder.end();
+              o && o.length && t.push(o);
+            }
+            t.push(null);
+          }), e.on("data", function(o) {
+            if (nu("wrapped data"), r.decoder && (o = r.decoder.write(o)), !(r.objectMode && o == null) && !(!r.objectMode && (!o || !o.length))) {
+              var s = t.push(o);
+              s || (n = true, e.pause());
+            }
+          });
+          for (var i in e) this[i] === void 0 && typeof e[i] == "function" && (this[i] = /* @__PURE__ */ function(s) {
+            return function() {
+              return e[s].apply(e, arguments);
+            };
+          }(i));
+          for (var a = 0; a < Pj.length; a++) e.on(Pj[a], this.emit.bind(this, Pj[a]));
+          return this._read = function(o) {
+            nu("wrapped _read", o), n && (n = false, e.resume());
+          }, this;
+        };
+        typeof Symbol == "function" && (Bu.prototype[Symbol.asyncIterator] = function() {
+          return Cj === void 0 && (Cj = gSe()), Cj(this);
+        });
+        Object.defineProperty(Bu.prototype, "readableHighWaterMark", { enumerable: false, get: function() {
+          return this._readableState.highWaterMark;
+        } });
+        Object.defineProperty(Bu.prototype, "readableBuffer", { enumerable: false, get: function() {
+          return this._readableState && this._readableState.buffer;
+        } });
+        Object.defineProperty(Bu.prototype, "readableFlowing", { enumerable: false, get: function() {
+          return this._readableState.flowing;
+        }, set: function(t) {
+          this._readableState && (this._readableState.flowing = t);
+        } });
+        Bu._fromList = MSe;
+        Object.defineProperty(Bu.prototype, "readableLength", { enumerable: false, get: function() {
+          return this._readableState.length;
+        } });
+        function MSe(e, t) {
+          if (t.length === 0) return null;
+          var r;
+          return t.objectMode ? r = t.buffer.shift() : !e || e >= t.length ? (t.decoder ? r = t.buffer.join("") : t.buffer.length === 1 ? r = t.buffer.first() : r = t.buffer.concat(t.length), t.buffer.clear()) : r = t.buffer.consume(e, t.decoder), r;
+        }
+        function Rj(e) {
+          var t = e._readableState;
+          nu("endReadable", t.endEmitted), t.endEmitted || (t.ended = true, process.nextTick(DMt, t, e));
+        }
+        function DMt(e, t) {
+          if (nu("endReadableNT", e.endEmitted, e.length), !e.endEmitted && e.length === 0 && (e.endEmitted = true, t.readable = false, t.emit("end"), e.autoDestroy)) {
+            var r = t._writableState;
+            (!r || r.autoDestroy && r.finished) && t.destroy();
+          }
+        }
+        typeof Symbol == "function" && (Bu.from = function(e, t) {
+          return Lj === void 0 && (Lj = ySe()), Lj(Bu, e, t);
+        });
+        function ESe(e, t) {
+          for (var r = 0, n = e.length; r < n; r++) if (e[r] === t) return r;
+          return -1;
+        }
+      });
+      var Oj = ye((sdr, LSe) => {
+        LSe.exports = Ky;
+        var zR = A2().codes, FMt = zR.ERR_METHOD_NOT_IMPLEMENTED, zMt = zR.ERR_MULTIPLE_CALLBACK, OMt = zR.ERR_TRANSFORM_ALREADY_TRANSFORMING, qMt = zR.ERR_TRANSFORM_WITH_LENGTH_0, OR = S2();
+        Zy()(Ky, OR);
+        function BMt(e, t) {
+          var r = this._transformState;
+          r.transforming = false;
+          var n = r.writecb;
+          if (n === null) return this.emit("error", new zMt());
+          r.writechunk = null, r.writecb = null, t != null && this.push(t), n(e);
+          var i = this._readableState;
+          i.reading = false, (i.needReadable || i.length < i.highWaterMark) && this._read(i.highWaterMark);
+        }
+        function Ky(e) {
+          if (!(this instanceof Ky)) return new Ky(e);
+          OR.call(this, e), this._transformState = { afterTransform: BMt.bind(this), needTransform: false, transforming: false, writecb: null, writechunk: null, writeencoding: null }, this._readableState.needReadable = true, this._readableState.sync = false, e && (typeof e.transform == "function" && (this._transform = e.transform), typeof e.flush == "function" && (this._flush = e.flush)), this.on("prefinish", NMt);
+        }
+        function NMt() {
+          var e = this;
+          typeof this._flush == "function" && !this._readableState.destroyed ? this._flush(function(t, r) {
+            CSe(e, t, r);
+          }) : CSe(this, null, null);
+        }
+        Ky.prototype.push = function(e, t) {
+          return this._transformState.needTransform = false, OR.prototype.push.call(this, e, t);
+        };
+        Ky.prototype._transform = function(e, t, r) {
+          r(new FMt("_transform()"));
+        };
+        Ky.prototype._write = function(e, t, r) {
+          var n = this._transformState;
+          if (n.writecb = r, n.writechunk = e, n.writeencoding = t, !n.transforming) {
+            var i = this._readableState;
+            (n.needTransform || i.needReadable || i.length < i.highWaterMark) && this._read(i.highWaterMark);
+          }
+        };
+        Ky.prototype._read = function(e) {
+          var t = this._transformState;
+          t.writechunk !== null && !t.transforming ? (t.transforming = true, this._transform(t.writechunk, t.writeencoding, t.afterTransform)) : t.needTransform = true;
+        };
+        Ky.prototype._destroy = function(e, t) {
+          OR.prototype._destroy.call(this, e, function(r) {
+            t(r);
+          });
+        };
+        function CSe(e, t, r) {
+          if (t) return e.emit("error", t);
+          if (r != null && e.push(r), e._writableState.length) throw new qMt();
+          if (e._transformState.transforming) throw new OMt();
+          return e.push(null);
+        }
+      });
+      var RSe = ye((ldr, ISe) => {
+        ISe.exports = hE;
+        var PSe = Oj();
+        Zy()(hE, PSe);
+        function hE(e) {
+          if (!(this instanceof hE)) return new hE(e);
+          PSe.call(this, e);
+        }
+        hE.prototype._transform = function(e, t, r) {
+          r(null, e);
+        };
+      });
+      var qSe = ye((udr, OSe) => {
+        var qj;
+        function UMt(e) {
+          var t = false;
+          return function() {
+            t || (t = true, e.apply(void 0, arguments));
+          };
+        }
+        var zSe = A2().codes, VMt = zSe.ERR_MISSING_ARGS, GMt = zSe.ERR_STREAM_DESTROYED;
+        function DSe(e) {
+          if (e) throw e;
+        }
+        function HMt(e) {
+          return e.setHeader && typeof e.abort == "function";
+        }
+        function jMt(e, t, r, n) {
+          n = UMt(n);
+          var i = false;
+          e.on("close", function() {
+            i = true;
+          }), qj === void 0 && (qj = LR()), qj(e, { readable: t, writable: r }, function(o) {
+            if (o) return n(o);
+            i = true, n();
+          });
+          var a = false;
+          return function(o) {
+            if (!i && !a) {
+              if (a = true, HMt(e)) return e.abort();
+              if (typeof e.destroy == "function") return e.destroy();
+              n(o || new GMt("pipe"));
+            }
+          };
+        }
+        function FSe(e) {
+          e();
+        }
+        function WMt(e, t) {
+          return e.pipe(t);
+        }
+        function XMt(e) {
+          return !e.length || typeof e[e.length - 1] != "function" ? DSe : e.pop();
+        }
+        function ZMt() {
+          for (var e = arguments.length, t = new Array(e), r = 0; r < e; r++) t[r] = arguments[r];
+          var n = XMt(t);
+          if (Array.isArray(t[0]) && (t = t[0]), t.length < 2) throw new VMt("streams");
+          var i, a = t.map(function(o, s) {
+            var l = s < t.length - 1, u = s > 0;
+            return jMt(o, l, u, function(c) {
+              i || (i = c), c && a.forEach(FSe), !l && (a.forEach(FSe), n(i));
+            });
+          });
+          return t.reduce(WMt);
+        }
+        OSe.exports = ZMt;
+      });
+      var NSe = ye((cdr, BSe) => {
+        BSe.exports = $0;
+        var Bj = Ab().EventEmitter, YMt = Zy();
+        YMt($0, Bj);
+        $0.Readable = wj();
+        $0.Writable = _j();
+        $0.Duplex = S2();
+        $0.Transform = Oj();
+        $0.PassThrough = RSe();
+        $0.finished = LR();
+        $0.pipeline = qSe();
+        $0.Stream = $0;
+        function $0() {
+          Bj.call(this);
+        }
+        $0.prototype.pipe = function(e, t) {
+          var r = this;
+          function n(c) {
+            e.writable && e.write(c) === false && r.pause && r.pause();
+          }
+          r.on("data", n);
+          function i() {
+            r.readable && r.resume && r.resume();
+          }
+          e.on("drain", i), !e._isStdio && (!t || t.end !== false) && (r.on("end", o), r.on("close", s));
+          var a = false;
+          function o() {
+            a || (a = true, e.end());
+          }
+          function s() {
+            a || (a = true, typeof e.destroy == "function" && e.destroy());
+          }
+          function l(c) {
+            if (u(), Bj.listenerCount(this, "error") === 0) throw c;
+          }
+          r.on("error", l), e.on("error", l);
+          function u() {
+            r.removeListener("data", n), e.removeListener("drain", i), r.removeListener("end", o), r.removeListener("close", s), r.removeListener("error", l), e.removeListener("error", l), r.removeListener("end", u), r.removeListener("close", u), e.removeListener("close", u);
+          }
+          return r.on("end", u), r.on("close", u), e.on("close", u), e.emit("pipe", r), e;
+        };
+      });
+      var bA = ye((fu) => {
+        var USe = Object.getOwnPropertyDescriptors || function(t) {
+          for (var r = Object.keys(t), n = {}, i = 0; i < r.length; i++) n[r[i]] = Object.getOwnPropertyDescriptor(t, r[i]);
+          return n;
+        }, KMt = /%[sdj%]/g;
+        fu.format = function(e) {
+          if (!HR(e)) {
+            for (var t = [], r = 0; r < arguments.length; r++) t.push(W_(arguments[r]));
+            return t.join(" ");
+          }
+          for (var r = 1, n = arguments, i = n.length, a = String(e).replace(KMt, function(s) {
+            if (s === "%%") return "%";
+            if (r >= i) return s;
+            switch (s) {
+              case "%s":
+                return String(n[r++]);
+              case "%d":
+                return Number(n[r++]);
+              case "%j":
+                try {
+                  return JSON.stringify(n[r++]);
+                } catch (l) {
+                  return "[Circular]";
+                }
+              default:
+                return s;
+            }
+          }), o = n[r]; r < i; o = n[++r]) GR(o) || !xA(o) ? a += " " + o : a += " " + W_(o);
+          return a;
+        };
+        fu.deprecate = function(e, t) {
+          if (typeof process != "undefined" && process.noDeprecation === true) return e;
+          if (typeof process == "undefined") return function() {
+            return fu.deprecate(e, t).apply(this, arguments);
+          };
+          var r = false;
+          function n() {
+            if (!r) {
+              if (process.throwDeprecation) throw new Error(t);
+              process.traceDeprecation ? console.trace(t) : console.error(t), r = true;
+            }
+            return e.apply(this, arguments);
+          }
+          return n;
+        };
+        var qR = {}, VSe = /^$/;
+        BR = "false", BR = BR.replace(/[|\\{}()[\]^$+?.]/g, "\\$&").replace(/\*/g, ".*").replace(/,/g, "$|^").toUpperCase(), VSe = new RegExp("^" + BR + "$", "i");
+        var BR;
+        fu.debuglog = function(e) {
+          if (e = e.toUpperCase(), !qR[e]) if (VSe.test(e)) {
+            var t = process.pid;
+            qR[e] = function() {
+              var r = fu.format.apply(fu, arguments);
+              console.error("%s %d: %s", e, t, r);
+            };
+          } else qR[e] = function() {
+          };
+          return qR[e];
+        };
+        function W_(e, t) {
+          var r = { seen: [], stylize: $Mt };
+          return arguments.length >= 3 && (r.depth = arguments[2]), arguments.length >= 4 && (r.colors = arguments[3]), Gj(t) ? r.showHidden = t : t && fu._extend(r, t), P2(r.showHidden) && (r.showHidden = false), P2(r.depth) && (r.depth = 2), P2(r.colors) && (r.colors = false), P2(r.customInspect) && (r.customInspect = true), r.colors && (r.stylize = JMt), UR(r, e, r.depth);
+        }
+        fu.inspect = W_;
+        W_.colors = { bold: [1, 22], italic: [3, 23], underline: [4, 24], inverse: [7, 27], white: [37, 39], grey: [90, 39], black: [30, 39], blue: [34, 39], cyan: [36, 39], green: [32, 39], magenta: [35, 39], red: [31, 39], yellow: [33, 39] };
+        W_.styles = { special: "cyan", number: "yellow", boolean: "yellow", undefined: "grey", null: "bold", string: "green", date: "magenta", regexp: "red" };
+        function JMt(e, t) {
+          var r = W_.styles[t];
+          return r ? "\x1B[" + W_.colors[r][0] + "m" + e + "\x1B[" + W_.colors[r][1] + "m" : e;
+        }
+        function $Mt(e, t) {
+          return e;
+        }
+        function QMt(e) {
+          var t = {};
+          return e.forEach(function(r, n) {
+            t[r] = true;
+          }), t;
+        }
+        function UR(e, t, r) {
+          if (e.customInspect && t && NR(t.inspect) && t.inspect !== fu.inspect && !(t.constructor && t.constructor.prototype === t)) {
+            var n = t.inspect(r, e);
+            return HR(n) || (n = UR(e, n, r)), n;
+          }
+          var i = e4t(e, t);
+          if (i) return i;
+          var a = Object.keys(t), o = QMt(a);
+          if (e.showHidden && (a = Object.getOwnPropertyNames(t)), vE(t) && (a.indexOf("message") >= 0 || a.indexOf("description") >= 0)) return Nj(t);
+          if (a.length === 0) {
+            if (NR(t)) {
+              var s = t.name ? ": " + t.name : "";
+              return e.stylize("[Function" + s + "]", "special");
+            }
+            if (dE(t)) return e.stylize(RegExp.prototype.toString.call(t), "regexp");
+            if (VR(t)) return e.stylize(Date.prototype.toString.call(t), "date");
+            if (vE(t)) return Nj(t);
+          }
+          var l = "", u = false, c = ["{", "}"];
+          if (GSe(t) && (u = true, c = ["[", "]"]), NR(t)) {
+            var f = t.name ? ": " + t.name : "";
+            l = " [Function" + f + "]";
+          }
+          if (dE(t) && (l = " " + RegExp.prototype.toString.call(t)), VR(t) && (l = " " + Date.prototype.toUTCString.call(t)), vE(t) && (l = " " + Nj(t)), a.length === 0 && (!u || t.length == 0)) return c[0] + l + c[1];
+          if (r < 0) return dE(t) ? e.stylize(RegExp.prototype.toString.call(t), "regexp") : e.stylize("[Object]", "special");
+          e.seen.push(t);
+          var h;
+          return u ? h = t4t(e, t, r, o, a) : h = a.map(function(d) {
+            return Vj(e, t, r, o, d, u);
+          }), e.seen.pop(), r4t(h, l, c);
+        }
+        function e4t(e, t) {
+          if (P2(t)) return e.stylize("undefined", "undefined");
+          if (HR(t)) {
+            var r = "'" + JSON.stringify(t).replace(/^"|"$/g, "").replace(/'/g, "\\'").replace(/\\"/g, '"') + "'";
+            return e.stylize(r, "string");
+          }
+          if (HSe(t)) return e.stylize("" + t, "number");
+          if (Gj(t)) return e.stylize("" + t, "boolean");
+          if (GR(t)) return e.stylize("null", "null");
+        }
+        function Nj(e) {
+          return "[" + Error.prototype.toString.call(e) + "]";
+        }
+        function t4t(e, t, r, n, i) {
+          for (var a = [], o = 0, s = t.length; o < s; ++o) jSe(t, String(o)) ? a.push(Vj(e, t, r, n, String(o), true)) : a.push("");
+          return i.forEach(function(l) {
+            l.match(/^\d+$/) || a.push(Vj(e, t, r, n, l, true));
+          }), a;
+        }
+        function Vj(e, t, r, n, i, a) {
+          var o, s, l;
+          if (l = Object.getOwnPropertyDescriptor(t, i) || { value: t[i] }, l.get ? l.set ? s = e.stylize("[Getter/Setter]", "special") : s = e.stylize("[Getter]", "special") : l.set && (s = e.stylize("[Setter]", "special")), jSe(n, i) || (o = "[" + i + "]"), s || (e.seen.indexOf(l.value) < 0 ? (GR(r) ? s = UR(e, l.value, null) : s = UR(e, l.value, r - 1), s.indexOf(`
+`) > -1 && (a ? s = s.split(`
+`).map(function(u) {
+            return "  " + u;
+          }).join(`
+`).slice(2) : s = `
+` + s.split(`
+`).map(function(u) {
+            return "   " + u;
+          }).join(`
+`))) : s = e.stylize("[Circular]", "special")), P2(o)) {
+            if (a && i.match(/^\d+$/)) return s;
+            o = JSON.stringify("" + i), o.match(/^"([a-zA-Z_][a-zA-Z_0-9]*)"$/) ? (o = o.slice(1, -1), o = e.stylize(o, "name")) : (o = o.replace(/'/g, "\\'").replace(/\\"/g, '"').replace(/(^"|"$)/g, "'"), o = e.stylize(o, "string"));
+          }
+          return o + ": " + s;
+        }
+        function r4t(e, t, r) {
+          var n = 0, i = e.reduce(function(a, o) {
+            return n++, o.indexOf(`
+`) >= 0 && n++, a + o.replace(/\u001b\[\d\d?m/g, "").length + 1;
+          }, 0);
+          return i > 60 ? r[0] + (t === "" ? "" : t + `
+ `) + " " + e.join(`,
+  `) + " " + r[1] : r[0] + t + " " + e.join(", ") + " " + r[1];
+        }
+        fu.types = nj();
+        function GSe(e) {
+          return Array.isArray(e);
+        }
+        fu.isArray = GSe;
+        function Gj(e) {
+          return typeof e == "boolean";
+        }
+        fu.isBoolean = Gj;
+        function GR(e) {
+          return e === null;
+        }
+        fu.isNull = GR;
+        function i4t(e) {
+          return e == null;
+        }
+        fu.isNullOrUndefined = i4t;
+        function HSe(e) {
+          return typeof e == "number";
+        }
+        fu.isNumber = HSe;
+        function HR(e) {
+          return typeof e == "string";
+        }
+        fu.isString = HR;
+        function n4t(e) {
+          return typeof e == "symbol";
+        }
+        fu.isSymbol = n4t;
+        function P2(e) {
+          return e === void 0;
+        }
+        fu.isUndefined = P2;
+        function dE(e) {
+          return xA(e) && Hj(e) === "[object RegExp]";
+        }
+        fu.isRegExp = dE;
+        fu.types.isRegExp = dE;
+        function xA(e) {
+          return typeof e == "object" && e !== null;
+        }
+        fu.isObject = xA;
+        function VR(e) {
+          return xA(e) && Hj(e) === "[object Date]";
+        }
+        fu.isDate = VR;
+        fu.types.isDate = VR;
+        function vE(e) {
+          return xA(e) && (Hj(e) === "[object Error]" || e instanceof Error);
+        }
+        fu.isError = vE;
+        fu.types.isNativeError = vE;
+        function NR(e) {
+          return typeof e == "function";
+        }
+        fu.isFunction = NR;
+        function a4t(e) {
+          return e === null || typeof e == "boolean" || typeof e == "number" || typeof e == "string" || typeof e == "symbol" || typeof e == "undefined";
+        }
+        fu.isPrimitive = a4t;
+        fu.isBuffer = aj();
+        function Hj(e) {
+          return Object.prototype.toString.call(e);
+        }
+        function Uj(e) {
+          return e < 10 ? "0" + e.toString(10) : e.toString(10);
+        }
+        var o4t = ["Jan", "Feb", "Mar", "Apr", "May", "Jun", "Jul", "Aug", "Sep", "Oct", "Nov", "Dec"];
+        function s4t() {
+          var e = /* @__PURE__ */ new Date(), t = [Uj(e.getHours()), Uj(e.getMinutes()), Uj(e.getSeconds())].join(":");
+          return [e.getDate(), o4t[e.getMonth()], t].join(" ");
+        }
+        fu.log = function() {
+          console.log("%s - %s", s4t(), fu.format.apply(fu, arguments));
+        };
+        fu.inherits = Zy();
+        fu._extend = function(e, t) {
+          if (!t || !xA(t)) return e;
+          for (var r = Object.keys(t), n = r.length; n--; ) e[r[n]] = t[r[n]];
+          return e;
+        };
+        function jSe(e, t) {
+          return Object.prototype.hasOwnProperty.call(e, t);
+        }
+        var L2 = typeof Symbol != "undefined" ? Symbol("util.promisify.custom") : void 0;
+        fu.promisify = function(t) {
+          if (typeof t != "function") throw new TypeError('The "original" argument must be of type Function');
+          if (L2 && t[L2]) {
+            var r = t[L2];
+            if (typeof r != "function") throw new TypeError('The "util.promisify.custom" argument must be of type Function');
+            return Object.defineProperty(r, L2, { value: r, enumerable: false, writable: false, configurable: true }), r;
+          }
+          function r() {
+            for (var n, i, a = new Promise(function(l, u) {
+              n = l, i = u;
+            }), o = [], s = 0; s < arguments.length; s++) o.push(arguments[s]);
+            o.push(function(l, u) {
+              l ? i(l) : n(u);
+            });
+            try {
+              t.apply(this, o);
+            } catch (l) {
+              i(l);
+            }
+            return a;
+          }
+          return Object.setPrototypeOf(r, Object.getPrototypeOf(t)), L2 && Object.defineProperty(r, L2, { value: r, enumerable: false, writable: false, configurable: true }), Object.defineProperties(r, USe(t));
+        };
+        fu.promisify.custom = L2;
+        function l4t(e, t) {
+          if (!e) {
+            var r = new Error("Promise was rejected with a falsy value");
+            r.reason = e, e = r;
+          }
+          return t(e);
+        }
+        function u4t(e) {
+          if (typeof e != "function") throw new TypeError('The "original" argument must be of type Function');
+          function t() {
+            for (var r = [], n = 0; n < arguments.length; n++) r.push(arguments[n]);
+            var i = r.pop();
+            if (typeof i != "function") throw new TypeError("The last argument must be of type Function");
+            var a = this, o = function() {
+              return i.apply(a, arguments);
+            };
+            e.apply(this, r).then(function(s) {
+              process.nextTick(o.bind(null, null, s));
+            }, function(s) {
+              process.nextTick(l4t.bind(null, s, o));
+            });
+          }
+          return Object.setPrototypeOf(t, Object.getPrototypeOf(e)), Object.defineProperties(t, USe(e)), t;
+        }
+        fu.callbackify = u4t;
+      });
+      var Xj = ye((hdr, YSe) => {
+        function X_(e) {
+          "@babel/helpers - typeof";
+          return X_ = typeof Symbol == "function" && typeof Symbol.iterator == "symbol" ? function(t) {
+            return typeof t;
+          } : function(t) {
+            return t && typeof Symbol == "function" && t.constructor === Symbol && t !== Symbol.prototype ? "symbol" : typeof t;
+          }, X_(e);
+        }
+        function c4t(e, t, r) {
+          return Object.defineProperty(e, "prototype", { writable: false }), e;
+        }
+        function d4t(e, t) {
+          if (!(e instanceof t)) throw new TypeError("Cannot call a class as a function");
+        }
+        function v4t(e, t) {
+          if (typeof t != "function" && t !== null) throw new TypeError("Super expression must either be null or a function");
+          e.prototype = Object.create(t && t.prototype, { constructor: { value: e, writable: true, configurable: true } }), Object.defineProperty(e, "prototype", { writable: false }), t && Wj(e, t);
+        }
+        function Wj(e, t) {
+          return Wj = Object.setPrototypeOf ? Object.setPrototypeOf.bind() : function(n, i) {
+            return n.__proto__ = i, n;
+          }, Wj(e, t);
+        }
+        function p4t(e) {
+          var t = y4t();
+          return function() {
+            var n = jR(e), i;
+            if (t) {
+              var a = jR(this).constructor;
+              i = Reflect.construct(n, arguments, a);
+            } else i = n.apply(this, arguments);
+            return g4t(this, i);
+          };
+        }
+        function g4t(e, t) {
+          if (t && (X_(t) === "object" || typeof t == "function")) return t;
+          if (t !== void 0) throw new TypeError("Derived constructors may only return object or undefined");
+          return m4t(e);
+        }
+        function m4t(e) {
+          if (e === void 0) throw new ReferenceError("this hasn't been initialised - super() hasn't been called");
+          return e;
+        }
+        function y4t() {
+          if (typeof Reflect == "undefined" || !Reflect.construct || Reflect.construct.sham) return false;
+          if (typeof Proxy == "function") return true;
+          try {
+            return Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function() {
+            })), true;
+          } catch (e) {
+            return false;
+          }
+        }
+        function jR(e) {
+          return jR = Object.setPrototypeOf ? Object.getPrototypeOf.bind() : function(r) {
+            return r.__proto__ || Object.getPrototypeOf(r);
+          }, jR(e);
+        }
+        var ZSe = {}, wA, jj;
+        function pE(e, t, r) {
+          r || (r = Error);
+          function n(a, o, s) {
+            return typeof t == "string" ? t : t(a, o, s);
+          }
+          var i = function(a) {
+            v4t(s, a);
+            var o = p4t(s);
+            function s(l, u, c) {
+              var f;
+              return d4t(this, s), f = o.call(this, n(l, u, c)), f.code = e, f;
+            }
+            return c4t(s);
+          }(r);
+          ZSe[e] = i;
+        }
+        function XSe(e, t) {
+          if (Array.isArray(e)) {
+            var r = e.length;
+            return e = e.map(function(n) {
+              return String(n);
+            }), r > 2 ? "one of ".concat(t, " ").concat(e.slice(0, r - 1).join(", "), ", or ") + e[r - 1] : r === 2 ? "one of ".concat(t, " ").concat(e[0], " or ").concat(e[1]) : "of ".concat(t, " ").concat(e[0]);
+          } else return "of ".concat(t, " ").concat(String(e));
+        }
+        function _4t(e, t, r) {
+          return e.substr(0, t.length) === t;
+        }
+        function x4t(e, t, r) {
+          return (r === void 0 || r > e.length) && (r = e.length), e.substring(r - t.length, r) === t;
+        }
+        function b4t(e, t, r) {
+          return typeof r != "number" && (r = 0), r + t.length > e.length ? false : e.indexOf(t, r) !== -1;
+        }
+        pE("ERR_AMBIGUOUS_ARGUMENT", 'The "%s" argument is ambiguous. %s', TypeError);
+        pE("ERR_INVALID_ARG_TYPE", function(e, t, r) {
+          wA === void 0 && (wA = gE()), wA(typeof e == "string", "'name' must be a string");
+          var n;
+          typeof t == "string" && _4t(t, "not ") ? (n = "must not be", t = t.replace(/^not /, "")) : n = "must be";
+          var i;
+          if (x4t(e, " argument")) i = "The ".concat(e, " ").concat(n, " ").concat(XSe(t, "type"));
+          else {
+            var a = b4t(e, ".") ? "property" : "argument";
+            i = 'The "'.concat(e, '" ').concat(a, " ").concat(n, " ").concat(XSe(t, "type"));
+          }
+          return i += ". Received type ".concat(X_(r)), i;
+        }, TypeError);
+        pE("ERR_INVALID_ARG_VALUE", function(e, t) {
+          var r = arguments.length > 2 && arguments[2] !== void 0 ? arguments[2] : "is invalid";
+          jj === void 0 && (jj = bA());
+          var n = jj.inspect(t);
+          return n.length > 128 && (n = "".concat(n.slice(0, 128), "...")), "The argument '".concat(e, "' ").concat(r, ". Received ").concat(n);
+        }, TypeError);
+        pE("ERR_INVALID_RETURN_VALUE", function(e, t, r) {
+          var n;
+          return r && r.constructor && r.constructor.name ? n = "instance of ".concat(r.constructor.name) : n = "type ".concat(X_(r)), "Expected ".concat(e, ' to be returned from the "').concat(t, '"') + " function but got ".concat(n, ".");
+        }, TypeError);
+        pE("ERR_MISSING_ARGS", function() {
+          for (var e = arguments.length, t = new Array(e), r = 0; r < e; r++) t[r] = arguments[r];
+          wA === void 0 && (wA = gE()), wA(t.length > 0, "At least one arg needs to be specified");
+          var n = "The ", i = t.length;
+          switch (t = t.map(function(a) {
+            return '"'.concat(a, '"');
+          }), i) {
+            case 1:
+              n += "".concat(t[0], " argument");
+              break;
+            case 2:
+              n += "".concat(t[0], " and ").concat(t[1], " arguments");
+              break;
+            default:
+              n += t.slice(0, i - 1).join(", "), n += ", and ".concat(t[i - 1], " arguments");
+              break;
+          }
+          return "".concat(n, " must be specified");
+        }, TypeError);
+        YSe.exports.codes = ZSe;
+      });
+      var aMe = ye((ddr, nMe) => {
+        function KSe(e, t) {
+          var r = Object.keys(e);
+          if (Object.getOwnPropertySymbols) {
+            var n = Object.getOwnPropertySymbols(e);
+            t && (n = n.filter(function(i) {
+              return Object.getOwnPropertyDescriptor(e, i).enumerable;
+            })), r.push.apply(r, n);
+          }
+          return r;
+        }
+        function JSe(e) {
+          for (var t = 1; t < arguments.length; t++) {
+            var r = arguments[t] != null ? arguments[t] : {};
+            t % 2 ? KSe(Object(r), true).forEach(function(n) {
+              w4t(e, n, r[n]);
+            }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(r)) : KSe(Object(r)).forEach(function(n) {
+              Object.defineProperty(e, n, Object.getOwnPropertyDescriptor(r, n));
+            });
+          }
+          return e;
+        }
+        function w4t(e, t, r) {
+          return t = tMe(t), t in e ? Object.defineProperty(e, t, { value: r, enumerable: true, configurable: true, writable: true }) : e[t] = r, e;
+        }
+        function T4t(e, t) {
+          if (!(e instanceof t)) throw new TypeError("Cannot call a class as a function");
+        }
+        function $Se(e, t) {
+          for (var r = 0; r < t.length; r++) {
+            var n = t[r];
+            n.enumerable = n.enumerable || false, n.configurable = true, "value" in n && (n.writable = true), Object.defineProperty(e, tMe(n.key), n);
+          }
+        }
+        function A4t(e, t, r) {
+          return t && $Se(e.prototype, t), Object.defineProperty(e, "prototype", { writable: false }), e;
+        }
+        function tMe(e) {
+          var t = S4t(e, "string");
+          return Dp(t) === "symbol" ? t : String(t);
+        }
+        function S4t(e, t) {
+          if (Dp(e) !== "object" || e === null) return e;
+          var r = e[Symbol.toPrimitive];
+          if (r !== void 0) {
+            var n = r.call(e, t);
+            if (Dp(n) !== "object") return n;
+            throw new TypeError("@@toPrimitive must return a primitive value.");
+          }
+          return String(e);
+        }
+        function M4t(e, t) {
+          if (typeof t != "function" && t !== null) throw new TypeError("Super expression must either be null or a function");
+          e.prototype = Object.create(t && t.prototype, { constructor: { value: e, writable: true, configurable: true } }), Object.defineProperty(e, "prototype", { writable: false }), t && xE(e, t);
+        }
+        function E4t(e) {
+          var t = iMe();
+          return function() {
+            var n = bE(e), i;
+            if (t) {
+              var a = bE(this).constructor;
+              i = Reflect.construct(n, arguments, a);
+            } else i = n.apply(this, arguments);
+            return rMe(this, i);
+          };
+        }
+        function rMe(e, t) {
+          if (t && (Dp(t) === "object" || typeof t == "function")) return t;
+          if (t !== void 0) throw new TypeError("Derived constructors may only return object or undefined");
+          return Zj(e);
+        }
+        function Zj(e) {
+          if (e === void 0) throw new ReferenceError("this hasn't been initialised - super() hasn't been called");
+          return e;
+        }
+        function Yj(e) {
+          var t = typeof Map == "function" ? /* @__PURE__ */ new Map() : void 0;
+          return Yj = function(n) {
+            if (n === null || !k4t(n)) return n;
+            if (typeof n != "function") throw new TypeError("Super expression must either be null or a function");
+            if (typeof t != "undefined") {
+              if (t.has(n)) return t.get(n);
+              t.set(n, i);
+            }
+            function i() {
+              return WR(n, arguments, bE(this).constructor);
+            }
+            return i.prototype = Object.create(n.prototype, { constructor: { value: i, enumerable: false, writable: true, configurable: true } }), xE(i, n);
+          }, Yj(e);
+        }
+        function WR(e, t, r) {
+          return iMe() ? WR = Reflect.construct.bind() : WR = function(i, a, o) {
+            var s = [null];
+            s.push.apply(s, a);
+            var l = Function.bind.apply(i, s), u = new l();
+            return o && xE(u, o.prototype), u;
+          }, WR.apply(null, arguments);
+        }
+        function iMe() {
+          if (typeof Reflect == "undefined" || !Reflect.construct || Reflect.construct.sham) return false;
+          if (typeof Proxy == "function") return true;
+          try {
+            return Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function() {
+            })), true;
+          } catch (e) {
+            return false;
+          }
+        }
+        function k4t(e) {
+          return Function.toString.call(e).indexOf("[native code]") !== -1;
+        }
+        function xE(e, t) {
+          return xE = Object.setPrototypeOf ? Object.setPrototypeOf.bind() : function(n, i) {
+            return n.__proto__ = i, n;
+          }, xE(e, t);
+        }
+        function bE(e) {
+          return bE = Object.setPrototypeOf ? Object.getPrototypeOf.bind() : function(r) {
+            return r.__proto__ || Object.getPrototypeOf(r);
+          }, bE(e);
+        }
+        function Dp(e) {
+          "@babel/helpers - typeof";
+          return Dp = typeof Symbol == "function" && typeof Symbol.iterator == "symbol" ? function(t) {
+            return typeof t;
+          } : function(t) {
+            return t && typeof Symbol == "function" && t.constructor === Symbol && t !== Symbol.prototype ? "symbol" : typeof t;
+          }, Dp(e);
+        }
+        var C4t = bA(), Kj = C4t.inspect, L4t = Xj(), P4t = L4t.codes.ERR_INVALID_ARG_TYPE;
+        function QSe(e, t, r) {
+          return (r === void 0 || r > e.length) && (r = e.length), e.substring(r - t.length, r) === t;
+        }
+        function I4t(e, t) {
+          if (t = Math.floor(t), e.length == 0 || t == 0) return "";
+          var r = e.length * t;
+          for (t = Math.floor(Math.log(t) / Math.log(2)); t; ) e += e, t--;
+          return e += e.substring(0, r - e.length), e;
+        }
+        var Xg = "", mE = "", yE = "", Tv = "", I2 = { deepStrictEqual: "Expected values to be strictly deep-equal:", strictEqual: "Expected values to be strictly equal:", strictEqualObject: 'Expected "actual" to be reference-equal to "expected":', deepEqual: "Expected values to be loosely deep-equal:", equal: "Expected values to be loosely equal:", notDeepStrictEqual: 'Expected "actual" not to be strictly deep-equal to:', notStrictEqual: 'Expected "actual" to be strictly unequal to:', notStrictEqualObject: 'Expected "actual" not to be reference-equal to "expected":', notDeepEqual: 'Expected "actual" not to be loosely deep-equal to:', notEqual: 'Expected "actual" to be loosely unequal to:', notIdentical: "Values identical but not reference-equal:" }, R4t = 10;
+        function eMe(e) {
+          var t = Object.keys(e), r = Object.create(Object.getPrototypeOf(e));
+          return t.forEach(function(n) {
+            r[n] = e[n];
+          }), Object.defineProperty(r, "message", { value: e.message }), r;
+        }
+        function _E(e) {
+          return Kj(e, { compact: false, customInspect: false, depth: 1e3, maxArrayLength: 1 / 0, showHidden: false, breakLength: 1 / 0, showProxy: false, sorted: true, getters: true });
+        }
+        function D4t(e, t, r) {
+          var n = "", i = "", a = 0, o = "", s = false, l = _E(e), u = l.split(`
+`), c = _E(t).split(`
+`), f = 0, h = "";
+          if (r === "strictEqual" && Dp(e) === "object" && Dp(t) === "object" && e !== null && t !== null && (r = "strictEqualObject"), u.length === 1 && c.length === 1 && u[0] !== c[0]) {
+            var d = u[0].length + c[0].length;
+            if (d <= R4t) {
+              if ((Dp(e) !== "object" || e === null) && (Dp(t) !== "object" || t === null) && (e !== 0 || t !== 0)) return "".concat(I2[r], `
+
+`) + "".concat(u[0], " !== ").concat(c[0], `
+`);
+            } else if (r !== "strictEqualObject") {
+              var v = process.stderr && process.stderr.isTTY ? process.stderr.columns : 80;
+              if (d < v) {
+                for (; u[0][f] === c[0][f]; ) f++;
+                f > 2 && (h = `
+  `.concat(I4t(" ", f), "^"), f = 0);
+              }
+            }
+          }
+          for (var _ = u[u.length - 1], b = c[c.length - 1]; _ === b && (f++ < 2 ? o = `
+  `.concat(_).concat(o) : n = _, u.pop(), c.pop(), !(u.length === 0 || c.length === 0)); ) _ = u[u.length - 1], b = c[c.length - 1];
+          var p = Math.max(u.length, c.length);
+          if (p === 0) {
+            var k = l.split(`
+`);
+            if (k.length > 30) for (k[26] = "".concat(Xg, "...").concat(Tv); k.length > 27; ) k.pop();
+            return "".concat(I2.notIdentical, `
+
+`).concat(k.join(`
+`), `
+`);
+          }
+          f > 3 && (o = `
+`.concat(Xg, "...").concat(Tv).concat(o), s = true), n !== "" && (o = `
+  `.concat(n).concat(o), n = "");
+          var E = 0, T = I2[r] + `
+`.concat(mE, "+ actual").concat(Tv, " ").concat(yE, "- expected").concat(Tv), L = " ".concat(Xg, "...").concat(Tv, " Lines skipped");
+          for (f = 0; f < p; f++) {
+            var x = f - a;
+            if (u.length < f + 1) x > 1 && f > 2 && (x > 4 ? (i += `
+`.concat(Xg, "...").concat(Tv), s = true) : x > 3 && (i += `
+  `.concat(c[f - 2]), E++), i += `
+  `.concat(c[f - 1]), E++), a = f, n += `
+`.concat(yE, "-").concat(Tv, " ").concat(c[f]), E++;
+            else if (c.length < f + 1) x > 1 && f > 2 && (x > 4 ? (i += `
+`.concat(Xg, "...").concat(Tv), s = true) : x > 3 && (i += `
+  `.concat(u[f - 2]), E++), i += `
+  `.concat(u[f - 1]), E++), a = f, i += `
+`.concat(mE, "+").concat(Tv, " ").concat(u[f]), E++;
+            else {
+              var C = c[f], M = u[f], g = M !== C && (!QSe(M, ",") || M.slice(0, -1) !== C);
+              g && QSe(C, ",") && C.slice(0, -1) === M && (g = false, M += ","), g ? (x > 1 && f > 2 && (x > 4 ? (i += `
+`.concat(Xg, "...").concat(Tv), s = true) : x > 3 && (i += `
+  `.concat(u[f - 2]), E++), i += `
+  `.concat(u[f - 1]), E++), a = f, i += `
+`.concat(mE, "+").concat(Tv, " ").concat(M), n += `
+`.concat(yE, "-").concat(Tv, " ").concat(C), E += 2) : (i += n, n = "", (x === 1 || f === 0) && (i += `
+  `.concat(M), E++));
+            }
+            if (E > 20 && f < p - 2) return "".concat(T).concat(L, `
+`).concat(i, `
+`).concat(Xg, "...").concat(Tv).concat(n, `
+`) + "".concat(Xg, "...").concat(Tv);
+          }
+          return "".concat(T).concat(s ? L : "", `
+`).concat(i).concat(n).concat(o).concat(h);
+        }
+        var F4t = function(e, t) {
+          M4t(n, e);
+          var r = E4t(n);
+          function n(i) {
+            var a;
+            if (T4t(this, n), Dp(i) !== "object" || i === null) throw new P4t("options", "Object", i);
+            var o = i.message, s = i.operator, l = i.stackStartFn, u = i.actual, c = i.expected, f = Error.stackTraceLimit;
+            if (Error.stackTraceLimit = 0, o != null) a = r.call(this, String(o));
+            else if (process.stderr && process.stderr.isTTY && (process.stderr && process.stderr.getColorDepth && process.stderr.getColorDepth() !== 1 ? (Xg = "\x1B[34m", mE = "\x1B[32m", Tv = "\x1B[39m", yE = "\x1B[31m") : (Xg = "", mE = "", Tv = "", yE = "")), Dp(u) === "object" && u !== null && Dp(c) === "object" && c !== null && "stack" in u && u instanceof Error && "stack" in c && c instanceof Error && (u = eMe(u), c = eMe(c)), s === "deepStrictEqual" || s === "strictEqual") a = r.call(this, D4t(u, c, s));
+            else if (s === "notDeepStrictEqual" || s === "notStrictEqual") {
+              var h = I2[s], d = _E(u).split(`
+`);
+              if (s === "notStrictEqual" && Dp(u) === "object" && u !== null && (h = I2.notStrictEqualObject), d.length > 30) for (d[26] = "".concat(Xg, "...").concat(Tv); d.length > 27; ) d.pop();
+              d.length === 1 ? a = r.call(this, "".concat(h, " ").concat(d[0])) : a = r.call(this, "".concat(h, `
+
+`).concat(d.join(`
+`), `
+`));
+            } else {
+              var v = _E(u), _ = "", b = I2[s];
+              s === "notDeepEqual" || s === "notEqual" ? (v = "".concat(I2[s], `
+
+`).concat(v), v.length > 1024 && (v = "".concat(v.slice(0, 1021), "..."))) : (_ = "".concat(_E(c)), v.length > 512 && (v = "".concat(v.slice(0, 509), "...")), _.length > 512 && (_ = "".concat(_.slice(0, 509), "...")), s === "deepEqual" || s === "equal" ? v = "".concat(b, `
+
+`).concat(v, `
+
+should equal
+
+`) : _ = " ".concat(s, " ").concat(_)), a = r.call(this, "".concat(v).concat(_));
+            }
+            return Error.stackTraceLimit = f, a.generatedMessage = !o, Object.defineProperty(Zj(a), "name", { value: "AssertionError [ERR_ASSERTION]", enumerable: false, writable: true, configurable: true }), a.code = "ERR_ASSERTION", a.actual = u, a.expected = c, a.operator = s, Error.captureStackTrace && Error.captureStackTrace(Zj(a), l), a.stack, a.name = "AssertionError", rMe(a);
+          }
+          return A4t(n, [{ key: "toString", value: function() {
+            return "".concat(this.name, " [").concat(this.code, "]: ").concat(this.message);
+          } }, { key: t, value: function(a, o) {
+            return Kj(this, JSe(JSe({}, o), {}, { customInspect: false, depth: 0 }));
+          } }]), n;
+        }(Yj(Error), Kj.custom);
+        nMe.exports = F4t;
+      });
+      var Jj = ye((vdr, sMe) => {
+        var oMe = Object.prototype.toString;
+        sMe.exports = function(t) {
+          var r = oMe.call(t), n = r === "[object Arguments]";
+          return n || (n = r !== "[object Array]" && t !== null && typeof t == "object" && typeof t.length == "number" && t.length >= 0 && oMe.call(t.callee) === "[object Function]"), n;
+        };
+      });
+      var gMe = ye((pdr, pMe) => {
+        var vMe;
+        Object.keys || (wE = Object.prototype.hasOwnProperty, $j = Object.prototype.toString, lMe = Jj(), Qj = Object.prototype.propertyIsEnumerable, uMe = !Qj.call({ toString: null }, "toString"), cMe = Qj.call(function() {
+        }, "prototype"), TE = ["toString", "toLocaleString", "valueOf", "hasOwnProperty", "isPrototypeOf", "propertyIsEnumerable", "constructor"], XR = function(e) {
+          var t = e.constructor;
+          return t && t.prototype === e;
+        }, fMe = { $applicationCache: true, $console: true, $external: true, $frame: true, $frameElement: true, $frames: true, $innerHeight: true, $innerWidth: true, $onmozfullscreenchange: true, $onmozfullscreenerror: true, $outerHeight: true, $outerWidth: true, $pageXOffset: true, $pageYOffset: true, $parent: true, $scrollLeft: true, $scrollTop: true, $scrollX: true, $scrollY: true, $self: true, $webkitIndexedDB: true, $webkitStorageInfo: true, $window: true }, hMe = function() {
+          if (typeof window == "undefined") return false;
+          for (var e in window) try {
+            if (!fMe["$" + e] && wE.call(window, e) && window[e] !== null && typeof window[e] == "object") try {
+              XR(window[e]);
+            } catch (t) {
+              return true;
+            }
+          } catch (t) {
+            return true;
+          }
+          return false;
+        }(), dMe = function(e) {
+          if (typeof window == "undefined" || !hMe) return XR(e);
+          try {
+            return XR(e);
+          } catch (t) {
+            return false;
+          }
+        }, vMe = function(t) {
+          var r = t !== null && typeof t == "object", n = $j.call(t) === "[object Function]", i = lMe(t), a = r && $j.call(t) === "[object String]", o = [];
+          if (!r && !n && !i) throw new TypeError("Object.keys called on a non-object");
+          var s = cMe && n;
+          if (a && t.length > 0 && !wE.call(t, 0)) for (var l = 0; l < t.length; ++l) o.push(String(l));
+          if (i && t.length > 0) for (var u = 0; u < t.length; ++u) o.push(String(u));
+          else for (var c in t) !(s && c === "prototype") && wE.call(t, c) && o.push(String(c));
+          if (uMe) for (var f = dMe(t), h = 0; h < TE.length; ++h) !(f && TE[h] === "constructor") && wE.call(t, TE[h]) && o.push(TE[h]);
+          return o;
+        });
+        var wE, $j, lMe, Qj, uMe, cMe, TE, XR, fMe, hMe, dMe;
+        pMe.exports = vMe;
+      });
+      var eW = ye((gdr, _Me) => {
+        var z4t = Array.prototype.slice, O4t = Jj(), mMe = Object.keys, ZR = mMe ? function(t) {
+          return mMe(t);
+        } : gMe(), yMe = Object.keys;
+        ZR.shim = function() {
+          if (Object.keys) {
+            var t = function() {
+              var r = Object.keys(arguments);
+              return r && r.length === arguments.length;
+            }(1, 2);
+            t || (Object.keys = function(n) {
+              return O4t(n) ? yMe(z4t.call(n)) : yMe(n);
+            });
+          } else Object.keys = ZR;
+          return Object.keys || ZR;
+        };
+        _Me.exports = ZR;
+      });
+      var SMe = ye((mdr, AMe) => {
+        var q4t = eW(), wMe = Y8()(), TMe = hA(), xMe = Object, B4t = TMe("Array.prototype.push"), bMe = TMe("Object.prototype.propertyIsEnumerable"), N4t = wMe ? Object.getOwnPropertySymbols : null;
+        AMe.exports = function(t, r) {
+          if (t == null) throw new TypeError("target must be an object");
+          var n = xMe(t);
+          if (arguments.length === 1) return n;
+          for (var i = 1; i < arguments.length; ++i) {
+            var a = xMe(arguments[i]), o = q4t(a), s = wMe && (Object.getOwnPropertySymbols || N4t);
+            if (s) for (var l = s(a), u = 0; u < l.length; ++u) {
+              var c = l[u];
+              bMe(a, c) && B4t(o, c);
+            }
+            for (var f = 0; f < o.length; ++f) {
+              var h = o[f];
+              if (bMe(a, h)) {
+                var d = a[h];
+                n[h] = d;
+              }
+            }
+          }
+          return n;
+        };
+      });
+      var EMe = ye((ydr, MMe) => {
+        var tW = SMe(), U4t = function() {
+          if (!Object.assign) return false;
+          for (var e = "abcdefghijklmnopqrst", t = e.split(""), r = {}, n = 0; n < t.length; ++n) r[t[n]] = t[n];
+          var i = Object.assign({}, r), a = "";
+          for (var o in i) a += o;
+          return e !== a;
+        }, V4t = function() {
+          if (!Object.assign || !Object.preventExtensions) return false;
+          var e = Object.preventExtensions({ 1: 2 });
+          try {
+            Object.assign(e, "xy");
+          } catch (t) {
+            return e[1] === "y";
+          }
+          return false;
+        };
+        MMe.exports = function() {
+          return !Object.assign || U4t() || V4t() ? tW : Object.assign;
+        };
+      });
+      var rW = ye((_dr, CMe) => {
+        var kMe = function(e) {
+          return e !== e;
+        };
+        CMe.exports = function(t, r) {
+          return t === 0 && r === 0 ? 1 / t === 1 / r : !!(t === r || kMe(t) && kMe(r));
+        };
+      });
+      var YR = ye((xdr, LMe) => {
+        var G4t = rW();
+        LMe.exports = function() {
+          return typeof Object.is == "function" ? Object.is : G4t;
+        };
+      });
+      var AE = ye((bdr, DMe) => {
+        var H4t = eW(), j4t = typeof Symbol == "function" && typeof Symbol("foo") == "symbol", W4t = Object.prototype.toString, X4t = Array.prototype.concat, PMe = Object.defineProperty, Z4t = function(e) {
+          return typeof e == "function" && W4t.call(e) === "[object Function]";
+        }, Y4t = qH()(), IMe = PMe && Y4t, K4t = function(e, t, r, n) {
+          if (t in e) {
+            if (n === true) {
+              if (e[t] === r) return;
+            } else if (!Z4t(n) || !n()) return;
+          }
+          IMe ? PMe(e, t, { configurable: true, enumerable: false, value: r, writable: true }) : e[t] = r;
+        }, RMe = function(e, t) {
+          var r = arguments.length > 2 ? arguments[2] : {}, n = H4t(t);
+          j4t && (n = X4t.call(n, Object.getOwnPropertySymbols(t)));
+          for (var i = 0; i < n.length; i += 1) K4t(e, n[i], t[n[i]], r[n[i]]);
+        };
+        RMe.supportsDescriptors = !!IMe;
+        DMe.exports = RMe;
+      });
+      var zMe = ye((wdr, FMe) => {
+        var J4t = YR(), $4t = AE();
+        FMe.exports = function() {
+          var t = J4t();
+          return $4t(Object, { is: t }, { is: function() {
+            return Object.is !== t;
+          } }), t;
+        };
+      });
+      var NMe = ye((Tdr, BMe) => {
+        var Q4t = AE(), eEt = tE(), tEt = rW(), OMe = YR(), rEt = zMe(), qMe = eEt(OMe(), Object);
+        Q4t(qMe, { getPolyfill: OMe, implementation: tEt, shim: rEt });
+        BMe.exports = qMe;
+      });
+      var iW = ye((Adr, UMe) => {
+        UMe.exports = function(t) {
+          return t !== t;
+        };
+      });
+      var nW = ye((Sdr, VMe) => {
+        var iEt = iW();
+        VMe.exports = function() {
+          return Number.isNaN && Number.isNaN(NaN) && !Number.isNaN("a") ? Number.isNaN : iEt;
+        };
+      });
+      var HMe = ye((Mdr, GMe) => {
+        var nEt = AE(), aEt = nW();
+        GMe.exports = function() {
+          var t = aEt();
+          return nEt(Number, { isNaN: t }, { isNaN: function() {
+            return Number.isNaN !== t;
+          } }), t;
+        };
+      });
+      var ZMe = ye((Edr, XMe) => {
+        var oEt = tE(), sEt = AE(), lEt = iW(), jMe = nW(), uEt = HMe(), WMe = oEt(jMe(), Number);
+        sEt(WMe, { getPolyfill: jMe, implementation: lEt, shim: uEt });
+        XMe.exports = WMe;
+      });
+      var v4e = ye((kdr, d4e) => {
+        function YMe(e, t) {
+          return dEt(e) || hEt(e, t) || fEt(e, t) || cEt();
+        }
+        function cEt() {
+          throw new TypeError(`Invalid attempt to destructure non-iterable instance.
+In order to be iterable, non-array objects must have a [Symbol.iterator]() method.`);
+        }
+        function fEt(e, t) {
+          if (e) {
+            if (typeof e == "string") return KMe(e, t);
+            var r = Object.prototype.toString.call(e).slice(8, -1);
+            if (r === "Object" && e.constructor && (r = e.constructor.name), r === "Map" || r === "Set") return Array.from(e);
+            if (r === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(r)) return KMe(e, t);
+          }
+        }
+        function KMe(e, t) {
+          (t == null || t > e.length) && (t = e.length);
+          for (var r = 0, n = new Array(t); r < t; r++) n[r] = e[r];
+          return n;
+        }
+        function hEt(e, t) {
+          var r = e == null ? null : typeof Symbol != "undefined" && e[Symbol.iterator] || e["@@iterator"];
+          if (r != null) {
+            var n, i, a, o, s = [], l = true, u = false;
+            try {
+              if (a = (r = r.call(e)).next, t === 0) ;
+              else for (; !(l = (n = a.call(r)).done) && (s.push(n.value), s.length !== t); l = true) ;
+            } catch (c) {
+              u = true, i = c;
+            } finally {
+              try {
+                if (!l && r.return != null && (o = r.return(), Object(o) !== o)) return;
+              } finally {
+                if (u) throw i;
+              }
+            }
+            return s;
+          }
+        }
+        function dEt(e) {
+          if (Array.isArray(e)) return e;
+        }
+        function Q0(e) {
+          "@babel/helpers - typeof";
+          return Q0 = typeof Symbol == "function" && typeof Symbol.iterator == "symbol" ? function(t) {
+            return typeof t;
+          } : function(t) {
+            return t && typeof Symbol == "function" && t.constructor === Symbol && t !== Symbol.prototype ? "symbol" : typeof t;
+          }, Q0(e);
+        }
+        var vEt = /a/g.flags !== void 0, rD = function(t) {
+          var r = [];
+          return t.forEach(function(n) {
+            return r.push(n);
+          }), r;
+        }, JMe = function(t) {
+          var r = [];
+          return t.forEach(function(n, i) {
+            return r.push([i, n]);
+          }), r;
+        }, l4e = Object.is ? Object.is : NMe(), eD = Object.getOwnPropertySymbols ? Object.getOwnPropertySymbols : function() {
+          return [];
+        }, aW = Number.isNaN ? Number.isNaN : ZMe();
+        function sW(e) {
+          return e.call.bind(e);
+        }
+        var ME = sW(Object.prototype.hasOwnProperty), tD = sW(Object.prototype.propertyIsEnumerable), $Me = sW(Object.prototype.toString), lp = bA().types, pEt = lp.isAnyArrayBuffer, gEt = lp.isArrayBufferView, QMe = lp.isDate, KR = lp.isMap, e4e = lp.isRegExp, JR = lp.isSet, mEt = lp.isNativeError, yEt = lp.isBoxedPrimitive, t4e = lp.isNumberObject, r4e = lp.isStringObject, i4e = lp.isBooleanObject, n4e = lp.isBigIntObject, _Et = lp.isSymbolObject, xEt = lp.isFloat32Array, bEt = lp.isFloat64Array;
+        function wEt(e) {
+          if (e.length === 0 || e.length > 10) return true;
+          for (var t = 0; t < e.length; t++) {
+            var r = e.charCodeAt(t);
+            if (r < 48 || r > 57) return true;
+          }
+          return e.length === 10 && e >= Math.pow(2, 32);
+        }
+        function $R(e) {
+          return Object.keys(e).filter(wEt).concat(eD(e).filter(Object.prototype.propertyIsEnumerable.bind(e)));
+        }
+        function u4e(e, t) {
+          if (e === t) return 0;
+          for (var r = e.length, n = t.length, i = 0, a = Math.min(r, n); i < a; ++i) if (e[i] !== t[i]) {
+            r = e[i], n = t[i];
+            break;
+          }
+          return r < n ? -1 : n < r ? 1 : 0;
+        }
+        var TEt = true, AEt = false, oW = 0, lW = 1, c4e = 2, f4e = 3;
+        function SEt(e, t) {
+          return vEt ? e.source === t.source && e.flags === t.flags : RegExp.prototype.toString.call(e) === RegExp.prototype.toString.call(t);
+        }
+        function MEt(e, t) {
+          if (e.byteLength !== t.byteLength) return false;
+          for (var r = 0; r < e.byteLength; r++) if (e[r] !== t[r]) return false;
+          return true;
+        }
+        function EEt(e, t) {
+          return e.byteLength !== t.byteLength ? false : u4e(new Uint8Array(e.buffer, e.byteOffset, e.byteLength), new Uint8Array(t.buffer, t.byteOffset, t.byteLength)) === 0;
+        }
+        function kEt(e, t) {
+          return e.byteLength === t.byteLength && u4e(new Uint8Array(e), new Uint8Array(t)) === 0;
+        }
+        function CEt(e, t) {
+          return t4e(e) ? t4e(t) && l4e(Number.prototype.valueOf.call(e), Number.prototype.valueOf.call(t)) : r4e(e) ? r4e(t) && String.prototype.valueOf.call(e) === String.prototype.valueOf.call(t) : i4e(e) ? i4e(t) && Boolean.prototype.valueOf.call(e) === Boolean.prototype.valueOf.call(t) : n4e(e) ? n4e(t) && BigInt.prototype.valueOf.call(e) === BigInt.prototype.valueOf.call(t) : _Et(t) && Symbol.prototype.valueOf.call(e) === Symbol.prototype.valueOf.call(t);
+        }
+        function eg(e, t, r, n) {
+          if (e === t) return e !== 0 ? true : r ? l4e(e, t) : true;
+          if (r) {
+            if (Q0(e) !== "object") return typeof e == "number" && aW(e) && aW(t);
+            if (Q0(t) !== "object" || e === null || t === null || Object.getPrototypeOf(e) !== Object.getPrototypeOf(t)) return false;
+          } else {
+            if (e === null || Q0(e) !== "object") return t === null || Q0(t) !== "object" ? e == t : false;
+            if (t === null || Q0(t) !== "object") return false;
+          }
+          var i = $Me(e), a = $Me(t);
+          if (i !== a) return false;
+          if (Array.isArray(e)) {
+            if (e.length !== t.length) return false;
+            var o = $R(e), s = $R(t);
+            return o.length !== s.length ? false : SE(e, t, r, n, lW, o);
+          }
+          if (i === "[object Object]" && (!KR(e) && KR(t) || !JR(e) && JR(t))) return false;
+          if (QMe(e)) {
+            if (!QMe(t) || Date.prototype.getTime.call(e) !== Date.prototype.getTime.call(t)) return false;
+          } else if (e4e(e)) {
+            if (!e4e(t) || !SEt(e, t)) return false;
+          } else if (mEt(e) || e instanceof Error) {
+            if (e.message !== t.message || e.name !== t.name) return false;
+          } else if (gEt(e)) {
+            if (!r && (xEt(e) || bEt(e))) {
+              if (!MEt(e, t)) return false;
+            } else if (!EEt(e, t)) return false;
+            var l = $R(e), u = $R(t);
+            return l.length !== u.length ? false : SE(e, t, r, n, oW, l);
+          } else {
+            if (JR(e)) return !JR(t) || e.size !== t.size ? false : SE(e, t, r, n, c4e);
+            if (KR(e)) return !KR(t) || e.size !== t.size ? false : SE(e, t, r, n, f4e);
+            if (pEt(e)) {
+              if (!kEt(e, t)) return false;
+            } else if (yEt(e) && !CEt(e, t)) return false;
+          }
+          return SE(e, t, r, n, oW);
+        }
+        function a4e(e, t) {
+          return t.filter(function(r) {
+            return tD(e, r);
+          });
+        }
+        function SE(e, t, r, n, i, a) {
+          if (arguments.length === 5) {
+            a = Object.keys(e);
+            var o = Object.keys(t);
+            if (a.length !== o.length) return false;
+          }
+          for (var s = 0; s < a.length; s++) if (!ME(t, a[s])) return false;
+          if (r && arguments.length === 5) {
+            var l = eD(e);
+            if (l.length !== 0) {
+              var u = 0;
+              for (s = 0; s < l.length; s++) {
+                var c = l[s];
+                if (tD(e, c)) {
+                  if (!tD(t, c)) return false;
+                  a.push(c), u++;
+                } else if (tD(t, c)) return false;
+              }
+              var f = eD(t);
+              if (l.length !== f.length && a4e(t, f).length !== u) return false;
+            } else {
+              var h = eD(t);
+              if (h.length !== 0 && a4e(t, h).length !== 0) return false;
+            }
+          }
+          if (a.length === 0 && (i === oW || i === lW && e.length === 0 || e.size === 0)) return true;
+          if (n === void 0) n = { val1: /* @__PURE__ */ new Map(), val2: /* @__PURE__ */ new Map(), position: 0 };
+          else {
+            var d = n.val1.get(e);
+            if (d !== void 0) {
+              var v = n.val2.get(t);
+              if (v !== void 0) return d === v;
+            }
+            n.position++;
+          }
+          n.val1.set(e, n.position), n.val2.set(t, n.position);
+          var _ = DEt(e, t, r, a, n, i);
+          return n.val1.delete(e), n.val2.delete(t), _;
+        }
+        function o4e(e, t, r, n) {
+          for (var i = rD(e), a = 0; a < i.length; a++) {
+            var o = i[a];
+            if (eg(t, o, r, n)) return e.delete(o), true;
+          }
+          return false;
+        }
+        function h4e(e) {
+          switch (Q0(e)) {
+            case "undefined":
+              return null;
+            case "object":
+              return;
+            case "symbol":
+              return false;
+            case "string":
+              e = +e;
+            case "number":
+              if (aW(e)) return false;
+          }
+          return true;
+        }
+        function LEt(e, t, r) {
+          var n = h4e(r);
+          return n != null ? n : t.has(n) && !e.has(n);
+        }
+        function PEt(e, t, r, n, i) {
+          var a = h4e(r);
+          if (a != null) return a;
+          var o = t.get(a);
+          return o === void 0 && !t.has(a) || !eg(n, o, false, i) ? false : !e.has(a) && eg(n, o, false, i);
+        }
+        function IEt(e, t, r, n) {
+          for (var i = null, a = rD(e), o = 0; o < a.length; o++) {
+            var s = a[o];
+            if (Q0(s) === "object" && s !== null) i === null && (i = /* @__PURE__ */ new Set()), i.add(s);
+            else if (!t.has(s)) {
+              if (r || !LEt(e, t, s)) return false;
+              i === null && (i = /* @__PURE__ */ new Set()), i.add(s);
+            }
+          }
+          if (i !== null) {
+            for (var l = rD(t), u = 0; u < l.length; u++) {
+              var c = l[u];
+              if (Q0(c) === "object" && c !== null) {
+                if (!o4e(i, c, r, n)) return false;
+              } else if (!r && !e.has(c) && !o4e(i, c, r, n)) return false;
+            }
+            return i.size === 0;
+          }
+          return true;
+        }
+        function s4e(e, t, r, n, i, a) {
+          for (var o = rD(e), s = 0; s < o.length; s++) {
+            var l = o[s];
+            if (eg(r, l, i, a) && eg(n, t.get(l), i, a)) return e.delete(l), true;
+          }
+          return false;
+        }
+        function REt(e, t, r, n) {
+          for (var i = null, a = JMe(e), o = 0; o < a.length; o++) {
+            var s = YMe(a[o], 2), l = s[0], u = s[1];
+            if (Q0(l) === "object" && l !== null) i === null && (i = /* @__PURE__ */ new Set()), i.add(l);
+            else {
+              var c = t.get(l);
+              if (c === void 0 && !t.has(l) || !eg(u, c, r, n)) {
+                if (r || !PEt(e, t, l, u, n)) return false;
+                i === null && (i = /* @__PURE__ */ new Set()), i.add(l);
+              }
+            }
+          }
+          if (i !== null) {
+            for (var f = JMe(t), h = 0; h < f.length; h++) {
+              var d = YMe(f[h], 2), v = d[0], _ = d[1];
+              if (Q0(v) === "object" && v !== null) {
+                if (!s4e(i, e, v, _, r, n)) return false;
+              } else if (!r && (!e.has(v) || !eg(e.get(v), _, false, n)) && !s4e(i, e, v, _, false, n)) return false;
+            }
+            return i.size === 0;
+          }
+          return true;
+        }
+        function DEt(e, t, r, n, i, a) {
+          var o = 0;
+          if (a === c4e) {
+            if (!IEt(e, t, r, i)) return false;
+          } else if (a === f4e) {
+            if (!REt(e, t, r, i)) return false;
+          } else if (a === lW) for (; o < e.length; o++) if (ME(e, o)) {
+            if (!ME(t, o) || !eg(e[o], t[o], r, i)) return false;
+          } else {
+            if (ME(t, o)) return false;
+            for (var s = Object.keys(e); o < s.length; o++) {
+              var l = s[o];
+              if (!ME(t, l) || !eg(e[l], t[l], r, i)) return false;
+            }
+            return s.length === Object.keys(t).length;
+          }
+          for (o = 0; o < n.length; o++) {
+            var u = n[o];
+            if (!eg(e[u], t[u], r, i)) return false;
+          }
+          return true;
+        }
+        function FEt(e, t) {
+          return eg(e, t, AEt);
+        }
+        function zEt(e, t) {
+          return eg(e, t, TEt);
+        }
+        d4e.exports = { isDeepEqual: FEt, isDeepStrictEqual: zEt };
+      });
+      var gE = ye((Cdr, I4e) => {
+        function Zg(e) {
+          "@babel/helpers - typeof";
+          return Zg = typeof Symbol == "function" && typeof Symbol.iterator == "symbol" ? function(t) {
+            return typeof t;
+          } : function(t) {
+            return t && typeof Symbol == "function" && t.constructor === Symbol && t !== Symbol.prototype ? "symbol" : typeof t;
+          }, Zg(e);
+        }
+        function OEt(e, t, r) {
+          return Object.defineProperty(e, "prototype", { writable: false }), e;
+        }
+        function NEt(e, t) {
+          if (!(e instanceof t)) throw new TypeError("Cannot call a class as a function");
+        }
+        var UEt = Xj(), EE = UEt.codes, g4e = EE.ERR_AMBIGUOUS_ARGUMENT, TA = EE.ERR_INVALID_ARG_TYPE, VEt = EE.ERR_INVALID_ARG_VALUE, GEt = EE.ERR_INVALID_RETURN_VALUE, Y_ = EE.ERR_MISSING_ARGS, K_ = aMe(), HEt = bA(), iD = HEt.inspect, x4e = bA().types, jEt = x4e.isPromise, nD = x4e.isRegExp, WEt = EMe()(), b4e = YR()(), aD = hA()("RegExp.prototype.test"), Z_, oD;
+        function kE() {
+          var e = v4e();
+          Z_ = e.isDeepEqual, oD = e.isDeepStrictEqual;
+        }
+        var m4e = false, Ef = I4e.exports = uW, sD = {};
+        function Yg(e) {
+          throw e.message instanceof Error ? e.message : new K_(e);
+        }
+        function w4e(e, t, r, n, i) {
+          var a = arguments.length, o;
+          if (a === 0) o = "Failed";
+          else if (a === 1) r = e, e = void 0;
+          else {
+            if (m4e === false) {
+              m4e = true;
+              var s = process.emitWarning ? process.emitWarning : console.warn.bind(console);
+              s("assert.fail() with more than one argument is deprecated. Please use assert.strictEqual() instead or only pass a message.", "DeprecationWarning", "DEP0094");
+            }
+            a === 2 && (n = "!=");
+          }
+          if (r instanceof Error) throw r;
+          var l = { actual: e, expected: t, operator: n === void 0 ? "fail" : n, stackStartFn: i || w4e };
+          r !== void 0 && (l.message = r);
+          var u = new K_(l);
+          throw o && (u.message = o, u.generatedMessage = true), u;
+        }
+        Ef.fail = w4e;
+        Ef.AssertionError = K_;
+        function T4e(e, t, r, n) {
+          if (!r) {
+            var i = false;
+            if (t === 0) i = true, n = "No value argument passed to `assert.ok()`";
+            else if (n instanceof Error) throw n;
+            var a = new K_({ actual: r, expected: true, message: n, operator: "==", stackStartFn: e });
+            throw a.generatedMessage = i, a;
+          }
+        }
+        function uW() {
+          for (var e = arguments.length, t = new Array(e), r = 0; r < e; r++) t[r] = arguments[r];
+          T4e.apply(void 0, [uW, t.length].concat(t));
+        }
+        Ef.ok = uW;
+        Ef.equal = function e(t, r, n) {
+          if (arguments.length < 2) throw new Y_("actual", "expected");
+          t != r && Yg({ actual: t, expected: r, message: n, operator: "==", stackStartFn: e });
+        };
+        Ef.notEqual = function e(t, r, n) {
+          if (arguments.length < 2) throw new Y_("actual", "expected");
+          t == r && Yg({ actual: t, expected: r, message: n, operator: "!=", stackStartFn: e });
+        };
+        Ef.deepEqual = function e(t, r, n) {
+          if (arguments.length < 2) throw new Y_("actual", "expected");
+          Z_ === void 0 && kE(), Z_(t, r) || Yg({ actual: t, expected: r, message: n, operator: "deepEqual", stackStartFn: e });
+        };
+        Ef.notDeepEqual = function e(t, r, n) {
+          if (arguments.length < 2) throw new Y_("actual", "expected");
+          Z_ === void 0 && kE(), Z_(t, r) && Yg({ actual: t, expected: r, message: n, operator: "notDeepEqual", stackStartFn: e });
+        };
+        Ef.deepStrictEqual = function e(t, r, n) {
+          if (arguments.length < 2) throw new Y_("actual", "expected");
+          Z_ === void 0 && kE(), oD(t, r) || Yg({ actual: t, expected: r, message: n, operator: "deepStrictEqual", stackStartFn: e });
+        };
+        Ef.notDeepStrictEqual = A4e;
+        function A4e(e, t, r) {
+          if (arguments.length < 2) throw new Y_("actual", "expected");
+          Z_ === void 0 && kE(), oD(e, t) && Yg({ actual: e, expected: t, message: r, operator: "notDeepStrictEqual", stackStartFn: A4e });
+        }
+        Ef.strictEqual = function e(t, r, n) {
+          if (arguments.length < 2) throw new Y_("actual", "expected");
+          b4e(t, r) || Yg({ actual: t, expected: r, message: n, operator: "strictEqual", stackStartFn: e });
+        };
+        Ef.notStrictEqual = function e(t, r, n) {
+          if (arguments.length < 2) throw new Y_("actual", "expected");
+          b4e(t, r) && Yg({ actual: t, expected: r, message: n, operator: "notStrictEqual", stackStartFn: e });
+        };
+        var y4e = OEt(function e(t, r, n) {
+          var i = this;
+          NEt(this, e), r.forEach(function(a) {
+            a in t && (n !== void 0 && typeof n[a] == "string" && nD(t[a]) && aD(t[a], n[a]) ? i[a] = n[a] : i[a] = t[a]);
+          });
+        });
+        function XEt(e, t, r, n, i, a) {
+          if (!(r in e) || !oD(e[r], t[r])) {
+            if (!n) {
+              var o = new y4e(e, i), s = new y4e(t, i, e), l = new K_({ actual: o, expected: s, operator: "deepStrictEqual", stackStartFn: a });
+              throw l.actual = e, l.expected = t, l.operator = a.name, l;
+            }
+            Yg({ actual: e, expected: t, message: n, operator: a.name, stackStartFn: a });
+          }
+        }
+        function S4e(e, t, r, n) {
+          if (typeof t != "function") {
+            if (nD(t)) return aD(t, e);
+            if (arguments.length === 2) throw new TA("expected", ["Function", "RegExp"], t);
+            if (Zg(e) !== "object" || e === null) {
+              var i = new K_({ actual: e, expected: t, message: r, operator: "deepStrictEqual", stackStartFn: n });
+              throw i.operator = n.name, i;
+            }
+            var a = Object.keys(t);
+            if (t instanceof Error) a.push("name", "message");
+            else if (a.length === 0) throw new VEt("error", t, "may not be an empty object");
+            return Z_ === void 0 && kE(), a.forEach(function(o) {
+              typeof e[o] == "string" && nD(t[o]) && aD(t[o], e[o]) || XEt(e, t, o, r, a, n);
+            }), true;
+          }
+          return t.prototype !== void 0 && e instanceof t ? true : Error.isPrototypeOf(t) ? false : t.call({}, e) === true;
+        }
+        function M4e(e) {
+          if (typeof e != "function") throw new TA("fn", "Function", e);
+          try {
+            e();
+          } catch (t) {
+            return t;
+          }
+          return sD;
+        }
+        function _4e(e) {
+          return jEt(e) || e !== null && Zg(e) === "object" && typeof e.then == "function" && typeof e.catch == "function";
+        }
+        function E4e(e) {
+          return Promise.resolve().then(function() {
+            var t;
+            if (typeof e == "function") {
+              if (t = e(), !_4e(t)) throw new GEt("instance of Promise", "promiseFn", t);
+            } else if (_4e(e)) t = e;
+            else throw new TA("promiseFn", ["Function", "Promise"], e);
+            return Promise.resolve().then(function() {
+              return t;
+            }).then(function() {
+              return sD;
+            }).catch(function(r) {
+              return r;
+            });
+          });
+        }
+        function k4e(e, t, r, n) {
+          if (typeof r == "string") {
+            if (arguments.length === 4) throw new TA("error", ["Object", "Error", "Function", "RegExp"], r);
+            if (Zg(t) === "object" && t !== null) {
+              if (t.message === r) throw new g4e("error/message", 'The error message "'.concat(t.message, '" is identical to the message.'));
+            } else if (t === r) throw new g4e("error/message", 'The error "'.concat(t, '" is identical to the message.'));
+            n = r, r = void 0;
+          } else if (r != null && Zg(r) !== "object" && typeof r != "function") throw new TA("error", ["Object", "Error", "Function", "RegExp"], r);
+          if (t === sD) {
+            var i = "";
+            r && r.name && (i += " (".concat(r.name, ")")), i += n ? ": ".concat(n) : ".";
+            var a = e.name === "rejects" ? "rejection" : "exception";
+            Yg({ actual: void 0, expected: r, operator: e.name, message: "Missing expected ".concat(a).concat(i), stackStartFn: e });
+          }
+          if (r && !S4e(t, r, n, e)) throw t;
+        }
+        function C4e(e, t, r, n) {
+          if (t !== sD) {
+            if (typeof r == "string" && (n = r, r = void 0), !r || S4e(t, r)) {
+              var i = n ? ": ".concat(n) : ".", a = e.name === "doesNotReject" ? "rejection" : "exception";
+              Yg({ actual: t, expected: r, operator: e.name, message: "Got unwanted ".concat(a).concat(i, `
+`) + 'Actual message: "'.concat(t && t.message, '"'), stackStartFn: e });
+            }
+            throw t;
+          }
+        }
+        Ef.throws = function e(t) {
+          for (var r = arguments.length, n = new Array(r > 1 ? r - 1 : 0), i = 1; i < r; i++) n[i - 1] = arguments[i];
+          k4e.apply(void 0, [e, M4e(t)].concat(n));
+        };
+        Ef.rejects = function e(t) {
+          for (var r = arguments.length, n = new Array(r > 1 ? r - 1 : 0), i = 1; i < r; i++) n[i - 1] = arguments[i];
+          return E4e(t).then(function(a) {
+            return k4e.apply(void 0, [e, a].concat(n));
+          });
+        };
+        Ef.doesNotThrow = function e(t) {
+          for (var r = arguments.length, n = new Array(r > 1 ? r - 1 : 0), i = 1; i < r; i++) n[i - 1] = arguments[i];
+          C4e.apply(void 0, [e, M4e(t)].concat(n));
+        };
+        Ef.doesNotReject = function e(t) {
+          for (var r = arguments.length, n = new Array(r > 1 ? r - 1 : 0), i = 1; i < r; i++) n[i - 1] = arguments[i];
+          return E4e(t).then(function(a) {
+            return C4e.apply(void 0, [e, a].concat(n));
+          });
+        };
+        Ef.ifError = function e(t) {
+          if (t != null) {
+            var r = "ifError got unwanted exception: ";
+            Zg(t) === "object" && typeof t.message == "string" ? t.message.length === 0 && t.constructor ? r += t.constructor.name : r += t.message : r += iD(t);
+            var n = new K_({ actual: t, expected: null, operator: "ifError", message: r, stackStartFn: e }), i = t.stack;
+            if (typeof i == "string") {
+              var a = i.split(`
+`);
+              a.shift();
+              for (var o = n.stack.split(`
+`), s = 0; s < a.length; s++) {
+                var l = o.indexOf(a[s]);
+                if (l !== -1) {
+                  o = o.slice(0, l);
+                  break;
+                }
+              }
+              n.stack = "".concat(o.join(`
+`), `
+`).concat(a.join(`
+`));
+            }
+            throw n;
+          }
+        };
+        function L4e(e, t, r, n, i) {
+          if (!nD(t)) throw new TA("regexp", "RegExp", t);
+          var a = i === "match";
+          if (typeof e != "string" || aD(t, e) !== a) {
+            if (r instanceof Error) throw r;
+            var o = !r;
+            r = r || (typeof e != "string" ? 'The "string" argument must be of type string. Received type ' + "".concat(Zg(e), " (").concat(iD(e), ")") : (a ? "The input did not match the regular expression " : "The input was expected to not match the regular expression ") + "".concat(iD(t), `. Input:
+
+`).concat(iD(e), `
+`));
+            var s = new K_({ actual: e, expected: t, message: r, operator: i, stackStartFn: n });
+            throw s.generatedMessage = o, s;
+          }
+        }
+        Ef.match = function e(t, r, n) {
+          L4e(t, r, n, e, "match");
+        };
+        Ef.doesNotMatch = function e(t, r, n) {
+          L4e(t, r, n, e, "doesNotMatch");
+        };
+        function P4e() {
+          for (var e = arguments.length, t = new Array(e), r = 0; r < e; r++) t[r] = arguments[r];
+          T4e.apply(void 0, [P4e, t.length].concat(t));
+        }
+        Ef.strict = WEt(P4e, Ef, { equal: Ef.strictEqual, deepEqual: Ef.deepStrictEqual, notEqual: Ef.notStrictEqual, notDeepEqual: Ef.notDeepStrictEqual });
+        Ef.strict.strict = Ef.strict;
+      });
+      var D4e = ye((Ldr, R4e) => {
+        var CE = 1e3, LE = CE * 60, PE = LE * 60, IE = PE * 24, ZEt = IE * 365.25;
+        R4e.exports = function(e, t) {
+          t = t || {};
+          var r = typeof e;
+          if (r === "string" && e.length > 0) return YEt(e);
+          if (r === "number" && isNaN(e) === false) return t.long ? JEt(e) : KEt(e);
+          throw new Error("val is not a non-empty string or a valid number. val=" + JSON.stringify(e));
+        };
+        function YEt(e) {
+          if (e = String(e), !(e.length > 100)) {
+            var t = /^((?:\d+)?\.?\d+) *(milliseconds?|msecs?|ms|seconds?|secs?|s|minutes?|mins?|m|hours?|hrs?|h|days?|d|years?|yrs?|y)?$/i.exec(e);
+            if (t) {
+              var r = parseFloat(t[1]), n = (t[2] || "ms").toLowerCase();
+              switch (n) {
+                case "years":
+                case "year":
+                case "yrs":
+                case "yr":
+                case "y":
+                  return r * ZEt;
+                case "days":
+                case "day":
+                case "d":
+                  return r * IE;
+                case "hours":
+                case "hour":
+                case "hrs":
+                case "hr":
+                case "h":
+                  return r * PE;
+                case "minutes":
+                case "minute":
+                case "mins":
+                case "min":
+                case "m":
+                  return r * LE;
+                case "seconds":
+                case "second":
+                case "secs":
+                case "sec":
+                case "s":
+                  return r * CE;
+                case "milliseconds":
+                case "millisecond":
+                case "msecs":
+                case "msec":
+                case "ms":
+                  return r;
+                default:
+                  return;
+              }
+            }
+          }
+        }
+        function KEt(e) {
+          return e >= IE ? Math.round(e / IE) + "d" : e >= PE ? Math.round(e / PE) + "h" : e >= LE ? Math.round(e / LE) + "m" : e >= CE ? Math.round(e / CE) + "s" : e + "ms";
+        }
+        function JEt(e) {
+          return lD(e, IE, "day") || lD(e, PE, "hour") || lD(e, LE, "minute") || lD(e, CE, "second") || e + " ms";
+        }
+        function lD(e, t, r) {
+          if (!(e < t)) return e < t * 1.5 ? Math.floor(e / t) + " " + r : Math.ceil(e / t) + " " + r + "s";
+        }
+      });
+      var z4e = ye((Lc, F4e) => {
+        Lc = F4e.exports = fW.debug = fW.default = fW;
+        Lc.coerce = rkt;
+        Lc.disable = ekt;
+        Lc.enable = QEt;
+        Lc.enabled = tkt;
+        Lc.humanize = D4e();
+        Lc.names = [];
+        Lc.skips = [];
+        Lc.formatters = {};
+        var cW;
+        function $Et(e) {
+          var t = 0, r;
+          for (r in e) t = (t << 5) - t + e.charCodeAt(r), t |= 0;
+          return Lc.colors[Math.abs(t) % Lc.colors.length];
+        }
+        function fW(e) {
+          function t() {
+            if (t.enabled) {
+              var r = t, n = +/* @__PURE__ */ new Date(), i = n - (cW || n);
+              r.diff = i, r.prev = cW, r.curr = n, cW = n;
+              for (var a = new Array(arguments.length), o = 0; o < a.length; o++) a[o] = arguments[o];
+              a[0] = Lc.coerce(a[0]), typeof a[0] != "string" && a.unshift("%O");
+              var s = 0;
+              a[0] = a[0].replace(/%([a-zA-Z%])/g, function(u, c) {
+                if (u === "%%") return u;
+                s++;
+                var f = Lc.formatters[c];
+                if (typeof f == "function") {
+                  var h = a[s];
+                  u = f.call(r, h), a.splice(s, 1), s--;
+                }
+                return u;
+              }), Lc.formatArgs.call(r, a);
+              var l = t.log || Lc.log || console.log.bind(console);
+              l.apply(r, a);
+            }
+          }
+          return t.namespace = e, t.enabled = Lc.enabled(e), t.useColors = Lc.useColors(), t.color = $Et(e), typeof Lc.init == "function" && Lc.init(t), t;
+        }
+        function QEt(e) {
+          Lc.save(e), Lc.names = [], Lc.skips = [];
+          for (var t = (typeof e == "string" ? e : "").split(/[\s,]+/), r = t.length, n = 0; n < r; n++) t[n] && (e = t[n].replace(/\*/g, ".*?"), e[0] === "-" ? Lc.skips.push(new RegExp("^" + e.substr(1) + "$")) : Lc.names.push(new RegExp("^" + e + "$")));
+        }
+        function ekt() {
+          Lc.enable("");
+        }
+        function tkt(e) {
+          var t, r;
+          for (t = 0, r = Lc.skips.length; t < r; t++) if (Lc.skips[t].test(e)) return false;
+          for (t = 0, r = Lc.names.length; t < r; t++) if (Lc.names[t].test(e)) return true;
+          return false;
+        }
+        function rkt(e) {
+          return e instanceof Error ? e.stack || e.message : e;
+        }
+      });
+      var B4e = ye((up, q4e) => {
+        up = q4e.exports = z4e();
+        up.log = akt;
+        up.formatArgs = nkt;
+        up.save = okt;
+        up.load = O4e;
+        up.useColors = ikt;
+        up.storage = typeof chrome != "undefined" && typeof chrome.storage != "undefined" ? chrome.storage.local : skt();
+        up.colors = ["lightseagreen", "forestgreen", "goldenrod", "dodgerblue", "darkorchid", "crimson"];
+        function ikt() {
+          return typeof window != "undefined" && window.process && window.process.type === "renderer" ? true : typeof document != "undefined" && document.documentElement && document.documentElement.style && document.documentElement.style.WebkitAppearance || typeof window != "undefined" && window.console && (window.console.firebug || window.console.exception && window.console.table) || typeof navigator != "undefined" && navigator.userAgent && navigator.userAgent.toLowerCase().match(/firefox\/(\d+)/) && parseInt(RegExp.$1, 10) >= 31 || typeof navigator != "undefined" && navigator.userAgent && navigator.userAgent.toLowerCase().match(/applewebkit\/(\d+)/);
+        }
+        up.formatters.j = function(e) {
+          try {
+            return JSON.stringify(e);
+          } catch (t) {
+            return "[UnexpectedJSONParseError]: " + t.message;
+          }
+        };
+        function nkt(e) {
+          var t = this.useColors;
+          if (e[0] = (t ? "%c" : "") + this.namespace + (t ? " %c" : " ") + e[0] + (t ? "%c " : " ") + "+" + up.humanize(this.diff), !!t) {
+            var r = "color: " + this.color;
+            e.splice(1, 0, r, "color: inherit");
+            var n = 0, i = 0;
+            e[0].replace(/%[a-zA-Z%]/g, function(a) {
+              a !== "%%" && (n++, a === "%c" && (i = n));
+            }), e.splice(i, 0, r);
+          }
+        }
+        function akt() {
+          return typeof console == "object" && console.log && Function.prototype.apply.call(console.log, console, arguments);
+        }
+        function okt(e) {
+          try {
+            e == null ? up.storage.removeItem("debug") : up.storage.debug = e;
+          } catch (t) {
+          }
+        }
+        function O4e() {
+          var e;
+          try {
+            e = up.storage.debug;
+          } catch (t) {
+          }
+          return !e && typeof process != "undefined" && "env" in process && (e = define_process_env_default.DEBUG), e;
+        }
+        up.enable(O4e());
+        function skt() {
+          try {
+            return window.localStorage;
+          } catch (e) {
+          }
+        }
+      });
+      var X4e = ye((Pdr, W4e) => {
+        var AA = gE(), J_ = B4e()("stream-parser");
+        W4e.exports = ukt;
+        var U4e = -1, uD = 0, lkt = 1, V4e = 2;
+        function ukt(e) {
+          var t = e && typeof e._transform == "function", r = e && typeof e._write == "function";
+          if (!t && !r) throw new Error("must pass a Writable or Transform stream in");
+          J_("extending Parser into stream"), e._bytes = ckt, e._skipBytes = fkt, t && (e._passthrough = hkt), t ? e._transform = vkt : e._write = dkt;
+        }
+        function RE(e) {
+          J_("initializing parser stream"), e._parserBytesLeft = 0, e._parserBuffers = [], e._parserBuffered = 0, e._parserState = U4e, e._parserCallback = null, typeof e.push == "function" && (e._parserOutput = e.push.bind(e)), e._parserInit = true;
+        }
+        function ckt(e, t) {
+          AA(!this._parserCallback, 'there is already a "callback" set!'), AA(isFinite(e) && e > 0, 'can only buffer a finite number of bytes > 0, got "' + e + '"'), this._parserInit || RE(this), J_("buffering %o bytes", e), this._parserBytesLeft = e, this._parserCallback = t, this._parserState = uD;
+        }
+        function fkt(e, t) {
+          AA(!this._parserCallback, 'there is already a "callback" set!'), AA(e > 0, 'can only skip > 0 bytes, got "' + e + '"'), this._parserInit || RE(this), J_("skipping %o bytes", e), this._parserBytesLeft = e, this._parserCallback = t, this._parserState = lkt;
+        }
+        function hkt(e, t) {
+          AA(!this._parserCallback, 'There is already a "callback" set!'), AA(e > 0, 'can only pass through > 0 bytes, got "' + e + '"'), this._parserInit || RE(this), J_("passing through %o bytes", e), this._parserBytesLeft = e, this._parserCallback = t, this._parserState = V4e;
+        }
+        function dkt(e, t, r) {
+          this._parserInit || RE(this), J_("write(%o bytes)", e.length), typeof t == "function" && (r = t), H4e(this, e, null, r);
+        }
+        function vkt(e, t, r) {
+          this._parserInit || RE(this), J_("transform(%o bytes)", e.length), typeof t != "function" && (t = this._parserOutput), H4e(this, e, t, r);
+        }
+        function G4e(e, t, r, n) {
+          return e._parserBytesLeft <= 0 ? n(new Error("got data but not currently parsing anything")) : t.length <= e._parserBytesLeft ? function() {
+            return N4e(e, t, r, n);
+          } : function() {
+            var i = t.slice(0, e._parserBytesLeft);
+            return N4e(e, i, r, function(a) {
+              if (a) return n(a);
+              if (t.length > i.length) return function() {
+                return G4e(e, t.slice(i.length), r, n);
+              };
+            });
+          };
+        }
+        function N4e(e, t, r, n) {
+          if (e._parserBytesLeft -= t.length, J_("%o bytes left for stream piece", e._parserBytesLeft), e._parserState === uD ? (e._parserBuffers.push(t), e._parserBuffered += t.length) : e._parserState === V4e && r(t), e._parserBytesLeft === 0) {
+            var i = e._parserCallback;
+            if (i && e._parserState === uD && e._parserBuffers.length > 1 && (t = Buffer.concat(e._parserBuffers, e._parserBuffered)), e._parserState !== uD && (t = null), e._parserCallback = null, e._parserBuffered = 0, e._parserState = U4e, e._parserBuffers.splice(0), i) {
+              var a = [];
+              t && a.push(t), r && a.push(r);
+              var o = i.length > a.length;
+              o && a.push(j4e(n));
+              var s = i.apply(e, a);
+              if (!o || n === s) return n;
+            }
+          } else return n;
+        }
+        var H4e = j4e(G4e);
+        function j4e(e) {
+          return function() {
+            for (var t = e.apply(this, arguments); typeof t == "function"; ) t = t();
+            return t;
+          };
+        }
+      });
+      var rc = ye((Jy) => {
+        var Z4e = NSe().Transform, pkt = X4e();
+        function DE() {
+          Z4e.call(this, { readableObjectMode: true });
+        }
+        DE.prototype = Object.create(Z4e.prototype);
+        DE.prototype.constructor = DE;
+        pkt(DE.prototype);
+        Jy.ParserStream = DE;
+        Jy.sliceEq = function(e, t, r) {
+          for (var n = t, i = 0; i < r.length; ) if (e[n++] !== r[i++]) return false;
+          return true;
+        };
+        Jy.str2arr = function(e, t) {
+          var r = [], n = 0;
+          if (t && t === "hex") for (; n < e.length; ) r.push(parseInt(e.slice(n, n + 2), 16)), n += 2;
+          else for (; n < e.length; n++) r.push(e.charCodeAt(n) & 255);
+          return r;
+        };
+        Jy.readUInt16LE = function(e, t) {
+          return e[t] | e[t + 1] << 8;
+        };
+        Jy.readUInt16BE = function(e, t) {
+          return e[t + 1] | e[t] << 8;
+        };
+        Jy.readUInt32LE = function(e, t) {
+          return e[t] | e[t + 1] << 8 | e[t + 2] << 16 | e[t + 3] * 16777216;
+        };
+        Jy.readUInt32BE = function(e, t) {
+          return e[t + 3] | e[t + 2] << 8 | e[t + 1] << 16 | e[t] * 16777216;
+        };
+        function cD(e, t, r) {
+          Error.call(this), Error.captureStackTrace ? Error.captureStackTrace(this, this.constructor) : this.stack = new Error().stack || "", this.name = this.constructor.name, this.message = e, t && (this.code = t), r && (this.statusCode = r);
+        }
+        cD.prototype = Object.create(Error.prototype);
+        cD.prototype.constructor = cD;
+        Jy.ProbeError = cD;
+      });
+      var Y4e = ye((Rdr, fD) => {
+        var SA = rc().readUInt16BE, dW = rc().readUInt32BE;
+        function FE(e, t) {
+          if (e.length < 4 + t) return null;
+          var r = dW(e, t);
+          return e.length < r + t || r < 8 ? null : { boxtype: String.fromCharCode.apply(null, e.slice(t + 4, t + 8)), data: e.slice(t + 8, t + r), end: t + r };
+        }
+        fD.exports.unbox = FE;
+        function gkt(e, t) {
+          for (var r = 0; ; ) {
+            var n = FE(e, r);
+            if (!n) break;
+            switch (n.boxtype) {
+              case "ispe":
+                t.sizes.push({ width: dW(n.data, 4), height: dW(n.data, 8) });
+                break;
+              case "irot":
+                t.transforms.push({ type: "irot", value: n.data[0] & 3 });
+                break;
+              case "imir":
+                t.transforms.push({ type: "imir", value: n.data[0] & 1 });
+                break;
+            }
+            r = n.end;
+          }
+        }
+        function hW(e, t, r) {
+          for (var n = 0, i = 0; i < r; i++) n = n * 256 + (e[t + i] || 0);
+          return n;
+        }
+        function mkt(e, t) {
+          for (var r = e[4] >> 4 & 15, n = e[4] & 15, i = e[5] >> 4 & 15, a = SA(e, 6), o = 8, s = 0; s < a; s++) {
+            var l = SA(e, o);
+            o += 2;
+            var u = SA(e, o);
+            o += 2;
+            var c = hW(e, o, i);
+            o += i;
+            var f = SA(e, o);
+            if (o += 2, u === 0 && f === 1) {
+              var h = hW(e, o, r), d = hW(e, o + r, n);
+              t.item_loc[l] = { length: d, offset: h + c };
+            }
+            o += f * (r + n);
+          }
+        }
+        function ykt(e, t) {
+          for (var r = SA(e, 4), n = 6, i = 0; i < r; i++) {
+            var a = FE(e, n);
+            if (!a) break;
+            if (a.boxtype === "infe") {
+              for (var o = SA(a.data, 4), s = "", l = 8; l < a.data.length && a.data[l]; l++) s += String.fromCharCode(a.data[l]);
+              t.item_inf[s] = o;
+            }
+            n = a.end;
+          }
+        }
+        function _kt(e, t) {
+          for (var r = 0; ; ) {
+            var n = FE(e, r);
+            if (!n) break;
+            n.boxtype === "ipco" && gkt(n.data, t), r = n.end;
+          }
+        }
+        function xkt(e, t) {
+          for (var r = 4; ; ) {
+            var n = FE(e, r);
+            if (!n) break;
+            n.boxtype === "iprp" && _kt(n.data, t), n.boxtype === "iloc" && mkt(n.data, t), n.boxtype === "iinf" && ykt(n.data, t), r = n.end;
+          }
+        }
+        function bkt(e) {
+          var t = e.reduce(function(i, a) {
+            return i.width > a.width || i.width === a.width && i.height > a.height ? i : a;
+          }), r = e.reduce(function(i, a) {
+            return i.height > a.height || i.height === a.height && i.width > a.width ? i : a;
+          }), n;
+          return t.width > r.height || t.width === r.height && t.height > r.width ? n = t : n = r, n;
+        }
+        fD.exports.readSizeFromMeta = function(e) {
+          var t = { sizes: [], transforms: [], item_inf: {}, item_loc: {} };
+          if (xkt(e, t), !!t.sizes.length) {
+            var r = bkt(t.sizes), n = 1;
+            t.transforms.forEach(function(a) {
+              var o = { 1: 6, 2: 5, 3: 8, 4: 7, 5: 4, 6: 3, 7: 2, 8: 1 }, s = { 1: 4, 2: 3, 3: 2, 4: 1, 5: 6, 6: 5, 7: 8, 8: 7 };
+              if (a.type === "imir" && (a.value === 0 ? n = s[n] : (n = s[n], n = o[n], n = o[n])), a.type === "irot") for (var l = 0; l < a.value; l++) n = o[n];
+            });
+            var i = null;
+            return t.item_inf.Exif && (i = t.item_loc[t.item_inf.Exif]), { width: r.width, height: r.height, orientation: t.transforms.length ? n : null, variants: t.sizes, exif_location: i };
+          }
+        };
+        fD.exports.getMimeType = function(e) {
+          var t = String.fromCharCode.apply(null, e.slice(0, 4)), r = {};
+          r[t] = true;
+          for (var n = 8; n < e.length; n += 4) r[String.fromCharCode.apply(null, e.slice(n, n + 4))] = true;
+          if (!(!r.mif1 && !r.msf1 && !r.miaf)) return t === "avif" || t === "avis" || t === "avio" ? { type: "avif", mime: "image/avif" } : t === "heic" || t === "heix" ? { type: "heic", mime: "image/heic" } : t === "hevc" || t === "hevx" ? { type: "heic", mime: "image/heic-sequence" } : r.avif || r.avis ? { type: "avif", mime: "image/avif" } : r.heic || r.heix || r.hevc || r.hevx || r.heis ? r.msf1 ? { type: "heif", mime: "image/heif-sequence" } : { type: "heif", mime: "image/heif" } : { type: "avif", mime: "image/avif" };
+        };
+      });
+      var dD = ye((Ddr, vW) => {
+        function hD(e, t) {
+          var r = new Error(e);
+          return r.code = t, r;
+        }
+        function wkt(e) {
+          try {
+            return decodeURIComponent(escape(e));
+          } catch (t) {
+            return e;
+          }
+        }
+        function $y(e, t, r) {
+          this.input = e.subarray(t, r), this.start = t;
+          var n = String.fromCharCode.apply(null, this.input.subarray(0, 4));
+          if (n !== "II*\0" && n !== "MM\0*") throw hD("invalid TIFF signature", "EBADDATA");
+          this.big_endian = n[0] === "M";
+        }
+        $y.prototype.each = function(e) {
+          this.aborted = false;
+          var t = this.read_uint32(4);
+          for (this.ifds_to_read = [{ id: 0, offset: t }]; this.ifds_to_read.length > 0 && !this.aborted; ) {
+            var r = this.ifds_to_read.shift();
+            r.offset && this.scan_ifd(r.id, r.offset, e);
+          }
+        };
+        $y.prototype.read_uint16 = function(e) {
+          var t = this.input;
+          if (e + 2 > t.length) throw hD("unexpected EOF", "EBADDATA");
+          return this.big_endian ? t[e] * 256 + t[e + 1] : t[e] + t[e + 1] * 256;
+        };
+        $y.prototype.read_uint32 = function(e) {
+          var t = this.input;
+          if (e + 4 > t.length) throw hD("unexpected EOF", "EBADDATA");
+          return this.big_endian ? t[e] * 16777216 + t[e + 1] * 65536 + t[e + 2] * 256 + t[e + 3] : t[e] + t[e + 1] * 256 + t[e + 2] * 65536 + t[e + 3] * 16777216;
+        };
+        $y.prototype.is_subifd_link = function(e, t) {
+          return e === 0 && t === 34665 || e === 0 && t === 34853 || e === 34665 && t === 40965;
+        };
+        $y.prototype.exif_format_length = function(e) {
+          switch (e) {
+            case 1:
+            case 2:
+            case 6:
+            case 7:
+              return 1;
+            case 3:
+            case 8:
+              return 2;
+            case 4:
+            case 9:
+            case 11:
+              return 4;
+            case 5:
+            case 10:
+            case 12:
+              return 8;
+            default:
+              return 0;
+          }
+        };
+        $y.prototype.exif_format_read = function(e, t) {
+          var r;
+          switch (e) {
+            case 1:
+            case 2:
+              return r = this.input[t], r;
+            case 6:
+              return r = this.input[t], r | (r & 128) * 33554430;
+            case 3:
+              return r = this.read_uint16(t), r;
+            case 8:
+              return r = this.read_uint16(t), r | (r & 32768) * 131070;
+            case 4:
+              return r = this.read_uint32(t), r;
+            case 9:
+              return r = this.read_uint32(t), r | 0;
+            case 5:
+            case 10:
+            case 11:
+            case 12:
+              return null;
+            case 7:
+              return null;
+            default:
+              return null;
+          }
+        };
+        $y.prototype.scan_ifd = function(e, t, r) {
+          var n = this.read_uint16(t);
+          t += 2;
+          for (var i = 0; i < n; i++) {
+            var a = this.read_uint16(t), o = this.read_uint16(t + 2), s = this.read_uint32(t + 4), l = this.exif_format_length(o), u = s * l, c = u <= 4 ? t + 8 : this.read_uint32(t + 8), f = false;
+            if (c + u > this.input.length) throw hD("unexpected EOF", "EBADDATA");
+            for (var h = [], d = c, v = 0; v < s; v++, d += l) {
+              var _ = this.exif_format_read(o, d);
+              if (_ === null) {
+                h = null;
+                break;
+              }
+              h.push(_);
+            }
+            Array.isArray(h) && o === 2 && (h = wkt(String.fromCharCode.apply(null, h)), h && h[h.length - 1] === "\0" && (h = h.slice(0, -1))), this.is_subifd_link(e, a) && Array.isArray(h) && Number.isInteger(h[0]) && h[0] > 0 && (this.ifds_to_read.push({ id: a, offset: h[0] }), f = true);
+            var b = { is_big_endian: this.big_endian, ifd: e, tag: a, format: o, count: s, entry_offset: t + this.start, data_length: u, data_offset: c + this.start, value: h, is_subifd_link: f };
+            if (r(b) === false) {
+              this.aborted = true;
+              return;
+            }
+            t += 12;
+          }
+          e === 0 && this.ifds_to_read.push({ id: 1, offset: this.read_uint32(t) });
+        };
+        vW.exports.ExifParser = $y;
+        vW.exports.get_orientation = function(e) {
+          var t = 0;
+          try {
+            return new $y(e, 0, e.length).each(function(r) {
+              if (r.ifd === 0 && r.tag === 274 && Array.isArray(r.value)) return t = r.value[0], false;
+            }), t;
+          } catch (r) {
+            return -1;
+          }
+        };
+      });
+      var J4e = ye((Fdr, K4e) => {
+        var Tkt = rc().str2arr, Akt = rc().sliceEq, Skt = rc().readUInt32BE, vD = Y4e(), Mkt = dD(), Ekt = Tkt("ftyp");
+        K4e.exports = function(e) {
+          if (Akt(e, 4, Ekt)) {
+            var t = vD.unbox(e, 0);
+            if (t) {
+              var r = vD.getMimeType(t.data);
+              if (r) {
+                for (var n, i = t.end; ; ) {
+                  var a = vD.unbox(e, i);
+                  if (!a) break;
+                  if (i = a.end, a.boxtype === "mdat") return;
+                  if (a.boxtype === "meta") {
+                    n = a.data;
+                    break;
+                  }
+                }
+                if (n) {
+                  var o = vD.readSizeFromMeta(n);
+                  if (o) {
+                    var s = { width: o.width, height: o.height, type: r.type, mime: r.mime, wUnits: "px", hUnits: "px" };
+                    if (o.variants.length > 1 && (s.variants = o.variants), o.orientation && (s.orientation = o.orientation), o.exif_location && o.exif_location.offset + o.exif_location.length <= e.length) {
+                      var l = Skt(e, o.exif_location.offset), u = e.slice(o.exif_location.offset + l + 4, o.exif_location.offset + o.exif_location.length), c = Mkt.get_orientation(u);
+                      c > 0 && (s.orientation = c);
+                    }
+                    return s;
+                  }
+                }
+              }
+            }
+          }
+        };
+      });
+      var eEe = ye((zdr, Q4e) => {
+        var kkt = rc().str2arr, Ckt = rc().sliceEq, $4e = rc().readUInt16LE, Lkt = kkt("BM");
+        Q4e.exports = function(e) {
+          if (!(e.length < 26) && Ckt(e, 0, Lkt)) return { width: $4e(e, 18), height: $4e(e, 22), type: "bmp", mime: "image/bmp", wUnits: "px", hUnits: "px" };
+        };
+      });
+      var aEe = ye((Odr, nEe) => {
+        var iEe = rc().str2arr, tEe = rc().sliceEq, rEe = rc().readUInt16LE, Pkt = iEe("GIF87a"), Ikt = iEe("GIF89a");
+        nEe.exports = function(e) {
+          if (!(e.length < 10) && !(!tEe(e, 0, Pkt) && !tEe(e, 0, Ikt))) return { width: rEe(e, 6), height: rEe(e, 8), type: "gif", mime: "image/gif", wUnits: "px", hUnits: "px" };
+        };
+      });
+      var lEe = ye((qdr, sEe) => {
+        var pW = rc().readUInt16LE, Rkt = 0, Dkt = 1, oEe = 16;
+        sEe.exports = function(e) {
+          var t = pW(e, 0), r = pW(e, 2), n = pW(e, 4);
+          if (!(t !== Rkt || r !== Dkt || !n)) {
+            for (var i = [], a = { width: 0, height: 0 }, o = 0; o < n; o++) {
+              var s = e[6 + oEe * o] || 256, l = e[6 + oEe * o + 1] || 256, u = { width: s, height: l };
+              i.push(u), (s > a.width || l > a.height) && (a = u);
+            }
+            return { width: a.width, height: a.height, variants: i, type: "ico", mime: "image/x-icon", wUnits: "px", hUnits: "px" };
+          }
+        };
+      });
+      var cEe = ye((Bdr, uEe) => {
+        var gW = rc().readUInt16BE, Fkt = rc().str2arr, zkt = rc().sliceEq, Okt = dD(), qkt = Fkt("Exif\0\0");
+        uEe.exports = function(e) {
+          if (!(e.length < 2) && !(e[0] !== 255 || e[1] !== 216 || e[2] !== 255)) for (var t = 2; ; ) {
+            for (; ; ) {
+              if (e.length - t < 2) return;
+              if (e[t++] === 255) break;
+            }
+            for (var r = e[t++], n; r === 255; ) r = e[t++];
+            if (208 <= r && r <= 217 || r === 1) n = 0;
+            else if (192 <= r && r <= 254) {
+              if (e.length - t < 2) return;
+              n = gW(e, t) - 2, t += 2;
+            } else return;
+            if (r === 217 || r === 218) return;
+            var i;
+            if (r === 225 && n >= 10 && zkt(e, t, qkt) && (i = Okt.get_orientation(e.slice(t + 6, t + n))), n >= 5 && 192 <= r && r <= 207 && r !== 196 && r !== 200 && r !== 204) {
+              if (e.length - t < n) return;
+              var a = { width: gW(e, t + 3), height: gW(e, t + 1), type: "jpg", mime: "image/jpeg", wUnits: "px", hUnits: "px" };
+              return i > 0 && (a.orientation = i), a;
+            }
+            t += n;
+          }
+        };
+      });
+      var pEe = ye((Ndr, vEe) => {
+        var dEe = rc().str2arr, fEe = rc().sliceEq, hEe = rc().readUInt32BE, Bkt = dEe(`‰PNG\r
+
+`), Nkt = dEe("IHDR");
+        vEe.exports = function(e) {
+          if (!(e.length < 24) && fEe(e, 0, Bkt) && fEe(e, 12, Nkt)) return { width: hEe(e, 16), height: hEe(e, 20), type: "png", mime: "image/png", wUnits: "px", hUnits: "px" };
+        };
+      });
+      var yEe = ye((Udr, mEe) => {
+        var Ukt = rc().str2arr, Vkt = rc().sliceEq, gEe = rc().readUInt32BE, Gkt = Ukt("8BPS\0
");
+        mEe.exports = function(e) {
+          if (!(e.length < 22) && Vkt(e, 0, Gkt)) return { width: gEe(e, 18), height: gEe(e, 14), type: "psd", mime: "image/vnd.adobe.photoshop", wUnits: "px", hUnits: "px" };
+        };
+      });
+      var bEe = ye((Vdr, xEe) => {
+        function Hkt(e) {
+          return e === 32 || e === 9 || e === 13 || e === 10;
+        }
+        function MA(e) {
+          return typeof e == "number" && isFinite(e) && e > 0;
+        }
+        function jkt(e) {
+          var t = 0, r = e.length;
+          for (e[0] === 239 && e[1] === 187 && e[2] === 191 && (t = 3); t < r && Hkt(e[t]); ) t++;
+          return t === r ? false : e[t] === 60;
+        }
+        var Wkt = /<[-_.:a-zA-Z0-9][^>]*>/, Xkt = /^<([-_.:a-zA-Z0-9]+:)?svg\s/, Zkt = /[^-]\bwidth="([^%]+?)"|[^-]\bwidth='([^%]+?)'/, Ykt = /\bheight="([^%]+?)"|\bheight='([^%]+?)'/, Kkt = /\bview[bB]ox="(.+?)"|\bview[bB]ox='(.+?)'/, _Ee = /in$|mm$|cm$|pt$|pc$|px$|em$|ex$/;
+        function Jkt(e) {
+          var t = e.match(Zkt), r = e.match(Ykt), n = e.match(Kkt);
+          return { width: t && (t[1] || t[2]), height: r && (r[1] || r[2]), viewbox: n && (n[1] || n[2]) };
+        }
+        function Xm(e) {
+          return _Ee.test(e) ? e.match(_Ee)[0] : "px";
+        }
+        xEe.exports = function(e) {
+          if (jkt(e)) {
+            for (var t = "", r = 0; r < e.length; r++) t += String.fromCharCode(e[r]);
+            var n = (t.match(Wkt) || [""])[0];
+            if (Xkt.test(n)) {
+              var i = Jkt(n), a = parseFloat(i.width), o = parseFloat(i.height);
+              if (i.width && i.height) return !MA(a) || !MA(o) ? void 0 : { width: a, height: o, type: "svg", mime: "image/svg+xml", wUnits: Xm(i.width), hUnits: Xm(i.height) };
+              var s = (i.viewbox || "").split(" "), l = { width: s[2], height: s[3] }, u = parseFloat(l.width), c = parseFloat(l.height);
+              if (!(!MA(u) || !MA(c)) && Xm(l.width) === Xm(l.height)) {
+                var f = u / c;
+                return i.width ? MA(a) ? { width: a, height: a / f, type: "svg", mime: "image/svg+xml", wUnits: Xm(i.width), hUnits: Xm(i.width) } : void 0 : i.height ? MA(o) ? { width: o * f, height: o, type: "svg", mime: "image/svg+xml", wUnits: Xm(i.height), hUnits: Xm(i.height) } : void 0 : { width: u, height: c, type: "svg", mime: "image/svg+xml", wUnits: Xm(l.width), hUnits: Xm(l.height) };
+              }
+            }
+          }
+        };
+      });
+      var MEe = ye((Gdr, SEe) => {
+        var AEe = rc().str2arr, wEe = rc().sliceEq, $kt = rc().readUInt16LE, Qkt = rc().readUInt16BE, eCt = rc().readUInt32LE, tCt = rc().readUInt32BE, rCt = AEe("II*\0"), iCt = AEe("MM\0*");
+        function pD(e, t, r) {
+          return r ? Qkt(e, t) : $kt(e, t);
+        }
+        function mW(e, t, r) {
+          return r ? tCt(e, t) : eCt(e, t);
+        }
+        function TEe(e, t, r) {
+          var n = pD(e, t + 2, r), i = mW(e, t + 4, r);
+          return i !== 1 || n !== 3 && n !== 4 ? null : n === 3 ? pD(e, t + 8, r) : mW(e, t + 8, r);
+        }
+        SEe.exports = function(e) {
+          if (!(e.length < 8) && !(!wEe(e, 0, rCt) && !wEe(e, 0, iCt))) {
+            var t = e[0] === 77, r = mW(e, 4, t) - 8;
+            if (!(r < 0)) {
+              var n = r + 8;
+              if (!(e.length - n < 2)) {
+                var i = pD(e, n + 0, t) * 12;
+                if (!(i <= 0) && (n += 2, !(e.length - n < i))) {
+                  var a, o, s, l;
+                  for (a = 0; a < i; a += 12) l = pD(e, n + a, t), l === 256 ? o = TEe(e, n + a, t) : l === 257 && (s = TEe(e, n + a, t));
+                  if (o && s) return { width: o, height: s, type: "tiff", mime: "image/tiff", wUnits: "px", hUnits: "px" };
+                }
+              }
+            }
+          }
+        };
+      });
+      var PEe = ye((Hdr, LEe) => {
+        var CEe = rc().str2arr, EEe = rc().sliceEq, kEe = rc().readUInt16LE, yW = rc().readUInt32LE, nCt = dD(), aCt = CEe("RIFF"), oCt = CEe("WEBP");
+        function sCt(e, t) {
+          if (!(e[t + 3] !== 157 || e[t + 4] !== 1 || e[t + 5] !== 42)) return { width: kEe(e, t + 6) & 16383, height: kEe(e, t + 8) & 16383, type: "webp", mime: "image/webp", wUnits: "px", hUnits: "px" };
+        }
+        function lCt(e, t) {
+          if (e[t] === 47) {
+            var r = yW(e, t + 1);
+            return { width: (r & 16383) + 1, height: (r >> 14 & 16383) + 1, type: "webp", mime: "image/webp", wUnits: "px", hUnits: "px" };
+          }
+        }
+        function uCt(e, t) {
+          return { width: (e[t + 6] << 16 | e[t + 5] << 8 | e[t + 4]) + 1, height: (e[t + 9] << t | e[t + 8] << 8 | e[t + 7]) + 1, type: "webp", mime: "image/webp", wUnits: "px", hUnits: "px" };
+        }
+        LEe.exports = function(e) {
+          if (!(e.length < 16) && !(!EEe(e, 0, aCt) && !EEe(e, 8, oCt))) {
+            var t = 12, r = null, n = 0, i = yW(e, 4) + 8;
+            if (!(i > e.length)) {
+              for (; t + 8 < i; ) {
+                if (e[t] === 0) {
+                  t++;
+                  continue;
+                }
+                var a = String.fromCharCode.apply(null, e.slice(t, t + 4)), o = yW(e, t + 4);
+                a === "VP8 " && o >= 10 ? r = r || sCt(e, t + 8) : a === "VP8L" && o >= 9 ? r = r || lCt(e, t + 8) : a === "VP8X" && o >= 10 ? r = r || uCt(e, t + 8) : a === "EXIF" && (n = nCt.get_orientation(e.slice(t + 8, t + 8 + o)), t = 1 / 0), t += 8 + o;
+              }
+              if (r) return n > 0 && (r.orientation = n), r;
+            }
+          }
+        };
+      });
+      var REe = ye((jdr, IEe) => {
+        IEe.exports = { avif: J4e(), bmp: eEe(), gif: aEe(), ico: lEe(), jpeg: cEe(), png: pEe(), psd: yEe(), svg: bEe(), tiff: MEe(), webp: PEe() };
+      });
+      var DEe = ye((Wdr, xW) => {
+        var _W = REe();
+        function cCt(e) {
+          for (var t = Object.keys(_W), r = 0; r < t.length; r++) {
+            var n = _W[t[r]](e);
+            if (n) return n;
+          }
+          return null;
+        }
+        xW.exports = function(t) {
+          return cCt(t);
+        };
+        xW.exports.parsers = _W;
+      });
+      var zEe = ye((FEe) => {
+        var fCt = DEe(), hCt = Oy().IMAGE_URL_PREFIX, dCt = _2().Buffer;
+        FEe.getImageSize = function(e) {
+          var t = e.replace(hCt, ""), r = new dCt(t, "base64");
+          return fCt(r);
+        };
+      });
+      var BEe = ye((Zdr, qEe) => {
+        var OEe = Dr(), vCt = QT(), pCt = Eo(), gD = ho(), gCt = Dr().maxRowLength, mCt = zEe().getImageSize;
+        qEe.exports = function(t, r) {
+          var n, i;
+          if (r._hasZ) n = r.z.length, i = gCt(r.z);
+          else if (r._hasSource) {
+            var a = mCt(r.source);
+            n = a.height, i = a.width;
+          }
+          var o = gD.getFromId(t, r.xaxis || "x"), s = gD.getFromId(t, r.yaxis || "y"), l = o.d2c(r.x0) - r.dx / 2, u = s.d2c(r.y0) - r.dy / 2, c, f = [l, l + i * r.dx], h = [u, u + n * r.dy];
+          if (o && o.type === "log") for (c = 0; c < i; c++) f.push(l + c * r.dx);
+          if (s && s.type === "log") for (c = 0; c < n; c++) h.push(u + c * r.dy);
+          r._extremes[o._id] = gD.findExtremes(o, f), r._extremes[s._id] = gD.findExtremes(s, h), r._scaler = xCt(r);
+          var d = { x0: l, y0: u, z: r.z, w: i, h: n };
+          return [d];
+        };
+        function yCt(e, t, r, n) {
+          return function(i) {
+            return OEe.constrain((i - e) * t, r, n);
+          };
+        }
+        function _Ct(e, t) {
+          return function(r) {
+            return OEe.constrain(r, e, t);
+          };
+        }
+        function xCt(e) {
+          var t = vCt.colormodel[e.colormodel], r = t.colormodel || e.colormodel, n = r.length;
+          e._sArray = [];
+          for (var i = 0; i < n; i++) t.min[i] !== e.zmin[i] || t.max[i] !== e.zmax[i] ? e._sArray.push(yCt(e.zmin[i], (t.max[i] - t.min[i]) / (e.zmax[i] - e.zmin[i]), t.min[i], t.max[i])) : e._sArray.push(_Ct(t.min[i], t.max[i]));
+          return function(a) {
+            for (var o = a.slice(0, n), s = 0; s < n; s++) {
+              var l = o[s];
+              if (!pCt(l)) return false;
+              o[s] = e._sArray[s](l);
+            }
+            return o;
+          };
+        }
+      });
+      var VEe = ye((Ydr, UEe) => {
+        var bCt = Oa(), R2 = Dr(), NEe = R2.strTranslate, wCt = Wp(), TCt = QT(), ACt = oG(), SCt = g8().STYLE;
+        UEe.exports = function(t, r, n, i) {
+          var a = r.xaxis, o = r.yaxis, s = !t._context._exportedPlot && ACt();
+          R2.makeTraceGroups(i, n, "im").each(function(l) {
+            var u = bCt.select(this), c = l[0], f = c.trace, h = (f.zsmooth === "fast" || f.zsmooth === false && s) && !f._hasZ && f._hasSource && a.type === "linear" && o.type === "linear";
+            f._realImage = h;
+            var d = c.z, v = c.x0, _ = c.y0, b = c.w, p = c.h, k = f.dx, E = f.dy, T, L, x, C, M, g;
+            for (g = 0; T === void 0 && g < b; ) T = a.c2p(v + g * k), g++;
+            for (g = b; L === void 0 && g > 0; ) L = a.c2p(v + g * k), g--;
+            for (g = 0; C === void 0 && g < p; ) C = o.c2p(_ + g * E), g++;
+            for (g = p; M === void 0 && g > 0; ) M = o.c2p(_ + g * E), g--;
+            if (L < T && (x = L, L = T, T = x), M < C && (x = C, C = M, M = x), !h) {
+              var P = 0.5;
+              T = Math.max(-P * a._length, T), L = Math.min((1 + P) * a._length, L), C = Math.max(-P * o._length, C), M = Math.min((1 + P) * o._length, M);
+            }
+            var A = Math.round(L - T), z = Math.round(M - C), O = A <= 0 || z <= 0;
+            if (O) {
+              var U = u.selectAll("image").data([]);
+              U.exit().remove();
+              return;
+            }
+            function G(ge) {
+              var ie = document.createElement("canvas");
+              ie.width = A, ie.height = z;
+              var Se = ie.getContext("2d", { willReadFrequently: true }), Ee = function(ot) {
+                return R2.constrain(Math.round(a.c2p(v + ot * k) - T), 0, A);
+              }, Ae = function(ot) {
+                return R2.constrain(Math.round(o.c2p(_ + ot * E) - C), 0, z);
+              }, Be = TCt.colormodel[f.colormodel], Pe = Be.colormodel || f.colormodel, me = Be.fmt, De;
+              for (g = 0; g < c.w; g++) {
+                var ce = Ee(g), je = Ee(g + 1);
+                if (!(je === ce || isNaN(je) || isNaN(ce))) for (var lt = 0; lt < c.h; lt++) {
+                  var pt = Ae(lt), Vt = Ae(lt + 1);
+                  Vt === pt || isNaN(Vt) || isNaN(pt) || !ge(g, lt) || (De = f._scaler(ge(g, lt)), De ? Se.fillStyle = Pe + "(" + me(De).join(",") + ")" : Se.fillStyle = "rgba(0,0,0,0)", Se.fillRect(ce, pt, je - ce, Vt - pt));
+                }
+              }
+              return ie;
+            }
+            var Z = u.selectAll("image").data([l]);
+            Z.enter().append("svg:image").attr({ xmlns: wCt.svg, preserveAspectRatio: "none" }), Z.exit().remove();
+            var j = f.zsmooth === false ? SCt : "";
+            if (h) {
+              var N = R2.simpleMap(a.range, a.r2l), H = R2.simpleMap(o.range, o.r2l), re = N[1] < N[0], oe = H[1] > H[0];
+              if (re || oe) {
+                var _e = T + A / 2, Ce = C + z / 2;
+                j += "transform:" + NEe(_e + "px", Ce + "px") + "scale(" + (re ? -1 : 1) + "," + (oe ? -1 : 1) + ")" + NEe(-_e + "px", -Ce + "px") + ";";
+              }
+            }
+            Z.attr("style", j);
+            var Le = new Promise(function(ge) {
+              if (f._hasZ) ge();
+              else if (f._hasSource) if (f._canvas && f._canvas.el.width === b && f._canvas.el.height === p && f._canvas.source === f.source) ge();
+              else {
+                var ie = document.createElement("canvas");
+                ie.width = b, ie.height = p;
+                var Se = ie.getContext("2d", { willReadFrequently: true });
+                f._image = f._image || new Image();
+                var Ee = f._image;
+                Ee.onload = function() {
+                  Se.drawImage(Ee, 0, 0), f._canvas = { el: ie, source: f.source }, ge();
+                }, Ee.setAttribute("src", f.source);
+              }
+            }).then(function() {
+              var ge, ie;
+              if (f._hasZ) ie = G(function(Ae, Be) {
+                var Pe = d[Be][Ae];
+                return R2.isTypedArray(Pe) && (Pe = Array.from(Pe)), Pe;
+              }), ge = ie.toDataURL("image/png");
+              else if (f._hasSource) if (h) ge = f.source;
+              else {
+                var Se = f._canvas.el.getContext("2d", { willReadFrequently: true }), Ee = Se.getImageData(0, 0, b, p).data;
+                ie = G(function(Ae, Be) {
+                  var Pe = 4 * (Be * b + Ae);
+                  return [Ee[Pe], Ee[Pe + 1], Ee[Pe + 2], Ee[Pe + 3]];
+                }), ge = ie.toDataURL("image/png");
+              }
+              Z.attr({ "xlink:href": ge, height: z, width: A, x: T, y: C });
+            });
+            t._promises.push(Le);
+          });
+        };
+      });
+      var HEe = ye((Kdr, GEe) => {
+        var MCt = Oa();
+        GEe.exports = function(t) {
+          MCt.select(t).selectAll(".im image").style("opacity", function(r) {
+            return r[0].trace.opacity;
+          });
+        };
+      });
+      var ZEe = ye((Jdr, XEe) => {
+        var jEe = vf(), WEe = Dr(), mD = WEe.isArrayOrTypedArray, ECt = QT();
+        XEe.exports = function(t, r, n) {
+          var i = t.cd[0], a = i.trace, o = t.xa, s = t.ya;
+          if (!(jEe.inbox(r - i.x0, r - (i.x0 + i.w * a.dx), 0) > 0 || jEe.inbox(n - i.y0, n - (i.y0 + i.h * a.dy), 0) > 0)) {
+            var l = Math.floor((r - i.x0) / a.dx), u = Math.floor(Math.abs(n - i.y0) / a.dy), c;
+            if (a._hasZ ? c = i.z[u][l] : a._hasSource && (c = a._canvas.el.getContext("2d", { willReadFrequently: true }).getImageData(l, u, 1, 1).data), !!c) {
+              var f = i.hi || a.hoverinfo, h;
+              if (f) {
+                var d = f.split("+");
+                d.indexOf("all") !== -1 && (d = ["color"]), d.indexOf("color") !== -1 && (h = true);
+              }
+              var v = ECt.colormodel[a.colormodel], _ = v.colormodel || a.colormodel, b = _.length, p = a._scaler(c), k = v.suffix, E = [];
+              (a.hovertemplate || h) && (E.push("[" + [p[0] + k[0], p[1] + k[1], p[2] + k[2]].join(", ")), b === 4 && E.push(", " + p[3] + k[3]), E.push("]"), E = E.join(""), t.extraText = _.toUpperCase() + ": " + E);
+              var T;
+              mD(a.hovertext) && mD(a.hovertext[u]) ? T = a.hovertext[u][l] : mD(a.text) && mD(a.text[u]) && (T = a.text[u][l]);
+              var L = s.c2p(i.y0 + (u + 0.5) * a.dy), x = i.x0 + (l + 0.5) * a.dx, C = i.y0 + (u + 0.5) * a.dy, M = "[" + c.slice(0, a.colormodel.length).join(", ") + "]";
+              return [WEe.extendFlat(t, { index: [u, l], x0: o.c2p(i.x0 + l * a.dx), x1: o.c2p(i.x0 + (l + 1) * a.dx), y0: L, y1: L, color: p, xVal: x, xLabelVal: x, yVal: C, yLabelVal: C, zLabelVal: M, text: T, hovertemplateLabels: { zLabel: M, colorLabel: E, "color[0]Label": p[0] + k[0], "color[1]Label": p[1] + k[1], "color[2]Label": p[2] + k[2], "color[3]Label": p[3] + k[3] } })];
+            }
+          }
+        };
+      });
+      var KEe = ye(($dr, YEe) => {
+        YEe.exports = function(t, r) {
+          return "xVal" in r && (t.x = r.xVal), "yVal" in r && (t.y = r.yVal), r.xa && (t.xaxis = r.xa), r.ya && (t.yaxis = r.ya), t.color = r.color, t.colormodel = r.trace.colormodel, t.z || (t.z = r.color), t;
+        };
+      });
+      var $Ee = ye((Qdr, JEe) => {
+        JEe.exports = { attributes: gH(), supplyDefaults: Z3e(), calc: BEe(), plot: VEe(), style: HEe(), hoverPoints: ZEe(), eventData: KEe(), moduleType: "trace", name: "image", basePlotModule: mh(), categories: ["cartesian", "svg", "2dMap", "noSortingByValue"], animatable: false, meta: {} };
+      });
+      var eke = ye((evr, QEe) => {
+        QEe.exports = $Ee();
+      });
+      var F2 = ye((tvr, rke) => {
+        var bW = Gl(), kCt = Cc().attributes, CCt = ec(), LCt = Ih(), { hovertemplateAttrs: PCt, texttemplateAttrs: ICt, templatefallbackAttrs: tke } = Ll(), D2 = Ao().extendFlat, RCt = Pd().pattern, yD = CCt({ editType: "plot", arrayOk: true, colorEditType: "plot" });
+        rke.exports = { labels: { valType: "data_array", editType: "calc" }, label0: { valType: "number", dflt: 0, editType: "calc" }, dlabel: { valType: "number", dflt: 1, editType: "calc" }, values: { valType: "data_array", editType: "calc" }, marker: { colors: { valType: "data_array", editType: "calc" }, line: { color: { valType: "color", dflt: LCt.defaultLine, arrayOk: true, editType: "style" }, width: { valType: "number", min: 0, dflt: 0, arrayOk: true, editType: "style" }, editType: "calc" }, pattern: RCt, editType: "calc" }, text: { valType: "data_array", editType: "plot" }, hovertext: { valType: "string", dflt: "", arrayOk: true, editType: "style" }, scalegroup: { valType: "string", dflt: "", editType: "calc" }, textinfo: { valType: "flaglist", flags: ["label", "text", "value", "percent"], extras: ["none"], editType: "calc" }, hoverinfo: D2({}, bW.hoverinfo, { flags: ["label", "text", "value", "percent", "name"] }), hovertemplate: PCt({}, { keys: ["label", "color", "value", "percent", "text"] }), hovertemplatefallback: tke(), texttemplate: ICt({ editType: "plot" }, { keys: ["label", "color", "value", "percent", "text"] }), texttemplatefallback: tke({ editType: "plot" }), textposition: { valType: "enumerated", values: ["inside", "outside", "auto", "none"], dflt: "auto", arrayOk: true, editType: "plot" }, textfont: D2({}, yD, {}), insidetextorientation: { valType: "enumerated", values: ["horizontal", "radial", "tangential", "auto"], dflt: "auto", editType: "plot" }, insidetextfont: D2({}, yD, {}), outsidetextfont: D2({}, yD, {}), automargin: { valType: "boolean", dflt: false, editType: "plot" }, showlegend: D2({}, bW.showlegend, { arrayOk: true }), legend: D2({}, bW.legend, { arrayOk: true }), title: { text: { valType: "string", dflt: "", editType: "plot" }, font: D2({}, yD, {}), position: { valType: "enumerated", values: ["top left", "top center", "top right", "middle center", "bottom left", "bottom center", "bottom right"], editType: "plot" }, editType: "plot" }, domain: kCt({ name: "pie", trace: true, editType: "calc" }), hole: { valType: "number", min: 0, max: 1, dflt: 0, editType: "calc" }, sort: { valType: "boolean", dflt: true, editType: "calc" }, direction: { valType: "enumerated", values: ["clockwise", "counterclockwise"], dflt: "counterclockwise", editType: "calc" }, rotation: { valType: "angle", dflt: 0, editType: "calc" }, pull: { valType: "number", min: 0, max: 1, dflt: 0, arrayOk: true, editType: "calc" } };
+      });
+      var z2 = ye((rvr, ake) => {
+        var DCt = Eo(), zE = Dr(), FCt = F2(), zCt = Cc().defaults, OCt = i0().handleText, qCt = Dr().coercePattern;
+        function ike(e, t) {
+          var r = zE.isArrayOrTypedArray(e), n = zE.isArrayOrTypedArray(t), i = Math.min(r ? e.length : 1 / 0, n ? t.length : 1 / 0);
+          if (isFinite(i) || (i = 0), i && n) {
+            for (var a, o = 0; o < i; o++) {
+              var s = t[o];
+              if (DCt(s) && s > 0) {
+                a = true;
+                break;
+              }
+            }
+            a || (i = 0);
+          }
+          return { hasLabels: r, hasValues: n, len: i };
+        }
+        function nke(e, t, r, n, i) {
+          var a = n("marker.line.width");
+          a && n("marker.line.color", i ? void 0 : r.paper_bgcolor);
+          var o = n("marker.colors");
+          qCt(n, "marker.pattern", o), e.marker && !t.marker.pattern.fgcolor && (t.marker.pattern.fgcolor = e.marker.colors), t.marker.pattern.bgcolor || (t.marker.pattern.bgcolor = r.paper_bgcolor);
+        }
+        function BCt(e, t, r, n) {
+          function i(k, E) {
+            return zE.coerce(e, t, FCt, k, E);
+          }
+          var a = i("labels"), o = i("values"), s = ike(a, o), l = s.len;
+          if (t._hasLabels = s.hasLabels, t._hasValues = s.hasValues, !t._hasLabels && t._hasValues && (i("label0"), i("dlabel")), !l) {
+            t.visible = false;
+            return;
+          }
+          t._length = l, nke(e, t, n, i, true), i("scalegroup");
+          var u = i("text"), c = i("texttemplate");
+          i("texttemplatefallback");
+          var f;
+          if (c || (f = i("textinfo", zE.isArrayOrTypedArray(u) ? "text+percent" : "percent")), i("hovertext"), i("hovertemplate"), i("hovertemplatefallback"), c || f && f !== "none") {
+            var h = i("textposition");
+            OCt(e, t, n, i, h, { moduleHasSelected: false, moduleHasUnselected: false, moduleHasConstrain: false, moduleHasCliponaxis: false, moduleHasTextangle: false, moduleHasInsideanchor: false });
+            var d = Array.isArray(h) || h === "auto", v = d || h === "outside";
+            v && i("automargin"), (h === "inside" || h === "auto" || Array.isArray(h)) && i("insidetextorientation");
+          } else f === "none" && i("textposition", "none");
+          zCt(t, n, i);
+          var _ = i("hole"), b = i("title.text");
+          if (b) {
+            var p = i("title.position", _ ? "middle center" : "top center");
+            !_ && p === "middle center" && (t.title.position = "top center"), zE.coerceFont(i, "title.font", n.font);
+          }
+          i("sort"), i("direction"), i("rotation"), i("pull");
+        }
+        ake.exports = { handleLabelsAndValues: ike, handleMarkerDefaults: nke, supplyDefaults: BCt };
+      });
+      var _D = ye((ivr, oke) => {
+        oke.exports = { hiddenlabels: { valType: "data_array", editType: "calc" }, piecolorway: { valType: "colorlist", editType: "calc" }, extendpiecolors: { valType: "boolean", dflt: true, editType: "calc" } };
+      });
+      var lke = ye((nvr, ske) => {
+        var NCt = Dr(), UCt = _D();
+        ske.exports = function(t, r) {
+          function n(i, a) {
+            return NCt.coerce(t, r, UCt, i, a);
+          }
+          n("hiddenlabels"), n("piecolorway", r.colorway), n("extendpiecolors");
+        };
+      });
+      var EA = ye((avr, fke) => {
+        var VCt = Eo(), wW = fd(), GCt = ka(), HCt = {};
+        function jCt(e, t) {
+          var r = [], n = e._fullLayout, i = n.hiddenlabels || [], a = t.labels, o = t.marker.colors || [], s = t.values, l = t._length, u = t._hasValues && l, c, f;
+          if (t.dlabel) for (a = new Array(l), c = 0; c < l; c++) a[c] = String(t.label0 + c * t.dlabel);
+          var h = {}, d = uke(n["_" + t.type + "colormap"]), v = 0, _ = false;
+          for (c = 0; c < l; c++) {
+            var b, p, k;
+            if (u) {
+              if (b = s[c], !VCt(b)) continue;
+              b = +b;
+            } else b = 1;
+            p = a[c], (p === void 0 || p === "") && (p = c), p = String(p);
+            var E = h[p];
+            E === void 0 ? (h[p] = r.length, k = i.indexOf(p) !== -1, k || (v += b), r.push({ v: b, label: p, color: d(o[c], p), i: c, pts: [c], hidden: k })) : (_ = true, f = r[E], f.v += b, f.pts.push(c), f.hidden || (v += b), f.color === false && o[c] && (f.color = d(o[c], p)));
+          }
+          r = r.filter(function(L) {
+            return L.v >= 0;
+          });
+          var T = t.type === "funnelarea" ? _ : t.sort;
+          return T && r.sort(function(L, x) {
+            return x.v - L.v;
+          }), r[0] && (r[0].vTotal = v), r;
+        }
+        function uke(e) {
+          return function(r, n) {
+            return !r || (r = wW(r), !r.isValid()) ? false : (r = GCt.addOpacity(r, r.getAlpha()), e[n] || (e[n] = r), r);
+          };
+        }
+        function WCt(e, t) {
+          var r = (t || {}).type;
+          r || (r = "pie");
+          var n = e._fullLayout, i = e.calcdata, a = n[r + "colorway"], o = n["_" + r + "colormap"];
+          n["extend" + r + "colors"] && (a = cke(a, HCt));
+          for (var s = 0, l = 0; l < i.length; l++) {
+            var u = i[l], c = u[0].trace.type;
+            if (c === r) for (var f = 0; f < u.length; f++) {
+              var h = u[f];
+              h.color === false && (o[h.label] ? h.color = o[h.label] : (o[h.label] = h.color = a[s % a.length], s++));
+            }
+          }
+        }
+        function cke(e, t) {
+          var r, n = JSON.stringify(e), i = t[n];
+          if (!i) {
+            for (i = e.slice(), r = 0; r < e.length; r++) i.push(wW(e[r]).lighten(20).toHexString());
+            for (r = 0; r < e.length; r++) i.push(wW(e[r]).darken(20).toHexString());
+            t[n] = i;
+          }
+          return i;
+        }
+        fke.exports = { calc: jCt, crossTraceCalc: WCt, makePullColorFn: uke, generateExtendedColors: cke };
+      });
+      var dke = ye((ovr, hke) => {
+        var XCt = ip().appendArrayMultiPointValues;
+        hke.exports = function(t, r) {
+          var n = { curveNumber: r.index, pointNumbers: t.pts, data: r._input, fullData: r, label: t.label, color: t.color, value: t.v, percent: t.percent, text: t.text, bbox: t.bbox, v: t.v };
+          return t.pts.length === 1 && (n.pointNumber = n.i = t.pts[0]), XCt(n, r, t.pts), r.type === "funnelarea" && (delete n.v, delete n.i), n;
+        };
+      });
+      var TD = ye((svr, Dke) => {
+        var Fp = Oa(), ZCt = Mc(), xD = vf(), _ke = ka(), Qy = So(), rv = Dr(), YCt = rv.strScale, vke = rv.strTranslate, TW = Zl(), xke = bv(), KCt = xke.recordMinTextSize, JCt = xke.clearMinTextSize, bke = A_().TEXTPAD, ns = g_(), bD = dke(), pke = Dr().isValidTextValue;
+        function $Ct(e, t) {
+          var r = e._context.staticPlot, n = e._fullLayout, i = n._size;
+          JCt("pie", n), Ake(t, e), Pke(t, i);
+          var a = rv.makeTraceGroups(n._pielayer, t, "trace").each(function(o) {
+            var s = Fp.select(this), l = o[0], u = l.trace;
+            s6t(o), s.attr("stroke-linejoin", "round"), s.each(function() {
+              var c = Fp.select(this).selectAll("g.slice").data(o);
+              c.enter().append("g").classed("slice", true), c.exit().remove();
+              var f = [[[], []], [[], []]], h = false;
+              c.each(function(T, L) {
+                if (T.hidden) {
+                  Fp.select(this).selectAll("path,g").remove();
+                  return;
+                }
+                T.pointNumber = T.i, T.curveNumber = u.index, f[T.pxmid[1] < 0 ? 0 : 1][T.pxmid[0] < 0 ? 0 : 1].push(T);
+                var x = l.cx, C = l.cy, M = Fp.select(this), g = M.selectAll("path.surface").data([T]);
+                if (g.enter().append("path").classed("surface", true).style({ "pointer-events": r ? "none" : "all" }), M.call(wke, e, o), u.pull) {
+                  var P = +ns.castOption(u.pull, T.pts) || 0;
+                  P > 0 && (x += P * T.pxmid[0], C += P * T.pxmid[1]);
+                }
+                T.cxFinal = x, T.cyFinal = C;
+                function A(N, H, re, oe) {
+                  var _e = oe * (H[0] - N[0]), Ce = oe * (H[1] - N[1]);
+                  return "a" + oe * l.r + "," + oe * l.r + " 0 " + T.largeArc + (re ? " 1 " : " 0 ") + _e + "," + Ce;
+                }
+                var z = u.hole;
+                if (T.v === l.vTotal) {
+                  var O = "M" + (x + T.px0[0]) + "," + (C + T.px0[1]) + A(T.px0, T.pxmid, true, 1) + A(T.pxmid, T.px0, true, 1) + "Z";
+                  z ? g.attr("d", "M" + (x + z * T.px0[0]) + "," + (C + z * T.px0[1]) + A(T.px0, T.pxmid, false, z) + A(T.pxmid, T.px0, false, z) + "Z" + O) : g.attr("d", O);
+                } else {
+                  var U = A(T.px0, T.px1, true, 1);
+                  if (z) {
+                    var G = 1 - z;
+                    g.attr("d", "M" + (x + z * T.px1[0]) + "," + (C + z * T.px1[1]) + A(T.px1, T.px0, false, z) + "l" + G * T.px0[0] + "," + G * T.px0[1] + U + "Z");
+                  } else g.attr("d", "M" + x + "," + C + "l" + T.px0[0] + "," + T.px0[1] + U + "Z");
+                }
+                Ike(e, T, l);
+                var Z = ns.castOption(u.textposition, T.pts), j = M.selectAll("g.slicetext").data(T.text && Z !== "none" ? [0] : []);
+                j.enter().append("g").classed("slicetext", true), j.exit().remove(), j.each(function() {
+                  var N = rv.ensureSingle(Fp.select(this), "text", "", function(ie) {
+                    ie.attr("data-notex", 1);
+                  }), H = rv.ensureUniformFontSize(e, Z === "outside" ? e6t(u, T, n.font) : Tke(u, T, n.font));
+                  N.text(T.text).attr({ class: "slicetext", transform: "", "text-anchor": "middle" }).call(Qy.font, H).call(TW.convertToTspans, e);
+                  var re = Qy.bBox(N.node()), oe;
+                  if (Z === "outside") oe = yke(re, T);
+                  else if (oe = Ske(re, T, l), Z === "auto" && oe.scale < 1) {
+                    var _e = rv.ensureUniformFontSize(e, u.outsidetextfont);
+                    N.call(Qy.font, _e), re = Qy.bBox(N.node()), oe = yke(re, T);
+                  }
+                  var Ce = oe.textPosAngle, Le = Ce === void 0 ? T.pxmid : wD(l.r, Ce);
+                  if (oe.targetX = x + Le[0] * oe.rCenter + (oe.x || 0), oe.targetY = C + Le[1] * oe.rCenter + (oe.y || 0), Rke(oe, re), oe.outside) {
+                    var ge = oe.targetY;
+                    T.yLabelMin = ge - re.height / 2, T.yLabelMid = ge, T.yLabelMax = ge + re.height / 2, T.labelExtraX = 0, T.labelExtraY = 0, h = true;
+                  }
+                  oe.fontSize = H.size, KCt(u.type, oe, n), o[L].transform = oe, rv.setTransormAndDisplay(N, oe);
+                });
+              });
+              var d = Fp.select(this).selectAll("g.titletext").data(u.title.text ? [0] : []);
+              if (d.enter().append("g").classed("titletext", true), d.exit().remove(), d.each(function() {
+                var T = rv.ensureSingle(Fp.select(this), "text", "", function(C) {
+                  C.attr("data-notex", 1);
+                }), L = u.title.text;
+                u._meta && (L = rv.templateString(L, u._meta)), T.text(L).attr({ class: "titletext", transform: "", "text-anchor": "middle" }).call(Qy.font, u.title.font).call(TW.convertToTspans, e);
+                var x;
+                u.title.position === "middle center" ? x = i6t(l) : x = Cke(l, i), T.attr("transform", vke(x.x, x.y) + YCt(Math.min(1, x.scale)) + vke(x.tx, x.ty));
+              }), h && a6t(f, u), QCt(c, u), h && u.automargin) {
+                var v = Qy.bBox(s.node()), _ = u.domain, b = i.w * (_.x[1] - _.x[0]), p = i.h * (_.y[1] - _.y[0]), k = (0.5 * b - l.r) / i.w, E = (0.5 * p - l.r) / i.h;
+                ZCt.autoMargin(e, "pie." + u.uid + ".automargin", { xl: _.x[0] - k, xr: _.x[1] + k, yb: _.y[0] - E, yt: _.y[1] + E, l: Math.max(l.cx - l.r - v.left, 0), r: Math.max(v.right - (l.cx + l.r), 0), b: Math.max(v.bottom - (l.cy + l.r), 0), t: Math.max(l.cy - l.r - v.top, 0), pad: 5 });
+              }
+            });
+          });
+          setTimeout(function() {
+            a.selectAll("tspan").each(function() {
+              var o = Fp.select(this);
+              o.attr("dy") && o.attr("dy", o.attr("dy"));
+            });
+          }, 0);
+        }
+        function QCt(e, t) {
+          e.each(function(r) {
+            var n = Fp.select(this);
+            if (!r.labelExtraX && !r.labelExtraY) {
+              n.select("path.textline").remove();
+              return;
+            }
+            var i = n.select("g.slicetext text");
+            r.transform.targetX += r.labelExtraX, r.transform.targetY += r.labelExtraY, rv.setTransormAndDisplay(i, r.transform);
+            var a = r.cxFinal + r.pxmid[0], o = r.cyFinal + r.pxmid[1], s = "M" + a + "," + o, l = (r.yLabelMax - r.yLabelMin) * (r.pxmid[0] < 0 ? -1 : 1) / 4;
+            if (r.labelExtraX) {
+              var u = r.labelExtraX * r.pxmid[1] / r.pxmid[0], c = r.yLabelMid + r.labelExtraY - (r.cyFinal + r.pxmid[1]);
+              Math.abs(u) > Math.abs(c) ? s += "l" + c * r.pxmid[0] / r.pxmid[1] + "," + c + "H" + (a + r.labelExtraX + l) : s += "l" + r.labelExtraX + "," + u + "v" + (c - u) + "h" + l;
+            } else s += "V" + (r.yLabelMid + r.labelExtraY) + "h" + l;
+            rv.ensureSingle(n, "path", "textline").call(_ke.stroke, t.outsidetextfont.color).attr({ "stroke-width": Math.min(2, t.outsidetextfont.size / 8), d: s, fill: "none" });
+          });
+        }
+        function wke(e, t, r) {
+          var n = r[0], i = n.cx, a = n.cy, o = n.trace, s = o.type === "funnelarea";
+          "_hasHoverLabel" in o || (o._hasHoverLabel = false), "_hasHoverEvent" in o || (o._hasHoverEvent = false), e.on("mouseover", function(l) {
+            var u = t._fullLayout, c = t._fullData[o.index];
+            if (!(t._dragging || u.hovermode === false)) {
+              var f = c.hoverinfo;
+              if (Array.isArray(f) && (f = xD.castHoverinfo({ hoverinfo: [ns.castOption(f, l.pts)], _module: o._module }, u, 0)), f === "all" && (f = "label+text+value+percent+name"), c.hovertemplate || f !== "none" && f !== "skip" && f) {
+                var h = l.rInscribed || 0, d = i + l.pxmid[0] * (1 - h), v = a + l.pxmid[1] * (1 - h), _ = u.separators, b = [];
+                if (f && f.indexOf("label") !== -1 && b.push(l.label), l.text = ns.castOption(c.hovertext || c.text, l.pts), f && f.indexOf("text") !== -1) {
+                  var p = l.text;
+                  rv.isValidTextValue(p) && b.push(p);
+                }
+                l.value = l.v, l.valueLabel = ns.formatPieValue(l.v, _), f && f.indexOf("value") !== -1 && b.push(l.valueLabel), l.percent = l.v / n.vTotal, l.percentLabel = ns.formatPiePercent(l.percent, _), f && f.indexOf("percent") !== -1 && b.push(l.percentLabel);
+                var k = c.hoverlabel, E = k.font, T = [];
+                xD.loneHover({ trace: o, x0: d - h * n.r, x1: d + h * n.r, y: v, _x0: s ? i + l.TL[0] : d - h * n.r, _x1: s ? i + l.TR[0] : d + h * n.r, _y0: s ? a + l.TL[1] : v - h * n.r, _y1: s ? a + l.BL[1] : v + h * n.r, text: b.join("<br>"), name: c.hovertemplate || f.indexOf("name") !== -1 ? c.name : void 0, idealAlign: l.pxmid[0] < 0 ? "left" : "right", color: ns.castOption(k.bgcolor, l.pts) || l.color, borderColor: ns.castOption(k.bordercolor, l.pts), fontFamily: ns.castOption(E.family, l.pts), fontSize: ns.castOption(E.size, l.pts), fontColor: ns.castOption(E.color, l.pts), nameLength: ns.castOption(k.namelength, l.pts), textAlign: ns.castOption(k.align, l.pts), hovertemplate: ns.castOption(c.hovertemplate, l.pts), hovertemplateLabels: l, eventData: [bD(l, c)] }, { container: u._hoverlayer.node(), outerContainer: u._paper.node(), gd: t, inOut_bbox: T }), l.bbox = T[0], o._hasHoverLabel = true;
+              }
+              o._hasHoverEvent = true, t.emit("plotly_hover", { points: [bD(l, c)], event: Fp.event });
+            }
+          }), e.on("mouseout", function(l) {
+            var u = t._fullLayout, c = t._fullData[o.index], f = Fp.select(this).datum();
+            o._hasHoverEvent && (l.originalEvent = Fp.event, t.emit("plotly_unhover", { points: [bD(f, c)], event: Fp.event }), o._hasHoverEvent = false), o._hasHoverLabel && (xD.loneUnhover(u._hoverlayer.node()), o._hasHoverLabel = false);
+          }), e.on("click", function(l) {
+            var u = t._fullLayout, c = t._fullData[o.index];
+            t._dragging || u.hovermode === false || (t._hoverdata = [bD(l, c)], xD.click(t, Fp.event));
+          });
+        }
+        function e6t(e, t, r) {
+          var n = ns.castOption(e.outsidetextfont.color, t.pts) || ns.castOption(e.textfont.color, t.pts) || r.color, i = ns.castOption(e.outsidetextfont.family, t.pts) || ns.castOption(e.textfont.family, t.pts) || r.family, a = ns.castOption(e.outsidetextfont.size, t.pts) || ns.castOption(e.textfont.size, t.pts) || r.size, o = ns.castOption(e.outsidetextfont.weight, t.pts) || ns.castOption(e.textfont.weight, t.pts) || r.weight, s = ns.castOption(e.outsidetextfont.style, t.pts) || ns.castOption(e.textfont.style, t.pts) || r.style, l = ns.castOption(e.outsidetextfont.variant, t.pts) || ns.castOption(e.textfont.variant, t.pts) || r.variant, u = ns.castOption(e.outsidetextfont.textcase, t.pts) || ns.castOption(e.textfont.textcase, t.pts) || r.textcase, c = ns.castOption(e.outsidetextfont.lineposition, t.pts) || ns.castOption(e.textfont.lineposition, t.pts) || r.lineposition, f = ns.castOption(e.outsidetextfont.shadow, t.pts) || ns.castOption(e.textfont.shadow, t.pts) || r.shadow;
+          return { color: n, family: i, size: a, weight: o, style: s, variant: l, textcase: u, lineposition: c, shadow: f };
+        }
+        function Tke(e, t, r) {
+          var n = ns.castOption(e.insidetextfont.color, t.pts);
+          !n && e._input.textfont && (n = ns.castOption(e._input.textfont.color, t.pts));
+          var i = ns.castOption(e.insidetextfont.family, t.pts) || ns.castOption(e.textfont.family, t.pts) || r.family, a = ns.castOption(e.insidetextfont.size, t.pts) || ns.castOption(e.textfont.size, t.pts) || r.size, o = ns.castOption(e.insidetextfont.weight, t.pts) || ns.castOption(e.textfont.weight, t.pts) || r.weight, s = ns.castOption(e.insidetextfont.style, t.pts) || ns.castOption(e.textfont.style, t.pts) || r.style, l = ns.castOption(e.insidetextfont.variant, t.pts) || ns.castOption(e.textfont.variant, t.pts) || r.variant, u = ns.castOption(e.insidetextfont.textcase, t.pts) || ns.castOption(e.textfont.textcase, t.pts) || r.textcase, c = ns.castOption(e.insidetextfont.lineposition, t.pts) || ns.castOption(e.textfont.lineposition, t.pts) || r.lineposition, f = ns.castOption(e.insidetextfont.shadow, t.pts) || ns.castOption(e.textfont.shadow, t.pts) || r.shadow;
+          return { color: n || _ke.contrast(t.color), family: i, size: a, weight: o, style: s, variant: l, textcase: u, lineposition: c, shadow: f };
+        }
+        function Ake(e, t) {
+          for (var r, n, i = 0; i < e.length; i++) if (r = e[i][0], n = r.trace, n.title.text) {
+            var a = n.title.text;
+            n._meta && (a = rv.templateString(a, n._meta));
+            var o = Qy.tester.append("text").attr("data-notex", 1).text(a).call(Qy.font, n.title.font).call(TW.convertToTspans, t), s = Qy.bBox(o.node(), true);
+            r.titleBox = { width: s.width, height: s.height }, o.remove();
+          }
+        }
+        function Ske(e, t, r) {
+          var n = r.r || t.rpx1, i = t.rInscribed, a = t.startangle === t.stopangle;
+          if (a) return { rCenter: 1 - i, scale: 0, rotate: 0, textPosAngle: 0 };
+          var o = t.ring, s = o === 1 && Math.abs(t.startangle - t.stopangle) === Math.PI * 2, l = t.halfangle, u = t.midangle, c = r.trace.insidetextorientation, f = c === "horizontal", h = c === "tangential", d = c === "radial", v = c === "auto", _ = [], b;
+          if (!v) {
+            var p = function(M, g) {
+              if (t6t(t, M)) {
+                var P = Math.abs(M - t.startangle), A = Math.abs(M - t.stopangle), z = P < A ? P : A;
+                g === "tan" ? b = mke(e, n, o, z, 0) : b = gke(e, n, o, z, Math.PI / 2), b.textPosAngle = M, _.push(b);
+              }
+            }, k;
+            if (f || h) {
+              for (k = 4; k >= -4; k -= 2) p(Math.PI * k, "tan");
+              for (k = 4; k >= -4; k -= 2) p(Math.PI * (k + 1), "tan");
+            }
+            if (f || d) {
+              for (k = 4; k >= -4; k -= 2) p(Math.PI * (k + 1.5), "rad");
+              for (k = 4; k >= -4; k -= 2) p(Math.PI * (k + 0.5), "rad");
+            }
+          }
+          if (s || v || f) {
+            var E = Math.sqrt(e.width * e.width + e.height * e.height);
+            if (b = { scale: i * n * 2 / E, rCenter: 1 - i, rotate: 0 }, b.textPosAngle = (t.startangle + t.stopangle) / 2, b.scale >= 1) return b;
+            _.push(b);
+          }
+          (v || d) && (b = gke(e, n, o, l, u), b.textPosAngle = (t.startangle + t.stopangle) / 2, _.push(b)), (v || h) && (b = mke(e, n, o, l, u), b.textPosAngle = (t.startangle + t.stopangle) / 2, _.push(b));
+          for (var T = 0, L = 0, x = 0; x < _.length; x++) {
+            var C = _[x].scale;
+            if (L < C && (L = C, T = x), !v && L >= 1) break;
+          }
+          return _[T];
+        }
+        function t6t(e, t) {
+          var r = e.startangle, n = e.stopangle;
+          return r > t && t > n || r < t && t < n;
+        }
+        function gke(e, t, r, n, i) {
+          t = Math.max(0, t - 2 * bke);
+          var a = e.width / e.height, o = kke(a, n, t, r);
+          return { scale: o * 2 / e.height, rCenter: Mke(a, o / t), rotate: Eke(i) };
+        }
+        function mke(e, t, r, n, i) {
+          t = Math.max(0, t - 2 * bke);
+          var a = e.height / e.width, o = kke(a, n, t, r);
+          return { scale: o * 2 / e.width, rCenter: Mke(a, o / t), rotate: Eke(i + Math.PI / 2) };
+        }
+        function Mke(e, t) {
+          return Math.cos(t) - e * t;
+        }
+        function Eke(e) {
+          return (180 / Math.PI * e + 720) % 180 - 90;
+        }
+        function kke(e, t, r, n) {
+          var i = e + 1 / (2 * Math.tan(t));
+          return r * Math.min(1 / (Math.sqrt(i * i + 0.5) + i), n / (Math.sqrt(e * e + n / 2) + e));
+        }
+        function r6t(e, t) {
+          return e.v === t.vTotal && !t.trace.hole ? 1 : Math.min(1 / (1 + 1 / Math.sin(e.halfangle)), e.ring / 2);
+        }
+        function yke(e, t) {
+          var r = t.pxmid[0], n = t.pxmid[1], i = e.width / 2, a = e.height / 2;
+          return r < 0 && (i *= -1), n < 0 && (a *= -1), { scale: 1, rCenter: 1, rotate: 0, x: i + Math.abs(a) * (i > 0 ? 1 : -1) / 2, y: a / (1 + r * r / (n * n)), outside: true };
+        }
+        function i6t(e) {
+          var t = Math.sqrt(e.titleBox.width * e.titleBox.width + e.titleBox.height * e.titleBox.height);
+          return { x: e.cx, y: e.cy, scale: e.trace.hole * e.r * 2 / t, tx: 0, ty: -e.titleBox.height / 2 + e.trace.title.font.size };
+        }
+        function Cke(e, t) {
+          var r = 1, n = 1, i, a = e.trace, o = { x: e.cx, y: e.cy }, s = { tx: 0, ty: 0 };
+          s.ty += a.title.font.size, i = Lke(a), a.title.position.indexOf("top") !== -1 ? (o.y -= (1 + i) * e.r, s.ty -= e.titleBox.height) : a.title.position.indexOf("bottom") !== -1 && (o.y += (1 + i) * e.r);
+          var l = n6t(e.r, e.trace.aspectratio), u = t.w * (a.domain.x[1] - a.domain.x[0]) / 2;
+          return a.title.position.indexOf("left") !== -1 ? (u = u + l, o.x -= (1 + i) * l, s.tx += e.titleBox.width / 2) : a.title.position.indexOf("center") !== -1 ? u *= 2 : a.title.position.indexOf("right") !== -1 && (u = u + l, o.x += (1 + i) * l, s.tx -= e.titleBox.width / 2), r = u / e.titleBox.width, n = AW(e, t) / e.titleBox.height, { x: o.x, y: o.y, scale: Math.min(r, n), tx: s.tx, ty: s.ty };
+        }
+        function n6t(e, t) {
+          return e / (t === void 0 ? 1 : t);
+        }
+        function AW(e, t) {
+          var r = e.trace, n = t.h * (r.domain.y[1] - r.domain.y[0]);
+          return Math.min(e.titleBox.height, n / 2);
+        }
+        function Lke(e) {
+          var t = e.pull;
+          if (!t) return 0;
+          var r;
+          if (rv.isArrayOrTypedArray(t)) for (t = 0, r = 0; r < e.pull.length; r++) e.pull[r] > t && (t = e.pull[r]);
+          return t;
+        }
+        function a6t(e, t) {
+          var r, n, i, a, o, s, l, u, c, f, h, d, v;
+          function _(E, T) {
+            return E.pxmid[1] - T.pxmid[1];
+          }
+          function b(E, T) {
+            return T.pxmid[1] - E.pxmid[1];
+          }
+          function p(E, T) {
+            T || (T = {});
+            var L = T.labelExtraY + (n ? T.yLabelMax : T.yLabelMin), x = n ? E.yLabelMin : E.yLabelMax, C = n ? E.yLabelMax : E.yLabelMin, M = E.cyFinal + o(E.px0[1], E.px1[1]), g = L - x, P, A, z, O, U, G;
+            if (g * l > 0 && (E.labelExtraY = g), !!rv.isArrayOrTypedArray(t.pull)) for (A = 0; A < f.length; A++) z = f[A], !(z === E || (ns.castOption(t.pull, E.pts) || 0) >= (ns.castOption(t.pull, z.pts) || 0)) && ((E.pxmid[1] - z.pxmid[1]) * l > 0 ? (O = z.cyFinal + o(z.px0[1], z.px1[1]), g = O - x - E.labelExtraY, g * l > 0 && (E.labelExtraY += g)) : (C + E.labelExtraY - M) * l > 0 && (P = 3 * s * Math.abs(A - f.indexOf(E)), U = z.cxFinal + a(z.px0[0], z.px1[0]), G = U + P - (E.cxFinal + E.pxmid[0]) - E.labelExtraX, G * s > 0 && (E.labelExtraX += G)));
+          }
+          for (n = 0; n < 2; n++) for (i = n ? _ : b, o = n ? Math.max : Math.min, l = n ? 1 : -1, r = 0; r < 2; r++) {
+            for (a = r ? Math.max : Math.min, s = r ? 1 : -1, u = e[n][r], u.sort(i), c = e[1 - n][r], f = c.concat(u), d = [], h = 0; h < u.length; h++) u[h].yLabelMid !== void 0 && d.push(u[h]);
+            for (v = false, h = 0; n && h < c.length; h++) if (c[h].yLabelMid !== void 0) {
+              v = c[h];
+              break;
+            }
+            for (h = 0; h < d.length; h++) {
+              var k = h && d[h - 1];
+              v && !h && (k = v), p(d[h], k);
+            }
+          }
+        }
+        function Pke(e, t) {
+          for (var r = [], n = 0; n < e.length; n++) {
+            var i = e[n][0], a = i.trace, o = a.domain, s = t.w * (o.x[1] - o.x[0]), l = t.h * (o.y[1] - o.y[0]);
+            a.title.text && a.title.position !== "middle center" && (l -= AW(i, t));
+            var u = s / 2, c = l / 2;
+            a.type === "funnelarea" && !a.scalegroup && (c /= a.aspectratio), i.r = Math.min(u, c) / (1 + Lke(a)), i.cx = t.l + t.w * (a.domain.x[1] + a.domain.x[0]) / 2, i.cy = t.t + t.h * (1 - a.domain.y[0]) - l / 2, a.title.text && a.title.position.indexOf("bottom") !== -1 && (i.cy -= AW(i, t)), a.scalegroup && r.indexOf(a.scalegroup) === -1 && r.push(a.scalegroup);
+          }
+          o6t(e, r);
+        }
+        function o6t(e, t) {
+          for (var r, n, i, a = 0; a < t.length; a++) {
+            var o = 1 / 0, s = t[a];
+            for (n = 0; n < e.length; n++) if (r = e[n][0], i = r.trace, i.scalegroup === s) {
+              var l;
+              if (i.type === "pie") l = r.r * r.r;
+              else if (i.type === "funnelarea") {
+                var u, c;
+                i.aspectratio > 1 ? (u = r.r, c = u / i.aspectratio) : (c = r.r, u = c * i.aspectratio), u *= (1 + i.baseratio) / 2, l = u * c;
+              }
+              o = Math.min(o, l / r.vTotal);
+            }
+            for (n = 0; n < e.length; n++) if (r = e[n][0], i = r.trace, i.scalegroup === s) {
+              var f = o * r.vTotal;
+              i.type === "funnelarea" && (f /= (1 + i.baseratio) / 2, f /= i.aspectratio), r.r = Math.sqrt(f);
+            }
+          }
+        }
+        function s6t(e) {
+          var t = e[0], r = t.r, n = t.trace, i = ns.getRotationAngle(n.rotation), a = 2 * Math.PI / t.vTotal, o = "px0", s = "px1", l, u, c;
+          if (n.direction === "counterclockwise") {
+            for (l = 0; l < e.length && e[l].hidden; l++) ;
+            if (l === e.length) return;
+            i += a * e[l].v, a *= -1, o = "px1", s = "px0";
+          }
+          for (c = wD(r, i), l = 0; l < e.length; l++) u = e[l], !u.hidden && (u[o] = c, u.startangle = i, i += a * u.v / 2, u.pxmid = wD(r, i), u.midangle = i, i += a * u.v / 2, c = wD(r, i), u.stopangle = i, u[s] = c, u.largeArc = u.v > t.vTotal / 2 ? 1 : 0, u.halfangle = Math.PI * Math.min(u.v / t.vTotal, 0.5), u.ring = 1 - n.hole, u.rInscribed = r6t(u, t));
+        }
+        function wD(e, t) {
+          return [e * Math.sin(t), -e * Math.cos(t)];
+        }
+        function Ike(e, t, r) {
+          var n = e._fullLayout, i = r.trace, a = i.texttemplate, o = i.textinfo;
+          if (!a && o && o !== "none") {
+            var s = o.split("+"), l = function(T) {
+              return s.indexOf(T) !== -1;
+            }, u = l("label"), c = l("text"), f = l("value"), h = l("percent"), d = n.separators, v;
+            if (v = u ? [t.label] : [], c) {
+              var _ = ns.getFirstFilled(i.text, t.pts);
+              pke(_) && v.push(_);
+            }
+            f && v.push(ns.formatPieValue(t.v, d)), h && v.push(ns.formatPiePercent(t.v / r.vTotal, d)), t.text = v.join("<br>");
+          }
+          function b(T) {
+            return { label: T.label, value: T.v, valueLabel: ns.formatPieValue(T.v, n.separators), percent: T.v / r.vTotal, percentLabel: ns.formatPiePercent(T.v / r.vTotal, n.separators), color: T.color, text: T.text, customdata: rv.castOption(i, T.i, "customdata") };
+          }
+          if (a) {
+            var p = rv.castOption(i, t.i, "texttemplate");
+            if (!p) t.text = "";
+            else {
+              var k = b(t), E = ns.getFirstFilled(i.text, t.pts);
+              (pke(E) || E === "") && (k.text = E), t.text = rv.texttemplateString({ data: [k, i._meta], fallback: i.texttemplatefallback, labels: k, locale: e._fullLayout._d3locale, template: p });
+            }
+          }
+        }
+        function Rke(e, t) {
+          var r = e.rotate * Math.PI / 180, n = Math.cos(r), i = Math.sin(r), a = (t.left + t.right) / 2, o = (t.top + t.bottom) / 2;
+          e.textX = a * n - o * i, e.textY = a * i + o * n, e.noCenter = true;
+        }
+        Dke.exports = { plot: $Ct, formatSliceLabel: Ike, transformInsideText: Ske, determineInsideTextFont: Tke, positionTitleOutside: Cke, prerenderTitles: Ake, layoutAreas: Pke, attachFxHandlers: wke, computeTransform: Rke };
+      });
+      var Oke = ye((lvr, zke) => {
+        var Fke = Oa(), l6t = X3(), u6t = bv().resizeText;
+        zke.exports = function(t) {
+          var r = t._fullLayout._pielayer.selectAll(".trace");
+          u6t(t, r, "pie"), r.each(function(n) {
+            var i = n[0], a = i.trace, o = Fke.select(this);
+            o.style({ opacity: a.opacity }), o.selectAll("path.surface").each(function(s) {
+              Fke.select(this).call(l6t, s, a, t);
+            });
+          });
+        };
+      });
+      var Bke = ye((kA) => {
+        var qke = Mc();
+        kA.name = "pie";
+        kA.plot = function(e, t, r, n) {
+          qke.plotBasePlot(kA.name, e, t, r, n);
+        };
+        kA.clean = function(e, t, r, n) {
+          qke.cleanBasePlot(kA.name, e, t, r, n);
+        };
+      });
+      var Uke = ye((cvr, Nke) => {
+        Nke.exports = { attributes: F2(), supplyDefaults: z2().supplyDefaults, supplyLayoutDefaults: lke(), layoutAttributes: _D(), calc: EA().calc, crossTraceCalc: EA().crossTraceCalc, plot: TD().plot, style: Oke(), styleOne: X3(), moduleType: "trace", name: "pie", basePlotModule: Bke(), categories: ["pie-like", "pie", "showLegend"], meta: {} };
+      });
+      var Gke = ye((fvr, Vke) => {
+        Vke.exports = Uke();
+      });
+      var jke = ye((CA) => {
+        var Hke = Mc();
+        CA.name = "sunburst";
+        CA.plot = function(e, t, r, n) {
+          Hke.plotBasePlot(CA.name, e, t, r, n);
+        };
+        CA.clean = function(e, t, r, n) {
+          Hke.cleanBasePlot(CA.name, e, t, r, n);
+        };
+      });
+      var SW = ye((dvr, Wke) => {
+        Wke.exports = { CLICK_TRANSITION_TIME: 750, CLICK_TRANSITION_EASING: "linear", eventDataKeys: ["currentPath", "root", "entry", "percentRoot", "percentEntry", "percentParent"] };
+      });
+      var qE = ye((vvr, Yke) => {
+        var c6t = Gl(), { hovertemplateAttrs: f6t, texttemplateAttrs: h6t, templatefallbackAttrs: Xke } = Ll(), d6t = Tu(), v6t = Cc().attributes, e1 = F2(), Zke = SW(), OE = Ao().extendFlat, p6t = Pd().pattern;
+        Yke.exports = { labels: { valType: "data_array", editType: "calc" }, parents: { valType: "data_array", editType: "calc" }, values: { valType: "data_array", editType: "calc" }, branchvalues: { valType: "enumerated", values: ["remainder", "total"], dflt: "remainder", editType: "calc" }, count: { valType: "flaglist", flags: ["branches", "leaves"], dflt: "leaves", editType: "calc" }, level: { valType: "any", editType: "plot", anim: true }, maxdepth: { valType: "integer", editType: "plot", dflt: -1 }, marker: OE({ colors: { valType: "data_array", editType: "calc" }, line: { color: OE({}, e1.marker.line.color, { dflt: null }), width: OE({}, e1.marker.line.width, { dflt: 1 }), editType: "calc" }, pattern: p6t, editType: "calc" }, d6t("marker", { colorAttr: "colors", anim: false })), leaf: { opacity: { valType: "number", editType: "style", min: 0, max: 1 }, editType: "plot" }, text: e1.text, textinfo: { valType: "flaglist", flags: ["label", "text", "value", "current path", "percent root", "percent entry", "percent parent"], extras: ["none"], editType: "plot" }, texttemplate: h6t({ editType: "plot" }, { keys: Zke.eventDataKeys.concat(["label", "value"]) }), texttemplatefallback: Xke({ editType: "plot" }), hovertext: e1.hovertext, hoverinfo: OE({}, c6t.hoverinfo, { flags: ["label", "text", "value", "name", "current path", "percent root", "percent entry", "percent parent"], dflt: "label+text+value+name" }), hovertemplate: f6t({}, { keys: Zke.eventDataKeys }), hovertemplatefallback: Xke(), textfont: e1.textfont, insidetextorientation: e1.insidetextorientation, insidetextfont: e1.insidetextfont, outsidetextfont: OE({}, e1.outsidetextfont, {}), rotation: { valType: "angle", dflt: 0, editType: "plot" }, sort: e1.sort, root: { color: { valType: "color", editType: "calc", dflt: "rgba(0,0,0,0)" }, editType: "calc" }, domain: v6t({ name: "sunburst", trace: true, editType: "calc" }) };
+      });
+      var MW = ye((pvr, Kke) => {
+        Kke.exports = { sunburstcolorway: { valType: "colorlist", editType: "calc" }, extendsunburstcolors: { valType: "boolean", dflt: true, editType: "calc" } };
+      });
+      var eCe = ye((gvr, Qke) => {
+        var Jke = Dr(), g6t = qE(), m6t = Cc().defaults, y6t = i0().handleText, _6t = z2().handleMarkerDefaults, $ke = tc(), x6t = $ke.hasColorscale, b6t = $ke.handleDefaults;
+        Qke.exports = function(t, r, n, i) {
+          function a(h, d) {
+            return Jke.coerce(t, r, g6t, h, d);
+          }
+          var o = a("labels"), s = a("parents");
+          if (!o || !o.length || !s || !s.length) {
+            r.visible = false;
+            return;
+          }
+          var l = a("values");
+          l && l.length ? a("branchvalues") : a("count"), a("level"), a("maxdepth"), _6t(t, r, i, a);
+          var u = r._hasColorscale = x6t(t, "marker", "colors") || (t.marker || {}).coloraxis;
+          u && b6t(t, r, i, a, { prefix: "marker.", cLetter: "c" }), a("leaf.opacity", u ? 1 : 0.7);
+          var c = a("text");
+          a("texttemplate"), a("texttemplatefallback"), r.texttemplate || a("textinfo", Jke.isArrayOrTypedArray(c) ? "text+label" : "label"), a("hovertext"), a("hovertemplate"), a("hovertemplatefallback");
+          var f = "auto";
+          y6t(t, r, i, a, f, { moduleHasSelected: false, moduleHasUnselected: false, moduleHasConstrain: false, moduleHasCliponaxis: false, moduleHasTextangle: false, moduleHasInsideanchor: false }), a("insidetextorientation"), a("sort"), a("rotation"), a("root.color"), m6t(r, i, a), r._length = null;
+        };
+      });
+      var rCe = ye((mvr, tCe) => {
+        var w6t = Dr(), T6t = MW();
+        tCe.exports = function(t, r) {
+          function n(i, a) {
+            return w6t.coerce(t, r, T6t, i, a);
+          }
+          n("sunburstcolorway", r.colorway), n("extendsunburstcolors");
+        };
+      });
+      var BE = ye((AD, iCe) => {
+        (function(e, t) {
+          typeof AD == "object" && typeof iCe != "undefined" ? t(AD) : (e = e || self, t(e.d3 = e.d3 || {}));
+        })(AD, function(e) {
+          function t(We, tt) {
+            return We.parent === tt.parent ? 1 : 2;
+          }
+          function r(We) {
+            return We.reduce(n, 0) / We.length;
+          }
+          function n(We, tt) {
+            return We + tt.x;
+          }
+          function i(We) {
+            return 1 + We.reduce(a, 0);
+          }
+          function a(We, tt) {
+            return Math.max(We, tt.y);
+          }
+          function o(We) {
+            for (var tt; tt = We.children; ) We = tt[0];
+            return We;
+          }
+          function s(We) {
+            for (var tt; tt = We.children; ) We = tt[tt.length - 1];
+            return We;
+          }
+          function l() {
+            var We = t, tt = 1, xt = 1, Ie = false;
+            function xe(ke) {
+              var vt, ir = 0;
+              ke.eachAfter(function($r) {
+                var di = $r.children;
+                di ? ($r.x = r(di), $r.y = i(di)) : ($r.x = vt ? ir += We($r, vt) : 0, $r.y = 0, vt = $r);
+              });
+              var ar = o(ke), vr = s(ke), ii = ar.x - We(ar, vr) / 2, pi = vr.x + We(vr, ar) / 2;
+              return ke.eachAfter(Ie ? function($r) {
+                $r.x = ($r.x - ke.x) * tt, $r.y = (ke.y - $r.y) * xt;
+              } : function($r) {
+                $r.x = ($r.x - ii) / (pi - ii) * tt, $r.y = (1 - (ke.y ? $r.y / ke.y : 1)) * xt;
+              });
+            }
+            return xe.separation = function(ke) {
+              return arguments.length ? (We = ke, xe) : We;
+            }, xe.size = function(ke) {
+              return arguments.length ? (Ie = false, tt = +ke[0], xt = +ke[1], xe) : Ie ? null : [tt, xt];
+            }, xe.nodeSize = function(ke) {
+              return arguments.length ? (Ie = true, tt = +ke[0], xt = +ke[1], xe) : Ie ? [tt, xt] : null;
+            }, xe;
+          }
+          function u(We) {
+            var tt = 0, xt = We.children, Ie = xt && xt.length;
+            if (!Ie) tt = 1;
+            else for (; --Ie >= 0; ) tt += xt[Ie].value;
+            We.value = tt;
+          }
+          function c() {
+            return this.eachAfter(u);
+          }
+          function f(We) {
+            var tt = this, xt, Ie = [tt], xe, ke, vt;
+            do
+              for (xt = Ie.reverse(), Ie = []; tt = xt.pop(); ) if (We(tt), xe = tt.children, xe) for (ke = 0, vt = xe.length; ke < vt; ++ke) Ie.push(xe[ke]);
+            while (Ie.length);
+            return this;
+          }
+          function h(We) {
+            for (var tt = this, xt = [tt], Ie, xe; tt = xt.pop(); ) if (We(tt), Ie = tt.children, Ie) for (xe = Ie.length - 1; xe >= 0; --xe) xt.push(Ie[xe]);
+            return this;
+          }
+          function d(We) {
+            for (var tt = this, xt = [tt], Ie = [], xe, ke, vt; tt = xt.pop(); ) if (Ie.push(tt), xe = tt.children, xe) for (ke = 0, vt = xe.length; ke < vt; ++ke) xt.push(xe[ke]);
+            for (; tt = Ie.pop(); ) We(tt);
+            return this;
+          }
+          function v(We) {
+            return this.eachAfter(function(tt) {
+              for (var xt = +We(tt.data) || 0, Ie = tt.children, xe = Ie && Ie.length; --xe >= 0; ) xt += Ie[xe].value;
+              tt.value = xt;
+            });
+          }
+          function _(We) {
+            return this.eachBefore(function(tt) {
+              tt.children && tt.children.sort(We);
+            });
+          }
+          function b(We) {
+            for (var tt = this, xt = p(tt, We), Ie = [tt]; tt !== xt; ) tt = tt.parent, Ie.push(tt);
+            for (var xe = Ie.length; We !== xt; ) Ie.splice(xe, 0, We), We = We.parent;
+            return Ie;
+          }
+          function p(We, tt) {
+            if (We === tt) return We;
+            var xt = We.ancestors(), Ie = tt.ancestors(), xe = null;
+            for (We = xt.pop(), tt = Ie.pop(); We === tt; ) xe = We, We = xt.pop(), tt = Ie.pop();
+            return xe;
+          }
+          function k() {
+            for (var We = this, tt = [We]; We = We.parent; ) tt.push(We);
+            return tt;
+          }
+          function E() {
+            var We = [];
+            return this.each(function(tt) {
+              We.push(tt);
+            }), We;
+          }
+          function T() {
+            var We = [];
+            return this.eachBefore(function(tt) {
+              tt.children || We.push(tt);
+            }), We;
+          }
+          function L() {
+            var We = this, tt = [];
+            return We.each(function(xt) {
+              xt !== We && tt.push({ source: xt.parent, target: xt });
+            }), tt;
+          }
+          function x(We, tt) {
+            var xt = new A(We), Ie = +We.value && (xt.value = We.value), xe, ke = [xt], vt, ir, ar, vr;
+            for (tt == null && (tt = M); xe = ke.pop(); ) if (Ie && (xe.value = +xe.data.value), (ir = tt(xe.data)) && (vr = ir.length)) for (xe.children = new Array(vr), ar = vr - 1; ar >= 0; --ar) ke.push(vt = xe.children[ar] = new A(ir[ar])), vt.parent = xe, vt.depth = xe.depth + 1;
+            return xt.eachBefore(P);
+          }
+          function C() {
+            return x(this).eachBefore(g);
+          }
+          function M(We) {
+            return We.children;
+          }
+          function g(We) {
+            We.data = We.data.data;
+          }
+          function P(We) {
+            var tt = 0;
+            do
+              We.height = tt;
+            while ((We = We.parent) && We.height < ++tt);
+          }
+          function A(We) {
+            this.data = We, this.depth = this.height = 0, this.parent = null;
+          }
+          A.prototype = x.prototype = { constructor: A, count: c, each: f, eachAfter: d, eachBefore: h, sum: v, sort: _, path: b, ancestors: k, descendants: E, leaves: T, links: L, copy: C };
+          var z = Array.prototype.slice;
+          function O(We) {
+            for (var tt = We.length, xt, Ie; tt; ) Ie = Math.random() * tt-- | 0, xt = We[tt], We[tt] = We[Ie], We[Ie] = xt;
+            return We;
+          }
+          function U(We) {
+            for (var tt = 0, xt = (We = O(z.call(We))).length, Ie = [], xe, ke; tt < xt; ) xe = We[tt], ke && j(ke, xe) ? ++tt : (ke = H(Ie = G(Ie, xe)), tt = 0);
+            return ke;
+          }
+          function G(We, tt) {
+            var xt, Ie;
+            if (N(tt, We)) return [tt];
+            for (xt = 0; xt < We.length; ++xt) if (Z(tt, We[xt]) && N(oe(We[xt], tt), We)) return [We[xt], tt];
+            for (xt = 0; xt < We.length - 1; ++xt) for (Ie = xt + 1; Ie < We.length; ++Ie) if (Z(oe(We[xt], We[Ie]), tt) && Z(oe(We[xt], tt), We[Ie]) && Z(oe(We[Ie], tt), We[xt]) && N(_e(We[xt], We[Ie], tt), We)) return [We[xt], We[Ie], tt];
+            throw new Error();
+          }
+          function Z(We, tt) {
+            var xt = We.r - tt.r, Ie = tt.x - We.x, xe = tt.y - We.y;
+            return xt < 0 || xt * xt < Ie * Ie + xe * xe;
+          }
+          function j(We, tt) {
+            var xt = We.r - tt.r + 1e-6, Ie = tt.x - We.x, xe = tt.y - We.y;
+            return xt > 0 && xt * xt > Ie * Ie + xe * xe;
+          }
+          function N(We, tt) {
+            for (var xt = 0; xt < tt.length; ++xt) if (!j(We, tt[xt])) return false;
+            return true;
+          }
+          function H(We) {
+            switch (We.length) {
+              case 1:
+                return re(We[0]);
+              case 2:
+                return oe(We[0], We[1]);
+              case 3:
+                return _e(We[0], We[1], We[2]);
+            }
+          }
+          function re(We) {
+            return { x: We.x, y: We.y, r: We.r };
+          }
+          function oe(We, tt) {
+            var xt = We.x, Ie = We.y, xe = We.r, ke = tt.x, vt = tt.y, ir = tt.r, ar = ke - xt, vr = vt - Ie, ii = ir - xe, pi = Math.sqrt(ar * ar + vr * vr);
+            return { x: (xt + ke + ar / pi * ii) / 2, y: (Ie + vt + vr / pi * ii) / 2, r: (pi + xe + ir) / 2 };
+          }
+          function _e(We, tt, xt) {
+            var Ie = We.x, xe = We.y, ke = We.r, vt = tt.x, ir = tt.y, ar = tt.r, vr = xt.x, ii = xt.y, pi = xt.r, $r = Ie - vt, di = Ie - vr, ji = xe - ir, In = xe - ii, wi = ar - ke, On = pi - ke, qn = Ie * Ie + xe * xe - ke * ke, Fn = qn - vt * vt - ir * ir + ar * ar, ra = qn - vr * vr - ii * ii + pi * pi, la = di * ji - $r * In, Ut = (ji * ra - In * Fn) / (la * 2) - Ie, wt = (In * wi - ji * On) / la, rr = (di * Fn - $r * ra) / (la * 2) - xe, nr = ($r * On - di * wi) / la, Er = wt * wt + nr * nr - 1, Xr = 2 * (ke + Ut * wt + rr * nr), ri = Ut * Ut + rr * rr - ke * ke, Qr = -(Er ? (Xr + Math.sqrt(Xr * Xr - 4 * Er * ri)) / (2 * Er) : ri / Xr);
+            return { x: Ie + Ut + wt * Qr, y: xe + rr + nr * Qr, r: Qr };
+          }
+          function Ce(We, tt, xt) {
+            var Ie = We.x - tt.x, xe, ke, vt = We.y - tt.y, ir, ar, vr = Ie * Ie + vt * vt;
+            vr ? (ke = tt.r + xt.r, ke *= ke, ar = We.r + xt.r, ar *= ar, ke > ar ? (xe = (vr + ar - ke) / (2 * vr), ir = Math.sqrt(Math.max(0, ar / vr - xe * xe)), xt.x = We.x - xe * Ie - ir * vt, xt.y = We.y - xe * vt + ir * Ie) : (xe = (vr + ke - ar) / (2 * vr), ir = Math.sqrt(Math.max(0, ke / vr - xe * xe)), xt.x = tt.x + xe * Ie - ir * vt, xt.y = tt.y + xe * vt + ir * Ie)) : (xt.x = tt.x + xt.r, xt.y = tt.y);
+          }
+          function Le(We, tt) {
+            var xt = We.r + tt.r - 1e-6, Ie = tt.x - We.x, xe = tt.y - We.y;
+            return xt > 0 && xt * xt > Ie * Ie + xe * xe;
+          }
+          function ge(We) {
+            var tt = We._, xt = We.next._, Ie = tt.r + xt.r, xe = (tt.x * xt.r + xt.x * tt.r) / Ie, ke = (tt.y * xt.r + xt.y * tt.r) / Ie;
+            return xe * xe + ke * ke;
+          }
+          function ie(We) {
+            this._ = We, this.next = null, this.previous = null;
+          }
+          function Se(We) {
+            if (!(xe = We.length)) return 0;
+            var tt, xt, Ie, xe, ke, vt, ir, ar, vr, ii, pi;
+            if (tt = We[0], tt.x = 0, tt.y = 0, !(xe > 1)) return tt.r;
+            if (xt = We[1], tt.x = -xt.r, xt.x = tt.r, xt.y = 0, !(xe > 2)) return tt.r + xt.r;
+            Ce(xt, tt, Ie = We[2]), tt = new ie(tt), xt = new ie(xt), Ie = new ie(Ie), tt.next = Ie.previous = xt, xt.next = tt.previous = Ie, Ie.next = xt.previous = tt;
+            e: for (ir = 3; ir < xe; ++ir) {
+              Ce(tt._, xt._, Ie = We[ir]), Ie = new ie(Ie), ar = xt.next, vr = tt.previous, ii = xt._.r, pi = tt._.r;
+              do
+                if (ii <= pi) {
+                  if (Le(ar._, Ie._)) {
+                    xt = ar, tt.next = xt, xt.previous = tt, --ir;
+                    continue e;
+                  }
+                  ii += ar._.r, ar = ar.next;
+                } else {
+                  if (Le(vr._, Ie._)) {
+                    tt = vr, tt.next = xt, xt.previous = tt, --ir;
+                    continue e;
+                  }
+                  pi += vr._.r, vr = vr.previous;
+                }
+              while (ar !== vr.next);
+              for (Ie.previous = tt, Ie.next = xt, tt.next = xt.previous = xt = Ie, ke = ge(tt); (Ie = Ie.next) !== xt; ) (vt = ge(Ie)) < ke && (tt = Ie, ke = vt);
+              xt = tt.next;
+            }
+            for (tt = [xt._], Ie = xt; (Ie = Ie.next) !== xt; ) tt.push(Ie._);
+            for (Ie = U(tt), ir = 0; ir < xe; ++ir) tt = We[ir], tt.x -= Ie.x, tt.y -= Ie.y;
+            return Ie.r;
+          }
+          function Ee(We) {
+            return Se(We), We;
+          }
+          function Ae(We) {
+            return We == null ? null : Be(We);
+          }
+          function Be(We) {
+            if (typeof We != "function") throw new Error();
+            return We;
+          }
+          function Pe() {
+            return 0;
+          }
+          function me(We) {
+            return function() {
+              return We;
+            };
+          }
+          function De(We) {
+            return Math.sqrt(We.value);
+          }
+          function ce() {
+            var We = null, tt = 1, xt = 1, Ie = Pe;
+            function xe(ke) {
+              return ke.x = tt / 2, ke.y = xt / 2, We ? ke.eachBefore(je(We)).eachAfter(lt(Ie, 0.5)).eachBefore(pt(1)) : ke.eachBefore(je(De)).eachAfter(lt(Pe, 1)).eachAfter(lt(Ie, ke.r / Math.min(tt, xt))).eachBefore(pt(Math.min(tt, xt) / (2 * ke.r))), ke;
+            }
+            return xe.radius = function(ke) {
+              return arguments.length ? (We = Ae(ke), xe) : We;
+            }, xe.size = function(ke) {
+              return arguments.length ? (tt = +ke[0], xt = +ke[1], xe) : [tt, xt];
+            }, xe.padding = function(ke) {
+              return arguments.length ? (Ie = typeof ke == "function" ? ke : me(+ke), xe) : Ie;
+            }, xe;
+          }
+          function je(We) {
+            return function(tt) {
+              tt.children || (tt.r = Math.max(0, +We(tt) || 0));
+            };
+          }
+          function lt(We, tt) {
+            return function(xt) {
+              if (Ie = xt.children) {
+                var Ie, xe, ke = Ie.length, vt = We(xt) * tt || 0, ir;
+                if (vt) for (xe = 0; xe < ke; ++xe) Ie[xe].r += vt;
+                if (ir = Se(Ie), vt) for (xe = 0; xe < ke; ++xe) Ie[xe].r -= vt;
+                xt.r = ir + vt;
+              }
+            };
+          }
+          function pt(We) {
+            return function(tt) {
+              var xt = tt.parent;
+              tt.r *= We, xt && (tt.x = xt.x + We * tt.x, tt.y = xt.y + We * tt.y);
+            };
+          }
+          function Vt(We) {
+            We.x0 = Math.round(We.x0), We.y0 = Math.round(We.y0), We.x1 = Math.round(We.x1), We.y1 = Math.round(We.y1);
+          }
+          function ot(We, tt, xt, Ie, xe) {
+            for (var ke = We.children, vt, ir = -1, ar = ke.length, vr = We.value && (Ie - tt) / We.value; ++ir < ar; ) vt = ke[ir], vt.y0 = xt, vt.y1 = xe, vt.x0 = tt, vt.x1 = tt += vt.value * vr;
+          }
+          function ut() {
+            var We = 1, tt = 1, xt = 0, Ie = false;
+            function xe(vt) {
+              var ir = vt.height + 1;
+              return vt.x0 = vt.y0 = xt, vt.x1 = We, vt.y1 = tt / ir, vt.eachBefore(ke(tt, ir)), Ie && vt.eachBefore(Vt), vt;
+            }
+            function ke(vt, ir) {
+              return function(ar) {
+                ar.children && ot(ar, ar.x0, vt * (ar.depth + 1) / ir, ar.x1, vt * (ar.depth + 2) / ir);
+                var vr = ar.x0, ii = ar.y0, pi = ar.x1 - xt, $r = ar.y1 - xt;
+                pi < vr && (vr = pi = (vr + pi) / 2), $r < ii && (ii = $r = (ii + $r) / 2), ar.x0 = vr, ar.y0 = ii, ar.x1 = pi, ar.y1 = $r;
+              };
+            }
+            return xe.round = function(vt) {
+              return arguments.length ? (Ie = !!vt, xe) : Ie;
+            }, xe.size = function(vt) {
+              return arguments.length ? (We = +vt[0], tt = +vt[1], xe) : [We, tt];
+            }, xe.padding = function(vt) {
+              return arguments.length ? (xt = +vt, xe) : xt;
+            }, xe;
+          }
+          var Wt = "$", Nt = { depth: -1 }, $t = {};
+          function sr(We) {
+            return We.id;
+          }
+          function Tr(We) {
+            return We.parentId;
+          }
+          function fr() {
+            var We = sr, tt = Tr;
+            function xt(Ie) {
+              var xe, ke, vt = Ie.length, ir, ar, vr, ii = new Array(vt), pi, $r, di = {};
+              for (ke = 0; ke < vt; ++ke) xe = Ie[ke], vr = ii[ke] = new A(xe), (pi = We(xe, ke, Ie)) != null && (pi += "") && ($r = Wt + (vr.id = pi), di[$r] = $r in di ? $t : vr);
+              for (ke = 0; ke < vt; ++ke) if (vr = ii[ke], pi = tt(Ie[ke], ke, Ie), pi == null || !(pi += "")) {
+                if (ir) throw new Error("multiple roots");
+                ir = vr;
+              } else {
+                if (ar = di[Wt + pi], !ar) throw new Error("missing: " + pi);
+                if (ar === $t) throw new Error("ambiguous: " + pi);
+                ar.children ? ar.children.push(vr) : ar.children = [vr], vr.parent = ar;
+              }
+              if (!ir) throw new Error("no root");
+              if (ir.parent = Nt, ir.eachBefore(function(ji) {
+                ji.depth = ji.parent.depth + 1, --vt;
+              }).eachBefore(P), ir.parent = null, vt > 0) throw new Error("cycle");
+              return ir;
+            }
+            return xt.id = function(Ie) {
+              return arguments.length ? (We = Be(Ie), xt) : We;
+            }, xt.parentId = function(Ie) {
+              return arguments.length ? (tt = Be(Ie), xt) : tt;
+            }, xt;
+          }
+          function $e(We, tt) {
+            return We.parent === tt.parent ? 1 : 2;
+          }
+          function St(We) {
+            var tt = We.children;
+            return tt ? tt[0] : We.t;
+          }
+          function Qt(We) {
+            var tt = We.children;
+            return tt ? tt[tt.length - 1] : We.t;
+          }
+          function Gt(We, tt, xt) {
+            var Ie = xt / (tt.i - We.i);
+            tt.c -= Ie, tt.s += xt, We.c += Ie, tt.z += xt, tt.m += xt;
+          }
+          function _t(We) {
+            for (var tt = 0, xt = 0, Ie = We.children, xe = Ie.length, ke; --xe >= 0; ) ke = Ie[xe], ke.z += tt, ke.m += tt, tt += ke.s + (xt += ke.c);
+          }
+          function It(We, tt, xt) {
+            return We.a.parent === tt.parent ? We.a : xt;
+          }
+          function mt(We, tt) {
+            this._ = We, this.parent = null, this.children = null, this.A = null, this.a = this, this.z = 0, this.m = 0, this.c = 0, this.s = 0, this.t = null, this.i = tt;
+          }
+          mt.prototype = Object.create(A.prototype);
+          function er(We) {
+            for (var tt = new mt(We, 0), xt, Ie = [tt], xe, ke, vt, ir; xt = Ie.pop(); ) if (ke = xt._.children) for (xt.children = new Array(ir = ke.length), vt = ir - 1; vt >= 0; --vt) Ie.push(xe = xt.children[vt] = new mt(ke[vt], vt)), xe.parent = xt;
+            return (tt.parent = new mt(null, 0)).children = [tt], tt;
+          }
+          function lr() {
+            var We = $e, tt = 1, xt = 1, Ie = null;
+            function xe(vr) {
+              var ii = er(vr);
+              if (ii.eachAfter(ke), ii.parent.m = -ii.z, ii.eachBefore(vt), Ie) vr.eachBefore(ar);
+              else {
+                var pi = vr, $r = vr, di = vr;
+                vr.eachBefore(function(qn) {
+                  qn.x < pi.x && (pi = qn), qn.x > $r.x && ($r = qn), qn.depth > di.depth && (di = qn);
+                });
+                var ji = pi === $r ? 1 : We(pi, $r) / 2, In = ji - pi.x, wi = tt / ($r.x + ji + In), On = xt / (di.depth || 1);
+                vr.eachBefore(function(qn) {
+                  qn.x = (qn.x + In) * wi, qn.y = qn.depth * On;
+                });
+              }
+              return vr;
+            }
+            function ke(vr) {
+              var ii = vr.children, pi = vr.parent.children, $r = vr.i ? pi[vr.i - 1] : null;
+              if (ii) {
+                _t(vr);
+                var di = (ii[0].z + ii[ii.length - 1].z) / 2;
+                $r ? (vr.z = $r.z + We(vr._, $r._), vr.m = vr.z - di) : vr.z = di;
+              } else $r && (vr.z = $r.z + We(vr._, $r._));
+              vr.parent.A = ir(vr, $r, vr.parent.A || pi[0]);
+            }
+            function vt(vr) {
+              vr._.x = vr.z + vr.parent.m, vr.m += vr.parent.m;
+            }
+            function ir(vr, ii, pi) {
+              if (ii) {
+                for (var $r = vr, di = vr, ji = ii, In = $r.parent.children[0], wi = $r.m, On = di.m, qn = ji.m, Fn = In.m, ra; ji = Qt(ji), $r = St($r), ji && $r; ) In = St(In), di = Qt(di), di.a = vr, ra = ji.z + qn - $r.z - wi + We(ji._, $r._), ra > 0 && (Gt(It(ji, vr, pi), vr, ra), wi += ra, On += ra), qn += ji.m, wi += $r.m, Fn += In.m, On += di.m;
+                ji && !Qt(di) && (di.t = ji, di.m += qn - On), $r && !St(In) && (In.t = $r, In.m += wi - Fn, pi = vr);
+              }
+              return pi;
+            }
+            function ar(vr) {
+              vr.x *= tt, vr.y = vr.depth * xt;
+            }
+            return xe.separation = function(vr) {
+              return arguments.length ? (We = vr, xe) : We;
+            }, xe.size = function(vr) {
+              return arguments.length ? (Ie = false, tt = +vr[0], xt = +vr[1], xe) : Ie ? null : [tt, xt];
+            }, xe.nodeSize = function(vr) {
+              return arguments.length ? (Ie = true, tt = +vr[0], xt = +vr[1], xe) : Ie ? [tt, xt] : null;
+            }, xe;
+          }
+          function wr(We, tt, xt, Ie, xe) {
+            for (var ke = We.children, vt, ir = -1, ar = ke.length, vr = We.value && (xe - xt) / We.value; ++ir < ar; ) vt = ke[ir], vt.x0 = tt, vt.x1 = Ie, vt.y0 = xt, vt.y1 = xt += vt.value * vr;
+          }
+          var Lr = (1 + Math.sqrt(5)) / 2;
+          function ti(We, tt, xt, Ie, xe, ke) {
+            for (var vt = [], ir = tt.children, ar, vr, ii = 0, pi = 0, $r = ir.length, di, ji, In = tt.value, wi, On, qn, Fn, ra, la, Ut; ii < $r; ) {
+              di = xe - xt, ji = ke - Ie;
+              do
+                wi = ir[pi++].value;
+              while (!wi && pi < $r);
+              for (On = qn = wi, la = Math.max(ji / di, di / ji) / (In * We), Ut = wi * wi * la, ra = Math.max(qn / Ut, Ut / On); pi < $r; ++pi) {
+                if (wi += vr = ir[pi].value, vr < On && (On = vr), vr > qn && (qn = vr), Ut = wi * wi * la, Fn = Math.max(qn / Ut, Ut / On), Fn > ra) {
+                  wi -= vr;
+                  break;
+                }
+                ra = Fn;
+              }
+              vt.push(ar = { value: wi, dice: di < ji, children: ir.slice(ii, pi) }), ar.dice ? ot(ar, xt, Ie, xe, In ? Ie += ji * wi / In : ke) : wr(ar, xt, Ie, In ? xt += di * wi / In : xe, ke), In -= wi, ii = pi;
+            }
+            return vt;
+          }
+          var Br = function We(tt) {
+            function xt(Ie, xe, ke, vt, ir) {
+              ti(tt, Ie, xe, ke, vt, ir);
+            }
+            return xt.ratio = function(Ie) {
+              return We((Ie = +Ie) > 1 ? Ie : 1);
+            }, xt;
+          }(Lr);
+          function Vr() {
+            var We = Br, tt = false, xt = 1, Ie = 1, xe = [0], ke = Pe, vt = Pe, ir = Pe, ar = Pe, vr = Pe;
+            function ii($r) {
+              return $r.x0 = $r.y0 = 0, $r.x1 = xt, $r.y1 = Ie, $r.eachBefore(pi), xe = [0], tt && $r.eachBefore(Vt), $r;
+            }
+            function pi($r) {
+              var di = xe[$r.depth], ji = $r.x0 + di, In = $r.y0 + di, wi = $r.x1 - di, On = $r.y1 - di;
+              wi < ji && (ji = wi = (ji + wi) / 2), On < In && (In = On = (In + On) / 2), $r.x0 = ji, $r.y0 = In, $r.x1 = wi, $r.y1 = On, $r.children && (di = xe[$r.depth + 1] = ke($r) / 2, ji += vr($r) - di, In += vt($r) - di, wi -= ir($r) - di, On -= ar($r) - di, wi < ji && (ji = wi = (ji + wi) / 2), On < In && (In = On = (In + On) / 2), We($r, ji, In, wi, On));
+            }
+            return ii.round = function($r) {
+              return arguments.length ? (tt = !!$r, ii) : tt;
+            }, ii.size = function($r) {
+              return arguments.length ? (xt = +$r[0], Ie = +$r[1], ii) : [xt, Ie];
+            }, ii.tile = function($r) {
+              return arguments.length ? (We = Be($r), ii) : We;
+            }, ii.padding = function($r) {
+              return arguments.length ? ii.paddingInner($r).paddingOuter($r) : ii.paddingInner();
+            }, ii.paddingInner = function($r) {
+              return arguments.length ? (ke = typeof $r == "function" ? $r : me(+$r), ii) : ke;
+            }, ii.paddingOuter = function($r) {
+              return arguments.length ? ii.paddingTop($r).paddingRight($r).paddingBottom($r).paddingLeft($r) : ii.paddingTop();
+            }, ii.paddingTop = function($r) {
+              return arguments.length ? (vt = typeof $r == "function" ? $r : me(+$r), ii) : vt;
+            }, ii.paddingRight = function($r) {
+              return arguments.length ? (ir = typeof $r == "function" ? $r : me(+$r), ii) : ir;
+            }, ii.paddingBottom = function($r) {
+              return arguments.length ? (ar = typeof $r == "function" ? $r : me(+$r), ii) : ar;
+            }, ii.paddingLeft = function($r) {
+              return arguments.length ? (vr = typeof $r == "function" ? $r : me(+$r), ii) : vr;
+            }, ii;
+          }
+          function dt(We, tt, xt, Ie, xe) {
+            var ke = We.children, vt, ir = ke.length, ar, vr = new Array(ir + 1);
+            for (vr[0] = ar = vt = 0; vt < ir; ++vt) vr[vt + 1] = ar += ke[vt].value;
+            ii(0, ir, We.value, tt, xt, Ie, xe);
+            function ii(pi, $r, di, ji, In, wi, On) {
+              if (pi >= $r - 1) {
+                var qn = ke[pi];
+                qn.x0 = ji, qn.y0 = In, qn.x1 = wi, qn.y1 = On;
+                return;
+              }
+              for (var Fn = vr[pi], ra = di / 2 + Fn, la = pi + 1, Ut = $r - 1; la < Ut; ) {
+                var wt = la + Ut >>> 1;
+                vr[wt] < ra ? la = wt + 1 : Ut = wt;
+              }
+              ra - vr[la - 1] < vr[la] - ra && pi + 1 < la && --la;
+              var rr = vr[la] - Fn, nr = di - rr;
+              if (wi - ji > On - In) {
+                var Er = (ji * nr + wi * rr) / di;
+                ii(pi, la, rr, ji, In, Er, On), ii(la, $r, nr, Er, In, wi, On);
+              } else {
+                var Xr = (In * nr + On * rr) / di;
+                ii(pi, la, rr, ji, In, wi, Xr), ii(la, $r, nr, ji, Xr, wi, On);
+              }
+            }
+          }
+          function Ge(We, tt, xt, Ie, xe) {
+            (We.depth & 1 ? wr : ot)(We, tt, xt, Ie, xe);
+          }
+          var Je = function We(tt) {
+            function xt(Ie, xe, ke, vt, ir) {
+              if ((ar = Ie._squarify) && ar.ratio === tt) for (var ar, vr, ii, pi, $r = -1, di, ji = ar.length, In = Ie.value; ++$r < ji; ) {
+                for (vr = ar[$r], ii = vr.children, pi = vr.value = 0, di = ii.length; pi < di; ++pi) vr.value += ii[pi].value;
+                vr.dice ? ot(vr, xe, ke, vt, ke += (ir - ke) * vr.value / In) : wr(vr, xe, ke, xe += (vt - xe) * vr.value / In, ir), In -= vr.value;
+              }
+              else Ie._squarify = ar = ti(tt, Ie, xe, ke, vt, ir), ar.ratio = tt;
+            }
+            return xt.ratio = function(Ie) {
+              return We((Ie = +Ie) > 1 ? Ie : 1);
+            }, xt;
+          }(Lr);
+          e.cluster = l, e.hierarchy = x, e.pack = ce, e.packEnclose = U, e.packSiblings = Ee, e.partition = ut, e.stratify = fr, e.tree = lr, e.treemap = Vr, e.treemapBinary = dt, e.treemapDice = ot, e.treemapResquarify = Je, e.treemapSlice = wr, e.treemapSliceDice = Ge, e.treemapSquarify = Br, Object.defineProperty(e, "__esModule", { value: true });
+        });
+      });
+      var UE = ye((NE) => {
+        var nCe = BE(), A6t = Eo(), LA = Dr(), S6t = tc().makeColorScaleFuncFromTrace, M6t = EA().makePullColorFn, E6t = EA().generateExtendedColors, k6t = tc().calc, C6t = fs().ALMOST_EQUAL, L6t = {}, P6t = {}, I6t = {};
+        NE.calc = function(e, t) {
+          var r = e._fullLayout, n = t.ids, i = LA.isArrayOrTypedArray(n), a = t.labels, o = t.parents, s = t.values, l = LA.isArrayOrTypedArray(s), u = [], c = {}, f = {}, h = function(j, N) {
+            c[j] ? c[j].push(N) : c[j] = [N], f[N] = 1;
+          }, d = function(j) {
+            return j || typeof j == "number";
+          }, v = function(j) {
+            return !l || A6t(s[j]) && s[j] >= 0;
+          }, _, b, p;
+          i ? (_ = Math.min(n.length, o.length), b = function(j) {
+            return d(n[j]) && v(j);
+          }, p = function(j) {
+            return String(n[j]);
+          }) : (_ = Math.min(a.length, o.length), b = function(j) {
+            return d(a[j]) && v(j);
+          }, p = function(j) {
+            return String(a[j]);
+          }), l && (_ = Math.min(_, s.length));
+          for (var k = 0; k < _; k++) if (b(k)) {
+            var E = p(k), T = d(o[k]) ? String(o[k]) : "", L = { i: k, id: E, pid: T, label: d(a[k]) ? String(a[k]) : "" };
+            l && (L.v = +s[k]), u.push(L), h(T, E);
+          }
+          if (c[""]) {
+            if (c[""].length > 1) {
+              for (var M = LA.randstr(), g = 0; g < u.length; g++) u[g].pid === "" && (u[g].pid = M);
+              u.unshift({ hasMultipleRoots: true, id: M, pid: "", label: "" });
+            }
+          } else {
+            var x = [], C;
+            for (C in c) f[C] || x.push(C);
+            if (x.length === 1) C = x[0], u.unshift({ hasImpliedRoot: true, id: C, pid: "", label: C });
+            else return LA.warn(["Multiple implied roots, cannot build", t.type, "hierarchy of", t.name + ".", "These roots include:", x.join(", ")].join(" "));
+          }
+          var P;
+          try {
+            P = nCe.stratify().id(function(j) {
+              return j.id;
+            }).parentId(function(j) {
+              return j.pid;
+            })(u);
+          } catch (j) {
+            return LA.warn(["Failed to build", t.type, "hierarchy of", t.name + ".", "Error:", j.message].join(" "));
+          }
+          var A = nCe.hierarchy(P), z = false;
+          if (l) switch (t.branchvalues) {
+            case "remainder":
+              A.sum(function(j) {
+                return j.data.v;
+              });
+              break;
+            case "total":
+              A.each(function(j) {
+                var N = j.data.data, H = N.v;
+                if (j.children) {
+                  var re = j.children.reduce(function(oe, _e) {
+                    return oe + _e.data.data.v;
+                  }, 0);
+                  if ((N.hasImpliedRoot || N.hasMultipleRoots) && (H = re), H < re * C6t) return z = true, LA.warn(["Total value for node", j.data.data.id, "of", t.name, "is smaller than the sum of its children.", `
+parent value =`, H, `
+children sum =`, re].join(" "));
+                }
+                j.value = H;
+              });
+              break;
+          }
+          else aCe(A, t, { branches: t.count.indexOf("branches") !== -1, leaves: t.count.indexOf("leaves") !== -1 });
+          if (!z) {
+            t.sort && A.sort(function(j, N) {
+              return N.value - j.value;
+            });
+            var O, U, G = t.marker.colors || [], Z = !!G.length;
+            return t._hasColorscale ? (Z || (G = l ? t.values : t._values), k6t(e, t, { vals: G, containerStr: "marker", cLetter: "c" }), U = S6t(t.marker)) : O = M6t(r["_" + t.type + "colormap"]), A.each(function(j) {
+              var N = j.data.data;
+              N.color = t._hasColorscale ? U(G[N.i]) : O(G[N.i], N.id);
+            }), u[0].hierarchy = A, u;
+          }
+        };
+        NE._runCrossTraceCalc = function(e, t) {
+          var r = t._fullLayout, n = t.calcdata, i = r[e + "colorway"], a = r["_" + e + "colormap"];
+          r["extend" + e + "colors"] && (i = E6t(i, e === "icicle" ? I6t : e === "treemap" ? P6t : L6t));
+          var o = 0, s;
+          function l(h) {
+            var d = h.data.data, v = d.id;
+            d.color === false && (a[v] ? d.color = a[v] : h.parent ? h.parent.parent ? d.color = h.parent.data.data.color : (a[v] = d.color = i[o % i.length], o++) : d.color = s);
+          }
+          for (var u = 0; u < n.length; u++) {
+            var c = n[u], f = c[0];
+            f.trace.type === e && f.hierarchy && (s = f.trace.root.color, f.hierarchy.each(l));
+          }
+        };
+        NE.crossTraceCalc = function(e) {
+          return NE._runCrossTraceCalc("sunburst", e);
+        };
+        function aCe(e, t, r) {
+          var n = 0, i = e.children;
+          if (i) {
+            for (var a = i.length, o = 0; o < a; o++) n += aCe(i[o], t, r);
+            r.branches && n++;
+          } else r.leaves && n++;
+          return e.value = e.data.data.value = n, t._values || (t._values = []), t._values[e.data.data.i] = n, n;
+        }
+      });
+      function t1(e, t, r) {
+        e.prototype = t.prototype = r, r.constructor = e;
+      }
+      function $_(e, t) {
+        var r = Object.create(e.prototype);
+        for (var n in t) r[n] = t[n];
+        return r;
+      }
+      var SD = gu(() => {
+      });
+      function Ym() {
+      }
+      function sCe() {
+        return this.rgb().formatHex();
+      }
+      function N6t() {
+        return this.rgb().formatHex8();
+      }
+      function U6t() {
+        return vCe(this).formatHsl();
+      }
+      function lCe() {
+        return this.rgb().formatRgb();
+      }
+      function ex(e) {
+        var t, r;
+        return e = (e + "").trim().toLowerCase(), (t = R6t.exec(e)) ? (r = t[1].length, t = parseInt(t[1], 16), r === 6 ? uCe(t) : r === 3 ? new _d(t >> 8 & 15 | t >> 4 & 240, t >> 4 & 15 | t & 240, (t & 15) << 4 | t & 15, 1) : r === 8 ? MD(t >> 24 & 255, t >> 16 & 255, t >> 8 & 255, (t & 255) / 255) : r === 4 ? MD(t >> 12 & 15 | t >> 8 & 240, t >> 8 & 15 | t >> 4 & 240, t >> 4 & 15 | t & 240, ((t & 15) << 4 | t & 15) / 255) : null) : (t = D6t.exec(e)) ? new _d(t[1], t[2], t[3], 1) : (t = F6t.exec(e)) ? new _d(t[1] * 255 / 100, t[2] * 255 / 100, t[3] * 255 / 100, 1) : (t = z6t.exec(e)) ? MD(t[1], t[2], t[3], t[4]) : (t = O6t.exec(e)) ? MD(t[1] * 255 / 100, t[2] * 255 / 100, t[3] * 255 / 100, t[4]) : (t = q6t.exec(e)) ? hCe(t[1], t[2] / 100, t[3] / 100, 1) : (t = B6t.exec(e)) ? hCe(t[1], t[2] / 100, t[3] / 100, t[4]) : oCe.hasOwnProperty(e) ? uCe(oCe[e]) : e === "transparent" ? new _d(NaN, NaN, NaN, 0) : null;
+      }
+      function uCe(e) {
+        return new _d(e >> 16 & 255, e >> 8 & 255, e & 255, 1);
+      }
+      function MD(e, t, r, n) {
+        return n <= 0 && (e = t = r = NaN), new _d(e, t, r, n);
+      }
+      function GE(e) {
+        return e instanceof Ym || (e = ex(e)), e ? (e = e.rgb(), new _d(e.r, e.g, e.b, e.opacity)) : new _d();
+      }
+      function IA(e, t, r, n) {
+        return arguments.length === 1 ? GE(e) : new _d(e, t, r, n == null ? 1 : n);
+      }
+      function _d(e, t, r, n) {
+        this.r = +e, this.g = +t, this.b = +r, this.opacity = +n;
+      }
+      function cCe() {
+        return `#${O2(this.r)}${O2(this.g)}${O2(this.b)}`;
+      }
+      function V6t() {
+        return `#${O2(this.r)}${O2(this.g)}${O2(this.b)}${O2((isNaN(this.opacity) ? 1 : this.opacity) * 255)}`;
+      }
+      function fCe() {
+        let e = kD(this.opacity);
+        return `${e === 1 ? "rgb(" : "rgba("}${q2(this.r)}, ${q2(this.g)}, ${q2(this.b)}${e === 1 ? ")" : `, ${e})`}`;
+      }
+      function kD(e) {
+        return isNaN(e) ? 1 : Math.max(0, Math.min(1, e));
+      }
+      function q2(e) {
+        return Math.max(0, Math.min(255, Math.round(e) || 0));
+      }
+      function O2(e) {
+        return e = q2(e), (e < 16 ? "0" : "") + e.toString(16);
+      }
+      function hCe(e, t, r, n) {
+        return n <= 0 ? e = t = r = NaN : r <= 0 || r >= 1 ? e = t = NaN : t <= 0 && (e = NaN), new Kg(e, t, r, n);
+      }
+      function vCe(e) {
+        if (e instanceof Kg) return new Kg(e.h, e.s, e.l, e.opacity);
+        if (e instanceof Ym || (e = ex(e)), !e) return new Kg();
+        if (e instanceof Kg) return e;
+        e = e.rgb();
+        var t = e.r / 255, r = e.g / 255, n = e.b / 255, i = Math.min(t, r, n), a = Math.max(t, r, n), o = NaN, s = a - i, l = (a + i) / 2;
+        return s ? (t === a ? o = (r - n) / s + (r < n) * 6 : r === a ? o = (n - t) / s + 2 : o = (t - r) / s + 4, s /= l < 0.5 ? a + i : 2 - a - i, o *= 60) : s = l > 0 && l < 1 ? 0 : o, new Kg(o, s, l, e.opacity);
+      }
+      function HE(e, t, r, n) {
+        return arguments.length === 1 ? vCe(e) : new Kg(e, t, r, n == null ? 1 : n);
+      }
+      function Kg(e, t, r, n) {
+        this.h = +e, this.s = +t, this.l = +r, this.opacity = +n;
+      }
+      function dCe(e) {
+        return e = (e || 0) % 360, e < 0 ? e + 360 : e;
+      }
+      function ED(e) {
+        return Math.max(0, Math.min(1, e || 0));
+      }
+      function EW(e, t, r) {
+        return (e < 60 ? t + (r - t) * e / 60 : e < 180 ? r : e < 240 ? t + (r - t) * (240 - e) / 60 : t) * 255;
+      }
+      var Q_, B2, PA, VE, Zm, R6t, D6t, F6t, z6t, O6t, q6t, B6t, oCe, CD = gu(() => {
+        SD();
+        Q_ = 0.7, B2 = 1 / Q_, PA = "\\s*([+-]?\\d+)\\s*", VE = "\\s*([+-]?(?:\\d*\\.)?\\d+(?:[eE][+-]?\\d+)?)\\s*", Zm = "\\s*([+-]?(?:\\d*\\.)?\\d+(?:[eE][+-]?\\d+)?)%\\s*", R6t = /^#([0-9a-f]{3,8})$/, D6t = new RegExp(`^rgb\\(${PA},${PA},${PA}\\)$`), F6t = new RegExp(`^rgb\\(${Zm},${Zm},${Zm}\\)$`), z6t = new RegExp(`^rgba\\(${PA},${PA},${PA},${VE}\\)$`), O6t = new RegExp(`^rgba\\(${Zm},${Zm},${Zm},${VE}\\)$`), q6t = new RegExp(`^hsl\\(${VE},${Zm},${Zm}\\)$`), B6t = new RegExp(`^hsla\\(${VE},${Zm},${Zm},${VE}\\)$`), oCe = { aliceblue: 15792383, antiquewhite: 16444375, aqua: 65535, aquamarine: 8388564, azure: 15794175, beige: 16119260, bisque: 16770244, black: 0, blanchedalmond: 16772045, blue: 255, blueviolet: 9055202, brown: 10824234, burlywood: 14596231, cadetblue: 6266528, chartreuse: 8388352, chocolate: 13789470, coral: 16744272, cornflowerblue: 6591981, cornsilk: 16775388, crimson: 14423100, cyan: 65535, darkblue: 139, darkcyan: 35723, darkgoldenrod: 12092939, darkgray: 11119017, darkgreen: 25600, darkgrey: 11119017, darkkhaki: 12433259, darkmagenta: 9109643, darkolivegreen: 5597999, darkorange: 16747520, darkorchid: 10040012, darkred: 9109504, darksalmon: 15308410, darkseagreen: 9419919, darkslateblue: 4734347, darkslategray: 3100495, darkslategrey: 3100495, darkturquoise: 52945, darkviolet: 9699539, deeppink: 16716947, deepskyblue: 49151, dimgray: 6908265, dimgrey: 6908265, dodgerblue: 2003199, firebrick: 11674146, floralwhite: 16775920, forestgreen: 2263842, fuchsia: 16711935, gainsboro: 14474460, ghostwhite: 16316671, gold: 16766720, goldenrod: 14329120, gray: 8421504, green: 32768, greenyellow: 11403055, grey: 8421504, honeydew: 15794160, hotpink: 16738740, indianred: 13458524, indigo: 4915330, ivory: 16777200, khaki: 15787660, lavender: 15132410, lavenderblush: 16773365, lawngreen: 8190976, lemonchiffon: 16775885, lightblue: 11393254, lightcoral: 15761536, lightcyan: 14745599, lightgoldenrodyellow: 16448210, lightgray: 13882323, lightgreen: 9498256, lightgrey: 13882323, lightpink: 16758465, lightsalmon: 16752762, lightseagreen: 2142890, lightskyblue: 8900346, lightslategray: 7833753, lightslategrey: 7833753, lightsteelblue: 11584734, lightyellow: 16777184, lime: 65280, limegreen: 3329330, linen: 16445670, magenta: 16711935, maroon: 8388608, mediumaquamarine: 6737322, mediumblue: 205, mediumorchid: 12211667, mediumpurple: 9662683, mediumseagreen: 3978097, mediumslateblue: 8087790, mediumspringgreen: 64154, mediumturquoise: 4772300, mediumvioletred: 13047173, midnightblue: 1644912, mintcream: 16121850, mistyrose: 16770273, moccasin: 16770229, navajowhite: 16768685, navy: 128, oldlace: 16643558, olive: 8421376, olivedrab: 7048739, orange: 16753920, orangered: 16729344, orchid: 14315734, palegoldenrod: 15657130, palegreen: 10025880, paleturquoise: 11529966, palevioletred: 14381203, papayawhip: 16773077, peachpuff: 16767673, peru: 13468991, pink: 16761035, plum: 14524637, powderblue: 11591910, purple: 8388736, rebeccapurple: 6697881, red: 16711680, rosybrown: 12357519, royalblue: 4286945, saddlebrown: 9127187, salmon: 16416882, sandybrown: 16032864, seagreen: 3050327, seashell: 16774638, sienna: 10506797, silver: 12632256, skyblue: 8900331, slateblue: 6970061, slategray: 7372944, slategrey: 7372944, snow: 16775930, springgreen: 65407, steelblue: 4620980, tan: 13808780, teal: 32896, thistle: 14204888, tomato: 16737095, turquoise: 4251856, violet: 15631086, wheat: 16113331, white: 16777215, whitesmoke: 16119285, yellow: 16776960, yellowgreen: 10145074 };
+        t1(Ym, ex, { copy(e) {
+          return Object.assign(new this.constructor(), this, e);
+        }, displayable() {
+          return this.rgb().displayable();
+        }, hex: sCe, formatHex: sCe, formatHex8: N6t, formatHsl: U6t, formatRgb: lCe, toString: lCe });
+        t1(_d, IA, $_(Ym, { brighter(e) {
+          return e = e == null ? B2 : Math.pow(B2, e), new _d(this.r * e, this.g * e, this.b * e, this.opacity);
+        }, darker(e) {
+          return e = e == null ? Q_ : Math.pow(Q_, e), new _d(this.r * e, this.g * e, this.b * e, this.opacity);
+        }, rgb() {
+          return this;
+        }, clamp() {
+          return new _d(q2(this.r), q2(this.g), q2(this.b), kD(this.opacity));
+        }, displayable() {
+          return -0.5 <= this.r && this.r < 255.5 && -0.5 <= this.g && this.g < 255.5 && -0.5 <= this.b && this.b < 255.5 && 0 <= this.opacity && this.opacity <= 1;
+        }, hex: cCe, formatHex: cCe, formatHex8: V6t, formatRgb: fCe, toString: fCe }));
+        t1(Kg, HE, $_(Ym, { brighter(e) {
+          return e = e == null ? B2 : Math.pow(B2, e), new Kg(this.h, this.s, this.l * e, this.opacity);
+        }, darker(e) {
+          return e = e == null ? Q_ : Math.pow(Q_, e), new Kg(this.h, this.s, this.l * e, this.opacity);
+        }, rgb() {
+          var e = this.h % 360 + (this.h < 0) * 360, t = isNaN(e) || isNaN(this.s) ? 0 : this.s, r = this.l, n = r + (r < 0.5 ? r : 1 - r) * t, i = 2 * r - n;
+          return new _d(EW(e >= 240 ? e - 240 : e + 120, i, n), EW(e, i, n), EW(e < 120 ? e + 240 : e - 120, i, n), this.opacity);
+        }, clamp() {
+          return new Kg(dCe(this.h), ED(this.s), ED(this.l), kD(this.opacity));
+        }, displayable() {
+          return (0 <= this.s && this.s <= 1 || isNaN(this.s)) && 0 <= this.l && this.l <= 1 && 0 <= this.opacity && this.opacity <= 1;
+        }, formatHsl() {
+          let e = kD(this.opacity);
+          return `${e === 1 ? "hsl(" : "hsla("}${dCe(this.h)}, ${ED(this.s) * 100}%, ${ED(this.l) * 100}%${e === 1 ? ")" : `, ${e})`}`;
+        } }));
+      });
+      var LD, PD, kW = gu(() => {
+        LD = Math.PI / 180, PD = 180 / Math.PI;
+      });
+      function xCe(e) {
+        if (e instanceof Km) return new Km(e.l, e.a, e.b, e.opacity);
+        if (e instanceof r1) return bCe(e);
+        e instanceof _d || (e = GE(e));
+        var t = IW(e.r), r = IW(e.g), n = IW(e.b), i = CW((0.2225045 * t + 0.7168786 * r + 0.0606169 * n) / gCe), a, o;
+        return t === r && r === n ? a = o = i : (a = CW((0.4360747 * t + 0.3850649 * r + 0.1430804 * n) / pCe), o = CW((0.0139322 * t + 0.0971045 * r + 0.7141733 * n) / mCe)), new Km(116 * i - 16, 500 * (a - i), 200 * (i - o), e.opacity);
+      }
+      function DA(e, t, r, n) {
+        return arguments.length === 1 ? xCe(e) : new Km(e, t, r, n == null ? 1 : n);
+      }
+      function Km(e, t, r, n) {
+        this.l = +e, this.a = +t, this.b = +r, this.opacity = +n;
+      }
+      function CW(e) {
+        return e > G6t ? Math.pow(e, 1 / 3) : e / _Ce + yCe;
+      }
+      function LW(e) {
+        return e > RA ? e * e * e : _Ce * (e - yCe);
+      }
+      function PW(e) {
+        return 255 * (e <= 31308e-7 ? 12.92 * e : 1.055 * Math.pow(e, 1 / 2.4) - 0.055);
+      }
+      function IW(e) {
+        return (e /= 255) <= 0.04045 ? e / 12.92 : Math.pow((e + 0.055) / 1.055, 2.4);
+      }
+      function H6t(e) {
+        if (e instanceof r1) return new r1(e.h, e.c, e.l, e.opacity);
+        if (e instanceof Km || (e = xCe(e)), e.a === 0 && e.b === 0) return new r1(NaN, 0 < e.l && e.l < 100 ? 0 : NaN, e.l, e.opacity);
+        var t = Math.atan2(e.b, e.a) * PD;
+        return new r1(t < 0 ? t + 360 : t, Math.sqrt(e.a * e.a + e.b * e.b), e.l, e.opacity);
+      }
+      function jE(e, t, r, n) {
+        return arguments.length === 1 ? H6t(e) : new r1(e, t, r, n == null ? 1 : n);
+      }
+      function r1(e, t, r, n) {
+        this.h = +e, this.c = +t, this.l = +r, this.opacity = +n;
+      }
+      function bCe(e) {
+        if (isNaN(e.h)) return new Km(e.l, 0, 0, e.opacity);
+        var t = e.h * LD;
+        return new Km(e.l, Math.cos(t) * e.c, Math.sin(t) * e.c, e.opacity);
+      }
+      var ID, pCe, gCe, mCe, yCe, RA, _Ce, G6t, wCe = gu(() => {
+        SD();
+        CD();
+        kW();
+        ID = 18, pCe = 0.96422, gCe = 1, mCe = 0.82521, yCe = 4 / 29, RA = 6 / 29, _Ce = 3 * RA * RA, G6t = RA * RA * RA;
+        t1(Km, DA, $_(Ym, { brighter(e) {
+          return new Km(this.l + ID * (e == null ? 1 : e), this.a, this.b, this.opacity);
+        }, darker(e) {
+          return new Km(this.l - ID * (e == null ? 1 : e), this.a, this.b, this.opacity);
+        }, rgb() {
+          var e = (this.l + 16) / 116, t = isNaN(this.a) ? e : e + this.a / 500, r = isNaN(this.b) ? e : e - this.b / 200;
+          return t = pCe * LW(t), e = gCe * LW(e), r = mCe * LW(r), new _d(PW(3.1338561 * t - 1.6168667 * e - 0.4906146 * r), PW(-0.9787684 * t + 1.9161415 * e + 0.033454 * r), PW(0.0719453 * t - 0.2289914 * e + 1.4052427 * r), this.opacity);
+        } }));
+        t1(r1, jE, $_(Ym, { brighter(e) {
+          return new r1(this.h, this.c, this.l + ID * (e == null ? 1 : e), this.opacity);
+        }, darker(e) {
+          return new r1(this.h, this.c, this.l - ID * (e == null ? 1 : e), this.opacity);
+        }, rgb() {
+          return bCe(this).rgb();
+        } }));
+      });
+      function j6t(e) {
+        if (e instanceof N2) return new N2(e.h, e.s, e.l, e.opacity);
+        e instanceof _d || (e = GE(e));
+        var t = e.r / 255, r = e.g / 255, n = e.b / 255, i = (SCe * n + TCe * t - ACe * r) / (SCe + TCe - ACe), a = n - i, o = (WE * (r - i) - DW * a) / RD, s = Math.sqrt(o * o + a * a) / (WE * i * (1 - i)), l = s ? Math.atan2(o, a) * PD - 120 : NaN;
+        return new N2(l < 0 ? l + 360 : l, s, i, e.opacity);
+      }
+      function FA(e, t, r, n) {
+        return arguments.length === 1 ? j6t(e) : new N2(e, t, r, n == null ? 1 : n);
+      }
+      function N2(e, t, r, n) {
+        this.h = +e, this.s = +t, this.l = +r, this.opacity = +n;
+      }
+      var MCe, RW, DW, RD, WE, TCe, ACe, SCe, ECe = gu(() => {
+        SD();
+        CD();
+        kW();
+        MCe = -0.14861, RW = 1.78277, DW = -0.29227, RD = -0.90649, WE = 1.97294, TCe = WE * RD, ACe = WE * RW, SCe = RW * DW - RD * MCe;
+        t1(N2, FA, $_(Ym, { brighter(e) {
+          return e = e == null ? B2 : Math.pow(B2, e), new N2(this.h, this.s, this.l * e, this.opacity);
+        }, darker(e) {
+          return e = e == null ? Q_ : Math.pow(Q_, e), new N2(this.h, this.s, this.l * e, this.opacity);
+        }, rgb() {
+          var e = isNaN(this.h) ? 0 : (this.h + 120) * LD, t = +this.l, r = isNaN(this.s) ? 0 : this.s * t * (1 - t), n = Math.cos(e), i = Math.sin(e);
+          return new _d(255 * (t + r * (MCe * n + RW * i)), 255 * (t + r * (DW * n + RD * i)), 255 * (t + r * (WE * n)), this.opacity);
+        } }));
+      });
+      var U2 = gu(() => {
+        CD();
+        wCe();
+        ECe();
+      });
+      function FW(e, t, r, n, i) {
+        var a = e * e, o = a * e;
+        return ((1 - 3 * e + 3 * a - o) * t + (4 - 6 * a + 3 * o) * r + (1 + 3 * e + 3 * a - 3 * o) * n + o * i) / 6;
+      }
+      function DD(e) {
+        var t = e.length - 1;
+        return function(r) {
+          var n = r <= 0 ? r = 0 : r >= 1 ? (r = 1, t - 1) : Math.floor(r * t), i = e[n], a = e[n + 1], o = n > 0 ? e[n - 1] : 2 * i - a, s = n < t - 1 ? e[n + 2] : 2 * a - i;
+          return FW((r - n / t) * t, o, i, a, s);
+        };
+      }
+      var FD = gu(() => {
+      });
+      function zD(e) {
+        var t = e.length;
+        return function(r) {
+          var n = Math.floor(((r %= 1) < 0 ? ++r : r) * t), i = e[(n + t - 1) % t], a = e[n % t], o = e[(n + 1) % t], s = e[(n + 2) % t];
+          return FW((r - n / t) * t, i, a, o, s);
+        };
+      }
+      var zW = gu(() => {
+        FD();
+      });
+      var zA, OW = gu(() => {
+        zA = (e) => () => e;
+      });
+      function kCe(e, t) {
+        return function(r) {
+          return e + r * t;
+        };
+      }
+      function W6t(e, t, r) {
+        return e = Math.pow(e, r), t = Math.pow(t, r) - e, r = 1 / r, function(n) {
+          return Math.pow(e + n * t, r);
+        };
+      }
+      function tx(e, t) {
+        var r = t - e;
+        return r ? kCe(e, r > 180 || r < -180 ? r - 360 * Math.round(r / 360) : r) : zA(isNaN(e) ? t : e);
+      }
+      function CCe(e) {
+        return (e = +e) == 1 ? $f : function(t, r) {
+          return r - t ? W6t(t, r, e) : zA(isNaN(t) ? r : t);
+        };
+      }
+      function $f(e, t) {
+        var r = t - e;
+        return r ? kCe(e, r) : zA(isNaN(e) ? t : e);
+      }
+      var V2 = gu(() => {
+        OW();
+      });
+      function LCe(e) {
+        return function(t) {
+          var r = t.length, n = new Array(r), i = new Array(r), a = new Array(r), o, s;
+          for (o = 0; o < r; ++o) s = IA(t[o]), n[o] = s.r || 0, i[o] = s.g || 0, a[o] = s.b || 0;
+          return n = e(n), i = e(i), a = e(a), s.opacity = 1, function(l) {
+            return s.r = n(l), s.g = i(l), s.b = a(l), s + "";
+          };
+        };
+      }
+      var XE, PCe, ICe, qW = gu(() => {
+        U2();
+        FD();
+        zW();
+        V2();
+        XE = function e(t) {
+          var r = CCe(t);
+          function n(i, a) {
+            var o = r((i = IA(i)).r, (a = IA(a)).r), s = r(i.g, a.g), l = r(i.b, a.b), u = $f(i.opacity, a.opacity);
+            return function(c) {
+              return i.r = o(c), i.g = s(c), i.b = l(c), i.opacity = u(c), i + "";
+            };
+          }
+          return n.gamma = e, n;
+        }(1);
+        PCe = LCe(DD), ICe = LCe(zD);
+      });
+      function OA(e, t) {
+        t || (t = []);
+        var r = e ? Math.min(t.length, e.length) : 0, n = t.slice(), i;
+        return function(a) {
+          for (i = 0; i < r; ++i) n[i] = e[i] * (1 - a) + t[i] * a;
+          return n;
+        };
+      }
+      function OD(e) {
+        return ArrayBuffer.isView(e) && !(e instanceof DataView);
+      }
+      var qD = gu(() => {
+      });
+      function RCe(e, t) {
+        return (OD(t) ? OA : BW)(e, t);
+      }
+      function BW(e, t) {
+        var r = t ? t.length : 0, n = e ? Math.min(r, e.length) : 0, i = new Array(n), a = new Array(r), o;
+        for (o = 0; o < n; ++o) i[o] = rx(e[o], t[o]);
+        for (; o < r; ++o) a[o] = t[o];
+        return function(s) {
+          for (o = 0; o < n; ++o) a[o] = i[o](s);
+          return a;
+        };
+      }
+      var NW = gu(() => {
+        ZE();
+        qD();
+      });
+      function BD(e, t) {
+        var r = /* @__PURE__ */ new Date();
+        return e = +e, t = +t, function(n) {
+          return r.setTime(e * (1 - n) + t * n), r;
+        };
+      }
+      var UW = gu(() => {
+      });
+      function zp(e, t) {
+        return e = +e, t = +t, function(r) {
+          return e * (1 - r) + t * r;
+        };
+      }
+      var YE = gu(() => {
+      });
+      function ND(e, t) {
+        var r = {}, n = {}, i;
+        (e === null || typeof e != "object") && (e = {}), (t === null || typeof t != "object") && (t = {});
+        for (i in t) i in e ? r[i] = rx(e[i], t[i]) : n[i] = t[i];
+        return function(a) {
+          for (i in r) n[i] = r[i](a);
+          return n;
+        };
+      }
+      var VW = gu(() => {
+        ZE();
+      });
+      function X6t(e) {
+        return function() {
+          return e;
+        };
+      }
+      function Z6t(e) {
+        return function(t) {
+          return e(t) + "";
+        };
+      }
+      function UD(e, t) {
+        var r = HW.lastIndex = GW.lastIndex = 0, n, i, a, o = -1, s = [], l = [];
+        for (e = e + "", t = t + ""; (n = HW.exec(e)) && (i = GW.exec(t)); ) (a = i.index) > r && (a = t.slice(r, a), s[o] ? s[o] += a : s[++o] = a), (n = n[0]) === (i = i[0]) ? s[o] ? s[o] += i : s[++o] = i : (s[++o] = null, l.push({ i: o, x: zp(n, i) })), r = GW.lastIndex;
+        return r < t.length && (a = t.slice(r), s[o] ? s[o] += a : s[++o] = a), s.length < 2 ? l[0] ? Z6t(l[0].x) : X6t(t) : (t = l.length, function(u) {
+          for (var c = 0, f; c < t; ++c) s[(f = l[c]).i] = f.x(u);
+          return s.join("");
+        });
+      }
+      var HW, GW, jW = gu(() => {
+        YE();
+        HW = /[-+]?(?:\d+\.?\d*|\.?\d+)(?:[eE][-+]?\d+)?/g, GW = new RegExp(HW.source, "g");
+      });
+      function rx(e, t) {
+        var r = typeof t, n;
+        return t == null || r === "boolean" ? zA(t) : (r === "number" ? zp : r === "string" ? (n = ex(t)) ? (t = n, XE) : UD : t instanceof ex ? XE : t instanceof Date ? BD : OD(t) ? OA : Array.isArray(t) ? BW : typeof t.valueOf != "function" && typeof t.toString != "function" || isNaN(t) ? ND : zp)(e, t);
+      }
+      var ZE = gu(() => {
+        U2();
+        qW();
+        NW();
+        UW();
+        YE();
+        VW();
+        jW();
+        OW();
+        qD();
+      });
+      function DCe(e) {
+        var t = e.length;
+        return function(r) {
+          return e[Math.max(0, Math.min(t - 1, Math.floor(r * t)))];
+        };
+      }
+      var FCe = gu(() => {
+      });
+      function zCe(e, t) {
+        var r = tx(+e, +t);
+        return function(n) {
+          var i = r(n);
+          return i - 360 * Math.floor(i / 360);
+        };
+      }
+      var OCe = gu(() => {
+        V2();
+      });
+      function qCe(e, t) {
+        return e = +e, t = +t, function(r) {
+          return Math.round(e * (1 - r) + t * r);
+        };
+      }
+      var BCe = gu(() => {
+      });
+      function WW(e, t, r, n, i, a) {
+        var o, s, l;
+        return (o = Math.sqrt(e * e + t * t)) && (e /= o, t /= o), (l = e * r + t * n) && (r -= e * l, n -= t * l), (s = Math.sqrt(r * r + n * n)) && (r /= s, n /= s, l /= s), e * n < t * r && (e = -e, t = -t, l = -l, o = -o), { translateX: i, translateY: a, rotate: Math.atan2(t, e) * NCe, skewX: Math.atan(l) * NCe, scaleX: o, scaleY: s };
+      }
+      var NCe, VD, UCe = gu(() => {
+        NCe = 180 / Math.PI, VD = { translateX: 0, translateY: 0, rotate: 0, skewX: 0, scaleX: 1, scaleY: 1 };
+      });
+      function VCe(e) {
+        let t = new (typeof DOMMatrix == "function" ? DOMMatrix : WebKitCSSMatrix)(e + "");
+        return t.isIdentity ? VD : WW(t.a, t.b, t.c, t.d, t.e, t.f);
+      }
+      function GCe(e) {
+        return e == null ? VD : (GD || (GD = document.createElementNS("http://www.w3.org/2000/svg", "g")), GD.setAttribute("transform", e), (e = GD.transform.baseVal.consolidate()) ? (e = e.matrix, WW(e.a, e.b, e.c, e.d, e.e, e.f)) : VD);
+      }
+      var GD, HCe = gu(() => {
+        UCe();
+      });
+      function jCe(e, t, r, n) {
+        function i(u) {
+          return u.length ? u.pop() + " " : "";
+        }
+        function a(u, c, f, h, d, v) {
+          if (u !== f || c !== h) {
+            var _ = d.push("translate(", null, t, null, r);
+            v.push({ i: _ - 4, x: zp(u, f) }, { i: _ - 2, x: zp(c, h) });
+          } else (f || h) && d.push("translate(" + f + t + h + r);
+        }
+        function o(u, c, f, h) {
+          u !== c ? (u - c > 180 ? c += 360 : c - u > 180 && (u += 360), h.push({ i: f.push(i(f) + "rotate(", null, n) - 2, x: zp(u, c) })) : c && f.push(i(f) + "rotate(" + c + n);
+        }
+        function s(u, c, f, h) {
+          u !== c ? h.push({ i: f.push(i(f) + "skewX(", null, n) - 2, x: zp(u, c) }) : c && f.push(i(f) + "skewX(" + c + n);
+        }
+        function l(u, c, f, h, d, v) {
+          if (u !== f || c !== h) {
+            var _ = d.push(i(d) + "scale(", null, ",", null, ")");
+            v.push({ i: _ - 4, x: zp(u, f) }, { i: _ - 2, x: zp(c, h) });
+          } else (f !== 1 || h !== 1) && d.push(i(d) + "scale(" + f + "," + h + ")");
+        }
+        return function(u, c) {
+          var f = [], h = [];
+          return u = e(u), c = e(c), a(u.translateX, u.translateY, c.translateX, c.translateY, f, h), o(u.rotate, c.rotate, f, h), s(u.skewX, c.skewX, f, h), l(u.scaleX, u.scaleY, c.scaleX, c.scaleY, f, h), u = c = null, function(d) {
+            for (var v = -1, _ = h.length, b; ++v < _; ) f[(b = h[v]).i] = b.x(d);
+            return f.join("");
+          };
+        };
+      }
+      var WCe, XCe, ZCe = gu(() => {
+        YE();
+        HCe();
+        WCe = jCe(VCe, "px, ", "px)", "deg)"), XCe = jCe(GCe, ", ", ")", ")");
+      });
+      function YCe(e) {
+        return ((e = Math.exp(e)) + 1 / e) / 2;
+      }
+      function K6t(e) {
+        return ((e = Math.exp(e)) - 1 / e) / 2;
+      }
+      function J6t(e) {
+        return ((e = Math.exp(2 * e)) - 1) / (e + 1);
+      }
+      var Y6t, KCe, JCe = gu(() => {
+        Y6t = 1e-12;
+        KCe = function e(t, r, n) {
+          function i(a, o) {
+            var s = a[0], l = a[1], u = a[2], c = o[0], f = o[1], h = o[2], d = c - s, v = f - l, _ = d * d + v * v, b, p;
+            if (_ < Y6t) p = Math.log(h / u) / t, b = function(C) {
+              return [s + C * d, l + C * v, u * Math.exp(t * C * p)];
+            };
+            else {
+              var k = Math.sqrt(_), E = (h * h - u * u + n * _) / (2 * u * r * k), T = (h * h - u * u - n * _) / (2 * h * r * k), L = Math.log(Math.sqrt(E * E + 1) - E), x = Math.log(Math.sqrt(T * T + 1) - T);
+              p = (x - L) / t, b = function(C) {
+                var M = C * p, g = YCe(L), P = u / (r * k) * (g * J6t(t * M + L) - K6t(L));
+                return [s + P * d, l + P * v, u * g / YCe(t * M + L)];
+              };
+            }
+            return b.duration = p * 1e3 * t / Math.SQRT2, b;
+          }
+          return i.rho = function(a) {
+            var o = Math.max(1e-3, +a), s = o * o, l = s * s;
+            return e(o, s, l);
+          }, i;
+        }(Math.SQRT2, 2, 4);
+      });
+      function $Ce(e) {
+        return function(t, r) {
+          var n = e((t = HE(t)).h, (r = HE(r)).h), i = $f(t.s, r.s), a = $f(t.l, r.l), o = $f(t.opacity, r.opacity);
+          return function(s) {
+            return t.h = n(s), t.s = i(s), t.l = a(s), t.opacity = o(s), t + "";
+          };
+        };
+      }
+      var QCe, e6e, t6e = gu(() => {
+        U2();
+        V2();
+        QCe = $Ce(tx), e6e = $Ce($f);
+      });
+      function XW(e, t) {
+        var r = $f((e = DA(e)).l, (t = DA(t)).l), n = $f(e.a, t.a), i = $f(e.b, t.b), a = $f(e.opacity, t.opacity);
+        return function(o) {
+          return e.l = r(o), e.a = n(o), e.b = i(o), e.opacity = a(o), e + "";
+        };
+      }
+      var r6e = gu(() => {
+        U2();
+        V2();
+      });
+      function i6e(e) {
+        return function(t, r) {
+          var n = e((t = jE(t)).h, (r = jE(r)).h), i = $f(t.c, r.c), a = $f(t.l, r.l), o = $f(t.opacity, r.opacity);
+          return function(s) {
+            return t.h = n(s), t.c = i(s), t.l = a(s), t.opacity = o(s), t + "";
+          };
+        };
+      }
+      var n6e, a6e, o6e = gu(() => {
+        U2();
+        V2();
+        n6e = i6e(tx), a6e = i6e($f);
+      });
+      function s6e(e) {
+        return function t(r) {
+          r = +r;
+          function n(i, a) {
+            var o = e((i = FA(i)).h, (a = FA(a)).h), s = $f(i.s, a.s), l = $f(i.l, a.l), u = $f(i.opacity, a.opacity);
+            return function(c) {
+              return i.h = o(c), i.s = s(c), i.l = l(Math.pow(c, r)), i.opacity = u(c), i + "";
+            };
+          }
+          return n.gamma = t, n;
+        }(1);
+      }
+      var l6e, u6e, c6e = gu(() => {
+        U2();
+        V2();
+        l6e = s6e(tx), u6e = s6e($f);
+      });
+      function ZW(e, t) {
+        t === void 0 && (t = e, e = rx);
+        for (var r = 0, n = t.length - 1, i = t[0], a = new Array(n < 0 ? 0 : n); r < n; ) a[r] = e(i, i = t[++r]);
+        return function(o) {
+          var s = Math.max(0, Math.min(n - 1, Math.floor(o *= n)));
+          return a[s](o - s);
+        };
+      }
+      var f6e = gu(() => {
+        ZE();
+      });
+      function h6e(e, t) {
+        for (var r = new Array(t), n = 0; n < t; ++n) r[n] = e(n / (t - 1));
+        return r;
+      }
+      var d6e = gu(() => {
+      });
+      var G2 = {};
+      mee(G2, { interpolate: () => rx, interpolateArray: () => RCe, interpolateBasis: () => DD, interpolateBasisClosed: () => zD, interpolateCubehelix: () => l6e, interpolateCubehelixLong: () => u6e, interpolateDate: () => BD, interpolateDiscrete: () => DCe, interpolateHcl: () => n6e, interpolateHclLong: () => a6e, interpolateHsl: () => QCe, interpolateHslLong: () => e6e, interpolateHue: () => zCe, interpolateLab: () => XW, interpolateNumber: () => zp, interpolateNumberArray: () => OA, interpolateObject: () => ND, interpolateRgb: () => XE, interpolateRgbBasis: () => PCe, interpolateRgbBasisClosed: () => ICe, interpolateRound: () => qCe, interpolateString: () => UD, interpolateTransformCss: () => WCe, interpolateTransformSvg: () => XCe, interpolateZoom: () => KCe, piecewise: () => ZW, quantize: () => h6e });
+      var H2 = gu(() => {
+        ZE();
+        NW();
+        FD();
+        zW();
+        UW();
+        FCe();
+        OCe();
+        YE();
+        qD();
+        VW();
+        BCe();
+        jW();
+        ZCe();
+        JCe();
+        qW();
+        t6e();
+        r6e();
+        o6e();
+        c6e();
+        f6e();
+        d6e();
+      });
+      var HD = ye((s0r, v6e) => {
+        var $6t = So(), Q6t = ka();
+        v6e.exports = function(t, r, n, i, a) {
+          var o = r.data.data, s = o.i, l = a || o.color;
+          if (s >= 0) {
+            r.i = o.i;
+            var u = n.marker;
+            u.pattern ? (!u.colors || !u.pattern.shape) && (u.color = l, r.color = l) : (u.color = l, r.color = l), $6t.pointStyle(t, n, i, r);
+          } else Q6t.fill(t, l);
+        };
+      });
+      var YW = ye((l0r, _6e) => {
+        var p6e = Oa(), g6e = ka(), m6e = Dr(), eLt = bv().resizeText, tLt = HD();
+        function rLt(e) {
+          var t = e._fullLayout._sunburstlayer.selectAll(".trace");
+          eLt(e, t, "sunburst"), t.each(function(r) {
+            var n = p6e.select(this), i = r[0], a = i.trace;
+            n.style("opacity", a.opacity), n.selectAll("path.surface").each(function(o) {
+              p6e.select(this).call(y6e, o, a, e);
+            });
+          });
+        }
+        function y6e(e, t, r, n) {
+          var i = t.data.data, a = !t.children, o = i.i, s = m6e.castOption(r, o, "marker.line.color") || g6e.defaultLine, l = m6e.castOption(r, o, "marker.line.width") || 0;
+          e.call(tLt, t, r, n).style("stroke-width", l).call(g6e.stroke, s).style("opacity", a ? r.leaf.opacity : null);
+        }
+        _6e.exports = { style: rLt, styleOne: y6e };
+      });
+      var i1 = ye((Bs) => {
+        var j2 = Dr(), iLt = ka(), nLt = Eg(), x6e = g_();
+        Bs.findEntryWithLevel = function(e, t) {
+          var r;
+          return t && e.eachAfter(function(n) {
+            if (Bs.getPtId(n) === t) return r = n.copy();
+          }), r || e;
+        };
+        Bs.findEntryWithChild = function(e, t) {
+          var r;
+          return e.eachAfter(function(n) {
+            for (var i = n.children || [], a = 0; a < i.length; a++) {
+              var o = i[a];
+              if (Bs.getPtId(o) === t) return r = n.copy();
+            }
+          }), r || e;
+        };
+        Bs.isEntry = function(e) {
+          return !e.parent;
+        };
+        Bs.isLeaf = function(e) {
+          return !e.children;
+        };
+        Bs.getPtId = function(e) {
+          return e.data.data.id;
+        };
+        Bs.getPtLabel = function(e) {
+          return e.data.data.label;
+        };
+        Bs.getValue = function(e) {
+          return e.value;
+        };
+        Bs.isHierarchyRoot = function(e) {
+          return b6e(e) === "";
+        };
+        Bs.setSliceCursor = function(e, t, r) {
+          var n = r.isTransitioning;
+          if (!n) {
+            var i = e.datum();
+            n = r.hideOnRoot && Bs.isHierarchyRoot(i) || r.hideOnLeaves && Bs.isLeaf(i);
+          }
+          nLt(e, n ? null : "pointer");
+        };
+        function aLt(e, t, r) {
+          return { color: Bs.getOutsideTextFontKey("color", e, t, r), family: Bs.getOutsideTextFontKey("family", e, t, r), size: Bs.getOutsideTextFontKey("size", e, t, r), weight: Bs.getOutsideTextFontKey("weight", e, t, r), style: Bs.getOutsideTextFontKey("style", e, t, r), variant: Bs.getOutsideTextFontKey("variant", e, t, r), textcase: Bs.getOutsideTextFontKey("textcase", e, t, r), lineposition: Bs.getOutsideTextFontKey("lineposition", e, t, r), shadow: Bs.getOutsideTextFontKey("shadow", e, t, r) };
+        }
+        function oLt(e, t, r, n) {
+          var i = (n || {}).onPathbar, a = t.data.data, o = a.i, s = j2.castOption(e, o, (i ? "pathbar.textfont" : "insidetextfont") + ".color");
+          return !s && e._input.textfont && (s = j2.castOption(e._input, o, "textfont.color")), { color: s || iLt.contrast(a.color), family: Bs.getInsideTextFontKey("family", e, t, r, n), size: Bs.getInsideTextFontKey("size", e, t, r, n), weight: Bs.getInsideTextFontKey("weight", e, t, r, n), style: Bs.getInsideTextFontKey("style", e, t, r, n), variant: Bs.getInsideTextFontKey("variant", e, t, r, n), textcase: Bs.getInsideTextFontKey("textcase", e, t, r, n), lineposition: Bs.getInsideTextFontKey("lineposition", e, t, r, n), shadow: Bs.getInsideTextFontKey("shadow", e, t, r, n) };
+        }
+        Bs.getInsideTextFontKey = function(e, t, r, n, i) {
+          var a = (i || {}).onPathbar, o = a ? "pathbar.textfont" : "insidetextfont", s = r.data.data.i;
+          return j2.castOption(t, s, o + "." + e) || j2.castOption(t, s, "textfont." + e) || n.size;
+        };
+        Bs.getOutsideTextFontKey = function(e, t, r, n) {
+          var i = r.data.data.i;
+          return j2.castOption(t, i, "outsidetextfont." + e) || j2.castOption(t, i, "textfont." + e) || n.size;
+        };
+        Bs.isOutsideText = function(e, t) {
+          return !e._hasColorscale && Bs.isHierarchyRoot(t);
+        };
+        Bs.determineTextFont = function(e, t, r, n) {
+          return Bs.isOutsideText(e, t) ? aLt(e, t, r) : oLt(e, t, r, n);
+        };
+        Bs.hasTransition = function(e) {
+          return !!(e && e.duration > 0);
+        };
+        Bs.getMaxDepth = function(e) {
+          return e.maxdepth >= 0 ? e.maxdepth : 1 / 0;
+        };
+        Bs.isHeader = function(e, t) {
+          return !(Bs.isLeaf(e) || e.depth === t._maxDepth - 1);
+        };
+        function b6e(e) {
+          return e.data.data.pid;
+        }
+        Bs.getParent = function(e, t) {
+          return Bs.findEntryWithLevel(e, b6e(t));
+        };
+        Bs.listPath = function(e, t) {
+          var r = e.parent;
+          if (!r) return [];
+          var n = t ? [r.data[t]] : [r];
+          return Bs.listPath(r, t).concat(n);
+        };
+        Bs.getPath = function(e) {
+          return Bs.listPath(e, "label").join("/") + "/";
+        };
+        Bs.formatValue = x6e.formatPieValue;
+        Bs.formatPercent = function(e, t) {
+          var r = j2.formatPercent(e, 0);
+          return r === "0%" && (r = x6e.formatPiePercent(e, t)), r;
+        };
+      });
+      var $E = ye((c0r, A6e) => {
+        var qA = Oa(), w6e = qa(), sLt = ip().appendArrayPointValue, KE = vf(), T6e = Dr(), lLt = k3(), id = i1(), uLt = g_(), cLt = uLt.formatPieValue;
+        A6e.exports = function(t, r, n, i, a) {
+          var o = i[0], s = o.trace, l = o.hierarchy, u = s.type === "sunburst", c = s.type === "treemap" || s.type === "icicle";
+          "_hasHoverLabel" in s || (s._hasHoverLabel = false), "_hasHoverEvent" in s || (s._hasHoverEvent = false);
+          var f = function(v) {
+            var _ = n._fullLayout;
+            if (!(n._dragging || _.hovermode === false)) {
+              var b = n._fullData[s.index], p = v.data.data, k = p.i, E = id.isHierarchyRoot(v), T = id.getParent(l, v), L = id.getValue(v), x = function(Ce) {
+                return T6e.castOption(b, k, Ce);
+              }, C = x("hovertemplate"), M = KE.castHoverinfo(b, _, k), g = _.separators, P;
+              if (C || M && M !== "none" && M !== "skip") {
+                var A, z;
+                u && (A = o.cx + v.pxmid[0] * (1 - v.rInscribed), z = o.cy + v.pxmid[1] * (1 - v.rInscribed)), c && (A = v._hoverX, z = v._hoverY);
+                var O = {}, U = [], G = [], Z = function(Ce) {
+                  return U.indexOf(Ce) !== -1;
+                };
+                M && (U = M === "all" ? b._module.attributes.hoverinfo.flags : M.split("+")), O.label = p.label, Z("label") && O.label && G.push(O.label), p.hasOwnProperty("v") && (O.value = p.v, O.valueLabel = cLt(O.value, g), Z("value") && G.push(O.valueLabel)), O.currentPath = v.currentPath = id.getPath(v.data), Z("current path") && !E && G.push(O.currentPath);
+                var j, N = [], H = function() {
+                  N.indexOf(j) === -1 && (G.push(j), N.push(j));
+                };
+                O.percentParent = v.percentParent = L / id.getValue(T), O.parent = v.parentString = id.getPtLabel(T), Z("percent parent") && (j = id.formatPercent(O.percentParent, g) + " of " + O.parent, H()), O.percentEntry = v.percentEntry = L / id.getValue(r), O.entry = v.entry = id.getPtLabel(r), Z("percent entry") && !E && !v.onPathbar && (j = id.formatPercent(O.percentEntry, g) + " of " + O.entry, H()), O.percentRoot = v.percentRoot = L / id.getValue(l), O.root = v.root = id.getPtLabel(l), Z("percent root") && !E && (j = id.formatPercent(O.percentRoot, g) + " of " + O.root, H()), O.text = x("hovertext") || x("text"), Z("text") && (j = O.text, T6e.isValidTextValue(j) && G.push(j)), P = [JE(v, b, a.eventDataKeys)];
+                var re = { trace: b, y: z, _x0: v._x0, _x1: v._x1, _y0: v._y0, _y1: v._y1, text: G.join("<br>"), name: C || Z("name") ? b.name : void 0, color: x("hoverlabel.bgcolor") || p.color, borderColor: x("hoverlabel.bordercolor"), fontFamily: x("hoverlabel.font.family"), fontSize: x("hoverlabel.font.size"), fontColor: x("hoverlabel.font.color"), fontWeight: x("hoverlabel.font.weight"), fontStyle: x("hoverlabel.font.style"), fontVariant: x("hoverlabel.font.variant"), nameLength: x("hoverlabel.namelength"), textAlign: x("hoverlabel.align"), hovertemplate: C, hovertemplateLabels: O, eventData: P };
+                u && (re.x0 = A - v.rInscribed * v.rpx1, re.x1 = A + v.rInscribed * v.rpx1, re.idealAlign = v.pxmid[0] < 0 ? "left" : "right"), c && (re.x = A, re.idealAlign = A < 0 ? "left" : "right");
+                var oe = [];
+                KE.loneHover(re, { container: _._hoverlayer.node(), outerContainer: _._paper.node(), gd: n, inOut_bbox: oe }), P[0].bbox = oe[0], s._hasHoverLabel = true;
+              }
+              if (c) {
+                var _e = t.select("path.surface");
+                a.styleOne(_e, v, b, n, { hovered: true });
+              }
+              s._hasHoverEvent = true, n.emit("plotly_hover", { points: P || [JE(v, b, a.eventDataKeys)], event: qA.event });
+            }
+          }, h = function(v) {
+            var _ = n._fullLayout, b = n._fullData[s.index], p = qA.select(this).datum();
+            if (s._hasHoverEvent && (v.originalEvent = qA.event, n.emit("plotly_unhover", { points: [JE(p, b, a.eventDataKeys)], event: qA.event }), s._hasHoverEvent = false), s._hasHoverLabel && (KE.loneUnhover(_._hoverlayer.node()), s._hasHoverLabel = false), c) {
+              var k = t.select("path.surface");
+              a.styleOne(k, p, b, n, { hovered: false });
+            }
+          }, d = function(v) {
+            var _ = n._fullLayout, b = n._fullData[s.index], p = u && (id.isHierarchyRoot(v) || id.isLeaf(v)), k = id.getPtId(v), E = id.isEntry(v) ? id.findEntryWithChild(l, k) : id.findEntryWithLevel(l, k), T = id.getPtId(E), L = { points: [JE(v, b, a.eventDataKeys)], event: qA.event };
+            p || (L.nextLevel = T);
+            var x = lLt.triggerHandler(n, "plotly_" + s.type + "click", L);
+            if (x !== false && _.hovermode && (n._hoverdata = [JE(v, b, a.eventDataKeys)], KE.click(n, qA.event)), !p && x !== false && !n._dragging && !n._transitioning) {
+              w6e.call("_storeDirectGUIEdit", b, _._tracePreGUI[b.uid], { level: b.level });
+              var C = { data: [{ level: T }], traces: [s.index] }, M = { frame: { redraw: false, duration: a.transitionTime }, transition: { duration: a.transitionTime, easing: a.transitionEasing }, mode: "immediate", fromcurrent: true };
+              KE.loneUnhover(_._hoverlayer.node()), w6e.call("animate", n, C, M);
+            }
+          };
+          t.on("mouseover", f), t.on("mouseout", h), t.on("click", d);
+        };
+        function JE(e, t, r) {
+          for (var n = e.data.data, i = { curveNumber: t.index, pointNumber: n.i, data: t._input, fullData: t }, a = 0; a < r.length; a++) {
+            var o = r[a];
+            o in e && (i[o] = e[o]);
+          }
+          return "parentString" in e && !id.isHierarchyRoot(e) && (i.parent = e.parentString), sLt(i, t, n.i), i;
+        }
+      });
+      var WD = ye((jD) => {
+        var QE = Oa(), fLt = BE(), Jg = (H2(), pb(G2)).interpolate, S6e = So(), Av = Dr(), hLt = Zl(), C6e = bv(), M6e = C6e.recordMinTextSize, dLt = C6e.clearMinTextSize, L6e = TD(), vLt = g_().getRotationAngle, pLt = L6e.computeTransform, gLt = L6e.transformInsideText, mLt = YW().styleOne, yLt = V0().resizeText, _Lt = $E(), KW = SW(), Rl = i1();
+        jD.plot = function(e, t, r, n) {
+          var i = e._fullLayout, a = i._sunburstlayer, o, s, l = !r, u = !i.uniformtext.mode && Rl.hasTransition(r);
+          if (dLt("sunburst", i), o = a.selectAll("g.trace.sunburst").data(t, function(f) {
+            return f[0].trace.uid;
+          }), o.enter().append("g").classed("trace", true).classed("sunburst", true).attr("stroke-linejoin", "round"), o.order(), u) {
+            n && (s = n());
+            var c = QE.transition().duration(r.duration).ease(r.easing).each("end", function() {
+              s && s();
+            }).each("interrupt", function() {
+              s && s();
+            });
+            c.each(function() {
+              a.selectAll("g.trace").each(function(f) {
+                E6e(e, f, this, r);
+              });
+            });
+          } else o.each(function(f) {
+            E6e(e, f, this, r);
+          }), i.uniformtext.mode && yLt(e, i._sunburstlayer.selectAll(".trace"), "sunburst");
+          l && o.exit().remove();
+        };
+        function E6e(e, t, r, n) {
+          var i = e._context.staticPlot, a = e._fullLayout, o = !a.uniformtext.mode && Rl.hasTransition(n), s = QE.select(r), l = s.selectAll("g.slice"), u = t[0], c = u.trace, f = u.hierarchy, h = Rl.findEntryWithLevel(f, c.level), d = Rl.getMaxDepth(c), v = a._size, _ = c.domain, b = v.w * (_.x[1] - _.x[0]), p = v.h * (_.y[1] - _.y[0]), k = 0.5 * Math.min(b, p), E = u.cx = v.l + v.w * (_.x[1] + _.x[0]) / 2, T = u.cy = v.t + v.h * (1 - _.y[0]) - p / 2;
+          if (!h) return l.remove();
+          var L = null, x = {};
+          o && l.each(function(ge) {
+            x[Rl.getPtId(ge)] = { rpx0: ge.rpx0, rpx1: ge.rpx1, x0: ge.x0, x1: ge.x1, transform: ge.transform }, !L && Rl.isEntry(ge) && (L = ge);
+          });
+          var C = xLt(h).descendants(), M = h.height + 1, g = 0, P = d;
+          u.hasMultipleRoots && Rl.isHierarchyRoot(h) && (C = C.slice(1), M -= 1, g = 1, P += 1), C = C.filter(function(ge) {
+            return ge.y1 <= P;
+          });
+          var A = vLt(c.rotation);
+          A && C.forEach(function(ge) {
+            ge.x0 += A, ge.x1 += A;
+          });
+          var z = Math.min(M, d), O = function(ge) {
+            return (ge - g) / z * k;
+          }, U = function(ge, ie) {
+            return [ge * Math.cos(ie), -ge * Math.sin(ie)];
+          }, G = function(ge) {
+            return Av.pathAnnulus(ge.rpx0, ge.rpx1, ge.x0, ge.x1, E, T);
+          }, Z = function(ge) {
+            return E + k6e(ge)[0] * (ge.transform.rCenter || 0) + (ge.transform.x || 0);
+          }, j = function(ge) {
+            return T + k6e(ge)[1] * (ge.transform.rCenter || 0) + (ge.transform.y || 0);
+          };
+          l = l.data(C, Rl.getPtId), l.enter().append("g").classed("slice", true), o ? l.exit().transition().each(function() {
+            var ge = QE.select(this), ie = ge.select("path.surface");
+            ie.transition().attrTween("d", function(Ee) {
+              var Ae = oe(Ee);
+              return function(Be) {
+                return G(Ae(Be));
+              };
+            });
+            var Se = ge.select("g.slicetext");
+            Se.attr("opacity", 0);
+          }).remove() : l.exit().remove(), l.order();
+          var N = null;
+          if (o && L) {
+            var H = Rl.getPtId(L);
+            l.each(function(ge) {
+              N === null && Rl.getPtId(ge) === H && (N = ge.x1);
+            });
+          }
+          var re = l;
+          o && (re = re.transition().each("end", function() {
+            var ge = QE.select(this);
+            Rl.setSliceCursor(ge, e, { hideOnRoot: true, hideOnLeaves: true, isTransitioning: false });
+          })), re.each(function(ge) {
+            var ie = QE.select(this), Se = Av.ensureSingle(ie, "path", "surface", function(De) {
+              De.style("pointer-events", i ? "none" : "all");
+            });
+            ge.rpx0 = O(ge.y0), ge.rpx1 = O(ge.y1), ge.xmid = (ge.x0 + ge.x1) / 2, ge.pxmid = U(ge.rpx1, ge.xmid), ge.midangle = -(ge.xmid - Math.PI / 2), ge.startangle = -(ge.x0 - Math.PI / 2), ge.stopangle = -(ge.x1 - Math.PI / 2), ge.halfangle = 0.5 * Math.min(Av.angleDelta(ge.x0, ge.x1) || Math.PI, Math.PI), ge.ring = 1 - ge.rpx0 / ge.rpx1, ge.rInscribed = bLt(ge), o ? Se.transition().attrTween("d", function(De) {
+              var ce = _e(De);
+              return function(je) {
+                return G(ce(je));
+              };
+            }) : Se.attr("d", G), ie.call(_Lt, h, e, t, { eventDataKeys: KW.eventDataKeys, transitionTime: KW.CLICK_TRANSITION_TIME, transitionEasing: KW.CLICK_TRANSITION_EASING }).call(Rl.setSliceCursor, e, { hideOnRoot: true, hideOnLeaves: true, isTransitioning: e._transitioning }), Se.call(mLt, ge, c, e);
+            var Ee = Av.ensureSingle(ie, "g", "slicetext"), Ae = Av.ensureSingle(Ee, "text", "", function(De) {
+              De.attr("data-notex", 1);
+            }), Be = Av.ensureUniformFontSize(e, Rl.determineTextFont(c, ge, a.font));
+            Ae.text(jD.formatSliceLabel(ge, h, c, t, a)).classed("slicetext", true).attr("text-anchor", "middle").call(S6e.font, Be).call(hLt.convertToTspans, e);
+            var Pe = S6e.bBox(Ae.node());
+            ge.transform = gLt(Pe, ge, u), ge.transform.targetX = Z(ge), ge.transform.targetY = j(ge);
+            var me = function(De, ce) {
+              var je = De.transform;
+              return pLt(je, ce), je.fontSize = Be.size, M6e(c.type, je, a), Av.getTextTransform(je);
+            };
+            o ? Ae.transition().attrTween("transform", function(De) {
+              var ce = Ce(De);
+              return function(je) {
+                return me(ce(je), Pe);
+              };
+            }) : Ae.attr("transform", me(ge, Pe));
+          });
+          function oe(ge) {
+            var ie = Rl.getPtId(ge), Se = x[ie], Ee = x[Rl.getPtId(h)], Ae;
+            if (Ee) {
+              var Be = (ge.x1 > Ee.x1 ? 2 * Math.PI : 0) + A;
+              Ae = ge.rpx1 < Ee.rpx1 ? { x0: ge.x0, x1: ge.x1, rpx0: 0, rpx1: 0 } : { x0: Be, x1: Be, rpx0: ge.rpx0, rpx1: ge.rpx1 };
+            } else {
+              var Pe, me = Rl.getPtId(ge.parent);
+              l.each(function(pt) {
+                if (Rl.getPtId(pt) === me) return Pe = pt;
+              });
+              var De = Pe.children, ce;
+              De.forEach(function(pt, Vt) {
+                if (Rl.getPtId(pt) === ie) return ce = Vt;
+              });
+              var je = De.length, lt = Jg(Pe.x0, Pe.x1);
+              Ae = { rpx0: k, rpx1: k, x0: lt(ce / je), x1: lt((ce + 1) / je) };
+            }
+            return Jg(Se, Ae);
+          }
+          function _e(ge) {
+            var ie = x[Rl.getPtId(ge)], Se, Ee = { x0: ge.x0, x1: ge.x1, rpx0: ge.rpx0, rpx1: ge.rpx1 };
+            if (ie) Se = ie;
+            else if (L) if (ge.parent) if (N) {
+              var Ae = (ge.x1 > N ? 2 * Math.PI : 0) + A;
+              Se = { x0: Ae, x1: Ae };
+            } else Se = { rpx0: k, rpx1: k }, Av.extendFlat(Se, Le(ge));
+            else Se = { rpx0: 0, rpx1: 0 };
+            else Se = { x0: A, x1: A };
+            return Jg(Se, Ee);
+          }
+          function Ce(ge) {
+            var ie = x[Rl.getPtId(ge)], Se, Ee = ge.transform;
+            if (ie) Se = ie;
+            else if (Se = { rpx1: ge.rpx1, transform: { textPosAngle: Ee.textPosAngle, scale: 0, rotate: Ee.rotate, rCenter: Ee.rCenter, x: Ee.x, y: Ee.y } }, L) if (ge.parent) if (N) {
+              var Ae = ge.x1 > N ? 2 * Math.PI : 0;
+              Se.x0 = Se.x1 = Ae;
+            } else Av.extendFlat(Se, Le(ge));
+            else Se.x0 = Se.x1 = A;
+            else Se.x0 = Se.x1 = A;
+            var Be = Jg(Se.transform.textPosAngle, ge.transform.textPosAngle), Pe = Jg(Se.rpx1, ge.rpx1), me = Jg(Se.x0, ge.x0), De = Jg(Se.x1, ge.x1), ce = Jg(Se.transform.scale, Ee.scale), je = Jg(Se.transform.rotate, Ee.rotate), lt = Ee.rCenter === 0 ? 3 : Se.transform.rCenter === 0 ? 1 / 3 : 1, pt = Jg(Se.transform.rCenter, Ee.rCenter), Vt = function(ot) {
+              return pt(Math.pow(ot, lt));
+            };
+            return function(ot) {
+              var ut = Pe(ot);
+              me(ot);
+              De(ot);
+              var $t = Vt(ot), Tr = Be(ot), fr = { rpx1: ut, transform: { textPosAngle: Tr, rCenter: $t, x: Ee.x, y: Ee.y } };
+              return M6e(c.type, Ee, a), { transform: { targetX: Z(fr), targetY: j(fr), scale: ce(ot), rotate: je(ot), rCenter: $t } };
+            };
+          }
+          function Le(ge) {
+            var ie = ge.parent, Se = x[Rl.getPtId(ie)], Ee = {};
+            if (Se) {
+              var Ae = ie.children, Be = Ae.indexOf(ge), Pe = Ae.length, me = Jg(Se.x0, Se.x1);
+              Ee.x0 = me(Be / Pe), Ee.x1 = me(Be / Pe);
+            } else Ee.x0 = Ee.x1 = 0;
+            return Ee;
+          }
+        }
+        function xLt(e) {
+          return fLt.partition().size([2 * Math.PI, e.height + 1])(e);
+        }
+        jD.formatSliceLabel = function(e, t, r, n, i) {
+          var a = r.texttemplate, o = r.textinfo;
+          if (!a && (!o || o === "none")) return "";
+          var s = i.separators, l = n[0], u = e.data.data, c = l.hierarchy, f = Rl.isHierarchyRoot(e), h = Rl.getParent(c, e), d = Rl.getValue(e);
+          if (!a) {
+            var v = o.split("+"), _ = function(g) {
+              return v.indexOf(g) !== -1;
+            }, b = [], p;
+            if (_("label") && u.label && b.push(u.label), u.hasOwnProperty("v") && _("value") && b.push(Rl.formatValue(u.v, s)), !f) {
+              _("current path") && b.push(Rl.getPath(e.data));
+              var k = 0;
+              _("percent parent") && k++, _("percent entry") && k++, _("percent root") && k++;
+              var E = k > 1;
+              if (k) {
+                var T, L = function(g) {
+                  p = Rl.formatPercent(T, s), E && (p += " of " + g), b.push(p);
+                };
+                _("percent parent") && !f && (T = d / Rl.getValue(h), L("parent")), _("percent entry") && (T = d / Rl.getValue(t), L("entry")), _("percent root") && (T = d / Rl.getValue(c), L("root"));
+              }
+            }
+            return _("text") && (p = Av.castOption(r, u.i, "text"), Av.isValidTextValue(p) && b.push(p)), b.join("<br>");
+          }
+          var x = Av.castOption(r, u.i, "texttemplate");
+          if (!x) return "";
+          var C = {};
+          u.label && (C.label = u.label), u.hasOwnProperty("v") && (C.value = u.v, C.valueLabel = Rl.formatValue(u.v, s)), C.currentPath = Rl.getPath(e.data), f || (C.percentParent = d / Rl.getValue(h), C.percentParentLabel = Rl.formatPercent(C.percentParent, s), C.parent = Rl.getPtLabel(h)), C.percentEntry = d / Rl.getValue(t), C.percentEntryLabel = Rl.formatPercent(C.percentEntry, s), C.entry = Rl.getPtLabel(t), C.percentRoot = d / Rl.getValue(c), C.percentRootLabel = Rl.formatPercent(C.percentRoot, s), C.root = Rl.getPtLabel(c), u.hasOwnProperty("color") && (C.color = u.color);
+          var M = Av.castOption(r, u.i, "text");
+          return (Av.isValidTextValue(M) || M === "") && (C.text = M), C.customdata = Av.castOption(r, u.i, "customdata"), Av.texttemplateString({ data: [C, r._meta], fallback: r.texttemplatefallback, labels: C, locale: i._d3locale, template: x });
+        };
+        function bLt(e) {
+          return e.rpx0 === 0 && Av.isFullCircle([e.x0, e.x1]) ? 1 : Math.max(0, Math.min(1 / (1 + 1 / Math.sin(e.halfangle)), e.ring / 2));
+        }
+        function k6e(e) {
+          return wLt(e.rpx1, e.transform.textPosAngle);
+        }
+        function wLt(e, t) {
+          return [e * Math.sin(t), -e * Math.cos(t)];
+        }
+      });
+      var I6e = ye((h0r, P6e) => {
+        P6e.exports = { moduleType: "trace", name: "sunburst", basePlotModule: jke(), categories: [], animatable: true, attributes: qE(), layoutAttributes: MW(), supplyDefaults: eCe(), supplyLayoutDefaults: rCe(), calc: UE().calc, crossTraceCalc: UE().crossTraceCalc, plot: WD().plot, style: YW().style, colorbar: $d(), meta: {} };
+      });
+      var D6e = ye((d0r, R6e) => {
+        R6e.exports = I6e();
+      });
+      var z6e = ye((BA) => {
+        var F6e = Mc();
+        BA.name = "treemap";
+        BA.plot = function(e, t, r, n) {
+          F6e.plotBasePlot(BA.name, e, t, r, n);
+        };
+        BA.clean = function(e, t, r, n) {
+          F6e.cleanBasePlot(BA.name, e, t, r, n);
+        };
+      });
+      var W2 = ye((p0r, O6e) => {
+        O6e.exports = { CLICK_TRANSITION_TIME: 750, CLICK_TRANSITION_EASING: "poly", eventDataKeys: ["currentPath", "root", "entry", "percentRoot", "percentEntry", "percentParent"], gapWithPathbar: 1 };
+      });
+      var XD = ye((g0r, N6e) => {
+        var { hovertemplateAttrs: TLt, texttemplateAttrs: ALt, templatefallbackAttrs: q6e } = Ll(), SLt = Tu(), MLt = Cc().attributes, X2 = F2(), tg = qE(), B6e = W2(), JW = Ao().extendFlat, ELt = Pd().pattern;
+        N6e.exports = { labels: tg.labels, parents: tg.parents, values: tg.values, branchvalues: tg.branchvalues, count: tg.count, level: tg.level, maxdepth: tg.maxdepth, tiling: { packing: { valType: "enumerated", values: ["squarify", "binary", "dice", "slice", "slice-dice", "dice-slice"], dflt: "squarify", editType: "plot" }, squarifyratio: { valType: "number", min: 1, dflt: 1, editType: "plot" }, flip: { valType: "flaglist", flags: ["x", "y"], dflt: "", editType: "plot" }, pad: { valType: "number", min: 0, dflt: 3, editType: "plot" }, editType: "calc" }, marker: JW({ pad: { t: { valType: "number", min: 0, editType: "plot" }, l: { valType: "number", min: 0, editType: "plot" }, r: { valType: "number", min: 0, editType: "plot" }, b: { valType: "number", min: 0, editType: "plot" }, editType: "calc" }, colors: tg.marker.colors, pattern: ELt, depthfade: { valType: "enumerated", values: [true, false, "reversed"], editType: "style" }, line: tg.marker.line, cornerradius: { valType: "number", min: 0, dflt: 0, editType: "plot" }, editType: "calc" }, SLt("marker", { colorAttr: "colors", anim: false })), pathbar: { visible: { valType: "boolean", dflt: true, editType: "plot" }, side: { valType: "enumerated", values: ["top", "bottom"], dflt: "top", editType: "plot" }, edgeshape: { valType: "enumerated", values: [">", "<", "|", "/", "\\"], dflt: ">", editType: "plot" }, thickness: { valType: "number", min: 12, editType: "plot" }, textfont: JW({}, X2.textfont, {}), editType: "calc" }, text: X2.text, textinfo: tg.textinfo, texttemplate: ALt({ editType: "plot" }, { keys: B6e.eventDataKeys.concat(["label", "value"]) }), texttemplatefallback: q6e({ editType: "plot" }), hovertext: X2.hovertext, hoverinfo: tg.hoverinfo, hovertemplate: TLt({}, { keys: B6e.eventDataKeys }), hovertemplatefallback: q6e(), textfont: X2.textfont, insidetextfont: X2.insidetextfont, outsidetextfont: JW({}, X2.outsidetextfont, {}), textposition: { valType: "enumerated", values: ["top left", "top center", "top right", "middle left", "middle center", "middle right", "bottom left", "bottom center", "bottom right"], dflt: "top left", editType: "plot" }, sort: X2.sort, root: tg.root, domain: MLt({ name: "treemap", trace: true, editType: "calc" }) };
+      });
+      var $W = ye((m0r, U6e) => {
+        U6e.exports = { treemapcolorway: { valType: "colorlist", editType: "calc" }, extendtreemapcolors: { valType: "boolean", dflt: true, editType: "calc" } };
+      });
+      var j6e = ye((y0r, H6e) => {
+        var V6e = Dr(), kLt = XD(), CLt = ka(), LLt = Cc().defaults, PLt = i0().handleText, ILt = A_().TEXTPAD, RLt = z2().handleMarkerDefaults, G6e = tc(), DLt = G6e.hasColorscale, FLt = G6e.handleDefaults;
+        H6e.exports = function(t, r, n, i) {
+          function a(b, p) {
+            return V6e.coerce(t, r, kLt, b, p);
+          }
+          var o = a("labels"), s = a("parents");
+          if (!o || !o.length || !s || !s.length) {
+            r.visible = false;
+            return;
+          }
+          var l = a("values");
+          l && l.length ? a("branchvalues") : a("count"), a("level"), a("maxdepth");
+          var u = a("tiling.packing");
+          u === "squarify" && a("tiling.squarifyratio"), a("tiling.flip"), a("tiling.pad");
+          var c = a("text");
+          a("texttemplate"), a("texttemplatefallback"), r.texttemplate || a("textinfo", V6e.isArrayOrTypedArray(c) ? "text+label" : "label"), a("hovertext"), a("hovertemplate"), a("hovertemplatefallback");
+          var f = a("pathbar.visible"), h = "auto";
+          PLt(t, r, i, a, h, { hasPathbar: f, moduleHasSelected: false, moduleHasUnselected: false, moduleHasConstrain: false, moduleHasCliponaxis: false, moduleHasTextangle: false, moduleHasInsideanchor: false }), a("textposition");
+          var d = r.textposition.indexOf("bottom") !== -1;
+          RLt(t, r, i, a);
+          var v = r._hasColorscale = DLt(t, "marker", "colors") || (t.marker || {}).coloraxis;
+          v ? FLt(t, r, i, a, { prefix: "marker.", cLetter: "c" }) : a("marker.depthfade", !(r.marker.colors || []).length);
+          var _ = r.textfont.size * 2;
+          a("marker.pad.t", d ? _ / 4 : _), a("marker.pad.l", _ / 4), a("marker.pad.r", _ / 4), a("marker.pad.b", d ? _ : _ / 4), a("marker.cornerradius"), r._hovered = { marker: { line: { width: 2, color: CLt.contrast(i.paper_bgcolor) } } }, f && (a("pathbar.thickness", r.pathbar.textfont.size + 2 * ILt), a("pathbar.side"), a("pathbar.edgeshape")), a("sort"), a("root.color"), LLt(r, i, a), r._length = null;
+        };
+      });
+      var X6e = ye((_0r, W6e) => {
+        var zLt = Dr(), OLt = $W();
+        W6e.exports = function(t, r) {
+          function n(i, a) {
+            return zLt.coerce(t, r, OLt, i, a);
+          }
+          n("treemapcolorway", r.colorway), n("extendtreemapcolors");
+        };
+      });
+      var eX = ye((QW) => {
+        var Z6e = UE();
+        QW.calc = function(e, t) {
+          return Z6e.calc(e, t);
+        };
+        QW.crossTraceCalc = function(e) {
+          return Z6e._runCrossTraceCalc("treemap", e);
+        };
+      });
+      var tX = ye((b0r, Y6e) => {
+        Y6e.exports = function e(t, r, n) {
+          var i;
+          n.swapXY && (i = t.x0, t.x0 = t.y0, t.y0 = i, i = t.x1, t.x1 = t.y1, t.y1 = i), n.flipX && (i = t.x0, t.x0 = r[0] - t.x1, t.x1 = r[0] - i), n.flipY && (i = t.y0, t.y0 = r[1] - t.y1, t.y1 = r[1] - i);
+          var a = t.children;
+          if (a) for (var o = 0; o < a.length; o++) e(a[o], r, n);
+        };
+      });
+      var rX = ye((w0r, K6e) => {
+        var NA = BE(), qLt = tX();
+        K6e.exports = function(t, r, n) {
+          var i = n.flipX, a = n.flipY, o = n.packing === "dice-slice", s = n.pad[a ? "bottom" : "top"], l = n.pad[i ? "right" : "left"], u = n.pad[i ? "left" : "right"], c = n.pad[a ? "top" : "bottom"], f;
+          o && (f = l, l = s, s = f, f = u, u = c, c = f);
+          var h = NA.treemap().tile(BLt(n.packing, n.squarifyratio)).paddingInner(n.pad.inner).paddingLeft(l).paddingRight(u).paddingTop(s).paddingBottom(c).size(o ? [r[1], r[0]] : r)(t);
+          return (o || i || a) && qLt(h, r, { swapXY: o, flipX: i, flipY: a }), h;
+        };
+        function BLt(e, t) {
+          switch (e) {
+            case "squarify":
+              return NA.treemapSquarify.ratio(t);
+            case "binary":
+              return NA.treemapBinary;
+            case "dice":
+              return NA.treemapDice;
+            case "slice":
+              return NA.treemapSlice;
+            default:
+              return NA.treemapSliceDice;
+          }
+        }
+      });
+      var ZD = ye((T0r, eLe) => {
+        var J6e = Oa(), UA = ka(), $6e = Dr(), iX = i1(), NLt = bv().resizeText, ULt = HD();
+        function VLt(e) {
+          var t = e._fullLayout._treemaplayer.selectAll(".trace");
+          NLt(e, t, "treemap"), t.each(function(r) {
+            var n = J6e.select(this), i = r[0], a = i.trace;
+            n.style("opacity", a.opacity), n.selectAll("path.surface").each(function(o) {
+              J6e.select(this).call(Q6e, o, a, e, { hovered: false });
+            });
+          });
+        }
+        function Q6e(e, t, r, n, i) {
+          var a = (i || {}).hovered, o = t.data.data, s = o.i, l, u, c = o.color, f = iX.isHierarchyRoot(t), h = 1;
+          if (a) l = r._hovered.marker.line.color, u = r._hovered.marker.line.width;
+          else if (f && c === r.root.color) h = 100, l = "rgba(0,0,0,0)", u = 0;
+          else if (l = $6e.castOption(r, s, "marker.line.color") || UA.defaultLine, u = $6e.castOption(r, s, "marker.line.width") || 0, !r._hasColorscale && !t.onPathbar) {
+            var d = r.marker.depthfade;
+            if (d) {
+              var v = UA.combine(UA.addOpacity(r._backgroundColor, 0.75), c), _;
+              if (d === true) {
+                var b = iX.getMaxDepth(r);
+                isFinite(b) ? iX.isLeaf(t) ? _ = 0 : _ = r._maxVisibleLayers - (t.data.depth - r._entryDepth) : _ = t.data.height + 1;
+              } else _ = t.data.depth - r._entryDepth, r._atRootLevel || _++;
+              if (_ > 0) for (var p = 0; p < _; p++) {
+                var k = 0.5 * p / _;
+                c = UA.combine(UA.addOpacity(v, k), c);
+              }
+            }
+          }
+          e.call(ULt, t, r, n, c).style("stroke-width", u).call(UA.stroke, l).style("opacity", h);
+        }
+        eLe.exports = { style: VLt, styleOne: Q6e };
+      });
+      var aLe = ye((A0r, nLe) => {
+        var tLe = Oa(), YD = Dr(), rLe = So(), GLt = Zl(), HLt = rX(), iLe = ZD().styleOne, nX = W2(), VA = i1(), jLt = $E(), aX = true;
+        nLe.exports = function(t, r, n, i, a) {
+          var o = a.barDifY, s = a.width, l = a.height, u = a.viewX, c = a.viewY, f = a.pathSlice, h = a.toMoveInsideSlice, d = a.strTransform, v = a.hasTransition, _ = a.handleSlicesExit, b = a.makeUpdateSliceInterpolator, p = a.makeUpdateTextInterpolator, k = {}, E = t._context.staticPlot, T = t._fullLayout, L = r[0], x = L.trace, C = L.hierarchy, M = s / x._entryDepth, g = VA.listPath(n.data, "id"), P = HLt(C.copy(), [s, l], { packing: "dice", pad: { inner: 0, top: 0, left: 0, right: 0, bottom: 0 } }).descendants();
+          P = P.filter(function(z) {
+            var O = g.indexOf(z.data.id);
+            return O === -1 ? false : (z.x0 = M * O, z.x1 = M * (O + 1), z.y0 = o, z.y1 = o + l, z.onPathbar = true, true);
+          }), P.reverse(), i = i.data(P, VA.getPtId), i.enter().append("g").classed("pathbar", true), _(i, aX, k, [s, l], f), i.order();
+          var A = i;
+          v && (A = A.transition().each("end", function() {
+            var z = tLe.select(this);
+            VA.setSliceCursor(z, t, { hideOnRoot: false, hideOnLeaves: false, isTransitioning: false });
+          })), A.each(function(z) {
+            z._x0 = u(z.x0), z._x1 = u(z.x1), z._y0 = c(z.y0), z._y1 = c(z.y1), z._hoverX = u(z.x1 - Math.min(s, l) / 2), z._hoverY = c(z.y1 - l / 2);
+            var O = tLe.select(this), U = YD.ensureSingle(O, "path", "surface", function(N) {
+              N.style("pointer-events", E ? "none" : "all");
+            });
+            v ? U.transition().attrTween("d", function(N) {
+              var H = b(N, aX, k, [s, l]);
+              return function(re) {
+                return f(H(re));
+              };
+            }) : U.attr("d", f), O.call(jLt, n, t, r, { styleOne: iLe, eventDataKeys: nX.eventDataKeys, transitionTime: nX.CLICK_TRANSITION_TIME, transitionEasing: nX.CLICK_TRANSITION_EASING }).call(VA.setSliceCursor, t, { hideOnRoot: false, hideOnLeaves: false, isTransitioning: t._transitioning }), U.call(iLe, z, x, t, { hovered: false }), z._text = (VA.getPtLabel(z) || "").split("<br>").join(" ") || "";
+            var G = YD.ensureSingle(O, "g", "slicetext"), Z = YD.ensureSingle(G, "text", "", function(N) {
+              N.attr("data-notex", 1);
+            }), j = YD.ensureUniformFontSize(t, VA.determineTextFont(x, z, T.font, { onPathbar: true }));
+            Z.text(z._text || " ").classed("slicetext", true).attr("text-anchor", "start").call(rLe.font, j).call(GLt.convertToTspans, t), z.textBB = rLe.bBox(Z.node()), z.transform = h(z, { fontSize: j.size, onPathbar: true }), z.transform.fontSize = j.size, v ? Z.transition().attrTween("transform", function(N) {
+              var H = p(N, aX, k, [s, l]);
+              return function(re) {
+                return d(H(re));
+              };
+            }) : Z.attr("transform", d(z));
+          });
+        };
+      });
+      var uLe = ye((S0r, lLe) => {
+        var oLe = Oa(), oX = (H2(), pb(G2)).interpolate, ix = i1(), ek = Dr(), sLe = A_().TEXTPAD, WLt = d2(), XLt = WLt.toMoveInsideBar, ZLt = bv(), sX = ZLt.recordMinTextSize, YLt = W2(), KLt = aLe();
+        function Z2(e) {
+          return ix.isHierarchyRoot(e) ? "" : ix.getPtId(e);
+        }
+        lLe.exports = function(t, r, n, i, a) {
+          var o = t._fullLayout, s = r[0], l = s.trace, u = l.type, c = u === "icicle", f = s.hierarchy, h = ix.findEntryWithLevel(f, l.level), d = oLe.select(n), v = d.selectAll("g.pathbar"), _ = d.selectAll("g.slice");
+          if (!h) {
+            v.remove(), _.remove();
+            return;
+          }
+          var b = ix.isHierarchyRoot(h), p = !o.uniformtext.mode && ix.hasTransition(i), k = ix.getMaxDepth(l), E = function($e) {
+            return $e.data.depth - h.data.depth < k;
+          }, T = o._size, L = l.domain, x = T.w * (L.x[1] - L.x[0]), C = T.h * (L.y[1] - L.y[0]), M = x, g = l.pathbar.thickness, P = l.marker.line.width + YLt.gapWithPathbar, A = l.pathbar.visible ? l.pathbar.side.indexOf("bottom") > -1 ? C + P : -(g + P) : 0, z = { x0: M, x1: M, y0: A, y1: A + g }, O = function($e, St, Qt) {
+            var Gt = l.tiling.pad, _t = function(lr) {
+              return lr - Gt <= St.x0;
+            }, It = function(lr) {
+              return lr + Gt >= St.x1;
+            }, mt = function(lr) {
+              return lr - Gt <= St.y0;
+            }, er = function(lr) {
+              return lr + Gt >= St.y1;
+            };
+            return $e.x0 === St.x0 && $e.x1 === St.x1 && $e.y0 === St.y0 && $e.y1 === St.y1 ? { x0: $e.x0, x1: $e.x1, y0: $e.y0, y1: $e.y1 } : { x0: _t($e.x0 - Gt) ? 0 : It($e.x0 - Gt) ? Qt[0] : $e.x0, x1: _t($e.x1 + Gt) ? 0 : It($e.x1 + Gt) ? Qt[0] : $e.x1, y0: mt($e.y0 - Gt) ? 0 : er($e.y0 - Gt) ? Qt[1] : $e.y0, y1: mt($e.y1 + Gt) ? 0 : er($e.y1 + Gt) ? Qt[1] : $e.y1 };
+          }, U = null, G = {}, Z = {}, j = null, N = function($e, St) {
+            return St ? G[Z2($e)] : Z[Z2($e)];
+          }, H = function($e, St, Qt, Gt) {
+            if (St) return G[Z2(f)] || z;
+            var _t = Z[l.level] || Qt;
+            return E($e) ? O($e, _t, Gt) : {};
+          };
+          s.hasMultipleRoots && b && k++, l._maxDepth = k, l._backgroundColor = o.paper_bgcolor, l._entryDepth = h.data.depth, l._atRootLevel = b;
+          var re = -x / 2 + T.l + T.w * (L.x[1] + L.x[0]) / 2, oe = -C / 2 + T.t + T.h * (1 - (L.y[1] + L.y[0]) / 2), _e = function($e) {
+            return re + $e;
+          }, Ce = function($e) {
+            return oe + $e;
+          }, Le = Ce(0), ge = _e(0), ie = function($e) {
+            return ge + $e;
+          }, Se = function($e) {
+            return Le + $e;
+          };
+          function Ee($e, St) {
+            return $e + "," + St;
+          }
+          var Ae = ie(0), Be = function($e) {
+            $e.x = Math.max(Ae, $e.x);
+          }, Pe = l.pathbar.edgeshape, me = function($e) {
+            var St = ie(Math.max(Math.min($e.x0, $e.x0), 0)), Qt = ie(Math.min(Math.max($e.x1, $e.x1), M)), Gt = Se($e.y0), _t = Se($e.y1), It = g / 2, mt = {}, er = {};
+            mt.x = St, er.x = Qt, mt.y = er.y = (Gt + _t) / 2;
+            var lr = { x: St, y: Gt }, wr = { x: Qt, y: Gt }, Lr = { x: Qt, y: _t }, ti = { x: St, y: _t };
+            return Pe === ">" ? (lr.x -= It, wr.x -= It, Lr.x -= It, ti.x -= It) : Pe === "/" ? (Lr.x -= It, ti.x -= It, mt.x -= It / 2, er.x -= It / 2) : Pe === "\\" ? (lr.x -= It, wr.x -= It, mt.x -= It / 2, er.x -= It / 2) : Pe === "<" && (mt.x -= It, er.x -= It), Be(lr), Be(ti), Be(mt), Be(wr), Be(Lr), Be(er), "M" + Ee(lr.x, lr.y) + "L" + Ee(wr.x, wr.y) + "L" + Ee(er.x, er.y) + "L" + Ee(Lr.x, Lr.y) + "L" + Ee(ti.x, ti.y) + "L" + Ee(mt.x, mt.y) + "Z";
+          }, De = l[c ? "tiling" : "marker"].pad, ce = function($e) {
+            return l.textposition.indexOf($e) !== -1;
+          }, je = ce("top"), lt = ce("left"), pt = ce("right"), Vt = ce("bottom"), ot = function($e) {
+            var St = _e($e.x0), Qt = _e($e.x1), Gt = Ce($e.y0), _t = Ce($e.y1), It = Qt - St, mt = _t - Gt;
+            if (!It || !mt) return "";
+            var er = l.marker.cornerradius || 0, lr = Math.min(er, It / 2, mt / 2);
+            lr && $e.data && $e.data.data && $e.data.data.label && (je && (lr = Math.min(lr, De.t)), lt && (lr = Math.min(lr, De.l)), pt && (lr = Math.min(lr, De.r)), Vt && (lr = Math.min(lr, De.b)));
+            var wr = function(Lr, ti) {
+              return lr ? "a" + Ee(lr, lr) + " 0 0 1 " + Ee(Lr, ti) : "";
+            };
+            return "M" + Ee(St, Gt + lr) + wr(lr, -lr) + "L" + Ee(Qt - lr, Gt) + wr(lr, lr) + "L" + Ee(Qt, _t - lr) + wr(-lr, lr) + "L" + Ee(St + lr, _t) + wr(-lr, -lr) + "Z";
+          }, ut = function($e, St) {
+            var Qt = $e.x0, Gt = $e.x1, _t = $e.y0, It = $e.y1, mt = $e.textBB, er = je || St.isHeader && !Vt, lr = er ? "start" : Vt ? "end" : "middle", wr = ce("right"), Lr = ce("left") || St.onPathbar, ti = Lr ? -1 : wr ? 1 : 0;
+            if (St.isHeader) {
+              if (Qt += (c ? De : De.l) - sLe, Gt -= (c ? De : De.r) - sLe, Qt >= Gt) {
+                var Br = (Qt + Gt) / 2;
+                Qt = Br, Gt = Br;
+              }
+              var Vr;
+              Vt ? (Vr = It - (c ? De : De.b), _t < Vr && Vr < It && (_t = Vr)) : (Vr = _t + (c ? De : De.t), _t < Vr && Vr < It && (It = Vr));
+            }
+            var dt = XLt(Qt, Gt, _t, It, mt, { isHorizontal: false, constrained: true, angle: 0, anchor: lr, leftToRight: ti });
+            return dt.fontSize = St.fontSize, dt.targetX = _e(dt.targetX), dt.targetY = Ce(dt.targetY), isNaN(dt.targetX) || isNaN(dt.targetY) ? {} : (Qt !== Gt && _t !== It && sX(l.type, dt, o), { scale: dt.scale, rotate: dt.rotate, textX: dt.textX, textY: dt.textY, anchorX: dt.anchorX, anchorY: dt.anchorY, targetX: dt.targetX, targetY: dt.targetY });
+          }, Wt = function($e, St) {
+            for (var Qt, Gt = 0, _t = $e; !Qt && Gt < k; ) Gt++, _t = _t.parent, _t ? Qt = N(_t, St) : Gt = k;
+            return Qt || {};
+          }, Nt = function($e, St, Qt, Gt) {
+            var _t = N($e, St), It;
+            if (St) It = z;
+            else {
+              var mt = N(h, St);
+              mt ? It = O($e, mt, Gt) : It = {};
+            }
+            return oX(_t, It);
+          }, $t = function($e, St, Qt, Gt, _t) {
+            var It = N($e, St), mt;
+            if (It) mt = It;
+            else if (St) mt = z;
+            else if (U) if ($e.parent) {
+              var er = j || Qt;
+              er && !St ? mt = O($e, er, Gt) : (mt = {}, ek.extendFlat(mt, Wt($e, St)));
+            } else mt = ek.extendFlat({}, $e), c && (_t.orientation === "h" ? _t.flipX ? mt.x0 = $e.x1 : mt.x1 = 0 : _t.flipY ? mt.y0 = $e.y1 : mt.y1 = 0);
+            else mt = {};
+            return oX(mt, { x0: $e.x0, x1: $e.x1, y0: $e.y0, y1: $e.y1 });
+          }, sr = function($e, St, Qt, Gt) {
+            var _t = N($e, St), It = {}, mt = H($e, St, Qt, Gt);
+            ek.extendFlat(It, { transform: ut({ x0: mt.x0, x1: mt.x1, y0: mt.y0, y1: mt.y1, textBB: $e.textBB, _text: $e._text }, { isHeader: ix.isHeader($e, l) }) }), _t ? It = _t : $e.parent && ek.extendFlat(It, Wt($e, St));
+            var er = $e.transform;
+            return $e.x0 !== $e.x1 && $e.y0 !== $e.y1 && sX(l.type, er, o), oX(It, { transform: { scale: er.scale, rotate: er.rotate, textX: er.textX, textY: er.textY, anchorX: er.anchorX, anchorY: er.anchorY, targetX: er.targetX, targetY: er.targetY } });
+          }, Tr = function($e, St, Qt, Gt, _t) {
+            var It = Gt[0], mt = Gt[1];
+            p ? $e.exit().transition().each(function() {
+              var er = oLe.select(this), lr = er.select("path.surface");
+              lr.transition().attrTween("d", function(Lr) {
+                var ti = Nt(Lr, St, Qt, [It, mt]);
+                return function(Br) {
+                  return _t(ti(Br));
+                };
+              });
+              var wr = er.select("g.slicetext");
+              wr.attr("opacity", 0);
+            }).remove() : $e.exit().remove();
+          }, fr = function($e) {
+            var St = $e.transform;
+            return $e.x0 !== $e.x1 && $e.y0 !== $e.y1 && sX(l.type, St, o), ek.getTextTransform({ textX: St.textX, textY: St.textY, anchorX: St.anchorX, anchorY: St.anchorY, targetX: St.targetX, targetY: St.targetY, scale: St.scale, rotate: St.rotate });
+          };
+          p && (v.each(function($e) {
+            G[Z2($e)] = { x0: $e.x0, x1: $e.x1, y0: $e.y0, y1: $e.y1 }, $e.transform && (G[Z2($e)].transform = { textX: $e.transform.textX, textY: $e.transform.textY, anchorX: $e.transform.anchorX, anchorY: $e.transform.anchorY, targetX: $e.transform.targetX, targetY: $e.transform.targetY, scale: $e.transform.scale, rotate: $e.transform.rotate });
+          }), _.each(function($e) {
+            Z[Z2($e)] = { x0: $e.x0, x1: $e.x1, y0: $e.y0, y1: $e.y1 }, $e.transform && (Z[Z2($e)].transform = { textX: $e.transform.textX, textY: $e.transform.textY, anchorX: $e.transform.anchorX, anchorY: $e.transform.anchorY, targetX: $e.transform.targetX, targetY: $e.transform.targetY, scale: $e.transform.scale, rotate: $e.transform.rotate }), !U && ix.isEntry($e) && (U = $e);
+          })), j = a(t, r, h, _, { width: x, height: C, viewX: _e, viewY: Ce, pathSlice: ot, toMoveInsideSlice: ut, prevEntry: U, makeUpdateSliceInterpolator: $t, makeUpdateTextInterpolator: sr, handleSlicesExit: Tr, hasTransition: p, strTransform: fr }), l.pathbar.visible ? KLt(t, r, h, v, { barDifY: A, width: M, height: g, viewX: ie, viewY: Se, pathSlice: me, toMoveInsideSlice: ut, makeUpdateSliceInterpolator: $t, makeUpdateTextInterpolator: sr, handleSlicesExit: Tr, hasTransition: p, strTransform: fr }) : v.remove();
+        };
+      });
+      var lX = ye((M0r, fLe) => {
+        var JLt = Oa(), $Lt = i1(), QLt = bv(), ePt = QLt.clearMinTextSize, tPt = V0().resizeText, cLe = uLe();
+        fLe.exports = function(t, r, n, i, a) {
+          var o = a.type, s = a.drawDescendants, l = t._fullLayout, u = l["_" + o + "layer"], c, f, h = !n;
+          if (ePt(o, l), c = u.selectAll("g.trace." + o).data(r, function(v) {
+            return v[0].trace.uid;
+          }), c.enter().append("g").classed("trace", true).classed(o, true), c.order(), !l.uniformtext.mode && $Lt.hasTransition(n)) {
+            i && (f = i());
+            var d = JLt.transition().duration(n.duration).ease(n.easing).each("end", function() {
+              f && f();
+            }).each("interrupt", function() {
+              f && f();
+            });
+            d.each(function() {
+              u.selectAll("g.trace").each(function(v) {
+                cLe(t, v, this, n, s);
+              });
+            });
+          } else c.each(function(v) {
+            cLe(t, v, this, n, s);
+          }), l.uniformtext.mode && tPt(t, u.selectAll(".trace"), o);
+          h && c.exit().remove();
+        };
+      });
+      var gLe = ye((E0r, pLe) => {
+        var hLe = Oa(), KD = Dr(), dLe = So(), rPt = Zl(), iPt = rX(), vLe = ZD().styleOne, uX = W2(), nx = i1(), nPt = $E(), aPt = WD().formatSliceLabel, cX = false;
+        pLe.exports = function(t, r, n, i, a) {
+          var o = a.width, s = a.height, l = a.viewX, u = a.viewY, c = a.pathSlice, f = a.toMoveInsideSlice, h = a.strTransform, d = a.hasTransition, v = a.handleSlicesExit, _ = a.makeUpdateSliceInterpolator, b = a.makeUpdateTextInterpolator, p = a.prevEntry, k = {}, E = t._context.staticPlot, T = t._fullLayout, L = r[0], x = L.trace, C = x.textposition.indexOf("left") !== -1, M = x.textposition.indexOf("right") !== -1, g = x.textposition.indexOf("bottom") !== -1, P = !g && !x.marker.pad.t || g && !x.marker.pad.b, A = iPt(n, [o, s], { packing: x.tiling.packing, squarifyratio: x.tiling.squarifyratio, flipX: x.tiling.flip.indexOf("x") > -1, flipY: x.tiling.flip.indexOf("y") > -1, pad: { inner: x.tiling.pad, top: x.marker.pad.t, left: x.marker.pad.l, right: x.marker.pad.r, bottom: x.marker.pad.b } }), z = A.descendants(), O = 1 / 0, U = -1 / 0;
+          z.forEach(function(H) {
+            var re = H.depth;
+            re >= x._maxDepth ? (H.x0 = H.x1 = (H.x0 + H.x1) / 2, H.y0 = H.y1 = (H.y0 + H.y1) / 2) : (O = Math.min(O, re), U = Math.max(U, re));
+          }), i = i.data(z, nx.getPtId), x._maxVisibleLayers = isFinite(U) ? U - O + 1 : 0, i.enter().append("g").classed("slice", true), v(i, cX, k, [o, s], c), i.order();
+          var G = null;
+          if (d && p) {
+            var Z = nx.getPtId(p);
+            i.each(function(H) {
+              G === null && nx.getPtId(H) === Z && (G = { x0: H.x0, x1: H.x1, y0: H.y0, y1: H.y1 });
+            });
+          }
+          var j = function() {
+            return G || { x0: 0, x1: o, y0: 0, y1: s };
+          }, N = i;
+          return d && (N = N.transition().each("end", function() {
+            var H = hLe.select(this);
+            nx.setSliceCursor(H, t, { hideOnRoot: true, hideOnLeaves: false, isTransitioning: false });
+          })), N.each(function(H) {
+            var re = nx.isHeader(H, x);
+            H._x0 = l(H.x0), H._x1 = l(H.x1), H._y0 = u(H.y0), H._y1 = u(H.y1), H._hoverX = l(H.x1 - x.marker.pad.r), H._hoverY = u(g ? H.y1 - x.marker.pad.b / 2 : H.y0 + x.marker.pad.t / 2);
+            var oe = hLe.select(this), _e = KD.ensureSingle(oe, "path", "surface", function(Ee) {
+              Ee.style("pointer-events", E ? "none" : "all");
+            });
+            d ? _e.transition().attrTween("d", function(Ee) {
+              var Ae = _(Ee, cX, j(), [o, s]);
+              return function(Be) {
+                return c(Ae(Be));
+              };
+            }) : _e.attr("d", c), oe.call(nPt, n, t, r, { styleOne: vLe, eventDataKeys: uX.eventDataKeys, transitionTime: uX.CLICK_TRANSITION_TIME, transitionEasing: uX.CLICK_TRANSITION_EASING }).call(nx.setSliceCursor, t, { isTransitioning: t._transitioning }), _e.call(vLe, H, x, t, { hovered: false }), H.x0 === H.x1 || H.y0 === H.y1 ? H._text = "" : re ? H._text = P ? "" : nx.getPtLabel(H) || "" : H._text = aPt(H, n, x, r, T) || "";
+            var Ce = KD.ensureSingle(oe, "g", "slicetext"), Le = KD.ensureSingle(Ce, "text", "", function(Ee) {
+              Ee.attr("data-notex", 1);
+            }), ge = KD.ensureUniformFontSize(t, nx.determineTextFont(x, H, T.font)), ie = H._text || " ", Se = re && ie.indexOf("<br>") === -1;
+            Le.text(ie).classed("slicetext", true).attr("text-anchor", M ? "end" : C || Se ? "start" : "middle").call(dLe.font, ge).call(rPt.convertToTspans, t), H.textBB = dLe.bBox(Le.node()), H.transform = f(H, { fontSize: ge.size, isHeader: re }), H.transform.fontSize = ge.size, d ? Le.transition().attrTween("transform", function(Ee) {
+              var Ae = b(Ee, cX, j(), [o, s]);
+              return function(Be) {
+                return h(Ae(Be));
+              };
+            }) : Le.attr("transform", h(H));
+          }), G;
+        };
+      });
+      var yLe = ye((k0r, mLe) => {
+        var oPt = lX(), sPt = gLe();
+        mLe.exports = function(t, r, n, i) {
+          return oPt(t, r, n, i, { type: "treemap", drawDescendants: sPt });
+        };
+      });
+      var xLe = ye((C0r, _Le) => {
+        _Le.exports = { moduleType: "trace", name: "treemap", basePlotModule: z6e(), categories: [], animatable: true, attributes: XD(), layoutAttributes: $W(), supplyDefaults: j6e(), supplyLayoutDefaults: X6e(), calc: eX().calc, crossTraceCalc: eX().crossTraceCalc, plot: yLe(), style: ZD().style, colorbar: $d(), meta: {} };
+      });
+      var wLe = ye((L0r, bLe) => {
+        bLe.exports = xLe();
+      });
+      var ALe = ye((GA) => {
+        var TLe = Mc();
+        GA.name = "icicle";
+        GA.plot = function(e, t, r, n) {
+          TLe.plotBasePlot(GA.name, e, t, r, n);
+        };
+        GA.clean = function(e, t, r, n) {
+          TLe.cleanBasePlot(GA.name, e, t, r, n);
+        };
+      });
+      var fX = ye((I0r, ELe) => {
+        var { hovertemplateAttrs: lPt, texttemplateAttrs: uPt, templatefallbackAttrs: SLe } = Ll(), cPt = Tu(), fPt = Cc().attributes, tk = F2(), s0 = qE(), JD = XD(), MLe = W2(), hPt = Ao().extendFlat, dPt = Pd().pattern;
+        ELe.exports = { labels: s0.labels, parents: s0.parents, values: s0.values, branchvalues: s0.branchvalues, count: s0.count, level: s0.level, maxdepth: s0.maxdepth, tiling: { orientation: { valType: "enumerated", values: ["v", "h"], dflt: "h", editType: "plot" }, flip: JD.tiling.flip, pad: { valType: "number", min: 0, dflt: 0, editType: "plot" }, editType: "calc" }, marker: hPt({ colors: s0.marker.colors, line: s0.marker.line, pattern: dPt, editType: "calc" }, cPt("marker", { colorAttr: "colors", anim: false })), leaf: s0.leaf, pathbar: JD.pathbar, text: tk.text, textinfo: s0.textinfo, texttemplate: uPt({ editType: "plot" }, { keys: MLe.eventDataKeys.concat(["label", "value"]) }), texttemplatefallback: SLe({ editType: "plot" }), hovertext: tk.hovertext, hoverinfo: s0.hoverinfo, hovertemplate: lPt({}, { keys: MLe.eventDataKeys }), hovertemplatefallback: SLe(), textfont: tk.textfont, insidetextfont: tk.insidetextfont, outsidetextfont: JD.outsidetextfont, textposition: JD.textposition, sort: tk.sort, root: s0.root, domain: fPt({ name: "icicle", trace: true, editType: "calc" }) };
+      });
+      var hX = ye((R0r, kLe) => {
+        kLe.exports = { iciclecolorway: { valType: "colorlist", editType: "calc" }, extendiciclecolors: { valType: "boolean", dflt: true, editType: "calc" } };
+      });
+      var ILe = ye((D0r, PLe) => {
+        var CLe = Dr(), vPt = fX(), pPt = ka(), gPt = Cc().defaults, mPt = i0().handleText, yPt = A_().TEXTPAD, _Pt = z2().handleMarkerDefaults, LLe = tc(), xPt = LLe.hasColorscale, bPt = LLe.handleDefaults;
+        PLe.exports = function(t, r, n, i) {
+          function a(d, v) {
+            return CLe.coerce(t, r, vPt, d, v);
+          }
+          var o = a("labels"), s = a("parents");
+          if (!o || !o.length || !s || !s.length) {
+            r.visible = false;
+            return;
+          }
+          var l = a("values");
+          l && l.length ? a("branchvalues") : a("count"), a("level"), a("maxdepth"), a("tiling.orientation"), a("tiling.flip"), a("tiling.pad");
+          var u = a("text");
+          a("texttemplate"), a("texttemplatefallback"), r.texttemplate || a("textinfo", CLe.isArrayOrTypedArray(u) ? "text+label" : "label"), a("hovertext"), a("hovertemplate"), a("hovertemplatefallback");
+          var c = a("pathbar.visible"), f = "auto";
+          mPt(t, r, i, a, f, { hasPathbar: c, moduleHasSelected: false, moduleHasUnselected: false, moduleHasConstrain: false, moduleHasCliponaxis: false, moduleHasTextangle: false, moduleHasInsideanchor: false }), a("textposition"), _Pt(t, r, i, a);
+          var h = r._hasColorscale = xPt(t, "marker", "colors") || (t.marker || {}).coloraxis;
+          h && bPt(t, r, i, a, { prefix: "marker.", cLetter: "c" }), a("leaf.opacity", h ? 1 : 0.7), r._hovered = { marker: { line: { width: 2, color: pPt.contrast(i.paper_bgcolor) } } }, c && (a("pathbar.thickness", r.pathbar.textfont.size + 2 * yPt), a("pathbar.side"), a("pathbar.edgeshape")), a("sort"), a("root.color"), gPt(r, i, a), r._length = null;
+        };
+      });
+      var DLe = ye((F0r, RLe) => {
+        var wPt = Dr(), TPt = hX();
+        RLe.exports = function(t, r) {
+          function n(i, a) {
+            return wPt.coerce(t, r, TPt, i, a);
+          }
+          n("iciclecolorway", r.colorway), n("extendiciclecolors");
+        };
+      });
+      var vX = ye((dX) => {
+        var FLe = UE();
+        dX.calc = function(e, t) {
+          return FLe.calc(e, t);
+        };
+        dX.crossTraceCalc = function(e) {
+          return FLe._runCrossTraceCalc("icicle", e);
+        };
+      });
+      var OLe = ye((O0r, zLe) => {
+        var APt = BE(), SPt = tX();
+        zLe.exports = function(t, r, n) {
+          var i = n.flipX, a = n.flipY, o = n.orientation === "h", s = n.maxDepth, l = r[0], u = r[1];
+          s && (l = (t.height + 1) * r[0] / Math.min(t.height + 1, s), u = (t.height + 1) * r[1] / Math.min(t.height + 1, s));
+          var c = APt.partition().padding(n.pad.inner).size(o ? [r[1], l] : [r[0], u])(t);
+          return (o || i || a) && SPt(c, r, { swapXY: o, flipX: i, flipY: a }), c;
+        };
+      });
+      var pX = ye((q0r, VLe) => {
+        var qLe = Oa(), BLe = ka(), NLe = Dr(), MPt = bv().resizeText, EPt = HD();
+        function kPt(e) {
+          var t = e._fullLayout._iciclelayer.selectAll(".trace");
+          MPt(e, t, "icicle"), t.each(function(r) {
+            var n = qLe.select(this), i = r[0], a = i.trace;
+            n.style("opacity", a.opacity), n.selectAll("path.surface").each(function(o) {
+              qLe.select(this).call(ULe, o, a, e);
+            });
+          });
+        }
+        function ULe(e, t, r, n) {
+          var i = t.data.data, a = !t.children, o = i.i, s = NLe.castOption(r, o, "marker.line.color") || BLe.defaultLine, l = NLe.castOption(r, o, "marker.line.width") || 0;
+          e.call(EPt, t, r, n).style("stroke-width", l).call(BLe.stroke, s).style("opacity", a ? r.leaf.opacity : null);
+        }
+        VLe.exports = { style: kPt, styleOne: ULe };
+      });
+      var XLe = ye((B0r, WLe) => {
+        var GLe = Oa(), $D = Dr(), HLe = So(), CPt = Zl(), LPt = OLe(), jLe = pX().styleOne, gX = W2(), HA = i1(), PPt = $E(), IPt = WD().formatSliceLabel, mX = false;
+        WLe.exports = function(t, r, n, i, a) {
+          var o = a.width, s = a.height, l = a.viewX, u = a.viewY, c = a.pathSlice, f = a.toMoveInsideSlice, h = a.strTransform, d = a.hasTransition, v = a.handleSlicesExit, _ = a.makeUpdateSliceInterpolator, b = a.makeUpdateTextInterpolator, p = a.prevEntry, k = {}, E = t._context.staticPlot, T = t._fullLayout, L = r[0], x = L.trace, C = x.textposition.indexOf("left") !== -1, M = x.textposition.indexOf("right") !== -1, g = x.textposition.indexOf("bottom") !== -1, P = LPt(n, [o, s], { flipX: x.tiling.flip.indexOf("x") > -1, flipY: x.tiling.flip.indexOf("y") > -1, orientation: x.tiling.orientation, pad: { inner: x.tiling.pad }, maxDepth: x._maxDepth }), A = P.descendants(), z = 1 / 0, O = -1 / 0;
+          A.forEach(function(N) {
+            var H = N.depth;
+            H >= x._maxDepth ? (N.x0 = N.x1 = (N.x0 + N.x1) / 2, N.y0 = N.y1 = (N.y0 + N.y1) / 2) : (z = Math.min(z, H), O = Math.max(O, H));
+          }), i = i.data(A, HA.getPtId), x._maxVisibleLayers = isFinite(O) ? O - z + 1 : 0, i.enter().append("g").classed("slice", true), v(i, mX, k, [o, s], c), i.order();
+          var U = null;
+          if (d && p) {
+            var G = HA.getPtId(p);
+            i.each(function(N) {
+              U === null && HA.getPtId(N) === G && (U = { x0: N.x0, x1: N.x1, y0: N.y0, y1: N.y1 });
+            });
+          }
+          var Z = function() {
+            return U || { x0: 0, x1: o, y0: 0, y1: s };
+          }, j = i;
+          return d && (j = j.transition().each("end", function() {
+            var N = GLe.select(this);
+            HA.setSliceCursor(N, t, { hideOnRoot: true, hideOnLeaves: false, isTransitioning: false });
+          })), j.each(function(N) {
+            N._x0 = l(N.x0), N._x1 = l(N.x1), N._y0 = u(N.y0), N._y1 = u(N.y1), N._hoverX = l(N.x1 - x.tiling.pad), N._hoverY = u(g ? N.y1 - x.tiling.pad / 2 : N.y0 + x.tiling.pad / 2);
+            var H = GLe.select(this), re = $D.ensureSingle(H, "path", "surface", function(Le) {
+              Le.style("pointer-events", E ? "none" : "all");
+            });
+            d ? re.transition().attrTween("d", function(Le) {
+              var ge = _(Le, mX, Z(), [o, s], { orientation: x.tiling.orientation, flipX: x.tiling.flip.indexOf("x") > -1, flipY: x.tiling.flip.indexOf("y") > -1 });
+              return function(ie) {
+                return c(ge(ie));
+              };
+            }) : re.attr("d", c), H.call(PPt, n, t, r, { styleOne: jLe, eventDataKeys: gX.eventDataKeys, transitionTime: gX.CLICK_TRANSITION_TIME, transitionEasing: gX.CLICK_TRANSITION_EASING }).call(HA.setSliceCursor, t, { isTransitioning: t._transitioning }), re.call(jLe, N, x, t, { hovered: false }), N.x0 === N.x1 || N.y0 === N.y1 ? N._text = "" : N._text = IPt(N, n, x, r, T) || "";
+            var oe = $D.ensureSingle(H, "g", "slicetext"), _e = $D.ensureSingle(oe, "text", "", function(Le) {
+              Le.attr("data-notex", 1);
+            }), Ce = $D.ensureUniformFontSize(t, HA.determineTextFont(x, N, T.font));
+            _e.text(N._text || " ").classed("slicetext", true).attr("text-anchor", M ? "end" : C ? "start" : "middle").call(HLe.font, Ce).call(CPt.convertToTspans, t), N.textBB = HLe.bBox(_e.node()), N.transform = f(N, { fontSize: Ce.size }), N.transform.fontSize = Ce.size, d ? _e.transition().attrTween("transform", function(Le) {
+              var ge = b(Le, mX, Z(), [o, s]);
+              return function(ie) {
+                return h(ge(ie));
+              };
+            }) : _e.attr("transform", h(N));
+          }), U;
+        };
+      });
+      var YLe = ye((N0r, ZLe) => {
+        var RPt = lX(), DPt = XLe();
+        ZLe.exports = function(t, r, n, i) {
+          return RPt(t, r, n, i, { type: "icicle", drawDescendants: DPt });
+        };
+      });
+      var JLe = ye((U0r, KLe) => {
+        KLe.exports = { moduleType: "trace", name: "icicle", basePlotModule: ALe(), categories: [], animatable: true, attributes: fX(), layoutAttributes: hX(), supplyDefaults: ILe(), supplyLayoutDefaults: DLe(), calc: vX().calc, crossTraceCalc: vX().crossTraceCalc, plot: YLe(), style: pX().style, colorbar: $d(), meta: {} };
+      });
+      var QLe = ye((V0r, $Le) => {
+        $Le.exports = JLe();
+      });
+      var tPe = ye((jA) => {
+        var ePe = Mc();
+        jA.name = "funnelarea";
+        jA.plot = function(e, t, r, n) {
+          ePe.plotBasePlot(jA.name, e, t, r, n);
+        };
+        jA.clean = function(e, t, r, n) {
+          ePe.cleanBasePlot(jA.name, e, t, r, n);
+        };
+      });
+      var yX = ye((H0r, iPe) => {
+        var iv = F2(), FPt = Gl(), zPt = Cc().attributes, { hovertemplateAttrs: OPt, texttemplateAttrs: qPt, templatefallbackAttrs: rPe } = Ll(), Y2 = Ao().extendFlat;
+        iPe.exports = { labels: iv.labels, label0: iv.label0, dlabel: iv.dlabel, values: iv.values, marker: { colors: iv.marker.colors, line: { color: Y2({}, iv.marker.line.color, { dflt: null }), width: Y2({}, iv.marker.line.width, { dflt: 1 }), editType: "calc" }, pattern: iv.marker.pattern, editType: "calc" }, text: iv.text, hovertext: iv.hovertext, scalegroup: Y2({}, iv.scalegroup, {}), textinfo: Y2({}, iv.textinfo, { flags: ["label", "text", "value", "percent"] }), texttemplate: qPt({ editType: "plot" }, { keys: ["label", "color", "value", "text", "percent"] }), texttemplatefallback: rPe({ editType: "plot" }), hoverinfo: Y2({}, FPt.hoverinfo, { flags: ["label", "text", "value", "percent", "name"] }), hovertemplate: OPt({}, { keys: ["label", "color", "value", "text", "percent"] }), hovertemplatefallback: rPe(), textposition: Y2({}, iv.textposition, { values: ["inside", "none"], dflt: "inside" }), textfont: iv.textfont, insidetextfont: iv.insidetextfont, title: { text: iv.title.text, font: iv.title.font, position: Y2({}, iv.title.position, { values: ["top left", "top center", "top right"], dflt: "top center" }), editType: "plot" }, domain: zPt({ name: "funnelarea", trace: true, editType: "calc" }), aspectratio: { valType: "number", min: 0, dflt: 1, editType: "plot" }, baseratio: { valType: "number", min: 0, max: 1, dflt: 0.333, editType: "plot" } };
+      });
+      var _X = ye((j0r, nPe) => {
+        var BPt = _D().hiddenlabels;
+        nPe.exports = { hiddenlabels: BPt, funnelareacolorway: { valType: "colorlist", editType: "calc" }, extendfunnelareacolors: { valType: "boolean", dflt: true, editType: "calc" } };
+      });
+      var sPe = ye((W0r, oPe) => {
+        var aPe = Dr(), NPt = yX(), UPt = Cc().defaults, VPt = i0().handleText, GPt = z2().handleLabelsAndValues, HPt = z2().handleMarkerDefaults;
+        oPe.exports = function(t, r, n, i) {
+          function a(_, b) {
+            return aPe.coerce(t, r, NPt, _, b);
+          }
+          var o = a("labels"), s = a("values"), l = GPt(o, s), u = l.len;
+          if (r._hasLabels = l.hasLabels, r._hasValues = l.hasValues, !r._hasLabels && r._hasValues && (a("label0"), a("dlabel")), !u) {
+            r.visible = false;
+            return;
+          }
+          r._length = u, HPt(t, r, i, a), a("scalegroup");
+          var c = a("text"), f = a("texttemplate");
+          a("texttemplatefallback");
+          var h;
+          if (f || (h = a("textinfo", Array.isArray(c) ? "text+percent" : "percent")), a("hovertext"), a("hovertemplate"), a("hovertemplatefallback"), f || h && h !== "none") {
+            var d = a("textposition");
+            VPt(t, r, i, a, d, { moduleHasSelected: false, moduleHasUnselected: false, moduleHasConstrain: false, moduleHasCliponaxis: false, moduleHasTextangle: false, moduleHasInsideanchor: false });
+          } else h === "none" && a("textposition", "none");
+          UPt(r, i, a);
+          var v = a("title.text");
+          v && (a("title.position"), aPe.coerceFont(a, "title.font", i.font)), a("aspectratio"), a("baseratio");
+        };
+      });
+      var uPe = ye((X0r, lPe) => {
+        var jPt = Dr(), WPt = _X();
+        lPe.exports = function(t, r) {
+          function n(i, a) {
+            return jPt.coerce(t, r, WPt, i, a);
+          }
+          n("hiddenlabels"), n("funnelareacolorway", r.colorway), n("extendfunnelareacolors");
+        };
+      });
+      var xX = ye((Z0r, fPe) => {
+        var cPe = EA();
+        function XPt(e, t) {
+          return cPe.calc(e, t);
+        }
+        function ZPt(e) {
+          cPe.crossTraceCalc(e, { type: "funnelarea" });
+        }
+        fPe.exports = { calc: XPt, crossTraceCalc: ZPt };
+      });
+      var gPe = ye((Y0r, pPe) => {
+        var K2 = Oa(), bX = So(), ax = Dr(), YPt = ax.strScale, hPe = ax.strTranslate, dPe = Zl(), KPt = d2(), JPt = KPt.toMoveInsideBar, vPe = bv(), $Pt = vPe.recordMinTextSize, QPt = vPe.clearMinTextSize, eIt = g_(), WA = TD(), tIt = WA.attachFxHandlers, rIt = WA.determineInsideTextFont, iIt = WA.layoutAreas, nIt = WA.prerenderTitles, aIt = WA.positionTitleOutside, oIt = WA.formatSliceLabel;
+        pPe.exports = function(t, r) {
+          var n = t._context.staticPlot, i = t._fullLayout;
+          QPt("funnelarea", i), nIt(r, t), iIt(r, i._size), ax.makeTraceGroups(i._funnelarealayer, r, "trace").each(function(a) {
+            var o = K2.select(this), s = a[0], l = s.trace;
+            lIt(a), o.each(function() {
+              var u = K2.select(this).selectAll("g.slice").data(a);
+              u.enter().append("g").classed("slice", true), u.exit().remove(), u.each(function(f, h) {
+                if (f.hidden) {
+                  K2.select(this).selectAll("path,g").remove();
+                  return;
+                }
+                f.pointNumber = f.i, f.curveNumber = l.index;
+                var d = s.cx, v = s.cy, _ = K2.select(this), b = _.selectAll("path.surface").data([f]);
+                b.enter().append("path").classed("surface", true).style({ "pointer-events": n ? "none" : "all" }), _.call(tIt, t, a);
+                var p = "M" + (d + f.TR[0]) + "," + (v + f.TR[1]) + wX(f.TR, f.BR) + wX(f.BR, f.BL) + wX(f.BL, f.TL) + "Z";
+                b.attr("d", p), oIt(t, f, s);
+                var k = eIt.castOption(l.textposition, f.pts), E = _.selectAll("g.slicetext").data(f.text && k !== "none" ? [0] : []);
+                E.enter().append("g").classed("slicetext", true), E.exit().remove(), E.each(function() {
+                  var T = ax.ensureSingle(K2.select(this), "text", "", function(z) {
+                    z.attr("data-notex", 1);
+                  }), L = ax.ensureUniformFontSize(t, rIt(l, f, i.font));
+                  T.text(f.text).attr({ class: "slicetext", transform: "", "text-anchor": "middle" }).call(bX.font, L).call(dPe.convertToTspans, t);
+                  var x = bX.bBox(T.node()), C, M, g, P = Math.min(f.BL[1], f.BR[1]) + v, A = Math.max(f.TL[1], f.TR[1]) + v;
+                  M = Math.max(f.TL[0], f.BL[0]) + d, g = Math.min(f.TR[0], f.BR[0]) + d, C = JPt(M, g, P, A, x, { isHorizontal: true, constrained: true, angle: 0, anchor: "middle" }), C.fontSize = L.size, $Pt(l.type, C, i), a[h].transform = C, ax.setTransormAndDisplay(T, C);
+                });
+              });
+              var c = K2.select(this).selectAll("g.titletext").data(l.title.text ? [0] : []);
+              c.enter().append("g").classed("titletext", true), c.exit().remove(), c.each(function() {
+                var f = ax.ensureSingle(K2.select(this), "text", "", function(v) {
+                  v.attr("data-notex", 1);
+                }), h = l.title.text;
+                l._meta && (h = ax.templateString(h, l._meta)), f.text(h).attr({ class: "titletext", transform: "", "text-anchor": "middle" }).call(bX.font, l.title.font).call(dPe.convertToTspans, t);
+                var d = aIt(s, i._size);
+                f.attr("transform", hPe(d.x, d.y) + YPt(Math.min(1, d.scale)) + hPe(d.tx, d.ty));
+              });
+            });
+          });
+        };
+        function wX(e, t) {
+          var r = t[0] - e[0], n = t[1] - e[1];
+          return "l" + r + "," + n;
+        }
+        function sIt(e, t) {
+          return [0.5 * (e[0] + t[0]), 0.5 * (e[1] + t[1])];
+        }
+        function lIt(e) {
+          if (!e.length) return;
+          var t = e[0], r = t.trace, n = r.aspectratio, i = r.baseratio;
+          i > 0.999 && (i = 0.999);
+          var a = Math.pow(i, 2), o = t.vTotal, s = o * a / (1 - a), l = o, u = s / o;
+          function c() {
+            var O = Math.sqrt(u);
+            return { x: O, y: -O };
+          }
+          function f() {
+            var O = c();
+            return [O.x, O.y];
+          }
+          var h, d = [];
+          d.push(f());
+          var v, _;
+          for (v = e.length - 1; v > -1; v--) if (_ = e[v], !_.hidden) {
+            var b = _.v / l;
+            u += b, d.push(f());
+          }
+          var p = 1 / 0, k = -1 / 0;
+          for (v = 0; v < d.length; v++) h = d[v], p = Math.min(p, h[1]), k = Math.max(k, h[1]);
+          for (v = 0; v < d.length; v++) d[v][1] -= (k + p) / 2;
+          var E = d[d.length - 1][0], T = t.r, L = (k - p) / 2, x = T / E, C = T / L * n;
+          for (t.r = C * L, v = 0; v < d.length; v++) d[v][0] *= x, d[v][1] *= C;
+          h = d[0];
+          var M = [-h[0], h[1]], g = [h[0], h[1]], P = 0;
+          for (v = e.length - 1; v > -1; v--) if (_ = e[v], !_.hidden) {
+            P += 1;
+            var A = d[P][0], z = d[P][1];
+            _.TL = [-A, z], _.TR = [A, z], _.BL = M, _.BR = g, _.pxmid = sIt(_.TR, _.BR), M = _.TL, g = _.TR;
+          }
+        }
+      });
+      var _Pe = ye((K0r, yPe) => {
+        var mPe = Oa(), uIt = X3(), cIt = bv().resizeText;
+        yPe.exports = function(t) {
+          var r = t._fullLayout._funnelarealayer.selectAll(".trace");
+          cIt(t, r, "funnelarea"), r.each(function(n) {
+            var i = n[0], a = i.trace, o = mPe.select(this);
+            o.style({ opacity: a.opacity }), o.selectAll("path.surface").each(function(s) {
+              mPe.select(this).call(uIt, s, a, t);
+            });
+          });
+        };
+      });
+      var bPe = ye((J0r, xPe) => {
+        xPe.exports = { moduleType: "trace", name: "funnelarea", basePlotModule: tPe(), categories: ["pie-like", "funnelarea", "showLegend"], attributes: yX(), layoutAttributes: _X(), supplyDefaults: sPe(), supplyLayoutDefaults: uPe(), calc: xX().calc, crossTraceCalc: xX().crossTraceCalc, plot: gPe(), style: _Pe(), styleOne: X3(), meta: {} };
+      });
+      var TPe = ye(($0r, wPe) => {
+        wPe.exports = bPe();
+      });
+      var zd = ye((Q0r, APe) => {
+        (function() {
+          var e = { 24: function(i) {
+            var a = { left: 0, top: 0 };
+            i.exports = o;
+            function o(l, u, c) {
+              u = u || l.currentTarget || l.srcElement, Array.isArray(c) || (c = [0, 0]);
+              var f = l.clientX || 0, h = l.clientY || 0, d = s(u);
+              return c[0] = f - d.left, c[1] = h - d.top, c;
+            }
+            function s(l) {
+              return l === window || l === document || l === document.body ? a : l.getBoundingClientRect();
+            }
+          }, 109: function(i) {
+            i.exports = a;
+            function a(o, s, l, u) {
+              var c = l[0], f = l[2], h = s[0] - c, d = s[2] - f, v = Math.sin(u), _ = Math.cos(u);
+              return o[0] = c + d * v + h * _, o[1] = s[1], o[2] = f + d * _ - h * v, o;
+            }
+          }, 160: function(i) {
+            i.exports = a;
+            function a(o, s, l) {
+              return o[0] = Math.max(s[0], l[0]), o[1] = Math.max(s[1], l[1]), o[2] = Math.max(s[2], l[2]), o[3] = Math.max(s[3], l[3]), o;
+            }
+          }, 216: function(i) {
+            i.exports = a;
+            function a(o, s) {
+              for (var l = {}, u = 0; u < o.length; ++u) for (var c = o[u].name, f = c.split("."), h = l, d = 0; d < f.length; ++d) {
+                var v = f[d].split("[");
+                if (v.length > 1) {
+                  v[0] in h || (h[v[0]] = []), h = h[v[0]];
+                  for (var _ = 1; _ < v.length; ++_) {
+                    var b = parseInt(v[_]);
+                    _ < v.length - 1 || d < f.length - 1 ? (b in h || (_ < v.length - 1 ? h[b] = [] : h[b] = {}), h = h[b]) : s ? h[b] = u : h[b] = o[u].type;
+                  }
+                } else d < f.length - 1 ? (v[0] in h || (h[v[0]] = {}), h = h[v[0]]) : s ? h[v[0]] = u : h[v[0]] = o[u].type;
+              }
+              return l;
+            }
+          }, 236: function(i, a, o) {
+            var s = o(8284);
+            i.exports = l;
+            function l() {
+              var u = {};
+              return function(c) {
+                if ((typeof c != "object" || c === null) && typeof c != "function") throw new Error("Weakmap-shim: Key must be object");
+                var f = c.valueOf(u);
+                return f && f.identity === u ? f : s(c, u);
+              };
+            }
+          }, 244: function(i) {
+            i.exports = a;
+            function a(o, s) {
+              return o[0] * s[0] + o[1] * s[1] + o[2] * s[2];
+            }
+          }, 264: function(i) {
+            i.exports = a;
+            function a(o, s, l) {
+              var u = s[0], c = s[1], f = s[2], h = l[0], d = l[1], v = l[2], _ = l[3], b = _ * u + d * f - v * c, p = _ * c + v * u - h * f, k = _ * f + h * c - d * u, E = -h * u - d * c - v * f;
+              return o[0] = b * _ + E * -h + p * -v - k * -d, o[1] = p * _ + E * -d + k * -h - b * -v, o[2] = k * _ + E * -v + b * -d - p * -h, o;
+            }
+          }, 332: function(i, a, o) {
+            i.exports = z;
+            var s = o(1755), l = o(6867), u = o(1125), c = o(7842), f = o(1318), h = o(946), d = o(5838), v = o(1278), _ = o(3637);
+            function b(O) {
+              var U = h(O);
+              return [v(U, -1 / 0), v(U, 1 / 0)];
+            }
+            function p(O, U) {
+              for (var G = new Array(U.length), Z = 0; Z < U.length; ++Z) {
+                var j = U[Z], N = O[j[0]], H = O[j[1]];
+                G[Z] = [v(Math.min(N[0], H[0]), -1 / 0), v(Math.min(N[1], H[1]), -1 / 0), v(Math.max(N[0], H[0]), 1 / 0), v(Math.max(N[1], H[1]), 1 / 0)];
+              }
+              return G;
+            }
+            function k(O) {
+              for (var U = new Array(O.length), G = 0; G < O.length; ++G) {
+                var Z = O[G];
+                U[G] = [v(Z[0], -1 / 0), v(Z[1], -1 / 0), v(Z[0], 1 / 0), v(Z[1], 1 / 0)];
+              }
+              return U;
+            }
+            function E(O, U, G) {
+              var Z = [];
+              return l(G, function(j, N) {
+                var H = U[j], re = U[N];
+                if (!(H[0] === re[0] || H[0] === re[1] || H[1] === re[0] || H[1] === re[1])) {
+                  var oe = O[H[0]], _e = O[H[1]], Ce = O[re[0]], Le = O[re[1]];
+                  u(oe, _e, Ce, Le) && Z.push([j, N]);
+                }
+              }), Z;
+            }
+            function T(O, U, G, Z) {
+              var j = [];
+              return l(G, Z, function(N, H) {
+                var re = U[N];
+                if (!(re[0] === H || re[1] === H)) {
+                  var oe = O[H], _e = O[re[0]], Ce = O[re[1]];
+                  u(_e, Ce, oe, oe) && j.push([N, H]);
+                }
+              }), j;
+            }
+            function L(O, U, G, Z, j) {
+              var N, H, re = O.map(function(pt) {
+                return [c(pt[0]), c(pt[1])];
+              });
+              for (N = 0; N < G.length; ++N) {
+                var oe = G[N];
+                H = oe[0];
+                var _e = oe[1], Ce = U[H], Le = U[_e], ge = _(d(O[Ce[0]]), d(O[Ce[1]]), d(O[Le[0]]), d(O[Le[1]]));
+                if (ge) {
+                  var ie = O.length;
+                  O.push([h(ge[0]), h(ge[1])]), re.push(ge), Z.push([H, ie], [_e, ie]);
+                }
+              }
+              for (Z.sort(function(pt, Vt) {
+                if (pt[0] !== Vt[0]) return pt[0] - Vt[0];
+                var ot = re[pt[1]], ut = re[Vt[1]];
+                return f(ot[0], ut[0]) || f(ot[1], ut[1]);
+              }), N = Z.length - 1; N >= 0; --N) {
+                var Se = Z[N];
+                H = Se[0];
+                var Ee = U[H], Ae = Ee[0], Be = Ee[1], Pe = O[Ae], me = O[Be];
+                if ((Pe[0] - me[0] || Pe[1] - me[1]) < 0) {
+                  var De = Ae;
+                  Ae = Be, Be = De;
+                }
+                Ee[0] = Ae;
+                var ce = Ee[1] = Se[1], je;
+                for (j && (je = Ee[2]); N > 0 && Z[N - 1][0] === H; ) {
+                  var Se = Z[--N], lt = Se[1];
+                  j ? U.push([ce, lt, je]) : U.push([ce, lt]), ce = lt;
+                }
+                j ? U.push([ce, Be, je]) : U.push([ce, Be]);
+              }
+              return re;
+            }
+            function x(O, U, G) {
+              for (var Z = U.length, j = new s(Z), N = [], H = 0; H < U.length; ++H) {
+                var re = U[H], oe = b(re[0]), _e = b(re[1]);
+                N.push([v(oe[0], -1 / 0), v(_e[0], -1 / 0), v(oe[1], 1 / 0), v(_e[1], 1 / 0)]);
+              }
+              l(N, function(Se, Ee) {
+                j.link(Se, Ee);
+              });
+              for (var Ce = true, Le = new Array(Z), H = 0; H < Z; ++H) {
+                var ge = j.find(H);
+                ge !== H && (Ce = false, O[ge] = [Math.min(O[H][0], O[ge][0]), Math.min(O[H][1], O[ge][1])]);
+              }
+              if (Ce) return null;
+              for (var ie = 0, H = 0; H < Z; ++H) {
+                var ge = j.find(H);
+                ge === H ? (Le[H] = ie, O[ie++] = O[H]) : Le[H] = -1;
+              }
+              O.length = ie;
+              for (var H = 0; H < Z; ++H) Le[H] < 0 && (Le[H] = Le[j.find(H)]);
+              return Le;
+            }
+            function C(O, U) {
+              return O[0] - U[0] || O[1] - U[1];
+            }
+            function M(O, U) {
+              var G = O[0] - U[0] || O[1] - U[1];
+              return G || (O[2] < U[2] ? -1 : O[2] > U[2] ? 1 : 0);
+            }
+            function g(O, U, G) {
+              if (O.length !== 0) {
+                if (U) for (var Z = 0; Z < O.length; ++Z) {
+                  var j = O[Z], N = U[j[0]], H = U[j[1]];
+                  j[0] = Math.min(N, H), j[1] = Math.max(N, H);
+                }
+                else for (var Z = 0; Z < O.length; ++Z) {
+                  var j = O[Z], N = j[0], H = j[1];
+                  j[0] = Math.min(N, H), j[1] = Math.max(N, H);
+                }
+                G ? O.sort(M) : O.sort(C);
+                for (var re = 1, Z = 1; Z < O.length; ++Z) {
+                  var oe = O[Z - 1], _e = O[Z];
+                  _e[0] === oe[0] && _e[1] === oe[1] && (!G || _e[2] === oe[2]) || (O[re++] = _e);
+                }
+                O.length = re;
+              }
+            }
+            function P(O, U, G) {
+              var Z = x(O, [], k(O));
+              return g(U, Z, G), !!Z;
+            }
+            function A(O, U, G) {
+              var Z = p(O, U), j = E(O, U, Z), N = k(O), H = T(O, U, Z, N), re = L(O, U, j, H, G), oe = x(O, re);
+              return g(U, oe, G), oe ? true : j.length > 0 || H.length > 0;
+            }
+            function z(O, U, G) {
+              var Z;
+              if (G) {
+                Z = U;
+                for (var j = new Array(U.length), N = 0; N < U.length; ++N) {
+                  var H = U[N];
+                  j[N] = [H[0], H[1], G[N]];
+                }
+                U = j;
+              }
+              for (var re = P(O, U, !!G); A(O, U, !!G); ) re = true;
+              if (G && re) {
+                Z.length = 0, G.length = 0;
+                for (var N = 0; N < U.length; ++N) {
+                  var H = U[N];
+                  Z.push([H[0], H[1]]), G.push(H[2]);
+                }
+              }
+              return re;
+            }
+          }, 351: function(i, a, o) {
+            i.exports = l;
+            var s = o(4687);
+            function l(u, c) {
+              c || (c = u, u = window);
+              var f = 0, h = 0, d = 0, v = { shift: false, alt: false, control: false, meta: false }, _ = false;
+              function b(A) {
+                var z = false;
+                return "altKey" in A && (z = z || A.altKey !== v.alt, v.alt = !!A.altKey), "shiftKey" in A && (z = z || A.shiftKey !== v.shift, v.shift = !!A.shiftKey), "ctrlKey" in A && (z = z || A.ctrlKey !== v.control, v.control = !!A.ctrlKey), "metaKey" in A && (z = z || A.metaKey !== v.meta, v.meta = !!A.metaKey), z;
+              }
+              function p(A, z) {
+                var O = s.x(z), U = s.y(z);
+                "buttons" in z && (A = z.buttons | 0), (A !== f || O !== h || U !== d || b(z)) && (f = A | 0, h = O || 0, d = U || 0, c && c(f, h, d, v));
+              }
+              function k(A) {
+                p(0, A);
+              }
+              function E() {
+                (f || h || d || v.shift || v.alt || v.meta || v.control) && (h = d = 0, f = 0, v.shift = v.alt = v.control = v.meta = false, c && c(0, 0, 0, v));
+              }
+              function T(A) {
+                b(A) && c && c(f, h, d, v);
+              }
+              function L(A) {
+                s.buttons(A) === 0 ? p(0, A) : p(f, A);
+              }
+              function x(A) {
+                p(f | s.buttons(A), A);
+              }
+              function C(A) {
+                p(f & ~s.buttons(A), A);
+              }
+              function M() {
+                _ || (_ = true, u.addEventListener("mousemove", L), u.addEventListener("mousedown", x), u.addEventListener("mouseup", C), u.addEventListener("mouseleave", k), u.addEventListener("mouseenter", k), u.addEventListener("mouseout", k), u.addEventListener("mouseover", k), u.addEventListener("blur", E), u.addEventListener("keyup", T), u.addEventListener("keydown", T), u.addEventListener("keypress", T), u !== window && (window.addEventListener("blur", E), window.addEventListener("keyup", T), window.addEventListener("keydown", T), window.addEventListener("keypress", T)));
+              }
+              function g() {
+                _ && (_ = false, u.removeEventListener("mousemove", L), u.removeEventListener("mousedown", x), u.removeEventListener("mouseup", C), u.removeEventListener("mouseleave", k), u.removeEventListener("mouseenter", k), u.removeEventListener("mouseout", k), u.removeEventListener("mouseover", k), u.removeEventListener("blur", E), u.removeEventListener("keyup", T), u.removeEventListener("keydown", T), u.removeEventListener("keypress", T), u !== window && (window.removeEventListener("blur", E), window.removeEventListener("keyup", T), window.removeEventListener("keydown", T), window.removeEventListener("keypress", T)));
+              }
+              M();
+              var P = { element: u };
+              return Object.defineProperties(P, { enabled: { get: function() {
+                return _;
+              }, set: function(A) {
+                A ? M() : g();
+              }, enumerable: true }, buttons: { get: function() {
+                return f;
+              }, enumerable: true }, x: { get: function() {
+                return h;
+              }, enumerable: true }, y: { get: function() {
+                return d;
+              }, enumerable: true }, mods: { get: function() {
+                return v;
+              }, enumerable: true } }), P;
+            }
+          }, 395: function(i) {
+            function a(o, s, l) {
+              return o * (1 - l) + s * l;
+            }
+            i.exports = a;
+          }, 446: function(i, a, o) {
+            var s = o(7640), l = {};
+            function u(c) {
+              var f = c.order, h = c.dtype, d = [f, h], v = d.join(":"), _ = l[v];
+              return _ || (l[v] = _ = s(f, h)), _(c), c;
+            }
+            i.exports = u;
+          }, 483: function(i) {
+            i.exports = a;
+            function a(o) {
+              var s = o[0], l = o[1], u = o[2], c = o[3];
+              return s * s + l * l + u * u + c * c;
+            }
+          }, 492: function(i) {
+            i.exports = a;
+            function a(o, s, l) {
+              var u = s[0], c = s[1], f = s[2];
+              return o[0] = u * l[0] + c * l[3] + f * l[6], o[1] = u * l[1] + c * l[4] + f * l[7], o[2] = u * l[2] + c * l[5] + f * l[8], o;
+            }
+          }, 501: function(i, a, o) {
+            i.exports = E;
+            var s = o(2762), l = o(8116), u = o(1879).n, c = [0, 0, 0], f = [0, 0, 0], h = [0, 0, 0], d = [0, 0, 0], v = [1, 1];
+            function _(T) {
+              return T[0] = T[1] = T[2] = 0, T;
+            }
+            function b(T, L) {
+              return T[0] = L[0], T[1] = L[1], T[2] = L[2], T;
+            }
+            function p(T, L, x, C, M, g, P, A) {
+              this.gl = T, this.vertBuffer = L, this.vao = x, this.shader = C, this.tickCount = M, this.tickOffset = g, this.gridCount = P, this.gridOffset = A;
+            }
+            var k = p.prototype;
+            k.bind = function(T, L, x) {
+              this.shader.bind(), this.shader.uniforms.model = T, this.shader.uniforms.view = L, this.shader.uniforms.projection = x, v[0] = this.gl.drawingBufferWidth, v[1] = this.gl.drawingBufferHeight, this.shader.uniforms.screenShape = v, this.vao.bind();
+            }, k.unbind = function() {
+              this.vao.unbind();
+            }, k.drawAxisLine = function(T, L, x, C, M) {
+              var g = _(f);
+              this.shader.uniforms.majorAxis = f, g[T] = L[1][T] - L[0][T], this.shader.uniforms.minorAxis = g;
+              var P = b(d, x);
+              P[T] += L[0][T], this.shader.uniforms.offset = P, this.shader.uniforms.lineWidth = M, this.shader.uniforms.color = C;
+              var A = _(h);
+              A[(T + 2) % 3] = 1, this.shader.uniforms.screenAxis = A, this.vao.draw(this.gl.TRIANGLES, 6);
+              var A = _(h);
+              A[(T + 1) % 3] = 1, this.shader.uniforms.screenAxis = A, this.vao.draw(this.gl.TRIANGLES, 6);
+            }, k.drawAxisTicks = function(T, L, x, C, M) {
+              if (this.tickCount[T]) {
+                var g = _(c);
+                g[T] = 1, this.shader.uniforms.majorAxis = g, this.shader.uniforms.offset = L, this.shader.uniforms.minorAxis = x, this.shader.uniforms.color = C, this.shader.uniforms.lineWidth = M;
+                var P = _(h);
+                P[T] = 1, this.shader.uniforms.screenAxis = P, this.vao.draw(this.gl.TRIANGLES, this.tickCount[T], this.tickOffset[T]);
+              }
+            }, k.drawGrid = function(T, L, x, C, M, g) {
+              if (this.gridCount[T]) {
+                var P = _(f);
+                P[L] = x[1][L] - x[0][L], this.shader.uniforms.minorAxis = P;
+                var A = b(d, C);
+                A[L] += x[0][L], this.shader.uniforms.offset = A;
+                var z = _(c);
+                z[T] = 1, this.shader.uniforms.majorAxis = z;
+                var O = _(h);
+                O[T] = 1, this.shader.uniforms.screenAxis = O, this.shader.uniforms.lineWidth = g, this.shader.uniforms.color = M, this.vao.draw(this.gl.TRIANGLES, this.gridCount[T], this.gridOffset[T]);
+              }
+            }, k.drawZero = function(T, L, x, C, M, g) {
+              var P = _(f);
+              this.shader.uniforms.majorAxis = P, P[T] = x[1][T] - x[0][T], this.shader.uniforms.minorAxis = P;
+              var A = b(d, C);
+              A[T] += x[0][T], this.shader.uniforms.offset = A;
+              var z = _(h);
+              z[L] = 1, this.shader.uniforms.screenAxis = z, this.shader.uniforms.lineWidth = g, this.shader.uniforms.color = M, this.vao.draw(this.gl.TRIANGLES, 6);
+            }, k.dispose = function() {
+              this.vao.dispose(), this.vertBuffer.dispose(), this.shader.dispose();
+            };
+            function E(T, L, x) {
+              var C = [], M = [0, 0, 0], g = [0, 0, 0], P = [0, 0, 0], A = [0, 0, 0];
+              C.push(0, 0, 1, 0, 1, 1, 0, 0, -1, 0, 0, -1, 0, 1, 1, 0, 1, -1);
+              for (var z = 0; z < 3; ++z) {
+                for (var G = C.length / 3 | 0, O = 0; O < x[z].length; ++O) {
+                  var U = +x[z][O].x;
+                  C.push(U, 0, 1, U, 1, 1, U, 0, -1, U, 0, -1, U, 1, 1, U, 1, -1);
+                }
+                var j = C.length / 3 | 0;
+                M[z] = G, g[z] = j - G;
+                for (var G = C.length / 3 | 0, Z = 0; Z < x[z].length; ++Z) {
+                  var U = +x[z][Z].x;
+                  C.push(U, 0, 1, U, 1, 1, U, 0, -1, U, 0, -1, U, 1, 1, U, 1, -1);
+                }
+                var j = C.length / 3 | 0;
+                P[z] = G, A[z] = j - G;
+              }
+              var N = s(T, new Float32Array(C)), H = l(T, [{ buffer: N, type: T.FLOAT, size: 3, stride: 0, offset: 0 }]), re = u(T);
+              return re.attributes.position.location = 0, new p(T, N, H, re, g, M, A, P);
+            }
+          }, 544: function(i, a, o) {
+            var s = o(5572);
+            i.exports = l;
+            function l(u, c) {
+              for (var f = u.length, h = new Array(f), d = 0; d < f; ++d) h[d] = s(u[d], c[d]);
+              return h;
+            }
+          }, 606: function(i, a, o) {
+            var s = o(236);
+            i.exports = l;
+            function l() {
+              var u = s();
+              return { get: function(c, f) {
+                var h = u(c);
+                return h.hasOwnProperty("value") ? h.value : f;
+              }, set: function(c, f) {
+                return u(c).value = f, this;
+              }, has: function(c) {
+                return "value" in u(c);
+              }, delete: function(c) {
+                return delete u(c).value;
+              } };
+            }
+          }, 614: function(i, a, o) {
+            var s = o(3236), l = s([`precision highp float;
+
+precision highp float;
+#define GLSLIFY 1
+
+vec3 getOrthogonalVector(vec3 v) {
+  // Return up-vector for only-z vector.
+  // Return ax + by + cz = 0, a point that lies on the plane that has v as a normal and that isn't (0,0,0).
+  // From the above if-statement we have ||a|| > 0  U  ||b|| > 0.
+  // Assign z = 0, x = -b, y = a:
+  // a*-b + b*a + c*0 = -ba + ba + 0 = 0
+  if (v.x*v.x > v.z*v.z || v.y*v.y > v.z*v.z) {
+    return normalize(vec3(-v.y, v.x, 0.0));
+  } else {
+    return normalize(vec3(0.0, v.z, -v.y));
+  }
+}
+
+// Calculate the cone vertex and normal at the given index.
+//
+// The returned vertex is for a cone with its top at origin and height of 1.0,
+// pointing in the direction of the vector attribute.
+//
+// Each cone is made up of a top vertex, a center base vertex and base perimeter vertices.
+// These vertices are used to make up the triangles of the cone by the following:
+//   segment + 0 top vertex
+//   segment + 1 perimeter vertex a+1
+//   segment + 2 perimeter vertex a
+//   segment + 3 center base vertex
+//   segment + 4 perimeter vertex a
+//   segment + 5 perimeter vertex a+1
+// Where segment is the number of the radial segment * 6 and a is the angle at that radial segment.
+// To go from index to segment, floor(index / 6)
+// To go from segment to angle, 2*pi * (segment/segmentCount)
+// To go from index to segment index, index - (segment*6)
+//
+vec3 getConePosition(vec3 d, float rawIndex, float coneOffset, out vec3 normal) {
+
+  const float segmentCount = 8.0;
+
+  float index = rawIndex - floor(rawIndex /
+    (segmentCount * 6.0)) *
+    (segmentCount * 6.0);
+
+  float segment = floor(0.001 + index/6.0);
+  float segmentIndex = index - (segment*6.0);
+
+  normal = -normalize(d);
+
+  if (segmentIndex > 2.99 && segmentIndex < 3.01) {
+    return mix(vec3(0.0), -d, coneOffset);
+  }
+
+  float nextAngle = (
+    (segmentIndex > 0.99 &&  segmentIndex < 1.01) ||
+    (segmentIndex > 4.99 &&  segmentIndex < 5.01)
+  ) ? 1.0 : 0.0;
+  float angle = 2.0 * 3.14159 * ((segment + nextAngle) / segmentCount);
+
+  vec3 v1 = mix(d, vec3(0.0), coneOffset);
+  vec3 v2 = v1 - d;
+
+  vec3 u = getOrthogonalVector(d);
+  vec3 v = normalize(cross(u, d));
+
+  vec3 x = u * cos(angle) * length(d)*0.25;
+  vec3 y = v * sin(angle) * length(d)*0.25;
+  vec3 v3 = v2 + x + y;
+  if (segmentIndex < 3.0) {
+    vec3 tx = u * sin(angle);
+    vec3 ty = v * -cos(angle);
+    vec3 tangent = tx + ty;
+    normal = normalize(cross(v3 - v1, tangent));
+  }
+
+  if (segmentIndex == 0.0) {
+    return mix(d, vec3(0.0), coneOffset);
+  }
+  return v3;
+}
+
+attribute vec3 vector;
+attribute vec4 color, position;
+attribute vec2 uv;
+
+uniform float vectorScale, coneScale, coneOffset;
+uniform mat4 model, view, projection, inverseModel;
+uniform vec3 eyePosition, lightPosition;
+
+varying vec3 f_normal, f_lightDirection, f_eyeDirection, f_data, f_position;
+varying vec4 f_color;
+varying vec2 f_uv;
+
+void main() {
+  // Scale the vector magnitude to stay constant with
+  // model & view changes.
+  vec3 normal;
+  vec3 XYZ = getConePosition(mat3(model) * ((vectorScale * coneScale) * vector), position.w, coneOffset, normal);
+  vec4 conePosition = model * vec4(position.xyz, 1.0) + vec4(XYZ, 0.0);
+
+  //Lighting geometry parameters
+  vec4 cameraCoordinate = view * conePosition;
+  cameraCoordinate.xyz /= cameraCoordinate.w;
+  f_lightDirection = lightPosition - cameraCoordinate.xyz;
+  f_eyeDirection   = eyePosition - cameraCoordinate.xyz;
+  f_normal = normalize((vec4(normal, 0.0) * inverseModel).xyz);
+
+  // vec4 m_position  = model * vec4(conePosition, 1.0);
+  vec4 t_position  = view * conePosition;
+  gl_Position      = projection * t_position;
+
+  f_color          = color;
+  f_data           = conePosition.xyz;
+  f_position       = position.xyz;
+  f_uv             = uv;
+}
+`]), u = s([`#extension GL_OES_standard_derivatives : enable
+
+precision highp float;
+#define GLSLIFY 1
+
+float beckmannDistribution(float x, float roughness) {
+  float NdotH = max(x, 0.0001);
+  float cos2Alpha = NdotH * NdotH;
+  float tan2Alpha = (cos2Alpha - 1.0) / cos2Alpha;
+  float roughness2 = roughness * roughness;
+  float denom = 3.141592653589793 * roughness2 * cos2Alpha * cos2Alpha;
+  return exp(tan2Alpha / roughness2) / denom;
+}
+
+float cookTorranceSpecular(
+  vec3 lightDirection,
+  vec3 viewDirection,
+  vec3 surfaceNormal,
+  float roughness,
+  float fresnel) {
+
+  float VdotN = max(dot(viewDirection, surfaceNormal), 0.0);
+  float LdotN = max(dot(lightDirection, surfaceNormal), 0.0);
+
+  //Half angle vector
+  vec3 H = normalize(lightDirection + viewDirection);
+
+  //Geometric term
+  float NdotH = max(dot(surfaceNormal, H), 0.0);
+  float VdotH = max(dot(viewDirection, H), 0.000001);
+  float LdotH = max(dot(lightDirection, H), 0.000001);
+  float G1 = (2.0 * NdotH * VdotN) / VdotH;
+  float G2 = (2.0 * NdotH * LdotN) / LdotH;
+  float G = min(1.0, min(G1, G2));
+
+  //Distribution term
+  float D = beckmannDistribution(NdotH, roughness);
+
+  //Fresnel term
+  float F = pow(1.0 - VdotN, fresnel);
+
+  //Multiply terms and done
+  return  G * F * D / max(3.14159265 * VdotN, 0.000001);
+}
+
+bool outOfRange(float a, float b, float p) {
+  return ((p > max(a, b)) ||
+          (p < min(a, b)));
+}
+
+bool outOfRange(vec2 a, vec2 b, vec2 p) {
+  return (outOfRange(a.x, b.x, p.x) ||
+          outOfRange(a.y, b.y, p.y));
+}
+
+bool outOfRange(vec3 a, vec3 b, vec3 p) {
+  return (outOfRange(a.x, b.x, p.x) ||
+          outOfRange(a.y, b.y, p.y) ||
+          outOfRange(a.z, b.z, p.z));
+}
+
+bool outOfRange(vec4 a, vec4 b, vec4 p) {
+  return outOfRange(a.xyz, b.xyz, p.xyz);
+}
+
+uniform vec3 clipBounds[2];
+uniform float roughness, fresnel, kambient, kdiffuse, kspecular, opacity;
+uniform sampler2D texture;
+
+varying vec3 f_normal, f_lightDirection, f_eyeDirection, f_data, f_position;
+varying vec4 f_color;
+varying vec2 f_uv;
+
+void main() {
+  if (outOfRange(clipBounds[0], clipBounds[1], f_position)) discard;
+  vec3 N = normalize(f_normal);
+  vec3 L = normalize(f_lightDirection);
+  vec3 V = normalize(f_eyeDirection);
+
+  if(gl_FrontFacing) {
+    N = -N;
+  }
+
+  float specular = min(1.0, max(0.0, cookTorranceSpecular(L, V, N, roughness, fresnel)));
+  float diffuse  = min(kambient + kdiffuse * max(dot(N, L), 0.0), 1.0);
+
+  vec4 surfaceColor = f_color * texture2D(texture, f_uv);
+  vec4 litColor = surfaceColor.a * vec4(diffuse * surfaceColor.rgb + kspecular * vec3(1,1,1) * specular,  1.0);
+
+  gl_FragColor = litColor * opacity;
+}
+`]), c = s([`precision highp float;
+
+precision highp float;
+#define GLSLIFY 1
+
+vec3 getOrthogonalVector(vec3 v) {
+  // Return up-vector for only-z vector.
+  // Return ax + by + cz = 0, a point that lies on the plane that has v as a normal and that isn't (0,0,0).
+  // From the above if-statement we have ||a|| > 0  U  ||b|| > 0.
+  // Assign z = 0, x = -b, y = a:
+  // a*-b + b*a + c*0 = -ba + ba + 0 = 0
+  if (v.x*v.x > v.z*v.z || v.y*v.y > v.z*v.z) {
+    return normalize(vec3(-v.y, v.x, 0.0));
+  } else {
+    return normalize(vec3(0.0, v.z, -v.y));
+  }
+}
+
+// Calculate the cone vertex and normal at the given index.
+//
+// The returned vertex is for a cone with its top at origin and height of 1.0,
+// pointing in the direction of the vector attribute.
+//
+// Each cone is made up of a top vertex, a center base vertex and base perimeter vertices.
+// These vertices are used to make up the triangles of the cone by the following:
+//   segment + 0 top vertex
+//   segment + 1 perimeter vertex a+1
+//   segment + 2 perimeter vertex a
+//   segment + 3 center base vertex
+//   segment + 4 perimeter vertex a
+//   segment + 5 perimeter vertex a+1
+// Where segment is the number of the radial segment * 6 and a is the angle at that radial segment.
+// To go from index to segment, floor(index / 6)
+// To go from segment to angle, 2*pi * (segment/segmentCount)
+// To go from index to segment index, index - (segment*6)
+//
+vec3 getConePosition(vec3 d, float rawIndex, float coneOffset, out vec3 normal) {
+
+  const float segmentCount = 8.0;
+
+  float index = rawIndex - floor(rawIndex /
+    (segmentCount * 6.0)) *
+    (segmentCount * 6.0);
+
+  float segment = floor(0.001 + index/6.0);
+  float segmentIndex = index - (segment*6.0);
+
+  normal = -normalize(d);
+
+  if (segmentIndex > 2.99 && segmentIndex < 3.01) {
+    return mix(vec3(0.0), -d, coneOffset);
+  }
+
+  float nextAngle = (
+    (segmentIndex > 0.99 &&  segmentIndex < 1.01) ||
+    (segmentIndex > 4.99 &&  segmentIndex < 5.01)
+  ) ? 1.0 : 0.0;
+  float angle = 2.0 * 3.14159 * ((segment + nextAngle) / segmentCount);
+
+  vec3 v1 = mix(d, vec3(0.0), coneOffset);
+  vec3 v2 = v1 - d;
+
+  vec3 u = getOrthogonalVector(d);
+  vec3 v = normalize(cross(u, d));
+
+  vec3 x = u * cos(angle) * length(d)*0.25;
+  vec3 y = v * sin(angle) * length(d)*0.25;
+  vec3 v3 = v2 + x + y;
+  if (segmentIndex < 3.0) {
+    vec3 tx = u * sin(angle);
+    vec3 ty = v * -cos(angle);
+    vec3 tangent = tx + ty;
+    normal = normalize(cross(v3 - v1, tangent));
+  }
+
+  if (segmentIndex == 0.0) {
+    return mix(d, vec3(0.0), coneOffset);
+  }
+  return v3;
+}
+
+attribute vec4 vector;
+attribute vec4 position;
+attribute vec4 id;
+
+uniform mat4 model, view, projection;
+uniform float vectorScale, coneScale, coneOffset;
+
+varying vec3 f_position;
+varying vec4 f_id;
+
+void main() {
+  vec3 normal;
+  vec3 XYZ = getConePosition(mat3(model) * ((vectorScale * coneScale) * vector.xyz), position.w, coneOffset, normal);
+  vec4 conePosition = model * vec4(position.xyz, 1.0) + vec4(XYZ, 0.0);
+  gl_Position = projection * (view * conePosition);
+  f_id        = id;
+  f_position  = position.xyz;
+}
+`]), f = s([`precision highp float;
+#define GLSLIFY 1
+
+bool outOfRange(float a, float b, float p) {
+  return ((p > max(a, b)) ||
+          (p < min(a, b)));
+}
+
+bool outOfRange(vec2 a, vec2 b, vec2 p) {
+  return (outOfRange(a.x, b.x, p.x) ||
+          outOfRange(a.y, b.y, p.y));
+}
+
+bool outOfRange(vec3 a, vec3 b, vec3 p) {
+  return (outOfRange(a.x, b.x, p.x) ||
+          outOfRange(a.y, b.y, p.y) ||
+          outOfRange(a.z, b.z, p.z));
+}
+
+bool outOfRange(vec4 a, vec4 b, vec4 p) {
+  return outOfRange(a.xyz, b.xyz, p.xyz);
+}
+
+uniform vec3  clipBounds[2];
+uniform float pickId;
+
+varying vec3 f_position;
+varying vec4 f_id;
+
+void main() {
+  if (outOfRange(clipBounds[0], clipBounds[1], f_position)) discard;
+
+  gl_FragColor = vec4(pickId, f_id.xyz);
+}`]);
+            a.meshShader = { vertex: l, fragment: u, attributes: [{ name: "position", type: "vec4" }, { name: "color", type: "vec4" }, { name: "uv", type: "vec2" }, { name: "vector", type: "vec3" }] }, a.pickShader = { vertex: c, fragment: f, attributes: [{ name: "position", type: "vec4" }, { name: "id", type: "vec4" }, { name: "vector", type: "vec3" }] };
+          }, 620: function(i) {
+            i.exports = ["precision", "highp", "mediump", "lowp", "attribute", "const", "uniform", "varying", "break", "continue", "do", "for", "while", "if", "else", "in", "out", "inout", "float", "int", "uint", "void", "bool", "true", "false", "discard", "return", "mat2", "mat3", "mat4", "vec2", "vec3", "vec4", "ivec2", "ivec3", "ivec4", "bvec2", "bvec3", "bvec4", "sampler1D", "sampler2D", "sampler3D", "samplerCube", "sampler1DShadow", "sampler2DShadow", "struct", "asm", "class", "union", "enum", "typedef", "template", "this", "packed", "goto", "switch", "default", "inline", "noinline", "volatile", "public", "static", "extern", "external", "interface", "long", "short", "double", "half", "fixed", "unsigned", "input", "output", "hvec2", "hvec3", "hvec4", "dvec2", "dvec3", "dvec4", "fvec2", "fvec3", "fvec4", "sampler2DRect", "sampler3DRect", "sampler2DRectShadow", "sizeof", "cast", "namespace", "using"];
+          }, 665: function(i, a, o) {
+            var s = o(3202);
+            i.exports = f;
+            var l = 96;
+            function u(h, d) {
+              var v = s(getComputedStyle(h).getPropertyValue(d));
+              return v[0] * f(v[1], h);
+            }
+            function c(h, d) {
+              var v = document.createElement("div");
+              v.style["font-size"] = "128" + h, d.appendChild(v);
+              var _ = u(v, "font-size") / 128;
+              return d.removeChild(v), _;
+            }
+            function f(h, d) {
+              switch (d = d || document.body, h = (h || "px").trim().toLowerCase(), (d === window || d === document) && (d = document.body), h) {
+                case "%":
+                  return d.clientHeight / 100;
+                case "ch":
+                case "ex":
+                  return c(h, d);
+                case "em":
+                  return u(d, "font-size");
+                case "rem":
+                  return u(document.body, "font-size");
+                case "vw":
+                  return window.innerWidth / 100;
+                case "vh":
+                  return window.innerHeight / 100;
+                case "vmin":
+                  return Math.min(window.innerWidth, window.innerHeight) / 100;
+                case "vmax":
+                  return Math.max(window.innerWidth, window.innerHeight) / 100;
+                case "in":
+                  return l;
+                case "cm":
+                  return l / 2.54;
+                case "mm":
+                  return l / 25.4;
+                case "pt":
+                  return l / 72;
+                case "pc":
+                  return l / 6;
+              }
+              return 1;
+            }
+          }, 727: function(i, a, o) {
+            var s = o(2962), l = 6;
+            function u(T) {
+              var L = T === 2 ? h : T === 3 ? d : T === 4 ? v : T === 5 ? _ : b;
+              return T < 6 ? L(s[T]) : L(s);
+            }
+            function c() {
+              return [[0]];
+            }
+            function f(T, L) {
+              return [[L[0]], [T[0][0]]];
+            }
+            function h(T) {
+              return function(x, C) {
+                return [T([[+C[0], +x[0][1]], [+C[1], +x[1][1]]]), T([[+x[0][0], +C[0]], [+x[1][0], +C[1]]]), T(x)];
+              };
+            }
+            function d(T) {
+              return function(x, C) {
+                return [T([[+C[0], +x[0][1], +x[0][2]], [+C[1], +x[1][1], +x[1][2]], [+C[2], +x[2][1], +x[2][2]]]), T([[+x[0][0], +C[0], +x[0][2]], [+x[1][0], +C[1], +x[1][2]], [+x[2][0], +C[2], +x[2][2]]]), T([[+x[0][0], +x[0][1], +C[0]], [+x[1][0], +x[1][1], +C[1]], [+x[2][0], +x[2][1], +C[2]]]), T(x)];
+              };
+            }
+            function v(T) {
+              return function(x, C) {
+                return [T([[+C[0], +x[0][1], +x[0][2], +x[0][3]], [+C[1], +x[1][1], +x[1][2], +x[1][3]], [+C[2], +x[2][1], +x[2][2], +x[2][3]], [+C[3], +x[3][1], +x[3][2], +x[3][3]]]), T([[+x[0][0], +C[0], +x[0][2], +x[0][3]], [+x[1][0], +C[1], +x[1][2], +x[1][3]], [+x[2][0], +C[2], +x[2][2], +x[2][3]], [+x[3][0], +C[3], +x[3][2], +x[3][3]]]), T([[+x[0][0], +x[0][1], +C[0], +x[0][3]], [+x[1][0], +x[1][1], +C[1], +x[1][3]], [+x[2][0], +x[2][1], +C[2], +x[2][3]], [+x[3][0], +x[3][1], +C[3], +x[3][3]]]), T([[+x[0][0], +x[0][1], +x[0][2], +C[0]], [+x[1][0], +x[1][1], +x[1][2], +C[1]], [+x[2][0], +x[2][1], +x[2][2], +C[2]], [+x[3][0], +x[3][1], +x[3][2], +C[3]]]), T(x)];
+              };
+            }
+            function _(T) {
+              return function(x, C) {
+                return [T([[+C[0], +x[0][1], +x[0][2], +x[0][3], +x[0][4]], [+C[1], +x[1][1], +x[1][2], +x[1][3], +x[1][4]], [+C[2], +x[2][1], +x[2][2], +x[2][3], +x[2][4]], [+C[3], +x[3][1], +x[3][2], +x[3][3], +x[3][4]], [+C[4], +x[4][1], +x[4][2], +x[4][3], +x[4][4]]]), T([[+x[0][0], +C[0], +x[0][2], +x[0][3], +x[0][4]], [+x[1][0], +C[1], +x[1][2], +x[1][3], +x[1][4]], [+x[2][0], +C[2], +x[2][2], +x[2][3], +x[2][4]], [+x[3][0], +C[3], +x[3][2], +x[3][3], +x[3][4]], [+x[4][0], +C[4], +x[4][2], +x[4][3], +x[4][4]]]), T([[+x[0][0], +x[0][1], +C[0], +x[0][3], +x[0][4]], [+x[1][0], +x[1][1], +C[1], +x[1][3], +x[1][4]], [+x[2][0], +x[2][1], +C[2], +x[2][3], +x[2][4]], [+x[3][0], +x[3][1], +C[3], +x[3][3], +x[3][4]], [+x[4][0], +x[4][1], +C[4], +x[4][3], +x[4][4]]]), T([[+x[0][0], +x[0][1], +x[0][2], +C[0], +x[0][4]], [+x[1][0], +x[1][1], +x[1][2], +C[1], +x[1][4]], [+x[2][0], +x[2][1], +x[2][2], +C[2], +x[2][4]], [+x[3][0], +x[3][1], +x[3][2], +C[3], +x[3][4]], [+x[4][0], +x[4][1], +x[4][2], +C[4], +x[4][4]]]), T([[+x[0][0], +x[0][1], +x[0][2], +x[0][3], +C[0]], [+x[1][0], +x[1][1], +x[1][2], +x[1][3], +C[1]], [+x[2][0], +x[2][1], +x[2][2], +x[2][3], +C[2]], [+x[3][0], +x[3][1], +x[3][2], +x[3][3], +C[3]], [+x[4][0], +x[4][1], +x[4][2], +x[4][3], +C[4]]]), T(x)];
+              };
+            }
+            function b(T) {
+              return function(x, C) {
+                return [T([[+C[0], +x[0][1], +x[0][2], +x[0][3], +x[0][4], +x[0][5]], [+C[1], +x[1][1], +x[1][2], +x[1][3], +x[1][4], +x[1][5]], [+C[2], +x[2][1], +x[2][2], +x[2][3], +x[2][4], +x[2][5]], [+C[3], +x[3][1], +x[3][2], +x[3][3], +x[3][4], +x[3][5]], [+C[4], +x[4][1], +x[4][2], +x[4][3], +x[4][4], +x[4][5]], [+C[5], +x[5][1], +x[5][2], +x[5][3], +x[5][4], +x[5][5]]]), T([[+x[0][0], +C[0], +x[0][2], +x[0][3], +x[0][4], +x[0][5]], [+x[1][0], +C[1], +x[1][2], +x[1][3], +x[1][4], +x[1][5]], [+x[2][0], +C[2], +x[2][2], +x[2][3], +x[2][4], +x[2][5]], [+x[3][0], +C[3], +x[3][2], +x[3][3], +x[3][4], +x[3][5]], [+x[4][0], +C[4], +x[4][2], +x[4][3], +x[4][4], +x[4][5]], [+x[5][0], +C[5], +x[5][2], +x[5][3], +x[5][4], +x[5][5]]]), T([[+x[0][0], +x[0][1], +C[0], +x[0][3], +x[0][4], +x[0][5]], [+x[1][0], +x[1][1], +C[1], +x[1][3], +x[1][4], +x[1][5]], [+x[2][0], +x[2][1], +C[2], +x[2][3], +x[2][4], +x[2][5]], [+x[3][0], +x[3][1], +C[3], +x[3][3], +x[3][4], +x[3][5]], [+x[4][0], +x[4][1], +C[4], +x[4][3], +x[4][4], +x[4][5]], [+x[5][0], +x[5][1], +C[5], +x[5][3], +x[5][4], +x[5][5]]]), T([[+x[0][0], +x[0][1], +x[0][2], +C[0], +x[0][4], +x[0][5]], [+x[1][0], +x[1][1], +x[1][2], +C[1], +x[1][4], +x[1][5]], [+x[2][0], +x[2][1], +x[2][2], +C[2], +x[2][4], +x[2][5]], [+x[3][0], +x[3][1], +x[3][2], +C[3], +x[3][4], +x[3][5]], [+x[4][0], +x[4][1], +x[4][2], +C[4], +x[4][4], +x[4][5]], [+x[5][0], +x[5][1], +x[5][2], +C[5], +x[5][4], +x[5][5]]]), T([[+x[0][0], +x[0][1], +x[0][2], +x[0][3], +C[0], +x[0][5]], [+x[1][0], +x[1][1], +x[1][2], +x[1][3], +C[1], +x[1][5]], [+x[2][0], +x[2][1], +x[2][2], +x[2][3], +C[2], +x[2][5]], [+x[3][0], +x[3][1], +x[3][2], +x[3][3], +C[3], +x[3][5]], [+x[4][0], +x[4][1], +x[4][2], +x[4][3], +C[4], +x[4][5]], [+x[5][0], +x[5][1], +x[5][2], +x[5][3], +C[5], +x[5][5]]]), T([[+x[0][0], +x[0][1], +x[0][2], +x[0][3], +x[0][4], +C[0]], [+x[1][0], +x[1][1], +x[1][2], +x[1][3], +x[1][4], +C[1]], [+x[2][0], +x[2][1], +x[2][2], +x[2][3], +x[2][4], +C[2]], [+x[3][0], +x[3][1], +x[3][2], +x[3][3], +x[3][4], +C[3]], [+x[4][0], +x[4][1], +x[4][2], +x[4][3], +x[4][4], +C[4]], [+x[5][0], +x[5][1], +x[5][2], +x[5][3], +x[5][4], +C[5]]]), T(x)];
+              };
+            }
+            var p = [c, f];
+            function k(T, L, x, C, M, g, P, A) {
+              return function(O, U) {
+                switch (O.length) {
+                  case 0:
+                    return T(O, U);
+                  case 1:
+                    return L(O, U);
+                  case 2:
+                    return x(O, U);
+                  case 3:
+                    return C(O, U);
+                  case 4:
+                    return M(O, U);
+                  case 5:
+                    return g(O, U);
+                }
+                var G = P[O.length];
+                return G || (G = P[O.length] = A(O.length)), G(O, U);
+              };
+            }
+            function E() {
+              for (; p.length < l; ) p.push(u(p.length));
+              i.exports = k.apply(void 0, p.concat([p, u]));
+              for (var T = 0; T < l; ++T) i.exports[T] = p[T];
+            }
+            E();
+          }, 737: function(i) {
+            i.exports = { 0: "NONE", 1: "ONE", 2: "LINE_LOOP", 3: "LINE_STRIP", 4: "TRIANGLES", 5: "TRIANGLE_STRIP", 6: "TRIANGLE_FAN", 256: "DEPTH_BUFFER_BIT", 512: "NEVER", 513: "LESS", 514: "EQUAL", 515: "LEQUAL", 516: "GREATER", 517: "NOTEQUAL", 518: "GEQUAL", 519: "ALWAYS", 768: "SRC_COLOR", 769: "ONE_MINUS_SRC_COLOR", 770: "SRC_ALPHA", 771: "ONE_MINUS_SRC_ALPHA", 772: "DST_ALPHA", 773: "ONE_MINUS_DST_ALPHA", 774: "DST_COLOR", 775: "ONE_MINUS_DST_COLOR", 776: "SRC_ALPHA_SATURATE", 1024: "STENCIL_BUFFER_BIT", 1028: "FRONT", 1029: "BACK", 1032: "FRONT_AND_BACK", 1280: "INVALID_ENUM", 1281: "INVALID_VALUE", 1282: "INVALID_OPERATION", 1285: "OUT_OF_MEMORY", 1286: "INVALID_FRAMEBUFFER_OPERATION", 2304: "CW", 2305: "CCW", 2849: "LINE_WIDTH", 2884: "CULL_FACE", 2885: "CULL_FACE_MODE", 2886: "FRONT_FACE", 2928: "DEPTH_RANGE", 2929: "DEPTH_TEST", 2930: "DEPTH_WRITEMASK", 2931: "DEPTH_CLEAR_VALUE", 2932: "DEPTH_FUNC", 2960: "STENCIL_TEST", 2961: "STENCIL_CLEAR_VALUE", 2962: "STENCIL_FUNC", 2963: "STENCIL_VALUE_MASK", 2964: "STENCIL_FAIL", 2965: "STENCIL_PASS_DEPTH_FAIL", 2966: "STENCIL_PASS_DEPTH_PASS", 2967: "STENCIL_REF", 2968: "STENCIL_WRITEMASK", 2978: "VIEWPORT", 3024: "DITHER", 3042: "BLEND", 3088: "SCISSOR_BOX", 3089: "SCISSOR_TEST", 3106: "COLOR_CLEAR_VALUE", 3107: "COLOR_WRITEMASK", 3317: "UNPACK_ALIGNMENT", 3333: "PACK_ALIGNMENT", 3379: "MAX_TEXTURE_SIZE", 3386: "MAX_VIEWPORT_DIMS", 3408: "SUBPIXEL_BITS", 3410: "RED_BITS", 3411: "GREEN_BITS", 3412: "BLUE_BITS", 3413: "ALPHA_BITS", 3414: "DEPTH_BITS", 3415: "STENCIL_BITS", 3553: "TEXTURE_2D", 4352: "DONT_CARE", 4353: "FASTEST", 4354: "NICEST", 5120: "BYTE", 5121: "UNSIGNED_BYTE", 5122: "SHORT", 5123: "UNSIGNED_SHORT", 5124: "INT", 5125: "UNSIGNED_INT", 5126: "FLOAT", 5386: "INVERT", 5890: "TEXTURE", 6401: "STENCIL_INDEX", 6402: "DEPTH_COMPONENT", 6406: "ALPHA", 6407: "RGB", 6408: "RGBA", 6409: "LUMINANCE", 6410: "LUMINANCE_ALPHA", 7680: "KEEP", 7681: "REPLACE", 7682: "INCR", 7683: "DECR", 7936: "VENDOR", 7937: "RENDERER", 7938: "VERSION", 9728: "NEAREST", 9729: "LINEAR", 9984: "NEAREST_MIPMAP_NEAREST", 9985: "LINEAR_MIPMAP_NEAREST", 9986: "NEAREST_MIPMAP_LINEAR", 9987: "LINEAR_MIPMAP_LINEAR", 10240: "TEXTURE_MAG_FILTER", 10241: "TEXTURE_MIN_FILTER", 10242: "TEXTURE_WRAP_S", 10243: "TEXTURE_WRAP_T", 10497: "REPEAT", 10752: "POLYGON_OFFSET_UNITS", 16384: "COLOR_BUFFER_BIT", 32769: "CONSTANT_COLOR", 32770: "ONE_MINUS_CONSTANT_COLOR", 32771: "CONSTANT_ALPHA", 32772: "ONE_MINUS_CONSTANT_ALPHA", 32773: "BLEND_COLOR", 32774: "FUNC_ADD", 32777: "BLEND_EQUATION_RGB", 32778: "FUNC_SUBTRACT", 32779: "FUNC_REVERSE_SUBTRACT", 32819: "UNSIGNED_SHORT_4_4_4_4", 32820: "UNSIGNED_SHORT_5_5_5_1", 32823: "POLYGON_OFFSET_FILL", 32824: "POLYGON_OFFSET_FACTOR", 32854: "RGBA4", 32855: "RGB5_A1", 32873: "TEXTURE_BINDING_2D", 32926: "SAMPLE_ALPHA_TO_COVERAGE", 32928: "SAMPLE_COVERAGE", 32936: "SAMPLE_BUFFERS", 32937: "SAMPLES", 32938: "SAMPLE_COVERAGE_VALUE", 32939: "SAMPLE_COVERAGE_INVERT", 32968: "BLEND_DST_RGB", 32969: "BLEND_SRC_RGB", 32970: "BLEND_DST_ALPHA", 32971: "BLEND_SRC_ALPHA", 33071: "CLAMP_TO_EDGE", 33170: "GENERATE_MIPMAP_HINT", 33189: "DEPTH_COMPONENT16", 33306: "DEPTH_STENCIL_ATTACHMENT", 33635: "UNSIGNED_SHORT_5_6_5", 33648: "MIRRORED_REPEAT", 33901: "ALIASED_POINT_SIZE_RANGE", 33902: "ALIASED_LINE_WIDTH_RANGE", 33984: "TEXTURE0", 33985: "TEXTURE1", 33986: "TEXTURE2", 33987: "TEXTURE3", 33988: "TEXTURE4", 33989: "TEXTURE5", 33990: "TEXTURE6", 33991: "TEXTURE7", 33992: "TEXTURE8", 33993: "TEXTURE9", 33994: "TEXTURE10", 33995: "TEXTURE11", 33996: "TEXTURE12", 33997: "TEXTURE13", 33998: "TEXTURE14", 33999: "TEXTURE15", 34e3: "TEXTURE16", 34001: "TEXTURE17", 34002: "TEXTURE18", 34003: "TEXTURE19", 34004: "TEXTURE20", 34005: "TEXTURE21", 34006: "TEXTURE22", 34007: "TEXTURE23", 34008: "TEXTURE24", 34009: "TEXTURE25", 34010: "TEXTURE26", 34011: "TEXTURE27", 34012: "TEXTURE28", 34013: "TEXTURE29", 34014: "TEXTURE30", 34015: "TEXTURE31", 34016: "ACTIVE_TEXTURE", 34024: "MAX_RENDERBUFFER_SIZE", 34041: "DEPTH_STENCIL", 34055: "INCR_WRAP", 34056: "DECR_WRAP", 34067: "TEXTURE_CUBE_MAP", 34068: "TEXTURE_BINDING_CUBE_MAP", 34069: "TEXTURE_CUBE_MAP_POSITIVE_X", 34070: "TEXTURE_CUBE_MAP_NEGATIVE_X", 34071: "TEXTURE_CUBE_MAP_POSITIVE_Y", 34072: "TEXTURE_CUBE_MAP_NEGATIVE_Y", 34073: "TEXTURE_CUBE_MAP_POSITIVE_Z", 34074: "TEXTURE_CUBE_MAP_NEGATIVE_Z", 34076: "MAX_CUBE_MAP_TEXTURE_SIZE", 34338: "VERTEX_ATTRIB_ARRAY_ENABLED", 34339: "VERTEX_ATTRIB_ARRAY_SIZE", 34340: "VERTEX_ATTRIB_ARRAY_STRIDE", 34341: "VERTEX_ATTRIB_ARRAY_TYPE", 34342: "CURRENT_VERTEX_ATTRIB", 34373: "VERTEX_ATTRIB_ARRAY_POINTER", 34466: "NUM_COMPRESSED_TEXTURE_FORMATS", 34467: "COMPRESSED_TEXTURE_FORMATS", 34660: "BUFFER_SIZE", 34661: "BUFFER_USAGE", 34816: "STENCIL_BACK_FUNC", 34817: "STENCIL_BACK_FAIL", 34818: "STENCIL_BACK_PASS_DEPTH_FAIL", 34819: "STENCIL_BACK_PASS_DEPTH_PASS", 34877: "BLEND_EQUATION_ALPHA", 34921: "MAX_VERTEX_ATTRIBS", 34922: "VERTEX_ATTRIB_ARRAY_NORMALIZED", 34930: "MAX_TEXTURE_IMAGE_UNITS", 34962: "ARRAY_BUFFER", 34963: "ELEMENT_ARRAY_BUFFER", 34964: "ARRAY_BUFFER_BINDING", 34965: "ELEMENT_ARRAY_BUFFER_BINDING", 34975: "VERTEX_ATTRIB_ARRAY_BUFFER_BINDING", 35040: "STREAM_DRAW", 35044: "STATIC_DRAW", 35048: "DYNAMIC_DRAW", 35632: "FRAGMENT_SHADER", 35633: "VERTEX_SHADER", 35660: "MAX_VERTEX_TEXTURE_IMAGE_UNITS", 35661: "MAX_COMBINED_TEXTURE_IMAGE_UNITS", 35663: "SHADER_TYPE", 35664: "FLOAT_VEC2", 35665: "FLOAT_VEC3", 35666: "FLOAT_VEC4", 35667: "INT_VEC2", 35668: "INT_VEC3", 35669: "INT_VEC4", 35670: "BOOL", 35671: "BOOL_VEC2", 35672: "BOOL_VEC3", 35673: "BOOL_VEC4", 35674: "FLOAT_MAT2", 35675: "FLOAT_MAT3", 35676: "FLOAT_MAT4", 35678: "SAMPLER_2D", 35680: "SAMPLER_CUBE", 35712: "DELETE_STATUS", 35713: "COMPILE_STATUS", 35714: "LINK_STATUS", 35715: "VALIDATE_STATUS", 35716: "INFO_LOG_LENGTH", 35717: "ATTACHED_SHADERS", 35718: "ACTIVE_UNIFORMS", 35719: "ACTIVE_UNIFORM_MAX_LENGTH", 35720: "SHADER_SOURCE_LENGTH", 35721: "ACTIVE_ATTRIBUTES", 35722: "ACTIVE_ATTRIBUTE_MAX_LENGTH", 35724: "SHADING_LANGUAGE_VERSION", 35725: "CURRENT_PROGRAM", 36003: "STENCIL_BACK_REF", 36004: "STENCIL_BACK_VALUE_MASK", 36005: "STENCIL_BACK_WRITEMASK", 36006: "FRAMEBUFFER_BINDING", 36007: "RENDERBUFFER_BINDING", 36048: "FRAMEBUFFER_ATTACHMENT_OBJECT_TYPE", 36049: "FRAMEBUFFER_ATTACHMENT_OBJECT_NAME", 36050: "FRAMEBUFFER_ATTACHMENT_TEXTURE_LEVEL", 36051: "FRAMEBUFFER_ATTACHMENT_TEXTURE_CUBE_MAP_FACE", 36053: "FRAMEBUFFER_COMPLETE", 36054: "FRAMEBUFFER_INCOMPLETE_ATTACHMENT", 36055: "FRAMEBUFFER_INCOMPLETE_MISSING_ATTACHMENT", 36057: "FRAMEBUFFER_INCOMPLETE_DIMENSIONS", 36061: "FRAMEBUFFER_UNSUPPORTED", 36064: "COLOR_ATTACHMENT0", 36096: "DEPTH_ATTACHMENT", 36128: "STENCIL_ATTACHMENT", 36160: "FRAMEBUFFER", 36161: "RENDERBUFFER", 36162: "RENDERBUFFER_WIDTH", 36163: "RENDERBUFFER_HEIGHT", 36164: "RENDERBUFFER_INTERNAL_FORMAT", 36168: "STENCIL_INDEX8", 36176: "RENDERBUFFER_RED_SIZE", 36177: "RENDERBUFFER_GREEN_SIZE", 36178: "RENDERBUFFER_BLUE_SIZE", 36179: "RENDERBUFFER_ALPHA_SIZE", 36180: "RENDERBUFFER_DEPTH_SIZE", 36181: "RENDERBUFFER_STENCIL_SIZE", 36194: "RGB565", 36336: "LOW_FLOAT", 36337: "MEDIUM_FLOAT", 36338: "HIGH_FLOAT", 36339: "LOW_INT", 36340: "MEDIUM_INT", 36341: "HIGH_INT", 36346: "SHADER_COMPILER", 36347: "MAX_VERTEX_UNIFORM_VECTORS", 36348: "MAX_VARYING_VECTORS", 36349: "MAX_FRAGMENT_UNIFORM_VECTORS", 37440: "UNPACK_FLIP_Y_WEBGL", 37441: "UNPACK_PREMULTIPLY_ALPHA_WEBGL", 37442: "CONTEXT_LOST_WEBGL", 37443: "UNPACK_COLORSPACE_CONVERSION_WEBGL", 37444: "BROWSER_DEFAULT_WEBGL" };
+          }, 781: function(i, a, o) {
+            i.exports = l;
+            var s = o(3349);
+            function l(u, c) {
+              var f = [];
+              return c = +c || 0, s(u.hi(u.shape[0] - 1), f, c), f;
+            }
+          }, 783: function(i) {
+            i.exports = a;
+            function a(o, s, l, u) {
+              var c = s[0], f = s[1], h = s[2], d = s[3], v = l[0], _ = l[1], b = l[2], p = l[3], k, E, T, L, x;
+              return E = c * v + f * _ + h * b + d * p, E < 0 && (E = -E, v = -v, _ = -_, b = -b, p = -p), 1 - E > 1e-6 ? (k = Math.acos(E), T = Math.sin(k), L = Math.sin((1 - u) * k) / T, x = Math.sin(u * k) / T) : (L = 1 - u, x = u), o[0] = L * c + x * v, o[1] = L * f + x * _, o[2] = L * h + x * b, o[3] = L * d + x * p, o;
+            }
+          }, 799: function(i, a, o) {
+            var s = o(3236), l = o(9405), u = s([`precision mediump float;
+#define GLSLIFY 1
+attribute vec2 position;
+varying vec2 uv;
+void main() {
+  uv = position;
+  gl_Position = vec4(position, 0, 1);
+}`]), c = s([`precision mediump float;
+#define GLSLIFY 1
+
+uniform sampler2D accumBuffer;
+varying vec2 uv;
+
+void main() {
+  vec4 accum = texture2D(accumBuffer, 0.5 * (uv + 1.0));
+  gl_FragColor = min(vec4(1,1,1,1), accum);
+}`]);
+            i.exports = function(f) {
+              return l(f, u, c, null, [{ name: "position", type: "vec2" }]);
+            };
+          }, 811: function(i) {
+            i.exports = a;
+            function a(o, s) {
+              return o[0] = 1 / s[0], o[1] = 1 / s[1], o[2] = 1 / s[2], o;
+            }
+          }, 840: function(i, a, o) {
+            var s = o(3236), l = s([`precision highp float;
+#define GLSLIFY 1
+
+attribute vec3 position, normal;
+attribute vec4 color;
+attribute vec2 uv;
+
+uniform mat4 model
+           , view
+           , projection
+           , inverseModel;
+uniform vec3 eyePosition
+           , lightPosition;
+
+varying vec3 f_normal
+           , f_lightDirection
+           , f_eyeDirection
+           , f_data;
+varying vec4 f_color;
+varying vec2 f_uv;
+
+vec4 project(vec3 p) {
+  return projection * (view * (model * vec4(p, 1.0)));
+}
+
+void main() {
+  gl_Position      = project(position);
+
+  //Lighting geometry parameters
+  vec4 cameraCoordinate = view * vec4(position , 1.0);
+  cameraCoordinate.xyz /= cameraCoordinate.w;
+  f_lightDirection = lightPosition - cameraCoordinate.xyz;
+  f_eyeDirection   = eyePosition - cameraCoordinate.xyz;
+  f_normal  = normalize((vec4(normal, 0.0) * inverseModel).xyz);
+
+  f_color          = color;
+  f_data           = position;
+  f_uv             = uv;
+}
+`]), u = s([`#extension GL_OES_standard_derivatives : enable
+
+precision highp float;
+#define GLSLIFY 1
+
+float beckmannDistribution(float x, float roughness) {
+  float NdotH = max(x, 0.0001);
+  float cos2Alpha = NdotH * NdotH;
+  float tan2Alpha = (cos2Alpha - 1.0) / cos2Alpha;
+  float roughness2 = roughness * roughness;
+  float denom = 3.141592653589793 * roughness2 * cos2Alpha * cos2Alpha;
+  return exp(tan2Alpha / roughness2) / denom;
+}
+
+float cookTorranceSpecular(
+  vec3 lightDirection,
+  vec3 viewDirection,
+  vec3 surfaceNormal,
+  float roughness,
+  float fresnel) {
+
+  float VdotN = max(dot(viewDirection, surfaceNormal), 0.0);
+  float LdotN = max(dot(lightDirection, surfaceNormal), 0.0);
+
+  //Half angle vector
+  vec3 H = normalize(lightDirection + viewDirection);
+
+  //Geometric term
+  float NdotH = max(dot(surfaceNormal, H), 0.0);
+  float VdotH = max(dot(viewDirection, H), 0.000001);
+  float LdotH = max(dot(lightDirection, H), 0.000001);
+  float G1 = (2.0 * NdotH * VdotN) / VdotH;
+  float G2 = (2.0 * NdotH * LdotN) / LdotH;
+  float G = min(1.0, min(G1, G2));
+
+  //Distribution term
+  float D = beckmannDistribution(NdotH, roughness);
+
+  //Fresnel term
+  float F = pow(1.0 - VdotN, fresnel);
+
+  //Multiply terms and done
+  return  G * F * D / max(3.14159265 * VdotN, 0.000001);
+}
+
+//#pragma glslify: beckmann = require(glsl-specular-beckmann) // used in gl-surface3d
+
+bool outOfRange(float a, float b, float p) {
+  return ((p > max(a, b)) ||
+          (p < min(a, b)));
+}
+
+bool outOfRange(vec2 a, vec2 b, vec2 p) {
+  return (outOfRange(a.x, b.x, p.x) ||
+          outOfRange(a.y, b.y, p.y));
+}
+
+bool outOfRange(vec3 a, vec3 b, vec3 p) {
+  return (outOfRange(a.x, b.x, p.x) ||
+          outOfRange(a.y, b.y, p.y) ||
+          outOfRange(a.z, b.z, p.z));
+}
+
+bool outOfRange(vec4 a, vec4 b, vec4 p) {
+  return outOfRange(a.xyz, b.xyz, p.xyz);
+}
+
+uniform vec3 clipBounds[2];
+uniform float roughness
+            , fresnel
+            , kambient
+            , kdiffuse
+            , kspecular;
+uniform sampler2D texture;
+
+varying vec3 f_normal
+           , f_lightDirection
+           , f_eyeDirection
+           , f_data;
+varying vec4 f_color;
+varying vec2 f_uv;
+
+void main() {
+  if (f_color.a == 0.0 ||
+    outOfRange(clipBounds[0], clipBounds[1], f_data)
+  ) discard;
+
+  vec3 N = normalize(f_normal);
+  vec3 L = normalize(f_lightDirection);
+  vec3 V = normalize(f_eyeDirection);
+
+  if(gl_FrontFacing) {
+    N = -N;
+  }
+
+  float specular = min(1.0, max(0.0, cookTorranceSpecular(L, V, N, roughness, fresnel)));
+  //float specular = max(0.0, beckmann(L, V, N, roughness)); // used in gl-surface3d
+
+  float diffuse  = min(kambient + kdiffuse * max(dot(N, L), 0.0), 1.0);
+
+  vec4 surfaceColor = vec4(f_color.rgb, 1.0) * texture2D(texture, f_uv);
+  vec4 litColor = surfaceColor.a * vec4(diffuse * surfaceColor.rgb + kspecular * vec3(1,1,1) * specular,  1.0);
+
+  gl_FragColor = litColor * f_color.a;
+}
+`]), c = s([`precision highp float;
+#define GLSLIFY 1
+
+attribute vec3 position;
+attribute vec4 color;
+attribute vec2 uv;
+
+uniform mat4 model, view, projection;
+
+varying vec4 f_color;
+varying vec3 f_data;
+varying vec2 f_uv;
+
+void main() {
+  gl_Position = projection * (view * (model * vec4(position, 1.0)));
+  f_color = color;
+  f_data  = position;
+  f_uv    = uv;
+}`]), f = s([`precision highp float;
+#define GLSLIFY 1
+
+bool outOfRange(float a, float b, float p) {
+  return ((p > max(a, b)) ||
+          (p < min(a, b)));
+}
+
+bool outOfRange(vec2 a, vec2 b, vec2 p) {
+  return (outOfRange(a.x, b.x, p.x) ||
+          outOfRange(a.y, b.y, p.y));
+}
+
+bool outOfRange(vec3 a, vec3 b, vec3 p) {
+  return (outOfRange(a.x, b.x, p.x) ||
+          outOfRange(a.y, b.y, p.y) ||
+          outOfRange(a.z, b.z, p.z));
+}
+
+bool outOfRange(vec4 a, vec4 b, vec4 p) {
+  return outOfRange(a.xyz, b.xyz, p.xyz);
+}
+
+uniform vec3 clipBounds[2];
+uniform sampler2D texture;
+uniform float opacity;
+
+varying vec4 f_color;
+varying vec3 f_data;
+varying vec2 f_uv;
+
+void main() {
+  if (outOfRange(clipBounds[0], clipBounds[1], f_data)) discard;
+
+  gl_FragColor = f_color * texture2D(texture, f_uv) * opacity;
+}`]), h = s([`precision highp float;
+#define GLSLIFY 1
+
+bool outOfRange(float a, float b, float p) {
+  return ((p > max(a, b)) ||
+          (p < min(a, b)));
+}
+
+bool outOfRange(vec2 a, vec2 b, vec2 p) {
+  return (outOfRange(a.x, b.x, p.x) ||
+          outOfRange(a.y, b.y, p.y));
+}
+
+bool outOfRange(vec3 a, vec3 b, vec3 p) {
+  return (outOfRange(a.x, b.x, p.x) ||
+          outOfRange(a.y, b.y, p.y) ||
+          outOfRange(a.z, b.z, p.z));
+}
+
+bool outOfRange(vec4 a, vec4 b, vec4 p) {
+  return outOfRange(a.xyz, b.xyz, p.xyz);
+}
+
+attribute vec3 position;
+attribute vec4 color;
+attribute vec2 uv;
+attribute float pointSize;
+
+uniform mat4 model, view, projection;
+uniform vec3 clipBounds[2];
+
+varying vec4 f_color;
+varying vec2 f_uv;
+
+void main() {
+  if (outOfRange(clipBounds[0], clipBounds[1], position)) {
+
+    gl_Position = vec4(0.0, 0.0 ,0.0 ,0.0);
+  } else {
+    gl_Position = projection * (view * (model * vec4(position, 1.0)));
+  }
+  gl_PointSize = pointSize;
+  f_color = color;
+  f_uv = uv;
+}`]), d = s([`precision highp float;
+#define GLSLIFY 1
+
+uniform sampler2D texture;
+uniform float opacity;
+
+varying vec4 f_color;
+varying vec2 f_uv;
+
+void main() {
+  vec2 pointR = gl_PointCoord.xy - vec2(0.5, 0.5);
+  if(dot(pointR, pointR) > 0.25) {
+    discard;
+  }
+  gl_FragColor = f_color * texture2D(texture, f_uv) * opacity;
+}`]), v = s([`precision highp float;
+#define GLSLIFY 1
+
+attribute vec3 position;
+attribute vec4 id;
+
+uniform mat4 model, view, projection;
+
+varying vec3 f_position;
+varying vec4 f_id;
+
+void main() {
+  gl_Position = projection * (view * (model * vec4(position, 1.0)));
+  f_id        = id;
+  f_position  = position;
+}`]), _ = s([`precision highp float;
+#define GLSLIFY 1
+
+bool outOfRange(float a, float b, float p) {
+  return ((p > max(a, b)) ||
+          (p < min(a, b)));
+}
+
+bool outOfRange(vec2 a, vec2 b, vec2 p) {
+  return (outOfRange(a.x, b.x, p.x) ||
+          outOfRange(a.y, b.y, p.y));
+}
+
+bool outOfRange(vec3 a, vec3 b, vec3 p) {
+  return (outOfRange(a.x, b.x, p.x) ||
+          outOfRange(a.y, b.y, p.y) ||
+          outOfRange(a.z, b.z, p.z));
+}
+
+bool outOfRange(vec4 a, vec4 b, vec4 p) {
+  return outOfRange(a.xyz, b.xyz, p.xyz);
+}
+
+uniform vec3  clipBounds[2];
+uniform float pickId;
+
+varying vec3 f_position;
+varying vec4 f_id;
+
+void main() {
+  if (outOfRange(clipBounds[0], clipBounds[1], f_position)) discard;
+
+  gl_FragColor = vec4(pickId, f_id.xyz);
+}`]), b = s([`precision highp float;
+#define GLSLIFY 1
+
+bool outOfRange(float a, float b, float p) {
+  return ((p > max(a, b)) ||
+          (p < min(a, b)));
+}
+
+bool outOfRange(vec2 a, vec2 b, vec2 p) {
+  return (outOfRange(a.x, b.x, p.x) ||
+          outOfRange(a.y, b.y, p.y));
+}
+
+bool outOfRange(vec3 a, vec3 b, vec3 p) {
+  return (outOfRange(a.x, b.x, p.x) ||
+          outOfRange(a.y, b.y, p.y) ||
+          outOfRange(a.z, b.z, p.z));
+}
+
+bool outOfRange(vec4 a, vec4 b, vec4 p) {
+  return outOfRange(a.xyz, b.xyz, p.xyz);
+}
+
+attribute vec3  position;
+attribute float pointSize;
+attribute vec4  id;
+
+uniform mat4 model, view, projection;
+uniform vec3 clipBounds[2];
+
+varying vec3 f_position;
+varying vec4 f_id;
+
+void main() {
+  if (outOfRange(clipBounds[0], clipBounds[1], position)) {
+
+    gl_Position = vec4(0.0, 0.0, 0.0, 0.0);
+  } else {
+    gl_Position  = projection * (view * (model * vec4(position, 1.0)));
+    gl_PointSize = pointSize;
+  }
+  f_id         = id;
+  f_position   = position;
+}`]), p = s([`precision highp float;
+#define GLSLIFY 1
+
+attribute vec3 position;
+
+uniform mat4 model, view, projection;
+
+void main() {
+  gl_Position = projection * (view * (model * vec4(position, 1.0)));
+}`]), k = s([`precision highp float;
+#define GLSLIFY 1
+
+uniform vec3 contourColor;
+
+void main() {
+  gl_FragColor = vec4(contourColor, 1.0);
+}
+`]);
+            a.meshShader = { vertex: l, fragment: u, attributes: [{ name: "position", type: "vec3" }, { name: "normal", type: "vec3" }, { name: "color", type: "vec4" }, { name: "uv", type: "vec2" }] }, a.wireShader = { vertex: c, fragment: f, attributes: [{ name: "position", type: "vec3" }, { name: "color", type: "vec4" }, { name: "uv", type: "vec2" }] }, a.pointShader = { vertex: h, fragment: d, attributes: [{ name: "position", type: "vec3" }, { name: "color", type: "vec4" }, { name: "uv", type: "vec2" }, { name: "pointSize", type: "float" }] }, a.pickShader = { vertex: v, fragment: _, attributes: [{ name: "position", type: "vec3" }, { name: "id", type: "vec4" }] }, a.pointPickShader = { vertex: b, fragment: _, attributes: [{ name: "position", type: "vec3" }, { name: "pointSize", type: "float" }, { name: "id", type: "vec4" }] }, a.contourShader = { vertex: p, fragment: k, attributes: [{ name: "position", type: "vec3" }] };
+          }, 855: function(i, a, o) {
+            i.exports = { init: E, sweepBipartite: x, sweepComplete: C, scanBipartite: M, scanComplete: g };
+            var s = o(1888), l = o(8828), u = o(4192), c = 1 << 28, f = 1024, h = s.mallocInt32(f), d = s.mallocInt32(f), v = s.mallocInt32(f), _ = s.mallocInt32(f), b = s.mallocInt32(f), p = s.mallocInt32(f), k = s.mallocDouble(f * 8);
+            function E(P) {
+              var A = l.nextPow2(P);
+              h.length < A && (s.free(h), h = s.mallocInt32(A)), d.length < A && (s.free(d), d = s.mallocInt32(A)), v.length < A && (s.free(v), v = s.mallocInt32(A)), _.length < A && (s.free(_), _ = s.mallocInt32(A)), b.length < A && (s.free(b), b = s.mallocInt32(A)), p.length < A && (s.free(p), p = s.mallocInt32(A));
+              var z = 8 * A;
+              k.length < z && (s.free(k), k = s.mallocDouble(z));
+            }
+            function T(P, A, z, O) {
+              var U = A[O], G = P[z - 1];
+              P[U] = G, A[G] = U;
+            }
+            function L(P, A, z, O) {
+              P[z] = O, A[O] = z;
+            }
+            function x(P, A, z, O, U, G, Z, j, N, H) {
+              for (var re = 0, oe = 2 * P, _e = P - 1, Ce = oe - 1, Le = z; Le < O; ++Le) {
+                var ge = G[Le], ie = oe * Le;
+                k[re++] = U[ie + _e], k[re++] = -(ge + 1), k[re++] = U[ie + Ce], k[re++] = ge;
+              }
+              for (var Le = Z; Le < j; ++Le) {
+                var ge = H[Le] + c, Se = oe * Le;
+                k[re++] = N[Se + _e], k[re++] = -ge, k[re++] = N[Se + Ce], k[re++] = ge;
+              }
+              var Ee = re >>> 1;
+              u(k, Ee);
+              for (var Ae = 0, Be = 0, Le = 0; Le < Ee; ++Le) {
+                var Pe = k[2 * Le + 1] | 0;
+                if (Pe >= c) Pe = Pe - c | 0, T(v, _, Be--, Pe);
+                else if (Pe >= 0) T(h, d, Ae--, Pe);
+                else if (Pe <= -268435456) {
+                  Pe = -Pe - c | 0;
+                  for (var me = 0; me < Ae; ++me) {
+                    var De = A(h[me], Pe);
+                    if (De !== void 0) return De;
+                  }
+                  L(v, _, Be++, Pe);
+                } else {
+                  Pe = -Pe - 1 | 0;
+                  for (var me = 0; me < Be; ++me) {
+                    var De = A(Pe, v[me]);
+                    if (De !== void 0) return De;
+                  }
+                  L(h, d, Ae++, Pe);
+                }
+              }
+            }
+            function C(P, A, z, O, U, G, Z, j, N, H) {
+              for (var re = 0, oe = 2 * P, _e = P - 1, Ce = oe - 1, Le = z; Le < O; ++Le) {
+                var ge = G[Le] + 1 << 1, ie = oe * Le;
+                k[re++] = U[ie + _e], k[re++] = -ge, k[re++] = U[ie + Ce], k[re++] = ge;
+              }
+              for (var Le = Z; Le < j; ++Le) {
+                var ge = H[Le] + 1 << 1, Se = oe * Le;
+                k[re++] = N[Se + _e], k[re++] = -ge | 1, k[re++] = N[Se + Ce], k[re++] = ge | 1;
+              }
+              var Ee = re >>> 1;
+              u(k, Ee);
+              for (var Ae = 0, Be = 0, Pe = 0, Le = 0; Le < Ee; ++Le) {
+                var me = k[2 * Le + 1] | 0, De = me & 1;
+                if (Le < Ee - 1 && me >> 1 === k[2 * Le + 3] >> 1 && (De = 2, Le += 1), me < 0) {
+                  for (var ce = -(me >> 1) - 1, je = 0; je < Pe; ++je) {
+                    var lt = A(b[je], ce);
+                    if (lt !== void 0) return lt;
+                  }
+                  if (De !== 0) for (var je = 0; je < Ae; ++je) {
+                    var lt = A(h[je], ce);
+                    if (lt !== void 0) return lt;
+                  }
+                  if (De !== 1) for (var je = 0; je < Be; ++je) {
+                    var lt = A(v[je], ce);
+                    if (lt !== void 0) return lt;
+                  }
+                  De === 0 ? L(h, d, Ae++, ce) : De === 1 ? L(v, _, Be++, ce) : De === 2 && L(b, p, Pe++, ce);
+                } else {
+                  var ce = (me >> 1) - 1;
+                  De === 0 ? T(h, d, Ae--, ce) : De === 1 ? T(v, _, Be--, ce) : De === 2 && T(b, p, Pe--, ce);
+                }
+              }
+            }
+            function M(P, A, z, O, U, G, Z, j, N, H, re, oe) {
+              var _e = 0, Ce = 2 * P, Le = A, ge = A + P, ie = 1, Se = 1;
+              O ? Se = c : ie = c;
+              for (var Ee = U; Ee < G; ++Ee) {
+                var Ae = Ee + ie, Be = Ce * Ee;
+                k[_e++] = Z[Be + Le], k[_e++] = -Ae, k[_e++] = Z[Be + ge], k[_e++] = Ae;
+              }
+              for (var Ee = N; Ee < H; ++Ee) {
+                var Ae = Ee + Se, Pe = Ce * Ee;
+                k[_e++] = re[Pe + Le], k[_e++] = -Ae;
+              }
+              var me = _e >>> 1;
+              u(k, me);
+              for (var De = 0, Ee = 0; Ee < me; ++Ee) {
+                var ce = k[2 * Ee + 1] | 0;
+                if (ce < 0) {
+                  var Ae = -ce, je = false;
+                  if (Ae >= c ? (je = !O, Ae -= c) : (je = !!O, Ae -= 1), je) L(h, d, De++, Ae);
+                  else {
+                    var lt = oe[Ae], pt = Ce * Ae, Vt = re[pt + A + 1], ot = re[pt + A + 1 + P];
+                    e: for (var ut = 0; ut < De; ++ut) {
+                      var Wt = h[ut], Nt = Ce * Wt;
+                      if (!(ot < Z[Nt + A + 1] || Z[Nt + A + 1 + P] < Vt)) {
+                        for (var $t = A + 2; $t < P; ++$t) if (re[pt + $t + P] < Z[Nt + $t] || Z[Nt + $t + P] < re[pt + $t]) continue e;
+                        var sr = j[Wt], Tr;
+                        if (O ? Tr = z(lt, sr) : Tr = z(sr, lt), Tr !== void 0) return Tr;
+                      }
+                    }
+                  }
+                } else T(h, d, De--, ce - ie);
+              }
+            }
+            function g(P, A, z, O, U, G, Z, j, N, H, re) {
+              for (var oe = 0, _e = 2 * P, Ce = A, Le = A + P, ge = O; ge < U; ++ge) {
+                var ie = ge + c, Se = _e * ge;
+                k[oe++] = G[Se + Ce], k[oe++] = -ie, k[oe++] = G[Se + Le], k[oe++] = ie;
+              }
+              for (var ge = j; ge < N; ++ge) {
+                var ie = ge + 1, Ee = _e * ge;
+                k[oe++] = H[Ee + Ce], k[oe++] = -ie;
+              }
+              var Ae = oe >>> 1;
+              u(k, Ae);
+              for (var Be = 0, ge = 0; ge < Ae; ++ge) {
+                var Pe = k[2 * ge + 1] | 0;
+                if (Pe < 0) {
+                  var ie = -Pe;
+                  if (ie >= c) h[Be++] = ie - c;
+                  else {
+                    ie -= 1;
+                    var me = re[ie], De = _e * ie, ce = H[De + A + 1], je = H[De + A + 1 + P];
+                    e: for (var lt = 0; lt < Be; ++lt) {
+                      var pt = h[lt], Vt = Z[pt];
+                      if (Vt === me) break;
+                      var ot = _e * pt;
+                      if (!(je < G[ot + A + 1] || G[ot + A + 1 + P] < ce)) {
+                        for (var ut = A + 2; ut < P; ++ut) if (H[De + ut + P] < G[ot + ut] || G[ot + ut + P] < H[De + ut]) continue e;
+                        var Wt = z(Vt, me);
+                        if (Wt !== void 0) return Wt;
+                      }
+                    }
+                  }
+                } else {
+                  for (var ie = Pe - c, lt = Be - 1; lt >= 0; --lt) if (h[lt] === ie) {
+                    for (var ut = lt + 1; ut < Be; ++ut) h[ut - 1] = h[ut];
+                    break;
+                  }
+                  --Be;
+                }
+              }
+            }
+          }, 868: function(i, a, o) {
+            i.exports = o(1387);
+          }, 869: function(i, a, o) {
+            var s = o(2651), l = o(5716);
+            i.exports = u;
+            function u(c, f) {
+              var h = l(c), d = l(f);
+              if (h === 0) return [s(0), s(1)];
+              if (d === 0) return [s(0), s(0)];
+              d < 0 && (c = c.neg(), f = f.neg());
+              var v = c.gcd(f);
+              return v.cmpn(1) ? [c.div(v), f.div(v)] : [c, f];
+            }
+          }, 870: function(i, a, o) {
+            var s = o(1433);
+            function l(c) {
+              this.gl = c, this._elements = null, this._attributes = null, this._elementsType = c.UNSIGNED_SHORT;
+            }
+            l.prototype.bind = function() {
+              s(this.gl, this._elements, this._attributes);
+            }, l.prototype.update = function(c, f, h) {
+              this._elements = f, this._attributes = c, this._elementsType = h || this.gl.UNSIGNED_SHORT;
+            }, l.prototype.dispose = function() {
+            }, l.prototype.unbind = function() {
+            }, l.prototype.draw = function(c, f, h) {
+              h = h || 0;
+              var d = this.gl;
+              this._elements ? d.drawElements(c, f, this._elementsType, h) : d.drawArrays(c, h, f);
+            };
+            function u(c) {
+              return new l(c);
+            }
+            i.exports = u;
+          }, 946: function(i, a, o) {
+            var s = o(1369), l = o(4025);
+            i.exports = u;
+            function u(c) {
+              var f = c[0], h = c[1];
+              if (f.cmpn(0) === 0) return 0;
+              var d = f.abs().divmod(h.abs()), v = d.div, _ = s(v), b = d.mod, p = f.negative !== h.negative ? -1 : 1;
+              if (b.cmpn(0) === 0) return p * _;
+              if (_) {
+                var k = l(_) + 4, E = s(b.ushln(k).divRound(h));
+                return p * (_ + E * Math.pow(2, -k));
+              } else {
+                var T = h.bitLength() - b.bitLength() + 53, E = s(b.ushln(T).divRound(h));
+                return T < 1023 ? p * E * Math.pow(2, -T) : (E *= Math.pow(2, -1023), p * E * Math.pow(2, 1023 - T));
+              }
+            }
+          }, 990: function(i, a, o) {
+            var s = o(9405), l = o(3236), u = l([`precision highp float;
+#define GLSLIFY 1
+
+attribute vec4 uv;
+attribute vec3 f;
+attribute vec3 normal;
+
+uniform vec3 objectOffset;
+uniform mat4 model, view, projection, inverseModel;
+uniform vec3 lightPosition, eyePosition;
+uniform sampler2D colormap;
+
+varying float value, kill;
+varying vec3 worldCoordinate;
+varying vec2 planeCoordinate;
+varying vec3 lightDirection, eyeDirection, surfaceNormal;
+varying vec4 vColor;
+
+void main() {
+  vec3 localCoordinate = vec3(uv.zw, f.x);
+  worldCoordinate = objectOffset + localCoordinate;
+  mat4 objectOffsetTranslation = mat4(1.0) + mat4(vec4(0), vec4(0), vec4(0), vec4(objectOffset, 0));
+  vec4 worldPosition = (model * objectOffsetTranslation) * vec4(localCoordinate, 1.0);
+  vec4 clipPosition = projection * (view * worldPosition);
+  gl_Position = clipPosition;
+  kill = f.y;
+  value = f.z;
+  planeCoordinate = uv.xy;
+
+  vColor = texture2D(colormap, vec2(value, value));
+
+  //Lighting geometry parameters
+  vec4 cameraCoordinate = view * worldPosition;
+  cameraCoordinate.xyz /= cameraCoordinate.w;
+  lightDirection = lightPosition - cameraCoordinate.xyz;
+  eyeDirection   = eyePosition - cameraCoordinate.xyz;
+  surfaceNormal  = normalize((vec4(normal,0) * inverseModel).xyz);
+}
+`]), c = l([`precision highp float;
+#define GLSLIFY 1
+
+float beckmannDistribution(float x, float roughness) {
+  float NdotH = max(x, 0.0001);
+  float cos2Alpha = NdotH * NdotH;
+  float tan2Alpha = (cos2Alpha - 1.0) / cos2Alpha;
+  float roughness2 = roughness * roughness;
+  float denom = 3.141592653589793 * roughness2 * cos2Alpha * cos2Alpha;
+  return exp(tan2Alpha / roughness2) / denom;
+}
+
+float beckmannSpecular(
+  vec3 lightDirection,
+  vec3 viewDirection,
+  vec3 surfaceNormal,
+  float roughness) {
+  return beckmannDistribution(dot(surfaceNormal, normalize(lightDirection + viewDirection)), roughness);
+}
+
+bool outOfRange(float a, float b, float p) {
+  return ((p > max(a, b)) ||
+          (p < min(a, b)));
+}
+
+bool outOfRange(vec2 a, vec2 b, vec2 p) {
+  return (outOfRange(a.x, b.x, p.x) ||
+          outOfRange(a.y, b.y, p.y));
+}
+
+bool outOfRange(vec3 a, vec3 b, vec3 p) {
+  return (outOfRange(a.x, b.x, p.x) ||
+          outOfRange(a.y, b.y, p.y) ||
+          outOfRange(a.z, b.z, p.z));
+}
+
+bool outOfRange(vec4 a, vec4 b, vec4 p) {
+  return outOfRange(a.xyz, b.xyz, p.xyz);
+}
+
+uniform vec3 lowerBound, upperBound;
+uniform float contourTint;
+uniform vec4 contourColor;
+uniform sampler2D colormap;
+uniform vec3 clipBounds[2];
+uniform float roughness, fresnel, kambient, kdiffuse, kspecular, opacity;
+uniform float vertexColor;
+
+varying float value, kill;
+varying vec3 worldCoordinate;
+varying vec3 lightDirection, eyeDirection, surfaceNormal;
+varying vec4 vColor;
+
+void main() {
+  if (
+    kill > 0.0 ||
+    vColor.a == 0.0 ||
+    outOfRange(clipBounds[0], clipBounds[1], worldCoordinate)
+  ) discard;
+
+  vec3 N = normalize(surfaceNormal);
+  vec3 V = normalize(eyeDirection);
+  vec3 L = normalize(lightDirection);
+
+  if(gl_FrontFacing) {
+    N = -N;
+  }
+
+  float specular = max(beckmannSpecular(L, V, N, roughness), 0.);
+  float diffuse  = min(kambient + kdiffuse * max(dot(N, L), 0.0), 1.0);
+
+  //decide how to interpolate color — in vertex or in fragment
+  vec4 surfaceColor =
+    step(vertexColor, .5) * texture2D(colormap, vec2(value, value)) +
+    step(.5, vertexColor) * vColor;
+
+  vec4 litColor = surfaceColor.a * vec4(diffuse * surfaceColor.rgb + kspecular * vec3(1,1,1) * specular,  1.0);
+
+  gl_FragColor = mix(litColor, contourColor, contourTint) * opacity;
+}
+`]), f = l([`precision highp float;
+#define GLSLIFY 1
+
+attribute vec4 uv;
+attribute float f;
+
+uniform vec3 objectOffset;
+uniform mat3 permutation;
+uniform mat4 model, view, projection;
+uniform float height, zOffset;
+uniform sampler2D colormap;
+
+varying float value, kill;
+varying vec3 worldCoordinate;
+varying vec2 planeCoordinate;
+varying vec3 lightDirection, eyeDirection, surfaceNormal;
+varying vec4 vColor;
+
+void main() {
+  vec3 dataCoordinate = permutation * vec3(uv.xy, height);
+  worldCoordinate = objectOffset + dataCoordinate;
+  mat4 objectOffsetTranslation = mat4(1.0) + mat4(vec4(0), vec4(0), vec4(0), vec4(objectOffset, 0));
+  vec4 worldPosition = (model * objectOffsetTranslation) * vec4(dataCoordinate, 1.0);
+
+  vec4 clipPosition = projection * (view * worldPosition);
+  clipPosition.z += zOffset;
+
+  gl_Position = clipPosition;
+  value = f + objectOffset.z;
+  kill = -1.0;
+  planeCoordinate = uv.zw;
+
+  vColor = texture2D(colormap, vec2(value, value));
+
+  //Don't do lighting for contours
+  surfaceNormal   = vec3(1,0,0);
+  eyeDirection    = vec3(0,1,0);
+  lightDirection  = vec3(0,0,1);
+}
+`]), h = l([`precision highp float;
+#define GLSLIFY 1
+
+bool outOfRange(float a, float b, float p) {
+  return ((p > max(a, b)) ||
+          (p < min(a, b)));
+}
+
+bool outOfRange(vec2 a, vec2 b, vec2 p) {
+  return (outOfRange(a.x, b.x, p.x) ||
+          outOfRange(a.y, b.y, p.y));
+}
+
+bool outOfRange(vec3 a, vec3 b, vec3 p) {
+  return (outOfRange(a.x, b.x, p.x) ||
+          outOfRange(a.y, b.y, p.y) ||
+          outOfRange(a.z, b.z, p.z));
+}
+
+bool outOfRange(vec4 a, vec4 b, vec4 p) {
+  return outOfRange(a.xyz, b.xyz, p.xyz);
+}
+
+uniform vec2 shape;
+uniform vec3 clipBounds[2];
+uniform float pickId;
+
+varying float value, kill;
+varying vec3 worldCoordinate;
+varying vec2 planeCoordinate;
+varying vec3 surfaceNormal;
+
+vec2 splitFloat(float v) {
+  float vh = 255.0 * v;
+  float upper = floor(vh);
+  float lower = fract(vh);
+  return vec2(upper / 255.0, floor(lower * 16.0) / 16.0);
+}
+
+void main() {
+  if ((kill > 0.0) ||
+      (outOfRange(clipBounds[0], clipBounds[1], worldCoordinate))) discard;
+
+  vec2 ux = splitFloat(planeCoordinate.x / shape.x);
+  vec2 uy = splitFloat(planeCoordinate.y / shape.y);
+  gl_FragColor = vec4(pickId, ux.x, uy.x, ux.y + (uy.y/16.0));
+}
+`]);
+            a.createShader = function(d) {
+              var v = s(d, u, c, null, [{ name: "uv", type: "vec4" }, { name: "f", type: "vec3" }, { name: "normal", type: "vec3" }]);
+              return v.attributes.uv.location = 0, v.attributes.f.location = 1, v.attributes.normal.location = 2, v;
+            }, a.createPickShader = function(d) {
+              var v = s(d, u, h, null, [{ name: "uv", type: "vec4" }, { name: "f", type: "vec3" }, { name: "normal", type: "vec3" }]);
+              return v.attributes.uv.location = 0, v.attributes.f.location = 1, v.attributes.normal.location = 2, v;
+            }, a.createContourShader = function(d) {
+              var v = s(d, f, c, null, [{ name: "uv", type: "vec4" }, { name: "f", type: "float" }]);
+              return v.attributes.uv.location = 0, v.attributes.f.location = 1, v;
+            }, a.createPickContourShader = function(d) {
+              var v = s(d, f, h, null, [{ name: "uv", type: "vec4" }, { name: "f", type: "float" }]);
+              return v.attributes.uv.location = 0, v.attributes.f.location = 1, v;
+            };
+          }, 1085: function(i, a, o) {
+            var s = o(1371);
+            i.exports = l;
+            function l(u, c, f) {
+              c = typeof c == "number" ? c : 1, f = f || ": ";
+              var h = u.split(/\r?\n/), d = String(h.length + c - 1).length;
+              return h.map(function(v, _) {
+                var b = _ + c, p = String(b).length, k = s(b, d - p);
+                return k + f + v;
+              }).join(`
+`);
+            }
+          }, 1091: function(i) {
+            i.exports = a;
+            function a() {
+              var o = new Float32Array(3);
+              return o[0] = 0, o[1] = 0, o[2] = 0, o;
+            }
+          }, 1125: function(i, a, o) {
+            i.exports = u;
+            var s = o(3250)[3];
+            function l(c, f, h, d) {
+              for (var v = 0; v < 2; ++v) {
+                var _ = c[v], b = f[v], p = Math.min(_, b), k = Math.max(_, b), E = h[v], T = d[v], L = Math.min(E, T), x = Math.max(E, T);
+                if (x < p || k < L) return false;
+              }
+              return true;
+            }
+            function u(c, f, h, d) {
+              var v = s(c, h, d), _ = s(f, h, d);
+              if (v > 0 && _ > 0 || v < 0 && _ < 0) return false;
+              var b = s(h, c, f), p = s(d, c, f);
+              return b > 0 && p > 0 || b < 0 && p < 0 ? false : v === 0 && _ === 0 && b === 0 && p === 0 ? l(c, f, h, d) : true;
+            }
+          }, 1278: function(i, a, o) {
+            var s = o(2361), l = Math.pow(2, -1074), u = -1 >>> 0;
+            i.exports = c;
+            function c(f, h) {
+              if (isNaN(f) || isNaN(h)) return NaN;
+              if (f === h) return f;
+              if (f === 0) return h < 0 ? -l : l;
+              var d = s.hi(f), v = s.lo(f);
+              return h > f == f > 0 ? v === u ? (d += 1, v = 0) : v += 1 : v === 0 ? (v = u, d -= 1) : v -= 1, s.pack(v, d);
+            }
+          }, 1283: function(i, a, o) {
+            var s = o(9405), l = o(3236), u = l([`precision highp float;
+#define GLSLIFY 1
+
+bool outOfRange(float a, float b, float p) {
+  return ((p > max(a, b)) ||
+          (p < min(a, b)));
+}
+
+bool outOfRange(vec2 a, vec2 b, vec2 p) {
+  return (outOfRange(a.x, b.x, p.x) ||
+          outOfRange(a.y, b.y, p.y));
+}
+
+bool outOfRange(vec3 a, vec3 b, vec3 p) {
+  return (outOfRange(a.x, b.x, p.x) ||
+          outOfRange(a.y, b.y, p.y) ||
+          outOfRange(a.z, b.z, p.z));
+}
+
+bool outOfRange(vec4 a, vec4 b, vec4 p) {
+  return outOfRange(a.xyz, b.xyz, p.xyz);
+}
+
+attribute vec3 position;
+attribute vec4 color;
+attribute vec2 glyph;
+attribute vec4 id;
+
+uniform vec4 highlightId;
+uniform float highlightScale;
+uniform mat4 model, view, projection;
+uniform vec3 clipBounds[2];
+
+varying vec4 interpColor;
+varying vec4 pickId;
+varying vec3 dataCoordinate;
+
+void main() {
+  if (outOfRange(clipBounds[0], clipBounds[1], position)) {
+
+    gl_Position = vec4(0,0,0,0);
+  } else {
+    float scale = 1.0;
+    if(distance(highlightId, id) < 0.0001) {
+      scale = highlightScale;
+    }
+
+    vec4 worldPosition = model * vec4(position, 1);
+    vec4 viewPosition = view * worldPosition;
+    viewPosition = viewPosition / viewPosition.w;
+    vec4 clipPosition = projection * (viewPosition + scale * vec4(glyph.x, -glyph.y, 0, 0));
+
+    gl_Position = clipPosition;
+    interpColor = color;
+    pickId = id;
+    dataCoordinate = position;
+  }
+}`]), c = l([`precision highp float;
+#define GLSLIFY 1
+
+bool outOfRange(float a, float b, float p) {
+  return ((p > max(a, b)) ||
+          (p < min(a, b)));
+}
+
+bool outOfRange(vec2 a, vec2 b, vec2 p) {
+  return (outOfRange(a.x, b.x, p.x) ||
+          outOfRange(a.y, b.y, p.y));
+}
+
+bool outOfRange(vec3 a, vec3 b, vec3 p) {
+  return (outOfRange(a.x, b.x, p.x) ||
+          outOfRange(a.y, b.y, p.y) ||
+          outOfRange(a.z, b.z, p.z));
+}
+
+bool outOfRange(vec4 a, vec4 b, vec4 p) {
+  return outOfRange(a.xyz, b.xyz, p.xyz);
+}
+
+attribute vec3 position;
+attribute vec4 color;
+attribute vec2 glyph;
+attribute vec4 id;
+
+uniform mat4 model, view, projection;
+uniform vec2 screenSize;
+uniform vec3 clipBounds[2];
+uniform float highlightScale, pixelRatio;
+uniform vec4 highlightId;
+
+varying vec4 interpColor;
+varying vec4 pickId;
+varying vec3 dataCoordinate;
+
+void main() {
+  if (outOfRange(clipBounds[0], clipBounds[1], position)) {
+
+    gl_Position = vec4(0,0,0,0);
+  } else {
+    float scale = pixelRatio;
+    if(distance(highlightId.bgr, id.bgr) < 0.001) {
+      scale *= highlightScale;
+    }
+
+    vec4 worldPosition = model * vec4(position, 1.0);
+    vec4 viewPosition = view * worldPosition;
+    vec4 clipPosition = projection * viewPosition;
+    clipPosition /= clipPosition.w;
+
+    gl_Position = clipPosition + vec4(screenSize * scale * vec2(glyph.x, -glyph.y), 0.0, 0.0);
+    interpColor = color;
+    pickId = id;
+    dataCoordinate = position;
+  }
+}`]), f = l([`precision highp float;
+#define GLSLIFY 1
+
+bool outOfRange(float a, float b, float p) {
+  return ((p > max(a, b)) ||
+          (p < min(a, b)));
+}
+
+bool outOfRange(vec2 a, vec2 b, vec2 p) {
+  return (outOfRange(a.x, b.x, p.x) ||
+          outOfRange(a.y, b.y, p.y));
+}
+
+bool outOfRange(vec3 a, vec3 b, vec3 p) {
+  return (outOfRange(a.x, b.x, p.x) ||
+          outOfRange(a.y, b.y, p.y) ||
+          outOfRange(a.z, b.z, p.z));
+}
+
+bool outOfRange(vec4 a, vec4 b, vec4 p) {
+  return outOfRange(a.xyz, b.xyz, p.xyz);
+}
+
+attribute vec3 position;
+attribute vec4 color;
+attribute vec2 glyph;
+attribute vec4 id;
+
+uniform float highlightScale;
+uniform vec4 highlightId;
+uniform vec3 axes[2];
+uniform mat4 model, view, projection;
+uniform vec2 screenSize;
+uniform vec3 clipBounds[2];
+uniform float scale, pixelRatio;
+
+varying vec4 interpColor;
+varying vec4 pickId;
+varying vec3 dataCoordinate;
+
+void main() {
+  if (outOfRange(clipBounds[0], clipBounds[1], position)) {
+
+    gl_Position = vec4(0,0,0,0);
+  } else {
+    float lscale = pixelRatio * scale;
+    if(distance(highlightId, id) < 0.0001) {
+      lscale *= highlightScale;
+    }
+
+    vec4 clipCenter   = projection * (view * (model * vec4(position, 1)));
+    vec3 dataPosition = position + 0.5*lscale*(axes[0] * glyph.x + axes[1] * glyph.y) * clipCenter.w * screenSize.y;
+    vec4 clipPosition = projection * (view * (model * vec4(dataPosition, 1)));
+
+    gl_Position = clipPosition;
+    interpColor = color;
+    pickId = id;
+    dataCoordinate = dataPosition;
+  }
+}
+`]), h = l([`precision highp float;
+#define GLSLIFY 1
+
+bool outOfRange(float a, float b, float p) {
+  return ((p > max(a, b)) ||
+          (p < min(a, b)));
+}
+
+bool outOfRange(vec2 a, vec2 b, vec2 p) {
+  return (outOfRange(a.x, b.x, p.x) ||
+          outOfRange(a.y, b.y, p.y));
+}
+
+bool outOfRange(vec3 a, vec3 b, vec3 p) {
+  return (outOfRange(a.x, b.x, p.x) ||
+          outOfRange(a.y, b.y, p.y) ||
+          outOfRange(a.z, b.z, p.z));
+}
+
+bool outOfRange(vec4 a, vec4 b, vec4 p) {
+  return outOfRange(a.xyz, b.xyz, p.xyz);
+}
+
+uniform vec3 fragClipBounds[2];
+uniform float opacity;
+
+varying vec4 interpColor;
+varying vec3 dataCoordinate;
+
+void main() {
+  if (
+    outOfRange(fragClipBounds[0], fragClipBounds[1], dataCoordinate) ||
+    interpColor.a * opacity == 0.
+  ) discard;
+  gl_FragColor = interpColor * opacity;
+}
+`]), d = l([`precision highp float;
+#define GLSLIFY 1
+
+bool outOfRange(float a, float b, float p) {
+  return ((p > max(a, b)) ||
+          (p < min(a, b)));
+}
+
+bool outOfRange(vec2 a, vec2 b, vec2 p) {
+  return (outOfRange(a.x, b.x, p.x) ||
+          outOfRange(a.y, b.y, p.y));
+}
+
+bool outOfRange(vec3 a, vec3 b, vec3 p) {
+  return (outOfRange(a.x, b.x, p.x) ||
+          outOfRange(a.y, b.y, p.y) ||
+          outOfRange(a.z, b.z, p.z));
+}
+
+bool outOfRange(vec4 a, vec4 b, vec4 p) {
+  return outOfRange(a.xyz, b.xyz, p.xyz);
+}
+
+uniform vec3 fragClipBounds[2];
+uniform float pickGroup;
+
+varying vec4 pickId;
+varying vec3 dataCoordinate;
+
+void main() {
+  if (outOfRange(fragClipBounds[0], fragClipBounds[1], dataCoordinate)) discard;
+
+  gl_FragColor = vec4(pickGroup, pickId.bgr);
+}`]), v = [{ name: "position", type: "vec3" }, { name: "color", type: "vec4" }, { name: "glyph", type: "vec2" }, { name: "id", type: "vec4" }], _ = { vertex: u, fragment: h, attributes: v }, b = { vertex: c, fragment: h, attributes: v }, p = { vertex: f, fragment: h, attributes: v }, k = { vertex: u, fragment: d, attributes: v }, E = { vertex: c, fragment: d, attributes: v }, T = { vertex: f, fragment: d, attributes: v };
+            function L(x, C) {
+              var M = s(x, C), g = M.attributes;
+              return g.position.location = 0, g.color.location = 1, g.glyph.location = 2, g.id.location = 3, M;
+            }
+            a.createPerspective = function(x) {
+              return L(x, _);
+            }, a.createOrtho = function(x) {
+              return L(x, b);
+            }, a.createProject = function(x) {
+              return L(x, p);
+            }, a.createPickPerspective = function(x) {
+              return L(x, k);
+            }, a.createPickOrtho = function(x) {
+              return L(x, E);
+            }, a.createPickProject = function(x) {
+              return L(x, T);
+            };
+          }, 1303: function(i, a, o) {
+            i.exports = u;
+            var s = o(3250);
+            function l(c, f) {
+              var h, d;
+              if (f[0][0] < f[1][0]) h = f[0], d = f[1];
+              else if (f[0][0] > f[1][0]) h = f[1], d = f[0];
+              else {
+                var v = Math.min(c[0][1], c[1][1]), _ = Math.max(c[0][1], c[1][1]), b = Math.min(f[0][1], f[1][1]), p = Math.max(f[0][1], f[1][1]);
+                return _ < b ? _ - b : v > p ? v - p : _ - p;
+              }
+              var k, E;
+              c[0][1] < c[1][1] ? (k = c[0], E = c[1]) : (k = c[1], E = c[0]);
+              var T = s(d, h, k);
+              return T || (T = s(d, h, E), T) ? T : E - d;
+            }
+            function u(c, f) {
+              var h, d;
+              if (f[0][0] < f[1][0]) h = f[0], d = f[1];
+              else if (f[0][0] > f[1][0]) h = f[1], d = f[0];
+              else return l(f, c);
+              var v, _;
+              if (c[0][0] < c[1][0]) v = c[0], _ = c[1];
+              else if (c[0][0] > c[1][0]) v = c[1], _ = c[0];
+              else return -l(c, f);
+              var b = s(h, d, _), p = s(h, d, v);
+              if (b < 0) {
+                if (p <= 0) return b;
+              } else if (b > 0) {
+                if (p >= 0) return b;
+              } else if (p) return p;
+              if (b = s(_, v, d), p = s(_, v, h), b < 0) {
+                if (p <= 0) return b;
+              } else if (b > 0) {
+                if (p >= 0) return b;
+              } else if (p) return p;
+              return d[0] - _[0];
+            }
+          }, 1318: function(i) {
+            i.exports = a;
+            function a(o, s) {
+              return o[0].mul(s[1]).cmp(s[0].mul(o[1]));
+            }
+          }, 1338: function(i) {
+            function a(l, u, c) {
+              var f = l[c] | 0;
+              if (f <= 0) return [];
+              var h = new Array(f), d;
+              if (c === l.length - 1) for (d = 0; d < f; ++d) h[d] = u;
+              else for (d = 0; d < f; ++d) h[d] = a(l, u, c + 1);
+              return h;
+            }
+            function o(l, u) {
+              var c, f;
+              for (c = new Array(l), f = 0; f < l; ++f) c[f] = u;
+              return c;
+            }
+            function s(l, u) {
+              switch (typeof u == "undefined" && (u = 0), typeof l) {
+                case "number":
+                  if (l > 0) return o(l | 0, u);
+                  break;
+                case "object":
+                  if (typeof l.length == "number") return a(l, u, 0);
+                  break;
+              }
+              return [];
+            }
+            i.exports = s;
+          }, 1369: function(i, a, o) {
+            var s = o(5716);
+            i.exports = l;
+            function l(u) {
+              var c = u.length, f = u.words, h = 0;
+              if (c === 1) h = f[0];
+              else if (c === 2) h = f[0] + f[1] * 67108864;
+              else for (var d = 0; d < c; d++) {
+                var v = f[d];
+                h += v * Math.pow(67108864, d);
+              }
+              return s(u) * h;
+            }
+          }, 1371: function(i, a, o) {
+            var s = o(3233);
+            i.exports = function(u, c, f) {
+              return f = typeof f != "undefined" ? f + "" : " ", s(f, c) + u;
+            };
+          }, 1373: function(i) {
+            i.exports = a;
+            function a(o, s, l) {
+              return o[0] = s[0] / l[0], o[1] = s[1] / l[1], o[2] = s[2] / l[2], o[3] = s[3] / l[3], o;
+            }
+          }, 1387: function(i) {
+            i.exports = a;
+            function a(o) {
+              var s = o[0], l = o[1], u = o[2];
+              return Math.sqrt(s * s + l * l + u * u);
+            }
+          }, 1433: function(i) {
+            function a(o, s, l) {
+              s ? s.bind() : o.bindBuffer(o.ELEMENT_ARRAY_BUFFER, null);
+              var u = o.getParameter(o.MAX_VERTEX_ATTRIBS) | 0;
+              if (l) {
+                if (l.length > u) throw new Error("gl-vao: Too many vertex attributes");
+                for (var c = 0; c < l.length; ++c) {
+                  var f = l[c];
+                  if (f.buffer) {
+                    var h = f.buffer, d = f.size || 4, v = f.type || o.FLOAT, _ = !!f.normalized, b = f.stride || 0, p = f.offset || 0;
+                    h.bind(), o.enableVertexAttribArray(c), o.vertexAttribPointer(c, d, v, _, b, p);
+                  } else {
+                    if (typeof f == "number") o.vertexAttrib1f(c, f);
+                    else if (f.length === 1) o.vertexAttrib1f(c, f[0]);
+                    else if (f.length === 2) o.vertexAttrib2f(c, f[0], f[1]);
+                    else if (f.length === 3) o.vertexAttrib3f(c, f[0], f[1], f[2]);
+                    else if (f.length === 4) o.vertexAttrib4f(c, f[0], f[1], f[2], f[3]);
+                    else throw new Error("gl-vao: Invalid vertex attribute");
+                    o.disableVertexAttribArray(c);
+                  }
+                }
+                for (; c < u; ++c) o.disableVertexAttribArray(c);
+              } else {
+                o.bindBuffer(o.ARRAY_BUFFER, null);
+                for (var c = 0; c < u; ++c) o.disableVertexAttribArray(c);
+              }
+            }
+            i.exports = a;
+          }, 1463: function(i) {
+            i.exports = a;
+            function a(o, s, l, u) {
+              return o[0] = s, o[1] = l, o[2] = u, o;
+            }
+          }, 1493: function(i, a, o) {
+            var s = o(3236), l = o(9405), u = s([`precision mediump float;
+#define GLSLIFY 1
+
+attribute vec3 position, color;
+attribute float weight;
+
+uniform mat4 model, view, projection;
+uniform vec3 coordinates[3];
+uniform vec4 colors[3];
+uniform vec2 screenShape;
+uniform float lineWidth;
+
+varying vec4 fragColor;
+
+void main() {
+  vec3 vertexPosition = mix(coordinates[0],
+    mix(coordinates[2], coordinates[1], 0.5 * (position + 1.0)), abs(position));
+
+  vec4 clipPos = projection * (view * (model * vec4(vertexPosition, 1.0)));
+  vec2 clipOffset = (projection * (view * (model * vec4(color, 0.0)))).xy;
+  vec2 delta = weight * clipOffset * screenShape;
+  vec2 lineOffset = normalize(vec2(delta.y, -delta.x)) / screenShape;
+
+  gl_Position   = vec4(clipPos.xy + clipPos.w * 0.5 * lineWidth * lineOffset, clipPos.z, clipPos.w);
+  fragColor     = color.x * colors[0] + color.y * colors[1] + color.z * colors[2];
+}
+`]), c = s([`precision mediump float;
+#define GLSLIFY 1
+
+varying vec4 fragColor;
+
+void main() {
+  gl_FragColor = fragColor;
+}`]);
+            i.exports = function(f) {
+              return l(f, u, c, null, [{ name: "position", type: "vec3" }, { name: "color", type: "vec3" }, { name: "weight", type: "float" }]);
+            };
+          }, 1498: function(i) {
+            i.exports = a;
+            function a(o, s) {
+              return o[0] = -s[0], o[1] = -s[1], o[2] = -s[2], o[3] = -s[3], o;
+            }
+          }, 1533: function(i, a, o) {
+            o(6859);
+            i.exports = l;
+            function l(u) {
+              return u && typeof u == "object" && !!u.words;
+            }
+          }, 1538: function(i) {
+            (function() {
+              if (typeof ses != "undefined" && ses.ok && !ses.ok()) return;
+              function o(A) {
+                A.permitHostObjects___ && A.permitHostObjects___(o);
+              }
+              typeof ses != "undefined" && (ses.weakMapPermitHostObjects = o);
+              var s = false;
+              if (typeof WeakMap == "function") {
+                var l = WeakMap;
+                if (!(typeof navigator != "undefined" && /Firefox/.test(navigator.userAgent))) {
+                  var u = new l(), c = Object.freeze({});
+                  if (u.set(c, 1), u.get(c) !== 1) s = true;
+                  else {
+                    i.exports = WeakMap;
+                    return;
+                  }
+                }
+              }
+              var h = Object.getOwnPropertyNames, d = Object.defineProperty, v = Object.isExtensible, _ = "weakmap:", b = _ + "ident:" + Math.random() + "___";
+              if (typeof crypto != "undefined" && typeof crypto.getRandomValues == "function" && typeof ArrayBuffer == "function" && typeof Uint8Array == "function") {
+                var p = new ArrayBuffer(25), k = new Uint8Array(p);
+                crypto.getRandomValues(k), b = _ + "rand:" + Array.prototype.map.call(k, function(A) {
+                  return (A % 36).toString(36);
+                }).join("") + "___";
+              }
+              function E(A) {
+                return !(A.substr(0, _.length) == _ && A.substr(A.length - 3) === "___");
+              }
+              if (d(Object, "getOwnPropertyNames", { value: function(z) {
+                return h(z).filter(E);
+              } }), "getPropertyNames" in Object) {
+                var T = Object.getPropertyNames;
+                d(Object, "getPropertyNames", { value: function(z) {
+                  return T(z).filter(E);
+                } });
+              }
+              function L(A) {
+                if (A !== Object(A)) throw new TypeError("Not an object: " + A);
+                var z = A[b];
+                if (z && z.key === A) return z;
+                if (v(A)) {
+                  z = { key: A };
+                  try {
+                    return d(A, b, { value: z, writable: false, enumerable: false, configurable: false }), z;
+                  } catch (O) {
+                    return;
+                  }
+                }
+              }
+              (function() {
+                var A = Object.freeze;
+                d(Object, "freeze", { value: function(G) {
+                  return L(G), A(G);
+                } });
+                var z = Object.seal;
+                d(Object, "seal", { value: function(G) {
+                  return L(G), z(G);
+                } });
+                var O = Object.preventExtensions;
+                d(Object, "preventExtensions", { value: function(G) {
+                  return L(G), O(G);
+                } });
+              })();
+              function x(A) {
+                return A.prototype = null, Object.freeze(A);
+              }
+              var C = false;
+              function M() {
+                !C && typeof console != "undefined" && (C = true, console.warn("WeakMap should be invoked as new WeakMap(), not WeakMap(). This will be an error in the future."));
+              }
+              var g = 0, P = function() {
+                this instanceof P || M();
+                var A = [], z = [], O = g++;
+                function U(N, H) {
+                  var re, oe = L(N);
+                  return oe ? O in oe ? oe[O] : H : (re = A.indexOf(N), re >= 0 ? z[re] : H);
+                }
+                function G(N) {
+                  var H = L(N);
+                  return H ? O in H : A.indexOf(N) >= 0;
+                }
+                function Z(N, H) {
+                  var re, oe = L(N);
+                  return oe ? oe[O] = H : (re = A.indexOf(N), re >= 0 ? z[re] = H : (re = A.length, z[re] = H, A[re] = N)), this;
+                }
+                function j(N) {
+                  var H = L(N), re, oe;
+                  return H ? O in H && delete H[O] : (re = A.indexOf(N), re < 0 ? false : (oe = A.length - 1, A[re] = void 0, z[re] = z[oe], A[re] = A[oe], A.length = oe, z.length = oe, true));
+                }
+                return Object.create(P.prototype, { get___: { value: x(U) }, has___: { value: x(G) }, set___: { value: x(Z) }, delete___: { value: x(j) } });
+              };
+              P.prototype = Object.create(Object.prototype, { get: { value: function(z, O) {
+                return this.get___(z, O);
+              }, writable: true, configurable: true }, has: { value: function(z) {
+                return this.has___(z);
+              }, writable: true, configurable: true }, set: { value: function(z, O) {
+                return this.set___(z, O);
+              }, writable: true, configurable: true }, delete: { value: function(z) {
+                return this.delete___(z);
+              }, writable: true, configurable: true } }), typeof l == "function" ? function() {
+                s && typeof Proxy != "undefined" && (Proxy = void 0);
+                function A() {
+                  this instanceof P || M();
+                  var z = new l(), O = void 0, U = false;
+                  function G(H, re) {
+                    return O ? z.has(H) ? z.get(H) : O.get___(H, re) : z.get(H, re);
+                  }
+                  function Z(H) {
+                    return z.has(H) || (O ? O.has___(H) : false);
+                  }
+                  var j;
+                  s ? j = function(H, re) {
+                    return z.set(H, re), z.has(H) || (O || (O = new P()), O.set(H, re)), this;
+                  } : j = function(H, re) {
+                    if (U) try {
+                      z.set(H, re);
+                    } catch (oe) {
+                      O || (O = new P()), O.set___(H, re);
+                    }
+                    else z.set(H, re);
+                    return this;
+                  };
+                  function N(H) {
+                    var re = !!z.delete(H);
+                    return O && O.delete___(H) || re;
+                  }
+                  return Object.create(P.prototype, { get___: { value: x(G) }, has___: { value: x(Z) }, set___: { value: x(j) }, delete___: { value: x(N) }, permitHostObjects___: { value: x(function(H) {
+                    if (H === o) U = true;
+                    else throw new Error("bogus call to permitHostObjects___");
+                  }) } });
+                }
+                A.prototype = P.prototype, i.exports = A, Object.defineProperty(WeakMap.prototype, "constructor", { value: WeakMap, enumerable: false, configurable: true, writable: true });
+              }() : (typeof Proxy != "undefined" && (Proxy = void 0), i.exports = P);
+            })();
+          }, 1570: function(i) {
+            i.exports = o;
+            var a = [function() {
+              function u(c, f, h, d) {
+                for (var v = c.length, _ = [], b = 0; b < v; ++b) var p = c[b], k = p.length;
+                return _;
+              }
+              return u;
+            }, function() {
+              function l(c, f, h, d) {
+                for (var v = Math.min(h, d) | 0, _ = Math.max(h, d) | 0, b = c[2 * v], p = c[2 * v + 1]; b < p; ) {
+                  var k = b + p >> 1, E = f[2 * k + 1];
+                  if (E === _) return k;
+                  _ < E ? p = k : b = k + 1;
+                }
+                return b;
+              }
+              function u(c, f, h, d) {
+                for (var v = c.length, _ = [], b = 0; b < v; ++b) {
+                  var p = c[b], k = p.length;
+                  if (k === 2) {
+                    var E = (d[p[0]] << 0) + (d[p[1]] << 1);
+                    if (E === 0 || E === 3) continue;
+                    switch (E) {
+                      case 0:
+                        break;
+                      case 1:
+                        _.push([l(h, f, p[0], p[1])]);
+                        break;
+                      case 2:
+                        _.push([l(h, f, p[1], p[0])]);
+                        break;
+                    }
+                  }
+                }
+                return _;
+              }
+              return u;
+            }, function() {
+              function l(c, f, h, d) {
+                for (var v = Math.min(h, d) | 0, _ = Math.max(h, d) | 0, b = c[2 * v], p = c[2 * v + 1]; b < p; ) {
+                  var k = b + p >> 1, E = f[2 * k + 1];
+                  if (E === _) return k;
+                  _ < E ? p = k : b = k + 1;
+                }
+                return b;
+              }
+              function u(c, f, h, d) {
+                for (var v = c.length, _ = [], b = 0; b < v; ++b) {
+                  var p = c[b], k = p.length;
+                  if (k === 3) {
+                    var E = (d[p[0]] << 0) + (d[p[1]] << 1) + (d[p[2]] << 2);
+                    if (E === 0 || E === 7) continue;
+                    switch (E) {
+                      case 0:
+                        break;
+                      case 1:
+                        _.push([l(h, f, p[0], p[2]), l(h, f, p[0], p[1])]);
+                        break;
+                      case 2:
+                        _.push([l(h, f, p[1], p[0]), l(h, f, p[1], p[2])]);
+                        break;
+                      case 3:
+                        _.push([l(h, f, p[0], p[2]), l(h, f, p[1], p[2])]);
+                        break;
+                      case 4:
+                        _.push([l(h, f, p[2], p[1]), l(h, f, p[2], p[0])]);
+                        break;
+                      case 5:
+                        _.push([l(h, f, p[2], p[1]), l(h, f, p[0], p[1])]);
+                        break;
+                      case 6:
+                        _.push([l(h, f, p[1], p[0]), l(h, f, p[2], p[0])]);
+                        break;
+                    }
+                  } else if (k === 2) {
+                    var E = (d[p[0]] << 0) + (d[p[1]] << 1);
+                    if (E === 0 || E === 3) continue;
+                    switch (E) {
+                      case 0:
+                        break;
+                      case 1:
+                        _.push([l(h, f, p[0], p[1])]);
+                        break;
+                      case 2:
+                        _.push([l(h, f, p[1], p[0])]);
+                        break;
+                    }
+                  }
+                }
+                return _;
+              }
+              return u;
+            }, function() {
+              function l(c, f, h, d) {
+                for (var v = Math.min(h, d) | 0, _ = Math.max(h, d) | 0, b = c[2 * v], p = c[2 * v + 1]; b < p; ) {
+                  var k = b + p >> 1, E = f[2 * k + 1];
+                  if (E === _) return k;
+                  _ < E ? p = k : b = k + 1;
+                }
+                return b;
+              }
+              function u(c, f, h, d) {
+                for (var v = c.length, _ = [], b = 0; b < v; ++b) {
+                  var p = c[b], k = p.length;
+                  if (k === 4) {
+                    var E = (d[p[0]] << 0) + (d[p[1]] << 1) + (d[p[2]] << 2) + (d[p[3]] << 3);
+                    if (E === 0 || E === 15) continue;
+                    switch (E) {
+                      case 0:
+                        break;
+                      case 1:
+                        _.push([l(h, f, p[0], p[1]), l(h, f, p[0], p[2]), l(h, f, p[0], p[3])]);
+                        break;
+                      case 2:
+                        _.push([l(h, f, p[1], p[2]), l(h, f, p[1], p[0]), l(h, f, p[1], p[3])]);
+                        break;
+                      case 3:
+                        _.push([l(h, f, p[1], p[2]), l(h, f, p[0], p[2]), l(h, f, p[0], p[3])], [l(h, f, p[1], p[3]), l(h, f, p[1], p[2]), l(h, f, p[0], p[3])]);
+                        break;
+                      case 4:
+                        _.push([l(h, f, p[2], p[0]), l(h, f, p[2], p[1]), l(h, f, p[2], p[3])]);
+                        break;
+                      case 5:
+                        _.push([l(h, f, p[0], p[1]), l(h, f, p[2], p[1]), l(h, f, p[0], p[3])], [l(h, f, p[2], p[1]), l(h, f, p[2], p[3]), l(h, f, p[0], p[3])]);
+                        break;
+                      case 6:
+                        _.push([l(h, f, p[2], p[0]), l(h, f, p[1], p[0]), l(h, f, p[1], p[3])], [l(h, f, p[2], p[3]), l(h, f, p[2], p[0]), l(h, f, p[1], p[3])]);
+                        break;
+                      case 7:
+                        _.push([l(h, f, p[0], p[3]), l(h, f, p[1], p[3]), l(h, f, p[2], p[3])]);
+                        break;
+                      case 8:
+                        _.push([l(h, f, p[3], p[1]), l(h, f, p[3], p[0]), l(h, f, p[3], p[2])]);
+                        break;
+                      case 9:
+                        _.push([l(h, f, p[3], p[1]), l(h, f, p[0], p[1]), l(h, f, p[0], p[2])], [l(h, f, p[3], p[2]), l(h, f, p[3], p[1]), l(h, f, p[0], p[2])]);
+                        break;
+                      case 10:
+                        _.push([l(h, f, p[1], p[0]), l(h, f, p[3], p[0]), l(h, f, p[1], p[2])], [l(h, f, p[3], p[0]), l(h, f, p[3], p[2]), l(h, f, p[1], p[2])]);
+                        break;
+                      case 11:
+                        _.push([l(h, f, p[1], p[2]), l(h, f, p[0], p[2]), l(h, f, p[3], p[2])]);
+                        break;
+                      case 12:
+                        _.push([l(h, f, p[3], p[0]), l(h, f, p[2], p[0]), l(h, f, p[2], p[1])], [l(h, f, p[3], p[1]), l(h, f, p[3], p[0]), l(h, f, p[2], p[1])]);
+                        break;
+                      case 13:
+                        _.push([l(h, f, p[0], p[1]), l(h, f, p[2], p[1]), l(h, f, p[3], p[1])]);
+                        break;
+                      case 14:
+                        _.push([l(h, f, p[2], p[0]), l(h, f, p[1], p[0]), l(h, f, p[3], p[0])]);
+                        break;
+                    }
+                  } else if (k === 3) {
+                    var E = (d[p[0]] << 0) + (d[p[1]] << 1) + (d[p[2]] << 2);
+                    if (E === 0 || E === 7) continue;
+                    switch (E) {
+                      case 0:
+                        break;
+                      case 1:
+                        _.push([l(h, f, p[0], p[2]), l(h, f, p[0], p[1])]);
+                        break;
+                      case 2:
+                        _.push([l(h, f, p[1], p[0]), l(h, f, p[1], p[2])]);
+                        break;
+                      case 3:
+                        _.push([l(h, f, p[0], p[2]), l(h, f, p[1], p[2])]);
+                        break;
+                      case 4:
+                        _.push([l(h, f, p[2], p[1]), l(h, f, p[2], p[0])]);
+                        break;
+                      case 5:
+                        _.push([l(h, f, p[2], p[1]), l(h, f, p[0], p[1])]);
+                        break;
+                      case 6:
+                        _.push([l(h, f, p[1], p[0]), l(h, f, p[2], p[0])]);
+                        break;
+                    }
+                  } else if (k === 2) {
+                    var E = (d[p[0]] << 0) + (d[p[1]] << 1);
+                    if (E === 0 || E === 3) continue;
+                    switch (E) {
+                      case 0:
+                        break;
+                      case 1:
+                        _.push([l(h, f, p[0], p[1])]);
+                        break;
+                      case 2:
+                        _.push([l(h, f, p[1], p[0])]);
+                        break;
+                    }
+                  }
+                }
+                return _;
+              }
+              return u;
+            }];
+            function o(s) {
+              return a[s]();
+            }
+          }, 1682: function(i) {
+            function a(l, u) {
+              for (var c = 1, f = l.length, h = l[0], d = l[0], v = 1; v < f; ++v) if (d = h, h = l[v], u(h, d)) {
+                if (v === c) {
+                  c++;
+                  continue;
+                }
+                l[c++] = h;
+              }
+              return l.length = c, l;
+            }
+            function o(l) {
+              for (var u = 1, c = l.length, f = l[0], h = l[0], d = 1; d < c; ++d, h = f) if (h = f, f = l[d], f !== h) {
+                if (d === u) {
+                  u++;
+                  continue;
+                }
+                l[u++] = f;
+              }
+              return l.length = u, l;
+            }
+            function s(l, u, c) {
+              return l.length === 0 ? l : u ? (c || l.sort(u), a(l, u)) : (c || l.sort(), o(l));
+            }
+            i.exports = s;
+          }, 1755: function(i) {
+            "use restrict";
+            i.exports = a;
+            function a(s) {
+              this.roots = new Array(s), this.ranks = new Array(s);
+              for (var l = 0; l < s; ++l) this.roots[l] = l, this.ranks[l] = 0;
+            }
+            var o = a.prototype;
+            Object.defineProperty(o, "length", { get: function() {
+              return this.roots.length;
+            } }), o.makeSet = function() {
+              var s = this.roots.length;
+              return this.roots.push(s), this.ranks.push(0), s;
+            }, o.find = function(s) {
+              for (var l = s, u = this.roots; u[s] !== s; ) s = u[s];
+              for (; u[l] !== s; ) {
+                var c = u[l];
+                u[l] = s, l = c;
+              }
+              return s;
+            }, o.link = function(s, l) {
+              var u = this.find(s), c = this.find(l);
+              if (u !== c) {
+                var f = this.ranks, h = this.roots, d = f[u], v = f[c];
+                d < v ? h[u] = c : v < d ? h[c] = u : (h[c] = u, ++f[u]);
+              }
+            };
+          }, 1811: function(i, a, o) {
+            var s = o(2478), l = o(7442), u = o(7608), c = o(5567), f = o(2408), h = o(7089), d = o(6582), v = o(7656);
+            o(2504);
+            var b = o(3536), p = [0, 0, 0];
+            i.exports = L;
+            function k(x) {
+              this._components = x.slice(), this._time = [0], this.prevMatrix = x.slice(), this.nextMatrix = x.slice(), this.computedMatrix = x.slice(), this.computedInverse = x.slice(), this.computedEye = [0, 0, 0], this.computedUp = [0, 0, 0], this.computedCenter = [0, 0, 0], this.computedRadius = [0], this._limits = [-1 / 0, 1 / 0];
+            }
+            var E = k.prototype;
+            E.recalcMatrix = function(x) {
+              var C = this._time, M = s.le(C, x), g = this.computedMatrix;
+              if (!(M < 0)) {
+                var P = this._components;
+                if (M === C.length - 1) for (var A = 16 * M, z = 0; z < 16; ++z) g[z] = P[A++];
+                else {
+                  for (var O = C[M + 1] - C[M], A = 16 * M, U = this.prevMatrix, G = true, z = 0; z < 16; ++z) U[z] = P[A++];
+                  for (var Z = this.nextMatrix, z = 0; z < 16; ++z) Z[z] = P[A++], G = G && U[z] === Z[z];
+                  if (O < 1e-6 || G) for (var z = 0; z < 16; ++z) g[z] = U[z];
+                  else l(g, U, Z, (x - C[M]) / O);
+                }
+                var j = this.computedUp;
+                j[0] = g[1], j[1] = g[5], j[2] = g[9], b(j, j);
+                var N = this.computedInverse;
+                u(N, g);
+                var H = this.computedEye, re = N[15];
+                H[0] = N[12] / re, H[1] = N[13] / re, H[2] = N[14] / re;
+                for (var oe = this.computedCenter, _e = Math.exp(this.computedRadius[0]), z = 0; z < 3; ++z) oe[z] = H[z] - g[2 + 4 * z] * _e;
+              }
+            }, E.idle = function(x) {
+              if (!(x < this.lastT())) {
+                for (var C = this._components, M = C.length - 16, g = 0; g < 16; ++g) C.push(C[M++]);
+                this._time.push(x);
+              }
+            }, E.flush = function(x) {
+              var C = s.gt(this._time, x) - 2;
+              C < 0 || (this._time.splice(0, C), this._components.splice(0, 16 * C));
+            }, E.lastT = function() {
+              return this._time[this._time.length - 1];
+            }, E.lookAt = function(x, C, M, g) {
+              this.recalcMatrix(x), C = C || this.computedEye, M = M || p, g = g || this.computedUp, this.setMatrix(x, d(this.computedMatrix, C, M, g));
+              for (var P = 0, A = 0; A < 3; ++A) P += Math.pow(M[A] - C[A], 2);
+              P = Math.log(Math.sqrt(P)), this.computedRadius[0] = P;
+            }, E.rotate = function(x, C, M, g) {
+              this.recalcMatrix(x);
+              var P = this.computedInverse;
+              C && f(P, P, C), M && c(P, P, M), g && h(P, P, g), this.setMatrix(x, u(this.computedMatrix, P));
+            };
+            var T = [0, 0, 0];
+            E.pan = function(x, C, M, g) {
+              T[0] = -(C || 0), T[1] = -(M || 0), T[2] = -(g || 0), this.recalcMatrix(x);
+              var P = this.computedInverse;
+              v(P, P, T), this.setMatrix(x, u(P, P));
+            }, E.translate = function(x, C, M, g) {
+              T[0] = C || 0, T[1] = M || 0, T[2] = g || 0, this.recalcMatrix(x);
+              var P = this.computedMatrix;
+              v(P, P, T), this.setMatrix(x, P);
+            }, E.setMatrix = function(x, C) {
+              if (!(x < this.lastT())) {
+                this._time.push(x);
+                for (var M = 0; M < 16; ++M) this._components.push(C[M]);
+              }
+            }, E.setDistance = function(x, C) {
+              this.computedRadius[0] = C;
+            }, E.setDistanceLimits = function(x, C) {
+              var M = this._limits;
+              M[0] = x, M[1] = C;
+            }, E.getDistanceLimits = function(x) {
+              var C = this._limits;
+              return x ? (x[0] = C[0], x[1] = C[1], x) : C;
+            };
+            function L(x) {
+              x = x || {};
+              var C = x.matrix || [1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1];
+              return new k(C);
+            }
+          }, 1848: function(i, a, o) {
+            var s = o(4905), l = o(6468);
+            i.exports = u;
+            function u(c) {
+              for (var f = Array.isArray(c) ? c : s(c), h = 0; h < f.length; h++) {
+                var d = f[h];
+                if (d.type === "preprocessor") {
+                  var v = d.data.match(/\#define\s+SHADER_NAME(_B64)?\s+(.+)$/);
+                  if (v && v[2]) {
+                    var _ = v[1], b = v[2];
+                    return (_ ? l(b) : b).trim();
+                  }
+                }
+              }
+            }
+          }, 1879: function(i, a, o) {
+            var s = o(3236), l = o(9405), u = s([`precision highp float;
+#define GLSLIFY 1
+
+attribute vec3 position;
+
+uniform mat4 model, view, projection;
+uniform vec3 offset, majorAxis, minorAxis, screenAxis;
+uniform float lineWidth;
+uniform vec2 screenShape;
+
+vec3 project(vec3 p) {
+  vec4 pp = projection * (view * (model * vec4(p, 1.0)));
+  return pp.xyz / max(pp.w, 0.0001);
+}
+
+void main() {
+  vec3 major = position.x * majorAxis;
+  vec3 minor = position.y * minorAxis;
+
+  vec3 vPosition = major + minor + offset;
+  vec3 pPosition = project(vPosition);
+  vec3 offset = project(vPosition + screenAxis * position.z);
+
+  vec2 screen = normalize((offset - pPosition).xy * screenShape) / screenShape;
+
+  gl_Position = vec4(pPosition + vec3(0.5 * screen * lineWidth, 0), 1.0);
+}
+`]), c = s([`precision highp float;
+#define GLSLIFY 1
+
+uniform vec4 color;
+void main() {
+  gl_FragColor = color;
+}`]);
+            a.n = function(_) {
+              return l(_, u, c, null, [{ name: "position", type: "vec3" }]);
+            };
+            var f = s([`precision highp float;
+#define GLSLIFY 1
+
+attribute vec3 position;
+
+uniform mat4 model, view, projection;
+uniform vec3 offset, axis, alignDir, alignOpt;
+uniform float scale, angle, pixelScale;
+uniform vec2 resolution;
+
+vec3 project(vec3 p) {
+  vec4 pp = projection * (view * (model * vec4(p, 1.0)));
+  return pp.xyz / max(pp.w, 0.0001);
+}
+
+float computeViewAngle(vec3 a, vec3 b) {
+  vec3 A = project(a);
+  vec3 B = project(b);
+
+  return atan(
+    (B.y - A.y) * resolution.y,
+    (B.x - A.x) * resolution.x
+  );
+}
+
+const float PI = 3.141592;
+const float TWO_PI = 2.0 * PI;
+const float HALF_PI = 0.5 * PI;
+const float ONE_AND_HALF_PI = 1.5 * PI;
+
+int option = int(floor(alignOpt.x + 0.001));
+float hv_ratio =       alignOpt.y;
+bool enableAlign =    (alignOpt.z != 0.0);
+
+float mod_angle(float a) {
+  return mod(a, PI);
+}
+
+float positive_angle(float a) {
+  return mod_angle((a < 0.0) ?
+    a + TWO_PI :
+    a
+  );
+}
+
+float look_upwards(float a) {
+  float b = positive_angle(a);
+  return ((b > HALF_PI) && (b <= ONE_AND_HALF_PI)) ?
+    b - PI :
+    b;
+}
+
+float look_horizontal_or_vertical(float a, float ratio) {
+  // ratio controls the ratio between being horizontal to (vertical + horizontal)
+  // if ratio is set to 0.5 then it is 50%, 50%.
+  // when using a higher ratio e.g. 0.75 the result would
+  // likely be more horizontal than vertical.
+
+  float b = positive_angle(a);
+
+  return
+    (b < (      ratio) * HALF_PI) ? 0.0 :
+    (b < (2.0 - ratio) * HALF_PI) ? -HALF_PI :
+    (b < (2.0 + ratio) * HALF_PI) ? 0.0 :
+    (b < (4.0 - ratio) * HALF_PI) ? HALF_PI :
+                                    0.0;
+}
+
+float roundTo(float a, float b) {
+  return float(b * floor((a + 0.5 * b) / b));
+}
+
+float look_round_n_directions(float a, int n) {
+  float b = positive_angle(a);
+  float div = TWO_PI / float(n);
+  float c = roundTo(b, div);
+  return look_upwards(c);
+}
+
+float applyAlignOption(float rawAngle, float delta) {
+  return
+    (option >  2) ? look_round_n_directions(rawAngle + delta, option) :       // option 3-n: round to n directions
+    (option == 2) ? look_horizontal_or_vertical(rawAngle + delta, hv_ratio) : // horizontal or vertical
+    (option == 1) ? rawAngle + delta :       // use free angle, and flip to align with one direction of the axis
+    (option == 0) ? look_upwards(rawAngle) : // use free angle, and stay upwards
+    (option ==-1) ? 0.0 :                    // useful for backward compatibility, all texts remains horizontal
+                    rawAngle;                // otherwise return back raw input angle
+}
+
+bool isAxisTitle = (axis.x == 0.0) &&
+                   (axis.y == 0.0) &&
+                   (axis.z == 0.0);
+
+void main() {
+  //Compute world offset
+  float axisDistance = position.z;
+  vec3 dataPosition = axisDistance * axis + offset;
+
+  float beta = angle; // i.e. user defined attributes for each tick
+
+  float axisAngle;
+  float clipAngle;
+  float flip;
+
+  if (enableAlign) {
+    axisAngle = (isAxisTitle) ? HALF_PI :
+                      computeViewAngle(dataPosition, dataPosition + axis);
+    clipAngle = computeViewAngle(dataPosition, dataPosition + alignDir);
+
+    axisAngle += (sin(axisAngle) < 0.0) ? PI : 0.0;
+    clipAngle += (sin(clipAngle) < 0.0) ? PI : 0.0;
+
+    flip = (dot(vec2(cos(axisAngle), sin(axisAngle)),
+                vec2(sin(clipAngle),-cos(clipAngle))) > 0.0) ? 1.0 : 0.0;
+
+    beta += applyAlignOption(clipAngle, flip * PI);
+  }
+
+  //Compute plane offset
+  vec2 planeCoord = position.xy * pixelScale;
+
+  mat2 planeXform = scale * mat2(
+     cos(beta), sin(beta),
+    -sin(beta), cos(beta)
+  );
+
+  vec2 viewOffset = 2.0 * planeXform * planeCoord / resolution;
+
+  //Compute clip position
+  vec3 clipPosition = project(dataPosition);
+
+  //Apply text offset in clip coordinates
+  clipPosition += vec3(viewOffset, 0.0);
+
+  //Done
+  gl_Position = vec4(clipPosition, 1.0);
+}
+`]), h = s([`precision highp float;
+#define GLSLIFY 1
+
+uniform vec4 color;
+void main() {
+  gl_FragColor = color;
+}`]);
+            a.Q = function(_) {
+              return l(_, f, h, null, [{ name: "position", type: "vec3" }]);
+            };
+            var d = s([`precision highp float;
+#define GLSLIFY 1
+
+attribute vec3 position;
+attribute vec3 normal;
+
+uniform mat4 model, view, projection;
+uniform vec3 enable;
+uniform vec3 bounds[2];
+
+varying vec3 colorChannel;
+
+void main() {
+
+  vec3 signAxis = sign(bounds[1] - bounds[0]);
+
+  vec3 realNormal = signAxis * normal;
+
+  if(dot(realNormal, enable) > 0.0) {
+    vec3 minRange = min(bounds[0], bounds[1]);
+    vec3 maxRange = max(bounds[0], bounds[1]);
+    vec3 nPosition = mix(minRange, maxRange, 0.5 * (position + 1.0));
+    gl_Position = projection * (view * (model * vec4(nPosition, 1.0)));
+  } else {
+    gl_Position = vec4(0,0,0,0);
+  }
+
+  colorChannel = abs(realNormal);
+}
+`]), v = s([`precision highp float;
+#define GLSLIFY 1
+
+uniform vec4 colors[3];
+
+varying vec3 colorChannel;
+
+void main() {
+  gl_FragColor = colorChannel.x * colors[0] +
+                 colorChannel.y * colors[1] +
+                 colorChannel.z * colors[2];
+}`]);
+            a.bg = function(_) {
+              return l(_, d, v, null, [{ name: "position", type: "vec3" }, { name: "normal", type: "vec3" }]);
+            };
+          }, 1888: function(i, a, o) {
+            var s = o(8828), l = o(1338), u = o(4793).hp;
+            o.g.__TYPEDARRAY_POOL || (o.g.__TYPEDARRAY_POOL = { UINT8: l([32, 0]), UINT16: l([32, 0]), UINT32: l([32, 0]), BIGUINT64: l([32, 0]), INT8: l([32, 0]), INT16: l([32, 0]), INT32: l([32, 0]), BIGINT64: l([32, 0]), FLOAT: l([32, 0]), DOUBLE: l([32, 0]), DATA: l([32, 0]), UINT8C: l([32, 0]), BUFFER: l([32, 0]) });
+            var c = typeof Uint8ClampedArray != "undefined", f = typeof BigUint64Array != "undefined", h = typeof BigInt64Array != "undefined", d = o.g.__TYPEDARRAY_POOL;
+            d.UINT8C || (d.UINT8C = l([32, 0])), d.BIGUINT64 || (d.BIGUINT64 = l([32, 0])), d.BIGINT64 || (d.BIGINT64 = l([32, 0])), d.BUFFER || (d.BUFFER = l([32, 0]));
+            var v = d.DATA, _ = d.BUFFER;
+            a.free = function(j) {
+              if (u.isBuffer(j)) _[s.log2(j.length)].push(j);
+              else {
+                if (Object.prototype.toString.call(j) !== "[object ArrayBuffer]" && (j = j.buffer), !j) return;
+                var N = j.length || j.byteLength, H = s.log2(N) | 0;
+                v[H].push(j);
+              }
+            };
+            function b(Z) {
+              if (Z) {
+                var j = Z.length || Z.byteLength, N = s.log2(j);
+                v[N].push(Z);
+              }
+            }
+            function p(Z) {
+              b(Z.buffer);
+            }
+            a.freeUint8 = a.freeUint16 = a.freeUint32 = a.freeBigUint64 = a.freeInt8 = a.freeInt16 = a.freeInt32 = a.freeBigInt64 = a.freeFloat32 = a.freeFloat = a.freeFloat64 = a.freeDouble = a.freeUint8Clamped = a.freeDataView = p, a.freeArrayBuffer = b, a.freeBuffer = function(j) {
+              _[s.log2(j.length)].push(j);
+            }, a.malloc = function(j, N) {
+              if (N === void 0 || N === "arraybuffer") return k(j);
+              switch (N) {
+                case "uint8":
+                  return E(j);
+                case "uint16":
+                  return T(j);
+                case "uint32":
+                  return L(j);
+                case "int8":
+                  return x(j);
+                case "int16":
+                  return C(j);
+                case "int32":
+                  return M(j);
+                case "float":
+                case "float32":
+                  return g(j);
+                case "double":
+                case "float64":
+                  return P(j);
+                case "uint8_clamped":
+                  return A(j);
+                case "bigint64":
+                  return O(j);
+                case "biguint64":
+                  return z(j);
+                case "buffer":
+                  return G(j);
+                case "data":
+                case "dataview":
+                  return U(j);
+                default:
+                  return null;
+              }
+              return null;
+            };
+            function k(j) {
+              var j = s.nextPow2(j), N = s.log2(j), H = v[N];
+              return H.length > 0 ? H.pop() : new ArrayBuffer(j);
+            }
+            a.mallocArrayBuffer = k;
+            function E(Z) {
+              return new Uint8Array(k(Z), 0, Z);
+            }
+            a.mallocUint8 = E;
+            function T(Z) {
+              return new Uint16Array(k(2 * Z), 0, Z);
+            }
+            a.mallocUint16 = T;
+            function L(Z) {
+              return new Uint32Array(k(4 * Z), 0, Z);
+            }
+            a.mallocUint32 = L;
+            function x(Z) {
+              return new Int8Array(k(Z), 0, Z);
+            }
+            a.mallocInt8 = x;
+            function C(Z) {
+              return new Int16Array(k(2 * Z), 0, Z);
+            }
+            a.mallocInt16 = C;
+            function M(Z) {
+              return new Int32Array(k(4 * Z), 0, Z);
+            }
+            a.mallocInt32 = M;
+            function g(Z) {
+              return new Float32Array(k(4 * Z), 0, Z);
+            }
+            a.mallocFloat32 = a.mallocFloat = g;
+            function P(Z) {
+              return new Float64Array(k(8 * Z), 0, Z);
+            }
+            a.mallocFloat64 = a.mallocDouble = P;
+            function A(Z) {
+              return c ? new Uint8ClampedArray(k(Z), 0, Z) : E(Z);
+            }
+            a.mallocUint8Clamped = A;
+            function z(Z) {
+              return f ? new BigUint64Array(k(8 * Z), 0, Z) : null;
+            }
+            a.mallocBigUint64 = z;
+            function O(Z) {
+              return h ? new BigInt64Array(k(8 * Z), 0, Z) : null;
+            }
+            a.mallocBigInt64 = O;
+            function U(Z) {
+              return new DataView(k(Z), 0, Z);
+            }
+            a.mallocDataView = U;
+            function G(Z) {
+              Z = s.nextPow2(Z);
+              var j = s.log2(Z), N = _[j];
+              return N.length > 0 ? N.pop() : new u(Z);
+            }
+            a.mallocBuffer = G, a.clearCache = function() {
+              for (var j = 0; j < 32; ++j) d.UINT8[j].length = 0, d.UINT16[j].length = 0, d.UINT32[j].length = 0, d.INT8[j].length = 0, d.INT16[j].length = 0, d.INT32[j].length = 0, d.FLOAT[j].length = 0, d.DOUBLE[j].length = 0, d.BIGUINT64[j].length = 0, d.BIGINT64[j].length = 0, d.UINT8C[j].length = 0, v[j].length = 0, _[j].length = 0;
+            };
+          }, 1903: function(i) {
+            i.exports = a;
+            function a(o) {
+              var s = new Float32Array(16);
+              return s[0] = o[0], s[1] = o[1], s[2] = o[2], s[3] = o[3], s[4] = o[4], s[5] = o[5], s[6] = o[6], s[7] = o[7], s[8] = o[8], s[9] = o[9], s[10] = o[10], s[11] = o[11], s[12] = o[12], s[13] = o[13], s[14] = o[14], s[15] = o[15], s;
+            }
+          }, 1944: function(i, a, o) {
+            var s = o(5250), l = o(8210);
+            i.exports = u;
+            function u(c, f) {
+              for (var h = s(c[0], f[0]), d = 1; d < c.length; ++d) h = l(h, s(c[d], f[d]));
+              return h;
+            }
+          }, 1964: function(i, a, o) {
+            i.exports = { alpha_shape: o(3502), convex_hull: o(7352), delaunay_triangulate: o(7642), gl_cone3d: o(6405), gl_error3d: o(9165), gl_line3d: o(5714), gl_mesh3d: o(7201), gl_plot3d: o(4100), gl_scatter3d: o(8418), gl_streamtube3d: o(7815), gl_surface3d: o(9499), ndarray: o(9618), ndarray_linear_interpolate: o(4317) };
+          }, 2014: function(i, a, o) {
+            "use restrict";
+            var s = o(3105), l = o(4623);
+            function u(g) {
+              for (var P = 0, A = Math.max, z = 0, O = g.length; z < O; ++z) P = A(P, g[z].length);
+              return P - 1;
+            }
+            a.dimension = u;
+            function c(g) {
+              for (var P = -1, A = Math.max, z = 0, O = g.length; z < O; ++z) for (var U = g[z], G = 0, Z = U.length; G < Z; ++G) P = A(P, U[G]);
+              return P + 1;
+            }
+            a.countVertices = c;
+            function f(g) {
+              for (var P = new Array(g.length), A = 0, z = g.length; A < z; ++A) P[A] = g[A].slice(0);
+              return P;
+            }
+            a.cloneCells = f;
+            function h(g, P) {
+              var A = g.length, z = g.length - P.length, O = Math.min;
+              if (z) return z;
+              switch (A) {
+                case 0:
+                  return 0;
+                case 1:
+                  return g[0] - P[0];
+                case 2:
+                  var N = g[0] + g[1] - P[0] - P[1];
+                  return N || O(g[0], g[1]) - O(P[0], P[1]);
+                case 3:
+                  var U = g[0] + g[1], G = P[0] + P[1];
+                  if (N = U + g[2] - (G + P[2]), N) return N;
+                  var Z = O(g[0], g[1]), j = O(P[0], P[1]), N = O(Z, g[2]) - O(j, P[2]);
+                  return N || O(Z + g[2], U) - O(j + P[2], G);
+                default:
+                  var H = g.slice(0);
+                  H.sort();
+                  var re = P.slice(0);
+                  re.sort();
+                  for (var oe = 0; oe < A; ++oe) if (z = H[oe] - re[oe], z) return z;
+                  return 0;
+              }
+            }
+            a.compareCells = h;
+            function d(g, P) {
+              return h(g[0], P[0]);
+            }
+            function v(g, P) {
+              if (P) {
+                for (var A = g.length, z = new Array(A), O = 0; O < A; ++O) z[O] = [g[O], P[O]];
+                z.sort(d);
+                for (var O = 0; O < A; ++O) g[O] = z[O][0], P[O] = z[O][1];
+                return g;
+              } else return g.sort(h), g;
+            }
+            a.normalize = v;
+            function _(g) {
+              if (g.length === 0) return [];
+              for (var P = 1, A = g.length, z = 1; z < A; ++z) {
+                var O = g[z];
+                if (h(O, g[z - 1])) {
+                  if (z === P) {
+                    P++;
+                    continue;
+                  }
+                  g[P++] = O;
+                }
+              }
+              return g.length = P, g;
+            }
+            a.unique = _;
+            function b(g, P) {
+              for (var A = 0, z = g.length - 1, O = -1; A <= z; ) {
+                var U = A + z >> 1, G = h(g[U], P);
+                G <= 0 ? (G === 0 && (O = U), A = U + 1) : G > 0 && (z = U - 1);
+              }
+              return O;
+            }
+            a.findCell = b;
+            function p(g, P) {
+              for (var A = new Array(g.length), z = 0, O = A.length; z < O; ++z) A[z] = [];
+              for (var U = [], z = 0, G = P.length; z < G; ++z) for (var Z = P[z], j = Z.length, N = 1, H = 1 << j; N < H; ++N) {
+                U.length = s.popCount(N);
+                for (var re = 0, oe = 0; oe < j; ++oe) N & 1 << oe && (U[re++] = Z[oe]);
+                var _e = b(g, U);
+                if (!(_e < 0)) for (; A[_e++].push(z), !(_e >= g.length || h(g[_e], U) !== 0); ) ;
+              }
+              return A;
+            }
+            a.incidence = p;
+            function k(g, P) {
+              if (!P) return p(_(T(g, 0)), g);
+              for (var A = new Array(P), z = 0; z < P; ++z) A[z] = [];
+              for (var z = 0, O = g.length; z < O; ++z) for (var U = g[z], G = 0, Z = U.length; G < Z; ++G) A[U[G]].push(z);
+              return A;
+            }
+            a.dual = k;
+            function E(g) {
+              for (var P = [], A = 0, z = g.length; A < z; ++A) for (var O = g[A], U = O.length | 0, G = 1, Z = 1 << U; G < Z; ++G) {
+                for (var j = [], N = 0; N < U; ++N) G >>> N & 1 && j.push(O[N]);
+                P.push(j);
+              }
+              return v(P);
+            }
+            a.explode = E;
+            function T(g, P) {
+              if (P < 0) return [];
+              for (var A = [], z = (1 << P + 1) - 1, O = 0; O < g.length; ++O) for (var U = g[O], G = z; G < 1 << U.length; G = s.nextCombination(G)) {
+                for (var Z = new Array(P + 1), j = 0, N = 0; N < U.length; ++N) G & 1 << N && (Z[j++] = U[N]);
+                A.push(Z);
+              }
+              return v(A);
+            }
+            a.skeleton = T;
+            function L(g) {
+              for (var P = [], A = 0, z = g.length; A < z; ++A) for (var O = g[A], U = 0, G = O.length; U < G; ++U) {
+                for (var Z = new Array(O.length - 1), j = 0, N = 0; j < G; ++j) j !== U && (Z[N++] = O[j]);
+                P.push(Z);
+              }
+              return v(P);
+            }
+            a.boundary = L;
+            function x(g, P) {
+              for (var A = new l(P), z = 0; z < g.length; ++z) for (var O = g[z], U = 0; U < O.length; ++U) for (var G = U + 1; G < O.length; ++G) A.link(O[U], O[G]);
+              for (var Z = [], j = A.ranks, z = 0; z < j.length; ++z) j[z] = -1;
+              for (var z = 0; z < g.length; ++z) {
+                var N = A.find(g[z][0]);
+                j[N] < 0 ? (j[N] = Z.length, Z.push([g[z].slice(0)])) : Z[j[N]].push(g[z].slice(0));
+              }
+              return Z;
+            }
+            function C(g) {
+              for (var P = _(v(T(g, 0))), A = new l(P.length), z = 0; z < g.length; ++z) for (var O = g[z], U = 0; U < O.length; ++U) for (var G = b(P, [O[U]]), Z = U + 1; Z < O.length; ++Z) A.link(G, b(P, [O[Z]]));
+              for (var j = [], N = A.ranks, z = 0; z < N.length; ++z) N[z] = -1;
+              for (var z = 0; z < g.length; ++z) {
+                var H = A.find(b(P, [g[z][0]]));
+                N[H] < 0 ? (N[H] = j.length, j.push([g[z].slice(0)])) : j[N[H]].push(g[z].slice(0));
+              }
+              return j;
+            }
+            function M(g, P) {
+              return P ? x(g, P) : C(g);
+            }
+            a.connectedComponents = M;
+          }, 2095: function(i, a, o) {
+            i.exports = b;
+            var s = o(3134), l = o(3088), u = o(5085), c = o(5250), f = o(8210), h = o(1682), d = o(5609);
+            function v(p, k) {
+              for (var E = new Array(p), T = 0; T < p; ++T) E[T] = k;
+              return E;
+            }
+            function _(p) {
+              for (var k = new Array(p), E = 0; E < p; ++E) k[E] = [];
+              return k;
+            }
+            function b(p, k) {
+              var De = d(p, k);
+              p = De[0], k = De[1];
+              for (var E = k.length, T = p.length, L = s(p, k.length), x = 0; x < E; ++x) if (L[x].length % 2 === 1) throw new Error("planar-graph-to-polyline: graph must be manifold");
+              var C = l(p, k);
+              function M(ut) {
+                for (var Wt = ut.length, Nt = [0], $t = 0; $t < Wt; ++$t) {
+                  var sr = k[ut[$t]], Tr = k[ut[($t + 1) % Wt]], fr = c(-sr[0], sr[1]), $e = c(-sr[0], Tr[1]), St = c(Tr[0], sr[1]), Qt = c(Tr[0], Tr[1]);
+                  Nt = f(Nt, f(f(fr, $e), f(St, Qt)));
+                }
+                return Nt[Nt.length - 1] > 0;
+              }
+              C = C.filter(M);
+              for (var g = C.length, P = new Array(g), A = new Array(g), x = 0; x < g; ++x) {
+                P[x] = x;
+                var z = new Array(g), O = C[x].map(function(Wt) {
+                  return k[Wt];
+                }), U = u([O]), G = 0;
+                e: for (var Z = 0; Z < g; ++Z) if (z[Z] = 0, x !== Z) {
+                  for (var j = C[Z], N = j.length, H = 0; H < N; ++H) {
+                    var re = U(k[j[H]]);
+                    if (re !== 0) {
+                      re < 0 && (z[Z] = 1, G += 1);
+                      continue e;
+                    }
+                  }
+                  z[Z] = 1, G += 1;
+                }
+                A[x] = [G, x, z];
+              }
+              A.sort(function(ut, Wt) {
+                return Wt[0] - ut[0];
+              });
+              for (var x = 0; x < g; ++x) for (var z = A[x], oe = z[1], _e = z[2], Z = 0; Z < g; ++Z) _e[Z] && (P[Z] = oe);
+              for (var Ce = _(g), x = 0; x < g; ++x) Ce[x].push(P[x]), Ce[P[x]].push(x);
+              for (var Le = {}, ge = v(E, false), x = 0; x < g; ++x) for (var j = C[x], N = j.length, Z = 0; Z < N; ++Z) {
+                var ie = j[Z], Se = j[(Z + 1) % N], Ee = Math.min(ie, Se) + ":" + Math.max(ie, Se);
+                if (Ee in Le) {
+                  var Ae = Le[Ee];
+                  Ce[Ae].push(x), Ce[x].push(Ae), ge[ie] = ge[Se] = true;
+                } else Le[Ee] = x;
+              }
+              function Be(ut) {
+                for (var Wt = ut.length, Nt = 0; Nt < Wt; ++Nt) if (!ge[ut[Nt]]) return false;
+                return true;
+              }
+              for (var Pe = [], me = v(g, -1), x = 0; x < g; ++x) P[x] === x && !Be(C[x]) ? (Pe.push(x), me[x] = 0) : me[x] = -1;
+              for (var De = []; Pe.length > 0; ) {
+                var ce = Pe.pop(), je = Ce[ce];
+                h(je, function(ut, Wt) {
+                  return ut - Wt;
+                });
+                var lt = je.length, pt = me[ce], Vt;
+                if (pt === 0) {
+                  var j = C[ce];
+                  Vt = [j];
+                }
+                for (var x = 0; x < lt; ++x) {
+                  var ot = je[x];
+                  if (!(me[ot] >= 0) && (me[ot] = pt ^ 1, Pe.push(ot), pt === 0)) {
+                    var j = C[ot];
+                    Be(j) || (j.reverse(), Vt.push(j));
+                  }
+                }
+                pt === 0 && De.push(Vt);
+              }
+              return De;
+            }
+          }, 2145: function(i, a) {
+            a.uniforms = u, a.attributes = c;
+            var o = { FLOAT: "float", FLOAT_VEC2: "vec2", FLOAT_VEC3: "vec3", FLOAT_VEC4: "vec4", INT: "int", INT_VEC2: "ivec2", INT_VEC3: "ivec3", INT_VEC4: "ivec4", BOOL: "bool", BOOL_VEC2: "bvec2", BOOL_VEC3: "bvec3", BOOL_VEC4: "bvec4", FLOAT_MAT2: "mat2", FLOAT_MAT3: "mat3", FLOAT_MAT4: "mat4", SAMPLER_2D: "sampler2D", SAMPLER_CUBE: "samplerCube" }, s = null;
+            function l(f, h) {
+              if (!s) {
+                var d = Object.keys(o);
+                s = {};
+                for (var v = 0; v < d.length; ++v) {
+                  var _ = d[v];
+                  s[f[_]] = o[_];
+                }
+              }
+              return s[h];
+            }
+            function u(f, h) {
+              for (var d = f.getProgramParameter(h, f.ACTIVE_UNIFORMS), v = [], _ = 0; _ < d; ++_) {
+                var b = f.getActiveUniform(h, _);
+                if (b) {
+                  var p = l(f, b.type);
+                  if (b.size > 1) for (var k = 0; k < b.size; ++k) v.push({ name: b.name.replace("[0]", "[" + k + "]"), type: p });
+                  else v.push({ name: b.name, type: p });
+                }
+              }
+              return v;
+            }
+            function c(f, h) {
+              for (var d = f.getProgramParameter(h, f.ACTIVE_ATTRIBUTES), v = [], _ = 0; _ < d; ++_) {
+                var b = f.getActiveAttrib(h, _);
+                b && v.push({ name: b.name, type: l(f, b.type) });
+              }
+              return v;
+            }
+          }, 2229: function(i, a, o) {
+            i.exports = o(6843);
+          }, 2260: function(i, a, o) {
+            var s = o(7766);
+            i.exports = C;
+            var l = null, u, c, f, h;
+            function d(M) {
+              var g = M.getParameter(M.FRAMEBUFFER_BINDING), P = M.getParameter(M.RENDERBUFFER_BINDING), A = M.getParameter(M.TEXTURE_BINDING_2D);
+              return [g, P, A];
+            }
+            function v(M, g) {
+              M.bindFramebuffer(M.FRAMEBUFFER, g[0]), M.bindRenderbuffer(M.RENDERBUFFER, g[1]), M.bindTexture(M.TEXTURE_2D, g[2]);
+            }
+            function _(M, g) {
+              var P = M.getParameter(g.MAX_COLOR_ATTACHMENTS_WEBGL);
+              l = new Array(P + 1);
+              for (var A = 0; A <= P; ++A) {
+                for (var z = new Array(P), O = 0; O < A; ++O) z[O] = M.COLOR_ATTACHMENT0 + O;
+                for (var O = A; O < P; ++O) z[O] = M.NONE;
+                l[A] = z;
+              }
+            }
+            function b(M) {
+              switch (M) {
+                case u:
+                  throw new Error("gl-fbo: Framebuffer unsupported");
+                case c:
+                  throw new Error("gl-fbo: Framebuffer incomplete attachment");
+                case f:
+                  throw new Error("gl-fbo: Framebuffer incomplete dimensions");
+                case h:
+                  throw new Error("gl-fbo: Framebuffer incomplete missing attachment");
+                default:
+                  throw new Error("gl-fbo: Framebuffer failed for unspecified reason");
+              }
+            }
+            function p(M, g, P, A, z, O) {
+              if (!A) return null;
+              var U = s(M, g, P, z, A);
+              return U.magFilter = M.NEAREST, U.minFilter = M.NEAREST, U.mipSamples = 1, U.bind(), M.framebufferTexture2D(M.FRAMEBUFFER, O, M.TEXTURE_2D, U.handle, 0), U;
+            }
+            function k(M, g, P, A, z) {
+              var O = M.createRenderbuffer();
+              return M.bindRenderbuffer(M.RENDERBUFFER, O), M.renderbufferStorage(M.RENDERBUFFER, A, g, P), M.framebufferRenderbuffer(M.FRAMEBUFFER, z, M.RENDERBUFFER, O), O;
+            }
+            function E(M) {
+              var g = d(M.gl), P = M.gl, A = M.handle = P.createFramebuffer(), z = M._shape[0], O = M._shape[1], U = M.color.length, G = M._ext, Z = M._useStencil, j = M._useDepth, N = M._colorType;
+              P.bindFramebuffer(P.FRAMEBUFFER, A);
+              for (var H = 0; H < U; ++H) M.color[H] = p(P, z, O, N, P.RGBA, P.COLOR_ATTACHMENT0 + H);
+              U === 0 ? (M._color_rb = k(P, z, O, P.RGBA4, P.COLOR_ATTACHMENT0), G && G.drawBuffersWEBGL(l[0])) : U > 1 && G.drawBuffersWEBGL(l[U]);
+              var re = P.getExtension("WEBGL_depth_texture");
+              re ? Z ? M.depth = p(P, z, O, re.UNSIGNED_INT_24_8_WEBGL, P.DEPTH_STENCIL, P.DEPTH_STENCIL_ATTACHMENT) : j && (M.depth = p(P, z, O, P.UNSIGNED_SHORT, P.DEPTH_COMPONENT, P.DEPTH_ATTACHMENT)) : j && Z ? M._depth_rb = k(P, z, O, P.DEPTH_STENCIL, P.DEPTH_STENCIL_ATTACHMENT) : j ? M._depth_rb = k(P, z, O, P.DEPTH_COMPONENT16, P.DEPTH_ATTACHMENT) : Z && (M._depth_rb = k(P, z, O, P.STENCIL_INDEX, P.STENCIL_ATTACHMENT));
+              var oe = P.checkFramebufferStatus(P.FRAMEBUFFER);
+              if (oe !== P.FRAMEBUFFER_COMPLETE) {
+                M._destroyed = true, P.bindFramebuffer(P.FRAMEBUFFER, null), P.deleteFramebuffer(M.handle), M.handle = null, M.depth && (M.depth.dispose(), M.depth = null), M._depth_rb && (P.deleteRenderbuffer(M._depth_rb), M._depth_rb = null);
+                for (var H = 0; H < M.color.length; ++H) M.color[H].dispose(), M.color[H] = null;
+                M._color_rb && (P.deleteRenderbuffer(M._color_rb), M._color_rb = null), v(P, g), b(oe);
+              }
+              v(P, g);
+            }
+            function T(M, g, P, A, z, O, U, G) {
+              this.gl = M, this._shape = [g | 0, P | 0], this._destroyed = false, this._ext = G, this.color = new Array(z);
+              for (var Z = 0; Z < z; ++Z) this.color[Z] = null;
+              this._color_rb = null, this.depth = null, this._depth_rb = null, this._colorType = A, this._useDepth = O, this._useStencil = U;
+              var j = this, N = [g | 0, P | 0];
+              Object.defineProperties(N, { 0: { get: function() {
+                return j._shape[0];
+              }, set: function(H) {
+                return j.width = H;
+              } }, 1: { get: function() {
+                return j._shape[1];
+              }, set: function(H) {
+                return j.height = H;
+              } } }), this._shapeVector = N, E(this);
+            }
+            var L = T.prototype;
+            function x(M, g, P) {
+              if (M._destroyed) throw new Error("gl-fbo: Can't resize destroyed FBO");
+              if (!(M._shape[0] === g && M._shape[1] === P)) {
+                var A = M.gl, z = A.getParameter(A.MAX_RENDERBUFFER_SIZE);
+                if (g < 0 || g > z || P < 0 || P > z) throw new Error("gl-fbo: Can't resize FBO, invalid dimensions");
+                M._shape[0] = g, M._shape[1] = P;
+                for (var O = d(A), U = 0; U < M.color.length; ++U) M.color[U].shape = M._shape;
+                M._color_rb && (A.bindRenderbuffer(A.RENDERBUFFER, M._color_rb), A.renderbufferStorage(A.RENDERBUFFER, A.RGBA4, M._shape[0], M._shape[1])), M.depth && (M.depth.shape = M._shape), M._depth_rb && (A.bindRenderbuffer(A.RENDERBUFFER, M._depth_rb), M._useDepth && M._useStencil ? A.renderbufferStorage(A.RENDERBUFFER, A.DEPTH_STENCIL, M._shape[0], M._shape[1]) : M._useDepth ? A.renderbufferStorage(A.RENDERBUFFER, A.DEPTH_COMPONENT16, M._shape[0], M._shape[1]) : M._useStencil && A.renderbufferStorage(A.RENDERBUFFER, A.STENCIL_INDEX, M._shape[0], M._shape[1])), A.bindFramebuffer(A.FRAMEBUFFER, M.handle);
+                var G = A.checkFramebufferStatus(A.FRAMEBUFFER);
+                G !== A.FRAMEBUFFER_COMPLETE && (M.dispose(), v(A, O), b(G)), v(A, O);
+              }
+            }
+            Object.defineProperties(L, { shape: { get: function() {
+              return this._destroyed ? [0, 0] : this._shapeVector;
+            }, set: function(M) {
+              if (Array.isArray(M) || (M = [M | 0, M | 0]), M.length !== 2) throw new Error("gl-fbo: Shape vector must be length 2");
+              var g = M[0] | 0, P = M[1] | 0;
+              return x(this, g, P), [g, P];
+            }, enumerable: false }, width: { get: function() {
+              return this._destroyed ? 0 : this._shape[0];
+            }, set: function(M) {
+              return M = M | 0, x(this, M, this._shape[1]), M;
+            }, enumerable: false }, height: { get: function() {
+              return this._destroyed ? 0 : this._shape[1];
+            }, set: function(M) {
+              return M = M | 0, x(this, this._shape[0], M), M;
+            }, enumerable: false } }), L.bind = function() {
+              if (!this._destroyed) {
+                var M = this.gl;
+                M.bindFramebuffer(M.FRAMEBUFFER, this.handle), M.viewport(0, 0, this._shape[0], this._shape[1]);
+              }
+            }, L.dispose = function() {
+              if (!this._destroyed) {
+                this._destroyed = true;
+                var M = this.gl;
+                M.deleteFramebuffer(this.handle), this.handle = null, this.depth && (this.depth.dispose(), this.depth = null), this._depth_rb && (M.deleteRenderbuffer(this._depth_rb), this._depth_rb = null);
+                for (var g = 0; g < this.color.length; ++g) this.color[g].dispose(), this.color[g] = null;
+                this._color_rb && (M.deleteRenderbuffer(this._color_rb), this._color_rb = null);
+              }
+            };
+            function C(M, g, P, A) {
+              u || (u = M.FRAMEBUFFER_UNSUPPORTED, c = M.FRAMEBUFFER_INCOMPLETE_ATTACHMENT, f = M.FRAMEBUFFER_INCOMPLETE_DIMENSIONS, h = M.FRAMEBUFFER_INCOMPLETE_MISSING_ATTACHMENT);
+              var z = M.getExtension("WEBGL_draw_buffers");
+              if (!l && z && _(M, z), Array.isArray(g) && (A = P, P = g[1] | 0, g = g[0] | 0), typeof g != "number") throw new Error("gl-fbo: Missing shape parameter");
+              var O = M.getParameter(M.MAX_RENDERBUFFER_SIZE);
+              if (g < 0 || g > O || P < 0 || P > O) throw new Error("gl-fbo: Parameters are too large for FBO");
+              A = A || {};
+              var U = 1;
+              if ("color" in A) {
+                if (U = Math.max(A.color | 0, 0), U < 0) throw new Error("gl-fbo: Must specify a nonnegative number of colors");
+                if (U > 1) if (z) {
+                  if (U > M.getParameter(z.MAX_COLOR_ATTACHMENTS_WEBGL)) throw new Error("gl-fbo: Context does not support " + U + " draw buffers");
+                } else throw new Error("gl-fbo: Multiple draw buffer extension not supported");
+              }
+              var G = M.UNSIGNED_BYTE, Z = M.getExtension("OES_texture_float");
+              if (A.float && U > 0) {
+                if (!Z) throw new Error("gl-fbo: Context does not support floating point textures");
+                G = M.FLOAT;
+              } else A.preferFloat && U > 0 && Z && (G = M.FLOAT);
+              var j = true;
+              "depth" in A && (j = !!A.depth);
+              var N = false;
+              return "stencil" in A && (N = !!A.stencil), new T(M, g, P, G, U, j, N, z);
+            }
+          }, 2272: function(i, a, o) {
+            var s = o(2646)[4];
+            o(2478);
+            i.exports = c;
+            function u(f, h, d, v, _, b) {
+              var p = h.opposite(v, _);
+              if (!(p < 0)) {
+                if (_ < v) {
+                  var k = v;
+                  v = _, _ = k, k = b, b = p, p = k;
+                }
+                h.isConstraint(v, _) || s(f[v], f[_], f[b], f[p]) < 0 && d.push(v, _);
+              }
+            }
+            function c(f, h) {
+              for (var d = [], v = f.length, _ = h.stars, b = 0; b < v; ++b) for (var p = _[b], k = 1; k < p.length; k += 2) {
+                var E = p[k];
+                if (!(E < b) && !h.isConstraint(b, E)) {
+                  for (var T = p[k - 1], L = -1, x = 1; x < p.length; x += 2) if (p[x - 1] === E) {
+                    L = p[x];
+                    break;
+                  }
+                  L < 0 || s(f[b], f[E], f[T], f[L]) < 0 && d.push(b, E);
+                }
+              }
+              for (; d.length > 0; ) {
+                for (var E = d.pop(), b = d.pop(), T = -1, L = -1, p = _[b], C = 1; C < p.length; C += 2) {
+                  var M = p[C - 1], g = p[C];
+                  M === E ? L = g : g === E && (T = M);
+                }
+                T < 0 || L < 0 || s(f[b], f[E], f[T], f[L]) >= 0 || (h.flip(b, E), u(f, h, d, T, b, L), u(f, h, d, b, L, T), u(f, h, d, L, E, T), u(f, h, d, E, T, L));
+              }
+            }
+          }, 2334: function(i) {
+            i.exports = a;
+            function a(o, s, l) {
+              return o[0] = Math.min(s[0], l[0]), o[1] = Math.min(s[1], l[1]), o[2] = Math.min(s[2], l[2]), o[3] = Math.min(s[3], l[3]), o;
+            }
+          }, 2335: function(i) {
+            i.exports = a;
+            function a(o) {
+              var s = new Float32Array(4);
+              return s[0] = o[0], s[1] = o[1], s[2] = o[2], s[3] = o[3], s;
+            }
+          }, 2361: function(i) {
+            var a = false;
+            if (typeof Float64Array != "undefined") {
+              var o = new Float64Array(1), s = new Uint32Array(o.buffer);
+              if (o[0] = 1, a = true, s[1] === 1072693248) {
+                let k = function(L, x) {
+                  return s[0] = L, s[1] = x, o[0];
+                }, E = function(L) {
+                  return o[0] = L, s[0];
+                }, T = function(L) {
+                  return o[0] = L, s[1];
+                };
+                i.exports = function(x) {
+                  return o[0] = x, [s[0], s[1]];
+                }, i.exports.pack = k, i.exports.lo = E, i.exports.hi = T;
+              } else if (s[0] === 1072693248) {
+                let k = function(L, x) {
+                  return s[1] = L, s[0] = x, o[0];
+                }, E = function(L) {
+                  return o[0] = L, s[1];
+                }, T = function(L) {
+                  return o[0] = L, s[0];
+                };
+                i.exports = function(x) {
+                  return o[0] = x, [s[1], s[0]];
+                }, i.exports.pack = k, i.exports.lo = E, i.exports.hi = T;
+              } else a = false;
+            }
+            if (!a) {
+              let k = function(L, x) {
+                return l.writeUInt32LE(L, 0, true), l.writeUInt32LE(x, 4, true), l.readDoubleLE(0, true);
+              }, E = function(L) {
+                return l.writeDoubleLE(L, 0, true), l.readUInt32LE(0, true);
+              }, T = function(L) {
+                return l.writeDoubleLE(L, 0, true), l.readUInt32LE(4, true);
+              };
+              var l = new Buffer(8);
+              i.exports = function(x) {
+                return l.writeDoubleLE(x, 0, true), [l.readUInt32LE(0, true), l.readUInt32LE(4, true)];
+              }, i.exports.pack = k, i.exports.lo = E, i.exports.hi = T;
+            }
+            i.exports.sign = function(k) {
+              return i.exports.hi(k) >>> 31;
+            }, i.exports.exponent = function(k) {
+              var E = i.exports.hi(k);
+              return (E << 1 >>> 21) - 1023;
+            }, i.exports.fraction = function(k) {
+              var E = i.exports.lo(k), T = i.exports.hi(k), L = T & (1 << 20) - 1;
+              return T & 2146435072 && (L += 1048576), [E, L];
+            }, i.exports.denormalized = function(k) {
+              var E = i.exports.hi(k);
+              return !(E & 2146435072);
+            };
+          }, 2408: function(i) {
+            i.exports = a;
+            function a(o, s, l) {
+              var u = Math.sin(l), c = Math.cos(l), f = s[0], h = s[1], d = s[2], v = s[3], _ = s[8], b = s[9], p = s[10], k = s[11];
+              return s !== o && (o[4] = s[4], o[5] = s[5], o[6] = s[6], o[7] = s[7], o[12] = s[12], o[13] = s[13], o[14] = s[14], o[15] = s[15]), o[0] = f * c - _ * u, o[1] = h * c - b * u, o[2] = d * c - p * u, o[3] = v * c - k * u, o[8] = f * u + _ * c, o[9] = h * u + b * c, o[10] = d * u + p * c, o[11] = v * u + k * c, o;
+            }
+          }, 2419: function(i) {
+            i.exports = a;
+            function a(o) {
+              for (var s = 1, l = 1; l < o.length; ++l) for (var u = 0; u < l; ++u) if (o[l] < o[u]) s = -s;
+              else if (o[u] === o[l]) return 0;
+              return s;
+            }
+          }, 2447: function(i) {
+            i.exports = a;
+            function a(o, s) {
+              return o[0] = Math.round(s[0]), o[1] = Math.round(s[1]), o[2] = Math.round(s[2]), o;
+            }
+          }, 2455: function(i, a) {
+            function o() {
+              function u(h, d, v, _, b, p, k, E, T, L, x) {
+                for (var C = 2 * h, M = _, g = C * _; M < b; ++M, g += C) {
+                  var P = p[d + g], A = p[d + g + h], z = k[M];
+                  e: for (var O = E, U = C * E; O < T; ++O, U += C) {
+                    var G = L[d + U], Z = L[d + U + h], j = x[O];
+                    if (!(Z < P || A < G)) {
+                      for (var N = d + 1; N < h; ++N) {
+                        var H = p[N + g], re = p[N + h + g], oe = L[N + U], _e = L[N + h + U];
+                        if (re < oe || _e < H) continue e;
+                      }
+                      var Ce = v(z, j);
+                      if (Ce !== void 0) return Ce;
+                    }
+                  }
+                }
+              }
+              function c(h, d, v, _, b, p, k, E, T, L, x) {
+                for (var C = 2 * h, M = E, g = C * E; M < T; ++M, g += C) {
+                  var P = L[d + g], A = L[d + g + h], z = x[M];
+                  e: for (var O = _, U = C * _; O < b; ++O, U += C) {
+                    var G = p[d + U], Z = p[d + U + h], j = k[O];
+                    if (!(A < G || Z < P)) {
+                      for (var N = d + 1; N < h; ++N) {
+                        var H = p[N + U], re = p[N + h + U], oe = L[N + g], _e = L[N + h + g];
+                        if (re < oe || _e < H) continue e;
+                      }
+                      var Ce = v(j, z);
+                      if (Ce !== void 0) return Ce;
+                    }
+                  }
+                }
+              }
+              function f(h, d, v, _, b, p, k, E, T, L, x) {
+                return b - _ > T - E ? u(h, d, v, _, b, p, k, E, T, L, x) : c(h, d, v, _, b, p, k, E, T, L, x);
+              }
+              return f;
+            }
+            function s() {
+              function u(v, _, b, p, k, E, T, L, x, C, M) {
+                for (var g = 2 * v, P = p, A = g * p; P < k; ++P, A += g) {
+                  var z = E[_ + A], O = E[_ + A + v], U = T[P];
+                  e: for (var G = L, Z = g * L; G < x; ++G, Z += g) {
+                    var j = C[_ + Z], N = M[G];
+                    if (!(j <= z || O < j)) {
+                      for (var H = _ + 1; H < v; ++H) {
+                        var re = E[H + A], oe = E[H + v + A], _e = C[H + Z], Ce = C[H + v + Z];
+                        if (oe < _e || Ce < re) continue e;
+                      }
+                      var Le = b(N, U);
+                      if (Le !== void 0) return Le;
+                    }
+                  }
+                }
+              }
+              function c(v, _, b, p, k, E, T, L, x, C, M) {
+                for (var g = 2 * v, P = p, A = g * p; P < k; ++P, A += g) {
+                  var z = E[_ + A], O = E[_ + A + v], U = T[P];
+                  e: for (var G = L, Z = g * L; G < x; ++G, Z += g) {
+                    var j = C[_ + Z], N = M[G];
+                    if (!(j < z || O < j)) {
+                      for (var H = _ + 1; H < v; ++H) {
+                        var re = E[H + A], oe = E[H + v + A], _e = C[H + Z], Ce = C[H + v + Z];
+                        if (oe < _e || Ce < re) continue e;
+                      }
+                      var Le = b(U, N);
+                      if (Le !== void 0) return Le;
+                    }
+                  }
+                }
+              }
+              function f(v, _, b, p, k, E, T, L, x, C, M) {
+                for (var g = 2 * v, P = L, A = g * L; P < x; ++P, A += g) {
+                  var z = C[_ + A], O = M[P];
+                  e: for (var U = p, G = g * p; U < k; ++U, G += g) {
+                    var Z = E[_ + G], j = E[_ + G + v], N = T[U];
+                    if (!(z <= Z || j < z)) {
+                      for (var H = _ + 1; H < v; ++H) {
+                        var re = E[H + G], oe = E[H + v + G], _e = C[H + A], Ce = C[H + v + A];
+                        if (oe < _e || Ce < re) continue e;
+                      }
+                      var Le = b(O, N);
+                      if (Le !== void 0) return Le;
+                    }
+                  }
+                }
+              }
+              function h(v, _, b, p, k, E, T, L, x, C, M) {
+                for (var g = 2 * v, P = L, A = g * L; P < x; ++P, A += g) {
+                  var z = C[_ + A], O = M[P];
+                  e: for (var U = p, G = g * p; U < k; ++U, G += g) {
+                    var Z = E[_ + G], j = E[_ + G + v], N = T[U];
+                    if (!(z < Z || j < z)) {
+                      for (var H = _ + 1; H < v; ++H) {
+                        var re = E[H + G], oe = E[H + v + G], _e = C[H + A], Ce = C[H + v + A];
+                        if (oe < _e || Ce < re) continue e;
+                      }
+                      var Le = b(N, O);
+                      if (Le !== void 0) return Le;
+                    }
+                  }
+                }
+              }
+              function d(v, _, b, p, k, E, T, L, x, C, M, g) {
+                return E - k > C - x ? p ? u(v, _, b, k, E, T, L, x, C, M, g) : c(v, _, b, k, E, T, L, x, C, M, g) : p ? f(v, _, b, k, E, T, L, x, C, M, g) : h(v, _, b, k, E, T, L, x, C, M, g);
+              }
+              return d;
+            }
+            function l(u) {
+              return u ? o() : s();
+            }
+            a.partial = l(false), a.full = l(true);
+          }, 2478: function(i) {
+            function a(f, h, d, v, _) {
+              for (var b = _ + 1; v <= _; ) {
+                var p = v + _ >>> 1, k = f[p], E = d !== void 0 ? d(k, h) : k - h;
+                E >= 0 ? (b = p, _ = p - 1) : v = p + 1;
+              }
+              return b;
+            }
+            function o(f, h, d, v, _) {
+              for (var b = _ + 1; v <= _; ) {
+                var p = v + _ >>> 1, k = f[p], E = d !== void 0 ? d(k, h) : k - h;
+                E > 0 ? (b = p, _ = p - 1) : v = p + 1;
+              }
+              return b;
+            }
+            function s(f, h, d, v, _) {
+              for (var b = v - 1; v <= _; ) {
+                var p = v + _ >>> 1, k = f[p], E = d !== void 0 ? d(k, h) : k - h;
+                E < 0 ? (b = p, v = p + 1) : _ = p - 1;
+              }
+              return b;
+            }
+            function l(f, h, d, v, _) {
+              for (var b = v - 1; v <= _; ) {
+                var p = v + _ >>> 1, k = f[p], E = d !== void 0 ? d(k, h) : k - h;
+                E <= 0 ? (b = p, v = p + 1) : _ = p - 1;
+              }
+              return b;
+            }
+            function u(f, h, d, v, _) {
+              for (; v <= _; ) {
+                var b = v + _ >>> 1, p = f[b], k = d !== void 0 ? d(p, h) : p - h;
+                if (k === 0) return b;
+                k <= 0 ? v = b + 1 : _ = b - 1;
+              }
+              return -1;
+            }
+            function c(f, h, d, v, _, b) {
+              return typeof d == "function" ? b(f, h, d, v === void 0 ? 0 : v | 0, _ === void 0 ? f.length - 1 : _ | 0) : b(f, h, void 0, d === void 0 ? 0 : d | 0, v === void 0 ? f.length - 1 : v | 0);
+            }
+            i.exports = { ge: function(f, h, d, v, _) {
+              return c(f, h, d, v, _, a);
+            }, gt: function(f, h, d, v, _) {
+              return c(f, h, d, v, _, o);
+            }, lt: function(f, h, d, v, _) {
+              return c(f, h, d, v, _, s);
+            }, le: function(f, h, d, v, _) {
+              return c(f, h, d, v, _, l);
+            }, eq: function(f, h, d, v, _) {
+              return c(f, h, d, v, _, u);
+            } };
+          }, 2504: function(i) {
+            i.exports = a;
+            function a(o, s, l) {
+              var u = l[0], c = l[1], f = l[2];
+              return o[0] = s[0] * u, o[1] = s[1] * u, o[2] = s[2] * u, o[3] = s[3] * u, o[4] = s[4] * c, o[5] = s[5] * c, o[6] = s[6] * c, o[7] = s[7] * c, o[8] = s[8] * f, o[9] = s[9] * f, o[10] = s[10] * f, o[11] = s[11] * f, o[12] = s[12], o[13] = s[13], o[14] = s[14], o[15] = s[15], o;
+            }
+          }, 2538: function(i, a, o) {
+            var s = o(8902), l = o(5542), u = o(2272), c = o(5023);
+            i.exports = _;
+            function f(b) {
+              return [Math.min(b[0], b[1]), Math.max(b[0], b[1])];
+            }
+            function h(b, p) {
+              return b[0] - p[0] || b[1] - p[1];
+            }
+            function d(b) {
+              return b.map(f).sort(h);
+            }
+            function v(b, p, k) {
+              return p in b ? b[p] : k;
+            }
+            function _(b, p, k) {
+              Array.isArray(p) ? (k = k || {}, p = p || []) : (k = p || {}, p = []);
+              var E = !!v(k, "delaunay", true), T = !!v(k, "interior", true), L = !!v(k, "exterior", true), x = !!v(k, "infinity", false);
+              if (!T && !L || b.length === 0) return [];
+              var C = s(b, p);
+              if (E || T !== L || x) {
+                for (var M = l(b.length, d(p)), g = 0; g < C.length; ++g) {
+                  var P = C[g];
+                  M.addTriangle(P[0], P[1], P[2]);
+                }
+                return E && u(b, M), L ? T ? x ? c(M, 0, x) : M.cells() : c(M, 1, x) : c(M, -1);
+              } else return C;
+            }
+          }, 2573: function(i) {
+            i.exports = a;
+            function a(o, s, l, u) {
+              var c = s[0], f = s[1], h = s[2], d = s[3];
+              return o[0] = c + u * (l[0] - c), o[1] = f + u * (l[1] - f), o[2] = h + u * (l[2] - h), o[3] = d + u * (l[3] - d), o;
+            }
+          }, 2613: function(i) {
+            i.exports = 1e-6;
+          }, 2640: function(i, a, o) {
+            var s = o(1888);
+            i.exports = c;
+            var l = { "false,0,1": function(h, d, v, _, b) {
+              return function(k, E, T, L) {
+                var x = k.shape[0] | 0, C = k.shape[1] | 0, M = k.data, g = k.offset | 0, P = k.stride[0] | 0, A = k.stride[1] | 0, z = g, O, U = -P | 0, G = 0, Z = -A | 0, j = 0, N = -P - A | 0, H = 0, re = P | 0, oe = A - P * x | 0, _e = 0, Ce = 0, Le = 0, ge = 2 * x | 0, ie = _(ge), Se = _(ge), Ee = 0, Ae = 0, Be = -1, Pe = -1, me = 0, De = -x | 0, ce = x | 0, je = 0, lt = -x - 1 | 0, pt = x - 1 | 0, Vt = 0, ot = 0, ut = 0;
+                for (_e = 0; _e < x; ++_e) ie[Ee++] = v(M[z], E, T, L), z += re;
+                if (z += oe, C > 0) {
+                  if (Ce = 1, ie[Ee++] = v(M[z], E, T, L), z += re, x > 0) for (_e = 1, O = M[z], Ae = ie[Ee] = v(O, E, T, L), me = ie[Ee + Be], je = ie[Ee + De], Vt = ie[Ee + lt], (Ae !== me || Ae !== je || Ae !== Vt) && (G = M[z + U], j = M[z + Z], H = M[z + N], h(_e, Ce, O, G, j, H, Ae, me, je, Vt, E, T, L), ot = Se[Ee] = Le++), Ee += 1, z += re, _e = 2; _e < x; ++_e) O = M[z], Ae = ie[Ee] = v(O, E, T, L), me = ie[Ee + Be], je = ie[Ee + De], Vt = ie[Ee + lt], (Ae !== me || Ae !== je || Ae !== Vt) && (G = M[z + U], j = M[z + Z], H = M[z + N], h(_e, Ce, O, G, j, H, Ae, me, je, Vt, E, T, L), ot = Se[Ee] = Le++, Vt !== me && d(Se[Ee + Be], ot, H, G, Vt, me, E, T, L)), Ee += 1, z += re;
+                  for (z += oe, Ee = 0, ut = Be, Be = Pe, Pe = ut, ut = De, De = ce, ce = ut, ut = lt, lt = pt, pt = ut, Ce = 2; Ce < C; ++Ce) {
+                    if (ie[Ee++] = v(M[z], E, T, L), z += re, x > 0) for (_e = 1, O = M[z], Ae = ie[Ee] = v(O, E, T, L), me = ie[Ee + Be], je = ie[Ee + De], Vt = ie[Ee + lt], (Ae !== me || Ae !== je || Ae !== Vt) && (G = M[z + U], j = M[z + Z], H = M[z + N], h(_e, Ce, O, G, j, H, Ae, me, je, Vt, E, T, L), ot = Se[Ee] = Le++, Vt !== je && d(Se[Ee + De], ot, j, H, je, Vt, E, T, L)), Ee += 1, z += re, _e = 2; _e < x; ++_e) O = M[z], Ae = ie[Ee] = v(O, E, T, L), me = ie[Ee + Be], je = ie[Ee + De], Vt = ie[Ee + lt], (Ae !== me || Ae !== je || Ae !== Vt) && (G = M[z + U], j = M[z + Z], H = M[z + N], h(_e, Ce, O, G, j, H, Ae, me, je, Vt, E, T, L), ot = Se[Ee] = Le++, Vt !== je && d(Se[Ee + De], ot, j, H, je, Vt, E, T, L), Vt !== me && d(Se[Ee + Be], ot, H, G, Vt, me, E, T, L)), Ee += 1, z += re;
+                    Ce & 1 && (Ee = 0), ut = Be, Be = Pe, Pe = ut, ut = De, De = ce, ce = ut, ut = lt, lt = pt, pt = ut, z += oe;
+                  }
+                }
+                b(Se), b(ie);
+              };
+            }, "false,1,0": function(h, d, v, _, b) {
+              return function(k, E, T, L) {
+                var x = k.shape[0] | 0, C = k.shape[1] | 0, M = k.data, g = k.offset | 0, P = k.stride[0] | 0, A = k.stride[1] | 0, z = g, O, U = -P | 0, G = 0, Z = -A | 0, j = 0, N = -P - A | 0, H = 0, re = A | 0, oe = P - A * C | 0, _e = 0, Ce = 0, Le = 0, ge = 2 * C | 0, ie = _(ge), Se = _(ge), Ee = 0, Ae = 0, Be = -1, Pe = -1, me = 0, De = -C | 0, ce = C | 0, je = 0, lt = -C - 1 | 0, pt = C - 1 | 0, Vt = 0, ot = 0, ut = 0;
+                for (Ce = 0; Ce < C; ++Ce) ie[Ee++] = v(M[z], E, T, L), z += re;
+                if (z += oe, x > 0) {
+                  if (_e = 1, ie[Ee++] = v(M[z], E, T, L), z += re, C > 0) for (Ce = 1, O = M[z], Ae = ie[Ee] = v(O, E, T, L), je = ie[Ee + De], me = ie[Ee + Be], Vt = ie[Ee + lt], (Ae !== je || Ae !== me || Ae !== Vt) && (G = M[z + U], j = M[z + Z], H = M[z + N], h(_e, Ce, O, G, j, H, Ae, je, me, Vt, E, T, L), ot = Se[Ee] = Le++), Ee += 1, z += re, Ce = 2; Ce < C; ++Ce) O = M[z], Ae = ie[Ee] = v(O, E, T, L), je = ie[Ee + De], me = ie[Ee + Be], Vt = ie[Ee + lt], (Ae !== je || Ae !== me || Ae !== Vt) && (G = M[z + U], j = M[z + Z], H = M[z + N], h(_e, Ce, O, G, j, H, Ae, je, me, Vt, E, T, L), ot = Se[Ee] = Le++, Vt !== me && d(Se[Ee + Be], ot, j, H, me, Vt, E, T, L)), Ee += 1, z += re;
+                  for (z += oe, Ee = 0, ut = De, De = ce, ce = ut, ut = Be, Be = Pe, Pe = ut, ut = lt, lt = pt, pt = ut, _e = 2; _e < x; ++_e) {
+                    if (ie[Ee++] = v(M[z], E, T, L), z += re, C > 0) for (Ce = 1, O = M[z], Ae = ie[Ee] = v(O, E, T, L), je = ie[Ee + De], me = ie[Ee + Be], Vt = ie[Ee + lt], (Ae !== je || Ae !== me || Ae !== Vt) && (G = M[z + U], j = M[z + Z], H = M[z + N], h(_e, Ce, O, G, j, H, Ae, je, me, Vt, E, T, L), ot = Se[Ee] = Le++, Vt !== je && d(Se[Ee + De], ot, H, G, Vt, je, E, T, L)), Ee += 1, z += re, Ce = 2; Ce < C; ++Ce) O = M[z], Ae = ie[Ee] = v(O, E, T, L), je = ie[Ee + De], me = ie[Ee + Be], Vt = ie[Ee + lt], (Ae !== je || Ae !== me || Ae !== Vt) && (G = M[z + U], j = M[z + Z], H = M[z + N], h(_e, Ce, O, G, j, H, Ae, je, me, Vt, E, T, L), ot = Se[Ee] = Le++, Vt !== me && d(Se[Ee + Be], ot, j, H, me, Vt, E, T, L), Vt !== je && d(Se[Ee + De], ot, H, G, Vt, je, E, T, L)), Ee += 1, z += re;
+                    _e & 1 && (Ee = 0), ut = De, De = ce, ce = ut, ut = Be, Be = Pe, Pe = ut, ut = lt, lt = pt, pt = ut, z += oe;
+                  }
+                }
+                b(Se), b(ie);
+              };
+            } };
+            function u(f, h, d, v, _, b) {
+              var p = [b, _].join(","), k = l[p];
+              return k(f, h, d, s.mallocUint32, s.freeUint32);
+            }
+            function c(f) {
+              function h(E) {
+                throw new Error("ndarray-extract-contour: " + E);
+              }
+              typeof f != "object" && h("Must specify arguments");
+              var d = f.order;
+              Array.isArray(d) || h("Must specify order");
+              var v = f.arrayArguments || 1;
+              v < 1 && h("Must have at least one array argument");
+              var _ = f.scalarArguments || 0;
+              _ < 0 && h("Scalar arg count must be > 0"), typeof f.vertex != "function" && h("Must specify vertex creation function"), typeof f.cell != "function" && h("Must specify cell creation function"), typeof f.phase != "function" && h("Must specify phase function");
+              for (var b = f.getters || [], p = new Array(v), k = 0; k < v; ++k) b.indexOf(k) >= 0 ? p[k] = true : p[k] = false;
+              return u(f.vertex, f.cell, f.phase, _, d, p);
+            }
+          }, 2642: function(i, a, o) {
+            i.exports = u;
+            var s = o(727);
+            function l(c) {
+              for (var f = 0, h = 0; h < c.length; ++h) f += c[h];
+              return f;
+            }
+            function u(c, f) {
+              for (var h = f.length, d = new Array(h + 1), v = 0; v < h; ++v) {
+                for (var _ = new Array(h + 1), b = 0; b <= h; ++b) _[b] = c[b][v];
+                d[v] = _;
+              }
+              d[h] = new Array(h + 1);
+              for (var v = 0; v <= h; ++v) d[h][v] = 1;
+              for (var p = new Array(h + 1), v = 0; v < h; ++v) p[v] = f[v];
+              p[h] = 1;
+              var k = s(d, p), E = l(k[h + 1]);
+              E === 0 && (E = 1);
+              for (var T = new Array(h + 1), v = 0; v <= h; ++v) T[v] = l(k[v]) / E;
+              return T;
+            }
+          }, 2646: function(i, a, o) {
+            var s = o(5250), l = o(8210), u = o(8545), c = o(3012), f = 6;
+            function h(M) {
+              var g = M === 3 ? b : M === 4 ? p : M === 5 ? k : E;
+              return g(l, u, s, c);
+            }
+            function d() {
+              return 0;
+            }
+            function v() {
+              return 0;
+            }
+            function _() {
+              return 0;
+            }
+            function b(M, g, P, A) {
+              function z(O, U, G) {
+                var Z = P(O[0], O[0]), j = A(Z, U[0]), N = A(Z, G[0]), H = P(U[0], U[0]), re = A(H, O[0]), oe = A(H, G[0]), _e = P(G[0], G[0]), Ce = A(_e, O[0]), Le = A(_e, U[0]), ge = M(g(Le, oe), g(re, j)), ie = g(Ce, N), Se = g(ge, ie);
+                return Se[Se.length - 1];
+              }
+              return z;
+            }
+            function p(M, g, P, A) {
+              function z(O, U, G, Z) {
+                var j = M(P(O[0], O[0]), P(O[1], O[1])), N = A(j, U[0]), H = A(j, G[0]), re = A(j, Z[0]), oe = M(P(U[0], U[0]), P(U[1], U[1])), _e = A(oe, O[0]), Ce = A(oe, G[0]), Le = A(oe, Z[0]), ge = M(P(G[0], G[0]), P(G[1], G[1])), ie = A(ge, O[0]), Se = A(ge, U[0]), Ee = A(ge, Z[0]), Ae = M(P(Z[0], Z[0]), P(Z[1], Z[1])), Be = A(Ae, O[0]), Pe = A(Ae, U[0]), me = A(Ae, G[0]), De = M(M(A(g(me, Ee), U[1]), M(A(g(Pe, Le), -G[1]), A(g(Se, Ce), Z[1]))), M(A(g(Pe, Le), O[1]), M(A(g(Be, re), -U[1]), A(g(_e, N), Z[1])))), ce = M(M(A(g(me, Ee), O[1]), M(A(g(Be, re), -G[1]), A(g(ie, H), Z[1]))), M(A(g(Se, Ce), O[1]), M(A(g(ie, H), -U[1]), A(g(_e, N), G[1])))), je = g(De, ce);
+                return je[je.length - 1];
+              }
+              return z;
+            }
+            function k(M, g, P, A) {
+              function z(O, U, G, Z, j) {
+                var N = M(P(O[0], O[0]), M(P(O[1], O[1]), P(O[2], O[2]))), H = A(N, U[0]), re = A(N, G[0]), oe = A(N, Z[0]), _e = A(N, j[0]), Ce = M(P(U[0], U[0]), M(P(U[1], U[1]), P(U[2], U[2]))), Le = A(Ce, O[0]), ge = A(Ce, G[0]), ie = A(Ce, Z[0]), Se = A(Ce, j[0]), Ee = M(P(G[0], G[0]), M(P(G[1], G[1]), P(G[2], G[2]))), Ae = A(Ee, O[0]), Be = A(Ee, U[0]), Pe = A(Ee, Z[0]), me = A(Ee, j[0]), De = M(P(Z[0], Z[0]), M(P(Z[1], Z[1]), P(Z[2], Z[2]))), ce = A(De, O[0]), je = A(De, U[0]), lt = A(De, G[0]), pt = A(De, j[0]), Vt = M(P(j[0], j[0]), M(P(j[1], j[1]), P(j[2], j[2]))), ot = A(Vt, O[0]), ut = A(Vt, U[0]), Wt = A(Vt, G[0]), Nt = A(Vt, Z[0]), $t = M(M(M(A(M(A(g(Nt, pt), G[1]), M(A(g(Wt, me), -Z[1]), A(g(lt, Pe), j[1]))), U[2]), M(A(M(A(g(Nt, pt), U[1]), M(A(g(ut, Se), -Z[1]), A(g(je, ie), j[1]))), -G[2]), A(M(A(g(Wt, me), U[1]), M(A(g(ut, Se), -G[1]), A(g(Be, ge), j[1]))), Z[2]))), M(A(M(A(g(lt, Pe), U[1]), M(A(g(je, ie), -G[1]), A(g(Be, ge), Z[1]))), -j[2]), M(A(M(A(g(Nt, pt), U[1]), M(A(g(ut, Se), -Z[1]), A(g(je, ie), j[1]))), O[2]), A(M(A(g(Nt, pt), O[1]), M(A(g(ot, _e), -Z[1]), A(g(ce, oe), j[1]))), -U[2])))), M(M(A(M(A(g(ut, Se), O[1]), M(A(g(ot, _e), -U[1]), A(g(Le, H), j[1]))), Z[2]), M(A(M(A(g(je, ie), O[1]), M(A(g(ce, oe), -U[1]), A(g(Le, H), Z[1]))), -j[2]), A(M(A(g(lt, Pe), U[1]), M(A(g(je, ie), -G[1]), A(g(Be, ge), Z[1]))), O[2]))), M(A(M(A(g(lt, Pe), O[1]), M(A(g(ce, oe), -G[1]), A(g(Ae, re), Z[1]))), -U[2]), M(A(M(A(g(je, ie), O[1]), M(A(g(ce, oe), -U[1]), A(g(Le, H), Z[1]))), G[2]), A(M(A(g(Be, ge), O[1]), M(A(g(Ae, re), -U[1]), A(g(Le, H), G[1]))), -Z[2]))))), sr = M(M(M(A(M(A(g(Nt, pt), G[1]), M(A(g(Wt, me), -Z[1]), A(g(lt, Pe), j[1]))), O[2]), A(M(A(g(Nt, pt), O[1]), M(A(g(ot, _e), -Z[1]), A(g(ce, oe), j[1]))), -G[2])), M(A(M(A(g(Wt, me), O[1]), M(A(g(ot, _e), -G[1]), A(g(Ae, re), j[1]))), Z[2]), A(M(A(g(lt, Pe), O[1]), M(A(g(ce, oe), -G[1]), A(g(Ae, re), Z[1]))), -j[2]))), M(M(A(M(A(g(Wt, me), U[1]), M(A(g(ut, Se), -G[1]), A(g(Be, ge), j[1]))), O[2]), A(M(A(g(Wt, me), O[1]), M(A(g(ot, _e), -G[1]), A(g(Ae, re), j[1]))), -U[2])), M(A(M(A(g(ut, Se), O[1]), M(A(g(ot, _e), -U[1]), A(g(Le, H), j[1]))), G[2]), A(M(A(g(Be, ge), O[1]), M(A(g(Ae, re), -U[1]), A(g(Le, H), G[1]))), -j[2])))), Tr = g($t, sr);
+                return Tr[Tr.length - 1];
+              }
+              return z;
+            }
+            function E(M, g, P, A) {
+              function z(O, U, G, Z, j, N) {
+                var H = M(M(P(O[0], O[0]), P(O[1], O[1])), M(P(O[2], O[2]), P(O[3], O[3]))), re = A(H, U[0]), oe = A(H, G[0]), _e = A(H, Z[0]), Ce = A(H, j[0]), Le = A(H, N[0]), ge = M(M(P(U[0], U[0]), P(U[1], U[1])), M(P(U[2], U[2]), P(U[3], U[3]))), ie = A(ge, O[0]), Se = A(ge, G[0]), Ee = A(ge, Z[0]), Ae = A(ge, j[0]), Be = A(ge, N[0]), Pe = M(M(P(G[0], G[0]), P(G[1], G[1])), M(P(G[2], G[2]), P(G[3], G[3]))), me = A(Pe, O[0]), De = A(Pe, U[0]), ce = A(Pe, Z[0]), je = A(Pe, j[0]), lt = A(Pe, N[0]), pt = M(M(P(Z[0], Z[0]), P(Z[1], Z[1])), M(P(Z[2], Z[2]), P(Z[3], Z[3]))), Vt = A(pt, O[0]), ot = A(pt, U[0]), ut = A(pt, G[0]), Wt = A(pt, j[0]), Nt = A(pt, N[0]), $t = M(M(P(j[0], j[0]), P(j[1], j[1])), M(P(j[2], j[2]), P(j[3], j[3]))), sr = A($t, O[0]), Tr = A($t, U[0]), fr = A($t, G[0]), $e = A($t, Z[0]), St = A($t, N[0]), Qt = M(M(P(N[0], N[0]), P(N[1], N[1])), M(P(N[2], N[2]), P(N[3], N[3]))), Gt = A(Qt, O[0]), _t = A(Qt, U[0]), It = A(Qt, G[0]), mt = A(Qt, Z[0]), er = A(Qt, j[0]), lr = M(M(M(A(M(M(A(M(A(g(er, St), Z[1]), M(A(g(mt, Nt), -j[1]), A(g($e, Wt), N[1]))), G[2]), A(M(A(g(er, St), G[1]), M(A(g(It, lt), -j[1]), A(g(fr, je), N[1]))), -Z[2])), M(A(M(A(g(mt, Nt), G[1]), M(A(g(It, lt), -Z[1]), A(g(ut, ce), N[1]))), j[2]), A(M(A(g($e, Wt), G[1]), M(A(g(fr, je), -Z[1]), A(g(ut, ce), j[1]))), -N[2]))), U[3]), M(A(M(M(A(M(A(g(er, St), Z[1]), M(A(g(mt, Nt), -j[1]), A(g($e, Wt), N[1]))), U[2]), A(M(A(g(er, St), U[1]), M(A(g(_t, Be), -j[1]), A(g(Tr, Ae), N[1]))), -Z[2])), M(A(M(A(g(mt, Nt), U[1]), M(A(g(_t, Be), -Z[1]), A(g(ot, Ee), N[1]))), j[2]), A(M(A(g($e, Wt), U[1]), M(A(g(Tr, Ae), -Z[1]), A(g(ot, Ee), j[1]))), -N[2]))), -G[3]), A(M(M(A(M(A(g(er, St), G[1]), M(A(g(It, lt), -j[1]), A(g(fr, je), N[1]))), U[2]), A(M(A(g(er, St), U[1]), M(A(g(_t, Be), -j[1]), A(g(Tr, Ae), N[1]))), -G[2])), M(A(M(A(g(It, lt), U[1]), M(A(g(_t, Be), -G[1]), A(g(De, Se), N[1]))), j[2]), A(M(A(g(fr, je), U[1]), M(A(g(Tr, Ae), -G[1]), A(g(De, Se), j[1]))), -N[2]))), Z[3]))), M(M(A(M(M(A(M(A(g(mt, Nt), G[1]), M(A(g(It, lt), -Z[1]), A(g(ut, ce), N[1]))), U[2]), A(M(A(g(mt, Nt), U[1]), M(A(g(_t, Be), -Z[1]), A(g(ot, Ee), N[1]))), -G[2])), M(A(M(A(g(It, lt), U[1]), M(A(g(_t, Be), -G[1]), A(g(De, Se), N[1]))), Z[2]), A(M(A(g(ut, ce), U[1]), M(A(g(ot, Ee), -G[1]), A(g(De, Se), Z[1]))), -N[2]))), -j[3]), A(M(M(A(M(A(g($e, Wt), G[1]), M(A(g(fr, je), -Z[1]), A(g(ut, ce), j[1]))), U[2]), A(M(A(g($e, Wt), U[1]), M(A(g(Tr, Ae), -Z[1]), A(g(ot, Ee), j[1]))), -G[2])), M(A(M(A(g(fr, je), U[1]), M(A(g(Tr, Ae), -G[1]), A(g(De, Se), j[1]))), Z[2]), A(M(A(g(ut, ce), U[1]), M(A(g(ot, Ee), -G[1]), A(g(De, Se), Z[1]))), -j[2]))), N[3])), M(A(M(M(A(M(A(g(er, St), Z[1]), M(A(g(mt, Nt), -j[1]), A(g($e, Wt), N[1]))), U[2]), A(M(A(g(er, St), U[1]), M(A(g(_t, Be), -j[1]), A(g(Tr, Ae), N[1]))), -Z[2])), M(A(M(A(g(mt, Nt), U[1]), M(A(g(_t, Be), -Z[1]), A(g(ot, Ee), N[1]))), j[2]), A(M(A(g($e, Wt), U[1]), M(A(g(Tr, Ae), -Z[1]), A(g(ot, Ee), j[1]))), -N[2]))), O[3]), A(M(M(A(M(A(g(er, St), Z[1]), M(A(g(mt, Nt), -j[1]), A(g($e, Wt), N[1]))), O[2]), A(M(A(g(er, St), O[1]), M(A(g(Gt, Le), -j[1]), A(g(sr, Ce), N[1]))), -Z[2])), M(A(M(A(g(mt, Nt), O[1]), M(A(g(Gt, Le), -Z[1]), A(g(Vt, _e), N[1]))), j[2]), A(M(A(g($e, Wt), O[1]), M(A(g(sr, Ce), -Z[1]), A(g(Vt, _e), j[1]))), -N[2]))), -U[3])))), M(M(M(A(M(M(A(M(A(g(er, St), U[1]), M(A(g(_t, Be), -j[1]), A(g(Tr, Ae), N[1]))), O[2]), A(M(A(g(er, St), O[1]), M(A(g(Gt, Le), -j[1]), A(g(sr, Ce), N[1]))), -U[2])), M(A(M(A(g(_t, Be), O[1]), M(A(g(Gt, Le), -U[1]), A(g(ie, re), N[1]))), j[2]), A(M(A(g(Tr, Ae), O[1]), M(A(g(sr, Ce), -U[1]), A(g(ie, re), j[1]))), -N[2]))), Z[3]), A(M(M(A(M(A(g(mt, Nt), U[1]), M(A(g(_t, Be), -Z[1]), A(g(ot, Ee), N[1]))), O[2]), A(M(A(g(mt, Nt), O[1]), M(A(g(Gt, Le), -Z[1]), A(g(Vt, _e), N[1]))), -U[2])), M(A(M(A(g(_t, Be), O[1]), M(A(g(Gt, Le), -U[1]), A(g(ie, re), N[1]))), Z[2]), A(M(A(g(ot, Ee), O[1]), M(A(g(Vt, _e), -U[1]), A(g(ie, re), Z[1]))), -N[2]))), -j[3])), M(A(M(M(A(M(A(g($e, Wt), U[1]), M(A(g(Tr, Ae), -Z[1]), A(g(ot, Ee), j[1]))), O[2]), A(M(A(g($e, Wt), O[1]), M(A(g(sr, Ce), -Z[1]), A(g(Vt, _e), j[1]))), -U[2])), M(A(M(A(g(Tr, Ae), O[1]), M(A(g(sr, Ce), -U[1]), A(g(ie, re), j[1]))), Z[2]), A(M(A(g(ot, Ee), O[1]), M(A(g(Vt, _e), -U[1]), A(g(ie, re), Z[1]))), -j[2]))), N[3]), A(M(M(A(M(A(g(mt, Nt), G[1]), M(A(g(It, lt), -Z[1]), A(g(ut, ce), N[1]))), U[2]), A(M(A(g(mt, Nt), U[1]), M(A(g(_t, Be), -Z[1]), A(g(ot, Ee), N[1]))), -G[2])), M(A(M(A(g(It, lt), U[1]), M(A(g(_t, Be), -G[1]), A(g(De, Se), N[1]))), Z[2]), A(M(A(g(ut, ce), U[1]), M(A(g(ot, Ee), -G[1]), A(g(De, Se), Z[1]))), -N[2]))), O[3]))), M(M(A(M(M(A(M(A(g(mt, Nt), G[1]), M(A(g(It, lt), -Z[1]), A(g(ut, ce), N[1]))), O[2]), A(M(A(g(mt, Nt), O[1]), M(A(g(Gt, Le), -Z[1]), A(g(Vt, _e), N[1]))), -G[2])), M(A(M(A(g(It, lt), O[1]), M(A(g(Gt, Le), -G[1]), A(g(me, oe), N[1]))), Z[2]), A(M(A(g(ut, ce), O[1]), M(A(g(Vt, _e), -G[1]), A(g(me, oe), Z[1]))), -N[2]))), -U[3]), A(M(M(A(M(A(g(mt, Nt), U[1]), M(A(g(_t, Be), -Z[1]), A(g(ot, Ee), N[1]))), O[2]), A(M(A(g(mt, Nt), O[1]), M(A(g(Gt, Le), -Z[1]), A(g(Vt, _e), N[1]))), -U[2])), M(A(M(A(g(_t, Be), O[1]), M(A(g(Gt, Le), -U[1]), A(g(ie, re), N[1]))), Z[2]), A(M(A(g(ot, Ee), O[1]), M(A(g(Vt, _e), -U[1]), A(g(ie, re), Z[1]))), -N[2]))), G[3])), M(A(M(M(A(M(A(g(It, lt), U[1]), M(A(g(_t, Be), -G[1]), A(g(De, Se), N[1]))), O[2]), A(M(A(g(It, lt), O[1]), M(A(g(Gt, Le), -G[1]), A(g(me, oe), N[1]))), -U[2])), M(A(M(A(g(_t, Be), O[1]), M(A(g(Gt, Le), -U[1]), A(g(ie, re), N[1]))), G[2]), A(M(A(g(De, Se), O[1]), M(A(g(me, oe), -U[1]), A(g(ie, re), G[1]))), -N[2]))), -Z[3]), A(M(M(A(M(A(g(ut, ce), U[1]), M(A(g(ot, Ee), -G[1]), A(g(De, Se), Z[1]))), O[2]), A(M(A(g(ut, ce), O[1]), M(A(g(Vt, _e), -G[1]), A(g(me, oe), Z[1]))), -U[2])), M(A(M(A(g(ot, Ee), O[1]), M(A(g(Vt, _e), -U[1]), A(g(ie, re), Z[1]))), G[2]), A(M(A(g(De, Se), O[1]), M(A(g(me, oe), -U[1]), A(g(ie, re), G[1]))), -Z[2]))), N[3]))))), wr = M(M(M(A(M(M(A(M(A(g(er, St), Z[1]), M(A(g(mt, Nt), -j[1]), A(g($e, Wt), N[1]))), G[2]), A(M(A(g(er, St), G[1]), M(A(g(It, lt), -j[1]), A(g(fr, je), N[1]))), -Z[2])), M(A(M(A(g(mt, Nt), G[1]), M(A(g(It, lt), -Z[1]), A(g(ut, ce), N[1]))), j[2]), A(M(A(g($e, Wt), G[1]), M(A(g(fr, je), -Z[1]), A(g(ut, ce), j[1]))), -N[2]))), O[3]), M(A(M(M(A(M(A(g(er, St), Z[1]), M(A(g(mt, Nt), -j[1]), A(g($e, Wt), N[1]))), O[2]), A(M(A(g(er, St), O[1]), M(A(g(Gt, Le), -j[1]), A(g(sr, Ce), N[1]))), -Z[2])), M(A(M(A(g(mt, Nt), O[1]), M(A(g(Gt, Le), -Z[1]), A(g(Vt, _e), N[1]))), j[2]), A(M(A(g($e, Wt), O[1]), M(A(g(sr, Ce), -Z[1]), A(g(Vt, _e), j[1]))), -N[2]))), -G[3]), A(M(M(A(M(A(g(er, St), G[1]), M(A(g(It, lt), -j[1]), A(g(fr, je), N[1]))), O[2]), A(M(A(g(er, St), O[1]), M(A(g(Gt, Le), -j[1]), A(g(sr, Ce), N[1]))), -G[2])), M(A(M(A(g(It, lt), O[1]), M(A(g(Gt, Le), -G[1]), A(g(me, oe), N[1]))), j[2]), A(M(A(g(fr, je), O[1]), M(A(g(sr, Ce), -G[1]), A(g(me, oe), j[1]))), -N[2]))), Z[3]))), M(M(A(M(M(A(M(A(g(mt, Nt), G[1]), M(A(g(It, lt), -Z[1]), A(g(ut, ce), N[1]))), O[2]), A(M(A(g(mt, Nt), O[1]), M(A(g(Gt, Le), -Z[1]), A(g(Vt, _e), N[1]))), -G[2])), M(A(M(A(g(It, lt), O[1]), M(A(g(Gt, Le), -G[1]), A(g(me, oe), N[1]))), Z[2]), A(M(A(g(ut, ce), O[1]), M(A(g(Vt, _e), -G[1]), A(g(me, oe), Z[1]))), -N[2]))), -j[3]), A(M(M(A(M(A(g($e, Wt), G[1]), M(A(g(fr, je), -Z[1]), A(g(ut, ce), j[1]))), O[2]), A(M(A(g($e, Wt), O[1]), M(A(g(sr, Ce), -Z[1]), A(g(Vt, _e), j[1]))), -G[2])), M(A(M(A(g(fr, je), O[1]), M(A(g(sr, Ce), -G[1]), A(g(me, oe), j[1]))), Z[2]), A(M(A(g(ut, ce), O[1]), M(A(g(Vt, _e), -G[1]), A(g(me, oe), Z[1]))), -j[2]))), N[3])), M(A(M(M(A(M(A(g(er, St), G[1]), M(A(g(It, lt), -j[1]), A(g(fr, je), N[1]))), U[2]), A(M(A(g(er, St), U[1]), M(A(g(_t, Be), -j[1]), A(g(Tr, Ae), N[1]))), -G[2])), M(A(M(A(g(It, lt), U[1]), M(A(g(_t, Be), -G[1]), A(g(De, Se), N[1]))), j[2]), A(M(A(g(fr, je), U[1]), M(A(g(Tr, Ae), -G[1]), A(g(De, Se), j[1]))), -N[2]))), O[3]), A(M(M(A(M(A(g(er, St), G[1]), M(A(g(It, lt), -j[1]), A(g(fr, je), N[1]))), O[2]), A(M(A(g(er, St), O[1]), M(A(g(Gt, Le), -j[1]), A(g(sr, Ce), N[1]))), -G[2])), M(A(M(A(g(It, lt), O[1]), M(A(g(Gt, Le), -G[1]), A(g(me, oe), N[1]))), j[2]), A(M(A(g(fr, je), O[1]), M(A(g(sr, Ce), -G[1]), A(g(me, oe), j[1]))), -N[2]))), -U[3])))), M(M(M(A(M(M(A(M(A(g(er, St), U[1]), M(A(g(_t, Be), -j[1]), A(g(Tr, Ae), N[1]))), O[2]), A(M(A(g(er, St), O[1]), M(A(g(Gt, Le), -j[1]), A(g(sr, Ce), N[1]))), -U[2])), M(A(M(A(g(_t, Be), O[1]), M(A(g(Gt, Le), -U[1]), A(g(ie, re), N[1]))), j[2]), A(M(A(g(Tr, Ae), O[1]), M(A(g(sr, Ce), -U[1]), A(g(ie, re), j[1]))), -N[2]))), G[3]), A(M(M(A(M(A(g(It, lt), U[1]), M(A(g(_t, Be), -G[1]), A(g(De, Se), N[1]))), O[2]), A(M(A(g(It, lt), O[1]), M(A(g(Gt, Le), -G[1]), A(g(me, oe), N[1]))), -U[2])), M(A(M(A(g(_t, Be), O[1]), M(A(g(Gt, Le), -U[1]), A(g(ie, re), N[1]))), G[2]), A(M(A(g(De, Se), O[1]), M(A(g(me, oe), -U[1]), A(g(ie, re), G[1]))), -N[2]))), -j[3])), M(A(M(M(A(M(A(g(fr, je), U[1]), M(A(g(Tr, Ae), -G[1]), A(g(De, Se), j[1]))), O[2]), A(M(A(g(fr, je), O[1]), M(A(g(sr, Ce), -G[1]), A(g(me, oe), j[1]))), -U[2])), M(A(M(A(g(Tr, Ae), O[1]), M(A(g(sr, Ce), -U[1]), A(g(ie, re), j[1]))), G[2]), A(M(A(g(De, Se), O[1]), M(A(g(me, oe), -U[1]), A(g(ie, re), G[1]))), -j[2]))), N[3]), A(M(M(A(M(A(g($e, Wt), G[1]), M(A(g(fr, je), -Z[1]), A(g(ut, ce), j[1]))), U[2]), A(M(A(g($e, Wt), U[1]), M(A(g(Tr, Ae), -Z[1]), A(g(ot, Ee), j[1]))), -G[2])), M(A(M(A(g(fr, je), U[1]), M(A(g(Tr, Ae), -G[1]), A(g(De, Se), j[1]))), Z[2]), A(M(A(g(ut, ce), U[1]), M(A(g(ot, Ee), -G[1]), A(g(De, Se), Z[1]))), -j[2]))), O[3]))), M(M(A(M(M(A(M(A(g($e, Wt), G[1]), M(A(g(fr, je), -Z[1]), A(g(ut, ce), j[1]))), O[2]), A(M(A(g($e, Wt), O[1]), M(A(g(sr, Ce), -Z[1]), A(g(Vt, _e), j[1]))), -G[2])), M(A(M(A(g(fr, je), O[1]), M(A(g(sr, Ce), -G[1]), A(g(me, oe), j[1]))), Z[2]), A(M(A(g(ut, ce), O[1]), M(A(g(Vt, _e), -G[1]), A(g(me, oe), Z[1]))), -j[2]))), -U[3]), A(M(M(A(M(A(g($e, Wt), U[1]), M(A(g(Tr, Ae), -Z[1]), A(g(ot, Ee), j[1]))), O[2]), A(M(A(g($e, Wt), O[1]), M(A(g(sr, Ce), -Z[1]), A(g(Vt, _e), j[1]))), -U[2])), M(A(M(A(g(Tr, Ae), O[1]), M(A(g(sr, Ce), -U[1]), A(g(ie, re), j[1]))), Z[2]), A(M(A(g(ot, Ee), O[1]), M(A(g(Vt, _e), -U[1]), A(g(ie, re), Z[1]))), -j[2]))), G[3])), M(A(M(M(A(M(A(g(fr, je), U[1]), M(A(g(Tr, Ae), -G[1]), A(g(De, Se), j[1]))), O[2]), A(M(A(g(fr, je), O[1]), M(A(g(sr, Ce), -G[1]), A(g(me, oe), j[1]))), -U[2])), M(A(M(A(g(Tr, Ae), O[1]), M(A(g(sr, Ce), -U[1]), A(g(ie, re), j[1]))), G[2]), A(M(A(g(De, Se), O[1]), M(A(g(me, oe), -U[1]), A(g(ie, re), G[1]))), -j[2]))), -Z[3]), A(M(M(A(M(A(g(ut, ce), U[1]), M(A(g(ot, Ee), -G[1]), A(g(De, Se), Z[1]))), O[2]), A(M(A(g(ut, ce), O[1]), M(A(g(Vt, _e), -G[1]), A(g(me, oe), Z[1]))), -U[2])), M(A(M(A(g(ot, Ee), O[1]), M(A(g(Vt, _e), -U[1]), A(g(ie, re), Z[1]))), G[2]), A(M(A(g(De, Se), O[1]), M(A(g(me, oe), -U[1]), A(g(ie, re), G[1]))), -Z[2]))), j[3]))))), Lr = g(lr, wr);
+                return Lr[Lr.length - 1];
+              }
+              return z;
+            }
+            var T = [d, v, _];
+            function L(M) {
+              var g = T[M.length];
+              return g || (g = T[M.length] = h(M.length)), g.apply(void 0, M);
+            }
+            function x(M, g, P, A, z, O, U, G) {
+              function Z(j, N, H, re, oe, _e) {
+                switch (arguments.length) {
+                  case 0:
+                  case 1:
+                    return 0;
+                  case 2:
+                    return A(j, N);
+                  case 3:
+                    return z(j, N, H);
+                  case 4:
+                    return O(j, N, H, re);
+                  case 5:
+                    return U(j, N, H, re, oe);
+                  case 6:
+                    return G(j, N, H, re, oe, _e);
+                }
+                for (var Ce = new Array(arguments.length), Le = 0; Le < arguments.length; ++Le) Ce[Le] = arguments[Le];
+                return M(Ce);
+              }
+              return Z;
+            }
+            function C() {
+              for (; T.length <= f; ) T.push(h(T.length));
+              i.exports = x.apply(void 0, [L].concat(T));
+              for (var M = 0; M <= f; ++M) i.exports[M] = T[M];
+            }
+            C();
+          }, 2651: function(i, a, o) {
+            var s = o(6859), l = o(2361);
+            i.exports = u;
+            function u(c) {
+              var f = l.exponent(c);
+              return f < 52 ? new s(c) : new s(c * Math.pow(2, 52 - f)).ushln(f - 52);
+            }
+          }, 2652: function(i, a, o) {
+            var s = o(4335), l = o(6864), u = o(1903), c = o(9921), f = o(7608), h = o(5665), d = { length: o(1387), normalize: o(3536), dot: o(244), cross: o(5911) }, v = l(), _ = l(), b = [0, 0, 0, 0], p = [[0, 0, 0], [0, 0, 0], [0, 0, 0]], k = [0, 0, 0];
+            i.exports = function(C, M, g, P, A, z) {
+              if (M || (M = [0, 0, 0]), g || (g = [0, 0, 0]), P || (P = [0, 0, 0]), A || (A = [0, 0, 0, 1]), z || (z = [0, 0, 0, 1]), !s(v, C) || (u(_, v), _[3] = 0, _[7] = 0, _[11] = 0, _[15] = 1, Math.abs(c(_) < 1e-8))) return false;
+              var O = v[3], U = v[7], G = v[11], Z = v[12], j = v[13], N = v[14], H = v[15];
+              if (O !== 0 || U !== 0 || G !== 0) {
+                b[0] = O, b[1] = U, b[2] = G, b[3] = H;
+                var re = f(_, _);
+                if (!re) return false;
+                h(_, _), E(A, b, _);
+              } else A[0] = A[1] = A[2] = 0, A[3] = 1;
+              if (M[0] = Z, M[1] = j, M[2] = N, T(p, v), g[0] = d.length(p[0]), d.normalize(p[0], p[0]), P[0] = d.dot(p[0], p[1]), L(p[1], p[1], p[0], 1, -P[0]), g[1] = d.length(p[1]), d.normalize(p[1], p[1]), P[0] /= g[1], P[1] = d.dot(p[0], p[2]), L(p[2], p[2], p[0], 1, -P[1]), P[2] = d.dot(p[1], p[2]), L(p[2], p[2], p[1], 1, -P[2]), g[2] = d.length(p[2]), d.normalize(p[2], p[2]), P[1] /= g[2], P[2] /= g[2], d.cross(k, p[1], p[2]), d.dot(p[0], k) < 0) for (var oe = 0; oe < 3; oe++) g[oe] *= -1, p[oe][0] *= -1, p[oe][1] *= -1, p[oe][2] *= -1;
+              return z[0] = 0.5 * Math.sqrt(Math.max(1 + p[0][0] - p[1][1] - p[2][2], 0)), z[1] = 0.5 * Math.sqrt(Math.max(1 - p[0][0] + p[1][1] - p[2][2], 0)), z[2] = 0.5 * Math.sqrt(Math.max(1 - p[0][0] - p[1][1] + p[2][2], 0)), z[3] = 0.5 * Math.sqrt(Math.max(1 + p[0][0] + p[1][1] + p[2][2], 0)), p[2][1] > p[1][2] && (z[0] = -z[0]), p[0][2] > p[2][0] && (z[1] = -z[1]), p[1][0] > p[0][1] && (z[2] = -z[2]), true;
+            };
+            function E(x, C, M) {
+              var g = C[0], P = C[1], A = C[2], z = C[3];
+              return x[0] = M[0] * g + M[4] * P + M[8] * A + M[12] * z, x[1] = M[1] * g + M[5] * P + M[9] * A + M[13] * z, x[2] = M[2] * g + M[6] * P + M[10] * A + M[14] * z, x[3] = M[3] * g + M[7] * P + M[11] * A + M[15] * z, x;
+            }
+            function T(x, C) {
+              x[0][0] = C[0], x[0][1] = C[1], x[0][2] = C[2], x[1][0] = C[4], x[1][1] = C[5], x[1][2] = C[6], x[2][0] = C[8], x[2][1] = C[9], x[2][2] = C[10];
+            }
+            function L(x, C, M, g, P) {
+              x[0] = C[0] * g + M[0] * P, x[1] = C[1] * g + M[1] * P, x[2] = C[2] * g + M[2] * P;
+            }
+          }, 2653: function(i, a, o) {
+            var s = o(3865);
+            i.exports = l;
+            function l(u, c) {
+              for (var f = u.length, h = new Array(f), d = 0; d < f; ++d) h[d] = s(u[d], c[d]);
+              return h;
+            }
+          }, 2681: function(i) {
+            i.exports = a;
+            function a(o, s) {
+              return o[0] = Math.floor(s[0]), o[1] = Math.floor(s[1]), o[2] = Math.floor(s[2]), o;
+            }
+          }, 2690: function(i, a, o) {
+            i.exports = f;
+            var s = o(8954), l = o(3952);
+            function u(h, d) {
+              for (var v = h.length, _ = new Array(v), b = 0; b < d.length; ++b) _[b] = h[d[b]];
+              for (var p = d.length, b = 0; b < v; ++b) d.indexOf(b) < 0 && (_[p++] = h[b]);
+              return _;
+            }
+            function c(h, d) {
+              for (var v = h.length, _ = d.length, b = 0; b < v; ++b) for (var p = h[b], k = 0; k < p.length; ++k) {
+                var E = p[k];
+                if (E < _) p[k] = d[E];
+                else {
+                  E = E - _;
+                  for (var T = 0; T < _; ++T) E >= d[T] && (E += 1);
+                  p[k] = E;
+                }
+              }
+              return h;
+            }
+            function f(h, d) {
+              try {
+                return s(h, true);
+              } catch (p) {
+                var v = l(h);
+                if (v.length <= d) return [];
+                var _ = u(h, v), b = s(_, true);
+                return c(b, v);
+              }
+            }
+          }, 2762: function(i, a, o) {
+            var s = o(1888), l = o(5298), u = o(9618), c = ["uint8", "uint8_clamped", "uint16", "uint32", "int8", "int16", "int32", "float32"];
+            function f(p, k, E, T, L) {
+              this.gl = p, this.type = k, this.handle = E, this.length = T, this.usage = L;
+            }
+            var h = f.prototype;
+            h.bind = function() {
+              this.gl.bindBuffer(this.type, this.handle);
+            }, h.unbind = function() {
+              this.gl.bindBuffer(this.type, null);
+            }, h.dispose = function() {
+              this.gl.deleteBuffer(this.handle);
+            };
+            function d(p, k, E, T, L, x) {
+              var C = L.length * L.BYTES_PER_ELEMENT;
+              if (x < 0) return p.bufferData(k, L, T), C;
+              if (C + x > E) throw new Error("gl-buffer: If resizing buffer, must not specify offset");
+              return p.bufferSubData(k, x, L), E;
+            }
+            function v(p, k) {
+              for (var E = s.malloc(p.length, k), T = p.length, L = 0; L < T; ++L) E[L] = p[L];
+              return E;
+            }
+            function _(p, k) {
+              for (var E = 1, T = k.length - 1; T >= 0; --T) {
+                if (k[T] !== E) return false;
+                E *= p[T];
+              }
+              return true;
+            }
+            h.update = function(p, k) {
+              if (typeof k != "number" && (k = -1), this.bind(), typeof p == "object" && typeof p.shape != "undefined") {
+                var E = p.dtype;
+                if (c.indexOf(E) < 0 && (E = "float32"), this.type === this.gl.ELEMENT_ARRAY_BUFFER) {
+                  var T = gl.getExtension("OES_element_index_uint");
+                  T && E !== "uint16" ? E = "uint32" : E = "uint16";
+                }
+                if (E === p.dtype && _(p.shape, p.stride)) p.offset === 0 && p.data.length === p.shape[0] ? this.length = d(this.gl, this.type, this.length, this.usage, p.data, k) : this.length = d(this.gl, this.type, this.length, this.usage, p.data.subarray(p.offset, p.shape[0]), k);
+                else {
+                  var L = s.malloc(p.size, E), x = u(L, p.shape);
+                  l.assign(x, p), k < 0 ? this.length = d(this.gl, this.type, this.length, this.usage, L, k) : this.length = d(this.gl, this.type, this.length, this.usage, L.subarray(0, p.size), k), s.free(L);
+                }
+              } else if (Array.isArray(p)) {
+                var C;
+                this.type === this.gl.ELEMENT_ARRAY_BUFFER ? C = v(p, "uint16") : C = v(p, "float32"), k < 0 ? this.length = d(this.gl, this.type, this.length, this.usage, C, k) : this.length = d(this.gl, this.type, this.length, this.usage, C.subarray(0, p.length), k), s.free(C);
+              } else if (typeof p == "object" && typeof p.length == "number") this.length = d(this.gl, this.type, this.length, this.usage, p, k);
+              else if (typeof p == "number" || p === void 0) {
+                if (k >= 0) throw new Error("gl-buffer: Cannot specify offset when resizing buffer");
+                p = p | 0, p <= 0 && (p = 1), this.gl.bufferData(this.type, p | 0, this.usage), this.length = p;
+              } else throw new Error("gl-buffer: Invalid data type");
+            };
+            function b(p, k, E, T) {
+              if (E = E || p.ARRAY_BUFFER, T = T || p.DYNAMIC_DRAW, E !== p.ARRAY_BUFFER && E !== p.ELEMENT_ARRAY_BUFFER) throw new Error("gl-buffer: Invalid type for webgl buffer, must be either gl.ARRAY_BUFFER or gl.ELEMENT_ARRAY_BUFFER");
+              if (T !== p.DYNAMIC_DRAW && T !== p.STATIC_DRAW && T !== p.STREAM_DRAW) throw new Error("gl-buffer: Invalid usage for buffer, must be either gl.DYNAMIC_DRAW, gl.STATIC_DRAW or gl.STREAM_DRAW");
+              var L = p.createBuffer(), x = new f(p, E, L, 0, T);
+              return x.update(k), x;
+            }
+            i.exports = b;
+          }, 2825: function(i) {
+            i.exports = a;
+            function a(o, s, l) {
+              var u = new Float32Array(3);
+              return u[0] = o, u[1] = s, u[2] = l, u;
+            }
+          }, 2931: function(i, a, o) {
+            i.exports = { EPSILON: o(2613), create: o(1091), clone: o(3126), angle: o(8192), fromValues: o(2825), copy: o(3990), set: o(1463), equals: o(9922), exactEquals: o(9265), add: o(5632), subtract: o(6843), sub: o(2229), multiply: o(5847), mul: o(4505), divide: o(6690), div: o(4008), min: o(8107), max: o(7417), floor: o(2681), ceil: o(9226), round: o(2447), scale: o(6621), scaleAndAdd: o(8489), distance: o(7056), dist: o(5455), squaredDistance: o(2953), sqrDist: o(6141), length: o(1387), len: o(868), squaredLength: o(3066), sqrLen: o(5486), negate: o(5093), inverse: o(811), normalize: o(3536), dot: o(244), cross: o(5911), lerp: o(6658), random: o(7636), transformMat4: o(5673), transformMat3: o(492), transformQuat: o(264), rotateX: o(6894), rotateY: o(109), rotateZ: o(8692), forEach: o(5137) };
+          }, 2933: function(i) {
+            i.exports = a;
+            function a(o, s) {
+              return o[0] = s[0], o[1] = s[1], o[2] = s[2], o[3] = s[3], o;
+            }
+          }, 2953: function(i) {
+            i.exports = a;
+            function a(o, s) {
+              var l = s[0] - o[0], u = s[1] - o[1], c = s[2] - o[2];
+              return l * l + u * u + c * c;
+            }
+          }, 2962: function(i, a, o) {
+            var s = o(5250), l = o(8210), u = o(3012), c = o(7004), f = 6;
+            function h(T, L, x, C) {
+              return function(g) {
+                return C(T(x(g[0][0], g[1][1]), x(-g[0][1], g[1][0])));
+              };
+            }
+            function d(T, L, x, C) {
+              return function(g) {
+                return C(T(L(T(x(g[1][1], g[2][2]), x(-g[1][2], g[2][1])), g[0][0]), T(L(T(x(g[1][0], g[2][2]), x(-g[1][2], g[2][0])), -g[0][1]), L(T(x(g[1][0], g[2][1]), x(-g[1][1], g[2][0])), g[0][2]))));
+              };
+            }
+            function v(T, L, x, C) {
+              return function(g) {
+                return C(T(T(L(T(L(T(x(g[2][2], g[3][3]), x(-g[2][3], g[3][2])), g[1][1]), T(L(T(x(g[2][1], g[3][3]), x(-g[2][3], g[3][1])), -g[1][2]), L(T(x(g[2][1], g[3][2]), x(-g[2][2], g[3][1])), g[1][3]))), g[0][0]), L(T(L(T(x(g[2][2], g[3][3]), x(-g[2][3], g[3][2])), g[1][0]), T(L(T(x(g[2][0], g[3][3]), x(-g[2][3], g[3][0])), -g[1][2]), L(T(x(g[2][0], g[3][2]), x(-g[2][2], g[3][0])), g[1][3]))), -g[0][1])), T(L(T(L(T(x(g[2][1], g[3][3]), x(-g[2][3], g[3][1])), g[1][0]), T(L(T(x(g[2][0], g[3][3]), x(-g[2][3], g[3][0])), -g[1][1]), L(T(x(g[2][0], g[3][1]), x(-g[2][1], g[3][0])), g[1][3]))), g[0][2]), L(T(L(T(x(g[2][1], g[3][2]), x(-g[2][2], g[3][1])), g[1][0]), T(L(T(x(g[2][0], g[3][2]), x(-g[2][2], g[3][0])), -g[1][1]), L(T(x(g[2][0], g[3][1]), x(-g[2][1], g[3][0])), g[1][2]))), -g[0][3]))));
+              };
+            }
+            function _(T, L, x, C) {
+              return function(g) {
+                return C(T(T(L(T(T(L(T(L(T(x(g[3][3], g[4][4]), x(-g[3][4], g[4][3])), g[2][2]), T(L(T(x(g[3][2], g[4][4]), x(-g[3][4], g[4][2])), -g[2][3]), L(T(x(g[3][2], g[4][3]), x(-g[3][3], g[4][2])), g[2][4]))), g[1][1]), L(T(L(T(x(g[3][3], g[4][4]), x(-g[3][4], g[4][3])), g[2][1]), T(L(T(x(g[3][1], g[4][4]), x(-g[3][4], g[4][1])), -g[2][3]), L(T(x(g[3][1], g[4][3]), x(-g[3][3], g[4][1])), g[2][4]))), -g[1][2])), T(L(T(L(T(x(g[3][2], g[4][4]), x(-g[3][4], g[4][2])), g[2][1]), T(L(T(x(g[3][1], g[4][4]), x(-g[3][4], g[4][1])), -g[2][2]), L(T(x(g[3][1], g[4][2]), x(-g[3][2], g[4][1])), g[2][4]))), g[1][3]), L(T(L(T(x(g[3][2], g[4][3]), x(-g[3][3], g[4][2])), g[2][1]), T(L(T(x(g[3][1], g[4][3]), x(-g[3][3], g[4][1])), -g[2][2]), L(T(x(g[3][1], g[4][2]), x(-g[3][2], g[4][1])), g[2][3]))), -g[1][4]))), g[0][0]), L(T(T(L(T(L(T(x(g[3][3], g[4][4]), x(-g[3][4], g[4][3])), g[2][2]), T(L(T(x(g[3][2], g[4][4]), x(-g[3][4], g[4][2])), -g[2][3]), L(T(x(g[3][2], g[4][3]), x(-g[3][3], g[4][2])), g[2][4]))), g[1][0]), L(T(L(T(x(g[3][3], g[4][4]), x(-g[3][4], g[4][3])), g[2][0]), T(L(T(x(g[3][0], g[4][4]), x(-g[3][4], g[4][0])), -g[2][3]), L(T(x(g[3][0], g[4][3]), x(-g[3][3], g[4][0])), g[2][4]))), -g[1][2])), T(L(T(L(T(x(g[3][2], g[4][4]), x(-g[3][4], g[4][2])), g[2][0]), T(L(T(x(g[3][0], g[4][4]), x(-g[3][4], g[4][0])), -g[2][2]), L(T(x(g[3][0], g[4][2]), x(-g[3][2], g[4][0])), g[2][4]))), g[1][3]), L(T(L(T(x(g[3][2], g[4][3]), x(-g[3][3], g[4][2])), g[2][0]), T(L(T(x(g[3][0], g[4][3]), x(-g[3][3], g[4][0])), -g[2][2]), L(T(x(g[3][0], g[4][2]), x(-g[3][2], g[4][0])), g[2][3]))), -g[1][4]))), -g[0][1])), T(L(T(T(L(T(L(T(x(g[3][3], g[4][4]), x(-g[3][4], g[4][3])), g[2][1]), T(L(T(x(g[3][1], g[4][4]), x(-g[3][4], g[4][1])), -g[2][3]), L(T(x(g[3][1], g[4][3]), x(-g[3][3], g[4][1])), g[2][4]))), g[1][0]), L(T(L(T(x(g[3][3], g[4][4]), x(-g[3][4], g[4][3])), g[2][0]), T(L(T(x(g[3][0], g[4][4]), x(-g[3][4], g[4][0])), -g[2][3]), L(T(x(g[3][0], g[4][3]), x(-g[3][3], g[4][0])), g[2][4]))), -g[1][1])), T(L(T(L(T(x(g[3][1], g[4][4]), x(-g[3][4], g[4][1])), g[2][0]), T(L(T(x(g[3][0], g[4][4]), x(-g[3][4], g[4][0])), -g[2][1]), L(T(x(g[3][0], g[4][1]), x(-g[3][1], g[4][0])), g[2][4]))), g[1][3]), L(T(L(T(x(g[3][1], g[4][3]), x(-g[3][3], g[4][1])), g[2][0]), T(L(T(x(g[3][0], g[4][3]), x(-g[3][3], g[4][0])), -g[2][1]), L(T(x(g[3][0], g[4][1]), x(-g[3][1], g[4][0])), g[2][3]))), -g[1][4]))), g[0][2]), T(L(T(T(L(T(L(T(x(g[3][2], g[4][4]), x(-g[3][4], g[4][2])), g[2][1]), T(L(T(x(g[3][1], g[4][4]), x(-g[3][4], g[4][1])), -g[2][2]), L(T(x(g[3][1], g[4][2]), x(-g[3][2], g[4][1])), g[2][4]))), g[1][0]), L(T(L(T(x(g[3][2], g[4][4]), x(-g[3][4], g[4][2])), g[2][0]), T(L(T(x(g[3][0], g[4][4]), x(-g[3][4], g[4][0])), -g[2][2]), L(T(x(g[3][0], g[4][2]), x(-g[3][2], g[4][0])), g[2][4]))), -g[1][1])), T(L(T(L(T(x(g[3][1], g[4][4]), x(-g[3][4], g[4][1])), g[2][0]), T(L(T(x(g[3][0], g[4][4]), x(-g[3][4], g[4][0])), -g[2][1]), L(T(x(g[3][0], g[4][1]), x(-g[3][1], g[4][0])), g[2][4]))), g[1][2]), L(T(L(T(x(g[3][1], g[4][2]), x(-g[3][2], g[4][1])), g[2][0]), T(L(T(x(g[3][0], g[4][2]), x(-g[3][2], g[4][0])), -g[2][1]), L(T(x(g[3][0], g[4][1]), x(-g[3][1], g[4][0])), g[2][2]))), -g[1][4]))), -g[0][3]), L(T(T(L(T(L(T(x(g[3][2], g[4][3]), x(-g[3][3], g[4][2])), g[2][1]), T(L(T(x(g[3][1], g[4][3]), x(-g[3][3], g[4][1])), -g[2][2]), L(T(x(g[3][1], g[4][2]), x(-g[3][2], g[4][1])), g[2][3]))), g[1][0]), L(T(L(T(x(g[3][2], g[4][3]), x(-g[3][3], g[4][2])), g[2][0]), T(L(T(x(g[3][0], g[4][3]), x(-g[3][3], g[4][0])), -g[2][2]), L(T(x(g[3][0], g[4][2]), x(-g[3][2], g[4][0])), g[2][3]))), -g[1][1])), T(L(T(L(T(x(g[3][1], g[4][3]), x(-g[3][3], g[4][1])), g[2][0]), T(L(T(x(g[3][0], g[4][3]), x(-g[3][3], g[4][0])), -g[2][1]), L(T(x(g[3][0], g[4][1]), x(-g[3][1], g[4][0])), g[2][3]))), g[1][2]), L(T(L(T(x(g[3][1], g[4][2]), x(-g[3][2], g[4][1])), g[2][0]), T(L(T(x(g[3][0], g[4][2]), x(-g[3][2], g[4][0])), -g[2][1]), L(T(x(g[3][0], g[4][1]), x(-g[3][1], g[4][0])), g[2][2]))), -g[1][3]))), g[0][4])))));
+              };
+            }
+            function b(T) {
+              var L = T === 2 ? h : T === 3 ? d : T === 4 ? v : T === 5 ? _ : void 0;
+              return L(l, u, s, c);
+            }
+            var p = [function() {
+              return [0];
+            }, function(L) {
+              return [L[0][0]];
+            }];
+            function k(T, L, x, C, M, g, P, A) {
+              return function(O) {
+                switch (O.length) {
+                  case 0:
+                    return T(O);
+                  case 1:
+                    return L(O);
+                  case 2:
+                    return x(O);
+                  case 3:
+                    return C(O);
+                  case 4:
+                    return M(O);
+                  case 5:
+                    return g(O);
+                }
+                var U = P[O.length];
+                return U || (U = P[O.length] = A(O.length)), U(O);
+              };
+            }
+            function E() {
+              for (; p.length < f; ) p.push(b(p.length));
+              i.exports = k.apply(void 0, p.concat([p, b]));
+              for (var T = 0; T < p.length; ++T) i.exports[T] = p[T];
+            }
+            E();
+          }, 2992: function(i, a, o) {
+            var s = o(3387).sprintf, l = o(5171), u = o(1848), c = o(1085);
+            i.exports = f;
+            function f(h, d, v) {
+              var _ = u(d) || "of unknown name (see npm glsl-shader-name)", b = "unknown type";
+              v !== void 0 && (b = v === l.FRAGMENT_SHADER ? "fragment" : "vertex");
+              for (var p = s(`Error compiling %s shader %s:
+`, b, _), k = s("%s%s", p, h), E = h.split(`
+`), T = {}, L = 0; L < E.length; L++) {
+                var x = E[L];
+                if (!(x === "" || x === "\0")) {
+                  var C = parseInt(x.split(":")[2]);
+                  if (isNaN(C)) throw new Error(s("Could not parse error: %s", x));
+                  T[C] = x;
+                }
+              }
+              for (var M = c(d).split(`
+`), L = 0; L < M.length; L++) if (!(!T[L + 3] && !T[L + 2] && !T[L + 1])) {
+                var g = M[L];
+                if (p += g + `
+`, T[L + 1]) {
+                  var P = T[L + 1];
+                  P = P.substr(P.split(":", 3).join(":").length + 1).trim(), p += s(`^^^ %s
+
+`, P);
+                }
+              }
+              return { long: p.trim(), short: k.trim() };
+            }
+          }, 3012: function(i, a, o) {
+            var s = o(5250), l = o(9362);
+            i.exports = u;
+            function u(c, f) {
+              var h = c.length;
+              if (h === 1) {
+                var d = s(c[0], f);
+                return d[0] ? d : [d[1]];
+              }
+              var v = new Array(2 * h), _ = [0.1, 0.1], b = [0.1, 0.1], p = 0;
+              s(c[0], f, _), _[0] && (v[p++] = _[0]);
+              for (var k = 1; k < h; ++k) {
+                s(c[k], f, b);
+                var E = _[1];
+                l(E, b[0], _), _[0] && (v[p++] = _[0]);
+                var T = b[1], L = _[1], x = T + L, C = x - T, M = L - C;
+                _[1] = x, M && (v[p++] = M);
+              }
+              return _[1] && (v[p++] = _[1]), p === 0 && (v[p++] = 0), v.length = p, v;
+            }
+          }, 3025: function(i, a, o) {
+            i.exports = o.g.performance && o.g.performance.now ? function() {
+              return performance.now();
+            } : Date.now || function() {
+              return +/* @__PURE__ */ new Date();
+            };
+          }, 3066: function(i) {
+            i.exports = a;
+            function a(o) {
+              var s = o[0], l = o[1], u = o[2];
+              return s * s + l * l + u * u;
+            }
+          }, 3088: function(i, a, o) {
+            i.exports = l;
+            var s = o(3140);
+            function l(u, c) {
+              for (var f = c.length | 0, h = u.length, d = [new Array(f), new Array(f)], v = 0; v < f; ++v) d[0][v] = [], d[1][v] = [];
+              for (var v = 0; v < h; ++v) {
+                var _ = u[v];
+                d[0][_[0]].push(_), d[1][_[1]].push(_);
+              }
+              for (var b = [], v = 0; v < f; ++v) d[0][v].length + d[1][v].length === 0 && b.push([v]);
+              function p(g, P) {
+                var A = d[P][g[P]];
+                A.splice(A.indexOf(g), 1);
+              }
+              function k(g, P, A) {
+                for (var z, O, U, G = 0; G < 2; ++G) if (d[G][P].length > 0) {
+                  z = d[G][P][0], U = G;
+                  break;
+                }
+                O = z[U ^ 1];
+                for (var Z = 0; Z < 2; ++Z) for (var j = d[Z][P], N = 0; N < j.length; ++N) {
+                  var H = j[N], re = H[Z ^ 1], oe = s(c[g], c[P], c[O], c[re]);
+                  oe > 0 && (z = H, O = re, U = Z);
+                }
+                return A || z && p(z, U), O;
+              }
+              function E(g, P) {
+                var A = d[P][g][0], z = [g];
+                p(A, P);
+                for (var O = A[P ^ 1], U = P; ; ) {
+                  for (; O !== g; ) z.push(O), O = k(z[z.length - 2], O, false);
+                  if (d[0][g].length + d[1][g].length === 0) break;
+                  var G = z[z.length - 1], Z = g, j = z[1], N = k(G, Z, true);
+                  if (s(c[G], c[Z], c[j], c[N]) < 0) break;
+                  z.push(g), O = k(G, Z);
+                }
+                return z;
+              }
+              function T(g, P) {
+                return P[1] === P[P.length - 1];
+              }
+              for (var v = 0; v < f; ++v) for (var L = 0; L < 2; ++L) {
+                for (var x = []; d[L][v].length > 0; ) {
+                  d[0][v].length;
+                  var M = E(v, L);
+                  T(x, M) ? x.push.apply(x, M) : (x.length > 0 && b.push(x), x = M);
+                }
+                x.length > 0 && b.push(x);
+              }
+              return b;
+            }
+          }, 3090: function(i, a, o) {
+            i.exports = l;
+            var s = o(3250)[3];
+            function l(u) {
+              var c = u.length;
+              if (c < 3) {
+                for (var k = new Array(c), f = 0; f < c; ++f) k[f] = f;
+                return c === 2 && u[0][0] === u[1][0] && u[0][1] === u[1][1] ? [0] : k;
+              }
+              for (var h = new Array(c), f = 0; f < c; ++f) h[f] = f;
+              h.sort(function(x, C) {
+                var M = u[x][0] - u[C][0];
+                return M || u[x][1] - u[C][1];
+              });
+              for (var d = [h[0], h[1]], v = [h[0], h[1]], f = 2; f < c; ++f) {
+                for (var _ = h[f], b = u[_], p = d.length; p > 1 && s(u[d[p - 2]], u[d[p - 1]], b) <= 0; ) p -= 1, d.pop();
+                for (d.push(_), p = v.length; p > 1 && s(u[v[p - 2]], u[v[p - 1]], b) >= 0; ) p -= 1, v.pop();
+                v.push(_);
+              }
+              for (var k = new Array(v.length + d.length - 2), E = 0, f = 0, T = d.length; f < T; ++f) k[E++] = d[f];
+              for (var L = v.length - 2; L > 0; --L) k[E++] = v[L];
+              return k;
+            }
+          }, 3105: function(i, a) {
+            "use restrict";
+            var o = 32;
+            a.INT_BITS = o, a.INT_MAX = 2147483647, a.INT_MIN = -1 << o - 1, a.sign = function(u) {
+              return (u > 0) - (u < 0);
+            }, a.abs = function(u) {
+              var c = u >> o - 1;
+              return (u ^ c) - c;
+            }, a.min = function(u, c) {
+              return c ^ (u ^ c) & -(u < c);
+            }, a.max = function(u, c) {
+              return u ^ (u ^ c) & -(u < c);
+            }, a.isPow2 = function(u) {
+              return !(u & u - 1) && !!u;
+            }, a.log2 = function(u) {
+              var c, f;
+              return c = (u > 65535) << 4, u >>>= c, f = (u > 255) << 3, u >>>= f, c |= f, f = (u > 15) << 2, u >>>= f, c |= f, f = (u > 3) << 1, u >>>= f, c |= f, c | u >> 1;
+            }, a.log10 = function(u) {
+              return u >= 1e9 ? 9 : u >= 1e8 ? 8 : u >= 1e7 ? 7 : u >= 1e6 ? 6 : u >= 1e5 ? 5 : u >= 1e4 ? 4 : u >= 1e3 ? 3 : u >= 100 ? 2 : u >= 10 ? 1 : 0;
+            }, a.popCount = function(u) {
+              return u = u - (u >>> 1 & 1431655765), u = (u & 858993459) + (u >>> 2 & 858993459), (u + (u >>> 4) & 252645135) * 16843009 >>> 24;
+            };
+            function s(u) {
+              var c = 32;
+              return u &= -u, u && c--, u & 65535 && (c -= 16), u & 16711935 && (c -= 8), u & 252645135 && (c -= 4), u & 858993459 && (c -= 2), u & 1431655765 && (c -= 1), c;
+            }
+            a.countTrailingZeros = s, a.nextPow2 = function(u) {
+              return u += u === 0, --u, u |= u >>> 1, u |= u >>> 2, u |= u >>> 4, u |= u >>> 8, u |= u >>> 16, u + 1;
+            }, a.prevPow2 = function(u) {
+              return u |= u >>> 1, u |= u >>> 2, u |= u >>> 4, u |= u >>> 8, u |= u >>> 16, u - (u >>> 1);
+            }, a.parity = function(u) {
+              return u ^= u >>> 16, u ^= u >>> 8, u ^= u >>> 4, u &= 15, 27030 >>> u & 1;
+            };
+            var l = new Array(256);
+            (function(u) {
+              for (var c = 0; c < 256; ++c) {
+                var f = c, h = c, d = 7;
+                for (f >>>= 1; f; f >>>= 1) h <<= 1, h |= f & 1, --d;
+                u[c] = h << d & 255;
+              }
+            })(l), a.reverse = function(u) {
+              return l[u & 255] << 24 | l[u >>> 8 & 255] << 16 | l[u >>> 16 & 255] << 8 | l[u >>> 24 & 255];
+            }, a.interleave2 = function(u, c) {
+              return u &= 65535, u = (u | u << 8) & 16711935, u = (u | u << 4) & 252645135, u = (u | u << 2) & 858993459, u = (u | u << 1) & 1431655765, c &= 65535, c = (c | c << 8) & 16711935, c = (c | c << 4) & 252645135, c = (c | c << 2) & 858993459, c = (c | c << 1) & 1431655765, u | c << 1;
+            }, a.deinterleave2 = function(u, c) {
+              return u = u >>> c & 1431655765, u = (u | u >>> 1) & 858993459, u = (u | u >>> 2) & 252645135, u = (u | u >>> 4) & 16711935, u = (u | u >>> 16) & 65535, u << 16 >> 16;
+            }, a.interleave3 = function(u, c, f) {
+              return u &= 1023, u = (u | u << 16) & 4278190335, u = (u | u << 8) & 251719695, u = (u | u << 4) & 3272356035, u = (u | u << 2) & 1227133513, c &= 1023, c = (c | c << 16) & 4278190335, c = (c | c << 8) & 251719695, c = (c | c << 4) & 3272356035, c = (c | c << 2) & 1227133513, u |= c << 1, f &= 1023, f = (f | f << 16) & 4278190335, f = (f | f << 8) & 251719695, f = (f | f << 4) & 3272356035, f = (f | f << 2) & 1227133513, u | f << 2;
+            }, a.deinterleave3 = function(u, c) {
+              return u = u >>> c & 1227133513, u = (u | u >>> 2) & 3272356035, u = (u | u >>> 4) & 251719695, u = (u | u >>> 8) & 4278190335, u = (u | u >>> 16) & 1023, u << 22 >> 22;
+            }, a.nextCombination = function(u) {
+              var c = u | u - 1;
+              return c + 1 | (~c & -~c) - 1 >>> s(u) + 1;
+            };
+          }, 3126: function(i) {
+            i.exports = a;
+            function a(o) {
+              var s = new Float32Array(3);
+              return s[0] = o[0], s[1] = o[1], s[2] = o[2], s;
+            }
+          }, 3134: function(i, a, o) {
+            i.exports = l;
+            var s = o(1682);
+            function l(u, c) {
+              var f = u.length;
+              if (typeof c != "number") {
+                c = 0;
+                for (var h = 0; h < f; ++h) {
+                  var d = u[h];
+                  c = Math.max(c, d[0], d[1]);
+                }
+                c = (c | 0) + 1;
+              }
+              c = c | 0;
+              for (var v = new Array(c), h = 0; h < c; ++h) v[h] = [];
+              for (var h = 0; h < f; ++h) {
+                var d = u[h];
+                v[d[0]].push(d[1]), v[d[1]].push(d[0]);
+              }
+              for (var _ = 0; _ < c; ++_) s(v[_], function(b, p) {
+                return b - p;
+              });
+              return v;
+            }
+          }, 3140: function(i, a, o) {
+            i.exports = d;
+            var s = o(3250), l = o(8572), u = o(9362), c = o(5382), f = o(8210);
+            function h(v, _, b) {
+              var p = u(v[0], -_[0]), k = u(v[1], -_[1]), E = u(b[0], -_[0]), T = u(b[1], -_[1]), L = f(c(p, E), c(k, T));
+              return L[L.length - 1] >= 0;
+            }
+            function d(v, _, b, p) {
+              var k = s(_, b, p);
+              if (k === 0) {
+                var E = l(s(v, _, b)), T = l(s(v, _, p));
+                if (E === T) {
+                  if (E === 0) {
+                    var L = h(v, _, b), x = h(v, _, p);
+                    return L === x ? 0 : L ? 1 : -1;
+                  }
+                  return 0;
+                } else {
+                  if (T === 0) return E > 0 || h(v, _, p) ? -1 : 1;
+                  if (E === 0) return T > 0 || h(v, _, b) ? 1 : -1;
+                }
+                return l(T - E);
+              }
+              var C = s(v, _, b);
+              if (C > 0) return k > 0 && s(v, _, p) > 0 ? 1 : -1;
+              if (C < 0) return k > 0 || s(v, _, p) > 0 ? 1 : -1;
+              var M = s(v, _, p);
+              return M > 0 || h(v, _, b) ? 1 : -1;
+            }
+          }, 3202: function(i) {
+            i.exports = function(o, s) {
+              s || (s = [0, ""]), o = String(o);
+              var l = parseFloat(o, 10);
+              return s[0] = l, s[1] = o.match(/[\d.\-\+]*\s*(.*)/)[1] || "", s;
+            };
+          }, 3233: function(i) {
+            var a = "", o;
+            i.exports = s;
+            function s(l, u) {
+              if (typeof l != "string") throw new TypeError("expected a string");
+              if (u === 1) return l;
+              if (u === 2) return l + l;
+              var c = l.length * u;
+              if (o !== l || typeof o == "undefined") o = l, a = "";
+              else if (a.length >= c) return a.substr(0, c);
+              for (; c > a.length && u > 1; ) u & 1 && (a += l), u >>= 1, l += l;
+              return a += l, a = a.substr(0, c), a;
+            }
+          }, 3236: function(i) {
+            i.exports = function(a) {
+              typeof a == "string" && (a = [a]);
+              for (var o = [].slice.call(arguments, 1), s = [], l = 0; l < a.length - 1; l++) s.push(a[l], o[l] || "");
+              return s.push(a[l]), s.join("");
+            };
+          }, 3250: function(i, a, o) {
+            var s = o(5250), l = o(8210), u = o(3012), c = o(8545), f = 5, h = 11102230246251565e-32, d = (3 + 16 * h) * h, v = (7 + 56 * h) * h;
+            function _(g, P, A, z) {
+              return function(U, G, Z) {
+                var j = g(g(P(G[1], Z[0]), P(-Z[1], G[0])), g(P(U[1], G[0]), P(-G[1], U[0]))), N = g(P(U[1], Z[0]), P(-Z[1], U[0])), H = z(j, N);
+                return H[H.length - 1];
+              };
+            }
+            function b(g, P, A, z) {
+              return function(U, G, Z, j) {
+                var N = g(g(A(g(P(Z[1], j[0]), P(-j[1], Z[0])), G[2]), g(A(g(P(G[1], j[0]), P(-j[1], G[0])), -Z[2]), A(g(P(G[1], Z[0]), P(-Z[1], G[0])), j[2]))), g(A(g(P(G[1], j[0]), P(-j[1], G[0])), U[2]), g(A(g(P(U[1], j[0]), P(-j[1], U[0])), -G[2]), A(g(P(U[1], G[0]), P(-G[1], U[0])), j[2])))), H = g(g(A(g(P(Z[1], j[0]), P(-j[1], Z[0])), U[2]), g(A(g(P(U[1], j[0]), P(-j[1], U[0])), -Z[2]), A(g(P(U[1], Z[0]), P(-Z[1], U[0])), j[2]))), g(A(g(P(G[1], Z[0]), P(-Z[1], G[0])), U[2]), g(A(g(P(U[1], Z[0]), P(-Z[1], U[0])), -G[2]), A(g(P(U[1], G[0]), P(-G[1], U[0])), Z[2])))), re = z(N, H);
+                return re[re.length - 1];
+              };
+            }
+            function p(g, P, A, z) {
+              return function(U, G, Z, j, N) {
+                var H = g(g(g(A(g(A(g(P(j[1], N[0]), P(-N[1], j[0])), Z[2]), g(A(g(P(Z[1], N[0]), P(-N[1], Z[0])), -j[2]), A(g(P(Z[1], j[0]), P(-j[1], Z[0])), N[2]))), G[3]), g(A(g(A(g(P(j[1], N[0]), P(-N[1], j[0])), G[2]), g(A(g(P(G[1], N[0]), P(-N[1], G[0])), -j[2]), A(g(P(G[1], j[0]), P(-j[1], G[0])), N[2]))), -Z[3]), A(g(A(g(P(Z[1], N[0]), P(-N[1], Z[0])), G[2]), g(A(g(P(G[1], N[0]), P(-N[1], G[0])), -Z[2]), A(g(P(G[1], Z[0]), P(-Z[1], G[0])), N[2]))), j[3]))), g(A(g(A(g(P(Z[1], j[0]), P(-j[1], Z[0])), G[2]), g(A(g(P(G[1], j[0]), P(-j[1], G[0])), -Z[2]), A(g(P(G[1], Z[0]), P(-Z[1], G[0])), j[2]))), -N[3]), g(A(g(A(g(P(j[1], N[0]), P(-N[1], j[0])), G[2]), g(A(g(P(G[1], N[0]), P(-N[1], G[0])), -j[2]), A(g(P(G[1], j[0]), P(-j[1], G[0])), N[2]))), U[3]), A(g(A(g(P(j[1], N[0]), P(-N[1], j[0])), U[2]), g(A(g(P(U[1], N[0]), P(-N[1], U[0])), -j[2]), A(g(P(U[1], j[0]), P(-j[1], U[0])), N[2]))), -G[3])))), g(g(A(g(A(g(P(G[1], N[0]), P(-N[1], G[0])), U[2]), g(A(g(P(U[1], N[0]), P(-N[1], U[0])), -G[2]), A(g(P(U[1], G[0]), P(-G[1], U[0])), N[2]))), j[3]), g(A(g(A(g(P(G[1], j[0]), P(-j[1], G[0])), U[2]), g(A(g(P(U[1], j[0]), P(-j[1], U[0])), -G[2]), A(g(P(U[1], G[0]), P(-G[1], U[0])), j[2]))), -N[3]), A(g(A(g(P(Z[1], j[0]), P(-j[1], Z[0])), G[2]), g(A(g(P(G[1], j[0]), P(-j[1], G[0])), -Z[2]), A(g(P(G[1], Z[0]), P(-Z[1], G[0])), j[2]))), U[3]))), g(A(g(A(g(P(Z[1], j[0]), P(-j[1], Z[0])), U[2]), g(A(g(P(U[1], j[0]), P(-j[1], U[0])), -Z[2]), A(g(P(U[1], Z[0]), P(-Z[1], U[0])), j[2]))), -G[3]), g(A(g(A(g(P(G[1], j[0]), P(-j[1], G[0])), U[2]), g(A(g(P(U[1], j[0]), P(-j[1], U[0])), -G[2]), A(g(P(U[1], G[0]), P(-G[1], U[0])), j[2]))), Z[3]), A(g(A(g(P(G[1], Z[0]), P(-Z[1], G[0])), U[2]), g(A(g(P(U[1], Z[0]), P(-Z[1], U[0])), -G[2]), A(g(P(U[1], G[0]), P(-G[1], U[0])), Z[2]))), -j[3]))))), re = g(g(g(A(g(A(g(P(j[1], N[0]), P(-N[1], j[0])), Z[2]), g(A(g(P(Z[1], N[0]), P(-N[1], Z[0])), -j[2]), A(g(P(Z[1], j[0]), P(-j[1], Z[0])), N[2]))), U[3]), A(g(A(g(P(j[1], N[0]), P(-N[1], j[0])), U[2]), g(A(g(P(U[1], N[0]), P(-N[1], U[0])), -j[2]), A(g(P(U[1], j[0]), P(-j[1], U[0])), N[2]))), -Z[3])), g(A(g(A(g(P(Z[1], N[0]), P(-N[1], Z[0])), U[2]), g(A(g(P(U[1], N[0]), P(-N[1], U[0])), -Z[2]), A(g(P(U[1], Z[0]), P(-Z[1], U[0])), N[2]))), j[3]), A(g(A(g(P(Z[1], j[0]), P(-j[1], Z[0])), U[2]), g(A(g(P(U[1], j[0]), P(-j[1], U[0])), -Z[2]), A(g(P(U[1], Z[0]), P(-Z[1], U[0])), j[2]))), -N[3]))), g(g(A(g(A(g(P(Z[1], N[0]), P(-N[1], Z[0])), G[2]), g(A(g(P(G[1], N[0]), P(-N[1], G[0])), -Z[2]), A(g(P(G[1], Z[0]), P(-Z[1], G[0])), N[2]))), U[3]), A(g(A(g(P(Z[1], N[0]), P(-N[1], Z[0])), U[2]), g(A(g(P(U[1], N[0]), P(-N[1], U[0])), -Z[2]), A(g(P(U[1], Z[0]), P(-Z[1], U[0])), N[2]))), -G[3])), g(A(g(A(g(P(G[1], N[0]), P(-N[1], G[0])), U[2]), g(A(g(P(U[1], N[0]), P(-N[1], U[0])), -G[2]), A(g(P(U[1], G[0]), P(-G[1], U[0])), N[2]))), Z[3]), A(g(A(g(P(G[1], Z[0]), P(-Z[1], G[0])), U[2]), g(A(g(P(U[1], Z[0]), P(-Z[1], U[0])), -G[2]), A(g(P(U[1], G[0]), P(-G[1], U[0])), Z[2]))), -N[3])))), oe = z(H, re);
+                return oe[oe.length - 1];
+              };
+            }
+            function k(g) {
+              var P = g === 3 ? _ : g === 4 ? b : p;
+              return P(l, s, u, c);
+            }
+            var E = k(3), T = k(4), L = [function() {
+              return 0;
+            }, function() {
+              return 0;
+            }, function(P, A) {
+              return A[0] - P[0];
+            }, function(P, A, z) {
+              var O = (P[1] - z[1]) * (A[0] - z[0]), U = (P[0] - z[0]) * (A[1] - z[1]), G = O - U, Z;
+              if (O > 0) {
+                if (U <= 0) return G;
+                Z = O + U;
+              } else if (O < 0) {
+                if (U >= 0) return G;
+                Z = -(O + U);
+              } else return G;
+              var j = d * Z;
+              return G >= j || G <= -j ? G : E(P, A, z);
+            }, function(P, A, z, O) {
+              var U = P[0] - O[0], G = A[0] - O[0], Z = z[0] - O[0], j = P[1] - O[1], N = A[1] - O[1], H = z[1] - O[1], re = P[2] - O[2], oe = A[2] - O[2], _e = z[2] - O[2], Ce = G * H, Le = Z * N, ge = Z * j, ie = U * H, Se = U * N, Ee = G * j, Ae = re * (Ce - Le) + oe * (ge - ie) + _e * (Se - Ee), Be = (Math.abs(Ce) + Math.abs(Le)) * Math.abs(re) + (Math.abs(ge) + Math.abs(ie)) * Math.abs(oe) + (Math.abs(Se) + Math.abs(Ee)) * Math.abs(_e), Pe = v * Be;
+              return Ae > Pe || -Ae > Pe ? Ae : T(P, A, z, O);
+            }];
+            function x(g) {
+              var P = L[g.length];
+              return P || (P = L[g.length] = k(g.length)), P.apply(void 0, g);
+            }
+            function C(g, P, A, z, O, U, G) {
+              return function(j, N, H, re, oe) {
+                switch (arguments.length) {
+                  case 0:
+                  case 1:
+                    return 0;
+                  case 2:
+                    return z(j, N);
+                  case 3:
+                    return O(j, N, H);
+                  case 4:
+                    return U(j, N, H, re);
+                  case 5:
+                    return G(j, N, H, re, oe);
+                }
+                for (var _e = new Array(arguments.length), Ce = 0; Ce < arguments.length; ++Ce) _e[Ce] = arguments[Ce];
+                return g(_e);
+              };
+            }
+            function M() {
+              for (; L.length <= f; ) L.push(k(L.length));
+              i.exports = C.apply(void 0, [x].concat(L));
+              for (var g = 0; g <= f; ++g) i.exports[g] = L[g];
+            }
+            M();
+          }, 3327: function(i, a, o) {
+            var s = o(216), l = o(8866);
+            i.exports = f;
+            function u(h) {
+              return function() {
+                return h;
+              };
+            }
+            function c(h, d) {
+              for (var v = new Array(h), _ = 0; _ < h; ++_) v[_] = d;
+              return v;
+            }
+            function f(h, d, v, _) {
+              function b(C) {
+                return function(M, g, P) {
+                  return M.getUniform(g.program, P[C]);
+                };
+              }
+              function p(C) {
+                return function(g) {
+                  for (var P = k("", C), A = 0; A < P.length; ++A) {
+                    var z = P[A], O = z[0], U = z[1];
+                    if (_[U]) {
+                      var G = g;
+                      if (typeof O == "string" && (O.indexOf(".") === 0 || O.indexOf("[") === 0)) {
+                        var Z = O;
+                        if (O.indexOf(".") === 0 && (Z = O.slice(1)), Z.indexOf("]") === Z.length - 1) {
+                          var j = Z.indexOf("["), N = Z.slice(0, j), H = Z.slice(j + 1, Z.length - 1);
+                          G = N ? g[N][H] : g[H];
+                        } else G = g[Z];
+                      }
+                      var re = v[U].type, oe;
+                      switch (re) {
+                        case "bool":
+                        case "int":
+                        case "sampler2D":
+                        case "samplerCube":
+                          h.uniform1i(_[U], G);
+                          break;
+                        case "float":
+                          h.uniform1f(_[U], G);
+                          break;
+                        default:
+                          var _e = re.indexOf("vec");
+                          if (0 <= _e && _e <= 1 && re.length === 4 + _e) {
+                            if (oe = re.charCodeAt(re.length - 1) - 48, oe < 2 || oe > 4) throw new l("", "Invalid data type");
+                            switch (re.charAt(0)) {
+                              case "b":
+                              case "i":
+                                h["uniform" + oe + "iv"](_[U], G);
+                                break;
+                              case "v":
+                                h["uniform" + oe + "fv"](_[U], G);
+                                break;
+                              default:
+                                throw new l("", "Unrecognized data type for vector " + name + ": " + re);
+                            }
+                          } else if (re.indexOf("mat") === 0 && re.length === 4) {
+                            if (oe = re.charCodeAt(re.length - 1) - 48, oe < 2 || oe > 4) throw new l("", "Invalid uniform dimension type for matrix " + name + ": " + re);
+                            h["uniformMatrix" + oe + "fv"](_[U], false, G);
+                            break;
+                          } else throw new l("", "Unknown uniform data type for " + name + ": " + re);
+                      }
+                    }
+                  }
+                };
+              }
+              function k(C, M) {
+                if (typeof M != "object") return [[C, M]];
+                var g = [];
+                for (var P in M) {
+                  var A = M[P], z = C;
+                  parseInt(P) + "" === P ? z += "[" + P + "]" : z += "." + P, typeof A == "object" ? g.push.apply(g, k(z, A)) : g.push([z, A]);
+                }
+                return g;
+              }
+              function E(C) {
+                switch (C) {
+                  case "bool":
+                    return false;
+                  case "int":
+                  case "sampler2D":
+                  case "samplerCube":
+                    return 0;
+                  case "float":
+                    return 0;
+                  default:
+                    var M = C.indexOf("vec");
+                    if (0 <= M && M <= 1 && C.length === 4 + M) {
+                      var g = C.charCodeAt(C.length - 1) - 48;
+                      if (g < 2 || g > 4) throw new l("", "Invalid data type");
+                      return C.charAt(0) === "b" ? c(g, false) : c(g, 0);
+                    } else if (C.indexOf("mat") === 0 && C.length === 4) {
+                      var g = C.charCodeAt(C.length - 1) - 48;
+                      if (g < 2 || g > 4) throw new l("", "Invalid uniform dimension type for matrix " + name + ": " + C);
+                      return c(g * g, 0);
+                    } else throw new l("", "Unknown uniform data type for " + name + ": " + C);
+                }
+              }
+              function T(C, M, g) {
+                if (typeof g == "object") {
+                  var P = L(g);
+                  Object.defineProperty(C, M, { get: u(P), set: p(g), enumerable: true, configurable: false });
+                } else _[g] ? Object.defineProperty(C, M, { get: b(g), set: p(g), enumerable: true, configurable: false }) : C[M] = E(v[g].type);
+              }
+              function L(C) {
+                var M;
+                if (Array.isArray(C)) {
+                  M = new Array(C.length);
+                  for (var g = 0; g < C.length; ++g) T(M, g, C[g]);
+                } else {
+                  M = {};
+                  for (var P in C) T(M, P, C[P]);
+                }
+                return M;
+              }
+              var x = s(v, true);
+              return { get: u(L(x)), set: p(x), enumerable: true, configurable: true };
+            }
+          }, 3349: function(i) {
+            function a() {
+              return function(f, h, d, v, _, b) {
+                var p = f[0], k = d[0], E = [0], T = k;
+                v |= 0;
+                var L = 0, x = k;
+                for (L = 0; L < p; ++L) {
+                  {
+                    var C = h[v] - b, M = h[v + T] - b;
+                    C >= 0 != M >= 0 && _.push(E[0] + 0.5 + 0.5 * (C + M) / (C - M));
+                  }
+                  v += x, ++E[0];
+                }
+              };
+            }
+            function o() {
+              return a();
+            }
+            var s = o;
+            function l(f) {
+              var h = {};
+              return function(v, _, b) {
+                var p = v.dtype, k = v.order, E = [p, k.join()].join(), T = h[E];
+                return T || (h[E] = T = f([p, k])), T(v.shape.slice(0), v.data, v.stride, v.offset | 0, _, b);
+              };
+            }
+            function u(f) {
+              return l(s.bind(void 0, f));
+            }
+            function c(f) {
+              return u({ funcName: f.funcName });
+            }
+            i.exports = c({ funcName: "zeroCrossings" });
+          }, 3352: function(i, a, o) {
+            var s = o(2478), l = 0, u = 1, c = 2;
+            i.exports = P;
+            function f(A, z, O, U, G) {
+              this.mid = A, this.left = z, this.right = O, this.leftPoints = U, this.rightPoints = G, this.count = (z ? z.count : 0) + (O ? O.count : 0) + U.length;
+            }
+            var h = f.prototype;
+            function d(A, z) {
+              A.mid = z.mid, A.left = z.left, A.right = z.right, A.leftPoints = z.leftPoints, A.rightPoints = z.rightPoints, A.count = z.count;
+            }
+            function v(A, z) {
+              var O = C(z);
+              A.mid = O.mid, A.left = O.left, A.right = O.right, A.leftPoints = O.leftPoints, A.rightPoints = O.rightPoints, A.count = O.count;
+            }
+            function _(A, z) {
+              var O = A.intervals([]);
+              O.push(z), v(A, O);
+            }
+            function b(A, z) {
+              var O = A.intervals([]), U = O.indexOf(z);
+              return U < 0 ? l : (O.splice(U, 1), v(A, O), u);
+            }
+            h.intervals = function(A) {
+              return A.push.apply(A, this.leftPoints), this.left && this.left.intervals(A), this.right && this.right.intervals(A), A;
+            }, h.insert = function(A) {
+              var z = this.count - this.leftPoints.length;
+              if (this.count += 1, A[1] < this.mid) this.left ? 4 * (this.left.count + 1) > 3 * (z + 1) ? _(this, A) : this.left.insert(A) : this.left = C([A]);
+              else if (A[0] > this.mid) this.right ? 4 * (this.right.count + 1) > 3 * (z + 1) ? _(this, A) : this.right.insert(A) : this.right = C([A]);
+              else {
+                var O = s.ge(this.leftPoints, A, L), U = s.ge(this.rightPoints, A, x);
+                this.leftPoints.splice(O, 0, A), this.rightPoints.splice(U, 0, A);
+              }
+            }, h.remove = function(A) {
+              var z = this.count - this.leftPoints;
+              if (A[1] < this.mid) {
+                if (!this.left) return l;
+                var O = this.right ? this.right.count : 0;
+                if (4 * O > 3 * (z - 1)) return b(this, A);
+                var U = this.left.remove(A);
+                return U === c ? (this.left = null, this.count -= 1, u) : (U === u && (this.count -= 1), U);
+              } else if (A[0] > this.mid) {
+                if (!this.right) return l;
+                var G = this.left ? this.left.count : 0;
+                if (4 * G > 3 * (z - 1)) return b(this, A);
+                var U = this.right.remove(A);
+                return U === c ? (this.right = null, this.count -= 1, u) : (U === u && (this.count -= 1), U);
+              } else {
+                if (this.count === 1) return this.leftPoints[0] === A ? c : l;
+                if (this.leftPoints.length === 1 && this.leftPoints[0] === A) {
+                  if (this.left && this.right) {
+                    for (var Z = this, j = this.left; j.right; ) Z = j, j = j.right;
+                    if (Z === this) j.right = this.right;
+                    else {
+                      var N = this.left, U = this.right;
+                      Z.count -= j.count, Z.right = j.left, j.left = N, j.right = U;
+                    }
+                    d(this, j), this.count = (this.left ? this.left.count : 0) + (this.right ? this.right.count : 0) + this.leftPoints.length;
+                  } else this.left ? d(this, this.left) : d(this, this.right);
+                  return u;
+                }
+                for (var N = s.ge(this.leftPoints, A, L); N < this.leftPoints.length && this.leftPoints[N][0] === A[0]; ++N) if (this.leftPoints[N] === A) {
+                  this.count -= 1, this.leftPoints.splice(N, 1);
+                  for (var U = s.ge(this.rightPoints, A, x); U < this.rightPoints.length && this.rightPoints[U][1] === A[1]; ++U) if (this.rightPoints[U] === A) return this.rightPoints.splice(U, 1), u;
+                }
+                return l;
+              }
+            };
+            function p(A, z, O) {
+              for (var U = 0; U < A.length && A[U][0] <= z; ++U) {
+                var G = O(A[U]);
+                if (G) return G;
+              }
+            }
+            function k(A, z, O) {
+              for (var U = A.length - 1; U >= 0 && A[U][1] >= z; --U) {
+                var G = O(A[U]);
+                if (G) return G;
+              }
+            }
+            function E(A, z) {
+              for (var O = 0; O < A.length; ++O) {
+                var U = z(A[O]);
+                if (U) return U;
+              }
+            }
+            h.queryPoint = function(A, z) {
+              if (A < this.mid) {
+                if (this.left) {
+                  var O = this.left.queryPoint(A, z);
+                  if (O) return O;
+                }
+                return p(this.leftPoints, A, z);
+              } else if (A > this.mid) {
+                if (this.right) {
+                  var O = this.right.queryPoint(A, z);
+                  if (O) return O;
+                }
+                return k(this.rightPoints, A, z);
+              } else return E(this.leftPoints, z);
+            }, h.queryInterval = function(A, z, O) {
+              if (A < this.mid && this.left) {
+                var U = this.left.queryInterval(A, z, O);
+                if (U) return U;
+              }
+              if (z > this.mid && this.right) {
+                var U = this.right.queryInterval(A, z, O);
+                if (U) return U;
+              }
+              return z < this.mid ? p(this.leftPoints, z, O) : A > this.mid ? k(this.rightPoints, A, O) : E(this.leftPoints, O);
+            };
+            function T(A, z) {
+              return A - z;
+            }
+            function L(A, z) {
+              var O = A[0] - z[0];
+              return O || A[1] - z[1];
+            }
+            function x(A, z) {
+              var O = A[1] - z[1];
+              return O || A[0] - z[0];
+            }
+            function C(A) {
+              if (A.length === 0) return null;
+              for (var z = [], O = 0; O < A.length; ++O) z.push(A[O][0], A[O][1]);
+              z.sort(T);
+              for (var U = z[z.length >> 1], G = [], Z = [], j = [], O = 0; O < A.length; ++O) {
+                var N = A[O];
+                N[1] < U ? G.push(N) : U < N[0] ? Z.push(N) : j.push(N);
+              }
+              var H = j, re = j.slice();
+              return H.sort(L), re.sort(x), new f(U, C(G), C(Z), H, re);
+            }
+            function M(A) {
+              this.root = A;
+            }
+            var g = M.prototype;
+            g.insert = function(A) {
+              this.root ? this.root.insert(A) : this.root = new f(A[0], null, null, [A], [A]);
+            }, g.remove = function(A) {
+              if (this.root) {
+                var z = this.root.remove(A);
+                return z === c && (this.root = null), z !== l;
+              }
+              return false;
+            }, g.queryPoint = function(A, z) {
+              if (this.root) return this.root.queryPoint(A, z);
+            }, g.queryInterval = function(A, z, O) {
+              if (A <= z && this.root) return this.root.queryInterval(A, z, O);
+            }, Object.defineProperty(g, "count", { get: function() {
+              return this.root ? this.root.count : 0;
+            } }), Object.defineProperty(g, "intervals", { get: function() {
+              return this.root ? this.root.intervals([]) : [];
+            } });
+            function P(A) {
+              return !A || A.length === 0 ? new M(null) : new M(C(A));
+            }
+          }, 3387: function(i, a, o) {
+            var s;
+            (function() {
+              var l = { not_type: /[^T]/, not_primitive: /[^v]/, number: /[diefg]/, numeric_arg: /[bcdiefguxX]/, json: /[j]/, text: /^[^\x25]+/, modulo: /^\x25{2}/, placeholder: /^\x25(?:([1-9]\d*)\$|\(([^)]+)\))?(\+)?(0|'[^$])?(-)?(\d+)?(?:\.(\d+))?([b-gijostTuvxX])/, key: /^([a-z_][a-z_\d]*)/i, key_access: /^\.([a-z_][a-z_\d]*)/i, index_access: /^\[(\d+)\]/, sign: /^[+-]/ };
+              function u(v) {
+                return f(d(v), arguments);
+              }
+              function c(v, _) {
+                return u.apply(null, [v].concat(_ || []));
+              }
+              function f(v, _) {
+                var b = 1, p = v.length, k, E = "", T, L, x, C, M, g, P, A;
+                for (T = 0; T < p; T++) if (typeof v[T] == "string") E += v[T];
+                else if (typeof v[T] == "object") {
+                  if (x = v[T], x.keys) for (k = _[b], L = 0; L < x.keys.length; L++) {
+                    if (k == null) throw new Error(u('[sprintf] Cannot access property "%s" of undefined value "%s"', x.keys[L], x.keys[L - 1]));
+                    k = k[x.keys[L]];
+                  }
+                  else x.param_no ? k = _[x.param_no] : k = _[b++];
+                  if (l.not_type.test(x.type) && l.not_primitive.test(x.type) && k instanceof Function && (k = k()), l.numeric_arg.test(x.type) && typeof k != "number" && isNaN(k)) throw new TypeError(u("[sprintf] expecting number but found %T", k));
+                  switch (l.number.test(x.type) && (P = k >= 0), x.type) {
+                    case "b":
+                      k = parseInt(k, 10).toString(2);
+                      break;
+                    case "c":
+                      k = String.fromCharCode(parseInt(k, 10));
+                      break;
+                    case "d":
+                    case "i":
+                      k = parseInt(k, 10);
+                      break;
+                    case "j":
+                      k = JSON.stringify(k, null, x.width ? parseInt(x.width) : 0);
+                      break;
+                    case "e":
+                      k = x.precision ? parseFloat(k).toExponential(x.precision) : parseFloat(k).toExponential();
+                      break;
+                    case "f":
+                      k = x.precision ? parseFloat(k).toFixed(x.precision) : parseFloat(k);
+                      break;
+                    case "g":
+                      k = x.precision ? String(Number(k.toPrecision(x.precision))) : parseFloat(k);
+                      break;
+                    case "o":
+                      k = (parseInt(k, 10) >>> 0).toString(8);
+                      break;
+                    case "s":
+                      k = String(k), k = x.precision ? k.substring(0, x.precision) : k;
+                      break;
+                    case "t":
+                      k = String(!!k), k = x.precision ? k.substring(0, x.precision) : k;
+                      break;
+                    case "T":
+                      k = Object.prototype.toString.call(k).slice(8, -1).toLowerCase(), k = x.precision ? k.substring(0, x.precision) : k;
+                      break;
+                    case "u":
+                      k = parseInt(k, 10) >>> 0;
+                      break;
+                    case "v":
+                      k = k.valueOf(), k = x.precision ? k.substring(0, x.precision) : k;
+                      break;
+                    case "x":
+                      k = (parseInt(k, 10) >>> 0).toString(16);
+                      break;
+                    case "X":
+                      k = (parseInt(k, 10) >>> 0).toString(16).toUpperCase();
+                      break;
+                  }
+                  l.json.test(x.type) ? E += k : (l.number.test(x.type) && (!P || x.sign) ? (A = P ? "+" : "-", k = k.toString().replace(l.sign, "")) : A = "", M = x.pad_char ? x.pad_char === "0" ? "0" : x.pad_char.charAt(1) : " ", g = x.width - (A + k).length, C = x.width && g > 0 ? M.repeat(g) : "", E += x.align ? A + k + C : M === "0" ? A + C + k : C + A + k);
+                }
+                return E;
+              }
+              var h = /* @__PURE__ */ Object.create(null);
+              function d(v) {
+                if (h[v]) return h[v];
+                for (var _ = v, b, p = [], k = 0; _; ) {
+                  if ((b = l.text.exec(_)) !== null) p.push(b[0]);
+                  else if ((b = l.modulo.exec(_)) !== null) p.push("%");
+                  else if ((b = l.placeholder.exec(_)) !== null) {
+                    if (b[2]) {
+                      k |= 1;
+                      var E = [], T = b[2], L = [];
+                      if ((L = l.key.exec(T)) !== null) for (E.push(L[1]); (T = T.substring(L[0].length)) !== ""; ) if ((L = l.key_access.exec(T)) !== null) E.push(L[1]);
+                      else if ((L = l.index_access.exec(T)) !== null) E.push(L[1]);
+                      else throw new SyntaxError("[sprintf] failed to parse named argument key");
+                      else throw new SyntaxError("[sprintf] failed to parse named argument key");
+                      b[2] = E;
+                    } else k |= 2;
+                    if (k === 3) throw new Error("[sprintf] mixing positional and named placeholders is not (yet) supported");
+                    p.push({ placeholder: b[0], param_no: b[1], keys: b[2], sign: b[3], pad_char: b[4], align: b[5], width: b[6], precision: b[7], type: b[8] });
+                  } else throw new SyntaxError("[sprintf] unexpected placeholder");
+                  _ = _.substring(b[0].length);
+                }
+                return h[v] = p;
+              }
+              a.sprintf = u, a.vsprintf = c, typeof window != "undefined" && (window.sprintf = u, window.vsprintf = c, s = (function() {
+                return { sprintf: u, vsprintf: c };
+              }).call(a, o, a, i), s !== void 0 && (i.exports = s));
+            })();
+          }, 3390: function(i) {
+            i.exports = a;
+            function a(o, s, l, u) {
+              var c = new Float32Array(4);
+              return c[0] = o, c[1] = s, c[2] = l, c[3] = u, c;
+            }
+          }, 3436: function(i, a, o) {
+            var s = o(3236), l = o(9405), u = s([`precision highp float;
+#define GLSLIFY 1
+
+attribute vec3 position, offset;
+attribute vec4 color;
+uniform mat4 model, view, projection;
+uniform float capSize;
+varying vec4 fragColor;
+varying vec3 fragPosition;
+
+void main() {
+  vec4 worldPosition  = model * vec4(position, 1.0);
+  worldPosition       = (worldPosition / worldPosition.w) + vec4(capSize * offset, 0.0);
+  gl_Position         = projection * (view * worldPosition);
+  fragColor           = color;
+  fragPosition        = position;
+}`]), c = s([`precision highp float;
+#define GLSLIFY 1
+
+bool outOfRange(float a, float b, float p) {
+  return ((p > max(a, b)) ||
+          (p < min(a, b)));
+}
+
+bool outOfRange(vec2 a, vec2 b, vec2 p) {
+  return (outOfRange(a.x, b.x, p.x) ||
+          outOfRange(a.y, b.y, p.y));
+}
+
+bool outOfRange(vec3 a, vec3 b, vec3 p) {
+  return (outOfRange(a.x, b.x, p.x) ||
+          outOfRange(a.y, b.y, p.y) ||
+          outOfRange(a.z, b.z, p.z));
+}
+
+bool outOfRange(vec4 a, vec4 b, vec4 p) {
+  return outOfRange(a.xyz, b.xyz, p.xyz);
+}
+
+uniform vec3 clipBounds[2];
+uniform float opacity;
+varying vec3 fragPosition;
+varying vec4 fragColor;
+
+void main() {
+  if (
+    outOfRange(clipBounds[0], clipBounds[1], fragPosition) ||
+    fragColor.a * opacity == 0.
+  ) discard;
+
+  gl_FragColor = opacity * fragColor;
+}`]);
+            i.exports = function(f) {
+              return l(f, u, c, null, [{ name: "position", type: "vec3" }, { name: "color", type: "vec4" }, { name: "offset", type: "vec3" }]);
+            };
+          }, 3502: function(i, a, o) {
+            i.exports = u;
+            var s = o(5995), l = o(9127);
+            function u(c, f) {
+              return l(s(c, f));
+            }
+          }, 3508: function(i, a, o) {
+            var s = o(6852);
+            s = s.slice().filter(function(l) {
+              return !/^(gl\_|texture)/.test(l);
+            }), i.exports = s.concat(["gl_VertexID", "gl_InstanceID", "gl_Position", "gl_PointSize", "gl_FragCoord", "gl_FrontFacing", "gl_FragDepth", "gl_PointCoord", "gl_MaxVertexAttribs", "gl_MaxVertexUniformVectors", "gl_MaxVertexOutputVectors", "gl_MaxFragmentInputVectors", "gl_MaxVertexTextureImageUnits", "gl_MaxCombinedTextureImageUnits", "gl_MaxTextureImageUnits", "gl_MaxFragmentUniformVectors", "gl_MaxDrawBuffers", "gl_MinProgramTexelOffset", "gl_MaxProgramTexelOffset", "gl_DepthRangeParameters", "gl_DepthRange", "trunc", "round", "roundEven", "isnan", "isinf", "floatBitsToInt", "floatBitsToUint", "intBitsToFloat", "uintBitsToFloat", "packSnorm2x16", "unpackSnorm2x16", "packUnorm2x16", "unpackUnorm2x16", "packHalf2x16", "unpackHalf2x16", "outerProduct", "transpose", "determinant", "inverse", "texture", "textureSize", "textureProj", "textureLod", "textureOffset", "texelFetch", "texelFetchOffset", "textureProjOffset", "textureLodOffset", "textureProjLod", "textureProjLodOffset", "textureGrad", "textureGradOffset", "textureProjGrad", "textureProjGradOffset"]);
+          }, 3536: function(i) {
+            i.exports = a;
+            function a(o, s) {
+              var l = s[0], u = s[1], c = s[2], f = l * l + u * u + c * c;
+              return f > 0 && (f = 1 / Math.sqrt(f), o[0] = s[0] * f, o[1] = s[1] * f, o[2] = s[2] * f), o;
+            }
+          }, 3545: function(i, a, o) {
+            i.exports = f;
+            var s = o(8105), l = s("lo<p0"), u = 8;
+            function c(h, d, v, _, b, p) {
+              for (var k = 2 * h, E = k * (v + 1) + d, T = v + 1; T < _; ++T, E += k) for (var L = b[E], x = T, C = k * (T - 1); x > v && b[C + d] > L; --x, C -= k) {
+                for (var M = C, g = C + k, P = 0; P < k; ++P, ++M, ++g) {
+                  var A = b[M];
+                  b[M] = b[g], b[g] = A;
+                }
+                var z = p[x];
+                p[x] = p[x - 1], p[x - 1] = z;
+              }
+            }
+            function f(h, d, v, _, b, p) {
+              if (_ <= v + 1) return v;
+              for (var k = v, E = _, T = _ + v >>> 1, L = 2 * h, x = T, C = b[L * T + d]; k < E; ) {
+                if (E - k < u) {
+                  c(h, d, k, E, b, p), C = b[L * T + d];
+                  break;
+                }
+                var M = E - k, g = Math.random() * M + k | 0, P = b[L * g + d], A = Math.random() * M + k | 0, z = b[L * A + d], O = Math.random() * M + k | 0, U = b[L * O + d];
+                P <= z ? U >= z ? (x = A, C = z) : P >= U ? (x = g, C = P) : (x = O, C = U) : z >= U ? (x = A, C = z) : U >= P ? (x = g, C = P) : (x = O, C = U);
+                for (var j = L * (E - 1), N = L * x, G = 0; G < L; ++G, ++j, ++N) {
+                  var Z = b[j];
+                  b[j] = b[N], b[N] = Z;
+                }
+                var H = p[E - 1];
+                p[E - 1] = p[x], p[x] = H, x = l(h, d, k, E - 1, b, p, C);
+                for (var j = L * (E - 1), N = L * x, G = 0; G < L; ++G, ++j, ++N) {
+                  var Z = b[j];
+                  b[j] = b[N], b[N] = Z;
+                }
+                var H = p[E - 1];
+                if (p[E - 1] = p[x], p[x] = H, T < x) {
+                  for (E = x - 1; k < E && b[L * (E - 1) + d] === C; ) E -= 1;
+                  E += 1;
+                } else if (x < T) for (k = x + 1; k < E && b[L * k + d] === C; ) k += 1;
+                else break;
+              }
+              return l(h, d, v, T, b, p, b[L * T + d]);
+            }
+          }, 3576: function(i) {
+            i.exports = a;
+            function a(o, s, l) {
+              return o[0] = s[0] * l[0], o[1] = s[1] * l[1], o[2] = s[2] * l[2], o[3] = s[3] * l[3], o;
+            }
+          }, 3589: function(i, a, o) {
+            i.exports = _;
+            var s = o(2260), l = o(1888), u = o(9618), c = o(8828).nextPow2, f = function(b, p, k) {
+              for (var E = 1e8, T = -1, L = -1, x = b.shape[0], C = b.shape[1], M = 0; M < x; M++) for (var g = 0; g < C; g++) {
+                var P = b.get(M, g, 0), A = b.get(M, g, 1), z = b.get(M, g, 2), O = b.get(M, g, 3);
+                if (P < 255 || A < 255 || z < 255 || O < 255) {
+                  var U = p - M, G = k - g, Z = U * U + G * G;
+                  Z < E && (E = Z, T = M, L = g);
+                }
+              }
+              return [T, L, E];
+            };
+            function h(b, p, k, E, T) {
+              this.coord = [b, p], this.id = k, this.value = E, this.distance = T;
+            }
+            function d(b, p, k) {
+              this.gl = b, this.fbo = p, this.buffer = k, this._readTimeout = null;
+              var E = this;
+              this._readCallback = function() {
+                E.gl && (p.bind(), b.readPixels(0, 0, p.shape[0], p.shape[1], b.RGBA, b.UNSIGNED_BYTE, E.buffer), E._readTimeout = null);
+              };
+            }
+            var v = d.prototype;
+            Object.defineProperty(v, "shape", { get: function() {
+              return this.gl ? this.fbo.shape.slice() : [0, 0];
+            }, set: function(b) {
+              if (this.gl) {
+                this.fbo.shape = b;
+                var p = this.fbo.shape[0], k = this.fbo.shape[1];
+                if (k * p * 4 > this.buffer.length) {
+                  l.free(this.buffer);
+                  for (var E = this.buffer = l.mallocUint8(c(k * p * 4)), T = 0; T < k * p * 4; ++T) E[T] = 255;
+                }
+                return b;
+              }
+            } }), v.begin = function() {
+              var b = this.gl;
+              this.shape;
+              b && (this.fbo.bind(), b.clearColor(1, 1, 1, 1), b.clear(b.COLOR_BUFFER_BIT | b.DEPTH_BUFFER_BIT));
+            }, v.end = function() {
+              var b = this.gl;
+              b && (b.bindFramebuffer(b.FRAMEBUFFER, null), this._readTimeout || clearTimeout(this._readTimeout), this._readTimeout = setTimeout(this._readCallback, 1));
+            }, v.query = function(b, p, k) {
+              if (!this.gl) return null;
+              var E = this.fbo.shape.slice();
+              b = b | 0, p = p | 0, typeof k != "number" && (k = 1);
+              var T = Math.min(Math.max(b - k, 0), E[0]) | 0, L = Math.min(Math.max(b + k, 0), E[0]) | 0, x = Math.min(Math.max(p - k, 0), E[1]) | 0, C = Math.min(Math.max(p + k, 0), E[1]) | 0;
+              if (L <= T || C <= x) return null;
+              var M = [L - T, C - x], g = u(this.buffer, [M[0], M[1], 4], [4, E[0] * 4, 1], 4 * (T + E[0] * x)), P = f(g.hi(M[0], M[1], 1), k, k), A = P[0], z = P[1];
+              if (A < 0 || Math.pow(this.radius, 2) < P[2]) return null;
+              var O = g.get(A, z, 0), U = g.get(A, z, 1), G = g.get(A, z, 2), Z = g.get(A, z, 3);
+              return new h(A + T | 0, z + x | 0, O, [U, G, Z], Math.sqrt(P[2]));
+            }, v.dispose = function() {
+              this.gl && (this.fbo.dispose(), l.free(this.buffer), this.gl = null, this._readTimeout && clearTimeout(this._readTimeout));
+            };
+            function _(b, p) {
+              var k = p[0], E = p[1], T = {}, L = s(b, k, E, T), x = l.mallocUint8(k * E * 4);
+              return new d(b, L, x);
+            }
+          }, 3628: function(i, a, o) {
+            var s = o(1338), l = o(727);
+            function u(h, d) {
+              for (var v = 0, _ = h.length, b = 0; b < _; ++b) v += h[b] * d[b];
+              return v;
+            }
+            function c(h) {
+              var d = h.length;
+              if (d === 0) return [];
+              h[0].length;
+              var _ = s([h.length + 1, h.length + 1], 1), b = s([h.length + 1], 1);
+              _[d][d] = 0;
+              for (var p = 0; p < d; ++p) {
+                for (var k = 0; k <= p; ++k) _[k][p] = _[p][k] = 2 * u(h[p], h[k]);
+                b[p] = u(h[p], h[p]);
+              }
+              for (var E = l(_, b), T = 0, L = E[d + 1], p = 0; p < L.length; ++p) T += L[p];
+              for (var x = new Array(d), p = 0; p < d; ++p) {
+                for (var L = E[p], C = 0, k = 0; k < L.length; ++k) C += L[k];
+                x[p] = C / T;
+              }
+              return x;
+            }
+            function f(h) {
+              if (h.length === 0) return [];
+              for (var d = h[0].length, v = s([d]), _ = c(h), b = 0; b < h.length; ++b) for (var p = 0; p < d; ++p) v[p] += h[b][p] * _[b];
+              return v;
+            }
+            f.barycenetric = c, i.exports = f;
+          }, 3637: function(i, a, o) {
+            i.exports = _;
+            var s = o(6504), l = o(8697), u = o(5572), c = o(7721), f = o(544), h = o(2653), d = o(8987);
+            function v(b, p) {
+              return u(s(b[0], p[1]), s(b[1], p[0]));
+            }
+            function _(b, p, k, E) {
+              var T = f(p, b), L = f(E, k), x = v(T, L);
+              if (c(x) === 0) return null;
+              var C = f(b, k), M = v(L, C), g = l(M, x), P = d(T, g), A = h(b, P);
+              return A;
+            }
+          }, 3642: function(i) {
+            i.exports = { jet: [{ index: 0, rgb: [0, 0, 131] }, { index: 0.125, rgb: [0, 60, 170] }, { index: 0.375, rgb: [5, 255, 255] }, { index: 0.625, rgb: [255, 255, 0] }, { index: 0.875, rgb: [250, 0, 0] }, { index: 1, rgb: [128, 0, 0] }], hsv: [{ index: 0, rgb: [255, 0, 0] }, { index: 0.169, rgb: [253, 255, 2] }, { index: 0.173, rgb: [247, 255, 2] }, { index: 0.337, rgb: [0, 252, 4] }, { index: 0.341, rgb: [0, 252, 10] }, { index: 0.506, rgb: [1, 249, 255] }, { index: 0.671, rgb: [2, 0, 253] }, { index: 0.675, rgb: [8, 0, 253] }, { index: 0.839, rgb: [255, 0, 251] }, { index: 0.843, rgb: [255, 0, 245] }, { index: 1, rgb: [255, 0, 6] }], hot: [{ index: 0, rgb: [0, 0, 0] }, { index: 0.3, rgb: [230, 0, 0] }, { index: 0.6, rgb: [255, 210, 0] }, { index: 1, rgb: [255, 255, 255] }], spring: [{ index: 0, rgb: [255, 0, 255] }, { index: 1, rgb: [255, 255, 0] }], summer: [{ index: 0, rgb: [0, 128, 102] }, { index: 1, rgb: [255, 255, 102] }], autumn: [{ index: 0, rgb: [255, 0, 0] }, { index: 1, rgb: [255, 255, 0] }], winter: [{ index: 0, rgb: [0, 0, 255] }, { index: 1, rgb: [0, 255, 128] }], bone: [{ index: 0, rgb: [0, 0, 0] }, { index: 0.376, rgb: [84, 84, 116] }, { index: 0.753, rgb: [169, 200, 200] }, { index: 1, rgb: [255, 255, 255] }], copper: [{ index: 0, rgb: [0, 0, 0] }, { index: 0.804, rgb: [255, 160, 102] }, { index: 1, rgb: [255, 199, 127] }], greys: [{ index: 0, rgb: [0, 0, 0] }, { index: 1, rgb: [255, 255, 255] }], yignbu: [{ index: 0, rgb: [8, 29, 88] }, { index: 0.125, rgb: [37, 52, 148] }, { index: 0.25, rgb: [34, 94, 168] }, { index: 0.375, rgb: [29, 145, 192] }, { index: 0.5, rgb: [65, 182, 196] }, { index: 0.625, rgb: [127, 205, 187] }, { index: 0.75, rgb: [199, 233, 180] }, { index: 0.875, rgb: [237, 248, 217] }, { index: 1, rgb: [255, 255, 217] }], greens: [{ index: 0, rgb: [0, 68, 27] }, { index: 0.125, rgb: [0, 109, 44] }, { index: 0.25, rgb: [35, 139, 69] }, { index: 0.375, rgb: [65, 171, 93] }, { index: 0.5, rgb: [116, 196, 118] }, { index: 0.625, rgb: [161, 217, 155] }, { index: 0.75, rgb: [199, 233, 192] }, { index: 0.875, rgb: [229, 245, 224] }, { index: 1, rgb: [247, 252, 245] }], yiorrd: [{ index: 0, rgb: [128, 0, 38] }, { index: 0.125, rgb: [189, 0, 38] }, { index: 0.25, rgb: [227, 26, 28] }, { index: 0.375, rgb: [252, 78, 42] }, { index: 0.5, rgb: [253, 141, 60] }, { index: 0.625, rgb: [254, 178, 76] }, { index: 0.75, rgb: [254, 217, 118] }, { index: 0.875, rgb: [255, 237, 160] }, { index: 1, rgb: [255, 255, 204] }], bluered: [{ index: 0, rgb: [0, 0, 255] }, { index: 1, rgb: [255, 0, 0] }], rdbu: [{ index: 0, rgb: [5, 10, 172] }, { index: 0.35, rgb: [106, 137, 247] }, { index: 0.5, rgb: [190, 190, 190] }, { index: 0.6, rgb: [220, 170, 132] }, { index: 0.7, rgb: [230, 145, 90] }, { index: 1, rgb: [178, 10, 28] }], picnic: [{ index: 0, rgb: [0, 0, 255] }, { index: 0.1, rgb: [51, 153, 255] }, { index: 0.2, rgb: [102, 204, 255] }, { index: 0.3, rgb: [153, 204, 255] }, { index: 0.4, rgb: [204, 204, 255] }, { index: 0.5, rgb: [255, 255, 255] }, { index: 0.6, rgb: [255, 204, 255] }, { index: 0.7, rgb: [255, 153, 255] }, { index: 0.8, rgb: [255, 102, 204] }, { index: 0.9, rgb: [255, 102, 102] }, { index: 1, rgb: [255, 0, 0] }], rainbow: [{ index: 0, rgb: [150, 0, 90] }, { index: 0.125, rgb: [0, 0, 200] }, { index: 0.25, rgb: [0, 25, 255] }, { index: 0.375, rgb: [0, 152, 255] }, { index: 0.5, rgb: [44, 255, 150] }, { index: 0.625, rgb: [151, 255, 0] }, { index: 0.75, rgb: [255, 234, 0] }, { index: 0.875, rgb: [255, 111, 0] }, { index: 1, rgb: [255, 0, 0] }], portland: [{ index: 0, rgb: [12, 51, 131] }, { index: 0.25, rgb: [10, 136, 186] }, { index: 0.5, rgb: [242, 211, 56] }, { index: 0.75, rgb: [242, 143, 56] }, { index: 1, rgb: [217, 30, 30] }], blackbody: [{ index: 0, rgb: [0, 0, 0] }, { index: 0.2, rgb: [230, 0, 0] }, { index: 0.4, rgb: [230, 210, 0] }, { index: 0.7, rgb: [255, 255, 255] }, { index: 1, rgb: [160, 200, 255] }], earth: [{ index: 0, rgb: [0, 0, 130] }, { index: 0.1, rgb: [0, 180, 180] }, { index: 0.2, rgb: [40, 210, 40] }, { index: 0.4, rgb: [230, 230, 50] }, { index: 0.6, rgb: [120, 70, 20] }, { index: 1, rgb: [255, 255, 255] }], electric: [{ index: 0, rgb: [0, 0, 0] }, { index: 0.15, rgb: [30, 0, 100] }, { index: 0.4, rgb: [120, 0, 100] }, { index: 0.6, rgb: [160, 90, 0] }, { index: 0.8, rgb: [230, 200, 0] }, { index: 1, rgb: [255, 250, 220] }], alpha: [{ index: 0, rgb: [255, 255, 255, 0] }, { index: 1, rgb: [255, 255, 255, 1] }], viridis: [{ index: 0, rgb: [68, 1, 84] }, { index: 0.13, rgb: [71, 44, 122] }, { index: 0.25, rgb: [59, 81, 139] }, { index: 0.38, rgb: [44, 113, 142] }, { index: 0.5, rgb: [33, 144, 141] }, { index: 0.63, rgb: [39, 173, 129] }, { index: 0.75, rgb: [92, 200, 99] }, { index: 0.88, rgb: [170, 220, 50] }, { index: 1, rgb: [253, 231, 37] }], inferno: [{ index: 0, rgb: [0, 0, 4] }, { index: 0.13, rgb: [31, 12, 72] }, { index: 0.25, rgb: [85, 15, 109] }, { index: 0.38, rgb: [136, 34, 106] }, { index: 0.5, rgb: [186, 54, 85] }, { index: 0.63, rgb: [227, 89, 51] }, { index: 0.75, rgb: [249, 140, 10] }, { index: 0.88, rgb: [249, 201, 50] }, { index: 1, rgb: [252, 255, 164] }], magma: [{ index: 0, rgb: [0, 0, 4] }, { index: 0.13, rgb: [28, 16, 68] }, { index: 0.25, rgb: [79, 18, 123] }, { index: 0.38, rgb: [129, 37, 129] }, { index: 0.5, rgb: [181, 54, 122] }, { index: 0.63, rgb: [229, 80, 100] }, { index: 0.75, rgb: [251, 135, 97] }, { index: 0.88, rgb: [254, 194, 135] }, { index: 1, rgb: [252, 253, 191] }], plasma: [{ index: 0, rgb: [13, 8, 135] }, { index: 0.13, rgb: [75, 3, 161] }, { index: 0.25, rgb: [125, 3, 168] }, { index: 0.38, rgb: [168, 34, 150] }, { index: 0.5, rgb: [203, 70, 121] }, { index: 0.63, rgb: [229, 107, 93] }, { index: 0.75, rgb: [248, 148, 65] }, { index: 0.88, rgb: [253, 195, 40] }, { index: 1, rgb: [240, 249, 33] }], warm: [{ index: 0, rgb: [125, 0, 179] }, { index: 0.13, rgb: [172, 0, 187] }, { index: 0.25, rgb: [219, 0, 170] }, { index: 0.38, rgb: [255, 0, 130] }, { index: 0.5, rgb: [255, 63, 74] }, { index: 0.63, rgb: [255, 123, 0] }, { index: 0.75, rgb: [234, 176, 0] }, { index: 0.88, rgb: [190, 228, 0] }, { index: 1, rgb: [147, 255, 0] }], cool: [{ index: 0, rgb: [125, 0, 179] }, { index: 0.13, rgb: [116, 0, 218] }, { index: 0.25, rgb: [98, 74, 237] }, { index: 0.38, rgb: [68, 146, 231] }, { index: 0.5, rgb: [0, 204, 197] }, { index: 0.63, rgb: [0, 247, 146] }, { index: 0.75, rgb: [0, 255, 88] }, { index: 0.88, rgb: [40, 255, 8] }, { index: 1, rgb: [147, 255, 0] }], "rainbow-soft": [{ index: 0, rgb: [125, 0, 179] }, { index: 0.1, rgb: [199, 0, 180] }, { index: 0.2, rgb: [255, 0, 121] }, { index: 0.3, rgb: [255, 108, 0] }, { index: 0.4, rgb: [222, 194, 0] }, { index: 0.5, rgb: [150, 255, 0] }, { index: 0.6, rgb: [0, 255, 55] }, { index: 0.7, rgb: [0, 246, 150] }, { index: 0.8, rgb: [50, 167, 222] }, { index: 0.9, rgb: [103, 51, 235] }, { index: 1, rgb: [124, 0, 186] }], bathymetry: [{ index: 0, rgb: [40, 26, 44] }, { index: 0.13, rgb: [59, 49, 90] }, { index: 0.25, rgb: [64, 76, 139] }, { index: 0.38, rgb: [63, 110, 151] }, { index: 0.5, rgb: [72, 142, 158] }, { index: 0.63, rgb: [85, 174, 163] }, { index: 0.75, rgb: [120, 206, 163] }, { index: 0.88, rgb: [187, 230, 172] }, { index: 1, rgb: [253, 254, 204] }], cdom: [{ index: 0, rgb: [47, 15, 62] }, { index: 0.13, rgb: [87, 23, 86] }, { index: 0.25, rgb: [130, 28, 99] }, { index: 0.38, rgb: [171, 41, 96] }, { index: 0.5, rgb: [206, 67, 86] }, { index: 0.63, rgb: [230, 106, 84] }, { index: 0.75, rgb: [242, 149, 103] }, { index: 0.88, rgb: [249, 193, 135] }, { index: 1, rgb: [254, 237, 176] }], chlorophyll: [{ index: 0, rgb: [18, 36, 20] }, { index: 0.13, rgb: [25, 63, 41] }, { index: 0.25, rgb: [24, 91, 59] }, { index: 0.38, rgb: [13, 119, 72] }, { index: 0.5, rgb: [18, 148, 80] }, { index: 0.63, rgb: [80, 173, 89] }, { index: 0.75, rgb: [132, 196, 122] }, { index: 0.88, rgb: [175, 221, 162] }, { index: 1, rgb: [215, 249, 208] }], density: [{ index: 0, rgb: [54, 14, 36] }, { index: 0.13, rgb: [89, 23, 80] }, { index: 0.25, rgb: [110, 45, 132] }, { index: 0.38, rgb: [120, 77, 178] }, { index: 0.5, rgb: [120, 113, 213] }, { index: 0.63, rgb: [115, 151, 228] }, { index: 0.75, rgb: [134, 185, 227] }, { index: 0.88, rgb: [177, 214, 227] }, { index: 1, rgb: [230, 241, 241] }], "freesurface-blue": [{ index: 0, rgb: [30, 4, 110] }, { index: 0.13, rgb: [47, 14, 176] }, { index: 0.25, rgb: [41, 45, 236] }, { index: 0.38, rgb: [25, 99, 212] }, { index: 0.5, rgb: [68, 131, 200] }, { index: 0.63, rgb: [114, 156, 197] }, { index: 0.75, rgb: [157, 181, 203] }, { index: 0.88, rgb: [200, 208, 216] }, { index: 1, rgb: [241, 237, 236] }], "freesurface-red": [{ index: 0, rgb: [60, 9, 18] }, { index: 0.13, rgb: [100, 17, 27] }, { index: 0.25, rgb: [142, 20, 29] }, { index: 0.38, rgb: [177, 43, 27] }, { index: 0.5, rgb: [192, 87, 63] }, { index: 0.63, rgb: [205, 125, 105] }, { index: 0.75, rgb: [216, 162, 148] }, { index: 0.88, rgb: [227, 199, 193] }, { index: 1, rgb: [241, 237, 236] }], oxygen: [{ index: 0, rgb: [64, 5, 5] }, { index: 0.13, rgb: [106, 6, 15] }, { index: 0.25, rgb: [144, 26, 7] }, { index: 0.38, rgb: [168, 64, 3] }, { index: 0.5, rgb: [188, 100, 4] }, { index: 0.63, rgb: [206, 136, 11] }, { index: 0.75, rgb: [220, 174, 25] }, { index: 0.88, rgb: [231, 215, 44] }, { index: 1, rgb: [248, 254, 105] }], par: [{ index: 0, rgb: [51, 20, 24] }, { index: 0.13, rgb: [90, 32, 35] }, { index: 0.25, rgb: [129, 44, 34] }, { index: 0.38, rgb: [159, 68, 25] }, { index: 0.5, rgb: [182, 99, 19] }, { index: 0.63, rgb: [199, 134, 22] }, { index: 0.75, rgb: [212, 171, 35] }, { index: 0.88, rgb: [221, 210, 54] }, { index: 1, rgb: [225, 253, 75] }], phase: [{ index: 0, rgb: [145, 105, 18] }, { index: 0.13, rgb: [184, 71, 38] }, { index: 0.25, rgb: [186, 58, 115] }, { index: 0.38, rgb: [160, 71, 185] }, { index: 0.5, rgb: [110, 97, 218] }, { index: 0.63, rgb: [50, 123, 164] }, { index: 0.75, rgb: [31, 131, 110] }, { index: 0.88, rgb: [77, 129, 34] }, { index: 1, rgb: [145, 105, 18] }], salinity: [{ index: 0, rgb: [42, 24, 108] }, { index: 0.13, rgb: [33, 50, 162] }, { index: 0.25, rgb: [15, 90, 145] }, { index: 0.38, rgb: [40, 118, 137] }, { index: 0.5, rgb: [59, 146, 135] }, { index: 0.63, rgb: [79, 175, 126] }, { index: 0.75, rgb: [120, 203, 104] }, { index: 0.88, rgb: [193, 221, 100] }, { index: 1, rgb: [253, 239, 154] }], temperature: [{ index: 0, rgb: [4, 35, 51] }, { index: 0.13, rgb: [23, 51, 122] }, { index: 0.25, rgb: [85, 59, 157] }, { index: 0.38, rgb: [129, 79, 143] }, { index: 0.5, rgb: [175, 95, 130] }, { index: 0.63, rgb: [222, 112, 101] }, { index: 0.75, rgb: [249, 146, 66] }, { index: 0.88, rgb: [249, 196, 65] }, { index: 1, rgb: [232, 250, 91] }], turbidity: [{ index: 0, rgb: [34, 31, 27] }, { index: 0.13, rgb: [65, 50, 41] }, { index: 0.25, rgb: [98, 69, 52] }, { index: 0.38, rgb: [131, 89, 57] }, { index: 0.5, rgb: [161, 112, 59] }, { index: 0.63, rgb: [185, 140, 66] }, { index: 0.75, rgb: [202, 174, 88] }, { index: 0.88, rgb: [216, 209, 126] }, { index: 1, rgb: [233, 246, 171] }], "velocity-blue": [{ index: 0, rgb: [17, 32, 64] }, { index: 0.13, rgb: [35, 52, 116] }, { index: 0.25, rgb: [29, 81, 156] }, { index: 0.38, rgb: [31, 113, 162] }, { index: 0.5, rgb: [50, 144, 169] }, { index: 0.63, rgb: [87, 173, 176] }, { index: 0.75, rgb: [149, 196, 189] }, { index: 0.88, rgb: [203, 221, 211] }, { index: 1, rgb: [254, 251, 230] }], "velocity-green": [{ index: 0, rgb: [23, 35, 19] }, { index: 0.13, rgb: [24, 64, 38] }, { index: 0.25, rgb: [11, 95, 45] }, { index: 0.38, rgb: [39, 123, 35] }, { index: 0.5, rgb: [95, 146, 12] }, { index: 0.63, rgb: [152, 165, 18] }, { index: 0.75, rgb: [201, 186, 69] }, { index: 0.88, rgb: [233, 216, 137] }, { index: 1, rgb: [255, 253, 205] }], cubehelix: [{ index: 0, rgb: [0, 0, 0] }, { index: 0.07, rgb: [22, 5, 59] }, { index: 0.13, rgb: [60, 4, 105] }, { index: 0.2, rgb: [109, 1, 135] }, { index: 0.27, rgb: [161, 0, 147] }, { index: 0.33, rgb: [210, 2, 142] }, { index: 0.4, rgb: [251, 11, 123] }, { index: 0.47, rgb: [255, 29, 97] }, { index: 0.53, rgb: [255, 54, 69] }, { index: 0.6, rgb: [255, 85, 46] }, { index: 0.67, rgb: [255, 120, 34] }, { index: 0.73, rgb: [255, 157, 37] }, { index: 0.8, rgb: [241, 191, 57] }, { index: 0.87, rgb: [224, 220, 93] }, { index: 0.93, rgb: [218, 241, 142] }, { index: 1, rgb: [227, 253, 198] }] };
+          }, 3711: function(i, a, o) {
+            i.exports = d;
+            var s = o(2640), l = o(781), u = { "2d": function(v, _, b) {
+              var p = v({ order: _, scalarArguments: 3, getters: b === "generic" ? [0] : void 0, phase: function(E, T, L, x) {
+                return E > x | 0;
+              }, vertex: function(E, T, L, x, C, M, g, P, A, z, O, U, G) {
+                var Z = (g << 0) + (P << 1) + (A << 2) + (z << 3) | 0;
+                if (!(Z === 0 || Z === 15)) switch (Z) {
+                  case 0:
+                    O.push([E - 0.5, T - 0.5]);
+                    break;
+                  case 1:
+                    O.push([E - 0.25 - 0.25 * (x + L - 2 * G) / (L - x), T - 0.25 - 0.25 * (C + L - 2 * G) / (L - C)]);
+                    break;
+                  case 2:
+                    O.push([E - 0.75 - 0.25 * (-x - L + 2 * G) / (x - L), T - 0.25 - 0.25 * (M + x - 2 * G) / (x - M)]);
+                    break;
+                  case 3:
+                    O.push([E - 0.5, T - 0.5 - 0.5 * (C + L + M + x - 4 * G) / (L - C + x - M)]);
+                    break;
+                  case 4:
+                    O.push([E - 0.25 - 0.25 * (M + C - 2 * G) / (C - M), T - 0.75 - 0.25 * (-C - L + 2 * G) / (C - L)]);
+                    break;
+                  case 5:
+                    O.push([E - 0.5 - 0.5 * (x + L + M + C - 4 * G) / (L - x + C - M), T - 0.5]);
+                    break;
+                  case 6:
+                    O.push([E - 0.5 - 0.25 * (-x - L + M + C) / (x - L + C - M), T - 0.5 - 0.25 * (-C - L + M + x) / (C - L + x - M)]);
+                    break;
+                  case 7:
+                    O.push([E - 0.75 - 0.25 * (M + C - 2 * G) / (C - M), T - 0.75 - 0.25 * (M + x - 2 * G) / (x - M)]);
+                    break;
+                  case 8:
+                    O.push([E - 0.75 - 0.25 * (-M - C + 2 * G) / (M - C), T - 0.75 - 0.25 * (-M - x + 2 * G) / (M - x)]);
+                    break;
+                  case 9:
+                    O.push([E - 0.5 - 0.25 * (x + L + -M - C) / (L - x + M - C), T - 0.5 - 0.25 * (C + L + -M - x) / (L - C + M - x)]);
+                    break;
+                  case 10:
+                    O.push([E - 0.5 - 0.5 * (-x - L + -M - C + 4 * G) / (x - L + M - C), T - 0.5]);
+                    break;
+                  case 11:
+                    O.push([E - 0.25 - 0.25 * (-M - C + 2 * G) / (M - C), T - 0.75 - 0.25 * (C + L - 2 * G) / (L - C)]);
+                    break;
+                  case 12:
+                    O.push([E - 0.5, T - 0.5 - 0.5 * (-C - L + -M - x + 4 * G) / (C - L + M - x)]);
+                    break;
+                  case 13:
+                    O.push([E - 0.75 - 0.25 * (x + L - 2 * G) / (L - x), T - 0.25 - 0.25 * (-M - x + 2 * G) / (M - x)]);
+                    break;
+                  case 14:
+                    O.push([E - 0.25 - 0.25 * (-x - L + 2 * G) / (x - L), T - 0.25 - 0.25 * (-C - L + 2 * G) / (C - L)]);
+                    break;
+                  case 15:
+                    O.push([E - 0.5, T - 0.5]);
+                    break;
+                }
+              }, cell: function(E, T, L, x, C, M, g, P, A) {
+                C ? P.push([E, T]) : P.push([T, E]);
+              } });
+              return function(k, E) {
+                var T = [], L = [];
+                return p(k, T, L, E), { positions: T, cells: L };
+              };
+            } };
+            function c(v, _) {
+              var b = v.length + "d", p = u[b];
+              if (p) return p(s, v, _);
+            }
+            function f(v, _) {
+              for (var b = l(v, _), p = b.length, k = new Array(p), E = new Array(p), T = 0; T < p; ++T) k[T] = [b[T]], E[T] = [T];
+              return { positions: k, cells: E };
+            }
+            var h = {};
+            function d(v, k) {
+              if (v.dimension <= 0) return { positions: [], cells: [] };
+              if (v.dimension === 1) return f(v, k);
+              var b = v.order.join() + "-" + v.dtype, p = h[b], k = +k || 0;
+              return p || (p = h[b] = c(v.order, v.dtype)), p(v, k);
+            }
+          }, 3750: function(i) {
+            i.exports = a;
+            function a(o, s) {
+              return o[0] * s[0] + o[1] * s[1] + o[2] * s[2] + o[3] * s[3];
+            }
+          }, 3778: function(i, a) {
+            a.read = function(o, s, l, u, c) {
+              var f, h, d = c * 8 - u - 1, v = (1 << d) - 1, _ = v >> 1, b = -7, p = l ? c - 1 : 0, k = l ? -1 : 1, E = o[s + p];
+              for (p += k, f = E & (1 << -b) - 1, E >>= -b, b += d; b > 0; f = f * 256 + o[s + p], p += k, b -= 8) ;
+              for (h = f & (1 << -b) - 1, f >>= -b, b += u; b > 0; h = h * 256 + o[s + p], p += k, b -= 8) ;
+              if (f === 0) f = 1 - _;
+              else {
+                if (f === v) return h ? NaN : (E ? -1 : 1) * (1 / 0);
+                h = h + Math.pow(2, u), f = f - _;
+              }
+              return (E ? -1 : 1) * h * Math.pow(2, f - u);
+            }, a.write = function(o, s, l, u, c, f) {
+              var h, d, v, _ = f * 8 - c - 1, b = (1 << _) - 1, p = b >> 1, k = c === 23 ? Math.pow(2, -24) - Math.pow(2, -77) : 0, E = u ? 0 : f - 1, T = u ? 1 : -1, L = s < 0 || s === 0 && 1 / s < 0 ? 1 : 0;
+              for (s = Math.abs(s), isNaN(s) || s === 1 / 0 ? (d = isNaN(s) ? 1 : 0, h = b) : (h = Math.floor(Math.log(s) / Math.LN2), s * (v = Math.pow(2, -h)) < 1 && (h--, v *= 2), h + p >= 1 ? s += k / v : s += k * Math.pow(2, 1 - p), s * v >= 2 && (h++, v /= 2), h + p >= b ? (d = 0, h = b) : h + p >= 1 ? (d = (s * v - 1) * Math.pow(2, c), h = h + p) : (d = s * Math.pow(2, p - 1) * Math.pow(2, c), h = 0)); c >= 8; o[l + E] = d & 255, E += T, d /= 256, c -= 8) ;
+              for (h = h << c | d, _ += c; _ > 0; o[l + E] = h & 255, E += T, h /= 256, _ -= 8) ;
+              o[l + E - T] |= L * 128;
+            };
+          }, 3788: function(i, a, o) {
+            var s = o(8507), l = o(2419);
+            i.exports = u;
+            function u(c, f) {
+              return s(c, f) || l(c) - l(f);
+            }
+          }, 3837: function(i, a, o) {
+            i.exports = O;
+            var s = o(4935), l = o(501), u = o(5304), c = o(6429), f = o(6444), h = new Float32Array([1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1]), d = ArrayBuffer, v = DataView;
+            function _(U) {
+              return d.isView(U) && !(U instanceof v);
+            }
+            function b(U) {
+              return Array.isArray(U) || _(U);
+            }
+            function p(U, G) {
+              return U[0] = G[0], U[1] = G[1], U[2] = G[2], U;
+            }
+            function k(U) {
+              this.gl = U, this.pixelRatio = 1, this.bounds = [[-10, -10, -10], [10, 10, 10]], this.ticks = [[], [], []], this.autoTicks = true, this.tickSpacing = [1, 1, 1], this.tickEnable = [true, true, true], this.tickFont = ["sans-serif", "sans-serif", "sans-serif"], this.tickFontStyle = ["normal", "normal", "normal"], this.tickFontWeight = ["normal", "normal", "normal"], this.tickFontVariant = ["normal", "normal", "normal"], this.tickSize = [12, 12, 12], this.tickAngle = [0, 0, 0], this.tickAlign = ["auto", "auto", "auto"], this.tickColor = [[0, 0, 0, 1], [0, 0, 0, 1], [0, 0, 0, 1]], this.tickPad = [10, 10, 10], this.lastCubeProps = { cubeEdges: [0, 0, 0], axis: [0, 0, 0] }, this.labels = ["x", "y", "z"], this.labelEnable = [true, true, true], this.labelFont = ["sans-serif", "sans-serif", "sans-serif"], this.labelFontStyle = ["normal", "normal", "normal"], this.labelFontWeight = ["normal", "normal", "normal"], this.labelFontVariant = ["normal", "normal", "normal"], this.labelSize = [20, 20, 20], this.labelAngle = [0, 0, 0], this.labelAlign = ["auto", "auto", "auto"], this.labelColor = [[0, 0, 0, 1], [0, 0, 0, 1], [0, 0, 0, 1]], this.labelPad = [10, 10, 10], this.lineEnable = [true, true, true], this.lineMirror = [false, false, false], this.lineWidth = [1, 1, 1], this.lineColor = [[0, 0, 0, 1], [0, 0, 0, 1], [0, 0, 0, 1]], this.lineTickEnable = [true, true, true], this.lineTickMirror = [false, false, false], this.lineTickLength = [0, 0, 0], this.lineTickWidth = [1, 1, 1], this.lineTickColor = [[0, 0, 0, 1], [0, 0, 0, 1], [0, 0, 0, 1]], this.gridEnable = [true, true, true], this.gridWidth = [1, 1, 1], this.gridColor = [[0, 0, 0, 1], [0, 0, 0, 1], [0, 0, 0, 1]], this.zeroEnable = [true, true, true], this.zeroLineColor = [[0, 0, 0, 1], [0, 0, 0, 1], [0, 0, 0, 1]], this.zeroLineWidth = [2, 2, 2], this.backgroundEnable = [false, false, false], this.backgroundColor = [[0.8, 0.8, 0.8, 0.5], [0.8, 0.8, 0.8, 0.5], [0.8, 0.8, 0.8, 0.5]], this._firstInit = true, this._text = null, this._lines = null, this._background = u(U);
+            }
+            var E = k.prototype;
+            E.update = function(U) {
+              U = U || {};
+              function G(Ae, Be, Pe) {
+                if (Pe in U) {
+                  var me = U[Pe], De = this[Pe], ce;
+                  (Ae ? b(me) && b(me[0]) : b(me)) ? this[Pe] = ce = [Be(me[0]), Be(me[1]), Be(me[2])] : this[Pe] = ce = [Be(me), Be(me), Be(me)];
+                  for (var je = 0; je < 3; ++je) if (ce[je] !== De[je]) return true;
+                }
+                return false;
+              }
+              var Z = G.bind(this, false, Number), j = G.bind(this, false, Boolean), N = G.bind(this, false, String), H = G.bind(this, true, function(Ae) {
+                if (b(Ae)) {
+                  if (Ae.length === 3) return [+Ae[0], +Ae[1], +Ae[2], 1];
+                  if (Ae.length === 4) return [+Ae[0], +Ae[1], +Ae[2], +Ae[3]];
+                }
+                return [0, 0, 0, 1];
+              }), re, oe = false, _e = false;
+              if ("bounds" in U) for (var Ce = U.bounds, Le = 0; Le < 2; ++Le) for (var ge = 0; ge < 3; ++ge) Ce[Le][ge] !== this.bounds[Le][ge] && (_e = true), this.bounds[Le][ge] = Ce[Le][ge];
+              if ("ticks" in U) {
+                re = U.ticks, oe = true, this.autoTicks = false;
+                for (var Le = 0; Le < 3; ++Le) this.tickSpacing[Le] = 0;
+              } else Z("tickSpacing") && (this.autoTicks = true, _e = true);
+              if (this._firstInit && ("ticks" in U || "tickSpacing" in U || (this.autoTicks = true), _e = true, oe = true, this._firstInit = false), _e && this.autoTicks && (re = f.create(this.bounds, this.tickSpacing), oe = true), oe) {
+                for (var Le = 0; Le < 3; ++Le) re[Le].sort(function(Be, Pe) {
+                  return Be.x - Pe.x;
+                });
+                f.equal(re, this.ticks) ? oe = false : this.ticks = re;
+              }
+              j("tickEnable"), N("tickFont") && (oe = true), N("tickFontStyle") && (oe = true), N("tickFontWeight") && (oe = true), N("tickFontVariant") && (oe = true), Z("tickSize"), Z("tickAngle"), Z("tickPad"), H("tickColor");
+              var ie = N("labels");
+              N("labelFont") && (ie = true), N("labelFontStyle") && (ie = true), N("labelFontWeight") && (ie = true), N("labelFontVariant") && (ie = true), j("labelEnable"), Z("labelSize"), Z("labelPad"), H("labelColor"), j("lineEnable"), j("lineMirror"), Z("lineWidth"), H("lineColor"), j("lineTickEnable"), j("lineTickMirror"), Z("lineTickLength"), Z("lineTickWidth"), H("lineTickColor"), j("gridEnable"), Z("gridWidth"), H("gridColor"), j("zeroEnable"), H("zeroLineColor"), Z("zeroLineWidth"), j("backgroundEnable"), H("backgroundColor");
+              var Se = [{ family: this.labelFont[0], style: this.labelFontStyle[0], weight: this.labelFontWeight[0], variant: this.labelFontVariant[0] }, { family: this.labelFont[1], style: this.labelFontStyle[1], weight: this.labelFontWeight[1], variant: this.labelFontVariant[1] }, { family: this.labelFont[2], style: this.labelFontStyle[2], weight: this.labelFontWeight[2], variant: this.labelFontVariant[2] }], Ee = [{ family: this.tickFont[0], style: this.tickFontStyle[0], weight: this.tickFontWeight[0], variant: this.tickFontVariant[0] }, { family: this.tickFont[1], style: this.tickFontStyle[1], weight: this.tickFontWeight[1], variant: this.tickFontVariant[1] }, { family: this.tickFont[2], style: this.tickFontStyle[2], weight: this.tickFontWeight[2], variant: this.tickFontVariant[2] }];
+              this._text ? this._text && (ie || oe) && this._text.update(this.bounds, this.labels, Se, this.ticks, Ee) : this._text = s(this.gl, this.bounds, this.labels, Se, this.ticks, Ee), this._lines && oe && (this._lines.dispose(), this._lines = null), this._lines || (this._lines = l(this.gl, this.bounds, this.ticks));
+            };
+            function T() {
+              this.primalOffset = [0, 0, 0], this.primalMinor = [0, 0, 0], this.mirrorOffset = [0, 0, 0], this.mirrorMinor = [0, 0, 0];
+            }
+            var L = [new T(), new T(), new T()];
+            function x(U, G, Z, j, N) {
+              for (var H = U.primalOffset, re = U.primalMinor, oe = U.mirrorOffset, _e = U.mirrorMinor, Ce = j[G], Le = 0; Le < 3; ++Le) if (G !== Le) {
+                var ge = H, ie = oe, Se = re, Ee = _e;
+                Ce & 1 << Le && (ge = oe, ie = H, Se = _e, Ee = re), ge[Le] = Z[0][Le], ie[Le] = Z[1][Le], N[Le] > 0 ? (Se[Le] = -1, Ee[Le] = 0) : (Se[Le] = 0, Ee[Le] = 1);
+              }
+            }
+            var C = [0, 0, 0], M = { model: h, view: h, projection: h, _ortho: false };
+            E.isOpaque = function() {
+              return true;
+            }, E.isTransparent = function() {
+              return false;
+            }, E.drawTransparent = function(U) {
+            };
+            var g = 0, P = [0, 0, 0], A = [0, 0, 0], z = [0, 0, 0];
+            E.draw = function(U) {
+              U = U || M;
+              for (var Pe = this.gl, G = U.model || h, Z = U.view || h, j = U.projection || h, N = this.bounds, H = U._ortho || false, re = c(G, Z, j, N, H), oe = re.cubeEdges, _e = re.axis, Ce = Z[12], Le = Z[13], ge = Z[14], ie = Z[15], Se = H ? 2 : 1, Ee = Se * this.pixelRatio * (j[3] * Ce + j[7] * Le + j[11] * ge + j[15] * ie) / Pe.drawingBufferHeight, Ae = 0; Ae < 3; ++Ae) this.lastCubeProps.cubeEdges[Ae] = oe[Ae], this.lastCubeProps.axis[Ae] = _e[Ae];
+              for (var Be = L, Ae = 0; Ae < 3; ++Ae) x(L[Ae], Ae, this.bounds, oe, _e);
+              for (var Pe = this.gl, me = C, Ae = 0; Ae < 3; ++Ae) this.backgroundEnable[Ae] ? me[Ae] = _e[Ae] : me[Ae] = 0;
+              this._background.draw(G, Z, j, N, me, this.backgroundColor), this._lines.bind(G, Z, j, this);
+              for (var Ae = 0; Ae < 3; ++Ae) {
+                var De = [0, 0, 0];
+                _e[Ae] > 0 ? De[Ae] = N[1][Ae] : De[Ae] = N[0][Ae];
+                for (var ce = 0; ce < 2; ++ce) {
+                  var je = (Ae + 1 + ce) % 3, lt = (Ae + 1 + (ce ^ 1)) % 3;
+                  this.gridEnable[je] && this._lines.drawGrid(je, lt, this.bounds, De, this.gridColor[je], this.gridWidth[je] * this.pixelRatio);
+                }
+                for (var ce = 0; ce < 2; ++ce) {
+                  var je = (Ae + 1 + ce) % 3, lt = (Ae + 1 + (ce ^ 1)) % 3;
+                  this.zeroEnable[lt] && Math.min(N[0][lt], N[1][lt]) <= 0 && Math.max(N[0][lt], N[1][lt]) >= 0 && this._lines.drawZero(je, lt, this.bounds, De, this.zeroLineColor[lt], this.zeroLineWidth[lt] * this.pixelRatio);
+                }
+              }
+              for (var Ae = 0; Ae < 3; ++Ae) {
+                this.lineEnable[Ae] && this._lines.drawAxisLine(Ae, this.bounds, Be[Ae].primalOffset, this.lineColor[Ae], this.lineWidth[Ae] * this.pixelRatio), this.lineMirror[Ae] && this._lines.drawAxisLine(Ae, this.bounds, Be[Ae].mirrorOffset, this.lineColor[Ae], this.lineWidth[Ae] * this.pixelRatio);
+                for (var pt = p(P, Be[Ae].primalMinor), Vt = p(A, Be[Ae].mirrorMinor), ot = this.lineTickLength, ce = 0; ce < 3; ++ce) {
+                  var ut = Ee / G[5 * ce];
+                  pt[ce] *= ot[ce] * ut, Vt[ce] *= ot[ce] * ut;
+                }
+                this.lineTickEnable[Ae] && this._lines.drawAxisTicks(Ae, Be[Ae].primalOffset, pt, this.lineTickColor[Ae], this.lineTickWidth[Ae] * this.pixelRatio), this.lineTickMirror[Ae] && this._lines.drawAxisTicks(Ae, Be[Ae].mirrorOffset, Vt, this.lineTickColor[Ae], this.lineTickWidth[Ae] * this.pixelRatio);
+              }
+              this._lines.unbind(), this._text.bind(G, Z, j, this.pixelRatio);
+              var Wt, Nt = 0.5, $t, sr;
+              function Tr(_t) {
+                sr = [0, 0, 0], sr[_t] = 1;
+              }
+              function fr(_t, It, mt) {
+                var er = (_t + 1) % 3, lr = (_t + 2) % 3, wr = It[er], Lr = It[lr], ti = mt[er], Br = mt[lr];
+                if (wr > 0 && Br > 0) {
+                  Tr(er);
+                  return;
+                } else if (wr > 0 && Br < 0) {
+                  Tr(er);
+                  return;
+                } else if (wr < 0 && Br > 0) {
+                  Tr(er);
+                  return;
+                } else if (wr < 0 && Br < 0) {
+                  Tr(er);
+                  return;
+                } else if (Lr > 0 && ti > 0) {
+                  Tr(lr);
+                  return;
+                } else if (Lr > 0 && ti < 0) {
+                  Tr(lr);
+                  return;
+                } else if (Lr < 0 && ti > 0) {
+                  Tr(lr);
+                  return;
+                } else if (Lr < 0 && ti < 0) {
+                  Tr(lr);
+                  return;
+                }
+              }
+              for (var Ae = 0; Ae < 3; ++Ae) {
+                for (var $e = Be[Ae].primalMinor, St = Be[Ae].mirrorMinor, Qt = p(z, Be[Ae].primalOffset), ce = 0; ce < 3; ++ce) this.lineTickEnable[Ae] && (Qt[ce] += Ee * $e[ce] * Math.max(this.lineTickLength[ce], 0) / G[5 * ce]);
+                var Gt = [0, 0, 0];
+                if (Gt[Ae] = 1, this.tickEnable[Ae]) {
+                  this.tickAngle[Ae] === -3600 ? (this.tickAngle[Ae] = 0, this.tickAlign[Ae] = "auto") : this.tickAlign[Ae] = -1, $t = 1, Wt = [this.tickAlign[Ae], Nt, $t], Wt[0] === "auto" ? Wt[0] = g : Wt[0] = parseInt("" + Wt[0]), sr = [0, 0, 0], fr(Ae, $e, St);
+                  for (var ce = 0; ce < 3; ++ce) Qt[ce] += Ee * $e[ce] * this.tickPad[ce] / G[5 * ce];
+                  this._text.drawTicks(Ae, this.tickSize[Ae], this.tickAngle[Ae], Qt, this.tickColor[Ae], Gt, sr, Wt);
+                }
+                if (this.labelEnable[Ae]) {
+                  $t = 0, sr = [0, 0, 0], this.labels[Ae].length > 4 && (Tr(Ae), $t = 1), Wt = [this.labelAlign[Ae], Nt, $t], Wt[0] === "auto" ? Wt[0] = g : Wt[0] = parseInt("" + Wt[0]);
+                  for (var ce = 0; ce < 3; ++ce) Qt[ce] += Ee * $e[ce] * this.labelPad[ce] / G[5 * ce];
+                  Qt[Ae] += 0.5 * (N[0][Ae] + N[1][Ae]), this._text.drawLabel(Ae, this.labelSize[Ae], this.labelAngle[Ae], Qt, this.labelColor[Ae], [0, 0, 0], sr, Wt);
+                }
+              }
+              this._text.unbind();
+            }, E.dispose = function() {
+              this._text.dispose(), this._lines.dispose(), this._background.dispose(), this._lines = null, this._text = null, this._background = null, this.gl = null;
+            };
+            function O(U, G) {
+              var Z = new k(U);
+              return Z.update(G), Z;
+            }
+          }, 3840: function(i) {
+            i.exports = L;
+            var a = 0, o = 1;
+            function s(x, C, M, g, P, A) {
+              this._color = x, this.key = C, this.value = M, this.left = g, this.right = P, this._count = A;
+            }
+            function l(x) {
+              return new s(x._color, x.key, x.value, x.left, x.right, x._count);
+            }
+            function u(x, C) {
+              return new s(x, C.key, C.value, C.left, C.right, C._count);
+            }
+            function c(x) {
+              x._count = 1 + (x.left ? x.left._count : 0) + (x.right ? x.right._count : 0);
+            }
+            function f(x, C) {
+              this._compare = x, this.root = C;
+            }
+            var h = f.prototype;
+            Object.defineProperty(h, "keys", { get: function() {
+              var x = [];
+              return this.forEach(function(C, M) {
+                x.push(C);
+              }), x;
+            } }), Object.defineProperty(h, "values", { get: function() {
+              var x = [];
+              return this.forEach(function(C, M) {
+                x.push(M);
+              }), x;
+            } }), Object.defineProperty(h, "length", { get: function() {
+              return this.root ? this.root._count : 0;
+            } }), h.insert = function(x, C) {
+              for (var M = this._compare, g = this.root, P = [], A = []; g; ) {
+                var z = M(x, g.key);
+                P.push(g), A.push(z), z <= 0 ? g = g.left : g = g.right;
+              }
+              P.push(new s(a, x, C, null, null, 1));
+              for (var O = P.length - 2; O >= 0; --O) {
+                var g = P[O];
+                A[O] <= 0 ? P[O] = new s(g._color, g.key, g.value, P[O + 1], g.right, g._count + 1) : P[O] = new s(g._color, g.key, g.value, g.left, P[O + 1], g._count + 1);
+              }
+              for (var O = P.length - 1; O > 1; --O) {
+                var U = P[O - 1], g = P[O];
+                if (U._color === o || g._color === o) break;
+                var G = P[O - 2];
+                if (G.left === U) if (U.left === g) {
+                  var Z = G.right;
+                  if (Z && Z._color === a) U._color = o, G.right = u(o, Z), G._color = a, O -= 1;
+                  else {
+                    if (G._color = a, G.left = U.right, U._color = o, U.right = G, P[O - 2] = U, P[O - 1] = g, c(G), c(U), O >= 3) {
+                      var j = P[O - 3];
+                      j.left === G ? j.left = U : j.right = U;
+                    }
+                    break;
+                  }
+                } else {
+                  var Z = G.right;
+                  if (Z && Z._color === a) U._color = o, G.right = u(o, Z), G._color = a, O -= 1;
+                  else {
+                    if (U.right = g.left, G._color = a, G.left = g.right, g._color = o, g.left = U, g.right = G, P[O - 2] = g, P[O - 1] = U, c(G), c(U), c(g), O >= 3) {
+                      var j = P[O - 3];
+                      j.left === G ? j.left = g : j.right = g;
+                    }
+                    break;
+                  }
+                }
+                else if (U.right === g) {
+                  var Z = G.left;
+                  if (Z && Z._color === a) U._color = o, G.left = u(o, Z), G._color = a, O -= 1;
+                  else {
+                    if (G._color = a, G.right = U.left, U._color = o, U.left = G, P[O - 2] = U, P[O - 1] = g, c(G), c(U), O >= 3) {
+                      var j = P[O - 3];
+                      j.right === G ? j.right = U : j.left = U;
+                    }
+                    break;
+                  }
+                } else {
+                  var Z = G.left;
+                  if (Z && Z._color === a) U._color = o, G.left = u(o, Z), G._color = a, O -= 1;
+                  else {
+                    if (U.left = g.right, G._color = a, G.right = g.left, g._color = o, g.right = U, g.left = G, P[O - 2] = g, P[O - 1] = U, c(G), c(U), c(g), O >= 3) {
+                      var j = P[O - 3];
+                      j.right === G ? j.right = g : j.left = g;
+                    }
+                    break;
+                  }
+                }
+              }
+              return P[0]._color = o, new f(M, P[0]);
+            };
+            function d(x, C) {
+              if (C.left) {
+                var M = d(x, C.left);
+                if (M) return M;
+              }
+              var M = x(C.key, C.value);
+              if (M) return M;
+              if (C.right) return d(x, C.right);
+            }
+            function v(x, C, M, g) {
+              var P = C(x, g.key);
+              if (P <= 0) {
+                if (g.left) {
+                  var A = v(x, C, M, g.left);
+                  if (A) return A;
+                }
+                var A = M(g.key, g.value);
+                if (A) return A;
+              }
+              if (g.right) return v(x, C, M, g.right);
+            }
+            function _(x, C, M, g, P) {
+              var A = M(x, P.key), z = M(C, P.key), O;
+              if (A <= 0 && (P.left && (O = _(x, C, M, g, P.left), O) || z > 0 && (O = g(P.key, P.value), O))) return O;
+              if (z > 0 && P.right) return _(x, C, M, g, P.right);
+            }
+            h.forEach = function(C, M, g) {
+              if (this.root) switch (arguments.length) {
+                case 1:
+                  return d(C, this.root);
+                case 2:
+                  return v(M, this._compare, C, this.root);
+                case 3:
+                  return this._compare(M, g) >= 0 ? void 0 : _(M, g, this._compare, C, this.root);
+              }
+            }, Object.defineProperty(h, "begin", { get: function() {
+              for (var x = [], C = this.root; C; ) x.push(C), C = C.left;
+              return new b(this, x);
+            } }), Object.defineProperty(h, "end", { get: function() {
+              for (var x = [], C = this.root; C; ) x.push(C), C = C.right;
+              return new b(this, x);
+            } }), h.at = function(x) {
+              if (x < 0) return new b(this, []);
+              for (var C = this.root, M = []; ; ) {
+                if (M.push(C), C.left) {
+                  if (x < C.left._count) {
+                    C = C.left;
+                    continue;
+                  }
+                  x -= C.left._count;
+                }
+                if (!x) return new b(this, M);
+                if (x -= 1, C.right) {
+                  if (x >= C.right._count) break;
+                  C = C.right;
+                } else break;
+              }
+              return new b(this, []);
+            }, h.ge = function(x) {
+              for (var C = this._compare, M = this.root, g = [], P = 0; M; ) {
+                var A = C(x, M.key);
+                g.push(M), A <= 0 && (P = g.length), A <= 0 ? M = M.left : M = M.right;
+              }
+              return g.length = P, new b(this, g);
+            }, h.gt = function(x) {
+              for (var C = this._compare, M = this.root, g = [], P = 0; M; ) {
+                var A = C(x, M.key);
+                g.push(M), A < 0 && (P = g.length), A < 0 ? M = M.left : M = M.right;
+              }
+              return g.length = P, new b(this, g);
+            }, h.lt = function(x) {
+              for (var C = this._compare, M = this.root, g = [], P = 0; M; ) {
+                var A = C(x, M.key);
+                g.push(M), A > 0 && (P = g.length), A <= 0 ? M = M.left : M = M.right;
+              }
+              return g.length = P, new b(this, g);
+            }, h.le = function(x) {
+              for (var C = this._compare, M = this.root, g = [], P = 0; M; ) {
+                var A = C(x, M.key);
+                g.push(M), A >= 0 && (P = g.length), A < 0 ? M = M.left : M = M.right;
+              }
+              return g.length = P, new b(this, g);
+            }, h.find = function(x) {
+              for (var C = this._compare, M = this.root, g = []; M; ) {
+                var P = C(x, M.key);
+                if (g.push(M), P === 0) return new b(this, g);
+                P <= 0 ? M = M.left : M = M.right;
+              }
+              return new b(this, []);
+            }, h.remove = function(x) {
+              var C = this.find(x);
+              return C ? C.remove() : this;
+            }, h.get = function(x) {
+              for (var C = this._compare, M = this.root; M; ) {
+                var g = C(x, M.key);
+                if (g === 0) return M.value;
+                g <= 0 ? M = M.left : M = M.right;
+              }
+            };
+            function b(x, C) {
+              this.tree = x, this._stack = C;
+            }
+            var p = b.prototype;
+            Object.defineProperty(p, "valid", { get: function() {
+              return this._stack.length > 0;
+            } }), Object.defineProperty(p, "node", { get: function() {
+              return this._stack.length > 0 ? this._stack[this._stack.length - 1] : null;
+            }, enumerable: true }), p.clone = function() {
+              return new b(this.tree, this._stack.slice());
+            };
+            function k(x, C) {
+              x.key = C.key, x.value = C.value, x.left = C.left, x.right = C.right, x._color = C._color, x._count = C._count;
+            }
+            function E(x) {
+              for (var C, M, g, P, A = x.length - 1; A >= 0; --A) {
+                if (C = x[A], A === 0) {
+                  C._color = o;
+                  return;
+                }
+                if (M = x[A - 1], M.left === C) {
+                  if (g = M.right, g.right && g.right._color === a) {
+                    if (g = M.right = l(g), P = g.right = l(g.right), M.right = g.left, g.left = M, g.right = P, g._color = M._color, C._color = o, M._color = o, P._color = o, c(M), c(g), A > 1) {
+                      var z = x[A - 2];
+                      z.left === M ? z.left = g : z.right = g;
+                    }
+                    x[A - 1] = g;
+                    return;
+                  } else if (g.left && g.left._color === a) {
+                    if (g = M.right = l(g), P = g.left = l(g.left), M.right = P.left, g.left = P.right, P.left = M, P.right = g, P._color = M._color, M._color = o, g._color = o, C._color = o, c(M), c(g), c(P), A > 1) {
+                      var z = x[A - 2];
+                      z.left === M ? z.left = P : z.right = P;
+                    }
+                    x[A - 1] = P;
+                    return;
+                  }
+                  if (g._color === o) if (M._color === a) {
+                    M._color = o, M.right = u(a, g);
+                    return;
+                  } else {
+                    M.right = u(a, g);
+                    continue;
+                  }
+                  else {
+                    if (g = l(g), M.right = g.left, g.left = M, g._color = M._color, M._color = a, c(M), c(g), A > 1) {
+                      var z = x[A - 2];
+                      z.left === M ? z.left = g : z.right = g;
+                    }
+                    x[A - 1] = g, x[A] = M, A + 1 < x.length ? x[A + 1] = C : x.push(C), A = A + 2;
+                  }
+                } else {
+                  if (g = M.left, g.left && g.left._color === a) {
+                    if (g = M.left = l(g), P = g.left = l(g.left), M.left = g.right, g.right = M, g.left = P, g._color = M._color, C._color = o, M._color = o, P._color = o, c(M), c(g), A > 1) {
+                      var z = x[A - 2];
+                      z.right === M ? z.right = g : z.left = g;
+                    }
+                    x[A - 1] = g;
+                    return;
+                  } else if (g.right && g.right._color === a) {
+                    if (g = M.left = l(g), P = g.right = l(g.right), M.left = P.right, g.right = P.left, P.right = M, P.left = g, P._color = M._color, M._color = o, g._color = o, C._color = o, c(M), c(g), c(P), A > 1) {
+                      var z = x[A - 2];
+                      z.right === M ? z.right = P : z.left = P;
+                    }
+                    x[A - 1] = P;
+                    return;
+                  }
+                  if (g._color === o) if (M._color === a) {
+                    M._color = o, M.left = u(a, g);
+                    return;
+                  } else {
+                    M.left = u(a, g);
+                    continue;
+                  }
+                  else {
+                    if (g = l(g), M.left = g.right, g.right = M, g._color = M._color, M._color = a, c(M), c(g), A > 1) {
+                      var z = x[A - 2];
+                      z.right === M ? z.right = g : z.left = g;
+                    }
+                    x[A - 1] = g, x[A] = M, A + 1 < x.length ? x[A + 1] = C : x.push(C), A = A + 2;
+                  }
+                }
+              }
+            }
+            p.remove = function() {
+              var x = this._stack;
+              if (x.length === 0) return this.tree;
+              var C = new Array(x.length), M = x[x.length - 1];
+              C[C.length - 1] = new s(M._color, M.key, M.value, M.left, M.right, M._count);
+              for (var g = x.length - 2; g >= 0; --g) {
+                var M = x[g];
+                M.left === x[g + 1] ? C[g] = new s(M._color, M.key, M.value, C[g + 1], M.right, M._count) : C[g] = new s(M._color, M.key, M.value, M.left, C[g + 1], M._count);
+              }
+              if (M = C[C.length - 1], M.left && M.right) {
+                var P = C.length;
+                for (M = M.left; M.right; ) C.push(M), M = M.right;
+                var A = C[P - 1];
+                C.push(new s(M._color, A.key, A.value, M.left, M.right, M._count)), C[P - 1].key = M.key, C[P - 1].value = M.value;
+                for (var g = C.length - 2; g >= P; --g) M = C[g], C[g] = new s(M._color, M.key, M.value, M.left, C[g + 1], M._count);
+                C[P - 1].left = C[P];
+              }
+              if (M = C[C.length - 1], M._color === a) {
+                var z = C[C.length - 2];
+                z.left === M ? z.left = null : z.right === M && (z.right = null), C.pop();
+                for (var g = 0; g < C.length; ++g) C[g]._count--;
+                return new f(this.tree._compare, C[0]);
+              } else if (M.left || M.right) {
+                M.left ? k(M, M.left) : M.right && k(M, M.right), M._color = o;
+                for (var g = 0; g < C.length - 1; ++g) C[g]._count--;
+                return new f(this.tree._compare, C[0]);
+              } else {
+                if (C.length === 1) return new f(this.tree._compare, null);
+                for (var g = 0; g < C.length; ++g) C[g]._count--;
+                var O = C[C.length - 2];
+                E(C), O.left === M ? O.left = null : O.right = null;
+              }
+              return new f(this.tree._compare, C[0]);
+            }, Object.defineProperty(p, "key", { get: function() {
+              if (this._stack.length > 0) return this._stack[this._stack.length - 1].key;
+            }, enumerable: true }), Object.defineProperty(p, "value", { get: function() {
+              if (this._stack.length > 0) return this._stack[this._stack.length - 1].value;
+            }, enumerable: true }), Object.defineProperty(p, "index", { get: function() {
+              var x = 0, C = this._stack;
+              if (C.length === 0) {
+                var M = this.tree.root;
+                return M ? M._count : 0;
+              } else C[C.length - 1].left && (x = C[C.length - 1].left._count);
+              for (var g = C.length - 2; g >= 0; --g) C[g + 1] === C[g].right && (++x, C[g].left && (x += C[g].left._count));
+              return x;
+            }, enumerable: true }), p.next = function() {
+              var x = this._stack;
+              if (x.length !== 0) {
+                var C = x[x.length - 1];
+                if (C.right) for (C = C.right; C; ) x.push(C), C = C.left;
+                else for (x.pop(); x.length > 0 && x[x.length - 1].right === C; ) C = x[x.length - 1], x.pop();
+              }
+            }, Object.defineProperty(p, "hasNext", { get: function() {
+              var x = this._stack;
+              if (x.length === 0) return false;
+              if (x[x.length - 1].right) return true;
+              for (var C = x.length - 1; C > 0; --C) if (x[C - 1].left === x[C]) return true;
+              return false;
+            } }), p.update = function(x) {
+              var C = this._stack;
+              if (C.length === 0) throw new Error("Can't update empty node!");
+              var M = new Array(C.length), g = C[C.length - 1];
+              M[M.length - 1] = new s(g._color, g.key, x, g.left, g.right, g._count);
+              for (var P = C.length - 2; P >= 0; --P) g = C[P], g.left === C[P + 1] ? M[P] = new s(g._color, g.key, g.value, M[P + 1], g.right, g._count) : M[P] = new s(g._color, g.key, g.value, g.left, M[P + 1], g._count);
+              return new f(this.tree._compare, M[0]);
+            }, p.prev = function() {
+              var x = this._stack;
+              if (x.length !== 0) {
+                var C = x[x.length - 1];
+                if (C.left) for (C = C.left; C; ) x.push(C), C = C.right;
+                else for (x.pop(); x.length > 0 && x[x.length - 1].left === C; ) C = x[x.length - 1], x.pop();
+              }
+            }, Object.defineProperty(p, "hasPrev", { get: function() {
+              var x = this._stack;
+              if (x.length === 0) return false;
+              if (x[x.length - 1].left) return true;
+              for (var C = x.length - 1; C > 0; --C) if (x[C - 1].right === x[C]) return true;
+              return false;
+            } });
+            function T(x, C) {
+              return x < C ? -1 : x > C ? 1 : 0;
+            }
+            function L(x) {
+              return new f(x || T, null);
+            }
+          }, 3865: function(i, a, o) {
+            var s = o(869);
+            i.exports = l;
+            function l(u, c) {
+              return s(u[0].mul(c[1]).add(c[0].mul(u[1])), u[1].mul(c[1]));
+            }
+          }, 3952: function(i, a, o) {
+            i.exports = u;
+            var s = o(3250);
+            function l(c, f) {
+              for (var h = new Array(f + 1), d = 0; d < c.length; ++d) h[d] = c[d];
+              for (var d = 0; d <= c.length; ++d) {
+                for (var v = c.length; v <= f; ++v) {
+                  for (var _ = new Array(f), b = 0; b < f; ++b) _[b] = Math.pow(v + 1 - d, b);
+                  h[v] = _;
+                }
+                var p = s.apply(void 0, h);
+                if (p) return true;
+              }
+              return false;
+            }
+            function u(c) {
+              var f = c.length;
+              if (f === 0) return [];
+              if (f === 1) return [0];
+              for (var h = c[0].length, d = [c[0]], v = [0], _ = 1; _ < f; ++_) {
+                if (d.push(c[_]), !l(d, h)) {
+                  d.pop();
+                  continue;
+                }
+                if (v.push(_), v.length === h + 1) return v;
+              }
+              return v;
+            }
+          }, 3990: function(i) {
+            i.exports = a;
+            function a(o, s) {
+              return o[0] = s[0], o[1] = s[1], o[2] = s[2], o;
+            }
+          }, 4008: function(i, a, o) {
+            i.exports = o(6690);
+          }, 4025: function(i, a, o) {
+            var s = o(2361), l = o(8828).countTrailingZeros;
+            i.exports = u;
+            function u(c) {
+              var f = l(s.lo(c));
+              if (f < 32) return f;
+              var h = l(s.hi(c));
+              return h > 20 ? 52 : h + 32;
+            }
+          }, 4040: function(i) {
+            i.exports = a;
+            function a(o, s, l, u, c, f, h) {
+              var d = 1 / (s - l), v = 1 / (u - c), _ = 1 / (f - h);
+              return o[0] = -2 * d, o[1] = 0, o[2] = 0, o[3] = 0, o[4] = 0, o[5] = -2 * v, o[6] = 0, o[7] = 0, o[8] = 0, o[9] = 0, o[10] = 2 * _, o[11] = 0, o[12] = (s + l) * d, o[13] = (c + u) * v, o[14] = (h + f) * _, o[15] = 1, o;
+            }
+          }, 4041: function(i) {
+            i.exports = a;
+            function a(o, s, l) {
+              var u = s[0], c = s[1], f = s[2], h = l[0], d = l[1], v = l[2], _ = l[3], b = _ * u + d * f - v * c, p = _ * c + v * u - h * f, k = _ * f + h * c - d * u, E = -h * u - d * c - v * f;
+              return o[0] = b * _ + E * -h + p * -v - k * -d, o[1] = p * _ + E * -d + k * -h - b * -v, o[2] = k * _ + E * -v + b * -d - p * -h, o[3] = s[3], o;
+            }
+          }, 4081: function(i) {
+            i.exports = a;
+            function a(o, s, l, u, c, f, h, d, v, _) {
+              var b = s + f + _;
+              if (p > 0) {
+                var p = Math.sqrt(b + 1);
+                o[0] = 0.5 * (h - v) / p, o[1] = 0.5 * (d - u) / p, o[2] = 0.5 * (l - f) / p, o[3] = 0.5 * p;
+              } else {
+                var k = Math.max(s, f, _), p = Math.sqrt(2 * k - b + 1);
+                s >= k ? (o[0] = 0.5 * p, o[1] = 0.5 * (c + l) / p, o[2] = 0.5 * (d + u) / p, o[3] = 0.5 * (h - v) / p) : f >= k ? (o[0] = 0.5 * (l + c) / p, o[1] = 0.5 * p, o[2] = 0.5 * (v + h) / p, o[3] = 0.5 * (d - u) / p) : (o[0] = 0.5 * (u + d) / p, o[1] = 0.5 * (h + v) / p, o[2] = 0.5 * p, o[3] = 0.5 * (l - c) / p);
+              }
+              return o;
+            }
+          }, 4100: function(i, a, o) {
+            var s = o(4437), l = o(3837), u = o(5445), c = o(4449), f = o(3589), h = o(2260), d = o(7169), v = o(351), _ = o(4772), b = o(4040), p = o(799), k = o(9216)({ tablet: true, featureDetect: true });
+            i.exports = { createScene: C, createCamera: s };
+            function E() {
+              this.mouse = [-1, -1], this.screen = null, this.distance = 1 / 0, this.index = null, this.dataCoordinate = null, this.dataPosition = null, this.object = null, this.data = null;
+            }
+            function T(g, P) {
+              var A = null;
+              try {
+                A = g.getContext("webgl", P), A || (A = g.getContext("experimental-webgl", P));
+              } catch (z) {
+                return null;
+              }
+              return A;
+            }
+            function L(g) {
+              var P = Math.round(Math.log(Math.abs(g)) / Math.log(10));
+              if (P < 0) {
+                var A = Math.round(Math.pow(10, -P));
+                return Math.ceil(g * A) / A;
+              } else if (P > 0) {
+                var A = Math.round(Math.pow(10, P));
+                return Math.ceil(g / A) * A;
+              }
+              return Math.ceil(g);
+            }
+            function x(g) {
+              return typeof g == "boolean" ? g : true;
+            }
+            function C(g) {
+              g = g || {}, g.camera = g.camera || {};
+              var P = g.canvas;
+              if (!P) if (P = document.createElement("canvas"), g.container) {
+                var A = g.container;
+                A.appendChild(P);
+              } else document.body.appendChild(P);
+              var z = g.gl;
+              if (z || (g.glOptions && (k = !!g.glOptions.preserveDrawingBuffer), z = T(P, g.glOptions || { premultipliedAlpha: true, antialias: true, preserveDrawingBuffer: k })), !z) throw new Error("webgl not supported");
+              var O = g.bounds || [[-10, -10, -10], [10, 10, 10]], U = new E(), G = h(z, z.drawingBufferWidth, z.drawingBufferHeight, { preferFloat: !k }), Z = p(z), j = g.cameraObject && g.cameraObject._ortho === true || g.camera.projection && g.camera.projection.type === "orthographic" || false, N = { eye: g.camera.eye || [2, 0, 0], center: g.camera.center || [0, 0, 0], up: g.camera.up || [0, 1, 0], zoomMin: g.camera.zoomMax || 0.1, zoomMax: g.camera.zoomMin || 100, mode: g.camera.mode || "turntable", _ortho: j }, H = g.axes || {}, re = l(z, H);
+              re.enable = !H.disable;
+              var oe = g.spikes || {}, _e = c(z, oe), Ce = [], Le = [], ge = [], ie = [], Se = true, Pe = true, Ee = new Array(16), Ae = new Array(16), Be = { view: null, projection: Ee, model: Ae, _ortho: false }, Pe = true, me = [z.drawingBufferWidth, z.drawingBufferHeight], De = g.cameraObject || s(P, N), ce = { gl: z, contextLost: false, pixelRatio: g.pixelRatio || 1, canvas: P, selection: U, camera: De, axes: re, axesPixels: null, spikes: _e, bounds: O, objects: Ce, shape: me, aspect: g.aspectRatio || [1, 1, 1], pickRadius: g.pickRadius || 10, zNear: g.zNear || 0.01, zFar: g.zFar || 1e3, fovy: g.fovy || Math.PI / 4, clearColor: g.clearColor || [0, 0, 0, 0], autoResize: x(g.autoResize), autoBounds: x(g.autoBounds), autoScale: !!g.autoScale, autoCenter: x(g.autoCenter), clipToBounds: x(g.clipToBounds), snapToData: !!g.snapToData, onselect: g.onselect || null, onrender: g.onrender || null, onclick: g.onclick || null, cameraParams: Be, oncontextloss: null, mouseListener: null, _stopped: false, getAspectratio: function() {
+                return { x: this.aspect[0], y: this.aspect[1], z: this.aspect[2] };
+              }, setAspectratio: function(sr) {
+                this.aspect[0] = sr.x, this.aspect[1] = sr.y, this.aspect[2] = sr.z, Pe = true;
+              }, setBounds: function(sr, Tr) {
+                this.bounds[0][sr] = Tr.min, this.bounds[1][sr] = Tr.max;
+              }, setClearColor: function(sr) {
+                this.clearColor = sr;
+              }, clearRGBA: function() {
+                this.gl.clearColor(this.clearColor[0], this.clearColor[1], this.clearColor[2], this.clearColor[3]), this.gl.clear(this.gl.COLOR_BUFFER_BIT | this.gl.DEPTH_BUFFER_BIT);
+              } }, je = [z.drawingBufferWidth / ce.pixelRatio | 0, z.drawingBufferHeight / ce.pixelRatio | 0];
+              function lt() {
+                if (!ce._stopped && ce.autoResize) {
+                  var sr = P.parentNode, Tr = 1, fr = 1;
+                  sr && sr !== document.body ? (Tr = sr.clientWidth, fr = sr.clientHeight) : (Tr = window.innerWidth, fr = window.innerHeight);
+                  var $e = Math.ceil(Tr * ce.pixelRatio) | 0, St = Math.ceil(fr * ce.pixelRatio) | 0;
+                  if ($e !== P.width || St !== P.height) {
+                    P.width = $e, P.height = St;
+                    var Qt = P.style;
+                    Qt.position = Qt.position || "absolute", Qt.left = "0px", Qt.top = "0px", Qt.width = Tr + "px", Qt.height = fr + "px", Se = true;
+                  }
+                }
+              }
+              ce.autoResize && lt(), window.addEventListener("resize", lt);
+              function pt() {
+                for (var sr = Ce.length, Tr = ie.length, fr = 0; fr < Tr; ++fr) ge[fr] = 0;
+                e: for (var fr = 0; fr < sr; ++fr) {
+                  var $e = Ce[fr], St = $e.pickSlots;
+                  if (!St) {
+                    Le[fr] = -1;
+                    continue;
+                  }
+                  for (var Qt = 0; Qt < Tr; ++Qt) if (ge[Qt] + St < 255) {
+                    Le[fr] = Qt, $e.setPickBase(ge[Qt] + 1), ge[Qt] += St;
+                    continue e;
+                  }
+                  var Gt = f(z, me);
+                  Le[fr] = Tr, ie.push(Gt), ge.push(St), $e.setPickBase(1), Tr += 1;
+                }
+                for (; Tr > 0 && ge[Tr - 1] === 0; ) ge.pop(), ie.pop().dispose();
+              }
+              ce.update = function(sr) {
+                ce._stopped || (Se = true, Pe = true);
+              }, ce.add = function(sr) {
+                ce._stopped || (sr.axes = re, Ce.push(sr), Le.push(-1), Se = true, Pe = true, pt());
+              }, ce.remove = function(sr) {
+                if (!ce._stopped) {
+                  var Tr = Ce.indexOf(sr);
+                  Tr < 0 || (Ce.splice(Tr, 1), Le.pop(), Se = true, Pe = true, pt());
+                }
+              }, ce.dispose = function() {
+                if (!ce._stopped && (ce._stopped = true, window.removeEventListener("resize", lt), P.removeEventListener("webglcontextlost", Vt), ce.mouseListener.enabled = false, !ce.contextLost)) {
+                  re.dispose(), _e.dispose();
+                  for (var sr = 0; sr < Ce.length; ++sr) Ce[sr].dispose();
+                  G.dispose();
+                  for (var sr = 0; sr < ie.length; ++sr) ie[sr].dispose();
+                  Z.dispose(), z = null, re = null, _e = null, Ce = [];
+                }
+              }, ce._mouseRotating = false, ce._prevButtons = 0, ce.enableMouseListeners = function() {
+                ce.mouseListener = v(P, function(sr, Tr, fr) {
+                  if (!ce._stopped) {
+                    var $e = ie.length, St = Ce.length, Qt = U.object;
+                    U.distance = 1 / 0, U.mouse[0] = Tr, U.mouse[1] = fr, U.object = null, U.screen = null, U.dataCoordinate = U.dataPosition = null;
+                    var Gt = false;
+                    if (sr && ce._prevButtons) ce._mouseRotating = true;
+                    else {
+                      ce._mouseRotating && (Pe = true), ce._mouseRotating = false;
+                      for (var _t = 0; _t < $e; ++_t) {
+                        var It = ie[_t].query(Tr, je[1] - fr - 1, ce.pickRadius);
+                        if (It) {
+                          if (It.distance > U.distance) continue;
+                          for (var mt = 0; mt < St; ++mt) {
+                            var er = Ce[mt];
+                            if (Le[mt] === _t) {
+                              var lr = er.pick(It);
+                              lr && (U.buttons = sr, U.screen = It.coord, U.distance = It.distance, U.object = er, U.index = lr.distance, U.dataPosition = lr.position, U.dataCoordinate = lr.dataCoordinate, U.data = lr, Gt = true);
+                            }
+                          }
+                        }
+                      }
+                    }
+                    Qt && Qt !== U.object && (Qt.highlight && Qt.highlight(null), Se = true), U.object && (U.object.highlight && U.object.highlight(U.data), Se = true), Gt = Gt || U.object !== Qt, Gt && ce.onselect && ce.onselect(U), sr & 1 && !(ce._prevButtons & 1) && ce.onclick && ce.onclick(U), ce._prevButtons = sr;
+                  }
+                });
+              };
+              function Vt() {
+                if (ce.contextLost) return true;
+                z.isContextLost() && (ce.contextLost = true, ce.mouseListener.enabled = false, ce.selection.object = null, ce.oncontextloss && ce.oncontextloss());
+              }
+              P.addEventListener("webglcontextlost", Vt);
+              function ot() {
+                if (!Vt()) {
+                  z.colorMask(true, true, true, true), z.depthMask(true), z.disable(z.BLEND), z.enable(z.DEPTH_TEST), z.depthFunc(z.LEQUAL);
+                  for (var sr = Ce.length, Tr = ie.length, fr = 0; fr < Tr; ++fr) {
+                    var $e = ie[fr];
+                    $e.shape = je, $e.begin();
+                    for (var St = 0; St < sr; ++St) if (Le[St] === fr) {
+                      var Qt = Ce[St];
+                      Qt.drawPick && (Qt.pixelRatio = 1, Qt.drawPick(Be));
+                    }
+                    $e.end();
+                  }
+                }
+              }
+              var ut = [[1 / 0, 1 / 0, 1 / 0], [-1 / 0, -1 / 0, -1 / 0]], Wt = [ut[0].slice(), ut[1].slice()];
+              function Nt() {
+                if (!Vt()) {
+                  lt();
+                  var sr = ce.camera.tick();
+                  Be.view = ce.camera.matrix, Se = Se || sr, Pe = Pe || sr, re.pixelRatio = ce.pixelRatio, _e.pixelRatio = ce.pixelRatio;
+                  var Tr = Ce.length, fr = ut[0], $e = ut[1];
+                  fr[0] = fr[1] = fr[2] = 1 / 0, $e[0] = $e[1] = $e[2] = -1 / 0;
+                  for (var St = 0; St < Tr; ++St) {
+                    var Qt = Ce[St];
+                    Qt.pixelRatio = ce.pixelRatio, Qt.axes = ce.axes, Se = Se || !!Qt.dirty, Pe = Pe || !!Qt.dirty;
+                    var Gt = Qt.bounds;
+                    if (Gt) for (var _t = Gt[0], It = Gt[1], mt = 0; mt < 3; ++mt) fr[mt] = Math.min(fr[mt], _t[mt]), $e[mt] = Math.max($e[mt], It[mt]);
+                  }
+                  var er = ce.bounds;
+                  if (ce.autoBounds) for (var mt = 0; mt < 3; ++mt) {
+                    if ($e[mt] < fr[mt]) fr[mt] = -1, $e[mt] = 1;
+                    else {
+                      fr[mt] === $e[mt] && (fr[mt] -= 1, $e[mt] += 1);
+                      var lr = 0.05 * ($e[mt] - fr[mt]);
+                      fr[mt] = fr[mt] - lr, $e[mt] = $e[mt] + lr;
+                    }
+                    er[0][mt] = fr[mt], er[1][mt] = $e[mt];
+                  }
+                  for (var wr = false, mt = 0; mt < 3; ++mt) wr = wr || Wt[0][mt] !== er[0][mt] || Wt[1][mt] !== er[1][mt], Wt[0][mt] = er[0][mt], Wt[1][mt] = er[1][mt];
+                  if (Pe = Pe || wr, Se = Se || wr, !!Se) {
+                    if (wr) {
+                      for (var Lr = [0, 0, 0], St = 0; St < 3; ++St) Lr[St] = L((er[1][St] - er[0][St]) / 10);
+                      re.autoTicks ? re.update({ bounds: er, tickSpacing: Lr }) : re.update({ bounds: er });
+                    }
+                    var ti = z.drawingBufferWidth, Br = z.drawingBufferHeight;
+                    me[0] = ti, me[1] = Br, je[0] = Math.max(ti / ce.pixelRatio, 1) | 0, je[1] = Math.max(Br / ce.pixelRatio, 1) | 0, M(ce, j);
+                    for (var St = 0; St < Tr; ++St) {
+                      var Qt = Ce[St];
+                      Qt.axesBounds = er, ce.clipToBounds && (Qt.clipBounds = er);
+                    }
+                    U.object && (ce.snapToData ? _e.position = U.dataCoordinate : _e.position = U.dataPosition, _e.bounds = er), Pe && (Pe = false, ot()), ce.axesPixels = u(ce.axes, Be, ti, Br), ce.onrender && ce.onrender(), z.bindFramebuffer(z.FRAMEBUFFER, null), z.viewport(0, 0, ti, Br), ce.clearRGBA(), z.depthMask(true), z.colorMask(true, true, true, true), z.enable(z.DEPTH_TEST), z.depthFunc(z.LEQUAL), z.disable(z.BLEND), z.disable(z.CULL_FACE);
+                    var Vr = false;
+                    re.enable && (Vr = Vr || re.isTransparent(), re.draw(Be)), _e.axes = re, U.object && _e.draw(Be), z.disable(z.CULL_FACE);
+                    for (var St = 0; St < Tr; ++St) {
+                      var Qt = Ce[St];
+                      Qt.axes = re, Qt.pixelRatio = ce.pixelRatio, Qt.isOpaque && Qt.isOpaque() && Qt.draw(Be), Qt.isTransparent && Qt.isTransparent() && (Vr = true);
+                    }
+                    if (Vr) {
+                      G.shape = me, G.bind(), z.clear(z.DEPTH_BUFFER_BIT), z.colorMask(false, false, false, false), z.depthMask(true), z.depthFunc(z.LESS), re.enable && re.isTransparent() && re.drawTransparent(Be);
+                      for (var St = 0; St < Tr; ++St) {
+                        var Qt = Ce[St];
+                        Qt.isOpaque && Qt.isOpaque() && Qt.draw(Be);
+                      }
+                      z.enable(z.BLEND), z.blendEquation(z.FUNC_ADD), z.blendFunc(z.ONE, z.ONE_MINUS_SRC_ALPHA), z.colorMask(true, true, true, true), z.depthMask(false), z.clearColor(0, 0, 0, 0), z.clear(z.COLOR_BUFFER_BIT), re.isTransparent() && re.drawTransparent(Be);
+                      for (var St = 0; St < Tr; ++St) {
+                        var Qt = Ce[St];
+                        Qt.isTransparent && Qt.isTransparent() && Qt.drawTransparent(Be);
+                      }
+                      z.bindFramebuffer(z.FRAMEBUFFER, null), z.blendFunc(z.ONE, z.ONE_MINUS_SRC_ALPHA), z.disable(z.DEPTH_TEST), Z.bind(), G.color[0].bind(0), Z.uniforms.accumBuffer = 0, d(z), z.disable(z.BLEND);
+                    }
+                    Se = false;
+                    for (var St = 0; St < Tr; ++St) Ce[St].dirty = false;
+                  }
+                }
+              }
+              function $t() {
+                ce._stopped || ce.contextLost || (Nt(), requestAnimationFrame($t));
+              }
+              return ce.enableMouseListeners(), $t(), ce.redraw = function() {
+                ce._stopped || (Se = true, Nt());
+              }, ce;
+            }
+            function M(g, P) {
+              var A = g.bounds, z = g.cameraParams, O = z.projection, U = z.model, G = g.gl.drawingBufferWidth, Z = g.gl.drawingBufferHeight, j = g.zNear, N = g.zFar, H = g.fovy, re = G / Z;
+              P ? (b(O, -re, re, -1, 1, j, N), z._ortho = true) : (_(O, H, re, j, N), z._ortho = false);
+              for (var oe = 0; oe < 16; ++oe) U[oe] = 0;
+              U[15] = 1;
+              for (var _e = 0, oe = 0; oe < 3; ++oe) _e = Math.max(_e, A[1][oe] - A[0][oe]);
+              for (var oe = 0; oe < 3; ++oe) g.autoScale ? U[5 * oe] = g.aspect[oe] / (A[1][oe] - A[0][oe]) : U[5 * oe] = 1 / _e, g.autoCenter && (U[12 + oe] = -U[5 * oe] * 0.5 * (A[0][oe] + A[1][oe]));
+            }
+          }, 4192: function(i) {
+            i.exports = o;
+            var a = 32;
+            function o(_, b) {
+              b <= 4 * a ? s(0, b - 1, _) : v(0, b - 1, _);
+            }
+            function s(_, b, p) {
+              for (var k = 2 * (_ + 1), E = _ + 1; E <= b; ++E) {
+                for (var T = p[k++], L = p[k++], x = E, C = k - 2; x-- > _; ) {
+                  var M = p[C - 2], g = p[C - 1];
+                  if (M < T) break;
+                  if (M === T && g < L) break;
+                  p[C] = M, p[C + 1] = g, C -= 2;
+                }
+                p[C] = T, p[C + 1] = L;
+              }
+            }
+            function l(_, b, p) {
+              _ *= 2, b *= 2;
+              var k = p[_], E = p[_ + 1];
+              p[_] = p[b], p[_ + 1] = p[b + 1], p[b] = k, p[b + 1] = E;
+            }
+            function u(_, b, p) {
+              _ *= 2, b *= 2, p[_] = p[b], p[_ + 1] = p[b + 1];
+            }
+            function c(_, b, p, k) {
+              _ *= 2, b *= 2, p *= 2;
+              var E = k[_], T = k[_ + 1];
+              k[_] = k[b], k[_ + 1] = k[b + 1], k[b] = k[p], k[b + 1] = k[p + 1], k[p] = E, k[p + 1] = T;
+            }
+            function f(_, b, p, k, E) {
+              _ *= 2, b *= 2, E[_] = E[b], E[b] = p, E[_ + 1] = E[b + 1], E[b + 1] = k;
+            }
+            function h(_, b, p) {
+              _ *= 2, b *= 2;
+              var k = p[_], E = p[b];
+              return k < E ? false : k === E ? p[_ + 1] > p[b + 1] : true;
+            }
+            function d(_, b, p, k) {
+              _ *= 2;
+              var E = k[_];
+              return E < b ? true : E === b ? k[_ + 1] < p : false;
+            }
+            function v(_, b, p) {
+              var k = (b - _ + 1) / 6 | 0, E = _ + k, T = b - k, L = _ + b >> 1, x = L - k, C = L + k, M = E, g = x, P = L, A = C, z = T, O = _ + 1, U = b - 1, G = 0;
+              h(M, g, p) && (G = M, M = g, g = G), h(A, z, p) && (G = A, A = z, z = G), h(M, P, p) && (G = M, M = P, P = G), h(g, P, p) && (G = g, g = P, P = G), h(M, A, p) && (G = M, M = A, A = G), h(P, A, p) && (G = P, P = A, A = G), h(g, z, p) && (G = g, g = z, z = G), h(g, P, p) && (G = g, g = P, P = G), h(A, z, p) && (G = A, A = z, z = G);
+              for (var Z = p[2 * g], j = p[2 * g + 1], N = p[2 * A], H = p[2 * A + 1], re = 2 * M, oe = 2 * P, _e = 2 * z, Ce = 2 * E, Le = 2 * L, ge = 2 * T, ie = 0; ie < 2; ++ie) {
+                var Se = p[re + ie], Ee = p[oe + ie], Ae = p[_e + ie];
+                p[Ce + ie] = Se, p[Le + ie] = Ee, p[ge + ie] = Ae;
+              }
+              u(x, _, p), u(C, b, p);
+              for (var Be = O; Be <= U; ++Be) if (d(Be, Z, j, p)) Be !== O && l(Be, O, p), ++O;
+              else if (!d(Be, N, H, p)) for (; ; ) if (d(U, N, H, p)) {
+                d(U, Z, j, p) ? (c(Be, O, U, p), ++O, --U) : (l(Be, U, p), --U);
+                break;
+              } else {
+                if (--U < Be) break;
+                continue;
+              }
+              f(_, O - 1, Z, j, p), f(b, U + 1, N, H, p), O - 2 - _ <= a ? s(_, O - 2, p) : v(_, O - 2, p), b - (U + 2) <= a ? s(U + 2, b, p) : v(U + 2, b, p), U - O <= a ? s(O, U, p) : v(O, U, p);
+            }
+          }, 4209: function(i, a, o) {
+            i.exports = p;
+            var s = o(2478), l = o(3840), u = o(3250), c = o(1303);
+            function f(k, E, T) {
+              this.slabs = k, this.coordinates = E, this.horizontal = T;
+            }
+            var h = f.prototype;
+            function d(k, E) {
+              return k.y - E;
+            }
+            function v(k, E) {
+              for (var T = null; k; ) {
+                var L = k.key, x, C;
+                L[0][0] < L[1][0] ? (x = L[0], C = L[1]) : (x = L[1], C = L[0]);
+                var M = u(x, C, E);
+                if (M < 0) k = k.left;
+                else if (M > 0) if (E[0] !== L[1][0]) T = k, k = k.right;
+                else {
+                  var g = v(k.right, E);
+                  if (g) return g;
+                  k = k.left;
+                }
+                else {
+                  if (E[0] !== L[1][0]) return k;
+                  var g = v(k.right, E);
+                  if (g) return g;
+                  k = k.left;
+                }
+              }
+              return T;
+            }
+            h.castUp = function(k) {
+              var E = s.le(this.coordinates, k[0]);
+              if (E < 0) return -1;
+              this.slabs[E];
+              var L = v(this.slabs[E], k), x = -1;
+              if (L && (x = L.value), this.coordinates[E] === k[0]) {
+                var C = null;
+                if (L && (C = L.key), E > 0) {
+                  var M = v(this.slabs[E - 1], k);
+                  M && (C ? c(M.key, C) > 0 && (C = M.key, x = M.value) : (x = M.value, C = M.key));
+                }
+                var g = this.horizontal[E];
+                if (g.length > 0) {
+                  var P = s.ge(g, k[1], d);
+                  if (P < g.length) {
+                    var A = g[P];
+                    if (k[1] === A.y) {
+                      if (A.closed) return A.index;
+                      for (; P < g.length - 1 && g[P + 1].y === k[1]; ) if (P = P + 1, A = g[P], A.closed) return A.index;
+                      if (A.y === k[1] && !A.start) {
+                        if (P = P + 1, P >= g.length) return x;
+                        A = g[P];
+                      }
+                    }
+                    if (A.start) if (C) {
+                      var z = u(C[0], C[1], [k[0], A.y]);
+                      C[0][0] > C[1][0] && (z = -z), z > 0 && (x = A.index);
+                    } else x = A.index;
+                    else A.y !== k[1] && (x = A.index);
+                  }
+                }
+              }
+              return x;
+            };
+            function _(k, E, T, L) {
+              this.y = k, this.index = E, this.start = T, this.closed = L;
+            }
+            function b(k, E, T, L) {
+              this.x = k, this.segment = E, this.create = T, this.index = L;
+            }
+            function p(k) {
+              for (var E = k.length, T = 2 * E, L = new Array(T), x = 0; x < E; ++x) {
+                var C = k[x], M = C[0][0] < C[1][0];
+                L[2 * x] = new b(C[0][0], C, M, x), L[2 * x + 1] = new b(C[1][0], C, !M, x);
+              }
+              L.sort(function(j, N) {
+                var H = j.x - N.x;
+                return H || (H = j.create - N.create, H) ? H : Math.min(j.segment[0][1], j.segment[1][1]) - Math.min(N.segment[0][1], N.segment[1][1]);
+              });
+              for (var g = l(c), P = [], A = [], z = [], O = -1 / 0, x = 0; x < T; ) {
+                for (var U = L[x].x, G = []; x < T; ) {
+                  var Z = L[x];
+                  if (Z.x !== U) break;
+                  x += 1, Z.segment[0][0] === Z.x && Z.segment[1][0] === Z.x ? Z.create && (Z.segment[0][1] < Z.segment[1][1] ? (G.push(new _(Z.segment[0][1], Z.index, true, true)), G.push(new _(Z.segment[1][1], Z.index, false, false))) : (G.push(new _(Z.segment[1][1], Z.index, true, false)), G.push(new _(Z.segment[0][1], Z.index, false, true)))) : Z.create ? g = g.insert(Z.segment, Z.index) : g = g.remove(Z.segment);
+                }
+                P.push(g.root), A.push(U), z.push(G);
+              }
+              return new f(P, A, z);
+            }
+          }, 4317: function(i) {
+            function a(c, f) {
+              var h = Math.floor(f), d = f - h, v = 0 <= h && h < c.shape[0], _ = 0 <= h + 1 && h + 1 < c.shape[0], b = v ? +c.get(h) : 0, p = _ ? +c.get(h + 1) : 0;
+              return (1 - d) * b + d * p;
+            }
+            function o(c, f, h) {
+              var d = Math.floor(f), v = f - d, _ = 0 <= d && d < c.shape[0], b = 0 <= d + 1 && d + 1 < c.shape[0], p = Math.floor(h), k = h - p, E = 0 <= p && p < c.shape[1], T = 0 <= p + 1 && p + 1 < c.shape[1], L = _ && E ? c.get(d, p) : 0, x = _ && T ? c.get(d, p + 1) : 0, C = b && E ? c.get(d + 1, p) : 0, M = b && T ? c.get(d + 1, p + 1) : 0;
+              return (1 - k) * ((1 - v) * L + v * C) + k * ((1 - v) * x + v * M);
+            }
+            function s(c, f, h, d) {
+              var v = Math.floor(f), _ = f - v, b = 0 <= v && v < c.shape[0], p = 0 <= v + 1 && v + 1 < c.shape[0], k = Math.floor(h), E = h - k, T = 0 <= k && k < c.shape[1], L = 0 <= k + 1 && k + 1 < c.shape[1], x = Math.floor(d), C = d - x, M = 0 <= x && x < c.shape[2], g = 0 <= x + 1 && x + 1 < c.shape[2], P = b && T && M ? c.get(v, k, x) : 0, A = b && L && M ? c.get(v, k + 1, x) : 0, z = p && T && M ? c.get(v + 1, k, x) : 0, O = p && L && M ? c.get(v + 1, k + 1, x) : 0, U = b && T && g ? c.get(v, k, x + 1) : 0, G = b && L && g ? c.get(v, k + 1, x + 1) : 0, Z = p && T && g ? c.get(v + 1, k, x + 1) : 0, j = p && L && g ? c.get(v + 1, k + 1, x + 1) : 0;
+              return (1 - C) * ((1 - E) * ((1 - _) * P + _ * z) + E * ((1 - _) * A + _ * O)) + C * ((1 - E) * ((1 - _) * U + _ * Z) + E * ((1 - _) * G + _ * j));
+            }
+            function l(c) {
+              var f = c.shape.length | 0, h = new Array(f), d = new Array(f), v = new Array(f), _ = new Array(f), b, p;
+              for (b = 0; b < f; ++b) p = +arguments[b + 1], h[b] = Math.floor(p), d[b] = p - h[b], v[b] = 0 <= h[b] && h[b] < c.shape[b], _[b] = 0 <= h[b] + 1 && h[b] + 1 < c.shape[b];
+              var k = 0, E, T, L;
+              e: for (b = 0; b < 1 << f; ++b) {
+                for (T = 1, L = c.offset, E = 0; E < f; ++E) if (b & 1 << E) {
+                  if (!_[E]) continue e;
+                  T *= d[E], L += c.stride[E] * (h[E] + 1);
+                } else {
+                  if (!v[E]) continue e;
+                  T *= 1 - d[E], L += c.stride[E] * h[E];
+                }
+                k += T * c.data[L];
+              }
+              return k;
+            }
+            function u(c, f, h, d) {
+              switch (c.shape.length) {
+                case 0:
+                  return 0;
+                case 1:
+                  return a(c, f);
+                case 2:
+                  return o(c, f, h);
+                case 3:
+                  return s(c, f, h, d);
+                default:
+                  return l.apply(void 0, arguments);
+              }
+            }
+            i.exports = u, i.exports.d1 = a, i.exports.d2 = o, i.exports.d3 = s;
+          }, 4335: function(i) {
+            i.exports = function(o, s) {
+              var l = s[15];
+              if (l === 0) return false;
+              for (var u = 1 / l, c = 0; c < 16; c++) o[c] = s[c] * u;
+              return true;
+            };
+          }, 4359: function(i, a, o) {
+            i.exports = c;
+            var s = o(7718), l = null, u = null;
+            typeof document != "undefined" && (l = document.createElement("canvas"), l.width = 8192, l.height = 1024, u = l.getContext("2d"));
+            function c(f, h) {
+              return (typeof h != "object" || h === null) && (h = {}), s(f, h.canvas || l, h.context || u, h);
+            }
+          }, 4361: function(i) {
+            i.exports = a;
+            function a(o, s, l) {
+              return o[0] = s[0] + l[0], o[1] = s[1] + l[1], o[2] = s[2] + l[2], o[3] = s[3] + l[3], o;
+            }
+          }, 4437: function(i, a, o) {
+            i.exports = d;
+            var s = o(3025), l = o(6296), u = o(351), c = o(8512), f = o(24), h = o(7520);
+            function d(v, _) {
+              v = v || document.body, _ = _ || {};
+              var b = [0.01, 1 / 0];
+              "distanceLimits" in _ && (b[0] = _.distanceLimits[0], b[1] = _.distanceLimits[1]), "zoomMin" in _ && (b[0] = _.zoomMin), "zoomMax" in _ && (b[1] = _.zoomMax);
+              var p = l({ center: _.center || [0, 0, 0], up: _.up || [0, 1, 0], eye: _.eye || [0, 0, 10], mode: _.mode || "orbit", distanceLimits: b }), k = [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], E = 0, T = v.clientWidth, L = v.clientHeight, x = { keyBindingMode: "rotate", enableWheel: true, view: p, element: v, delay: _.delay || 16, rotateSpeed: _.rotateSpeed || 1, zoomSpeed: _.zoomSpeed || 1, translateSpeed: _.translateSpeed || 1, flipX: !!_.flipX, flipY: !!_.flipY, modes: p.modes, _ortho: _._ortho || _.projection && _.projection.type === "orthographic" || false, tick: function() {
+                var C = s(), M = this.delay, g = C - 2 * M;
+                p.idle(C - M), p.recalcMatrix(g), p.flush(C - (100 + M * 2));
+                for (var P = true, A = p.computedMatrix, z = 0; z < 16; ++z) P = P && k[z] === A[z], k[z] = A[z];
+                var O = v.clientWidth === T && v.clientHeight === L;
+                return T = v.clientWidth, L = v.clientHeight, P ? !O : (E = Math.exp(p.computedRadius[0]), true);
+              }, lookAt: function(C, M, g) {
+                p.lookAt(p.lastT(), C, M, g);
+              }, rotate: function(C, M, g) {
+                p.rotate(p.lastT(), C, M, g);
+              }, pan: function(C, M, g) {
+                p.pan(p.lastT(), C, M, g);
+              }, translate: function(C, M, g) {
+                p.translate(p.lastT(), C, M, g);
+              } };
+              return Object.defineProperties(x, { matrix: { get: function() {
+                return p.computedMatrix;
+              }, set: function(C) {
+                return p.setMatrix(p.lastT(), C), p.computedMatrix;
+              }, enumerable: true }, mode: { get: function() {
+                return p.getMode();
+              }, set: function(C) {
+                var M = p.computedUp.slice(), g = p.computedEye.slice(), P = p.computedCenter.slice();
+                if (p.setMode(C), C === "turntable") {
+                  var A = s();
+                  p._active.lookAt(A, g, P, M), p._active.lookAt(A + 500, g, P, [0, 0, 1]), p._active.flush(A);
+                }
+                return p.getMode();
+              }, enumerable: true }, center: { get: function() {
+                return p.computedCenter;
+              }, set: function(C) {
+                return p.lookAt(p.lastT(), null, C), p.computedCenter;
+              }, enumerable: true }, eye: { get: function() {
+                return p.computedEye;
+              }, set: function(C) {
+                return p.lookAt(p.lastT(), C), p.computedEye;
+              }, enumerable: true }, up: { get: function() {
+                return p.computedUp;
+              }, set: function(C) {
+                return p.lookAt(p.lastT(), null, null, C), p.computedUp;
+              }, enumerable: true }, distance: { get: function() {
+                return E;
+              }, set: function(C) {
+                return p.setDistance(p.lastT(), C), C;
+              }, enumerable: true }, distanceLimits: { get: function() {
+                return p.getDistanceLimits(b);
+              }, set: function(C) {
+                return p.setDistanceLimits(C), C;
+              }, enumerable: true } }), v.addEventListener("contextmenu", function(C) {
+                return C.preventDefault(), false;
+              }), x._lastX = -1, x._lastY = -1, x._lastMods = { shift: false, control: false, alt: false, meta: false }, x.enableMouseListeners = function() {
+                x.mouseListener = u(v, C), v.addEventListener("touchstart", function(M) {
+                  var g = f(M.changedTouches[0], v);
+                  C(0, g[0], g[1], x._lastMods), C(1, g[0], g[1], x._lastMods);
+                }, h ? { passive: true } : false), v.addEventListener("touchmove", function(M) {
+                  var g = f(M.changedTouches[0], v);
+                  C(1, g[0], g[1], x._lastMods), M.preventDefault();
+                }, h ? { passive: false } : false), v.addEventListener("touchend", function(M) {
+                  C(0, x._lastX, x._lastY, x._lastMods);
+                }, h ? { passive: true } : false);
+                function C(M, g, P, A) {
+                  var z = x.keyBindingMode;
+                  if (z !== false) {
+                    var O = z === "rotate", U = z === "pan", G = z === "zoom", Z = !!A.control, j = !!A.alt, N = !!A.shift, H = !!(M & 1), re = !!(M & 2), oe = !!(M & 4), _e = 1 / v.clientHeight, Ce = _e * (g - x._lastX), Le = _e * (P - x._lastY), ge = x.flipX ? 1 : -1, ie = x.flipY ? 1 : -1, Se = Math.PI * x.rotateSpeed, Ee = s();
+                    if (x._lastX !== -1 && x._lastY !== -1 && ((O && H && !Z && !j && !N || H && !Z && !j && N) && p.rotate(Ee, ge * Se * Ce, -ie * Se * Le, 0), (U && H && !Z && !j && !N || re || H && Z && !j && !N) && p.pan(Ee, -x.translateSpeed * Ce * E, x.translateSpeed * Le * E, 0), G && H && !Z && !j && !N || oe || H && !Z && j && !N)) {
+                      var Ae = -x.zoomSpeed * Le / window.innerHeight * (Ee - p.lastT()) * 100;
+                      p.pan(Ee, 0, 0, E * (Math.exp(Ae) - 1));
+                    }
+                    return x._lastX = g, x._lastY = P, x._lastMods = A, true;
+                  }
+                }
+                x.wheelListener = c(v, function(M, g) {
+                  if (x.keyBindingMode !== false && x.enableWheel) {
+                    var P = x.flipX ? 1 : -1, A = x.flipY ? 1 : -1, z = s();
+                    if (Math.abs(M) > Math.abs(g)) p.rotate(z, 0, 0, -M * P * Math.PI * x.rotateSpeed / window.innerWidth);
+                    else if (!x._ortho) {
+                      var O = -x.zoomSpeed * A * g / window.innerHeight * (z - p.lastT()) / 20;
+                      p.pan(z, 0, 0, E * (Math.exp(O) - 1));
+                    }
+                  }
+                }, true);
+              }, x.enableMouseListeners(), x;
+            }
+          }, 4449: function(i, a, o) {
+            var s = o(2762), l = o(8116), u = o(1493);
+            i.exports = b;
+            var c = [1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1];
+            function f(p, k, E, T) {
+              this.gl = p, this.buffer = k, this.vao = E, this.shader = T, this.pixelRatio = 1, this.bounds = [[-1e3, -1e3, -1e3], [1e3, 1e3, 1e3]], this.position = [0, 0, 0], this.lineWidth = [2, 2, 2], this.colors = [[0, 0, 0, 1], [0, 0, 0, 1], [0, 0, 0, 1]], this.enabled = [true, true, true], this.drawSides = [true, true, true], this.axes = null;
+            }
+            var h = f.prototype, d = [0, 0, 0], v = [0, 0, 0], _ = [0, 0];
+            h.isTransparent = function() {
+              return false;
+            }, h.drawTransparent = function(p) {
+            }, h.draw = function(p) {
+              var k = this.gl, E = this.vao, T = this.shader;
+              E.bind(), T.bind();
+              var L = p.model || c, x = p.view || c, C = p.projection || c, M;
+              this.axes && (M = this.axes.lastCubeProps.axis);
+              for (var g = d, P = v, A = 0; A < 3; ++A) M && M[A] < 0 ? (g[A] = this.bounds[0][A], P[A] = this.bounds[1][A]) : (g[A] = this.bounds[1][A], P[A] = this.bounds[0][A]);
+              _[0] = k.drawingBufferWidth, _[1] = k.drawingBufferHeight, T.uniforms.model = L, T.uniforms.view = x, T.uniforms.projection = C, T.uniforms.coordinates = [this.position, g, P], T.uniforms.colors = this.colors, T.uniforms.screenShape = _;
+              for (var A = 0; A < 3; ++A) T.uniforms.lineWidth = this.lineWidth[A] * this.pixelRatio, this.enabled[A] && (E.draw(k.TRIANGLES, 6, 6 * A), this.drawSides[A] && E.draw(k.TRIANGLES, 12, 18 + 12 * A));
+              E.unbind();
+            }, h.update = function(p) {
+              p && ("bounds" in p && (this.bounds = p.bounds), "position" in p && (this.position = p.position), "lineWidth" in p && (this.lineWidth = p.lineWidth), "colors" in p && (this.colors = p.colors), "enabled" in p && (this.enabled = p.enabled), "drawSides" in p && (this.drawSides = p.drawSides));
+            }, h.dispose = function() {
+              this.vao.dispose(), this.buffer.dispose(), this.shader.dispose();
+            };
+            function b(p, k) {
+              var E = [];
+              function T(g, P, A, z, O, U) {
+                var G = [g, P, A, 0, 0, 0, 1];
+                G[z + 3] = 1, G[z] = O, E.push.apply(E, G), G[6] = -1, E.push.apply(E, G), G[z] = U, E.push.apply(E, G), E.push.apply(E, G), G[6] = 1, E.push.apply(E, G), G[z] = O, E.push.apply(E, G);
+              }
+              T(0, 0, 0, 0, 0, 1), T(0, 0, 0, 1, 0, 1), T(0, 0, 0, 2, 0, 1), T(1, 0, 0, 1, -1, 1), T(1, 0, 0, 2, -1, 1), T(0, 1, 0, 0, -1, 1), T(0, 1, 0, 2, -1, 1), T(0, 0, 1, 0, -1, 1), T(0, 0, 1, 1, -1, 1);
+              var L = s(p, E), x = l(p, [{ type: p.FLOAT, buffer: L, size: 3, offset: 0, stride: 28 }, { type: p.FLOAT, buffer: L, size: 3, offset: 12, stride: 28 }, { type: p.FLOAT, buffer: L, size: 1, offset: 24, stride: 28 }]), C = u(p);
+              C.attributes.position.location = 0, C.attributes.color.location = 1, C.attributes.weight.location = 2;
+              var M = new f(p, L, x, C);
+              return M.update(k), M;
+            }
+          }, 4494: function(i) {
+            i.exports = a;
+            function a(o, s) {
+              return o[0] = 1 / s[0], o[1] = 1 / s[1], o[2] = 1 / s[2], o[3] = 1 / s[3], o;
+            }
+          }, 4505: function(i, a, o) {
+            i.exports = o(5847);
+          }, 4578: function(i) {
+            i.exports = a;
+            function a(o, s, l, u, c) {
+              return o[0] = s, o[1] = l, o[2] = u, o[3] = c, o;
+            }
+          }, 4623: function(i) {
+            "use restrict";
+            i.exports = a;
+            function a(o) {
+              this.roots = new Array(o), this.ranks = new Array(o);
+              for (var s = 0; s < o; ++s) this.roots[s] = s, this.ranks[s] = 0;
+            }
+            a.prototype.length = function() {
+              return this.roots.length;
+            }, a.prototype.makeSet = function() {
+              var o = this.roots.length;
+              return this.roots.push(o), this.ranks.push(0), o;
+            }, a.prototype.find = function(o) {
+              for (var s = this.roots; s[o] !== o; ) {
+                var l = s[o];
+                s[o] = s[l], o = l;
+              }
+              return o;
+            }, a.prototype.link = function(o, s) {
+              var l = this.find(o), u = this.find(s);
+              if (l !== u) {
+                var c = this.ranks, f = this.roots, h = c[l], d = c[u];
+                h < d ? f[l] = u : d < h ? f[u] = l : (f[u] = l, ++c[l]);
+              }
+            };
+          }, 4687: function(i, a) {
+            function o(c) {
+              if (typeof c == "object") {
+                if ("buttons" in c) return c.buttons;
+                if ("which" in c) {
+                  var f = c.which;
+                  if (f === 2) return 4;
+                  if (f === 3) return 2;
+                  if (f > 0) return 1 << f - 1;
+                } else if ("button" in c) {
+                  var f = c.button;
+                  if (f === 1) return 4;
+                  if (f === 2) return 2;
+                  if (f >= 0) return 1 << f;
+                }
+              }
+              return 0;
+            }
+            a.buttons = o;
+            function s(c) {
+              return c.target || c.srcElement || window;
+            }
+            a.element = s;
+            function l(c) {
+              if (typeof c == "object") {
+                if ("offsetX" in c) return c.offsetX;
+                var f = s(c), h = f.getBoundingClientRect();
+                return c.clientX - h.left;
+              }
+              return 0;
+            }
+            a.x = l;
+            function u(c) {
+              if (typeof c == "object") {
+                if ("offsetY" in c) return c.offsetY;
+                var f = s(c), h = f.getBoundingClientRect();
+                return c.clientY - h.top;
+              }
+              return 0;
+            }
+            a.y = u;
+          }, 4691: function(i) {
+            i.exports = a;
+            function a(o, s) {
+              var l = s[0] - o[0], u = s[1] - o[1], c = s[2] - o[2], f = s[3] - o[3];
+              return Math.sqrt(l * l + u * u + c * c + f * f);
+            }
+          }, 4750: function(i, a, o) {
+            i.exports = l;
+            var s = o(3090);
+            function l(u) {
+              var c = s(u), f = c.length;
+              if (f <= 2) return [];
+              for (var h = new Array(f), d = c[f - 1], v = 0; v < f; ++v) {
+                var _ = c[v];
+                h[v] = [d, _], d = _;
+              }
+              return h;
+            }
+          }, 4769: function(i) {
+            function a(s, l, u, c, f, h) {
+              var d = 6 * f * f - 6 * f, v = 3 * f * f - 4 * f + 1, _ = -6 * f * f + 6 * f, b = 3 * f * f - 2 * f;
+              if (s.length) {
+                h || (h = new Array(s.length));
+                for (var p = s.length - 1; p >= 0; --p) h[p] = d * s[p] + v * l[p] + _ * u[p] + b * c[p];
+                return h;
+              }
+              return d * s + v * l + _ * u[p] + b * c;
+            }
+            function o(s, l, u, c, f, h) {
+              var d = f - 1, v = f * f, _ = d * d, b = (1 + 2 * f) * _, p = f * _, k = v * (3 - 2 * f), E = v * d;
+              if (s.length) {
+                h || (h = new Array(s.length));
+                for (var T = s.length - 1; T >= 0; --T) h[T] = b * s[T] + p * l[T] + k * u[T] + E * c[T];
+                return h;
+              }
+              return b * s + p * l + k * u + E * c;
+            }
+            i.exports = o, i.exports.derivative = a;
+          }, 4772: function(i) {
+            i.exports = a;
+            function a(o, s, l, u, c) {
+              var f = 1 / Math.tan(s / 2), h = 1 / (u - c);
+              return o[0] = f / l, o[1] = 0, o[2] = 0, o[3] = 0, o[4] = 0, o[5] = f, o[6] = 0, o[7] = 0, o[8] = 0, o[9] = 0, o[10] = (c + u) * h, o[11] = -1, o[12] = 0, o[13] = 0, o[14] = 2 * c * u * h, o[15] = 0, o;
+            }
+          }, 4793: function(i, a, o) {
+            function l(Ie, xe) {
+              if (!(Ie instanceof xe)) throw new TypeError("Cannot call a class as a function");
+            }
+            function u(Ie, xe) {
+              for (var ke = 0; ke < xe.length; ke++) {
+                var vt = xe[ke];
+                vt.enumerable = vt.enumerable || false, vt.configurable = true, "value" in vt && (vt.writable = true), Object.defineProperty(Ie, f(vt.key), vt);
+              }
+            }
+            function c(Ie, xe, ke) {
+              return xe && u(Ie.prototype, xe), Object.defineProperty(Ie, "prototype", { writable: false }), Ie;
+            }
+            function f(Ie) {
+              var xe = h(Ie, "string");
+              return T(xe) == "symbol" ? xe : xe + "";
+            }
+            function h(Ie, xe) {
+              if (T(Ie) != "object" || !Ie) return Ie;
+              var ke = Ie[Symbol.toPrimitive];
+              if (ke !== void 0) {
+                var vt = ke.call(Ie, xe);
+                if (T(vt) != "object") return vt;
+                throw new TypeError("@@toPrimitive must return a primitive value.");
+              }
+              return String(Ie);
+            }
+            function d(Ie, xe, ke) {
+              return xe = p(xe), v(Ie, b() ? Reflect.construct(xe, [], p(Ie).constructor) : xe.apply(Ie, ke));
+            }
+            function v(Ie, xe) {
+              if (xe && (T(xe) == "object" || typeof xe == "function")) return xe;
+              if (xe !== void 0) throw new TypeError("Derived constructors may only return object or undefined");
+              return _(Ie);
+            }
+            function _(Ie) {
+              if (Ie === void 0) throw new ReferenceError("this hasn't been initialised - super() hasn't been called");
+              return Ie;
+            }
+            function b() {
+              try {
+                var Ie = !Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function() {
+                }));
+              } catch (xe) {
+              }
+              return (b = function() {
+                return !!Ie;
+              })();
+            }
+            function p(Ie) {
+              return p = Object.setPrototypeOf ? Object.getPrototypeOf.bind() : function(xe) {
+                return xe.__proto__ || Object.getPrototypeOf(xe);
+              }, p(Ie);
+            }
+            function k(Ie, xe) {
+              if (typeof xe != "function" && xe !== null) throw new TypeError("Super expression must either be null or a function");
+              Ie.prototype = Object.create(xe && xe.prototype, { constructor: { value: Ie, writable: true, configurable: true } }), Object.defineProperty(Ie, "prototype", { writable: false }), xe && E(Ie, xe);
+            }
+            function E(Ie, xe) {
+              return E = Object.setPrototypeOf ? Object.setPrototypeOf.bind() : function(ke, vt) {
+                return ke.__proto__ = vt, ke;
+              }, E(Ie, xe);
+            }
+            function T(Ie) {
+              "@babel/helpers - typeof";
+              return T = typeof Symbol == "function" && typeof Symbol.iterator == "symbol" ? function(xe) {
+                return typeof xe;
+              } : function(xe) {
+                return xe && typeof Symbol == "function" && xe.constructor === Symbol && xe !== Symbol.prototype ? "symbol" : typeof xe;
+              }, T(Ie);
+            }
+            var L = o(7507), x = o(3778), C = typeof Symbol == "function" && typeof Symbol.for == "function" ? Symbol.for("nodejs.util.inspect.custom") : null;
+            a.hp = A, a.IS = 50;
+            var M = 2147483647;
+            A.TYPED_ARRAY_SUPPORT = g(), !A.TYPED_ARRAY_SUPPORT && typeof console != "undefined" && typeof console.error == "function" && console.error("This browser lacks typed array (Uint8Array) support which is required by `buffer` v5.x. Use `buffer` v4.x if you require old browser support.");
+            function g() {
+              try {
+                var Ie = new Uint8Array(1), xe = { foo: function() {
+                  return 42;
+                } };
+                return Object.setPrototypeOf(xe, Uint8Array.prototype), Object.setPrototypeOf(Ie, xe), Ie.foo() === 42;
+              } catch (ke) {
+                return false;
+              }
+            }
+            Object.defineProperty(A.prototype, "parent", { enumerable: true, get: function() {
+              if (A.isBuffer(this)) return this.buffer;
+            } }), Object.defineProperty(A.prototype, "offset", { enumerable: true, get: function() {
+              if (A.isBuffer(this)) return this.byteOffset;
+            } });
+            function P(Ie) {
+              if (Ie > M) throw new RangeError('The value "' + Ie + '" is invalid for option "size"');
+              var xe = new Uint8Array(Ie);
+              return Object.setPrototypeOf(xe, A.prototype), xe;
+            }
+            function A(Ie, xe, ke) {
+              if (typeof Ie == "number") {
+                if (typeof xe == "string") throw new TypeError('The "string" argument must be of type string. Received type number');
+                return G(Ie);
+              }
+              return z(Ie, xe, ke);
+            }
+            A.poolSize = 8192;
+            function z(Ie, xe, ke) {
+              if (typeof Ie == "string") return Z(Ie, xe);
+              if (ArrayBuffer.isView(Ie)) return N(Ie);
+              if (Ie == null) throw new TypeError("The first argument must be one of type string, Buffer, ArrayBuffer, Array, or Array-like Object. Received type " + T(Ie));
+              if (Ge(Ie, ArrayBuffer) || Ie && Ge(Ie.buffer, ArrayBuffer) || typeof SharedArrayBuffer != "undefined" && (Ge(Ie, SharedArrayBuffer) || Ie && Ge(Ie.buffer, SharedArrayBuffer))) return H(Ie, xe, ke);
+              if (typeof Ie == "number") throw new TypeError('The "value" argument must not be of type number. Received type number');
+              var vt = Ie.valueOf && Ie.valueOf();
+              if (vt != null && vt !== Ie) return A.from(vt, xe, ke);
+              var ir = re(Ie);
+              if (ir) return ir;
+              if (typeof Symbol != "undefined" && Symbol.toPrimitive != null && typeof Ie[Symbol.toPrimitive] == "function") return A.from(Ie[Symbol.toPrimitive]("string"), xe, ke);
+              throw new TypeError("The first argument must be one of type string, Buffer, ArrayBuffer, Array, or Array-like Object. Received type " + T(Ie));
+            }
+            A.from = function(Ie, xe, ke) {
+              return z(Ie, xe, ke);
+            }, Object.setPrototypeOf(A.prototype, Uint8Array.prototype), Object.setPrototypeOf(A, Uint8Array);
+            function O(Ie) {
+              if (typeof Ie != "number") throw new TypeError('"size" argument must be of type number');
+              if (Ie < 0) throw new RangeError('The value "' + Ie + '" is invalid for option "size"');
+            }
+            function U(Ie, xe, ke) {
+              return O(Ie), Ie <= 0 ? P(Ie) : xe !== void 0 ? typeof ke == "string" ? P(Ie).fill(xe, ke) : P(Ie).fill(xe) : P(Ie);
+            }
+            A.alloc = function(Ie, xe, ke) {
+              return U(Ie, xe, ke);
+            };
+            function G(Ie) {
+              return O(Ie), P(Ie < 0 ? 0 : oe(Ie) | 0);
+            }
+            A.allocUnsafe = function(Ie) {
+              return G(Ie);
+            }, A.allocUnsafeSlow = function(Ie) {
+              return G(Ie);
+            };
+            function Z(Ie, xe) {
+              if ((typeof xe != "string" || xe === "") && (xe = "utf8"), !A.isEncoding(xe)) throw new TypeError("Unknown encoding: " + xe);
+              var ke = Ce(Ie, xe) | 0, vt = P(ke), ir = vt.write(Ie, xe);
+              return ir !== ke && (vt = vt.slice(0, ir)), vt;
+            }
+            function j(Ie) {
+              for (var xe = Ie.length < 0 ? 0 : oe(Ie.length) | 0, ke = P(xe), vt = 0; vt < xe; vt += 1) ke[vt] = Ie[vt] & 255;
+              return ke;
+            }
+            function N(Ie) {
+              if (Ge(Ie, Uint8Array)) {
+                var xe = new Uint8Array(Ie);
+                return H(xe.buffer, xe.byteOffset, xe.byteLength);
+              }
+              return j(Ie);
+            }
+            function H(Ie, xe, ke) {
+              if (xe < 0 || Ie.byteLength < xe) throw new RangeError('"offset" is outside of buffer bounds');
+              if (Ie.byteLength < xe + (ke || 0)) throw new RangeError('"length" is outside of buffer bounds');
+              var vt;
+              return xe === void 0 && ke === void 0 ? vt = new Uint8Array(Ie) : ke === void 0 ? vt = new Uint8Array(Ie, xe) : vt = new Uint8Array(Ie, xe, ke), Object.setPrototypeOf(vt, A.prototype), vt;
+            }
+            function re(Ie) {
+              if (A.isBuffer(Ie)) {
+                var xe = oe(Ie.length) | 0, ke = P(xe);
+                return ke.length === 0 || Ie.copy(ke, 0, 0, xe), ke;
+              }
+              if (Ie.length !== void 0) return typeof Ie.length != "number" || Je(Ie.length) ? P(0) : j(Ie);
+              if (Ie.type === "Buffer" && Array.isArray(Ie.data)) return j(Ie.data);
+            }
+            function oe(Ie) {
+              if (Ie >= M) throw new RangeError("Attempt to allocate Buffer larger than maximum size: 0x" + M.toString(16) + " bytes");
+              return Ie | 0;
+            }
+            A.isBuffer = function(xe) {
+              return xe != null && xe._isBuffer === true && xe !== A.prototype;
+            }, A.compare = function(xe, ke) {
+              if (Ge(xe, Uint8Array) && (xe = A.from(xe, xe.offset, xe.byteLength)), Ge(ke, Uint8Array) && (ke = A.from(ke, ke.offset, ke.byteLength)), !A.isBuffer(xe) || !A.isBuffer(ke)) throw new TypeError('The "buf1", "buf2" arguments must be one of type Buffer or Uint8Array');
+              if (xe === ke) return 0;
+              for (var vt = xe.length, ir = ke.length, ar = 0, vr = Math.min(vt, ir); ar < vr; ++ar) if (xe[ar] !== ke[ar]) {
+                vt = xe[ar], ir = ke[ar];
+                break;
+              }
+              return vt < ir ? -1 : ir < vt ? 1 : 0;
+            }, A.isEncoding = function(xe) {
+              switch (String(xe).toLowerCase()) {
+                case "hex":
+                case "utf8":
+                case "utf-8":
+                case "ascii":
+                case "latin1":
+                case "binary":
+                case "base64":
+                case "ucs2":
+                case "ucs-2":
+                case "utf16le":
+                case "utf-16le":
+                  return true;
+                default:
+                  return false;
+              }
+            }, A.concat = function(xe, ke) {
+              if (!Array.isArray(xe)) throw new TypeError('"list" argument must be an Array of Buffers');
+              if (xe.length === 0) return A.alloc(0);
+              var vt;
+              if (ke === void 0) for (ke = 0, vt = 0; vt < xe.length; ++vt) ke += xe[vt].length;
+              var ir = A.allocUnsafe(ke), ar = 0;
+              for (vt = 0; vt < xe.length; ++vt) {
+                var vr = xe[vt];
+                if (Ge(vr, Uint8Array)) ar + vr.length > ir.length ? (A.isBuffer(vr) || (vr = A.from(vr)), vr.copy(ir, ar)) : Uint8Array.prototype.set.call(ir, vr, ar);
+                else if (A.isBuffer(vr)) vr.copy(ir, ar);
+                else throw new TypeError('"list" argument must be an Array of Buffers');
+                ar += vr.length;
+              }
+              return ir;
+            };
+            function Ce(Ie, xe) {
+              if (A.isBuffer(Ie)) return Ie.length;
+              if (ArrayBuffer.isView(Ie) || Ge(Ie, ArrayBuffer)) return Ie.byteLength;
+              if (typeof Ie != "string") throw new TypeError('The "string" argument must be one of type string, Buffer, or ArrayBuffer. Received type ' + T(Ie));
+              var ke = Ie.length, vt = arguments.length > 2 && arguments[2] === true;
+              if (!vt && ke === 0) return 0;
+              for (var ir = false; ; ) switch (xe) {
+                case "ascii":
+                case "latin1":
+                case "binary":
+                  return ke;
+                case "utf8":
+                case "utf-8":
+                  return Lr(Ie).length;
+                case "ucs2":
+                case "ucs-2":
+                case "utf16le":
+                case "utf-16le":
+                  return ke * 2;
+                case "hex":
+                  return ke >>> 1;
+                case "base64":
+                  return Vr(Ie).length;
+                default:
+                  if (ir) return vt ? -1 : Lr(Ie).length;
+                  xe = ("" + xe).toLowerCase(), ir = true;
+              }
+            }
+            A.byteLength = Ce;
+            function Le(Ie, xe, ke) {
+              var vt = false;
+              if ((xe === void 0 || xe < 0) && (xe = 0), xe > this.length || ((ke === void 0 || ke > this.length) && (ke = this.length), ke <= 0) || (ke >>>= 0, xe >>>= 0, ke <= xe)) return "";
+              for (Ie || (Ie = "utf8"); ; ) switch (Ie) {
+                case "hex":
+                  return ot(this, xe, ke);
+                case "utf8":
+                case "utf-8":
+                  return ce(this, xe, ke);
+                case "ascii":
+                  return pt(this, xe, ke);
+                case "latin1":
+                case "binary":
+                  return Vt(this, xe, ke);
+                case "base64":
+                  return De(this, xe, ke);
+                case "ucs2":
+                case "ucs-2":
+                case "utf16le":
+                case "utf-16le":
+                  return ut(this, xe, ke);
+                default:
+                  if (vt) throw new TypeError("Unknown encoding: " + Ie);
+                  Ie = (Ie + "").toLowerCase(), vt = true;
+              }
+            }
+            A.prototype._isBuffer = true;
+            function ge(Ie, xe, ke) {
+              var vt = Ie[xe];
+              Ie[xe] = Ie[ke], Ie[ke] = vt;
+            }
+            A.prototype.swap16 = function() {
+              var xe = this.length;
+              if (xe % 2 !== 0) throw new RangeError("Buffer size must be a multiple of 16-bits");
+              for (var ke = 0; ke < xe; ke += 2) ge(this, ke, ke + 1);
+              return this;
+            }, A.prototype.swap32 = function() {
+              var xe = this.length;
+              if (xe % 4 !== 0) throw new RangeError("Buffer size must be a multiple of 32-bits");
+              for (var ke = 0; ke < xe; ke += 4) ge(this, ke, ke + 3), ge(this, ke + 1, ke + 2);
+              return this;
+            }, A.prototype.swap64 = function() {
+              var xe = this.length;
+              if (xe % 8 !== 0) throw new RangeError("Buffer size must be a multiple of 64-bits");
+              for (var ke = 0; ke < xe; ke += 8) ge(this, ke, ke + 7), ge(this, ke + 1, ke + 6), ge(this, ke + 2, ke + 5), ge(this, ke + 3, ke + 4);
+              return this;
+            }, A.prototype.toString = function() {
+              var xe = this.length;
+              return xe === 0 ? "" : arguments.length === 0 ? ce(this, 0, xe) : Le.apply(this, arguments);
+            }, A.prototype.toLocaleString = A.prototype.toString, A.prototype.equals = function(xe) {
+              if (!A.isBuffer(xe)) throw new TypeError("Argument must be a Buffer");
+              return this === xe ? true : A.compare(this, xe) === 0;
+            }, A.prototype.inspect = function() {
+              var xe = "", ke = a.IS;
+              return xe = this.toString("hex", 0, ke).replace(/(.{2})/g, "$1 ").trim(), this.length > ke && (xe += " ... "), "<Buffer " + xe + ">";
+            }, C && (A.prototype[C] = A.prototype.inspect), A.prototype.compare = function(xe, ke, vt, ir, ar) {
+              if (Ge(xe, Uint8Array) && (xe = A.from(xe, xe.offset, xe.byteLength)), !A.isBuffer(xe)) throw new TypeError('The "target" argument must be one of type Buffer or Uint8Array. Received type ' + T(xe));
+              if (ke === void 0 && (ke = 0), vt === void 0 && (vt = xe ? xe.length : 0), ir === void 0 && (ir = 0), ar === void 0 && (ar = this.length), ke < 0 || vt > xe.length || ir < 0 || ar > this.length) throw new RangeError("out of range index");
+              if (ir >= ar && ke >= vt) return 0;
+              if (ir >= ar) return -1;
+              if (ke >= vt) return 1;
+              if (ke >>>= 0, vt >>>= 0, ir >>>= 0, ar >>>= 0, this === xe) return 0;
+              for (var vr = ar - ir, ii = vt - ke, pi = Math.min(vr, ii), $r = this.slice(ir, ar), di = xe.slice(ke, vt), ji = 0; ji < pi; ++ji) if ($r[ji] !== di[ji]) {
+                vr = $r[ji], ii = di[ji];
+                break;
+              }
+              return vr < ii ? -1 : ii < vr ? 1 : 0;
+            };
+            function ie(Ie, xe, ke, vt, ir) {
+              if (Ie.length === 0) return -1;
+              if (typeof ke == "string" ? (vt = ke, ke = 0) : ke > 2147483647 ? ke = 2147483647 : ke < -2147483648 && (ke = -2147483648), ke = +ke, Je(ke) && (ke = ir ? 0 : Ie.length - 1), ke < 0 && (ke = Ie.length + ke), ke >= Ie.length) {
+                if (ir) return -1;
+                ke = Ie.length - 1;
+              } else if (ke < 0) if (ir) ke = 0;
+              else return -1;
+              if (typeof xe == "string" && (xe = A.from(xe, vt)), A.isBuffer(xe)) return xe.length === 0 ? -1 : Se(Ie, xe, ke, vt, ir);
+              if (typeof xe == "number") return xe = xe & 255, typeof Uint8Array.prototype.indexOf == "function" ? ir ? Uint8Array.prototype.indexOf.call(Ie, xe, ke) : Uint8Array.prototype.lastIndexOf.call(Ie, xe, ke) : Se(Ie, [xe], ke, vt, ir);
+              throw new TypeError("val must be string, number or Buffer");
+            }
+            function Se(Ie, xe, ke, vt, ir) {
+              var ar = 1, vr = Ie.length, ii = xe.length;
+              if (vt !== void 0 && (vt = String(vt).toLowerCase(), vt === "ucs2" || vt === "ucs-2" || vt === "utf16le" || vt === "utf-16le")) {
+                if (Ie.length < 2 || xe.length < 2) return -1;
+                ar = 2, vr /= 2, ii /= 2, ke /= 2;
+              }
+              function pi(wi, On) {
+                return ar === 1 ? wi[On] : wi.readUInt16BE(On * ar);
+              }
+              var $r;
+              if (ir) {
+                var di = -1;
+                for ($r = ke; $r < vr; $r++) if (pi(Ie, $r) === pi(xe, di === -1 ? 0 : $r - di)) {
+                  if (di === -1 && (di = $r), $r - di + 1 === ii) return di * ar;
+                } else di !== -1 && ($r -= $r - di), di = -1;
+              } else for (ke + ii > vr && (ke = vr - ii), $r = ke; $r >= 0; $r--) {
+                for (var ji = true, In = 0; In < ii; In++) if (pi(Ie, $r + In) !== pi(xe, In)) {
+                  ji = false;
+                  break;
+                }
+                if (ji) return $r;
+              }
+              return -1;
+            }
+            A.prototype.includes = function(xe, ke, vt) {
+              return this.indexOf(xe, ke, vt) !== -1;
+            }, A.prototype.indexOf = function(xe, ke, vt) {
+              return ie(this, xe, ke, vt, true);
+            }, A.prototype.lastIndexOf = function(xe, ke, vt) {
+              return ie(this, xe, ke, vt, false);
+            };
+            function Ee(Ie, xe, ke, vt) {
+              ke = Number(ke) || 0;
+              var ir = Ie.length - ke;
+              vt ? (vt = Number(vt), vt > ir && (vt = ir)) : vt = ir;
+              var ar = xe.length;
+              vt > ar / 2 && (vt = ar / 2);
+              var vr;
+              for (vr = 0; vr < vt; ++vr) {
+                var ii = parseInt(xe.substr(vr * 2, 2), 16);
+                if (Je(ii)) return vr;
+                Ie[ke + vr] = ii;
+              }
+              return vr;
+            }
+            function Ae(Ie, xe, ke, vt) {
+              return dt(Lr(xe, Ie.length - ke), Ie, ke, vt);
+            }
+            function Be(Ie, xe, ke, vt) {
+              return dt(ti(xe), Ie, ke, vt);
+            }
+            function Pe(Ie, xe, ke, vt) {
+              return dt(Vr(xe), Ie, ke, vt);
+            }
+            function me(Ie, xe, ke, vt) {
+              return dt(Br(xe, Ie.length - ke), Ie, ke, vt);
+            }
+            A.prototype.write = function(xe, ke, vt, ir) {
+              if (ke === void 0) ir = "utf8", vt = this.length, ke = 0;
+              else if (vt === void 0 && typeof ke == "string") ir = ke, vt = this.length, ke = 0;
+              else if (isFinite(ke)) ke = ke >>> 0, isFinite(vt) ? (vt = vt >>> 0, ir === void 0 && (ir = "utf8")) : (ir = vt, vt = void 0);
+              else throw new Error("Buffer.write(string, encoding, offset[, length]) is no longer supported");
+              var ar = this.length - ke;
+              if ((vt === void 0 || vt > ar) && (vt = ar), xe.length > 0 && (vt < 0 || ke < 0) || ke > this.length) throw new RangeError("Attempt to write outside buffer bounds");
+              ir || (ir = "utf8");
+              for (var vr = false; ; ) switch (ir) {
+                case "hex":
+                  return Ee(this, xe, ke, vt);
+                case "utf8":
+                case "utf-8":
+                  return Ae(this, xe, ke, vt);
+                case "ascii":
+                case "latin1":
+                case "binary":
+                  return Be(this, xe, ke, vt);
+                case "base64":
+                  return Pe(this, xe, ke, vt);
+                case "ucs2":
+                case "ucs-2":
+                case "utf16le":
+                case "utf-16le":
+                  return me(this, xe, ke, vt);
+                default:
+                  if (vr) throw new TypeError("Unknown encoding: " + ir);
+                  ir = ("" + ir).toLowerCase(), vr = true;
+              }
+            }, A.prototype.toJSON = function() {
+              return { type: "Buffer", data: Array.prototype.slice.call(this._arr || this, 0) };
+            };
+            function De(Ie, xe, ke) {
+              return xe === 0 && ke === Ie.length ? L.fromByteArray(Ie) : L.fromByteArray(Ie.slice(xe, ke));
+            }
+            function ce(Ie, xe, ke) {
+              ke = Math.min(Ie.length, ke);
+              for (var vt = [], ir = xe; ir < ke; ) {
+                var ar = Ie[ir], vr = null, ii = ar > 239 ? 4 : ar > 223 ? 3 : ar > 191 ? 2 : 1;
+                if (ir + ii <= ke) {
+                  var pi = void 0, $r = void 0, di = void 0, ji = void 0;
+                  switch (ii) {
+                    case 1:
+                      ar < 128 && (vr = ar);
+                      break;
+                    case 2:
+                      pi = Ie[ir + 1], (pi & 192) === 128 && (ji = (ar & 31) << 6 | pi & 63, ji > 127 && (vr = ji));
+                      break;
+                    case 3:
+                      pi = Ie[ir + 1], $r = Ie[ir + 2], (pi & 192) === 128 && ($r & 192) === 128 && (ji = (ar & 15) << 12 | (pi & 63) << 6 | $r & 63, ji > 2047 && (ji < 55296 || ji > 57343) && (vr = ji));
+                      break;
+                    case 4:
+                      pi = Ie[ir + 1], $r = Ie[ir + 2], di = Ie[ir + 3], (pi & 192) === 128 && ($r & 192) === 128 && (di & 192) === 128 && (ji = (ar & 15) << 18 | (pi & 63) << 12 | ($r & 63) << 6 | di & 63, ji > 65535 && ji < 1114112 && (vr = ji));
+                  }
+                }
+                vr === null ? (vr = 65533, ii = 1) : vr > 65535 && (vr -= 65536, vt.push(vr >>> 10 & 1023 | 55296), vr = 56320 | vr & 1023), vt.push(vr), ir += ii;
+              }
+              return lt(vt);
+            }
+            var je = 4096;
+            function lt(Ie) {
+              var xe = Ie.length;
+              if (xe <= je) return String.fromCharCode.apply(String, Ie);
+              for (var ke = "", vt = 0; vt < xe; ) ke += String.fromCharCode.apply(String, Ie.slice(vt, vt += je));
+              return ke;
+            }
+            function pt(Ie, xe, ke) {
+              var vt = "";
+              ke = Math.min(Ie.length, ke);
+              for (var ir = xe; ir < ke; ++ir) vt += String.fromCharCode(Ie[ir] & 127);
+              return vt;
+            }
+            function Vt(Ie, xe, ke) {
+              var vt = "";
+              ke = Math.min(Ie.length, ke);
+              for (var ir = xe; ir < ke; ++ir) vt += String.fromCharCode(Ie[ir]);
+              return vt;
+            }
+            function ot(Ie, xe, ke) {
+              var vt = Ie.length;
+              (!xe || xe < 0) && (xe = 0), (!ke || ke < 0 || ke > vt) && (ke = vt);
+              for (var ir = "", ar = xe; ar < ke; ++ar) ir += We[Ie[ar]];
+              return ir;
+            }
+            function ut(Ie, xe, ke) {
+              for (var vt = Ie.slice(xe, ke), ir = "", ar = 0; ar < vt.length - 1; ar += 2) ir += String.fromCharCode(vt[ar] + vt[ar + 1] * 256);
+              return ir;
+            }
+            A.prototype.slice = function(xe, ke) {
+              var vt = this.length;
+              xe = ~~xe, ke = ke === void 0 ? vt : ~~ke, xe < 0 ? (xe += vt, xe < 0 && (xe = 0)) : xe > vt && (xe = vt), ke < 0 ? (ke += vt, ke < 0 && (ke = 0)) : ke > vt && (ke = vt), ke < xe && (ke = xe);
+              var ir = this.subarray(xe, ke);
+              return Object.setPrototypeOf(ir, A.prototype), ir;
+            };
+            function Wt(Ie, xe, ke) {
+              if (Ie % 1 !== 0 || Ie < 0) throw new RangeError("offset is not uint");
+              if (Ie + xe > ke) throw new RangeError("Trying to access beyond buffer length");
+            }
+            A.prototype.readUintLE = A.prototype.readUIntLE = function(xe, ke, vt) {
+              xe = xe >>> 0, ke = ke >>> 0, vt || Wt(xe, ke, this.length);
+              for (var ir = this[xe], ar = 1, vr = 0; ++vr < ke && (ar *= 256); ) ir += this[xe + vr] * ar;
+              return ir;
+            }, A.prototype.readUintBE = A.prototype.readUIntBE = function(xe, ke, vt) {
+              xe = xe >>> 0, ke = ke >>> 0, vt || Wt(xe, ke, this.length);
+              for (var ir = this[xe + --ke], ar = 1; ke > 0 && (ar *= 256); ) ir += this[xe + --ke] * ar;
+              return ir;
+            }, A.prototype.readUint8 = A.prototype.readUInt8 = function(xe, ke) {
+              return xe = xe >>> 0, ke || Wt(xe, 1, this.length), this[xe];
+            }, A.prototype.readUint16LE = A.prototype.readUInt16LE = function(xe, ke) {
+              return xe = xe >>> 0, ke || Wt(xe, 2, this.length), this[xe] | this[xe + 1] << 8;
+            }, A.prototype.readUint16BE = A.prototype.readUInt16BE = function(xe, ke) {
+              return xe = xe >>> 0, ke || Wt(xe, 2, this.length), this[xe] << 8 | this[xe + 1];
+            }, A.prototype.readUint32LE = A.prototype.readUInt32LE = function(xe, ke) {
+              return xe = xe >>> 0, ke || Wt(xe, 4, this.length), (this[xe] | this[xe + 1] << 8 | this[xe + 2] << 16) + this[xe + 3] * 16777216;
+            }, A.prototype.readUint32BE = A.prototype.readUInt32BE = function(xe, ke) {
+              return xe = xe >>> 0, ke || Wt(xe, 4, this.length), this[xe] * 16777216 + (this[xe + 1] << 16 | this[xe + 2] << 8 | this[xe + 3]);
+            }, A.prototype.readBigUInt64LE = tt(function(xe) {
+              xe = xe >>> 0, mt(xe, "offset");
+              var ke = this[xe], vt = this[xe + 7];
+              (ke === void 0 || vt === void 0) && er(xe, this.length - 8);
+              var ir = ke + this[++xe] * Math.pow(2, 8) + this[++xe] * Math.pow(2, 16) + this[++xe] * Math.pow(2, 24), ar = this[++xe] + this[++xe] * Math.pow(2, 8) + this[++xe] * Math.pow(2, 16) + vt * Math.pow(2, 24);
+              return BigInt(ir) + (BigInt(ar) << BigInt(32));
+            }), A.prototype.readBigUInt64BE = tt(function(xe) {
+              xe = xe >>> 0, mt(xe, "offset");
+              var ke = this[xe], vt = this[xe + 7];
+              (ke === void 0 || vt === void 0) && er(xe, this.length - 8);
+              var ir = ke * Math.pow(2, 24) + this[++xe] * Math.pow(2, 16) + this[++xe] * Math.pow(2, 8) + this[++xe], ar = this[++xe] * Math.pow(2, 24) + this[++xe] * Math.pow(2, 16) + this[++xe] * Math.pow(2, 8) + vt;
+              return (BigInt(ir) << BigInt(32)) + BigInt(ar);
+            }), A.prototype.readIntLE = function(xe, ke, vt) {
+              xe = xe >>> 0, ke = ke >>> 0, vt || Wt(xe, ke, this.length);
+              for (var ir = this[xe], ar = 1, vr = 0; ++vr < ke && (ar *= 256); ) ir += this[xe + vr] * ar;
+              return ar *= 128, ir >= ar && (ir -= Math.pow(2, 8 * ke)), ir;
+            }, A.prototype.readIntBE = function(xe, ke, vt) {
+              xe = xe >>> 0, ke = ke >>> 0, vt || Wt(xe, ke, this.length);
+              for (var ir = ke, ar = 1, vr = this[xe + --ir]; ir > 0 && (ar *= 256); ) vr += this[xe + --ir] * ar;
+              return ar *= 128, vr >= ar && (vr -= Math.pow(2, 8 * ke)), vr;
+            }, A.prototype.readInt8 = function(xe, ke) {
+              return xe = xe >>> 0, ke || Wt(xe, 1, this.length), this[xe] & 128 ? (255 - this[xe] + 1) * -1 : this[xe];
+            }, A.prototype.readInt16LE = function(xe, ke) {
+              xe = xe >>> 0, ke || Wt(xe, 2, this.length);
+              var vt = this[xe] | this[xe + 1] << 8;
+              return vt & 32768 ? vt | 4294901760 : vt;
+            }, A.prototype.readInt16BE = function(xe, ke) {
+              xe = xe >>> 0, ke || Wt(xe, 2, this.length);
+              var vt = this[xe + 1] | this[xe] << 8;
+              return vt & 32768 ? vt | 4294901760 : vt;
+            }, A.prototype.readInt32LE = function(xe, ke) {
+              return xe = xe >>> 0, ke || Wt(xe, 4, this.length), this[xe] | this[xe + 1] << 8 | this[xe + 2] << 16 | this[xe + 3] << 24;
+            }, A.prototype.readInt32BE = function(xe, ke) {
+              return xe = xe >>> 0, ke || Wt(xe, 4, this.length), this[xe] << 24 | this[xe + 1] << 16 | this[xe + 2] << 8 | this[xe + 3];
+            }, A.prototype.readBigInt64LE = tt(function(xe) {
+              xe = xe >>> 0, mt(xe, "offset");
+              var ke = this[xe], vt = this[xe + 7];
+              (ke === void 0 || vt === void 0) && er(xe, this.length - 8);
+              var ir = this[xe + 4] + this[xe + 5] * Math.pow(2, 8) + this[xe + 6] * Math.pow(2, 16) + (vt << 24);
+              return (BigInt(ir) << BigInt(32)) + BigInt(ke + this[++xe] * Math.pow(2, 8) + this[++xe] * Math.pow(2, 16) + this[++xe] * Math.pow(2, 24));
+            }), A.prototype.readBigInt64BE = tt(function(xe) {
+              xe = xe >>> 0, mt(xe, "offset");
+              var ke = this[xe], vt = this[xe + 7];
+              (ke === void 0 || vt === void 0) && er(xe, this.length - 8);
+              var ir = (ke << 24) + this[++xe] * Math.pow(2, 16) + this[++xe] * Math.pow(2, 8) + this[++xe];
+              return (BigInt(ir) << BigInt(32)) + BigInt(this[++xe] * Math.pow(2, 24) + this[++xe] * Math.pow(2, 16) + this[++xe] * Math.pow(2, 8) + vt);
+            }), A.prototype.readFloatLE = function(xe, ke) {
+              return xe = xe >>> 0, ke || Wt(xe, 4, this.length), x.read(this, xe, true, 23, 4);
+            }, A.prototype.readFloatBE = function(xe, ke) {
+              return xe = xe >>> 0, ke || Wt(xe, 4, this.length), x.read(this, xe, false, 23, 4);
+            }, A.prototype.readDoubleLE = function(xe, ke) {
+              return xe = xe >>> 0, ke || Wt(xe, 8, this.length), x.read(this, xe, true, 52, 8);
+            }, A.prototype.readDoubleBE = function(xe, ke) {
+              return xe = xe >>> 0, ke || Wt(xe, 8, this.length), x.read(this, xe, false, 52, 8);
+            };
+            function Nt(Ie, xe, ke, vt, ir, ar) {
+              if (!A.isBuffer(Ie)) throw new TypeError('"buffer" argument must be a Buffer instance');
+              if (xe > ir || xe < ar) throw new RangeError('"value" argument is out of bounds');
+              if (ke + vt > Ie.length) throw new RangeError("Index out of range");
+            }
+            A.prototype.writeUintLE = A.prototype.writeUIntLE = function(xe, ke, vt, ir) {
+              if (xe = +xe, ke = ke >>> 0, vt = vt >>> 0, !ir) {
+                var ar = Math.pow(2, 8 * vt) - 1;
+                Nt(this, xe, ke, vt, ar, 0);
+              }
+              var vr = 1, ii = 0;
+              for (this[ke] = xe & 255; ++ii < vt && (vr *= 256); ) this[ke + ii] = xe / vr & 255;
+              return ke + vt;
+            }, A.prototype.writeUintBE = A.prototype.writeUIntBE = function(xe, ke, vt, ir) {
+              if (xe = +xe, ke = ke >>> 0, vt = vt >>> 0, !ir) {
+                var ar = Math.pow(2, 8 * vt) - 1;
+                Nt(this, xe, ke, vt, ar, 0);
+              }
+              var vr = vt - 1, ii = 1;
+              for (this[ke + vr] = xe & 255; --vr >= 0 && (ii *= 256); ) this[ke + vr] = xe / ii & 255;
+              return ke + vt;
+            }, A.prototype.writeUint8 = A.prototype.writeUInt8 = function(xe, ke, vt) {
+              return xe = +xe, ke = ke >>> 0, vt || Nt(this, xe, ke, 1, 255, 0), this[ke] = xe & 255, ke + 1;
+            }, A.prototype.writeUint16LE = A.prototype.writeUInt16LE = function(xe, ke, vt) {
+              return xe = +xe, ke = ke >>> 0, vt || Nt(this, xe, ke, 2, 65535, 0), this[ke] = xe & 255, this[ke + 1] = xe >>> 8, ke + 2;
+            }, A.prototype.writeUint16BE = A.prototype.writeUInt16BE = function(xe, ke, vt) {
+              return xe = +xe, ke = ke >>> 0, vt || Nt(this, xe, ke, 2, 65535, 0), this[ke] = xe >>> 8, this[ke + 1] = xe & 255, ke + 2;
+            }, A.prototype.writeUint32LE = A.prototype.writeUInt32LE = function(xe, ke, vt) {
+              return xe = +xe, ke = ke >>> 0, vt || Nt(this, xe, ke, 4, 4294967295, 0), this[ke + 3] = xe >>> 24, this[ke + 2] = xe >>> 16, this[ke + 1] = xe >>> 8, this[ke] = xe & 255, ke + 4;
+            }, A.prototype.writeUint32BE = A.prototype.writeUInt32BE = function(xe, ke, vt) {
+              return xe = +xe, ke = ke >>> 0, vt || Nt(this, xe, ke, 4, 4294967295, 0), this[ke] = xe >>> 24, this[ke + 1] = xe >>> 16, this[ke + 2] = xe >>> 8, this[ke + 3] = xe & 255, ke + 4;
+            };
+            function $t(Ie, xe, ke, vt, ir) {
+              It(xe, vt, ir, Ie, ke, 7);
+              var ar = Number(xe & BigInt(4294967295));
+              Ie[ke++] = ar, ar = ar >> 8, Ie[ke++] = ar, ar = ar >> 8, Ie[ke++] = ar, ar = ar >> 8, Ie[ke++] = ar;
+              var vr = Number(xe >> BigInt(32) & BigInt(4294967295));
+              return Ie[ke++] = vr, vr = vr >> 8, Ie[ke++] = vr, vr = vr >> 8, Ie[ke++] = vr, vr = vr >> 8, Ie[ke++] = vr, ke;
+            }
+            function sr(Ie, xe, ke, vt, ir) {
+              It(xe, vt, ir, Ie, ke, 7);
+              var ar = Number(xe & BigInt(4294967295));
+              Ie[ke + 7] = ar, ar = ar >> 8, Ie[ke + 6] = ar, ar = ar >> 8, Ie[ke + 5] = ar, ar = ar >> 8, Ie[ke + 4] = ar;
+              var vr = Number(xe >> BigInt(32) & BigInt(4294967295));
+              return Ie[ke + 3] = vr, vr = vr >> 8, Ie[ke + 2] = vr, vr = vr >> 8, Ie[ke + 1] = vr, vr = vr >> 8, Ie[ke] = vr, ke + 8;
+            }
+            A.prototype.writeBigUInt64LE = tt(function(xe) {
+              var ke = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : 0;
+              return $t(this, xe, ke, BigInt(0), BigInt("0xffffffffffffffff"));
+            }), A.prototype.writeBigUInt64BE = tt(function(xe) {
+              var ke = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : 0;
+              return sr(this, xe, ke, BigInt(0), BigInt("0xffffffffffffffff"));
+            }), A.prototype.writeIntLE = function(xe, ke, vt, ir) {
+              if (xe = +xe, ke = ke >>> 0, !ir) {
+                var ar = Math.pow(2, 8 * vt - 1);
+                Nt(this, xe, ke, vt, ar - 1, -ar);
+              }
+              var vr = 0, ii = 1, pi = 0;
+              for (this[ke] = xe & 255; ++vr < vt && (ii *= 256); ) xe < 0 && pi === 0 && this[ke + vr - 1] !== 0 && (pi = 1), this[ke + vr] = (xe / ii >> 0) - pi & 255;
+              return ke + vt;
+            }, A.prototype.writeIntBE = function(xe, ke, vt, ir) {
+              if (xe = +xe, ke = ke >>> 0, !ir) {
+                var ar = Math.pow(2, 8 * vt - 1);
+                Nt(this, xe, ke, vt, ar - 1, -ar);
+              }
+              var vr = vt - 1, ii = 1, pi = 0;
+              for (this[ke + vr] = xe & 255; --vr >= 0 && (ii *= 256); ) xe < 0 && pi === 0 && this[ke + vr + 1] !== 0 && (pi = 1), this[ke + vr] = (xe / ii >> 0) - pi & 255;
+              return ke + vt;
+            }, A.prototype.writeInt8 = function(xe, ke, vt) {
+              return xe = +xe, ke = ke >>> 0, vt || Nt(this, xe, ke, 1, 127, -128), xe < 0 && (xe = 255 + xe + 1), this[ke] = xe & 255, ke + 1;
+            }, A.prototype.writeInt16LE = function(xe, ke, vt) {
+              return xe = +xe, ke = ke >>> 0, vt || Nt(this, xe, ke, 2, 32767, -32768), this[ke] = xe & 255, this[ke + 1] = xe >>> 8, ke + 2;
+            }, A.prototype.writeInt16BE = function(xe, ke, vt) {
+              return xe = +xe, ke = ke >>> 0, vt || Nt(this, xe, ke, 2, 32767, -32768), this[ke] = xe >>> 8, this[ke + 1] = xe & 255, ke + 2;
+            }, A.prototype.writeInt32LE = function(xe, ke, vt) {
+              return xe = +xe, ke = ke >>> 0, vt || Nt(this, xe, ke, 4, 2147483647, -2147483648), this[ke] = xe & 255, this[ke + 1] = xe >>> 8, this[ke + 2] = xe >>> 16, this[ke + 3] = xe >>> 24, ke + 4;
+            }, A.prototype.writeInt32BE = function(xe, ke, vt) {
+              return xe = +xe, ke = ke >>> 0, vt || Nt(this, xe, ke, 4, 2147483647, -2147483648), xe < 0 && (xe = 4294967295 + xe + 1), this[ke] = xe >>> 24, this[ke + 1] = xe >>> 16, this[ke + 2] = xe >>> 8, this[ke + 3] = xe & 255, ke + 4;
+            }, A.prototype.writeBigInt64LE = tt(function(xe) {
+              var ke = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : 0;
+              return $t(this, xe, ke, -BigInt("0x8000000000000000"), BigInt("0x7fffffffffffffff"));
+            }), A.prototype.writeBigInt64BE = tt(function(xe) {
+              var ke = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : 0;
+              return sr(this, xe, ke, -BigInt("0x8000000000000000"), BigInt("0x7fffffffffffffff"));
+            });
+            function Tr(Ie, xe, ke, vt, ir, ar) {
+              if (ke + vt > Ie.length) throw new RangeError("Index out of range");
+              if (ke < 0) throw new RangeError("Index out of range");
+            }
+            function fr(Ie, xe, ke, vt, ir) {
+              return xe = +xe, ke = ke >>> 0, ir || Tr(Ie, xe, ke, 4), x.write(Ie, xe, ke, vt, 23, 4), ke + 4;
+            }
+            A.prototype.writeFloatLE = function(xe, ke, vt) {
+              return fr(this, xe, ke, true, vt);
+            }, A.prototype.writeFloatBE = function(xe, ke, vt) {
+              return fr(this, xe, ke, false, vt);
+            };
+            function $e(Ie, xe, ke, vt, ir) {
+              return xe = +xe, ke = ke >>> 0, ir || Tr(Ie, xe, ke, 8), x.write(Ie, xe, ke, vt, 52, 8), ke + 8;
+            }
+            A.prototype.writeDoubleLE = function(xe, ke, vt) {
+              return $e(this, xe, ke, true, vt);
+            }, A.prototype.writeDoubleBE = function(xe, ke, vt) {
+              return $e(this, xe, ke, false, vt);
+            }, A.prototype.copy = function(xe, ke, vt, ir) {
+              if (!A.isBuffer(xe)) throw new TypeError("argument should be a Buffer");
+              if (vt || (vt = 0), !ir && ir !== 0 && (ir = this.length), ke >= xe.length && (ke = xe.length), ke || (ke = 0), ir > 0 && ir < vt && (ir = vt), ir === vt || xe.length === 0 || this.length === 0) return 0;
+              if (ke < 0) throw new RangeError("targetStart out of bounds");
+              if (vt < 0 || vt >= this.length) throw new RangeError("Index out of range");
+              if (ir < 0) throw new RangeError("sourceEnd out of bounds");
+              ir > this.length && (ir = this.length), xe.length - ke < ir - vt && (ir = xe.length - ke + vt);
+              var ar = ir - vt;
+              return this === xe && typeof Uint8Array.prototype.copyWithin == "function" ? this.copyWithin(ke, vt, ir) : Uint8Array.prototype.set.call(xe, this.subarray(vt, ir), ke), ar;
+            }, A.prototype.fill = function(xe, ke, vt, ir) {
+              if (typeof xe == "string") {
+                if (typeof ke == "string" ? (ir = ke, ke = 0, vt = this.length) : typeof vt == "string" && (ir = vt, vt = this.length), ir !== void 0 && typeof ir != "string") throw new TypeError("encoding must be a string");
+                if (typeof ir == "string" && !A.isEncoding(ir)) throw new TypeError("Unknown encoding: " + ir);
+                if (xe.length === 1) {
+                  var ar = xe.charCodeAt(0);
+                  (ir === "utf8" && ar < 128 || ir === "latin1") && (xe = ar);
+                }
+              } else typeof xe == "number" ? xe = xe & 255 : typeof xe == "boolean" && (xe = Number(xe));
+              if (ke < 0 || this.length < ke || this.length < vt) throw new RangeError("Out of range index");
+              if (vt <= ke) return this;
+              ke = ke >>> 0, vt = vt === void 0 ? this.length : vt >>> 0, xe || (xe = 0);
+              var vr;
+              if (typeof xe == "number") for (vr = ke; vr < vt; ++vr) this[vr] = xe;
+              else {
+                var ii = A.isBuffer(xe) ? xe : A.from(xe, ir), pi = ii.length;
+                if (pi === 0) throw new TypeError('The value "' + xe + '" is invalid for argument "value"');
+                for (vr = 0; vr < vt - ke; ++vr) this[vr + ke] = ii[vr % pi];
+              }
+              return this;
+            };
+            var St = {};
+            function Qt(Ie, xe, ke) {
+              St[Ie] = function(vt) {
+                function ir() {
+                  var ar;
+                  return l(this, ir), ar = d(this, ir), Object.defineProperty(ar, "message", { value: xe.apply(ar, arguments), writable: true, configurable: true }), ar.name = "".concat(ar.name, " [").concat(Ie, "]"), ar.stack, delete ar.name, ar;
+                }
+                return k(ir, vt), c(ir, [{ key: "code", get: function() {
+                  return Ie;
+                }, set: function(vr) {
+                  Object.defineProperty(this, "code", { configurable: true, enumerable: true, value: vr, writable: true });
+                } }, { key: "toString", value: function() {
+                  return "".concat(this.name, " [").concat(Ie, "]: ").concat(this.message);
+                } }]);
+              }(ke);
+            }
+            Qt("ERR_BUFFER_OUT_OF_BOUNDS", function(Ie) {
+              return Ie ? "".concat(Ie, " is outside of buffer bounds") : "Attempt to access memory outside buffer bounds";
+            }, RangeError), Qt("ERR_INVALID_ARG_TYPE", function(Ie, xe) {
+              return 'The "'.concat(Ie, '" argument must be of type number. Received type ').concat(T(xe));
+            }, TypeError), Qt("ERR_OUT_OF_RANGE", function(Ie, xe, ke) {
+              var vt = 'The value of "'.concat(Ie, '" is out of range.'), ir = ke;
+              return Number.isInteger(ke) && Math.abs(ke) > Math.pow(2, 32) ? ir = Gt(String(ke)) : typeof ke == "bigint" && (ir = String(ke), (ke > Math.pow(BigInt(2), BigInt(32)) || ke < -Math.pow(BigInt(2), BigInt(32))) && (ir = Gt(ir)), ir += "n"), vt += " It must be ".concat(xe, ". Received ").concat(ir), vt;
+            }, RangeError);
+            function Gt(Ie) {
+              for (var xe = "", ke = Ie.length, vt = Ie[0] === "-" ? 1 : 0; ke >= vt + 4; ke -= 3) xe = "_".concat(Ie.slice(ke - 3, ke)).concat(xe);
+              return "".concat(Ie.slice(0, ke)).concat(xe);
+            }
+            function _t(Ie, xe, ke) {
+              mt(xe, "offset"), (Ie[xe] === void 0 || Ie[xe + ke] === void 0) && er(xe, Ie.length - (ke + 1));
+            }
+            function It(Ie, xe, ke, vt, ir, ar) {
+              if (Ie > ke || Ie < xe) {
+                var vr = typeof xe == "bigint" ? "n" : "", ii;
+                throw xe === 0 || xe === BigInt(0) ? ii = ">= 0".concat(vr, " and < 2").concat(vr, " ** ").concat((ar + 1) * 8).concat(vr) : ii = ">= -(2".concat(vr, " ** ").concat((ar + 1) * 8 - 1).concat(vr, ") and < 2 ** ") + "".concat((ar + 1) * 8 - 1).concat(vr), new St.ERR_OUT_OF_RANGE("value", ii, Ie);
+              }
+              _t(vt, ir, ar);
+            }
+            function mt(Ie, xe) {
+              if (typeof Ie != "number") throw new St.ERR_INVALID_ARG_TYPE(xe, "number", Ie);
+            }
+            function er(Ie, xe, ke) {
+              throw Math.floor(Ie) !== Ie ? (mt(Ie, ke), new St.ERR_OUT_OF_RANGE("offset", "an integer", Ie)) : xe < 0 ? new St.ERR_BUFFER_OUT_OF_BOUNDS() : new St.ERR_OUT_OF_RANGE("offset", ">= ".concat(0, " and <= ").concat(xe), Ie);
+            }
+            var lr = /[^+/0-9A-Za-z-_]/g;
+            function wr(Ie) {
+              if (Ie = Ie.split("=")[0], Ie = Ie.trim().replace(lr, ""), Ie.length < 2) return "";
+              for (; Ie.length % 4 !== 0; ) Ie = Ie + "=";
+              return Ie;
+            }
+            function Lr(Ie, xe) {
+              xe = xe || 1 / 0;
+              for (var ke, vt = Ie.length, ir = null, ar = [], vr = 0; vr < vt; ++vr) {
+                if (ke = Ie.charCodeAt(vr), ke > 55295 && ke < 57344) {
+                  if (!ir) {
+                    if (ke > 56319) {
+                      (xe -= 3) > -1 && ar.push(239, 191, 189);
+                      continue;
+                    } else if (vr + 1 === vt) {
+                      (xe -= 3) > -1 && ar.push(239, 191, 189);
+                      continue;
+                    }
+                    ir = ke;
+                    continue;
+                  }
+                  if (ke < 56320) {
+                    (xe -= 3) > -1 && ar.push(239, 191, 189), ir = ke;
+                    continue;
+                  }
+                  ke = (ir - 55296 << 10 | ke - 56320) + 65536;
+                } else ir && (xe -= 3) > -1 && ar.push(239, 191, 189);
+                if (ir = null, ke < 128) {
+                  if ((xe -= 1) < 0) break;
+                  ar.push(ke);
+                } else if (ke < 2048) {
+                  if ((xe -= 2) < 0) break;
+                  ar.push(ke >> 6 | 192, ke & 63 | 128);
+                } else if (ke < 65536) {
+                  if ((xe -= 3) < 0) break;
+                  ar.push(ke >> 12 | 224, ke >> 6 & 63 | 128, ke & 63 | 128);
+                } else if (ke < 1114112) {
+                  if ((xe -= 4) < 0) break;
+                  ar.push(ke >> 18 | 240, ke >> 12 & 63 | 128, ke >> 6 & 63 | 128, ke & 63 | 128);
+                } else throw new Error("Invalid code point");
+              }
+              return ar;
+            }
+            function ti(Ie) {
+              for (var xe = [], ke = 0; ke < Ie.length; ++ke) xe.push(Ie.charCodeAt(ke) & 255);
+              return xe;
+            }
+            function Br(Ie, xe) {
+              for (var ke, vt, ir, ar = [], vr = 0; vr < Ie.length && !((xe -= 2) < 0); ++vr) ke = Ie.charCodeAt(vr), vt = ke >> 8, ir = ke % 256, ar.push(ir), ar.push(vt);
+              return ar;
+            }
+            function Vr(Ie) {
+              return L.toByteArray(wr(Ie));
+            }
+            function dt(Ie, xe, ke, vt) {
+              var ir;
+              for (ir = 0; ir < vt && !(ir + ke >= xe.length || ir >= Ie.length); ++ir) xe[ir + ke] = Ie[ir];
+              return ir;
+            }
+            function Ge(Ie, xe) {
+              return Ie instanceof xe || Ie != null && Ie.constructor != null && Ie.constructor.name != null && Ie.constructor.name === xe.name;
+            }
+            function Je(Ie) {
+              return Ie !== Ie;
+            }
+            var We = function() {
+              for (var Ie = "0123456789abcdef", xe = new Array(256), ke = 0; ke < 16; ++ke) for (var vt = ke * 16, ir = 0; ir < 16; ++ir) xe[vt + ir] = Ie[ke] + Ie[ir];
+              return xe;
+            }();
+            function tt(Ie) {
+              return typeof BigInt == "undefined" ? xt : Ie;
+            }
+            function xt() {
+              throw new Error("BigInt not supported");
+            }
+          }, 4844: function(i) {
+            i.exports = a;
+            function a(o, s, l, u) {
+              return o[0] = s[0] + l[0] * u, o[1] = s[1] + l[1] * u, o[2] = s[2] + l[2] * u, o[3] = s[3] + l[3] * u, o;
+            }
+          }, 4905: function(i, a, o) {
+            var s = o(5874);
+            i.exports = l;
+            function l(u, c) {
+              var f = s(c), h = [];
+              return h = h.concat(f(u)), h = h.concat(f(null)), h;
+            }
+          }, 4935: function(i, a, o) {
+            i.exports = k;
+            var s = o(2762), l = o(8116), u = o(4359), c = o(1879).Q, f = window || process.global || {}, h = f.__TEXT_CACHE || {};
+            f.__TEXT_CACHE = {};
+            var d = 3;
+            function v(E, T, L, x) {
+              this.gl = E, this.shader = T, this.buffer = L, this.vao = x, this.tickOffset = this.tickCount = this.labelOffset = this.labelCount = null;
+            }
+            var _ = v.prototype, b = [0, 0];
+            _.bind = function(E, T, L, x) {
+              this.vao.bind(), this.shader.bind();
+              var C = this.shader.uniforms;
+              C.model = E, C.view = T, C.projection = L, C.pixelScale = x, b[0] = this.gl.drawingBufferWidth, b[1] = this.gl.drawingBufferHeight, this.shader.uniforms.resolution = b;
+            }, _.unbind = function() {
+              this.vao.unbind();
+            }, _.update = function(E, T, L, x, C) {
+              var M = [];
+              function g(H, re, oe, _e, Ce, Le) {
+                var ge = [oe.style, oe.weight, oe.variant, oe.family].join("_"), ie = h[ge];
+                ie || (ie = h[ge] = {});
+                var Se = ie[re];
+                Se || (Se = ie[re] = p(re, { triangles: true, font: oe.family, fontStyle: oe.style, fontWeight: oe.weight, fontVariant: oe.variant, textAlign: "center", textBaseline: "middle", lineSpacing: Ce, styletags: Le }));
+                for (var Ee = (_e || 12) / 12, Ae = Se.positions, Be = Se.cells, Pe = 0, me = Be.length; Pe < me; ++Pe) for (var De = Be[Pe], ce = 2; ce >= 0; --ce) {
+                  var je = Ae[De[ce]];
+                  M.push(Ee * je[0], -Ee * je[1], H);
+                }
+              }
+              for (var P = [0, 0, 0], A = [0, 0, 0], z = [0, 0, 0], O = [0, 0, 0], U = 1.25, G = { breaklines: true, bolds: true, italics: true, subscripts: true, superscripts: true }, Z = 0; Z < 3; ++Z) {
+                z[Z] = M.length / d | 0, g(0.5 * (E[0][Z] + E[1][Z]), T[Z], L[Z], 12, U, G), O[Z] = (M.length / d | 0) - z[Z], P[Z] = M.length / d | 0;
+                for (var j = 0; j < x[Z].length; ++j) if (x[Z][j].text) {
+                  var N = { family: x[Z][j].font || C[Z].family, style: C[Z].fontStyle || C[Z].style, weight: C[Z].fontWeight || C[Z].weight, variant: C[Z].fontVariant || C[Z].variant };
+                  g(x[Z][j].x, x[Z][j].text, N, x[Z][j].fontSize || 12, U, G);
+                }
+                A[Z] = (M.length / d | 0) - P[Z];
+              }
+              this.buffer.update(M), this.tickOffset = P, this.tickCount = A, this.labelOffset = z, this.labelCount = O;
+            }, _.drawTicks = function(E, T, L, x, C, M, g, P) {
+              this.tickCount[E] && (this.shader.uniforms.axis = M, this.shader.uniforms.color = C, this.shader.uniforms.angle = L, this.shader.uniforms.scale = T, this.shader.uniforms.offset = x, this.shader.uniforms.alignDir = g, this.shader.uniforms.alignOpt = P, this.vao.draw(this.gl.TRIANGLES, this.tickCount[E], this.tickOffset[E]));
+            }, _.drawLabel = function(E, T, L, x, C, M, g, P) {
+              this.labelCount[E] && (this.shader.uniforms.axis = M, this.shader.uniforms.color = C, this.shader.uniforms.angle = L, this.shader.uniforms.scale = T, this.shader.uniforms.offset = x, this.shader.uniforms.alignDir = g, this.shader.uniforms.alignOpt = P, this.vao.draw(this.gl.TRIANGLES, this.labelCount[E], this.labelOffset[E]));
+            }, _.dispose = function() {
+              this.shader.dispose(), this.vao.dispose(), this.buffer.dispose();
+            };
+            function p(E, T) {
+              try {
+                return u(E, T);
+              } catch (L) {
+                return console.warn('error vectorizing text:"' + E + '" error:', L), { cells: [], positions: [] };
+              }
+            }
+            function k(E, T, L, x, C, M) {
+              var g = s(E), P = l(E, [{ buffer: g, size: 3 }]), A = c(E);
+              A.attributes.position.location = 0;
+              var z = new v(E, A, g, P);
+              return z.update(T, L, x, C, M), z;
+            }
+          }, 5023: function(i, a, o) {
+            var s = o(2478);
+            i.exports = d;
+            function l(v, _, b, p, k, E, T) {
+              this.cells = v, this.neighbor = _, this.flags = p, this.constraint = b, this.active = k, this.next = E, this.boundary = T;
+            }
+            var u = l.prototype;
+            function c(v, _) {
+              return v[0] - _[0] || v[1] - _[1] || v[2] - _[2];
+            }
+            u.locate = /* @__PURE__ */ function() {
+              var v = [0, 0, 0];
+              return function(_, b, p) {
+                var k = _, E = b, T = p;
+                return b < p ? b < _ && (k = b, E = p, T = _) : p < _ && (k = p, E = _, T = b), k < 0 ? -1 : (v[0] = k, v[1] = E, v[2] = T, s.eq(this.cells, v, c));
+              };
+            }();
+            function f(v, _) {
+              for (var b = v.cells(), p = b.length, k = 0; k < p; ++k) {
+                var E = b[k], T = E[0], L = E[1], x = E[2];
+                L < x ? L < T && (E[0] = L, E[1] = x, E[2] = T) : x < T && (E[0] = x, E[1] = T, E[2] = L);
+              }
+              b.sort(c);
+              for (var C = new Array(p), k = 0; k < C.length; ++k) C[k] = 0;
+              var M = [], g = [], P = new Array(3 * p), A = new Array(3 * p), z = null;
+              _ && (z = []);
+              for (var O = new l(b, P, A, C, M, g, z), k = 0; k < p; ++k) for (var E = b[k], U = 0; U < 3; ++U) {
+                var T = E[U], L = E[(U + 1) % 3], G = P[3 * k + U] = O.locate(L, T, v.opposite(L, T)), Z = A[3 * k + U] = v.isConstraint(T, L);
+                G < 0 && (Z ? g.push(k) : (M.push(k), C[k] = 1), _ && z.push([L, T, -1]));
+              }
+              return O;
+            }
+            function h(v, _, b) {
+              for (var p = 0, k = 0; k < v.length; ++k) _[k] === b && (v[p++] = v[k]);
+              return v.length = p, v;
+            }
+            function d(v, _, b) {
+              var p = f(v, b);
+              if (_ === 0) return b ? p.cells.concat(p.boundary) : p.cells;
+              for (var k = 1, E = p.active, T = p.next, L = p.flags, x = p.cells, C = p.constraint, M = p.neighbor; E.length > 0 || T.length > 0; ) {
+                for (; E.length > 0; ) {
+                  var g = E.pop();
+                  if (L[g] !== -k) {
+                    L[g] = k;
+                    for (var P = x[g], A = 0; A < 3; ++A) {
+                      var z = M[3 * g + A];
+                      z >= 0 && L[z] === 0 && (C[3 * g + A] ? T.push(z) : (E.push(z), L[z] = k));
+                    }
+                  }
+                }
+                var O = T;
+                T = E, E = O, T.length = 0, k = -k;
+              }
+              var U = h(x, L, _);
+              return b ? U.concat(p.boundary) : U;
+            }
+          }, 5033: function(i) {
+            i.exports = a;
+            function a(o, s, l) {
+              var u = s || 0, c = l || 1;
+              return [[o[12] + o[0], o[13] + o[1], o[14] + o[2], o[15] + o[3]], [o[12] - o[0], o[13] - o[1], o[14] - o[2], o[15] - o[3]], [o[12] + o[4], o[13] + o[5], o[14] + o[6], o[15] + o[7]], [o[12] - o[4], o[13] - o[5], o[14] - o[6], o[15] - o[7]], [u * o[12] + o[8], u * o[13] + o[9], u * o[14] + o[10], u * o[15] + o[11]], [c * o[12] - o[8], c * o[13] - o[9], c * o[14] - o[10], c * o[15] - o[11]]];
+            }
+          }, 5085: function(i, a, o) {
+            i.exports = k;
+            var s = o(3250)[3], l = o(4209), u = o(3352), c = o(2478);
+            function f() {
+              return true;
+            }
+            function h(E) {
+              return function(T, L) {
+                var x = E[T];
+                return x ? !!x.queryPoint(L, f) : false;
+              };
+            }
+            function d(E) {
+              for (var T = {}, L = 0; L < E.length; ++L) {
+                var x = E[L], C = x[0][0], M = x[0][1], g = x[1][1], P = [Math.min(M, g), Math.max(M, g)];
+                C in T ? T[C].push(P) : T[C] = [P];
+              }
+              for (var A = {}, z = Object.keys(T), L = 0; L < z.length; ++L) {
+                var O = T[z[L]];
+                A[z[L]] = u(O);
+              }
+              return h(A);
+            }
+            function v(E, T) {
+              return function(L) {
+                var x = c.le(T, L[0]);
+                if (x < 0) return 1;
+                var C = E[x];
+                if (!C) if (x > 0 && T[x] === L[0]) C = E[x - 1];
+                else return 1;
+                for (var M = 1; C; ) {
+                  var g = C.key, P = s(L, g[0], g[1]);
+                  if (g[0][0] < g[1][0]) if (P < 0) C = C.left;
+                  else if (P > 0) M = -1, C = C.right;
+                  else return 0;
+                  else if (P > 0) C = C.left;
+                  else if (P < 0) M = 1, C = C.right;
+                  else return 0;
+                }
+                return M;
+              };
+            }
+            function _(E) {
+              return 1;
+            }
+            function b(E) {
+              return function(L) {
+                return E(L[0], L[1]) ? 0 : 1;
+              };
+            }
+            function p(E, T) {
+              return function(x) {
+                return E(x[0], x[1]) ? 0 : T(x);
+              };
+            }
+            function k(E) {
+              for (var T = E.length, L = [], x = [], C = 0, M = 0; M < T; ++M) for (var g = E[M], P = g.length, A = P - 1, z = 0; z < P; A = z++) {
+                var O = g[A], U = g[z];
+                O[0] === U[0] ? x.push([O, U]) : L.push([O, U]);
+              }
+              if (L.length === 0) return x.length === 0 ? _ : b(d(x));
+              var G = l(L), Z = v(G.slabs, G.coordinates);
+              return x.length === 0 ? Z : p(d(x), Z);
+            }
+          }, 5091: function(i, a, o) {
+            a.shader = k, a.program = E;
+            var s = o(8866), l = o(2992), u = typeof WeakMap == "undefined" ? o(606) : WeakMap, c = new u(), f = 0;
+            function h(T, L, x, C, M, g, P) {
+              this.id = T, this.src = L, this.type = x, this.shader = C, this.count = g, this.programs = [], this.cache = P;
+            }
+            h.prototype.dispose = function() {
+              if (--this.count === 0) {
+                for (var T = this.cache, L = T.gl, x = this.programs, C = 0, M = x.length; C < M; ++C) {
+                  var g = T.programs[x[C]];
+                  g && (delete T.programs[C], L.deleteProgram(g));
+                }
+                L.deleteShader(this.shader), delete T.shaders[this.type === L.FRAGMENT_SHADER | 0][this.src];
+              }
+            };
+            function d(T) {
+              this.gl = T, this.shaders = [{}, {}], this.programs = {};
+            }
+            var v = d.prototype;
+            function _(T, L, x) {
+              var C = T.createShader(L);
+              if (T.shaderSource(C, x), T.compileShader(C), !T.getShaderParameter(C, T.COMPILE_STATUS)) {
+                var M = T.getShaderInfoLog(C);
+                try {
+                  var g = l(M, x, L);
+                } catch (P) {
+                  throw console.warn("Failed to format compiler error: " + P), new s(M, `Error compiling shader:
+` + M);
+                }
+                throw new s(M, g.short, g.long);
+              }
+              return C;
+            }
+            v.getShaderReference = function(T, L) {
+              var x = this.gl, C = this.shaders[T === x.FRAGMENT_SHADER | 0], M = C[L];
+              if (!M || !x.isShader(M.shader)) {
+                var g = _(x, T, L);
+                M = C[L] = new h(f++, L, T, g, [], 1, this);
+              } else M.count += 1;
+              return M;
+            };
+            function b(T, L, x, C, M) {
+              var g = T.createProgram();
+              T.attachShader(g, L), T.attachShader(g, x);
+              for (var P = 0; P < C.length; ++P) T.bindAttribLocation(g, M[P], C[P]);
+              if (T.linkProgram(g), !T.getProgramParameter(g, T.LINK_STATUS)) {
+                var A = T.getProgramInfoLog(g);
+                throw new s(A, "Error linking program: " + A);
+              }
+              return g;
+            }
+            v.getProgram = function(T, L, x, C) {
+              var M = [T.id, L.id, x.join(":"), C.join(":")].join("@"), g = this.programs[M];
+              return (!g || !this.gl.isProgram(g)) && (this.programs[M] = g = b(this.gl, T.shader, L.shader, x, C), T.programs.push(M), L.programs.push(M)), g;
+            };
+            function p(T) {
+              var L = c.get(T);
+              return L || (L = new d(T), c.set(T, L)), L;
+            }
+            function k(T, L, x) {
+              return p(T).getShaderReference(L, x);
+            }
+            function E(T, L, x, C, M) {
+              return p(T).getProgram(L, x, C, M);
+            }
+          }, 5093: function(i) {
+            i.exports = a;
+            function a(o, s) {
+              return o[0] = -s[0], o[1] = -s[1], o[2] = -s[2], o;
+            }
+          }, 5137: function(i, a, o) {
+            i.exports = l;
+            var s = o(1091)();
+            function l(u, c, f, h, d, v) {
+              var _, b;
+              for (c || (c = 3), f || (f = 0), h ? b = Math.min(h * c + f, u.length) : b = u.length, _ = f; _ < b; _ += c) s[0] = u[_], s[1] = u[_ + 1], s[2] = u[_ + 2], d(s, s, v), u[_] = s[0], u[_ + 1] = s[1], u[_ + 2] = s[2];
+              return u;
+            }
+          }, 5171: function(i, a, o) {
+            var s = o(737);
+            i.exports = function(u) {
+              return s[u];
+            };
+          }, 5177: function(i) {
+            i.exports = a;
+            function a(o, s) {
+              var l = s[0], u = s[1], c = s[2], f = s[3], h = l * l + u * u + c * c + f * f;
+              return h > 0 && (h = 1 / Math.sqrt(h), o[0] = l * h, o[1] = u * h, o[2] = c * h, o[3] = f * h), o;
+            }
+          }, 5202: function(i, a, o) {
+            var s = o(1944), l = o(8210);
+            i.exports = f, i.exports.positive = h, i.exports.negative = d;
+            function u(v, _) {
+              var b = l(s(v, _), [_[_.length - 1]]);
+              return b[b.length - 1];
+            }
+            function c(v, _, b, p) {
+              var k = p - _, E = -_ / k;
+              E < 0 ? E = 0 : E > 1 && (E = 1);
+              for (var T = 1 - E, L = v.length, x = new Array(L), C = 0; C < L; ++C) x[C] = E * v[C] + T * b[C];
+              return x;
+            }
+            function f(v, _) {
+              for (var b = [], p = [], k = u(v[v.length - 1], _), E = v[v.length - 1], T = v[0], L = 0; L < v.length; ++L, E = T) {
+                T = v[L];
+                var x = u(T, _);
+                if (k < 0 && x > 0 || k > 0 && x < 0) {
+                  var C = c(E, x, T, k);
+                  b.push(C), p.push(C.slice());
+                }
+                x < 0 ? p.push(T.slice()) : x > 0 ? b.push(T.slice()) : (b.push(T.slice()), p.push(T.slice())), k = x;
+              }
+              return { positive: b, negative: p };
+            }
+            function h(v, _) {
+              for (var b = [], p = u(v[v.length - 1], _), k = v[v.length - 1], E = v[0], T = 0; T < v.length; ++T, k = E) {
+                E = v[T];
+                var L = u(E, _);
+                (p < 0 && L > 0 || p > 0 && L < 0) && b.push(c(k, L, E, p)), L >= 0 && b.push(E.slice()), p = L;
+              }
+              return b;
+            }
+            function d(v, _) {
+              for (var b = [], p = u(v[v.length - 1], _), k = v[v.length - 1], E = v[0], T = 0; T < v.length; ++T, k = E) {
+                E = v[T];
+                var L = u(E, _);
+                (p < 0 && L > 0 || p > 0 && L < 0) && b.push(c(k, L, E, p)), L <= 0 && b.push(E.slice()), p = L;
+              }
+              return b;
+            }
+          }, 5219: function(i) {
+            i.exports = function(a) {
+              for (var o = a.length, s, l = 0; l < o; l++) if (s = a.charCodeAt(l), (s < 9 || s > 13) && s !== 32 && s !== 133 && s !== 160 && s !== 5760 && s !== 6158 && (s < 8192 || s > 8205) && s !== 8232 && s !== 8233 && s !== 8239 && s !== 8287 && s !== 8288 && s !== 12288 && s !== 65279) return false;
+              return true;
+            };
+          }, 5250: function(i) {
+            i.exports = o;
+            var a = +(Math.pow(2, 27) + 1);
+            function o(s, l, u) {
+              var c = s * l, f = a * s, h = f - s, d = f - h, v = s - d, _ = a * l, b = _ - l, p = _ - b, k = l - p, E = c - d * p, T = E - v * p, L = T - d * k, x = v * k - L;
+              return u ? (u[0] = x, u[1] = c, u) : [x, c];
+            }
+          }, 5298: function(i, a) {
+            var o = { "float64,2,1,0": function() {
+              return function(v, _, b, p, k) {
+                var E = v[0], T = v[1], L = v[2], x = b[0], C = b[1], M = b[2];
+                p |= 0;
+                var g = 0, P = 0, A = 0, z = M, O = C - L * M, U = x - T * C;
+                for (A = 0; A < E; ++A) {
+                  for (P = 0; P < T; ++P) {
+                    for (g = 0; g < L; ++g) _[p] /= k, p += z;
+                    p += O;
+                  }
+                  p += U;
+                }
+              };
+            }, "uint8,2,0,1,float64,2,1,0": function() {
+              return function(v, _, b, p, k, E, T, L) {
+                var x = v[0], C = v[1], M = v[2], g = b[0], P = b[1], A = b[2], z = E[0], O = E[1], U = E[2];
+                p |= 0, T |= 0;
+                for (var G = p, Z = T, j = v[0] | 0; j > 0; ) {
+                  j < 64 ? (x = j, j = 0) : (x = 64, j -= 64);
+                  for (var N = v[1] | 0; N > 0; ) {
+                    N < 64 ? (C = N, N = 0) : (C = 64, N -= 64), p = G + j * g + N * P, T = Z + j * z + N * O;
+                    var H = 0, re = 0, oe = 0, _e = A, Ce = g - M * A, Le = P - x * g, ge = U, ie = z - M * U, Se = O - x * z;
+                    for (oe = 0; oe < C; ++oe) {
+                      for (re = 0; re < x; ++re) {
+                        for (H = 0; H < M; ++H) _[p] = k[T] * L, p += _e, T += ge;
+                        p += Ce, T += ie;
+                      }
+                      p += Le, T += Se;
+                    }
+                  }
+                }
+              };
+            }, "float32,1,0,float32,1,0": function() {
+              return function(v, _, b, p, k, E, T) {
+                var L = v[0], x = v[1], C = b[0], M = b[1], g = E[0], P = E[1];
+                p |= 0, T |= 0;
+                var A = 0, z = 0, O = M, U = C - x * M, G = P, Z = g - x * P;
+                for (z = 0; z < L; ++z) {
+                  for (A = 0; A < x; ++A) _[p] = k[T], p += O, T += G;
+                  p += U, T += Z;
+                }
+              };
+            }, "float32,1,0,float32,0,1": function() {
+              return function(v, _, b, p, k, E, T) {
+                var L = v[0], x = v[1], C = b[0], M = b[1], g = E[0], P = E[1];
+                p |= 0, T |= 0;
+                for (var A = p, z = T, O = v[1] | 0; O > 0; ) {
+                  O < 64 ? (x = O, O = 0) : (x = 64, O -= 64);
+                  for (var U = v[0] | 0; U > 0; ) {
+                    U < 64 ? (L = U, U = 0) : (L = 64, U -= 64), p = A + O * M + U * C, T = z + O * P + U * g;
+                    var G = 0, Z = 0, j = M, N = C - x * M, H = P, re = g - x * P;
+                    for (Z = 0; Z < L; ++Z) {
+                      for (G = 0; G < x; ++G) _[p] = k[T], p += j, T += H;
+                      p += N, T += re;
+                    }
+                  }
+                }
+              };
+            }, "uint8,2,0,1,uint8,1,2,0": function() {
+              return function(v, _, b, p, k, E, T) {
+                var L = v[0], x = v[1], C = v[2], M = b[0], g = b[1], P = b[2], A = E[0], z = E[1], O = E[2];
+                p |= 0, T |= 0;
+                for (var U = p, G = T, Z = v[2] | 0; Z > 0; ) {
+                  Z < 64 ? (C = Z, Z = 0) : (C = 64, Z -= 64);
+                  for (var j = v[0] | 0; j > 0; ) {
+                    j < 64 ? (L = j, j = 0) : (L = 64, j -= 64);
+                    for (var N = v[1] | 0; N > 0; ) {
+                      N < 64 ? (x = N, N = 0) : (x = 64, N -= 64), p = U + Z * P + j * M + N * g, T = G + Z * O + j * A + N * z;
+                      var H = 0, re = 0, oe = 0, _e = P, Ce = M - C * P, Le = g - L * M, ge = O, ie = A - C * O, Se = z - L * A;
+                      for (oe = 0; oe < x; ++oe) {
+                        for (re = 0; re < L; ++re) {
+                          for (H = 0; H < C; ++H) _[p] = k[T], p += _e, T += ge;
+                          p += Ce, T += ie;
+                        }
+                        p += Le, T += Se;
+                      }
+                    }
+                  }
+                }
+              };
+            }, "uint8,2,0,1,array,2,0,1": function() {
+              return function(v, _, b, p, k, E, T) {
+                var L = v[0], x = v[1], C = v[2], M = b[0], g = b[1], P = b[2], A = E[0], z = E[1], O = E[2];
+                p |= 0, T |= 0;
+                var U = 0, G = 0, Z = 0, j = P, N = M - C * P, H = g - L * M, re = O, oe = A - C * O, _e = z - L * A;
+                for (Z = 0; Z < x; ++Z) {
+                  for (G = 0; G < L; ++G) {
+                    for (U = 0; U < C; ++U) _[p] = k[T], p += j, T += re;
+                    p += N, T += oe;
+                  }
+                  p += H, T += _e;
+                }
+              };
+            } };
+            function s(d, v) {
+              var _ = v.join(","), b = o[_];
+              return b();
+            }
+            var l = s, u = { mul: function(d) {
+              var v = {};
+              return function(b, p, k) {
+                var E = b.dtype, T = b.order, L = p.dtype, x = p.order, C = k.dtype, M = k.order, g = [E, T.join(), L, x.join(), C, M.join()].join(), P = v[g];
+                return P || (v[g] = P = d([E, T, L, x, C, M])), P(b.shape.slice(0), b.data, b.stride, b.offset | 0, p.data, p.stride, p.offset | 0, k.data, k.stride, k.offset | 0);
+              };
+            }, muls: function(d) {
+              var v = {};
+              return function(b, p, k) {
+                var E = b.dtype, T = b.order, L = p.dtype, x = p.order, C = [E, T.join(), L, x.join()].join(), M = v[C];
+                return M || (v[C] = M = d([E, T, L, x])), M(b.shape.slice(0), b.data, b.stride, b.offset | 0, p.data, p.stride, p.offset | 0, k);
+              };
+            }, mulseq: function(d) {
+              var v = {};
+              return function(b, p) {
+                var k = b.dtype, E = b.order, T = [k, E.join()].join(), L = v[T];
+                return L || (v[T] = L = d([k, E])), L(b.shape.slice(0), b.data, b.stride, b.offset | 0, p);
+              };
+            }, div: function(d) {
+              var v = {};
+              return function(b, p, k) {
+                var E = b.dtype, T = b.order, L = p.dtype, x = p.order, C = k.dtype, M = k.order, g = [E, T.join(), L, x.join(), C, M.join()].join(), P = v[g];
+                return P || (v[g] = P = d([E, T, L, x, C, M])), P(b.shape.slice(0), b.data, b.stride, b.offset | 0, p.data, p.stride, p.offset | 0, k.data, k.stride, k.offset | 0);
+              };
+            }, divs: function(d) {
+              var v = {};
+              return function(b, p, k) {
+                var E = b.dtype, T = b.order, L = p.dtype, x = p.order, C = [E, T.join(), L, x.join()].join(), M = v[C];
+                return M || (v[C] = M = d([E, T, L, x])), M(b.shape.slice(0), b.data, b.stride, b.offset | 0, p.data, p.stride, p.offset | 0, k);
+              };
+            }, divseq: function(d) {
+              var v = {};
+              return function(b, p) {
+                var k = b.dtype, E = b.order, T = [k, E.join()].join(), L = v[T];
+                return L || (v[T] = L = d([k, E])), L(b.shape.slice(0), b.data, b.stride, b.offset | 0, p);
+              };
+            }, assign: function(d) {
+              var v = {};
+              return function(b, p) {
+                var k = b.dtype, E = b.order, T = p.dtype, L = p.order, x = [k, E.join(), T, L.join()].join(), C = v[x];
+                return C || (v[x] = C = d([k, E, T, L])), C(b.shape.slice(0), b.data, b.stride, b.offset | 0, p.data, p.stride, p.offset | 0);
+              };
+            } };
+            function c(d) {
+              var v = u[d.funcName];
+              return v(l.bind(void 0, d));
+            }
+            function f(d) {
+              return c({ funcName: d.funcName });
+            }
+            var h = { mul: "*", div: "/" };
+            (function() {
+              for (var d in h) a[d] = f({ funcName: d }), a[d + "s"] = f({ funcName: d + "s" }), a[d + "seq"] = f({ funcName: d + "seq" });
+            })(), a.assign = f({ funcName: "assign" });
+          }, 5304: function(i, a, o) {
+            i.exports = h;
+            var s = o(2762), l = o(8116), u = o(1879).bg;
+            function c(d, v, _, b) {
+              this.gl = d, this.buffer = v, this.vao = _, this.shader = b;
+            }
+            var f = c.prototype;
+            f.draw = function(d, v, _, b, p, k) {
+              for (var E = false, T = 0; T < 3; ++T) E = E || p[T];
+              if (E) {
+                var L = this.gl;
+                L.enable(L.POLYGON_OFFSET_FILL), L.polygonOffset(1, 2), this.shader.bind(), this.shader.uniforms = { model: d, view: v, projection: _, bounds: b, enable: p, colors: k }, this.vao.bind(), this.vao.draw(this.gl.TRIANGLES, 36), this.vao.unbind(), L.disable(L.POLYGON_OFFSET_FILL);
+              }
+            }, f.dispose = function() {
+              this.vao.dispose(), this.buffer.dispose(), this.shader.dispose();
+            };
+            function h(d) {
+              for (var v = [], _ = [], b = 0, p = 0; p < 3; ++p) for (var k = (p + 1) % 3, E = (p + 2) % 3, T = [0, 0, 0], L = [0, 0, 0], x = -1; x <= 1; x += 2) {
+                _.push(b, b + 2, b + 1, b + 1, b + 2, b + 3), T[p] = x, L[p] = x;
+                for (var C = -1; C <= 1; C += 2) {
+                  T[k] = C;
+                  for (var M = -1; M <= 1; M += 2) T[E] = M, v.push(T[0], T[1], T[2], L[0], L[1], L[2]), b += 1;
+                }
+                var g = k;
+                k = E, E = g;
+              }
+              var P = s(d, new Float32Array(v)), A = s(d, new Uint16Array(_), d.ELEMENT_ARRAY_BUFFER), z = l(d, [{ buffer: P, type: d.FLOAT, size: 3, offset: 0, stride: 24 }, { buffer: P, type: d.FLOAT, size: 3, offset: 12, stride: 24 }], A), O = u(d);
+              return O.attributes.position.location = 0, O.attributes.normal.location = 1, new c(d, P, z, O);
+            }
+          }, 5352: function(i) {
+            i.exports = a;
+            function a(o, s, l) {
+              var u = s[0], c = s[1], f = s[2], h = s[3];
+              return o[0] = l[0] * u + l[4] * c + l[8] * f + l[12] * h, o[1] = l[1] * u + l[5] * c + l[9] * f + l[13] * h, o[2] = l[2] * u + l[6] * c + l[10] * f + l[14] * h, o[3] = l[3] * u + l[7] * c + l[11] * f + l[15] * h, o;
+            }
+          }, 5382: function(i, a, o) {
+            var s = o(8210), l = o(3012);
+            i.exports = u;
+            function u(c, f) {
+              if (c.length === 1) return l(f, c[0]);
+              if (f.length === 1) return l(c, f[0]);
+              if (c.length === 0 || f.length === 0) return [0];
+              var h = [0];
+              if (c.length < f.length) for (var d = 0; d < c.length; ++d) h = s(h, l(f, c[d]));
+              else for (var d = 0; d < f.length; ++d) h = s(h, l(c, f[d]));
+              return h;
+            }
+          }, 5445: function(i, a, o) {
+            i.exports = L;
+            var s = o(5033), l = o(5202), u = o(6429), c = o(6760), f = o(5665), h = o(5352), d = new Float32Array([1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1]), v = new Float32Array(16);
+            function _(x, C, M) {
+              this.lo = x, this.hi = C, this.pixelsPerDataUnit = M;
+            }
+            var b = [0, 0, 0, 1], p = [0, 0, 0, 1];
+            function k(x, C, M, g, P) {
+              for (var A = 0; A < 3; ++A) {
+                for (var z = b, O = p, U = 0; U < 3; ++U) O[U] = z[U] = M[U];
+                O[3] = z[3] = 1, O[A] += 1, h(O, O, C), O[3] < 0 && (x[A] = 1 / 0), z[A] -= 1, h(z, z, C), z[3] < 0 && (x[A] = 1 / 0);
+                var G = (z[0] / z[3] - O[0] / O[3]) * g, Z = (z[1] / z[3] - O[1] / O[3]) * P;
+                x[A] = 0.25 * Math.sqrt(G * G + Z * Z);
+              }
+              return x;
+            }
+            var E = [new _(1 / 0, -1 / 0, 1 / 0), new _(1 / 0, -1 / 0, 1 / 0), new _(1 / 0, -1 / 0, 1 / 0)], T = [0, 0, 0];
+            function L(x, C, M, g, Z) {
+              var A = C.model || d, z = C.view || d, O = C.projection || d, U = C._ortho || false, G = x.bounds, Z = Z || u(A, z, O, G, U), j = Z.axis;
+              c(v, z, A), c(v, O, v);
+              for (var N = E, H = 0; H < 3; ++H) N[H].lo = 1 / 0, N[H].hi = -1 / 0, N[H].pixelsPerDataUnit = 1 / 0;
+              var re = s(f(v, v));
+              f(v, v);
+              for (var oe = 0; oe < 3; ++oe) {
+                var _e = (oe + 1) % 3, Ce = (oe + 2) % 3, Le = T;
+                e: for (var H = 0; H < 2; ++H) {
+                  var ge = [];
+                  if (j[oe] < 0 != !!H) {
+                    Le[oe] = G[H][oe];
+                    for (var ie = 0; ie < 2; ++ie) {
+                      Le[_e] = G[ie ^ H][_e];
+                      for (var Se = 0; Se < 2; ++Se) Le[Ce] = G[Se ^ ie ^ H][Ce], ge.push(Le.slice());
+                    }
+                    for (var Ee = U ? 5 : 4, ie = Ee; ie === Ee; ++ie) {
+                      if (ge.length === 0) continue e;
+                      ge = l.positive(ge, re[ie]);
+                    }
+                    for (var ie = 0; ie < ge.length; ++ie) for (var Ce = ge[ie], Ae = k(T, v, Ce, M, g), Se = 0; Se < 3; ++Se) N[Se].lo = Math.min(N[Se].lo, Ce[Se]), N[Se].hi = Math.max(N[Se].hi, Ce[Se]), Se !== oe && (N[Se].pixelsPerDataUnit = Math.min(N[Se].pixelsPerDataUnit, Math.abs(Ae[Se])));
+                  }
+                }
+              }
+              return N;
+            }
+          }, 5455: function(i, a, o) {
+            i.exports = o(7056);
+          }, 5486: function(i, a, o) {
+            i.exports = o(3066);
+          }, 5542: function(i, a, o) {
+            var s = o(2478);
+            i.exports = f;
+            function l(h, d) {
+              this.stars = h, this.edges = d;
+            }
+            var u = l.prototype;
+            function c(h, d, v) {
+              for (var _ = 1, b = h.length; _ < b; _ += 2) if (h[_ - 1] === d && h[_] === v) {
+                h[_ - 1] = h[b - 2], h[_] = h[b - 1], h.length = b - 2;
+                return;
+              }
+            }
+            u.isConstraint = /* @__PURE__ */ function() {
+              var h = [0, 0];
+              function d(v, _) {
+                return v[0] - _[0] || v[1] - _[1];
+              }
+              return function(v, _) {
+                return h[0] = Math.min(v, _), h[1] = Math.max(v, _), s.eq(this.edges, h, d) >= 0;
+              };
+            }(), u.removeTriangle = function(h, d, v) {
+              var _ = this.stars;
+              c(_[h], d, v), c(_[d], v, h), c(_[v], h, d);
+            }, u.addTriangle = function(h, d, v) {
+              var _ = this.stars;
+              _[h].push(d, v), _[d].push(v, h), _[v].push(h, d);
+            }, u.opposite = function(h, d) {
+              for (var v = this.stars[d], _ = 1, b = v.length; _ < b; _ += 2) if (v[_] === h) return v[_ - 1];
+              return -1;
+            }, u.flip = function(h, d) {
+              var v = this.opposite(h, d), _ = this.opposite(d, h);
+              this.removeTriangle(h, d, v), this.removeTriangle(d, h, _), this.addTriangle(h, _, v), this.addTriangle(d, v, _);
+            }, u.edges = function() {
+              for (var h = this.stars, d = [], v = 0, _ = h.length; v < _; ++v) for (var b = h[v], p = 0, k = b.length; p < k; p += 2) d.push([b[p], b[p + 1]]);
+              return d;
+            }, u.cells = function() {
+              for (var h = this.stars, d = [], v = 0, _ = h.length; v < _; ++v) for (var b = h[v], p = 0, k = b.length; p < k; p += 2) {
+                var E = b[p], T = b[p + 1];
+                v < Math.min(E, T) && d.push([v, E, T]);
+              }
+              return d;
+            };
+            function f(h, d) {
+              for (var v = new Array(h), _ = 0; _ < h; ++_) v[_] = [];
+              return new l(v, d);
+            }
+          }, 5567: function(i) {
+            i.exports = a;
+            function a(o, s, l) {
+              var u = Math.sin(l), c = Math.cos(l), f = s[4], h = s[5], d = s[6], v = s[7], _ = s[8], b = s[9], p = s[10], k = s[11];
+              return s !== o && (o[0] = s[0], o[1] = s[1], o[2] = s[2], o[3] = s[3], o[12] = s[12], o[13] = s[13], o[14] = s[14], o[15] = s[15]), o[4] = f * c + _ * u, o[5] = h * c + b * u, o[6] = d * c + p * u, o[7] = v * c + k * u, o[8] = _ * c - f * u, o[9] = b * c - h * u, o[10] = p * c - d * u, o[11] = k * c - v * u, o;
+            }
+          }, 5572: function(i, a, o) {
+            var s = o(869);
+            i.exports = l;
+            function l(u, c) {
+              return s(u[0].mul(c[1]).sub(u[1].mul(c[0])), u[1].mul(c[1]));
+            }
+          }, 5609: function(i, a, o) {
+            i.exports = l;
+            var s = o(3134);
+            function l(u, c) {
+              for (var f = s(u, c.length), h = new Array(c.length), d = new Array(c.length), v = [], _ = 0; _ < c.length; ++_) {
+                var b = f[_].length;
+                d[_] = b, h[_] = true, b <= 1 && v.push(_);
+              }
+              for (; v.length > 0; ) {
+                var p = v.pop();
+                h[p] = false;
+                for (var k = f[p], _ = 0; _ < k.length; ++_) {
+                  var E = k[_];
+                  --d[E] === 0 && v.push(E);
+                }
+              }
+              for (var T = new Array(c.length), L = [], _ = 0; _ < c.length; ++_) if (h[_]) {
+                var p = L.length;
+                T[_] = p, L.push(c[_]);
+              } else T[_] = -1;
+              for (var x = [], _ = 0; _ < u.length; ++_) {
+                var C = u[_];
+                h[C[0]] && h[C[1]] && x.push([T[C[0]], T[C[1]]]);
+              }
+              return [x, L];
+            }
+          }, 5632: function(i) {
+            i.exports = a;
+            function a(o, s, l) {
+              return o[0] = s[0] + l[0], o[1] = s[1] + l[1], o[2] = s[2] + l[2], o;
+            }
+          }, 5665: function(i) {
+            i.exports = a;
+            function a(o, s) {
+              if (o === s) {
+                var l = s[1], u = s[2], c = s[3], f = s[6], h = s[7], d = s[11];
+                o[1] = s[4], o[2] = s[8], o[3] = s[12], o[4] = l, o[6] = s[9], o[7] = s[13], o[8] = u, o[9] = f, o[11] = s[14], o[12] = c, o[13] = h, o[14] = d;
+              } else o[0] = s[0], o[1] = s[4], o[2] = s[8], o[3] = s[12], o[4] = s[1], o[5] = s[5], o[6] = s[9], o[7] = s[13], o[8] = s[2], o[9] = s[6], o[10] = s[10], o[11] = s[14], o[12] = s[3], o[13] = s[7], o[14] = s[11], o[15] = s[15];
+              return o;
+            }
+          }, 5673: function(i) {
+            i.exports = a;
+            function a(o, s, l) {
+              var u = s[0], c = s[1], f = s[2], h = l[3] * u + l[7] * c + l[11] * f + l[15];
+              return h = h || 1, o[0] = (l[0] * u + l[4] * c + l[8] * f + l[12]) / h, o[1] = (l[1] * u + l[5] * c + l[9] * f + l[13]) / h, o[2] = (l[2] * u + l[6] * c + l[10] * f + l[14]) / h, o;
+            }
+          }, 5714: function(i, a, o) {
+            i.exports = M;
+            var s = o(2762), l = o(8116), u = o(7766), c = new Uint8Array(4), f = new Float32Array(c.buffer);
+            function h(g, P, A, z) {
+              return c[0] = z, c[1] = A, c[2] = P, c[3] = g, f[0];
+            }
+            var d = o(2478), v = o(9618), _ = o(7319), b = _.createShader, p = _.createPickShader, k = [1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1];
+            function E(g, P) {
+              for (var A = 0, z = 0; z < 3; ++z) {
+                var O = g[z] - P[z];
+                A += O * O;
+              }
+              return Math.sqrt(A);
+            }
+            function T(g) {
+              for (var P = [[-1e6, -1e6, -1e6], [1e6, 1e6, 1e6]], A = 0; A < 3; ++A) P[0][A] = Math.max(g[0][A], P[0][A]), P[1][A] = Math.min(g[1][A], P[1][A]);
+              return P;
+            }
+            function L(g, P, A, z) {
+              this.arcLength = g, this.position = P, this.index = A, this.dataCoordinate = z;
+            }
+            function x(g, P, A, z, O, U) {
+              this.gl = g, this.shader = P, this.pickShader = A, this.buffer = z, this.vao = O, this.clipBounds = [[-1 / 0, -1 / 0, -1 / 0], [1 / 0, 1 / 0, 1 / 0]], this.points = [], this.arcLength = [], this.vertexCount = 0, this.bounds = [[0, 0, 0], [0, 0, 0]], this.pickId = 0, this.lineWidth = 1, this.texture = U, this.dashScale = 1, this.opacity = 1, this.hasAlpha = false, this.dirty = true, this.pixelRatio = 1;
+            }
+            var C = x.prototype;
+            C.isTransparent = function() {
+              return this.hasAlpha;
+            }, C.isOpaque = function() {
+              return !this.hasAlpha;
+            }, C.pickSlots = 1, C.setPickBase = function(g) {
+              this.pickId = g;
+            }, C.drawTransparent = C.draw = function(g) {
+              if (this.vertexCount) {
+                var P = this.gl, A = this.shader, z = this.vao;
+                A.bind(), A.uniforms = { model: g.model || k, view: g.view || k, projection: g.projection || k, clipBounds: T(this.clipBounds), dashTexture: this.texture.bind(), dashScale: this.dashScale / this.arcLength[this.arcLength.length - 1], opacity: this.opacity, screenShape: [P.drawingBufferWidth, P.drawingBufferHeight], pixelRatio: this.pixelRatio }, z.bind(), z.draw(P.TRIANGLE_STRIP, this.vertexCount), z.unbind();
+              }
+            }, C.drawPick = function(g) {
+              if (this.vertexCount) {
+                var P = this.gl, A = this.pickShader, z = this.vao;
+                A.bind(), A.uniforms = { model: g.model || k, view: g.view || k, projection: g.projection || k, pickId: this.pickId, clipBounds: T(this.clipBounds), screenShape: [P.drawingBufferWidth, P.drawingBufferHeight], pixelRatio: this.pixelRatio }, z.bind(), z.draw(P.TRIANGLE_STRIP, this.vertexCount), z.unbind();
+              }
+            }, C.update = function(g) {
+              var P, A;
+              this.dirty = true;
+              var z = !!g.connectGaps;
+              "dashScale" in g && (this.dashScale = g.dashScale), this.hasAlpha = false, "opacity" in g && (this.opacity = +g.opacity, this.opacity < 1 && (this.hasAlpha = true));
+              var O = [], U = [], G = [], Z = 0, j = 0, N = [[1 / 0, 1 / 0, 1 / 0], [-1 / 0, -1 / 0, -1 / 0]], H = g.position || g.positions;
+              if (H) {
+                var re = g.color || g.colors || [0, 0, 0, 1], oe = g.lineWidth || 1, _e = false;
+                e: for (P = 1; P < H.length; ++P) {
+                  var Ce = H[P - 1], Le = H[P];
+                  for (U.push(Z), G.push(Ce.slice()), A = 0; A < 3; ++A) {
+                    if (isNaN(Ce[A]) || isNaN(Le[A]) || !isFinite(Ce[A]) || !isFinite(Le[A])) {
+                      if (!z && O.length > 0) {
+                        for (var ge = 0; ge < 24; ++ge) O.push(O[O.length - 12]);
+                        j += 2, _e = true;
+                      }
+                      continue e;
+                    }
+                    N[0][A] = Math.min(N[0][A], Ce[A], Le[A]), N[1][A] = Math.max(N[1][A], Ce[A], Le[A]);
+                  }
+                  var ie, Se;
+                  Array.isArray(re[0]) ? (ie = re.length > P - 1 ? re[P - 1] : re.length > 0 ? re[re.length - 1] : [0, 0, 0, 1], Se = re.length > P ? re[P] : re.length > 0 ? re[re.length - 1] : [0, 0, 0, 1]) : ie = Se = re, ie.length === 3 && (ie = [ie[0], ie[1], ie[2], 1]), Se.length === 3 && (Se = [Se[0], Se[1], Se[2], 1]), !this.hasAlpha && ie[3] < 1 && (this.hasAlpha = true);
+                  var Ee;
+                  Array.isArray(oe) ? Ee = oe.length > P - 1 ? oe[P - 1] : oe.length > 0 ? oe[oe.length - 1] : [0, 0, 0, 1] : Ee = oe;
+                  var Ae = Z;
+                  if (Z += E(Ce, Le), _e) {
+                    for (A = 0; A < 2; ++A) O.push(Ce[0], Ce[1], Ce[2], Le[0], Le[1], Le[2], Ae, Ee, ie[0], ie[1], ie[2], ie[3]);
+                    j += 2, _e = false;
+                  }
+                  O.push(Ce[0], Ce[1], Ce[2], Le[0], Le[1], Le[2], Ae, Ee, ie[0], ie[1], ie[2], ie[3], Ce[0], Ce[1], Ce[2], Le[0], Le[1], Le[2], Ae, -Ee, ie[0], ie[1], ie[2], ie[3], Le[0], Le[1], Le[2], Ce[0], Ce[1], Ce[2], Z, -Ee, Se[0], Se[1], Se[2], Se[3], Le[0], Le[1], Le[2], Ce[0], Ce[1], Ce[2], Z, Ee, Se[0], Se[1], Se[2], Se[3]), j += 4;
+                }
+              }
+              if (this.buffer.update(O), U.push(Z), G.push(H[H.length - 1].slice()), this.bounds = N, this.vertexCount = j, this.points = G, this.arcLength = U, "dashes" in g) {
+                var Be = g.dashes, Pe = Be.slice();
+                for (Pe.unshift(0), P = 1; P < Pe.length; ++P) Pe[P] = Pe[P - 1] + Pe[P];
+                var me = v(new Array(256 * 4), [256, 1, 4]);
+                for (P = 0; P < 256; ++P) {
+                  for (A = 0; A < 4; ++A) me.set(P, 0, A, 0);
+                  d.le(Pe, Pe[Pe.length - 1] * P / 255) & 1 ? me.set(P, 0, 0, 0) : me.set(P, 0, 0, 255);
+                }
+                this.texture.setPixels(me);
+              }
+            }, C.dispose = function() {
+              this.shader.dispose(), this.vao.dispose(), this.buffer.dispose();
+            }, C.pick = function(g) {
+              if (!g || g.id !== this.pickId) return null;
+              var P = h(g.value[0], g.value[1], g.value[2], 0), A = d.le(this.arcLength, P);
+              if (A < 0) return null;
+              if (A === this.arcLength.length - 1) return new L(this.arcLength[this.arcLength.length - 1], this.points[this.points.length - 1].slice(), A);
+              for (var z = this.points[A], O = this.points[Math.min(A + 1, this.points.length - 1)], U = (P - this.arcLength[A]) / (this.arcLength[A + 1] - this.arcLength[A]), G = 1 - U, Z = [0, 0, 0], j = 0; j < 3; ++j) Z[j] = G * z[j] + U * O[j];
+              var N = Math.min(U < 0.5 ? A : A + 1, this.points.length - 1);
+              return new L(P, Z, N, this.points[N]);
+            };
+            function M(g) {
+              var P = g.gl || g.scene && g.scene.gl, A = b(P);
+              A.attributes.position.location = 0, A.attributes.nextPosition.location = 1, A.attributes.arcLength.location = 2, A.attributes.lineWidth.location = 3, A.attributes.color.location = 4;
+              var z = p(P);
+              z.attributes.position.location = 0, z.attributes.nextPosition.location = 1, z.attributes.arcLength.location = 2, z.attributes.lineWidth.location = 3, z.attributes.color.location = 4;
+              for (var O = s(P), U = l(P, [{ buffer: O, size: 3, offset: 0, stride: 48 }, { buffer: O, size: 3, offset: 12, stride: 48 }, { buffer: O, size: 1, offset: 24, stride: 48 }, { buffer: O, size: 1, offset: 28, stride: 48 }, { buffer: O, size: 4, offset: 32, stride: 48 }]), G = v(new Array(256 * 4), [256, 1, 4]), Z = 0; Z < 1024; ++Z) G.data[Z] = 255;
+              var j = u(P, G);
+              j.wrap = P.REPEAT;
+              var N = new x(P, A, z, O, U, j);
+              return N.update(g), N;
+            }
+          }, 5716: function(i, a, o) {
+            var s = o(6859);
+            i.exports = l;
+            function l(u) {
+              return u.cmp(new s(0));
+            }
+          }, 5721: function(i) {
+            i.exports = a;
+            function a(o) {
+              for (var s = 0, l = 0, u = 1; u < o.length; ++u) o[u][0] < o[s][0] && (s = u), o[u][0] > o[l][0] && (l = u);
+              return s < l ? [[s], [l]] : s > l ? [[l], [s]] : [[s]];
+            }
+          }, 5771: function(i, a, o) {
+            var s = o(8507), l = o(3788), u = o(2419);
+            i.exports = c;
+            function c(f) {
+              f.sort(l);
+              for (var h = f.length, d = 0, v = 0; v < h; ++v) {
+                var _ = f[v], b = u(_);
+                if (b !== 0) {
+                  if (d > 0) {
+                    var p = f[d - 1];
+                    if (s(_, p) === 0 && u(p) !== b) {
+                      d -= 1;
+                      continue;
+                    }
+                  }
+                  f[d++] = _;
+                }
+              }
+              return f.length = d, f;
+            }
+          }, 5838: function(i, a, o) {
+            i.exports = l;
+            var s = o(7842);
+            function l(u) {
+              for (var c = new Array(u.length), f = 0; f < u.length; ++f) c[f] = s(u[f]);
+              return c;
+            }
+          }, 5847: function(i) {
+            i.exports = a;
+            function a(o, s, l) {
+              return o[0] = s[0] * l[0], o[1] = s[1] * l[1], o[2] = s[2] * l[2], o;
+            }
+          }, 5874: function(i, a, o) {
+            i.exports = A;
+            var s = o(620), l = o(7827), u = o(6852), c = o(7932), f = o(3508), h = 999, d = 9999, v = 0, _ = 1, b = 2, p = 3, k = 4, E = 5, T = 6, L = 7, x = 8, C = 9, M = 10, g = 11, P = ["block-comment", "line-comment", "preprocessor", "operator", "integer", "float", "ident", "builtin", "keyword", "whitespace", "eof", "integer"];
+            function A(z) {
+              var O = 0, U = 0, G = h, Z, j, N = [], H = [], _e = 1, Ce = 0, Le = 0, ge = false, ie = false, Se = "", Ee;
+              z = z || {};
+              var Ae = u, Be = s;
+              z.version === "300 es" && (Ae = f, Be = c);
+              for (var Pe = {}, me = {}, O = 0; O < Ae.length; O++) Pe[Ae[O]] = true;
+              for (var O = 0; O < Be.length; O++) me[Be[O]] = true;
+              return function($e) {
+                return H = [], $e !== null ? ce($e) : je();
+              };
+              function De($e) {
+                $e.length && H.push({ type: P[G], data: $e, position: Le, line: _e, column: Ce });
+              }
+              function ce($e) {
+                O = 0, $e.toString && ($e = $e.toString()), Se += $e.replace(/\r\n/g, `
+`), Ee = Se.length;
+                for (var St; Z = Se[O], O < Ee; ) {
+                  switch (St = O, G) {
+                    case v:
+                      O = ut();
+                      break;
+                    case _:
+                      O = ot();
+                      break;
+                    case b:
+                      O = Vt();
+                      break;
+                    case p:
+                      O = Wt();
+                      break;
+                    case k:
+                      O = sr();
+                      break;
+                    case g:
+                      O = $t();
+                      break;
+                    case E:
+                      O = Tr();
+                      break;
+                    case d:
+                      O = fr();
+                      break;
+                    case C:
+                      O = pt();
+                      break;
+                    case h:
+                      O = lt();
+                      break;
+                  }
+                  if (St !== O) switch (Se[St]) {
+                    case `
+`:
+                      Ce = 0, ++_e;
+                      break;
+                    default:
+                      ++Ce;
+                      break;
+                  }
+                }
+                return U += O, Se = Se.slice(O), H;
+              }
+              function je($e) {
+                return N.length && De(N.join("")), G = M, De("(eof)"), H;
+              }
+              function lt() {
+                return N = N.length ? [] : N, j === "/" && Z === "*" ? (Le = U + O - 1, G = v, j = Z, O + 1) : j === "/" && Z === "/" ? (Le = U + O - 1, G = _, j = Z, O + 1) : Z === "#" ? (G = b, Le = U + O, O) : /\s/.test(Z) ? (G = C, Le = U + O, O) : (ge = /\d/.test(Z), ie = /[^\w_]/.test(Z), Le = U + O, G = ge ? k : ie ? p : d, O);
+              }
+              function pt() {
+                return /[^\s]/g.test(Z) ? (De(N.join("")), G = h, O) : (N.push(Z), j = Z, O + 1);
+              }
+              function Vt() {
+                return (Z === "\r" || Z === `
+`) && j !== "\\" ? (De(N.join("")), G = h, O) : (N.push(Z), j = Z, O + 1);
+              }
+              function ot() {
+                return Vt();
+              }
+              function ut() {
+                return Z === "/" && j === "*" ? (N.push(Z), De(N.join("")), G = h, O + 1) : (N.push(Z), j = Z, O + 1);
+              }
+              function Wt() {
+                if (j === "." && /\d/.test(Z)) return G = E, O;
+                if (j === "/" && Z === "*") return G = v, O;
+                if (j === "/" && Z === "/") return G = _, O;
+                if (Z === "." && N.length) {
+                  for (; Nt(N); ) ;
+                  return G = E, O;
+                }
+                if (Z === ";" || Z === ")" || Z === "(") {
+                  if (N.length) for (; Nt(N); ) ;
+                  return De(Z), G = h, O + 1;
+                }
+                var $e = N.length === 2 && Z !== "=";
+                if (/[\w_\d\s]/.test(Z) || $e) {
+                  for (; Nt(N); ) ;
+                  return G = h, O;
+                }
+                return N.push(Z), j = Z, O + 1;
+              }
+              function Nt($e) {
+                var St = 0, Qt, Gt;
+                do {
+                  if (Qt = l.indexOf($e.slice(0, $e.length + St).join("")), Gt = l[Qt], Qt === -1) {
+                    if (St-- + $e.length > 0) continue;
+                    Gt = $e.slice(0, 1).join("");
+                  }
+                  return De(Gt), Le += Gt.length, N = N.slice(Gt.length), N.length;
+                } while (true);
+              }
+              function $t() {
+                return /[^a-fA-F0-9]/.test(Z) ? (De(N.join("")), G = h, O) : (N.push(Z), j = Z, O + 1);
+              }
+              function sr() {
+                return Z === "." || /[eE]/.test(Z) ? (N.push(Z), G = E, j = Z, O + 1) : Z === "x" && N.length === 1 && N[0] === "0" ? (G = g, N.push(Z), j = Z, O + 1) : /[^\d]/.test(Z) ? (De(N.join("")), G = h, O) : (N.push(Z), j = Z, O + 1);
+              }
+              function Tr() {
+                return Z === "f" && (N.push(Z), j = Z, O += 1), /[eE]/.test(Z) || (Z === "-" || Z === "+") && /[eE]/.test(j) ? (N.push(Z), j = Z, O + 1) : /[^\d]/.test(Z) ? (De(N.join("")), G = h, O) : (N.push(Z), j = Z, O + 1);
+              }
+              function fr() {
+                if (/[^\d\w_]/.test(Z)) {
+                  var $e = N.join("");
+                  return me[$e] ? G = x : Pe[$e] ? G = L : G = T, De(N.join("")), G = h, O;
+                }
+                return N.push(Z), j = Z, O + 1;
+              }
+            }
+          }, 5878: function(i, a, o) {
+            i.exports = c;
+            var s = o(3250), l = o(2014);
+            function u(f, h, d) {
+              var v = Math.abs(s(f, h, d)), _ = Math.sqrt(Math.pow(h[0] - d[0], 2) + Math.pow(h[1] - d[1], 2));
+              return v / _;
+            }
+            function c(f, h, d) {
+              for (var v = h.length, _ = f.length, b = new Array(v), p = new Array(v), k = new Array(v), E = new Array(v), T = 0; T < v; ++T) b[T] = p[T] = -1, k[T] = 1 / 0, E[T] = false;
+              for (var T = 0; T < _; ++T) {
+                var L = f[T];
+                if (L.length !== 2) throw new Error("Input must be a graph");
+                var x = L[1], C = L[0];
+                p[C] !== -1 ? p[C] = -2 : p[C] = x, b[x] !== -1 ? b[x] = -2 : b[x] = C;
+              }
+              function M(ie) {
+                if (E[ie]) return 1 / 0;
+                var Se = b[ie], Ee = p[ie];
+                return Se < 0 || Ee < 0 ? 1 / 0 : u(h[ie], h[Se], h[Ee]);
+              }
+              function g(ie, Se) {
+                var Ee = j[ie], Ae = j[Se];
+                j[ie] = Ae, j[Se] = Ee, N[Ee] = Se, N[Ae] = ie;
+              }
+              function P(ie) {
+                return k[j[ie]];
+              }
+              function A(ie) {
+                return ie & 1 ? ie - 1 >> 1 : (ie >> 1) - 1;
+              }
+              function z(ie) {
+                for (var Se = P(ie); ; ) {
+                  var Ee = Se, Ae = 2 * ie + 1, Be = 2 * (ie + 1), Pe = ie;
+                  if (Ae < re) {
+                    var me = P(Ae);
+                    me < Ee && (Pe = Ae, Ee = me);
+                  }
+                  if (Be < re) {
+                    var De = P(Be);
+                    De < Ee && (Pe = Be);
+                  }
+                  if (Pe === ie) return ie;
+                  g(ie, Pe), ie = Pe;
+                }
+              }
+              function O(ie) {
+                for (var Se = P(ie); ie > 0; ) {
+                  var Ee = A(ie);
+                  if (Ee >= 0) {
+                    var Ae = P(Ee);
+                    if (Se < Ae) {
+                      g(ie, Ee), ie = Ee;
+                      continue;
+                    }
+                  }
+                  return ie;
+                }
+              }
+              function U() {
+                if (re > 0) {
+                  var ie = j[0];
+                  return g(0, re - 1), re -= 1, z(0), ie;
+                }
+                return -1;
+              }
+              function G(ie, Se) {
+                var Ee = j[ie];
+                return k[Ee] === Se ? ie : (k[Ee] = -1 / 0, O(ie), U(), k[Ee] = Se, re += 1, O(re - 1));
+              }
+              function Z(ie) {
+                if (!E[ie]) {
+                  E[ie] = true;
+                  var Se = b[ie], Ee = p[ie];
+                  b[Ee] >= 0 && (b[Ee] = Se), p[Se] >= 0 && (p[Se] = Ee), N[Se] >= 0 && G(N[Se], M(Se)), N[Ee] >= 0 && G(N[Ee], M(Ee));
+                }
+              }
+              for (var j = [], N = new Array(v), T = 0; T < v; ++T) {
+                var H = k[T] = M(T);
+                H < 1 / 0 ? (N[T] = j.length, j.push(T)) : N[T] = -1;
+              }
+              for (var re = j.length, T = re >> 1; T >= 0; --T) z(T);
+              for (; ; ) {
+                var oe = U();
+                if (oe < 0 || k[oe] > d) break;
+                Z(oe);
+              }
+              for (var _e = [], T = 0; T < v; ++T) E[T] || (N[T] = _e.length, _e.push(h[T].slice()));
+              _e.length;
+              function Le(ie, Se) {
+                if (ie[Se] < 0) return Se;
+                var Ee = Se, Ae = Se;
+                do {
+                  var Be = ie[Ae];
+                  if (!E[Ae] || Be < 0 || Be === Ae || (Ae = Be, Be = ie[Ae], !E[Ae] || Be < 0 || Be === Ae)) break;
+                  Ae = Be, Ee = ie[Ee];
+                } while (Ee !== Ae);
+                for (var Pe = Se; Pe !== Ae; Pe = ie[Pe]) ie[Pe] = Ae;
+                return Ae;
+              }
+              var ge = [];
+              return f.forEach(function(ie) {
+                var Se = Le(b, ie[0]), Ee = Le(p, ie[1]);
+                if (Se >= 0 && Ee >= 0 && Se !== Ee) {
+                  var Ae = N[Se], Be = N[Ee];
+                  Ae !== Be && ge.push([Ae, Be]);
+                }
+              }), l.unique(l.normalize(ge)), { positions: _e, edges: ge };
+            }
+          }, 5911: function(i) {
+            i.exports = a;
+            function a(o, s, l) {
+              var u = s[0], c = s[1], f = s[2], h = l[0], d = l[1], v = l[2];
+              return o[0] = c * v - f * d, o[1] = f * h - u * v, o[2] = u * d - c * h, o;
+            }
+          }, 5964: function(i) {
+            i.exports = function(a) {
+              return !a && a !== 0 ? "" : a.toString();
+            };
+          }, 5995: function(i, a, o) {
+            i.exports = u;
+            var s = o(7642), l = o(6037);
+            function u(c, f) {
+              return s(f).filter(function(h) {
+                for (var d = new Array(h.length), v = 0; v < h.length; ++v) d[v] = f[h[v]];
+                return l(d) * c < 1;
+              });
+            }
+          }, 6037: function(i, a, o) {
+            i.exports = l;
+            var s = o(3628);
+            function l(u) {
+              for (var c = s(u), f = 0, h = 0; h < u.length; ++h) for (var d = u[h], v = 0; v < c.length; ++v) f += Math.pow(d[v] - c[v], 2);
+              return Math.sqrt(f / u.length);
+            }
+          }, 6079: function(i) {
+            i.exports = a;
+            function a(o, s, l, u) {
+              var c = u[0], f = u[1], h = u[2], d = Math.sqrt(c * c + f * f + h * h), v, _, b, p, k, E, T, L, x, C, M, g, P, A, z, O, U, G, Z, j, N, H, re, oe;
+              return Math.abs(d) < 1e-6 ? null : (d = 1 / d, c *= d, f *= d, h *= d, v = Math.sin(l), _ = Math.cos(l), b = 1 - _, p = s[0], k = s[1], E = s[2], T = s[3], L = s[4], x = s[5], C = s[6], M = s[7], g = s[8], P = s[9], A = s[10], z = s[11], O = c * c * b + _, U = f * c * b + h * v, G = h * c * b - f * v, Z = c * f * b - h * v, j = f * f * b + _, N = h * f * b + c * v, H = c * h * b + f * v, re = f * h * b - c * v, oe = h * h * b + _, o[0] = p * O + L * U + g * G, o[1] = k * O + x * U + P * G, o[2] = E * O + C * U + A * G, o[3] = T * O + M * U + z * G, o[4] = p * Z + L * j + g * N, o[5] = k * Z + x * j + P * N, o[6] = E * Z + C * j + A * N, o[7] = T * Z + M * j + z * N, o[8] = p * H + L * re + g * oe, o[9] = k * H + x * re + P * oe, o[10] = E * H + C * re + A * oe, o[11] = T * H + M * re + z * oe, s !== o && (o[12] = s[12], o[13] = s[13], o[14] = s[14], o[15] = s[15]), o);
+            }
+          }, 6141: function(i, a, o) {
+            i.exports = o(2953);
+          }, 6199: function(i, a, o) {
+            var s = o(1338), l = { zero: function(L, x, C, M) {
+              var g = L[0], P = C[0];
+              M |= 0;
+              var A = 0, z = P;
+              for (A = 0; A < g; ++A) x[M] = 0, M += z;
+            }, fdTemplate1: function(L, x, C, M, g, P, A) {
+              var z = L[0], O = C[0], U = P[0], G = -1 * O, Z = O;
+              M |= 0, A |= 0;
+              var j = 0, N = O, H = U;
+              for (j = 0; j < z; ++j) g[A] = 0.5 * (x[M + G] - x[M + Z]), M += N, A += H;
+            }, fdTemplate2: function(L, x, C, M, g, P, A, z, O, U) {
+              var G = L[0], Z = L[1], j = C[0], N = C[1], H = P[0], re = P[1], oe = O[0], _e = O[1], Ce = -1 * j, Le = j, ge = -1 * N, ie = N;
+              M |= 0, A |= 0, U |= 0;
+              var Se = 0, Ee = 0, Ae = N, Be = j - Z * N, Pe = re, me = H - Z * re, De = _e, ce = oe - Z * _e;
+              for (Ee = 0; Ee < G; ++Ee) {
+                for (Se = 0; Se < Z; ++Se) g[A] = 0.5 * (x[M + Ce] - x[M + Le]), z[U] = 0.5 * (x[M + ge] - x[M + ie]), M += Ae, A += Pe, U += De;
+                M += Be, A += me, U += ce;
+              }
+            } }, u = { cdiff: function(L) {
+              var x = {};
+              return function(M, g, P) {
+                var A = M.dtype, z = M.order, O = g.dtype, U = g.order, G = P.dtype, Z = P.order, j = [A, z.join(), O, U.join(), G, Z.join()].join(), N = x[j];
+                return N || (x[j] = N = L([A, z, O, U, G, Z])), N(M.shape.slice(0), M.data, M.stride, M.offset | 0, g.data, g.stride, g.offset | 0, P.data, P.stride, P.offset | 0);
+              };
+            }, zero: function(L) {
+              var x = {};
+              return function(M) {
+                var g = M.dtype, P = M.order, A = [g, P.join()].join(), z = x[A];
+                return z || (x[A] = z = L([g, P])), z(M.shape.slice(0), M.data, M.stride, M.offset | 0);
+              };
+            }, fdTemplate1: function(L) {
+              var x = {};
+              return function(M, g) {
+                var P = M.dtype, A = M.order, z = g.dtype, O = g.order, U = [P, A.join(), z, O.join()].join(), G = x[U];
+                return G || (x[U] = G = L([P, A, z, O])), G(M.shape.slice(0), M.data, M.stride, M.offset | 0, g.data, g.stride, g.offset | 0);
+              };
+            }, fdTemplate2: function(L) {
+              var x = {};
+              return function(M, g, P) {
+                var A = M.dtype, z = M.order, O = g.dtype, U = g.order, G = P.dtype, Z = P.order, j = [A, z.join(), O, U.join(), G, Z.join()].join(), N = x[j];
+                return N || (x[j] = N = L([A, z, O, U, G, Z])), N(M.shape.slice(0), M.data, M.stride, M.offset | 0, g.data, g.stride, g.offset | 0, P.data, P.stride, P.offset | 0);
+              };
+            } };
+            function c(L) {
+              var x = u[L.funcName];
+              return x(f.bind(void 0, L));
+            }
+            function f(L) {
+              return l[L.funcName];
+            }
+            function h(L) {
+              return c({ funcName: L.funcName });
+            }
+            var d = {}, v = {}, b = h({ funcName: "cdiff" }), p = h({ funcName: "zero" });
+            function k(L) {
+              return L in d ? d[L] : d[L] = h({ funcName: "fdTemplate" + L });
+            }
+            function E(L, x, C, M) {
+              return function(g, P) {
+                var A = P.shape.slice();
+                return A[0] > 2 && A[1] > 2 && M(P.pick(-1, -1).lo(1, 1).hi(A[0] - 2, A[1] - 2), g.pick(-1, -1, 0).lo(1, 1).hi(A[0] - 2, A[1] - 2), g.pick(-1, -1, 1).lo(1, 1).hi(A[0] - 2, A[1] - 2)), A[1] > 2 && (C(P.pick(0, -1).lo(1).hi(A[1] - 2), g.pick(0, -1, 1).lo(1).hi(A[1] - 2)), x(g.pick(0, -1, 0).lo(1).hi(A[1] - 2))), A[1] > 2 && (C(P.pick(A[0] - 1, -1).lo(1).hi(A[1] - 2), g.pick(A[0] - 1, -1, 1).lo(1).hi(A[1] - 2)), x(g.pick(A[0] - 1, -1, 0).lo(1).hi(A[1] - 2))), A[0] > 2 && (C(P.pick(-1, 0).lo(1).hi(A[0] - 2), g.pick(-1, 0, 0).lo(1).hi(A[0] - 2)), x(g.pick(-1, 0, 1).lo(1).hi(A[0] - 2))), A[0] > 2 && (C(P.pick(-1, A[1] - 1).lo(1).hi(A[0] - 2), g.pick(-1, A[1] - 1, 0).lo(1).hi(A[0] - 2)), x(g.pick(-1, A[1] - 1, 1).lo(1).hi(A[0] - 2))), g.set(0, 0, 0, 0), g.set(0, 0, 1, 0), g.set(A[0] - 1, 0, 0, 0), g.set(A[0] - 1, 0, 1, 0), g.set(0, A[1] - 1, 0, 0), g.set(0, A[1] - 1, 1, 0), g.set(A[0] - 1, A[1] - 1, 0, 0), g.set(A[0] - 1, A[1] - 1, 1, 0), g;
+              };
+            }
+            function T(L) {
+              var x = L.join(), A = v[x];
+              if (A) return A;
+              for (var C = L.length, M = [b, p], g = 1; g <= C; ++g) M.push(k(g));
+              var P = E, A = P.apply(void 0, M);
+              return v[x] = A, A;
+            }
+            i.exports = function(x, C, M) {
+              if (Array.isArray(M) || (typeof M == "string" ? M = s(C.dimension, M) : M = s(C.dimension, "clamp")), C.size === 0) return x;
+              if (C.dimension === 0) return x.set(0), x;
+              var g = T(M);
+              return g(x, C);
+            };
+          }, 6204: function(i) {
+            i.exports = a;
+            function a(o) {
+              var s, l, u, c = o.length, f = 0;
+              for (s = 0; s < c; ++s) f += o[s].length;
+              var h = new Array(f), d = 0;
+              for (s = 0; s < c; ++s) {
+                var v = o[s], _ = v.length;
+                for (l = 0; l < _; ++l) {
+                  var b = h[d++] = new Array(_ - 1), p = 0;
+                  for (u = 0; u < _; ++u) u !== l && (b[p++] = v[u]);
+                  if (l & 1) {
+                    var k = b[1];
+                    b[1] = b[0], b[0] = k;
+                  }
+                }
+              }
+              return h;
+            }
+          }, 6296: function(i, a, o) {
+            i.exports = h;
+            var s = o(7261), l = o(9977), u = o(1811);
+            function c(d, v) {
+              this._controllerNames = Object.keys(d), this._controllerList = this._controllerNames.map(function(_) {
+                return d[_];
+              }), this._mode = v, this._active = d[v], this._active || (this._mode = "turntable", this._active = d.turntable), this.modes = this._controllerNames, this.computedMatrix = this._active.computedMatrix, this.computedEye = this._active.computedEye, this.computedUp = this._active.computedUp, this.computedCenter = this._active.computedCenter, this.computedRadius = this._active.computedRadius;
+            }
+            var f = c.prototype;
+            f.flush = function(d) {
+              for (var v = this._controllerList, _ = 0; _ < v.length; ++_) v[_].flush(d);
+            }, f.idle = function(d) {
+              for (var v = this._controllerList, _ = 0; _ < v.length; ++_) v[_].idle(d);
+            }, f.lookAt = function(d, v, _, b) {
+              for (var p = this._controllerList, k = 0; k < p.length; ++k) p[k].lookAt(d, v, _, b);
+            }, f.rotate = function(d, v, _, b) {
+              for (var p = this._controllerList, k = 0; k < p.length; ++k) p[k].rotate(d, v, _, b);
+            }, f.pan = function(d, v, _, b) {
+              for (var p = this._controllerList, k = 0; k < p.length; ++k) p[k].pan(d, v, _, b);
+            }, f.translate = function(d, v, _, b) {
+              for (var p = this._controllerList, k = 0; k < p.length; ++k) p[k].translate(d, v, _, b);
+            }, f.setMatrix = function(d, v) {
+              for (var _ = this._controllerList, b = 0; b < _.length; ++b) _[b].setMatrix(d, v);
+            }, f.setDistanceLimits = function(d, v) {
+              for (var _ = this._controllerList, b = 0; b < _.length; ++b) _[b].setDistanceLimits(d, v);
+            }, f.setDistance = function(d, v) {
+              for (var _ = this._controllerList, b = 0; b < _.length; ++b) _[b].setDistance(d, v);
+            }, f.recalcMatrix = function(d) {
+              this._active.recalcMatrix(d);
+            }, f.getDistance = function(d) {
+              return this._active.getDistance(d);
+            }, f.getDistanceLimits = function(d) {
+              return this._active.getDistanceLimits(d);
+            }, f.lastT = function() {
+              return this._active.lastT();
+            }, f.setMode = function(d) {
+              if (d !== this._mode) {
+                var v = this._controllerNames.indexOf(d);
+                if (!(v < 0)) {
+                  var _ = this._active, b = this._controllerList[v], p = Math.max(_.lastT(), b.lastT());
+                  _.recalcMatrix(p), b.setMatrix(p, _.computedMatrix), this._active = b, this._mode = d, this.computedMatrix = this._active.computedMatrix, this.computedEye = this._active.computedEye, this.computedUp = this._active.computedUp, this.computedCenter = this._active.computedCenter, this.computedRadius = this._active.computedRadius;
+                }
+              }
+            }, f.getMode = function() {
+              return this._mode;
+            };
+            function h(d) {
+              d = d || {};
+              var v = d.eye || [0, 0, 1], _ = d.center || [0, 0, 0], b = d.up || [0, 1, 0], p = d.distanceLimits || [0, 1 / 0], k = d.mode || "turntable", E = s(), T = l(), L = u();
+              return E.setDistanceLimits(p[0], p[1]), E.lookAt(0, v, _, b), T.setDistanceLimits(p[0], p[1]), T.lookAt(0, v, _, b), L.setDistanceLimits(p[0], p[1]), L.lookAt(0, v, _, b), new c({ turntable: E, orbit: T, matrix: L }, k);
+            }
+          }, 6330: function(i, a, o) {
+            var s = o(1533);
+            i.exports = l;
+            function l(u) {
+              return Array.isArray(u) && u.length === 2 && s(u[0]) && s(u[1]);
+            }
+          }, 6405: function(i, a, o) {
+            var s = o(2931);
+            i.exports = function(u, c) {
+              var f = u.positions, h = u.vectors, d = { positions: [], vertexIntensity: [], vertexIntensityBounds: u.vertexIntensityBounds, vectors: [], cells: [], coneOffset: u.coneOffset, colormap: u.colormap };
+              if (u.positions.length === 0) return c && (c[0] = [0, 0, 0], c[1] = [0, 0, 0]), d;
+              for (var v = 0, _ = 1 / 0, b = -1 / 0, p = 1 / 0, k = -1 / 0, E = 1 / 0, T = -1 / 0, L = null, x = null, C = [], M = 1 / 0, g = false, P = u.coneSizemode === "raw", A = 0; A < f.length; A++) {
+                var z = f[A];
+                _ = Math.min(z[0], _), b = Math.max(z[0], b), p = Math.min(z[1], p), k = Math.max(z[1], k), E = Math.min(z[2], E), T = Math.max(z[2], T);
+                var O = h[A];
+                if (s.length(O) > v && (v = s.length(O)), A && !P) {
+                  var U = 2 * s.distance(L, z) / (s.length(x) + s.length(O));
+                  U ? (M = Math.min(M, U), g = false) : g = true;
+                }
+                g || (L = z, x = O), C.push(O);
+              }
+              var G = [_, p, E], Z = [b, k, T];
+              c && (c[0] = G, c[1] = Z), v === 0 && (v = 1);
+              var j = 1 / v;
+              isFinite(M) || (M = 1), d.vectorScale = M;
+              var N = u.coneSize || (P ? 1 : 0.5);
+              u.absoluteConeSize && (N = u.absoluteConeSize * j), d.coneScale = N;
+              for (var A = 0, H = 0; A < f.length; A++) for (var z = f[A], re = z[0], oe = z[1], _e = z[2], Ce = C[A], Le = s.length(Ce) * j, ge = 0, ie = 8; ge < ie; ge++) {
+                d.positions.push([re, oe, _e, H++]), d.positions.push([re, oe, _e, H++]), d.positions.push([re, oe, _e, H++]), d.positions.push([re, oe, _e, H++]), d.positions.push([re, oe, _e, H++]), d.positions.push([re, oe, _e, H++]), d.vectors.push(Ce), d.vectors.push(Ce), d.vectors.push(Ce), d.vectors.push(Ce), d.vectors.push(Ce), d.vectors.push(Ce), d.vertexIntensity.push(Le, Le, Le), d.vertexIntensity.push(Le, Le, Le);
+                var Se = d.positions.length;
+                d.cells.push([Se - 6, Se - 5, Se - 4], [Se - 3, Se - 2, Se - 1]);
+              }
+              return d;
+            };
+            var l = o(614);
+            i.exports.createMesh = o(9060), i.exports.createConeMesh = function(u, c) {
+              return i.exports.createMesh(u, c, { shaders: l, traceType: "cone" });
+            };
+          }, 6429: function(i, a, o) {
+            i.exports = x;
+            var s = o(8828), l = o(6760), u = o(5202), c = o(3250), f = new Array(16), h = new Array(8), d = new Array(8), v = new Array(3), _ = [0, 0, 0];
+            (function() {
+              for (var C = 0; C < 8; ++C) h[C] = [1, 1, 1, 1], d[C] = [1, 1, 1];
+            })();
+            function b(C, M, g) {
+              for (var P = 0; P < 4; ++P) {
+                C[P] = g[12 + P];
+                for (var A = 0; A < 3; ++A) C[P] += M[A] * g[4 * A + P];
+              }
+            }
+            var p = [[0, 0, 1, 0, 0], [0, 0, -1, 1, 0], [0, -1, 0, 1, 0], [0, 1, 0, 1, 0], [-1, 0, 0, 1, 0], [1, 0, 0, 1, 0]];
+            function k(C) {
+              for (var M = 0; M < p.length; ++M) if (C = u.positive(C, p[M]), C.length < 3) return 0;
+              for (var g = C[0], P = g[0] / g[3], A = g[1] / g[3], z = 0, M = 1; M + 1 < C.length; ++M) {
+                var O = C[M], U = C[M + 1], G = O[0] / O[3], Z = O[1] / O[3], j = U[0] / U[3], N = U[1] / U[3], H = G - P, re = Z - A, oe = j - P, _e = N - A;
+                z += Math.abs(H * _e - re * oe);
+              }
+              return z;
+            }
+            var E = [1, 1, 1], T = [0, 0, 0], L = { cubeEdges: E, axis: T };
+            function x(C, M, g, P, A) {
+              l(f, M, C), l(f, g, f);
+              for (var z = 0, O = 0; O < 2; ++O) {
+                v[2] = P[O][2];
+                for (var U = 0; U < 2; ++U) {
+                  v[1] = P[U][1];
+                  for (var G = 0; G < 2; ++G) v[0] = P[G][0], b(h[z], v, f), z += 1;
+                }
+              }
+              for (var Z = -1, O = 0; O < 8; ++O) {
+                for (var j = h[O][3], N = 0; N < 3; ++N) d[O][N] = h[O][N] / j;
+                A && (d[O][2] *= -1), j < 0 && (Z < 0 || d[O][2] < d[Z][2]) && (Z = O);
+              }
+              if (Z < 0) {
+                Z = 0;
+                for (var H = 0; H < 3; ++H) {
+                  for (var re = (H + 2) % 3, oe = (H + 1) % 3, _e = -1, Ce = -1, Le = 0; Le < 2; ++Le) {
+                    var ge = Le << H, ie = ge + (Le << re) + (1 - Le << oe), Se = ge + (1 - Le << re) + (Le << oe);
+                    c(d[ge], d[ie], d[Se], _) < 0 || (Le ? _e = 1 : Ce = 1);
+                  }
+                  if (_e < 0 || Ce < 0) {
+                    Ce > _e && (Z |= 1 << H);
+                    continue;
+                  }
+                  for (var Le = 0; Le < 2; ++Le) {
+                    var ge = Le << H, ie = ge + (Le << re) + (1 - Le << oe), Se = ge + (1 - Le << re) + (Le << oe), Ee = k([h[ge], h[ie], h[Se], h[ge + (1 << re) + (1 << oe)]]);
+                    Le ? _e = Ee : Ce = Ee;
+                  }
+                  if (Ce > _e) {
+                    Z |= 1 << H;
+                    continue;
+                  }
+                }
+              }
+              for (var Ae = 7 ^ Z, Be = -1, O = 0; O < 8; ++O) O === Z || O === Ae || (Be < 0 || d[Be][1] > d[O][1]) && (Be = O);
+              for (var Pe = -1, O = 0; O < 3; ++O) {
+                var me = Be ^ 1 << O;
+                if (!(me === Z || me === Ae)) {
+                  Pe < 0 && (Pe = me);
+                  var oe = d[me];
+                  oe[0] < d[Pe][0] && (Pe = me);
+                }
+              }
+              for (var De = -1, O = 0; O < 3; ++O) {
+                var me = Be ^ 1 << O;
+                if (!(me === Z || me === Ae || me === Pe)) {
+                  De < 0 && (De = me);
+                  var oe = d[me];
+                  oe[0] > d[De][0] && (De = me);
+                }
+              }
+              var ce = E;
+              ce[0] = ce[1] = ce[2] = 0, ce[s.log2(Pe ^ Be)] = Be & Pe, ce[s.log2(Be ^ De)] = Be & De;
+              var je = De ^ 7;
+              je === Z || je === Ae ? (je = Pe ^ 7, ce[s.log2(De ^ je)] = je & De) : ce[s.log2(Pe ^ je)] = je & Pe;
+              for (var lt = T, pt = Z, H = 0; H < 3; ++H) pt & 1 << H ? lt[H] = -1 : lt[H] = 1;
+              return L;
+            }
+          }, 6444: function(i, a) {
+            a.create = s, a.equal = l;
+            function o(u, c) {
+              var f = u + "", h = f.indexOf("."), d = 0;
+              h >= 0 && (d = f.length - h - 1);
+              var v = Math.pow(10, d), _ = Math.round(u * c * v), b = _ + "";
+              if (b.indexOf("e") >= 0) return b;
+              var p = _ / v, k = _ % v;
+              _ < 0 ? (p = -Math.ceil(p) | 0, k = -k | 0) : (p = Math.floor(p) | 0, k = k | 0);
+              var E = "" + p;
+              if (_ < 0 && (E = "-" + E), d) {
+                for (var T = "" + k; T.length < d; ) T = "0" + T;
+                return E + "." + T;
+              } else return E;
+            }
+            function s(u, c) {
+              for (var f = [], h = 0; h < 3; ++h) {
+                for (var d = [], v = 0.5 * (u[0][h] + u[1][h]), _ = 0; _ * c[h] <= u[1][h]; ++_) d.push({ x: _ * c[h], text: o(c[h], _) });
+                for (var _ = -1; _ * c[h] >= u[0][h]; --_) d.push({ x: _ * c[h], text: o(c[h], _) });
+                f.push(d);
+              }
+              return f;
+            }
+            function l(u, c) {
+              for (var f = 0; f < 3; ++f) {
+                if (u[f].length !== c[f].length) return false;
+                for (var h = 0; h < u[f].length; ++h) {
+                  var d = u[f][h], v = c[f][h];
+                  if (d.x !== v.x || d.text !== v.text || d.font !== v.font || d.fontColor !== v.fontColor || d.fontSize !== v.fontSize || d.dx !== v.dx || d.dy !== v.dy) return false;
+                }
+              }
+              return true;
+            }
+          }, 6468: function(i) {
+            i.exports = function(o) {
+              return atob(o);
+            };
+          }, 6504: function(i, a, o) {
+            var s = o(869);
+            i.exports = l;
+            function l(u, c) {
+              return s(u[0].mul(c[0]), u[1].mul(c[1]));
+            }
+          }, 6582: function(i, a, o) {
+            var s = o(7894);
+            i.exports = l;
+            function l(u, c, f, h) {
+              var d, v, _, b, p, k, E, T, L, x, C = c[0], M = c[1], g = c[2], P = h[0], A = h[1], z = h[2], O = f[0], U = f[1], G = f[2];
+              return Math.abs(C - O) < 1e-6 && Math.abs(M - U) < 1e-6 && Math.abs(g - G) < 1e-6 ? s(u) : (E = C - O, T = M - U, L = g - G, x = 1 / Math.sqrt(E * E + T * T + L * L), E *= x, T *= x, L *= x, d = A * L - z * T, v = z * E - P * L, _ = P * T - A * E, x = Math.sqrt(d * d + v * v + _ * _), x ? (x = 1 / x, d *= x, v *= x, _ *= x) : (d = 0, v = 0, _ = 0), b = T * _ - L * v, p = L * d - E * _, k = E * v - T * d, x = Math.sqrt(b * b + p * p + k * k), x ? (x = 1 / x, b *= x, p *= x, k *= x) : (b = 0, p = 0, k = 0), u[0] = d, u[1] = b, u[2] = E, u[3] = 0, u[4] = v, u[5] = p, u[6] = T, u[7] = 0, u[8] = _, u[9] = k, u[10] = L, u[11] = 0, u[12] = -(d * C + v * M + _ * g), u[13] = -(b * C + p * M + k * g), u[14] = -(E * C + T * M + L * g), u[15] = 1, u);
+            }
+          }, 6621: function(i) {
+            i.exports = a;
+            function a(o, s, l) {
+              return o[0] = s[0] * l, o[1] = s[1] * l, o[2] = s[2] * l, o;
+            }
+          }, 6658: function(i) {
+            i.exports = a;
+            function a(o, s, l, u) {
+              var c = s[0], f = s[1], h = s[2];
+              return o[0] = c + u * (l[0] - c), o[1] = f + u * (l[1] - f), o[2] = h + u * (l[2] - h), o;
+            }
+          }, 6690: function(i) {
+            i.exports = a;
+            function a(o, s, l) {
+              return o[0] = s[0] / l[0], o[1] = s[1] / l[1], o[2] = s[2] / l[2], o;
+            }
+          }, 6729: function(i, a, o) {
+            var s = o(3642), l = o(395);
+            i.exports = u;
+            function u(d) {
+              var v, _, b, p, k, E, T, L, g, x, C;
+              if (d || (d = {}), L = (d.nshades || 72) - 1, T = d.format || "hex", E = d.colormap, E || (E = "jet"), typeof E == "string") {
+                if (E = E.toLowerCase(), !s[E]) throw Error(E + " not a supported colorscale");
+                k = s[E];
+              } else if (Array.isArray(E)) k = E.slice();
+              else throw Error("unsupported colormap option", E);
+              if (k.length > L + 1) throw new Error(E + " map requires nshades to be at least size " + k.length);
+              Array.isArray(d.alpha) ? d.alpha.length !== 2 ? x = [1, 1] : x = d.alpha.slice() : typeof d.alpha == "number" ? x = [d.alpha, d.alpha] : x = [1, 1], v = k.map(function(z) {
+                return Math.round(z.index * L);
+              }), x[0] = Math.min(Math.max(x[0], 0), 1), x[1] = Math.min(Math.max(x[1], 0), 1);
+              var M = k.map(function(z, O) {
+                var U = k[O].index, G = k[O].rgb.slice();
+                return G.length === 4 && G[3] >= 0 && G[3] <= 1 || (G[3] = x[0] + (x[1] - x[0]) * U), G;
+              }), g = [];
+              for (C = 0; C < v.length - 1; ++C) {
+                p = v[C + 1] - v[C], _ = M[C], b = M[C + 1];
+                for (var P = 0; P < p; P++) {
+                  var A = P / p;
+                  g.push([Math.round(l(_[0], b[0], A)), Math.round(l(_[1], b[1], A)), Math.round(l(_[2], b[2], A)), l(_[3], b[3], A)]);
+                }
+              }
+              return g.push(k[k.length - 1].rgb.concat(x[1])), T === "hex" ? g = g.map(f) : T === "rgbaString" ? g = g.map(h) : T === "float" && (g = g.map(c)), g;
+            }
+            function c(d) {
+              return [d[0] / 255, d[1] / 255, d[2] / 255, d[3]];
+            }
+            function f(d) {
+              for (var v, _ = "#", b = 0; b < 3; ++b) v = d[b], v = v.toString(16), _ += ("00" + v).substr(v.length);
+              return _;
+            }
+            function h(d) {
+              return "rgba(" + d.join(",") + ")";
+            }
+          }, 6740: function(i, a, o) {
+            var s = o(3236), l = s([`precision highp float;
+
+precision highp float;
+#define GLSLIFY 1
+
+vec3 getOrthogonalVector(vec3 v) {
+  // Return up-vector for only-z vector.
+  // Return ax + by + cz = 0, a point that lies on the plane that has v as a normal and that isn't (0,0,0).
+  // From the above if-statement we have ||a|| > 0  U  ||b|| > 0.
+  // Assign z = 0, x = -b, y = a:
+  // a*-b + b*a + c*0 = -ba + ba + 0 = 0
+  if (v.x*v.x > v.z*v.z || v.y*v.y > v.z*v.z) {
+    return normalize(vec3(-v.y, v.x, 0.0));
+  } else {
+    return normalize(vec3(0.0, v.z, -v.y));
+  }
+}
+
+// Calculate the tube vertex and normal at the given index.
+//
+// The returned vertex is for a tube ring with its center at origin, radius of length(d), pointing in the direction of d.
+//
+// Each tube segment is made up of a ring of vertices.
+// These vertices are used to make up the triangles of the tube by connecting them together in the vertex array.
+// The indexes of tube segments run from 0 to 8.
+//
+vec3 getTubePosition(vec3 d, float index, out vec3 normal) {
+  float segmentCount = 8.0;
+
+  float angle = 2.0 * 3.14159 * (index / segmentCount);
+
+  vec3 u = getOrthogonalVector(d);
+  vec3 v = normalize(cross(u, d));
+
+  vec3 x = u * cos(angle) * length(d);
+  vec3 y = v * sin(angle) * length(d);
+  vec3 v3 = x + y;
+
+  normal = normalize(v3);
+
+  return v3;
+}
+
+attribute vec4 vector;
+attribute vec4 color, position;
+attribute vec2 uv;
+
+uniform float vectorScale, tubeScale;
+uniform mat4 model, view, projection, inverseModel;
+uniform vec3 eyePosition, lightPosition;
+
+varying vec3 f_normal, f_lightDirection, f_eyeDirection, f_data, f_position;
+varying vec4 f_color;
+varying vec2 f_uv;
+
+void main() {
+  // Scale the vector magnitude to stay constant with
+  // model & view changes.
+  vec3 normal;
+  vec3 XYZ = getTubePosition(mat3(model) * (tubeScale * vector.w * normalize(vector.xyz)), position.w, normal);
+  vec4 tubePosition = model * vec4(position.xyz, 1.0) + vec4(XYZ, 0.0);
+
+  //Lighting geometry parameters
+  vec4 cameraCoordinate = view * tubePosition;
+  cameraCoordinate.xyz /= cameraCoordinate.w;
+  f_lightDirection = lightPosition - cameraCoordinate.xyz;
+  f_eyeDirection   = eyePosition - cameraCoordinate.xyz;
+  f_normal = normalize((vec4(normal, 0.0) * inverseModel).xyz);
+
+  // vec4 m_position  = model * vec4(tubePosition, 1.0);
+  vec4 t_position  = view * tubePosition;
+  gl_Position      = projection * t_position;
+
+  f_color          = color;
+  f_data           = tubePosition.xyz;
+  f_position       = position.xyz;
+  f_uv             = uv;
+}
+`]), u = s([`#extension GL_OES_standard_derivatives : enable
+
+precision highp float;
+#define GLSLIFY 1
+
+float beckmannDistribution(float x, float roughness) {
+  float NdotH = max(x, 0.0001);
+  float cos2Alpha = NdotH * NdotH;
+  float tan2Alpha = (cos2Alpha - 1.0) / cos2Alpha;
+  float roughness2 = roughness * roughness;
+  float denom = 3.141592653589793 * roughness2 * cos2Alpha * cos2Alpha;
+  return exp(tan2Alpha / roughness2) / denom;
+}
+
+float cookTorranceSpecular(
+  vec3 lightDirection,
+  vec3 viewDirection,
+  vec3 surfaceNormal,
+  float roughness,
+  float fresnel) {
+
+  float VdotN = max(dot(viewDirection, surfaceNormal), 0.0);
+  float LdotN = max(dot(lightDirection, surfaceNormal), 0.0);
+
+  //Half angle vector
+  vec3 H = normalize(lightDirection + viewDirection);
+
+  //Geometric term
+  float NdotH = max(dot(surfaceNormal, H), 0.0);
+  float VdotH = max(dot(viewDirection, H), 0.000001);
+  float LdotH = max(dot(lightDirection, H), 0.000001);
+  float G1 = (2.0 * NdotH * VdotN) / VdotH;
+  float G2 = (2.0 * NdotH * LdotN) / LdotH;
+  float G = min(1.0, min(G1, G2));
+
+  //Distribution term
+  float D = beckmannDistribution(NdotH, roughness);
+
+  //Fresnel term
+  float F = pow(1.0 - VdotN, fresnel);
+
+  //Multiply terms and done
+  return  G * F * D / max(3.14159265 * VdotN, 0.000001);
+}
+
+bool outOfRange(float a, float b, float p) {
+  return ((p > max(a, b)) ||
+          (p < min(a, b)));
+}
+
+bool outOfRange(vec2 a, vec2 b, vec2 p) {
+  return (outOfRange(a.x, b.x, p.x) ||
+          outOfRange(a.y, b.y, p.y));
+}
+
+bool outOfRange(vec3 a, vec3 b, vec3 p) {
+  return (outOfRange(a.x, b.x, p.x) ||
+          outOfRange(a.y, b.y, p.y) ||
+          outOfRange(a.z, b.z, p.z));
+}
+
+bool outOfRange(vec4 a, vec4 b, vec4 p) {
+  return outOfRange(a.xyz, b.xyz, p.xyz);
+}
+
+uniform vec3 clipBounds[2];
+uniform float roughness, fresnel, kambient, kdiffuse, kspecular, opacity;
+uniform sampler2D texture;
+
+varying vec3 f_normal, f_lightDirection, f_eyeDirection, f_data, f_position;
+varying vec4 f_color;
+varying vec2 f_uv;
+
+void main() {
+  if (outOfRange(clipBounds[0], clipBounds[1], f_position)) discard;
+  vec3 N = normalize(f_normal);
+  vec3 L = normalize(f_lightDirection);
+  vec3 V = normalize(f_eyeDirection);
+
+  if(gl_FrontFacing) {
+    N = -N;
+  }
+
+  float specular = min(1.0, max(0.0, cookTorranceSpecular(L, V, N, roughness, fresnel)));
+  float diffuse  = min(kambient + kdiffuse * max(dot(N, L), 0.0), 1.0);
+
+  vec4 surfaceColor = f_color * texture2D(texture, f_uv);
+  vec4 litColor = surfaceColor.a * vec4(diffuse * surfaceColor.rgb + kspecular * vec3(1,1,1) * specular,  1.0);
+
+  gl_FragColor = litColor * opacity;
+}
+`]), c = s([`precision highp float;
+
+precision highp float;
+#define GLSLIFY 1
+
+vec3 getOrthogonalVector(vec3 v) {
+  // Return up-vector for only-z vector.
+  // Return ax + by + cz = 0, a point that lies on the plane that has v as a normal and that isn't (0,0,0).
+  // From the above if-statement we have ||a|| > 0  U  ||b|| > 0.
+  // Assign z = 0, x = -b, y = a:
+  // a*-b + b*a + c*0 = -ba + ba + 0 = 0
+  if (v.x*v.x > v.z*v.z || v.y*v.y > v.z*v.z) {
+    return normalize(vec3(-v.y, v.x, 0.0));
+  } else {
+    return normalize(vec3(0.0, v.z, -v.y));
+  }
+}
+
+// Calculate the tube vertex and normal at the given index.
+//
+// The returned vertex is for a tube ring with its center at origin, radius of length(d), pointing in the direction of d.
+//
+// Each tube segment is made up of a ring of vertices.
+// These vertices are used to make up the triangles of the tube by connecting them together in the vertex array.
+// The indexes of tube segments run from 0 to 8.
+//
+vec3 getTubePosition(vec3 d, float index, out vec3 normal) {
+  float segmentCount = 8.0;
+
+  float angle = 2.0 * 3.14159 * (index / segmentCount);
+
+  vec3 u = getOrthogonalVector(d);
+  vec3 v = normalize(cross(u, d));
+
+  vec3 x = u * cos(angle) * length(d);
+  vec3 y = v * sin(angle) * length(d);
+  vec3 v3 = x + y;
+
+  normal = normalize(v3);
+
+  return v3;
+}
+
+attribute vec4 vector;
+attribute vec4 position;
+attribute vec4 id;
+
+uniform mat4 model, view, projection;
+uniform float tubeScale;
+
+varying vec3 f_position;
+varying vec4 f_id;
+
+void main() {
+  vec3 normal;
+  vec3 XYZ = getTubePosition(mat3(model) * (tubeScale * vector.w * normalize(vector.xyz)), position.w, normal);
+  vec4 tubePosition = model * vec4(position.xyz, 1.0) + vec4(XYZ, 0.0);
+
+  gl_Position = projection * (view * tubePosition);
+  f_id        = id;
+  f_position  = position.xyz;
+}
+`]), f = s([`precision highp float;
+#define GLSLIFY 1
+
+bool outOfRange(float a, float b, float p) {
+  return ((p > max(a, b)) ||
+          (p < min(a, b)));
+}
+
+bool outOfRange(vec2 a, vec2 b, vec2 p) {
+  return (outOfRange(a.x, b.x, p.x) ||
+          outOfRange(a.y, b.y, p.y));
+}
+
+bool outOfRange(vec3 a, vec3 b, vec3 p) {
+  return (outOfRange(a.x, b.x, p.x) ||
+          outOfRange(a.y, b.y, p.y) ||
+          outOfRange(a.z, b.z, p.z));
+}
+
+bool outOfRange(vec4 a, vec4 b, vec4 p) {
+  return outOfRange(a.xyz, b.xyz, p.xyz);
+}
+
+uniform vec3  clipBounds[2];
+uniform float pickId;
+
+varying vec3 f_position;
+varying vec4 f_id;
+
+void main() {
+  if (outOfRange(clipBounds[0], clipBounds[1], f_position)) discard;
+
+  gl_FragColor = vec4(pickId, f_id.xyz);
+}`]);
+            a.meshShader = { vertex: l, fragment: u, attributes: [{ name: "position", type: "vec4" }, { name: "color", type: "vec4" }, { name: "uv", type: "vec2" }, { name: "vector", type: "vec4" }] }, a.pickShader = { vertex: c, fragment: f, attributes: [{ name: "position", type: "vec4" }, { name: "id", type: "vec4" }, { name: "vector", type: "vec4" }] };
+          }, 6743: function(i) {
+            i.exports = a;
+            function a(o, s, l) {
+              var u = s[0], c = s[1], f = s[2], h = s[3], d = u + u, v = c + c, _ = f + f, b = u * d, p = u * v, k = u * _, E = c * v, T = c * _, L = f * _, x = h * d, C = h * v, M = h * _;
+              return o[0] = 1 - (E + L), o[1] = p + M, o[2] = k - C, o[3] = 0, o[4] = p - M, o[5] = 1 - (b + L), o[6] = T + x, o[7] = 0, o[8] = k + C, o[9] = T - x, o[10] = 1 - (b + E), o[11] = 0, o[12] = l[0], o[13] = l[1], o[14] = l[2], o[15] = 1, o;
+            }
+          }, 6760: function(i) {
+            i.exports = a;
+            function a(o, s, l) {
+              var u = s[0], c = s[1], f = s[2], h = s[3], d = s[4], v = s[5], _ = s[6], b = s[7], p = s[8], k = s[9], E = s[10], T = s[11], L = s[12], x = s[13], C = s[14], M = s[15], g = l[0], P = l[1], A = l[2], z = l[3];
+              return o[0] = g * u + P * d + A * p + z * L, o[1] = g * c + P * v + A * k + z * x, o[2] = g * f + P * _ + A * E + z * C, o[3] = g * h + P * b + A * T + z * M, g = l[4], P = l[5], A = l[6], z = l[7], o[4] = g * u + P * d + A * p + z * L, o[5] = g * c + P * v + A * k + z * x, o[6] = g * f + P * _ + A * E + z * C, o[7] = g * h + P * b + A * T + z * M, g = l[8], P = l[9], A = l[10], z = l[11], o[8] = g * u + P * d + A * p + z * L, o[9] = g * c + P * v + A * k + z * x, o[10] = g * f + P * _ + A * E + z * C, o[11] = g * h + P * b + A * T + z * M, g = l[12], P = l[13], A = l[14], z = l[15], o[12] = g * u + P * d + A * p + z * L, o[13] = g * c + P * v + A * k + z * x, o[14] = g * f + P * _ + A * E + z * C, o[15] = g * h + P * b + A * T + z * M, o;
+            }
+          }, 6768: function(i, a, o) {
+            var s = o(6859);
+            i.exports = l;
+            function l(u) {
+              return new s(u);
+            }
+          }, 6803: function(i, a, o) {
+            o(8828);
+            o(1755);
+            function d(P, A) {
+              var z = P.length, O = P.length - A.length, U = Math.min;
+              if (O) return O;
+              switch (z) {
+                case 0:
+                  return 0;
+                case 1:
+                  return P[0] - A[0];
+                case 2:
+                  var H = P[0] + P[1] - A[0] - A[1];
+                  return H || U(P[0], P[1]) - U(A[0], A[1]);
+                case 3:
+                  var G = P[0] + P[1], Z = A[0] + A[1];
+                  if (H = G + P[2] - (Z + A[2]), H) return H;
+                  var j = U(P[0], P[1]), N = U(A[0], A[1]), H = U(j, P[2]) - U(N, A[2]);
+                  return H || U(j + P[2], G) - U(N + A[2], Z);
+                default:
+                  var re = P.slice(0);
+                  re.sort();
+                  var oe = A.slice(0);
+                  oe.sort();
+                  for (var _e = 0; _e < z; ++_e) if (O = re[_e] - oe[_e], O) return O;
+                  return 0;
+              }
+            }
+            a.Fw = d;
+          }, 6808: function(i) {
+            i.exports = a;
+            function a(o) {
+              var s = o[0], l = o[1], u = o[2], c = o[3];
+              return Math.sqrt(s * s + l * l + u * u + c * c);
+            }
+          }, 6843: function(i) {
+            i.exports = a;
+            function a(o, s, l) {
+              return o[0] = s[0] - l[0], o[1] = s[1] - l[1], o[2] = s[2] - l[2], o;
+            }
+          }, 6852: function(i) {
+            i.exports = ["abs", "acos", "all", "any", "asin", "atan", "ceil", "clamp", "cos", "cross", "dFdx", "dFdy", "degrees", "distance", "dot", "equal", "exp", "exp2", "faceforward", "floor", "fract", "gl_BackColor", "gl_BackLightModelProduct", "gl_BackLightProduct", "gl_BackMaterial", "gl_BackSecondaryColor", "gl_ClipPlane", "gl_ClipVertex", "gl_Color", "gl_DepthRange", "gl_DepthRangeParameters", "gl_EyePlaneQ", "gl_EyePlaneR", "gl_EyePlaneS", "gl_EyePlaneT", "gl_Fog", "gl_FogCoord", "gl_FogFragCoord", "gl_FogParameters", "gl_FragColor", "gl_FragCoord", "gl_FragData", "gl_FragDepth", "gl_FragDepthEXT", "gl_FrontColor", "gl_FrontFacing", "gl_FrontLightModelProduct", "gl_FrontLightProduct", "gl_FrontMaterial", "gl_FrontSecondaryColor", "gl_LightModel", "gl_LightModelParameters", "gl_LightModelProducts", "gl_LightProducts", "gl_LightSource", "gl_LightSourceParameters", "gl_MaterialParameters", "gl_MaxClipPlanes", "gl_MaxCombinedTextureImageUnits", "gl_MaxDrawBuffers", "gl_MaxFragmentUniformComponents", "gl_MaxLights", "gl_MaxTextureCoords", "gl_MaxTextureImageUnits", "gl_MaxTextureUnits", "gl_MaxVaryingFloats", "gl_MaxVertexAttribs", "gl_MaxVertexTextureImageUnits", "gl_MaxVertexUniformComponents", "gl_ModelViewMatrix", "gl_ModelViewMatrixInverse", "gl_ModelViewMatrixInverseTranspose", "gl_ModelViewMatrixTranspose", "gl_ModelViewProjectionMatrix", "gl_ModelViewProjectionMatrixInverse", "gl_ModelViewProjectionMatrixInverseTranspose", "gl_ModelViewProjectionMatrixTranspose", "gl_MultiTexCoord0", "gl_MultiTexCoord1", "gl_MultiTexCoord2", "gl_MultiTexCoord3", "gl_MultiTexCoord4", "gl_MultiTexCoord5", "gl_MultiTexCoord6", "gl_MultiTexCoord7", "gl_Normal", "gl_NormalMatrix", "gl_NormalScale", "gl_ObjectPlaneQ", "gl_ObjectPlaneR", "gl_ObjectPlaneS", "gl_ObjectPlaneT", "gl_Point", "gl_PointCoord", "gl_PointParameters", "gl_PointSize", "gl_Position", "gl_ProjectionMatrix", "gl_ProjectionMatrixInverse", "gl_ProjectionMatrixInverseTranspose", "gl_ProjectionMatrixTranspose", "gl_SecondaryColor", "gl_TexCoord", "gl_TextureEnvColor", "gl_TextureMatrix", "gl_TextureMatrixInverse", "gl_TextureMatrixInverseTranspose", "gl_TextureMatrixTranspose", "gl_Vertex", "greaterThan", "greaterThanEqual", "inversesqrt", "length", "lessThan", "lessThanEqual", "log", "log2", "matrixCompMult", "max", "min", "mix", "mod", "normalize", "not", "notEqual", "pow", "radians", "reflect", "refract", "sign", "sin", "smoothstep", "sqrt", "step", "tan", "texture2D", "texture2DLod", "texture2DProj", "texture2DProjLod", "textureCube", "textureCubeLod", "texture2DLodEXT", "texture2DProjLodEXT", "textureCubeLodEXT", "texture2DGradEXT", "texture2DProjGradEXT", "textureCubeGradEXT"];
+          }, 6859: function(i, a, o) {
+            i = o.nmd(i), function(s, l) {
+              function u(j, N) {
+                if (!j) throw new Error(N || "Assertion failed");
+              }
+              function c(j, N) {
+                j.super_ = N;
+                var H = function() {
+                };
+                H.prototype = N.prototype, j.prototype = new H(), j.prototype.constructor = j;
+              }
+              function f(j, N, H) {
+                if (f.isBN(j)) return j;
+                this.negative = 0, this.words = null, this.length = 0, this.red = null, j !== null && ((N === "le" || N === "be") && (H = N, N = 10), this._init(j || 0, N || 10, H || "be"));
+              }
+              typeof s == "object" ? s.exports = f : l.BN = f, f.BN = f, f.wordSize = 26;
+              var h;
+              try {
+                typeof window != "undefined" && typeof window.Buffer != "undefined" ? h = window.Buffer : h = o(7790).Buffer;
+              } catch (j) {
+              }
+              f.isBN = function(N) {
+                return N instanceof f ? true : N !== null && typeof N == "object" && N.constructor.wordSize === f.wordSize && Array.isArray(N.words);
+              }, f.max = function(N, H) {
+                return N.cmp(H) > 0 ? N : H;
+              }, f.min = function(N, H) {
+                return N.cmp(H) < 0 ? N : H;
+              }, f.prototype._init = function(N, H, re) {
+                if (typeof N == "number") return this._initNumber(N, H, re);
+                if (typeof N == "object") return this._initArray(N, H, re);
+                H === "hex" && (H = 16), u(H === (H | 0) && H >= 2 && H <= 36), N = N.toString().replace(/\s+/g, "");
+                var oe = 0;
+                N[0] === "-" && (oe++, this.negative = 1), oe < N.length && (H === 16 ? this._parseHex(N, oe, re) : (this._parseBase(N, H, oe), re === "le" && this._initArray(this.toArray(), H, re)));
+              }, f.prototype._initNumber = function(N, H, re) {
+                N < 0 && (this.negative = 1, N = -N), N < 67108864 ? (this.words = [N & 67108863], this.length = 1) : N < 4503599627370496 ? (this.words = [N & 67108863, N / 67108864 & 67108863], this.length = 2) : (u(N < 9007199254740992), this.words = [N & 67108863, N / 67108864 & 67108863, 1], this.length = 3), re === "le" && this._initArray(this.toArray(), H, re);
+              }, f.prototype._initArray = function(N, H, re) {
+                if (u(typeof N.length == "number"), N.length <= 0) return this.words = [0], this.length = 1, this;
+                this.length = Math.ceil(N.length / 3), this.words = new Array(this.length);
+                for (var oe = 0; oe < this.length; oe++) this.words[oe] = 0;
+                var _e, Ce, Le = 0;
+                if (re === "be") for (oe = N.length - 1, _e = 0; oe >= 0; oe -= 3) Ce = N[oe] | N[oe - 1] << 8 | N[oe - 2] << 16, this.words[_e] |= Ce << Le & 67108863, this.words[_e + 1] = Ce >>> 26 - Le & 67108863, Le += 24, Le >= 26 && (Le -= 26, _e++);
+                else if (re === "le") for (oe = 0, _e = 0; oe < N.length; oe += 3) Ce = N[oe] | N[oe + 1] << 8 | N[oe + 2] << 16, this.words[_e] |= Ce << Le & 67108863, this.words[_e + 1] = Ce >>> 26 - Le & 67108863, Le += 24, Le >= 26 && (Le -= 26, _e++);
+                return this.strip();
+              };
+              function d(j, N) {
+                var H = j.charCodeAt(N);
+                return H >= 65 && H <= 70 ? H - 55 : H >= 97 && H <= 102 ? H - 87 : H - 48 & 15;
+              }
+              function v(j, N, H) {
+                var re = d(j, H);
+                return H - 1 >= N && (re |= d(j, H - 1) << 4), re;
+              }
+              f.prototype._parseHex = function(N, H, re) {
+                this.length = Math.ceil((N.length - H) / 6), this.words = new Array(this.length);
+                for (var oe = 0; oe < this.length; oe++) this.words[oe] = 0;
+                var _e = 0, Ce = 0, Le;
+                if (re === "be") for (oe = N.length - 1; oe >= H; oe -= 2) Le = v(N, H, oe) << _e, this.words[Ce] |= Le & 67108863, _e >= 18 ? (_e -= 18, Ce += 1, this.words[Ce] |= Le >>> 26) : _e += 8;
+                else {
+                  var ge = N.length - H;
+                  for (oe = ge % 2 === 0 ? H + 1 : H; oe < N.length; oe += 2) Le = v(N, H, oe) << _e, this.words[Ce] |= Le & 67108863, _e >= 18 ? (_e -= 18, Ce += 1, this.words[Ce] |= Le >>> 26) : _e += 8;
+                }
+                this.strip();
+              };
+              function _(j, N, H, re) {
+                for (var oe = 0, _e = Math.min(j.length, H), Ce = N; Ce < _e; Ce++) {
+                  var Le = j.charCodeAt(Ce) - 48;
+                  oe *= re, Le >= 49 ? oe += Le - 49 + 10 : Le >= 17 ? oe += Le - 17 + 10 : oe += Le;
+                }
+                return oe;
+              }
+              f.prototype._parseBase = function(N, H, re) {
+                this.words = [0], this.length = 1;
+                for (var oe = 0, _e = 1; _e <= 67108863; _e *= H) oe++;
+                oe--, _e = _e / H | 0;
+                for (var Ce = N.length - re, Le = Ce % oe, ge = Math.min(Ce, Ce - Le) + re, ie = 0, Se = re; Se < ge; Se += oe) ie = _(N, Se, Se + oe, H), this.imuln(_e), this.words[0] + ie < 67108864 ? this.words[0] += ie : this._iaddn(ie);
+                if (Le !== 0) {
+                  var Ee = 1;
+                  for (ie = _(N, Se, N.length, H), Se = 0; Se < Le; Se++) Ee *= H;
+                  this.imuln(Ee), this.words[0] + ie < 67108864 ? this.words[0] += ie : this._iaddn(ie);
+                }
+                this.strip();
+              }, f.prototype.copy = function(N) {
+                N.words = new Array(this.length);
+                for (var H = 0; H < this.length; H++) N.words[H] = this.words[H];
+                N.length = this.length, N.negative = this.negative, N.red = this.red;
+              }, f.prototype.clone = function() {
+                var N = new f(null);
+                return this.copy(N), N;
+              }, f.prototype._expand = function(N) {
+                for (; this.length < N; ) this.words[this.length++] = 0;
+                return this;
+              }, f.prototype.strip = function() {
+                for (; this.length > 1 && this.words[this.length - 1] === 0; ) this.length--;
+                return this._normSign();
+              }, f.prototype._normSign = function() {
+                return this.length === 1 && this.words[0] === 0 && (this.negative = 0), this;
+              }, f.prototype.inspect = function() {
+                return (this.red ? "<BN-R: " : "<BN: ") + this.toString(16) + ">";
+              };
+              var b = ["", "0", "00", "000", "0000", "00000", "000000", "0000000", "00000000", "000000000", "0000000000", "00000000000", "000000000000", "0000000000000", "00000000000000", "000000000000000", "0000000000000000", "00000000000000000", "000000000000000000", "0000000000000000000", "00000000000000000000", "000000000000000000000", "0000000000000000000000", "00000000000000000000000", "000000000000000000000000", "0000000000000000000000000"], p = [0, 0, 25, 16, 12, 11, 10, 9, 8, 8, 7, 7, 7, 7, 6, 6, 6, 6, 6, 6, 6, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5], k = [0, 0, 33554432, 43046721, 16777216, 48828125, 60466176, 40353607, 16777216, 43046721, 1e7, 19487171, 35831808, 62748517, 7529536, 11390625, 16777216, 24137569, 34012224, 47045881, 64e6, 4084101, 5153632, 6436343, 7962624, 9765625, 11881376, 14348907, 17210368, 20511149, 243e5, 28629151, 33554432, 39135393, 45435424, 52521875, 60466176];
+              f.prototype.toString = function(N, H) {
+                N = N || 10, H = H | 0 || 1;
+                var re;
+                if (N === 16 || N === "hex") {
+                  re = "";
+                  for (var oe = 0, _e = 0, Ce = 0; Ce < this.length; Ce++) {
+                    var Le = this.words[Ce], ge = ((Le << oe | _e) & 16777215).toString(16);
+                    _e = Le >>> 24 - oe & 16777215, _e !== 0 || Ce !== this.length - 1 ? re = b[6 - ge.length] + ge + re : re = ge + re, oe += 2, oe >= 26 && (oe -= 26, Ce--);
+                  }
+                  for (_e !== 0 && (re = _e.toString(16) + re); re.length % H !== 0; ) re = "0" + re;
+                  return this.negative !== 0 && (re = "-" + re), re;
+                }
+                if (N === (N | 0) && N >= 2 && N <= 36) {
+                  var ie = p[N], Se = k[N];
+                  re = "";
+                  var Ee = this.clone();
+                  for (Ee.negative = 0; !Ee.isZero(); ) {
+                    var Ae = Ee.modn(Se).toString(N);
+                    Ee = Ee.idivn(Se), Ee.isZero() ? re = Ae + re : re = b[ie - Ae.length] + Ae + re;
+                  }
+                  for (this.isZero() && (re = "0" + re); re.length % H !== 0; ) re = "0" + re;
+                  return this.negative !== 0 && (re = "-" + re), re;
+                }
+                u(false, "Base should be between 2 and 36");
+              }, f.prototype.toNumber = function() {
+                var N = this.words[0];
+                return this.length === 2 ? N += this.words[1] * 67108864 : this.length === 3 && this.words[2] === 1 ? N += 4503599627370496 + this.words[1] * 67108864 : this.length > 2 && u(false, "Number can only safely store up to 53 bits"), this.negative !== 0 ? -N : N;
+              }, f.prototype.toJSON = function() {
+                return this.toString(16);
+              }, f.prototype.toBuffer = function(N, H) {
+                return u(typeof h != "undefined"), this.toArrayLike(h, N, H);
+              }, f.prototype.toArray = function(N, H) {
+                return this.toArrayLike(Array, N, H);
+              }, f.prototype.toArrayLike = function(N, H, re) {
+                var oe = this.byteLength(), _e = re || Math.max(1, oe);
+                u(oe <= _e, "byte array longer than desired length"), u(_e > 0, "Requested array length <= 0"), this.strip();
+                var Ce = H === "le", Le = new N(_e), ge, ie, Se = this.clone();
+                if (Ce) {
+                  for (ie = 0; !Se.isZero(); ie++) ge = Se.andln(255), Se.iushrn(8), Le[ie] = ge;
+                  for (; ie < _e; ie++) Le[ie] = 0;
+                } else {
+                  for (ie = 0; ie < _e - oe; ie++) Le[ie] = 0;
+                  for (ie = 0; !Se.isZero(); ie++) ge = Se.andln(255), Se.iushrn(8), Le[_e - ie - 1] = ge;
+                }
+                return Le;
+              }, Math.clz32 ? f.prototype._countBits = function(N) {
+                return 32 - Math.clz32(N);
+              } : f.prototype._countBits = function(N) {
+                var H = N, re = 0;
+                return H >= 4096 && (re += 13, H >>>= 13), H >= 64 && (re += 7, H >>>= 7), H >= 8 && (re += 4, H >>>= 4), H >= 2 && (re += 2, H >>>= 2), re + H;
+              }, f.prototype._zeroBits = function(N) {
+                if (N === 0) return 26;
+                var H = N, re = 0;
+                return (H & 8191) === 0 && (re += 13, H >>>= 13), (H & 127) === 0 && (re += 7, H >>>= 7), (H & 15) === 0 && (re += 4, H >>>= 4), (H & 3) === 0 && (re += 2, H >>>= 2), (H & 1) === 0 && re++, re;
+              }, f.prototype.bitLength = function() {
+                var N = this.words[this.length - 1], H = this._countBits(N);
+                return (this.length - 1) * 26 + H;
+              };
+              function E(j) {
+                for (var N = new Array(j.bitLength()), H = 0; H < N.length; H++) {
+                  var re = H / 26 | 0, oe = H % 26;
+                  N[H] = (j.words[re] & 1 << oe) >>> oe;
+                }
+                return N;
+              }
+              f.prototype.zeroBits = function() {
+                if (this.isZero()) return 0;
+                for (var N = 0, H = 0; H < this.length; H++) {
+                  var re = this._zeroBits(this.words[H]);
+                  if (N += re, re !== 26) break;
+                }
+                return N;
+              }, f.prototype.byteLength = function() {
+                return Math.ceil(this.bitLength() / 8);
+              }, f.prototype.toTwos = function(N) {
+                return this.negative !== 0 ? this.abs().inotn(N).iaddn(1) : this.clone();
+              }, f.prototype.fromTwos = function(N) {
+                return this.testn(N - 1) ? this.notn(N).iaddn(1).ineg() : this.clone();
+              }, f.prototype.isNeg = function() {
+                return this.negative !== 0;
+              }, f.prototype.neg = function() {
+                return this.clone().ineg();
+              }, f.prototype.ineg = function() {
+                return this.isZero() || (this.negative ^= 1), this;
+              }, f.prototype.iuor = function(N) {
+                for (; this.length < N.length; ) this.words[this.length++] = 0;
+                for (var H = 0; H < N.length; H++) this.words[H] = this.words[H] | N.words[H];
+                return this.strip();
+              }, f.prototype.ior = function(N) {
+                return u((this.negative | N.negative) === 0), this.iuor(N);
+              }, f.prototype.or = function(N) {
+                return this.length > N.length ? this.clone().ior(N) : N.clone().ior(this);
+              }, f.prototype.uor = function(N) {
+                return this.length > N.length ? this.clone().iuor(N) : N.clone().iuor(this);
+              }, f.prototype.iuand = function(N) {
+                var H;
+                this.length > N.length ? H = N : H = this;
+                for (var re = 0; re < H.length; re++) this.words[re] = this.words[re] & N.words[re];
+                return this.length = H.length, this.strip();
+              }, f.prototype.iand = function(N) {
+                return u((this.negative | N.negative) === 0), this.iuand(N);
+              }, f.prototype.and = function(N) {
+                return this.length > N.length ? this.clone().iand(N) : N.clone().iand(this);
+              }, f.prototype.uand = function(N) {
+                return this.length > N.length ? this.clone().iuand(N) : N.clone().iuand(this);
+              }, f.prototype.iuxor = function(N) {
+                var H, re;
+                this.length > N.length ? (H = this, re = N) : (H = N, re = this);
+                for (var oe = 0; oe < re.length; oe++) this.words[oe] = H.words[oe] ^ re.words[oe];
+                if (this !== H) for (; oe < H.length; oe++) this.words[oe] = H.words[oe];
+                return this.length = H.length, this.strip();
+              }, f.prototype.ixor = function(N) {
+                return u((this.negative | N.negative) === 0), this.iuxor(N);
+              }, f.prototype.xor = function(N) {
+                return this.length > N.length ? this.clone().ixor(N) : N.clone().ixor(this);
+              }, f.prototype.uxor = function(N) {
+                return this.length > N.length ? this.clone().iuxor(N) : N.clone().iuxor(this);
+              }, f.prototype.inotn = function(N) {
+                u(typeof N == "number" && N >= 0);
+                var H = Math.ceil(N / 26) | 0, re = N % 26;
+                this._expand(H), re > 0 && H--;
+                for (var oe = 0; oe < H; oe++) this.words[oe] = ~this.words[oe] & 67108863;
+                return re > 0 && (this.words[oe] = ~this.words[oe] & 67108863 >> 26 - re), this.strip();
+              }, f.prototype.notn = function(N) {
+                return this.clone().inotn(N);
+              }, f.prototype.setn = function(N, H) {
+                u(typeof N == "number" && N >= 0);
+                var re = N / 26 | 0, oe = N % 26;
+                return this._expand(re + 1), H ? this.words[re] = this.words[re] | 1 << oe : this.words[re] = this.words[re] & ~(1 << oe), this.strip();
+              }, f.prototype.iadd = function(N) {
+                var H;
+                if (this.negative !== 0 && N.negative === 0) return this.negative = 0, H = this.isub(N), this.negative ^= 1, this._normSign();
+                if (this.negative === 0 && N.negative !== 0) return N.negative = 0, H = this.isub(N), N.negative = 1, H._normSign();
+                var re, oe;
+                this.length > N.length ? (re = this, oe = N) : (re = N, oe = this);
+                for (var _e = 0, Ce = 0; Ce < oe.length; Ce++) H = (re.words[Ce] | 0) + (oe.words[Ce] | 0) + _e, this.words[Ce] = H & 67108863, _e = H >>> 26;
+                for (; _e !== 0 && Ce < re.length; Ce++) H = (re.words[Ce] | 0) + _e, this.words[Ce] = H & 67108863, _e = H >>> 26;
+                if (this.length = re.length, _e !== 0) this.words[this.length] = _e, this.length++;
+                else if (re !== this) for (; Ce < re.length; Ce++) this.words[Ce] = re.words[Ce];
+                return this;
+              }, f.prototype.add = function(N) {
+                var H;
+                return N.negative !== 0 && this.negative === 0 ? (N.negative = 0, H = this.sub(N), N.negative ^= 1, H) : N.negative === 0 && this.negative !== 0 ? (this.negative = 0, H = N.sub(this), this.negative = 1, H) : this.length > N.length ? this.clone().iadd(N) : N.clone().iadd(this);
+              }, f.prototype.isub = function(N) {
+                if (N.negative !== 0) {
+                  N.negative = 0;
+                  var H = this.iadd(N);
+                  return N.negative = 1, H._normSign();
+                } else if (this.negative !== 0) return this.negative = 0, this.iadd(N), this.negative = 1, this._normSign();
+                var re = this.cmp(N);
+                if (re === 0) return this.negative = 0, this.length = 1, this.words[0] = 0, this;
+                var oe, _e;
+                re > 0 ? (oe = this, _e = N) : (oe = N, _e = this);
+                for (var Ce = 0, Le = 0; Le < _e.length; Le++) H = (oe.words[Le] | 0) - (_e.words[Le] | 0) + Ce, Ce = H >> 26, this.words[Le] = H & 67108863;
+                for (; Ce !== 0 && Le < oe.length; Le++) H = (oe.words[Le] | 0) + Ce, Ce = H >> 26, this.words[Le] = H & 67108863;
+                if (Ce === 0 && Le < oe.length && oe !== this) for (; Le < oe.length; Le++) this.words[Le] = oe.words[Le];
+                return this.length = Math.max(this.length, Le), oe !== this && (this.negative = 1), this.strip();
+              }, f.prototype.sub = function(N) {
+                return this.clone().isub(N);
+              };
+              function T(j, N, H) {
+                H.negative = N.negative ^ j.negative;
+                var re = j.length + N.length | 0;
+                H.length = re, re = re - 1 | 0;
+                var oe = j.words[0] | 0, _e = N.words[0] | 0, Ce = oe * _e, Le = Ce & 67108863, ge = Ce / 67108864 | 0;
+                H.words[0] = Le;
+                for (var ie = 1; ie < re; ie++) {
+                  for (var Se = ge >>> 26, Ee = ge & 67108863, Ae = Math.min(ie, N.length - 1), Be = Math.max(0, ie - j.length + 1); Be <= Ae; Be++) {
+                    var Pe = ie - Be | 0;
+                    oe = j.words[Pe] | 0, _e = N.words[Be] | 0, Ce = oe * _e + Ee, Se += Ce / 67108864 | 0, Ee = Ce & 67108863;
+                  }
+                  H.words[ie] = Ee | 0, ge = Se | 0;
+                }
+                return ge !== 0 ? H.words[ie] = ge | 0 : H.length--, H.strip();
+              }
+              var L = function(N, H, re) {
+                var oe = N.words, _e = H.words, Ce = re.words, Le = 0, ge, ie, Se, Ee = oe[0] | 0, Ae = Ee & 8191, Be = Ee >>> 13, Pe = oe[1] | 0, me = Pe & 8191, De = Pe >>> 13, ce = oe[2] | 0, je = ce & 8191, lt = ce >>> 13, pt = oe[3] | 0, Vt = pt & 8191, ot = pt >>> 13, ut = oe[4] | 0, Wt = ut & 8191, Nt = ut >>> 13, $t = oe[5] | 0, sr = $t & 8191, Tr = $t >>> 13, fr = oe[6] | 0, $e = fr & 8191, St = fr >>> 13, Qt = oe[7] | 0, Gt = Qt & 8191, _t = Qt >>> 13, It = oe[8] | 0, mt = It & 8191, er = It >>> 13, lr = oe[9] | 0, wr = lr & 8191, Lr = lr >>> 13, ti = _e[0] | 0, Br = ti & 8191, Vr = ti >>> 13, dt = _e[1] | 0, Ge = dt & 8191, Je = dt >>> 13, We = _e[2] | 0, tt = We & 8191, xt = We >>> 13, Ie = _e[3] | 0, xe = Ie & 8191, ke = Ie >>> 13, vt = _e[4] | 0, ir = vt & 8191, ar = vt >>> 13, vr = _e[5] | 0, ii = vr & 8191, pi = vr >>> 13, $r = _e[6] | 0, di = $r & 8191, ji = $r >>> 13, In = _e[7] | 0, wi = In & 8191, On = In >>> 13, qn = _e[8] | 0, Fn = qn & 8191, ra = qn >>> 13, la = _e[9] | 0, Ut = la & 8191, wt = la >>> 13;
+                re.negative = N.negative ^ H.negative, re.length = 19, ge = Math.imul(Ae, Br), ie = Math.imul(Ae, Vr), ie = ie + Math.imul(Be, Br) | 0, Se = Math.imul(Be, Vr);
+                var rr = (Le + ge | 0) + ((ie & 8191) << 13) | 0;
+                Le = (Se + (ie >>> 13) | 0) + (rr >>> 26) | 0, rr &= 67108863, ge = Math.imul(me, Br), ie = Math.imul(me, Vr), ie = ie + Math.imul(De, Br) | 0, Se = Math.imul(De, Vr), ge = ge + Math.imul(Ae, Ge) | 0, ie = ie + Math.imul(Ae, Je) | 0, ie = ie + Math.imul(Be, Ge) | 0, Se = Se + Math.imul(Be, Je) | 0;
+                var nr = (Le + ge | 0) + ((ie & 8191) << 13) | 0;
+                Le = (Se + (ie >>> 13) | 0) + (nr >>> 26) | 0, nr &= 67108863, ge = Math.imul(je, Br), ie = Math.imul(je, Vr), ie = ie + Math.imul(lt, Br) | 0, Se = Math.imul(lt, Vr), ge = ge + Math.imul(me, Ge) | 0, ie = ie + Math.imul(me, Je) | 0, ie = ie + Math.imul(De, Ge) | 0, Se = Se + Math.imul(De, Je) | 0, ge = ge + Math.imul(Ae, tt) | 0, ie = ie + Math.imul(Ae, xt) | 0, ie = ie + Math.imul(Be, tt) | 0, Se = Se + Math.imul(Be, xt) | 0;
+                var Er = (Le + ge | 0) + ((ie & 8191) << 13) | 0;
+                Le = (Se + (ie >>> 13) | 0) + (Er >>> 26) | 0, Er &= 67108863, ge = Math.imul(Vt, Br), ie = Math.imul(Vt, Vr), ie = ie + Math.imul(ot, Br) | 0, Se = Math.imul(ot, Vr), ge = ge + Math.imul(je, Ge) | 0, ie = ie + Math.imul(je, Je) | 0, ie = ie + Math.imul(lt, Ge) | 0, Se = Se + Math.imul(lt, Je) | 0, ge = ge + Math.imul(me, tt) | 0, ie = ie + Math.imul(me, xt) | 0, ie = ie + Math.imul(De, tt) | 0, Se = Se + Math.imul(De, xt) | 0, ge = ge + Math.imul(Ae, xe) | 0, ie = ie + Math.imul(Ae, ke) | 0, ie = ie + Math.imul(Be, xe) | 0, Se = Se + Math.imul(Be, ke) | 0;
+                var Xr = (Le + ge | 0) + ((ie & 8191) << 13) | 0;
+                Le = (Se + (ie >>> 13) | 0) + (Xr >>> 26) | 0, Xr &= 67108863, ge = Math.imul(Wt, Br), ie = Math.imul(Wt, Vr), ie = ie + Math.imul(Nt, Br) | 0, Se = Math.imul(Nt, Vr), ge = ge + Math.imul(Vt, Ge) | 0, ie = ie + Math.imul(Vt, Je) | 0, ie = ie + Math.imul(ot, Ge) | 0, Se = Se + Math.imul(ot, Je) | 0, ge = ge + Math.imul(je, tt) | 0, ie = ie + Math.imul(je, xt) | 0, ie = ie + Math.imul(lt, tt) | 0, Se = Se + Math.imul(lt, xt) | 0, ge = ge + Math.imul(me, xe) | 0, ie = ie + Math.imul(me, ke) | 0, ie = ie + Math.imul(De, xe) | 0, Se = Se + Math.imul(De, ke) | 0, ge = ge + Math.imul(Ae, ir) | 0, ie = ie + Math.imul(Ae, ar) | 0, ie = ie + Math.imul(Be, ir) | 0, Se = Se + Math.imul(Be, ar) | 0;
+                var ri = (Le + ge | 0) + ((ie & 8191) << 13) | 0;
+                Le = (Se + (ie >>> 13) | 0) + (ri >>> 26) | 0, ri &= 67108863, ge = Math.imul(sr, Br), ie = Math.imul(sr, Vr), ie = ie + Math.imul(Tr, Br) | 0, Se = Math.imul(Tr, Vr), ge = ge + Math.imul(Wt, Ge) | 0, ie = ie + Math.imul(Wt, Je) | 0, ie = ie + Math.imul(Nt, Ge) | 0, Se = Se + Math.imul(Nt, Je) | 0, ge = ge + Math.imul(Vt, tt) | 0, ie = ie + Math.imul(Vt, xt) | 0, ie = ie + Math.imul(ot, tt) | 0, Se = Se + Math.imul(ot, xt) | 0, ge = ge + Math.imul(je, xe) | 0, ie = ie + Math.imul(je, ke) | 0, ie = ie + Math.imul(lt, xe) | 0, Se = Se + Math.imul(lt, ke) | 0, ge = ge + Math.imul(me, ir) | 0, ie = ie + Math.imul(me, ar) | 0, ie = ie + Math.imul(De, ir) | 0, Se = Se + Math.imul(De, ar) | 0, ge = ge + Math.imul(Ae, ii) | 0, ie = ie + Math.imul(Ae, pi) | 0, ie = ie + Math.imul(Be, ii) | 0, Se = Se + Math.imul(Be, pi) | 0;
+                var Qr = (Le + ge | 0) + ((ie & 8191) << 13) | 0;
+                Le = (Se + (ie >>> 13) | 0) + (Qr >>> 26) | 0, Qr &= 67108863, ge = Math.imul($e, Br), ie = Math.imul($e, Vr), ie = ie + Math.imul(St, Br) | 0, Se = Math.imul(St, Vr), ge = ge + Math.imul(sr, Ge) | 0, ie = ie + Math.imul(sr, Je) | 0, ie = ie + Math.imul(Tr, Ge) | 0, Se = Se + Math.imul(Tr, Je) | 0, ge = ge + Math.imul(Wt, tt) | 0, ie = ie + Math.imul(Wt, xt) | 0, ie = ie + Math.imul(Nt, tt) | 0, Se = Se + Math.imul(Nt, xt) | 0, ge = ge + Math.imul(Vt, xe) | 0, ie = ie + Math.imul(Vt, ke) | 0, ie = ie + Math.imul(ot, xe) | 0, Se = Se + Math.imul(ot, ke) | 0, ge = ge + Math.imul(je, ir) | 0, ie = ie + Math.imul(je, ar) | 0, ie = ie + Math.imul(lt, ir) | 0, Se = Se + Math.imul(lt, ar) | 0, ge = ge + Math.imul(me, ii) | 0, ie = ie + Math.imul(me, pi) | 0, ie = ie + Math.imul(De, ii) | 0, Se = Se + Math.imul(De, pi) | 0, ge = ge + Math.imul(Ae, di) | 0, ie = ie + Math.imul(Ae, ji) | 0, ie = ie + Math.imul(Be, di) | 0, Se = Se + Math.imul(Be, ji) | 0;
+                var Oi = (Le + ge | 0) + ((ie & 8191) << 13) | 0;
+                Le = (Se + (ie >>> 13) | 0) + (Oi >>> 26) | 0, Oi &= 67108863, ge = Math.imul(Gt, Br), ie = Math.imul(Gt, Vr), ie = ie + Math.imul(_t, Br) | 0, Se = Math.imul(_t, Vr), ge = ge + Math.imul($e, Ge) | 0, ie = ie + Math.imul($e, Je) | 0, ie = ie + Math.imul(St, Ge) | 0, Se = Se + Math.imul(St, Je) | 0, ge = ge + Math.imul(sr, tt) | 0, ie = ie + Math.imul(sr, xt) | 0, ie = ie + Math.imul(Tr, tt) | 0, Se = Se + Math.imul(Tr, xt) | 0, ge = ge + Math.imul(Wt, xe) | 0, ie = ie + Math.imul(Wt, ke) | 0, ie = ie + Math.imul(Nt, xe) | 0, Se = Se + Math.imul(Nt, ke) | 0, ge = ge + Math.imul(Vt, ir) | 0, ie = ie + Math.imul(Vt, ar) | 0, ie = ie + Math.imul(ot, ir) | 0, Se = Se + Math.imul(ot, ar) | 0, ge = ge + Math.imul(je, ii) | 0, ie = ie + Math.imul(je, pi) | 0, ie = ie + Math.imul(lt, ii) | 0, Se = Se + Math.imul(lt, pi) | 0, ge = ge + Math.imul(me, di) | 0, ie = ie + Math.imul(me, ji) | 0, ie = ie + Math.imul(De, di) | 0, Se = Se + Math.imul(De, ji) | 0, ge = ge + Math.imul(Ae, wi) | 0, ie = ie + Math.imul(Ae, On) | 0, ie = ie + Math.imul(Be, wi) | 0, Se = Se + Math.imul(Be, On) | 0;
+                var $i = (Le + ge | 0) + ((ie & 8191) << 13) | 0;
+                Le = (Se + (ie >>> 13) | 0) + ($i >>> 26) | 0, $i &= 67108863, ge = Math.imul(mt, Br), ie = Math.imul(mt, Vr), ie = ie + Math.imul(er, Br) | 0, Se = Math.imul(er, Vr), ge = ge + Math.imul(Gt, Ge) | 0, ie = ie + Math.imul(Gt, Je) | 0, ie = ie + Math.imul(_t, Ge) | 0, Se = Se + Math.imul(_t, Je) | 0, ge = ge + Math.imul($e, tt) | 0, ie = ie + Math.imul($e, xt) | 0, ie = ie + Math.imul(St, tt) | 0, Se = Se + Math.imul(St, xt) | 0, ge = ge + Math.imul(sr, xe) | 0, ie = ie + Math.imul(sr, ke) | 0, ie = ie + Math.imul(Tr, xe) | 0, Se = Se + Math.imul(Tr, ke) | 0, ge = ge + Math.imul(Wt, ir) | 0, ie = ie + Math.imul(Wt, ar) | 0, ie = ie + Math.imul(Nt, ir) | 0, Se = Se + Math.imul(Nt, ar) | 0, ge = ge + Math.imul(Vt, ii) | 0, ie = ie + Math.imul(Vt, pi) | 0, ie = ie + Math.imul(ot, ii) | 0, Se = Se + Math.imul(ot, pi) | 0, ge = ge + Math.imul(je, di) | 0, ie = ie + Math.imul(je, ji) | 0, ie = ie + Math.imul(lt, di) | 0, Se = Se + Math.imul(lt, ji) | 0, ge = ge + Math.imul(me, wi) | 0, ie = ie + Math.imul(me, On) | 0, ie = ie + Math.imul(De, wi) | 0, Se = Se + Math.imul(De, On) | 0, ge = ge + Math.imul(Ae, Fn) | 0, ie = ie + Math.imul(Ae, ra) | 0, ie = ie + Math.imul(Be, Fn) | 0, Se = Se + Math.imul(Be, ra) | 0;
+                var tn = (Le + ge | 0) + ((ie & 8191) << 13) | 0;
+                Le = (Se + (ie >>> 13) | 0) + (tn >>> 26) | 0, tn &= 67108863, ge = Math.imul(wr, Br), ie = Math.imul(wr, Vr), ie = ie + Math.imul(Lr, Br) | 0, Se = Math.imul(Lr, Vr), ge = ge + Math.imul(mt, Ge) | 0, ie = ie + Math.imul(mt, Je) | 0, ie = ie + Math.imul(er, Ge) | 0, Se = Se + Math.imul(er, Je) | 0, ge = ge + Math.imul(Gt, tt) | 0, ie = ie + Math.imul(Gt, xt) | 0, ie = ie + Math.imul(_t, tt) | 0, Se = Se + Math.imul(_t, xt) | 0, ge = ge + Math.imul($e, xe) | 0, ie = ie + Math.imul($e, ke) | 0, ie = ie + Math.imul(St, xe) | 0, Se = Se + Math.imul(St, ke) | 0, ge = ge + Math.imul(sr, ir) | 0, ie = ie + Math.imul(sr, ar) | 0, ie = ie + Math.imul(Tr, ir) | 0, Se = Se + Math.imul(Tr, ar) | 0, ge = ge + Math.imul(Wt, ii) | 0, ie = ie + Math.imul(Wt, pi) | 0, ie = ie + Math.imul(Nt, ii) | 0, Se = Se + Math.imul(Nt, pi) | 0, ge = ge + Math.imul(Vt, di) | 0, ie = ie + Math.imul(Vt, ji) | 0, ie = ie + Math.imul(ot, di) | 0, Se = Se + Math.imul(ot, ji) | 0, ge = ge + Math.imul(je, wi) | 0, ie = ie + Math.imul(je, On) | 0, ie = ie + Math.imul(lt, wi) | 0, Se = Se + Math.imul(lt, On) | 0, ge = ge + Math.imul(me, Fn) | 0, ie = ie + Math.imul(me, ra) | 0, ie = ie + Math.imul(De, Fn) | 0, Se = Se + Math.imul(De, ra) | 0, ge = ge + Math.imul(Ae, Ut) | 0, ie = ie + Math.imul(Ae, wt) | 0, ie = ie + Math.imul(Be, Ut) | 0, Se = Se + Math.imul(Be, wt) | 0;
+                var fn = (Le + ge | 0) + ((ie & 8191) << 13) | 0;
+                Le = (Se + (ie >>> 13) | 0) + (fn >>> 26) | 0, fn &= 67108863, ge = Math.imul(wr, Ge), ie = Math.imul(wr, Je), ie = ie + Math.imul(Lr, Ge) | 0, Se = Math.imul(Lr, Je), ge = ge + Math.imul(mt, tt) | 0, ie = ie + Math.imul(mt, xt) | 0, ie = ie + Math.imul(er, tt) | 0, Se = Se + Math.imul(er, xt) | 0, ge = ge + Math.imul(Gt, xe) | 0, ie = ie + Math.imul(Gt, ke) | 0, ie = ie + Math.imul(_t, xe) | 0, Se = Se + Math.imul(_t, ke) | 0, ge = ge + Math.imul($e, ir) | 0, ie = ie + Math.imul($e, ar) | 0, ie = ie + Math.imul(St, ir) | 0, Se = Se + Math.imul(St, ar) | 0, ge = ge + Math.imul(sr, ii) | 0, ie = ie + Math.imul(sr, pi) | 0, ie = ie + Math.imul(Tr, ii) | 0, Se = Se + Math.imul(Tr, pi) | 0, ge = ge + Math.imul(Wt, di) | 0, ie = ie + Math.imul(Wt, ji) | 0, ie = ie + Math.imul(Nt, di) | 0, Se = Se + Math.imul(Nt, ji) | 0, ge = ge + Math.imul(Vt, wi) | 0, ie = ie + Math.imul(Vt, On) | 0, ie = ie + Math.imul(ot, wi) | 0, Se = Se + Math.imul(ot, On) | 0, ge = ge + Math.imul(je, Fn) | 0, ie = ie + Math.imul(je, ra) | 0, ie = ie + Math.imul(lt, Fn) | 0, Se = Se + Math.imul(lt, ra) | 0, ge = ge + Math.imul(me, Ut) | 0, ie = ie + Math.imul(me, wt) | 0, ie = ie + Math.imul(De, Ut) | 0, Se = Se + Math.imul(De, wt) | 0;
+                var yn = (Le + ge | 0) + ((ie & 8191) << 13) | 0;
+                Le = (Se + (ie >>> 13) | 0) + (yn >>> 26) | 0, yn &= 67108863, ge = Math.imul(wr, tt), ie = Math.imul(wr, xt), ie = ie + Math.imul(Lr, tt) | 0, Se = Math.imul(Lr, xt), ge = ge + Math.imul(mt, xe) | 0, ie = ie + Math.imul(mt, ke) | 0, ie = ie + Math.imul(er, xe) | 0, Se = Se + Math.imul(er, ke) | 0, ge = ge + Math.imul(Gt, ir) | 0, ie = ie + Math.imul(Gt, ar) | 0, ie = ie + Math.imul(_t, ir) | 0, Se = Se + Math.imul(_t, ar) | 0, ge = ge + Math.imul($e, ii) | 0, ie = ie + Math.imul($e, pi) | 0, ie = ie + Math.imul(St, ii) | 0, Se = Se + Math.imul(St, pi) | 0, ge = ge + Math.imul(sr, di) | 0, ie = ie + Math.imul(sr, ji) | 0, ie = ie + Math.imul(Tr, di) | 0, Se = Se + Math.imul(Tr, ji) | 0, ge = ge + Math.imul(Wt, wi) | 0, ie = ie + Math.imul(Wt, On) | 0, ie = ie + Math.imul(Nt, wi) | 0, Se = Se + Math.imul(Nt, On) | 0, ge = ge + Math.imul(Vt, Fn) | 0, ie = ie + Math.imul(Vt, ra) | 0, ie = ie + Math.imul(ot, Fn) | 0, Se = Se + Math.imul(ot, ra) | 0, ge = ge + Math.imul(je, Ut) | 0, ie = ie + Math.imul(je, wt) | 0, ie = ie + Math.imul(lt, Ut) | 0, Se = Se + Math.imul(lt, wt) | 0;
+                var Sn = (Le + ge | 0) + ((ie & 8191) << 13) | 0;
+                Le = (Se + (ie >>> 13) | 0) + (Sn >>> 26) | 0, Sn &= 67108863, ge = Math.imul(wr, xe), ie = Math.imul(wr, ke), ie = ie + Math.imul(Lr, xe) | 0, Se = Math.imul(Lr, ke), ge = ge + Math.imul(mt, ir) | 0, ie = ie + Math.imul(mt, ar) | 0, ie = ie + Math.imul(er, ir) | 0, Se = Se + Math.imul(er, ar) | 0, ge = ge + Math.imul(Gt, ii) | 0, ie = ie + Math.imul(Gt, pi) | 0, ie = ie + Math.imul(_t, ii) | 0, Se = Se + Math.imul(_t, pi) | 0, ge = ge + Math.imul($e, di) | 0, ie = ie + Math.imul($e, ji) | 0, ie = ie + Math.imul(St, di) | 0, Se = Se + Math.imul(St, ji) | 0, ge = ge + Math.imul(sr, wi) | 0, ie = ie + Math.imul(sr, On) | 0, ie = ie + Math.imul(Tr, wi) | 0, Se = Se + Math.imul(Tr, On) | 0, ge = ge + Math.imul(Wt, Fn) | 0, ie = ie + Math.imul(Wt, ra) | 0, ie = ie + Math.imul(Nt, Fn) | 0, Se = Se + Math.imul(Nt, ra) | 0, ge = ge + Math.imul(Vt, Ut) | 0, ie = ie + Math.imul(Vt, wt) | 0, ie = ie + Math.imul(ot, Ut) | 0, Se = Se + Math.imul(ot, wt) | 0;
+                var Ba = (Le + ge | 0) + ((ie & 8191) << 13) | 0;
+                Le = (Se + (ie >>> 13) | 0) + (Ba >>> 26) | 0, Ba &= 67108863, ge = Math.imul(wr, ir), ie = Math.imul(wr, ar), ie = ie + Math.imul(Lr, ir) | 0, Se = Math.imul(Lr, ar), ge = ge + Math.imul(mt, ii) | 0, ie = ie + Math.imul(mt, pi) | 0, ie = ie + Math.imul(er, ii) | 0, Se = Se + Math.imul(er, pi) | 0, ge = ge + Math.imul(Gt, di) | 0, ie = ie + Math.imul(Gt, ji) | 0, ie = ie + Math.imul(_t, di) | 0, Se = Se + Math.imul(_t, ji) | 0, ge = ge + Math.imul($e, wi) | 0, ie = ie + Math.imul($e, On) | 0, ie = ie + Math.imul(St, wi) | 0, Se = Se + Math.imul(St, On) | 0, ge = ge + Math.imul(sr, Fn) | 0, ie = ie + Math.imul(sr, ra) | 0, ie = ie + Math.imul(Tr, Fn) | 0, Se = Se + Math.imul(Tr, ra) | 0, ge = ge + Math.imul(Wt, Ut) | 0, ie = ie + Math.imul(Wt, wt) | 0, ie = ie + Math.imul(Nt, Ut) | 0, Se = Se + Math.imul(Nt, wt) | 0;
+                var ua = (Le + ge | 0) + ((ie & 8191) << 13) | 0;
+                Le = (Se + (ie >>> 13) | 0) + (ua >>> 26) | 0, ua &= 67108863, ge = Math.imul(wr, ii), ie = Math.imul(wr, pi), ie = ie + Math.imul(Lr, ii) | 0, Se = Math.imul(Lr, pi), ge = ge + Math.imul(mt, di) | 0, ie = ie + Math.imul(mt, ji) | 0, ie = ie + Math.imul(er, di) | 0, Se = Se + Math.imul(er, ji) | 0, ge = ge + Math.imul(Gt, wi) | 0, ie = ie + Math.imul(Gt, On) | 0, ie = ie + Math.imul(_t, wi) | 0, Se = Se + Math.imul(_t, On) | 0, ge = ge + Math.imul($e, Fn) | 0, ie = ie + Math.imul($e, ra) | 0, ie = ie + Math.imul(St, Fn) | 0, Se = Se + Math.imul(St, ra) | 0, ge = ge + Math.imul(sr, Ut) | 0, ie = ie + Math.imul(sr, wt) | 0, ie = ie + Math.imul(Tr, Ut) | 0, Se = Se + Math.imul(Tr, wt) | 0;
+                var ma = (Le + ge | 0) + ((ie & 8191) << 13) | 0;
+                Le = (Se + (ie >>> 13) | 0) + (ma >>> 26) | 0, ma &= 67108863, ge = Math.imul(wr, di), ie = Math.imul(wr, ji), ie = ie + Math.imul(Lr, di) | 0, Se = Math.imul(Lr, ji), ge = ge + Math.imul(mt, wi) | 0, ie = ie + Math.imul(mt, On) | 0, ie = ie + Math.imul(er, wi) | 0, Se = Se + Math.imul(er, On) | 0, ge = ge + Math.imul(Gt, Fn) | 0, ie = ie + Math.imul(Gt, ra) | 0, ie = ie + Math.imul(_t, Fn) | 0, Se = Se + Math.imul(_t, ra) | 0, ge = ge + Math.imul($e, Ut) | 0, ie = ie + Math.imul($e, wt) | 0, ie = ie + Math.imul(St, Ut) | 0, Se = Se + Math.imul(St, wt) | 0;
+                var Wa = (Le + ge | 0) + ((ie & 8191) << 13) | 0;
+                Le = (Se + (ie >>> 13) | 0) + (Wa >>> 26) | 0, Wa &= 67108863, ge = Math.imul(wr, wi), ie = Math.imul(wr, On), ie = ie + Math.imul(Lr, wi) | 0, Se = Math.imul(Lr, On), ge = ge + Math.imul(mt, Fn) | 0, ie = ie + Math.imul(mt, ra) | 0, ie = ie + Math.imul(er, Fn) | 0, Se = Se + Math.imul(er, ra) | 0, ge = ge + Math.imul(Gt, Ut) | 0, ie = ie + Math.imul(Gt, wt) | 0, ie = ie + Math.imul(_t, Ut) | 0, Se = Se + Math.imul(_t, wt) | 0;
+                var Fa = (Le + ge | 0) + ((ie & 8191) << 13) | 0;
+                Le = (Se + (ie >>> 13) | 0) + (Fa >>> 26) | 0, Fa &= 67108863, ge = Math.imul(wr, Fn), ie = Math.imul(wr, ra), ie = ie + Math.imul(Lr, Fn) | 0, Se = Math.imul(Lr, ra), ge = ge + Math.imul(mt, Ut) | 0, ie = ie + Math.imul(mt, wt) | 0, ie = ie + Math.imul(er, Ut) | 0, Se = Se + Math.imul(er, wt) | 0;
+                var Xo = (Le + ge | 0) + ((ie & 8191) << 13) | 0;
+                Le = (Se + (ie >>> 13) | 0) + (Xo >>> 26) | 0, Xo &= 67108863, ge = Math.imul(wr, Ut), ie = Math.imul(wr, wt), ie = ie + Math.imul(Lr, Ut) | 0, Se = Math.imul(Lr, wt);
+                var da = (Le + ge | 0) + ((ie & 8191) << 13) | 0;
+                return Le = (Se + (ie >>> 13) | 0) + (da >>> 26) | 0, da &= 67108863, Ce[0] = rr, Ce[1] = nr, Ce[2] = Er, Ce[3] = Xr, Ce[4] = ri, Ce[5] = Qr, Ce[6] = Oi, Ce[7] = $i, Ce[8] = tn, Ce[9] = fn, Ce[10] = yn, Ce[11] = Sn, Ce[12] = Ba, Ce[13] = ua, Ce[14] = ma, Ce[15] = Wa, Ce[16] = Fa, Ce[17] = Xo, Ce[18] = da, Le !== 0 && (Ce[19] = Le, re.length++), re;
+              };
+              Math.imul || (L = T);
+              function x(j, N, H) {
+                H.negative = N.negative ^ j.negative, H.length = j.length + N.length;
+                for (var re = 0, oe = 0, _e = 0; _e < H.length - 1; _e++) {
+                  var Ce = oe;
+                  oe = 0;
+                  for (var Le = re & 67108863, ge = Math.min(_e, N.length - 1), ie = Math.max(0, _e - j.length + 1); ie <= ge; ie++) {
+                    var Se = _e - ie, Ee = j.words[Se] | 0, Ae = N.words[ie] | 0, Be = Ee * Ae, Pe = Be & 67108863;
+                    Ce = Ce + (Be / 67108864 | 0) | 0, Pe = Pe + Le | 0, Le = Pe & 67108863, Ce = Ce + (Pe >>> 26) | 0, oe += Ce >>> 26, Ce &= 67108863;
+                  }
+                  H.words[_e] = Le, re = Ce, Ce = oe;
+                }
+                return re !== 0 ? H.words[_e] = re : H.length--, H.strip();
+              }
+              function C(j, N, H) {
+                var re = new M();
+                return re.mulp(j, N, H);
+              }
+              f.prototype.mulTo = function(N, H) {
+                var re, oe = this.length + N.length;
+                return this.length === 10 && N.length === 10 ? re = L(this, N, H) : oe < 63 ? re = T(this, N, H) : oe < 1024 ? re = x(this, N, H) : re = C(this, N, H), re;
+              };
+              function M(j, N) {
+                this.x = j, this.y = N;
+              }
+              M.prototype.makeRBT = function(N) {
+                for (var H = new Array(N), re = f.prototype._countBits(N) - 1, oe = 0; oe < N; oe++) H[oe] = this.revBin(oe, re, N);
+                return H;
+              }, M.prototype.revBin = function(N, H, re) {
+                if (N === 0 || N === re - 1) return N;
+                for (var oe = 0, _e = 0; _e < H; _e++) oe |= (N & 1) << H - _e - 1, N >>= 1;
+                return oe;
+              }, M.prototype.permute = function(N, H, re, oe, _e, Ce) {
+                for (var Le = 0; Le < Ce; Le++) oe[Le] = H[N[Le]], _e[Le] = re[N[Le]];
+              }, M.prototype.transform = function(N, H, re, oe, _e, Ce) {
+                this.permute(Ce, N, H, re, oe, _e);
+                for (var Le = 1; Le < _e; Le <<= 1) for (var ge = Le << 1, ie = Math.cos(2 * Math.PI / ge), Se = Math.sin(2 * Math.PI / ge), Ee = 0; Ee < _e; Ee += ge) for (var Ae = ie, Be = Se, Pe = 0; Pe < Le; Pe++) {
+                  var me = re[Ee + Pe], De = oe[Ee + Pe], ce = re[Ee + Pe + Le], je = oe[Ee + Pe + Le], lt = Ae * ce - Be * je;
+                  je = Ae * je + Be * ce, ce = lt, re[Ee + Pe] = me + ce, oe[Ee + Pe] = De + je, re[Ee + Pe + Le] = me - ce, oe[Ee + Pe + Le] = De - je, Pe !== ge && (lt = ie * Ae - Se * Be, Be = ie * Be + Se * Ae, Ae = lt);
+                }
+              }, M.prototype.guessLen13b = function(N, H) {
+                var re = Math.max(H, N) | 1, oe = re & 1, _e = 0;
+                for (re = re / 2 | 0; re; re = re >>> 1) _e++;
+                return 1 << _e + 1 + oe;
+              }, M.prototype.conjugate = function(N, H, re) {
+                if (!(re <= 1)) for (var oe = 0; oe < re / 2; oe++) {
+                  var _e = N[oe];
+                  N[oe] = N[re - oe - 1], N[re - oe - 1] = _e, _e = H[oe], H[oe] = -H[re - oe - 1], H[re - oe - 1] = -_e;
+                }
+              }, M.prototype.normalize13b = function(N, H) {
+                for (var re = 0, oe = 0; oe < H / 2; oe++) {
+                  var _e = Math.round(N[2 * oe + 1] / H) * 8192 + Math.round(N[2 * oe] / H) + re;
+                  N[oe] = _e & 67108863, _e < 67108864 ? re = 0 : re = _e / 67108864 | 0;
+                }
+                return N;
+              }, M.prototype.convert13b = function(N, H, re, oe) {
+                for (var _e = 0, Ce = 0; Ce < H; Ce++) _e = _e + (N[Ce] | 0), re[2 * Ce] = _e & 8191, _e = _e >>> 13, re[2 * Ce + 1] = _e & 8191, _e = _e >>> 13;
+                for (Ce = 2 * H; Ce < oe; ++Ce) re[Ce] = 0;
+                u(_e === 0), u((_e & -8192) === 0);
+              }, M.prototype.stub = function(N) {
+                for (var H = new Array(N), re = 0; re < N; re++) H[re] = 0;
+                return H;
+              }, M.prototype.mulp = function(N, H, re) {
+                var oe = 2 * this.guessLen13b(N.length, H.length), _e = this.makeRBT(oe), Ce = this.stub(oe), Le = new Array(oe), ge = new Array(oe), ie = new Array(oe), Se = new Array(oe), Ee = new Array(oe), Ae = new Array(oe), Be = re.words;
+                Be.length = oe, this.convert13b(N.words, N.length, Le, oe), this.convert13b(H.words, H.length, Se, oe), this.transform(Le, Ce, ge, ie, oe, _e), this.transform(Se, Ce, Ee, Ae, oe, _e);
+                for (var Pe = 0; Pe < oe; Pe++) {
+                  var me = ge[Pe] * Ee[Pe] - ie[Pe] * Ae[Pe];
+                  ie[Pe] = ge[Pe] * Ae[Pe] + ie[Pe] * Ee[Pe], ge[Pe] = me;
+                }
+                return this.conjugate(ge, ie, oe), this.transform(ge, ie, Be, Ce, oe, _e), this.conjugate(Be, Ce, oe), this.normalize13b(Be, oe), re.negative = N.negative ^ H.negative, re.length = N.length + H.length, re.strip();
+              }, f.prototype.mul = function(N) {
+                var H = new f(null);
+                return H.words = new Array(this.length + N.length), this.mulTo(N, H);
+              }, f.prototype.mulf = function(N) {
+                var H = new f(null);
+                return H.words = new Array(this.length + N.length), C(this, N, H);
+              }, f.prototype.imul = function(N) {
+                return this.clone().mulTo(N, this);
+              }, f.prototype.imuln = function(N) {
+                u(typeof N == "number"), u(N < 67108864);
+                for (var H = 0, re = 0; re < this.length; re++) {
+                  var oe = (this.words[re] | 0) * N, _e = (oe & 67108863) + (H & 67108863);
+                  H >>= 26, H += oe / 67108864 | 0, H += _e >>> 26, this.words[re] = _e & 67108863;
+                }
+                return H !== 0 && (this.words[re] = H, this.length++), this;
+              }, f.prototype.muln = function(N) {
+                return this.clone().imuln(N);
+              }, f.prototype.sqr = function() {
+                return this.mul(this);
+              }, f.prototype.isqr = function() {
+                return this.imul(this.clone());
+              }, f.prototype.pow = function(N) {
+                var H = E(N);
+                if (H.length === 0) return new f(1);
+                for (var re = this, oe = 0; oe < H.length && H[oe] === 0; oe++, re = re.sqr()) ;
+                if (++oe < H.length) for (var _e = re.sqr(); oe < H.length; oe++, _e = _e.sqr()) H[oe] !== 0 && (re = re.mul(_e));
+                return re;
+              }, f.prototype.iushln = function(N) {
+                u(typeof N == "number" && N >= 0);
+                var H = N % 26, re = (N - H) / 26, oe = 67108863 >>> 26 - H << 26 - H, _e;
+                if (H !== 0) {
+                  var Ce = 0;
+                  for (_e = 0; _e < this.length; _e++) {
+                    var Le = this.words[_e] & oe, ge = (this.words[_e] | 0) - Le << H;
+                    this.words[_e] = ge | Ce, Ce = Le >>> 26 - H;
+                  }
+                  Ce && (this.words[_e] = Ce, this.length++);
+                }
+                if (re !== 0) {
+                  for (_e = this.length - 1; _e >= 0; _e--) this.words[_e + re] = this.words[_e];
+                  for (_e = 0; _e < re; _e++) this.words[_e] = 0;
+                  this.length += re;
+                }
+                return this.strip();
+              }, f.prototype.ishln = function(N) {
+                return u(this.negative === 0), this.iushln(N);
+              }, f.prototype.iushrn = function(N, H, re) {
+                u(typeof N == "number" && N >= 0);
+                var oe;
+                H ? oe = (H - H % 26) / 26 : oe = 0;
+                var _e = N % 26, Ce = Math.min((N - _e) / 26, this.length), Le = 67108863 ^ 67108863 >>> _e << _e, ge = re;
+                if (oe -= Ce, oe = Math.max(0, oe), ge) {
+                  for (var ie = 0; ie < Ce; ie++) ge.words[ie] = this.words[ie];
+                  ge.length = Ce;
+                }
+                if (Ce !== 0) if (this.length > Ce) for (this.length -= Ce, ie = 0; ie < this.length; ie++) this.words[ie] = this.words[ie + Ce];
+                else this.words[0] = 0, this.length = 1;
+                var Se = 0;
+                for (ie = this.length - 1; ie >= 0 && (Se !== 0 || ie >= oe); ie--) {
+                  var Ee = this.words[ie] | 0;
+                  this.words[ie] = Se << 26 - _e | Ee >>> _e, Se = Ee & Le;
+                }
+                return ge && Se !== 0 && (ge.words[ge.length++] = Se), this.length === 0 && (this.words[0] = 0, this.length = 1), this.strip();
+              }, f.prototype.ishrn = function(N, H, re) {
+                return u(this.negative === 0), this.iushrn(N, H, re);
+              }, f.prototype.shln = function(N) {
+                return this.clone().ishln(N);
+              }, f.prototype.ushln = function(N) {
+                return this.clone().iushln(N);
+              }, f.prototype.shrn = function(N) {
+                return this.clone().ishrn(N);
+              }, f.prototype.ushrn = function(N) {
+                return this.clone().iushrn(N);
+              }, f.prototype.testn = function(N) {
+                u(typeof N == "number" && N >= 0);
+                var H = N % 26, re = (N - H) / 26, oe = 1 << H;
+                if (this.length <= re) return false;
+                var _e = this.words[re];
+                return !!(_e & oe);
+              }, f.prototype.imaskn = function(N) {
+                u(typeof N == "number" && N >= 0);
+                var H = N % 26, re = (N - H) / 26;
+                if (u(this.negative === 0, "imaskn works only with positive numbers"), this.length <= re) return this;
+                if (H !== 0 && re++, this.length = Math.min(re, this.length), H !== 0) {
+                  var oe = 67108863 ^ 67108863 >>> H << H;
+                  this.words[this.length - 1] &= oe;
+                }
+                return this.strip();
+              }, f.prototype.maskn = function(N) {
+                return this.clone().imaskn(N);
+              }, f.prototype.iaddn = function(N) {
+                return u(typeof N == "number"), u(N < 67108864), N < 0 ? this.isubn(-N) : this.negative !== 0 ? this.length === 1 && (this.words[0] | 0) < N ? (this.words[0] = N - (this.words[0] | 0), this.negative = 0, this) : (this.negative = 0, this.isubn(N), this.negative = 1, this) : this._iaddn(N);
+              }, f.prototype._iaddn = function(N) {
+                this.words[0] += N;
+                for (var H = 0; H < this.length && this.words[H] >= 67108864; H++) this.words[H] -= 67108864, H === this.length - 1 ? this.words[H + 1] = 1 : this.words[H + 1]++;
+                return this.length = Math.max(this.length, H + 1), this;
+              }, f.prototype.isubn = function(N) {
+                if (u(typeof N == "number"), u(N < 67108864), N < 0) return this.iaddn(-N);
+                if (this.negative !== 0) return this.negative = 0, this.iaddn(N), this.negative = 1, this;
+                if (this.words[0] -= N, this.length === 1 && this.words[0] < 0) this.words[0] = -this.words[0], this.negative = 1;
+                else for (var H = 0; H < this.length && this.words[H] < 0; H++) this.words[H] += 67108864, this.words[H + 1] -= 1;
+                return this.strip();
+              }, f.prototype.addn = function(N) {
+                return this.clone().iaddn(N);
+              }, f.prototype.subn = function(N) {
+                return this.clone().isubn(N);
+              }, f.prototype.iabs = function() {
+                return this.negative = 0, this;
+              }, f.prototype.abs = function() {
+                return this.clone().iabs();
+              }, f.prototype._ishlnsubmul = function(N, H, re) {
+                var oe = N.length + re, _e;
+                this._expand(oe);
+                var Ce, Le = 0;
+                for (_e = 0; _e < N.length; _e++) {
+                  Ce = (this.words[_e + re] | 0) + Le;
+                  var ge = (N.words[_e] | 0) * H;
+                  Ce -= ge & 67108863, Le = (Ce >> 26) - (ge / 67108864 | 0), this.words[_e + re] = Ce & 67108863;
+                }
+                for (; _e < this.length - re; _e++) Ce = (this.words[_e + re] | 0) + Le, Le = Ce >> 26, this.words[_e + re] = Ce & 67108863;
+                if (Le === 0) return this.strip();
+                for (u(Le === -1), Le = 0, _e = 0; _e < this.length; _e++) Ce = -(this.words[_e] | 0) + Le, Le = Ce >> 26, this.words[_e] = Ce & 67108863;
+                return this.negative = 1, this.strip();
+              }, f.prototype._wordDiv = function(N, H) {
+                var re = this.length - N.length, oe = this.clone(), _e = N, Ce = _e.words[_e.length - 1] | 0, Le = this._countBits(Ce);
+                re = 26 - Le, re !== 0 && (_e = _e.ushln(re), oe.iushln(re), Ce = _e.words[_e.length - 1] | 0);
+                var ge = oe.length - _e.length, ie;
+                if (H !== "mod") {
+                  ie = new f(null), ie.length = ge + 1, ie.words = new Array(ie.length);
+                  for (var Se = 0; Se < ie.length; Se++) ie.words[Se] = 0;
+                }
+                var Ee = oe.clone()._ishlnsubmul(_e, 1, ge);
+                Ee.negative === 0 && (oe = Ee, ie && (ie.words[ge] = 1));
+                for (var Ae = ge - 1; Ae >= 0; Ae--) {
+                  var Be = (oe.words[_e.length + Ae] | 0) * 67108864 + (oe.words[_e.length + Ae - 1] | 0);
+                  for (Be = Math.min(Be / Ce | 0, 67108863), oe._ishlnsubmul(_e, Be, Ae); oe.negative !== 0; ) Be--, oe.negative = 0, oe._ishlnsubmul(_e, 1, Ae), oe.isZero() || (oe.negative ^= 1);
+                  ie && (ie.words[Ae] = Be);
+                }
+                return ie && ie.strip(), oe.strip(), H !== "div" && re !== 0 && oe.iushrn(re), { div: ie || null, mod: oe };
+              }, f.prototype.divmod = function(N, H, re) {
+                if (u(!N.isZero()), this.isZero()) return { div: new f(0), mod: new f(0) };
+                var oe, _e, Ce;
+                return this.negative !== 0 && N.negative === 0 ? (Ce = this.neg().divmod(N, H), H !== "mod" && (oe = Ce.div.neg()), H !== "div" && (_e = Ce.mod.neg(), re && _e.negative !== 0 && _e.iadd(N)), { div: oe, mod: _e }) : this.negative === 0 && N.negative !== 0 ? (Ce = this.divmod(N.neg(), H), H !== "mod" && (oe = Ce.div.neg()), { div: oe, mod: Ce.mod }) : (this.negative & N.negative) !== 0 ? (Ce = this.neg().divmod(N.neg(), H), H !== "div" && (_e = Ce.mod.neg(), re && _e.negative !== 0 && _e.isub(N)), { div: Ce.div, mod: _e }) : N.length > this.length || this.cmp(N) < 0 ? { div: new f(0), mod: this } : N.length === 1 ? H === "div" ? { div: this.divn(N.words[0]), mod: null } : H === "mod" ? { div: null, mod: new f(this.modn(N.words[0])) } : { div: this.divn(N.words[0]), mod: new f(this.modn(N.words[0])) } : this._wordDiv(N, H);
+              }, f.prototype.div = function(N) {
+                return this.divmod(N, "div", false).div;
+              }, f.prototype.mod = function(N) {
+                return this.divmod(N, "mod", false).mod;
+              }, f.prototype.umod = function(N) {
+                return this.divmod(N, "mod", true).mod;
+              }, f.prototype.divRound = function(N) {
+                var H = this.divmod(N);
+                if (H.mod.isZero()) return H.div;
+                var re = H.div.negative !== 0 ? H.mod.isub(N) : H.mod, oe = N.ushrn(1), _e = N.andln(1), Ce = re.cmp(oe);
+                return Ce < 0 || _e === 1 && Ce === 0 ? H.div : H.div.negative !== 0 ? H.div.isubn(1) : H.div.iaddn(1);
+              }, f.prototype.modn = function(N) {
+                u(N <= 67108863);
+                for (var H = (1 << 26) % N, re = 0, oe = this.length - 1; oe >= 0; oe--) re = (H * re + (this.words[oe] | 0)) % N;
+                return re;
+              }, f.prototype.idivn = function(N) {
+                u(N <= 67108863);
+                for (var H = 0, re = this.length - 1; re >= 0; re--) {
+                  var oe = (this.words[re] | 0) + H * 67108864;
+                  this.words[re] = oe / N | 0, H = oe % N;
+                }
+                return this.strip();
+              }, f.prototype.divn = function(N) {
+                return this.clone().idivn(N);
+              }, f.prototype.egcd = function(N) {
+                u(N.negative === 0), u(!N.isZero());
+                var H = this, re = N.clone();
+                H.negative !== 0 ? H = H.umod(N) : H = H.clone();
+                for (var oe = new f(1), _e = new f(0), Ce = new f(0), Le = new f(1), ge = 0; H.isEven() && re.isEven(); ) H.iushrn(1), re.iushrn(1), ++ge;
+                for (var ie = re.clone(), Se = H.clone(); !H.isZero(); ) {
+                  for (var Ee = 0, Ae = 1; (H.words[0] & Ae) === 0 && Ee < 26; ++Ee, Ae <<= 1) ;
+                  if (Ee > 0) for (H.iushrn(Ee); Ee-- > 0; ) (oe.isOdd() || _e.isOdd()) && (oe.iadd(ie), _e.isub(Se)), oe.iushrn(1), _e.iushrn(1);
+                  for (var Be = 0, Pe = 1; (re.words[0] & Pe) === 0 && Be < 26; ++Be, Pe <<= 1) ;
+                  if (Be > 0) for (re.iushrn(Be); Be-- > 0; ) (Ce.isOdd() || Le.isOdd()) && (Ce.iadd(ie), Le.isub(Se)), Ce.iushrn(1), Le.iushrn(1);
+                  H.cmp(re) >= 0 ? (H.isub(re), oe.isub(Ce), _e.isub(Le)) : (re.isub(H), Ce.isub(oe), Le.isub(_e));
+                }
+                return { a: Ce, b: Le, gcd: re.iushln(ge) };
+              }, f.prototype._invmp = function(N) {
+                u(N.negative === 0), u(!N.isZero());
+                var H = this, re = N.clone();
+                H.negative !== 0 ? H = H.umod(N) : H = H.clone();
+                for (var oe = new f(1), _e = new f(0), Ce = re.clone(); H.cmpn(1) > 0 && re.cmpn(1) > 0; ) {
+                  for (var Le = 0, ge = 1; (H.words[0] & ge) === 0 && Le < 26; ++Le, ge <<= 1) ;
+                  if (Le > 0) for (H.iushrn(Le); Le-- > 0; ) oe.isOdd() && oe.iadd(Ce), oe.iushrn(1);
+                  for (var ie = 0, Se = 1; (re.words[0] & Se) === 0 && ie < 26; ++ie, Se <<= 1) ;
+                  if (ie > 0) for (re.iushrn(ie); ie-- > 0; ) _e.isOdd() && _e.iadd(Ce), _e.iushrn(1);
+                  H.cmp(re) >= 0 ? (H.isub(re), oe.isub(_e)) : (re.isub(H), _e.isub(oe));
+                }
+                var Ee;
+                return H.cmpn(1) === 0 ? Ee = oe : Ee = _e, Ee.cmpn(0) < 0 && Ee.iadd(N), Ee;
+              }, f.prototype.gcd = function(N) {
+                if (this.isZero()) return N.abs();
+                if (N.isZero()) return this.abs();
+                var H = this.clone(), re = N.clone();
+                H.negative = 0, re.negative = 0;
+                for (var oe = 0; H.isEven() && re.isEven(); oe++) H.iushrn(1), re.iushrn(1);
+                do {
+                  for (; H.isEven(); ) H.iushrn(1);
+                  for (; re.isEven(); ) re.iushrn(1);
+                  var _e = H.cmp(re);
+                  if (_e < 0) {
+                    var Ce = H;
+                    H = re, re = Ce;
+                  } else if (_e === 0 || re.cmpn(1) === 0) break;
+                  H.isub(re);
+                } while (true);
+                return re.iushln(oe);
+              }, f.prototype.invm = function(N) {
+                return this.egcd(N).a.umod(N);
+              }, f.prototype.isEven = function() {
+                return (this.words[0] & 1) === 0;
+              }, f.prototype.isOdd = function() {
+                return (this.words[0] & 1) === 1;
+              }, f.prototype.andln = function(N) {
+                return this.words[0] & N;
+              }, f.prototype.bincn = function(N) {
+                u(typeof N == "number");
+                var H = N % 26, re = (N - H) / 26, oe = 1 << H;
+                if (this.length <= re) return this._expand(re + 1), this.words[re] |= oe, this;
+                for (var _e = oe, Ce = re; _e !== 0 && Ce < this.length; Ce++) {
+                  var Le = this.words[Ce] | 0;
+                  Le += _e, _e = Le >>> 26, Le &= 67108863, this.words[Ce] = Le;
+                }
+                return _e !== 0 && (this.words[Ce] = _e, this.length++), this;
+              }, f.prototype.isZero = function() {
+                return this.length === 1 && this.words[0] === 0;
+              }, f.prototype.cmpn = function(N) {
+                var H = N < 0;
+                if (this.negative !== 0 && !H) return -1;
+                if (this.negative === 0 && H) return 1;
+                this.strip();
+                var re;
+                if (this.length > 1) re = 1;
+                else {
+                  H && (N = -N), u(N <= 67108863, "Number is too big");
+                  var oe = this.words[0] | 0;
+                  re = oe === N ? 0 : oe < N ? -1 : 1;
+                }
+                return this.negative !== 0 ? -re | 0 : re;
+              }, f.prototype.cmp = function(N) {
+                if (this.negative !== 0 && N.negative === 0) return -1;
+                if (this.negative === 0 && N.negative !== 0) return 1;
+                var H = this.ucmp(N);
+                return this.negative !== 0 ? -H | 0 : H;
+              }, f.prototype.ucmp = function(N) {
+                if (this.length > N.length) return 1;
+                if (this.length < N.length) return -1;
+                for (var H = 0, re = this.length - 1; re >= 0; re--) {
+                  var oe = this.words[re] | 0, _e = N.words[re] | 0;
+                  if (oe !== _e) {
+                    oe < _e ? H = -1 : oe > _e && (H = 1);
+                    break;
+                  }
+                }
+                return H;
+              }, f.prototype.gtn = function(N) {
+                return this.cmpn(N) === 1;
+              }, f.prototype.gt = function(N) {
+                return this.cmp(N) === 1;
+              }, f.prototype.gten = function(N) {
+                return this.cmpn(N) >= 0;
+              }, f.prototype.gte = function(N) {
+                return this.cmp(N) >= 0;
+              }, f.prototype.ltn = function(N) {
+                return this.cmpn(N) === -1;
+              }, f.prototype.lt = function(N) {
+                return this.cmp(N) === -1;
+              }, f.prototype.lten = function(N) {
+                return this.cmpn(N) <= 0;
+              }, f.prototype.lte = function(N) {
+                return this.cmp(N) <= 0;
+              }, f.prototype.eqn = function(N) {
+                return this.cmpn(N) === 0;
+              }, f.prototype.eq = function(N) {
+                return this.cmp(N) === 0;
+              }, f.red = function(N) {
+                return new G(N);
+              }, f.prototype.toRed = function(N) {
+                return u(!this.red, "Already a number in reduction context"), u(this.negative === 0, "red works only with positives"), N.convertTo(this)._forceRed(N);
+              }, f.prototype.fromRed = function() {
+                return u(this.red, "fromRed works only with numbers in reduction context"), this.red.convertFrom(this);
+              }, f.prototype._forceRed = function(N) {
+                return this.red = N, this;
+              }, f.prototype.forceRed = function(N) {
+                return u(!this.red, "Already a number in reduction context"), this._forceRed(N);
+              }, f.prototype.redAdd = function(N) {
+                return u(this.red, "redAdd works only with red numbers"), this.red.add(this, N);
+              }, f.prototype.redIAdd = function(N) {
+                return u(this.red, "redIAdd works only with red numbers"), this.red.iadd(this, N);
+              }, f.prototype.redSub = function(N) {
+                return u(this.red, "redSub works only with red numbers"), this.red.sub(this, N);
+              }, f.prototype.redISub = function(N) {
+                return u(this.red, "redISub works only with red numbers"), this.red.isub(this, N);
+              }, f.prototype.redShl = function(N) {
+                return u(this.red, "redShl works only with red numbers"), this.red.shl(this, N);
+              }, f.prototype.redMul = function(N) {
+                return u(this.red, "redMul works only with red numbers"), this.red._verify2(this, N), this.red.mul(this, N);
+              }, f.prototype.redIMul = function(N) {
+                return u(this.red, "redMul works only with red numbers"), this.red._verify2(this, N), this.red.imul(this, N);
+              }, f.prototype.redSqr = function() {
+                return u(this.red, "redSqr works only with red numbers"), this.red._verify1(this), this.red.sqr(this);
+              }, f.prototype.redISqr = function() {
+                return u(this.red, "redISqr works only with red numbers"), this.red._verify1(this), this.red.isqr(this);
+              }, f.prototype.redSqrt = function() {
+                return u(this.red, "redSqrt works only with red numbers"), this.red._verify1(this), this.red.sqrt(this);
+              }, f.prototype.redInvm = function() {
+                return u(this.red, "redInvm works only with red numbers"), this.red._verify1(this), this.red.invm(this);
+              }, f.prototype.redNeg = function() {
+                return u(this.red, "redNeg works only with red numbers"), this.red._verify1(this), this.red.neg(this);
+              }, f.prototype.redPow = function(N) {
+                return u(this.red && !N.red, "redPow(normalNum)"), this.red._verify1(this), this.red.pow(this, N);
+              };
+              var g = { k256: null, p224: null, p192: null, p25519: null };
+              function P(j, N) {
+                this.name = j, this.p = new f(N, 16), this.n = this.p.bitLength(), this.k = new f(1).iushln(this.n).isub(this.p), this.tmp = this._tmp();
+              }
+              P.prototype._tmp = function() {
+                var N = new f(null);
+                return N.words = new Array(Math.ceil(this.n / 13)), N;
+              }, P.prototype.ireduce = function(N) {
+                var H = N, re;
+                do
+                  this.split(H, this.tmp), H = this.imulK(H), H = H.iadd(this.tmp), re = H.bitLength();
+                while (re > this.n);
+                var oe = re < this.n ? -1 : H.ucmp(this.p);
+                return oe === 0 ? (H.words[0] = 0, H.length = 1) : oe > 0 ? H.isub(this.p) : H.strip !== void 0 ? H.strip() : H._strip(), H;
+              }, P.prototype.split = function(N, H) {
+                N.iushrn(this.n, 0, H);
+              }, P.prototype.imulK = function(N) {
+                return N.imul(this.k);
+              };
+              function A() {
+                P.call(this, "k256", "ffffffff ffffffff ffffffff ffffffff ffffffff ffffffff fffffffe fffffc2f");
+              }
+              c(A, P), A.prototype.split = function(N, H) {
+                for (var re = 4194303, oe = Math.min(N.length, 9), _e = 0; _e < oe; _e++) H.words[_e] = N.words[_e];
+                if (H.length = oe, N.length <= 9) {
+                  N.words[0] = 0, N.length = 1;
+                  return;
+                }
+                var Ce = N.words[9];
+                for (H.words[H.length++] = Ce & re, _e = 10; _e < N.length; _e++) {
+                  var Le = N.words[_e] | 0;
+                  N.words[_e - 10] = (Le & re) << 4 | Ce >>> 22, Ce = Le;
+                }
+                Ce >>>= 22, N.words[_e - 10] = Ce, Ce === 0 && N.length > 10 ? N.length -= 10 : N.length -= 9;
+              }, A.prototype.imulK = function(N) {
+                N.words[N.length] = 0, N.words[N.length + 1] = 0, N.length += 2;
+                for (var H = 0, re = 0; re < N.length; re++) {
+                  var oe = N.words[re] | 0;
+                  H += oe * 977, N.words[re] = H & 67108863, H = oe * 64 + (H / 67108864 | 0);
+                }
+                return N.words[N.length - 1] === 0 && (N.length--, N.words[N.length - 1] === 0 && N.length--), N;
+              };
+              function z() {
+                P.call(this, "p224", "ffffffff ffffffff ffffffff ffffffff 00000000 00000000 00000001");
+              }
+              c(z, P);
+              function O() {
+                P.call(this, "p192", "ffffffff ffffffff ffffffff fffffffe ffffffff ffffffff");
+              }
+              c(O, P);
+              function U() {
+                P.call(this, "25519", "7fffffffffffffff ffffffffffffffff ffffffffffffffff ffffffffffffffed");
+              }
+              c(U, P), U.prototype.imulK = function(N) {
+                for (var H = 0, re = 0; re < N.length; re++) {
+                  var oe = (N.words[re] | 0) * 19 + H, _e = oe & 67108863;
+                  oe >>>= 26, N.words[re] = _e, H = oe;
+                }
+                return H !== 0 && (N.words[N.length++] = H), N;
+              }, f._prime = function(N) {
+                if (g[N]) return g[N];
+                var H;
+                if (N === "k256") H = new A();
+                else if (N === "p224") H = new z();
+                else if (N === "p192") H = new O();
+                else if (N === "p25519") H = new U();
+                else throw new Error("Unknown prime " + N);
+                return g[N] = H, H;
+              };
+              function G(j) {
+                if (typeof j == "string") {
+                  var N = f._prime(j);
+                  this.m = N.p, this.prime = N;
+                } else u(j.gtn(1), "modulus must be greater than 1"), this.m = j, this.prime = null;
+              }
+              G.prototype._verify1 = function(N) {
+                u(N.negative === 0, "red works only with positives"), u(N.red, "red works only with red numbers");
+              }, G.prototype._verify2 = function(N, H) {
+                u((N.negative | H.negative) === 0, "red works only with positives"), u(N.red && N.red === H.red, "red works only with red numbers");
+              }, G.prototype.imod = function(N) {
+                return this.prime ? this.prime.ireduce(N)._forceRed(this) : N.umod(this.m)._forceRed(this);
+              }, G.prototype.neg = function(N) {
+                return N.isZero() ? N.clone() : this.m.sub(N)._forceRed(this);
+              }, G.prototype.add = function(N, H) {
+                this._verify2(N, H);
+                var re = N.add(H);
+                return re.cmp(this.m) >= 0 && re.isub(this.m), re._forceRed(this);
+              }, G.prototype.iadd = function(N, H) {
+                this._verify2(N, H);
+                var re = N.iadd(H);
+                return re.cmp(this.m) >= 0 && re.isub(this.m), re;
+              }, G.prototype.sub = function(N, H) {
+                this._verify2(N, H);
+                var re = N.sub(H);
+                return re.cmpn(0) < 0 && re.iadd(this.m), re._forceRed(this);
+              }, G.prototype.isub = function(N, H) {
+                this._verify2(N, H);
+                var re = N.isub(H);
+                return re.cmpn(0) < 0 && re.iadd(this.m), re;
+              }, G.prototype.shl = function(N, H) {
+                return this._verify1(N), this.imod(N.ushln(H));
+              }, G.prototype.imul = function(N, H) {
+                return this._verify2(N, H), this.imod(N.imul(H));
+              }, G.prototype.mul = function(N, H) {
+                return this._verify2(N, H), this.imod(N.mul(H));
+              }, G.prototype.isqr = function(N) {
+                return this.imul(N, N.clone());
+              }, G.prototype.sqr = function(N) {
+                return this.mul(N, N);
+              }, G.prototype.sqrt = function(N) {
+                if (N.isZero()) return N.clone();
+                var H = this.m.andln(3);
+                if (u(H % 2 === 1), H === 3) {
+                  var re = this.m.add(new f(1)).iushrn(2);
+                  return this.pow(N, re);
+                }
+                for (var oe = this.m.subn(1), _e = 0; !oe.isZero() && oe.andln(1) === 0; ) _e++, oe.iushrn(1);
+                u(!oe.isZero());
+                var Ce = new f(1).toRed(this), Le = Ce.redNeg(), ge = this.m.subn(1).iushrn(1), ie = this.m.bitLength();
+                for (ie = new f(2 * ie * ie).toRed(this); this.pow(ie, ge).cmp(Le) !== 0; ) ie.redIAdd(Le);
+                for (var Se = this.pow(ie, oe), Ee = this.pow(N, oe.addn(1).iushrn(1)), Ae = this.pow(N, oe), Be = _e; Ae.cmp(Ce) !== 0; ) {
+                  for (var Pe = Ae, me = 0; Pe.cmp(Ce) !== 0; me++) Pe = Pe.redSqr();
+                  u(me < Be);
+                  var De = this.pow(Se, new f(1).iushln(Be - me - 1));
+                  Ee = Ee.redMul(De), Se = De.redSqr(), Ae = Ae.redMul(Se), Be = me;
+                }
+                return Ee;
+              }, G.prototype.invm = function(N) {
+                var H = N._invmp(this.m);
+                return H.negative !== 0 ? (H.negative = 0, this.imod(H).redNeg()) : this.imod(H);
+              }, G.prototype.pow = function(N, H) {
+                if (H.isZero()) return new f(1).toRed(this);
+                if (H.cmpn(1) === 0) return N.clone();
+                var re = 4, oe = new Array(1 << re);
+                oe[0] = new f(1).toRed(this), oe[1] = N;
+                for (var _e = 2; _e < oe.length; _e++) oe[_e] = this.mul(oe[_e - 1], N);
+                var Ce = oe[0], Le = 0, ge = 0, ie = H.bitLength() % 26;
+                for (ie === 0 && (ie = 26), _e = H.length - 1; _e >= 0; _e--) {
+                  for (var Se = H.words[_e], Ee = ie - 1; Ee >= 0; Ee--) {
+                    var Ae = Se >> Ee & 1;
+                    if (Ce !== oe[0] && (Ce = this.sqr(Ce)), Ae === 0 && Le === 0) {
+                      ge = 0;
+                      continue;
+                    }
+                    Le <<= 1, Le |= Ae, ge++, !(ge !== re && (_e !== 0 || Ee !== 0)) && (Ce = this.mul(Ce, oe[Le]), ge = 0, Le = 0);
+                  }
+                  ie = 26;
+                }
+                return Ce;
+              }, G.prototype.convertTo = function(N) {
+                var H = N.umod(this.m);
+                return H === N ? H.clone() : H;
+              }, G.prototype.convertFrom = function(N) {
+                var H = N.clone();
+                return H.red = null, H;
+              }, f.mont = function(N) {
+                return new Z(N);
+              };
+              function Z(j) {
+                G.call(this, j), this.shift = this.m.bitLength(), this.shift % 26 !== 0 && (this.shift += 26 - this.shift % 26), this.r = new f(1).iushln(this.shift), this.r2 = this.imod(this.r.sqr()), this.rinv = this.r._invmp(this.m), this.minv = this.rinv.mul(this.r).isubn(1).div(this.m), this.minv = this.minv.umod(this.r), this.minv = this.r.sub(this.minv);
+              }
+              c(Z, G), Z.prototype.convertTo = function(N) {
+                return this.imod(N.ushln(this.shift));
+              }, Z.prototype.convertFrom = function(N) {
+                var H = this.imod(N.mul(this.rinv));
+                return H.red = null, H;
+              }, Z.prototype.imul = function(N, H) {
+                if (N.isZero() || H.isZero()) return N.words[0] = 0, N.length = 1, N;
+                var re = N.imul(H), oe = re.maskn(this.shift).mul(this.minv).imaskn(this.shift).mul(this.m), _e = re.isub(oe).iushrn(this.shift), Ce = _e;
+                return _e.cmp(this.m) >= 0 ? Ce = _e.isub(this.m) : _e.cmpn(0) < 0 && (Ce = _e.iadd(this.m)), Ce._forceRed(this);
+              }, Z.prototype.mul = function(N, H) {
+                if (N.isZero() || H.isZero()) return new f(0)._forceRed(this);
+                var re = N.mul(H), oe = re.maskn(this.shift).mul(this.minv).imaskn(this.shift).mul(this.m), _e = re.isub(oe).iushrn(this.shift), Ce = _e;
+                return _e.cmp(this.m) >= 0 ? Ce = _e.isub(this.m) : _e.cmpn(0) < 0 && (Ce = _e.iadd(this.m)), Ce._forceRed(this);
+              }, Z.prototype.invm = function(N) {
+                var H = this.imod(N._invmp(this.m).mul(this.r2));
+                return H._forceRed(this);
+              };
+            }(i, this);
+          }, 6860: function(i) {
+            i.exports = a;
+            function a(o, s, l) {
+              return o[0] = s[0] - l[0], o[1] = s[1] - l[1], o[2] = s[2] - l[2], o[3] = s[3] - l[3], o;
+            }
+          }, 6864: function(i) {
+            i.exports = a;
+            function a() {
+              var o = new Float32Array(16);
+              return o[0] = 1, o[1] = 0, o[2] = 0, o[3] = 0, o[4] = 0, o[5] = 1, o[6] = 0, o[7] = 0, o[8] = 0, o[9] = 0, o[10] = 1, o[11] = 0, o[12] = 0, o[13] = 0, o[14] = 0, o[15] = 1, o;
+            }
+          }, 6867: function(i, a, o) {
+            i.exports = p;
+            var s = o(1888), l = o(855), u = o(7150);
+            function c(k, E) {
+              for (var T = 0; T < k; ++T) if (!(E[T] <= E[T + k])) return true;
+              return false;
+            }
+            function f(k, E, T, L) {
+              for (var x = 0, C = 0, M = 0, g = k.length; M < g; ++M) {
+                var P = k[M];
+                if (!c(E, P)) {
+                  for (var A = 0; A < 2 * E; ++A) T[x++] = P[A];
+                  L[C++] = M;
+                }
+              }
+              return C;
+            }
+            function h(k, E, T, L) {
+              var x = k.length, C = E.length;
+              if (!(x <= 0 || C <= 0)) {
+                var M = k[0].length >>> 1;
+                if (!(M <= 0)) {
+                  var g, P = s.mallocDouble(2 * M * x), A = s.mallocInt32(x);
+                  if (x = f(k, M, P, A), x > 0) {
+                    if (M === 1 && L) l.init(x), g = l.sweepComplete(M, T, 0, x, P, A, 0, x, P, A);
+                    else {
+                      var z = s.mallocDouble(2 * M * C), O = s.mallocInt32(C);
+                      C = f(E, M, z, O), C > 0 && (l.init(x + C), M === 1 ? g = l.sweepBipartite(M, T, 0, x, P, A, 0, C, z, O) : g = u(M, T, L, x, P, A, C, z, O), s.free(z), s.free(O));
+                    }
+                    s.free(P), s.free(A);
+                  }
+                  return g;
+                }
+              }
+            }
+            var d;
+            function v(k, E) {
+              d.push([k, E]);
+            }
+            function _(k) {
+              return d = [], h(k, k, v, true), d;
+            }
+            function b(k, E) {
+              return d = [], h(k, E, v, false), d;
+            }
+            function p(k, E, T) {
+              switch (arguments.length) {
+                case 1:
+                  return _(k);
+                case 2:
+                  return typeof E == "function" ? h(k, k, E, true) : b(k, E);
+                case 3:
+                  return h(k, E, T, false);
+                default:
+                  throw new Error("box-intersect: Invalid arguments");
+              }
+            }
+          }, 6894: function(i) {
+            i.exports = a;
+            function a(o, s, l, u) {
+              var c = l[1], f = l[2], h = s[1] - c, d = s[2] - f, v = Math.sin(u), _ = Math.cos(u);
+              return o[0] = s[0], o[1] = c + h * _ - d * v, o[2] = f + h * v + d * _, o;
+            }
+          }, 7004: function(i) {
+            i.exports = a;
+            function a(o) {
+              for (var s = o.length, l = o[o.length - 1], u = s, c = s - 2; c >= 0; --c) {
+                var f = l, h = o[c];
+                l = f + h;
+                var d = l - f, v = h - d;
+                v && (o[--u] = l, l = v);
+              }
+              for (var _ = 0, c = u; c < s; ++c) {
+                var f = o[c], h = l;
+                l = f + h;
+                var d = l - f, v = h - d;
+                v && (o[_++] = v);
+              }
+              return o[_++] = l, o.length = _, o;
+            }
+          }, 7056: function(i) {
+            i.exports = a;
+            function a(o, s) {
+              var l = s[0] - o[0], u = s[1] - o[1], c = s[2] - o[2];
+              return Math.sqrt(l * l + u * u + c * c);
+            }
+          }, 7089: function(i) {
+            i.exports = a;
+            function a(o, s, l) {
+              var u = Math.sin(l), c = Math.cos(l), f = s[0], h = s[1], d = s[2], v = s[3], _ = s[4], b = s[5], p = s[6], k = s[7];
+              return s !== o && (o[8] = s[8], o[9] = s[9], o[10] = s[10], o[11] = s[11], o[12] = s[12], o[13] = s[13], o[14] = s[14], o[15] = s[15]), o[0] = f * c + _ * u, o[1] = h * c + b * u, o[2] = d * c + p * u, o[3] = v * c + k * u, o[4] = _ * c - f * u, o[5] = b * c - h * u, o[6] = p * c - d * u, o[7] = k * c - v * u, o;
+            }
+          }, 7150: function(i, a, o) {
+            i.exports = j;
+            var s = o(1888), l = o(8828), u = o(2455), c = u.partial, f = u.full, h = o(855), d = o(3545), v = o(8105), _ = 128, b = 1 << 22, p = 1 << 22, k = v("!(lo>=p0)&&!(p1>=hi)"), E = v("lo===p0"), T = v("lo<p0"), L = v("hi<=p0"), x = v("lo<=p0&&p0<=hi"), C = v("lo<p0&&p0<=hi"), M = 6, g = 2, P = 1024, A = s.mallocInt32(P), z = s.mallocDouble(P);
+            function O(N, H) {
+              var re = 8 * l.log2(H + 1) * (N + 1) | 0, oe = l.nextPow2(M * re);
+              A.length < oe && (s.free(A), A = s.mallocInt32(oe));
+              var _e = l.nextPow2(g * re);
+              z.length < _e && (s.free(z), z = s.mallocDouble(_e));
+            }
+            function U(N, H, re, oe, _e, Ce, Le, ge, ie) {
+              var Se = M * N;
+              A[Se] = H, A[Se + 1] = re, A[Se + 2] = oe, A[Se + 3] = _e, A[Se + 4] = Ce, A[Se + 5] = Le;
+              var Ee = g * N;
+              z[Ee] = ge, z[Ee + 1] = ie;
+            }
+            function G(N, H, re, oe, _e, Ce, Le, ge, ie, Se, Ee) {
+              var Ae = 2 * N, Be = ie * Ae, Pe = Se[Be + H];
+              e: for (var me = _e, De = _e * Ae; me < Ce; ++me, De += Ae) {
+                var ce = Le[De + H], je = Le[De + H + N];
+                if (!(Pe < ce || je < Pe) && !(oe && Pe === ce)) {
+                  for (var lt = ge[me], pt = H + 1; pt < N; ++pt) {
+                    var ce = Le[De + pt], je = Le[De + pt + N], Vt = Se[Be + pt], ot = Se[Be + pt + N];
+                    if (je < Vt || ot < ce) continue e;
+                  }
+                  var ut;
+                  if (oe ? ut = re(Ee, lt) : ut = re(lt, Ee), ut !== void 0) return ut;
+                }
+              }
+            }
+            function Z(N, H, re, oe, _e, Ce, Le, ge, ie, Se) {
+              var Ee = 2 * N, Ae = ge * Ee, Be = ie[Ae + H];
+              e: for (var Pe = oe, me = oe * Ee; Pe < _e; ++Pe, me += Ee) {
+                var De = Le[Pe];
+                if (De !== Se) {
+                  var ce = Ce[me + H], je = Ce[me + H + N];
+                  if (!(Be < ce || je < Be)) {
+                    for (var lt = H + 1; lt < N; ++lt) {
+                      var ce = Ce[me + lt], je = Ce[me + lt + N], pt = ie[Ae + lt], Vt = ie[Ae + lt + N];
+                      if (je < pt || Vt < ce) continue e;
+                    }
+                    var ot = re(De, Se);
+                    if (ot !== void 0) return ot;
+                  }
+                }
+              }
+            }
+            function j(N, H, re, oe, _e, Ce, Le, ge, ie) {
+              O(N, oe + Le);
+              var Se = 0, Ee = 2 * N, Ae;
+              for (U(Se++, 0, 0, oe, 0, Le, re ? 16 : 0, -1 / 0, 1 / 0), re || U(Se++, 0, 0, Le, 0, oe, 1, -1 / 0, 1 / 0); Se > 0; ) {
+                Se -= 1;
+                var Be = Se * M, Pe = A[Be], me = A[Be + 1], De = A[Be + 2], ce = A[Be + 3], je = A[Be + 4], lt = A[Be + 5], pt = Se * g, Vt = z[pt], ot = z[pt + 1], ut = lt & 1, Wt = !!(lt & 16), Nt = _e, $t = Ce, sr = ge, Tr = ie;
+                if (ut && (Nt = ge, $t = ie, sr = _e, Tr = Ce), !(lt & 2 && (De = T(N, Pe, me, De, Nt, $t, ot), me >= De)) && !(lt & 4 && (me = L(N, Pe, me, De, Nt, $t, Vt), me >= De))) {
+                  var fr = De - me, $e = je - ce;
+                  if (Wt) {
+                    if (N * fr * (fr + $e) < p) {
+                      if (Ae = h.scanComplete(N, Pe, H, me, De, Nt, $t, ce, je, sr, Tr), Ae !== void 0) return Ae;
+                      continue;
+                    }
+                  } else if (N * Math.min(fr, $e) < _) {
+                    if (Ae = c(N, Pe, H, ut, me, De, Nt, $t, ce, je, sr, Tr), Ae !== void 0) return Ae;
+                    continue;
+                  } else if (N * fr * $e < b) {
+                    if (Ae = h.scanBipartite(N, Pe, H, ut, me, De, Nt, $t, ce, je, sr, Tr), Ae !== void 0) return Ae;
+                    continue;
+                  }
+                  var St = k(N, Pe, me, De, Nt, $t, Vt, ot);
+                  if (me < St) if (N * (St - me) < _) {
+                    if (Ae = f(N, Pe + 1, H, me, St, Nt, $t, ce, je, sr, Tr), Ae !== void 0) return Ae;
+                  } else if (Pe === N - 2) {
+                    if (ut ? Ae = h.sweepBipartite(N, H, ce, je, sr, Tr, me, St, Nt, $t) : Ae = h.sweepBipartite(N, H, me, St, Nt, $t, ce, je, sr, Tr), Ae !== void 0) return Ae;
+                  } else U(Se++, Pe + 1, me, St, ce, je, ut, -1 / 0, 1 / 0), U(Se++, Pe + 1, ce, je, me, St, ut ^ 1, -1 / 0, 1 / 0);
+                  if (St < De) {
+                    var Qt = d(N, Pe, ce, je, sr, Tr), Gt = sr[Ee * Qt + Pe], _t = E(N, Pe, Qt, je, sr, Tr, Gt);
+                    if (_t < je && U(Se++, Pe, St, De, _t, je, (ut | 4) + (Wt ? 16 : 0), Gt, ot), ce < Qt && U(Se++, Pe, St, De, ce, Qt, (ut | 2) + (Wt ? 16 : 0), Vt, Gt), Qt + 1 === _t) {
+                      if (Wt ? Ae = Z(N, Pe, H, St, De, Nt, $t, Qt, sr, Tr[Qt]) : Ae = G(N, Pe, H, ut, St, De, Nt, $t, Qt, sr, Tr[Qt]), Ae !== void 0) return Ae;
+                    } else if (Qt < _t) {
+                      var It;
+                      if (Wt) {
+                        if (It = x(N, Pe, St, De, Nt, $t, Gt), St < It) {
+                          var mt = E(N, Pe, St, It, Nt, $t, Gt);
+                          if (Pe === N - 2) {
+                            if (St < mt && (Ae = h.sweepComplete(N, H, St, mt, Nt, $t, Qt, _t, sr, Tr), Ae !== void 0) || mt < It && (Ae = h.sweepBipartite(N, H, mt, It, Nt, $t, Qt, _t, sr, Tr), Ae !== void 0)) return Ae;
+                          } else St < mt && U(Se++, Pe + 1, St, mt, Qt, _t, 16, -1 / 0, 1 / 0), mt < It && (U(Se++, Pe + 1, mt, It, Qt, _t, 0, -1 / 0, 1 / 0), U(Se++, Pe + 1, Qt, _t, mt, It, 1, -1 / 0, 1 / 0));
+                        }
+                      } else ut ? It = C(N, Pe, St, De, Nt, $t, Gt) : It = x(N, Pe, St, De, Nt, $t, Gt), St < It && (Pe === N - 2 ? ut ? Ae = h.sweepBipartite(N, H, Qt, _t, sr, Tr, St, It, Nt, $t) : Ae = h.sweepBipartite(N, H, St, It, Nt, $t, Qt, _t, sr, Tr) : (U(Se++, Pe + 1, St, It, Qt, _t, ut, -1 / 0, 1 / 0), U(Se++, Pe + 1, Qt, _t, St, It, ut ^ 1, -1 / 0, 1 / 0)));
+                    }
+                  }
+                }
+              }
+            }
+          }, 7163: function(i) {
+            i.exports = function(s) {
+              return s != null && (a(s) || o(s) || !!s._isBuffer);
+            };
+            function a(s) {
+              return !!s.constructor && typeof s.constructor.isBuffer == "function" && s.constructor.isBuffer(s);
+            }
+            function o(s) {
+              return typeof s.readFloatLE == "function" && typeof s.slice == "function" && a(s.slice(0, 0));
+            }
+          }, 7169: function(i, a, o) {
+            var s = typeof WeakMap == "undefined" ? o(1538) : WeakMap, l = o(2762), u = o(8116), c = new s();
+            function f(h) {
+              var d = c.get(h), v = d && (d._triangleBuffer.handle || d._triangleBuffer.buffer);
+              if (!v || !h.isBuffer(v)) {
+                var _ = l(h, new Float32Array([-1, -1, -1, 4, 4, -1]));
+                d = u(h, [{ buffer: _, type: h.FLOAT, size: 2 }]), d._triangleBuffer = _, c.set(h, d);
+              }
+              d.bind(), h.drawArrays(h.TRIANGLES, 0, 3), d.unbind();
+            }
+            i.exports = f;
+          }, 7182: function(i, a, o) {
+            var s = { identity: o(7894), translate: o(7656), multiply: o(6760), create: o(6864), scale: o(2504), fromRotationTranslation: o(6743) };
+            s.create();
+            var u = s.create();
+            i.exports = function(f, h, d, v, _, b) {
+              return s.identity(f), s.fromRotationTranslation(f, b, h), f[3] = _[0], f[7] = _[1], f[11] = _[2], f[15] = _[3], s.identity(u), v[2] !== 0 && (u[9] = v[2], s.multiply(f, f, u)), v[1] !== 0 && (u[9] = 0, u[8] = v[1], s.multiply(f, f, u)), v[0] !== 0 && (u[8] = 0, u[4] = v[0], s.multiply(f, f, u)), s.scale(f, f, d), f;
+            };
+          }, 7201: function(i, a, o) {
+            var s = 1e-6, l = 1e-6, u = o(9405), c = o(2762), f = o(8116), h = o(7766), d = o(8406), v = o(6760), _ = o(7608), b = o(9618), p = o(6729), k = o(7765), E = o(1888), T = o(840), L = o(7626), x = T.meshShader, C = T.wireShader, M = T.pointShader, g = T.pickShader, P = T.pointPickShader, A = T.contourShader, z = [1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1];
+            function O(ge, ie, Se, Ee, Ae, Be, Pe, me, De, ce, je, lt, pt, Vt, ot, ut, Wt, Nt, $t, sr, Tr, fr, $e, St, Qt, Gt, _t) {
+              this.gl = ge, this.pixelRatio = 1, this.cells = [], this.positions = [], this.intensity = [], this.texture = ie, this.dirty = true, this.triShader = Se, this.lineShader = Ee, this.pointShader = Ae, this.pickShader = Be, this.pointPickShader = Pe, this.contourShader = me, this.trianglePositions = De, this.triangleColors = je, this.triangleNormals = pt, this.triangleUVs = lt, this.triangleIds = ce, this.triangleVAO = Vt, this.triangleCount = 0, this.lineWidth = 1, this.edgePositions = ot, this.edgeColors = Wt, this.edgeUVs = Nt, this.edgeIds = ut, this.edgeVAO = $t, this.edgeCount = 0, this.pointPositions = sr, this.pointColors = fr, this.pointUVs = $e, this.pointSizes = St, this.pointIds = Tr, this.pointVAO = Qt, this.pointCount = 0, this.contourLineWidth = 1, this.contourPositions = Gt, this.contourVAO = _t, this.contourCount = 0, this.contourColor = [0, 0, 0], this.contourEnable = true, this.pickVertex = true, this.pickId = 1, this.bounds = [[1 / 0, 1 / 0, 1 / 0], [-1 / 0, -1 / 0, -1 / 0]], this.clipBounds = [[-1 / 0, -1 / 0, -1 / 0], [1 / 0, 1 / 0, 1 / 0]], this.lightPosition = [1e5, 1e5, 0], this.ambientLight = 0.8, this.diffuseLight = 0.8, this.specularLight = 2, this.roughness = 0.5, this.fresnel = 1.5, this.opacity = 1, this.hasAlpha = false, this.opacityscale = false, this._model = z, this._view = z, this._projection = z, this._resolution = [1, 1];
+            }
+            var U = O.prototype;
+            U.isOpaque = function() {
+              return !this.hasAlpha;
+            }, U.isTransparent = function() {
+              return this.hasAlpha;
+            }, U.pickSlots = 1, U.setPickBase = function(ge) {
+              this.pickId = ge;
+            };
+            function G(ge, ie) {
+              if (!ie || !ie.length) return 1;
+              for (var Se = 0; Se < ie.length; ++Se) {
+                if (ie.length < 2) return 1;
+                if (ie[Se][0] === ge) return ie[Se][1];
+                if (ie[Se][0] > ge && Se > 0) {
+                  var Ee = (ie[Se][0] - ge) / (ie[Se][0] - ie[Se - 1][0]);
+                  return ie[Se][1] * (1 - Ee) + Ee * ie[Se - 1][1];
+                }
+              }
+              return 1;
+            }
+            function Z(ge, ie) {
+              for (var Se = p({ colormap: ge, nshades: 256, format: "rgba" }), Ee = new Uint8Array(256 * 4), Ae = 0; Ae < 256; ++Ae) {
+                for (var Be = Se[Ae], Pe = 0; Pe < 3; ++Pe) Ee[4 * Ae + Pe] = Be[Pe];
+                ie ? Ee[4 * Ae + 3] = 255 * G(Ae / 255, ie) : Ee[4 * Ae + 3] = 255 * Be[3];
+              }
+              return b(Ee, [256, 256, 4], [4, 0, 1]);
+            }
+            function j(ge) {
+              for (var ie = ge.length, Se = new Array(ie), Ee = 0; Ee < ie; ++Ee) Se[Ee] = ge[Ee][2];
+              return Se;
+            }
+            U.highlight = function(ge) {
+              if (!ge || !this.contourEnable) {
+                this.contourCount = 0;
+                return;
+              }
+              for (var ie = k(this.cells, this.intensity, ge.intensity), Se = ie.cells, Ee = ie.vertexIds, Ae = ie.vertexWeights, Be = Se.length, Pe = E.mallocFloat32(2 * 3 * Be), me = 0, De = 0; De < Be; ++De) for (var ce = Se[De], je = 0; je < 2; ++je) {
+                var lt = ce[0];
+                ce.length === 2 && (lt = ce[je]);
+                for (var pt = Ee[lt][0], Vt = Ee[lt][1], ot = Ae[lt], ut = 1 - ot, Wt = this.positions[pt], Nt = this.positions[Vt], $t = 0; $t < 3; ++$t) Pe[me++] = ot * Wt[$t] + ut * Nt[$t];
+              }
+              this.contourCount = me / 3 | 0, this.contourPositions.update(Pe.subarray(0, me)), E.free(Pe);
+            }, U.update = function(ge) {
+              ge = ge || {};
+              var ie = this.gl;
+              this.dirty = true, "contourEnable" in ge && (this.contourEnable = ge.contourEnable), "contourColor" in ge && (this.contourColor = ge.contourColor), "lineWidth" in ge && (this.lineWidth = ge.lineWidth), "lightPosition" in ge && (this.lightPosition = ge.lightPosition), this.hasAlpha = false, "opacity" in ge && (this.opacity = ge.opacity, this.opacity < 1 && (this.hasAlpha = true)), "opacityscale" in ge && (this.opacityscale = ge.opacityscale, this.hasAlpha = true), "ambient" in ge && (this.ambientLight = ge.ambient), "diffuse" in ge && (this.diffuseLight = ge.diffuse), "specular" in ge && (this.specularLight = ge.specular), "roughness" in ge && (this.roughness = ge.roughness), "fresnel" in ge && (this.fresnel = ge.fresnel), ge.texture ? (this.texture.dispose(), this.texture = h(ie, ge.texture)) : ge.colormap && (this.texture.shape = [256, 256], this.texture.minFilter = ie.LINEAR_MIPMAP_LINEAR, this.texture.magFilter = ie.LINEAR, this.texture.setPixels(Z(ge.colormap, this.opacityscale)), this.texture.generateMipmap());
+              var Se = ge.cells, Ee = ge.positions;
+              if (!(!Ee || !Se)) {
+                var Ae = [], Be = [], Pe = [], me = [], De = [], ce = [], je = [], lt = [], pt = [], Vt = [], ot = [], ut = [], Wt = [], Nt = [];
+                this.cells = Se, this.positions = Ee;
+                var $t = ge.vertexNormals, sr = ge.cellNormals, Tr = ge.vertexNormalsEpsilon === void 0 ? s : ge.vertexNormalsEpsilon, fr = ge.faceNormalsEpsilon === void 0 ? l : ge.faceNormalsEpsilon;
+                ge.useFacetNormals && !sr && (sr = d.faceNormals(Se, Ee, fr)), !sr && !$t && ($t = d.vertexNormals(Se, Ee, Tr));
+                var $e = ge.vertexColors, St = ge.cellColors, Qt = ge.meshColor || [1, 1, 1, 1], Gt = ge.vertexUVs, _t = ge.vertexIntensity, It = ge.cellUVs, mt = ge.cellIntensity, er = 1 / 0, lr = -1 / 0;
+                if (!Gt && !It) if (_t) if (ge.vertexIntensityBounds) er = +ge.vertexIntensityBounds[0], lr = +ge.vertexIntensityBounds[1];
+                else for (var wr = 0; wr < _t.length; ++wr) {
+                  var Lr = _t[wr];
+                  er = Math.min(er, Lr), lr = Math.max(lr, Lr);
+                }
+                else if (mt) if (ge.cellIntensityBounds) er = +ge.cellIntensityBounds[0], lr = +ge.cellIntensityBounds[1];
+                else for (var wr = 0; wr < mt.length; ++wr) {
+                  var Lr = mt[wr];
+                  er = Math.min(er, Lr), lr = Math.max(lr, Lr);
+                }
+                else for (var wr = 0; wr < Ee.length; ++wr) {
+                  var Lr = Ee[wr][2];
+                  er = Math.min(er, Lr), lr = Math.max(lr, Lr);
+                }
+                _t ? this.intensity = _t : mt ? this.intensity = mt : this.intensity = j(Ee), this.pickVertex = !(mt || St);
+                var ti = ge.pointSizes, Br = ge.pointSize || 1;
+                this.bounds = [[1 / 0, 1 / 0, 1 / 0], [-1 / 0, -1 / 0, -1 / 0]];
+                for (var wr = 0; wr < Ee.length; ++wr) for (var Vr = Ee[wr], dt = 0; dt < 3; ++dt) isNaN(Vr[dt]) || !isFinite(Vr[dt]) || (this.bounds[0][dt] = Math.min(this.bounds[0][dt], Vr[dt]), this.bounds[1][dt] = Math.max(this.bounds[1][dt], Vr[dt]));
+                var Ge = 0, Je = 0, We = 0;
+                e: for (var wr = 0; wr < Se.length; ++wr) {
+                  var tt = Se[wr];
+                  switch (tt.length) {
+                    case 1:
+                      for (var xt = tt[0], Vr = Ee[xt], dt = 0; dt < 3; ++dt) if (isNaN(Vr[dt]) || !isFinite(Vr[dt])) continue e;
+                      Vt.push(Vr[0], Vr[1], Vr[2]);
+                      var Ie;
+                      $e ? Ie = $e[xt] : St ? Ie = St[wr] : Ie = Qt, this.opacityscale && _t ? Be.push(Ie[0], Ie[1], Ie[2], this.opacity * G((_t[xt] - er) / (lr - er), this.opacityscale)) : Ie.length === 3 ? ot.push(Ie[0], Ie[1], Ie[2], this.opacity) : (ot.push(Ie[0], Ie[1], Ie[2], Ie[3] * this.opacity), Ie[3] < 1 && (this.hasAlpha = true));
+                      var xe;
+                      Gt ? xe = Gt[xt] : _t ? xe = [(_t[xt] - er) / (lr - er), 0] : It ? xe = It[wr] : mt ? xe = [(mt[wr] - er) / (lr - er), 0] : xe = [(Vr[2] - er) / (lr - er), 0], ut.push(xe[0], xe[1]), ti ? Wt.push(ti[xt]) : Wt.push(Br), Nt.push(wr), We += 1;
+                      break;
+                    case 2:
+                      for (var dt = 0; dt < 2; ++dt) for (var xt = tt[dt], Vr = Ee[xt], ke = 0; ke < 3; ++ke) if (isNaN(Vr[ke]) || !isFinite(Vr[ke])) continue e;
+                      for (var dt = 0; dt < 2; ++dt) {
+                        var xt = tt[dt], Vr = Ee[xt];
+                        ce.push(Vr[0], Vr[1], Vr[2]);
+                        var Ie;
+                        $e ? Ie = $e[xt] : St ? Ie = St[wr] : Ie = Qt, this.opacityscale && _t ? Be.push(Ie[0], Ie[1], Ie[2], this.opacity * G((_t[xt] - er) / (lr - er), this.opacityscale)) : Ie.length === 3 ? je.push(Ie[0], Ie[1], Ie[2], this.opacity) : (je.push(Ie[0], Ie[1], Ie[2], Ie[3] * this.opacity), Ie[3] < 1 && (this.hasAlpha = true));
+                        var xe;
+                        Gt ? xe = Gt[xt] : _t ? xe = [(_t[xt] - er) / (lr - er), 0] : It ? xe = It[wr] : mt ? xe = [(mt[wr] - er) / (lr - er), 0] : xe = [(Vr[2] - er) / (lr - er), 0], lt.push(xe[0], xe[1]), pt.push(wr);
+                      }
+                      Je += 1;
+                      break;
+                    case 3:
+                      for (var dt = 0; dt < 3; ++dt) for (var xt = tt[dt], Vr = Ee[xt], ke = 0; ke < 3; ++ke) if (isNaN(Vr[ke]) || !isFinite(Vr[ke])) continue e;
+                      for (var dt = 0; dt < 3; ++dt) {
+                        var xt = tt[2 - dt], Vr = Ee[xt];
+                        Ae.push(Vr[0], Vr[1], Vr[2]);
+                        var Ie;
+                        $e ? Ie = $e[xt] : St ? Ie = St[wr] : Ie = Qt, Ie ? this.opacityscale && _t ? Be.push(Ie[0], Ie[1], Ie[2], this.opacity * G((_t[xt] - er) / (lr - er), this.opacityscale)) : Ie.length === 3 ? Be.push(Ie[0], Ie[1], Ie[2], this.opacity) : (Be.push(Ie[0], Ie[1], Ie[2], Ie[3] * this.opacity), Ie[3] < 1 && (this.hasAlpha = true)) : Be.push(0.5, 0.5, 0.5, 1);
+                        var xe;
+                        Gt ? xe = Gt[xt] : _t ? xe = [(_t[xt] - er) / (lr - er), 0] : It ? xe = It[wr] : mt ? xe = [(mt[wr] - er) / (lr - er), 0] : xe = [(Vr[2] - er) / (lr - er), 0], me.push(xe[0], xe[1]);
+                        var vt;
+                        $t ? vt = $t[xt] : vt = sr[wr], Pe.push(vt[0], vt[1], vt[2]), De.push(wr);
+                      }
+                      Ge += 1;
+                      break;
+                  }
+                }
+                this.pointCount = We, this.edgeCount = Je, this.triangleCount = Ge, this.pointPositions.update(Vt), this.pointColors.update(ot), this.pointUVs.update(ut), this.pointSizes.update(Wt), this.pointIds.update(new Uint32Array(Nt)), this.edgePositions.update(ce), this.edgeColors.update(je), this.edgeUVs.update(lt), this.edgeIds.update(new Uint32Array(pt)), this.trianglePositions.update(Ae), this.triangleColors.update(Be), this.triangleUVs.update(me), this.triangleNormals.update(Pe), this.triangleIds.update(new Uint32Array(De));
+              }
+            }, U.drawTransparent = U.draw = function(ge) {
+              ge = ge || {};
+              for (var ie = this.gl, Se = ge.model || z, Ee = ge.view || z, Ae = ge.projection || z, Be = [[-1e6, -1e6, -1e6], [1e6, 1e6, 1e6]], Pe = 0; Pe < 3; ++Pe) Be[0][Pe] = Math.max(Be[0][Pe], this.clipBounds[0][Pe]), Be[1][Pe] = Math.min(Be[1][Pe], this.clipBounds[1][Pe]);
+              var me = { model: Se, view: Ee, projection: Ae, inverseModel: z.slice(), clipBounds: Be, kambient: this.ambientLight, kdiffuse: this.diffuseLight, kspecular: this.specularLight, roughness: this.roughness, fresnel: this.fresnel, eyePosition: [0, 0, 0], lightPosition: [0, 0, 0], contourColor: this.contourColor, texture: 0 };
+              me.inverseModel = _(me.inverseModel, me.model), ie.disable(ie.CULL_FACE), this.texture.bind(0);
+              var De = new Array(16);
+              v(De, me.view, me.model), v(De, me.projection, De), _(De, De);
+              for (var Pe = 0; Pe < 3; ++Pe) me.eyePosition[Pe] = De[12 + Pe] / De[15];
+              for (var ce = De[15], Pe = 0; Pe < 3; ++Pe) ce += this.lightPosition[Pe] * De[4 * Pe + 3];
+              for (var Pe = 0; Pe < 3; ++Pe) {
+                for (var je = De[12 + Pe], lt = 0; lt < 3; ++lt) je += De[4 * lt + Pe] * this.lightPosition[lt];
+                me.lightPosition[Pe] = je / ce;
+              }
+              if (this.triangleCount > 0) {
+                var pt = this.triShader;
+                pt.bind(), pt.uniforms = me, this.triangleVAO.bind(), ie.drawArrays(ie.TRIANGLES, 0, this.triangleCount * 3), this.triangleVAO.unbind();
+              }
+              if (this.edgeCount > 0 && this.lineWidth > 0) {
+                var pt = this.lineShader;
+                pt.bind(), pt.uniforms = me, this.edgeVAO.bind(), ie.lineWidth(this.lineWidth * this.pixelRatio), ie.drawArrays(ie.LINES, 0, this.edgeCount * 2), this.edgeVAO.unbind();
+              }
+              if (this.pointCount > 0) {
+                var pt = this.pointShader;
+                pt.bind(), pt.uniforms = me, this.pointVAO.bind(), ie.drawArrays(ie.POINTS, 0, this.pointCount), this.pointVAO.unbind();
+              }
+              if (this.contourEnable && this.contourCount > 0 && this.contourLineWidth > 0) {
+                var pt = this.contourShader;
+                pt.bind(), pt.uniforms = me, this.contourVAO.bind(), ie.drawArrays(ie.LINES, 0, this.contourCount), this.contourVAO.unbind();
+              }
+            }, U.drawPick = function(ge) {
+              ge = ge || {};
+              for (var ie = this.gl, Se = ge.model || z, Ee = ge.view || z, Ae = ge.projection || z, Be = [[-1e6, -1e6, -1e6], [1e6, 1e6, 1e6]], Pe = 0; Pe < 3; ++Pe) Be[0][Pe] = Math.max(Be[0][Pe], this.clipBounds[0][Pe]), Be[1][Pe] = Math.min(Be[1][Pe], this.clipBounds[1][Pe]);
+              this._model = [].slice.call(Se), this._view = [].slice.call(Ee), this._projection = [].slice.call(Ae), this._resolution = [ie.drawingBufferWidth, ie.drawingBufferHeight];
+              var me = { model: Se, view: Ee, projection: Ae, clipBounds: Be, pickId: this.pickId / 255 }, De = this.pickShader;
+              if (De.bind(), De.uniforms = me, this.triangleCount > 0 && (this.triangleVAO.bind(), ie.drawArrays(ie.TRIANGLES, 0, this.triangleCount * 3), this.triangleVAO.unbind()), this.edgeCount > 0 && (this.edgeVAO.bind(), ie.lineWidth(this.lineWidth * this.pixelRatio), ie.drawArrays(ie.LINES, 0, this.edgeCount * 2), this.edgeVAO.unbind()), this.pointCount > 0) {
+                var De = this.pointPickShader;
+                De.bind(), De.uniforms = me, this.pointVAO.bind(), ie.drawArrays(ie.POINTS, 0, this.pointCount), this.pointVAO.unbind();
+              }
+            }, U.pick = function(ge) {
+              if (!ge || ge.id !== this.pickId) return null;
+              for (var ie = ge.value[0] + 256 * ge.value[1] + 65536 * ge.value[2], Se = this.cells[ie], Ee = this.positions, Ae = new Array(Se.length), Be = 0; Be < Se.length; ++Be) Ae[Be] = Ee[Se[Be]];
+              var Pe = ge.coord[0], me = ge.coord[1];
+              if (!this.pickVertex) {
+                var De = this.positions[Se[0]], ce = this.positions[Se[1]], je = this.positions[Se[2]], lt = [(De[0] + ce[0] + je[0]) / 3, (De[1] + ce[1] + je[1]) / 3, (De[2] + ce[2] + je[2]) / 3];
+                return { _cellCenter: true, position: [Pe, me], index: ie, cell: Se, cellId: ie, intensity: this.intensity[ie], dataCoordinate: lt };
+              }
+              var pt = L(Ae, [Pe * this.pixelRatio, this._resolution[1] - me * this.pixelRatio], this._model, this._view, this._projection, this._resolution);
+              if (!pt) return null;
+              for (var Vt = pt[2], ot = 0, Be = 0; Be < Se.length; ++Be) ot += Vt[Be] * this.intensity[Se[Be]];
+              return { position: pt[1], index: Se[pt[0]], cell: Se, cellId: ie, intensity: ot, dataCoordinate: this.positions[Se[pt[0]]] };
+            }, U.dispose = function() {
+              this.texture.dispose(), this.triShader.dispose(), this.lineShader.dispose(), this.pointShader.dispose(), this.pickShader.dispose(), this.pointPickShader.dispose(), this.triangleVAO.dispose(), this.trianglePositions.dispose(), this.triangleColors.dispose(), this.triangleUVs.dispose(), this.triangleNormals.dispose(), this.triangleIds.dispose(), this.edgeVAO.dispose(), this.edgePositions.dispose(), this.edgeColors.dispose(), this.edgeUVs.dispose(), this.edgeIds.dispose(), this.pointVAO.dispose(), this.pointPositions.dispose(), this.pointColors.dispose(), this.pointUVs.dispose(), this.pointSizes.dispose(), this.pointIds.dispose(), this.contourVAO.dispose(), this.contourPositions.dispose(), this.contourShader.dispose();
+            };
+            function N(ge) {
+              var ie = u(ge, x.vertex, x.fragment);
+              return ie.attributes.position.location = 0, ie.attributes.color.location = 2, ie.attributes.uv.location = 3, ie.attributes.normal.location = 4, ie;
+            }
+            function H(ge) {
+              var ie = u(ge, C.vertex, C.fragment);
+              return ie.attributes.position.location = 0, ie.attributes.color.location = 2, ie.attributes.uv.location = 3, ie;
+            }
+            function re(ge) {
+              var ie = u(ge, M.vertex, M.fragment);
+              return ie.attributes.position.location = 0, ie.attributes.color.location = 2, ie.attributes.uv.location = 3, ie.attributes.pointSize.location = 4, ie;
+            }
+            function oe(ge) {
+              var ie = u(ge, g.vertex, g.fragment);
+              return ie.attributes.position.location = 0, ie.attributes.id.location = 1, ie;
+            }
+            function _e(ge) {
+              var ie = u(ge, P.vertex, P.fragment);
+              return ie.attributes.position.location = 0, ie.attributes.id.location = 1, ie.attributes.pointSize.location = 4, ie;
+            }
+            function Ce(ge) {
+              var ie = u(ge, A.vertex, A.fragment);
+              return ie.attributes.position.location = 0, ie;
+            }
+            function Le(ge, ie) {
+              arguments.length === 1 && (ie = ge, ge = ie.gl);
+              var Se = ge.getExtension("OES_standard_derivatives") || ge.getExtension("MOZ_OES_standard_derivatives") || ge.getExtension("WEBKIT_OES_standard_derivatives");
+              if (!Se) throw new Error("derivatives not supported");
+              var Ee = N(ge), Ae = H(ge), Be = re(ge), Pe = oe(ge), me = _e(ge), De = Ce(ge), ce = h(ge, b(new Uint8Array([255, 255, 255, 255]), [1, 1, 4]));
+              ce.generateMipmap(), ce.minFilter = ge.LINEAR_MIPMAP_LINEAR, ce.magFilter = ge.LINEAR;
+              var je = c(ge), lt = c(ge), pt = c(ge), Vt = c(ge), ot = c(ge), ut = f(ge, [{ buffer: je, type: ge.FLOAT, size: 3 }, { buffer: ot, type: ge.UNSIGNED_BYTE, size: 4, normalized: true }, { buffer: lt, type: ge.FLOAT, size: 4 }, { buffer: pt, type: ge.FLOAT, size: 2 }, { buffer: Vt, type: ge.FLOAT, size: 3 }]), Wt = c(ge), Nt = c(ge), $t = c(ge), sr = c(ge), Tr = f(ge, [{ buffer: Wt, type: ge.FLOAT, size: 3 }, { buffer: sr, type: ge.UNSIGNED_BYTE, size: 4, normalized: true }, { buffer: Nt, type: ge.FLOAT, size: 4 }, { buffer: $t, type: ge.FLOAT, size: 2 }]), fr = c(ge), $e = c(ge), St = c(ge), Qt = c(ge), Gt = c(ge), _t = f(ge, [{ buffer: fr, type: ge.FLOAT, size: 3 }, { buffer: Gt, type: ge.UNSIGNED_BYTE, size: 4, normalized: true }, { buffer: $e, type: ge.FLOAT, size: 4 }, { buffer: St, type: ge.FLOAT, size: 2 }, { buffer: Qt, type: ge.FLOAT, size: 1 }]), It = c(ge), mt = f(ge, [{ buffer: It, type: ge.FLOAT, size: 3 }]), er = new O(ge, ce, Ee, Ae, Be, Pe, me, De, je, ot, lt, pt, Vt, ut, Wt, sr, Nt, $t, Tr, fr, Gt, $e, St, Qt, _t, It, mt);
+              return er.update(ie), er;
+            }
+            i.exports = Le;
+          }, 7261: function(i, a, o) {
+            i.exports = E;
+            var s = o(9215), l = o(7608), u = o(6079), c = o(5911), f = o(3536), h = o(244);
+            function d(T, L, x) {
+              return Math.sqrt(Math.pow(T, 2) + Math.pow(L, 2) + Math.pow(x, 2));
+            }
+            function v(T) {
+              return Math.min(1, Math.max(-1, T));
+            }
+            function _(T) {
+              var L = Math.abs(T[0]), x = Math.abs(T[1]), C = Math.abs(T[2]), M = [0, 0, 0];
+              L > Math.max(x, C) ? M[2] = 1 : x > Math.max(L, C) ? M[0] = 1 : M[1] = 1;
+              for (var g = 0, P = 0, A = 0; A < 3; ++A) g += T[A] * T[A], P += M[A] * T[A];
+              for (var A = 0; A < 3; ++A) M[A] -= P / g * T[A];
+              return f(M, M), M;
+            }
+            function b(T, L, x, C, M, g, P, A) {
+              this.center = s(x), this.up = s(C), this.right = s(M), this.radius = s([g]), this.angle = s([P, A]), this.angle.bounds = [[-1 / 0, -Math.PI / 2], [1 / 0, Math.PI / 2]], this.setDistanceLimits(T, L), this.computedCenter = this.center.curve(0), this.computedUp = this.up.curve(0), this.computedRight = this.right.curve(0), this.computedRadius = this.radius.curve(0), this.computedAngle = this.angle.curve(0), this.computedToward = [0, 0, 0], this.computedEye = [0, 0, 0], this.computedMatrix = new Array(16);
+              for (var z = 0; z < 16; ++z) this.computedMatrix[z] = 0.5;
+              this.recalcMatrix(0);
+            }
+            var p = b.prototype;
+            p.setDistanceLimits = function(T, L) {
+              T > 0 ? T = Math.log(T) : T = -1 / 0, L > 0 ? L = Math.log(L) : L = 1 / 0, L = Math.max(L, T), this.radius.bounds[0][0] = T, this.radius.bounds[1][0] = L;
+            }, p.getDistanceLimits = function(T) {
+              var L = this.radius.bounds[0];
+              return T ? (T[0] = Math.exp(L[0][0]), T[1] = Math.exp(L[1][0]), T) : [Math.exp(L[0][0]), Math.exp(L[1][0])];
+            }, p.recalcMatrix = function(T) {
+              this.center.curve(T), this.up.curve(T), this.right.curve(T), this.radius.curve(T), this.angle.curve(T);
+              for (var L = this.computedUp, x = this.computedRight, C = 0, M = 0, g = 0; g < 3; ++g) M += L[g] * x[g], C += L[g] * L[g];
+              for (var P = Math.sqrt(C), A = 0, g = 0; g < 3; ++g) x[g] -= L[g] * M / C, A += x[g] * x[g], L[g] /= P;
+              for (var z = Math.sqrt(A), g = 0; g < 3; ++g) x[g] /= z;
+              var O = this.computedToward;
+              c(O, L, x), f(O, O);
+              for (var U = Math.exp(this.computedRadius[0]), G = this.computedAngle[0], Z = this.computedAngle[1], j = Math.cos(G), N = Math.sin(G), H = Math.cos(Z), re = Math.sin(Z), oe = this.computedCenter, _e = j * H, Ce = N * H, Le = re, ge = -j * re, ie = -N * re, Se = H, Ee = this.computedEye, Ae = this.computedMatrix, g = 0; g < 3; ++g) {
+                var Be = _e * x[g] + Ce * O[g] + Le * L[g];
+                Ae[4 * g + 1] = ge * x[g] + ie * O[g] + Se * L[g], Ae[4 * g + 2] = Be, Ae[4 * g + 3] = 0;
+              }
+              var Pe = Ae[1], me = Ae[5], De = Ae[9], ce = Ae[2], je = Ae[6], lt = Ae[10], pt = me * lt - De * je, Vt = De * ce - Pe * lt, ot = Pe * je - me * ce, ut = d(pt, Vt, ot);
+              pt /= ut, Vt /= ut, ot /= ut, Ae[0] = pt, Ae[4] = Vt, Ae[8] = ot;
+              for (var g = 0; g < 3; ++g) Ee[g] = oe[g] + Ae[2 + 4 * g] * U;
+              for (var g = 0; g < 3; ++g) {
+                for (var A = 0, Wt = 0; Wt < 3; ++Wt) A += Ae[g + 4 * Wt] * Ee[Wt];
+                Ae[12 + g] = -A;
+              }
+              Ae[15] = 1;
+            }, p.getMatrix = function(T, L) {
+              this.recalcMatrix(T);
+              var x = this.computedMatrix;
+              if (L) {
+                for (var C = 0; C < 16; ++C) L[C] = x[C];
+                return L;
+              }
+              return x;
+            };
+            var k = [0, 0, 0];
+            p.rotate = function(T, L, x, C) {
+              if (this.angle.move(T, L, x), C) {
+                this.recalcMatrix(T);
+                var M = this.computedMatrix;
+                k[0] = M[2], k[1] = M[6], k[2] = M[10];
+                for (var g = this.computedUp, P = this.computedRight, A = this.computedToward, z = 0; z < 3; ++z) M[4 * z] = g[z], M[4 * z + 1] = P[z], M[4 * z + 2] = A[z];
+                u(M, M, C, k);
+                for (var z = 0; z < 3; ++z) g[z] = M[4 * z], P[z] = M[4 * z + 1];
+                this.up.set(T, g[0], g[1], g[2]), this.right.set(T, P[0], P[1], P[2]);
+              }
+            }, p.pan = function(T, L, x, C) {
+              L = L || 0, x = x || 0, C = C || 0, this.recalcMatrix(T);
+              var M = this.computedMatrix;
+              Math.exp(this.computedRadius[0]);
+              var P = M[1], A = M[5], z = M[9], O = d(P, A, z);
+              P /= O, A /= O, z /= O;
+              var U = M[0], G = M[4], Z = M[8], j = U * P + G * A + Z * z;
+              U -= P * j, G -= A * j, Z -= z * j;
+              var N = d(U, G, Z);
+              U /= N, G /= N, Z /= N;
+              var H = U * L + P * x, re = G * L + A * x, oe = Z * L + z * x;
+              this.center.move(T, H, re, oe);
+              var _e = Math.exp(this.computedRadius[0]);
+              _e = Math.max(1e-4, _e + C), this.radius.set(T, Math.log(_e));
+            }, p.translate = function(T, L, x, C) {
+              this.center.move(T, L || 0, x || 0, C || 0);
+            }, p.setMatrix = function(T, L, x, C) {
+              var M = 1;
+              typeof x == "number" && (M = x | 0), (M < 0 || M > 3) && (M = 1);
+              var g = (M + 2) % 3;
+              L || (this.recalcMatrix(T), L = this.computedMatrix);
+              var A = L[M], z = L[M + 4], O = L[M + 8];
+              if (C) {
+                var G = Math.abs(A), Z = Math.abs(z), j = Math.abs(O), N = Math.max(G, Z, j);
+                G === N ? (A = A < 0 ? -1 : 1, z = O = 0) : j === N ? (O = O < 0 ? -1 : 1, A = z = 0) : (z = z < 0 ? -1 : 1, A = O = 0);
+              } else {
+                var U = d(A, z, O);
+                A /= U, z /= U, O /= U;
+              }
+              var H = L[g], re = L[g + 4], oe = L[g + 8], _e = H * A + re * z + oe * O;
+              H -= A * _e, re -= z * _e, oe -= O * _e;
+              var Ce = d(H, re, oe);
+              H /= Ce, re /= Ce, oe /= Ce;
+              var Le = z * oe - O * re, ge = O * H - A * oe, ie = A * re - z * H, Se = d(Le, ge, ie);
+              Le /= Se, ge /= Se, ie /= Se, this.center.jump(T, fr, $e, St), this.radius.idle(T), this.up.jump(T, A, z, O), this.right.jump(T, H, re, oe);
+              var Ee, Ae;
+              if (M === 2) {
+                var Be = L[1], Pe = L[5], me = L[9], De = Be * H + Pe * re + me * oe, ce = Be * Le + Pe * ge + me * ie;
+                Vt < 0 ? Ee = -Math.PI / 2 : Ee = Math.PI / 2, Ae = Math.atan2(ce, De);
+              } else {
+                var je = L[2], lt = L[6], pt = L[10], Vt = je * A + lt * z + pt * O, ot = je * H + lt * re + pt * oe, ut = je * Le + lt * ge + pt * ie;
+                Ee = Math.asin(v(Vt)), Ae = Math.atan2(ut, ot);
+              }
+              this.angle.jump(T, Ae, Ee), this.recalcMatrix(T);
+              var Wt = L[2], Nt = L[6], $t = L[10], sr = this.computedMatrix;
+              l(sr, L);
+              var Tr = sr[15], fr = sr[12] / Tr, $e = sr[13] / Tr, St = sr[14] / Tr, Qt = Math.exp(this.computedRadius[0]);
+              this.center.jump(T, fr - Wt * Qt, $e - Nt * Qt, St - $t * Qt);
+            }, p.lastT = function() {
+              return Math.max(this.center.lastT(), this.up.lastT(), this.right.lastT(), this.radius.lastT(), this.angle.lastT());
+            }, p.idle = function(T) {
+              this.center.idle(T), this.up.idle(T), this.right.idle(T), this.radius.idle(T), this.angle.idle(T);
+            }, p.flush = function(T) {
+              this.center.flush(T), this.up.flush(T), this.right.flush(T), this.radius.flush(T), this.angle.flush(T);
+            }, p.setDistance = function(T, L) {
+              L > 0 && this.radius.set(T, Math.log(L));
+            }, p.lookAt = function(T, L, x, C) {
+              this.recalcMatrix(T), L = L || this.computedEye, x = x || this.computedCenter, C = C || this.computedUp;
+              var M = C[0], g = C[1], P = C[2], A = d(M, g, P);
+              if (!(A < 1e-6)) {
+                M /= A, g /= A, P /= A;
+                var z = L[0] - x[0], O = L[1] - x[1], U = L[2] - x[2], G = d(z, O, U);
+                if (!(G < 1e-6)) {
+                  z /= G, O /= G, U /= G;
+                  var Z = this.computedRight, j = Z[0], N = Z[1], H = Z[2], re = M * j + g * N + P * H;
+                  j -= re * M, N -= re * g, H -= re * P;
+                  var oe = d(j, N, H);
+                  if (!(oe < 0.01 && (j = g * U - P * O, N = P * z - M * U, H = M * O - g * z, oe = d(j, N, H), oe < 1e-6))) {
+                    j /= oe, N /= oe, H /= oe, this.up.set(T, M, g, P), this.right.set(T, j, N, H), this.center.set(T, x[0], x[1], x[2]), this.radius.set(T, Math.log(G));
+                    var _e = g * H - P * N, Ce = P * j - M * H, Le = M * N - g * j, ge = d(_e, Ce, Le);
+                    _e /= ge, Ce /= ge, Le /= ge;
+                    var ie = M * z + g * O + P * U, Se = j * z + N * O + H * U, Ee = _e * z + Ce * O + Le * U, Ae = Math.asin(v(ie)), Be = Math.atan2(Ee, Se), Pe = this.angle._state, me = Pe[Pe.length - 1], De = Pe[Pe.length - 2];
+                    me = me % (2 * Math.PI);
+                    var ce = Math.abs(me + 2 * Math.PI - Be), je = Math.abs(me - Be), lt = Math.abs(me - 2 * Math.PI - Be);
+                    ce < je && (me += 2 * Math.PI), lt < je && (me -= 2 * Math.PI), this.angle.jump(this.angle.lastT(), me, De), this.angle.set(T, Be, Ae);
+                  }
+                }
+              }
+            };
+            function E(T) {
+              T = T || {};
+              var L = T.center || [0, 0, 0], x = T.up || [0, 1, 0], C = T.right || _(x), M = T.radius || 1, g = T.theta || 0, P = T.phi || 0;
+              if (L = [].slice.call(L, 0, 3), x = [].slice.call(x, 0, 3), f(x, x), C = [].slice.call(C, 0, 3), f(C, C), "eye" in T) {
+                var A = T.eye, z = [A[0] - L[0], A[1] - L[1], A[2] - L[2]];
+                c(C, z, x), d(C[0], C[1], C[2]) < 1e-6 ? C = _(x) : f(C, C), M = d(z[0], z[1], z[2]);
+                var O = h(x, z) / M, U = h(C, z) / M;
+                P = Math.acos(O), g = Math.acos(U);
+              }
+              return M = Math.log(M), new b(T.zoomMin, T.zoomMax, L, x, C, M, g, P);
+            }
+          }, 7319: function(i, a, o) {
+            var s = o(3236), l = o(9405), u = s([`precision highp float;
+#define GLSLIFY 1
+
+attribute vec3 position, nextPosition;
+attribute float arcLength, lineWidth;
+attribute vec4 color;
+
+uniform vec2 screenShape;
+uniform float pixelRatio;
+uniform mat4 model, view, projection;
+
+varying vec4 fragColor;
+varying vec3 worldPosition;
+varying float pixelArcLength;
+
+vec4 project(vec3 p) {
+  return projection * (view * (model * vec4(p, 1.0)));
+}
+
+void main() {
+  vec4 startPoint = project(position);
+  vec4 endPoint   = project(nextPosition);
+
+  vec2 A = startPoint.xy / startPoint.w;
+  vec2 B =   endPoint.xy /   endPoint.w;
+
+  float clipAngle = atan(
+    (B.y - A.y) * screenShape.y,
+    (B.x - A.x) * screenShape.x
+  );
+
+  vec2 offset = 0.5 * pixelRatio * lineWidth * vec2(
+    sin(clipAngle),
+    -cos(clipAngle)
+  ) / screenShape;
+
+  gl_Position = vec4(startPoint.xy + startPoint.w * offset, startPoint.zw);
+
+  worldPosition = position;
+  pixelArcLength = arcLength;
+  fragColor = color;
+}
+`]), c = s([`precision highp float;
+#define GLSLIFY 1
+
+bool outOfRange(float a, float b, float p) {
+  return ((p > max(a, b)) ||
+          (p < min(a, b)));
+}
+
+bool outOfRange(vec2 a, vec2 b, vec2 p) {
+  return (outOfRange(a.x, b.x, p.x) ||
+          outOfRange(a.y, b.y, p.y));
+}
+
+bool outOfRange(vec3 a, vec3 b, vec3 p) {
+  return (outOfRange(a.x, b.x, p.x) ||
+          outOfRange(a.y, b.y, p.y) ||
+          outOfRange(a.z, b.z, p.z));
+}
+
+bool outOfRange(vec4 a, vec4 b, vec4 p) {
+  return outOfRange(a.xyz, b.xyz, p.xyz);
+}
+
+uniform vec3      clipBounds[2];
+uniform sampler2D dashTexture;
+uniform float     dashScale;
+uniform float     opacity;
+
+varying vec3    worldPosition;
+varying float   pixelArcLength;
+varying vec4    fragColor;
+
+void main() {
+  if (
+    outOfRange(clipBounds[0], clipBounds[1], worldPosition) ||
+    fragColor.a * opacity == 0.
+  ) discard;
+
+  float dashWeight = texture2D(dashTexture, vec2(dashScale * pixelArcLength, 0)).r;
+  if(dashWeight < 0.5) {
+    discard;
+  }
+  gl_FragColor = fragColor * opacity;
+}
+`]), f = s([`precision highp float;
+#define GLSLIFY 1
+
+#define FLOAT_MAX  1.70141184e38
+#define FLOAT_MIN  1.17549435e-38
+
+// https://github.com/mikolalysenko/glsl-read-float/blob/master/index.glsl
+vec4 packFloat(float v) {
+  float av = abs(v);
+
+  //Handle special cases
+  if(av < FLOAT_MIN) {
+    return vec4(0.0, 0.0, 0.0, 0.0);
+  } else if(v > FLOAT_MAX) {
+    return vec4(127.0, 128.0, 0.0, 0.0) / 255.0;
+  } else if(v < -FLOAT_MAX) {
+    return vec4(255.0, 128.0, 0.0, 0.0) / 255.0;
+  }
+
+  vec4 c = vec4(0,0,0,0);
+
+  //Compute exponent and mantissa
+  float e = floor(log2(av));
+  float m = av * pow(2.0, -e) - 1.0;
+
+  //Unpack mantissa
+  c[1] = floor(128.0 * m);
+  m -= c[1] / 128.0;
+  c[2] = floor(32768.0 * m);
+  m -= c[2] / 32768.0;
+  c[3] = floor(8388608.0 * m);
+
+  //Unpack exponent
+  float ebias = e + 127.0;
+  c[0] = floor(ebias / 2.0);
+  ebias -= c[0] * 2.0;
+  c[1] += floor(ebias) * 128.0;
+
+  //Unpack sign bit
+  c[0] += 128.0 * step(0.0, -v);
+
+  //Scale back to range
+  return c / 255.0;
+}
+
+bool outOfRange(float a, float b, float p) {
+  return ((p > max(a, b)) ||
+          (p < min(a, b)));
+}
+
+bool outOfRange(vec2 a, vec2 b, vec2 p) {
+  return (outOfRange(a.x, b.x, p.x) ||
+          outOfRange(a.y, b.y, p.y));
+}
+
+bool outOfRange(vec3 a, vec3 b, vec3 p) {
+  return (outOfRange(a.x, b.x, p.x) ||
+          outOfRange(a.y, b.y, p.y) ||
+          outOfRange(a.z, b.z, p.z));
+}
+
+bool outOfRange(vec4 a, vec4 b, vec4 p) {
+  return outOfRange(a.xyz, b.xyz, p.xyz);
+}
+
+uniform float pickId;
+uniform vec3 clipBounds[2];
+
+varying vec3 worldPosition;
+varying float pixelArcLength;
+varying vec4 fragColor;
+
+void main() {
+  if (outOfRange(clipBounds[0], clipBounds[1], worldPosition)) discard;
+
+  gl_FragColor = vec4(pickId/255.0, packFloat(pixelArcLength).xyz);
+}`]), h = [{ name: "position", type: "vec3" }, { name: "nextPosition", type: "vec3" }, { name: "arcLength", type: "float" }, { name: "lineWidth", type: "float" }, { name: "color", type: "vec4" }];
+            a.createShader = function(d) {
+              return l(d, u, c, null, h);
+            }, a.createPickShader = function(d) {
+              return l(d, u, f, null, h);
+            };
+          }, 7352: function(i, a, o) {
+            var s = o(5721), l = o(4750), u = o(2690);
+            i.exports = c;
+            function c(f) {
+              var h = f.length;
+              if (h === 0) return [];
+              if (h === 1) return [[0]];
+              var d = f[0].length;
+              return d === 0 ? [] : d === 1 ? s(f) : d === 2 ? l(f) : u(f, d);
+            }
+          }, 7399: function(i) {
+            i.exports = a;
+            function a(o, s) {
+              var l = s[0], u = s[1], c = s[2], f = s[3], h = l + l, d = u + u, v = c + c, _ = l * h, b = u * h, p = u * d, k = c * h, E = c * d, T = c * v, L = f * h, x = f * d, C = f * v;
+              return o[0] = 1 - p - T, o[1] = b + C, o[2] = k - x, o[3] = 0, o[4] = b - C, o[5] = 1 - _ - T, o[6] = E + L, o[7] = 0, o[8] = k + x, o[9] = E - L, o[10] = 1 - _ - p, o[11] = 0, o[12] = 0, o[13] = 0, o[14] = 0, o[15] = 1, o;
+            }
+          }, 7417: function(i) {
+            i.exports = a;
+            function a(o, s, l) {
+              return o[0] = Math.max(s[0], l[0]), o[1] = Math.max(s[1], l[1]), o[2] = Math.max(s[2], l[2]), o;
+            }
+          }, 7442: function(i, a, o) {
+            var s = o(6658), l = o(7182), u = o(2652), c = o(9921), f = o(8648), h = b(), d = b(), v = b();
+            i.exports = _;
+            function _(E, T, L, x) {
+              if (c(T) === 0 || c(L) === 0) return false;
+              var C = u(T, h.translate, h.scale, h.skew, h.perspective, h.quaternion), M = u(L, d.translate, d.scale, d.skew, d.perspective, d.quaternion);
+              return !C || !M ? false : (s(v.translate, h.translate, d.translate, x), s(v.skew, h.skew, d.skew, x), s(v.scale, h.scale, d.scale, x), s(v.perspective, h.perspective, d.perspective, x), f(v.quaternion, h.quaternion, d.quaternion, x), l(E, v.translate, v.scale, v.skew, v.perspective, v.quaternion), true);
+            }
+            function b() {
+              return { translate: p(), scale: p(1), skew: p(), perspective: k(), quaternion: k() };
+            }
+            function p(E) {
+              return [E || 0, E || 0, E || 0];
+            }
+            function k() {
+              return [0, 0, 0, 1];
+            }
+          }, 7507: function(i, a) {
+            a.byteLength = d, a.toByteArray = _, a.fromByteArray = k;
+            for (var o = [], s = [], l = typeof Uint8Array != "undefined" ? Uint8Array : Array, u = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/", c = 0, f = u.length; c < f; ++c) o[c] = u[c], s[u.charCodeAt(c)] = c;
+            s[45] = 62, s[95] = 63;
+            function h(E) {
+              var T = E.length;
+              if (T % 4 > 0) throw new Error("Invalid string. Length must be a multiple of 4");
+              var L = E.indexOf("=");
+              L === -1 && (L = T);
+              var x = L === T ? 0 : 4 - L % 4;
+              return [L, x];
+            }
+            function d(E) {
+              var T = h(E), L = T[0], x = T[1];
+              return (L + x) * 3 / 4 - x;
+            }
+            function v(E, T, L) {
+              return (T + L) * 3 / 4 - L;
+            }
+            function _(E) {
+              var T, L = h(E), x = L[0], C = L[1], M = new l(v(E, x, C)), g = 0, P = C > 0 ? x - 4 : x, A;
+              for (A = 0; A < P; A += 4) T = s[E.charCodeAt(A)] << 18 | s[E.charCodeAt(A + 1)] << 12 | s[E.charCodeAt(A + 2)] << 6 | s[E.charCodeAt(A + 3)], M[g++] = T >> 16 & 255, M[g++] = T >> 8 & 255, M[g++] = T & 255;
+              return C === 2 && (T = s[E.charCodeAt(A)] << 2 | s[E.charCodeAt(A + 1)] >> 4, M[g++] = T & 255), C === 1 && (T = s[E.charCodeAt(A)] << 10 | s[E.charCodeAt(A + 1)] << 4 | s[E.charCodeAt(A + 2)] >> 2, M[g++] = T >> 8 & 255, M[g++] = T & 255), M;
+            }
+            function b(E) {
+              return o[E >> 18 & 63] + o[E >> 12 & 63] + o[E >> 6 & 63] + o[E & 63];
+            }
+            function p(E, T, L) {
+              for (var x, C = [], M = T; M < L; M += 3) x = (E[M] << 16 & 16711680) + (E[M + 1] << 8 & 65280) + (E[M + 2] & 255), C.push(b(x));
+              return C.join("");
+            }
+            function k(E) {
+              for (var T, L = E.length, x = L % 3, C = [], M = 16383, g = 0, P = L - x; g < P; g += M) C.push(p(E, g, g + M > P ? P : g + M));
+              return x === 1 ? (T = E[L - 1], C.push(o[T >> 2] + o[T << 4 & 63] + "==")) : x === 2 && (T = (E[L - 2] << 8) + E[L - 1], C.push(o[T >> 10] + o[T >> 4 & 63] + o[T << 2 & 63] + "=")), C.join("");
+            }
+          }, 7518: function(i, a, o) {
+            var s = o(1433);
+            function l(f, h, d, v, _, b) {
+              this.location = f, this.dimension = h, this.a = d, this.b = v, this.c = _, this.d = b;
+            }
+            l.prototype.bind = function(f) {
+              switch (this.dimension) {
+                case 1:
+                  f.vertexAttrib1f(this.location, this.a);
+                  break;
+                case 2:
+                  f.vertexAttrib2f(this.location, this.a, this.b);
+                  break;
+                case 3:
+                  f.vertexAttrib3f(this.location, this.a, this.b, this.c);
+                  break;
+                case 4:
+                  f.vertexAttrib4f(this.location, this.a, this.b, this.c, this.d);
+                  break;
+              }
+            };
+            function u(f, h, d) {
+              this.gl = f, this._ext = h, this.handle = d, this._attribs = [], this._useElements = false, this._elementsType = f.UNSIGNED_SHORT;
+            }
+            u.prototype.bind = function() {
+              this._ext.bindVertexArrayOES(this.handle);
+              for (var f = 0; f < this._attribs.length; ++f) this._attribs[f].bind(this.gl);
+            }, u.prototype.unbind = function() {
+              this._ext.bindVertexArrayOES(null);
+            }, u.prototype.dispose = function() {
+              this._ext.deleteVertexArrayOES(this.handle);
+            }, u.prototype.update = function(f, h, d) {
+              if (this.bind(), s(this.gl, h, f), this.unbind(), this._attribs.length = 0, f) for (var v = 0; v < f.length; ++v) {
+                var _ = f[v];
+                typeof _ == "number" ? this._attribs.push(new l(v, 1, _)) : Array.isArray(_) && this._attribs.push(new l(v, _.length, _[0], _[1], _[2], _[3]));
+              }
+              this._useElements = !!h, this._elementsType = d || this.gl.UNSIGNED_SHORT;
+            }, u.prototype.draw = function(f, h, d) {
+              d = d || 0;
+              var v = this.gl;
+              this._useElements ? v.drawElements(f, h, this._elementsType, d) : v.drawArrays(f, d, h);
+            };
+            function c(f, h) {
+              return new u(f, h, h.createVertexArrayOES());
+            }
+            i.exports = c;
+          }, 7520: function(i, a, o) {
+            var s = o(9507);
+            function l() {
+              var u = false;
+              try {
+                var c = Object.defineProperty({}, "passive", { get: function() {
+                  u = true;
+                } });
+                window.addEventListener("test", null, c), window.removeEventListener("test", null, c);
+              } catch (f) {
+                u = false;
+              }
+              return u;
+            }
+            i.exports = s && l();
+          }, 7536: function(i) {
+            i.exports = a;
+            function a() {
+              var o = new Float32Array(4);
+              return o[0] = 0, o[1] = 0, o[2] = 0, o[3] = 0, o;
+            }
+          }, 7608: function(i) {
+            i.exports = a;
+            function a(o, s) {
+              var l = s[0], u = s[1], c = s[2], f = s[3], h = s[4], d = s[5], v = s[6], _ = s[7], b = s[8], p = s[9], k = s[10], E = s[11], T = s[12], L = s[13], x = s[14], C = s[15], M = l * d - u * h, g = l * v - c * h, P = l * _ - f * h, A = u * v - c * d, z = u * _ - f * d, O = c * _ - f * v, U = b * L - p * T, G = b * x - k * T, Z = b * C - E * T, j = p * x - k * L, N = p * C - E * L, H = k * C - E * x, re = M * H - g * N + P * j + A * Z - z * G + O * U;
+              return re ? (re = 1 / re, o[0] = (d * H - v * N + _ * j) * re, o[1] = (c * N - u * H - f * j) * re, o[2] = (L * O - x * z + C * A) * re, o[3] = (k * z - p * O - E * A) * re, o[4] = (v * Z - h * H - _ * G) * re, o[5] = (l * H - c * Z + f * G) * re, o[6] = (x * P - T * O - C * g) * re, o[7] = (b * O - k * P + E * g) * re, o[8] = (h * N - d * Z + _ * U) * re, o[9] = (u * Z - l * N - f * U) * re, o[10] = (T * z - L * P + C * M) * re, o[11] = (p * P - b * z - E * M) * re, o[12] = (d * G - h * j - v * U) * re, o[13] = (l * j - u * G + c * U) * re, o[14] = (L * g - T * A - x * M) * re, o[15] = (b * A - p * g + k * M) * re, o) : null;
+            }
+          }, 7626: function(i, a, o) {
+            var s = o(2642), l = o(9346);
+            i.exports = d;
+            function u(v, _) {
+              for (var b = [0, 0, 0, 0], p = 0; p < 4; ++p) for (var k = 0; k < 4; ++k) b[k] += v[4 * p + k] * _[p];
+              return b;
+            }
+            function c(v, _, b, p, k) {
+              for (var E = u(p, u(b, u(_, [v[0], v[1], v[2], 1]))), T = 0; T < 3; ++T) E[T] /= E[3];
+              return [0.5 * k[0] * (1 + E[0]), 0.5 * k[1] * (1 - E[1])];
+            }
+            function f(v, _) {
+              if (v.length === 2) {
+                for (var b = 0, p = 0, k = 0; k < 2; ++k) b += Math.pow(_[k] - v[0][k], 2), p += Math.pow(_[k] - v[1][k], 2);
+                return b = Math.sqrt(b), p = Math.sqrt(p), b + p < 1e-6 ? [1, 0] : [p / (b + p), b / (p + b)];
+              } else if (v.length === 3) {
+                var E = [0, 0];
+                return l(v[0], v[1], v[2], _, E), s(v, E);
+              }
+              return [];
+            }
+            function h(v, _) {
+              for (var b = [0, 0, 0], p = 0; p < v.length; ++p) for (var k = v[p], E = _[p], T = 0; T < 3; ++T) b[T] += E * k[T];
+              return b;
+            }
+            function d(v, _, b, p, k, E) {
+              if (v.length === 1) return [0, v[0].slice()];
+              for (var T = new Array(v.length), L = 0; L < v.length; ++L) T[L] = c(v[L], b, p, k, E);
+              for (var x = 0, C = 1 / 0, L = 0; L < T.length; ++L) {
+                for (var M = 0, g = 0; g < 2; ++g) M += Math.pow(T[L][g] - _[g], 2);
+                M < C && (C = M, x = L);
+              }
+              for (var P = f(T, _), A = 0, L = 0; L < 3; ++L) {
+                if (P[L] < -1e-3 || P[L] > 1.0001) return null;
+                A += P[L];
+              }
+              return Math.abs(A - 1) > 1e-3 ? null : [x, h(v, P), P];
+            }
+          }, 7636: function(i) {
+            i.exports = a;
+            function a(o, s) {
+              s = s || 1;
+              var l = Math.random() * 2 * Math.PI, u = Math.random() * 2 - 1, c = Math.sqrt(1 - u * u) * s;
+              return o[0] = Math.cos(l) * c, o[1] = Math.sin(l) * c, o[2] = u * s, o;
+            }
+          }, 7640: function(i, a, o) {
+            var s = o(1888);
+            function l(_) {
+              switch (_) {
+                case "uint32":
+                  return [s.mallocUint32, s.freeUint32];
+                default:
+                  return null;
+              }
+            }
+            var u = { "uint32,1,0": function(_, b) {
+              return function(k, E, T, L, x, C, M, g, P, A, z) {
+                var O, U, G, Z = k * x + L, j, N = _(g), H, re, oe, _e;
+                for (O = k + 1; O <= E; ++O) {
+                  for (U = O, Z += x, G = Z, H = 0, re = Z, j = 0; j < g; ++j) N[H++] = T[re], re += P;
+                  e: for (; U-- > k; ) {
+                    H = 0, re = G - x;
+                    t: for (j = 0; j < g; ++j) {
+                      if (oe = T[re], _e = N[H], oe < _e) break e;
+                      if (oe > _e) break t;
+                      re += A, H += z;
+                    }
+                    for (H = G, re = G - x, j = 0; j < g; ++j) T[H] = T[re], H += P, re += P;
+                    G -= x;
+                  }
+                  for (H = G, re = 0, j = 0; j < g; ++j) T[H] = N[re++], H += P;
+                }
+                b(N);
+              };
+            } };
+            function c(_, b) {
+              var p = l(b), k = [b, _].join(","), E = u[k];
+              return p ? E(p[0], p[1]) : E();
+            }
+            var f = { "uint32,1,0": function(_, b, p) {
+              return function k(E, T, L, x, C, M, g, P, A, z, O) {
+                var U = (T - E + 1) / 6 | 0, G = E + U, Z = T - U, j = E + T >> 1, N = j - U, H = j + U, re = G, oe = N, _e = j, Ce = H, Le = Z, ge = E + 1, ie = T - 1, Se = true, Ee, Ae, Be, Pe, me, De, ce, je, lt, pt = 0, Vt = 0, ot = 0, ut, Wt, Nt, $t, sr, Tr, fr, $e, St, Qt, Gt, _t, It, mt, er, lr, wr = P, Lr = b(wr), ti = b(wr);
+                Wt = C * re, Nt = C * oe, lr = x;
+                e: for (ut = 0; ut < P; ++ut) {
+                  if (ce = Wt + lr, je = Nt + lr, ot = L[ce] - L[je], ot > 0) {
+                    Ae = re, re = oe, oe = Ae;
+                    break e;
+                  }
+                  if (ot < 0) break e;
+                  lr += z;
+                }
+                Wt = C * Ce, Nt = C * Le, lr = x;
+                e: for (ut = 0; ut < P; ++ut) {
+                  if (ce = Wt + lr, je = Nt + lr, ot = L[ce] - L[je], ot > 0) {
+                    Ae = Ce, Ce = Le, Le = Ae;
+                    break e;
+                  }
+                  if (ot < 0) break e;
+                  lr += z;
+                }
+                Wt = C * re, Nt = C * _e, lr = x;
+                e: for (ut = 0; ut < P; ++ut) {
+                  if (ce = Wt + lr, je = Nt + lr, ot = L[ce] - L[je], ot > 0) {
+                    Ae = re, re = _e, _e = Ae;
+                    break e;
+                  }
+                  if (ot < 0) break e;
+                  lr += z;
+                }
+                Wt = C * oe, Nt = C * _e, lr = x;
+                e: for (ut = 0; ut < P; ++ut) {
+                  if (ce = Wt + lr, je = Nt + lr, ot = L[ce] - L[je], ot > 0) {
+                    Ae = oe, oe = _e, _e = Ae;
+                    break e;
+                  }
+                  if (ot < 0) break e;
+                  lr += z;
+                }
+                Wt = C * re, Nt = C * Ce, lr = x;
+                e: for (ut = 0; ut < P; ++ut) {
+                  if (ce = Wt + lr, je = Nt + lr, ot = L[ce] - L[je], ot > 0) {
+                    Ae = re, re = Ce, Ce = Ae;
+                    break e;
+                  }
+                  if (ot < 0) break e;
+                  lr += z;
+                }
+                Wt = C * _e, Nt = C * Ce, lr = x;
+                e: for (ut = 0; ut < P; ++ut) {
+                  if (ce = Wt + lr, je = Nt + lr, ot = L[ce] - L[je], ot > 0) {
+                    Ae = _e, _e = Ce, Ce = Ae;
+                    break e;
+                  }
+                  if (ot < 0) break e;
+                  lr += z;
+                }
+                Wt = C * oe, Nt = C * Le, lr = x;
+                e: for (ut = 0; ut < P; ++ut) {
+                  if (ce = Wt + lr, je = Nt + lr, ot = L[ce] - L[je], ot > 0) {
+                    Ae = oe, oe = Le, Le = Ae;
+                    break e;
+                  }
+                  if (ot < 0) break e;
+                  lr += z;
+                }
+                Wt = C * oe, Nt = C * _e, lr = x;
+                e: for (ut = 0; ut < P; ++ut) {
+                  if (ce = Wt + lr, je = Nt + lr, ot = L[ce] - L[je], ot > 0) {
+                    Ae = oe, oe = _e, _e = Ae;
+                    break e;
+                  }
+                  if (ot < 0) break e;
+                  lr += z;
+                }
+                Wt = C * Ce, Nt = C * Le, lr = x;
+                e: for (ut = 0; ut < P; ++ut) {
+                  if (ce = Wt + lr, je = Nt + lr, ot = L[ce] - L[je], ot > 0) {
+                    Ae = Ce, Ce = Le, Le = Ae;
+                    break e;
+                  }
+                  if (ot < 0) break e;
+                  lr += z;
+                }
+                for (Wt = C * re, Nt = C * oe, $t = C * _e, sr = C * Ce, Tr = C * Le, fr = C * G, $e = C * j, St = C * Z, er = 0, lr = x, ut = 0; ut < P; ++ut) ce = Wt + lr, je = Nt + lr, lt = $t + lr, Qt = sr + lr, Gt = Tr + lr, _t = fr + lr, It = $e + lr, mt = St + lr, Lr[er] = L[je], ti[er] = L[Qt], Se = Se && Lr[er] === ti[er], Be = L[ce], Pe = L[lt], me = L[Gt], L[_t] = Be, L[It] = Pe, L[mt] = me, ++er, lr += A;
+                for (Wt = C * N, Nt = C * E, lr = x, ut = 0; ut < P; ++ut) ce = Wt + lr, je = Nt + lr, L[ce] = L[je], lr += A;
+                for (Wt = C * H, Nt = C * T, lr = x, ut = 0; ut < P; ++ut) ce = Wt + lr, je = Nt + lr, L[ce] = L[je], lr += A;
+                if (Se) for (De = ge; De <= ie; ++De) {
+                  ce = x + De * C, er = 0;
+                  e: for (ut = 0; ut < P; ++ut) {
+                    if (ot = L[ce] - Lr[er], ot !== 0) break e;
+                    er += O, ce += z;
+                  }
+                  if (ot !== 0) if (ot < 0) {
+                    if (De !== ge) for (Wt = C * De, Nt = C * ge, lr = x, ut = 0; ut < P; ++ut) ce = Wt + lr, je = Nt + lr, Ee = L[ce], L[ce] = L[je], L[je] = Ee, lr += A;
+                    ++ge;
+                  } else for (; ; ) {
+                    ce = x + ie * C, er = 0;
+                    e: for (ut = 0; ut < P; ++ut) {
+                      if (ot = L[ce] - Lr[er], ot !== 0) break e;
+                      er += O, ce += z;
+                    }
+                    if (ot > 0) ie--;
+                    else if (ot < 0) {
+                      for (Wt = C * De, Nt = C * ge, $t = C * ie, lr = x, ut = 0; ut < P; ++ut) ce = Wt + lr, je = Nt + lr, lt = $t + lr, Ee = L[ce], L[ce] = L[je], L[je] = L[lt], L[lt] = Ee, lr += A;
+                      ++ge, --ie;
+                      break;
+                    } else {
+                      for (Wt = C * De, Nt = C * ie, lr = x, ut = 0; ut < P; ++ut) ce = Wt + lr, je = Nt + lr, Ee = L[ce], L[ce] = L[je], L[je] = Ee, lr += A;
+                      --ie;
+                      break;
+                    }
+                  }
+                }
+                else for (De = ge; De <= ie; ++De) {
+                  ce = x + De * C, er = 0;
+                  e: for (ut = 0; ut < P; ++ut) {
+                    if (pt = L[ce] - Lr[er], pt !== 0) break e;
+                    er += O, ce += z;
+                  }
+                  if (pt < 0) {
+                    if (De !== ge) for (Wt = C * De, Nt = C * ge, lr = x, ut = 0; ut < P; ++ut) ce = Wt + lr, je = Nt + lr, Ee = L[ce], L[ce] = L[je], L[je] = Ee, lr += A;
+                    ++ge;
+                  } else {
+                    ce = x + De * C, er = 0;
+                    e: for (ut = 0; ut < P; ++ut) {
+                      if (Vt = L[ce] - ti[er], Vt !== 0) break e;
+                      er += O, ce += z;
+                    }
+                    if (Vt > 0) for (; ; ) {
+                      ce = x + ie * C, er = 0;
+                      e: for (ut = 0; ut < P; ++ut) {
+                        if (ot = L[ce] - ti[er], ot !== 0) break e;
+                        er += O, ce += z;
+                      }
+                      if (ot > 0) {
+                        if (--ie < De) break;
+                        continue;
+                      } else {
+                        ce = x + ie * C, er = 0;
+                        e: for (ut = 0; ut < P; ++ut) {
+                          if (ot = L[ce] - Lr[er], ot !== 0) break e;
+                          er += O, ce += z;
+                        }
+                        if (ot < 0) {
+                          for (Wt = C * De, Nt = C * ge, $t = C * ie, lr = x, ut = 0; ut < P; ++ut) ce = Wt + lr, je = Nt + lr, lt = $t + lr, Ee = L[ce], L[ce] = L[je], L[je] = L[lt], L[lt] = Ee, lr += A;
+                          ++ge, --ie;
+                        } else {
+                          for (Wt = C * De, Nt = C * ie, lr = x, ut = 0; ut < P; ++ut) ce = Wt + lr, je = Nt + lr, Ee = L[ce], L[ce] = L[je], L[je] = Ee, lr += A;
+                          --ie;
+                        }
+                        break;
+                      }
+                    }
+                  }
+                }
+                for (Wt = C * E, Nt = C * (ge - 1), er = 0, lr = x, ut = 0; ut < P; ++ut) ce = Wt + lr, je = Nt + lr, L[ce] = L[je], L[je] = Lr[er], ++er, lr += A;
+                for (Wt = C * T, Nt = C * (ie + 1), er = 0, lr = x, ut = 0; ut < P; ++ut) ce = Wt + lr, je = Nt + lr, L[ce] = L[je], L[je] = ti[er], ++er, lr += A;
+                if (ge - 2 - E <= 32 ? _(E, ge - 2, L, x, C, M, g, P, A, z, O) : k(E, ge - 2, L, x, C, M, g, P, A, z, O), T - (ie + 2) <= 32 ? _(ie + 2, T, L, x, C, M, g, P, A, z, O) : k(ie + 2, T, L, x, C, M, g, P, A, z, O), Se) {
+                  p(Lr), p(ti);
+                  return;
+                }
+                if (ge < G && ie > Z) {
+                  e: for (; ; ) {
+                    for (ce = x + ge * C, er = 0, lr = x, ut = 0; ut < P; ++ut) {
+                      if (L[ce] !== Lr[er]) break e;
+                      ++er, ce += A;
+                    }
+                    ++ge;
+                  }
+                  e: for (; ; ) {
+                    for (ce = x + ie * C, er = 0, lr = x, ut = 0; ut < P; ++ut) {
+                      if (L[ce] !== ti[er]) break e;
+                      ++er, ce += A;
+                    }
+                    --ie;
+                  }
+                  for (De = ge; De <= ie; ++De) {
+                    ce = x + De * C, er = 0;
+                    e: for (ut = 0; ut < P; ++ut) {
+                      if (pt = L[ce] - Lr[er], pt !== 0) break e;
+                      er += O, ce += z;
+                    }
+                    if (pt === 0) {
+                      if (De !== ge) for (Wt = C * De, Nt = C * ge, lr = x, ut = 0; ut < P; ++ut) ce = Wt + lr, je = Nt + lr, Ee = L[ce], L[ce] = L[je], L[je] = Ee, lr += A;
+                      ++ge;
+                    } else {
+                      ce = x + De * C, er = 0;
+                      e: for (ut = 0; ut < P; ++ut) {
+                        if (Vt = L[ce] - ti[er], Vt !== 0) break e;
+                        er += O, ce += z;
+                      }
+                      if (Vt === 0) for (; ; ) {
+                        ce = x + ie * C, er = 0;
+                        e: for (ut = 0; ut < P; ++ut) {
+                          if (ot = L[ce] - ti[er], ot !== 0) break e;
+                          er += O, ce += z;
+                        }
+                        if (ot === 0) {
+                          if (--ie < De) break;
+                          continue;
+                        } else {
+                          ce = x + ie * C, er = 0;
+                          e: for (ut = 0; ut < P; ++ut) {
+                            if (ot = L[ce] - Lr[er], ot !== 0) break e;
+                            er += O, ce += z;
+                          }
+                          if (ot < 0) {
+                            for (Wt = C * De, Nt = C * ge, $t = C * ie, lr = x, ut = 0; ut < P; ++ut) ce = Wt + lr, je = Nt + lr, lt = $t + lr, Ee = L[ce], L[ce] = L[je], L[je] = L[lt], L[lt] = Ee, lr += A;
+                            ++ge, --ie;
+                          } else {
+                            for (Wt = C * De, Nt = C * ie, lr = x, ut = 0; ut < P; ++ut) ce = Wt + lr, je = Nt + lr, Ee = L[ce], L[ce] = L[je], L[je] = Ee, lr += A;
+                            --ie;
+                          }
+                          break;
+                        }
+                      }
+                    }
+                  }
+                }
+                p(Lr), p(ti), ie - ge <= 32 ? _(ge, ie, L, x, C, M, g, P, A, z, O) : k(ge, ie, L, x, C, M, g, P, A, z, O);
+              };
+            } };
+            function h(_, b, p) {
+              var k = l(b), E = [b, _].join(","), T = f[E];
+              return _.length > 1 && k ? T(p, k[0], k[1]) : T(p);
+            }
+            var d = { "uint32,1,0": function(_, b) {
+              return function(p) {
+                var k = p.data, E = p.offset | 0, T = p.shape, L = p.stride, x = L[0] | 0, C = T[0] | 0, M = L[1] | 0, g = T[1] | 0, P = M, A = M, z = 1;
+                C <= 32 ? _(0, C - 1, k, E, x, M, C, g, P, A, z) : b(0, C - 1, k, E, x, M, C, g, P, A, z);
+              };
+            } };
+            function v(_, b) {
+              var p = [b, _].join(","), k = d[p], E = c(_, b), T = h(_, b, E);
+              return k(E, T);
+            }
+            i.exports = v;
+          }, 7642: function(i, a, o) {
+            var s = o(8954), l = o(1682);
+            i.exports = h;
+            function u(d, v) {
+              this.point = d, this.index = v;
+            }
+            function c(d, v) {
+              for (var _ = d.point, b = v.point, p = _.length, k = 0; k < p; ++k) {
+                var E = b[k] - _[k];
+                if (E) return E;
+              }
+              return 0;
+            }
+            function f(d, v, _) {
+              if (d === 1) return _ ? [[-1, 0]] : [];
+              var b = v.map(function(L, x) {
+                return [L[0], x];
+              });
+              b.sort(function(L, x) {
+                return L[0] - x[0];
+              });
+              for (var p = new Array(d - 1), k = 1; k < d; ++k) {
+                var E = b[k - 1], T = b[k];
+                p[k - 1] = [E[1], T[1]];
+              }
+              return _ && p.push([-1, p[0][1]], [p[d - 1][1], -1]), p;
+            }
+            function h(d, v) {
+              var _ = d.length;
+              if (_ === 0) return [];
+              var b = d[0].length;
+              if (b < 1) return [];
+              if (b === 1) return f(_, d, v);
+              for (var p = new Array(_), k = 1, E = 0; E < _; ++E) {
+                for (var T = d[E], L = new Array(b + 1), x = 0, C = 0; C < b; ++C) {
+                  var M = T[C];
+                  L[C] = M, x += M * M;
+                }
+                L[b] = x, p[E] = new u(L, E), k = Math.max(x, k);
+              }
+              l(p, c), _ = p.length;
+              for (var g = new Array(_ + b + 1), P = new Array(_ + b + 1), A = (b + 1) * (b + 1) * k, z = new Array(b + 1), E = 0; E <= b; ++E) z[E] = 0;
+              z[b] = A, g[0] = z.slice(), P[0] = -1;
+              for (var E = 0; E <= b; ++E) {
+                var L = z.slice();
+                L[E] = 1, g[E + 1] = L, P[E + 1] = -1;
+              }
+              for (var E = 0; E < _; ++E) {
+                var O = p[E];
+                g[E + b + 1] = O.point, P[E + b + 1] = O.index;
+              }
+              var U = s(g, false);
+              if (v ? U = U.filter(function(G) {
+                for (var Z = 0, j = 0; j <= b; ++j) {
+                  var N = P[G[j]];
+                  if (N < 0 && ++Z >= 2) return false;
+                  G[j] = N;
+                }
+                return true;
+              }) : U = U.filter(function(G) {
+                for (var Z = 0; Z <= b; ++Z) {
+                  var j = P[G[Z]];
+                  if (j < 0) return false;
+                  G[Z] = j;
+                }
+                return true;
+              }), b & 1) for (var E = 0; E < U.length; ++E) {
+                var O = U[E], L = O[0];
+                O[0] = O[1], O[1] = L;
+              }
+              return U;
+            }
+          }, 7656: function(i) {
+            i.exports = a;
+            function a(o, s, l) {
+              var u = l[0], c = l[1], f = l[2], h, d, v, _, b, p, k, E, T, L, x, C;
+              return s === o ? (o[12] = s[0] * u + s[4] * c + s[8] * f + s[12], o[13] = s[1] * u + s[5] * c + s[9] * f + s[13], o[14] = s[2] * u + s[6] * c + s[10] * f + s[14], o[15] = s[3] * u + s[7] * c + s[11] * f + s[15]) : (h = s[0], d = s[1], v = s[2], _ = s[3], b = s[4], p = s[5], k = s[6], E = s[7], T = s[8], L = s[9], x = s[10], C = s[11], o[0] = h, o[1] = d, o[2] = v, o[3] = _, o[4] = b, o[5] = p, o[6] = k, o[7] = E, o[8] = T, o[9] = L, o[10] = x, o[11] = C, o[12] = h * u + b * c + T * f + s[12], o[13] = d * u + p * c + L * f + s[13], o[14] = v * u + k * c + x * f + s[14], o[15] = _ * u + E * c + C * f + s[15]), o;
+            }
+          }, 7718: function(i, a, o) {
+            i.exports = O, i.exports.processPixels = z;
+            var s = o(3711), l = o(9618), u = o(5878), c = o(332), f = o(2538), h = o(2095), d = "b", v = "b|", _ = "i", b = "i|", p = "sup", k = "+", E = "+1", T = "sub", L = "-", x = "-1";
+            function C(U, G, Z, j) {
+              for (var N = "<" + U + ">", H = "</" + U + ">", re = N.length, oe = H.length, _e = G[0] === k || G[0] === L, Ce = 0, Le = -oe; Ce > -1 && (Ce = Z.indexOf(N, Ce), !(Ce === -1 || (Le = Z.indexOf(H, Ce + re), Le === -1) || Le <= Ce)); ) {
+                for (var ge = Ce; ge < Le + oe; ++ge) if (ge < Ce + re || ge >= Le) j[ge] = null, Z = Z.substr(0, ge) + " " + Z.substr(ge + 1);
+                else if (j[ge] !== null) {
+                  var ie = j[ge].indexOf(G[0]);
+                  ie === -1 ? j[ge] += G : _e && (j[ge] = j[ge].substr(0, ie + 1) + (1 + parseInt(j[ge][ie + 1])) + j[ge].substr(ie + 2));
+                }
+                var Se = Ce + re, Ee = Z.substr(Se, Le - Se), Ae = Ee.indexOf(N);
+                Ae !== -1 ? Ce = Ae : Ce = Le + oe;
+              }
+              return j;
+            }
+            function M(U, G, Z) {
+              for (var j = G.textAlign || "start", N = G.textBaseline || "alphabetic", H = [1 << 30, 1 << 30], re = [0, 0], oe = U.length, _e = 0; _e < oe; ++_e) for (var Ce = U[_e], Le = 0; Le < 2; ++Le) H[Le] = Math.min(H[Le], Ce[Le]) | 0, re[Le] = Math.max(re[Le], Ce[Le]) | 0;
+              var ge = 0;
+              switch (j) {
+                case "center":
+                  ge = -0.5 * (H[0] + re[0]);
+                  break;
+                case "right":
+                case "end":
+                  ge = -re[0];
+                  break;
+                case "left":
+                case "start":
+                  ge = -H[0];
+                  break;
+                default:
+                  throw new Error("vectorize-text: Unrecognized textAlign: '" + j + "'");
+              }
+              var ie = 0;
+              switch (N) {
+                case "hanging":
+                case "top":
+                  ie = -H[1];
+                  break;
+                case "middle":
+                  ie = -0.5 * (H[1] + re[1]);
+                  break;
+                case "alphabetic":
+                case "ideographic":
+                  ie = -3 * Z;
+                  break;
+                case "bottom":
+                  ie = -re[1];
+                  break;
+                default:
+                  throw new Error("vectorize-text: Unrecoginized textBaseline: '" + N + "'");
+              }
+              var Se = 1 / Z;
+              return "lineHeight" in G ? Se *= +G.lineHeight : "width" in G ? Se = G.width / (re[0] - H[0]) : "height" in G && (Se = G.height / (re[1] - H[1])), U.map(function(Ee) {
+                return [Se * (Ee[0] + ge), Se * (Ee[1] + ie)];
+              });
+            }
+            function g(U, G, Z, j, N, H) {
+              Z = Z.replace(/\n/g, ""), H.breaklines === true ? Z = Z.replace(/\<br\>/g, `
+`) : Z = Z.replace(/\<br\>/g, " ");
+              var re = "", oe = [];
+              for (me = 0; me < Z.length; ++me) oe[me] = re;
+              H.bolds === true && (oe = C(d, v, Z, oe)), H.italics === true && (oe = C(_, b, Z, oe)), H.superscripts === true && (oe = C(p, E, Z, oe)), H.subscripts === true && (oe = C(T, x, Z, oe));
+              var _e = [], Ce = "";
+              for (me = 0; me < Z.length; ++me) oe[me] !== null && (Ce += Z[me], _e.push(oe[me]));
+              var Le = Ce.split(`
+`), ge = Le.length, ie = Math.round(N * j), Se = j, Ee = j * 2, Ae = 0, Be = ge * ie + Ee;
+              U.height < Be && (U.height = Be), G.fillStyle = "#000", G.fillRect(0, 0, U.width, U.height), G.fillStyle = "#fff";
+              var Pe, me, De, ce, je, lt = 0, pt = "";
+              function Vt() {
+                if (pt !== "") {
+                  var $e = G.measureText(pt).width;
+                  G.fillText(pt, Se + De, Ee + ce), De += $e;
+                }
+              }
+              function ot() {
+                return "" + Math.round(je) + "px ";
+              }
+              function ut($e, St) {
+                var Qt = "" + G.font;
+                if (H.subscripts === true) {
+                  var Gt = $e.indexOf(L), _t = St.indexOf(L), It = Gt > -1 ? parseInt($e[1 + Gt]) : 0, mt = _t > -1 ? parseInt(St[1 + _t]) : 0;
+                  It !== mt && (Qt = Qt.replace(ot(), "?px "), je *= Math.pow(0.75, mt - It), Qt = Qt.replace("?px ", ot())), ce += 0.25 * ie * (mt - It);
+                }
+                if (H.superscripts === true) {
+                  var er = $e.indexOf(k), lr = St.indexOf(k), wr = er > -1 ? parseInt($e[1 + er]) : 0, Lr = lr > -1 ? parseInt(St[1 + lr]) : 0;
+                  wr !== Lr && (Qt = Qt.replace(ot(), "?px "), je *= Math.pow(0.75, Lr - wr), Qt = Qt.replace("?px ", ot())), ce -= 0.25 * ie * (Lr - wr);
+                }
+                if (H.bolds === true) {
+                  var ti = $e.indexOf(v) > -1, Br = St.indexOf(v) > -1;
+                  !ti && Br && (Vr ? Qt = Qt.replace("italic ", "italic bold ") : Qt = "bold " + Qt), ti && !Br && (Qt = Qt.replace("bold ", ""));
+                }
+                if (H.italics === true) {
+                  var Vr = $e.indexOf(b) > -1, dt = St.indexOf(b) > -1;
+                  !Vr && dt && (Qt = "italic " + Qt), Vr && !dt && (Qt = Qt.replace("italic ", ""));
+                }
+                G.font = Qt;
+              }
+              for (Pe = 0; Pe < ge; ++Pe) {
+                var Wt = Le[Pe] + `
+`;
+                for (De = 0, ce = Pe * ie, je = j, pt = "", me = 0; me < Wt.length; ++me) {
+                  var Nt = me + lt < _e.length ? _e[me + lt] : _e[_e.length - 1];
+                  re === Nt ? pt += Wt[me] : (Vt(), pt = Wt[me], Nt !== void 0 && (ut(re, Nt), re = Nt));
+                }
+                Vt(), lt += Wt.length;
+                var $t = Math.round(De + 2 * Se) | 0;
+                Ae < $t && (Ae = $t);
+              }
+              var sr = Ae, Tr = Ee + ie * ge, fr = l(G.getImageData(0, 0, sr, Tr).data, [Tr, sr, 4]);
+              return fr.pick(-1, -1, 0).transpose(1, 0);
+            }
+            function P(U, G) {
+              var Z = s(U, 128);
+              return G ? u(Z.cells, Z.positions, 0.25) : { edges: Z.cells, positions: Z.positions };
+            }
+            function A(U, G, Z, j) {
+              var N = P(U, j), H = M(N.positions, G, Z), re = N.edges, oe = G.orientation === "ccw";
+              if (c(H, re), G.polygons || G.polygon || G.polyline) {
+                for (var _e = h(re, H), Ce = new Array(_e.length), Le = 0; Le < _e.length; ++Le) {
+                  for (var ge = _e[Le], ie = new Array(ge.length), Se = 0; Se < ge.length; ++Se) {
+                    for (var Ee = ge[Se], Ae = new Array(Ee.length), Be = 0; Be < Ee.length; ++Be) Ae[Be] = H[Ee[Be]].slice();
+                    oe && Ae.reverse(), ie[Se] = Ae;
+                  }
+                  Ce[Le] = ie;
+                }
+                return Ce;
+              } else return G.triangles || G.triangulate || G.triangle ? { cells: f(H, re, { delaunay: false, exterior: false, interior: true }), positions: H } : { edges: re, positions: H };
+            }
+            function z(U, G, Z) {
+              try {
+                return A(U, G, Z, true);
+              } catch (j) {
+              }
+              try {
+                return A(U, G, Z, false);
+              } catch (j) {
+              }
+              return G.polygons || G.polyline || G.polygon ? [] : G.triangles || G.triangulate || G.triangle ? { cells: [], positions: [] } : { edges: [], positions: [] };
+            }
+            function O(U, G, Z, j) {
+              var N = 64, H = 1.25, re = { breaklines: false, bolds: false, italics: false, subscripts: false, superscripts: false };
+              j && (j.size && j.size > 0 && (N = j.size), j.lineSpacing && j.lineSpacing > 0 && (H = j.lineSpacing), j.styletags && j.styletags.breaklines && (re.breaklines = !!j.styletags.breaklines), j.styletags && j.styletags.bolds && (re.bolds = !!j.styletags.bolds), j.styletags && j.styletags.italics && (re.italics = !!j.styletags.italics), j.styletags && j.styletags.subscripts && (re.subscripts = !!j.styletags.subscripts), j.styletags && j.styletags.superscripts && (re.superscripts = !!j.styletags.superscripts)), Z.font = [j.fontStyle, j.fontVariant, j.fontWeight, N + "px", j.font].filter(function(_e) {
+                return _e;
+              }).join(" "), Z.textAlign = "start", Z.textBaseline = "alphabetic", Z.direction = "ltr";
+              var oe = g(G, Z, U, N, H, re);
+              return z(oe, j, N);
+            }
+          }, 7721: function(i, a, o) {
+            var s = o(5716);
+            i.exports = l;
+            function l(u) {
+              return s(u[0]) * s(u[1]);
+            }
+          }, 7765: function(i, a, o) {
+            i.exports = p;
+            var s = o(9618), l = o(1888), u = o(446), c = o(1570);
+            function f(k) {
+              for (var E = k.length, T = 0, L = 0; L < E; ++L) T = Math.max(T, k[L].length) | 0;
+              return T - 1;
+            }
+            function h(k, E) {
+              for (var T = k.length, L = l.mallocUint8(T), x = 0; x < T; ++x) L[x] = k[x] < E | 0;
+              return L;
+            }
+            function d(k, E) {
+              for (var T = k.length, L = E * (E + 1) / 2 * T | 0, x = l.mallocUint32(L * 2), C = 0, M = 0; M < T; ++M) for (var g = k[M], E = g.length, P = 0; P < E; ++P) for (var A = 0; A < P; ++A) {
+                var z = g[A], O = g[P];
+                x[C++] = Math.min(z, O) | 0, x[C++] = Math.max(z, O) | 0;
+              }
+              var U = C / 2 | 0;
+              u(s(x, [U, 2]));
+              for (var G = 2, M = 2; M < C; M += 2) x[M - 2] === x[M] && x[M - 1] === x[M + 1] || (x[G++] = x[M], x[G++] = x[M + 1]);
+              return s(x, [G / 2 | 0, 2]);
+            }
+            function v(k, E, T, L) {
+              for (var x = k.data, C = k.shape[0], M = l.mallocDouble(C), g = 0, P = 0; P < C; ++P) {
+                var A = x[2 * P], z = x[2 * P + 1];
+                if (T[A] !== T[z]) {
+                  var O = E[A], U = E[z];
+                  x[2 * g] = A, x[2 * g + 1] = z, M[g++] = (U - L) / (U - O);
+                }
+              }
+              return k.shape[0] = g, s(M, [g]);
+            }
+            function _(k, E) {
+              var T = l.mallocInt32(E * 2), L = k.shape[0], x = k.data;
+              T[0] = 0;
+              for (var C = 0, M = 0; M < L; ++M) {
+                var g = x[2 * M];
+                if (g !== C) {
+                  for (T[2 * C + 1] = M; ++C < g; ) T[2 * C] = M, T[2 * C + 1] = M;
+                  T[2 * C] = M;
+                }
+              }
+              for (T[2 * C + 1] = L; ++C < E; ) T[2 * C] = T[2 * C + 1] = L;
+              return T;
+            }
+            function b(k) {
+              for (var E = k.shape[0] | 0, T = k.data, L = new Array(E), x = 0; x < E; ++x) L[x] = [T[2 * x], T[2 * x + 1]];
+              return L;
+            }
+            function p(k, E, T, L) {
+              T = T || 0, typeof L == "undefined" && (L = f(k));
+              var x = k.length;
+              if (x === 0 || L < 1) return { cells: [], vertexIds: [], vertexWeights: [] };
+              var C = h(E, +T), M = d(k, L), g = v(M, E, C, +T), P = _(M, E.length | 0), A = c(L)(k, M.data, P, C), z = b(M), O = [].slice.call(g.data, 0, g.shape[0]);
+              return l.free(C), l.free(M.data), l.free(g.data), l.free(P), { cells: A, vertexIds: z, vertexWeights: O };
+            }
+          }, 7766: function(i, a, o) {
+            var s = o(9618), l = o(5298), u = o(1888);
+            i.exports = g;
+            var c = null, f = null, h = null;
+            function d(P) {
+              c = [P.LINEAR, P.NEAREST_MIPMAP_LINEAR, P.LINEAR_MIPMAP_NEAREST, P.LINEAR_MIPMAP_NEAREST], f = [P.NEAREST, P.LINEAR, P.NEAREST_MIPMAP_NEAREST, P.NEAREST_MIPMAP_LINEAR, P.LINEAR_MIPMAP_NEAREST, P.LINEAR_MIPMAP_LINEAR], h = [P.REPEAT, P.CLAMP_TO_EDGE, P.MIRRORED_REPEAT];
+            }
+            function v(P) {
+              return typeof HTMLCanvasElement != "undefined" && P instanceof HTMLCanvasElement || typeof HTMLImageElement != "undefined" && P instanceof HTMLImageElement || typeof HTMLVideoElement != "undefined" && P instanceof HTMLVideoElement || typeof ImageData != "undefined" && P instanceof ImageData;
+            }
+            var _ = function(P, A) {
+              l.muls(P, A, 255);
+            };
+            function b(P, A, z) {
+              var O = P.gl, U = O.getParameter(O.MAX_TEXTURE_SIZE);
+              if (A < 0 || A > U || z < 0 || z > U) throw new Error("gl-texture2d: Invalid texture size");
+              return P._shape = [A, z], P.bind(), O.texImage2D(O.TEXTURE_2D, 0, P.format, A, z, 0, P.format, P.type, null), P._mipLevels = [0], P;
+            }
+            function p(P, A, z, O, U, G) {
+              this.gl = P, this.handle = A, this.format = U, this.type = G, this._shape = [z, O], this._mipLevels = [0], this._magFilter = P.NEAREST, this._minFilter = P.NEAREST, this._wrapS = P.CLAMP_TO_EDGE, this._wrapT = P.CLAMP_TO_EDGE, this._anisoSamples = 1;
+              var Z = this, j = [this._wrapS, this._wrapT];
+              Object.defineProperties(j, [{ get: function() {
+                return Z._wrapS;
+              }, set: function(H) {
+                return Z.wrapS = H;
+              } }, { get: function() {
+                return Z._wrapT;
+              }, set: function(H) {
+                return Z.wrapT = H;
+              } }]), this._wrapVector = j;
+              var N = [this._shape[0], this._shape[1]];
+              Object.defineProperties(N, [{ get: function() {
+                return Z._shape[0];
+              }, set: function(H) {
+                return Z.width = H;
+              } }, { get: function() {
+                return Z._shape[1];
+              }, set: function(H) {
+                return Z.height = H;
+              } }]), this._shapeVector = N;
+            }
+            var k = p.prototype;
+            Object.defineProperties(k, { minFilter: { get: function() {
+              return this._minFilter;
+            }, set: function(P) {
+              this.bind();
+              var A = this.gl;
+              if (this.type === A.FLOAT && c.indexOf(P) >= 0 && (A.getExtension("OES_texture_float_linear") || (P = A.NEAREST)), f.indexOf(P) < 0) throw new Error("gl-texture2d: Unknown filter mode " + P);
+              return A.texParameteri(A.TEXTURE_2D, A.TEXTURE_MIN_FILTER, P), this._minFilter = P;
+            } }, magFilter: { get: function() {
+              return this._magFilter;
+            }, set: function(P) {
+              this.bind();
+              var A = this.gl;
+              if (this.type === A.FLOAT && c.indexOf(P) >= 0 && (A.getExtension("OES_texture_float_linear") || (P = A.NEAREST)), f.indexOf(P) < 0) throw new Error("gl-texture2d: Unknown filter mode " + P);
+              return A.texParameteri(A.TEXTURE_2D, A.TEXTURE_MAG_FILTER, P), this._magFilter = P;
+            } }, mipSamples: { get: function() {
+              return this._anisoSamples;
+            }, set: function(P) {
+              var A = this._anisoSamples;
+              if (this._anisoSamples = Math.max(P, 1) | 0, A !== this._anisoSamples) {
+                var z = this.gl.getExtension("EXT_texture_filter_anisotropic");
+                z && this.gl.texParameterf(this.gl.TEXTURE_2D, z.TEXTURE_MAX_ANISOTROPY_EXT, this._anisoSamples);
+              }
+              return this._anisoSamples;
+            } }, wrapS: { get: function() {
+              return this._wrapS;
+            }, set: function(P) {
+              if (this.bind(), h.indexOf(P) < 0) throw new Error("gl-texture2d: Unknown wrap mode " + P);
+              return this.gl.texParameteri(this.gl.TEXTURE_2D, this.gl.TEXTURE_WRAP_S, P), this._wrapS = P;
+            } }, wrapT: { get: function() {
+              return this._wrapT;
+            }, set: function(P) {
+              if (this.bind(), h.indexOf(P) < 0) throw new Error("gl-texture2d: Unknown wrap mode " + P);
+              return this.gl.texParameteri(this.gl.TEXTURE_2D, this.gl.TEXTURE_WRAP_T, P), this._wrapT = P;
+            } }, wrap: { get: function() {
+              return this._wrapVector;
+            }, set: function(P) {
+              if (Array.isArray(P) || (P = [P, P]), P.length !== 2) throw new Error("gl-texture2d: Must specify wrap mode for rows and columns");
+              for (var A = 0; A < 2; ++A) if (h.indexOf(P[A]) < 0) throw new Error("gl-texture2d: Unknown wrap mode " + P);
+              this._wrapS = P[0], this._wrapT = P[1];
+              var z = this.gl;
+              return this.bind(), z.texParameteri(z.TEXTURE_2D, z.TEXTURE_WRAP_S, this._wrapS), z.texParameteri(z.TEXTURE_2D, z.TEXTURE_WRAP_T, this._wrapT), P;
+            } }, shape: { get: function() {
+              return this._shapeVector;
+            }, set: function(P) {
+              if (!Array.isArray(P)) P = [P | 0, P | 0];
+              else if (P.length !== 2) throw new Error("gl-texture2d: Invalid texture shape");
+              return b(this, P[0] | 0, P[1] | 0), [P[0] | 0, P[1] | 0];
+            } }, width: { get: function() {
+              return this._shape[0];
+            }, set: function(P) {
+              return P = P | 0, b(this, P, this._shape[1]), P;
+            } }, height: { get: function() {
+              return this._shape[1];
+            }, set: function(P) {
+              return P = P | 0, b(this, this._shape[0], P), P;
+            } } }), k.bind = function(P) {
+              var A = this.gl;
+              return P !== void 0 && A.activeTexture(A.TEXTURE0 + (P | 0)), A.bindTexture(A.TEXTURE_2D, this.handle), P !== void 0 ? P | 0 : A.getParameter(A.ACTIVE_TEXTURE) - A.TEXTURE0;
+            }, k.dispose = function() {
+              this.gl.deleteTexture(this.handle);
+            }, k.generateMipmap = function() {
+              this.bind(), this.gl.generateMipmap(this.gl.TEXTURE_2D);
+              for (var P = Math.min(this._shape[0], this._shape[1]), A = 0; P > 0; ++A, P >>>= 1) this._mipLevels.indexOf(A) < 0 && this._mipLevels.push(A);
+            }, k.setPixels = function(P, A, z, O) {
+              var U = this.gl;
+              this.bind(), Array.isArray(A) ? (O = z, z = A[1] | 0, A = A[0] | 0) : (A = A || 0, z = z || 0), O = O || 0;
+              var G = v(P) ? P : P.raw;
+              if (G) {
+                var Z = this._mipLevels.indexOf(O) < 0;
+                Z ? (U.texImage2D(U.TEXTURE_2D, 0, this.format, this.format, this.type, G), this._mipLevels.push(O)) : U.texSubImage2D(U.TEXTURE_2D, O, A, z, this.format, this.type, G);
+              } else if (P.shape && P.stride && P.data) {
+                if (P.shape.length < 2 || A + P.shape[1] > this._shape[1] >>> O || z + P.shape[0] > this._shape[0] >>> O || A < 0 || z < 0) throw new Error("gl-texture2d: Texture dimensions are out of bounds");
+                T(U, A, z, O, this.format, this.type, this._mipLevels, P);
+              } else throw new Error("gl-texture2d: Unsupported data type");
+            };
+            function E(P, A) {
+              return P.length === 3 ? A[2] === 1 && A[1] === P[0] * P[2] && A[0] === P[2] : A[0] === 1 && A[1] === P[0];
+            }
+            function T(P, A, z, O, U, G, Z, j) {
+              var N = j.dtype, H = j.shape.slice();
+              if (H.length < 2 || H.length > 3) throw new Error("gl-texture2d: Invalid ndarray, must be 2d or 3d");
+              var re = 0, oe = 0, _e = E(H, j.stride.slice());
+              N === "float32" ? re = P.FLOAT : N === "float64" ? (re = P.FLOAT, _e = false, N = "float32") : N === "uint8" ? re = P.UNSIGNED_BYTE : (re = P.UNSIGNED_BYTE, _e = false, N = "uint8");
+              if (H.length === 2) oe = P.LUMINANCE, H = [H[0], H[1], 1], j = s(j.data, H, [j.stride[0], j.stride[1], 1], j.offset);
+              else if (H.length === 3) {
+                if (H[2] === 1) oe = P.ALPHA;
+                else if (H[2] === 2) oe = P.LUMINANCE_ALPHA;
+                else if (H[2] === 3) oe = P.RGB;
+                else if (H[2] === 4) oe = P.RGBA;
+                else throw new Error("gl-texture2d: Invalid shape for pixel coords");
+                H[2];
+              } else throw new Error("gl-texture2d: Invalid shape for texture");
+              if ((oe === P.LUMINANCE || oe === P.ALPHA) && (U === P.LUMINANCE || U === P.ALPHA) && (oe = U), oe !== U) throw new Error("gl-texture2d: Incompatible texture format for setPixels");
+              var Le = j.size, ge = Z.indexOf(O) < 0;
+              if (ge && Z.push(O), re === G && _e) j.offset === 0 && j.data.length === Le ? ge ? P.texImage2D(P.TEXTURE_2D, O, U, H[0], H[1], 0, U, G, j.data) : P.texSubImage2D(P.TEXTURE_2D, O, A, z, H[0], H[1], U, G, j.data) : ge ? P.texImage2D(P.TEXTURE_2D, O, U, H[0], H[1], 0, U, G, j.data.subarray(j.offset, j.offset + Le)) : P.texSubImage2D(P.TEXTURE_2D, O, A, z, H[0], H[1], U, G, j.data.subarray(j.offset, j.offset + Le));
+              else {
+                var ie;
+                G === P.FLOAT ? ie = u.mallocFloat32(Le) : ie = u.mallocUint8(Le);
+                var Se = s(ie, H, [H[2], H[2] * H[0], 1]);
+                re === P.FLOAT && G === P.UNSIGNED_BYTE ? _(Se, j) : l.assign(Se, j), ge ? P.texImage2D(P.TEXTURE_2D, O, U, H[0], H[1], 0, U, G, ie.subarray(0, Le)) : P.texSubImage2D(P.TEXTURE_2D, O, A, z, H[0], H[1], U, G, ie.subarray(0, Le)), G === P.FLOAT ? u.freeFloat32(ie) : u.freeUint8(ie);
+              }
+            }
+            function L(P) {
+              var A = P.createTexture();
+              return P.bindTexture(P.TEXTURE_2D, A), P.texParameteri(P.TEXTURE_2D, P.TEXTURE_MIN_FILTER, P.NEAREST), P.texParameteri(P.TEXTURE_2D, P.TEXTURE_MAG_FILTER, P.NEAREST), P.texParameteri(P.TEXTURE_2D, P.TEXTURE_WRAP_S, P.CLAMP_TO_EDGE), P.texParameteri(P.TEXTURE_2D, P.TEXTURE_WRAP_T, P.CLAMP_TO_EDGE), A;
+            }
+            function x(P, A, z, O, U) {
+              var G = P.getParameter(P.MAX_TEXTURE_SIZE);
+              if (A < 0 || A > G || z < 0 || z > G) throw new Error("gl-texture2d: Invalid texture shape");
+              if (U === P.FLOAT && !P.getExtension("OES_texture_float")) throw new Error("gl-texture2d: Floating point textures not supported on this platform");
+              var Z = L(P);
+              return P.texImage2D(P.TEXTURE_2D, 0, O, A, z, 0, O, U, null), new p(P, Z, A, z, O, U);
+            }
+            function C(P, A, z, O, U, G) {
+              var Z = L(P);
+              return P.texImage2D(P.TEXTURE_2D, 0, U, U, G, A), new p(P, Z, z, O, U, G);
+            }
+            function M(P, A) {
+              var z = A.dtype, O = A.shape.slice(), U = P.getParameter(P.MAX_TEXTURE_SIZE);
+              if (O[0] < 0 || O[0] > U || O[1] < 0 || O[1] > U) throw new Error("gl-texture2d: Invalid texture size");
+              var G = E(O, A.stride.slice()), Z = 0;
+              z === "float32" ? Z = P.FLOAT : z === "float64" ? (Z = P.FLOAT, G = false, z = "float32") : z === "uint8" ? Z = P.UNSIGNED_BYTE : (Z = P.UNSIGNED_BYTE, G = false, z = "uint8");
+              var j = 0;
+              if (O.length === 2) j = P.LUMINANCE, O = [O[0], O[1], 1], A = s(A.data, O, [A.stride[0], A.stride[1], 1], A.offset);
+              else if (O.length === 3) if (O[2] === 1) j = P.ALPHA;
+              else if (O[2] === 2) j = P.LUMINANCE_ALPHA;
+              else if (O[2] === 3) j = P.RGB;
+              else if (O[2] === 4) j = P.RGBA;
+              else throw new Error("gl-texture2d: Invalid shape for pixel coords");
+              else throw new Error("gl-texture2d: Invalid shape for texture");
+              Z === P.FLOAT && !P.getExtension("OES_texture_float") && (Z = P.UNSIGNED_BYTE, G = false);
+              var N, H, re = A.size;
+              if (G) A.offset === 0 && A.data.length === re ? N = A.data : N = A.data.subarray(A.offset, A.offset + re);
+              else {
+                var oe = [O[2], O[2] * O[0], 1];
+                H = u.malloc(re, z);
+                var _e = s(H, O, oe, 0);
+                (z === "float32" || z === "float64") && Z === P.UNSIGNED_BYTE ? _(_e, A) : l.assign(_e, A), N = H.subarray(0, re);
+              }
+              var Ce = L(P);
+              return P.texImage2D(P.TEXTURE_2D, 0, j, O[0], O[1], 0, j, Z, N), G || u.free(H), new p(P, Ce, O[0], O[1], j, Z);
+            }
+            function g(P) {
+              if (arguments.length <= 1) throw new Error("gl-texture2d: Missing arguments for texture2d constructor");
+              if (c || d(P), typeof arguments[1] == "number") return x(P, arguments[1], arguments[2], arguments[3] || P.RGBA, arguments[4] || P.UNSIGNED_BYTE);
+              if (Array.isArray(arguments[1])) return x(P, arguments[1][0] | 0, arguments[1][1] | 0, arguments[2] || P.RGBA, arguments[3] || P.UNSIGNED_BYTE);
+              if (typeof arguments[1] == "object") {
+                var A = arguments[1], z = v(A) ? A : A.raw;
+                if (z) return C(P, z, A.width | 0, A.height | 0, arguments[2] || P.RGBA, arguments[3] || P.UNSIGNED_BYTE);
+                if (A.shape && A.data && A.stride) return M(P, A);
+              }
+              throw new Error("gl-texture2d: Invalid arguments for texture2d constructor");
+            }
+          }, 7790: function() {
+          }, 7815: function(i, a, o) {
+            var s = o(2931), l = o(9970), u = ["xyz", "xzy", "yxz", "yzx", "zxy", "zyx"], c = function(T, L, x, C) {
+              for (var M = T.points, g = T.velocities, P = T.divergences, A = [], z = [], O = [], U = [], G = [], Z = [], j = 0, N = 0, H = l.create(), re = l.create(), oe = 8, _e = 0; _e < M.length; _e++) {
+                var Ce = M[_e], Le = g[_e], ge = P[_e];
+                L === 0 && (ge = x * 0.05), N = s.length(Le) / C, H = l.create(), s.copy(H, Le), H[3] = ge;
+                for (var ie = 0; ie < oe; ie++) G[ie] = [Ce[0], Ce[1], Ce[2], ie];
+                if (U.length > 0) for (var ie = 0; ie < oe; ie++) {
+                  var Se = (ie + 1) % oe;
+                  A.push(U[ie], G[ie], G[Se], G[Se], U[Se], U[ie]), O.push(re, H, H, H, re, re), Z.push(j, N, N, N, j, j);
+                  var Ee = A.length;
+                  z.push([Ee - 6, Ee - 5, Ee - 4], [Ee - 3, Ee - 2, Ee - 1]);
+                }
+                var Ae = U;
+                U = G, G = Ae;
+                var Be = re;
+                re = H, H = Be;
+                var Pe = j;
+                j = N, N = Pe;
+              }
+              return { positions: A, cells: z, vectors: O, vertexIntensity: Z };
+            }, f = function(T, L, x, C) {
+              for (var M = 0, g = 0; g < T.length; g++) for (var P = T[g].velocities, A = 0; A < P.length; A++) M = Math.max(M, s.length(P[A]));
+              for (var z = T.map(function(_e) {
+                return c(_e, x, C, M);
+              }), O = [], U = [], G = [], Z = [], g = 0; g < z.length; g++) {
+                var j = z[g], N = O.length;
+                O = O.concat(j.positions), G = G.concat(j.vectors), Z = Z.concat(j.vertexIntensity);
+                for (var A = 0; A < j.cells.length; A++) {
+                  var H = j.cells[A], re = [];
+                  U.push(re);
+                  for (var oe = 0; oe < H.length; oe++) re.push(H[oe] + N);
+                }
+              }
+              return { positions: O, cells: U, vectors: G, vertexIntensity: Z, colormap: L };
+            }, h = function(T, L) {
+              var x = T.length, C;
+              for (C = 0; C < x; C++) {
+                var M = T[C];
+                if (M === L) return C;
+                if (M > L) return C - 1;
+              }
+              return C;
+            }, d = function(T, L, x) {
+              return T < L ? L : T > x ? x : T;
+            }, v = function(T, L, x) {
+              var C = L.vectors, M = L.meshgrid, g = T[0], P = T[1], A = T[2], z = M[0].length, O = M[1].length, U = M[2].length, G = h(M[0], g), Z = h(M[1], P), j = h(M[2], A), N = G + 1, H = Z + 1, re = j + 1;
+              if (G = d(G, 0, z - 1), N = d(N, 0, z - 1), Z = d(Z, 0, O - 1), H = d(H, 0, O - 1), j = d(j, 0, U - 1), re = d(re, 0, U - 1), G < 0 || Z < 0 || j < 0 || N > z - 1 || H > O - 1 || re > U - 1) return s.create();
+              var oe = M[0][G], _e = M[0][N], Ce = M[1][Z], Le = M[1][H], ge = M[2][j], ie = M[2][re], Se = (g - oe) / (_e - oe), Ee = (P - Ce) / (Le - Ce), Ae = (A - ge) / (ie - ge);
+              isFinite(Se) || (Se = 0.5), isFinite(Ee) || (Ee = 0.5), isFinite(Ae) || (Ae = 0.5);
+              var Be, Pe, me, De, ce, je;
+              switch (x.reversedX && (G = z - 1 - G, N = z - 1 - N), x.reversedY && (Z = O - 1 - Z, H = O - 1 - H), x.reversedZ && (j = U - 1 - j, re = U - 1 - re), x.filled) {
+                case 5:
+                  ce = j, je = re, me = Z * U, De = H * U, Be = G * U * O, Pe = N * U * O;
+                  break;
+                case 4:
+                  ce = j, je = re, Be = G * U, Pe = N * U, me = Z * U * z, De = H * U * z;
+                  break;
+                case 3:
+                  me = Z, De = H, ce = j * O, je = re * O, Be = G * O * U, Pe = N * O * U;
+                  break;
+                case 2:
+                  me = Z, De = H, Be = G * O, Pe = N * O, ce = j * O * z, je = re * O * z;
+                  break;
+                case 1:
+                  Be = G, Pe = N, ce = j * z, je = re * z, me = Z * z * U, De = H * z * U;
+                  break;
+                default:
+                  Be = G, Pe = N, me = Z * z, De = H * z, ce = j * z * O, je = re * z * O;
+                  break;
+              }
+              var lt = C[Be + me + ce], pt = C[Be + me + je], Vt = C[Be + De + ce], ot = C[Be + De + je], ut = C[Pe + me + ce], Wt = C[Pe + me + je], Nt = C[Pe + De + ce], $t = C[Pe + De + je], sr = s.create(), Tr = s.create(), fr = s.create(), $e = s.create();
+              s.lerp(sr, lt, ut, Se), s.lerp(Tr, pt, Wt, Se), s.lerp(fr, Vt, Nt, Se), s.lerp($e, ot, $t, Se);
+              var St = s.create(), Qt = s.create();
+              s.lerp(St, sr, fr, Ee), s.lerp(Qt, Tr, $e, Ee);
+              var Gt = s.create();
+              return s.lerp(Gt, St, Qt, Ae), Gt;
+            }, b = function(T) {
+              var L = 1 / 0;
+              T.sort(function(g, P) {
+                return g - P;
+              });
+              for (var x = T.length, C = 1; C < x; C++) {
+                var M = Math.abs(T[C] - T[C - 1]);
+                M < L && (L = M);
+              }
+              return L;
+            }, p = function(T) {
+              for (var L = [], x = [], C = [], M = {}, g = {}, P = {}, A = T.length, z = 0; z < A; z++) {
+                var O = T[z], U = O[0], G = O[1], Z = O[2];
+                M[U] || (L.push(U), M[U] = true), g[G] || (x.push(G), g[G] = true), P[Z] || (C.push(Z), P[Z] = true);
+              }
+              var j = b(L), N = b(x), H = b(C), re = Math.min(j, N, H);
+              return isFinite(re) ? re : 1;
+            };
+            i.exports = function(T, L) {
+              var x = T.startingPositions, C = T.maxLength || 1e3, M = T.tubeSize || 1, g = T.absoluteTubeSize, P = T.gridFill || "+x+y+z", A = {};
+              P.indexOf("-x") !== -1 && (A.reversedX = true), P.indexOf("-y") !== -1 && (A.reversedY = true), P.indexOf("-z") !== -1 && (A.reversedZ = true), A.filled = u.indexOf(P.replace(/-/g, "").replace(/\+/g, ""));
+              var z = T.getVelocity || function(Wt) {
+                return v(Wt, T, A);
+              }, O = T.getDivergence || function(Wt, Nt) {
+                var $t = s.create(), sr = 1e-4;
+                s.add($t, Wt, [sr, 0, 0]);
+                var Tr = z($t);
+                s.subtract(Tr, Tr, Nt), s.scale(Tr, Tr, 1 / sr), s.add($t, Wt, [0, sr, 0]);
+                var fr = z($t);
+                s.subtract(fr, fr, Nt), s.scale(fr, fr, 1 / sr), s.add($t, Wt, [0, 0, sr]);
+                var $e = z($t);
+                return s.subtract($e, $e, Nt), s.scale($e, $e, 1 / sr), s.add($t, Tr, fr), s.add($t, $t, $e), $t;
+              }, U = [], G = L[0][0], Z = L[0][1], j = L[0][2], N = L[1][0], H = L[1][1], re = L[1][2], oe = function(Wt) {
+                var Nt = Wt[0], $t = Wt[1], sr = Wt[2];
+                return !(Nt < G || Nt > N || $t < Z || $t > H || sr < j || sr > re);
+              }, _e = s.distance(L[0], L[1]), Ce = 10 * _e / C, Le = Ce * Ce, ge = 1, ie = 0, Se = x.length;
+              Se > 1 && (ge = p(x));
+              for (var Ee = 0; Ee < Se; Ee++) {
+                var Ae = s.create();
+                s.copy(Ae, x[Ee]);
+                var Be = [Ae], Pe = [], me = z(Ae), De = Ae;
+                Pe.push(me);
+                var ce = [], je = O(Ae, me), lt = s.length(je);
+                isFinite(lt) && lt > ie && (ie = lt), ce.push(lt), U.push({ points: Be, velocities: Pe, divergences: ce });
+                for (var pt = 0; pt < C * 100 && Be.length < C && oe(Ae); ) {
+                  pt++;
+                  var Vt = s.clone(me), ot = s.squaredLength(Vt);
+                  if (ot === 0) break;
+                  if (ot > Le && s.scale(Vt, Vt, Ce / Math.sqrt(ot)), s.add(Vt, Vt, Ae), me = z(Vt), s.squaredDistance(De, Vt) - Le > -1e-4 * Le) {
+                    Be.push(Vt), De = Vt, Pe.push(me);
+                    var je = O(Vt, me), lt = s.length(je);
+                    isFinite(lt) && lt > ie && (ie = lt), ce.push(lt);
+                  }
+                  Ae = Vt;
+                }
+              }
+              var ut = f(U, T.colormap, ie, ge);
+              return g ? ut.tubeScale = g : (ie === 0 && (ie = 1), ut.tubeScale = M * 0.5 * ge / ie), ut;
+            };
+            var k = o(6740), E = o(6405).createMesh;
+            i.exports.createTubeMesh = function(T, L) {
+              return E(T, L, { shaders: k, traceType: "streamtube" });
+            };
+          }, 7827: function(i) {
+            i.exports = ["<<=", ">>=", "++", "--", "<<", ">>", "<=", ">=", "==", "!=", "&&", "||", "+=", "-=", "*=", "/=", "%=", "&=", "^^", "^=", "|=", "(", ")", "[", "]", ".", "!", "~", "*", "/", "%", "+", "-", "<", ">", "&", "^", "|", "?", ":", "=", ",", ";", "{", "}"];
+          }, 7842: function(i, a, o) {
+            var s = o(6330), l = o(1533), u = o(2651), c = o(6768), f = o(869), h = o(8697);
+            i.exports = d;
+            function d(v, _) {
+              if (s(v)) return _ ? h(v, d(_)) : [v[0].clone(), v[1].clone()];
+              var b = 0, p, k;
+              if (l(v)) p = v.clone();
+              else if (typeof v == "string") p = c(v);
+              else {
+                if (v === 0) return [u(0), u(1)];
+                if (v === Math.floor(v)) p = u(v);
+                else {
+                  for (; v !== Math.floor(v); ) v = v * Math.pow(2, 256), b -= 256;
+                  p = u(v);
+                }
+              }
+              if (s(_)) p.mul(_[1]), k = _[0].clone();
+              else if (l(_)) k = _.clone();
+              else if (typeof _ == "string") k = c(_);
+              else if (!_) k = u(1);
+              else if (_ === Math.floor(_)) k = u(_);
+              else {
+                for (; _ !== Math.floor(_); ) _ = _ * Math.pow(2, 256), b += 256;
+                k = u(_);
+              }
+              return b > 0 ? p = p.ushln(b) : b < 0 && (k = k.ushln(-b)), f(p, k);
+            }
+          }, 7894: function(i) {
+            i.exports = a;
+            function a(o) {
+              return o[0] = 1, o[1] = 0, o[2] = 0, o[3] = 0, o[4] = 0, o[5] = 1, o[6] = 0, o[7] = 0, o[8] = 0, o[9] = 0, o[10] = 1, o[11] = 0, o[12] = 0, o[13] = 0, o[14] = 0, o[15] = 1, o;
+            }
+          }, 7932: function(i, a, o) {
+            var s = o(620);
+            i.exports = s.slice().concat(["layout", "centroid", "smooth", "case", "mat2x2", "mat2x3", "mat2x4", "mat3x2", "mat3x3", "mat3x4", "mat4x2", "mat4x3", "mat4x4", "uvec2", "uvec3", "uvec4", "samplerCubeShadow", "sampler2DArray", "sampler2DArrayShadow", "isampler2D", "isampler3D", "isamplerCube", "isampler2DArray", "usampler2D", "usampler3D", "usamplerCube", "usampler2DArray", "coherent", "restrict", "readonly", "writeonly", "resource", "atomic_uint", "noperspective", "patch", "sample", "subroutine", "common", "partition", "active", "filter", "image1D", "image2D", "image3D", "imageCube", "iimage1D", "iimage2D", "iimage3D", "iimageCube", "uimage1D", "uimage2D", "uimage3D", "uimageCube", "image1DArray", "image2DArray", "iimage1DArray", "iimage2DArray", "uimage1DArray", "uimage2DArray", "image1DShadow", "image2DShadow", "image1DArrayShadow", "image2DArrayShadow", "imageBuffer", "iimageBuffer", "uimageBuffer", "sampler1DArray", "sampler1DArrayShadow", "isampler1D", "isampler1DArray", "usampler1D", "usampler1DArray", "isampler2DRect", "usampler2DRect", "samplerBuffer", "isamplerBuffer", "usamplerBuffer", "sampler2DMS", "isampler2DMS", "usampler2DMS", "sampler2DMSArray", "isampler2DMSArray", "usampler2DMSArray"]);
+          }, 7960: function(i) {
+            i.exports = a;
+            function a(o, s) {
+              var l = s[0] - o[0], u = s[1] - o[1], c = s[2] - o[2], f = s[3] - o[3];
+              return l * l + u * u + c * c + f * f;
+            }
+          }, 8105: function(i) {
+            i.exports = o;
+            var a = { "lo===p0": s, "lo<p0": l, "lo<=p0": u, "hi<=p0": c, "lo<p0&&p0<=hi": h, "lo<=p0&&p0<=hi": f, "!(lo>=p0)&&!(p1>=hi)": d };
+            function o(v) {
+              return a[v];
+            }
+            function s(v, _, b, p, k, E, T) {
+              for (var L = 2 * v, x = L * b, C = x, M = b, g = _, P = v + _, A = b; p > A; ++A, x += L) {
+                var z = k[x + g];
+                if (z === T) if (M === A) M += 1, C += L;
+                else {
+                  for (var O = 0; L > O; ++O) {
+                    var U = k[x + O];
+                    k[x + O] = k[C], k[C++] = U;
+                  }
+                  var G = E[A];
+                  E[A] = E[M], E[M++] = G;
+                }
+              }
+              return M;
+            }
+            function l(v, _, b, p, k, E, T) {
+              for (var L = 2 * v, x = L * b, C = x, M = b, g = _, P = v + _, A = b; p > A; ++A, x += L) {
+                var z = k[x + g];
+                if (z < T) if (M === A) M += 1, C += L;
+                else {
+                  for (var O = 0; L > O; ++O) {
+                    var U = k[x + O];
+                    k[x + O] = k[C], k[C++] = U;
+                  }
+                  var G = E[A];
+                  E[A] = E[M], E[M++] = G;
+                }
+              }
+              return M;
+            }
+            function u(v, _, b, p, k, E, T) {
+              for (var L = 2 * v, x = L * b, C = x, M = b, g = _, P = v + _, A = b; p > A; ++A, x += L) {
+                var z = k[x + P];
+                if (z <= T) if (M === A) M += 1, C += L;
+                else {
+                  for (var O = 0; L > O; ++O) {
+                    var U = k[x + O];
+                    k[x + O] = k[C], k[C++] = U;
+                  }
+                  var G = E[A];
+                  E[A] = E[M], E[M++] = G;
+                }
+              }
+              return M;
+            }
+            function c(v, _, b, p, k, E, T) {
+              for (var L = 2 * v, x = L * b, C = x, M = b, g = _, P = v + _, A = b; p > A; ++A, x += L) {
+                var z = k[x + P];
+                if (z <= T) if (M === A) M += 1, C += L;
+                else {
+                  for (var O = 0; L > O; ++O) {
+                    var U = k[x + O];
+                    k[x + O] = k[C], k[C++] = U;
+                  }
+                  var G = E[A];
+                  E[A] = E[M], E[M++] = G;
+                }
+              }
+              return M;
+            }
+            function f(v, _, b, p, k, E, T) {
+              for (var L = 2 * v, x = L * b, C = x, M = b, g = _, P = v + _, A = b; p > A; ++A, x += L) {
+                var z = k[x + g], O = k[x + P];
+                if (z <= T && T <= O) if (M === A) M += 1, C += L;
+                else {
+                  for (var U = 0; L > U; ++U) {
+                    var G = k[x + U];
+                    k[x + U] = k[C], k[C++] = G;
+                  }
+                  var Z = E[A];
+                  E[A] = E[M], E[M++] = Z;
+                }
+              }
+              return M;
+            }
+            function h(v, _, b, p, k, E, T) {
+              for (var L = 2 * v, x = L * b, C = x, M = b, g = _, P = v + _, A = b; p > A; ++A, x += L) {
+                var z = k[x + g], O = k[x + P];
+                if (z < T && T <= O) if (M === A) M += 1, C += L;
+                else {
+                  for (var U = 0; L > U; ++U) {
+                    var G = k[x + U];
+                    k[x + U] = k[C], k[C++] = G;
+                  }
+                  var Z = E[A];
+                  E[A] = E[M], E[M++] = Z;
+                }
+              }
+              return M;
+            }
+            function d(v, _, b, p, k, E, T, L) {
+              for (var x = 2 * v, C = x * b, M = C, g = b, P = _, A = v + _, z = b; p > z; ++z, C += x) {
+                var O = k[C + P], U = k[C + A];
+                if (!(O >= T) && !(L >= U)) if (g === z) g += 1, M += x;
+                else {
+                  for (var G = 0; x > G; ++G) {
+                    var Z = k[C + G];
+                    k[C + G] = k[M], k[M++] = Z;
+                  }
+                  var j = E[z];
+                  E[z] = E[g], E[g++] = j;
+                }
+              }
+              return g;
+            }
+          }, 8107: function(i) {
+            i.exports = a;
+            function a(o, s, l) {
+              return o[0] = Math.min(s[0], l[0]), o[1] = Math.min(s[1], l[1]), o[2] = Math.min(s[2], l[2]), o;
+            }
+          }, 8116: function(i, a, o) {
+            var s = o(7518), l = o(870);
+            function u(f) {
+              this.bindVertexArrayOES = f.bindVertexArray.bind(f), this.createVertexArrayOES = f.createVertexArray.bind(f), this.deleteVertexArrayOES = f.deleteVertexArray.bind(f);
+            }
+            function c(f, h, d, v) {
+              var _ = f.createVertexArray ? new u(f) : f.getExtension("OES_vertex_array_object"), b;
+              return _ ? b = s(f, _) : b = l(f), b.update(h, d, v), b;
+            }
+            i.exports = c;
+          }, 8192: function(i, a, o) {
+            i.exports = c;
+            var s = o(2825), l = o(3536), u = o(244);
+            function c(f, h) {
+              var d = s(f[0], f[1], f[2]), v = s(h[0], h[1], h[2]);
+              l(d, d), l(v, v);
+              var _ = u(d, v);
+              return _ > 1 ? 0 : Math.acos(_);
+            }
+          }, 8210: function(i) {
+            i.exports = o;
+            function a(s, l) {
+              var u = s + l, c = u - s, f = u - c, h = l - c, d = s - f, v = d + h;
+              return v ? [v, u] : [u];
+            }
+            function o(s, l) {
+              var u = s.length | 0, c = l.length | 0;
+              if (u === 1 && c === 1) return a(s[0], l[0]);
+              var f = u + c, h = new Array(f), d = 0, v = 0, _ = 0, b = Math.abs, p = s[v], k = b(p), E = l[_], T = b(E), L, x;
+              k < T ? (x = p, v += 1, v < u && (p = s[v], k = b(p))) : (x = E, _ += 1, _ < c && (E = l[_], T = b(E))), v < u && k < T || _ >= c ? (L = p, v += 1, v < u && (p = s[v], k = b(p))) : (L = E, _ += 1, _ < c && (E = l[_], T = b(E)));
+              for (var C = L + x, M = C - L, g = x - M, P = g, A = C, z, O, U, G, Z; v < u && _ < c; ) k < T ? (L = p, v += 1, v < u && (p = s[v], k = b(p))) : (L = E, _ += 1, _ < c && (E = l[_], T = b(E))), x = P, C = L + x, M = C - L, g = x - M, g && (h[d++] = g), z = A + C, O = z - A, U = z - O, G = C - O, Z = A - U, P = Z + G, A = z;
+              for (; v < u; ) L = p, x = P, C = L + x, M = C - L, g = x - M, g && (h[d++] = g), z = A + C, O = z - A, U = z - O, G = C - O, Z = A - U, P = Z + G, A = z, v += 1, v < u && (p = s[v]);
+              for (; _ < c; ) L = E, x = P, C = L + x, M = C - L, g = x - M, g && (h[d++] = g), z = A + C, O = z - A, U = z - O, G = C - O, Z = A - U, P = Z + G, A = z, _ += 1, _ < c && (E = l[_]);
+              return P && (h[d++] = P), A && (h[d++] = A), d || (h[d++] = 0), h.length = d, h;
+            }
+          }, 8277: function(i) {
+            function a() {
+              return function(f, h, d, v, _) {
+                var b = f[0], p = f[1], k = f[2], E = d[0], T = d[1], L = d[2], x = [0, 0, 0];
+                v |= 0;
+                var C = 0, M = 0, g = 0, P = L, A = T - k * L, z = E - p * T;
+                for (g = 0; g < b; ++g) {
+                  for (M = 0; M < p; ++M) {
+                    for (C = 0; C < k; ++C) {
+                      {
+                        var O = _, U;
+                        for (U = 0; U < x.length - 1; ++U) O = O[x[U]];
+                        h[v] = O[x[x.length - 1]];
+                      }
+                      v += P, ++x[2];
+                    }
+                    v += A, x[2] -= k, ++x[1];
+                  }
+                  v += z, x[1] -= p, ++x[0];
+                }
+              };
+            }
+            function o() {
+              return a();
+            }
+            var s = o;
+            function l(f) {
+              var h = {};
+              return function(v, _) {
+                var b = v.dtype, p = v.order, k = [b, p.join()].join(), E = h[k];
+                return E || (h[k] = E = f([b, p])), E(v.shape.slice(0), v.data, v.stride, v.offset | 0, _);
+              };
+            }
+            function u(f) {
+              return l(s.bind(void 0, f));
+            }
+            function c(f) {
+              return u({ funcName: f.funcName });
+            }
+            i.exports = c({ funcName: "convert" });
+          }, 8284: function(i) {
+            i.exports = a;
+            function a(o, s) {
+              var l = { identity: s }, u = o.valueOf;
+              return Object.defineProperty(o, "valueOf", { value: function(c) {
+                return c !== s ? u.apply(this, arguments) : l;
+              }, writable: true }), l;
+            }
+          }, 8406: function(i, a) {
+            var o = 1e-6, s = 1e-6;
+            a.vertexNormals = function(l, u, c) {
+              for (var f = u.length, h = new Array(f), d = c === void 0 ? o : c, v = 0; v < f; ++v) h[v] = [0, 0, 0];
+              for (var v = 0; v < l.length; ++v) for (var _ = l[v], b = 0, p = _[_.length - 1], k = _[0], E = 0; E < _.length; ++E) {
+                b = p, p = k, k = _[(E + 1) % _.length];
+                for (var T = u[b], L = u[p], x = u[k], C = new Array(3), M = 0, g = new Array(3), P = 0, A = 0; A < 3; ++A) C[A] = T[A] - L[A], M += C[A] * C[A], g[A] = x[A] - L[A], P += g[A] * g[A];
+                if (M * P > d) for (var z = h[p], O = 1 / Math.sqrt(M * P), A = 0; A < 3; ++A) {
+                  var U = (A + 1) % 3, G = (A + 2) % 3;
+                  z[A] += O * (g[U] * C[G] - g[G] * C[U]);
+                }
+              }
+              for (var v = 0; v < f; ++v) {
+                for (var z = h[v], Z = 0, A = 0; A < 3; ++A) Z += z[A] * z[A];
+                if (Z > d) for (var O = 1 / Math.sqrt(Z), A = 0; A < 3; ++A) z[A] *= O;
+                else for (var A = 0; A < 3; ++A) z[A] = 0;
+              }
+              return h;
+            }, a.faceNormals = function(l, u, c) {
+              for (var f = l.length, h = new Array(f), d = c === void 0 ? s : c, v = 0; v < f; ++v) {
+                for (var _ = l[v], b = new Array(3), p = 0; p < 3; ++p) b[p] = u[_[p]];
+                for (var k = new Array(3), E = new Array(3), p = 0; p < 3; ++p) k[p] = b[1][p] - b[0][p], E[p] = b[2][p] - b[0][p];
+                for (var T = new Array(3), L = 0, p = 0; p < 3; ++p) {
+                  var x = (p + 1) % 3, C = (p + 2) % 3;
+                  T[p] = k[x] * E[C] - k[C] * E[x], L += T[p] * T[p];
+                }
+                L > d ? L = 1 / Math.sqrt(L) : L = 0;
+                for (var p = 0; p < 3; ++p) T[p] *= L;
+                h[v] = T;
+              }
+              return h;
+            };
+          }, 8418: function(i, a, o) {
+            var s = o(5219), l = o(2762), u = o(8116), c = o(1888), f = o(6760), h = o(1283), d = o(9366), v = o(5964), _ = [1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1], b = ArrayBuffer, p = DataView;
+            function k(Ae) {
+              return b.isView(Ae) && !(Ae instanceof p);
+            }
+            function E(Ae) {
+              return Array.isArray(Ae) || k(Ae);
+            }
+            i.exports = Ee;
+            function T(Ae, Be) {
+              var Pe = Ae[0], me = Ae[1], De = Ae[2], ce = Ae[3];
+              return Ae[0] = Be[0] * Pe + Be[4] * me + Be[8] * De + Be[12] * ce, Ae[1] = Be[1] * Pe + Be[5] * me + Be[9] * De + Be[13] * ce, Ae[2] = Be[2] * Pe + Be[6] * me + Be[10] * De + Be[14] * ce, Ae[3] = Be[3] * Pe + Be[7] * me + Be[11] * De + Be[15] * ce, Ae;
+            }
+            function L(Ae, Be, Pe, me) {
+              return T(me, me), T(me, me), T(me, me);
+            }
+            function x(Ae, Be) {
+              this.index = Ae, this.dataCoordinate = this.position = Be;
+            }
+            function C(Ae) {
+              return Ae === true || Ae > 1 ? 1 : Ae;
+            }
+            function M(Ae, Be, Pe, me, De, ce, je, lt, pt, Vt, ot, ut) {
+              this.gl = Ae, this.pixelRatio = 1, this.shader = Be, this.orthoShader = Pe, this.projectShader = me, this.pointBuffer = De, this.colorBuffer = ce, this.glyphBuffer = je, this.idBuffer = lt, this.vao = pt, this.vertexCount = 0, this.lineVertexCount = 0, this.opacity = 1, this.hasAlpha = false, this.lineWidth = 0, this.projectScale = [0.6666666666666666, 0.6666666666666666, 0.6666666666666666], this.projectOpacity = [1, 1, 1], this.projectHasAlpha = false, this.pickId = 0, this.pickPerspectiveShader = Vt, this.pickOrthoShader = ot, this.pickProjectShader = ut, this.points = [], this._selectResult = new x(0, [0, 0, 0]), this.useOrtho = true, this.bounds = [[1 / 0, 1 / 0, 1 / 0], [-1 / 0, -1 / 0, -1 / 0]], this.axesProject = [true, true, true], this.axesBounds = [[-1 / 0, -1 / 0, -1 / 0], [1 / 0, 1 / 0, 1 / 0]], this.highlightId = [1, 1, 1, 1], this.highlightScale = 2, this.clipBounds = [[-1 / 0, -1 / 0, -1 / 0], [1 / 0, 1 / 0, 1 / 0]], this.dirty = true;
+            }
+            var g = M.prototype;
+            g.pickSlots = 1, g.setPickBase = function(Ae) {
+              this.pickId = Ae;
+            }, g.isTransparent = function() {
+              if (this.hasAlpha) return true;
+              for (var Ae = 0; Ae < 3; ++Ae) if (this.axesProject[Ae] && this.projectHasAlpha) return true;
+              return false;
+            }, g.isOpaque = function() {
+              if (!this.hasAlpha) return true;
+              for (var Ae = 0; Ae < 3; ++Ae) if (this.axesProject[Ae] && !this.projectHasAlpha) return true;
+              return false;
+            };
+            var P = [0, 0], A = [0, 0, 0], z = [0, 0, 0], O = [0, 0, 0, 1], U = [0, 0, 0, 1], G = _.slice(), Z = [0, 0, 0], j = [[0, 0, 0], [0, 0, 0]];
+            function N(Ae) {
+              return Ae[0] = Ae[1] = Ae[2] = 0, Ae;
+            }
+            function H(Ae, Be) {
+              return Ae[0] = Be[0], Ae[1] = Be[1], Ae[2] = Be[2], Ae[3] = 1, Ae;
+            }
+            function re(Ae, Be, Pe, me) {
+              return Ae[0] = Be[0], Ae[1] = Be[1], Ae[2] = Be[2], Ae[Pe] = me, Ae;
+            }
+            function oe(Ae) {
+              for (var Be = j, Pe = 0; Pe < 2; ++Pe) for (var me = 0; me < 3; ++me) Be[Pe][me] = Math.max(Math.min(Ae[Pe][me], 1e8), -1e8);
+              return Be;
+            }
+            function _e(Ae, Be, Pe, me) {
+              var De = Be.axesProject, ce = Be.gl, je = Ae.uniforms, lt = Pe.model || _, pt = Pe.view || _, Vt = Pe.projection || _, ot = Be.axesBounds, ut = oe(Be.clipBounds), Wt;
+              Be.axes && Be.axes.lastCubeProps ? Wt = Be.axes.lastCubeProps.axis : Wt = [1, 1, 1], P[0] = 2 / ce.drawingBufferWidth, P[1] = 2 / ce.drawingBufferHeight, Ae.bind(), je.view = pt, je.projection = Vt, je.screenSize = P, je.highlightId = Be.highlightId, je.highlightScale = Be.highlightScale, je.clipBounds = ut, je.pickGroup = Be.pickId / 255, je.pixelRatio = me;
+              for (var Nt = 0; Nt < 3; ++Nt) if (De[Nt]) {
+                je.scale = Be.projectScale[Nt], je.opacity = Be.projectOpacity[Nt];
+                for (var $t = G, sr = 0; sr < 16; ++sr) $t[sr] = 0;
+                for (var sr = 0; sr < 4; ++sr) $t[5 * sr] = 1;
+                $t[5 * Nt] = 0, Wt[Nt] < 0 ? $t[12 + Nt] = ot[0][Nt] : $t[12 + Nt] = ot[1][Nt], f($t, lt, $t), je.model = $t;
+                var Tr = (Nt + 1) % 3, fr = (Nt + 2) % 3, $e = N(A), St = N(z);
+                $e[Tr] = 1, St[fr] = 1;
+                var Qt = L(Vt, pt, lt, H(O, $e)), Gt = L(Vt, pt, lt, H(U, St));
+                if (Math.abs(Qt[1]) > Math.abs(Gt[1])) {
+                  var _t = Qt;
+                  Qt = Gt, Gt = _t, _t = $e, $e = St, St = _t;
+                  var It = Tr;
+                  Tr = fr, fr = It;
+                }
+                Qt[0] < 0 && ($e[Tr] = -1), Gt[1] > 0 && (St[fr] = -1);
+                for (var mt = 0, er = 0, sr = 0; sr < 4; ++sr) mt += Math.pow(lt[4 * Tr + sr], 2), er += Math.pow(lt[4 * fr + sr], 2);
+                $e[Tr] /= Math.sqrt(mt), St[fr] /= Math.sqrt(er), je.axes[0] = $e, je.axes[1] = St, je.fragClipBounds[0] = re(Z, ut[0], Nt, -1e8), je.fragClipBounds[1] = re(Z, ut[1], Nt, 1e8), Be.vao.bind(), Be.vao.draw(ce.TRIANGLES, Be.vertexCount), Be.lineWidth > 0 && (ce.lineWidth(Be.lineWidth * me), Be.vao.draw(ce.LINES, Be.lineVertexCount, Be.vertexCount)), Be.vao.unbind();
+              }
+            }
+            var Ce = [-1e8, -1e8, -1e8], Le = [1e8, 1e8, 1e8], ge = [Ce, Le];
+            function ie(Ae, Be, Pe, me, De, ce, je) {
+              var lt = Pe.gl;
+              if ((ce === Pe.projectHasAlpha || je) && _e(Be, Pe, me, De), ce === Pe.hasAlpha || je) {
+                Ae.bind();
+                var pt = Ae.uniforms;
+                pt.model = me.model || _, pt.view = me.view || _, pt.projection = me.projection || _, P[0] = 2 / lt.drawingBufferWidth, P[1] = 2 / lt.drawingBufferHeight, pt.screenSize = P, pt.highlightId = Pe.highlightId, pt.highlightScale = Pe.highlightScale, pt.fragClipBounds = ge, pt.clipBounds = Pe.axes.bounds, pt.opacity = Pe.opacity, pt.pickGroup = Pe.pickId / 255, pt.pixelRatio = De, Pe.vao.bind(), Pe.vao.draw(lt.TRIANGLES, Pe.vertexCount), Pe.lineWidth > 0 && (lt.lineWidth(Pe.lineWidth * De), Pe.vao.draw(lt.LINES, Pe.lineVertexCount, Pe.vertexCount)), Pe.vao.unbind();
+              }
+            }
+            g.draw = function(Ae) {
+              var Be = this.useOrtho ? this.orthoShader : this.shader;
+              ie(Be, this.projectShader, this, Ae, this.pixelRatio, false, false);
+            }, g.drawTransparent = function(Ae) {
+              var Be = this.useOrtho ? this.orthoShader : this.shader;
+              ie(Be, this.projectShader, this, Ae, this.pixelRatio, true, false);
+            }, g.drawPick = function(Ae) {
+              var Be = this.useOrtho ? this.pickOrthoShader : this.pickPerspectiveShader;
+              ie(Be, this.pickProjectShader, this, Ae, 1, true, true);
+            }, g.pick = function(Ae) {
+              if (!Ae || Ae.id !== this.pickId) return null;
+              var Be = Ae.value[2] + (Ae.value[1] << 8) + (Ae.value[0] << 16);
+              if (Be >= this.pointCount || Be < 0) return null;
+              var Pe = this.points[Be], me = this._selectResult;
+              me.index = Be;
+              for (var De = 0; De < 3; ++De) me.position[De] = me.dataCoordinate[De] = Pe[De];
+              return me;
+            }, g.highlight = function(Ae) {
+              if (!Ae) this.highlightId = [1, 1, 1, 1];
+              else {
+                var Be = Ae.index, Pe = Be & 255, me = Be >> 8 & 255, De = Be >> 16 & 255;
+                this.highlightId = [Pe / 255, me / 255, De / 255, 0];
+              }
+            };
+            function Se(Ae, Be, Pe, me) {
+              var De;
+              E(Ae) ? Be < Ae.length ? De = Ae[Be] : De = void 0 : De = Ae, De = v(De);
+              var ce = true;
+              s(De) && (De = "▼", ce = false), Pe || (Pe = {});
+              var je = Pe.family;
+              E(je) && (je = je[Be]), je || (je = "normal");
+              var lt = Pe.weight;
+              E(lt) && (lt = lt[Be]), lt || (lt = "normal");
+              var pt = Pe.style;
+              E(pt) && (pt = pt[Be]), pt || (pt = "normal");
+              var Vt = Pe.variant;
+              E(Vt) && (Vt = Vt[Be]), Vt || (Vt = "normal");
+              var ot = d(De, { family: je, weight: lt, style: pt, variant: Vt }, me), ot = d(De, Pe, me);
+              return { mesh: ot[0], lines: ot[1], bounds: ot[2], visible: ce };
+            }
+            g.update = function(Ae) {
+              if (Ae = Ae || {}, "perspective" in Ae && (this.useOrtho = !Ae.perspective), "orthographic" in Ae && (this.useOrtho = !!Ae.orthographic), "lineWidth" in Ae && (this.lineWidth = Ae.lineWidth), "project" in Ae) if (E(Ae.project)) this.axesProject = Ae.project;
+              else {
+                var Be = !!Ae.project;
+                this.axesProject = [Be, Be, Be];
+              }
+              if ("projectScale" in Ae) if (E(Ae.projectScale)) this.projectScale = Ae.projectScale.slice();
+              else {
+                var Pe = +Ae.projectScale;
+                this.projectScale = [Pe, Pe, Pe];
+              }
+              if (this.projectHasAlpha = false, "projectOpacity" in Ae) {
+                if (E(Ae.projectOpacity)) this.projectOpacity = Ae.projectOpacity.slice();
+                else {
+                  var Pe = +Ae.projectOpacity;
+                  this.projectOpacity = [Pe, Pe, Pe];
+                }
+                for (var me = 0; me < 3; ++me) this.projectOpacity[me] = C(this.projectOpacity[me]), this.projectOpacity[me] < 1 && (this.projectHasAlpha = true);
+              }
+              this.hasAlpha = false, "opacity" in Ae && (this.opacity = C(Ae.opacity), this.opacity < 1 && (this.hasAlpha = true)), this.dirty = true;
+              var De = Ae.position, ce = { family: Ae.font || "normal", style: Ae.fontStyle || "normal", weight: Ae.fontWeight || "normal", variant: Ae.fontVariant || "normal" }, je = Ae.alignment || [0, 0], lt, pt;
+              if (je.length === 2) lt = je[0], pt = je[1];
+              else {
+                lt = [], pt = [];
+                for (var me = 0; me < je.length; ++me) lt[me] = je[me][0], pt[me] = je[me][1];
+              }
+              var Vt = [1 / 0, 1 / 0, 1 / 0], ot = [-1 / 0, -1 / 0, -1 / 0], ut = Ae.glyph, Wt = Ae.color, Nt = Ae.size, $t = Ae.angle, sr = Ae.lineColor, Tr = -1, fr = 0, $e = 0, St = 0;
+              if (De.length) {
+                St = De.length;
+                e: for (var me = 0; me < St; ++me) {
+                  for (var Qt = De[me], Gt = 0; Gt < 3; ++Gt) if (isNaN(Qt[Gt]) || !isFinite(Qt[Gt])) continue e;
+                  var _t = Se(ut, me, ce, this.pixelRatio), It = _t.mesh, mt = _t.lines, er = _t.bounds;
+                  fr += It.cells.length * 3, $e += mt.edges.length * 2;
+                }
+              }
+              var lr = fr + $e, wr = c.mallocFloat(3 * lr), Lr = c.mallocFloat(4 * lr), ti = c.mallocFloat(2 * lr), Br = c.mallocUint32(lr);
+              if (lr > 0) {
+                var Vr = 0, dt = fr, Ge = [0, 0, 0, 1], Je = [0, 0, 0, 1], We = E(Wt) && E(Wt[0]), tt = E(sr) && E(sr[0]);
+                e: for (var me = 0; me < St; ++me) {
+                  Tr += 1;
+                  for (var Qt = De[me], Gt = 0; Gt < 3; ++Gt) {
+                    if (isNaN(Qt[Gt]) || !isFinite(Qt[Gt])) continue e;
+                    ot[Gt] = Math.max(ot[Gt], Qt[Gt]), Vt[Gt] = Math.min(Vt[Gt], Qt[Gt]);
+                  }
+                  var _t = Se(ut, me, ce, this.pixelRatio), It = _t.mesh, mt = _t.lines, er = _t.bounds, xt = _t.visible;
+                  if (!xt) Ge = [1, 1, 1, 0];
+                  else if (E(Wt)) {
+                    var Ie;
+                    if (We ? me < Wt.length ? Ie = Wt[me] : Ie = [0, 0, 0, 0] : Ie = Wt, Ie.length === 3) {
+                      for (var Gt = 0; Gt < 3; ++Gt) Ge[Gt] = Ie[Gt];
+                      Ge[3] = 1;
+                    } else if (Ie.length === 4) {
+                      for (var Gt = 0; Gt < 4; ++Gt) Ge[Gt] = Ie[Gt];
+                      !this.hasAlpha && Ie[3] < 1 && (this.hasAlpha = true);
+                    }
+                  } else Ge[0] = Ge[1] = Ge[2] = 0, Ge[3] = 1;
+                  if (!xt) Je = [1, 1, 1, 0];
+                  else if (E(sr)) {
+                    var Ie;
+                    if (tt ? me < sr.length ? Ie = sr[me] : Ie = [0, 0, 0, 0] : Ie = sr, Ie.length === 3) {
+                      for (var Gt = 0; Gt < 3; ++Gt) Je[Gt] = Ie[Gt];
+                      Je[Gt] = 1;
+                    } else if (Ie.length === 4) {
+                      for (var Gt = 0; Gt < 4; ++Gt) Je[Gt] = Ie[Gt];
+                      !this.hasAlpha && Ie[3] < 1 && (this.hasAlpha = true);
+                    }
+                  } else Je[0] = Je[1] = Je[2] = 0, Je[3] = 1;
+                  var xe = 0.5;
+                  xt ? E(Nt) ? me < Nt.length ? xe = +Nt[me] : xe = 12 : Nt ? xe = +Nt : this.useOrtho && (xe = 12) : xe = 0;
+                  var ke = 0;
+                  E($t) ? me < $t.length ? ke = +$t[me] : ke = 0 : $t && (ke = +$t);
+                  for (var vt = Math.cos(ke), ir = Math.sin(ke), Qt = De[me], Gt = 0; Gt < 3; ++Gt) ot[Gt] = Math.max(ot[Gt], Qt[Gt]), Vt[Gt] = Math.min(Vt[Gt], Qt[Gt]);
+                  var ar = lt, vr = pt, ar = 0;
+                  E(lt) ? me < lt.length ? ar = lt[me] : ar = 0 : lt && (ar = lt);
+                  var vr = 0;
+                  E(pt) ? me < pt.length ? vr = pt[me] : vr = 0 : pt && (vr = pt), ar *= ar > 0 ? 1 - er[0][0] : ar < 0 ? 1 + er[1][0] : 1, vr *= vr > 0 ? 1 - er[0][1] : vr < 0 ? 1 + er[1][1] : 1;
+                  for (var ii = [ar, vr], In = It.cells || [], wi = It.positions || [], Gt = 0; Gt < In.length; ++Gt) for (var pi = In[Gt], $r = 0; $r < 3; ++$r) {
+                    for (var di = 0; di < 3; ++di) wr[3 * Vr + di] = Qt[di];
+                    for (var di = 0; di < 4; ++di) Lr[4 * Vr + di] = Ge[di];
+                    Br[Vr] = Tr;
+                    var ji = wi[pi[$r]];
+                    ti[2 * Vr] = xe * (vt * ji[0] - ir * ji[1] + ii[0]), ti[2 * Vr + 1] = xe * (ir * ji[0] + vt * ji[1] + ii[1]), Vr += 1;
+                  }
+                  for (var In = mt.edges, wi = mt.positions, Gt = 0; Gt < In.length; ++Gt) for (var pi = In[Gt], $r = 0; $r < 2; ++$r) {
+                    for (var di = 0; di < 3; ++di) wr[3 * dt + di] = Qt[di];
+                    for (var di = 0; di < 4; ++di) Lr[4 * dt + di] = Je[di];
+                    Br[dt] = Tr;
+                    var ji = wi[pi[$r]];
+                    ti[2 * dt] = xe * (vt * ji[0] - ir * ji[1] + ii[0]), ti[2 * dt + 1] = xe * (ir * ji[0] + vt * ji[1] + ii[1]), dt += 1;
+                  }
+                }
+              }
+              this.bounds = [Vt, ot], this.points = De, this.pointCount = De.length, this.vertexCount = fr, this.lineVertexCount = $e, this.pointBuffer.update(wr), this.colorBuffer.update(Lr), this.glyphBuffer.update(ti), this.idBuffer.update(Br), c.free(wr), c.free(Lr), c.free(ti), c.free(Br);
+            }, g.dispose = function() {
+              this.shader.dispose(), this.orthoShader.dispose(), this.pickPerspectiveShader.dispose(), this.pickOrthoShader.dispose(), this.vao.dispose(), this.pointBuffer.dispose(), this.colorBuffer.dispose(), this.glyphBuffer.dispose(), this.idBuffer.dispose();
+            };
+            function Ee(Ae) {
+              var Be = Ae.gl, Pe = h.createPerspective(Be), me = h.createOrtho(Be), De = h.createProject(Be), ce = h.createPickPerspective(Be), je = h.createPickOrtho(Be), lt = h.createPickProject(Be), pt = l(Be), Vt = l(Be), ot = l(Be), ut = l(Be), Wt = u(Be, [{ buffer: pt, size: 3, type: Be.FLOAT }, { buffer: Vt, size: 4, type: Be.FLOAT }, { buffer: ot, size: 2, type: Be.FLOAT }, { buffer: ut, size: 4, type: Be.UNSIGNED_BYTE, normalized: true }]), Nt = new M(Be, Pe, me, De, pt, Vt, ot, ut, Wt, ce, je, lt);
+              return Nt.update(Ae), Nt;
+            }
+          }, 8489: function(i) {
+            i.exports = a;
+            function a(o, s, l, u) {
+              return o[0] = s[0] + l[0] * u, o[1] = s[1] + l[1] * u, o[2] = s[2] + l[2] * u, o;
+            }
+          }, 8507: function(i) {
+            i.exports = s;
+            var a = Math.min;
+            function o(l, u) {
+              return l - u;
+            }
+            function s(l, u) {
+              var c = l.length, f = l.length - u.length;
+              if (f) return f;
+              switch (c) {
+                case 0:
+                  return 0;
+                case 1:
+                  return l[0] - u[0];
+                case 2:
+                  return l[0] + l[1] - u[0] - u[1] || a(l[0], l[1]) - a(u[0], u[1]);
+                case 3:
+                  var h = l[0] + l[1], d = u[0] + u[1];
+                  if (f = h + l[2] - (d + u[2]), f) return f;
+                  var v = a(l[0], l[1]), _ = a(u[0], u[1]);
+                  return a(v, l[2]) - a(_, u[2]) || a(v + l[2], h) - a(_ + u[2], d);
+                case 4:
+                  var b = l[0], p = l[1], k = l[2], E = l[3], T = u[0], L = u[1], x = u[2], C = u[3];
+                  return b + p + k + E - (T + L + x + C) || a(b, p, k, E) - a(T, L, x, C, T) || a(b + p, b + k, b + E, p + k, p + E, k + E) - a(T + L, T + x, T + C, L + x, L + C, x + C) || a(b + p + k, b + p + E, b + k + E, p + k + E) - a(T + L + x, T + L + C, T + x + C, L + x + C);
+                default:
+                  for (var M = l.slice().sort(o), g = u.slice().sort(o), P = 0; P < c; ++P) if (f = M[P] - g[P], f) return f;
+                  return 0;
+              }
+            }
+          }, 8512: function(i, a, o) {
+            var s = o(665);
+            i.exports = l;
+            function l(u, c, f) {
+              typeof u == "function" && (f = !!c, c = u, u = window);
+              var h = s("ex", u), d = function(v) {
+                f && v.preventDefault();
+                var _ = v.deltaX || 0, b = v.deltaY || 0, p = v.deltaZ || 0, k = v.deltaMode, E = 1;
+                switch (k) {
+                  case 1:
+                    E = h;
+                    break;
+                  case 2:
+                    E = window.innerHeight;
+                    break;
+                }
+                if (_ *= E, b *= E, p *= E, _ || b || p) return c(_, b, p, v);
+              };
+              return u.addEventListener("wheel", d), d;
+            }
+          }, 8545: function(i) {
+            i.exports = o;
+            function a(s, l) {
+              var u = s + l, c = u - s, f = u - c, h = l - c, d = s - f, v = d + h;
+              return v ? [v, u] : [u];
+            }
+            function o(s, l) {
+              var u = s.length | 0, c = l.length | 0;
+              if (u === 1 && c === 1) return a(s[0], -l[0]);
+              var f = u + c, h = new Array(f), d = 0, v = 0, _ = 0, b = Math.abs, p = s[v], k = b(p), E = -l[_], T = b(E), L, x;
+              k < T ? (x = p, v += 1, v < u && (p = s[v], k = b(p))) : (x = E, _ += 1, _ < c && (E = -l[_], T = b(E))), v < u && k < T || _ >= c ? (L = p, v += 1, v < u && (p = s[v], k = b(p))) : (L = E, _ += 1, _ < c && (E = -l[_], T = b(E)));
+              for (var C = L + x, M = C - L, g = x - M, P = g, A = C, z, O, U, G, Z; v < u && _ < c; ) k < T ? (L = p, v += 1, v < u && (p = s[v], k = b(p))) : (L = E, _ += 1, _ < c && (E = -l[_], T = b(E))), x = P, C = L + x, M = C - L, g = x - M, g && (h[d++] = g), z = A + C, O = z - A, U = z - O, G = C - O, Z = A - U, P = Z + G, A = z;
+              for (; v < u; ) L = p, x = P, C = L + x, M = C - L, g = x - M, g && (h[d++] = g), z = A + C, O = z - A, U = z - O, G = C - O, Z = A - U, P = Z + G, A = z, v += 1, v < u && (p = s[v]);
+              for (; _ < c; ) L = E, x = P, C = L + x, M = C - L, g = x - M, g && (h[d++] = g), z = A + C, O = z - A, U = z - O, G = C - O, Z = A - U, P = Z + G, A = z, _ += 1, _ < c && (E = -l[_]);
+              return P && (h[d++] = P), A && (h[d++] = A), d || (h[d++] = 0), h.length = d, h;
+            }
+          }, 8572: function(i) {
+            i.exports = function(o) {
+              return o < 0 ? -1 : o > 0 ? 1 : 0;
+            };
+          }, 8648: function(i, a, o) {
+            i.exports = o(783);
+          }, 8692: function(i) {
+            i.exports = a;
+            function a(o, s, l, u) {
+              var c = l[0], f = l[1], h = s[0] - c, d = s[1] - f, v = Math.sin(u), _ = Math.cos(u);
+              return o[0] = c + h * _ - d * v, o[1] = f + h * v + d * _, o[2] = s[2], o;
+            }
+          }, 8697: function(i, a, o) {
+            var s = o(869);
+            i.exports = l;
+            function l(u, c) {
+              return s(u[0].mul(c[1]), u[1].mul(c[0]));
+            }
+          }, 8731: function(i, a, o) {
+            i.exports = d;
+            var s = o(8866);
+            function l(v, _, b, p, k, E) {
+              this._gl = v, this._wrapper = _, this._index = b, this._locations = p, this._dimension = k, this._constFunc = E;
+            }
+            var u = l.prototype;
+            u.pointer = function(_, b, p, k) {
+              var E = this, T = E._gl, L = E._locations[E._index];
+              T.vertexAttribPointer(L, E._dimension, _ || T.FLOAT, !!b, p || 0, k || 0), T.enableVertexAttribArray(L);
+            }, u.set = function(v, _, b, p) {
+              return this._constFunc(this._locations[this._index], v, _, b, p);
+            }, Object.defineProperty(u, "location", { get: function() {
+              return this._locations[this._index];
+            }, set: function(v) {
+              return v !== this._locations[this._index] && (this._locations[this._index] = v | 0, this._wrapper.program = null), v | 0;
+            } });
+            var c = [function(v, _, b) {
+              return b.length === void 0 ? v.vertexAttrib1f(_, b) : v.vertexAttrib1fv(_, b);
+            }, function(v, _, b, p) {
+              return b.length === void 0 ? v.vertexAttrib2f(_, b, p) : v.vertexAttrib2fv(_, b);
+            }, function(v, _, b, p, k) {
+              return b.length === void 0 ? v.vertexAttrib3f(_, b, p, k) : v.vertexAttrib3fv(_, b);
+            }, function(v, _, b, p, k, E) {
+              return b.length === void 0 ? v.vertexAttrib4f(_, b, p, k, E) : v.vertexAttrib4fv(_, b);
+            }];
+            function f(v, _, b, p, k, E, T) {
+              var L = c[k], x = new l(v, _, b, p, k, L);
+              Object.defineProperty(E, T, { set: function(C) {
+                return v.disableVertexAttribArray(p[b]), L(v, p[b], C), C;
+              }, get: function() {
+                return x;
+              }, enumerable: true });
+            }
+            function h(v, _, b, p, k, E, T) {
+              for (var L = new Array(k), x = new Array(k), C = 0; C < k; ++C) f(v, _, b[C], p, k, L, C), x[C] = L[C];
+              Object.defineProperty(L, "location", { set: function(P) {
+                if (Array.isArray(P)) for (var A = 0; A < k; ++A) x[A].location = P[A];
+                else for (var A = 0; A < k; ++A) x[A].location = P + A;
+                return P;
+              }, get: function() {
+                for (var P = new Array(k), A = 0; A < k; ++A) P[A] = p[b[A]];
+                return P;
+              }, enumerable: true }), L.pointer = function(P, A, z, O) {
+                P = P || v.FLOAT, A = !!A, z = z || k * k, O = O || 0;
+                for (var U = 0; U < k; ++U) {
+                  var G = p[b[U]];
+                  v.vertexAttribPointer(G, k, P, A, z, O + U * k), v.enableVertexAttribArray(G);
+                }
+              };
+              var M = new Array(k), g = v["vertexAttrib" + k + "fv"];
+              Object.defineProperty(E, T, { set: function(P) {
+                for (var A = 0; A < k; ++A) {
+                  var z = p[b[A]];
+                  if (v.disableVertexAttribArray(z), Array.isArray(P[0])) g.call(v, z, P[A]);
+                  else {
+                    for (var O = 0; O < k; ++O) M[O] = P[k * A + O];
+                    g.call(v, z, M);
+                  }
+                }
+                return P;
+              }, get: function() {
+                return L;
+              }, enumerable: true });
+            }
+            function d(v, _, b, p) {
+              for (var k = {}, E = 0, T = b.length; E < T; ++E) {
+                var L = b[E], x = L.name, C = L.type, M = L.locations;
+                switch (C) {
+                  case "bool":
+                  case "int":
+                  case "float":
+                    f(v, _, M[0], p, 1, k, x);
+                    break;
+                  default:
+                    if (C.indexOf("vec") >= 0) {
+                      var g = C.charCodeAt(C.length - 1) - 48;
+                      if (g < 2 || g > 4) throw new s("", "Invalid data type for attribute " + x + ": " + C);
+                      f(v, _, M[0], p, g, k, x);
+                    } else if (C.indexOf("mat") >= 0) {
+                      var g = C.charCodeAt(C.length - 1) - 48;
+                      if (g < 2 || g > 4) throw new s("", "Invalid data type for attribute " + x + ": " + C);
+                      h(v, _, M, p, g, k, x);
+                    } else throw new s("", "Unknown data type for attribute " + x + ": " + C);
+                    break;
+                }
+              }
+              return k;
+            }
+          }, 8828: function(i, a) {
+            "use restrict";
+            var o = 32;
+            a.INT_BITS = o, a.INT_MAX = 2147483647, a.INT_MIN = -1 << o - 1, a.sign = function(u) {
+              return (u > 0) - (u < 0);
+            }, a.abs = function(u) {
+              var c = u >> o - 1;
+              return (u ^ c) - c;
+            }, a.min = function(u, c) {
+              return c ^ (u ^ c) & -(u < c);
+            }, a.max = function(u, c) {
+              return u ^ (u ^ c) & -(u < c);
+            }, a.isPow2 = function(u) {
+              return !(u & u - 1) && !!u;
+            }, a.log2 = function(u) {
+              var c, f;
+              return c = (u > 65535) << 4, u >>>= c, f = (u > 255) << 3, u >>>= f, c |= f, f = (u > 15) << 2, u >>>= f, c |= f, f = (u > 3) << 1, u >>>= f, c |= f, c | u >> 1;
+            }, a.log10 = function(u) {
+              return u >= 1e9 ? 9 : u >= 1e8 ? 8 : u >= 1e7 ? 7 : u >= 1e6 ? 6 : u >= 1e5 ? 5 : u >= 1e4 ? 4 : u >= 1e3 ? 3 : u >= 100 ? 2 : u >= 10 ? 1 : 0;
+            }, a.popCount = function(u) {
+              return u = u - (u >>> 1 & 1431655765), u = (u & 858993459) + (u >>> 2 & 858993459), (u + (u >>> 4) & 252645135) * 16843009 >>> 24;
+            };
+            function s(u) {
+              var c = 32;
+              return u &= -u, u && c--, u & 65535 && (c -= 16), u & 16711935 && (c -= 8), u & 252645135 && (c -= 4), u & 858993459 && (c -= 2), u & 1431655765 && (c -= 1), c;
+            }
+            a.countTrailingZeros = s, a.nextPow2 = function(u) {
+              return u += u === 0, --u, u |= u >>> 1, u |= u >>> 2, u |= u >>> 4, u |= u >>> 8, u |= u >>> 16, u + 1;
+            }, a.prevPow2 = function(u) {
+              return u |= u >>> 1, u |= u >>> 2, u |= u >>> 4, u |= u >>> 8, u |= u >>> 16, u - (u >>> 1);
+            }, a.parity = function(u) {
+              return u ^= u >>> 16, u ^= u >>> 8, u ^= u >>> 4, u &= 15, 27030 >>> u & 1;
+            };
+            var l = new Array(256);
+            (function(u) {
+              for (var c = 0; c < 256; ++c) {
+                var f = c, h = c, d = 7;
+                for (f >>>= 1; f; f >>>= 1) h <<= 1, h |= f & 1, --d;
+                u[c] = h << d & 255;
+              }
+            })(l), a.reverse = function(u) {
+              return l[u & 255] << 24 | l[u >>> 8 & 255] << 16 | l[u >>> 16 & 255] << 8 | l[u >>> 24 & 255];
+            }, a.interleave2 = function(u, c) {
+              return u &= 65535, u = (u | u << 8) & 16711935, u = (u | u << 4) & 252645135, u = (u | u << 2) & 858993459, u = (u | u << 1) & 1431655765, c &= 65535, c = (c | c << 8) & 16711935, c = (c | c << 4) & 252645135, c = (c | c << 2) & 858993459, c = (c | c << 1) & 1431655765, u | c << 1;
+            }, a.deinterleave2 = function(u, c) {
+              return u = u >>> c & 1431655765, u = (u | u >>> 1) & 858993459, u = (u | u >>> 2) & 252645135, u = (u | u >>> 4) & 16711935, u = (u | u >>> 16) & 65535, u << 16 >> 16;
+            }, a.interleave3 = function(u, c, f) {
+              return u &= 1023, u = (u | u << 16) & 4278190335, u = (u | u << 8) & 251719695, u = (u | u << 4) & 3272356035, u = (u | u << 2) & 1227133513, c &= 1023, c = (c | c << 16) & 4278190335, c = (c | c << 8) & 251719695, c = (c | c << 4) & 3272356035, c = (c | c << 2) & 1227133513, u |= c << 1, f &= 1023, f = (f | f << 16) & 4278190335, f = (f | f << 8) & 251719695, f = (f | f << 4) & 3272356035, f = (f | f << 2) & 1227133513, u | f << 2;
+            }, a.deinterleave3 = function(u, c) {
+              return u = u >>> c & 1227133513, u = (u | u >>> 2) & 3272356035, u = (u | u >>> 4) & 251719695, u = (u | u >>> 8) & 4278190335, u = (u | u >>> 16) & 1023, u << 22 >> 22;
+            }, a.nextCombination = function(u) {
+              var c = u | u - 1;
+              return c + 1 | (~c & -~c) - 1 >>> s(u) + 1;
+            };
+          }, 8866: function(i) {
+            function a(o, s, l) {
+              this.shortMessage = s || "", this.longMessage = l || "", this.rawError = o || "", this.message = "gl-shader: " + (s || o || "") + (l ? `
+` + l : ""), this.stack = new Error().stack;
+            }
+            a.prototype = new Error(), a.prototype.name = "GLError", a.prototype.constructor = a, i.exports = a;
+          }, 8902: function(i, a, o) {
+            var s = o(2478), l = o(3250)[3], u = 0, c = 1, f = 2;
+            i.exports = T;
+            function h(L, x, C, M, g) {
+              this.a = L, this.b = x, this.idx = C, this.lowerIds = M, this.upperIds = g;
+            }
+            function d(L, x, C, M) {
+              this.a = L, this.b = x, this.type = C, this.idx = M;
+            }
+            function v(L, x) {
+              var C = L.a[0] - x.a[0] || L.a[1] - x.a[1] || L.type - x.type;
+              return C || L.type !== u && (C = l(L.a, L.b, x.b), C) ? C : L.idx - x.idx;
+            }
+            function _(L, x) {
+              return l(L.a, L.b, x);
+            }
+            function b(L, x, C, M, g) {
+              for (var P = s.lt(x, M, _), A = s.gt(x, M, _), z = P; z < A; ++z) {
+                for (var O = x[z], U = O.lowerIds, Z = U.length; Z > 1 && l(C[U[Z - 2]], C[U[Z - 1]], M) > 0; ) L.push([U[Z - 1], U[Z - 2], g]), Z -= 1;
+                U.length = Z, U.push(g);
+                for (var G = O.upperIds, Z = G.length; Z > 1 && l(C[G[Z - 2]], C[G[Z - 1]], M) < 0; ) L.push([G[Z - 2], G[Z - 1], g]), Z -= 1;
+                G.length = Z, G.push(g);
+              }
+            }
+            function p(L, x) {
+              var C;
+              return L.a[0] < x.a[0] ? C = l(L.a, L.b, x.a) : C = l(x.b, x.a, L.a), C || (x.b[0] < L.b[0] ? C = l(L.a, L.b, x.b) : C = l(x.b, x.a, L.b), C || L.idx - x.idx);
+            }
+            function k(L, x, C) {
+              var M = s.le(L, C, p), g = L[M], P = g.upperIds, A = P[P.length - 1];
+              g.upperIds = [A], L.splice(M + 1, 0, new h(C.a, C.b, C.idx, [A], P));
+            }
+            function E(L, x, C) {
+              var M = C.a;
+              C.a = C.b, C.b = M;
+              var g = s.eq(L, C, p), P = L[g], A = L[g - 1];
+              A.upperIds = P.upperIds, L.splice(g, 1);
+            }
+            function T(L, x) {
+              for (var C = L.length, M = x.length, g = [], P = 0; P < C; ++P) g.push(new d(L[P], null, u, P));
+              for (var P = 0; P < M; ++P) {
+                var A = x[P], z = L[A[0]], O = L[A[1]];
+                z[0] < O[0] ? g.push(new d(z, O, f, P), new d(O, z, c, P)) : z[0] > O[0] && g.push(new d(O, z, f, P), new d(z, O, c, P));
+              }
+              g.sort(v);
+              for (var U = g[0].a[0] - (1 + Math.abs(g[0].a[0])) * Math.pow(2, -52), G = [new h([U, 1], [U, 0], -1, [], [])], Z = [], P = 0, j = g.length; P < j; ++P) {
+                var N = g[P], H = N.type;
+                H === u ? b(Z, G, L, N.a, N.idx) : H === f ? k(G, L, N) : E(G, L, N);
+              }
+              return Z;
+            }
+          }, 8954: function(i, a, o) {
+            i.exports = p;
+            var s = o(3250), l = o(6803).Fw;
+            function u(k, E, T) {
+              this.vertices = k, this.adjacent = E, this.boundary = T, this.lastVisited = -1;
+            }
+            u.prototype.flip = function() {
+              var k = this.vertices[0];
+              this.vertices[0] = this.vertices[1], this.vertices[1] = k;
+              var E = this.adjacent[0];
+              this.adjacent[0] = this.adjacent[1], this.adjacent[1] = E;
+            };
+            function c(k, E, T) {
+              this.vertices = k, this.cell = E, this.index = T;
+            }
+            function f(k, E) {
+              return l(k.vertices, E.vertices);
+            }
+            function h(k) {
+              return function() {
+                var E = this.tuple;
+                return k.apply(this, E);
+              };
+            }
+            function d(k) {
+              var E = s[k + 1];
+              return E || (E = s), h(E);
+            }
+            var v = [];
+            function _(k, E, T) {
+              this.dimension = k, this.vertices = E, this.simplices = T, this.interior = T.filter(function(C) {
+                return !C.boundary;
+              }), this.tuple = new Array(k + 1);
+              for (var L = 0; L <= k; ++L) this.tuple[L] = this.vertices[L];
+              var x = v[k];
+              x || (x = v[k] = d(k)), this.orient = x;
+            }
+            var b = _.prototype;
+            b.handleBoundaryDegeneracy = function(k, E) {
+              var T = this.dimension, L = this.vertices.length - 1, x = this.tuple, C = this.vertices, M = [k];
+              for (k.lastVisited = -L; M.length > 0; ) {
+                k = M.pop();
+                for (var g = k.adjacent, P = 0; P <= T; ++P) {
+                  var A = g[P];
+                  if (!(!A.boundary || A.lastVisited <= -L)) {
+                    for (var z = A.vertices, O = 0; O <= T; ++O) {
+                      var U = z[O];
+                      U < 0 ? x[O] = E : x[O] = C[U];
+                    }
+                    var G = this.orient();
+                    if (G > 0) return A;
+                    A.lastVisited = -L, G === 0 && M.push(A);
+                  }
+                }
+              }
+              return null;
+            }, b.walk = function(k, E) {
+              var T = this.vertices.length - 1, L = this.dimension, x = this.vertices, C = this.tuple, M = E ? this.interior.length * Math.random() | 0 : this.interior.length - 1, g = this.interior[M];
+              e: for (; !g.boundary; ) {
+                for (var P = g.vertices, A = g.adjacent, z = 0; z <= L; ++z) C[z] = x[P[z]];
+                g.lastVisited = T;
+                for (var z = 0; z <= L; ++z) {
+                  var O = A[z];
+                  if (!(O.lastVisited >= T)) {
+                    var U = C[z];
+                    C[z] = k;
+                    var G = this.orient();
+                    if (C[z] = U, G < 0) {
+                      g = O;
+                      continue e;
+                    } else O.boundary ? O.lastVisited = -T : O.lastVisited = T;
+                  }
+                }
+                return;
+              }
+              return g;
+            }, b.addPeaks = function(k, E) {
+              var T = this.vertices.length - 1, L = this.dimension, x = this.vertices, C = this.tuple, M = this.interior, g = this.simplices, P = [E];
+              E.lastVisited = T, E.vertices[E.vertices.indexOf(-1)] = T, E.boundary = false, M.push(E);
+              for (var A = []; P.length > 0; ) {
+                var E = P.pop(), z = E.vertices, O = E.adjacent, U = z.indexOf(T);
+                if (!(U < 0)) {
+                  for (var G = 0; G <= L; ++G) if (G !== U) {
+                    var Z = O[G];
+                    if (!(!Z.boundary || Z.lastVisited >= T)) {
+                      var j = Z.vertices;
+                      if (Z.lastVisited !== -T) {
+                        for (var N = 0, H = 0; H <= L; ++H) j[H] < 0 ? (N = H, C[H] = k) : C[H] = x[j[H]];
+                        var re = this.orient();
+                        if (re > 0) {
+                          j[N] = T, Z.boundary = false, M.push(Z), P.push(Z), Z.lastVisited = T;
+                          continue;
+                        } else Z.lastVisited = -T;
+                      }
+                      var oe = Z.adjacent, _e = z.slice(), Ce = O.slice(), Le = new u(_e, Ce, true);
+                      g.push(Le);
+                      var ge = oe.indexOf(E);
+                      if (!(ge < 0)) {
+                        oe[ge] = Le, Ce[U] = Z, _e[G] = -1, Ce[G] = E, O[G] = Le, Le.flip();
+                        for (var H = 0; H <= L; ++H) {
+                          var ie = _e[H];
+                          if (!(ie < 0 || ie === T)) {
+                            for (var Se = new Array(L - 1), Ee = 0, Ae = 0; Ae <= L; ++Ae) {
+                              var Be = _e[Ae];
+                              Be < 0 || Ae === H || (Se[Ee++] = Be);
+                            }
+                            A.push(new c(Se, Le, H));
+                          }
+                        }
+                      }
+                    }
+                  }
+                }
+              }
+              A.sort(f);
+              for (var G = 0; G + 1 < A.length; G += 2) {
+                var Pe = A[G], me = A[G + 1], De = Pe.index, ce = me.index;
+                De < 0 || ce < 0 || (Pe.cell.adjacent[Pe.index] = me.cell, me.cell.adjacent[me.index] = Pe.cell);
+              }
+            }, b.insert = function(k, E) {
+              var T = this.vertices;
+              T.push(k);
+              var L = this.walk(k, E);
+              if (L) {
+                for (var x = this.dimension, C = this.tuple, M = 0; M <= x; ++M) {
+                  var g = L.vertices[M];
+                  g < 0 ? C[M] = k : C[M] = T[g];
+                }
+                var P = this.orient(C);
+                P < 0 || P === 0 && (L = this.handleBoundaryDegeneracy(L, k), !L) || this.addPeaks(k, L);
+              }
+            }, b.boundary = function() {
+              for (var k = this.dimension, E = [], T = this.simplices, L = T.length, x = 0; x < L; ++x) {
+                var C = T[x];
+                if (C.boundary) {
+                  for (var M = new Array(k), g = C.vertices, P = 0, A = 0, z = 0; z <= k; ++z) g[z] >= 0 ? M[P++] = g[z] : A = z & 1;
+                  if (A === (k & 1)) {
+                    var O = M[0];
+                    M[0] = M[1], M[1] = O;
+                  }
+                  E.push(M);
+                }
+              }
+              return E;
+            };
+            function p(k, E) {
+              var T = k.length;
+              if (T === 0) throw new Error("Must have at least d+1 points");
+              var L = k[0].length;
+              if (T <= L) throw new Error("Must input at least d+1 points");
+              var x = k.slice(0, L + 1), C = s.apply(void 0, x);
+              if (C === 0) throw new Error("Input not in general position");
+              for (var M = new Array(L + 1), g = 0; g <= L; ++g) M[g] = g;
+              C < 0 && (M[0] = 1, M[1] = 0);
+              for (var P = new u(M, new Array(L + 1), false), A = P.adjacent, z = new Array(L + 2), g = 0; g <= L; ++g) {
+                for (var O = M.slice(), U = 0; U <= L; ++U) U === g && (O[U] = -1);
+                var G = O[0];
+                O[0] = O[1], O[1] = G;
+                var Z = new u(O, new Array(L + 1), true);
+                A[g] = Z, z[g] = Z;
+              }
+              z[L + 1] = P;
+              for (var g = 0; g <= L; ++g) for (var O = A[g].vertices, j = A[g].adjacent, U = 0; U <= L; ++U) {
+                var N = O[U];
+                if (N < 0) {
+                  j[U] = P;
+                  continue;
+                }
+                for (var H = 0; H <= L; ++H) A[H].vertices.indexOf(N) < 0 && (j[U] = A[H]);
+              }
+              for (var re = new _(L, x, z), oe = !!E, g = L + 1; g < T; ++g) re.insert(k[g], oe);
+              return re.boundary();
+            }
+          }, 8987: function(i, a, o) {
+            var s = o(7842), l = o(6504);
+            i.exports = u;
+            function u(c, f) {
+              for (var h = s(f), d = c.length, v = new Array(d), _ = 0; _ < d; ++_) v[_] = l(c[_], h);
+              return v;
+            }
+          }, 9060: function(i, a, o) {
+            var s = o(9405), l = o(2762), u = o(8116), c = o(7766), f = o(6760), h = o(7608), d = o(9618), v = o(6729), _ = [1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1];
+            function b(C, M, g, P, A, z, O, U, G, Z, j) {
+              this.gl = C, this.pixelRatio = 1, this.cells = [], this.positions = [], this.intensity = [], this.texture = M, this.dirty = true, this.triShader = g, this.pickShader = P, this.trianglePositions = A, this.triangleVectors = z, this.triangleColors = U, this.triangleUVs = G, this.triangleIds = O, this.triangleVAO = Z, this.triangleCount = 0, this.pickId = 1, this.bounds = [[1 / 0, 1 / 0, 1 / 0], [-1 / 0, -1 / 0, -1 / 0]], this.clipBounds = [[-1 / 0, -1 / 0, -1 / 0], [1 / 0, 1 / 0, 1 / 0]], this.lightPosition = [1e5, 1e5, 0], this.ambientLight = 0.8, this.diffuseLight = 0.8, this.specularLight = 2, this.roughness = 0.5, this.fresnel = 1.5, this.opacity = 1, this.traceType = j, this.tubeScale = 1, this.coneScale = 2, this.vectorScale = 1, this.coneOffset = 0.25, this._model = _, this._view = _, this._projection = _, this._resolution = [1, 1];
+            }
+            var p = b.prototype;
+            p.isOpaque = function() {
+              return this.opacity >= 1;
+            }, p.isTransparent = function() {
+              return this.opacity < 1;
+            }, p.pickSlots = 1, p.setPickBase = function(C) {
+              this.pickId = C;
+            };
+            function k(C) {
+              for (var M = v({ colormap: C, nshades: 256, format: "rgba" }), g = new Uint8Array(256 * 4), P = 0; P < 256; ++P) {
+                for (var A = M[P], z = 0; z < 3; ++z) g[4 * P + z] = A[z];
+                g[4 * P + 3] = A[3] * 255;
+              }
+              return d(g, [256, 256, 4], [4, 0, 1]);
+            }
+            function E(C) {
+              for (var M = C.length, g = new Array(M), P = 0; P < M; ++P) g[P] = C[P][2];
+              return g;
+            }
+            p.update = function(C) {
+              C = C || {};
+              var M = this.gl;
+              this.dirty = true, "lightPosition" in C && (this.lightPosition = C.lightPosition), "opacity" in C && (this.opacity = C.opacity), "ambient" in C && (this.ambientLight = C.ambient), "diffuse" in C && (this.diffuseLight = C.diffuse), "specular" in C && (this.specularLight = C.specular), "roughness" in C && (this.roughness = C.roughness), "fresnel" in C && (this.fresnel = C.fresnel), C.tubeScale !== void 0 && (this.tubeScale = C.tubeScale), C.vectorScale !== void 0 && (this.vectorScale = C.vectorScale), C.coneScale !== void 0 && (this.coneScale = C.coneScale), C.coneOffset !== void 0 && (this.coneOffset = C.coneOffset), C.colormap && (this.texture.shape = [256, 256], this.texture.minFilter = M.LINEAR_MIPMAP_LINEAR, this.texture.magFilter = M.LINEAR, this.texture.setPixels(k(C.colormap)), this.texture.generateMipmap());
+              var g = C.cells, P = C.positions, A = C.vectors;
+              if (!(!P || !g || !A)) {
+                var z = [], O = [], U = [], G = [], Z = [];
+                this.cells = g, this.positions = P, this.vectors = A;
+                var j = C.meshColor || [1, 1, 1, 1], N = C.vertexIntensity, H = 1 / 0, re = -1 / 0;
+                if (N) if (C.vertexIntensityBounds) H = +C.vertexIntensityBounds[0], re = +C.vertexIntensityBounds[1];
+                else for (var oe = 0; oe < N.length; ++oe) {
+                  var _e = N[oe];
+                  H = Math.min(H, _e), re = Math.max(re, _e);
+                }
+                else for (var oe = 0; oe < P.length; ++oe) {
+                  var _e = P[oe][2];
+                  H = Math.min(H, _e), re = Math.max(re, _e);
+                }
+                N ? this.intensity = N : this.intensity = E(P), this.bounds = [[1 / 0, 1 / 0, 1 / 0], [-1 / 0, -1 / 0, -1 / 0]];
+                for (var oe = 0; oe < P.length; ++oe) for (var Ce = P[oe], Le = 0; Le < 3; ++Le) isNaN(Ce[Le]) || !isFinite(Ce[Le]) || (this.bounds[0][Le] = Math.min(this.bounds[0][Le], Ce[Le]), this.bounds[1][Le] = Math.max(this.bounds[1][Le], Ce[Le]));
+                var ge = 0;
+                e: for (var oe = 0; oe < g.length; ++oe) {
+                  var ie = g[oe];
+                  switch (ie.length) {
+                    case 3:
+                      for (var Le = 0; Le < 3; ++Le) for (var Se = ie[Le], Ce = P[Se], Ee = 0; Ee < 3; ++Ee) if (isNaN(Ce[Ee]) || !isFinite(Ce[Ee])) continue e;
+                      for (var Le = 0; Le < 3; ++Le) {
+                        var Se = ie[2 - Le], Ce = P[Se];
+                        z.push(Ce[0], Ce[1], Ce[2], Ce[3]);
+                        var Ae = A[Se];
+                        O.push(Ae[0], Ae[1], Ae[2], Ae[3] || 0);
+                        var Be = j;
+                        Be.length === 3 ? U.push(Be[0], Be[1], Be[2], 1) : U.push(Be[0], Be[1], Be[2], Be[3]);
+                        var Pe;
+                        N ? Pe = [(N[Se] - H) / (re - H), 0] : Pe = [(Ce[2] - H) / (re - H), 0], G.push(Pe[0], Pe[1]), Z.push(oe);
+                      }
+                      ge += 1;
+                      break;
+                  }
+                }
+                this.triangleCount = ge, this.trianglePositions.update(z), this.triangleVectors.update(O), this.triangleColors.update(U), this.triangleUVs.update(G), this.triangleIds.update(new Uint32Array(Z));
+              }
+            }, p.drawTransparent = p.draw = function(C) {
+              C = C || {};
+              for (var M = this.gl, g = C.model || _, P = C.view || _, A = C.projection || _, z = [[-1e6, -1e6, -1e6], [1e6, 1e6, 1e6]], O = 0; O < 3; ++O) z[0][O] = Math.max(z[0][O], this.clipBounds[0][O]), z[1][O] = Math.min(z[1][O], this.clipBounds[1][O]);
+              var U = { model: g, view: P, projection: A, inverseModel: _.slice(), clipBounds: z, kambient: this.ambientLight, kdiffuse: this.diffuseLight, kspecular: this.specularLight, roughness: this.roughness, fresnel: this.fresnel, eyePosition: [0, 0, 0], lightPosition: [0, 0, 0], opacity: this.opacity, tubeScale: this.tubeScale, vectorScale: this.vectorScale, coneScale: this.coneScale, coneOffset: this.coneOffset, texture: 0 };
+              U.inverseModel = h(U.inverseModel, U.model), M.disable(M.CULL_FACE), this.texture.bind(0);
+              var G = new Array(16);
+              f(G, U.view, U.model), f(G, U.projection, G), h(G, G);
+              for (var O = 0; O < 3; ++O) U.eyePosition[O] = G[12 + O] / G[15];
+              for (var Z = G[15], O = 0; O < 3; ++O) Z += this.lightPosition[O] * G[4 * O + 3];
+              for (var O = 0; O < 3; ++O) {
+                for (var j = G[12 + O], N = 0; N < 3; ++N) j += G[4 * N + O] * this.lightPosition[N];
+                U.lightPosition[O] = j / Z;
+              }
+              if (this.triangleCount > 0) {
+                var H = this.triShader;
+                H.bind(), H.uniforms = U, this.triangleVAO.bind(), M.drawArrays(M.TRIANGLES, 0, this.triangleCount * 3), this.triangleVAO.unbind();
+              }
+            }, p.drawPick = function(C) {
+              C = C || {};
+              for (var M = this.gl, g = C.model || _, P = C.view || _, A = C.projection || _, z = [[-1e6, -1e6, -1e6], [1e6, 1e6, 1e6]], O = 0; O < 3; ++O) z[0][O] = Math.max(z[0][O], this.clipBounds[0][O]), z[1][O] = Math.min(z[1][O], this.clipBounds[1][O]);
+              this._model = [].slice.call(g), this._view = [].slice.call(P), this._projection = [].slice.call(A), this._resolution = [M.drawingBufferWidth, M.drawingBufferHeight];
+              var U = { model: g, view: P, projection: A, clipBounds: z, tubeScale: this.tubeScale, vectorScale: this.vectorScale, coneScale: this.coneScale, coneOffset: this.coneOffset, pickId: this.pickId / 255 }, G = this.pickShader;
+              G.bind(), G.uniforms = U, this.triangleCount > 0 && (this.triangleVAO.bind(), M.drawArrays(M.TRIANGLES, 0, this.triangleCount * 3), this.triangleVAO.unbind());
+            }, p.pick = function(C) {
+              if (!C || C.id !== this.pickId) return null;
+              var M = C.value[0] + 256 * C.value[1] + 65536 * C.value[2], g = this.cells[M], P = this.positions[g[1]].slice(0, 3), A = { position: P, dataCoordinate: P, index: Math.floor(g[1] / 48) };
+              return this.traceType === "cone" ? A.index = Math.floor(g[1] / 48) : this.traceType === "streamtube" && (A.intensity = this.intensity[g[1]], A.velocity = this.vectors[g[1]].slice(0, 3), A.divergence = this.vectors[g[1]][3], A.index = M), A;
+            }, p.dispose = function() {
+              this.texture.dispose(), this.triShader.dispose(), this.pickShader.dispose(), this.triangleVAO.dispose(), this.trianglePositions.dispose(), this.triangleVectors.dispose(), this.triangleColors.dispose(), this.triangleUVs.dispose(), this.triangleIds.dispose();
+            };
+            function T(C, M) {
+              var g = s(C, M.meshShader.vertex, M.meshShader.fragment, null, M.meshShader.attributes);
+              return g.attributes.position.location = 0, g.attributes.color.location = 2, g.attributes.uv.location = 3, g.attributes.vector.location = 4, g;
+            }
+            function L(C, M) {
+              var g = s(C, M.pickShader.vertex, M.pickShader.fragment, null, M.pickShader.attributes);
+              return g.attributes.position.location = 0, g.attributes.id.location = 1, g.attributes.vector.location = 4, g;
+            }
+            function x(C, M, g) {
+              var P = g.shaders;
+              arguments.length === 1 && (M = C, C = M.gl);
+              var A = T(C, P), z = L(C, P), O = c(C, d(new Uint8Array([255, 255, 255, 255]), [1, 1, 4]));
+              O.generateMipmap(), O.minFilter = C.LINEAR_MIPMAP_LINEAR, O.magFilter = C.LINEAR;
+              var U = l(C), G = l(C), Z = l(C), j = l(C), N = l(C), H = u(C, [{ buffer: U, type: C.FLOAT, size: 4 }, { buffer: N, type: C.UNSIGNED_BYTE, size: 4, normalized: true }, { buffer: Z, type: C.FLOAT, size: 4 }, { buffer: j, type: C.FLOAT, size: 2 }, { buffer: G, type: C.FLOAT, size: 4 }]), re = new b(C, O, A, z, U, G, N, Z, j, H, g.traceType || "cone");
+              return re.update(M), re;
+            }
+            i.exports = x;
+          }, 9127: function(i, a, o) {
+            i.exports = u;
+            var s = o(6204), l = o(5771);
+            function u(c) {
+              return l(s(c));
+            }
+          }, 9131: function(i, a, o) {
+            var s = o(5177), l = o(9288);
+            i.exports = u;
+            function u(c, f) {
+              return f = f || 1, c[0] = Math.random(), c[1] = Math.random(), c[2] = Math.random(), c[3] = Math.random(), s(c, c), l(c, c, f), c;
+            }
+          }, 9165: function(i, a, o) {
+            i.exports = b;
+            var s = o(2762), l = o(8116), u = o(3436), c = [1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1];
+            function f(p, k, E, T) {
+              this.gl = p, this.shader = T, this.buffer = k, this.vao = E, this.pixelRatio = 1, this.bounds = [[1 / 0, 1 / 0, 1 / 0], [-1 / 0, -1 / 0, -1 / 0]], this.clipBounds = [[-1 / 0, -1 / 0, -1 / 0], [1 / 0, 1 / 0, 1 / 0]], this.lineWidth = [1, 1, 1], this.capSize = [10, 10, 10], this.lineCount = [0, 0, 0], this.lineOffset = [0, 0, 0], this.opacity = 1, this.hasAlpha = false;
+            }
+            var h = f.prototype;
+            h.isOpaque = function() {
+              return !this.hasAlpha;
+            }, h.isTransparent = function() {
+              return this.hasAlpha;
+            }, h.drawTransparent = h.draw = function(p) {
+              var k = this.gl, E = this.shader.uniforms;
+              this.shader.bind();
+              var T = E.view = p.view || c, L = E.projection = p.projection || c;
+              E.model = p.model || c, E.clipBounds = this.clipBounds, E.opacity = this.opacity;
+              var x = T[12], C = T[13], M = T[14], g = T[15], P = p._ortho || false, A = P ? 2 : 1, z = A * this.pixelRatio * (L[3] * x + L[7] * C + L[11] * M + L[15] * g) / k.drawingBufferHeight;
+              this.vao.bind();
+              for (var O = 0; O < 3; ++O) k.lineWidth(this.lineWidth[O] * this.pixelRatio), E.capSize = this.capSize[O] * z, this.lineCount[O] && k.drawArrays(k.LINES, this.lineOffset[O], this.lineCount[O]);
+              this.vao.unbind();
+            };
+            function d(p, k) {
+              for (var E = 0; E < 3; ++E) p[0][E] = Math.min(p[0][E], k[E]), p[1][E] = Math.max(p[1][E], k[E]);
+            }
+            var v = function() {
+              for (var p = new Array(3), k = 0; k < 3; ++k) {
+                for (var E = [], T = 1; T <= 2; ++T) for (var L = -1; L <= 1; L += 2) {
+                  var x = (T + k) % 3, C = [0, 0, 0];
+                  C[x] = L, E.push(C);
+                }
+                p[k] = E;
+              }
+              return p;
+            }();
+            function _(p, k, E, T) {
+              for (var L = v[T], x = 0; x < L.length; ++x) {
+                var C = L[x];
+                p.push(k[0], k[1], k[2], E[0], E[1], E[2], E[3], C[0], C[1], C[2]);
+              }
+              return L.length;
+            }
+            h.update = function(p) {
+              p = p || {}, "lineWidth" in p && (this.lineWidth = p.lineWidth, Array.isArray(this.lineWidth) || (this.lineWidth = [this.lineWidth, this.lineWidth, this.lineWidth])), "capSize" in p && (this.capSize = p.capSize, Array.isArray(this.capSize) || (this.capSize = [this.capSize, this.capSize, this.capSize])), this.hasAlpha = false, "opacity" in p && (this.opacity = +p.opacity, this.opacity < 1 && (this.hasAlpha = true));
+              var k = p.color || [[0, 0, 0], [0, 0, 0], [0, 0, 0]], E = p.position, T = p.error;
+              if (Array.isArray(k[0]) || (k = [k, k, k]), E && T) {
+                var L = [], x = E.length, C = 0;
+                this.bounds = [[1 / 0, 1 / 0, 1 / 0], [-1 / 0, -1 / 0, -1 / 0]], this.lineCount = [0, 0, 0];
+                for (var M = 0; M < 3; ++M) {
+                  this.lineOffset[M] = C;
+                  e: for (var g = 0; g < x; ++g) {
+                    for (var P = E[g], A = 0; A < 3; ++A) if (isNaN(P[A]) || !isFinite(P[A])) continue e;
+                    var z = T[g], O = k[M];
+                    if (Array.isArray(O[0]) && (O = k[g]), O.length === 3 ? O = [O[0], O[1], O[2], 1] : O.length === 4 && (O = [O[0], O[1], O[2], O[3]], !this.hasAlpha && O[3] < 1 && (this.hasAlpha = true)), !(isNaN(z[0][M]) || isNaN(z[1][M]))) {
+                      if (z[0][M] < 0) {
+                        var U = P.slice();
+                        U[M] += z[0][M], L.push(P[0], P[1], P[2], O[0], O[1], O[2], O[3], 0, 0, 0, U[0], U[1], U[2], O[0], O[1], O[2], O[3], 0, 0, 0), d(this.bounds, U), C += 2 + _(L, U, O, M);
+                      }
+                      if (z[1][M] > 0) {
+                        var U = P.slice();
+                        U[M] += z[1][M], L.push(P[0], P[1], P[2], O[0], O[1], O[2], O[3], 0, 0, 0, U[0], U[1], U[2], O[0], O[1], O[2], O[3], 0, 0, 0), d(this.bounds, U), C += 2 + _(L, U, O, M);
+                      }
+                    }
+                  }
+                  this.lineCount[M] = C - this.lineOffset[M];
+                }
+                this.buffer.update(L);
+              }
+            }, h.dispose = function() {
+              this.shader.dispose(), this.buffer.dispose(), this.vao.dispose();
+            };
+            function b(p) {
+              var k = p.gl, E = s(k), T = l(k, [{ buffer: E, type: k.FLOAT, size: 3, offset: 0, stride: 40 }, { buffer: E, type: k.FLOAT, size: 4, offset: 12, stride: 40 }, { buffer: E, type: k.FLOAT, size: 3, offset: 28, stride: 40 }]), L = u(k);
+              L.attributes.position.location = 0, L.attributes.color.location = 1, L.attributes.offset.location = 2;
+              var x = new f(k, E, T, L);
+              return x.update(p), x;
+            }
+          }, 9215: function(i, a, o) {
+            i.exports = d;
+            var s = o(4769), l = o(2478);
+            function u(v, _, b) {
+              return Math.min(_, Math.max(v, b));
+            }
+            function c(v, _, b) {
+              this.dimension = v.length, this.bounds = [new Array(this.dimension), new Array(this.dimension)];
+              for (var p = 0; p < this.dimension; ++p) this.bounds[0][p] = -1 / 0, this.bounds[1][p] = 1 / 0;
+              this._state = v.slice().reverse(), this._velocity = _.slice().reverse(), this._time = [b], this._scratch = [v.slice(), v.slice(), v.slice(), v.slice(), v.slice()];
+            }
+            var f = c.prototype;
+            f.flush = function(v) {
+              var _ = l.gt(this._time, v) - 1;
+              _ <= 0 || (this._time.splice(0, _), this._state.splice(0, _ * this.dimension), this._velocity.splice(0, _ * this.dimension));
+            }, f.curve = function(v) {
+              var _ = this._time, b = _.length, p = l.le(_, v), k = this._scratch[0], E = this._state, T = this._velocity, L = this.dimension, x = this.bounds;
+              if (p < 0) for (var C = L - 1, M = 0; M < L; ++M, --C) k[M] = E[C];
+              else if (p >= b - 1) for (var C = E.length - 1, g = v - _[b - 1], M = 0; M < L; ++M, --C) k[M] = E[C] + g * T[C];
+              else {
+                for (var C = L * (p + 1) - 1, P = _[p], A = _[p + 1], z = A - P || 1, O = this._scratch[1], U = this._scratch[2], G = this._scratch[3], Z = this._scratch[4], j = true, M = 0; M < L; ++M, --C) O[M] = E[C], G[M] = T[C] * z, U[M] = E[C + L], Z[M] = T[C + L] * z, j = j && O[M] === U[M] && G[M] === Z[M] && G[M] === 0;
+                if (j) for (var M = 0; M < L; ++M) k[M] = O[M];
+                else s(O, G, U, Z, (v - P) / z, k);
+              }
+              for (var N = x[0], H = x[1], M = 0; M < L; ++M) k[M] = u(N[M], H[M], k[M]);
+              return k;
+            }, f.dcurve = function(v) {
+              var _ = this._time, b = _.length, p = l.le(_, v), k = this._scratch[0], E = this._state, T = this._velocity, L = this.dimension;
+              if (p >= b - 1) for (var x = E.length - 1, C = v - _[b - 1], M = 0; M < L; ++M, --x) k[M] = T[x];
+              else {
+                for (var x = L * (p + 1) - 1, g = _[p], P = _[p + 1], A = P - g || 1, z = this._scratch[1], O = this._scratch[2], U = this._scratch[3], G = this._scratch[4], Z = true, M = 0; M < L; ++M, --x) z[M] = E[x], U[M] = T[x] * A, O[M] = E[x + L], G[M] = T[x + L] * A, Z = Z && z[M] === O[M] && U[M] === G[M] && U[M] === 0;
+                if (Z) for (var M = 0; M < L; ++M) k[M] = 0;
+                else {
+                  s.derivative(z, U, O, G, (v - g) / A, k);
+                  for (var M = 0; M < L; ++M) k[M] /= A;
+                }
+              }
+              return k;
+            }, f.lastT = function() {
+              var v = this._time;
+              return v[v.length - 1];
+            }, f.stable = function() {
+              for (var v = this._velocity, _ = v.length, b = this.dimension - 1; b >= 0; --b) if (v[--_]) return false;
+              return true;
+            }, f.jump = function(v) {
+              var _ = this.lastT(), b = this.dimension;
+              if (!(v < _ || arguments.length !== b + 1)) {
+                var p = this._state, k = this._velocity, E = p.length - this.dimension, T = this.bounds, L = T[0], x = T[1];
+                this._time.push(_, v);
+                for (var C = 0; C < 2; ++C) for (var M = 0; M < b; ++M) p.push(p[E++]), k.push(0);
+                this._time.push(v);
+                for (var M = b; M > 0; --M) p.push(u(L[M - 1], x[M - 1], arguments[M])), k.push(0);
+              }
+            }, f.push = function(v) {
+              var _ = this.lastT(), b = this.dimension;
+              if (!(v < _ || arguments.length !== b + 1)) {
+                var p = this._state, k = this._velocity, E = p.length - this.dimension, T = v - _, L = this.bounds, x = L[0], C = L[1], M = T > 1e-6 ? 1 / T : 0;
+                this._time.push(v);
+                for (var g = b; g > 0; --g) {
+                  var P = u(x[g - 1], C[g - 1], arguments[g]);
+                  p.push(P), k.push((P - p[E++]) * M);
+                }
+              }
+            }, f.set = function(v) {
+              var _ = this.dimension;
+              if (!(v < this.lastT() || arguments.length !== _ + 1)) {
+                var b = this._state, p = this._velocity, k = this.bounds, E = k[0], T = k[1];
+                this._time.push(v);
+                for (var L = _; L > 0; --L) b.push(u(E[L - 1], T[L - 1], arguments[L])), p.push(0);
+              }
+            }, f.move = function(v) {
+              var _ = this.lastT(), b = this.dimension;
+              if (!(v <= _ || arguments.length !== b + 1)) {
+                var p = this._state, k = this._velocity, E = p.length - this.dimension, T = this.bounds, L = T[0], x = T[1], C = v - _, M = C > 1e-6 ? 1 / C : 0;
+                this._time.push(v);
+                for (var g = b; g > 0; --g) {
+                  var P = arguments[g];
+                  p.push(u(L[g - 1], x[g - 1], p[E++] + P)), k.push(P * M);
+                }
+              }
+            }, f.idle = function(v) {
+              var _ = this.lastT();
+              if (!(v < _)) {
+                var b = this.dimension, p = this._state, k = this._velocity, E = p.length - b, T = this.bounds, L = T[0], x = T[1], C = v - _;
+                this._time.push(v);
+                for (var M = b - 1; M >= 0; --M) p.push(u(L[M], x[M], p[E] + C * k[E])), k.push(0), E += 1;
+              }
+            };
+            function h(v) {
+              for (var _ = new Array(v), b = 0; b < v; ++b) _[b] = 0;
+              return _;
+            }
+            function d(v, _, b) {
+              switch (arguments.length) {
+                case 0:
+                  return new c([0], [0], 0);
+                case 1:
+                  if (typeof v == "number") {
+                    var p = h(v);
+                    return new c(p, p, 0);
+                  } else return new c(v, h(v.length), 0);
+                case 2:
+                  if (typeof _ == "number") {
+                    var p = h(v.length);
+                    return new c(v, p, +_);
+                  } else b = 0;
+                case 3:
+                  if (v.length !== _.length) throw new Error("state and velocity lengths must match");
+                  return new c(v, _, b);
+              }
+            }
+          }, 9216: function(i) {
+            i.exports = l, i.exports.isMobile = l, i.exports.default = l;
+            var a = /(android|bb\d+|meego).+mobile|armv7l|avantgo|bada\/|blackberry|blazer|compal|elaine|fennec|hiptop|iemobile|ip(hone|od)|iris|kindle|lge |maemo|midp|mmp|mobile.+firefox|netfront|opera m(ob|in)i|palm( os)?|phone|p(ixi|re)\/|plucker|pocket|psp|series[46]0|samsungbrowser.*mobile|symbian|treo|up\.(browser|link)|vodafone|wap|windows (ce|phone)|xda|xiino/i, o = /CrOS/, s = /android|ipad|playbook|silk/i;
+            function l(u) {
+              u || (u = {});
+              var c = u.ua;
+              if (!c && typeof navigator != "undefined" && (c = navigator.userAgent), c && c.headers && typeof c.headers["user-agent"] == "string" && (c = c.headers["user-agent"]), typeof c != "string") return false;
+              var f = a.test(c) && !o.test(c) || !!u.tablet && s.test(c);
+              return !f && u.tablet && u.featureDetect && navigator && navigator.maxTouchPoints > 1 && c.indexOf("Macintosh") !== -1 && c.indexOf("Safari") !== -1 && (f = true), f;
+            }
+          }, 9226: function(i) {
+            i.exports = a;
+            function a(o, s) {
+              return o[0] = Math.ceil(s[0]), o[1] = Math.ceil(s[1]), o[2] = Math.ceil(s[2]), o;
+            }
+          }, 9265: function(i) {
+            i.exports = a;
+            function a(o, s) {
+              return o[0] === s[0] && o[1] === s[1] && o[2] === s[2];
+            }
+          }, 9288: function(i) {
+            i.exports = a;
+            function a(o, s, l) {
+              return o[0] = s[0] * l, o[1] = s[1] * l, o[2] = s[2] * l, o[3] = s[3] * l, o;
+            }
+          }, 9346: function(i) {
+            var a = new Float64Array(4), o = new Float64Array(4), s = new Float64Array(4);
+            function l(u, c, f, h, d) {
+              a.length < h.length && (a = new Float64Array(h.length), o = new Float64Array(h.length), s = new Float64Array(h.length));
+              for (var v = 0; v < h.length; ++v) a[v] = u[v] - h[v], o[v] = c[v] - u[v], s[v] = f[v] - u[v];
+              for (var _ = 0, b = 0, p = 0, k = 0, E = 0, T = 0, v = 0; v < h.length; ++v) {
+                var L = o[v], x = s[v], C = a[v];
+                _ += L * L, b += L * x, p += x * x, k += C * L, E += C * x, T += C * C;
+              }
+              var M = Math.abs(_ * p - b * b), g = b * E - p * k, P = b * k - _ * E, A;
+              if (g + P <= M) if (g < 0) P < 0 && k < 0 ? (P = 0, -k >= _ ? (g = 1, A = _ + 2 * k + T) : (g = -k / _, A = k * g + T)) : (g = 0, E >= 0 ? (P = 0, A = T) : -E >= p ? (P = 1, A = p + 2 * E + T) : (P = -E / p, A = E * P + T));
+              else if (P < 0) P = 0, k >= 0 ? (g = 0, A = T) : -k >= _ ? (g = 1, A = _ + 2 * k + T) : (g = -k / _, A = k * g + T);
+              else {
+                var z = 1 / M;
+                g *= z, P *= z, A = g * (_ * g + b * P + 2 * k) + P * (b * g + p * P + 2 * E) + T;
+              }
+              else {
+                var O, U, G, Z;
+                g < 0 ? (O = b + k, U = p + E, U > O ? (G = U - O, Z = _ - 2 * b + p, G >= Z ? (g = 1, P = 0, A = _ + 2 * k + T) : (g = G / Z, P = 1 - g, A = g * (_ * g + b * P + 2 * k) + P * (b * g + p * P + 2 * E) + T)) : (g = 0, U <= 0 ? (P = 1, A = p + 2 * E + T) : E >= 0 ? (P = 0, A = T) : (P = -E / p, A = E * P + T))) : P < 0 ? (O = b + E, U = _ + k, U > O ? (G = U - O, Z = _ - 2 * b + p, G >= Z ? (P = 1, g = 0, A = p + 2 * E + T) : (P = G / Z, g = 1 - P, A = g * (_ * g + b * P + 2 * k) + P * (b * g + p * P + 2 * E) + T)) : (P = 0, U <= 0 ? (g = 1, A = _ + 2 * k + T) : k >= 0 ? (g = 0, A = T) : (g = -k / _, A = k * g + T))) : (G = p + E - b - k, G <= 0 ? (g = 0, P = 1, A = p + 2 * E + T) : (Z = _ - 2 * b + p, G >= Z ? (g = 1, P = 0, A = _ + 2 * k + T) : (g = G / Z, P = 1 - g, A = g * (_ * g + b * P + 2 * k) + P * (b * g + p * P + 2 * E) + T)));
+              }
+              for (var j = 1 - g - P, v = 0; v < h.length; ++v) d[v] = j * u[v] + g * c[v] + P * f[v];
+              return A < 0 ? 0 : A;
+            }
+            i.exports = l;
+          }, 9362: function(i) {
+            i.exports = a;
+            function a(o, s, l) {
+              var u = o + s, c = u - o, f = u - c, h = s - c, d = o - f;
+              return l ? (l[0] = d + h, l[1] = u, l) : [d + h, u];
+            }
+          }, 9366: function(i, a, o) {
+            var s = o(4359);
+            i.exports = u;
+            var l = {};
+            function u(c, f, h) {
+              var d = [f.style, f.weight, f.variant, f.family].join("_"), v = l[d];
+              if (v || (v = l[d] = {}), c in v) return v[c];
+              var _ = { textAlign: "center", textBaseline: "middle", lineHeight: 1, font: f.family, fontStyle: f.style, fontWeight: f.weight, fontVariant: f.variant, lineSpacing: 1.25, styletags: { breaklines: true, bolds: true, italics: true, subscripts: true, superscripts: true } };
+              _.triangles = true;
+              var b = s(c, _);
+              _.triangles = false;
+              var p = s(c, _), k, E;
+              if (h && h !== 1) {
+                for (k = 0; k < b.positions.length; ++k) for (E = 0; E < b.positions[k].length; ++E) b.positions[k][E] /= h;
+                for (k = 0; k < p.positions.length; ++k) for (E = 0; E < p.positions[k].length; ++E) p.positions[k][E] /= h;
+              }
+              var T = [[1 / 0, 1 / 0], [-1 / 0, -1 / 0]], L = p.positions.length;
+              for (k = 0; k < L; ++k) {
+                var x = p.positions[k];
+                for (E = 0; E < 2; ++E) T[0][E] = Math.min(T[0][E], x[E]), T[1][E] = Math.max(T[1][E], x[E]);
+              }
+              return v[c] = [b, p, T];
+            }
+          }, 9405: function(i, a, o) {
+            var s = o(3327), l = o(8731), u = o(216), c = o(5091), f = o(2145), h = o(8866);
+            function d(p) {
+              this.gl = p, this.gl.lastAttribCount = 0, this._vref = this._fref = this._relink = this.vertShader = this.fragShader = this.program = this.attributes = this.uniforms = this.types = null;
+            }
+            var v = d.prototype;
+            v.bind = function() {
+              this.program || this._relink();
+              var p, k = this.gl.getProgramParameter(this.program, this.gl.ACTIVE_ATTRIBUTES), E = this.gl.lastAttribCount;
+              if (k > E) for (p = E; p < k; p++) this.gl.enableVertexAttribArray(p);
+              else if (E > k) for (p = k; p < E; p++) this.gl.disableVertexAttribArray(p);
+              this.gl.lastAttribCount = k, this.gl.useProgram(this.program);
+            }, v.dispose = function() {
+              for (var p = this.gl.lastAttribCount, k = 0; k < p; k++) this.gl.disableVertexAttribArray(k);
+              this.gl.lastAttribCount = 0, this._fref && this._fref.dispose(), this._vref && this._vref.dispose(), this.attributes = this.types = this.vertShader = this.fragShader = this.program = this._relink = this._fref = this._vref = null;
+            };
+            function _(p, k) {
+              return p.name < k.name ? -1 : 1;
+            }
+            v.update = function(p, k, E, T) {
+              if (!k || arguments.length === 1) {
+                var L = p;
+                p = L.vertex, k = L.fragment, E = L.uniforms, T = L.attributes;
+              }
+              var x = this, C = x.gl, M = x._vref;
+              x._vref = c.shader(C, C.VERTEX_SHADER, p), M && M.dispose(), x.vertShader = x._vref.shader;
+              var g = this._fref;
+              if (x._fref = c.shader(C, C.FRAGMENT_SHADER, k), g && g.dispose(), x.fragShader = x._fref.shader, !E || !T) {
+                var P = C.createProgram();
+                if (C.attachShader(P, x.fragShader), C.attachShader(P, x.vertShader), C.linkProgram(P), !C.getProgramParameter(P, C.LINK_STATUS)) {
+                  var A = C.getProgramInfoLog(P);
+                  throw new h(A, "Error linking program:" + A);
+                }
+                E = E || f.uniforms(C, P), T = T || f.attributes(C, P), C.deleteProgram(P);
+              }
+              T = T.slice(), T.sort(_);
+              var z = [], O = [], U = [], G;
+              for (G = 0; G < T.length; ++G) {
+                var Z = T[G];
+                if (Z.type.indexOf("mat") >= 0) {
+                  for (var j = Z.type.charAt(Z.type.length - 1) | 0, N = new Array(j), H = 0; H < j; ++H) N[H] = U.length, O.push(Z.name + "[" + H + "]"), typeof Z.location == "number" ? U.push(Z.location + H) : Array.isArray(Z.location) && Z.location.length === j && typeof Z.location[H] == "number" ? U.push(Z.location[H] | 0) : U.push(-1);
+                  z.push({ name: Z.name, type: Z.type, locations: N });
+                } else z.push({ name: Z.name, type: Z.type, locations: [U.length] }), O.push(Z.name), typeof Z.location == "number" ? U.push(Z.location | 0) : U.push(-1);
+              }
+              var re = 0;
+              for (G = 0; G < U.length; ++G) if (U[G] < 0) {
+                for (; U.indexOf(re) >= 0; ) re += 1;
+                U[G] = re;
+              }
+              var oe = new Array(E.length);
+              function _e() {
+                x.program = c.program(C, x._vref, x._fref, O, U);
+                for (var Ce = 0; Ce < E.length; ++Ce) oe[Ce] = C.getUniformLocation(x.program, E[Ce].name);
+              }
+              _e(), x._relink = _e, x.types = { uniforms: u(E), attributes: u(T) }, x.attributes = l(C, x, z, U), Object.defineProperty(x, "uniforms", s(C, x, E, oe));
+            };
+            function b(p, k, E, T, L) {
+              var x = new d(p);
+              return x.update(k, E, T, L), x;
+            }
+            i.exports = b;
+          }, 9499: function(i, a, o) {
+            i.exports = Be;
+            var s = o(8828), l = o(2762), u = o(8116), c = o(7766), f = o(1888), h = o(6729), d = o(5298), v = o(9994), _ = o(9618), b = o(3711), p = o(6760), k = o(7608), E = o(2478), T = o(6199), L = o(990), x = L.createShader, C = L.createContourShader, M = L.createPickShader, g = L.createPickContourShader, P = 4 * 10, A = [1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1], z = [[0, 0], [0, 1], [1, 0], [1, 1], [1, 0], [0, 1]], O = [[0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0]];
+            (function() {
+              for (var Pe = 0; Pe < 3; ++Pe) {
+                var me = O[Pe], De = (Pe + 1) % 3, ce = (Pe + 2) % 3;
+                me[De + 0] = 1, me[ce + 3] = 1, me[Pe + 6] = 1;
+              }
+            })();
+            function U(Pe, me, De, ce, je) {
+              this.position = Pe, this.index = me, this.uv = De, this.level = ce, this.dataCoordinate = je;
+            }
+            var G = 256;
+            function Z(Pe, me, De, ce, je, lt, pt, Vt, ot, ut, Wt, Nt, $t, sr, Tr) {
+              this.gl = Pe, this.shape = me, this.bounds = De, this.objectOffset = Tr, this.intensityBounds = [], this._shader = ce, this._pickShader = je, this._coordinateBuffer = lt, this._vao = pt, this._colorMap = Vt, this._contourShader = ot, this._contourPickShader = ut, this._contourBuffer = Wt, this._contourVAO = Nt, this._contourOffsets = [[], [], []], this._contourCounts = [[], [], []], this._vertexCount = 0, this._pickResult = new U([0, 0, 0], [0, 0], [0, 0], [0, 0, 0], [0, 0, 0]), this._dynamicBuffer = $t, this._dynamicVAO = sr, this._dynamicOffsets = [0, 0, 0], this._dynamicCounts = [0, 0, 0], this.contourWidth = [1, 1, 1], this.contourLevels = [[1], [1], [1]], this.contourTint = [0, 0, 0], this.contourColor = [[0.5, 0.5, 0.5, 1], [0.5, 0.5, 0.5, 1], [0.5, 0.5, 0.5, 1]], this.showContour = true, this.showSurface = true, this.enableHighlight = [true, true, true], this.highlightColor = [[0, 0, 0, 1], [0, 0, 0, 1], [0, 0, 0, 1]], this.highlightTint = [1, 1, 1], this.highlightLevel = [-1, -1, -1], this.enableDynamic = [true, true, true], this.dynamicLevel = [NaN, NaN, NaN], this.dynamicColor = [[0, 0, 0, 1], [0, 0, 0, 1], [0, 0, 0, 1]], this.dynamicTint = [1, 1, 1], this.dynamicWidth = [1, 1, 1], this.axesBounds = [[1 / 0, 1 / 0, 1 / 0], [-1 / 0, -1 / 0, -1 / 0]], this.surfaceProject = [false, false, false], this.contourProject = [[false, false, false], [false, false, false], [false, false, false]], this.colorBounds = [false, false], this._field = [_(f.mallocFloat(1024), [0, 0]), _(f.mallocFloat(1024), [0, 0]), _(f.mallocFloat(1024), [0, 0])], this.pickId = 1, this.clipBounds = [[-1 / 0, -1 / 0, -1 / 0], [1 / 0, 1 / 0, 1 / 0]], this.snapToData = false, this.pixelRatio = 1, this.opacity = 1, this.lightPosition = [10, 1e4, 0], this.ambientLight = 0.8, this.diffuseLight = 0.8, this.specularLight = 2, this.roughness = 0.5, this.fresnel = 1.5, this.vertexColor = 0, this.dirty = true;
+            }
+            var j = Z.prototype;
+            j.genColormap = function(Pe, me) {
+              var De = false, ce = v([h({ colormap: Pe, nshades: G, format: "rgba" }).map(function(je, lt) {
+                var pt = me ? N(lt / 255, me) : je[3];
+                return pt < 1 && (De = true), [je[0], je[1], je[2], 255 * pt];
+              })]);
+              return d.divseq(ce, 255), this.hasAlphaScale = De, ce;
+            }, j.isTransparent = function() {
+              return this.opacity < 1 || this.hasAlphaScale;
+            }, j.isOpaque = function() {
+              return !this.isTransparent();
+            }, j.pickSlots = 1, j.setPickBase = function(Pe) {
+              this.pickId = Pe;
+            };
+            function N(Pe, me) {
+              if (!me || !me.length) return 1;
+              for (var De = 0; De < me.length; ++De) {
+                if (me.length < 2) return 1;
+                if (me[De][0] === Pe) return me[De][1];
+                if (me[De][0] > Pe && De > 0) {
+                  var ce = (me[De][0] - Pe) / (me[De][0] - me[De - 1][0]);
+                  return me[De][1] * (1 - ce) + ce * me[De - 1][1];
+                }
+              }
+              return 1;
+            }
+            var H = [0, 0, 0], re = { showSurface: false, showContour: false, projections: [A.slice(), A.slice(), A.slice()], clipBounds: [[[0, 0, 0], [0, 0, 0]], [[0, 0, 0], [0, 0, 0]], [[0, 0, 0], [0, 0, 0]]] };
+            function oe(Pe, me) {
+              var De, ce, je, lt = me.axes && me.axes.lastCubeProps.axis || H, pt = me.showSurface, Vt = me.showContour;
+              for (De = 0; De < 3; ++De) for (pt = pt || me.surfaceProject[De], ce = 0; ce < 3; ++ce) Vt = Vt || me.contourProject[De][ce];
+              for (De = 0; De < 3; ++De) {
+                var ot = re.projections[De];
+                for (ce = 0; ce < 16; ++ce) ot[ce] = 0;
+                for (ce = 0; ce < 4; ++ce) ot[5 * ce] = 1;
+                ot[5 * De] = 0, ot[12 + De] = me.axesBounds[+(lt[De] > 0)][De], p(ot, Pe.model, ot);
+                var ut = re.clipBounds[De];
+                for (je = 0; je < 2; ++je) for (ce = 0; ce < 3; ++ce) ut[je][ce] = Pe.clipBounds[je][ce];
+                ut[0][De] = -1e8, ut[1][De] = 1e8;
+              }
+              return re.showSurface = pt, re.showContour = Vt, re;
+            }
+            var _e = { model: A, view: A, projection: A, inverseModel: A.slice(), lowerBound: [0, 0, 0], upperBound: [0, 0, 0], colorMap: 0, clipBounds: [[0, 0, 0], [0, 0, 0]], height: 0, contourTint: 0, contourColor: [0, 0, 0, 1], permutation: [1, 0, 0, 0, 1, 0, 0, 0, 1], zOffset: -1e-4, objectOffset: [0, 0, 0], kambient: 1, kdiffuse: 1, kspecular: 1, lightPosition: [1e3, 1e3, 1e3], eyePosition: [0, 0, 0], roughness: 1, fresnel: 1, opacity: 1, vertexColor: 0 }, Ce = A.slice(), Le = [1, 0, 0, 0, 1, 0, 0, 0, 1];
+            function ge(Pe, me) {
+              Pe = Pe || {};
+              var De = this.gl;
+              De.disable(De.CULL_FACE), this._colorMap.bind(0);
+              var ce = _e;
+              ce.model = Pe.model || A, ce.view = Pe.view || A, ce.projection = Pe.projection || A, ce.lowerBound = [this.bounds[0][0], this.bounds[0][1], this.colorBounds[0] || this.bounds[0][2]], ce.upperBound = [this.bounds[1][0], this.bounds[1][1], this.colorBounds[1] || this.bounds[1][2]], ce.objectOffset = this.objectOffset, ce.contourColor = this.contourColor[0], ce.inverseModel = k(ce.inverseModel, ce.model);
+              for (var je = 0; je < 2; ++je) for (var lt = ce.clipBounds[je], pt = 0; pt < 3; ++pt) lt[pt] = Math.min(Math.max(this.clipBounds[je][pt], -1e8), 1e8);
+              ce.kambient = this.ambientLight, ce.kdiffuse = this.diffuseLight, ce.kspecular = this.specularLight, ce.roughness = this.roughness, ce.fresnel = this.fresnel, ce.opacity = this.opacity, ce.height = 0, ce.permutation = Le, ce.vertexColor = this.vertexColor;
+              var Vt = Ce;
+              for (p(Vt, ce.view, ce.model), p(Vt, ce.projection, Vt), k(Vt, Vt), je = 0; je < 3; ++je) ce.eyePosition[je] = Vt[12 + je] / Vt[15];
+              var ot = Vt[15];
+              for (je = 0; je < 3; ++je) ot += this.lightPosition[je] * Vt[4 * je + 3];
+              for (je = 0; je < 3; ++je) {
+                var ut = Vt[12 + je];
+                for (pt = 0; pt < 3; ++pt) ut += Vt[4 * pt + je] * this.lightPosition[pt];
+                ce.lightPosition[je] = ut / ot;
+              }
+              var Wt = oe(ce, this);
+              if (Wt.showSurface) {
+                for (this._shader.bind(), this._shader.uniforms = ce, this._vao.bind(), this.showSurface && this._vertexCount && this._vao.draw(De.TRIANGLES, this._vertexCount), je = 0; je < 3; ++je) !this.surfaceProject[je] || !this.vertexCount || (this._shader.uniforms.model = Wt.projections[je], this._shader.uniforms.clipBounds = Wt.clipBounds[je], this._vao.draw(De.TRIANGLES, this._vertexCount));
+                this._vao.unbind();
+              }
+              if (Wt.showContour) {
+                var Nt = this._contourShader;
+                ce.kambient = 1, ce.kdiffuse = 0, ce.kspecular = 0, ce.opacity = 1, Nt.bind(), Nt.uniforms = ce;
+                var $t = this._contourVAO;
+                for ($t.bind(), je = 0; je < 3; ++je) for (Nt.uniforms.permutation = O[je], De.lineWidth(this.contourWidth[je] * this.pixelRatio), pt = 0; pt < this.contourLevels[je].length; ++pt) pt === this.highlightLevel[je] ? (Nt.uniforms.contourColor = this.highlightColor[je], Nt.uniforms.contourTint = this.highlightTint[je]) : (pt === 0 || pt - 1 === this.highlightLevel[je]) && (Nt.uniforms.contourColor = this.contourColor[je], Nt.uniforms.contourTint = this.contourTint[je]), this._contourCounts[je][pt] && (Nt.uniforms.height = this.contourLevels[je][pt], $t.draw(De.LINES, this._contourCounts[je][pt], this._contourOffsets[je][pt]));
+                for (je = 0; je < 3; ++je) for (Nt.uniforms.model = Wt.projections[je], Nt.uniforms.clipBounds = Wt.clipBounds[je], pt = 0; pt < 3; ++pt) if (this.contourProject[je][pt]) {
+                  Nt.uniforms.permutation = O[pt], De.lineWidth(this.contourWidth[pt] * this.pixelRatio);
+                  for (var sr = 0; sr < this.contourLevels[pt].length; ++sr) sr === this.highlightLevel[pt] ? (Nt.uniforms.contourColor = this.highlightColor[pt], Nt.uniforms.contourTint = this.highlightTint[pt]) : (sr === 0 || sr - 1 === this.highlightLevel[pt]) && (Nt.uniforms.contourColor = this.contourColor[pt], Nt.uniforms.contourTint = this.contourTint[pt]), this._contourCounts[pt][sr] && (Nt.uniforms.height = this.contourLevels[pt][sr], $t.draw(De.LINES, this._contourCounts[pt][sr], this._contourOffsets[pt][sr]));
+                }
+                for ($t.unbind(), $t = this._dynamicVAO, $t.bind(), je = 0; je < 3; ++je) if (this._dynamicCounts[je] !== 0) for (Nt.uniforms.model = ce.model, Nt.uniforms.clipBounds = ce.clipBounds, Nt.uniforms.permutation = O[je], De.lineWidth(this.dynamicWidth[je] * this.pixelRatio), Nt.uniforms.contourColor = this.dynamicColor[je], Nt.uniforms.contourTint = this.dynamicTint[je], Nt.uniforms.height = this.dynamicLevel[je], $t.draw(De.LINES, this._dynamicCounts[je], this._dynamicOffsets[je]), pt = 0; pt < 3; ++pt) this.contourProject[pt][je] && (Nt.uniforms.model = Wt.projections[pt], Nt.uniforms.clipBounds = Wt.clipBounds[pt], $t.draw(De.LINES, this._dynamicCounts[je], this._dynamicOffsets[je]));
+                $t.unbind();
+              }
+            }
+            j.draw = function(Pe) {
+              return ge.call(this, Pe, false);
+            }, j.drawTransparent = function(Pe) {
+              return ge.call(this, Pe, true);
+            };
+            var ie = { model: A, view: A, projection: A, inverseModel: A, clipBounds: [[0, 0, 0], [0, 0, 0]], height: 0, shape: [0, 0], pickId: 0, lowerBound: [0, 0, 0], upperBound: [0, 0, 0], zOffset: 0, objectOffset: [0, 0, 0], permutation: [1, 0, 0, 0, 1, 0, 0, 0, 1], lightPosition: [0, 0, 0], eyePosition: [0, 0, 0] };
+            j.drawPick = function(Pe) {
+              Pe = Pe || {};
+              var me = this.gl;
+              me.disable(me.CULL_FACE);
+              var De = ie;
+              De.model = Pe.model || A, De.view = Pe.view || A, De.projection = Pe.projection || A, De.shape = this._field[2].shape, De.pickId = this.pickId / 255, De.lowerBound = this.bounds[0], De.upperBound = this.bounds[1], De.objectOffset = this.objectOffset, De.permutation = Le;
+              for (var ce = 0; ce < 2; ++ce) for (var je = De.clipBounds[ce], lt = 0; lt < 3; ++lt) je[lt] = Math.min(Math.max(this.clipBounds[ce][lt], -1e8), 1e8);
+              var pt = oe(De, this);
+              if (pt.showSurface) {
+                for (this._pickShader.bind(), this._pickShader.uniforms = De, this._vao.bind(), this._vao.draw(me.TRIANGLES, this._vertexCount), ce = 0; ce < 3; ++ce) this.surfaceProject[ce] && (this._pickShader.uniforms.model = pt.projections[ce], this._pickShader.uniforms.clipBounds = pt.clipBounds[ce], this._vao.draw(me.TRIANGLES, this._vertexCount));
+                this._vao.unbind();
+              }
+              if (pt.showContour) {
+                var Vt = this._contourPickShader;
+                Vt.bind(), Vt.uniforms = De;
+                var ot = this._contourVAO;
+                for (ot.bind(), lt = 0; lt < 3; ++lt) for (me.lineWidth(this.contourWidth[lt] * this.pixelRatio), Vt.uniforms.permutation = O[lt], ce = 0; ce < this.contourLevels[lt].length; ++ce) this._contourCounts[lt][ce] && (Vt.uniforms.height = this.contourLevels[lt][ce], ot.draw(me.LINES, this._contourCounts[lt][ce], this._contourOffsets[lt][ce]));
+                for (ce = 0; ce < 3; ++ce) for (Vt.uniforms.model = pt.projections[ce], Vt.uniforms.clipBounds = pt.clipBounds[ce], lt = 0; lt < 3; ++lt) if (this.contourProject[ce][lt]) {
+                  Vt.uniforms.permutation = O[lt], me.lineWidth(this.contourWidth[lt] * this.pixelRatio);
+                  for (var ut = 0; ut < this.contourLevels[lt].length; ++ut) this._contourCounts[lt][ut] && (Vt.uniforms.height = this.contourLevels[lt][ut], ot.draw(me.LINES, this._contourCounts[lt][ut], this._contourOffsets[lt][ut]));
+                }
+                ot.unbind();
+              }
+            }, j.pick = function(Pe) {
+              if (!Pe || Pe.id !== this.pickId) return null;
+              var me = this._field[2].shape, De = this._pickResult, ce = me[0] * (Pe.value[0] + (Pe.value[2] >> 4) / 16) / 255, je = Math.floor(ce), lt = ce - je, pt = me[1] * (Pe.value[1] + (Pe.value[2] & 15) / 16) / 255, Vt = Math.floor(pt), ot = pt - Vt;
+              je += 1, Vt += 1;
+              var ut = De.position;
+              ut[0] = ut[1] = ut[2] = 0;
+              for (var Wt = 0; Wt < 2; ++Wt) for (var Nt = Wt ? lt : 1 - lt, $t = 0; $t < 2; ++$t) for (var sr = $t ? ot : 1 - ot, Tr = je + Wt, fr = Vt + $t, $e = Nt * sr, St = 0; St < 3; ++St) ut[St] += this._field[St].get(Tr, fr) * $e;
+              for (var Qt = this._pickResult.level, Gt = 0; Gt < 3; ++Gt) if (Qt[Gt] = E.le(this.contourLevels[Gt], ut[Gt]), Qt[Gt] < 0) this.contourLevels[Gt].length > 0 && (Qt[Gt] = 0);
+              else if (Qt[Gt] < this.contourLevels[Gt].length - 1) {
+                var _t = this.contourLevels[Gt][Qt[Gt]], It = this.contourLevels[Gt][Qt[Gt] + 1];
+                Math.abs(_t - ut[Gt]) > Math.abs(It - ut[Gt]) && (Qt[Gt] += 1);
+              }
+              for (De.index[0] = lt < 0.5 ? je : je + 1, De.index[1] = ot < 0.5 ? Vt : Vt + 1, De.uv[0] = ce / me[0], De.uv[1] = pt / me[1], St = 0; St < 3; ++St) De.dataCoordinate[St] = this._field[St].get(De.index[0], De.index[1]);
+              return De;
+            }, j.padField = function(Pe, me) {
+              var De = me.shape.slice(), ce = Pe.shape.slice();
+              d.assign(Pe.lo(1, 1).hi(De[0], De[1]), me), d.assign(Pe.lo(1).hi(De[0], 1), me.hi(De[0], 1)), d.assign(Pe.lo(1, ce[1] - 1).hi(De[0], 1), me.lo(0, De[1] - 1).hi(De[0], 1)), d.assign(Pe.lo(0, 1).hi(1, De[1]), me.hi(1)), d.assign(Pe.lo(ce[0] - 1, 1).hi(1, De[1]), me.lo(De[0] - 1)), Pe.set(0, 0, me.get(0, 0)), Pe.set(0, ce[1] - 1, me.get(0, De[1] - 1)), Pe.set(ce[0] - 1, 0, me.get(De[0] - 1, 0)), Pe.set(ce[0] - 1, ce[1] - 1, me.get(De[0] - 1, De[1] - 1));
+            };
+            function Se(Pe, me) {
+              return Array.isArray(Pe) ? [me(Pe[0]), me(Pe[1]), me(Pe[2])] : [me(Pe), me(Pe), me(Pe)];
+            }
+            function Ee(Pe) {
+              return Array.isArray(Pe) ? Pe.length === 3 ? [Pe[0], Pe[1], Pe[2], 1] : [Pe[0], Pe[1], Pe[2], Pe[3]] : [0, 0, 0, 1];
+            }
+            function Ae(Pe) {
+              if (Array.isArray(Pe)) {
+                if (Array.isArray(Pe)) return [Ee(Pe[0]), Ee(Pe[1]), Ee(Pe[2])];
+                var me = Ee(Pe);
+                return [me.slice(), me.slice(), me.slice()];
+              }
+            }
+            j.update = function(Pe) {
+              Pe = Pe || {}, this.objectOffset = Pe.objectOffset || this.objectOffset, this.dirty = true, "contourWidth" in Pe && (this.contourWidth = Se(Pe.contourWidth, Number)), "showContour" in Pe && (this.showContour = Se(Pe.showContour, Boolean)), "showSurface" in Pe && (this.showSurface = !!Pe.showSurface), "contourTint" in Pe && (this.contourTint = Se(Pe.contourTint, Boolean)), "contourColor" in Pe && (this.contourColor = Ae(Pe.contourColor)), "contourProject" in Pe && (this.contourProject = Se(Pe.contourProject, function(yn) {
+                return Se(yn, Boolean);
+              })), "surfaceProject" in Pe && (this.surfaceProject = Pe.surfaceProject), "dynamicColor" in Pe && (this.dynamicColor = Ae(Pe.dynamicColor)), "dynamicTint" in Pe && (this.dynamicTint = Se(Pe.dynamicTint, Number)), "dynamicWidth" in Pe && (this.dynamicWidth = Se(Pe.dynamicWidth, Number)), "opacity" in Pe && (this.opacity = Pe.opacity), "opacityscale" in Pe && (this.opacityscale = Pe.opacityscale), "colorBounds" in Pe && (this.colorBounds = Pe.colorBounds), "vertexColor" in Pe && (this.vertexColor = Pe.vertexColor ? 1 : 0), "colormap" in Pe && this._colorMap.setPixels(this.genColormap(Pe.colormap, this.opacityscale));
+              var me = Pe.field || Pe.coords && Pe.coords[2] || null, De = false;
+              if (me || (this._field[2].shape[0] || this._field[2].shape[2] ? me = this._field[2].lo(1, 1).hi(this._field[2].shape[0] - 2, this._field[2].shape[1] - 2) : me = this._field[2].hi(0, 0)), "field" in Pe || "coords" in Pe) {
+                var ce = (me.shape[0] + 2) * (me.shape[1] + 2);
+                ce > this._field[2].data.length && (f.freeFloat(this._field[2].data), this._field[2].data = f.mallocFloat(s.nextPow2(ce))), this._field[2] = _(this._field[2].data, [me.shape[0] + 2, me.shape[1] + 2]), this.padField(this._field[2], me), this.shape = me.shape.slice();
+                for (var je = this.shape, lt = 0; lt < 2; ++lt) this._field[2].size > this._field[lt].data.length && (f.freeFloat(this._field[lt].data), this._field[lt].data = f.mallocFloat(this._field[2].size)), this._field[lt] = _(this._field[lt].data, [je[0] + 2, je[1] + 2]);
+                if (Pe.coords) {
+                  var pt = Pe.coords;
+                  if (!Array.isArray(pt) || pt.length !== 3) throw new Error("gl-surface: invalid coordinates for x/y");
+                  for (lt = 0; lt < 2; ++lt) {
+                    var Vt = pt[lt];
+                    for ($t = 0; $t < 2; ++$t) if (Vt.shape[$t] !== je[$t]) throw new Error("gl-surface: coords have incorrect shape");
+                    this.padField(this._field[lt], Vt);
+                  }
+                } else if (Pe.ticks) {
+                  var ot = Pe.ticks;
+                  if (!Array.isArray(ot) || ot.length !== 2) throw new Error("gl-surface: invalid ticks");
+                  for (lt = 0; lt < 2; ++lt) {
+                    var ut = ot[lt];
+                    if ((Array.isArray(ut) || ut.length) && (ut = _(ut)), ut.shape[0] !== je[lt]) throw new Error("gl-surface: invalid tick length");
+                    var Wt = _(ut.data, je);
+                    Wt.stride[lt] = ut.stride[0], Wt.stride[lt ^ 1] = 0, this.padField(this._field[lt], Wt);
+                  }
+                } else {
+                  for (lt = 0; lt < 2; ++lt) {
+                    var Nt = [0, 0];
+                    Nt[lt] = 1, this._field[lt] = _(this._field[lt].data, [je[0] + 2, je[1] + 2], Nt, 0);
+                  }
+                  this._field[0].set(0, 0, 0);
+                  for (var $t = 0; $t < je[0]; ++$t) this._field[0].set($t + 1, 0, $t);
+                  for (this._field[0].set(je[0] + 1, 0, je[0] - 1), this._field[1].set(0, 0, 0), $t = 0; $t < je[1]; ++$t) this._field[1].set(0, $t + 1, $t);
+                  this._field[1].set(0, je[1] + 1, je[1] - 1);
+                }
+                var sr = this._field, Tr = _(f.mallocFloat(sr[2].size * 3 * 2), [3, je[0] + 2, je[1] + 2, 2]);
+                for (lt = 0; lt < 3; ++lt) T(Tr.pick(lt), sr[lt], "mirror");
+                var fr = _(f.mallocFloat(sr[2].size * 3), [je[0] + 2, je[1] + 2, 3]);
+                for (lt = 0; lt < je[0] + 2; ++lt) for ($t = 0; $t < je[1] + 2; ++$t) {
+                  var $e = Tr.get(0, lt, $t, 0), St = Tr.get(0, lt, $t, 1), Qt = Tr.get(1, lt, $t, 0), Gt = Tr.get(1, lt, $t, 1), _t = Tr.get(2, lt, $t, 0), It = Tr.get(2, lt, $t, 1), mt = Qt * It - Gt * _t, er = _t * St - It * $e, lr = $e * Gt - St * Qt, wr = Math.sqrt(mt * mt + er * er + lr * lr);
+                  wr < 1e-8 ? (wr = Math.max(Math.abs(mt), Math.abs(er), Math.abs(lr)), wr < 1e-8 ? (lr = 1, er = mt = 0, wr = 1) : wr = 1 / wr) : wr = 1 / Math.sqrt(wr), fr.set(lt, $t, 0, mt * wr), fr.set(lt, $t, 1, er * wr), fr.set(lt, $t, 2, lr * wr);
+                }
+                f.free(Tr.data);
+                var Lr = [1 / 0, 1 / 0, 1 / 0], ti = [-1 / 0, -1 / 0, -1 / 0], Br = 1 / 0, Vr = -1 / 0, dt = (je[0] - 1) * (je[1] - 1) * 6, Ge = f.mallocFloat(s.nextPow2(10 * dt)), Je = 0, We = 0;
+                for (lt = 0; lt < je[0] - 1; ++lt) e: for ($t = 0; $t < je[1] - 1; ++$t) {
+                  for (var tt = 0; tt < 2; ++tt) for (var xt = 0; xt < 2; ++xt) for (var Ie = 0; Ie < 3; ++Ie) {
+                    var xe = this._field[Ie].get(1 + lt + tt, 1 + $t + xt);
+                    if (isNaN(xe) || !isFinite(xe)) continue e;
+                  }
+                  for (Ie = 0; Ie < 6; ++Ie) {
+                    var ke = lt + z[Ie][0], vt = $t + z[Ie][1], ir = this._field[0].get(ke + 1, vt + 1), ar = this._field[1].get(ke + 1, vt + 1);
+                    xe = this._field[2].get(ke + 1, vt + 1), mt = fr.get(ke + 1, vt + 1, 0), er = fr.get(ke + 1, vt + 1, 1), lr = fr.get(ke + 1, vt + 1, 2), Pe.intensity && (vr = Pe.intensity.get(ke, vt));
+                    var vr = Pe.intensity ? Pe.intensity.get(ke, vt) : xe + this.objectOffset[2];
+                    Ge[Je++] = ke, Ge[Je++] = vt, Ge[Je++] = ir, Ge[Je++] = ar, Ge[Je++] = xe, Ge[Je++] = 0, Ge[Je++] = vr, Ge[Je++] = mt, Ge[Je++] = er, Ge[Je++] = lr, Lr[0] = Math.min(Lr[0], ir + this.objectOffset[0]), Lr[1] = Math.min(Lr[1], ar + this.objectOffset[1]), Lr[2] = Math.min(Lr[2], xe + this.objectOffset[2]), Br = Math.min(Br, vr), ti[0] = Math.max(ti[0], ir + this.objectOffset[0]), ti[1] = Math.max(ti[1], ar + this.objectOffset[1]), ti[2] = Math.max(ti[2], xe + this.objectOffset[2]), Vr = Math.max(Vr, vr), We += 1;
+                  }
+                }
+                for (Pe.intensityBounds && (Br = +Pe.intensityBounds[0], Vr = +Pe.intensityBounds[1]), lt = 6; lt < Je; lt += 10) Ge[lt] = (Ge[lt] - Br) / (Vr - Br);
+                this._vertexCount = We, this._coordinateBuffer.update(Ge.subarray(0, Je)), f.freeFloat(Ge), f.free(fr.data), this.bounds = [Lr, ti], this.intensity = Pe.intensity || this._field[2], (this.intensityBounds[0] !== Br || this.intensityBounds[1] !== Vr) && (De = true), this.intensityBounds = [Br, Vr];
+              }
+              if ("levels" in Pe) {
+                var ii = Pe.levels;
+                for (Array.isArray(ii[0]) ? ii = ii.slice() : ii = [[], [], ii], lt = 0; lt < 3; ++lt) ii[lt] = ii[lt].slice(), ii[lt].sort(function(yn, Sn) {
+                  return yn - Sn;
+                });
+                for (lt = 0; lt < 3; ++lt) for ($t = 0; $t < ii[lt].length; ++$t) ii[lt][$t] -= this.objectOffset[lt];
+                e: for (lt = 0; lt < 3; ++lt) {
+                  if (ii[lt].length !== this.contourLevels[lt].length) {
+                    De = true;
+                    break;
+                  }
+                  for ($t = 0; $t < ii[lt].length; ++$t) if (ii[lt][$t] !== this.contourLevels[lt][$t]) {
+                    De = true;
+                    break e;
+                  }
+                }
+                this.contourLevels = ii;
+              }
+              if (De) {
+                sr = this._field, je = this.shape;
+                for (var pi = [], $r = 0; $r < 3; ++$r) {
+                  var di = this.contourLevels[$r], ji = [], In = [], wi = [0, 0, 0];
+                  for (lt = 0; lt < di.length; ++lt) {
+                    var On = b(this._field[$r], di[lt]);
+                    ji.push(pi.length / 5 | 0), We = 0;
+                    e: for ($t = 0; $t < On.cells.length; ++$t) {
+                      var qn = On.cells[$t];
+                      for (Ie = 0; Ie < 2; ++Ie) {
+                        var Fn = On.positions[qn[Ie]], ra = Fn[0], la = Math.floor(ra) | 0, Ut = ra - la, wt = Fn[1], rr = Math.floor(wt) | 0, nr = wt - rr, Er = false;
+                        t: for (var Xr = 0; Xr < 3; ++Xr) {
+                          wi[Xr] = 0;
+                          var ri = ($r + Xr + 1) % 3;
+                          for (tt = 0; tt < 2; ++tt) {
+                            var Qr = tt ? Ut : 1 - Ut;
+                            for (ke = Math.min(Math.max(la + tt, 0), je[0]) | 0, xt = 0; xt < 2; ++xt) {
+                              var Oi = xt ? nr : 1 - nr;
+                              if (vt = Math.min(Math.max(rr + xt, 0), je[1]) | 0, Xr < 2 ? xe = this._field[ri].get(ke, vt) : xe = (this.intensity.get(ke, vt) - this.intensityBounds[0]) / (this.intensityBounds[1] - this.intensityBounds[0]), !isFinite(xe) || isNaN(xe)) {
+                                Er = true;
+                                break t;
+                              }
+                              var $i = Qr * Oi;
+                              wi[Xr] += $i * xe;
+                            }
+                          }
+                        }
+                        if (!Er) pi.push(wi[0], wi[1], Fn[0], Fn[1], wi[2]), We += 1;
+                        else {
+                          if (Ie > 0) {
+                            for (var tn = 0; tn < 5; ++tn) pi.pop();
+                            We -= 1;
+                          }
+                          continue e;
+                        }
+                      }
+                    }
+                    In.push(We);
+                  }
+                  this._contourOffsets[$r] = ji, this._contourCounts[$r] = In;
+                }
+                var fn = f.mallocFloat(pi.length);
+                for (lt = 0; lt < pi.length; ++lt) fn[lt] = pi[lt];
+                this._contourBuffer.update(fn), f.freeFloat(fn);
+              }
+            }, j.dispose = function() {
+              this._shader.dispose(), this._vao.dispose(), this._coordinateBuffer.dispose(), this._colorMap.dispose(), this._contourBuffer.dispose(), this._contourVAO.dispose(), this._contourShader.dispose(), this._contourPickShader.dispose(), this._dynamicBuffer.dispose(), this._dynamicVAO.dispose();
+              for (var Pe = 0; Pe < 3; ++Pe) f.freeFloat(this._field[Pe].data);
+            }, j.highlight = function(Pe) {
+              var me;
+              if (!Pe) {
+                this._dynamicCounts = [0, 0, 0], this.dyanamicLevel = [NaN, NaN, NaN], this.highlightLevel = [-1, -1, -1];
+                return;
+              }
+              for (me = 0; me < 3; ++me) this.enableHighlight[me] ? this.highlightLevel[me] = Pe.level[me] : this.highlightLevel[me] = -1;
+              var De;
+              for (this.snapToData ? De = Pe.dataCoordinate : De = Pe.position, me = 0; me < 3; ++me) De[me] -= this.objectOffset[me];
+              if (!((!this.enableDynamic[0] || De[0] === this.dynamicLevel[0]) && (!this.enableDynamic[1] || De[1] === this.dynamicLevel[1]) && (!this.enableDynamic[2] || De[2] === this.dynamicLevel[2]))) {
+                for (var ce = 0, je = this.shape, lt = f.mallocFloat(12 * je[0] * je[1]), pt = 0; pt < 3; ++pt) {
+                  if (!this.enableDynamic[pt]) {
+                    this.dynamicLevel[pt] = NaN, this._dynamicCounts[pt] = 0;
+                    continue;
+                  }
+                  this.dynamicLevel[pt] = De[pt];
+                  var Vt = (pt + 1) % 3, ot = (pt + 2) % 3, ut = this._field[pt], Wt = this._field[Vt], Nt = this._field[ot], $t = b(ut, De[pt]), sr = $t.cells, Tr = $t.positions;
+                  for (this._dynamicOffsets[pt] = ce, me = 0; me < sr.length; ++me) for (var fr = sr[me], $e = 0; $e < 2; ++$e) {
+                    var St = Tr[fr[$e]], Qt = +St[0], Gt = Qt | 0, _t = Math.min(Gt + 1, je[0]) | 0, It = Qt - Gt, mt = 1 - It, er = +St[1], lr = er | 0, wr = Math.min(lr + 1, je[1]) | 0, Lr = er - lr, ti = 1 - Lr, Br = mt * ti, Vr = mt * Lr, dt = It * ti, Ge = It * Lr, Je = Br * Wt.get(Gt, lr) + Vr * Wt.get(Gt, wr) + dt * Wt.get(_t, lr) + Ge * Wt.get(_t, wr), We = Br * Nt.get(Gt, lr) + Vr * Nt.get(Gt, wr) + dt * Nt.get(_t, lr) + Ge * Nt.get(_t, wr);
+                    if (isNaN(Je) || isNaN(We)) {
+                      $e && (ce -= 1);
+                      break;
+                    }
+                    lt[2 * ce + 0] = Je, lt[2 * ce + 1] = We, ce += 1;
+                  }
+                  this._dynamicCounts[pt] = ce - this._dynamicOffsets[pt];
+                }
+                this._dynamicBuffer.update(lt.subarray(0, 2 * ce)), f.freeFloat(lt);
+              }
+            };
+            function Be(Pe) {
+              var me = Pe.gl, De = x(me), ce = M(me), je = C(me), lt = g(me), pt = l(me), Vt = u(me, [{ buffer: pt, size: 4, stride: P, offset: 0 }, { buffer: pt, size: 3, stride: P, offset: 16 }, { buffer: pt, size: 3, stride: P, offset: 28 }]), ot = l(me), ut = u(me, [{ buffer: ot, size: 4, stride: 20, offset: 0 }, { buffer: ot, size: 1, stride: 20, offset: 16 }]), Wt = l(me), Nt = u(me, [{ buffer: Wt, size: 2, type: me.FLOAT }]), $t = c(me, 1, G, me.RGBA, me.UNSIGNED_BYTE);
+              $t.minFilter = me.LINEAR, $t.magFilter = me.LINEAR;
+              var sr = new Z(me, [0, 0], [[0, 0, 0], [0, 0, 0]], De, ce, pt, Vt, $t, je, lt, ot, ut, Wt, Nt, [0, 0, 0]), Tr = { levels: [[], [], []] };
+              for (var fr in Pe) Tr[fr] = Pe[fr];
+              return Tr.colormap = Tr.colormap || "jet", sr.update(Tr), sr;
+            }
+          }, 9507: function(i) {
+            i.exports = true;
+          }, 9618: function(i, a, o) {
+            var s = o(7163), l = typeof Float64Array != "undefined";
+            function u(b, p) {
+              return b[0] - p[0];
+            }
+            function c() {
+              var b = this.stride, p = new Array(b.length), k;
+              for (k = 0; k < p.length; ++k) p[k] = [Math.abs(b[k]), k];
+              p.sort(u);
+              var E = new Array(p.length);
+              for (k = 0; k < E.length; ++k) E[k] = p[k][1];
+              return E;
+            }
+            var f = { T: function(b) {
+              function p(E) {
+                this.data = E;
+              }
+              var k = p.prototype;
+              return k.dtype = b, k.index = function() {
+                return -1;
+              }, k.size = 0, k.dimension = -1, k.shape = k.stride = k.order = [], k.lo = k.hi = k.transpose = k.step = function() {
+                return new p(this.data);
+              }, k.get = k.set = function() {
+              }, k.pick = function() {
+                return null;
+              }, function(T) {
+                return new p(T);
+              };
+            }, 0: function(b, p) {
+              function k(T, L) {
+                this.data = T, this.offset = L;
+              }
+              var E = k.prototype;
+              return E.dtype = b, E.index = function() {
+                return this.offset;
+              }, E.dimension = 0, E.size = 1, E.shape = E.stride = E.order = [], E.lo = E.hi = E.transpose = E.step = function() {
+                return new k(this.data, this.offset);
+              }, E.pick = function() {
+                return p(this.data);
+              }, E.valueOf = E.get = function() {
+                return b === "generic" ? this.data.get(this.offset) : this.data[this.offset];
+              }, E.set = function(L) {
+                return b === "generic" ? this.data.set(this.offset, L) : this.data[this.offset] = L;
+              }, function(L, x, C, M) {
+                return new k(L, M);
+              };
+            }, 1: function(b, p, k) {
+              function E(L, x, C, M) {
+                this.data = L, this.shape = [x], this.stride = [C], this.offset = M | 0;
+              }
+              var T = E.prototype;
+              return T.dtype = b, T.dimension = 1, Object.defineProperty(T, "size", { get: function() {
+                return this.shape[0];
+              } }), T.order = [0], T.set = function(x, C) {
+                return b === "generic" ? this.data.set(this.offset + this.stride[0] * x, C) : this.data[this.offset + this.stride[0] * x] = C;
+              }, T.get = function(x) {
+                return b === "generic" ? this.data.get(this.offset + this.stride[0] * x) : this.data[this.offset + this.stride[0] * x];
+              }, T.index = function(x) {
+                return this.offset + this.stride[0] * x;
+              }, T.hi = function(x) {
+                return new E(this.data, typeof x != "number" || x < 0 ? this.shape[0] : x | 0, this.stride[0], this.offset);
+              }, T.lo = function(x) {
+                var C = this.offset, M = 0, g = this.shape[0], P = this.stride[0];
+                return typeof x == "number" && x >= 0 && (M = x | 0, C += P * M, g -= M), new E(this.data, g, P, C);
+              }, T.step = function(x) {
+                var C = this.shape[0], M = this.stride[0], g = this.offset, P = 0, A = Math.ceil;
+                return typeof x == "number" && (P = x | 0, P < 0 ? (g += M * (C - 1), C = A(-C / P)) : C = A(C / P), M *= P), new E(this.data, C, M, g);
+              }, T.transpose = function(x) {
+                x = x === void 0 ? 0 : x | 0;
+                var C = this.shape, M = this.stride;
+                return new E(this.data, C[x], M[x], this.offset);
+              }, T.pick = function(x) {
+                var C = [], M = [], g = this.offset;
+                typeof x == "number" && x >= 0 ? g = g + this.stride[0] * x | 0 : (C.push(this.shape[0]), M.push(this.stride[0]));
+                var P = p[C.length + 1];
+                return P(this.data, C, M, g);
+              }, function(x, C, M, g) {
+                return new E(x, C[0], M[0], g);
+              };
+            }, 2: function(b, p, k) {
+              function E(L, x, C, M, g, P) {
+                this.data = L, this.shape = [x, C], this.stride = [M, g], this.offset = P | 0;
+              }
+              var T = E.prototype;
+              return T.dtype = b, T.dimension = 2, Object.defineProperty(T, "size", { get: function() {
+                return this.shape[0] * this.shape[1];
+              } }), Object.defineProperty(T, "order", { get: function() {
+                return Math.abs(this.stride[0]) > Math.abs(this.stride[1]) ? [1, 0] : [0, 1];
+              } }), T.set = function(x, C, M) {
+                return b === "generic" ? this.data.set(this.offset + this.stride[0] * x + this.stride[1] * C, M) : this.data[this.offset + this.stride[0] * x + this.stride[1] * C] = M;
+              }, T.get = function(x, C) {
+                return b === "generic" ? this.data.get(this.offset + this.stride[0] * x + this.stride[1] * C) : this.data[this.offset + this.stride[0] * x + this.stride[1] * C];
+              }, T.index = function(x, C) {
+                return this.offset + this.stride[0] * x + this.stride[1] * C;
+              }, T.hi = function(x, C) {
+                return new E(this.data, typeof x != "number" || x < 0 ? this.shape[0] : x | 0, typeof C != "number" || C < 0 ? this.shape[1] : C | 0, this.stride[0], this.stride[1], this.offset);
+              }, T.lo = function(x, C) {
+                var M = this.offset, g = 0, P = this.shape[0], A = this.shape[1], z = this.stride[0], O = this.stride[1];
+                return typeof x == "number" && x >= 0 && (g = x | 0, M += z * g, P -= g), typeof C == "number" && C >= 0 && (g = C | 0, M += O * g, A -= g), new E(this.data, P, A, z, O, M);
+              }, T.step = function(x, C) {
+                var M = this.shape[0], g = this.shape[1], P = this.stride[0], A = this.stride[1], z = this.offset, O = 0, U = Math.ceil;
+                return typeof x == "number" && (O = x | 0, O < 0 ? (z += P * (M - 1), M = U(-M / O)) : M = U(M / O), P *= O), typeof C == "number" && (O = C | 0, O < 0 ? (z += A * (g - 1), g = U(-g / O)) : g = U(g / O), A *= O), new E(this.data, M, g, P, A, z);
+              }, T.transpose = function(x, C) {
+                x = x === void 0 ? 0 : x | 0, C = C === void 0 ? 1 : C | 0;
+                var M = this.shape, g = this.stride;
+                return new E(this.data, M[x], M[C], g[x], g[C], this.offset);
+              }, T.pick = function(x, C) {
+                var M = [], g = [], P = this.offset;
+                typeof x == "number" && x >= 0 ? P = P + this.stride[0] * x | 0 : (M.push(this.shape[0]), g.push(this.stride[0])), typeof C == "number" && C >= 0 ? P = P + this.stride[1] * C | 0 : (M.push(this.shape[1]), g.push(this.stride[1]));
+                var A = p[M.length + 1];
+                return A(this.data, M, g, P);
+              }, function(x, C, M, g) {
+                return new E(x, C[0], C[1], M[0], M[1], g);
+              };
+            }, 3: function(b, p, k) {
+              function E(L, x, C, M, g, P, A, z) {
+                this.data = L, this.shape = [x, C, M], this.stride = [g, P, A], this.offset = z | 0;
+              }
+              var T = E.prototype;
+              return T.dtype = b, T.dimension = 3, Object.defineProperty(T, "size", { get: function() {
+                return this.shape[0] * this.shape[1] * this.shape[2];
+              } }), Object.defineProperty(T, "order", { get: function() {
+                var x = Math.abs(this.stride[0]), C = Math.abs(this.stride[1]), M = Math.abs(this.stride[2]);
+                return x > C ? C > M ? [2, 1, 0] : x > M ? [1, 2, 0] : [1, 0, 2] : x > M ? [2, 0, 1] : M > C ? [0, 1, 2] : [0, 2, 1];
+              } }), T.set = function(x, C, M, g) {
+                return b === "generic" ? this.data.set(this.offset + this.stride[0] * x + this.stride[1] * C + this.stride[2] * M, g) : this.data[this.offset + this.stride[0] * x + this.stride[1] * C + this.stride[2] * M] = g;
+              }, T.get = function(x, C, M) {
+                return b === "generic" ? this.data.get(this.offset + this.stride[0] * x + this.stride[1] * C + this.stride[2] * M) : this.data[this.offset + this.stride[0] * x + this.stride[1] * C + this.stride[2] * M];
+              }, T.index = function(x, C, M) {
+                return this.offset + this.stride[0] * x + this.stride[1] * C + this.stride[2] * M;
+              }, T.hi = function(x, C, M) {
+                return new E(this.data, typeof x != "number" || x < 0 ? this.shape[0] : x | 0, typeof C != "number" || C < 0 ? this.shape[1] : C | 0, typeof M != "number" || M < 0 ? this.shape[2] : M | 0, this.stride[0], this.stride[1], this.stride[2], this.offset);
+              }, T.lo = function(x, C, M) {
+                var g = this.offset, P = 0, A = this.shape[0], z = this.shape[1], O = this.shape[2], U = this.stride[0], G = this.stride[1], Z = this.stride[2];
+                return typeof x == "number" && x >= 0 && (P = x | 0, g += U * P, A -= P), typeof C == "number" && C >= 0 && (P = C | 0, g += G * P, z -= P), typeof M == "number" && M >= 0 && (P = M | 0, g += Z * P, O -= P), new E(this.data, A, z, O, U, G, Z, g);
+              }, T.step = function(x, C, M) {
+                var g = this.shape[0], P = this.shape[1], A = this.shape[2], z = this.stride[0], O = this.stride[1], U = this.stride[2], G = this.offset, Z = 0, j = Math.ceil;
+                return typeof x == "number" && (Z = x | 0, Z < 0 ? (G += z * (g - 1), g = j(-g / Z)) : g = j(g / Z), z *= Z), typeof C == "number" && (Z = C | 0, Z < 0 ? (G += O * (P - 1), P = j(-P / Z)) : P = j(P / Z), O *= Z), typeof M == "number" && (Z = M | 0, Z < 0 ? (G += U * (A - 1), A = j(-A / Z)) : A = j(A / Z), U *= Z), new E(this.data, g, P, A, z, O, U, G);
+              }, T.transpose = function(x, C, M) {
+                x = x === void 0 ? 0 : x | 0, C = C === void 0 ? 1 : C | 0, M = M === void 0 ? 2 : M | 0;
+                var g = this.shape, P = this.stride;
+                return new E(this.data, g[x], g[C], g[M], P[x], P[C], P[M], this.offset);
+              }, T.pick = function(x, C, M) {
+                var g = [], P = [], A = this.offset;
+                typeof x == "number" && x >= 0 ? A = A + this.stride[0] * x | 0 : (g.push(this.shape[0]), P.push(this.stride[0])), typeof C == "number" && C >= 0 ? A = A + this.stride[1] * C | 0 : (g.push(this.shape[1]), P.push(this.stride[1])), typeof M == "number" && M >= 0 ? A = A + this.stride[2] * M | 0 : (g.push(this.shape[2]), P.push(this.stride[2]));
+                var z = p[g.length + 1];
+                return z(this.data, g, P, A);
+              }, function(x, C, M, g) {
+                return new E(x, C[0], C[1], C[2], M[0], M[1], M[2], g);
+              };
+            }, 4: function(b, p, k) {
+              function E(L, x, C, M, g, P, A, z, O, U) {
+                this.data = L, this.shape = [x, C, M, g], this.stride = [P, A, z, O], this.offset = U | 0;
+              }
+              var T = E.prototype;
+              return T.dtype = b, T.dimension = 4, Object.defineProperty(T, "size", { get: function() {
+                return this.shape[0] * this.shape[1] * this.shape[2] * this.shape[3];
+              } }), Object.defineProperty(T, "order", { get: k }), T.set = function(x, C, M, g, P) {
+                return b === "generic" ? this.data.set(this.offset + this.stride[0] * x + this.stride[1] * C + this.stride[2] * M + this.stride[3] * g, P) : this.data[this.offset + this.stride[0] * x + this.stride[1] * C + this.stride[2] * M + this.stride[3] * g] = P;
+              }, T.get = function(x, C, M, g) {
+                return b === "generic" ? this.data.get(this.offset + this.stride[0] * x + this.stride[1] * C + this.stride[2] * M + this.stride[3] * g) : this.data[this.offset + this.stride[0] * x + this.stride[1] * C + this.stride[2] * M + this.stride[3] * g];
+              }, T.index = function(x, C, M, g) {
+                return this.offset + this.stride[0] * x + this.stride[1] * C + this.stride[2] * M + this.stride[3] * g;
+              }, T.hi = function(x, C, M, g) {
+                return new E(this.data, typeof x != "number" || x < 0 ? this.shape[0] : x | 0, typeof C != "number" || C < 0 ? this.shape[1] : C | 0, typeof M != "number" || M < 0 ? this.shape[2] : M | 0, typeof g != "number" || g < 0 ? this.shape[3] : g | 0, this.stride[0], this.stride[1], this.stride[2], this.stride[3], this.offset);
+              }, T.lo = function(x, C, M, g) {
+                var P = this.offset, A = 0, z = this.shape[0], O = this.shape[1], U = this.shape[2], G = this.shape[3], Z = this.stride[0], j = this.stride[1], N = this.stride[2], H = this.stride[3];
+                return typeof x == "number" && x >= 0 && (A = x | 0, P += Z * A, z -= A), typeof C == "number" && C >= 0 && (A = C | 0, P += j * A, O -= A), typeof M == "number" && M >= 0 && (A = M | 0, P += N * A, U -= A), typeof g == "number" && g >= 0 && (A = g | 0, P += H * A, G -= A), new E(this.data, z, O, U, G, Z, j, N, H, P);
+              }, T.step = function(x, C, M, g) {
+                var P = this.shape[0], A = this.shape[1], z = this.shape[2], O = this.shape[3], U = this.stride[0], G = this.stride[1], Z = this.stride[2], j = this.stride[3], N = this.offset, H = 0, re = Math.ceil;
+                return typeof x == "number" && (H = x | 0, H < 0 ? (N += U * (P - 1), P = re(-P / H)) : P = re(P / H), U *= H), typeof C == "number" && (H = C | 0, H < 0 ? (N += G * (A - 1), A = re(-A / H)) : A = re(A / H), G *= H), typeof M == "number" && (H = M | 0, H < 0 ? (N += Z * (z - 1), z = re(-z / H)) : z = re(z / H), Z *= H), typeof g == "number" && (H = g | 0, H < 0 ? (N += j * (O - 1), O = re(-O / H)) : O = re(O / H), j *= H), new E(this.data, P, A, z, O, U, G, Z, j, N);
+              }, T.transpose = function(x, C, M, g) {
+                x = x === void 0 ? 0 : x | 0, C = C === void 0 ? 1 : C | 0, M = M === void 0 ? 2 : M | 0, g = g === void 0 ? 3 : g | 0;
+                var P = this.shape, A = this.stride;
+                return new E(this.data, P[x], P[C], P[M], P[g], A[x], A[C], A[M], A[g], this.offset);
+              }, T.pick = function(x, C, M, g) {
+                var P = [], A = [], z = this.offset;
+                typeof x == "number" && x >= 0 ? z = z + this.stride[0] * x | 0 : (P.push(this.shape[0]), A.push(this.stride[0])), typeof C == "number" && C >= 0 ? z = z + this.stride[1] * C | 0 : (P.push(this.shape[1]), A.push(this.stride[1])), typeof M == "number" && M >= 0 ? z = z + this.stride[2] * M | 0 : (P.push(this.shape[2]), A.push(this.stride[2])), typeof g == "number" && g >= 0 ? z = z + this.stride[3] * g | 0 : (P.push(this.shape[3]), A.push(this.stride[3]));
+                var O = p[P.length + 1];
+                return O(this.data, P, A, z);
+              }, function(x, C, M, g) {
+                return new E(x, C[0], C[1], C[2], C[3], M[0], M[1], M[2], M[3], g);
+              };
+            }, 5: function(p, k, E) {
+              function T(x, C, M, g, P, A, z, O, U, G, Z, j) {
+                this.data = x, this.shape = [C, M, g, P, A], this.stride = [z, O, U, G, Z], this.offset = j | 0;
+              }
+              var L = T.prototype;
+              return L.dtype = p, L.dimension = 5, Object.defineProperty(L, "size", { get: function() {
+                return this.shape[0] * this.shape[1] * this.shape[2] * this.shape[3] * this.shape[4];
+              } }), Object.defineProperty(L, "order", { get: E }), L.set = function(C, M, g, P, A, z) {
+                return p === "generic" ? this.data.set(this.offset + this.stride[0] * C + this.stride[1] * M + this.stride[2] * g + this.stride[3] * P + this.stride[4] * A, z) : this.data[this.offset + this.stride[0] * C + this.stride[1] * M + this.stride[2] * g + this.stride[3] * P + this.stride[4] * A] = z;
+              }, L.get = function(C, M, g, P, A) {
+                return p === "generic" ? this.data.get(this.offset + this.stride[0] * C + this.stride[1] * M + this.stride[2] * g + this.stride[3] * P + this.stride[4] * A) : this.data[this.offset + this.stride[0] * C + this.stride[1] * M + this.stride[2] * g + this.stride[3] * P + this.stride[4] * A];
+              }, L.index = function(C, M, g, P, A) {
+                return this.offset + this.stride[0] * C + this.stride[1] * M + this.stride[2] * g + this.stride[3] * P + this.stride[4] * A;
+              }, L.hi = function(C, M, g, P, A) {
+                return new T(this.data, typeof C != "number" || C < 0 ? this.shape[0] : C | 0, typeof M != "number" || M < 0 ? this.shape[1] : M | 0, typeof g != "number" || g < 0 ? this.shape[2] : g | 0, typeof P != "number" || P < 0 ? this.shape[3] : P | 0, typeof A != "number" || A < 0 ? this.shape[4] : A | 0, this.stride[0], this.stride[1], this.stride[2], this.stride[3], this.stride[4], this.offset);
+              }, L.lo = function(C, M, g, P, A) {
+                var z = this.offset, O = 0, U = this.shape[0], G = this.shape[1], Z = this.shape[2], j = this.shape[3], N = this.shape[4], H = this.stride[0], re = this.stride[1], oe = this.stride[2], _e = this.stride[3], Ce = this.stride[4];
+                return typeof C == "number" && C >= 0 && (O = C | 0, z += H * O, U -= O), typeof M == "number" && M >= 0 && (O = M | 0, z += re * O, G -= O), typeof g == "number" && g >= 0 && (O = g | 0, z += oe * O, Z -= O), typeof P == "number" && P >= 0 && (O = P | 0, z += _e * O, j -= O), typeof A == "number" && A >= 0 && (O = A | 0, z += Ce * O, N -= O), new T(this.data, U, G, Z, j, N, H, re, oe, _e, Ce, z);
+              }, L.step = function(C, M, g, P, A) {
+                var z = this.shape[0], O = this.shape[1], U = this.shape[2], G = this.shape[3], Z = this.shape[4], j = this.stride[0], N = this.stride[1], H = this.stride[2], re = this.stride[3], oe = this.stride[4], _e = this.offset, Ce = 0, Le = Math.ceil;
+                return typeof C == "number" && (Ce = C | 0, Ce < 0 ? (_e += j * (z - 1), z = Le(-z / Ce)) : z = Le(z / Ce), j *= Ce), typeof M == "number" && (Ce = M | 0, Ce < 0 ? (_e += N * (O - 1), O = Le(-O / Ce)) : O = Le(O / Ce), N *= Ce), typeof g == "number" && (Ce = g | 0, Ce < 0 ? (_e += H * (U - 1), U = Le(-U / Ce)) : U = Le(U / Ce), H *= Ce), typeof P == "number" && (Ce = P | 0, Ce < 0 ? (_e += re * (G - 1), G = Le(-G / Ce)) : G = Le(G / Ce), re *= Ce), typeof A == "number" && (Ce = A | 0, Ce < 0 ? (_e += oe * (Z - 1), Z = Le(-Z / Ce)) : Z = Le(Z / Ce), oe *= Ce), new T(this.data, z, O, U, G, Z, j, N, H, re, oe, _e);
+              }, L.transpose = function(C, M, g, P, A) {
+                C = C === void 0 ? 0 : C | 0, M = M === void 0 ? 1 : M | 0, g = g === void 0 ? 2 : g | 0, P = P === void 0 ? 3 : P | 0, A = A === void 0 ? 4 : A | 0;
+                var z = this.shape, O = this.stride;
+                return new T(this.data, z[C], z[M], z[g], z[P], z[A], O[C], O[M], O[g], O[P], O[A], this.offset);
+              }, L.pick = function(C, M, g, P, A) {
+                var z = [], O = [], U = this.offset;
+                typeof C == "number" && C >= 0 ? U = U + this.stride[0] * C | 0 : (z.push(this.shape[0]), O.push(this.stride[0])), typeof M == "number" && M >= 0 ? U = U + this.stride[1] * M | 0 : (z.push(this.shape[1]), O.push(this.stride[1])), typeof g == "number" && g >= 0 ? U = U + this.stride[2] * g | 0 : (z.push(this.shape[2]), O.push(this.stride[2])), typeof P == "number" && P >= 0 ? U = U + this.stride[3] * P | 0 : (z.push(this.shape[3]), O.push(this.stride[3])), typeof A == "number" && A >= 0 ? U = U + this.stride[4] * A | 0 : (z.push(this.shape[4]), O.push(this.stride[4]));
+                var G = k[z.length + 1];
+                return G(this.data, z, O, U);
+              }, function(C, M, g, P) {
+                return new T(C, M[0], M[1], M[2], M[3], M[4], g[0], g[1], g[2], g[3], g[4], P);
+              };
+            } };
+            function h(b, p) {
+              var k = p === -1 ? "T" : String(p), E = f[k];
+              return p === -1 ? E(b) : p === 0 ? E(b, v[b][0]) : E(b, v[b], c);
+            }
+            function d(b) {
+              if (s(b)) return "buffer";
+              if (l) switch (Object.prototype.toString.call(b)) {
+                case "[object Float64Array]":
+                  return "float64";
+                case "[object Float32Array]":
+                  return "float32";
+                case "[object Int8Array]":
+                  return "int8";
+                case "[object Int16Array]":
+                  return "int16";
+                case "[object Int32Array]":
+                  return "int32";
+                case "[object Uint8ClampedArray]":
+                  return "uint8_clamped";
+                case "[object Uint8Array]":
+                  return "uint8";
+                case "[object Uint16Array]":
+                  return "uint16";
+                case "[object Uint32Array]":
+                  return "uint32";
+                case "[object BigInt64Array]":
+                  return "bigint64";
+                case "[object BigUint64Array]":
+                  return "biguint64";
+              }
+              return Array.isArray(b) ? "array" : "generic";
+            }
+            var v = { generic: [], buffer: [], array: [], float32: [], float64: [], int8: [], int16: [], int32: [], uint8_clamped: [], uint8: [], uint16: [], uint32: [], bigint64: [], biguint64: [] };
+            function _(b, p, k, E) {
+              if (b === void 0) {
+                var g = v.array[0];
+                return g([]);
+              } else typeof b == "number" && (b = [b]);
+              p === void 0 && (p = [b.length]);
+              var T = p.length;
+              if (k === void 0) {
+                k = new Array(T);
+                for (var L = T - 1, x = 1; L >= 0; --L) k[L] = x, x *= p[L];
+              }
+              if (E === void 0) {
+                E = 0;
+                for (var L = 0; L < T; ++L) k[L] < 0 && (E -= (p[L] - 1) * k[L]);
+              }
+              for (var C = d(b), M = v[C]; M.length <= T + 1; ) M.push(h(C, M.length - 1));
+              var g = M[T + 1];
+              return g(b, p, k, E);
+            }
+            i.exports = _;
+          }, 9921: function(i) {
+            i.exports = a;
+            function a(o) {
+              var s = o[0], l = o[1], u = o[2], c = o[3], f = o[4], h = o[5], d = o[6], v = o[7], _ = o[8], b = o[9], p = o[10], k = o[11], E = o[12], T = o[13], L = o[14], x = o[15], C = s * h - l * f, M = s * d - u * f, g = s * v - c * f, P = l * d - u * h, A = l * v - c * h, z = u * v - c * d, O = _ * T - b * E, U = _ * L - p * E, G = _ * x - k * E, Z = b * L - p * T, j = b * x - k * T, N = p * x - k * L;
+              return C * N - M * j + g * Z + P * G - A * U + z * O;
+            }
+          }, 9922: function(i, a, o) {
+            i.exports = l;
+            var s = o(2613);
+            function l(u, c) {
+              var f = u[0], h = u[1], d = u[2], v = c[0], _ = c[1], b = c[2];
+              return Math.abs(f - v) <= s * Math.max(1, Math.abs(f), Math.abs(v)) && Math.abs(h - _) <= s * Math.max(1, Math.abs(h), Math.abs(_)) && Math.abs(d - b) <= s * Math.max(1, Math.abs(d), Math.abs(b));
+            }
+          }, 9970: function(i, a, o) {
+            i.exports = { create: o(7536), clone: o(2335), fromValues: o(3390), copy: o(2933), set: o(4578), add: o(4361), subtract: o(6860), multiply: o(3576), divide: o(1373), min: o(2334), max: o(160), scale: o(9288), scaleAndAdd: o(4844), distance: o(4691), squaredDistance: o(7960), length: o(6808), squaredLength: o(483), negate: o(1498), inverse: o(4494), normalize: o(5177), dot: o(3750), lerp: o(2573), random: o(9131), transformMat4: o(5352), transformQuat: o(4041) };
+          }, 9977: function(i, a, o) {
+            i.exports = p;
+            var s = o(9215), l = o(6582), u = o(7399), c = o(7608), f = o(4081);
+            function h(k, E, T) {
+              return Math.sqrt(Math.pow(k, 2) + Math.pow(E, 2) + Math.pow(T, 2));
+            }
+            function d(k, E, T, L) {
+              return Math.sqrt(Math.pow(k, 2) + Math.pow(E, 2) + Math.pow(T, 2) + Math.pow(L, 2));
+            }
+            function v(k, E) {
+              var T = E[0], L = E[1], x = E[2], C = E[3], M = d(T, L, x, C);
+              M > 1e-6 ? (k[0] = T / M, k[1] = L / M, k[2] = x / M, k[3] = C / M) : (k[0] = k[1] = k[2] = 0, k[3] = 1);
+            }
+            function _(k, E, T) {
+              this.radius = s([T]), this.center = s(E), this.rotation = s(k), this.computedRadius = this.radius.curve(0), this.computedCenter = this.center.curve(0), this.computedRotation = this.rotation.curve(0), this.computedUp = [0.1, 0, 0], this.computedEye = [0.1, 0, 0], this.computedMatrix = [0.1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], this.recalcMatrix(0);
+            }
+            var b = _.prototype;
+            b.lastT = function() {
+              return Math.max(this.radius.lastT(), this.center.lastT(), this.rotation.lastT());
+            }, b.recalcMatrix = function(k) {
+              this.radius.curve(k), this.center.curve(k), this.rotation.curve(k);
+              var E = this.computedRotation;
+              v(E, E);
+              var T = this.computedMatrix;
+              u(T, E);
+              var L = this.computedCenter, x = this.computedEye, C = this.computedUp, M = Math.exp(this.computedRadius[0]);
+              x[0] = L[0] + M * T[2], x[1] = L[1] + M * T[6], x[2] = L[2] + M * T[10], C[0] = T[1], C[1] = T[5], C[2] = T[9];
+              for (var g = 0; g < 3; ++g) {
+                for (var P = 0, A = 0; A < 3; ++A) P += T[g + 4 * A] * x[A];
+                T[12 + g] = -P;
+              }
+            }, b.getMatrix = function(k, E) {
+              this.recalcMatrix(k);
+              var T = this.computedMatrix;
+              if (E) {
+                for (var L = 0; L < 16; ++L) E[L] = T[L];
+                return E;
+              }
+              return T;
+            }, b.idle = function(k) {
+              this.center.idle(k), this.radius.idle(k), this.rotation.idle(k);
+            }, b.flush = function(k) {
+              this.center.flush(k), this.radius.flush(k), this.rotation.flush(k);
+            }, b.pan = function(k, E, T, L) {
+              E = E || 0, T = T || 0, L = L || 0, this.recalcMatrix(k);
+              var x = this.computedMatrix, C = x[1], M = x[5], g = x[9], P = h(C, M, g);
+              C /= P, M /= P, g /= P;
+              var A = x[0], z = x[4], O = x[8], U = A * C + z * M + O * g;
+              A -= C * U, z -= M * U, O -= g * U;
+              var G = h(A, z, O);
+              A /= G, z /= G, O /= G;
+              x[2];
+              x[6];
+              x[10];
+              var _e = A * E + C * T, Ce = z * E + M * T, Le = O * E + g * T;
+              this.center.move(k, _e, Ce, Le);
+              var ge = Math.exp(this.computedRadius[0]);
+              ge = Math.max(1e-4, ge + L), this.radius.set(k, Math.log(ge));
+            }, b.rotate = function(k, E, T, L) {
+              this.recalcMatrix(k), E = E || 0, T = T || 0;
+              var x = this.computedMatrix, C = x[0], M = x[4], g = x[8], P = x[1], A = x[5], z = x[9], O = x[2], U = x[6], G = x[10], Z = E * C + T * P, j = E * M + T * A, N = E * g + T * z, H = -(U * N - G * j), re = -(G * Z - O * N), oe = -(O * j - U * Z), _e = Math.sqrt(Math.max(0, 1 - Math.pow(H, 2) - Math.pow(re, 2) - Math.pow(oe, 2))), Ce = d(H, re, oe, _e);
+              Ce > 1e-6 ? (H /= Ce, re /= Ce, oe /= Ce, _e /= Ce) : (H = re = oe = 0, _e = 1);
+              var Le = this.computedRotation, ge = Le[0], ie = Le[1], Se = Le[2], Ee = Le[3], Ae = ge * _e + Ee * H + ie * oe - Se * re, Be = ie * _e + Ee * re + Se * H - ge * oe, Pe = Se * _e + Ee * oe + ge * re - ie * H, me = Ee * _e - ge * H - ie * re - Se * oe;
+              if (L) {
+                H = O, re = U, oe = G;
+                var De = Math.sin(L) / h(H, re, oe);
+                H *= De, re *= De, oe *= De, _e = Math.cos(E), Ae = Ae * _e + me * H + Be * oe - Pe * re, Be = Be * _e + me * re + Pe * H - Ae * oe, Pe = Pe * _e + me * oe + Ae * re - Be * H, me = me * _e - Ae * H - Be * re - Pe * oe;
+              }
+              var ce = d(Ae, Be, Pe, me);
+              ce > 1e-6 ? (Ae /= ce, Be /= ce, Pe /= ce, me /= ce) : (Ae = Be = Pe = 0, me = 1), this.rotation.set(k, Ae, Be, Pe, me);
+            }, b.lookAt = function(k, E, T, L) {
+              this.recalcMatrix(k), T = T || this.computedCenter, E = E || this.computedEye, L = L || this.computedUp;
+              var x = this.computedMatrix;
+              l(x, E, T, L);
+              var C = this.computedRotation;
+              f(C, x[0], x[1], x[2], x[4], x[5], x[6], x[8], x[9], x[10]), v(C, C), this.rotation.set(k, C[0], C[1], C[2], C[3]);
+              for (var M = 0, g = 0; g < 3; ++g) M += Math.pow(T[g] - E[g], 2);
+              this.radius.set(k, 0.5 * Math.log(Math.max(M, 1e-6))), this.center.set(k, T[0], T[1], T[2]);
+            }, b.translate = function(k, E, T, L) {
+              this.center.move(k, E || 0, T || 0, L || 0);
+            }, b.setMatrix = function(k, E) {
+              var T = this.computedRotation;
+              f(T, E[0], E[1], E[2], E[4], E[5], E[6], E[8], E[9], E[10]), v(T, T), this.rotation.set(k, T[0], T[1], T[2], T[3]);
+              var L = this.computedMatrix;
+              c(L, E);
+              var x = L[15];
+              if (Math.abs(x) > 1e-6) {
+                var C = L[12] / x, M = L[13] / x, g = L[14] / x;
+                this.recalcMatrix(k);
+                var P = Math.exp(this.computedRadius[0]);
+                this.center.set(k, C - L[2] * P, M - L[6] * P, g - L[10] * P), this.radius.idle(k);
+              } else this.center.idle(k), this.radius.idle(k);
+            }, b.setDistance = function(k, E) {
+              E > 0 && this.radius.set(k, Math.log(E));
+            }, b.setDistanceLimits = function(k, E) {
+              k > 0 ? k = Math.log(k) : k = -1 / 0, E > 0 ? E = Math.log(E) : E = 1 / 0, E = Math.max(E, k), this.radius.bounds[0][0] = k, this.radius.bounds[1][0] = E;
+            }, b.getDistanceLimits = function(k) {
+              var E = this.radius.bounds;
+              return k ? (k[0] = Math.exp(E[0][0]), k[1] = Math.exp(E[1][0]), k) : [Math.exp(E[0][0]), Math.exp(E[1][0])];
+            }, b.toJSON = function() {
+              return this.recalcMatrix(this.lastT()), { center: this.computedCenter.slice(), rotation: this.computedRotation.slice(), distance: Math.log(this.computedRadius[0]), zoomMin: this.radius.bounds[0][0], zoomMax: this.radius.bounds[1][0] };
+            }, b.fromJSON = function(k) {
+              var E = this.lastT(), T = k.center;
+              T && this.center.set(E, T[0], T[1], T[2]);
+              var L = k.rotation;
+              L && this.rotation.set(E, L[0], L[1], L[2], L[3]);
+              var x = k.distance;
+              x && x > 0 && this.radius.set(E, Math.log(x)), this.setDistanceLimits(k.zoomMin, k.zoomMax);
+            };
+            function p(k) {
+              k = k || {};
+              var E = k.center || [0, 0, 0], T = k.rotation || [0, 0, 0, 1], L = k.radius || 1;
+              E = [].slice.call(E, 0, 3), T = [].slice.call(T, 0, 4), v(T, T);
+              var x = new _(T, E, Math.log(L));
+              return x.setDistanceLimits(k.zoomMin, k.zoomMax), ("eye" in k || "up" in k) && x.lookAt(0, k.eye, k.center, k.up), x;
+            }
+          }, 9994: function(i, a, o) {
+            var s = o(9618), l = o(8277);
+            i.exports = function(c, f) {
+              for (var h = [], d = c, v = 1; Array.isArray(d); ) h.push(d.length), v *= d.length, d = d[0];
+              return h.length === 0 ? s() : (f || (f = s(new Float64Array(v), h)), l(f, c), f);
+            };
+          } }, t = {};
+          function r(i) {
+            var a = t[i];
+            if (a !== void 0) return a.exports;
+            var o = t[i] = { id: i, loaded: false, exports: {} };
+            return e[i].call(o.exports, o, o.exports, r), o.loaded = true, o.exports;
+          }
+          (function() {
+            r.g = function() {
+              if (typeof globalThis == "object") return globalThis;
+              try {
+                return this || new Function("return this")();
+              } catch (i) {
+                if (typeof window == "object") return window;
+              }
+            }();
+          })(), function() {
+            r.nmd = function(i) {
+              return i.paths = [], i.children || (i.children = []), i;
+            };
+          }();
+          var n = r(1964);
+          APe.exports = n;
+        })();
+      });
+      var TX = ye((egr, SPe) => {
+        SPe.exports = { aliceblue: [240, 248, 255], antiquewhite: [250, 235, 215], aqua: [0, 255, 255], aquamarine: [127, 255, 212], azure: [240, 255, 255], beige: [245, 245, 220], bisque: [255, 228, 196], black: [0, 0, 0], blanchedalmond: [255, 235, 205], blue: [0, 0, 255], blueviolet: [138, 43, 226], brown: [165, 42, 42], burlywood: [222, 184, 135], cadetblue: [95, 158, 160], chartreuse: [127, 255, 0], chocolate: [210, 105, 30], coral: [255, 127, 80], cornflowerblue: [100, 149, 237], cornsilk: [255, 248, 220], crimson: [220, 20, 60], cyan: [0, 255, 255], darkblue: [0, 0, 139], darkcyan: [0, 139, 139], darkgoldenrod: [184, 134, 11], darkgray: [169, 169, 169], darkgreen: [0, 100, 0], darkgrey: [169, 169, 169], darkkhaki: [189, 183, 107], darkmagenta: [139, 0, 139], darkolivegreen: [85, 107, 47], darkorange: [255, 140, 0], darkorchid: [153, 50, 204], darkred: [139, 0, 0], darksalmon: [233, 150, 122], darkseagreen: [143, 188, 143], darkslateblue: [72, 61, 139], darkslategray: [47, 79, 79], darkslategrey: [47, 79, 79], darkturquoise: [0, 206, 209], darkviolet: [148, 0, 211], deeppink: [255, 20, 147], deepskyblue: [0, 191, 255], dimgray: [105, 105, 105], dimgrey: [105, 105, 105], dodgerblue: [30, 144, 255], firebrick: [178, 34, 34], floralwhite: [255, 250, 240], forestgreen: [34, 139, 34], fuchsia: [255, 0, 255], gainsboro: [220, 220, 220], ghostwhite: [248, 248, 255], gold: [255, 215, 0], goldenrod: [218, 165, 32], gray: [128, 128, 128], green: [0, 128, 0], greenyellow: [173, 255, 47], grey: [128, 128, 128], honeydew: [240, 255, 240], hotpink: [255, 105, 180], indianred: [205, 92, 92], indigo: [75, 0, 130], ivory: [255, 255, 240], khaki: [240, 230, 140], lavender: [230, 230, 250], lavenderblush: [255, 240, 245], lawngreen: [124, 252, 0], lemonchiffon: [255, 250, 205], lightblue: [173, 216, 230], lightcoral: [240, 128, 128], lightcyan: [224, 255, 255], lightgoldenrodyellow: [250, 250, 210], lightgray: [211, 211, 211], lightgreen: [144, 238, 144], lightgrey: [211, 211, 211], lightpink: [255, 182, 193], lightsalmon: [255, 160, 122], lightseagreen: [32, 178, 170], lightskyblue: [135, 206, 250], lightslategray: [119, 136, 153], lightslategrey: [119, 136, 153], lightsteelblue: [176, 196, 222], lightyellow: [255, 255, 224], lime: [0, 255, 0], limegreen: [50, 205, 50], linen: [250, 240, 230], magenta: [255, 0, 255], maroon: [128, 0, 0], mediumaquamarine: [102, 205, 170], mediumblue: [0, 0, 205], mediumorchid: [186, 85, 211], mediumpurple: [147, 112, 219], mediumseagreen: [60, 179, 113], mediumslateblue: [123, 104, 238], mediumspringgreen: [0, 250, 154], mediumturquoise: [72, 209, 204], mediumvioletred: [199, 21, 133], midnightblue: [25, 25, 112], mintcream: [245, 255, 250], mistyrose: [255, 228, 225], moccasin: [255, 228, 181], navajowhite: [255, 222, 173], navy: [0, 0, 128], oldlace: [253, 245, 230], olive: [128, 128, 0], olivedrab: [107, 142, 35], orange: [255, 165, 0], orangered: [255, 69, 0], orchid: [218, 112, 214], palegoldenrod: [238, 232, 170], palegreen: [152, 251, 152], paleturquoise: [175, 238, 238], palevioletred: [219, 112, 147], papayawhip: [255, 239, 213], peachpuff: [255, 218, 185], peru: [205, 133, 63], pink: [255, 192, 203], plum: [221, 160, 221], powderblue: [176, 224, 230], purple: [128, 0, 128], rebeccapurple: [102, 51, 153], red: [255, 0, 0], rosybrown: [188, 143, 143], royalblue: [65, 105, 225], saddlebrown: [139, 69, 19], salmon: [250, 128, 114], sandybrown: [244, 164, 96], seagreen: [46, 139, 87], seashell: [255, 245, 238], sienna: [160, 82, 45], silver: [192, 192, 192], skyblue: [135, 206, 235], slateblue: [106, 90, 205], slategray: [112, 128, 144], slategrey: [112, 128, 144], snow: [255, 250, 250], springgreen: [0, 255, 127], steelblue: [70, 130, 180], tan: [210, 180, 140], teal: [0, 128, 128], thistle: [216, 191, 216], tomato: [255, 99, 71], turquoise: [64, 224, 208], violet: [238, 130, 238], wheat: [245, 222, 179], white: [255, 255, 255], whitesmoke: [245, 245, 245], yellow: [255, 255, 0], yellowgreen: [154, 205, 50] };
+      });
+      var CPe = ye((tgr, kPe) => {
+        var MPe = TX();
+        kPe.exports = fIt;
+        var EPe = { red: 0, orange: 60, yellow: 120, green: 180, blue: 240, purple: 300 };
+        function fIt(e) {
+          var t, r = [], n = 1, i;
+          if (typeof e == "string") if (e = e.toLowerCase(), MPe[e]) r = MPe[e].slice(), i = "rgb";
+          else if (e === "transparent") n = 0, i = "rgb", r = [0, 0, 0];
+          else if (/^#[A-Fa-f0-9]+$/.test(e)) {
+            var a = e.slice(1), o = a.length, s = o <= 4;
+            n = 1, s ? (r = [parseInt(a[0] + a[0], 16), parseInt(a[1] + a[1], 16), parseInt(a[2] + a[2], 16)], o === 4 && (n = parseInt(a[3] + a[3], 16) / 255)) : (r = [parseInt(a[0] + a[1], 16), parseInt(a[2] + a[3], 16), parseInt(a[4] + a[5], 16)], o === 8 && (n = parseInt(a[6] + a[7], 16) / 255)), r[0] || (r[0] = 0), r[1] || (r[1] = 0), r[2] || (r[2] = 0), i = "rgb";
+          } else if (t = /^((?:rgb|hs[lvb]|hwb|cmyk?|xy[zy]|gray|lab|lchu?v?|[ly]uv|lms)a?)\s*\(([^\)]*)\)/.exec(e)) {
+            var l = t[1], u = l === "rgb", a = l.replace(/a$/, "");
+            i = a;
+            var o = a === "cmyk" ? 4 : a === "gray" ? 1 : 3;
+            r = t[2].trim().split(/\s*[,\/]\s*|\s+/).map(function(h, d) {
+              if (/%$/.test(h)) return d === o ? parseFloat(h) / 100 : a === "rgb" ? parseFloat(h) * 255 / 100 : parseFloat(h);
+              if (a[d] === "h") {
+                if (/deg$/.test(h)) return parseFloat(h);
+                if (EPe[h] !== void 0) return EPe[h];
+              }
+              return parseFloat(h);
+            }), l === a && r.push(1), n = u || r[o] === void 0 ? 1 : r[o], r = r.slice(0, o);
+          } else e.length > 10 && /[0-9](?:\s|\/)/.test(e) && (r = e.match(/([0-9]+)/g).map(function(c) {
+            return parseFloat(c);
+          }), i = e.match(/([a-z])/ig).join("").toLowerCase());
+          else isNaN(e) ? Array.isArray(e) || e.length ? (r = [e[0], e[1], e[2]], i = "rgb", n = e.length === 4 ? e[3] : 1) : e instanceof Object && (e.r != null || e.red != null || e.R != null ? (i = "rgb", r = [e.r || e.red || e.R || 0, e.g || e.green || e.G || 0, e.b || e.blue || e.B || 0]) : (i = "hsl", r = [e.h || e.hue || e.H || 0, e.s || e.saturation || e.S || 0, e.l || e.lightness || e.L || e.b || e.brightness]), n = e.a || e.alpha || e.opacity || 1, e.opacity != null && (n /= 100)) : (i = "rgb", r = [e >>> 16, (e & 65280) >>> 8, e & 255]);
+          return { space: i, values: r, alpha: n };
+        }
+      });
+      var PPe = ye((rgr, LPe) => {
+        var hIt = CPe();
+        LPe.exports = function(t) {
+          Array.isArray(t) && t.raw && (t = String.raw.apply(null, arguments));
+          var r, a = hIt(t);
+          if (!a.space) return [];
+          var o = [0, 0, 0], s = a.space[0] === "h" ? [360, 100, 100] : [255, 255, 255];
+          return r = Array(3), r[0] = Math.min(Math.max(a.values[0], o[0]), s[0]), r[1] = Math.min(Math.max(a.values[1], o[1]), s[1]), r[2] = Math.min(Math.max(a.values[2], o[2]), s[2]), a.space[0] === "h" && (r = dIt(r)), r.push(Math.min(Math.max(a.alpha, 0), 1)), r;
+        };
+        function dIt(e) {
+          var t = e[0] / 360, r = e[1] / 100, n = e[2] / 100, i, a, o, s, l, u = 0;
+          if (r === 0) return l = n * 255, [l, l, l];
+          for (a = n < 0.5 ? n * (1 + r) : n + r - n * r, i = 2 * n - a, s = [0, 0, 0]; u < 3; ) o = t + 1 / 3 * -(u - 1), o < 0 ? o++ : o > 1 && o--, l = 6 * o < 1 ? i + (a - i) * 6 * o : 2 * o < 1 ? a : 3 * o < 2 ? i + (a - i) * (2 / 3 - o) * 6 : i, s[u++] = l * 255;
+          return s;
+        }
+      });
+      var rk = ye((igr, IPe) => {
+        IPe.exports = vIt;
+        function vIt(e, t, r) {
+          return t < r ? e < t ? t : e > r ? r : e : e < r ? r : e > t ? t : e;
+        }
+      });
+      var QD = ye((ngr, RPe) => {
+        RPe.exports = function(e) {
+          switch (e) {
+            case "int8":
+              return Int8Array;
+            case "int16":
+              return Int16Array;
+            case "int32":
+              return Int32Array;
+            case "uint8":
+              return Uint8Array;
+            case "uint16":
+              return Uint16Array;
+            case "uint32":
+              return Uint32Array;
+            case "float32":
+              return Float32Array;
+            case "float64":
+              return Float64Array;
+            case "array":
+              return Array;
+            case "uint8_clamped":
+              return Uint8ClampedArray;
+          }
+        };
+      });
+      var ox = ye((agr, DPe) => {
+        var pIt = PPe(), eF = rk(), gIt = QD();
+        DPe.exports = function(t, r) {
+          (r === "float" || !r) && (r = "array"), r === "uint" && (r = "uint8"), r === "uint_clamped" && (r = "uint8_clamped");
+          var n = gIt(r), i = new n(4), a = r !== "uint8" && r !== "uint8_clamped";
+          return (!t.length || typeof t == "string") && (t = pIt(t), t[0] /= 255, t[1] /= 255, t[2] /= 255), mIt(t) ? (i[0] = t[0], i[1] = t[1], i[2] = t[2], i[3] = t[3] != null ? t[3] : 255, a && (i[0] /= 255, i[1] /= 255, i[2] /= 255, i[3] /= 255), i) : (a ? (i[0] = t[0], i[1] = t[1], i[2] = t[2], i[3] = t[3] != null ? t[3] : 1) : (i[0] = eF(Math.floor(t[0] * 255), 0, 255), i[1] = eF(Math.floor(t[1] * 255), 0, 255), i[2] = eF(Math.floor(t[2] * 255), 0, 255), i[3] = t[3] == null ? 255 : eF(Math.floor(t[3] * 255), 0, 255)), i);
+        };
+        function mIt(e) {
+          return !!(e instanceof Uint8Array || e instanceof Uint8ClampedArray || Array.isArray(e) && (e[0] > 1 || e[0] === 0) && (e[1] > 1 || e[1] === 0) && (e[2] > 1 || e[2] === 0) && (!e[3] || e[3] > 1));
+        }
+      });
+      var n1 = ye((ogr, FPe) => {
+        var yIt = ox();
+        function _It(e) {
+          return e ? yIt(e) : [0, 0, 0, 1];
+        }
+        FPe.exports = _It;
+      });
+      var a1 = ye((sgr, VPe) => {
+        var NPe = Eo(), xIt = fd(), tF = ox(), rF = tc(), bIt = Ih().defaultLine, zPe = vv().isArrayOrTypedArray, AX = tF(bIt), UPe = 1;
+        function OPe(e, t) {
+          var r = e;
+          return r[3] *= t, r;
+        }
+        function qPe(e) {
+          if (NPe(e)) return AX;
+          var t = tF(e);
+          return t.length ? t : AX;
+        }
+        function BPe(e) {
+          return NPe(e) ? e : UPe;
+        }
+        function wIt(e, t, r) {
+          var n = e.color;
+          n && n._inputArray && (n = n._inputArray);
+          var i = zPe(n), a = zPe(t), o = rF.extractOpts(e), s = [], l, u, c, f, h;
+          if (o.colorscale !== void 0 ? l = rF.makeColorScaleFuncFromTrace(e) : l = qPe, i ? u = function(v, _) {
+            return v[_] === void 0 ? AX : tF(l(v[_]));
+          } : u = qPe, a ? c = function(v, _) {
+            return v[_] === void 0 ? UPe : BPe(v[_]);
+          } : c = BPe, i || a) for (var d = 0; d < r; d++) f = u(n, d), h = c(t, d), s[d] = OPe(f, h);
+          else s = OPe(tF(n), t);
+          return s;
+        }
+        function TIt(e) {
+          var t = rF.extractOpts(e), r = t.colorscale;
+          return t.reversescale && (r = rF.flipScale(t.colorscale)), r.map(function(n) {
+            var i = n[0], a = xIt(n[1]), o = a.toRgb();
+            return { index: i, rgb: [o.r, o.g, o.b, o.a] };
+          });
+        }
+        VPe.exports = { formatColor: wIt, parseColorScale: TIt };
+      });
+      var SX = ye((lgr, GPe) => {
+        GPe.exports = { solid: [[], 0], dot: [[0.5, 1], 200], dash: [[0.5, 1], 50], longdash: [[0.5, 1], 10], dashdot: [[0.5, 0.625, 0.875, 1], 50], longdashdot: [[0.5, 0.7, 0.8, 1], 10] };
+      });
+      var iF = ye((ugr, HPe) => {
+        HPe.exports = { circle: "●", "circle-open": "○", square: "■", "square-open": "□", diamond: "◆", "diamond-open": "◇", cross: "+", x: "❌" };
+      });
+      var WPe = ye((cgr, jPe) => {
+        var AIt = qa();
+        function MX(e, t, r, n) {
+          if (!t || !t.visible) return null;
+          for (var i = AIt.getComponentMethod("errorbars", "makeComputeError")(t), a = new Array(e.length), o = 0; o < e.length; o++) {
+            var s = i(+e[o], o);
+            if (n.type === "log") {
+              var l = n.c2l(e[o]), u = e[o] - s[0], c = e[o] + s[1];
+              if (a[o] = [(n.c2l(u, true) - l) * r, (n.c2l(c, true) - l) * r], u > 0) {
+                var f = n.c2l(u);
+                n._lowerLogErrorBound || (n._lowerLogErrorBound = f), n._lowerErrorBound = Math.min(n._lowerLogErrorBound, f);
+              }
+            } else a[o] = [-s[0] * r, s[1] * r];
+          }
+          return a;
+        }
+        function SIt(e) {
+          for (var t = 0; t < e.length; t++) if (e[t]) return e[t].length;
+          return 0;
+        }
+        function MIt(e, t, r) {
+          var n = [MX(e.x, e.error_x, t[0], r.xaxis), MX(e.y, e.error_y, t[1], r.yaxis), MX(e.z, e.error_z, t[2], r.zaxis)], i = SIt(n);
+          if (i === 0) return null;
+          for (var a = new Array(i), o = 0; o < i; o++) {
+            for (var s = [[0, 0, 0], [0, 0, 0]], l = 0; l < 3; l++) if (n[l]) for (var u = 0; u < 2; u++) s[u][l] = n[l][o][u];
+            a[o] = s;
+          }
+          return a;
+        }
+        jPe.exports = MIt;
+      });
+      var tIe = ye((fgr, eIe) => {
+        var EIt = zd().gl_line3d, XPe = zd().gl_scatter3d, kIt = zd().gl_error3d, CIt = zd().gl_mesh3d, LIt = zd().delaunay_triangulate, o1 = Dr(), $Pe = n1(), nF = a1().formatColor, PIt = O3(), EX = SX(), IIt = iF(), RIt = ho(), DIt = ip().appendArrayPointValue, FIt = WPe();
+        function QPe(e, t) {
+          this.scene = e, this.uid = t, this.linePlot = null, this.scatterPlot = null, this.errorBars = null, this.textMarkers = null, this.delaunayMesh = null, this.color = null, this.mode = "", this.dataPoints = [], this.axesBounds = [[-1 / 0, -1 / 0, -1 / 0], [1 / 0, 1 / 0, 1 / 0]], this.textLabels = null, this.data = null;
+        }
+        var CX = QPe.prototype;
+        CX.handlePick = function(e) {
+          if (e.object && (e.object === this.linePlot || e.object === this.delaunayMesh || e.object === this.textMarkers || e.object === this.scatterPlot)) {
+            var t = e.index = e.data.index;
+            return e.object.highlight && e.object.highlight(null), this.scatterPlot && (e.object = this.scatterPlot, this.scatterPlot.highlight(e.data)), e.textLabel = "", this.textLabels && (o1.isArrayOrTypedArray(this.textLabels) ? (this.textLabels[t] || this.textLabels[t] === 0) && (e.textLabel = this.textLabels[t]) : e.textLabel = this.textLabels), e.traceCoordinate = [this.data.x[t], this.data.y[t], this.data.z[t]], true;
+          }
+        };
+        function zIt(e, t, r) {
+          var n = (r + 1) % 3, i = (r + 2) % 3, a = [], o = [], s;
+          for (s = 0; s < e.length; ++s) {
+            var l = e[s];
+            isNaN(l[n]) || !isFinite(l[n]) || isNaN(l[i]) || !isFinite(l[i]) || (a.push([l[n], l[i]]), o.push(s));
+          }
+          var u = LIt(a);
+          for (s = 0; s < u.length; ++s) for (var c = u[s], f = 0; f < c.length; ++f) c[f] = o[c[f]];
+          return { positions: e, cells: u, meshColor: t };
+        }
+        function OIt(e) {
+          for (var t = [0, 0, 0], r = [[0, 0, 0], [0, 0, 0], [0, 0, 0]], n = [1, 1, 1], i = 0; i < 3; i++) {
+            var a = e[i];
+            a && a.copy_zstyle !== false && e[2].visible !== false && (a = e[2]), !(!a || !a.visible) && (t[i] = a.width / 2, r[i] = $Pe(a.color), n[i] = a.thickness);
+          }
+          return { capSize: t, color: r, lineWidth: n };
+        }
+        function ZPe(e) {
+          return e == null ? 0 : e.indexOf("left") > -1 ? -1 : e.indexOf("right") > -1 ? 1 : 0;
+        }
+        function YPe(e) {
+          return e == null ? 0 : e.indexOf("top") > -1 ? -1 : e.indexOf("bottom") > -1 ? 1 : 0;
+        }
+        function qIt(e) {
+          var t = 0, r = 0, n = [t, r];
+          if (Array.isArray(e)) for (var i = 0; i < e.length; i++) n[i] = [t, r], e[i] && (n[i][0] = ZPe(e[i]), n[i][1] = YPe(e[i]));
+          else n[0] = ZPe(e), n[1] = YPe(e);
+          return n;
+        }
+        function BIt(e, t) {
+          return t(e * 4);
+        }
+        function NIt(e) {
+          return IIt[e];
+        }
+        function kX(e, t, r, n, i) {
+          var a = null;
+          if (o1.isArrayOrTypedArray(e)) {
+            a = [];
+            for (var o = 0; o < t; o++) e[o] === void 0 ? a[o] = n : a[o] = r(e[o], i);
+          } else a = r(e, o1.identity);
+          return a;
+        }
+        function UIt(e, t) {
+          var r = [], n = e.fullSceneLayout, i = e.dataScale, a = n.xaxis, o = n.yaxis, s = n.zaxis, l = t.marker, u = t.line, c = t.x || [], f = t.y || [], h = t.z || [], d = c.length, v = t.xcalendar, _ = t.ycalendar, b = t.zcalendar, p, k, E, T, L, x;
+          for (L = 0; L < d; L++) p = a.d2l(c[L], 0, v) * i[0], k = o.d2l(f[L], 0, _) * i[1], E = s.d2l(h[L], 0, b) * i[2], r[L] = [p, k, E];
+          if (Array.isArray(t.text)) x = t.text;
+          else if (o1.isTypedArray(t.text)) x = Array.from(t.text);
+          else if (t.text !== void 0) for (x = new Array(d), L = 0; L < d; L++) x[L] = t.text;
+          function C(oe, _e) {
+            var Ce = n[oe];
+            return RIt.tickText(Ce, Ce.d2l(_e), true).text;
+          }
+          var M = t.texttemplate;
+          if (M) {
+            var g = e.fullLayout, P = g._d3locale, A = Array.isArray(M), z = A ? Math.min(M.length, d) : d, O = A ? function(oe) {
+              return M[oe];
+            } : function() {
+              return M;
+            };
+            for (x = new Array(z), L = 0; L < z; L++) {
+              var U = { x: c[L], y: f[L], z: h[L] }, G = { xLabel: C("xaxis", c[L]), yLabel: C("yaxis", f[L]), zLabel: C("zaxis", h[L]) }, Z = {};
+              DIt(Z, t, L), x[L] = o1.texttemplateString({ data: [Z, U, t._meta], fallback: t.texttemplatefallback, labels: G, locale: P, template: O(L) });
+            }
+          }
+          if (T = { position: r, mode: t.mode, text: x }, "line" in t && (T.lineColor = nF(u, 1, d), T.lineWidth = u.width, T.lineDashes = u.dash), "marker" in t) {
+            var j = PIt(t);
+            T.scatterColor = nF(l, 1, d), T.scatterSize = kX(l.size, d, BIt, 20, j), T.scatterMarker = kX(l.symbol, d, NIt, "●"), T.scatterLineWidth = l.line.width, T.scatterLineColor = nF(l.line, 1, d), T.scatterAngle = 0;
+          }
+          "textposition" in t && (T.textOffset = qIt(t.textposition), T.textColor = nF(t.textfont, 1, d), T.textSize = kX(t.textfont.size, d, o1.identity, 12), T.textFontFamily = t.textfont.family, T.textFontWeight = t.textfont.weight, T.textFontStyle = t.textfont.style, T.textFontVariant = t.textfont.variant, T.textAngle = 0);
+          var N = ["x", "y", "z"];
+          for (T.project = [false, false, false], T.projectScale = [1, 1, 1], T.projectOpacity = [1, 1, 1], L = 0; L < 3; ++L) {
+            var H = t.projection[N[L]];
+            (T.project[L] = H.show) && (T.projectOpacity[L] = H.opacity, T.projectScale[L] = H.scale);
+          }
+          T.errorBounds = FIt(t, i, n);
+          var re = OIt([t.error_x, t.error_y, t.error_z]);
+          return T.errorColor = re.color, T.errorLineWidth = re.lineWidth, T.errorCapSize = re.capSize, T.delaunayAxis = t.surfaceaxis, T.delaunayColor = $Pe(t.surfacecolor), T;
+        }
+        function KPe(e) {
+          if (o1.isArrayOrTypedArray(e)) {
+            var t = e[0];
+            return o1.isArrayOrTypedArray(t) && (e = t), "rgb(" + e.slice(0, 3).map(function(r) {
+              return Math.round(r * 255);
+            }) + ")";
+          }
+          return null;
+        }
+        function JPe(e) {
+          return o1.isArrayOrTypedArray(e) ? e.length === 4 && typeof e[0] == "number" ? KPe(e) : e.map(KPe) : null;
+        }
+        CX.update = function(e) {
+          var t = this.scene.glplot.gl, r, n, i, a, o = EX.solid;
+          this.data = e;
+          var s = UIt(this.scene, e);
+          "mode" in s && (this.mode = s.mode), "lineDashes" in s && s.lineDashes in EX && (o = EX[s.lineDashes]), this.color = JPe(s.scatterColor) || JPe(s.lineColor), this.dataPoints = s.position, r = { gl: this.scene.glplot.gl, position: s.position, color: s.lineColor, lineWidth: s.lineWidth || 1, dashes: o[0], dashScale: o[1], opacity: e.opacity, connectGaps: e.connectgaps }, this.mode.indexOf("lines") !== -1 ? this.linePlot ? this.linePlot.update(r) : (this.linePlot = EIt(r), this.linePlot._trace = this, this.scene.glplot.add(this.linePlot)) : this.linePlot && (this.scene.glplot.remove(this.linePlot), this.linePlot.dispose(), this.linePlot = null);
+          var l = e.opacity;
+          if (e.marker && e.marker.opacity !== void 0 && (l *= e.marker.opacity), n = { gl: this.scene.glplot.gl, position: s.position, color: s.scatterColor, size: s.scatterSize, glyph: s.scatterMarker, opacity: l, orthographic: true, lineWidth: s.scatterLineWidth, lineColor: s.scatterLineColor, project: s.project, projectScale: s.projectScale, projectOpacity: s.projectOpacity }, this.mode.indexOf("markers") !== -1 ? this.scatterPlot ? this.scatterPlot.update(n) : (this.scatterPlot = XPe(n), this.scatterPlot._trace = this, this.scatterPlot.highlightScale = 1, this.scene.glplot.add(this.scatterPlot)) : this.scatterPlot && (this.scene.glplot.remove(this.scatterPlot), this.scatterPlot.dispose(), this.scatterPlot = null), a = { gl: this.scene.glplot.gl, position: s.position, glyph: s.text, color: s.textColor, size: s.textSize, angle: s.textAngle, alignment: s.textOffset, font: s.textFontFamily, fontWeight: s.textFontWeight, fontStyle: s.textFontStyle, fontVariant: s.textFontVariant, orthographic: true, lineWidth: 0, project: false, opacity: e.opacity }, this.textLabels = e.hovertext || e.text, this.mode.indexOf("text") !== -1 ? this.textMarkers ? this.textMarkers.update(a) : (this.textMarkers = XPe(a), this.textMarkers._trace = this, this.textMarkers.highlightScale = 1, this.scene.glplot.add(this.textMarkers)) : this.textMarkers && (this.scene.glplot.remove(this.textMarkers), this.textMarkers.dispose(), this.textMarkers = null), i = { gl: this.scene.glplot.gl, position: s.position, color: s.errorColor, error: s.errorBounds, lineWidth: s.errorLineWidth, capSize: s.errorCapSize, opacity: e.opacity }, this.errorBars ? s.errorBounds ? this.errorBars.update(i) : (this.scene.glplot.remove(this.errorBars), this.errorBars.dispose(), this.errorBars = null) : s.errorBounds && (this.errorBars = kIt(i), this.errorBars._trace = this, this.scene.glplot.add(this.errorBars)), s.delaunayAxis >= 0) {
+            var u = zIt(s.position, s.delaunayColor, s.delaunayAxis);
+            u.opacity = e.opacity, this.delaunayMesh ? this.delaunayMesh.update(u) : (u.gl = t, this.delaunayMesh = CIt(u), this.delaunayMesh._trace = this, this.scene.glplot.add(this.delaunayMesh));
+          } else this.delaunayMesh && (this.scene.glplot.remove(this.delaunayMesh), this.delaunayMesh.dispose(), this.delaunayMesh = null);
+        };
+        CX.dispose = function() {
+          this.linePlot && (this.scene.glplot.remove(this.linePlot), this.linePlot.dispose()), this.scatterPlot && (this.scene.glplot.remove(this.scatterPlot), this.scatterPlot.dispose()), this.errorBars && (this.scene.glplot.remove(this.errorBars), this.errorBars.dispose()), this.textMarkers && (this.scene.glplot.remove(this.textMarkers), this.textMarkers.dispose()), this.delaunayMesh && (this.scene.glplot.remove(this.delaunayMesh), this.delaunayMesh.dispose());
+        };
+        function VIt(e, t) {
+          var r = new QPe(e, t.uid);
+          return r.update(t), r;
+        }
+        eIe.exports = VIt;
+      });
+      var DX = ye((hgr, aIe) => {
+        var s1 = pf(), GIt = ec(), RX = Tu(), LX = df().axisHoverFormat, { hovertemplateAttrs: HIt, texttemplateAttrs: jIt, templatefallbackAttrs: rIe } = Ll(), iIe = Gl(), WIt = SX(), XIt = iF(), $g = Ao().extendFlat, ZIt = mc().overrideAll, nIe = t_(), YIt = s1.line, J2 = s1.marker, KIt = J2.line, JIt = $g({ width: YIt.width, dash: { valType: "enumerated", values: nIe(WIt), dflt: "solid" } }, RX("line"));
+        function PX(e) {
+          return { show: { valType: "boolean", dflt: false }, opacity: { valType: "number", min: 0, max: 1, dflt: 1 }, scale: { valType: "number", min: 0, max: 10, dflt: 2 / 3 } };
+        }
+        var IX = aIe.exports = ZIt({ x: s1.x, y: s1.y, z: { valType: "data_array" }, text: $g({}, s1.text, {}), texttemplate: jIt(), texttemplatefallback: rIe({ editType: "calc" }), hovertext: $g({}, s1.hovertext, {}), hovertemplate: HIt(), hovertemplatefallback: rIe(), xhoverformat: LX("x"), yhoverformat: LX("y"), zhoverformat: LX("z"), mode: $g({}, s1.mode, { dflt: "lines+markers" }), surfaceaxis: { valType: "enumerated", values: [-1, 0, 1, 2], dflt: -1 }, surfacecolor: { valType: "color" }, projection: { x: PX(), y: PX(), z: PX() }, connectgaps: s1.connectgaps, line: JIt, marker: $g({ symbol: { valType: "enumerated", values: nIe(XIt), dflt: "circle", arrayOk: true }, size: $g({}, J2.size, { dflt: 8 }), sizeref: J2.sizeref, sizemin: J2.sizemin, sizemode: J2.sizemode, opacity: $g({}, J2.opacity, { arrayOk: false }), colorbar: J2.colorbar, line: $g({ width: $g({}, KIt.width, { arrayOk: false }) }, RX("marker.line")) }, RX("marker")), textposition: $g({}, s1.textposition, { dflt: "top center" }), textfont: GIt({ noFontShadow: true, noFontLineposition: true, noFontTextcase: true, editType: "calc", colorEditType: "style", arrayOk: true, variantValues: ["normal", "small-caps"] }), opacity: iIe.opacity, hoverinfo: $g({}, iIe.hoverinfo) }, "calc", "nested");
+        IX.x.editType = IX.y.editType = IX.z.editType = "calc+clearAxisTypes";
+      });
+      var lIe = ye((dgr, sIe) => {
+        var oIe = qa(), $It = Dr(), FX = Ru(), QIt = $p(), e8t = D0(), t8t = F0(), r8t = DX();
+        sIe.exports = function(t, r, n, i) {
+          function a(d, v) {
+            return $It.coerce(t, r, r8t, d, v);
+          }
+          var o = i8t(t, r, a, i);
+          if (!o) {
+            r.visible = false;
+            return;
+          }
+          a("text"), a("hovertext"), a("hovertemplate"), a("hovertemplatefallback"), a("xhoverformat"), a("yhoverformat"), a("zhoverformat"), a("mode"), FX.hasMarkers(r) && QIt(t, r, n, i, a, { noAngle: true, noLineDash: true, noSelect: true }), FX.hasLines(r) && (a("connectgaps"), e8t(t, r, n, i, a)), FX.hasText(r) && (a("texttemplate"), a("texttemplatefallback"), t8t(t, r, i, a, { noSelect: true, noFontShadow: true, noFontLineposition: true, noFontTextcase: true }));
+          var s = (r.line || {}).color, l = (r.marker || {}).color;
+          a("surfaceaxis") >= 0 && a("surfacecolor", s || l);
+          for (var u = ["x", "y", "z"], c = 0; c < 3; ++c) {
+            var f = "projection." + u[c];
+            a(f + ".show") && (a(f + ".opacity"), a(f + ".scale"));
+          }
+          var h = oIe.getComponentMethod("errorbars", "supplyDefaults");
+          h(t, r, s || l || n, { axis: "z" }), h(t, r, s || l || n, { axis: "y", inherit: "z" }), h(t, r, s || l || n, { axis: "x", inherit: "z" });
+        };
+        function i8t(e, t, r, n) {
+          var i = 0, a = r("x"), o = r("y"), s = r("z"), l = oIe.getComponentMethod("calendars", "handleTraceDefaults");
+          return l(e, t, ["x", "y", "z"], n), a && o && s && (i = Math.min(a.length, o.length, s.length), t._length = t._xlength = t._ylength = t._zlength = i), i;
+        }
+      });
+      var cIe = ye((vgr, uIe) => {
+        var n8t = Rm(), a8t = z0();
+        uIe.exports = function(t, r) {
+          var n = [{ x: false, y: false, trace: r, t: {} }];
+          return n8t(n, r), a8t(t, r), n;
+        };
+      });
+      var hIe = ye((pgr, fIe) => {
+        fIe.exports = o8t;
+        function o8t(e, t) {
+          if (typeof e != "string") throw new TypeError("must specify type string");
+          if (t = t || {}, typeof document == "undefined" && !t.canvas) return null;
+          var r = t.canvas || document.createElement("canvas");
+          typeof t.width == "number" && (r.width = t.width), typeof t.height == "number" && (r.height = t.height);
+          var n = t, i;
+          try {
+            var a = [e];
+            e.indexOf("webgl") === 0 && a.push("experimental-" + e);
+            for (var o = 0; o < a.length; o++) if (i = r.getContext(a[o], n), i) return i;
+          } catch (s) {
+            i = null;
+          }
+          return i || null;
+        }
+      });
+      var vIe = ye((ggr, dIe) => {
+        var s8t = hIe();
+        dIe.exports = function(t) {
+          return s8t("webgl", t);
+        };
+      });
+      var zX = ye((mgr, gIe) => {
+        var pIe = ka(), l8t = function() {
+        };
+        gIe.exports = function(t) {
+          for (var r in t) typeof t[r] == "function" && (t[r] = l8t);
+          t.destroy = function() {
+            t.container.parentNode.removeChild(t.container);
+          };
+          var n = document.createElement("div");
+          n.className = "no-webgl", n.style.cursor = "pointer", n.style.fontSize = "24px", n.style.color = pIe.defaults[0], n.style.position = "absolute", n.style.left = n.style.top = "0px", n.style.width = n.style.height = "100%", n.style["background-color"] = pIe.lightLine, n.style["z-index"] = 30;
+          var i = document.createElement("p");
+          return i.textContent = "WebGL is not supported by your browser - visit https://get.webgl.org for more info", i.style.position = "relative", i.style.top = "50%", i.style.left = "50%", i.style.height = "30%", i.style.width = "50%", i.style.margin = "-15% 0 0 -25%", n.appendChild(i), t.container.appendChild(n), t.container.style.background = "#FFFFFF", t.container.onclick = function() {
+            window.open("https://get.webgl.org");
+          }, false;
+        };
+      });
+      var _Ie = ye((ygr, yIe) => {
+        var $2 = n1(), u8t = Dr(), c8t = ["xaxis", "yaxis", "zaxis"];
+        function mIe() {
+          this.bounds = [[-10, -10, -10], [10, 10, 10]], this.ticks = [[], [], []], this.tickEnable = [true, true, true], this.tickFont = ["sans-serif", "sans-serif", "sans-serif"], this.tickSize = [12, 12, 12], this.tickFontWeight = ["normal", "normal", "normal", "normal"], this.tickFontStyle = ["normal", "normal", "normal", "normal"], this.tickFontVariant = ["normal", "normal", "normal", "normal"], this.tickAngle = [0, 0, 0], this.tickColor = [[0, 0, 0, 1], [0, 0, 0, 1], [0, 0, 0, 1]], this.tickPad = [18, 18, 18], this.labels = ["x", "y", "z"], this.labelEnable = [true, true, true], this.labelFont = ["Open Sans", "Open Sans", "Open Sans"], this.labelSize = [20, 20, 20], this.labelFontWeight = ["normal", "normal", "normal", "normal"], this.labelFontStyle = ["normal", "normal", "normal", "normal"], this.labelFontVariant = ["normal", "normal", "normal", "normal"], this.labelColor = [[0, 0, 0, 1], [0, 0, 0, 1], [0, 0, 0, 1]], this.labelPad = [30, 30, 30], this.lineEnable = [true, true, true], this.lineMirror = [false, false, false], this.lineWidth = [1, 1, 1], this.lineColor = [[0, 0, 0, 1], [0, 0, 0, 1], [0, 0, 0, 1]], this.lineTickEnable = [true, true, true], this.lineTickMirror = [false, false, false], this.lineTickLength = [10, 10, 10], this.lineTickWidth = [1, 1, 1], this.lineTickColor = [[0, 0, 0, 1], [0, 0, 0, 1], [0, 0, 0, 1]], this.gridEnable = [true, true, true], this.gridWidth = [1, 1, 1], this.gridColor = [[0, 0, 0, 1], [0, 0, 0, 1], [0, 0, 0, 1]], this.zeroEnable = [true, true, true], this.zeroLineColor = [[0, 0, 0, 1], [0, 0, 0, 1], [0, 0, 0, 1]], this.zeroLineWidth = [2, 2, 2], this.backgroundEnable = [true, true, true], this.backgroundColor = [[0.8, 0.8, 0.8, 0.5], [0.8, 0.8, 0.8, 0.5], [0.8, 0.8, 0.8, 0.5]], this._defaultTickPad = this.tickPad.slice(), this._defaultLabelPad = this.labelPad.slice(), this._defaultLineTickLength = this.lineTickLength.slice();
+        }
+        var f8t = mIe.prototype;
+        f8t.merge = function(e, t) {
+          for (var r = this, n = 0; n < 3; ++n) {
+            var i = t[c8t[n]];
+            if (!i.visible) {
+              r.tickEnable[n] = false, r.labelEnable[n] = false, r.lineEnable[n] = false, r.lineTickEnable[n] = false, r.gridEnable[n] = false, r.zeroEnable[n] = false, r.backgroundEnable[n] = false;
+              continue;
+            }
+            r.labels[n] = e._meta ? u8t.templateString(i.title.text, e._meta) : i.title.text, "font" in i.title && (i.title.font.color && (r.labelColor[n] = $2(i.title.font.color)), i.title.font.family && (r.labelFont[n] = i.title.font.family), i.title.font.size && (r.labelSize[n] = i.title.font.size), i.title.font.weight && (r.labelFontWeight[n] = i.title.font.weight), i.title.font.style && (r.labelFontStyle[n] = i.title.font.style), i.title.font.variant && (r.labelFontVariant[n] = i.title.font.variant)), "showline" in i && (r.lineEnable[n] = i.showline), "linecolor" in i && (r.lineColor[n] = $2(i.linecolor)), "linewidth" in i && (r.lineWidth[n] = i.linewidth), "showgrid" in i && (r.gridEnable[n] = i.showgrid), "gridcolor" in i && (r.gridColor[n] = $2(i.gridcolor)), "gridwidth" in i && (r.gridWidth[n] = i.gridwidth), i.type === "log" ? r.zeroEnable[n] = false : "zeroline" in i && (r.zeroEnable[n] = i.zeroline), "zerolinecolor" in i && (r.zeroLineColor[n] = $2(i.zerolinecolor)), "zerolinewidth" in i && (r.zeroLineWidth[n] = i.zerolinewidth), "ticks" in i && i.ticks ? r.lineTickEnable[n] = true : r.lineTickEnable[n] = false, "ticklen" in i && (r.lineTickLength[n] = r._defaultLineTickLength[n] = i.ticklen), "tickcolor" in i && (r.lineTickColor[n] = $2(i.tickcolor)), "tickwidth" in i && (r.lineTickWidth[n] = i.tickwidth), "tickangle" in i && (r.tickAngle[n] = i.tickangle === "auto" ? -3600 : Math.PI * -i.tickangle / 180), "showticklabels" in i && (r.tickEnable[n] = i.showticklabels), "tickfont" in i && (i.tickfont.color && (r.tickColor[n] = $2(i.tickfont.color)), i.tickfont.family && (r.tickFont[n] = i.tickfont.family), i.tickfont.size && (r.tickSize[n] = i.tickfont.size), i.tickfont.weight && (r.tickFontWeight[n] = i.tickfont.weight), i.tickfont.style && (r.tickFontStyle[n] = i.tickfont.style), i.tickfont.variant && (r.tickFontVariant[n] = i.tickfont.variant)), "mirror" in i ? ["ticks", "all", "allticks"].indexOf(i.mirror) !== -1 ? (r.lineTickMirror[n] = true, r.lineMirror[n] = true) : i.mirror === true ? (r.lineTickMirror[n] = false, r.lineMirror[n] = true) : (r.lineTickMirror[n] = false, r.lineMirror[n] = false) : r.lineMirror[n] = false, "showbackground" in i && i.showbackground !== false ? (r.backgroundEnable[n] = true, r.backgroundColor[n] = $2(i.backgroundcolor)) : r.backgroundEnable[n] = false;
+          }
+        };
+        function h8t(e, t) {
+          var r = new mIe();
+          return r.merge(e, t), r;
+        }
+        yIe.exports = h8t;
+      });
+      var wIe = ye((_gr, bIe) => {
+        var d8t = n1(), v8t = ["xaxis", "yaxis", "zaxis"];
+        function xIe() {
+          this.enabled = [true, true, true], this.colors = [[0, 0, 0, 1], [0, 0, 0, 1], [0, 0, 0, 1]], this.drawSides = [true, true, true], this.lineWidth = [1, 1, 1];
+        }
+        var p8t = xIe.prototype;
+        p8t.merge = function(e) {
+          for (var t = 0; t < 3; ++t) {
+            var r = e[v8t[t]];
+            if (!r.visible) {
+              this.enabled[t] = false, this.drawSides[t] = false;
+              continue;
+            }
+            this.enabled[t] = r.showspikes, this.colors[t] = d8t(r.spikecolor), this.drawSides[t] = r.spikesides, this.lineWidth[t] = r.spikethickness;
+          }
+        };
+        function g8t(e) {
+          var t = new xIe();
+          return t.merge(e), t;
+        }
+        bIe.exports = g8t;
+      });
+      var SIe = ye((xgr, AIe) => {
+        AIe.exports = b8t;
+        var TIe = ho(), m8t = Dr(), y8t = ["xaxis", "yaxis", "zaxis"];
+        function x8t(e) {
+          for (var t = new Array(3), r = 0; r < 3; ++r) {
+            for (var n = e[r], i = new Array(n.length), a = 0; a < n.length; ++a) i[a] = n[a].x;
+            t[r] = i;
+          }
+          return t;
+        }
+        function b8t(e) {
+          for (var t = e.axesOptions, r = e.glplot.axesPixels, n = e.fullSceneLayout, i = [[], [], []], a = 0; a < 3; ++a) {
+            var o = n[y8t[a]];
+            if (o._length = (r[a].hi - r[a].lo) * r[a].pixelsPerDataUnit / e.dataScale[a], Math.abs(o._length) === 1 / 0 || isNaN(o._length)) i[a] = [];
+            else {
+              o._input_range = o.range.slice(), o.range[0] = r[a].lo / e.dataScale[a], o.range[1] = r[a].hi / e.dataScale[a], o._m = 1 / (e.dataScale[a] * r[a].pixelsPerDataUnit), o.range[0] === o.range[1] && (o.range[0] -= 1, o.range[1] += 1);
+              var s = o.tickmode;
+              if (o.tickmode === "auto") {
+                o.tickmode = "linear";
+                var l = o.nticks || m8t.constrain(o._length / 40, 4, 9);
+                TIe.autoTicks(o, Math.abs(o.range[1] - o.range[0]) / l);
+              }
+              for (var u = TIe.calcTicks(o, { msUTC: true }), c = 0; c < u.length; ++c) u[c].x = u[c].x * e.dataScale[a], o.type === "date" && (u[c].text = u[c].text.replace(/\<br\>/g, " "));
+              i[a] = u, o.tickmode = s;
+            }
+          }
+          t.ticks = i;
+          for (var a = 0; a < 3; ++a) {
+            0.5 * (e.glplot.bounds[0][a] + e.glplot.bounds[1][a]);
+            for (var c = 0; c < 2; ++c) t.bounds[c][a] = e.glplot.bounds[c][a];
+          }
+          e.contourLevels = x8t(i);
+        }
+      });
+      var IIe = ye((bgr, PIe) => {
+        var kIe = zd().gl_plot3d, w8t = kIe.createCamera, MIe = kIe.createScene, T8t = vIe(), A8t = UL(), sF = qa(), cp = Dr(), oF = cp.preserveDrawingBuffer(), lF = ho(), Qg = vf(), S8t = n1(), M8t = zX(), E8t = XU(), k8t = _Ie(), C8t = wIe(), L8t = SIe(), P8t = Mg().applyAutorangeOptions, ik, aF, CIe = false;
+        function LIe(e, t) {
+          var r = document.createElement("div"), n = e.container;
+          this.graphDiv = e.graphDiv;
+          var i = document.createElementNS("http://www.w3.org/2000/svg", "svg");
+          i.style.position = "absolute", i.style.top = i.style.left = "0px", i.style.width = i.style.height = "100%", i.style["z-index"] = 20, i.style["pointer-events"] = "none", r.appendChild(i), this.svgContainer = i, r.id = e.id, r.style.position = "absolute", r.style.top = r.style.left = "0px", r.style.width = r.style.height = "100%", n.appendChild(r), this.fullLayout = t, this.id = e.id || "scene", this.fullSceneLayout = t[this.id], this.plotArgs = [[], {}, {}], this.axesOptions = k8t(t, t[this.id]), this.spikeOptions = C8t(t[this.id]), this.container = r, this.staticMode = !!e.staticPlot, this.pixelRatio = this.pixelRatio || e.plotGlPixelRatio || 2, this.dataScale = [1, 1, 1], this.contourLevels = [[], [], []], this.convertAnnotations = sF.getComponentMethod("annotations3d", "convert"), this.drawAnnotations = sF.getComponentMethod("annotations3d", "draw"), this.initializeGLPlot();
+        }
+        var Sv = LIe.prototype;
+        Sv.prepareOptions = function() {
+          var e = this, t = { canvas: e.canvas, gl: e.gl, glOptions: { preserveDrawingBuffer: oF, premultipliedAlpha: true, antialias: true }, container: e.container, axes: e.axesOptions, spikes: e.spikeOptions, pickRadius: 10, snapToData: true, autoScale: true, autoBounds: false, cameraObject: e.camera, pixelRatio: e.pixelRatio };
+          if (e.staticMode) {
+            if (!aF && (ik = document.createElement("canvas"), aF = T8t({ canvas: ik, preserveDrawingBuffer: true, premultipliedAlpha: true, antialias: true }), !aF)) throw new Error("error creating static canvas/context for image server");
+            t.gl = aF, t.canvas = ik;
+          }
+          return t;
+        };
+        var EIe = true;
+        Sv.tryCreatePlot = function() {
+          var e = this, t = e.prepareOptions(), r = true;
+          try {
+            e.glplot = MIe(t);
+          } catch (n) {
+            if (e.staticMode || !EIe || oF) r = false;
+            else {
+              cp.warn(["webgl setup failed possibly due to", "false preserveDrawingBuffer config.", "The mobile/tablet device may not be detected by is-mobile module.", "Enabling preserveDrawingBuffer in second attempt to create webgl scene..."].join(" "));
+              try {
+                oF = t.glOptions.preserveDrawingBuffer = true, e.glplot = MIe(t);
+              } catch (i) {
+                oF = t.glOptions.preserveDrawingBuffer = false, r = false;
+              }
+            }
+          }
+          return EIe = false, r;
+        };
+        Sv.initializeGLCamera = function() {
+          var e = this, t = e.fullSceneLayout.camera, r = t.projection.type === "orthographic";
+          e.camera = w8t(e.container, { center: [t.center.x, t.center.y, t.center.z], eye: [t.eye.x, t.eye.y, t.eye.z], up: [t.up.x, t.up.y, t.up.z], _ortho: r, zoomMin: 0.01, zoomMax: 100, mode: "orbit" });
+        };
+        Sv.initializeGLPlot = function() {
+          var e = this;
+          e.initializeGLCamera();
+          var t = e.tryCreatePlot();
+          if (!t) return M8t(e);
+          e.traces = {}, e.make4thDimension();
+          var r = e.graphDiv, n = r.layout, i = function() {
+            var o = {};
+            return e.isCameraChanged(n) && (o[e.id + ".camera"] = e.getCamera()), e.isAspectChanged(n) && (o[e.id + ".aspectratio"] = e.glplot.getAspectratio(), n[e.id].aspectmode !== "manual" && (e.fullSceneLayout.aspectmode = n[e.id].aspectmode = o[e.id + ".aspectmode"] = "manual")), o;
+          }, a = function(o) {
+            if (o.fullSceneLayout.dragmode !== false) {
+              var s = i();
+              o.saveLayout(n), o.graphDiv.emit("plotly_relayout", s);
+            }
+          };
+          return e.glplot.canvas && (e.glplot.canvas.addEventListener("mouseup", function() {
+            a(e);
+          }), e.glplot.canvas.addEventListener("touchstart", function() {
+            CIe = true;
+          }), e.glplot.canvas.addEventListener("wheel", function(o) {
+            if (r._context._scrollZoom.gl3d) {
+              if (e.camera._ortho) {
+                var s = o.deltaX > o.deltaY ? 1.1 : 0.9090909090909091, l = e.glplot.getAspectratio();
+                e.glplot.setAspectratio({ x: s * l.x, y: s * l.y, z: s * l.z });
+              }
+              a(e);
+            }
+          }, A8t ? { passive: false } : false), e.glplot.canvas.addEventListener("mousemove", function() {
+            if (e.fullSceneLayout.dragmode !== false && e.camera.mouseListener.buttons !== 0) {
+              var o = i();
+              e.graphDiv.emit("plotly_relayouting", o);
+            }
+          }), e.staticMode || e.glplot.canvas.addEventListener("webglcontextlost", function(o) {
+            r && r.emit && r.emit("plotly_webglcontextlost", { event: o, layer: e.id });
+          }, false)), e.glplot.oncontextloss = function() {
+            e.recoverContext();
+          }, e.glplot.onrender = function() {
+            e.render();
+          }, true;
+        };
+        Sv.render = function() {
+          var e = this, t = e.graphDiv, r, n = e.svgContainer, i = e.container.getBoundingClientRect();
+          t._fullLayout._calcInverseTransform(t);
+          var a = t._fullLayout._invScaleX, o = t._fullLayout._invScaleY, s = i.width * a, l = i.height * o;
+          n.setAttributeNS(null, "viewBox", "0 0 " + s + " " + l), n.setAttributeNS(null, "width", s), n.setAttributeNS(null, "height", l), L8t(e), e.glplot.axes.update(e.axesOptions);
+          for (var u = Object.keys(e.traces), c = null, f = e.glplot.selection, h = 0; h < u.length; ++h) r = e.traces[u[h]], r.data.hoverinfo !== "skip" && r.handlePick(f) && (c = r), r.setContourLevels && r.setContourLevels();
+          function d(P, A, z) {
+            var O = e.fullSceneLayout[P + "axis"];
+            return O.type !== "log" && (A = O.d2l(A)), lF.hoverLabelText(O, A, z);
+          }
+          if (c !== null) {
+            var v = E8t(e.glplot.cameraParams, f.dataCoordinate);
+            r = c.data;
+            var _ = t._fullData[r.index], b = f.index, p = { xLabel: d("x", f.traceCoordinate[0], r.xhoverformat), yLabel: d("y", f.traceCoordinate[1], r.yhoverformat), zLabel: d("z", f.traceCoordinate[2], r.zhoverformat) }, k = Qg.castHoverinfo(_, e.fullLayout, b), E = (k || "").split("+"), T = k && k === "all";
+            !_.hovertemplate && !T && (E.indexOf("x") === -1 && (p.xLabel = void 0), E.indexOf("y") === -1 && (p.yLabel = void 0), E.indexOf("z") === -1 && (p.zLabel = void 0), E.indexOf("text") === -1 && (f.textLabel = void 0), E.indexOf("name") === -1 && (c.name = void 0));
+            var L, x = [];
+            r.type === "cone" || r.type === "streamtube" ? (p.uLabel = d("x", f.traceCoordinate[3], r.uhoverformat), (T || E.indexOf("u") !== -1) && x.push("u: " + p.uLabel), p.vLabel = d("y", f.traceCoordinate[4], r.vhoverformat), (T || E.indexOf("v") !== -1) && x.push("v: " + p.vLabel), p.wLabel = d("z", f.traceCoordinate[5], r.whoverformat), (T || E.indexOf("w") !== -1) && x.push("w: " + p.wLabel), p.normLabel = f.traceCoordinate[6].toPrecision(3), (T || E.indexOf("norm") !== -1) && x.push("norm: " + p.normLabel), r.type === "streamtube" && (p.divergenceLabel = f.traceCoordinate[7].toPrecision(3), (T || E.indexOf("divergence") !== -1) && x.push("divergence: " + p.divergenceLabel)), f.textLabel && x.push(f.textLabel), L = x.join("<br>")) : r.type === "isosurface" || r.type === "volume" ? (p.valueLabel = lF.hoverLabelText(e._mockAxis, e._mockAxis.d2l(f.traceCoordinate[3]), r.valuehoverformat), x.push("value: " + p.valueLabel), f.textLabel && x.push(f.textLabel), L = x.join("<br>")) : L = f.textLabel;
+            var C = { x: f.traceCoordinate[0], y: f.traceCoordinate[1], z: f.traceCoordinate[2], data: _._input, fullData: _, curveNumber: _.index, pointNumber: b };
+            Qg.appendArrayPointValue(C, _, b), r._module.eventData && (C = _._module.eventData(C, f, _, {}, b));
+            var M = { points: [C] };
+            if (e.fullSceneLayout.hovermode) {
+              var g = [];
+              Qg.loneHover({ trace: _, x: (0.5 + 0.5 * v[0] / v[3]) * s, y: (0.5 - 0.5 * v[1] / v[3]) * l, xLabel: p.xLabel, yLabel: p.yLabel, zLabel: p.zLabel, text: L, name: c.name, color: Qg.castHoverOption(_, b, "bgcolor") || c.color, borderColor: Qg.castHoverOption(_, b, "bordercolor"), fontFamily: Qg.castHoverOption(_, b, "font.family"), fontSize: Qg.castHoverOption(_, b, "font.size"), fontColor: Qg.castHoverOption(_, b, "font.color"), nameLength: Qg.castHoverOption(_, b, "namelength"), textAlign: Qg.castHoverOption(_, b, "align"), hovertemplate: cp.castOption(_, b, "hovertemplate"), hovertemplateLabels: cp.extendFlat({}, C, p), eventData: [C] }, { container: n, gd: t, inOut_bbox: g }), C.bbox = g[0];
+            }
+            f.distance < 5 && (f.buttons || CIe) ? t.emit("plotly_click", M) : t.emit("plotly_hover", M), this.oldEventData = M;
+          } else Qg.loneUnhover(n), this.oldEventData && t.emit("plotly_unhover", this.oldEventData), this.oldEventData = void 0;
+          e.drawAnnotations(e);
+        };
+        Sv.recoverContext = function() {
+          var e = this;
+          e.glplot.dispose();
+          var t = function() {
+            if (e.glplot.gl.isContextLost()) {
+              requestAnimationFrame(t);
+              return;
+            }
+            if (!e.initializeGLPlot()) {
+              cp.error("Catastrophic and unrecoverable WebGL error. Context lost.");
+              return;
+            }
+            e.plot.apply(e, e.plotArgs);
+          };
+          requestAnimationFrame(t);
+        };
+        var nk = ["xaxis", "yaxis", "zaxis"];
+        function I8t(e, t, r) {
+          for (var n = e.fullSceneLayout, i = 0; i < 3; i++) {
+            var a = nk[i], o = a.charAt(0), s = n[a], l = t[o], u = t[o + "calendar"], c = t["_" + o + "length"];
+            if (!cp.isArrayOrTypedArray(l)) r[0][i] = Math.min(r[0][i], 0), r[1][i] = Math.max(r[1][i], c - 1);
+            else for (var f, h = 0; h < (c || l.length); h++) if (cp.isArrayOrTypedArray(l[h])) for (var d = 0; d < l[h].length; ++d) f = s.d2l(l[h][d], 0, u), !isNaN(f) && isFinite(f) && (r[0][i] = Math.min(r[0][i], f), r[1][i] = Math.max(r[1][i], f));
+            else f = s.d2l(l[h], 0, u), !isNaN(f) && isFinite(f) && (r[0][i] = Math.min(r[0][i], f), r[1][i] = Math.max(r[1][i], f));
+          }
+        }
+        function R8t(e, t) {
+          for (var r = e.fullSceneLayout, n = r.annotations || [], i = 0; i < 3; i++) for (var a = nk[i], o = a.charAt(0), s = r[a], l = 0; l < n.length; l++) {
+            var u = n[l];
+            if (u.visible) {
+              var c = s.r2l(u[o]);
+              !isNaN(c) && isFinite(c) && (t[0][i] = Math.min(t[0][i], c), t[1][i] = Math.max(t[1][i], c));
+            }
+          }
+        }
+        Sv.plot = function(e, t, r) {
+          var n = this;
+          if (n.plotArgs = [e, t, r], !n.glplot.contextLost) {
+            var i, a, o, s, l, u, c = t[n.id], f = r[n.id];
+            n.fullLayout = t, n.fullSceneLayout = c, n.axesOptions.merge(t, c), n.spikeOptions.merge(c), n.setViewport(c), n.updateFx(c.dragmode, c.hovermode), n.camera.enableWheel = n.graphDiv._context._scrollZoom.gl3d, n.glplot.setClearColor(S8t(c.bgcolor)), n.setConvert(l), e ? Array.isArray(e) || (e = [e]) : e = [];
+            var h = [[1 / 0, 1 / 0, 1 / 0], [-1 / 0, -1 / 0, -1 / 0]];
+            for (o = 0; o < e.length; ++o) i = e[o], !(i.visible !== true || i._length === 0) && I8t(this, i, h);
+            R8t(this, h);
+            var d = [1, 1, 1];
+            for (s = 0; s < 3; ++s) h[1][s] === h[0][s] ? d[s] = 1 : d[s] = 1 / (h[1][s] - h[0][s]);
+            for (n.dataScale = d, n.convertAnnotations(this), o = 0; o < e.length; ++o) i = e[o], !(i.visible !== true || i._length === 0) && (a = n.traces[i.uid], a ? a.data.type === i.type ? a.update(i) : (a.dispose(), a = i._module.plot(this, i), n.traces[i.uid] = a) : (a = i._module.plot(this, i), n.traces[i.uid] = a), a.name = i.name);
+            var v = Object.keys(n.traces);
+            e: for (o = 0; o < v.length; ++o) {
+              for (s = 0; s < e.length; ++s) if (e[s].uid === v[o] && e[s].visible === true && e[s]._length !== 0) continue e;
+              a = n.traces[v[o]], a.dispose(), delete n.traces[v[o]];
+            }
+            n.glplot.objects.sort(function(oe, _e) {
+              return oe._trace.data.index - _e._trace.data.index;
+            });
+            var _ = [[0, 0, 0], [0, 0, 0]], b = [], p = {};
+            for (o = 0; o < 3; ++o) {
+              l = c[nk[o]], u = l.type, u in p ? (p[u].acc *= d[o], p[u].count += 1) : p[u] = { acc: d[o], count: 1 };
+              var k;
+              if (l.autorange) {
+                _[0][o] = 1 / 0, _[1][o] = -1 / 0;
+                var E = n.glplot.objects, T = n.fullSceneLayout.annotations || [], L = l._name.charAt(0);
+                for (s = 0; s < E.length; s++) {
+                  var x = E[s], C = x.bounds, M = x._trace.data._pad || 0;
+                  x.constructor.name === "ErrorBars" && l._lowerLogErrorBound ? _[0][o] = Math.min(_[0][o], l._lowerLogErrorBound) : _[0][o] = Math.min(_[0][o], C[0][o] / d[o] - M), _[1][o] = Math.max(_[1][o], C[1][o] / d[o] + M);
+                }
+                for (s = 0; s < T.length; s++) {
+                  var g = T[s];
+                  if (g.visible) {
+                    var P = l.r2l(g[L]);
+                    _[0][o] = Math.min(_[0][o], P), _[1][o] = Math.max(_[1][o], P);
+                  }
+                }
+                if ("rangemode" in l && l.rangemode === "tozero" && (_[0][o] = Math.min(_[0][o], 0), _[1][o] = Math.max(_[1][o], 0)), _[0][o] > _[1][o]) _[0][o] = -1, _[1][o] = 1;
+                else {
+                  var A = _[1][o] - _[0][o];
+                  _[0][o] -= A / 32, _[1][o] += A / 32;
+                }
+                if (k = [_[0][o], _[1][o]], k = P8t(k, l), _[0][o] = k[0], _[1][o] = k[1], l.isReversed()) {
+                  var z = _[0][o];
+                  _[0][o] = _[1][o], _[1][o] = z;
+                }
+              } else k = l.range, _[0][o] = l.r2l(k[0]), _[1][o] = l.r2l(k[1]);
+              _[0][o] === _[1][o] && (_[0][o] -= 1, _[1][o] += 1), b[o] = _[1][o] - _[0][o], l.range = [_[0][o], _[1][o]], l.limitRange(), n.glplot.setBounds(o, { min: l.range[0] * d[o], max: l.range[1] * d[o] });
+            }
+            var O, U = c.aspectmode;
+            if (U === "cube") O = [1, 1, 1];
+            else if (U === "manual") {
+              var G = c.aspectratio;
+              O = [G.x, G.y, G.z];
+            } else if (U === "auto" || U === "data") {
+              var Z = [1, 1, 1];
+              for (o = 0; o < 3; ++o) {
+                l = c[nk[o]], u = l.type;
+                var j = p[u];
+                Z[o] = Math.pow(j.acc, 1 / j.count) / d[o];
+              }
+              U === "data" || Math.max.apply(null, Z) / Math.min.apply(null, Z) <= 4 ? O = Z : O = [1, 1, 1];
+            } else throw new Error("scene.js aspectRatio was not one of the enumerated types");
+            c.aspectratio.x = f.aspectratio.x = O[0], c.aspectratio.y = f.aspectratio.y = O[1], c.aspectratio.z = f.aspectratio.z = O[2], n.glplot.setAspectratio(c.aspectratio), n.viewInitial.aspectratio || (n.viewInitial.aspectratio = { x: c.aspectratio.x, y: c.aspectratio.y, z: c.aspectratio.z }), n.viewInitial.aspectmode || (n.viewInitial.aspectmode = c.aspectmode);
+            var N = c.domain || null, H = t._size || null;
+            if (N && H) {
+              var re = n.container.style;
+              re.position = "absolute", re.left = H.l + N.x[0] * H.w + "px", re.top = H.t + (1 - N.y[1]) * H.h + "px", re.width = H.w * (N.x[1] - N.x[0]) + "px", re.height = H.h * (N.y[1] - N.y[0]) + "px";
+            }
+            n.glplot.redraw();
+          }
+        };
+        Sv.destroy = function() {
+          var e = this;
+          e.glplot && (e.camera.mouseListener.enabled = false, e.container.removeEventListener("wheel", e.camera.wheelListener), e.camera = null, e.glplot.dispose(), e.container.parentNode.removeChild(e.container), e.glplot = null);
+        };
+        function D8t(e) {
+          return [[e.eye.x, e.eye.y, e.eye.z], [e.center.x, e.center.y, e.center.z], [e.up.x, e.up.y, e.up.z]];
+        }
+        function F8t(e) {
+          return { up: { x: e.up[0], y: e.up[1], z: e.up[2] }, center: { x: e.center[0], y: e.center[1], z: e.center[2] }, eye: { x: e.eye[0], y: e.eye[1], z: e.eye[2] }, projection: { type: e._ortho === true ? "orthographic" : "perspective" } };
+        }
+        Sv.getCamera = function() {
+          var e = this;
+          return e.camera.view.recalcMatrix(e.camera.view.lastT()), F8t(e.camera);
+        };
+        Sv.setViewport = function(e) {
+          var t = this, r = e.camera;
+          t.camera.lookAt.apply(this, D8t(r)), t.glplot.setAspectratio(e.aspectratio);
+          var n = r.projection.type === "orthographic", i = t.camera._ortho;
+          n !== i && (t.glplot.redraw(), t.glplot.clearRGBA(), t.glplot.dispose(), t.initializeGLPlot());
+        };
+        Sv.isCameraChanged = function(e) {
+          var t = this, r = t.getCamera(), n = cp.nestedProperty(e, t.id + ".camera"), i = n.get();
+          function a(u, c, f, h) {
+            var d = ["up", "center", "eye"], v = ["x", "y", "z"];
+            return c[d[f]] && u[d[f]][v[h]] === c[d[f]][v[h]];
+          }
+          var o = false;
+          if (i === void 0) o = true;
+          else {
+            for (var s = 0; s < 3; s++) for (var l = 0; l < 3; l++) if (!a(r, i, s, l)) {
+              o = true;
+              break;
+            }
+            (!i.projection || r.projection && r.projection.type !== i.projection.type) && (o = true);
+          }
+          return o;
+        };
+        Sv.isAspectChanged = function(e) {
+          var t = this, r = t.glplot.getAspectratio(), n = cp.nestedProperty(e, t.id + ".aspectratio"), i = n.get();
+          return i === void 0 || i.x !== r.x || i.y !== r.y || i.z !== r.z;
+        };
+        Sv.saveLayout = function(e) {
+          var t = this, r = t.fullLayout, n, i, a, o, s, l, u = t.isCameraChanged(e), c = t.isAspectChanged(e), f = u || c;
+          if (f) {
+            var h = {};
+            if (u && (n = t.getCamera(), i = cp.nestedProperty(e, t.id + ".camera"), a = i.get(), h[t.id + ".camera"] = a), c && (o = t.glplot.getAspectratio(), s = cp.nestedProperty(e, t.id + ".aspectratio"), l = s.get(), h[t.id + ".aspectratio"] = l), sF.call("_storeDirectGUIEdit", e, r._preGUI, h), u) {
+              i.set(n);
+              var d = cp.nestedProperty(r, t.id + ".camera");
+              d.set(n);
+            }
+            if (c) {
+              s.set(o);
+              var v = cp.nestedProperty(r, t.id + ".aspectratio");
+              v.set(o), t.glplot.redraw();
+            }
+          }
+          return f;
+        };
+        Sv.updateFx = function(e, t) {
+          var r = this, n = r.camera;
+          if (n) if (e === "orbit") n.mode = "orbit", n.keyBindingMode = "rotate";
+          else if (e === "turntable") {
+            n.up = [0, 0, 1], n.mode = "turntable", n.keyBindingMode = "rotate";
+            var i = r.graphDiv, a = i._fullLayout, o = r.fullSceneLayout.camera, s = o.up.x, l = o.up.y, u = o.up.z;
+            if (u / Math.sqrt(s * s + l * l + u * u) < 0.999) {
+              var c = r.id + ".camera.up", f = { x: 0, y: 0, z: 1 }, h = {};
+              h[c] = f;
+              var d = i.layout;
+              sF.call("_storeDirectGUIEdit", d, a._preGUI, h), o.up = f, cp.nestedProperty(d, c).set(f);
+            }
+          } else n.keyBindingMode = e;
+          r.fullSceneLayout.hovermode = t;
+        };
+        function z8t(e, t, r) {
+          for (var n = 0, i = r - 1; n < i; ++n, --i) for (var a = 0; a < t; ++a) for (var o = 0; o < 4; ++o) {
+            var s = 4 * (t * n + a) + o, l = 4 * (t * i + a) + o, u = e[s];
+            e[s] = e[l], e[l] = u;
+          }
+        }
+        function O8t(e, t, r) {
+          for (var n = 0; n < r; ++n) for (var i = 0; i < t; ++i) {
+            var a = 4 * (t * n + i), o = e[a + 3];
+            if (o > 0) for (var s = 255 / o, l = 0; l < 3; ++l) e[a + l] = Math.min(s * e[a + l], 255);
+          }
+        }
+        Sv.toImage = function(e) {
+          var t = this;
+          e || (e = "png"), t.staticMode && t.container.appendChild(ik), t.glplot.redraw();
+          var r = t.glplot.gl, n = r.drawingBufferWidth, i = r.drawingBufferHeight;
+          r.bindFramebuffer(r.FRAMEBUFFER, null);
+          var a = new Uint8Array(n * i * 4);
+          r.readPixels(0, 0, n, i, r.RGBA, r.UNSIGNED_BYTE, a), z8t(a, n, i), O8t(a, n, i);
+          var o = document.createElement("canvas");
+          o.width = n, o.height = i;
+          var s = o.getContext("2d", { willReadFrequently: true }), l = s.createImageData(n, i);
+          l.data.set(a), s.putImageData(l, 0, 0);
+          var u;
+          switch (e) {
+            case "jpeg":
+              u = o.toDataURL("image/jpeg");
+              break;
+            case "webp":
+              u = o.toDataURL("image/webp");
+              break;
+            default:
+              u = o.toDataURL("image/png");
+          }
+          return t.staticMode && t.container.removeChild(ik), u;
+        };
+        Sv.setConvert = function() {
+          for (var e = this, t = 0; t < 3; t++) {
+            var r = e.fullSceneLayout[nk[t]];
+            lF.setConvert(r, e.fullLayout), r.setScale = cp.noop;
+          }
+        };
+        Sv.make4thDimension = function() {
+          var e = this, t = e.graphDiv, r = t._fullLayout;
+          e._mockAxis = { type: "linear", showexponent: "all", exponentformat: "B" }, lF.setConvert(e._mockAxis, r);
+        };
+        PIe.exports = LIe;
+      });
+      var DIe = ye((wgr, RIe) => {
+        RIe.exports = { scene: { valType: "subplotid", dflt: "scene", editType: "calc+clearAxisTypes" } };
+      });
+      var qX = ye((Tgr, FIe) => {
+        var q8t = ka(), xs = Rd(), OX = Ao().extendFlat, B8t = mc().overrideAll;
+        FIe.exports = B8t({ visible: xs.visible, showspikes: { valType: "boolean", dflt: true }, spikesides: { valType: "boolean", dflt: true }, spikethickness: { valType: "number", min: 0, dflt: 2 }, spikecolor: { valType: "color", dflt: q8t.defaultLine }, showbackground: { valType: "boolean", dflt: false }, backgroundcolor: { valType: "color", dflt: "rgba(204, 204, 204, 0.5)" }, showaxeslabels: { valType: "boolean", dflt: true }, color: xs.color, categoryorder: xs.categoryorder, categoryarray: xs.categoryarray, title: { text: xs.title.text, font: xs.title.font }, type: OX({}, xs.type, { values: ["-", "linear", "log", "date", "category"] }), autotypenumbers: xs.autotypenumbers, autorange: xs.autorange, autorangeoptions: { minallowed: xs.autorangeoptions.minallowed, maxallowed: xs.autorangeoptions.maxallowed, clipmin: xs.autorangeoptions.clipmin, clipmax: xs.autorangeoptions.clipmax, include: xs.autorangeoptions.include, editType: "plot" }, rangemode: xs.rangemode, minallowed: xs.minallowed, maxallowed: xs.maxallowed, range: OX({}, xs.range, { items: [{ valType: "any", editType: "plot", impliedEdits: { "^autorange": false } }, { valType: "any", editType: "plot", impliedEdits: { "^autorange": false } }], anim: false }), tickmode: xs.minor.tickmode, nticks: xs.nticks, tick0: xs.tick0, dtick: xs.dtick, tickvals: xs.tickvals, ticktext: xs.ticktext, ticks: xs.ticks, mirror: xs.mirror, ticklen: xs.ticklen, tickwidth: xs.tickwidth, tickcolor: xs.tickcolor, showticklabels: xs.showticklabels, labelalias: xs.labelalias, tickfont: xs.tickfont, tickangle: xs.tickangle, tickprefix: xs.tickprefix, showtickprefix: xs.showtickprefix, ticksuffix: xs.ticksuffix, showticksuffix: xs.showticksuffix, showexponent: xs.showexponent, exponentformat: xs.exponentformat, minexponent: xs.minexponent, separatethousands: xs.separatethousands, tickformat: xs.tickformat, tickformatstops: xs.tickformatstops, hoverformat: xs.hoverformat, showline: xs.showline, linecolor: xs.linecolor, linewidth: xs.linewidth, showgrid: xs.showgrid, gridcolor: OX({}, xs.gridcolor, { dflt: "rgb(204, 204, 204)" }), gridwidth: xs.gridwidth, zeroline: xs.zeroline, zerolinecolor: xs.zerolinecolor, zerolinewidth: xs.zerolinewidth }, "plot", "from-root");
+      });
+      var VX = ye((Agr, zIe) => {
+        var BX = qX(), N8t = Cc().attributes, NX = Ao().extendFlat, U8t = Dr().counterRegex;
+        function UX(e, t, r) {
+          return { x: { valType: "number", dflt: e, editType: "camera" }, y: { valType: "number", dflt: t, editType: "camera" }, z: { valType: "number", dflt: r, editType: "camera" }, editType: "camera" };
+        }
+        zIe.exports = { _arrayAttrRegexps: [U8t("scene", ".annotations", true)], bgcolor: { valType: "color", dflt: "rgba(0,0,0,0)", editType: "plot" }, camera: { up: NX(UX(0, 0, 1), {}), center: NX(UX(0, 0, 0), {}), eye: NX(UX(1.25, 1.25, 1.25), {}), projection: { type: { valType: "enumerated", values: ["perspective", "orthographic"], dflt: "perspective", editType: "calc" }, editType: "calc" }, editType: "camera" }, domain: N8t({ name: "scene", editType: "plot" }), aspectmode: { valType: "enumerated", values: ["auto", "cube", "data", "manual"], dflt: "auto", editType: "plot", impliedEdits: { "aspectratio.x": void 0, "aspectratio.y": void 0, "aspectratio.z": void 0 } }, aspectratio: { x: { valType: "number", min: 0, editType: "plot", impliedEdits: { "^aspectmode": "manual" } }, y: { valType: "number", min: 0, editType: "plot", impliedEdits: { "^aspectmode": "manual" } }, z: { valType: "number", min: 0, editType: "plot", impliedEdits: { "^aspectmode": "manual" } }, editType: "plot", impliedEdits: { aspectmode: "manual" } }, xaxis: BX, yaxis: BX, zaxis: BX, dragmode: { valType: "enumerated", values: ["orbit", "turntable", "zoom", "pan", false], editType: "plot" }, hovermode: { valType: "enumerated", values: ["closest", false], dflt: "closest", editType: "modebar" }, uirevision: { valType: "any", editType: "none" }, editType: "plot" };
+      });
+      var NIe = ye((Sgr, BIe) => {
+        var V8t = fd().mix, OIe = Dr(), G8t = vl(), H8t = qX(), j8t = PU(), W8t = f4(), qIe = ["xaxis", "yaxis", "zaxis"], X8t = 100 * 136 / 187;
+        BIe.exports = function(t, r, n) {
+          var i, a;
+          function o(u, c) {
+            return OIe.coerce(i, a, H8t, u, c);
+          }
+          for (var s = 0; s < qIe.length; s++) {
+            var l = qIe[s];
+            i = t[l] || {}, a = G8t.newContainer(r, l), a._id = l[0] + n.scene, a._name = l, j8t(i, a, o, n), W8t(i, a, o, { font: n.font, letter: l[0], data: n.data, showGrid: true, noAutotickangles: true, noMinorloglabels: true, noTicklabelindex: true, noTickson: true, noTicklabelmode: true, noTicklabelshift: true, noTicklabelstandoff: true, noTicklabelstep: true, noTicklabelposition: true, noTicklabeloverflow: true, noInsiderange: true, noUnifiedhovertitle: true, bgColor: n.bgColor, calendar: n.calendar }, n.fullLayout), o("gridcolor", V8t(a.color, n.bgColor, X8t).toRgbString()), o("title.text", l[0]), a.setScale = OIe.noop, o("showspikes") && (o("spikesides"), o("spikethickness"), o("spikecolor", a.color)), o("showaxeslabels"), o("showbackground") && o("backgroundcolor");
+          }
+        };
+      });
+      var HIe = ye((Mgr, GIe) => {
+        var Z8t = Dr(), Y8t = ka(), K8t = qa(), J8t = O_(), $8t = NIe(), UIe = VX(), Q8t = Id().getSubplotData, VIe = "gl3d";
+        GIe.exports = function(t, r, n) {
+          var i = r._basePlotModules.length > 1;
+          function a(o) {
+            if (!i) {
+              var s = Z8t.validate(t[o], UIe[o]);
+              if (s) return t[o];
+            }
+          }
+          J8t(t, r, n, { type: VIe, attributes: UIe, handleDefaults: eRt, fullLayout: r, font: r.font, fullData: n, getDfltFromLayout: a, autotypenumbersDflt: r.autotypenumbers, paper_bgcolor: r.paper_bgcolor, calendar: r.calendar });
+        };
+        function eRt(e, t, r, n) {
+          for (var i = r("bgcolor"), a = Y8t.combine(i, n.paper_bgcolor), o = ["up", "center", "eye"], s = 0; s < o.length; s++) r("camera." + o[s] + ".x"), r("camera." + o[s] + ".y"), r("camera." + o[s] + ".z");
+          r("camera.projection.type");
+          var l = !!r("aspectratio.x") && !!r("aspectratio.y") && !!r("aspectratio.z"), u = l ? "manual" : "auto", c = r("aspectmode", u);
+          l || (e.aspectratio = t.aspectratio = { x: 1, y: 1, z: 1 }, c === "manual" && (t.aspectmode = "auto"), e.aspectmode = t.aspectmode);
+          var f = Q8t(n.fullData, VIe, n.id);
+          $8t(e, t, { font: n.font, scene: n.id, data: f, bgColor: a, calendar: n.calendar, autotypenumbersDflt: n.autotypenumbersDflt, fullLayout: n.fullLayout }), K8t.getComponentMethod("annotations3d", "handleDefaults")(e, t, n);
+          var h = n.getDfltFromLayout("dragmode");
+          if (h !== false && !h) if (h = "orbit", e.camera && e.camera.up) {
+            var d = e.camera.up.x, v = e.camera.up.y, _ = e.camera.up.z;
+            _ !== 0 && (!d || !v || !_ || _ / Math.sqrt(d * d + v * v + _ * _) > 0.999) && (h = "turntable");
+          } else h = "turntable";
+          r("dragmode", h), r("hovermode", n.getDfltFromLayout("hovermode"));
+        }
+      });
+      var sx = ye((fp) => {
+        var tRt = mc().overrideAll, rRt = W1(), iRt = IIe(), nRt = Id().getSubplotData, aRt = Dr(), oRt = Wp(), XA = "gl3d", GX = "scene";
+        fp.name = XA;
+        fp.attr = GX;
+        fp.idRoot = GX;
+        fp.idRegex = fp.attrRegex = aRt.counterRegex("scene");
+        fp.attributes = DIe();
+        fp.layoutAttributes = VX();
+        fp.baseLayoutAttrOverrides = tRt({ hoverlabel: rRt.hoverlabel }, "plot", "nested");
+        fp.supplyLayoutDefaults = HIe();
+        fp.plot = function(t) {
+          for (var r = t._fullLayout, n = t._fullData, i = r._subplots[XA], a = 0; a < i.length; a++) {
+            var o = i[a], s = nRt(n, XA, o), l = r[o], u = l.camera, c = l._scene;
+            c || (c = new iRt({ id: o, graphDiv: t, container: t.querySelector(".gl-container"), staticPlot: t._context.staticPlot, plotGlPixelRatio: t._context.plotGlPixelRatio, camera: u }, r), l._scene = c), c.viewInitial || (c.viewInitial = { up: { x: u.up.x, y: u.up.y, z: u.up.z }, eye: { x: u.eye.x, y: u.eye.y, z: u.eye.z }, center: { x: u.center.x, y: u.center.y, z: u.center.z } }), c.plot(s, r, t.layout);
+          }
+        };
+        fp.clean = function(e, t, r, n) {
+          for (var i = n._subplots[XA] || [], a = 0; a < i.length; a++) {
+            var o = i[a];
+            !t[o] && n[o]._scene && (n[o]._scene.destroy(), n._infolayer && n._infolayer.selectAll(".annotation-" + o).remove());
+          }
+        };
+        fp.toSVG = function(e) {
+          for (var t = e._fullLayout, r = t._subplots[XA], n = t._size, i = 0; i < r.length; i++) {
+            var a = t[r[i]], o = a.domain, s = a._scene, l = s.toImage("png"), u = t._glimages.append("svg:image");
+            u.attr({ xmlns: oRt.svg, "xlink:href": l, x: n.l + n.w * o.x[0], y: n.t + n.h * (1 - o.y[1]), width: n.w * (o.x[1] - o.x[0]), height: n.h * (o.y[1] - o.y[0]), preserveAspectRatio: "none" }), s.destroy();
+          }
+        };
+        fp.cleanId = function(t) {
+          if (t.match(/^scene[0-9]*$/)) {
+            var r = t.slice(5);
+            return r === "1" && (r = ""), GX + r;
+          }
+        };
+        fp.updateFx = function(e) {
+          for (var t = e._fullLayout, r = t._subplots[XA], n = 0; n < r.length; n++) {
+            var i = t[r[n]]._scene;
+            i.updateFx(t.dragmode, t.hovermode);
+          }
+        };
+      });
+      var WIe = ye((kgr, jIe) => {
+        jIe.exports = { plot: tIe(), attributes: DX(), markerSymbols: iF(), supplyDefaults: lIe(), colorbar: [{ container: "marker", min: "cmin", max: "cmax" }, { container: "line", min: "cmin", max: "cmax" }], calc: cIe(), moduleType: "trace", name: "scatter3d", basePlotModule: sx(), categories: ["gl3d", "symbols", "showLegend", "scatter-like"], meta: {} };
+      });
+      var ZIe = ye((Cgr, XIe) => {
+        XIe.exports = WIe();
+      });
+      var ak = ye((Lgr, JIe) => {
+        var YIe = ka(), sRt = Tu(), HX = df().axisHoverFormat, { hovertemplateAttrs: lRt, templatefallbackAttrs: uRt } = Ll(), KIe = Gl(), jX = Ao().extendFlat, cRt = mc().overrideAll;
+        function WX(e) {
+          return { valType: "boolean", dflt: false };
+        }
+        function XX(e) {
+          return { show: { valType: "boolean", dflt: false }, start: { valType: "number", dflt: null, editType: "plot" }, end: { valType: "number", dflt: null, editType: "plot" }, size: { valType: "number", dflt: null, min: 0, editType: "plot" }, project: { x: WX(), y: WX(), z: WX() }, color: { valType: "color", dflt: YIe.defaultLine }, usecolormap: { valType: "boolean", dflt: false }, width: { valType: "number", min: 1, max: 16, dflt: 2 }, highlight: { valType: "boolean", dflt: true }, highlightcolor: { valType: "color", dflt: YIe.defaultLine }, highlightwidth: { valType: "number", min: 1, max: 16, dflt: 2 } };
+        }
+        var ZX = JIe.exports = cRt(jX({ z: { valType: "data_array" }, x: { valType: "data_array" }, y: { valType: "data_array" }, text: { valType: "string", dflt: "", arrayOk: true }, hovertext: { valType: "string", dflt: "", arrayOk: true }, hovertemplate: lRt(), hovertemplatefallback: uRt(), xhoverformat: HX("x"), yhoverformat: HX("y"), zhoverformat: HX("z"), connectgaps: { valType: "boolean", dflt: false, editType: "calc" }, surfacecolor: { valType: "data_array" } }, sRt("", { colorAttr: "z or surfacecolor", showScaleDflt: true, autoColorDflt: false, editTypeOverride: "calc" }), { contours: { x: XX(), y: XX(), z: XX() }, hidesurface: { valType: "boolean", dflt: false }, lightposition: { x: { valType: "number", min: -1e5, max: 1e5, dflt: 10 }, y: { valType: "number", min: -1e5, max: 1e5, dflt: 1e4 }, z: { valType: "number", min: -1e5, max: 1e5, dflt: 0 } }, lighting: { ambient: { valType: "number", min: 0, max: 1, dflt: 0.8 }, diffuse: { valType: "number", min: 0, max: 1, dflt: 0.8 }, specular: { valType: "number", min: 0, max: 2, dflt: 0.05, description: "Represents the level that incident rays are reflected in a single direction, causing shine." }, roughness: { valType: "number", min: 0, max: 1, dflt: 0.5, description: "Alters specular reflection; the rougher the surface, the wider and less contrasty the shine." }, fresnel: { valType: "number", min: 0, max: 5, dflt: 0.2 } }, opacity: { valType: "number", min: 0, max: 1, dflt: 1 }, opacityscale: { valType: "any", editType: "calc" }, hoverinfo: jX({}, KIe.hoverinfo), showlegend: jX({}, KIe.showlegend, { dflt: false }) }), "calc", "nested");
+        ZX.x.editType = ZX.y.editType = ZX.z.editType = "calc+clearAxisTypes";
+      });
+      var KX = ye((Pgr, e8e) => {
+        var fRt = qa(), $Ie = Dr(), hRt = td(), dRt = ak(), YX = 0.1;
+        function vRt(e, t) {
+          for (var r = [], n = 32, i = 0; i < n; i++) {
+            var a = i / (n - 1), o = t + (1 - t) * (1 - Math.pow(Math.sin(e * a * Math.PI), 2));
+            r.push([a, Math.max(0, Math.min(1, o))]);
+          }
+          return r;
+        }
+        function pRt(e) {
+          var t = 0;
+          if (!Array.isArray(e) || e.length < 2 || !e[0] || !e[e.length - 1] || +e[0][0] != 0 || +e[e.length - 1][0] != 1) return false;
+          for (var r = 0; r < e.length; r++) {
+            var n = e[r];
+            if (n.length !== 2 || +n[0] < t) return false;
+            t = +n[0];
+          }
+          return true;
+        }
+        function gRt(e, t, r, n) {
+          var i, a;
+          function o(b, p) {
+            return $Ie.coerce(e, t, dRt, b, p);
+          }
+          var s = o("x"), l = o("y"), u = o("z");
+          if (!u || !u.length || s && s.length < 1 || l && l.length < 1) {
+            t.visible = false;
+            return;
+          }
+          t._xlength = Array.isArray(s) && $Ie.isArrayOrTypedArray(s[0]) ? u.length : u[0].length, t._ylength = u.length;
+          var c = fRt.getComponentMethod("calendars", "handleTraceDefaults");
+          c(e, t, ["x", "y", "z"], n), o("text"), o("hovertext"), o("hovertemplate"), o("hovertemplatefallback"), o("xhoverformat"), o("yhoverformat"), o("zhoverformat"), ["lighting.ambient", "lighting.diffuse", "lighting.specular", "lighting.roughness", "lighting.fresnel", "lightposition.x", "lightposition.y", "lightposition.z", "hidesurface", "connectgaps", "opacity"].forEach(function(b) {
+            o(b);
+          });
+          o("surfacecolor");
+          var h = ["x", "y", "z"];
+          for (i = 0; i < 3; ++i) {
+            var d = "contours." + h[i], v = o(d + ".show"), _ = o(d + ".highlight");
+            if (v || _) for (a = 0; a < 3; ++a) o(d + ".project." + h[a]);
+            v && (o(d + ".color"), o(d + ".width"), o(d + ".usecolormap")), _ && (o(d + ".highlightcolor"), o(d + ".highlightwidth")), o(d + ".start"), o(d + ".end"), o(d + ".size");
+          }
+          hRt(e, t, n, o, { prefix: "", cLetter: "c" }), QIe(e, t, n, o), t._length = null;
+        }
+        function QIe(e, t, r, n) {
+          var i = n("opacityscale");
+          i === "max" ? t.opacityscale = [[0, YX], [1, 1]] : i === "min" ? t.opacityscale = [[0, 1], [1, YX]] : i === "extremes" ? t.opacityscale = vRt(1, YX) : pRt(i) || (t.opacityscale = void 0);
+        }
+        e8e.exports = { supplyDefaults: gRt, opacityscaleDefaults: QIe };
+      });
+      var i8e = ye((Igr, r8e) => {
+        var t8e = gv();
+        r8e.exports = function(t, r) {
+          r.surfacecolor ? t8e(t, r, { vals: r.surfacecolor, containerStr: "", cLetter: "c" }) : t8e(t, r, { vals: r.z, containerStr: "", cLetter: "c" });
+        };
+      });
+      var u8e = ye((Rgr, l8e) => {
+        var mRt = zd().gl_surface3d, ZA = zd().ndarray, yRt = zd().ndarray_linear_interpolate.d2, _Rt = c8(), xRt = f8(), ok = Dr().isArrayOrTypedArray, bRt = a1().parseColorScale, n8e = n1(), wRt = tc().extractOpts;
+        function o8e(e, t, r) {
+          this.scene = e, this.uid = r, this.surface = t, this.data = null, this.showContour = [false, false, false], this.contourStart = [null, null, null], this.contourEnd = [null, null, null], this.contourSize = [0, 0, 0], this.minValues = [1 / 0, 1 / 0, 1 / 0], this.maxValues = [-1 / 0, -1 / 0, -1 / 0], this.dataScaleX = 1, this.dataScaleY = 1, this.refineData = true, this.objectOffset = [0, 0, 0];
+        }
+        var em = o8e.prototype;
+        em.getXat = function(e, t, r, n) {
+          var i = ok(this.data.x) ? ok(this.data.x[0]) ? this.data.x[t][e] : this.data.x[e] : e;
+          return r === void 0 ? i : n.d2l(i, 0, r);
+        };
+        em.getYat = function(e, t, r, n) {
+          var i = ok(this.data.y) ? ok(this.data.y[0]) ? this.data.y[t][e] : this.data.y[t] : t;
+          return r === void 0 ? i : n.d2l(i, 0, r);
+        };
+        em.getZat = function(e, t, r, n) {
+          var i = this.data.z[t][e];
+          return i === null && this.data.connectgaps && this.data._interpolatedZ && (i = this.data._interpolatedZ[t][e]), r === void 0 ? i : n.d2l(i, 0, r);
+        };
+        em.handlePick = function(e) {
+          if (e.object === this.surface) {
+            var t = (e.data.index[0] - 1) / this.dataScaleX - 1, r = (e.data.index[1] - 1) / this.dataScaleY - 1, n = Math.max(Math.min(Math.round(t), this.data.z[0].length - 1), 0), i = Math.max(Math.min(Math.round(r), this.data._ylength - 1), 0);
+            e.index = [n, i], e.traceCoordinate = [this.getXat(n, i), this.getYat(n, i), this.getZat(n, i)], e.dataCoordinate = [this.getXat(n, i, this.data.xcalendar, this.scene.fullSceneLayout.xaxis), this.getYat(n, i, this.data.ycalendar, this.scene.fullSceneLayout.yaxis), this.getZat(n, i, this.data.zcalendar, this.scene.fullSceneLayout.zaxis)];
+            for (var a = 0; a < 3; a++) {
+              var o = e.dataCoordinate[a];
+              o != null && (e.dataCoordinate[a] *= this.scene.dataScale[a]);
+            }
+            var s = this.data.hovertext || this.data.text;
+            return ok(s) && s[i] && s[i][n] !== void 0 ? e.textLabel = s[i][n] : s ? e.textLabel = s : e.textLabel = "", e.data.dataCoordinate = e.dataCoordinate.slice(), this.surface.highlight(e.data), this.scene.glplot.spikes.position = e.dataCoordinate, true;
+          }
+        };
+        function TRt(e) {
+          var t = e[0].rgb, r = e[e.length - 1].rgb;
+          return t[0] === r[0] && t[1] === r[1] && t[2] === r[2] && t[3] === r[3];
+        }
+        var YA = [2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37, 41, 43, 47, 53, 59, 61, 67, 71, 73, 79, 83, 89, 97, 101, 103, 107, 109, 113, 127, 131, 137, 139, 149, 151, 157, 163, 167, 173, 179, 181, 191, 193, 197, 199, 211, 223, 227, 229, 233, 239, 241, 251, 257, 263, 269, 271, 277, 281, 283, 293, 307, 311, 313, 317, 331, 337, 347, 349, 353, 359, 367, 373, 379, 383, 389, 397, 401, 409, 419, 421, 431, 433, 439, 443, 449, 457, 461, 463, 467, 479, 487, 491, 499, 503, 509, 521, 523, 541, 547, 557, 563, 569, 571, 577, 587, 593, 599, 601, 607, 613, 617, 619, 631, 641, 643, 647, 653, 659, 661, 673, 677, 683, 691, 701, 709, 719, 727, 733, 739, 743, 751, 757, 761, 769, 773, 787, 797, 809, 811, 821, 823, 827, 829, 839, 853, 857, 859, 863, 877, 881, 883, 887, 907, 911, 919, 929, 937, 941, 947, 953, 967, 971, 977, 983, 991, 997, 1009, 1013, 1019, 1021, 1031, 1033, 1039, 1049, 1051, 1061, 1063, 1069, 1087, 1091, 1093, 1097, 1103, 1109, 1117, 1123, 1129, 1151, 1153, 1163, 1171, 1181, 1187, 1193, 1201, 1213, 1217, 1223, 1229, 1231, 1237, 1249, 1259, 1277, 1279, 1283, 1289, 1291, 1297, 1301, 1303, 1307, 1319, 1321, 1327, 1361, 1367, 1373, 1381, 1399, 1409, 1423, 1427, 1429, 1433, 1439, 1447, 1451, 1453, 1459, 1471, 1481, 1483, 1487, 1489, 1493, 1499, 1511, 1523, 1531, 1543, 1549, 1553, 1559, 1567, 1571, 1579, 1583, 1597, 1601, 1607, 1609, 1613, 1619, 1621, 1627, 1637, 1657, 1663, 1667, 1669, 1693, 1697, 1699, 1709, 1721, 1723, 1733, 1741, 1747, 1753, 1759, 1777, 1783, 1787, 1789, 1801, 1811, 1823, 1831, 1847, 1861, 1867, 1871, 1873, 1877, 1879, 1889, 1901, 1907, 1913, 1931, 1933, 1949, 1951, 1973, 1979, 1987, 1993, 1997, 1999, 2003, 2011, 2017, 2027, 2029, 2039, 2053, 2063, 2069, 2081, 2083, 2087, 2089, 2099, 2111, 2113, 2129, 2131, 2137, 2141, 2143, 2153, 2161, 2179, 2203, 2207, 2213, 2221, 2237, 2239, 2243, 2251, 2267, 2269, 2273, 2281, 2287, 2293, 2297, 2309, 2311, 2333, 2339, 2341, 2347, 2351, 2357, 2371, 2377, 2381, 2383, 2389, 2393, 2399, 2411, 2417, 2423, 2437, 2441, 2447, 2459, 2467, 2473, 2477, 2503, 2521, 2531, 2539, 2543, 2549, 2551, 2557, 2579, 2591, 2593, 2609, 2617, 2621, 2633, 2647, 2657, 2659, 2663, 2671, 2677, 2683, 2687, 2689, 2693, 2699, 2707, 2711, 2713, 2719, 2729, 2731, 2741, 2749, 2753, 2767, 2777, 2789, 2791, 2797, 2801, 2803, 2819, 2833, 2837, 2843, 2851, 2857, 2861, 2879, 2887, 2897, 2903, 2909, 2917, 2927, 2939, 2953, 2957, 2963, 2969, 2971, 2999];
+        function ARt(e, t) {
+          if (e < t) return 0;
+          for (var r = 0; Math.floor(e % t) === 0; ) e /= t, r++;
+          return r;
+        }
+        function JX(e) {
+          for (var t = [], r = 0; r < YA.length; r++) {
+            var n = YA[r];
+            t.push(ARt(e, n));
+          }
+          return t;
+        }
+        function SRt(e) {
+          for (var t = JX(e), r = e, n = 0; n < YA.length; n++) if (t[n] > 0) {
+            r = YA[n];
+            break;
+          }
+          return r;
+        }
+        function MRt(e, t) {
+          if (!(e < 1 || t < 1)) {
+            for (var r = JX(e), n = JX(t), i = 1, a = 0; a < YA.length; a++) i *= Math.pow(YA[a], Math.max(r[a], n[a]));
+            return i;
+          }
+        }
+        function ERt(e) {
+          if (e.length !== 0) {
+            for (var t = 1, r = 0; r < e.length; r++) t = MRt(t, e[r]);
+            return t;
+          }
+        }
+        em.calcXnums = function(e) {
+          var t, r = [];
+          for (t = 1; t < e; t++) {
+            var n = this.getXat(t - 1, 0), i = this.getXat(t, 0);
+            i !== n && n !== void 0 && n !== null && i !== void 0 && i !== null ? r[t - 1] = Math.abs(i - n) : r[t - 1] = 0;
+          }
+          var a = 0;
+          for (t = 1; t < e; t++) a += r[t - 1];
+          for (t = 1; t < e; t++) r[t - 1] === 0 ? r[t - 1] = 1 : r[t - 1] = Math.round(a / r[t - 1]);
+          return r;
+        };
+        em.calcYnums = function(e) {
+          var t, r = [];
+          for (t = 1; t < e; t++) {
+            var n = this.getYat(0, t - 1), i = this.getYat(0, t);
+            i !== n && n !== void 0 && n !== null && i !== void 0 && i !== null ? r[t - 1] = Math.abs(i - n) : r[t - 1] = 0;
+          }
+          var a = 0;
+          for (t = 1; t < e; t++) a += r[t - 1];
+          for (t = 1; t < e; t++) r[t - 1] === 0 ? r[t - 1] = 1 : r[t - 1] = Math.round(a / r[t - 1]);
+          return r;
+        };
+        var s8e = [1, 2, 4, 6, 12, 24, 36, 48, 60, 120, 180, 240, 360, 720, 840, 1260], a8e = s8e[9], uF = s8e[13];
+        em.estimateScale = function(e, t) {
+          for (var r = t === 0 ? this.calcXnums(e) : this.calcYnums(e), n = 1 + ERt(r); n < a8e; ) n *= 2;
+          for (; n > uF; ) n--, n /= SRt(n), n++, n < a8e && (n = uF);
+          var i = Math.round(n / e);
+          return i > 1 ? i : 1;
+        };
+        function kRt(e, t, r) {
+          var n = r[8] + r[2] * t[0] + r[5] * t[1];
+          return e[0] = (r[6] + r[0] * t[0] + r[3] * t[1]) / n, e[1] = (r[7] + r[1] * t[0] + r[4] * t[1]) / n, e;
+        }
+        function CRt(e, t, r) {
+          return LRt(e, t, kRt, r), e;
+        }
+        function LRt(e, t, r, n) {
+          for (var i = [0, 0], a = e.shape[0], o = e.shape[1], s = 0; s < a; s++) for (var l = 0; l < o; l++) r(i, [s, l], n), e.set(s, l, yRt(t, i[0], i[1]));
+          return e;
+        }
+        em.refineCoords = function(e) {
+          for (var t = this.dataScaleX, r = this.dataScaleY, n = e[0].shape[0], i = e[0].shape[1], a = Math.floor(e[0].shape[0] * t + 1) | 0, o = Math.floor(e[0].shape[1] * r + 1) | 0, s = 1 + n + 1, l = 1 + i + 1, u = ZA(new Float32Array(s * l), [s, l]), c = [1 / t, 0, 0, 0, 1 / r, 0, 0, 0, 1], f = 0; f < e.length; ++f) {
+            this.surface.padField(u, e[f]);
+            var h = ZA(new Float32Array(a * o), [a, o]);
+            CRt(h, u, c), e[f] = h;
+          }
+        };
+        function PRt(e, t) {
+          for (var r = false, n = 0; n < e.length; n++) if (t === e[n]) {
+            r = true;
+            break;
+          }
+          r === false && e.push(t);
+        }
+        em.setContourLevels = function() {
+          var e = [[], [], []], t = [false, false, false], r = false, n, i, a;
+          for (n = 0; n < 3; ++n) if (this.showContour[n] && (r = true, this.contourSize[n] > 0 && this.contourStart[n] !== null && this.contourEnd[n] !== null && this.contourEnd[n] > this.contourStart[n])) for (t[n] = true, i = this.contourStart[n]; i < this.contourEnd[n]; i += this.contourSize[n]) a = i * this.scene.dataScale[n], PRt(e[n], a);
+          if (r) {
+            var o = [[], [], []];
+            for (n = 0; n < 3; ++n) this.showContour[n] && (o[n] = t[n] ? e[n] : this.scene.contourLevels[n]);
+            this.surface.update({ levels: o });
+          }
+        };
+        em.update = function(e) {
+          var t = this.scene, r = t.fullSceneLayout, n = this.surface, i = bRt(e), a = t.dataScale, o = e.z[0].length, s = e._ylength, l = t.contourLevels;
+          this.data = e;
+          var u, c, f, h, d = [];
+          for (u = 0; u < 3; u++) for (d[u] = [], c = 0; c < o; c++) d[u][c] = [];
+          for (c = 0; c < o; c++) for (f = 0; f < s; f++) d[0][c][f] = this.getXat(c, f, e.xcalendar, r.xaxis), d[1][c][f] = this.getYat(c, f, e.ycalendar, r.yaxis), d[2][c][f] = this.getZat(c, f, e.zcalendar, r.zaxis);
+          if (e.connectgaps) for (e._emptypoints = xRt(d[2]), _Rt(d[2], e._emptypoints), e._interpolatedZ = [], c = 0; c < o; c++) for (e._interpolatedZ[c] = [], f = 0; f < s; f++) e._interpolatedZ[c][f] = d[2][c][f];
+          for (u = 0; u < 3; u++) for (c = 0; c < o; c++) for (f = 0; f < s; f++) h = d[u][c][f], h == null ? d[u][c][f] = NaN : h = d[u][c][f] *= a[u];
+          for (u = 0; u < 3; u++) for (c = 0; c < o; c++) for (f = 0; f < s; f++) h = d[u][c][f], h != null && (this.minValues[u] > h && (this.minValues[u] = h), this.maxValues[u] < h && (this.maxValues[u] = h));
+          for (u = 0; u < 3; u++) this.objectOffset[u] = 0.5 * (this.minValues[u] + this.maxValues[u]);
+          for (u = 0; u < 3; u++) for (c = 0; c < o; c++) for (f = 0; f < s; f++) h = d[u][c][f], h != null && (d[u][c][f] -= this.objectOffset[u]);
+          var v = [ZA(new Float32Array(o * s), [o, s]), ZA(new Float32Array(o * s), [o, s]), ZA(new Float32Array(o * s), [o, s])];
+          for (u = 0; u < 3; u++) for (c = 0; c < o; c++) for (f = 0; f < s; f++) v[u].set(c, f, d[u][c][f]);
+          d = [];
+          var _ = { colormap: i, levels: [[], [], []], showContour: [true, true, true], showSurface: !e.hidesurface, contourProject: [[false, false, false], [false, false, false], [false, false, false]], contourWidth: [1, 1, 1], contourColor: [[1, 1, 1, 1], [1, 1, 1, 1], [1, 1, 1, 1]], contourTint: [1, 1, 1], dynamicColor: [[1, 1, 1, 1], [1, 1, 1, 1], [1, 1, 1, 1]], dynamicWidth: [1, 1, 1], dynamicTint: [1, 1, 1], opacityscale: e.opacityscale, opacity: e.opacity }, b = wRt(e);
+          if (_.intensityBounds = [b.min, b.max], e.surfacecolor) {
+            var p = ZA(new Float32Array(o * s), [o, s]);
+            for (c = 0; c < o; c++) for (f = 0; f < s; f++) p.set(c, f, e.surfacecolor[f][c]);
+            v.push(p);
+          } else _.intensityBounds[0] *= a[2], _.intensityBounds[1] *= a[2];
+          (uF < v[0].shape[0] || uF < v[0].shape[1]) && (this.refineData = false), this.refineData === true && (this.dataScaleX = this.estimateScale(v[0].shape[0], 0), this.dataScaleY = this.estimateScale(v[0].shape[1], 1), (this.dataScaleX !== 1 || this.dataScaleY !== 1) && this.refineCoords(v)), e.surfacecolor && (_.intensity = v.pop());
+          var k = [true, true, true], E = ["x", "y", "z"];
+          for (u = 0; u < 3; ++u) {
+            var T = e.contours[E[u]];
+            k[u] = T.highlight, _.showContour[u] = T.show || T.highlight, _.showContour[u] && (_.contourProject[u] = [T.project.x, T.project.y, T.project.z], T.show ? (this.showContour[u] = true, _.levels[u] = l[u], n.highlightColor[u] = _.contourColor[u] = n8e(T.color), T.usecolormap ? n.highlightTint[u] = _.contourTint[u] = 0 : n.highlightTint[u] = _.contourTint[u] = 1, _.contourWidth[u] = T.width, this.contourStart[u] = T.start, this.contourEnd[u] = T.end, this.contourSize[u] = T.size) : (this.showContour[u] = false, this.contourStart[u] = null, this.contourEnd[u] = null, this.contourSize[u] = 0), T.highlight && (_.dynamicColor[u] = n8e(T.highlightcolor), _.dynamicWidth[u] = T.highlightwidth));
+          }
+          TRt(i) && (_.vertexColor = true), _.objectOffset = this.objectOffset, _.coords = v, n.update(_), n.visible = e.visible, n.enableDynamic = k, n.enableHighlight = k, n.snapToData = true, "lighting" in e && (n.ambientLight = e.lighting.ambient, n.diffuseLight = e.lighting.diffuse, n.specularLight = e.lighting.specular, n.roughness = e.lighting.roughness, n.fresnel = e.lighting.fresnel), "lightposition" in e && (n.lightPosition = [e.lightposition.x, e.lightposition.y, e.lightposition.z]);
+        };
+        em.dispose = function() {
+          this.scene.glplot.remove(this.surface), this.surface.dispose();
+        };
+        function IRt(e, t) {
+          var r = e.glplot.gl, n = mRt({ gl: r }), i = new o8e(e, n, t.uid);
+          return n._trace = i, i.update(t), e.glplot.add(n), i;
+        }
+        l8e.exports = IRt;
+      });
+      var f8e = ye((Dgr, c8e) => {
+        c8e.exports = { attributes: ak(), supplyDefaults: KX().supplyDefaults, colorbar: { min: "cmin", max: "cmax" }, calc: i8e(), plot: u8e(), moduleType: "trace", name: "surface", basePlotModule: sx(), categories: ["gl3d", "2dMap", "showLegend"], meta: {} };
+      });
+      var d8e = ye((Fgr, h8e) => {
+        h8e.exports = f8e();
+      });
+      var KA = ye((zgr, p8e) => {
+        var RRt = Tu(), $X = df().axisHoverFormat, { hovertemplateAttrs: DRt, templatefallbackAttrs: FRt } = Ll(), lx = ak(), v8e = Gl(), ux = Ao().extendFlat;
+        p8e.exports = ux({ x: { valType: "data_array", editType: "calc+clearAxisTypes" }, y: { valType: "data_array", editType: "calc+clearAxisTypes" }, z: { valType: "data_array", editType: "calc+clearAxisTypes" }, i: { valType: "data_array", editType: "calc" }, j: { valType: "data_array", editType: "calc" }, k: { valType: "data_array", editType: "calc" }, text: { valType: "string", dflt: "", arrayOk: true, editType: "calc" }, hovertext: { valType: "string", dflt: "", arrayOk: true, editType: "calc" }, hovertemplate: DRt({ editType: "calc" }), hovertemplatefallback: FRt({ editType: "calc" }), xhoverformat: $X("x"), yhoverformat: $X("y"), zhoverformat: $X("z"), delaunayaxis: { valType: "enumerated", values: ["x", "y", "z"], dflt: "z", editType: "calc" }, alphahull: { valType: "number", dflt: -1, editType: "calc" }, intensity: { valType: "data_array", editType: "calc" }, intensitymode: { valType: "enumerated", values: ["vertex", "cell"], dflt: "vertex", editType: "calc" }, color: { valType: "color", editType: "calc" }, vertexcolor: { valType: "data_array", editType: "calc" }, facecolor: { valType: "data_array", editType: "calc" } }, RRt("", { colorAttr: "`intensity`", showScaleDflt: true, editTypeOverride: "calc" }), { opacity: lx.opacity, flatshading: { valType: "boolean", dflt: false, editType: "calc" }, contour: { show: ux({}, lx.contours.x.show, {}), color: lx.contours.x.color, width: lx.contours.x.width, editType: "calc" }, lightposition: { x: ux({}, lx.lightposition.x, { dflt: 1e5 }), y: ux({}, lx.lightposition.y, { dflt: 1e5 }), z: ux({}, lx.lightposition.z, { dflt: 0 }), editType: "calc" }, lighting: ux({ vertexnormalsepsilon: { valType: "number", min: 0, max: 1, dflt: 1e-12, editType: "calc", description: "Epsilon for vertex normals calculation avoids math issues arising from degenerate geometry." }, facenormalsepsilon: { valType: "number", min: 0, max: 1, dflt: 1e-6, editType: "calc", description: "Epsilon for face normals calculation avoids math issues arising from degenerate geometry." }, editType: "calc" }, lx.lighting), hoverinfo: ux({}, v8e.hoverinfo, { editType: "calc" }), showlegend: ux({}, v8e.showlegend, { dflt: false }) });
+      });
+      var fF = ye((Ogr, m8e) => {
+        var zRt = Tu(), cF = df().axisHoverFormat, { hovertemplateAttrs: ORt, templatefallbackAttrs: qRt } = Ll(), sk = KA(), g8e = Gl(), QX = Ao().extendFlat, BRt = mc().overrideAll;
+        function eZ(e) {
+          return { show: { valType: "boolean", dflt: false }, locations: { valType: "data_array", dflt: [] }, fill: { valType: "number", min: 0, max: 1, dflt: 1 } };
+        }
+        function tZ(e) {
+          return { show: { valType: "boolean", dflt: true }, fill: { valType: "number", min: 0, max: 1, dflt: 1 } };
+        }
+        var JA = m8e.exports = BRt(QX({ x: { valType: "data_array" }, y: { valType: "data_array" }, z: { valType: "data_array" }, value: { valType: "data_array" }, isomin: { valType: "number" }, isomax: { valType: "number" }, surface: { show: { valType: "boolean", dflt: true }, count: { valType: "integer", dflt: 2, min: 1 }, fill: { valType: "number", min: 0, max: 1, dflt: 1 }, pattern: { valType: "flaglist", flags: ["A", "B", "C", "D", "E"], extras: ["all", "odd", "even"], dflt: "all" } }, spaceframe: { show: { valType: "boolean", dflt: false }, fill: { valType: "number", min: 0, max: 1, dflt: 0.15 } }, slices: { x: eZ(), y: eZ(), z: eZ() }, caps: { x: tZ(), y: tZ(), z: tZ() }, text: { valType: "string", dflt: "", arrayOk: true }, hovertext: { valType: "string", dflt: "", arrayOk: true }, hovertemplate: ORt(), hovertemplatefallback: qRt(), xhoverformat: cF("x"), yhoverformat: cF("y"), zhoverformat: cF("z"), valuehoverformat: cF("value", 1), showlegend: QX({}, g8e.showlegend, { dflt: false }) }, zRt("", { colorAttr: "`value`", showScaleDflt: true, editTypeOverride: "calc" }), { opacity: sk.opacity, lightposition: sk.lightposition, lighting: sk.lighting, flatshading: sk.flatshading, contour: sk.contour, hoverinfo: QX({}, g8e.hoverinfo) }), "calc", "nested");
+        JA.flatshading.dflt = true;
+        JA.lighting.facenormalsepsilon.dflt = 0;
+        JA.x.editType = JA.y.editType = JA.z.editType = JA.value.editType = "calc+clearAxisTypes";
+      });
+      var rZ = ye((qgr, _8e) => {
+        var NRt = Dr(), URt = qa(), VRt = fF(), GRt = td();
+        function HRt(e, t, r, n) {
+          function i(a, o) {
+            return NRt.coerce(e, t, VRt, a, o);
+          }
+          y8e(e, t, r, n, i);
+        }
+        function y8e(e, t, r, n, i) {
+          var a = i("isomin"), o = i("isomax");
+          o != null && a !== void 0 && a !== null && a > o && (t.isomin = null, t.isomax = null);
+          var s = i("x"), l = i("y"), u = i("z"), c = i("value");
+          if (!s || !s.length || !l || !l.length || !u || !u.length || !c || !c.length) {
+            t.visible = false;
+            return;
+          }
+          var f = URt.getComponentMethod("calendars", "handleTraceDefaults");
+          f(e, t, ["x", "y", "z"], n), i("valuehoverformat"), ["x", "y", "z"].forEach(function(_) {
+            i(_ + "hoverformat");
+            var b = "caps." + _, p = i(b + ".show");
+            p && i(b + ".fill");
+            var k = "slices." + _, E = i(k + ".show");
+            E && (i(k + ".fill"), i(k + ".locations"));
+          });
+          var h = i("spaceframe.show");
+          h && i("spaceframe.fill");
+          var d = i("surface.show");
+          d && (i("surface.count"), i("surface.fill"), i("surface.pattern"));
+          var v = i("contour.show");
+          v && (i("contour.color"), i("contour.width")), ["text", "hovertext", "hovertemplate", "lighting.ambient", "lighting.diffuse", "lighting.specular", "lighting.roughness", "lighting.fresnel", "lighting.vertexnormalsepsilon", "lighting.facenormalsepsilon", "lightposition.x", "lightposition.y", "lightposition.z", "flatshading", "opacity"].forEach(function(_) {
+            i(_);
+          }), GRt(e, t, n, i, { prefix: "", cLetter: "c" }), t._length = null;
+        }
+        _8e.exports = { supplyDefaults: HRt, supplyIsoDefaults: y8e };
+      });
+      var hF = ye((Bgr, b8e) => {
+        var nZ = Dr(), jRt = gv();
+        function WRt(e, t) {
+          t._len = Math.min(t.u.length, t.v.length, t.w.length, t.x.length, t.y.length, t.z.length), t._u = Jm(t.u, t._len), t._v = Jm(t.v, t._len), t._w = Jm(t.w, t._len), t._x = Jm(t.x, t._len), t._y = Jm(t.y, t._len), t._z = Jm(t.z, t._len);
+          var r = x8e(t);
+          t._gridFill = r.fill, t._Xs = r.Xs, t._Ys = r.Ys, t._Zs = r.Zs, t._len = r.len;
+          var n = 0, i, a, o;
+          t.starts && (i = Jm(t.starts.x || []), a = Jm(t.starts.y || []), o = Jm(t.starts.z || []), n = Math.min(i.length, a.length, o.length)), t._startsX = i || [], t._startsY = a || [], t._startsZ = o || [];
+          var s = 0, l = 1 / 0, u;
+          for (u = 0; u < t._len; u++) {
+            var c = t._u[u], f = t._v[u], h = t._w[u], d = Math.sqrt(c * c + f * f + h * h);
+            s = Math.max(s, d), l = Math.min(l, d);
+          }
+          for (jRt(e, t, { vals: [l, s], containerStr: "", cLetter: "c" }), u = 0; u < n; u++) {
+            var v = i[u];
+            r.xMax = Math.max(r.xMax, v), r.xMin = Math.min(r.xMin, v);
+            var _ = a[u];
+            r.yMax = Math.max(r.yMax, _), r.yMin = Math.min(r.yMin, _);
+            var b = o[u];
+            r.zMax = Math.max(r.zMax, b), r.zMin = Math.min(r.zMin, b);
+          }
+          t._slen = n, t._normMax = s, t._xbnds = [r.xMin, r.xMax], t._ybnds = [r.yMin, r.yMax], t._zbnds = [r.zMin, r.zMax];
+        }
+        function x8e(e) {
+          var t = e._x, r = e._y, n = e._z, i = e._len, a, o, s, l = -1 / 0, u = 1 / 0, c = -1 / 0, f = 1 / 0, h = -1 / 0, d = 1 / 0, v = "", _, b, p, k, E, T, L, x, C;
+          for (i && (k = t[0], T = r[0], x = n[0]), i > 1 && (E = t[i - 1], L = r[i - 1], C = n[i - 1]), a = 0; a < i; a++) l = Math.max(l, t[a]), u = Math.min(u, t[a]), c = Math.max(c, r[a]), f = Math.min(f, r[a]), h = Math.max(h, n[a]), d = Math.min(d, n[a]), !_ && t[a] !== k && (_ = true, v += "x"), !b && r[a] !== T && (b = true, v += "y"), !p && n[a] !== x && (p = true, v += "z");
+          _ || (v += "x"), b || (v += "y"), p || (v += "z");
+          var M = iZ(e._x), g = iZ(e._y), P = iZ(e._z);
+          v = v.replace("x", (k > E ? "-" : "+") + "x"), v = v.replace("y", (T > L ? "-" : "+") + "y"), v = v.replace("z", (x > C ? "-" : "+") + "z");
+          var A = function() {
+            i = 0, M = [], g = [], P = [];
+          };
+          (!i || i < M.length * g.length * P.length) && A();
+          var z = function(Be) {
+            return Be === "x" ? t : Be === "y" ? r : n;
+          }, O = function(Be) {
+            return Be === "x" ? M : Be === "y" ? g : P;
+          }, U = function(Be) {
+            return Be[i - 1] < Be[0] ? -1 : 1;
+          }, G = z(v[1]), Z = z(v[3]), j = z(v[5]), N = O(v[1]).length, H = O(v[3]).length, re = O(v[5]).length, oe = false, _e = function(Be, Pe, me) {
+            return N * (H * Be + Pe) + me;
+          }, Ce = U(z(v[1])), Le = U(z(v[3])), ge = U(z(v[5]));
+          for (a = 0; a < re - 1; a++) {
+            for (o = 0; o < H - 1; o++) {
+              for (s = 0; s < N - 1; s++) {
+                var ie = _e(a, o, s), Se = _e(a, o, s + 1), Ee = _e(a, o + 1, s), Ae = _e(a + 1, o, s);
+                if ((!(G[ie] * Ce < G[Se] * Ce) || !(Z[ie] * Le < Z[Ee] * Le) || !(j[ie] * ge < j[Ae] * ge)) && (oe = true), oe) break;
+              }
+              if (oe) break;
+            }
+            if (oe) break;
+          }
+          return oe && (nZ.warn("Encountered arbitrary coordinates! Unable to input data grid."), A()), { xMin: u, yMin: f, zMin: d, xMax: l, yMax: c, zMax: h, Xs: M, Ys: g, Zs: P, len: i, fill: v };
+        }
+        function iZ(e) {
+          return nZ.distinctVals(e).vals;
+        }
+        function Jm(e, t) {
+          if (t === void 0 && (t = e.length), nZ.isTypedArray(e)) return e.subarray(0, t);
+          for (var r = [], n = 0; n < t; n++) r[n] = +e[n];
+          return r;
+        }
+        b8e.exports = { calc: WRt, filter: Jm, processGrid: x8e };
+      });
+      var aZ = ye((Ngr, w8e) => {
+        var XRt = gv(), ZRt = hF().processGrid, dF = hF().filter;
+        w8e.exports = function(t, r) {
+          r._len = Math.min(r.x.length, r.y.length, r.z.length, r.value.length), r._x = dF(r.x, r._len), r._y = dF(r.y, r._len), r._z = dF(r.z, r._len), r._value = dF(r.value, r._len);
+          var n = ZRt(r);
+          r._gridFill = n.fill, r._Xs = n.Xs, r._Ys = n.Ys, r._Zs = n.Zs, r._len = n.len;
+          for (var i = 1 / 0, a = -1 / 0, o = 0; o < r._len; o++) {
+            var s = r._value[o];
+            i = Math.min(i, s), a = Math.max(a, s);
+          }
+          r._minValues = i, r._maxValues = a, r._vMin = r.isomin === void 0 || r.isomin === null ? i : r.isomin, r._vMax = r.isomax === void 0 || r.isomax === null ? a : r.isomax, XRt(t, r, { vals: [r._vMin, r._vMax], containerStr: "", cLetter: "c" });
+        };
+      });
+      var $A = ye((Ugr, T8e) => {
+        T8e.exports = function(t, r, n, i) {
+          i = i || t.length;
+          for (var a = new Array(i), o = 0; o < i; o++) a[o] = [t[o], r[o], n[o]];
+          return a;
+        };
+      });
+      var vF = ye((Vgr, E8e) => {
+        var YRt = zd().gl_mesh3d, KRt = a1().parseColorScale, JRt = Dr().isArrayOrTypedArray, $Rt = n1(), QRt = tc().extractOpts, A8e = $A(), lk = function(e, t) {
+          for (var r = t.length - 1; r > 0; r--) {
+            var n = Math.min(t[r], t[r - 1]), i = Math.max(t[r], t[r - 1]);
+            if (i > n && n < e && e <= i) return { id: r, distRatio: (i - e) / (i - n) };
+          }
+          return { id: 0, distRatio: 0 };
+        };
+        function S8e(e, t, r) {
+          this.scene = e, this.uid = r, this.mesh = t, this.name = "", this.data = null, this.showContour = false;
+        }
+        var oZ = S8e.prototype;
+        oZ.handlePick = function(e) {
+          if (e.object === this.mesh) {
+            var t = e.data.index, r = this.data._meshX[t], n = this.data._meshY[t], i = this.data._meshZ[t], a = this.data._Ys.length, o = this.data._Zs.length, s = lk(r, this.data._Xs).id, l = lk(n, this.data._Ys).id, u = lk(i, this.data._Zs).id, c = e.index = u + o * l + o * a * s;
+            e.traceCoordinate = [this.data._meshX[c], this.data._meshY[c], this.data._meshZ[c], this.data._value[c]];
+            var f = this.data.hovertext || this.data.text;
+            return JRt(f) && f[c] !== void 0 ? e.textLabel = f[c] : f && (e.textLabel = f), true;
+          }
+        };
+        oZ.update = function(e) {
+          var t = this.scene, r = t.fullSceneLayout;
+          this.data = M8e(e);
+          function n(l, u, c, f) {
+            return u.map(function(h) {
+              return l.d2l(h, 0, f) * c;
+            });
+          }
+          var i = A8e(n(r.xaxis, e._meshX, t.dataScale[0], e.xcalendar), n(r.yaxis, e._meshY, t.dataScale[1], e.ycalendar), n(r.zaxis, e._meshZ, t.dataScale[2], e.zcalendar)), a = A8e(e._meshI, e._meshJ, e._meshK), o = { positions: i, cells: a, lightPosition: [e.lightposition.x, e.lightposition.y, e.lightposition.z], ambient: e.lighting.ambient, diffuse: e.lighting.diffuse, specular: e.lighting.specular, roughness: e.lighting.roughness, fresnel: e.lighting.fresnel, vertexNormalsEpsilon: e.lighting.vertexnormalsepsilon, faceNormalsEpsilon: e.lighting.facenormalsepsilon, opacity: e.opacity, contourEnable: e.contour.show, contourColor: $Rt(e.contour.color).slice(0, 3), contourWidth: e.contour.width, useFacetNormals: e.flatshading }, s = QRt(e);
+          o.vertexIntensity = e._meshIntensity, o.vertexIntensityBounds = [s.min, s.max], o.colormap = KRt(e), this.mesh.update(o);
+        };
+        oZ.dispose = function() {
+          this.scene.glplot.remove(this.mesh), this.mesh.dispose();
+        };
+        var eDt = ["xyz", "xzy", "yxz", "yzx", "zxy", "zyx"];
+        function M8e(e) {
+          e._meshI = [], e._meshJ = [], e._meshK = [];
+          var t = e.surface.show, r = e.spaceframe.show, n = e.surface.fill, i = e.spaceframe.fill, a = false, o = false, s = 0, l, u, c = e._Xs, f = e._Ys, h = e._Zs, d = c.length, v = f.length, _ = h.length, b = eDt.indexOf(e._gridFill.replace(/-/g, "").replace(/\+/g, "")), p = function(Qt, Gt, _t) {
+            switch (b) {
+              case 5:
+                return _t + _ * Gt + _ * v * Qt;
+              case 4:
+                return _t + _ * Qt + _ * d * Gt;
+              case 3:
+                return Gt + v * _t + v * _ * Qt;
+              case 2:
+                return Gt + v * Qt + v * d * _t;
+              case 1:
+                return Qt + d * _t + d * _ * Gt;
+              default:
+                return Qt + d * Gt + d * v * _t;
+            }
+          }, k = e._minValues, E = e._maxValues, T = e._vMin, L = e._vMax, x, C, M, g;
+          function P(Qt, Gt, _t) {
+            for (var It = g.length, mt = u; mt < It; mt++) if (Qt === x[mt] && Gt === C[mt] && _t === M[mt]) return mt;
+            return -1;
+          }
+          function A() {
+            u = l;
+          }
+          function z() {
+            x = [], C = [], M = [], g = [], l = 0, A();
+          }
+          function O(Qt, Gt, _t, It) {
+            return x.push(Qt), C.push(Gt), M.push(_t), g.push(It), l++, l - 1;
+          }
+          function U(Qt, Gt, _t) {
+            return e._meshI.push(Qt), e._meshJ.push(Gt), e._meshK.push(_t), s++, s - 1;
+          }
+          function G(Qt, Gt, _t) {
+            for (var It = [], mt = 0; mt < Qt.length; mt++) It[mt] = (Qt[mt] + Gt[mt] + _t[mt]) / 3;
+            return It;
+          }
+          function Z(Qt, Gt, _t) {
+            for (var It = [], mt = 0; mt < Qt.length; mt++) It[mt] = Qt[mt] * (1 - _t) + _t * Gt[mt];
+            return It;
+          }
+          var j;
+          function N(Qt) {
+            j = Qt;
+          }
+          function H(Qt, Gt) {
+            var _t = Qt[0], It = Qt[1], mt = Qt[2], er = G(_t, It, mt), lr = Math.sqrt(1 - j), wr = Z(er, _t, lr), Lr = Z(er, It, lr), ti = Z(er, mt, lr), Br = Gt[0], Vr = Gt[1], dt = Gt[2];
+            return { xyzv: [[_t, It, Lr], [Lr, wr, _t], [It, mt, ti], [ti, Lr, It], [mt, _t, wr], [wr, ti, mt]], abc: [[Br, Vr, -1], [-1, -1, Br], [Vr, dt, -1], [-1, -1, Vr], [dt, Br, -1], [-1, -1, dt]] };
+          }
+          function re(Qt, Gt) {
+            return Qt === "all" || Qt === null ? true : Qt.indexOf(Gt) > -1;
+          }
+          function oe(Qt, Gt) {
+            return Qt === null ? Gt : Qt;
+          }
+          function _e(Qt, Gt, _t) {
+            A();
+            var It = [Gt], mt = [_t];
+            if (j >= 1) It = [Gt], mt = [_t];
+            else if (j > 0) {
+              var er = H(Gt, _t);
+              It = er.xyzv, mt = er.abc;
+            }
+            for (var lr = 0; lr < It.length; lr++) {
+              Gt = It[lr], _t = mt[lr];
+              for (var wr = [], Lr = 0; Lr < 3; Lr++) {
+                var ti = Gt[Lr][0], Br = Gt[Lr][1], Vr = Gt[Lr][2], dt = Gt[Lr][3], Ge = _t[Lr] > -1 ? _t[Lr] : P(ti, Br, Vr);
+                Ge > -1 ? wr[Lr] = Ge : wr[Lr] = O(ti, Br, Vr, oe(Qt, dt));
+              }
+              U(wr[0], wr[1], wr[2]);
+            }
+          }
+          function Ce(Qt, Gt, _t) {
+            var It = function(mt, er, lr) {
+              _e(Qt, [Gt[mt], Gt[er], Gt[lr]], [_t[mt], _t[er], _t[lr]]);
+            };
+            It(0, 1, 2), It(2, 3, 0);
+          }
+          function Le(Qt, Gt, _t) {
+            var It = function(mt, er, lr) {
+              _e(Qt, [Gt[mt], Gt[er], Gt[lr]], [_t[mt], _t[er], _t[lr]]);
+            };
+            It(0, 1, 2), It(3, 0, 1), It(2, 3, 0), It(1, 2, 3);
+          }
+          function ge(Qt, Gt, _t, It) {
+            var mt = Qt[3];
+            mt < _t && (mt = _t), mt > It && (mt = It);
+            for (var er = (Qt[3] - mt) / (Qt[3] - Gt[3] + 1e-9), lr = [], wr = 0; wr < 4; wr++) lr[wr] = (1 - er) * Qt[wr] + er * Gt[wr];
+            return lr;
+          }
+          function ie(Qt, Gt, _t) {
+            return Qt >= Gt && Qt <= _t;
+          }
+          function Se(Qt) {
+            var Gt = 1e-3 * (L - T);
+            return Qt >= T - Gt && Qt <= L + Gt;
+          }
+          function Ee(Qt) {
+            for (var Gt = [], _t = 0; _t < 4; _t++) {
+              var It = Qt[_t];
+              Gt.push([e._x[It], e._y[It], e._z[It], e._value[It]]);
+            }
+            return Gt;
+          }
+          var Ae = 3;
+          function Be(Qt, Gt, _t, It, mt, er) {
+            er || (er = 1), _t = [-1, -1, -1];
+            var lr = false, wr = [ie(Gt[0][3], It, mt), ie(Gt[1][3], It, mt), ie(Gt[2][3], It, mt)];
+            if (!wr[0] && !wr[1] && !wr[2]) return false;
+            var Lr = function(Br, Vr, dt) {
+              return Se(Vr[0][3]) && Se(Vr[1][3]) && Se(Vr[2][3]) ? (_e(Br, Vr, dt), true) : er < Ae ? Be(Br, Vr, dt, T, L, ++er) : false;
+            };
+            if (wr[0] && wr[1] && wr[2]) return Lr(Qt, Gt, _t) || lr;
+            var ti = false;
+            return [[0, 1, 2], [2, 0, 1], [1, 2, 0]].forEach(function(Br) {
+              if (wr[Br[0]] && wr[Br[1]] && !wr[Br[2]]) {
+                var Vr = Gt[Br[0]], dt = Gt[Br[1]], Ge = Gt[Br[2]], Je = ge(Ge, Vr, It, mt), We = ge(Ge, dt, It, mt);
+                lr = Lr(Qt, [We, Je, Vr], [-1, -1, _t[Br[0]]]) || lr, lr = Lr(Qt, [Vr, dt, We], [_t[Br[0]], _t[Br[1]], -1]) || lr, ti = true;
+              }
+            }), ti || [[0, 1, 2], [1, 2, 0], [2, 0, 1]].forEach(function(Br) {
+              if (wr[Br[0]] && !wr[Br[1]] && !wr[Br[2]]) {
+                var Vr = Gt[Br[0]], dt = Gt[Br[1]], Ge = Gt[Br[2]], Je = ge(dt, Vr, It, mt), We = ge(Ge, Vr, It, mt);
+                lr = Lr(Qt, [We, Je, Vr], [-1, -1, _t[Br[0]]]) || lr, ti = true;
+              }
+            }), lr;
+          }
+          function Pe(Qt, Gt, _t, It) {
+            var mt = false, er = Ee(Gt), lr = [ie(er[0][3], _t, It), ie(er[1][3], _t, It), ie(er[2][3], _t, It), ie(er[3][3], _t, It)];
+            if (!lr[0] && !lr[1] && !lr[2] && !lr[3]) return mt;
+            if (lr[0] && lr[1] && lr[2] && lr[3]) return o && (mt = Le(Qt, er, Gt) || mt), mt;
+            var wr = false;
+            return [[0, 1, 2, 3], [3, 0, 1, 2], [2, 3, 0, 1], [1, 2, 3, 0]].forEach(function(Lr) {
+              if (lr[Lr[0]] && lr[Lr[1]] && lr[Lr[2]] && !lr[Lr[3]]) {
+                var ti = er[Lr[0]], Br = er[Lr[1]], Vr = er[Lr[2]], dt = er[Lr[3]];
+                if (o) mt = _e(Qt, [ti, Br, Vr], [Gt[Lr[0]], Gt[Lr[1]], Gt[Lr[2]]]) || mt;
+                else {
+                  var Ge = ge(dt, ti, _t, It), Je = ge(dt, Br, _t, It), We = ge(dt, Vr, _t, It);
+                  mt = _e(null, [Ge, Je, We], [-1, -1, -1]) || mt;
+                }
+                wr = true;
+              }
+            }), wr || ([[0, 1, 2, 3], [1, 2, 3, 0], [2, 3, 0, 1], [3, 0, 1, 2], [0, 2, 3, 1], [1, 3, 2, 0]].forEach(function(Lr) {
+              if (lr[Lr[0]] && lr[Lr[1]] && !lr[Lr[2]] && !lr[Lr[3]]) {
+                var ti = er[Lr[0]], Br = er[Lr[1]], Vr = er[Lr[2]], dt = er[Lr[3]], Ge = ge(Vr, ti, _t, It), Je = ge(Vr, Br, _t, It), We = ge(dt, Br, _t, It), tt = ge(dt, ti, _t, It);
+                o ? (mt = _e(Qt, [ti, tt, Ge], [Gt[Lr[0]], -1, -1]) || mt, mt = _e(Qt, [Br, Je, We], [Gt[Lr[1]], -1, -1]) || mt) : mt = Ce(null, [Ge, Je, We, tt], [-1, -1, -1, -1]) || mt, wr = true;
+              }
+            }), wr) || [[0, 1, 2, 3], [1, 2, 3, 0], [2, 3, 0, 1], [3, 0, 1, 2]].forEach(function(Lr) {
+              if (lr[Lr[0]] && !lr[Lr[1]] && !lr[Lr[2]] && !lr[Lr[3]]) {
+                var ti = er[Lr[0]], Br = er[Lr[1]], Vr = er[Lr[2]], dt = er[Lr[3]], Ge = ge(Br, ti, _t, It), Je = ge(Vr, ti, _t, It), We = ge(dt, ti, _t, It);
+                o ? (mt = _e(Qt, [ti, Ge, Je], [Gt[Lr[0]], -1, -1]) || mt, mt = _e(Qt, [ti, Je, We], [Gt[Lr[0]], -1, -1]) || mt, mt = _e(Qt, [ti, We, Ge], [Gt[Lr[0]], -1, -1]) || mt) : mt = _e(null, [Ge, Je, We], [-1, -1, -1]) || mt, wr = true;
+              }
+            }), mt;
+          }
+          function me(Qt, Gt, _t, It, mt, er, lr, wr, Lr, ti, Br) {
+            var Vr = false;
+            return a && (re(Qt, "A") && (Vr = Pe(null, [Gt, _t, It, er], ti, Br) || Vr), re(Qt, "B") && (Vr = Pe(null, [_t, It, mt, Lr], ti, Br) || Vr), re(Qt, "C") && (Vr = Pe(null, [_t, er, lr, Lr], ti, Br) || Vr), re(Qt, "D") && (Vr = Pe(null, [It, er, wr, Lr], ti, Br) || Vr), re(Qt, "E") && (Vr = Pe(null, [_t, It, er, Lr], ti, Br) || Vr)), o && (Vr = Pe(Qt, [_t, It, er, Lr], ti, Br) || Vr), Vr;
+          }
+          function De(Qt, Gt, _t, It, mt, er, lr, wr) {
+            return [wr[0] === true ? true : Be(Qt, Ee([Gt, _t, It]), [Gt, _t, It], er, lr), wr[1] === true ? true : Be(Qt, Ee([It, mt, Gt]), [It, mt, Gt], er, lr)];
+          }
+          function ce(Qt, Gt, _t, It, mt, er, lr, wr, Lr) {
+            return wr ? De(Qt, Gt, _t, mt, It, er, lr, Lr) : De(Qt, _t, mt, It, Gt, er, lr, Lr);
+          }
+          function je(Qt, Gt, _t, It, mt, er, lr) {
+            var wr = false, Lr, ti, Br, Vr, dt = function() {
+              wr = Be(Qt, [Lr, ti, Br], [-1, -1, -1], mt, er) || wr, wr = Be(Qt, [Br, Vr, Lr], [-1, -1, -1], mt, er) || wr;
+            }, Ge = lr[0], Je = lr[1], We = lr[2];
+            return Ge && (Lr = Z(Ee([p(Gt, _t - 0, It - 0)])[0], Ee([p(Gt - 1, _t - 0, It - 0)])[0], Ge), ti = Z(Ee([p(Gt, _t - 0, It - 1)])[0], Ee([p(Gt - 1, _t - 0, It - 1)])[0], Ge), Br = Z(Ee([p(Gt, _t - 1, It - 1)])[0], Ee([p(Gt - 1, _t - 1, It - 1)])[0], Ge), Vr = Z(Ee([p(Gt, _t - 1, It - 0)])[0], Ee([p(Gt - 1, _t - 1, It - 0)])[0], Ge), dt()), Je && (Lr = Z(Ee([p(Gt - 0, _t, It - 0)])[0], Ee([p(Gt - 0, _t - 1, It - 0)])[0], Je), ti = Z(Ee([p(Gt - 0, _t, It - 1)])[0], Ee([p(Gt - 0, _t - 1, It - 1)])[0], Je), Br = Z(Ee([p(Gt - 1, _t, It - 1)])[0], Ee([p(Gt - 1, _t - 1, It - 1)])[0], Je), Vr = Z(Ee([p(Gt - 1, _t, It - 0)])[0], Ee([p(Gt - 1, _t - 1, It - 0)])[0], Je), dt()), We && (Lr = Z(Ee([p(Gt - 0, _t - 0, It)])[0], Ee([p(Gt - 0, _t - 0, It - 1)])[0], We), ti = Z(Ee([p(Gt - 0, _t - 1, It)])[0], Ee([p(Gt - 0, _t - 1, It - 1)])[0], We), Br = Z(Ee([p(Gt - 1, _t - 1, It)])[0], Ee([p(Gt - 1, _t - 1, It - 1)])[0], We), Vr = Z(Ee([p(Gt - 1, _t - 0, It)])[0], Ee([p(Gt - 1, _t - 0, It - 1)])[0], We), dt()), wr;
+          }
+          function lt(Qt, Gt, _t, It, mt, er, lr, wr, Lr, ti, Br, Vr) {
+            var dt = Qt;
+            return Vr ? (a && Qt === "even" && (dt = null), me(dt, Gt, _t, It, mt, er, lr, wr, Lr, ti, Br)) : (a && Qt === "odd" && (dt = null), me(dt, Lr, wr, lr, er, mt, It, _t, Gt, ti, Br));
+          }
+          function pt(Qt, Gt, _t, It, mt) {
+            for (var er = [], lr = 0, wr = 0; wr < Gt.length; wr++) for (var Lr = Gt[wr], ti = 1; ti < _; ti++) for (var Br = 1; Br < v; Br++) er.push(ce(Qt, p(Lr, Br - 1, ti - 1), p(Lr, Br - 1, ti), p(Lr, Br, ti - 1), p(Lr, Br, ti), _t, It, (Lr + Br + ti) % 2, mt && mt[lr] ? mt[lr] : [])), lr++;
+            return er;
+          }
+          function Vt(Qt, Gt, _t, It, mt) {
+            for (var er = [], lr = 0, wr = 0; wr < Gt.length; wr++) for (var Lr = Gt[wr], ti = 1; ti < d; ti++) for (var Br = 1; Br < _; Br++) er.push(ce(Qt, p(ti - 1, Lr, Br - 1), p(ti, Lr, Br - 1), p(ti - 1, Lr, Br), p(ti, Lr, Br), _t, It, (ti + Lr + Br) % 2, mt && mt[lr] ? mt[lr] : [])), lr++;
+            return er;
+          }
+          function ot(Qt, Gt, _t, It, mt) {
+            for (var er = [], lr = 0, wr = 0; wr < Gt.length; wr++) for (var Lr = Gt[wr], ti = 1; ti < v; ti++) for (var Br = 1; Br < d; Br++) er.push(ce(Qt, p(Br - 1, ti - 1, Lr), p(Br - 1, ti, Lr), p(Br, ti - 1, Lr), p(Br, ti, Lr), _t, It, (Br + ti + Lr) % 2, mt && mt[lr] ? mt[lr] : [])), lr++;
+            return er;
+          }
+          function ut(Qt, Gt, _t) {
+            for (var It = 1; It < _; It++) for (var mt = 1; mt < v; mt++) for (var er = 1; er < d; er++) lt(Qt, p(er - 1, mt - 1, It - 1), p(er - 1, mt - 1, It), p(er - 1, mt, It - 1), p(er - 1, mt, It), p(er, mt - 1, It - 1), p(er, mt - 1, It), p(er, mt, It - 1), p(er, mt, It), Gt, _t, (er + mt + It) % 2);
+          }
+          function Wt(Qt, Gt, _t) {
+            o = true, ut(Qt, Gt, _t), o = false;
+          }
+          function Nt(Qt, Gt, _t) {
+            a = true, ut(Qt, Gt, _t), a = false;
+          }
+          function $t(Qt, Gt, _t, It, mt, er) {
+            for (var lr = [], wr = 0, Lr = 0; Lr < Gt.length; Lr++) for (var ti = Gt[Lr], Br = 1; Br < _; Br++) for (var Vr = 1; Vr < v; Vr++) lr.push(je(Qt, ti, Vr, Br, _t, It, mt[Lr], er && er[wr] ? er[wr] : [])), wr++;
+            return lr;
+          }
+          function sr(Qt, Gt, _t, It, mt, er) {
+            for (var lr = [], wr = 0, Lr = 0; Lr < Gt.length; Lr++) for (var ti = Gt[Lr], Br = 1; Br < d; Br++) for (var Vr = 1; Vr < _; Vr++) lr.push(je(Qt, Br, ti, Vr, _t, It, mt[Lr], er && er[wr] ? er[wr] : [])), wr++;
+            return lr;
+          }
+          function Tr(Qt, Gt, _t, It, mt, er) {
+            for (var lr = [], wr = 0, Lr = 0; Lr < Gt.length; Lr++) for (var ti = Gt[Lr], Br = 1; Br < v; Br++) for (var Vr = 1; Vr < d; Vr++) lr.push(je(Qt, Vr, Br, ti, _t, It, mt[Lr], er && er[wr] ? er[wr] : [])), wr++;
+            return lr;
+          }
+          function fr(Qt, Gt) {
+            for (var _t = [], It = Qt; It < Gt; It++) _t.push(It);
+            return _t;
+          }
+          function $e() {
+            for (var Qt = 0; Qt < d; Qt++) for (var Gt = 0; Gt < v; Gt++) for (var _t = 0; _t < _; _t++) {
+              var It = p(Qt, Gt, _t);
+              O(e._x[It], e._y[It], e._z[It], e._value[It]);
+            }
+          }
+          function St() {
+            z(), $e();
+            var Qt = null;
+            if (r && i && (N(i), Wt(Qt, T, L)), t && n) {
+              N(n);
+              for (var Gt = e.surface.pattern, _t = e.surface.count, It = 0; It < _t; It++) {
+                var mt = _t === 1 ? 0.5 : It / (_t - 1), er = (1 - mt) * T + mt * L, lr = Math.abs(er - k), wr = Math.abs(er - E), Lr = lr > wr ? [k, er] : [er, E];
+                Nt(Gt, Lr[0], Lr[1]);
+              }
+            }
+            var ti = [[Math.min(T, E), Math.max(T, E)], [Math.min(k, L), Math.max(k, L)]];
+            ["x", "y", "z"].forEach(function(Br) {
+              for (var Vr = [], dt = 0; dt < ti.length; dt++) {
+                var Ge = 0, Je = ti[dt][0], We = ti[dt][1], tt = e.slices[Br];
+                if (tt.show && tt.fill) {
+                  N(tt.fill);
+                  var xt = [], Ie = [], xe = [];
+                  if (tt.locations.length) for (var ke = 0; ke < tt.locations.length; ke++) {
+                    var vt = lk(tt.locations[ke], Br === "x" ? c : Br === "y" ? f : h);
+                    vt.distRatio === 0 ? xt.push(vt.id) : vt.id > 0 && (Ie.push(vt.id), Br === "x" ? xe.push([vt.distRatio, 0, 0]) : Br === "y" ? xe.push([0, vt.distRatio, 0]) : xe.push([0, 0, vt.distRatio]));
+                  }
+                  else Br === "x" ? xt = fr(1, d - 1) : Br === "y" ? xt = fr(1, v - 1) : xt = fr(1, _ - 1);
+                  Ie.length > 0 && (Br === "x" ? Vr[Ge] = $t(Qt, Ie, Je, We, xe, Vr[Ge]) : Br === "y" ? Vr[Ge] = sr(Qt, Ie, Je, We, xe, Vr[Ge]) : Vr[Ge] = Tr(Qt, Ie, Je, We, xe, Vr[Ge]), Ge++), xt.length > 0 && (Br === "x" ? Vr[Ge] = pt(Qt, xt, Je, We, Vr[Ge]) : Br === "y" ? Vr[Ge] = Vt(Qt, xt, Je, We, Vr[Ge]) : Vr[Ge] = ot(Qt, xt, Je, We, Vr[Ge]), Ge++);
+                }
+                var ir = e.caps[Br];
+                ir.show && ir.fill && (N(ir.fill), Br === "x" ? Vr[Ge] = pt(Qt, [0, d - 1], Je, We, Vr[Ge]) : Br === "y" ? Vr[Ge] = Vt(Qt, [0, v - 1], Je, We, Vr[Ge]) : Vr[Ge] = ot(Qt, [0, _ - 1], Je, We, Vr[Ge]), Ge++);
+              }
+            }), s === 0 && z(), e._meshX = x, e._meshY = C, e._meshZ = M, e._meshIntensity = g, e._Xs = c, e._Ys = f, e._Zs = h;
+          }
+          return St(), e;
+        }
+        function tDt(e, t) {
+          var r = e.glplot.gl, n = YRt({ gl: r }), i = new S8e(e, n, t.uid);
+          return n._trace = i, i.update(t), e.glplot.add(n), i;
+        }
+        E8e.exports = { findNearestOnAxis: lk, generateIsoMeshes: M8e, createIsosurfaceTrace: tDt };
+      });
+      var C8e = ye((Ggr, k8e) => {
+        k8e.exports = { attributes: fF(), supplyDefaults: rZ().supplyDefaults, calc: aZ(), colorbar: { min: "cmin", max: "cmax" }, plot: vF().createIsosurfaceTrace, moduleType: "trace", name: "isosurface", basePlotModule: sx(), categories: ["gl3d", "showLegend"], meta: {} };
+      });
+      var P8e = ye((Hgr, L8e) => {
+        L8e.exports = C8e();
+      });
+      var lZ = ye((jgr, R8e) => {
+        var rDt = Tu(), xh = fF(), iDt = ak(), I8e = Gl(), sZ = Ao().extendFlat, nDt = mc().overrideAll, pF = R8e.exports = nDt(sZ({ x: xh.x, y: xh.y, z: xh.z, value: xh.value, isomin: xh.isomin, isomax: xh.isomax, surface: xh.surface, spaceframe: { show: { valType: "boolean", dflt: false }, fill: { valType: "number", min: 0, max: 1, dflt: 1 } }, slices: xh.slices, caps: xh.caps, text: xh.text, hovertext: xh.hovertext, xhoverformat: xh.xhoverformat, yhoverformat: xh.yhoverformat, zhoverformat: xh.zhoverformat, valuehoverformat: xh.valuehoverformat, hovertemplate: xh.hovertemplate, hovertemplatefallback: xh.hovertemplatefallback }, rDt("", { colorAttr: "`value`", showScaleDflt: true, editTypeOverride: "calc" }), { colorbar: xh.colorbar, opacity: xh.opacity, opacityscale: iDt.opacityscale, lightposition: xh.lightposition, lighting: xh.lighting, flatshading: xh.flatshading, contour: xh.contour, hoverinfo: sZ({}, I8e.hoverinfo), showlegend: sZ({}, I8e.showlegend, { dflt: false }) }), "calc", "nested");
+        pF.x.editType = pF.y.editType = pF.z.editType = pF.value.editType = "calc+clearAxisTypes";
+      });
+      var F8e = ye((Wgr, D8e) => {
+        var aDt = Dr(), oDt = lZ(), sDt = rZ().supplyIsoDefaults, lDt = KX().opacityscaleDefaults;
+        D8e.exports = function(t, r, n, i) {
+          function a(o, s) {
+            return aDt.coerce(t, r, oDt, o, s);
+          }
+          sDt(t, r, n, i, a), lDt(t, r, i, a);
+        };
+      });
+      var B8e = ye((Xgr, q8e) => {
+        var uDt = zd().gl_mesh3d, cDt = a1().parseColorScale, fDt = Dr().isArrayOrTypedArray, hDt = n1(), dDt = tc().extractOpts, z8e = $A(), uZ = vF().findNearestOnAxis, vDt = vF().generateIsoMeshes;
+        function O8e(e, t, r) {
+          this.scene = e, this.uid = r, this.mesh = t, this.name = "", this.data = null, this.showContour = false;
+        }
+        var cZ = O8e.prototype;
+        cZ.handlePick = function(e) {
+          if (e.object === this.mesh) {
+            var t = e.data.index, r = this.data._meshX[t], n = this.data._meshY[t], i = this.data._meshZ[t], a = this.data._Ys.length, o = this.data._Zs.length, s = uZ(r, this.data._Xs).id, l = uZ(n, this.data._Ys).id, u = uZ(i, this.data._Zs).id, c = e.index = u + o * l + o * a * s;
+            e.traceCoordinate = [this.data._meshX[c], this.data._meshY[c], this.data._meshZ[c], this.data._value[c]];
+            var f = this.data.hovertext || this.data.text;
+            return fDt(f) && f[c] !== void 0 ? e.textLabel = f[c] : f && (e.textLabel = f), true;
+          }
+        };
+        cZ.update = function(e) {
+          var t = this.scene, r = t.fullSceneLayout;
+          this.data = vDt(e);
+          function n(l, u, c, f) {
+            return u.map(function(h) {
+              return l.d2l(h, 0, f) * c;
+            });
+          }
+          var i = z8e(n(r.xaxis, e._meshX, t.dataScale[0], e.xcalendar), n(r.yaxis, e._meshY, t.dataScale[1], e.ycalendar), n(r.zaxis, e._meshZ, t.dataScale[2], e.zcalendar)), a = z8e(e._meshI, e._meshJ, e._meshK), o = { positions: i, cells: a, lightPosition: [e.lightposition.x, e.lightposition.y, e.lightposition.z], ambient: e.lighting.ambient, diffuse: e.lighting.diffuse, specular: e.lighting.specular, roughness: e.lighting.roughness, fresnel: e.lighting.fresnel, vertexNormalsEpsilon: e.lighting.vertexnormalsepsilon, faceNormalsEpsilon: e.lighting.facenormalsepsilon, opacity: e.opacity, opacityscale: e.opacityscale, contourEnable: e.contour.show, contourColor: hDt(e.contour.color).slice(0, 3), contourWidth: e.contour.width, useFacetNormals: e.flatshading }, s = dDt(e);
+          o.vertexIntensity = e._meshIntensity, o.vertexIntensityBounds = [s.min, s.max], o.colormap = cDt(e), this.mesh.update(o);
+        };
+        cZ.dispose = function() {
+          this.scene.glplot.remove(this.mesh), this.mesh.dispose();
+        };
+        function pDt(e, t) {
+          var r = e.glplot.gl, n = uDt({ gl: r }), i = new O8e(e, n, t.uid);
+          return n._trace = i, i.update(t), e.glplot.add(n), i;
+        }
+        q8e.exports = pDt;
+      });
+      var U8e = ye((Zgr, N8e) => {
+        N8e.exports = { attributes: lZ(), supplyDefaults: F8e(), calc: aZ(), colorbar: { min: "cmin", max: "cmax" }, plot: B8e(), moduleType: "trace", name: "volume", basePlotModule: sx(), categories: ["gl3d", "showLegend"], meta: {} };
+      });
+      var G8e = ye((Ygr, V8e) => {
+        V8e.exports = U8e();
+      });
+      var W8e = ye((Kgr, j8e) => {
+        var gDt = qa(), H8e = Dr(), mDt = td(), yDt = KA();
+        j8e.exports = function(t, r, n, i) {
+          function a(c, f) {
+            return H8e.coerce(t, r, yDt, c, f);
+          }
+          function o(c) {
+            var f = c.map(function(h) {
+              var d = a(h);
+              return d && H8e.isArrayOrTypedArray(d) ? d : null;
+            });
+            return f.every(function(h) {
+              return h && h.length === f[0].length;
+            }) && f;
+          }
+          var s = o(["x", "y", "z"]);
+          if (!s) {
+            r.visible = false;
+            return;
+          }
+          if (o(["i", "j", "k"]), r.i && (!r.j || !r.k) || r.j && (!r.k || !r.i) || r.k && (!r.i || !r.j)) {
+            r.visible = false;
+            return;
+          }
+          var l = gDt.getComponentMethod("calendars", "handleTraceDefaults");
+          l(t, r, ["x", "y", "z"], i), ["lighting.ambient", "lighting.diffuse", "lighting.specular", "lighting.roughness", "lighting.fresnel", "lighting.vertexnormalsepsilon", "lighting.facenormalsepsilon", "lightposition.x", "lightposition.y", "lightposition.z", "flatshading", "alphahull", "delaunayaxis", "opacity"].forEach(function(c) {
+            a(c);
+          });
+          var u = a("contour.show");
+          u && (a("contour.color"), a("contour.width")), "intensity" in t ? (a("intensity"), a("intensitymode"), mDt(t, r, i, a, { prefix: "", cLetter: "c" })) : (r.showscale = false, "facecolor" in t ? a("facecolor") : "vertexcolor" in t ? a("vertexcolor") : a("color", n)), a("text"), a("hovertext"), a("hovertemplate"), a("hovertemplatefallback"), a("xhoverformat"), a("yhoverformat"), a("zhoverformat"), r._length = null;
+        };
+      });
+      var Z8e = ye((Jgr, X8e) => {
+        var _Dt = gv();
+        X8e.exports = function(t, r) {
+          r.intensity && _Dt(t, r, { vals: r.intensity, containerStr: "", cLetter: "c" });
+        };
+      });
+      var Q8e = ye(($gr, $8e) => {
+        var xDt = zd().gl_mesh3d, bDt = zd().delaunay_triangulate, wDt = zd().alpha_shape, TDt = zd().convex_hull, ADt = a1().parseColorScale, SDt = Dr().isArrayOrTypedArray, vZ = n1(), MDt = tc().extractOpts, Y8e = $A();
+        function J8e(e, t, r) {
+          this.scene = e, this.uid = r, this.mesh = t, this.name = "", this.color = "#fff", this.data = null, this.showContour = false;
+        }
+        var pZ = J8e.prototype;
+        pZ.handlePick = function(e) {
+          if (e.object === this.mesh) {
+            var t = e.index = e.data.index;
+            e.data._cellCenter ? e.traceCoordinate = e.data.dataCoordinate : e.traceCoordinate = [this.data.x[t], this.data.y[t], this.data.z[t]];
+            var r = this.data.hovertext || this.data.text;
+            return SDt(r) && r[t] !== void 0 ? e.textLabel = r[t] : r && (e.textLabel = r), true;
+          }
+        };
+        function K8e(e) {
+          for (var t = [], r = e.length, n = 0; n < r; n++) t[n] = vZ(e[n]);
+          return t;
+        }
+        function fZ(e, t, r, n) {
+          for (var i = [], a = t.length, o = 0; o < a; o++) i[o] = e.d2l(t[o], 0, n) * r;
+          return i;
+        }
+        function hZ(e) {
+          for (var t = [], r = e.length, n = 0; n < r; n++) t[n] = Math.round(e[n]);
+          return t;
+        }
+        function EDt(e, t) {
+          for (var r = ["x", "y", "z"].indexOf(e), n = [], i = t.length, a = 0; a < i; a++) n[a] = [t[a][(r + 1) % 3], t[a][(r + 2) % 3]];
+          return bDt(n);
+        }
+        function dZ(e, t) {
+          for (var r = e.length, n = 0; n < r; n++) if (e[n] <= -0.5 || e[n] >= t - 0.5) return false;
+          return true;
+        }
+        pZ.update = function(e) {
+          var t = this.scene, r = t.fullSceneLayout;
+          this.data = e;
+          var n = e.x.length, i = Y8e(fZ(r.xaxis, e.x, t.dataScale[0], e.xcalendar), fZ(r.yaxis, e.y, t.dataScale[1], e.ycalendar), fZ(r.zaxis, e.z, t.dataScale[2], e.zcalendar)), a;
+          if (e.i && e.j && e.k) {
+            if (e.i.length !== e.j.length || e.j.length !== e.k.length || !dZ(e.i, n) || !dZ(e.j, n) || !dZ(e.k, n)) return;
+            a = Y8e(hZ(e.i), hZ(e.j), hZ(e.k));
+          } else e.alphahull === 0 ? a = TDt(i) : e.alphahull > 0 ? a = wDt(e.alphahull, i) : a = EDt(e.delaunayaxis, i);
+          var o = { positions: i, cells: a, lightPosition: [e.lightposition.x, e.lightposition.y, e.lightposition.z], ambient: e.lighting.ambient, diffuse: e.lighting.diffuse, specular: e.lighting.specular, roughness: e.lighting.roughness, fresnel: e.lighting.fresnel, vertexNormalsEpsilon: e.lighting.vertexnormalsepsilon, faceNormalsEpsilon: e.lighting.facenormalsepsilon, opacity: e.opacity, contourEnable: e.contour.show, contourColor: vZ(e.contour.color).slice(0, 3), contourWidth: e.contour.width, useFacetNormals: e.flatshading };
+          if (e.intensity) {
+            var s = MDt(e);
+            this.color = "#fff";
+            var l = e.intensitymode;
+            o[l + "Intensity"] = e.intensity, o[l + "IntensityBounds"] = [s.min, s.max], o.colormap = ADt(e);
+          } else e.vertexcolor ? (this.color = e.vertexcolor[0], o.vertexColors = K8e(e.vertexcolor)) : e.facecolor ? (this.color = e.facecolor[0], o.cellColors = K8e(e.facecolor)) : (this.color = e.color, o.meshColor = vZ(e.color));
+          this.mesh.update(o);
+        };
+        pZ.dispose = function() {
+          this.scene.glplot.remove(this.mesh), this.mesh.dispose();
+        };
+        function kDt(e, t) {
+          var r = e.glplot.gl, n = xDt({ gl: r }), i = new J8e(e, n, t.uid);
+          return n._trace = i, i.update(t), e.glplot.add(n), i;
+        }
+        $8e.exports = kDt;
+      });
+      var tRe = ye((Qgr, eRe) => {
+        eRe.exports = { attributes: KA(), supplyDefaults: W8e(), calc: Z8e(), colorbar: { min: "cmin", max: "cmax" }, plot: Q8e(), moduleType: "trace", name: "mesh3d", basePlotModule: sx(), categories: ["gl3d", "showLegend"], meta: {} };
+      });
+      var iRe = ye((emr, rRe) => {
+        rRe.exports = tRe();
+      });
+      var mZ = ye((tmr, aRe) => {
+        var CDt = Tu(), QA = df().axisHoverFormat, { hovertemplateAttrs: LDt, templatefallbackAttrs: PDt } = Ll(), IDt = KA(), nRe = Gl(), gZ = Ao().extendFlat, gF = { x: { valType: "data_array", editType: "calc+clearAxisTypes" }, y: { valType: "data_array", editType: "calc+clearAxisTypes" }, z: { valType: "data_array", editType: "calc+clearAxisTypes" }, u: { valType: "data_array", editType: "calc" }, v: { valType: "data_array", editType: "calc" }, w: { valType: "data_array", editType: "calc" }, sizemode: { valType: "enumerated", values: ["scaled", "absolute", "raw"], editType: "calc", dflt: "scaled" }, sizeref: { valType: "number", editType: "calc", min: 0 }, anchor: { valType: "enumerated", editType: "calc", values: ["tip", "tail", "cm", "center"], dflt: "cm" }, text: { valType: "string", dflt: "", arrayOk: true, editType: "calc" }, hovertext: { valType: "string", dflt: "", arrayOk: true, editType: "calc" }, hovertemplate: LDt({ editType: "calc" }, { keys: ["norm"] }), hovertemplatefallback: PDt({ editType: "calc" }), uhoverformat: QA("u", 1), vhoverformat: QA("v", 1), whoverformat: QA("w", 1), xhoverformat: QA("x"), yhoverformat: QA("y"), zhoverformat: QA("z"), showlegend: gZ({}, nRe.showlegend, { dflt: false }) };
+        gZ(gF, CDt("", { colorAttr: "u/v/w norm", showScaleDflt: true, editTypeOverride: "calc" }));
+        var RDt = ["opacity", "lightposition", "lighting"];
+        RDt.forEach(function(e) {
+          gF[e] = IDt[e];
+        });
+        gF.hoverinfo = gZ({}, nRe.hoverinfo, { editType: "calc", flags: ["x", "y", "z", "u", "v", "w", "norm", "text", "name"], dflt: "x+y+z+norm+text+name" });
+        aRe.exports = gF;
+      });
+      var sRe = ye((rmr, oRe) => {
+        var DDt = Dr(), FDt = td(), zDt = mZ();
+        oRe.exports = function(t, r, n, i) {
+          function a(d, v) {
+            return DDt.coerce(t, r, zDt, d, v);
+          }
+          var o = a("u"), s = a("v"), l = a("w"), u = a("x"), c = a("y"), f = a("z");
+          if (!o || !o.length || !s || !s.length || !l || !l.length || !u || !u.length || !c || !c.length || !f || !f.length) {
+            r.visible = false;
+            return;
+          }
+          var h = a("sizemode");
+          a("sizeref", h === "raw" ? 1 : 0.5), a("anchor"), a("lighting.ambient"), a("lighting.diffuse"), a("lighting.specular"), a("lighting.roughness"), a("lighting.fresnel"), a("lightposition.x"), a("lightposition.y"), a("lightposition.z"), FDt(t, r, i, a, { prefix: "", cLetter: "c" }), a("text"), a("hovertext"), a("hovertemplate"), a("hovertemplatefallback"), a("uhoverformat"), a("vhoverformat"), a("whoverformat"), a("xhoverformat"), a("yhoverformat"), a("zhoverformat"), r._length = null;
+        };
+      });
+      var uRe = ye((imr, lRe) => {
+        var ODt = gv();
+        lRe.exports = function(t, r) {
+          for (var n = r.u, i = r.v, a = r.w, o = Math.min(r.x.length, r.y.length, r.z.length, n.length, i.length, a.length), s = -1 / 0, l = 1 / 0, u = 0; u < o; u++) {
+            var c = n[u], f = i[u], h = a[u], d = Math.sqrt(c * c + f * f + h * h);
+            s = Math.max(s, d), l = Math.min(l, d);
+          }
+          r._len = o, r._normMax = s, ODt(t, r, { vals: [l, s], containerStr: "", cLetter: "c" });
+        };
+      });
+      var vRe = ye((nmr, dRe) => {
+        var qDt = zd().gl_cone3d, BDt = zd().gl_cone3d.createConeMesh, NDt = Dr().simpleMap, UDt = a1().parseColorScale, VDt = tc().extractOpts, GDt = Dr().isArrayOrTypedArray, cRe = $A();
+        function fRe(e, t) {
+          this.scene = e, this.uid = t, this.mesh = null, this.data = null;
+        }
+        var yZ = fRe.prototype;
+        yZ.handlePick = function(e) {
+          if (e.object === this.mesh) {
+            var t = e.index = e.data.index, r = this.data.x[t], n = this.data.y[t], i = this.data.z[t], a = this.data.u[t], o = this.data.v[t], s = this.data.w[t];
+            e.traceCoordinate = [r, n, i, a, o, s, Math.sqrt(a * a + o * o + s * s)];
+            var l = this.data.hovertext || this.data.text;
+            return GDt(l) && l[t] !== void 0 ? e.textLabel = l[t] : l && (e.textLabel = l), true;
+          }
+        };
+        var HDt = { xaxis: 0, yaxis: 1, zaxis: 2 }, jDt = { tip: 1, tail: 0, cm: 0.25, center: 0.5 }, WDt = { tip: 1, tail: 1, cm: 0.75, center: 0.5 };
+        function hRe(e, t) {
+          var r = e.fullSceneLayout, n = e.dataScale, i = {};
+          function a(c, f) {
+            var h = r[f], d = n[HDt[f]];
+            return NDt(c, function(v) {
+              return h.d2l(v) * d;
+            });
+          }
+          i.vectors = cRe(a(t.u, "xaxis"), a(t.v, "yaxis"), a(t.w, "zaxis"), t._len), i.positions = cRe(a(t.x, "xaxis"), a(t.y, "yaxis"), a(t.z, "zaxis"), t._len);
+          var o = VDt(t);
+          i.colormap = UDt(t), i.vertexIntensityBounds = [o.min / t._normMax, o.max / t._normMax], i.coneOffset = jDt[t.anchor];
+          var s = t.sizemode;
+          s === "scaled" ? i.coneSize = t.sizeref || 0.5 : s === "absolute" ? i.coneSize = t.sizeref && t._normMax ? t.sizeref / t._normMax : 0.5 : s === "raw" && (i.coneSize = t.sizeref), i.coneSizemode = s;
+          var l = qDt(i), u = t.lightposition;
+          return l.lightPosition = [u.x, u.y, u.z], l.ambient = t.lighting.ambient, l.diffuse = t.lighting.diffuse, l.specular = t.lighting.specular, l.roughness = t.lighting.roughness, l.fresnel = t.lighting.fresnel, l.opacity = t.opacity, t._pad = WDt[t.anchor] * l.vectorScale * l.coneScale * t._normMax, l;
+        }
+        yZ.update = function(e) {
+          this.data = e;
+          var t = hRe(this.scene, e);
+          this.mesh.update(t);
+        };
+        yZ.dispose = function() {
+          this.scene.glplot.remove(this.mesh), this.mesh.dispose();
+        };
+        function XDt(e, t) {
+          var r = e.glplot.gl, n = hRe(e, t), i = BDt(r, n), a = new fRe(e, t.uid);
+          return a.mesh = i, a.data = t, i._trace = a, e.glplot.add(i), a;
+        }
+        dRe.exports = XDt;
+      });
+      var gRe = ye((amr, pRe) => {
+        pRe.exports = { moduleType: "trace", name: "cone", basePlotModule: sx(), categories: ["gl3d", "showLegend"], attributes: mZ(), supplyDefaults: sRe(), colorbar: { min: "cmin", max: "cmax" }, calc: uRe(), plot: vRe(), eventData: function(e, t) {
+          return e.norm = t.traceCoordinate[6], e;
+        }, meta: {} };
+      });
+      var yRe = ye((omr, mRe) => {
+        mRe.exports = gRe();
+      });
+      var xZ = ye((smr, xRe) => {
+        var ZDt = Tu(), e5 = df().axisHoverFormat, { hovertemplateAttrs: YDt, templatefallbackAttrs: KDt } = Ll(), JDt = KA(), _Re = Gl(), _Z = Ao().extendFlat, mF = { x: { valType: "data_array", editType: "calc+clearAxisTypes" }, y: { valType: "data_array", editType: "calc+clearAxisTypes" }, z: { valType: "data_array", editType: "calc+clearAxisTypes" }, u: { valType: "data_array", editType: "calc" }, v: { valType: "data_array", editType: "calc" }, w: { valType: "data_array", editType: "calc" }, starts: { x: { valType: "data_array", editType: "calc" }, y: { valType: "data_array", editType: "calc" }, z: { valType: "data_array", editType: "calc" }, editType: "calc" }, maxdisplayed: { valType: "integer", min: 0, dflt: 1e3, editType: "calc" }, sizeref: { valType: "number", editType: "calc", min: 0, dflt: 1 }, text: { valType: "string", dflt: "", editType: "calc" }, hovertext: { valType: "string", dflt: "", editType: "calc" }, hovertemplate: YDt({ editType: "calc" }, { keys: ["tubex", "tubey", "tubez", "tubeu", "tubev", "tubew", "norm", "divergence"] }), hovertemplatefallback: KDt({ editType: "calc" }), uhoverformat: e5("u", 1), vhoverformat: e5("v", 1), whoverformat: e5("w", 1), xhoverformat: e5("x"), yhoverformat: e5("y"), zhoverformat: e5("z"), showlegend: _Z({}, _Re.showlegend, { dflt: false }) };
+        _Z(mF, ZDt("", { colorAttr: "u/v/w norm", showScaleDflt: true, editTypeOverride: "calc" }));
+        var $Dt = ["opacity", "lightposition", "lighting"];
+        $Dt.forEach(function(e) {
+          mF[e] = JDt[e];
+        });
+        mF.hoverinfo = _Z({}, _Re.hoverinfo, { editType: "calc", flags: ["x", "y", "z", "u", "v", "w", "norm", "divergence", "text", "name"], dflt: "x+y+z+norm+text+name" });
+        xRe.exports = mF;
+      });
+      var wRe = ye((lmr, bRe) => {
+        var QDt = Dr(), eFt = td(), tFt = xZ();
+        bRe.exports = function(t, r, n, i) {
+          function a(h, d) {
+            return QDt.coerce(t, r, tFt, h, d);
+          }
+          var o = a("u"), s = a("v"), l = a("w"), u = a("x"), c = a("y"), f = a("z");
+          if (!o || !o.length || !s || !s.length || !l || !l.length || !u || !u.length || !c || !c.length || !f || !f.length) {
+            r.visible = false;
+            return;
+          }
+          a("starts.x"), a("starts.y"), a("starts.z"), a("maxdisplayed"), a("sizeref"), a("lighting.ambient"), a("lighting.diffuse"), a("lighting.specular"), a("lighting.roughness"), a("lighting.fresnel"), a("lightposition.x"), a("lightposition.y"), a("lightposition.z"), eFt(t, r, i, a, { prefix: "", cLetter: "c" }), a("text"), a("hovertext"), a("hovertemplate"), a("hovertemplatefallback"), a("uhoverformat"), a("vhoverformat"), a("whoverformat"), a("xhoverformat"), a("yhoverformat"), a("zhoverformat"), r._length = null;
+        };
+      });
+      var LRe = ye((umr, CRe) => {
+        var SRe = zd().gl_streamtube3d, rFt = SRe.createTubeMesh, iFt = Dr(), nFt = a1().parseColorScale, aFt = tc().extractOpts, TRe = $A(), MRe = { xaxis: 0, yaxis: 1, zaxis: 2 };
+        function ERe(e, t) {
+          this.scene = e, this.uid = t, this.mesh = null, this.data = null;
+        }
+        var wZ = ERe.prototype;
+        wZ.handlePick = function(e) {
+          var t = this.scene.fullSceneLayout, r = this.scene.dataScale;
+          function n(o, s) {
+            var l = t[s], u = r[MRe[s]];
+            return l.l2c(o) / u;
+          }
+          if (e.object === this.mesh) {
+            var i = e.data.position, a = e.data.velocity;
+            return e.traceCoordinate = [n(i[0], "xaxis"), n(i[1], "yaxis"), n(i[2], "zaxis"), n(a[0], "xaxis"), n(a[1], "yaxis"), n(a[2], "zaxis"), e.data.intensity * this.data._normMax, e.data.divergence], e.textLabel = this.data.hovertext || this.data.text, true;
+          }
+        };
+        function ARe(e) {
+          var t = e.length, r;
+          return t > 2 ? r = e.slice(1, t - 1) : t === 2 ? r = [(e[0] + e[1]) / 2] : r = e, r;
+        }
+        function bZ(e) {
+          var t = e.length;
+          return t === 1 ? [0.5, 0.5] : [e[1] - e[0], e[t - 1] - e[t - 2]];
+        }
+        function kRe(e, t) {
+          var r = e.fullSceneLayout, n = e.dataScale, i = t._len, a = {};
+          function o(z, O) {
+            var U = r[O], G = n[MRe[O]];
+            return iFt.simpleMap(z, function(Z) {
+              return U.d2l(Z) * G;
+            });
+          }
+          if (a.vectors = TRe(o(t._u, "xaxis"), o(t._v, "yaxis"), o(t._w, "zaxis"), i), !i) return { positions: [], cells: [] };
+          var s = o(t._Xs, "xaxis"), l = o(t._Ys, "yaxis"), u = o(t._Zs, "zaxis");
+          a.meshgrid = [s, l, u], a.gridFill = t._gridFill;
+          var c = t._slen;
+          if (c) a.startingPositions = TRe(o(t._startsX, "xaxis"), o(t._startsY, "yaxis"), o(t._startsZ, "zaxis"));
+          else {
+            for (var f = l[0], h = ARe(s), d = ARe(u), v = new Array(h.length * d.length), _ = 0, b = 0; b < h.length; b++) for (var p = 0; p < d.length; p++) v[_++] = [h[b], f, d[p]];
+            a.startingPositions = v;
+          }
+          a.colormap = nFt(t), a.tubeSize = t.sizeref, a.maxLength = t.maxdisplayed;
+          var k = o(t._xbnds, "xaxis"), E = o(t._ybnds, "yaxis"), T = o(t._zbnds, "zaxis"), L = bZ(s), x = bZ(l), C = bZ(u), M = [[k[0] - L[0], E[0] - x[0], T[0] - C[0]], [k[1] + L[1], E[1] + x[1], T[1] + C[1]]], g = SRe(a, M), P = aFt(t);
+          g.vertexIntensityBounds = [P.min / t._normMax, P.max / t._normMax];
+          var A = t.lightposition;
+          return g.lightPosition = [A.x, A.y, A.z], g.ambient = t.lighting.ambient, g.diffuse = t.lighting.diffuse, g.specular = t.lighting.specular, g.roughness = t.lighting.roughness, g.fresnel = t.lighting.fresnel, g.opacity = t.opacity, t._pad = g.tubeScale * t.sizeref * 2, g;
+        }
+        wZ.update = function(e) {
+          this.data = e;
+          var t = kRe(this.scene, e);
+          this.mesh.update(t);
+        };
+        wZ.dispose = function() {
+          this.scene.glplot.remove(this.mesh), this.mesh.dispose();
+        };
+        function oFt(e, t) {
+          var r = e.glplot.gl, n = kRe(e, t), i = rFt(r, n), a = new ERe(e, t.uid);
+          return a.mesh = i, a.data = t, i._trace = a, e.glplot.add(i), a;
+        }
+        CRe.exports = oFt;
+      });
+      var IRe = ye((cmr, PRe) => {
+        PRe.exports = { moduleType: "trace", name: "streamtube", basePlotModule: sx(), categories: ["gl3d", "showLegend"], attributes: xZ(), supplyDefaults: wRe(), colorbar: { min: "cmin", max: "cmax" }, calc: hF().calc, plot: LRe(), eventData: function(e, t) {
+          return e.tubex = e.x, e.tubey = e.y, e.tubez = e.z, e.tubeu = t.traceCoordinate[3], e.tubev = t.traceCoordinate[4], e.tubew = t.traceCoordinate[5], e.norm = t.traceCoordinate[6], e.divergence = t.traceCoordinate[7], delete e.x, delete e.y, delete e.z, e;
+        }, meta: {} };
+      });
+      var DRe = ye((fmr, RRe) => {
+        RRe.exports = IRe();
+      });
+      var ew = ye((dmr, BRe) => {
+        var { hovertemplateAttrs: sFt, texttemplateAttrs: lFt, templatefallbackAttrs: FRe } = Ll(), uFt = Pg(), $m = pf(), cFt = Gl(), zRe = Tu(), fFt = Pd().dash, Q2 = Ao().extendFlat, hFt = mc().overrideAll, rg = $m.marker, ORe = $m.line, qRe = rg.line;
+        BRe.exports = hFt({ lon: { valType: "data_array" }, lat: { valType: "data_array" }, locations: { valType: "data_array" }, locationmode: { valType: "enumerated", values: ["ISO-3", "USA-states", "country names", "geojson-id"], dflt: "ISO-3" }, geojson: { valType: "any", editType: "calc" }, featureidkey: { valType: "string", editType: "calc", dflt: "id" }, mode: Q2({}, $m.mode, { dflt: "markers" }), text: Q2({}, $m.text, {}), texttemplate: lFt({ editType: "plot" }, { keys: ["lat", "lon", "location", "text"] }), texttemplatefallback: FRe({ editType: "plot" }), hovertext: Q2({}, $m.hovertext, {}), textfont: $m.textfont, textposition: $m.textposition, line: { color: ORe.color, width: ORe.width, dash: fFt }, connectgaps: $m.connectgaps, marker: Q2({ symbol: rg.symbol, opacity: rg.opacity, angle: rg.angle, angleref: Q2({}, rg.angleref, { values: ["previous", "up", "north"] }), standoff: rg.standoff, size: rg.size, sizeref: rg.sizeref, sizemin: rg.sizemin, sizemode: rg.sizemode, colorbar: rg.colorbar, line: Q2({ width: qRe.width, dash: qRe.dash }, zRe("marker.line")), gradient: rg.gradient }, zRe("marker")), fill: { valType: "enumerated", values: ["none", "toself"], dflt: "none" }, fillcolor: uFt(), selected: $m.selected, unselected: $m.unselected, hoverinfo: Q2({}, cFt.hoverinfo, { flags: ["lon", "lat", "location", "text", "name"] }), hovertemplate: sFt(), hovertemplatefallback: FRe() }, "calc", "nested");
+      });
+      var URe = ye((vmr, NRe) => {
+        var yF = Dr(), TZ = Ru(), dFt = $p(), vFt = D0(), pFt = F0(), gFt = Fg(), mFt = ew(), yFt = ["The library used by the *country names* `locationmode` option is changing in the next major version.", "Some country names in existing plots may not work in the new version.", "To ensure consistent behavior, consider setting `locationmode` to *ISO-3*."].join(" ");
+        NRe.exports = function(t, r, n, i) {
+          function a(d, v) {
+            return yF.coerce(t, r, mFt, d, v);
+          }
+          var o = a("locations"), s;
+          if (o && o.length) {
+            var l = a("geojson"), u;
+            (typeof l == "string" && l !== "" || yF.isPlainObject(l)) && (u = "geojson-id");
+            var c = a("locationmode", u);
+            c === "country names" && yF.warn(yFt), c === "geojson-id" && a("featureidkey"), s = o.length;
+          } else {
+            var f = a("lon") || [], h = a("lat") || [];
+            s = Math.min(f.length, h.length);
+          }
+          if (!s) {
+            r.visible = false;
+            return;
+          }
+          r._length = s, a("text"), a("hovertext"), a("hovertemplate"), a("hovertemplatefallback"), a("mode"), TZ.hasMarkers(r) && dFt(t, r, n, i, a, { gradient: true }), TZ.hasLines(r) && (vFt(t, r, n, i, a), a("connectgaps")), TZ.hasText(r) && (a("texttemplate"), a("texttemplatefallback"), pFt(t, r, i, a)), a("fill"), r.fill !== "none" && gFt(t, r, n, a), yF.coerceSelectionMarkerOpacity(r, a);
+        };
+      });
+      var HRe = ye((pmr, GRe) => {
+        var VRe = ho();
+        GRe.exports = function(t, r, n) {
+          var i = {}, a = n[r.geo]._subplot, o = a.mockAxis, s = t.lonlat;
+          return i.lonLabel = VRe.tickText(o, o.c2l(s[0]), true).text, i.latLabel = VRe.tickText(o, o.c2l(s[1]), true).text, i;
+        };
+      });
+      var _F = ye((gmr, ZRe) => {
+        var AZ = Eo(), jRe = fs().BADNUM, _Ft = z0(), xFt = Rm(), bFt = O0(), wFt = Dr().isArrayOrTypedArray, WRe = Dr()._;
+        function XRe(e) {
+          return e && typeof e == "string";
+        }
+        ZRe.exports = function(t, r) {
+          var n = wFt(r.locations), i = n ? r.locations.length : r._length, a = new Array(i), o;
+          r.geojson ? o = function(h) {
+            return XRe(h) || AZ(h);
+          } : o = XRe;
+          for (var s = 0; s < i; s++) {
+            var l = a[s] = {};
+            if (n) {
+              var u = r.locations[s];
+              l.loc = o(u) ? u : null;
+            } else {
+              var c = r.lon[s], f = r.lat[s];
+              AZ(c) && AZ(f) ? l.lonlat = [+c, +f] : l.lonlat = [jRe, jRe];
+            }
+          }
+          return xFt(a, r), _Ft(t, r), bFt(a, r), i && (a[0].t = { labels: { lat: WRe(t, "lat:") + " ", lon: WRe(t, "lon:") + " " } }), a;
+        };
+      });
+      var uk = ye((Mv) => {
+        Mv.projNames = { airy: "airy", aitoff: "aitoff", "albers usa": "albersUsa", albers: "albers", august: "august", "azimuthal equal area": "azimuthalEqualArea", "azimuthal equidistant": "azimuthalEquidistant", baker: "baker", bertin1953: "bertin1953", boggs: "boggs", bonne: "bonne", bottomley: "bottomley", bromley: "bromley", collignon: "collignon", "conic conformal": "conicConformal", "conic equal area": "conicEqualArea", "conic equidistant": "conicEquidistant", craig: "craig", craster: "craster", "cylindrical equal area": "cylindricalEqualArea", "cylindrical stereographic": "cylindricalStereographic", eckert1: "eckert1", eckert2: "eckert2", eckert3: "eckert3", eckert4: "eckert4", eckert5: "eckert5", eckert6: "eckert6", eisenlohr: "eisenlohr", "equal earth": "equalEarth", equirectangular: "equirectangular", fahey: "fahey", "foucaut sinusoidal": "foucautSinusoidal", foucaut: "foucaut", ginzburg4: "ginzburg4", ginzburg5: "ginzburg5", ginzburg6: "ginzburg6", ginzburg8: "ginzburg8", ginzburg9: "ginzburg9", gnomonic: "gnomonic", "gringorten quincuncial": "gringortenQuincuncial", gringorten: "gringorten", guyou: "guyou", hammer: "hammer", hill: "hill", homolosine: "homolosine", hufnagel: "hufnagel", hyperelliptical: "hyperelliptical", kavrayskiy7: "kavrayskiy7", lagrange: "lagrange", larrivee: "larrivee", laskowski: "laskowski", loximuthal: "loximuthal", mercator: "mercator", miller: "miller", mollweide: "mollweide", "mt flat polar parabolic": "mtFlatPolarParabolic", "mt flat polar quartic": "mtFlatPolarQuartic", "mt flat polar sinusoidal": "mtFlatPolarSinusoidal", "natural earth": "naturalEarth", "natural earth1": "naturalEarth1", "natural earth2": "naturalEarth2", "nell hammer": "nellHammer", nicolosi: "nicolosi", orthographic: "orthographic", patterson: "patterson", "peirce quincuncial": "peirceQuincuncial", polyconic: "polyconic", "rectangular polyconic": "rectangularPolyconic", robinson: "robinson", satellite: "satellite", "sinu mollweide": "sinuMollweide", sinusoidal: "sinusoidal", stereographic: "stereographic", times: "times", "transverse mercator": "transverseMercator", "van der grinten": "vanDerGrinten", "van der grinten2": "vanDerGrinten2", "van der grinten3": "vanDerGrinten3", "van der grinten4": "vanDerGrinten4", wagner4: "wagner4", wagner6: "wagner6", wiechel: "wiechel", "winkel tripel": "winkel3", winkel3: "winkel3" };
+        Mv.axesNames = ["lonaxis", "lataxis"];
+        Mv.lonaxisSpan = { orthographic: 180, "azimuthal equal area": 360, "azimuthal equidistant": 360, "conic conformal": 180, gnomonic: 160, stereographic: 180, "transverse mercator": 180, "*": 360 };
+        Mv.lataxisSpan = { "conic conformal": 150, stereographic: 179.5, "*": 180 };
+        Mv.scopeDefaults = { world: { lonaxisRange: [-180, 180], lataxisRange: [-90, 90], projType: "equirectangular", projRotate: [0, 0, 0] }, usa: { lonaxisRange: [-180, -50], lataxisRange: [15, 80], projType: "albers usa" }, europe: { lonaxisRange: [-30, 60], lataxisRange: [30, 85], projType: "conic conformal", projRotate: [15, 0, 0], projParallels: [0, 60] }, asia: { lonaxisRange: [22, 160], lataxisRange: [-15, 55], projType: "mercator", projRotate: [0, 0, 0] }, africa: { lonaxisRange: [-30, 60], lataxisRange: [-40, 40], projType: "mercator", projRotate: [0, 0, 0] }, "north america": { lonaxisRange: [-180, -45], lataxisRange: [5, 85], projType: "conic conformal", projRotate: [-100, 0, 0], projParallels: [29.5, 45.5] }, "south america": { lonaxisRange: [-100, -30], lataxisRange: [-60, 15], projType: "mercator", projRotate: [0, 0, 0] }, antarctica: { lonaxisRange: [-180, 180], lataxisRange: [-90, -60], projType: "equirectangular", projRotate: [0, 0, 0] }, oceania: { lonaxisRange: [-180, 180], lataxisRange: [-50, 25], projType: "equirectangular", projRotate: [0, 0, 0] } };
+        Mv.clipPad = 1e-3;
+        Mv.precision = 0.1;
+        Mv.landColor = "#F0DC82";
+        Mv.waterColor = "#3399FF";
+        Mv.locationmodeToLayer = { "ISO-3": "countries", "USA-states": "subunits", "country names": "countries" };
+        Mv.sphereSVG = { type: "Sphere" };
+        Mv.fillLayers = { ocean: 1, land: 1, lakes: 1 };
+        Mv.lineLayers = { subunits: 1, countries: 1, coastlines: 1, rivers: 1, frame: 1 };
+        Mv.layers = ["bg", "ocean", "land", "lakes", "subunits", "countries", "coastlines", "rivers", "lataxis", "lonaxis", "frame", "backplot", "frontplot"];
+        Mv.layersForChoropleth = ["bg", "ocean", "land", "subunits", "countries", "coastlines", "lataxis", "lonaxis", "frame", "backplot", "rivers", "lakes", "frontplot"];
+        Mv.layerNameToAdjective = { ocean: "ocean", land: "land", lakes: "lake", subunits: "subunit", countries: "country", coastlines: "coastline", rivers: "river", frame: "frame" };
+      });
+      var SZ = ye((xF, YRe) => {
+        (function(e, t) {
+          typeof xF == "object" && typeof YRe != "undefined" ? t(xF) : (e = e || self, t(e.topojson = e.topojson || {}));
+        })(xF, function(e) {
+          function t(E) {
+            return E;
+          }
+          function r(E) {
+            if (E == null) return t;
+            var T, L, x = E.scale[0], C = E.scale[1], M = E.translate[0], g = E.translate[1];
+            return function(P, A) {
+              A || (T = L = 0);
+              var z = 2, O = P.length, U = new Array(O);
+              for (U[0] = (T += P[0]) * x + M, U[1] = (L += P[1]) * C + g; z < O; ) U[z] = P[z], ++z;
+              return U;
+            };
+          }
+          function n(E) {
+            var T = r(E.transform), L, x = 1 / 0, C = x, M = -x, g = -x;
+            function P(z) {
+              z = T(z), z[0] < x && (x = z[0]), z[0] > M && (M = z[0]), z[1] < C && (C = z[1]), z[1] > g && (g = z[1]);
+            }
+            function A(z) {
+              switch (z.type) {
+                case "GeometryCollection":
+                  z.geometries.forEach(A);
+                  break;
+                case "Point":
+                  P(z.coordinates);
+                  break;
+                case "MultiPoint":
+                  z.coordinates.forEach(P);
+                  break;
+              }
+            }
+            E.arcs.forEach(function(z) {
+              for (var O = -1, U = z.length, G; ++O < U; ) G = T(z[O], O), G[0] < x && (x = G[0]), G[0] > M && (M = G[0]), G[1] < C && (C = G[1]), G[1] > g && (g = G[1]);
+            });
+            for (L in E.objects) A(E.objects[L]);
+            return [x, C, M, g];
+          }
+          function i(E, T) {
+            for (var L, x = E.length, C = x - T; C < --x; ) L = E[C], E[C++] = E[x], E[x] = L;
+          }
+          function a(E, T) {
+            return typeof T == "string" && (T = E.objects[T]), T.type === "GeometryCollection" ? { type: "FeatureCollection", features: T.geometries.map(function(L) {
+              return o(E, L);
+            }) } : o(E, T);
+          }
+          function o(E, T) {
+            var L = T.id, x = T.bbox, C = T.properties == null ? {} : T.properties, M = s(E, T);
+            return L == null && x == null ? { type: "Feature", properties: C, geometry: M } : x == null ? { type: "Feature", id: L, properties: C, geometry: M } : { type: "Feature", id: L, bbox: x, properties: C, geometry: M };
+          }
+          function s(E, T) {
+            var L = r(E.transform), x = E.arcs;
+            function C(O, U) {
+              U.length && U.pop();
+              for (var G = x[O < 0 ? ~O : O], Z = 0, j = G.length; Z < j; ++Z) U.push(L(G[Z], Z));
+              O < 0 && i(U, j);
+            }
+            function M(O) {
+              return L(O);
+            }
+            function g(O) {
+              for (var U = [], G = 0, Z = O.length; G < Z; ++G) C(O[G], U);
+              return U.length < 2 && U.push(U[0]), U;
+            }
+            function P(O) {
+              for (var U = g(O); U.length < 4; ) U.push(U[0]);
+              return U;
+            }
+            function A(O) {
+              return O.map(P);
+            }
+            function z(O) {
+              var U = O.type, G;
+              switch (U) {
+                case "GeometryCollection":
+                  return { type: U, geometries: O.geometries.map(z) };
+                case "Point":
+                  G = M(O.coordinates);
+                  break;
+                case "MultiPoint":
+                  G = O.coordinates.map(M);
+                  break;
+                case "LineString":
+                  G = g(O.arcs);
+                  break;
+                case "MultiLineString":
+                  G = O.arcs.map(g);
+                  break;
+                case "Polygon":
+                  G = A(O.arcs);
+                  break;
+                case "MultiPolygon":
+                  G = O.arcs.map(A);
+                  break;
+                default:
+                  return null;
+              }
+              return { type: U, coordinates: G };
+            }
+            return z(T);
+          }
+          function l(E, T) {
+            var L = {}, x = {}, C = {}, M = [], g = -1;
+            T.forEach(function(z, O) {
+              var U = E.arcs[z < 0 ? ~z : z], G;
+              U.length < 3 && !U[1][0] && !U[1][1] && (G = T[++g], T[g] = z, T[O] = G);
+            }), T.forEach(function(z) {
+              var O = P(z), U = O[0], G = O[1], Z, j;
+              if (Z = C[U]) if (delete C[Z.end], Z.push(z), Z.end = G, j = x[G]) {
+                delete x[j.start];
+                var N = j === Z ? Z : Z.concat(j);
+                x[N.start = Z.start] = C[N.end = j.end] = N;
+              } else x[Z.start] = C[Z.end] = Z;
+              else if (Z = x[G]) if (delete x[Z.start], Z.unshift(z), Z.start = U, j = C[U]) {
+                delete C[j.end];
+                var H = j === Z ? Z : j.concat(Z);
+                x[H.start = j.start] = C[H.end = Z.end] = H;
+              } else x[Z.start] = C[Z.end] = Z;
+              else Z = [z], x[Z.start = U] = C[Z.end = G] = Z;
+            });
+            function P(z) {
+              var O = E.arcs[z < 0 ? ~z : z], U = O[0], G;
+              return E.transform ? (G = [0, 0], O.forEach(function(Z) {
+                G[0] += Z[0], G[1] += Z[1];
+              })) : G = O[O.length - 1], z < 0 ? [G, U] : [U, G];
+            }
+            function A(z, O) {
+              for (var U in z) {
+                var G = z[U];
+                delete O[G.start], delete G.start, delete G.end, G.forEach(function(Z) {
+                  L[Z < 0 ? ~Z : Z] = 1;
+                }), M.push(G);
+              }
+            }
+            return A(C, x), A(x, C), T.forEach(function(z) {
+              L[z < 0 ? ~z : z] || M.push([z]);
+            }), M;
+          }
+          function u(E) {
+            return s(E, c.apply(this, arguments));
+          }
+          function c(E, T, L) {
+            var x, C, M;
+            if (arguments.length > 1) x = f(E, T, L);
+            else for (C = 0, x = new Array(M = E.arcs.length); C < M; ++C) x[C] = C;
+            return { type: "MultiLineString", arcs: l(E, x) };
+          }
+          function f(E, T, L) {
+            var x = [], C = [], M;
+            function g(U) {
+              var G = U < 0 ? ~U : U;
+              (C[G] || (C[G] = [])).push({ i: U, g: M });
+            }
+            function P(U) {
+              U.forEach(g);
+            }
+            function A(U) {
+              U.forEach(P);
+            }
+            function z(U) {
+              U.forEach(A);
+            }
+            function O(U) {
+              switch (M = U, U.type) {
+                case "GeometryCollection":
+                  U.geometries.forEach(O);
+                  break;
+                case "LineString":
+                  P(U.arcs);
+                  break;
+                case "MultiLineString":
+                case "Polygon":
+                  A(U.arcs);
+                  break;
+                case "MultiPolygon":
+                  z(U.arcs);
+                  break;
+              }
+            }
+            return O(T), C.forEach(L == null ? function(U) {
+              x.push(U[0].i);
+            } : function(U) {
+              L(U[0].g, U[U.length - 1].g) && x.push(U[0].i);
+            }), x;
+          }
+          function h(E) {
+            for (var T = -1, L = E.length, x, C = E[L - 1], M = 0; ++T < L; ) x = C, C = E[T], M += x[0] * C[1] - x[1] * C[0];
+            return Math.abs(M);
+          }
+          function d(E) {
+            return s(E, v.apply(this, arguments));
+          }
+          function v(E, T) {
+            var L = {}, x = [], C = [];
+            T.forEach(M);
+            function M(A) {
+              switch (A.type) {
+                case "GeometryCollection":
+                  A.geometries.forEach(M);
+                  break;
+                case "Polygon":
+                  g(A.arcs);
+                  break;
+                case "MultiPolygon":
+                  A.arcs.forEach(g);
+                  break;
+              }
+            }
+            function g(A) {
+              A.forEach(function(z) {
+                z.forEach(function(O) {
+                  (L[O = O < 0 ? ~O : O] || (L[O] = [])).push(A);
+                });
+              }), x.push(A);
+            }
+            function P(A) {
+              return h(s(E, { type: "Polygon", arcs: [A] }).coordinates[0]);
+            }
+            return x.forEach(function(A) {
+              if (!A._) {
+                var z = [], O = [A];
+                for (A._ = 1, C.push(z); A = O.pop(); ) z.push(A), A.forEach(function(U) {
+                  U.forEach(function(G) {
+                    L[G < 0 ? ~G : G].forEach(function(Z) {
+                      Z._ || (Z._ = 1, O.push(Z));
+                    });
+                  });
+                });
+              }
+            }), x.forEach(function(A) {
+              delete A._;
+            }), { type: "MultiPolygon", arcs: C.map(function(A) {
+              var z = [], O;
+              if (A.forEach(function(N) {
+                N.forEach(function(H) {
+                  H.forEach(function(re) {
+                    L[re < 0 ? ~re : re].length < 2 && z.push(re);
+                  });
+                });
+              }), z = l(E, z), (O = z.length) > 1) for (var U = 1, G = P(z[0]), Z, j; U < O; ++U) (Z = P(z[U])) > G && (j = z[0], z[0] = z[U], z[U] = j, G = Z);
+              return z;
+            }).filter(function(A) {
+              return A.length > 0;
+            }) };
+          }
+          function _(E, T) {
+            for (var L = 0, x = E.length; L < x; ) {
+              var C = L + x >>> 1;
+              E[C] < T ? L = C + 1 : x = C;
+            }
+            return L;
+          }
+          function b(E) {
+            var T = {}, L = E.map(function() {
+              return [];
+            });
+            function x(N, H) {
+              N.forEach(function(re) {
+                re < 0 && (re = ~re);
+                var oe = T[re];
+                oe ? oe.push(H) : T[re] = [H];
+              });
+            }
+            function C(N, H) {
+              N.forEach(function(re) {
+                x(re, H);
+              });
+            }
+            function M(N, H) {
+              N.type === "GeometryCollection" ? N.geometries.forEach(function(re) {
+                M(re, H);
+              }) : N.type in g && g[N.type](N.arcs, H);
+            }
+            var g = { LineString: x, MultiLineString: C, Polygon: C, MultiPolygon: function(N, H) {
+              N.forEach(function(re) {
+                C(re, H);
+              });
+            } };
+            E.forEach(M);
+            for (var P in T) for (var A = T[P], z = A.length, O = 0; O < z; ++O) for (var U = O + 1; U < z; ++U) {
+              var G = A[O], Z = A[U], j;
+              (j = L[G])[P = _(j, Z)] !== Z && j.splice(P, 0, Z), (j = L[Z])[P = _(j, G)] !== G && j.splice(P, 0, G);
+            }
+            return L;
+          }
+          function p(E) {
+            if (E == null) return t;
+            var T, L, x = E.scale[0], C = E.scale[1], M = E.translate[0], g = E.translate[1];
+            return function(P, A) {
+              A || (T = L = 0);
+              var z = 2, O = P.length, U = new Array(O), G = Math.round((P[0] - M) / x), Z = Math.round((P[1] - g) / C);
+              for (U[0] = G - T, T = G, U[1] = Z - L, L = Z; z < O; ) U[z] = P[z], ++z;
+              return U;
+            };
+          }
+          function k(E, T) {
+            if (E.transform) throw new Error("already quantized");
+            if (!T || !T.scale) {
+              if (!((g = Math.floor(T)) >= 2)) throw new Error("n must be ≥2");
+              A = E.bbox || n(E);
+              var L = A[0], x = A[1], C = A[2], M = A[3], g;
+              T = { scale: [C - L ? (C - L) / (g - 1) : 1, M - x ? (M - x) / (g - 1) : 1], translate: [L, x] };
+            } else A = E.bbox;
+            var P = p(T), A, z, O = E.objects, U = {};
+            function G(N) {
+              return P(N);
+            }
+            function Z(N) {
+              var H;
+              switch (N.type) {
+                case "GeometryCollection":
+                  H = { type: "GeometryCollection", geometries: N.geometries.map(Z) };
+                  break;
+                case "Point":
+                  H = { type: "Point", coordinates: G(N.coordinates) };
+                  break;
+                case "MultiPoint":
+                  H = { type: "MultiPoint", coordinates: N.coordinates.map(G) };
+                  break;
+                default:
+                  return N;
+              }
+              return N.id != null && (H.id = N.id), N.bbox != null && (H.bbox = N.bbox), N.properties != null && (H.properties = N.properties), H;
+            }
+            function j(N) {
+              var H = 0, re = 1, oe = N.length, _e, Ce = new Array(oe);
+              for (Ce[0] = P(N[0], 0); ++H < oe; ) ((_e = P(N[H], H))[0] || _e[1]) && (Ce[re++] = _e);
+              return re === 1 && (Ce[re++] = [0, 0]), Ce.length = re, Ce;
+            }
+            for (z in O) U[z] = Z(O[z]);
+            return { type: "Topology", bbox: A, transform: T, objects: U, arcs: E.arcs.map(j) };
+          }
+          e.bbox = n, e.feature = a, e.merge = d, e.mergeArcs = v, e.mesh = u, e.meshArcs = c, e.neighbors = b, e.quantize = k, e.transform = r, e.untransform = p, Object.defineProperty(e, "__esModule", { value: true });
+        });
+      });
+      var bF = ye((ymr, KRe) => {
+        var MZ = KRe.exports = {}, TFt = uk().locationmodeToLayer, AFt = SZ().feature;
+        MZ.getTopojsonName = function(e) {
+          return [e.scope.replace(/ /g, "-"), "_", e.resolution.toString(), "m"].join("");
+        };
+        MZ.getTopojsonPath = function(e, t) {
+          return e += e.endsWith("/") ? "" : "/", `${e}${t}.json`;
+        };
+        MZ.getTopojsonFeatures = function(e, t) {
+          var r = TFt[e.locationmode], n = t.objects[r];
+          return AFt(t, n).features;
+        };
+      });
+      var cx = ye((ck) => {
+        var SFt = fs().BADNUM;
+        ck.calcTraceToLineCoords = function(e) {
+          for (var t = e[0].trace, r = t.connectgaps, n = [], i = [], a = 0; a < e.length; a++) {
+            var o = e[a], s = o.lonlat;
+            s[0] !== SFt ? i.push(s) : !r && i.length > 0 && (n.push(i), i = []);
+          }
+          return i.length > 0 && n.push(i), n;
+        };
+        ck.makeLine = function(e) {
+          return e.length === 1 ? { type: "LineString", coordinates: e[0] } : { type: "MultiLineString", coordinates: e };
+        };
+        ck.makePolygon = function(e) {
+          if (e.length === 1) return { type: "Polygon", coordinates: e };
+          for (var t = new Array(e.length), r = 0; r < e.length; r++) t[r] = [e[r]];
+          return { type: "MultiPolygon", coordinates: t };
+        };
+        ck.makeBlank = function() {
+          return { type: "Point", coordinates: [] };
+        };
+      });
+      var $Re = ye((xmr, JRe) => {
+        JRe.exports = { AFG: "afghan", ALA: "\\b\\wland", ALB: "albania", DZA: "algeria", ASM: "^(?=.*americ).*samoa", AND: "andorra", AGO: "angola", AIA: "anguill?a", ATA: "antarctica", ATG: "antigua", ARG: "argentin", ARM: "armenia", ABW: "^(?!.*bonaire).*\\baruba", AUS: "australia", AUT: "^(?!.*hungary).*austria|\\baustri.*\\bemp", AZE: "azerbaijan", BHS: "bahamas", BHR: "bahrain", BGD: "bangladesh|^(?=.*east).*paki?stan", BRB: "barbados", BLR: "belarus|byelo", BEL: "^(?!.*luxem).*belgium", BLZ: "belize|^(?=.*british).*honduras", BEN: "benin|dahome", BMU: "bermuda", BTN: "bhutan", BOL: "bolivia", BES: "^(?=.*bonaire).*eustatius|^(?=.*carib).*netherlands|\\bbes.?islands", BIH: "herzegovina|bosnia", BWA: "botswana|bechuana", BVT: "bouvet", BRA: "brazil", IOT: "british.?indian.?ocean", BRN: "brunei", BGR: "bulgaria", BFA: "burkina|\\bfaso|upper.?volta", BDI: "burundi", CPV: "verde", KHM: "cambodia|kampuchea|khmer", CMR: "cameroon", CAN: "canada", CYM: "cayman", CAF: "\\bcentral.african.republic", TCD: "\\bchad", CHL: "\\bchile", CHN: "^(?!.*\\bmac)(?!.*\\bhong)(?!.*\\btai)(?!.*\\brep).*china|^(?=.*peo)(?=.*rep).*china", CXR: "christmas", CCK: "\\bcocos|keeling", COL: "colombia", COM: "comoro", COG: "^(?!.*\\bdem)(?!.*\\bd[\\.]?r)(?!.*kinshasa)(?!.*zaire)(?!.*belg)(?!.*l.opoldville)(?!.*free).*\\bcongo", COK: "\\bcook", CRI: "costa.?rica", CIV: "ivoire|ivory", HRV: "croatia", CUB: "\\bcuba", CUW: "^(?!.*bonaire).*\\bcura(c|ç)ao", CYP: "cyprus", CSK: "czechoslovakia", CZE: "^(?=.*rep).*czech|czechia|bohemia", COD: "\\bdem.*congo|congo.*\\bdem|congo.*\\bd[\\.]?r|\\bd[\\.]?r.*congo|belgian.?congo|congo.?free.?state|kinshasa|zaire|l.opoldville|drc|droc|rdc", DNK: "denmark", DJI: "djibouti", DMA: "dominica(?!n)", DOM: "dominican.rep", ECU: "ecuador", EGY: "egypt", SLV: "el.?salvador", GNQ: "guine.*eq|eq.*guine|^(?=.*span).*guinea", ERI: "eritrea", EST: "estonia", ETH: "ethiopia|abyssinia", FLK: "falkland|malvinas", FRO: "faroe|faeroe", FJI: "fiji", FIN: "finland", FRA: "^(?!.*\\bdep)(?!.*martinique).*france|french.?republic|\\bgaul", GUF: "^(?=.*french).*guiana", PYF: "french.?polynesia|tahiti", ATF: "french.?southern", GAB: "gabon", GMB: "gambia", GEO: "^(?!.*south).*georgia", DDR: "german.?democratic.?republic|democratic.?republic.*germany|east.germany", DEU: "^(?!.*east).*germany|^(?=.*\\bfed.*\\brep).*german", GHA: "ghana|gold.?coast", GIB: "gibraltar", GRC: "greece|hellenic|hellas", GRL: "greenland", GRD: "grenada", GLP: "guadeloupe", GUM: "\\bguam", GTM: "guatemala", GGY: "guernsey", GIN: "^(?!.*eq)(?!.*span)(?!.*bissau)(?!.*portu)(?!.*new).*guinea", GNB: "bissau|^(?=.*portu).*guinea", GUY: "guyana|british.?guiana", HTI: "haiti", HMD: "heard.*mcdonald", VAT: "holy.?see|vatican|papal.?st", HND: "^(?!.*brit).*honduras", HKG: "hong.?kong", HUN: "^(?!.*austr).*hungary", ISL: "iceland", IND: "india(?!.*ocea)", IDN: "indonesia", IRN: "\\biran|persia", IRQ: "\\biraq|mesopotamia", IRL: "(^ireland)|(^republic.*ireland)", IMN: "^(?=.*isle).*\\bman", ISR: "israel", ITA: "italy", JAM: "jamaica", JPN: "japan", JEY: "jersey", JOR: "jordan", KAZ: "kazak", KEN: "kenya|british.?east.?africa|east.?africa.?prot", KIR: "kiribati", PRK: "^(?=.*democrat|people|north|d.*p.*.r).*\\bkorea|dprk|korea.*(d.*p.*r)", KWT: "kuwait", KGZ: "kyrgyz|kirghiz", LAO: "\\blaos?\\b", LVA: "latvia", LBN: "lebanon", LSO: "lesotho|basuto", LBR: "liberia", LBY: "libya", LIE: "liechtenstein", LTU: "lithuania", LUX: "^(?!.*belg).*luxem", MAC: "maca(o|u)", MDG: "madagascar|malagasy", MWI: "malawi|nyasa", MYS: "malaysia", MDV: "maldive", MLI: "\\bmali\\b", MLT: "\\bmalta", MHL: "marshall", MTQ: "martinique", MRT: "mauritania", MUS: "mauritius", MYT: "\\bmayotte", MEX: "\\bmexic", FSM: "fed.*micronesia|micronesia.*fed", MCO: "monaco", MNG: "mongolia", MNE: "^(?!.*serbia).*montenegro", MSR: "montserrat", MAR: "morocco|\\bmaroc", MOZ: "mozambique", MMR: "myanmar|burma", NAM: "namibia", NRU: "nauru", NPL: "nepal", NLD: "^(?!.*\\bant)(?!.*\\bcarib).*netherlands", ANT: "^(?=.*\\bant).*(nether|dutch)", NCL: "new.?caledonia", NZL: "new.?zealand", NIC: "nicaragua", NER: "\\bniger(?!ia)", NGA: "nigeria", NIU: "niue", NFK: "norfolk", MNP: "mariana", NOR: "norway", OMN: "\\boman|trucial", PAK: "^(?!.*east).*paki?stan", PLW: "palau", PSE: "palestin|\\bgaza|west.?bank", PAN: "panama", PNG: "papua|new.?guinea", PRY: "paraguay", PER: "peru", PHL: "philippines", PCN: "pitcairn", POL: "poland", PRT: "portugal", PRI: "puerto.?rico", QAT: "qatar", KOR: "^(?!.*d.*p.*r)(?!.*democrat)(?!.*people)(?!.*north).*\\bkorea(?!.*d.*p.*r)", MDA: "moldov|b(a|e)ssarabia", REU: "r(e|é)union", ROU: "r(o|u|ou)mania", RUS: "\\brussia|soviet.?union|u\\.?s\\.?s\\.?r|socialist.?republics", RWA: "rwanda", BLM: "barth(e|é)lemy", SHN: "helena", KNA: "kitts|\\bnevis", LCA: "\\blucia", MAF: "^(?=.*collectivity).*martin|^(?=.*france).*martin(?!ique)|^(?=.*french).*martin(?!ique)", SPM: "miquelon", VCT: "vincent", WSM: "^(?!.*amer).*samoa", SMR: "san.?marino", STP: "\\bs(a|ã)o.?tom(e|é)", SAU: "\\bsa\\w*.?arabia", SEN: "senegal", SRB: "^(?!.*monte).*serbia", SYC: "seychell", SLE: "sierra", SGP: "singapore", SXM: "^(?!.*martin)(?!.*saba).*maarten", SVK: "^(?!.*cze).*slovak", SVN: "slovenia", SLB: "solomon", SOM: "somali", ZAF: "south.africa|s\\\\..?africa", SGS: "south.?georgia|sandwich", SSD: "\\bs\\w*.?sudan", ESP: "spain", LKA: "sri.?lanka|ceylon", SDN: "^(?!.*\\bs(?!u)).*sudan", SUR: "surinam|dutch.?guiana", SJM: "svalbard", SWZ: "swaziland", SWE: "sweden", CHE: "switz|swiss", SYR: "syria", TWN: "taiwan|taipei|formosa|^(?!.*peo)(?=.*rep).*china", TJK: "tajik", THA: "thailand|\\bsiam", MKD: "macedonia|fyrom", TLS: "^(?=.*leste).*timor|^(?=.*east).*timor", TGO: "togo", TKL: "tokelau", TON: "tonga", TTO: "trinidad|tobago", TUN: "tunisia", TUR: "turkey", TKM: "turkmen", TCA: "turks", TUV: "tuvalu", UGA: "uganda", UKR: "ukrain", ARE: "emirates|^u\\.?a\\.?e\\.?$|united.?arab.?em", GBR: "united.?kingdom|britain|^u\\.?k\\.?$", TZA: "tanzania", USA: "united.?states\\b(?!.*islands)|\\bu\\.?s\\.?a\\.?\\b|^\\s*u\\.?s\\.?\\b(?!.*islands)", UMI: "minor.?outlying.?is", URY: "uruguay", UZB: "uzbek", VUT: "vanuatu|new.?hebrides", VEN: "venezuela", VNM: "^(?!.*republic).*viet.?nam|^(?=.*socialist).*viet.?nam", VGB: "^(?=.*\\bu\\.?\\s?k).*virgin|^(?=.*brit).*virgin|^(?=.*kingdom).*virgin", VIR: "^(?=.*\\bu\\.?\\s?s).*virgin|^(?=.*states).*virgin", WLF: "futuna|wallis", ESH: "western.sahara", YEM: "^(?!.*arab)(?!.*north)(?!.*sana)(?!.*peo)(?!.*dem)(?!.*south)(?!.*aden)(?!.*\\bp\\.?d\\.?r).*yemen", YMD: "^(?=.*peo).*yemen|^(?!.*rep)(?=.*dem).*yemen|^(?=.*south).*yemen|^(?=.*aden).*yemen|^(?=.*\\bp\\.?d\\.?r).*yemen", YUG: "yugoslavia", ZMB: "zambia|northern.?rhodesia", EAZ: "zanzibar", ZWE: "zimbabwe|^(?!.*northern).*rhodesia" };
+      });
+      var AF = ye((ic) => {
+        Object.defineProperty(ic, "__esModule", { value: true });
+        var Op = 63710088e-1, kZ = { centimeters: Op * 100, centimetres: Op * 100, degrees: 360 / (2 * Math.PI), feet: Op * 3.28084, inches: Op * 39.37, kilometers: Op / 1e3, kilometres: Op / 1e3, meters: Op, metres: Op, miles: Op / 1609.344, millimeters: Op * 1e3, millimetres: Op * 1e3, nauticalmiles: Op / 1852, radians: 1, yards: Op * 1.0936 }, EZ = { acres: 247105e-9, centimeters: 1e4, centimetres: 1e4, feet: 10.763910417, hectares: 1e-4, inches: 1550.003100006, kilometers: 1e-6, kilometres: 1e-6, meters: 1, metres: 1, miles: 386e-9, nauticalmiles: 29155334959812285e-23, millimeters: 1e6, millimetres: 1e6, yards: 1.195990046 };
+        function fx(e, t, r = {}) {
+          let n = { type: "Feature" };
+          return (r.id === 0 || r.id) && (n.id = r.id), r.bbox && (n.bbox = r.bbox), n.properties = t || {}, n.geometry = e, n;
+        }
+        function MFt(e, t, r = {}) {
+          switch (e) {
+            case "Point":
+              return CZ(t).geometry;
+            case "LineString":
+              return PZ(t).geometry;
+            case "Polygon":
+              return LZ(t).geometry;
+            case "MultiPoint":
+              return eDe(t).geometry;
+            case "MultiLineString":
+              return QRe(t).geometry;
+            case "MultiPolygon":
+              return tDe(t).geometry;
+            default:
+              throw new Error(e + " is invalid");
+          }
+        }
+        function CZ(e, t, r = {}) {
+          if (!e) throw new Error("coordinates is required");
+          if (!Array.isArray(e)) throw new Error("coordinates must be an Array");
+          if (e.length < 2) throw new Error("coordinates must be at least 2 numbers long");
+          if (!wF(e[0]) || !wF(e[1])) throw new Error("coordinates must contain numbers");
+          return fx({ type: "Point", coordinates: e }, t, r);
+        }
+        function EFt(e, t, r = {}) {
+          return TF(e.map((n) => CZ(n, t)), r);
+        }
+        function LZ(e, t, r = {}) {
+          for (let i of e) {
+            if (i.length < 4) throw new Error("Each LinearRing of a Polygon must have 4 or more Positions.");
+            if (i[i.length - 1].length !== i[0].length) throw new Error("First and last Position are not equivalent.");
+            for (let a = 0; a < i[i.length - 1].length; a++) if (i[i.length - 1][a] !== i[0][a]) throw new Error("First and last Position are not equivalent.");
+          }
+          return fx({ type: "Polygon", coordinates: e }, t, r);
+        }
+        function kFt(e, t, r = {}) {
+          return TF(e.map((n) => LZ(n, t)), r);
+        }
+        function PZ(e, t, r = {}) {
+          if (e.length < 2) throw new Error("coordinates must be an array of two or more positions");
+          return fx({ type: "LineString", coordinates: e }, t, r);
+        }
+        function CFt(e, t, r = {}) {
+          return TF(e.map((n) => PZ(n, t)), r);
+        }
+        function TF(e, t = {}) {
+          let r = { type: "FeatureCollection" };
+          return t.id && (r.id = t.id), t.bbox && (r.bbox = t.bbox), r.features = e, r;
+        }
+        function QRe(e, t, r = {}) {
+          return fx({ type: "MultiLineString", coordinates: e }, t, r);
+        }
+        function eDe(e, t, r = {}) {
+          return fx({ type: "MultiPoint", coordinates: e }, t, r);
+        }
+        function tDe(e, t, r = {}) {
+          return fx({ type: "MultiPolygon", coordinates: e }, t, r);
+        }
+        function LFt(e, t, r = {}) {
+          return fx({ type: "GeometryCollection", geometries: e }, t, r);
+        }
+        function PFt(e, t = 0) {
+          if (t && !(t >= 0)) throw new Error("precision must be a positive number");
+          let r = Math.pow(10, t || 0);
+          return Math.round(e * r) / r;
+        }
+        function rDe(e, t = "kilometers") {
+          let r = kZ[t];
+          if (!r) throw new Error(t + " units is invalid");
+          return e * r;
+        }
+        function IZ(e, t = "kilometers") {
+          let r = kZ[t];
+          if (!r) throw new Error(t + " units is invalid");
+          return e / r;
+        }
+        function IFt(e, t) {
+          return iDe(IZ(e, t));
+        }
+        function RFt(e) {
+          let t = e % 360;
+          return t < 0 && (t += 360), t;
+        }
+        function DFt(e) {
+          return e = e % 360, e > 180 ? e - 360 : e < -180 ? e + 360 : e;
+        }
+        function iDe(e) {
+          return e % (2 * Math.PI) * 180 / Math.PI;
+        }
+        function FFt(e) {
+          return e % 360 * Math.PI / 180;
+        }
+        function zFt(e, t = "kilometers", r = "kilometers") {
+          if (!(e >= 0)) throw new Error("length must be a positive number");
+          return rDe(IZ(e, t), r);
+        }
+        function OFt(e, t = "meters", r = "kilometers") {
+          if (!(e >= 0)) throw new Error("area must be a positive number");
+          let n = EZ[t];
+          if (!n) throw new Error("invalid original units");
+          let i = EZ[r];
+          if (!i) throw new Error("invalid final units");
+          return e / n * i;
+        }
+        function wF(e) {
+          return !isNaN(e) && e !== null && !Array.isArray(e);
+        }
+        function qFt(e) {
+          return e !== null && typeof e == "object" && !Array.isArray(e);
+        }
+        function BFt(e) {
+          if (!e) throw new Error("bbox is required");
+          if (!Array.isArray(e)) throw new Error("bbox must be an Array");
+          if (e.length !== 4 && e.length !== 6) throw new Error("bbox must be an Array of 4 or 6 numbers");
+          e.forEach((t) => {
+            if (!wF(t)) throw new Error("bbox must only contain numbers");
+          });
+        }
+        function NFt(e) {
+          if (!e) throw new Error("id is required");
+          if (["string", "number"].indexOf(typeof e) === -1) throw new Error("id must be a number or a string");
+        }
+        ic.areaFactors = EZ;
+        ic.azimuthToBearing = DFt;
+        ic.bearingToAzimuth = RFt;
+        ic.convertArea = OFt;
+        ic.convertLength = zFt;
+        ic.degreesToRadians = FFt;
+        ic.earthRadius = Op;
+        ic.factors = kZ;
+        ic.feature = fx;
+        ic.featureCollection = TF;
+        ic.geometry = MFt;
+        ic.geometryCollection = LFt;
+        ic.isNumber = wF;
+        ic.isObject = qFt;
+        ic.lengthToDegrees = IFt;
+        ic.lengthToRadians = IZ;
+        ic.lineString = PZ;
+        ic.lineStrings = CFt;
+        ic.multiLineString = QRe;
+        ic.multiPoint = eDe;
+        ic.multiPolygon = tDe;
+        ic.point = CZ;
+        ic.points = EFt;
+        ic.polygon = LZ;
+        ic.polygons = kFt;
+        ic.radiansToDegrees = iDe;
+        ic.radiansToLength = rDe;
+        ic.round = PFt;
+        ic.validateBBox = BFt;
+        ic.validateId = NFt;
+      });
+      var MF = ye((Od) => {
+        Object.defineProperty(Od, "__esModule", { value: true });
+        var Wv = AF();
+        function fk(e, t, r) {
+          if (e !== null) for (var n, i, a, o, s, l, u, c = 0, f = 0, h, d = e.type, v = d === "FeatureCollection", _ = d === "Feature", b = v ? e.features.length : 1, p = 0; p < b; p++) {
+            u = v ? e.features[p].geometry : _ ? e.geometry : e, h = u ? u.type === "GeometryCollection" : false, s = h ? u.geometries.length : 1;
+            for (var k = 0; k < s; k++) {
+              var E = 0, T = 0;
+              if (o = h ? u.geometries[k] : u, o !== null) {
+                l = o.coordinates;
+                var L = o.type;
+                switch (c = r && (L === "Polygon" || L === "MultiPolygon") ? 1 : 0, L) {
+                  case null:
+                    break;
+                  case "Point":
+                    if (t(l, f, p, E, T) === false) return false;
+                    f++, E++;
+                    break;
+                  case "LineString":
+                  case "MultiPoint":
+                    for (n = 0; n < l.length; n++) {
+                      if (t(l[n], f, p, E, T) === false) return false;
+                      f++, L === "MultiPoint" && E++;
+                    }
+                    L === "LineString" && E++;
+                    break;
+                  case "Polygon":
+                  case "MultiLineString":
+                    for (n = 0; n < l.length; n++) {
+                      for (i = 0; i < l[n].length - c; i++) {
+                        if (t(l[n][i], f, p, E, T) === false) return false;
+                        f++;
+                      }
+                      L === "MultiLineString" && E++, L === "Polygon" && T++;
+                    }
+                    L === "Polygon" && E++;
+                    break;
+                  case "MultiPolygon":
+                    for (n = 0; n < l.length; n++) {
+                      for (T = 0, i = 0; i < l[n].length; i++) {
+                        for (a = 0; a < l[n][i].length - c; a++) {
+                          if (t(l[n][i][a], f, p, E, T) === false) return false;
+                          f++;
+                        }
+                        T++;
+                      }
+                      E++;
+                    }
+                    break;
+                  case "GeometryCollection":
+                    for (n = 0; n < o.geometries.length; n++) if (fk(o.geometries[n], t, r) === false) return false;
+                    break;
+                  default:
+                    throw new Error("Unknown Geometry Type");
+                }
+              }
+            }
+          }
+        }
+        function UFt(e, t, r, n) {
+          var i = r;
+          return fk(e, function(a, o, s, l, u) {
+            o === 0 && r === void 0 ? i = a : i = t(i, a, o, s, l, u);
+          }, n), i;
+        }
+        function nDe(e, t) {
+          var r;
+          switch (e.type) {
+            case "FeatureCollection":
+              for (r = 0; r < e.features.length && t(e.features[r].properties, r) !== false; r++) ;
+              break;
+            case "Feature":
+              t(e.properties, 0);
+              break;
+          }
+        }
+        function VFt(e, t, r) {
+          var n = r;
+          return nDe(e, function(i, a) {
+            a === 0 && r === void 0 ? n = i : n = t(n, i, a);
+          }), n;
+        }
+        function aDe(e, t) {
+          if (e.type === "Feature") t(e, 0);
+          else if (e.type === "FeatureCollection") for (var r = 0; r < e.features.length && t(e.features[r], r) !== false; r++) ;
+        }
+        function GFt(e, t, r) {
+          var n = r;
+          return aDe(e, function(i, a) {
+            a === 0 && r === void 0 ? n = i : n = t(n, i, a);
+          }), n;
+        }
+        function HFt(e) {
+          var t = [];
+          return fk(e, function(r) {
+            t.push(r);
+          }), t;
+        }
+        function RZ(e, t) {
+          var r, n, i, a, o, s, l, u, c, f, h = 0, d = e.type === "FeatureCollection", v = e.type === "Feature", _ = d ? e.features.length : 1;
+          for (r = 0; r < _; r++) {
+            for (s = d ? e.features[r].geometry : v ? e.geometry : e, u = d ? e.features[r].properties : v ? e.properties : {}, c = d ? e.features[r].bbox : v ? e.bbox : void 0, f = d ? e.features[r].id : v ? e.id : void 0, l = s ? s.type === "GeometryCollection" : false, o = l ? s.geometries.length : 1, i = 0; i < o; i++) {
+              if (a = l ? s.geometries[i] : s, a === null) {
+                if (t(null, h, u, c, f) === false) return false;
+                continue;
+              }
+              switch (a.type) {
+                case "Point":
+                case "LineString":
+                case "MultiPoint":
+                case "Polygon":
+                case "MultiLineString":
+                case "MultiPolygon": {
+                  if (t(a, h, u, c, f) === false) return false;
+                  break;
+                }
+                case "GeometryCollection": {
+                  for (n = 0; n < a.geometries.length; n++) if (t(a.geometries[n], h, u, c, f) === false) return false;
+                  break;
+                }
+                default:
+                  throw new Error("Unknown Geometry Type");
+              }
+            }
+            h++;
+          }
+        }
+        function jFt(e, t, r) {
+          var n = r;
+          return RZ(e, function(i, a, o, s, l) {
+            a === 0 && r === void 0 ? n = i : n = t(n, i, a, o, s, l);
+          }), n;
+        }
+        function SF(e, t) {
+          RZ(e, function(r, n, i, a, o) {
+            var s = r === null ? null : r.type;
+            switch (s) {
+              case null:
+              case "Point":
+              case "LineString":
+              case "Polygon":
+                return t(Wv.feature.call(void 0, r, i, { bbox: a, id: o }), n, 0) === false ? false : void 0;
+            }
+            var l;
+            switch (s) {
+              case "MultiPoint":
+                l = "Point";
+                break;
+              case "MultiLineString":
+                l = "LineString";
+                break;
+              case "MultiPolygon":
+                l = "Polygon";
+                break;
+            }
+            for (var u = 0; u < r.coordinates.length; u++) {
+              var c = r.coordinates[u], f = { type: l, coordinates: c };
+              if (t(Wv.feature.call(void 0, f, i), n, u) === false) return false;
+            }
+          });
+        }
+        function WFt(e, t, r) {
+          var n = r;
+          return SF(e, function(i, a, o) {
+            a === 0 && o === 0 && r === void 0 ? n = i : n = t(n, i, a, o);
+          }), n;
+        }
+        function oDe(e, t) {
+          SF(e, function(r, n, i) {
+            var a = 0;
+            if (r.geometry) {
+              var o = r.geometry.type;
+              if (!(o === "Point" || o === "MultiPoint")) {
+                var s, l = 0, u = 0, c = 0;
+                if (fk(r, function(f, h, d, v, _) {
+                  if (s === void 0 || n > l || v > u || _ > c) {
+                    s = f, l = n, u = v, c = _, a = 0;
+                    return;
+                  }
+                  var b = Wv.lineString.call(void 0, [s, f], r.properties);
+                  if (t(b, n, i, _, a) === false) return false;
+                  a++, s = f;
+                }) === false) return false;
+              }
+            }
+          });
+        }
+        function XFt(e, t, r) {
+          var n = r, i = false;
+          return oDe(e, function(a, o, s, l, u) {
+            i === false && r === void 0 ? n = a : n = t(n, a, o, s, l, u), i = true;
+          }), n;
+        }
+        function sDe(e, t) {
+          if (!e) throw new Error("geojson is required");
+          SF(e, function(r, n, i) {
+            if (r.geometry !== null) {
+              var a = r.geometry.type, o = r.geometry.coordinates;
+              switch (a) {
+                case "LineString":
+                  if (t(r, n, i, 0, 0) === false) return false;
+                  break;
+                case "Polygon":
+                  for (var s = 0; s < o.length; s++) if (t(Wv.lineString.call(void 0, o[s], r.properties), n, i, s) === false) return false;
+                  break;
+              }
+            }
+          });
+        }
+        function ZFt(e, t, r) {
+          var n = r;
+          return sDe(e, function(i, a, o, s) {
+            a === 0 && r === void 0 ? n = i : n = t(n, i, a, o, s);
+          }), n;
+        }
+        function YFt(e, t) {
+          if (t = t || {}, !Wv.isObject.call(void 0, t)) throw new Error("options is invalid");
+          var r = t.featureIndex || 0, n = t.multiFeatureIndex || 0, i = t.geometryIndex || 0, a = t.segmentIndex || 0, o = t.properties, s;
+          switch (e.type) {
+            case "FeatureCollection":
+              r < 0 && (r = e.features.length + r), o = o || e.features[r].properties, s = e.features[r].geometry;
+              break;
+            case "Feature":
+              o = o || e.properties, s = e.geometry;
+              break;
+            case "Point":
+            case "MultiPoint":
+              return null;
+            case "LineString":
+            case "Polygon":
+            case "MultiLineString":
+            case "MultiPolygon":
+              s = e;
+              break;
+            default:
+              throw new Error("geojson is invalid");
+          }
+          if (s === null) return null;
+          var l = s.coordinates;
+          switch (s.type) {
+            case "Point":
+            case "MultiPoint":
+              return null;
+            case "LineString":
+              return a < 0 && (a = l.length + a - 1), Wv.lineString.call(void 0, [l[a], l[a + 1]], o, t);
+            case "Polygon":
+              return i < 0 && (i = l.length + i), a < 0 && (a = l[i].length + a - 1), Wv.lineString.call(void 0, [l[i][a], l[i][a + 1]], o, t);
+            case "MultiLineString":
+              return n < 0 && (n = l.length + n), a < 0 && (a = l[n].length + a - 1), Wv.lineString.call(void 0, [l[n][a], l[n][a + 1]], o, t);
+            case "MultiPolygon":
+              return n < 0 && (n = l.length + n), i < 0 && (i = l[n].length + i), a < 0 && (a = l[n][i].length - a - 1), Wv.lineString.call(void 0, [l[n][i][a], l[n][i][a + 1]], o, t);
+          }
+          throw new Error("geojson is invalid");
+        }
+        function KFt(e, t) {
+          if (t = t || {}, !Wv.isObject.call(void 0, t)) throw new Error("options is invalid");
+          var r = t.featureIndex || 0, n = t.multiFeatureIndex || 0, i = t.geometryIndex || 0, a = t.coordIndex || 0, o = t.properties, s;
+          switch (e.type) {
+            case "FeatureCollection":
+              r < 0 && (r = e.features.length + r), o = o || e.features[r].properties, s = e.features[r].geometry;
+              break;
+            case "Feature":
+              o = o || e.properties, s = e.geometry;
+              break;
+            case "Point":
+            case "MultiPoint":
+              return null;
+            case "LineString":
+            case "Polygon":
+            case "MultiLineString":
+            case "MultiPolygon":
+              s = e;
+              break;
+            default:
+              throw new Error("geojson is invalid");
+          }
+          if (s === null) return null;
+          var l = s.coordinates;
+          switch (s.type) {
+            case "Point":
+              return Wv.point.call(void 0, l, o, t);
+            case "MultiPoint":
+              return n < 0 && (n = l.length + n), Wv.point.call(void 0, l[n], o, t);
+            case "LineString":
+              return a < 0 && (a = l.length + a), Wv.point.call(void 0, l[a], o, t);
+            case "Polygon":
+              return i < 0 && (i = l.length + i), a < 0 && (a = l[i].length + a), Wv.point.call(void 0, l[i][a], o, t);
+            case "MultiLineString":
+              return n < 0 && (n = l.length + n), a < 0 && (a = l[n].length + a), Wv.point.call(void 0, l[n][a], o, t);
+            case "MultiPolygon":
+              return n < 0 && (n = l.length + n), i < 0 && (i = l[n].length + i), a < 0 && (a = l[n][i].length - a), Wv.point.call(void 0, l[n][i][a], o, t);
+          }
+          throw new Error("geojson is invalid");
+        }
+        Od.coordAll = HFt;
+        Od.coordEach = fk;
+        Od.coordReduce = UFt;
+        Od.featureEach = aDe;
+        Od.featureReduce = GFt;
+        Od.findPoint = KFt;
+        Od.findSegment = YFt;
+        Od.flattenEach = SF;
+        Od.flattenReduce = WFt;
+        Od.geomEach = RZ;
+        Od.geomReduce = jFt;
+        Od.lineEach = sDe;
+        Od.lineReduce = ZFt;
+        Od.propEach = nDe;
+        Od.propReduce = VFt;
+        Od.segmentEach = oDe;
+        Od.segmentReduce = XFt;
+      });
+      var hDe = ye((EF) => {
+        Object.defineProperty(EF, "__esModule", { value: true });
+        var lDe = AF(), JFt = MF();
+        function fDe(e) {
+          return JFt.geomReduce.call(void 0, e, (t, r) => t + $Ft(r), 0);
+        }
+        function $Ft(e) {
+          let t = 0, r;
+          switch (e.type) {
+            case "Polygon":
+              return uDe(e.coordinates);
+            case "MultiPolygon":
+              for (r = 0; r < e.coordinates.length; r++) t += uDe(e.coordinates[r]);
+              return t;
+            case "Point":
+            case "MultiPoint":
+            case "LineString":
+            case "MultiLineString":
+              return 0;
+          }
+          return 0;
+        }
+        function uDe(e) {
+          let t = 0;
+          if (e && e.length > 0) {
+            t += Math.abs(cDe(e[0]));
+            for (let r = 1; r < e.length; r++) t -= Math.abs(cDe(e[r]));
+          }
+          return t;
+        }
+        var QFt = lDe.earthRadius * lDe.earthRadius / 2, DZ = Math.PI / 180;
+        function cDe(e) {
+          let t = e.length - 1;
+          if (t <= 2) return 0;
+          let r = 0, n = 0;
+          for (; n < t; ) {
+            let i = e[n], a = e[n + 1 === t ? 0 : n + 1], o = e[n + 2 >= t ? (n + 2) % t : n + 2], s = i[0] * DZ, l = a[1] * DZ, u = o[0] * DZ;
+            r += (u - s) * Math.sin(l), n++;
+          }
+          return r * QFt;
+        }
+        var ezt = fDe;
+        EF.area = fDe;
+        EF.default = ezt;
+      });
+      var vDe = ye((kF) => {
+        Object.defineProperty(kF, "__esModule", { value: true });
+        var tzt = AF(), rzt = MF();
+        function dDe(e, t = {}) {
+          let r = 0, n = 0, i = 0;
+          return rzt.coordEach.call(void 0, e, function(a) {
+            r += a[0], n += a[1], i++;
+          }, true), tzt.point.call(void 0, [r / i, n / i], t.properties);
+        }
+        var izt = dDe;
+        kF.centroid = dDe;
+        kF.default = izt;
+      });
+      var gDe = ye((CF) => {
+        Object.defineProperty(CF, "__esModule", { value: true });
+        var nzt = MF();
+        function pDe(e, t = {}) {
+          if (e.bbox != null && t.recompute !== true) return e.bbox;
+          let r = [1 / 0, 1 / 0, -1 / 0, -1 / 0];
+          return nzt.coordEach.call(void 0, e, (n) => {
+            r[0] > n[0] && (r[0] = n[0]), r[1] > n[1] && (r[1] = n[1]), r[2] < n[0] && (r[2] = n[0]), r[3] < n[1] && (r[3] = n[1]);
+          }), r;
+        }
+        var azt = pDe;
+        CF.bbox = pDe;
+        CF.default = azt;
+      });
+      var hx = ye((Mmr, bDe) => {
+        var ozt = Oa(), _De = $Re(), { area: szt } = hDe(), { centroid: lzt } = vDe(), { bbox: uzt } = gDe(), mDe = ZS(), t5 = K1(), czt = Ty(), fzt = FS(), LF = FM(), yDe = Object.keys(_De), hzt = { "ISO-3": mDe, "USA-states": mDe, "country names": dzt };
+        function dzt(e) {
+          for (var t = 0; t < yDe.length; t++) {
+            var r = yDe[t], n = new RegExp(_De[r]);
+            if (n.test(e.trim().toLowerCase())) return r;
+          }
+          return t5.log("Unrecognized country name: " + e + "."), false;
+        }
+        function vzt(e, t, r) {
+          if (!t || typeof t != "string") return false;
+          var n = hzt[e](t), i, a, o;
+          if (n) {
+            if (e === "USA-states") for (i = [], o = 0; o < r.length; o++) a = r[o], a.properties && a.properties.gu && a.properties.gu === "USA" && i.push(a);
+            else i = r;
+            for (o = 0; o < i.length; o++) if (a = i[o], a.id === n) return a;
+            t5.log(["Location with id", n, "does not have a matching topojson feature at this resolution."].join(" "));
+          }
+          return false;
+        }
+        function pzt(e) {
+          var t = e.geometry, r = t.coordinates, n = e.id, i = [], a, o, s, l;
+          function u(c) {
+            for (var f = 0; f < c.length - 1; f++) if (c[f][0] > 0 && c[f + 1][0] < 0) return f;
+            return null;
+          }
+          switch (n === "RUS" || n === "FJI" ? a = function(c) {
+            var f;
+            if (u(c) === null) f = c;
+            else for (f = new Array(c.length), l = 0; l < c.length; l++) f[l] = [c[l][0] < 0 ? c[l][0] + 360 : c[l][0], c[l][1]];
+            i.push(LF.tester(f));
+          } : n === "ATA" ? a = function(c) {
+            var f = u(c);
+            if (f === null) return i.push(LF.tester(c));
+            var h = new Array(c.length + 1), d = 0;
+            for (l = 0; l < c.length; l++) l > f ? h[d++] = [c[l][0] + 360, c[l][1]] : l === f ? (h[d++] = c[l], h[d++] = [c[l][0], -90]) : h[d++] = c[l];
+            var v = LF.tester(h);
+            v.pts.pop(), i.push(v);
+          } : a = function(c) {
+            i.push(LF.tester(c));
+          }, t.type) {
+            case "MultiPolygon":
+              for (o = 0; o < r.length; o++) for (s = 0; s < r[o].length; s++) a(r[o][s]);
+              break;
+            case "Polygon":
+              for (o = 0; o < r.length; o++) a(r[o]);
+              break;
+          }
+          return i;
+        }
+        function xDe(e) {
+          var t = e.geojson, r = window.PlotlyGeoAssets || {}, n = typeof t == "string" ? r[t] : t;
+          return czt(n) ? n : (t5.error("Oops ... something went wrong when fetching " + t), false);
+        }
+        function gzt(e) {
+          var t = e[0].trace, r = xDe(t);
+          if (!r) return false;
+          var n = {}, i = [], a;
+          for (a = 0; a < t._length; a++) {
+            var o = e[a];
+            (o.loc || o.loc === 0) && (n[o.loc] = o);
+          }
+          function s(c) {
+            var f = fzt(c, t.featureidkey || "id").get(), h = n[f];
+            if (h) {
+              var d = c.geometry;
+              if (d.type === "Polygon" || d.type === "MultiPolygon") {
+                var v = { type: "Feature", id: f, geometry: d, properties: {} };
+                v.geometry.coordinates.length > 0 ? v.properties.ct = mzt(v) : v.properties.ct = [NaN, NaN], h.fIn = c, h.fOut = v, i.push(v);
+              } else t5.log(["Location", h.loc, "does not have a valid GeoJSON geometry.", "Traces with locationmode *geojson-id* only support", "*Polygon* and *MultiPolygon* geometries."].join(" "));
+            }
+            delete n[f];
+          }
+          switch (r.type) {
+            case "FeatureCollection":
+              var l = r.features;
+              for (a = 0; a < l.length; a++) s(l[a]);
+              break;
+            case "Feature":
+              s(r);
+              break;
+            default:
+              return t5.warn(["Invalid GeoJSON type", (r.type || "none") + ".", "Traces with locationmode *geojson-id* only support", "*FeatureCollection* and *Feature* types."].join(" ")), false;
+          }
+          for (var u in n) t5.log(["Location *" + u + "*", "does not have a matching feature with id-key", "*" + t.featureidkey + "*."].join(" "));
+          return i;
+        }
+        function mzt(e) {
+          var t = e.geometry, r;
+          if (t.type === "MultiPolygon") for (var n = t.coordinates, i = 0, a = 0; a < n.length; a++) {
+            var o = { type: "Polygon", coordinates: n[a] }, s = szt(o);
+            s > i && (i = s, r = o);
+          }
+          else r = t;
+          return lzt(r).geometry.coordinates;
+        }
+        function yzt(e) {
+          var t = window.PlotlyGeoAssets || {}, r = [];
+          function n(l) {
+            return new Promise(function(u, c) {
+              ozt.json(l, function(f, h) {
+                if (f) {
+                  delete t[l];
+                  var d = f.status === 404 ? 'GeoJSON at URL "' + l + '" does not exist.' : "Unexpected error while fetching from " + l;
+                  return c(new Error(d));
+                }
+                return t[l] = h, u(h);
+              });
+            });
+          }
+          function i(l) {
+            return new Promise(function(u, c) {
+              var f = 0, h = setInterval(function() {
+                if (t[l] && t[l] !== "pending") return clearInterval(h), u(t[l]);
+                if (f > 100) return clearInterval(h), c("Unexpected error while fetching from " + l);
+                f++;
+              }, 50);
+            });
+          }
+          for (var a = 0; a < e.length; a++) {
+            var o = e[a][0].trace, s = o.geojson;
+            typeof s == "string" && (t[s] ? t[s] === "pending" && r.push(i(s)) : (t[s] = "pending", r.push(n(s))));
+          }
+          return r;
+        }
+        function _zt(e) {
+          return uzt(e);
+        }
+        bDe.exports = { locationToFeature: vzt, feature2polygons: pzt, getTraceGeojson: xDe, extractTraceFeature: gzt, fetchTraceGeoData: yzt, computeBbox: _zt };
+      });
+      var FZ = ye((Emr, ADe) => {
+        var xzt = Oa(), bzt = So(), wDe = ka(), TDe = sp(), wzt = TDe.stylePoints, Tzt = TDe.styleText;
+        ADe.exports = function(t, r) {
+          r && Azt(t, r);
+        };
+        function Azt(e, t) {
+          var r = t[0].trace, n = t[0].node3;
+          n.style("opacity", t[0].trace.opacity), wzt(n, r, e), Tzt(n, r, e), n.selectAll("path.js-line").style("fill", "none").each(function(i) {
+            var a = xzt.select(this), o = i.trace, s = o.line || {};
+            a.call(wDe.stroke, s.color).call(bzt.dashLine, s.dash || "", s.width || 0), o.fill !== "none" && a.call(wDe.fill, o.fillcolor);
+          });
+        }
+      });
+      var BZ = ye((kmr, EDe) => {
+        var SDe = Oa(), IF = Dr(), Szt = bF().getTopojsonFeatures, zZ = cx(), PF = hx(), MDe = Mg().findExtremes, qZ = fs().BADNUM, Mzt = q0().calcMarkerSize, OZ = Ru(), Ezt = FZ();
+        function kzt(e, t, r) {
+          var n = t.layers.frontplot.select(".scatterlayer"), i = IF.makeTraceGroups(n, r, "trace scattergeo");
+          function a(o, s) {
+            o.lonlat[0] === qZ && SDe.select(s).remove();
+          }
+          i.selectAll("*").remove(), i.each(function(o) {
+            var s = SDe.select(this), l = o[0].trace;
+            if (OZ.hasLines(l) || l.fill !== "none") {
+              var u = zZ.calcTraceToLineCoords(o), c = l.fill !== "none" ? zZ.makePolygon(u) : zZ.makeLine(u);
+              s.selectAll("path.js-line").data([{ geojson: c, trace: l }]).enter().append("path").classed("js-line", true).style("stroke-miterlimit", 2);
+            }
+            OZ.hasMarkers(l) && s.selectAll("path.point").data(IF.identity).enter().append("path").classed("point", true).each(function(f) {
+              a(f, this);
+            }), OZ.hasText(l) && s.selectAll("g").data(IF.identity).enter().append("g").append("text").each(function(f) {
+              a(f, this);
+            }), Ezt(e, o);
+          });
+        }
+        function Czt(e, t) {
+          var r = e[0].trace, n = t[r.geo], i = n._subplot, a = r._length, o, s;
+          if (IF.isArrayOrTypedArray(r.locations)) {
+            var l = r.locationmode, u = l === "geojson-id" ? PF.extractTraceFeature(e) : Szt(r, i.topojson);
+            for (o = 0; o < a; o++) {
+              s = e[o];
+              var c = l === "geojson-id" ? s.fOut : PF.locationToFeature(l, s.loc, u);
+              s.lonlat = c ? c.properties.ct : [qZ, qZ];
+            }
+          }
+          var f = { padded: true }, h, d;
+          if (n.fitbounds === "geojson" && r.locationmode === "geojson-id") {
+            var v = PF.computeBbox(PF.getTraceGeojson(r));
+            h = [v[0], v[2]], d = [v[1], v[3]];
+          } else {
+            for (h = new Array(a), d = new Array(a), o = 0; o < a; o++) s = e[o], h[o] = s.lonlat[0], d[o] = s.lonlat[1];
+            f.ppad = Mzt(r, a);
+          }
+          r._extremes.lon = MDe(n.lonaxis._ax, h, f), r._extremes.lat = MDe(n.lataxis._ax, d, f);
+        }
+        EDe.exports = { calcGeoJSON: Czt, plot: kzt };
+      });
+      var CDe = ye((Cmr, kDe) => {
+        var Lzt = vf(), Pzt = fs().BADNUM, Izt = gT(), Rzt = Dr().fillText, Dzt = ew();
+        kDe.exports = function(t, r, n) {
+          var i = t.cd, a = i[0].trace, o = t.xa, s = t.ya, l = t.subplot, u = l.projection.isLonLatOverEdges, c = l.project;
+          function f(k) {
+            var E = k.lonlat;
+            if (E[0] === Pzt || u(E)) return 1 / 0;
+            var T = c(E), L = c([r, n]), x = Math.abs(T[0] - L[0]), C = Math.abs(T[1] - L[1]), M = Math.max(3, k.mrc || 0);
+            return Math.max(Math.sqrt(x * x + C * C) - M, 1 - 3 / M);
+          }
+          if (Lzt.getClosest(i, f, t), t.index !== false) {
+            var h = i[t.index], d = h.lonlat, v = [o.c2p(d), s.c2p(d)], _ = h.mrc || 1;
+            t.x0 = v[0] - _, t.x1 = v[0] + _, t.y0 = v[1] - _, t.y1 = v[1] + _, t.loc = h.loc, t.lon = d[0], t.lat = d[1];
+            var b = {};
+            b[a.geo] = { _subplot: l };
+            var p = a._module.formatLabels(h, a, b);
+            return t.lonLabel = p.lonLabel, t.latLabel = p.latLabel, t.color = Izt(a, h), t.extraText = Fzt(a, h, t, i[0].t.labels), t.hovertemplate = a.hovertemplate, [t];
+          }
+        };
+        function Fzt(e, t, r, n) {
+          if (e.hovertemplate) return;
+          var i = t.hi || e.hoverinfo, a = i === "all" ? Dzt.hoverinfo.flags : i.split("+"), o = a.indexOf("location") !== -1 && Array.isArray(e.locations), s = a.indexOf("lon") !== -1, l = a.indexOf("lat") !== -1, u = a.indexOf("text") !== -1, c = [];
+          function f(h) {
+            return h + "°";
+          }
+          return o ? c.push(t.loc) : s && l ? c.push("(" + f(r.latLabel) + ", " + f(r.lonLabel) + ")") : s ? c.push(n.lon + f(r.lonLabel)) : l && c.push(n.lat + f(r.latLabel)), u && Rzt(t, e, c), c.join("<br>");
+        }
+      });
+      var PDe = ye((Lmr, LDe) => {
+        LDe.exports = function(t, r, n, i, a) {
+          t.lon = r.lon, t.lat = r.lat, t.location = r.loc ? r.loc : null;
+          var o = i[a];
+          return o.fIn && o.fIn.properties && (t.properties = o.fIn.properties), t;
+        };
+      });
+      var DDe = ye((Pmr, RDe) => {
+        var IDe = Ru(), zzt = fs().BADNUM;
+        RDe.exports = function(t, r) {
+          var n = t.cd, i = t.xaxis, a = t.yaxis, o = [], s = n[0].trace, l, u, c, f, h, d = !IDe.hasMarkers(s) && !IDe.hasText(s);
+          if (d) return [];
+          if (r === false) for (h = 0; h < n.length; h++) n[h].selected = 0;
+          else for (h = 0; h < n.length; h++) l = n[h], u = l.lonlat, u[0] !== zzt && (c = i.c2p(u), f = a.c2p(u), r.contains([c, f], null, h, t) ? (o.push({ pointNumber: h, lon: u[0], lat: u[1] }), l.selected = 1) : l.selected = 0);
+          return o;
+        };
+      });
+      var hk = ye((RF, FDe) => {
+        (function(e, t) {
+          t(typeof RF == "object" && typeof FDe != "undefined" ? RF : e.d3 = e.d3 || {});
+        })(RF, function(e) {
+          function t(Ee, Ae) {
+            return Ee < Ae ? -1 : Ee > Ae ? 1 : Ee >= Ae ? 0 : NaN;
+          }
+          function r(Ee) {
+            return Ee.length === 1 && (Ee = n(Ee)), { left: function(Ae, Be, Pe, me) {
+              for (Pe == null && (Pe = 0), me == null && (me = Ae.length); Pe < me; ) {
+                var De = Pe + me >>> 1;
+                Ee(Ae[De], Be) < 0 ? Pe = De + 1 : me = De;
+              }
+              return Pe;
+            }, right: function(Ae, Be, Pe, me) {
+              for (Pe == null && (Pe = 0), me == null && (me = Ae.length); Pe < me; ) {
+                var De = Pe + me >>> 1;
+                Ee(Ae[De], Be) > 0 ? me = De : Pe = De + 1;
+              }
+              return Pe;
+            } };
+          }
+          function n(Ee) {
+            return function(Ae, Be) {
+              return t(Ee(Ae), Be);
+            };
+          }
+          var i = r(t), a = i.right, o = i.left;
+          function s(Ee, Ae) {
+            Ae == null && (Ae = l);
+            for (var Be = 0, Pe = Ee.length - 1, me = Ee[0], De = new Array(Pe < 0 ? 0 : Pe); Be < Pe; ) De[Be] = Ae(me, me = Ee[++Be]);
+            return De;
+          }
+          function l(Ee, Ae) {
+            return [Ee, Ae];
+          }
+          function u(Ee, Ae, Be) {
+            var Pe = Ee.length, me = Ae.length, De = new Array(Pe * me), ce, je, lt, pt;
+            for (Be == null && (Be = l), ce = lt = 0; ce < Pe; ++ce) for (pt = Ee[ce], je = 0; je < me; ++je, ++lt) De[lt] = Be(pt, Ae[je]);
+            return De;
+          }
+          function c(Ee, Ae) {
+            return Ae < Ee ? -1 : Ae > Ee ? 1 : Ae >= Ee ? 0 : NaN;
+          }
+          function f(Ee) {
+            return Ee === null ? NaN : +Ee;
+          }
+          function h(Ee, Ae) {
+            var Be = Ee.length, Pe = 0, me = -1, De = 0, ce, je, lt = 0;
+            if (Ae == null) for (; ++me < Be; ) isNaN(ce = f(Ee[me])) || (je = ce - De, De += je / ++Pe, lt += je * (ce - De));
+            else for (; ++me < Be; ) isNaN(ce = f(Ae(Ee[me], me, Ee))) || (je = ce - De, De += je / ++Pe, lt += je * (ce - De));
+            if (Pe > 1) return lt / (Pe - 1);
+          }
+          function d(Ee, Ae) {
+            var Be = h(Ee, Ae);
+            return Be && Math.sqrt(Be);
+          }
+          function v(Ee, Ae) {
+            var Be = Ee.length, Pe = -1, me, De, ce;
+            if (Ae == null) {
+              for (; ++Pe < Be; ) if ((me = Ee[Pe]) != null && me >= me) for (De = ce = me; ++Pe < Be; ) (me = Ee[Pe]) != null && (De > me && (De = me), ce < me && (ce = me));
+            } else for (; ++Pe < Be; ) if ((me = Ae(Ee[Pe], Pe, Ee)) != null && me >= me) for (De = ce = me; ++Pe < Be; ) (me = Ae(Ee[Pe], Pe, Ee)) != null && (De > me && (De = me), ce < me && (ce = me));
+            return [De, ce];
+          }
+          var _ = Array.prototype, b = _.slice, p = _.map;
+          function k(Ee) {
+            return function() {
+              return Ee;
+            };
+          }
+          function E(Ee) {
+            return Ee;
+          }
+          function T(Ee, Ae, Be) {
+            Ee = +Ee, Ae = +Ae, Be = (me = arguments.length) < 2 ? (Ae = Ee, Ee = 0, 1) : me < 3 ? 1 : +Be;
+            for (var Pe = -1, me = Math.max(0, Math.ceil((Ae - Ee) / Be)) | 0, De = new Array(me); ++Pe < me; ) De[Pe] = Ee + Pe * Be;
+            return De;
+          }
+          var L = Math.sqrt(50), x = Math.sqrt(10), C = Math.sqrt(2);
+          function M(Ee, Ae, Be) {
+            var Pe, me = -1, De, ce, je;
+            if (Ae = +Ae, Ee = +Ee, Be = +Be, Ee === Ae && Be > 0) return [Ee];
+            if ((Pe = Ae < Ee) && (De = Ee, Ee = Ae, Ae = De), (je = g(Ee, Ae, Be)) === 0 || !isFinite(je)) return [];
+            if (je > 0) for (Ee = Math.ceil(Ee / je), Ae = Math.floor(Ae / je), ce = new Array(De = Math.ceil(Ae - Ee + 1)); ++me < De; ) ce[me] = (Ee + me) * je;
+            else for (Ee = Math.floor(Ee * je), Ae = Math.ceil(Ae * je), ce = new Array(De = Math.ceil(Ee - Ae + 1)); ++me < De; ) ce[me] = (Ee - me) / je;
+            return Pe && ce.reverse(), ce;
+          }
+          function g(Ee, Ae, Be) {
+            var Pe = (Ae - Ee) / Math.max(0, Be), me = Math.floor(Math.log(Pe) / Math.LN10), De = Pe / Math.pow(10, me);
+            return me >= 0 ? (De >= L ? 10 : De >= x ? 5 : De >= C ? 2 : 1) * Math.pow(10, me) : -Math.pow(10, -me) / (De >= L ? 10 : De >= x ? 5 : De >= C ? 2 : 1);
+          }
+          function P(Ee, Ae, Be) {
+            var Pe = Math.abs(Ae - Ee) / Math.max(0, Be), me = Math.pow(10, Math.floor(Math.log(Pe) / Math.LN10)), De = Pe / me;
+            return De >= L ? me *= 10 : De >= x ? me *= 5 : De >= C && (me *= 2), Ae < Ee ? -me : me;
+          }
+          function A(Ee) {
+            return Math.ceil(Math.log(Ee.length) / Math.LN2) + 1;
+          }
+          function z() {
+            var Ee = E, Ae = v, Be = A;
+            function Pe(me) {
+              var De, ce = me.length, je, lt = new Array(ce);
+              for (De = 0; De < ce; ++De) lt[De] = Ee(me[De], De, me);
+              var pt = Ae(lt), Vt = pt[0], ot = pt[1], ut = Be(lt, Vt, ot);
+              Array.isArray(ut) || (ut = P(Vt, ot, ut), ut = T(Math.ceil(Vt / ut) * ut, ot, ut));
+              for (var Wt = ut.length; ut[0] <= Vt; ) ut.shift(), --Wt;
+              for (; ut[Wt - 1] > ot; ) ut.pop(), --Wt;
+              var Nt = new Array(Wt + 1), $t;
+              for (De = 0; De <= Wt; ++De) $t = Nt[De] = [], $t.x0 = De > 0 ? ut[De - 1] : Vt, $t.x1 = De < Wt ? ut[De] : ot;
+              for (De = 0; De < ce; ++De) je = lt[De], Vt <= je && je <= ot && Nt[a(ut, je, 0, Wt)].push(me[De]);
+              return Nt;
+            }
+            return Pe.value = function(me) {
+              return arguments.length ? (Ee = typeof me == "function" ? me : k(me), Pe) : Ee;
+            }, Pe.domain = function(me) {
+              return arguments.length ? (Ae = typeof me == "function" ? me : k([me[0], me[1]]), Pe) : Ae;
+            }, Pe.thresholds = function(me) {
+              return arguments.length ? (Be = typeof me == "function" ? me : Array.isArray(me) ? k(b.call(me)) : k(me), Pe) : Be;
+            }, Pe;
+          }
+          function O(Ee, Ae, Be) {
+            if (Be == null && (Be = f), !!(Pe = Ee.length)) {
+              if ((Ae = +Ae) <= 0 || Pe < 2) return +Be(Ee[0], 0, Ee);
+              if (Ae >= 1) return +Be(Ee[Pe - 1], Pe - 1, Ee);
+              var Pe, me = (Pe - 1) * Ae, De = Math.floor(me), ce = +Be(Ee[De], De, Ee), je = +Be(Ee[De + 1], De + 1, Ee);
+              return ce + (je - ce) * (me - De);
+            }
+          }
+          function U(Ee, Ae, Be) {
+            return Ee = p.call(Ee, f).sort(t), Math.ceil((Be - Ae) / (2 * (O(Ee, 0.75) - O(Ee, 0.25)) * Math.pow(Ee.length, -1 / 3)));
+          }
+          function G(Ee, Ae, Be) {
+            return Math.ceil((Be - Ae) / (3.5 * d(Ee) * Math.pow(Ee.length, -1 / 3)));
+          }
+          function Z(Ee, Ae) {
+            var Be = Ee.length, Pe = -1, me, De;
+            if (Ae == null) {
+              for (; ++Pe < Be; ) if ((me = Ee[Pe]) != null && me >= me) for (De = me; ++Pe < Be; ) (me = Ee[Pe]) != null && me > De && (De = me);
+            } else for (; ++Pe < Be; ) if ((me = Ae(Ee[Pe], Pe, Ee)) != null && me >= me) for (De = me; ++Pe < Be; ) (me = Ae(Ee[Pe], Pe, Ee)) != null && me > De && (De = me);
+            return De;
+          }
+          function j(Ee, Ae) {
+            var Be = Ee.length, Pe = Be, me = -1, De, ce = 0;
+            if (Ae == null) for (; ++me < Be; ) isNaN(De = f(Ee[me])) ? --Pe : ce += De;
+            else for (; ++me < Be; ) isNaN(De = f(Ae(Ee[me], me, Ee))) ? --Pe : ce += De;
+            if (Pe) return ce / Pe;
+          }
+          function N(Ee, Ae) {
+            var Be = Ee.length, Pe = -1, me, De = [];
+            if (Ae == null) for (; ++Pe < Be; ) isNaN(me = f(Ee[Pe])) || De.push(me);
+            else for (; ++Pe < Be; ) isNaN(me = f(Ae(Ee[Pe], Pe, Ee))) || De.push(me);
+            return O(De.sort(t), 0.5);
+          }
+          function H(Ee) {
+            for (var Ae = Ee.length, Be, Pe = -1, me = 0, De, ce; ++Pe < Ae; ) me += Ee[Pe].length;
+            for (De = new Array(me); --Ae >= 0; ) for (ce = Ee[Ae], Be = ce.length; --Be >= 0; ) De[--me] = ce[Be];
+            return De;
+          }
+          function re(Ee, Ae) {
+            var Be = Ee.length, Pe = -1, me, De;
+            if (Ae == null) {
+              for (; ++Pe < Be; ) if ((me = Ee[Pe]) != null && me >= me) for (De = me; ++Pe < Be; ) (me = Ee[Pe]) != null && De > me && (De = me);
+            } else for (; ++Pe < Be; ) if ((me = Ae(Ee[Pe], Pe, Ee)) != null && me >= me) for (De = me; ++Pe < Be; ) (me = Ae(Ee[Pe], Pe, Ee)) != null && De > me && (De = me);
+            return De;
+          }
+          function oe(Ee, Ae) {
+            for (var Be = Ae.length, Pe = new Array(Be); Be--; ) Pe[Be] = Ee[Ae[Be]];
+            return Pe;
+          }
+          function _e(Ee, Ae) {
+            if (Be = Ee.length) {
+              var Be, Pe = 0, me = 0, De, ce = Ee[me];
+              for (Ae == null && (Ae = t); ++Pe < Be; ) (Ae(De = Ee[Pe], ce) < 0 || Ae(ce, ce) !== 0) && (ce = De, me = Pe);
+              if (Ae(ce, ce) === 0) return me;
+            }
+          }
+          function Ce(Ee, Ae, Be) {
+            for (var Pe = (Be == null ? Ee.length : Be) - (Ae = Ae == null ? 0 : +Ae), me, De; Pe; ) De = Math.random() * Pe-- | 0, me = Ee[Pe + Ae], Ee[Pe + Ae] = Ee[De + Ae], Ee[De + Ae] = me;
+            return Ee;
+          }
+          function Le(Ee, Ae) {
+            var Be = Ee.length, Pe = -1, me, De = 0;
+            if (Ae == null) for (; ++Pe < Be; ) (me = +Ee[Pe]) && (De += me);
+            else for (; ++Pe < Be; ) (me = +Ae(Ee[Pe], Pe, Ee)) && (De += me);
+            return De;
+          }
+          function ge(Ee) {
+            if (!(De = Ee.length)) return [];
+            for (var Ae = -1, Be = re(Ee, ie), Pe = new Array(Be); ++Ae < Be; ) for (var me = -1, De, ce = Pe[Ae] = new Array(De); ++me < De; ) ce[me] = Ee[me][Ae];
+            return Pe;
+          }
+          function ie(Ee) {
+            return Ee.length;
+          }
+          function Se() {
+            return ge(arguments);
+          }
+          e.bisect = a, e.bisectRight = a, e.bisectLeft = o, e.ascending = t, e.bisector = r, e.cross = u, e.descending = c, e.deviation = d, e.extent = v, e.histogram = z, e.thresholdFreedmanDiaconis = U, e.thresholdScott = G, e.thresholdSturges = A, e.max = Z, e.mean = j, e.median = N, e.merge = H, e.min = re, e.pairs = s, e.permute = oe, e.quantile = O, e.range = T, e.scan = _e, e.shuffle = Ce, e.sum = Le, e.ticks = M, e.tickIncrement = g, e.tickStep = P, e.transpose = ge, e.variance = h, e.zip = Se, Object.defineProperty(e, "__esModule", { value: true });
+        });
+      });
+      var NZ = ye((DF, zDe) => {
+        (function(e, t) {
+          typeof DF == "object" && typeof zDe != "undefined" ? t(DF, hk()) : (e = e || self, t(e.d3 = e.d3 || {}, e.d3));
+        })(DF, function(e, t) {
+          function r() {
+            return new n();
+          }
+          function n() {
+            this.reset();
+          }
+          n.prototype = { constructor: n, reset: function() {
+            this.s = this.t = 0;
+          }, add: function(At) {
+            a(i, At, this.t), a(this, i.s, this.s), this.s ? this.t += i.t : this.s = i.t;
+          }, valueOf: function() {
+            return this.s;
+          } };
+          var i = new n();
+          function a(At, Xt, Cr) {
+            var Ar = At.s = Xt + Cr, Kr = Ar - Xt, ki = Ar - Kr;
+            At.t = Xt - ki + (Cr - Kr);
+          }
+          var o = 1e-6, s = 1e-12, l = Math.PI, u = l / 2, c = l / 4, f = l * 2, h = 180 / l, d = l / 180, v = Math.abs, _ = Math.atan, b = Math.atan2, p = Math.cos, k = Math.ceil, E = Math.exp, T = Math.log, L = Math.pow, x = Math.sin, C = Math.sign || function(At) {
+            return At > 0 ? 1 : At < 0 ? -1 : 0;
+          }, M = Math.sqrt, g = Math.tan;
+          function P(At) {
+            return At > 1 ? 0 : At < -1 ? l : Math.acos(At);
+          }
+          function A(At) {
+            return At > 1 ? u : At < -1 ? -u : Math.asin(At);
+          }
+          function z(At) {
+            return (At = x(At / 2)) * At;
+          }
+          function O() {
+          }
+          function U(At, Xt) {
+            At && Z.hasOwnProperty(At.type) && Z[At.type](At, Xt);
+          }
+          var G = { Feature: function(At, Xt) {
+            U(At.geometry, Xt);
+          }, FeatureCollection: function(At, Xt) {
+            for (var Cr = At.features, Ar = -1, Kr = Cr.length; ++Ar < Kr; ) U(Cr[Ar].geometry, Xt);
+          } }, Z = { Sphere: function(At, Xt) {
+            Xt.sphere();
+          }, Point: function(At, Xt) {
+            At = At.coordinates, Xt.point(At[0], At[1], At[2]);
+          }, MultiPoint: function(At, Xt) {
+            for (var Cr = At.coordinates, Ar = -1, Kr = Cr.length; ++Ar < Kr; ) At = Cr[Ar], Xt.point(At[0], At[1], At[2]);
+          }, LineString: function(At, Xt) {
+            j(At.coordinates, Xt, 0);
+          }, MultiLineString: function(At, Xt) {
+            for (var Cr = At.coordinates, Ar = -1, Kr = Cr.length; ++Ar < Kr; ) j(Cr[Ar], Xt, 0);
+          }, Polygon: function(At, Xt) {
+            N(At.coordinates, Xt);
+          }, MultiPolygon: function(At, Xt) {
+            for (var Cr = At.coordinates, Ar = -1, Kr = Cr.length; ++Ar < Kr; ) N(Cr[Ar], Xt);
+          }, GeometryCollection: function(At, Xt) {
+            for (var Cr = At.geometries, Ar = -1, Kr = Cr.length; ++Ar < Kr; ) U(Cr[Ar], Xt);
+          } };
+          function j(At, Xt, Cr) {
+            var Ar = -1, Kr = At.length - Cr, ki;
+            for (Xt.lineStart(); ++Ar < Kr; ) ki = At[Ar], Xt.point(ki[0], ki[1], ki[2]);
+            Xt.lineEnd();
+          }
+          function N(At, Xt) {
+            var Cr = -1, Ar = At.length;
+            for (Xt.polygonStart(); ++Cr < Ar; ) j(At[Cr], Xt, 1);
+            Xt.polygonEnd();
+          }
+          function H(At, Xt) {
+            At && G.hasOwnProperty(At.type) ? G[At.type](At, Xt) : U(At, Xt);
+          }
+          var re = r(), oe = r(), _e, Ce, Le, ge, ie, Se = { point: O, lineStart: O, lineEnd: O, polygonStart: function() {
+            re.reset(), Se.lineStart = Ee, Se.lineEnd = Ae;
+          }, polygonEnd: function() {
+            var At = +re;
+            oe.add(At < 0 ? f + At : At), this.lineStart = this.lineEnd = this.point = O;
+          }, sphere: function() {
+            oe.add(f);
+          } };
+          function Ee() {
+            Se.point = Be;
+          }
+          function Ae() {
+            Pe(_e, Ce);
+          }
+          function Be(At, Xt) {
+            Se.point = Pe, _e = At, Ce = Xt, At *= d, Xt *= d, Le = At, ge = p(Xt = Xt / 2 + c), ie = x(Xt);
+          }
+          function Pe(At, Xt) {
+            At *= d, Xt *= d, Xt = Xt / 2 + c;
+            var Cr = At - Le, Ar = Cr >= 0 ? 1 : -1, Kr = Ar * Cr, ki = p(Xt), Xi = x(Xt), dn = ie * Xi, wn = ge * ki + dn * p(Kr), Nn = dn * Ar * x(Kr);
+            re.add(b(Nn, wn)), Le = At, ge = ki, ie = Xi;
+          }
+          function me(At) {
+            return oe.reset(), H(At, Se), oe * 2;
+          }
+          function De(At) {
+            return [b(At[1], At[0]), A(At[2])];
+          }
+          function ce(At) {
+            var Xt = At[0], Cr = At[1], Ar = p(Cr);
+            return [Ar * p(Xt), Ar * x(Xt), x(Cr)];
+          }
+          function je(At, Xt) {
+            return At[0] * Xt[0] + At[1] * Xt[1] + At[2] * Xt[2];
+          }
+          function lt(At, Xt) {
+            return [At[1] * Xt[2] - At[2] * Xt[1], At[2] * Xt[0] - At[0] * Xt[2], At[0] * Xt[1] - At[1] * Xt[0]];
+          }
+          function pt(At, Xt) {
+            At[0] += Xt[0], At[1] += Xt[1], At[2] += Xt[2];
+          }
+          function Vt(At, Xt) {
+            return [At[0] * Xt, At[1] * Xt, At[2] * Xt];
+          }
+          function ot(At) {
+            var Xt = M(At[0] * At[0] + At[1] * At[1] + At[2] * At[2]);
+            At[0] /= Xt, At[1] /= Xt, At[2] /= Xt;
+          }
+          var ut, Wt, Nt, $t, sr, Tr, fr, $e, St = r(), Qt, Gt, _t = { point: It, lineStart: er, lineEnd: lr, polygonStart: function() {
+            _t.point = wr, _t.lineStart = Lr, _t.lineEnd = ti, St.reset(), Se.polygonStart();
+          }, polygonEnd: function() {
+            Se.polygonEnd(), _t.point = It, _t.lineStart = er, _t.lineEnd = lr, re < 0 ? (ut = -(Nt = 180), Wt = -($t = 90)) : St > o ? $t = 90 : St < -1e-6 && (Wt = -90), Gt[0] = ut, Gt[1] = Nt;
+          }, sphere: function() {
+            ut = -(Nt = 180), Wt = -($t = 90);
+          } };
+          function It(At, Xt) {
+            Qt.push(Gt = [ut = At, Nt = At]), Xt < Wt && (Wt = Xt), Xt > $t && ($t = Xt);
+          }
+          function mt(At, Xt) {
+            var Cr = ce([At * d, Xt * d]);
+            if ($e) {
+              var Ar = lt($e, Cr), Kr = [Ar[1], -Ar[0], 0], ki = lt(Kr, Ar);
+              ot(ki), ki = De(ki);
+              var Xi = At - sr, dn = Xi > 0 ? 1 : -1, wn = ki[0] * h * dn, Nn, Yi = v(Xi) > 180;
+              Yi ^ (dn * sr < wn && wn < dn * At) ? (Nn = ki[1] * h, Nn > $t && ($t = Nn)) : (wn = (wn + 360) % 360 - 180, Yi ^ (dn * sr < wn && wn < dn * At) ? (Nn = -ki[1] * h, Nn < Wt && (Wt = Nn)) : (Xt < Wt && (Wt = Xt), Xt > $t && ($t = Xt))), Yi ? At < sr ? Br(ut, At) > Br(ut, Nt) && (Nt = At) : Br(At, Nt) > Br(ut, Nt) && (ut = At) : Nt >= ut ? (At < ut && (ut = At), At > Nt && (Nt = At)) : At > sr ? Br(ut, At) > Br(ut, Nt) && (Nt = At) : Br(At, Nt) > Br(ut, Nt) && (ut = At);
+            } else Qt.push(Gt = [ut = At, Nt = At]);
+            Xt < Wt && (Wt = Xt), Xt > $t && ($t = Xt), $e = Cr, sr = At;
+          }
+          function er() {
+            _t.point = mt;
+          }
+          function lr() {
+            Gt[0] = ut, Gt[1] = Nt, _t.point = It, $e = null;
+          }
+          function wr(At, Xt) {
+            if ($e) {
+              var Cr = At - sr;
+              St.add(v(Cr) > 180 ? Cr + (Cr > 0 ? 360 : -360) : Cr);
+            } else Tr = At, fr = Xt;
+            Se.point(At, Xt), mt(At, Xt);
+          }
+          function Lr() {
+            Se.lineStart();
+          }
+          function ti() {
+            wr(Tr, fr), Se.lineEnd(), v(St) > o && (ut = -(Nt = 180)), Gt[0] = ut, Gt[1] = Nt, $e = null;
+          }
+          function Br(At, Xt) {
+            return (Xt -= At) < 0 ? Xt + 360 : Xt;
+          }
+          function Vr(At, Xt) {
+            return At[0] - Xt[0];
+          }
+          function dt(At, Xt) {
+            return At[0] <= At[1] ? At[0] <= Xt && Xt <= At[1] : Xt < At[0] || At[1] < Xt;
+          }
+          function Ge(At) {
+            var Xt, Cr, Ar, Kr, ki, Xi, dn;
+            if ($t = Nt = -(ut = Wt = 1 / 0), Qt = [], H(At, _t), Cr = Qt.length) {
+              for (Qt.sort(Vr), Xt = 1, Ar = Qt[0], ki = [Ar]; Xt < Cr; ++Xt) Kr = Qt[Xt], dt(Ar, Kr[0]) || dt(Ar, Kr[1]) ? (Br(Ar[0], Kr[1]) > Br(Ar[0], Ar[1]) && (Ar[1] = Kr[1]), Br(Kr[0], Ar[1]) > Br(Ar[0], Ar[1]) && (Ar[0] = Kr[0])) : ki.push(Ar = Kr);
+              for (Xi = -1 / 0, Cr = ki.length - 1, Xt = 0, Ar = ki[Cr]; Xt <= Cr; Ar = Kr, ++Xt) Kr = ki[Xt], (dn = Br(Ar[1], Kr[0])) > Xi && (Xi = dn, ut = Kr[0], Nt = Ar[1]);
+            }
+            return Qt = Gt = null, ut === 1 / 0 || Wt === 1 / 0 ? [[NaN, NaN], [NaN, NaN]] : [[ut, Wt], [Nt, $t]];
+          }
+          var Je, We, tt, xt, Ie, xe, ke, vt, ir, ar, vr, ii, pi, $r, di, ji, In = { sphere: O, point: wi, lineStart: qn, lineEnd: la, polygonStart: function() {
+            In.lineStart = Ut, In.lineEnd = wt;
+          }, polygonEnd: function() {
+            In.lineStart = qn, In.lineEnd = la;
+          } };
+          function wi(At, Xt) {
+            At *= d, Xt *= d;
+            var Cr = p(Xt);
+            On(Cr * p(At), Cr * x(At), x(Xt));
+          }
+          function On(At, Xt, Cr) {
+            ++Je, tt += (At - tt) / Je, xt += (Xt - xt) / Je, Ie += (Cr - Ie) / Je;
+          }
+          function qn() {
+            In.point = Fn;
+          }
+          function Fn(At, Xt) {
+            At *= d, Xt *= d;
+            var Cr = p(Xt);
+            $r = Cr * p(At), di = Cr * x(At), ji = x(Xt), In.point = ra, On($r, di, ji);
+          }
+          function ra(At, Xt) {
+            At *= d, Xt *= d;
+            var Cr = p(Xt), Ar = Cr * p(At), Kr = Cr * x(At), ki = x(Xt), Xi = b(M((Xi = di * ki - ji * Kr) * Xi + (Xi = ji * Ar - $r * ki) * Xi + (Xi = $r * Kr - di * Ar) * Xi), $r * Ar + di * Kr + ji * ki);
+            We += Xi, xe += Xi * ($r + ($r = Ar)), ke += Xi * (di + (di = Kr)), vt += Xi * (ji + (ji = ki)), On($r, di, ji);
+          }
+          function la() {
+            In.point = wi;
+          }
+          function Ut() {
+            In.point = rr;
+          }
+          function wt() {
+            nr(ii, pi), In.point = wi;
+          }
+          function rr(At, Xt) {
+            ii = At, pi = Xt, At *= d, Xt *= d, In.point = nr;
+            var Cr = p(Xt);
+            $r = Cr * p(At), di = Cr * x(At), ji = x(Xt), On($r, di, ji);
+          }
+          function nr(At, Xt) {
+            At *= d, Xt *= d;
+            var Cr = p(Xt), Ar = Cr * p(At), Kr = Cr * x(At), ki = x(Xt), Xi = di * ki - ji * Kr, dn = ji * Ar - $r * ki, wn = $r * Kr - di * Ar, Nn = M(Xi * Xi + dn * dn + wn * wn), Yi = A(Nn), Qi = Nn && -Yi / Nn;
+            ir += Qi * Xi, ar += Qi * dn, vr += Qi * wn, We += Yi, xe += Yi * ($r + ($r = Ar)), ke += Yi * (di + (di = Kr)), vt += Yi * (ji + (ji = ki)), On($r, di, ji);
+          }
+          function Er(At) {
+            Je = We = tt = xt = Ie = xe = ke = vt = ir = ar = vr = 0, H(At, In);
+            var Xt = ir, Cr = ar, Ar = vr, Kr = Xt * Xt + Cr * Cr + Ar * Ar;
+            return Kr < s && (Xt = xe, Cr = ke, Ar = vt, We < o && (Xt = tt, Cr = xt, Ar = Ie), Kr = Xt * Xt + Cr * Cr + Ar * Ar, Kr < s) ? [NaN, NaN] : [b(Cr, Xt) * h, A(Ar / M(Kr)) * h];
+          }
+          function Xr(At) {
+            return function() {
+              return At;
+            };
+          }
+          function ri(At, Xt) {
+            function Cr(Ar, Kr) {
+              return Ar = At(Ar, Kr), Xt(Ar[0], Ar[1]);
+            }
+            return At.invert && Xt.invert && (Cr.invert = function(Ar, Kr) {
+              return Ar = Xt.invert(Ar, Kr), Ar && At.invert(Ar[0], Ar[1]);
+            }), Cr;
+          }
+          function Qr(At, Xt) {
+            return [v(At) > l ? At + Math.round(-At / f) * f : At, Xt];
+          }
+          Qr.invert = Qr;
+          function Oi(At, Xt, Cr) {
+            return (At %= f) ? Xt || Cr ? ri(tn(At), fn(Xt, Cr)) : tn(At) : Xt || Cr ? fn(Xt, Cr) : Qr;
+          }
+          function $i(At) {
+            return function(Xt, Cr) {
+              return Xt += At, [Xt > l ? Xt - f : Xt < -l ? Xt + f : Xt, Cr];
+            };
+          }
+          function tn(At) {
+            var Xt = $i(At);
+            return Xt.invert = $i(-At), Xt;
+          }
+          function fn(At, Xt) {
+            var Cr = p(At), Ar = x(At), Kr = p(Xt), ki = x(Xt);
+            function Xi(dn, wn) {
+              var Nn = p(wn), Yi = p(dn) * Nn, Qi = x(dn) * Nn, on = x(wn), Fi = on * Cr + Yi * Ar;
+              return [b(Qi * Kr - Fi * ki, Yi * Cr - on * Ar), A(Fi * Kr + Qi * ki)];
+            }
+            return Xi.invert = function(dn, wn) {
+              var Nn = p(wn), Yi = p(dn) * Nn, Qi = x(dn) * Nn, on = x(wn), Fi = on * Kr - Qi * ki;
+              return [b(Qi * Kr + on * ki, Yi * Cr + Fi * Ar), A(Fi * Cr - Yi * Ar)];
+            }, Xi;
+          }
+          function yn(At) {
+            At = Oi(At[0] * d, At[1] * d, At.length > 2 ? At[2] * d : 0);
+            function Xt(Cr) {
+              return Cr = At(Cr[0] * d, Cr[1] * d), Cr[0] *= h, Cr[1] *= h, Cr;
+            }
+            return Xt.invert = function(Cr) {
+              return Cr = At.invert(Cr[0] * d, Cr[1] * d), Cr[0] *= h, Cr[1] *= h, Cr;
+            }, Xt;
+          }
+          function Sn(At, Xt, Cr, Ar, Kr, ki) {
+            if (Cr) {
+              var Xi = p(Xt), dn = x(Xt), wn = Ar * Cr;
+              Kr == null ? (Kr = Xt + Ar * f, ki = Xt - wn / 2) : (Kr = Ba(Xi, Kr), ki = Ba(Xi, ki), (Ar > 0 ? Kr < ki : Kr > ki) && (Kr += Ar * f));
+              for (var Nn, Yi = Kr; Ar > 0 ? Yi > ki : Yi < ki; Yi -= wn) Nn = De([Xi, -dn * p(Yi), -dn * x(Yi)]), At.point(Nn[0], Nn[1]);
+            }
+          }
+          function Ba(At, Xt) {
+            Xt = ce(Xt), Xt[0] -= At, ot(Xt);
+            var Cr = P(-Xt[1]);
+            return ((-Xt[2] < 0 ? -Cr : Cr) + f - o) % f;
+          }
+          function ua() {
+            var At = Xr([0, 0]), Xt = Xr(90), Cr = Xr(6), Ar, Kr, ki = { point: Xi };
+            function Xi(wn, Nn) {
+              Ar.push(wn = Kr(wn, Nn)), wn[0] *= h, wn[1] *= h;
+            }
+            function dn() {
+              var wn = At.apply(this, arguments), Nn = Xt.apply(this, arguments) * d, Yi = Cr.apply(this, arguments) * d;
+              return Ar = [], Kr = Oi(-wn[0] * d, -wn[1] * d, 0).invert, Sn(ki, Nn, Yi, 1), wn = { type: "Polygon", coordinates: [Ar] }, Ar = Kr = null, wn;
+            }
+            return dn.center = function(wn) {
+              return arguments.length ? (At = typeof wn == "function" ? wn : Xr([+wn[0], +wn[1]]), dn) : At;
+            }, dn.radius = function(wn) {
+              return arguments.length ? (Xt = typeof wn == "function" ? wn : Xr(+wn), dn) : Xt;
+            }, dn.precision = function(wn) {
+              return arguments.length ? (Cr = typeof wn == "function" ? wn : Xr(+wn), dn) : Cr;
+            }, dn;
+          }
+          function ma() {
+            var At = [], Xt;
+            return { point: function(Cr, Ar, Kr) {
+              Xt.push([Cr, Ar, Kr]);
+            }, lineStart: function() {
+              At.push(Xt = []);
+            }, lineEnd: O, rejoin: function() {
+              At.length > 1 && At.push(At.pop().concat(At.shift()));
+            }, result: function() {
+              var Cr = At;
+              return At = [], Xt = null, Cr;
+            } };
+          }
+          function Wa(At, Xt) {
+            return v(At[0] - Xt[0]) < o && v(At[1] - Xt[1]) < o;
+          }
+          function Fa(At, Xt, Cr, Ar) {
+            this.x = At, this.z = Xt, this.o = Cr, this.e = Ar, this.v = false, this.n = this.p = null;
+          }
+          function Xo(At, Xt, Cr, Ar, Kr) {
+            var ki = [], Xi = [], dn, wn;
+            if (At.forEach(function(Qn) {
+              if (!((Ca = Qn.length - 1) <= 0)) {
+                var Ca, Ra = Qn[0], La = Qn[Ca], Na;
+                if (Wa(Ra, La)) {
+                  if (!Ra[2] && !La[2]) {
+                    for (Kr.lineStart(), dn = 0; dn < Ca; ++dn) Kr.point((Ra = Qn[dn])[0], Ra[1]);
+                    Kr.lineEnd();
+                    return;
+                  }
+                  La[0] += 2 * o;
+                }
+                ki.push(Na = new Fa(Ra, Qn, null, true)), Xi.push(Na.o = new Fa(Ra, null, Na, false)), ki.push(Na = new Fa(La, Qn, null, false)), Xi.push(Na.o = new Fa(La, null, Na, true));
+              }
+            }), !!ki.length) {
+              for (Xi.sort(Xt), da(ki), da(Xi), dn = 0, wn = Xi.length; dn < wn; ++dn) Xi[dn].e = Cr = !Cr;
+              for (var Nn = ki[0], Yi, Qi; ; ) {
+                for (var on = Nn, Fi = true; on.v; ) if ((on = on.n) === Nn) return;
+                Yi = on.z, Kr.lineStart();
+                do {
+                  if (on.v = on.o.v = true, on.e) {
+                    if (Fi) for (dn = 0, wn = Yi.length; dn < wn; ++dn) Kr.point((Qi = Yi[dn])[0], Qi[1]);
+                    else Ar(on.x, on.n.x, 1, Kr);
+                    on = on.n;
+                  } else {
+                    if (Fi) for (Yi = on.p.z, dn = Yi.length - 1; dn >= 0; --dn) Kr.point((Qi = Yi[dn])[0], Qi[1]);
+                    else Ar(on.x, on.p.x, -1, Kr);
+                    on = on.p;
+                  }
+                  on = on.o, Yi = on.z, Fi = !Fi;
+                } while (!on.v);
+                Kr.lineEnd();
+              }
+            }
+          }
+          function da(At) {
+            if (Xt = At.length) {
+              for (var Xt, Cr = 0, Ar = At[0], Kr; ++Cr < Xt; ) Ar.n = Kr = At[Cr], Kr.p = Ar, Ar = Kr;
+              Ar.n = Kr = At[0], Kr.p = Ar;
+            }
+          }
+          var Wn = r();
+          function Ha(At) {
+            return v(At[0]) <= l ? At[0] : C(At[0]) * ((v(At[0]) + l) % f - l);
+          }
+          function vo(At, Xt) {
+            var Cr = Ha(Xt), Ar = Xt[1], Kr = x(Ar), ki = [x(Cr), -p(Cr), 0], Xi = 0, dn = 0;
+            Wn.reset(), Kr === 1 ? Ar = u + o : Kr === -1 && (Ar = -u - o);
+            for (var wn = 0, Nn = At.length; wn < Nn; ++wn) if (Qi = (Yi = At[wn]).length) for (var Yi, Qi, on = Yi[Qi - 1], Fi = Ha(on), Qn = on[1] / 2 + c, Ca = x(Qn), Ra = p(Qn), La = 0; La < Qi; ++La, Fi = Yn, Ca = Ka, Ra = bo, on = Na) {
+              var Na = Yi[La], Yn = Ha(Na), Dn = Na[1] / 2 + c, Ka = x(Dn), bo = p(Dn), Zo = Yn - Fi, Ss = Zo >= 0 ? 1 : -1, as = Ss * Zo, ws = as > l, Ho = Ca * Ka;
+              if (Wn.add(b(Ho * Ss * x(as), Ra * bo + Ho * p(as))), Xi += ws ? Zo + Ss * f : Zo, ws ^ Fi >= Cr ^ Yn >= Cr) {
+                var ml = lt(ce(on), ce(Na));
+                ot(ml);
+                var Ws = lt(ki, ml);
+                ot(Ws);
+                var Ls = (ws ^ Zo >= 0 ? -1 : 1) * A(Ws[2]);
+                (Ar > Ls || Ar === Ls && (ml[0] || ml[1])) && (dn += ws ^ Zo >= 0 ? 1 : -1);
+              }
+            }
+            return (Xi < -1e-6 || Xi < o && Wn < -1e-6) ^ dn & 1;
+          }
+          function jn(At, Xt, Cr, Ar) {
+            return function(Kr) {
+              var ki = Xt(Kr), Xi = ma(), dn = Xt(Xi), wn = false, Nn, Yi, Qi, on = { point: Fi, lineStart: Ca, lineEnd: Ra, polygonStart: function() {
+                on.point = La, on.lineStart = Na, on.lineEnd = Yn, Yi = [], Nn = [];
+              }, polygonEnd: function() {
+                on.point = Fi, on.lineStart = Ca, on.lineEnd = Ra, Yi = t.merge(Yi);
+                var Dn = vo(Nn, Ar);
+                Yi.length ? (wn || (Kr.polygonStart(), wn = true), Xo(Yi, kr, Dn, Cr, Kr)) : Dn && (wn || (Kr.polygonStart(), wn = true), Kr.lineStart(), Cr(null, null, 1, Kr), Kr.lineEnd()), wn && (Kr.polygonEnd(), wn = false), Yi = Nn = null;
+              }, sphere: function() {
+                Kr.polygonStart(), Kr.lineStart(), Cr(null, null, 1, Kr), Kr.lineEnd(), Kr.polygonEnd();
+              } };
+              function Fi(Dn, Ka) {
+                At(Dn, Ka) && Kr.point(Dn, Ka);
+              }
+              function Qn(Dn, Ka) {
+                ki.point(Dn, Ka);
+              }
+              function Ca() {
+                on.point = Qn, ki.lineStart();
+              }
+              function Ra() {
+                on.point = Fi, ki.lineEnd();
+              }
+              function La(Dn, Ka) {
+                Qi.push([Dn, Ka]), dn.point(Dn, Ka);
+              }
+              function Na() {
+                dn.lineStart(), Qi = [];
+              }
+              function Yn() {
+                La(Qi[0][0], Qi[0][1]), dn.lineEnd();
+                var Dn = dn.clean(), Ka = Xi.result(), bo, Zo = Ka.length, Ss, as, ws;
+                if (Qi.pop(), Nn.push(Qi), Qi = null, !!Zo) {
+                  if (Dn & 1) {
+                    if (as = Ka[0], (Ss = as.length - 1) > 0) {
+                      for (wn || (Kr.polygonStart(), wn = true), Kr.lineStart(), bo = 0; bo < Ss; ++bo) Kr.point((ws = as[bo])[0], ws[1]);
+                      Kr.lineEnd();
+                    }
+                    return;
+                  }
+                  Zo > 1 && Dn & 2 && Ka.push(Ka.pop().concat(Ka.shift())), Yi.push(Ka.filter(Mt));
+                }
+              }
+              return on;
+            };
+          }
+          function Mt(At) {
+            return At.length > 1;
+          }
+          function kr(At, Xt) {
+            return ((At = At.x)[0] < 0 ? At[1] - u - o : u - At[1]) - ((Xt = Xt.x)[0] < 0 ? Xt[1] - u - o : u - Xt[1]);
+          }
+          var Jr = jn(function() {
+            return true;
+          }, vi, An, [-l, -u]);
+          function vi(At) {
+            var Xt = NaN, Cr = NaN, Ar = NaN, Kr;
+            return { lineStart: function() {
+              At.lineStart(), Kr = 1;
+            }, point: function(ki, Xi) {
+              var dn = ki > 0 ? l : -l, wn = v(ki - Xt);
+              v(wn - l) < o ? (At.point(Xt, Cr = (Cr + Xi) / 2 > 0 ? u : -u), At.point(Ar, Cr), At.lineEnd(), At.lineStart(), At.point(dn, Cr), At.point(ki, Cr), Kr = 0) : Ar !== dn && wn >= l && (v(Xt - Ar) < o && (Xt -= Ar * o), v(ki - dn) < o && (ki -= dn * o), Cr = hn(Xt, Cr, ki, Xi), At.point(Ar, Cr), At.lineEnd(), At.lineStart(), At.point(dn, Cr), Kr = 0), At.point(Xt = ki, Cr = Xi), Ar = dn;
+            }, lineEnd: function() {
+              At.lineEnd(), Xt = Cr = NaN;
+            }, clean: function() {
+              return 2 - Kr;
+            } };
+          }
+          function hn(At, Xt, Cr, Ar) {
+            var Kr, ki, Xi = x(At - Cr);
+            return v(Xi) > o ? _((x(Xt) * (ki = p(Ar)) * x(Cr) - x(Ar) * (Kr = p(Xt)) * x(At)) / (Kr * ki * Xi)) : (Xt + Ar) / 2;
+          }
+          function An(At, Xt, Cr, Ar) {
+            var Kr;
+            if (At == null) Kr = Cr * u, Ar.point(-l, Kr), Ar.point(0, Kr), Ar.point(l, Kr), Ar.point(l, 0), Ar.point(l, -Kr), Ar.point(0, -Kr), Ar.point(-l, -Kr), Ar.point(-l, 0), Ar.point(-l, Kr);
+            else if (v(At[0] - Xt[0]) > o) {
+              var ki = At[0] < Xt[0] ? l : -l;
+              Kr = Cr * ki / 2, Ar.point(-ki, Kr), Ar.point(0, Kr), Ar.point(ki, Kr);
+            } else Ar.point(Xt[0], Xt[1]);
+          }
+          function Mn(At) {
+            var Xt = p(At), Cr = 6 * d, Ar = Xt > 0, Kr = v(Xt) > o;
+            function ki(Yi, Qi, on, Fi) {
+              Sn(Fi, At, Cr, on, Yi, Qi);
+            }
+            function Xi(Yi, Qi) {
+              return p(Yi) * p(Qi) > Xt;
+            }
+            function dn(Yi) {
+              var Qi, on, Fi, Qn, Ca;
+              return { lineStart: function() {
+                Qn = Fi = false, Ca = 1;
+              }, point: function(Ra, La) {
+                var Na = [Ra, La], Yn, Dn = Xi(Ra, La), Ka = Ar ? Dn ? 0 : Nn(Ra, La) : Dn ? Nn(Ra + (Ra < 0 ? l : -l), La) : 0;
+                if (!Qi && (Qn = Fi = Dn) && Yi.lineStart(), Dn !== Fi && (Yn = wn(Qi, Na), (!Yn || Wa(Qi, Yn) || Wa(Na, Yn)) && (Na[2] = 1)), Dn !== Fi) Ca = 0, Dn ? (Yi.lineStart(), Yn = wn(Na, Qi), Yi.point(Yn[0], Yn[1])) : (Yn = wn(Qi, Na), Yi.point(Yn[0], Yn[1], 2), Yi.lineEnd()), Qi = Yn;
+                else if (Kr && Qi && Ar ^ Dn) {
+                  var bo;
+                  !(Ka & on) && (bo = wn(Na, Qi, true)) && (Ca = 0, Ar ? (Yi.lineStart(), Yi.point(bo[0][0], bo[0][1]), Yi.point(bo[1][0], bo[1][1]), Yi.lineEnd()) : (Yi.point(bo[1][0], bo[1][1]), Yi.lineEnd(), Yi.lineStart(), Yi.point(bo[0][0], bo[0][1], 3)));
+                }
+                Dn && (!Qi || !Wa(Qi, Na)) && Yi.point(Na[0], Na[1]), Qi = Na, Fi = Dn, on = Ka;
+              }, lineEnd: function() {
+                Fi && Yi.lineEnd(), Qi = null;
+              }, clean: function() {
+                return Ca | (Qn && Fi) << 1;
+              } };
+            }
+            function wn(Yi, Qi, on) {
+              var Fi = ce(Yi), Qn = ce(Qi), Ca = [1, 0, 0], Ra = lt(Fi, Qn), La = je(Ra, Ra), Na = Ra[0], Yn = La - Na * Na;
+              if (!Yn) return !on && Yi;
+              var Dn = Xt * La / Yn, Ka = -Xt * Na / Yn, bo = lt(Ca, Ra), Zo = Vt(Ca, Dn), Ss = Vt(Ra, Ka);
+              pt(Zo, Ss);
+              var as = bo, ws = je(Zo, as), Ho = je(as, as), ml = ws * ws - Ho * (je(Zo, Zo) - 1);
+              if (!(ml < 0)) {
+                var Ws = M(ml), Ls = Vt(as, (-ws - Ws) / Ho);
+                if (pt(Ls, Zo), Ls = De(Ls), !on) return Ls;
+                var va = Yi[0], no = Qi[0], ys = Yi[1], rs = Qi[1], Ql;
+                no < va && (Ql = va, va = no, no = Ql);
+                var Cu = no - va, Yu = v(Cu - l) < o, Nc = Yu || Cu < o;
+                if (!Yu && rs < ys && (Ql = ys, ys = rs, rs = Ql), Nc ? Yu ? ys + rs > 0 ^ Ls[1] < (v(Ls[0] - va) < o ? ys : rs) : ys <= Ls[1] && Ls[1] <= rs : Cu > l ^ (va <= Ls[0] && Ls[0] <= no)) {
+                  var pu = Vt(as, (-ws + Ws) / Ho);
+                  return pt(pu, Zo), [Ls, De(pu)];
+                }
+              }
+            }
+            function Nn(Yi, Qi) {
+              var on = Ar ? At : l - At, Fi = 0;
+              return Yi < -on ? Fi |= 1 : Yi > on && (Fi |= 2), Qi < -on ? Fi |= 4 : Qi > on && (Fi |= 8), Fi;
+            }
+            return jn(Xi, dn, ki, Ar ? [0, -At] : [-l, At - l]);
+          }
+          function Li(At, Xt, Cr, Ar, Kr, ki) {
+            var Xi = At[0], dn = At[1], wn = Xt[0], Nn = Xt[1], Yi = 0, Qi = 1, on = wn - Xi, Fi = Nn - dn, Qn;
+            if (Qn = Cr - Xi, !(!on && Qn > 0)) {
+              if (Qn /= on, on < 0) {
+                if (Qn < Yi) return;
+                Qn < Qi && (Qi = Qn);
+              } else if (on > 0) {
+                if (Qn > Qi) return;
+                Qn > Yi && (Yi = Qn);
+              }
+              if (Qn = Kr - Xi, !(!on && Qn < 0)) {
+                if (Qn /= on, on < 0) {
+                  if (Qn > Qi) return;
+                  Qn > Yi && (Yi = Qn);
+                } else if (on > 0) {
+                  if (Qn < Yi) return;
+                  Qn < Qi && (Qi = Qn);
+                }
+                if (Qn = Ar - dn, !(!Fi && Qn > 0)) {
+                  if (Qn /= Fi, Fi < 0) {
+                    if (Qn < Yi) return;
+                    Qn < Qi && (Qi = Qn);
+                  } else if (Fi > 0) {
+                    if (Qn > Qi) return;
+                    Qn > Yi && (Yi = Qn);
+                  }
+                  if (Qn = ki - dn, !(!Fi && Qn < 0)) {
+                    if (Qn /= Fi, Fi < 0) {
+                      if (Qn > Qi) return;
+                      Qn > Yi && (Yi = Qn);
+                    } else if (Fi > 0) {
+                      if (Qn < Yi) return;
+                      Qn < Qi && (Qi = Qn);
+                    }
+                    return Yi > 0 && (At[0] = Xi + Yi * on, At[1] = dn + Yi * Fi), Qi < 1 && (Xt[0] = Xi + Qi * on, Xt[1] = dn + Qi * Fi), true;
+                  }
+                }
+              }
+            }
+          }
+          var _n = 1e9, ya = -1e9;
+          function $n(At, Xt, Cr, Ar) {
+            function Kr(Nn, Yi) {
+              return At <= Nn && Nn <= Cr && Xt <= Yi && Yi <= Ar;
+            }
+            function ki(Nn, Yi, Qi, on) {
+              var Fi = 0, Qn = 0;
+              if (Nn == null || (Fi = Xi(Nn, Qi)) !== (Qn = Xi(Yi, Qi)) || wn(Nn, Yi) < 0 ^ Qi > 0) do
+                on.point(Fi === 0 || Fi === 3 ? At : Cr, Fi > 1 ? Ar : Xt);
+              while ((Fi = (Fi + Qi + 4) % 4) !== Qn);
+              else on.point(Yi[0], Yi[1]);
+            }
+            function Xi(Nn, Yi) {
+              return v(Nn[0] - At) < o ? Yi > 0 ? 0 : 3 : v(Nn[0] - Cr) < o ? Yi > 0 ? 2 : 1 : v(Nn[1] - Xt) < o ? Yi > 0 ? 1 : 0 : Yi > 0 ? 3 : 2;
+            }
+            function dn(Nn, Yi) {
+              return wn(Nn.x, Yi.x);
+            }
+            function wn(Nn, Yi) {
+              var Qi = Xi(Nn, 1), on = Xi(Yi, 1);
+              return Qi !== on ? Qi - on : Qi === 0 ? Yi[1] - Nn[1] : Qi === 1 ? Nn[0] - Yi[0] : Qi === 2 ? Nn[1] - Yi[1] : Yi[0] - Nn[0];
+            }
+            return function(Nn) {
+              var Yi = Nn, Qi = ma(), on, Fi, Qn, Ca, Ra, La, Na, Yn, Dn, Ka, bo, Zo = { point: Ss, lineStart: ml, lineEnd: Ws, polygonStart: ws, polygonEnd: Ho };
+              function Ss(va, no) {
+                Kr(va, no) && Yi.point(va, no);
+              }
+              function as() {
+                for (var va = 0, no = 0, ys = Fi.length; no < ys; ++no) for (var rs = Fi[no], Ql = 1, Cu = rs.length, Yu = rs[0], Nc, pu, Uc = Yu[0], xu = Yu[1]; Ql < Cu; ++Ql) Nc = Uc, pu = xu, Yu = rs[Ql], Uc = Yu[0], xu = Yu[1], pu <= Ar ? xu > Ar && (Uc - Nc) * (Ar - pu) > (xu - pu) * (At - Nc) && ++va : xu <= Ar && (Uc - Nc) * (Ar - pu) < (xu - pu) * (At - Nc) && --va;
+                return va;
+              }
+              function ws() {
+                Yi = Qi, on = [], Fi = [], bo = true;
+              }
+              function Ho() {
+                var va = as(), no = bo && va, ys = (on = t.merge(on)).length;
+                (no || ys) && (Nn.polygonStart(), no && (Nn.lineStart(), ki(null, null, 1, Nn), Nn.lineEnd()), ys && Xo(on, dn, va, ki, Nn), Nn.polygonEnd()), Yi = Nn, on = Fi = Qn = null;
+              }
+              function ml() {
+                Zo.point = Ls, Fi && Fi.push(Qn = []), Ka = true, Dn = false, Na = Yn = NaN;
+              }
+              function Ws() {
+                on && (Ls(Ca, Ra), La && Dn && Qi.rejoin(), on.push(Qi.result())), Zo.point = Ss, Dn && Yi.lineEnd();
+              }
+              function Ls(va, no) {
+                var ys = Kr(va, no);
+                if (Fi && Qn.push([va, no]), Ka) Ca = va, Ra = no, La = ys, Ka = false, ys && (Yi.lineStart(), Yi.point(va, no));
+                else if (ys && Dn) Yi.point(va, no);
+                else {
+                  var rs = [Na = Math.max(ya, Math.min(_n, Na)), Yn = Math.max(ya, Math.min(_n, Yn))], Ql = [va = Math.max(ya, Math.min(_n, va)), no = Math.max(ya, Math.min(_n, no))];
+                  Li(rs, Ql, At, Xt, Cr, Ar) ? (Dn || (Yi.lineStart(), Yi.point(rs[0], rs[1])), Yi.point(Ql[0], Ql[1]), ys || Yi.lineEnd(), bo = false) : ys && (Yi.lineStart(), Yi.point(va, no), bo = false);
+                }
+                Na = va, Yn = no, Dn = ys;
+              }
+              return Zo;
+            };
+          }
+          function Ma() {
+            var At = 0, Xt = 0, Cr = 960, Ar = 500, Kr, ki, Xi;
+            return Xi = { stream: function(dn) {
+              return Kr && ki === dn ? Kr : Kr = $n(At, Xt, Cr, Ar)(ki = dn);
+            }, extent: function(dn) {
+              return arguments.length ? (At = +dn[0][0], Xt = +dn[0][1], Cr = +dn[1][0], Ar = +dn[1][1], Kr = ki = null, Xi) : [[At, Xt], [Cr, Ar]];
+            } };
+          }
+          var _o = r(), No, po, Lo, ko = { sphere: O, point: O, lineStart: Ds, lineEnd: O, polygonStart: O, polygonEnd: O };
+          function Ds() {
+            ko.point = ll, ko.lineEnd = Fs;
+          }
+          function Fs() {
+            ko.point = ko.lineEnd = O;
+          }
+          function ll(At, Xt) {
+            At *= d, Xt *= d, No = At, po = x(Xt), Lo = p(Xt), ko.point = ul;
+          }
+          function ul(At, Xt) {
+            At *= d, Xt *= d;
+            var Cr = x(Xt), Ar = p(Xt), Kr = v(At - No), ki = p(Kr), Xi = x(Kr), dn = Ar * Xi, wn = Lo * Cr - po * Ar * ki, Nn = po * Cr + Lo * Ar * ki;
+            _o.add(b(M(dn * dn + wn * wn), Nn)), No = At, po = Cr, Lo = Ar;
+          }
+          function zl(At) {
+            return _o.reset(), H(At, ko), +_o;
+          }
+          var us = [null, null], il = { type: "LineString", coordinates: us };
+          function As(At, Xt) {
+            return us[0] = At, us[1] = Xt, zl(il);
+          }
+          var cl = { Feature: function(At, Xt) {
+            return zs(At.geometry, Xt);
+          }, FeatureCollection: function(At, Xt) {
+            for (var Cr = At.features, Ar = -1, Kr = Cr.length; ++Ar < Kr; ) if (zs(Cr[Ar].geometry, Xt)) return true;
+            return false;
+          } }, Ks = { Sphere: function() {
+            return true;
+          }, Point: function(At, Xt) {
+            return Io(At.coordinates, Xt);
+          }, MultiPoint: function(At, Xt) {
+            for (var Cr = At.coordinates, Ar = -1, Kr = Cr.length; ++Ar < Kr; ) if (Io(Cr[Ar], Xt)) return true;
+            return false;
+          }, LineString: function(At, Xt) {
+            return ls(At.coordinates, Xt);
+          }, MultiLineString: function(At, Xt) {
+            for (var Cr = At.coordinates, Ar = -1, Kr = Cr.length; ++Ar < Kr; ) if (ls(Cr[Ar], Xt)) return true;
+            return false;
+          }, Polygon: function(At, Xt) {
+            return Yl(At.coordinates, Xt);
+          }, MultiPolygon: function(At, Xt) {
+            for (var Cr = At.coordinates, Ar = -1, Kr = Cr.length; ++Ar < Kr; ) if (Yl(Cr[Ar], Xt)) return true;
+            return false;
+          }, GeometryCollection: function(At, Xt) {
+            for (var Cr = At.geometries, Ar = -1, Kr = Cr.length; ++Ar < Kr; ) if (zs(Cr[Ar], Xt)) return true;
+            return false;
+          } };
+          function zs(At, Xt) {
+            return At && Ks.hasOwnProperty(At.type) ? Ks[At.type](At, Xt) : false;
+          }
+          function Io(At, Xt) {
+            return As(At, Xt) === 0;
+          }
+          function ls(At, Xt) {
+            for (var Cr, Ar, Kr, ki = 0, Xi = At.length; ki < Xi; ki++) {
+              if (Ar = As(At[ki], Xt), Ar === 0 || ki > 0 && (Kr = As(At[ki], At[ki - 1]), Kr > 0 && Cr <= Kr && Ar <= Kr && (Cr + Ar - Kr) * (1 - Math.pow((Cr - Ar) / Kr, 2)) < s * Kr)) return true;
+              Cr = Ar;
+            }
+            return false;
+          }
+          function Yl(At, Xt) {
+            return !!vo(At.map(Su), nc(Xt));
+          }
+          function Su(At) {
+            return At = At.map(nc), At.pop(), At;
+          }
+          function nc(At) {
+            return [At[0] * d, At[1] * d];
+          }
+          function bs(At, Xt) {
+            return (At && cl.hasOwnProperty(At.type) ? cl[At.type] : zs)(At, Xt);
+          }
+          function Rn(At, Xt, Cr) {
+            var Ar = t.range(At, Xt - o, Cr).concat(Xt);
+            return function(Kr) {
+              return Ar.map(function(ki) {
+                return [Kr, ki];
+              });
+            };
+          }
+          function _a(At, Xt, Cr) {
+            var Ar = t.range(At, Xt - o, Cr).concat(Xt);
+            return function(Kr) {
+              return Ar.map(function(ki) {
+                return [ki, Kr];
+              });
+            };
+          }
+          function Vu() {
+            var At, Xt, Cr, Ar, Kr, ki, Xi, dn, wn = 10, Nn = wn, Yi = 90, Qi = 360, on, Fi, Qn, Ca, Ra = 2.5;
+            function La() {
+              return { type: "MultiLineString", coordinates: Na() };
+            }
+            function Na() {
+              return t.range(k(Ar / Yi) * Yi, Cr, Yi).map(Qn).concat(t.range(k(dn / Qi) * Qi, Xi, Qi).map(Ca)).concat(t.range(k(Xt / wn) * wn, At, wn).filter(function(Yn) {
+                return v(Yn % Yi) > o;
+              }).map(on)).concat(t.range(k(ki / Nn) * Nn, Kr, Nn).filter(function(Yn) {
+                return v(Yn % Qi) > o;
+              }).map(Fi));
+            }
+            return La.lines = function() {
+              return Na().map(function(Yn) {
+                return { type: "LineString", coordinates: Yn };
+              });
+            }, La.outline = function() {
+              return { type: "Polygon", coordinates: [Qn(Ar).concat(Ca(Xi).slice(1), Qn(Cr).reverse().slice(1), Ca(dn).reverse().slice(1))] };
+            }, La.extent = function(Yn) {
+              return arguments.length ? La.extentMajor(Yn).extentMinor(Yn) : La.extentMinor();
+            }, La.extentMajor = function(Yn) {
+              return arguments.length ? (Ar = +Yn[0][0], Cr = +Yn[1][0], dn = +Yn[0][1], Xi = +Yn[1][1], Ar > Cr && (Yn = Ar, Ar = Cr, Cr = Yn), dn > Xi && (Yn = dn, dn = Xi, Xi = Yn), La.precision(Ra)) : [[Ar, dn], [Cr, Xi]];
+            }, La.extentMinor = function(Yn) {
+              return arguments.length ? (Xt = +Yn[0][0], At = +Yn[1][0], ki = +Yn[0][1], Kr = +Yn[1][1], Xt > At && (Yn = Xt, Xt = At, At = Yn), ki > Kr && (Yn = ki, ki = Kr, Kr = Yn), La.precision(Ra)) : [[Xt, ki], [At, Kr]];
+            }, La.step = function(Yn) {
+              return arguments.length ? La.stepMajor(Yn).stepMinor(Yn) : La.stepMinor();
+            }, La.stepMajor = function(Yn) {
+              return arguments.length ? (Yi = +Yn[0], Qi = +Yn[1], La) : [Yi, Qi];
+            }, La.stepMinor = function(Yn) {
+              return arguments.length ? (wn = +Yn[0], Nn = +Yn[1], La) : [wn, Nn];
+            }, La.precision = function(Yn) {
+              return arguments.length ? (Ra = +Yn, on = Rn(ki, Kr, 90), Fi = _a(Xt, At, Ra), Qn = Rn(dn, Xi, 90), Ca = _a(Ar, Cr, Ra), La) : Ra;
+            }, La.extentMajor([[-180, -90 + o], [180, 90 - o]]).extentMinor([[-180, -80 - o], [180, 80 + o]]);
+          }
+          function Ol() {
+            return Vu()();
+          }
+          function xo(At, Xt) {
+            var Cr = At[0] * d, Ar = At[1] * d, Kr = Xt[0] * d, ki = Xt[1] * d, Xi = p(Ar), dn = x(Ar), wn = p(ki), Nn = x(ki), Yi = Xi * p(Cr), Qi = Xi * x(Cr), on = wn * p(Kr), Fi = wn * x(Kr), Qn = 2 * A(M(z(ki - Ar) + Xi * wn * z(Kr - Cr))), Ca = x(Qn), Ra = Qn ? function(La) {
+              var Na = x(La *= Qn) / Ca, Yn = x(Qn - La) / Ca, Dn = Yn * Yi + Na * on, Ka = Yn * Qi + Na * Fi, bo = Yn * dn + Na * Nn;
+              return [b(Ka, Dn) * h, b(bo, M(Dn * Dn + Ka * Ka)) * h];
+            } : function() {
+              return [Cr * h, Ar * h];
+            };
+            return Ra.distance = Qn, Ra;
+          }
+          function Kl(At) {
+            return At;
+          }
+          var Ns = r(), Hl = r(), ac, aa, Oo, qo, ql = { point: O, lineStart: O, lineEnd: O, polygonStart: function() {
+            ql.lineStart = Pc, ql.lineEnd = Vf;
+          }, polygonEnd: function() {
+            ql.lineStart = ql.lineEnd = ql.point = O, Ns.add(v(Hl)), Hl.reset();
+          }, result: function() {
+            var At = Ns / 2;
+            return Ns.reset(), At;
+          } };
+          function Pc() {
+            ql.point = Do;
+          }
+          function Do(At, Xt) {
+            ql.point = rf, ac = Oo = At, aa = qo = Xt;
+          }
+          function rf(At, Xt) {
+            Hl.add(qo * At - Oo * Xt), Oo = At, qo = Xt;
+          }
+          function Vf() {
+            rf(ac, aa);
+          }
+          var pl = 1 / 0, Zc = pl, Jl = -pl, Os = Jl, yu = { point: oc, lineStart: O, lineEnd: O, polygonStart: O, polygonEnd: O, result: function() {
+            var At = [[pl, Zc], [Jl, Os]];
+            return Jl = Os = -(Zc = pl = 1 / 0), At;
+          } };
+          function oc(At, Xt) {
+            At < pl && (pl = At), At > Jl && (Jl = At), Xt < Zc && (Zc = Xt), Xt > Os && (Os = Xt);
+          }
+          var Cf = 0, sc = 0, jh = 0, Lf = 0, cs = 0, nf = 0, Gf = 0, $l = 0, fl = 0, lc, Fu, Es, Hs, Go = { point: ps, lineStart: uc, lineEnd: qs, polygonStart: function() {
+            Go.lineStart = od, Go.lineEnd = Po;
+          }, polygonEnd: function() {
+            Go.point = ps, Go.lineStart = uc, Go.lineEnd = qs;
+          }, result: function() {
+            var At = fl ? [Gf / fl, $l / fl] : nf ? [Lf / nf, cs / nf] : jh ? [Cf / jh, sc / jh] : [NaN, NaN];
+            return Cf = sc = jh = Lf = cs = nf = Gf = $l = fl = 0, At;
+          } };
+          function ps(At, Xt) {
+            Cf += At, sc += Xt, ++jh;
+          }
+          function uc() {
+            Go.point = xl;
+          }
+          function xl(At, Xt) {
+            Go.point = Gu, ps(Es = At, Hs = Xt);
+          }
+          function Gu(At, Xt) {
+            var Cr = At - Es, Ar = Xt - Hs, Kr = M(Cr * Cr + Ar * Ar);
+            Lf += Kr * (Es + At) / 2, cs += Kr * (Hs + Xt) / 2, nf += Kr, ps(Es = At, Hs = Xt);
+          }
+          function qs() {
+            Go.point = ps;
+          }
+          function od() {
+            Go.point = sd;
+          }
+          function Po() {
+            Ko(lc, Fu);
+          }
+          function sd(At, Xt) {
+            Go.point = Ko, ps(lc = Es = At, Fu = Hs = Xt);
+          }
+          function Ko(At, Xt) {
+            var Cr = At - Es, Ar = Xt - Hs, Kr = M(Cr * Cr + Ar * Ar);
+            Lf += Kr * (Es + At) / 2, cs += Kr * (Hs + Xt) / 2, nf += Kr, Kr = Hs * At - Es * Xt, Gf += Kr * (Es + At), $l += Kr * (Hs + Xt), fl += Kr * 3, ps(Es = At, Hs = Xt);
+          }
+          function Pa(At) {
+            this._context = At;
+          }
+          Pa.prototype = { _radius: 4.5, pointRadius: function(At) {
+            return this._radius = At, this;
+          }, polygonStart: function() {
+            this._line = 0;
+          }, polygonEnd: function() {
+            this._line = NaN;
+          }, lineStart: function() {
+            this._point = 0;
+          }, lineEnd: function() {
+            this._line === 0 && this._context.closePath(), this._point = NaN;
+          }, point: function(At, Xt) {
+            switch (this._point) {
+              case 0: {
+                this._context.moveTo(At, Xt), this._point = 1;
+                break;
+              }
+              case 1: {
+                this._context.lineTo(At, Xt);
+                break;
+              }
+              default: {
+                this._context.moveTo(At + this._radius, Xt), this._context.arc(At, Xt, this._radius, 0, f);
+                break;
+              }
+            }
+          }, result: O };
+          var af = r(), Hu, bl, Hf, Ic, yf, Bl = { point: O, lineStart: function() {
+            Bl.point = Ah;
+          }, lineEnd: function() {
+            Hu && Qf(bl, Hf), Bl.point = O;
+          }, polygonStart: function() {
+            Hu = true;
+          }, polygonEnd: function() {
+            Hu = null;
+          }, result: function() {
+            var At = +af;
+            return af.reset(), At;
+          } };
+          function Ah(At, Xt) {
+            Bl.point = Qf, bl = Ic = At, Hf = yf = Xt;
+          }
+          function Qf(At, Xt) {
+            Ic -= At, yf -= Xt, af.add(M(Ic * Ic + yf * yf)), Ic = At, yf = Xt;
+          }
+          function _f() {
+            this._string = [];
+          }
+          _f.prototype = { _radius: 4.5, _circle: Yc(4.5), pointRadius: function(At) {
+            return (At = +At) !== this._radius && (this._radius = At, this._circle = null), this;
+          }, polygonStart: function() {
+            this._line = 0;
+          }, polygonEnd: function() {
+            this._line = NaN;
+          }, lineStart: function() {
+            this._point = 0;
+          }, lineEnd: function() {
+            this._line === 0 && this._string.push("Z"), this._point = NaN;
+          }, point: function(At, Xt) {
+            switch (this._point) {
+              case 0: {
+                this._string.push("M", At, ",", Xt), this._point = 1;
+                break;
+              }
+              case 1: {
+                this._string.push("L", At, ",", Xt);
+                break;
+              }
+              default: {
+                this._circle == null && (this._circle = Yc(this._radius)), this._string.push("M", At, ",", Xt, this._circle);
+                break;
+              }
+            }
+          }, result: function() {
+            if (this._string.length) {
+              var At = this._string.join("");
+              return this._string = [], At;
+            } else return null;
+          } };
+          function Yc(At) {
+            return "m0," + At + "a" + At + "," + At + " 0 1,1 0," + -2 * At + "a" + At + "," + At + " 0 1,1 0," + 2 * At + "z";
+          }
+          function eh(At, Xt) {
+            var Cr = 4.5, Ar, Kr;
+            function ki(Xi) {
+              return Xi && (typeof Cr == "function" && Kr.pointRadius(+Cr.apply(this, arguments)), H(Xi, Ar(Kr))), Kr.result();
+            }
+            return ki.area = function(Xi) {
+              return H(Xi, Ar(ql)), ql.result();
+            }, ki.measure = function(Xi) {
+              return H(Xi, Ar(Bl)), Bl.result();
+            }, ki.bounds = function(Xi) {
+              return H(Xi, Ar(yu)), yu.result();
+            }, ki.centroid = function(Xi) {
+              return H(Xi, Ar(Go)), Go.result();
+            }, ki.projection = function(Xi) {
+              return arguments.length ? (Ar = Xi == null ? (At = null, Kl) : (At = Xi).stream, ki) : At;
+            }, ki.context = function(Xi) {
+              return arguments.length ? (Kr = Xi == null ? (Xt = null, new _f()) : new Pa(Xt = Xi), typeof Cr != "function" && Kr.pointRadius(Cr), ki) : Xt;
+            }, ki.pointRadius = function(Xi) {
+              return arguments.length ? (Cr = typeof Xi == "function" ? Xi : (Kr.pointRadius(+Xi), +Xi), ki) : Cr;
+            }, ki.projection(At).context(Xt);
+          }
+          function th(At) {
+            return { stream: ju(At) };
+          }
+          function ju(At) {
+            return function(Xt) {
+              var Cr = new jf();
+              for (var Ar in At) Cr[Ar] = At[Ar];
+              return Cr.stream = Xt, Cr;
+            };
+          }
+          function jf() {
+          }
+          jf.prototype = { constructor: jf, point: function(At, Xt) {
+            this.stream.point(At, Xt);
+          }, 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();
+          } };
+          function cc(At, Xt, Cr) {
+            var Ar = At.clipExtent && At.clipExtent();
+            return At.scale(150).translate([0, 0]), Ar != null && At.clipExtent(null), H(Cr, At.stream(yu)), Xt(yu.result()), Ar != null && At.clipExtent(Ar), At;
+          }
+          function of(At, Xt, Cr) {
+            return cc(At, function(Ar) {
+              var Kr = Xt[1][0] - Xt[0][0], ki = Xt[1][1] - Xt[0][1], Xi = Math.min(Kr / (Ar[1][0] - Ar[0][0]), ki / (Ar[1][1] - Ar[0][1])), dn = +Xt[0][0] + (Kr - Xi * (Ar[1][0] + Ar[0][0])) / 2, wn = +Xt[0][1] + (ki - Xi * (Ar[1][1] + Ar[0][1])) / 2;
+              At.scale(150 * Xi).translate([dn, wn]);
+            }, Cr);
+          }
+          function Nl(At, Xt, Cr) {
+            return of(At, [[0, 0], Xt], Cr);
+          }
+          function Kc(At, Xt, Cr) {
+            return cc(At, function(Ar) {
+              var Kr = +Xt, ki = Kr / (Ar[1][0] - Ar[0][0]), Xi = (Kr - ki * (Ar[1][0] + Ar[0][0])) / 2, dn = -ki * Ar[0][1];
+              At.scale(150 * ki).translate([Xi, dn]);
+            }, Cr);
+          }
+          function Rc(At, Xt, Cr) {
+            return cc(At, function(Ar) {
+              var Kr = +Xt, ki = Kr / (Ar[1][1] - Ar[0][1]), Xi = -ki * Ar[0][0], dn = (Kr - ki * (Ar[1][1] + Ar[0][1])) / 2;
+              At.scale(150 * ki).translate([Xi, dn]);
+            }, Cr);
+          }
+          var gs = 16, Wf = p(30 * d);
+          function Wh(At, Xt) {
+            return +Xt ? sf(At, Xt) : rh(At);
+          }
+          function rh(At) {
+            return ju({ point: function(Xt, Cr) {
+              Xt = At(Xt, Cr), this.stream.point(Xt[0], Xt[1]);
+            } });
+          }
+          function sf(At, Xt) {
+            function Cr(Ar, Kr, ki, Xi, dn, wn, Nn, Yi, Qi, on, Fi, Qn, Ca, Ra) {
+              var La = Nn - Ar, Na = Yi - Kr, Yn = La * La + Na * Na;
+              if (Yn > 4 * Xt && Ca--) {
+                var Dn = Xi + on, Ka = dn + Fi, bo = wn + Qn, Zo = M(Dn * Dn + Ka * Ka + bo * bo), Ss = A(bo /= Zo), as = v(v(bo) - 1) < o || v(ki - Qi) < o ? (ki + Qi) / 2 : b(Ka, Dn), ws = At(as, Ss), Ho = ws[0], ml = ws[1], Ws = Ho - Ar, Ls = ml - Kr, va = Na * Ws - La * Ls;
+                (va * va / Yn > Xt || v((La * Ws + Na * Ls) / Yn - 0.5) > 0.3 || Xi * on + dn * Fi + wn * Qn < Wf) && (Cr(Ar, Kr, ki, Xi, dn, wn, Ho, ml, as, Dn /= Zo, Ka /= Zo, bo, Ca, Ra), Ra.point(Ho, ml), Cr(Ho, ml, as, Dn, Ka, bo, Nn, Yi, Qi, on, Fi, Qn, Ca, Ra));
+              }
+            }
+            return function(Ar) {
+              var Kr, ki, Xi, dn, wn, Nn, Yi, Qi, on, Fi, Qn, Ca, Ra = { point: La, lineStart: Na, lineEnd: Dn, polygonStart: function() {
+                Ar.polygonStart(), Ra.lineStart = Ka;
+              }, polygonEnd: function() {
+                Ar.polygonEnd(), Ra.lineStart = Na;
+              } };
+              function La(Ss, as) {
+                Ss = At(Ss, as), Ar.point(Ss[0], Ss[1]);
+              }
+              function Na() {
+                Qi = NaN, Ra.point = Yn, Ar.lineStart();
+              }
+              function Yn(Ss, as) {
+                var ws = ce([Ss, as]), Ho = At(Ss, as);
+                Cr(Qi, on, Yi, Fi, Qn, Ca, Qi = Ho[0], on = Ho[1], Yi = Ss, Fi = ws[0], Qn = ws[1], Ca = ws[2], gs, Ar), Ar.point(Qi, on);
+              }
+              function Dn() {
+                Ra.point = La, Ar.lineEnd();
+              }
+              function Ka() {
+                Na(), Ra.point = bo, Ra.lineEnd = Zo;
+              }
+              function bo(Ss, as) {
+                Yn(Kr = Ss, as), ki = Qi, Xi = on, dn = Fi, wn = Qn, Nn = Ca, Ra.point = Yn;
+              }
+              function Zo() {
+                Cr(Qi, on, Yi, Fi, Qn, Ca, ki, Xi, Kr, dn, wn, Nn, gs, Ar), Ra.lineEnd = Dn, Dn();
+              }
+              return Ra;
+            };
+          }
+          var Sh = ju({ point: function(At, Xt) {
+            this.stream.point(At * d, Xt * d);
+          } });
+          function Mu(At) {
+            return ju({ point: function(Xt, Cr) {
+              var Ar = At(Xt, Cr);
+              return this.stream.point(Ar[0], Ar[1]);
+            } });
+          }
+          function ih(At, Xt, Cr, Ar, Kr) {
+            function ki(Xi, dn) {
+              return Xi *= Ar, dn *= Kr, [Xt + At * Xi, Cr - At * dn];
+            }
+            return ki.invert = function(Xi, dn) {
+              return [(Xi - Xt) / At * Ar, (Cr - dn) / At * Kr];
+            }, ki;
+          }
+          function js(At, Xt, Cr, Ar, Kr, ki) {
+            var Xi = p(ki), dn = x(ki), wn = Xi * At, Nn = dn * At, Yi = Xi / At, Qi = dn / At, on = (dn * Cr - Xi * Xt) / At, Fi = (dn * Xt + Xi * Cr) / At;
+            function Qn(Ca, Ra) {
+              return Ca *= Ar, Ra *= Kr, [wn * Ca - Nn * Ra + Xt, Cr - Nn * Ca - wn * Ra];
+            }
+            return Qn.invert = function(Ca, Ra) {
+              return [Ar * (Yi * Ca - Qi * Ra + on), Kr * (Fi - Qi * Ca - Yi * Ra)];
+            }, Qn;
+          }
+          function Eu(At) {
+            return Dc(function() {
+              return At;
+            })();
+          }
+          function Dc(At) {
+            var Xt, Cr = 150, Ar = 480, Kr = 250, ki = 0, Xi = 0, dn = 0, wn = 0, Nn = 0, Yi, Qi = 0, on = 1, Fi = 1, Qn = null, Ca = Jr, Ra = null, La, Na, Yn, Dn = Kl, Ka = 0.5, bo, Zo, Ss, as, ws;
+            function Ho(va) {
+              return Ss(va[0] * d, va[1] * d);
+            }
+            function ml(va) {
+              return va = Ss.invert(va[0], va[1]), va && [va[0] * h, va[1] * h];
+            }
+            Ho.stream = function(va) {
+              return as && ws === va ? as : as = Sh(Mu(Yi)(Ca(bo(Dn(ws = va)))));
+            }, Ho.preclip = function(va) {
+              return arguments.length ? (Ca = va, Qn = void 0, Ls()) : Ca;
+            }, Ho.postclip = function(va) {
+              return arguments.length ? (Dn = va, Ra = La = Na = Yn = null, Ls()) : Dn;
+            }, Ho.clipAngle = function(va) {
+              return arguments.length ? (Ca = +va ? Mn(Qn = va * d) : (Qn = null, Jr), Ls()) : Qn * h;
+            }, Ho.clipExtent = function(va) {
+              return arguments.length ? (Dn = va == null ? (Ra = La = Na = Yn = null, Kl) : $n(Ra = +va[0][0], La = +va[0][1], Na = +va[1][0], Yn = +va[1][1]), Ls()) : Ra == null ? null : [[Ra, La], [Na, Yn]];
+            }, Ho.scale = function(va) {
+              return arguments.length ? (Cr = +va, Ws()) : Cr;
+            }, Ho.translate = function(va) {
+              return arguments.length ? (Ar = +va[0], Kr = +va[1], Ws()) : [Ar, Kr];
+            }, Ho.center = function(va) {
+              return arguments.length ? (ki = va[0] % 360 * d, Xi = va[1] % 360 * d, Ws()) : [ki * h, Xi * h];
+            }, Ho.rotate = function(va) {
+              return arguments.length ? (dn = va[0] % 360 * d, wn = va[1] % 360 * d, Nn = va.length > 2 ? va[2] % 360 * d : 0, Ws()) : [dn * h, wn * h, Nn * h];
+            }, Ho.angle = function(va) {
+              return arguments.length ? (Qi = va % 360 * d, Ws()) : Qi * h;
+            }, Ho.reflectX = function(va) {
+              return arguments.length ? (on = va ? -1 : 1, Ws()) : on < 0;
+            }, Ho.reflectY = function(va) {
+              return arguments.length ? (Fi = va ? -1 : 1, Ws()) : Fi < 0;
+            }, Ho.precision = function(va) {
+              return arguments.length ? (bo = Wh(Zo, Ka = va * va), Ls()) : M(Ka);
+            }, Ho.fitExtent = function(va, no) {
+              return of(Ho, va, no);
+            }, Ho.fitSize = function(va, no) {
+              return Nl(Ho, va, no);
+            }, Ho.fitWidth = function(va, no) {
+              return Kc(Ho, va, no);
+            }, Ho.fitHeight = function(va, no) {
+              return Rc(Ho, va, no);
+            };
+            function Ws() {
+              var va = js(Cr, 0, 0, on, Fi, Qi).apply(null, Xt(ki, Xi)), no = (Qi ? js : ih)(Cr, Ar - va[0], Kr - va[1], on, Fi, Qi);
+              return Yi = Oi(dn, wn, Nn), Zo = ri(Xt, no), Ss = ri(Yi, Zo), bo = Wh(Zo, Ka), Ls();
+            }
+            function Ls() {
+              return as = ws = null, Ho;
+            }
+            return function() {
+              return Xt = At.apply(this, arguments), Ho.invert = Xt.invert && ml, Ws();
+            };
+          }
+          function ks(At) {
+            var Xt = 0, Cr = l / 3, Ar = Dc(At), Kr = Ar(Xt, Cr);
+            return Kr.parallels = function(ki) {
+              return arguments.length ? Ar(Xt = ki[0] * d, Cr = ki[1] * d) : [Xt * h, Cr * h];
+            }, Kr;
+          }
+          function bc(At) {
+            var Xt = p(At);
+            function Cr(Ar, Kr) {
+              return [Ar * Xt, x(Kr) / Xt];
+            }
+            return Cr.invert = function(Ar, Kr) {
+              return [Ar / Xt, A(Kr * Xt)];
+            }, Cr;
+          }
+          function hu(At, Xt) {
+            var Cr = x(At), Ar = (Cr + x(Xt)) / 2;
+            if (v(Ar) < o) return bc(At);
+            var Kr = 1 + Cr * (2 * Ar - Cr), ki = M(Kr) / Ar;
+            function Xi(dn, wn) {
+              var Nn = M(Kr - 2 * Ar * x(wn)) / Ar;
+              return [Nn * x(dn *= Ar), ki - Nn * p(dn)];
+            }
+            return Xi.invert = function(dn, wn) {
+              var Nn = ki - wn, Yi = b(dn, v(Nn)) * C(Nn);
+              return Nn * Ar < 0 && (Yi -= l * C(dn) * C(Nn)), [Yi / Ar, A((Kr - (dn * dn + Nn * Nn) * Ar * Ar) / (2 * Ar))];
+            }, Xi;
+          }
+          function _u() {
+            return ks(hu).scale(155.424).center([0, 33.6442]);
+          }
+          function nl() {
+            return _u().parallels([29.5, 45.5]).scale(1070).translate([480, 250]).rotate([96, 0]).center([-0.6, 38.7]);
+          }
+          function nh(At) {
+            var Xt = At.length;
+            return { point: function(Cr, Ar) {
+              for (var Kr = -1; ++Kr < Xt; ) At[Kr].point(Cr, Ar);
+            }, sphere: function() {
+              for (var Cr = -1; ++Cr < Xt; ) At[Cr].sphere();
+            }, lineStart: function() {
+              for (var Cr = -1; ++Cr < Xt; ) At[Cr].lineStart();
+            }, lineEnd: function() {
+              for (var Cr = -1; ++Cr < Xt; ) At[Cr].lineEnd();
+            }, polygonStart: function() {
+              for (var Cr = -1; ++Cr < Xt; ) At[Cr].polygonStart();
+            }, polygonEnd: function() {
+              for (var Cr = -1; ++Cr < Xt; ) At[Cr].polygonEnd();
+            } };
+          }
+          function Mh() {
+            var At, Xt, Cr = nl(), Ar, Kr = _u().rotate([154, 0]).center([-2, 58.5]).parallels([55, 65]), ki, Xi = _u().rotate([157, 0]).center([-3, 19.9]).parallels([8, 18]), dn, wn, Nn = { point: function(on, Fi) {
+              wn = [on, Fi];
+            } };
+            function Yi(on) {
+              var Fi = on[0], Qn = on[1];
+              return wn = null, Ar.point(Fi, Qn), wn || (ki.point(Fi, Qn), wn) || (dn.point(Fi, Qn), wn);
+            }
+            Yi.invert = function(on) {
+              var Fi = Cr.scale(), Qn = Cr.translate(), Ca = (on[0] - Qn[0]) / Fi, Ra = (on[1] - Qn[1]) / Fi;
+              return (Ra >= 0.12 && Ra < 0.234 && Ca >= -0.425 && Ca < -0.214 ? Kr : Ra >= 0.166 && Ra < 0.234 && Ca >= -0.214 && Ca < -0.115 ? Xi : Cr).invert(on);
+            }, Yi.stream = function(on) {
+              return At && Xt === on ? At : At = nh([Cr.stream(Xt = on), Kr.stream(on), Xi.stream(on)]);
+            }, Yi.precision = function(on) {
+              return arguments.length ? (Cr.precision(on), Kr.precision(on), Xi.precision(on), Qi()) : Cr.precision();
+            }, Yi.scale = function(on) {
+              return arguments.length ? (Cr.scale(on), Kr.scale(on * 0.35), Xi.scale(on), Yi.translate(Cr.translate())) : Cr.scale();
+            }, Yi.translate = function(on) {
+              if (!arguments.length) return Cr.translate();
+              var Fi = Cr.scale(), Qn = +on[0], Ca = +on[1];
+              return Ar = Cr.translate(on).clipExtent([[Qn - 0.455 * Fi, Ca - 0.238 * Fi], [Qn + 0.455 * Fi, Ca + 0.238 * Fi]]).stream(Nn), ki = Kr.translate([Qn - 0.307 * Fi, Ca + 0.201 * Fi]).clipExtent([[Qn - 0.425 * Fi + o, Ca + 0.12 * Fi + o], [Qn - 0.214 * Fi - o, Ca + 0.234 * Fi - o]]).stream(Nn), dn = Xi.translate([Qn - 0.205 * Fi, Ca + 0.212 * Fi]).clipExtent([[Qn - 0.214 * Fi + o, Ca + 0.166 * Fi + o], [Qn - 0.115 * Fi - o, Ca + 0.234 * Fi - o]]).stream(Nn), Qi();
+            }, Yi.fitExtent = function(on, Fi) {
+              return of(Yi, on, Fi);
+            }, Yi.fitSize = function(on, Fi) {
+              return Nl(Yi, on, Fi);
+            }, Yi.fitWidth = function(on, Fi) {
+              return Kc(Yi, on, Fi);
+            }, Yi.fitHeight = function(on, Fi) {
+              return Rc(Yi, on, Fi);
+            };
+            function Qi() {
+              return At = Xt = null, Yi;
+            }
+            return Yi.scale(1070);
+          }
+          function zu(At) {
+            return function(Xt, Cr) {
+              var Ar = p(Xt), Kr = p(Cr), ki = At(Ar * Kr);
+              return [ki * Kr * x(Xt), ki * x(Cr)];
+            };
+          }
+          function Fc(At) {
+            return function(Xt, Cr) {
+              var Ar = M(Xt * Xt + Cr * Cr), Kr = At(Ar), ki = x(Kr), Xi = p(Kr);
+              return [b(Xt * ki, Ar * Xi), A(Ar && Cr * ki / Ar)];
+            };
+          }
+          var wc = zu(function(At) {
+            return M(2 / (1 + At));
+          });
+          wc.invert = Fc(function(At) {
+            return 2 * A(At / 2);
+          });
+          function bd() {
+            return Eu(wc).scale(124.75).clipAngle(180 - 1e-3);
+          }
+          var xf = zu(function(At) {
+            return (At = P(At)) && At / x(At);
+          });
+          xf.invert = Fc(function(At) {
+            return At;
+          });
+          function Pf() {
+            return Eu(xf).scale(79.4188).clipAngle(180 - 1e-3);
+          }
+          function Ou(At, Xt) {
+            return [At, T(g((u + Xt) / 2))];
+          }
+          Ou.invert = function(At, Xt) {
+            return [At, 2 * _(E(Xt)) - u];
+          };
+          function bf() {
+            return jl(Ou).scale(961 / f);
+          }
+          function jl(At) {
+            var Xt = Eu(At), Cr = Xt.center, Ar = Xt.scale, Kr = Xt.translate, ki = Xt.clipExtent, Xi = null, dn, wn, Nn;
+            Xt.scale = function(Qi) {
+              return arguments.length ? (Ar(Qi), Yi()) : Ar();
+            }, Xt.translate = function(Qi) {
+              return arguments.length ? (Kr(Qi), Yi()) : Kr();
+            }, Xt.center = function(Qi) {
+              return arguments.length ? (Cr(Qi), Yi()) : Cr();
+            }, Xt.clipExtent = function(Qi) {
+              return arguments.length ? (Qi == null ? Xi = dn = wn = Nn = null : (Xi = +Qi[0][0], dn = +Qi[0][1], wn = +Qi[1][0], Nn = +Qi[1][1]), Yi()) : Xi == null ? null : [[Xi, dn], [wn, Nn]];
+            };
+            function Yi() {
+              var Qi = l * Ar(), on = Xt(yn(Xt.rotate()).invert([0, 0]));
+              return ki(Xi == null ? [[on[0] - Qi, on[1] - Qi], [on[0] + Qi, on[1] + Qi]] : At === Ou ? [[Math.max(on[0] - Qi, Xi), dn], [Math.min(on[0] + Qi, wn), Nn]] : [[Xi, Math.max(on[1] - Qi, dn)], [wn, Math.min(on[1] + Qi, Nn)]]);
+            }
+            return Yi();
+          }
+          function lf(At) {
+            return g((u + At) / 2);
+          }
+          function Xh(At, Xt) {
+            var Cr = p(At), Ar = At === Xt ? x(At) : T(Cr / p(Xt)) / T(lf(Xt) / lf(At)), Kr = Cr * L(lf(At), Ar) / Ar;
+            if (!Ar) return Ou;
+            function ki(Xi, dn) {
+              Kr > 0 ? dn < -u + o && (dn = -u + o) : dn > u - o && (dn = u - o);
+              var wn = Kr / L(lf(dn), Ar);
+              return [wn * x(Ar * Xi), Kr - wn * p(Ar * Xi)];
+            }
+            return ki.invert = function(Xi, dn) {
+              var wn = Kr - dn, Nn = C(Ar) * M(Xi * Xi + wn * wn), Yi = b(Xi, v(wn)) * C(wn);
+              return wn * Ar < 0 && (Yi -= l * C(Xi) * C(wn)), [Yi / Ar, 2 * _(L(Kr / Nn, 1 / Ar)) - u];
+            }, ki;
+          }
+          function If() {
+            return ks(Xh).scale(109.5).parallels([30, 30]);
+          }
+          function Cs(At, Xt) {
+            return [At, Xt];
+          }
+          Cs.invert = Cs;
+          function du() {
+            return Eu(Cs).scale(152.63);
+          }
+          function ku(At, Xt) {
+            var Cr = p(At), Ar = At === Xt ? x(At) : (Cr - p(Xt)) / (Xt - At), Kr = Cr / Ar + At;
+            if (v(Ar) < o) return Cs;
+            function ki(Xi, dn) {
+              var wn = Kr - dn, Nn = Ar * Xi;
+              return [wn * x(Nn), Kr - wn * p(Nn)];
+            }
+            return ki.invert = function(Xi, dn) {
+              var wn = Kr - dn, Nn = b(Xi, v(wn)) * C(wn);
+              return wn * Ar < 0 && (Nn -= l * C(Xi) * C(wn)), [Nn / Ar, Kr - C(Ar) * M(Xi * Xi + wn * wn)];
+            }, ki;
+          }
+          function Xf() {
+            return ks(ku).scale(131.154).center([0, 13.9389]);
+          }
+          var Us = 1.340264, wf = -0.081106, zc = 893e-6, Wu = 3796e-6, Rf = M(3) / 2, Xu = 12;
+          function uf(At, Xt) {
+            var Cr = A(Rf * x(Xt)), Ar = Cr * Cr, Kr = Ar * Ar * Ar;
+            return [At * p(Cr) / (Rf * (Us + 3 * wf * Ar + Kr * (7 * zc + 9 * Wu * Ar))), Cr * (Us + wf * Ar + Kr * (zc + Wu * Ar))];
+          }
+          uf.invert = function(At, Xt) {
+            for (var Cr = Xt, Ar = Cr * Cr, Kr = Ar * Ar * Ar, ki = 0, Xi, dn, wn; ki < Xu && (dn = Cr * (Us + wf * Ar + Kr * (zc + Wu * Ar)) - Xt, wn = Us + 3 * wf * Ar + Kr * (7 * zc + 9 * Wu * Ar), Cr -= Xi = dn / wn, Ar = Cr * Cr, Kr = Ar * Ar * Ar, !(v(Xi) < s)); ++ki) ;
+            return [Rf * At * (Us + 3 * wf * Ar + Kr * (7 * zc + 9 * Wu * Ar)) / p(Cr), A(x(Cr) / Rf)];
+          };
+          function Zf() {
+            return Eu(uf).scale(177.158);
+          }
+          function Wl(At, Xt) {
+            var Cr = p(Xt), Ar = p(At) * Cr;
+            return [Cr * x(At) / Ar, x(Xt) / Ar];
+          }
+          Wl.invert = Fc(_);
+          function ah() {
+            return Eu(Wl).scale(144.049).clipAngle(60);
+          }
+          function Zu() {
+            var At = 1, Xt = 0, Cr = 0, Ar = 1, Kr = 1, ki = 0, Xi, dn, wn = null, Nn, Yi, Qi, on = 1, Fi = 1, Qn = ju({ point: function(Dn, Ka) {
+              var bo = Yn([Dn, Ka]);
+              this.stream.point(bo[0], bo[1]);
+            } }), Ca = Kl, Ra, La;
+            function Na() {
+              return on = At * Ar, Fi = At * Kr, Ra = La = null, Yn;
+            }
+            function Yn(Dn) {
+              var Ka = Dn[0] * on, bo = Dn[1] * Fi;
+              if (ki) {
+                var Zo = bo * Xi - Ka * dn;
+                Ka = Ka * Xi + bo * dn, bo = Zo;
+              }
+              return [Ka + Xt, bo + Cr];
+            }
+            return Yn.invert = function(Dn) {
+              var Ka = Dn[0] - Xt, bo = Dn[1] - Cr;
+              if (ki) {
+                var Zo = bo * Xi + Ka * dn;
+                Ka = Ka * Xi - bo * dn, bo = Zo;
+              }
+              return [Ka / on, bo / Fi];
+            }, Yn.stream = function(Dn) {
+              return Ra && La === Dn ? Ra : Ra = Qn(Ca(La = Dn));
+            }, Yn.postclip = function(Dn) {
+              return arguments.length ? (Ca = Dn, wn = Nn = Yi = Qi = null, Na()) : Ca;
+            }, Yn.clipExtent = function(Dn) {
+              return arguments.length ? (Ca = Dn == null ? (wn = Nn = Yi = Qi = null, Kl) : $n(wn = +Dn[0][0], Nn = +Dn[0][1], Yi = +Dn[1][0], Qi = +Dn[1][1]), Na()) : wn == null ? null : [[wn, Nn], [Yi, Qi]];
+            }, Yn.scale = function(Dn) {
+              return arguments.length ? (At = +Dn, Na()) : At;
+            }, Yn.translate = function(Dn) {
+              return arguments.length ? (Xt = +Dn[0], Cr = +Dn[1], Na()) : [Xt, Cr];
+            }, Yn.angle = function(Dn) {
+              return arguments.length ? (ki = Dn % 360 * d, dn = x(ki), Xi = p(ki), Na()) : ki * h;
+            }, Yn.reflectX = function(Dn) {
+              return arguments.length ? (Ar = Dn ? -1 : 1, Na()) : Ar < 0;
+            }, Yn.reflectY = function(Dn) {
+              return arguments.length ? (Kr = Dn ? -1 : 1, Na()) : Kr < 0;
+            }, Yn.fitExtent = function(Dn, Ka) {
+              return of(Yn, Dn, Ka);
+            }, Yn.fitSize = function(Dn, Ka) {
+              return Nl(Yn, Dn, Ka);
+            }, Yn.fitWidth = function(Dn, Ka) {
+              return Kc(Yn, Dn, Ka);
+            }, Yn.fitHeight = function(Dn, Ka) {
+              return Rc(Yn, Dn, Ka);
+            }, Yn;
+          }
+          function Oc(At, Xt) {
+            var Cr = Xt * Xt, Ar = Cr * Cr;
+            return [At * (0.8707 - 0.131979 * Cr + Ar * (-0.013791 + Ar * (3971e-6 * Cr - 1529e-6 * Ar))), Xt * (1.007226 + Cr * (0.015085 + Ar * (-0.044475 + 0.028874 * Cr - 5916e-6 * Ar)))];
+          }
+          Oc.invert = function(At, Xt) {
+            var Cr = Xt, Ar = 25, Kr;
+            do {
+              var ki = Cr * Cr, Xi = ki * ki;
+              Cr -= Kr = (Cr * (1.007226 + ki * (0.015085 + Xi * (-0.044475 + 0.028874 * ki - 5916e-6 * Xi))) - Xt) / (1.007226 + ki * (0.015085 * 3 + Xi * (-0.044475 * 7 + 0.028874 * 9 * ki - 5916e-6 * 11 * Xi)));
+            } while (v(Kr) > o && --Ar > 0);
+            return [At / (0.8707 + (ki = Cr * Cr) * (-0.131979 + ki * (-0.013791 + ki * ki * ki * (3971e-6 - 1529e-6 * ki)))), Cr];
+          };
+          function Tc() {
+            return Eu(Oc).scale(175.295);
+          }
+          function wl(At, Xt) {
+            return [p(Xt) * x(At), x(Xt)];
+          }
+          wl.invert = Fc(A);
+          function vu() {
+            return Eu(wl).scale(249.5).clipAngle(90 + o);
+          }
+          function qc(At, Xt) {
+            var Cr = p(Xt), Ar = 1 + p(At) * Cr;
+            return [Cr * x(At) / Ar, x(Xt) / Ar];
+          }
+          qc.invert = Fc(function(At) {
+            return 2 * _(At);
+          });
+          function cf() {
+            return Eu(qc).scale(250).clipAngle(142);
+          }
+          function fc(At, Xt) {
+            return [T(g((u + Xt) / 2)), -At];
+          }
+          fc.invert = function(At, Xt) {
+            return [-Xt, 2 * _(E(At)) - u];
+          };
+          function Bc() {
+            var At = jl(fc), Xt = At.center, Cr = At.rotate;
+            return At.center = function(Ar) {
+              return arguments.length ? Xt([-Ar[1], Ar[0]]) : (Ar = Xt(), [Ar[1], -Ar[0]]);
+            }, At.rotate = function(Ar) {
+              return arguments.length ? Cr([Ar[0], Ar[1], Ar.length > 2 ? Ar[2] + 90 : 90]) : (Ar = Cr(), [Ar[0], Ar[1], Ar[2] - 90]);
+            }, Cr([0, 0, 90]).scale(159.155);
+          }
+          e.geoAlbers = nl, e.geoAlbersUsa = Mh, e.geoArea = me, e.geoAzimuthalEqualArea = bd, e.geoAzimuthalEqualAreaRaw = wc, e.geoAzimuthalEquidistant = Pf, e.geoAzimuthalEquidistantRaw = xf, e.geoBounds = Ge, e.geoCentroid = Er, e.geoCircle = ua, e.geoClipAntimeridian = Jr, e.geoClipCircle = Mn, e.geoClipExtent = Ma, e.geoClipRectangle = $n, e.geoConicConformal = If, e.geoConicConformalRaw = Xh, e.geoConicEqualArea = _u, e.geoConicEqualAreaRaw = hu, e.geoConicEquidistant = Xf, e.geoConicEquidistantRaw = ku, e.geoContains = bs, e.geoDistance = As, e.geoEqualEarth = Zf, e.geoEqualEarthRaw = uf, e.geoEquirectangular = du, e.geoEquirectangularRaw = Cs, e.geoGnomonic = ah, e.geoGnomonicRaw = Wl, e.geoGraticule = Vu, e.geoGraticule10 = Ol, e.geoIdentity = Zu, e.geoInterpolate = xo, e.geoLength = zl, e.geoMercator = bf, e.geoMercatorRaw = Ou, e.geoNaturalEarth1 = Tc, e.geoNaturalEarth1Raw = Oc, e.geoOrthographic = vu, e.geoOrthographicRaw = wl, e.geoPath = eh, e.geoProjection = Eu, e.geoProjectionMutator = Dc, e.geoRotation = yn, e.geoStereographic = cf, e.geoStereographicRaw = qc, e.geoStream = H, e.geoTransform = th, e.geoTransverseMercator = Bc, e.geoTransverseMercatorRaw = fc, Object.defineProperty(e, "__esModule", { value: true });
+        });
+      });
+      var qDe = ye((FF, ODe) => {
+        (function(e, t) {
+          typeof FF == "object" && typeof ODe != "undefined" ? t(FF, NZ(), hk()) : t(e.d3 = e.d3 || {}, e.d3, e.d3);
+        })(FF, function(e, t, r) {
+          var n = Math.abs, i = Math.atan, a = Math.atan2, o = Math.cos, s = Math.exp, l = Math.floor, u = Math.log, c = Math.max, f = Math.min, h = Math.pow, d = Math.round, v = Math.sign || function(ve) {
+            return ve > 0 ? 1 : ve < 0 ? -1 : 0;
+          }, _ = Math.sin, b = Math.tan, p = 1e-6, k = 1e-12, E = Math.PI, T = E / 2, L = E / 4, x = Math.SQRT1_2, C = G(2), M = G(E), g = E * 2, P = 180 / E, A = E / 180;
+          function z(ve) {
+            return ve ? ve / Math.sin(ve) : 1;
+          }
+          function O(ve) {
+            return ve > 1 ? T : ve < -1 ? -T : Math.asin(ve);
+          }
+          function U(ve) {
+            return ve > 1 ? 0 : ve < -1 ? E : Math.acos(ve);
+          }
+          function G(ve) {
+            return ve > 0 ? Math.sqrt(ve) : 0;
+          }
+          function Z(ve) {
+            return ve = s(2 * ve), (ve - 1) / (ve + 1);
+          }
+          function j(ve) {
+            return (s(ve) - s(-ve)) / 2;
+          }
+          function N(ve) {
+            return (s(ve) + s(-ve)) / 2;
+          }
+          function H(ve) {
+            return u(ve + G(ve * ve + 1));
+          }
+          function re(ve) {
+            return u(ve + G(ve * ve - 1));
+          }
+          function oe(ve) {
+            var be = b(ve / 2), Re = 2 * u(o(ve / 2)) / (be * be);
+            function qe(et, Xe) {
+              var it = o(et), Ft = o(Xe), Ht = _(Xe), tr = Ft * it, dr = -((1 - tr ? u((1 + tr) / 2) / (1 - tr) : -0.5) + Re / (1 + tr));
+              return [dr * Ft * _(et), dr * Ht];
+            }
+            return qe.invert = function(et, Xe) {
+              var it = G(et * et + Xe * Xe), Ft = -ve / 2, Ht = 50, tr;
+              if (!it) return [0, 0];
+              do {
+                var dr = Ft / 2, Sr = o(dr), Or = _(dr), Wr = Or / Sr, ni = -u(n(Sr));
+                Ft -= tr = (2 / Wr * ni - Re * Wr - it) / (-ni / (Or * Or) + 1 - Re / (2 * Sr * Sr)) * (Sr < 0 ? 0.7 : 1);
+              } while (n(tr) > p && --Ht > 0);
+              var Pi = _(Ft);
+              return [a(et * Pi, it * o(Ft)), O(Xe * Pi / it)];
+            }, qe;
+          }
+          function _e() {
+            var ve = T, be = t.geoProjectionMutator(oe), Re = be(ve);
+            return Re.radius = function(qe) {
+              return arguments.length ? be(ve = qe * A) : ve * P;
+            }, Re.scale(179.976).clipAngle(147);
+          }
+          function Ce(ve, be) {
+            var Re = o(be), qe = z(U(Re * o(ve /= 2)));
+            return [2 * Re * _(ve) * qe, _(be) * qe];
+          }
+          Ce.invert = function(ve, be) {
+            if (!(ve * ve + 4 * be * be > E * E + p)) {
+              var Re = ve, qe = be, et = 25;
+              do {
+                var Xe = _(Re), it = _(Re / 2), Ft = o(Re / 2), Ht = _(qe), tr = o(qe), dr = _(2 * qe), Sr = Ht * Ht, Or = tr * tr, Wr = it * it, ni = 1 - Or * Ft * Ft, Pi = ni ? U(tr * Ft) * G(cn = 1 / ni) : cn = 0, cn, ln = 2 * Pi * tr * it - ve, Cn = Pi * Ht - be, Kn = cn * (Or * Wr + Pi * tr * Ft * Sr), Aa = cn * (0.5 * Xe * dr - Pi * 2 * Ht * it), fa = cn * 0.25 * (dr * it - Pi * Ht * Or * Xe), $a = cn * (Sr * Ft + Pi * Wr * tr), Co = Aa * fa - $a * Kn;
+                if (!Co) break;
+                var Qa = (Cn * Aa - ln * $a) / Co, mo = (ln * fa - Cn * Kn) / Co;
+                Re -= Qa, qe -= mo;
+              } while ((n(Qa) > p || n(mo) > p) && --et > 0);
+              return [Re, qe];
+            }
+          };
+          function Le() {
+            return t.geoProjection(Ce).scale(152.63);
+          }
+          function ge(ve) {
+            var be = _(ve), Re = o(ve), qe = ve >= 0 ? 1 : -1, et = b(qe * ve), Xe = (1 + be - Re) / 2;
+            function it(Ft, Ht) {
+              var tr = o(Ht), dr = o(Ft /= 2);
+              return [(1 + tr) * _(Ft), (qe * Ht > -a(dr, et) - 1e-3 ? 0 : -qe * 10) + Xe + _(Ht) * Re - (1 + tr) * be * dr];
+            }
+            return it.invert = function(Ft, Ht) {
+              var tr = 0, dr = 0, Sr = 50;
+              do {
+                var Or = o(tr), Wr = _(tr), ni = o(dr), Pi = _(dr), cn = 1 + ni, ln = cn * Wr - Ft, Cn = Xe + Pi * Re - cn * be * Or - Ht, Kn = cn * Or / 2, Aa = -Wr * Pi, fa = be * cn * Wr / 2, $a = Re * ni + be * Or * Pi, Co = Aa * fa - $a * Kn, Qa = (Cn * Aa - ln * $a) / Co / 2, mo = (ln * fa - Cn * Kn) / Co;
+                n(mo) > 2 && (mo /= 2), tr -= Qa, dr -= mo;
+              } while ((n(Qa) > p || n(mo) > p) && --Sr > 0);
+              return qe * dr > -a(o(tr), et) - 1e-3 ? [tr * 2, dr] : null;
+            }, it;
+          }
+          function ie() {
+            var ve = 20 * A, be = ve >= 0 ? 1 : -1, Re = b(be * ve), qe = t.geoProjectionMutator(ge), et = qe(ve), Xe = et.stream;
+            return et.parallel = function(it) {
+              return arguments.length ? (Re = b((be = (ve = it * A) >= 0 ? 1 : -1) * ve), qe(ve)) : ve * P;
+            }, et.stream = function(it) {
+              var Ft = et.rotate(), Ht = Xe(it), tr = (et.rotate([0, 0]), Xe(it)), dr = et.precision();
+              return et.rotate(Ft), Ht.sphere = function() {
+                tr.polygonStart(), tr.lineStart();
+                for (var Sr = be * -180; be * Sr < 180; Sr += be * 90) tr.point(Sr, be * 90);
+                if (ve) for (; be * (Sr -= 3 * be * dr) >= -180; ) tr.point(Sr, be * -a(o(Sr * A / 2), Re) * P);
+                tr.lineEnd(), tr.polygonEnd();
+              }, Ht;
+            }, et.scale(218.695).center([0, 28.0974]);
+          }
+          function Se(ve, be) {
+            var Re = b(be / 2), qe = G(1 - Re * Re), et = 1 + qe * o(ve /= 2), Xe = _(ve) * qe / et, it = Re / et, Ft = Xe * Xe, Ht = it * it;
+            return [4 / 3 * Xe * (3 + Ft - 3 * Ht), 4 / 3 * it * (3 + 3 * Ft - Ht)];
+          }
+          Se.invert = function(ve, be) {
+            if (ve *= 3 / 8, be *= 3 / 8, !ve && n(be) > 1) return null;
+            var Re = ve * ve, qe = be * be, et = 1 + Re + qe, Xe = G((et - G(et * et - 4 * be * be)) / 2), it = O(Xe) / 3, Ft = Xe ? re(n(be / Xe)) / 3 : H(n(ve)) / 3, Ht = o(it), tr = N(Ft), dr = tr * tr - Ht * Ht;
+            return [v(ve) * 2 * a(j(Ft) * Ht, 0.25 - dr), v(be) * 2 * a(tr * _(it), 0.25 + dr)];
+          };
+          function Ee() {
+            return t.geoProjection(Se).scale(66.1603);
+          }
+          var Ae = G(8), Be = u(1 + C);
+          function Pe(ve, be) {
+            var Re = n(be);
+            return Re < L ? [ve, u(b(L + be / 2))] : [ve * o(Re) * (2 * C - 1 / _(Re)), v(be) * (2 * C * (Re - L) - u(b(Re / 2)))];
+          }
+          Pe.invert = function(ve, be) {
+            if ((Xe = n(be)) < Be) return [ve, 2 * i(s(be)) - T];
+            var Re = L, qe = 25, et, Xe;
+            do {
+              var it = o(Re / 2), Ft = b(Re / 2);
+              Re -= et = (Ae * (Re - L) - u(Ft) - Xe) / (Ae - it * it / (2 * Ft));
+            } while (n(et) > k && --qe > 0);
+            return [ve / (o(Re) * (Ae - 1 / _(Re))), v(be) * Re];
+          };
+          function me() {
+            return t.geoProjection(Pe).scale(112.314);
+          }
+          function De(ve) {
+            var be = 2 * E / ve;
+            function Re(qe, et) {
+              var Xe = t.geoAzimuthalEquidistantRaw(qe, et);
+              if (n(qe) > T) {
+                var it = a(Xe[1], Xe[0]), Ft = G(Xe[0] * Xe[0] + Xe[1] * Xe[1]), Ht = be * d((it - T) / be) + T, tr = a(_(it -= Ht), 2 - o(it));
+                it = Ht + O(E / Ft * _(tr)) - tr, Xe[0] = Ft * o(it), Xe[1] = Ft * _(it);
+              }
+              return Xe;
+            }
+            return Re.invert = function(qe, et) {
+              var Xe = G(qe * qe + et * et);
+              if (Xe > T) {
+                var it = a(et, qe), Ft = be * d((it - T) / be) + T, Ht = it > Ft ? -1 : 1, tr = Xe * o(Ft - it), dr = 1 / b(Ht * U((tr - E) / G(E * (E - 2 * tr) + Xe * Xe)));
+                it = Ft + 2 * i((dr + Ht * G(dr * dr - 3)) / 3), qe = Xe * o(it), et = Xe * _(it);
+              }
+              return t.geoAzimuthalEquidistantRaw.invert(qe, et);
+            }, Re;
+          }
+          function ce() {
+            var ve = 5, be = t.geoProjectionMutator(De), Re = be(ve), qe = Re.stream, et = 0.01, Xe = -o(et * A), it = _(et * A);
+            return Re.lobes = function(Ft) {
+              return arguments.length ? be(ve = +Ft) : ve;
+            }, Re.stream = function(Ft) {
+              var Ht = Re.rotate(), tr = qe(Ft), dr = (Re.rotate([0, 0]), qe(Ft));
+              return Re.rotate(Ht), tr.sphere = function() {
+                dr.polygonStart(), dr.lineStart();
+                for (var Sr = 0, Or = 360 / ve, Wr = 2 * E / ve, ni = 90 - 180 / ve, Pi = T; Sr < ve; ++Sr, ni -= Or, Pi -= Wr) dr.point(a(it * o(Pi), Xe) * P, O(it * _(Pi)) * P), ni < -90 ? (dr.point(-90, -180 - ni - et), dr.point(-90, -180 - ni + et)) : (dr.point(90, ni + et), dr.point(90, ni - et));
+                dr.lineEnd(), dr.polygonEnd();
+              }, tr;
+            }, Re.scale(87.8076).center([0, 17.1875]).clipAngle(180 - 1e-3);
+          }
+          function je(ve, be) {
+            if (arguments.length < 2 && (be = ve), be === 1) return t.geoAzimuthalEqualAreaRaw;
+            if (be === 1 / 0) return lt;
+            function Re(qe, et) {
+              var Xe = t.geoAzimuthalEqualAreaRaw(qe / be, et);
+              return Xe[0] *= ve, Xe;
+            }
+            return Re.invert = function(qe, et) {
+              var Xe = t.geoAzimuthalEqualAreaRaw.invert(qe / ve, et);
+              return Xe[0] *= be, Xe;
+            }, Re;
+          }
+          function lt(ve, be) {
+            return [ve * o(be) / o(be /= 2), 2 * _(be)];
+          }
+          lt.invert = function(ve, be) {
+            var Re = 2 * O(be / 2);
+            return [ve * o(Re / 2) / o(Re), Re];
+          };
+          function pt() {
+            var ve = 2, be = t.geoProjectionMutator(je), Re = be(ve);
+            return Re.coefficient = function(qe) {
+              return arguments.length ? be(ve = +qe) : ve;
+            }, Re.scale(169.529);
+          }
+          function Vt(ve, be, Re) {
+            var qe = 100, et, Xe, it;
+            Re = Re === void 0 ? 0 : +Re, be = +be;
+            do
+              Xe = ve(Re), it = ve(Re + p), Xe === it && (it = Xe + p), Re -= et = -1 * p * (Xe - be) / (Xe - it);
+            while (qe-- > 0 && n(et) > p);
+            return qe < 0 ? NaN : Re;
+          }
+          function ot(ve, be, Re) {
+            return be === void 0 && (be = 40), Re === void 0 && (Re = k), function(qe, et, Xe, it) {
+              var Ft, Ht, tr;
+              Xe = Xe === void 0 ? 0 : +Xe, it = it === void 0 ? 0 : +it;
+              for (var dr = 0; dr < be; dr++) {
+                var Sr = ve(Xe, it), Or = Sr[0] - qe, Wr = Sr[1] - et;
+                if (n(Or) < Re && n(Wr) < Re) break;
+                var ni = Or * Or + Wr * Wr;
+                if (ni > Ft) {
+                  Xe -= Ht /= 2, it -= tr /= 2;
+                  continue;
+                }
+                Ft = ni;
+                var Pi = (Xe > 0 ? -1 : 1) * Re, cn = (it > 0 ? -1 : 1) * Re, ln = ve(Xe + Pi, it), Cn = ve(Xe, it + cn), Kn = (ln[0] - Sr[0]) / Pi, Aa = (ln[1] - Sr[1]) / Pi, fa = (Cn[0] - Sr[0]) / cn, $a = (Cn[1] - Sr[1]) / cn, Co = $a * Kn - Aa * fa, Qa = (n(Co) < 0.5 ? 0.5 : 1) / Co;
+                if (Ht = (Wr * fa - Or * $a) * Qa, tr = (Or * Aa - Wr * Kn) * Qa, Xe += Ht, it += tr, n(Ht) < Re && n(tr) < Re) break;
+              }
+              return [Xe, it];
+            };
+          }
+          function ut() {
+            var ve = je(1.68, 2), be = 1.4, Re = 12;
+            function qe(et, Xe) {
+              if (et + Xe < -1.4) {
+                var it = (et - Xe + 1.6) * (et + Xe + be) / 8;
+                et += it, Xe -= 0.8 * it * _(Xe + E / 2);
+              }
+              var Ft = ve(et, Xe), Ht = (1 - o(et * Xe)) / Re;
+              return Ft[1] < 0 && (Ft[0] *= 1 + Ht), Ft[1] > 0 && (Ft[1] *= 1 + Ht / 1.5 * Ft[0] * Ft[0]), Ft;
+            }
+            return qe.invert = ot(qe), qe;
+          }
+          function Wt() {
+            return t.geoProjection(ut()).rotate([-16.5, -42]).scale(176.57).center([7.93, 0.09]);
+          }
+          function Nt(ve, be) {
+            var Re = ve * _(be), qe = 30, et;
+            do
+              be -= et = (be + _(be) - Re) / (1 + o(be));
+            while (n(et) > p && --qe > 0);
+            return be / 2;
+          }
+          function $t(ve, be, Re) {
+            function qe(et, Xe) {
+              return [ve * et * o(Xe = Nt(Re, Xe)), be * _(Xe)];
+            }
+            return qe.invert = function(et, Xe) {
+              return Xe = O(Xe / be), [et / (ve * o(Xe)), O((2 * Xe + _(2 * Xe)) / Re)];
+            }, qe;
+          }
+          var sr = $t(C / T, C, E);
+          function Tr() {
+            return t.geoProjection(sr).scale(169.529);
+          }
+          var fr = 2.00276, $e = 1.11072;
+          function St(ve, be) {
+            var Re = Nt(E, be);
+            return [fr * ve / (1 / o(be) + $e / o(Re)), (be + C * _(Re)) / fr];
+          }
+          St.invert = function(ve, be) {
+            var Re = fr * be, qe = be < 0 ? -L : L, et = 25, Xe, it;
+            do
+              it = Re - C * _(qe), qe -= Xe = (_(2 * qe) + 2 * qe - E * _(it)) / (2 * o(2 * qe) + 2 + E * o(it) * C * o(qe));
+            while (n(Xe) > p && --et > 0);
+            return it = Re - C * _(qe), [ve * (1 / o(it) + $e / o(qe)) / fr, it];
+          };
+          function Qt() {
+            return t.geoProjection(St).scale(160.857);
+          }
+          function Gt(ve) {
+            var be = 0, Re = t.geoProjectionMutator(ve), qe = Re(be);
+            return qe.parallel = function(et) {
+              return arguments.length ? Re(be = et * A) : be * P;
+            }, qe;
+          }
+          function _t(ve, be) {
+            return [ve * o(be), be];
+          }
+          _t.invert = function(ve, be) {
+            return [ve / o(be), be];
+          };
+          function It() {
+            return t.geoProjection(_t).scale(152.63);
+          }
+          function mt(ve) {
+            if (!ve) return _t;
+            var be = 1 / b(ve);
+            function Re(qe, et) {
+              var Xe = be + ve - et, it = Xe && qe * o(et) / Xe;
+              return [Xe * _(it), be - Xe * o(it)];
+            }
+            return Re.invert = function(qe, et) {
+              var Xe = G(qe * qe + (et = be - et) * et), it = be + ve - Xe;
+              return [Xe / o(it) * a(qe, et), it];
+            }, Re;
+          }
+          function er() {
+            return Gt(mt).scale(123.082).center([0, 26.1441]).parallel(45);
+          }
+          function lr(ve) {
+            function be(Re, qe) {
+              var et = T - qe, Xe = et && Re * ve * _(et) / et;
+              return [et * _(Xe) / ve, T - et * o(Xe)];
+            }
+            return be.invert = function(Re, qe) {
+              var et = Re * ve, Xe = T - qe, it = G(et * et + Xe * Xe), Ft = a(et, Xe);
+              return [(it ? it / _(it) : 1) * Ft / ve, T - it];
+            }, be;
+          }
+          function wr() {
+            var ve = 0.5, be = t.geoProjectionMutator(lr), Re = be(ve);
+            return Re.fraction = function(qe) {
+              return arguments.length ? be(ve = +qe) : ve;
+            }, Re.scale(158.837);
+          }
+          var Lr = $t(1, 4 / E, E);
+          function ti() {
+            return t.geoProjection(Lr).scale(152.63);
+          }
+          function Br(ve, be, Re, qe, et, Xe) {
+            var it = o(Xe), Ft;
+            if (n(ve) > 1 || n(Xe) > 1) Ft = U(Re * et + be * qe * it);
+            else {
+              var Ht = _(ve / 2), tr = _(Xe / 2);
+              Ft = 2 * O(G(Ht * Ht + be * qe * tr * tr));
+            }
+            return n(Ft) > p ? [Ft, a(qe * _(Xe), be * et - Re * qe * it)] : [0, 0];
+          }
+          function Vr(ve, be, Re) {
+            return U((ve * ve + be * be - Re * Re) / (2 * ve * be));
+          }
+          function dt(ve) {
+            return ve - 2 * E * l((ve + E) / (2 * E));
+          }
+          function Ge(ve, be, Re) {
+            for (var qe = [[ve[0], ve[1], _(ve[1]), o(ve[1])], [be[0], be[1], _(be[1]), o(be[1])], [Re[0], Re[1], _(Re[1]), o(Re[1])]], et = qe[2], Xe, it = 0; it < 3; ++it, et = Xe) Xe = qe[it], et.v = Br(Xe[1] - et[1], et[3], et[2], Xe[3], Xe[2], Xe[0] - et[0]), et.point = [0, 0];
+            var Ft = Vr(qe[0].v[0], qe[2].v[0], qe[1].v[0]), Ht = Vr(qe[0].v[0], qe[1].v[0], qe[2].v[0]), tr = E - Ft;
+            qe[2].point[1] = 0, qe[0].point[0] = -(qe[1].point[0] = qe[0].v[0] / 2);
+            var dr = [qe[2].point[0] = qe[0].point[0] + qe[2].v[0] * o(Ft), 2 * (qe[0].point[1] = qe[1].point[1] = qe[2].v[0] * _(Ft))];
+            function Sr(Or, Wr) {
+              var ni = _(Wr), Pi = o(Wr), cn = new Array(3), ln;
+              for (ln = 0; ln < 3; ++ln) {
+                var Cn = qe[ln];
+                if (cn[ln] = Br(Wr - Cn[1], Cn[3], Cn[2], Pi, ni, Or - Cn[0]), !cn[ln][0]) return Cn.point;
+                cn[ln][1] = dt(cn[ln][1] - Cn.v[1]);
+              }
+              var Kn = dr.slice();
+              for (ln = 0; ln < 3; ++ln) {
+                var Aa = ln == 2 ? 0 : ln + 1, fa = Vr(qe[ln].v[0], cn[ln][0], cn[Aa][0]);
+                cn[ln][1] < 0 && (fa = -fa), ln ? ln == 1 ? (fa = Ht - fa, Kn[0] -= cn[ln][0] * o(fa), Kn[1] -= cn[ln][0] * _(fa)) : (fa = tr - fa, Kn[0] += cn[ln][0] * o(fa), Kn[1] += cn[ln][0] * _(fa)) : (Kn[0] += cn[ln][0] * o(fa), Kn[1] -= cn[ln][0] * _(fa));
+              }
+              return Kn[0] /= 3, Kn[1] /= 3, Kn;
+            }
+            return Sr;
+          }
+          function Je(ve) {
+            return ve[0] *= A, ve[1] *= A, ve;
+          }
+          function We() {
+            return tt([0, 22], [45, 22], [22.5, -22]).scale(380).center([22.5, 2]);
+          }
+          function tt(ve, be, Re) {
+            var qe = t.geoCentroid({ type: "MultiPoint", coordinates: [ve, be, Re] }), et = [-qe[0], -qe[1]], Xe = t.geoRotation(et), it = Ge(Je(Xe(ve)), Je(Xe(be)), Je(Xe(Re)));
+            it.invert = ot(it);
+            var Ft = t.geoProjection(it).rotate(et), Ht = Ft.center;
+            return delete Ft.rotate, Ft.center = function(tr) {
+              return arguments.length ? Ht(Xe(tr)) : Xe.invert(Ht());
+            }, Ft.clipAngle(90);
+          }
+          function xt(ve, be) {
+            var Re = G(1 - _(be));
+            return [2 / M * ve * Re, M * (1 - Re)];
+          }
+          xt.invert = function(ve, be) {
+            var Re = (Re = be / M - 1) * Re;
+            return [Re > 0 ? ve * G(E / Re) / 2 : 0, O(1 - Re)];
+          };
+          function Ie() {
+            return t.geoProjection(xt).scale(95.6464).center([0, 30]);
+          }
+          function xe(ve) {
+            var be = b(ve);
+            function Re(qe, et) {
+              return [qe, (qe ? qe / _(qe) : 1) * (_(et) * o(qe) - be * o(et))];
+            }
+            return Re.invert = be ? function(qe, et) {
+              qe && (et *= _(qe) / qe);
+              var Xe = o(qe);
+              return [qe, 2 * a(G(Xe * Xe + be * be - et * et) - Xe, be - et)];
+            } : function(qe, et) {
+              return [qe, O(qe ? et * b(qe) / qe : et)];
+            }, Re;
+          }
+          function ke() {
+            return Gt(xe).scale(249.828).clipAngle(90);
+          }
+          var vt = G(3);
+          function ir(ve, be) {
+            return [vt * ve * (2 * o(2 * be / 3) - 1) / M, vt * M * _(be / 3)];
+          }
+          ir.invert = function(ve, be) {
+            var Re = 3 * O(be / (vt * M));
+            return [M * ve / (vt * (2 * o(2 * Re / 3) - 1)), Re];
+          };
+          function ar() {
+            return t.geoProjection(ir).scale(156.19);
+          }
+          function vr(ve) {
+            var be = o(ve);
+            function Re(qe, et) {
+              return [qe * be, _(et) / be];
+            }
+            return Re.invert = function(qe, et) {
+              return [qe / be, O(et * be)];
+            }, Re;
+          }
+          function ii() {
+            return Gt(vr).parallel(38.58).scale(195.044);
+          }
+          function pi(ve) {
+            var be = o(ve);
+            function Re(qe, et) {
+              return [qe * be, (1 + be) * b(et / 2)];
+            }
+            return Re.invert = function(qe, et) {
+              return [qe / be, i(et / (1 + be)) * 2];
+            }, Re;
+          }
+          function $r() {
+            return Gt(pi).scale(124.75);
+          }
+          function di(ve, be) {
+            var Re = G(8 / (3 * E));
+            return [Re * ve * (1 - n(be) / E), Re * be];
+          }
+          di.invert = function(ve, be) {
+            var Re = G(8 / (3 * E)), qe = be / Re;
+            return [ve / (Re * (1 - n(qe) / E)), qe];
+          };
+          function ji() {
+            return t.geoProjection(di).scale(165.664);
+          }
+          function In(ve, be) {
+            var Re = G(4 - 3 * _(n(be)));
+            return [2 / G(6 * E) * ve * Re, v(be) * G(2 * E / 3) * (2 - Re)];
+          }
+          In.invert = function(ve, be) {
+            var Re = 2 - n(be) / G(2 * E / 3);
+            return [ve * G(6 * E) / (2 * Re), v(be) * O((4 - Re * Re) / 3)];
+          };
+          function wi() {
+            return t.geoProjection(In).scale(165.664);
+          }
+          function On(ve, be) {
+            var Re = G(E * (4 + E));
+            return [2 / Re * ve * (1 + G(1 - 4 * be * be / (E * E))), 4 / Re * be];
+          }
+          On.invert = function(ve, be) {
+            var Re = G(E * (4 + E)) / 2;
+            return [ve * Re / (1 + G(1 - be * be * (4 + E) / (4 * E))), be * Re / 2];
+          };
+          function qn() {
+            return t.geoProjection(On).scale(180.739);
+          }
+          function Fn(ve, be) {
+            var Re = (2 + T) * _(be);
+            be /= 2;
+            for (var qe = 0, et = 1 / 0; qe < 10 && n(et) > p; qe++) {
+              var Xe = o(be);
+              be -= et = (be + _(be) * (Xe + 2) - Re) / (2 * Xe * (1 + Xe));
+            }
+            return [2 / G(E * (4 + E)) * ve * (1 + o(be)), 2 * G(E / (4 + E)) * _(be)];
+          }
+          Fn.invert = function(ve, be) {
+            var Re = be * G((4 + E) / E) / 2, qe = O(Re), et = o(qe);
+            return [ve / (2 / G(E * (4 + E)) * (1 + et)), O((qe + Re * (et + 2)) / (2 + T))];
+          };
+          function ra() {
+            return t.geoProjection(Fn).scale(180.739);
+          }
+          function la(ve, be) {
+            return [ve * (1 + o(be)) / G(2 + E), 2 * be / G(2 + E)];
+          }
+          la.invert = function(ve, be) {
+            var Re = G(2 + E), qe = be * Re / 2;
+            return [Re * ve / (1 + o(qe)), qe];
+          };
+          function Ut() {
+            return t.geoProjection(la).scale(173.044);
+          }
+          function wt(ve, be) {
+            for (var Re = (1 + T) * _(be), qe = 0, et = 1 / 0; qe < 10 && n(et) > p; qe++) be -= et = (be + _(be) - Re) / (1 + o(be));
+            return Re = G(2 + E), [ve * (1 + o(be)) / Re, 2 * be / Re];
+          }
+          wt.invert = function(ve, be) {
+            var Re = 1 + T, qe = G(Re / 2);
+            return [ve * 2 * qe / (1 + o(be *= qe)), O((be + _(be)) / Re)];
+          };
+          function rr() {
+            return t.geoProjection(wt).scale(173.044);
+          }
+          var nr = 3 + 2 * C;
+          function Er(ve, be) {
+            var Re = _(ve /= 2), qe = o(ve), et = G(o(be)), Xe = o(be /= 2), it = _(be) / (Xe + C * qe * et), Ft = G(2 / (1 + it * it)), Ht = G((C * Xe + (qe + Re) * et) / (C * Xe + (qe - Re) * et));
+            return [nr * (Ft * (Ht - 1 / Ht) - 2 * u(Ht)), nr * (Ft * it * (Ht + 1 / Ht) - 2 * i(it))];
+          }
+          Er.invert = function(ve, be) {
+            if (!(Xe = Se.invert(ve / 1.2, be * 1.065))) return null;
+            var Re = Xe[0], qe = Xe[1], et = 20, Xe;
+            ve /= nr, be /= nr;
+            do {
+              var it = Re / 2, Ft = qe / 2, Ht = _(it), tr = o(it), dr = _(Ft), Sr = o(Ft), Or = o(qe), Wr = G(Or), ni = dr / (Sr + C * tr * Wr), Pi = ni * ni, cn = G(2 / (1 + Pi)), ln = C * Sr + (tr + Ht) * Wr, Cn = C * Sr + (tr - Ht) * Wr, Kn = ln / Cn, Aa = G(Kn), fa = Aa - 1 / Aa, $a = Aa + 1 / Aa, Co = cn * fa - 2 * u(Aa) - ve, Qa = cn * ni * $a - 2 * i(ni) - be, mo = dr && x * Wr * Ht * Pi / dr, Bo = (C * tr * Sr + Wr) / (2 * (Sr + C * tr * Wr) * (Sr + C * tr * Wr) * Wr), Ps = -0.5 * ni * cn * cn * cn, Ts = Ps * mo, wo = Ps * Bo, To = (To = 2 * Sr + C * Wr * (tr - Ht)) * To * Aa, hl = (C * tr * Sr * Wr + Or) / To, Ul = -(C * Ht * dr) / (Wr * To), Lu = fa * Ts - 2 * hl / Aa + cn * (hl + hl / Kn), au = fa * wo - 2 * Ul / Aa + cn * (Ul + Ul / Kn), Js = ni * $a * Ts - 2 * mo / (1 + Pi) + cn * $a * mo + cn * ni * (hl - hl / Kn), eu = ni * $a * wo - 2 * Bo / (1 + Pi) + cn * $a * Bo + cn * ni * (Ul - Ul / Kn), dc = au * Js - eu * Lu;
+              if (!dc) break;
+              var Tl = (Qa * au - Co * eu) / dc, Al = (Co * Js - Qa * Lu) / dc;
+              Re -= Tl, qe = c(-T, f(T, qe - Al));
+            } while ((n(Tl) > p || n(Al) > p) && --et > 0);
+            return n(n(qe) - T) < p ? [0, qe] : et && [Re, qe];
+          };
+          function Xr() {
+            return t.geoProjection(Er).scale(62.5271);
+          }
+          var ri = o(35 * A);
+          function Qr(ve, be) {
+            var Re = b(be / 2);
+            return [ve * ri * G(1 - Re * Re), (1 + ri) * Re];
+          }
+          Qr.invert = function(ve, be) {
+            var Re = be / (1 + ri);
+            return [ve && ve / (ri * G(1 - Re * Re)), 2 * i(Re)];
+          };
+          function Oi() {
+            return t.geoProjection(Qr).scale(137.152);
+          }
+          function $i(ve, be) {
+            var Re = be / 2, qe = o(Re);
+            return [2 * ve / M * o(be) * qe * qe, M * b(Re)];
+          }
+          $i.invert = function(ve, be) {
+            var Re = i(be / M), qe = o(Re), et = 2 * Re;
+            return [ve * M / 2 / (o(et) * qe * qe), et];
+          };
+          function tn() {
+            return t.geoProjection($i).scale(135.264);
+          }
+          function fn(ve) {
+            var be = 1 - ve, Re = Xe(E, 0)[0] - Xe(-E, 0)[0], qe = Xe(0, T)[1] - Xe(0, -T)[1], et = G(2 * qe / Re);
+            function Xe(Ht, tr) {
+              var dr = o(tr), Sr = _(tr);
+              return [dr / (be + ve * dr) * Ht, be * tr + ve * Sr];
+            }
+            function it(Ht, tr) {
+              var dr = Xe(Ht, tr);
+              return [dr[0] * et, dr[1] / et];
+            }
+            function Ft(Ht) {
+              return it(0, Ht)[1];
+            }
+            return it.invert = function(Ht, tr) {
+              var dr = Vt(Ft, tr), Sr = Ht / et * (ve + be / o(dr));
+              return [Sr, dr];
+            }, it;
+          }
+          function yn() {
+            var ve = 0.5, be = t.geoProjectionMutator(fn), Re = be(ve);
+            return Re.alpha = function(qe) {
+              return arguments.length ? be(ve = +qe) : ve;
+            }, Re.scale(168.725);
+          }
+          function Sn(ve) {
+            return [ve[0] / 2, O(b(ve[1] / 2 * A)) * P];
+          }
+          function Ba(ve) {
+            return [ve[0] * 2, 2 * i(_(ve[1] * A)) * P];
+          }
+          function ua(ve) {
+            ve == null && (ve = t.geoOrthographic);
+            var be = ve(), Re = t.geoEquirectangular().scale(P).precision(0).clipAngle(null).translate([0, 0]);
+            function qe(Xe) {
+              return be(Sn(Xe));
+            }
+            be.invert && (qe.invert = function(Xe) {
+              return Ba(be.invert(Xe));
+            }), qe.stream = function(Xe) {
+              var it = be.stream(Xe), Ft = Re.stream({ point: function(Ht, tr) {
+                it.point(Ht / 2, O(b(-tr / 2 * A)) * P);
+              }, lineStart: function() {
+                it.lineStart();
+              }, lineEnd: function() {
+                it.lineEnd();
+              }, polygonStart: function() {
+                it.polygonStart();
+              }, polygonEnd: function() {
+                it.polygonEnd();
+              } });
+              return Ft.sphere = it.sphere, Ft;
+            };
+            function et(Xe) {
+              qe[Xe] = function() {
+                return arguments.length ? (be[Xe].apply(be, arguments), qe) : be[Xe]();
+              };
+            }
+            return qe.rotate = function(Xe) {
+              return arguments.length ? (Re.rotate(Xe), qe) : Re.rotate();
+            }, qe.center = function(Xe) {
+              return arguments.length ? (be.center(Sn(Xe)), qe) : Ba(be.center());
+            }, et("angle"), et("clipAngle"), et("clipExtent"), et("fitExtent"), et("fitHeight"), et("fitSize"), et("fitWidth"), et("scale"), et("translate"), et("precision"), qe.scale(249.5);
+          }
+          function ma(ve, be) {
+            var Re = 2 * E / be, qe = ve * ve;
+            function et(Xe, it) {
+              var Ft = t.geoAzimuthalEquidistantRaw(Xe, it), Ht = Ft[0], tr = Ft[1], dr = Ht * Ht + tr * tr;
+              if (dr > qe) {
+                var Sr = G(dr), Or = a(tr, Ht), Wr = Re * d(Or / Re), ni = Or - Wr, Pi = ve * o(ni), cn = (ve * _(ni) - ni * _(Pi)) / (T - Pi), ln = Wa(ni, cn), Cn = (E - ve) / Fa(ln, Pi, E);
+                Ht = Sr;
+                var Kn = 50, Aa;
+                do
+                  Ht -= Aa = (ve + Fa(ln, Pi, Ht) * Cn - Sr) / (ln(Ht) * Cn);
+                while (n(Aa) > p && --Kn > 0);
+                tr = ni * _(Ht), Ht < T && (tr -= cn * (Ht - T));
+                var fa = _(Wr), $a = o(Wr);
+                Ft[0] = Ht * $a - tr * fa, Ft[1] = Ht * fa + tr * $a;
+              }
+              return Ft;
+            }
+            return et.invert = function(Xe, it) {
+              var Ft = Xe * Xe + it * it;
+              if (Ft > qe) {
+                var Ht = G(Ft), tr = a(it, Xe), dr = Re * d(tr / Re), Sr = tr - dr;
+                Xe = Ht * o(Sr), it = Ht * _(Sr);
+                for (var Or = Xe - T, Wr = _(Xe), ni = it / Wr, Pi = Xe < T ? 1 / 0 : 0, cn = 10; ; ) {
+                  var ln = ve * _(ni), Cn = ve * o(ni), Kn = _(Cn), Aa = T - Cn, fa = (ln - ni * Kn) / Aa, $a = Wa(ni, fa);
+                  if (n(Pi) < k || !--cn) break;
+                  ni -= Pi = (ni * Wr - fa * Or - it) / (Wr - Or * 2 * (Aa * (Cn + ni * ln * o(Cn) - Kn) - ln * (ln - ni * Kn)) / (Aa * Aa));
+                }
+                Ht = ve + Fa($a, Cn, Xe) * (E - ve) / Fa($a, Cn, E), tr = dr + ni, Xe = Ht * o(tr), it = Ht * _(tr);
+              }
+              return t.geoAzimuthalEquidistantRaw.invert(Xe, it);
+            }, et;
+          }
+          function Wa(ve, be) {
+            return function(Re) {
+              var qe = ve * o(Re);
+              return Re < T && (qe -= be), G(1 + qe * qe);
+            };
+          }
+          function Fa(ve, be, Re) {
+            for (var qe = 50, et = (Re - be) / qe, Xe = ve(be) + ve(Re), it = 1, Ft = be; it < qe; ++it) Xe += 2 * ve(Ft += et);
+            return Xe * 0.5 * et;
+          }
+          function Xo() {
+            var ve = 6, be = 30 * A, Re = o(be), qe = _(be), et = t.geoProjectionMutator(ma), Xe = et(be, ve), it = Xe.stream, Ft = 0.01, Ht = -o(Ft * A), tr = _(Ft * A);
+            return Xe.radius = function(dr) {
+              return arguments.length ? (Re = o(be = dr * A), qe = _(be), et(be, ve)) : be * P;
+            }, Xe.lobes = function(dr) {
+              return arguments.length ? et(be, ve = +dr) : ve;
+            }, Xe.stream = function(dr) {
+              var Sr = Xe.rotate(), Or = it(dr), Wr = (Xe.rotate([0, 0]), it(dr));
+              return Xe.rotate(Sr), Or.sphere = function() {
+                Wr.polygonStart(), Wr.lineStart();
+                for (var ni = 0, Pi = 2 * E / ve, cn = 0; ni < ve; ++ni, cn -= Pi) Wr.point(a(tr * o(cn), Ht) * P, O(tr * _(cn)) * P), Wr.point(a(qe * o(cn - Pi / 2), Re) * P, O(qe * _(cn - Pi / 2)) * P);
+                Wr.lineEnd(), Wr.polygonEnd();
+              }, Or;
+            }, Xe.rotate([90, -40]).scale(91.7095).clipAngle(180 - 1e-3);
+          }
+          function da(ve, be, Re, qe, et, Xe, it, Ft) {
+            arguments.length < 8 && (Ft = 0);
+            function Ht(tr, dr) {
+              if (!dr) return [ve * tr / E, 0];
+              var Sr = dr * dr, Or = ve + Sr * (be + Sr * (Re + Sr * qe)), Wr = dr * (et - 1 + Sr * (Xe - Ft + Sr * it)), ni = (Or * Or + Wr * Wr) / (2 * Wr), Pi = tr * O(Or / ni) / E;
+              return [ni * _(Pi), dr * (1 + Sr * Ft) + ni * (1 - o(Pi))];
+            }
+            return Ht.invert = function(tr, dr) {
+              var Sr = E * tr / ve, Or = dr, Wr, ni, Pi = 50;
+              do {
+                var cn = Or * Or, ln = ve + cn * (be + cn * (Re + cn * qe)), Cn = Or * (et - 1 + cn * (Xe - Ft + cn * it)), Kn = ln * ln + Cn * Cn, Aa = 2 * Cn, fa = Kn / Aa, $a = fa * fa, Co = O(ln / fa) / E, Qa = Sr * Co, mo = ln * ln, Bo = (2 * be + cn * (4 * Re + cn * 6 * qe)) * Or, Ps = et + cn * (3 * Xe + cn * 5 * it), Ts = 2 * (ln * Bo + Cn * (Ps - 1)), wo = 2 * (Ps - 1), To = (Ts * Aa - Kn * wo) / (Aa * Aa), hl = o(Qa), Ul = _(Qa), Lu = fa * hl, au = fa * Ul, Js = Sr / E * (1 / G(1 - mo / $a)) * (Bo * fa - ln * To) / $a, eu = au - tr, dc = Or * (1 + cn * Ft) + fa - Lu - dr, Tl = To * Ul + Lu * Js, Al = Lu * Co, X = 1 + To - (To * hl - au * Js), se = au * Co, Te = Tl * se - X * Al;
+                if (!Te) break;
+                Sr -= Wr = (dc * Tl - eu * X) / Te, Or -= ni = (eu * se - dc * Al) / Te;
+              } while ((n(Wr) > p || n(ni) > p) && --Pi > 0);
+              return [Sr, Or];
+            }, Ht;
+          }
+          var Wn = da(2.8284, -1.6988, 0.75432, -0.18071, 1.76003, -0.38914, 0.042555);
+          function Ha() {
+            return t.geoProjection(Wn).scale(149.995);
+          }
+          var vo = da(2.583819, -0.835827, 0.170354, -0.038094, 1.543313, -0.411435, 0.082742);
+          function jn() {
+            return t.geoProjection(vo).scale(153.93);
+          }
+          var Mt = da(5 / 6 * E, -0.62636, -0.0344, 0, 1.3493, -0.05524, 0, 0.045);
+          function kr() {
+            return t.geoProjection(Mt).scale(130.945);
+          }
+          function Jr(ve, be) {
+            var Re = ve * ve, qe = be * be;
+            return [ve * (1 - 0.162388 * qe) * (0.87 - 952426e-9 * Re * Re), be * (1 + qe / 12)];
+          }
+          Jr.invert = function(ve, be) {
+            var Re = ve, qe = be, et = 50, Xe;
+            do {
+              var it = qe * qe;
+              qe -= Xe = (qe * (1 + it / 12) - be) / (1 + it / 4);
+            } while (n(Xe) > p && --et > 0);
+            et = 50, ve /= 1 - 0.162388 * it;
+            do {
+              var Ft = (Ft = Re * Re) * Ft;
+              Re -= Xe = (Re * (0.87 - 952426e-9 * Ft) - ve) / (0.87 - 476213e-8 * Ft);
+            } while (n(Xe) > p && --et > 0);
+            return [Re, qe];
+          };
+          function vi() {
+            return t.geoProjection(Jr).scale(131.747);
+          }
+          var hn = da(2.6516, -0.76534, 0.19123, -0.047094, 1.36289, -0.13965, 0.031762);
+          function An() {
+            return t.geoProjection(hn).scale(131.087);
+          }
+          function Mn(ve) {
+            var be = ve(T, 0)[0] - ve(-T, 0)[0];
+            function Re(qe, et) {
+              var Xe = qe > 0 ? -0.5 : 0.5, it = ve(qe + Xe * E, et);
+              return it[0] -= Xe * be, it;
+            }
+            return ve.invert && (Re.invert = function(qe, et) {
+              var Xe = qe > 0 ? -0.5 : 0.5, it = ve.invert(qe + Xe * be, et), Ft = it[0] - Xe * E;
+              return Ft < -E ? Ft += 2 * E : Ft > E && (Ft -= 2 * E), it[0] = Ft, it;
+            }), Re;
+          }
+          function Li(ve, be) {
+            var Re = v(ve), qe = v(be), et = o(be), Xe = o(ve) * et, it = _(ve) * et, Ft = _(qe * be);
+            ve = n(a(it, Ft)), be = O(Xe), n(ve - T) > p && (ve %= T);
+            var Ht = _n(ve > E / 4 ? T - ve : ve, be);
+            return ve > E / 4 && (Ft = Ht[0], Ht[0] = -Ht[1], Ht[1] = -Ft), Ht[0] *= Re, Ht[1] *= -qe, Ht;
+          }
+          Li.invert = function(ve, be) {
+            n(ve) > 1 && (ve = v(ve) * 2 - ve), n(be) > 1 && (be = v(be) * 2 - be);
+            var Re = v(ve), qe = v(be), et = -Re * ve, Xe = -qe * be, it = Xe / et < 1, Ft = ya(it ? Xe : et, it ? et : Xe), Ht = Ft[0], tr = Ft[1], dr = o(tr);
+            return it && (Ht = -T - Ht), [Re * (a(_(Ht) * dr, -_(tr)) + E), qe * O(o(Ht) * dr)];
+          };
+          function _n(ve, be) {
+            if (be === T) return [0, 0];
+            var Re = _(be), qe = Re * Re, et = qe * qe, Xe = 1 + et, it = 1 + 3 * et, Ft = 1 - et, Ht = O(1 / G(Xe)), tr = Ft + qe * Xe * Ht, dr = (1 - Re) / tr, Sr = G(dr), Or = dr * Xe, Wr = G(Or), ni = Sr * Ft, Pi, cn;
+            if (ve === 0) return [0, -(ni + qe * Wr)];
+            var ln = o(be), Cn = 1 / ln, Kn = 2 * Re * ln, Aa = (-3 * qe + Ht * it) * Kn, fa = (-tr * ln - (1 - Re) * Aa) / (tr * tr), $a = 0.5 * fa / Sr, Co = Ft * $a - 2 * qe * Sr * Kn, Qa = qe * Xe * fa + dr * it * Kn, mo = -Cn * Kn, Bo = -Cn * Qa, Ps = -2 * Cn * Co, Ts = 4 * ve / E, wo;
+            if (ve > 0.222 * E || be < E / 4 && ve > 0.175 * E) {
+              if (Pi = (ni + qe * G(Or * (1 + et) - ni * ni)) / (1 + et), ve > E / 4) return [Pi, Pi];
+              var To = Pi, hl = 0.5 * Pi;
+              Pi = 0.5 * (hl + To), cn = 50;
+              do {
+                var Ul = G(Or - Pi * Pi), Lu = Pi * (Ps + mo * Ul) + Bo * O(Pi / Wr) - Ts;
+                if (!Lu) break;
+                Lu < 0 ? hl = Pi : To = Pi, Pi = 0.5 * (hl + To);
+              } while (n(To - hl) > p && --cn > 0);
+            } else {
+              Pi = p, cn = 25;
+              do {
+                var au = Pi * Pi, Js = G(Or - au), eu = Ps + mo * Js, dc = Pi * eu + Bo * O(Pi / Wr) - Ts, Tl = eu + (Bo - mo * au) / Js;
+                Pi -= wo = Js ? dc / Tl : 0;
+              } while (n(wo) > p && --cn > 0);
+            }
+            return [Pi, -ni - qe * G(Or - Pi * Pi)];
+          }
+          function ya(ve, be) {
+            for (var Re = 0, qe = 1, et = 0.5, Xe = 50; ; ) {
+              var it = et * et, Ft = G(et), Ht = O(1 / G(1 + it)), tr = 1 - it + et * (1 + it) * Ht, dr = (1 - Ft) / tr, Sr = G(dr), Or = dr * (1 + it), Wr = Sr * (1 - it), ni = Or - ve * ve, Pi = G(ni), cn = be + Wr + et * Pi;
+              if (n(qe - Re) < k || --Xe === 0 || cn === 0) break;
+              cn > 0 ? Re = et : qe = et, et = 0.5 * (Re + qe);
+            }
+            if (!Xe) return null;
+            var ln = O(Ft), Cn = o(ln), Kn = 1 / Cn, Aa = 2 * Ft * Cn, fa = (-3 * et + Ht * (1 + 3 * it)) * Aa, $a = (-tr * Cn - (1 - Ft) * fa) / (tr * tr), Co = 0.5 * $a / Sr, Qa = (1 - it) * Co - 2 * et * Sr * Aa, mo = -2 * Kn * Qa, Bo = -Kn * Aa, Ps = -Kn * (et * (1 + it) * $a + dr * (1 + 3 * it) * Aa);
+            return [E / 4 * (ve * (mo + Bo * Pi) + Ps * O(ve / G(Or))), ln];
+          }
+          function $n() {
+            return t.geoProjection(Mn(Li)).scale(239.75);
+          }
+          function Ma(ve, be, Re) {
+            var qe, et, Xe;
+            return ve ? (qe = _o(ve, Re), be ? (et = _o(be, 1 - Re), Xe = et[1] * et[1] + Re * qe[0] * qe[0] * et[0] * et[0], [[qe[0] * et[2] / Xe, qe[1] * qe[2] * et[0] * et[1] / Xe], [qe[1] * et[1] / Xe, -qe[0] * qe[2] * et[0] * et[2] / Xe], [qe[2] * et[1] * et[2] / Xe, -Re * qe[0] * qe[1] * et[0] / Xe]]) : [[qe[0], 0], [qe[1], 0], [qe[2], 0]]) : (et = _o(be, 1 - Re), [[0, et[0] / et[1]], [1 / et[1], 0], [et[2] / et[1], 0]]);
+          }
+          function _o(ve, be) {
+            var Re, qe, et, Xe, it;
+            if (be < p) return Xe = _(ve), qe = o(ve), Re = be * (ve - Xe * qe) / 4, [Xe - Re * qe, qe + Re * Xe, 1 - be * Xe * Xe / 2, ve - Re];
+            if (be >= 1 - p) return Re = (1 - be) / 4, qe = N(ve), Xe = Z(ve), et = 1 / qe, it = qe * j(ve), [Xe + Re * (it - ve) / (qe * qe), et - Re * Xe * et * (it - ve), et + Re * Xe * et * (it + ve), 2 * i(s(ve)) - T + Re * (it - ve) / qe];
+            var Ft = [1, 0, 0, 0, 0, 0, 0, 0, 0], Ht = [G(be), 0, 0, 0, 0, 0, 0, 0, 0], tr = 0;
+            for (qe = G(1 - be), it = 1; n(Ht[tr] / Ft[tr]) > p && tr < 8; ) Re = Ft[tr++], Ht[tr] = (Re - qe) / 2, Ft[tr] = (Re + qe) / 2, qe = G(Re * qe), it *= 2;
+            et = it * Ft[tr] * ve;
+            do
+              Xe = Ht[tr] * _(qe = et) / Ft[tr], et = (O(Xe) + et) / 2;
+            while (--tr);
+            return [_(et), Xe = o(et), Xe / o(et - qe), et];
+          }
+          function No(ve, be, Re) {
+            var qe = n(ve), et = n(be), Xe = j(et);
+            if (qe) {
+              var it = 1 / _(qe), Ft = 1 / (b(qe) * b(qe)), Ht = -(Ft + Re * (Xe * Xe * it * it) - 1 + Re), tr = (Re - 1) * Ft, dr = (-Ht + G(Ht * Ht - 4 * tr)) / 2;
+              return [po(i(1 / G(dr)), Re) * v(ve), po(i(G((dr / Ft - 1) / Re)), 1 - Re) * v(be)];
+            }
+            return [0, po(i(Xe), 1 - Re) * v(be)];
+          }
+          function po(ve, be) {
+            if (!be) return ve;
+            if (be === 1) return u(b(ve / 2 + L));
+            for (var Re = 1, qe = G(1 - be), et = G(be), Xe = 0; n(et) > p; Xe++) {
+              if (ve % E) {
+                var it = i(qe * b(ve) / Re);
+                it < 0 && (it += E), ve += it + ~~(ve / E) * E;
+              } else ve += ve;
+              et = (Re + qe) / 2, qe = G(Re * qe), et = ((Re = et) - qe) / 2;
+            }
+            return ve / (h(2, Xe) * Re);
+          }
+          function Lo(ve, be) {
+            var Re = (C - 1) / (C + 1), qe = G(1 - Re * Re), et = po(T, qe * qe), Xe = -1, it = u(b(E / 4 + n(be) / 2)), Ft = s(Xe * it) / G(Re), Ht = ko(Ft * o(Xe * ve), Ft * _(Xe * ve)), tr = No(Ht[0], Ht[1], qe * qe);
+            return [-tr[1], (be >= 0 ? 1 : -1) * (0.5 * et - tr[0])];
+          }
+          function ko(ve, be) {
+            var Re = ve * ve, qe = be + 1, et = 1 - Re - be * be;
+            return [0.5 * ((ve >= 0 ? T : -T) - a(et, 2 * ve)), -0.25 * u(et * et + 4 * Re) + 0.5 * u(qe * qe + Re)];
+          }
+          function Ds(ve, be) {
+            var Re = be[0] * be[0] + be[1] * be[1];
+            return [(ve[0] * be[0] + ve[1] * be[1]) / Re, (ve[1] * be[0] - ve[0] * be[1]) / Re];
+          }
+          Lo.invert = function(ve, be) {
+            var Re = (C - 1) / (C + 1), qe = G(1 - Re * Re), et = po(T, qe * qe), Xe = -1, it = Ma(0.5 * et - be, -ve, qe * qe), Ft = Ds(it[0], it[1]), Ht = a(Ft[1], Ft[0]) / Xe;
+            return [Ht, 2 * i(s(0.5 / Xe * u(Re * Ft[0] * Ft[0] + Re * Ft[1] * Ft[1]))) - T];
+          };
+          function Fs() {
+            return t.geoProjection(Mn(Lo)).scale(151.496);
+          }
+          function ll(ve) {
+            var be = _(ve), Re = o(ve), qe = ul(ve);
+            qe.invert = ul(-ve);
+            function et(Xe, it) {
+              var Ft = qe(Xe, it);
+              Xe = Ft[0], it = Ft[1];
+              var Ht = _(it), tr = o(it), dr = o(Xe), Sr = U(be * Ht + Re * tr * dr), Or = _(Sr), Wr = n(Or) > p ? Sr / Or : 1;
+              return [Wr * Re * _(Xe), (n(Xe) > T ? Wr : -Wr) * (be * tr - Re * Ht * dr)];
+            }
+            return et.invert = function(Xe, it) {
+              var Ft = G(Xe * Xe + it * it), Ht = -_(Ft), tr = o(Ft), dr = Ft * tr, Sr = -it * Ht, Or = Ft * be, Wr = G(dr * dr + Sr * Sr - Or * Or), ni = a(dr * Or + Sr * Wr, Sr * Or - dr * Wr), Pi = (Ft > T ? -1 : 1) * a(Xe * Ht, Ft * o(ni) * tr + it * _(ni) * Ht);
+              return qe.invert(Pi, ni);
+            }, et;
+          }
+          function ul(ve) {
+            var be = _(ve), Re = o(ve);
+            return function(qe, et) {
+              var Xe = o(et), it = o(qe) * Xe, Ft = _(qe) * Xe, Ht = _(et);
+              return [a(Ft, it * Re - Ht * be), O(Ht * Re + it * be)];
+            };
+          }
+          function zl() {
+            var ve = 0, be = t.geoProjectionMutator(ll), Re = be(ve), qe = Re.rotate, et = Re.stream, Xe = t.geoCircle();
+            return Re.parallel = function(it) {
+              if (!arguments.length) return ve * P;
+              var Ft = Re.rotate();
+              return be(ve = it * A).rotate(Ft);
+            }, Re.rotate = function(it) {
+              return arguments.length ? (qe.call(Re, [it[0], it[1] - ve * P]), Xe.center([-it[0], -it[1]]), Re) : (it = qe.call(Re), it[1] += ve * P, it);
+            }, Re.stream = function(it) {
+              return it = et(it), it.sphere = function() {
+                it.polygonStart();
+                var Ft = 0.01, Ht = Xe.radius(90 - Ft)().coordinates[0], tr = Ht.length - 1, dr = -1, Sr;
+                for (it.lineStart(); ++dr < tr; ) it.point((Sr = Ht[dr])[0], Sr[1]);
+                for (it.lineEnd(), Ht = Xe.radius(90 + Ft)().coordinates[0], tr = Ht.length - 1, it.lineStart(); --dr >= 0; ) it.point((Sr = Ht[dr])[0], Sr[1]);
+                it.lineEnd(), it.polygonEnd();
+              }, it;
+            }, Re.scale(79.4187).parallel(45).clipAngle(180 - 1e-3);
+          }
+          var us = 3, il = O(1 - 1 / us) * P, As = vr(0);
+          function cl(ve) {
+            var be = il * A, Re = xt(E, be)[0] - xt(-E, be)[0], qe = As(0, be)[1], et = xt(0, be)[1], Xe = M - et, it = g / ve, Ft = 4 / g, Ht = qe + Xe * Xe * 4 / g;
+            function tr(dr, Sr) {
+              var Or, Wr = n(Sr);
+              if (Wr > be) {
+                var ni = f(ve - 1, c(0, l((dr + E) / it)));
+                dr += E * (ve - 1) / ve - ni * it, Or = xt(dr, Wr), Or[0] = Or[0] * g / Re - g * (ve - 1) / (2 * ve) + ni * g / ve, Or[1] = qe + (Or[1] - et) * 4 * Xe / g, Sr < 0 && (Or[1] = -Or[1]);
+              } else Or = As(dr, Sr);
+              return Or[0] *= Ft, Or[1] /= Ht, Or;
+            }
+            return tr.invert = function(dr, Sr) {
+              dr /= Ft, Sr *= Ht;
+              var Or = n(Sr);
+              if (Or > qe) {
+                var Wr = f(ve - 1, c(0, l((dr + E) / it)));
+                dr = (dr + E * (ve - 1) / ve - Wr * it) * Re / g;
+                var ni = xt.invert(dr, 0.25 * (Or - qe) * g / Xe + et);
+                return ni[0] -= E * (ve - 1) / ve - Wr * it, Sr < 0 && (ni[1] = -ni[1]), ni;
+              }
+              return As.invert(dr, Sr);
+            }, tr;
+          }
+          function Ks(ve, be) {
+            return [ve, be & 1 ? 90 - p : il];
+          }
+          function zs(ve, be) {
+            return [ve, be & 1 ? -90 + p : -il];
+          }
+          function Io(ve) {
+            return [ve[0] * (1 - p), ve[1]];
+          }
+          function ls(ve) {
+            var be = [].concat(r.range(-180, 180 + ve / 2, ve).map(Ks), r.range(180, -180 - ve / 2, -ve).map(zs));
+            return { type: "Polygon", coordinates: [ve === 180 ? be.map(Io) : be] };
+          }
+          function Yl() {
+            var ve = 4, be = t.geoProjectionMutator(cl), Re = be(ve), qe = Re.stream;
+            return Re.lobes = function(et) {
+              return arguments.length ? be(ve = +et) : ve;
+            }, Re.stream = function(et) {
+              var Xe = Re.rotate(), it = qe(et), Ft = (Re.rotate([0, 0]), qe(et));
+              return Re.rotate(Xe), it.sphere = function() {
+                t.geoStream(ls(180 / ve), Ft);
+              }, it;
+            }, Re.scale(239.75);
+          }
+          function Su(ve) {
+            var be = 1 + ve, Re = _(1 / be), qe = O(Re), et = 2 * G(E / (Xe = E + 4 * qe * be)), Xe, it = 0.5 * et * (be + G(ve * (2 + ve))), Ft = ve * ve, Ht = be * be;
+            function tr(dr, Sr) {
+              var Or = 1 - _(Sr), Wr, ni;
+              if (Or && Or < 2) {
+                var Pi = T - Sr, cn = 25, ln;
+                do {
+                  var Cn = _(Pi), Kn = o(Pi), Aa = qe + a(Cn, be - Kn), fa = 1 + Ht - 2 * be * Kn;
+                  Pi -= ln = (Pi - Ft * qe - be * Cn + fa * Aa - 0.5 * Or * Xe) / (2 * be * Cn * Aa);
+                } while (n(ln) > k && --cn > 0);
+                Wr = et * G(fa), ni = dr * Aa / E;
+              } else Wr = et * (ve + Or), ni = dr * qe / E;
+              return [Wr * _(ni), it - Wr * o(ni)];
+            }
+            return tr.invert = function(dr, Sr) {
+              var Or = dr * dr + (Sr -= it) * Sr, Wr = (1 + Ht - Or / (et * et)) / (2 * be), ni = U(Wr), Pi = _(ni), cn = qe + a(Pi, be - Wr);
+              return [O(dr / G(Or)) * E / cn, O(1 - 2 * (ni - Ft * qe - be * Pi + (1 + Ht - 2 * be * Wr) * cn) / Xe)];
+            }, tr;
+          }
+          function nc() {
+            var ve = 1, be = t.geoProjectionMutator(Su), Re = be(ve);
+            return Re.ratio = function(qe) {
+              return arguments.length ? be(ve = +qe) : ve;
+            }, Re.scale(167.774).center([0, 18.67]);
+          }
+          var bs = 0.7109889596207567, Rn = 0.0528035274542;
+          function _a(ve, be) {
+            return be > -0.7109889596207567 ? (ve = sr(ve, be), ve[1] += Rn, ve) : _t(ve, be);
+          }
+          _a.invert = function(ve, be) {
+            return be > -0.7109889596207567 ? sr.invert(ve, be - Rn) : _t.invert(ve, be);
+          };
+          function Vu() {
+            return t.geoProjection(_a).rotate([-20, -55]).scale(164.263).center([0, -5.4036]);
+          }
+          function Ol(ve, be) {
+            return n(be) > bs ? (ve = sr(ve, be), ve[1] -= be > 0 ? Rn : -0.0528035274542, ve) : _t(ve, be);
+          }
+          Ol.invert = function(ve, be) {
+            return n(be) > bs ? sr.invert(ve, be + (be > 0 ? Rn : -0.0528035274542)) : _t.invert(ve, be);
+          };
+          function xo() {
+            return t.geoProjection(Ol).scale(152.63);
+          }
+          function Kl(ve, be, Re, qe) {
+            var et = G(4 * E / (2 * Re + (1 + ve - be / 2) * _(2 * Re) + (ve + be) / 2 * _(4 * Re) + be / 2 * _(6 * Re))), Xe = G(qe * _(Re) * G((1 + ve * o(2 * Re) + be * o(4 * Re)) / (1 + ve + be))), it = Re * Ht(1);
+            function Ft(Sr) {
+              return G(1 + ve * o(2 * Sr) + be * o(4 * Sr));
+            }
+            function Ht(Sr) {
+              var Or = Sr * Re;
+              return (2 * Or + (1 + ve - be / 2) * _(2 * Or) + (ve + be) / 2 * _(4 * Or) + be / 2 * _(6 * Or)) / Re;
+            }
+            function tr(Sr) {
+              return Ft(Sr) * _(Sr);
+            }
+            var dr = function(Sr, Or) {
+              var Wr = Re * Vt(Ht, it * _(Or) / Re, Or / E);
+              isNaN(Wr) && (Wr = Re * v(Or));
+              var ni = et * Ft(Wr);
+              return [ni * Xe * Sr / E * o(Wr), ni / Xe * _(Wr)];
+            };
+            return dr.invert = function(Sr, Or) {
+              var Wr = Vt(tr, Or * Xe / et);
+              return [Sr * E / (o(Wr) * et * Xe * Ft(Wr)), O(Re * Ht(Wr / Re) / it)];
+            }, Re === 0 && (et = G(qe / E), dr = function(Sr, Or) {
+              return [Sr * et, _(Or) / et];
+            }, dr.invert = function(Sr, Or) {
+              return [Sr / et, O(Or * et)];
+            }), dr;
+          }
+          function Ns() {
+            var ve = 1, be = 0, Re = 45 * A, qe = 2, et = t.geoProjectionMutator(Kl), Xe = et(ve, be, Re, qe);
+            return Xe.a = function(it) {
+              return arguments.length ? et(ve = +it, be, Re, qe) : ve;
+            }, Xe.b = function(it) {
+              return arguments.length ? et(ve, be = +it, Re, qe) : be;
+            }, Xe.psiMax = function(it) {
+              return arguments.length ? et(ve, be, Re = +it * A, qe) : Re * P;
+            }, Xe.ratio = function(it) {
+              return arguments.length ? et(ve, be, Re, qe = +it) : qe;
+            }, Xe.scale(180.739);
+          }
+          function Hl(ve, be, Re, qe, et, Xe, it, Ft, Ht, tr, dr) {
+            if (dr.nanEncountered) return NaN;
+            var Sr, Or, Wr, ni, Pi, cn, ln, Cn, Kn, Aa;
+            if (Sr = Re - be, Or = ve(be + Sr * 0.25), Wr = ve(Re - Sr * 0.25), isNaN(Or)) {
+              dr.nanEncountered = true;
+              return;
+            }
+            if (isNaN(Wr)) {
+              dr.nanEncountered = true;
+              return;
+            }
+            return ni = Sr * (qe + 4 * Or + et) / 12, Pi = Sr * (et + 4 * Wr + Xe) / 12, cn = ni + Pi, Aa = (cn - it) / 15, tr > Ht ? (dr.maxDepthCount++, cn + Aa) : Math.abs(Aa) < Ft ? cn + Aa : (ln = be + Sr * 0.5, Cn = Hl(ve, be, ln, qe, Or, et, ni, Ft * 0.5, Ht, tr + 1, dr), isNaN(Cn) ? (dr.nanEncountered = true, NaN) : (Kn = Hl(ve, ln, Re, et, Wr, Xe, Pi, Ft * 0.5, Ht, tr + 1, dr), isNaN(Kn) ? (dr.nanEncountered = true, NaN) : Cn + Kn));
+          }
+          function ac(ve, be, Re, qe, et) {
+            var Xe = { maxDepthCount: 0, nanEncountered: false };
+            et === void 0 && (et = 20);
+            var it = ve(be), Ft = ve(0.5 * (be + Re)), Ht = ve(Re), tr = (it + 4 * Ft + Ht) * (Re - be) / 6, dr = Hl(ve, be, Re, it, Ft, Ht, tr, qe, et, 1, Xe);
+            return dr;
+          }
+          function aa(ve, be, Re) {
+            function qe(Wr) {
+              return ve + (1 - ve) * h(1 - h(Wr, be), 1 / be);
+            }
+            function et(Wr) {
+              return ac(qe, 0, Wr, 1e-4);
+            }
+            for (var Xe = 1 / et(1), it = 1e3, Ft = (1 + 1e-8) * Xe, Ht = [], tr = 0; tr <= it; tr++) Ht.push(et(tr / it) * Ft);
+            function dr(Wr) {
+              var ni = 0, Pi = it, cn = it >> 1;
+              do
+                Ht[cn] > Wr ? Pi = cn : ni = cn, cn = ni + Pi >> 1;
+              while (cn > ni);
+              var ln = Ht[cn + 1] - Ht[cn];
+              return ln && (ln = (Wr - Ht[cn + 1]) / ln), (cn + 1 + ln) / it;
+            }
+            var Sr = 2 * dr(1) / E * Xe / Re, Or = function(Wr, ni) {
+              var Pi = dr(n(_(ni))), cn = qe(Pi) * Wr;
+              return Pi /= Sr, [cn, ni >= 0 ? Pi : -Pi];
+            };
+            return Or.invert = function(Wr, ni) {
+              var Pi;
+              return ni *= Sr, n(ni) < 1 && (Pi = v(ni) * O(et(n(ni)) * Xe)), [Wr / qe(n(ni)), Pi];
+            }, Or;
+          }
+          function Oo() {
+            var ve = 0, be = 2.5, Re = 1.183136, qe = t.geoProjectionMutator(aa), et = qe(ve, be, Re);
+            return et.alpha = function(Xe) {
+              return arguments.length ? qe(ve = +Xe, be, Re) : ve;
+            }, et.k = function(Xe) {
+              return arguments.length ? qe(ve, be = +Xe, Re) : be;
+            }, et.gamma = function(Xe) {
+              return arguments.length ? qe(ve, be, Re = +Xe) : Re;
+            }, et.scale(152.63);
+          }
+          function qo(ve, be) {
+            return n(ve[0] - be[0]) < p && n(ve[1] - be[1]) < p;
+          }
+          function ql(ve, be) {
+            for (var Re = -1, qe = ve.length, et = ve[0], Xe, it, Ft, Ht = []; ++Re < qe; ) {
+              Xe = ve[Re], it = (Xe[0] - et[0]) / be, Ft = (Xe[1] - et[1]) / be;
+              for (var tr = 0; tr < be; ++tr) Ht.push([et[0] + tr * it, et[1] + tr * Ft]);
+              et = Xe;
+            }
+            return Ht.push(Xe), Ht;
+          }
+          function Pc(ve) {
+            var be = [], Re, qe, et, Xe, it, Ft, Ht, tr = ve[0].length;
+            for (Ht = 0; Ht < tr; ++Ht) Re = ve[0][Ht], qe = Re[0][0], et = Re[0][1], Xe = Re[1][1], it = Re[2][0], Ft = Re[2][1], be.push(ql([[qe + p, et + p], [qe + p, Xe - p], [it - p, Xe - p], [it - p, Ft + p]], 30));
+            for (Ht = ve[1].length - 1; Ht >= 0; --Ht) Re = ve[1][Ht], qe = Re[0][0], et = Re[0][1], Xe = Re[1][1], it = Re[2][0], Ft = Re[2][1], be.push(ql([[it - p, Ft - p], [it - p, Xe + p], [qe + p, Xe + p], [qe + p, et - p]], 30));
+            return { type: "Polygon", coordinates: [r.merge(be)] };
+          }
+          function Do(ve, be, Re) {
+            var qe, et;
+            function Xe(Ht, tr) {
+              for (var dr = tr < 0 ? -1 : 1, Sr = be[+(tr < 0)], Or = 0, Wr = Sr.length - 1; Or < Wr && Ht > Sr[Or][2][0]; ++Or) ;
+              var ni = ve(Ht - Sr[Or][1][0], tr);
+              return ni[0] += ve(Sr[Or][1][0], dr * tr > dr * Sr[Or][0][1] ? Sr[Or][0][1] : tr)[0], ni;
+            }
+            Re ? Xe.invert = Re(Xe) : ve.invert && (Xe.invert = function(Ht, tr) {
+              for (var dr = et[+(tr < 0)], Sr = be[+(tr < 0)], Or = 0, Wr = dr.length; Or < Wr; ++Or) {
+                var ni = dr[Or];
+                if (ni[0][0] <= Ht && Ht < ni[1][0] && ni[0][1] <= tr && tr < ni[1][1]) {
+                  var Pi = ve.invert(Ht - ve(Sr[Or][1][0], 0)[0], tr);
+                  return Pi[0] += Sr[Or][1][0], qo(Xe(Pi[0], Pi[1]), [Ht, tr]) ? Pi : null;
+                }
+              }
+            });
+            var it = t.geoProjection(Xe), Ft = it.stream;
+            return it.stream = function(Ht) {
+              var tr = it.rotate(), dr = Ft(Ht), Sr = (it.rotate([0, 0]), Ft(Ht));
+              return it.rotate(tr), dr.sphere = function() {
+                t.geoStream(qe, Sr);
+              }, dr;
+            }, it.lobes = function(Ht) {
+              return arguments.length ? (qe = Pc(Ht), be = Ht.map(function(tr) {
+                return tr.map(function(dr) {
+                  return [[dr[0][0] * A, dr[0][1] * A], [dr[1][0] * A, dr[1][1] * A], [dr[2][0] * A, dr[2][1] * A]];
+                });
+              }), et = be.map(function(tr) {
+                return tr.map(function(dr) {
+                  var Sr = ve(dr[0][0], dr[0][1])[0], Or = ve(dr[2][0], dr[2][1])[0], Wr = ve(dr[1][0], dr[0][1])[1], ni = ve(dr[1][0], dr[1][1])[1], Pi;
+                  return Wr > ni && (Pi = Wr, Wr = ni, ni = Pi), [[Sr, Wr], [Or, ni]];
+                });
+              }), it) : be.map(function(tr) {
+                return tr.map(function(dr) {
+                  return [[dr[0][0] * P, dr[0][1] * P], [dr[1][0] * P, dr[1][1] * P], [dr[2][0] * P, dr[2][1] * P]];
+                });
+              });
+            }, be != null && it.lobes(be), it;
+          }
+          var rf = [[[[-180, 0], [-100, 90], [-40, 0]], [[-40, 0], [30, 90], [180, 0]]], [[[-180, 0], [-160, -90], [-100, 0]], [[-100, 0], [-60, -90], [-20, 0]], [[-20, 0], [20, -90], [80, 0]], [[80, 0], [140, -90], [180, 0]]]];
+          function Vf() {
+            return Do(St, rf).scale(160.857);
+          }
+          var pl = [[[[-180, 0], [-100, 90], [-40, 0]], [[-40, 0], [30, 90], [180, 0]]], [[[-180, 0], [-160, -90], [-100, 0]], [[-100, 0], [-60, -90], [-20, 0]], [[-20, 0], [20, -90], [80, 0]], [[80, 0], [140, -90], [180, 0]]]];
+          function Zc() {
+            return Do(Ol, pl).scale(152.63);
+          }
+          var Jl = [[[[-180, 0], [-100, 90], [-40, 0]], [[-40, 0], [30, 90], [180, 0]]], [[[-180, 0], [-160, -90], [-100, 0]], [[-100, 0], [-60, -90], [-20, 0]], [[-20, 0], [20, -90], [80, 0]], [[80, 0], [140, -90], [180, 0]]]];
+          function Os() {
+            return Do(sr, Jl).scale(169.529);
+          }
+          var yu = [[[[-180, 0], [-90, 90], [0, 0]], [[0, 0], [90, 90], [180, 0]]], [[[-180, 0], [-90, -90], [0, 0]], [[0, 0], [90, -90], [180, 0]]]];
+          function oc() {
+            return Do(sr, yu).scale(169.529).rotate([20, 0]);
+          }
+          var Cf = [[[[-180, 35], [-30, 90], [0, 35]], [[0, 35], [30, 90], [180, 35]]], [[[-180, -10], [-102, -90], [-65, -10]], [[-65, -10], [5, -90], [77, -10]], [[77, -10], [103, -90], [180, -10]]]];
+          function sc() {
+            return Do(_a, Cf, ot).rotate([-20, -55]).scale(164.263).center([0, -5.4036]);
+          }
+          var jh = [[[[-180, 0], [-110, 90], [-40, 0]], [[-40, 0], [0, 90], [40, 0]], [[40, 0], [110, 90], [180, 0]]], [[[-180, 0], [-110, -90], [-40, 0]], [[-40, 0], [0, -90], [40, 0]], [[40, 0], [110, -90], [180, 0]]]];
+          function Lf() {
+            return Do(_t, jh).scale(152.63).rotate([-20, 0]);
+          }
+          function cs(ve, be) {
+            return [3 / g * ve * G(E * E / 3 - be * be), be];
+          }
+          cs.invert = function(ve, be) {
+            return [g / 3 * ve / G(E * E / 3 - be * be), be];
+          };
+          function nf() {
+            return t.geoProjection(cs).scale(158.837);
+          }
+          function Gf(ve) {
+            function be(Re, qe) {
+              if (n(n(qe) - T) < p) return [0, qe < 0 ? -2 : 2];
+              var et = _(qe), Xe = h((1 + et) / (1 - et), ve / 2), it = 0.5 * (Xe + 1 / Xe) + o(Re *= ve);
+              return [2 * _(Re) / it, (Xe - 1 / Xe) / it];
+            }
+            return be.invert = function(Re, qe) {
+              var et = n(qe);
+              if (n(et - 2) < p) return Re ? null : [0, v(qe) * T];
+              if (et > 2) return null;
+              Re /= 2, qe /= 2;
+              var Xe = Re * Re, it = qe * qe, Ft = 2 * qe / (1 + Xe + it);
+              return Ft = h((1 + Ft) / (1 - Ft), 1 / ve), [a(2 * Re, 1 - Xe - it) / ve, O((Ft - 1) / (Ft + 1))];
+            }, be;
+          }
+          function $l() {
+            var ve = 0.5, be = t.geoProjectionMutator(Gf), Re = be(ve);
+            return Re.spacing = function(qe) {
+              return arguments.length ? be(ve = +qe) : ve;
+            }, Re.scale(124.75);
+          }
+          var fl = E / C;
+          function lc(ve, be) {
+            return [ve * (1 + G(o(be))) / 2, be / (o(be / 2) * o(ve / 6))];
+          }
+          lc.invert = function(ve, be) {
+            var Re = n(ve), qe = n(be), et = p, Xe = T;
+            qe < fl ? Xe *= qe / fl : et += 6 * U(fl / qe);
+            for (var it = 0; it < 25; it++) {
+              var Ft = _(Xe), Ht = G(o(Xe)), tr = _(Xe / 2), dr = o(Xe / 2), Sr = _(et / 6), Or = o(et / 6), Wr = 0.5 * et * (1 + Ht) - Re, ni = Xe / (dr * Or) - qe, Pi = Ht ? -0.25 * et * Ft / Ht : 0, cn = 0.5 * (1 + Ht), ln = (1 + 0.5 * Xe * tr / dr) / (dr * Or), Cn = Xe / dr * (Sr / 6) / (Or * Or), Kn = Pi * Cn - ln * cn, Aa = (Wr * Cn - ni * cn) / Kn, fa = (ni * Pi - Wr * ln) / Kn;
+              if (Xe -= Aa, et -= fa, n(Aa) < p && n(fa) < p) break;
+            }
+            return [ve < 0 ? -et : et, be < 0 ? -Xe : Xe];
+          };
+          function Fu() {
+            return t.geoProjection(lc).scale(97.2672);
+          }
+          function Es(ve, be) {
+            var Re = ve * ve, qe = be * be;
+            return [ve * (0.975534 + qe * (-0.119161 + Re * -0.0143059 + qe * -0.0547009)), be * (1.00384 + Re * (0.0802894 + qe * -0.02855 + Re * 199025e-9) + qe * (0.0998909 + qe * -0.0491032))];
+          }
+          Es.invert = function(ve, be) {
+            var Re = v(ve) * E, qe = be / 2, et = 50;
+            do {
+              var Xe = Re * Re, it = qe * qe, Ft = Re * qe, Ht = Re * (0.975534 + it * (-0.119161 + Xe * -0.0143059 + it * -0.0547009)) - ve, tr = qe * (1.00384 + Xe * (0.0802894 + it * -0.02855 + Xe * 199025e-9) + it * (0.0998909 + it * -0.0491032)) - be, dr = 0.975534 - it * (0.119161 + 3 * Xe * 0.0143059 + it * 0.0547009), Sr = -Ft * (2 * 0.119161 + 4 * 0.0547009 * it + 2 * 0.0143059 * Xe), Or = Ft * (2 * 0.0802894 + 4 * 199025e-9 * Xe + 2 * -0.02855 * it), Wr = 1.00384 + Xe * (0.0802894 + 199025e-9 * Xe) + it * (3 * (0.0998909 - 0.02855 * Xe) - 5 * 0.0491032 * it), ni = Sr * Or - Wr * dr, Pi = (tr * Sr - Ht * Wr) / ni, cn = (Ht * Or - tr * dr) / ni;
+              Re -= Pi, qe -= cn;
+            } while ((n(Pi) > p || n(cn) > p) && --et > 0);
+            return et && [Re, qe];
+          };
+          function Hs() {
+            return t.geoProjection(Es).scale(139.98);
+          }
+          function Go(ve, be) {
+            return [_(ve) / o(be), b(be) * o(ve)];
+          }
+          Go.invert = function(ve, be) {
+            var Re = ve * ve, qe = be * be, et = qe + 1, Xe = Re + et, it = ve ? x * G((Xe - G(Xe * Xe - 4 * Re)) / Re) : 1 / G(et);
+            return [O(ve * it), v(be) * U(it)];
+          };
+          function ps() {
+            return t.geoProjection(Go).scale(144.049).clipAngle(90 - 1e-3);
+          }
+          function uc(ve) {
+            var be = o(ve), Re = b(L + ve / 2);
+            function qe(et, Xe) {
+              var it = Xe - ve, Ft = n(it) < p ? et * be : n(Ft = L + Xe / 2) < p || n(n(Ft) - T) < p ? 0 : et * it / u(b(Ft) / Re);
+              return [Ft, it];
+            }
+            return qe.invert = function(et, Xe) {
+              var it, Ft = Xe + ve;
+              return [n(Xe) < p ? et / be : n(it = L + Ft / 2) < p || n(n(it) - T) < p ? 0 : et * u(b(it) / Re) / Xe, Ft];
+            }, qe;
+          }
+          function xl() {
+            return Gt(uc).parallel(40).scale(158.837);
+          }
+          function Gu(ve, be) {
+            return [ve, 1.25 * u(b(L + 0.4 * be))];
+          }
+          Gu.invert = function(ve, be) {
+            return [ve, 2.5 * i(s(0.8 * be)) - 0.625 * E];
+          };
+          function qs() {
+            return t.geoProjection(Gu).scale(108.318);
+          }
+          function od(ve) {
+            var be = ve.length - 1;
+            function Re(qe, et) {
+              for (var Xe = o(et), it = 2 / (1 + Xe * o(qe)), Ft = it * Xe * _(qe), Ht = it * _(et), tr = be, dr = ve[tr], Sr = dr[0], Or = dr[1], Wr; --tr >= 0; ) dr = ve[tr], Sr = dr[0] + Ft * (Wr = Sr) - Ht * Or, Or = dr[1] + Ft * Or + Ht * Wr;
+              return Sr = Ft * (Wr = Sr) - Ht * Or, Or = Ft * Or + Ht * Wr, [Sr, Or];
+            }
+            return Re.invert = function(qe, et) {
+              var Xe = 20, it = qe, Ft = et;
+              do {
+                for (var Ht = be, tr = ve[Ht], dr = tr[0], Sr = tr[1], Or = 0, Wr = 0, ni; --Ht >= 0; ) tr = ve[Ht], Or = dr + it * (ni = Or) - Ft * Wr, Wr = Sr + it * Wr + Ft * ni, dr = tr[0] + it * (ni = dr) - Ft * Sr, Sr = tr[1] + it * Sr + Ft * ni;
+                Or = dr + it * (ni = Or) - Ft * Wr, Wr = Sr + it * Wr + Ft * ni, dr = it * (ni = dr) - Ft * Sr - qe, Sr = it * Sr + Ft * ni - et;
+                var Pi = Or * Or + Wr * Wr, cn, ln;
+                it -= cn = (dr * Or + Sr * Wr) / Pi, Ft -= ln = (Sr * Or - dr * Wr) / Pi;
+              } while (n(cn) + n(ln) > p * p && --Xe > 0);
+              if (Xe) {
+                var Cn = G(it * it + Ft * Ft), Kn = 2 * i(Cn * 0.5), Aa = _(Kn);
+                return [a(it * Aa, Cn * o(Kn)), Cn ? O(Ft * Aa / Cn) : 0];
+              }
+            }, Re;
+          }
+          var Po = [[0.9972523, 0], [52513e-7, -41175e-7], [74606e-7, 48125e-7], [-0.0153783, -0.1968253], [0.0636871, -0.1408027], [0.3660976, -0.2937382]], sd = [[0.98879, 0], [0, 0], [-0.050909, 0], [0, 0], [0.075528, 0]], Ko = [[0.984299, 0], [0.0211642, 37608e-7], [-0.1036018, -0.0575102], [-0.0329095, -0.0320119], [0.0499471, 0.1223335], [0.026046, 0.0899805], [7388e-7, -0.1435792], [75848e-7, -0.1334108], [-0.0216473, 0.0776645], [-0.0225161, 0.0853673]], Pa = [[0.9245, 0], [0, 0], [0.01943, 0]], af = [[0.721316, 0], [0, 0], [-881625e-8, -617325e-8]];
+          function Hu() {
+            return Bl(Po, [152, -64]).scale(1400).center([-160.908, 62.4864]).clipAngle(30).angle(7.8);
+          }
+          function bl() {
+            return Bl(sd, [95, -38]).scale(1e3).clipAngle(55).center([-96.5563, 38.8675]);
+          }
+          function Hf() {
+            return Bl(Ko, [120, -45]).scale(359.513).clipAngle(55).center([-117.474, 53.0628]);
+          }
+          function Ic() {
+            return Bl(Pa, [-20, -18]).scale(209.091).center([20, 16.7214]).clipAngle(82);
+          }
+          function yf() {
+            return Bl(af, [165, 10]).scale(250).clipAngle(130).center([-165, -10]);
+          }
+          function Bl(ve, be) {
+            var Re = t.geoProjection(od(ve)).rotate(be).clipAngle(90), qe = t.geoRotation(be), et = Re.center;
+            return delete Re.rotate, Re.center = function(Xe) {
+              return arguments.length ? et(qe(Xe)) : qe.invert(et());
+            }, Re;
+          }
+          var Ah = G(6), Qf = G(7);
+          function _f(ve, be) {
+            var Re = O(7 * _(be) / (3 * Ah));
+            return [Ah * ve * (2 * o(2 * Re / 3) - 1) / Qf, 9 * _(Re / 3) / Qf];
+          }
+          _f.invert = function(ve, be) {
+            var Re = 3 * O(be * Qf / 9);
+            return [ve * Qf / (Ah * (2 * o(2 * Re / 3) - 1)), O(_(Re) * 3 * Ah / 7)];
+          };
+          function Yc() {
+            return t.geoProjection(_f).scale(164.859);
+          }
+          function eh(ve, be) {
+            for (var Re = (1 + x) * _(be), qe = be, et = 0, Xe; et < 25 && (qe -= Xe = (_(qe / 2) + _(qe) - Re) / (0.5 * o(qe / 2) + o(qe)), !(n(Xe) < p)); et++) ;
+            return [ve * (1 + 2 * o(qe) / o(qe / 2)) / (3 * C), 2 * G(3) * _(qe / 2) / G(2 + C)];
+          }
+          eh.invert = function(ve, be) {
+            var Re = be * G(2 + C) / (2 * G(3)), qe = 2 * O(Re);
+            return [3 * C * ve / (1 + 2 * o(qe) / o(qe / 2)), O((Re + _(qe)) / (1 + x))];
+          };
+          function th() {
+            return t.geoProjection(eh).scale(188.209);
+          }
+          function ju(ve, be) {
+            for (var Re = G(6 / (4 + E)), qe = (1 + E / 4) * _(be), et = be / 2, Xe = 0, it; Xe < 25 && (et -= it = (et / 2 + _(et) - qe) / (0.5 + o(et)), !(n(it) < p)); Xe++) ;
+            return [Re * (0.5 + o(et)) * ve / 1.5, Re * et];
+          }
+          ju.invert = function(ve, be) {
+            var Re = G(6 / (4 + E)), qe = be / Re;
+            return n(n(qe) - T) < p && (qe = qe < 0 ? -T : T), [1.5 * ve / (Re * (0.5 + o(qe))), O((qe / 2 + _(qe)) / (1 + E / 4))];
+          };
+          function jf() {
+            return t.geoProjection(ju).scale(166.518);
+          }
+          function cc(ve, be) {
+            var Re = be * be, qe = Re * Re, et = Re * qe;
+            return [ve * (0.84719 - 0.13063 * Re + et * et * (-0.04515 + 0.05494 * Re - 0.02326 * qe + 331e-5 * et)), be * (1.01183 + qe * qe * (-0.02625 + 0.01926 * Re - 396e-5 * qe))];
+          }
+          cc.invert = function(ve, be) {
+            var Re = be, qe = 25, et, Xe, it, Ft;
+            do
+              Xe = Re * Re, it = Xe * Xe, Re -= et = (Re * (1.01183 + it * it * (-0.02625 + 0.01926 * Xe - 396e-5 * it)) - be) / (1.01183 + it * it * (9 * -0.02625 + 11 * 0.01926 * Xe + 13 * -396e-5 * it));
+            while (n(et) > k && --qe > 0);
+            return Xe = Re * Re, it = Xe * Xe, Ft = Xe * it, [ve / (0.84719 - 0.13063 * Xe + Ft * Ft * (-0.04515 + 0.05494 * Xe - 0.02326 * it + 331e-5 * Ft)), Re];
+          };
+          function of() {
+            return t.geoProjection(cc).scale(175.295);
+          }
+          function Nl(ve, be) {
+            return [ve * (1 + o(be)) / 2, 2 * (be - b(be / 2))];
+          }
+          Nl.invert = function(ve, be) {
+            for (var Re = be / 2, qe = 0, et = 1 / 0; qe < 10 && n(et) > p; ++qe) {
+              var Xe = o(be / 2);
+              be -= et = (be - b(be / 2) - Re) / (1 - 0.5 / (Xe * Xe));
+            }
+            return [2 * ve / (1 + o(be)), be];
+          };
+          function Kc() {
+            return t.geoProjection(Nl).scale(152.63);
+          }
+          var Rc = [[[[-180, 0], [-90, 90], [0, 0]], [[0, 0], [90, 90], [180, 0]]], [[[-180, 0], [-90, -90], [0, 0]], [[0, 0], [90, -90], [180, 0]]]];
+          function gs() {
+            return Do(je(1 / 0), Rc).rotate([20, 0]).scale(152.63);
+          }
+          function Wf(ve, be) {
+            var Re = _(be), qe = o(be), et = v(ve);
+            if (ve === 0 || n(be) === T) return [0, be];
+            if (be === 0) return [ve, 0];
+            if (n(ve) === T) return [ve * qe, T * Re];
+            var Xe = E / (2 * ve) - 2 * ve / E, it = 2 * be / E, Ft = (1 - it * it) / (Re - it), Ht = Xe * Xe, tr = Ft * Ft, dr = 1 + Ht / tr, Sr = 1 + tr / Ht, Or = (Xe * Re / Ft - Xe / 2) / dr, Wr = (tr * Re / Ht + Ft / 2) / Sr, ni = Or * Or + qe * qe / dr, Pi = Wr * Wr - (tr * Re * Re / Ht + Ft * Re - 1) / Sr;
+            return [T * (Or + G(ni) * et), T * (Wr + G(Pi < 0 ? 0 : Pi) * v(-be * Xe) * et)];
+          }
+          Wf.invert = function(ve, be) {
+            ve /= T, be /= T;
+            var Re = ve * ve, qe = be * be, et = Re + qe, Xe = E * E;
+            return [ve ? (et - 1 + G((1 - et) * (1 - et) + 4 * Re)) / (2 * ve) * T : 0, Vt(function(it) {
+              return et * (E * _(it) - 2 * it) * E + 4 * it * it * (be - _(it)) + 2 * E * it - Xe * be;
+            }, 0)];
+          };
+          function Wh() {
+            return t.geoProjection(Wf).scale(127.267);
+          }
+          var rh = 1.0148, sf = 0.23185, Sh = -0.14499, Mu = 0.02406, ih = rh, js = 5 * sf, Eu = 7 * Sh, Dc = 9 * Mu, ks = 1.790857183;
+          function bc(ve, be) {
+            var Re = be * be;
+            return [ve, be * (rh + Re * Re * (sf + Re * (Sh + Mu * Re)))];
+          }
+          bc.invert = function(ve, be) {
+            be > ks ? be = ks : be < -1.790857183 && (be = -1.790857183);
+            var Re = be, qe;
+            do {
+              var et = Re * Re;
+              Re -= qe = (Re * (rh + et * et * (sf + et * (Sh + Mu * et))) - be) / (ih + et * et * (js + et * (Eu + Dc * et)));
+            } while (n(qe) > p);
+            return [ve, Re];
+          };
+          function hu() {
+            return t.geoProjection(bc).scale(139.319);
+          }
+          function _u(ve, be) {
+            if (n(be) < p) return [ve, 0];
+            var Re = b(be), qe = ve * _(be);
+            return [_(qe) / Re, be + (1 - o(qe)) / Re];
+          }
+          _u.invert = function(ve, be) {
+            if (n(be) < p) return [ve, 0];
+            var Re = ve * ve + be * be, qe = be * 0.5, et = 10, Xe;
+            do {
+              var it = b(qe), Ft = 1 / o(qe), Ht = Re - 2 * be * qe + qe * qe;
+              qe -= Xe = (it * Ht + 2 * (qe - be)) / (2 + Ht * Ft * Ft + 2 * (qe - be) * it);
+            } while (n(Xe) > p && --et > 0);
+            return it = b(qe), [(n(be) < n(qe + 1 / it) ? O(ve * it) : v(be) * v(ve) * (U(n(ve * it)) + T)) / _(qe), qe];
+          };
+          function nl() {
+            return t.geoProjection(_u).scale(103.74);
+          }
+          function nh(ve, be) {
+            var Re = Fc(ve[1], ve[0]), qe = Fc(be[1], be[0]), et = bd(Re, qe), Xe = wc(Re) / wc(qe);
+            return zu([1, 0, ve[0][0], 0, 1, ve[0][1]], zu([Xe, 0, 0, 0, Xe, 0], zu([o(et), _(et), 0, -_(et), o(et), 0], [1, 0, -be[0][0], 0, 1, -be[0][1]])));
+          }
+          function Mh(ve) {
+            var be = 1 / (ve[0] * ve[4] - ve[1] * ve[3]);
+            return [be * ve[4], -be * ve[1], be * (ve[1] * ve[5] - ve[2] * ve[4]), -be * ve[3], be * ve[0], be * (ve[2] * ve[3] - ve[0] * ve[5])];
+          }
+          function zu(ve, be) {
+            return [ve[0] * be[0] + ve[1] * be[3], ve[0] * be[1] + ve[1] * be[4], ve[0] * be[2] + ve[1] * be[5] + ve[2], ve[3] * be[0] + ve[4] * be[3], ve[3] * be[1] + ve[4] * be[4], ve[3] * be[2] + ve[4] * be[5] + ve[5]];
+          }
+          function Fc(ve, be) {
+            return [ve[0] - be[0], ve[1] - be[1]];
+          }
+          function wc(ve) {
+            return G(ve[0] * ve[0] + ve[1] * ve[1]);
+          }
+          function bd(ve, be) {
+            return a(ve[0] * be[1] - ve[1] * be[0], ve[0] * be[0] + ve[1] * be[1]);
+          }
+          function xf(ve, be, Re) {
+            qe(ve, { transform: null });
+            function qe(tr, dr) {
+              if (tr.edges = jl(tr.face), dr.face) {
+                var Sr = tr.shared = bf(tr.face, dr.face), Or = nh(Sr.map(dr.project), Sr.map(tr.project));
+                tr.transform = dr.transform ? zu(dr.transform, Or) : Or;
+                for (var Wr = dr.edges, ni = 0, Pi = Wr.length; ni < Pi; ++ni) Ou(Sr[0], Wr[ni][1]) && Ou(Sr[1], Wr[ni][0]) && (Wr[ni] = tr), Ou(Sr[0], Wr[ni][0]) && Ou(Sr[1], Wr[ni][1]) && (Wr[ni] = tr);
+                for (Wr = tr.edges, ni = 0, Pi = Wr.length; ni < Pi; ++ni) Ou(Sr[0], Wr[ni][0]) && Ou(Sr[1], Wr[ni][1]) && (Wr[ni] = dr), Ou(Sr[0], Wr[ni][1]) && Ou(Sr[1], Wr[ni][0]) && (Wr[ni] = dr);
+              } else tr.transform = dr.transform;
+              return tr.children && tr.children.forEach(function(cn) {
+                qe(cn, tr);
+              }), tr;
+            }
+            function et(tr, dr) {
+              var Sr = be(tr, dr), Or = Sr.project([tr * P, dr * P]), Wr;
+              return (Wr = Sr.transform) ? [Wr[0] * Or[0] + Wr[1] * Or[1] + Wr[2], -(Wr[3] * Or[0] + Wr[4] * Or[1] + Wr[5])] : (Or[1] = -Or[1], Or);
+            }
+            lf(ve) && (et.invert = function(tr, dr) {
+              var Sr = Xe(ve, [tr, -dr]);
+              return Sr && (Sr[0] *= A, Sr[1] *= A, Sr);
+            });
+            function Xe(tr, dr) {
+              var Sr = tr.project.invert, Or = tr.transform, Wr = dr;
+              if (Or && (Or = Mh(Or), Wr = [Or[0] * Wr[0] + Or[1] * Wr[1] + Or[2], Or[3] * Wr[0] + Or[4] * Wr[1] + Or[5]]), Sr && tr === it(ni = Sr(Wr))) return ni;
+              for (var ni, Pi = tr.children, cn = 0, ln = Pi && Pi.length; cn < ln; ++cn) if (ni = Xe(Pi[cn], dr)) return ni;
+            }
+            function it(tr) {
+              return be(tr[0] * A, tr[1] * A);
+            }
+            var Ft = t.geoProjection(et), Ht = Ft.stream;
+            return Ft.stream = function(tr) {
+              var dr = Ft.rotate(), Sr = Ht(tr), Or = (Ft.rotate([0, 0]), Ht(tr));
+              return Ft.rotate(dr), Sr.sphere = function() {
+                Or.polygonStart(), Or.lineStart(), Pf(Or, ve), Or.lineEnd(), Or.polygonEnd();
+              }, Sr;
+            }, Ft.angle(Re == null ? -30 : Re * P);
+          }
+          function Pf(ve, be, Re) {
+            var qe, et = be.edges, Xe = et.length, it, Ft = { type: "MultiPoint", coordinates: be.face }, Ht = be.face.filter(function(Pi) {
+              return n(Pi[1]) !== 90;
+            }), tr = t.geoBounds({ type: "MultiPoint", coordinates: Ht }), dr = false, Sr = -1, Or = tr[1][0] - tr[0][0], Wr = Or === 180 || Or === 360 ? [(tr[0][0] + tr[1][0]) / 2, (tr[0][1] + tr[1][1]) / 2] : t.geoCentroid(Ft);
+            if (Re) for (; ++Sr < Xe && et[Sr] !== Re; ) ;
+            ++Sr;
+            for (var ni = 0; ni < Xe; ++ni) it = et[(ni + Sr) % Xe], Array.isArray(it) ? (dr || (ve.point((qe = t.geoInterpolate(it[0], Wr)(p))[0], qe[1]), dr = true), ve.point((qe = t.geoInterpolate(it[1], Wr)(p))[0], qe[1])) : (dr = false, it !== Re && Pf(ve, it, be));
+          }
+          function Ou(ve, be) {
+            return ve && be && ve[0] === be[0] && ve[1] === be[1];
+          }
+          function bf(ve, be) {
+            for (var Re, qe, et = ve.length, Xe = null, it = 0; it < et; ++it) {
+              Re = ve[it];
+              for (var Ft = be.length; --Ft >= 0; ) if (qe = be[Ft], Re[0] === qe[0] && Re[1] === qe[1]) {
+                if (Xe) return [Xe, Re];
+                Xe = Re;
+              }
+            }
+          }
+          function jl(ve) {
+            for (var be = ve.length, Re = [], qe = ve[be - 1], et = 0; et < be; ++et) Re.push([qe, qe = ve[et]]);
+            return Re;
+          }
+          function lf(ve) {
+            return ve.project.invert || ve.children && ve.children.some(lf);
+          }
+          var Xh = [[0, 90], [-90, 0], [0, 0], [90, 0], [180, 0], [0, -90]], If = [[0, 2, 1], [0, 3, 2], [5, 1, 2], [5, 2, 3], [0, 1, 4], [0, 4, 3], [5, 4, 1], [5, 3, 4]].map(function(ve) {
+            return ve.map(function(be) {
+              return Xh[be];
+            });
+          });
+          function Cs(ve) {
+            ve = ve || function(Re) {
+              var qe = t.geoCentroid({ type: "MultiPoint", coordinates: Re });
+              return t.geoGnomonic().scale(1).translate([0, 0]).rotate([-qe[0], -qe[1]]);
+            };
+            var be = If.map(function(Re) {
+              return { face: Re, project: ve(Re) };
+            });
+            return [-1, 0, 0, 1, 0, 1, 4, 5].forEach(function(Re, qe) {
+              var et = be[Re];
+              et && (et.children || (et.children = [])).push(be[qe]);
+            }), xf(be[0], function(Re, qe) {
+              return be[Re < -E / 2 ? qe < 0 ? 6 : 4 : Re < 0 ? qe < 0 ? 2 : 0 : Re < E / 2 ? qe < 0 ? 3 : 1 : qe < 0 ? 7 : 5];
+            }).angle(-30).scale(101.858).center([0, 45]);
+          }
+          var du = 2 / G(3);
+          function ku(ve, be) {
+            var Re = xt(ve, be);
+            return [Re[0] * du, Re[1]];
+          }
+          ku.invert = function(ve, be) {
+            return xt.invert(ve / du, be);
+          };
+          function Xf(ve) {
+            ve = ve || function(Re) {
+              var qe = t.geoCentroid({ type: "MultiPoint", coordinates: Re });
+              return t.geoProjection(ku).translate([0, 0]).scale(1).rotate(qe[1] > 0 ? [-qe[0], 0] : [180 - qe[0], 180]);
+            };
+            var be = If.map(function(Re) {
+              return { face: Re, project: ve(Re) };
+            });
+            return [-1, 0, 0, 1, 0, 1, 4, 5].forEach(function(Re, qe) {
+              var et = be[Re];
+              et && (et.children || (et.children = [])).push(be[qe]);
+            }), xf(be[0], function(Re, qe) {
+              return be[Re < -E / 2 ? qe < 0 ? 6 : 4 : Re < 0 ? qe < 0 ? 2 : 0 : Re < E / 2 ? qe < 0 ? 3 : 1 : qe < 0 ? 7 : 5];
+            }).angle(-30).scale(121.906).center([0, 48.5904]);
+          }
+          function Us(ve) {
+            ve = ve || function(it) {
+              var Ft = it.length === 6 ? t.geoCentroid({ type: "MultiPoint", coordinates: it }) : it[0];
+              return t.geoGnomonic().scale(1).translate([0, 0]).rotate([-Ft[0], -Ft[1]]);
+            };
+            var be = If.map(function(it) {
+              for (var Ft = it.map(Rf), Ht = Ft.length, tr = Ft[Ht - 1], dr, Sr = [], Or = 0; Or < Ht; ++Or) dr = Ft[Or], Sr.push(Wu([tr[0] * 0.9486832980505138 + dr[0] * 0.31622776601683794, tr[1] * 0.9486832980505138 + dr[1] * 0.31622776601683794, tr[2] * 0.9486832980505138 + dr[2] * 0.31622776601683794]), Wu([dr[0] * 0.9486832980505138 + tr[0] * 0.31622776601683794, dr[1] * 0.9486832980505138 + tr[1] * 0.31622776601683794, dr[2] * 0.9486832980505138 + tr[2] * 0.31622776601683794])), tr = dr;
+              return Sr;
+            }), Re = [], qe = [-1, 0, 0, 1, 0, 1, 4, 5];
+            be.forEach(function(it, Ft) {
+              for (var Ht = If[Ft], tr = Ht.length, dr = Re[Ft] = [], Sr = 0; Sr < tr; ++Sr) be.push([Ht[Sr], it[(Sr * 2 + 2) % (2 * tr)], it[(Sr * 2 + 1) % (2 * tr)]]), qe.push(Ft), dr.push(zc(Rf(it[(Sr * 2 + 2) % (2 * tr)]), Rf(it[(Sr * 2 + 1) % (2 * tr)])));
+            });
+            var et = be.map(function(it) {
+              return { project: ve(it), face: it };
+            });
+            qe.forEach(function(it, Ft) {
+              var Ht = et[it];
+              Ht && (Ht.children || (Ht.children = [])).push(et[Ft]);
+            });
+            function Xe(it, Ft) {
+              var Ht = o(Ft), tr = [Ht * o(it), Ht * _(it), _(Ft)], dr = it < -E / 2 ? Ft < 0 ? 6 : 4 : it < 0 ? Ft < 0 ? 2 : 0 : it < E / 2 ? Ft < 0 ? 3 : 1 : Ft < 0 ? 7 : 5, Sr = Re[dr];
+              return et[wf(Sr[0], tr) < 0 ? 8 + 3 * dr : wf(Sr[1], tr) < 0 ? 8 + 3 * dr + 1 : wf(Sr[2], tr) < 0 ? 8 + 3 * dr + 2 : dr];
+            }
+            return xf(et[0], Xe).angle(-30).scale(110.625).center([0, 45]);
+          }
+          function wf(ve, be) {
+            for (var Re = 0, qe = ve.length, et = 0; Re < qe; ++Re) et += ve[Re] * be[Re];
+            return et;
+          }
+          function zc(ve, be) {
+            return [ve[1] * be[2] - ve[2] * be[1], ve[2] * be[0] - ve[0] * be[2], ve[0] * be[1] - ve[1] * be[0]];
+          }
+          function Wu(ve) {
+            return [a(ve[1], ve[0]) * P, O(c(-1, f(1, ve[2]))) * P];
+          }
+          function Rf(ve) {
+            var be = ve[0] * A, Re = ve[1] * A, qe = o(Re);
+            return [qe * o(be), qe * _(be), _(Re)];
+          }
+          function Xu() {
+          }
+          function uf(ve) {
+            if ((Re = ve.length) < 4) return false;
+            for (var be = 0, Re, qe = ve[Re - 1][1] * ve[0][0] - ve[Re - 1][0] * ve[0][1]; ++be < Re; ) qe += ve[be - 1][1] * ve[be][0] - ve[be - 1][0] * ve[be][1];
+            return qe <= 0;
+          }
+          function Zf(ve, be) {
+            for (var Re = be[0], qe = be[1], et = false, Xe = 0, it = ve.length, Ft = it - 1; Xe < it; Ft = Xe++) {
+              var Ht = ve[Xe], tr = Ht[0], dr = Ht[1], Sr = ve[Ft], Or = Sr[0], Wr = Sr[1];
+              dr > qe ^ Wr > qe && Re < (Or - tr) * (qe - dr) / (Wr - dr) + tr && (et = !et);
+            }
+            return et;
+          }
+          function Wl(ve, be) {
+            var Re = be.stream, qe;
+            if (!Re) throw new Error("invalid projection");
+            switch (ve && ve.type) {
+              case "Feature":
+                qe = Zu;
+                break;
+              case "FeatureCollection":
+                qe = ah;
+                break;
+              default:
+                qe = Tc;
+                break;
+            }
+            return qe(ve, Re);
+          }
+          function ah(ve, be) {
+            return { type: "FeatureCollection", features: ve.features.map(function(Re) {
+              return Zu(Re, be);
+            }) };
+          }
+          function Zu(ve, be) {
+            return { type: "Feature", id: ve.id, properties: ve.properties, geometry: Tc(ve.geometry, be) };
+          }
+          function Oc(ve, be) {
+            return { type: "GeometryCollection", geometries: ve.geometries.map(function(Re) {
+              return Tc(Re, be);
+            }) };
+          }
+          function Tc(ve, be) {
+            if (!ve) return null;
+            if (ve.type === "GeometryCollection") return Oc(ve, be);
+            var Re;
+            switch (ve.type) {
+              case "Point":
+                Re = qc;
+                break;
+              case "MultiPoint":
+                Re = qc;
+                break;
+              case "LineString":
+                Re = cf;
+                break;
+              case "MultiLineString":
+                Re = cf;
+                break;
+              case "Polygon":
+                Re = fc;
+                break;
+              case "MultiPolygon":
+                Re = fc;
+                break;
+              case "Sphere":
+                Re = fc;
+                break;
+              default:
+                return null;
+            }
+            return t.geoStream(ve, be(Re)), Re.result();
+          }
+          var wl = [], vu = [], qc = { point: function(ve, be) {
+            wl.push([ve, be]);
+          }, result: function() {
+            var ve = wl.length ? wl.length < 2 ? { type: "Point", coordinates: wl[0] } : { type: "MultiPoint", coordinates: wl } : null;
+            return wl = [], ve;
+          } }, cf = { lineStart: Xu, point: function(ve, be) {
+            wl.push([ve, be]);
+          }, lineEnd: function() {
+            wl.length && (vu.push(wl), wl = []);
+          }, result: function() {
+            var ve = vu.length ? vu.length < 2 ? { type: "LineString", coordinates: vu[0] } : { type: "MultiLineString", coordinates: vu } : null;
+            return vu = [], ve;
+          } }, fc = { polygonStart: Xu, lineStart: Xu, point: function(ve, be) {
+            wl.push([ve, be]);
+          }, lineEnd: function() {
+            var ve = wl.length;
+            if (ve) {
+              do
+                wl.push(wl[0].slice());
+              while (++ve < 4);
+              vu.push(wl), wl = [];
+            }
+          }, polygonEnd: Xu, result: function() {
+            if (!vu.length) return null;
+            var ve = [], be = [];
+            return vu.forEach(function(Re) {
+              uf(Re) ? ve.push([Re]) : be.push(Re);
+            }), be.forEach(function(Re) {
+              var qe = Re[0];
+              ve.some(function(et) {
+                if (Zf(et[0], qe)) return et.push(Re), true;
+              }) || ve.push([Re]);
+            }), vu = [], ve.length ? ve.length > 1 ? { type: "MultiPolygon", coordinates: ve } : { type: "Polygon", coordinates: ve[0] } : null;
+          } };
+          function Bc(ve) {
+            var be = ve(T, 0)[0] - ve(-T, 0)[0];
+            function Re(qe, et) {
+              var Xe = n(qe) < T, it = ve(Xe ? qe : qe > 0 ? qe - E : qe + E, et), Ft = (it[0] - it[1]) * x, Ht = (it[0] + it[1]) * x;
+              if (Xe) return [Ft, Ht];
+              var tr = be * x, dr = Ft > 0 ^ Ht > 0 ? -1 : 1;
+              return [dr * Ft - v(Ht) * tr, dr * Ht - v(Ft) * tr];
+            }
+            return ve.invert && (Re.invert = function(qe, et) {
+              var Xe = (qe + et) * x, it = (et - qe) * x, Ft = n(Xe) < 0.5 * be && n(it) < 0.5 * be;
+              if (!Ft) {
+                var Ht = be * x, tr = Xe > 0 ^ it > 0 ? -1 : 1, dr = -tr * qe + (it > 0 ? 1 : -1) * Ht, Sr = -tr * et + (Xe > 0 ? 1 : -1) * Ht;
+                Xe = (-dr - Sr) * x, it = (dr - Sr) * x;
+              }
+              var Or = ve.invert(Xe, it);
+              return Ft || (Or[0] += Xe > 0 ? E : -E), Or;
+            }), t.geoProjection(Re).rotate([-90, -90, 45]).clipAngle(180 - 1e-3);
+          }
+          function At() {
+            return Bc(Li).scale(176.423);
+          }
+          function Xt() {
+            return Bc(Lo).scale(111.48);
+          }
+          function Cr(ve, be) {
+            if (!(0 <= (be = +be) && be <= 20)) throw new Error("invalid digits");
+            function Re(tr) {
+              var dr = tr.length, Sr = 2, Or = new Array(dr);
+              for (Or[0] = +tr[0].toFixed(be), Or[1] = +tr[1].toFixed(be); Sr < dr; ) Or[Sr] = tr[Sr], ++Sr;
+              return Or;
+            }
+            function qe(tr) {
+              return tr.map(Re);
+            }
+            function et(tr) {
+              for (var dr = Re(tr[0]), Sr = [dr], Or = 1; Or < tr.length; Or++) {
+                var Wr = Re(tr[Or]);
+                (Wr.length > 2 || Wr[0] != dr[0] || Wr[1] != dr[1]) && (Sr.push(Wr), dr = Wr);
+              }
+              return Sr.length === 1 && tr.length > 1 && Sr.push(Re(tr[tr.length - 1])), Sr;
+            }
+            function Xe(tr) {
+              return tr.map(et);
+            }
+            function it(tr) {
+              if (tr == null) return tr;
+              var dr;
+              switch (tr.type) {
+                case "GeometryCollection":
+                  dr = { type: "GeometryCollection", geometries: tr.geometries.map(it) };
+                  break;
+                case "Point":
+                  dr = { type: "Point", coordinates: Re(tr.coordinates) };
+                  break;
+                case "MultiPoint":
+                  dr = { type: tr.type, coordinates: qe(tr.coordinates) };
+                  break;
+                case "LineString":
+                  dr = { type: tr.type, coordinates: et(tr.coordinates) };
+                  break;
+                case "MultiLineString":
+                case "Polygon":
+                  dr = { type: tr.type, coordinates: Xe(tr.coordinates) };
+                  break;
+                case "MultiPolygon":
+                  dr = { type: "MultiPolygon", coordinates: tr.coordinates.map(Xe) };
+                  break;
+                default:
+                  return tr;
+              }
+              return tr.bbox != null && (dr.bbox = tr.bbox), dr;
+            }
+            function Ft(tr) {
+              var dr = { type: "Feature", properties: tr.properties, geometry: it(tr.geometry) };
+              return tr.id != null && (dr.id = tr.id), tr.bbox != null && (dr.bbox = tr.bbox), dr;
+            }
+            if (ve != null) switch (ve.type) {
+              case "Feature":
+                return Ft(ve);
+              case "FeatureCollection": {
+                var Ht = { type: "FeatureCollection", features: ve.features.map(Ft) };
+                return ve.bbox != null && (Ht.bbox = ve.bbox), Ht;
+              }
+              default:
+                return it(ve);
+            }
+            return ve;
+          }
+          function Ar(ve) {
+            var be = _(ve);
+            function Re(qe, et) {
+              var Xe = be ? b(qe * be / 2) / be : qe / 2;
+              if (!et) return [2 * Xe, -ve];
+              var it = 2 * i(Xe * _(et)), Ft = 1 / b(et);
+              return [_(it) * Ft, et + (1 - o(it)) * Ft - ve];
+            }
+            return Re.invert = function(qe, et) {
+              if (n(et += ve) < p) return [be ? 2 * i(be * qe / 2) / be : qe, 0];
+              var Xe = qe * qe + et * et, it = 0, Ft = 10, Ht;
+              do {
+                var tr = b(it), dr = 1 / o(it), Sr = Xe - 2 * et * it + it * it;
+                it -= Ht = (tr * Sr + 2 * (it - et)) / (2 + Sr * dr * dr + 2 * (it - et) * tr);
+              } while (n(Ht) > p && --Ft > 0);
+              var Or = qe * (tr = b(it)), Wr = b(n(et) < n(it + 1 / tr) ? O(Or) * 0.5 : U(Or) * 0.5 + E / 4) / _(it);
+              return [be ? 2 * i(be * Wr) / be : 2 * Wr, it];
+            }, Re;
+          }
+          function Kr() {
+            return Gt(Ar).scale(131.215);
+          }
+          var ki = [[0.9986, -0.062], [1, 0], [0.9986, 0.062], [0.9954, 0.124], [0.99, 0.186], [0.9822, 0.248], [0.973, 0.31], [0.96, 0.372], [0.9427, 0.434], [0.9216, 0.4958], [0.8962, 0.5571], [0.8679, 0.6176], [0.835, 0.6769], [0.7986, 0.7346], [0.7597, 0.7903], [0.7186, 0.8435], [0.6732, 0.8936], [0.6213, 0.9394], [0.5722, 0.9761], [0.5322, 1]];
+          ki.forEach(function(ve) {
+            ve[1] *= 1.0144;
+          });
+          function Xi(ve, be) {
+            var Re = f(18, n(be) * 36 / E), qe = l(Re), et = Re - qe, Xe = (Sr = ki[qe])[0], it = Sr[1], Ft = (Sr = ki[++qe])[0], Ht = Sr[1], tr = (Sr = ki[f(19, ++qe)])[0], dr = Sr[1], Sr;
+            return [ve * (Ft + et * (tr - Xe) / 2 + et * et * (tr - 2 * Ft + Xe) / 2), (be > 0 ? T : -T) * (Ht + et * (dr - it) / 2 + et * et * (dr - 2 * Ht + it) / 2)];
+          }
+          Xi.invert = function(ve, be) {
+            var Re = be / T, qe = Re * 90, et = f(18, n(qe / 5)), Xe = c(0, l(et));
+            do {
+              var it = ki[Xe][1], Ft = ki[Xe + 1][1], Ht = ki[f(19, Xe + 2)][1], tr = Ht - it, dr = Ht - 2 * Ft + it, Sr = 2 * (n(Re) - Ft) / tr, Or = dr / tr, Wr = Sr * (1 - Or * Sr * (1 - 2 * Or * Sr));
+              if (Wr >= 0 || Xe === 1) {
+                qe = (be >= 0 ? 5 : -5) * (Wr + et);
+                var ni = 50, Pi;
+                do
+                  et = f(18, n(qe) / 5), Xe = l(et), Wr = et - Xe, it = ki[Xe][1], Ft = ki[Xe + 1][1], Ht = ki[f(19, Xe + 2)][1], qe -= (Pi = (be >= 0 ? T : -T) * (Ft + Wr * (Ht - it) / 2 + Wr * Wr * (Ht - 2 * Ft + it) / 2) - be) * P;
+                while (n(Pi) > k && --ni > 0);
+                break;
+              }
+            } while (--Xe >= 0);
+            var cn = ki[Xe][0], ln = ki[Xe + 1][0], Cn = ki[f(19, Xe + 2)][0];
+            return [ve / (ln + Wr * (Cn - cn) / 2 + Wr * Wr * (Cn - 2 * ln + cn) / 2), qe * A];
+          };
+          function dn() {
+            return t.geoProjection(Xi).scale(152.63);
+          }
+          function wn(ve) {
+            function be(Re, qe) {
+              var et = o(qe), Xe = (ve - 1) / (ve - et * o(Re));
+              return [Xe * et * _(Re), Xe * _(qe)];
+            }
+            return be.invert = function(Re, qe) {
+              var et = Re * Re + qe * qe, Xe = G(et), it = (ve - G(1 - et * (ve + 1) / (ve - 1))) / ((ve - 1) / Xe + Xe / (ve - 1));
+              return [a(Re * it, Xe * G(1 - it * it)), Xe ? O(qe * it / Xe) : 0];
+            }, be;
+          }
+          function Nn(ve, be) {
+            var Re = wn(ve);
+            if (!be) return Re;
+            var qe = o(be), et = _(be);
+            function Xe(it, Ft) {
+              var Ht = Re(it, Ft), tr = Ht[1], dr = tr * et / (ve - 1) + qe;
+              return [Ht[0] * qe / dr, tr / dr];
+            }
+            return Xe.invert = function(it, Ft) {
+              var Ht = (ve - 1) / (ve - 1 - Ft * et);
+              return Re.invert(Ht * it, Ht * Ft * qe);
+            }, Xe;
+          }
+          function Yi() {
+            var ve = 2, be = 0, Re = t.geoProjectionMutator(Nn), qe = Re(ve, be);
+            return qe.distance = function(et) {
+              return arguments.length ? Re(ve = +et, be) : ve;
+            }, qe.tilt = function(et) {
+              return arguments.length ? Re(ve, be = et * A) : be * P;
+            }, qe.scale(432.147).clipAngle(U(1 / ve) * P - 1e-6);
+          }
+          var Qi = 1e-4, on = 1e4, Fi = -180, Qn = Fi + Qi, Ca = 180, Ra = Ca - Qi, La = -90, Na = La + Qi, Yn = 90, Dn = Yn - Qi;
+          function Ka(ve) {
+            return ve.length > 0;
+          }
+          function bo(ve) {
+            return Math.floor(ve * on) / on;
+          }
+          function Zo(ve) {
+            return ve === La || ve === Yn ? [0, ve] : [Fi, bo(ve)];
+          }
+          function Ss(ve) {
+            var be = ve[0], Re = ve[1], qe = false;
+            return be <= Qn ? (be = Fi, qe = true) : be >= Ra && (be = Ca, qe = true), Re <= Na ? (Re = La, qe = true) : Re >= Dn && (Re = Yn, qe = true), qe ? [be, Re] : ve;
+          }
+          function as(ve) {
+            return ve.map(Ss);
+          }
+          function ws(ve, be, Re) {
+            for (var qe = 0, et = ve.length; qe < et; ++qe) {
+              var Xe = ve[qe].slice();
+              Re.push({ index: -1, polygon: be, ring: Xe });
+              for (var it = 0, Ft = Xe.length; it < Ft; ++it) {
+                var Ht = Xe[it], tr = Ht[0], dr = Ht[1];
+                if (tr <= Qn || tr >= Ra || dr <= Na || dr >= Dn) {
+                  Xe[it] = Ss(Ht);
+                  for (var Sr = it + 1; Sr < Ft; ++Sr) {
+                    var Or = Xe[Sr], Wr = Or[0], ni = Or[1];
+                    if (Wr > Qn && Wr < Ra && ni > Na && ni < Dn) break;
+                  }
+                  if (Sr === it + 1) continue;
+                  if (it) {
+                    var Pi = { index: -1, polygon: be, ring: Xe.slice(0, it + 1) };
+                    Pi.ring[Pi.ring.length - 1] = Zo(dr), Re[Re.length - 1] = Pi;
+                  } else Re.pop();
+                  if (Sr >= Ft) break;
+                  Re.push({ index: -1, polygon: be, ring: Xe = Xe.slice(Sr - 1) }), Xe[0] = Zo(Xe[0][1]), it = -1, Ft = Xe.length;
+                }
+              }
+            }
+          }
+          function Ho(ve) {
+            var be, Re = ve.length, qe = {}, et = {}, Xe, it, Ft, Ht, tr;
+            for (be = 0; be < Re; ++be) {
+              if (Xe = ve[be], it = Xe.ring[0], Ht = Xe.ring[Xe.ring.length - 1], it[0] === Ht[0] && it[1] === Ht[1]) {
+                Xe.polygon.push(Xe.ring), ve[be] = null;
+                continue;
+              }
+              Xe.index = be, qe[it] = et[Ht] = Xe;
+            }
+            for (be = 0; be < Re; ++be) if (Xe = ve[be], Xe) {
+              if (it = Xe.ring[0], Ht = Xe.ring[Xe.ring.length - 1], Ft = et[it], tr = qe[Ht], delete qe[it], delete et[Ht], it[0] === Ht[0] && it[1] === Ht[1]) {
+                Xe.polygon.push(Xe.ring);
+                continue;
+              }
+              Ft ? (delete et[it], delete qe[Ft.ring[0]], Ft.ring.pop(), ve[Ft.index] = null, Xe = { index: -1, polygon: Ft.polygon, ring: Ft.ring.concat(Xe.ring) }, Ft === tr ? Xe.polygon.push(Xe.ring) : (Xe.index = Re++, ve.push(qe[Xe.ring[0]] = et[Xe.ring[Xe.ring.length - 1]] = Xe))) : tr ? (delete qe[Ht], delete et[tr.ring[tr.ring.length - 1]], Xe.ring.pop(), Xe = { index: Re++, polygon: tr.polygon, ring: Xe.ring.concat(tr.ring) }, ve[tr.index] = null, ve.push(qe[Xe.ring[0]] = et[Xe.ring[Xe.ring.length - 1]] = Xe)) : (Xe.ring.push(Xe.ring[0]), Xe.polygon.push(Xe.ring));
+            }
+          }
+          function ml(ve) {
+            var be = { type: "Feature", geometry: Ws(ve.geometry) };
+            return ve.id != null && (be.id = ve.id), ve.bbox != null && (be.bbox = ve.bbox), ve.properties != null && (be.properties = ve.properties), be;
+          }
+          function Ws(ve) {
+            if (ve == null) return ve;
+            var be, Re, qe, et;
+            switch (ve.type) {
+              case "GeometryCollection":
+                be = { type: "GeometryCollection", geometries: ve.geometries.map(Ws) };
+                break;
+              case "Point":
+                be = { type: "Point", coordinates: Ss(ve.coordinates) };
+                break;
+              case "MultiPoint":
+              case "LineString":
+                be = { type: ve.type, coordinates: as(ve.coordinates) };
+                break;
+              case "MultiLineString":
+                be = { type: "MultiLineString", coordinates: ve.coordinates.map(as) };
+                break;
+              case "Polygon": {
+                var Xe = [];
+                ws(ve.coordinates, Xe, Re = []), Ho(Re), be = { type: "Polygon", coordinates: Xe };
+                break;
+              }
+              case "MultiPolygon": {
+                Re = [], qe = -1, et = ve.coordinates.length;
+                for (var it = new Array(et); ++qe < et; ) ws(ve.coordinates[qe], it[qe] = [], Re);
+                Ho(Re), be = { type: "MultiPolygon", coordinates: it.filter(Ka) };
+                break;
+              }
+              default:
+                return ve;
+            }
+            return ve.bbox != null && (be.bbox = ve.bbox), be;
+          }
+          function Ls(ve) {
+            if (ve == null) return ve;
+            switch (ve.type) {
+              case "Feature":
+                return ml(ve);
+              case "FeatureCollection": {
+                var be = { type: "FeatureCollection", features: ve.features.map(ml) };
+                return ve.bbox != null && (be.bbox = ve.bbox), be;
+              }
+              default:
+                return Ws(ve);
+            }
+          }
+          function va(ve, be) {
+            var Re = b(be / 2), qe = _(L * Re);
+            return [ve * (0.74482 - 0.34588 * qe * qe), 1.70711 * Re];
+          }
+          va.invert = function(ve, be) {
+            var Re = be / 1.70711, qe = _(L * Re);
+            return [ve / (0.74482 - 0.34588 * qe * qe), 2 * i(Re)];
+          };
+          function no() {
+            return t.geoProjection(va).scale(146.153);
+          }
+          function ys(ve, be, Re) {
+            var qe = t.geoInterpolate(be, Re), et = qe(0.5), Xe = t.geoRotation([-et[0], -et[1]])(be), it = qe.distance / 2, Ft = -O(_(Xe[1] * A) / _(it)), Ht = [-et[0], -et[1], -(Xe[0] > 0 ? E - Ft : Ft) * P], tr = t.geoProjection(ve(it)).rotate(Ht), dr = t.geoRotation(Ht), Sr = tr.center;
+            return delete tr.rotate, tr.center = function(Or) {
+              return arguments.length ? Sr(dr(Or)) : dr.invert(Sr());
+            }, tr.clipAngle(90);
+          }
+          function rs(ve) {
+            var be = o(ve);
+            function Re(qe, et) {
+              var Xe = t.geoGnomonicRaw(qe, et);
+              return Xe[0] *= be, Xe;
+            }
+            return Re.invert = function(qe, et) {
+              return t.geoGnomonicRaw.invert(qe / be, et);
+            }, Re;
+          }
+          function Ql() {
+            return Cu([-158, 21.5], [-77, 39]).clipAngle(60).scale(400);
+          }
+          function Cu(ve, be) {
+            return ys(rs, ve, be);
+          }
+          function Yu(ve) {
+            if (!(ve *= 2)) return t.geoAzimuthalEquidistantRaw;
+            var be = -ve / 2, Re = -be, qe = ve * ve, et = b(Re), Xe = 0.5 / _(Re);
+            function it(Ft, Ht) {
+              var tr = U(o(Ht) * o(Ft - be)), dr = U(o(Ht) * o(Ft - Re)), Sr = Ht < 0 ? -1 : 1;
+              return tr *= tr, dr *= dr, [(tr - dr) / (2 * ve), Sr * G(4 * qe * dr - (qe - tr + dr) * (qe - tr + dr)) / (2 * ve)];
+            }
+            return it.invert = function(Ft, Ht) {
+              var tr = Ht * Ht, dr = o(G(tr + (Or = Ft + be) * Or)), Sr = o(G(tr + (Or = Ft + Re) * Or)), Or, Wr;
+              return [a(Wr = dr - Sr, Or = (dr + Sr) * et), (Ht < 0 ? -1 : 1) * U(G(Or * Or + Wr * Wr) * Xe)];
+            }, it;
+          }
+          function Nc() {
+            return pu([-158, 21.5], [-77, 39]).clipAngle(130).scale(122.571);
+          }
+          function pu(ve, be) {
+            return ys(Yu, ve, be);
+          }
+          function Uc(ve, be) {
+            if (n(be) < p) return [ve, 0];
+            var Re = n(be / T), qe = O(Re);
+            if (n(ve) < p || n(n(be) - T) < p) return [0, v(be) * E * b(qe / 2)];
+            var et = o(qe), Xe = n(E / ve - ve / E) / 2, it = Xe * Xe, Ft = et / (Re + et - 1), Ht = Ft * (2 / Re - 1), tr = Ht * Ht, dr = tr + it, Sr = Ft - tr, Or = it + Ft;
+            return [v(ve) * E * (Xe * Sr + G(it * Sr * Sr - dr * (Ft * Ft - tr))) / dr, v(be) * E * (Ht * Or - Xe * G((it + 1) * dr - Or * Or)) / dr];
+          }
+          Uc.invert = function(ve, be) {
+            if (n(be) < p) return [ve, 0];
+            if (n(ve) < p) return [0, T * _(2 * i(be / E))];
+            var Re = (ve /= E) * ve, qe = (be /= E) * be, et = Re + qe, Xe = et * et, it = -n(be) * (1 + et), Ft = it - 2 * qe + Re, Ht = -2 * it + 1 + 2 * qe + Xe, tr = qe / Ht + (2 * Ft * Ft * Ft / (Ht * Ht * Ht) - 9 * it * Ft / (Ht * Ht)) / 27, dr = (it - Ft * Ft / (3 * Ht)) / Ht, Sr = 2 * G(-dr / 3), Or = U(3 * tr / (dr * Sr)) / 3;
+            return [E * (et - 1 + G(1 + 2 * (Re - qe) + Xe)) / (2 * ve), v(be) * E * (-Sr * o(Or + E / 3) - Ft / (3 * Ht))];
+          };
+          function xu() {
+            return t.geoProjection(Uc).scale(79.4183);
+          }
+          function Ac(ve, be) {
+            if (n(be) < p) return [ve, 0];
+            var Re = n(be / T), qe = O(Re);
+            if (n(ve) < p || n(n(be) - T) < p) return [0, v(be) * E * b(qe / 2)];
+            var et = o(qe), Xe = n(E / ve - ve / E) / 2, it = Xe * Xe, Ft = et * (G(1 + it) - Xe * et) / (1 + it * Re * Re);
+            return [v(ve) * E * Ft, v(be) * E * G(1 - Ft * (2 * Xe + Ft))];
+          }
+          Ac.invert = function(ve, be) {
+            if (!ve) return [0, T * _(2 * i(be / E))];
+            var Re = n(ve / E), qe = (1 - Re * Re - (be /= E) * be) / (2 * Re), et = qe * qe, Xe = G(et + 1);
+            return [v(ve) * E * (Xe - qe), v(be) * T * _(2 * a(G((1 - 2 * qe * Re) * (qe + Xe) - Re), G(Xe + qe + Re)))];
+          };
+          function Ua() {
+            return t.geoProjection(Ac).scale(79.4183);
+          }
+          function oo(ve, be) {
+            if (n(be) < p) return [ve, 0];
+            var Re = be / T, qe = O(Re);
+            if (n(ve) < p || n(n(be) - T) < p) return [0, E * b(qe / 2)];
+            var et = (E / ve - ve / E) / 2, Xe = Re / (1 + o(qe));
+            return [E * (v(ve) * G(et * et + 1 - Xe * Xe) - et), E * Xe];
+          }
+          oo.invert = function(ve, be) {
+            if (!be) return [ve, 0];
+            var Re = be / E, qe = (E * E * (1 - Re * Re) - ve * ve) / (2 * E * ve);
+            return [ve ? E * (v(ve) * G(qe * qe + 1) - qe) : 0, T * _(2 * i(Re))];
+          };
+          function Vc() {
+            return t.geoProjection(oo).scale(79.4183);
+          }
+          function hc(ve, be) {
+            if (!be) return [ve, 0];
+            var Re = n(be);
+            if (!ve || Re === T) return [0, be];
+            var qe = Re / T, et = qe * qe, Xe = (8 * qe - et * (et + 2) - 5) / (2 * et * (qe - 1)), it = Xe * Xe, Ft = qe * Xe, Ht = et + it + 2 * Ft, tr = qe + 3 * Xe, dr = ve / T, Sr = dr + 1 / dr, Or = v(n(ve) - T) * G(Sr * Sr - 4), Wr = Or * Or, ni = Ht * (et + it * Wr - 1) + (1 - et) * (et * (tr * tr + 4 * it) + 12 * Ft * it + 4 * it * it), Pi = (Or * (Ht + it - 1) + 2 * G(ni)) / (4 * Ht + Wr);
+            return [v(ve) * T * Pi, v(be) * T * G(1 + Or * n(Pi) - Pi * Pi)];
+          }
+          hc.invert = function(ve, be) {
+            var Re;
+            if (!ve || !be) return [ve, be];
+            be /= E;
+            var qe = v(ve) * ve / T, et = (qe * qe - 1 + 4 * be * be) / n(qe), Xe = et * et, it = 2 * be, Ft = 50;
+            do {
+              var Ht = it * it, tr = (8 * it - Ht * (Ht + 2) - 5) / (2 * Ht * (it - 1)), dr = (3 * it - Ht * it - 10) / (2 * Ht * it), Sr = tr * tr, Or = it * tr, Wr = it + tr, ni = Wr * Wr, Pi = it + 3 * tr, cn = ni * (Ht + Sr * Xe - 1) + (1 - Ht) * (Ht * (Pi * Pi + 4 * Sr) + Sr * (12 * Or + 4 * Sr)), ln = -2 * Wr * (4 * Or * Sr + (1 - 4 * Ht + 3 * Ht * Ht) * (1 + dr) + Sr * (-6 + 14 * Ht - Xe + (-8 + 8 * Ht - 2 * Xe) * dr) + Or * (-8 + 12 * Ht + (-10 + 10 * Ht - Xe) * dr)), Cn = G(cn), Kn = et * (ni + Sr - 1) + 2 * Cn - qe * (4 * ni + Xe), Aa = et * (2 * tr * dr + 2 * Wr * (1 + dr)) + ln / Cn - 8 * Wr * (et * (-1 + Sr + ni) + 2 * Cn) * (1 + dr) / (Xe + 4 * ni);
+              it -= Re = Kn / Aa;
+            } while (Re > p && --Ft > 0);
+            return [v(ve) * (G(et * et + 4) + et) * E / 4, T * it];
+          };
+          function Ku() {
+            return t.geoProjection(hc).scale(127.16);
+          }
+          function ue(ve, be, Re, qe, et) {
+            function Xe(it, Ft) {
+              var Ht = Re * _(qe * Ft), tr = G(1 - Ht * Ht), dr = G(2 / (1 + tr * o(it *= et)));
+              return [ve * tr * dr * _(it), be * Ht * dr];
+            }
+            return Xe.invert = function(it, Ft) {
+              var Ht = it / ve, tr = Ft / be, dr = G(Ht * Ht + tr * tr), Sr = 2 * O(dr / 2);
+              return [a(it * b(Sr), ve * dr) / et, dr && O(Ft * _(Sr) / (be * Re * dr)) / qe];
+            }, Xe;
+          }
+          function w(ve, be, Re, qe) {
+            var et = E / 3;
+            ve = c(ve, p), be = c(be, p), ve = f(ve, T), be = f(be, E - p), Re = c(Re, 0), Re = f(Re, 100 - p), qe = c(qe, p);
+            var Xe = Re / 100 + 1, it = qe / 100, Ft = U(Xe * o(et)) / et, Ht = _(ve) / _(Ft * T), tr = be / E, dr = G(it * _(ve / 2) / _(be / 2)), Sr = dr / G(tr * Ht * Ft), Or = 1 / (dr * G(tr * Ht * Ft));
+            return ue(Sr, Or, Ht, Ft, tr);
+          }
+          function B() {
+            var ve = 65 * A, be = 60 * A, Re = 20, qe = 200, et = t.geoProjectionMutator(w), Xe = et(ve, be, Re, qe);
+            return Xe.poleline = function(it) {
+              return arguments.length ? et(ve = +it * A, be, Re, qe) : ve * P;
+            }, Xe.parallels = function(it) {
+              return arguments.length ? et(ve, be = +it * A, Re, qe) : be * P;
+            }, Xe.inflation = function(it) {
+              return arguments.length ? et(ve, be, Re = +it, qe) : Re;
+            }, Xe.ratio = function(it) {
+              return arguments.length ? et(ve, be, Re, qe = +it) : qe;
+            }, Xe.scale(163.775);
+          }
+          function Q() {
+            return B().poleline(65).parallels(60).inflation(0).ratio(200).scale(172.633);
+          }
+          var ee = 4 * E + 3 * G(3), le = 2 * G(2 * E * G(3) / ee), Oe = $t(le * G(3) / E, le, ee / 6);
+          function Ze() {
+            return t.geoProjection(Oe).scale(176.84);
+          }
+          function st(ve, be) {
+            return [ve * G(1 - 3 * be * be / (E * E)), be];
+          }
+          st.invert = function(ve, be) {
+            return [ve / G(1 - 3 * be * be / (E * E)), be];
+          };
+          function Tt() {
+            return t.geoProjection(st).scale(152.63);
+          }
+          function Yt(ve, be) {
+            var Re = o(be), qe = o(ve) * Re, et = 1 - qe, Xe = o(ve = a(_(ve) * Re, -_(be))), it = _(ve);
+            return Re = G(1 - qe * qe), [it * Re - Xe * et, -Xe * Re - it * et];
+          }
+          Yt.invert = function(ve, be) {
+            var Re = (ve * ve + be * be) / -2, qe = G(-Re * (2 + Re)), et = be * Re + ve * qe, Xe = ve * Re - be * qe, it = G(Xe * Xe + et * et);
+            return [a(qe * et, it * (1 + Re)), it ? -O(qe * Xe / it) : 0];
+          };
+          function Kt() {
+            return t.geoProjection(Yt).rotate([0, -90, 45]).scale(124.75).clipAngle(180 - 1e-3);
+          }
+          function xr(ve, be) {
+            var Re = Ce(ve, be);
+            return [(Re[0] + ve / T) / 2, (Re[1] + be) / 2];
+          }
+          xr.invert = function(ve, be) {
+            var Re = ve, qe = be, et = 25;
+            do {
+              var Xe = o(qe), it = _(qe), Ft = _(2 * qe), Ht = it * it, tr = Xe * Xe, dr = _(Re), Sr = o(Re / 2), Or = _(Re / 2), Wr = Or * Or, ni = 1 - tr * Sr * Sr, Pi = ni ? U(Xe * Sr) * G(cn = 1 / ni) : cn = 0, cn, ln = 0.5 * (2 * Pi * Xe * Or + Re / T) - ve, Cn = 0.5 * (Pi * it + qe) - be, Kn = 0.5 * cn * (tr * Wr + Pi * Xe * Sr * Ht) + 0.5 / T, Aa = cn * (dr * Ft / 4 - Pi * it * Or), fa = 0.125 * cn * (Ft * Or - Pi * it * tr * dr), $a = 0.5 * cn * (Ht * Sr + Pi * Wr * Xe) + 0.5, Co = Aa * fa - $a * Kn, Qa = (Cn * Aa - ln * $a) / Co, mo = (ln * fa - Cn * Kn) / Co;
+              Re -= Qa, qe -= mo;
+            } while ((n(Qa) > p || n(mo) > p) && --et > 0);
+            return [Re, qe];
+          };
+          function Ir() {
+            return t.geoProjection(xr).scale(158.837);
+          }
+          e.geoNaturalEarth = t.geoNaturalEarth1, e.geoNaturalEarthRaw = t.geoNaturalEarth1Raw, e.geoAiry = _e, e.geoAiryRaw = oe, e.geoAitoff = Le, e.geoAitoffRaw = Ce, e.geoArmadillo = ie, e.geoArmadilloRaw = ge, e.geoAugust = Ee, e.geoAugustRaw = Se, e.geoBaker = me, e.geoBakerRaw = Pe, e.geoBerghaus = ce, e.geoBerghausRaw = De, e.geoBertin1953 = Wt, e.geoBertin1953Raw = ut, e.geoBoggs = Qt, e.geoBoggsRaw = St, e.geoBonne = er, e.geoBonneRaw = mt, e.geoBottomley = wr, e.geoBottomleyRaw = lr, e.geoBromley = ti, e.geoBromleyRaw = Lr, e.geoChamberlin = tt, e.geoChamberlinRaw = Ge, e.geoChamberlinAfrica = We, e.geoCollignon = Ie, e.geoCollignonRaw = xt, e.geoCraig = ke, e.geoCraigRaw = xe, e.geoCraster = ar, e.geoCrasterRaw = ir, e.geoCylindricalEqualArea = ii, e.geoCylindricalEqualAreaRaw = vr, e.geoCylindricalStereographic = $r, e.geoCylindricalStereographicRaw = pi, e.geoEckert1 = ji, e.geoEckert1Raw = di, e.geoEckert2 = wi, e.geoEckert2Raw = In, e.geoEckert3 = qn, e.geoEckert3Raw = On, e.geoEckert4 = ra, e.geoEckert4Raw = Fn, e.geoEckert5 = Ut, e.geoEckert5Raw = la, e.geoEckert6 = rr, e.geoEckert6Raw = wt, e.geoEisenlohr = Xr, e.geoEisenlohrRaw = Er, e.geoFahey = Oi, e.geoFaheyRaw = Qr, e.geoFoucaut = tn, e.geoFoucautRaw = $i, e.geoFoucautSinusoidal = yn, e.geoFoucautSinusoidalRaw = fn, e.geoGilbert = ua, e.geoGingery = Xo, e.geoGingeryRaw = ma, e.geoGinzburg4 = Ha, e.geoGinzburg4Raw = Wn, e.geoGinzburg5 = jn, e.geoGinzburg5Raw = vo, e.geoGinzburg6 = kr, e.geoGinzburg6Raw = Mt, e.geoGinzburg8 = vi, e.geoGinzburg8Raw = Jr, e.geoGinzburg9 = An, e.geoGinzburg9Raw = hn, e.geoGringorten = $n, e.geoGringortenRaw = Li, e.geoGuyou = Fs, e.geoGuyouRaw = Lo, e.geoHammer = pt, e.geoHammerRaw = je, e.geoHammerRetroazimuthal = zl, e.geoHammerRetroazimuthalRaw = ll, e.geoHealpix = Yl, e.geoHealpixRaw = cl, e.geoHill = nc, e.geoHillRaw = Su, e.geoHomolosine = xo, e.geoHomolosineRaw = Ol, e.geoHufnagel = Ns, e.geoHufnagelRaw = Kl, e.geoHyperelliptical = Oo, e.geoHyperellipticalRaw = aa, e.geoInterrupt = Do, e.geoInterruptedBoggs = Vf, e.geoInterruptedHomolosine = Zc, e.geoInterruptedMollweide = Os, e.geoInterruptedMollweideHemispheres = oc, e.geoInterruptedSinuMollweide = sc, e.geoInterruptedSinusoidal = Lf, e.geoKavrayskiy7 = nf, e.geoKavrayskiy7Raw = cs, e.geoLagrange = $l, e.geoLagrangeRaw = Gf, e.geoLarrivee = Fu, e.geoLarriveeRaw = lc, e.geoLaskowski = Hs, e.geoLaskowskiRaw = Es, e.geoLittrow = ps, e.geoLittrowRaw = Go, e.geoLoximuthal = xl, e.geoLoximuthalRaw = uc, e.geoMiller = qs, e.geoMillerRaw = Gu, e.geoModifiedStereographic = Bl, e.geoModifiedStereographicRaw = od, e.geoModifiedStereographicAlaska = Hu, e.geoModifiedStereographicGs48 = bl, e.geoModifiedStereographicGs50 = Hf, e.geoModifiedStereographicMiller = Ic, e.geoModifiedStereographicLee = yf, e.geoMollweide = Tr, e.geoMollweideRaw = sr, e.geoMtFlatPolarParabolic = Yc, e.geoMtFlatPolarParabolicRaw = _f, e.geoMtFlatPolarQuartic = th, e.geoMtFlatPolarQuarticRaw = eh, e.geoMtFlatPolarSinusoidal = jf, e.geoMtFlatPolarSinusoidalRaw = ju, e.geoNaturalEarth2 = of, e.geoNaturalEarth2Raw = cc, e.geoNellHammer = Kc, e.geoNellHammerRaw = Nl, e.geoInterruptedQuarticAuthalic = gs, e.geoNicolosi = Wh, e.geoNicolosiRaw = Wf, e.geoPatterson = hu, e.geoPattersonRaw = bc, e.geoPolyconic = nl, e.geoPolyconicRaw = _u, e.geoPolyhedral = xf, e.geoPolyhedralButterfly = Cs, e.geoPolyhedralCollignon = Xf, e.geoPolyhedralWaterman = Us, e.geoProject = Wl, e.geoGringortenQuincuncial = At, e.geoPeirceQuincuncial = Xt, e.geoPierceQuincuncial = Xt, e.geoQuantize = Cr, e.geoQuincuncial = Bc, e.geoRectangularPolyconic = Kr, e.geoRectangularPolyconicRaw = Ar, e.geoRobinson = dn, e.geoRobinsonRaw = Xi, e.geoSatellite = Yi, e.geoSatelliteRaw = Nn, e.geoSinuMollweide = Vu, e.geoSinuMollweideRaw = _a, e.geoSinusoidal = It, e.geoSinusoidalRaw = _t, e.geoStitch = Ls, e.geoTimes = no, e.geoTimesRaw = va, e.geoTwoPointAzimuthal = Cu, e.geoTwoPointAzimuthalRaw = rs, e.geoTwoPointAzimuthalUsa = Ql, e.geoTwoPointEquidistant = pu, e.geoTwoPointEquidistantRaw = Yu, e.geoTwoPointEquidistantUsa = Nc, e.geoVanDerGrinten = xu, e.geoVanDerGrintenRaw = Uc, e.geoVanDerGrinten2 = Ua, e.geoVanDerGrinten2Raw = Ac, e.geoVanDerGrinten3 = Vc, e.geoVanDerGrinten3Raw = oo, e.geoVanDerGrinten4 = Ku, e.geoVanDerGrinten4Raw = hc, e.geoWagner = B, e.geoWagner7 = Q, e.geoWagnerRaw = w, e.geoWagner4 = Ze, e.geoWagner4Raw = Oe, e.geoWagner6 = Tt, e.geoWagner6Raw = st, e.geoWiechel = Kt, e.geoWiechelRaw = Yt, e.geoWinkel3 = Ir, e.geoWinkel3Raw = xr, Object.defineProperty(e, "__esModule", { value: true });
+        });
+      });
+      var GDe = ye((Imr, VDe) => {
+        var nd = Oa(), UZ = Dr(), Ozt = qa(), r5 = Math.PI / 180, tw = 180 / Math.PI, GZ = { cursor: "pointer" }, HZ = { cursor: "auto" };
+        function qzt(e, t) {
+          var r = e.projection, n;
+          return t._isScoped ? n = Bzt : t._isClipped ? n = Uzt : n = Nzt, n(e, r);
+        }
+        VDe.exports = qzt;
+        function jZ(e, t) {
+          return nd.behavior.zoom().translate(t.translate()).scale(t.scale());
+        }
+        function WZ(e, t, r) {
+          var n = e.id, i = e.graphDiv, a = i.layout, o = a[n], s = i._fullLayout, l = s[n], u = {}, c = {};
+          function f(h, d) {
+            u[n + "." + h] = UZ.nestedProperty(o, h).get(), Ozt.call("_storeDirectGUIEdit", a, s._preGUI, u);
+            var v = UZ.nestedProperty(l, h);
+            v.get() !== d && (v.set(d), UZ.nestedProperty(o, h).set(d), c[n + "." + h] = d);
+          }
+          r(f), f("projection.scale", t.scale() / e.fitScale), f("fitbounds", false), i.emit("plotly_relayout", c);
+        }
+        function Bzt(e, t) {
+          var r = jZ(e, t);
+          function n() {
+            nd.select(this).style(GZ);
+          }
+          function i() {
+            t.scale(nd.event.scale).translate(nd.event.translate), e.render(true);
+            var s = t.invert(e.midPt);
+            e.graphDiv.emit("plotly_relayouting", { "geo.projection.scale": t.scale() / e.fitScale, "geo.center.lon": s[0], "geo.center.lat": s[1] });
+          }
+          function a(s) {
+            var l = t.invert(e.midPt);
+            s("center.lon", l[0]), s("center.lat", l[1]);
+          }
+          function o() {
+            nd.select(this).style(HZ), WZ(e, t, a);
+          }
+          return r.on("zoomstart", n).on("zoom", i).on("zoomend", o), r;
+        }
+        function Nzt(e, t) {
+          var r = jZ(e, t), n = 2, i, a, o, s, l, u, c, f, h;
+          function d(E) {
+            return t.invert(E);
+          }
+          function v(E) {
+            var T = d(E);
+            if (!T) return true;
+            var L = t(T);
+            return Math.abs(L[0] - E[0]) > n || Math.abs(L[1] - E[1]) > n;
+          }
+          function _() {
+            nd.select(this).style(GZ), i = nd.mouse(this), a = t.rotate(), o = t.translate(), s = a, l = d(i);
+          }
+          function b() {
+            if (u = nd.mouse(this), v(i)) {
+              r.scale(t.scale()), r.translate(t.translate());
+              return;
+            }
+            t.scale(nd.event.scale), t.translate([o[0], nd.event.translate[1]]), l ? d(u) && (f = d(u), c = [s[0] + (f[0] - l[0]), a[1], a[2]], t.rotate(c), s = c) : (i = u, l = d(i)), h = true, e.render(true);
+            var E = t.rotate(), T = t.invert(e.midPt);
+            e.graphDiv.emit("plotly_relayouting", { "geo.projection.scale": t.scale() / e.fitScale, "geo.center.lon": T[0], "geo.center.lat": T[1], "geo.projection.rotation.lon": -E[0] });
+          }
+          function p() {
+            nd.select(this).style(HZ), h && WZ(e, t, k);
+          }
+          function k(E) {
+            var T = t.rotate(), L = t.invert(e.midPt);
+            E("projection.rotation.lon", -T[0]), E("center.lon", L[0]), E("center.lat", L[1]);
+          }
+          return r.on("zoomstart", _).on("zoom", b).on("zoomend", p), r;
+        }
+        function Uzt(e, t) {
+          ({ r: t.rotate(), k: t.scale() });
+          var n = jZ(e, t), i = Yzt(n, "zoomstart", "zoom", "zoomend"), a = 0, o = n.on, s;
+          n.on("zoomstart", function() {
+            nd.select(this).style(GZ);
+            var h = nd.mouse(this), d = t.rotate(), v = d, _ = t.translate(), b = Vzt(d);
+            s = zF(t, h), o.call(n, "zoom", function() {
+              var p = nd.mouse(this);
+              if (t.scale(nd.event.scale), !s) h = p, s = zF(t, h);
+              else if (zF(t, p)) {
+                t.rotate(d).translate(_);
+                var k = zF(t, p), E = Hzt(s, k), T = Wzt(Gzt(b, E)), L = jzt(T, s, v);
+                (!isFinite(L[0]) || !isFinite(L[1]) || !isFinite(L[2])) && (L = v), t.rotate(L), v = L;
+              }
+              u(i.of(this, arguments));
+            }), l(i.of(this, arguments));
+          }).on("zoomend", function() {
+            nd.select(this).style(HZ), o.call(n, "zoom", null), c(i.of(this, arguments)), WZ(e, t, f);
+          }).on("zoom.redraw", function() {
+            e.render(true);
+            var h = t.rotate();
+            e.graphDiv.emit("plotly_relayouting", { "geo.projection.scale": t.scale() / e.fitScale, "geo.projection.rotation.lon": -h[0], "geo.projection.rotation.lat": -h[1] });
+          });
+          function l(h) {
+            a++ || h({ type: "zoomstart" });
+          }
+          function u(h) {
+            h({ type: "zoom" });
+          }
+          function c(h) {
+            --a || h({ type: "zoomend" });
+          }
+          function f(h) {
+            var d = t.rotate();
+            h("projection.rotation.lon", -d[0]), h("projection.rotation.lat", -d[1]);
+          }
+          return nd.rebind(n, i, "on");
+        }
+        function zF(e, t) {
+          var r = e.invert(t);
+          return r && isFinite(r[0]) && isFinite(r[1]) && Xzt(r);
+        }
+        function Vzt(e) {
+          var t = 0.5 * e[0] * r5, r = 0.5 * e[1] * r5, n = 0.5 * e[2] * r5, i = Math.sin(t), a = Math.cos(t), o = Math.sin(r), s = Math.cos(r), l = Math.sin(n), u = Math.cos(n);
+          return [a * s * u + i * o * l, i * s * u - a * o * l, a * o * u + i * s * l, a * s * l - i * o * u];
+        }
+        function Gzt(e, t) {
+          var r = e[0], n = e[1], i = e[2], a = e[3], o = t[0], s = t[1], l = t[2], u = t[3];
+          return [r * o - n * s - i * l - a * u, r * s + n * o + i * u - a * l, r * l - n * u + i * o + a * s, r * u + n * l - i * s + a * o];
+        }
+        function Hzt(e, t) {
+          if (!(!e || !t)) {
+            var r = Zzt(e, t), n = Math.sqrt(UDe(r, r)), i = 0.5 * Math.acos(Math.max(-1, Math.min(1, UDe(e, t)))), a = Math.sin(i) / n;
+            return n && [Math.cos(i), r[2] * a, -r[1] * a, r[0] * a];
+          }
+        }
+        function jzt(e, t, r) {
+          var n = VZ(t, 2, e[0]);
+          n = VZ(n, 1, e[1]), n = VZ(n, 0, e[2] - r[2]);
+          var i = t[0], a = t[1], o = t[2], s = n[0], l = n[1], u = n[2], c = Math.atan2(a, i) * tw, f = Math.sqrt(i * i + a * a), h, d;
+          Math.abs(l) > f ? (d = (l > 0 ? 90 : -90) - c, h = 0) : (d = Math.asin(l / f) * tw - c, h = Math.sqrt(f * f - l * l));
+          var v = 180 - d - 2 * c, _ = (Math.atan2(u, s) - Math.atan2(o, h)) * tw, b = (Math.atan2(u, s) - Math.atan2(o, -h)) * tw, p = BDe(r[0], r[1], d, _), k = BDe(r[0], r[1], v, b);
+          return p <= k ? [d, _, r[2]] : [v, b, r[2]];
+        }
+        function BDe(e, t, r, n) {
+          var i = NDe(r - e), a = NDe(n - t);
+          return Math.sqrt(i * i + a * a);
+        }
+        function NDe(e) {
+          return (e % 360 + 540) % 360 - 180;
+        }
+        function VZ(e, t, r) {
+          var n = r * r5, i = e.slice(), a = t === 0 ? 1 : 0, o = t === 2 ? 1 : 2, s = Math.cos(n), l = Math.sin(n);
+          return i[a] = e[a] * s - e[o] * l, i[o] = e[o] * s + e[a] * l, i;
+        }
+        function Wzt(e) {
+          return [Math.atan2(2 * (e[0] * e[1] + e[2] * e[3]), 1 - 2 * (e[1] * e[1] + e[2] * e[2])) * tw, Math.asin(Math.max(-1, Math.min(1, 2 * (e[0] * e[2] - e[3] * e[1])))) * tw, Math.atan2(2 * (e[0] * e[3] + e[1] * e[2]), 1 - 2 * (e[2] * e[2] + e[3] * e[3])) * tw];
+        }
+        function Xzt(e) {
+          var t = e[0] * r5, r = e[1] * r5, n = Math.cos(r);
+          return [n * Math.cos(t), n * Math.sin(t), Math.sin(r)];
+        }
+        function UDe(e, t) {
+          for (var r = 0, n = 0, i = e.length; n < i; ++n) r += e[n] * t[n];
+          return r;
+        }
+        function Zzt(e, t) {
+          return [e[1] * t[2] - e[2] * t[1], e[2] * t[0] - e[0] * t[2], e[0] * t[1] - e[1] * t[0]];
+        }
+        function Yzt(e) {
+          for (var t = 0, r = arguments.length, n = []; ++t < r; ) n.push(arguments[t]);
+          var i = nd.dispatch.apply(null, n);
+          return i.of = function(a, o) {
+            return function(s) {
+              var l;
+              try {
+                l = s.sourceEvent = nd.event, s.target = e, nd.event = s, i[s.type].apply(a, o);
+              } finally {
+                nd.event = l;
+              }
+            };
+          }, i;
+        }
+      });
+      var KDe = ye((Rmr, YDe) => {
+        var l1 = Oa(), YZ = NZ(), Kzt = YZ.geoPath, Jzt = YZ.geoDistance, $zt = qDe(), Qzt = qa(), vk = Dr(), e7t = vk.strTranslate, OF = ka(), dk = So(), HDe = vf(), t7t = Mc(), ZZ = ho(), jDe = Mg().getAutoRange, XZ = yv(), r7t = Of().prepSelect, i7t = Of().clearOutline, n7t = Of().selectOnClick, a7t = GDe(), hp = uk(), o7t = hx(), XDe = bF(), s7t = SZ().feature;
+        function ZDe(e) {
+          this.id = e.id, this.graphDiv = e.graphDiv, this.container = e.container, this.topojsonURL = e.topojsonURL, this.isStatic = e.staticPlot, this.topojsonName = null, this.topojson = null, this.projection = null, this.scope = null, this.viewInitial = null, this.fitScale = null, this.bounds = null, this.midPt = null, this.hasChoropleth = false, this.traceHash = {}, this.layers = {}, this.basePaths = {}, this.dataPaths = {}, this.dataPoints = {}, this.clipDef = null, this.clipRect = null, this.bgRect = null, this.makeFramework();
+        }
+        var tm = ZDe.prototype;
+        YDe.exports = function(t) {
+          return new ZDe(t);
+        };
+        tm.plot = function(e, t, r, n) {
+          var i = this;
+          if (n) return i.update(e, t, true);
+          i._geoCalcData = e, i._fullLayout = t;
+          var a = t[this.id], o = [], s = false;
+          for (var l in hp.layerNameToAdjective) if (l !== "frame" && a["show" + l]) {
+            s = true;
+            break;
+          }
+          for (var u = false, c = 0; c < e.length; c++) {
+            var f = e[0][0].trace;
+            f._geo = i, f.locationmode && (s = true);
+            var h = f.marker;
+            if (h) {
+              var d = h.angle, v = h.angleref;
+              (d || v === "north" || v === "previous") && (u = true);
+            }
+          }
+          if (this._hasMarkerAngles = u, s) {
+            var _ = XDe.getTopojsonName(a);
+            (i.topojson === null || _ !== i.topojsonName) && (i.topojsonName = _, PlotlyGeoAssets.topojson[i.topojsonName] === void 0 && o.push(i.fetchTopojson()));
+          }
+          o = o.concat(o7t.fetchTraceGeoData(e)), r.push(new Promise(function(b, p) {
+            Promise.all(o).then(function() {
+              i.topojson = PlotlyGeoAssets.topojson[i.topojsonName], i.update(e, t), b();
+            }).catch(p);
+          }));
+        };
+        tm.fetchTopojson = function() {
+          var e = this, t = XDe.getTopojsonPath(e.topojsonURL, e.topojsonName);
+          return new Promise(function(r, n) {
+            l1.json(t, function(i, a) {
+              if (i) return i.status === 404 ? n(new Error(["plotly.js could not find topojson file at", t + ".", "Make sure the *topojsonURL* plot config option", "is set properly."].join(" "))) : n(new Error(["unexpected error while fetching topojson file at", t].join(" ")));
+              PlotlyGeoAssets.topojson[e.topojsonName] = a, r();
+            });
+          });
+        };
+        tm.update = function(e, t, r) {
+          var n = t[this.id];
+          this.hasChoropleth = false;
+          for (var i = 0; i < e.length; i++) {
+            var a = e[i], o = a[0].trace;
+            o.type === "choropleth" && (this.hasChoropleth = true), o.visible === true && o._length > 0 && o._module.calcGeoJSON(a, t);
+          }
+          if (!r) {
+            var s = this.updateProjection(e, t);
+            if (s) return;
+            (!this.viewInitial || this.scope !== n.scope) && this.saveViewInitial(n);
+          }
+          this.scope = n.scope, this.updateBaseLayers(t, n), this.updateDims(t, n), this.updateFx(t, n), t7t.generalUpdatePerTraceModule(this.graphDiv, this, e, n);
+          var l = this.layers.frontplot.select(".scatterlayer");
+          this.dataPoints.point = l.selectAll(".point"), this.dataPoints.text = l.selectAll("text"), this.dataPaths.line = l.selectAll(".js-line");
+          var u = this.layers.backplot.select(".choroplethlayer");
+          this.dataPaths.choropleth = u.selectAll("path"), this._render();
+        };
+        tm.updateProjection = function(e, t) {
+          var r = this.graphDiv, n = t[this.id], i = t._size, a = n.domain, o = n.projection, s = n.lonaxis, l = n.lataxis, u = s._ax, c = l._ax, f = this.projection = l7t(n), h = [[i.l + i.w * a.x[0], i.t + i.h * (1 - a.y[1])], [i.l + i.w * a.x[1], i.t + i.h * (1 - a.y[0])]], d = n.center || {}, v = o.rotation || {}, _ = s.range || [], b = l.range || [];
+          if (n.fitbounds) {
+            u._length = h[1][0] - h[0][0], c._length = h[1][1] - h[0][1], u.range = jDe(r, u), c.range = jDe(r, c);
+            var p = (u.range[0] + u.range[1]) / 2, k = (c.range[0] + c.range[1]) / 2;
+            if (n._isScoped) d = { lon: p, lat: k };
+            else if (n._isClipped) {
+              d = { lon: p, lat: k }, v = { lon: p, lat: k, roll: v.roll };
+              var E = o.type, T = hp.lonaxisSpan[E] / 2 || 180, L = hp.lataxisSpan[E] / 2 || 90;
+              _ = [p - T, p + T], b = [k - L, k + L];
+            } else d = { lon: p, lat: k }, v = { lon: p, lat: v.lat, roll: v.roll };
+          }
+          f.center([d.lon - v.lon, d.lat - v.lat]).rotate([-v.lon, -v.lat, v.roll]).parallels(o.parallels);
+          var x = WDe(_, b);
+          f.fitExtent(h, x);
+          var C = this.bounds = f.getBounds(x), M = this.fitScale = f.scale(), g = f.translate();
+          if (n.fitbounds) {
+            var P = f.getBounds(WDe(u.range, c.range)), A = Math.min((C[1][0] - C[0][0]) / (P[1][0] - P[0][0]), (C[1][1] - C[0][1]) / (P[1][1] - P[0][1]));
+            isFinite(A) ? f.scale(A * M) : vk.warn("Something went wrong during" + this.id + "fitbounds computations.");
+          } else f.scale(o.scale * M);
+          var z = this.midPt = [(C[0][0] + C[1][0]) / 2, (C[0][1] + C[1][1]) / 2];
+          if (f.translate([g[0] + (z[0] - g[0]), g[1] + (z[1] - g[1])]).clipExtent(C), n._isAlbersUsa) {
+            var O = f([d.lon, d.lat]), U = f.translate();
+            f.translate([U[0] - (O[0] - U[0]), U[1] - (O[1] - U[1])]);
+          }
+        };
+        tm.updateBaseLayers = function(e, t) {
+          var r = this, n = r.topojson, i = r.layers, a = r.basePaths;
+          function o(h) {
+            return h === "lonaxis" || h === "lataxis";
+          }
+          function s(h) {
+            return !!hp.lineLayers[h];
+          }
+          function l(h) {
+            return !!hp.fillLayers[h];
+          }
+          var u = this.hasChoropleth ? hp.layersForChoropleth : hp.layers, c = u.filter(function(h) {
+            return s(h) || l(h) ? t["show" + h] : o(h) ? t[h].showgrid : true;
+          }), f = r.framework.selectAll(".layer").data(c, String);
+          f.exit().each(function(h) {
+            delete i[h], delete a[h], l1.select(this).remove();
+          }), f.enter().append("g").attr("class", function(h) {
+            return "layer " + h;
+          }).each(function(h) {
+            var d = i[h] = l1.select(this);
+            h === "bg" ? r.bgRect = d.append("rect").style("pointer-events", "all") : o(h) ? a[h] = d.append("path").style("fill", "none") : h === "backplot" ? d.append("g").classed("choroplethlayer", true) : h === "frontplot" ? d.append("g").classed("scatterlayer", true) : s(h) ? a[h] = d.append("path").style("fill", "none").style("stroke-miterlimit", 2) : l(h) && (a[h] = d.append("path").style("stroke", "none"));
+          }), f.order(), f.each(function(h) {
+            var d = a[h], v = hp.layerNameToAdjective[h];
+            h === "frame" ? d.datum(hp.sphereSVG) : s(h) || l(h) ? d.datum(s7t(n, n.objects[h])) : o(h) && d.datum(u7t(h, t, e)).call(OF.stroke, t[h].gridcolor).call(dk.dashLine, t[h].griddash, t[h].gridwidth), s(h) ? d.call(OF.stroke, t[v + "color"]).call(dk.dashLine, "", t[v + "width"]) : l(h) && d.call(OF.fill, t[v + "color"]);
+          });
+        };
+        tm.updateDims = function(e, t) {
+          var r = this.bounds, n = (t.framewidth || 0) / 2, i = r[0][0] - n, a = r[0][1] - n, o = r[1][0] - i + n, s = r[1][1] - a + n;
+          dk.setRect(this.clipRect, i, a, o, s), this.bgRect.call(dk.setRect, i, a, o, s).call(OF.fill, t.bgcolor), this.xaxis._offset = i, this.xaxis._length = o, this.yaxis._offset = a, this.yaxis._length = s;
+        };
+        tm.updateFx = function(e, t) {
+          var r = this, n = r.graphDiv, i = r.bgRect, a = e.dragmode, o = e.clickmode;
+          if (r.isStatic) return;
+          function s() {
+            var f = r.viewInitial, h = {};
+            for (var d in f) h[r.id + "." + d] = f[d];
+            Qzt.call("_guiRelayout", n, h), n.emit("plotly_doubleclick", null);
+          }
+          function l(f) {
+            return r.projection.invert([f[0] + r.xaxis._offset, f[1] + r.yaxis._offset]);
+          }
+          var u = function(f, h) {
+            if (h.isRect) {
+              var d = f.range = {};
+              d[r.id] = [l([h.xmin, h.ymin]), l([h.xmax, h.ymax])];
+            } else {
+              var v = f.lassoPoints = {};
+              v[r.id] = h.map(l);
+            }
+          }, c = { element: r.bgRect.node(), gd: n, plotinfo: { id: r.id, xaxis: r.xaxis, yaxis: r.yaxis, fillRangeItems: u }, xaxes: [r.xaxis], yaxes: [r.yaxis], subplot: r.id, clickFn: function(f) {
+            f === 2 && i7t(n);
+          } };
+          a === "pan" ? (i.node().onmousedown = null, i.call(a7t(r, t)), i.on("dblclick.zoom", s), n._context._scrollZoom.geo || i.on("wheel.zoom", null)) : (a === "select" || a === "lasso") && (i.on(".zoom", null), c.prepFn = function(f, h, d) {
+            r7t(f, h, d, c, a);
+          }, XZ.init(c)), i.on("mousemove", function() {
+            var f = r.projection.invert(vk.getPositionFromD3Event());
+            if (!f) return XZ.unhover(n, l1.event);
+            r.xaxis.p2c = function() {
+              return f[0];
+            }, r.yaxis.p2c = function() {
+              return f[1];
+            }, HDe.hover(n, l1.event, r.id);
+          }), i.on("mouseout", function() {
+            n._dragging || XZ.unhover(n, l1.event);
+          }), i.on("click", function() {
+            a !== "select" && a !== "lasso" && (o.indexOf("select") > -1 && n7t(l1.event, n, [r.xaxis], [r.yaxis], r.id, c), o.indexOf("event") > -1 && HDe.click(n, l1.event));
+          });
+        };
+        tm.makeFramework = function() {
+          var e = this, t = e.graphDiv, r = t._fullLayout, n = "clip" + r._uid + e.id;
+          e.clipDef = r._clips.append("clipPath").attr("id", n), e.clipRect = e.clipDef.append("rect"), e.framework = l1.select(e.container).append("g").attr("class", "geo " + e.id).call(dk.setClipUrl, n, t), e.project = function(i) {
+            var a = e.projection(i);
+            return a ? [a[0] - e.xaxis._offset, a[1] - e.yaxis._offset] : [null, null];
+          }, e.xaxis = { _id: "x", c2p: function(i) {
+            return e.project(i)[0];
+          } }, e.yaxis = { _id: "y", c2p: function(i) {
+            return e.project(i)[1];
+          } }, e.mockAxis = { type: "linear", showexponent: "all", exponentformat: "B" }, ZZ.setConvert(e.mockAxis, r);
+        };
+        tm.saveViewInitial = function(e) {
+          var t = e.center || {}, r = e.projection, n = r.rotation || {};
+          this.viewInitial = { fitbounds: e.fitbounds, "projection.scale": r.scale };
+          var i;
+          e._isScoped ? i = { "center.lon": t.lon, "center.lat": t.lat } : e._isClipped ? i = { "projection.rotation.lon": n.lon, "projection.rotation.lat": n.lat } : i = { "center.lon": t.lon, "center.lat": t.lat, "projection.rotation.lon": n.lon }, vk.extendFlat(this.viewInitial, i);
+        };
+        tm.render = function(e) {
+          this._hasMarkerAngles && e ? this.plot(this._geoCalcData, this._fullLayout, [], true) : this._render();
+        };
+        tm._render = function() {
+          var e = this.projection, t = e.getPath(), r;
+          function n(a) {
+            var o = e(a.lonlat);
+            return o ? e7t(o[0], o[1]) : null;
+          }
+          function i(a) {
+            return e.isLonLatOverEdges(a.lonlat) ? "none" : null;
+          }
+          for (r in this.basePaths) this.basePaths[r].attr("d", t);
+          for (r in this.dataPaths) this.dataPaths[r].attr("d", function(a) {
+            return t(a.geojson);
+          });
+          for (r in this.dataPoints) this.dataPoints[r].attr("display", i).attr("transform", n);
+        };
+        function l7t(e) {
+          var t = e.projection, r = t.type, n = hp.projNames[r];
+          n = "geo" + vk.titleCase(n);
+          for (var i = YZ[n] || $zt[n], a = i(), o = e._isSatellite ? Math.acos(1 / t.distance) * 180 / Math.PI : e._isClipped ? hp.lonaxisSpan[r] / 2 : null, s = ["center", "rotate", "parallels", "clipExtent"], l = function(f) {
+            return f ? a : [];
+          }, u = 0; u < s.length; u++) {
+            var c = s[u];
+            typeof a[c] != "function" && (a[c] = l);
+          }
+          return a.isLonLatOverEdges = function(f) {
+            if (a(f) === null) return true;
+            if (o) {
+              var h = a.rotate(), d = Jzt(f, [-h[0], -h[1]]), v = o * Math.PI / 180;
+              return d > v;
+            } else return false;
+          }, a.getPath = function() {
+            return Kzt().projection(a);
+          }, a.getBounds = function(f) {
+            return a.getPath().bounds(f);
+          }, a.precision(hp.precision), e._isSatellite && a.tilt(t.tilt).distance(t.distance), o && a.clipAngle(o - hp.clipPad), a;
+        }
+        function u7t(e, t, r) {
+          var n = 1e-6, i = 2.5, a = t[e], o = hp.scopeDefaults[t.scope], s, l, u;
+          e === "lonaxis" ? (s = o.lonaxisRange, l = o.lataxisRange, u = function(k, E) {
+            return [k, E];
+          }) : e === "lataxis" && (s = o.lataxisRange, l = o.lonaxisRange, u = function(k, E) {
+            return [E, k];
+          });
+          var c = { type: "linear", range: [s[0], s[1] - n], tick0: a.tick0, dtick: a.dtick };
+          ZZ.setConvert(c, r);
+          var f = ZZ.calcTicks(c);
+          !t.isScoped && e === "lonaxis" && f.pop();
+          for (var h = f.length, d = new Array(h), v = 0; v < h; v++) for (var _ = f[v].x, b = d[v] = [], p = l[0]; p < l[1] + i; p += i) b.push(u(_, p));
+          return { type: "MultiLineString", coordinates: d };
+        }
+        function WDe(e, t) {
+          var r = hp.clipPad, n = e[0] + r, i = e[1] - r, a = t[0] + r, o = t[1] - r;
+          n > 0 && i < 0 && (i += 360);
+          var s = (i - n) / 4;
+          return { type: "Polygon", coordinates: [[[n, a], [n, o], [n + s, o], [n + 2 * s, o], [n + 3 * s, o], [i, o], [i, a], [i - s, a], [i - 2 * s, a], [i - 3 * s, a], [n, a]]] };
+        }
+      });
+      var KZ = ye((Dmr, QDe) => {
+        var n5 = Ih(), c7t = Cc().attributes, f7t = Pd().dash, i5 = uk(), h7t = mc().overrideAll, JDe = t_(), $De = { range: { valType: "info_array", items: [{ valType: "number" }, { valType: "number" }] }, showgrid: { valType: "boolean", dflt: false }, tick0: { valType: "number", dflt: 0 }, dtick: { valType: "number" }, gridcolor: { valType: "color", dflt: n5.lightLine }, gridwidth: { valType: "number", min: 0, dflt: 1 }, griddash: f7t }, d7t = QDe.exports = h7t({ domain: c7t({ name: "geo" }, {}), fitbounds: { valType: "enumerated", values: [false, "locations", "geojson"], dflt: false, editType: "plot" }, resolution: { valType: "enumerated", values: [110, 50], dflt: 110, coerceNumber: true }, scope: { valType: "enumerated", values: JDe(i5.scopeDefaults), dflt: "world" }, projection: { type: { valType: "enumerated", values: JDe(i5.projNames) }, rotation: { lon: { valType: "number" }, lat: { valType: "number" }, roll: { valType: "number" } }, tilt: { valType: "number", dflt: 0 }, distance: { valType: "number", min: 1.001, dflt: 2 }, parallels: { valType: "info_array", items: [{ valType: "number" }, { valType: "number" }] }, scale: { valType: "number", min: 0, dflt: 1 } }, center: { lon: { valType: "number" }, lat: { valType: "number" } }, visible: { valType: "boolean", dflt: true }, showcoastlines: { valType: "boolean" }, coastlinecolor: { valType: "color", dflt: n5.defaultLine }, coastlinewidth: { valType: "number", min: 0, dflt: 1 }, showland: { valType: "boolean", dflt: false }, landcolor: { valType: "color", dflt: i5.landColor }, showocean: { valType: "boolean", dflt: false }, oceancolor: { valType: "color", dflt: i5.waterColor }, showlakes: { valType: "boolean", dflt: false }, lakecolor: { valType: "color", dflt: i5.waterColor }, showrivers: { valType: "boolean", dflt: false }, rivercolor: { valType: "color", dflt: i5.waterColor }, riverwidth: { valType: "number", min: 0, dflt: 1 }, showcountries: { valType: "boolean" }, countrycolor: { valType: "color", dflt: n5.defaultLine }, countrywidth: { valType: "number", min: 0, dflt: 1 }, showsubunits: { valType: "boolean" }, subunitcolor: { valType: "color", dflt: n5.defaultLine }, subunitwidth: { valType: "number", min: 0, dflt: 1 }, showframe: { valType: "boolean" }, framecolor: { valType: "color", dflt: n5.defaultLine }, framewidth: { valType: "number", min: 0, dflt: 1 }, bgcolor: { valType: "color", dflt: n5.background }, lonaxis: $De, lataxis: $De }, "plot", "from-root");
+        d7t.uirevision = { valType: "any", editType: "none" };
+      });
+      var rFe = ye((Fmr, tFe) => {
+        var qF = Dr(), v7t = O_(), p7t = Id().getSubplotData, BF = uk(), g7t = KZ(), eFe = BF.axesNames;
+        tFe.exports = function(t, r, n) {
+          v7t(t, r, n, { type: "geo", attributes: g7t, handleDefaults: m7t, fullData: n, partition: "y" });
+        };
+        function m7t(e, t, r, n) {
+          var i = p7t(n.fullData, "geo", n.id), a = i.map(function(oe) {
+            return oe.index;
+          }), o = r("resolution"), s = r("scope"), l = BF.scopeDefaults[s], u = r("projection.type", l.projType), c = t._isAlbersUsa = u === "albers usa";
+          c && (s = t.scope = "usa");
+          var f = t._isScoped = s !== "world", h = t._isSatellite = u === "satellite", d = t._isConic = u.indexOf("conic") !== -1 || u === "albers", v = t._isClipped = !!BF.lonaxisSpan[u];
+          if (e.visible === false) {
+            var _ = qF.extendDeep({}, t._template);
+            _.showcoastlines = false, _.showcountries = false, _.showframe = false, _.showlakes = false, _.showland = false, _.showocean = false, _.showrivers = false, _.showsubunits = false, _.lonaxis && (_.lonaxis.showgrid = false), _.lataxis && (_.lataxis.showgrid = false), t._template = _;
+          }
+          for (var b = r("visible"), p, k = 0; k < eFe.length; k++) {
+            var E = eFe[k], T = [30, 10][k], L;
+            if (f) L = l[E + "Range"];
+            else {
+              var x = BF[E + "Span"], C = (x[u] || x["*"]) / 2, M = r("projection.rotation." + E.slice(0, 3), l.projRotate[k]);
+              L = [M - C, M + C];
+            }
+            var g = r(E + ".range", L);
+            r(E + ".tick0"), r(E + ".dtick", T), p = r(E + ".showgrid", b ? void 0 : false), p && (r(E + ".gridcolor"), r(E + ".gridwidth"), r(E + ".griddash")), t[E]._ax = { type: "linear", _id: E.slice(0, 3), _traceIndices: a, setScale: qF.identity, c2l: qF.identity, r2l: qF.identity, autorange: true, range: g.slice(), _m: 1, _input: {} };
+          }
+          var P = t.lonaxis.range, A = t.lataxis.range, z = P[0], O = P[1];
+          z > 0 && O < 0 && (O += 360);
+          var U = (z + O) / 2, G;
+          if (!c) {
+            var Z = f ? l.projRotate : [U, 0, 0];
+            G = r("projection.rotation.lon", Z[0]), r("projection.rotation.lat", Z[1]), r("projection.rotation.roll", Z[2]), p = r("showcoastlines", !f && b), p && (r("coastlinecolor"), r("coastlinewidth")), p = r("showocean", b ? void 0 : false), p && r("oceancolor");
+          }
+          var j, N;
+          if (c ? (j = -96.6, N = 38.7) : (j = f ? U : G, N = (A[0] + A[1]) / 2), r("center.lon", j), r("center.lat", N), h && (r("projection.tilt"), r("projection.distance")), d) {
+            var H = l.projParallels || [0, 60];
+            r("projection.parallels", H);
+          }
+          r("projection.scale"), p = r("showland", b ? void 0 : false), p && r("landcolor"), p = r("showlakes", b ? void 0 : false), p && r("lakecolor"), p = r("showrivers", b ? void 0 : false), p && (r("rivercolor"), r("riverwidth")), p = r("showcountries", f && s !== "usa" && b), p && (r("countrycolor"), r("countrywidth")), (s === "usa" || s === "north america" && o === 50) && (r("showsubunits", b), r("subunitcolor"), r("subunitwidth")), f || (p = r("showframe", b), p && (r("framecolor"), r("framewidth"))), r("bgcolor");
+          var re = r("fitbounds");
+          re && (delete t.projection.scale, f ? (delete t.center.lon, delete t.center.lat) : v ? (delete t.center.lon, delete t.center.lat, delete t.projection.rotation.lon, delete t.projection.rotation.lat, delete t.lonaxis.range, delete t.lataxis.range) : (delete t.center.lon, delete t.center.lat, delete t.projection.rotation.lon));
+        }
+      });
+      var JZ = ye((zmr, aFe) => {
+        var y7t = Id().getSubplotCalcData, _7t = Dr().counterRegex, x7t = KDe(), Qm = "geo", iFe = _7t(Qm), nFe = {};
+        nFe[Qm] = { valType: "subplotid", dflt: Qm, editType: "calc" };
+        function b7t(e) {
+          for (var t = e._fullLayout, r = e.calcdata, n = t._subplots[Qm], i = 0; i < n.length; i++) {
+            var a = n[i], o = y7t(r, Qm, a), s = t[a], l = s._subplot;
+            l || (l = x7t({ id: a, graphDiv: e, container: t._geolayer.node(), topojsonURL: e._context.topojsonURL, staticPlot: e._context.staticPlot }), t[a]._subplot = l), l.plot(o, t, e._promises);
+          }
+        }
+        function w7t(e, t, r, n) {
+          for (var i = n._subplots[Qm] || [], a = 0; a < i.length; a++) {
+            var o = i[a], s = n[o]._subplot;
+            !t[o] && s && (s.framework.remove(), s.clipDef.remove());
+          }
+        }
+        function T7t(e) {
+          for (var t = e._fullLayout, r = t._subplots[Qm], n = 0; n < r.length; n++) {
+            var i = t[r[n]], a = i._subplot;
+            a.updateFx(t, i);
+          }
+        }
+        aFe.exports = { attr: Qm, name: Qm, idRoot: Qm, idRegex: iFe, attrRegex: iFe, attributes: nFe, layoutAttributes: KZ(), supplyLayoutDefaults: rFe(), plot: b7t, updateFx: T7t, clean: w7t };
+      });
+      var sFe = ye((Omr, oFe) => {
+        oFe.exports = { attributes: ew(), supplyDefaults: URe(), colorbar: $d(), formatLabels: HRe(), calc: _F(), calcGeoJSON: BZ().calcGeoJSON, plot: BZ().plot, style: FZ(), styleOnSelect: sp().styleOnSelect, hoverPoints: CDe(), eventData: PDe(), selectPoints: DDe(), moduleType: "trace", name: "scattergeo", basePlotModule: JZ(), categories: ["geo", "symbols", "showLegend", "scatter-like"], meta: {} };
+      });
+      var uFe = ye((qmr, lFe) => {
+        lFe.exports = sFe();
+      });
+      var a5 = ye((Bmr, hFe) => {
+        var { hovertemplateAttrs: A7t, templatefallbackAttrs: S7t } = Ll(), vx = ew(), M7t = Tu(), cFe = Gl(), E7t = Ih().defaultLine, dx = Ao().extendFlat, fFe = vx.marker.line;
+        hFe.exports = dx({ locations: { valType: "data_array", editType: "calc" }, locationmode: vx.locationmode, z: { valType: "data_array", editType: "calc" }, geojson: dx({}, vx.geojson, {}), featureidkey: vx.featureidkey, text: dx({}, vx.text, {}), hovertext: dx({}, vx.hovertext, {}), marker: { line: { color: dx({}, fFe.color, { dflt: E7t }), width: dx({}, fFe.width, { dflt: 1 }), editType: "calc" }, opacity: { valType: "number", arrayOk: true, min: 0, max: 1, dflt: 1, editType: "style" }, editType: "calc" }, selected: { marker: { opacity: vx.selected.marker.opacity, editType: "plot" }, editType: "plot" }, unselected: { marker: { opacity: vx.unselected.marker.opacity, editType: "plot" }, editType: "plot" }, hoverinfo: dx({}, cFe.hoverinfo, { editType: "calc", flags: ["location", "z", "text", "name"] }), hovertemplate: A7t(), hovertemplatefallback: S7t(), showlegend: dx({}, cFe.showlegend, { dflt: false }) }, M7t("", { cLetter: "z", editTypeOverride: "calc" }));
+      });
+      var vFe = ye((Nmr, dFe) => {
+        var pk = Dr(), k7t = td(), C7t = a5(), L7t = ["The library used by the *country names* `locationmode` option is changing in the next major version.", "Some country names in existing plots may not work in the new version.", "To ensure consistent behavior, consider setting `locationmode` to *ISO-3*."].join(" ");
+        dFe.exports = function(t, r, n, i) {
+          function a(h, d) {
+            return pk.coerce(t, r, C7t, h, d);
+          }
+          var o = a("locations"), s = a("z");
+          if (!(o && o.length && pk.isArrayOrTypedArray(s) && s.length)) {
+            r.visible = false;
+            return;
+          }
+          r._length = Math.min(o.length, s.length);
+          var l = a("geojson"), u;
+          (typeof l == "string" && l !== "" || pk.isPlainObject(l)) && (u = "geojson-id");
+          var c = a("locationmode", u);
+          c === "country names" && pk.warn(L7t), c === "geojson-id" && a("featureidkey"), a("text"), a("hovertext"), a("hovertemplate"), a("hovertemplatefallback");
+          var f = a("marker.line.width");
+          f && a("marker.line.color"), a("marker.opacity"), k7t(t, r, i, a, { prefix: "", cLetter: "z" }), pk.coerceSelectionMarkerOpacity(r, a);
+        };
+      });
+      var NF = ye((Umr, mFe) => {
+        var pFe = Eo(), P7t = fs().BADNUM, I7t = gv(), R7t = Rm(), D7t = O0();
+        function gFe(e) {
+          return e && typeof e == "string";
+        }
+        mFe.exports = function(t, r) {
+          var n = r._length, i = new Array(n), a;
+          r.geojson ? a = function(c) {
+            return gFe(c) || pFe(c);
+          } : a = gFe;
+          for (var o = 0; o < n; o++) {
+            var s = i[o] = {}, l = r.locations[o], u = r.z[o];
+            a(l) && pFe(u) ? (s.loc = l, s.z = u) : (s.loc = null, s.z = P7t), s.index = o;
+          }
+          return R7t(i, r), I7t(t, r, { vals: r.z, containerStr: "", cLetter: "z" }), D7t(i, r), i;
+        };
+      });
+      var UF = ye((Vmr, _Fe) => {
+        var F7t = Oa(), z7t = ka(), $Z = So(), O7t = tc();
+        function q7t(e, t) {
+          t && yFe(e, t);
+        }
+        function yFe(e, t) {
+          var r = t[0].trace, n = t[0].node3, i = n.selectAll(".choroplethlocation"), a = r.marker || {}, o = a.line || {}, s = O7t.makeColorScaleFuncFromTrace(r);
+          i.each(function(l) {
+            F7t.select(this).attr("fill", s(l.z)).call(z7t.stroke, l.mlc || o.color).call($Z.dashLine, "", l.mlw || o.width || 0).style("opacity", a.opacity);
+          }), $Z.selectedPointStyle(i, r);
+        }
+        function B7t(e, t) {
+          var r = t[0].node3, n = t[0].trace;
+          n.selectedpoints ? $Z.selectedPointStyle(r.selectAll(".choroplethlocation"), n) : yFe(e, t);
+        }
+        _Fe.exports = { style: q7t, styleOnSelect: B7t };
+      });
+      var QZ = ye((Gmr, wFe) => {
+        var N7t = Oa(), xFe = Dr(), o5 = hx(), U7t = bF().getTopojsonFeatures, bFe = Mg().findExtremes, V7t = UF().style;
+        function G7t(e, t, r) {
+          var n = t.layers.backplot.select(".choroplethlayer");
+          xFe.makeTraceGroups(n, r, "trace choropleth").each(function(i) {
+            var a = N7t.select(this), o = a.selectAll("path.choroplethlocation").data(xFe.identity);
+            o.enter().append("path").classed("choroplethlocation", true), o.exit().remove(), V7t(e, i);
+          });
+        }
+        function H7t(e, t) {
+          for (var r = e[0].trace, n = t[r.geo], i = n._subplot, a = r.locationmode, o = r._length, s = a === "geojson-id" ? o5.extractTraceFeature(e) : U7t(r, i.topojson), l = [], u = [], c = 0; c < o; c++) {
+            var f = e[c], h = a === "geojson-id" ? f.fOut : o5.locationToFeature(a, f.loc, s);
+            if (h) {
+              f.geojson = h, f.ct = h.properties.ct, f._polygons = o5.feature2polygons(h);
+              var d = o5.computeBbox(h);
+              l.push(d[0], d[2]), u.push(d[1], d[3]);
+            } else f.geojson = null;
+          }
+          if (n.fitbounds === "geojson" && a === "geojson-id") {
+            var v = o5.computeBbox(o5.getTraceGeojson(r));
+            l = [v[0], v[2]], u = [v[1], v[3]];
+          }
+          var _ = { padded: true };
+          r._extremes.lon = bFe(n.lonaxis._ax, l, _), r._extremes.lat = bFe(n.lataxis._ax, u, _);
+        }
+        wFe.exports = { calcGeoJSON: H7t, plot: G7t };
+      });
+      var VF = ye((Hmr, TFe) => {
+        var j7t = ho(), W7t = a5(), X7t = Dr().fillText;
+        TFe.exports = function(t, r, n) {
+          var i = t.cd, a = i[0].trace, o = t.subplot, s, l, u, c, f = [r, n], h = [r + 360, n];
+          for (l = 0; l < i.length; l++) if (s = i[l], c = false, s._polygons) {
+            for (u = 0; u < s._polygons.length; u++) s._polygons[u].contains(f) && (c = !c), s._polygons[u].contains(h) && (c = !c);
+            if (c) break;
+          }
+          if (!(!c || !s)) return t.x0 = t.x1 = t.xa.c2p(s.ct), t.y0 = t.y1 = t.ya.c2p(s.ct), t.index = s.index, t.location = s.loc, t.z = s.z, t.zLabel = j7t.tickText(o.mockAxis, o.mockAxis.c2l(s.z), "hover").text, t.hovertemplate = s.hovertemplate, Z7t(t, a, s), [t];
+        };
+        function Z7t(e, t, r) {
+          if (!t.hovertemplate) {
+            var n = r.hi || t.hoverinfo, i = String(r.loc), a = n === "all" ? W7t.hoverinfo.flags : n.split("+"), o = a.indexOf("name") !== -1, s = a.indexOf("location") !== -1, l = a.indexOf("z") !== -1, u = a.indexOf("text") !== -1, c = !o && s, f = [];
+            c ? e.nameOverride = i : (o && (e.nameOverride = t.name), s && f.push(i)), l && f.push(e.zLabel), u && X7t(r, t, f), e.extraText = f.join("<br>");
+          }
+        }
+      });
+      var GF = ye((jmr, AFe) => {
+        AFe.exports = function(t, r, n, i, a) {
+          t.location = r.location, t.z = r.z;
+          var o = i[a];
+          return o.fIn && o.fIn.properties && (t.properties = o.fIn.properties), t.ct = o.ct, t;
+        };
+      });
+      var HF = ye((Wmr, SFe) => {
+        SFe.exports = function(t, r) {
+          var n = t.cd, i = t.xaxis, a = t.yaxis, o = [], s, l, u, c, f;
+          if (r === false) for (s = 0; s < n.length; s++) n[s].selected = 0;
+          else for (s = 0; s < n.length; s++) l = n[s], u = l.ct, u && (c = i.c2p(u), f = a.c2p(u), r.contains([c, f], null, s, t) ? (o.push({ pointNumber: s, lon: u[0], lat: u[1] }), l.selected = 1) : l.selected = 0);
+          return o;
+        };
+      });
+      var EFe = ye((Xmr, MFe) => {
+        MFe.exports = { attributes: a5(), supplyDefaults: vFe(), colorbar: D_(), calc: NF(), calcGeoJSON: QZ().calcGeoJSON, plot: QZ().plot, style: UF().style, styleOnSelect: UF().styleOnSelect, hoverPoints: VF(), eventData: GF(), selectPoints: HF(), moduleType: "trace", name: "choropleth", basePlotModule: JZ(), categories: ["geo", "noOpacity", "showLegend"], meta: {} };
+      });
+      var CFe = ye((Zmr, kFe) => {
+        kFe.exports = EFe();
+      });
+      var jF = ye((Ymr, PFe) => {
+        var Y7t = qa(), l0 = Dr(), K7t = gT();
+        function J7t(e, t, r, n) {
+          var i = e.cd, a = i[0].t, o = i[0].trace, s = e.xa, l = e.ya, u = a.x, c = a.y, f = s.c2p(t), h = l.c2p(r), d = e.distance, v;
+          if (a.tree) {
+            var _ = s.p2c(f - d), b = s.p2c(f + d), p = l.p2c(h - d), k = l.p2c(h + d);
+            n === "x" ? v = a.tree.range(Math.min(_, b), Math.min(l._rl[0], l._rl[1]), Math.max(_, b), Math.max(l._rl[0], l._rl[1])) : v = a.tree.range(Math.min(_, b), Math.min(p, k), Math.max(_, b), Math.max(p, k));
+          } else v = a.ids;
+          var E, T, L, x, C, M, g, P, A, z = d;
+          if (n === "x") {
+            var O = !!o.xperiodalignment, U = !!o.yperiodalignment;
+            for (C = 0; C < v.length; C++) {
+              if (E = v[C], L = u[E], M = Math.abs(s.c2p(L) - f), O) {
+                var G = s.c2p(o._xStarts[E]), Z = s.c2p(o._xEnds[E]);
+                M = f >= Math.min(G, Z) && f <= Math.max(G, Z) ? 0 : 1 / 0;
+              }
+              if (M < z) {
+                if (z = M, x = c[E], g = l.c2p(x) - h, U) {
+                  var j = l.c2p(o._yStarts[E]), N = l.c2p(o._yEnds[E]);
+                  g = h >= Math.min(j, N) && h <= Math.max(j, N) ? 0 : 1 / 0;
+                }
+                A = Math.sqrt(M * M + g * g), T = v[C];
+              }
+            }
+          } else for (C = v.length - 1; C > -1; C--) E = v[C], L = u[E], x = c[E], M = s.c2p(L) - f, g = l.c2p(x) - h, P = Math.sqrt(M * M + g * g), P < z && (z = A = P, T = E);
+          return e.index = T, e.distance = z, e.dxy = A, T === void 0 ? [e] : [LFe(e, u, c, o)];
+        }
+        function LFe(e, t, r, n) {
+          var i = e.xa, a = e.ya, o = e.distance, s = e.dxy, l = e.index, u = { pointNumber: l, x: t[l], y: r[l] };
+          u.tx = l0.isArrayOrTypedArray(n.text) ? n.text[l] : n.text, u.htx = Array.isArray(n.hovertext) ? n.hovertext[l] : n.hovertext, u.data = Array.isArray(n.customdata) ? n.customdata[l] : n.customdata, u.tp = Array.isArray(n.textposition) ? n.textposition[l] : n.textposition;
+          var c = n.textfont;
+          c && (u.ts = l0.isArrayOrTypedArray(c.size) ? c.size[l] : c.size, u.tc = l0.isArrayOrTypedArray(c.color) ? c.color[l] : c.color, u.tf = Array.isArray(c.family) ? c.family[l] : c.family, u.tw = Array.isArray(c.weight) ? c.weight[l] : c.weight, u.ty = Array.isArray(c.style) ? c.style[l] : c.style, u.tv = Array.isArray(c.variant) ? c.variant[l] : c.variant);
+          var f = n.marker;
+          f && (u.ms = l0.isArrayOrTypedArray(f.size) ? f.size[l] : f.size, u.mo = l0.isArrayOrTypedArray(f.opacity) ? f.opacity[l] : f.opacity, u.mx = l0.isArrayOrTypedArray(f.symbol) ? f.symbol[l] : f.symbol, u.ma = l0.isArrayOrTypedArray(f.angle) ? f.angle[l] : f.angle, u.mc = l0.isArrayOrTypedArray(f.color) ? f.color[l] : f.color);
+          var h = f && f.line;
+          h && (u.mlc = Array.isArray(h.color) ? h.color[l] : h.color, u.mlw = l0.isArrayOrTypedArray(h.width) ? h.width[l] : h.width);
+          var d = f && f.gradient;
+          d && d.type !== "none" && (u.mgt = Array.isArray(d.type) ? d.type[l] : d.type, u.mgc = Array.isArray(d.color) ? d.color[l] : d.color);
+          var v = i.c2p(u.x, true), _ = a.c2p(u.y, true), b = u.mrc || 1, p = n.hoverlabel;
+          p && (u.hbg = Array.isArray(p.bgcolor) ? p.bgcolor[l] : p.bgcolor, u.hbc = Array.isArray(p.bordercolor) ? p.bordercolor[l] : p.bordercolor, u.hts = l0.isArrayOrTypedArray(p.font.size) ? p.font.size[l] : p.font.size, u.htc = Array.isArray(p.font.color) ? p.font.color[l] : p.font.color, u.htf = Array.isArray(p.font.family) ? p.font.family[l] : p.font.family, u.hnl = l0.isArrayOrTypedArray(p.namelength) ? p.namelength[l] : p.namelength);
+          var k = n.hoverinfo;
+          k && (u.hi = Array.isArray(k) ? k[l] : k);
+          var E = n.hovertemplate;
+          E && (u.ht = Array.isArray(E) ? E[l] : E);
+          var T = {};
+          T[e.index] = u;
+          var L = n._origX, x = n._origY, C = l0.extendFlat({}, e, { color: K7t(n, u), x0: v - b, x1: v + b, xLabelVal: L ? L[l] : u.x, y0: _ - b, y1: _ + b, yLabelVal: x ? x[l] : u.y, cd: T, distance: o, spikeDistance: s, hovertemplate: u.ht });
+          return u.htx ? C.text = u.htx : u.tx ? C.text = u.tx : n.text && (C.text = n.text), l0.fillText(u, n, C), Y7t.getComponentMethod("errorbars", "hoverInfo")(u, n, C), C;
+        }
+        PFe.exports = { hoverPoints: J7t, calcHover: LFe };
+      });
+      var px = ye((Kmr, RFe) => {
+        var IFe = 20;
+        RFe.exports = { TOO_MANY_POINTS: 1e5, SYMBOL_SDF_SIZE: 200, SYMBOL_SIZE: IFe, SYMBOL_STROKE: IFe / 20, DOT_RE: /-dot/, OPEN_RE: /-open/, DASHES: { solid: [1], dot: [1, 1], dash: [4, 1], longdash: [8, 1], dashdot: [4, 1, 1, 1], longdashdot: [8, 1, 1, 1] } };
+      });
+      var gk = ye((Jmr, OFe) => {
+        var $7t = Gl(), Q7t = ec(), e9t = Pg(), mf = pf(), DFe = df().axisHoverFormat, FFe = Tu(), t9t = t_(), eY = Ao().extendFlat, r9t = mc().overrideAll, i9t = px().DASHES, zFe = mf.line, u1 = mf.marker, n9t = u1.line, gx = OFe.exports = r9t({ x: mf.x, x0: mf.x0, dx: mf.dx, y: mf.y, y0: mf.y0, dy: mf.dy, xperiod: mf.xperiod, yperiod: mf.yperiod, xperiod0: mf.xperiod0, yperiod0: mf.yperiod0, xperiodalignment: mf.xperiodalignment, yperiodalignment: mf.yperiodalignment, xhoverformat: DFe("x"), yhoverformat: DFe("y"), text: mf.text, hovertext: mf.hovertext, textposition: mf.textposition, textfont: Q7t({ noFontShadow: true, noFontLineposition: true, noFontTextcase: true, editType: "calc", colorEditType: "style", arrayOk: true, noNumericWeightValues: true, variantValues: ["normal", "small-caps"] }), mode: { valType: "flaglist", flags: ["lines", "markers", "text"], extras: ["none"] }, line: { color: zFe.color, width: zFe.width, shape: { valType: "enumerated", values: ["linear", "hv", "vh", "hvh", "vhv"], dflt: "linear", editType: "plot" }, dash: { valType: "enumerated", values: t9t(i9t), dflt: "solid" } }, marker: eY({}, FFe("marker"), { symbol: u1.symbol, angle: u1.angle, size: u1.size, sizeref: u1.sizeref, sizemin: u1.sizemin, sizemode: u1.sizemode, opacity: u1.opacity, colorbar: u1.colorbar, line: eY({}, FFe("marker.line"), { width: n9t.width }) }), connectgaps: mf.connectgaps, fill: eY({}, mf.fill, { dflt: "none" }), fillcolor: e9t(), selected: { marker: mf.selected.marker, textfont: mf.selected.textfont }, unselected: { marker: mf.unselected.marker, textfont: mf.unselected.textfont }, opacity: $7t.opacity }, "calc", "nested");
+        gx.x.editType = gx.y.editType = gx.x0.editType = gx.y0.editType = "calc+clearAxisTypes";
+        gx.hovertemplate = mf.hovertemplate;
+        gx.hovertemplatefallback = mf.hovertemplatefallback;
+        gx.texttemplate = mf.texttemplate;
+        gx.texttemplatefallback = mf.texttemplatefallback;
+      });
+      var WF = ye((tY) => {
+        var qFe = px();
+        tY.isOpenSymbol = function(e) {
+          return typeof e == "string" ? qFe.OPEN_RE.test(e) : e % 200 > 100;
+        };
+        tY.isDotSymbol = function(e) {
+          return typeof e == "string" ? qFe.DOT_RE.test(e) : e > 200;
+        };
+      });
+      var UFe = ye((Qmr, NFe) => {
+        var BFe = Dr(), a9t = qa(), o9t = WF(), s9t = gk(), l9t = Lm(), XF = Ru(), u9t = oT(), c9t = Dg(), f9t = $p(), h9t = D0(), d9t = Fg(), v9t = F0();
+        NFe.exports = function(t, r, n, i) {
+          function a(d, v) {
+            return BFe.coerce(t, r, s9t, d, v);
+          }
+          var o = t.marker ? o9t.isOpenSymbol(t.marker.symbol) : false, s = XF.isBubble(t), l = u9t(t, r, i, a);
+          if (!l) {
+            r.visible = false;
+            return;
+          }
+          c9t(t, r, i, a), a("xhoverformat"), a("yhoverformat");
+          var u = l < l9t.PTS_LINESONLY ? "lines+markers" : "lines";
+          a("text"), a("hovertext"), a("hovertemplate"), a("hovertemplatefallback"), a("mode", u), XF.hasMarkers(r) && (f9t(t, r, n, i, a, { noAngleRef: true, noLineDash: true, noStandOff: true }), a("marker.line.width", o || s ? 1 : 0)), XF.hasLines(r) && (a("connectgaps"), h9t(t, r, n, i, a), a("line.shape")), XF.hasText(r) && (a("texttemplate"), a("texttemplatefallback"), v9t(t, r, i, a, { noFontShadow: true, noFontLineposition: true, noFontTextcase: true }));
+          var c = (r.line || {}).color, f = (r.marker || {}).color;
+          a("fill"), r.fill !== "none" && d9t(t, r, n, a);
+          var h = a9t.getComponentMethod("errorbars", "supplyDefaults");
+          h(t, r, c || f || n, { axis: "y" }), h(t, r, c || f || n, { axis: "x", inherit: "y" }), BFe.coerceSelectionMarkerOpacity(r, a);
+        };
+      });
+      var GFe = ye((eyr, VFe) => {
+        var p9t = lI();
+        VFe.exports = function(t, r, n) {
+          var i = t.i;
+          return "x" in t || (t.x = r._x[i]), "y" in t || (t.y = r._y[i]), p9t(t, r, n);
+        };
+      });
+      var jFe = ye((tyr, HFe) => {
+        function g9t(e, t, r, n, i) {
+          for (var a = i + 1; n <= i; ) {
+            var o = n + i >>> 1, s = e[o], l = r !== void 0 ? r(s, t) : s - t;
+            l >= 0 ? (a = o, i = o - 1) : n = o + 1;
+          }
+          return a;
+        }
+        function m9t(e, t, r, n, i) {
+          for (var a = i + 1; n <= i; ) {
+            var o = n + i >>> 1, s = e[o], l = r !== void 0 ? r(s, t) : s - t;
+            l > 0 ? (a = o, i = o - 1) : n = o + 1;
+          }
+          return a;
+        }
+        function y9t(e, t, r, n, i) {
+          for (var a = n - 1; n <= i; ) {
+            var o = n + i >>> 1, s = e[o], l = r !== void 0 ? r(s, t) : s - t;
+            l < 0 ? (a = o, n = o + 1) : i = o - 1;
+          }
+          return a;
+        }
+        function _9t(e, t, r, n, i) {
+          for (var a = n - 1; n <= i; ) {
+            var o = n + i >>> 1, s = e[o], l = r !== void 0 ? r(s, t) : s - t;
+            l <= 0 ? (a = o, n = o + 1) : i = o - 1;
+          }
+          return a;
+        }
+        function x9t(e, t, r, n, i) {
+          for (; n <= i; ) {
+            var a = n + i >>> 1, o = e[a], s = r !== void 0 ? r(o, t) : o - t;
+            if (s === 0) return a;
+            s <= 0 ? n = a + 1 : i = a - 1;
+          }
+          return -1;
+        }
+        function mk(e, t, r, n, i, a) {
+          return typeof r == "function" ? a(e, t, r, n === void 0 ? 0 : n | 0, i === void 0 ? e.length - 1 : i | 0) : a(e, t, void 0, r === void 0 ? 0 : r | 0, n === void 0 ? e.length - 1 : n | 0);
+        }
+        HFe.exports = { ge: function(e, t, r, n, i) {
+          return mk(e, t, r, n, i, g9t);
+        }, gt: function(e, t, r, n, i) {
+          return mk(e, t, r, n, i, m9t);
+        }, lt: function(e, t, r, n, i) {
+          return mk(e, t, r, n, i, y9t);
+        }, le: function(e, t, r, n, i) {
+          return mk(e, t, r, n, i, _9t);
+        }, eq: function(e, t, r, n, i) {
+          return mk(e, t, r, n, i, x9t);
+        } };
+      });
+      var ey = ye((ryr, XFe) => {
+        XFe.exports = function(t, r, n) {
+          var i = {}, a, o;
+          if (typeof r == "string" && (r = WFe(r)), Array.isArray(r)) {
+            var s = {};
+            for (o = 0; o < r.length; o++) s[r[o]] = true;
+            r = s;
+          }
+          for (a in r) r[a] = WFe(r[a]);
+          var l = {};
+          for (a in r) {
+            var u = r[a];
+            if (Array.isArray(u)) for (o = 0; o < u.length; o++) {
+              var c = u[o];
+              if (n && (l[c] = true), c in t) {
+                if (i[a] = t[c], n) for (var f = o; f < u.length; f++) l[u[f]] = true;
+                break;
+              }
+            }
+            else a in t && (r[a] && (i[a] = t[a]), n && (l[a] = true));
+          }
+          if (n) for (a in t) l[a] || (i[a] = t[a]);
+          return i;
+        };
+        var rY = {};
+        function WFe(e) {
+          return rY[e] ? rY[e] : (typeof e == "string" && (e = rY[e] = e.split(/\s*,\s*|\s+/)), e);
+        }
+      });
+      var s5 = ye((iyr, ZFe) => {
+        var b9t = ey();
+        ZFe.exports = w9t;
+        function w9t(e) {
+          var t;
+          return arguments.length > 1 && (e = arguments), typeof e == "string" ? e = e.split(/\s/).map(parseFloat) : typeof e == "number" && (e = [e]), e.length && typeof e[0] == "number" ? e.length === 1 ? t = { width: e[0], height: e[0], x: 0, y: 0 } : e.length === 2 ? t = { width: e[0], height: e[1], x: 0, y: 0 } : t = { x: e[0], y: e[1], width: e[2] - e[0] || 0, height: e[3] - e[1] || 0 } : e && (e = b9t(e, { left: "x l left Left", top: "y t top Top", width: "w width W Width", height: "h height W Width", bottom: "b bottom Bottom", right: "r right Right" }), t = { x: e.left || 0, y: e.top || 0 }, e.width == null ? e.right ? t.width = e.right - t.x : t.width = 0 : t.width = e.width, e.height == null ? e.bottom ? t.height = e.bottom - t.y : t.height = 0 : t.height = e.height), t;
+        }
+      });
+      var rw = ye((nyr, YFe) => {
+        YFe.exports = T9t;
+        function T9t(e, t) {
+          if (!e || e.length == null) throw Error("Argument should be an array");
+          t == null ? t = 1 : t = Math.floor(t);
+          for (var r = Array(t * 2), n = 0; n < t; n++) {
+            for (var i = -1 / 0, a = 1 / 0, o = n, s = e.length; o < s; o += t) e[o] > i && (i = e[o]), e[o] < a && (a = e[o]);
+            r[n] = a, r[t + n] = i;
+          }
+          return r;
+        }
+      });
+      var JFe = ye((ayr, KFe) => {
+        KFe.exports = function() {
+          for (var e = 0; e < arguments.length; e++) if (arguments[e] !== void 0) return arguments[e];
+        };
+      });
+      var iw = ye((oyr, QFe) => {
+        var $Fe = QD();
+        QFe.exports = A9t;
+        function A9t(e, t, r) {
+          if (!e) throw new TypeError("must specify data as first parameter");
+          if (r = +(r || 0) | 0, Array.isArray(e) && e[0] && typeof e[0][0] == "number") {
+            var n = e[0].length, i = e.length * n, a, o, s, l;
+            (!t || typeof t == "string") && (t = new ($Fe(t || "float32"))(i + r));
+            var u = t.length - r;
+            if (i !== u) throw new Error("source length " + i + " (" + n + "x" + e.length + ") does not match destination length " + u);
+            for (a = 0, s = r; a < e.length; a++) for (o = 0; o < n; o++) t[s++] = e[a][o] === null ? NaN : e[a][o];
+          } else if (!t || typeof t == "string") {
+            var c = $Fe(t || "float32");
+            if (Array.isArray(e) || t === "array") for (t = new c(e.length + r), a = 0, s = r, l = t.length; s < l; s++, a++) t[s] = e[a] === null ? NaN : e[a];
+            else r === 0 ? t = new c(e) : (t = new c(e.length + r), t.set(e, r));
+          } else t.set(e, r);
+          return t;
+        }
+      });
+      var tze = ye((syr, eze) => {
+        eze.exports = function(e) {
+          var t = typeof e;
+          return e !== null && (t === "object" || t === "function");
+        };
+      });
+      var ize = ye((lyr, rze) => {
+        rze.exports = Math.log2 || function(e) {
+          return Math.log(e) * Math.LOG2E;
+        };
+      });
+      var cze = ye((uyr, uze) => {
+        var nze = jFe(), aze = rk(), S9t = s5(), M9t = rw(), oze = ey(), iY = JFe(), E9t = iw(), k9t = tze(), C9t = QD(), sze = ize(), L9t = 1073741824;
+        uze.exports = function(t, r) {
+          r || (r = {}), t = E9t(t, "float64"), r = oze(r, { bounds: "range bounds dataBox databox", maxDepth: "depth maxDepth maxdepth level maxLevel maxlevel levels", dtype: "type dtype format out dst output destination" });
+          let n = iY(r.maxDepth, 255), i = iY(r.bounds, M9t(t, 2));
+          i[0] === i[2] && i[2]++, i[1] === i[3] && i[3]++;
+          let a = lze(t, i), o = t.length >>> 1, s;
+          r.dtype || (r.dtype = "array"), typeof r.dtype == "string" ? s = new (C9t(r.dtype))(o) : r.dtype && (s = r.dtype, Array.isArray(s) && (s.length = o));
+          for (let p = 0; p < o; ++p) s[p] = p;
+          let l = [], u = [], c = [], f = [];
+          d(0, 0, 1, s, 0, 1);
+          let h = 0;
+          for (let p = 0; p < l.length; p++) {
+            let k = l[p];
+            if (s.set) s.set(k, h);
+            else for (let T = 0, L = k.length; T < L; T++) s[T + h] = k[T];
+            let E = h + l[p].length;
+            f[p] = [h, E], h = E;
+          }
+          return s.range = v, s;
+          function d(p, k, E, T, L, x) {
+            if (!T.length) return null;
+            let C = l[L] || (l[L] = []), M = c[L] || (c[L] = []), g = u[L] || (u[L] = []), P = C.length;
+            if (L++, L > n || x > L9t) {
+              for (let N = 0; N < T.length; N++) C.push(T[N]), M.push(x), g.push(null, null, null, null);
+              return P;
+            }
+            if (C.push(T[0]), M.push(x), T.length <= 1) return g.push(null, null, null, null), P;
+            let A = E * 0.5, z = p + A, O = k + A, U = [], G = [], Z = [], j = [];
+            for (let N = 1, H = T.length; N < H; N++) {
+              let re = T[N], oe = a[re * 2], _e = a[re * 2 + 1];
+              oe < z ? _e < O ? U.push(re) : G.push(re) : _e < O ? Z.push(re) : j.push(re);
+            }
+            return x <<= 2, g.push(d(p, k, A, U, L, x), d(p, O, A, G, L, x + 1), d(z, k, A, Z, L, x + 2), d(z, O, A, j, L, x + 3)), P;
+          }
+          function v(...p) {
+            let k;
+            if (k9t(p[p.length - 1])) {
+              let Z = p.pop();
+              !p.length && (Z.x != null || Z.l != null || Z.left != null) && (p = [Z], k = {}), k = oze(Z, { level: "level maxLevel", d: "d diam diameter r radius px pxSize pixel pixelSize maxD size minSize", lod: "lod details ranges offsets" });
+            } else k = {};
+            p.length || (p = i);
+            let E = S9t(...p), [T, L, x, C] = [Math.min(E.x, E.x + E.width), Math.min(E.y, E.y + E.height), Math.max(E.x, E.x + E.width), Math.max(E.y, E.y + E.height)], [M, g, P, A] = lze([T, L, x, C], i), z = iY(k.level, l.length);
+            if (k.d != null) {
+              let Z;
+              typeof k.d == "number" ? Z = [k.d, k.d] : k.d.length && (Z = k.d), z = Math.min(Math.max(Math.ceil(-sze(Math.abs(Z[0]) / (i[2] - i[0]))), Math.ceil(-sze(Math.abs(Z[1]) / (i[3] - i[1])))), z);
+            }
+            if (z = Math.min(z, l.length), k.lod) return _(M, g, P, A, z);
+            let O = [];
+            U(0, 0, 1, 0, 0, 1);
+            function U(Z, j, N, H, re, oe) {
+              if (re === null || oe === null) return;
+              let _e = Z + N, Ce = j + N;
+              if (M > _e || g > Ce || P < Z || A < j || H >= z || re === oe) return;
+              let Le = l[H];
+              oe === void 0 && (oe = Le.length);
+              for (let De = re; De < oe; De++) {
+                let ce = Le[De], je = t[ce * 2], lt = t[ce * 2 + 1];
+                je >= T && je <= x && lt >= L && lt <= C && O.push(ce);
+              }
+              let ge = u[H], ie = ge[re * 4 + 0], Se = ge[re * 4 + 1], Ee = ge[re * 4 + 2], Ae = ge[re * 4 + 3], Be = G(ge, re + 1), Pe = N * 0.5, me = H + 1;
+              U(Z, j, Pe, me, ie, Se || Ee || Ae || Be), U(Z, j + Pe, Pe, me, Se, Ee || Ae || Be), U(Z + Pe, j, Pe, me, Ee, Ae || Be), U(Z + Pe, j + Pe, Pe, me, Ae, Be);
+            }
+            function G(Z, j) {
+              let N = null, H = 0;
+              for (; N === null; ) if (N = Z[j * 4 + H], H++, H > Z.length) return null;
+              return N;
+            }
+            return O;
+          }
+          function _(p, k, E, T, L) {
+            let x = [];
+            for (let C = 0; C < L; C++) {
+              let M = c[C], g = f[C][0], P = b(p, k, C), A = b(E, T, C), z = nze.ge(M, P), O = nze.gt(M, A, z, M.length - 1);
+              x[C] = [z + g, O + g];
+            }
+            return x;
+          }
+          function b(p, k, E) {
+            let T = 1, L = 0.5, x = 0.5, C = 0.5;
+            for (let M = 0; M < E; M++) T <<= 2, T += p < L ? k < x ? 0 : 1 : k < x ? 2 : 3, C *= 0.5, L += p < L ? -C : C, x += k < x ? -C : C;
+            return T;
+          }
+        };
+        function lze(e, t) {
+          let [r, n, i, a] = t, o = 1 / (i - r), s = 1 / (a - n), l = new Array(e.length);
+          for (let u = 0, c = e.length / 2; u < c; u++) l[2 * u] = aze((e[2 * u] - r) * o, 0, 1), l[2 * u + 1] = aze((e[2 * u + 1] - n) * s, 0, 1);
+          return l;
+        }
+      });
+      var ZF = ye((cyr, fze) => {
+        fze.exports = cze();
+      });
+      var nY = ye((fyr, hze) => {
+        hze.exports = P9t;
+        function P9t(e) {
+          var t = 0, r = 0, n = 0, i = 0;
+          return e.map(function(a) {
+            a = a.slice();
+            var o = a[0], s = o.toUpperCase();
+            if (o != s) switch (a[0] = s, o) {
+              case "a":
+                a[6] += n, a[7] += i;
+                break;
+              case "v":
+                a[1] += i;
+                break;
+              case "h":
+                a[1] += n;
+                break;
+              default:
+                for (var l = 1; l < a.length; ) a[l++] += n, a[l++] += i;
+            }
+            switch (s) {
+              case "Z":
+                n = t, i = r;
+                break;
+              case "H":
+                n = a[1];
+                break;
+              case "V":
+                i = a[1];
+                break;
+              case "M":
+                n = t = a[1], i = r = a[2];
+                break;
+              default:
+                n = a[a.length - 2], i = a[a.length - 1];
+            }
+            return a;
+          });
+        }
+      });
+      var pze = ye((YF, vze) => {
+        Object.defineProperty(YF, "__esModule", { value: true });
+        var I9t = /* @__PURE__ */ function() {
+          function e(t, r) {
+            var n = [], i = true, a = false, o = void 0;
+            try {
+              for (var s = t[Symbol.iterator](), l; !(i = (l = s.next()).done) && (n.push(l.value), !(r && n.length === r)); i = true) ;
+            } catch (u) {
+              a = true, o = u;
+            } finally {
+              try {
+                !i && s.return && s.return();
+              } finally {
+                if (a) throw o;
+              }
+            }
+            return n;
+          }
+          return function(t, r) {
+            if (Array.isArray(t)) return t;
+            if (Symbol.iterator in Object(t)) return e(t, r);
+            throw new TypeError("Invalid attempt to destructure non-iterable instance");
+          };
+        }(), yk = Math.PI * 2, aY = function(t, r, n, i, a, o, s) {
+          var l = t.x, u = t.y;
+          l *= r, u *= n;
+          var c = i * l - a * u, f = a * l + i * u;
+          return { x: c + o, y: f + s };
+        }, R9t = function(t, r) {
+          var n = r === 1.5707963267948966 ? 0.551915024494 : r === -1.5707963267948966 ? -0.551915024494 : 1.3333333333333333 * Math.tan(r / 4), i = Math.cos(t), a = Math.sin(t), o = Math.cos(t + r), s = Math.sin(t + r);
+          return [{ x: i - a * n, y: a + i * n }, { x: o + s * n, y: s - o * n }, { x: o, y: s }];
+        }, dze = function(t, r, n, i) {
+          var a = t * i - r * n < 0 ? -1 : 1, o = t * n + r * i;
+          return o > 1 && (o = 1), o < -1 && (o = -1), a * Math.acos(o);
+        }, D9t = function(t, r, n, i, a, o, s, l, u, c, f, h) {
+          var d = Math.pow(a, 2), v = Math.pow(o, 2), _ = Math.pow(f, 2), b = Math.pow(h, 2), p = d * v - d * b - v * _;
+          p < 0 && (p = 0), p /= d * b + v * _, p = Math.sqrt(p) * (s === l ? -1 : 1);
+          var k = p * a / o * h, E = p * -o / a * f, T = c * k - u * E + (t + n) / 2, L = u * k + c * E + (r + i) / 2, x = (f - k) / a, C = (h - E) / o, M = (-f - k) / a, g = (-h - E) / o, P = dze(1, 0, x, C), A = dze(x, C, M, g);
+          return l === 0 && A > 0 && (A -= yk), l === 1 && A < 0 && (A += yk), [T, L, P, A];
+        }, F9t = function(t) {
+          var r = t.px, n = t.py, i = t.cx, a = t.cy, o = t.rx, s = t.ry, l = t.xAxisRotation, u = l === void 0 ? 0 : l, c = t.largeArcFlag, f = c === void 0 ? 0 : c, h = t.sweepFlag, d = h === void 0 ? 0 : h, v = [];
+          if (o === 0 || s === 0) return [];
+          var _ = Math.sin(u * yk / 360), b = Math.cos(u * yk / 360), p = b * (r - i) / 2 + _ * (n - a) / 2, k = -_ * (r - i) / 2 + b * (n - a) / 2;
+          if (p === 0 && k === 0) return [];
+          o = Math.abs(o), s = Math.abs(s);
+          var E = Math.pow(p, 2) / Math.pow(o, 2) + Math.pow(k, 2) / Math.pow(s, 2);
+          E > 1 && (o *= Math.sqrt(E), s *= Math.sqrt(E));
+          var T = D9t(r, n, i, a, o, s, f, d, _, b, p, k), L = I9t(T, 4), x = L[0], C = L[1], M = L[2], g = L[3], P = Math.abs(g) / (yk / 4);
+          Math.abs(1 - P) < 1e-7 && (P = 1);
+          var A = Math.max(Math.ceil(P), 1);
+          g /= A;
+          for (var z = 0; z < A; z++) v.push(R9t(M, g)), M += g;
+          return v.map(function(O) {
+            var U = aY(O[0], o, s, b, _, x, C), G = U.x, Z = U.y, j = aY(O[1], o, s, b, _, x, C), N = j.x, H = j.y, re = aY(O[2], o, s, b, _, x, C), oe = re.x, _e = re.y;
+            return { x1: G, y1: Z, x2: N, y2: H, x: oe, y: _e };
+          });
+        };
+        YF.default = F9t;
+        vze.exports = YF.default;
+      });
+      var yze = ye((hyr, mze) => {
+        mze.exports = O9t;
+        var z9t = pze();
+        function O9t(e) {
+          for (var t, r = [], n = 0, i = 0, a = 0, o = 0, s = null, l = null, u = 0, c = 0, f = 0, h = e.length; f < h; f++) {
+            var d = e[f], v = d[0];
+            switch (v) {
+              case "M":
+                a = d[1], o = d[2];
+                break;
+              case "A":
+                var _ = z9t({ px: u, py: c, cx: d[6], cy: d[7], rx: d[1], ry: d[2], xAxisRotation: d[3], largeArcFlag: d[4], sweepFlag: d[5] });
+                if (!_.length) continue;
+                for (var b = 0, p; b < _.length; b++) p = _[b], d = ["C", p.x1, p.y1, p.x2, p.y2, p.x, p.y], b < _.length - 1 && r.push(d);
+                break;
+              case "S":
+                var k = u, E = c;
+                (t == "C" || t == "S") && (k += k - n, E += E - i), d = ["C", k, E, d[1], d[2], d[3], d[4]];
+                break;
+              case "T":
+                t == "Q" || t == "T" ? (s = u * 2 - s, l = c * 2 - l) : (s = u, l = c), d = gze(u, c, s, l, d[1], d[2]);
+                break;
+              case "Q":
+                s = d[1], l = d[2], d = gze(u, c, d[1], d[2], d[3], d[4]);
+                break;
+              case "L":
+                d = KF(u, c, d[1], d[2]);
+                break;
+              case "H":
+                d = KF(u, c, d[1], c);
+                break;
+              case "V":
+                d = KF(u, c, u, d[1]);
+                break;
+              case "Z":
+                d = KF(u, c, a, o);
+                break;
+            }
+            t = v, u = d[d.length - 2], c = d[d.length - 1], d.length > 4 ? (n = d[d.length - 4], i = d[d.length - 3]) : (n = u, i = c), r.push(d);
+          }
+          return r;
+        }
+        function KF(e, t, r, n) {
+          return ["C", e, t, r, n, r, n];
+        }
+        function gze(e, t, r, n, i, a) {
+          return ["C", e / 3 + 2 / 3 * r, t / 3 + 2 / 3 * n, i / 3 + 2 / 3 * r, a / 3 + 2 / 3 * n, i, a];
+        }
+      });
+      var oY = ye((dyr, _ze) => {
+        _ze.exports = function(t) {
+          return typeof t != "string" ? false : (t = t.trim(), !!(/^[mzlhvcsqta]\s*[-+.0-9][^mlhvzcsqta]+/i.test(t) && /[\dz]$/i.test(t) && t.length > 4));
+        };
+      });
+      var wze = ye((vyr, bze) => {
+        var q9t = nM(), B9t = nY(), N9t = yze(), U9t = oY(), xze = gE();
+        bze.exports = V9t;
+        function V9t(e) {
+          if (Array.isArray(e) && e.length === 1 && typeof e[0] == "string" && (e = e[0]), typeof e == "string" && (xze(U9t(e), "String is not an SVG path."), e = q9t(e)), xze(Array.isArray(e), "Argument should be a string or an array of path segments."), e = B9t(e), e = N9t(e), !e.length) return [0, 0, 0, 0];
+          for (var t = [1 / 0, 1 / 0, -1 / 0, -1 / 0], r = 0, n = e.length; r < n; r++) for (var i = e[r].slice(1), a = 0; a < i.length; a += 2) i[a + 0] < t[0] && (t[0] = i[a + 0]), i[a + 1] < t[1] && (t[1] = i[a + 1]), i[a + 0] > t[2] && (t[2] = i[a + 0]), i[a + 1] > t[3] && (t[3] = i[a + 1]);
+          return t;
+        }
+      });
+      var kze = ye((pyr, Eze) => {
+        var nw = Math.PI, Tze = Mze(120);
+        Eze.exports = G9t;
+        function G9t(e) {
+          for (var t, r = [], n = 0, i = 0, a = 0, o = 0, s = null, l = null, u = 0, c = 0, f = 0, h = e.length; f < h; f++) {
+            var d = e[f], v = d[0];
+            switch (v) {
+              case "M":
+                a = d[1], o = d[2];
+                break;
+              case "A":
+                d = Sze(u, c, d[1], d[2], Mze(d[3]), d[4], d[5], d[6], d[7]), d.unshift("C"), d.length > 7 && (r.push(d.splice(0, 7)), d.unshift("C"));
+                break;
+              case "S":
+                var _ = u, b = c;
+                (t == "C" || t == "S") && (_ += _ - n, b += b - i), d = ["C", _, b, d[1], d[2], d[3], d[4]];
+                break;
+              case "T":
+                t == "Q" || t == "T" ? (s = u * 2 - s, l = c * 2 - l) : (s = u, l = c), d = Aze(u, c, s, l, d[1], d[2]);
+                break;
+              case "Q":
+                s = d[1], l = d[2], d = Aze(u, c, d[1], d[2], d[3], d[4]);
+                break;
+              case "L":
+                d = JF(u, c, d[1], d[2]);
+                break;
+              case "H":
+                d = JF(u, c, d[1], c);
+                break;
+              case "V":
+                d = JF(u, c, u, d[1]);
+                break;
+              case "Z":
+                d = JF(u, c, a, o);
+                break;
+            }
+            t = v, u = d[d.length - 2], c = d[d.length - 1], d.length > 4 ? (n = d[d.length - 4], i = d[d.length - 3]) : (n = u, i = c), r.push(d);
+          }
+          return r;
+        }
+        function JF(e, t, r, n) {
+          return ["C", e, t, r, n, r, n];
+        }
+        function Aze(e, t, r, n, i, a) {
+          return ["C", e / 3 + 2 / 3 * r, t / 3 + 2 / 3 * n, i / 3 + 2 / 3 * r, a / 3 + 2 / 3 * n, i, a];
+        }
+        function Sze(e, t, r, n, i, a, o, s, l, u) {
+          if (u) E = u[0], T = u[1], p = u[2], k = u[3];
+          else {
+            var c = sY(e, t, -i);
+            e = c.x, t = c.y, c = sY(s, l, -i), s = c.x, l = c.y;
+            var f = (e - s) / 2, h = (t - l) / 2, d = f * f / (r * r) + h * h / (n * n);
+            d > 1 && (d = Math.sqrt(d), r = d * r, n = d * n);
+            var v = r * r, _ = n * n, b = (a == o ? -1 : 1) * Math.sqrt(Math.abs((v * _ - v * h * h - _ * f * f) / (v * h * h + _ * f * f)));
+            b == 1 / 0 && (b = 1);
+            var p = b * r * h / n + (e + s) / 2, k = b * -n * f / r + (t + l) / 2, E = Math.asin(((t - k) / n).toFixed(9)), T = Math.asin(((l - k) / n).toFixed(9));
+            E = e < p ? nw - E : E, T = s < p ? nw - T : T, E < 0 && (E = nw * 2 + E), T < 0 && (T = nw * 2 + T), o && E > T && (E = E - nw * 2), !o && T > E && (T = T - nw * 2);
+          }
+          if (Math.abs(T - E) > Tze) {
+            var L = T, x = s, C = l;
+            T = E + Tze * (o && T > E ? 1 : -1), s = p + r * Math.cos(T), l = k + n * Math.sin(T);
+            var M = Sze(s, l, r, n, i, 0, o, x, C, [T, L, p, k]);
+          }
+          var g = Math.tan((T - E) / 4), P = 4 / 3 * r * g, A = 4 / 3 * n * g, z = [2 * e - (e + P * Math.sin(E)), 2 * t - (t - A * Math.cos(E)), s + P * Math.sin(T), l - A * Math.cos(T), s, l];
+          if (u) return z;
+          M && (z = z.concat(M));
+          for (var O = 0; O < z.length; ) {
+            var U = sY(z[O], z[O + 1], i);
+            z[O++] = U.x, z[O++] = U.y;
+          }
+          return z;
+        }
+        function sY(e, t, r) {
+          return { x: e * Math.cos(r) - t * Math.sin(r), y: e * Math.sin(r) + t * Math.cos(r) };
+        }
+        function Mze(e) {
+          return e * (nw / 180);
+        }
+      });
+      var Lze = ye((gyr, Cze) => {
+        var H9t = nY(), j9t = kze(), W9t = { M: "moveTo", C: "bezierCurveTo" };
+        Cze.exports = function(e, t) {
+          e.beginPath(), j9t(H9t(t)).forEach(function(r) {
+            var n = r[0], i = r.slice(1);
+            e[W9t[n]].apply(e, i);
+          }), e.closePath();
+        };
+      });
+      var Dze = ye((myr, Rze) => {
+        var X9t = rk();
+        Rze.exports = Z9t;
+        var _k = 1e20;
+        function Z9t(e, t) {
+          t || (t = {});
+          var r = t.cutoff == null ? 0.25 : t.cutoff, n = t.radius == null ? 8 : t.radius, i = t.channel || 0, a, o, s, l, u, c, f, h, d, v, _;
+          if (ArrayBuffer.isView(e) || Array.isArray(e)) {
+            if (!t.width || !t.height) throw Error("For raw data width and height should be provided by options");
+            a = t.width, o = t.height, l = e, t.stride ? c = t.stride : c = Math.floor(e.length / a / o);
+          } else window.HTMLCanvasElement && e instanceof window.HTMLCanvasElement ? (h = e, f = h.getContext("2d"), a = h.width, o = h.height, d = f.getImageData(0, 0, a, o), l = d.data, c = 4) : window.CanvasRenderingContext2D && e instanceof window.CanvasRenderingContext2D ? (h = e.canvas, f = e, a = h.width, o = h.height, d = f.getImageData(0, 0, a, o), l = d.data, c = 4) : window.ImageData && e instanceof window.ImageData && (d = e, a = e.width, o = e.height, l = d.data, c = 4);
+          if (s = Math.max(a, o), window.Uint8ClampedArray && l instanceof window.Uint8ClampedArray || window.Uint8Array && l instanceof window.Uint8Array) for (u = l, l = Array(a * o), v = 0, _ = u.length; v < _; v++) l[v] = u[v * c + i] / 255;
+          else if (c !== 1) throw Error("Raw data can have only 1 value per pixel");
+          var b = Array(a * o), p = Array(a * o), k = Array(s), E = Array(s), T = Array(s + 1), L = Array(s);
+          for (v = 0, _ = a * o; v < _; v++) {
+            var x = l[v];
+            b[v] = x === 1 ? 0 : x === 0 ? _k : Math.pow(Math.max(0, 0.5 - x), 2), p[v] = x === 1 ? _k : x === 0 ? 0 : Math.pow(Math.max(0, x - 0.5), 2);
+          }
+          Pze(b, a, o, k, E, L, T), Pze(p, a, o, k, E, L, T);
+          var C = window.Float32Array ? new Float32Array(a * o) : new Array(a * o);
+          for (v = 0, _ = a * o; v < _; v++) C[v] = X9t(1 - ((b[v] - p[v]) / n + r), 0, 1);
+          return C;
+        }
+        function Pze(e, t, r, n, i, a, o) {
+          for (var s = 0; s < t; s++) {
+            for (var l = 0; l < r; l++) n[l] = e[l * t + s];
+            for (Ize(n, i, a, o, r), l = 0; l < r; l++) e[l * t + s] = i[l];
+          }
+          for (l = 0; l < r; l++) {
+            for (s = 0; s < t; s++) n[s] = e[l * t + s];
+            for (Ize(n, i, a, o, t), s = 0; s < t; s++) e[l * t + s] = Math.sqrt(i[s]);
+          }
+        }
+        function Ize(e, t, r, n, i) {
+          r[0] = 0, n[0] = -1e20, n[1] = 1e20;
+          for (var a = 1, o = 0; a < i; a++) {
+            for (var s = (e[a] + a * a - (e[r[o]] + r[o] * r[o])) / (2 * a - 2 * r[o]); s <= n[o]; ) o--, s = (e[a] + a * a - (e[r[o]] + r[o] * r[o])) / (2 * a - 2 * r[o]);
+            o++, r[o] = a, n[o] = s, n[o + 1] = 1e20;
+          }
+          for (a = 0, o = 0; a < i; a++) {
+            for (; n[o + 1] < a; ) o++;
+            t[a] = (a - r[o]) * (a - r[o]) + e[r[o]];
+          }
+        }
+      });
+      var zze = ye((yyr, Fze) => {
+        var Y9t = wze(), K9t = nM(), J9t = Lze(), $9t = oY(), Q9t = Dze(), lY = document.createElement("canvas"), dp = lY.getContext("2d");
+        Fze.exports = eOt;
+        function eOt(e, t) {
+          if (!$9t(e)) throw Error("Argument should be valid svg path string");
+          t || (t = {});
+          var r, n;
+          t.shape ? (r = t.shape[0], n = t.shape[1]) : (r = lY.width = t.w || t.width || 200, n = lY.height = t.h || t.height || 200);
+          var i = Math.min(r, n), a = t.stroke || 0, o = t.viewbox || t.viewBox || Y9t(e), s = [r / (o[2] - o[0]), n / (o[3] - o[1])], l = Math.min(s[0] || 0, s[1] || 0) / 2;
+          if (dp.fillStyle = "black", dp.fillRect(0, 0, r, n), dp.fillStyle = "white", a && (typeof a != "number" && (a = 1), a > 0 ? dp.strokeStyle = "white" : dp.strokeStyle = "black", dp.lineWidth = Math.abs(a)), dp.translate(r * 0.5, n * 0.5), dp.scale(l, l), tOt()) {
+            var u = new Path2D(e);
+            dp.fill(u), a && dp.stroke(u);
+          } else {
+            var c = K9t(e);
+            J9t(dp, c), dp.fill(), a && dp.stroke();
+          }
+          dp.setTransform(1, 0, 0, 1, 0, 0);
+          var f = Q9t(dp, { cutoff: t.cutoff != null ? t.cutoff : 0.5, radius: t.radius != null ? t.radius : i * 0.5 });
+          return f;
+        }
+        var $F;
+        function tOt() {
+          if ($F != null) return $F;
+          var e = document.createElement("canvas").getContext("2d");
+          if (e.canvas.width = e.canvas.height = 1, !window.Path2D) return $F = false;
+          var t = new Path2D("M0,0h1v1h-1v-1Z");
+          e.fillStyle = "black", e.fill(t);
+          var r = e.getImageData(0, 0, 1, 1);
+          return $F = r && r.data && r.data[3] === 255;
+        }
+      });
+      var ow = ye((_yr, Xze) => {
+        var ez = Eo(), rOt = zze(), QF = ox(), iOt = qa(), c5 = Dr(), bh = c5.isArrayOrTypedArray, l5 = So(), Oze = hf(), qze = a1().formatColor, u5 = Ru(), nOt = O3(), cY = WF(), xk = px(), aOt = X1().DESELECTDIM, Bze = { start: 1, left: 1, end: -1, right: -1, middle: 0, center: 0, bottom: 1, top: -1 }, oOt = ip().appendArrayPointValue;
+        function sOt(e, t) {
+          var r, n = { marker: void 0, markerSel: void 0, markerUnsel: void 0, line: void 0, fill: void 0, errorX: void 0, errorY: void 0, text: void 0, textSel: void 0, textUnsel: void 0 }, i = e._context.plotGlPixelRatio;
+          if (t.visible !== true) return n;
+          if (u5.hasText(t) && (n.text = Wze(e, t), n.textSel = Uze(e, t, t.selected), n.textUnsel = Uze(e, t, t.unselected)), u5.hasMarkers(t) && (n.marker = hY(e, t), n.markerSel = fY(e, t, t.selected), n.markerUnsel = fY(e, t, t.unselected), !t.unselected && bh(t.marker.opacity))) {
+            var a = t.marker.opacity;
+            for (n.markerUnsel.opacity = new Array(a.length), r = 0; r < a.length; r++) n.markerUnsel.opacity[r] = aOt * a[r];
+          }
+          if (u5.hasLines(t)) {
+            n.line = { overlay: true, thickness: t.line.width * i, color: t.line.color, opacity: t.opacity };
+            var o = (xk.DASHES[t.line.dash] || [1]).slice();
+            for (r = 0; r < o.length; ++r) o[r] *= t.line.width * i;
+            n.line.dashes = o;
+          }
+          return t.error_x && t.error_x.visible && (n.errorX = Vze(t, t.error_x, i)), t.error_y && t.error_y.visible && (n.errorY = Vze(t, t.error_y, i)), t.fill && t.fill !== "none" && (n.fill = { closed: true, fill: t.fillcolor, thickness: 0 }), n;
+        }
+        function Wze(e, t) {
+          var r = e._fullLayout, n = t._length, i = t.textfont, a = t.textposition, o = bh(a) ? a : [a], s = i.color, l = i.size, u = i.family, c = i.weight, f = i.style, h = i.variant, d = {}, v, _ = e._context.plotGlPixelRatio, b = t.texttemplate;
+          if (b) {
+            d.text = [];
+            var p = r._d3locale, k = Array.isArray(b), E = k ? Math.min(b.length, n) : n, T = k ? function(P) {
+              return b[P];
+            } : function() {
+              return b;
+            };
+            for (v = 0; v < E; v++) {
+              var L = { i: v }, x = t._module.formatLabels(L, t, r), C = {};
+              oOt(C, t, v), d.text.push(c5.texttemplateString({ data: [C, L, t._meta], fallback: t.texttemplatefallback, labels: x, locale: p, template: T(v) }));
+            }
+          } else bh(t.text) && t.text.length < n ? d.text = t.text.slice() : d.text = t.text;
+          if (bh(d.text)) for (v = d.text.length; v < n; v++) d.text[v] = "";
+          for (d.opacity = t.opacity, d.font = {}, d.align = [], d.baseline = [], v = 0; v < o.length; v++) {
+            var M = o[v].split(/\s+/);
+            switch (M[1]) {
+              case "left":
+                d.align.push("right");
+                break;
+              case "right":
+                d.align.push("left");
+                break;
+              default:
+                d.align.push(M[1]);
+            }
+            switch (M[0]) {
+              case "top":
+                d.baseline.push("bottom");
+                break;
+              case "bottom":
+                d.baseline.push("top");
+                break;
+              default:
+                d.baseline.push(M[0]);
+            }
+          }
+          if (bh(s)) for (d.color = new Array(n), v = 0; v < n; v++) d.color[v] = s[v];
+          else d.color = s;
+          if (bh(l) || Array.isArray(u) || bh(c) || Array.isArray(f) || Array.isArray(h)) for (d.font = new Array(n), v = 0; v < n; v++) {
+            var g = d.font[v] = {};
+            g.size = (c5.isTypedArray(l) ? l[v] : bh(l) ? ez(l[v]) ? l[v] : 0 : l) * _, g.family = Array.isArray(u) ? u[v] : u, g.weight = Nze(bh(c) ? c[v] : c), g.style = Array.isArray(f) ? f[v] : f, g.variant = Array.isArray(h) ? h[v] : h;
+          }
+          else d.font = { size: l * _, family: u, weight: Nze(c), style: f, variant: h };
+          return d;
+        }
+        function Nze(e) {
+          return e <= 1e3 ? e > 500 ? "bold" : "normal" : e;
+        }
+        function hY(e, t) {
+          var r = t._length, n = t.marker, i = {}, a, o = bh(n.symbol), s = bh(n.angle), l = bh(n.color), u = bh(n.line.color), c = bh(n.opacity), f = bh(n.size), h = bh(n.line.width), d;
+          if (o || (d = cY.isOpenSymbol(n.symbol)), o || l || u || c || s) {
+            i.symbols = new Array(r), i.angles = new Array(r), i.colors = new Array(r), i.borderColors = new Array(r);
+            var v = n.symbol, _ = n.angle, b = qze(n, n.opacity, r), p = qze(n.line, n.opacity, r);
+            if (!bh(p[0])) {
+              var k = p;
+              for (p = Array(r), a = 0; a < r; a++) p[a] = k;
+            }
+            if (!bh(b[0])) {
+              var E = b;
+              for (b = Array(r), a = 0; a < r; a++) b[a] = E;
+            }
+            if (!bh(v)) {
+              var T = v;
+              for (v = Array(r), a = 0; a < r; a++) v[a] = T;
+            }
+            if (!bh(_)) {
+              var L = _;
+              for (_ = Array(r), a = 0; a < r; a++) _[a] = L;
+            }
+            for (i.symbols = v, i.angles = _, i.colors = b, i.borderColors = p, a = 0; a < r; a++) o && (d = cY.isOpenSymbol(n.symbol[a])), d && (p[a] = b[a].slice(), b[a] = b[a].slice(), b[a][3] = 0);
+            for (i.opacity = t.opacity, i.markers = new Array(r), a = 0; a < r; a++) i.markers[a] = jze({ mx: i.symbols[a], ma: i.angles[a] }, t);
+          } else d ? (i.color = QF(n.color, "uint8"), i.color[3] = 0, i.borderColor = QF(n.color, "uint8")) : (i.color = QF(n.color, "uint8"), i.borderColor = QF(n.line.color, "uint8")), i.opacity = t.opacity * n.opacity, i.marker = jze({ mx: n.symbol, ma: n.angle }, t);
+          var x = 1, C = nOt(t, x), M;
+          if (f || h) {
+            var g = i.sizes = new Array(r), P = i.borderSizes = new Array(r), A = 0, z;
+            if (f) {
+              for (a = 0; a < r; a++) g[a] = C(n.size[a]), A += g[a];
+              z = A / r;
+            } else for (M = C(n.size), a = 0; a < r; a++) g[a] = M;
+            if (h) for (a = 0; a < r; a++) P[a] = n.line.width[a];
+            else for (M = n.line.width, a = 0; a < r; a++) P[a] = M;
+            i.sizeAvg = z;
+          } else i.size = C(n && n.size || 10), i.borderSizes = C(n.line.width);
+          return i;
+        }
+        function fY(e, t, r) {
+          var n = t.marker, i = {};
+          return r && (r.marker && r.marker.symbol ? i = hY(e, c5.extendFlat({}, n, r.marker)) : r.marker && (r.marker.size && (i.size = r.marker.size), r.marker.color && (i.colors = r.marker.color), r.marker.opacity !== void 0 && (i.opacity = r.marker.opacity))), i;
+        }
+        function Uze(e, t, r) {
+          var n = {};
+          if (!r) return n;
+          if (r.textfont) {
+            var i = { opacity: 1, text: t.text, texttemplate: t.texttemplate, textposition: t.textposition, textfont: c5.extendFlat({}, t.textfont) };
+            r.textfont && c5.extendFlat(i.textfont, r.textfont), n = Wze(e, i);
+          }
+          return n;
+        }
+        function Vze(e, t, r) {
+          var n = { capSize: t.width * 2 * r, lineWidth: t.thickness * r, color: t.color };
+          return t.copy_ystyle && (n = e.error_y), n;
+        }
+        var Gze = xk.SYMBOL_SDF_SIZE, aw = xk.SYMBOL_SIZE, Hze = xk.SYMBOL_STROKE, uY = {}, lOt = l5.symbolFuncs[0](aw * 0.05);
+        function jze(e, t) {
+          var r = e.mx;
+          if (r === "circle") return null;
+          var n, i, a = l5.symbolNumber(r), o = l5.symbolFuncs[a % 100], s = !!l5.symbolNoDot[a % 100], l = !!l5.symbolNoFill[a % 100], u = cY.isDotSymbol(r);
+          if (e.ma && (r += "_" + e.ma), uY[r]) return uY[r];
+          var c = l5.getMarkerAngle(e, t);
+          return u && !s ? n = o(aw * 1.1, c) + lOt : n = o(aw, c), i = rOt(n, { w: Gze, h: Gze, viewBox: [-aw, -aw, aw, aw], stroke: l ? Hze : -Hze }), uY[r] = i, i || null;
+        }
+        function uOt(e, t, r) {
+          var n = r.length, i = n / 2, a, o;
+          if (u5.hasLines(t) && i) if (t.line.shape === "hv") {
+            for (a = [], o = 0; o < i - 1; o++) isNaN(r[o * 2]) || isNaN(r[o * 2 + 1]) ? a.push(NaN, NaN, NaN, NaN) : (a.push(r[o * 2], r[o * 2 + 1]), !isNaN(r[o * 2 + 2]) && !isNaN(r[o * 2 + 3]) ? a.push(r[o * 2 + 2], r[o * 2 + 1]) : a.push(NaN, NaN));
+            a.push(r[n - 2], r[n - 1]);
+          } else if (t.line.shape === "hvh") {
+            for (a = [], o = 0; o < i - 1; o++) if (isNaN(r[o * 2]) || isNaN(r[o * 2 + 1]) || isNaN(r[o * 2 + 2]) || isNaN(r[o * 2 + 3])) !isNaN(r[o * 2]) && !isNaN(r[o * 2 + 1]) ? a.push(r[o * 2], r[o * 2 + 1]) : a.push(NaN, NaN), a.push(NaN, NaN);
+            else {
+              var s = (r[o * 2] + r[o * 2 + 2]) / 2;
+              a.push(r[o * 2], r[o * 2 + 1], s, r[o * 2 + 1], s, r[o * 2 + 3]);
+            }
+            a.push(r[n - 2], r[n - 1]);
+          } else if (t.line.shape === "vhv") {
+            for (a = [], o = 0; o < i - 1; o++) if (isNaN(r[o * 2]) || isNaN(r[o * 2 + 1]) || isNaN(r[o * 2 + 2]) || isNaN(r[o * 2 + 3])) !isNaN(r[o * 2]) && !isNaN(r[o * 2 + 1]) ? a.push(r[o * 2], r[o * 2 + 1]) : a.push(NaN, NaN), a.push(NaN, NaN);
+            else {
+              var l = (r[o * 2 + 1] + r[o * 2 + 3]) / 2;
+              a.push(r[o * 2], r[o * 2 + 1], r[o * 2], l, r[o * 2 + 2], l);
+            }
+            a.push(r[n - 2], r[n - 1]);
+          } else if (t.line.shape === "vh") {
+            for (a = [], o = 0; o < i - 1; o++) isNaN(r[o * 2]) || isNaN(r[o * 2 + 1]) ? a.push(NaN, NaN, NaN, NaN) : (a.push(r[o * 2], r[o * 2 + 1]), !isNaN(r[o * 2 + 2]) && !isNaN(r[o * 2 + 3]) ? a.push(r[o * 2], r[o * 2 + 3]) : a.push(NaN, NaN));
+            a.push(r[n - 2], r[n - 1]);
+          } else a = r;
+          var u = false;
+          for (o = 0; o < a.length; o++) if (isNaN(a[o])) {
+            u = true;
+            break;
+          }
+          var c = u || a.length > xk.TOO_MANY_POINTS || u5.hasMarkers(t) ? "rect" : "round";
+          if (u && t.connectgaps) {
+            var f = a[0], h = a[1];
+            for (o = 0; o < a.length; o += 2) isNaN(a[o]) || isNaN(a[o + 1]) ? (a[o] = f, a[o + 1] = h) : (f = a[o], h = a[o + 1]);
+          }
+          return { join: c, positions: a };
+        }
+        function cOt(e, t, r, n, i) {
+          var a = iOt.getComponentMethod("errorbars", "makeComputeError"), o = Oze.getFromId(e, t.xaxis, "x"), s = Oze.getFromId(e, t.yaxis, "y"), l = r.length / 2, u = {};
+          function c(f, h) {
+            var d = h._id.charAt(0), v = t["error_" + d];
+            if (v && v.visible && (h.type === "linear" || h.type === "log")) {
+              for (var _ = a(v), b = { x: 0, y: 1 }[d], p = { x: [0, 1, 2, 3], y: [2, 3, 0, 1] }[d], k = new Float64Array(4 * l), E = 1 / 0, T = -1 / 0, L = 0, x = 0; L < l; L++, x += 4) {
+                var C = f[L];
+                if (ez(C)) {
+                  var M = r[L * 2 + b], g = _(C, L), P = g[0], A = g[1];
+                  if (ez(P) && ez(A)) {
+                    var z = C - P, O = C + A;
+                    k[x + p[0]] = M - h.c2l(z), k[x + p[1]] = h.c2l(O) - M, k[x + p[2]] = 0, k[x + p[3]] = 0, E = Math.min(E, C - P), T = Math.max(T, C + A);
+                  }
+                }
+              }
+              u[d] = { positions: r, errors: k, _bnds: [E, T] };
+            }
+          }
+          return c(n, o), c(i, s), u;
+        }
+        function fOt(e, t, r, n) {
+          var i = t._length, a = {}, o;
+          if (u5.hasMarkers(t)) {
+            var s = r.font, l = r.align, u = r.baseline;
+            for (a.offset = new Array(i), o = 0; o < i; o++) {
+              var c = n.sizes ? n.sizes[o] : n.size, f = bh(s) ? s[o].size : s.size, h = bh(l) ? l.length > 1 ? l[o] : l[0] : l, d = bh(u) ? u.length > 1 ? u[o] : u[0] : u, v = Bze[h], _ = Bze[d], b = c ? c / 0.8 + 1 : 0, p = -_ * b - _ * 0.5;
+              a.offset[o] = [v * b / f, p / f];
+            }
+          }
+          return a;
+        }
+        Xze.exports = { style: sOt, markerStyle: hY, markerSelection: fY, linePositions: uOt, errorBarPositions: cOt, textPosition: fOt };
+      });
+      var dY = ye((xyr, Zze) => {
+        var tz = Dr();
+        Zze.exports = function(t, r) {
+          var n = r._scene, i = { count: 0, dirty: true, lineOptions: [], fillOptions: [], markerOptions: [], markerSelectedOptions: [], markerUnselectedOptions: [], errorXOptions: [], errorYOptions: [], textOptions: [], textSelectedOptions: [], textUnselectedOptions: [], selectBatch: [], unselectBatch: [] }, a = { fill2d: false, scatter2d: false, error2d: false, line2d: false, glText: false, select2d: false };
+          return r._scene || (n = r._scene = {}, n.init = function() {
+            tz.extendFlat(n, a, i);
+          }, n.init(), n.update = function(s) {
+            var l = tz.repeat(s, n.count);
+            if (n.fill2d && n.fill2d.update(l), n.scatter2d && n.scatter2d.update(l), n.line2d && n.line2d.update(l), n.error2d && n.error2d.update(l.concat(l)), n.select2d && n.select2d.update(l), n.glText) for (var u = 0; u < n.count; u++) n.glText[u].update(s);
+          }, n.draw = function() {
+            for (var s = n.count, l = n.fill2d, u = n.error2d, c = n.line2d, f = n.scatter2d, h = n.glText, d = n.select2d, v = n.selectBatch, _ = n.unselectBatch, b = 0; b < s; b++) {
+              if (l && n.fillOrder[b] && l.draw(n.fillOrder[b]), c && n.lineOptions[b] && c.draw(b), u && (n.errorXOptions[b] && u.draw(b), n.errorYOptions[b] && u.draw(b + s)), f && n.markerOptions[b]) if (_[b].length) {
+                var p = tz.repeat([], n.count);
+                p[b] = _[b], f.draw(p);
+              } else v[b].length || f.draw(b);
+              h[b] && n.textOptions[b] && h[b].render();
+            }
+            d && d.draw(v), n.dirty = false;
+          }, n.destroy = function() {
+            n.fill2d && n.fill2d.destroy && n.fill2d.destroy(), n.scatter2d && n.scatter2d.destroy && n.scatter2d.destroy(), n.error2d && n.error2d.destroy && n.error2d.destroy(), n.line2d && n.line2d.destroy && n.line2d.destroy(), n.select2d && n.select2d.destroy && n.select2d.destroy(), n.glText && n.glText.forEach(function(s) {
+              s.destroy && s.destroy();
+            }), n.lineOptions = null, n.fillOptions = null, n.markerOptions = null, n.markerSelectedOptions = null, n.markerUnselectedOptions = null, n.errorXOptions = null, n.errorYOptions = null, n.textOptions = null, n.textSelectedOptions = null, n.textUnselectedOptions = null, n.selectBatch = null, n.unselectBatch = null, r._scene = null;
+          }), n.dirty || tz.extendFlat(n, i), n;
+        };
+      });
+      var e7e = ye((byr, Qze) => {
+        var hOt = ZF(), f5 = Dr(), Yze = hf(), dOt = Mg().findExtremes, Kze = zg(), vY = q0(), vOt = vY.calcMarkerSize, pOt = vY.calcAxisExpansion, gOt = vY.setFirstScatter, mOt = z0(), h5 = ow(), yOt = dY(), Jze = fs().BADNUM, _Ot = px().TOO_MANY_POINTS;
+        Qze.exports = function(t, r) {
+          var n = t._fullLayout, i = r._xA = Yze.getFromId(t, r.xaxis, "x"), a = r._yA = Yze.getFromId(t, r.yaxis, "y"), o = n._plots[r.xaxis + r.yaxis], s = r._length, l = s >= _Ot, u = s * 2, c = {}, f, h = i.makeCalcdata(r, "x"), d = a.makeCalcdata(r, "y"), v = Kze(r, i, "x", h), _ = Kze(r, a, "y", d), b = v.vals, p = _.vals;
+          r._x = b, r._y = p, r.xperiodalignment && (r._origX = h, r._xStarts = v.starts, r._xEnds = v.ends), r.yperiodalignment && (r._origY = d, r._yStarts = _.starts, r._yEnds = _.ends);
+          var k = new Array(u), E = new Array(s);
+          for (f = 0; f < s; f++) k[f * 2] = b[f] === Jze ? NaN : b[f], k[f * 2 + 1] = p[f] === Jze ? NaN : p[f], E[f] = f;
+          if (i.type === "log") for (f = 0; f < u; f += 2) k[f] = i.c2l(k[f]);
+          if (a.type === "log") for (f = 1; f < u; f += 2) k[f] = a.c2l(k[f]);
+          l && i.type !== "log" && a.type !== "log" ? c.tree = hOt(k) : c.ids = E, mOt(t, r);
+          var T = xOt(t, o, r, k, b, p), L = yOt(t, o);
+          gOt(n, r);
+          var x;
+          return l ? T.marker && (x = T.marker.sizeAvg || Math.max(T.marker.size, 3)) : x = vOt(r, s), pOt(t, r, i, a, b, p, x), T.errorX && $ze(r, i, T.errorX), T.errorY && $ze(r, a, T.errorY), T.fill && !L.fill2d && (L.fill2d = true), T.marker && !L.scatter2d && (L.scatter2d = true), T.line && !L.line2d && (L.line2d = true), (T.errorX || T.errorY) && !L.error2d && (L.error2d = true), T.text && !L.glText && (L.glText = true), T.marker && (T.marker.snap = s), L.lineOptions.push(T.line), L.errorXOptions.push(T.errorX), L.errorYOptions.push(T.errorY), L.fillOptions.push(T.fill), L.markerOptions.push(T.marker), L.markerSelectedOptions.push(T.markerSel), L.markerUnselectedOptions.push(T.markerUnsel), L.textOptions.push(T.text), L.textSelectedOptions.push(T.textSel), L.textUnselectedOptions.push(T.textUnsel), L.selectBatch.push([]), L.unselectBatch.push([]), c._scene = L, c.index = L.count, c.x = b, c.y = p, c.positions = k, L.count++, [{ x: false, y: false, t: c, trace: r }];
+        };
+        function $ze(e, t, r) {
+          var n = e._extremes[t._id], i = dOt(t, r._bnds, { padded: true });
+          n.min = n.min.concat(i.min), n.max = n.max.concat(i.max);
+        }
+        function xOt(e, t, r, n, i, a) {
+          var o = h5.style(e, r);
+          if (o.marker && (o.marker.positions = n), o.line && n.length > 1 && f5.extendFlat(o.line, h5.linePositions(e, r, n)), o.errorX || o.errorY) {
+            var s = h5.errorBarPositions(e, r, n, i, a);
+            o.errorX && f5.extendFlat(o.errorX, s.x), o.errorY && f5.extendFlat(o.errorY, s.y);
+          }
+          return o.text && (f5.extendFlat(o.text, { positions: n }, h5.textPosition(e, r, o.text, o.marker)), f5.extendFlat(o.textSel, { positions: n }, h5.textPosition(e, r, o.text, o.markerSel)), f5.extendFlat(o.textUnsel, { positions: n }, h5.textPosition(e, r, o.text, o.markerUnsel))), o;
+        }
+      });
+      var pY = ye((wyr, r7e) => {
+        var t7e = Dr(), bOt = ka(), wOt = X1().DESELECTDIM;
+        function TOt(e) {
+          var t = e[0], r = t.trace, n = t.t, i = n._scene, a = n.index, o = i.selectBatch[a], s = i.unselectBatch[a], l = i.textOptions[a], u = i.textSelectedOptions[a] || {}, c = i.textUnselectedOptions[a] || {}, f = t7e.extendFlat({}, l), h, d;
+          if (o.length || s.length) {
+            var v = u.color, _ = c.color, b = l.color, p = t7e.isArrayOrTypedArray(b);
+            for (f.color = new Array(r._length), h = 0; h < o.length; h++) d = o[h], f.color[d] = v || (p ? b[d] : b);
+            for (h = 0; h < s.length; h++) {
+              d = s[h];
+              var k = p ? b[d] : b;
+              f.color[d] = _ || (v ? k : bOt.addOpacity(k, wOt));
+            }
+          }
+          i.glText[a].update(f);
+        }
+        r7e.exports = { styleTextSelection: TOt };
+      });
+      var gY = ye((Tyr, n7e) => {
+        var i7e = Ru(), AOt = pY().styleTextSelection;
+        n7e.exports = function(t, r) {
+          var n = t.cd, i = t.xaxis, a = t.yaxis, o = [], s = n[0].trace, l = n[0].t, u = s._length, c = l.x, f = l.y, h = l._scene, d = l.index;
+          if (!h) return o;
+          var v = i7e.hasText(s), _ = i7e.hasMarkers(s), b = !_ && !v;
+          if (s.visible !== true || b) return o;
+          var p = [], k = [];
+          if (r !== false && !r.degenerate) for (var E = 0; E < u; E++) r.contains([l.xpx[E], l.ypx[E]], false, E, t) ? (p.push(E), o.push({ pointNumber: E, x: i.c2d(c[E]), y: a.c2d(f[E]) })) : k.push(E);
+          if (_) {
+            var T = h.scatter2d;
+            if (!p.length && !k.length) {
+              var L = new Array(h.count);
+              L[d] = h.markerOptions[d], T.update.apply(T, L);
+            } else if (!h.selectBatch[d].length && !h.unselectBatch[d].length) {
+              var x = new Array(h.count);
+              x[d] = h.markerUnselectedOptions[d], T.update.apply(T, x);
+            }
+          }
+          return h.selectBatch[d] = p, h.unselectBatch[d] = k, v && AOt(n), o;
+        };
+      });
+      var o7e = ye((Ayr, a7e) => {
+        var SOt = jF();
+        a7e.exports = { moduleType: "trace", name: "scattergl", basePlotModule: mh(), categories: ["gl", "regl", "cartesian", "symbols", "errorBarsOK", "showLegend", "scatter-like"], attributes: gk(), supplyDefaults: UFe(), crossTraceDefaults: cU(), colorbar: $d(), formatLabels: GFe(), calc: e7e(), hoverPoints: SOt.hoverPoints, selectPoints: gY(), meta: {} };
+      });
+      var l7e = ye((Syr, iz) => {
+        var rz = rk();
+        iz.exports = s7e;
+        iz.exports.to = s7e;
+        iz.exports.from = MOt;
+        function s7e(e, t) {
+          t == null && (t = true);
+          var r = e[0], n = e[1], i = e[2], a = e[3];
+          a == null && (a = t ? 1 : 255), t && (r *= 255, n *= 255, i *= 255, a *= 255), r = rz(r, 0, 255) & 255, n = rz(n, 0, 255) & 255, i = rz(i, 0, 255) & 255, a = rz(a, 0, 255) & 255;
+          var o = r * 16777216 + (n << 16) + (i << 8) + a;
+          return o;
+        }
+        function MOt(e, t) {
+          e = +e;
+          var r = e >>> 24, n = (e & 16711680) >>> 16, i = (e & 65280) >>> 8, a = e & 255;
+          return t === false ? [r, n, i, a] : [r / 255, n / 255, i / 255, a / 255];
+        }
+      });
+      var Nh = ye((Myr, c7e) => {
+        var u7e = Object.getOwnPropertySymbols, EOt = Object.prototype.hasOwnProperty, kOt = Object.prototype.propertyIsEnumerable;
+        function COt(e) {
+          if (e == null) throw new TypeError("Object.assign cannot be called with null or undefined");
+          return Object(e);
+        }
+        function LOt() {
+          try {
+            if (!Object.assign) return false;
+            var e = new String("abc");
+            if (e[5] = "de", Object.getOwnPropertyNames(e)[0] === "5") return false;
+            for (var t = {}, r = 0; r < 10; r++) t["_" + String.fromCharCode(r)] = r;
+            var n = Object.getOwnPropertyNames(t).map(function(a) {
+              return t[a];
+            });
+            if (n.join("") !== "0123456789") return false;
+            var i = {};
+            return "abcdefghijklmnopqrst".split("").forEach(function(a) {
+              i[a] = a;
+            }), Object.keys(Object.assign({}, i)).join("") === "abcdefghijklmnopqrst";
+          } catch (a) {
+            return false;
+          }
+        }
+        c7e.exports = LOt() ? Object.assign : function(e, t) {
+          for (var r, n = COt(e), i, a = 1; a < arguments.length; a++) {
+            r = Object(arguments[a]);
+            for (var o in r) EOt.call(r, o) && (n[o] = r[o]);
+            if (u7e) {
+              i = u7e(r);
+              for (var s = 0; s < i.length; s++) kOt.call(r, i[s]) && (n[i[s]] = r[i[s]]);
+            }
+          }
+          return n;
+        };
+      });
+      var h7e = ye((Eyr, f7e) => {
+        f7e.exports = function(e) {
+          typeof e == "string" && (e = [e]);
+          for (var t = [].slice.call(arguments, 1), r = [], n = 0; n < e.length - 1; n++) r.push(e[n], t[n] || "");
+          return r.push(e[n]), r.join("");
+        };
+      });
+      var mY = ye((kyr, d7e) => {
+        d7e.exports = function(t, r, n) {
+          Array.isArray(n) || (n = [].slice.call(arguments, 2));
+          for (var i = 0, a = n.length; i < a; i++) {
+            var o = n[i];
+            for (var s in o) if (!(r[s] !== void 0 && !Array.isArray(r[s]) && t[s] === r[s]) && s in r) {
+              var l;
+              if (o[s] === true) l = r[s];
+              else {
+                if (o[s] === false) continue;
+                if (typeof o[s] == "function" && (l = o[s](r[s], t, r), l === void 0)) continue;
+              }
+              t[s] = l;
+            }
+          }
+          return t;
+        };
+      });
+      var p7e = ye((Cyr, v7e) => {
+        v7e.exports = typeof navigator != "undefined" && (/MSIE/.test(navigator.userAgent) || /Trident\//.test(navigator.appVersion));
+      });
+      var nz = ye((Lyr, d5) => {
+        d5.exports = bk;
+        d5.exports.float32 = d5.exports.float = bk;
+        d5.exports.fract32 = d5.exports.fract = POt;
+        var g7e = new Float32Array(1);
+        function POt(e, t) {
+          if (e.length) {
+            if (e instanceof Float32Array) return new Float32Array(e.length);
+            t instanceof Float32Array || (t = bk(e));
+            for (var r = 0, n = t.length; r < n; r++) t[r] = e[r] - t[r];
+            return t;
+          }
+          return bk(e - bk(e));
+        }
+        function bk(e) {
+          return e.length ? e instanceof Float32Array ? e : new Float32Array(e) : (g7e[0] = e, g7e[0]);
+        }
+      });
+      var _Y = ye((Pyr, _7e) => {
+        function IOt(e, t) {
+          var r = e == null ? null : typeof Symbol != "undefined" && e[Symbol.iterator] || e["@@iterator"];
+          if (r != null) {
+            var n, i, a, o, s = [], l = true, u = false;
+            try {
+              if (a = (r = r.call(e)).next, t === 0) ;
+              else for (; !(l = (n = a.call(r)).done) && (s.push(n.value), s.length !== t); l = true) ;
+            } catch (c) {
+              u = true, i = c;
+            } finally {
+              try {
+                if (!l && r.return != null && (o = r.return(), Object(o) !== o)) return;
+              } finally {
+                if (u) throw i;
+              }
+            }
+            return s;
+          }
+        }
+        function ROt(e, t) {
+          return zOt(e) || IOt(e, t) || y7e(e, t) || BOt();
+        }
+        function DOt(e) {
+          return FOt(e) || OOt(e) || y7e(e) || qOt();
+        }
+        function FOt(e) {
+          if (Array.isArray(e)) return yY(e);
+        }
+        function zOt(e) {
+          if (Array.isArray(e)) return e;
+        }
+        function OOt(e) {
+          if (typeof Symbol != "undefined" && e[Symbol.iterator] != null || e["@@iterator"] != null) return Array.from(e);
+        }
+        function y7e(e, t) {
+          if (e) {
+            if (typeof e == "string") return yY(e, t);
+            var r = Object.prototype.toString.call(e).slice(8, -1);
+            if (r === "Object" && e.constructor && (r = e.constructor.name), r === "Map" || r === "Set") return Array.from(e);
+            if (r === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(r)) return yY(e, t);
+          }
+        }
+        function yY(e, t) {
+          (t == null || t > e.length) && (t = e.length);
+          for (var r = 0, n = new Array(t); r < t; r++) n[r] = e[r];
+          return n;
+        }
+        function qOt() {
+          throw new TypeError(`Invalid attempt to spread non-iterable instance.
+In order to be iterable, non-array objects must have a [Symbol.iterator]() method.`);
+        }
+        function BOt() {
+          throw new TypeError(`Invalid attempt to destructure non-iterable instance.
+In order to be iterable, non-array objects must have a [Symbol.iterator]() method.`);
+        }
+        var NOt = ox(), UOt = rw(), VOt = l7e(), GOt = ZF(), sw = Nh(), az = h7e(), HOt = ey(), jOt = mY(), WOt = iw(), m7e = p7e(), oz = nz(), XOt = s5(), ZOt = nv;
+        function nv(e, t) {
+          var r = this;
+          if (!(this instanceof nv)) return new nv(e, t);
+          typeof e == "function" ? (t || (t = {}), t.regl = e) : (t = e, e = null), t && t.length && (t.positions = t), e = t.regl;
+          var n = e._gl, i, a = [], o = {}, s = [], l = [null], u = [null], c = 255, f = 100;
+          this.tooManyColors = m7e, i = e.texture({ data: new Uint8Array(c * 4), width: c, height: 1, type: "uint8", format: "rgba", wrapS: "clamp", wrapT: "clamp", mag: "nearest", min: "nearest" }), sw(this, { regl: e, gl: n, groups: s, markerCache: u, markerTextures: l, palette: a, paletteIds: o, paletteTexture: i, maxColors: c, maxSize: f, canvas: n.canvas }), this.update(t);
+          var h = { uniforms: { constPointSize: !!t.constPointSize, opacity: e.prop("opacity"), paletteSize: function(b, p) {
+            return [r.tooManyColors ? 0 : c, i.height];
+          }, pixelRatio: e.context("pixelRatio"), scale: e.prop("scale"), scaleFract: e.prop("scaleFract"), translate: e.prop("translate"), translateFract: e.prop("translateFract"), markerTexture: e.prop("markerTexture"), paletteTexture: i }, attributes: { x: function(b, p) {
+            return p.xAttr || { buffer: p.positionBuffer, stride: 8, offset: 0 };
+          }, y: function(b, p) {
+            return p.yAttr || { buffer: p.positionBuffer, stride: 8, offset: 4 };
+          }, xFract: function(b, p) {
+            return p.xAttr ? { constant: [0, 0] } : { buffer: p.positionFractBuffer, stride: 8, offset: 0 };
+          }, yFract: function(b, p) {
+            return p.yAttr ? { constant: [0, 0] } : { buffer: p.positionFractBuffer, stride: 8, offset: 4 };
+          }, size: function(b, p) {
+            return p.size.length ? { buffer: p.sizeBuffer, stride: 2, offset: 0 } : { constant: [Math.round(p.size * 255 / r.maxSize)] };
+          }, borderSize: function(b, p) {
+            return p.borderSize.length ? { buffer: p.sizeBuffer, stride: 2, offset: 1 } : { constant: [Math.round(p.borderSize * 255 / r.maxSize)] };
+          }, colorId: function(b, p) {
+            return p.color.length ? { buffer: p.colorBuffer, stride: r.tooManyColors ? 8 : 4, offset: 0 } : { constant: r.tooManyColors ? a.slice(p.color * 4, p.color * 4 + 4) : [p.color] };
+          }, borderColorId: function(b, p) {
+            return p.borderColor.length ? { buffer: p.colorBuffer, stride: r.tooManyColors ? 8 : 4, offset: r.tooManyColors ? 4 : 2 } : { constant: r.tooManyColors ? a.slice(p.borderColor * 4, p.borderColor * 4 + 4) : [p.borderColor] };
+          }, isActive: function(b, p) {
+            return p.activation === true ? { constant: [1] } : p.activation ? p.activation : { constant: [0] };
+          } }, blend: { enable: true, color: [0, 0, 0, 1], func: { srcRGB: "src alpha", dstRGB: "one minus src alpha", srcAlpha: "one minus dst alpha", dstAlpha: "one" } }, scissor: { enable: true, box: e.prop("viewport") }, viewport: e.prop("viewport"), stencil: { enable: false }, depth: { enable: false }, elements: e.prop("elements"), count: e.prop("count"), offset: e.prop("offset"), primitive: "points" }, d = sw({}, h);
+          d.frag = az([`precision highp float;
+#define GLSLIFY 1
+
+uniform float opacity;
+uniform sampler2D markerTexture;
+
+varying vec4 fragColor, fragBorderColor;
+varying float fragWidth, fragBorderColorLevel, fragColorLevel;
+
+float smoothStep(float x, float y) {
+  return 1.0 / (1.0 + exp(50.0*(x - y)));
+}
+
+void main() {
+  float dist = texture2D(markerTexture, gl_PointCoord).r, delta = fragWidth;
+
+  // max-distance alpha
+  if (dist < 0.003) discard;
+
+  // null-border case
+  if (fragBorderColorLevel == fragColorLevel || fragBorderColor.a == 0.) {
+    float colorAmt = smoothstep(.5 - delta, .5 + delta, dist);
+    gl_FragColor = vec4(fragColor.rgb, colorAmt * fragColor.a * opacity);
+  }
+  else {
+    float borderColorAmt = smoothstep(fragBorderColorLevel - delta, fragBorderColorLevel + delta, dist);
+    float colorAmt = smoothstep(fragColorLevel - delta, fragColorLevel + delta, dist);
+
+    vec4 color = fragBorderColor;
+    color.a *= borderColorAmt;
+    color = mix(color, fragColor, colorAmt);
+    color.a *= opacity;
+
+    gl_FragColor = color;
+  }
+
+}
+`]), d.vert = az([`precision highp float;
+#define GLSLIFY 1
+
+attribute float x, y, xFract, yFract;
+attribute float size, borderSize;
+attribute vec4 colorId, borderColorId;
+attribute float isActive;
+
+// \`invariant\` effectively turns off optimizations for the position.
+// We need this because -fast-math on M1 Macs is re-ordering
+// floating point operations in a way that causes floating point
+// precision limits to put points in the wrong locations.
+invariant gl_Position;
+
+uniform bool constPointSize;
+uniform float pixelRatio;
+uniform vec2 scale, scaleFract, translate, translateFract, paletteSize;
+uniform sampler2D paletteTexture;
+
+const float maxSize = 100.;
+const float borderLevel = .5;
+
+varying vec4 fragColor, fragBorderColor;
+varying float fragPointSize, fragBorderRadius, fragWidth, fragBorderColorLevel, fragColorLevel;
+
+float pointSizeScale = (constPointSize) ? 2. : pixelRatio;
+
+bool isDirect = (paletteSize.x < 1.);
+
+vec4 getColor(vec4 id) {
+  return isDirect ? id / 255. : texture2D(paletteTexture,
+    vec2(
+      (id.x + .5) / paletteSize.x,
+      (id.y + .5) / paletteSize.y
+    )
+  );
+}
+
+void main() {
+  // ignore inactive points
+  if (isActive == 0.) return;
+
+  vec2 position = vec2(x, y);
+  vec2 positionFract = vec2(xFract, yFract);
+
+  vec4 color = getColor(colorId);
+  vec4 borderColor = getColor(borderColorId);
+
+  float size = size * maxSize / 255.;
+  float borderSize = borderSize * maxSize / 255.;
+
+  gl_PointSize = 2. * size * pointSizeScale;
+  fragPointSize = size * pixelRatio;
+
+  vec2 pos = (position + translate) * scale
+      + (positionFract + translateFract) * scale
+      + (position + translate) * scaleFract
+      + (positionFract + translateFract) * scaleFract;
+
+  gl_Position = vec4(pos * 2. - 1., 0., 1.);
+
+  fragColor = color;
+  fragBorderColor = borderColor;
+  fragWidth = 1. / gl_PointSize;
+
+  fragBorderColorLevel = clamp(borderLevel - borderLevel * borderSize / size, 0., 1.);
+  fragColorLevel = clamp(borderLevel + (1. - borderLevel) * borderSize / size, 0., 1.);
+}
+`]), this.drawMarker = e(d);
+          var v = sw({}, h);
+          v.frag = az([`precision highp float;
+#define GLSLIFY 1
+
+varying vec4 fragColor, fragBorderColor;
+varying float fragBorderRadius, fragWidth;
+
+uniform float opacity;
+
+float smoothStep(float edge0, float edge1, float x) {
+	float t;
+	t = clamp((x - edge0) / (edge1 - edge0), 0.0, 1.0);
+	return t * t * (3.0 - 2.0 * t);
+}
+
+void main() {
+	float radius, alpha = 1.0, delta = fragWidth;
+
+	radius = length(2.0 * gl_PointCoord.xy - 1.0);
+
+	if (radius > 1.0 + delta) {
+		discard;
+	}
+
+	alpha -= smoothstep(1.0 - delta, 1.0 + delta, radius);
+
+	float borderRadius = fragBorderRadius;
+	float ratio = smoothstep(borderRadius - delta, borderRadius + delta, radius);
+	vec4 color = mix(fragColor, fragBorderColor, ratio);
+	color.a *= alpha * opacity;
+	gl_FragColor = color;
+}
+`]), v.vert = az([`precision highp float;
+#define GLSLIFY 1
+
+attribute float x, y, xFract, yFract;
+attribute float size, borderSize;
+attribute vec4 colorId, borderColorId;
+attribute float isActive;
+
+// \`invariant\` effectively turns off optimizations for the position.
+// We need this because -fast-math on M1 Macs is re-ordering
+// floating point operations in a way that causes floating point
+// precision limits to put points in the wrong locations.
+invariant gl_Position;
+
+uniform bool constPointSize;
+uniform float pixelRatio;
+uniform vec2 paletteSize, scale, scaleFract, translate, translateFract;
+uniform sampler2D paletteTexture;
+
+const float maxSize = 100.;
+
+varying vec4 fragColor, fragBorderColor;
+varying float fragBorderRadius, fragWidth;
+
+float pointSizeScale = (constPointSize) ? 2. : pixelRatio;
+
+bool isDirect = (paletteSize.x < 1.);
+
+vec4 getColor(vec4 id) {
+  return isDirect ? id / 255. : texture2D(paletteTexture,
+    vec2(
+      (id.x + .5) / paletteSize.x,
+      (id.y + .5) / paletteSize.y
+    )
+  );
+}
+
+void main() {
+  // ignore inactive points
+  if (isActive == 0.) return;
+
+  vec2 position = vec2(x, y);
+  vec2 positionFract = vec2(xFract, yFract);
+
+  vec4 color = getColor(colorId);
+  vec4 borderColor = getColor(borderColorId);
+
+  float size = size * maxSize / 255.;
+  float borderSize = borderSize * maxSize / 255.;
+
+  gl_PointSize = (size + borderSize) * pointSizeScale;
+
+  vec2 pos = (position + translate) * scale
+      + (positionFract + translateFract) * scale
+      + (position + translate) * scaleFract
+      + (positionFract + translateFract) * scaleFract;
+
+  gl_Position = vec4(pos * 2. - 1., 0., 1.);
+
+  fragBorderRadius = 1. - 2. * borderSize / (size + borderSize);
+  fragColor = color;
+  fragBorderColor = borderColor.a == 0. || borderSize == 0. ? vec4(color.rgb, 0.) : borderColor;
+  fragWidth = 1. / gl_PointSize;
+}
+`]), m7e && (v.frag = v.frag.replace("smoothstep", "smoothStep"), d.frag = d.frag.replace("smoothstep", "smoothStep")), this.drawCircle = e(v);
+        }
+        nv.defaults = { color: "black", borderColor: "transparent", borderSize: 0, size: 12, opacity: 1, marker: void 0, viewport: null, range: null, pixelSize: null, count: 0, offset: 0, bounds: null, positions: [], snap: 1e4 };
+        nv.prototype.render = function() {
+          return arguments.length && this.update.apply(this, arguments), this.draw(), this;
+        };
+        nv.prototype.draw = function() {
+          for (var e = this, t = arguments.length, r = new Array(t), n = 0; n < t; n++) r[n] = arguments[n];
+          var i = this.groups;
+          if (r.length === 1 && Array.isArray(r[0]) && (r[0][0] === null || Array.isArray(r[0][0])) && (r = r[0]), this.regl._refresh(), r.length) for (var a = 0; a < r.length; a++) this.drawItem(a, r[a]);
+          else i.forEach(function(o, s) {
+            e.drawItem(s);
+          });
+          return this;
+        };
+        nv.prototype.drawItem = function(e, t) {
+          var r = this.groups, n = r[e];
+          if (typeof t == "number" && (e = t, n = r[t], t = null), !!(n && n.count && n.opacity)) {
+            n.activation[0] && this.drawCircle(this.getMarkerDrawOptions(0, n, t));
+            for (var i = [], a = 1; a < n.activation.length; a++) !n.activation[a] || n.activation[a] !== true && !n.activation[a].data.length || i.push.apply(i, DOt(this.getMarkerDrawOptions(a, n, t)));
+            i.length && this.drawMarker(i);
+          }
+        };
+        nv.prototype.getMarkerDrawOptions = function(e, t, r) {
+          var n = t.range, i = t.tree, a = t.viewport, o = t.activation, s = t.selectionBuffer, l = t.count;
+          this.regl;
+          if (!i) return r ? [sw({}, t, { markerTexture: this.markerTextures[e], activation: o[e], count: r.length, elements: r, offset: 0 })] : [sw({}, t, { markerTexture: this.markerTextures[e], activation: o[e], offset: 0 })];
+          var c = [], f = i.range(n, { lod: true, px: [(n[2] - n[0]) / a.width, (n[3] - n[1]) / a.height] });
+          if (r) {
+            for (var h = o[e], d = h.data, v = new Uint8Array(l), _ = 0; _ < r.length; _++) {
+              var b = r[_];
+              v[b] = d ? d[b] : 1;
+            }
+            s.subdata(v);
+          }
+          for (var p = f.length; p--; ) {
+            var k = ROt(f[p], 2), E = k[0], T = k[1];
+            c.push(sw({}, t, { markerTexture: this.markerTextures[e], activation: r ? s : o[e], offset: E, count: T - E }));
+          }
+          return c;
+        };
+        nv.prototype.update = function() {
+          for (var e = this, t = arguments.length, r = new Array(t), n = 0; n < t; n++) r[n] = arguments[n];
+          if (r.length) {
+            r.length === 1 && Array.isArray(r[0]) && (r = r[0]);
+            var i = this.groups, a = this.gl, o = this.regl, s = this.maxSize, l = this.maxColors, u = this.palette;
+            this.groups = i = r.map(function(c, f) {
+              var h = i[f];
+              if (c === void 0) return h;
+              c === null ? c = { positions: null } : typeof c == "function" ? c = { ondraw: c } : typeof c[0] == "number" && (c = { positions: c }), c = HOt(c, { positions: "positions data points", snap: "snap cluster lod tree", size: "sizes size radius", borderSize: "borderSizes borderSize border-size bordersize borderWidth borderWidths border-width borderwidth stroke-width strokeWidth strokewidth outline", color: "colors color fill fill-color fillColor", borderColor: "borderColors borderColor stroke stroke-color strokeColor", marker: "markers marker shape", range: "range dataBox databox", viewport: "viewport viewPort viewBox viewbox", opacity: "opacity alpha transparency", bounds: "bound bounds boundaries limits", tooManyColors: "tooManyColors palette paletteMode optimizePalette enablePalette" }), c.positions === null && (c.positions = []), c.tooManyColors != null && (e.tooManyColors = c.tooManyColors), h || (i[f] = h = { id: f, scale: null, translate: null, scaleFract: null, translateFract: null, activation: [], selectionBuffer: o.buffer({ data: new Uint8Array(0), usage: "stream", type: "uint8" }), sizeBuffer: o.buffer({ data: new Uint8Array(0), usage: "dynamic", type: "uint8" }), colorBuffer: o.buffer({ data: new Uint8Array(0), usage: "dynamic", type: "uint8" }), positionBuffer: o.buffer({ data: new Uint8Array(0), usage: "dynamic", type: "float" }), positionFractBuffer: o.buffer({ data: new Uint8Array(0), usage: "dynamic", type: "float" }) }, c = sw({}, nv.defaults, c)), c.positions && !("marker" in c) && (c.marker = h.marker, delete h.marker), c.marker && !("positions" in c) && (c.positions = h.positions, delete h.positions);
+              var d = 0, v = 0;
+              if (jOt(h, c, [{ snap: true, size: function(j, N) {
+                return j == null && (j = nv.defaults.size), d += j && j.length ? 1 : 0, j;
+              }, borderSize: function(j, N) {
+                return j == null && (j = nv.defaults.borderSize), d += j && j.length ? 1 : 0, j;
+              }, opacity: parseFloat, color: function(j, N) {
+                return j == null && (j = nv.defaults.color), j = e.updateColor(j), v++, j;
+              }, borderColor: function(j, N) {
+                return j == null && (j = nv.defaults.borderColor), j = e.updateColor(j), v++, j;
+              }, bounds: function(j, N, H) {
+                return "range" in H || (H.range = null), j;
+              }, positions: function(j, N, H) {
+                var re = N.snap, oe = N.positionBuffer, _e = N.positionFractBuffer, Ce = N.selectionBuffer;
+                if (j.x || j.y) return j.x.length ? N.xAttr = { buffer: o.buffer(j.x), offset: 0, stride: 4, count: j.x.length } : N.xAttr = { buffer: j.x.buffer, offset: j.x.offset * 4 || 0, stride: (j.x.stride || 1) * 4, count: j.x.count }, j.y.length ? N.yAttr = { buffer: o.buffer(j.y), offset: 0, stride: 4, count: j.y.length } : N.yAttr = { buffer: j.y.buffer, offset: j.y.offset * 4 || 0, stride: (j.y.stride || 1) * 4, count: j.y.count }, N.count = Math.max(N.xAttr.count, N.yAttr.count), j;
+                j = WOt(j, "float64");
+                var Le = N.count = Math.floor(j.length / 2), ge = N.bounds = Le ? UOt(j, 2) : null;
+                if (!H.range && !N.range && (delete N.range, H.range = ge), !H.marker && !N.marker && (delete N.marker, H.marker = null), re && (re === true || Le > re) ? N.tree = GOt(j, { bounds: ge }) : re && re.length && (N.tree = re), N.tree) {
+                  var ie = { primitive: "points", usage: "static", data: N.tree, type: "uint32" };
+                  N.elements ? N.elements(ie) : N.elements = o.elements(ie);
+                }
+                var Se = oz.float32(j);
+                oe({ data: Se, usage: "dynamic" });
+                var Ee = oz.fract32(j, Se);
+                return _e({ data: Ee, usage: "dynamic" }), Ce({ data: new Uint8Array(Le), type: "uint8", usage: "stream" }), j;
+              } }, { marker: function(j, N, H) {
+                var re = N.activation;
+                if (re.forEach(function(Ee) {
+                  return Ee && Ee.destroy && Ee.destroy();
+                }), re.length = 0, !j || typeof j[0] == "number") {
+                  var oe = e.addMarker(j);
+                  re[oe] = true;
+                } else {
+                  for (var _e = [], Ce = 0, Le = Math.min(j.length, N.count); Ce < Le; Ce++) {
+                    var ge = e.addMarker(j[Ce]);
+                    _e[ge] || (_e[ge] = new Uint8Array(N.count)), _e[ge][Ce] = 1;
+                  }
+                  for (var ie = 0; ie < _e.length; ie++) if (_e[ie]) {
+                    var Se = { data: _e[ie], type: "uint8", usage: "static" };
+                    re[ie] ? re[ie](Se) : re[ie] = o.buffer(Se), re[ie].data = _e[ie];
+                  }
+                }
+                return j;
+              }, range: function(j, N, H) {
+                var re = N.bounds;
+                if (re) return j || (j = re), N.scale = [1 / (j[2] - j[0]), 1 / (j[3] - j[1])], N.translate = [-j[0], -j[1]], N.scaleFract = oz.fract(N.scale), N.translateFract = oz.fract(N.translate), j;
+              }, viewport: function(j) {
+                var N = XOt(j || [a.drawingBufferWidth, a.drawingBufferHeight]);
+                return N;
+              } }]), d) {
+                var _ = h, b = _.count, p = _.size, k = _.borderSize, E = _.sizeBuffer, T = new Uint8Array(b * 2);
+                if (p.length || k.length) for (var L = 0; L < b; L++) T[L * 2] = Math.round((p[L] == null ? p : p[L]) * 255 / s), T[L * 2 + 1] = Math.round((k[L] == null ? k : k[L]) * 255 / s);
+                E({ data: T, usage: "dynamic" });
+              }
+              if (v) {
+                var x = h, C = x.count, M = x.color, g = x.borderColor, P = x.colorBuffer, A;
+                if (e.tooManyColors) {
+                  if (M.length || g.length) {
+                    A = new Uint8Array(C * 8);
+                    for (var z = 0; z < C; z++) {
+                      var O = M[z];
+                      A[z * 8] = u[O * 4], A[z * 8 + 1] = u[O * 4 + 1], A[z * 8 + 2] = u[O * 4 + 2], A[z * 8 + 3] = u[O * 4 + 3];
+                      var U = g[z];
+                      A[z * 8 + 4] = u[U * 4], A[z * 8 + 5] = u[U * 4 + 1], A[z * 8 + 6] = u[U * 4 + 2], A[z * 8 + 7] = u[U * 4 + 3];
+                    }
+                  }
+                } else if (M.length || g.length) {
+                  A = new Uint8Array(C * 4 + 2);
+                  for (var G = 0; G < C; G++) M[G] != null && (A[G * 4] = M[G] % l, A[G * 4 + 1] = Math.floor(M[G] / l)), g[G] != null && (A[G * 4 + 2] = g[G] % l, A[G * 4 + 3] = Math.floor(g[G] / l));
+                }
+                P({ data: A || new Uint8Array(0), type: "uint8", usage: "dynamic" });
+              }
+              return h;
+            });
+          }
+        };
+        nv.prototype.addMarker = function(e) {
+          var t = this.markerTextures, r = this.regl, n = this.markerCache, i = e == null ? 0 : n.indexOf(e);
+          if (i >= 0) return i;
+          var a;
+          if (e instanceof Uint8Array || e instanceof Uint8ClampedArray) a = e;
+          else {
+            a = new Uint8Array(e.length);
+            for (var o = 0, s = e.length; o < s; o++) a[o] = e[o] * 255;
+          }
+          var l = Math.floor(Math.sqrt(a.length));
+          return i = t.length, n.push(e), t.push(r.texture({ channels: 1, data: a, radius: l, mag: "linear", min: "linear" })), i;
+        };
+        nv.prototype.updateColor = function(e) {
+          var t = this.paletteIds, r = this.palette, n = this.maxColors;
+          Array.isArray(e) || (e = [e]);
+          var i = [];
+          if (typeof e[0] == "number") {
+            var a = [];
+            if (Array.isArray(e)) for (var o = 0; o < e.length; o += 4) a.push(e.slice(o, o + 4));
+            else for (var s = 0; s < e.length; s += 4) a.push(e.subarray(s, s + 4));
+            e = a;
+          }
+          for (var l = 0; l < e.length; l++) {
+            var u = e[l];
+            u = NOt(u, "uint8");
+            var c = VOt(u, false);
+            if (t[c] == null) {
+              var f = r.length;
+              t[c] = Math.floor(f / 4), r[f] = u[0], r[f + 1] = u[1], r[f + 2] = u[2], r[f + 3] = u[3];
+            }
+            i[l] = t[c];
+          }
+          return !this.tooManyColors && r.length > n * 4 && (this.tooManyColors = true), this.updatePalette(r), i.length === 1 ? i[0] : i;
+        };
+        nv.prototype.updatePalette = function(e) {
+          if (!this.tooManyColors) {
+            var t = this.maxColors, r = this.paletteTexture, n = Math.ceil(e.length * 0.25 / t);
+            if (n > 1) {
+              e = e.slice();
+              for (var i = e.length * 0.25 % t; i < n * t; i++) e.push(0, 0, 0, 0);
+            }
+            r.height < n && r.resize(t, n), r.subimage({ width: Math.min(e.length * 0.25, t), height: n, data: e }, 0, 0);
+          }
+        };
+        nv.prototype.destroy = function() {
+          return this.groups.forEach(function(e) {
+            e.sizeBuffer.destroy(), e.positionBuffer.destroy(), e.positionFractBuffer.destroy(), e.colorBuffer.destroy(), e.activation.forEach(function(t) {
+              return t && t.destroy && t.destroy();
+            }), e.selectionBuffer.destroy(), e.elements && e.elements.destroy();
+          }), this.groups.length = 0, this.paletteTexture.destroy(), this.markerTextures.forEach(function(e) {
+            return e && e.destroy && e.destroy();
+          }), this;
+        };
+        var YOt = Nh(), KOt = function(t, r) {
+          var n = new ZOt(t, r), i = n.render.bind(n);
+          return YOt(i, { render: i, update: n.update.bind(n), draw: n.draw.bind(n), destroy: n.destroy.bind(n), regl: n.regl, gl: n.gl, canvas: n.gl.canvas, groups: n.groups, markers: n.markerCache, palette: n.palette }), i;
+        };
+        _7e.exports = KOt;
+      });
+      var A7e = ye((Iyr, TY) => {
+        TY.exports = uz;
+        TY.exports.default = uz;
+        function uz(e, t, r) {
+          r = r || 2;
+          var n = t && t.length, i = n ? t[0] * r : e.length, a = b7e(e, 0, i, r, true), o = [];
+          if (!a || a.next === a.prev) return o;
+          var s, l, u, c, f, h, d;
+          if (n && (a = tqt(e, t, a, r)), e.length > 80 * r) {
+            s = u = e[0], l = c = e[1];
+            for (var v = r; v < i; v += r) f = e[v], h = e[v + 1], f < s && (s = f), h < l && (l = h), f > u && (u = f), h > c && (c = h);
+            d = Math.max(u - s, c - l), d = d !== 0 ? 32767 / d : 0;
+          }
+          return wk(a, o, r, s, l, d, 0), o;
+        }
+        function b7e(e, t, r, n, i) {
+          var a, o;
+          if (i === wY(e, t, r, n) > 0) for (a = t; a < r; a += n) o = x7e(a, e[a], e[a + 1], o);
+          else for (a = r - n; a >= t; a -= n) o = x7e(a, e[a], e[a + 1], o);
+          return o && cz(o, o.next) && (Ak(o), o = o.next), o;
+        }
+        function lw(e, t) {
+          if (!e) return e;
+          t || (t = e);
+          var r = e, n;
+          do
+            if (n = false, !r.steiner && (cz(r, r.next) || wh(r.prev, r, r.next) === 0)) {
+              if (Ak(r), r = t = r.prev, r === r.next) break;
+              n = true;
+            } else r = r.next;
+          while (n || r !== t);
+          return t;
+        }
+        function wk(e, t, r, n, i, a, o) {
+          if (e) {
+            !o && a && oqt(e, n, i, a);
+            for (var s = e, l, u; e.prev !== e.next; ) {
+              if (l = e.prev, u = e.next, a ? $Ot(e, n, i, a) : JOt(e)) {
+                t.push(l.i / r | 0), t.push(e.i / r | 0), t.push(u.i / r | 0), Ak(e), e = u.next, s = u.next;
+                continue;
+              }
+              if (e = u, e === s) {
+                o ? o === 1 ? (e = QOt(lw(e), t, r), wk(e, t, r, n, i, a, 2)) : o === 2 && eqt(e, t, r, n, i, a) : wk(lw(e), t, r, n, i, a, 1);
+                break;
+              }
+            }
+          }
+        }
+        function JOt(e) {
+          var t = e.prev, r = e, n = e.next;
+          if (wh(t, r, n) >= 0) return false;
+          for (var i = t.x, a = r.x, o = n.x, s = t.y, l = r.y, u = n.y, c = i < a ? i < o ? i : o : a < o ? a : o, f = s < l ? s < u ? s : u : l < u ? l : u, h = i > a ? i > o ? i : o : a > o ? a : o, d = s > l ? s > u ? s : u : l > u ? l : u, v = n.next; v !== t; ) {
+            if (v.x >= c && v.x <= h && v.y >= f && v.y <= d && v5(i, s, a, l, o, u, v.x, v.y) && wh(v.prev, v, v.next) >= 0) return false;
+            v = v.next;
+          }
+          return true;
+        }
+        function $Ot(e, t, r, n) {
+          var i = e.prev, a = e, o = e.next;
+          if (wh(i, a, o) >= 0) return false;
+          for (var s = i.x, l = a.x, u = o.x, c = i.y, f = a.y, h = o.y, d = s < l ? s < u ? s : u : l < u ? l : u, v = c < f ? c < h ? c : h : f < h ? f : h, _ = s > l ? s > u ? s : u : l > u ? l : u, b = c > f ? c > h ? c : h : f > h ? f : h, p = xY(d, v, t, r, n), k = xY(_, b, t, r, n), E = e.prevZ, T = e.nextZ; E && E.z >= p && T && T.z <= k; ) {
+            if (E.x >= d && E.x <= _ && E.y >= v && E.y <= b && E !== i && E !== o && v5(s, c, l, f, u, h, E.x, E.y) && wh(E.prev, E, E.next) >= 0 || (E = E.prevZ, T.x >= d && T.x <= _ && T.y >= v && T.y <= b && T !== i && T !== o && v5(s, c, l, f, u, h, T.x, T.y) && wh(T.prev, T, T.next) >= 0)) return false;
+            T = T.nextZ;
+          }
+          for (; E && E.z >= p; ) {
+            if (E.x >= d && E.x <= _ && E.y >= v && E.y <= b && E !== i && E !== o && v5(s, c, l, f, u, h, E.x, E.y) && wh(E.prev, E, E.next) >= 0) return false;
+            E = E.prevZ;
+          }
+          for (; T && T.z <= k; ) {
+            if (T.x >= d && T.x <= _ && T.y >= v && T.y <= b && T !== i && T !== o && v5(s, c, l, f, u, h, T.x, T.y) && wh(T.prev, T, T.next) >= 0) return false;
+            T = T.nextZ;
+          }
+          return true;
+        }
+        function QOt(e, t, r) {
+          var n = e;
+          do {
+            var i = n.prev, a = n.next.next;
+            !cz(i, a) && w7e(i, n, n.next, a) && Tk(i, a) && Tk(a, i) && (t.push(i.i / r | 0), t.push(n.i / r | 0), t.push(a.i / r | 0), Ak(n), Ak(n.next), n = e = a), n = n.next;
+          } while (n !== e);
+          return lw(n);
+        }
+        function eqt(e, t, r, n, i, a) {
+          var o = e;
+          do {
+            for (var s = o.next.next; s !== o.prev; ) {
+              if (o.i !== s.i && uqt(o, s)) {
+                var l = T7e(o, s);
+                o = lw(o, o.next), l = lw(l, l.next), wk(o, t, r, n, i, a, 0), wk(l, t, r, n, i, a, 0);
+                return;
+              }
+              s = s.next;
+            }
+            o = o.next;
+          } while (o !== e);
+        }
+        function tqt(e, t, r, n) {
+          var i = [], a, o, s, l, u;
+          for (a = 0, o = t.length; a < o; a++) s = t[a] * n, l = a < o - 1 ? t[a + 1] * n : e.length, u = b7e(e, s, l, n, false), u === u.next && (u.steiner = true), i.push(lqt(u));
+          for (i.sort(rqt), a = 0; a < i.length; a++) r = iqt(i[a], r);
+          return r;
+        }
+        function rqt(e, t) {
+          return e.x - t.x;
+        }
+        function iqt(e, t) {
+          var r = nqt(e, t);
+          if (!r) return t;
+          var n = T7e(r, e);
+          return lw(n, n.next), lw(r, r.next);
+        }
+        function nqt(e, t) {
+          var r = t, n = e.x, i = e.y, a = -1 / 0, o;
+          do {
+            if (i <= r.y && i >= r.next.y && r.next.y !== r.y) {
+              var s = r.x + (i - r.y) * (r.next.x - r.x) / (r.next.y - r.y);
+              if (s <= n && s > a && (a = s, o = r.x < r.next.x ? r : r.next, s === n)) return o;
+            }
+            r = r.next;
+          } while (r !== t);
+          if (!o) return null;
+          var l = o, u = o.x, c = o.y, f = 1 / 0, h;
+          r = o;
+          do
+            n >= r.x && r.x >= u && n !== r.x && v5(i < c ? n : a, i, u, c, i < c ? a : n, i, r.x, r.y) && (h = Math.abs(i - r.y) / (n - r.x), Tk(r, e) && (h < f || h === f && (r.x > o.x || r.x === o.x && aqt(o, r))) && (o = r, f = h)), r = r.next;
+          while (r !== l);
+          return o;
+        }
+        function aqt(e, t) {
+          return wh(e.prev, e, t.prev) < 0 && wh(t.next, e, e.next) < 0;
+        }
+        function oqt(e, t, r, n) {
+          var i = e;
+          do
+            i.z === 0 && (i.z = xY(i.x, i.y, t, r, n)), i.prevZ = i.prev, i.nextZ = i.next, i = i.next;
+          while (i !== e);
+          i.prevZ.nextZ = null, i.prevZ = null, sqt(i);
+        }
+        function sqt(e) {
+          var t, r, n, i, a, o, s, l, u = 1;
+          do {
+            for (r = e, e = null, a = null, o = 0; r; ) {
+              for (o++, n = r, s = 0, t = 0; t < u && (s++, n = n.nextZ, !!n); t++) ;
+              for (l = u; s > 0 || l > 0 && n; ) s !== 0 && (l === 0 || !n || r.z <= n.z) ? (i = r, r = r.nextZ, s--) : (i = n, n = n.nextZ, l--), a ? a.nextZ = i : e = i, i.prevZ = a, a = i;
+              r = n;
+            }
+            a.nextZ = null, u *= 2;
+          } while (o > 1);
+          return e;
+        }
+        function xY(e, t, r, n, i) {
+          return e = (e - r) * i | 0, t = (t - n) * i | 0, e = (e | e << 8) & 16711935, e = (e | e << 4) & 252645135, e = (e | e << 2) & 858993459, e = (e | e << 1) & 1431655765, t = (t | t << 8) & 16711935, t = (t | t << 4) & 252645135, t = (t | t << 2) & 858993459, t = (t | t << 1) & 1431655765, e | t << 1;
+        }
+        function lqt(e) {
+          var t = e, r = e;
+          do
+            (t.x < r.x || t.x === r.x && t.y < r.y) && (r = t), t = t.next;
+          while (t !== e);
+          return r;
+        }
+        function v5(e, t, r, n, i, a, o, s) {
+          return (i - o) * (t - s) >= (e - o) * (a - s) && (e - o) * (n - s) >= (r - o) * (t - s) && (r - o) * (a - s) >= (i - o) * (n - s);
+        }
+        function uqt(e, t) {
+          return e.next.i !== t.i && e.prev.i !== t.i && !cqt(e, t) && (Tk(e, t) && Tk(t, e) && fqt(e, t) && (wh(e.prev, e, t.prev) || wh(e, t.prev, t)) || cz(e, t) && wh(e.prev, e, e.next) > 0 && wh(t.prev, t, t.next) > 0);
+        }
+        function wh(e, t, r) {
+          return (t.y - e.y) * (r.x - t.x) - (t.x - e.x) * (r.y - t.y);
+        }
+        function cz(e, t) {
+          return e.x === t.x && e.y === t.y;
+        }
+        function w7e(e, t, r, n) {
+          var i = lz(wh(e, t, r)), a = lz(wh(e, t, n)), o = lz(wh(r, n, e)), s = lz(wh(r, n, t));
+          return !!(i !== a && o !== s || i === 0 && sz(e, r, t) || a === 0 && sz(e, n, t) || o === 0 && sz(r, e, n) || s === 0 && sz(r, t, n));
+        }
+        function sz(e, t, r) {
+          return t.x <= Math.max(e.x, r.x) && t.x >= Math.min(e.x, r.x) && t.y <= Math.max(e.y, r.y) && t.y >= Math.min(e.y, r.y);
+        }
+        function lz(e) {
+          return e > 0 ? 1 : e < 0 ? -1 : 0;
+        }
+        function cqt(e, t) {
+          var r = e;
+          do {
+            if (r.i !== e.i && r.next.i !== e.i && r.i !== t.i && r.next.i !== t.i && w7e(r, r.next, e, t)) return true;
+            r = r.next;
+          } while (r !== e);
+          return false;
+        }
+        function Tk(e, t) {
+          return wh(e.prev, e, e.next) < 0 ? wh(e, t, e.next) >= 0 && wh(e, e.prev, t) >= 0 : wh(e, t, e.prev) < 0 || wh(e, e.next, t) < 0;
+        }
+        function fqt(e, t) {
+          var r = e, n = false, i = (e.x + t.x) / 2, a = (e.y + t.y) / 2;
+          do
+            r.y > a != r.next.y > a && r.next.y !== r.y && i < (r.next.x - r.x) * (a - r.y) / (r.next.y - r.y) + r.x && (n = !n), r = r.next;
+          while (r !== e);
+          return n;
+        }
+        function T7e(e, t) {
+          var r = new bY(e.i, e.x, e.y), n = new bY(t.i, t.x, t.y), i = e.next, a = t.prev;
+          return e.next = t, t.prev = e, r.next = i, i.prev = r, n.next = r, r.prev = n, a.next = n, n.prev = a, n;
+        }
+        function x7e(e, t, r, n) {
+          var i = new bY(e, t, r);
+          return n ? (i.next = n.next, i.prev = n, n.next.prev = i, n.next = i) : (i.prev = i, i.next = i), i;
+        }
+        function Ak(e) {
+          e.next.prev = e.prev, e.prev.next = e.next, e.prevZ && (e.prevZ.nextZ = e.nextZ), e.nextZ && (e.nextZ.prevZ = e.prevZ);
+        }
+        function bY(e, t, r) {
+          this.i = e, this.x = t, this.y = r, this.prev = null, this.next = null, this.z = 0, this.prevZ = null, this.nextZ = null, this.steiner = false;
+        }
+        uz.deviation = function(e, t, r, n) {
+          var i = t && t.length, a = i ? t[0] * r : e.length, o = Math.abs(wY(e, 0, a, r));
+          if (i) for (var s = 0, l = t.length; s < l; s++) {
+            var u = t[s] * r, c = s < l - 1 ? t[s + 1] * r : e.length;
+            o -= Math.abs(wY(e, u, c, r));
+          }
+          var f = 0;
+          for (s = 0; s < n.length; s += 3) {
+            var h = n[s] * r, d = n[s + 1] * r, v = n[s + 2] * r;
+            f += Math.abs((e[h] - e[v]) * (e[d + 1] - e[h + 1]) - (e[h] - e[d]) * (e[v + 1] - e[h + 1]));
+          }
+          return o === 0 && f === 0 ? 0 : Math.abs((f - o) / o);
+        };
+        function wY(e, t, r, n) {
+          for (var i = 0, a = t, o = r - n; a < r; a += n) i += (e[o] - e[a]) * (e[a + 1] + e[o + 1]), o = a;
+          return i;
+        }
+        uz.flatten = function(e) {
+          for (var t = e[0][0].length, r = { vertices: [], holes: [], dimensions: t }, n = 0, i = 0; i < e.length; i++) {
+            for (var a = 0; a < e[i].length; a++) for (var o = 0; o < t; o++) r.vertices.push(e[i][a][o]);
+            i > 0 && (n += e[i - 1].length, r.holes.push(n));
+          }
+          return r;
+        };
+      });
+      var M7e = ye((Ryr, S7e) => {
+        var hqt = rw();
+        S7e.exports = dqt;
+        function dqt(e, t, r) {
+          if (!e || e.length == null) throw Error("Argument should be an array");
+          t == null && (t = 1), r == null && (r = hqt(e, t));
+          for (var n = 0; n < t; n++) {
+            var i = r[t + n], a = r[n], o = n, s = e.length;
+            if (i === 1 / 0 && a === -1 / 0) for (o = n; o < s; o += t) e[o] = e[o] === i ? 1 : e[o] === a ? 0 : 0.5;
+            else if (i === 1 / 0) for (o = n; o < s; o += t) e[o] = e[o] === i ? 1 : 0;
+            else if (a === -1 / 0) for (o = n; o < s; o += t) e[o] = e[o] === a ? 0 : 1;
+            else {
+              var l = i - a;
+              for (o = n; o < s; o += t) isNaN(e[o]) || (e[o] = l === 0 ? 0.5 : (e[o] - a) / l);
+            }
+          }
+          return e;
+        }
+      });
+      var k7e = ye((Dyr, E7e) => {
+        E7e.exports = function() {
+          var e, t;
+          if (typeof WeakMap != "function") return false;
+          try {
+            e = new WeakMap([[t = {}, "one"], [{}, "two"], [{}, "three"]]);
+          } catch (r) {
+            return false;
+          }
+          return !(String(e) !== "[object WeakMap]" || typeof e.set != "function" || e.set({}, 1) !== e || typeof e.delete != "function" || typeof e.has != "function" || e.get(t) !== "one");
+        };
+      });
+      var L7e = ye((Fyr, C7e) => {
+        C7e.exports = function() {
+        };
+      });
+      var mx = ye((zyr, P7e) => {
+        var vqt = L7e()();
+        P7e.exports = function(e) {
+          return e !== vqt && e !== null;
+        };
+      });
+      var AY = ye((Oyr, R7e) => {
+        var pqt = Object.create, gqt = Object.getPrototypeOf, I7e = {};
+        R7e.exports = function() {
+          var e = Object.setPrototypeOf, t = arguments[0] || pqt;
+          return typeof e != "function" ? false : gqt(e(t(null), I7e)) === I7e;
+        };
+      });
+      var SY = ye((qyr, D7e) => {
+        var mqt = mx(), yqt = { function: true, object: true };
+        D7e.exports = function(e) {
+          return mqt(e) && yqt[typeof e] || false;
+        };
+      });
+      var c1 = ye((Byr, F7e) => {
+        var _qt = mx();
+        F7e.exports = function(e) {
+          if (!_qt(e)) throw new TypeError("Cannot use null or undefined");
+          return e;
+        };
+      });
+      var O7e = ye((Nyr, z7e) => {
+        var MY = Object.create, fz;
+        AY()() || (fz = EY());
+        z7e.exports = function() {
+          var e, t, r;
+          return !fz || fz.level !== 1 ? MY : (e = {}, t = {}, r = { configurable: false, enumerable: false, writable: true, value: void 0 }, Object.getOwnPropertyNames(Object.prototype).forEach(function(n) {
+            if (n === "__proto__") {
+              t[n] = { configurable: true, enumerable: false, writable: true, value: void 0 };
+              return;
+            }
+            t[n] = r;
+          }), Object.defineProperties(e, t), Object.defineProperty(fz, "nullPolyfill", { configurable: false, enumerable: false, writable: false, value: e }), function(n, i) {
+            return MY(n === null ? e : n, i);
+          });
+        }();
+      });
+      var EY = ye((Uyr, q7e) => {
+        var xqt = SY(), bqt = c1(), wqt = Object.prototype.isPrototypeOf, Tqt = Object.defineProperty, Aqt = { configurable: true, enumerable: false, writable: true, value: void 0 }, hz;
+        hz = function(e, t) {
+          if (bqt(e), t === null || xqt(t)) return e;
+          throw new TypeError("Prototype must be null or an object");
+        };
+        q7e.exports = function(e) {
+          var t, r;
+          return e ? (e.level === 2 ? e.set ? (r = e.set, t = function(n, i) {
+            return r.call(hz(n, i), i), n;
+          }) : t = function(n, i) {
+            return hz(n, i).__proto__ = i, n;
+          } : t = function n(i, a) {
+            var o;
+            return hz(i, a), o = wqt.call(n.nullPolyfill, i), o && delete n.nullPolyfill.__proto__, a === null && (a = n.nullPolyfill), i.__proto__ = a, o && Tqt(n.nullPolyfill, "__proto__", Aqt), i;
+          }, Object.defineProperty(t, "level", { configurable: false, enumerable: false, writable: false, value: e.level })) : null;
+        }(function() {
+          var e = /* @__PURE__ */ Object.create(null), t = {}, r, n = Object.getOwnPropertyDescriptor(Object.prototype, "__proto__");
+          if (n) {
+            try {
+              r = n.set, r.call(e, t);
+            } catch (i) {
+            }
+            if (Object.getPrototypeOf(e) === t) return { set: r, level: 2 };
+          }
+          return e.__proto__ = t, Object.getPrototypeOf(e) === t ? { level: 2 } : (e = {}, e.__proto__ = t, Object.getPrototypeOf(e) === t ? { level: 1 } : false);
+        }());
+        O7e();
+      });
+      var dz = ye((Vyr, B7e) => {
+        B7e.exports = AY()() ? Object.setPrototypeOf : EY();
+      });
+      var U7e = ye((Gyr, N7e) => {
+        var Sqt = SY();
+        N7e.exports = function(e) {
+          if (!Sqt(e)) throw new TypeError(e + " is not an Object");
+          return e;
+        };
+      });
+      var G7e = ye((Hyr, V7e) => {
+        var Mqt = /* @__PURE__ */ Object.create(null), Eqt = Math.random;
+        V7e.exports = function() {
+          var e;
+          do
+            e = Eqt().toString(36).slice(2);
+          while (Mqt[e]);
+          return e;
+        };
+      });
+      var uw = ye((jyr, H7e) => {
+        var kqt = void 0;
+        H7e.exports = function(e) {
+          return e !== kqt && e !== null;
+        };
+      });
+      var vz = ye((Wyr, j7e) => {
+        var Cqt = uw(), Lqt = { object: true, function: true, undefined: true };
+        j7e.exports = function(e) {
+          return Cqt(e) ? hasOwnProperty.call(Lqt, typeof e) : false;
+        };
+      });
+      var X7e = ye((Xyr, W7e) => {
+        var Pqt = vz();
+        W7e.exports = function(e) {
+          if (!Pqt(e)) return false;
+          try {
+            return e.constructor ? e.constructor.prototype === e : false;
+          } catch (t) {
+            return false;
+          }
+        };
+      });
+      var Y7e = ye((Zyr, Z7e) => {
+        var Iqt = X7e();
+        Z7e.exports = function(e) {
+          if (typeof e != "function" || !hasOwnProperty.call(e, "length")) return false;
+          try {
+            if (typeof e.length != "number" || typeof e.call != "function" || typeof e.apply != "function") return false;
+          } catch (t) {
+            return false;
+          }
+          return !Iqt(e);
+        };
+      });
+      var kY = ye((Yyr, K7e) => {
+        var Rqt = Y7e(), Dqt = /^\s*class[\s{/}]/, Fqt = Function.prototype.toString;
+        K7e.exports = function(e) {
+          return !(!Rqt(e) || Dqt.test(Fqt.call(e)));
+        };
+      });
+      var $7e = ye((Kyr, J7e) => {
+        J7e.exports = function() {
+          var e = Object.assign, t;
+          return typeof e != "function" ? false : (t = { foo: "raz" }, e(t, { bar: "dwa" }, { trzy: "trzy" }), t.foo + t.bar + t.trzy === "razdwatrzy");
+        };
+      });
+      var e9e = ye((Jyr, Q7e) => {
+        Q7e.exports = function() {
+          try {
+            return Object.keys("primitive"), true;
+          } catch (e) {
+            return false;
+          }
+        };
+      });
+      var r9e = ye(($yr, t9e) => {
+        var zqt = mx(), Oqt = Object.keys;
+        t9e.exports = function(e) {
+          return Oqt(zqt(e) ? Object(e) : e);
+        };
+      });
+      var n9e = ye((Qyr, i9e) => {
+        i9e.exports = e9e()() ? Object.keys : r9e();
+      });
+      var o9e = ye((e1r, a9e) => {
+        var qqt = n9e(), Bqt = c1(), Nqt = Math.max;
+        a9e.exports = function(e, t) {
+          var r, n, i = Nqt(arguments.length, 2), a;
+          for (e = Object(Bqt(e)), a = function(o) {
+            try {
+              e[o] = t[o];
+            } catch (s) {
+              r || (r = s);
+            }
+          }, n = 1; n < i; ++n) t = arguments[n], qqt(t).forEach(a);
+          if (r !== void 0) throw r;
+          return e;
+        };
+      });
+      var pz = ye((t1r, s9e) => {
+        s9e.exports = $7e()() ? Object.assign : o9e();
+      });
+      var CY = ye((r1r, l9e) => {
+        var Uqt = mx(), Vqt = Array.prototype.forEach, Gqt = Object.create, Hqt = function(e, t) {
+          var r;
+          for (r in e) t[r] = e[r];
+        };
+        l9e.exports = function(e) {
+          var t = Gqt(null);
+          return Vqt.call(arguments, function(r) {
+            Uqt(r) && Hqt(Object(r), t);
+          }), t;
+        };
+      });
+      var c9e = ye((i1r, u9e) => {
+        var LY = "razdwatrzy";
+        u9e.exports = function() {
+          return typeof LY.contains != "function" ? false : LY.contains("dwa") === true && LY.contains("foo") === false;
+        };
+      });
+      var h9e = ye((n1r, f9e) => {
+        var jqt = String.prototype.indexOf;
+        f9e.exports = function(e) {
+          return jqt.call(this, e, arguments[1]) > -1;
+        };
+      });
+      var PY = ye((a1r, d9e) => {
+        d9e.exports = c9e()() ? String.prototype.contains : h9e();
+      });
+      var f1 = ye((o1r, m9e) => {
+        var gz = uw(), v9e = kY(), p9e = pz(), g9e = CY(), Sk = PY(), Wqt = m9e.exports = function(e, t) {
+          var r, n, i, a, o;
+          return arguments.length < 2 || typeof e != "string" ? (a = t, t = e, e = null) : a = arguments[2], gz(e) ? (r = Sk.call(e, "c"), n = Sk.call(e, "e"), i = Sk.call(e, "w")) : (r = i = true, n = false), o = { value: t, configurable: r, enumerable: n, writable: i }, a ? p9e(g9e(a), o) : o;
+        };
+        Wqt.gs = function(e, t, r) {
+          var n, i, a, o;
+          return typeof e != "string" ? (a = r, r = t, t = e, e = null) : a = arguments[3], gz(t) ? v9e(t) ? gz(r) ? v9e(r) || (a = r, r = void 0) : r = void 0 : (a = t, t = r = void 0) : t = void 0, gz(e) ? (n = Sk.call(e, "c"), i = Sk.call(e, "e")) : (n = true, i = false), o = { get: t, set: r, configurable: n, enumerable: i }, a ? p9e(g9e(a), o) : o;
+        };
+      });
+      var Mk = ye((s1r, _9e) => {
+        var y9e = Object.prototype.toString, Xqt = y9e.call(/* @__PURE__ */ function() {
+          return arguments;
+        }());
+        _9e.exports = function(e) {
+          return y9e.call(e) === Xqt;
+        };
+      });
+      var Ek = ye((l1r, b9e) => {
+        var x9e = Object.prototype.toString, Zqt = x9e.call("");
+        b9e.exports = function(e) {
+          return typeof e == "string" || e && typeof e == "object" && (e instanceof String || x9e.call(e) === Zqt) || false;
+        };
+      });
+      var T9e = ye((u1r, w9e) => {
+        w9e.exports = function() {
+          return typeof globalThis != "object" || !globalThis ? false : globalThis.Array === Array;
+        };
+      });
+      var M9e = ye((c1r, S9e) => {
+        var A9e = function() {
+          if (typeof self == "object" && self) return self;
+          if (typeof window == "object" && window) return window;
+          throw new Error("Unable to resolve global `this`");
+        };
+        S9e.exports = function() {
+          if (this) return this;
+          try {
+            Object.defineProperty(Object.prototype, "__global__", { get: function() {
+              return this;
+            }, configurable: true });
+          } catch (e) {
+            return A9e();
+          }
+          try {
+            return __global__ || A9e();
+          } finally {
+            delete Object.prototype.__global__;
+          }
+        }();
+      });
+      var kk = ye((f1r, E9e) => {
+        E9e.exports = T9e()() ? globalThis : M9e();
+      });
+      var C9e = ye((h1r, k9e) => {
+        var Yqt = kk(), IY = { object: true, symbol: true };
+        k9e.exports = function() {
+          var e = Yqt.Symbol, t;
+          if (typeof e != "function") return false;
+          t = e("test symbol");
+          try {
+            String(t);
+          } catch (r) {
+            return false;
+          }
+          return !(!IY[typeof e.iterator] || !IY[typeof e.toPrimitive] || !IY[typeof e.toStringTag]);
+        };
+      });
+      var P9e = ye((d1r, L9e) => {
+        L9e.exports = function(e) {
+          return e ? typeof e == "symbol" ? true : !e.constructor || e.constructor.name !== "Symbol" ? false : e[e.constructor.toStringTag] === "Symbol" : false;
+        };
+      });
+      var RY = ye((v1r, I9e) => {
+        var Kqt = P9e();
+        I9e.exports = function(e) {
+          if (!Kqt(e)) throw new TypeError(e + " is not a symbol");
+          return e;
+        };
+      });
+      var O9e = ye((p1r, z9e) => {
+        var R9e = f1(), Jqt = Object.create, D9e = Object.defineProperty, $qt = Object.prototype, F9e = Jqt(null);
+        z9e.exports = function(e) {
+          for (var t = 0, r, n; F9e[e + (t || "")]; ) ++t;
+          return e += t || "", F9e[e] = true, r = "@@" + e, D9e($qt, r, R9e.gs(null, function(i) {
+            n || (n = true, D9e(this, r, R9e(i)), n = false);
+          })), r;
+        };
+      });
+      var B9e = ye((g1r, q9e) => {
+        var rm = f1(), Uh = kk().Symbol;
+        q9e.exports = function(e) {
+          return Object.defineProperties(e, { hasInstance: rm("", Uh && Uh.hasInstance || e("hasInstance")), isConcatSpreadable: rm("", Uh && Uh.isConcatSpreadable || e("isConcatSpreadable")), iterator: rm("", Uh && Uh.iterator || e("iterator")), match: rm("", Uh && Uh.match || e("match")), replace: rm("", Uh && Uh.replace || e("replace")), search: rm("", Uh && Uh.search || e("search")), species: rm("", Uh && Uh.species || e("species")), split: rm("", Uh && Uh.split || e("split")), toPrimitive: rm("", Uh && Uh.toPrimitive || e("toPrimitive")), toStringTag: rm("", Uh && Uh.toStringTag || e("toStringTag")), unscopables: rm("", Uh && Uh.unscopables || e("unscopables")) });
+        };
+      });
+      var V9e = ye((m1r, U9e) => {
+        var N9e = f1(), Qqt = RY(), Ck = /* @__PURE__ */ Object.create(null);
+        U9e.exports = function(e) {
+          return Object.defineProperties(e, { for: N9e(function(t) {
+            return Ck[t] ? Ck[t] : Ck[t] = e(String(t));
+          }), keyFor: N9e(function(t) {
+            var r;
+            Qqt(t);
+            for (r in Ck) if (Ck[r] === t) return r;
+          }) });
+        };
+      });
+      var j9e = ye((y1r, H9e) => {
+        var ty = f1(), DY = RY(), mz = kk().Symbol, eBt = O9e(), tBt = B9e(), rBt = V9e(), iBt = Object.create, FY = Object.defineProperties, yz = Object.defineProperty, Xv, p5, G9e;
+        if (typeof mz == "function") try {
+          String(mz()), G9e = true;
+        } catch (e) {
+        }
+        else mz = null;
+        p5 = function(t) {
+          if (this instanceof p5) throw new TypeError("Symbol is not a constructor");
+          return Xv(t);
+        };
+        H9e.exports = Xv = function e(t) {
+          var r;
+          if (this instanceof e) throw new TypeError("Symbol is not a constructor");
+          return G9e ? mz(t) : (r = iBt(p5.prototype), t = t === void 0 ? "" : String(t), FY(r, { __description__: ty("", t), __name__: ty("", eBt(t)) }));
+        };
+        tBt(Xv);
+        rBt(Xv);
+        FY(p5.prototype, { constructor: ty(Xv), toString: ty("", function() {
+          return this.__name__;
+        }) });
+        FY(Xv.prototype, { toString: ty(function() {
+          return "Symbol (" + DY(this).__description__ + ")";
+        }), valueOf: ty(function() {
+          return DY(this);
+        }) });
+        yz(Xv.prototype, Xv.toPrimitive, ty("", function() {
+          var e = DY(this);
+          return typeof e == "symbol" ? e : e.toString();
+        }));
+        yz(Xv.prototype, Xv.toStringTag, ty("c", "Symbol"));
+        yz(p5.prototype, Xv.toStringTag, ty("c", Xv.prototype[Xv.toStringTag]));
+        yz(p5.prototype, Xv.toPrimitive, ty("c", Xv.prototype[Xv.toPrimitive]));
+      });
+      var yx = ye((_1r, W9e) => {
+        W9e.exports = C9e()() ? kk().Symbol : j9e();
+      });
+      var Z9e = ye((x1r, X9e) => {
+        var nBt = c1();
+        X9e.exports = function() {
+          return nBt(this).length = 0, this;
+        };
+      });
+      var g5 = ye((b1r, Y9e) => {
+        Y9e.exports = function(e) {
+          if (typeof e != "function") throw new TypeError(e + " is not a function");
+          return e;
+        };
+      });
+      var J9e = ye((w1r, K9e) => {
+        var aBt = uw(), oBt = vz(), sBt = Object.prototype.toString;
+        K9e.exports = function(e) {
+          if (!aBt(e)) return null;
+          if (oBt(e)) {
+            var t = e.toString;
+            if (typeof t != "function" || t === sBt) return null;
+          }
+          try {
+            return "" + e;
+          } catch (r) {
+            return null;
+          }
+        };
+      });
+      var Q9e = ye((T1r, $9e) => {
+        $9e.exports = function(e) {
+          try {
+            return e.toString();
+          } catch (t) {
+            try {
+              return String(e);
+            } catch (r) {
+              return null;
+            }
+          }
+        };
+      });
+      var tOe = ye((A1r, eOe) => {
+        var lBt = Q9e(), uBt = /[\n\r\u2028\u2029]/g;
+        eOe.exports = function(e) {
+          var t = lBt(e);
+          return t === null ? "<Non-coercible to string value>" : (t.length > 100 && (t = t.slice(0, 99) + "…"), t = t.replace(uBt, function(r) {
+            switch (r) {
+              case `
+`:
+                return "\\n";
+              case "\r":
+                return "\\r";
+              case "\u2028":
+                return "\\u2028";
+              case "\u2029":
+                return "\\u2029";
+              default:
+                throw new Error("Unexpected character");
+            }
+          }), t);
+        };
+      });
+      var zY = ye((S1r, nOe) => {
+        var rOe = uw(), cBt = vz(), fBt = J9e(), hBt = tOe(), iOe = function(e, t) {
+          return e.replace("%v", hBt(t));
+        };
+        nOe.exports = function(e, t, r) {
+          if (!cBt(r)) throw new TypeError(iOe(t, e));
+          if (!rOe(e)) {
+            if ("default" in r) return r.default;
+            if (r.isOptional) return null;
+          }
+          var n = fBt(r.errorMessage);
+          throw rOe(n) || (n = t), new TypeError(iOe(n, e));
+        };
+      });
+      var oOe = ye((M1r, aOe) => {
+        var dBt = zY(), vBt = uw();
+        aOe.exports = function(e) {
+          return vBt(e) ? e : dBt(e, "Cannot use %v", arguments[1]);
+        };
+      });
+      var lOe = ye((E1r, sOe) => {
+        var pBt = zY(), gBt = kY();
+        sOe.exports = function(e) {
+          return gBt(e) ? e : pBt(e, "%v is not a plain function", arguments[1]);
+        };
+      });
+      var cOe = ye((k1r, uOe) => {
+        uOe.exports = function() {
+          var e = Array.from, t, r;
+          return typeof e != "function" ? false : (t = ["raz", "dwa"], r = e(t), !!(r && r !== t && r[1] === "dwa"));
+        };
+      });
+      var hOe = ye((C1r, fOe) => {
+        var mBt = Object.prototype.toString, yBt = RegExp.prototype.test.bind(/^[object [A-Za-z0-9]*Function]$/);
+        fOe.exports = function(e) {
+          return typeof e == "function" && yBt(mBt.call(e));
+        };
+      });
+      var vOe = ye((L1r, dOe) => {
+        dOe.exports = function() {
+          var e = Math.sign;
+          return typeof e != "function" ? false : e(10) === 1 && e(-20) === -1;
+        };
+      });
+      var gOe = ye((P1r, pOe) => {
+        pOe.exports = function(e) {
+          return e = Number(e), isNaN(e) || e === 0 ? e : e > 0 ? 1 : -1;
+        };
+      });
+      var yOe = ye((I1r, mOe) => {
+        mOe.exports = vOe()() ? Math.sign : gOe();
+      });
+      var xOe = ye((R1r, _Oe) => {
+        var _Bt = yOe(), xBt = Math.abs, bBt = Math.floor;
+        _Oe.exports = function(e) {
+          return isNaN(e) ? 0 : (e = Number(e), e === 0 || !isFinite(e) ? e : _Bt(e) * bBt(xBt(e)));
+        };
+      });
+      var wOe = ye((D1r, bOe) => {
+        var wBt = xOe(), TBt = Math.max;
+        bOe.exports = function(e) {
+          return TBt(0, wBt(e));
+        };
+      });
+      var MOe = ye((F1r, SOe) => {
+        var ABt = yx().iterator, SBt = Mk(), MBt = hOe(), EBt = wOe(), TOe = g5(), kBt = c1(), CBt = mx(), LBt = Ek(), AOe = Array.isArray, OY = Function.prototype.call, cw = { configurable: true, enumerable: true, writable: true, value: null }, qY = Object.defineProperty;
+        SOe.exports = function(e) {
+          var t = arguments[1], r = arguments[2], n, i, a, o, s, l, u, c, f, h;
+          if (e = Object(kBt(e)), CBt(t) && TOe(t), !this || this === Array || !MBt(this)) {
+            if (!t) {
+              if (SBt(e)) return s = e.length, s !== 1 ? Array.apply(null, e) : (o = new Array(1), o[0] = e[0], o);
+              if (AOe(e)) {
+                for (o = new Array(s = e.length), i = 0; i < s; ++i) o[i] = e[i];
+                return o;
+              }
+            }
+            o = [];
+          } else n = this;
+          if (!AOe(e)) {
+            if ((f = e[ABt]) !== void 0) {
+              for (u = TOe(f).call(e), n && (o = new n()), c = u.next(), i = 0; !c.done; ) h = t ? OY.call(t, r, c.value, i) : c.value, n ? (cw.value = h, qY(o, i, cw)) : o[i] = h, c = u.next(), ++i;
+              s = i;
+            } else if (LBt(e)) {
+              for (s = e.length, n && (o = new n()), i = 0, a = 0; i < s; ++i) h = e[i], i + 1 < s && (l = h.charCodeAt(0), l >= 55296 && l <= 56319 && (h += e[++i])), h = t ? OY.call(t, r, h, a) : h, n ? (cw.value = h, qY(o, a, cw)) : o[a] = h, ++a;
+              s = a;
+            }
+          }
+          if (s === void 0) for (s = EBt(e.length), n && (o = new n(s)), i = 0; i < s; ++i) h = t ? OY.call(t, r, e[i], i) : e[i], n ? (cw.value = h, qY(o, i, cw)) : o[i] = h;
+          return n && (cw.value = null, o.length = s), o;
+        };
+      });
+      var kOe = ye((z1r, EOe) => {
+        EOe.exports = cOe()() ? Array.from : MOe();
+      });
+      var LOe = ye((O1r, COe) => {
+        var PBt = kOe(), IBt = pz(), RBt = c1();
+        COe.exports = function(e) {
+          var t = Object(RBt(e)), r = arguments[1], n = Object(arguments[2]);
+          if (t !== e && !r) return t;
+          var i = {};
+          return r ? PBt(r, function(a) {
+            (n.ensure || a in e) && (i[a] = e[a]);
+          }) : IBt(i, e), i;
+        };
+      });
+      var ROe = ye((q1r, IOe) => {
+        var DBt = g5(), FBt = c1(), zBt = Function.prototype.bind, POe = Function.prototype.call, OBt = Object.keys, qBt = Object.prototype.propertyIsEnumerable;
+        IOe.exports = function(e, t) {
+          return function(r, n) {
+            var i, a = arguments[2], o = arguments[3];
+            return r = Object(FBt(r)), DBt(n), i = OBt(r), o && i.sort(typeof o == "function" ? zBt.call(o, r) : void 0), typeof e != "function" && (e = i[e]), POe.call(e, i, function(s, l) {
+              return qBt.call(r, s) ? POe.call(n, a, r[s], s, r, l) : t;
+            });
+          };
+        };
+      });
+      var FOe = ye((B1r, DOe) => {
+        DOe.exports = ROe()("forEach");
+      });
+      var OOe = ye((N1r, zOe) => {
+        var BBt = g5(), NBt = FOe(), UBt = Function.prototype.call;
+        zOe.exports = function(e, t) {
+          var r = {}, n = arguments[2];
+          return BBt(t), NBt(e, function(i, a, o, s) {
+            r[a] = UBt.call(t, n, i, a, o, s);
+          }), r;
+        };
+      });
+      var UOe = ye((U1r, NOe) => {
+        var VBt = uw(), GBt = oOe(), qOe = lOe(), HBt = LOe(), jBt = CY(), WBt = OOe(), XBt = Function.prototype.bind, ZBt = Object.defineProperty, YBt = Object.prototype.hasOwnProperty, BOe;
+        BOe = function(e, t, r) {
+          var n = GBt(t) && qOe(t.value), i;
+          return i = HBt(t), delete i.writable, delete i.value, i.get = function() {
+            return !r.overwriteDefinition && YBt.call(this, e) ? n : (t.value = XBt.call(n, r.resolveContext ? r.resolveContext(this) : this), ZBt(this, e, t), this[e]);
+          }, i;
+        };
+        NOe.exports = function(e) {
+          var t = jBt(arguments[1]);
+          return VBt(t.resolveContext) && qOe(t.resolveContext), WBt(e, function(r, n) {
+            return BOe(n, r, t);
+          });
+        };
+      });
+      var BY = ye((V1r, jOe) => {
+        var KBt = Z9e(), JBt = pz(), $Bt = g5(), QBt = c1(), qp = f1(), eNt = UOe(), VOe = yx(), GOe = Object.defineProperty, HOe = Object.defineProperties, Lk;
+        jOe.exports = Lk = function(e, t) {
+          if (!(this instanceof Lk)) throw new TypeError("Constructor requires 'new'");
+          HOe(this, { __list__: qp("w", QBt(e)), __context__: qp("w", t), __nextIndex__: qp("w", 0) }), t && ($Bt(t.on), t.on("_add", this._onAdd), t.on("_delete", this._onDelete), t.on("_clear", this._onClear));
+        };
+        delete Lk.prototype.constructor;
+        HOe(Lk.prototype, JBt({ _next: qp(function() {
+          var e;
+          if (this.__list__) {
+            if (this.__redo__ && (e = this.__redo__.shift(), e !== void 0)) return e;
+            if (this.__nextIndex__ < this.__list__.length) return this.__nextIndex__++;
+            this._unBind();
+          }
+        }), next: qp(function() {
+          return this._createResult(this._next());
+        }), _createResult: qp(function(e) {
+          return e === void 0 ? { done: true, value: void 0 } : { done: false, value: this._resolve(e) };
+        }), _resolve: qp(function(e) {
+          return this.__list__[e];
+        }), _unBind: qp(function() {
+          this.__list__ = null, delete this.__redo__, this.__context__ && (this.__context__.off("_add", this._onAdd), this.__context__.off("_delete", this._onDelete), this.__context__.off("_clear", this._onClear), this.__context__ = null);
+        }), toString: qp(function() {
+          return "[object " + (this[VOe.toStringTag] || "Object") + "]";
+        }) }, eNt({ _onAdd: qp(function(e) {
+          if (!(e >= this.__nextIndex__)) {
+            if (++this.__nextIndex__, !this.__redo__) {
+              GOe(this, "__redo__", qp("c", [e]));
+              return;
+            }
+            this.__redo__.forEach(function(t, r) {
+              t >= e && (this.__redo__[r] = ++t);
+            }, this), this.__redo__.push(e);
+          }
+        }), _onDelete: qp(function(e) {
+          var t;
+          e >= this.__nextIndex__ || (--this.__nextIndex__, this.__redo__ && (t = this.__redo__.indexOf(e), t !== -1 && this.__redo__.splice(t, 1), this.__redo__.forEach(function(r, n) {
+            r > e && (this.__redo__[n] = --r);
+          }, this)));
+        }), _onClear: qp(function() {
+          this.__redo__ && KBt.call(this.__redo__), this.__nextIndex__ = 0;
+        }) })));
+        GOe(Lk.prototype, VOe.iterator, qp(function() {
+          return this;
+        }));
+      });
+      var KOe = ye((G1r, YOe) => {
+        var WOe = dz(), XOe = PY(), NY = f1(), tNt = yx(), UY = BY(), ZOe = Object.defineProperty, m5;
+        m5 = YOe.exports = function(e, t) {
+          if (!(this instanceof m5)) throw new TypeError("Constructor requires 'new'");
+          UY.call(this, e), t ? XOe.call(t, "key+value") ? t = "key+value" : XOe.call(t, "key") ? t = "key" : t = "value" : t = "value", ZOe(this, "__kind__", NY("", t));
+        };
+        WOe && WOe(m5, UY);
+        delete m5.prototype.constructor;
+        m5.prototype = Object.create(UY.prototype, { _resolve: NY(function(e) {
+          return this.__kind__ === "value" ? this.__list__[e] : this.__kind__ === "key+value" ? [e, this.__list__[e]] : e;
+        }) });
+        ZOe(m5.prototype, tNt.toStringTag, NY("c", "Array Iterator"));
+      });
+      var eqe = ye((H1r, QOe) => {
+        var JOe = dz(), _z = f1(), rNt = yx(), VY = BY(), $Oe = Object.defineProperty, y5;
+        y5 = QOe.exports = function(e) {
+          if (!(this instanceof y5)) throw new TypeError("Constructor requires 'new'");
+          e = String(e), VY.call(this, e), $Oe(this, "__length__", _z("", e.length));
+        };
+        JOe && JOe(y5, VY);
+        delete y5.prototype.constructor;
+        y5.prototype = Object.create(VY.prototype, { _next: _z(function() {
+          if (this.__list__) {
+            if (this.__nextIndex__ < this.__length__) return this.__nextIndex__++;
+            this._unBind();
+          }
+        }), _resolve: _z(function(e) {
+          var t = this.__list__[e], r;
+          return this.__nextIndex__ === this.__length__ ? t : (r = t.charCodeAt(0), r >= 55296 && r <= 56319 ? t + this.__list__[this.__nextIndex__++] : t);
+        }) });
+        $Oe(y5.prototype, rNt.toStringTag, _z("c", "String Iterator"));
+      });
+      var rqe = ye((j1r, tqe) => {
+        var iNt = Mk(), nNt = mx(), aNt = Ek(), oNt = yx().iterator, sNt = Array.isArray;
+        tqe.exports = function(e) {
+          return nNt(e) ? sNt(e) || aNt(e) || iNt(e) ? true : typeof e[oNt] == "function" : false;
+        };
+      });
+      var nqe = ye((W1r, iqe) => {
+        var lNt = rqe();
+        iqe.exports = function(e) {
+          if (!lNt(e)) throw new TypeError(e + " is not iterable");
+          return e;
+        };
+      });
+      var GY = ye((X1r, sqe) => {
+        var uNt = Mk(), cNt = Ek(), aqe = KOe(), fNt = eqe(), hNt = nqe(), oqe = yx().iterator;
+        sqe.exports = function(e) {
+          return typeof hNt(e)[oqe] == "function" ? e[oqe]() : uNt(e) ? new aqe(e) : cNt(e) ? new fNt(e) : new aqe(e);
+        };
+      });
+      var uqe = ye((Z1r, lqe) => {
+        var dNt = Mk(), vNt = g5(), pNt = Ek(), gNt = GY(), mNt = Array.isArray, HY = Function.prototype.call, yNt = Array.prototype.some;
+        lqe.exports = function(e, t) {
+          var r, n = arguments[2], i, a, o, s, l, u, c;
+          if (mNt(e) || dNt(e) ? r = "array" : pNt(e) ? r = "string" : e = gNt(e), vNt(t), a = function() {
+            o = true;
+          }, r === "array") {
+            yNt.call(e, function(f) {
+              return HY.call(t, n, f, a), o;
+            });
+            return;
+          }
+          if (r === "string") {
+            for (l = e.length, s = 0; s < l && (u = e[s], s + 1 < l && (c = u.charCodeAt(0), c >= 55296 && c <= 56319 && (u += e[++s])), HY.call(t, n, u, a), !o); ++s) ;
+            return;
+          }
+          for (i = e.next(); !i.done; ) {
+            if (HY.call(t, n, i.value, a), o) return;
+            i = e.next();
+          }
+        };
+      });
+      var fqe = ye((Y1r, cqe) => {
+        cqe.exports = function() {
+          return typeof WeakMap != "function" ? false : Object.prototype.toString.call(/* @__PURE__ */ new WeakMap()) === "[object WeakMap]";
+        }();
+      });
+      var vqe = ye((K1r, dqe) => {
+        var _Nt = mx(), bz = dz(), xz = U7e(), xNt = c1(), bNt = G7e(), h1 = f1(), wNt = GY(), TNt = uqe(), ANt = yx().toStringTag, hqe = fqe(), SNt = Array.isArray, WY = Object.defineProperty, jY = Object.prototype.hasOwnProperty, MNt = Object.getPrototypeOf, _x;
+        dqe.exports = _x = function() {
+          var e = arguments[0], t;
+          if (!(this instanceof _x)) throw new TypeError("Constructor requires 'new'");
+          return t = hqe && bz && WeakMap !== _x ? bz(/* @__PURE__ */ new WeakMap(), MNt(this)) : this, _Nt(e) && (SNt(e) || (e = wNt(e))), WY(t, "__weakMapData__", h1("c", "$weakMap$" + bNt())), e && TNt(e, function(r) {
+            xNt(r), t.set(r[0], r[1]);
+          }), t;
+        };
+        hqe && (bz && bz(_x, WeakMap), _x.prototype = Object.create(WeakMap.prototype, { constructor: h1(_x) }));
+        Object.defineProperties(_x.prototype, { delete: h1(function(e) {
+          return jY.call(xz(e), this.__weakMapData__) ? (delete e[this.__weakMapData__], true) : false;
+        }), get: h1(function(e) {
+          if (jY.call(xz(e), this.__weakMapData__)) return e[this.__weakMapData__];
+        }), has: h1(function(e) {
+          return jY.call(xz(e), this.__weakMapData__);
+        }), set: h1(function(e, t) {
+          return WY(xz(e), this.__weakMapData__, h1("c", t)), this;
+        }), toString: h1(function() {
+          return "[object WeakMap]";
+        }) });
+        WY(_x.prototype, ANt, h1("c", "WeakMap"));
+      });
+      var XY = ye((J1r, pqe) => {
+        pqe.exports = k7e()() ? WeakMap : vqe();
+      });
+      var mqe = ye(($1r, gqe) => {
+        gqe.exports = function(e, t, r) {
+          if (typeof Array.prototype.findIndex == "function") return e.findIndex(t, r);
+          if (typeof t != "function") throw new TypeError("predicate must be a function");
+          var n = Object(e), i = n.length;
+          if (i === 0) return -1;
+          for (var a = 0; a < i; a++) if (t.call(r, n[a], a, n)) return a;
+          return -1;
+        };
+      });
+      var KY = ye((Q1r, xqe) => {
+        var wz = ox(), ENt = rw(), YY = Nh(), kNt = ey(), CNt = iw(), yqe = A7e(), LNt = M7e(), { float32: PNt, fract32: ZY } = nz(), INt = XY(), _qe = s5(), RNt = mqe(), DNt = `
+precision highp float;
+
+attribute vec2 aCoord, bCoord, aCoordFract, bCoordFract;
+attribute vec4 color;
+attribute float lineEnd, lineTop;
+
+uniform vec2 scale, scaleFract, translate, translateFract;
+uniform float thickness, pixelRatio, id, depth;
+uniform vec4 viewport;
+
+varying vec4 fragColor;
+varying vec2 tangent;
+
+vec2 project(vec2 position, vec2 positionFract, vec2 scale, vec2 scaleFract, vec2 translate, vec2 translateFract) {
+	// the order is important
+	return position * scale + translate
+       + positionFract * scale + translateFract
+       + position * scaleFract
+       + positionFract * scaleFract;
+}
+
+void main() {
+	float lineStart = 1. - lineEnd;
+	float lineOffset = lineTop * 2. - 1.;
+
+	vec2 diff = (bCoord + bCoordFract - aCoord - aCoordFract);
+	tangent = normalize(diff * scale * viewport.zw);
+	vec2 normal = vec2(-tangent.y, tangent.x);
+
+	vec2 position = project(aCoord, aCoordFract, scale, scaleFract, translate, translateFract) * lineStart
+		+ project(bCoord, bCoordFract, scale, scaleFract, translate, translateFract) * lineEnd
+
+		+ thickness * normal * .5 * lineOffset / viewport.zw;
+
+	gl_Position = vec4(position * 2.0 - 1.0, depth, 1);
+
+	fragColor = color / 255.;
+}
+`, FNt = `
+precision highp float;
+
+uniform float dashLength, pixelRatio, thickness, opacity, id;
+uniform sampler2D dashTexture;
+
+varying vec4 fragColor;
+varying vec2 tangent;
+
+void main() {
+	float alpha = 1.;
+
+	float t = fract(dot(tangent, gl_FragCoord.xy) / dashLength) * .5 + .25;
+	float dash = texture2D(dashTexture, vec2(t, .5)).r;
+
+	gl_FragColor = fragColor;
+	gl_FragColor.a *= alpha * opacity * dash;
+}
+`, zNt = `
+precision highp float;
+
+attribute vec2 position, positionFract;
+
+uniform vec4 color;
+uniform vec2 scale, scaleFract, translate, translateFract;
+uniform float pixelRatio, id;
+uniform vec4 viewport;
+uniform float opacity;
+
+varying vec4 fragColor;
+
+const float MAX_LINES = 256.;
+
+void main() {
+	float depth = (MAX_LINES - 4. - id) / (MAX_LINES);
+
+	vec2 position = position * scale + translate
+       + positionFract * scale + translateFract
+       + position * scaleFract
+       + positionFract * scaleFract;
+
+	gl_Position = vec4(position * 2.0 - 1.0, depth, 1);
+
+	fragColor = color / 255.;
+	fragColor.a *= opacity;
+}
+`, ONt = `
+precision highp float;
+varying vec4 fragColor;
+
+void main() {
+	gl_FragColor = fragColor;
+}
+`, qNt = `
+precision highp float;
+
+attribute vec2 aCoord, bCoord, nextCoord, prevCoord;
+attribute vec4 aColor, bColor;
+attribute float lineEnd, lineTop;
+
+uniform vec2 scale, translate;
+uniform float thickness, pixelRatio, id, depth;
+uniform vec4 viewport;
+uniform float miterLimit, miterMode;
+
+varying vec4 fragColor;
+varying vec4 startCutoff, endCutoff;
+varying vec2 tangent;
+varying vec2 startCoord, endCoord;
+varying float enableStartMiter, enableEndMiter;
+
+const float REVERSE_THRESHOLD = -.875;
+const float MIN_DIFF = 1e-6;
+
+// TODO: possible optimizations: avoid overcalculating all for vertices and calc just one instead
+// TODO: precalculate dot products, normalize things beforehead etc.
+// TODO: refactor to rectangular algorithm
+
+float distToLine(vec2 p, vec2 a, vec2 b) {
+	vec2 diff = b - a;
+	vec2 perp = normalize(vec2(-diff.y, diff.x));
+	return dot(p - a, perp);
+}
+
+bool isNaN( float val ){
+  return ( val < 0.0 || 0.0 < val || val == 0.0 ) ? false : true;
+}
+
+void main() {
+	vec2 aCoord = aCoord, bCoord = bCoord, prevCoord = prevCoord, nextCoord = nextCoord;
+
+  vec2 adjustedScale;
+  adjustedScale.x = (abs(scale.x) < MIN_DIFF) ? MIN_DIFF : scale.x;
+  adjustedScale.y = (abs(scale.y) < MIN_DIFF) ? MIN_DIFF : scale.y;
+
+  vec2 scaleRatio = adjustedScale * viewport.zw;
+	vec2 normalWidth = thickness / scaleRatio;
+
+	float lineStart = 1. - lineEnd;
+	float lineBot = 1. - lineTop;
+
+	fragColor = (lineStart * aColor + lineEnd * bColor) / 255.;
+
+	if (isNaN(aCoord.x) || isNaN(aCoord.y) || isNaN(bCoord.x) || isNaN(bCoord.y)) return;
+
+	if (aCoord == prevCoord) prevCoord = aCoord + normalize(bCoord - aCoord);
+	if (bCoord == nextCoord) nextCoord = bCoord - normalize(bCoord - aCoord);
+
+
+	vec2 prevDiff = aCoord - prevCoord;
+	vec2 currDiff = bCoord - aCoord;
+	vec2 nextDiff = nextCoord - bCoord;
+
+	vec2 prevTangent = normalize(prevDiff * scaleRatio);
+	vec2 currTangent = normalize(currDiff * scaleRatio);
+	vec2 nextTangent = normalize(nextDiff * scaleRatio);
+
+	vec2 prevNormal = vec2(-prevTangent.y, prevTangent.x);
+	vec2 currNormal = vec2(-currTangent.y, currTangent.x);
+	vec2 nextNormal = vec2(-nextTangent.y, nextTangent.x);
+
+	vec2 startJoinDirection = normalize(prevTangent - currTangent);
+	vec2 endJoinDirection = normalize(currTangent - nextTangent);
+
+	// collapsed/unidirectional segment cases
+	// FIXME: there should be more elegant solution
+	vec2 prevTanDiff = abs(prevTangent - currTangent);
+	vec2 nextTanDiff = abs(nextTangent - currTangent);
+	if (max(prevTanDiff.x, prevTanDiff.y) < MIN_DIFF) {
+		startJoinDirection = currNormal;
+	}
+	if (max(nextTanDiff.x, nextTanDiff.y) < MIN_DIFF) {
+		endJoinDirection = currNormal;
+	}
+	if (aCoord == bCoord) {
+		endJoinDirection = startJoinDirection;
+		currNormal = prevNormal;
+		currTangent = prevTangent;
+	}
+
+	tangent = currTangent;
+
+	//calculate join shifts relative to normals
+	float startJoinShift = dot(currNormal, startJoinDirection);
+	float endJoinShift = dot(currNormal, endJoinDirection);
+
+	float startMiterRatio = abs(1. / startJoinShift);
+	float endMiterRatio = abs(1. / endJoinShift);
+
+	vec2 startJoin = startJoinDirection * startMiterRatio;
+	vec2 endJoin = endJoinDirection * endMiterRatio;
+
+	vec2 startTopJoin, startBotJoin, endTopJoin, endBotJoin;
+	startTopJoin = sign(startJoinShift) * startJoin * .5;
+	startBotJoin = -startTopJoin;
+
+	endTopJoin = sign(endJoinShift) * endJoin * .5;
+	endBotJoin = -endTopJoin;
+
+	vec2 aTopCoord = aCoord + normalWidth * startTopJoin;
+	vec2 bTopCoord = bCoord + normalWidth * endTopJoin;
+	vec2 aBotCoord = aCoord + normalWidth * startBotJoin;
+	vec2 bBotCoord = bCoord + normalWidth * endBotJoin;
+
+	//miter anti-clipping
+	float baClipping = distToLine(bCoord, aCoord, aBotCoord) / dot(normalize(normalWidth * endBotJoin), normalize(normalWidth.yx * vec2(-startBotJoin.y, startBotJoin.x)));
+	float abClipping = distToLine(aCoord, bCoord, bTopCoord) / dot(normalize(normalWidth * startBotJoin), normalize(normalWidth.yx * vec2(-endBotJoin.y, endBotJoin.x)));
+
+	//prevent close to reverse direction switch
+	bool prevReverse = dot(currTangent, prevTangent) <= REVERSE_THRESHOLD && abs(dot(currTangent, prevNormal)) * min(length(prevDiff), length(currDiff)) <  length(normalWidth * currNormal);
+	bool nextReverse = dot(currTangent, nextTangent) <= REVERSE_THRESHOLD && abs(dot(currTangent, nextNormal)) * min(length(nextDiff), length(currDiff)) <  length(normalWidth * currNormal);
+
+	if (prevReverse) {
+		//make join rectangular
+		vec2 miterShift = normalWidth * startJoinDirection * miterLimit * .5;
+		float normalAdjust = 1. - min(miterLimit / startMiterRatio, 1.);
+		aBotCoord = aCoord + miterShift - normalAdjust * normalWidth * currNormal * .5;
+		aTopCoord = aCoord + miterShift + normalAdjust * normalWidth * currNormal * .5;
+	}
+	else if (!nextReverse && baClipping > 0. && baClipping < length(normalWidth * endBotJoin)) {
+		//handle miter clipping
+		bTopCoord -= normalWidth * endTopJoin;
+		bTopCoord += normalize(endTopJoin * normalWidth) * baClipping;
+	}
+
+	if (nextReverse) {
+		//make join rectangular
+		vec2 miterShift = normalWidth * endJoinDirection * miterLimit * .5;
+		float normalAdjust = 1. - min(miterLimit / endMiterRatio, 1.);
+		bBotCoord = bCoord + miterShift - normalAdjust * normalWidth * currNormal * .5;
+		bTopCoord = bCoord + miterShift + normalAdjust * normalWidth * currNormal * .5;
+	}
+	else if (!prevReverse && abClipping > 0. && abClipping < length(normalWidth * startBotJoin)) {
+		//handle miter clipping
+		aBotCoord -= normalWidth * startBotJoin;
+		aBotCoord += normalize(startBotJoin * normalWidth) * abClipping;
+	}
+
+	vec2 aTopPosition = (aTopCoord) * adjustedScale + translate;
+	vec2 aBotPosition = (aBotCoord) * adjustedScale + translate;
+
+	vec2 bTopPosition = (bTopCoord) * adjustedScale + translate;
+	vec2 bBotPosition = (bBotCoord) * adjustedScale + translate;
+
+	//position is normalized 0..1 coord on the screen
+	vec2 position = (aTopPosition * lineTop + aBotPosition * lineBot) * lineStart + (bTopPosition * lineTop + bBotPosition * lineBot) * lineEnd;
+
+	startCoord = aCoord * scaleRatio + translate * viewport.zw + viewport.xy;
+	endCoord = bCoord * scaleRatio + translate * viewport.zw + viewport.xy;
+
+	gl_Position = vec4(position  * 2.0 - 1.0, depth, 1);
+
+	enableStartMiter = step(dot(currTangent, prevTangent), .5);
+	enableEndMiter = step(dot(currTangent, nextTangent), .5);
+
+	//bevel miter cutoffs
+	if (miterMode == 1.) {
+		if (enableStartMiter == 1.) {
+			vec2 startMiterWidth = vec2(startJoinDirection) * thickness * miterLimit * .5;
+			startCutoff = vec4(aCoord, aCoord);
+			startCutoff.zw += vec2(-startJoinDirection.y, startJoinDirection.x) / scaleRatio;
+			startCutoff = startCutoff * scaleRatio.xyxy + translate.xyxy * viewport.zwzw;
+			startCutoff += viewport.xyxy;
+			startCutoff += startMiterWidth.xyxy;
+		}
+
+		if (enableEndMiter == 1.) {
+			vec2 endMiterWidth = vec2(endJoinDirection) * thickness * miterLimit * .5;
+			endCutoff = vec4(bCoord, bCoord);
+			endCutoff.zw += vec2(-endJoinDirection.y, endJoinDirection.x)  / scaleRatio;
+			endCutoff = endCutoff * scaleRatio.xyxy + translate.xyxy * viewport.zwzw;
+			endCutoff += viewport.xyxy;
+			endCutoff += endMiterWidth.xyxy;
+		}
+	}
+
+	//round miter cutoffs
+	else if (miterMode == 2.) {
+		if (enableStartMiter == 1.) {
+			vec2 startMiterWidth = vec2(startJoinDirection) * thickness * abs(dot(startJoinDirection, currNormal)) * .5;
+			startCutoff = vec4(aCoord, aCoord);
+			startCutoff.zw += vec2(-startJoinDirection.y, startJoinDirection.x) / scaleRatio;
+			startCutoff = startCutoff * scaleRatio.xyxy + translate.xyxy * viewport.zwzw;
+			startCutoff += viewport.xyxy;
+			startCutoff += startMiterWidth.xyxy;
+		}
+
+		if (enableEndMiter == 1.) {
+			vec2 endMiterWidth = vec2(endJoinDirection) * thickness * abs(dot(endJoinDirection, currNormal)) * .5;
+			endCutoff = vec4(bCoord, bCoord);
+			endCutoff.zw += vec2(-endJoinDirection.y, endJoinDirection.x)  / scaleRatio;
+			endCutoff = endCutoff * scaleRatio.xyxy + translate.xyxy * viewport.zwzw;
+			endCutoff += viewport.xyxy;
+			endCutoff += endMiterWidth.xyxy;
+		}
+	}
+}
+`, BNt = `
+precision highp float;
+
+uniform float dashLength, pixelRatio, thickness, opacity, id, miterMode;
+uniform sampler2D dashTexture;
+
+varying vec4 fragColor;
+varying vec2 tangent;
+varying vec4 startCutoff, endCutoff;
+varying vec2 startCoord, endCoord;
+varying float enableStartMiter, enableEndMiter;
+
+float distToLine(vec2 p, vec2 a, vec2 b) {
+	vec2 diff = b - a;
+	vec2 perp = normalize(vec2(-diff.y, diff.x));
+	return dot(p - a, perp);
+}
+
+void main() {
+	float alpha = 1., distToStart, distToEnd;
+	float cutoff = thickness * .5;
+
+	//bevel miter
+	if (miterMode == 1.) {
+		if (enableStartMiter == 1.) {
+			distToStart = distToLine(gl_FragCoord.xy, startCutoff.xy, startCutoff.zw);
+			if (distToStart < -1.) {
+				discard;
+				return;
+			}
+			alpha *= min(max(distToStart + 1., 0.), 1.);
+		}
+
+		if (enableEndMiter == 1.) {
+			distToEnd = distToLine(gl_FragCoord.xy, endCutoff.xy, endCutoff.zw);
+			if (distToEnd < -1.) {
+				discard;
+				return;
+			}
+			alpha *= min(max(distToEnd + 1., 0.), 1.);
+		}
+	}
+
+	// round miter
+	else if (miterMode == 2.) {
+		if (enableStartMiter == 1.) {
+			distToStart = distToLine(gl_FragCoord.xy, startCutoff.xy, startCutoff.zw);
+			if (distToStart < 0.) {
+				float radius = length(gl_FragCoord.xy - startCoord);
+
+				if(radius > cutoff + .5) {
+					discard;
+					return;
+				}
+
+				alpha -= smoothstep(cutoff - .5, cutoff + .5, radius);
+			}
+		}
+
+		if (enableEndMiter == 1.) {
+			distToEnd = distToLine(gl_FragCoord.xy, endCutoff.xy, endCutoff.zw);
+			if (distToEnd < 0.) {
+				float radius = length(gl_FragCoord.xy - endCoord);
+
+				if(radius > cutoff + .5) {
+					discard;
+					return;
+				}
+
+				alpha -= smoothstep(cutoff - .5, cutoff + .5, radius);
+			}
+		}
+	}
+
+	float t = fract(dot(tangent, gl_FragCoord.xy) / dashLength) * .5 + .25;
+	float dash = texture2D(dashTexture, vec2(t, .5)).r;
+
+	gl_FragColor = fragColor;
+	gl_FragColor.a *= alpha * opacity * dash;
+}
+`;
+        xqe.exports = Wc;
+        function Wc(e, t) {
+          if (!(this instanceof Wc)) return new Wc(e, t);
+          if (typeof e == "function" ? (t || (t = {}), t.regl = e) : t = e, t.length && (t.positions = t), e = t.regl, !e.hasExtension("ANGLE_instanced_arrays")) throw Error("regl-error2d: `ANGLE_instanced_arrays` extension should be enabled");
+          this.gl = e._gl, this.regl = e, this.passes = [], this.shaders = Wc.shaders.has(e) ? Wc.shaders.get(e) : Wc.shaders.set(e, Wc.createShaders(e)).get(e), this.update(t);
+        }
+        Wc.dashMult = 2;
+        Wc.maxPatternLength = 256;
+        Wc.precisionThreshold = 3e6;
+        Wc.maxPoints = 1e4;
+        Wc.maxLines = 2048;
+        Wc.shaders = new INt();
+        Wc.createShaders = function(e) {
+          let t = e.buffer({ usage: "static", type: "float", data: [0, 1, 0, 0, 1, 1, 1, 0] }), r = { primitive: "triangle strip", instances: e.prop("count"), count: 4, offset: 0, uniforms: { miterMode: (o, s) => s.join === "round" ? 2 : 1, miterLimit: e.prop("miterLimit"), scale: e.prop("scale"), scaleFract: e.prop("scaleFract"), translateFract: e.prop("translateFract"), translate: e.prop("translate"), thickness: e.prop("thickness"), dashTexture: e.prop("dashTexture"), opacity: e.prop("opacity"), pixelRatio: e.context("pixelRatio"), id: e.prop("id"), dashLength: e.prop("dashLength"), viewport: (o, s) => [s.viewport.x, s.viewport.y, o.viewportWidth, o.viewportHeight], depth: e.prop("depth") }, blend: { enable: true, color: [0, 0, 0, 0], equation: { rgb: "add", alpha: "add" }, func: { srcRGB: "src alpha", dstRGB: "one minus src alpha", srcAlpha: "one minus dst alpha", dstAlpha: "one" } }, depth: { enable: (o, s) => !s.overlay }, stencil: { enable: false }, scissor: { enable: true, box: e.prop("viewport") }, viewport: e.prop("viewport") }, n = e(YY({ vert: DNt, frag: FNt, attributes: { lineEnd: { buffer: t, divisor: 0, stride: 8, offset: 0 }, lineTop: { buffer: t, divisor: 0, stride: 8, offset: 4 }, aCoord: { buffer: e.prop("positionBuffer"), stride: 8, offset: 8, divisor: 1 }, bCoord: { buffer: e.prop("positionBuffer"), stride: 8, offset: 16, divisor: 1 }, aCoordFract: { buffer: e.prop("positionFractBuffer"), stride: 8, offset: 8, divisor: 1 }, bCoordFract: { buffer: e.prop("positionFractBuffer"), stride: 8, offset: 16, divisor: 1 }, color: { buffer: e.prop("colorBuffer"), stride: 4, offset: 0, divisor: 1 } } }, r)), i;
+          try {
+            i = e(YY({ cull: { enable: true, face: "back" }, vert: qNt, frag: BNt, attributes: { lineEnd: { buffer: t, divisor: 0, stride: 8, offset: 0 }, lineTop: { buffer: t, divisor: 0, stride: 8, offset: 4 }, aColor: { buffer: e.prop("colorBuffer"), stride: 4, offset: 0, divisor: 1 }, bColor: { buffer: e.prop("colorBuffer"), stride: 4, offset: 4, divisor: 1 }, prevCoord: { buffer: e.prop("positionBuffer"), stride: 8, offset: 0, divisor: 1 }, aCoord: { buffer: e.prop("positionBuffer"), stride: 8, offset: 8, divisor: 1 }, bCoord: { buffer: e.prop("positionBuffer"), stride: 8, offset: 16, divisor: 1 }, nextCoord: { buffer: e.prop("positionBuffer"), stride: 8, offset: 24, divisor: 1 } } }, r));
+          } catch (o) {
+            i = n;
+          }
+          return { fill: e({ primitive: "triangle", elements: (o, s) => s.triangles, offset: 0, vert: zNt, frag: ONt, uniforms: { scale: e.prop("scale"), color: e.prop("fill"), scaleFract: e.prop("scaleFract"), translateFract: e.prop("translateFract"), translate: e.prop("translate"), opacity: e.prop("opacity"), pixelRatio: e.context("pixelRatio"), id: e.prop("id"), viewport: (o, s) => [s.viewport.x, s.viewport.y, o.viewportWidth, o.viewportHeight] }, attributes: { position: { buffer: e.prop("positionBuffer"), stride: 8, offset: 8 }, positionFract: { buffer: e.prop("positionFractBuffer"), stride: 8, offset: 8 } }, blend: r.blend, depth: { enable: false }, scissor: r.scissor, stencil: r.stencil, viewport: r.viewport }), rect: n, miter: i };
+        };
+        Wc.defaults = { dashes: null, join: "miter", miterLimit: 1, thickness: 10, cap: "square", color: "black", opacity: 1, overlay: false, viewport: null, range: null, close: false, fill: null };
+        Wc.prototype.render = function(...e) {
+          e.length && this.update(...e), this.draw();
+        };
+        Wc.prototype.draw = function(...e) {
+          return (e.length ? e : this.passes).forEach((t, r) => {
+            if (t && Array.isArray(t)) return this.draw(...t);
+            typeof t == "number" && (t = this.passes[t]), t && t.count > 1 && t.opacity && (this.regl._refresh(), t.fill && t.triangles && t.triangles.length > 2 && this.shaders.fill(t), t.thickness && (t.scale[0] * t.viewport.width > Wc.precisionThreshold || t.scale[1] * t.viewport.height > Wc.precisionThreshold ? this.shaders.rect(t) : t.join === "rect" || !t.join && (t.thickness <= 2 || t.count >= Wc.maxPoints) ? this.shaders.rect(t) : this.shaders.miter(t)));
+          }), this;
+        };
+        Wc.prototype.update = function(e) {
+          if (!e) return;
+          e.length != null ? typeof e[0] == "number" && (e = [{ positions: e }]) : Array.isArray(e) || (e = [e]);
+          let { regl: t, gl: r } = this;
+          if (e.forEach((i, a) => {
+            let o = this.passes[a];
+            if (i !== void 0) {
+              if (i === null) {
+                this.passes[a] = null;
+                return;
+              }
+              if (typeof i[0] == "number" && (i = { positions: i }), i = kNt(i, { positions: "positions points data coords", thickness: "thickness lineWidth lineWidths line-width linewidth width stroke-width strokewidth strokeWidth", join: "lineJoin linejoin join type mode", miterLimit: "miterlimit miterLimit", dashes: "dash dashes dasharray dash-array dashArray", color: "color colour stroke colors colours stroke-color strokeColor", fill: "fill fill-color fillColor", opacity: "alpha opacity", overlay: "overlay crease overlap intersect", close: "closed close closed-path closePath", range: "range dataBox", viewport: "viewport viewBox", hole: "holes hole hollow", splitNull: "splitNull" }), o || (this.passes[a] = o = { id: a, scale: null, scaleFract: null, translate: null, translateFract: null, count: 0, hole: [], depth: 0, dashLength: 1, dashTexture: t.texture({ channels: 1, data: new Uint8Array([255]), width: 1, height: 1, mag: "linear", min: "linear" }), colorBuffer: t.buffer({ usage: "dynamic", type: "uint8", data: new Uint8Array() }), positionBuffer: t.buffer({ usage: "dynamic", type: "float", data: new Uint8Array() }), positionFractBuffer: t.buffer({ usage: "dynamic", type: "float", data: new Uint8Array() }) }, i = YY({}, Wc.defaults, i)), i.thickness != null && (o.thickness = parseFloat(i.thickness)), i.opacity != null && (o.opacity = parseFloat(i.opacity)), i.miterLimit != null && (o.miterLimit = parseFloat(i.miterLimit)), i.overlay != null && (o.overlay = !!i.overlay, a < Wc.maxLines && (o.depth = 2 * (Wc.maxLines - 1 - a % Wc.maxLines) / Wc.maxLines - 1)), i.join != null && (o.join = i.join), i.hole != null && (o.hole = i.hole), i.fill != null && (o.fill = i.fill ? wz(i.fill, "uint8") : null), i.viewport != null && (o.viewport = _qe(i.viewport)), o.viewport || (o.viewport = _qe([r.drawingBufferWidth, r.drawingBufferHeight])), i.close != null && (o.close = i.close), i.positions === null && (i.positions = []), i.positions) {
+                let u, c;
+                if (i.positions.x && i.positions.y) {
+                  let v = i.positions.x, _ = i.positions.y;
+                  c = o.count = Math.max(v.length, _.length), u = new Float64Array(c * 2);
+                  for (let b = 0; b < c; b++) u[b * 2] = v[b], u[b * 2 + 1] = _[b];
+                } else u = CNt(i.positions, "float64"), c = o.count = Math.floor(u.length / 2);
+                let f = o.bounds = ENt(u, 2);
+                if (o.fill) {
+                  let v = [], _ = {}, b = 0;
+                  for (let p = 0, k = 0, E = o.count; p < E; p++) {
+                    let T = u[p * 2], L = u[p * 2 + 1];
+                    isNaN(T) || isNaN(L) || T == null || L == null ? (T = u[b * 2], L = u[b * 2 + 1], _[p] = b) : b = p, v[k++] = T, v[k++] = L;
+                  }
+                  if (i.splitNull) {
+                    o.count - 1 in _ || (_[o.count] = o.count - 1);
+                    let p = Object.keys(_).map(Number).sort((L, x) => L - x), k = [], E = 0, T = o.hole != null ? o.hole[0] : null;
+                    if (T != null) {
+                      let L = RNt(p, (x) => x >= T);
+                      p = p.slice(0, L), p.push(T);
+                    }
+                    for (let L = 0; L < p.length; L++) {
+                      let x = v.slice(E * 2, p[L] * 2).concat(T ? v.slice(T * 2) : []), C = (o.hole || []).map((g) => g - T + (p[L] - E)), M = yqe(x, C);
+                      M = M.map((g) => g + E + (g + E < p[L] ? 0 : T - p[L])), k.push(...M), E = p[L] + 1;
+                    }
+                    for (let L = 0, x = k.length; L < x; L++) _[k[L]] != null && (k[L] = _[k[L]]);
+                    o.triangles = k;
+                  } else {
+                    let p = yqe(v, o.hole || []);
+                    for (let k = 0, E = p.length; k < E; k++) _[p[k]] != null && (p[k] = _[p[k]]);
+                    o.triangles = p;
+                  }
+                }
+                let h = new Float64Array(u);
+                LNt(h, 2, f);
+                let d = new Float64Array(c * 2 + 6);
+                o.close ? u[0] === u[c * 2 - 2] && u[1] === u[c * 2 - 1] ? (d[0] = h[c * 2 - 4], d[1] = h[c * 2 - 3]) : (d[0] = h[c * 2 - 2], d[1] = h[c * 2 - 1]) : (d[0] = h[0], d[1] = h[1]), d.set(h, 2), o.close ? u[0] === u[c * 2 - 2] && u[1] === u[c * 2 - 1] ? (d[c * 2 + 2] = h[2], d[c * 2 + 3] = h[3], o.count -= 1) : (d[c * 2 + 2] = h[0], d[c * 2 + 3] = h[1], d[c * 2 + 4] = h[2], d[c * 2 + 5] = h[3]) : (d[c * 2 + 2] = h[c * 2 - 2], d[c * 2 + 3] = h[c * 2 - 1], d[c * 2 + 4] = h[c * 2 - 2], d[c * 2 + 5] = h[c * 2 - 1]);
+                var s = PNt(d);
+                o.positionBuffer(s);
+                var l = ZY(d, s);
+                o.positionFractBuffer(l);
+              }
+              if (i.range ? o.range = i.range : o.range || (o.range = o.bounds), (i.range || i.positions) && o.count) {
+                let u = o.bounds, c = u[2] - u[0], f = u[3] - u[1], h = o.range[2] - o.range[0], d = o.range[3] - o.range[1];
+                o.scale = [c / h, f / d], o.translate = [-o.range[0] / h + u[0] / h || 0, -o.range[1] / d + u[1] / d || 0], o.scaleFract = ZY(o.scale), o.translateFract = ZY(o.translate);
+              }
+              if (i.dashes) {
+                let u = 0, c;
+                if (!i.dashes || i.dashes.length < 2) u = 1, c = new Uint8Array([255, 255, 255, 255, 255, 255, 255, 255]);
+                else {
+                  u = 0;
+                  for (let d = 0; d < i.dashes.length; ++d) u += i.dashes[d];
+                  c = new Uint8Array(u * Wc.dashMult);
+                  let f = 0, h = 255;
+                  for (let d = 0; d < 2; d++) for (let v = 0; v < i.dashes.length; ++v) {
+                    for (let _ = 0, b = i.dashes[v] * Wc.dashMult * 0.5; _ < b; ++_) c[f++] = h;
+                    h ^= 255;
+                  }
+                }
+                o.dashLength = u, o.dashTexture({ channels: 1, data: c, width: c.length, height: 1, mag: "linear", min: "linear" }, 0, 0);
+              }
+              if (i.color) {
+                let u = o.count, c = i.color;
+                c || (c = "transparent");
+                let f = new Uint8Array(u * 4 + 4);
+                if (!Array.isArray(c) || typeof c[0] == "number") {
+                  let h = wz(c, "uint8");
+                  for (let d = 0; d < u + 1; d++) f.set(h, d * 4);
+                } else {
+                  for (let h = 0; h < u; h++) {
+                    let d = wz(c[h], "uint8");
+                    f.set(d, h * 4);
+                  }
+                  f.set(wz(c[0], "uint8"), u * 4);
+                }
+                o.colorBuffer({ usage: "dynamic", type: "uint8", data: f });
+              }
+            }
+          }), e.length < this.passes.length) {
+            for (let i = e.length; i < this.passes.length; i++) {
+              let a = this.passes[i];
+              a && (a.colorBuffer.destroy(), a.positionBuffer.destroy(), a.dashTexture.destroy());
+            }
+            this.passes.length = e.length;
+          }
+          let n = [];
+          for (let i = 0; i < this.passes.length; i++) this.passes[i] !== null && n.push(this.passes[i]);
+          return this.passes = n, this;
+        };
+        Wc.prototype.destroy = function() {
+          return this.passes.forEach((e) => {
+            e.colorBuffer.destroy(), e.positionBuffer.destroy(), e.dashTexture.destroy();
+          }), this.passes.length = 0, this;
+        };
+      });
+      var Sqe = ye((e_r, Aqe) => {
+        var NNt = rw(), UNt = ox(), VNt = mY(), GNt = ey(), bqe = Nh(), wqe = iw(), { float32: HNt, fract32: JY } = nz();
+        Aqe.exports = jNt;
+        var Tqe = [[1, 0, 0, 1, 0, 0], [1, 0, 0, -1, 0, 0], [-1, 0, 0, -1, 0, 0], [-1, 0, 0, -1, 0, 0], [-1, 0, 0, 1, 0, 0], [1, 0, 0, 1, 0, 0], [1, 0, -1, 0, 0, 1], [1, 0, -1, 0, 0, -1], [1, 0, 1, 0, 0, -1], [1, 0, 1, 0, 0, -1], [1, 0, 1, 0, 0, 1], [1, 0, -1, 0, 0, 1], [-1, 0, -1, 0, 0, 1], [-1, 0, -1, 0, 0, -1], [-1, 0, 1, 0, 0, -1], [-1, 0, 1, 0, 0, -1], [-1, 0, 1, 0, 0, 1], [-1, 0, -1, 0, 0, 1], [0, 1, 1, 0, 0, 0], [0, 1, -1, 0, 0, 0], [0, -1, -1, 0, 0, 0], [0, -1, -1, 0, 0, 0], [0, 1, 1, 0, 0, 0], [0, -1, 1, 0, 0, 0], [0, 1, 0, -1, 1, 0], [0, 1, 0, -1, -1, 0], [0, 1, 0, 1, -1, 0], [0, 1, 0, 1, 1, 0], [0, 1, 0, -1, 1, 0], [0, 1, 0, 1, -1, 0], [0, -1, 0, -1, 1, 0], [0, -1, 0, -1, -1, 0], [0, -1, 0, 1, -1, 0], [0, -1, 0, 1, 1, 0], [0, -1, 0, -1, 1, 0], [0, -1, 0, 1, -1, 0]];
+        function jNt(e, t) {
+          if (typeof e == "function" ? (t || (t = {}), t.regl = e) : t = e, t.length && (t.positions = t), e = t.regl, !e.hasExtension("ANGLE_instanced_arrays")) throw Error("regl-error2d: `ANGLE_instanced_arrays` extension should be enabled");
+          let r = e._gl, n, i, a, o, s, l, u = { color: "black", capSize: 5, lineWidth: 1, opacity: 1, viewport: null, range: null, offset: 0, count: 0, bounds: null, positions: [], errors: [] }, c = [];
+          return o = e.buffer({ usage: "dynamic", type: "uint8", data: new Uint8Array(0) }), i = e.buffer({ usage: "dynamic", type: "float", data: new Uint8Array(0) }), a = e.buffer({ usage: "dynamic", type: "float", data: new Uint8Array(0) }), s = e.buffer({ usage: "dynamic", type: "float", data: new Uint8Array(0) }), l = e.buffer({ usage: "static", type: "float", data: Tqe }), v(t), n = e({ vert: `
+		precision highp float;
+
+		attribute vec2 position, positionFract;
+		attribute vec4 error;
+		attribute vec4 color;
+
+		attribute vec2 direction, lineOffset, capOffset;
+
+		uniform vec4 viewport;
+		uniform float lineWidth, capSize;
+		uniform vec2 scale, scaleFract, translate, translateFract;
+
+		varying vec4 fragColor;
+
+		void main() {
+			fragColor = color / 255.;
+
+			vec2 pixelOffset = lineWidth * lineOffset + (capSize + lineWidth) * capOffset;
+
+			vec2 dxy = -step(.5, direction.xy) * error.xz + step(direction.xy, vec2(-.5)) * error.yw;
+
+			vec2 position = position + dxy;
+
+			vec2 pos = (position + translate) * scale
+				+ (positionFract + translateFract) * scale
+				+ (position + translate) * scaleFract
+				+ (positionFract + translateFract) * scaleFract;
+
+			pos += pixelOffset / viewport.zw;
+
+			gl_Position = vec4(pos * 2. - 1., 0, 1);
+		}
+		`, frag: `
+		precision highp float;
+
+		varying vec4 fragColor;
+
+		uniform float opacity;
+
+		void main() {
+			gl_FragColor = fragColor;
+			gl_FragColor.a *= opacity;
+		}
+		`, uniforms: { range: e.prop("range"), lineWidth: e.prop("lineWidth"), capSize: e.prop("capSize"), opacity: e.prop("opacity"), scale: e.prop("scale"), translate: e.prop("translate"), scaleFract: e.prop("scaleFract"), translateFract: e.prop("translateFract"), viewport: (b, p) => [p.viewport.x, p.viewport.y, b.viewportWidth, b.viewportHeight] }, attributes: { color: { buffer: o, offset: (b, p) => p.offset * 4, divisor: 1 }, position: { buffer: i, offset: (b, p) => p.offset * 8, divisor: 1 }, positionFract: { buffer: a, offset: (b, p) => p.offset * 8, divisor: 1 }, error: { buffer: s, offset: (b, p) => p.offset * 16, divisor: 1 }, direction: { buffer: l, stride: 24, offset: 0 }, lineOffset: { buffer: l, stride: 24, offset: 8 }, capOffset: { buffer: l, stride: 24, offset: 16 } }, primitive: "triangles", blend: { enable: true, color: [0, 0, 0, 0], equation: { rgb: "add", alpha: "add" }, func: { srcRGB: "src alpha", dstRGB: "one minus src alpha", srcAlpha: "one minus dst alpha", dstAlpha: "one" } }, depth: { enable: false }, scissor: { enable: true, box: e.prop("viewport") }, viewport: e.prop("viewport"), stencil: false, instances: e.prop("count"), count: Tqe.length }), bqe(f, { update: v, draw: h, destroy: _, regl: e, gl: r, canvas: r.canvas, groups: c }), f;
+          function f(b) {
+            b ? v(b) : b === null && _(), h();
+          }
+          function h(b) {
+            if (typeof b == "number") return d(b);
+            b && !Array.isArray(b) && (b = [b]), e._refresh(), c.forEach((p, k) => {
+              if (p) {
+                if (b && (b[k] ? p.draw = true : p.draw = false), !p.draw) {
+                  p.draw = true;
+                  return;
+                }
+                d(k);
+              }
+            });
+          }
+          function d(b) {
+            typeof b == "number" && (b = c[b]), b != null && b && b.count && b.color && b.opacity && b.positions && b.positions.length > 1 && (b.scaleRatio = [b.scale[0] * b.viewport.width, b.scale[1] * b.viewport.height], n(b), b.after && b.after(b));
+          }
+          function v(b) {
+            if (!b) return;
+            b.length != null ? typeof b[0] == "number" && (b = [{ positions: b }]) : Array.isArray(b) || (b = [b]);
+            let p = 0, k = 0;
+            if (f.groups = c = b.map((L, x) => {
+              let C = c[x];
+              if (L) typeof L == "function" ? L = { after: L } : typeof L[0] == "number" && (L = { positions: L });
+              else return C;
+              return L = GNt(L, { color: "color colors fill", capSize: "capSize cap capsize cap-size", lineWidth: "lineWidth line-width width line thickness", opacity: "opacity alpha", range: "range dataBox", viewport: "viewport viewBox", errors: "errors error", positions: "positions position data points" }), C || (c[x] = C = { id: x, scale: null, translate: null, scaleFract: null, translateFract: null, draw: true }, L = bqe({}, u, L)), VNt(C, L, [{ lineWidth: (M) => +M * 0.5, capSize: (M) => +M * 0.5, opacity: parseFloat, errors: (M) => (M = wqe(M), k += M.length, M), positions: (M, g) => (M = wqe(M, "float64"), g.count = Math.floor(M.length / 2), g.bounds = NNt(M, 2), g.offset = p, p += g.count, M) }, { color: (M, g) => {
+                let P = g.count;
+                if (M || (M = "transparent"), !Array.isArray(M) || typeof M[0] == "number") {
+                  let z = M;
+                  M = Array(P);
+                  for (let O = 0; O < P; O++) M[O] = z;
+                }
+                if (M.length < P) throw Error("Not enough colors");
+                let A = new Uint8Array(P * 4);
+                for (let z = 0; z < P; z++) {
+                  let O = UNt(M[z], "uint8");
+                  A.set(O, z * 4);
+                }
+                return A;
+              }, range: (M, g, P) => {
+                let A = g.bounds;
+                return M || (M = A), g.scale = [1 / (M[2] - M[0]), 1 / (M[3] - M[1])], g.translate = [-M[0], -M[1]], g.scaleFract = JY(g.scale), g.translateFract = JY(g.translate), M;
+              }, viewport: (M) => {
+                let g;
+                return Array.isArray(M) ? g = { x: M[0], y: M[1], width: M[2] - M[0], height: M[3] - M[1] } : M ? (g = { x: M.x || M.left || 0, y: M.y || M.top || 0 }, M.right ? g.width = M.right - g.x : g.width = M.w || M.width || 0, M.bottom ? g.height = M.bottom - g.y : g.height = M.h || M.height || 0) : g = { x: 0, y: 0, width: r.drawingBufferWidth, height: r.drawingBufferHeight }, g;
+              } }]), C;
+            }), p || k) {
+              let L = c.reduce((g, P, A) => g + (P ? P.count : 0), 0), x = new Float64Array(L * 2), C = new Uint8Array(L * 4), M = new Float32Array(L * 4);
+              c.forEach((g, P) => {
+                if (!g) return;
+                let { positions: A, count: z, offset: O, color: U, errors: G } = g;
+                z && (C.set(U, O * 4), M.set(G, O * 4), x.set(A, O * 2));
+              });
+              var E = HNt(x);
+              i(E);
+              var T = JY(x, E);
+              a(T), o(C), s(M);
+            }
+          }
+          function _() {
+            i.destroy(), a.destroy(), o.destroy(), s.destroy(), l.destroy();
+          }
+        }
+      });
+      var kqe = ye((t_r, Eqe) => {
+        var Mqe = /[\'\"]/;
+        Eqe.exports = function(t) {
+          return t ? (Mqe.test(t.charAt(0)) && (t = t.substr(1)), Mqe.test(t.charAt(t.length - 1)) && (t = t.substr(0, t.length - 1)), t) : "";
+        };
+      });
+      var $Y = ye((r_r, WNt) => {
+        WNt.exports = ["inherit", "initial", "unset"];
+      });
+      var QY = ye((i_r, XNt) => {
+        XNt.exports = ["caption", "icon", "menu", "message-box", "small-caption", "status-bar"];
+      });
+      var eK = ye((n_r, ZNt) => {
+        ZNt.exports = ["normal", "bold", "bolder", "lighter", "100", "200", "300", "400", "500", "600", "700", "800", "900"];
+      });
+      var tK = ye((a_r, YNt) => {
+        YNt.exports = ["normal", "italic", "oblique"];
+      });
+      var rK = ye((o_r, KNt) => {
+        KNt.exports = ["normal", "condensed", "semi-condensed", "extra-condensed", "ultra-condensed", "expanded", "semi-expanded", "extra-expanded", "ultra-expanded"];
+      });
+      var Iqe = ye((s_r, Pqe) => {
+        function Cqe(e, t) {
+          if (typeof e != "string") return [e];
+          var r = [e];
+          typeof t == "string" || Array.isArray(t) ? t = { brackets: t } : t || (t = {});
+          var n = t.brackets ? Array.isArray(t.brackets) ? t.brackets : [t.brackets] : ["{}", "[]", "()"], i = t.escape || "___", a = !!t.flat;
+          n.forEach(function(l) {
+            var u = new RegExp(["\\", l[0], "[^\\", l[0], "\\", l[1], "]*\\", l[1]].join("")), c = [];
+            function f(h, d, v) {
+              var _ = r.push(h.slice(l[0].length, -l[1].length)) - 1;
+              return c.push(_), i + _ + i;
+            }
+            r.forEach(function(h, d) {
+              for (var v, _ = 0; h != v; ) if (v = h, h = h.replace(u, f), _++ > 1e4) throw Error("References have circular dependency. Please, check them.");
+              r[d] = h;
+            }), c = c.reverse(), r = r.map(function(h) {
+              return c.forEach(function(d) {
+                h = h.replace(new RegExp("(\\" + i + d + "\\" + i + ")", "g"), l[0] + "$1" + l[1]);
+              }), h;
+            });
+          });
+          var o = new RegExp("\\" + i + "([0-9]+)\\" + i);
+          function s(l, u, c) {
+            for (var f = [], h, d = 0; h = o.exec(l); ) {
+              if (d++ > 1e4) throw Error("Circular references in parenthesis");
+              f.push(l.slice(0, h.index)), f.push(s(u[h[1]], u)), l = l.slice(h.index + h[0].length);
+            }
+            return f.push(l), f;
+          }
+          return a ? r : s(r[0], r);
+        }
+        function Lqe(e, t) {
+          if (t && t.flat) {
+            var r = t && t.escape || "___", n = e[0], i;
+            if (!n) return "";
+            for (var a = new RegExp("\\" + r + "([0-9]+)\\" + r), o = 0; n != i; ) {
+              if (o++ > 1e4) throw Error("Circular references in " + e);
+              i = n, n = n.replace(a, s);
+            }
+            return n;
+          }
+          return e.reduce(function l(u, c) {
+            return Array.isArray(c) && (c = c.reduce(l, "")), u + c;
+          }, "");
+          function s(l, u) {
+            if (e[u] == null) throw Error("Reference " + u + "is undefined");
+            return e[u];
+          }
+        }
+        function iK(e, t) {
+          return Array.isArray(e) ? Lqe(e, t) : Cqe(e, t);
+        }
+        iK.parse = Cqe;
+        iK.stringify = Lqe;
+        Pqe.exports = iK;
+      });
+      var Fqe = ye((l_r, Dqe) => {
+        var Rqe = Iqe();
+        Dqe.exports = function(t, r, n) {
+          if (t == null) throw Error("First argument should be a string");
+          if (r == null) throw Error("Separator should be a string or a RegExp");
+          n ? (typeof n == "string" || Array.isArray(n)) && (n = { ignore: n }) : n = {}, n.escape == null && (n.escape = true), n.ignore == null ? n.ignore = ["[]", "()", "{}", "<>", '""', "''", "``", "“”", "«»"] : (typeof n.ignore == "string" && (n.ignore = [n.ignore]), n.ignore = n.ignore.map(function(f) {
+            return f.length === 1 && (f = f + f), f;
+          }));
+          var i = Rqe.parse(t, { flat: true, brackets: n.ignore }), a = i[0], o = a.split(r);
+          if (n.escape) {
+            for (var s = [], l = 0; l < o.length; l++) {
+              var u = o[l], c = o[l + 1];
+              u[u.length - 1] === "\\" && u[u.length - 2] !== "\\" ? (s.push(u + r + c), l++) : s.push(u);
+            }
+            o = s;
+          }
+          for (var l = 0; l < o.length; l++) i[0] = o[l], o[l] = Rqe.stringify(i, { flat: true });
+          return o;
+        };
+      });
+      var zqe = ye((u_r, JNt) => {
+        JNt.exports = ["xx-small", "x-small", "small", "medium", "large", "x-large", "xx-large", "larger", "smaller"];
+      });
+      var nK = ye((c_r, Oqe) => {
+        var $Nt = zqe();
+        Oqe.exports = { isSize: function(t) {
+          return /^[\d\.]/.test(t) || t.indexOf("/") !== -1 || $Nt.indexOf(t) !== -1;
+        } };
+      });
+      var Uqe = ye((f_r, Nqe) => {
+        var QNt = kqe(), eUt = $Y(), tUt = QY(), rUt = eK(), iUt = tK(), nUt = rK(), aK = Fqe(), aUt = nK().isSize;
+        Nqe.exports = Bqe;
+        var Pk = Bqe.cache = {};
+        function Bqe(e) {
+          if (typeof e != "string") throw new Error("Font argument must be a string.");
+          if (Pk[e]) return Pk[e];
+          if (e === "") throw new Error("Cannot parse an empty string.");
+          if (tUt.indexOf(e) !== -1) return Pk[e] = { system: e };
+          for (var t = { style: "normal", variant: "normal", weight: "normal", stretch: "normal", lineHeight: "normal", size: "1rem", family: ["serif"] }, r = aK(e, /\s+/), n; n = r.shift(); ) {
+            if (eUt.indexOf(n) !== -1) return ["style", "variant", "weight", "stretch"].forEach(function(a) {
+              t[a] = n;
+            }), Pk[e] = t;
+            if (iUt.indexOf(n) !== -1) {
+              t.style = n;
+              continue;
+            }
+            if (n === "normal" || n === "small-caps") {
+              t.variant = n;
+              continue;
+            }
+            if (nUt.indexOf(n) !== -1) {
+              t.stretch = n;
+              continue;
+            }
+            if (rUt.indexOf(n) !== -1) {
+              t.weight = n;
+              continue;
+            }
+            if (aUt(n)) {
+              var i = aK(n, "/");
+              if (t.size = i[0], i[1] != null ? t.lineHeight = qqe(i[1]) : r[0] === "/" && (r.shift(), t.lineHeight = qqe(r.shift())), !r.length) throw new Error("Missing required font-family.");
+              return t.family = aK(r.join(" "), /\s*,\s*/).map(QNt), Pk[e] = t;
+            }
+            throw new Error("Unknown or unsupported font token: " + n);
+          }
+          throw new Error("Missing required font-size.");
+        }
+        function qqe(e) {
+          var t = parseFloat(e);
+          return t.toString() === e ? t : e;
+        }
+      });
+      var sK = ye((h_r, Vqe) => {
+        var oUt = ey(), sUt = nK().isSize, lUt = Rk($Y()), uUt = Rk(QY()), cUt = Rk(eK()), fUt = Rk(tK()), hUt = Rk(rK()), dUt = { normal: 1, "small-caps": 1 }, vUt = { serif: 1, "sans-serif": 1, monospace: 1, cursive: 1, fantasy: 1, "system-ui": 1 }, oK = { size: "1rem", family: "serif" };
+        Vqe.exports = function(t) {
+          if (t = oUt(t, { style: "style fontstyle fontStyle font-style slope distinction", variant: "variant font-variant fontVariant fontvariant var capitalization", weight: "weight w font-weight fontWeight fontweight", stretch: "stretch font-stretch fontStretch fontstretch width", size: "size s font-size fontSize fontsize height em emSize", lineHeight: "lh line-height lineHeight lineheight leading", family: "font family fontFamily font-family fontfamily type typeface face", system: "system reserved default global" }), t.system) return t.system && Ik(t.system, uUt), t.system;
+          if (Ik(t.style, fUt), Ik(t.variant, dUt), Ik(t.weight, cUt), Ik(t.stretch, hUt), t.size == null && (t.size = oK.size), typeof t.size == "number" && (t.size += "px"), !sUt) throw Error("Bad size value `" + t.size + "`");
+          t.family || (t.family = oK.family), Array.isArray(t.family) && (t.family.length || (t.family = [oK.family]), t.family = t.family.map(function(n) {
+            return vUt[n] ? n : '"' + n + '"';
+          }).join(", "));
+          var r = [];
+          return r.push(t.style), t.variant !== t.style && r.push(t.variant), t.weight !== t.variant && t.weight !== t.style && r.push(t.weight), t.stretch !== t.weight && t.stretch !== t.variant && t.stretch !== t.style && r.push(t.stretch), r.push(t.size + (t.lineHeight == null || t.lineHeight === "normal" || t.lineHeight + "" == "1" ? "" : "/" + t.lineHeight)), r.push(t.family), r.filter(Boolean).join(" ");
+        };
+        function Ik(e, t) {
+          if (e && !t[e] && !lUt[e]) throw Error("Unknown keyword `" + e + "`");
+          return e;
+        }
+        function Rk(e) {
+          for (var t = {}, r = 0; r < e.length; r++) t[e[r]] = 1;
+          return t;
+        }
+      });
+      var Hqe = ye((d_r, Gqe) => {
+        Gqe.exports = { parse: Uqe(), stringify: sK() };
+      });
+      var jqe = ye((lK, uK) => {
+        (function(e, t) {
+          typeof lK == "object" && typeof uK != "undefined" ? uK.exports = t() : e.createREGL = t();
+        })(lK, function() {
+          var e = function(Me, bt) {
+            for (var zt = Object.keys(bt), Rr = 0; Rr < zt.length; ++Rr) Me[zt[Rr]] = bt[zt[Rr]];
+            return Me;
+          }, t = 0, r = 0, n = 5, i = 6;
+          function a(Me, bt) {
+            this.id = t++, this.type = Me, this.data = bt;
+          }
+          function o(Me) {
+            return Me.replace(/\\/g, "\\\\").replace(/"/g, '\\"');
+          }
+          function s(Me) {
+            if (Me.length === 0) return [];
+            var bt = Me.charAt(0), zt = Me.charAt(Me.length - 1);
+            if (Me.length > 1 && bt === zt && (bt === '"' || bt === "'")) return ['"' + o(Me.substr(1, Me.length - 2)) + '"'];
+            var Rr = /\[(false|true|null|\d+|'[^']*'|"[^"]*")\]/.exec(Me);
+            if (Rr) return s(Me.substr(0, Rr.index)).concat(s(Rr[1])).concat(s(Me.substr(Rr.index + Rr[0].length)));
+            var jr = Me.split(".");
+            if (jr.length === 1) return ['"' + o(Me) + '"'];
+            for (var Nr = [], Gr = 0; Gr < jr.length; ++Gr) Nr = Nr.concat(s(jr[Gr]));
+            return Nr;
+          }
+          function l(Me) {
+            return "[" + s(Me).join("][") + "]";
+          }
+          function u(Me, bt) {
+            return new a(Me, l(bt + ""));
+          }
+          function c(Me) {
+            return typeof Me == "function" && !Me._reglType || Me instanceof a;
+          }
+          function f(Me, bt) {
+            if (typeof Me == "function") return new a(r, Me);
+            if (typeof Me == "number" || typeof Me == "boolean") return new a(n, Me);
+            if (Array.isArray(Me)) return new a(i, Me.map(function(zt, Rr) {
+              return f(zt);
+            }));
+            if (Me instanceof a) return Me;
+          }
+          var h = { DynamicVariable: a, define: u, isDynamic: c, unbox: f, accessor: l }, d = { next: typeof requestAnimationFrame == "function" ? function(Me) {
+            return requestAnimationFrame(Me);
+          } : function(Me) {
+            return setTimeout(Me, 16);
+          }, cancel: typeof cancelAnimationFrame == "function" ? function(Me) {
+            return cancelAnimationFrame(Me);
+          } : clearTimeout }, v = typeof performance != "undefined" && performance.now ? function() {
+            return performance.now();
+          } : function() {
+            return +/* @__PURE__ */ new Date();
+          };
+          function _() {
+            var Me = { "": 0 }, bt = [""];
+            return { id: function(zt) {
+              var Rr = Me[zt];
+              return Rr || (Rr = Me[zt] = bt.length, bt.push(zt), Rr);
+            }, str: function(zt) {
+              return bt[zt];
+            } };
+          }
+          function b(Me, bt, zt) {
+            var Rr = document.createElement("canvas");
+            e(Rr.style, { border: 0, margin: 0, padding: 0, top: 0, left: 0, width: "100%", height: "100%" }), Me.appendChild(Rr), Me === document.body && (Rr.style.position = "absolute", e(Me.style, { margin: 0, padding: 0 }));
+            function jr() {
+              var mi = window.innerWidth, Ui = window.innerHeight;
+              if (Me !== document.body) {
+                var qi = Rr.getBoundingClientRect();
+                mi = qi.right - qi.left, Ui = qi.bottom - qi.top;
+              }
+              Rr.width = zt * mi, Rr.height = zt * Ui;
+            }
+            var Nr;
+            Me !== document.body && typeof ResizeObserver == "function" ? (Nr = new ResizeObserver(function() {
+              setTimeout(jr);
+            }), Nr.observe(Me)) : window.addEventListener("resize", jr, false);
+            function Gr() {
+              Nr ? Nr.disconnect() : window.removeEventListener("resize", jr), Me.removeChild(Rr);
+            }
+            return jr(), { canvas: Rr, onDestroy: Gr };
+          }
+          function p(Me, bt) {
+            function zt(Rr) {
+              try {
+                return Me.getContext(Rr, bt);
+              } catch (jr) {
+                return null;
+              }
+            }
+            return zt("webgl") || zt("experimental-webgl") || zt("webgl-experimental");
+          }
+          function k(Me) {
+            return typeof Me.nodeName == "string" && typeof Me.appendChild == "function" && typeof Me.getBoundingClientRect == "function";
+          }
+          function E(Me) {
+            return typeof Me.drawArrays == "function" || typeof Me.drawElements == "function";
+          }
+          function T(Me) {
+            return typeof Me == "string" ? Me.split() : Me;
+          }
+          function L(Me) {
+            return typeof Me == "string" ? document.querySelector(Me) : Me;
+          }
+          function x(Me) {
+            var bt = Me || {}, zt, Rr, jr, Nr, Gr = {}, mi = [], Ui = [], qi = typeof window == "undefined" ? 1 : window.devicePixelRatio, Ei = false, Hn = {}, en = function(Mr) {
+            }, Wi = function() {
+            };
+            if (typeof bt == "string" ? zt = document.querySelector(bt) : typeof bt == "object" && (k(bt) ? zt = bt : E(bt) ? (Nr = bt, jr = Nr.canvas) : ("gl" in bt ? Nr = bt.gl : "canvas" in bt ? jr = L(bt.canvas) : "container" in bt && (Rr = L(bt.container)), "attributes" in bt && (Gr = bt.attributes), "extensions" in bt && (mi = T(bt.extensions)), "optionalExtensions" in bt && (Ui = T(bt.optionalExtensions)), "onDone" in bt && (en = bt.onDone), "profile" in bt && (Ei = !!bt.profile), "pixelRatio" in bt && (qi = +bt.pixelRatio), "cachedCode" in bt && (Hn = bt.cachedCode))), zt && (zt.nodeName.toLowerCase() === "canvas" ? jr = zt : Rr = zt), !Nr) {
+              if (!jr) {
+                var si = b(Rr || document.body, en, qi);
+                if (!si) return null;
+                jr = si.canvas, Wi = si.onDestroy;
+              }
+              Gr.premultipliedAlpha === void 0 && (Gr.premultipliedAlpha = true), Nr = p(jr, Gr);
+            }
+            return Nr ? { gl: Nr, canvas: jr, container: Rr, extensions: mi, optionalExtensions: Ui, pixelRatio: qi, profile: Ei, cachedCode: Hn, onDone: en, onDestroy: Wi } : (Wi(), en("webgl not supported, try upgrading your browser or graphics drivers http://get.webgl.org"), null);
+          }
+          function C(Me, bt) {
+            var zt = {};
+            function Rr(Gr) {
+              var mi = Gr.toLowerCase(), Ui;
+              try {
+                Ui = zt[mi] = Me.getExtension(mi);
+              } catch (qi) {
+              }
+              return !!Ui;
+            }
+            for (var jr = 0; jr < bt.extensions.length; ++jr) {
+              var Nr = bt.extensions[jr];
+              if (!Rr(Nr)) return bt.onDestroy(), bt.onDone('"' + Nr + '" extension is not supported by the current WebGL context, try upgrading your system or a different browser'), null;
+            }
+            return bt.optionalExtensions.forEach(Rr), { extensions: zt, restore: function() {
+              Object.keys(zt).forEach(function(Gr) {
+                if (zt[Gr] && !Rr(Gr)) throw new Error("(regl): error restoring extension " + Gr);
+              });
+            } };
+          }
+          function M(Me, bt) {
+            for (var zt = Array(Me), Rr = 0; Rr < Me; ++Rr) zt[Rr] = bt(Rr);
+            return zt;
+          }
+          var g = 5120, P = 5121, A = 5122, z = 5123, O = 5124, U = 5125, G = 5126;
+          function Z(Me) {
+            for (var bt = 16; bt <= 1 << 28; bt *= 16) if (Me <= bt) return bt;
+            return 0;
+          }
+          function j(Me) {
+            var bt, zt;
+            return bt = (Me > 65535) << 4, Me >>>= bt, zt = (Me > 255) << 3, Me >>>= zt, bt |= zt, zt = (Me > 15) << 2, Me >>>= zt, bt |= zt, zt = (Me > 3) << 1, Me >>>= zt, bt |= zt, bt | Me >> 1;
+          }
+          function N() {
+            var Me = M(8, function() {
+              return [];
+            });
+            function bt(Nr) {
+              var Gr = Z(Nr), mi = Me[j(Gr) >> 2];
+              return mi.length > 0 ? mi.pop() : new ArrayBuffer(Gr);
+            }
+            function zt(Nr) {
+              Me[j(Nr.byteLength) >> 2].push(Nr);
+            }
+            function Rr(Nr, Gr) {
+              var mi = null;
+              switch (Nr) {
+                case g:
+                  mi = new Int8Array(bt(Gr), 0, Gr);
+                  break;
+                case P:
+                  mi = new Uint8Array(bt(Gr), 0, Gr);
+                  break;
+                case A:
+                  mi = new Int16Array(bt(2 * Gr), 0, Gr);
+                  break;
+                case z:
+                  mi = new Uint16Array(bt(2 * Gr), 0, Gr);
+                  break;
+                case O:
+                  mi = new Int32Array(bt(4 * Gr), 0, Gr);
+                  break;
+                case U:
+                  mi = new Uint32Array(bt(4 * Gr), 0, Gr);
+                  break;
+                case G:
+                  mi = new Float32Array(bt(4 * Gr), 0, Gr);
+                  break;
+                default:
+                  return null;
+              }
+              return mi.length !== Gr ? mi.subarray(0, Gr) : mi;
+            }
+            function jr(Nr) {
+              zt(Nr.buffer);
+            }
+            return { alloc: bt, free: zt, allocType: Rr, freeType: jr };
+          }
+          var H = N();
+          H.zero = N();
+          var re = 3408, oe = 3410, _e = 3411, Ce = 3412, Le = 3413, ge = 3414, ie = 3415, Se = 33901, Ee = 33902, Ae = 3379, Be = 3386, Pe = 34921, me = 36347, De = 36348, ce = 35661, je = 35660, lt = 34930, pt = 36349, Vt = 34076, ot = 34024, ut = 7936, Wt = 7937, Nt = 7938, $t = 35724, sr = 34047, Tr = 36063, fr = 34852, $e = 3553, St = 34067, Qt = 34069, Gt = 33984, _t = 6408, It = 5126, mt = 5121, er = 36160, lr = 36053, wr = 36064, Lr = 16384, ti = function(Me, bt) {
+            var zt = 1;
+            bt.ext_texture_filter_anisotropic && (zt = Me.getParameter(sr));
+            var Rr = 1, jr = 1;
+            bt.webgl_draw_buffers && (Rr = Me.getParameter(fr), jr = Me.getParameter(Tr));
+            var Nr = !!bt.oes_texture_float;
+            if (Nr) {
+              var Gr = Me.createTexture();
+              Me.bindTexture($e, Gr), Me.texImage2D($e, 0, _t, 1, 1, 0, _t, It, null);
+              var mi = Me.createFramebuffer();
+              if (Me.bindFramebuffer(er, mi), Me.framebufferTexture2D(er, wr, $e, Gr, 0), Me.bindTexture($e, null), Me.checkFramebufferStatus(er) !== lr) Nr = false;
+              else {
+                Me.viewport(0, 0, 1, 1), Me.clearColor(1, 0, 0, 1), Me.clear(Lr);
+                var Ui = H.allocType(It, 4);
+                Me.readPixels(0, 0, 1, 1, _t, It, Ui), Me.getError() ? Nr = false : (Me.deleteFramebuffer(mi), Me.deleteTexture(Gr), Nr = Ui[0] === 1), H.freeType(Ui);
+              }
+            }
+            var qi = typeof navigator != "undefined" && (/MSIE/.test(navigator.userAgent) || /Trident\//.test(navigator.appVersion) || /Edge/.test(navigator.userAgent)), Ei = true;
+            if (!qi) {
+              var Hn = Me.createTexture(), en = H.allocType(mt, 36);
+              Me.activeTexture(Gt), Me.bindTexture(St, Hn), Me.texImage2D(Qt, 0, _t, 3, 3, 0, _t, mt, en), H.freeType(en), Me.bindTexture(St, null), Me.deleteTexture(Hn), Ei = !Me.getError();
+            }
+            return { colorBits: [Me.getParameter(oe), Me.getParameter(_e), Me.getParameter(Ce), Me.getParameter(Le)], depthBits: Me.getParameter(ge), stencilBits: Me.getParameter(ie), subpixelBits: Me.getParameter(re), extensions: Object.keys(bt).filter(function(Wi) {
+              return !!bt[Wi];
+            }), maxAnisotropic: zt, maxDrawbuffers: Rr, maxColorAttachments: jr, pointSizeDims: Me.getParameter(Se), lineWidthDims: Me.getParameter(Ee), maxViewportDims: Me.getParameter(Be), maxCombinedTextureUnits: Me.getParameter(ce), maxCubeMapSize: Me.getParameter(Vt), maxRenderbufferSize: Me.getParameter(ot), maxTextureUnits: Me.getParameter(lt), maxTextureSize: Me.getParameter(Ae), maxAttributes: Me.getParameter(Pe), maxVertexUniforms: Me.getParameter(me), maxVertexTextureUnits: Me.getParameter(je), maxVaryingVectors: Me.getParameter(De), maxFragmentUniforms: Me.getParameter(pt), glsl: Me.getParameter($t), renderer: Me.getParameter(Wt), vendor: Me.getParameter(ut), version: Me.getParameter(Nt), readFloat: Nr, npotTextureCube: Ei };
+          }, Br = function(Me) {
+            return Me instanceof Uint8Array || Me instanceof Uint16Array || Me instanceof Uint32Array || Me instanceof Int8Array || Me instanceof Int16Array || Me instanceof Int32Array || Me instanceof Float32Array || Me instanceof Float64Array || Me instanceof Uint8ClampedArray;
+          };
+          function Vr(Me) {
+            return !!Me && typeof Me == "object" && Array.isArray(Me.shape) && Array.isArray(Me.stride) && typeof Me.offset == "number" && Me.shape.length === Me.stride.length && (Array.isArray(Me.data) || Br(Me.data));
+          }
+          var dt = function(Me) {
+            return Object.keys(Me).map(function(bt) {
+              return Me[bt];
+            });
+          }, Ge = { shape: xe, flatten: Ie };
+          function Je(Me, bt, zt) {
+            for (var Rr = 0; Rr < bt; ++Rr) zt[Rr] = Me[Rr];
+          }
+          function We(Me, bt, zt, Rr) {
+            for (var jr = 0, Nr = 0; Nr < bt; ++Nr) for (var Gr = Me[Nr], mi = 0; mi < zt; ++mi) Rr[jr++] = Gr[mi];
+          }
+          function tt(Me, bt, zt, Rr, jr, Nr) {
+            for (var Gr = Nr, mi = 0; mi < bt; ++mi) for (var Ui = Me[mi], qi = 0; qi < zt; ++qi) for (var Ei = Ui[qi], Hn = 0; Hn < Rr; ++Hn) jr[Gr++] = Ei[Hn];
+          }
+          function xt(Me, bt, zt, Rr, jr) {
+            for (var Nr = 1, Gr = zt + 1; Gr < bt.length; ++Gr) Nr *= bt[Gr];
+            var mi = bt[zt];
+            if (bt.length - zt === 4) {
+              var Ui = bt[zt + 1], qi = bt[zt + 2], Ei = bt[zt + 3];
+              for (Gr = 0; Gr < mi; ++Gr) tt(Me[Gr], Ui, qi, Ei, Rr, jr), jr += Nr;
+            } else for (Gr = 0; Gr < mi; ++Gr) xt(Me[Gr], bt, zt + 1, Rr, jr), jr += Nr;
+          }
+          function Ie(Me, bt, zt, Rr) {
+            var jr = 1;
+            if (bt.length) for (var Nr = 0; Nr < bt.length; ++Nr) jr *= bt[Nr];
+            else jr = 0;
+            var Gr = Rr || H.allocType(zt, jr);
+            switch (bt.length) {
+              case 0:
+                break;
+              case 1:
+                Je(Me, bt[0], Gr);
+                break;
+              case 2:
+                We(Me, bt[0], bt[1], Gr);
+                break;
+              case 3:
+                tt(Me, bt[0], bt[1], bt[2], Gr, 0);
+                break;
+              default:
+                xt(Me, bt, 0, Gr, 0);
+            }
+            return Gr;
+          }
+          function xe(Me) {
+            for (var bt = [], zt = Me; zt.length; zt = zt[0]) bt.push(zt.length);
+            return bt;
+          }
+          var ke = { "[object Int8Array]": 5120, "[object Int16Array]": 5122, "[object Int32Array]": 5124, "[object Uint8Array]": 5121, "[object Uint8ClampedArray]": 5121, "[object Uint16Array]": 5123, "[object Uint32Array]": 5125, "[object Float32Array]": 5126, "[object Float64Array]": 5121, "[object ArrayBuffer]": 5121 }, vt = 5120, ir = 5122, ar = 5124, vr = 5121, ii = 5123, pi = 5125, $r = 5126, di = 5126, ji = { int8: vt, int16: ir, int32: ar, uint8: vr, uint16: ii, uint32: pi, float: $r, float32: di }, In = 35048, wi = 35040, On = { dynamic: In, stream: wi, static: 35044 }, qn = Ge.flatten, Fn = Ge.shape, ra = 35044, la = 35040, Ut = 5121, wt = 5126, rr = [];
+          rr[5120] = 1, rr[5122] = 2, rr[5124] = 4, rr[5121] = 1, rr[5123] = 2, rr[5125] = 4, rr[5126] = 4;
+          function nr(Me) {
+            return ke[Object.prototype.toString.call(Me)] | 0;
+          }
+          function Er(Me, bt) {
+            for (var zt = 0; zt < bt.length; ++zt) Me[zt] = bt[zt];
+          }
+          function Xr(Me, bt, zt, Rr, jr, Nr, Gr) {
+            for (var mi = 0, Ui = 0; Ui < zt; ++Ui) for (var qi = 0; qi < Rr; ++qi) Me[mi++] = bt[jr * Ui + Nr * qi + Gr];
+          }
+          function ri(Me, bt, zt, Rr) {
+            var jr = 0, Nr = {};
+            function Gr(Mr) {
+              this.id = jr++, this.buffer = Me.createBuffer(), this.type = Mr, this.usage = ra, this.byteLength = 0, this.dimension = 1, this.dtype = Ut, this.persistentData = null, zt.profile && (this.stats = { size: 0 });
+            }
+            Gr.prototype.bind = function() {
+              Me.bindBuffer(this.type, this.buffer);
+            }, Gr.prototype.destroy = function() {
+              en(this);
+            };
+            var mi = [];
+            function Ui(Mr, Yr) {
+              var xi = mi.pop();
+              return xi || (xi = new Gr(Mr)), xi.bind(), Hn(xi, Yr, la, 0, 1, false), xi;
+            }
+            function qi(Mr) {
+              mi.push(Mr);
+            }
+            function Ei(Mr, Yr, xi) {
+              Mr.byteLength = Yr.byteLength, Me.bufferData(Mr.type, Yr, xi);
+            }
+            function Hn(Mr, Yr, xi, Ri, ci, an) {
+              var Zi;
+              if (Mr.usage = xi, Array.isArray(Yr)) {
+                if (Mr.dtype = Ri || wt, Yr.length > 0) {
+                  var Bn;
+                  if (Array.isArray(Yr[0])) {
+                    Zi = Fn(Yr);
+                    for (var hi = 1, li = 1; li < Zi.length; ++li) hi *= Zi[li];
+                    Mr.dimension = hi, Bn = qn(Yr, Zi, Mr.dtype), Ei(Mr, Bn, xi), an ? Mr.persistentData = Bn : H.freeType(Bn);
+                  } else if (typeof Yr[0] == "number") {
+                    Mr.dimension = ci;
+                    var mn = H.allocType(Mr.dtype, Yr.length);
+                    Er(mn, Yr), Ei(Mr, mn, xi), an ? Mr.persistentData = mn : H.freeType(mn);
+                  } else Br(Yr[0]) && (Mr.dimension = Yr[0].length, Mr.dtype = Ri || nr(Yr[0]) || wt, Bn = qn(Yr, [Yr.length, Yr[0].length], Mr.dtype), Ei(Mr, Bn, xi), an ? Mr.persistentData = Bn : H.freeType(Bn));
+                }
+              } else if (Br(Yr)) Mr.dtype = Ri || nr(Yr), Mr.dimension = ci, Ei(Mr, Yr, xi), an && (Mr.persistentData = new Uint8Array(new Uint8Array(Yr.buffer)));
+              else if (Vr(Yr)) {
+                Zi = Yr.shape;
+                var Ji = Yr.stride, Vi = Yr.offset, Ni = 0, pn = 0, Vn = 0, na = 0;
+                Zi.length === 1 ? (Ni = Zi[0], pn = 1, Vn = Ji[0], na = 0) : Zi.length === 2 && (Ni = Zi[0], pn = Zi[1], Vn = Ji[0], na = Ji[1]), Mr.dtype = Ri || nr(Yr.data) || wt, Mr.dimension = pn;
+                var Ki = H.allocType(Mr.dtype, Ni * pn);
+                Xr(Ki, Yr.data, Ni, pn, Vn, na, Vi), Ei(Mr, Ki, xi), an ? Mr.persistentData = Ki : H.freeType(Ki);
+              } else Yr instanceof ArrayBuffer && (Mr.dtype = Ut, Mr.dimension = ci, Ei(Mr, Yr, xi), an && (Mr.persistentData = new Uint8Array(new Uint8Array(Yr))));
+            }
+            function en(Mr) {
+              bt.bufferCount--, Rr(Mr);
+              var Yr = Mr.buffer;
+              Me.deleteBuffer(Yr), Mr.buffer = null, delete Nr[Mr.id];
+            }
+            function Wi(Mr, Yr, xi, Ri) {
+              bt.bufferCount++;
+              var ci = new Gr(Yr);
+              Nr[ci.id] = ci;
+              function an(hi) {
+                var li = ra, mn = null, Ji = 0, Vi = 0, Ni = 1;
+                return Array.isArray(hi) || Br(hi) || Vr(hi) || hi instanceof ArrayBuffer ? mn = hi : typeof hi == "number" ? Ji = hi | 0 : hi && ("data" in hi && (mn = hi.data), "usage" in hi && (li = On[hi.usage]), "type" in hi && (Vi = ji[hi.type]), "dimension" in hi && (Ni = hi.dimension | 0), "length" in hi && (Ji = hi.length | 0)), ci.bind(), mn ? Hn(ci, mn, li, Vi, Ni, Ri) : (Ji && Me.bufferData(ci.type, Ji, li), ci.dtype = Vi || Ut, ci.usage = li, ci.dimension = Ni, ci.byteLength = Ji), zt.profile && (ci.stats.size = ci.byteLength * rr[ci.dtype]), an;
+              }
+              function Zi(hi, li) {
+                Me.bufferSubData(ci.type, li, hi);
+              }
+              function Bn(hi, li) {
+                var mn = (li || 0) | 0, Ji;
+                if (ci.bind(), Br(hi) || hi instanceof ArrayBuffer) Zi(hi, mn);
+                else if (Array.isArray(hi)) {
+                  if (hi.length > 0) {
+                    if (typeof hi[0] == "number") {
+                      var Vi = H.allocType(ci.dtype, hi.length);
+                      Er(Vi, hi), Zi(Vi, mn), H.freeType(Vi);
+                    } else if (Array.isArray(hi[0]) || Br(hi[0])) {
+                      Ji = Fn(hi);
+                      var Ni = qn(hi, Ji, ci.dtype);
+                      Zi(Ni, mn), H.freeType(Ni);
+                    }
+                  }
+                } else if (Vr(hi)) {
+                  Ji = hi.shape;
+                  var pn = hi.stride, Vn = 0, na = 0, Ki = 0, kn = 0;
+                  Ji.length === 1 ? (Vn = Ji[0], na = 1, Ki = pn[0], kn = 0) : Ji.length === 2 && (Vn = Ji[0], na = Ji[1], Ki = pn[0], kn = pn[1]);
+                  var ta = Array.isArray(hi.data) ? ci.dtype : nr(hi.data), oa = H.allocType(ta, Vn * na);
+                  Xr(oa, hi.data, Vn, na, Ki, kn, hi.offset), Zi(oa, mn), H.freeType(oa);
+                }
+                return an;
+              }
+              return xi || an(Mr), an._reglType = "buffer", an._buffer = ci, an.subdata = Bn, zt.profile && (an.stats = ci.stats), an.destroy = function() {
+                en(ci);
+              }, an;
+            }
+            function si() {
+              dt(Nr).forEach(function(Mr) {
+                Mr.buffer = Me.createBuffer(), Me.bindBuffer(Mr.type, Mr.buffer), Me.bufferData(Mr.type, Mr.persistentData || Mr.byteLength, Mr.usage);
+              });
+            }
+            return zt.profile && (bt.getTotalBufferSize = function() {
+              var Mr = 0;
+              return Object.keys(Nr).forEach(function(Yr) {
+                Mr += Nr[Yr].stats.size;
+              }), Mr;
+            }), { create: Wi, createStream: Ui, destroyStream: qi, clear: function() {
+              dt(Nr).forEach(en), mi.forEach(en);
+            }, getBuffer: function(Mr) {
+              return Mr && Mr._buffer instanceof Gr ? Mr._buffer : null;
+            }, restore: si, _initBuffer: Hn };
+          }
+          var Qr = 0, Oi = 0, $i = 1, tn = 1, fn = 4, yn = 4, Sn = { points: Qr, point: Oi, lines: $i, line: tn, triangles: fn, triangle: yn, "line loop": 2, "line strip": 3, "triangle strip": 5, "triangle fan": 6 }, Ba = 0, ua = 1, ma = 4, Wa = 5120, Fa = 5121, Xo = 5122, da = 5123, Wn = 5124, Ha = 5125, vo = 34963, jn = 35040, Mt = 35044;
+          function kr(Me, bt, zt, Rr) {
+            var jr = {}, Nr = 0, Gr = { uint8: Fa, uint16: da };
+            bt.oes_element_index_uint && (Gr.uint32 = Ha);
+            function mi(si) {
+              this.id = Nr++, jr[this.id] = this, this.buffer = si, this.primType = ma, this.vertCount = 0, this.type = 0;
+            }
+            mi.prototype.bind = function() {
+              this.buffer.bind();
+            };
+            var Ui = [];
+            function qi(si) {
+              var Mr = Ui.pop();
+              return Mr || (Mr = new mi(zt.create(null, vo, true, false)._buffer)), Hn(Mr, si, jn, -1, -1, 0, 0), Mr;
+            }
+            function Ei(si) {
+              Ui.push(si);
+            }
+            function Hn(si, Mr, Yr, xi, Ri, ci, an) {
+              si.buffer.bind();
+              var Zi;
+              if (Mr) {
+                var Bn = an;
+                !an && (!Br(Mr) || Vr(Mr) && !Br(Mr.data)) && (Bn = bt.oes_element_index_uint ? Ha : da), zt._initBuffer(si.buffer, Mr, Yr, Bn, 3);
+              } else Me.bufferData(vo, ci, Yr), si.buffer.dtype = Zi || Fa, si.buffer.usage = Yr, si.buffer.dimension = 3, si.buffer.byteLength = ci;
+              if (Zi = an, !an) {
+                switch (si.buffer.dtype) {
+                  case Fa:
+                  case Wa:
+                    Zi = Fa;
+                    break;
+                  case da:
+                  case Xo:
+                    Zi = da;
+                    break;
+                  case Ha:
+                  case Wn:
+                    Zi = Ha;
+                    break;
+                }
+                si.buffer.dtype = Zi;
+              }
+              si.type = Zi;
+              var hi = Ri;
+              hi < 0 && (hi = si.buffer.byteLength, Zi === da ? hi >>= 1 : Zi === Ha && (hi >>= 2)), si.vertCount = hi;
+              var li = xi;
+              if (xi < 0) {
+                li = ma;
+                var mn = si.buffer.dimension;
+                mn === 1 && (li = Ba), mn === 2 && (li = ua), mn === 3 && (li = ma);
+              }
+              si.primType = li;
+            }
+            function en(si) {
+              Rr.elementsCount--, delete jr[si.id], si.buffer.destroy(), si.buffer = null;
+            }
+            function Wi(si, Mr) {
+              var Yr = zt.create(null, vo, true), xi = new mi(Yr._buffer);
+              Rr.elementsCount++;
+              function Ri(ci) {
+                if (!ci) Yr(), xi.primType = ma, xi.vertCount = 0, xi.type = Fa;
+                else if (typeof ci == "number") Yr(ci), xi.primType = ma, xi.vertCount = ci | 0, xi.type = Fa;
+                else {
+                  var an = null, Zi = Mt, Bn = -1, hi = -1, li = 0, mn = 0;
+                  Array.isArray(ci) || Br(ci) || Vr(ci) ? an = ci : ("data" in ci && (an = ci.data), "usage" in ci && (Zi = On[ci.usage]), "primitive" in ci && (Bn = Sn[ci.primitive]), "count" in ci && (hi = ci.count | 0), "type" in ci && (mn = Gr[ci.type]), "length" in ci ? li = ci.length | 0 : (li = hi, mn === da || mn === Xo ? li *= 2 : (mn === Ha || mn === Wn) && (li *= 4))), Hn(xi, an, Zi, Bn, hi, li, mn);
+                }
+                return Ri;
+              }
+              return Ri(si), Ri._reglType = "elements", Ri._elements = xi, Ri.subdata = function(ci, an) {
+                return Yr.subdata(ci, an), Ri;
+              }, Ri.destroy = function() {
+                en(xi);
+              }, Ri;
+            }
+            return { create: Wi, createStream: qi, destroyStream: Ei, getElements: function(si) {
+              return typeof si == "function" && si._elements instanceof mi ? si._elements : null;
+            }, clear: function() {
+              dt(jr).forEach(en);
+            } };
+          }
+          var Jr = new Float32Array(1), vi = new Uint32Array(Jr.buffer), hn = 5123;
+          function An(Me) {
+            for (var bt = H.allocType(hn, Me.length), zt = 0; zt < Me.length; ++zt) if (isNaN(Me[zt])) bt[zt] = 65535;
+            else if (Me[zt] === 1 / 0) bt[zt] = 31744;
+            else if (Me[zt] === -1 / 0) bt[zt] = 64512;
+            else {
+              Jr[0] = Me[zt];
+              var Rr = vi[0], jr = Rr >>> 31 << 15, Nr = (Rr << 1 >>> 24) - 127, Gr = Rr >> 13 & 1023;
+              if (Nr < -24) bt[zt] = jr;
+              else if (Nr < -14) {
+                var mi = -14 - Nr;
+                bt[zt] = jr + (Gr + 1024 >> mi);
+              } else Nr > 15 ? bt[zt] = jr + 31744 : bt[zt] = jr + (Nr + 15 << 10) + Gr;
+            }
+            return bt;
+          }
+          function Mn(Me) {
+            return Array.isArray(Me) || Br(Me);
+          }
+          var Li = 34467, _n = 3553, ya = 34067, $n = 34069, Ma = 6408, _o = 6406, No = 6407, po = 6409, Lo = 6410, ko = 32854, Ds = 32855, Fs = 36194, ll = 32819, ul = 32820, zl = 33635, us = 34042, il = 6402, As = 34041, cl = 35904, Ks = 35906, zs = 36193, Io = 33776, ls = 33777, Yl = 33778, Su = 33779, nc = 35986, bs = 35987, Rn = 34798, _a = 35840, Vu = 35841, Ol = 35842, xo = 35843, Kl = 36196, Ns = 5121, Hl = 5123, ac = 5125, aa = 5126, Oo = 10242, qo = 10243, ql = 10497, Pc = 33071, Do = 33648, rf = 10240, Vf = 10241, pl = 9728, Zc = 9729, Jl = 9984, Os = 9985, yu = 9986, oc = 9987, Cf = 33170, sc = 4352, jh = 4353, Lf = 4354, cs = 34046, nf = 3317, Gf = 37440, $l = 37441, fl = 37443, lc = 37444, Fu = 33984, Es = [Jl, yu, Os, oc], Hs = [0, po, Lo, No, Ma], Go = {};
+          Go[po] = Go[_o] = Go[il] = 1, Go[As] = Go[Lo] = 2, Go[No] = Go[cl] = 3, Go[Ma] = Go[Ks] = 4;
+          function ps(Me) {
+            return "[object " + Me + "]";
+          }
+          var uc = ps("HTMLCanvasElement"), xl = ps("OffscreenCanvas"), Gu = ps("CanvasRenderingContext2D"), qs = ps("ImageBitmap"), od = ps("HTMLImageElement"), Po = ps("HTMLVideoElement"), sd = Object.keys(ke).concat([uc, xl, Gu, qs, od, Po]), Ko = [];
+          Ko[Ns] = 1, Ko[aa] = 4, Ko[zs] = 2, Ko[Hl] = 2, Ko[ac] = 4;
+          var Pa = [];
+          Pa[ko] = 2, Pa[Ds] = 2, Pa[Fs] = 2, Pa[As] = 4, Pa[Io] = 0.5, Pa[ls] = 0.5, Pa[Yl] = 1, Pa[Su] = 1, Pa[nc] = 0.5, Pa[bs] = 1, Pa[Rn] = 1, Pa[_a] = 0.5, Pa[Vu] = 0.25, Pa[Ol] = 0.5, Pa[xo] = 0.25, Pa[Kl] = 0.5;
+          function af(Me) {
+            return Array.isArray(Me) && (Me.length === 0 || typeof Me[0] == "number");
+          }
+          function Hu(Me) {
+            if (!Array.isArray(Me)) return false;
+            var bt = Me.length;
+            return !(bt === 0 || !Mn(Me[0]));
+          }
+          function bl(Me) {
+            return Object.prototype.toString.call(Me);
+          }
+          function Hf(Me) {
+            return bl(Me) === uc;
+          }
+          function Ic(Me) {
+            return bl(Me) === xl;
+          }
+          function yf(Me) {
+            return bl(Me) === Gu;
+          }
+          function Bl(Me) {
+            return bl(Me) === qs;
+          }
+          function Ah(Me) {
+            return bl(Me) === od;
+          }
+          function Qf(Me) {
+            return bl(Me) === Po;
+          }
+          function _f(Me) {
+            if (!Me) return false;
+            var bt = bl(Me);
+            return sd.indexOf(bt) >= 0 ? true : af(Me) || Hu(Me) || Vr(Me);
+          }
+          function Yc(Me) {
+            return ke[Object.prototype.toString.call(Me)] | 0;
+          }
+          function eh(Me, bt) {
+            var zt = bt.length;
+            switch (Me.type) {
+              case Ns:
+              case Hl:
+              case ac:
+              case aa:
+                var Rr = H.allocType(Me.type, zt);
+                Rr.set(bt), Me.data = Rr;
+                break;
+              case zs:
+                Me.data = An(bt);
+                break;
+            }
+          }
+          function th(Me, bt) {
+            return H.allocType(Me.type === zs ? aa : Me.type, bt);
+          }
+          function ju(Me, bt) {
+            Me.type === zs ? (Me.data = An(bt), H.freeType(bt)) : Me.data = bt;
+          }
+          function jf(Me, bt, zt, Rr, jr, Nr) {
+            for (var Gr = Me.width, mi = Me.height, Ui = Me.channels, qi = Gr * mi * Ui, Ei = th(Me, qi), Hn = 0, en = 0; en < mi; ++en) for (var Wi = 0; Wi < Gr; ++Wi) for (var si = 0; si < Ui; ++si) Ei[Hn++] = bt[zt * Wi + Rr * en + jr * si + Nr];
+            ju(Me, Ei);
+          }
+          function cc(Me, bt, zt, Rr, jr, Nr) {
+            var Gr;
+            if (typeof Pa[Me] != "undefined" ? Gr = Pa[Me] : Gr = Go[Me] * Ko[bt], Nr && (Gr *= 6), jr) {
+              for (var mi = 0, Ui = zt; Ui >= 1; ) mi += Gr * Ui * Ui, Ui /= 2;
+              return mi;
+            } else return Gr * zt * Rr;
+          }
+          function of(Me, bt, zt, Rr, jr, Nr, Gr) {
+            var mi = { "don't care": sc, "dont care": sc, nice: Lf, fast: jh }, Ui = { repeat: ql, clamp: Pc, mirror: Do }, qi = { nearest: pl, linear: Zc }, Ei = e({ mipmap: oc, "nearest mipmap nearest": Jl, "linear mipmap nearest": Os, "nearest mipmap linear": yu, "linear mipmap linear": oc }, qi), Hn = { none: 0, browser: lc }, en = { uint8: Ns, rgba4: ll, rgb565: zl, "rgb5 a1": ul }, Wi = { alpha: _o, luminance: po, "luminance alpha": Lo, rgb: No, rgba: Ma, rgba4: ko, "rgb5 a1": Ds, rgb565: Fs }, si = {};
+            bt.ext_srgb && (Wi.srgb = cl, Wi.srgba = Ks), bt.oes_texture_float && (en.float32 = en.float = aa), bt.oes_texture_half_float && (en.float16 = en["half float"] = zs), bt.webgl_depth_texture && (e(Wi, { depth: il, "depth stencil": As }), e(en, { uint16: Hl, uint32: ac, "depth stencil": us })), bt.webgl_compressed_texture_s3tc && e(si, { "rgb s3tc dxt1": Io, "rgba s3tc dxt1": ls, "rgba s3tc dxt3": Yl, "rgba s3tc dxt5": Su }), bt.webgl_compressed_texture_atc && e(si, { "rgb atc": nc, "rgba atc explicit alpha": bs, "rgba atc interpolated alpha": Rn }), bt.webgl_compressed_texture_pvrtc && e(si, { "rgb pvrtc 4bppv1": _a, "rgb pvrtc 2bppv1": Vu, "rgba pvrtc 4bppv1": Ol, "rgba pvrtc 2bppv1": xo }), bt.webgl_compressed_texture_etc1 && (si["rgb etc1"] = Kl);
+            var Mr = Array.prototype.slice.call(Me.getParameter(Li));
+            Object.keys(si).forEach(function(ne) {
+              var we = si[ne];
+              Mr.indexOf(we) >= 0 && (Wi[ne] = we);
+            });
+            var Yr = Object.keys(Wi);
+            zt.textureFormats = Yr;
+            var xi = [];
+            Object.keys(Wi).forEach(function(ne) {
+              var we = Wi[ne];
+              xi[we] = ne;
+            });
+            var Ri = [];
+            Object.keys(en).forEach(function(ne) {
+              var we = en[ne];
+              Ri[we] = ne;
+            });
+            var ci = [];
+            Object.keys(qi).forEach(function(ne) {
+              var we = qi[ne];
+              ci[we] = ne;
+            });
+            var an = [];
+            Object.keys(Ei).forEach(function(ne) {
+              var we = Ei[ne];
+              an[we] = ne;
+            });
+            var Zi = [];
+            Object.keys(Ui).forEach(function(ne) {
+              var we = Ui[ne];
+              Zi[we] = ne;
+            });
+            var Bn = Yr.reduce(function(ne, we) {
+              var Ue = Wi[we];
+              return Ue === po || Ue === _o || Ue === po || Ue === Lo || Ue === il || Ue === As || bt.ext_srgb && (Ue === cl || Ue === Ks) ? ne[Ue] = Ue : Ue === Ds || we.indexOf("rgba") >= 0 ? ne[Ue] = Ma : ne[Ue] = No, ne;
+            }, {});
+            function hi() {
+              this.internalformat = Ma, this.format = Ma, this.type = Ns, this.compressed = false, this.premultiplyAlpha = false, this.flipY = false, this.unpackAlignment = 1, this.colorSpace = lc, this.width = 0, this.height = 0, this.channels = 0;
+            }
+            function li(ne, we) {
+              ne.internalformat = we.internalformat, ne.format = we.format, ne.type = we.type, ne.compressed = we.compressed, ne.premultiplyAlpha = we.premultiplyAlpha, ne.flipY = we.flipY, ne.unpackAlignment = we.unpackAlignment, ne.colorSpace = we.colorSpace, ne.width = we.width, ne.height = we.height, ne.channels = we.channels;
+            }
+            function mn(ne, we) {
+              if (!(typeof we != "object" || !we)) {
+                if ("premultiplyAlpha" in we && (ne.premultiplyAlpha = we.premultiplyAlpha), "flipY" in we && (ne.flipY = we.flipY), "alignment" in we && (ne.unpackAlignment = we.alignment), "colorSpace" in we && (ne.colorSpace = Hn[we.colorSpace]), "type" in we) {
+                  var Ue = we.type;
+                  ne.type = en[Ue];
+                }
+                var ft = ne.width, Zt = ne.height, hr = ne.channels, qt = false;
+                "shape" in we ? (ft = we.shape[0], Zt = we.shape[1], we.shape.length === 3 && (hr = we.shape[2], qt = true)) : ("radius" in we && (ft = Zt = we.radius), "width" in we && (ft = we.width), "height" in we && (Zt = we.height), "channels" in we && (hr = we.channels, qt = true)), ne.width = ft | 0, ne.height = Zt | 0, ne.channels = hr | 0;
+                var Ve = false;
+                if ("format" in we) {
+                  var Qe = we.format, at = ne.internalformat = Wi[Qe];
+                  ne.format = Bn[at], Qe in en && ("type" in we || (ne.type = en[Qe])), Qe in si && (ne.compressed = true), Ve = true;
+                }
+                !qt && Ve ? ne.channels = Go[ne.format] : qt && !Ve && ne.channels !== Hs[ne.format] && (ne.format = ne.internalformat = Hs[ne.channels]);
+              }
+            }
+            function Ji(ne) {
+              Me.pixelStorei(Gf, ne.flipY), Me.pixelStorei($l, ne.premultiplyAlpha), Me.pixelStorei(fl, ne.colorSpace), Me.pixelStorei(nf, ne.unpackAlignment);
+            }
+            function Vi() {
+              hi.call(this), this.xOffset = 0, this.yOffset = 0, this.data = null, this.needsFree = false, this.element = null, this.needsCopy = false;
+            }
+            function Ni(ne, we) {
+              var Ue = null;
+              if (_f(we) ? Ue = we : we && (mn(ne, we), "x" in we && (ne.xOffset = we.x | 0), "y" in we && (ne.yOffset = we.y | 0), _f(we.data) && (Ue = we.data)), we.copy) {
+                var ft = jr.viewportWidth, Zt = jr.viewportHeight;
+                ne.width = ne.width || ft - ne.xOffset, ne.height = ne.height || Zt - ne.yOffset, ne.needsCopy = true;
+              } else if (!Ue) ne.width = ne.width || 1, ne.height = ne.height || 1, ne.channels = ne.channels || 4;
+              else if (Br(Ue)) ne.channels = ne.channels || 4, ne.data = Ue, !("type" in we) && ne.type === Ns && (ne.type = Yc(Ue));
+              else if (af(Ue)) ne.channels = ne.channels || 4, eh(ne, Ue), ne.alignment = 1, ne.needsFree = true;
+              else if (Vr(Ue)) {
+                var hr = Ue.data;
+                !Array.isArray(hr) && ne.type === Ns && (ne.type = Yc(hr));
+                var qt = Ue.shape, Ve = Ue.stride, Qe, at, Ct, Ot, Rt, Bt;
+                qt.length === 3 ? (Ct = qt[2], Bt = Ve[2]) : (Ct = 1, Bt = 1), Qe = qt[0], at = qt[1], Ot = Ve[0], Rt = Ve[1], ne.alignment = 1, ne.width = Qe, ne.height = at, ne.channels = Ct, ne.format = ne.internalformat = Hs[Ct], ne.needsFree = true, jf(ne, hr, Ot, Rt, Bt, Ue.offset);
+              } else if (Hf(Ue) || Ic(Ue) || yf(Ue)) Hf(Ue) || Ic(Ue) ? ne.element = Ue : ne.element = Ue.canvas, ne.width = ne.element.width, ne.height = ne.element.height, ne.channels = 4;
+              else if (Bl(Ue)) ne.element = Ue, ne.width = Ue.width, ne.height = Ue.height, ne.channels = 4;
+              else if (Ah(Ue)) ne.element = Ue, ne.width = Ue.naturalWidth, ne.height = Ue.naturalHeight, ne.channels = 4;
+              else if (Qf(Ue)) ne.element = Ue, ne.width = Ue.videoWidth, ne.height = Ue.videoHeight, ne.channels = 4;
+              else if (Hu(Ue)) {
+                var Dt = ne.width || Ue[0].length, yt = ne.height || Ue.length, Pt = ne.channels;
+                Mn(Ue[0][0]) ? Pt = Pt || Ue[0][0].length : Pt = Pt || 1;
+                for (var ht = Ge.shape(Ue), ur = 1, br = 0; br < ht.length; ++br) ur *= ht[br];
+                var Ur = th(ne, ur);
+                Ge.flatten(Ue, ht, "", Ur), ju(ne, Ur), ne.alignment = 1, ne.width = Dt, ne.height = yt, ne.channels = Pt, ne.format = ne.internalformat = Hs[Pt], ne.needsFree = true;
+              }
+              ne.type === aa || ne.type;
+            }
+            function pn(ne, we, Ue) {
+              var ft = ne.element, Zt = ne.data, hr = ne.internalformat, qt = ne.format, Ve = ne.type, Qe = ne.width, at = ne.height;
+              Ji(ne), ft ? Me.texImage2D(we, Ue, qt, qt, Ve, ft) : ne.compressed ? Me.compressedTexImage2D(we, Ue, hr, Qe, at, 0, Zt) : ne.needsCopy ? (Rr(), Me.copyTexImage2D(we, Ue, qt, ne.xOffset, ne.yOffset, Qe, at, 0)) : Me.texImage2D(we, Ue, qt, Qe, at, 0, qt, Ve, Zt || null);
+            }
+            function Vn(ne, we, Ue, ft, Zt) {
+              var hr = ne.element, qt = ne.data, Ve = ne.internalformat, Qe = ne.format, at = ne.type, Ct = ne.width, Ot = ne.height;
+              Ji(ne), hr ? Me.texSubImage2D(we, Zt, Ue, ft, Qe, at, hr) : ne.compressed ? Me.compressedTexSubImage2D(we, Zt, Ue, ft, Ve, Ct, Ot, qt) : ne.needsCopy ? (Rr(), Me.copyTexSubImage2D(we, Zt, Ue, ft, ne.xOffset, ne.yOffset, Ct, Ot)) : Me.texSubImage2D(we, Zt, Ue, ft, Ct, Ot, Qe, at, qt);
+            }
+            var na = [];
+            function Ki() {
+              return na.pop() || new Vi();
+            }
+            function kn(ne) {
+              ne.needsFree && H.freeType(ne.data), Vi.call(ne), na.push(ne);
+            }
+            function ta() {
+              hi.call(this), this.genMipmaps = false, this.mipmapHint = sc, this.mipmask = 0, this.images = Array(16);
+            }
+            function oa(ne, we, Ue) {
+              var ft = ne.images[0] = Ki();
+              ne.mipmask = 1, ft.width = ne.width = we, ft.height = ne.height = Ue, ft.channels = ne.channels = 4;
+            }
+            function ba(ne, we) {
+              var Ue = null;
+              if (_f(we)) Ue = ne.images[0] = Ki(), li(Ue, ne), Ni(Ue, we), ne.mipmask = 1;
+              else if (mn(ne, we), Array.isArray(we.mipmap)) for (var ft = we.mipmap, Zt = 0; Zt < ft.length; ++Zt) Ue = ne.images[Zt] = Ki(), li(Ue, ne), Ue.width >>= Zt, Ue.height >>= Zt, Ni(Ue, ft[Zt]), ne.mipmask |= 1 << Zt;
+              else Ue = ne.images[0] = Ki(), li(Ue, ne), Ni(Ue, we), ne.mipmask = 1;
+              li(ne, ne.images[0]), ne.compressed && (ne.internalformat === Io || ne.internalformat === ls || ne.internalformat === Yl || ne.internalformat);
+            }
+            function is(ne, we) {
+              for (var Ue = ne.images, ft = 0; ft < Ue.length; ++ft) {
+                if (!Ue[ft]) return;
+                pn(Ue[ft], we, ft);
+              }
+            }
+            var Zs = [];
+            function Va() {
+              var ne = Zs.pop() || new ta();
+              hi.call(ne), ne.mipmask = 0;
+              for (var we = 0; we < 16; ++we) ne.images[we] = null;
+              return ne;
+            }
+            function Ml(ne) {
+              for (var we = ne.images, Ue = 0; Ue < we.length; ++Ue) we[Ue] && kn(we[Ue]), we[Ue] = null;
+              Zs.push(ne);
+            }
+            function zo() {
+              this.minFilter = pl, this.magFilter = pl, this.wrapS = Pc, this.wrapT = Pc, this.anisotropic = 1, this.genMipmaps = false, this.mipmapHint = sc;
+            }
+            function Qs(ne, we) {
+              if ("min" in we) {
+                var Ue = we.min;
+                ne.minFilter = Ei[Ue], Es.indexOf(ne.minFilter) >= 0 && !("faces" in we) && (ne.genMipmaps = true);
+              }
+              if ("mag" in we) {
+                var ft = we.mag;
+                ne.magFilter = qi[ft];
+              }
+              var Zt = ne.wrapS, hr = ne.wrapT;
+              if ("wrap" in we) {
+                var qt = we.wrap;
+                typeof qt == "string" ? Zt = hr = Ui[qt] : Array.isArray(qt) && (Zt = Ui[qt[0]], hr = Ui[qt[1]]);
+              } else {
+                if ("wrapS" in we) {
+                  var Ve = we.wrapS;
+                  Zt = Ui[Ve];
+                }
+                if ("wrapT" in we) {
+                  var Qe = we.wrapT;
+                  hr = Ui[Qe];
+                }
+              }
+              if (ne.wrapS = Zt, ne.wrapT = hr, "anisotropic" in we) {
+                we.anisotropic;
+                ne.anisotropic = we.anisotropic;
+              }
+              if ("mipmap" in we) {
+                var Ct = false;
+                switch (typeof we.mipmap) {
+                  case "string":
+                    ne.mipmapHint = mi[we.mipmap], ne.genMipmaps = true, Ct = true;
+                    break;
+                  case "boolean":
+                    Ct = ne.genMipmaps = we.mipmap;
+                    break;
+                  case "object":
+                    ne.genMipmaps = false, Ct = true;
+                    break;
+                }
+                Ct && !("min" in we) && (ne.minFilter = Jl);
+              }
+            }
+            function al(ne, we) {
+              Me.texParameteri(we, Vf, ne.minFilter), Me.texParameteri(we, rf, ne.magFilter), Me.texParameteri(we, Oo, ne.wrapS), Me.texParameteri(we, qo, ne.wrapT), bt.ext_texture_filter_anisotropic && Me.texParameteri(we, cs, ne.anisotropic), ne.genMipmaps && (Me.hint(Cf, ne.mipmapHint), Me.generateMipmap(we));
+            }
+            var Vl = 0, ss = {}, Vs = zt.maxTextureUnits, Ys = Array(Vs).map(function() {
+              return null;
+            });
+            function wa(ne) {
+              hi.call(this), this.mipmask = 0, this.internalformat = Ma, this.id = Vl++, this.refCount = 1, this.target = ne, this.texture = Me.createTexture(), this.unit = -1, this.bindCount = 0, this.texInfo = new zo(), Gr.profile && (this.stats = { size: 0 });
+            }
+            function ol(ne) {
+              Me.activeTexture(Fu), Me.bindTexture(ne.target, ne.texture);
+            }
+            function io() {
+              var ne = Ys[0];
+              ne ? Me.bindTexture(ne.target, ne.texture) : Me.bindTexture(_n, null);
+            }
+            function Y(ne) {
+              var we = ne.texture, Ue = ne.unit, ft = ne.target;
+              Ue >= 0 && (Me.activeTexture(Fu + Ue), Me.bindTexture(ft, null), Ys[Ue] = null), Me.deleteTexture(we), ne.texture = null, ne.params = null, ne.pixels = null, ne.refCount = 0, delete ss[ne.id], Nr.textureCount--;
+            }
+            e(wa.prototype, { bind: function() {
+              var ne = this;
+              ne.bindCount += 1;
+              var we = ne.unit;
+              if (we < 0) {
+                for (var Ue = 0; Ue < Vs; ++Ue) {
+                  var ft = Ys[Ue];
+                  if (ft) {
+                    if (ft.bindCount > 0) continue;
+                    ft.unit = -1;
+                  }
+                  Ys[Ue] = ne, we = Ue;
+                  break;
+                }
+                Gr.profile && Nr.maxTextureUnits < we + 1 && (Nr.maxTextureUnits = we + 1), ne.unit = we, Me.activeTexture(Fu + we), Me.bindTexture(ne.target, ne.texture);
+              }
+              return we;
+            }, unbind: function() {
+              this.bindCount -= 1;
+            }, decRef: function() {
+              --this.refCount <= 0 && Y(this);
+            } });
+            function D(ne, we) {
+              var Ue = new wa(_n);
+              ss[Ue.id] = Ue, Nr.textureCount++;
+              function ft(qt, Ve) {
+                var Qe = Ue.texInfo;
+                zo.call(Qe);
+                var at = Va();
+                return typeof qt == "number" ? typeof Ve == "number" ? oa(at, qt | 0, Ve | 0) : oa(at, qt | 0, qt | 0) : qt ? (Qs(Qe, qt), ba(at, qt)) : oa(at, 1, 1), Qe.genMipmaps && (at.mipmask = (at.width << 1) - 1), Ue.mipmask = at.mipmask, li(Ue, at), Ue.internalformat = at.internalformat, ft.width = at.width, ft.height = at.height, ol(Ue), is(at, _n), al(Qe, _n), io(), Ml(at), Gr.profile && (Ue.stats.size = cc(Ue.internalformat, Ue.type, at.width, at.height, Qe.genMipmaps, false)), ft.format = xi[Ue.internalformat], ft.type = Ri[Ue.type], ft.mag = ci[Qe.magFilter], ft.min = an[Qe.minFilter], ft.wrapS = Zi[Qe.wrapS], ft.wrapT = Zi[Qe.wrapT], ft;
+              }
+              function Zt(qt, Ve, Qe, at) {
+                var Ct = Ve | 0, Ot = Qe | 0, Rt = at | 0, Bt = Ki();
+                return li(Bt, Ue), Bt.width = 0, Bt.height = 0, Ni(Bt, qt), Bt.width = Bt.width || (Ue.width >> Rt) - Ct, Bt.height = Bt.height || (Ue.height >> Rt) - Ot, ol(Ue), Vn(Bt, _n, Ct, Ot, Rt), io(), kn(Bt), ft;
+              }
+              function hr(qt, Ve) {
+                var Qe = qt | 0, at = Ve | 0 || Qe;
+                if (Qe === Ue.width && at === Ue.height) return ft;
+                ft.width = Ue.width = Qe, ft.height = Ue.height = at, ol(Ue);
+                for (var Ct = 0; Ue.mipmask >> Ct; ++Ct) {
+                  var Ot = Qe >> Ct, Rt = at >> Ct;
+                  if (!Ot || !Rt) break;
+                  Me.texImage2D(_n, Ct, Ue.format, Ot, Rt, 0, Ue.format, Ue.type, null);
+                }
+                return io(), Gr.profile && (Ue.stats.size = cc(Ue.internalformat, Ue.type, Qe, at, false, false)), ft;
+              }
+              return ft(ne, we), ft.subimage = Zt, ft.resize = hr, ft._reglType = "texture2d", ft._texture = Ue, Gr.profile && (ft.stats = Ue.stats), ft.destroy = function() {
+                Ue.decRef();
+              }, ft;
+            }
+            function J(ne, we, Ue, ft, Zt, hr) {
+              var qt = new wa(ya);
+              ss[qt.id] = qt, Nr.cubeCount++;
+              var Ve = new Array(6);
+              function Qe(Ot, Rt, Bt, Dt, yt, Pt) {
+                var ht, ur = qt.texInfo;
+                for (zo.call(ur), ht = 0; ht < 6; ++ht) Ve[ht] = Va();
+                if (typeof Ot == "number" || !Ot) {
+                  var br = Ot | 0 || 1;
+                  for (ht = 0; ht < 6; ++ht) oa(Ve[ht], br, br);
+                } else if (typeof Ot == "object") if (Rt) ba(Ve[0], Ot), ba(Ve[1], Rt), ba(Ve[2], Bt), ba(Ve[3], Dt), ba(Ve[4], yt), ba(Ve[5], Pt);
+                else if (Qs(ur, Ot), mn(qt, Ot), "faces" in Ot) {
+                  var Ur = Ot.faces;
+                  for (ht = 0; ht < 6; ++ht) li(Ve[ht], qt), ba(Ve[ht], Ur[ht]);
+                } else for (ht = 0; ht < 6; ++ht) ba(Ve[ht], Ot);
+                for (li(qt, Ve[0]), ur.genMipmaps ? qt.mipmask = (Ve[0].width << 1) - 1 : qt.mipmask = Ve[0].mipmask, qt.internalformat = Ve[0].internalformat, Qe.width = Ve[0].width, Qe.height = Ve[0].height, ol(qt), ht = 0; ht < 6; ++ht) is(Ve[ht], $n + ht);
+                for (al(ur, ya), io(), Gr.profile && (qt.stats.size = cc(qt.internalformat, qt.type, Qe.width, Qe.height, ur.genMipmaps, true)), Qe.format = xi[qt.internalformat], Qe.type = Ri[qt.type], Qe.mag = ci[ur.magFilter], Qe.min = an[ur.minFilter], Qe.wrapS = Zi[ur.wrapS], Qe.wrapT = Zi[ur.wrapT], ht = 0; ht < 6; ++ht) Ml(Ve[ht]);
+                return Qe;
+              }
+              function at(Ot, Rt, Bt, Dt, yt) {
+                var Pt = Bt | 0, ht = Dt | 0, ur = yt | 0, br = Ki();
+                return li(br, qt), br.width = 0, br.height = 0, Ni(br, Rt), br.width = br.width || (qt.width >> ur) - Pt, br.height = br.height || (qt.height >> ur) - ht, ol(qt), Vn(br, $n + Ot, Pt, ht, ur), io(), kn(br), Qe;
+              }
+              function Ct(Ot) {
+                var Rt = Ot | 0;
+                if (Rt !== qt.width) {
+                  Qe.width = qt.width = Rt, Qe.height = qt.height = Rt, ol(qt);
+                  for (var Bt = 0; Bt < 6; ++Bt) for (var Dt = 0; qt.mipmask >> Dt; ++Dt) Me.texImage2D($n + Bt, Dt, qt.format, Rt >> Dt, Rt >> Dt, 0, qt.format, qt.type, null);
+                  return io(), Gr.profile && (qt.stats.size = cc(qt.internalformat, qt.type, Qe.width, Qe.height, false, true)), Qe;
+                }
+              }
+              return Qe(ne, we, Ue, ft, Zt, hr), Qe.subimage = at, Qe.resize = Ct, Qe._reglType = "textureCube", Qe._texture = qt, Gr.profile && (Qe.stats = qt.stats), Qe.destroy = function() {
+                qt.decRef();
+              }, Qe;
+            }
+            function q() {
+              for (var ne = 0; ne < Vs; ++ne) Me.activeTexture(Fu + ne), Me.bindTexture(_n, null), Ys[ne] = null;
+              dt(ss).forEach(Y), Nr.cubeCount = 0, Nr.textureCount = 0;
+            }
+            Gr.profile && (Nr.getTotalTextureSize = function() {
+              var ne = 0;
+              return Object.keys(ss).forEach(function(we) {
+                ne += ss[we].stats.size;
+              }), ne;
+            });
+            function K() {
+              for (var ne = 0; ne < Vs; ++ne) {
+                var we = Ys[ne];
+                we && (we.bindCount = 0, we.unit = -1, Ys[ne] = null);
+              }
+              dt(ss).forEach(function(Ue) {
+                Ue.texture = Me.createTexture(), Me.bindTexture(Ue.target, Ue.texture);
+                for (var ft = 0; ft < 32; ++ft) if ((Ue.mipmask & 1 << ft) !== 0) if (Ue.target === _n) Me.texImage2D(_n, ft, Ue.internalformat, Ue.width >> ft, Ue.height >> ft, 0, Ue.internalformat, Ue.type, null);
+                else for (var Zt = 0; Zt < 6; ++Zt) Me.texImage2D($n + Zt, ft, Ue.internalformat, Ue.width >> ft, Ue.height >> ft, 0, Ue.internalformat, Ue.type, null);
+                al(Ue.texInfo, Ue.target);
+              });
+            }
+            function de() {
+              for (var ne = 0; ne < Vs; ++ne) {
+                var we = Ys[ne];
+                we && (we.bindCount = 0, we.unit = -1, Ys[ne] = null), Me.activeTexture(Fu + ne), Me.bindTexture(_n, null), Me.bindTexture(ya, null);
+              }
+            }
+            return { create2D: D, createCube: J, clear: q, getTexture: function(ne) {
+              return null;
+            }, restore: K, refresh: de };
+          }
+          var Nl = 36161, Kc = 32854, Rc = 32855, gs = 36194, Wf = 33189, Wh = 36168, rh = 34041, sf = 35907, Sh = 34836, Mu = 34842, ih = 34843, js = [];
+          js[Kc] = 2, js[Rc] = 2, js[gs] = 2, js[Wf] = 2, js[Wh] = 1, js[rh] = 4, js[sf] = 4, js[Sh] = 16, js[Mu] = 8, js[ih] = 6;
+          function Eu(Me, bt, zt) {
+            return js[Me] * bt * zt;
+          }
+          var Dc = function(Me, bt, zt, Rr, jr) {
+            var Nr = { rgba4: Kc, rgb565: gs, "rgb5 a1": Rc, depth: Wf, stencil: Wh, "depth stencil": rh };
+            bt.ext_srgb && (Nr.srgba = sf), bt.ext_color_buffer_half_float && (Nr.rgba16f = Mu, Nr.rgb16f = ih), bt.webgl_color_buffer_float && (Nr.rgba32f = Sh);
+            var Gr = [];
+            Object.keys(Nr).forEach(function(Wi) {
+              var si = Nr[Wi];
+              Gr[si] = Wi;
+            });
+            var mi = 0, Ui = {};
+            function qi(Wi) {
+              this.id = mi++, this.refCount = 1, this.renderbuffer = Wi, this.format = Kc, this.width = 0, this.height = 0, jr.profile && (this.stats = { size: 0 });
+            }
+            qi.prototype.decRef = function() {
+              --this.refCount <= 0 && Ei(this);
+            };
+            function Ei(Wi) {
+              var si = Wi.renderbuffer;
+              Me.bindRenderbuffer(Nl, null), Me.deleteRenderbuffer(si), Wi.renderbuffer = null, Wi.refCount = 0, delete Ui[Wi.id], Rr.renderbufferCount--;
+            }
+            function Hn(Wi, si) {
+              var Mr = new qi(Me.createRenderbuffer());
+              Ui[Mr.id] = Mr, Rr.renderbufferCount++;
+              function Yr(Ri, ci) {
+                var an = 0, Zi = 0, Bn = Kc;
+                if (typeof Ri == "object" && Ri) {
+                  var hi = Ri;
+                  if ("shape" in hi) {
+                    var li = hi.shape;
+                    an = li[0] | 0, Zi = li[1] | 0;
+                  } else "radius" in hi && (an = Zi = hi.radius | 0), "width" in hi && (an = hi.width | 0), "height" in hi && (Zi = hi.height | 0);
+                  "format" in hi && (Bn = Nr[hi.format]);
+                } else typeof Ri == "number" ? (an = Ri | 0, typeof ci == "number" ? Zi = ci | 0 : Zi = an) : Ri || (an = Zi = 1);
+                if (!(an === Mr.width && Zi === Mr.height && Bn === Mr.format)) return Yr.width = Mr.width = an, Yr.height = Mr.height = Zi, Mr.format = Bn, Me.bindRenderbuffer(Nl, Mr.renderbuffer), Me.renderbufferStorage(Nl, Bn, an, Zi), jr.profile && (Mr.stats.size = Eu(Mr.format, Mr.width, Mr.height)), Yr.format = Gr[Mr.format], Yr;
+              }
+              function xi(Ri, ci) {
+                var an = Ri | 0, Zi = ci | 0 || an;
+                return an === Mr.width && Zi === Mr.height || (Yr.width = Mr.width = an, Yr.height = Mr.height = Zi, Me.bindRenderbuffer(Nl, Mr.renderbuffer), Me.renderbufferStorage(Nl, Mr.format, an, Zi), jr.profile && (Mr.stats.size = Eu(Mr.format, Mr.width, Mr.height))), Yr;
+              }
+              return Yr(Wi, si), Yr.resize = xi, Yr._reglType = "renderbuffer", Yr._renderbuffer = Mr, jr.profile && (Yr.stats = Mr.stats), Yr.destroy = function() {
+                Mr.decRef();
+              }, Yr;
+            }
+            jr.profile && (Rr.getTotalRenderbufferSize = function() {
+              var Wi = 0;
+              return Object.keys(Ui).forEach(function(si) {
+                Wi += Ui[si].stats.size;
+              }), Wi;
+            });
+            function en() {
+              dt(Ui).forEach(function(Wi) {
+                Wi.renderbuffer = Me.createRenderbuffer(), Me.bindRenderbuffer(Nl, Wi.renderbuffer), Me.renderbufferStorage(Nl, Wi.format, Wi.width, Wi.height);
+              }), Me.bindRenderbuffer(Nl, null);
+            }
+            return { create: Hn, clear: function() {
+              dt(Ui).forEach(Ei);
+            }, restore: en };
+          }, ks = 36160, bc = 36161, hu = 3553, _u = 34069, nl = 36064, nh = 36096, Mh = 36128, zu = 33306, wc = 36193, bd = 5121, xf = 5126, Pf = 6407, Ou = 6408, bf = [];
+          bf[Ou] = 4, bf[Pf] = 3;
+          var jl = [];
+          jl[bd] = 1, jl[xf] = 4, jl[wc] = 2;
+          function lf(Me, bt, zt, Rr, jr, Nr) {
+            var Gr = { cur: null, next: null, dirty: false, setFBO: null }, mi = ["rgba"], Ui = ["rgba4", "rgb565", "rgb5 a1"];
+            bt.ext_srgb && Ui.push("srgba"), bt.ext_color_buffer_half_float && Ui.push("rgba16f", "rgb16f"), bt.webgl_color_buffer_float && Ui.push("rgba32f");
+            var qi = ["uint8"];
+            bt.oes_texture_half_float && qi.push("half float", "float16"), bt.oes_texture_float && qi.push("float", "float32");
+            function Ei(Vi, Ni, pn) {
+              this.target = Vi, this.texture = Ni, this.renderbuffer = pn;
+              var Vn = 0, na = 0;
+              Ni ? (Vn = Ni.width, na = Ni.height) : pn && (Vn = pn.width, na = pn.height), this.width = Vn, this.height = na;
+            }
+            function Hn(Vi) {
+              Vi && (Vi.texture && Vi.texture._texture.decRef(), Vi.renderbuffer && Vi.renderbuffer._renderbuffer.decRef());
+            }
+            function en(Vi, Ni, pn) {
+              if (Vi) if (Vi.texture) {
+                var Vn = Vi.texture._texture;
+                Math.max(1, Vn.width);
+                Math.max(1, Vn.height);
+                Vn.refCount += 1;
+              } else {
+                var kn = Vi.renderbuffer._renderbuffer;
+                kn.refCount += 1;
+              }
+            }
+            function Wi(Vi, Ni) {
+              Ni && (Ni.texture ? Me.framebufferTexture2D(ks, Vi, Ni.target, Ni.texture._texture.texture, 0) : Me.framebufferRenderbuffer(ks, Vi, bc, Ni.renderbuffer._renderbuffer.renderbuffer));
+            }
+            function si(Vi) {
+              var Ni = hu, pn = null, Vn = null, na = Vi;
+              typeof Vi == "object" && (na = Vi.data, "target" in Vi && (Ni = Vi.target | 0));
+              var Ki = na._reglType;
+              return Ki === "texture2d" || Ki === "textureCube" ? pn = na : Ki === "renderbuffer" && (Vn = na, Ni = bc), new Ei(Ni, pn, Vn);
+            }
+            function Mr(Vi, Ni, pn, Vn, na) {
+              if (pn) {
+                var Ki = Rr.create2D({ width: Vi, height: Ni, format: Vn, type: na });
+                return Ki._texture.refCount = 0, new Ei(hu, Ki, null);
+              } else {
+                var kn = jr.create({ width: Vi, height: Ni, format: Vn });
+                return kn._renderbuffer.refCount = 0, new Ei(bc, null, kn);
+              }
+            }
+            function Yr(Vi) {
+              return Vi && (Vi.texture || Vi.renderbuffer);
+            }
+            function xi(Vi, Ni, pn) {
+              Vi && (Vi.texture ? Vi.texture.resize(Ni, pn) : Vi.renderbuffer && Vi.renderbuffer.resize(Ni, pn), Vi.width = Ni, Vi.height = pn);
+            }
+            var Ri = 0, ci = {};
+            function an() {
+              this.id = Ri++, ci[this.id] = this, this.framebuffer = Me.createFramebuffer(), this.width = 0, this.height = 0, this.colorAttachments = [], this.depthAttachment = null, this.stencilAttachment = null, this.depthStencilAttachment = null;
+            }
+            function Zi(Vi) {
+              Vi.colorAttachments.forEach(Hn), Hn(Vi.depthAttachment), Hn(Vi.stencilAttachment), Hn(Vi.depthStencilAttachment);
+            }
+            function Bn(Vi) {
+              var Ni = Vi.framebuffer;
+              Me.deleteFramebuffer(Ni), Vi.framebuffer = null, Nr.framebufferCount--, delete ci[Vi.id];
+            }
+            function hi(Vi) {
+              var Ni;
+              Me.bindFramebuffer(ks, Vi.framebuffer);
+              var pn = Vi.colorAttachments;
+              for (Ni = 0; Ni < pn.length; ++Ni) Wi(nl + Ni, pn[Ni]);
+              for (Ni = pn.length; Ni < zt.maxColorAttachments; ++Ni) Me.framebufferTexture2D(ks, nl + Ni, hu, null, 0);
+              Me.framebufferTexture2D(ks, zu, hu, null, 0), Me.framebufferTexture2D(ks, nh, hu, null, 0), Me.framebufferTexture2D(ks, Mh, hu, null, 0), Wi(nh, Vi.depthAttachment), Wi(Mh, Vi.stencilAttachment), Wi(zu, Vi.depthStencilAttachment);
+              Me.checkFramebufferStatus(ks);
+              Me.isContextLost(), Me.bindFramebuffer(ks, Gr.next ? Gr.next.framebuffer : null), Gr.cur = Gr.next, Me.getError();
+            }
+            function li(Vi, Ni) {
+              var pn = new an();
+              Nr.framebufferCount++;
+              function Vn(Ki, kn) {
+                var ta, oa = 0, ba = 0, is = true, Zs = true, Va = null, Ml = true, zo = "rgba", Qs = "uint8", al = 1, Vl = null, ss = null, Vs = null, Ys = false;
+                if (typeof Ki == "number") oa = Ki | 0, ba = kn | 0 || oa;
+                else if (!Ki) oa = ba = 1;
+                else {
+                  var wa = Ki;
+                  if ("shape" in wa) {
+                    var ol = wa.shape;
+                    oa = ol[0], ba = ol[1];
+                  } else "radius" in wa && (oa = ba = wa.radius), "width" in wa && (oa = wa.width), "height" in wa && (ba = wa.height);
+                  ("color" in wa || "colors" in wa) && (Va = wa.color || wa.colors, Array.isArray(Va)), Va || ("colorCount" in wa && (al = wa.colorCount | 0), "colorTexture" in wa && (Ml = !!wa.colorTexture, zo = "rgba4"), "colorType" in wa && (Qs = wa.colorType, Ml || (Qs === "half float" || Qs === "float16" ? zo = "rgba16f" : (Qs === "float" || Qs === "float32") && (zo = "rgba32f"))), "colorFormat" in wa && (zo = wa.colorFormat, mi.indexOf(zo) >= 0 ? Ml = true : Ui.indexOf(zo) >= 0 && (Ml = false))), ("depthTexture" in wa || "depthStencilTexture" in wa) && (Ys = !!(wa.depthTexture || wa.depthStencilTexture)), "depth" in wa && (typeof wa.depth == "boolean" ? is = wa.depth : (Vl = wa.depth, Zs = false)), "stencil" in wa && (typeof wa.stencil == "boolean" ? Zs = wa.stencil : (ss = wa.stencil, is = false)), "depthStencil" in wa && (typeof wa.depthStencil == "boolean" ? is = Zs = wa.depthStencil : (Vs = wa.depthStencil, is = false, Zs = false));
+                }
+                var io = null, Y = null, D = null, J = null;
+                if (Array.isArray(Va)) io = Va.map(si);
+                else if (Va) io = [si(Va)];
+                else for (io = new Array(al), ta = 0; ta < al; ++ta) io[ta] = Mr(oa, ba, Ml, zo, Qs);
+                oa = oa || io[0].width, ba = ba || io[0].height, Vl ? Y = si(Vl) : is && !Zs && (Y = Mr(oa, ba, Ys, "depth", "uint32")), ss ? D = si(ss) : Zs && !is && (D = Mr(oa, ba, false, "stencil", "uint8")), Vs ? J = si(Vs) : !Vl && !ss && Zs && is && (J = Mr(oa, ba, Ys, "depth stencil", "depth stencil"));
+                for (ta = 0; ta < io.length; ++ta) if (en(io[ta]), io[ta] && io[ta].texture) {
+                  bf[io[ta].texture._texture.format] * jl[io[ta].texture._texture.type];
+                }
+                return en(Y), en(D), en(J), Zi(pn), pn.width = oa, pn.height = ba, pn.colorAttachments = io, pn.depthAttachment = Y, pn.stencilAttachment = D, pn.depthStencilAttachment = J, Vn.color = io.map(Yr), Vn.depth = Yr(Y), Vn.stencil = Yr(D), Vn.depthStencil = Yr(J), Vn.width = pn.width, Vn.height = pn.height, hi(pn), Vn;
+              }
+              function na(Ki, kn) {
+                var ta = Math.max(Ki | 0, 1), oa = Math.max(kn | 0 || ta, 1);
+                if (ta === pn.width && oa === pn.height) return Vn;
+                for (var ba = pn.colorAttachments, is = 0; is < ba.length; ++is) xi(ba[is], ta, oa);
+                return xi(pn.depthAttachment, ta, oa), xi(pn.stencilAttachment, ta, oa), xi(pn.depthStencilAttachment, ta, oa), pn.width = Vn.width = ta, pn.height = Vn.height = oa, hi(pn), Vn;
+              }
+              return Vn(Vi, Ni), e(Vn, { resize: na, _reglType: "framebuffer", _framebuffer: pn, destroy: function() {
+                Bn(pn), Zi(pn);
+              }, use: function(Ki) {
+                Gr.setFBO({ framebuffer: Vn }, Ki);
+              } });
+            }
+            function mn(Vi) {
+              var Ni = Array(6);
+              function pn(na) {
+                var Ki, kn = { color: null }, ta = 0, oa = null, ba = "rgba", is = "uint8", Zs = 1;
+                if (typeof na == "number") ta = na | 0;
+                else if (!na) ta = 1;
+                else {
+                  var Va = na;
+                  if ("shape" in Va) {
+                    var Ml = Va.shape;
+                    ta = Ml[0];
+                  } else "radius" in Va && (ta = Va.radius | 0), "width" in Va ? (ta = Va.width | 0, "height" in Va) : "height" in Va && (ta = Va.height | 0);
+                  ("color" in Va || "colors" in Va) && (oa = Va.color || Va.colors, Array.isArray(oa)), oa || ("colorCount" in Va && (Zs = Va.colorCount | 0), "colorType" in Va && (is = Va.colorType), "colorFormat" in Va && (ba = Va.colorFormat)), "depth" in Va && (kn.depth = Va.depth), "stencil" in Va && (kn.stencil = Va.stencil), "depthStencil" in Va && (kn.depthStencil = Va.depthStencil);
+                }
+                var zo;
+                if (oa) if (Array.isArray(oa)) for (zo = [], Ki = 0; Ki < oa.length; ++Ki) zo[Ki] = oa[Ki];
+                else zo = [oa];
+                else {
+                  zo = Array(Zs);
+                  var Qs = { radius: ta, format: ba, type: is };
+                  for (Ki = 0; Ki < Zs; ++Ki) zo[Ki] = Rr.createCube(Qs);
+                }
+                for (kn.color = Array(zo.length), Ki = 0; Ki < zo.length; ++Ki) {
+                  var al = zo[Ki];
+                  ta = ta || al.width, kn.color[Ki] = { target: _u, data: zo[Ki] };
+                }
+                for (Ki = 0; Ki < 6; ++Ki) {
+                  for (var Vl = 0; Vl < zo.length; ++Vl) kn.color[Vl].target = _u + Ki;
+                  Ki > 0 && (kn.depth = Ni[0].depth, kn.stencil = Ni[0].stencil, kn.depthStencil = Ni[0].depthStencil), Ni[Ki] ? Ni[Ki](kn) : Ni[Ki] = li(kn);
+                }
+                return e(pn, { width: ta, height: ta, color: zo });
+              }
+              function Vn(na) {
+                var Ki, kn = na | 0;
+                if (kn === pn.width) return pn;
+                var ta = pn.color;
+                for (Ki = 0; Ki < ta.length; ++Ki) ta[Ki].resize(kn);
+                for (Ki = 0; Ki < 6; ++Ki) Ni[Ki].resize(kn);
+                return pn.width = pn.height = kn, pn;
+              }
+              return pn(Vi), e(pn, { faces: Ni, resize: Vn, _reglType: "framebufferCube", destroy: function() {
+                Ni.forEach(function(na) {
+                  na.destroy();
+                });
+              } });
+            }
+            function Ji() {
+              Gr.cur = null, Gr.next = null, Gr.dirty = true, dt(ci).forEach(function(Vi) {
+                Vi.framebuffer = Me.createFramebuffer(), hi(Vi);
+              });
+            }
+            return e(Gr, { getFramebuffer: function(Vi) {
+              if (typeof Vi == "function" && Vi._reglType === "framebuffer") {
+                var Ni = Vi._framebuffer;
+                if (Ni instanceof an) return Ni;
+              }
+              return null;
+            }, create: li, createCube: mn, clear: function() {
+              dt(ci).forEach(Bn);
+            }, restore: Ji });
+          }
+          var Xh = 5126, If = 34962, Cs = 34963;
+          function du() {
+            this.state = 0, this.x = 0, this.y = 0, this.z = 0, this.w = 0, this.buffer = null, this.size = 0, this.normalized = false, this.type = Xh, this.offset = 0, this.stride = 0, this.divisor = 0;
+          }
+          function ku(Me, bt, zt, Rr, jr, Nr, Gr) {
+            for (var mi = zt.maxAttributes, Ui = new Array(mi), qi = 0; qi < mi; ++qi) Ui[qi] = new du();
+            var Ei = 0, Hn = {}, en = { Record: du, scope: {}, state: Ui, currentVAO: null, targetVAO: null, restore: si() ? Zi : function() {
+            }, createVAO: Bn, getVAO: Yr, destroyBuffer: Wi, setVAO: si() ? xi : Ri, clear: si() ? ci : function() {
+            } };
+            function Wi(hi) {
+              for (var li = 0; li < Ui.length; ++li) {
+                var mn = Ui[li];
+                mn.buffer === hi && (Me.disableVertexAttribArray(li), mn.buffer = null);
+              }
+            }
+            function si() {
+              return bt.oes_vertex_array_object;
+            }
+            function Mr() {
+              return bt.angle_instanced_arrays;
+            }
+            function Yr(hi) {
+              return typeof hi == "function" && hi._vao ? hi._vao : null;
+            }
+            function xi(hi) {
+              if (hi !== en.currentVAO) {
+                var li = si();
+                hi ? li.bindVertexArrayOES(hi.vao) : li.bindVertexArrayOES(null), en.currentVAO = hi;
+              }
+            }
+            function Ri(hi) {
+              if (hi !== en.currentVAO) {
+                if (hi) hi.bindAttrs();
+                else {
+                  for (var li = Mr(), mn = 0; mn < Ui.length; ++mn) {
+                    var Ji = Ui[mn];
+                    Ji.buffer ? (Me.enableVertexAttribArray(mn), Ji.buffer.bind(), Me.vertexAttribPointer(mn, Ji.size, Ji.type, Ji.normalized, Ji.stride, Ji.offfset), li && Ji.divisor && li.vertexAttribDivisorANGLE(mn, Ji.divisor)) : (Me.disableVertexAttribArray(mn), Me.vertexAttrib4f(mn, Ji.x, Ji.y, Ji.z, Ji.w));
+                  }
+                  Gr.elements ? Me.bindBuffer(Cs, Gr.elements.buffer.buffer) : Me.bindBuffer(Cs, null);
+                }
+                en.currentVAO = hi;
+              }
+            }
+            function ci() {
+              dt(Hn).forEach(function(hi) {
+                hi.destroy();
+              });
+            }
+            function an() {
+              this.id = ++Ei, this.attributes = [], this.elements = null, this.ownsElements = false, this.count = 0, this.offset = 0, this.instances = -1, this.primitive = 4;
+              var hi = si();
+              hi ? this.vao = hi.createVertexArrayOES() : this.vao = null, Hn[this.id] = this, this.buffers = [];
+            }
+            an.prototype.bindAttrs = function() {
+              for (var hi = Mr(), li = this.attributes, mn = 0; mn < li.length; ++mn) {
+                var Ji = li[mn];
+                Ji.buffer ? (Me.enableVertexAttribArray(mn), Me.bindBuffer(If, Ji.buffer.buffer), Me.vertexAttribPointer(mn, Ji.size, Ji.type, Ji.normalized, Ji.stride, Ji.offset), hi && Ji.divisor && hi.vertexAttribDivisorANGLE(mn, Ji.divisor)) : (Me.disableVertexAttribArray(mn), Me.vertexAttrib4f(mn, Ji.x, Ji.y, Ji.z, Ji.w));
+              }
+              for (var Vi = li.length; Vi < mi; ++Vi) Me.disableVertexAttribArray(Vi);
+              var Ni = Nr.getElements(this.elements);
+              Ni ? Me.bindBuffer(Cs, Ni.buffer.buffer) : Me.bindBuffer(Cs, null);
+            }, an.prototype.refresh = function() {
+              var hi = si();
+              hi && (hi.bindVertexArrayOES(this.vao), this.bindAttrs(), en.currentVAO = null, hi.bindVertexArrayOES(null));
+            }, an.prototype.destroy = function() {
+              if (this.vao) {
+                var hi = si();
+                this === en.currentVAO && (en.currentVAO = null, hi.bindVertexArrayOES(null)), hi.deleteVertexArrayOES(this.vao), this.vao = null;
+              }
+              this.ownsElements && (this.elements.destroy(), this.elements = null, this.ownsElements = false), Hn[this.id] && (delete Hn[this.id], Rr.vaoCount -= 1);
+            };
+            function Zi() {
+              var hi = si();
+              hi && dt(Hn).forEach(function(li) {
+                li.refresh();
+              });
+            }
+            function Bn(hi) {
+              var li = new an();
+              Rr.vaoCount += 1;
+              function mn(Ji) {
+                var Vi;
+                if (Array.isArray(Ji)) Vi = Ji, li.elements && li.ownsElements && li.elements.destroy(), li.elements = null, li.ownsElements = false, li.offset = 0, li.count = 0, li.instances = -1, li.primitive = 4;
+                else {
+                  if (Ji.elements) {
+                    var Ni = Ji.elements;
+                    li.ownsElements ? typeof Ni == "function" && Ni._reglType === "elements" ? (li.elements.destroy(), li.ownsElements = false) : (li.elements(Ni), li.ownsElements = false) : Nr.getElements(Ji.elements) ? (li.elements = Ji.elements, li.ownsElements = false) : (li.elements = Nr.create(Ji.elements), li.ownsElements = true);
+                  } else li.elements = null, li.ownsElements = false;
+                  Vi = Ji.attributes, li.offset = 0, li.count = -1, li.instances = -1, li.primitive = 4, li.elements && (li.count = li.elements._elements.vertCount, li.primitive = li.elements._elements.primType), "offset" in Ji && (li.offset = Ji.offset | 0), "count" in Ji && (li.count = Ji.count | 0), "instances" in Ji && (li.instances = Ji.instances | 0), "primitive" in Ji && (li.primitive = Sn[Ji.primitive]);
+                }
+                var pn = {}, Vn = li.attributes;
+                Vn.length = Vi.length;
+                for (var na = 0; na < Vi.length; ++na) {
+                  var Ki = Vi[na], kn = Vn[na] = new du(), ta = Ki.data || Ki;
+                  if (Array.isArray(ta) || Br(ta) || Vr(ta)) {
+                    var oa;
+                    li.buffers[na] && (oa = li.buffers[na], Br(ta) && oa._buffer.byteLength >= ta.byteLength ? oa.subdata(ta) : (oa.destroy(), li.buffers[na] = null)), li.buffers[na] || (oa = li.buffers[na] = jr.create(Ki, If, false, true)), kn.buffer = jr.getBuffer(oa), kn.size = kn.buffer.dimension | 0, kn.normalized = false, kn.type = kn.buffer.dtype, kn.offset = 0, kn.stride = 0, kn.divisor = 0, kn.state = 1, pn[na] = 1;
+                  } else jr.getBuffer(Ki) ? (kn.buffer = jr.getBuffer(Ki), kn.size = kn.buffer.dimension | 0, kn.normalized = false, kn.type = kn.buffer.dtype, kn.offset = 0, kn.stride = 0, kn.divisor = 0, kn.state = 1) : jr.getBuffer(Ki.buffer) ? (kn.buffer = jr.getBuffer(Ki.buffer), kn.size = (+Ki.size || kn.buffer.dimension) | 0, kn.normalized = !!Ki.normalized || false, "type" in Ki ? kn.type = ji[Ki.type] : kn.type = kn.buffer.dtype, kn.offset = (Ki.offset || 0) | 0, kn.stride = (Ki.stride || 0) | 0, kn.divisor = (Ki.divisor || 0) | 0, kn.state = 1) : "x" in Ki && (kn.x = +Ki.x || 0, kn.y = +Ki.y || 0, kn.z = +Ki.z || 0, kn.w = +Ki.w || 0, kn.state = 2);
+                }
+                for (var ba = 0; ba < li.buffers.length; ++ba) !pn[ba] && li.buffers[ba] && (li.buffers[ba].destroy(), li.buffers[ba] = null);
+                return li.refresh(), mn;
+              }
+              return mn.destroy = function() {
+                for (var Ji = 0; Ji < li.buffers.length; ++Ji) li.buffers[Ji] && li.buffers[Ji].destroy();
+                li.buffers.length = 0, li.ownsElements && (li.elements.destroy(), li.elements = null, li.ownsElements = false), li.destroy();
+              }, mn._vao = li, mn._reglType = "vao", mn(hi);
+            }
+            return en;
+          }
+          var Xf = 35632, Us = 35633, wf = 35718, zc = 35721;
+          function Wu(Me, bt, zt, Rr) {
+            var jr = {}, Nr = {};
+            function Gr(Mr, Yr, xi, Ri) {
+              this.name = Mr, this.id = Yr, this.location = xi, this.info = Ri;
+            }
+            function mi(Mr, Yr) {
+              for (var xi = 0; xi < Mr.length; ++xi) if (Mr[xi].id === Yr.id) {
+                Mr[xi].location = Yr.location;
+                return;
+              }
+              Mr.push(Yr);
+            }
+            function Ui(Mr, Yr, xi) {
+              var Ri = Mr === Xf ? jr : Nr, ci = Ri[Yr];
+              if (!ci) {
+                var an = bt.str(Yr);
+                ci = Me.createShader(Mr), Me.shaderSource(ci, an), Me.compileShader(ci), Ri[Yr] = ci;
+              }
+              return ci;
+            }
+            var qi = {}, Ei = [], Hn = 0;
+            function en(Mr, Yr) {
+              this.id = Hn++, this.fragId = Mr, this.vertId = Yr, this.program = null, this.uniforms = [], this.attributes = [], this.refCount = 1, Rr.profile && (this.stats = { uniformsCount: 0, attributesCount: 0 });
+            }
+            function Wi(Mr, Yr, xi) {
+              var Ri, ci, an = Ui(Xf, Mr.fragId), Zi = Ui(Us, Mr.vertId), Bn = Mr.program = Me.createProgram();
+              if (Me.attachShader(Bn, an), Me.attachShader(Bn, Zi), xi) for (Ri = 0; Ri < xi.length; ++Ri) {
+                var hi = xi[Ri];
+                Me.bindAttribLocation(Bn, hi[0], hi[1]);
+              }
+              Me.linkProgram(Bn);
+              var li = Me.getProgramParameter(Bn, wf);
+              Rr.profile && (Mr.stats.uniformsCount = li);
+              var mn = Mr.uniforms;
+              for (Ri = 0; Ri < li; ++Ri) if (ci = Me.getActiveUniform(Bn, Ri), ci) if (ci.size > 1) for (var Ji = 0; Ji < ci.size; ++Ji) {
+                var Vi = ci.name.replace("[0]", "[" + Ji + "]");
+                mi(mn, new Gr(Vi, bt.id(Vi), Me.getUniformLocation(Bn, Vi), ci));
+              }
+              else mi(mn, new Gr(ci.name, bt.id(ci.name), Me.getUniformLocation(Bn, ci.name), ci));
+              var Ni = Me.getProgramParameter(Bn, zc);
+              Rr.profile && (Mr.stats.attributesCount = Ni);
+              var pn = Mr.attributes;
+              for (Ri = 0; Ri < Ni; ++Ri) ci = Me.getActiveAttrib(Bn, Ri), ci && mi(pn, new Gr(ci.name, bt.id(ci.name), Me.getAttribLocation(Bn, ci.name), ci));
+            }
+            Rr.profile && (zt.getMaxUniformsCount = function() {
+              var Mr = 0;
+              return Ei.forEach(function(Yr) {
+                Yr.stats.uniformsCount > Mr && (Mr = Yr.stats.uniformsCount);
+              }), Mr;
+            }, zt.getMaxAttributesCount = function() {
+              var Mr = 0;
+              return Ei.forEach(function(Yr) {
+                Yr.stats.attributesCount > Mr && (Mr = Yr.stats.attributesCount);
+              }), Mr;
+            });
+            function si() {
+              jr = {}, Nr = {};
+              for (var Mr = 0; Mr < Ei.length; ++Mr) Wi(Ei[Mr], null, Ei[Mr].attributes.map(function(Yr) {
+                return [Yr.location, Yr.name];
+              }));
+            }
+            return { clear: function() {
+              var Mr = Me.deleteShader.bind(Me);
+              dt(jr).forEach(Mr), jr = {}, dt(Nr).forEach(Mr), Nr = {}, Ei.forEach(function(Yr) {
+                Me.deleteProgram(Yr.program);
+              }), Ei.length = 0, qi = {}, zt.shaderCount = 0;
+            }, program: function(Mr, Yr, xi, Ri) {
+              var ci = qi[Yr];
+              ci || (ci = qi[Yr] = {});
+              var an = ci[Mr];
+              if (an && (an.refCount++, !Ri)) return an;
+              var Zi = new en(Yr, Mr);
+              return zt.shaderCount++, Wi(Zi, xi, Ri), an || (ci[Mr] = Zi), Ei.push(Zi), e(Zi, { destroy: function() {
+                if (Zi.refCount--, Zi.refCount <= 0) {
+                  Me.deleteProgram(Zi.program);
+                  var Bn = Ei.indexOf(Zi);
+                  Ei.splice(Bn, 1), zt.shaderCount--;
+                }
+                ci[Zi.vertId].refCount <= 0 && (Me.deleteShader(Nr[Zi.vertId]), delete Nr[Zi.vertId], delete qi[Zi.fragId][Zi.vertId]), Object.keys(qi[Zi.fragId]).length || (Me.deleteShader(jr[Zi.fragId]), delete jr[Zi.fragId], delete qi[Zi.fragId]);
+              } });
+            }, restore: si, shader: Ui, frag: -1, vert: -1 };
+          }
+          var Rf = 6408, Xu = 5121, uf = 3333, Zf = 5126;
+          function Wl(Me, bt, zt, Rr, jr, Nr, Gr) {
+            function mi(Ei) {
+              var Hn;
+              bt.next === null ? Hn = Xu : Hn = bt.next.colorAttachments[0].texture._texture.type;
+              var en = 0, Wi = 0, si = Rr.framebufferWidth, Mr = Rr.framebufferHeight, Yr = null;
+              Br(Ei) ? Yr = Ei : Ei && (en = Ei.x | 0, Wi = Ei.y | 0, si = (Ei.width || Rr.framebufferWidth - en) | 0, Mr = (Ei.height || Rr.framebufferHeight - Wi) | 0, Yr = Ei.data || null), zt();
+              var xi = si * Mr * 4;
+              return Yr || (Hn === Xu ? Yr = new Uint8Array(xi) : Hn === Zf && (Yr = Yr || new Float32Array(xi))), Me.pixelStorei(uf, 4), Me.readPixels(en, Wi, si, Mr, Rf, Hn, Yr), Yr;
+            }
+            function Ui(Ei) {
+              var Hn;
+              return bt.setFBO({ framebuffer: Ei.framebuffer }, function() {
+                Hn = mi(Ei);
+              }), Hn;
+            }
+            function qi(Ei) {
+              return !Ei || !("framebuffer" in Ei) ? mi(Ei) : Ui(Ei);
+            }
+            return qi;
+          }
+          function Oc(Me) {
+            return vu(Tc(fc(Me)));
+          }
+          function Tc(Me) {
+            return At(Yi(Bc(Me), Me.length * 8));
+          }
+          function vu(Me) {
+            for (var bt = "0123456789abcdef", zt = "", Rr, jr = 0; jr < Me.length; jr++) Rr = Me.charCodeAt(jr), zt += bt.charAt(Rr >>> 4 & 15) + bt.charAt(Rr & 15);
+            return zt;
+          }
+          function fc(Me) {
+            for (var bt = "", zt = -1, Rr, jr; ++zt < Me.length; ) Rr = Me.charCodeAt(zt), jr = zt + 1 < Me.length ? Me.charCodeAt(zt + 1) : 0, 55296 <= Rr && Rr <= 56319 && 56320 <= jr && jr <= 57343 && (Rr = 65536 + ((Rr & 1023) << 10) + (jr & 1023), zt++), Rr <= 127 ? bt += String.fromCharCode(Rr) : Rr <= 2047 ? bt += String.fromCharCode(192 | Rr >>> 6 & 31, 128 | Rr & 63) : Rr <= 65535 ? bt += String.fromCharCode(224 | Rr >>> 12 & 15, 128 | Rr >>> 6 & 63, 128 | Rr & 63) : Rr <= 2097151 && (bt += String.fromCharCode(240 | Rr >>> 18 & 7, 128 | Rr >>> 12 & 63, 128 | Rr >>> 6 & 63, 128 | Rr & 63));
+            return bt;
+          }
+          function Bc(Me) {
+            for (var bt = Array(Me.length >> 2), zt = 0; zt < bt.length; zt++) bt[zt] = 0;
+            for (var zt = 0; zt < Me.length * 8; zt += 8) bt[zt >> 5] |= (Me.charCodeAt(zt / 8) & 255) << 24 - zt % 32;
+            return bt;
+          }
+          function At(Me) {
+            for (var bt = "", zt = 0; zt < Me.length * 32; zt += 8) bt += String.fromCharCode(Me[zt >> 5] >>> 24 - zt % 32 & 255);
+            return bt;
+          }
+          function Xt(Me, bt) {
+            return Me >>> bt | Me << 32 - bt;
+          }
+          function Cr(Me, bt) {
+            return Me >>> bt;
+          }
+          function Ar(Me, bt, zt) {
+            return Me & bt ^ ~Me & zt;
+          }
+          function Kr(Me, bt, zt) {
+            return Me & bt ^ Me & zt ^ bt & zt;
+          }
+          function ki(Me) {
+            return Xt(Me, 2) ^ Xt(Me, 13) ^ Xt(Me, 22);
+          }
+          function Xi(Me) {
+            return Xt(Me, 6) ^ Xt(Me, 11) ^ Xt(Me, 25);
+          }
+          function dn(Me) {
+            return Xt(Me, 7) ^ Xt(Me, 18) ^ Cr(Me, 3);
+          }
+          function wn(Me) {
+            return Xt(Me, 17) ^ Xt(Me, 19) ^ Cr(Me, 10);
+          }
+          var Nn = new Array(1116352408, 1899447441, -1245643825, -373957723, 961987163, 1508970993, -1841331548, -1424204075, -670586216, 310598401, 607225278, 1426881987, 1925078388, -2132889090, -1680079193, -1046744716, -459576895, -272742522, 264347078, 604807628, 770255983, 1249150122, 1555081692, 1996064986, -1740746414, -1473132947, -1341970488, -1084653625, -958395405, -710438585, 113926993, 338241895, 666307205, 773529912, 1294757372, 1396182291, 1695183700, 1986661051, -2117940946, -1838011259, -1564481375, -1474664885, -1035236496, -949202525, -778901479, -694614492, -200395387, 275423344, 430227734, 506948616, 659060556, 883997877, 958139571, 1322822218, 1537002063, 1747873779, 1955562222, 2024104815, -2067236844, -1933114872, -1866530822, -1538233109, -1090935817, -965641998);
+          function Yi(Me, bt) {
+            var zt = new Array(1779033703, -1150833019, 1013904242, -1521486534, 1359893119, -1694144372, 528734635, 1541459225), Rr = new Array(64), jr, Nr, Gr, mi, Ui, qi, Ei, Hn, en, Wi, si, Mr;
+            for (Me[bt >> 5] |= 128 << 24 - bt % 32, Me[(bt + 64 >> 9 << 4) + 15] = bt, en = 0; en < Me.length; en += 16) {
+              for (jr = zt[0], Nr = zt[1], Gr = zt[2], mi = zt[3], Ui = zt[4], qi = zt[5], Ei = zt[6], Hn = zt[7], Wi = 0; Wi < 64; Wi++) Wi < 16 ? Rr[Wi] = Me[Wi + en] : Rr[Wi] = Qi(Qi(Qi(wn(Rr[Wi - 2]), Rr[Wi - 7]), dn(Rr[Wi - 15])), Rr[Wi - 16]), si = Qi(Qi(Qi(Qi(Hn, Xi(Ui)), Ar(Ui, qi, Ei)), Nn[Wi]), Rr[Wi]), Mr = Qi(ki(jr), Kr(jr, Nr, Gr)), Hn = Ei, Ei = qi, qi = Ui, Ui = Qi(mi, si), mi = Gr, Gr = Nr, Nr = jr, jr = Qi(si, Mr);
+              zt[0] = Qi(jr, zt[0]), zt[1] = Qi(Nr, zt[1]), zt[2] = Qi(Gr, zt[2]), zt[3] = Qi(mi, zt[3]), zt[4] = Qi(Ui, zt[4]), zt[5] = Qi(qi, zt[5]), zt[6] = Qi(Ei, zt[6]), zt[7] = Qi(Hn, zt[7]);
+            }
+            return zt;
+          }
+          function Qi(Me, bt) {
+            var zt = (Me & 65535) + (bt & 65535), Rr = (Me >> 16) + (bt >> 16) + (zt >> 16);
+            return Rr << 16 | zt & 65535;
+          }
+          function on(Me) {
+            return Array.prototype.slice.call(Me);
+          }
+          function Fi(Me) {
+            return on(Me).join("");
+          }
+          function Qn(Me) {
+            var bt = Me && Me.cache, zt = 0, Rr = [], jr = [], Nr = [];
+            function Gr(si, Mr) {
+              var Yr = Mr && Mr.stable;
+              if (!Yr) {
+                for (var xi = 0; xi < jr.length; ++xi) if (jr[xi] === si && !Nr[xi]) return Rr[xi];
+              }
+              var Ri = "g" + zt++;
+              return Rr.push(Ri), jr.push(si), Nr.push(Yr), Ri;
+            }
+            function mi() {
+              var si = [];
+              function Mr() {
+                si.push.apply(si, on(arguments));
+              }
+              var Yr = [];
+              function xi() {
+                var Ri = "v" + zt++;
+                return Yr.push(Ri), arguments.length > 0 && (si.push(Ri, "="), si.push.apply(si, on(arguments)), si.push(";")), Ri;
+              }
+              return e(Mr, { def: xi, toString: function() {
+                return Fi([Yr.length > 0 ? "var " + Yr.join(",") + ";" : "", Fi(si)]);
+              } });
+            }
+            function Ui() {
+              var si = mi(), Mr = mi(), Yr = si.toString, xi = Mr.toString;
+              function Ri(ci, an) {
+                Mr(ci, an, "=", si.def(ci, an), ";");
+              }
+              return e(function() {
+                si.apply(si, on(arguments));
+              }, { def: si.def, entry: si, exit: Mr, save: Ri, set: function(ci, an, Zi) {
+                Ri(ci, an), si(ci, an, "=", Zi, ";");
+              }, toString: function() {
+                return Yr() + xi();
+              } });
+            }
+            function qi() {
+              var si = Fi(arguments), Mr = Ui(), Yr = Ui(), xi = Mr.toString, Ri = Yr.toString;
+              return e(Mr, { then: function() {
+                return Mr.apply(Mr, on(arguments)), this;
+              }, else: function() {
+                return Yr.apply(Yr, on(arguments)), this;
+              }, toString: function() {
+                var ci = Ri();
+                return ci && (ci = "else{" + ci + "}"), Fi(["if(", si, "){", xi(), "}", ci]);
+              } });
+            }
+            var Ei = mi(), Hn = {};
+            function en(si, Mr) {
+              var Yr = [];
+              function xi() {
+                var Bn = "a" + Yr.length;
+                return Yr.push(Bn), Bn;
+              }
+              Mr = Mr || 0;
+              for (var Ri = 0; Ri < Mr; ++Ri) xi();
+              var ci = Ui(), an = ci.toString, Zi = Hn[si] = e(ci, { arg: xi, toString: function() {
+                return Fi(["function(", Yr.join(), "){", an(), "}"]);
+              } });
+              return Zi;
+            }
+            function Wi() {
+              var si = ['"use strict";', Ei, "return {"];
+              Object.keys(Hn).forEach(function(Ri) {
+                si.push('"', Ri, '":', Hn[Ri].toString(), ",");
+              }), si.push("}");
+              var Mr = Fi(si).replace(/;/g, `;
+`).replace(/}/g, `}
+`).replace(/{/g, `{
+`), Yr;
+              if (bt && (Yr = Oc(Mr), bt[Yr])) return bt[Yr].apply(null, jr);
+              var xi = Function.apply(null, Rr.concat(Mr));
+              return bt && (bt[Yr] = xi), xi.apply(null, jr);
+            }
+            return { global: Ei, link: Gr, block: mi, proc: en, scope: Ui, cond: qi, compile: Wi };
+          }
+          var Ca = "xyzw".split(""), Ra = 5121, La = 1, Na = 2, Yn = 0, Dn = 1, Ka = 2, bo = 3, Zo = 4, Ss = 5, as = 6, ws = "dither", Ho = "blend.enable", ml = "blend.color", Ws = "blend.equation", Ls = "blend.func", va = "depth.enable", no = "depth.func", ys = "depth.range", rs = "depth.mask", Ql = "colorMask", Cu = "cull.enable", Yu = "cull.face", Nc = "frontFace", pu = "lineWidth", Uc = "polygonOffset.enable", xu = "polygonOffset.offset", Ac = "sample.alpha", Ua = "sample.enable", oo = "sample.coverage", Vc = "stencil.enable", hc = "stencil.mask", Ku = "stencil.func", ue = "stencil.opFront", w = "stencil.opBack", B = "scissor.enable", Q = "scissor.box", ee = "viewport", le = "profile", Oe = "framebuffer", Ze = "vert", st = "frag", Tt = "elements", Yt = "primitive", Kt = "count", xr = "offset", Ir = "instances", ve = "vao", be = "Width", Re = "Height", qe = Oe + be, et = Oe + Re, Xe = ee + be, it = ee + Re, Ft = "drawingBuffer", Ht = Ft + be, tr = Ft + Re, dr = [Ls, Ws, Ku, ue, w, oo, ee, Q, xu], Sr = 34962, Or = 34963, Wr = 2884, ni = 3042, Pi = 3024, cn = 2960, ln = 2929, Cn = 3089, Kn = 32823, Aa = 32926, fa = 32928, $a = 5126, Co = 35664, Qa = 35665, mo = 35666, Bo = 5124, Ps = 35667, Ts = 35668, wo = 35669, To = 35670, hl = 35671, Ul = 35672, Lu = 35673, au = 35674, Js = 35675, eu = 35676, dc = 35678, Tl = 35680, Al = 4, X = 1028, se = 1029, Te = 2304, Ne = 2305, He = 32775, Ye = 32776, kt = 519, nt = 7680, jt = 0, gr = 1, yr = 32774, Hr = 513, qr = 36160, _i = 36064, bi = { 0: 0, 1: 1, zero: 0, one: 1, "src color": 768, "one minus src color": 769, "src alpha": 770, "one minus src alpha": 771, "dst color": 774, "one minus dst color": 775, "dst alpha": 772, "one minus dst alpha": 773, "constant color": 32769, "one minus constant color": 32770, "constant alpha": 32771, "one minus constant alpha": 32772, "src alpha saturate": 776 }, Zr = { never: 512, less: 513, "<": 513, equal: 514, "=": 514, "==": 514, "===": 514, lequal: 515, "<=": 515, greater: 516, ">": 516, notequal: 517, "!=": 517, "!==": 517, gequal: 518, ">=": 518, always: 519 }, ai = { 0: 0, zero: 0, keep: 7680, replace: 7681, increment: 7682, decrement: 7683, "increment wrap": 34055, "decrement wrap": 34056, invert: 5386 }, gi = { cw: Te, ccw: Ne };
+          function Ii(Me) {
+            return Array.isArray(Me) || Br(Me) || Vr(Me);
+          }
+          function Si(Me) {
+            return Me.sort(function(bt, zt) {
+              return bt === ee ? -1 : zt === ee ? 1 : bt < zt ? -1 : 1;
+            });
+          }
+          function ei(Me, bt, zt, Rr) {
+            this.thisDep = Me, this.contextDep = bt, this.propDep = zt, this.append = Rr;
+          }
+          function Ln(Me) {
+            return Me && !(Me.thisDep || Me.contextDep || Me.propDep);
+          }
+          function En(Me) {
+            return new ei(false, false, false, Me);
+          }
+          function Un(Me, bt) {
+            var zt = Me.type;
+            if (zt === Yn) {
+              var Rr = Me.data.length;
+              return new ei(true, Rr >= 1, Rr >= 2, bt);
+            } else if (zt === Zo) {
+              var jr = Me.data;
+              return new ei(jr.thisDep, jr.contextDep, jr.propDep, bt);
+            } else {
+              if (zt === Ss) return new ei(false, false, false, bt);
+              if (zt === as) {
+                for (var Nr = false, Gr = false, mi = false, Ui = 0; Ui < Me.data.length; ++Ui) {
+                  var qi = Me.data[Ui];
+                  if (qi.type === Dn) mi = true;
+                  else if (qi.type === Ka) Gr = true;
+                  else if (qi.type === bo) Nr = true;
+                  else if (qi.type === Yn) {
+                    Nr = true;
+                    var Ei = qi.data;
+                    Ei >= 1 && (Gr = true), Ei >= 2 && (mi = true);
+                  } else qi.type === Zo && (Nr = Nr || qi.data.thisDep, Gr = Gr || qi.data.contextDep, mi = mi || qi.data.propDep);
+                }
+                return new ei(Nr, Gr, mi, bt);
+              } else return new ei(zt === bo, zt === Ka, zt === Dn, bt);
+            }
+          }
+          var ia = new ei(false, false, false, function() {
+          });
+          function Ea(Me, bt, zt, Rr, jr, Nr, Gr, mi, Ui, qi, Ei, Hn, en, Wi, si, Mr) {
+            var Yr = qi.Record, xi = { add: 32774, subtract: 32778, "reverse subtract": 32779 };
+            zt.ext_blend_minmax && (xi.min = He, xi.max = Ye);
+            var Ri = zt.angle_instanced_arrays, ci = zt.webgl_draw_buffers, an = zt.oes_vertex_array_object, Zi = { dirty: true, profile: Mr.profile }, Bn = {}, hi = [], li = {}, mn = {};
+            function Ji(Ve) {
+              return Ve.replace(".", "_");
+            }
+            function Vi(Ve, Qe, at) {
+              var Ct = Ji(Ve);
+              hi.push(Ve), Bn[Ct] = Zi[Ct] = !!at, li[Ct] = Qe;
+            }
+            function Ni(Ve, Qe, at) {
+              var Ct = Ji(Ve);
+              hi.push(Ve), Array.isArray(at) ? (Zi[Ct] = at.slice(), Bn[Ct] = at.slice()) : Zi[Ct] = Bn[Ct] = at, mn[Ct] = Qe;
+            }
+            function pn(Ve) {
+              return !!isNaN(Ve);
+            }
+            Vi(ws, Pi), Vi(Ho, ni), Ni(ml, "blendColor", [0, 0, 0, 0]), Ni(Ws, "blendEquationSeparate", [yr, yr]), Ni(Ls, "blendFuncSeparate", [gr, jt, gr, jt]), Vi(va, ln, true), Ni(no, "depthFunc", Hr), Ni(ys, "depthRange", [0, 1]), Ni(rs, "depthMask", true), Ni(Ql, Ql, [true, true, true, true]), Vi(Cu, Wr), Ni(Yu, "cullFace", se), Ni(Nc, Nc, Ne), Ni(pu, pu, 1), Vi(Uc, Kn), Ni(xu, "polygonOffset", [0, 0]), Vi(Ac, Aa), Vi(Ua, fa), Ni(oo, "sampleCoverage", [1, false]), Vi(Vc, cn), Ni(hc, "stencilMask", -1), Ni(Ku, "stencilFunc", [kt, 0, -1]), Ni(ue, "stencilOpSeparate", [X, nt, nt, nt]), Ni(w, "stencilOpSeparate", [se, nt, nt, nt]), Vi(B, Cn), Ni(Q, "scissor", [0, 0, Me.drawingBufferWidth, Me.drawingBufferHeight]), Ni(ee, ee, [0, 0, Me.drawingBufferWidth, Me.drawingBufferHeight]);
+            var Vn = { gl: Me, context: en, strings: bt, next: Bn, current: Zi, draw: Hn, elements: Nr, buffer: jr, shader: Ei, attributes: qi.state, vao: qi, uniforms: Ui, framebuffer: mi, extensions: zt, timer: Wi, isBufferArgs: Ii }, na = { primTypes: Sn, compareFuncs: Zr, blendFuncs: bi, blendEquations: xi, stencilOps: ai, glTypes: ji, orientationType: gi };
+            ci && (na.backBuffer = [se], na.drawBuffer = M(Rr.maxDrawbuffers, function(Ve) {
+              return Ve === 0 ? [0] : M(Ve, function(Qe) {
+                return _i + Qe;
+              });
+            }));
+            var Ki = 0;
+            function kn() {
+              var Ve = Qn({ cache: si }), Qe = Ve.link, at = Ve.global;
+              Ve.id = Ki++, Ve.batchId = "0";
+              var Ct = Qe(Vn), Ot = Ve.shared = { props: "a0" };
+              Object.keys(Vn).forEach(function(Pt) {
+                Ot[Pt] = at.def(Ct, ".", Pt);
+              });
+              var Rt = Ve.next = {}, Bt = Ve.current = {};
+              Object.keys(mn).forEach(function(Pt) {
+                Array.isArray(Zi[Pt]) && (Rt[Pt] = at.def(Ot.next, ".", Pt), Bt[Pt] = at.def(Ot.current, ".", Pt));
+              });
+              var Dt = Ve.constants = {};
+              Object.keys(na).forEach(function(Pt) {
+                Dt[Pt] = at.def(JSON.stringify(na[Pt]));
+              }), Ve.invoke = function(Pt, ht) {
+                switch (ht.type) {
+                  case Yn:
+                    var ur = ["this", Ot.context, Ot.props, Ve.batchId];
+                    return Pt.def(Qe(ht.data), ".call(", ur.slice(0, Math.max(ht.data.length + 1, 4)), ")");
+                  case Dn:
+                    return Pt.def(Ot.props, ht.data);
+                  case Ka:
+                    return Pt.def(Ot.context, ht.data);
+                  case bo:
+                    return Pt.def("this", ht.data);
+                  case Zo:
+                    return ht.data.append(Ve, Pt), ht.data.ref;
+                  case Ss:
+                    return ht.data.toString();
+                  case as:
+                    return ht.data.map(function(br) {
+                      return Ve.invoke(Pt, br);
+                    });
+                }
+              }, Ve.attribCache = {};
+              var yt = {};
+              return Ve.scopeAttrib = function(Pt) {
+                var ht = bt.id(Pt);
+                if (ht in yt) return yt[ht];
+                var ur = qi.scope[ht];
+                ur || (ur = qi.scope[ht] = new Yr());
+                var br = yt[ht] = Qe(ur);
+                return br;
+              }, Ve;
+            }
+            function ta(Ve) {
+              var Qe = Ve.static, at = Ve.dynamic, Ct;
+              if (le in Qe) {
+                var Ot = !!Qe[le];
+                Ct = En(function(Bt, Dt) {
+                  return Ot;
+                }), Ct.enable = Ot;
+              } else if (le in at) {
+                var Rt = at[le];
+                Ct = Un(Rt, function(Bt, Dt) {
+                  return Bt.invoke(Dt, Rt);
+                });
+              }
+              return Ct;
+            }
+            function oa(Ve, Qe) {
+              var at = Ve.static, Ct = Ve.dynamic;
+              if (Oe in at) {
+                var Ot = at[Oe];
+                return Ot ? (Ot = mi.getFramebuffer(Ot), En(function(Bt, Dt) {
+                  var yt = Bt.link(Ot), Pt = Bt.shared;
+                  Dt.set(Pt.framebuffer, ".next", yt);
+                  var ht = Pt.context;
+                  return Dt.set(ht, "." + qe, yt + ".width"), Dt.set(ht, "." + et, yt + ".height"), yt;
+                })) : En(function(Bt, Dt) {
+                  var yt = Bt.shared;
+                  Dt.set(yt.framebuffer, ".next", "null");
+                  var Pt = yt.context;
+                  return Dt.set(Pt, "." + qe, Pt + "." + Ht), Dt.set(Pt, "." + et, Pt + "." + tr), "null";
+                });
+              } else if (Oe in Ct) {
+                var Rt = Ct[Oe];
+                return Un(Rt, function(Bt, Dt) {
+                  var yt = Bt.invoke(Dt, Rt), Pt = Bt.shared, ht = Pt.framebuffer, ur = Dt.def(ht, ".getFramebuffer(", yt, ")");
+                  Dt.set(ht, ".next", ur);
+                  var br = Pt.context;
+                  return Dt.set(br, "." + qe, ur + "?" + ur + ".width:" + br + "." + Ht), Dt.set(br, "." + et, ur + "?" + ur + ".height:" + br + "." + tr), ur;
+                });
+              } else return null;
+            }
+            function ba(Ve, Qe, at) {
+              var Ct = Ve.static, Ot = Ve.dynamic;
+              function Rt(yt) {
+                if (yt in Ct) {
+                  var Pt = Ct[yt], ht = true, ur = Pt.x | 0, br = Pt.y | 0, Ur, Di;
+                  return "width" in Pt ? Ur = Pt.width | 0 : ht = false, "height" in Pt ? Di = Pt.height | 0 : ht = false, new ei(!ht && Qe && Qe.thisDep, !ht && Qe && Qe.contextDep, !ht && Qe && Qe.propDep, function(gn, rn) {
+                    var Ci = gn.shared.context, Bi = Ur;
+                    "width" in Pt || (Bi = rn.def(Ci, ".", qe, "-", ur));
+                    var Gi = Di;
+                    return "height" in Pt || (Gi = rn.def(Ci, ".", et, "-", br)), [ur, br, Bi, Gi];
+                  });
+                } else if (yt in Ot) {
+                  var fi = Ot[yt], Ti = Un(fi, function(gn, rn) {
+                    var Ci = gn.invoke(rn, fi), Bi = gn.shared.context, Gi = rn.def(Ci, ".x|0"), sn = rn.def(Ci, ".y|0"), zn = rn.def('"width" in ', Ci, "?", Ci, ".width|0:", "(", Bi, ".", qe, "-", Gi, ")"), Ja = rn.def('"height" in ', Ci, "?", Ci, ".height|0:", "(", Bi, ".", et, "-", sn, ")");
+                    return [Gi, sn, zn, Ja];
+                  });
+                  return Qe && (Ti.thisDep = Ti.thisDep || Qe.thisDep, Ti.contextDep = Ti.contextDep || Qe.contextDep, Ti.propDep = Ti.propDep || Qe.propDep), Ti;
+                } else return Qe ? new ei(Qe.thisDep, Qe.contextDep, Qe.propDep, function(gn, rn) {
+                  var Ci = gn.shared.context;
+                  return [0, 0, rn.def(Ci, ".", qe), rn.def(Ci, ".", et)];
+                }) : null;
+              }
+              var Bt = Rt(ee);
+              if (Bt) {
+                var Dt = Bt;
+                Bt = new ei(Bt.thisDep, Bt.contextDep, Bt.propDep, function(yt, Pt) {
+                  var ht = Dt.append(yt, Pt), ur = yt.shared.context;
+                  return Pt.set(ur, "." + Xe, ht[2]), Pt.set(ur, "." + it, ht[3]), ht;
+                });
+              }
+              return { viewport: Bt, scissor_box: Rt(Q) };
+            }
+            function is(Ve, Qe) {
+              var at = Ve.static, Ct = typeof at[st] == "string" && typeof at[Ze] == "string";
+              if (Ct) {
+                if (Object.keys(Qe.dynamic).length > 0) return null;
+                var Ot = Qe.static, Rt = Object.keys(Ot);
+                if (Rt.length > 0 && typeof Ot[Rt[0]] == "number") {
+                  for (var Bt = [], Dt = 0; Dt < Rt.length; ++Dt) Bt.push([Ot[Rt[Dt]] | 0, Rt[Dt]]);
+                  return Bt;
+                }
+              }
+              return null;
+            }
+            function Zs(Ve, Qe, at) {
+              var Ct = Ve.static, Ot = Ve.dynamic;
+              function Rt(ht) {
+                if (ht in Ct) {
+                  var ur = bt.id(Ct[ht]), br = En(function() {
+                    return ur;
+                  });
+                  return br.id = ur, br;
+                } else if (ht in Ot) {
+                  var Ur = Ot[ht];
+                  return Un(Ur, function(Di, fi) {
+                    var Ti = Di.invoke(fi, Ur), gn = fi.def(Di.shared.strings, ".id(", Ti, ")");
+                    return gn;
+                  });
+                }
+                return null;
+              }
+              var Bt = Rt(st), Dt = Rt(Ze), yt = null, Pt;
+              return Ln(Bt) && Ln(Dt) ? (yt = Ei.program(Dt.id, Bt.id, null, at), Pt = En(function(ht, ur) {
+                return ht.link(yt);
+              })) : Pt = new ei(Bt && Bt.thisDep || Dt && Dt.thisDep, Bt && Bt.contextDep || Dt && Dt.contextDep, Bt && Bt.propDep || Dt && Dt.propDep, function(ht, ur) {
+                var br = ht.shared.shader, Ur;
+                Bt ? Ur = Bt.append(ht, ur) : Ur = ur.def(br, ".", st);
+                var Di;
+                Dt ? Di = Dt.append(ht, ur) : Di = ur.def(br, ".", Ze);
+                var fi = br + ".program(" + Di + "," + Ur;
+                return ur.def(fi + ")");
+              }), { frag: Bt, vert: Dt, progVar: Pt, program: yt };
+            }
+            function Va(Ve, Qe) {
+              var at = Ve.static, Ct = Ve.dynamic, Ot = {}, Rt = false;
+              function Bt() {
+                if (ve in at) {
+                  var rn = at[ve];
+                  return rn !== null && qi.getVAO(rn) === null && (rn = qi.createVAO(rn)), Rt = true, Ot.vao = rn, En(function(Bi) {
+                    var Gi = qi.getVAO(rn);
+                    return Gi ? Bi.link(Gi) : "null";
+                  });
+                } else if (ve in Ct) {
+                  Rt = true;
+                  var Ci = Ct[ve];
+                  return Un(Ci, function(Bi, Gi) {
+                    var sn = Bi.invoke(Gi, Ci);
+                    return Gi.def(Bi.shared.vao + ".getVAO(" + sn + ")");
+                  });
+                }
+                return null;
+              }
+              var Dt = Bt(), yt = false;
+              function Pt() {
+                if (Tt in at) {
+                  var rn = at[Tt];
+                  if (Ot.elements = rn, Ii(rn)) {
+                    var Ci = Ot.elements = Nr.create(rn, true);
+                    rn = Nr.getElements(Ci), yt = true;
+                  } else rn && (rn = Nr.getElements(rn), yt = true);
+                  var Bi = En(function(sn, zn) {
+                    if (rn) {
+                      var Ja = sn.link(rn);
+                      return sn.ELEMENTS = Ja, Ja;
+                    }
+                    return sn.ELEMENTS = null, null;
+                  });
+                  return Bi.value = rn, Bi;
+                } else if (Tt in Ct) {
+                  yt = true;
+                  var Gi = Ct[Tt];
+                  return Un(Gi, function(sn, zn) {
+                    var Ja = sn.shared, co = Ja.isBufferArgs, ts = Ja.elements, so = sn.invoke(zn, Gi), Yo = zn.def("null"), ms = zn.def(co, "(", so, ")"), ou = sn.cond(ms).then(Yo, "=", ts, ".createStream(", so, ");").else(Yo, "=", ts, ".getElements(", so, ");");
+                    return zn.entry(ou), zn.exit(sn.cond(ms).then(ts, ".destroyStream(", Yo, ");")), sn.ELEMENTS = Yo, Yo;
+                  });
+                } else if (Rt) return new ei(Dt.thisDep, Dt.contextDep, Dt.propDep, function(sn, zn) {
+                  return zn.def(sn.shared.vao + ".currentVAO?" + sn.shared.elements + ".getElements(" + sn.shared.vao + ".currentVAO.elements):null");
+                });
+                return null;
+              }
+              var ht = Pt();
+              function ur() {
+                if (Yt in at) {
+                  var rn = at[Yt];
+                  return Ot.primitive = rn, En(function(Bi, Gi) {
+                    return Sn[rn];
+                  });
+                } else if (Yt in Ct) {
+                  var Ci = Ct[Yt];
+                  return Un(Ci, function(Bi, Gi) {
+                    var sn = Bi.constants.primTypes, zn = Bi.invoke(Gi, Ci);
+                    return Gi.def(sn, "[", zn, "]");
+                  });
+                } else {
+                  if (yt) return Ln(ht) ? ht.value ? En(function(Bi, Gi) {
+                    return Gi.def(Bi.ELEMENTS, ".primType");
+                  }) : En(function() {
+                    return Al;
+                  }) : new ei(ht.thisDep, ht.contextDep, ht.propDep, function(Bi, Gi) {
+                    var sn = Bi.ELEMENTS;
+                    return Gi.def(sn, "?", sn, ".primType:", Al);
+                  });
+                  if (Rt) return new ei(Dt.thisDep, Dt.contextDep, Dt.propDep, function(Bi, Gi) {
+                    return Gi.def(Bi.shared.vao + ".currentVAO?" + Bi.shared.vao + ".currentVAO.primitive:" + Al);
+                  });
+                }
+                return null;
+              }
+              function br(rn, Ci) {
+                if (rn in at) {
+                  var Bi = at[rn] | 0;
+                  return Ci ? Ot.offset = Bi : Ot.instances = Bi, En(function(sn, zn) {
+                    return Ci && (sn.OFFSET = Bi), Bi;
+                  });
+                } else if (rn in Ct) {
+                  var Gi = Ct[rn];
+                  return Un(Gi, function(sn, zn) {
+                    var Ja = sn.invoke(zn, Gi);
+                    return Ci && (sn.OFFSET = Ja), Ja;
+                  });
+                } else if (Ci) {
+                  if (yt) return En(function(sn, zn) {
+                    return sn.OFFSET = 0, 0;
+                  });
+                  if (Rt) return new ei(Dt.thisDep, Dt.contextDep, Dt.propDep, function(sn, zn) {
+                    return zn.def(sn.shared.vao + ".currentVAO?" + sn.shared.vao + ".currentVAO.offset:0");
+                  });
+                } else if (Rt) return new ei(Dt.thisDep, Dt.contextDep, Dt.propDep, function(sn, zn) {
+                  return zn.def(sn.shared.vao + ".currentVAO?" + sn.shared.vao + ".currentVAO.instances:-1");
+                });
+                return null;
+              }
+              var Ur = br(xr, true);
+              function Di() {
+                if (Kt in at) {
+                  var rn = at[Kt] | 0;
+                  return Ot.count = rn, En(function() {
+                    return rn;
+                  });
+                } else if (Kt in Ct) {
+                  var Ci = Ct[Kt];
+                  return Un(Ci, function(zn, Ja) {
+                    var co = zn.invoke(Ja, Ci);
+                    return co;
+                  });
+                } else if (yt) if (Ln(ht)) {
+                  if (ht) return Ur ? new ei(Ur.thisDep, Ur.contextDep, Ur.propDep, function(zn, Ja) {
+                    var co = Ja.def(zn.ELEMENTS, ".vertCount-", zn.OFFSET);
+                    return co;
+                  }) : En(function(zn, Ja) {
+                    return Ja.def(zn.ELEMENTS, ".vertCount");
+                  });
+                  var Bi = En(function() {
+                    return -1;
+                  });
+                  return Bi;
+                } else {
+                  var Gi = new ei(ht.thisDep || Ur.thisDep, ht.contextDep || Ur.contextDep, ht.propDep || Ur.propDep, function(zn, Ja) {
+                    var co = zn.ELEMENTS;
+                    return zn.OFFSET ? Ja.def(co, "?", co, ".vertCount-", zn.OFFSET, ":-1") : Ja.def(co, "?", co, ".vertCount:-1");
+                  });
+                  return Gi;
+                }
+                else if (Rt) {
+                  var sn = new ei(Dt.thisDep, Dt.contextDep, Dt.propDep, function(zn, Ja) {
+                    return Ja.def(zn.shared.vao, ".currentVAO?", zn.shared.vao, ".currentVAO.count:-1");
+                  });
+                  return sn;
+                }
+                return null;
+              }
+              var fi = ur(), Ti = Di(), gn = br(Ir, false);
+              return { elements: ht, primitive: fi, count: Ti, instances: gn, offset: Ur, vao: Dt, vaoActive: Rt, elementsActive: yt, static: Ot };
+            }
+            function Ml(Ve, Qe) {
+              var at = Ve.static, Ct = Ve.dynamic, Ot = {};
+              return hi.forEach(function(Rt) {
+                var Bt = Ji(Rt);
+                function Dt(yt, Pt) {
+                  if (Rt in at) {
+                    var ht = yt(at[Rt]);
+                    Ot[Bt] = En(function() {
+                      return ht;
+                    });
+                  } else if (Rt in Ct) {
+                    var ur = Ct[Rt];
+                    Ot[Bt] = Un(ur, function(br, Ur) {
+                      return Pt(br, Ur, br.invoke(Ur, ur));
+                    });
+                  }
+                }
+                switch (Rt) {
+                  case Cu:
+                  case Ho:
+                  case ws:
+                  case Vc:
+                  case va:
+                  case B:
+                  case Uc:
+                  case Ac:
+                  case Ua:
+                  case rs:
+                    return Dt(function(yt) {
+                      return yt;
+                    }, function(yt, Pt, ht) {
+                      return ht;
+                    });
+                  case no:
+                    return Dt(function(yt) {
+                      return Zr[yt];
+                    }, function(yt, Pt, ht) {
+                      var ur = yt.constants.compareFuncs;
+                      return Pt.def(ur, "[", ht, "]");
+                    });
+                  case ys:
+                    return Dt(function(yt) {
+                      return yt;
+                    }, function(yt, Pt, ht) {
+                      var ur = Pt.def("+", ht, "[0]"), br = Pt.def("+", ht, "[1]");
+                      return [ur, br];
+                    });
+                  case Ls:
+                    return Dt(function(yt) {
+                      var Pt = "srcRGB" in yt ? yt.srcRGB : yt.src, ht = "srcAlpha" in yt ? yt.srcAlpha : yt.src, ur = "dstRGB" in yt ? yt.dstRGB : yt.dst, br = "dstAlpha" in yt ? yt.dstAlpha : yt.dst;
+                      return [bi[Pt], bi[ur], bi[ht], bi[br]];
+                    }, function(yt, Pt, ht) {
+                      var ur = yt.constants.blendFuncs;
+                      function br(Ci, Bi) {
+                        var Gi = Pt.def('"', Ci, Bi, '" in ', ht, "?", ht, ".", Ci, Bi, ":", ht, ".", Ci);
+                        return Gi;
+                      }
+                      var Ur = br("src", "RGB"), Di = br("dst", "RGB"), fi = Pt.def(ur, "[", Ur, "]"), Ti = Pt.def(ur, "[", br("src", "Alpha"), "]"), gn = Pt.def(ur, "[", Di, "]"), rn = Pt.def(ur, "[", br("dst", "Alpha"), "]");
+                      return [fi, gn, Ti, rn];
+                    });
+                  case Ws:
+                    return Dt(function(yt) {
+                      if (typeof yt == "string") return [xi[yt], xi[yt]];
+                      if (typeof yt == "object") return [xi[yt.rgb], xi[yt.alpha]];
+                    }, function(yt, Pt, ht) {
+                      var ur = yt.constants.blendEquations, br = Pt.def(), Ur = Pt.def(), Di = yt.cond("typeof ", ht, '==="string"');
+                      return Di.then(br, "=", Ur, "=", ur, "[", ht, "];"), Di.else(br, "=", ur, "[", ht, ".rgb];", Ur, "=", ur, "[", ht, ".alpha];"), Pt(Di), [br, Ur];
+                    });
+                  case ml:
+                    return Dt(function(yt) {
+                      return M(4, function(Pt) {
+                        return +yt[Pt];
+                      });
+                    }, function(yt, Pt, ht) {
+                      return M(4, function(ur) {
+                        return Pt.def("+", ht, "[", ur, "]");
+                      });
+                    });
+                  case hc:
+                    return Dt(function(yt) {
+                      return yt | 0;
+                    }, function(yt, Pt, ht) {
+                      return Pt.def(ht, "|0");
+                    });
+                  case Ku:
+                    return Dt(function(yt) {
+                      var Pt = yt.cmp || "keep", ht = yt.ref || 0, ur = "mask" in yt ? yt.mask : -1;
+                      return [Zr[Pt], ht, ur];
+                    }, function(yt, Pt, ht) {
+                      var ur = yt.constants.compareFuncs, br = Pt.def('"cmp" in ', ht, "?", ur, "[", ht, ".cmp]", ":", nt), Ur = Pt.def(ht, ".ref|0"), Di = Pt.def('"mask" in ', ht, "?", ht, ".mask|0:-1");
+                      return [br, Ur, Di];
+                    });
+                  case ue:
+                  case w:
+                    return Dt(function(yt) {
+                      var Pt = yt.fail || "keep", ht = yt.zfail || "keep", ur = yt.zpass || "keep";
+                      return [Rt === w ? se : X, ai[Pt], ai[ht], ai[ur]];
+                    }, function(yt, Pt, ht) {
+                      var ur = yt.constants.stencilOps;
+                      function br(Ur) {
+                        return Pt.def('"', Ur, '" in ', ht, "?", ur, "[", ht, ".", Ur, "]:", nt);
+                      }
+                      return [Rt === w ? se : X, br("fail"), br("zfail"), br("zpass")];
+                    });
+                  case xu:
+                    return Dt(function(yt) {
+                      var Pt = yt.factor | 0, ht = yt.units | 0;
+                      return [Pt, ht];
+                    }, function(yt, Pt, ht) {
+                      var ur = Pt.def(ht, ".factor|0"), br = Pt.def(ht, ".units|0");
+                      return [ur, br];
+                    });
+                  case Yu:
+                    return Dt(function(yt) {
+                      var Pt = 0;
+                      return yt === "front" ? Pt = X : yt === "back" && (Pt = se), Pt;
+                    }, function(yt, Pt, ht) {
+                      return Pt.def(ht, '==="front"?', X, ":", se);
+                    });
+                  case pu:
+                    return Dt(function(yt) {
+                      return yt;
+                    }, function(yt, Pt, ht) {
+                      return ht;
+                    });
+                  case Nc:
+                    return Dt(function(yt) {
+                      return gi[yt];
+                    }, function(yt, Pt, ht) {
+                      return Pt.def(ht + '==="cw"?' + Te + ":" + Ne);
+                    });
+                  case Ql:
+                    return Dt(function(yt) {
+                      return yt.map(function(Pt) {
+                        return !!Pt;
+                      });
+                    }, function(yt, Pt, ht) {
+                      return M(4, function(ur) {
+                        return "!!" + ht + "[" + ur + "]";
+                      });
+                    });
+                  case oo:
+                    return Dt(function(yt) {
+                      var Pt = "value" in yt ? yt.value : 1, ht = !!yt.invert;
+                      return [Pt, ht];
+                    }, function(yt, Pt, ht) {
+                      var ur = Pt.def('"value" in ', ht, "?+", ht, ".value:1"), br = Pt.def("!!", ht, ".invert");
+                      return [ur, br];
+                    });
+                }
+              }), Ot;
+            }
+            function zo(Ve, Qe) {
+              var at = Ve.static, Ct = Ve.dynamic, Ot = {};
+              return Object.keys(at).forEach(function(Rt) {
+                var Bt = at[Rt], Dt;
+                if (typeof Bt == "number" || typeof Bt == "boolean") Dt = En(function() {
+                  return Bt;
+                });
+                else if (typeof Bt == "function") {
+                  var yt = Bt._reglType;
+                  yt === "texture2d" || yt === "textureCube" ? Dt = En(function(Pt) {
+                    return Pt.link(Bt);
+                  }) : (yt === "framebuffer" || yt === "framebufferCube") && (Dt = En(function(Pt) {
+                    return Pt.link(Bt.color[0]);
+                  }));
+                } else Mn(Bt) && (Dt = En(function(Pt) {
+                  var ht = Pt.global.def("[", M(Bt.length, function(ur) {
+                    return Bt[ur];
+                  }), "]");
+                  return ht;
+                }));
+                Dt.value = Bt, Ot[Rt] = Dt;
+              }), Object.keys(Ct).forEach(function(Rt) {
+                var Bt = Ct[Rt];
+                Ot[Rt] = Un(Bt, function(Dt, yt) {
+                  return Dt.invoke(yt, Bt);
+                });
+              }), Ot;
+            }
+            function Qs(Ve, Qe) {
+              var at = Ve.static, Ct = Ve.dynamic, Ot = {};
+              return Object.keys(at).forEach(function(Rt) {
+                var Bt = at[Rt], Dt = bt.id(Rt), yt = new Yr();
+                if (Ii(Bt)) yt.state = La, yt.buffer = jr.getBuffer(jr.create(Bt, Sr, false, true)), yt.type = 0;
+                else {
+                  var Pt = jr.getBuffer(Bt);
+                  if (Pt) yt.state = La, yt.buffer = Pt, yt.type = 0;
+                  else if ("constant" in Bt) {
+                    var ht = Bt.constant;
+                    yt.buffer = "null", yt.state = Na, typeof ht == "number" ? yt.x = ht : Ca.forEach(function(gn, rn) {
+                      rn < ht.length && (yt[gn] = ht[rn]);
+                    });
+                  } else {
+                    Ii(Bt.buffer) ? Pt = jr.getBuffer(jr.create(Bt.buffer, Sr, false, true)) : Pt = jr.getBuffer(Bt.buffer);
+                    var ur = Bt.offset | 0, br = Bt.stride | 0, Ur = Bt.size | 0, Di = !!Bt.normalized, fi = 0;
+                    "type" in Bt && (fi = ji[Bt.type]);
+                    var Ti = Bt.divisor | 0;
+                    yt.buffer = Pt, yt.state = La, yt.size = Ur, yt.normalized = Di, yt.type = fi || Pt.dtype, yt.offset = ur, yt.stride = br, yt.divisor = Ti;
+                  }
+                }
+                Ot[Rt] = En(function(gn, rn) {
+                  var Ci = gn.attribCache;
+                  if (Dt in Ci) return Ci[Dt];
+                  var Bi = { isStream: false };
+                  return Object.keys(yt).forEach(function(Gi) {
+                    Bi[Gi] = yt[Gi];
+                  }), yt.buffer && (Bi.buffer = gn.link(yt.buffer), Bi.type = Bi.type || Bi.buffer + ".dtype"), Ci[Dt] = Bi, Bi;
+                });
+              }), Object.keys(Ct).forEach(function(Rt) {
+                var Bt = Ct[Rt];
+                function Dt(yt, Pt) {
+                  var ht = yt.invoke(Pt, Bt), ur = yt.shared, br = yt.constants, Ur = ur.isBufferArgs, Di = ur.buffer, fi = { isStream: Pt.def(false) }, Ti = new Yr();
+                  Ti.state = La, Object.keys(Ti).forEach(function(Bi) {
+                    fi[Bi] = Pt.def("" + Ti[Bi]);
+                  });
+                  var gn = fi.buffer, rn = fi.type;
+                  Pt("if(", Ur, "(", ht, ")){", fi.isStream, "=true;", gn, "=", Di, ".createStream(", Sr, ",", ht, ");", rn, "=", gn, ".dtype;", "}else{", gn, "=", Di, ".getBuffer(", ht, ");", "if(", gn, "){", rn, "=", gn, ".dtype;", '}else if("constant" in ', ht, "){", fi.state, "=", Na, ";", "if(typeof " + ht + '.constant === "number"){', fi[Ca[0]], "=", ht, ".constant;", Ca.slice(1).map(function(Bi) {
+                    return fi[Bi];
+                  }).join("="), "=0;", "}else{", Ca.map(function(Bi, Gi) {
+                    return fi[Bi] + "=" + ht + ".constant.length>" + Gi + "?" + ht + ".constant[" + Gi + "]:0;";
+                  }).join(""), "}}else{", "if(", Ur, "(", ht, ".buffer)){", gn, "=", Di, ".createStream(", Sr, ",", ht, ".buffer);", "}else{", gn, "=", Di, ".getBuffer(", ht, ".buffer);", "}", rn, '="type" in ', ht, "?", br.glTypes, "[", ht, ".type]:", gn, ".dtype;", fi.normalized, "=!!", ht, ".normalized;");
+                  function Ci(Bi) {
+                    Pt(fi[Bi], "=", ht, ".", Bi, "|0;");
+                  }
+                  return Ci("size"), Ci("offset"), Ci("stride"), Ci("divisor"), Pt("}}"), Pt.exit("if(", fi.isStream, "){", Di, ".destroyStream(", gn, ");", "}"), fi;
+                }
+                Ot[Rt] = Un(Bt, Dt);
+              }), Ot;
+            }
+            function al(Ve) {
+              var Qe = Ve.static, at = Ve.dynamic, Ct = {};
+              return Object.keys(Qe).forEach(function(Ot) {
+                var Rt = Qe[Ot];
+                Ct[Ot] = En(function(Bt, Dt) {
+                  return typeof Rt == "number" || typeof Rt == "boolean" ? "" + Rt : Bt.link(Rt);
+                });
+              }), Object.keys(at).forEach(function(Ot) {
+                var Rt = at[Ot];
+                Ct[Ot] = Un(Rt, function(Bt, Dt) {
+                  return Bt.invoke(Dt, Rt);
+                });
+              }), Ct;
+            }
+            function Vl(Ve, Qe, at, Ct, Ot) {
+              Ve.static;
+              Ve.dynamic;
+              var Dt = is(Ve, Qe), yt = oa(Ve), Pt = ba(Ve, yt), ht = Va(Ve), ur = Ml(Ve), br = Zs(Ve, Ot, Dt);
+              function Ur(Ci) {
+                var Bi = Pt[Ci];
+                Bi && (ur[Ci] = Bi);
+              }
+              Ur(ee), Ur(Ji(Q));
+              var Di = Object.keys(ur).length > 0, fi = { framebuffer: yt, draw: ht, shader: br, state: ur, dirty: Di, scopeVAO: null, drawVAO: null, useVAO: false, attributes: {} };
+              if (fi.profile = ta(Ve), fi.uniforms = zo(at), fi.drawVAO = fi.scopeVAO = ht.vao, !fi.drawVAO && br.program && !Dt && zt.angle_instanced_arrays && ht.static.elements) {
+                var Ti = true, gn = br.program.attributes.map(function(Ci) {
+                  var Bi = Qe.static[Ci];
+                  return Ti = Ti && !!Bi, Bi;
+                });
+                if (Ti && gn.length > 0) {
+                  var rn = qi.getVAO(qi.createVAO({ attributes: gn, elements: ht.static.elements }));
+                  fi.drawVAO = new ei(null, null, null, function(Ci, Bi) {
+                    return Ci.link(rn);
+                  }), fi.useVAO = true;
+                }
+              }
+              return Dt ? fi.useVAO = true : fi.attributes = Qs(Qe), fi.context = al(Ct), fi;
+            }
+            function ss(Ve, Qe, at) {
+              var Ct = Ve.shared, Ot = Ct.context, Rt = Ve.scope();
+              Object.keys(at).forEach(function(Bt) {
+                Qe.save(Ot, "." + Bt);
+                var Dt = at[Bt], yt = Dt.append(Ve, Qe);
+                Array.isArray(yt) ? Rt(Ot, ".", Bt, "=[", yt.join(), "];") : Rt(Ot, ".", Bt, "=", yt, ";");
+              }), Qe(Rt);
+            }
+            function Vs(Ve, Qe, at, Ct) {
+              var Ot = Ve.shared, Rt = Ot.gl, Bt = Ot.framebuffer, Dt;
+              ci && (Dt = Qe.def(Ot.extensions, ".webgl_draw_buffers"));
+              var yt = Ve.constants, Pt = yt.drawBuffer, ht = yt.backBuffer, ur;
+              at ? ur = at.append(Ve, Qe) : ur = Qe.def(Bt, ".next"), Ct || Qe("if(", ur, "!==", Bt, ".cur){"), Qe("if(", ur, "){", Rt, ".bindFramebuffer(", qr, ",", ur, ".framebuffer);"), ci && Qe(Dt, ".drawBuffersWEBGL(", Pt, "[", ur, ".colorAttachments.length]);"), Qe("}else{", Rt, ".bindFramebuffer(", qr, ",null);"), ci && Qe(Dt, ".drawBuffersWEBGL(", ht, ");"), Qe("}", Bt, ".cur=", ur, ";"), Ct || Qe("}");
+            }
+            function Ys(Ve, Qe, at) {
+              var Ct = Ve.shared, Ot = Ct.gl, Rt = Ve.current, Bt = Ve.next, Dt = Ct.current, yt = Ct.next, Pt = Ve.cond(Dt, ".dirty");
+              hi.forEach(function(ht) {
+                var ur = Ji(ht);
+                if (!(ur in at.state)) {
+                  var br, Ur;
+                  if (ur in Bt) {
+                    br = Bt[ur], Ur = Rt[ur];
+                    var Di = M(Zi[ur].length, function(Ti) {
+                      return Pt.def(br, "[", Ti, "]");
+                    });
+                    Pt(Ve.cond(Di.map(function(Ti, gn) {
+                      return Ti + "!==" + Ur + "[" + gn + "]";
+                    }).join("||")).then(Ot, ".", mn[ur], "(", Di, ");", Di.map(function(Ti, gn) {
+                      return Ur + "[" + gn + "]=" + Ti;
+                    }).join(";"), ";"));
+                  } else {
+                    br = Pt.def(yt, ".", ur);
+                    var fi = Ve.cond(br, "!==", Dt, ".", ur);
+                    Pt(fi), ur in li ? fi(Ve.cond(br).then(Ot, ".enable(", li[ur], ");").else(Ot, ".disable(", li[ur], ");"), Dt, ".", ur, "=", br, ";") : fi(Ot, ".", mn[ur], "(", br, ");", Dt, ".", ur, "=", br, ";");
+                  }
+                }
+              }), Object.keys(at.state).length === 0 && Pt(Dt, ".dirty=false;"), Qe(Pt);
+            }
+            function wa(Ve, Qe, at, Ct) {
+              var Ot = Ve.shared, Rt = Ve.current, Bt = Ot.current, Dt = Ot.gl, yt;
+              Si(Object.keys(at)).forEach(function(Pt) {
+                var ht = at[Pt];
+                if (!(Ct && !Ct(ht))) {
+                  var ur = ht.append(Ve, Qe);
+                  if (li[Pt]) {
+                    var br = li[Pt];
+                    Ln(ht) ? (yt = Ve.link(ur, { stable: true }), Qe(Ve.cond(yt).then(Dt, ".enable(", br, ");").else(Dt, ".disable(", br, ");")), Qe(Bt, ".", Pt, "=", yt, ";")) : (Qe(Ve.cond(ur).then(Dt, ".enable(", br, ");").else(Dt, ".disable(", br, ");")), Qe(Bt, ".", Pt, "=", ur, ";"));
+                  } else if (Mn(ur)) {
+                    var Ur = Rt[Pt];
+                    Qe(Dt, ".", mn[Pt], "(", ur, ");", ur.map(function(Di, fi) {
+                      return Ur + "[" + fi + "]=" + Di;
+                    }).join(";"), ";");
+                  } else Ln(ht) ? (yt = Ve.link(ur, { stable: true }), Qe(Dt, ".", mn[Pt], "(", yt, ");", Bt, ".", Pt, "=", yt, ";")) : Qe(Dt, ".", mn[Pt], "(", ur, ");", Bt, ".", Pt, "=", ur, ";");
+                }
+              });
+            }
+            function ol(Ve, Qe) {
+              Ri && (Ve.instancing = Qe.def(Ve.shared.extensions, ".angle_instanced_arrays"));
+            }
+            function io(Ve, Qe, at, Ct, Ot) {
+              var Rt = Ve.shared, Bt = Ve.stats, Dt = Rt.current, yt = Rt.timer, Pt = at.profile;
+              function ht() {
+                return typeof performance == "undefined" ? "Date.now()" : "performance.now()";
+              }
+              var ur, br;
+              function Ur(Ci) {
+                ur = Qe.def(), Ci(ur, "=", ht(), ";"), typeof Ot == "string" ? Ci(Bt, ".count+=", Ot, ";") : Ci(Bt, ".count++;"), Wi && (Ct ? (br = Qe.def(), Ci(br, "=", yt, ".getNumPendingQueries();")) : Ci(yt, ".beginQuery(", Bt, ");"));
+              }
+              function Di(Ci) {
+                Ci(Bt, ".cpuTime+=", ht(), "-", ur, ";"), Wi && (Ct ? Ci(yt, ".pushScopeStats(", br, ",", yt, ".getNumPendingQueries(),", Bt, ");") : Ci(yt, ".endQuery();"));
+              }
+              function fi(Ci) {
+                var Bi = Qe.def(Dt, ".profile");
+                Qe(Dt, ".profile=", Ci, ";"), Qe.exit(Dt, ".profile=", Bi, ";");
+              }
+              var Ti;
+              if (Pt) {
+                if (Ln(Pt)) {
+                  Pt.enable ? (Ur(Qe), Di(Qe.exit), fi("true")) : fi("false");
+                  return;
+                }
+                Ti = Pt.append(Ve, Qe), fi(Ti);
+              } else Ti = Qe.def(Dt, ".profile");
+              var gn = Ve.block();
+              Ur(gn), Qe("if(", Ti, "){", gn, "}");
+              var rn = Ve.block();
+              Di(rn), Qe.exit("if(", Ti, "){", rn, "}");
+            }
+            function Y(Ve, Qe, at, Ct, Ot) {
+              var Rt = Ve.shared;
+              function Bt(yt) {
+                switch (yt) {
+                  case Co:
+                  case Ps:
+                  case hl:
+                    return 2;
+                  case Qa:
+                  case Ts:
+                  case Ul:
+                    return 3;
+                  case mo:
+                  case wo:
+                  case Lu:
+                    return 4;
+                  default:
+                    return 1;
+                }
+              }
+              function Dt(yt, Pt, ht) {
+                var ur = Rt.gl, br = Qe.def(yt, ".location"), Ur = Qe.def(Rt.attributes, "[", br, "]"), Di = ht.state, fi = ht.buffer, Ti = [ht.x, ht.y, ht.z, ht.w], gn = ["buffer", "normalized", "offset", "stride"];
+                function rn() {
+                  Qe("if(!", Ur, ".buffer){", ur, ".enableVertexAttribArray(", br, ");}");
+                  var Bi = ht.type, Gi;
+                  if (ht.size ? Gi = Qe.def(ht.size, "||", Pt) : Gi = Pt, Qe("if(", Ur, ".type!==", Bi, "||", Ur, ".size!==", Gi, "||", gn.map(function(zn) {
+                    return Ur + "." + zn + "!==" + ht[zn];
+                  }).join("||"), "){", ur, ".bindBuffer(", Sr, ",", fi, ".buffer);", ur, ".vertexAttribPointer(", [br, Gi, Bi, ht.normalized, ht.stride, ht.offset], ");", Ur, ".type=", Bi, ";", Ur, ".size=", Gi, ";", gn.map(function(zn) {
+                    return Ur + "." + zn + "=" + ht[zn] + ";";
+                  }).join(""), "}"), Ri) {
+                    var sn = ht.divisor;
+                    Qe("if(", Ur, ".divisor!==", sn, "){", Ve.instancing, ".vertexAttribDivisorANGLE(", [br, sn], ");", Ur, ".divisor=", sn, ";}");
+                  }
+                }
+                function Ci() {
+                  Qe("if(", Ur, ".buffer){", ur, ".disableVertexAttribArray(", br, ");", Ur, ".buffer=null;", "}if(", Ca.map(function(Bi, Gi) {
+                    return Ur + "." + Bi + "!==" + Ti[Gi];
+                  }).join("||"), "){", ur, ".vertexAttrib4f(", br, ",", Ti, ");", Ca.map(function(Bi, Gi) {
+                    return Ur + "." + Bi + "=" + Ti[Gi] + ";";
+                  }).join(""), "}");
+                }
+                Di === La ? rn() : Di === Na ? Ci() : (Qe("if(", Di, "===", La, "){"), rn(), Qe("}else{"), Ci(), Qe("}"));
+              }
+              Ct.forEach(function(yt) {
+                var Pt = yt.name, ht = at.attributes[Pt], ur;
+                if (ht) {
+                  if (!Ot(ht)) return;
+                  ur = ht.append(Ve, Qe);
+                } else {
+                  if (!Ot(ia)) return;
+                  var br = Ve.scopeAttrib(Pt);
+                  ur = {}, Object.keys(new Yr()).forEach(function(Ur) {
+                    ur[Ur] = Qe.def(br, ".", Ur);
+                  });
+                }
+                Dt(Ve.link(yt), Bt(yt.info.type), ur);
+              });
+            }
+            function D(Ve, Qe, at, Ct, Ot, Rt) {
+              for (var Bt = Ve.shared, Dt = Bt.gl, yt, Pt = 0; Pt < Ct.length; ++Pt) {
+                var ht = Ct[Pt], ur = ht.name, br = ht.info.type, Ur = at.uniforms[ur], Di = Ve.link(ht), fi = Di + ".location", Ti;
+                if (Ur) {
+                  if (!Ot(Ur)) continue;
+                  if (Ln(Ur)) {
+                    var gn = Ur.value;
+                    if (br === dc || br === Tl) {
+                      var rn = Ve.link(gn._texture || gn.color[0]._texture);
+                      Qe(Dt, ".uniform1i(", fi, ",", rn + ".bind());"), Qe.exit(rn, ".unbind();");
+                    } else if (br === au || br === Js || br === eu) {
+                      var Ci = Ve.global.def("new Float32Array([" + Array.prototype.slice.call(gn) + "])"), Bi = 2;
+                      br === Js ? Bi = 3 : br === eu && (Bi = 4), Qe(Dt, ".uniformMatrix", Bi, "fv(", fi, ",false,", Ci, ");");
+                    } else {
+                      switch (br) {
+                        case $a:
+                          yt = "1f";
+                          break;
+                        case Co:
+                          yt = "2f";
+                          break;
+                        case Qa:
+                          yt = "3f";
+                          break;
+                        case mo:
+                          yt = "4f";
+                          break;
+                        case To:
+                          yt = "1i";
+                          break;
+                        case Bo:
+                          yt = "1i";
+                          break;
+                        case hl:
+                          yt = "2i";
+                          break;
+                        case Ps:
+                          yt = "2i";
+                          break;
+                        case Ul:
+                          yt = "3i";
+                          break;
+                        case Ts:
+                          yt = "3i";
+                          break;
+                        case Lu:
+                          yt = "4i";
+                          break;
+                        case wo:
+                          yt = "4i";
+                          break;
+                      }
+                      Qe(Dt, ".uniform", yt, "(", fi, ",", Mn(gn) ? Array.prototype.slice.call(gn) : gn, ");");
+                    }
+                    continue;
+                  } else Ti = Ur.append(Ve, Qe);
+                } else {
+                  if (!Ot(ia)) continue;
+                  Ti = Qe.def(Bt.uniforms, "[", bt.id(ur), "]");
+                }
+                br === dc ? Qe("if(", Ti, "&&", Ti, '._reglType==="framebuffer"){', Ti, "=", Ti, ".color[0];", "}") : br === Tl && Qe("if(", Ti, "&&", Ti, '._reglType==="framebufferCube"){', Ti, "=", Ti, ".color[0];", "}");
+                var Gi = 1;
+                switch (br) {
+                  case dc:
+                  case Tl:
+                    var sn = Qe.def(Ti, "._texture");
+                    Qe(Dt, ".uniform1i(", fi, ",", sn, ".bind());"), Qe.exit(sn, ".unbind();");
+                    continue;
+                  case Bo:
+                  case To:
+                    yt = "1i";
+                    break;
+                  case Ps:
+                  case hl:
+                    yt = "2i", Gi = 2;
+                    break;
+                  case Ts:
+                  case Ul:
+                    yt = "3i", Gi = 3;
+                    break;
+                  case wo:
+                  case Lu:
+                    yt = "4i", Gi = 4;
+                    break;
+                  case $a:
+                    yt = "1f";
+                    break;
+                  case Co:
+                    yt = "2f", Gi = 2;
+                    break;
+                  case Qa:
+                    yt = "3f", Gi = 3;
+                    break;
+                  case mo:
+                    yt = "4f", Gi = 4;
+                    break;
+                  case au:
+                    yt = "Matrix2fv";
+                    break;
+                  case Js:
+                    yt = "Matrix3fv";
+                    break;
+                  case eu:
+                    yt = "Matrix4fv";
+                    break;
+                }
+                if (yt.charAt(0) === "M") {
+                  Qe(Dt, ".uniform", yt, "(", fi, ",");
+                  var zn = Math.pow(br - au + 2, 2), Ja = Ve.global.def("new Float32Array(", zn, ")");
+                  Array.isArray(Ti) ? Qe("false,(", M(zn, function(ms) {
+                    return Ja + "[" + ms + "]=" + Ti[ms];
+                  }), ",", Ja, ")") : Qe("false,(Array.isArray(", Ti, ")||", Ti, " instanceof Float32Array)?", Ti, ":(", M(zn, function(ms) {
+                    return Ja + "[" + ms + "]=" + Ti + "[" + ms + "]";
+                  }), ",", Ja, ")"), Qe(");");
+                } else if (Gi > 1) {
+                  for (var co = [], ts = [], so = 0; so < Gi; ++so) Array.isArray(Ti) ? ts.push(Ti[so]) : ts.push(Qe.def(Ti + "[" + so + "]")), Rt && co.push(Qe.def());
+                  Rt && Qe("if(!", Ve.batchId, "||", co.map(function(ms, ou) {
+                    return ms + "!==" + ts[ou];
+                  }).join("||"), "){", co.map(function(ms, ou) {
+                    return ms + "=" + ts[ou] + ";";
+                  }).join("")), Qe(Dt, ".uniform", yt, "(", fi, ",", ts.join(","), ");"), Rt && Qe("}");
+                } else {
+                  if (Rt) {
+                    var Yo = Qe.def();
+                    Qe("if(!", Ve.batchId, "||", Yo, "!==", Ti, "){", Yo, "=", Ti, ";");
+                  }
+                  Qe(Dt, ".uniform", yt, "(", fi, ",", Ti, ");"), Rt && Qe("}");
+                }
+              }
+            }
+            function J(Ve, Qe, at, Ct) {
+              var Ot = Ve.shared, Rt = Ot.gl, Bt = Ot.draw, Dt = Ct.draw;
+              function yt() {
+                var Gi = Dt.elements, sn, zn = Qe;
+                return Gi ? ((Gi.contextDep && Ct.contextDynamic || Gi.propDep) && (zn = at), sn = Gi.append(Ve, zn), Dt.elementsActive && zn("if(" + sn + ")" + Rt + ".bindBuffer(" + Or + "," + sn + ".buffer.buffer);")) : (sn = zn.def(), zn(sn, "=", Bt, ".", Tt, ";", "if(", sn, "){", Rt, ".bindBuffer(", Or, ",", sn, ".buffer.buffer);}", "else if(", Ot.vao, ".currentVAO){", sn, "=", Ve.shared.elements + ".getElements(" + Ot.vao, ".currentVAO.elements);", an ? "" : "if(" + sn + ")" + Rt + ".bindBuffer(" + Or + "," + sn + ".buffer.buffer);", "}")), sn;
+              }
+              function Pt() {
+                var Gi = Dt.count, sn, zn = Qe;
+                return Gi ? ((Gi.contextDep && Ct.contextDynamic || Gi.propDep) && (zn = at), sn = Gi.append(Ve, zn)) : sn = zn.def(Bt, ".", Kt), sn;
+              }
+              var ht = yt();
+              function ur(Gi) {
+                var sn = Dt[Gi];
+                return sn ? sn.contextDep && Ct.contextDynamic || sn.propDep ? sn.append(Ve, at) : sn.append(Ve, Qe) : Qe.def(Bt, ".", Gi);
+              }
+              var br = ur(Yt), Ur = ur(xr), Di = Pt();
+              if (typeof Di == "number") {
+                if (Di === 0) return;
+              } else at("if(", Di, "){"), at.exit("}");
+              var fi, Ti;
+              Ri && (fi = ur(Ir), Ti = Ve.instancing);
+              var gn = ht + ".type", rn = Dt.elements && Ln(Dt.elements) && !Dt.vaoActive;
+              function Ci() {
+                function Gi() {
+                  at(Ti, ".drawElementsInstancedANGLE(", [br, Di, gn, Ur + "<<((" + gn + "-" + Ra + ")>>1)", fi], ");");
+                }
+                function sn() {
+                  at(Ti, ".drawArraysInstancedANGLE(", [br, Ur, Di, fi], ");");
+                }
+                ht && ht !== "null" ? rn ? Gi() : (at("if(", ht, "){"), Gi(), at("}else{"), sn(), at("}")) : sn();
+              }
+              function Bi() {
+                function Gi() {
+                  at(Rt + ".drawElements(" + [br, Di, gn, Ur + "<<((" + gn + "-" + Ra + ")>>1)"] + ");");
+                }
+                function sn() {
+                  at(Rt + ".drawArrays(" + [br, Ur, Di] + ");");
+                }
+                ht && ht !== "null" ? rn ? Gi() : (at("if(", ht, "){"), Gi(), at("}else{"), sn(), at("}")) : sn();
+              }
+              Ri && (typeof fi != "number" || fi >= 0) ? typeof fi == "string" ? (at("if(", fi, ">0){"), Ci(), at("}else if(", fi, "<0){"), Bi(), at("}")) : Ci() : Bi();
+            }
+            function q(Ve, Qe, at, Ct, Ot) {
+              var Rt = kn(), Bt = Rt.proc("body", Ot);
+              return Ri && (Rt.instancing = Bt.def(Rt.shared.extensions, ".angle_instanced_arrays")), Ve(Rt, Bt, at, Ct), Rt.compile().body;
+            }
+            function K(Ve, Qe, at, Ct) {
+              ol(Ve, Qe), at.useVAO ? at.drawVAO ? Qe(Ve.shared.vao, ".setVAO(", at.drawVAO.append(Ve, Qe), ");") : Qe(Ve.shared.vao, ".setVAO(", Ve.shared.vao, ".targetVAO);") : (Qe(Ve.shared.vao, ".setVAO(null);"), Y(Ve, Qe, at, Ct.attributes, function() {
+                return true;
+              })), D(Ve, Qe, at, Ct.uniforms, function() {
+                return true;
+              }, false), J(Ve, Qe, Qe, at);
+            }
+            function de(Ve, Qe) {
+              var at = Ve.proc("draw", 1);
+              ol(Ve, at), ss(Ve, at, Qe.context), Vs(Ve, at, Qe.framebuffer), Ys(Ve, at, Qe), wa(Ve, at, Qe.state), io(Ve, at, Qe, false, true);
+              var Ct = Qe.shader.progVar.append(Ve, at);
+              if (at(Ve.shared.gl, ".useProgram(", Ct, ".program);"), Qe.shader.program) K(Ve, at, Qe, Qe.shader.program);
+              else {
+                at(Ve.shared.vao, ".setVAO(null);");
+                var Ot = Ve.global.def("{}"), Rt = at.def(Ct, ".id"), Bt = at.def(Ot, "[", Rt, "]");
+                at(Ve.cond(Bt).then(Bt, ".call(this,a0);").else(Bt, "=", Ot, "[", Rt, "]=", Ve.link(function(Dt) {
+                  return q(K, Ve, Qe, Dt, 1);
+                }), "(", Ct, ");", Bt, ".call(this,a0);"));
+              }
+              Object.keys(Qe.state).length > 0 && at(Ve.shared.current, ".dirty=true;"), Ve.shared.vao && at(Ve.shared.vao, ".setVAO(null);");
+            }
+            function ne(Ve, Qe, at, Ct) {
+              Ve.batchId = "a1", ol(Ve, Qe);
+              function Ot() {
+                return true;
+              }
+              Y(Ve, Qe, at, Ct.attributes, Ot), D(Ve, Qe, at, Ct.uniforms, Ot, false), J(Ve, Qe, Qe, at);
+            }
+            function we(Ve, Qe, at, Ct) {
+              ol(Ve, Qe);
+              var Ot = at.contextDep, Rt = Qe.def(), Bt = "a0", Dt = "a1", yt = Qe.def();
+              Ve.shared.props = yt, Ve.batchId = Rt;
+              var Pt = Ve.scope(), ht = Ve.scope();
+              Qe(Pt.entry, "for(", Rt, "=0;", Rt, "<", Dt, ";++", Rt, "){", yt, "=", Bt, "[", Rt, "];", ht, "}", Pt.exit);
+              function ur(gn) {
+                return gn.contextDep && Ot || gn.propDep;
+              }
+              function br(gn) {
+                return !ur(gn);
+              }
+              if (at.needsContext && ss(Ve, ht, at.context), at.needsFramebuffer && Vs(Ve, ht, at.framebuffer), wa(Ve, ht, at.state, ur), at.profile && ur(at.profile) && io(Ve, ht, at, false, true), Ct) at.useVAO ? at.drawVAO ? ur(at.drawVAO) ? ht(Ve.shared.vao, ".setVAO(", at.drawVAO.append(Ve, ht), ");") : Pt(Ve.shared.vao, ".setVAO(", at.drawVAO.append(Ve, Pt), ");") : Pt(Ve.shared.vao, ".setVAO(", Ve.shared.vao, ".targetVAO);") : (Pt(Ve.shared.vao, ".setVAO(null);"), Y(Ve, Pt, at, Ct.attributes, br), Y(Ve, ht, at, Ct.attributes, ur)), D(Ve, Pt, at, Ct.uniforms, br, false), D(Ve, ht, at, Ct.uniforms, ur, true), J(Ve, Pt, ht, at);
+              else {
+                var Ur = Ve.global.def("{}"), Di = at.shader.progVar.append(Ve, ht), fi = ht.def(Di, ".id"), Ti = ht.def(Ur, "[", fi, "]");
+                ht(Ve.shared.gl, ".useProgram(", Di, ".program);", "if(!", Ti, "){", Ti, "=", Ur, "[", fi, "]=", Ve.link(function(gn) {
+                  return q(ne, Ve, at, gn, 2);
+                }), "(", Di, ");}", Ti, ".call(this,a0[", Rt, "],", Rt, ");");
+              }
+            }
+            function Ue(Ve, Qe) {
+              var at = Ve.proc("batch", 2);
+              Ve.batchId = "0", ol(Ve, at);
+              var Ct = false, Ot = true;
+              Object.keys(Qe.context).forEach(function(Ur) {
+                Ct = Ct || Qe.context[Ur].propDep;
+              }), Ct || (ss(Ve, at, Qe.context), Ot = false);
+              var Rt = Qe.framebuffer, Bt = false;
+              Rt ? (Rt.propDep ? Ct = Bt = true : Rt.contextDep && Ct && (Bt = true), Bt || Vs(Ve, at, Rt)) : Vs(Ve, at, null), Qe.state.viewport && Qe.state.viewport.propDep && (Ct = true);
+              function Dt(Ur) {
+                return Ur.contextDep && Ct || Ur.propDep;
+              }
+              Ys(Ve, at, Qe), wa(Ve, at, Qe.state, function(Ur) {
+                return !Dt(Ur);
+              }), (!Qe.profile || !Dt(Qe.profile)) && io(Ve, at, Qe, false, "a1"), Qe.contextDep = Ct, Qe.needsContext = Ot, Qe.needsFramebuffer = Bt;
+              var yt = Qe.shader.progVar;
+              if (yt.contextDep && Ct || yt.propDep) we(Ve, at, Qe, null);
+              else {
+                var Pt = yt.append(Ve, at);
+                if (at(Ve.shared.gl, ".useProgram(", Pt, ".program);"), Qe.shader.program) we(Ve, at, Qe, Qe.shader.program);
+                else {
+                  at(Ve.shared.vao, ".setVAO(null);");
+                  var ht = Ve.global.def("{}"), ur = at.def(Pt, ".id"), br = at.def(ht, "[", ur, "]");
+                  at(Ve.cond(br).then(br, ".call(this,a0,a1);").else(br, "=", ht, "[", ur, "]=", Ve.link(function(Ur) {
+                    return q(we, Ve, Qe, Ur, 2);
+                  }), "(", Pt, ");", br, ".call(this,a0,a1);"));
+                }
+              }
+              Object.keys(Qe.state).length > 0 && at(Ve.shared.current, ".dirty=true;"), Ve.shared.vao && at(Ve.shared.vao, ".setVAO(null);");
+            }
+            function ft(Ve, Qe) {
+              var at = Ve.proc("scope", 3);
+              Ve.batchId = "a2";
+              var Ct = Ve.shared, Ot = Ct.current;
+              if (ss(Ve, at, Qe.context), Qe.framebuffer && Qe.framebuffer.append(Ve, at), Si(Object.keys(Qe.state)).forEach(function(Dt) {
+                var yt = Qe.state[Dt], Pt = yt.append(Ve, at);
+                Mn(Pt) ? Pt.forEach(function(ht, ur) {
+                  pn(ht) ? at.set(Ve.next[Dt], "[" + ur + "]", ht) : at.set(Ve.next[Dt], "[" + ur + "]", Ve.link(ht, { stable: true }));
+                }) : Ln(yt) ? at.set(Ct.next, "." + Dt, Ve.link(Pt, { stable: true })) : at.set(Ct.next, "." + Dt, Pt);
+              }), io(Ve, at, Qe, true, true), [Tt, xr, Kt, Ir, Yt].forEach(function(Dt) {
+                var yt = Qe.draw[Dt];
+                if (yt) {
+                  var Pt = yt.append(Ve, at);
+                  pn(Pt) ? at.set(Ct.draw, "." + Dt, Pt) : at.set(Ct.draw, "." + Dt, Ve.link(Pt), { stable: true });
+                }
+              }), Object.keys(Qe.uniforms).forEach(function(Dt) {
+                var yt = Qe.uniforms[Dt].append(Ve, at);
+                Array.isArray(yt) && (yt = "[" + yt.map(function(Pt) {
+                  return pn(Pt) ? Pt : Ve.link(Pt, { stable: true });
+                }) + "]"), at.set(Ct.uniforms, "[" + Ve.link(bt.id(Dt), { stable: true }) + "]", yt);
+              }), Object.keys(Qe.attributes).forEach(function(Dt) {
+                var yt = Qe.attributes[Dt].append(Ve, at), Pt = Ve.scopeAttrib(Dt);
+                Object.keys(new Yr()).forEach(function(ht) {
+                  at.set(Pt, "." + ht, yt[ht]);
+                });
+              }), Qe.scopeVAO) {
+                var Rt = Qe.scopeVAO.append(Ve, at);
+                pn(Rt) ? at.set(Ct.vao, ".targetVAO", Rt) : at.set(Ct.vao, ".targetVAO", Ve.link(Rt, { stable: true }));
+              }
+              function Bt(Dt) {
+                var yt = Qe.shader[Dt];
+                if (yt) {
+                  var Pt = yt.append(Ve, at);
+                  pn(Pt) ? at.set(Ct.shader, "." + Dt, Pt) : at.set(Ct.shader, "." + Dt, Ve.link(Pt, { stable: true }));
+                }
+              }
+              Bt(Ze), Bt(st), Object.keys(Qe.state).length > 0 && (at(Ot, ".dirty=true;"), at.exit(Ot, ".dirty=true;")), at("a1(", Ve.shared.context, ",a0,", Ve.batchId, ");");
+            }
+            function Zt(Ve) {
+              if (!(typeof Ve != "object" || Mn(Ve))) {
+                for (var Qe = Object.keys(Ve), at = 0; at < Qe.length; ++at) if (h.isDynamic(Ve[Qe[at]])) return true;
+                return false;
+              }
+            }
+            function hr(Ve, Qe, at) {
+              var Ct = Qe.static[at];
+              if (!Ct || !Zt(Ct)) return;
+              var Ot = Ve.global, Rt = Object.keys(Ct), Bt = false, Dt = false, yt = false, Pt = Ve.global.def("{}");
+              Rt.forEach(function(ur) {
+                var br = Ct[ur];
+                if (h.isDynamic(br)) {
+                  typeof br == "function" && (br = Ct[ur] = h.unbox(br));
+                  var Ur = Un(br, null);
+                  Bt = Bt || Ur.thisDep, yt = yt || Ur.propDep, Dt = Dt || Ur.contextDep;
+                } else {
+                  switch (Ot(Pt, ".", ur, "="), typeof br) {
+                    case "number":
+                      Ot(br);
+                      break;
+                    case "string":
+                      Ot('"', br, '"');
+                      break;
+                    case "object":
+                      Array.isArray(br) && Ot("[", br.join(), "]");
+                      break;
+                    default:
+                      Ot(Ve.link(br));
+                      break;
+                  }
+                  Ot(";");
+                }
+              });
+              function ht(ur, br) {
+                Rt.forEach(function(Ur) {
+                  var Di = Ct[Ur];
+                  if (h.isDynamic(Di)) {
+                    var fi = ur.invoke(br, Di);
+                    br(Pt, ".", Ur, "=", fi, ";");
+                  }
+                });
+              }
+              Qe.dynamic[at] = new h.DynamicVariable(Zo, { thisDep: Bt, contextDep: Dt, propDep: yt, ref: Pt, append: ht }), delete Qe.static[at];
+            }
+            function qt(Ve, Qe, at, Ct, Ot) {
+              var Rt = kn();
+              Rt.stats = Rt.link(Ot), Object.keys(Qe.static).forEach(function(Dt) {
+                hr(Rt, Qe, Dt);
+              }), dr.forEach(function(Dt) {
+                hr(Rt, Ve, Dt);
+              });
+              var Bt = Vl(Ve, Qe, at, Ct, Rt);
+              return Bt.shader.program && (Bt.shader.program.attributes.sort(function(Dt, yt) {
+                return Dt.name < yt.name ? -1 : 1;
+              }), Bt.shader.program.uniforms.sort(function(Dt, yt) {
+                return Dt.name < yt.name ? -1 : 1;
+              })), de(Rt, Bt), ft(Rt, Bt), Ue(Rt, Bt), e(Rt.compile(), { destroy: function() {
+                Bt.shader.program.destroy();
+              } });
+            }
+            return { next: Bn, current: Zi, procs: function() {
+              var Ve = kn(), Qe = Ve.proc("poll"), at = Ve.proc("refresh"), Ct = Ve.block();
+              Qe(Ct), at(Ct);
+              var Ot = Ve.shared, Rt = Ot.gl, Bt = Ot.next, Dt = Ot.current;
+              Ct(Dt, ".dirty=false;"), Vs(Ve, Qe), Vs(Ve, at, null, true);
+              var yt;
+              Ri && (yt = Ve.link(Ri)), zt.oes_vertex_array_object && at(Ve.link(zt.oes_vertex_array_object), ".bindVertexArrayOES(null);");
+              var Pt = at.def(Ot.attributes), ht = at.def(0), ur = Ve.cond(ht, ".buffer");
+              ur.then(Rt, ".enableVertexAttribArray(i);", Rt, ".bindBuffer(", Sr, ",", ht, ".buffer.buffer);", Rt, ".vertexAttribPointer(i,", ht, ".size,", ht, ".type,", ht, ".normalized,", ht, ".stride,", ht, ".offset);").else(Rt, ".disableVertexAttribArray(i);", Rt, ".vertexAttrib4f(i,", ht, ".x,", ht, ".y,", ht, ".z,", ht, ".w);", ht, ".buffer=null;");
+              var br = Ve.link(Rr.maxAttributes, { stable: true });
+              return at("for(var i=0;i<", br, ";++i){", ht, "=", Pt, "[i];", ur, "}"), Ri && at("for(var i=0;i<", br, ";++i){", yt, ".vertexAttribDivisorANGLE(i,", Pt, "[i].divisor);", "}"), at(Ve.shared.vao, ".currentVAO=null;", Ve.shared.vao, ".setVAO(", Ve.shared.vao, ".targetVAO);"), Object.keys(li).forEach(function(Ur) {
+                var Di = li[Ur], fi = Ct.def(Bt, ".", Ur), Ti = Ve.block();
+                Ti("if(", fi, "){", Rt, ".enable(", Di, ")}else{", Rt, ".disable(", Di, ")}", Dt, ".", Ur, "=", fi, ";"), at(Ti), Qe("if(", fi, "!==", Dt, ".", Ur, "){", Ti, "}");
+              }), Object.keys(mn).forEach(function(Ur) {
+                var Di = mn[Ur], fi = Zi[Ur], Ti, gn, rn = Ve.block();
+                if (rn(Rt, ".", Di, "("), Mn(fi)) {
+                  var Ci = fi.length;
+                  Ti = Ve.global.def(Bt, ".", Ur), gn = Ve.global.def(Dt, ".", Ur), rn(M(Ci, function(Bi) {
+                    return Ti + "[" + Bi + "]";
+                  }), ");", M(Ci, function(Bi) {
+                    return gn + "[" + Bi + "]=" + Ti + "[" + Bi + "];";
+                  }).join("")), Qe("if(", M(Ci, function(Bi) {
+                    return Ti + "[" + Bi + "]!==" + gn + "[" + Bi + "]";
+                  }).join("||"), "){", rn, "}");
+                } else Ti = Ct.def(Bt, ".", Ur), gn = Ct.def(Dt, ".", Ur), rn(Ti, ");", Dt, ".", Ur, "=", Ti, ";"), Qe("if(", Ti, "!==", gn, "){", rn, "}");
+                at(rn);
+              }), Ve.compile();
+            }(), compile: qt };
+          }
+          function Ia() {
+            return { vaoCount: 0, bufferCount: 0, elementsCount: 0, framebufferCount: 0, shaderCount: 0, textureCount: 0, cubeCount: 0, renderbufferCount: 0, maxTextureUnits: 0 };
+          }
+          var yo = 34918, Da = 34919, go = 35007, Is = function(Me, bt) {
+            if (!bt.ext_disjoint_timer_query) return null;
+            var zt = [];
+            function Rr() {
+              return zt.pop() || bt.ext_disjoint_timer_query.createQueryEXT();
+            }
+            function jr(xi) {
+              zt.push(xi);
+            }
+            var Nr = [];
+            function Gr(xi) {
+              var Ri = Rr();
+              bt.ext_disjoint_timer_query.beginQueryEXT(go, Ri), Nr.push(Ri), Wi(Nr.length - 1, Nr.length, xi);
+            }
+            function mi() {
+              bt.ext_disjoint_timer_query.endQueryEXT(go);
+            }
+            function Ui() {
+              this.startQueryIndex = -1, this.endQueryIndex = -1, this.sum = 0, this.stats = null;
+            }
+            var qi = [];
+            function Ei() {
+              return qi.pop() || new Ui();
+            }
+            function Hn(xi) {
+              qi.push(xi);
+            }
+            var en = [];
+            function Wi(xi, Ri, ci) {
+              var an = Ei();
+              an.startQueryIndex = xi, an.endQueryIndex = Ri, an.sum = 0, an.stats = ci, en.push(an);
+            }
+            var si = [], Mr = [];
+            function Yr() {
+              var xi, Ri, ci = Nr.length;
+              if (ci !== 0) {
+                Mr.length = Math.max(Mr.length, ci + 1), si.length = Math.max(si.length, ci + 1), si[0] = 0, Mr[0] = 0;
+                var an = 0;
+                for (xi = 0, Ri = 0; Ri < Nr.length; ++Ri) {
+                  var Zi = Nr[Ri];
+                  bt.ext_disjoint_timer_query.getQueryObjectEXT(Zi, Da) ? (an += bt.ext_disjoint_timer_query.getQueryObjectEXT(Zi, yo), jr(Zi)) : Nr[xi++] = Zi, si[Ri + 1] = an, Mr[Ri + 1] = xi;
+                }
+                for (Nr.length = xi, xi = 0, Ri = 0; Ri < en.length; ++Ri) {
+                  var Bn = en[Ri], hi = Bn.startQueryIndex, li = Bn.endQueryIndex;
+                  Bn.sum += si[li] - si[hi];
+                  var mn = Mr[hi], Ji = Mr[li];
+                  Ji === mn ? (Bn.stats.gpuTime += Bn.sum / 1e6, Hn(Bn)) : (Bn.startQueryIndex = mn, Bn.endQueryIndex = Ji, en[xi++] = Bn);
+                }
+                en.length = xi;
+              }
+            }
+            return { beginQuery: Gr, endQuery: mi, pushScopeStats: Wi, update: Yr, getNumPendingQueries: function() {
+              return Nr.length;
+            }, clear: function() {
+              zt.push.apply(zt, Nr);
+              for (var xi = 0; xi < zt.length; xi++) bt.ext_disjoint_timer_query.deleteQueryEXT(zt[xi]);
+              Nr.length = 0, zt.length = 0;
+            }, restore: function() {
+              Nr.length = 0, zt.length = 0;
+            } };
+          }, Ms = 16384, Xs = 256, Gn = 1024, ja = 34962, Fo = "webglcontextlost", Uo = "webglcontextrestored", $s = 1, Sl = 2, bu = 3;
+          function dl(Me, bt) {
+            for (var zt = 0; zt < Me.length; ++zt) if (Me[zt] === bt) return zt;
+            return -1;
+          }
+          function Sc(Me) {
+            var bt = x(Me);
+            if (!bt) return null;
+            var zt = bt.gl, Rr = zt.getContextAttributes();
+            zt.isContextLost();
+            var Nr = C(zt, bt);
+            if (!Nr) return null;
+            var Gr = _(), mi = Ia(), Ui = bt.cachedCode || {}, qi = Nr.extensions, Ei = Is(zt, qi), Hn = v(), en = zt.drawingBufferWidth, Wi = zt.drawingBufferHeight, si = { tick: 0, time: 0, viewportWidth: en, viewportHeight: Wi, framebufferWidth: en, framebufferHeight: Wi, drawingBufferWidth: en, drawingBufferHeight: Wi, pixelRatio: bt.pixelRatio }, Mr = {}, Yr = { elements: null, primitive: 4, count: -1, offset: 0, instances: -1 }, xi = ti(zt, qi), Ri = ri(zt, mi, bt, Zi), ci = kr(zt, qi, Ri, mi), an = ku(zt, qi, xi, mi, Ri, ci, Yr);
+            function Zi(q) {
+              return an.destroyBuffer(q);
+            }
+            var Bn = Wu(zt, Gr, mi, bt), hi = of(zt, qi, xi, function() {
+              Ji.procs.poll();
+            }, si, mi, bt), li = Dc(zt, qi, xi, mi, bt), mn = lf(zt, qi, xi, hi, li, mi), Ji = Ea(zt, Gr, qi, xi, Ri, ci, hi, mn, Mr, an, Bn, Yr, si, Ei, Ui, bt), Vi = Wl(zt, mn, Ji.procs.poll, si), Ni = Ji.next, pn = zt.canvas, Vn = [], na = [], Ki = [], kn = [bt.onDestroy], ta = null;
+            function oa() {
+              if (Vn.length === 0) {
+                Ei && Ei.update(), ta = null;
+                return;
+              }
+              ta = d.next(oa), Ys();
+              for (var q = Vn.length - 1; q >= 0; --q) {
+                var K = Vn[q];
+                K && K(si, null, 0);
+              }
+              zt.flush(), Ei && Ei.update();
+            }
+            function ba() {
+              !ta && Vn.length > 0 && (ta = d.next(oa));
+            }
+            function is() {
+              ta && (d.cancel(oa), ta = null);
+            }
+            function Zs(q) {
+              q.preventDefault(), is(), na.forEach(function(K) {
+                K();
+              });
+            }
+            function Va(q) {
+              zt.getError(), Nr.restore(), Bn.restore(), Ri.restore(), hi.restore(), li.restore(), mn.restore(), an.restore(), Ei && Ei.restore(), Ji.procs.refresh(), ba(), Ki.forEach(function(K) {
+                K();
+              });
+            }
+            pn && (pn.addEventListener(Fo, Zs, false), pn.addEventListener(Uo, Va, false));
+            function Ml() {
+              Vn.length = 0, is(), pn && (pn.removeEventListener(Fo, Zs), pn.removeEventListener(Uo, Va)), Bn.clear(), mn.clear(), li.clear(), an.clear(), hi.clear(), ci.clear(), Ri.clear(), Ei && Ei.clear(), kn.forEach(function(q) {
+                q();
+              });
+            }
+            function zo(q) {
+              function K(Rt) {
+                var Bt = e({}, Rt);
+                delete Bt.uniforms, delete Bt.attributes, delete Bt.context, delete Bt.vao, "stencil" in Bt && Bt.stencil.op && (Bt.stencil.opBack = Bt.stencil.opFront = Bt.stencil.op, delete Bt.stencil.op);
+                function Dt(yt) {
+                  if (yt in Bt) {
+                    var Pt = Bt[yt];
+                    delete Bt[yt], Object.keys(Pt).forEach(function(ht) {
+                      Bt[yt + "." + ht] = Pt[ht];
+                    });
+                  }
+                }
+                return Dt("blend"), Dt("depth"), Dt("cull"), Dt("stencil"), Dt("polygonOffset"), Dt("scissor"), Dt("sample"), "vao" in Rt && (Bt.vao = Rt.vao), Bt;
+              }
+              function de(Rt, Bt) {
+                var Dt = {}, yt = {};
+                return Object.keys(Rt).forEach(function(Pt) {
+                  var ht = Rt[Pt];
+                  if (h.isDynamic(ht)) {
+                    yt[Pt] = h.unbox(ht, Pt);
+                    return;
+                  } else if (Bt && Array.isArray(ht)) {
+                    for (var ur = 0; ur < ht.length; ++ur) if (h.isDynamic(ht[ur])) {
+                      yt[Pt] = h.unbox(ht, Pt);
+                      return;
+                    }
+                  }
+                  Dt[Pt] = ht;
+                }), { dynamic: yt, static: Dt };
+              }
+              var ne = de(q.context || {}, true), we = de(q.uniforms || {}, true), Ue = de(q.attributes || {}, false), ft = de(K(q), false), Zt = { gpuTime: 0, cpuTime: 0, count: 0 }, hr = Ji.compile(ft, Ue, we, ne, Zt), qt = hr.draw, Ve = hr.batch, Qe = hr.scope, at = [];
+              function Ct(Rt) {
+                for (; at.length < Rt; ) at.push(null);
+                return at;
+              }
+              function Ot(Rt, Bt) {
+                var Dt;
+                if (typeof Rt == "function") return Qe.call(this, null, Rt, 0);
+                if (typeof Bt == "function") if (typeof Rt == "number") for (Dt = 0; Dt < Rt; ++Dt) Qe.call(this, null, Bt, Dt);
+                else if (Array.isArray(Rt)) for (Dt = 0; Dt < Rt.length; ++Dt) Qe.call(this, Rt[Dt], Bt, Dt);
+                else return Qe.call(this, Rt, Bt, 0);
+                else if (typeof Rt == "number") {
+                  if (Rt > 0) return Ve.call(this, Ct(Rt | 0), Rt | 0);
+                } else if (Array.isArray(Rt)) {
+                  if (Rt.length) return Ve.call(this, Rt, Rt.length);
+                } else return qt.call(this, Rt);
+              }
+              return e(Ot, { stats: Zt, destroy: function() {
+                hr.destroy();
+              } });
+            }
+            var Qs = mn.setFBO = zo({ framebuffer: h.define.call(null, $s, "framebuffer") });
+            function al(q, K) {
+              var de = 0;
+              Ji.procs.poll();
+              var ne = K.color;
+              ne && (zt.clearColor(+ne[0] || 0, +ne[1] || 0, +ne[2] || 0, +ne[3] || 0), de |= Ms), "depth" in K && (zt.clearDepth(+K.depth), de |= Xs), "stencil" in K && (zt.clearStencil(K.stencil | 0), de |= Gn), zt.clear(de);
+            }
+            function Vl(q) {
+              if ("framebuffer" in q) if (q.framebuffer && q.framebuffer_reglType === "framebufferCube") for (var K = 0; K < 6; ++K) Qs(e({ framebuffer: q.framebuffer.faces[K] }, q), al);
+              else Qs(q, al);
+              else al(null, q);
+            }
+            function ss(q) {
+              Vn.push(q);
+              function K() {
+                var de = dl(Vn, q);
+                function ne() {
+                  var we = dl(Vn, ne);
+                  Vn[we] = Vn[Vn.length - 1], Vn.length -= 1, Vn.length <= 0 && is();
+                }
+                Vn[de] = ne;
+              }
+              return ba(), { cancel: K };
+            }
+            function Vs() {
+              var q = Ni.viewport, K = Ni.scissor_box;
+              q[0] = q[1] = K[0] = K[1] = 0, si.viewportWidth = si.framebufferWidth = si.drawingBufferWidth = q[2] = K[2] = zt.drawingBufferWidth, si.viewportHeight = si.framebufferHeight = si.drawingBufferHeight = q[3] = K[3] = zt.drawingBufferHeight;
+            }
+            function Ys() {
+              si.tick += 1, si.time = ol(), Vs(), Ji.procs.poll();
+            }
+            function wa() {
+              hi.refresh(), Vs(), Ji.procs.refresh(), Ei && Ei.update();
+            }
+            function ol() {
+              return (v() - Hn) / 1e3;
+            }
+            wa();
+            function io(q, K) {
+              var de;
+              switch (q) {
+                case "frame":
+                  return ss(K);
+                case "lost":
+                  de = na;
+                  break;
+                case "restore":
+                  de = Ki;
+                  break;
+                case "destroy":
+                  de = kn;
+                  break;
+              }
+              return de.push(K), { cancel: function() {
+                for (var ne = 0; ne < de.length; ++ne) if (de[ne] === K) {
+                  de[ne] = de[de.length - 1], de.pop();
+                  return;
+                }
+              } };
+            }
+            function Y() {
+              return Ui;
+            }
+            function D(q) {
+              Object.entries(q).forEach(function(K) {
+                Ui[K[0]] = K[1];
+              });
+            }
+            var J = e(zo, { clear: Vl, prop: h.define.bind(null, $s), context: h.define.bind(null, Sl), this: h.define.bind(null, bu), draw: zo({}), buffer: function(q) {
+              return Ri.create(q, ja, false, false);
+            }, elements: function(q) {
+              return ci.create(q, false);
+            }, texture: hi.create2D, cube: hi.createCube, renderbuffer: li.create, framebuffer: mn.create, framebufferCube: mn.createCube, vao: an.createVAO, attributes: Rr, frame: ss, on: io, limits: xi, hasExtension: function(q) {
+              return xi.extensions.indexOf(q.toLowerCase()) >= 0;
+            }, read: Vi, destroy: Ml, _gl: zt, _refresh: wa, poll: function() {
+              Ys(), Ei && Ei.update();
+            }, now: ol, stats: mi, getCachedCode: Y, preloadCachedCode: D });
+            return bt.onDone(null, J), J;
+          }
+          return Sc;
+        });
+      });
+      var Kqe = ye((v_r, Yqe) => {
+        var pUt = ey();
+        Yqe.exports = function(t) {
+          if (t ? typeof t == "string" && (t = { container: t }) : t = {}, Xqe(t) ? t = { container: t } : gUt(t) ? t = { container: t } : mUt(t) ? t = { gl: t } : t = pUt(t, { container: "container target element el canvas holder parent parentNode wrapper use ref root node", gl: "gl context webgl glContext", attrs: "attributes attrs contextAttributes", pixelRatio: "pixelRatio pxRatio px ratio pxratio pixelratio", width: "w width", height: "h height" }, true), t.pixelRatio || (t.pixelRatio = window.pixelRatio || 1), t.gl) return t.gl;
+          if (t.canvas && (t.container = t.canvas.parentNode), t.container) {
+            if (typeof t.container == "string") {
+              var r = document.querySelector(t.container);
+              if (!r) throw Error("Element " + t.container + " is not found");
+              t.container = r;
+            }
+            Xqe(t.container) ? (t.canvas = t.container, t.container = t.canvas.parentNode) : t.canvas || (t.canvas = Zqe(), t.container.appendChild(t.canvas), Wqe(t));
+          } else if (!t.canvas) if (typeof document != "undefined") t.container = document.body || document.documentElement, t.canvas = Zqe(), t.container.appendChild(t.canvas), Wqe(t);
+          else throw Error("Not DOM environment. Use headless-gl.");
+          return t.gl || ["webgl", "experimental-webgl", "webgl-experimental"].some(function(n) {
+            try {
+              t.gl = t.canvas.getContext(n, t.attrs);
+            } catch (i) {
+            }
+            return t.gl;
+          }), t.gl;
+        };
+        function Wqe(e) {
+          if (e.container) if (e.container == document.body) document.body.style.width || (e.canvas.width = e.width || e.pixelRatio * window.innerWidth), document.body.style.height || (e.canvas.height = e.height || e.pixelRatio * window.innerHeight);
+          else {
+            var t = e.container.getBoundingClientRect();
+            e.canvas.width = e.width || t.right - t.left, e.canvas.height = e.height || t.bottom - t.top;
+          }
+        }
+        function Xqe(e) {
+          return typeof e.getContext == "function" && "width" in e && "height" in e;
+        }
+        function gUt(e) {
+          return typeof e.nodeName == "string" && typeof e.appendChild == "function" && typeof e.getBoundingClientRect == "function";
+        }
+        function mUt(e) {
+          return typeof e.drawArrays == "function" || typeof e.drawElements == "function";
+        }
+        function Zqe() {
+          var e = document.createElement("canvas");
+          return e.style.position = "absolute", e.style.top = 0, e.style.left = 0, e;
+        }
+      });
+      var $qe = ye((p_r, Jqe) => {
+        var yUt = sK(), _Ut = [32, 126];
+        Jqe.exports = xUt;
+        function xUt(e) {
+          e = e || {};
+          var t = e.shape ? e.shape : e.canvas ? [e.canvas.width, e.canvas.height] : [512, 512], r = e.canvas || document.createElement("canvas"), n = e.font, i = typeof e.step == "number" ? [e.step, e.step] : e.step || [32, 32], a = e.chars || _Ut;
+          if (n && typeof n != "string" && (n = yUt(n)), !Array.isArray(a)) a = String(a).split("");
+          else if (a.length === 2 && typeof a[0] == "number" && typeof a[1] == "number") {
+            for (var o = [], s = a[0], l = 0; s <= a[1]; s++) o[l++] = String.fromCharCode(s);
+            a = o;
+          }
+          t = t.slice(), r.width = t[0], r.height = t[1];
+          var u = r.getContext("2d");
+          u.fillStyle = "#000", u.fillRect(0, 0, r.width, r.height), u.font = n, u.textAlign = "center", u.textBaseline = "middle", u.fillStyle = "#fff";
+          for (var c = i[0] / 2, f = i[1] / 2, s = 0; s < a.length; s++) u.fillText(a[s], c, f), (c += i[0]) > t[0] - i[0] / 2 && (c = i[0] / 2, f += i[1]);
+          return r;
+        }
+      });
+      var fK = ye((Vh) => {
+        "use restrict";
+        var cK = 32;
+        Vh.INT_BITS = cK;
+        Vh.INT_MAX = 2147483647;
+        Vh.INT_MIN = -1 << cK - 1;
+        Vh.sign = function(e) {
+          return (e > 0) - (e < 0);
+        };
+        Vh.abs = function(e) {
+          var t = e >> cK - 1;
+          return (e ^ t) - t;
+        };
+        Vh.min = function(e, t) {
+          return t ^ (e ^ t) & -(e < t);
+        };
+        Vh.max = function(e, t) {
+          return e ^ (e ^ t) & -(e < t);
+        };
+        Vh.isPow2 = function(e) {
+          return !(e & e - 1) && !!e;
+        };
+        Vh.log2 = function(e) {
+          var t, r;
+          return t = (e > 65535) << 4, e >>>= t, r = (e > 255) << 3, e >>>= r, t |= r, r = (e > 15) << 2, e >>>= r, t |= r, r = (e > 3) << 1, e >>>= r, t |= r, t | e >> 1;
+        };
+        Vh.log10 = function(e) {
+          return e >= 1e9 ? 9 : e >= 1e8 ? 8 : e >= 1e7 ? 7 : e >= 1e6 ? 6 : e >= 1e5 ? 5 : e >= 1e4 ? 4 : e >= 1e3 ? 3 : e >= 100 ? 2 : e >= 10 ? 1 : 0;
+        };
+        Vh.popCount = function(e) {
+          return e = e - (e >>> 1 & 1431655765), e = (e & 858993459) + (e >>> 2 & 858993459), (e + (e >>> 4) & 252645135) * 16843009 >>> 24;
+        };
+        function Qqe(e) {
+          var t = 32;
+          return e &= -e, e && t--, e & 65535 && (t -= 16), e & 16711935 && (t -= 8), e & 252645135 && (t -= 4), e & 858993459 && (t -= 2), e & 1431655765 && (t -= 1), t;
+        }
+        Vh.countTrailingZeros = Qqe;
+        Vh.nextPow2 = function(e) {
+          return e += e === 0, --e, e |= e >>> 1, e |= e >>> 2, e |= e >>> 4, e |= e >>> 8, e |= e >>> 16, e + 1;
+        };
+        Vh.prevPow2 = function(e) {
+          return e |= e >>> 1, e |= e >>> 2, e |= e >>> 4, e |= e >>> 8, e |= e >>> 16, e - (e >>> 1);
+        };
+        Vh.parity = function(e) {
+          return e ^= e >>> 16, e ^= e >>> 8, e ^= e >>> 4, e &= 15, 27030 >>> e & 1;
+        };
+        var Dk = new Array(256);
+        (function(e) {
+          for (var t = 0; t < 256; ++t) {
+            var r = t, n = t, i = 7;
+            for (r >>>= 1; r; r >>>= 1) n <<= 1, n |= r & 1, --i;
+            e[t] = n << i & 255;
+          }
+        })(Dk);
+        Vh.reverse = function(e) {
+          return Dk[e & 255] << 24 | Dk[e >>> 8 & 255] << 16 | Dk[e >>> 16 & 255] << 8 | Dk[e >>> 24 & 255];
+        };
+        Vh.interleave2 = function(e, t) {
+          return e &= 65535, e = (e | e << 8) & 16711935, e = (e | e << 4) & 252645135, e = (e | e << 2) & 858993459, e = (e | e << 1) & 1431655765, t &= 65535, t = (t | t << 8) & 16711935, t = (t | t << 4) & 252645135, t = (t | t << 2) & 858993459, t = (t | t << 1) & 1431655765, e | t << 1;
+        };
+        Vh.deinterleave2 = function(e, t) {
+          return e = e >>> t & 1431655765, e = (e | e >>> 1) & 858993459, e = (e | e >>> 2) & 252645135, e = (e | e >>> 4) & 16711935, e = (e | e >>> 16) & 65535, e << 16 >> 16;
+        };
+        Vh.interleave3 = function(e, t, r) {
+          return e &= 1023, e = (e | e << 16) & 4278190335, e = (e | e << 8) & 251719695, e = (e | e << 4) & 3272356035, e = (e | e << 2) & 1227133513, t &= 1023, t = (t | t << 16) & 4278190335, t = (t | t << 8) & 251719695, t = (t | t << 4) & 3272356035, t = (t | t << 2) & 1227133513, e |= t << 1, r &= 1023, r = (r | r << 16) & 4278190335, r = (r | r << 8) & 251719695, r = (r | r << 4) & 3272356035, r = (r | r << 2) & 1227133513, e | r << 2;
+        };
+        Vh.deinterleave3 = function(e, t) {
+          return e = e >>> t & 1227133513, e = (e | e >>> 2) & 3272356035, e = (e | e >>> 4) & 251719695, e = (e | e >>> 8) & 4278190335, e = (e | e >>> 16) & 1023, e << 22 >> 22;
+        };
+        Vh.nextCombination = function(e) {
+          var t = e | e - 1;
+          return t + 1 | (~t & -~t) - 1 >>> Qqe(e) + 1;
+        };
+      });
+      var rBe = ye((m_r, tBe) => {
+        function eBe(e, t, r) {
+          var n = e[r] | 0;
+          if (n <= 0) return [];
+          var i = new Array(n), a;
+          if (r === e.length - 1) for (a = 0; a < n; ++a) i[a] = t;
+          else for (a = 0; a < n; ++a) i[a] = eBe(e, t, r + 1);
+          return i;
+        }
+        function bUt(e, t) {
+          var r, n;
+          for (r = new Array(e), n = 0; n < e; ++n) r[n] = t;
+          return r;
+        }
+        function wUt(e, t) {
+          switch (typeof t == "undefined" && (t = 0), typeof e) {
+            case "number":
+              if (e > 0) return bUt(e | 0, t);
+              break;
+            case "object":
+              if (typeof e.length == "number") return eBe(e, t, 0);
+              break;
+          }
+          return [];
+        }
+        tBe.exports = wUt;
+      });
+      var mBe = ye((mu) => {
+        var xx = fK(), Ev = rBe(), iBe = _2().Buffer;
+        window.__TYPEDARRAY_POOL || (window.__TYPEDARRAY_POOL = { UINT8: Ev([32, 0]), UINT16: Ev([32, 0]), UINT32: Ev([32, 0]), BIGUINT64: Ev([32, 0]), INT8: Ev([32, 0]), INT16: Ev([32, 0]), INT32: Ev([32, 0]), BIGINT64: Ev([32, 0]), FLOAT: Ev([32, 0]), DOUBLE: Ev([32, 0]), DATA: Ev([32, 0]), UINT8C: Ev([32, 0]), BUFFER: Ev([32, 0]) });
+        var TUt = typeof Uint8ClampedArray != "undefined", AUt = typeof BigUint64Array != "undefined", SUt = typeof BigInt64Array != "undefined", ad = window.__TYPEDARRAY_POOL;
+        ad.UINT8C || (ad.UINT8C = Ev([32, 0]));
+        ad.BIGUINT64 || (ad.BIGUINT64 = Ev([32, 0]));
+        ad.BIGINT64 || (ad.BIGINT64 = Ev([32, 0]));
+        ad.BUFFER || (ad.BUFFER = Ev([32, 0]));
+        var Tz = ad.DATA, Az = ad.BUFFER;
+        mu.free = function(t) {
+          if (iBe.isBuffer(t)) Az[xx.log2(t.length)].push(t);
+          else {
+            if (Object.prototype.toString.call(t) !== "[object ArrayBuffer]" && (t = t.buffer), !t) return;
+            var r = t.length || t.byteLength, n = xx.log2(r) | 0;
+            Tz[n].push(t);
+          }
+        };
+        function nBe(e) {
+          if (e) {
+            var t = e.length || e.byteLength, r = xx.log2(t);
+            Tz[r].push(e);
+          }
+        }
+        function MUt(e) {
+          nBe(e.buffer);
+        }
+        mu.freeUint8 = mu.freeUint16 = mu.freeUint32 = mu.freeBigUint64 = mu.freeInt8 = mu.freeInt16 = mu.freeInt32 = mu.freeBigInt64 = mu.freeFloat32 = mu.freeFloat = mu.freeFloat64 = mu.freeDouble = mu.freeUint8Clamped = mu.freeDataView = MUt;
+        mu.freeArrayBuffer = nBe;
+        mu.freeBuffer = function(t) {
+          Az[xx.log2(t.length)].push(t);
+        };
+        mu.malloc = function(t, r) {
+          if (r === void 0 || r === "arraybuffer") return Bp(t);
+          switch (r) {
+            case "uint8":
+              return hK(t);
+            case "uint16":
+              return aBe(t);
+            case "uint32":
+              return oBe(t);
+            case "int8":
+              return sBe(t);
+            case "int16":
+              return lBe(t);
+            case "int32":
+              return uBe(t);
+            case "float":
+            case "float32":
+              return cBe(t);
+            case "double":
+            case "float64":
+              return fBe(t);
+            case "uint8_clamped":
+              return hBe(t);
+            case "bigint64":
+              return vBe(t);
+            case "biguint64":
+              return dBe(t);
+            case "buffer":
+              return gBe(t);
+            case "data":
+            case "dataview":
+              return pBe(t);
+            default:
+              return null;
+          }
+          return null;
+        };
+        function Bp(t) {
+          var t = xx.nextPow2(t), r = xx.log2(t), n = Tz[r];
+          return n.length > 0 ? n.pop() : new ArrayBuffer(t);
+        }
+        mu.mallocArrayBuffer = Bp;
+        function hK(e) {
+          return new Uint8Array(Bp(e), 0, e);
+        }
+        mu.mallocUint8 = hK;
+        function aBe(e) {
+          return new Uint16Array(Bp(2 * e), 0, e);
+        }
+        mu.mallocUint16 = aBe;
+        function oBe(e) {
+          return new Uint32Array(Bp(4 * e), 0, e);
+        }
+        mu.mallocUint32 = oBe;
+        function sBe(e) {
+          return new Int8Array(Bp(e), 0, e);
+        }
+        mu.mallocInt8 = sBe;
+        function lBe(e) {
+          return new Int16Array(Bp(2 * e), 0, e);
+        }
+        mu.mallocInt16 = lBe;
+        function uBe(e) {
+          return new Int32Array(Bp(4 * e), 0, e);
+        }
+        mu.mallocInt32 = uBe;
+        function cBe(e) {
+          return new Float32Array(Bp(4 * e), 0, e);
+        }
+        mu.mallocFloat32 = mu.mallocFloat = cBe;
+        function fBe(e) {
+          return new Float64Array(Bp(8 * e), 0, e);
+        }
+        mu.mallocFloat64 = mu.mallocDouble = fBe;
+        function hBe(e) {
+          return TUt ? new Uint8ClampedArray(Bp(e), 0, e) : hK(e);
+        }
+        mu.mallocUint8Clamped = hBe;
+        function dBe(e) {
+          return AUt ? new BigUint64Array(Bp(8 * e), 0, e) : null;
+        }
+        mu.mallocBigUint64 = dBe;
+        function vBe(e) {
+          return SUt ? new BigInt64Array(Bp(8 * e), 0, e) : null;
+        }
+        mu.mallocBigInt64 = vBe;
+        function pBe(e) {
+          return new DataView(Bp(e), 0, e);
+        }
+        mu.mallocDataView = pBe;
+        function gBe(e) {
+          e = xx.nextPow2(e);
+          var t = xx.log2(e), r = Az[t];
+          return r.length > 0 ? r.pop() : new iBe(e);
+        }
+        mu.mallocBuffer = gBe;
+        mu.clearCache = function() {
+          for (var t = 0; t < 32; ++t) ad.UINT8[t].length = 0, ad.UINT16[t].length = 0, ad.UINT32[t].length = 0, ad.INT8[t].length = 0, ad.INT16[t].length = 0, ad.INT32[t].length = 0, ad.FLOAT[t].length = 0, ad.DOUBLE[t].length = 0, ad.BIGUINT64[t].length = 0, ad.BIGINT64[t].length = 0, ad.UINT8C[t].length = 0, Tz[t].length = 0, Az[t].length = 0;
+        };
+      });
+      var _Be = ye((__r, yBe) => {
+        var EUt = Object.prototype.toString;
+        yBe.exports = function(e) {
+          var t;
+          return EUt.call(e) === "[object Object]" && (t = Object.getPrototypeOf(e), t === null || t === Object.getPrototypeOf({}));
+        };
+      });
+      var dK = ye((x_r, xBe) => {
+        xBe.exports = function(t, r) {
+          r || (r = [0, ""]), t = String(t);
+          var n = parseFloat(t, 10);
+          return r[0] = n, r[1] = t.match(/[\d.\-\+]*\s*(.*)/)[1] || "", r;
+        };
+      });
+      var TBe = ye((b_r, wBe) => {
+        var kUt = dK();
+        wBe.exports = bBe;
+        var Fk = 96;
+        function vK(e, t) {
+          var r = kUt(getComputedStyle(e).getPropertyValue(t));
+          return r[0] * bBe(r[1], e);
+        }
+        function CUt(e, t) {
+          var r = document.createElement("div");
+          r.style["font-size"] = "128" + e, t.appendChild(r);
+          var n = vK(r, "font-size") / 128;
+          return t.removeChild(r), n;
+        }
+        function bBe(e, t) {
+          switch (t = t || document.body, e = (e || "px").trim().toLowerCase(), (t === window || t === document) && (t = document.body), e) {
+            case "%":
+              return t.clientHeight / 100;
+            case "ch":
+            case "ex":
+              return CUt(e, t);
+            case "em":
+              return vK(t, "font-size");
+            case "rem":
+              return vK(document.body, "font-size");
+            case "vw":
+              return window.innerWidth / 100;
+            case "vh":
+              return window.innerHeight / 100;
+            case "vmin":
+              return Math.min(window.innerWidth, window.innerHeight) / 100;
+            case "vmax":
+              return Math.max(window.innerWidth, window.innerHeight) / 100;
+            case "in":
+              return Fk;
+            case "cm":
+              return Fk / 2.54;
+            case "mm":
+              return Fk / 25.4;
+            case "pt":
+              return Fk / 72;
+            case "pc":
+              return Fk / 6;
+          }
+          return 1;
+        }
+      });
+      var MBe = ye((w_r, SBe) => {
+        SBe.exports = Ez;
+        var LUt = Ez.canvas = document.createElement("canvas"), Sz = LUt.getContext("2d"), ABe = Mz([32, 126]);
+        Ez.createPairs = Mz;
+        Ez.ascii = ABe;
+        function Ez(e, t) {
+          Array.isArray(e) && (e = e.join(", "));
+          var r = {}, n, i = 16, a = 0.05;
+          t && (t.length === 2 && typeof t[0] == "number" ? n = Mz(t) : Array.isArray(t) ? n = t : (t.o ? n = Mz(t.o) : t.pairs && (n = t.pairs), t.fontSize && (i = t.fontSize), t.threshold != null && (a = t.threshold))), n || (n = ABe), Sz.font = i + "px " + e;
+          for (var o = 0; o < n.length; o++) {
+            var s = n[o], l = Sz.measureText(s[0]).width + Sz.measureText(s[1]).width, u = Sz.measureText(s).width;
+            if (Math.abs(l - u) > i * a) {
+              var c = (u - l) / i;
+              r[s] = c * 1e3;
+            }
+          }
+          return r;
+        }
+        function Mz(e) {
+          for (var t = [], r = e[0]; r <= e[1]; r++) for (var n = String.fromCharCode(r), i = e[0]; i < e[1]; i++) {
+            var a = String.fromCharCode(i), o = n + a;
+            t.push(o);
+          }
+          return t;
+        }
+      });
+      var LBe = ye((T_r, CBe) => {
+        CBe.exports = bx;
+        bx.canvas = document.createElement("canvas");
+        bx.cache = {};
+        function bx(o, t) {
+          t || (t = {}), (typeof o == "string" || Array.isArray(o)) && (t.family = o);
+          var r = Array.isArray(t.family) ? t.family.join(", ") : t.family;
+          if (!r) throw Error("`family` must be defined");
+          var n = t.size || t.fontSize || t.em || 48, i = t.weight || t.fontWeight || "", a = t.style || t.fontStyle || "", o = [a, i, n].join(" ") + "px " + r, s = t.origin || "top";
+          if (bx.cache[r] && n <= bx.cache[r].em) return EBe(bx.cache[r], s);
+          var l = t.canvas || bx.canvas, u = l.getContext("2d"), c = { upper: t.upper !== void 0 ? t.upper : "H", lower: t.lower !== void 0 ? t.lower : "x", descent: t.descent !== void 0 ? t.descent : "p", ascent: t.ascent !== void 0 ? t.ascent : "h", tittle: t.tittle !== void 0 ? t.tittle : "i", overshoot: t.overshoot !== void 0 ? t.overshoot : "O" }, f = Math.ceil(n * 1.5);
+          l.height = f, l.width = f * 0.5, u.font = o;
+          var h = "H", d = { top: 0 };
+          u.clearRect(0, 0, f, f), u.textBaseline = "top", u.fillStyle = "black", u.fillText(h, 0, 0);
+          var v = ry(u.getImageData(0, 0, f, f));
+          u.clearRect(0, 0, f, f), u.textBaseline = "bottom", u.fillText(h, 0, f);
+          var _ = ry(u.getImageData(0, 0, f, f));
+          d.lineHeight = d.bottom = f - _ + v, u.clearRect(0, 0, f, f), u.textBaseline = "alphabetic", u.fillText(h, 0, f);
+          var b = ry(u.getImageData(0, 0, f, f)), p = f - b - 1 + v;
+          d.baseline = d.alphabetic = p, u.clearRect(0, 0, f, f), u.textBaseline = "middle", u.fillText(h, 0, f * 0.5);
+          var k = ry(u.getImageData(0, 0, f, f));
+          d.median = d.middle = f - k - 1 + v - f * 0.5, u.clearRect(0, 0, f, f), u.textBaseline = "hanging", u.fillText(h, 0, f * 0.5);
+          var E = ry(u.getImageData(0, 0, f, f));
+          d.hanging = f - E - 1 + v - f * 0.5, u.clearRect(0, 0, f, f), u.textBaseline = "ideographic", u.fillText(h, 0, f);
+          var T = ry(u.getImageData(0, 0, f, f));
+          if (d.ideographic = f - T - 1 + v, c.upper && (u.clearRect(0, 0, f, f), u.textBaseline = "top", u.fillText(c.upper, 0, 0), d.upper = ry(u.getImageData(0, 0, f, f)), d.capHeight = d.baseline - d.upper), c.lower && (u.clearRect(0, 0, f, f), u.textBaseline = "top", u.fillText(c.lower, 0, 0), d.lower = ry(u.getImageData(0, 0, f, f)), d.xHeight = d.baseline - d.lower), c.tittle && (u.clearRect(0, 0, f, f), u.textBaseline = "top", u.fillText(c.tittle, 0, 0), d.tittle = ry(u.getImageData(0, 0, f, f))), c.ascent && (u.clearRect(0, 0, f, f), u.textBaseline = "top", u.fillText(c.ascent, 0, 0), d.ascent = ry(u.getImageData(0, 0, f, f))), c.descent && (u.clearRect(0, 0, f, f), u.textBaseline = "top", u.fillText(c.descent, 0, 0), d.descent = kBe(u.getImageData(0, 0, f, f))), c.overshoot) {
+            u.clearRect(0, 0, f, f), u.textBaseline = "top", u.fillText(c.overshoot, 0, 0);
+            var L = kBe(u.getImageData(0, 0, f, f));
+            d.overshoot = L - p;
+          }
+          for (var x in d) d[x] /= n;
+          return d.em = n, bx.cache[r] = d, EBe(d, s);
+        }
+        function EBe(e, t) {
+          var r = {};
+          typeof t == "string" && (t = e[t]);
+          for (var n in e) n !== "em" && (r[n] = e[n] - t);
+          return r;
+        }
+        function ry(e) {
+          for (var t = e.height, r = e.data, n = 3; n < r.length; n += 4) if (r[n] !== 0) return Math.floor((n - 3) * 0.25 / t);
+        }
+        function kBe(e) {
+          for (var t = e.height, r = e.data, n = r.length - 1; n > 0; n -= 4) if (r[n] !== 0) return Math.floor((n - 3) * 0.25 / t);
+        }
+      });
+      var DBe = ye((A_r, RBe) => {
+        var _5 = Hqe(), PUt = ey(), IUt = jqe(), RUt = Kqe(), DUt = XY(), pK = ox(), FUt = $qe(), wx = mBe(), zUt = s5(), OUt = _Be(), qUt = dK(), BUt = TBe(), NUt = MBe(), UUt = Nh(), VUt = LBe(), GUt = iw(), HUt = fK(), PBe = HUt.nextPow2, IBe = new DUt(), Cz = false;
+        document.body && (kz = document.body.appendChild(document.createElement("div")), kz.style.font = "italic small-caps bold condensed 16px/2 cursive", getComputedStyle(kz).fontStretch && (Cz = true), document.body.removeChild(kz));
+        var kz, xc = function(t) {
+          jUt(t) ? (t = { regl: t }, this.gl = t.regl._gl) : this.gl = RUt(t), this.shader = IBe.get(this.gl), this.shader ? this.regl = this.shader.regl : this.regl = t.regl || IUt({ gl: this.gl }), this.charBuffer = this.regl.buffer({ type: "uint8", usage: "stream" }), this.sizeBuffer = this.regl.buffer({ type: "float", usage: "stream" }), this.shader || (this.shader = this.createShader(), IBe.set(this.gl, this.shader)), this.batch = [], this.fontSize = [], this.font = [], this.fontAtlas = [], this.draw = this.shader.draw.bind(this), this.render = function() {
+            this.regl._refresh(), this.draw(this.batch);
+          }, this.canvas = this.gl.canvas, this.update(OUt(t) ? t : {});
+        };
+        xc.prototype.createShader = function() {
+          var t = this.regl, r = t({ blend: { enable: true, color: [0, 0, 0, 1], func: { srcRGB: "src alpha", dstRGB: "one minus src alpha", srcAlpha: "one minus dst alpha", dstAlpha: "one" } }, stencil: { enable: false }, depth: { enable: false }, count: t.prop("count"), offset: t.prop("offset"), attributes: { charOffset: { offset: 4, stride: 8, buffer: t.this("sizeBuffer") }, width: { offset: 0, stride: 8, buffer: t.this("sizeBuffer") }, char: t.this("charBuffer"), position: t.this("position") }, uniforms: { atlasSize: function(i, a) {
+            return [a.atlas.width, a.atlas.height];
+          }, atlasDim: function(i, a) {
+            return [a.atlas.cols, a.atlas.rows];
+          }, atlas: function(i, a) {
+            return a.atlas.texture;
+          }, charStep: function(i, a) {
+            return a.atlas.step;
+          }, em: function(i, a) {
+            return a.atlas.em;
+          }, color: t.prop("color"), opacity: t.prop("opacity"), viewport: t.this("viewportArray"), scale: t.this("scale"), align: t.prop("align"), baseline: t.prop("baseline"), translate: t.this("translate"), positionOffset: t.prop("positionOffset") }, primitive: "points", viewport: t.this("viewport"), vert: `
+			precision highp float;
+			attribute float width, charOffset, char;
+			attribute vec2 position;
+			uniform float fontSize, charStep, em, align, baseline;
+			uniform vec4 viewport;
+			uniform vec4 color;
+			uniform vec2 atlasSize, atlasDim, scale, translate, positionOffset;
+			varying vec2 charCoord, charId;
+			varying float charWidth;
+			varying vec4 fontColor;
+			void main () {
+				vec2 offset = floor(em * (vec2(align + charOffset, baseline)
+					+ vec2(positionOffset.x, -positionOffset.y)))
+					/ (viewport.zw * scale.xy);
+
+				vec2 position = (position + translate) * scale;
+				position += offset * scale;
+
+				charCoord = position * viewport.zw + viewport.xy;
+
+				gl_Position = vec4(position * 2. - 1., 0, 1);
+
+				gl_PointSize = charStep;
+
+				charId.x = mod(char, atlasDim.x);
+				charId.y = floor(char / atlasDim.x);
+
+				charWidth = width * em;
+
+				fontColor = color / 255.;
+			}`, frag: `
+			precision highp float;
+			uniform float fontSize, charStep, opacity;
+			uniform vec2 atlasSize;
+			uniform vec4 viewport;
+			uniform sampler2D atlas;
+			varying vec4 fontColor;
+			varying vec2 charCoord, charId;
+			varying float charWidth;
+
+			float lightness(vec4 color) {
+				return color.r * 0.299 + color.g * 0.587 + color.b * 0.114;
+			}
+
+			void main () {
+				vec2 uv = gl_FragCoord.xy - charCoord + charStep * .5;
+				float halfCharStep = floor(charStep * .5 + .5);
+
+				// invert y and shift by 1px (FF expecially needs that)
+				uv.y = charStep - uv.y;
+
+				// ignore points outside of character bounding box
+				float halfCharWidth = ceil(charWidth * .5);
+				if (floor(uv.x) > halfCharStep + halfCharWidth ||
+					floor(uv.x) < halfCharStep - halfCharWidth) return;
+
+				uv += charId * charStep;
+				uv = uv / atlasSize;
+
+				vec4 color = fontColor;
+				vec4 mask = texture2D(atlas, uv);
+
+				float maskY = lightness(mask);
+				// float colorY = lightness(color);
+				color.a *= maskY;
+				color.a *= opacity;
+
+				// color.a += .1;
+
+				// antialiasing, see yiq color space y-channel formula
+				// color.rgb += (1. - color.rgb) * (1. - mask.rgb);
+
+				gl_FragColor = color;
+			}` }), n = {};
+          return { regl: t, draw: r, atlas: n };
+        };
+        xc.prototype.update = function(t) {
+          var r = this;
+          if (typeof t == "string") t = { text: t };
+          else if (!t) return;
+          t = PUt(t, { position: "position positions coord coords coordinates", font: "font fontFace fontface typeface cssFont css-font family fontFamily", fontSize: "fontSize fontsize size font-size", text: "text texts chars characters value values symbols", align: "align alignment textAlign textbaseline", baseline: "baseline textBaseline textbaseline", direction: "dir direction textDirection", color: "color colour fill fill-color fillColor textColor textcolor", kerning: "kerning kern", range: "range dataBox", viewport: "vp viewport viewBox viewbox viewPort", opacity: "opacity alpha transparency visible visibility opaque", offset: "offset positionOffset padding shift indent indentation" }, true), t.opacity != null && (Array.isArray(t.opacity) ? this.opacity = t.opacity.map(function(Le) {
+            return parseFloat(Le);
+          }) : this.opacity = parseFloat(t.opacity)), t.viewport != null && (this.viewport = zUt(t.viewport), this.viewportArray = [this.viewport.x, this.viewport.y, this.viewport.width, this.viewport.height]), this.viewport == null && (this.viewport = { x: 0, y: 0, width: this.gl.drawingBufferWidth, height: this.gl.drawingBufferHeight }, this.viewportArray = [this.viewport.x, this.viewport.y, this.viewport.width, this.viewport.height]), t.kerning != null && (this.kerning = t.kerning), t.offset != null && (typeof t.offset == "number" && (t.offset = [t.offset, 0]), this.positionOffset = GUt(t.offset)), t.direction && (this.direction = t.direction), t.range && (this.range = t.range, this.scale = [1 / (t.range[2] - t.range[0]), 1 / (t.range[3] - t.range[1])], this.translate = [-t.range[0], -t.range[1]]), t.scale && (this.scale = t.scale), t.translate && (this.translate = t.translate), this.scale || (this.scale = [1 / this.viewport.width, 1 / this.viewport.height]), this.translate || (this.translate = [0, 0]), !this.font.length && !t.font && (t.font = xc.baseFontSize + "px sans-serif");
+          var n = false, i = false;
+          if (t.font && (Array.isArray(t.font) ? t.font : [t.font]).forEach(function(Le, ge) {
+            if (typeof Le == "string") try {
+              Le = _5.parse(Le);
+            } catch (je) {
+              Le = _5.parse(xc.baseFontSize + "px " + Le);
+            }
+            else {
+              var ie = Le.style, Se = Le.weight, Ee = Le.stretch, Ae = Le.variant;
+              Le = _5.parse(_5.stringify(Le)), ie && (Le.style = ie), Se && (Le.weight = Se), Ee && (Le.stretch = Ee), Ae && (Le.variant = Ae);
+            }
+            var Be = _5.stringify({ size: xc.baseFontSize, family: Le.family, stretch: Cz ? Le.stretch : void 0, variant: Le.variant, weight: Le.weight, style: Le.style }), Pe = qUt(Le.size), me = Math.round(Pe[0] * BUt(Pe[1]));
+            if (me !== r.fontSize[ge] && (i = true, r.fontSize[ge] = me), (!r.font[ge] || Be != r.font[ge].baseString) && (n = true, r.font[ge] = xc.fonts[Be], !r.font[ge])) {
+              var De = Le.family.join(", "), ce = [Le.style];
+              Le.style != Le.variant && ce.push(Le.variant), Le.variant != Le.weight && ce.push(Le.weight), Cz && Le.weight != Le.stretch && ce.push(Le.stretch), r.font[ge] = { baseString: Be, family: De, weight: Le.weight, stretch: Le.stretch, style: Le.style, variant: Le.variant, width: {}, kerning: {}, metrics: VUt(De, { origin: "top", fontSize: xc.baseFontSize, fontStyle: ce.join(" ") }) }, xc.fonts[Be] = r.font[ge];
+            }
+          }), (n || i) && this.font.forEach(function(Le, ge) {
+            var ie = _5.stringify({ size: r.fontSize[ge], family: Le.family, stretch: Cz ? Le.stretch : void 0, variant: Le.variant, weight: Le.weight, style: Le.style });
+            if (r.fontAtlas[ge] = r.shader.atlas[ie], !r.fontAtlas[ge]) {
+              var Se = Le.metrics;
+              r.shader.atlas[ie] = r.fontAtlas[ge] = { fontString: ie, step: Math.ceil(r.fontSize[ge] * Se.bottom * 0.5) * 2, em: r.fontSize[ge], cols: 0, rows: 0, height: 0, width: 0, chars: [], ids: {}, texture: r.regl.texture() };
+            }
+            t.text == null && (t.text = r.text);
+          }), typeof t.text == "string" && t.position && t.position.length > 2) {
+            for (var a = Array(t.position.length * 0.5), o = 0; o < a.length; o++) a[o] = t.text;
+            t.text = a;
+          }
+          var s;
+          if (t.text != null || n) {
+            if (this.textOffsets = [0], Array.isArray(t.text)) {
+              this.count = t.text[0].length, this.counts = [this.count];
+              for (var l = 1; l < t.text.length; l++) this.textOffsets[l] = this.textOffsets[l - 1] + t.text[l - 1].length, this.count += t.text[l].length, this.counts.push(t.text[l].length);
+              this.text = t.text.join("");
+            } else this.text = t.text, this.count = this.text.length, this.counts = [this.count];
+            s = [], this.font.forEach(function(Le, ge) {
+              xc.atlasContext.font = Le.baseString;
+              for (var ie = r.fontAtlas[ge], Se = 0; Se < r.text.length; Se++) {
+                var Ee = r.text.charAt(Se);
+                if (ie.ids[Ee] == null && (ie.ids[Ee] = ie.chars.length, ie.chars.push(Ee), s.push(Ee)), Le.width[Ee] == null && (Le.width[Ee] = xc.atlasContext.measureText(Ee).width / xc.baseFontSize, r.kerning)) {
+                  var Ae = [];
+                  for (var Be in Le.width) Ae.push(Be + Ee, Ee + Be);
+                  UUt(Le.kerning, NUt(Le.family, { pairs: Ae }));
+                }
+              }
+            });
+          }
+          if (t.position) if (t.position.length > 2) {
+            for (var u = !t.position[0].length, c = wx.mallocFloat(this.count * 2), f = 0, h = 0; f < this.counts.length; f++) {
+              var d = this.counts[f];
+              if (u) for (var v = 0; v < d; v++) c[h++] = t.position[f * 2], c[h++] = t.position[f * 2 + 1];
+              else for (var _ = 0; _ < d; _++) c[h++] = t.position[f][0], c[h++] = t.position[f][1];
+            }
+            this.position.call ? this.position({ type: "float", data: c }) : this.position = this.regl.buffer({ type: "float", data: c }), wx.freeFloat(c);
+          } else this.position.destroy && this.position.destroy(), this.position = { constant: t.position };
+          if (t.text || n) {
+            var b = wx.mallocUint8(this.count), p = wx.mallocFloat(this.count * 2);
+            this.textWidth = [];
+            for (var k = 0, E = 0; k < this.counts.length; k++) {
+              for (var T = this.counts[k], L = this.font[k] || this.font[0], x = this.fontAtlas[k] || this.fontAtlas[0], C = 0; C < T; C++) {
+                var M = this.text.charAt(E), g = this.text.charAt(E - 1);
+                if (b[E] = x.ids[M], p[E * 2] = L.width[M], C) {
+                  var P = p[E * 2 - 2], A = p[E * 2], z = p[E * 2 - 1], O = z + P * 0.5 + A * 0.5;
+                  if (this.kerning) {
+                    var U = L.kerning[g + M];
+                    U && (O += U * 1e-3);
+                  }
+                  p[E * 2 + 1] = O;
+                } else p[E * 2 + 1] = p[E * 2] * 0.5;
+                E++;
+              }
+              this.textWidth.push(p.length ? p[E * 2 - 2] * 0.5 + p[E * 2 - 1] : 0);
+            }
+            t.align || (t.align = this.align), this.charBuffer({ data: b, type: "uint8", usage: "stream" }), this.sizeBuffer({ data: p, type: "float", usage: "stream" }), wx.freeUint8(b), wx.freeFloat(p), s.length && this.font.forEach(function(Le, ge) {
+              var ie = r.fontAtlas[ge], Se = ie.step, Ee = Math.floor(xc.maxAtlasSize / Se), Ae = Math.min(Ee, ie.chars.length), Be = Math.ceil(ie.chars.length / Ae), Pe = PBe(Ae * Se), me = PBe(Be * Se);
+              ie.width = Pe, ie.height = me, ie.rows = Be, ie.cols = Ae, ie.em && ie.texture({ data: FUt({ canvas: xc.atlasCanvas, font: ie.fontString, chars: ie.chars, shape: [Pe, me], step: [Se, Se] }) });
+            });
+          }
+          if (t.align && (this.align = t.align, this.alignOffset = this.textWidth.map(function(Le, ge) {
+            var ie = Array.isArray(r.align) ? r.align.length > 1 ? r.align[ge] : r.align[0] : r.align;
+            if (typeof ie == "number") return ie;
+            switch (ie) {
+              case "right":
+              case "end":
+                return -Le;
+              case "center":
+              case "centre":
+              case "middle":
+                return -Le * 0.5;
+            }
+            return 0;
+          })), this.baseline == null && t.baseline == null && (t.baseline = 0), t.baseline != null && (this.baseline = t.baseline, Array.isArray(this.baseline) || (this.baseline = [this.baseline]), this.baselineOffset = this.baseline.map(function(Le, ge) {
+            var ie = (r.font[ge] || r.font[0]).metrics, Se = 0;
+            return Se += ie.bottom * 0.5, typeof Le == "number" ? Se += Le - ie.baseline : Se += -ie[Le], Se *= -1, Se;
+          })), t.color != null) if (t.color || (t.color = "transparent"), typeof t.color == "string" || !isNaN(t.color)) this.color = pK(t.color, "uint8");
+          else {
+            var G;
+            if (typeof t.color[0] == "number" && t.color.length > this.counts.length) {
+              var Z = t.color.length;
+              G = wx.mallocUint8(Z);
+              for (var j = (t.color.subarray || t.color.slice).bind(t.color), N = 0; N < Z; N += 4) G.set(pK(j(N, N + 4), "uint8"), N);
+            } else {
+              var H = t.color.length;
+              G = wx.mallocUint8(H * 4);
+              for (var re = 0; re < H; re++) G.set(pK(t.color[re] || 0, "uint8"), re * 4);
+            }
+            this.color = G;
+          }
+          if (t.position || t.text || t.color || t.baseline || t.align || t.font || t.offset || t.opacity) {
+            var oe = this.color.length > 4 || this.baselineOffset.length > 1 || this.align && this.align.length > 1 || this.fontAtlas.length > 1 || this.positionOffset.length > 2;
+            if (oe) {
+              var _e = Math.max(this.position.length * 0.5 || 0, this.color.length * 0.25 || 0, this.baselineOffset.length || 0, this.alignOffset.length || 0, this.font.length || 0, this.opacity.length || 0, this.positionOffset.length * 0.5 || 0);
+              this.batch = Array(_e);
+              for (var Ce = 0; Ce < this.batch.length; Ce++) this.batch[Ce] = { count: this.counts.length > 1 ? this.counts[Ce] : this.counts[0], offset: this.textOffsets.length > 1 ? this.textOffsets[Ce] : this.textOffsets[0], color: this.color ? this.color.length <= 4 ? this.color : this.color.subarray(Ce * 4, Ce * 4 + 4) : [0, 0, 0, 255], opacity: Array.isArray(this.opacity) ? this.opacity[Ce] : this.opacity, baseline: this.baselineOffset[Ce] != null ? this.baselineOffset[Ce] : this.baselineOffset[0], align: this.align ? this.alignOffset[Ce] != null ? this.alignOffset[Ce] : this.alignOffset[0] : 0, atlas: this.fontAtlas[Ce] || this.fontAtlas[0], positionOffset: this.positionOffset.length > 2 ? this.positionOffset.subarray(Ce * 2, Ce * 2 + 2) : this.positionOffset };
+            } else this.count ? this.batch = [{ count: this.count, offset: 0, color: this.color || [0, 0, 0, 255], opacity: Array.isArray(this.opacity) ? this.opacity[0] : this.opacity, baseline: this.baselineOffset[0], align: this.alignOffset ? this.alignOffset[0] : 0, atlas: this.fontAtlas[0], positionOffset: this.positionOffset }] : this.batch = [];
+          }
+        };
+        xc.prototype.destroy = function() {
+        };
+        xc.prototype.kerning = true;
+        xc.prototype.position = { constant: new Float32Array(2) };
+        xc.prototype.translate = null;
+        xc.prototype.scale = null;
+        xc.prototype.font = null;
+        xc.prototype.text = "";
+        xc.prototype.positionOffset = [0, 0];
+        xc.prototype.opacity = 1;
+        xc.prototype.color = new Uint8Array([0, 0, 0, 255]);
+        xc.prototype.alignOffset = [0, 0];
+        xc.maxAtlasSize = 1024;
+        xc.atlasCanvas = document.createElement("canvas");
+        xc.atlasContext = xc.atlasCanvas.getContext("2d", { alpha: false });
+        xc.baseFontSize = 64;
+        xc.fonts = {};
+        function jUt(e) {
+          return typeof e == "function" && e._gl && e.prop && e.texture && e.buffer;
+        }
+        RBe.exports = xc;
+      });
+      var FBe = ye((gK, mK) => {
+        (function(e, t) {
+          typeof gK == "object" && typeof mK != "undefined" ? mK.exports = t() : e.createREGL = t();
+        })(gK, function() {
+          var e = function(Me, bt) {
+            for (var zt = Object.keys(bt), Rr = 0; Rr < zt.length; ++Rr) Me[zt[Rr]] = bt[zt[Rr]];
+            return Me;
+          }, t = 0, r = 0, n = 5, i = 6;
+          function a(Me, bt) {
+            this.id = t++, this.type = Me, this.data = bt;
+          }
+          function o(Me) {
+            return Me.replace(/\\/g, "\\\\").replace(/"/g, '\\"');
+          }
+          function s(Me) {
+            if (Me.length === 0) return [];
+            var bt = Me.charAt(0), zt = Me.charAt(Me.length - 1);
+            if (Me.length > 1 && bt === zt && (bt === '"' || bt === "'")) return ['"' + o(Me.substr(1, Me.length - 2)) + '"'];
+            var Rr = /\[(false|true|null|\d+|'[^']*'|"[^"]*")\]/.exec(Me);
+            if (Rr) return s(Me.substr(0, Rr.index)).concat(s(Rr[1])).concat(s(Me.substr(Rr.index + Rr[0].length)));
+            var jr = Me.split(".");
+            if (jr.length === 1) return ['"' + o(Me) + '"'];
+            for (var Nr = [], Gr = 0; Gr < jr.length; ++Gr) Nr = Nr.concat(s(jr[Gr]));
+            return Nr;
+          }
+          function l(Me) {
+            return "[" + s(Me).join("][") + "]";
+          }
+          function u(Me, bt) {
+            return new a(Me, l(bt + ""));
+          }
+          function c(Me) {
+            return typeof Me == "function" && !Me._reglType || Me instanceof a;
+          }
+          function f(Me, bt) {
+            if (typeof Me == "function") return new a(r, Me);
+            if (typeof Me == "number" || typeof Me == "boolean") return new a(n, Me);
+            if (Array.isArray(Me)) return new a(i, Me.map(function(zt, Rr) {
+              return f(zt);
+            }));
+            if (Me instanceof a) return Me;
+          }
+          var h = { DynamicVariable: a, define: u, isDynamic: c, unbox: f, accessor: l }, d = { next: typeof requestAnimationFrame == "function" ? function(Me) {
+            return requestAnimationFrame(Me);
+          } : function(Me) {
+            return setTimeout(Me, 16);
+          }, cancel: typeof cancelAnimationFrame == "function" ? function(Me) {
+            return cancelAnimationFrame(Me);
+          } : clearTimeout }, v = typeof performance != "undefined" && performance.now ? function() {
+            return performance.now();
+          } : function() {
+            return +/* @__PURE__ */ new Date();
+          };
+          function _() {
+            var Me = { "": 0 }, bt = [""];
+            return { id: function(zt) {
+              var Rr = Me[zt];
+              return Rr || (Rr = Me[zt] = bt.length, bt.push(zt), Rr);
+            }, str: function(zt) {
+              return bt[zt];
+            } };
+          }
+          function b(Me, bt, zt) {
+            var Rr = document.createElement("canvas");
+            e(Rr.style, { border: 0, margin: 0, padding: 0, top: 0, left: 0, width: "100%", height: "100%" }), Me.appendChild(Rr), Me === document.body && (Rr.style.position = "absolute", e(Me.style, { margin: 0, padding: 0 }));
+            function jr() {
+              var mi = window.innerWidth, Ui = window.innerHeight;
+              if (Me !== document.body) {
+                var qi = Rr.getBoundingClientRect();
+                mi = qi.right - qi.left, Ui = qi.bottom - qi.top;
+              }
+              Rr.width = zt * mi, Rr.height = zt * Ui;
+            }
+            var Nr;
+            Me !== document.body && typeof ResizeObserver == "function" ? (Nr = new ResizeObserver(function() {
+              setTimeout(jr);
+            }), Nr.observe(Me)) : window.addEventListener("resize", jr, false);
+            function Gr() {
+              Nr ? Nr.disconnect() : window.removeEventListener("resize", jr), Me.removeChild(Rr);
+            }
+            return jr(), { canvas: Rr, onDestroy: Gr };
+          }
+          function p(Me, bt) {
+            function zt(Rr) {
+              try {
+                return Me.getContext(Rr, bt);
+              } catch (jr) {
+                return null;
+              }
+            }
+            return zt("webgl") || zt("experimental-webgl") || zt("webgl-experimental");
+          }
+          function k(Me) {
+            return typeof Me.nodeName == "string" && typeof Me.appendChild == "function" && typeof Me.getBoundingClientRect == "function";
+          }
+          function E(Me) {
+            return typeof Me.drawArrays == "function" || typeof Me.drawElements == "function";
+          }
+          function T(Me) {
+            return typeof Me == "string" ? Me.split() : Me;
+          }
+          function L(Me) {
+            return typeof Me == "string" ? document.querySelector(Me) : Me;
+          }
+          function x(Me) {
+            var bt = Me || {}, zt, Rr, jr, Nr, Gr = {}, mi = [], Ui = [], qi = typeof window == "undefined" ? 1 : window.devicePixelRatio, Ei = false, Hn = {}, en = function(Mr) {
+            }, Wi = function() {
+            };
+            if (typeof bt == "string" ? zt = document.querySelector(bt) : typeof bt == "object" && (k(bt) ? zt = bt : E(bt) ? (Nr = bt, jr = Nr.canvas) : ("gl" in bt ? Nr = bt.gl : "canvas" in bt ? jr = L(bt.canvas) : "container" in bt && (Rr = L(bt.container)), "attributes" in bt && (Gr = bt.attributes), "extensions" in bt && (mi = T(bt.extensions)), "optionalExtensions" in bt && (Ui = T(bt.optionalExtensions)), "onDone" in bt && (en = bt.onDone), "profile" in bt && (Ei = !!bt.profile), "pixelRatio" in bt && (qi = +bt.pixelRatio), "cachedCode" in bt && (Hn = bt.cachedCode))), zt && (zt.nodeName.toLowerCase() === "canvas" ? jr = zt : Rr = zt), !Nr) {
+              if (!jr) {
+                var si = b(Rr || document.body, en, qi);
+                if (!si) return null;
+                jr = si.canvas, Wi = si.onDestroy;
+              }
+              Gr.premultipliedAlpha === void 0 && (Gr.premultipliedAlpha = true), Nr = p(jr, Gr);
+            }
+            return Nr ? { gl: Nr, canvas: jr, container: Rr, extensions: mi, optionalExtensions: Ui, pixelRatio: qi, profile: Ei, cachedCode: Hn, onDone: en, onDestroy: Wi } : (Wi(), en("webgl not supported, try upgrading your browser or graphics drivers http://get.webgl.org"), null);
+          }
+          function C(Me, bt) {
+            var zt = {};
+            function Rr(Gr) {
+              var mi = Gr.toLowerCase(), Ui;
+              try {
+                Ui = zt[mi] = Me.getExtension(mi);
+              } catch (qi) {
+              }
+              return !!Ui;
+            }
+            for (var jr = 0; jr < bt.extensions.length; ++jr) {
+              var Nr = bt.extensions[jr];
+              if (!Rr(Nr)) return bt.onDestroy(), bt.onDone('"' + Nr + '" extension is not supported by the current WebGL context, try upgrading your system or a different browser'), null;
+            }
+            return bt.optionalExtensions.forEach(Rr), { extensions: zt, restore: function() {
+              Object.keys(zt).forEach(function(Gr) {
+                if (zt[Gr] && !Rr(Gr)) throw new Error("(regl): error restoring extension " + Gr);
+              });
+            } };
+          }
+          function M(Me, bt) {
+            for (var zt = Array(Me), Rr = 0; Rr < Me; ++Rr) zt[Rr] = bt(Rr);
+            return zt;
+          }
+          var g = 5120, P = 5121, A = 5122, z = 5123, O = 5124, U = 5125, G = 5126;
+          function Z(Me) {
+            for (var bt = 16; bt <= 1 << 28; bt *= 16) if (Me <= bt) return bt;
+            return 0;
+          }
+          function j(Me) {
+            var bt, zt;
+            return bt = (Me > 65535) << 4, Me >>>= bt, zt = (Me > 255) << 3, Me >>>= zt, bt |= zt, zt = (Me > 15) << 2, Me >>>= zt, bt |= zt, zt = (Me > 3) << 1, Me >>>= zt, bt |= zt, bt | Me >> 1;
+          }
+          function N() {
+            var Me = M(8, function() {
+              return [];
+            });
+            function bt(Nr) {
+              var Gr = Z(Nr), mi = Me[j(Gr) >> 2];
+              return mi.length > 0 ? mi.pop() : new ArrayBuffer(Gr);
+            }
+            function zt(Nr) {
+              Me[j(Nr.byteLength) >> 2].push(Nr);
+            }
+            function Rr(Nr, Gr) {
+              var mi = null;
+              switch (Nr) {
+                case g:
+                  mi = new Int8Array(bt(Gr), 0, Gr);
+                  break;
+                case P:
+                  mi = new Uint8Array(bt(Gr), 0, Gr);
+                  break;
+                case A:
+                  mi = new Int16Array(bt(2 * Gr), 0, Gr);
+                  break;
+                case z:
+                  mi = new Uint16Array(bt(2 * Gr), 0, Gr);
+                  break;
+                case O:
+                  mi = new Int32Array(bt(4 * Gr), 0, Gr);
+                  break;
+                case U:
+                  mi = new Uint32Array(bt(4 * Gr), 0, Gr);
+                  break;
+                case G:
+                  mi = new Float32Array(bt(4 * Gr), 0, Gr);
+                  break;
+                default:
+                  return null;
+              }
+              return mi.length !== Gr ? mi.subarray(0, Gr) : mi;
+            }
+            function jr(Nr) {
+              zt(Nr.buffer);
+            }
+            return { alloc: bt, free: zt, allocType: Rr, freeType: jr };
+          }
+          var H = N();
+          H.zero = N();
+          var re = 3408, oe = 3410, _e = 3411, Ce = 3412, Le = 3413, ge = 3414, ie = 3415, Se = 33901, Ee = 33902, Ae = 3379, Be = 3386, Pe = 34921, me = 36347, De = 36348, ce = 35661, je = 35660, lt = 34930, pt = 36349, Vt = 34076, ot = 34024, ut = 7936, Wt = 7937, Nt = 7938, $t = 35724, sr = 34047, Tr = 36063, fr = 34852, $e = 3553, St = 34067, Qt = 34069, Gt = 33984, _t = 6408, It = 5126, mt = 5121, er = 36160, lr = 36053, wr = 36064, Lr = 16384, ti = function(Me, bt) {
+            var zt = 1;
+            bt.ext_texture_filter_anisotropic && (zt = Me.getParameter(sr));
+            var Rr = 1, jr = 1;
+            bt.webgl_draw_buffers && (Rr = Me.getParameter(fr), jr = Me.getParameter(Tr));
+            var Nr = !!bt.oes_texture_float;
+            if (Nr) {
+              var Gr = Me.createTexture();
+              Me.bindTexture($e, Gr), Me.texImage2D($e, 0, _t, 1, 1, 0, _t, It, null);
+              var mi = Me.createFramebuffer();
+              if (Me.bindFramebuffer(er, mi), Me.framebufferTexture2D(er, wr, $e, Gr, 0), Me.bindTexture($e, null), Me.checkFramebufferStatus(er) !== lr) Nr = false;
+              else {
+                Me.viewport(0, 0, 1, 1), Me.clearColor(1, 0, 0, 1), Me.clear(Lr);
+                var Ui = H.allocType(It, 4);
+                Me.readPixels(0, 0, 1, 1, _t, It, Ui), Me.getError() ? Nr = false : (Me.deleteFramebuffer(mi), Me.deleteTexture(Gr), Nr = Ui[0] === 1), H.freeType(Ui);
+              }
+            }
+            var qi = typeof navigator != "undefined" && (/MSIE/.test(navigator.userAgent) || /Trident\//.test(navigator.appVersion) || /Edge/.test(navigator.userAgent)), Ei = true;
+            if (!qi) {
+              var Hn = Me.createTexture(), en = H.allocType(mt, 36);
+              Me.activeTexture(Gt), Me.bindTexture(St, Hn), Me.texImage2D(Qt, 0, _t, 3, 3, 0, _t, mt, en), H.freeType(en), Me.bindTexture(St, null), Me.deleteTexture(Hn), Ei = !Me.getError();
+            }
+            return { colorBits: [Me.getParameter(oe), Me.getParameter(_e), Me.getParameter(Ce), Me.getParameter(Le)], depthBits: Me.getParameter(ge), stencilBits: Me.getParameter(ie), subpixelBits: Me.getParameter(re), extensions: Object.keys(bt).filter(function(Wi) {
+              return !!bt[Wi];
+            }), maxAnisotropic: zt, maxDrawbuffers: Rr, maxColorAttachments: jr, pointSizeDims: Me.getParameter(Se), lineWidthDims: Me.getParameter(Ee), maxViewportDims: Me.getParameter(Be), maxCombinedTextureUnits: Me.getParameter(ce), maxCubeMapSize: Me.getParameter(Vt), maxRenderbufferSize: Me.getParameter(ot), maxTextureUnits: Me.getParameter(lt), maxTextureSize: Me.getParameter(Ae), maxAttributes: Me.getParameter(Pe), maxVertexUniforms: Me.getParameter(me), maxVertexTextureUnits: Me.getParameter(je), maxVaryingVectors: Me.getParameter(De), maxFragmentUniforms: Me.getParameter(pt), glsl: Me.getParameter($t), renderer: Me.getParameter(Wt), vendor: Me.getParameter(ut), version: Me.getParameter(Nt), readFloat: Nr, npotTextureCube: Ei };
+          }, Br = function(Me) {
+            return Me instanceof Uint8Array || Me instanceof Uint16Array || Me instanceof Uint32Array || Me instanceof Int8Array || Me instanceof Int16Array || Me instanceof Int32Array || Me instanceof Float32Array || Me instanceof Float64Array || Me instanceof Uint8ClampedArray;
+          };
+          function Vr(Me) {
+            return !!Me && typeof Me == "object" && Array.isArray(Me.shape) && Array.isArray(Me.stride) && typeof Me.offset == "number" && Me.shape.length === Me.stride.length && (Array.isArray(Me.data) || Br(Me.data));
+          }
+          var dt = function(Me) {
+            return Object.keys(Me).map(function(bt) {
+              return Me[bt];
+            });
+          }, Ge = { shape: xe, flatten: Ie };
+          function Je(Me, bt, zt) {
+            for (var Rr = 0; Rr < bt; ++Rr) zt[Rr] = Me[Rr];
+          }
+          function We(Me, bt, zt, Rr) {
+            for (var jr = 0, Nr = 0; Nr < bt; ++Nr) for (var Gr = Me[Nr], mi = 0; mi < zt; ++mi) Rr[jr++] = Gr[mi];
+          }
+          function tt(Me, bt, zt, Rr, jr, Nr) {
+            for (var Gr = Nr, mi = 0; mi < bt; ++mi) for (var Ui = Me[mi], qi = 0; qi < zt; ++qi) for (var Ei = Ui[qi], Hn = 0; Hn < Rr; ++Hn) jr[Gr++] = Ei[Hn];
+          }
+          function xt(Me, bt, zt, Rr, jr) {
+            for (var Nr = 1, Gr = zt + 1; Gr < bt.length; ++Gr) Nr *= bt[Gr];
+            var mi = bt[zt];
+            if (bt.length - zt === 4) {
+              var Ui = bt[zt + 1], qi = bt[zt + 2], Ei = bt[zt + 3];
+              for (Gr = 0; Gr < mi; ++Gr) tt(Me[Gr], Ui, qi, Ei, Rr, jr), jr += Nr;
+            } else for (Gr = 0; Gr < mi; ++Gr) xt(Me[Gr], bt, zt + 1, Rr, jr), jr += Nr;
+          }
+          function Ie(Me, bt, zt, Rr) {
+            var jr = 1;
+            if (bt.length) for (var Nr = 0; Nr < bt.length; ++Nr) jr *= bt[Nr];
+            else jr = 0;
+            var Gr = Rr || H.allocType(zt, jr);
+            switch (bt.length) {
+              case 0:
+                break;
+              case 1:
+                Je(Me, bt[0], Gr);
+                break;
+              case 2:
+                We(Me, bt[0], bt[1], Gr);
+                break;
+              case 3:
+                tt(Me, bt[0], bt[1], bt[2], Gr, 0);
+                break;
+              default:
+                xt(Me, bt, 0, Gr, 0);
+            }
+            return Gr;
+          }
+          function xe(Me) {
+            for (var bt = [], zt = Me; zt.length; zt = zt[0]) bt.push(zt.length);
+            return bt;
+          }
+          var ke = { "[object Int8Array]": 5120, "[object Int16Array]": 5122, "[object Int32Array]": 5124, "[object Uint8Array]": 5121, "[object Uint8ClampedArray]": 5121, "[object Uint16Array]": 5123, "[object Uint32Array]": 5125, "[object Float32Array]": 5126, "[object Float64Array]": 5121, "[object ArrayBuffer]": 5121 }, vt = 5120, ir = 5122, ar = 5124, vr = 5121, ii = 5123, pi = 5125, $r = 5126, di = 5126, ji = { int8: vt, int16: ir, int32: ar, uint8: vr, uint16: ii, uint32: pi, float: $r, float32: di }, In = 35048, wi = 35040, On = { dynamic: In, stream: wi, static: 35044 }, qn = Ge.flatten, Fn = Ge.shape, ra = 35044, la = 35040, Ut = 5121, wt = 5126, rr = [];
+          rr[5120] = 1, rr[5122] = 2, rr[5124] = 4, rr[5121] = 1, rr[5123] = 2, rr[5125] = 4, rr[5126] = 4;
+          function nr(Me) {
+            return ke[Object.prototype.toString.call(Me)] | 0;
+          }
+          function Er(Me, bt) {
+            for (var zt = 0; zt < bt.length; ++zt) Me[zt] = bt[zt];
+          }
+          function Xr(Me, bt, zt, Rr, jr, Nr, Gr) {
+            for (var mi = 0, Ui = 0; Ui < zt; ++Ui) for (var qi = 0; qi < Rr; ++qi) Me[mi++] = bt[jr * Ui + Nr * qi + Gr];
+          }
+          function ri(Me, bt, zt, Rr) {
+            var jr = 0, Nr = {};
+            function Gr(Mr) {
+              this.id = jr++, this.buffer = Me.createBuffer(), this.type = Mr, this.usage = ra, this.byteLength = 0, this.dimension = 1, this.dtype = Ut, this.persistentData = null, zt.profile && (this.stats = { size: 0 });
+            }
+            Gr.prototype.bind = function() {
+              Me.bindBuffer(this.type, this.buffer);
+            }, Gr.prototype.destroy = function() {
+              en(this);
+            };
+            var mi = [];
+            function Ui(Mr, Yr) {
+              var xi = mi.pop();
+              return xi || (xi = new Gr(Mr)), xi.bind(), Hn(xi, Yr, la, 0, 1, false), xi;
+            }
+            function qi(Mr) {
+              mi.push(Mr);
+            }
+            function Ei(Mr, Yr, xi) {
+              Mr.byteLength = Yr.byteLength, Me.bufferData(Mr.type, Yr, xi);
+            }
+            function Hn(Mr, Yr, xi, Ri, ci, an) {
+              var Zi;
+              if (Mr.usage = xi, Array.isArray(Yr)) {
+                if (Mr.dtype = Ri || wt, Yr.length > 0) {
+                  var Bn;
+                  if (Array.isArray(Yr[0])) {
+                    Zi = Fn(Yr);
+                    for (var hi = 1, li = 1; li < Zi.length; ++li) hi *= Zi[li];
+                    Mr.dimension = hi, Bn = qn(Yr, Zi, Mr.dtype), Ei(Mr, Bn, xi), an ? Mr.persistentData = Bn : H.freeType(Bn);
+                  } else if (typeof Yr[0] == "number") {
+                    Mr.dimension = ci;
+                    var mn = H.allocType(Mr.dtype, Yr.length);
+                    Er(mn, Yr), Ei(Mr, mn, xi), an ? Mr.persistentData = mn : H.freeType(mn);
+                  } else Br(Yr[0]) && (Mr.dimension = Yr[0].length, Mr.dtype = Ri || nr(Yr[0]) || wt, Bn = qn(Yr, [Yr.length, Yr[0].length], Mr.dtype), Ei(Mr, Bn, xi), an ? Mr.persistentData = Bn : H.freeType(Bn));
+                }
+              } else if (Br(Yr)) Mr.dtype = Ri || nr(Yr), Mr.dimension = ci, Ei(Mr, Yr, xi), an && (Mr.persistentData = new Uint8Array(new Uint8Array(Yr.buffer)));
+              else if (Vr(Yr)) {
+                Zi = Yr.shape;
+                var Ji = Yr.stride, Vi = Yr.offset, Ni = 0, pn = 0, Vn = 0, na = 0;
+                Zi.length === 1 ? (Ni = Zi[0], pn = 1, Vn = Ji[0], na = 0) : Zi.length === 2 && (Ni = Zi[0], pn = Zi[1], Vn = Ji[0], na = Ji[1]), Mr.dtype = Ri || nr(Yr.data) || wt, Mr.dimension = pn;
+                var Ki = H.allocType(Mr.dtype, Ni * pn);
+                Xr(Ki, Yr.data, Ni, pn, Vn, na, Vi), Ei(Mr, Ki, xi), an ? Mr.persistentData = Ki : H.freeType(Ki);
+              } else Yr instanceof ArrayBuffer && (Mr.dtype = Ut, Mr.dimension = ci, Ei(Mr, Yr, xi), an && (Mr.persistentData = new Uint8Array(new Uint8Array(Yr))));
+            }
+            function en(Mr) {
+              bt.bufferCount--, Rr(Mr);
+              var Yr = Mr.buffer;
+              Me.deleteBuffer(Yr), Mr.buffer = null, delete Nr[Mr.id];
+            }
+            function Wi(Mr, Yr, xi, Ri) {
+              bt.bufferCount++;
+              var ci = new Gr(Yr);
+              Nr[ci.id] = ci;
+              function an(hi) {
+                var li = ra, mn = null, Ji = 0, Vi = 0, Ni = 1;
+                return Array.isArray(hi) || Br(hi) || Vr(hi) || hi instanceof ArrayBuffer ? mn = hi : typeof hi == "number" ? Ji = hi | 0 : hi && ("data" in hi && (mn = hi.data), "usage" in hi && (li = On[hi.usage]), "type" in hi && (Vi = ji[hi.type]), "dimension" in hi && (Ni = hi.dimension | 0), "length" in hi && (Ji = hi.length | 0)), ci.bind(), mn ? Hn(ci, mn, li, Vi, Ni, Ri) : (Ji && Me.bufferData(ci.type, Ji, li), ci.dtype = Vi || Ut, ci.usage = li, ci.dimension = Ni, ci.byteLength = Ji), zt.profile && (ci.stats.size = ci.byteLength * rr[ci.dtype]), an;
+              }
+              function Zi(hi, li) {
+                Me.bufferSubData(ci.type, li, hi);
+              }
+              function Bn(hi, li) {
+                var mn = (li || 0) | 0, Ji;
+                if (ci.bind(), Br(hi) || hi instanceof ArrayBuffer) Zi(hi, mn);
+                else if (Array.isArray(hi)) {
+                  if (hi.length > 0) {
+                    if (typeof hi[0] == "number") {
+                      var Vi = H.allocType(ci.dtype, hi.length);
+                      Er(Vi, hi), Zi(Vi, mn), H.freeType(Vi);
+                    } else if (Array.isArray(hi[0]) || Br(hi[0])) {
+                      Ji = Fn(hi);
+                      var Ni = qn(hi, Ji, ci.dtype);
+                      Zi(Ni, mn), H.freeType(Ni);
+                    }
+                  }
+                } else if (Vr(hi)) {
+                  Ji = hi.shape;
+                  var pn = hi.stride, Vn = 0, na = 0, Ki = 0, kn = 0;
+                  Ji.length === 1 ? (Vn = Ji[0], na = 1, Ki = pn[0], kn = 0) : Ji.length === 2 && (Vn = Ji[0], na = Ji[1], Ki = pn[0], kn = pn[1]);
+                  var ta = Array.isArray(hi.data) ? ci.dtype : nr(hi.data), oa = H.allocType(ta, Vn * na);
+                  Xr(oa, hi.data, Vn, na, Ki, kn, hi.offset), Zi(oa, mn), H.freeType(oa);
+                }
+                return an;
+              }
+              return xi || an(Mr), an._reglType = "buffer", an._buffer = ci, an.subdata = Bn, zt.profile && (an.stats = ci.stats), an.destroy = function() {
+                en(ci);
+              }, an;
+            }
+            function si() {
+              dt(Nr).forEach(function(Mr) {
+                Mr.buffer = Me.createBuffer(), Me.bindBuffer(Mr.type, Mr.buffer), Me.bufferData(Mr.type, Mr.persistentData || Mr.byteLength, Mr.usage);
+              });
+            }
+            return zt.profile && (bt.getTotalBufferSize = function() {
+              var Mr = 0;
+              return Object.keys(Nr).forEach(function(Yr) {
+                Mr += Nr[Yr].stats.size;
+              }), Mr;
+            }), { create: Wi, createStream: Ui, destroyStream: qi, clear: function() {
+              dt(Nr).forEach(en), mi.forEach(en);
+            }, getBuffer: function(Mr) {
+              return Mr && Mr._buffer instanceof Gr ? Mr._buffer : null;
+            }, restore: si, _initBuffer: Hn };
+          }
+          var Qr = 0, Oi = 0, $i = 1, tn = 1, fn = 4, yn = 4, Sn = { points: Qr, point: Oi, lines: $i, line: tn, triangles: fn, triangle: yn, "line loop": 2, "line strip": 3, "triangle strip": 5, "triangle fan": 6 }, Ba = 0, ua = 1, ma = 4, Wa = 5120, Fa = 5121, Xo = 5122, da = 5123, Wn = 5124, Ha = 5125, vo = 34963, jn = 35040, Mt = 35044;
+          function kr(Me, bt, zt, Rr) {
+            var jr = {}, Nr = 0, Gr = { uint8: Fa, uint16: da };
+            bt.oes_element_index_uint && (Gr.uint32 = Ha);
+            function mi(si) {
+              this.id = Nr++, jr[this.id] = this, this.buffer = si, this.primType = ma, this.vertCount = 0, this.type = 0;
+            }
+            mi.prototype.bind = function() {
+              this.buffer.bind();
+            };
+            var Ui = [];
+            function qi(si) {
+              var Mr = Ui.pop();
+              return Mr || (Mr = new mi(zt.create(null, vo, true, false)._buffer)), Hn(Mr, si, jn, -1, -1, 0, 0), Mr;
+            }
+            function Ei(si) {
+              Ui.push(si);
+            }
+            function Hn(si, Mr, Yr, xi, Ri, ci, an) {
+              si.buffer.bind();
+              var Zi;
+              if (Mr) {
+                var Bn = an;
+                !an && (!Br(Mr) || Vr(Mr) && !Br(Mr.data)) && (Bn = bt.oes_element_index_uint ? Ha : da), zt._initBuffer(si.buffer, Mr, Yr, Bn, 3);
+              } else Me.bufferData(vo, ci, Yr), si.buffer.dtype = Zi || Fa, si.buffer.usage = Yr, si.buffer.dimension = 3, si.buffer.byteLength = ci;
+              if (Zi = an, !an) {
+                switch (si.buffer.dtype) {
+                  case Fa:
+                  case Wa:
+                    Zi = Fa;
+                    break;
+                  case da:
+                  case Xo:
+                    Zi = da;
+                    break;
+                  case Ha:
+                  case Wn:
+                    Zi = Ha;
+                    break;
+                }
+                si.buffer.dtype = Zi;
+              }
+              si.type = Zi;
+              var hi = Ri;
+              hi < 0 && (hi = si.buffer.byteLength, Zi === da ? hi >>= 1 : Zi === Ha && (hi >>= 2)), si.vertCount = hi;
+              var li = xi;
+              if (xi < 0) {
+                li = ma;
+                var mn = si.buffer.dimension;
+                mn === 1 && (li = Ba), mn === 2 && (li = ua), mn === 3 && (li = ma);
+              }
+              si.primType = li;
+            }
+            function en(si) {
+              Rr.elementsCount--, delete jr[si.id], si.buffer.destroy(), si.buffer = null;
+            }
+            function Wi(si, Mr) {
+              var Yr = zt.create(null, vo, true), xi = new mi(Yr._buffer);
+              Rr.elementsCount++;
+              function Ri(ci) {
+                if (!ci) Yr(), xi.primType = ma, xi.vertCount = 0, xi.type = Fa;
+                else if (typeof ci == "number") Yr(ci), xi.primType = ma, xi.vertCount = ci | 0, xi.type = Fa;
+                else {
+                  var an = null, Zi = Mt, Bn = -1, hi = -1, li = 0, mn = 0;
+                  Array.isArray(ci) || Br(ci) || Vr(ci) ? an = ci : ("data" in ci && (an = ci.data), "usage" in ci && (Zi = On[ci.usage]), "primitive" in ci && (Bn = Sn[ci.primitive]), "count" in ci && (hi = ci.count | 0), "type" in ci && (mn = Gr[ci.type]), "length" in ci ? li = ci.length | 0 : (li = hi, mn === da || mn === Xo ? li *= 2 : (mn === Ha || mn === Wn) && (li *= 4))), Hn(xi, an, Zi, Bn, hi, li, mn);
+                }
+                return Ri;
+              }
+              return Ri(si), Ri._reglType = "elements", Ri._elements = xi, Ri.subdata = function(ci, an) {
+                return Yr.subdata(ci, an), Ri;
+              }, Ri.destroy = function() {
+                en(xi);
+              }, Ri;
+            }
+            return { create: Wi, createStream: qi, destroyStream: Ei, getElements: function(si) {
+              return typeof si == "function" && si._elements instanceof mi ? si._elements : null;
+            }, clear: function() {
+              dt(jr).forEach(en);
+            } };
+          }
+          var Jr = new Float32Array(1), vi = new Uint32Array(Jr.buffer), hn = 5123;
+          function An(Me) {
+            for (var bt = H.allocType(hn, Me.length), zt = 0; zt < Me.length; ++zt) if (isNaN(Me[zt])) bt[zt] = 65535;
+            else if (Me[zt] === 1 / 0) bt[zt] = 31744;
+            else if (Me[zt] === -1 / 0) bt[zt] = 64512;
+            else {
+              Jr[0] = Me[zt];
+              var Rr = vi[0], jr = Rr >>> 31 << 15, Nr = (Rr << 1 >>> 24) - 127, Gr = Rr >> 13 & 1023;
+              if (Nr < -24) bt[zt] = jr;
+              else if (Nr < -14) {
+                var mi = -14 - Nr;
+                bt[zt] = jr + (Gr + 1024 >> mi);
+              } else Nr > 15 ? bt[zt] = jr + 31744 : bt[zt] = jr + (Nr + 15 << 10) + Gr;
+            }
+            return bt;
+          }
+          function Mn(Me) {
+            return Array.isArray(Me) || Br(Me);
+          }
+          var Li = 34467, _n = 3553, ya = 34067, $n = 34069, Ma = 6408, _o = 6406, No = 6407, po = 6409, Lo = 6410, ko = 32854, Ds = 32855, Fs = 36194, ll = 32819, ul = 32820, zl = 33635, us = 34042, il = 6402, As = 34041, cl = 35904, Ks = 35906, zs = 36193, Io = 33776, ls = 33777, Yl = 33778, Su = 33779, nc = 35986, bs = 35987, Rn = 34798, _a = 35840, Vu = 35841, Ol = 35842, xo = 35843, Kl = 36196, Ns = 5121, Hl = 5123, ac = 5125, aa = 5126, Oo = 10242, qo = 10243, ql = 10497, Pc = 33071, Do = 33648, rf = 10240, Vf = 10241, pl = 9728, Zc = 9729, Jl = 9984, Os = 9985, yu = 9986, oc = 9987, Cf = 33170, sc = 4352, jh = 4353, Lf = 4354, cs = 34046, nf = 3317, Gf = 37440, $l = 37441, fl = 37443, lc = 37444, Fu = 33984, Es = [Jl, yu, Os, oc], Hs = [0, po, Lo, No, Ma], Go = {};
+          Go[po] = Go[_o] = Go[il] = 1, Go[As] = Go[Lo] = 2, Go[No] = Go[cl] = 3, Go[Ma] = Go[Ks] = 4;
+          function ps(Me) {
+            return "[object " + Me + "]";
+          }
+          var uc = ps("HTMLCanvasElement"), xl = ps("OffscreenCanvas"), Gu = ps("CanvasRenderingContext2D"), qs = ps("ImageBitmap"), od = ps("HTMLImageElement"), Po = ps("HTMLVideoElement"), sd = Object.keys(ke).concat([uc, xl, Gu, qs, od, Po]), Ko = [];
+          Ko[Ns] = 1, Ko[aa] = 4, Ko[zs] = 2, Ko[Hl] = 2, Ko[ac] = 4;
+          var Pa = [];
+          Pa[ko] = 2, Pa[Ds] = 2, Pa[Fs] = 2, Pa[As] = 4, Pa[Io] = 0.5, Pa[ls] = 0.5, Pa[Yl] = 1, Pa[Su] = 1, Pa[nc] = 0.5, Pa[bs] = 1, Pa[Rn] = 1, Pa[_a] = 0.5, Pa[Vu] = 0.25, Pa[Ol] = 0.5, Pa[xo] = 0.25, Pa[Kl] = 0.5;
+          function af(Me) {
+            return Array.isArray(Me) && (Me.length === 0 || typeof Me[0] == "number");
+          }
+          function Hu(Me) {
+            if (!Array.isArray(Me)) return false;
+            var bt = Me.length;
+            return !(bt === 0 || !Mn(Me[0]));
+          }
+          function bl(Me) {
+            return Object.prototype.toString.call(Me);
+          }
+          function Hf(Me) {
+            return bl(Me) === uc;
+          }
+          function Ic(Me) {
+            return bl(Me) === xl;
+          }
+          function yf(Me) {
+            return bl(Me) === Gu;
+          }
+          function Bl(Me) {
+            return bl(Me) === qs;
+          }
+          function Ah(Me) {
+            return bl(Me) === od;
+          }
+          function Qf(Me) {
+            return bl(Me) === Po;
+          }
+          function _f(Me) {
+            if (!Me) return false;
+            var bt = bl(Me);
+            return sd.indexOf(bt) >= 0 ? true : af(Me) || Hu(Me) || Vr(Me);
+          }
+          function Yc(Me) {
+            return ke[Object.prototype.toString.call(Me)] | 0;
+          }
+          function eh(Me, bt) {
+            var zt = bt.length;
+            switch (Me.type) {
+              case Ns:
+              case Hl:
+              case ac:
+              case aa:
+                var Rr = H.allocType(Me.type, zt);
+                Rr.set(bt), Me.data = Rr;
+                break;
+              case zs:
+                Me.data = An(bt);
+                break;
+            }
+          }
+          function th(Me, bt) {
+            return H.allocType(Me.type === zs ? aa : Me.type, bt);
+          }
+          function ju(Me, bt) {
+            Me.type === zs ? (Me.data = An(bt), H.freeType(bt)) : Me.data = bt;
+          }
+          function jf(Me, bt, zt, Rr, jr, Nr) {
+            for (var Gr = Me.width, mi = Me.height, Ui = Me.channels, qi = Gr * mi * Ui, Ei = th(Me, qi), Hn = 0, en = 0; en < mi; ++en) for (var Wi = 0; Wi < Gr; ++Wi) for (var si = 0; si < Ui; ++si) Ei[Hn++] = bt[zt * Wi + Rr * en + jr * si + Nr];
+            ju(Me, Ei);
+          }
+          function cc(Me, bt, zt, Rr, jr, Nr) {
+            var Gr;
+            if (typeof Pa[Me] != "undefined" ? Gr = Pa[Me] : Gr = Go[Me] * Ko[bt], Nr && (Gr *= 6), jr) {
+              for (var mi = 0, Ui = zt; Ui >= 1; ) mi += Gr * Ui * Ui, Ui /= 2;
+              return mi;
+            } else return Gr * zt * Rr;
+          }
+          function of(Me, bt, zt, Rr, jr, Nr, Gr) {
+            var mi = { "don't care": sc, "dont care": sc, nice: Lf, fast: jh }, Ui = { repeat: ql, clamp: Pc, mirror: Do }, qi = { nearest: pl, linear: Zc }, Ei = e({ mipmap: oc, "nearest mipmap nearest": Jl, "linear mipmap nearest": Os, "nearest mipmap linear": yu, "linear mipmap linear": oc }, qi), Hn = { none: 0, browser: lc }, en = { uint8: Ns, rgba4: ll, rgb565: zl, "rgb5 a1": ul }, Wi = { alpha: _o, luminance: po, "luminance alpha": Lo, rgb: No, rgba: Ma, rgba4: ko, "rgb5 a1": Ds, rgb565: Fs }, si = {};
+            bt.ext_srgb && (Wi.srgb = cl, Wi.srgba = Ks), bt.oes_texture_float && (en.float32 = en.float = aa), bt.oes_texture_half_float && (en.float16 = en["half float"] = zs), bt.webgl_depth_texture && (e(Wi, { depth: il, "depth stencil": As }), e(en, { uint16: Hl, uint32: ac, "depth stencil": us })), bt.webgl_compressed_texture_s3tc && e(si, { "rgb s3tc dxt1": Io, "rgba s3tc dxt1": ls, "rgba s3tc dxt3": Yl, "rgba s3tc dxt5": Su }), bt.webgl_compressed_texture_atc && e(si, { "rgb atc": nc, "rgba atc explicit alpha": bs, "rgba atc interpolated alpha": Rn }), bt.webgl_compressed_texture_pvrtc && e(si, { "rgb pvrtc 4bppv1": _a, "rgb pvrtc 2bppv1": Vu, "rgba pvrtc 4bppv1": Ol, "rgba pvrtc 2bppv1": xo }), bt.webgl_compressed_texture_etc1 && (si["rgb etc1"] = Kl);
+            var Mr = Array.prototype.slice.call(Me.getParameter(Li));
+            Object.keys(si).forEach(function(ne) {
+              var we = si[ne];
+              Mr.indexOf(we) >= 0 && (Wi[ne] = we);
+            });
+            var Yr = Object.keys(Wi);
+            zt.textureFormats = Yr;
+            var xi = [];
+            Object.keys(Wi).forEach(function(ne) {
+              var we = Wi[ne];
+              xi[we] = ne;
+            });
+            var Ri = [];
+            Object.keys(en).forEach(function(ne) {
+              var we = en[ne];
+              Ri[we] = ne;
+            });
+            var ci = [];
+            Object.keys(qi).forEach(function(ne) {
+              var we = qi[ne];
+              ci[we] = ne;
+            });
+            var an = [];
+            Object.keys(Ei).forEach(function(ne) {
+              var we = Ei[ne];
+              an[we] = ne;
+            });
+            var Zi = [];
+            Object.keys(Ui).forEach(function(ne) {
+              var we = Ui[ne];
+              Zi[we] = ne;
+            });
+            var Bn = Yr.reduce(function(ne, we) {
+              var Ue = Wi[we];
+              return Ue === po || Ue === _o || Ue === po || Ue === Lo || Ue === il || Ue === As || bt.ext_srgb && (Ue === cl || Ue === Ks) ? ne[Ue] = Ue : Ue === Ds || we.indexOf("rgba") >= 0 ? ne[Ue] = Ma : ne[Ue] = No, ne;
+            }, {});
+            function hi() {
+              this.internalformat = Ma, this.format = Ma, this.type = Ns, this.compressed = false, this.premultiplyAlpha = false, this.flipY = false, this.unpackAlignment = 1, this.colorSpace = lc, this.width = 0, this.height = 0, this.channels = 0;
+            }
+            function li(ne, we) {
+              ne.internalformat = we.internalformat, ne.format = we.format, ne.type = we.type, ne.compressed = we.compressed, ne.premultiplyAlpha = we.premultiplyAlpha, ne.flipY = we.flipY, ne.unpackAlignment = we.unpackAlignment, ne.colorSpace = we.colorSpace, ne.width = we.width, ne.height = we.height, ne.channels = we.channels;
+            }
+            function mn(ne, we) {
+              if (!(typeof we != "object" || !we)) {
+                if ("premultiplyAlpha" in we && (ne.premultiplyAlpha = we.premultiplyAlpha), "flipY" in we && (ne.flipY = we.flipY), "alignment" in we && (ne.unpackAlignment = we.alignment), "colorSpace" in we && (ne.colorSpace = Hn[we.colorSpace]), "type" in we) {
+                  var Ue = we.type;
+                  ne.type = en[Ue];
+                }
+                var ft = ne.width, Zt = ne.height, hr = ne.channels, qt = false;
+                "shape" in we ? (ft = we.shape[0], Zt = we.shape[1], we.shape.length === 3 && (hr = we.shape[2], qt = true)) : ("radius" in we && (ft = Zt = we.radius), "width" in we && (ft = we.width), "height" in we && (Zt = we.height), "channels" in we && (hr = we.channels, qt = true)), ne.width = ft | 0, ne.height = Zt | 0, ne.channels = hr | 0;
+                var Ve = false;
+                if ("format" in we) {
+                  var Qe = we.format, at = ne.internalformat = Wi[Qe];
+                  ne.format = Bn[at], Qe in en && ("type" in we || (ne.type = en[Qe])), Qe in si && (ne.compressed = true), Ve = true;
+                }
+                !qt && Ve ? ne.channels = Go[ne.format] : qt && !Ve && ne.channels !== Hs[ne.format] && (ne.format = ne.internalformat = Hs[ne.channels]);
+              }
+            }
+            function Ji(ne) {
+              Me.pixelStorei(Gf, ne.flipY), Me.pixelStorei($l, ne.premultiplyAlpha), Me.pixelStorei(fl, ne.colorSpace), Me.pixelStorei(nf, ne.unpackAlignment);
+            }
+            function Vi() {
+              hi.call(this), this.xOffset = 0, this.yOffset = 0, this.data = null, this.needsFree = false, this.element = null, this.needsCopy = false;
+            }
+            function Ni(ne, we) {
+              var Ue = null;
+              if (_f(we) ? Ue = we : we && (mn(ne, we), "x" in we && (ne.xOffset = we.x | 0), "y" in we && (ne.yOffset = we.y | 0), _f(we.data) && (Ue = we.data)), we.copy) {
+                var ft = jr.viewportWidth, Zt = jr.viewportHeight;
+                ne.width = ne.width || ft - ne.xOffset, ne.height = ne.height || Zt - ne.yOffset, ne.needsCopy = true;
+              } else if (!Ue) ne.width = ne.width || 1, ne.height = ne.height || 1, ne.channels = ne.channels || 4;
+              else if (Br(Ue)) ne.channels = ne.channels || 4, ne.data = Ue, !("type" in we) && ne.type === Ns && (ne.type = Yc(Ue));
+              else if (af(Ue)) ne.channels = ne.channels || 4, eh(ne, Ue), ne.alignment = 1, ne.needsFree = true;
+              else if (Vr(Ue)) {
+                var hr = Ue.data;
+                !Array.isArray(hr) && ne.type === Ns && (ne.type = Yc(hr));
+                var qt = Ue.shape, Ve = Ue.stride, Qe, at, Ct, Ot, Rt, Bt;
+                qt.length === 3 ? (Ct = qt[2], Bt = Ve[2]) : (Ct = 1, Bt = 1), Qe = qt[0], at = qt[1], Ot = Ve[0], Rt = Ve[1], ne.alignment = 1, ne.width = Qe, ne.height = at, ne.channels = Ct, ne.format = ne.internalformat = Hs[Ct], ne.needsFree = true, jf(ne, hr, Ot, Rt, Bt, Ue.offset);
+              } else if (Hf(Ue) || Ic(Ue) || yf(Ue)) Hf(Ue) || Ic(Ue) ? ne.element = Ue : ne.element = Ue.canvas, ne.width = ne.element.width, ne.height = ne.element.height, ne.channels = 4;
+              else if (Bl(Ue)) ne.element = Ue, ne.width = Ue.width, ne.height = Ue.height, ne.channels = 4;
+              else if (Ah(Ue)) ne.element = Ue, ne.width = Ue.naturalWidth, ne.height = Ue.naturalHeight, ne.channels = 4;
+              else if (Qf(Ue)) ne.element = Ue, ne.width = Ue.videoWidth, ne.height = Ue.videoHeight, ne.channels = 4;
+              else if (Hu(Ue)) {
+                var Dt = ne.width || Ue[0].length, yt = ne.height || Ue.length, Pt = ne.channels;
+                Mn(Ue[0][0]) ? Pt = Pt || Ue[0][0].length : Pt = Pt || 1;
+                for (var ht = Ge.shape(Ue), ur = 1, br = 0; br < ht.length; ++br) ur *= ht[br];
+                var Ur = th(ne, ur);
+                Ge.flatten(Ue, ht, "", Ur), ju(ne, Ur), ne.alignment = 1, ne.width = Dt, ne.height = yt, ne.channels = Pt, ne.format = ne.internalformat = Hs[Pt], ne.needsFree = true;
+              }
+              ne.type === aa || ne.type;
+            }
+            function pn(ne, we, Ue) {
+              var ft = ne.element, Zt = ne.data, hr = ne.internalformat, qt = ne.format, Ve = ne.type, Qe = ne.width, at = ne.height;
+              Ji(ne), ft ? Me.texImage2D(we, Ue, qt, qt, Ve, ft) : ne.compressed ? Me.compressedTexImage2D(we, Ue, hr, Qe, at, 0, Zt) : ne.needsCopy ? (Rr(), Me.copyTexImage2D(we, Ue, qt, ne.xOffset, ne.yOffset, Qe, at, 0)) : Me.texImage2D(we, Ue, qt, Qe, at, 0, qt, Ve, Zt || null);
+            }
+            function Vn(ne, we, Ue, ft, Zt) {
+              var hr = ne.element, qt = ne.data, Ve = ne.internalformat, Qe = ne.format, at = ne.type, Ct = ne.width, Ot = ne.height;
+              Ji(ne), hr ? Me.texSubImage2D(we, Zt, Ue, ft, Qe, at, hr) : ne.compressed ? Me.compressedTexSubImage2D(we, Zt, Ue, ft, Ve, Ct, Ot, qt) : ne.needsCopy ? (Rr(), Me.copyTexSubImage2D(we, Zt, Ue, ft, ne.xOffset, ne.yOffset, Ct, Ot)) : Me.texSubImage2D(we, Zt, Ue, ft, Ct, Ot, Qe, at, qt);
+            }
+            var na = [];
+            function Ki() {
+              return na.pop() || new Vi();
+            }
+            function kn(ne) {
+              ne.needsFree && H.freeType(ne.data), Vi.call(ne), na.push(ne);
+            }
+            function ta() {
+              hi.call(this), this.genMipmaps = false, this.mipmapHint = sc, this.mipmask = 0, this.images = Array(16);
+            }
+            function oa(ne, we, Ue) {
+              var ft = ne.images[0] = Ki();
+              ne.mipmask = 1, ft.width = ne.width = we, ft.height = ne.height = Ue, ft.channels = ne.channels = 4;
+            }
+            function ba(ne, we) {
+              var Ue = null;
+              if (_f(we)) Ue = ne.images[0] = Ki(), li(Ue, ne), Ni(Ue, we), ne.mipmask = 1;
+              else if (mn(ne, we), Array.isArray(we.mipmap)) for (var ft = we.mipmap, Zt = 0; Zt < ft.length; ++Zt) Ue = ne.images[Zt] = Ki(), li(Ue, ne), Ue.width >>= Zt, Ue.height >>= Zt, Ni(Ue, ft[Zt]), ne.mipmask |= 1 << Zt;
+              else Ue = ne.images[0] = Ki(), li(Ue, ne), Ni(Ue, we), ne.mipmask = 1;
+              li(ne, ne.images[0]), ne.compressed && (ne.internalformat === Io || ne.internalformat === ls || ne.internalformat === Yl || ne.internalformat);
+            }
+            function is(ne, we) {
+              for (var Ue = ne.images, ft = 0; ft < Ue.length; ++ft) {
+                if (!Ue[ft]) return;
+                pn(Ue[ft], we, ft);
+              }
+            }
+            var Zs = [];
+            function Va() {
+              var ne = Zs.pop() || new ta();
+              hi.call(ne), ne.mipmask = 0;
+              for (var we = 0; we < 16; ++we) ne.images[we] = null;
+              return ne;
+            }
+            function Ml(ne) {
+              for (var we = ne.images, Ue = 0; Ue < we.length; ++Ue) we[Ue] && kn(we[Ue]), we[Ue] = null;
+              Zs.push(ne);
+            }
+            function zo() {
+              this.minFilter = pl, this.magFilter = pl, this.wrapS = Pc, this.wrapT = Pc, this.anisotropic = 1, this.genMipmaps = false, this.mipmapHint = sc;
+            }
+            function Qs(ne, we) {
+              if ("min" in we) {
+                var Ue = we.min;
+                ne.minFilter = Ei[Ue], Es.indexOf(ne.minFilter) >= 0 && !("faces" in we) && (ne.genMipmaps = true);
+              }
+              if ("mag" in we) {
+                var ft = we.mag;
+                ne.magFilter = qi[ft];
+              }
+              var Zt = ne.wrapS, hr = ne.wrapT;
+              if ("wrap" in we) {
+                var qt = we.wrap;
+                typeof qt == "string" ? Zt = hr = Ui[qt] : Array.isArray(qt) && (Zt = Ui[qt[0]], hr = Ui[qt[1]]);
+              } else {
+                if ("wrapS" in we) {
+                  var Ve = we.wrapS;
+                  Zt = Ui[Ve];
+                }
+                if ("wrapT" in we) {
+                  var Qe = we.wrapT;
+                  hr = Ui[Qe];
+                }
+              }
+              if (ne.wrapS = Zt, ne.wrapT = hr, "anisotropic" in we) {
+                we.anisotropic;
+                ne.anisotropic = we.anisotropic;
+              }
+              if ("mipmap" in we) {
+                var Ct = false;
+                switch (typeof we.mipmap) {
+                  case "string":
+                    ne.mipmapHint = mi[we.mipmap], ne.genMipmaps = true, Ct = true;
+                    break;
+                  case "boolean":
+                    Ct = ne.genMipmaps = we.mipmap;
+                    break;
+                  case "object":
+                    ne.genMipmaps = false, Ct = true;
+                    break;
+                }
+                Ct && !("min" in we) && (ne.minFilter = Jl);
+              }
+            }
+            function al(ne, we) {
+              Me.texParameteri(we, Vf, ne.minFilter), Me.texParameteri(we, rf, ne.magFilter), Me.texParameteri(we, Oo, ne.wrapS), Me.texParameteri(we, qo, ne.wrapT), bt.ext_texture_filter_anisotropic && Me.texParameteri(we, cs, ne.anisotropic), ne.genMipmaps && (Me.hint(Cf, ne.mipmapHint), Me.generateMipmap(we));
+            }
+            var Vl = 0, ss = {}, Vs = zt.maxTextureUnits, Ys = Array(Vs).map(function() {
+              return null;
+            });
+            function wa(ne) {
+              hi.call(this), this.mipmask = 0, this.internalformat = Ma, this.id = Vl++, this.refCount = 1, this.target = ne, this.texture = Me.createTexture(), this.unit = -1, this.bindCount = 0, this.texInfo = new zo(), Gr.profile && (this.stats = { size: 0 });
+            }
+            function ol(ne) {
+              Me.activeTexture(Fu), Me.bindTexture(ne.target, ne.texture);
+            }
+            function io() {
+              var ne = Ys[0];
+              ne ? Me.bindTexture(ne.target, ne.texture) : Me.bindTexture(_n, null);
+            }
+            function Y(ne) {
+              var we = ne.texture, Ue = ne.unit, ft = ne.target;
+              Ue >= 0 && (Me.activeTexture(Fu + Ue), Me.bindTexture(ft, null), Ys[Ue] = null), Me.deleteTexture(we), ne.texture = null, ne.params = null, ne.pixels = null, ne.refCount = 0, delete ss[ne.id], Nr.textureCount--;
+            }
+            e(wa.prototype, { bind: function() {
+              var ne = this;
+              ne.bindCount += 1;
+              var we = ne.unit;
+              if (we < 0) {
+                for (var Ue = 0; Ue < Vs; ++Ue) {
+                  var ft = Ys[Ue];
+                  if (ft) {
+                    if (ft.bindCount > 0) continue;
+                    ft.unit = -1;
+                  }
+                  Ys[Ue] = ne, we = Ue;
+                  break;
+                }
+                Gr.profile && Nr.maxTextureUnits < we + 1 && (Nr.maxTextureUnits = we + 1), ne.unit = we, Me.activeTexture(Fu + we), Me.bindTexture(ne.target, ne.texture);
+              }
+              return we;
+            }, unbind: function() {
+              this.bindCount -= 1;
+            }, decRef: function() {
+              --this.refCount <= 0 && Y(this);
+            } });
+            function D(ne, we) {
+              var Ue = new wa(_n);
+              ss[Ue.id] = Ue, Nr.textureCount++;
+              function ft(qt, Ve) {
+                var Qe = Ue.texInfo;
+                zo.call(Qe);
+                var at = Va();
+                return typeof qt == "number" ? typeof Ve == "number" ? oa(at, qt | 0, Ve | 0) : oa(at, qt | 0, qt | 0) : qt ? (Qs(Qe, qt), ba(at, qt)) : oa(at, 1, 1), Qe.genMipmaps && (at.mipmask = (at.width << 1) - 1), Ue.mipmask = at.mipmask, li(Ue, at), Ue.internalformat = at.internalformat, ft.width = at.width, ft.height = at.height, ol(Ue), is(at, _n), al(Qe, _n), io(), Ml(at), Gr.profile && (Ue.stats.size = cc(Ue.internalformat, Ue.type, at.width, at.height, Qe.genMipmaps, false)), ft.format = xi[Ue.internalformat], ft.type = Ri[Ue.type], ft.mag = ci[Qe.magFilter], ft.min = an[Qe.minFilter], ft.wrapS = Zi[Qe.wrapS], ft.wrapT = Zi[Qe.wrapT], ft;
+              }
+              function Zt(qt, Ve, Qe, at) {
+                var Ct = Ve | 0, Ot = Qe | 0, Rt = at | 0, Bt = Ki();
+                return li(Bt, Ue), Bt.width = 0, Bt.height = 0, Ni(Bt, qt), Bt.width = Bt.width || (Ue.width >> Rt) - Ct, Bt.height = Bt.height || (Ue.height >> Rt) - Ot, ol(Ue), Vn(Bt, _n, Ct, Ot, Rt), io(), kn(Bt), ft;
+              }
+              function hr(qt, Ve) {
+                var Qe = qt | 0, at = Ve | 0 || Qe;
+                if (Qe === Ue.width && at === Ue.height) return ft;
+                ft.width = Ue.width = Qe, ft.height = Ue.height = at, ol(Ue);
+                for (var Ct = 0; Ue.mipmask >> Ct; ++Ct) {
+                  var Ot = Qe >> Ct, Rt = at >> Ct;
+                  if (!Ot || !Rt) break;
+                  Me.texImage2D(_n, Ct, Ue.format, Ot, Rt, 0, Ue.format, Ue.type, null);
+                }
+                return io(), Gr.profile && (Ue.stats.size = cc(Ue.internalformat, Ue.type, Qe, at, false, false)), ft;
+              }
+              return ft(ne, we), ft.subimage = Zt, ft.resize = hr, ft._reglType = "texture2d", ft._texture = Ue, Gr.profile && (ft.stats = Ue.stats), ft.destroy = function() {
+                Ue.decRef();
+              }, ft;
+            }
+            function J(ne, we, Ue, ft, Zt, hr) {
+              var qt = new wa(ya);
+              ss[qt.id] = qt, Nr.cubeCount++;
+              var Ve = new Array(6);
+              function Qe(Ot, Rt, Bt, Dt, yt, Pt) {
+                var ht, ur = qt.texInfo;
+                for (zo.call(ur), ht = 0; ht < 6; ++ht) Ve[ht] = Va();
+                if (typeof Ot == "number" || !Ot) {
+                  var br = Ot | 0 || 1;
+                  for (ht = 0; ht < 6; ++ht) oa(Ve[ht], br, br);
+                } else if (typeof Ot == "object") if (Rt) ba(Ve[0], Ot), ba(Ve[1], Rt), ba(Ve[2], Bt), ba(Ve[3], Dt), ba(Ve[4], yt), ba(Ve[5], Pt);
+                else if (Qs(ur, Ot), mn(qt, Ot), "faces" in Ot) {
+                  var Ur = Ot.faces;
+                  for (ht = 0; ht < 6; ++ht) li(Ve[ht], qt), ba(Ve[ht], Ur[ht]);
+                } else for (ht = 0; ht < 6; ++ht) ba(Ve[ht], Ot);
+                for (li(qt, Ve[0]), ur.genMipmaps ? qt.mipmask = (Ve[0].width << 1) - 1 : qt.mipmask = Ve[0].mipmask, qt.internalformat = Ve[0].internalformat, Qe.width = Ve[0].width, Qe.height = Ve[0].height, ol(qt), ht = 0; ht < 6; ++ht) is(Ve[ht], $n + ht);
+                for (al(ur, ya), io(), Gr.profile && (qt.stats.size = cc(qt.internalformat, qt.type, Qe.width, Qe.height, ur.genMipmaps, true)), Qe.format = xi[qt.internalformat], Qe.type = Ri[qt.type], Qe.mag = ci[ur.magFilter], Qe.min = an[ur.minFilter], Qe.wrapS = Zi[ur.wrapS], Qe.wrapT = Zi[ur.wrapT], ht = 0; ht < 6; ++ht) Ml(Ve[ht]);
+                return Qe;
+              }
+              function at(Ot, Rt, Bt, Dt, yt) {
+                var Pt = Bt | 0, ht = Dt | 0, ur = yt | 0, br = Ki();
+                return li(br, qt), br.width = 0, br.height = 0, Ni(br, Rt), br.width = br.width || (qt.width >> ur) - Pt, br.height = br.height || (qt.height >> ur) - ht, ol(qt), Vn(br, $n + Ot, Pt, ht, ur), io(), kn(br), Qe;
+              }
+              function Ct(Ot) {
+                var Rt = Ot | 0;
+                if (Rt !== qt.width) {
+                  Qe.width = qt.width = Rt, Qe.height = qt.height = Rt, ol(qt);
+                  for (var Bt = 0; Bt < 6; ++Bt) for (var Dt = 0; qt.mipmask >> Dt; ++Dt) Me.texImage2D($n + Bt, Dt, qt.format, Rt >> Dt, Rt >> Dt, 0, qt.format, qt.type, null);
+                  return io(), Gr.profile && (qt.stats.size = cc(qt.internalformat, qt.type, Qe.width, Qe.height, false, true)), Qe;
+                }
+              }
+              return Qe(ne, we, Ue, ft, Zt, hr), Qe.subimage = at, Qe.resize = Ct, Qe._reglType = "textureCube", Qe._texture = qt, Gr.profile && (Qe.stats = qt.stats), Qe.destroy = function() {
+                qt.decRef();
+              }, Qe;
+            }
+            function q() {
+              for (var ne = 0; ne < Vs; ++ne) Me.activeTexture(Fu + ne), Me.bindTexture(_n, null), Ys[ne] = null;
+              dt(ss).forEach(Y), Nr.cubeCount = 0, Nr.textureCount = 0;
+            }
+            Gr.profile && (Nr.getTotalTextureSize = function() {
+              var ne = 0;
+              return Object.keys(ss).forEach(function(we) {
+                ne += ss[we].stats.size;
+              }), ne;
+            });
+            function K() {
+              for (var ne = 0; ne < Vs; ++ne) {
+                var we = Ys[ne];
+                we && (we.bindCount = 0, we.unit = -1, Ys[ne] = null);
+              }
+              dt(ss).forEach(function(Ue) {
+                Ue.texture = Me.createTexture(), Me.bindTexture(Ue.target, Ue.texture);
+                for (var ft = 0; ft < 32; ++ft) if ((Ue.mipmask & 1 << ft) !== 0) if (Ue.target === _n) Me.texImage2D(_n, ft, Ue.internalformat, Ue.width >> ft, Ue.height >> ft, 0, Ue.internalformat, Ue.type, null);
+                else for (var Zt = 0; Zt < 6; ++Zt) Me.texImage2D($n + Zt, ft, Ue.internalformat, Ue.width >> ft, Ue.height >> ft, 0, Ue.internalformat, Ue.type, null);
+                al(Ue.texInfo, Ue.target);
+              });
+            }
+            function de() {
+              for (var ne = 0; ne < Vs; ++ne) {
+                var we = Ys[ne];
+                we && (we.bindCount = 0, we.unit = -1, Ys[ne] = null), Me.activeTexture(Fu + ne), Me.bindTexture(_n, null), Me.bindTexture(ya, null);
+              }
+            }
+            return { create2D: D, createCube: J, clear: q, getTexture: function(ne) {
+              return null;
+            }, restore: K, refresh: de };
+          }
+          var Nl = 36161, Kc = 32854, Rc = 32855, gs = 36194, Wf = 33189, Wh = 36168, rh = 34041, sf = 35907, Sh = 34836, Mu = 34842, ih = 34843, js = [];
+          js[Kc] = 2, js[Rc] = 2, js[gs] = 2, js[Wf] = 2, js[Wh] = 1, js[rh] = 4, js[sf] = 4, js[Sh] = 16, js[Mu] = 8, js[ih] = 6;
+          function Eu(Me, bt, zt) {
+            return js[Me] * bt * zt;
+          }
+          var Dc = function(Me, bt, zt, Rr, jr) {
+            var Nr = { rgba4: Kc, rgb565: gs, "rgb5 a1": Rc, depth: Wf, stencil: Wh, "depth stencil": rh };
+            bt.ext_srgb && (Nr.srgba = sf), bt.ext_color_buffer_half_float && (Nr.rgba16f = Mu, Nr.rgb16f = ih), bt.webgl_color_buffer_float && (Nr.rgba32f = Sh);
+            var Gr = [];
+            Object.keys(Nr).forEach(function(Wi) {
+              var si = Nr[Wi];
+              Gr[si] = Wi;
+            });
+            var mi = 0, Ui = {};
+            function qi(Wi) {
+              this.id = mi++, this.refCount = 1, this.renderbuffer = Wi, this.format = Kc, this.width = 0, this.height = 0, jr.profile && (this.stats = { size: 0 });
+            }
+            qi.prototype.decRef = function() {
+              --this.refCount <= 0 && Ei(this);
+            };
+            function Ei(Wi) {
+              var si = Wi.renderbuffer;
+              Me.bindRenderbuffer(Nl, null), Me.deleteRenderbuffer(si), Wi.renderbuffer = null, Wi.refCount = 0, delete Ui[Wi.id], Rr.renderbufferCount--;
+            }
+            function Hn(Wi, si) {
+              var Mr = new qi(Me.createRenderbuffer());
+              Ui[Mr.id] = Mr, Rr.renderbufferCount++;
+              function Yr(Ri, ci) {
+                var an = 0, Zi = 0, Bn = Kc;
+                if (typeof Ri == "object" && Ri) {
+                  var hi = Ri;
+                  if ("shape" in hi) {
+                    var li = hi.shape;
+                    an = li[0] | 0, Zi = li[1] | 0;
+                  } else "radius" in hi && (an = Zi = hi.radius | 0), "width" in hi && (an = hi.width | 0), "height" in hi && (Zi = hi.height | 0);
+                  "format" in hi && (Bn = Nr[hi.format]);
+                } else typeof Ri == "number" ? (an = Ri | 0, typeof ci == "number" ? Zi = ci | 0 : Zi = an) : Ri || (an = Zi = 1);
+                if (!(an === Mr.width && Zi === Mr.height && Bn === Mr.format)) return Yr.width = Mr.width = an, Yr.height = Mr.height = Zi, Mr.format = Bn, Me.bindRenderbuffer(Nl, Mr.renderbuffer), Me.renderbufferStorage(Nl, Bn, an, Zi), jr.profile && (Mr.stats.size = Eu(Mr.format, Mr.width, Mr.height)), Yr.format = Gr[Mr.format], Yr;
+              }
+              function xi(Ri, ci) {
+                var an = Ri | 0, Zi = ci | 0 || an;
+                return an === Mr.width && Zi === Mr.height || (Yr.width = Mr.width = an, Yr.height = Mr.height = Zi, Me.bindRenderbuffer(Nl, Mr.renderbuffer), Me.renderbufferStorage(Nl, Mr.format, an, Zi), jr.profile && (Mr.stats.size = Eu(Mr.format, Mr.width, Mr.height))), Yr;
+              }
+              return Yr(Wi, si), Yr.resize = xi, Yr._reglType = "renderbuffer", Yr._renderbuffer = Mr, jr.profile && (Yr.stats = Mr.stats), Yr.destroy = function() {
+                Mr.decRef();
+              }, Yr;
+            }
+            jr.profile && (Rr.getTotalRenderbufferSize = function() {
+              var Wi = 0;
+              return Object.keys(Ui).forEach(function(si) {
+                Wi += Ui[si].stats.size;
+              }), Wi;
+            });
+            function en() {
+              dt(Ui).forEach(function(Wi) {
+                Wi.renderbuffer = Me.createRenderbuffer(), Me.bindRenderbuffer(Nl, Wi.renderbuffer), Me.renderbufferStorage(Nl, Wi.format, Wi.width, Wi.height);
+              }), Me.bindRenderbuffer(Nl, null);
+            }
+            return { create: Hn, clear: function() {
+              dt(Ui).forEach(Ei);
+            }, restore: en };
+          }, ks = 36160, bc = 36161, hu = 3553, _u = 34069, nl = 36064, nh = 36096, Mh = 36128, zu = 33306, wc = 36193, bd = 5121, xf = 5126, Pf = 6407, Ou = 6408, bf = [];
+          bf[Ou] = 4, bf[Pf] = 3;
+          var jl = [];
+          jl[bd] = 1, jl[xf] = 4, jl[wc] = 2;
+          function lf(Me, bt, zt, Rr, jr, Nr) {
+            var Gr = { cur: null, next: null, dirty: false, setFBO: null }, mi = ["rgba"], Ui = ["rgba4", "rgb565", "rgb5 a1"];
+            bt.ext_srgb && Ui.push("srgba"), bt.ext_color_buffer_half_float && Ui.push("rgba16f", "rgb16f"), bt.webgl_color_buffer_float && Ui.push("rgba32f");
+            var qi = ["uint8"];
+            bt.oes_texture_half_float && qi.push("half float", "float16"), bt.oes_texture_float && qi.push("float", "float32");
+            function Ei(Vi, Ni, pn) {
+              this.target = Vi, this.texture = Ni, this.renderbuffer = pn;
+              var Vn = 0, na = 0;
+              Ni ? (Vn = Ni.width, na = Ni.height) : pn && (Vn = pn.width, na = pn.height), this.width = Vn, this.height = na;
+            }
+            function Hn(Vi) {
+              Vi && (Vi.texture && Vi.texture._texture.decRef(), Vi.renderbuffer && Vi.renderbuffer._renderbuffer.decRef());
+            }
+            function en(Vi, Ni, pn) {
+              if (Vi) if (Vi.texture) {
+                var Vn = Vi.texture._texture;
+                Math.max(1, Vn.width);
+                Math.max(1, Vn.height);
+                Vn.refCount += 1;
+              } else {
+                var kn = Vi.renderbuffer._renderbuffer;
+                kn.refCount += 1;
+              }
+            }
+            function Wi(Vi, Ni) {
+              Ni && (Ni.texture ? Me.framebufferTexture2D(ks, Vi, Ni.target, Ni.texture._texture.texture, 0) : Me.framebufferRenderbuffer(ks, Vi, bc, Ni.renderbuffer._renderbuffer.renderbuffer));
+            }
+            function si(Vi) {
+              var Ni = hu, pn = null, Vn = null, na = Vi;
+              typeof Vi == "object" && (na = Vi.data, "target" in Vi && (Ni = Vi.target | 0));
+              var Ki = na._reglType;
+              return Ki === "texture2d" || Ki === "textureCube" ? pn = na : Ki === "renderbuffer" && (Vn = na, Ni = bc), new Ei(Ni, pn, Vn);
+            }
+            function Mr(Vi, Ni, pn, Vn, na) {
+              if (pn) {
+                var Ki = Rr.create2D({ width: Vi, height: Ni, format: Vn, type: na });
+                return Ki._texture.refCount = 0, new Ei(hu, Ki, null);
+              } else {
+                var kn = jr.create({ width: Vi, height: Ni, format: Vn });
+                return kn._renderbuffer.refCount = 0, new Ei(bc, null, kn);
+              }
+            }
+            function Yr(Vi) {
+              return Vi && (Vi.texture || Vi.renderbuffer);
+            }
+            function xi(Vi, Ni, pn) {
+              Vi && (Vi.texture ? Vi.texture.resize(Ni, pn) : Vi.renderbuffer && Vi.renderbuffer.resize(Ni, pn), Vi.width = Ni, Vi.height = pn);
+            }
+            var Ri = 0, ci = {};
+            function an() {
+              this.id = Ri++, ci[this.id] = this, this.framebuffer = Me.createFramebuffer(), this.width = 0, this.height = 0, this.colorAttachments = [], this.depthAttachment = null, this.stencilAttachment = null, this.depthStencilAttachment = null;
+            }
+            function Zi(Vi) {
+              Vi.colorAttachments.forEach(Hn), Hn(Vi.depthAttachment), Hn(Vi.stencilAttachment), Hn(Vi.depthStencilAttachment);
+            }
+            function Bn(Vi) {
+              var Ni = Vi.framebuffer;
+              Me.deleteFramebuffer(Ni), Vi.framebuffer = null, Nr.framebufferCount--, delete ci[Vi.id];
+            }
+            function hi(Vi) {
+              var Ni;
+              Me.bindFramebuffer(ks, Vi.framebuffer);
+              var pn = Vi.colorAttachments;
+              for (Ni = 0; Ni < pn.length; ++Ni) Wi(nl + Ni, pn[Ni]);
+              for (Ni = pn.length; Ni < zt.maxColorAttachments; ++Ni) Me.framebufferTexture2D(ks, nl + Ni, hu, null, 0);
+              Me.framebufferTexture2D(ks, zu, hu, null, 0), Me.framebufferTexture2D(ks, nh, hu, null, 0), Me.framebufferTexture2D(ks, Mh, hu, null, 0), Wi(nh, Vi.depthAttachment), Wi(Mh, Vi.stencilAttachment), Wi(zu, Vi.depthStencilAttachment);
+              Me.checkFramebufferStatus(ks);
+              Me.isContextLost(), Me.bindFramebuffer(ks, Gr.next ? Gr.next.framebuffer : null), Gr.cur = Gr.next, Me.getError();
+            }
+            function li(Vi, Ni) {
+              var pn = new an();
+              Nr.framebufferCount++;
+              function Vn(Ki, kn) {
+                var ta, oa = 0, ba = 0, is = true, Zs = true, Va = null, Ml = true, zo = "rgba", Qs = "uint8", al = 1, Vl = null, ss = null, Vs = null, Ys = false;
+                if (typeof Ki == "number") oa = Ki | 0, ba = kn | 0 || oa;
+                else if (!Ki) oa = ba = 1;
+                else {
+                  var wa = Ki;
+                  if ("shape" in wa) {
+                    var ol = wa.shape;
+                    oa = ol[0], ba = ol[1];
+                  } else "radius" in wa && (oa = ba = wa.radius), "width" in wa && (oa = wa.width), "height" in wa && (ba = wa.height);
+                  ("color" in wa || "colors" in wa) && (Va = wa.color || wa.colors, Array.isArray(Va)), Va || ("colorCount" in wa && (al = wa.colorCount | 0), "colorTexture" in wa && (Ml = !!wa.colorTexture, zo = "rgba4"), "colorType" in wa && (Qs = wa.colorType, Ml || (Qs === "half float" || Qs === "float16" ? zo = "rgba16f" : (Qs === "float" || Qs === "float32") && (zo = "rgba32f"))), "colorFormat" in wa && (zo = wa.colorFormat, mi.indexOf(zo) >= 0 ? Ml = true : Ui.indexOf(zo) >= 0 && (Ml = false))), ("depthTexture" in wa || "depthStencilTexture" in wa) && (Ys = !!(wa.depthTexture || wa.depthStencilTexture)), "depth" in wa && (typeof wa.depth == "boolean" ? is = wa.depth : (Vl = wa.depth, Zs = false)), "stencil" in wa && (typeof wa.stencil == "boolean" ? Zs = wa.stencil : (ss = wa.stencil, is = false)), "depthStencil" in wa && (typeof wa.depthStencil == "boolean" ? is = Zs = wa.depthStencil : (Vs = wa.depthStencil, is = false, Zs = false));
+                }
+                var io = null, Y = null, D = null, J = null;
+                if (Array.isArray(Va)) io = Va.map(si);
+                else if (Va) io = [si(Va)];
+                else for (io = new Array(al), ta = 0; ta < al; ++ta) io[ta] = Mr(oa, ba, Ml, zo, Qs);
+                oa = oa || io[0].width, ba = ba || io[0].height, Vl ? Y = si(Vl) : is && !Zs && (Y = Mr(oa, ba, Ys, "depth", "uint32")), ss ? D = si(ss) : Zs && !is && (D = Mr(oa, ba, false, "stencil", "uint8")), Vs ? J = si(Vs) : !Vl && !ss && Zs && is && (J = Mr(oa, ba, Ys, "depth stencil", "depth stencil"));
+                for (ta = 0; ta < io.length; ++ta) if (en(io[ta]), io[ta] && io[ta].texture) {
+                  bf[io[ta].texture._texture.format] * jl[io[ta].texture._texture.type];
+                }
+                return en(Y), en(D), en(J), Zi(pn), pn.width = oa, pn.height = ba, pn.colorAttachments = io, pn.depthAttachment = Y, pn.stencilAttachment = D, pn.depthStencilAttachment = J, Vn.color = io.map(Yr), Vn.depth = Yr(Y), Vn.stencil = Yr(D), Vn.depthStencil = Yr(J), Vn.width = pn.width, Vn.height = pn.height, hi(pn), Vn;
+              }
+              function na(Ki, kn) {
+                var ta = Math.max(Ki | 0, 1), oa = Math.max(kn | 0 || ta, 1);
+                if (ta === pn.width && oa === pn.height) return Vn;
+                for (var ba = pn.colorAttachments, is = 0; is < ba.length; ++is) xi(ba[is], ta, oa);
+                return xi(pn.depthAttachment, ta, oa), xi(pn.stencilAttachment, ta, oa), xi(pn.depthStencilAttachment, ta, oa), pn.width = Vn.width = ta, pn.height = Vn.height = oa, hi(pn), Vn;
+              }
+              return Vn(Vi, Ni), e(Vn, { resize: na, _reglType: "framebuffer", _framebuffer: pn, destroy: function() {
+                Bn(pn), Zi(pn);
+              }, use: function(Ki) {
+                Gr.setFBO({ framebuffer: Vn }, Ki);
+              } });
+            }
+            function mn(Vi) {
+              var Ni = Array(6);
+              function pn(na) {
+                var Ki, kn = { color: null }, ta = 0, oa = null, ba = "rgba", is = "uint8", Zs = 1;
+                if (typeof na == "number") ta = na | 0;
+                else if (!na) ta = 1;
+                else {
+                  var Va = na;
+                  if ("shape" in Va) {
+                    var Ml = Va.shape;
+                    ta = Ml[0];
+                  } else "radius" in Va && (ta = Va.radius | 0), "width" in Va ? (ta = Va.width | 0, "height" in Va) : "height" in Va && (ta = Va.height | 0);
+                  ("color" in Va || "colors" in Va) && (oa = Va.color || Va.colors, Array.isArray(oa)), oa || ("colorCount" in Va && (Zs = Va.colorCount | 0), "colorType" in Va && (is = Va.colorType), "colorFormat" in Va && (ba = Va.colorFormat)), "depth" in Va && (kn.depth = Va.depth), "stencil" in Va && (kn.stencil = Va.stencil), "depthStencil" in Va && (kn.depthStencil = Va.depthStencil);
+                }
+                var zo;
+                if (oa) if (Array.isArray(oa)) for (zo = [], Ki = 0; Ki < oa.length; ++Ki) zo[Ki] = oa[Ki];
+                else zo = [oa];
+                else {
+                  zo = Array(Zs);
+                  var Qs = { radius: ta, format: ba, type: is };
+                  for (Ki = 0; Ki < Zs; ++Ki) zo[Ki] = Rr.createCube(Qs);
+                }
+                for (kn.color = Array(zo.length), Ki = 0; Ki < zo.length; ++Ki) {
+                  var al = zo[Ki];
+                  ta = ta || al.width, kn.color[Ki] = { target: _u, data: zo[Ki] };
+                }
+                for (Ki = 0; Ki < 6; ++Ki) {
+                  for (var Vl = 0; Vl < zo.length; ++Vl) kn.color[Vl].target = _u + Ki;
+                  Ki > 0 && (kn.depth = Ni[0].depth, kn.stencil = Ni[0].stencil, kn.depthStencil = Ni[0].depthStencil), Ni[Ki] ? Ni[Ki](kn) : Ni[Ki] = li(kn);
+                }
+                return e(pn, { width: ta, height: ta, color: zo });
+              }
+              function Vn(na) {
+                var Ki, kn = na | 0;
+                if (kn === pn.width) return pn;
+                var ta = pn.color;
+                for (Ki = 0; Ki < ta.length; ++Ki) ta[Ki].resize(kn);
+                for (Ki = 0; Ki < 6; ++Ki) Ni[Ki].resize(kn);
+                return pn.width = pn.height = kn, pn;
+              }
+              return pn(Vi), e(pn, { faces: Ni, resize: Vn, _reglType: "framebufferCube", destroy: function() {
+                Ni.forEach(function(na) {
+                  na.destroy();
+                });
+              } });
+            }
+            function Ji() {
+              Gr.cur = null, Gr.next = null, Gr.dirty = true, dt(ci).forEach(function(Vi) {
+                Vi.framebuffer = Me.createFramebuffer(), hi(Vi);
+              });
+            }
+            return e(Gr, { getFramebuffer: function(Vi) {
+              if (typeof Vi == "function" && Vi._reglType === "framebuffer") {
+                var Ni = Vi._framebuffer;
+                if (Ni instanceof an) return Ni;
+              }
+              return null;
+            }, create: li, createCube: mn, clear: function() {
+              dt(ci).forEach(Bn);
+            }, restore: Ji });
+          }
+          var Xh = 5126, If = 34962, Cs = 34963;
+          function du() {
+            this.state = 0, this.x = 0, this.y = 0, this.z = 0, this.w = 0, this.buffer = null, this.size = 0, this.normalized = false, this.type = Xh, this.offset = 0, this.stride = 0, this.divisor = 0;
+          }
+          function ku(Me, bt, zt, Rr, jr, Nr, Gr) {
+            for (var mi = zt.maxAttributes, Ui = new Array(mi), qi = 0; qi < mi; ++qi) Ui[qi] = new du();
+            var Ei = 0, Hn = {}, en = { Record: du, scope: {}, state: Ui, currentVAO: null, targetVAO: null, restore: si() ? Zi : function() {
+            }, createVAO: Bn, getVAO: Yr, destroyBuffer: Wi, setVAO: si() ? xi : Ri, clear: si() ? ci : function() {
+            } };
+            function Wi(hi) {
+              for (var li = 0; li < Ui.length; ++li) {
+                var mn = Ui[li];
+                mn.buffer === hi && (Me.disableVertexAttribArray(li), mn.buffer = null);
+              }
+            }
+            function si() {
+              return bt.oes_vertex_array_object;
+            }
+            function Mr() {
+              return bt.angle_instanced_arrays;
+            }
+            function Yr(hi) {
+              return typeof hi == "function" && hi._vao ? hi._vao : null;
+            }
+            function xi(hi) {
+              if (hi !== en.currentVAO) {
+                var li = si();
+                hi ? li.bindVertexArrayOES(hi.vao) : li.bindVertexArrayOES(null), en.currentVAO = hi;
+              }
+            }
+            function Ri(hi) {
+              if (hi !== en.currentVAO) {
+                if (hi) hi.bindAttrs();
+                else {
+                  for (var li = Mr(), mn = 0; mn < Ui.length; ++mn) {
+                    var Ji = Ui[mn];
+                    Ji.buffer ? (Me.enableVertexAttribArray(mn), Ji.buffer.bind(), Me.vertexAttribPointer(mn, Ji.size, Ji.type, Ji.normalized, Ji.stride, Ji.offfset), li && Ji.divisor && li.vertexAttribDivisorANGLE(mn, Ji.divisor)) : (Me.disableVertexAttribArray(mn), Me.vertexAttrib4f(mn, Ji.x, Ji.y, Ji.z, Ji.w));
+                  }
+                  Gr.elements ? Me.bindBuffer(Cs, Gr.elements.buffer.buffer) : Me.bindBuffer(Cs, null);
+                }
+                en.currentVAO = hi;
+              }
+            }
+            function ci() {
+              dt(Hn).forEach(function(hi) {
+                hi.destroy();
+              });
+            }
+            function an() {
+              this.id = ++Ei, this.attributes = [], this.elements = null, this.ownsElements = false, this.count = 0, this.offset = 0, this.instances = -1, this.primitive = 4;
+              var hi = si();
+              hi ? this.vao = hi.createVertexArrayOES() : this.vao = null, Hn[this.id] = this, this.buffers = [];
+            }
+            an.prototype.bindAttrs = function() {
+              for (var hi = Mr(), li = this.attributes, mn = 0; mn < li.length; ++mn) {
+                var Ji = li[mn];
+                Ji.buffer ? (Me.enableVertexAttribArray(mn), Me.bindBuffer(If, Ji.buffer.buffer), Me.vertexAttribPointer(mn, Ji.size, Ji.type, Ji.normalized, Ji.stride, Ji.offset), hi && Ji.divisor && hi.vertexAttribDivisorANGLE(mn, Ji.divisor)) : (Me.disableVertexAttribArray(mn), Me.vertexAttrib4f(mn, Ji.x, Ji.y, Ji.z, Ji.w));
+              }
+              for (var Vi = li.length; Vi < mi; ++Vi) Me.disableVertexAttribArray(Vi);
+              var Ni = Nr.getElements(this.elements);
+              Ni ? Me.bindBuffer(Cs, Ni.buffer.buffer) : Me.bindBuffer(Cs, null);
+            }, an.prototype.refresh = function() {
+              var hi = si();
+              hi && (hi.bindVertexArrayOES(this.vao), this.bindAttrs(), en.currentVAO = null, hi.bindVertexArrayOES(null));
+            }, an.prototype.destroy = function() {
+              if (this.vao) {
+                var hi = si();
+                this === en.currentVAO && (en.currentVAO = null, hi.bindVertexArrayOES(null)), hi.deleteVertexArrayOES(this.vao), this.vao = null;
+              }
+              this.ownsElements && (this.elements.destroy(), this.elements = null, this.ownsElements = false), Hn[this.id] && (delete Hn[this.id], Rr.vaoCount -= 1);
+            };
+            function Zi() {
+              var hi = si();
+              hi && dt(Hn).forEach(function(li) {
+                li.refresh();
+              });
+            }
+            function Bn(hi) {
+              var li = new an();
+              Rr.vaoCount += 1;
+              function mn(Ji) {
+                var Vi;
+                if (Array.isArray(Ji)) Vi = Ji, li.elements && li.ownsElements && li.elements.destroy(), li.elements = null, li.ownsElements = false, li.offset = 0, li.count = 0, li.instances = -1, li.primitive = 4;
+                else {
+                  if (Ji.elements) {
+                    var Ni = Ji.elements;
+                    li.ownsElements ? typeof Ni == "function" && Ni._reglType === "elements" ? (li.elements.destroy(), li.ownsElements = false) : (li.elements(Ni), li.ownsElements = false) : Nr.getElements(Ji.elements) ? (li.elements = Ji.elements, li.ownsElements = false) : (li.elements = Nr.create(Ji.elements), li.ownsElements = true);
+                  } else li.elements = null, li.ownsElements = false;
+                  Vi = Ji.attributes, li.offset = 0, li.count = -1, li.instances = -1, li.primitive = 4, li.elements && (li.count = li.elements._elements.vertCount, li.primitive = li.elements._elements.primType), "offset" in Ji && (li.offset = Ji.offset | 0), "count" in Ji && (li.count = Ji.count | 0), "instances" in Ji && (li.instances = Ji.instances | 0), "primitive" in Ji && (li.primitive = Sn[Ji.primitive]);
+                }
+                var pn = {}, Vn = li.attributes;
+                Vn.length = Vi.length;
+                for (var na = 0; na < Vi.length; ++na) {
+                  var Ki = Vi[na], kn = Vn[na] = new du(), ta = Ki.data || Ki;
+                  if (Array.isArray(ta) || Br(ta) || Vr(ta)) {
+                    var oa;
+                    li.buffers[na] && (oa = li.buffers[na], Br(ta) && oa._buffer.byteLength >= ta.byteLength ? oa.subdata(ta) : (oa.destroy(), li.buffers[na] = null)), li.buffers[na] || (oa = li.buffers[na] = jr.create(Ki, If, false, true)), kn.buffer = jr.getBuffer(oa), kn.size = kn.buffer.dimension | 0, kn.normalized = false, kn.type = kn.buffer.dtype, kn.offset = 0, kn.stride = 0, kn.divisor = 0, kn.state = 1, pn[na] = 1;
+                  } else jr.getBuffer(Ki) ? (kn.buffer = jr.getBuffer(Ki), kn.size = kn.buffer.dimension | 0, kn.normalized = false, kn.type = kn.buffer.dtype, kn.offset = 0, kn.stride = 0, kn.divisor = 0, kn.state = 1) : jr.getBuffer(Ki.buffer) ? (kn.buffer = jr.getBuffer(Ki.buffer), kn.size = (+Ki.size || kn.buffer.dimension) | 0, kn.normalized = !!Ki.normalized || false, "type" in Ki ? kn.type = ji[Ki.type] : kn.type = kn.buffer.dtype, kn.offset = (Ki.offset || 0) | 0, kn.stride = (Ki.stride || 0) | 0, kn.divisor = (Ki.divisor || 0) | 0, kn.state = 1) : "x" in Ki && (kn.x = +Ki.x || 0, kn.y = +Ki.y || 0, kn.z = +Ki.z || 0, kn.w = +Ki.w || 0, kn.state = 2);
+                }
+                for (var ba = 0; ba < li.buffers.length; ++ba) !pn[ba] && li.buffers[ba] && (li.buffers[ba].destroy(), li.buffers[ba] = null);
+                return li.refresh(), mn;
+              }
+              return mn.destroy = function() {
+                for (var Ji = 0; Ji < li.buffers.length; ++Ji) li.buffers[Ji] && li.buffers[Ji].destroy();
+                li.buffers.length = 0, li.ownsElements && (li.elements.destroy(), li.elements = null, li.ownsElements = false), li.destroy();
+              }, mn._vao = li, mn._reglType = "vao", mn(hi);
+            }
+            return en;
+          }
+          var Xf = 35632, Us = 35633, wf = 35718, zc = 35721;
+          function Wu(Me, bt, zt, Rr) {
+            var jr = {}, Nr = {};
+            function Gr(Mr, Yr, xi, Ri) {
+              this.name = Mr, this.id = Yr, this.location = xi, this.info = Ri;
+            }
+            function mi(Mr, Yr) {
+              for (var xi = 0; xi < Mr.length; ++xi) if (Mr[xi].id === Yr.id) {
+                Mr[xi].location = Yr.location;
+                return;
+              }
+              Mr.push(Yr);
+            }
+            function Ui(Mr, Yr, xi) {
+              var Ri = Mr === Xf ? jr : Nr, ci = Ri[Yr];
+              if (!ci) {
+                var an = bt.str(Yr);
+                ci = Me.createShader(Mr), Me.shaderSource(ci, an), Me.compileShader(ci), Ri[Yr] = ci;
+              }
+              return ci;
+            }
+            var qi = {}, Ei = [], Hn = 0;
+            function en(Mr, Yr) {
+              this.id = Hn++, this.fragId = Mr, this.vertId = Yr, this.program = null, this.uniforms = [], this.attributes = [], this.refCount = 1, Rr.profile && (this.stats = { uniformsCount: 0, attributesCount: 0 });
+            }
+            function Wi(Mr, Yr, xi) {
+              var Ri, ci, an = Ui(Xf, Mr.fragId), Zi = Ui(Us, Mr.vertId), Bn = Mr.program = Me.createProgram();
+              if (Me.attachShader(Bn, an), Me.attachShader(Bn, Zi), xi) for (Ri = 0; Ri < xi.length; ++Ri) {
+                var hi = xi[Ri];
+                Me.bindAttribLocation(Bn, hi[0], hi[1]);
+              }
+              Me.linkProgram(Bn);
+              var li = Me.getProgramParameter(Bn, wf);
+              Rr.profile && (Mr.stats.uniformsCount = li);
+              var mn = Mr.uniforms;
+              for (Ri = 0; Ri < li; ++Ri) if (ci = Me.getActiveUniform(Bn, Ri), ci) if (ci.size > 1) for (var Ji = 0; Ji < ci.size; ++Ji) {
+                var Vi = ci.name.replace("[0]", "[" + Ji + "]");
+                mi(mn, new Gr(Vi, bt.id(Vi), Me.getUniformLocation(Bn, Vi), ci));
+              }
+              else mi(mn, new Gr(ci.name, bt.id(ci.name), Me.getUniformLocation(Bn, ci.name), ci));
+              var Ni = Me.getProgramParameter(Bn, zc);
+              Rr.profile && (Mr.stats.attributesCount = Ni);
+              var pn = Mr.attributes;
+              for (Ri = 0; Ri < Ni; ++Ri) ci = Me.getActiveAttrib(Bn, Ri), ci && mi(pn, new Gr(ci.name, bt.id(ci.name), Me.getAttribLocation(Bn, ci.name), ci));
+            }
+            Rr.profile && (zt.getMaxUniformsCount = function() {
+              var Mr = 0;
+              return Ei.forEach(function(Yr) {
+                Yr.stats.uniformsCount > Mr && (Mr = Yr.stats.uniformsCount);
+              }), Mr;
+            }, zt.getMaxAttributesCount = function() {
+              var Mr = 0;
+              return Ei.forEach(function(Yr) {
+                Yr.stats.attributesCount > Mr && (Mr = Yr.stats.attributesCount);
+              }), Mr;
+            });
+            function si() {
+              jr = {}, Nr = {};
+              for (var Mr = 0; Mr < Ei.length; ++Mr) Wi(Ei[Mr], null, Ei[Mr].attributes.map(function(Yr) {
+                return [Yr.location, Yr.name];
+              }));
+            }
+            return { clear: function() {
+              var Mr = Me.deleteShader.bind(Me);
+              dt(jr).forEach(Mr), jr = {}, dt(Nr).forEach(Mr), Nr = {}, Ei.forEach(function(Yr) {
+                Me.deleteProgram(Yr.program);
+              }), Ei.length = 0, qi = {}, zt.shaderCount = 0;
+            }, program: function(Mr, Yr, xi, Ri) {
+              var ci = qi[Yr];
+              ci || (ci = qi[Yr] = {});
+              var an = ci[Mr];
+              if (an && (an.refCount++, !Ri)) return an;
+              var Zi = new en(Yr, Mr);
+              return zt.shaderCount++, Wi(Zi, xi, Ri), an || (ci[Mr] = Zi), Ei.push(Zi), e(Zi, { destroy: function() {
+                if (Zi.refCount--, Zi.refCount <= 0) {
+                  Me.deleteProgram(Zi.program);
+                  var Bn = Ei.indexOf(Zi);
+                  Ei.splice(Bn, 1), zt.shaderCount--;
+                }
+                ci[Zi.vertId].refCount <= 0 && (Me.deleteShader(Nr[Zi.vertId]), delete Nr[Zi.vertId], delete qi[Zi.fragId][Zi.vertId]), Object.keys(qi[Zi.fragId]).length || (Me.deleteShader(jr[Zi.fragId]), delete jr[Zi.fragId], delete qi[Zi.fragId]);
+              } });
+            }, restore: si, shader: Ui, frag: -1, vert: -1 };
+          }
+          var Rf = 6408, Xu = 5121, uf = 3333, Zf = 5126;
+          function Wl(Me, bt, zt, Rr, jr, Nr, Gr) {
+            function mi(Ei) {
+              var Hn;
+              bt.next === null ? Hn = Xu : Hn = bt.next.colorAttachments[0].texture._texture.type;
+              var en = 0, Wi = 0, si = Rr.framebufferWidth, Mr = Rr.framebufferHeight, Yr = null;
+              Br(Ei) ? Yr = Ei : Ei && (en = Ei.x | 0, Wi = Ei.y | 0, si = (Ei.width || Rr.framebufferWidth - en) | 0, Mr = (Ei.height || Rr.framebufferHeight - Wi) | 0, Yr = Ei.data || null), zt();
+              var xi = si * Mr * 4;
+              return Yr || (Hn === Xu ? Yr = new Uint8Array(xi) : Hn === Zf && (Yr = Yr || new Float32Array(xi))), Me.pixelStorei(uf, 4), Me.readPixels(en, Wi, si, Mr, Rf, Hn, Yr), Yr;
+            }
+            function Ui(Ei) {
+              var Hn;
+              return bt.setFBO({ framebuffer: Ei.framebuffer }, function() {
+                Hn = mi(Ei);
+              }), Hn;
+            }
+            function qi(Ei) {
+              return !Ei || !("framebuffer" in Ei) ? mi(Ei) : Ui(Ei);
+            }
+            return qi;
+          }
+          function Oc(Me) {
+            return vu(Tc(fc(Me)));
+          }
+          function Tc(Me) {
+            return At(Yi(Bc(Me), Me.length * 8));
+          }
+          function vu(Me) {
+            for (var bt = "0123456789abcdef", zt = "", Rr, jr = 0; jr < Me.length; jr++) Rr = Me.charCodeAt(jr), zt += bt.charAt(Rr >>> 4 & 15) + bt.charAt(Rr & 15);
+            return zt;
+          }
+          function fc(Me) {
+            for (var bt = "", zt = -1, Rr, jr; ++zt < Me.length; ) Rr = Me.charCodeAt(zt), jr = zt + 1 < Me.length ? Me.charCodeAt(zt + 1) : 0, 55296 <= Rr && Rr <= 56319 && 56320 <= jr && jr <= 57343 && (Rr = 65536 + ((Rr & 1023) << 10) + (jr & 1023), zt++), Rr <= 127 ? bt += String.fromCharCode(Rr) : Rr <= 2047 ? bt += String.fromCharCode(192 | Rr >>> 6 & 31, 128 | Rr & 63) : Rr <= 65535 ? bt += String.fromCharCode(224 | Rr >>> 12 & 15, 128 | Rr >>> 6 & 63, 128 | Rr & 63) : Rr <= 2097151 && (bt += String.fromCharCode(240 | Rr >>> 18 & 7, 128 | Rr >>> 12 & 63, 128 | Rr >>> 6 & 63, 128 | Rr & 63));
+            return bt;
+          }
+          function Bc(Me) {
+            for (var bt = Array(Me.length >> 2), zt = 0; zt < bt.length; zt++) bt[zt] = 0;
+            for (var zt = 0; zt < Me.length * 8; zt += 8) bt[zt >> 5] |= (Me.charCodeAt(zt / 8) & 255) << 24 - zt % 32;
+            return bt;
+          }
+          function At(Me) {
+            for (var bt = "", zt = 0; zt < Me.length * 32; zt += 8) bt += String.fromCharCode(Me[zt >> 5] >>> 24 - zt % 32 & 255);
+            return bt;
+          }
+          function Xt(Me, bt) {
+            return Me >>> bt | Me << 32 - bt;
+          }
+          function Cr(Me, bt) {
+            return Me >>> bt;
+          }
+          function Ar(Me, bt, zt) {
+            return Me & bt ^ ~Me & zt;
+          }
+          function Kr(Me, bt, zt) {
+            return Me & bt ^ Me & zt ^ bt & zt;
+          }
+          function ki(Me) {
+            return Xt(Me, 2) ^ Xt(Me, 13) ^ Xt(Me, 22);
+          }
+          function Xi(Me) {
+            return Xt(Me, 6) ^ Xt(Me, 11) ^ Xt(Me, 25);
+          }
+          function dn(Me) {
+            return Xt(Me, 7) ^ Xt(Me, 18) ^ Cr(Me, 3);
+          }
+          function wn(Me) {
+            return Xt(Me, 17) ^ Xt(Me, 19) ^ Cr(Me, 10);
+          }
+          var Nn = new Array(1116352408, 1899447441, -1245643825, -373957723, 961987163, 1508970993, -1841331548, -1424204075, -670586216, 310598401, 607225278, 1426881987, 1925078388, -2132889090, -1680079193, -1046744716, -459576895, -272742522, 264347078, 604807628, 770255983, 1249150122, 1555081692, 1996064986, -1740746414, -1473132947, -1341970488, -1084653625, -958395405, -710438585, 113926993, 338241895, 666307205, 773529912, 1294757372, 1396182291, 1695183700, 1986661051, -2117940946, -1838011259, -1564481375, -1474664885, -1035236496, -949202525, -778901479, -694614492, -200395387, 275423344, 430227734, 506948616, 659060556, 883997877, 958139571, 1322822218, 1537002063, 1747873779, 1955562222, 2024104815, -2067236844, -1933114872, -1866530822, -1538233109, -1090935817, -965641998);
+          function Yi(Me, bt) {
+            var zt = new Array(1779033703, -1150833019, 1013904242, -1521486534, 1359893119, -1694144372, 528734635, 1541459225), Rr = new Array(64), jr, Nr, Gr, mi, Ui, qi, Ei, Hn, en, Wi, si, Mr;
+            for (Me[bt >> 5] |= 128 << 24 - bt % 32, Me[(bt + 64 >> 9 << 4) + 15] = bt, en = 0; en < Me.length; en += 16) {
+              for (jr = zt[0], Nr = zt[1], Gr = zt[2], mi = zt[3], Ui = zt[4], qi = zt[5], Ei = zt[6], Hn = zt[7], Wi = 0; Wi < 64; Wi++) Wi < 16 ? Rr[Wi] = Me[Wi + en] : Rr[Wi] = Qi(Qi(Qi(wn(Rr[Wi - 2]), Rr[Wi - 7]), dn(Rr[Wi - 15])), Rr[Wi - 16]), si = Qi(Qi(Qi(Qi(Hn, Xi(Ui)), Ar(Ui, qi, Ei)), Nn[Wi]), Rr[Wi]), Mr = Qi(ki(jr), Kr(jr, Nr, Gr)), Hn = Ei, Ei = qi, qi = Ui, Ui = Qi(mi, si), mi = Gr, Gr = Nr, Nr = jr, jr = Qi(si, Mr);
+              zt[0] = Qi(jr, zt[0]), zt[1] = Qi(Nr, zt[1]), zt[2] = Qi(Gr, zt[2]), zt[3] = Qi(mi, zt[3]), zt[4] = Qi(Ui, zt[4]), zt[5] = Qi(qi, zt[5]), zt[6] = Qi(Ei, zt[6]), zt[7] = Qi(Hn, zt[7]);
+            }
+            return zt;
+          }
+          function Qi(Me, bt) {
+            var zt = (Me & 65535) + (bt & 65535), Rr = (Me >> 16) + (bt >> 16) + (zt >> 16);
+            return Rr << 16 | zt & 65535;
+          }
+          function on(Me) {
+            return Array.prototype.slice.call(Me);
+          }
+          function Fi(Me) {
+            return on(Me).join("");
+          }
+          function Qn(Me) {
+            var bt = Me && Me.cache, zt = 0, Rr = [], jr = [], Nr = [];
+            function Gr(si, Mr) {
+              var Yr = Mr && Mr.stable;
+              if (!Yr) {
+                for (var xi = 0; xi < jr.length; ++xi) if (jr[xi] === si && !Nr[xi]) return Rr[xi];
+              }
+              var Ri = "g" + zt++;
+              return Rr.push(Ri), jr.push(si), Nr.push(Yr), Ri;
+            }
+            function mi() {
+              var si = [];
+              function Mr() {
+                si.push.apply(si, on(arguments));
+              }
+              var Yr = [];
+              function xi() {
+                var Ri = "v" + zt++;
+                return Yr.push(Ri), arguments.length > 0 && (si.push(Ri, "="), si.push.apply(si, on(arguments)), si.push(";")), Ri;
+              }
+              return e(Mr, { def: xi, toString: function() {
+                return Fi([Yr.length > 0 ? "var " + Yr.join(",") + ";" : "", Fi(si)]);
+              } });
+            }
+            function Ui() {
+              var si = mi(), Mr = mi(), Yr = si.toString, xi = Mr.toString;
+              function Ri(ci, an) {
+                Mr(ci, an, "=", si.def(ci, an), ";");
+              }
+              return e(function() {
+                si.apply(si, on(arguments));
+              }, { def: si.def, entry: si, exit: Mr, save: Ri, set: function(ci, an, Zi) {
+                Ri(ci, an), si(ci, an, "=", Zi, ";");
+              }, toString: function() {
+                return Yr() + xi();
+              } });
+            }
+            function qi() {
+              var si = Fi(arguments), Mr = Ui(), Yr = Ui(), xi = Mr.toString, Ri = Yr.toString;
+              return e(Mr, { then: function() {
+                return Mr.apply(Mr, on(arguments)), this;
+              }, else: function() {
+                return Yr.apply(Yr, on(arguments)), this;
+              }, toString: function() {
+                var ci = Ri();
+                return ci && (ci = "else{" + ci + "}"), Fi(["if(", si, "){", xi(), "}", ci]);
+              } });
+            }
+            var Ei = mi(), Hn = {};
+            function en(si, Mr) {
+              var Yr = [];
+              function xi() {
+                var Bn = "a" + Yr.length;
+                return Yr.push(Bn), Bn;
+              }
+              Mr = Mr || 0;
+              for (var Ri = 0; Ri < Mr; ++Ri) xi();
+              var ci = Ui(), an = ci.toString, Zi = Hn[si] = e(ci, { arg: xi, toString: function() {
+                return Fi(["function(", Yr.join(), "){", an(), "}"]);
+              } });
+              return Zi;
+            }
+            function Wi() {
+              var si = ['"use strict";', Ei, "return {"];
+              Object.keys(Hn).forEach(function(Ri) {
+                si.push('"', Ri, '":', Hn[Ri].toString(), ",");
+              }), si.push("}");
+              var Mr = Fi(si).replace(/;/g, `;
+`).replace(/}/g, `}
+`).replace(/{/g, `{
+`), Yr;
+              if (bt && (Yr = Oc(Mr), bt[Yr])) return bt[Yr].apply(null, jr);
+              var xi = Function.apply(null, Rr.concat(Mr));
+              return bt && (bt[Yr] = xi), xi.apply(null, jr);
+            }
+            return { global: Ei, link: Gr, block: mi, proc: en, scope: Ui, cond: qi, compile: Wi };
+          }
+          var Ca = "xyzw".split(""), Ra = 5121, La = 1, Na = 2, Yn = 0, Dn = 1, Ka = 2, bo = 3, Zo = 4, Ss = 5, as = 6, ws = "dither", Ho = "blend.enable", ml = "blend.color", Ws = "blend.equation", Ls = "blend.func", va = "depth.enable", no = "depth.func", ys = "depth.range", rs = "depth.mask", Ql = "colorMask", Cu = "cull.enable", Yu = "cull.face", Nc = "frontFace", pu = "lineWidth", Uc = "polygonOffset.enable", xu = "polygonOffset.offset", Ac = "sample.alpha", Ua = "sample.enable", oo = "sample.coverage", Vc = "stencil.enable", hc = "stencil.mask", Ku = "stencil.func", ue = "stencil.opFront", w = "stencil.opBack", B = "scissor.enable", Q = "scissor.box", ee = "viewport", le = "profile", Oe = "framebuffer", Ze = "vert", st = "frag", Tt = "elements", Yt = "primitive", Kt = "count", xr = "offset", Ir = "instances", ve = "vao", be = "Width", Re = "Height", qe = Oe + be, et = Oe + Re, Xe = ee + be, it = ee + Re, Ft = "drawingBuffer", Ht = Ft + be, tr = Ft + Re, dr = [Ls, Ws, Ku, ue, w, oo, ee, Q, xu], Sr = 34962, Or = 34963, Wr = 2884, ni = 3042, Pi = 3024, cn = 2960, ln = 2929, Cn = 3089, Kn = 32823, Aa = 32926, fa = 32928, $a = 5126, Co = 35664, Qa = 35665, mo = 35666, Bo = 5124, Ps = 35667, Ts = 35668, wo = 35669, To = 35670, hl = 35671, Ul = 35672, Lu = 35673, au = 35674, Js = 35675, eu = 35676, dc = 35678, Tl = 35680, Al = 4, X = 1028, se = 1029, Te = 2304, Ne = 2305, He = 32775, Ye = 32776, kt = 519, nt = 7680, jt = 0, gr = 1, yr = 32774, Hr = 513, qr = 36160, _i = 36064, bi = { 0: 0, 1: 1, zero: 0, one: 1, "src color": 768, "one minus src color": 769, "src alpha": 770, "one minus src alpha": 771, "dst color": 774, "one minus dst color": 775, "dst alpha": 772, "one minus dst alpha": 773, "constant color": 32769, "one minus constant color": 32770, "constant alpha": 32771, "one minus constant alpha": 32772, "src alpha saturate": 776 }, Zr = { never: 512, less: 513, "<": 513, equal: 514, "=": 514, "==": 514, "===": 514, lequal: 515, "<=": 515, greater: 516, ">": 516, notequal: 517, "!=": 517, "!==": 517, gequal: 518, ">=": 518, always: 519 }, ai = { 0: 0, zero: 0, keep: 7680, replace: 7681, increment: 7682, decrement: 7683, "increment wrap": 34055, "decrement wrap": 34056, invert: 5386 }, gi = { cw: Te, ccw: Ne };
+          function Ii(Me) {
+            return Array.isArray(Me) || Br(Me) || Vr(Me);
+          }
+          function Si(Me) {
+            return Me.sort(function(bt, zt) {
+              return bt === ee ? -1 : zt === ee ? 1 : bt < zt ? -1 : 1;
+            });
+          }
+          function ei(Me, bt, zt, Rr) {
+            this.thisDep = Me, this.contextDep = bt, this.propDep = zt, this.append = Rr;
+          }
+          function Ln(Me) {
+            return Me && !(Me.thisDep || Me.contextDep || Me.propDep);
+          }
+          function En(Me) {
+            return new ei(false, false, false, Me);
+          }
+          function Un(Me, bt) {
+            var zt = Me.type;
+            if (zt === Yn) {
+              var Rr = Me.data.length;
+              return new ei(true, Rr >= 1, Rr >= 2, bt);
+            } else if (zt === Zo) {
+              var jr = Me.data;
+              return new ei(jr.thisDep, jr.contextDep, jr.propDep, bt);
+            } else {
+              if (zt === Ss) return new ei(false, false, false, bt);
+              if (zt === as) {
+                for (var Nr = false, Gr = false, mi = false, Ui = 0; Ui < Me.data.length; ++Ui) {
+                  var qi = Me.data[Ui];
+                  if (qi.type === Dn) mi = true;
+                  else if (qi.type === Ka) Gr = true;
+                  else if (qi.type === bo) Nr = true;
+                  else if (qi.type === Yn) {
+                    Nr = true;
+                    var Ei = qi.data;
+                    Ei >= 1 && (Gr = true), Ei >= 2 && (mi = true);
+                  } else qi.type === Zo && (Nr = Nr || qi.data.thisDep, Gr = Gr || qi.data.contextDep, mi = mi || qi.data.propDep);
+                }
+                return new ei(Nr, Gr, mi, bt);
+              } else return new ei(zt === bo, zt === Ka, zt === Dn, bt);
+            }
+          }
+          var ia = new ei(false, false, false, function() {
+          });
+          function Ea(Me, bt, zt, Rr, jr, Nr, Gr, mi, Ui, qi, Ei, Hn, en, Wi, si, Mr) {
+            var Yr = qi.Record, xi = { add: 32774, subtract: 32778, "reverse subtract": 32779 };
+            zt.ext_blend_minmax && (xi.min = He, xi.max = Ye);
+            var Ri = zt.angle_instanced_arrays, ci = zt.webgl_draw_buffers, an = zt.oes_vertex_array_object, Zi = { dirty: true, profile: Mr.profile }, Bn = {}, hi = [], li = {}, mn = {};
+            function Ji(Ve) {
+              return Ve.replace(".", "_");
+            }
+            function Vi(Ve, Qe, at) {
+              var Ct = Ji(Ve);
+              hi.push(Ve), Bn[Ct] = Zi[Ct] = !!at, li[Ct] = Qe;
+            }
+            function Ni(Ve, Qe, at) {
+              var Ct = Ji(Ve);
+              hi.push(Ve), Array.isArray(at) ? (Zi[Ct] = at.slice(), Bn[Ct] = at.slice()) : Zi[Ct] = Bn[Ct] = at, mn[Ct] = Qe;
+            }
+            function pn(Ve) {
+              return !!isNaN(Ve);
+            }
+            Vi(ws, Pi), Vi(Ho, ni), Ni(ml, "blendColor", [0, 0, 0, 0]), Ni(Ws, "blendEquationSeparate", [yr, yr]), Ni(Ls, "blendFuncSeparate", [gr, jt, gr, jt]), Vi(va, ln, true), Ni(no, "depthFunc", Hr), Ni(ys, "depthRange", [0, 1]), Ni(rs, "depthMask", true), Ni(Ql, Ql, [true, true, true, true]), Vi(Cu, Wr), Ni(Yu, "cullFace", se), Ni(Nc, Nc, Ne), Ni(pu, pu, 1), Vi(Uc, Kn), Ni(xu, "polygonOffset", [0, 0]), Vi(Ac, Aa), Vi(Ua, fa), Ni(oo, "sampleCoverage", [1, false]), Vi(Vc, cn), Ni(hc, "stencilMask", -1), Ni(Ku, "stencilFunc", [kt, 0, -1]), Ni(ue, "stencilOpSeparate", [X, nt, nt, nt]), Ni(w, "stencilOpSeparate", [se, nt, nt, nt]), Vi(B, Cn), Ni(Q, "scissor", [0, 0, Me.drawingBufferWidth, Me.drawingBufferHeight]), Ni(ee, ee, [0, 0, Me.drawingBufferWidth, Me.drawingBufferHeight]);
+            var Vn = { gl: Me, context: en, strings: bt, next: Bn, current: Zi, draw: Hn, elements: Nr, buffer: jr, shader: Ei, attributes: qi.state, vao: qi, uniforms: Ui, framebuffer: mi, extensions: zt, timer: Wi, isBufferArgs: Ii }, na = { primTypes: Sn, compareFuncs: Zr, blendFuncs: bi, blendEquations: xi, stencilOps: ai, glTypes: ji, orientationType: gi };
+            ci && (na.backBuffer = [se], na.drawBuffer = M(Rr.maxDrawbuffers, function(Ve) {
+              return Ve === 0 ? [0] : M(Ve, function(Qe) {
+                return _i + Qe;
+              });
+            }));
+            var Ki = 0;
+            function kn() {
+              var Ve = Qn({ cache: si }), Qe = Ve.link, at = Ve.global;
+              Ve.id = Ki++, Ve.batchId = "0";
+              var Ct = Qe(Vn), Ot = Ve.shared = { props: "a0" };
+              Object.keys(Vn).forEach(function(Pt) {
+                Ot[Pt] = at.def(Ct, ".", Pt);
+              });
+              var Rt = Ve.next = {}, Bt = Ve.current = {};
+              Object.keys(mn).forEach(function(Pt) {
+                Array.isArray(Zi[Pt]) && (Rt[Pt] = at.def(Ot.next, ".", Pt), Bt[Pt] = at.def(Ot.current, ".", Pt));
+              });
+              var Dt = Ve.constants = {};
+              Object.keys(na).forEach(function(Pt) {
+                Dt[Pt] = at.def(JSON.stringify(na[Pt]));
+              }), Ve.invoke = function(Pt, ht) {
+                switch (ht.type) {
+                  case Yn:
+                    var ur = ["this", Ot.context, Ot.props, Ve.batchId];
+                    return Pt.def(Qe(ht.data), ".call(", ur.slice(0, Math.max(ht.data.length + 1, 4)), ")");
+                  case Dn:
+                    return Pt.def(Ot.props, ht.data);
+                  case Ka:
+                    return Pt.def(Ot.context, ht.data);
+                  case bo:
+                    return Pt.def("this", ht.data);
+                  case Zo:
+                    return ht.data.append(Ve, Pt), ht.data.ref;
+                  case Ss:
+                    return ht.data.toString();
+                  case as:
+                    return ht.data.map(function(br) {
+                      return Ve.invoke(Pt, br);
+                    });
+                }
+              }, Ve.attribCache = {};
+              var yt = {};
+              return Ve.scopeAttrib = function(Pt) {
+                var ht = bt.id(Pt);
+                if (ht in yt) return yt[ht];
+                var ur = qi.scope[ht];
+                ur || (ur = qi.scope[ht] = new Yr());
+                var br = yt[ht] = Qe(ur);
+                return br;
+              }, Ve;
+            }
+            function ta(Ve) {
+              var Qe = Ve.static, at = Ve.dynamic, Ct;
+              if (le in Qe) {
+                var Ot = !!Qe[le];
+                Ct = En(function(Bt, Dt) {
+                  return Ot;
+                }), Ct.enable = Ot;
+              } else if (le in at) {
+                var Rt = at[le];
+                Ct = Un(Rt, function(Bt, Dt) {
+                  return Bt.invoke(Dt, Rt);
+                });
+              }
+              return Ct;
+            }
+            function oa(Ve, Qe) {
+              var at = Ve.static, Ct = Ve.dynamic;
+              if (Oe in at) {
+                var Ot = at[Oe];
+                return Ot ? (Ot = mi.getFramebuffer(Ot), En(function(Bt, Dt) {
+                  var yt = Bt.link(Ot), Pt = Bt.shared;
+                  Dt.set(Pt.framebuffer, ".next", yt);
+                  var ht = Pt.context;
+                  return Dt.set(ht, "." + qe, yt + ".width"), Dt.set(ht, "." + et, yt + ".height"), yt;
+                })) : En(function(Bt, Dt) {
+                  var yt = Bt.shared;
+                  Dt.set(yt.framebuffer, ".next", "null");
+                  var Pt = yt.context;
+                  return Dt.set(Pt, "." + qe, Pt + "." + Ht), Dt.set(Pt, "." + et, Pt + "." + tr), "null";
+                });
+              } else if (Oe in Ct) {
+                var Rt = Ct[Oe];
+                return Un(Rt, function(Bt, Dt) {
+                  var yt = Bt.invoke(Dt, Rt), Pt = Bt.shared, ht = Pt.framebuffer, ur = Dt.def(ht, ".getFramebuffer(", yt, ")");
+                  Dt.set(ht, ".next", ur);
+                  var br = Pt.context;
+                  return Dt.set(br, "." + qe, ur + "?" + ur + ".width:" + br + "." + Ht), Dt.set(br, "." + et, ur + "?" + ur + ".height:" + br + "." + tr), ur;
+                });
+              } else return null;
+            }
+            function ba(Ve, Qe, at) {
+              var Ct = Ve.static, Ot = Ve.dynamic;
+              function Rt(yt) {
+                if (yt in Ct) {
+                  var Pt = Ct[yt], ht = true, ur = Pt.x | 0, br = Pt.y | 0, Ur, Di;
+                  return "width" in Pt ? Ur = Pt.width | 0 : ht = false, "height" in Pt ? Di = Pt.height | 0 : ht = false, new ei(!ht && Qe && Qe.thisDep, !ht && Qe && Qe.contextDep, !ht && Qe && Qe.propDep, function(gn, rn) {
+                    var Ci = gn.shared.context, Bi = Ur;
+                    "width" in Pt || (Bi = rn.def(Ci, ".", qe, "-", ur));
+                    var Gi = Di;
+                    return "height" in Pt || (Gi = rn.def(Ci, ".", et, "-", br)), [ur, br, Bi, Gi];
+                  });
+                } else if (yt in Ot) {
+                  var fi = Ot[yt], Ti = Un(fi, function(gn, rn) {
+                    var Ci = gn.invoke(rn, fi), Bi = gn.shared.context, Gi = rn.def(Ci, ".x|0"), sn = rn.def(Ci, ".y|0"), zn = rn.def('"width" in ', Ci, "?", Ci, ".width|0:", "(", Bi, ".", qe, "-", Gi, ")"), Ja = rn.def('"height" in ', Ci, "?", Ci, ".height|0:", "(", Bi, ".", et, "-", sn, ")");
+                    return [Gi, sn, zn, Ja];
+                  });
+                  return Qe && (Ti.thisDep = Ti.thisDep || Qe.thisDep, Ti.contextDep = Ti.contextDep || Qe.contextDep, Ti.propDep = Ti.propDep || Qe.propDep), Ti;
+                } else return Qe ? new ei(Qe.thisDep, Qe.contextDep, Qe.propDep, function(gn, rn) {
+                  var Ci = gn.shared.context;
+                  return [0, 0, rn.def(Ci, ".", qe), rn.def(Ci, ".", et)];
+                }) : null;
+              }
+              var Bt = Rt(ee);
+              if (Bt) {
+                var Dt = Bt;
+                Bt = new ei(Bt.thisDep, Bt.contextDep, Bt.propDep, function(yt, Pt) {
+                  var ht = Dt.append(yt, Pt), ur = yt.shared.context;
+                  return Pt.set(ur, "." + Xe, ht[2]), Pt.set(ur, "." + it, ht[3]), ht;
+                });
+              }
+              return { viewport: Bt, scissor_box: Rt(Q) };
+            }
+            function is(Ve, Qe) {
+              var at = Ve.static, Ct = typeof at[st] == "string" && typeof at[Ze] == "string";
+              if (Ct) {
+                if (Object.keys(Qe.dynamic).length > 0) return null;
+                var Ot = Qe.static, Rt = Object.keys(Ot);
+                if (Rt.length > 0 && typeof Ot[Rt[0]] == "number") {
+                  for (var Bt = [], Dt = 0; Dt < Rt.length; ++Dt) Bt.push([Ot[Rt[Dt]] | 0, Rt[Dt]]);
+                  return Bt;
+                }
+              }
+              return null;
+            }
+            function Zs(Ve, Qe, at) {
+              var Ct = Ve.static, Ot = Ve.dynamic;
+              function Rt(ht) {
+                if (ht in Ct) {
+                  var ur = bt.id(Ct[ht]), br = En(function() {
+                    return ur;
+                  });
+                  return br.id = ur, br;
+                } else if (ht in Ot) {
+                  var Ur = Ot[ht];
+                  return Un(Ur, function(Di, fi) {
+                    var Ti = Di.invoke(fi, Ur), gn = fi.def(Di.shared.strings, ".id(", Ti, ")");
+                    return gn;
+                  });
+                }
+                return null;
+              }
+              var Bt = Rt(st), Dt = Rt(Ze), yt = null, Pt;
+              return Ln(Bt) && Ln(Dt) ? (yt = Ei.program(Dt.id, Bt.id, null, at), Pt = En(function(ht, ur) {
+                return ht.link(yt);
+              })) : Pt = new ei(Bt && Bt.thisDep || Dt && Dt.thisDep, Bt && Bt.contextDep || Dt && Dt.contextDep, Bt && Bt.propDep || Dt && Dt.propDep, function(ht, ur) {
+                var br = ht.shared.shader, Ur;
+                Bt ? Ur = Bt.append(ht, ur) : Ur = ur.def(br, ".", st);
+                var Di;
+                Dt ? Di = Dt.append(ht, ur) : Di = ur.def(br, ".", Ze);
+                var fi = br + ".program(" + Di + "," + Ur;
+                return ur.def(fi + ")");
+              }), { frag: Bt, vert: Dt, progVar: Pt, program: yt };
+            }
+            function Va(Ve, Qe) {
+              var at = Ve.static, Ct = Ve.dynamic, Ot = {}, Rt = false;
+              function Bt() {
+                if (ve in at) {
+                  var rn = at[ve];
+                  return rn !== null && qi.getVAO(rn) === null && (rn = qi.createVAO(rn)), Rt = true, Ot.vao = rn, En(function(Bi) {
+                    var Gi = qi.getVAO(rn);
+                    return Gi ? Bi.link(Gi) : "null";
+                  });
+                } else if (ve in Ct) {
+                  Rt = true;
+                  var Ci = Ct[ve];
+                  return Un(Ci, function(Bi, Gi) {
+                    var sn = Bi.invoke(Gi, Ci);
+                    return Gi.def(Bi.shared.vao + ".getVAO(" + sn + ")");
+                  });
+                }
+                return null;
+              }
+              var Dt = Bt(), yt = false;
+              function Pt() {
+                if (Tt in at) {
+                  var rn = at[Tt];
+                  if (Ot.elements = rn, Ii(rn)) {
+                    var Ci = Ot.elements = Nr.create(rn, true);
+                    rn = Nr.getElements(Ci), yt = true;
+                  } else rn && (rn = Nr.getElements(rn), yt = true);
+                  var Bi = En(function(sn, zn) {
+                    if (rn) {
+                      var Ja = sn.link(rn);
+                      return sn.ELEMENTS = Ja, Ja;
+                    }
+                    return sn.ELEMENTS = null, null;
+                  });
+                  return Bi.value = rn, Bi;
+                } else if (Tt in Ct) {
+                  yt = true;
+                  var Gi = Ct[Tt];
+                  return Un(Gi, function(sn, zn) {
+                    var Ja = sn.shared, co = Ja.isBufferArgs, ts = Ja.elements, so = sn.invoke(zn, Gi), Yo = zn.def("null"), ms = zn.def(co, "(", so, ")"), ou = sn.cond(ms).then(Yo, "=", ts, ".createStream(", so, ");").else(Yo, "=", ts, ".getElements(", so, ");");
+                    return zn.entry(ou), zn.exit(sn.cond(ms).then(ts, ".destroyStream(", Yo, ");")), sn.ELEMENTS = Yo, Yo;
+                  });
+                } else if (Rt) return new ei(Dt.thisDep, Dt.contextDep, Dt.propDep, function(sn, zn) {
+                  return zn.def(sn.shared.vao + ".currentVAO?" + sn.shared.elements + ".getElements(" + sn.shared.vao + ".currentVAO.elements):null");
+                });
+                return null;
+              }
+              var ht = Pt();
+              function ur() {
+                if (Yt in at) {
+                  var rn = at[Yt];
+                  return Ot.primitive = rn, En(function(Bi, Gi) {
+                    return Sn[rn];
+                  });
+                } else if (Yt in Ct) {
+                  var Ci = Ct[Yt];
+                  return Un(Ci, function(Bi, Gi) {
+                    var sn = Bi.constants.primTypes, zn = Bi.invoke(Gi, Ci);
+                    return Gi.def(sn, "[", zn, "]");
+                  });
+                } else {
+                  if (yt) return Ln(ht) ? ht.value ? En(function(Bi, Gi) {
+                    return Gi.def(Bi.ELEMENTS, ".primType");
+                  }) : En(function() {
+                    return Al;
+                  }) : new ei(ht.thisDep, ht.contextDep, ht.propDep, function(Bi, Gi) {
+                    var sn = Bi.ELEMENTS;
+                    return Gi.def(sn, "?", sn, ".primType:", Al);
+                  });
+                  if (Rt) return new ei(Dt.thisDep, Dt.contextDep, Dt.propDep, function(Bi, Gi) {
+                    return Gi.def(Bi.shared.vao + ".currentVAO?" + Bi.shared.vao + ".currentVAO.primitive:" + Al);
+                  });
+                }
+                return null;
+              }
+              function br(rn, Ci) {
+                if (rn in at) {
+                  var Bi = at[rn] | 0;
+                  return Ci ? Ot.offset = Bi : Ot.instances = Bi, En(function(sn, zn) {
+                    return Ci && (sn.OFFSET = Bi), Bi;
+                  });
+                } else if (rn in Ct) {
+                  var Gi = Ct[rn];
+                  return Un(Gi, function(sn, zn) {
+                    var Ja = sn.invoke(zn, Gi);
+                    return Ci && (sn.OFFSET = Ja), Ja;
+                  });
+                } else if (Ci) {
+                  if (yt) return En(function(sn, zn) {
+                    return sn.OFFSET = 0, 0;
+                  });
+                  if (Rt) return new ei(Dt.thisDep, Dt.contextDep, Dt.propDep, function(sn, zn) {
+                    return zn.def(sn.shared.vao + ".currentVAO?" + sn.shared.vao + ".currentVAO.offset:0");
+                  });
+                } else if (Rt) return new ei(Dt.thisDep, Dt.contextDep, Dt.propDep, function(sn, zn) {
+                  return zn.def(sn.shared.vao + ".currentVAO?" + sn.shared.vao + ".currentVAO.instances:-1");
+                });
+                return null;
+              }
+              var Ur = br(xr, true);
+              function Di() {
+                if (Kt in at) {
+                  var rn = at[Kt] | 0;
+                  return Ot.count = rn, En(function() {
+                    return rn;
+                  });
+                } else if (Kt in Ct) {
+                  var Ci = Ct[Kt];
+                  return Un(Ci, function(zn, Ja) {
+                    var co = zn.invoke(Ja, Ci);
+                    return co;
+                  });
+                } else if (yt) if (Ln(ht)) {
+                  if (ht) return Ur ? new ei(Ur.thisDep, Ur.contextDep, Ur.propDep, function(zn, Ja) {
+                    var co = Ja.def(zn.ELEMENTS, ".vertCount-", zn.OFFSET);
+                    return co;
+                  }) : En(function(zn, Ja) {
+                    return Ja.def(zn.ELEMENTS, ".vertCount");
+                  });
+                  var Bi = En(function() {
+                    return -1;
+                  });
+                  return Bi;
+                } else {
+                  var Gi = new ei(ht.thisDep || Ur.thisDep, ht.contextDep || Ur.contextDep, ht.propDep || Ur.propDep, function(zn, Ja) {
+                    var co = zn.ELEMENTS;
+                    return zn.OFFSET ? Ja.def(co, "?", co, ".vertCount-", zn.OFFSET, ":-1") : Ja.def(co, "?", co, ".vertCount:-1");
+                  });
+                  return Gi;
+                }
+                else if (Rt) {
+                  var sn = new ei(Dt.thisDep, Dt.contextDep, Dt.propDep, function(zn, Ja) {
+                    return Ja.def(zn.shared.vao, ".currentVAO?", zn.shared.vao, ".currentVAO.count:-1");
+                  });
+                  return sn;
+                }
+                return null;
+              }
+              var fi = ur(), Ti = Di(), gn = br(Ir, false);
+              return { elements: ht, primitive: fi, count: Ti, instances: gn, offset: Ur, vao: Dt, vaoActive: Rt, elementsActive: yt, static: Ot };
+            }
+            function Ml(Ve, Qe) {
+              var at = Ve.static, Ct = Ve.dynamic, Ot = {};
+              return hi.forEach(function(Rt) {
+                var Bt = Ji(Rt);
+                function Dt(yt, Pt) {
+                  if (Rt in at) {
+                    var ht = yt(at[Rt]);
+                    Ot[Bt] = En(function() {
+                      return ht;
+                    });
+                  } else if (Rt in Ct) {
+                    var ur = Ct[Rt];
+                    Ot[Bt] = Un(ur, function(br, Ur) {
+                      return Pt(br, Ur, br.invoke(Ur, ur));
+                    });
+                  }
+                }
+                switch (Rt) {
+                  case Cu:
+                  case Ho:
+                  case ws:
+                  case Vc:
+                  case va:
+                  case B:
+                  case Uc:
+                  case Ac:
+                  case Ua:
+                  case rs:
+                    return Dt(function(yt) {
+                      return yt;
+                    }, function(yt, Pt, ht) {
+                      return ht;
+                    });
+                  case no:
+                    return Dt(function(yt) {
+                      return Zr[yt];
+                    }, function(yt, Pt, ht) {
+                      var ur = yt.constants.compareFuncs;
+                      return Pt.def(ur, "[", ht, "]");
+                    });
+                  case ys:
+                    return Dt(function(yt) {
+                      return yt;
+                    }, function(yt, Pt, ht) {
+                      var ur = Pt.def("+", ht, "[0]"), br = Pt.def("+", ht, "[1]");
+                      return [ur, br];
+                    });
+                  case Ls:
+                    return Dt(function(yt) {
+                      var Pt = "srcRGB" in yt ? yt.srcRGB : yt.src, ht = "srcAlpha" in yt ? yt.srcAlpha : yt.src, ur = "dstRGB" in yt ? yt.dstRGB : yt.dst, br = "dstAlpha" in yt ? yt.dstAlpha : yt.dst;
+                      return [bi[Pt], bi[ur], bi[ht], bi[br]];
+                    }, function(yt, Pt, ht) {
+                      var ur = yt.constants.blendFuncs;
+                      function br(Ci, Bi) {
+                        var Gi = Pt.def('"', Ci, Bi, '" in ', ht, "?", ht, ".", Ci, Bi, ":", ht, ".", Ci);
+                        return Gi;
+                      }
+                      var Ur = br("src", "RGB"), Di = br("dst", "RGB"), fi = Pt.def(ur, "[", Ur, "]"), Ti = Pt.def(ur, "[", br("src", "Alpha"), "]"), gn = Pt.def(ur, "[", Di, "]"), rn = Pt.def(ur, "[", br("dst", "Alpha"), "]");
+                      return [fi, gn, Ti, rn];
+                    });
+                  case Ws:
+                    return Dt(function(yt) {
+                      if (typeof yt == "string") return [xi[yt], xi[yt]];
+                      if (typeof yt == "object") return [xi[yt.rgb], xi[yt.alpha]];
+                    }, function(yt, Pt, ht) {
+                      var ur = yt.constants.blendEquations, br = Pt.def(), Ur = Pt.def(), Di = yt.cond("typeof ", ht, '==="string"');
+                      return Di.then(br, "=", Ur, "=", ur, "[", ht, "];"), Di.else(br, "=", ur, "[", ht, ".rgb];", Ur, "=", ur, "[", ht, ".alpha];"), Pt(Di), [br, Ur];
+                    });
+                  case ml:
+                    return Dt(function(yt) {
+                      return M(4, function(Pt) {
+                        return +yt[Pt];
+                      });
+                    }, function(yt, Pt, ht) {
+                      return M(4, function(ur) {
+                        return Pt.def("+", ht, "[", ur, "]");
+                      });
+                    });
+                  case hc:
+                    return Dt(function(yt) {
+                      return yt | 0;
+                    }, function(yt, Pt, ht) {
+                      return Pt.def(ht, "|0");
+                    });
+                  case Ku:
+                    return Dt(function(yt) {
+                      var Pt = yt.cmp || "keep", ht = yt.ref || 0, ur = "mask" in yt ? yt.mask : -1;
+                      return [Zr[Pt], ht, ur];
+                    }, function(yt, Pt, ht) {
+                      var ur = yt.constants.compareFuncs, br = Pt.def('"cmp" in ', ht, "?", ur, "[", ht, ".cmp]", ":", nt), Ur = Pt.def(ht, ".ref|0"), Di = Pt.def('"mask" in ', ht, "?", ht, ".mask|0:-1");
+                      return [br, Ur, Di];
+                    });
+                  case ue:
+                  case w:
+                    return Dt(function(yt) {
+                      var Pt = yt.fail || "keep", ht = yt.zfail || "keep", ur = yt.zpass || "keep";
+                      return [Rt === w ? se : X, ai[Pt], ai[ht], ai[ur]];
+                    }, function(yt, Pt, ht) {
+                      var ur = yt.constants.stencilOps;
+                      function br(Ur) {
+                        return Pt.def('"', Ur, '" in ', ht, "?", ur, "[", ht, ".", Ur, "]:", nt);
+                      }
+                      return [Rt === w ? se : X, br("fail"), br("zfail"), br("zpass")];
+                    });
+                  case xu:
+                    return Dt(function(yt) {
+                      var Pt = yt.factor | 0, ht = yt.units | 0;
+                      return [Pt, ht];
+                    }, function(yt, Pt, ht) {
+                      var ur = Pt.def(ht, ".factor|0"), br = Pt.def(ht, ".units|0");
+                      return [ur, br];
+                    });
+                  case Yu:
+                    return Dt(function(yt) {
+                      var Pt = 0;
+                      return yt === "front" ? Pt = X : yt === "back" && (Pt = se), Pt;
+                    }, function(yt, Pt, ht) {
+                      return Pt.def(ht, '==="front"?', X, ":", se);
+                    });
+                  case pu:
+                    return Dt(function(yt) {
+                      return yt;
+                    }, function(yt, Pt, ht) {
+                      return ht;
+                    });
+                  case Nc:
+                    return Dt(function(yt) {
+                      return gi[yt];
+                    }, function(yt, Pt, ht) {
+                      return Pt.def(ht + '==="cw"?' + Te + ":" + Ne);
+                    });
+                  case Ql:
+                    return Dt(function(yt) {
+                      return yt.map(function(Pt) {
+                        return !!Pt;
+                      });
+                    }, function(yt, Pt, ht) {
+                      return M(4, function(ur) {
+                        return "!!" + ht + "[" + ur + "]";
+                      });
+                    });
+                  case oo:
+                    return Dt(function(yt) {
+                      var Pt = "value" in yt ? yt.value : 1, ht = !!yt.invert;
+                      return [Pt, ht];
+                    }, function(yt, Pt, ht) {
+                      var ur = Pt.def('"value" in ', ht, "?+", ht, ".value:1"), br = Pt.def("!!", ht, ".invert");
+                      return [ur, br];
+                    });
+                }
+              }), Ot;
+            }
+            function zo(Ve, Qe) {
+              var at = Ve.static, Ct = Ve.dynamic, Ot = {};
+              return Object.keys(at).forEach(function(Rt) {
+                var Bt = at[Rt], Dt;
+                if (typeof Bt == "number" || typeof Bt == "boolean") Dt = En(function() {
+                  return Bt;
+                });
+                else if (typeof Bt == "function") {
+                  var yt = Bt._reglType;
+                  yt === "texture2d" || yt === "textureCube" ? Dt = En(function(Pt) {
+                    return Pt.link(Bt);
+                  }) : (yt === "framebuffer" || yt === "framebufferCube") && (Dt = En(function(Pt) {
+                    return Pt.link(Bt.color[0]);
+                  }));
+                } else Mn(Bt) && (Dt = En(function(Pt) {
+                  var ht = Pt.global.def("[", M(Bt.length, function(ur) {
+                    return Bt[ur];
+                  }), "]");
+                  return ht;
+                }));
+                Dt.value = Bt, Ot[Rt] = Dt;
+              }), Object.keys(Ct).forEach(function(Rt) {
+                var Bt = Ct[Rt];
+                Ot[Rt] = Un(Bt, function(Dt, yt) {
+                  return Dt.invoke(yt, Bt);
+                });
+              }), Ot;
+            }
+            function Qs(Ve, Qe) {
+              var at = Ve.static, Ct = Ve.dynamic, Ot = {};
+              return Object.keys(at).forEach(function(Rt) {
+                var Bt = at[Rt], Dt = bt.id(Rt), yt = new Yr();
+                if (Ii(Bt)) yt.state = La, yt.buffer = jr.getBuffer(jr.create(Bt, Sr, false, true)), yt.type = 0;
+                else {
+                  var Pt = jr.getBuffer(Bt);
+                  if (Pt) yt.state = La, yt.buffer = Pt, yt.type = 0;
+                  else if ("constant" in Bt) {
+                    var ht = Bt.constant;
+                    yt.buffer = "null", yt.state = Na, typeof ht == "number" ? yt.x = ht : Ca.forEach(function(gn, rn) {
+                      rn < ht.length && (yt[gn] = ht[rn]);
+                    });
+                  } else {
+                    Ii(Bt.buffer) ? Pt = jr.getBuffer(jr.create(Bt.buffer, Sr, false, true)) : Pt = jr.getBuffer(Bt.buffer);
+                    var ur = Bt.offset | 0, br = Bt.stride | 0, Ur = Bt.size | 0, Di = !!Bt.normalized, fi = 0;
+                    "type" in Bt && (fi = ji[Bt.type]);
+                    var Ti = Bt.divisor | 0;
+                    yt.buffer = Pt, yt.state = La, yt.size = Ur, yt.normalized = Di, yt.type = fi || Pt.dtype, yt.offset = ur, yt.stride = br, yt.divisor = Ti;
+                  }
+                }
+                Ot[Rt] = En(function(gn, rn) {
+                  var Ci = gn.attribCache;
+                  if (Dt in Ci) return Ci[Dt];
+                  var Bi = { isStream: false };
+                  return Object.keys(yt).forEach(function(Gi) {
+                    Bi[Gi] = yt[Gi];
+                  }), yt.buffer && (Bi.buffer = gn.link(yt.buffer), Bi.type = Bi.type || Bi.buffer + ".dtype"), Ci[Dt] = Bi, Bi;
+                });
+              }), Object.keys(Ct).forEach(function(Rt) {
+                var Bt = Ct[Rt];
+                function Dt(yt, Pt) {
+                  var ht = yt.invoke(Pt, Bt), ur = yt.shared, br = yt.constants, Ur = ur.isBufferArgs, Di = ur.buffer, fi = { isStream: Pt.def(false) }, Ti = new Yr();
+                  Ti.state = La, Object.keys(Ti).forEach(function(Bi) {
+                    fi[Bi] = Pt.def("" + Ti[Bi]);
+                  });
+                  var gn = fi.buffer, rn = fi.type;
+                  Pt("if(", Ur, "(", ht, ")){", fi.isStream, "=true;", gn, "=", Di, ".createStream(", Sr, ",", ht, ");", rn, "=", gn, ".dtype;", "}else{", gn, "=", Di, ".getBuffer(", ht, ");", "if(", gn, "){", rn, "=", gn, ".dtype;", '}else if("constant" in ', ht, "){", fi.state, "=", Na, ";", "if(typeof " + ht + '.constant === "number"){', fi[Ca[0]], "=", ht, ".constant;", Ca.slice(1).map(function(Bi) {
+                    return fi[Bi];
+                  }).join("="), "=0;", "}else{", Ca.map(function(Bi, Gi) {
+                    return fi[Bi] + "=" + ht + ".constant.length>" + Gi + "?" + ht + ".constant[" + Gi + "]:0;";
+                  }).join(""), "}}else{", "if(", Ur, "(", ht, ".buffer)){", gn, "=", Di, ".createStream(", Sr, ",", ht, ".buffer);", "}else{", gn, "=", Di, ".getBuffer(", ht, ".buffer);", "}", rn, '="type" in ', ht, "?", br.glTypes, "[", ht, ".type]:", gn, ".dtype;", fi.normalized, "=!!", ht, ".normalized;");
+                  function Ci(Bi) {
+                    Pt(fi[Bi], "=", ht, ".", Bi, "|0;");
+                  }
+                  return Ci("size"), Ci("offset"), Ci("stride"), Ci("divisor"), Pt("}}"), Pt.exit("if(", fi.isStream, "){", Di, ".destroyStream(", gn, ");", "}"), fi;
+                }
+                Ot[Rt] = Un(Bt, Dt);
+              }), Ot;
+            }
+            function al(Ve) {
+              var Qe = Ve.static, at = Ve.dynamic, Ct = {};
+              return Object.keys(Qe).forEach(function(Ot) {
+                var Rt = Qe[Ot];
+                Ct[Ot] = En(function(Bt, Dt) {
+                  return typeof Rt == "number" || typeof Rt == "boolean" ? "" + Rt : Bt.link(Rt);
+                });
+              }), Object.keys(at).forEach(function(Ot) {
+                var Rt = at[Ot];
+                Ct[Ot] = Un(Rt, function(Bt, Dt) {
+                  return Bt.invoke(Dt, Rt);
+                });
+              }), Ct;
+            }
+            function Vl(Ve, Qe, at, Ct, Ot) {
+              Ve.static;
+              Ve.dynamic;
+              var Dt = is(Ve, Qe), yt = oa(Ve), Pt = ba(Ve, yt), ht = Va(Ve), ur = Ml(Ve), br = Zs(Ve, Ot, Dt);
+              function Ur(Ci) {
+                var Bi = Pt[Ci];
+                Bi && (ur[Ci] = Bi);
+              }
+              Ur(ee), Ur(Ji(Q));
+              var Di = Object.keys(ur).length > 0, fi = { framebuffer: yt, draw: ht, shader: br, state: ur, dirty: Di, scopeVAO: null, drawVAO: null, useVAO: false, attributes: {} };
+              if (fi.profile = ta(Ve), fi.uniforms = zo(at), fi.drawVAO = fi.scopeVAO = ht.vao, !fi.drawVAO && br.program && !Dt && zt.angle_instanced_arrays && ht.static.elements) {
+                var Ti = true, gn = br.program.attributes.map(function(Ci) {
+                  var Bi = Qe.static[Ci];
+                  return Ti = Ti && !!Bi, Bi;
+                });
+                if (Ti && gn.length > 0) {
+                  var rn = qi.getVAO(qi.createVAO({ attributes: gn, elements: ht.static.elements }));
+                  fi.drawVAO = new ei(null, null, null, function(Ci, Bi) {
+                    return Ci.link(rn);
+                  }), fi.useVAO = true;
+                }
+              }
+              return Dt ? fi.useVAO = true : fi.attributes = Qs(Qe), fi.context = al(Ct), fi;
+            }
+            function ss(Ve, Qe, at) {
+              var Ct = Ve.shared, Ot = Ct.context, Rt = Ve.scope();
+              Object.keys(at).forEach(function(Bt) {
+                Qe.save(Ot, "." + Bt);
+                var Dt = at[Bt], yt = Dt.append(Ve, Qe);
+                Array.isArray(yt) ? Rt(Ot, ".", Bt, "=[", yt.join(), "];") : Rt(Ot, ".", Bt, "=", yt, ";");
+              }), Qe(Rt);
+            }
+            function Vs(Ve, Qe, at, Ct) {
+              var Ot = Ve.shared, Rt = Ot.gl, Bt = Ot.framebuffer, Dt;
+              ci && (Dt = Qe.def(Ot.extensions, ".webgl_draw_buffers"));
+              var yt = Ve.constants, Pt = yt.drawBuffer, ht = yt.backBuffer, ur;
+              at ? ur = at.append(Ve, Qe) : ur = Qe.def(Bt, ".next"), Ct || Qe("if(", ur, "!==", Bt, ".cur){"), Qe("if(", ur, "){", Rt, ".bindFramebuffer(", qr, ",", ur, ".framebuffer);"), ci && Qe(Dt, ".drawBuffersWEBGL(", Pt, "[", ur, ".colorAttachments.length]);"), Qe("}else{", Rt, ".bindFramebuffer(", qr, ",null);"), ci && Qe(Dt, ".drawBuffersWEBGL(", ht, ");"), Qe("}", Bt, ".cur=", ur, ";"), Ct || Qe("}");
+            }
+            function Ys(Ve, Qe, at) {
+              var Ct = Ve.shared, Ot = Ct.gl, Rt = Ve.current, Bt = Ve.next, Dt = Ct.current, yt = Ct.next, Pt = Ve.cond(Dt, ".dirty");
+              hi.forEach(function(ht) {
+                var ur = Ji(ht);
+                if (!(ur in at.state)) {
+                  var br, Ur;
+                  if (ur in Bt) {
+                    br = Bt[ur], Ur = Rt[ur];
+                    var Di = M(Zi[ur].length, function(Ti) {
+                      return Pt.def(br, "[", Ti, "]");
+                    });
+                    Pt(Ve.cond(Di.map(function(Ti, gn) {
+                      return Ti + "!==" + Ur + "[" + gn + "]";
+                    }).join("||")).then(Ot, ".", mn[ur], "(", Di, ");", Di.map(function(Ti, gn) {
+                      return Ur + "[" + gn + "]=" + Ti;
+                    }).join(";"), ";"));
+                  } else {
+                    br = Pt.def(yt, ".", ur);
+                    var fi = Ve.cond(br, "!==", Dt, ".", ur);
+                    Pt(fi), ur in li ? fi(Ve.cond(br).then(Ot, ".enable(", li[ur], ");").else(Ot, ".disable(", li[ur], ");"), Dt, ".", ur, "=", br, ";") : fi(Ot, ".", mn[ur], "(", br, ");", Dt, ".", ur, "=", br, ";");
+                  }
+                }
+              }), Object.keys(at.state).length === 0 && Pt(Dt, ".dirty=false;"), Qe(Pt);
+            }
+            function wa(Ve, Qe, at, Ct) {
+              var Ot = Ve.shared, Rt = Ve.current, Bt = Ot.current, Dt = Ot.gl, yt;
+              Si(Object.keys(at)).forEach(function(Pt) {
+                var ht = at[Pt];
+                if (!(Ct && !Ct(ht))) {
+                  var ur = ht.append(Ve, Qe);
+                  if (li[Pt]) {
+                    var br = li[Pt];
+                    Ln(ht) ? (yt = Ve.link(ur, { stable: true }), Qe(Ve.cond(yt).then(Dt, ".enable(", br, ");").else(Dt, ".disable(", br, ");")), Qe(Bt, ".", Pt, "=", yt, ";")) : (Qe(Ve.cond(ur).then(Dt, ".enable(", br, ");").else(Dt, ".disable(", br, ");")), Qe(Bt, ".", Pt, "=", ur, ";"));
+                  } else if (Mn(ur)) {
+                    var Ur = Rt[Pt];
+                    Qe(Dt, ".", mn[Pt], "(", ur, ");", ur.map(function(Di, fi) {
+                      return Ur + "[" + fi + "]=" + Di;
+                    }).join(";"), ";");
+                  } else Ln(ht) ? (yt = Ve.link(ur, { stable: true }), Qe(Dt, ".", mn[Pt], "(", yt, ");", Bt, ".", Pt, "=", yt, ";")) : Qe(Dt, ".", mn[Pt], "(", ur, ");", Bt, ".", Pt, "=", ur, ";");
+                }
+              });
+            }
+            function ol(Ve, Qe) {
+              Ri && (Ve.instancing = Qe.def(Ve.shared.extensions, ".angle_instanced_arrays"));
+            }
+            function io(Ve, Qe, at, Ct, Ot) {
+              var Rt = Ve.shared, Bt = Ve.stats, Dt = Rt.current, yt = Rt.timer, Pt = at.profile;
+              function ht() {
+                return typeof performance == "undefined" ? "Date.now()" : "performance.now()";
+              }
+              var ur, br;
+              function Ur(Ci) {
+                ur = Qe.def(), Ci(ur, "=", ht(), ";"), typeof Ot == "string" ? Ci(Bt, ".count+=", Ot, ";") : Ci(Bt, ".count++;"), Wi && (Ct ? (br = Qe.def(), Ci(br, "=", yt, ".getNumPendingQueries();")) : Ci(yt, ".beginQuery(", Bt, ");"));
+              }
+              function Di(Ci) {
+                Ci(Bt, ".cpuTime+=", ht(), "-", ur, ";"), Wi && (Ct ? Ci(yt, ".pushScopeStats(", br, ",", yt, ".getNumPendingQueries(),", Bt, ");") : Ci(yt, ".endQuery();"));
+              }
+              function fi(Ci) {
+                var Bi = Qe.def(Dt, ".profile");
+                Qe(Dt, ".profile=", Ci, ";"), Qe.exit(Dt, ".profile=", Bi, ";");
+              }
+              var Ti;
+              if (Pt) {
+                if (Ln(Pt)) {
+                  Pt.enable ? (Ur(Qe), Di(Qe.exit), fi("true")) : fi("false");
+                  return;
+                }
+                Ti = Pt.append(Ve, Qe), fi(Ti);
+              } else Ti = Qe.def(Dt, ".profile");
+              var gn = Ve.block();
+              Ur(gn), Qe("if(", Ti, "){", gn, "}");
+              var rn = Ve.block();
+              Di(rn), Qe.exit("if(", Ti, "){", rn, "}");
+            }
+            function Y(Ve, Qe, at, Ct, Ot) {
+              var Rt = Ve.shared;
+              function Bt(yt) {
+                switch (yt) {
+                  case Co:
+                  case Ps:
+                  case hl:
+                    return 2;
+                  case Qa:
+                  case Ts:
+                  case Ul:
+                    return 3;
+                  case mo:
+                  case wo:
+                  case Lu:
+                    return 4;
+                  default:
+                    return 1;
+                }
+              }
+              function Dt(yt, Pt, ht) {
+                var ur = Rt.gl, br = Qe.def(yt, ".location"), Ur = Qe.def(Rt.attributes, "[", br, "]"), Di = ht.state, fi = ht.buffer, Ti = [ht.x, ht.y, ht.z, ht.w], gn = ["buffer", "normalized", "offset", "stride"];
+                function rn() {
+                  Qe("if(!", Ur, ".buffer){", ur, ".enableVertexAttribArray(", br, ");}");
+                  var Bi = ht.type, Gi;
+                  if (ht.size ? Gi = Qe.def(ht.size, "||", Pt) : Gi = Pt, Qe("if(", Ur, ".type!==", Bi, "||", Ur, ".size!==", Gi, "||", gn.map(function(zn) {
+                    return Ur + "." + zn + "!==" + ht[zn];
+                  }).join("||"), "){", ur, ".bindBuffer(", Sr, ",", fi, ".buffer);", ur, ".vertexAttribPointer(", [br, Gi, Bi, ht.normalized, ht.stride, ht.offset], ");", Ur, ".type=", Bi, ";", Ur, ".size=", Gi, ";", gn.map(function(zn) {
+                    return Ur + "." + zn + "=" + ht[zn] + ";";
+                  }).join(""), "}"), Ri) {
+                    var sn = ht.divisor;
+                    Qe("if(", Ur, ".divisor!==", sn, "){", Ve.instancing, ".vertexAttribDivisorANGLE(", [br, sn], ");", Ur, ".divisor=", sn, ";}");
+                  }
+                }
+                function Ci() {
+                  Qe("if(", Ur, ".buffer){", ur, ".disableVertexAttribArray(", br, ");", Ur, ".buffer=null;", "}if(", Ca.map(function(Bi, Gi) {
+                    return Ur + "." + Bi + "!==" + Ti[Gi];
+                  }).join("||"), "){", ur, ".vertexAttrib4f(", br, ",", Ti, ");", Ca.map(function(Bi, Gi) {
+                    return Ur + "." + Bi + "=" + Ti[Gi] + ";";
+                  }).join(""), "}");
+                }
+                Di === La ? rn() : Di === Na ? Ci() : (Qe("if(", Di, "===", La, "){"), rn(), Qe("}else{"), Ci(), Qe("}"));
+              }
+              Ct.forEach(function(yt) {
+                var Pt = yt.name, ht = at.attributes[Pt], ur;
+                if (ht) {
+                  if (!Ot(ht)) return;
+                  ur = ht.append(Ve, Qe);
+                } else {
+                  if (!Ot(ia)) return;
+                  var br = Ve.scopeAttrib(Pt);
+                  ur = {}, Object.keys(new Yr()).forEach(function(Ur) {
+                    ur[Ur] = Qe.def(br, ".", Ur);
+                  });
+                }
+                Dt(Ve.link(yt), Bt(yt.info.type), ur);
+              });
+            }
+            function D(Ve, Qe, at, Ct, Ot, Rt) {
+              for (var Bt = Ve.shared, Dt = Bt.gl, yt, Pt = 0; Pt < Ct.length; ++Pt) {
+                var ht = Ct[Pt], ur = ht.name, br = ht.info.type, Ur = at.uniforms[ur], Di = Ve.link(ht), fi = Di + ".location", Ti;
+                if (Ur) {
+                  if (!Ot(Ur)) continue;
+                  if (Ln(Ur)) {
+                    var gn = Ur.value;
+                    if (br === dc || br === Tl) {
+                      var rn = Ve.link(gn._texture || gn.color[0]._texture);
+                      Qe(Dt, ".uniform1i(", fi, ",", rn + ".bind());"), Qe.exit(rn, ".unbind();");
+                    } else if (br === au || br === Js || br === eu) {
+                      var Ci = Ve.global.def("new Float32Array([" + Array.prototype.slice.call(gn) + "])"), Bi = 2;
+                      br === Js ? Bi = 3 : br === eu && (Bi = 4), Qe(Dt, ".uniformMatrix", Bi, "fv(", fi, ",false,", Ci, ");");
+                    } else {
+                      switch (br) {
+                        case $a:
+                          yt = "1f";
+                          break;
+                        case Co:
+                          yt = "2f";
+                          break;
+                        case Qa:
+                          yt = "3f";
+                          break;
+                        case mo:
+                          yt = "4f";
+                          break;
+                        case To:
+                          yt = "1i";
+                          break;
+                        case Bo:
+                          yt = "1i";
+                          break;
+                        case hl:
+                          yt = "2i";
+                          break;
+                        case Ps:
+                          yt = "2i";
+                          break;
+                        case Ul:
+                          yt = "3i";
+                          break;
+                        case Ts:
+                          yt = "3i";
+                          break;
+                        case Lu:
+                          yt = "4i";
+                          break;
+                        case wo:
+                          yt = "4i";
+                          break;
+                      }
+                      Qe(Dt, ".uniform", yt, "(", fi, ",", Mn(gn) ? Array.prototype.slice.call(gn) : gn, ");");
+                    }
+                    continue;
+                  } else Ti = Ur.append(Ve, Qe);
+                } else {
+                  if (!Ot(ia)) continue;
+                  Ti = Qe.def(Bt.uniforms, "[", bt.id(ur), "]");
+                }
+                br === dc ? Qe("if(", Ti, "&&", Ti, '._reglType==="framebuffer"){', Ti, "=", Ti, ".color[0];", "}") : br === Tl && Qe("if(", Ti, "&&", Ti, '._reglType==="framebufferCube"){', Ti, "=", Ti, ".color[0];", "}");
+                var Gi = 1;
+                switch (br) {
+                  case dc:
+                  case Tl:
+                    var sn = Qe.def(Ti, "._texture");
+                    Qe(Dt, ".uniform1i(", fi, ",", sn, ".bind());"), Qe.exit(sn, ".unbind();");
+                    continue;
+                  case Bo:
+                  case To:
+                    yt = "1i";
+                    break;
+                  case Ps:
+                  case hl:
+                    yt = "2i", Gi = 2;
+                    break;
+                  case Ts:
+                  case Ul:
+                    yt = "3i", Gi = 3;
+                    break;
+                  case wo:
+                  case Lu:
+                    yt = "4i", Gi = 4;
+                    break;
+                  case $a:
+                    yt = "1f";
+                    break;
+                  case Co:
+                    yt = "2f", Gi = 2;
+                    break;
+                  case Qa:
+                    yt = "3f", Gi = 3;
+                    break;
+                  case mo:
+                    yt = "4f", Gi = 4;
+                    break;
+                  case au:
+                    yt = "Matrix2fv";
+                    break;
+                  case Js:
+                    yt = "Matrix3fv";
+                    break;
+                  case eu:
+                    yt = "Matrix4fv";
+                    break;
+                }
+                if (yt.charAt(0) === "M") {
+                  Qe(Dt, ".uniform", yt, "(", fi, ",");
+                  var zn = Math.pow(br - au + 2, 2), Ja = Ve.global.def("new Float32Array(", zn, ")");
+                  Array.isArray(Ti) ? Qe("false,(", M(zn, function(ms) {
+                    return Ja + "[" + ms + "]=" + Ti[ms];
+                  }), ",", Ja, ")") : Qe("false,(Array.isArray(", Ti, ")||", Ti, " instanceof Float32Array)?", Ti, ":(", M(zn, function(ms) {
+                    return Ja + "[" + ms + "]=" + Ti + "[" + ms + "]";
+                  }), ",", Ja, ")"), Qe(");");
+                } else if (Gi > 1) {
+                  for (var co = [], ts = [], so = 0; so < Gi; ++so) Array.isArray(Ti) ? ts.push(Ti[so]) : ts.push(Qe.def(Ti + "[" + so + "]")), Rt && co.push(Qe.def());
+                  Rt && Qe("if(!", Ve.batchId, "||", co.map(function(ms, ou) {
+                    return ms + "!==" + ts[ou];
+                  }).join("||"), "){", co.map(function(ms, ou) {
+                    return ms + "=" + ts[ou] + ";";
+                  }).join("")), Qe(Dt, ".uniform", yt, "(", fi, ",", ts.join(","), ");"), Rt && Qe("}");
+                } else {
+                  if (Rt) {
+                    var Yo = Qe.def();
+                    Qe("if(!", Ve.batchId, "||", Yo, "!==", Ti, "){", Yo, "=", Ti, ";");
+                  }
+                  Qe(Dt, ".uniform", yt, "(", fi, ",", Ti, ");"), Rt && Qe("}");
+                }
+              }
+            }
+            function J(Ve, Qe, at, Ct) {
+              var Ot = Ve.shared, Rt = Ot.gl, Bt = Ot.draw, Dt = Ct.draw;
+              function yt() {
+                var Gi = Dt.elements, sn, zn = Qe;
+                return Gi ? ((Gi.contextDep && Ct.contextDynamic || Gi.propDep) && (zn = at), sn = Gi.append(Ve, zn), Dt.elementsActive && zn("if(" + sn + ")" + Rt + ".bindBuffer(" + Or + "," + sn + ".buffer.buffer);")) : (sn = zn.def(), zn(sn, "=", Bt, ".", Tt, ";", "if(", sn, "){", Rt, ".bindBuffer(", Or, ",", sn, ".buffer.buffer);}", "else if(", Ot.vao, ".currentVAO){", sn, "=", Ve.shared.elements + ".getElements(" + Ot.vao, ".currentVAO.elements);", an ? "" : "if(" + sn + ")" + Rt + ".bindBuffer(" + Or + "," + sn + ".buffer.buffer);", "}")), sn;
+              }
+              function Pt() {
+                var Gi = Dt.count, sn, zn = Qe;
+                return Gi ? ((Gi.contextDep && Ct.contextDynamic || Gi.propDep) && (zn = at), sn = Gi.append(Ve, zn)) : sn = zn.def(Bt, ".", Kt), sn;
+              }
+              var ht = yt();
+              function ur(Gi) {
+                var sn = Dt[Gi];
+                return sn ? sn.contextDep && Ct.contextDynamic || sn.propDep ? sn.append(Ve, at) : sn.append(Ve, Qe) : Qe.def(Bt, ".", Gi);
+              }
+              var br = ur(Yt), Ur = ur(xr), Di = Pt();
+              if (typeof Di == "number") {
+                if (Di === 0) return;
+              } else at("if(", Di, "){"), at.exit("}");
+              var fi, Ti;
+              Ri && (fi = ur(Ir), Ti = Ve.instancing);
+              var gn = ht + ".type", rn = Dt.elements && Ln(Dt.elements) && !Dt.vaoActive;
+              function Ci() {
+                function Gi() {
+                  at(Ti, ".drawElementsInstancedANGLE(", [br, Di, gn, Ur + "<<((" + gn + "-" + Ra + ")>>1)", fi], ");");
+                }
+                function sn() {
+                  at(Ti, ".drawArraysInstancedANGLE(", [br, Ur, Di, fi], ");");
+                }
+                ht && ht !== "null" ? rn ? Gi() : (at("if(", ht, "){"), Gi(), at("}else{"), sn(), at("}")) : sn();
+              }
+              function Bi() {
+                function Gi() {
+                  at(Rt + ".drawElements(" + [br, Di, gn, Ur + "<<((" + gn + "-" + Ra + ")>>1)"] + ");");
+                }
+                function sn() {
+                  at(Rt + ".drawArrays(" + [br, Ur, Di] + ");");
+                }
+                ht && ht !== "null" ? rn ? Gi() : (at("if(", ht, "){"), Gi(), at("}else{"), sn(), at("}")) : sn();
+              }
+              Ri && (typeof fi != "number" || fi >= 0) ? typeof fi == "string" ? (at("if(", fi, ">0){"), Ci(), at("}else if(", fi, "<0){"), Bi(), at("}")) : Ci() : Bi();
+            }
+            function q(Ve, Qe, at, Ct, Ot) {
+              var Rt = kn(), Bt = Rt.proc("body", Ot);
+              return Ri && (Rt.instancing = Bt.def(Rt.shared.extensions, ".angle_instanced_arrays")), Ve(Rt, Bt, at, Ct), Rt.compile().body;
+            }
+            function K(Ve, Qe, at, Ct) {
+              ol(Ve, Qe), at.useVAO ? at.drawVAO ? Qe(Ve.shared.vao, ".setVAO(", at.drawVAO.append(Ve, Qe), ");") : Qe(Ve.shared.vao, ".setVAO(", Ve.shared.vao, ".targetVAO);") : (Qe(Ve.shared.vao, ".setVAO(null);"), Y(Ve, Qe, at, Ct.attributes, function() {
+                return true;
+              })), D(Ve, Qe, at, Ct.uniforms, function() {
+                return true;
+              }, false), J(Ve, Qe, Qe, at);
+            }
+            function de(Ve, Qe) {
+              var at = Ve.proc("draw", 1);
+              ol(Ve, at), ss(Ve, at, Qe.context), Vs(Ve, at, Qe.framebuffer), Ys(Ve, at, Qe), wa(Ve, at, Qe.state), io(Ve, at, Qe, false, true);
+              var Ct = Qe.shader.progVar.append(Ve, at);
+              if (at(Ve.shared.gl, ".useProgram(", Ct, ".program);"), Qe.shader.program) K(Ve, at, Qe, Qe.shader.program);
+              else {
+                at(Ve.shared.vao, ".setVAO(null);");
+                var Ot = Ve.global.def("{}"), Rt = at.def(Ct, ".id"), Bt = at.def(Ot, "[", Rt, "]");
+                at(Ve.cond(Bt).then(Bt, ".call(this,a0);").else(Bt, "=", Ot, "[", Rt, "]=", Ve.link(function(Dt) {
+                  return q(K, Ve, Qe, Dt, 1);
+                }), "(", Ct, ");", Bt, ".call(this,a0);"));
+              }
+              Object.keys(Qe.state).length > 0 && at(Ve.shared.current, ".dirty=true;"), Ve.shared.vao && at(Ve.shared.vao, ".setVAO(null);");
+            }
+            function ne(Ve, Qe, at, Ct) {
+              Ve.batchId = "a1", ol(Ve, Qe);
+              function Ot() {
+                return true;
+              }
+              Y(Ve, Qe, at, Ct.attributes, Ot), D(Ve, Qe, at, Ct.uniforms, Ot, false), J(Ve, Qe, Qe, at);
+            }
+            function we(Ve, Qe, at, Ct) {
+              ol(Ve, Qe);
+              var Ot = at.contextDep, Rt = Qe.def(), Bt = "a0", Dt = "a1", yt = Qe.def();
+              Ve.shared.props = yt, Ve.batchId = Rt;
+              var Pt = Ve.scope(), ht = Ve.scope();
+              Qe(Pt.entry, "for(", Rt, "=0;", Rt, "<", Dt, ";++", Rt, "){", yt, "=", Bt, "[", Rt, "];", ht, "}", Pt.exit);
+              function ur(gn) {
+                return gn.contextDep && Ot || gn.propDep;
+              }
+              function br(gn) {
+                return !ur(gn);
+              }
+              if (at.needsContext && ss(Ve, ht, at.context), at.needsFramebuffer && Vs(Ve, ht, at.framebuffer), wa(Ve, ht, at.state, ur), at.profile && ur(at.profile) && io(Ve, ht, at, false, true), Ct) at.useVAO ? at.drawVAO ? ur(at.drawVAO) ? ht(Ve.shared.vao, ".setVAO(", at.drawVAO.append(Ve, ht), ");") : Pt(Ve.shared.vao, ".setVAO(", at.drawVAO.append(Ve, Pt), ");") : Pt(Ve.shared.vao, ".setVAO(", Ve.shared.vao, ".targetVAO);") : (Pt(Ve.shared.vao, ".setVAO(null);"), Y(Ve, Pt, at, Ct.attributes, br), Y(Ve, ht, at, Ct.attributes, ur)), D(Ve, Pt, at, Ct.uniforms, br, false), D(Ve, ht, at, Ct.uniforms, ur, true), J(Ve, Pt, ht, at);
+              else {
+                var Ur = Ve.global.def("{}"), Di = at.shader.progVar.append(Ve, ht), fi = ht.def(Di, ".id"), Ti = ht.def(Ur, "[", fi, "]");
+                ht(Ve.shared.gl, ".useProgram(", Di, ".program);", "if(!", Ti, "){", Ti, "=", Ur, "[", fi, "]=", Ve.link(function(gn) {
+                  return q(ne, Ve, at, gn, 2);
+                }), "(", Di, ");}", Ti, ".call(this,a0[", Rt, "],", Rt, ");");
+              }
+            }
+            function Ue(Ve, Qe) {
+              var at = Ve.proc("batch", 2);
+              Ve.batchId = "0", ol(Ve, at);
+              var Ct = false, Ot = true;
+              Object.keys(Qe.context).forEach(function(Ur) {
+                Ct = Ct || Qe.context[Ur].propDep;
+              }), Ct || (ss(Ve, at, Qe.context), Ot = false);
+              var Rt = Qe.framebuffer, Bt = false;
+              Rt ? (Rt.propDep ? Ct = Bt = true : Rt.contextDep && Ct && (Bt = true), Bt || Vs(Ve, at, Rt)) : Vs(Ve, at, null), Qe.state.viewport && Qe.state.viewport.propDep && (Ct = true);
+              function Dt(Ur) {
+                return Ur.contextDep && Ct || Ur.propDep;
+              }
+              Ys(Ve, at, Qe), wa(Ve, at, Qe.state, function(Ur) {
+                return !Dt(Ur);
+              }), (!Qe.profile || !Dt(Qe.profile)) && io(Ve, at, Qe, false, "a1"), Qe.contextDep = Ct, Qe.needsContext = Ot, Qe.needsFramebuffer = Bt;
+              var yt = Qe.shader.progVar;
+              if (yt.contextDep && Ct || yt.propDep) we(Ve, at, Qe, null);
+              else {
+                var Pt = yt.append(Ve, at);
+                if (at(Ve.shared.gl, ".useProgram(", Pt, ".program);"), Qe.shader.program) we(Ve, at, Qe, Qe.shader.program);
+                else {
+                  at(Ve.shared.vao, ".setVAO(null);");
+                  var ht = Ve.global.def("{}"), ur = at.def(Pt, ".id"), br = at.def(ht, "[", ur, "]");
+                  at(Ve.cond(br).then(br, ".call(this,a0,a1);").else(br, "=", ht, "[", ur, "]=", Ve.link(function(Ur) {
+                    return q(we, Ve, Qe, Ur, 2);
+                  }), "(", Pt, ");", br, ".call(this,a0,a1);"));
+                }
+              }
+              Object.keys(Qe.state).length > 0 && at(Ve.shared.current, ".dirty=true;"), Ve.shared.vao && at(Ve.shared.vao, ".setVAO(null);");
+            }
+            function ft(Ve, Qe) {
+              var at = Ve.proc("scope", 3);
+              Ve.batchId = "a2";
+              var Ct = Ve.shared, Ot = Ct.current;
+              if (ss(Ve, at, Qe.context), Qe.framebuffer && Qe.framebuffer.append(Ve, at), Si(Object.keys(Qe.state)).forEach(function(Dt) {
+                var yt = Qe.state[Dt], Pt = yt.append(Ve, at);
+                Mn(Pt) ? Pt.forEach(function(ht, ur) {
+                  pn(ht) ? at.set(Ve.next[Dt], "[" + ur + "]", ht) : at.set(Ve.next[Dt], "[" + ur + "]", Ve.link(ht, { stable: true }));
+                }) : Ln(yt) ? at.set(Ct.next, "." + Dt, Ve.link(Pt, { stable: true })) : at.set(Ct.next, "." + Dt, Pt);
+              }), io(Ve, at, Qe, true, true), [Tt, xr, Kt, Ir, Yt].forEach(function(Dt) {
+                var yt = Qe.draw[Dt];
+                if (yt) {
+                  var Pt = yt.append(Ve, at);
+                  pn(Pt) ? at.set(Ct.draw, "." + Dt, Pt) : at.set(Ct.draw, "." + Dt, Ve.link(Pt), { stable: true });
+                }
+              }), Object.keys(Qe.uniforms).forEach(function(Dt) {
+                var yt = Qe.uniforms[Dt].append(Ve, at);
+                Array.isArray(yt) && (yt = "[" + yt.map(function(Pt) {
+                  return pn(Pt) ? Pt : Ve.link(Pt, { stable: true });
+                }) + "]"), at.set(Ct.uniforms, "[" + Ve.link(bt.id(Dt), { stable: true }) + "]", yt);
+              }), Object.keys(Qe.attributes).forEach(function(Dt) {
+                var yt = Qe.attributes[Dt].append(Ve, at), Pt = Ve.scopeAttrib(Dt);
+                Object.keys(new Yr()).forEach(function(ht) {
+                  at.set(Pt, "." + ht, yt[ht]);
+                });
+              }), Qe.scopeVAO) {
+                var Rt = Qe.scopeVAO.append(Ve, at);
+                pn(Rt) ? at.set(Ct.vao, ".targetVAO", Rt) : at.set(Ct.vao, ".targetVAO", Ve.link(Rt, { stable: true }));
+              }
+              function Bt(Dt) {
+                var yt = Qe.shader[Dt];
+                if (yt) {
+                  var Pt = yt.append(Ve, at);
+                  pn(Pt) ? at.set(Ct.shader, "." + Dt, Pt) : at.set(Ct.shader, "." + Dt, Ve.link(Pt, { stable: true }));
+                }
+              }
+              Bt(Ze), Bt(st), Object.keys(Qe.state).length > 0 && (at(Ot, ".dirty=true;"), at.exit(Ot, ".dirty=true;")), at("a1(", Ve.shared.context, ",a0,", Ve.batchId, ");");
+            }
+            function Zt(Ve) {
+              if (!(typeof Ve != "object" || Mn(Ve))) {
+                for (var Qe = Object.keys(Ve), at = 0; at < Qe.length; ++at) if (h.isDynamic(Ve[Qe[at]])) return true;
+                return false;
+              }
+            }
+            function hr(Ve, Qe, at) {
+              var Ct = Qe.static[at];
+              if (!Ct || !Zt(Ct)) return;
+              var Ot = Ve.global, Rt = Object.keys(Ct), Bt = false, Dt = false, yt = false, Pt = Ve.global.def("{}");
+              Rt.forEach(function(ur) {
+                var br = Ct[ur];
+                if (h.isDynamic(br)) {
+                  typeof br == "function" && (br = Ct[ur] = h.unbox(br));
+                  var Ur = Un(br, null);
+                  Bt = Bt || Ur.thisDep, yt = yt || Ur.propDep, Dt = Dt || Ur.contextDep;
+                } else {
+                  switch (Ot(Pt, ".", ur, "="), typeof br) {
+                    case "number":
+                      Ot(br);
+                      break;
+                    case "string":
+                      Ot('"', br, '"');
+                      break;
+                    case "object":
+                      Array.isArray(br) && Ot("[", br.join(), "]");
+                      break;
+                    default:
+                      Ot(Ve.link(br));
+                      break;
+                  }
+                  Ot(";");
+                }
+              });
+              function ht(ur, br) {
+                Rt.forEach(function(Ur) {
+                  var Di = Ct[Ur];
+                  if (h.isDynamic(Di)) {
+                    var fi = ur.invoke(br, Di);
+                    br(Pt, ".", Ur, "=", fi, ";");
+                  }
+                });
+              }
+              Qe.dynamic[at] = new h.DynamicVariable(Zo, { thisDep: Bt, contextDep: Dt, propDep: yt, ref: Pt, append: ht }), delete Qe.static[at];
+            }
+            function qt(Ve, Qe, at, Ct, Ot) {
+              var Rt = kn();
+              Rt.stats = Rt.link(Ot), Object.keys(Qe.static).forEach(function(Dt) {
+                hr(Rt, Qe, Dt);
+              }), dr.forEach(function(Dt) {
+                hr(Rt, Ve, Dt);
+              });
+              var Bt = Vl(Ve, Qe, at, Ct, Rt);
+              return Bt.shader.program && (Bt.shader.program.attributes.sort(function(Dt, yt) {
+                return Dt.name < yt.name ? -1 : 1;
+              }), Bt.shader.program.uniforms.sort(function(Dt, yt) {
+                return Dt.name < yt.name ? -1 : 1;
+              })), de(Rt, Bt), ft(Rt, Bt), Ue(Rt, Bt), e(Rt.compile(), { destroy: function() {
+                Bt.shader.program.destroy();
+              } });
+            }
+            return { next: Bn, current: Zi, procs: function() {
+              var Ve = kn(), Qe = Ve.proc("poll"), at = Ve.proc("refresh"), Ct = Ve.block();
+              Qe(Ct), at(Ct);
+              var Ot = Ve.shared, Rt = Ot.gl, Bt = Ot.next, Dt = Ot.current;
+              Ct(Dt, ".dirty=false;"), Vs(Ve, Qe), Vs(Ve, at, null, true);
+              var yt;
+              Ri && (yt = Ve.link(Ri)), zt.oes_vertex_array_object && at(Ve.link(zt.oes_vertex_array_object), ".bindVertexArrayOES(null);");
+              var Pt = at.def(Ot.attributes), ht = at.def(0), ur = Ve.cond(ht, ".buffer");
+              ur.then(Rt, ".enableVertexAttribArray(i);", Rt, ".bindBuffer(", Sr, ",", ht, ".buffer.buffer);", Rt, ".vertexAttribPointer(i,", ht, ".size,", ht, ".type,", ht, ".normalized,", ht, ".stride,", ht, ".offset);").else(Rt, ".disableVertexAttribArray(i);", Rt, ".vertexAttrib4f(i,", ht, ".x,", ht, ".y,", ht, ".z,", ht, ".w);", ht, ".buffer=null;");
+              var br = Ve.link(Rr.maxAttributes, { stable: true });
+              return at("for(var i=0;i<", br, ";++i){", ht, "=", Pt, "[i];", ur, "}"), Ri && at("for(var i=0;i<", br, ";++i){", yt, ".vertexAttribDivisorANGLE(i,", Pt, "[i].divisor);", "}"), at(Ve.shared.vao, ".currentVAO=null;", Ve.shared.vao, ".setVAO(", Ve.shared.vao, ".targetVAO);"), Object.keys(li).forEach(function(Ur) {
+                var Di = li[Ur], fi = Ct.def(Bt, ".", Ur), Ti = Ve.block();
+                Ti("if(", fi, "){", Rt, ".enable(", Di, ")}else{", Rt, ".disable(", Di, ")}", Dt, ".", Ur, "=", fi, ";"), at(Ti), Qe("if(", fi, "!==", Dt, ".", Ur, "){", Ti, "}");
+              }), Object.keys(mn).forEach(function(Ur) {
+                var Di = mn[Ur], fi = Zi[Ur], Ti, gn, rn = Ve.block();
+                if (rn(Rt, ".", Di, "("), Mn(fi)) {
+                  var Ci = fi.length;
+                  Ti = Ve.global.def(Bt, ".", Ur), gn = Ve.global.def(Dt, ".", Ur), rn(M(Ci, function(Bi) {
+                    return Ti + "[" + Bi + "]";
+                  }), ");", M(Ci, function(Bi) {
+                    return gn + "[" + Bi + "]=" + Ti + "[" + Bi + "];";
+                  }).join("")), Qe("if(", M(Ci, function(Bi) {
+                    return Ti + "[" + Bi + "]!==" + gn + "[" + Bi + "]";
+                  }).join("||"), "){", rn, "}");
+                } else Ti = Ct.def(Bt, ".", Ur), gn = Ct.def(Dt, ".", Ur), rn(Ti, ");", Dt, ".", Ur, "=", Ti, ";"), Qe("if(", Ti, "!==", gn, "){", rn, "}");
+                at(rn);
+              }), Ve.compile();
+            }(), compile: qt };
+          }
+          function Ia() {
+            return { vaoCount: 0, bufferCount: 0, elementsCount: 0, framebufferCount: 0, shaderCount: 0, textureCount: 0, cubeCount: 0, renderbufferCount: 0, maxTextureUnits: 0 };
+          }
+          var yo = 34918, Da = 34919, go = 35007, Is = function(Me, bt) {
+            if (!bt.ext_disjoint_timer_query) return null;
+            var zt = [];
+            function Rr() {
+              return zt.pop() || bt.ext_disjoint_timer_query.createQueryEXT();
+            }
+            function jr(xi) {
+              zt.push(xi);
+            }
+            var Nr = [];
+            function Gr(xi) {
+              var Ri = Rr();
+              bt.ext_disjoint_timer_query.beginQueryEXT(go, Ri), Nr.push(Ri), Wi(Nr.length - 1, Nr.length, xi);
+            }
+            function mi() {
+              bt.ext_disjoint_timer_query.endQueryEXT(go);
+            }
+            function Ui() {
+              this.startQueryIndex = -1, this.endQueryIndex = -1, this.sum = 0, this.stats = null;
+            }
+            var qi = [];
+            function Ei() {
+              return qi.pop() || new Ui();
+            }
+            function Hn(xi) {
+              qi.push(xi);
+            }
+            var en = [];
+            function Wi(xi, Ri, ci) {
+              var an = Ei();
+              an.startQueryIndex = xi, an.endQueryIndex = Ri, an.sum = 0, an.stats = ci, en.push(an);
+            }
+            var si = [], Mr = [];
+            function Yr() {
+              var xi, Ri, ci = Nr.length;
+              if (ci !== 0) {
+                Mr.length = Math.max(Mr.length, ci + 1), si.length = Math.max(si.length, ci + 1), si[0] = 0, Mr[0] = 0;
+                var an = 0;
+                for (xi = 0, Ri = 0; Ri < Nr.length; ++Ri) {
+                  var Zi = Nr[Ri];
+                  bt.ext_disjoint_timer_query.getQueryObjectEXT(Zi, Da) ? (an += bt.ext_disjoint_timer_query.getQueryObjectEXT(Zi, yo), jr(Zi)) : Nr[xi++] = Zi, si[Ri + 1] = an, Mr[Ri + 1] = xi;
+                }
+                for (Nr.length = xi, xi = 0, Ri = 0; Ri < en.length; ++Ri) {
+                  var Bn = en[Ri], hi = Bn.startQueryIndex, li = Bn.endQueryIndex;
+                  Bn.sum += si[li] - si[hi];
+                  var mn = Mr[hi], Ji = Mr[li];
+                  Ji === mn ? (Bn.stats.gpuTime += Bn.sum / 1e6, Hn(Bn)) : (Bn.startQueryIndex = mn, Bn.endQueryIndex = Ji, en[xi++] = Bn);
+                }
+                en.length = xi;
+              }
+            }
+            return { beginQuery: Gr, endQuery: mi, pushScopeStats: Wi, update: Yr, getNumPendingQueries: function() {
+              return Nr.length;
+            }, clear: function() {
+              zt.push.apply(zt, Nr);
+              for (var xi = 0; xi < zt.length; xi++) bt.ext_disjoint_timer_query.deleteQueryEXT(zt[xi]);
+              Nr.length = 0, zt.length = 0;
+            }, restore: function() {
+              Nr.length = 0, zt.length = 0;
+            } };
+          }, Ms = 16384, Xs = 256, Gn = 1024, ja = 34962, Fo = "webglcontextlost", Uo = "webglcontextrestored", $s = 1, Sl = 2, bu = 3;
+          function dl(Me, bt) {
+            for (var zt = 0; zt < Me.length; ++zt) if (Me[zt] === bt) return zt;
+            return -1;
+          }
+          function Sc(Me) {
+            var bt = x(Me);
+            if (!bt) return null;
+            var zt = bt.gl, Rr = zt.getContextAttributes();
+            zt.isContextLost();
+            var Nr = C(zt, bt);
+            if (!Nr) return null;
+            var Gr = _(), mi = Ia(), Ui = bt.cachedCode || {}, qi = Nr.extensions, Ei = Is(zt, qi), Hn = v(), en = zt.drawingBufferWidth, Wi = zt.drawingBufferHeight, si = { tick: 0, time: 0, viewportWidth: en, viewportHeight: Wi, framebufferWidth: en, framebufferHeight: Wi, drawingBufferWidth: en, drawingBufferHeight: Wi, pixelRatio: bt.pixelRatio }, Mr = {}, Yr = { elements: null, primitive: 4, count: -1, offset: 0, instances: -1 }, xi = ti(zt, qi), Ri = ri(zt, mi, bt, Zi), ci = kr(zt, qi, Ri, mi), an = ku(zt, qi, xi, mi, Ri, ci, Yr);
+            function Zi(q) {
+              return an.destroyBuffer(q);
+            }
+            var Bn = Wu(zt, Gr, mi, bt), hi = of(zt, qi, xi, function() {
+              Ji.procs.poll();
+            }, si, mi, bt), li = Dc(zt, qi, xi, mi, bt), mn = lf(zt, qi, xi, hi, li, mi), Ji = Ea(zt, Gr, qi, xi, Ri, ci, hi, mn, Mr, an, Bn, Yr, si, Ei, Ui, bt), Vi = Wl(zt, mn, Ji.procs.poll, si), Ni = Ji.next, pn = zt.canvas, Vn = [], na = [], Ki = [], kn = [bt.onDestroy], ta = null;
+            function oa() {
+              if (Vn.length === 0) {
+                Ei && Ei.update(), ta = null;
+                return;
+              }
+              ta = d.next(oa), Ys();
+              for (var q = Vn.length - 1; q >= 0; --q) {
+                var K = Vn[q];
+                K && K(si, null, 0);
+              }
+              zt.flush(), Ei && Ei.update();
+            }
+            function ba() {
+              !ta && Vn.length > 0 && (ta = d.next(oa));
+            }
+            function is() {
+              ta && (d.cancel(oa), ta = null);
+            }
+            function Zs(q) {
+              q.preventDefault(), is(), na.forEach(function(K) {
+                K();
+              });
+            }
+            function Va(q) {
+              zt.getError(), Nr.restore(), Bn.restore(), Ri.restore(), hi.restore(), li.restore(), mn.restore(), an.restore(), Ei && Ei.restore(), Ji.procs.refresh(), ba(), Ki.forEach(function(K) {
+                K();
+              });
+            }
+            pn && (pn.addEventListener(Fo, Zs, false), pn.addEventListener(Uo, Va, false));
+            function Ml() {
+              Vn.length = 0, is(), pn && (pn.removeEventListener(Fo, Zs), pn.removeEventListener(Uo, Va)), Bn.clear(), mn.clear(), li.clear(), an.clear(), hi.clear(), ci.clear(), Ri.clear(), Ei && Ei.clear(), kn.forEach(function(q) {
+                q();
+              });
+            }
+            function zo(q) {
+              function K(Rt) {
+                var Bt = e({}, Rt);
+                delete Bt.uniforms, delete Bt.attributes, delete Bt.context, delete Bt.vao, "stencil" in Bt && Bt.stencil.op && (Bt.stencil.opBack = Bt.stencil.opFront = Bt.stencil.op, delete Bt.stencil.op);
+                function Dt(yt) {
+                  if (yt in Bt) {
+                    var Pt = Bt[yt];
+                    delete Bt[yt], Object.keys(Pt).forEach(function(ht) {
+                      Bt[yt + "." + ht] = Pt[ht];
+                    });
+                  }
+                }
+                return Dt("blend"), Dt("depth"), Dt("cull"), Dt("stencil"), Dt("polygonOffset"), Dt("scissor"), Dt("sample"), "vao" in Rt && (Bt.vao = Rt.vao), Bt;
+              }
+              function de(Rt, Bt) {
+                var Dt = {}, yt = {};
+                return Object.keys(Rt).forEach(function(Pt) {
+                  var ht = Rt[Pt];
+                  if (h.isDynamic(ht)) {
+                    yt[Pt] = h.unbox(ht, Pt);
+                    return;
+                  } else if (Bt && Array.isArray(ht)) {
+                    for (var ur = 0; ur < ht.length; ++ur) if (h.isDynamic(ht[ur])) {
+                      yt[Pt] = h.unbox(ht, Pt);
+                      return;
+                    }
+                  }
+                  Dt[Pt] = ht;
+                }), { dynamic: yt, static: Dt };
+              }
+              var ne = de(q.context || {}, true), we = de(q.uniforms || {}, true), Ue = de(q.attributes || {}, false), ft = de(K(q), false), Zt = { gpuTime: 0, cpuTime: 0, count: 0 }, hr = Ji.compile(ft, Ue, we, ne, Zt), qt = hr.draw, Ve = hr.batch, Qe = hr.scope, at = [];
+              function Ct(Rt) {
+                for (; at.length < Rt; ) at.push(null);
+                return at;
+              }
+              function Ot(Rt, Bt) {
+                var Dt;
+                if (typeof Rt == "function") return Qe.call(this, null, Rt, 0);
+                if (typeof Bt == "function") if (typeof Rt == "number") for (Dt = 0; Dt < Rt; ++Dt) Qe.call(this, null, Bt, Dt);
+                else if (Array.isArray(Rt)) for (Dt = 0; Dt < Rt.length; ++Dt) Qe.call(this, Rt[Dt], Bt, Dt);
+                else return Qe.call(this, Rt, Bt, 0);
+                else if (typeof Rt == "number") {
+                  if (Rt > 0) return Ve.call(this, Ct(Rt | 0), Rt | 0);
+                } else if (Array.isArray(Rt)) {
+                  if (Rt.length) return Ve.call(this, Rt, Rt.length);
+                } else return qt.call(this, Rt);
+              }
+              return e(Ot, { stats: Zt, destroy: function() {
+                hr.destroy();
+              } });
+            }
+            var Qs = mn.setFBO = zo({ framebuffer: h.define.call(null, $s, "framebuffer") });
+            function al(q, K) {
+              var de = 0;
+              Ji.procs.poll();
+              var ne = K.color;
+              ne && (zt.clearColor(+ne[0] || 0, +ne[1] || 0, +ne[2] || 0, +ne[3] || 0), de |= Ms), "depth" in K && (zt.clearDepth(+K.depth), de |= Xs), "stencil" in K && (zt.clearStencil(K.stencil | 0), de |= Gn), zt.clear(de);
+            }
+            function Vl(q) {
+              if ("framebuffer" in q) if (q.framebuffer && q.framebuffer_reglType === "framebufferCube") for (var K = 0; K < 6; ++K) Qs(e({ framebuffer: q.framebuffer.faces[K] }, q), al);
+              else Qs(q, al);
+              else al(null, q);
+            }
+            function ss(q) {
+              Vn.push(q);
+              function K() {
+                var de = dl(Vn, q);
+                function ne() {
+                  var we = dl(Vn, ne);
+                  Vn[we] = Vn[Vn.length - 1], Vn.length -= 1, Vn.length <= 0 && is();
+                }
+                Vn[de] = ne;
+              }
+              return ba(), { cancel: K };
+            }
+            function Vs() {
+              var q = Ni.viewport, K = Ni.scissor_box;
+              q[0] = q[1] = K[0] = K[1] = 0, si.viewportWidth = si.framebufferWidth = si.drawingBufferWidth = q[2] = K[2] = zt.drawingBufferWidth, si.viewportHeight = si.framebufferHeight = si.drawingBufferHeight = q[3] = K[3] = zt.drawingBufferHeight;
+            }
+            function Ys() {
+              si.tick += 1, si.time = ol(), Vs(), Ji.procs.poll();
+            }
+            function wa() {
+              hi.refresh(), Vs(), Ji.procs.refresh(), Ei && Ei.update();
+            }
+            function ol() {
+              return (v() - Hn) / 1e3;
+            }
+            wa();
+            function io(q, K) {
+              var de;
+              switch (q) {
+                case "frame":
+                  return ss(K);
+                case "lost":
+                  de = na;
+                  break;
+                case "restore":
+                  de = Ki;
+                  break;
+                case "destroy":
+                  de = kn;
+                  break;
+              }
+              return de.push(K), { cancel: function() {
+                for (var ne = 0; ne < de.length; ++ne) if (de[ne] === K) {
+                  de[ne] = de[de.length - 1], de.pop();
+                  return;
+                }
+              } };
+            }
+            function Y() {
+              return Ui;
+            }
+            function D(q) {
+              Object.entries(q).forEach(function(K) {
+                Ui[K[0]] = K[1];
+              });
+            }
+            var J = e(zo, { clear: Vl, prop: h.define.bind(null, $s), context: h.define.bind(null, Sl), this: h.define.bind(null, bu), draw: zo({}), buffer: function(q) {
+              return Ri.create(q, ja, false, false);
+            }, elements: function(q) {
+              return ci.create(q, false);
+            }, texture: hi.create2D, cube: hi.createCube, renderbuffer: li.create, framebuffer: mn.create, framebufferCube: mn.createCube, vao: an.createVAO, attributes: Rr, frame: ss, on: io, limits: xi, hasExtension: function(q) {
+              return xi.extensions.indexOf(q.toLowerCase()) >= 0;
+            }, read: Vi, destroy: Ml, _gl: zt, _refresh: wa, poll: function() {
+              Ys(), Ei && Ei.update();
+            }, now: ol, stats: mi, getCachedCode: Y, preloadCachedCode: D });
+            return bt.onDone(null, J), J;
+          }
+          return Sc;
+        });
+      });
+      var Lz = ye((S_r, zBe) => {
+        var WUt = zX(), XUt = FBe();
+        zBe.exports = function(t, r, n) {
+          var i = t._fullLayout, a = true;
+          return i._glcanvas.each(function(o) {
+            if (o.regl) {
+              o.regl.preloadCachedCode(n);
+              return;
+            }
+            if (!(o.pick && !i._has("parcoords"))) {
+              try {
+                o.regl = XUt({ canvas: this, attributes: { antialias: !o.pick, preserveDrawingBuffer: true }, pixelRatio: t._context.plotGlPixelRatio || window.devicePixelRatio, extensions: r || [], cachedCode: n || {} });
+              } catch (s) {
+                a = false;
+              }
+              o.regl || (a = false), a && this.addEventListener("webglcontextlost", function(s) {
+                t && t.emit && t.emit("plotly_webglcontextlost", { event: s, layer: o.key });
+              }, false);
+            }
+          }), a || WUt({ container: i._glcontainer.node() }), a;
+        };
+      });
+      var xK = ye((_K, UBe) => {
+        var OBe = _Y(), qBe = KY(), ZUt = Sqe(), BBe = DBe(), yK = Dr(), YUt = Cg().selectMode, KUt = Lz(), JUt = Ru(), $Ut = SU(), QUt = pY().styleTextSelection, NBe = {};
+        function eVt(e, t, r, n) {
+          var i = e._size, a = e.width * n, o = e.height * n, s = i.l * n, l = i.b * n, u = i.r * n, c = i.t * n, f = i.w * n, h = i.h * n;
+          return [s + t.domain[0] * f, l + r.domain[0] * h, a - u - (1 - t.domain[1]) * f, o - c - (1 - r.domain[1]) * h];
+        }
+        var _K = UBe.exports = function(t, r, n) {
+          if (n.length) {
+            var i = t._fullLayout, a = r._scene, o = r.xaxis, s = r.yaxis, l, u;
+            if (a) {
+              var c = KUt(t, ["ANGLE_instanced_arrays", "OES_element_index_uint"], NBe);
+              if (!c) {
+                a.init();
+                return;
+              }
+              var f = a.count, h = i._glcanvas.data()[0].regl;
+              if ($Ut(t, r, n), a.dirty) {
+                if ((a.line2d || a.error2d) && !(a.scatter2d || a.fill2d || a.glText) && h.clear({ color: true, depth: true }), a.error2d === true && (a.error2d = ZUt(h)), a.line2d === true && (a.line2d = qBe(h)), a.scatter2d === true && (a.scatter2d = OBe(h)), a.fill2d === true && (a.fill2d = qBe(h)), a.glText === true) for (a.glText = new Array(f), l = 0; l < f; l++) a.glText[l] = new BBe(h);
+                if (a.glText) {
+                  if (f > a.glText.length) {
+                    var d = f - a.glText.length;
+                    for (l = 0; l < d; l++) a.glText.push(new BBe(h));
+                  } else if (f < a.glText.length) {
+                    var v = a.glText.length - f, _ = a.glText.splice(f, v);
+                    _.forEach(function(N) {
+                      N.destroy();
+                    });
+                  }
+                  for (l = 0; l < f; l++) a.glText[l].update(a.textOptions[l]);
+                }
+                if (a.line2d && (a.line2d.update(a.lineOptions), a.lineOptions = a.lineOptions.map(function(N) {
+                  if (N && N.positions) {
+                    for (var H = N.positions, re = 0; re < H.length && (isNaN(H[re]) || isNaN(H[re + 1])); ) re += 2;
+                    for (var oe = H.length - 2; oe > re && (isNaN(H[oe]) || isNaN(H[oe + 1])); ) oe -= 2;
+                    N.positions = H.slice(re, oe + 2);
+                  }
+                  return N;
+                }), a.line2d.update(a.lineOptions)), a.error2d) {
+                  var b = (a.errorXOptions || []).concat(a.errorYOptions || []);
+                  a.error2d.update(b);
+                }
+                a.scatter2d && a.scatter2d.update(a.markerOptions), a.fillOrder = yK.repeat(null, f), a.fill2d && (a.fillOptions = a.fillOptions.map(function(N, H) {
+                  var re = n[H];
+                  if (!(!N || !re || !re[0] || !re[0].trace)) {
+                    var oe = re[0], _e = oe.trace, Ce = oe.t, Le = a.lineOptions[H], ge, ie, Se = [];
+                    _e._ownfill && Se.push(H), _e._nexttrace && Se.push(H + 1), Se.length && (a.fillOrder[H] = Se);
+                    var Ee = [], Ae = Le && Le.positions || Ce.positions, Be, Pe;
+                    if (_e.fill === "tozeroy") {
+                      for (Be = 0; Be < Ae.length && isNaN(Ae[Be + 1]); ) Be += 2;
+                      for (Pe = Ae.length - 2; Pe > Be && isNaN(Ae[Pe + 1]); ) Pe -= 2;
+                      Ae[Be + 1] !== 0 && (Ee = [Ae[Be], 0]), Ee = Ee.concat(Ae.slice(Be, Pe + 2)), Ae[Pe + 1] !== 0 && (Ee = Ee.concat([Ae[Pe], 0]));
+                    } else if (_e.fill === "tozerox") {
+                      for (Be = 0; Be < Ae.length && isNaN(Ae[Be]); ) Be += 2;
+                      for (Pe = Ae.length - 2; Pe > Be && isNaN(Ae[Pe]); ) Pe -= 2;
+                      Ae[Be] !== 0 && (Ee = [0, Ae[Be + 1]]), Ee = Ee.concat(Ae.slice(Be, Pe + 2)), Ae[Pe] !== 0 && (Ee = Ee.concat([0, Ae[Pe + 1]]));
+                    } else if (_e.fill === "toself" || _e.fill === "tonext") {
+                      for (Ee = [], ge = 0, N.splitNull = true, ie = 0; ie < Ae.length; ie += 2) (isNaN(Ae[ie]) || isNaN(Ae[ie + 1])) && (Ee = Ee.concat(Ae.slice(ge, ie)), Ee.push(Ae[ge], Ae[ge + 1]), Ee.push(null, null), ge = ie + 2);
+                      Ee = Ee.concat(Ae.slice(ge)), ge && Ee.push(Ae[ge], Ae[ge + 1]);
+                    } else {
+                      var me = _e._nexttrace;
+                      if (me) {
+                        var De = a.lineOptions[H + 1];
+                        if (De) {
+                          var ce = De.positions;
+                          if (_e.fill === "tonexty") {
+                            for (Ee = Ae.slice(), H = Math.floor(ce.length / 2); H--; ) {
+                              var je = ce[H * 2], lt = ce[H * 2 + 1];
+                              isNaN(je) || isNaN(lt) || Ee.push(je, lt);
+                            }
+                            N.fill = me.fillcolor;
+                          }
+                        }
+                      }
+                    }
+                    if (_e._prevtrace && _e._prevtrace.fill === "tonext") {
+                      var pt = a.lineOptions[H - 1].positions, Vt = Ee.length / 2;
+                      ge = Vt;
+                      var ot = [ge];
+                      for (ie = 0; ie < pt.length; ie += 2) (isNaN(pt[ie]) || isNaN(pt[ie + 1])) && (ot.push(ie / 2 + Vt + 1), ge = ie + 2);
+                      Ee = Ee.concat(pt), N.hole = ot;
+                    }
+                    return N.fillmode = _e.fill, N.opacity = _e.opacity, N.positions = Ee, N;
+                  }
+                }), a.fill2d.update(a.fillOptions));
+              }
+              var p = i.dragmode, k = YUt(p), E = i.clickmode.indexOf("select") > -1;
+              for (let [N] of n) if (N) {
+                var T = N.trace, L = N.t, x = L.index, C = T._length, M = L.x, g = L.y;
+                if (T.selectedpoints || k || E) {
+                  if (k || (k = true), T.selectedpoints) {
+                    var P = a.selectBatch[x] = yK.selIndices2selPoints(T), A = {};
+                    for (u = 0; u < P.length; u++) A[P[u]] = 1;
+                    var z = [];
+                    for (u = 0; u < C; u++) A[u] || z.push(u);
+                    a.unselectBatch[x] = z;
+                  }
+                  var O = L.xpx = new Array(C), U = L.ypx = new Array(C);
+                  for (u = 0; u < C; u++) O[u] = o.c2p(M[u]), U[u] = s.c2p(g[u]);
+                } else L.xpx = L.ypx = null;
+              }
+              if (k) {
+                if (a.select2d || (a.select2d = OBe(i._glcanvas.data()[1].regl)), a.scatter2d) {
+                  var G = new Array(f);
+                  for (l = 0; l < f; l++) G[l] = a.selectBatch[l].length || a.unselectBatch[l].length ? a.markerUnselectedOptions[l] : {};
+                  a.scatter2d.update(G);
+                }
+                a.select2d && (a.select2d.update(a.markerOptions), a.select2d.update(a.markerSelectedOptions)), a.glText && n.forEach(function(N) {
+                  var H = ((N || [])[0] || {}).trace || {};
+                  JUt.hasText(H) && QUt(N);
+                });
+              } else a.scatter2d && a.scatter2d.update(a.markerOptions);
+              var Z = { viewport: eVt(i, o, s, t._context.plotGlPixelRatio), range: [(o._rl || o.range)[0], (s._rl || s.range)[0], (o._rl || o.range)[1], (s._rl || s.range)[1]] }, j = yK.repeat(Z, a.count);
+              a.fill2d && a.fill2d.update(j), a.line2d && a.line2d.update(j), a.error2d && a.error2d.update(j.concat(j)), a.scatter2d && a.scatter2d.update(j), a.select2d && a.select2d.update(j), a.glText && a.glText.forEach(function(N) {
+                N.update(Z);
+              });
+            }
+          }
+        };
+        _K.reglPrecompiled = NBe;
+      });
+      var HBe = ye((M_r, GBe) => {
+        var VBe = o7e();
+        VBe.plot = xK();
+        GBe.exports = VBe;
+      });
+      var WBe = ye((E_r, jBe) => {
+        jBe.exports = HBe();
+      });
+      var bK = ye((k_r, KBe) => {
+        var tVt = pf(), YBe = Tu(), XBe = df().axisHoverFormat, { hovertemplateAttrs: rVt, templatefallbackAttrs: iVt } = Ll(), zk = gk(), nVt = Rh().idRegex, aVt = vl().templatedArray, x5 = Ao().extendFlat, d1 = tVt.marker, oVt = d1.line, sVt = x5(YBe("marker.line", { editTypeOverride: "calc" }), { width: x5({}, oVt.width, { editType: "calc" }), editType: "calc" }), Pz = x5(YBe("marker"), { symbol: d1.symbol, angle: d1.angle, size: x5({}, d1.size, { editType: "markerSize" }), sizeref: d1.sizeref, sizemin: d1.sizemin, sizemode: d1.sizemode, opacity: d1.opacity, colorbar: d1.colorbar, line: sVt, editType: "calc" });
+        Pz.color.editType = Pz.cmin.editType = Pz.cmax.editType = "style";
+        function ZBe(e) {
+          return { valType: "info_array", freeLength: true, editType: "calc", items: { valType: "subplotid", regex: nVt[e], editType: "plot" } };
+        }
+        KBe.exports = { dimensions: aVt("dimension", { visible: { valType: "boolean", dflt: true, editType: "calc" }, label: { valType: "string", editType: "calc" }, values: { valType: "data_array", editType: "calc+clearAxisTypes" }, axis: { type: { valType: "enumerated", values: ["linear", "log", "date", "category"], editType: "calc+clearAxisTypes" }, matches: { valType: "boolean", dflt: false, editType: "calc" }, editType: "calc+clearAxisTypes" }, editType: "calc+clearAxisTypes" }), text: x5({}, zk.text, {}), hovertext: x5({}, zk.hovertext, {}), hovertemplate: rVt(), hovertemplatefallback: iVt(), xhoverformat: XBe("x"), yhoverformat: XBe("y"), marker: Pz, xaxes: ZBe("x"), yaxes: ZBe("y"), diagonal: { visible: { valType: "boolean", dflt: true, editType: "calc" }, editType: "calc" }, showupperhalf: { valType: "boolean", dflt: true, editType: "calc" }, showlowerhalf: { valType: "boolean", dflt: true, editType: "calc" }, selected: { marker: zk.selected.marker, editType: "calc" }, unselected: { marker: zk.unselected.marker, editType: "calc" }, opacity: zk.opacity };
+      });
+      var Iz = ye((C_r, JBe) => {
+        JBe.exports = function(e, t, r, n) {
+          n || (n = 1 / 0);
+          var i, a;
+          for (i = 0; i < t.length; i++) a = t[i], a.visible && (n = Math.min(n, a[r].length));
+          for (n === 1 / 0 && (n = 0), e._length = n, i = 0; i < t.length; i++) a = t[i], a.visible && (a._length = n);
+          return n;
+        };
+      });
+      var eNe = ye((L_r, QBe) => {
+        var wK = Dr(), lVt = Zd(), $Be = bK(), uVt = Ru(), cVt = $p(), fVt = Iz(), hVt = WF().isOpenSymbol;
+        QBe.exports = function(t, r, n, i) {
+          function a(d, v) {
+            return wK.coerce(t, r, $Be, d, v);
+          }
+          var o = lVt(t, r, { name: "dimensions", handleItemDefaults: dVt }), s = a("diagonal.visible"), l = a("showupperhalf"), u = a("showlowerhalf"), c = fVt(r, o, "values");
+          if (!c || !s && !l && !u) {
+            r.visible = false;
+            return;
+          }
+          a("text"), a("hovertext"), a("hovertemplate"), a("hovertemplatefallback"), a("xhoverformat"), a("yhoverformat"), cVt(t, r, n, i, a, { noAngleRef: true, noLineDash: true, noStandOff: true });
+          var f = hVt(r.marker.symbol), h = uVt.isBubble(r);
+          a("marker.line.width", f || h ? 1 : 0), vVt(t, r, i, a), wK.coerceSelectionMarkerOpacity(r, a);
+        };
+        function dVt(e, t) {
+          function r(i, a) {
+            return wK.coerce(e, t, $Be.dimensions, i, a);
+          }
+          r("label");
+          var n = r("values");
+          n && n.length ? r("visible") : t.visible = false, r("axis.type"), r("axis.matches");
+        }
+        function vVt(e, t, r, n) {
+          var i = t.dimensions, a = i.length, o = t.showupperhalf, s = t.showlowerhalf, l = t.diagonal.visible, u, c, f = new Array(a), h = new Array(a);
+          for (u = 0; u < a; u++) {
+            var d = u ? u + 1 : "";
+            f[u] = "x" + d, h[u] = "y" + d;
+          }
+          var v = n("xaxes", f), _ = n("yaxes", h), b = t._diag = new Array(a);
+          t._xaxes = {}, t._yaxes = {};
+          var p = [], k = [];
+          function E(z, O, U, G) {
+            if (z) {
+              var Z = z.charAt(0), j = r._splomAxes[Z];
+              if (t["_" + Z + "axes"][z] = 1, G.push(z), !(z in j)) {
+                var N = j[z] = {};
+                U && (N.label = U.label || "", U.visible && U.axis && (U.axis.type && (N.type = U.axis.type), U.axis.matches && (N.matches = O)));
+              }
+            }
+          }
+          var T = !l && !s, L = !l && !o;
+          for (t._axesDim = {}, u = 0; u < a; u++) {
+            var x = i[u], C = u === 0, M = u === a - 1, g = C && T || M && L ? void 0 : v[u], P = C && L || M && T ? void 0 : _[u];
+            E(g, P, x, p), E(P, g, x, k), b[u] = [g, P], t._axesDim[g] = u, t._axesDim[P] = u;
+          }
+          for (u = 0; u < p.length; u++) for (c = 0; c < k.length; c++) {
+            var A = p[u] + k[c];
+            (u > c && o || u < c && s || u === c && (l || !s || !o)) && (r._splomSubplots[A] = 1);
+          }
+          (!s || !l && o && s) && (r._splomGridDflt.xside = "bottom", r._splomGridDflt.yside = "left");
+        }
+      });
+      var iNe = ye((P_r, rNe) => {
+        var tNe = Dr();
+        rNe.exports = function(t, r) {
+          var n = t._fullLayout, i = r.uid, a = n._splomScenes;
+          a || (a = n._splomScenes = {});
+          var o = { dirty: true, selectBatch: [], unselectBatch: [] }, s = { matrix: false, selectBatch: [], unselectBatch: [] }, l = a[r.uid];
+          return l || (l = a[i] = tNe.extendFlat({}, o, s), l.draw = function() {
+            l.matrix && l.matrix.draw && (l.selectBatch.length || l.unselectBatch.length ? l.matrix.draw(l.unselectBatch, l.selectBatch) : l.matrix.draw()), l.dirty = false;
+          }, l.destroy = function() {
+            l.matrix && l.matrix.destroy && l.matrix.destroy(), l.matrixOptions = null, l.selectBatch = null, l.unselectBatch = null, l = null;
+          }), l.dirty || tNe.extendFlat(l, o), l;
+        };
+      });
+      var oNe = ye((I_r, aNe) => {
+        var TK = Dr(), Rz = hf(), pVt = q0().calcMarkerSize, gVt = q0().calcAxisExpansion, mVt = z0(), nNe = ow().markerSelection, yVt = ow().markerStyle, _Vt = iNe(), xVt = fs().BADNUM, bVt = px().TOO_MANY_POINTS;
+        aNe.exports = function(t, r) {
+          var n = r.dimensions, i = r._length, a = {}, o = a.cdata = [], s = a.data = [], l = r._visibleDims = [], u, c, f, h, d;
+          function v(E, T) {
+            for (var L = E.makeCalcdata({ v: T.values, vcalendar: r.calendar }, "v"), x = 0; x < L.length; x++) L[x] = L[x] === xVt ? NaN : L[x];
+            o.push(L), s.push(E.type === "log" ? TK.simpleMap(L, E.c2l) : L);
+          }
+          for (u = 0; u < n.length; u++) if (f = n[u], f.visible) {
+            if (h = Rz.getFromId(t, r._diag[u][0]), d = Rz.getFromId(t, r._diag[u][1]), h && d && h.type !== d.type) {
+              TK.log("Skipping splom dimension " + u + " with conflicting axis types");
+              continue;
+            }
+            h ? (v(h, f), d && d.type === "category" && (d._categories = h._categories.slice())) : v(d, f), l.push(u);
+          }
+          mVt(t, r), TK.extendFlat(a, yVt(t, r));
+          var _ = o.length, b = _ * i > bVt, p;
+          for (b ? p = a.sizeAvg || Math.max(a.size, 3) : p = pVt(r, i), c = 0; c < l.length; c++) u = l[c], f = n[u], h = Rz.getFromId(t, r._diag[u][0]) || {}, d = Rz.getFromId(t, r._diag[u][1]) || {}, gVt(t, r, h, d, o[c], o[c], p);
+          var k = _Vt(t, r);
+          return k.matrix || (k.matrix = true), k.matrixOptions = a, k.selectedOptions = nNe(t, r, r.selected), k.unselectedOptions = nNe(t, r, r.unselected), [{ x: false, y: false, t: {}, trace: r }];
+        };
+      });
+      var lNe = ye((sNe, Ok) => {
+        (function() {
+          var e, t, r, n, i, a;
+          typeof performance != "undefined" && performance !== null && performance.now ? Ok.exports = function() {
+            return performance.now();
+          } : typeof process != "undefined" && process !== null && process.hrtime ? (Ok.exports = function() {
+            return (e() - i) / 1e6;
+          }, t = process.hrtime, e = function() {
+            var o;
+            return o = t(), o[0] * 1e9 + o[1];
+          }, n = e(), a = process.uptime() * 1e9, i = n - a) : Date.now ? (Ok.exports = function() {
+            return Date.now() - r;
+          }, r = Date.now()) : (Ok.exports = function() {
+            return (/* @__PURE__ */ new Date()).getTime() - r;
+          }, r = (/* @__PURE__ */ new Date()).getTime());
+        }).call(sNe);
+      });
+      var cNe = ye((R_r, zz) => {
+        var wVt = lNe(), v1 = window, Dz = ["moz", "webkit"], w5 = "AnimationFrame", T5 = v1["request" + w5], qk = v1["cancel" + w5] || v1["cancelRequest" + w5];
+        for (b5 = 0; !T5 && b5 < Dz.length; b5++) T5 = v1[Dz[b5] + "Request" + w5], qk = v1[Dz[b5] + "Cancel" + w5] || v1[Dz[b5] + "CancelRequest" + w5];
+        var b5;
+        (!T5 || !qk) && (Fz = 0, AK = 0, Tx = [], uNe = 1e3 / 60, T5 = function(e) {
+          if (Tx.length === 0) {
+            var t = wVt(), r = Math.max(0, uNe - (t - Fz));
+            Fz = r + t, setTimeout(function() {
+              var n = Tx.slice(0);
+              Tx.length = 0;
+              for (var i = 0; i < n.length; i++) if (!n[i].cancelled) try {
+                n[i].callback(Fz);
+              } catch (a) {
+                setTimeout(function() {
+                  throw a;
+                }, 0);
+              }
+            }, Math.round(r));
+          }
+          return Tx.push({ handle: ++AK, callback: e, cancelled: false }), AK;
+        }, qk = function(e) {
+          for (var t = 0; t < Tx.length; t++) Tx[t].handle === e && (Tx[t].cancelled = true);
+        });
+        var Fz, AK, Tx, uNe;
+        zz.exports = function(e) {
+          return T5.call(v1, e);
+        };
+        zz.exports.cancel = function() {
+          qk.apply(v1, arguments);
+        };
+        zz.exports.polyfill = function(e) {
+          e || (e = v1), e.requestAnimationFrame = T5, e.cancelAnimationFrame = qk;
+        };
+      });
+      var hNe = ye((D_r, fNe) => {
+        fNe.exports = function(t, r) {
+          var n = typeof t == "number", i = typeof r == "number";
+          n && !i ? (r = t, t = 0) : !n && !i && (t = 0, r = 0), t = t | 0, r = r | 0;
+          var a = r - t;
+          if (a < 0) throw new Error("array length must be positive");
+          for (var o = new Array(a), s = 0, l = t; s < a; s++, l++) o[s] = l;
+          return o;
+        };
+      });
+      var gNe = ye((F_r, pNe) => {
+        var TVt = _Y(), AVt = ey(), SVt = rw(), dNe = cNe(), MVt = hNe(), SK = s5(), EVt = iw();
+        pNe.exports = Ax;
+        function Ax(e, t) {
+          if (!(this instanceof Ax)) return new Ax(e);
+          this.traces = [], this.passes = {}, this.regl = e, this.scatter = TVt(e), this.canvas = this.scatter.canvas;
+        }
+        Ax.prototype.render = function(...e) {
+          return e.length && this.update(...e), this.regl.attributes.preserveDrawingBuffer ? this.draw() : (this.dirty ? this.planned == null && (this.planned = dNe(() => {
+            this.draw(), this.dirty = true, this.planned = null;
+          })) : (this.draw(), this.dirty = true, dNe(() => {
+            this.dirty = false;
+          })), this);
+        };
+        Ax.prototype.update = function(...e) {
+          if (!e.length) return;
+          for (let n = 0; n < e.length; n++) this.updateItem(n, e[n]);
+          this.traces = this.traces.filter(Boolean);
+          let t = [], r = 0;
+          for (let n = 0; n < this.traces.length; n++) {
+            let i = this.traces[n], a = this.traces[n].passes;
+            for (let o = 0; o < a.length; o++) t.push(this.passes[a[o]]);
+            i.passOffset = r, r += i.passes.length;
+          }
+          return this.scatter.update(...t), this;
+        };
+        Ax.prototype.updateItem = function(e, t) {
+          let { regl: r } = this;
+          if (t === null) return this.traces[e] = null, this;
+          if (!t) return this;
+          let n = AVt(t, { data: "data items columns rows values dimensions samples x", snap: "snap cluster", size: "sizes size radius", color: "colors color fill fill-color fillColor", opacity: "opacity alpha transparency opaque", borderSize: "borderSizes borderSize border-size bordersize borderWidth borderWidths border-width borderwidth stroke-width strokeWidth strokewidth outline", borderColor: "borderColors borderColor bordercolor stroke stroke-color strokeColor", marker: "markers marker shape", range: "range ranges databox dataBox", viewport: "viewport viewBox viewbox", domain: "domain domains area areas", padding: "pad padding paddings pads margin margins", transpose: "transpose transposed", diagonal: "diagonal diag showDiagonal", upper: "upper up top upperhalf upperHalf showupperhalf showUpper showUpperHalf", lower: "lower low bottom lowerhalf lowerHalf showlowerhalf showLowerHalf showLower" }), i = this.traces[e] || (this.traces[e] = { id: e, buffer: r.buffer({ usage: "dynamic", type: "float", data: new Uint8Array() }), color: "black", marker: null, size: 12, borderColor: "transparent", borderSize: 1, viewport: SK([r._gl.drawingBufferWidth, r._gl.drawingBufferHeight]), padding: [0, 0, 0, 0], opacity: 1, diagonal: true, upper: true, lower: true });
+          if (n.color != null && (i.color = n.color), n.size != null && (i.size = n.size), n.marker != null && (i.marker = n.marker), n.borderColor != null && (i.borderColor = n.borderColor), n.borderSize != null && (i.borderSize = n.borderSize), n.opacity != null && (i.opacity = n.opacity), n.viewport && (i.viewport = SK(n.viewport)), n.diagonal != null && (i.diagonal = n.diagonal), n.upper != null && (i.upper = n.upper), n.lower != null && (i.lower = n.lower), n.data) {
+            i.buffer(EVt(n.data)), i.columns = n.data.length, i.count = n.data[0].length, i.bounds = [];
+            for (let _ = 0; _ < i.columns; _++) i.bounds[_] = SVt(n.data[_], 1);
+          }
+          let a;
+          n.range && (i.range = n.range, a = i.range && typeof i.range[0] != "number"), n.domain && (i.domain = n.domain);
+          let o = false;
+          n.padding != null && (Array.isArray(n.padding) && n.padding.length === i.columns && typeof n.padding[n.padding.length - 1] == "number" ? (i.padding = n.padding.map(vNe), o = true) : i.padding = vNe(n.padding));
+          let s = i.columns, l = i.count, u = i.viewport.width, c = i.viewport.height, f = i.viewport.x, h = i.viewport.y, d = u / s, v = c / s;
+          i.passes = [];
+          for (let _ = 0; _ < s; _++) for (let b = 0; b < s; b++) {
+            if (!i.diagonal && b === _ || !i.upper && _ > b || !i.lower && _ < b) continue;
+            let p = kVt(i.id, _, b), k = this.passes[p] || (this.passes[p] = {});
+            if (n.data && (n.transpose ? k.positions = { x: { buffer: i.buffer, offset: b, count: l, stride: s }, y: { buffer: i.buffer, offset: _, count: l, stride: s } } : k.positions = { x: { buffer: i.buffer, offset: b * l, count: l }, y: { buffer: i.buffer, offset: _ * l, count: l } }, k.bounds = Oz(i.bounds, _, b)), n.domain || n.viewport || n.data) {
+              let E = o ? Oz(i.padding, _, b) : i.padding;
+              if (i.domain) {
+                let [T, L, x, C] = Oz(i.domain, _, b);
+                k.viewport = [f + T * u + E[0], h + L * c + E[1], f + x * u - E[2], h + C * c - E[3]];
+              } else k.viewport = [f + b * d + d * E[0], h + _ * v + v * E[1], f + (b + 1) * d - d * E[2], h + (_ + 1) * v - v * E[3]];
+            }
+            n.color && (k.color = i.color), n.size && (k.size = i.size), n.marker && (k.marker = i.marker), n.borderSize && (k.borderSize = i.borderSize), n.borderColor && (k.borderColor = i.borderColor), n.opacity && (k.opacity = i.opacity), n.range && (k.range = a ? Oz(i.range, _, b) : i.range || k.bounds), i.passes.push(p);
+          }
+          return this;
+        };
+        Ax.prototype.draw = function(...e) {
+          if (!e.length) this.scatter.draw();
+          else {
+            let t = [];
+            for (let r = 0; r < e.length; r++) if (typeof e[r] == "number") {
+              let { passes: n, passOffset: i } = this.traces[e[r]];
+              t.push(...MVt(i, i + n.length));
+            } else if (e[r].length) {
+              let n = e[r], { passes: i, passOffset: a } = this.traces[r];
+              i = i.map((o, s) => {
+                t[a + s] = n;
+              });
+            }
+            this.scatter.draw(...t);
+          }
+          return this;
+        };
+        Ax.prototype.destroy = function() {
+          return this.traces.forEach((e) => {
+            e.buffer && e.buffer.destroy && e.buffer.destroy();
+          }), this.traces = null, this.passes = null, this.scatter.destroy(), this;
+        };
+        function kVt(e, t, r) {
+          let n = e.id != null ? e.id : e, i = t, a = r;
+          return n << 16 | (i & 255) << 8 | a & 255;
+        }
+        function Oz(e, t, r) {
+          let i, o, s, u, f = e[t], h = e[r];
+          return f.length > 2 ? (f[0], f[2], i = f[1], o = f[3]) : f.length ? (i = f[0], o = f[1]) : (f.x, i = f.y, f.x + f.width, o = f.y + f.height), h.length > 2 ? (s = h[0], u = h[2], h[1], h[3]) : h.length ? (s = h[0], u = h[1]) : (s = h.x, h.y, u = h.x + h.width, h.y + h.height), [s, i, u, o];
+        }
+        function vNe(e) {
+          if (typeof e == "number") return [e, e, e, e];
+          if (e.length === 2) return [e[0], e[1], e[0], e[1]];
+          {
+            let t = SK(e);
+            return [t.x, t.y, t.x + t.width, t.y + t.height];
+          }
+        }
+      });
+      var yNe = ye((z_r, mNe) => {
+        var CVt = gNe(), MK = Dr(), qz = hf(), LVt = Cg().selectMode;
+        mNe.exports = function(t, r, n) {
+          if (n.length) for (var i = 0; i < n.length; i++) PVt(t, n[i][0]);
+        };
+        function PVt(e, t) {
+          var r = e._fullLayout, n = r._size, i = t.trace, a = t.t, o = r._splomScenes[i.uid], s = o.matrixOptions, l = s.cdata, u = r._glcanvas.data()[0].regl, c = r.dragmode, f, h, d, v, _;
+          if (l.length !== 0) {
+            s.lower = i.showupperhalf, s.upper = i.showlowerhalf, s.diagonal = i.diagonal.visible;
+            var b = i._visibleDims, p = l.length, k = o.viewOpts = {};
+            for (k.ranges = new Array(p), k.domains = new Array(p), _ = 0; _ < b.length; _++) {
+              d = b[_];
+              var E = k.ranges[_] = new Array(4), T = k.domains[_] = new Array(4);
+              f = qz.getFromId(e, i._diag[d][0]), f && (E[0] = f._rl[0], E[2] = f._rl[1], T[0] = f.domain[0], T[2] = f.domain[1]), h = qz.getFromId(e, i._diag[d][1]), h && (E[1] = h._rl[0], E[3] = h._rl[1], T[1] = h.domain[0], T[3] = h.domain[1]);
+            }
+            var L = e._context.plotGlPixelRatio, x = n.l * L, C = n.b * L, M = n.w * L, g = n.h * L;
+            k.viewport = [x, C, M + x, g + C], o.matrix === true && (o.matrix = CVt(u));
+            var P = r.clickmode.indexOf("select") > -1, A = LVt(c) || !!i.selectedpoints || P, z = true;
+            if (A) {
+              var O = i._length;
+              if (i.selectedpoints) {
+                o.selectBatch = i.selectedpoints;
+                var U = i.selectedpoints, G = {};
+                for (d = 0; d < U.length; d++) G[U[d]] = true;
+                var Z = [];
+                for (d = 0; d < O; d++) G[d] || Z.push(d);
+                o.unselectBatch = Z;
+              }
+              var j = a.xpx = new Array(p), N = a.ypx = new Array(p);
+              for (_ = 0; _ < b.length; _++) {
+                if (d = b[_], f = qz.getFromId(e, i._diag[d][0]), f) for (j[_] = new Array(O), v = 0; v < O; v++) j[_][v] = f.c2p(l[_][v]);
+                if (h = qz.getFromId(e, i._diag[d][1]), h) for (N[_] = new Array(O), v = 0; v < O; v++) N[_][v] = h.c2p(l[_][v]);
+              }
+              if (o.selectBatch.length || o.unselectBatch.length) {
+                var H = MK.extendFlat({}, s, o.unselectedOptions, k), re = MK.extendFlat({}, s, o.selectedOptions, k);
+                o.matrix.update(H, re), z = false;
+              }
+            } else a.xpx = a.ypx = null;
+            if (z) {
+              var oe = MK.extendFlat({}, s, k);
+              o.matrix.update(oe, null);
+            }
+          }
+        }
+      });
+      var EK = ye((_Ne) => {
+        _Ne.getDimIndex = function(t, r) {
+          for (var n = r._id, i = n.charAt(0), a = { x: 0, y: 1 }[i], o = t._visibleDims, s = 0; s < o.length; s++) {
+            var l = o[s];
+            if (t._diag[l][a] === n) return s;
+          }
+          return false;
+        };
+      });
+      var ANe = ye((q_r, TNe) => {
+        var xNe = EK(), IVt = jF().calcHover, bNe = ho().getFromId, RVt = Ao().extendFlat;
+        function DVt(e, t, r, n, i) {
+          i || (i = {});
+          var a = (n || "").charAt(0) === "x", o = (n || "").charAt(0) === "y", s = wNe(e, t, r);
+          if ((a || o) && i.hoversubplots === "axis" && s[0]) for (var l = (a ? e.xa : e.ya)._subplotsWith, u = i.gd, c = RVt({}, e), f = 0; f < l.length; f++) {
+            var h = l[f];
+            if (h !== e.xa._id + e.ya._id) {
+              o ? c.xa = bNe(u, h, "x") : c.ya = bNe(u, h, "y");
+              var d = a || o, v = wNe(c, t, r, d);
+              s = s.concat(v);
+            }
+          }
+          return s;
+        }
+        function wNe(e, t, r, n) {
+          var i = e.cd, a = i[0].trace, o = e.scene, s = o.matrixOptions.cdata, l = e.xa, u = e.ya, c = l.c2p(t), f = u.c2p(r), h = e.distance, d = xNe.getDimIndex(a, l), v = xNe.getDimIndex(a, u);
+          if (d === false || v === false) return [e];
+          for (var _ = s[d], b = s[v], p, k, E = h, T = 0; T < _.length; T++) if (!(n && T !== e.index)) {
+            var L = _[T], x = b[T], C = l.c2p(L) - c, M = u.c2p(x) - f, g = Math.sqrt(C * C + M * M);
+            (n || g < E) && (E = k = g, p = T);
+          }
+          return e.index = p, e.distance = E, e.dxy = k, p === void 0 ? [e] : [IVt(e, _, b, a)];
+        }
+        TNe.exports = { hoverPoints: DVt };
+      });
+      var LNe = ye((B_r, CNe) => {
+        var kNe = Dr(), SNe = kNe.pushUnique, MNe = Ru(), ENe = EK();
+        CNe.exports = function(t, r) {
+          var n = t.cd, i = n[0].trace, a = n[0].t, o = t.scene, s = o.matrixOptions.cdata, l = t.xaxis, u = t.yaxis, c = [];
+          if (!o) return c;
+          var f = !MNe.hasMarkers(i) && !MNe.hasText(i);
+          if (i.visible !== true || f) return c;
+          var h = ENe.getDimIndex(i, l), d = ENe.getDimIndex(i, u);
+          if (h === false || d === false) return c;
+          var v = a.xpx[h], _ = a.ypx[d], b = s[h], p = s[d], k = (t.scene.selectBatch || []).slice(), E = [];
+          if (r !== false && !r.degenerate) for (var T = 0; T < b.length; T++) r.contains([v[T], _[T]], null, T, t) ? (c.push({ pointNumber: T, x: b[T], y: p[T] }), SNe(k, T)) : k.indexOf(T) !== -1 ? SNe(k, T) : E.push(T);
+          var L = o.matrixOptions;
+          return !k.length && !E.length ? o.matrix.update(L, null) : !o.selectBatch.length && !o.unselectBatch.length && o.matrix.update(o.unselectedOptions, kNe.extendFlat({}, L, o.selectedOptions, o.viewOpts)), o.selectBatch = k, o.unselectBatch = E, c;
+        };
+      });
+      var RNe = ye((N_r, INe) => {
+        var PNe = Dr(), FVt = z0(), zVt = ow().markerStyle;
+        INe.exports = function(t, r) {
+          var n = r.trace, i = t._fullLayout._splomScenes[n.uid];
+          if (i) {
+            FVt(t, n), PNe.extendFlat(i.matrixOptions, zVt(t, n));
+            var a = PNe.extendFlat({}, i.matrixOptions, i.viewOpts);
+            i.matrix.update(a, null);
+          }
+        };
+      });
+      var FNe = ye((U_r, DNe) => {
+        var OVt = qa(), qVt = yV();
+        DNe.exports = { moduleType: "trace", name: "splom", categories: ["gl", "regl", "cartesian", "symbols", "showLegend", "scatter-like"], attributes: bK(), supplyDefaults: eNe(), colorbar: $d(), calc: oNe(), plot: yNe(), hoverPoints: ANe().hoverPoints, selectPoints: LNe(), editStyle: RNe(), meta: {} };
+        OVt.register(qVt);
+      });
+      var UNe = ye((V_r, NNe) => {
+        var BVt = KY(), NVt = qa(), UVt = Lz(), VVt = Id().getModuleCalcData, Sx = mh(), zNe = hf().getFromId, ONe = ho().shouldShowZeroLine, qNe = "splom", BNe = {};
+        function GVt(e) {
+          var t = e._fullLayout, r = NVt.getModule(qNe), n = VVt(e.calcdata, r)[0], i = UVt(e, ["ANGLE_instanced_arrays", "OES_element_index_uint"], BNe);
+          i && (t._hasOnlyLargeSploms && kK(e), r.plot(e, {}, n));
+        }
+        function HVt(e) {
+          var t = e.calcdata, r = e._fullLayout;
+          r._hasOnlyLargeSploms && kK(e);
+          for (var n = 0; n < t.length; n++) {
+            var i = t[n][0], a = i.trace, o = r._splomScenes[a.uid];
+            a.type === "splom" && o && o.matrix && jVt(e, a, o);
+          }
+        }
+        function jVt(e, t, r) {
+          for (var n = r.matrixOptions.data.length, i = t._visibleDims, a = r.viewOpts.ranges = new Array(n), o = 0; o < i.length; o++) {
+            var s = i[o], l = a[o] = new Array(4), u = zNe(e, t._diag[s][0]);
+            u && (l[0] = u.r2l(u.range[0]), l[2] = u.r2l(u.range[1]));
+            var c = zNe(e, t._diag[s][1]);
+            c && (l[1] = c.r2l(c.range[0]), l[3] = c.r2l(c.range[1]));
+          }
+          r.selectBatch.length || r.unselectBatch.length ? r.matrix.update({ ranges: a }, { ranges: a }) : r.matrix.update({ ranges: a });
+        }
+        function kK(e) {
+          var t = e._fullLayout, r = t._glcanvas.data()[0].regl, n = t._splomGrid;
+          n || (n = t._splomGrid = BVt(r)), n.update(WVt(e));
+        }
+        function WVt(e) {
+          var t = e._context.plotGlPixelRatio, r = e._fullLayout, n = r._size, i = [0, 0, r.width * t, r.height * t], a = {}, o;
+          function s(x, C, M, g, P, A) {
+            M *= t, g *= t, P *= t, A *= t;
+            var z = C[x + "color"], O = C[x + "width"], U = String(z + O);
+            U in a ? a[U].data.push(NaN, NaN, M, g, P, A) : a[U] = { data: [M, g, P, A], join: "rect", thickness: O * t, color: z, viewport: i, range: i, overlay: false };
+          }
+          for (o in r._splomSubplots) {
+            var l = r._plots[o], u = l.xaxis, c = l.yaxis, f = u._gridVals, h = c._gridVals, d = u._offset, v = u._length, _ = c._length, b = n.b + c.domain[0] * n.h, p = -c._m, k = -p * c.r2l(c.range[0], c.calendar), E, T;
+            if (u.showgrid) for (o = 0; o < f.length; o++) E = d + u.l2p(f[o].x), s("grid", u, E, b, E, b + _);
+            if (c.showgrid) for (o = 0; o < h.length; o++) T = b + k + p * h[o].x, s("grid", c, d, T, d + v, T);
+            ONe(e, u, c) && (E = d + u.l2p(0), s("zeroline", u, E, b, E, b + _)), ONe(e, c, u) && (T = b + k + 0, s("zeroline", c, d, T, d + v, T));
+          }
+          var L = [];
+          for (o in a) L.push(a[o]);
+          return L;
+        }
+        function XVt(e, t, r, n) {
+          var i = {}, a;
+          if (n._splomScenes) {
+            for (a = 0; a < e.length; a++) {
+              var o = e[a];
+              o.type === "splom" && (i[o.uid] = 1);
+            }
+            for (a = 0; a < r.length; a++) {
+              var s = r[a];
+              if (!i[s.uid]) {
+                var l = n._splomScenes[s.uid];
+                l && l.destroy && l.destroy(), n._splomScenes[s.uid] = null, delete n._splomScenes[s.uid];
+              }
+            }
+          }
+          Object.keys(n._splomScenes || {}).length === 0 && delete n._splomScenes, n._splomGrid && !t._hasOnlyLargeSploms && n._hasOnlyLargeSploms && (n._splomGrid.destroy(), n._splomGrid = null, delete n._splomGrid), Sx.clean(e, t, r, n);
+        }
+        NNe.exports = { name: qNe, attr: Sx.attr, attrRegex: Sx.attrRegex, layoutAttributes: Sx.layoutAttributes, supplyLayoutDefaults: Sx.supplyLayoutDefaults, drawFramework: Sx.drawFramework, plot: GVt, drag: HVt, updateGrid: kK, clean: XVt, updateFx: Sx.updateFx, toSVG: Sx.toSVG, reglPrecompiled: BNe };
+      });
+      var HNe = ye((G_r, GNe) => {
+        var VNe = FNe();
+        VNe.basePlotModule = UNe(), GNe.exports = VNe;
+      });
+      var WNe = ye((H_r, jNe) => {
+        jNe.exports = HNe();
+      });
+      var PK = ye((j_r, XNe) => {
+        var ZVt = Tu(), CK = Rd(), LK = ec(), YVt = Cc().attributes, Bz = Ao().extendFlat, KVt = vl().templatedArray;
+        XNe.exports = { domain: YVt({ name: "parcoords", trace: true, editType: "plot" }), labelangle: { valType: "angle", dflt: 0, editType: "plot" }, labelside: { valType: "enumerated", values: ["top", "bottom"], dflt: "top", editType: "plot" }, labelfont: LK({ editType: "plot" }), tickfont: LK({ autoShadowDflt: true, editType: "plot" }), rangefont: LK({ editType: "plot" }), dimensions: KVt("dimension", { label: { valType: "string", editType: "plot" }, tickvals: Bz({}, CK.tickvals, { editType: "plot" }), ticktext: Bz({}, CK.ticktext, { editType: "plot" }), tickformat: Bz({}, CK.tickformat, { editType: "plot" }), visible: { valType: "boolean", dflt: true, editType: "plot" }, range: { valType: "info_array", items: [{ valType: "number", editType: "plot" }, { valType: "number", editType: "plot" }], editType: "plot" }, constraintrange: { valType: "info_array", freeLength: true, dimensions: "1-2", items: [{ valType: "any", editType: "plot" }, { valType: "any", editType: "plot" }], editType: "plot" }, multiselect: { valType: "boolean", dflt: true, editType: "plot" }, values: { valType: "data_array", editType: "calc" }, editType: "calc" }), line: Bz({ editType: "calc" }, ZVt("line", { colorscaleDflt: "Viridis", autoColorDflt: false, editTypeOverride: "calc" })), unselected: { line: { color: { valType: "color", dflt: "#7f7f7f", editType: "plot" }, opacity: { valType: "number", min: 0, max: 1, dflt: "auto", editType: "plot" }, editType: "plot" }, editType: "plot" } };
+      });
+      var Bk = ye((W_r, ZNe) => {
+        ZNe.exports = { maxDimensionCount: 60, overdrag: 45, verticalPadding: 2, tickDistance: 50, canvasPixelRatio: 1, blockLineCount: 5e3, layers: ["contextLineLayer", "focusLineLayer", "pickLineLayer"], axisTitleOffset: 28, axisExtentOffset: 10, bar: { width: 4, captureWidth: 10, fillColor: "magenta", fillOpacity: 1, snapDuration: 150, snapRatio: 0.25, snapClose: 0.01, strokeOpacity: 1, strokeWidth: 1, handleHeight: 8, handleOpacity: 1, handleOverlap: 0 }, cn: { axisExtentText: "axis-extent-text", parcoordsLineLayers: "parcoords-line-layers", parcoordsLineLayer: "parcoords-lines", parcoords: "parcoords", parcoordsControlView: "parcoords-control-view", yAxis: "y-axis", axisOverlays: "axis-overlays", axis: "axis", axisHeading: "axis-heading", axisTitle: "axis-title", axisExtent: "axis-extent", axisExtentTop: "axis-extent-top", axisExtentTopText: "axis-extent-top-text", axisExtentBottom: "axis-extent-bottom", axisExtentBottomText: "axis-extent-bottom-text", axisBrush: "axis-brush" }, id: { filterBarPattern: "filter-bar-pattern" } };
+      });
+      var iy = ye((X_r, KNe) => {
+        var JVt = ZS();
+        function YNe(e) {
+          return [e];
+        }
+        KNe.exports = { keyFun: function(e) {
+          return e.key;
+        }, repeat: YNe, descend: JVt, wrap: YNe, unwrap: function(e) {
+          return e[0];
+        } };
+      });
+      var DK = ye((Z_r, sUe) => {
+        var Th = Bk(), im = Oa(), $Vt = iy().keyFun, Nz = iy().repeat, A5 = Dr().sorterAsc, QVt = Dr().strTranslate, JNe = Th.bar.snapRatio;
+        function $Ne(e, t) {
+          return e * (1 - JNe) + t * JNe;
+        }
+        var QNe = Th.bar.snapClose;
+        function eGt(e, t) {
+          return e * (1 - QNe) + t * QNe;
+        }
+        function Vz(e, t, r, n) {
+          if (tGt(r, n)) return r;
+          var i = e ? -1 : 1, a = 0, o = t.length - 1;
+          if (i < 0) {
+            var s = a;
+            a = o, o = s;
+          }
+          for (var l = t[a], u = l, c = a; i * c < i * o; c += i) {
+            var f = c + i, h = t[f];
+            if (i * r < i * eGt(l, h)) return $Ne(l, u);
+            if (i * r < i * h || f === o) return $Ne(h, l);
+            u = l, l = h;
+          }
+        }
+        function tGt(e, t) {
+          for (var r = 0; r < t.length; r++) if (e >= t[r][0] && e <= t[r][1]) return true;
+          return false;
+        }
+        function rGt(e) {
+          e.attr("x", -Th.bar.captureWidth / 2).attr("width", Th.bar.captureWidth);
+        }
+        function iGt(e) {
+          e.attr("visibility", "visible").style("visibility", "visible").attr("fill", "yellow").attr("opacity", 0);
+        }
+        function nGt(e) {
+          if (!e.brush.filterSpecified) return "0," + e.height;
+          for (var t = eUe(e.brush.filter.getConsolidated(), e.height), r = [0], n, i, a, o = t.length ? t[0][0] : null, s = 0; s < t.length; s++) n = t[s], i = n[1] - n[0], r.push(o), r.push(i), a = s + 1, a < t.length && (o = t[a][0] - n[1]);
+          return r.push(e.height), r;
+        }
+        function eUe(e, t) {
+          return e.map(function(r) {
+            return r.map(function(n) {
+              return Math.max(0, n * t);
+            }).sort(A5);
+          });
+        }
+        function aGt(e, t) {
+          var r = Th.bar.handleHeight;
+          if (!(t > e[1] + r || t < e[0] - r)) return t >= 0.9 * e[1] + 0.1 * e[0] ? "n" : t <= 0.9 * e[0] + 0.1 * e[1] ? "s" : "ns";
+        }
+        function tUe() {
+          im.select(document.body).style("cursor", null);
+        }
+        function RK(e) {
+          e.attr("stroke-dasharray", nGt);
+        }
+        function Uz(e, t) {
+          var r = im.select(e).selectAll(".highlight, .highlight-shadow"), n = t ? r.transition().duration(Th.bar.snapDuration).each("end", t) : r;
+          RK(n);
+        }
+        function rUe(e, t) {
+          var r = e.brush, n = r.filterSpecified, i = NaN, a = {}, o;
+          if (n) {
+            var s = e.height, l = r.filter.getConsolidated(), u = eUe(l, s), c = NaN, f = NaN, h = NaN;
+            for (o = 0; o <= u.length; o++) {
+              var d = u[o];
+              if (d && d[0] <= t && t <= d[1]) {
+                c = o;
+                break;
+              } else if (f = o ? o - 1 : NaN, d && d[0] > t) {
+                h = o;
+                break;
+              }
+            }
+            if (i = c, isNaN(i) && (isNaN(f) || isNaN(h) ? i = isNaN(f) ? h : f : i = t - u[f][1] < u[h][0] - t ? f : h), !isNaN(i)) {
+              var v = u[i], _ = aGt(v, t);
+              _ && (a.interval = l[i], a.intervalPix = v, a.region = _);
+            }
+          }
+          if (e.ordinal && !a.region) {
+            var b = e.unitTickvals, p = e.unitToPaddedPx.invert(t);
+            for (o = 0; o < b.length; o++) {
+              var k = [b[Math.max(o - 1, 0)] * 0.25 + b[o] * 0.75, b[Math.min(o + 1, b.length - 1)] * 0.25 + b[o] * 0.75];
+              if (p >= k[0] && p <= k[1]) {
+                a.clickableOrdinalRange = k;
+                break;
+              }
+            }
+          }
+          return a;
+        }
+        function oGt(e, t) {
+          im.event.sourceEvent.stopPropagation();
+          var r = t.height - im.mouse(e)[1] - 2 * Th.verticalPadding, n = t.unitToPaddedPx.invert(r), i = t.brush, a = rUe(t, r), o = a.interval, s = i.svgBrush;
+          if (s.wasDragged = false, s.grabbingBar = a.region === "ns", s.grabbingBar) {
+            var l = o.map(t.unitToPaddedPx);
+            s.grabPoint = r - l[0] - Th.verticalPadding, s.barLength = l[1] - l[0];
+          }
+          s.clickableOrdinalRange = a.clickableOrdinalRange, s.stayingIntervals = t.multiselect && i.filterSpecified ? i.filter.getConsolidated() : [], o && (s.stayingIntervals = s.stayingIntervals.filter(function(u) {
+            return u[0] !== o[0] && u[1] !== o[1];
+          })), s.startExtent = a.region ? o[a.region === "s" ? 1 : 0] : n, t.parent.inBrushDrag = true, s.brushStartCallback();
+        }
+        function iUe(e, t) {
+          im.event.sourceEvent.stopPropagation();
+          var r = t.height - im.mouse(e)[1] - 2 * Th.verticalPadding, n = t.brush.svgBrush;
+          n.wasDragged = true, n._dragging = true, n.grabbingBar ? n.newExtent = [r - n.grabPoint, r + n.barLength - n.grabPoint].map(t.unitToPaddedPx.invert) : n.newExtent = [n.startExtent, t.unitToPaddedPx.invert(r)].sort(A5), t.brush.filterSpecified = true, n.extent = n.stayingIntervals.concat([n.newExtent]), n.brushCallback(t), Uz(e.parentNode);
+        }
+        function sGt(e, t) {
+          var r = t.brush, n = r.filter, i = r.svgBrush;
+          i._dragging || (nUe(e, t), iUe(e, t), t.brush.svgBrush.wasDragged = false), i._dragging = false;
+          var a = im.event;
+          a.sourceEvent.stopPropagation();
+          var o = i.grabbingBar;
+          if (i.grabbingBar = false, i.grabLocation = void 0, t.parent.inBrushDrag = false, tUe(), !i.wasDragged) {
+            i.wasDragged = void 0, i.clickableOrdinalRange ? r.filterSpecified && t.multiselect ? i.extent.push(i.clickableOrdinalRange) : (i.extent = [i.clickableOrdinalRange], r.filterSpecified = true) : o ? (i.extent = i.stayingIntervals, i.extent.length === 0 && IK(r)) : IK(r), i.brushCallback(t), Uz(e.parentNode), i.brushEndCallback(r.filterSpecified ? n.getConsolidated() : []);
+            return;
+          }
+          var s = function() {
+            n.set(n.getConsolidated());
+          };
+          if (t.ordinal) {
+            var l = t.unitTickvals;
+            l[l.length - 1] < l[0] && l.reverse(), i.newExtent = [Vz(0, l, i.newExtent[0], i.stayingIntervals), Vz(1, l, i.newExtent[1], i.stayingIntervals)];
+            var u = i.newExtent[1] > i.newExtent[0];
+            i.extent = i.stayingIntervals.concat(u ? [i.newExtent] : []), i.extent.length || IK(r), i.brushCallback(t), u ? Uz(e.parentNode, s) : (s(), Uz(e.parentNode));
+          } else s();
+          i.brushEndCallback(r.filterSpecified ? n.getConsolidated() : []);
+        }
+        function nUe(e, t) {
+          var r = t.height - im.mouse(e)[1] - 2 * Th.verticalPadding, n = rUe(t, r), i = "crosshair";
+          n.clickableOrdinalRange ? i = "pointer" : n.region && (i = n.region + "-resize"), im.select(document.body).style("cursor", i);
+        }
+        function lGt(e) {
+          e.on("mousemove", function(t) {
+            im.event.preventDefault(), t.parent.inBrushDrag || nUe(this, t);
+          }).on("mouseleave", function(t) {
+            t.parent.inBrushDrag || tUe();
+          }).call(im.behavior.drag().on("dragstart", function(t) {
+            oGt(this, t);
+          }).on("drag", function(t) {
+            iUe(this, t);
+          }).on("dragend", function(t) {
+            sGt(this, t);
+          }));
+        }
+        function aUe(e, t) {
+          return e[0] - t[0];
+        }
+        function uGt(e, t, r) {
+          var n = r._context.staticPlot, i = e.selectAll(".background").data(Nz);
+          i.enter().append("rect").classed("background", true).call(rGt).call(iGt).style("pointer-events", n ? "none" : "auto").attr("transform", QVt(0, Th.verticalPadding)), i.call(lGt).attr("height", function(s) {
+            return s.height - Th.verticalPadding;
+          });
+          var a = e.selectAll(".highlight-shadow").data(Nz);
+          a.enter().append("line").classed("highlight-shadow", true).attr("x", -Th.bar.width / 2).attr("stroke-width", Th.bar.width + Th.bar.strokeWidth).attr("stroke", t).attr("opacity", Th.bar.strokeOpacity).attr("stroke-linecap", "butt"), a.attr("y1", function(s) {
+            return s.height;
+          }).call(RK);
+          var o = e.selectAll(".highlight").data(Nz);
+          o.enter().append("line").classed("highlight", true).attr("x", -Th.bar.width / 2).attr("stroke-width", Th.bar.width - Th.bar.strokeWidth).attr("stroke", Th.bar.fillColor).attr("opacity", Th.bar.fillOpacity).attr("stroke-linecap", "butt"), o.attr("y1", function(s) {
+            return s.height;
+          }).call(RK);
+        }
+        function cGt(e, t, r) {
+          var n = e.selectAll("." + Th.cn.axisBrush).data(Nz, $Vt);
+          n.enter().append("g").classed(Th.cn.axisBrush, true), uGt(n, t, r);
+        }
+        function fGt(e) {
+          return e.svgBrush.extent.map(function(t) {
+            return t.slice();
+          });
+        }
+        function IK(e) {
+          e.filterSpecified = false, e.svgBrush.extent = [[-1 / 0, 1 / 0]];
+        }
+        function hGt(e) {
+          return function(r) {
+            var n = r.brush, i = fGt(n), a = i.slice();
+            n.filter.set(a), e();
+          };
+        }
+        function oUe(e) {
+          for (var t = e.slice(), r = [], n, i = t.shift(); i; ) {
+            for (n = i.slice(); (i = t.shift()) && i[0] <= n[1]; ) n[1] = Math.max(n[1], i[1]);
+            r.push(n);
+          }
+          return r.length === 1 && r[0][0] > r[0][1] && (r = []), r;
+        }
+        function dGt() {
+          var e = [], t, r;
+          return { set: function(n) {
+            e = n.map(function(i) {
+              return i.slice().sort(A5);
+            }).sort(aUe), e.length === 1 && e[0][0] === -1 / 0 && e[0][1] === 1 / 0 && (e = [[0, -1]]), t = oUe(e), r = e.reduce(function(i, a) {
+              return [Math.min(i[0], a[0]), Math.max(i[1], a[1])];
+            }, [1 / 0, -1 / 0]);
+          }, get: function() {
+            return e.slice();
+          }, getConsolidated: function() {
+            return t;
+          }, getBounds: function() {
+            return r;
+          } };
+        }
+        function vGt(e, t, r, n, i, a) {
+          var o = dGt();
+          return o.set(r), { filter: o, filterSpecified: t, svgBrush: { extent: [], brushStartCallback: n, brushCallback: hGt(i), brushEndCallback: a } };
+        }
+        function pGt(e, t) {
+          if (Array.isArray(e[0]) ? (e = e.map(function(n) {
+            return n.sort(A5);
+          }), t.multiselect ? e = oUe(e.sort(aUe)) : e = [e[0]]) : e = [e.sort(A5)], t.tickvals) {
+            var r = t.tickvals.slice().sort(A5);
+            if (e = e.map(function(n) {
+              var i = [Vz(0, r, n[0], []), Vz(1, r, n[1], [])];
+              if (i[1] > i[0]) return i;
+            }).filter(function(n) {
+              return n;
+            }), !e.length) return;
+          }
+          return e.length > 1 ? e : e[0];
+        }
+        sUe.exports = { makeBrush: vGt, ensureAxisBrush: cGt, cleanRanges: pGt };
+      });
+      var cUe = ye((Y_r, uUe) => {
+        var Mx = Dr(), gGt = pv().hasColorscale, mGt = td(), yGt = Cc().defaults, _Gt = Zd(), xGt = ho(), lUe = PK(), bGt = DK(), FK = Bk().maxDimensionCount, wGt = Iz();
+        function TGt(e, t, r, n, i) {
+          var a = i("line.color", r);
+          if (gGt(e, "line") && Mx.isArrayOrTypedArray(a)) {
+            if (a.length) return i("line.colorscale"), mGt(e, t, n, i, { prefix: "line.", cLetter: "c" }), a.length;
+            t.line.color = r;
+          }
+          return 1 / 0;
+        }
+        function AGt(e, t, r, n) {
+          function i(u, c) {
+            return Mx.coerce(e, t, lUe.dimensions, u, c);
+          }
+          var a = i("values"), o = i("visible");
+          if (a && a.length || (o = t.visible = false), o) {
+            i("label"), i("tickvals"), i("ticktext"), i("tickformat");
+            var s = i("range");
+            t._ax = { _id: "y", type: "linear", showexponent: "all", exponentformat: "B", range: s }, xGt.setConvert(t._ax, n.layout), i("multiselect");
+            var l = i("constraintrange");
+            l && (t.constraintrange = bGt.cleanRanges(l, t));
+          }
+        }
+        uUe.exports = function(t, r, n, i) {
+          function a(c, f) {
+            return Mx.coerce(t, r, lUe, c, f);
+          }
+          var o = t.dimensions;
+          Array.isArray(o) && o.length > FK && (Mx.log("parcoords traces support up to " + FK + " dimensions at the moment"), o.splice(FK));
+          var s = _Gt(t, r, { name: "dimensions", layout: i, handleItemDefaults: AGt }), l = TGt(t, r, n, i, a);
+          yGt(r, i, a), (!Array.isArray(s) || !s.length) && (r.visible = false), wGt(r, s, "values", l);
+          var u = Mx.extendFlat({}, i.font, { size: Math.round(i.font.size / 1.2) });
+          Mx.coerceFont(a, "labelfont", u), Mx.coerceFont(a, "tickfont", u, { autoShadowDflt: true }), Mx.coerceFont(a, "rangefont", u), a("labelangle"), a("labelside"), a("unselected.line.color"), a("unselected.line.opacity");
+        };
+      });
+      var hUe = ye((K_r, fUe) => {
+        var SGt = Dr().isArrayOrTypedArray, zK = tc(), MGt = iy().wrap;
+        fUe.exports = function(t, r) {
+          var n, i;
+          return zK.hasColorscale(r, "line") && SGt(r.line.color) ? (n = r.line.color, i = zK.extractOpts(r.line).colorscale, zK.calc(t, r, { vals: n, containerStr: "line", cLetter: "c" })) : (n = EGt(r._length), i = [[0, r.line.color], [1, r.line.color]]), MGt({ lineColor: n, cscale: i });
+        };
+        function EGt(e) {
+          for (var t = new Array(e), r = 0; r < e; r++) t[r] = 0.5;
+          return t;
+        }
+      });
+      function kGt(e) {
+        var c, f;
+        var t, r = [], n = 1, i;
+        if (typeof e == "number") return { space: "rgb", values: [e >>> 16, (e & 65280) >>> 8, e & 255], alpha: 1 };
+        if (typeof e == "number") return { space: "rgb", values: [e >>> 16, (e & 65280) >>> 8, e & 255], alpha: 1 };
+        if (e = String(e).toLowerCase(), OK.default[e]) r = OK.default[e].slice(), i = "rgb";
+        else if (e === "transparent") n = 0, i = "rgb", r = [0, 0, 0];
+        else if (e[0] === "#") {
+          var a = e.slice(1), o = a.length, s = o <= 4;
+          n = 1, s ? (r = [parseInt(a[0] + a[0], 16), parseInt(a[1] + a[1], 16), parseInt(a[2] + a[2], 16)], o === 4 && (n = parseInt(a[3] + a[3], 16) / 255)) : (r = [parseInt(a[0] + a[1], 16), parseInt(a[2] + a[3], 16), parseInt(a[4] + a[5], 16)], o === 8 && (n = parseInt(a[6] + a[7], 16) / 255)), r[0] || (r[0] = 0), r[1] || (r[1] = 0), r[2] || (r[2] = 0), i = "rgb";
+        } else if (t = /^((?:rgba?|hs[lvb]a?|hwba?|cmyk?|xy[zy]|gray|lab|lchu?v?|[ly]uv|lms|oklch|oklab|color))\s*\(([^\)]*)\)/.exec(e)) {
+          var l = t[1];
+          i = l.replace(/a$/, "");
+          var u = i === "cmyk" ? 4 : i === "gray" ? 1 : 3;
+          r = t[2].trim().split(/\s*[,\/]\s*|\s+/), i === "color" && (i = r.shift()), r = r.map(function(h, d) {
+            if (h[h.length - 1] === "%") return h = parseFloat(h) / 100, d === 3 ? h : i === "rgb" ? h * 255 : i[0] === "h" || i[0] === "l" && !d ? h * 100 : i === "lab" ? h * 125 : i === "lch" ? d < 2 ? h * 150 : h * 360 : i[0] === "o" && !d ? h : i === "oklab" ? h * 0.4 : i === "oklch" ? d < 2 ? h * 0.4 : h * 360 : h;
+            if (i[d] === "h" || d === 2 && i[i.length - 1] === "h") {
+              if (dUe[h] !== void 0) return dUe[h];
+              if (h.endsWith("deg")) return parseFloat(h);
+              if (h.endsWith("turn")) return parseFloat(h) * 360;
+              if (h.endsWith("grad")) return parseFloat(h) * 360 / 400;
+              if (h.endsWith("rad")) return parseFloat(h) * 180 / Math.PI;
+            }
+            return h === "none" ? 0 : parseFloat(h);
+          }), n = r.length > u ? r.pop() : 1;
+        } else /[0-9](?:\s|\/|,)/.test(e) && (r = e.match(/([0-9]+)/g).map(function(h) {
+          return parseFloat(h);
+        }), i = ((f = (c = e.match(/([a-z])/ig)) == null ? void 0 : c.join("")) == null ? void 0 : f.toLowerCase()) || "rgb");
+        return { space: i, values: r, alpha: n };
+      }
+      var OK, vUe, dUe, pUe = gu(() => {
+        OK = Att(TX()), vUe = kGt, dUe = { red: 0, orange: 60, yellow: 120, green: 180, blue: 240, purple: 300 };
+      });
+      var Nk, qK = gu(() => {
+        Nk = { name: "rgb", min: [0, 0, 0], max: [255, 255, 255], channel: ["red", "green", "blue"], alias: ["RGB"] };
+      });
+      var Gz, gUe = gu(() => {
+        qK();
+        Gz = { name: "hsl", min: [0, 0, 0], max: [360, 100, 100], channel: ["hue", "saturation", "lightness"], alias: ["HSL"], rgb: function(e) {
+          var t = e[0] / 360, r = e[1] / 100, n = e[2] / 100, i, a, o, s, l, u = 0;
+          if (r === 0) return l = n * 255, [l, l, l];
+          for (a = n < 0.5 ? n * (1 + r) : n + r - n * r, i = 2 * n - a, s = [0, 0, 0]; u < 3; ) o = t + 1 / 3 * -(u - 1), o < 0 ? o++ : o > 1 && o--, l = 6 * o < 1 ? i + (a - i) * 6 * o : 2 * o < 1 ? a : 3 * o < 2 ? i + (a - i) * (2 / 3 - o) * 6 : i, s[u++] = l * 255;
+          return s;
+        } };
+        Nk.hsl = function(e) {
+          var t = e[0] / 255, r = e[1] / 255, n = e[2] / 255, i = Math.min(t, r, n), a = Math.max(t, r, n), o = a - i, s, l, u;
+          return a === i ? s = 0 : t === a ? s = (r - n) / o : r === a ? s = 2 + (n - t) / o : n === a && (s = 4 + (t - r) / o), s = Math.min(s * 60, 360), s < 0 && (s += 360), u = (i + a) / 2, a === i ? l = 0 : u <= 0.5 ? l = o / (a + i) : l = o / (2 - a - i), [s, l * 100, u * 100];
+        };
+      });
+      var yUe = {};
+      mee(yUe, { default: () => mUe });
+      function mUe(e) {
+        Array.isArray(e) && e.raw && (e = String.raw(...arguments)), e instanceof Number && (e = +e);
+        var t, i = vUe(e);
+        if (!i.space) return [];
+        let a = i.space[0] === "h" ? Gz.min : Nk.min, o = i.space[0] === "h" ? Gz.max : Nk.max;
+        return t = Array(3), t[0] = Math.min(Math.max(i.values[0], a[0]), o[0]), t[1] = Math.min(Math.max(i.values[1], a[1]), o[1]), t[2] = Math.min(Math.max(i.values[2], a[2]), o[2]), i.space[0] === "h" && (t = Gz.rgb(t)), t.push(Math.min(Math.max(i.alpha, 0), 1)), t;
+      }
+      var _Ue = gu(() => {
+        pUe();
+        qK();
+        gUe();
+      });
+      var BK = ye((Hz) => {
+        var CGt = Dr().isTypedArray;
+        Hz.convertTypedArray = function(e) {
+          return CGt(e) ? Array.prototype.slice.call(e) : e;
+        };
+        Hz.isOrdinal = function(e) {
+          return !!e.tickvals;
+        };
+        Hz.isVisible = function(e) {
+          return e.visible || !("visible" in e);
+        };
+      });
+      var CUe = ye((axr, kUe) => {
+        var LGt = ["precision highp float;", "", "varying vec4 fragColor;", "", "attribute vec4 p01_04, p05_08, p09_12, p13_16,", "               p17_20, p21_24, p25_28, p29_32,", "               p33_36, p37_40, p41_44, p45_48,", "               p49_52, p53_56, p57_60, colors;", "", "uniform mat4 dim0A, dim1A, dim0B, dim1B, dim0C, dim1C, dim0D, dim1D,", "             loA, hiA, loB, hiB, loC, hiC, loD, hiD;", "", "uniform vec2 resolution, viewBoxPos, viewBoxSize;", "uniform float maskHeight;", "uniform float drwLayer; // 0: context, 1: focus, 2: pick", "uniform vec4 contextColor;", "uniform sampler2D maskTexture, palette;", "", "bool isPick    = (drwLayer > 1.5);", "bool isContext = (drwLayer < 0.5);", "", "const vec4 ZEROS = vec4(0.0, 0.0, 0.0, 0.0);", "const vec4 UNITS = vec4(1.0, 1.0, 1.0, 1.0);", "", "float val(mat4 p, mat4 v) {", "    return dot(matrixCompMult(p, v) * UNITS, UNITS);", "}", "", "float axisY(float ratio, mat4 A, mat4 B, mat4 C, mat4 D) {", "    float y1 = val(A, dim0A) + val(B, dim0B) + val(C, dim0C) + val(D, dim0D);", "    float y2 = val(A, dim1A) + val(B, dim1B) + val(C, dim1C) + val(D, dim1D);", "    return y1 * (1.0 - ratio) + y2 * ratio;", "}", "", "int iMod(int a, int b) {", "    return a - b * (a / b);", "}", "", "bool fOutside(float p, float lo, float hi) {", "    return (lo < hi) && (lo > p || p > hi);", "}", "", "bool vOutside(vec4 p, vec4 lo, vec4 hi) {", "    return (", "        fOutside(p[0], lo[0], hi[0]) ||", "        fOutside(p[1], lo[1], hi[1]) ||", "        fOutside(p[2], lo[2], hi[2]) ||", "        fOutside(p[3], lo[3], hi[3])", "    );", "}", "", "bool mOutside(mat4 p, mat4 lo, mat4 hi) {", "    return (", "        vOutside(p[0], lo[0], hi[0]) ||", "        vOutside(p[1], lo[1], hi[1]) ||", "        vOutside(p[2], lo[2], hi[2]) ||", "        vOutside(p[3], lo[3], hi[3])", "    );", "}", "", "bool outsideBoundingBox(mat4 A, mat4 B, mat4 C, mat4 D) {", "    return mOutside(A, loA, hiA) ||", "           mOutside(B, loB, hiB) ||", "           mOutside(C, loC, hiC) ||", "           mOutside(D, loD, hiD);", "}", "", "bool outsideRasterMask(mat4 A, mat4 B, mat4 C, mat4 D) {", "    mat4 pnts[4];", "    pnts[0] = A;", "    pnts[1] = B;", "    pnts[2] = C;", "    pnts[3] = D;", "", "    for(int i = 0; i < 4; ++i) {", "        for(int j = 0; j < 4; ++j) {", "            for(int k = 0; k < 4; ++k) {", "                if(0 == iMod(", "                    int(255.0 * texture2D(maskTexture,", "                        vec2(", "                            (float(i * 2 + j / 2) + 0.5) / 8.0,", "                            (pnts[i][j][k] * (maskHeight - 1.0) + 1.0) / maskHeight", "                        ))[3]", "                    ) / int(pow(2.0, float(iMod(j * 4 + k, 8)))),", "                    2", "                )) return true;", "            }", "        }", "    }", "    return false;", "}", "", "vec4 position(bool isContext, float v, mat4 A, mat4 B, mat4 C, mat4 D) {", "    float x = 0.5 * sign(v) + 0.5;", "    float y = axisY(x, A, B, C, D);", "    float z = 1.0 - abs(v);", "", "    z += isContext ? 0.0 : 2.0 * float(", "        outsideBoundingBox(A, B, C, D) ||", "        outsideRasterMask(A, B, C, D)", "    );", "", "    return vec4(", "        2.0 * (vec2(x, y) * viewBoxSize + viewBoxPos) / resolution - 1.0,", "        z,", "        1.0", "    );", "}", "", "void main() {", "    mat4 A = mat4(p01_04, p05_08, p09_12, p13_16);", "    mat4 B = mat4(p17_20, p21_24, p25_28, p29_32);", "    mat4 C = mat4(p33_36, p37_40, p41_44, p45_48);", "    mat4 D = mat4(p49_52, p53_56, p57_60, ZEROS);", "", "    float v = colors[3];", "", "    gl_Position = position(isContext, v, A, B, C, D);", "", "    fragColor =", "        isContext ? vec4(contextColor) :", "        isPick ? vec4(colors.rgb, 1.0) : texture2D(palette, vec2(abs(v), 0.5));", "}"].join(`
+`), PGt = ["precision highp float;", "", "varying vec4 fragColor;", "", "void main() {", "    gl_FragColor = fragColor;", "}"].join(`
+`), Uk = Bk().maxDimensionCount, SUe = Dr(), xUe = 1e-6, jz = 2048, IGt = new Uint8Array(4), bUe = new Uint8Array(4), wUe = { shape: [256, 1], format: "rgba", type: "uint8", mag: "nearest", min: "nearest" };
+        function RGt(e) {
+          e.read({ x: 0, y: 0, width: 1, height: 1, data: IGt });
+        }
+        function MUe(e, t, r, n, i) {
+          var a = e._gl;
+          a.enable(a.SCISSOR_TEST), a.scissor(t, r, n, i), e.clear({ color: [0, 0, 0, 0], depth: 1 });
+        }
+        function DGt(e, t, r, n, i, a) {
+          var o = a.key;
+          function s(l) {
+            var u = Math.min(n, i - l * n);
+            l === 0 && (window.cancelAnimationFrame(r.currentRafs[o]), delete r.currentRafs[o], MUe(e, a.scissorX, a.scissorY, a.scissorWidth, a.viewBoxSize[1])), !r.clearOnly && (a.count = 2 * u, a.offset = 2 * l * n, t(a), l * n + u < i && (r.currentRafs[o] = window.requestAnimationFrame(function() {
+              s(l + 1);
+            })), r.drawCompleted = false);
+          }
+          r.drawCompleted || (RGt(e), r.drawCompleted = true), s(0);
+        }
+        function FGt(e) {
+          return Math.max(xUe, Math.min(1 - xUe, e));
+        }
+        function zGt(e, t) {
+          for (var r = new Array(256), n = 0; n < 256; n++) r[n] = e(n / 255).concat(t);
+          return r;
+        }
+        function NK(e, t) {
+          return (e >>> 8 * t) % 256 / 255;
+        }
+        function OGt(e, t, r) {
+          for (var n = new Array(e * (Uk + 4)), i = 0, a = 0; a < e; a++) {
+            for (var o = 0; o < Uk; o++) n[i++] = o < t.length ? t[o].paddedUnitValues[a] : 0.5;
+            n[i++] = NK(a, 2), n[i++] = NK(a, 1), n[i++] = NK(a, 0), n[i++] = FGt(r[a]);
+          }
+          return n;
+        }
+        function qGt(e, t, r) {
+          for (var n = new Array(t * 8), i = 0, a = 0; a < t; a++) for (var o = 0; o < 2; o++) for (var s = 0; s < 4; s++) {
+            var l = e * 4 + s, u = r[a * 64 + l];
+            l === 63 && o === 0 && (u *= -1), n[i++] = u;
+          }
+          return n;
+        }
+        function TUe(e) {
+          var t = "0" + e;
+          return t.slice(-2);
+        }
+        function EUe(e) {
+          return e < Uk ? "p" + TUe(e + 1) + "_" + TUe(e + 4) : "colors";
+        }
+        function BGt(e, t, r) {
+          for (var n = 0; n <= Uk; n += 4) e[EUe(n)](qGt(n / 4, t, r));
+        }
+        function NGt(e) {
+          for (var t = {}, r = 0; r <= Uk; r += 4) t[EUe(r)] = e.buffer({ usage: "dynamic", type: "float", data: new Uint8Array(0) });
+          return t;
+        }
+        function UGt(e, t, r, n, i, a, o, s, l, u, c, f, h, d) {
+          for (var v = [[], []], _ = 0; _ < 64; _++) v[0][_] = _ === i ? 1 : 0, v[1][_] = _ === a ? 1 : 0;
+          o *= d, s *= d, l *= d, u *= d;
+          var b = e.lines.canvasOverdrag * d, p = e.domain, k = e.canvasWidth * d, E = e.canvasHeight * d, T = e.pad.l * d, L = e.pad.b * d, x = e.layoutHeight * d, C = e.layoutWidth * d, M = e.deselectedLines.color, g = e.deselectedLines.opacity, P = SUe.extendFlat({ key: c, resolution: [k, E], viewBoxPos: [o + b, s], viewBoxSize: [l, u], i0: i, i1: a, dim0A: v[0].slice(0, 16), dim0B: v[0].slice(16, 32), dim0C: v[0].slice(32, 48), dim0D: v[0].slice(48, 64), dim1A: v[1].slice(0, 16), dim1B: v[1].slice(16, 32), dim1C: v[1].slice(32, 48), dim1D: v[1].slice(48, 64), drwLayer: f, contextColor: [M[0] / 255, M[1] / 255, M[2] / 255, g !== "auto" ? M[3] * g : Math.max(1 / 255, Math.pow(1 / e.lines.color.length, 1 / 3))], scissorX: (n === t ? 0 : o + b) + (T - b) + C * p.x[0], scissorWidth: (n === r ? k - o + b : l + 0.5) + (n === t ? o + b : 0), scissorY: s + L + x * p.y[0], scissorHeight: u, viewportX: T - b + C * p.x[0], viewportY: L + x * p.y[0], viewportWidth: k, viewportHeight: E }, h);
+          return P;
+        }
+        function AUe(e) {
+          var t = jz - 1, r = Math.max(0, Math.floor(e[0] * t), 0), n = Math.min(t, Math.ceil(e[1] * t), t);
+          return [Math.min(r, n), Math.max(r, n)];
+        }
+        kUe.exports = function(e, t) {
+          var r = t.context, n = t.pick, i = t.regl, a = i._gl, o = a.getParameter(a.ALIASED_LINE_WIDTH_RANGE), s = Math.max(o[0], Math.min(o[1], t.viewModel.plotGlPixelRatio)), l = { currentRafs: {}, drawCompleted: true, clearOnly: false }, u, c, f, h, d = NGt(i), v, _ = i.texture(wUe), b = [];
+          k(t);
+          var p = i({ profile: false, blend: { enable: r, func: { srcRGB: "src alpha", dstRGB: "one minus src alpha", srcAlpha: 1, dstAlpha: 1 }, equation: { rgb: "add", alpha: "add" }, color: [0, 0, 0, 0] }, depth: { enable: !r, mask: true, func: "less", range: [0, 1] }, cull: { enable: true, face: "back" }, scissor: { enable: true, box: { x: i.prop("scissorX"), y: i.prop("scissorY"), width: i.prop("scissorWidth"), height: i.prop("scissorHeight") } }, viewport: { x: i.prop("viewportX"), y: i.prop("viewportY"), width: i.prop("viewportWidth"), height: i.prop("viewportHeight") }, dither: false, vert: LGt, frag: PGt, primitive: "lines", lineWidth: s, attributes: d, uniforms: { resolution: i.prop("resolution"), viewBoxPos: i.prop("viewBoxPos"), viewBoxSize: i.prop("viewBoxSize"), dim0A: i.prop("dim0A"), dim1A: i.prop("dim1A"), dim0B: i.prop("dim0B"), dim1B: i.prop("dim1B"), dim0C: i.prop("dim0C"), dim1C: i.prop("dim1C"), dim0D: i.prop("dim0D"), dim1D: i.prop("dim1D"), loA: i.prop("loA"), hiA: i.prop("hiA"), loB: i.prop("loB"), hiB: i.prop("hiB"), loC: i.prop("loC"), hiC: i.prop("hiC"), loD: i.prop("loD"), hiD: i.prop("hiD"), palette: _, contextColor: i.prop("contextColor"), maskTexture: i.prop("maskTexture"), drwLayer: i.prop("drwLayer"), maskHeight: i.prop("maskHeight") }, offset: i.prop("offset"), count: i.prop("count") });
+          function k(M) {
+            u = M.model, c = M.viewModel, f = c.dimensions.slice(), h = f[0] ? f[0].values.length : 0;
+            var g = u.lines, P = n ? g.color.map(function(z, O) {
+              return O / g.color.length;
+            }) : g.color, A = OGt(h, f, P);
+            BGt(d, h, A), !r && !n && (_ = i.texture(SUe.extendFlat({ data: zGt(u.unitToColor, 255) }, wUe)));
+          }
+          function E(M) {
+            var g, P, A, z = [[], []];
+            for (A = 0; A < 64; A++) {
+              var O = !M && A < f.length ? f[A].brush.filter.getBounds() : [-1 / 0, 1 / 0];
+              z[0][A] = O[0], z[1][A] = O[1];
+            }
+            var U = jz * 8, G = new Array(U);
+            for (g = 0; g < U; g++) G[g] = 255;
+            if (!M) for (g = 0; g < f.length; g++) {
+              var Z = g % 8, j = (g - Z) / 8, N = Math.pow(2, Z), H = f[g], re = H.brush.filter.get();
+              if (!(re.length < 2)) {
+                var oe = AUe(re[0])[1];
+                for (P = 1; P < re.length; P++) {
+                  var _e = AUe(re[P]);
+                  for (A = oe + 1; A < _e[0]; A++) G[A * 8 + j] &= ~N;
+                  oe = Math.max(oe, _e[1]);
+                }
+              }
+            }
+            var Ce = { shape: [8, jz], format: "alpha", type: "uint8", mag: "nearest", min: "nearest", data: G };
+            return v ? v(Ce) : v = i.texture(Ce), { maskTexture: v, maskHeight: jz, loA: z[0].slice(0, 16), loB: z[0].slice(16, 32), loC: z[0].slice(32, 48), loD: z[0].slice(48, 64), hiA: z[1].slice(0, 16), hiB: z[1].slice(16, 32), hiC: z[1].slice(32, 48), hiD: z[1].slice(48, 64) };
+          }
+          function T(M, g, P) {
+            var A = M.length, z, O, U, G = 1 / 0, Z = -1 / 0;
+            for (z = 0; z < A; z++) M[z].dim0.canvasX < G && (G = M[z].dim0.canvasX, O = z), M[z].dim1.canvasX > Z && (Z = M[z].dim1.canvasX, U = z);
+            A === 0 && MUe(i, 0, 0, u.canvasWidth, u.canvasHeight);
+            var j = E(r);
+            for (z = 0; z < A; z++) {
+              var N = M[z], H = N.dim0.crossfilterDimensionIndex, re = N.dim1.crossfilterDimensionIndex, oe = N.canvasX, _e = N.canvasY, Ce = oe + N.panelSizeX, Le = N.plotGlPixelRatio;
+              if (g || !b[H] || b[H][0] !== oe || b[H][1] !== Ce) {
+                b[H] = [oe, Ce];
+                var ge = UGt(u, O, U, z, H, re, oe, _e, N.panelSizeX, N.panelSizeY, N.dim0.crossfilterDimensionIndex, r ? 0 : n ? 2 : 1, j, Le);
+                l.clearOnly = P;
+                var ie = g ? u.lines.blockLineCount : h;
+                DGt(i, p, l, ie, h, ge);
+              }
+            }
+          }
+          function L(M, g) {
+            return i.read({ x: M, y: g, width: 1, height: 1, data: bUe }), bUe;
+          }
+          function x(M, g, P, A) {
+            var z = new Uint8Array(4 * P * A);
+            return i.read({ x: M, y: g, width: P, height: A, data: z }), z;
+          }
+          function C() {
+            e.style["pointer-events"] = "none", _.destroy(), v && v.destroy();
+            for (var M in d) d[M].destroy();
+          }
+          return { render: T, readPixel: L, readPixels: x, destroy: C, update: k };
+        };
+      });
+      var GUe = ye((oxr, VUe) => {
+        var qd = Oa(), p1 = Dr(), UK = p1.isArrayOrTypedArray, FUe = p1.numberFormat, zUe = (_Ue(), pb(yUe)).default, OUe = ho(), VGt = p1.strRotate, ny = p1.strTranslate, GGt = Zl(), Wz = So(), LUe = tc(), HK = iy(), ig = HK.keyFun, ay = HK.repeat, qUe = HK.unwrap, S5 = BK(), Dl = Bk(), BUe = DK(), HGt = CUe();
+        function PUe(e, t, r) {
+          return p1.aggNums(e, null, t, r);
+        }
+        function NUe(e, t) {
+          return jK(PUe(Math.min, e, t), PUe(Math.max, e, t));
+        }
+        function Xz(e) {
+          var t = e.range;
+          return t ? jK(t[0], t[1]) : NUe(e.values, e._length);
+        }
+        function jK(e, t) {
+          return (isNaN(e) || !isFinite(e)) && (e = 0), (isNaN(t) || !isFinite(t)) && (t = 0), e === t && (e === 0 ? (e -= 1, t += 1) : (e *= 0.9, t *= 1.1)), [e, t];
+        }
+        function jGt(e, t) {
+          return t ? function(r, n) {
+            var i = t[n];
+            return i == null ? e(r) : i;
+          } : e;
+        }
+        function WGt(e, t, r, n, i) {
+          var a = Xz(r);
+          return n ? qd.scale.ordinal().domain(n.map(jGt(FUe(r.tickformat), i))).range(n.map(function(o) {
+            var s = (o - a[0]) / (a[1] - a[0]);
+            return e - t + s * (2 * t - e);
+          })) : qd.scale.linear().domain(a).range([e - t, t]);
+        }
+        function XGt(e, t) {
+          return qd.scale.linear().range([t, e - t]);
+        }
+        function ZGt(e, t) {
+          return qd.scale.linear().domain(Xz(e)).range([t, 1 - t]);
+        }
+        function YGt(e) {
+          if (e.tickvals) {
+            var t = Xz(e);
+            return qd.scale.ordinal().domain(e.tickvals).range(e.tickvals.map(function(r) {
+              return (r - t[0]) / (t[1] - t[0]);
+            }));
+          }
+        }
+        function KGt(e) {
+          var t = e.map(function(a) {
+            return a[0];
+          }), r = e.map(function(a) {
+            var o = zUe(a[1]);
+            return qd.rgb("rgb(" + o[0] + "," + o[1] + "," + o[2] + ")");
+          }), n = function(a) {
+            return function(o) {
+              return o[a];
+            };
+          }, i = "rgb".split("").map(function(a) {
+            return qd.scale.linear().clamp(true).domain(t).range(r.map(n(a)));
+          });
+          return function(a) {
+            return i.map(function(o) {
+              return o(a);
+            });
+          };
+        }
+        function GK(e) {
+          return e.dimensions.some(function(t) {
+            return t.brush.filterSpecified;
+          });
+        }
+        function JGt(e, t, r) {
+          var n = qUe(t), i = n.trace, a = S5.convertTypedArray(n.lineColor), o = i.line, s = { color: zUe(i.unselected.line.color), opacity: i.unselected.line.opacity }, l = LUe.extractOpts(o), u = l.reversescale ? LUe.flipScale(n.cscale) : n.cscale, c = i.domain, f = i.dimensions, h = e.width, d = i.labelangle, v = i.labelside, _ = i.labelfont, b = i.tickfont, p = i.rangefont, k = p1.extendDeepNoArrays({}, o, { color: a.map(qd.scale.linear().domain(Xz({ values: a, range: [l.min, l.max], _length: i._length }))), blockLineCount: Dl.blockLineCount, canvasOverdrag: Dl.overdrag * Dl.canvasPixelRatio }), E = Math.floor(h * (c.x[1] - c.x[0])), T = Math.floor(e.height * (c.y[1] - c.y[0])), L = e.margin || { l: 80, r: 80, t: 100, b: 80 }, x = E, C = T;
+          return { key: r, colCount: f.filter(S5.isVisible).length, dimensions: f, tickDistance: Dl.tickDistance, unitToColor: KGt(u), lines: k, deselectedLines: s, labelAngle: d, labelSide: v, labelFont: _, tickFont: b, rangeFont: p, layoutWidth: h, layoutHeight: e.height, domain: c, translateX: c.x[0] * h, translateY: e.height - c.y[1] * e.height, pad: L, canvasWidth: x * Dl.canvasPixelRatio + 2 * k.canvasOverdrag, canvasHeight: C * Dl.canvasPixelRatio, width: x, height: C, canvasPixelRatio: Dl.canvasPixelRatio };
+        }
+        function $Gt(e, t, r) {
+          var n = r.width, i = r.height, a = r.dimensions, o = r.canvasPixelRatio, s = function(h) {
+            return n * h / Math.max(1, r.colCount - 1);
+          }, l = Dl.verticalPadding / i, u = XGt(i, Dl.verticalPadding), c = { key: r.key, xScale: s, model: r, inBrushDrag: false }, f = {};
+          return c.dimensions = a.filter(S5.isVisible).map(function(h, d) {
+            var v = ZGt(h, l), _ = f[h.label];
+            f[h.label] = (_ || 0) + 1;
+            var b = h.label + (_ ? "__" + _ : ""), p = h.constraintrange, k = p && p.length;
+            k && !UK(p[0]) && (p = [p]);
+            var E = k ? p.map(function(O) {
+              return O.map(v);
+            }) : [[-1 / 0, 1 / 0]], T = function() {
+              var O = c;
+              O.focusLayer && O.focusLayer.render(O.panels, true);
+              var U = GK(O);
+              !e.contextShown() && U ? (O.contextLayer && O.contextLayer.render(O.panels, true), e.contextShown(true)) : e.contextShown() && !U && (O.contextLayer && O.contextLayer.render(O.panels, true, true), e.contextShown(false));
+            }, L = h.values;
+            L.length > h._length && (L = L.slice(0, h._length));
+            var x = h.tickvals, C;
+            function M(O, U) {
+              return { val: O, text: C[U] };
+            }
+            function g(O, U) {
+              return O.val - U.val;
+            }
+            if (UK(x) && x.length) {
+              p1.isTypedArray(x) && (x = Array.from(x)), C = h.ticktext, !UK(C) || !C.length ? C = x.map(FUe(h.tickformat)) : C.length > x.length ? C = C.slice(0, x.length) : x.length > C.length && (x = x.slice(0, C.length));
+              for (var P = 1; P < x.length; P++) if (x[P] < x[P - 1]) {
+                for (var A = x.map(M).sort(g), z = 0; z < x.length; z++) x[z] = A[z].val, C[z] = A[z].text;
+                break;
+              }
+            } else x = void 0;
+            return L = S5.convertTypedArray(L), { key: b, label: h.label, tickFormat: h.tickformat, tickvals: x, ticktext: C, ordinal: S5.isOrdinal(h), multiselect: h.multiselect, xIndex: d, crossfilterDimensionIndex: d, visibleIndex: h._index, height: i, values: L, paddedUnitValues: L.map(v), unitTickvals: x && x.map(v), xScale: s, x: s(d), canvasX: s(d) * o, unitToPaddedPx: u, domainScale: WGt(i, Dl.verticalPadding, h, x, C), ordinalScale: YGt(h), parent: c, model: r, brush: BUe.makeBrush(e, k, E, function() {
+              e.linePickActive(false);
+            }, T, function(O) {
+              if (c.focusLayer.render(c.panels, true), c.pickLayer && c.pickLayer.render(c.panels, true), e.linePickActive(true), t && t.filterChanged) {
+                var U = v.invert, G = O.map(function(Z) {
+                  return Z.map(U).sort(p1.sorterAsc);
+                }).sort(function(Z, j) {
+                  return Z[0] - j[0];
+                });
+                t.filterChanged(c.key, h._index, G);
+              }
+            }) };
+          }), c;
+        }
+        function IUe(e) {
+          e.classed(Dl.cn.axisExtentText, true).attr("text-anchor", "middle").style("cursor", "default");
+        }
+        function QGt() {
+          var e = true, t = false;
+          return { linePickActive: function(r) {
+            return arguments.length ? e = !!r : e;
+          }, contextShown: function(r) {
+            return arguments.length ? t = !!r : t;
+          } };
+        }
+        function RUe(e, t) {
+          var r = t === "top" ? 1 : -1, n = e * Math.PI / 180, i = Math.sin(n), a = Math.cos(n);
+          return { dir: r, dx: i, dy: a, degrees: e };
+        }
+        function VK(e, t, r) {
+          for (var n = t.panels || (t.panels = []), i = e.data(), a = 0; a < i.length - 1; a++) {
+            var o = n[a] || (n[a] = {}), s = i[a], l = i[a + 1];
+            o.dim0 = s, o.dim1 = l, o.canvasX = s.canvasX, o.panelSizeX = l.canvasX - s.canvasX, o.panelSizeY = t.model.canvasHeight, o.y = 0, o.canvasY = 0, o.plotGlPixelRatio = r;
+          }
+        }
+        function eHt(e) {
+          for (var t = 0; t < e.length; t++) for (var r = 0; r < e[t].length; r++) for (var n = e[t][r].trace, i = n.dimensions, a = 0; a < i.length; a++) {
+            var o = i[a].values, s = i[a]._ax;
+            s && (s.range ? s.range = jK(s.range[0], s.range[1]) : s.range = NUe(o, n._length), s.dtick || (s.dtick = 0.01 * (Math.abs(s.range[1] - s.range[0]) || 1)), s.tickformat = i[a].tickformat, OUe.calcTicks(s), s.cleanRange());
+          }
+        }
+        function UUe(e, t) {
+          return OUe.tickText(e._ax, t, false).text;
+        }
+        function DUe(e, t) {
+          if (e.ordinal) return "";
+          var r = e.domainScale.domain(), n = r[t ? r.length - 1 : 0];
+          return UUe(e.model.dimensions[e.visibleIndex], n);
+        }
+        VUe.exports = function(t, r, n, i) {
+          var a = t._context.staticPlot, o = t._fullLayout, s = o._toppaper, l = o._glcontainer, u = t._context.plotGlPixelRatio, c = t._fullLayout.paper_bgcolor;
+          eHt(r);
+          var f = QGt(), h = r.filter(function(z) {
+            return qUe(z).trace.visible;
+          }).map(JGt.bind(0, n)).map($Gt.bind(0, f, i));
+          l.each(function(z, O) {
+            return p1.extendFlat(z, h[O]);
+          });
+          var d = l.selectAll(".gl-canvas").each(function(z) {
+            z.viewModel = h[0], z.viewModel.plotGlPixelRatio = u, z.viewModel.paperColor = c, z.model = z.viewModel ? z.viewModel.model : null;
+          }), v = null, _ = d.filter(function(z) {
+            return z.pick;
+          });
+          _.style("pointer-events", a ? "none" : "auto").on("mousemove", function(z) {
+            if (f.linePickActive() && z.lineLayer && i && i.hover) {
+              var O = qd.event, U = this.width, G = this.height, Z = qd.mouse(this), j = Z[0], N = Z[1];
+              if (j < 0 || N < 0 || j >= U || N >= G) return;
+              var H = z.lineLayer.readPixel(j, G - 1 - N), re = H[3] !== 0, oe = re ? H[2] + 256 * (H[1] + 256 * H[0]) : null, _e = { x: j, y: N, clientX: O.clientX, clientY: O.clientY, dataIndex: z.model.key, curveNumber: oe };
+              oe !== v && (re ? i.hover(_e) : i.unhover && i.unhover(_e), v = oe);
+            }
+          }), d.style("opacity", function(z) {
+            return z.pick ? 0 : 1;
+          }), s.style("background", "rgba(255, 255, 255, 0)");
+          var b = s.selectAll("." + Dl.cn.parcoords).data(h, ig);
+          b.exit().remove(), b.enter().append("g").classed(Dl.cn.parcoords, true).style("shape-rendering", "crispEdges").style("pointer-events", "none"), b.attr("transform", function(z) {
+            return ny(z.model.translateX, z.model.translateY);
+          });
+          var p = b.selectAll("." + Dl.cn.parcoordsControlView).data(ay, ig);
+          p.enter().append("g").classed(Dl.cn.parcoordsControlView, true), p.attr("transform", function(z) {
+            return ny(z.model.pad.l, z.model.pad.t);
+          });
+          var k = p.selectAll("." + Dl.cn.yAxis).data(function(z) {
+            return z.dimensions;
+          }, ig);
+          k.enter().append("g").classed(Dl.cn.yAxis, true), p.each(function(z) {
+            VK(k, z, u);
+          }), d.each(function(z) {
+            if (z.viewModel) {
+              !z.lineLayer || i ? z.lineLayer = HGt(this, z) : z.lineLayer.update(z), (z.key || z.key === 0) && (z.viewModel[z.key] = z.lineLayer);
+              var O = !z.context || i;
+              z.lineLayer.render(z.viewModel.panels, O);
+            }
+          }), k.attr("transform", function(z) {
+            return ny(z.xScale(z.xIndex), 0);
+          }), k.call(qd.behavior.drag().origin(function(z) {
+            return z;
+          }).on("drag", function(z) {
+            var O = z.parent;
+            f.linePickActive(false), z.x = Math.max(-Dl.overdrag, Math.min(z.model.width + Dl.overdrag, qd.event.x)), z.canvasX = z.x * z.model.canvasPixelRatio, k.sort(function(U, G) {
+              return U.x - G.x;
+            }).each(function(U, G) {
+              U.xIndex = G, U.x = z === U ? U.x : U.xScale(U.xIndex), U.canvasX = U.x * U.model.canvasPixelRatio;
+            }), VK(k, O, u), k.filter(function(U) {
+              return Math.abs(z.xIndex - U.xIndex) !== 0;
+            }).attr("transform", function(U) {
+              return ny(U.xScale(U.xIndex), 0);
+            }), qd.select(this).attr("transform", ny(z.x, 0)), k.each(function(U, G, Z) {
+              Z === z.parent.key && (O.dimensions[G] = U);
+            }), O.contextLayer && O.contextLayer.render(O.panels, false, !GK(O)), O.focusLayer.render && O.focusLayer.render(O.panels);
+          }).on("dragend", function(z) {
+            var O = z.parent;
+            z.x = z.xScale(z.xIndex), z.canvasX = z.x * z.model.canvasPixelRatio, VK(k, O, u), qd.select(this).attr("transform", function(U) {
+              return ny(U.x, 0);
+            }), O.contextLayer && O.contextLayer.render(O.panels, false, !GK(O)), O.focusLayer && O.focusLayer.render(O.panels), O.pickLayer && O.pickLayer.render(O.panels, true), f.linePickActive(true), i && i.axesMoved && i.axesMoved(O.key, O.dimensions.map(function(U) {
+              return U.crossfilterDimensionIndex;
+            }));
+          })), k.exit().remove();
+          var E = k.selectAll("." + Dl.cn.axisOverlays).data(ay, ig);
+          E.enter().append("g").classed(Dl.cn.axisOverlays, true), E.selectAll("." + Dl.cn.axis).remove();
+          var T = E.selectAll("." + Dl.cn.axis).data(ay, ig);
+          T.enter().append("g").classed(Dl.cn.axis, true), T.each(function(z) {
+            var O = z.model.height / z.model.tickDistance, U = z.domainScale, G = U.domain();
+            qd.select(this).call(qd.svg.axis().orient("left").tickSize(4).outerTickSize(2).ticks(O, z.tickFormat).tickValues(z.ordinal ? G : null).tickFormat(function(Z) {
+              return S5.isOrdinal(z) ? Z : UUe(z.model.dimensions[z.visibleIndex], Z);
+            }).scale(U)), Wz.font(T.selectAll("text"), z.model.tickFont);
+          }), T.selectAll(".domain, .tick>line").attr("fill", "none").attr("stroke", "black").attr("stroke-opacity", 0.25).attr("stroke-width", "1px"), T.selectAll("text").style("cursor", "default");
+          var L = E.selectAll("." + Dl.cn.axisHeading).data(ay, ig);
+          L.enter().append("g").classed(Dl.cn.axisHeading, true);
+          var x = L.selectAll("." + Dl.cn.axisTitle).data(ay, ig);
+          x.enter().append("text").classed(Dl.cn.axisTitle, true).attr("text-anchor", "middle").style("cursor", "ew-resize").style("pointer-events", a ? "none" : "auto"), x.text(function(z) {
+            return z.label;
+          }).each(function(z) {
+            var O = qd.select(this);
+            Wz.font(O, z.model.labelFont), GGt.convertToTspans(O, t);
+          }).attr("transform", function(z) {
+            var O = RUe(z.model.labelAngle, z.model.labelSide), U = Dl.axisTitleOffset;
+            return (O.dir > 0 ? "" : ny(0, 2 * U + z.model.height)) + VGt(O.degrees) + ny(-U * O.dx, -U * O.dy);
+          }).attr("text-anchor", function(z) {
+            var O = RUe(z.model.labelAngle, z.model.labelSide), U = Math.abs(O.dx), G = Math.abs(O.dy);
+            return 2 * U > G ? O.dir * O.dx < 0 ? "start" : "end" : "middle";
+          });
+          var C = E.selectAll("." + Dl.cn.axisExtent).data(ay, ig);
+          C.enter().append("g").classed(Dl.cn.axisExtent, true);
+          var M = C.selectAll("." + Dl.cn.axisExtentTop).data(ay, ig);
+          M.enter().append("g").classed(Dl.cn.axisExtentTop, true), M.attr("transform", ny(0, -Dl.axisExtentOffset));
+          var g = M.selectAll("." + Dl.cn.axisExtentTopText).data(ay, ig);
+          g.enter().append("text").classed(Dl.cn.axisExtentTopText, true).call(IUe), g.text(function(z) {
+            return DUe(z, true);
+          }).each(function(z) {
+            Wz.font(qd.select(this), z.model.rangeFont);
+          });
+          var P = C.selectAll("." + Dl.cn.axisExtentBottom).data(ay, ig);
+          P.enter().append("g").classed(Dl.cn.axisExtentBottom, true), P.attr("transform", function(z) {
+            return ny(0, z.model.height + Dl.axisExtentOffset);
+          });
+          var A = P.selectAll("." + Dl.cn.axisExtentBottomText).data(ay, ig);
+          A.enter().append("text").classed(Dl.cn.axisExtentBottomText, true).attr("dy", "0.75em").call(IUe), A.text(function(z) {
+            return DUe(z, false);
+          }).each(function(z) {
+            Wz.font(qd.select(this), z.model.rangeFont);
+          }), BUe.ensureAxisBrush(E, c, t);
+        };
+      });
+      var XK = ye((WK, XUe) => {
+        var tHt = GUe(), rHt = Lz(), HUe = BK().isVisible, WUe = {};
+        function jUe(e, t, r) {
+          var n = t.indexOf(r), i = e.indexOf(n);
+          return i === -1 && (i += t.length), i;
+        }
+        function iHt(e, t) {
+          return function(n, i) {
+            return jUe(e, t, n) - jUe(e, t, i);
+          };
+        }
+        var WK = XUe.exports = function(t, r) {
+          var n = t._fullLayout, i = rHt(t, [], WUe);
+          if (i) {
+            var a = {}, o = {}, s = {}, l = {}, u = n._size;
+            r.forEach(function(v, _) {
+              var b = v[0].trace;
+              s[_] = b.index;
+              var p = l[_] = b.index;
+              a[_] = t.data[p].dimensions, o[_] = t.data[p].dimensions.slice();
+            });
+            var c = function(v, _, b) {
+              var p = o[v][_], k = b.map(function(M) {
+                return M.slice();
+              }), E = "dimensions[" + _ + "].constraintrange", T = n._tracePreGUI[t._fullData[s[v]]._fullInput.uid];
+              if (T[E] === void 0) {
+                var L = p.constraintrange;
+                T[E] = L || null;
+              }
+              var x = t._fullData[s[v]].dimensions[_];
+              k.length ? (k.length === 1 && (k = k[0]), p.constraintrange = k, x.constraintrange = k.slice(), k = [k]) : (delete p.constraintrange, delete x.constraintrange, k = null);
+              var C = {};
+              C[E] = k, t.emit("plotly_restyle", [C, [l[v]]]);
+            }, f = function(v) {
+              t.emit("plotly_hover", v);
+            }, h = function(v) {
+              t.emit("plotly_unhover", v);
+            }, d = function(v, _) {
+              var b = iHt(_, o[v].filter(HUe));
+              a[v].sort(b), o[v].filter(function(p) {
+                return !HUe(p);
+              }).sort(function(p) {
+                return o[v].indexOf(p);
+              }).forEach(function(p) {
+                a[v].splice(a[v].indexOf(p), 1), a[v].splice(o[v].indexOf(p), 0, p);
+              }), t.emit("plotly_restyle", [{ dimensions: [a[v]] }, [l[v]]]);
+            };
+            tHt(t, r, { width: u.w, height: u.h, margin: { t: u.t, r: u.r, b: u.b, l: u.l } }, { filterChanged: c, hover: f, unhover: h, axesMoved: d });
+          }
+        };
+        WK.reglPrecompiled = WUe;
+      });
+      var YUe = ye((Vk) => {
+        var ZUe = Oa(), nHt = Id().getModuleCalcData, aHt = XK(), oHt = Wp();
+        Vk.name = "parcoords";
+        Vk.plot = function(e) {
+          var t = nHt(e.calcdata, "parcoords")[0];
+          t.length && aHt(e, t);
+        };
+        Vk.clean = function(e, t, r, n) {
+          var i = n._has && n._has("parcoords"), a = t._has && t._has("parcoords");
+          i && !a && (n._paperdiv.selectAll(".parcoords").remove(), n._glimages.selectAll("*").remove());
+        };
+        Vk.toSVG = function(e) {
+          var t = e._fullLayout._glimages, r = ZUe.select(e).selectAll(".svg-container"), n = r.filter(function(a, o) {
+            return o === r.size() - 1;
+          }).selectAll(".gl-canvas-context, .gl-canvas-focus");
+          function i() {
+            var a = this, o = a.toDataURL("image/png"), s = t.append("svg:image");
+            s.attr({ xmlns: oHt.svg, "xlink:href": o, preserveAspectRatio: "none", x: 0, y: 0, width: a.style.width, height: a.style.height });
+          }
+          n.each(i), window.setTimeout(function() {
+            ZUe.selectAll("#filterBarPattern").attr("id", "filterBarPattern");
+          }, 60);
+        };
+      });
+      var JUe = ye((lxr, KUe) => {
+        KUe.exports = { attributes: PK(), supplyDefaults: cUe(), calc: hUe(), colorbar: { container: "line", min: "cmin", max: "cmax" }, moduleType: "trace", name: "parcoords", basePlotModule: YUe(), categories: ["gl", "regl", "noOpacity", "noHover"], meta: {} };
+      });
+      var eVe = ye((uxr, QUe) => {
+        var $Ue = JUe();
+        $Ue.plot = XK();
+        QUe.exports = $Ue;
+      });
+      var rVe = ye((cxr, tVe) => {
+        tVe.exports = eVe();
+      });
+      var ZK = ye((fxr, sVe) => {
+        var nVe = Ao().extendFlat, sHt = Gl(), iVe = ec(), lHt = Tu(), { hovertemplateAttrs: aVe, templatefallbackAttrs: oVe } = Ll(), uHt = Cc().attributes, cHt = nVe({ editType: "calc" }, lHt("line", { editTypeOverride: "calc" }), { shape: { valType: "enumerated", values: ["linear", "hspline"], dflt: "linear", editType: "plot" }, hovertemplate: aVe({ editType: "plot", arrayOk: false }, { keys: ["count", "probability"] }), hovertemplatefallback: oVe({ editType: "plot" }) });
+        sVe.exports = { domain: uHt({ name: "parcats", trace: true, editType: "calc" }), hoverinfo: nVe({}, sHt.hoverinfo, { flags: ["count", "probability"], editType: "plot", arrayOk: false }), hoveron: { valType: "enumerated", values: ["category", "color", "dimension"], dflt: "category", editType: "plot" }, hovertemplate: aVe({ editType: "plot", arrayOk: false }, { keys: ["count", "probability", "category", "categorycount", "colorcount", "bandcolorcount"] }), hovertemplatefallback: oVe({ editType: "plot" }), arrangement: { valType: "enumerated", values: ["perpendicular", "freeform", "fixed"], dflt: "perpendicular", editType: "plot" }, bundlecolors: { valType: "boolean", dflt: true, editType: "plot" }, sortpaths: { valType: "enumerated", values: ["forward", "backward"], dflt: "forward", editType: "plot" }, labelfont: iVe({ editType: "calc" }), tickfont: iVe({ autoShadowDflt: true, editType: "calc" }), dimensions: { _isLinkedToArray: "dimension", label: { valType: "string", editType: "calc" }, categoryorder: { valType: "enumerated", values: ["trace", "category ascending", "category descending", "array"], dflt: "trace", editType: "calc" }, categoryarray: { valType: "data_array", editType: "calc" }, ticktext: { valType: "data_array", editType: "calc" }, values: { valType: "data_array", dflt: [], editType: "calc" }, displayindex: { valType: "integer", editType: "calc" }, editType: "calc", visible: { valType: "boolean", dflt: true, editType: "calc" } }, line: cHt, counts: { valType: "number", min: 0, dflt: 1, arrayOk: true, editType: "calc" }, customdata: void 0, hoverlabel: void 0, ids: void 0, legend: void 0, legendgroup: void 0, legendrank: void 0, opacity: void 0, selectedpoints: void 0, showlegend: void 0 };
+      });
+      var cVe = ye((hxr, uVe) => {
+        var M5 = Dr(), fHt = pv().hasColorscale, hHt = td(), dHt = Cc().defaults, vHt = Zd(), lVe = ZK(), pHt = Iz(), gHt = vv().isTypedArraySpec;
+        function mHt(e, t, r, n, i) {
+          i("line.shape"), i("line.hovertemplate"), i("line.hovertemplatefallback");
+          var a = i("line.color", n.colorway[0]);
+          if (fHt(e, "line") && M5.isArrayOrTypedArray(a)) {
+            if (a.length) return i("line.colorscale"), hHt(e, t, n, i, { prefix: "line.", cLetter: "c" }), a.length;
+            t.line.color = r;
+          }
+          return 1 / 0;
+        }
+        function yHt(e, t) {
+          function r(u, c) {
+            return M5.coerce(e, t, lVe.dimensions, u, c);
+          }
+          var n = r("values"), i = r("visible");
+          if (n && n.length || (i = t.visible = false), i) {
+            r("label"), r("displayindex", t._index);
+            var a = e.categoryarray, o = M5.isArrayOrTypedArray(a) && a.length > 0 || gHt(a), s;
+            o && (s = "array");
+            var l = r("categoryorder", s);
+            l === "array" ? (r("categoryarray"), r("ticktext")) : (delete e.categoryarray, delete e.ticktext), !o && l === "array" && (t.categoryorder = "trace");
+          }
+        }
+        uVe.exports = function(t, r, n, i) {
+          function a(u, c) {
+            return M5.coerce(t, r, lVe, u, c);
+          }
+          var o = vHt(t, r, { name: "dimensions", handleItemDefaults: yHt }), s = mHt(t, r, n, i, a);
+          dHt(r, i, a), (!Array.isArray(o) || !o.length) && (r.visible = false), pHt(r, o, "values", s), a("hoveron"), a("hovertemplate"), a("hovertemplatefallback"), a("arrangement"), a("bundlecolors"), a("sortpaths"), a("counts");
+          var l = i.font;
+          M5.coerceFont(a, "labelfont", l, { overrideDflt: { size: Math.round(l.size) } }), M5.coerceFont(a, "tickfont", l, { autoShadowDflt: true, overrideDflt: { size: Math.round(l.size / 1.2) } });
+        };
+      });
+      var hVe = ye((dxr, fVe) => {
+        var _Ht = iy().wrap, xHt = pv().hasColorscale, bHt = gv(), wHt = tq(), THt = So(), Gk = Dr(), AHt = Eo();
+        fVe.exports = function(t, r) {
+          var n = Gk.filterVisible(r.dimensions);
+          if (n.length === 0) return [];
+          var i = n.map(function(g) {
+            var P;
+            if (g.categoryorder === "trace") P = null;
+            else if (g.categoryorder === "array") P = g.categoryarray;
+            else {
+              P = wHt(g.values);
+              for (var A = true, z = 0; z < P.length; z++) if (!AHt(P[z])) {
+                A = false;
+                break;
+              }
+              P.sort(A ? Gk.sorterAsc : void 0), g.categoryorder === "category descending" && (P = P.reverse());
+            }
+            return PHt(g.values, P);
+          }), a, o, s;
+          Gk.isArrayOrTypedArray(r.counts) ? a = r.counts : a = [r.counts], IHt(n), n.forEach(function(g, P) {
+            RHt(g, i[P]);
+          });
+          var l = r.line, u;
+          l ? (xHt(r, "line") && bHt(t, r, { vals: r.line.color, containerStr: "line", cLetter: "c" }), u = THt.tryColorscale(l)) : u = Gk.identity;
+          function c(g) {
+            var P, A;
+            return Gk.isArrayOrTypedArray(l.color) ? (P = l.color[g % l.color.length], A = P) : P = l.color, { color: u(P), rawColor: A };
+          }
+          var f = n[0].values.length, h = {}, d = i.map(function(g) {
+            return g.inds;
+          });
+          s = 0;
+          var v, _;
+          for (v = 0; v < f; v++) {
+            var b = [];
+            for (_ = 0; _ < d.length; _++) b.push(d[_][v]);
+            o = a[v % a.length], s += o;
+            var p = c(v), k = b + "-" + p.rawColor;
+            h[k] === void 0 && (h[k] = CHt(b, p.color, p.rawColor)), LHt(h[k], v, o);
+          }
+          var E = n.map(function(g, P) {
+            return MHt(P, g._index, g._displayindex, g.label, s);
+          });
+          for (v = 0; v < f; v++) for (o = a[v % a.length], _ = 0; _ < E.length; _++) {
+            var T = E[_].containerInd, L = i[_].inds[v], x = E[_].categories;
+            if (x[L] === void 0) {
+              var C = r.dimensions[T]._categoryarray[L], M = r.dimensions[T]._ticktext[L];
+              x[L] = EHt(_, L, C, M);
+            }
+            kHt(x[L], v, o);
+          }
+          return _Ht(SHt(E, h, s));
+        };
+        function SHt(e, t, r) {
+          var n = e.map(function(i) {
+            return i.categories.length;
+          }).reduce(function(i, a) {
+            return Math.max(i, a);
+          });
+          return { dimensions: e, paths: t, trace: void 0, maxCats: n, count: r };
+        }
+        function MHt(e, t, r, n, i) {
+          return { dimensionInd: e, containerInd: t, displayInd: r, dimensionLabel: n, count: i, categories: [], dragX: null };
+        }
+        function EHt(e, t, r, n) {
+          return { dimensionInd: e, categoryInd: t, categoryValue: r, displayInd: t, categoryLabel: n, valueInds: [], count: 0, dragY: null };
+        }
+        function kHt(e, t, r) {
+          e.valueInds.push(t), e.count += r;
+        }
+        function CHt(e, t, r) {
+          return { categoryInds: e, color: t, rawColor: r, valueInds: [], count: 0 };
+        }
+        function LHt(e, t, r) {
+          e.valueInds.push(t), e.count += r;
+        }
+        function PHt(e, t) {
+          t == null ? t = [] : t = t.map(function(u) {
+            return u;
+          });
+          var r = {}, n = {}, i = [];
+          t.forEach(function(u, c) {
+            r[u] = 0, n[u] = c;
+          });
+          for (var a = 0; a < e.length; a++) {
+            var o = e[a], s;
+            r[o] === void 0 ? (r[o] = 1, s = t.push(o) - 1, n[o] = s) : (r[o]++, s = n[o]), i.push(s);
+          }
+          var l = t.map(function(u) {
+            return r[u];
+          });
+          return { uniqueValues: t, uniqueCounts: l, inds: i };
+        }
+        function IHt(e) {
+          var t = e.map(function(n) {
+            return n.displayindex;
+          }), r;
+          if (DHt(t)) for (r = 0; r < e.length; r++) e[r]._displayindex = e[r].displayindex;
+          else for (r = 0; r < e.length; r++) e[r]._displayindex = r;
+        }
+        function RHt(e, t) {
+          e._categoryarray = t.uniqueValues, e.ticktext === null || e.ticktext === void 0 ? e._ticktext = [] : e._ticktext = e.ticktext.slice();
+          for (var r = e._ticktext.length; r < t.uniqueValues.length; r++) e._ticktext.push(t.uniqueValues[r]);
+        }
+        function DHt(e) {
+          for (var t = new Array(e.length), r = 0; r < e.length; r++) {
+            if (e[r] < 0 || e[r] >= e.length || t[e[r]] !== void 0) return false;
+            t[e[r]] = true;
+          }
+          return true;
+        }
+      });
+      var bVe = ye((vxr, xVe) => {
+        var Fl = Oa(), FHt = (H2(), pb(G2)).interpolateNumber, zHt = ZP(), Wk = vf(), Ex = Dr(), Hk = Ex.strTranslate, dVe = So(), YK = fd(), OHt = Zl();
+        function qHt(e, t, r, n) {
+          var i = t._context.staticPlot, a = e.map(QHt.bind(0, t, r)), o = n.selectAll("g.parcatslayer").data([null]);
+          o.enter().append("g").attr("class", "parcatslayer").style("pointer-events", i ? "none" : "all");
+          var s = o.selectAll("g.trace.parcats").data(a, g1), l = s.enter().append("g").attr("class", "trace parcats");
+          s.attr("transform", function(k) {
+            return Hk(k.x, k.y);
+          }), l.append("g").attr("class", "paths");
+          var u = s.select("g.paths"), c = u.selectAll("path.path").data(function(k) {
+            return k.paths;
+          }, g1);
+          c.attr("fill", function(k) {
+            return k.model.color;
+          });
+          var f = c.enter().append("path").attr("class", "path").attr("stroke-opacity", 0).attr("fill", function(k) {
+            return k.model.color;
+          }).attr("fill-opacity", 0);
+          $K(f), c.attr("d", function(k) {
+            return k.svgD;
+          }), f.empty() || c.sort(KK), c.exit().remove(), c.on("mouseover", BHt).on("mouseout", NHt).on("click", UHt), l.append("g").attr("class", "dimensions");
+          var h = s.select("g.dimensions"), d = h.selectAll("g.dimension").data(function(k) {
+            return k.dimensions;
+          }, g1);
+          d.enter().append("g").attr("class", "dimension"), d.attr("transform", function(k) {
+            return Hk(k.x, 0);
+          }), d.exit().remove();
+          var v = d.selectAll("g.category").data(function(k) {
+            return k.categories;
+          }, g1), _ = v.enter().append("g").attr("class", "category");
+          v.attr("transform", function(k) {
+            return Hk(0, k.y);
+          }), _.append("rect").attr("class", "catrect").attr("pointer-events", "none"), v.select("rect.catrect").attr("fill", "none").attr("width", function(k) {
+            return k.width;
+          }).attr("height", function(k) {
+            return k.height;
+          }), pVe(_);
+          var b = v.selectAll("rect.bandrect").data(function(k) {
+            return k.bands;
+          }, g1);
+          b.each(function() {
+            Ex.raiseToTop(this);
+          }), b.attr("fill", function(k) {
+            return k.color;
+          });
+          var p = b.enter().append("rect").attr("class", "bandrect").attr("stroke-opacity", 0).attr("fill", function(k) {
+            return k.color;
+          }).attr("fill-opacity", 0);
+          b.attr("fill", function(k) {
+            return k.color;
+          }).attr("width", function(k) {
+            return k.width;
+          }).attr("height", function(k) {
+            return k.height;
+          }).attr("y", function(k) {
+            return k.y;
+          }).attr("cursor", function(k) {
+            return k.parcatsViewModel.arrangement === "fixed" ? "default" : k.parcatsViewModel.arrangement === "perpendicular" ? "ns-resize" : "move";
+          }), eJ(p), b.exit().remove(), _.append("text").attr("class", "catlabel").attr("pointer-events", "none"), v.select("text.catlabel").attr("text-anchor", function(k) {
+            return jk(k) ? "start" : "end";
+          }).attr("alignment-baseline", "middle").style("fill", "rgb(0, 0, 0)").attr("x", function(k) {
+            return jk(k) ? k.width + 5 : -5;
+          }).attr("y", function(k) {
+            return k.height / 2;
+          }).text(function(k) {
+            return k.model.categoryLabel;
+          }).each(function(k) {
+            dVe.font(Fl.select(this), k.parcatsViewModel.categorylabelfont), OHt.convertToTspans(Fl.select(this), t);
+          }), _.append("text").attr("class", "dimlabel"), v.select("text.dimlabel").attr("text-anchor", "middle").attr("alignment-baseline", "baseline").attr("cursor", function(k) {
+            return k.parcatsViewModel.arrangement === "fixed" ? "default" : "ew-resize";
+          }).attr("x", function(k) {
+            return k.width / 2;
+          }).attr("y", -5).text(function(k, E) {
+            return E === 0 ? k.parcatsViewModel.model.dimensions[k.model.dimensionInd].dimensionLabel : null;
+          }).each(function(k) {
+            dVe.font(Fl.select(this), k.parcatsViewModel.labelfont);
+          }), v.selectAll("rect.bandrect").on("mouseover", ZHt).on("mouseout", YHt), v.exit().remove(), d.call(Fl.behavior.drag().origin(function(k) {
+            return { x: k.x, y: 0 };
+          }).on("dragstart", KHt).on("drag", JHt).on("dragend", $Ht)), s.each(function(k) {
+            k.traceSelection = Fl.select(this), k.pathSelection = Fl.select(this).selectAll("g.paths").selectAll("path.path"), k.dimensionSelection = Fl.select(this).selectAll("g.dimensions").selectAll("g.dimension");
+          }), s.exit().remove();
+        }
+        xVe.exports = function(e, t, r, n) {
+          qHt(r, e, n, t);
+        };
+        function g1(e) {
+          return e.key;
+        }
+        function jk(e) {
+          var t = e.parcatsViewModel.dimensions.length, r = e.parcatsViewModel.dimensions[t - 1].model.dimensionInd;
+          return e.model.dimensionInd === r;
+        }
+        function KK(e, t) {
+          return e.model.rawColor > t.model.rawColor ? 1 : e.model.rawColor < t.model.rawColor ? -1 : 0;
+        }
+        function BHt(e) {
+          if (!e.parcatsViewModel.dragDimension && e.parcatsViewModel.hoverinfoItems.indexOf("skip") === -1) {
+            Ex.raiseToTop(this), QK(Fl.select(this));
+            var t = Xk(e), r = JK(e);
+            if (e.parcatsViewModel.graphDiv.emit("plotly_hover", { points: t, event: Fl.event, constraints: r }), e.parcatsViewModel.hoverinfoItems.indexOf("none") === -1) {
+              var n = Fl.mouse(this)[0], i = e.parcatsViewModel.graphDiv, a = e.parcatsViewModel.trace, o = i._fullLayout, s = o._paperdiv.node().getBoundingClientRect(), l = e.parcatsViewModel.graphDiv.getBoundingClientRect(), u, c, f;
+              for (f = 0; f < e.leftXs.length - 1; f++) if (e.leftXs[f] + e.dimWidths[f] - 2 <= n && n <= e.leftXs[f + 1] + 2) {
+                var h = e.parcatsViewModel.dimensions[f], d = e.parcatsViewModel.dimensions[f + 1];
+                u = (h.x + h.width + d.x) / 2, c = (e.topYs[f] + e.topYs[f + 1] + e.height) / 2;
+                break;
+              }
+              var v = e.parcatsViewModel.x + u, _ = e.parcatsViewModel.y + c, b = YK.mostReadable(e.model.color, ["black", "white"]), p = e.model.count, k = p / e.parcatsViewModel.model.count, E = { countLabel: p, probabilityLabel: k.toFixed(3) }, T = [];
+              e.parcatsViewModel.hoverinfoItems.indexOf("count") !== -1 && T.push(["Count:", E.countLabel].join(" ")), e.parcatsViewModel.hoverinfoItems.indexOf("probability") !== -1 && T.push(["P:", E.probabilityLabel].join(" "));
+              var L = T.join("<br>"), x = Fl.mouse(i)[0];
+              Wk.loneHover({ trace: a, x: v - s.left + l.left, y: _ - s.top + l.top, text: L, color: e.model.color, borderColor: "black", fontFamily: 'Monaco, "Courier New", monospace', fontSize: 10, fontColor: b, idealAlign: x < v ? "right" : "left", hovertemplate: (a.line || {}).hovertemplate, hovertemplateLabels: E, eventData: [{ data: a._input, fullData: a, count: p, probability: k }] }, { container: o._hoverlayer.node(), outerContainer: o._paper.node(), gd: i });
+            }
+          }
+        }
+        function NHt(e) {
+          if (!e.parcatsViewModel.dragDimension && ($K(Fl.select(this)), Wk.loneUnhover(e.parcatsViewModel.graphDiv._fullLayout._hoverlayer.node()), e.parcatsViewModel.pathSelection.sort(KK), e.parcatsViewModel.hoverinfoItems.indexOf("skip") === -1)) {
+            var t = Xk(e), r = JK(e);
+            e.parcatsViewModel.graphDiv.emit("plotly_unhover", { points: t, event: Fl.event, constraints: r });
+          }
+        }
+        function Xk(e) {
+          for (var t = [], r = mVe(e.parcatsViewModel), n = 0; n < e.model.valueInds.length; n++) {
+            var i = e.model.valueInds[n];
+            t.push({ curveNumber: r, pointNumber: i });
+          }
+          return t;
+        }
+        function JK(e) {
+          for (var t = {}, r = e.parcatsViewModel.model.dimensions, n = 0; n < r.length; n++) {
+            var i = r[n], a = i.categories[e.model.categoryInds[n]];
+            t[i.containerInd] = a.categoryValue;
+          }
+          return e.model.rawColor !== void 0 && (t.color = e.model.rawColor), t;
+        }
+        function UHt(e) {
+          if (e.parcatsViewModel.hoverinfoItems.indexOf("skip") === -1) {
+            var t = Xk(e), r = JK(e);
+            e.parcatsViewModel.graphDiv.emit("plotly_click", { points: t, event: Fl.event, constraints: r });
+          }
+        }
+        function $K(e) {
+          e.attr("fill", function(t) {
+            return t.model.color;
+          }).attr("fill-opacity", 0.6).attr("stroke", "lightgray").attr("stroke-width", 0.2).attr("stroke-opacity", 1);
+        }
+        function QK(e) {
+          e.attr("fill-opacity", 0.8).attr("stroke", function(t) {
+            return YK.mostReadable(t.model.color, ["black", "white"]);
+          }).attr("stroke-width", 0.3);
+        }
+        function VHt(e) {
+          e.select("rect.catrect").attr("stroke", "black").attr("stroke-width", 2.5);
+        }
+        function pVe(e) {
+          e.select("rect.catrect").attr("stroke", "black").attr("stroke-width", 1).attr("stroke-opacity", 1);
+        }
+        function GHt(e) {
+          e.attr("stroke", "black").attr("stroke-width", 1.5);
+        }
+        function eJ(e) {
+          e.attr("stroke", "black").attr("stroke-width", 0.2).attr("stroke-opacity", 1).attr("fill-opacity", 1);
+        }
+        function Zz(e) {
+          var t = e.parcatsViewModel.pathSelection, r = e.categoryViewModel.model.dimensionInd, n = e.categoryViewModel.model.categoryInd;
+          return t.filter(function(i) {
+            return i.model.categoryInds[r] === n && i.model.color === e.color;
+          });
+        }
+        function HHt(e) {
+          var t = Fl.select(e.parentNode).selectAll("rect.bandrect");
+          t.each(function(r) {
+            var n = Zz(r);
+            QK(n), n.each(function() {
+              Ex.raiseToTop(this);
+            });
+          }), VHt(Fl.select(e.parentNode));
+        }
+        function jHt(e) {
+          var t = Fl.select(e).datum(), r = Zz(t);
+          QK(r), r.each(function() {
+            Ex.raiseToTop(this);
+          }), Fl.select(e.parentNode).selectAll("rect.bandrect").filter(function(n) {
+            return n.color === t.color;
+          }).each(function() {
+            Ex.raiseToTop(this), GHt(Fl.select(this));
+          });
+        }
+        function tJ(e, t, r) {
+          var n = Fl.select(e).datum(), i = n.categoryViewModel.model, a = n.parcatsViewModel.graphDiv, o = Fl.select(e.parentNode).selectAll("rect.bandrect"), s = [];
+          o.each(function(u) {
+            var c = Zz(u);
+            c.each(function(f) {
+              Array.prototype.push.apply(s, Xk(f));
+            });
+          });
+          var l = {};
+          l[i.dimensionInd] = i.categoryValue, a.emit(t, { points: s, event: r, constraints: l });
+        }
+        function rJ(e, t, r) {
+          var n = Fl.select(e).datum(), i = n.categoryViewModel.model, a = n.parcatsViewModel.graphDiv, o = Zz(n), s = [];
+          o.each(function(u) {
+            Array.prototype.push.apply(s, Xk(u));
+          });
+          var l = {};
+          l[i.dimensionInd] = i.categoryValue, n.rawColor !== void 0 && (l.color = n.rawColor), a.emit(t, { points: s, event: r, constraints: l });
+        }
+        function gVe(e, t, r) {
+          e._fullLayout._calcInverseTransform(e);
+          var n = e._fullLayout._invScaleX, i = e._fullLayout._invScaleY, a = Fl.select(r.parentNode).select("rect.catrect"), o = a.node().getBoundingClientRect(), s = a.datum(), l = s.parcatsViewModel, u = l.model.dimensions[s.model.dimensionInd], c = l.trace, f = o.top + o.height / 2, h, d;
+          l.dimensions.length > 1 && u.displayInd === l.dimensions.length - 1 ? (h = o.left, d = "left") : (h = o.left + o.width, d = "right");
+          var v = s.model.count, _ = s.model.categoryLabel, b = v / s.parcatsViewModel.model.count, p = { countLabel: v, categoryLabel: _, probabilityLabel: b.toFixed(3) }, k = [];
+          s.parcatsViewModel.hoverinfoItems.indexOf("count") !== -1 && k.push(["Count:", p.countLabel].join(" ")), s.parcatsViewModel.hoverinfoItems.indexOf("probability") !== -1 && k.push(["P(" + p.categoryLabel + "):", p.probabilityLabel].join(" "));
+          var E = k.join("<br>");
+          return { trace: c, x: n * (h - t.left), y: i * (f - t.top), text: E, color: "lightgray", borderColor: "black", fontFamily: 'Monaco, "Courier New", monospace', fontSize: 12, fontColor: "black", idealAlign: d, hovertemplate: c.hovertemplate, hovertemplateLabels: p, eventData: [{ data: c._input, fullData: c, count: v, category: _, probability: b }] };
+        }
+        function WHt(e, t, r) {
+          var n = [];
+          return Fl.select(r.parentNode.parentNode).selectAll("g.category").select("rect.catrect").each(function() {
+            var i = this;
+            n.push(gVe(e, t, i));
+          }), n;
+        }
+        function XHt(e, t, r) {
+          e._fullLayout._calcInverseTransform(e);
+          var n = e._fullLayout._invScaleX, i = e._fullLayout._invScaleY, a = r.getBoundingClientRect(), o = Fl.select(r).datum(), s = o.categoryViewModel, l = s.parcatsViewModel, u = l.model.dimensions[s.model.dimensionInd], c = l.trace, f = a.y + a.height / 2, h, d;
+          l.dimensions.length > 1 && u.displayInd === l.dimensions.length - 1 ? (h = a.left, d = "left") : (h = a.left + a.width, d = "right");
+          var v = s.model.categoryLabel, _ = o.parcatsViewModel.model.count, b = 0;
+          o.categoryViewModel.bands.forEach(function(P) {
+            P.color === o.color && (b += P.count);
+          });
+          var p = s.model.count, k = 0;
+          l.pathSelection.each(function(P) {
+            P.model.color === o.color && (k += P.model.count);
+          });
+          var E = b / _, T = b / k, L = b / p, x = { countLabel: b, categoryLabel: v, probabilityLabel: E.toFixed(3) }, C = [];
+          s.parcatsViewModel.hoverinfoItems.indexOf("count") !== -1 && C.push(["Count:", x.countLabel].join(" ")), s.parcatsViewModel.hoverinfoItems.indexOf("probability") !== -1 && (C.push("P(color ∩ " + v + "): " + x.probabilityLabel), C.push("P(" + v + " | color): " + T.toFixed(3)), C.push("P(color | " + v + "): " + L.toFixed(3)));
+          var M = C.join("<br>"), g = YK.mostReadable(o.color, ["black", "white"]);
+          return { trace: c, x: n * (h - t.left), y: i * (f - t.top), text: M, color: o.color, borderColor: "black", fontFamily: 'Monaco, "Courier New", monospace', fontColor: g, fontSize: 10, idealAlign: d, hovertemplate: c.hovertemplate, hovertemplateLabels: x, eventData: [{ data: c._input, fullData: c, category: v, count: _, probability: E, categorycount: p, colorcount: k, bandcolorcount: b }] };
+        }
+        function ZHt(e) {
+          if (!e.parcatsViewModel.dragDimension && e.parcatsViewModel.hoverinfoItems.indexOf("skip") === -1) {
+            var t = Fl.mouse(this)[1];
+            if (t < -1) return;
+            var r = e.parcatsViewModel.graphDiv, n = r._fullLayout, i = n._paperdiv.node().getBoundingClientRect(), a = e.parcatsViewModel.hoveron, o = this;
+            if (a === "color" ? (jHt(o), rJ(o, "plotly_hover", Fl.event)) : (HHt(o), tJ(o, "plotly_hover", Fl.event)), e.parcatsViewModel.hoverinfoItems.indexOf("none") === -1) {
+              var s;
+              a === "category" ? s = gVe(r, i, o) : a === "color" ? s = XHt(r, i, o) : a === "dimension" && (s = WHt(r, i, o)), s && Wk.loneHover(s, { container: n._hoverlayer.node(), outerContainer: n._paper.node(), gd: r });
+            }
+          }
+        }
+        function YHt(e) {
+          var t = e.parcatsViewModel;
+          if (!t.dragDimension && ($K(t.pathSelection), pVe(t.dimensionSelection.selectAll("g.category")), eJ(t.dimensionSelection.selectAll("g.category").selectAll("rect.bandrect")), Wk.loneUnhover(t.graphDiv._fullLayout._hoverlayer.node()), t.pathSelection.sort(KK), t.hoverinfoItems.indexOf("skip") === -1)) {
+            var r = e.parcatsViewModel.hoveron, n = this;
+            r === "color" ? rJ(n, "plotly_unhover", Fl.event) : tJ(n, "plotly_unhover", Fl.event);
+          }
+        }
+        function KHt(e) {
+          e.parcatsViewModel.arrangement !== "fixed" && (e.dragDimensionDisplayInd = e.model.displayInd, e.initialDragDimensionDisplayInds = e.parcatsViewModel.model.dimensions.map(function(t) {
+            return t.displayInd;
+          }), e.dragHasMoved = false, e.dragCategoryDisplayInd = null, Fl.select(this).selectAll("g.category").select("rect.catrect").each(function(t) {
+            var r = Fl.mouse(this)[0], n = Fl.mouse(this)[1];
+            -2 <= r && r <= t.width + 2 && -2 <= n && n <= t.height + 2 && (e.dragCategoryDisplayInd = t.model.displayInd, e.initialDragCategoryDisplayInds = e.model.categories.map(function(i) {
+              return i.displayInd;
+            }), t.model.dragY = t.y, Ex.raiseToTop(this.parentNode), Fl.select(this.parentNode).selectAll("rect.bandrect").each(function(i) {
+              i.y < n && n <= i.y + i.height && (e.potentialClickBand = this);
+            }));
+          }), e.parcatsViewModel.dragDimension = e, Wk.loneUnhover(e.parcatsViewModel.graphDiv._fullLayout._hoverlayer.node()));
+        }
+        function JHt(e) {
+          if (e.parcatsViewModel.arrangement !== "fixed" && (e.dragHasMoved = true, e.dragDimensionDisplayInd !== null)) {
+            var t = e.dragDimensionDisplayInd, r = t - 1, n = t + 1, i = e.parcatsViewModel.dimensions[t];
+            if (e.dragCategoryDisplayInd !== null) {
+              var a = i.categories[e.dragCategoryDisplayInd];
+              a.model.dragY += Fl.event.dy;
+              var o = a.model.dragY, s = a.model.displayInd, l = i.categories, u = l[s - 1], c = l[s + 1];
+              u !== void 0 && o < u.y + u.height / 2 && (a.model.displayInd = u.model.displayInd, u.model.displayInd = s), c !== void 0 && o + a.height > c.y + c.height / 2 && (a.model.displayInd = c.model.displayInd, c.model.displayInd = s), e.dragCategoryDisplayInd = a.model.displayInd;
+            }
+            if (e.dragCategoryDisplayInd === null || e.parcatsViewModel.arrangement === "freeform") {
+              i.model.dragX = Fl.event.x;
+              var f = e.parcatsViewModel.dimensions[r], h = e.parcatsViewModel.dimensions[n];
+              f !== void 0 && i.model.dragX < f.x + f.width && (i.model.displayInd = f.model.displayInd, f.model.displayInd = t), h !== void 0 && i.model.dragX + i.width > h.x && (i.model.displayInd = h.model.displayInd, h.model.displayInd = e.dragDimensionDisplayInd), e.dragDimensionDisplayInd = i.model.displayInd;
+            }
+            nJ(e.parcatsViewModel), iJ(e.parcatsViewModel), _Ve(e.parcatsViewModel), yVe(e.parcatsViewModel);
+          }
+        }
+        function $Ht(e) {
+          if (e.parcatsViewModel.arrangement !== "fixed" && e.dragDimensionDisplayInd !== null) {
+            Fl.select(this).selectAll("text").attr("font-weight", "normal");
+            var t = {}, r = mVe(e.parcatsViewModel), n = e.parcatsViewModel.model.dimensions.map(function(h) {
+              return h.displayInd;
+            }), i = e.initialDragDimensionDisplayInds.some(function(h, d) {
+              return h !== n[d];
+            });
+            i && n.forEach(function(h, d) {
+              var v = e.parcatsViewModel.model.dimensions[d].containerInd;
+              t["dimensions[" + v + "].displayindex"] = h;
+            });
+            var a = false;
+            if (e.dragCategoryDisplayInd !== null) {
+              var o = e.model.categories.map(function(h) {
+                return h.displayInd;
+              });
+              if (a = e.initialDragCategoryDisplayInds.some(function(h, d) {
+                return h !== o[d];
+              }), a) {
+                var s = e.model.categories.slice().sort(function(h, d) {
+                  return h.displayInd - d.displayInd;
+                }), l = s.map(function(h) {
+                  return h.categoryValue;
+                }), u = s.map(function(h) {
+                  return h.categoryLabel;
+                });
+                t["dimensions[" + e.model.containerInd + "].categoryarray"] = [l], t["dimensions[" + e.model.containerInd + "].ticktext"] = [u], t["dimensions[" + e.model.containerInd + "].categoryorder"] = "array";
+              }
+            }
+            if (e.parcatsViewModel.hoverinfoItems.indexOf("skip") === -1 && !e.dragHasMoved && e.potentialClickBand && (e.parcatsViewModel.hoveron === "color" ? rJ(e.potentialClickBand, "plotly_click", Fl.event.sourceEvent) : tJ(e.potentialClickBand, "plotly_click", Fl.event.sourceEvent)), e.model.dragX = null, e.dragCategoryDisplayInd !== null) {
+              var c = e.parcatsViewModel.dimensions[e.dragDimensionDisplayInd].categories[e.dragCategoryDisplayInd];
+              c.model.dragY = null, e.dragCategoryDisplayInd = null;
+            }
+            e.dragDimensionDisplayInd = null, e.parcatsViewModel.dragDimension = null, e.dragHasMoved = null, e.potentialClickBand = null, nJ(e.parcatsViewModel), iJ(e.parcatsViewModel);
+            var f = Fl.transition().duration(300).ease("cubic-in-out");
+            f.each(function() {
+              _Ve(e.parcatsViewModel, true), yVe(e.parcatsViewModel, true);
+            }).each("end", function() {
+              (i || a) && zHt.restyle(e.parcatsViewModel.graphDiv, t, [r]);
+            });
+          }
+        }
+        function mVe(e) {
+          for (var t, r = e.graphDiv._fullData, n = 0; n < r.length; n++) if (e.key === r[n].uid) {
+            t = n;
+            break;
+          }
+          return t;
+        }
+        function yVe(e, t) {
+          t === void 0 && (t = false);
+          function r(n) {
+            return t ? n.transition() : n;
+          }
+          e.pathSelection.data(function(n) {
+            return n.paths;
+          }, g1), r(e.pathSelection).attr("d", function(n) {
+            return n.svgD;
+          });
+        }
+        function _Ve(e, t) {
+          t === void 0 && (t = false);
+          function r(l) {
+            return t ? l.transition() : l;
+          }
+          e.dimensionSelection.data(function(l) {
+            return l.dimensions;
+          }, g1);
+          var n = e.dimensionSelection.selectAll("g.category").data(function(l) {
+            return l.categories;
+          }, g1);
+          r(e.dimensionSelection).attr("transform", function(l) {
+            return Hk(l.x, 0);
+          }), r(n).attr("transform", function(l) {
+            return Hk(0, l.y);
+          });
+          var i = n.select(".dimlabel");
+          i.text(function(l, u) {
+            return u === 0 ? l.parcatsViewModel.model.dimensions[l.model.dimensionInd].dimensionLabel : null;
+          });
+          var a = n.select(".catlabel");
+          a.attr("text-anchor", function(l) {
+            return jk(l) ? "start" : "end";
+          }).attr("x", function(l) {
+            return jk(l) ? l.width + 5 : -5;
+          }).each(function(l) {
+            var u, c;
+            jk(l) ? (u = l.width + 5, c = "start") : (u = -5, c = "end"), Fl.select(this).selectAll("tspan").attr("x", u).attr("text-anchor", c);
+          });
+          var o = n.selectAll("rect.bandrect").data(function(l) {
+            return l.bands;
+          }, g1), s = o.enter().append("rect").attr("class", "bandrect").attr("cursor", "move").attr("stroke-opacity", 0).attr("fill", function(l) {
+            return l.color;
+          }).attr("fill-opacity", 0);
+          o.attr("fill", function(l) {
+            return l.color;
+          }).attr("width", function(l) {
+            return l.width;
+          }).attr("height", function(l) {
+            return l.height;
+          }).attr("y", function(l) {
+            return l.y;
+          }), eJ(s), o.each(function() {
+            Ex.raiseToTop(this);
+          }), o.exit().remove();
+        }
+        function QHt(e, t, r) {
+          var n = r[0], i = t.margin || { l: 80, r: 80, t: 100, b: 80 }, a = n.trace, o = a.domain, s = t.width, l = t.height, u = Math.floor(s * (o.x[1] - o.x[0])), c = Math.floor(l * (o.y[1] - o.y[0])), f = o.x[0] * s + i.l, h = t.height - o.y[1] * t.height + i.t, d = a.line.shape, v;
+          a.hoverinfo === "all" ? v = ["count", "probability"] : v = (a.hoverinfo || "").split("+");
+          var _ = { trace: a, key: a.uid, model: n, x: f, y: h, width: u, height: c, hoveron: a.hoveron, hoverinfoItems: v, arrangement: a.arrangement, bundlecolors: a.bundlecolors, sortpaths: a.sortpaths, labelfont: a.labelfont, categorylabelfont: a.tickfont, pathShape: d, dragDimension: null, margin: i, paths: [], dimensions: [], graphDiv: e, traceSelection: null, pathSelection: null, dimensionSelection: null };
+          return n.dimensions && (nJ(_), iJ(_)), _;
+        }
+        function vVe(e, t, r, n, i) {
+          var a = [], o = [], s, l;
+          for (l = 0; l < r.length - 1; l++) s = FHt(r[l] + e[l], e[l + 1]), a.push(s(i)), o.push(s(1 - i));
+          var u = "M " + e[0] + "," + t[0];
+          for (u += "l" + r[0] + ",0 ", l = 1; l < r.length; l++) u += "C" + a[l - 1] + "," + t[l - 1] + " " + o[l - 1] + "," + t[l] + " " + e[l] + "," + t[l], u += "l" + r[l] + ",0 ";
+          for (u += "l0," + n + " ", u += "l -" + r[r.length - 1] + ",0 ", l = r.length - 2; l >= 0; l--) u += "C" + o[l] + "," + (t[l + 1] + n) + " " + a[l] + "," + (t[l] + n) + " " + (e[l] + r[l]) + "," + (t[l] + n), u += "l-" + r[l] + ",0 ";
+          return u += "Z", u;
+        }
+        function iJ(e) {
+          var t = e.dimensions, r = e.model, n = t.map(function(O) {
+            return O.categories.map(function(U) {
+              return U.y;
+            });
+          }), i = e.model.dimensions.map(function(O) {
+            return O.categories.map(function(U) {
+              return U.displayInd;
+            });
+          }), a = e.model.dimensions.map(function(O) {
+            return O.displayInd;
+          }), o = e.dimensions.map(function(O) {
+            return O.model.dimensionInd;
+          }), s = t.map(function(O) {
+            return O.x;
+          }), l = t.map(function(O) {
+            return O.width;
+          }), u = [];
+          for (var c in r.paths) r.paths.hasOwnProperty(c) && u.push(r.paths[c]);
+          function f(O) {
+            var U = O.categoryInds.map(function(Z, j) {
+              return i[j][Z];
+            }), G = o.map(function(Z) {
+              return U[Z];
+            });
+            return G;
+          }
+          u.sort(function(O, U) {
+            var G = f(O), Z = f(U);
+            return e.sortpaths === "backward" && (G.reverse(), Z.reverse()), G.push(O.valueInds[0]), Z.push(U.valueInds[0]), e.bundlecolors && (G.unshift(O.rawColor), Z.unshift(U.rawColor)), G < Z ? -1 : G > Z ? 1 : 0;
+          });
+          for (var h = new Array(u.length), d = t[0].model.count, v = t[0].categories.map(function(O) {
+            return O.height;
+          }).reduce(function(O, U) {
+            return O + U;
+          }), _ = 0; _ < u.length; _++) {
+            var b = u[_], p;
+            d > 0 ? p = v * (b.count / d) : p = 0;
+            for (var k = new Array(n.length), E = 0; E < b.categoryInds.length; E++) {
+              var T = b.categoryInds[E], L = i[E][T], x = a[E];
+              k[x] = n[x][L], n[x][L] += p;
+              var C = e.dimensions[x].categories[L], M = C.bands.length, g = C.bands[M - 1];
+              if (g === void 0 || b.rawColor !== g.rawColor) {
+                var P = g === void 0 ? 0 : g.y + g.height;
+                C.bands.push({ key: P, color: b.color, rawColor: b.rawColor, height: p, width: C.width, count: b.count, y: P, categoryViewModel: C, parcatsViewModel: e });
+              } else {
+                var A = C.bands[M - 1];
+                A.height += p, A.count += b.count;
+              }
+            }
+            var z;
+            e.pathShape === "hspline" ? z = vVe(s, k, l, p, 0.5) : z = vVe(s, k, l, p, 0), h[_] = { key: b.valueInds[0], model: b, height: p, leftXs: s, topYs: k, dimWidths: l, svgD: z, parcatsViewModel: e };
+          }
+          e.paths = h;
+        }
+        function nJ(e) {
+          var t = e.model.dimensions.map(function(o) {
+            return { displayInd: o.displayInd, dimensionInd: o.dimensionInd };
+          });
+          t.sort(function(o, s) {
+            return o.displayInd - s.displayInd;
+          });
+          var r = [];
+          for (var n in t) {
+            var i = t[n].dimensionInd, a = e.model.dimensions[i];
+            r.push(ejt(e, a));
+          }
+          e.dimensions = r;
+        }
+        function ejt(e, t) {
+          var r = 40, n = 16, i = e.model.dimensions.length, a = t.displayInd, o, s, l;
+          i > 1 ? o = (e.width - 2 * r - n) / (i - 1) : o = 0, s = r, l = s + o * a;
+          var u = [], c = e.model.maxCats, f = t.categories.length, h = 8, d = t.count, v = e.height - h * (c - 1), _, b, p, k, E, T = (c - f) * h / 2, L = t.categories.map(function(x) {
+            return { displayInd: x.displayInd, categoryInd: x.categoryInd };
+          });
+          for (L.sort(function(x, C) {
+            return x.displayInd - C.displayInd;
+          }), E = 0; E < f; E++) k = L[E].categoryInd, b = t.categories[k], d > 0 ? _ = b.count / d * v : _ = 0, p = { key: b.valueInds[0], model: b, width: n, height: _, y: b.dragY !== null ? b.dragY : T, bands: [], parcatsViewModel: e }, T = T + _ + h, u.push(p);
+          return { key: t.dimensionInd, x: t.dragX !== null ? t.dragX : l, y: 0, width: n, model: t, categories: u, parcatsViewModel: e, dragCategoryDisplayInd: null, dragDimensionDisplayInd: null, initialDragDimensionDisplayInds: null, initialDragCategoryDisplayInds: null, dragHasMoved: null, potentialClickBand: null };
+        }
+      });
+      var aJ = ye((pxr, wVe) => {
+        var tjt = bVe();
+        wVe.exports = function(t, r, n, i) {
+          var a = t._fullLayout, o = a._paper, s = a._size;
+          tjt(t, o, r, { width: s.w, height: s.h, margin: { t: s.t, r: s.r, b: s.b, l: s.l } }, n, i);
+        };
+      });
+      var AVe = ye((Yz) => {
+        var rjt = Id().getModuleCalcData, ijt = aJ(), TVe = "parcats";
+        Yz.name = TVe;
+        Yz.plot = function(e, t, r, n) {
+          var i = rjt(e.calcdata, TVe);
+          if (i.length) {
+            var a = i[0];
+            ijt(e, a, r, n);
+          }
+        };
+        Yz.clean = function(e, t, r, n) {
+          var i = n._has && n._has("parcats"), a = t._has && t._has("parcats");
+          i && !a && n._paperdiv.selectAll(".parcats").remove();
+        };
+      });
+      var MVe = ye((mxr, SVe) => {
+        SVe.exports = { attributes: ZK(), supplyDefaults: cVe(), calc: hVe(), plot: aJ(), colorbar: { container: "line", min: "cmin", max: "cmax" }, moduleType: "trace", name: "parcats", basePlotModule: AVe(), categories: ["noOpacity"], meta: {} };
+      });
+      var kVe = ye((yxr, EVe) => {
+        EVe.exports = MVe();
+      });
+      var m1 = ye((_xr, FVe) => {
+        var njt = t_(), CVe = "1.13.4", RVe = '© <a target="_blank" href="https://www.openstreetmap.org/copyright">OpenStreetMap</a> contributors', LVe = ['© <a target="_blank" href="https://carto.com/">Carto</a>', RVe].join(" "), PVe = ['Map tiles by <a target="_blank" href="https://stamen.com">Stamen Design</a>', 'under <a target="_blank" href="https://creativecommons.org/licenses/by/3.0">CC BY 3.0</a>', "|", 'Data by <a target="_blank" href="https://openstreetmap.org">OpenStreetMap</a> contributors', 'under <a target="_blank" href="https://www.openstreetmap.org/copyright">ODbL</a>'].join(" "), ajt = ['Map tiles by <a target="_blank" href="https://stamen.com">Stamen Design</a>', 'under <a target="_blank" href="https://creativecommons.org/licenses/by/3.0">CC BY 3.0</a>', "|", 'Data by <a target="_blank" href="https://openstreetmap.org">OpenStreetMap</a> contributors', 'under <a target="_blank" href="https://creativecommons.org/licenses/by-sa/3.0">CC BY SA</a>'].join(" "), DVe = { "open-street-map": { id: "osm", version: 8, sources: { "plotly-osm-tiles": { type: "raster", attribution: RVe, tiles: ["https://a.tile.openstreetmap.org/{z}/{x}/{y}.png", "https://b.tile.openstreetmap.org/{z}/{x}/{y}.png"], tileSize: 256 } }, layers: [{ id: "plotly-osm-tiles", type: "raster", source: "plotly-osm-tiles", minzoom: 0, maxzoom: 22 }], glyphs: "https://fonts.openmaptiles.org/{fontstack}/{range}.pbf" }, "white-bg": { id: "white-bg", version: 8, sources: {}, layers: [{ id: "white-bg", type: "background", paint: { "background-color": "#FFFFFF" }, minzoom: 0, maxzoom: 22 }], glyphs: "https://fonts.openmaptiles.org/{fontstack}/{range}.pbf" }, "carto-positron": { id: "carto-positron", version: 8, sources: { "plotly-carto-positron": { type: "raster", attribution: LVe, tiles: ["https://cartodb-basemaps-c.global.ssl.fastly.net/light_all/{z}/{x}/{y}.png"], tileSize: 256 } }, layers: [{ id: "plotly-carto-positron", type: "raster", source: "plotly-carto-positron", minzoom: 0, maxzoom: 22 }], glyphs: "https://fonts.openmaptiles.org/{fontstack}/{range}.pbf" }, "carto-darkmatter": { id: "carto-darkmatter", version: 8, sources: { "plotly-carto-darkmatter": { type: "raster", attribution: LVe, tiles: ["https://cartodb-basemaps-c.global.ssl.fastly.net/dark_all/{z}/{x}/{y}.png"], tileSize: 256 } }, layers: [{ id: "plotly-carto-darkmatter", type: "raster", source: "plotly-carto-darkmatter", minzoom: 0, maxzoom: 22 }], glyphs: "https://fonts.openmaptiles.org/{fontstack}/{range}.pbf" }, "stamen-terrain": { id: "stamen-terrain", version: 8, sources: { "plotly-stamen-terrain": { type: "raster", attribution: PVe, tiles: ["https://tiles.stadiamaps.com/tiles/stamen_terrain/{z}/{x}/{y}.png?api_key="], tileSize: 256 } }, layers: [{ id: "plotly-stamen-terrain", type: "raster", source: "plotly-stamen-terrain", minzoom: 0, maxzoom: 22 }], glyphs: "https://fonts.openmaptiles.org/{fontstack}/{range}.pbf" }, "stamen-toner": { id: "stamen-toner", version: 8, sources: { "plotly-stamen-toner": { type: "raster", attribution: PVe, tiles: ["https://tiles.stadiamaps.com/tiles/stamen_toner/{z}/{x}/{y}.png?api_key="], tileSize: 256 } }, layers: [{ id: "plotly-stamen-toner", type: "raster", source: "plotly-stamen-toner", minzoom: 0, maxzoom: 22 }], glyphs: "https://fonts.openmaptiles.org/{fontstack}/{range}.pbf" }, "stamen-watercolor": { id: "stamen-watercolor", version: 8, sources: { "plotly-stamen-watercolor": { type: "raster", attribution: ajt, tiles: ["https://tiles.stadiamaps.com/tiles/stamen_watercolor/{z}/{x}/{y}.jpg?api_key="], tileSize: 256 } }, layers: [{ id: "plotly-stamen-watercolor", type: "raster", source: "plotly-stamen-watercolor", minzoom: 0, maxzoom: 22 }], glyphs: "https://fonts.openmaptiles.org/{fontstack}/{range}.pbf" } }, IVe = njt(DVe);
+        FVe.exports = { requiredVersion: CVe, styleUrlPrefix: "mapbox://styles/mapbox/", styleUrlSuffix: "v9", styleValuesMapbox: ["basic", "streets", "outdoors", "light", "dark", "satellite", "satellite-streets"], styleValueDflt: "basic", stylesNonMapbox: DVe, styleValuesNonMapbox: IVe, traceLayerPrefix: "plotly-trace-layer-", layoutLayerPrefix: "plotly-layout-layer-", wrongVersionErrorMsg: ["Your custom plotly.js bundle is not using the correct mapbox-gl version", "Please install @plotly/mapbox-gl@" + CVe + "."].join(`
+`), noAccessTokenErrorMsg: ["Missing Mapbox access token.", "Mapbox trace type require a Mapbox access token to be registered.", "For example:", "  Plotly.newPlot(gd, data, layout, { mapboxAccessToken: 'my-access-token' });", "More info here: https://www.mapbox.com/help/define-access-token/"].join(`
+`), missingStyleErrorMsg: ["No valid mapbox style found, please set `mapbox.style` to one of:", IVe.join(", "), "or register a Mapbox access token to use a Mapbox-served style."].join(`
+`), multipleTokensErrorMsg: ["Set multiple mapbox access token across different mapbox subplot,", "using first token found as mapbox-gl does not allow multipleaccess tokens on the same page."].join(`
+`), mapOnErrorMsg: "Mapbox error.", mapboxLogo: { path0: "m 10.5,1.24 c -5.11,0 -9.25,4.15 -9.25,9.25 0,5.1 4.15,9.25 9.25,9.25 5.1,0 9.25,-4.15 9.25,-9.25 0,-5.11 -4.14,-9.25 -9.25,-9.25 z m 4.39,11.53 c -1.93,1.93 -4.78,2.31 -6.7,2.31 -0.7,0 -1.41,-0.05 -2.1,-0.16 0,0 -1.02,-5.64 2.14,-8.81 0.83,-0.83 1.95,-1.28 3.13,-1.28 1.27,0 2.49,0.51 3.39,1.42 1.84,1.84 1.89,4.75 0.14,6.52 z", path1: "M 10.5,-0.01 C 4.7,-0.01 0,4.7 0,10.49 c 0,5.79 4.7,10.5 10.5,10.5 5.8,0 10.5,-4.7 10.5,-10.5 C 20.99,4.7 16.3,-0.01 10.5,-0.01 Z m 0,19.75 c -5.11,0 -9.25,-4.15 -9.25,-9.25 0,-5.1 4.14,-9.26 9.25,-9.26 5.11,0 9.25,4.15 9.25,9.25 0,5.13 -4.14,9.26 -9.25,9.26 z", path2: "M 14.74,6.25 C 12.9,4.41 9.98,4.35 8.23,6.1 5.07,9.27 6.09,14.91 6.09,14.91 c 0,0 5.64,1.02 8.81,-2.14 C 16.64,11 16.59,8.09 14.74,6.25 Z m -2.27,4.09 -0.91,1.87 -0.9,-1.87 -1.86,-0.91 1.86,-0.9 0.9,-1.87 0.91,1.87 1.86,0.9 z", polygon: "11.56,12.21 10.66,10.34 8.8,9.43 10.66,8.53 11.56,6.66 12.47,8.53 14.33,9.43 12.47,10.34" }, styleRules: { map: "overflow:hidden;position:relative;", "missing-css": "display:none;", canary: "background-color:salmon;", "ctrl-bottom-left": "position: absolute; pointer-events: none; z-index: 2; bottom: 0; left: 0;", "ctrl-bottom-right": "position: absolute; pointer-events: none; z-index: 2; right: 0; bottom: 0;", ctrl: "clear: both; pointer-events: auto; transform: translate(0, 0);", "ctrl-attrib.mapboxgl-compact .mapboxgl-ctrl-attrib-inner": "display: none;", "ctrl-attrib.mapboxgl-compact:hover .mapboxgl-ctrl-attrib-inner": "display: block; margin-top:2px", "ctrl-attrib.mapboxgl-compact:hover": "padding: 2px 24px 2px 4px; visibility: visible; margin-top: 6px;", "ctrl-attrib.mapboxgl-compact::after": `content: ""; cursor: pointer; position: absolute; background-image: url('data:image/svg+xml;charset=utf-8,%3Csvg viewBox="0 0 20 20" xmlns="http://www.w3.org/2000/svg"%3E %3Cpath fill="%23333333" fill-rule="evenodd" d="M4,10a6,6 0 1,0 12,0a6,6 0 1,0 -12,0 M9,7a1,1 0 1,0 2,0a1,1 0 1,0 -2,0 M9,10a1,1 0 1,1 2,0l0,3a1,1 0 1,1 -2,0"/%3E %3C/svg%3E'); background-color: rgba(255, 255, 255, 0.5); width: 24px; height: 24px; box-sizing: border-box; border-radius: 12px;`, "ctrl-attrib.mapboxgl-compact": "min-height: 20px; padding: 0; margin: 10px; position: relative; background-color: #fff; border-radius: 3px 12px 12px 3px;", "ctrl-bottom-right > .mapboxgl-ctrl-attrib.mapboxgl-compact::after": "bottom: 0; right: 0", "ctrl-bottom-left > .mapboxgl-ctrl-attrib.mapboxgl-compact::after": "bottom: 0; left: 0", "ctrl-bottom-left .mapboxgl-ctrl": "margin: 0 0 10px 10px; float: left;", "ctrl-bottom-right .mapboxgl-ctrl": "margin: 0 10px 10px 0; float: right;", "ctrl-attrib": "color: rgba(0, 0, 0, 0.75); text-decoration: none; font-size: 12px", "ctrl-attrib a": "color: rgba(0, 0, 0, 0.75); text-decoration: none; font-size: 12px", "ctrl-attrib a:hover": "color: inherit; text-decoration: underline;", "ctrl-attrib .mapbox-improve-map": "font-weight: bold; margin-left: 2px;", "attrib-empty": "display: none;", "ctrl-logo": `display:block; width: 21px; height: 21px; background-image: url('data:image/svg+xml;charset=utf-8,%3C?xml version="1.0" encoding="utf-8"?%3E %3Csvg version="1.1" id="Layer_1" xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink" x="0px" y="0px" viewBox="0 0 21 21" style="enable-background:new 0 0 21 21;" xml:space="preserve"%3E%3Cg transform="translate(0,0.01)"%3E%3Cpath d="m 10.5,1.24 c -5.11,0 -9.25,4.15 -9.25,9.25 0,5.1 4.15,9.25 9.25,9.25 5.1,0 9.25,-4.15 9.25,-9.25 0,-5.11 -4.14,-9.25 -9.25,-9.25 z m 4.39,11.53 c -1.93,1.93 -4.78,2.31 -6.7,2.31 -0.7,0 -1.41,-0.05 -2.1,-0.16 0,0 -1.02,-5.64 2.14,-8.81 0.83,-0.83 1.95,-1.28 3.13,-1.28 1.27,0 2.49,0.51 3.39,1.42 1.84,1.84 1.89,4.75 0.14,6.52 z" style="opacity:0.9;fill:%23ffffff;enable-background:new" class="st0"/%3E%3Cpath d="M 10.5,-0.01 C 4.7,-0.01 0,4.7 0,10.49 c 0,5.79 4.7,10.5 10.5,10.5 5.8,0 10.5,-4.7 10.5,-10.5 C 20.99,4.7 16.3,-0.01 10.5,-0.01 Z m 0,19.75 c -5.11,0 -9.25,-4.15 -9.25,-9.25 0,-5.1 4.14,-9.26 9.25,-9.26 5.11,0 9.25,4.15 9.25,9.25 0,5.13 -4.14,9.26 -9.25,9.26 z" style="opacity:0.35;enable-background:new" class="st1"/%3E%3Cpath d="M 14.74,6.25 C 12.9,4.41 9.98,4.35 8.23,6.1 5.07,9.27 6.09,14.91 6.09,14.91 c 0,0 5.64,1.02 8.81,-2.14 C 16.64,11 16.59,8.09 14.74,6.25 Z m -2.27,4.09 -0.91,1.87 -0.9,-1.87 -1.86,-0.91 1.86,-0.9 0.9,-1.87 0.91,1.87 1.86,0.9 z" style="opacity:0.35;enable-background:new" class="st1"/%3E%3Cpolygon points="11.56,12.21 10.66,10.34 8.8,9.43 10.66,8.53 11.56,6.66 12.47,8.53 14.33,9.43 12.47,10.34 " style="opacity:0.9;fill:%23ffffff;enable-background:new" class="st0"/%3E%3C/g%3E%3C/svg%3E')` } };
+      });
+      var Zk = ye((xxr, BVe) => {
+        var zVe = Dr(), OVe = ka().defaultLine, ojt = Cc().attributes, sjt = ec(), ljt = pf().textposition, ujt = mc().overrideAll, cjt = vl().templatedArray, oJ = m1(), qVe = sjt({ noFontVariant: true, noFontShadow: true, noFontLineposition: true, noFontTextcase: true });
+        qVe.family.dflt = "Open Sans Regular, Arial Unicode MS Regular";
+        var fjt = BVe.exports = ujt({ _arrayAttrRegexps: [zVe.counterRegex("mapbox", ".layers", true)], domain: ojt({ name: "mapbox" }), accesstoken: { valType: "string", noBlank: true, strict: true }, style: { valType: "any", values: oJ.styleValuesMapbox.concat(oJ.styleValuesNonMapbox), dflt: oJ.styleValueDflt }, center: { lon: { valType: "number", dflt: 0 }, lat: { valType: "number", dflt: 0 } }, zoom: { valType: "number", dflt: 1 }, bearing: { valType: "number", dflt: 0 }, pitch: { valType: "number", dflt: 0 }, bounds: { west: { valType: "number" }, east: { valType: "number" }, south: { valType: "number" }, north: { valType: "number" } }, layers: cjt("layer", { visible: { valType: "boolean", dflt: true }, sourcetype: { valType: "enumerated", values: ["geojson", "vector", "raster", "image"], dflt: "geojson" }, source: { valType: "any" }, sourcelayer: { valType: "string", dflt: "" }, sourceattribution: { valType: "string" }, type: { valType: "enumerated", values: ["circle", "line", "fill", "symbol", "raster"], dflt: "circle" }, coordinates: { valType: "any" }, below: { valType: "string" }, color: { valType: "color", dflt: OVe }, opacity: { valType: "number", min: 0, max: 1, dflt: 1 }, minzoom: { valType: "number", min: 0, max: 24, dflt: 0 }, maxzoom: { valType: "number", min: 0, max: 24, dflt: 24 }, circle: { radius: { valType: "number", dflt: 15 } }, line: { width: { valType: "number", dflt: 2 }, dash: { valType: "data_array" } }, fill: { outlinecolor: { valType: "color", dflt: OVe } }, symbol: { icon: { valType: "string", dflt: "marker" }, iconsize: { valType: "number", dflt: 10 }, text: { valType: "string", dflt: "" }, placement: { valType: "enumerated", values: ["point", "line", "line-center"], dflt: "point" }, textfont: qVe, textposition: zVe.extendFlat({}, ljt, { arrayOk: false }) } }) }, "plot", "from-root");
+        fjt.uirevision = { valType: "any", editType: "none" };
+      });
+      var Kz = ye((bxr, GVe) => {
+        var { hovertemplateAttrs: hjt, texttemplateAttrs: djt, templatefallbackAttrs: NVe } = Ll(), vjt = Pg(), Yk = ew(), E5 = pf(), UVe = Zk(), pjt = Gl(), gjt = Tu(), fw = Ao().extendFlat, mjt = mc().overrideAll, yjt = Zk(), VVe = Yk.line, k5 = Yk.marker;
+        GVe.exports = mjt({ lon: Yk.lon, lat: Yk.lat, cluster: { enabled: { valType: "boolean" }, maxzoom: fw({}, yjt.layers.maxzoom, {}), step: { valType: "number", arrayOk: true, dflt: -1, min: -1 }, size: { valType: "number", arrayOk: true, dflt: 20, min: 0 }, color: { valType: "color", arrayOk: true }, opacity: fw({}, k5.opacity, { dflt: 1 }) }, mode: fw({}, E5.mode, { dflt: "markers" }), text: fw({}, E5.text, {}), texttemplate: djt({ editType: "plot" }, { keys: ["lat", "lon", "text"] }), texttemplatefallback: NVe({ editType: "plot" }), hovertext: fw({}, E5.hovertext, {}), line: { color: VVe.color, width: VVe.width }, connectgaps: E5.connectgaps, marker: fw({ symbol: { valType: "string", dflt: "circle", arrayOk: true }, angle: { valType: "number", dflt: "auto", arrayOk: true }, allowoverlap: { valType: "boolean", dflt: false }, opacity: k5.opacity, size: k5.size, sizeref: k5.sizeref, sizemin: k5.sizemin, sizemode: k5.sizemode }, gjt("marker")), fill: Yk.fill, fillcolor: vjt(), textfont: UVe.layers.symbol.textfont, textposition: UVe.layers.symbol.textposition, below: { valType: "string" }, selected: { marker: E5.selected.marker }, unselected: { marker: E5.unselected.marker }, hoverinfo: fw({}, pjt.hoverinfo, { flags: ["lon", "lat", "text", "name"] }), hovertemplate: hjt(), hovertemplatefallback: NVe() }, "calc", "nested");
+      });
+      var sJ = ye((wxr, HVe) => {
+        var _jt = ["Metropolis Black Italic", "Metropolis Black", "Metropolis Bold Italic", "Metropolis Bold", "Metropolis Extra Bold Italic", "Metropolis Extra Bold", "Metropolis Extra Light Italic", "Metropolis Extra Light", "Metropolis Light Italic", "Metropolis Light", "Metropolis Medium Italic", "Metropolis Medium", "Metropolis Regular Italic", "Metropolis Regular", "Metropolis Semi Bold Italic", "Metropolis Semi Bold", "Metropolis Thin Italic", "Metropolis Thin", "Open Sans Bold Italic", "Open Sans Bold", "Open Sans Extrabold Italic", "Open Sans Extrabold", "Open Sans Italic", "Open Sans Light Italic", "Open Sans Light", "Open Sans Regular", "Open Sans Semibold Italic", "Open Sans Semibold", "Klokantech Noto Sans Bold", "Klokantech Noto Sans CJK Bold", "Klokantech Noto Sans CJK Regular", "Klokantech Noto Sans Italic", "Klokantech Noto Sans Regular"];
+        HVe.exports = { isSupportedFont: function(e) {
+          return _jt.indexOf(e) !== -1;
+        } };
+      });
+      var XVe = ye((Txr, WVe) => {
+        var Kk = Dr(), lJ = Ru(), xjt = $p(), bjt = D0(), wjt = F0(), Tjt = Fg(), jVe = Kz(), Ajt = sJ().isSupportedFont;
+        WVe.exports = function(t, r, n, i) {
+          function a(p, k) {
+            return Kk.coerce(t, r, jVe, p, k);
+          }
+          function o(p, k) {
+            return Kk.coerce2(t, r, jVe, p, k);
+          }
+          var s = Sjt(t, r, a);
+          if (!s) {
+            r.visible = false;
+            return;
+          }
+          if (a("text"), a("texttemplate"), a("texttemplatefallback"), a("hovertext"), a("hovertemplate"), a("hovertemplatefallback"), a("mode"), a("below"), lJ.hasMarkers(r)) {
+            xjt(t, r, n, i, a, { noLine: true, noAngle: true }), a("marker.allowoverlap"), a("marker.angle");
+            var l = r.marker;
+            l.symbol !== "circle" && (Kk.isArrayOrTypedArray(l.size) && (l.size = l.size[0]), Kk.isArrayOrTypedArray(l.color) && (l.color = l.color[0]));
+          }
+          lJ.hasLines(r) && (bjt(t, r, n, i, a, { noDash: true }), a("connectgaps"));
+          var u = o("cluster.maxzoom"), c = o("cluster.step"), f = o("cluster.color", r.marker && r.marker.color || n), h = o("cluster.size"), d = o("cluster.opacity"), v = u !== false || c !== false || f !== false || h !== false || d !== false, _ = a("cluster.enabled", v);
+          if (_ || lJ.hasText(r)) {
+            var b = i.font.family;
+            wjt(t, r, i, a, { noSelect: true, noFontVariant: true, noFontShadow: true, noFontLineposition: true, noFontTextcase: true, font: { family: Ajt(b) ? b : "Open Sans Regular", weight: i.font.weight, style: i.font.style, size: i.font.size, color: i.font.color } });
+          }
+          a("fill"), r.fill !== "none" && Tjt(t, r, n, a), Kk.coerceSelectionMarkerOpacity(r, a);
+        };
+        function Sjt(e, t, r) {
+          var n = r("lon") || [], i = r("lat") || [], a = Math.min(n.length, i.length);
+          return t._length = a, a;
+        }
+      });
+      var uJ = ye((Axr, YVe) => {
+        var ZVe = ho();
+        YVe.exports = function(t, r, n) {
+          var i = {}, a = n[r.subplot]._subplot, o = a.mockAxis, s = t.lonlat;
+          return i.lonLabel = ZVe.tickText(o, o.c2l(s[0]), true).text, i.latLabel = ZVe.tickText(o, o.c2l(s[1]), true).text, i;
+        };
+      });
+      var cJ = ye((Sxr, JVe) => {
+        var KVe = Dr();
+        JVe.exports = function(t, r) {
+          var n = t.split(" "), i = n[0], a = n[1], o = KVe.isArrayOrTypedArray(r) ? KVe.mean(r) : r, s = 0.5 + o / 100, l = 1.5 + o / 100, u = ["", ""], c = [0, 0];
+          switch (i) {
+            case "top":
+              u[0] = "top", c[1] = -l;
+              break;
+            case "bottom":
+              u[0] = "bottom", c[1] = l;
+              break;
+          }
+          switch (a) {
+            case "left":
+              u[1] = "right", c[0] = -s;
+              break;
+            case "right":
+              u[1] = "left", c[0] = s;
+              break;
+          }
+          var f;
+          return u[0] && u[1] ? f = u.join("-") : u[0] ? f = u[0] : u[1] ? f = u[1] : f = "center", { anchor: f, offset: c };
+        };
+      });
+      var iGe = ye((Mxr, rGe) => {
+        var eGe = Eo(), av = Dr(), Mjt = fs().BADNUM, $z = cx(), $Ve = tc(), Ejt = So(), kjt = O3(), Qz = Ru(), Cjt = sJ().isSupportedFont, Ljt = cJ(), Pjt = ip().appendArrayPointValue, Ijt = Zl().NEWLINES, Rjt = Zl().BR_TAG_ALL;
+        rGe.exports = function(t, r) {
+          var n = r[0].trace, i = n.visible === true && n._length !== 0, a = n.fill !== "none", o = Qz.hasLines(n), s = Qz.hasMarkers(n), l = Qz.hasText(n), u = s && n.marker.symbol === "circle", c = s && n.marker.symbol !== "circle", f = n.cluster && n.cluster.enabled, h = Jz("fill"), d = Jz("line"), v = Jz("circle"), _ = Jz("symbol"), b = { fill: h, line: d, circle: v, symbol: _ };
+          if (!i) return b;
+          var p;
+          if ((a || o) && (p = $z.calcTraceToLineCoords(r)), a && (h.geojson = $z.makePolygon(p), h.layout.visibility = "visible", av.extendFlat(h.paint, { "fill-color": n.fillcolor })), o && (d.geojson = $z.makeLine(p), d.layout.visibility = "visible", av.extendFlat(d.paint, { "line-width": n.line.width, "line-color": n.line.color, "line-opacity": n.opacity })), u) {
+            var k = Djt(r);
+            v.geojson = k.geojson, v.layout.visibility = "visible", f && (v.filter = ["!", ["has", "point_count"]], b.cluster = { type: "circle", filter: ["has", "point_count"], layout: { visibility: "visible" }, paint: { "circle-color": hJ(n.cluster.color, n.cluster.step), "circle-radius": hJ(n.cluster.size, n.cluster.step), "circle-opacity": hJ(n.cluster.opacity, n.cluster.step) } }, b.clusterCount = { type: "symbol", filter: ["has", "point_count"], paint: {}, layout: { "text-field": "{point_count_abbreviated}", "text-font": QVe(n), "text-size": 12 } }), av.extendFlat(v.paint, { "circle-color": k.mcc, "circle-radius": k.mrc, "circle-opacity": k.mo });
+          }
+          if (u && f && (v.filter = ["!", ["has", "point_count"]]), (c || l) && (_.geojson = Fjt(r, t), av.extendFlat(_.layout, { visibility: "visible", "icon-image": "{symbol}-15", "text-field": "{text}" }), c && (av.extendFlat(_.layout, { "icon-size": n.marker.size / 10 }), "angle" in n.marker && n.marker.angle !== "auto" && av.extendFlat(_.layout, { "icon-rotate": { type: "identity", property: "angle" }, "icon-rotation-alignment": "map" }), _.layout["icon-allow-overlap"] = n.marker.allowoverlap, av.extendFlat(_.paint, { "icon-opacity": n.opacity * n.marker.opacity, "icon-color": n.marker.color })), l)) {
+            var E = (n.marker || {}).size, T = Ljt(n.textposition, E);
+            av.extendFlat(_.layout, { "text-size": n.textfont.size, "text-anchor": T.anchor, "text-offset": T.offset, "text-font": QVe(n) }), av.extendFlat(_.paint, { "text-color": n.textfont.color, "text-opacity": n.opacity });
+          }
+          return b;
+        };
+        function Jz(e) {
+          return { type: e, geojson: $z.makeBlank(), layout: { visibility: "none" }, filter: null, paint: {} };
+        }
+        function Djt(e) {
+          var t = e[0].trace, r = t.marker, n = t.selectedpoints, i = av.isArrayOrTypedArray(r.color), a = av.isArrayOrTypedArray(r.size), o = av.isArrayOrTypedArray(r.opacity), s;
+          function l(E) {
+            return t.opacity * E;
+          }
+          function u(E) {
+            return E / 2;
+          }
+          var c;
+          i && ($Ve.hasColorscale(t, "marker") ? c = $Ve.makeColorScaleFuncFromTrace(r) : c = av.identity);
+          var f;
+          a && (f = kjt(t));
+          var h;
+          o && (h = function(E) {
+            var T = eGe(E) ? +av.constrain(E, 0, 1) : 0;
+            return l(T);
+          });
+          var d = [];
+          for (s = 0; s < e.length; s++) {
+            var v = e[s], _ = v.lonlat;
+            if (!tGe(_)) {
+              var b = {};
+              c && (b.mcc = v.mcc = c(v.mc)), f && (b.mrc = v.mrc = f(v.ms)), h && (b.mo = h(v.mo)), n && (b.selected = v.selected || 0), d.push({ type: "Feature", id: s + 1, geometry: { type: "Point", coordinates: _ }, properties: b });
+            }
+          }
+          var p;
+          if (n) for (p = Ejt.makeSelectedPointStyleFns(t), s = 0; s < d.length; s++) {
+            var k = d[s].properties;
+            p.selectedOpacityFn && (k.mo = l(p.selectedOpacityFn(k))), p.selectedColorFn && (k.mcc = p.selectedColorFn(k)), p.selectedSizeFn && (k.mrc = p.selectedSizeFn(k));
+          }
+          return { geojson: { type: "FeatureCollection", features: d }, mcc: i || p && p.selectedColorFn ? { type: "identity", property: "mcc" } : r.color, mrc: a || p && p.selectedSizeFn ? { type: "identity", property: "mrc" } : u(r.size), mo: o || p && p.selectedOpacityFn ? { type: "identity", property: "mo" } : l(r.opacity) };
+        }
+        function Fjt(e, t) {
+          for (var r = t._fullLayout, n = e[0].trace, i = n.marker || {}, a = i.symbol, o = i.angle, s = a !== "circle" ? fJ(a) : e7, l = o !== "auto" ? fJ(o, true) : e7, u = Qz.hasText(n) ? fJ(n.text) : e7, c = [], f = 0; f < e.length; f++) {
+            var h = e[f];
+            if (!tGe(h.lonlat)) {
+              var d = n.texttemplate, v;
+              if (d) {
+                var _ = Array.isArray(d) ? d[f] || "" : d, b = n._module.formatLabels(h, n, r), p = {};
+                Pjt(p, n, h.i), v = av.texttemplateString({ data: [p, h, n._meta], fallback: n.texttemplatefallback, labels: b, locale: r._d3locale, template: _ });
+              } else v = u(f);
+              v && (v = v.replace(Ijt, "").replace(Rjt, `
+`)), c.push({ type: "Feature", geometry: { type: "Point", coordinates: h.lonlat }, properties: { symbol: s(f), angle: l(f), text: v } });
+            }
+          }
+          return { type: "FeatureCollection", features: c };
+        }
+        function fJ(e, t) {
+          return av.isArrayOrTypedArray(e) ? t ? function(r) {
+            return eGe(e[r]) ? +e[r] : 0;
+          } : function(r) {
+            return e[r];
+          } : e ? function() {
+            return e;
+          } : e7;
+        }
+        function e7() {
+          return "";
+        }
+        function tGe(e) {
+          return e[0] === Mjt;
+        }
+        function hJ(e, t) {
+          var r;
+          if (av.isArrayOrTypedArray(e) && av.isArrayOrTypedArray(t)) {
+            r = ["step", ["get", "point_count"], e[0]];
+            for (var n = 1; n < e.length; n++) r.push(t[n - 1], e[n]);
+          } else r = e;
+          return r;
+        }
+        function QVe(e) {
+          var t = e.textfont, r = t.family, n = t.style, i = t.weight, a = r.split(" "), o = a[a.length - 1] === "Italic";
+          o && a.pop(), o = o || n === "italic";
+          var s = a.join(" ");
+          i === "bold" && a.indexOf("Bold") === -1 ? s += " Bold" : i <= 1e3 && (a[0] === "Metropolis" ? (s = "Metropolis", i > 850 ? s += " Black" : i > 750 ? s += " Extra Bold" : i > 650 ? s += " Bold" : i > 550 ? s += " Semi Bold" : i > 450 ? s += " Medium" : i > 350 ? s += " Regular" : i > 250 ? s += " Light" : i > 150 ? s += " Extra Light" : s += " Thin") : a.slice(0, 2).join(" ") === "Open Sans" ? (s = "Open Sans", i > 750 ? s += " Extrabold" : i > 650 ? s += " Bold" : i > 550 ? s += " Semibold" : i > 350 ? s += " Regular" : s += " Light") : a.slice(0, 3).join(" ") === "Klokantech Noto Sans" && (s = "Klokantech Noto Sans", a[3] === "CJK" && (s += " CJK"), s += i > 500 ? " Bold" : " Regular")), o && (s += " Italic"), s === "Open Sans Regular Italic" ? s = "Open Sans Italic" : s === "Open Sans Regular Bold" ? s = "Open Sans Bold" : s === "Open Sans Regular Bold Italic" ? s = "Open Sans Bold Italic" : s === "Klokantech Noto Sans Regular Italic" && (s = "Klokantech Noto Sans Italic"), Cjt(s) || (s = r);
+          var l = s.split(", ");
+          return l;
+        }
+      });
+      var sGe = ye((Exr, oGe) => {
+        var zjt = Dr(), nGe = iGe(), C5 = m1().traceLayerPrefix, ng = { cluster: ["cluster", "clusterCount", "circle"], nonCluster: ["fill", "line", "circle", "symbol"] };
+        function aGe(e, t, r, n) {
+          this.type = "scattermapbox", this.subplot = e, this.uid = t, this.clusterEnabled = r, this.isHidden = n, this.sourceIds = { fill: "source-" + t + "-fill", line: "source-" + t + "-line", circle: "source-" + t + "-circle", symbol: "source-" + t + "-symbol", cluster: "source-" + t + "-circle", clusterCount: "source-" + t + "-circle" }, this.layerIds = { fill: C5 + t + "-fill", line: C5 + t + "-line", circle: C5 + t + "-circle", symbol: C5 + t + "-symbol", cluster: C5 + t + "-cluster", clusterCount: C5 + t + "-cluster-count" }, this.below = null;
+        }
+        var Jk = aGe.prototype;
+        Jk.addSource = function(e, t, r) {
+          var n = { type: "geojson", data: t.geojson };
+          r && r.enabled && zjt.extendFlat(n, { cluster: true, clusterMaxZoom: r.maxzoom });
+          var i = this.subplot.map.getSource(this.sourceIds[e]);
+          i ? i.setData(t.geojson) : this.subplot.map.addSource(this.sourceIds[e], n);
+        };
+        Jk.setSourceData = function(e, t) {
+          this.subplot.map.getSource(this.sourceIds[e]).setData(t.geojson);
+        };
+        Jk.addLayer = function(e, t, r) {
+          var n = { type: t.type, id: this.layerIds[e], source: this.sourceIds[e], layout: t.layout, paint: t.paint };
+          t.filter && (n.filter = t.filter);
+          for (var i = this.layerIds[e], a, o = this.subplot.getMapLayers(), s = 0; s < o.length; s++) if (o[s].id === i) {
+            a = true;
+            break;
+          }
+          a ? (this.subplot.setOptions(i, "setLayoutProperty", n.layout), n.layout.visibility === "visible" && this.subplot.setOptions(i, "setPaintProperty", n.paint)) : this.subplot.addLayer(n, r);
+        };
+        Jk.update = function(t) {
+          var r = t[0].trace, n = this.subplot, i = n.map, a = nGe(n.gd, t), o = n.belowLookup["trace-" + this.uid], s = !!(r.cluster && r.cluster.enabled), l = !!this.clusterEnabled, u = this;
+          function c(E) {
+            E || u.addSource("circle", a.circle, r.cluster);
+            for (var T = ng.cluster, L = 0; L < T.length; L++) {
+              var x = T[L], C = a[x];
+              u.addLayer(x, C, o);
+            }
+          }
+          function f(E) {
+            for (var T = ng.cluster, L = T.length - 1; L >= 0; L--) {
+              var x = T[L];
+              i.removeLayer(u.layerIds[x]);
+            }
+            E || i.removeSource(u.sourceIds.circle);
+          }
+          function h(E) {
+            for (var T = ng.nonCluster, L = 0; L < T.length; L++) {
+              var x = T[L], C = a[x];
+              E || u.addSource(x, C), u.addLayer(x, C, o);
+            }
+          }
+          function d(E) {
+            for (var T = ng.nonCluster, L = T.length - 1; L >= 0; L--) {
+              var x = T[L];
+              i.removeLayer(u.layerIds[x]), E || i.removeSource(u.sourceIds[x]);
+            }
+          }
+          function v(E) {
+            l ? f(E) : d(E);
+          }
+          function _(E) {
+            s ? c(E) : h(E);
+          }
+          function b() {
+            for (var E = s ? ng.cluster : ng.nonCluster, T = 0; T < E.length; T++) {
+              var L = E[T], x = a[L];
+              x && (n.setOptions(u.layerIds[L], "setLayoutProperty", x.layout), x.layout.visibility === "visible" && (L !== "cluster" && u.setSourceData(L, x), n.setOptions(u.layerIds[L], "setPaintProperty", x.paint)));
+            }
+          }
+          var p = this.isHidden, k = r.visible !== true;
+          k ? p || v() : p ? k || _() : l !== s ? (v(), _()) : (this.below !== o && (v(true), _(true)), b()), this.clusterEnabled = s, this.isHidden = k, this.below = o, t[0].trace._glTrace = this;
+        };
+        Jk.dispose = function() {
+          for (var t = this.subplot.map, r = this.clusterEnabled ? ng.cluster : ng.nonCluster, n = r.length - 1; n >= 0; n--) {
+            var i = r[n];
+            t.removeLayer(this.layerIds[i]), t.removeSource(this.sourceIds[i]);
+          }
+        };
+        oGe.exports = function(t, r) {
+          var n = r[0].trace, i = n.cluster && n.cluster.enabled, a = n.visible !== true, o = new aGe(t, n.uid, i, a), s = nGe(t.gd, r), l = o.below = t.belowLookup["trace-" + n.uid], u, c, f;
+          if (i) for (o.addSource("circle", s.circle, n.cluster), u = 0; u < ng.cluster.length; u++) c = ng.cluster[u], f = s[c], o.addLayer(c, f, l);
+          else for (u = 0; u < ng.nonCluster.length; u++) c = ng.nonCluster[u], f = s[c], o.addSource(c, f, n.cluster), o.addLayer(c, f, l);
+          return r[0].trace._glTrace = o, o;
+        };
+      });
+      var t7 = ye((kxr, uGe) => {
+        var Ojt = vf(), dJ = Dr(), qjt = gT(), Bjt = dJ.fillText, Njt = fs().BADNUM, Ujt = m1().traceLayerPrefix;
+        function Vjt(e, t, r) {
+          var n = e.cd, i = n[0].trace, a = e.xa, o = e.ya, s = e.subplot, l = [], u = Ujt + i.uid + "-circle", c = i.cluster && i.cluster.enabled;
+          if (c) {
+            var f = s.map.queryRenderedFeatures(null, { layers: [u] });
+            l = f.map(function(M) {
+              return M.id;
+            });
+          }
+          var h = t >= 0 ? Math.floor((t + 180) / 360) : Math.ceil((t - 180) / 360), d = h * 360, v = t - d;
+          function _(M) {
+            var g = M.lonlat;
+            if (g[0] === Njt || c && l.indexOf(M.i + 1) === -1) return 1 / 0;
+            var P = dJ.modHalf(g[0], 360), A = g[1], z = s.project([P, A]), O = z.x - a.c2p([v, A]), U = z.y - o.c2p([P, r]), G = Math.max(3, M.mrc || 0);
+            return Math.max(Math.sqrt(O * O + U * U) - G, 1 - 3 / G);
+          }
+          if (Ojt.getClosest(n, _, e), e.index !== false) {
+            var b = n[e.index], p = b.lonlat, k = [dJ.modHalf(p[0], 360) + d, p[1]], E = a.c2p(k), T = o.c2p(k), L = b.mrc || 1;
+            e.x0 = E - L, e.x1 = E + L, e.y0 = T - L, e.y1 = T + L;
+            var x = {};
+            x[i.subplot] = { _subplot: s };
+            var C = i._module.formatLabels(b, i, x);
+            return e.lonLabel = C.lonLabel, e.latLabel = C.latLabel, e.color = qjt(i, b), e.extraText = lGe(i, b, n[0].t.labels), e.hovertemplate = i.hovertemplate, [e];
+          }
+        }
+        function lGe(e, t, r) {
+          if (e.hovertemplate) return;
+          var n = t.hi || e.hoverinfo, i = n.split("+"), a = i.indexOf("all") !== -1, o = i.indexOf("lon") !== -1, s = i.indexOf("lat") !== -1, l = t.lonlat, u = [];
+          function c(f) {
+            return f + "°";
+          }
+          return a || o && s ? u.push("(" + c(l[1]) + ", " + c(l[0]) + ")") : o ? u.push(r.lon + c(l[0])) : s && u.push(r.lat + c(l[1])), (a || i.indexOf("text") !== -1) && Bjt(t, e, u), u.join("<br>");
+        }
+        uGe.exports = { hoverPoints: Vjt, getExtraText: lGe };
+      });
+      var fGe = ye((Cxr, cGe) => {
+        cGe.exports = function(t, r) {
+          return t.lon = r.lon, t.lat = r.lat, t;
+        };
+      });
+      var dGe = ye((Lxr, hGe) => {
+        var Gjt = Dr(), Hjt = Ru(), jjt = fs().BADNUM;
+        hGe.exports = function(t, r) {
+          var n = t.cd, i = t.xaxis, a = t.yaxis, o = [], s = n[0].trace, l;
+          if (!Hjt.hasMarkers(s)) return [];
+          if (r === false) for (l = 0; l < n.length; l++) n[l].selected = 0;
+          else for (l = 0; l < n.length; l++) {
+            var u = n[l], c = u.lonlat;
+            if (c[0] !== jjt) {
+              var f = [Gjt.modHalf(c[0], 360), c[1]], h = [i.c2p(f), a.c2p(f)];
+              r.contains(h, null, l, t) ? (o.push({ pointNumber: l, lon: c[0], lat: c[1] }), u.selected = 1) : u.selected = 0;
+            }
+          }
+          return o;
+        };
+      });
+      var gJ = ye((vJ, pJ) => {
+        (function(e, t) {
+          typeof vJ == "object" && typeof pJ != "undefined" ? pJ.exports = t() : (e = e || self, e.mapboxgl = t());
+        })(vJ, function() {
+          var e, t, r;
+          function n(i, a) {
+            if (!e) e = a;
+            else if (!t) t = a;
+            else {
+              var o = "var sharedChunk = {}; (" + e + ")(sharedChunk); (" + t + ")(sharedChunk);", s = {};
+              e(s), r = a(s), typeof window != "undefined" && (r.workerUrl = window.URL.createObjectURL(new Blob([o], { type: "text/javascript" })));
+            }
+          }
+          return n(["exports"], function(i) {
+            function a(m, y) {
+              return y = { exports: {} }, m(y, y.exports), y.exports;
+            }
+            var o = "1.13.4", s = l;
+            function l(m, y, I, V) {
+              this.cx = 3 * m, this.bx = 3 * (I - m) - this.cx, this.ax = 1 - this.cx - this.bx, this.cy = 3 * y, this.by = 3 * (V - y) - this.cy, this.ay = 1 - this.cy - this.by, this.p1x = m, this.p1y = V, this.p2x = I, this.p2y = V;
+            }
+            l.prototype.sampleCurveX = function(m) {
+              return ((this.ax * m + this.bx) * m + this.cx) * m;
+            }, l.prototype.sampleCurveY = function(m) {
+              return ((this.ay * m + this.by) * m + this.cy) * m;
+            }, l.prototype.sampleCurveDerivativeX = function(m) {
+              return (3 * this.ax * m + 2 * this.bx) * m + this.cx;
+            }, l.prototype.solveCurveX = function(m, y) {
+              typeof y == "undefined" && (y = 1e-6);
+              var I, V, $, ae, he;
+              for ($ = m, he = 0; he < 8; he++) {
+                if (ae = this.sampleCurveX($) - m, Math.abs(ae) < y) return $;
+                var ze = this.sampleCurveDerivativeX($);
+                if (Math.abs(ze) < 1e-6) break;
+                $ = $ - ae / ze;
+              }
+              if (I = 0, V = 1, $ = m, $ < I) return I;
+              if ($ > V) return V;
+              for (; I < V; ) {
+                if (ae = this.sampleCurveX($), Math.abs(ae - m) < y) return $;
+                m > ae ? I = $ : V = $, $ = (V - I) * 0.5 + I;
+              }
+              return $;
+            }, l.prototype.solve = function(m, y) {
+              return this.sampleCurveY(this.solveCurveX(m, y));
+            };
+            var u = c;
+            function c(m, y) {
+              this.x = m, this.y = y;
+            }
+            c.prototype = { clone: function() {
+              return new c(this.x, this.y);
+            }, add: function(m) {
+              return this.clone()._add(m);
+            }, sub: function(m) {
+              return this.clone()._sub(m);
+            }, multByPoint: function(m) {
+              return this.clone()._multByPoint(m);
+            }, divByPoint: function(m) {
+              return this.clone()._divByPoint(m);
+            }, mult: function(m) {
+              return this.clone()._mult(m);
+            }, div: function(m) {
+              return this.clone()._div(m);
+            }, rotate: function(m) {
+              return this.clone()._rotate(m);
+            }, rotateAround: function(m, y) {
+              return this.clone()._rotateAround(m, y);
+            }, matMult: function(m) {
+              return this.clone()._matMult(m);
+            }, unit: function() {
+              return this.clone()._unit();
+            }, perp: function() {
+              return this.clone()._perp();
+            }, round: function() {
+              return this.clone()._round();
+            }, mag: function() {
+              return Math.sqrt(this.x * this.x + this.y * this.y);
+            }, equals: function(m) {
+              return this.x === m.x && this.y === m.y;
+            }, dist: function(m) {
+              return Math.sqrt(this.distSqr(m));
+            }, distSqr: function(m) {
+              var y = m.x - this.x, I = m.y - this.y;
+              return y * y + I * I;
+            }, angle: function() {
+              return Math.atan2(this.y, this.x);
+            }, angleTo: function(m) {
+              return Math.atan2(this.y - m.y, this.x - m.x);
+            }, angleWith: function(m) {
+              return this.angleWithSep(m.x, m.y);
+            }, angleWithSep: function(m, y) {
+              return Math.atan2(this.x * y - this.y * m, this.x * m + this.y * y);
+            }, _matMult: function(m) {
+              var y = m[0] * this.x + m[1] * this.y, I = m[2] * this.x + m[3] * this.y;
+              return this.x = y, this.y = I, this;
+            }, _add: function(m) {
+              return this.x += m.x, this.y += m.y, this;
+            }, _sub: function(m) {
+              return this.x -= m.x, this.y -= m.y, this;
+            }, _mult: function(m) {
+              return this.x *= m, this.y *= m, this;
+            }, _div: function(m) {
+              return this.x /= m, this.y /= m, this;
+            }, _multByPoint: function(m) {
+              return this.x *= m.x, this.y *= m.y, this;
+            }, _divByPoint: function(m) {
+              return this.x /= m.x, this.y /= m.y, this;
+            }, _unit: function() {
+              return this._div(this.mag()), this;
+            }, _perp: function() {
+              var m = this.y;
+              return this.y = this.x, this.x = -m, this;
+            }, _rotate: function(m) {
+              var y = Math.cos(m), I = Math.sin(m), V = y * this.x - I * this.y, $ = I * this.x + y * this.y;
+              return this.x = V, this.y = $, this;
+            }, _rotateAround: function(m, y) {
+              var I = Math.cos(m), V = Math.sin(m), $ = y.x + I * (this.x - y.x) - V * (this.y - y.y), ae = y.y + V * (this.x - y.x) + I * (this.y - y.y);
+              return this.x = $, this.y = ae, this;
+            }, _round: function() {
+              return this.x = Math.round(this.x), this.y = Math.round(this.y), this;
+            } }, c.convert = function(m) {
+              return m instanceof c ? m : Array.isArray(m) ? new c(m[0], m[1]) : m;
+            };
+            var f = typeof self != "undefined" ? self : {};
+            function h(m, y) {
+              if (Array.isArray(m)) {
+                if (!Array.isArray(y) || m.length !== y.length) return false;
+                for (var I = 0; I < m.length; I++) if (!h(m[I], y[I])) return false;
+                return true;
+              }
+              if (typeof m == "object" && m !== null && y !== null) {
+                if (typeof y != "object") return false;
+                var V = Object.keys(m);
+                if (V.length !== Object.keys(y).length) return false;
+                for (var $ in m) if (!h(m[$], y[$])) return false;
+                return true;
+              }
+              return m === y;
+            }
+            var d = Math.pow(2, 53) - 1;
+            function v(m) {
+              if (m <= 0) return 0;
+              if (m >= 1) return 1;
+              var y = m * m, I = y * m;
+              return 4 * (m < 0.5 ? I : 3 * (m - y) + I - 0.75);
+            }
+            function _(m, y, I, V) {
+              var $ = new s(m, y, I, V);
+              return function(ae) {
+                return $.solve(ae);
+              };
+            }
+            var b = _(0.25, 0.1, 0.25, 1);
+            function p(m, y, I) {
+              return Math.min(I, Math.max(y, m));
+            }
+            function k(m, y, I) {
+              var V = I - y, $ = ((m - y) % V + V) % V + y;
+              return $ === y ? I : $;
+            }
+            function E(m, y, I) {
+              if (!m.length) return I(null, []);
+              var V = m.length, $ = new Array(m.length), ae = null;
+              m.forEach(function(he, ze) {
+                y(he, function(rt, gt) {
+                  rt && (ae = rt), $[ze] = gt, --V === 0 && I(ae, $);
+                });
+              });
+            }
+            function T(m) {
+              var y = [];
+              for (var I in m) y.push(m[I]);
+              return y;
+            }
+            function L(m, y) {
+              var I = [];
+              for (var V in m) V in y || I.push(V);
+              return I;
+            }
+            function x(m) {
+              for (var y = [], I = arguments.length - 1; I-- > 0; ) y[I] = arguments[I + 1];
+              for (var V = 0, $ = y; V < $.length; V += 1) {
+                var ae = $[V];
+                for (var he in ae) m[he] = ae[he];
+              }
+              return m;
+            }
+            function C(m, y) {
+              for (var I = {}, V = 0; V < y.length; V++) {
+                var $ = y[V];
+                $ in m && (I[$] = m[$]);
+              }
+              return I;
+            }
+            var M = 1;
+            function g() {
+              return M++;
+            }
+            function P() {
+              function m(y) {
+                return y ? (y ^ Math.random() * 16 >> y / 4).toString(16) : ([1e7] + -[1e3] + -4e3 + -8e3 + -1e11).replace(/[018]/g, m);
+              }
+              return m();
+            }
+            function A(m) {
+              return m <= 1 ? 1 : Math.pow(2, Math.ceil(Math.log(m) / Math.LN2));
+            }
+            function z(m) {
+              return m ? /^[0-9a-f]{8}-[0-9a-f]{4}-[4][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i.test(m) : false;
+            }
+            function O(m, y) {
+              m.forEach(function(I) {
+                y[I] && (y[I] = y[I].bind(y));
+              });
+            }
+            function U(m, y) {
+              return m.indexOf(y, m.length - y.length) !== -1;
+            }
+            function G(m, y, I) {
+              var V = {};
+              for (var $ in m) V[$] = y.call(I || this, m[$], $, m);
+              return V;
+            }
+            function Z(m, y, I) {
+              var V = {};
+              for (var $ in m) y.call(I || this, m[$], $, m) && (V[$] = m[$]);
+              return V;
+            }
+            function j(m) {
+              return Array.isArray(m) ? m.map(j) : typeof m == "object" && m ? G(m, j) : m;
+            }
+            function N(m, y) {
+              for (var I = 0; I < m.length; I++) if (y.indexOf(m[I]) >= 0) return true;
+              return false;
+            }
+            var H = {};
+            function re(m) {
+              H[m] || (typeof console != "undefined" && console.warn(m), H[m] = true);
+            }
+            function oe(m, y, I) {
+              return (I.y - m.y) * (y.x - m.x) > (y.y - m.y) * (I.x - m.x);
+            }
+            function _e(m) {
+              for (var y = 0, I = 0, V = m.length, $ = V - 1, ae = void 0, he = void 0; I < V; $ = I++) ae = m[I], he = m[$], y += (he.x - ae.x) * (ae.y + he.y);
+              return y;
+            }
+            function Ce(m) {
+              var y = m[0], I = m[1], V = m[2];
+              return I += 90, I *= Math.PI / 180, V *= Math.PI / 180, { x: y * Math.cos(I) * Math.sin(V), y: y * Math.sin(I) * Math.sin(V), z: y * Math.cos(V) };
+            }
+            function Le() {
+              return typeof WorkerGlobalScope != "undefined" && typeof self != "undefined" && self instanceof WorkerGlobalScope;
+            }
+            function ge(m) {
+              var y = /(?:^|(?:\s*\,\s*))([^\x00-\x20\(\)<>@\,;\:\\"\/\[\]\?\=\{\}\x7F]+)(?:\=(?:([^\x00-\x20\(\)<>@\,;\:\\"\/\[\]\?\=\{\}\x7F]+)|(?:\"((?:[^"\\]|\\.)*)\")))?/g, I = {};
+              if (m.replace(y, function($, ae, he, ze) {
+                var rt = he || ze;
+                return I[ae] = rt ? rt.toLowerCase() : true, "";
+              }), I["max-age"]) {
+                var V = parseInt(I["max-age"], 10);
+                isNaN(V) ? delete I["max-age"] : I["max-age"] = V;
+              }
+              return I;
+            }
+            var ie = null;
+            function Se(m) {
+              if (ie == null) {
+                var y = m.navigator ? m.navigator.userAgent : null;
+                ie = !!m.safari || !!(y && (/\b(iPad|iPhone|iPod)\b/.test(y) || y.match("Safari") && !y.match("Chrome")));
+              }
+              return ie;
+            }
+            function Ee(m) {
+              try {
+                var y = f[m];
+                return y.setItem("_mapbox_test_", 1), y.removeItem("_mapbox_test_"), true;
+              } catch (I) {
+                return false;
+              }
+            }
+            function Ae(m) {
+              return f.btoa(encodeURIComponent(m).replace(/%([0-9A-F]{2})/g, function(y, I) {
+                return String.fromCharCode(+("0x" + I));
+              }));
+            }
+            function Be(m) {
+              return decodeURIComponent(f.atob(m).split("").map(function(y) {
+                return "%" + ("00" + y.charCodeAt(0).toString(16)).slice(-2);
+              }).join(""));
+            }
+            var Pe = f.performance && f.performance.now ? f.performance.now.bind(f.performance) : Date.now.bind(Date), me = f.requestAnimationFrame || f.mozRequestAnimationFrame || f.webkitRequestAnimationFrame || f.msRequestAnimationFrame, De = f.cancelAnimationFrame || f.mozCancelAnimationFrame || f.webkitCancelAnimationFrame || f.msCancelAnimationFrame, ce, je, lt = { now: Pe, frame: function(y) {
+              var I = me(y);
+              return { cancel: function() {
+                return De(I);
+              } };
+            }, getImageData: function(y, I) {
+              I === void 0 && (I = 0);
+              var V = f.document.createElement("canvas"), $ = V.getContext("2d");
+              if (!$) throw new Error("failed to create canvas 2d context");
+              return V.width = y.width, V.height = y.height, $.drawImage(y, 0, 0, y.width, y.height), $.getImageData(-I, -I, y.width + 2 * I, y.height + 2 * I);
+            }, resolveURL: function(y) {
+              return ce || (ce = f.document.createElement("a")), ce.href = y, ce.href;
+            }, hardwareConcurrency: f.navigator && f.navigator.hardwareConcurrency || 4, get devicePixelRatio() {
+              return f.devicePixelRatio;
+            }, get prefersReducedMotion() {
+              return f.matchMedia ? (je == null && (je = f.matchMedia("(prefers-reduced-motion: reduce)")), je.matches) : false;
+            } }, pt = { API_URL: "https://api.mapbox.com", get EVENTS_URL() {
+              return this.API_URL ? this.API_URL.indexOf("https://api.mapbox.cn") === 0 ? "https://events.mapbox.cn/events/v2" : this.API_URL.indexOf("https://api.mapbox.com") === 0 ? "https://events.mapbox.com/events/v2" : null : null;
+            }, FEEDBACK_URL: "https://apps.mapbox.com/feedback", REQUIRE_ACCESS_TOKEN: true, ACCESS_TOKEN: null, MAX_PARALLEL_IMAGE_REQUESTS: 16 }, Vt = { supported: false, testSupport: $t }, ot, ut = false, Wt, Nt = false;
+            f.document && (Wt = f.document.createElement("img"), Wt.onload = function() {
+              ot && sr(ot), ot = null, Nt = true;
+            }, Wt.onerror = function() {
+              ut = true, ot = null;
+            }, Wt.src = "data:image/webp;base64,UklGRh4AAABXRUJQVlA4TBEAAAAvAQAAAAfQ//73v/+BiOh/AAA=");
+            function $t(m) {
+              ut || !Wt || (Nt ? sr(m) : ot = m);
+            }
+            function sr(m) {
+              var y = m.createTexture();
+              m.bindTexture(m.TEXTURE_2D, y);
+              try {
+                if (m.texImage2D(m.TEXTURE_2D, 0, m.RGBA, m.RGBA, m.UNSIGNED_BYTE, Wt), m.isContextLost()) return;
+                Vt.supported = true;
+              } catch (I) {
+              }
+              m.deleteTexture(y), ut = true;
+            }
+            var Tr = "01";
+            function fr() {
+              for (var m = "1", y = "0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ", I = "", V = 0; V < 10; V++) I += y[Math.floor(Math.random() * 62)];
+              var $ = 12 * 60 * 60 * 1e3, ae = [m, Tr, I].join(""), he = Date.now() + $;
+              return { token: ae, tokenExpiresAt: he };
+            }
+            var $e = function(y, I) {
+              this._transformRequestFn = y, this._customAccessToken = I, this._createSkuToken();
+            };
+            $e.prototype._createSkuToken = function() {
+              var y = fr();
+              this._skuToken = y.token, this._skuTokenExpiresAt = y.tokenExpiresAt;
+            }, $e.prototype._isSkuTokenExpired = function() {
+              return Date.now() > this._skuTokenExpiresAt;
+            }, $e.prototype.transformRequest = function(y, I) {
+              return this._transformRequestFn ? this._transformRequestFn(y, I) || { url: y } : { url: y };
+            }, $e.prototype.normalizeStyleURL = function(y, I) {
+              if (!St(y)) return y;
+              var V = er(y);
+              return V.path = "/styles/v1" + V.path, this._makeAPIURL(V, this._customAccessToken || I);
+            }, $e.prototype.normalizeGlyphsURL = function(y, I) {
+              if (!St(y)) return y;
+              var V = er(y);
+              return V.path = "/fonts/v1" + V.path, this._makeAPIURL(V, this._customAccessToken || I);
+            }, $e.prototype.normalizeSourceURL = function(y, I) {
+              if (!St(y)) return y;
+              var V = er(y);
+              return V.path = "/v4/" + V.authority + ".json", V.params.push("secure"), this._makeAPIURL(V, this._customAccessToken || I);
+            }, $e.prototype.normalizeSpriteURL = function(y, I, V, $) {
+              var ae = er(y);
+              return St(y) ? (ae.path = "/styles/v1" + ae.path + "/sprite" + I + V, this._makeAPIURL(ae, this._customAccessToken || $)) : (ae.path += "" + I + V, lr(ae));
+            }, $e.prototype.normalizeTileURL = function(y, I) {
+              if (this._isSkuTokenExpired() && this._createSkuToken(), y && !St(y)) return y;
+              var V = er(y), $ = /(\.(png|jpg)\d*)(?=$)/, ae = /^.+\/v4\//, he = lt.devicePixelRatio >= 2 || I === 512 ? "@2x" : "", ze = Vt.supported ? ".webp" : "$1";
+              V.path = V.path.replace($, "" + he + ze), V.path = V.path.replace(ae, "/"), V.path = "/v4" + V.path;
+              var rt = this._customAccessToken || It(V.params) || pt.ACCESS_TOKEN;
+              return pt.REQUIRE_ACCESS_TOKEN && rt && this._skuToken && V.params.push("sku=" + this._skuToken), this._makeAPIURL(V, rt);
+            }, $e.prototype.canonicalizeTileURL = function(y, I) {
+              var V = "/v4/", $ = /\.[\w]+$/, ae = er(y);
+              if (!ae.path.match(/(^\/v4\/)/) || !ae.path.match($)) return y;
+              var he = "mapbox://tiles/";
+              he += ae.path.replace(V, "");
+              var ze = ae.params;
+              return I && (ze = ze.filter(function(rt) {
+                return !rt.match(/^access_token=/);
+              })), ze.length && (he += "?" + ze.join("&")), he;
+            }, $e.prototype.canonicalizeTileset = function(y, I) {
+              for (var V = I ? St(I) : false, $ = [], ae = 0, he = y.tiles || []; ae < he.length; ae += 1) {
+                var ze = he[ae];
+                Gt(ze) ? $.push(this.canonicalizeTileURL(ze, V)) : $.push(ze);
+              }
+              return $;
+            }, $e.prototype._makeAPIURL = function(y, I) {
+              var V = "See https://www.mapbox.com/api-documentation/#access-tokens-and-token-scopes", $ = er(pt.API_URL);
+              if (y.protocol = $.protocol, y.authority = $.authority, y.protocol === "http") {
+                var ae = y.params.indexOf("secure");
+                ae >= 0 && y.params.splice(ae, 1);
+              }
+              if ($.path !== "/" && (y.path = "" + $.path + y.path), !pt.REQUIRE_ACCESS_TOKEN) return lr(y);
+              if (I = I || pt.ACCESS_TOKEN, !I) throw new Error("An API access token is required to use Mapbox GL. " + V);
+              if (I[0] === "s") throw new Error("Use a public access token (pk.*) with Mapbox GL, not a secret access token (sk.*). " + V);
+              return y.params = y.params.filter(function(he) {
+                return he.indexOf("access_token") === -1;
+              }), y.params.push("access_token=" + I), lr(y);
+            };
+            function St(m) {
+              return m.indexOf("mapbox:") === 0;
+            }
+            var Qt = /^((https?:)?\/\/)?([^\/]+\.)?mapbox\.c(n|om)(\/|\?|$)/i;
+            function Gt(m) {
+              return Qt.test(m);
+            }
+            function _t(m) {
+              return m.indexOf("sku=") > 0 && Gt(m);
+            }
+            function It(m) {
+              for (var y = 0, I = m; y < I.length; y += 1) {
+                var V = I[y], $ = V.match(/^access_token=(.*)$/);
+                if ($) return $[1];
+              }
+              return null;
+            }
+            var mt = /^(\w+):\/\/([^/?]*)(\/[^?]+)?\??(.+)?/;
+            function er(m) {
+              var y = m.match(mt);
+              if (!y) throw new Error("Unable to parse URL object");
+              return { protocol: y[1], authority: y[2], path: y[3] || "/", params: y[4] ? y[4].split("&") : [] };
+            }
+            function lr(m) {
+              var y = m.params.length ? "?" + m.params.join("&") : "";
+              return m.protocol + "://" + m.authority + m.path + y;
+            }
+            var wr = "mapbox.eventData";
+            function Lr(m) {
+              if (!m) return null;
+              var y = m.split(".");
+              if (!y || y.length !== 3) return null;
+              try {
+                var I = JSON.parse(Be(y[1]));
+                return I;
+              } catch (V) {
+                return null;
+              }
+            }
+            var ti = function(y) {
+              this.type = y, this.anonId = null, this.eventData = {}, this.queue = [], this.pendingRequest = null;
+            };
+            ti.prototype.getStorageKey = function(y) {
+              var I = Lr(pt.ACCESS_TOKEN), V = "";
+              return I && I.u ? V = Ae(I.u) : V = pt.ACCESS_TOKEN || "", y ? wr + "." + y + ":" + V : wr + ":" + V;
+            }, ti.prototype.fetchEventData = function() {
+              var y = Ee("localStorage"), I = this.getStorageKey(), V = this.getStorageKey("uuid");
+              if (y) try {
+                var $ = f.localStorage.getItem(I);
+                $ && (this.eventData = JSON.parse($));
+                var ae = f.localStorage.getItem(V);
+                ae && (this.anonId = ae);
+              } catch (he) {
+                re("Unable to read from LocalStorage");
+              }
+            }, ti.prototype.saveEventData = function() {
+              var y = Ee("localStorage"), I = this.getStorageKey(), V = this.getStorageKey("uuid");
+              if (y) try {
+                f.localStorage.setItem(V, this.anonId), Object.keys(this.eventData).length >= 1 && f.localStorage.setItem(I, JSON.stringify(this.eventData));
+              } catch ($) {
+                re("Unable to write to LocalStorage");
+              }
+            }, ti.prototype.processRequests = function(y) {
+            }, ti.prototype.postEvent = function(y, I, V, $) {
+              var ae = this;
+              if (pt.EVENTS_URL) {
+                var he = er(pt.EVENTS_URL);
+                he.params.push("access_token=" + ($ || pt.ACCESS_TOKEN || ""));
+                var ze = { event: this.type, created: new Date(y).toISOString(), sdkIdentifier: "mapbox-gl-js", sdkVersion: o, skuId: Tr, userId: this.anonId }, rt = I ? x(ze, I) : ze, gt = { url: lr(he), headers: { "Content-Type": "text/plain" }, body: JSON.stringify([rt]) };
+                this.pendingRequest = Qr(gt, function(Et) {
+                  ae.pendingRequest = null, V(Et), ae.saveEventData(), ae.processRequests($);
+                });
+              }
+            }, ti.prototype.queueRequest = function(y, I) {
+              this.queue.push(y), this.processRequests(I);
+            };
+            var Br = function(m) {
+              function y() {
+                m.call(this, "map.load"), this.success = {}, this.skuToken = "";
+              }
+              return m && (y.__proto__ = m), y.prototype = Object.create(m && m.prototype), y.prototype.constructor = y, y.prototype.postMapLoadEvent = function(V, $, ae, he) {
+                this.skuToken = ae, (pt.EVENTS_URL && he || pt.ACCESS_TOKEN && Array.isArray(V) && V.some(function(ze) {
+                  return St(ze) || Gt(ze);
+                })) && this.queueRequest({ id: $, timestamp: Date.now() }, he);
+              }, y.prototype.processRequests = function(V) {
+                var $ = this;
+                if (!(this.pendingRequest || this.queue.length === 0)) {
+                  var ae = this.queue.shift(), he = ae.id, ze = ae.timestamp;
+                  he && this.success[he] || (this.anonId || this.fetchEventData(), z(this.anonId) || (this.anonId = P()), this.postEvent(ze, { skuToken: this.skuToken }, function(rt) {
+                    rt || he && ($.success[he] = true);
+                  }, V));
+                }
+              }, y;
+            }(ti), Vr = function(m) {
+              function y(I) {
+                m.call(this, "appUserTurnstile"), this._customAccessToken = I;
+              }
+              return m && (y.__proto__ = m), y.prototype = Object.create(m && m.prototype), y.prototype.constructor = y, y.prototype.postTurnstileEvent = function(V, $) {
+                pt.EVENTS_URL && pt.ACCESS_TOKEN && Array.isArray(V) && V.some(function(ae) {
+                  return St(ae) || Gt(ae);
+                }) && this.queueRequest(Date.now(), $);
+              }, y.prototype.processRequests = function(V) {
+                var $ = this;
+                if (!(this.pendingRequest || this.queue.length === 0)) {
+                  (!this.anonId || !this.eventData.lastSuccess || !this.eventData.tokenU) && this.fetchEventData();
+                  var ae = Lr(pt.ACCESS_TOKEN), he = ae ? ae.u : pt.ACCESS_TOKEN, ze = he !== this.eventData.tokenU;
+                  z(this.anonId) || (this.anonId = P(), ze = true);
+                  var rt = this.queue.shift();
+                  if (this.eventData.lastSuccess) {
+                    var gt = new Date(this.eventData.lastSuccess), Et = new Date(rt), or = (rt - this.eventData.lastSuccess) / (24 * 60 * 60 * 1e3);
+                    ze = ze || or >= 1 || or < -1 || gt.getDate() !== Et.getDate();
+                  } else ze = true;
+                  if (!ze) return this.processRequests();
+                  this.postEvent(rt, { "enabled.telemetry": false }, function(_r) {
+                    _r || ($.eventData.lastSuccess = rt, $.eventData.tokenU = he);
+                  }, V);
+                }
+              }, y;
+            }(ti), dt = new Vr(), Ge = dt.postTurnstileEvent.bind(dt), Je = new Br(), We = Je.postMapLoadEvent.bind(Je), tt = "mapbox-tiles", xt = 500, Ie = 50, xe = 1e3 * 60 * 7, ke;
+            function vt() {
+              f.caches && !ke && (ke = f.caches.open(tt));
+            }
+            var ir;
+            function ar(m, y) {
+              if (ir === void 0) try {
+                new Response(new ReadableStream()), ir = true;
+              } catch (I) {
+                ir = false;
+              }
+              ir ? y(m.body) : m.blob().then(y);
+            }
+            function vr(m, y, I) {
+              if (vt(), !!ke) {
+                var V = { status: y.status, statusText: y.statusText, headers: new f.Headers() };
+                y.headers.forEach(function(he, ze) {
+                  return V.headers.set(ze, he);
+                });
+                var $ = ge(y.headers.get("Cache-Control") || "");
+                if (!$["no-store"]) {
+                  $["max-age"] && V.headers.set("Expires", new Date(I + $["max-age"] * 1e3).toUTCString());
+                  var ae = new Date(V.headers.get("Expires")).getTime() - I;
+                  ae < xe || ar(y, function(he) {
+                    var ze = new f.Response(he, V);
+                    vt(), ke && ke.then(function(rt) {
+                      return rt.put(ii(m.url), ze);
+                    }).catch(function(rt) {
+                      return re(rt.message);
+                    });
+                  });
+                }
+              }
+            }
+            function ii(m) {
+              var y = m.indexOf("?");
+              return y < 0 ? m : m.slice(0, y);
+            }
+            function pi(m, y) {
+              if (vt(), !ke) return y(null);
+              var I = ii(m.url);
+              ke.then(function(V) {
+                V.match(I).then(function($) {
+                  var ae = $r($);
+                  V.delete(I), ae && V.put(I, $.clone()), y(null, $, ae);
+                }).catch(y);
+              }).catch(y);
+            }
+            function $r(m) {
+              if (!m) return false;
+              var y = new Date(m.headers.get("Expires") || 0), I = ge(m.headers.get("Cache-Control") || "");
+              return y > Date.now() && !I["no-cache"];
+            }
+            var di = 1 / 0;
+            function ji(m) {
+              di++, di > Ie && (m.getActor().send("enforceCacheSizeLimit", xt), di = 0);
+            }
+            function In(m) {
+              vt(), ke && ke.then(function(y) {
+                y.keys().then(function(I) {
+                  for (var V = 0; V < I.length - m; V++) y.delete(I[V]);
+                });
+              });
+            }
+            function wi(m) {
+              var y = f.caches.delete(tt);
+              m && y.catch(m).then(function() {
+                return m();
+              });
+            }
+            function On(m, y) {
+              xt = m, Ie = y;
+            }
+            var qn;
+            function Fn() {
+              return qn == null && (qn = f.OffscreenCanvas && new f.OffscreenCanvas(1, 1).getContext("2d") && typeof f.createImageBitmap == "function"), qn;
+            }
+            var ra = { Unknown: "Unknown", Style: "Style", Source: "Source", Tile: "Tile", Glyphs: "Glyphs", SpriteImage: "SpriteImage", SpriteJSON: "SpriteJSON", Image: "Image" };
+            typeof Object.freeze == "function" && Object.freeze(ra);
+            var la = function(m) {
+              function y(I, V, $) {
+                V === 401 && Gt($) && (I += ": you may have provided an invalid Mapbox access token. See https://www.mapbox.com/api-documentation/#access-tokens-and-token-scopes"), m.call(this, I), this.status = V, this.url = $, this.name = this.constructor.name, this.message = I;
+              }
+              return m && (y.__proto__ = m), y.prototype = Object.create(m && m.prototype), y.prototype.constructor = y, y.prototype.toString = function() {
+                return this.name + ": " + this.message + " (" + this.status + "): " + this.url;
+              }, y;
+            }(Error), Ut = Le() ? function() {
+              return self.worker && self.worker.referrer;
+            } : function() {
+              return (f.location.protocol === "blob:" ? f.parent : f).location.href;
+            }, wt = function(m) {
+              return /^file:/.test(m) || /^file:/.test(Ut()) && !/^\w+:/.test(m);
+            };
+            function rr(m, y) {
+              var I = new f.AbortController(), V = new f.Request(m.url, { method: m.method || "GET", body: m.body, credentials: m.credentials, headers: m.headers, referrer: Ut(), signal: I.signal }), $ = false, ae = false, he = _t(V.url);
+              m.type === "json" && V.headers.set("Accept", "application/json");
+              var ze = function(gt, Et, or) {
+                if (!ae) {
+                  if (gt && gt.message !== "SecurityError" && re(gt), Et && or) return rt(Et);
+                  var _r = Date.now();
+                  f.fetch(V).then(function(pr) {
+                    if (pr.ok) {
+                      var Fr = he ? pr.clone() : null;
+                      return rt(pr, Fr, _r);
+                    } else return y(new la(pr.statusText, pr.status, m.url));
+                  }).catch(function(pr) {
+                    pr.code !== 20 && y(new Error(pr.message));
+                  });
+                }
+              }, rt = function(gt, Et, or) {
+                (m.type === "arrayBuffer" ? gt.arrayBuffer() : m.type === "json" ? gt.json() : gt.text()).then(function(_r) {
+                  ae || (Et && or && vr(V, Et, or), $ = true, y(null, _r, gt.headers.get("Cache-Control"), gt.headers.get("Expires")));
+                }).catch(function(_r) {
+                  ae || y(new Error(_r.message));
+                });
+              };
+              return he ? pi(V, ze) : ze(null, null), { cancel: function() {
+                ae = true, $ || I.abort();
+              } };
+            }
+            function nr(m, y) {
+              var I = new f.XMLHttpRequest();
+              I.open(m.method || "GET", m.url, true), m.type === "arrayBuffer" && (I.responseType = "arraybuffer");
+              for (var V in m.headers) I.setRequestHeader(V, m.headers[V]);
+              return m.type === "json" && (I.responseType = "text", I.setRequestHeader("Accept", "application/json")), I.withCredentials = m.credentials === "include", I.onerror = function() {
+                y(new Error(I.statusText));
+              }, I.onload = function() {
+                if ((I.status >= 200 && I.status < 300 || I.status === 0) && I.response !== null) {
+                  var $ = I.response;
+                  if (m.type === "json") try {
+                    $ = JSON.parse(I.response);
+                  } catch (ae) {
+                    return y(ae);
+                  }
+                  y(null, $, I.getResponseHeader("Cache-Control"), I.getResponseHeader("Expires"));
+                } else y(new la(I.statusText, I.status, m.url));
+              }, I.send(m.body), { cancel: function() {
+                return I.abort();
+              } };
+            }
+            var Er = function(m, y) {
+              if (!wt(m.url)) {
+                if (f.fetch && f.Request && f.AbortController && f.Request.prototype.hasOwnProperty("signal")) return rr(m, y);
+                if (Le() && self.worker && self.worker.actor) {
+                  var I = true;
+                  return self.worker.actor.send("getResource", m, y, void 0, I);
+                }
+              }
+              return nr(m, y);
+            }, Xr = function(m, y) {
+              return Er(x(m, { type: "json" }), y);
+            }, ri = function(m, y) {
+              return Er(x(m, { type: "arrayBuffer" }), y);
+            }, Qr = function(m, y) {
+              return Er(x(m, { method: "POST" }), y);
+            };
+            function Oi(m) {
+              var y = f.document.createElement("a");
+              return y.href = m, y.protocol === f.document.location.protocol && y.host === f.document.location.host;
+            }
+            var $i = "data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAYAAAAfFcSJAAAAC0lEQVQYV2NgAAIAAAUAAarVyFEAAAAASUVORK5CYII=";
+            function tn(m, y, I, V) {
+              var $ = new f.Image(), ae = f.URL;
+              $.onload = function() {
+                y(null, $), ae.revokeObjectURL($.src), $.onload = null, f.requestAnimationFrame(function() {
+                  $.src = $i;
+                });
+              }, $.onerror = function() {
+                return y(new Error("Could not load image. Please make sure to use a supported image type such as PNG or JPEG. Note that SVGs are not supported."));
+              };
+              var he = new f.Blob([new Uint8Array(m)], { type: "image/png" });
+              $.cacheControl = I, $.expires = V, $.src = m.byteLength ? ae.createObjectURL(he) : $i;
+            }
+            function fn(m, y) {
+              var I = new f.Blob([new Uint8Array(m)], { type: "image/png" });
+              f.createImageBitmap(I).then(function(V) {
+                y(null, V);
+              }).catch(function(V) {
+                y(new Error("Could not load image because of " + V.message + ". Please make sure to use a supported image type such as PNG or JPEG. Note that SVGs are not supported."));
+              });
+            }
+            var yn, Sn, Ba = function() {
+              yn = [], Sn = 0;
+            };
+            Ba();
+            var ua = function(m, y) {
+              if (Vt.supported && (m.headers || (m.headers = {}), m.headers.accept = "image/webp,*/*"), Sn >= pt.MAX_PARALLEL_IMAGE_REQUESTS) {
+                var I = { requestParameters: m, callback: y, cancelled: false, cancel: function() {
+                  this.cancelled = true;
+                } };
+                return yn.push(I), I;
+              }
+              Sn++;
+              var V = false, $ = function() {
+                if (!V) for (V = true, Sn--; yn.length && Sn < pt.MAX_PARALLEL_IMAGE_REQUESTS; ) {
+                  var he = yn.shift(), ze = he.requestParameters, rt = he.callback, gt = he.cancelled;
+                  gt || (he.cancel = ua(ze, rt).cancel);
+                }
+              }, ae = ri(m, function(he, ze, rt, gt) {
+                $(), he ? y(he) : ze && (Fn() ? fn(ze, y) : tn(ze, y, rt, gt));
+              });
+              return { cancel: function() {
+                ae.cancel(), $();
+              } };
+            }, ma = function(m, y) {
+              var I = f.document.createElement("video");
+              I.muted = true, I.onloadstart = function() {
+                y(null, I);
+              };
+              for (var V = 0; V < m.length; V++) {
+                var $ = f.document.createElement("source");
+                Oi(m[V]) || (I.crossOrigin = "Anonymous"), $.src = m[V], I.appendChild($);
+              }
+              return { cancel: function() {
+              } };
+            };
+            function Wa(m, y, I) {
+              var V = I[m] && I[m].indexOf(y) !== -1;
+              V || (I[m] = I[m] || [], I[m].push(y));
+            }
+            function Fa(m, y, I) {
+              if (I && I[m]) {
+                var V = I[m].indexOf(y);
+                V !== -1 && I[m].splice(V, 1);
+              }
+            }
+            var Xo = function(y, I) {
+              I === void 0 && (I = {}), x(this, I), this.type = y;
+            }, da = function(m) {
+              function y(I, V) {
+                V === void 0 && (V = {}), m.call(this, "error", x({ error: I }, V));
+              }
+              return m && (y.__proto__ = m), y.prototype = Object.create(m && m.prototype), y.prototype.constructor = y, y;
+            }(Xo), Wn = function() {
+            };
+            Wn.prototype.on = function(y, I) {
+              return this._listeners = this._listeners || {}, Wa(y, I, this._listeners), this;
+            }, Wn.prototype.off = function(y, I) {
+              return Fa(y, I, this._listeners), Fa(y, I, this._oneTimeListeners), this;
+            }, Wn.prototype.once = function(y, I) {
+              return this._oneTimeListeners = this._oneTimeListeners || {}, Wa(y, I, this._oneTimeListeners), this;
+            }, Wn.prototype.fire = function(y, I) {
+              typeof y == "string" && (y = new Xo(y, I || {}));
+              var V = y.type;
+              if (this.listens(V)) {
+                y.target = this;
+                for (var $ = this._listeners && this._listeners[V] ? this._listeners[V].slice() : [], ae = 0, he = $; ae < he.length; ae += 1) {
+                  var ze = he[ae];
+                  ze.call(this, y);
+                }
+                for (var rt = this._oneTimeListeners && this._oneTimeListeners[V] ? this._oneTimeListeners[V].slice() : [], gt = 0, Et = rt; gt < Et.length; gt += 1) {
+                  var or = Et[gt];
+                  Fa(V, or, this._oneTimeListeners), or.call(this, y);
+                }
+                var _r = this._eventedParent;
+                _r && (x(y, typeof this._eventedParentData == "function" ? this._eventedParentData() : this._eventedParentData), _r.fire(y));
+              } else y instanceof da && console.error(y.error);
+              return this;
+            }, Wn.prototype.listens = function(y) {
+              return this._listeners && this._listeners[y] && this._listeners[y].length > 0 || this._oneTimeListeners && this._oneTimeListeners[y] && this._oneTimeListeners[y].length > 0 || this._eventedParent && this._eventedParent.listens(y);
+            }, Wn.prototype.setEventedParent = function(y, I) {
+              return this._eventedParent = y, this._eventedParentData = I, this;
+            };
+            var Ha = 8, vo = { version: { required: true, type: "enum", values: [8] }, name: { type: "string" }, metadata: { type: "*" }, center: { type: "array", value: "number" }, zoom: { type: "number" }, bearing: { type: "number", default: 0, period: 360, units: "degrees" }, pitch: { type: "number", default: 0, units: "degrees" }, light: { type: "light" }, sources: { required: true, type: "sources" }, sprite: { type: "string" }, glyphs: { type: "string" }, transition: { type: "transition" }, layers: { required: true, type: "array", value: "layer" } }, jn = { "*": { type: "source" } }, Mt = ["source_vector", "source_raster", "source_raster_dem", "source_geojson", "source_video", "source_image"], kr = { type: { required: true, type: "enum", values: { vector: {} } }, url: { type: "string" }, tiles: { type: "array", value: "string" }, bounds: { type: "array", value: "number", length: 4, default: [-180, -85.051129, 180, 85.051129] }, scheme: { type: "enum", values: { xyz: {}, tms: {} }, default: "xyz" }, minzoom: { type: "number", default: 0 }, maxzoom: { type: "number", default: 22 }, attribution: { type: "string" }, promoteId: { type: "promoteId" }, volatile: { type: "boolean", default: false }, "*": { type: "*" } }, Jr = { type: { required: true, type: "enum", values: { raster: {} } }, url: { type: "string" }, tiles: { type: "array", value: "string" }, bounds: { type: "array", value: "number", length: 4, default: [-180, -85.051129, 180, 85.051129] }, minzoom: { type: "number", default: 0 }, maxzoom: { type: "number", default: 22 }, tileSize: { type: "number", default: 512, units: "pixels" }, scheme: { type: "enum", values: { xyz: {}, tms: {} }, default: "xyz" }, attribution: { type: "string" }, volatile: { type: "boolean", default: false }, "*": { type: "*" } }, vi = { type: { required: true, type: "enum", values: { "raster-dem": {} } }, url: { type: "string" }, tiles: { type: "array", value: "string" }, bounds: { type: "array", value: "number", length: 4, default: [-180, -85.051129, 180, 85.051129] }, minzoom: { type: "number", default: 0 }, maxzoom: { type: "number", default: 22 }, tileSize: { type: "number", default: 512, units: "pixels" }, attribution: { type: "string" }, encoding: { type: "enum", values: { terrarium: {}, mapbox: {} }, default: "mapbox" }, volatile: { type: "boolean", default: false }, "*": { type: "*" } }, hn = { type: { required: true, type: "enum", values: { geojson: {} } }, data: { type: "*" }, maxzoom: { type: "number", default: 18 }, attribution: { type: "string" }, buffer: { type: "number", default: 128, maximum: 512, minimum: 0 }, filter: { type: "*" }, tolerance: { type: "number", default: 0.375 }, cluster: { type: "boolean", default: false }, clusterRadius: { type: "number", default: 50, minimum: 0 }, clusterMaxZoom: { type: "number" }, clusterMinPoints: { type: "number" }, clusterProperties: { type: "*" }, lineMetrics: { type: "boolean", default: false }, generateId: { type: "boolean", default: false }, promoteId: { type: "promoteId" } }, An = { type: { required: true, type: "enum", values: { video: {} } }, urls: { required: true, type: "array", value: "string" }, coordinates: { required: true, type: "array", length: 4, value: { type: "array", length: 2, value: "number" } } }, Mn = { type: { required: true, type: "enum", values: { image: {} } }, url: { required: true, type: "string" }, coordinates: { required: true, type: "array", length: 4, value: { type: "array", length: 2, value: "number" } } }, Li = { id: { type: "string", required: true }, type: { type: "enum", values: { fill: {}, line: {}, symbol: {}, circle: {}, heatmap: {}, "fill-extrusion": {}, raster: {}, hillshade: {}, background: {} }, required: true }, metadata: { type: "*" }, source: { type: "string" }, "source-layer": { type: "string" }, minzoom: { type: "number", minimum: 0, maximum: 24 }, maxzoom: { type: "number", minimum: 0, maximum: 24 }, filter: { type: "filter" }, layout: { type: "layout" }, paint: { type: "paint" } }, _n = ["layout_fill", "layout_line", "layout_circle", "layout_heatmap", "layout_fill-extrusion", "layout_symbol", "layout_raster", "layout_hillshade", "layout_background"], ya = { visibility: { type: "enum", values: { visible: {}, none: {} }, default: "visible", "property-type": "constant" } }, $n = { "fill-sort-key": { type: "number", expression: { interpolated: false, parameters: ["zoom", "feature"] }, "property-type": "data-driven" }, visibility: { type: "enum", values: { visible: {}, none: {} }, default: "visible", "property-type": "constant" } }, Ma = { "circle-sort-key": { type: "number", expression: { interpolated: false, parameters: ["zoom", "feature"] }, "property-type": "data-driven" }, visibility: { type: "enum", values: { visible: {}, none: {} }, default: "visible", "property-type": "constant" } }, _o = { visibility: { type: "enum", values: { visible: {}, none: {} }, default: "visible", "property-type": "constant" } }, No = { "line-cap": { type: "enum", values: { butt: {}, round: {}, square: {} }, default: "butt", expression: { interpolated: false, parameters: ["zoom"] }, "property-type": "data-constant" }, "line-join": { type: "enum", values: { bevel: {}, round: {}, miter: {} }, default: "miter", expression: { interpolated: false, parameters: ["zoom", "feature"] }, "property-type": "data-driven" }, "line-miter-limit": { type: "number", default: 2, requires: [{ "line-join": "miter" }], expression: { interpolated: true, parameters: ["zoom"] }, "property-type": "data-constant" }, "line-round-limit": { type: "number", default: 1.05, requires: [{ "line-join": "round" }], expression: { interpolated: true, parameters: ["zoom"] }, "property-type": "data-constant" }, "line-sort-key": { type: "number", expression: { interpolated: false, parameters: ["zoom", "feature"] }, "property-type": "data-driven" }, visibility: { type: "enum", values: { visible: {}, none: {} }, default: "visible", "property-type": "constant" } }, po = { "symbol-placement": { type: "enum", values: { point: {}, line: {}, "line-center": {} }, default: "point", expression: { interpolated: false, parameters: ["zoom"] }, "property-type": "data-constant" }, "symbol-spacing": { type: "number", default: 250, minimum: 1, units: "pixels", requires: [{ "symbol-placement": "line" }], expression: { interpolated: true, parameters: ["zoom"] }, "property-type": "data-constant" }, "symbol-avoid-edges": { type: "boolean", default: false, expression: { interpolated: false, parameters: ["zoom"] }, "property-type": "data-constant" }, "symbol-sort-key": { type: "number", expression: { interpolated: false, parameters: ["zoom", "feature"] }, "property-type": "data-driven" }, "symbol-z-order": { type: "enum", values: { auto: {}, "viewport-y": {}, source: {} }, default: "auto", expression: { interpolated: false, parameters: ["zoom"] }, "property-type": "data-constant" }, "icon-allow-overlap": { type: "boolean", default: false, requires: ["icon-image"], expression: { interpolated: false, parameters: ["zoom"] }, "property-type": "data-constant" }, "icon-ignore-placement": { type: "boolean", default: false, requires: ["icon-image"], expression: { interpolated: false, parameters: ["zoom"] }, "property-type": "data-constant" }, "icon-optional": { type: "boolean", default: false, requires: ["icon-image", "text-field"], expression: { interpolated: false, parameters: ["zoom"] }, "property-type": "data-constant" }, "icon-rotation-alignment": { type: "enum", values: { map: {}, viewport: {}, auto: {} }, default: "auto", requires: ["icon-image"], expression: { interpolated: false, parameters: ["zoom"] }, "property-type": "data-constant" }, "icon-size": { type: "number", default: 1, minimum: 0, units: "factor of the original icon size", requires: ["icon-image"], expression: { interpolated: true, parameters: ["zoom", "feature"] }, "property-type": "data-driven" }, "icon-text-fit": { type: "enum", values: { none: {}, width: {}, height: {}, both: {} }, default: "none", requires: ["icon-image", "text-field"], expression: { interpolated: false, parameters: ["zoom"] }, "property-type": "data-constant" }, "icon-text-fit-padding": { type: "array", value: "number", length: 4, default: [0, 0, 0, 0], units: "pixels", requires: ["icon-image", "text-field", { "icon-text-fit": ["both", "width", "height"] }], expression: { interpolated: true, parameters: ["zoom"] }, "property-type": "data-constant" }, "icon-image": { type: "resolvedImage", tokens: true, expression: { interpolated: false, parameters: ["zoom", "feature"] }, "property-type": "data-driven" }, "icon-rotate": { type: "number", default: 0, period: 360, units: "degrees", requires: ["icon-image"], expression: { interpolated: true, parameters: ["zoom", "feature"] }, "property-type": "data-driven" }, "icon-padding": { type: "number", default: 2, minimum: 0, units: "pixels", requires: ["icon-image"], expression: { interpolated: true, parameters: ["zoom"] }, "property-type": "data-constant" }, "icon-keep-upright": { type: "boolean", default: false, requires: ["icon-image", { "icon-rotation-alignment": "map" }, { "symbol-placement": ["line", "line-center"] }], expression: { interpolated: false, parameters: ["zoom"] }, "property-type": "data-constant" }, "icon-offset": { type: "array", value: "number", length: 2, default: [0, 0], requires: ["icon-image"], expression: { interpolated: true, parameters: ["zoom", "feature"] }, "property-type": "data-driven" }, "icon-anchor": { type: "enum", values: { center: {}, left: {}, right: {}, top: {}, bottom: {}, "top-left": {}, "top-right": {}, "bottom-left": {}, "bottom-right": {} }, default: "center", requires: ["icon-image"], expression: { interpolated: false, parameters: ["zoom", "feature"] }, "property-type": "data-driven" }, "icon-pitch-alignment": { type: "enum", values: { map: {}, viewport: {}, auto: {} }, default: "auto", requires: ["icon-image"], expression: { interpolated: false, parameters: ["zoom"] }, "property-type": "data-constant" }, "text-pitch-alignment": { type: "enum", values: { map: {}, viewport: {}, auto: {} }, default: "auto", requires: ["text-field"], expression: { interpolated: false, parameters: ["zoom"] }, "property-type": "data-constant" }, "text-rotation-alignment": { type: "enum", values: { map: {}, viewport: {}, auto: {} }, default: "auto", requires: ["text-field"], expression: { interpolated: false, parameters: ["zoom"] }, "property-type": "data-constant" }, "text-field": { type: "formatted", default: "", tokens: true, expression: { interpolated: false, parameters: ["zoom", "feature"] }, "property-type": "data-driven" }, "text-font": { type: "array", value: "string", default: ["Open Sans Regular", "Arial Unicode MS Regular"], requires: ["text-field"], expression: { interpolated: false, parameters: ["zoom", "feature"] }, "property-type": "data-driven" }, "text-size": { type: "number", default: 16, minimum: 0, units: "pixels", requires: ["text-field"], expression: { interpolated: true, parameters: ["zoom", "feature"] }, "property-type": "data-driven" }, "text-max-width": { type: "number", default: 10, minimum: 0, units: "ems", requires: ["text-field"], expression: { interpolated: true, parameters: ["zoom", "feature"] }, "property-type": "data-driven" }, "text-line-height": { type: "number", default: 1.2, units: "ems", requires: ["text-field"], expression: { interpolated: true, parameters: ["zoom"] }, "property-type": "data-constant" }, "text-letter-spacing": { type: "number", default: 0, units: "ems", requires: ["text-field"], expression: { interpolated: true, parameters: ["zoom", "feature"] }, "property-type": "data-driven" }, "text-justify": { type: "enum", values: { auto: {}, left: {}, center: {}, right: {} }, default: "center", requires: ["text-field"], expression: { interpolated: false, parameters: ["zoom", "feature"] }, "property-type": "data-driven" }, "text-radial-offset": { type: "number", units: "ems", default: 0, requires: ["text-field"], "property-type": "data-driven", expression: { interpolated: true, parameters: ["zoom", "feature"] } }, "text-variable-anchor": { type: "array", value: "enum", values: { center: {}, left: {}, right: {}, top: {}, bottom: {}, "top-left": {}, "top-right": {}, "bottom-left": {}, "bottom-right": {} }, requires: ["text-field", { "symbol-placement": ["point"] }], expression: { interpolated: false, parameters: ["zoom"] }, "property-type": "data-constant" }, "text-anchor": { type: "enum", values: { center: {}, left: {}, right: {}, top: {}, bottom: {}, "top-left": {}, "top-right": {}, "bottom-left": {}, "bottom-right": {} }, default: "center", requires: ["text-field", { "!": "text-variable-anchor" }], expression: { interpolated: false, parameters: ["zoom", "feature"] }, "property-type": "data-driven" }, "text-max-angle": { type: "number", default: 45, units: "degrees", requires: ["text-field", { "symbol-placement": ["line", "line-center"] }], expression: { interpolated: true, parameters: ["zoom"] }, "property-type": "data-constant" }, "text-writing-mode": { type: "array", value: "enum", values: { horizontal: {}, vertical: {} }, requires: ["text-field", { "symbol-placement": ["point"] }], expression: { interpolated: false, parameters: ["zoom"] }, "property-type": "data-constant" }, "text-rotate": { type: "number", default: 0, period: 360, units: "degrees", requires: ["text-field"], expression: { interpolated: true, parameters: ["zoom", "feature"] }, "property-type": "data-driven" }, "text-padding": { type: "number", default: 2, minimum: 0, units: "pixels", requires: ["text-field"], expression: { interpolated: true, parameters: ["zoom"] }, "property-type": "data-constant" }, "text-keep-upright": { type: "boolean", default: true, requires: ["text-field", { "text-rotation-alignment": "map" }, { "symbol-placement": ["line", "line-center"] }], expression: { interpolated: false, parameters: ["zoom"] }, "property-type": "data-constant" }, "text-transform": { type: "enum", values: { none: {}, uppercase: {}, lowercase: {} }, default: "none", requires: ["text-field"], expression: { interpolated: false, parameters: ["zoom", "feature"] }, "property-type": "data-driven" }, "text-offset": { type: "array", value: "number", units: "ems", length: 2, default: [0, 0], requires: ["text-field", { "!": "text-radial-offset" }], expression: { interpolated: true, parameters: ["zoom", "feature"] }, "property-type": "data-driven" }, "text-allow-overlap": { type: "boolean", default: false, requires: ["text-field"], expression: { interpolated: false, parameters: ["zoom"] }, "property-type": "data-constant" }, "text-ignore-placement": { type: "boolean", default: false, requires: ["text-field"], expression: { interpolated: false, parameters: ["zoom"] }, "property-type": "data-constant" }, "text-optional": { type: "boolean", default: false, requires: ["text-field", "icon-image"], expression: { interpolated: false, parameters: ["zoom"] }, "property-type": "data-constant" }, visibility: { type: "enum", values: { visible: {}, none: {} }, default: "visible", "property-type": "constant" } }, Lo = { visibility: { type: "enum", values: { visible: {}, none: {} }, default: "visible", "property-type": "constant" } }, ko = { visibility: { type: "enum", values: { visible: {}, none: {} }, default: "visible", "property-type": "constant" } }, Ds = { type: "array", value: "*" }, Fs = { type: "enum", values: { "==": {}, "!=": {}, ">": {}, ">=": {}, "<": {}, "<=": {}, in: {}, "!in": {}, all: {}, any: {}, none: {}, has: {}, "!has": {}, within: {} } }, ll = { type: "enum", values: { Point: {}, LineString: {}, Polygon: {} } }, ul = { type: "array", minimum: 0, maximum: 24, value: ["number", "color"], length: 2 }, zl = { type: "array", value: "*", minimum: 1 }, us = { anchor: { type: "enum", default: "viewport", values: { map: {}, viewport: {} }, "property-type": "data-constant", transition: false, expression: { interpolated: false, parameters: ["zoom"] } }, position: { type: "array", default: [1.15, 210, 30], length: 3, value: "number", "property-type": "data-constant", transition: true, expression: { interpolated: true, parameters: ["zoom"] } }, color: { type: "color", "property-type": "data-constant", default: "#ffffff", expression: { interpolated: true, parameters: ["zoom"] }, transition: true }, intensity: { type: "number", "property-type": "data-constant", default: 0.5, minimum: 0, maximum: 1, expression: { interpolated: true, parameters: ["zoom"] }, transition: true } }, il = ["paint_fill", "paint_line", "paint_circle", "paint_heatmap", "paint_fill-extrusion", "paint_symbol", "paint_raster", "paint_hillshade", "paint_background"], As = { "fill-antialias": { type: "boolean", default: true, expression: { interpolated: false, parameters: ["zoom"] }, "property-type": "data-constant" }, "fill-opacity": { type: "number", default: 1, minimum: 0, maximum: 1, transition: true, expression: { interpolated: true, parameters: ["zoom", "feature", "feature-state"] }, "property-type": "data-driven" }, "fill-color": { type: "color", default: "#000000", transition: true, requires: [{ "!": "fill-pattern" }], expression: { interpolated: true, parameters: ["zoom", "feature", "feature-state"] }, "property-type": "data-driven" }, "fill-outline-color": { type: "color", transition: true, requires: [{ "!": "fill-pattern" }, { "fill-antialias": true }], expression: { interpolated: true, parameters: ["zoom", "feature", "feature-state"] }, "property-type": "data-driven" }, "fill-translate": { type: "array", value: "number", length: 2, default: [0, 0], transition: true, units: "pixels", expression: { interpolated: true, parameters: ["zoom"] }, "property-type": "data-constant" }, "fill-translate-anchor": { type: "enum", values: { map: {}, viewport: {} }, default: "map", requires: ["fill-translate"], expression: { interpolated: false, parameters: ["zoom"] }, "property-type": "data-constant" }, "fill-pattern": { type: "resolvedImage", transition: true, expression: { interpolated: false, parameters: ["zoom", "feature"] }, "property-type": "cross-faded-data-driven" } }, cl = { "line-opacity": { type: "number", default: 1, minimum: 0, maximum: 1, transition: true, expression: { interpolated: true, parameters: ["zoom", "feature", "feature-state"] }, "property-type": "data-driven" }, "line-color": { type: "color", default: "#000000", transition: true, requires: [{ "!": "line-pattern" }], expression: { interpolated: true, parameters: ["zoom", "feature", "feature-state"] }, "property-type": "data-driven" }, "line-translate": { type: "array", value: "number", length: 2, default: [0, 0], transition: true, units: "pixels", expression: { interpolated: true, parameters: ["zoom"] }, "property-type": "data-constant" }, "line-translate-anchor": { type: "enum", values: { map: {}, viewport: {} }, default: "map", requires: ["line-translate"], expression: { interpolated: false, parameters: ["zoom"] }, "property-type": "data-constant" }, "line-width": { type: "number", default: 1, minimum: 0, transition: true, units: "pixels", expression: { interpolated: true, parameters: ["zoom", "feature", "feature-state"] }, "property-type": "data-driven" }, "line-gap-width": { type: "number", default: 0, minimum: 0, transition: true, units: "pixels", expression: { interpolated: true, parameters: ["zoom", "feature", "feature-state"] }, "property-type": "data-driven" }, "line-offset": { type: "number", default: 0, transition: true, units: "pixels", expression: { interpolated: true, parameters: ["zoom", "feature", "feature-state"] }, "property-type": "data-driven" }, "line-blur": { type: "number", default: 0, minimum: 0, transition: true, units: "pixels", expression: { interpolated: true, parameters: ["zoom", "feature", "feature-state"] }, "property-type": "data-driven" }, "line-dasharray": { type: "array", value: "number", minimum: 0, transition: true, units: "line widths", requires: [{ "!": "line-pattern" }], expression: { interpolated: false, parameters: ["zoom"] }, "property-type": "cross-faded" }, "line-pattern": { type: "resolvedImage", transition: true, expression: { interpolated: false, parameters: ["zoom", "feature"] }, "property-type": "cross-faded-data-driven" }, "line-gradient": { type: "color", transition: false, requires: [{ "!": "line-dasharray" }, { "!": "line-pattern" }, { source: "geojson", has: { lineMetrics: true } }], expression: { interpolated: true, parameters: ["line-progress"] }, "property-type": "color-ramp" } }, Ks = { "circle-radius": { type: "number", default: 5, minimum: 0, transition: true, units: "pixels", expression: { interpolated: true, parameters: ["zoom", "feature", "feature-state"] }, "property-type": "data-driven" }, "circle-color": { type: "color", default: "#000000", transition: true, expression: { interpolated: true, parameters: ["zoom", "feature", "feature-state"] }, "property-type": "data-driven" }, "circle-blur": { type: "number", default: 0, transition: true, expression: { interpolated: true, parameters: ["zoom", "feature", "feature-state"] }, "property-type": "data-driven" }, "circle-opacity": { type: "number", default: 1, minimum: 0, maximum: 1, transition: true, expression: { interpolated: true, parameters: ["zoom", "feature", "feature-state"] }, "property-type": "data-driven" }, "circle-translate": { type: "array", value: "number", length: 2, default: [0, 0], transition: true, units: "pixels", expression: { interpolated: true, parameters: ["zoom"] }, "property-type": "data-constant" }, "circle-translate-anchor": { type: "enum", values: { map: {}, viewport: {} }, default: "map", requires: ["circle-translate"], expression: { interpolated: false, parameters: ["zoom"] }, "property-type": "data-constant" }, "circle-pitch-scale": { type: "enum", values: { map: {}, viewport: {} }, default: "map", expression: { interpolated: false, parameters: ["zoom"] }, "property-type": "data-constant" }, "circle-pitch-alignment": { type: "enum", values: { map: {}, viewport: {} }, default: "viewport", expression: { interpolated: false, parameters: ["zoom"] }, "property-type": "data-constant" }, "circle-stroke-width": { type: "number", default: 0, minimum: 0, transition: true, units: "pixels", expression: { interpolated: true, parameters: ["zoom", "feature", "feature-state"] }, "property-type": "data-driven" }, "circle-stroke-color": { type: "color", default: "#000000", transition: true, expression: { interpolated: true, parameters: ["zoom", "feature", "feature-state"] }, "property-type": "data-driven" }, "circle-stroke-opacity": { type: "number", default: 1, minimum: 0, maximum: 1, transition: true, expression: { interpolated: true, parameters: ["zoom", "feature", "feature-state"] }, "property-type": "data-driven" } }, zs = { "heatmap-radius": { type: "number", default: 30, minimum: 1, transition: true, units: "pixels", expression: { interpolated: true, parameters: ["zoom", "feature", "feature-state"] }, "property-type": "data-driven" }, "heatmap-weight": { type: "number", default: 1, minimum: 0, transition: false, expression: { interpolated: true, parameters: ["zoom", "feature", "feature-state"] }, "property-type": "data-driven" }, "heatmap-intensity": { type: "number", default: 1, minimum: 0, transition: true, expression: { interpolated: true, parameters: ["zoom"] }, "property-type": "data-constant" }, "heatmap-color": { type: "color", default: ["interpolate", ["linear"], ["heatmap-density"], 0, "rgba(0, 0, 255, 0)", 0.1, "royalblue", 0.3, "cyan", 0.5, "lime", 0.7, "yellow", 1, "red"], transition: false, expression: { interpolated: true, parameters: ["heatmap-density"] }, "property-type": "color-ramp" }, "heatmap-opacity": { type: "number", default: 1, minimum: 0, maximum: 1, transition: true, expression: { interpolated: true, parameters: ["zoom"] }, "property-type": "data-constant" } }, Io = { "icon-opacity": { type: "number", default: 1, minimum: 0, maximum: 1, transition: true, requires: ["icon-image"], expression: { interpolated: true, parameters: ["zoom", "feature", "feature-state"] }, "property-type": "data-driven" }, "icon-color": { type: "color", default: "#000000", transition: true, requires: ["icon-image"], expression: { interpolated: true, parameters: ["zoom", "feature", "feature-state"] }, "property-type": "data-driven" }, "icon-halo-color": { type: "color", default: "rgba(0, 0, 0, 0)", transition: true, requires: ["icon-image"], expression: { interpolated: true, parameters: ["zoom", "feature", "feature-state"] }, "property-type": "data-driven" }, "icon-halo-width": { type: "number", default: 0, minimum: 0, transition: true, units: "pixels", requires: ["icon-image"], expression: { interpolated: true, parameters: ["zoom", "feature", "feature-state"] }, "property-type": "data-driven" }, "icon-halo-blur": { type: "number", default: 0, minimum: 0, transition: true, units: "pixels", requires: ["icon-image"], expression: { interpolated: true, parameters: ["zoom", "feature", "feature-state"] }, "property-type": "data-driven" }, "icon-translate": { type: "array", value: "number", length: 2, default: [0, 0], transition: true, units: "pixels", requires: ["icon-image"], expression: { interpolated: true, parameters: ["zoom"] }, "property-type": "data-constant" }, "icon-translate-anchor": { type: "enum", values: { map: {}, viewport: {} }, default: "map", requires: ["icon-image", "icon-translate"], expression: { interpolated: false, parameters: ["zoom"] }, "property-type": "data-constant" }, "text-opacity": { type: "number", default: 1, minimum: 0, maximum: 1, transition: true, requires: ["text-field"], expression: { interpolated: true, parameters: ["zoom", "feature", "feature-state"] }, "property-type": "data-driven" }, "text-color": { type: "color", default: "#000000", transition: true, overridable: true, requires: ["text-field"], expression: { interpolated: true, parameters: ["zoom", "feature", "feature-state"] }, "property-type": "data-driven" }, "text-halo-color": { type: "color", default: "rgba(0, 0, 0, 0)", transition: true, requires: ["text-field"], expression: { interpolated: true, parameters: ["zoom", "feature", "feature-state"] }, "property-type": "data-driven" }, "text-halo-width": { type: "number", default: 0, minimum: 0, transition: true, units: "pixels", requires: ["text-field"], expression: { interpolated: true, parameters: ["zoom", "feature", "feature-state"] }, "property-type": "data-driven" }, "text-halo-blur": { type: "number", default: 0, minimum: 0, transition: true, units: "pixels", requires: ["text-field"], expression: { interpolated: true, parameters: ["zoom", "feature", "feature-state"] }, "property-type": "data-driven" }, "text-translate": { type: "array", value: "number", length: 2, default: [0, 0], transition: true, units: "pixels", requires: ["text-field"], expression: { interpolated: true, parameters: ["zoom"] }, "property-type": "data-constant" }, "text-translate-anchor": { type: "enum", values: { map: {}, viewport: {} }, default: "map", requires: ["text-field", "text-translate"], expression: { interpolated: false, parameters: ["zoom"] }, "property-type": "data-constant" } }, ls = { "raster-opacity": { type: "number", default: 1, minimum: 0, maximum: 1, transition: true, expression: { interpolated: true, parameters: ["zoom"] }, "property-type": "data-constant" }, "raster-hue-rotate": { type: "number", default: 0, period: 360, transition: true, units: "degrees", expression: { interpolated: true, parameters: ["zoom"] }, "property-type": "data-constant" }, "raster-brightness-min": { type: "number", default: 0, minimum: 0, maximum: 1, transition: true, expression: { interpolated: true, parameters: ["zoom"] }, "property-type": "data-constant" }, "raster-brightness-max": { type: "number", default: 1, minimum: 0, maximum: 1, transition: true, expression: { interpolated: true, parameters: ["zoom"] }, "property-type": "data-constant" }, "raster-saturation": { type: "number", default: 0, minimum: -1, maximum: 1, transition: true, expression: { interpolated: true, parameters: ["zoom"] }, "property-type": "data-constant" }, "raster-contrast": { type: "number", default: 0, minimum: -1, maximum: 1, transition: true, expression: { interpolated: true, parameters: ["zoom"] }, "property-type": "data-constant" }, "raster-resampling": { type: "enum", values: { linear: {}, nearest: {} }, default: "linear", expression: { interpolated: false, parameters: ["zoom"] }, "property-type": "data-constant" }, "raster-fade-duration": { type: "number", default: 300, minimum: 0, transition: false, units: "milliseconds", expression: { interpolated: true, parameters: ["zoom"] }, "property-type": "data-constant" } }, Yl = { "hillshade-illumination-direction": { type: "number", default: 335, minimum: 0, maximum: 359, transition: false, expression: { interpolated: true, parameters: ["zoom"] }, "property-type": "data-constant" }, "hillshade-illumination-anchor": { type: "enum", values: { map: {}, viewport: {} }, default: "viewport", expression: { interpolated: false, parameters: ["zoom"] }, "property-type": "data-constant" }, "hillshade-exaggeration": { type: "number", default: 0.5, minimum: 0, maximum: 1, transition: true, expression: { interpolated: true, parameters: ["zoom"] }, "property-type": "data-constant" }, "hillshade-shadow-color": { type: "color", default: "#000000", transition: true, expression: { interpolated: true, parameters: ["zoom"] }, "property-type": "data-constant" }, "hillshade-highlight-color": { type: "color", default: "#FFFFFF", transition: true, expression: { interpolated: true, parameters: ["zoom"] }, "property-type": "data-constant" }, "hillshade-accent-color": { type: "color", default: "#000000", transition: true, expression: { interpolated: true, parameters: ["zoom"] }, "property-type": "data-constant" } }, Su = { "background-color": { type: "color", default: "#000000", transition: true, requires: [{ "!": "background-pattern" }], expression: { interpolated: true, parameters: ["zoom"] }, "property-type": "data-constant" }, "background-pattern": { type: "resolvedImage", transition: true, expression: { interpolated: false, parameters: ["zoom"] }, "property-type": "cross-faded" }, "background-opacity": { type: "number", default: 1, minimum: 0, maximum: 1, transition: true, expression: { interpolated: true, parameters: ["zoom"] }, "property-type": "data-constant" } }, nc = { duration: { type: "number", default: 300, minimum: 0, units: "milliseconds" }, delay: { type: "number", default: 0, minimum: 0, units: "milliseconds" } }, bs = { "*": { type: "string" } }, Rn = { $version: Ha, $root: vo, sources: jn, source: Mt, source_vector: kr, source_raster: Jr, source_raster_dem: vi, source_geojson: hn, source_video: An, source_image: Mn, layer: Li, layout: _n, layout_background: ya, layout_fill: $n, layout_circle: Ma, layout_heatmap: _o, "layout_fill-extrusion": { visibility: { type: "enum", values: { visible: {}, none: {} }, default: "visible", "property-type": "constant" } }, layout_line: No, layout_symbol: po, layout_raster: Lo, layout_hillshade: ko, filter: Ds, filter_operator: Fs, geometry_type: ll, function: { expression: { type: "expression" }, stops: { type: "array", value: "function_stop" }, base: { type: "number", default: 1, minimum: 0 }, property: { type: "string", default: "$zoom" }, type: { type: "enum", values: { identity: {}, exponential: {}, interval: {}, categorical: {} }, default: "exponential" }, colorSpace: { type: "enum", values: { rgb: {}, lab: {}, hcl: {} }, default: "rgb" }, default: { type: "*", required: false } }, function_stop: ul, expression: zl, light: us, paint: il, paint_fill: As, "paint_fill-extrusion": { "fill-extrusion-opacity": { type: "number", default: 1, minimum: 0, maximum: 1, transition: true, expression: { interpolated: true, parameters: ["zoom"] }, "property-type": "data-constant" }, "fill-extrusion-color": { type: "color", default: "#000000", transition: true, requires: [{ "!": "fill-extrusion-pattern" }], expression: { interpolated: true, parameters: ["zoom", "feature", "feature-state"] }, "property-type": "data-driven" }, "fill-extrusion-translate": { type: "array", value: "number", length: 2, default: [0, 0], transition: true, units: "pixels", expression: { interpolated: true, parameters: ["zoom"] }, "property-type": "data-constant" }, "fill-extrusion-translate-anchor": { type: "enum", values: { map: {}, viewport: {} }, default: "map", requires: ["fill-extrusion-translate"], expression: { interpolated: false, parameters: ["zoom"] }, "property-type": "data-constant" }, "fill-extrusion-pattern": { type: "resolvedImage", transition: true, expression: { interpolated: false, parameters: ["zoom", "feature"] }, "property-type": "cross-faded-data-driven" }, "fill-extrusion-height": { type: "number", default: 0, minimum: 0, units: "meters", transition: true, expression: { interpolated: true, parameters: ["zoom", "feature", "feature-state"] }, "property-type": "data-driven" }, "fill-extrusion-base": { type: "number", default: 0, minimum: 0, units: "meters", transition: true, requires: ["fill-extrusion-height"], expression: { interpolated: true, parameters: ["zoom", "feature", "feature-state"] }, "property-type": "data-driven" }, "fill-extrusion-vertical-gradient": { type: "boolean", default: true, transition: false, expression: { interpolated: false, parameters: ["zoom"] }, "property-type": "data-constant" } }, paint_line: cl, paint_circle: Ks, paint_heatmap: zs, paint_symbol: Io, paint_raster: ls, paint_hillshade: Yl, paint_background: Su, transition: nc, "property-type": { "data-driven": { type: "property-type" }, "cross-faded": { type: "property-type" }, "cross-faded-data-driven": { type: "property-type" }, "color-ramp": { type: "property-type" }, "data-constant": { type: "property-type" }, constant: { type: "property-type" } }, promoteId: bs }, _a = function(y, I, V, $) {
+              this.message = (y ? y + ": " : "") + V, $ && (this.identifier = $), I != null && I.__line__ && (this.line = I.__line__);
+            };
+            function Vu(m) {
+              var y = m.key, I = m.value;
+              return I ? [new _a(y, I, "constants have been deprecated as of v8")] : [];
+            }
+            function Ol(m) {
+              for (var y = [], I = arguments.length - 1; I-- > 0; ) y[I] = arguments[I + 1];
+              for (var V = 0, $ = y; V < $.length; V += 1) {
+                var ae = $[V];
+                for (var he in ae) m[he] = ae[he];
+              }
+              return m;
+            }
+            function xo(m) {
+              return m instanceof Number || m instanceof String || m instanceof Boolean ? m.valueOf() : m;
+            }
+            function Kl(m) {
+              if (Array.isArray(m)) return m.map(Kl);
+              if (m instanceof Object && !(m instanceof Number || m instanceof String || m instanceof Boolean)) {
+                var y = {};
+                for (var I in m) y[I] = Kl(m[I]);
+                return y;
+              }
+              return xo(m);
+            }
+            var Ns = function(m) {
+              function y(I, V) {
+                m.call(this, V), this.message = V, this.key = I;
+              }
+              return m && (y.__proto__ = m), y.prototype = Object.create(m && m.prototype), y.prototype.constructor = y, y;
+            }(Error), Hl = function(y, I) {
+              I === void 0 && (I = []), this.parent = y, this.bindings = {};
+              for (var V = 0, $ = I; V < $.length; V += 1) {
+                var ae = $[V], he = ae[0], ze = ae[1];
+                this.bindings[he] = ze;
+              }
+            };
+            Hl.prototype.concat = function(y) {
+              return new Hl(this, y);
+            }, Hl.prototype.get = function(y) {
+              if (this.bindings[y]) return this.bindings[y];
+              if (this.parent) return this.parent.get(y);
+              throw new Error(y + " not found in scope.");
+            }, Hl.prototype.has = function(y) {
+              return this.bindings[y] ? true : this.parent ? this.parent.has(y) : false;
+            };
+            var ac = { kind: "null" }, aa = { kind: "number" }, Oo = { kind: "string" }, qo = { kind: "boolean" }, ql = { kind: "color" }, Pc = { kind: "object" }, Do = { kind: "value" }, rf = { kind: "error" }, Vf = { kind: "collator" }, pl = { kind: "formatted" }, Zc = { kind: "resolvedImage" };
+            function Jl(m, y) {
+              return { kind: "array", itemType: m, N: y };
+            }
+            function Os(m) {
+              if (m.kind === "array") {
+                var y = Os(m.itemType);
+                return typeof m.N == "number" ? "array<" + y + ", " + m.N + ">" : m.itemType.kind === "value" ? "array" : "array<" + y + ">";
+              } else return m.kind;
+            }
+            var yu = [ac, aa, Oo, qo, ql, pl, Pc, Jl(Do), Zc];
+            function oc(m, y) {
+              if (y.kind === "error") return null;
+              if (m.kind === "array") {
+                if (y.kind === "array" && (y.N === 0 && y.itemType.kind === "value" || !oc(m.itemType, y.itemType)) && (typeof m.N != "number" || m.N === y.N)) return null;
+              } else {
+                if (m.kind === y.kind) return null;
+                if (m.kind === "value") for (var I = 0, V = yu; I < V.length; I += 1) {
+                  var $ = V[I];
+                  if (!oc($, y)) return null;
+                }
+              }
+              return "Expected " + Os(m) + " but found " + Os(y) + " instead.";
+            }
+            function Cf(m, y) {
+              return y.some(function(I) {
+                return I.kind === m.kind;
+              });
+            }
+            function sc(m, y) {
+              return y.some(function(I) {
+                return I === "null" ? m === null : I === "array" ? Array.isArray(m) : I === "object" ? m && !Array.isArray(m) && typeof m == "object" : I === typeof m;
+              });
+            }
+            var jh = a(function(m, y) {
+              var I = { transparent: [0, 0, 0, 0], aliceblue: [240, 248, 255, 1], antiquewhite: [250, 235, 215, 1], aqua: [0, 255, 255, 1], aquamarine: [127, 255, 212, 1], azure: [240, 255, 255, 1], beige: [245, 245, 220, 1], bisque: [255, 228, 196, 1], black: [0, 0, 0, 1], blanchedalmond: [255, 235, 205, 1], blue: [0, 0, 255, 1], blueviolet: [138, 43, 226, 1], brown: [165, 42, 42, 1], burlywood: [222, 184, 135, 1], cadetblue: [95, 158, 160, 1], chartreuse: [127, 255, 0, 1], chocolate: [210, 105, 30, 1], coral: [255, 127, 80, 1], cornflowerblue: [100, 149, 237, 1], cornsilk: [255, 248, 220, 1], crimson: [220, 20, 60, 1], cyan: [0, 255, 255, 1], darkblue: [0, 0, 139, 1], darkcyan: [0, 139, 139, 1], darkgoldenrod: [184, 134, 11, 1], darkgray: [169, 169, 169, 1], darkgreen: [0, 100, 0, 1], darkgrey: [169, 169, 169, 1], darkkhaki: [189, 183, 107, 1], darkmagenta: [139, 0, 139, 1], darkolivegreen: [85, 107, 47, 1], darkorange: [255, 140, 0, 1], darkorchid: [153, 50, 204, 1], darkred: [139, 0, 0, 1], darksalmon: [233, 150, 122, 1], darkseagreen: [143, 188, 143, 1], darkslateblue: [72, 61, 139, 1], darkslategray: [47, 79, 79, 1], darkslategrey: [47, 79, 79, 1], darkturquoise: [0, 206, 209, 1], darkviolet: [148, 0, 211, 1], deeppink: [255, 20, 147, 1], deepskyblue: [0, 191, 255, 1], dimgray: [105, 105, 105, 1], dimgrey: [105, 105, 105, 1], dodgerblue: [30, 144, 255, 1], firebrick: [178, 34, 34, 1], floralwhite: [255, 250, 240, 1], forestgreen: [34, 139, 34, 1], fuchsia: [255, 0, 255, 1], gainsboro: [220, 220, 220, 1], ghostwhite: [248, 248, 255, 1], gold: [255, 215, 0, 1], goldenrod: [218, 165, 32, 1], gray: [128, 128, 128, 1], green: [0, 128, 0, 1], greenyellow: [173, 255, 47, 1], grey: [128, 128, 128, 1], honeydew: [240, 255, 240, 1], hotpink: [255, 105, 180, 1], indianred: [205, 92, 92, 1], indigo: [75, 0, 130, 1], ivory: [255, 255, 240, 1], khaki: [240, 230, 140, 1], lavender: [230, 230, 250, 1], lavenderblush: [255, 240, 245, 1], lawngreen: [124, 252, 0, 1], lemonchiffon: [255, 250, 205, 1], lightblue: [173, 216, 230, 1], lightcoral: [240, 128, 128, 1], lightcyan: [224, 255, 255, 1], lightgoldenrodyellow: [250, 250, 210, 1], lightgray: [211, 211, 211, 1], lightgreen: [144, 238, 144, 1], lightgrey: [211, 211, 211, 1], lightpink: [255, 182, 193, 1], lightsalmon: [255, 160, 122, 1], lightseagreen: [32, 178, 170, 1], lightskyblue: [135, 206, 250, 1], lightslategray: [119, 136, 153, 1], lightslategrey: [119, 136, 153, 1], lightsteelblue: [176, 196, 222, 1], lightyellow: [255, 255, 224, 1], lime: [0, 255, 0, 1], limegreen: [50, 205, 50, 1], linen: [250, 240, 230, 1], magenta: [255, 0, 255, 1], maroon: [128, 0, 0, 1], mediumaquamarine: [102, 205, 170, 1], mediumblue: [0, 0, 205, 1], mediumorchid: [186, 85, 211, 1], mediumpurple: [147, 112, 219, 1], mediumseagreen: [60, 179, 113, 1], mediumslateblue: [123, 104, 238, 1], mediumspringgreen: [0, 250, 154, 1], mediumturquoise: [72, 209, 204, 1], mediumvioletred: [199, 21, 133, 1], midnightblue: [25, 25, 112, 1], mintcream: [245, 255, 250, 1], mistyrose: [255, 228, 225, 1], moccasin: [255, 228, 181, 1], navajowhite: [255, 222, 173, 1], navy: [0, 0, 128, 1], oldlace: [253, 245, 230, 1], olive: [128, 128, 0, 1], olivedrab: [107, 142, 35, 1], orange: [255, 165, 0, 1], orangered: [255, 69, 0, 1], orchid: [218, 112, 214, 1], palegoldenrod: [238, 232, 170, 1], palegreen: [152, 251, 152, 1], paleturquoise: [175, 238, 238, 1], palevioletred: [219, 112, 147, 1], papayawhip: [255, 239, 213, 1], peachpuff: [255, 218, 185, 1], peru: [205, 133, 63, 1], pink: [255, 192, 203, 1], plum: [221, 160, 221, 1], powderblue: [176, 224, 230, 1], purple: [128, 0, 128, 1], rebeccapurple: [102, 51, 153, 1], red: [255, 0, 0, 1], rosybrown: [188, 143, 143, 1], royalblue: [65, 105, 225, 1], saddlebrown: [139, 69, 19, 1], salmon: [250, 128, 114, 1], sandybrown: [244, 164, 96, 1], seagreen: [46, 139, 87, 1], seashell: [255, 245, 238, 1], sienna: [160, 82, 45, 1], silver: [192, 192, 192, 1], skyblue: [135, 206, 235, 1], slateblue: [106, 90, 205, 1], slategray: [112, 128, 144, 1], slategrey: [112, 128, 144, 1], snow: [255, 250, 250, 1], springgreen: [0, 255, 127, 1], steelblue: [70, 130, 180, 1], tan: [210, 180, 140, 1], teal: [0, 128, 128, 1], thistle: [216, 191, 216, 1], tomato: [255, 99, 71, 1], turquoise: [64, 224, 208, 1], violet: [238, 130, 238, 1], wheat: [245, 222, 179, 1], white: [255, 255, 255, 1], whitesmoke: [245, 245, 245, 1], yellow: [255, 255, 0, 1], yellowgreen: [154, 205, 50, 1] };
+              function V(gt) {
+                return gt = Math.round(gt), gt < 0 ? 0 : gt > 255 ? 255 : gt;
+              }
+              function $(gt) {
+                return gt < 0 ? 0 : gt > 1 ? 1 : gt;
+              }
+              function ae(gt) {
+                return gt[gt.length - 1] === "%" ? V(parseFloat(gt) / 100 * 255) : V(parseInt(gt));
+              }
+              function he(gt) {
+                return gt[gt.length - 1] === "%" ? $(parseFloat(gt) / 100) : $(parseFloat(gt));
+              }
+              function ze(gt, Et, or) {
+                return or < 0 ? or += 1 : or > 1 && (or -= 1), or * 6 < 1 ? gt + (Et - gt) * or * 6 : or * 2 < 1 ? Et : or * 3 < 2 ? gt + (Et - gt) * (2 / 3 - or) * 6 : gt;
+              }
+              function rt(gt) {
+                var Et = gt.replace(/ /g, "").toLowerCase();
+                if (Et in I) return I[Et].slice();
+                if (Et[0] === "#") {
+                  if (Et.length === 4) {
+                    var or = parseInt(Et.substr(1), 16);
+                    return or >= 0 && or <= 4095 ? [(or & 3840) >> 4 | (or & 3840) >> 8, or & 240 | (or & 240) >> 4, or & 15 | (or & 15) << 4, 1] : null;
+                  } else if (Et.length === 7) {
+                    var or = parseInt(Et.substr(1), 16);
+                    return or >= 0 && or <= 16777215 ? [(or & 16711680) >> 16, (or & 65280) >> 8, or & 255, 1] : null;
+                  }
+                  return null;
+                }
+                var _r = Et.indexOf("("), pr = Et.indexOf(")");
+                if (_r !== -1 && pr + 1 === Et.length) {
+                  var Fr = Et.substr(0, _r), oi = Et.substr(_r + 1, pr - (_r + 1)).split(","), Hi = 1;
+                  switch (Fr) {
+                    case "rgba":
+                      if (oi.length !== 4) return null;
+                      Hi = he(oi.pop());
+                    case "rgb":
+                      return oi.length !== 3 ? null : [ae(oi[0]), ae(oi[1]), ae(oi[2]), Hi];
+                    case "hsla":
+                      if (oi.length !== 4) return null;
+                      Hi = he(oi.pop());
+                    case "hsl":
+                      if (oi.length !== 3) return null;
+                      var Ai = (parseFloat(oi[0]) % 360 + 360) % 360 / 360, bn = he(oi[1]), nn = he(oi[2]), xn = nn <= 0.5 ? nn * (bn + 1) : nn + bn - nn * bn, Pn = nn * 2 - xn;
+                      return [V(ze(Pn, xn, Ai + 1 / 3) * 255), V(ze(Pn, xn, Ai) * 255), V(ze(Pn, xn, Ai - 1 / 3) * 255), Hi];
+                    default:
+                      return null;
+                  }
+                }
+                return null;
+              }
+              try {
+                y.parseCSSColor = rt;
+              } catch (gt) {
+              }
+            }), Lf = jh.parseCSSColor, cs = function(y, I, V, $) {
+              $ === void 0 && ($ = 1), this.r = y, this.g = I, this.b = V, this.a = $;
+            };
+            cs.parse = function(y) {
+              if (y) {
+                if (y instanceof cs) return y;
+                if (typeof y == "string") {
+                  var I = Lf(y);
+                  if (I) return new cs(I[0] / 255 * I[3], I[1] / 255 * I[3], I[2] / 255 * I[3], I[3]);
+                }
+              }
+            }, cs.prototype.toString = function() {
+              var y = this.toArray(), I = y[0], V = y[1], $ = y[2], ae = y[3];
+              return "rgba(" + Math.round(I) + "," + Math.round(V) + "," + Math.round($) + "," + ae + ")";
+            }, cs.prototype.toArray = function() {
+              var y = this, I = y.r, V = y.g, $ = y.b, ae = y.a;
+              return ae === 0 ? [0, 0, 0, 0] : [I * 255 / ae, V * 255 / ae, $ * 255 / ae, ae];
+            }, cs.black = new cs(0, 0, 0, 1), cs.white = new cs(1, 1, 1, 1), cs.transparent = new cs(0, 0, 0, 0), cs.red = new cs(1, 0, 0, 1);
+            var nf = function(y, I, V) {
+              y ? this.sensitivity = I ? "variant" : "case" : this.sensitivity = I ? "accent" : "base", this.locale = V, this.collator = new Intl.Collator(this.locale ? this.locale : [], { sensitivity: this.sensitivity, usage: "search" });
+            };
+            nf.prototype.compare = function(y, I) {
+              return this.collator.compare(y, I);
+            }, nf.prototype.resolvedLocale = function() {
+              return new Intl.Collator(this.locale ? this.locale : []).resolvedOptions().locale;
+            };
+            var Gf = function(y, I, V, $, ae) {
+              this.text = y, this.image = I, this.scale = V, this.fontStack = $, this.textColor = ae;
+            }, $l = function(y) {
+              this.sections = y;
+            };
+            $l.fromString = function(y) {
+              return new $l([new Gf(y, null, null, null, null)]);
+            }, $l.prototype.isEmpty = function() {
+              return this.sections.length === 0 ? true : !this.sections.some(function(y) {
+                return y.text.length !== 0 || y.image && y.image.name.length !== 0;
+              });
+            }, $l.factory = function(y) {
+              return y instanceof $l ? y : $l.fromString(y);
+            }, $l.prototype.toString = function() {
+              return this.sections.length === 0 ? "" : this.sections.map(function(y) {
+                return y.text;
+              }).join("");
+            }, $l.prototype.serialize = function() {
+              for (var y = ["format"], I = 0, V = this.sections; I < V.length; I += 1) {
+                var $ = V[I];
+                if ($.image) {
+                  y.push(["image", $.image.name]);
+                  continue;
+                }
+                y.push($.text);
+                var ae = {};
+                $.fontStack && (ae["text-font"] = ["literal", $.fontStack.split(",")]), $.scale && (ae["font-scale"] = $.scale), $.textColor && (ae["text-color"] = ["rgba"].concat($.textColor.toArray())), y.push(ae);
+              }
+              return y;
+            };
+            var fl = function(y) {
+              this.name = y.name, this.available = y.available;
+            };
+            fl.prototype.toString = function() {
+              return this.name;
+            }, fl.fromString = function(y) {
+              return y ? new fl({ name: y, available: false }) : null;
+            }, fl.prototype.serialize = function() {
+              return ["image", this.name];
+            };
+            function lc(m, y, I, V) {
+              if (!(typeof m == "number" && m >= 0 && m <= 255 && typeof y == "number" && y >= 0 && y <= 255 && typeof I == "number" && I >= 0 && I <= 255)) {
+                var $ = typeof V == "number" ? [m, y, I, V] : [m, y, I];
+                return "Invalid rgba value [" + $.join(", ") + "]: 'r', 'g', and 'b' must be between 0 and 255.";
+              }
+              return typeof V == "undefined" || typeof V == "number" && V >= 0 && V <= 1 ? null : "Invalid rgba value [" + [m, y, I, V].join(", ") + "]: 'a' must be between 0 and 1.";
+            }
+            function Fu(m) {
+              if (m === null) return true;
+              if (typeof m == "string") return true;
+              if (typeof m == "boolean") return true;
+              if (typeof m == "number") return true;
+              if (m instanceof cs) return true;
+              if (m instanceof nf) return true;
+              if (m instanceof $l) return true;
+              if (m instanceof fl) return true;
+              if (Array.isArray(m)) {
+                for (var y = 0, I = m; y < I.length; y += 1) {
+                  var V = I[y];
+                  if (!Fu(V)) return false;
+                }
+                return true;
+              } else if (typeof m == "object") {
+                for (var $ in m) if (!Fu(m[$])) return false;
+                return true;
+              } else return false;
+            }
+            function Es(m) {
+              if (m === null) return ac;
+              if (typeof m == "string") return Oo;
+              if (typeof m == "boolean") return qo;
+              if (typeof m == "number") return aa;
+              if (m instanceof cs) return ql;
+              if (m instanceof nf) return Vf;
+              if (m instanceof $l) return pl;
+              if (m instanceof fl) return Zc;
+              if (Array.isArray(m)) {
+                for (var y = m.length, I, V = 0, $ = m; V < $.length; V += 1) {
+                  var ae = $[V], he = Es(ae);
+                  if (!I) I = he;
+                  else {
+                    if (I === he) continue;
+                    I = Do;
+                    break;
+                  }
+                }
+                return Jl(I || Do, y);
+              } else return Pc;
+            }
+            function Hs(m) {
+              var y = typeof m;
+              return m === null ? "" : y === "string" || y === "number" || y === "boolean" ? String(m) : m instanceof cs || m instanceof $l || m instanceof fl ? m.toString() : JSON.stringify(m);
+            }
+            var Go = function(y, I) {
+              this.type = y, this.value = I;
+            };
+            Go.parse = function(y, I) {
+              if (y.length !== 2) return I.error("'literal' expression requires exactly one argument, but found " + (y.length - 1) + " instead.");
+              if (!Fu(y[1])) return I.error("invalid value");
+              var V = y[1], $ = Es(V), ae = I.expectedType;
+              return $.kind === "array" && $.N === 0 && ae && ae.kind === "array" && (typeof ae.N != "number" || ae.N === 0) && ($ = ae), new Go($, V);
+            }, Go.prototype.evaluate = function() {
+              return this.value;
+            }, Go.prototype.eachChild = function() {
+            }, Go.prototype.outputDefined = function() {
+              return true;
+            }, Go.prototype.serialize = function() {
+              return this.type.kind === "array" || this.type.kind === "object" ? ["literal", this.value] : this.value instanceof cs ? ["rgba"].concat(this.value.toArray()) : this.value instanceof $l ? this.value.serialize() : this.value;
+            };
+            var ps = function(y) {
+              this.name = "ExpressionEvaluationError", this.message = y;
+            };
+            ps.prototype.toJSON = function() {
+              return this.message;
+            };
+            var uc = { string: Oo, number: aa, boolean: qo, object: Pc }, xl = function(y, I) {
+              this.type = y, this.args = I;
+            };
+            xl.parse = function(y, I) {
+              if (y.length < 2) return I.error("Expected at least one argument.");
+              var V = 1, $, ae = y[0];
+              if (ae === "array") {
+                var he;
+                if (y.length > 2) {
+                  var ze = y[1];
+                  if (typeof ze != "string" || !(ze in uc) || ze === "object") return I.error('The item type argument of "array" must be one of string, number, boolean', 1);
+                  he = uc[ze], V++;
+                } else he = Do;
+                var rt;
+                if (y.length > 3) {
+                  if (y[2] !== null && (typeof y[2] != "number" || y[2] < 0 || y[2] !== Math.floor(y[2]))) return I.error('The length argument to "array" must be a positive integer literal', 2);
+                  rt = y[2], V++;
+                }
+                $ = Jl(he, rt);
+              } else $ = uc[ae];
+              for (var gt = []; V < y.length; V++) {
+                var Et = I.parse(y[V], V, Do);
+                if (!Et) return null;
+                gt.push(Et);
+              }
+              return new xl($, gt);
+            }, xl.prototype.evaluate = function(y) {
+              for (var I = 0; I < this.args.length; I++) {
+                var V = this.args[I].evaluate(y), $ = oc(this.type, Es(V));
+                if ($) {
+                  if (I === this.args.length - 1) throw new ps("Expected value to be of type " + Os(this.type) + ", but found " + Os(Es(V)) + " instead.");
+                } else return V;
+              }
+              return null;
+            }, xl.prototype.eachChild = function(y) {
+              this.args.forEach(y);
+            }, xl.prototype.outputDefined = function() {
+              return this.args.every(function(y) {
+                return y.outputDefined();
+              });
+            }, xl.prototype.serialize = function() {
+              var y = this.type, I = [y.kind];
+              if (y.kind === "array") {
+                var V = y.itemType;
+                if (V.kind === "string" || V.kind === "number" || V.kind === "boolean") {
+                  I.push(V.kind);
+                  var $ = y.N;
+                  (typeof $ == "number" || this.args.length > 1) && I.push($);
+                }
+              }
+              return I.concat(this.args.map(function(ae) {
+                return ae.serialize();
+              }));
+            };
+            var Gu = function(y) {
+              this.type = pl, this.sections = y;
+            };
+            Gu.parse = function(y, I) {
+              if (y.length < 2) return I.error("Expected at least one argument.");
+              var V = y[1];
+              if (!Array.isArray(V) && typeof V == "object") return I.error("First argument must be an image or text section.");
+              for (var $ = [], ae = false, he = 1; he <= y.length - 1; ++he) {
+                var ze = y[he];
+                if (ae && typeof ze == "object" && !Array.isArray(ze)) {
+                  ae = false;
+                  var rt = null;
+                  if (ze["font-scale"] && (rt = I.parse(ze["font-scale"], 1, aa), !rt)) return null;
+                  var gt = null;
+                  if (ze["text-font"] && (gt = I.parse(ze["text-font"], 1, Jl(Oo)), !gt)) return null;
+                  var Et = null;
+                  if (ze["text-color"] && (Et = I.parse(ze["text-color"], 1, ql), !Et)) return null;
+                  var or = $[$.length - 1];
+                  or.scale = rt, or.font = gt, or.textColor = Et;
+                } else {
+                  var _r = I.parse(y[he], 1, Do);
+                  if (!_r) return null;
+                  var pr = _r.type.kind;
+                  if (pr !== "string" && pr !== "value" && pr !== "null" && pr !== "resolvedImage") return I.error("Formatted text type must be 'string', 'value', 'image' or 'null'.");
+                  ae = true, $.push({ content: _r, scale: null, font: null, textColor: null });
+                }
+              }
+              return new Gu($);
+            }, Gu.prototype.evaluate = function(y) {
+              var I = function(V) {
+                var $ = V.content.evaluate(y);
+                return Es($) === Zc ? new Gf("", $, null, null, null) : new Gf(Hs($), null, V.scale ? V.scale.evaluate(y) : null, V.font ? V.font.evaluate(y).join(",") : null, V.textColor ? V.textColor.evaluate(y) : null);
+              };
+              return new $l(this.sections.map(I));
+            }, Gu.prototype.eachChild = function(y) {
+              for (var I = 0, V = this.sections; I < V.length; I += 1) {
+                var $ = V[I];
+                y($.content), $.scale && y($.scale), $.font && y($.font), $.textColor && y($.textColor);
+              }
+            }, Gu.prototype.outputDefined = function() {
+              return false;
+            }, Gu.prototype.serialize = function() {
+              for (var y = ["format"], I = 0, V = this.sections; I < V.length; I += 1) {
+                var $ = V[I];
+                y.push($.content.serialize());
+                var ae = {};
+                $.scale && (ae["font-scale"] = $.scale.serialize()), $.font && (ae["text-font"] = $.font.serialize()), $.textColor && (ae["text-color"] = $.textColor.serialize()), y.push(ae);
+              }
+              return y;
+            };
+            var qs = function(y) {
+              this.type = Zc, this.input = y;
+            };
+            qs.parse = function(y, I) {
+              if (y.length !== 2) return I.error("Expected two arguments.");
+              var V = I.parse(y[1], 1, Oo);
+              return V ? new qs(V) : I.error("No image name provided.");
+            }, qs.prototype.evaluate = function(y) {
+              var I = this.input.evaluate(y), V = fl.fromString(I);
+              return V && y.availableImages && (V.available = y.availableImages.indexOf(I) > -1), V;
+            }, qs.prototype.eachChild = function(y) {
+              y(this.input);
+            }, qs.prototype.outputDefined = function() {
+              return false;
+            }, qs.prototype.serialize = function() {
+              return ["image", this.input.serialize()];
+            };
+            var od = { "to-boolean": qo, "to-color": ql, "to-number": aa, "to-string": Oo }, Po = function(y, I) {
+              this.type = y, this.args = I;
+            };
+            Po.parse = function(y, I) {
+              if (y.length < 2) return I.error("Expected at least one argument.");
+              var V = y[0];
+              if ((V === "to-boolean" || V === "to-string") && y.length !== 2) return I.error("Expected one argument.");
+              for (var $ = od[V], ae = [], he = 1; he < y.length; he++) {
+                var ze = I.parse(y[he], he, Do);
+                if (!ze) return null;
+                ae.push(ze);
+              }
+              return new Po($, ae);
+            }, Po.prototype.evaluate = function(y) {
+              if (this.type.kind === "boolean") return !!this.args[0].evaluate(y);
+              if (this.type.kind === "color") {
+                for (var I, V, $ = 0, ae = this.args; $ < ae.length; $ += 1) {
+                  var he = ae[$];
+                  if (I = he.evaluate(y), V = null, I instanceof cs) return I;
+                  if (typeof I == "string") {
+                    var ze = y.parseColor(I);
+                    if (ze) return ze;
+                  } else if (Array.isArray(I) && (I.length < 3 || I.length > 4 ? V = "Invalid rbga value " + JSON.stringify(I) + ": expected an array containing either three or four numeric values." : V = lc(I[0], I[1], I[2], I[3]), !V)) return new cs(I[0] / 255, I[1] / 255, I[2] / 255, I[3]);
+                }
+                throw new ps(V || "Could not parse color from value '" + (typeof I == "string" ? I : String(JSON.stringify(I))) + "'");
+              } else if (this.type.kind === "number") {
+                for (var rt = null, gt = 0, Et = this.args; gt < Et.length; gt += 1) {
+                  var or = Et[gt];
+                  if (rt = or.evaluate(y), rt === null) return 0;
+                  var _r = Number(rt);
+                  if (!isNaN(_r)) return _r;
+                }
+                throw new ps("Could not convert " + JSON.stringify(rt) + " to number.");
+              } else return this.type.kind === "formatted" ? $l.fromString(Hs(this.args[0].evaluate(y))) : this.type.kind === "resolvedImage" ? fl.fromString(Hs(this.args[0].evaluate(y))) : Hs(this.args[0].evaluate(y));
+            }, Po.prototype.eachChild = function(y) {
+              this.args.forEach(y);
+            }, Po.prototype.outputDefined = function() {
+              return this.args.every(function(y) {
+                return y.outputDefined();
+              });
+            }, Po.prototype.serialize = function() {
+              if (this.type.kind === "formatted") return new Gu([{ content: this.args[0], scale: null, font: null, textColor: null }]).serialize();
+              if (this.type.kind === "resolvedImage") return new qs(this.args[0]).serialize();
+              var y = ["to-" + this.type.kind];
+              return this.eachChild(function(I) {
+                y.push(I.serialize());
+              }), y;
+            };
+            var sd = ["Unknown", "Point", "LineString", "Polygon"], Ko = function() {
+              this.globals = null, this.feature = null, this.featureState = null, this.formattedSection = null, this._parseColorCache = {}, this.availableImages = null, this.canonical = null;
+            };
+            Ko.prototype.id = function() {
+              return this.feature && "id" in this.feature ? this.feature.id : null;
+            }, Ko.prototype.geometryType = function() {
+              return this.feature ? typeof this.feature.type == "number" ? sd[this.feature.type] : this.feature.type : null;
+            }, Ko.prototype.geometry = function() {
+              return this.feature && "geometry" in this.feature ? this.feature.geometry : null;
+            }, Ko.prototype.canonicalID = function() {
+              return this.canonical;
+            }, Ko.prototype.properties = function() {
+              return this.feature && this.feature.properties || {};
+            }, Ko.prototype.parseColor = function(y) {
+              var I = this._parseColorCache[y];
+              return I || (I = this._parseColorCache[y] = cs.parse(y)), I;
+            };
+            var Pa = function(y, I, V, $) {
+              this.name = y, this.type = I, this._evaluate = V, this.args = $;
+            };
+            Pa.prototype.evaluate = function(y) {
+              return this._evaluate(y, this.args);
+            }, Pa.prototype.eachChild = function(y) {
+              this.args.forEach(y);
+            }, Pa.prototype.outputDefined = function() {
+              return false;
+            }, Pa.prototype.serialize = function() {
+              return [this.name].concat(this.args.map(function(y) {
+                return y.serialize();
+              }));
+            }, Pa.parse = function(y, I) {
+              var V, $ = y[0], ae = Pa.definitions[$];
+              if (!ae) return I.error('Unknown expression "' + $ + '". If you wanted a literal array, use ["literal", [...]].', 0);
+              for (var he = Array.isArray(ae) ? ae[0] : ae.type, ze = Array.isArray(ae) ? [[ae[1], ae[2]]] : ae.overloads, rt = ze.filter(function(to) {
+                var ao = to[0];
+                return !Array.isArray(ao) || ao.length === y.length - 1;
+              }), gt = null, Et = 0, or = rt; Et < or.length; Et += 1) {
+                var _r = or[Et], pr = _r[0], Fr = _r[1];
+                gt = new ks(I.registry, I.path, null, I.scope);
+                for (var oi = [], Hi = false, Ai = 1; Ai < y.length; Ai++) {
+                  var bn = y[Ai], nn = Array.isArray(pr) ? pr[Ai - 1] : pr.type, xn = gt.parse(bn, 1 + oi.length, nn);
+                  if (!xn) {
+                    Hi = true;
+                    break;
+                  }
+                  oi.push(xn);
+                }
+                if (!Hi) {
+                  if (Array.isArray(pr) && pr.length !== oi.length) {
+                    gt.error("Expected " + pr.length + " arguments, but found " + oi.length + " instead.");
+                    continue;
+                  }
+                  for (var Pn = 0; Pn < oi.length; Pn++) {
+                    var Zn = Array.isArray(pr) ? pr[Pn] : pr.type, ga = oi[Pn];
+                    gt.concat(Pn + 1).checkSubtype(Zn, ga.type);
+                  }
+                  if (gt.errors.length === 0) return new Pa($, he, Fr, oi);
+                }
+              }
+              if (rt.length === 1) (V = I.errors).push.apply(V, gt.errors);
+              else {
+                for (var ha = rt.length ? rt : ze, eo = ha.map(function(to) {
+                  var ao = to[0];
+                  return af(ao);
+                }).join(" | "), za = [], Za = 1; Za < y.length; Za++) {
+                  var Jo = I.parse(y[Za], 1 + za.length);
+                  if (!Jo) return null;
+                  za.push(Os(Jo.type));
+                }
+                I.error("Expected arguments of type " + eo + ", but found (" + za.join(", ") + ") instead.");
+              }
+              return null;
+            }, Pa.register = function(y, I) {
+              Pa.definitions = I;
+              for (var V in I) y[V] = Pa;
+            };
+            function af(m) {
+              return Array.isArray(m) ? "(" + m.map(Os).join(", ") + ")" : "(" + Os(m.type) + "...)";
+            }
+            var Hu = function(y, I, V) {
+              this.type = Vf, this.locale = V, this.caseSensitive = y, this.diacriticSensitive = I;
+            };
+            Hu.parse = function(y, I) {
+              if (y.length !== 2) return I.error("Expected one argument.");
+              var V = y[1];
+              if (typeof V != "object" || Array.isArray(V)) return I.error("Collator options argument must be an object.");
+              var $ = I.parse(V["case-sensitive"] === void 0 ? false : V["case-sensitive"], 1, qo);
+              if (!$) return null;
+              var ae = I.parse(V["diacritic-sensitive"] === void 0 ? false : V["diacritic-sensitive"], 1, qo);
+              if (!ae) return null;
+              var he = null;
+              return V.locale && (he = I.parse(V.locale, 1, Oo), !he) ? null : new Hu($, ae, he);
+            }, Hu.prototype.evaluate = function(y) {
+              return new nf(this.caseSensitive.evaluate(y), this.diacriticSensitive.evaluate(y), this.locale ? this.locale.evaluate(y) : null);
+            }, Hu.prototype.eachChild = function(y) {
+              y(this.caseSensitive), y(this.diacriticSensitive), this.locale && y(this.locale);
+            }, Hu.prototype.outputDefined = function() {
+              return false;
+            }, Hu.prototype.serialize = function() {
+              var y = {};
+              return y["case-sensitive"] = this.caseSensitive.serialize(), y["diacritic-sensitive"] = this.diacriticSensitive.serialize(), this.locale && (y.locale = this.locale.serialize()), ["collator", y];
+            };
+            var bl = 8192;
+            function Hf(m, y) {
+              m[0] = Math.min(m[0], y[0]), m[1] = Math.min(m[1], y[1]), m[2] = Math.max(m[2], y[0]), m[3] = Math.max(m[3], y[1]);
+            }
+            function Ic(m) {
+              return (180 + m) / 360;
+            }
+            function yf(m) {
+              return (180 - 180 / Math.PI * Math.log(Math.tan(Math.PI / 4 + m * Math.PI / 360))) / 360;
+            }
+            function Bl(m, y) {
+              return !(m[0] <= y[0] || m[2] >= y[2] || m[1] <= y[1] || m[3] >= y[3]);
+            }
+            function Ah(m, y) {
+              var I = Ic(m[0]), V = yf(m[1]), $ = Math.pow(2, y.z);
+              return [Math.round(I * $ * bl), Math.round(V * $ * bl)];
+            }
+            function Qf(m, y, I) {
+              var V = m[0] - y[0], $ = m[1] - y[1], ae = m[0] - I[0], he = m[1] - I[1];
+              return V * he - ae * $ === 0 && V * ae <= 0 && $ * he <= 0;
+            }
+            function _f(m, y, I) {
+              return y[1] > m[1] != I[1] > m[1] && m[0] < (I[0] - y[0]) * (m[1] - y[1]) / (I[1] - y[1]) + y[0];
+            }
+            function Yc(m, y) {
+              for (var I = false, V = 0, $ = y.length; V < $; V++) for (var ae = y[V], he = 0, ze = ae.length; he < ze - 1; he++) {
+                if (Qf(m, ae[he], ae[he + 1])) return false;
+                _f(m, ae[he], ae[he + 1]) && (I = !I);
+              }
+              return I;
+            }
+            function eh(m, y) {
+              for (var I = 0; I < y.length; I++) if (Yc(m, y[I])) return true;
+              return false;
+            }
+            function th(m, y) {
+              return m[0] * y[1] - m[1] * y[0];
+            }
+            function ju(m, y, I, V) {
+              var $ = m[0] - I[0], ae = m[1] - I[1], he = y[0] - I[0], ze = y[1] - I[1], rt = V[0] - I[0], gt = V[1] - I[1], Et = $ * gt - rt * ae, or = he * gt - rt * ze;
+              return Et > 0 && or < 0 || Et < 0 && or > 0;
+            }
+            function jf(m, y, I, V) {
+              var $ = [y[0] - m[0], y[1] - m[1]], ae = [V[0] - I[0], V[1] - I[1]];
+              return th(ae, $) === 0 ? false : !!(ju(m, y, I, V) && ju(I, V, m, y));
+            }
+            function cc(m, y, I) {
+              for (var V = 0, $ = I; V < $.length; V += 1) for (var ae = $[V], he = 0; he < ae.length - 1; ++he) if (jf(m, y, ae[he], ae[he + 1])) return true;
+              return false;
+            }
+            function of(m, y) {
+              for (var I = 0; I < m.length; ++I) if (!Yc(m[I], y)) return false;
+              for (var V = 0; V < m.length - 1; ++V) if (cc(m[V], m[V + 1], y)) return false;
+              return true;
+            }
+            function Nl(m, y) {
+              for (var I = 0; I < y.length; I++) if (of(m, y[I])) return true;
+              return false;
+            }
+            function Kc(m, y, I) {
+              for (var V = [], $ = 0; $ < m.length; $++) {
+                for (var ae = [], he = 0; he < m[$].length; he++) {
+                  var ze = Ah(m[$][he], I);
+                  Hf(y, ze), ae.push(ze);
+                }
+                V.push(ae);
+              }
+              return V;
+            }
+            function Rc(m, y, I) {
+              for (var V = [], $ = 0; $ < m.length; $++) {
+                var ae = Kc(m[$], y, I);
+                V.push(ae);
+              }
+              return V;
+            }
+            function gs(m, y, I, V) {
+              if (m[0] < I[0] || m[0] > I[2]) {
+                var $ = V * 0.5, ae = m[0] - I[0] > $ ? -V : I[0] - m[0] > $ ? V : 0;
+                ae === 0 && (ae = m[0] - I[2] > $ ? -V : I[2] - m[0] > $ ? V : 0), m[0] += ae;
+              }
+              Hf(y, m);
+            }
+            function Wf(m) {
+              m[0] = m[1] = 1 / 0, m[2] = m[3] = -1 / 0;
+            }
+            function Wh(m, y, I, V) {
+              for (var $ = Math.pow(2, V.z) * bl, ae = [V.x * bl, V.y * bl], he = [], ze = 0, rt = m; ze < rt.length; ze += 1) for (var gt = rt[ze], Et = 0, or = gt; Et < or.length; Et += 1) {
+                var _r = or[Et], pr = [_r.x + ae[0], _r.y + ae[1]];
+                gs(pr, y, I, $), he.push(pr);
+              }
+              return he;
+            }
+            function rh(m, y, I, V) {
+              for (var $ = Math.pow(2, V.z) * bl, ae = [V.x * bl, V.y * bl], he = [], ze = 0, rt = m; ze < rt.length; ze += 1) {
+                for (var gt = rt[ze], Et = [], or = 0, _r = gt; or < _r.length; or += 1) {
+                  var pr = _r[or], Fr = [pr.x + ae[0], pr.y + ae[1]];
+                  Hf(y, Fr), Et.push(Fr);
+                }
+                he.push(Et);
+              }
+              if (y[2] - y[0] <= $ / 2) {
+                Wf(y);
+                for (var oi = 0, Hi = he; oi < Hi.length; oi += 1) for (var Ai = Hi[oi], bn = 0, nn = Ai; bn < nn.length; bn += 1) {
+                  var xn = nn[bn];
+                  gs(xn, y, I, $);
+                }
+              }
+              return he;
+            }
+            function sf(m, y) {
+              var I = [1 / 0, 1 / 0, -1 / 0, -1 / 0], V = [1 / 0, 1 / 0, -1 / 0, -1 / 0], $ = m.canonicalID();
+              if (y.type === "Polygon") {
+                var ae = Kc(y.coordinates, V, $), he = Wh(m.geometry(), I, V, $);
+                if (!Bl(I, V)) return false;
+                for (var ze = 0, rt = he; ze < rt.length; ze += 1) {
+                  var gt = rt[ze];
+                  if (!Yc(gt, ae)) return false;
+                }
+              }
+              if (y.type === "MultiPolygon") {
+                var Et = Rc(y.coordinates, V, $), or = Wh(m.geometry(), I, V, $);
+                if (!Bl(I, V)) return false;
+                for (var _r = 0, pr = or; _r < pr.length; _r += 1) {
+                  var Fr = pr[_r];
+                  if (!eh(Fr, Et)) return false;
+                }
+              }
+              return true;
+            }
+            function Sh(m, y) {
+              var I = [1 / 0, 1 / 0, -1 / 0, -1 / 0], V = [1 / 0, 1 / 0, -1 / 0, -1 / 0], $ = m.canonicalID();
+              if (y.type === "Polygon") {
+                var ae = Kc(y.coordinates, V, $), he = rh(m.geometry(), I, V, $);
+                if (!Bl(I, V)) return false;
+                for (var ze = 0, rt = he; ze < rt.length; ze += 1) {
+                  var gt = rt[ze];
+                  if (!of(gt, ae)) return false;
+                }
+              }
+              if (y.type === "MultiPolygon") {
+                var Et = Rc(y.coordinates, V, $), or = rh(m.geometry(), I, V, $);
+                if (!Bl(I, V)) return false;
+                for (var _r = 0, pr = or; _r < pr.length; _r += 1) {
+                  var Fr = pr[_r];
+                  if (!Nl(Fr, Et)) return false;
+                }
+              }
+              return true;
+            }
+            var Mu = function(y, I) {
+              this.type = qo, this.geojson = y, this.geometries = I;
+            };
+            Mu.parse = function(y, I) {
+              if (y.length !== 2) return I.error("'within' expression requires exactly one argument, but found " + (y.length - 1) + " instead.");
+              if (Fu(y[1])) {
+                var V = y[1];
+                if (V.type === "FeatureCollection") for (var $ = 0; $ < V.features.length; ++$) {
+                  var ae = V.features[$].geometry.type;
+                  if (ae === "Polygon" || ae === "MultiPolygon") return new Mu(V, V.features[$].geometry);
+                }
+                else if (V.type === "Feature") {
+                  var he = V.geometry.type;
+                  if (he === "Polygon" || he === "MultiPolygon") return new Mu(V, V.geometry);
+                } else if (V.type === "Polygon" || V.type === "MultiPolygon") return new Mu(V, V);
+              }
+              return I.error("'within' expression requires valid geojson object that contains polygon geometry type.");
+            }, Mu.prototype.evaluate = function(y) {
+              if (y.geometry() != null && y.canonicalID() != null) {
+                if (y.geometryType() === "Point") return sf(y, this.geometries);
+                if (y.geometryType() === "LineString") return Sh(y, this.geometries);
+              }
+              return false;
+            }, Mu.prototype.eachChild = function() {
+            }, Mu.prototype.outputDefined = function() {
+              return true;
+            }, Mu.prototype.serialize = function() {
+              return ["within", this.geojson];
+            };
+            function ih(m) {
+              if (m instanceof Pa) {
+                if (m.name === "get" && m.args.length === 1) return false;
+                if (m.name === "feature-state") return false;
+                if (m.name === "has" && m.args.length === 1) return false;
+                if (m.name === "properties" || m.name === "geometry-type" || m.name === "id") return false;
+                if (/^filter-/.test(m.name)) return false;
+              }
+              if (m instanceof Mu) return false;
+              var y = true;
+              return m.eachChild(function(I) {
+                y && !ih(I) && (y = false);
+              }), y;
+            }
+            function js(m) {
+              if (m instanceof Pa && m.name === "feature-state") return false;
+              var y = true;
+              return m.eachChild(function(I) {
+                y && !js(I) && (y = false);
+              }), y;
+            }
+            function Eu(m, y) {
+              if (m instanceof Pa && y.indexOf(m.name) >= 0) return false;
+              var I = true;
+              return m.eachChild(function(V) {
+                I && !Eu(V, y) && (I = false);
+              }), I;
+            }
+            var Dc = function(y, I) {
+              this.type = I.type, this.name = y, this.boundExpression = I;
+            };
+            Dc.parse = function(y, I) {
+              if (y.length !== 2 || typeof y[1] != "string") return I.error("'var' expression requires exactly one string literal argument.");
+              var V = y[1];
+              return I.scope.has(V) ? new Dc(V, I.scope.get(V)) : I.error('Unknown variable "' + V + '". Make sure "' + V + '" has been bound in an enclosing "let" expression before using it.', 1);
+            }, Dc.prototype.evaluate = function(y) {
+              return this.boundExpression.evaluate(y);
+            }, Dc.prototype.eachChild = function() {
+            }, Dc.prototype.outputDefined = function() {
+              return false;
+            }, Dc.prototype.serialize = function() {
+              return ["var", this.name];
+            };
+            var ks = function(y, I, V, $, ae) {
+              I === void 0 && (I = []), $ === void 0 && ($ = new Hl()), ae === void 0 && (ae = []), this.registry = y, this.path = I, this.key = I.map(function(he) {
+                return "[" + he + "]";
+              }).join(""), this.scope = $, this.errors = ae, this.expectedType = V;
+            };
+            ks.prototype.parse = function(y, I, V, $, ae) {
+              return ae === void 0 && (ae = {}), I ? this.concat(I, V, $)._parse(y, ae) : this._parse(y, ae);
+            }, ks.prototype._parse = function(y, I) {
+              (y === null || typeof y == "string" || typeof y == "boolean" || typeof y == "number") && (y = ["literal", y]);
+              function V(Et, or, _r) {
+                return _r === "assert" ? new xl(or, [Et]) : _r === "coerce" ? new Po(or, [Et]) : Et;
+              }
+              if (Array.isArray(y)) {
+                if (y.length === 0) return this.error('Expected an array with at least one element. If you wanted a literal array, use ["literal", []].');
+                var $ = y[0];
+                if (typeof $ != "string") return this.error("Expression name must be a string, but found " + typeof $ + ' instead. If you wanted a literal array, use ["literal", [...]].', 0), null;
+                var ae = this.registry[$];
+                if (ae) {
+                  var he = ae.parse(y, this);
+                  if (!he) return null;
+                  if (this.expectedType) {
+                    var ze = this.expectedType, rt = he.type;
+                    if ((ze.kind === "string" || ze.kind === "number" || ze.kind === "boolean" || ze.kind === "object" || ze.kind === "array") && rt.kind === "value") he = V(he, ze, I.typeAnnotation || "assert");
+                    else if ((ze.kind === "color" || ze.kind === "formatted" || ze.kind === "resolvedImage") && (rt.kind === "value" || rt.kind === "string")) he = V(he, ze, I.typeAnnotation || "coerce");
+                    else if (this.checkSubtype(ze, rt)) return null;
+                  }
+                  if (!(he instanceof Go) && he.type.kind !== "resolvedImage" && bc(he)) {
+                    var gt = new Ko();
+                    try {
+                      he = new Go(he.type, he.evaluate(gt));
+                    } catch (Et) {
+                      return this.error(Et.message), null;
+                    }
+                  }
+                  return he;
+                }
+                return this.error('Unknown expression "' + $ + '". If you wanted a literal array, use ["literal", [...]].', 0);
+              } else return typeof y == "undefined" ? this.error("'undefined' value invalid. Use null instead.") : typeof y == "object" ? this.error('Bare objects invalid. Use ["literal", {...}] instead.') : this.error("Expected an array, but found " + typeof y + " instead.");
+            }, ks.prototype.concat = function(y, I, V) {
+              var $ = typeof y == "number" ? this.path.concat(y) : this.path, ae = V ? this.scope.concat(V) : this.scope;
+              return new ks(this.registry, $, I || null, ae, this.errors);
+            }, ks.prototype.error = function(y) {
+              for (var I = [], V = arguments.length - 1; V-- > 0; ) I[V] = arguments[V + 1];
+              var $ = "" + this.key + I.map(function(ae) {
+                return "[" + ae + "]";
+              }).join("");
+              this.errors.push(new Ns($, y));
+            }, ks.prototype.checkSubtype = function(y, I) {
+              var V = oc(y, I);
+              return V && this.error(V), V;
+            };
+            function bc(m) {
+              if (m instanceof Dc) return bc(m.boundExpression);
+              if (m instanceof Pa && m.name === "error") return false;
+              if (m instanceof Hu) return false;
+              if (m instanceof Mu) return false;
+              var y = m instanceof Po || m instanceof xl, I = true;
+              return m.eachChild(function(V) {
+                y ? I = I && bc(V) : I = I && V instanceof Go;
+              }), I ? ih(m) && Eu(m, ["zoom", "heatmap-density", "line-progress", "accumulated", "is-supported-script"]) : false;
+            }
+            function hu(m, y) {
+              for (var I = m.length - 1, V = 0, $ = I, ae = 0, he, ze; V <= $; ) if (ae = Math.floor((V + $) / 2), he = m[ae], ze = m[ae + 1], he <= y) {
+                if (ae === I || y < ze) return ae;
+                V = ae + 1;
+              } else if (he > y) $ = ae - 1;
+              else throw new ps("Input is not a number.");
+              return 0;
+            }
+            var _u = function(y, I, V) {
+              this.type = y, this.input = I, this.labels = [], this.outputs = [];
+              for (var $ = 0, ae = V; $ < ae.length; $ += 1) {
+                var he = ae[$], ze = he[0], rt = he[1];
+                this.labels.push(ze), this.outputs.push(rt);
+              }
+            };
+            _u.parse = function(y, I) {
+              if (y.length - 1 < 4) return I.error("Expected at least 4 arguments, but found only " + (y.length - 1) + ".");
+              if ((y.length - 1) % 2 !== 0) return I.error("Expected an even number of arguments.");
+              var V = I.parse(y[1], 1, aa);
+              if (!V) return null;
+              var $ = [], ae = null;
+              I.expectedType && I.expectedType.kind !== "value" && (ae = I.expectedType);
+              for (var he = 1; he < y.length; he += 2) {
+                var ze = he === 1 ? -1 / 0 : y[he], rt = y[he + 1], gt = he, Et = he + 1;
+                if (typeof ze != "number") return I.error('Input/output pairs for "step" expressions must be defined using literal numeric values (not computed expressions) for the input values.', gt);
+                if ($.length && $[$.length - 1][0] >= ze) return I.error('Input/output pairs for "step" expressions must be arranged with input values in strictly ascending order.', gt);
+                var or = I.parse(rt, Et, ae);
+                if (!or) return null;
+                ae = ae || or.type, $.push([ze, or]);
+              }
+              return new _u(ae, V, $);
+            }, _u.prototype.evaluate = function(y) {
+              var I = this.labels, V = this.outputs;
+              if (I.length === 1) return V[0].evaluate(y);
+              var $ = this.input.evaluate(y);
+              if ($ <= I[0]) return V[0].evaluate(y);
+              var ae = I.length;
+              if ($ >= I[ae - 1]) return V[ae - 1].evaluate(y);
+              var he = hu(I, $);
+              return V[he].evaluate(y);
+            }, _u.prototype.eachChild = function(y) {
+              y(this.input);
+              for (var I = 0, V = this.outputs; I < V.length; I += 1) {
+                var $ = V[I];
+                y($);
+              }
+            }, _u.prototype.outputDefined = function() {
+              return this.outputs.every(function(y) {
+                return y.outputDefined();
+              });
+            }, _u.prototype.serialize = function() {
+              for (var y = ["step", this.input.serialize()], I = 0; I < this.labels.length; I++) I > 0 && y.push(this.labels[I]), y.push(this.outputs[I].serialize());
+              return y;
+            };
+            function nl(m, y, I) {
+              return m * (1 - I) + y * I;
+            }
+            function nh(m, y, I) {
+              return new cs(nl(m.r, y.r, I), nl(m.g, y.g, I), nl(m.b, y.b, I), nl(m.a, y.a, I));
+            }
+            function Mh(m, y, I) {
+              return m.map(function(V, $) {
+                return nl(V, y[$], I);
+              });
+            }
+            var zu = Object.freeze({ __proto__: null, number: nl, color: nh, array: Mh }), Fc = 0.95047, wc = 1, bd = 1.08883, xf = 4 / 29, Pf = 6 / 29, Ou = 3 * Pf * Pf, bf = Pf * Pf * Pf, jl = Math.PI / 180, lf = 180 / Math.PI;
+            function Xh(m) {
+              return m > bf ? Math.pow(m, 1 / 3) : m / Ou + xf;
+            }
+            function If(m) {
+              return m > Pf ? m * m * m : Ou * (m - xf);
+            }
+            function Cs(m) {
+              return 255 * (m <= 31308e-7 ? 12.92 * m : 1.055 * Math.pow(m, 1 / 2.4) - 0.055);
+            }
+            function du(m) {
+              return m /= 255, m <= 0.04045 ? m / 12.92 : Math.pow((m + 0.055) / 1.055, 2.4);
+            }
+            function ku(m) {
+              var y = du(m.r), I = du(m.g), V = du(m.b), $ = Xh((0.4124564 * y + 0.3575761 * I + 0.1804375 * V) / Fc), ae = Xh((0.2126729 * y + 0.7151522 * I + 0.072175 * V) / wc), he = Xh((0.0193339 * y + 0.119192 * I + 0.9503041 * V) / bd);
+              return { l: 116 * ae - 16, a: 500 * ($ - ae), b: 200 * (ae - he), alpha: m.a };
+            }
+            function Xf(m) {
+              var y = (m.l + 16) / 116, I = isNaN(m.a) ? y : y + m.a / 500, V = isNaN(m.b) ? y : y - m.b / 200;
+              return y = wc * If(y), I = Fc * If(I), V = bd * If(V), new cs(Cs(3.2404542 * I - 1.5371385 * y - 0.4985314 * V), Cs(-0.969266 * I + 1.8760108 * y + 0.041556 * V), Cs(0.0556434 * I - 0.2040259 * y + 1.0572252 * V), m.alpha);
+            }
+            function Us(m, y, I) {
+              return { l: nl(m.l, y.l, I), a: nl(m.a, y.a, I), b: nl(m.b, y.b, I), alpha: nl(m.alpha, y.alpha, I) };
+            }
+            function wf(m) {
+              var y = ku(m), I = y.l, V = y.a, $ = y.b, ae = Math.atan2($, V) * lf;
+              return { h: ae < 0 ? ae + 360 : ae, c: Math.sqrt(V * V + $ * $), l: I, alpha: m.a };
+            }
+            function zc(m) {
+              var y = m.h * jl, I = m.c, V = m.l;
+              return Xf({ l: V, a: Math.cos(y) * I, b: Math.sin(y) * I, alpha: m.alpha });
+            }
+            function Wu(m, y, I) {
+              var V = y - m;
+              return m + I * (V > 180 || V < -180 ? V - 360 * Math.round(V / 360) : V);
+            }
+            function Rf(m, y, I) {
+              return { h: Wu(m.h, y.h, I), c: nl(m.c, y.c, I), l: nl(m.l, y.l, I), alpha: nl(m.alpha, y.alpha, I) };
+            }
+            var Xu = { forward: ku, reverse: Xf, interpolate: Us }, uf = { forward: wf, reverse: zc, interpolate: Rf }, Zf = Object.freeze({ __proto__: null, lab: Xu, hcl: uf }), Wl = function(y, I, V, $, ae) {
+              this.type = y, this.operator = I, this.interpolation = V, this.input = $, this.labels = [], this.outputs = [];
+              for (var he = 0, ze = ae; he < ze.length; he += 1) {
+                var rt = ze[he], gt = rt[0], Et = rt[1];
+                this.labels.push(gt), this.outputs.push(Et);
+              }
+            };
+            Wl.interpolationFactor = function(y, I, V, $) {
+              var ae = 0;
+              if (y.name === "exponential") ae = ah(I, y.base, V, $);
+              else if (y.name === "linear") ae = ah(I, 1, V, $);
+              else if (y.name === "cubic-bezier") {
+                var he = y.controlPoints, ze = new s(he[0], he[1], he[2], he[3]);
+                ae = ze.solve(ah(I, 1, V, $));
+              }
+              return ae;
+            }, Wl.parse = function(y, I) {
+              var V = y[0], $ = y[1], ae = y[2], he = y.slice(3);
+              if (!Array.isArray($) || $.length === 0) return I.error("Expected an interpolation type expression.", 1);
+              if ($[0] === "linear") $ = { name: "linear" };
+              else if ($[0] === "exponential") {
+                var ze = $[1];
+                if (typeof ze != "number") return I.error("Exponential interpolation requires a numeric base.", 1, 1);
+                $ = { name: "exponential", base: ze };
+              } else if ($[0] === "cubic-bezier") {
+                var rt = $.slice(1);
+                if (rt.length !== 4 || rt.some(function(Ai) {
+                  return typeof Ai != "number" || Ai < 0 || Ai > 1;
+                })) return I.error("Cubic bezier interpolation requires four numeric arguments with values between 0 and 1.", 1);
+                $ = { name: "cubic-bezier", controlPoints: rt };
+              } else return I.error("Unknown interpolation type " + String($[0]), 1, 0);
+              if (y.length - 1 < 4) return I.error("Expected at least 4 arguments, but found only " + (y.length - 1) + ".");
+              if ((y.length - 1) % 2 !== 0) return I.error("Expected an even number of arguments.");
+              if (ae = I.parse(ae, 2, aa), !ae) return null;
+              var gt = [], Et = null;
+              V === "interpolate-hcl" || V === "interpolate-lab" ? Et = ql : I.expectedType && I.expectedType.kind !== "value" && (Et = I.expectedType);
+              for (var or = 0; or < he.length; or += 2) {
+                var _r = he[or], pr = he[or + 1], Fr = or + 3, oi = or + 4;
+                if (typeof _r != "number") return I.error('Input/output pairs for "interpolate" expressions must be defined using literal numeric values (not computed expressions) for the input values.', Fr);
+                if (gt.length && gt[gt.length - 1][0] >= _r) return I.error('Input/output pairs for "interpolate" expressions must be arranged with input values in strictly ascending order.', Fr);
+                var Hi = I.parse(pr, oi, Et);
+                if (!Hi) return null;
+                Et = Et || Hi.type, gt.push([_r, Hi]);
+              }
+              return Et.kind !== "number" && Et.kind !== "color" && !(Et.kind === "array" && Et.itemType.kind === "number" && typeof Et.N == "number") ? I.error("Type " + Os(Et) + " is not interpolatable.") : new Wl(Et, V, $, ae, gt);
+            }, Wl.prototype.evaluate = function(y) {
+              var I = this.labels, V = this.outputs;
+              if (I.length === 1) return V[0].evaluate(y);
+              var $ = this.input.evaluate(y);
+              if ($ <= I[0]) return V[0].evaluate(y);
+              var ae = I.length;
+              if ($ >= I[ae - 1]) return V[ae - 1].evaluate(y);
+              var he = hu(I, $), ze = I[he], rt = I[he + 1], gt = Wl.interpolationFactor(this.interpolation, $, ze, rt), Et = V[he].evaluate(y), or = V[he + 1].evaluate(y);
+              return this.operator === "interpolate" ? zu[this.type.kind.toLowerCase()](Et, or, gt) : this.operator === "interpolate-hcl" ? uf.reverse(uf.interpolate(uf.forward(Et), uf.forward(or), gt)) : Xu.reverse(Xu.interpolate(Xu.forward(Et), Xu.forward(or), gt));
+            }, Wl.prototype.eachChild = function(y) {
+              y(this.input);
+              for (var I = 0, V = this.outputs; I < V.length; I += 1) {
+                var $ = V[I];
+                y($);
+              }
+            }, Wl.prototype.outputDefined = function() {
+              return this.outputs.every(function(y) {
+                return y.outputDefined();
+              });
+            }, Wl.prototype.serialize = function() {
+              var y;
+              this.interpolation.name === "linear" ? y = ["linear"] : this.interpolation.name === "exponential" ? this.interpolation.base === 1 ? y = ["linear"] : y = ["exponential", this.interpolation.base] : y = ["cubic-bezier"].concat(this.interpolation.controlPoints);
+              for (var I = [this.operator, y, this.input.serialize()], V = 0; V < this.labels.length; V++) I.push(this.labels[V], this.outputs[V].serialize());
+              return I;
+            };
+            function ah(m, y, I, V) {
+              var $ = V - I, ae = m - I;
+              return $ === 0 ? 0 : y === 1 ? ae / $ : (Math.pow(y, ae) - 1) / (Math.pow(y, $) - 1);
+            }
+            var Zu = function(y, I) {
+              this.type = y, this.args = I;
+            };
+            Zu.parse = function(y, I) {
+              if (y.length < 2) return I.error("Expectected at least one argument.");
+              var V = null, $ = I.expectedType;
+              $ && $.kind !== "value" && (V = $);
+              for (var ae = [], he = 0, ze = y.slice(1); he < ze.length; he += 1) {
+                var rt = ze[he], gt = I.parse(rt, 1 + ae.length, V, void 0, { typeAnnotation: "omit" });
+                if (!gt) return null;
+                V = V || gt.type, ae.push(gt);
+              }
+              var Et = $ && ae.some(function(or) {
+                return oc($, or.type);
+              });
+              return Et ? new Zu(Do, ae) : new Zu(V, ae);
+            }, Zu.prototype.evaluate = function(y) {
+              for (var I = null, V = 0, $, ae = 0, he = this.args; ae < he.length; ae += 1) {
+                var ze = he[ae];
+                if (V++, I = ze.evaluate(y), I && I instanceof fl && !I.available && ($ || ($ = I.name), I = null, V === this.args.length && (I = $)), I !== null) break;
+              }
+              return I;
+            }, Zu.prototype.eachChild = function(y) {
+              this.args.forEach(y);
+            }, Zu.prototype.outputDefined = function() {
+              return this.args.every(function(y) {
+                return y.outputDefined();
+              });
+            }, Zu.prototype.serialize = function() {
+              var y = ["coalesce"];
+              return this.eachChild(function(I) {
+                y.push(I.serialize());
+              }), y;
+            };
+            var Oc = function(y, I) {
+              this.type = I.type, this.bindings = [].concat(y), this.result = I;
+            };
+            Oc.prototype.evaluate = function(y) {
+              return this.result.evaluate(y);
+            }, Oc.prototype.eachChild = function(y) {
+              for (var I = 0, V = this.bindings; I < V.length; I += 1) {
+                var $ = V[I];
+                y($[1]);
+              }
+              y(this.result);
+            }, Oc.parse = function(y, I) {
+              if (y.length < 4) return I.error("Expected at least 3 arguments, but found " + (y.length - 1) + " instead.");
+              for (var V = [], $ = 1; $ < y.length - 1; $ += 2) {
+                var ae = y[$];
+                if (typeof ae != "string") return I.error("Expected string, but found " + typeof ae + " instead.", $);
+                if (/[^a-zA-Z0-9_]/.test(ae)) return I.error("Variable names must contain only alphanumeric characters or '_'.", $);
+                var he = I.parse(y[$ + 1], $ + 1);
+                if (!he) return null;
+                V.push([ae, he]);
+              }
+              var ze = I.parse(y[y.length - 1], y.length - 1, I.expectedType, V);
+              return ze ? new Oc(V, ze) : null;
+            }, Oc.prototype.outputDefined = function() {
+              return this.result.outputDefined();
+            }, Oc.prototype.serialize = function() {
+              for (var y = ["let"], I = 0, V = this.bindings; I < V.length; I += 1) {
+                var $ = V[I], ae = $[0], he = $[1];
+                y.push(ae, he.serialize());
+              }
+              return y.push(this.result.serialize()), y;
+            };
+            var Tc = function(y, I, V) {
+              this.type = y, this.index = I, this.input = V;
+            };
+            Tc.parse = function(y, I) {
+              if (y.length !== 3) return I.error("Expected 2 arguments, but found " + (y.length - 1) + " instead.");
+              var V = I.parse(y[1], 1, aa), $ = I.parse(y[2], 2, Jl(I.expectedType || Do));
+              if (!V || !$) return null;
+              var ae = $.type;
+              return new Tc(ae.itemType, V, $);
+            }, Tc.prototype.evaluate = function(y) {
+              var I = this.index.evaluate(y), V = this.input.evaluate(y);
+              if (I < 0) throw new ps("Array index out of bounds: " + I + " < 0.");
+              if (I >= V.length) throw new ps("Array index out of bounds: " + I + " > " + (V.length - 1) + ".");
+              if (I !== Math.floor(I)) throw new ps("Array index must be an integer, but found " + I + " instead.");
+              return V[I];
+            }, Tc.prototype.eachChild = function(y) {
+              y(this.index), y(this.input);
+            }, Tc.prototype.outputDefined = function() {
+              return false;
+            }, Tc.prototype.serialize = function() {
+              return ["at", this.index.serialize(), this.input.serialize()];
+            };
+            var wl = function(y, I) {
+              this.type = qo, this.needle = y, this.haystack = I;
+            };
+            wl.parse = function(y, I) {
+              if (y.length !== 3) return I.error("Expected 2 arguments, but found " + (y.length - 1) + " instead.");
+              var V = I.parse(y[1], 1, Do), $ = I.parse(y[2], 2, Do);
+              return !V || !$ ? null : Cf(V.type, [qo, Oo, aa, ac, Do]) ? new wl(V, $) : I.error("Expected first argument to be of type boolean, string, number or null, but found " + Os(V.type) + " instead");
+            }, wl.prototype.evaluate = function(y) {
+              var I = this.needle.evaluate(y), V = this.haystack.evaluate(y);
+              if (!V) return false;
+              if (!sc(I, ["boolean", "string", "number", "null"])) throw new ps("Expected first argument to be of type boolean, string, number or null, but found " + Os(Es(I)) + " instead.");
+              if (!sc(V, ["string", "array"])) throw new ps("Expected second argument to be of type array or string, but found " + Os(Es(V)) + " instead.");
+              return V.indexOf(I) >= 0;
+            }, wl.prototype.eachChild = function(y) {
+              y(this.needle), y(this.haystack);
+            }, wl.prototype.outputDefined = function() {
+              return true;
+            }, wl.prototype.serialize = function() {
+              return ["in", this.needle.serialize(), this.haystack.serialize()];
+            };
+            var vu = function(y, I, V) {
+              this.type = aa, this.needle = y, this.haystack = I, this.fromIndex = V;
+            };
+            vu.parse = function(y, I) {
+              if (y.length <= 2 || y.length >= 5) return I.error("Expected 3 or 4 arguments, but found " + (y.length - 1) + " instead.");
+              var V = I.parse(y[1], 1, Do), $ = I.parse(y[2], 2, Do);
+              if (!V || !$) return null;
+              if (!Cf(V.type, [qo, Oo, aa, ac, Do])) return I.error("Expected first argument to be of type boolean, string, number or null, but found " + Os(V.type) + " instead");
+              if (y.length === 4) {
+                var ae = I.parse(y[3], 3, aa);
+                return ae ? new vu(V, $, ae) : null;
+              } else return new vu(V, $);
+            }, vu.prototype.evaluate = function(y) {
+              var I = this.needle.evaluate(y), V = this.haystack.evaluate(y);
+              if (!sc(I, ["boolean", "string", "number", "null"])) throw new ps("Expected first argument to be of type boolean, string, number or null, but found " + Os(Es(I)) + " instead.");
+              if (!sc(V, ["string", "array"])) throw new ps("Expected second argument to be of type array or string, but found " + Os(Es(V)) + " instead.");
+              if (this.fromIndex) {
+                var $ = this.fromIndex.evaluate(y);
+                return V.indexOf(I, $);
+              }
+              return V.indexOf(I);
+            }, vu.prototype.eachChild = function(y) {
+              y(this.needle), y(this.haystack), this.fromIndex && y(this.fromIndex);
+            }, vu.prototype.outputDefined = function() {
+              return false;
+            }, vu.prototype.serialize = function() {
+              if (this.fromIndex != null && this.fromIndex !== void 0) {
+                var y = this.fromIndex.serialize();
+                return ["index-of", this.needle.serialize(), this.haystack.serialize(), y];
+              }
+              return ["index-of", this.needle.serialize(), this.haystack.serialize()];
+            };
+            var qc = function(y, I, V, $, ae, he) {
+              this.inputType = y, this.type = I, this.input = V, this.cases = $, this.outputs = ae, this.otherwise = he;
+            };
+            qc.parse = function(y, I) {
+              if (y.length < 5) return I.error("Expected at least 4 arguments, but found only " + (y.length - 1) + ".");
+              if (y.length % 2 !== 1) return I.error("Expected an even number of arguments.");
+              var V, $;
+              I.expectedType && I.expectedType.kind !== "value" && ($ = I.expectedType);
+              for (var ae = {}, he = [], ze = 2; ze < y.length - 1; ze += 2) {
+                var rt = y[ze], gt = y[ze + 1];
+                Array.isArray(rt) || (rt = [rt]);
+                var Et = I.concat(ze);
+                if (rt.length === 0) return Et.error("Expected at least one branch label.");
+                for (var or = 0, _r = rt; or < _r.length; or += 1) {
+                  var pr = _r[or];
+                  if (typeof pr != "number" && typeof pr != "string") return Et.error("Branch labels must be numbers or strings.");
+                  if (typeof pr == "number" && Math.abs(pr) > Number.MAX_SAFE_INTEGER) return Et.error("Branch labels must be integers no larger than " + Number.MAX_SAFE_INTEGER + ".");
+                  if (typeof pr == "number" && Math.floor(pr) !== pr) return Et.error("Numeric branch labels must be integer values.");
+                  if (!V) V = Es(pr);
+                  else if (Et.checkSubtype(V, Es(pr))) return null;
+                  if (typeof ae[String(pr)] != "undefined") return Et.error("Branch labels must be unique.");
+                  ae[String(pr)] = he.length;
+                }
+                var Fr = I.parse(gt, ze, $);
+                if (!Fr) return null;
+                $ = $ || Fr.type, he.push(Fr);
+              }
+              var oi = I.parse(y[1], 1, Do);
+              if (!oi) return null;
+              var Hi = I.parse(y[y.length - 1], y.length - 1, $);
+              return !Hi || oi.type.kind !== "value" && I.concat(1).checkSubtype(V, oi.type) ? null : new qc(V, $, oi, ae, he, Hi);
+            }, qc.prototype.evaluate = function(y) {
+              var I = this.input.evaluate(y), V = Es(I) === this.inputType && this.outputs[this.cases[I]] || this.otherwise;
+              return V.evaluate(y);
+            }, qc.prototype.eachChild = function(y) {
+              y(this.input), this.outputs.forEach(y), y(this.otherwise);
+            }, qc.prototype.outputDefined = function() {
+              return this.outputs.every(function(y) {
+                return y.outputDefined();
+              }) && this.otherwise.outputDefined();
+            }, qc.prototype.serialize = function() {
+              for (var y = this, I = ["match", this.input.serialize()], V = Object.keys(this.cases).sort(), $ = [], ae = {}, he = 0, ze = V; he < ze.length; he += 1) {
+                var rt = ze[he], gt = ae[this.cases[rt]];
+                gt === void 0 ? (ae[this.cases[rt]] = $.length, $.push([this.cases[rt], [rt]])) : $[gt][1].push(rt);
+              }
+              for (var Et = function(oi) {
+                return y.inputType.kind === "number" ? Number(oi) : oi;
+              }, or = 0, _r = $; or < _r.length; or += 1) {
+                var pr = _r[or], gt = pr[0], Fr = pr[1];
+                Fr.length === 1 ? I.push(Et(Fr[0])) : I.push(Fr.map(Et)), I.push(this.outputs[outputIndex$1].serialize());
+              }
+              return I.push(this.otherwise.serialize()), I;
+            };
+            var cf = function(y, I, V) {
+              this.type = y, this.branches = I, this.otherwise = V;
+            };
+            cf.parse = function(y, I) {
+              if (y.length < 4) return I.error("Expected at least 3 arguments, but found only " + (y.length - 1) + ".");
+              if (y.length % 2 !== 0) return I.error("Expected an odd number of arguments.");
+              var V;
+              I.expectedType && I.expectedType.kind !== "value" && (V = I.expectedType);
+              for (var $ = [], ae = 1; ae < y.length - 1; ae += 2) {
+                var he = I.parse(y[ae], ae, qo);
+                if (!he) return null;
+                var ze = I.parse(y[ae + 1], ae + 1, V);
+                if (!ze) return null;
+                $.push([he, ze]), V = V || ze.type;
+              }
+              var rt = I.parse(y[y.length - 1], y.length - 1, V);
+              return rt ? new cf(V, $, rt) : null;
+            }, cf.prototype.evaluate = function(y) {
+              for (var I = 0, V = this.branches; I < V.length; I += 1) {
+                var $ = V[I], ae = $[0], he = $[1];
+                if (ae.evaluate(y)) return he.evaluate(y);
+              }
+              return this.otherwise.evaluate(y);
+            }, cf.prototype.eachChild = function(y) {
+              for (var I = 0, V = this.branches; I < V.length; I += 1) {
+                var $ = V[I], ae = $[0], he = $[1];
+                y(ae), y(he);
+              }
+              y(this.otherwise);
+            }, cf.prototype.outputDefined = function() {
+              return this.branches.every(function(y) {
+                y[0];
+                var V = y[1];
+                return V.outputDefined();
+              }) && this.otherwise.outputDefined();
+            }, cf.prototype.serialize = function() {
+              var y = ["case"];
+              return this.eachChild(function(I) {
+                y.push(I.serialize());
+              }), y;
+            };
+            var fc = function(y, I, V, $) {
+              this.type = y, this.input = I, this.beginIndex = V, this.endIndex = $;
+            };
+            fc.parse = function(y, I) {
+              if (y.length <= 2 || y.length >= 5) return I.error("Expected 3 or 4 arguments, but found " + (y.length - 1) + " instead.");
+              var V = I.parse(y[1], 1, Do), $ = I.parse(y[2], 2, aa);
+              if (!V || !$) return null;
+              if (!Cf(V.type, [Jl(Do), Oo, Do])) return I.error("Expected first argument to be of type array or string, but found " + Os(V.type) + " instead");
+              if (y.length === 4) {
+                var ae = I.parse(y[3], 3, aa);
+                return ae ? new fc(V.type, V, $, ae) : null;
+              } else return new fc(V.type, V, $);
+            }, fc.prototype.evaluate = function(y) {
+              var I = this.input.evaluate(y), V = this.beginIndex.evaluate(y);
+              if (!sc(I, ["string", "array"])) throw new ps("Expected first argument to be of type array or string, but found " + Os(Es(I)) + " instead.");
+              if (this.endIndex) {
+                var $ = this.endIndex.evaluate(y);
+                return I.slice(V, $);
+              }
+              return I.slice(V);
+            }, fc.prototype.eachChild = function(y) {
+              y(this.input), y(this.beginIndex), this.endIndex && y(this.endIndex);
+            }, fc.prototype.outputDefined = function() {
+              return false;
+            }, fc.prototype.serialize = function() {
+              if (this.endIndex != null && this.endIndex !== void 0) {
+                var y = this.endIndex.serialize();
+                return ["slice", this.input.serialize(), this.beginIndex.serialize(), y];
+              }
+              return ["slice", this.input.serialize(), this.beginIndex.serialize()];
+            };
+            function Bc(m, y) {
+              return m === "==" || m === "!=" ? y.kind === "boolean" || y.kind === "string" || y.kind === "number" || y.kind === "null" || y.kind === "value" : y.kind === "string" || y.kind === "number" || y.kind === "value";
+            }
+            function At(m, y, I) {
+              return y === I;
+            }
+            function Xt(m, y, I) {
+              return y !== I;
+            }
+            function Cr(m, y, I) {
+              return y < I;
+            }
+            function Ar(m, y, I) {
+              return y > I;
+            }
+            function Kr(m, y, I) {
+              return y <= I;
+            }
+            function ki(m, y, I) {
+              return y >= I;
+            }
+            function Xi(m, y, I, V) {
+              return V.compare(y, I) === 0;
+            }
+            function dn(m, y, I, V) {
+              return !Xi(m, y, I, V);
+            }
+            function wn(m, y, I, V) {
+              return V.compare(y, I) < 0;
+            }
+            function Nn(m, y, I, V) {
+              return V.compare(y, I) > 0;
+            }
+            function Yi(m, y, I, V) {
+              return V.compare(y, I) <= 0;
+            }
+            function Qi(m, y, I, V) {
+              return V.compare(y, I) >= 0;
+            }
+            function on(m, y, I) {
+              var V = m !== "==" && m !== "!=";
+              return function() {
+                function $(ae, he, ze) {
+                  this.type = qo, this.lhs = ae, this.rhs = he, this.collator = ze, this.hasUntypedArgument = ae.type.kind === "value" || he.type.kind === "value";
+                }
+                return $.parse = function(he, ze) {
+                  if (he.length !== 3 && he.length !== 4) return ze.error("Expected two or three arguments.");
+                  var rt = he[0], gt = ze.parse(he[1], 1, Do);
+                  if (!gt) return null;
+                  if (!Bc(rt, gt.type)) return ze.concat(1).error('"' + rt + `" comparisons are not supported for type '` + Os(gt.type) + "'.");
+                  var Et = ze.parse(he[2], 2, Do);
+                  if (!Et) return null;
+                  if (!Bc(rt, Et.type)) return ze.concat(2).error('"' + rt + `" comparisons are not supported for type '` + Os(Et.type) + "'.");
+                  if (gt.type.kind !== Et.type.kind && gt.type.kind !== "value" && Et.type.kind !== "value") return ze.error("Cannot compare types '" + Os(gt.type) + "' and '" + Os(Et.type) + "'.");
+                  V && (gt.type.kind === "value" && Et.type.kind !== "value" ? gt = new xl(Et.type, [gt]) : gt.type.kind !== "value" && Et.type.kind === "value" && (Et = new xl(gt.type, [Et])));
+                  var or = null;
+                  if (he.length === 4) {
+                    if (gt.type.kind !== "string" && Et.type.kind !== "string" && gt.type.kind !== "value" && Et.type.kind !== "value") return ze.error("Cannot use collator to compare non-string types.");
+                    if (or = ze.parse(he[3], 3, Vf), !or) return null;
+                  }
+                  return new $(gt, Et, or);
+                }, $.prototype.evaluate = function(he) {
+                  var ze = this.lhs.evaluate(he), rt = this.rhs.evaluate(he);
+                  if (V && this.hasUntypedArgument) {
+                    var gt = Es(ze), Et = Es(rt);
+                    if (gt.kind !== Et.kind || !(gt.kind === "string" || gt.kind === "number")) throw new ps('Expected arguments for "' + m + '" to be (string, string) or (number, number), but found (' + gt.kind + ", " + Et.kind + ") instead.");
+                  }
+                  if (this.collator && !V && this.hasUntypedArgument) {
+                    var or = Es(ze), _r = Es(rt);
+                    if (or.kind !== "string" || _r.kind !== "string") return y(he, ze, rt);
+                  }
+                  return this.collator ? I(he, ze, rt, this.collator.evaluate(he)) : y(he, ze, rt);
+                }, $.prototype.eachChild = function(he) {
+                  he(this.lhs), he(this.rhs), this.collator && he(this.collator);
+                }, $.prototype.outputDefined = function() {
+                  return true;
+                }, $.prototype.serialize = function() {
+                  var he = [m];
+                  return this.eachChild(function(ze) {
+                    he.push(ze.serialize());
+                  }), he;
+                }, $;
+              }();
+            }
+            var Fi = on("==", At, Xi), Qn = on("!=", Xt, dn), Ca = on("<", Cr, wn), Ra = on(">", Ar, Nn), La = on("<=", Kr, Yi), Na = on(">=", ki, Qi), Yn = function(y, I, V, $, ae) {
+              this.type = Oo, this.number = y, this.locale = I, this.currency = V, this.minFractionDigits = $, this.maxFractionDigits = ae;
+            };
+            Yn.parse = function(y, I) {
+              if (y.length !== 3) return I.error("Expected two arguments.");
+              var V = I.parse(y[1], 1, aa);
+              if (!V) return null;
+              var $ = y[2];
+              if (typeof $ != "object" || Array.isArray($)) return I.error("NumberFormat options argument must be an object.");
+              var ae = null;
+              if ($.locale && (ae = I.parse($.locale, 1, Oo), !ae)) return null;
+              var he = null;
+              if ($.currency && (he = I.parse($.currency, 1, Oo), !he)) return null;
+              var ze = null;
+              if ($["min-fraction-digits"] && (ze = I.parse($["min-fraction-digits"], 1, aa), !ze)) return null;
+              var rt = null;
+              return $["max-fraction-digits"] && (rt = I.parse($["max-fraction-digits"], 1, aa), !rt) ? null : new Yn(V, ae, he, ze, rt);
+            }, Yn.prototype.evaluate = function(y) {
+              return new Intl.NumberFormat(this.locale ? this.locale.evaluate(y) : [], { style: this.currency ? "currency" : "decimal", currency: this.currency ? this.currency.evaluate(y) : void 0, minimumFractionDigits: this.minFractionDigits ? this.minFractionDigits.evaluate(y) : void 0, maximumFractionDigits: this.maxFractionDigits ? this.maxFractionDigits.evaluate(y) : void 0 }).format(this.number.evaluate(y));
+            }, Yn.prototype.eachChild = function(y) {
+              y(this.number), this.locale && y(this.locale), this.currency && y(this.currency), this.minFractionDigits && y(this.minFractionDigits), this.maxFractionDigits && y(this.maxFractionDigits);
+            }, Yn.prototype.outputDefined = function() {
+              return false;
+            }, Yn.prototype.serialize = function() {
+              var y = {};
+              return this.locale && (y.locale = this.locale.serialize()), this.currency && (y.currency = this.currency.serialize()), this.minFractionDigits && (y["min-fraction-digits"] = this.minFractionDigits.serialize()), this.maxFractionDigits && (y["max-fraction-digits"] = this.maxFractionDigits.serialize()), ["number-format", this.number.serialize(), y];
+            };
+            var Dn = function(y) {
+              this.type = aa, this.input = y;
+            };
+            Dn.parse = function(y, I) {
+              if (y.length !== 2) return I.error("Expected 1 argument, but found " + (y.length - 1) + " instead.");
+              var V = I.parse(y[1], 1);
+              return V ? V.type.kind !== "array" && V.type.kind !== "string" && V.type.kind !== "value" ? I.error("Expected argument of type string or array, but found " + Os(V.type) + " instead.") : new Dn(V) : null;
+            }, Dn.prototype.evaluate = function(y) {
+              var I = this.input.evaluate(y);
+              if (typeof I == "string") return I.length;
+              if (Array.isArray(I)) return I.length;
+              throw new ps("Expected value to be of type string or array, but found " + Os(Es(I)) + " instead.");
+            }, Dn.prototype.eachChild = function(y) {
+              y(this.input);
+            }, Dn.prototype.outputDefined = function() {
+              return false;
+            }, Dn.prototype.serialize = function() {
+              var y = ["length"];
+              return this.eachChild(function(I) {
+                y.push(I.serialize());
+              }), y;
+            };
+            var Ka = { "==": Fi, "!=": Qn, ">": Ra, "<": Ca, ">=": Na, "<=": La, array: xl, at: Tc, boolean: xl, case: cf, coalesce: Zu, collator: Hu, format: Gu, image: qs, in: wl, "index-of": vu, interpolate: Wl, "interpolate-hcl": Wl, "interpolate-lab": Wl, length: Dn, let: Oc, literal: Go, match: qc, number: xl, "number-format": Yn, object: xl, slice: fc, step: _u, string: xl, "to-boolean": Po, "to-color": Po, "to-number": Po, "to-string": Po, var: Dc, within: Mu };
+            function bo(m, y) {
+              var I = y[0], V = y[1], $ = y[2], ae = y[3];
+              I = I.evaluate(m), V = V.evaluate(m), $ = $.evaluate(m);
+              var he = ae ? ae.evaluate(m) : 1, ze = lc(I, V, $, he);
+              if (ze) throw new ps(ze);
+              return new cs(I / 255 * he, V / 255 * he, $ / 255 * he, he);
+            }
+            function Zo(m, y) {
+              return m in y;
+            }
+            function Ss(m, y) {
+              var I = y[m];
+              return typeof I == "undefined" ? null : I;
+            }
+            function as(m, y, I, V) {
+              for (; I <= V; ) {
+                var $ = I + V >> 1;
+                if (y[$] === m) return true;
+                y[$] > m ? V = $ - 1 : I = $ + 1;
+              }
+              return false;
+            }
+            function ws(m) {
+              return { type: m };
+            }
+            Pa.register(Ka, { error: [rf, [Oo], function(m, y) {
+              var I = y[0];
+              throw new ps(I.evaluate(m));
+            }], typeof: [Oo, [Do], function(m, y) {
+              var I = y[0];
+              return Os(Es(I.evaluate(m)));
+            }], "to-rgba": [Jl(aa, 4), [ql], function(m, y) {
+              var I = y[0];
+              return I.evaluate(m).toArray();
+            }], rgb: [ql, [aa, aa, aa], bo], rgba: [ql, [aa, aa, aa, aa], bo], has: { type: qo, overloads: [[[Oo], function(m, y) {
+              var I = y[0];
+              return Zo(I.evaluate(m), m.properties());
+            }], [[Oo, Pc], function(m, y) {
+              var I = y[0], V = y[1];
+              return Zo(I.evaluate(m), V.evaluate(m));
+            }]] }, get: { type: Do, overloads: [[[Oo], function(m, y) {
+              var I = y[0];
+              return Ss(I.evaluate(m), m.properties());
+            }], [[Oo, Pc], function(m, y) {
+              var I = y[0], V = y[1];
+              return Ss(I.evaluate(m), V.evaluate(m));
+            }]] }, "feature-state": [Do, [Oo], function(m, y) {
+              var I = y[0];
+              return Ss(I.evaluate(m), m.featureState || {});
+            }], properties: [Pc, [], function(m) {
+              return m.properties();
+            }], "geometry-type": [Oo, [], function(m) {
+              return m.geometryType();
+            }], id: [Do, [], function(m) {
+              return m.id();
+            }], zoom: [aa, [], function(m) {
+              return m.globals.zoom;
+            }], "heatmap-density": [aa, [], function(m) {
+              return m.globals.heatmapDensity || 0;
+            }], "line-progress": [aa, [], function(m) {
+              return m.globals.lineProgress || 0;
+            }], accumulated: [Do, [], function(m) {
+              return m.globals.accumulated === void 0 ? null : m.globals.accumulated;
+            }], "+": [aa, ws(aa), function(m, y) {
+              for (var I = 0, V = 0, $ = y; V < $.length; V += 1) {
+                var ae = $[V];
+                I += ae.evaluate(m);
+              }
+              return I;
+            }], "*": [aa, ws(aa), function(m, y) {
+              for (var I = 1, V = 0, $ = y; V < $.length; V += 1) {
+                var ae = $[V];
+                I *= ae.evaluate(m);
+              }
+              return I;
+            }], "-": { type: aa, overloads: [[[aa, aa], function(m, y) {
+              var I = y[0], V = y[1];
+              return I.evaluate(m) - V.evaluate(m);
+            }], [[aa], function(m, y) {
+              var I = y[0];
+              return -I.evaluate(m);
+            }]] }, "/": [aa, [aa, aa], function(m, y) {
+              var I = y[0], V = y[1];
+              return I.evaluate(m) / V.evaluate(m);
+            }], "%": [aa, [aa, aa], function(m, y) {
+              var I = y[0], V = y[1];
+              return I.evaluate(m) % V.evaluate(m);
+            }], ln2: [aa, [], function() {
+              return Math.LN2;
+            }], pi: [aa, [], function() {
+              return Math.PI;
+            }], e: [aa, [], function() {
+              return Math.E;
+            }], "^": [aa, [aa, aa], function(m, y) {
+              var I = y[0], V = y[1];
+              return Math.pow(I.evaluate(m), V.evaluate(m));
+            }], sqrt: [aa, [aa], function(m, y) {
+              var I = y[0];
+              return Math.sqrt(I.evaluate(m));
+            }], log10: [aa, [aa], function(m, y) {
+              var I = y[0];
+              return Math.log(I.evaluate(m)) / Math.LN10;
+            }], ln: [aa, [aa], function(m, y) {
+              var I = y[0];
+              return Math.log(I.evaluate(m));
+            }], log2: [aa, [aa], function(m, y) {
+              var I = y[0];
+              return Math.log(I.evaluate(m)) / Math.LN2;
+            }], sin: [aa, [aa], function(m, y) {
+              var I = y[0];
+              return Math.sin(I.evaluate(m));
+            }], cos: [aa, [aa], function(m, y) {
+              var I = y[0];
+              return Math.cos(I.evaluate(m));
+            }], tan: [aa, [aa], function(m, y) {
+              var I = y[0];
+              return Math.tan(I.evaluate(m));
+            }], asin: [aa, [aa], function(m, y) {
+              var I = y[0];
+              return Math.asin(I.evaluate(m));
+            }], acos: [aa, [aa], function(m, y) {
+              var I = y[0];
+              return Math.acos(I.evaluate(m));
+            }], atan: [aa, [aa], function(m, y) {
+              var I = y[0];
+              return Math.atan(I.evaluate(m));
+            }], min: [aa, ws(aa), function(m, y) {
+              return Math.min.apply(Math, y.map(function(I) {
+                return I.evaluate(m);
+              }));
+            }], max: [aa, ws(aa), function(m, y) {
+              return Math.max.apply(Math, y.map(function(I) {
+                return I.evaluate(m);
+              }));
+            }], abs: [aa, [aa], function(m, y) {
+              var I = y[0];
+              return Math.abs(I.evaluate(m));
+            }], round: [aa, [aa], function(m, y) {
+              var I = y[0], V = I.evaluate(m);
+              return V < 0 ? -Math.round(-V) : Math.round(V);
+            }], floor: [aa, [aa], function(m, y) {
+              var I = y[0];
+              return Math.floor(I.evaluate(m));
+            }], ceil: [aa, [aa], function(m, y) {
+              var I = y[0];
+              return Math.ceil(I.evaluate(m));
+            }], "filter-==": [qo, [Oo, Do], function(m, y) {
+              var I = y[0], V = y[1];
+              return m.properties()[I.value] === V.value;
+            }], "filter-id-==": [qo, [Do], function(m, y) {
+              var I = y[0];
+              return m.id() === I.value;
+            }], "filter-type-==": [qo, [Oo], function(m, y) {
+              var I = y[0];
+              return m.geometryType() === I.value;
+            }], "filter-<": [qo, [Oo, Do], function(m, y) {
+              var I = y[0], V = y[1], $ = m.properties()[I.value], ae = V.value;
+              return typeof $ == typeof ae && $ < ae;
+            }], "filter-id-<": [qo, [Do], function(m, y) {
+              var I = y[0], V = m.id(), $ = I.value;
+              return typeof V == typeof $ && V < $;
+            }], "filter->": [qo, [Oo, Do], function(m, y) {
+              var I = y[0], V = y[1], $ = m.properties()[I.value], ae = V.value;
+              return typeof $ == typeof ae && $ > ae;
+            }], "filter-id->": [qo, [Do], function(m, y) {
+              var I = y[0], V = m.id(), $ = I.value;
+              return typeof V == typeof $ && V > $;
+            }], "filter-<=": [qo, [Oo, Do], function(m, y) {
+              var I = y[0], V = y[1], $ = m.properties()[I.value], ae = V.value;
+              return typeof $ == typeof ae && $ <= ae;
+            }], "filter-id-<=": [qo, [Do], function(m, y) {
+              var I = y[0], V = m.id(), $ = I.value;
+              return typeof V == typeof $ && V <= $;
+            }], "filter->=": [qo, [Oo, Do], function(m, y) {
+              var I = y[0], V = y[1], $ = m.properties()[I.value], ae = V.value;
+              return typeof $ == typeof ae && $ >= ae;
+            }], "filter-id->=": [qo, [Do], function(m, y) {
+              var I = y[0], V = m.id(), $ = I.value;
+              return typeof V == typeof $ && V >= $;
+            }], "filter-has": [qo, [Do], function(m, y) {
+              var I = y[0];
+              return I.value in m.properties();
+            }], "filter-has-id": [qo, [], function(m) {
+              return m.id() !== null && m.id() !== void 0;
+            }], "filter-type-in": [qo, [Jl(Oo)], function(m, y) {
+              var I = y[0];
+              return I.value.indexOf(m.geometryType()) >= 0;
+            }], "filter-id-in": [qo, [Jl(Do)], function(m, y) {
+              var I = y[0];
+              return I.value.indexOf(m.id()) >= 0;
+            }], "filter-in-small": [qo, [Oo, Jl(Do)], function(m, y) {
+              var I = y[0], V = y[1];
+              return V.value.indexOf(m.properties()[I.value]) >= 0;
+            }], "filter-in-large": [qo, [Oo, Jl(Do)], function(m, y) {
+              var I = y[0], V = y[1];
+              return as(m.properties()[I.value], V.value, 0, V.value.length - 1);
+            }], all: { type: qo, overloads: [[[qo, qo], function(m, y) {
+              var I = y[0], V = y[1];
+              return I.evaluate(m) && V.evaluate(m);
+            }], [ws(qo), function(m, y) {
+              for (var I = 0, V = y; I < V.length; I += 1) {
+                var $ = V[I];
+                if (!$.evaluate(m)) return false;
+              }
+              return true;
+            }]] }, any: { type: qo, overloads: [[[qo, qo], function(m, y) {
+              var I = y[0], V = y[1];
+              return I.evaluate(m) || V.evaluate(m);
+            }], [ws(qo), function(m, y) {
+              for (var I = 0, V = y; I < V.length; I += 1) {
+                var $ = V[I];
+                if ($.evaluate(m)) return true;
+              }
+              return false;
+            }]] }, "!": [qo, [qo], function(m, y) {
+              var I = y[0];
+              return !I.evaluate(m);
+            }], "is-supported-script": [qo, [Oo], function(m, y) {
+              var I = y[0], V = m.globals && m.globals.isSupportedScript;
+              return V ? V(I.evaluate(m)) : true;
+            }], upcase: [Oo, [Oo], function(m, y) {
+              var I = y[0];
+              return I.evaluate(m).toUpperCase();
+            }], downcase: [Oo, [Oo], function(m, y) {
+              var I = y[0];
+              return I.evaluate(m).toLowerCase();
+            }], concat: [Oo, ws(Do), function(m, y) {
+              return y.map(function(I) {
+                return Hs(I.evaluate(m));
+              }).join("");
+            }], "resolved-locale": [Oo, [Vf], function(m, y) {
+              var I = y[0];
+              return I.evaluate(m).resolvedLocale();
+            }] });
+            function Ho(m) {
+              return { result: "success", value: m };
+            }
+            function ml(m) {
+              return { result: "error", value: m };
+            }
+            function Ws(m) {
+              return m["property-type"] === "data-driven" || m["property-type"] === "cross-faded-data-driven";
+            }
+            function Ls(m) {
+              return !!m.expression && m.expression.parameters.indexOf("zoom") > -1;
+            }
+            function va(m) {
+              return !!m.expression && m.expression.interpolated;
+            }
+            function no(m) {
+              return m instanceof Number ? "number" : m instanceof String ? "string" : m instanceof Boolean ? "boolean" : Array.isArray(m) ? "array" : m === null ? "null" : typeof m;
+            }
+            function ys(m) {
+              return typeof m == "object" && m !== null && !Array.isArray(m);
+            }
+            function rs(m) {
+              return m;
+            }
+            function Ql(m, y) {
+              var I = y.type === "color", V = m.stops && typeof m.stops[0][0] == "object", $ = V || m.property !== void 0, ae = V || !$, he = m.type || (va(y) ? "exponential" : "interval");
+              if (I && (m = Ol({}, m), m.stops && (m.stops = m.stops.map(function(ha) {
+                return [ha[0], cs.parse(ha[1])];
+              })), m.default ? m.default = cs.parse(m.default) : m.default = cs.parse(y.default)), m.colorSpace && m.colorSpace !== "rgb" && !Zf[m.colorSpace]) throw new Error("Unknown color space: " + m.colorSpace);
+              var ze, rt, gt;
+              if (he === "exponential") ze = pu;
+              else if (he === "interval") ze = Nc;
+              else if (he === "categorical") {
+                ze = Yu, rt = /* @__PURE__ */ Object.create(null);
+                for (var Et = 0, or = m.stops; Et < or.length; Et += 1) {
+                  var _r = or[Et];
+                  rt[_r[0]] = _r[1];
+                }
+                gt = typeof m.stops[0][0];
+              } else if (he === "identity") ze = Uc;
+              else throw new Error('Unknown function type "' + he + '"');
+              if (V) {
+                for (var pr = {}, Fr = [], oi = 0; oi < m.stops.length; oi++) {
+                  var Hi = m.stops[oi], Ai = Hi[0].zoom;
+                  pr[Ai] === void 0 && (pr[Ai] = { zoom: Ai, type: m.type, property: m.property, default: m.default, stops: [] }, Fr.push(Ai)), pr[Ai].stops.push([Hi[0].value, Hi[1]]);
+                }
+                for (var bn = [], nn = 0, xn = Fr; nn < xn.length; nn += 1) {
+                  var Pn = xn[nn];
+                  bn.push([pr[Pn].zoom, Ql(pr[Pn], y)]);
+                }
+                var Zn = { name: "linear" };
+                return { kind: "composite", interpolationType: Zn, interpolationFactor: Wl.interpolationFactor.bind(void 0, Zn), zoomStops: bn.map(function(ha) {
+                  return ha[0];
+                }), evaluate: function(eo, za) {
+                  var Za = eo.zoom;
+                  return pu({ stops: bn, base: m.base }, y, Za).evaluate(Za, za);
+                } };
+              } else if (ae) {
+                var ga = he === "exponential" ? { name: "exponential", base: m.base !== void 0 ? m.base : 1 } : null;
+                return { kind: "camera", interpolationType: ga, interpolationFactor: Wl.interpolationFactor.bind(void 0, ga), zoomStops: m.stops.map(function(ha) {
+                  return ha[0];
+                }), evaluate: function(ha) {
+                  var eo = ha.zoom;
+                  return ze(m, y, eo, rt, gt);
+                } };
+              } else return { kind: "source", evaluate: function(eo, za) {
+                var Za = za && za.properties ? za.properties[m.property] : void 0;
+                return Za === void 0 ? Cu(m.default, y.default) : ze(m, y, Za, rt, gt);
+              } };
+            }
+            function Cu(m, y, I) {
+              if (m !== void 0) return m;
+              if (y !== void 0) return y;
+              if (I !== void 0) return I;
+            }
+            function Yu(m, y, I, V, $) {
+              var ae = typeof I === $ ? V[I] : void 0;
+              return Cu(ae, m.default, y.default);
+            }
+            function Nc(m, y, I) {
+              if (no(I) !== "number") return Cu(m.default, y.default);
+              var V = m.stops.length;
+              if (V === 1 || I <= m.stops[0][0]) return m.stops[0][1];
+              if (I >= m.stops[V - 1][0]) return m.stops[V - 1][1];
+              var $ = hu(m.stops.map(function(ae) {
+                return ae[0];
+              }), I);
+              return m.stops[$][1];
+            }
+            function pu(m, y, I) {
+              var V = m.base !== void 0 ? m.base : 1;
+              if (no(I) !== "number") return Cu(m.default, y.default);
+              var $ = m.stops.length;
+              if ($ === 1 || I <= m.stops[0][0]) return m.stops[0][1];
+              if (I >= m.stops[$ - 1][0]) return m.stops[$ - 1][1];
+              var ae = hu(m.stops.map(function(or) {
+                return or[0];
+              }), I), he = xu(I, V, m.stops[ae][0], m.stops[ae + 1][0]), ze = m.stops[ae][1], rt = m.stops[ae + 1][1], gt = zu[y.type] || rs;
+              if (m.colorSpace && m.colorSpace !== "rgb") {
+                var Et = Zf[m.colorSpace];
+                gt = function(or, _r) {
+                  return Et.reverse(Et.interpolate(Et.forward(or), Et.forward(_r), he));
+                };
+              }
+              return typeof ze.evaluate == "function" ? { evaluate: function() {
+                for (var _r = [], pr = arguments.length; pr--; ) _r[pr] = arguments[pr];
+                var Fr = ze.evaluate.apply(void 0, _r), oi = rt.evaluate.apply(void 0, _r);
+                if (!(Fr === void 0 || oi === void 0)) return gt(Fr, oi, he);
+              } } : gt(ze, rt, he);
+            }
+            function Uc(m, y, I) {
+              return y.type === "color" ? I = cs.parse(I) : y.type === "formatted" ? I = $l.fromString(I.toString()) : y.type === "resolvedImage" ? I = fl.fromString(I.toString()) : no(I) !== y.type && (y.type !== "enum" || !y.values[I]) && (I = void 0), Cu(I, m.default, y.default);
+            }
+            function xu(m, y, I, V) {
+              var $ = V - I, ae = m - I;
+              return $ === 0 ? 0 : y === 1 ? ae / $ : (Math.pow(y, ae) - 1) / (Math.pow(y, $) - 1);
+            }
+            var Ac = function(y, I) {
+              this.expression = y, this._warningHistory = {}, this._evaluator = new Ko(), this._defaultValue = I ? ee(I) : null, this._enumValues = I && I.type === "enum" ? I.values : null;
+            };
+            Ac.prototype.evaluateWithoutErrorHandling = function(y, I, V, $, ae, he) {
+              return this._evaluator.globals = y, this._evaluator.feature = I, this._evaluator.featureState = V, this._evaluator.canonical = $, this._evaluator.availableImages = ae || null, this._evaluator.formattedSection = he, this.expression.evaluate(this._evaluator);
+            }, Ac.prototype.evaluate = function(y, I, V, $, ae, he) {
+              this._evaluator.globals = y, this._evaluator.feature = I || null, this._evaluator.featureState = V || null, this._evaluator.canonical = $, this._evaluator.availableImages = ae || null, this._evaluator.formattedSection = he || null;
+              try {
+                var ze = this.expression.evaluate(this._evaluator);
+                if (ze == null || typeof ze == "number" && ze !== ze) return this._defaultValue;
+                if (this._enumValues && !(ze in this._enumValues)) throw new ps("Expected value to be one of " + Object.keys(this._enumValues).map(function(rt) {
+                  return JSON.stringify(rt);
+                }).join(", ") + ", but found " + JSON.stringify(ze) + " instead.");
+                return ze;
+              } catch (rt) {
+                return this._warningHistory[rt.message] || (this._warningHistory[rt.message] = true, typeof console != "undefined" && console.warn(rt.message)), this._defaultValue;
+              }
+            };
+            function Ua(m) {
+              return Array.isArray(m) && m.length > 0 && typeof m[0] == "string" && m[0] in Ka;
+            }
+            function oo(m, y) {
+              var I = new ks(Ka, [], y ? Q(y) : void 0), V = I.parse(m, void 0, void 0, void 0, y && y.type === "string" ? { typeAnnotation: "coerce" } : void 0);
+              return V ? Ho(new Ac(V, y)) : ml(I.errors);
+            }
+            var Vc = function(y, I) {
+              this.kind = y, this._styleExpression = I, this.isStateDependent = y !== "constant" && !js(I.expression);
+            };
+            Vc.prototype.evaluateWithoutErrorHandling = function(y, I, V, $, ae, he) {
+              return this._styleExpression.evaluateWithoutErrorHandling(y, I, V, $, ae, he);
+            }, Vc.prototype.evaluate = function(y, I, V, $, ae, he) {
+              return this._styleExpression.evaluate(y, I, V, $, ae, he);
+            };
+            var hc = function(y, I, V, $) {
+              this.kind = y, this.zoomStops = V, this._styleExpression = I, this.isStateDependent = y !== "camera" && !js(I.expression), this.interpolationType = $;
+            };
+            hc.prototype.evaluateWithoutErrorHandling = function(y, I, V, $, ae, he) {
+              return this._styleExpression.evaluateWithoutErrorHandling(y, I, V, $, ae, he);
+            }, hc.prototype.evaluate = function(y, I, V, $, ae, he) {
+              return this._styleExpression.evaluate(y, I, V, $, ae, he);
+            }, hc.prototype.interpolationFactor = function(y, I, V) {
+              return this.interpolationType ? Wl.interpolationFactor(this.interpolationType, y, I, V) : 0;
+            };
+            function Ku(m, y) {
+              if (m = oo(m, y), m.result === "error") return m;
+              var I = m.value.expression, V = ih(I);
+              if (!V && !Ws(y)) return ml([new Ns("", "data expressions not supported")]);
+              var $ = Eu(I, ["zoom"]);
+              if (!$ && !Ls(y)) return ml([new Ns("", "zoom expressions not supported")]);
+              var ae = B(I);
+              if (!ae && !$) return ml([new Ns("", '"zoom" expression may only be used as input to a top-level "step" or "interpolate" expression.')]);
+              if (ae instanceof Ns) return ml([ae]);
+              if (ae instanceof Wl && !va(y)) return ml([new Ns("", '"interpolate" expressions cannot be used with this property')]);
+              if (!ae) return Ho(V ? new Vc("constant", m.value) : new Vc("source", m.value));
+              var he = ae instanceof Wl ? ae.interpolation : void 0;
+              return Ho(V ? new hc("camera", m.value, ae.labels, he) : new hc("composite", m.value, ae.labels, he));
+            }
+            var ue = function(y, I) {
+              this._parameters = y, this._specification = I, Ol(this, Ql(this._parameters, this._specification));
+            };
+            ue.deserialize = function(y) {
+              return new ue(y._parameters, y._specification);
+            }, ue.serialize = function(y) {
+              return { _parameters: y._parameters, _specification: y._specification };
+            };
+            function w(m, y) {
+              if (ys(m)) return new ue(m, y);
+              if (Ua(m)) {
+                var I = Ku(m, y);
+                if (I.result === "error") throw new Error(I.value.map(function($) {
+                  return $.key + ": " + $.message;
+                }).join(", "));
+                return I.value;
+              } else {
+                var V = m;
+                return typeof m == "string" && y.type === "color" && (V = cs.parse(m)), { kind: "constant", evaluate: function() {
+                  return V;
+                } };
+              }
+            }
+            function B(m) {
+              var y = null;
+              if (m instanceof Oc) y = B(m.result);
+              else if (m instanceof Zu) for (var I = 0, V = m.args; I < V.length; I += 1) {
+                var $ = V[I];
+                if (y = B($), y) break;
+              }
+              else (m instanceof _u || m instanceof Wl) && m.input instanceof Pa && m.input.name === "zoom" && (y = m);
+              return y instanceof Ns || m.eachChild(function(ae) {
+                var he = B(ae);
+                he instanceof Ns ? y = he : !y && he ? y = new Ns("", '"zoom" expression may only be used as input to a top-level "step" or "interpolate" expression.') : y && he && y !== he && (y = new Ns("", 'Only one zoom-based "step" or "interpolate" subexpression may be used in an expression.'));
+              }), y;
+            }
+            function Q(m) {
+              var y = { color: ql, string: Oo, number: aa, enum: Oo, boolean: qo, formatted: pl, resolvedImage: Zc };
+              return m.type === "array" ? Jl(y[m.value] || Do, m.length) : y[m.type];
+            }
+            function ee(m) {
+              return m.type === "color" && ys(m.default) ? new cs(0, 0, 0, 0) : m.type === "color" ? cs.parse(m.default) || null : m.default === void 0 ? null : m.default;
+            }
+            function le(m) {
+              var y = m.key, I = m.value, V = m.valueSpec || {}, $ = m.objectElementValidators || {}, ae = m.style, he = m.styleSpec, ze = [], rt = no(I);
+              if (rt !== "object") return [new _a(y, I, "object expected, " + rt + " found")];
+              for (var gt in I) {
+                var Et = gt.split(".")[0], or = V[Et] || V["*"], _r = void 0;
+                if ($[Et]) _r = $[Et];
+                else if (V[Et]) _r = Qa;
+                else if ($["*"]) _r = $["*"];
+                else if (V["*"]) _r = Qa;
+                else {
+                  ze.push(new _a(y, I[gt], 'unknown property "' + gt + '"'));
+                  continue;
+                }
+                ze = ze.concat(_r({ key: (y && y + ".") + gt, value: I[gt], valueSpec: or, style: ae, styleSpec: he, object: I, objectKey: gt }, I));
+              }
+              for (var pr in V) $[pr] || V[pr].required && V[pr].default === void 0 && I[pr] === void 0 && ze.push(new _a(y, I, 'missing required property "' + pr + '"'));
+              return ze;
+            }
+            function Oe(m) {
+              var y = m.value, I = m.valueSpec, V = m.style, $ = m.styleSpec, ae = m.key, he = m.arrayElementValidator || Qa;
+              if (no(y) !== "array") return [new _a(ae, y, "array expected, " + no(y) + " found")];
+              if (I.length && y.length !== I.length) return [new _a(ae, y, "array length " + I.length + " expected, length " + y.length + " found")];
+              if (I["min-length"] && y.length < I["min-length"]) return [new _a(ae, y, "array length at least " + I["min-length"] + " expected, length " + y.length + " found")];
+              var ze = { type: I.value, values: I.values };
+              $.$version < 7 && (ze.function = I.function), no(I.value) === "object" && (ze = I.value);
+              for (var rt = [], gt = 0; gt < y.length; gt++) rt = rt.concat(he({ array: y, arrayIndex: gt, value: y[gt], valueSpec: ze, style: V, styleSpec: $, key: ae + "[" + gt + "]" }));
+              return rt;
+            }
+            function Ze(m) {
+              var y = m.key, I = m.value, V = m.valueSpec, $ = no(I);
+              return $ === "number" && I !== I && ($ = "NaN"), $ !== "number" ? [new _a(y, I, "number expected, " + $ + " found")] : "minimum" in V && I < V.minimum ? [new _a(y, I, I + " is less than the minimum value " + V.minimum)] : "maximum" in V && I > V.maximum ? [new _a(y, I, I + " is greater than the maximum value " + V.maximum)] : [];
+            }
+            function st(m) {
+              var y = m.valueSpec, I = xo(m.value.type), V, $ = {}, ae, he, ze = I !== "categorical" && m.value.property === void 0, rt = !ze, gt = no(m.value.stops) === "array" && no(m.value.stops[0]) === "array" && no(m.value.stops[0][0]) === "object", Et = le({ key: m.key, value: m.value, valueSpec: m.styleSpec.function, style: m.style, styleSpec: m.styleSpec, objectElementValidators: { stops: or, default: Fr } });
+              return I === "identity" && ze && Et.push(new _a(m.key, m.value, 'missing required property "property"')), I !== "identity" && !m.value.stops && Et.push(new _a(m.key, m.value, 'missing required property "stops"')), I === "exponential" && m.valueSpec.expression && !va(m.valueSpec) && Et.push(new _a(m.key, m.value, "exponential functions not supported")), m.styleSpec.$version >= 8 && (rt && !Ws(m.valueSpec) ? Et.push(new _a(m.key, m.value, "property functions not supported")) : ze && !Ls(m.valueSpec) && Et.push(new _a(m.key, m.value, "zoom functions not supported"))), (I === "categorical" || gt) && m.value.property === void 0 && Et.push(new _a(m.key, m.value, '"property" property is required')), Et;
+              function or(oi) {
+                if (I === "identity") return [new _a(oi.key, oi.value, 'identity function may not have a "stops" property')];
+                var Hi = [], Ai = oi.value;
+                return Hi = Hi.concat(Oe({ key: oi.key, value: Ai, valueSpec: oi.valueSpec, style: oi.style, styleSpec: oi.styleSpec, arrayElementValidator: _r })), no(Ai) === "array" && Ai.length === 0 && Hi.push(new _a(oi.key, Ai, "array must have at least one stop")), Hi;
+              }
+              function _r(oi) {
+                var Hi = [], Ai = oi.value, bn = oi.key;
+                if (no(Ai) !== "array") return [new _a(bn, Ai, "array expected, " + no(Ai) + " found")];
+                if (Ai.length !== 2) return [new _a(bn, Ai, "array length 2 expected, length " + Ai.length + " found")];
+                if (gt) {
+                  if (no(Ai[0]) !== "object") return [new _a(bn, Ai, "object expected, " + no(Ai[0]) + " found")];
+                  if (Ai[0].zoom === void 0) return [new _a(bn, Ai, "object stop key must have zoom")];
+                  if (Ai[0].value === void 0) return [new _a(bn, Ai, "object stop key must have value")];
+                  if (he && he > xo(Ai[0].zoom)) return [new _a(bn, Ai[0].zoom, "stop zoom values must appear in ascending order")];
+                  xo(Ai[0].zoom) !== he && (he = xo(Ai[0].zoom), ae = void 0, $ = {}), Hi = Hi.concat(le({ key: bn + "[0]", value: Ai[0], valueSpec: { zoom: {} }, style: oi.style, styleSpec: oi.styleSpec, objectElementValidators: { zoom: Ze, value: pr } }));
+                } else Hi = Hi.concat(pr({ key: bn + "[0]", value: Ai[0], style: oi.style, styleSpec: oi.styleSpec }, Ai));
+                return Ua(Kl(Ai[1])) ? Hi.concat([new _a(bn + "[1]", Ai[1], "expressions are not allowed in function stops.")]) : Hi.concat(Qa({ key: bn + "[1]", value: Ai[1], valueSpec: y, style: oi.style, styleSpec: oi.styleSpec }));
+              }
+              function pr(oi, Hi) {
+                var Ai = no(oi.value), bn = xo(oi.value), nn = oi.value !== null ? oi.value : Hi;
+                if (!V) V = Ai;
+                else if (Ai !== V) return [new _a(oi.key, nn, Ai + " stop domain type must match previous stop domain type " + V)];
+                if (Ai !== "number" && Ai !== "string" && Ai !== "boolean") return [new _a(oi.key, nn, "stop domain value must be a number, string, or boolean")];
+                if (Ai !== "number" && I !== "categorical") {
+                  var xn = "number expected, " + Ai + " found";
+                  return Ws(y) && I === void 0 && (xn += '\nIf you intended to use a categorical function, specify `"type": "categorical"`.'), [new _a(oi.key, nn, xn)];
+                }
+                return I === "categorical" && Ai === "number" && (!isFinite(bn) || Math.floor(bn) !== bn) ? [new _a(oi.key, nn, "integer expected, found " + bn)] : I !== "categorical" && Ai === "number" && ae !== void 0 && bn < ae ? [new _a(oi.key, nn, "stop domain values must appear in ascending order")] : (ae = bn, I === "categorical" && bn in $ ? [new _a(oi.key, nn, "stop domain values must be unique")] : ($[bn] = true, []));
+              }
+              function Fr(oi) {
+                return Qa({ key: oi.key, value: oi.value, valueSpec: y, style: oi.style, styleSpec: oi.styleSpec });
+              }
+            }
+            function Tt(m) {
+              var y = (m.expressionContext === "property" ? Ku : oo)(Kl(m.value), m.valueSpec);
+              if (y.result === "error") return y.value.map(function(V) {
+                return new _a("" + m.key + V.key, m.value, V.message);
+              });
+              var I = y.value.expression || y.value._styleExpression.expression;
+              if (m.expressionContext === "property" && m.propertyKey === "text-font" && !I.outputDefined()) return [new _a(m.key, m.value, 'Invalid data expression for "' + m.propertyKey + '". Output values must be contained as literals within the expression.')];
+              if (m.expressionContext === "property" && m.propertyType === "layout" && !js(I)) return [new _a(m.key, m.value, '"feature-state" data expressions are not supported with layout properties.')];
+              if (m.expressionContext === "filter" && !js(I)) return [new _a(m.key, m.value, '"feature-state" data expressions are not supported with filters.')];
+              if (m.expressionContext && m.expressionContext.indexOf("cluster") === 0) {
+                if (!Eu(I, ["zoom", "feature-state"])) return [new _a(m.key, m.value, '"zoom" and "feature-state" expressions are not supported with cluster properties.')];
+                if (m.expressionContext === "cluster-initial" && !ih(I)) return [new _a(m.key, m.value, "Feature data expressions are not supported with initial expression part of cluster properties.")];
+              }
+              return [];
+            }
+            function Yt(m) {
+              var y = m.value, I = m.key, V = no(y);
+              return V !== "boolean" ? [new _a(I, y, "boolean expected, " + V + " found")] : [];
+            }
+            function Kt(m) {
+              var y = m.key, I = m.value, V = no(I);
+              return V !== "string" ? [new _a(y, I, "color expected, " + V + " found")] : Lf(I) === null ? [new _a(y, I, 'color expected, "' + I + '" found')] : [];
+            }
+            function xr(m) {
+              var y = m.key, I = m.value, V = m.valueSpec, $ = [];
+              return Array.isArray(V.values) ? V.values.indexOf(xo(I)) === -1 && $.push(new _a(y, I, "expected one of [" + V.values.join(", ") + "], " + JSON.stringify(I) + " found")) : Object.keys(V.values).indexOf(xo(I)) === -1 && $.push(new _a(y, I, "expected one of [" + Object.keys(V.values).join(", ") + "], " + JSON.stringify(I) + " found")), $;
+            }
+            function Ir(m) {
+              if (m === true || m === false) return true;
+              if (!Array.isArray(m) || m.length === 0) return false;
+              switch (m[0]) {
+                case "has":
+                  return m.length >= 2 && m[1] !== "$id" && m[1] !== "$type";
+                case "in":
+                  return m.length >= 3 && (typeof m[1] != "string" || Array.isArray(m[2]));
+                case "!in":
+                case "!has":
+                case "none":
+                  return false;
+                case "==":
+                case "!=":
+                case ">":
+                case ">=":
+                case "<":
+                case "<=":
+                  return m.length !== 3 || Array.isArray(m[1]) || Array.isArray(m[2]);
+                case "any":
+                case "all":
+                  for (var y = 0, I = m.slice(1); y < I.length; y += 1) {
+                    var V = I[y];
+                    if (!Ir(V) && typeof V != "boolean") return false;
+                  }
+                  return true;
+                default:
+                  return true;
+              }
+            }
+            var ve = { type: "boolean", default: false };
+            function be(m) {
+              if (m == null) return { filter: function() {
+                return true;
+              }, needGeometry: false };
+              Ir(m) || (m = et(m));
+              var y = oo(m, ve);
+              if (y.result === "error") throw new Error(y.value.map(function(V) {
+                return V.key + ": " + V.message;
+              }).join(", "));
+              var I = qe(m);
+              return { filter: function(V, $, ae) {
+                return y.value.evaluate(V, $, {}, ae);
+              }, needGeometry: I };
+            }
+            function Re(m, y) {
+              return m < y ? -1 : m > y ? 1 : 0;
+            }
+            function qe(m) {
+              if (!Array.isArray(m)) return false;
+              if (m[0] === "within") return true;
+              for (var y = 1; y < m.length; y++) if (qe(m[y])) return true;
+              return false;
+            }
+            function et(m) {
+              if (!m) return true;
+              var y = m[0];
+              if (m.length <= 1) return y !== "any";
+              var I = y === "==" ? Xe(m[1], m[2], "==") : y === "!=" ? tr(Xe(m[1], m[2], "==")) : y === "<" || y === ">" || y === "<=" || y === ">=" ? Xe(m[1], m[2], y) : y === "any" ? it(m.slice(1)) : y === "all" ? ["all"].concat(m.slice(1).map(et)) : y === "none" ? ["all"].concat(m.slice(1).map(et).map(tr)) : y === "in" ? Ft(m[1], m.slice(2)) : y === "!in" ? tr(Ft(m[1], m.slice(2))) : y === "has" ? Ht(m[1]) : y === "!has" ? tr(Ht(m[1])) : y === "within" ? m : true;
+              return I;
+            }
+            function Xe(m, y, I) {
+              switch (m) {
+                case "$type":
+                  return ["filter-type-" + I, y];
+                case "$id":
+                  return ["filter-id-" + I, y];
+                default:
+                  return ["filter-" + I, m, y];
+              }
+            }
+            function it(m) {
+              return ["any"].concat(m.map(et));
+            }
+            function Ft(m, y) {
+              if (y.length === 0) return false;
+              switch (m) {
+                case "$type":
+                  return ["filter-type-in", ["literal", y]];
+                case "$id":
+                  return ["filter-id-in", ["literal", y]];
+                default:
+                  return y.length > 200 && !y.some(function(I) {
+                    return typeof I != typeof y[0];
+                  }) ? ["filter-in-large", m, ["literal", y.sort(Re)]] : ["filter-in-small", m, ["literal", y]];
+              }
+            }
+            function Ht(m) {
+              switch (m) {
+                case "$type":
+                  return true;
+                case "$id":
+                  return ["filter-has-id"];
+                default:
+                  return ["filter-has", m];
+              }
+            }
+            function tr(m) {
+              return ["!", m];
+            }
+            function dr(m) {
+              return Ir(Kl(m.value)) ? Tt(Ol({}, m, { expressionContext: "filter", valueSpec: { value: "boolean" } })) : Sr(m);
+            }
+            function Sr(m) {
+              var y = m.value, I = m.key;
+              if (no(y) !== "array") return [new _a(I, y, "array expected, " + no(y) + " found")];
+              var V = m.styleSpec, $, ae = [];
+              if (y.length < 1) return [new _a(I, y, "filter array must have at least 1 element")];
+              switch (ae = ae.concat(xr({ key: I + "[0]", value: y[0], valueSpec: V.filter_operator, style: m.style, styleSpec: m.styleSpec })), xo(y[0])) {
+                case "<":
+                case "<=":
+                case ">":
+                case ">=":
+                  y.length >= 2 && xo(y[1]) === "$type" && ae.push(new _a(I, y, '"$type" cannot be use with operator "' + y[0] + '"'));
+                case "==":
+                case "!=":
+                  y.length !== 3 && ae.push(new _a(I, y, 'filter array for operator "' + y[0] + '" must have 3 elements'));
+                case "in":
+                case "!in":
+                  y.length >= 2 && ($ = no(y[1]), $ !== "string" && ae.push(new _a(I + "[1]", y[1], "string expected, " + $ + " found")));
+                  for (var he = 2; he < y.length; he++) $ = no(y[he]), xo(y[1]) === "$type" ? ae = ae.concat(xr({ key: I + "[" + he + "]", value: y[he], valueSpec: V.geometry_type, style: m.style, styleSpec: m.styleSpec })) : $ !== "string" && $ !== "number" && $ !== "boolean" && ae.push(new _a(I + "[" + he + "]", y[he], "string, number, or boolean expected, " + $ + " found"));
+                  break;
+                case "any":
+                case "all":
+                case "none":
+                  for (var ze = 1; ze < y.length; ze++) ae = ae.concat(Sr({ key: I + "[" + ze + "]", value: y[ze], style: m.style, styleSpec: m.styleSpec }));
+                  break;
+                case "has":
+                case "!has":
+                  $ = no(y[1]), y.length !== 2 ? ae.push(new _a(I, y, 'filter array for "' + y[0] + '" operator must have 2 elements')) : $ !== "string" && ae.push(new _a(I + "[1]", y[1], "string expected, " + $ + " found"));
+                  break;
+                case "within":
+                  $ = no(y[1]), y.length !== 2 ? ae.push(new _a(I, y, 'filter array for "' + y[0] + '" operator must have 2 elements')) : $ !== "object" && ae.push(new _a(I + "[1]", y[1], "object expected, " + $ + " found"));
+                  break;
+              }
+              return ae;
+            }
+            function Or(m, y) {
+              var I = m.key, V = m.style, $ = m.styleSpec, ae = m.value, he = m.objectKey, ze = $[y + "_" + m.layerType];
+              if (!ze) return [];
+              var rt = he.match(/^(.*)-transition$/);
+              if (y === "paint" && rt && ze[rt[1]] && ze[rt[1]].transition) return Qa({ key: I, value: ae, valueSpec: $.transition, style: V, styleSpec: $ });
+              var gt = m.valueSpec || ze[he];
+              if (!gt) return [new _a(I, ae, 'unknown property "' + he + '"')];
+              var Et;
+              if (no(ae) === "string" && Ws(gt) && !gt.tokens && (Et = /^{([^}]+)}$/.exec(ae))) return [new _a(I, ae, '"' + he + '" does not support interpolation syntax\nUse an identity property function instead: `{ "type": "identity", "property": ' + JSON.stringify(Et[1]) + " }`.")];
+              var or = [];
+              return m.layerType === "symbol" && (he === "text-field" && V && !V.glyphs && or.push(new _a(I, ae, 'use of "text-field" requires a style "glyphs" property')), he === "text-font" && ys(Kl(ae)) && xo(ae.type) === "identity" && or.push(new _a(I, ae, '"text-font" does not support identity functions'))), or.concat(Qa({ key: m.key, value: ae, valueSpec: gt, style: V, styleSpec: $, expressionContext: "property", propertyType: y, propertyKey: he }));
+            }
+            function Wr(m) {
+              return Or(m, "paint");
+            }
+            function ni(m) {
+              return Or(m, "layout");
+            }
+            function Pi(m) {
+              var y = [], I = m.value, V = m.key, $ = m.style, ae = m.styleSpec;
+              !I.type && !I.ref && y.push(new _a(V, I, 'either "type" or "ref" is required'));
+              var he = xo(I.type), ze = xo(I.ref);
+              if (I.id) for (var rt = xo(I.id), gt = 0; gt < m.arrayIndex; gt++) {
+                var Et = $.layers[gt];
+                xo(Et.id) === rt && y.push(new _a(V, I.id, 'duplicate layer id "' + I.id + '", previously used at line ' + Et.id.__line__));
+              }
+              if ("ref" in I) {
+                ["type", "source", "source-layer", "filter", "layout"].forEach(function(Fr) {
+                  Fr in I && y.push(new _a(V, I[Fr], '"' + Fr + '" is prohibited for ref layers'));
+                });
+                var or;
+                $.layers.forEach(function(Fr) {
+                  xo(Fr.id) === ze && (or = Fr);
+                }), or ? or.ref ? y.push(new _a(V, I.ref, "ref cannot reference another ref layer")) : he = xo(or.type) : y.push(new _a(V, I.ref, 'ref layer "' + ze + '" not found'));
+              } else if (he !== "background") if (!I.source) y.push(new _a(V, I, 'missing required property "source"'));
+              else {
+                var _r = $.sources && $.sources[I.source], pr = _r && xo(_r.type);
+                _r ? pr === "vector" && he === "raster" ? y.push(new _a(V, I.source, 'layer "' + I.id + '" requires a raster source')) : pr === "raster" && he !== "raster" ? y.push(new _a(V, I.source, 'layer "' + I.id + '" requires a vector source')) : pr === "vector" && !I["source-layer"] ? y.push(new _a(V, I, 'layer "' + I.id + '" must specify a "source-layer"')) : pr === "raster-dem" && he !== "hillshade" ? y.push(new _a(V, I.source, "raster-dem source can only be used with layer type 'hillshade'.")) : he === "line" && I.paint && I.paint["line-gradient"] && (pr !== "geojson" || !_r.lineMetrics) && y.push(new _a(V, I, 'layer "' + I.id + '" specifies a line-gradient, which requires a GeoJSON source with `lineMetrics` enabled.')) : y.push(new _a(V, I.source, 'source "' + I.source + '" not found'));
+              }
+              return y = y.concat(le({ key: V, value: I, valueSpec: ae.layer, style: m.style, styleSpec: m.styleSpec, objectElementValidators: { "*": function() {
+                return [];
+              }, type: function() {
+                return Qa({ key: V + ".type", value: I.type, valueSpec: ae.layer.type, style: m.style, styleSpec: m.styleSpec, object: I, objectKey: "type" });
+              }, filter: dr, layout: function(oi) {
+                return le({ layer: I, key: oi.key, value: oi.value, style: oi.style, styleSpec: oi.styleSpec, objectElementValidators: { "*": function(Ai) {
+                  return ni(Ol({ layerType: he }, Ai));
+                } } });
+              }, paint: function(oi) {
+                return le({ layer: I, key: oi.key, value: oi.value, style: oi.style, styleSpec: oi.styleSpec, objectElementValidators: { "*": function(Ai) {
+                  return Wr(Ol({ layerType: he }, Ai));
+                } } });
+              } } })), y;
+            }
+            function cn(m) {
+              var y = m.value, I = m.key, V = no(y);
+              return V !== "string" ? [new _a(I, y, "string expected, " + V + " found")] : [];
+            }
+            var ln = { promoteId: Kn };
+            function Cn(m) {
+              var y = m.value, I = m.key, V = m.styleSpec, $ = m.style;
+              if (!y.type) return [new _a(I, y, '"type" is required')];
+              var ae = xo(y.type), he;
+              switch (ae) {
+                case "vector":
+                case "raster":
+                case "raster-dem":
+                  return he = le({ key: I, value: y, valueSpec: V["source_" + ae.replace("-", "_")], style: m.style, styleSpec: V, objectElementValidators: ln }), he;
+                case "geojson":
+                  if (he = le({ key: I, value: y, valueSpec: V.source_geojson, style: $, styleSpec: V, objectElementValidators: ln }), y.cluster) for (var ze in y.clusterProperties) {
+                    var rt = y.clusterProperties[ze], gt = rt[0], Et = rt[1], or = typeof gt == "string" ? [gt, ["accumulated"], ["get", ze]] : gt;
+                    he.push.apply(he, Tt({ key: I + "." + ze + ".map", value: Et, expressionContext: "cluster-map" })), he.push.apply(he, Tt({ key: I + "." + ze + ".reduce", value: or, expressionContext: "cluster-reduce" }));
+                  }
+                  return he;
+                case "video":
+                  return le({ key: I, value: y, valueSpec: V.source_video, style: $, styleSpec: V });
+                case "image":
+                  return le({ key: I, value: y, valueSpec: V.source_image, style: $, styleSpec: V });
+                case "canvas":
+                  return [new _a(I, null, "Please use runtime APIs to add canvas sources, rather than including them in stylesheets.", "source.canvas")];
+                default:
+                  return xr({ key: I + ".type", value: y.type, valueSpec: { values: ["vector", "raster", "raster-dem", "geojson", "video", "image"] } });
+              }
+            }
+            function Kn(m) {
+              var y = m.key, I = m.value;
+              if (no(I) === "string") return cn({ key: y, value: I });
+              var V = [];
+              for (var $ in I) V.push.apply(V, cn({ key: y + "." + $, value: I[$] }));
+              return V;
+            }
+            function Aa(m) {
+              var y = m.value, I = m.styleSpec, V = I.light, $ = m.style, ae = [], he = no(y);
+              if (y === void 0) return ae;
+              if (he !== "object") return ae = ae.concat([new _a("light", y, "object expected, " + he + " found")]), ae;
+              for (var ze in y) {
+                var rt = ze.match(/^(.*)-transition$/);
+                rt && V[rt[1]] && V[rt[1]].transition ? ae = ae.concat(Qa({ key: ze, value: y[ze], valueSpec: I.transition, style: $, styleSpec: I })) : V[ze] ? ae = ae.concat(Qa({ key: ze, value: y[ze], valueSpec: V[ze], style: $, styleSpec: I })) : ae = ae.concat([new _a(ze, y[ze], 'unknown property "' + ze + '"')]);
+              }
+              return ae;
+            }
+            function fa(m) {
+              return cn(m).length === 0 ? [] : Tt(m);
+            }
+            function $a(m) {
+              return cn(m).length === 0 ? [] : Tt(m);
+            }
+            var Co = { "*": function() {
+              return [];
+            }, array: Oe, boolean: Yt, number: Ze, color: Kt, constants: Vu, enum: xr, filter: dr, function: st, layer: Pi, object: le, source: Cn, light: Aa, string: cn, formatted: fa, resolvedImage: $a };
+            function Qa(m) {
+              var y = m.value, I = m.valueSpec, V = m.styleSpec;
+              if (I.expression && ys(xo(y))) return st(m);
+              if (I.expression && Ua(Kl(y))) return Tt(m);
+              if (I.type && Co[I.type]) return Co[I.type](m);
+              var $ = le(Ol({}, m, { valueSpec: I.type ? V[I.type] : I }));
+              return $;
+            }
+            function mo(m) {
+              var y = m.value, I = m.key, V = cn(m);
+              return V.length || (y.indexOf("{fontstack}") === -1 && V.push(new _a(I, y, '"glyphs" url must include a "{fontstack}" token')), y.indexOf("{range}") === -1 && V.push(new _a(I, y, '"glyphs" url must include a "{range}" token'))), V;
+            }
+            function Bo(m, y) {
+              y === void 0 && (y = Rn);
+              var I = [];
+              return I = I.concat(Qa({ key: "", value: m, valueSpec: y.$root, styleSpec: y, style: m, objectElementValidators: { glyphs: mo, "*": function() {
+                return [];
+              } } })), m.constants && (I = I.concat(Vu({ key: "constants", value: m.constants }))), Ps(I);
+            }
+            Bo.source = Ts(Cn), Bo.light = Ts(Aa), Bo.layer = Ts(Pi), Bo.filter = Ts(dr), Bo.paintProperty = Ts(Wr), Bo.layoutProperty = Ts(ni);
+            function Ps(m) {
+              return [].concat(m).sort(function(y, I) {
+                return y.line - I.line;
+              });
+            }
+            function Ts(m) {
+              return function() {
+                for (var y = [], I = arguments.length; I--; ) y[I] = arguments[I];
+                return Ps(m.apply(this, y));
+              };
+            }
+            var wo = Bo, To = wo.light, hl = wo.paintProperty, Ul = wo.layoutProperty;
+            function Lu(m, y) {
+              var I = false;
+              if (y && y.length) for (var V = 0, $ = y; V < $.length; V += 1) {
+                var ae = $[V];
+                m.fire(new da(new Error(ae.message))), I = true;
+              }
+              return I;
+            }
+            var au = eu, Js = 3;
+            function eu(m, y, I) {
+              var V = this.cells = [];
+              if (m instanceof ArrayBuffer) {
+                this.arrayBuffer = m;
+                var $ = new Int32Array(this.arrayBuffer);
+                m = $[0], y = $[1], I = $[2], this.d = y + 2 * I;
+                for (var ae = 0; ae < this.d * this.d; ae++) {
+                  var he = $[Js + ae], ze = $[Js + ae + 1];
+                  V.push(he === ze ? null : $.subarray(he, ze));
+                }
+                var rt = $[Js + V.length], gt = $[Js + V.length + 1];
+                this.keys = $.subarray(rt, gt), this.bboxes = $.subarray(gt), this.insert = this._insertReadonly;
+              } else {
+                this.d = y + 2 * I;
+                for (var Et = 0; Et < this.d * this.d; Et++) V.push([]);
+                this.keys = [], this.bboxes = [];
+              }
+              this.n = y, this.extent = m, this.padding = I, this.scale = y / m, this.uid = 0;
+              var or = I / y * m;
+              this.min = -or, this.max = m + or;
+            }
+            eu.prototype.insert = function(m, y, I, V, $) {
+              this._forEachCell(y, I, V, $, this._insertCell, this.uid++), this.keys.push(m), this.bboxes.push(y), this.bboxes.push(I), this.bboxes.push(V), this.bboxes.push($);
+            }, eu.prototype._insertReadonly = function() {
+              throw "Cannot insert into a GridIndex created from an ArrayBuffer.";
+            }, eu.prototype._insertCell = function(m, y, I, V, $, ae) {
+              this.cells[$].push(ae);
+            }, eu.prototype.query = function(m, y, I, V, $) {
+              var ae = this.min, he = this.max;
+              if (m <= ae && y <= ae && he <= I && he <= V && !$) return Array.prototype.slice.call(this.keys);
+              var ze = [], rt = {};
+              return this._forEachCell(m, y, I, V, this._queryCell, ze, rt, $), ze;
+            }, eu.prototype._queryCell = function(m, y, I, V, $, ae, he, ze) {
+              var rt = this.cells[$];
+              if (rt !== null) for (var gt = this.keys, Et = this.bboxes, or = 0; or < rt.length; or++) {
+                var _r = rt[or];
+                if (he[_r] === void 0) {
+                  var pr = _r * 4;
+                  (ze ? ze(Et[pr + 0], Et[pr + 1], Et[pr + 2], Et[pr + 3]) : m <= Et[pr + 2] && y <= Et[pr + 3] && I >= Et[pr + 0] && V >= Et[pr + 1]) ? (he[_r] = true, ae.push(gt[_r])) : he[_r] = false;
+                }
+              }
+            }, eu.prototype._forEachCell = function(m, y, I, V, $, ae, he, ze) {
+              for (var rt = this._convertToCellCoord(m), gt = this._convertToCellCoord(y), Et = this._convertToCellCoord(I), or = this._convertToCellCoord(V), _r = rt; _r <= Et; _r++) for (var pr = gt; pr <= or; pr++) {
+                var Fr = this.d * pr + _r;
+                if (!(ze && !ze(this._convertFromCellCoord(_r), this._convertFromCellCoord(pr), this._convertFromCellCoord(_r + 1), this._convertFromCellCoord(pr + 1))) && $.call(this, m, y, I, V, Fr, ae, he, ze)) return;
+              }
+            }, eu.prototype._convertFromCellCoord = function(m) {
+              return (m - this.padding) / this.scale;
+            }, eu.prototype._convertToCellCoord = function(m) {
+              return Math.max(0, Math.min(this.d - 1, Math.floor(m * this.scale) + this.padding));
+            }, eu.prototype.toArrayBuffer = function() {
+              if (this.arrayBuffer) return this.arrayBuffer;
+              for (var m = this.cells, y = Js + this.cells.length + 1 + 1, I = 0, V = 0; V < this.cells.length; V++) I += this.cells[V].length;
+              var $ = new Int32Array(y + I + this.keys.length + this.bboxes.length);
+              $[0] = this.extent, $[1] = this.n, $[2] = this.padding;
+              for (var ae = y, he = 0; he < m.length; he++) {
+                var ze = m[he];
+                $[Js + he] = ae, $.set(ze, ae), ae += ze.length;
+              }
+              return $[Js + m.length] = ae, $.set(this.keys, ae), ae += this.keys.length, $[Js + m.length + 1] = ae, $.set(this.bboxes, ae), ae += this.bboxes.length, $.buffer;
+            };
+            var dc = f.ImageData, Tl = f.ImageBitmap, Al = {};
+            function X(m, y, I) {
+              I === void 0 && (I = {}), Object.defineProperty(y, "_classRegistryKey", { value: m, writeable: false }), Al[m] = { klass: y, omit: I.omit || [], shallow: I.shallow || [] };
+            }
+            X("Object", Object), au.serialize = function(y, I) {
+              var V = y.toArrayBuffer();
+              return I && I.push(V), { buffer: V };
+            }, au.deserialize = function(y) {
+              return new au(y.buffer);
+            }, X("Grid", au), X("Color", cs), X("Error", Error), X("ResolvedImage", fl), X("StylePropertyFunction", ue), X("StyleExpression", Ac, { omit: ["_evaluator"] }), X("ZoomDependentExpression", hc), X("ZoomConstantExpression", Vc), X("CompoundExpression", Pa, { omit: ["_evaluate"] });
+            for (var se in Ka) Ka[se]._classRegistryKey || X("Expression_" + se, Ka[se]);
+            function Te(m) {
+              return m && typeof ArrayBuffer != "undefined" && (m instanceof ArrayBuffer || m.constructor && m.constructor.name === "ArrayBuffer");
+            }
+            function Ne(m) {
+              return Tl && m instanceof Tl;
+            }
+            function He(m, y) {
+              if (m == null || typeof m == "boolean" || typeof m == "number" || typeof m == "string" || m instanceof Boolean || m instanceof Number || m instanceof String || m instanceof Date || m instanceof RegExp) return m;
+              if (Te(m) || Ne(m)) return y && y.push(m), m;
+              if (ArrayBuffer.isView(m)) {
+                var I = m;
+                return y && y.push(I.buffer), I;
+              }
+              if (m instanceof dc) return y && y.push(m.data.buffer), m;
+              if (Array.isArray(m)) {
+                for (var V = [], $ = 0, ae = m; $ < ae.length; $ += 1) {
+                  var he = ae[$];
+                  V.push(He(he, y));
+                }
+                return V;
+              }
+              if (typeof m == "object") {
+                var ze = m.constructor, rt = ze._classRegistryKey;
+                if (!rt) throw new Error("can't serialize object of unregistered class");
+                var gt = ze.serialize ? ze.serialize(m, y) : {};
+                if (!ze.serialize) {
+                  for (var Et in m) if (m.hasOwnProperty(Et) && !(Al[rt].omit.indexOf(Et) >= 0)) {
+                    var or = m[Et];
+                    gt[Et] = Al[rt].shallow.indexOf(Et) >= 0 ? or : He(or, y);
+                  }
+                  m instanceof Error && (gt.message = m.message);
+                }
+                if (gt.$name) throw new Error("$name property is reserved for worker serialization logic.");
+                return rt !== "Object" && (gt.$name = rt), gt;
+              }
+              throw new Error("can't serialize object of type " + typeof m);
+            }
+            function Ye(m) {
+              if (m == null || typeof m == "boolean" || typeof m == "number" || typeof m == "string" || m instanceof Boolean || m instanceof Number || m instanceof String || m instanceof Date || m instanceof RegExp || Te(m) || Ne(m) || ArrayBuffer.isView(m) || m instanceof dc) return m;
+              if (Array.isArray(m)) return m.map(Ye);
+              if (typeof m == "object") {
+                var y = m.$name || "Object", I = Al[y], V = I.klass;
+                if (!V) throw new Error("can't deserialize unregistered class " + y);
+                if (V.deserialize) return V.deserialize(m);
+                for (var $ = Object.create(V.prototype), ae = 0, he = Object.keys(m); ae < he.length; ae += 1) {
+                  var ze = he[ae];
+                  if (ze !== "$name") {
+                    var rt = m[ze];
+                    $[ze] = Al[y].shallow.indexOf(ze) >= 0 ? rt : Ye(rt);
+                  }
+                }
+                return $;
+              }
+              throw new Error("can't deserialize object of type " + typeof m);
+            }
+            var kt = function() {
+              this.first = true;
+            };
+            kt.prototype.update = function(y, I) {
+              var V = Math.floor(y);
+              return this.first ? (this.first = false, this.lastIntegerZoom = V, this.lastIntegerZoomTime = 0, this.lastZoom = y, this.lastFloorZoom = V, true) : (this.lastFloorZoom > V ? (this.lastIntegerZoom = V + 1, this.lastIntegerZoomTime = I) : this.lastFloorZoom < V && (this.lastIntegerZoom = V, this.lastIntegerZoomTime = I), y !== this.lastZoom ? (this.lastZoom = y, this.lastFloorZoom = V, true) : false);
+            };
+            var nt = { "Latin-1 Supplement": function(m) {
+              return m >= 128 && m <= 255;
+            }, Arabic: function(m) {
+              return m >= 1536 && m <= 1791;
+            }, "Arabic Supplement": function(m) {
+              return m >= 1872 && m <= 1919;
+            }, "Arabic Extended-A": function(m) {
+              return m >= 2208 && m <= 2303;
+            }, "Hangul Jamo": function(m) {
+              return m >= 4352 && m <= 4607;
+            }, "Unified Canadian Aboriginal Syllabics": function(m) {
+              return m >= 5120 && m <= 5759;
+            }, Khmer: function(m) {
+              return m >= 6016 && m <= 6143;
+            }, "Unified Canadian Aboriginal Syllabics Extended": function(m) {
+              return m >= 6320 && m <= 6399;
+            }, "General Punctuation": function(m) {
+              return m >= 8192 && m <= 8303;
+            }, "Letterlike Symbols": function(m) {
+              return m >= 8448 && m <= 8527;
+            }, "Number Forms": function(m) {
+              return m >= 8528 && m <= 8591;
+            }, "Miscellaneous Technical": function(m) {
+              return m >= 8960 && m <= 9215;
+            }, "Control Pictures": function(m) {
+              return m >= 9216 && m <= 9279;
+            }, "Optical Character Recognition": function(m) {
+              return m >= 9280 && m <= 9311;
+            }, "Enclosed Alphanumerics": function(m) {
+              return m >= 9312 && m <= 9471;
+            }, "Geometric Shapes": function(m) {
+              return m >= 9632 && m <= 9727;
+            }, "Miscellaneous Symbols": function(m) {
+              return m >= 9728 && m <= 9983;
+            }, "Miscellaneous Symbols and Arrows": function(m) {
+              return m >= 11008 && m <= 11263;
+            }, "CJK Radicals Supplement": function(m) {
+              return m >= 11904 && m <= 12031;
+            }, "Kangxi Radicals": function(m) {
+              return m >= 12032 && m <= 12255;
+            }, "Ideographic Description Characters": function(m) {
+              return m >= 12272 && m <= 12287;
+            }, "CJK Symbols and Punctuation": function(m) {
+              return m >= 12288 && m <= 12351;
+            }, Hiragana: function(m) {
+              return m >= 12352 && m <= 12447;
+            }, Katakana: function(m) {
+              return m >= 12448 && m <= 12543;
+            }, Bopomofo: function(m) {
+              return m >= 12544 && m <= 12591;
+            }, "Hangul Compatibility Jamo": function(m) {
+              return m >= 12592 && m <= 12687;
+            }, Kanbun: function(m) {
+              return m >= 12688 && m <= 12703;
+            }, "Bopomofo Extended": function(m) {
+              return m >= 12704 && m <= 12735;
+            }, "CJK Strokes": function(m) {
+              return m >= 12736 && m <= 12783;
+            }, "Katakana Phonetic Extensions": function(m) {
+              return m >= 12784 && m <= 12799;
+            }, "Enclosed CJK Letters and Months": function(m) {
+              return m >= 12800 && m <= 13055;
+            }, "CJK Compatibility": function(m) {
+              return m >= 13056 && m <= 13311;
+            }, "CJK Unified Ideographs Extension A": function(m) {
+              return m >= 13312 && m <= 19903;
+            }, "Yijing Hexagram Symbols": function(m) {
+              return m >= 19904 && m <= 19967;
+            }, "CJK Unified Ideographs": function(m) {
+              return m >= 19968 && m <= 40959;
+            }, "Yi Syllables": function(m) {
+              return m >= 40960 && m <= 42127;
+            }, "Yi Radicals": function(m) {
+              return m >= 42128 && m <= 42191;
+            }, "Hangul Jamo Extended-A": function(m) {
+              return m >= 43360 && m <= 43391;
+            }, "Hangul Syllables": function(m) {
+              return m >= 44032 && m <= 55215;
+            }, "Hangul Jamo Extended-B": function(m) {
+              return m >= 55216 && m <= 55295;
+            }, "Private Use Area": function(m) {
+              return m >= 57344 && m <= 63743;
+            }, "CJK Compatibility Ideographs": function(m) {
+              return m >= 63744 && m <= 64255;
+            }, "Arabic Presentation Forms-A": function(m) {
+              return m >= 64336 && m <= 65023;
+            }, "Vertical Forms": function(m) {
+              return m >= 65040 && m <= 65055;
+            }, "CJK Compatibility Forms": function(m) {
+              return m >= 65072 && m <= 65103;
+            }, "Small Form Variants": function(m) {
+              return m >= 65104 && m <= 65135;
+            }, "Arabic Presentation Forms-B": function(m) {
+              return m >= 65136 && m <= 65279;
+            }, "Halfwidth and Fullwidth Forms": function(m) {
+              return m >= 65280 && m <= 65519;
+            } };
+            function jt(m) {
+              for (var y = 0, I = m; y < I.length; y += 1) {
+                var V = I[y];
+                if (qr(V.charCodeAt(0))) return true;
+              }
+              return false;
+            }
+            function gr(m) {
+              for (var y = 0, I = m; y < I.length; y += 1) {
+                var V = I[y];
+                if (!yr(V.charCodeAt(0))) return false;
+              }
+              return true;
+            }
+            function yr(m) {
+              return !(nt.Arabic(m) || nt["Arabic Supplement"](m) || nt["Arabic Extended-A"](m) || nt["Arabic Presentation Forms-A"](m) || nt["Arabic Presentation Forms-B"](m));
+            }
+            function Hr(m) {
+              return m < 11904 ? false : !!(nt["Bopomofo Extended"](m) || nt.Bopomofo(m) || nt["CJK Compatibility Forms"](m) || nt["CJK Compatibility Ideographs"](m) || nt["CJK Compatibility"](m) || nt["CJK Radicals Supplement"](m) || nt["CJK Strokes"](m) || nt["CJK Symbols and Punctuation"](m) || nt["CJK Unified Ideographs Extension A"](m) || nt["CJK Unified Ideographs"](m) || nt["Enclosed CJK Letters and Months"](m) || nt["Halfwidth and Fullwidth Forms"](m) || nt.Hiragana(m) || nt["Ideographic Description Characters"](m) || nt["Kangxi Radicals"](m) || nt["Katakana Phonetic Extensions"](m) || nt.Katakana(m) || nt["Vertical Forms"](m) || nt["Yi Radicals"](m) || nt["Yi Syllables"](m));
+            }
+            function qr(m) {
+              return m === 746 || m === 747 ? true : m < 4352 ? false : !!(nt["Bopomofo Extended"](m) || nt.Bopomofo(m) || nt["CJK Compatibility Forms"](m) && !(m >= 65097 && m <= 65103) || nt["CJK Compatibility Ideographs"](m) || nt["CJK Compatibility"](m) || nt["CJK Radicals Supplement"](m) || nt["CJK Strokes"](m) || nt["CJK Symbols and Punctuation"](m) && !(m >= 12296 && m <= 12305) && !(m >= 12308 && m <= 12319) && m !== 12336 || nt["CJK Unified Ideographs Extension A"](m) || nt["CJK Unified Ideographs"](m) || nt["Enclosed CJK Letters and Months"](m) || nt["Hangul Compatibility Jamo"](m) || nt["Hangul Jamo Extended-A"](m) || nt["Hangul Jamo Extended-B"](m) || nt["Hangul Jamo"](m) || nt["Hangul Syllables"](m) || nt.Hiragana(m) || nt["Ideographic Description Characters"](m) || nt.Kanbun(m) || nt["Kangxi Radicals"](m) || nt["Katakana Phonetic Extensions"](m) || nt.Katakana(m) && m !== 12540 || nt["Halfwidth and Fullwidth Forms"](m) && m !== 65288 && m !== 65289 && m !== 65293 && !(m >= 65306 && m <= 65310) && m !== 65339 && m !== 65341 && m !== 65343 && !(m >= 65371 && m <= 65503) && m !== 65507 && !(m >= 65512 && m <= 65519) || nt["Small Form Variants"](m) && !(m >= 65112 && m <= 65118) && !(m >= 65123 && m <= 65126) || nt["Unified Canadian Aboriginal Syllabics"](m) || nt["Unified Canadian Aboriginal Syllabics Extended"](m) || nt["Vertical Forms"](m) || nt["Yijing Hexagram Symbols"](m) || nt["Yi Syllables"](m) || nt["Yi Radicals"](m));
+            }
+            function _i(m) {
+              return !!(nt["Latin-1 Supplement"](m) && (m === 167 || m === 169 || m === 174 || m === 177 || m === 188 || m === 189 || m === 190 || m === 215 || m === 247) || nt["General Punctuation"](m) && (m === 8214 || m === 8224 || m === 8225 || m === 8240 || m === 8241 || m === 8251 || m === 8252 || m === 8258 || m === 8263 || m === 8264 || m === 8265 || m === 8273) || nt["Letterlike Symbols"](m) || nt["Number Forms"](m) || nt["Miscellaneous Technical"](m) && (m >= 8960 && m <= 8967 || m >= 8972 && m <= 8991 || m >= 8996 && m <= 9e3 || m === 9003 || m >= 9085 && m <= 9114 || m >= 9150 && m <= 9165 || m === 9167 || m >= 9169 && m <= 9179 || m >= 9186 && m <= 9215) || nt["Control Pictures"](m) && m !== 9251 || nt["Optical Character Recognition"](m) || nt["Enclosed Alphanumerics"](m) || nt["Geometric Shapes"](m) || nt["Miscellaneous Symbols"](m) && !(m >= 9754 && m <= 9759) || nt["Miscellaneous Symbols and Arrows"](m) && (m >= 11026 && m <= 11055 || m >= 11088 && m <= 11097 || m >= 11192 && m <= 11243) || nt["CJK Symbols and Punctuation"](m) || nt.Katakana(m) || nt["Private Use Area"](m) || nt["CJK Compatibility Forms"](m) || nt["Small Form Variants"](m) || nt["Halfwidth and Fullwidth Forms"](m) || m === 8734 || m === 8756 || m === 8757 || m >= 9984 && m <= 10087 || m >= 10102 && m <= 10131 || m === 65532 || m === 65533);
+            }
+            function bi(m) {
+              return !(qr(m) || _i(m));
+            }
+            function Zr(m) {
+              return nt.Arabic(m) || nt["Arabic Supplement"](m) || nt["Arabic Extended-A"](m) || nt["Arabic Presentation Forms-A"](m) || nt["Arabic Presentation Forms-B"](m);
+            }
+            function ai(m) {
+              return m >= 1424 && m <= 2303 || nt["Arabic Presentation Forms-A"](m) || nt["Arabic Presentation Forms-B"](m);
+            }
+            function gi(m, y) {
+              return !(!y && ai(m) || m >= 2304 && m <= 3583 || m >= 3840 && m <= 4255 || nt.Khmer(m));
+            }
+            function Ii(m) {
+              for (var y = 0, I = m; y < I.length; y += 1) {
+                var V = I[y];
+                if (ai(V.charCodeAt(0))) return true;
+              }
+              return false;
+            }
+            function Si(m, y) {
+              for (var I = 0, V = m; I < V.length; I += 1) {
+                var $ = V[I];
+                if (!gi($.charCodeAt(0), y)) return false;
+              }
+              return true;
+            }
+            var ei = { unavailable: "unavailable", deferred: "deferred", loading: "loading", loaded: "loaded", error: "error" }, Ln = null, En = ei.unavailable, Un = null, ia = function(m) {
+              m && typeof m == "string" && m.indexOf("NetworkError") > -1 && (En = ei.error), Ln && Ln(m);
+            };
+            function Ea() {
+              Ia.fire(new Xo("pluginStateChange", { pluginStatus: En, pluginURL: Un }));
+            }
+            var Ia = new Wn(), yo = function() {
+              return En;
+            }, Da = function(m) {
+              return m({ pluginStatus: En, pluginURL: Un }), Ia.on("pluginStateChange", m), m;
+            }, go = function(m, y, I) {
+              if (I === void 0 && (I = false), En === ei.deferred || En === ei.loading || En === ei.loaded) throw new Error("setRTLTextPlugin cannot be called multiple times.");
+              Un = lt.resolveURL(m), En = ei.deferred, Ln = y, Ea(), I || Is();
+            }, Is = function() {
+              if (En !== ei.deferred || !Un) throw new Error("rtl-text-plugin cannot be downloaded unless a pluginURL is specified");
+              En = ei.loading, Ea(), Un && ri({ url: Un }, function(m) {
+                m ? ia(m) : (En = ei.loaded, Ea());
+              });
+            }, Ms = { applyArabicShaping: null, processBidirectionalText: null, processStyledBidirectionalText: null, isLoaded: function() {
+              return En === ei.loaded || Ms.applyArabicShaping != null;
+            }, isLoading: function() {
+              return En === ei.loading;
+            }, setState: function(y) {
+              En = y.pluginStatus, Un = y.pluginURL;
+            }, isParsed: function() {
+              return Ms.applyArabicShaping != null && Ms.processBidirectionalText != null && Ms.processStyledBidirectionalText != null;
+            }, getPluginURL: function() {
+              return Un;
+            } }, Xs = function() {
+              !Ms.isLoading() && !Ms.isLoaded() && yo() === "deferred" && Is();
+            }, Gn = function(y, I) {
+              this.zoom = y, I ? (this.now = I.now, this.fadeDuration = I.fadeDuration, this.zoomHistory = I.zoomHistory, this.transition = I.transition) : (this.now = 0, this.fadeDuration = 0, this.zoomHistory = new kt(), this.transition = {});
+            };
+            Gn.prototype.isSupportedScript = function(y) {
+              return Si(y, Ms.isLoaded());
+            }, Gn.prototype.crossFadingFactor = function() {
+              return this.fadeDuration === 0 ? 1 : Math.min((this.now - this.zoomHistory.lastIntegerZoomTime) / this.fadeDuration, 1);
+            }, Gn.prototype.getCrossfadeParameters = function() {
+              var y = this.zoom, I = y - Math.floor(y), V = this.crossFadingFactor();
+              return y > this.zoomHistory.lastIntegerZoom ? { fromScale: 2, toScale: 1, t: I + (1 - I) * V } : { fromScale: 0.5, toScale: 1, t: 1 - (1 - V) * I };
+            };
+            var ja = function(y, I) {
+              this.property = y, this.value = I, this.expression = w(I === void 0 ? y.specification.default : I, y.specification);
+            };
+            ja.prototype.isDataDriven = function() {
+              return this.expression.kind === "source" || this.expression.kind === "composite";
+            }, ja.prototype.possiblyEvaluate = function(y, I, V) {
+              return this.property.possiblyEvaluate(this, y, I, V);
+            };
+            var Fo = function(y) {
+              this.property = y, this.value = new ja(y, void 0);
+            };
+            Fo.prototype.transitioned = function(y, I) {
+              return new $s(this.property, this.value, I, x({}, y.transition, this.transition), y.now);
+            }, Fo.prototype.untransitioned = function() {
+              return new $s(this.property, this.value, null, {}, 0);
+            };
+            var Uo = function(y) {
+              this._properties = y, this._values = Object.create(y.defaultTransitionablePropertyValues);
+            };
+            Uo.prototype.getValue = function(y) {
+              return j(this._values[y].value.value);
+            }, Uo.prototype.setValue = function(y, I) {
+              this._values.hasOwnProperty(y) || (this._values[y] = new Fo(this._values[y].property)), this._values[y].value = new ja(this._values[y].property, I === null ? void 0 : j(I));
+            }, Uo.prototype.getTransition = function(y) {
+              return j(this._values[y].transition);
+            }, Uo.prototype.setTransition = function(y, I) {
+              this._values.hasOwnProperty(y) || (this._values[y] = new Fo(this._values[y].property)), this._values[y].transition = j(I) || void 0;
+            }, Uo.prototype.serialize = function() {
+              for (var y = {}, I = 0, V = Object.keys(this._values); I < V.length; I += 1) {
+                var $ = V[I], ae = this.getValue($);
+                ae !== void 0 && (y[$] = ae);
+                var he = this.getTransition($);
+                he !== void 0 && (y[$ + "-transition"] = he);
+              }
+              return y;
+            }, Uo.prototype.transitioned = function(y, I) {
+              for (var V = new Sl(this._properties), $ = 0, ae = Object.keys(this._values); $ < ae.length; $ += 1) {
+                var he = ae[$];
+                V._values[he] = this._values[he].transitioned(y, I._values[he]);
+              }
+              return V;
+            }, Uo.prototype.untransitioned = function() {
+              for (var y = new Sl(this._properties), I = 0, V = Object.keys(this._values); I < V.length; I += 1) {
+                var $ = V[I];
+                y._values[$] = this._values[$].untransitioned();
+              }
+              return y;
+            };
+            var $s = function(y, I, V, $, ae) {
+              this.property = y, this.value = I, this.begin = ae + $.delay || 0, this.end = this.begin + $.duration || 0, y.specification.transition && ($.delay || $.duration) && (this.prior = V);
+            };
+            $s.prototype.possiblyEvaluate = function(y, I, V) {
+              var $ = y.now || 0, ae = this.value.possiblyEvaluate(y, I, V), he = this.prior;
+              if (he) {
+                if ($ > this.end) return this.prior = null, ae;
+                if (this.value.isDataDriven()) return this.prior = null, ae;
+                if ($ < this.begin) return he.possiblyEvaluate(y, I, V);
+                var ze = ($ - this.begin) / (this.end - this.begin);
+                return this.property.interpolate(he.possiblyEvaluate(y, I, V), ae, v(ze));
+              } else return ae;
+            };
+            var Sl = function(y) {
+              this._properties = y, this._values = Object.create(y.defaultTransitioningPropertyValues);
+            };
+            Sl.prototype.possiblyEvaluate = function(y, I, V) {
+              for (var $ = new Sc(this._properties), ae = 0, he = Object.keys(this._values); ae < he.length; ae += 1) {
+                var ze = he[ae];
+                $._values[ze] = this._values[ze].possiblyEvaluate(y, I, V);
+              }
+              return $;
+            }, Sl.prototype.hasTransition = function() {
+              for (var y = 0, I = Object.keys(this._values); y < I.length; y += 1) {
+                var V = I[y];
+                if (this._values[V].prior) return true;
+              }
+              return false;
+            };
+            var bu = function(y) {
+              this._properties = y, this._values = Object.create(y.defaultPropertyValues);
+            };
+            bu.prototype.getValue = function(y) {
+              return j(this._values[y].value);
+            }, bu.prototype.setValue = function(y, I) {
+              this._values[y] = new ja(this._values[y].property, I === null ? void 0 : j(I));
+            }, bu.prototype.serialize = function() {
+              for (var y = {}, I = 0, V = Object.keys(this._values); I < V.length; I += 1) {
+                var $ = V[I], ae = this.getValue($);
+                ae !== void 0 && (y[$] = ae);
+              }
+              return y;
+            }, bu.prototype.possiblyEvaluate = function(y, I, V) {
+              for (var $ = new Sc(this._properties), ae = 0, he = Object.keys(this._values); ae < he.length; ae += 1) {
+                var ze = he[ae];
+                $._values[ze] = this._values[ze].possiblyEvaluate(y, I, V);
+              }
+              return $;
+            };
+            var dl = function(y, I, V) {
+              this.property = y, this.value = I, this.parameters = V;
+            };
+            dl.prototype.isConstant = function() {
+              return this.value.kind === "constant";
+            }, dl.prototype.constantOr = function(y) {
+              return this.value.kind === "constant" ? this.value.value : y;
+            }, dl.prototype.evaluate = function(y, I, V, $) {
+              return this.property.evaluate(this.value, this.parameters, y, I, V, $);
+            };
+            var Sc = function(y) {
+              this._properties = y, this._values = Object.create(y.defaultPossiblyEvaluatedValues);
+            };
+            Sc.prototype.get = function(y) {
+              return this._values[y];
+            };
+            var Me = function(y) {
+              this.specification = y;
+            };
+            Me.prototype.possiblyEvaluate = function(y, I) {
+              return y.expression.evaluate(I);
+            }, Me.prototype.interpolate = function(y, I, V) {
+              var $ = zu[this.specification.type];
+              return $ ? $(y, I, V) : y;
+            };
+            var bt = function(y, I) {
+              this.specification = y, this.overrides = I;
+            };
+            bt.prototype.possiblyEvaluate = function(y, I, V, $) {
+              return y.expression.kind === "constant" || y.expression.kind === "camera" ? new dl(this, { kind: "constant", value: y.expression.evaluate(I, null, {}, V, $) }, I) : new dl(this, y.expression, I);
+            }, bt.prototype.interpolate = function(y, I, V) {
+              if (y.value.kind !== "constant" || I.value.kind !== "constant") return y;
+              if (y.value.value === void 0 || I.value.value === void 0) return new dl(this, { kind: "constant", value: void 0 }, y.parameters);
+              var $ = zu[this.specification.type];
+              return $ ? new dl(this, { kind: "constant", value: $(y.value.value, I.value.value, V) }, y.parameters) : y;
+            }, bt.prototype.evaluate = function(y, I, V, $, ae, he) {
+              return y.kind === "constant" ? y.value : y.evaluate(I, V, $, ae, he);
+            };
+            var zt = function(m) {
+              function y() {
+                m.apply(this, arguments);
+              }
+              return m && (y.__proto__ = m), y.prototype = Object.create(m && m.prototype), y.prototype.constructor = y, y.prototype.possiblyEvaluate = function(V, $, ae, he) {
+                if (V.value === void 0) return new dl(this, { kind: "constant", value: void 0 }, $);
+                if (V.expression.kind === "constant") {
+                  var ze = V.expression.evaluate($, null, {}, ae, he), rt = V.property.specification.type === "resolvedImage", gt = rt && typeof ze != "string" ? ze.name : ze, Et = this._calculate(gt, gt, gt, $);
+                  return new dl(this, { kind: "constant", value: Et }, $);
+                } else if (V.expression.kind === "camera") {
+                  var or = this._calculate(V.expression.evaluate({ zoom: $.zoom - 1 }), V.expression.evaluate({ zoom: $.zoom }), V.expression.evaluate({ zoom: $.zoom + 1 }), $);
+                  return new dl(this, { kind: "constant", value: or }, $);
+                } else return new dl(this, V.expression, $);
+              }, y.prototype.evaluate = function(V, $, ae, he, ze, rt) {
+                if (V.kind === "source") {
+                  var gt = V.evaluate($, ae, he, ze, rt);
+                  return this._calculate(gt, gt, gt, $);
+                } else return V.kind === "composite" ? this._calculate(V.evaluate({ zoom: Math.floor($.zoom) - 1 }, ae, he), V.evaluate({ zoom: Math.floor($.zoom) }, ae, he), V.evaluate({ zoom: Math.floor($.zoom) + 1 }, ae, he), $) : V.value;
+              }, y.prototype._calculate = function(V, $, ae, he) {
+                var ze = he.zoom;
+                return ze > he.zoomHistory.lastIntegerZoom ? { from: V, to: $ } : { from: ae, to: $ };
+              }, y.prototype.interpolate = function(V) {
+                return V;
+              }, y;
+            }(bt), Rr = function(y) {
+              this.specification = y;
+            };
+            Rr.prototype.possiblyEvaluate = function(y, I, V, $) {
+              if (y.value !== void 0) if (y.expression.kind === "constant") {
+                var ae = y.expression.evaluate(I, null, {}, V, $);
+                return this._calculate(ae, ae, ae, I);
+              } else return this._calculate(y.expression.evaluate(new Gn(Math.floor(I.zoom - 1), I)), y.expression.evaluate(new Gn(Math.floor(I.zoom), I)), y.expression.evaluate(new Gn(Math.floor(I.zoom + 1), I)), I);
+            }, Rr.prototype._calculate = function(y, I, V, $) {
+              var ae = $.zoom;
+              return ae > $.zoomHistory.lastIntegerZoom ? { from: y, to: I } : { from: V, to: I };
+            }, Rr.prototype.interpolate = function(y) {
+              return y;
+            };
+            var jr = function(y) {
+              this.specification = y;
+            };
+            jr.prototype.possiblyEvaluate = function(y, I, V, $) {
+              return !!y.expression.evaluate(I, null, {}, V, $);
+            }, jr.prototype.interpolate = function() {
+              return false;
+            };
+            var Nr = function(y) {
+              this.properties = y, this.defaultPropertyValues = {}, this.defaultTransitionablePropertyValues = {}, this.defaultTransitioningPropertyValues = {}, this.defaultPossiblyEvaluatedValues = {}, this.overridableProperties = [];
+              for (var I in y) {
+                var V = y[I];
+                V.specification.overridable && this.overridableProperties.push(I);
+                var $ = this.defaultPropertyValues[I] = new ja(V, void 0), ae = this.defaultTransitionablePropertyValues[I] = new Fo(V);
+                this.defaultTransitioningPropertyValues[I] = ae.untransitioned(), this.defaultPossiblyEvaluatedValues[I] = $.possiblyEvaluate({});
+              }
+            };
+            X("DataDrivenProperty", bt), X("DataConstantProperty", Me), X("CrossFadedDataDrivenProperty", zt), X("CrossFadedProperty", Rr), X("ColorRampProperty", jr);
+            var Gr = "-transition", mi = function(m) {
+              function y(I, V) {
+                if (m.call(this), this.id = I.id, this.type = I.type, this._featureFilter = { filter: function() {
+                  return true;
+                }, needGeometry: false }, I.type !== "custom" && (I = I, this.metadata = I.metadata, this.minzoom = I.minzoom, this.maxzoom = I.maxzoom, I.type !== "background" && (this.source = I.source, this.sourceLayer = I["source-layer"], this.filter = I.filter), V.layout && (this._unevaluatedLayout = new bu(V.layout)), V.paint)) {
+                  this._transitionablePaint = new Uo(V.paint);
+                  for (var $ in I.paint) this.setPaintProperty($, I.paint[$], { validate: false });
+                  for (var ae in I.layout) this.setLayoutProperty(ae, I.layout[ae], { validate: false });
+                  this._transitioningPaint = this._transitionablePaint.untransitioned(), this.paint = new Sc(V.paint);
+                }
+              }
+              return m && (y.__proto__ = m), y.prototype = Object.create(m && m.prototype), y.prototype.constructor = y, y.prototype.getCrossfadeParameters = function() {
+                return this._crossfadeParameters;
+              }, y.prototype.getLayoutProperty = function(V) {
+                return V === "visibility" ? this.visibility : this._unevaluatedLayout.getValue(V);
+              }, y.prototype.setLayoutProperty = function(V, $, ae) {
+                if (ae === void 0 && (ae = {}), $ != null) {
+                  var he = "layers." + this.id + ".layout." + V;
+                  if (this._validate(Ul, he, V, $, ae)) return;
+                }
+                if (V === "visibility") {
+                  this.visibility = $;
+                  return;
+                }
+                this._unevaluatedLayout.setValue(V, $);
+              }, y.prototype.getPaintProperty = function(V) {
+                return U(V, Gr) ? this._transitionablePaint.getTransition(V.slice(0, -Gr.length)) : this._transitionablePaint.getValue(V);
+              }, y.prototype.setPaintProperty = function(V, $, ae) {
+                if (ae === void 0 && (ae = {}), $ != null) {
+                  var he = "layers." + this.id + ".paint." + V;
+                  if (this._validate(hl, he, V, $, ae)) return false;
+                }
+                if (U(V, Gr)) return this._transitionablePaint.setTransition(V.slice(0, -Gr.length), $ || void 0), false;
+                var ze = this._transitionablePaint._values[V], rt = ze.property.specification["property-type"] === "cross-faded-data-driven", gt = ze.value.isDataDriven(), Et = ze.value;
+                this._transitionablePaint.setValue(V, $), this._handleSpecialPaintPropertyUpdate(V);
+                var or = this._transitionablePaint._values[V].value, _r = or.isDataDriven();
+                return _r || gt || rt || this._handleOverridablePaintPropertyUpdate(V, Et, or);
+              }, y.prototype._handleSpecialPaintPropertyUpdate = function(V) {
+              }, y.prototype._handleOverridablePaintPropertyUpdate = function(V, $, ae) {
+                return false;
+              }, y.prototype.isHidden = function(V) {
+                return this.minzoom && V < this.minzoom || this.maxzoom && V >= this.maxzoom ? true : this.visibility === "none";
+              }, y.prototype.updateTransitions = function(V) {
+                this._transitioningPaint = this._transitionablePaint.transitioned(V, this._transitioningPaint);
+              }, y.prototype.hasTransition = function() {
+                return this._transitioningPaint.hasTransition();
+              }, y.prototype.recalculate = function(V, $) {
+                V.getCrossfadeParameters && (this._crossfadeParameters = V.getCrossfadeParameters()), this._unevaluatedLayout && (this.layout = this._unevaluatedLayout.possiblyEvaluate(V, void 0, $)), this.paint = this._transitioningPaint.possiblyEvaluate(V, void 0, $);
+              }, y.prototype.serialize = function() {
+                var V = { id: this.id, type: this.type, source: this.source, "source-layer": this.sourceLayer, metadata: this.metadata, minzoom: this.minzoom, maxzoom: this.maxzoom, filter: this.filter, layout: this._unevaluatedLayout && this._unevaluatedLayout.serialize(), paint: this._transitionablePaint && this._transitionablePaint.serialize() };
+                return this.visibility && (V.layout = V.layout || {}, V.layout.visibility = this.visibility), Z(V, function($, ae) {
+                  return $ !== void 0 && !(ae === "layout" && !Object.keys($).length) && !(ae === "paint" && !Object.keys($).length);
+                });
+              }, y.prototype._validate = function(V, $, ae, he, ze) {
+                return ze === void 0 && (ze = {}), ze && ze.validate === false ? false : Lu(this, V.call(wo, { key: $, layerType: this.type, objectKey: ae, value: he, styleSpec: Rn, style: { glyphs: true, sprite: true } }));
+              }, y.prototype.is3D = function() {
+                return false;
+              }, y.prototype.isTileClipped = function() {
+                return false;
+              }, y.prototype.hasOffscreenPass = function() {
+                return false;
+              }, y.prototype.resize = function() {
+              }, y.prototype.isStateDependent = function() {
+                for (var V in this.paint._values) {
+                  var $ = this.paint.get(V);
+                  if (!(!($ instanceof dl) || !Ws($.property.specification)) && ($.value.kind === "source" || $.value.kind === "composite") && $.value.isStateDependent) return true;
+                }
+                return false;
+              }, y;
+            }(Wn), Ui = { Int8: Int8Array, Uint8: Uint8Array, Int16: Int16Array, Uint16: Uint16Array, Int32: Int32Array, Uint32: Uint32Array, Float32: Float32Array }, qi = function(y, I) {
+              this._structArray = y, this._pos1 = I * this.size, this._pos2 = this._pos1 / 2, this._pos4 = this._pos1 / 4, this._pos8 = this._pos1 / 8;
+            }, Ei = 128, Hn = 5, en = function() {
+              this.isTransferred = false, this.capacity = -1, this.resize(0);
+            };
+            en.serialize = function(y, I) {
+              return y._trim(), I && (y.isTransferred = true, I.push(y.arrayBuffer)), { length: y.length, arrayBuffer: y.arrayBuffer };
+            }, en.deserialize = function(y) {
+              var I = Object.create(this.prototype);
+              return I.arrayBuffer = y.arrayBuffer, I.length = y.length, I.capacity = y.arrayBuffer.byteLength / I.bytesPerElement, I._refreshViews(), I;
+            }, en.prototype._trim = function() {
+              this.length !== this.capacity && (this.capacity = this.length, this.arrayBuffer = this.arrayBuffer.slice(0, this.length * this.bytesPerElement), this._refreshViews());
+            }, en.prototype.clear = function() {
+              this.length = 0;
+            }, en.prototype.resize = function(y) {
+              this.reserve(y), this.length = y;
+            }, en.prototype.reserve = function(y) {
+              if (y > this.capacity) {
+                this.capacity = Math.max(y, Math.floor(this.capacity * Hn), Ei), this.arrayBuffer = new ArrayBuffer(this.capacity * this.bytesPerElement);
+                var I = this.uint8;
+                this._refreshViews(), I && this.uint8.set(I);
+              }
+            }, en.prototype._refreshViews = function() {
+              throw new Error("_refreshViews() must be implemented by each concrete StructArray layout");
+            };
+            function Wi(m, y) {
+              y === void 0 && (y = 1);
+              var I = 0, V = 0, $ = m.map(function(he) {
+                var ze = si(he.type), rt = I = Mr(I, Math.max(y, ze)), gt = he.components || 1;
+                return V = Math.max(V, ze), I += ze * gt, { name: he.name, type: he.type, components: gt, offset: rt };
+              }), ae = Mr(I, Math.max(V, y));
+              return { members: $, size: ae, alignment: y };
+            }
+            function si(m) {
+              return Ui[m].BYTES_PER_ELEMENT;
+            }
+            function Mr(m, y) {
+              return Math.ceil(m / y) * y;
+            }
+            var Yr = function(m) {
+              function y() {
+                m.apply(this, arguments);
+              }
+              return m && (y.__proto__ = m), y.prototype = Object.create(m && m.prototype), y.prototype.constructor = y, y.prototype._refreshViews = function() {
+                this.uint8 = new Uint8Array(this.arrayBuffer), this.int16 = new Int16Array(this.arrayBuffer);
+              }, y.prototype.emplaceBack = function(V, $) {
+                var ae = this.length;
+                return this.resize(ae + 1), this.emplace(ae, V, $);
+              }, y.prototype.emplace = function(V, $, ae) {
+                var he = V * 2;
+                return this.int16[he + 0] = $, this.int16[he + 1] = ae, V;
+              }, y;
+            }(en);
+            Yr.prototype.bytesPerElement = 4, X("StructArrayLayout2i4", Yr);
+            var xi = function(m) {
+              function y() {
+                m.apply(this, arguments);
+              }
+              return m && (y.__proto__ = m), y.prototype = Object.create(m && m.prototype), y.prototype.constructor = y, y.prototype._refreshViews = function() {
+                this.uint8 = new Uint8Array(this.arrayBuffer), this.int16 = new Int16Array(this.arrayBuffer);
+              }, y.prototype.emplaceBack = function(V, $, ae, he) {
+                var ze = this.length;
+                return this.resize(ze + 1), this.emplace(ze, V, $, ae, he);
+              }, y.prototype.emplace = function(V, $, ae, he, ze) {
+                var rt = V * 4;
+                return this.int16[rt + 0] = $, this.int16[rt + 1] = ae, this.int16[rt + 2] = he, this.int16[rt + 3] = ze, V;
+              }, y;
+            }(en);
+            xi.prototype.bytesPerElement = 8, X("StructArrayLayout4i8", xi);
+            var Ri = function(m) {
+              function y() {
+                m.apply(this, arguments);
+              }
+              return m && (y.__proto__ = m), y.prototype = Object.create(m && m.prototype), y.prototype.constructor = y, y.prototype._refreshViews = function() {
+                this.uint8 = new Uint8Array(this.arrayBuffer), this.int16 = new Int16Array(this.arrayBuffer);
+              }, y.prototype.emplaceBack = function(V, $, ae, he, ze, rt) {
+                var gt = this.length;
+                return this.resize(gt + 1), this.emplace(gt, V, $, ae, he, ze, rt);
+              }, y.prototype.emplace = function(V, $, ae, he, ze, rt, gt) {
+                var Et = V * 6;
+                return this.int16[Et + 0] = $, this.int16[Et + 1] = ae, this.int16[Et + 2] = he, this.int16[Et + 3] = ze, this.int16[Et + 4] = rt, this.int16[Et + 5] = gt, V;
+              }, y;
+            }(en);
+            Ri.prototype.bytesPerElement = 12, X("StructArrayLayout2i4i12", Ri);
+            var ci = function(m) {
+              function y() {
+                m.apply(this, arguments);
+              }
+              return m && (y.__proto__ = m), y.prototype = Object.create(m && m.prototype), y.prototype.constructor = y, y.prototype._refreshViews = function() {
+                this.uint8 = new Uint8Array(this.arrayBuffer), this.int16 = new Int16Array(this.arrayBuffer);
+              }, y.prototype.emplaceBack = function(V, $, ae, he, ze, rt) {
+                var gt = this.length;
+                return this.resize(gt + 1), this.emplace(gt, V, $, ae, he, ze, rt);
+              }, y.prototype.emplace = function(V, $, ae, he, ze, rt, gt) {
+                var Et = V * 4, or = V * 8;
+                return this.int16[Et + 0] = $, this.int16[Et + 1] = ae, this.uint8[or + 4] = he, this.uint8[or + 5] = ze, this.uint8[or + 6] = rt, this.uint8[or + 7] = gt, V;
+              }, y;
+            }(en);
+            ci.prototype.bytesPerElement = 8, X("StructArrayLayout2i4ub8", ci);
+            var an = function(m) {
+              function y() {
+                m.apply(this, arguments);
+              }
+              return m && (y.__proto__ = m), y.prototype = Object.create(m && m.prototype), y.prototype.constructor = y, y.prototype._refreshViews = function() {
+                this.uint8 = new Uint8Array(this.arrayBuffer), this.float32 = new Float32Array(this.arrayBuffer);
+              }, y.prototype.emplaceBack = function(V, $) {
+                var ae = this.length;
+                return this.resize(ae + 1), this.emplace(ae, V, $);
+              }, y.prototype.emplace = function(V, $, ae) {
+                var he = V * 2;
+                return this.float32[he + 0] = $, this.float32[he + 1] = ae, V;
+              }, y;
+            }(en);
+            an.prototype.bytesPerElement = 8, X("StructArrayLayout2f8", an);
+            var Zi = function(m) {
+              function y() {
+                m.apply(this, arguments);
+              }
+              return m && (y.__proto__ = m), y.prototype = Object.create(m && m.prototype), y.prototype.constructor = y, y.prototype._refreshViews = function() {
+                this.uint8 = new Uint8Array(this.arrayBuffer), this.uint16 = new Uint16Array(this.arrayBuffer);
+              }, y.prototype.emplaceBack = function(V, $, ae, he, ze, rt, gt, Et, or, _r) {
+                var pr = this.length;
+                return this.resize(pr + 1), this.emplace(pr, V, $, ae, he, ze, rt, gt, Et, or, _r);
+              }, y.prototype.emplace = function(V, $, ae, he, ze, rt, gt, Et, or, _r, pr) {
+                var Fr = V * 10;
+                return this.uint16[Fr + 0] = $, this.uint16[Fr + 1] = ae, this.uint16[Fr + 2] = he, this.uint16[Fr + 3] = ze, this.uint16[Fr + 4] = rt, this.uint16[Fr + 5] = gt, this.uint16[Fr + 6] = Et, this.uint16[Fr + 7] = or, this.uint16[Fr + 8] = _r, this.uint16[Fr + 9] = pr, V;
+              }, y;
+            }(en);
+            Zi.prototype.bytesPerElement = 20, X("StructArrayLayout10ui20", Zi);
+            var Bn = function(m) {
+              function y() {
+                m.apply(this, arguments);
+              }
+              return m && (y.__proto__ = m), y.prototype = Object.create(m && m.prototype), y.prototype.constructor = y, y.prototype._refreshViews = function() {
+                this.uint8 = new Uint8Array(this.arrayBuffer), this.int16 = new Int16Array(this.arrayBuffer), this.uint16 = new Uint16Array(this.arrayBuffer);
+              }, y.prototype.emplaceBack = function(V, $, ae, he, ze, rt, gt, Et, or, _r, pr, Fr) {
+                var oi = this.length;
+                return this.resize(oi + 1), this.emplace(oi, V, $, ae, he, ze, rt, gt, Et, or, _r, pr, Fr);
+              }, y.prototype.emplace = function(V, $, ae, he, ze, rt, gt, Et, or, _r, pr, Fr, oi) {
+                var Hi = V * 12;
+                return this.int16[Hi + 0] = $, this.int16[Hi + 1] = ae, this.int16[Hi + 2] = he, this.int16[Hi + 3] = ze, this.uint16[Hi + 4] = rt, this.uint16[Hi + 5] = gt, this.uint16[Hi + 6] = Et, this.uint16[Hi + 7] = or, this.int16[Hi + 8] = _r, this.int16[Hi + 9] = pr, this.int16[Hi + 10] = Fr, this.int16[Hi + 11] = oi, V;
+              }, y;
+            }(en);
+            Bn.prototype.bytesPerElement = 24, X("StructArrayLayout4i4ui4i24", Bn);
+            var hi = function(m) {
+              function y() {
+                m.apply(this, arguments);
+              }
+              return m && (y.__proto__ = m), y.prototype = Object.create(m && m.prototype), y.prototype.constructor = y, y.prototype._refreshViews = function() {
+                this.uint8 = new Uint8Array(this.arrayBuffer), this.float32 = new Float32Array(this.arrayBuffer);
+              }, y.prototype.emplaceBack = function(V, $, ae) {
+                var he = this.length;
+                return this.resize(he + 1), this.emplace(he, V, $, ae);
+              }, y.prototype.emplace = function(V, $, ae, he) {
+                var ze = V * 3;
+                return this.float32[ze + 0] = $, this.float32[ze + 1] = ae, this.float32[ze + 2] = he, V;
+              }, y;
+            }(en);
+            hi.prototype.bytesPerElement = 12, X("StructArrayLayout3f12", hi);
+            var li = function(m) {
+              function y() {
+                m.apply(this, arguments);
+              }
+              return m && (y.__proto__ = m), y.prototype = Object.create(m && m.prototype), y.prototype.constructor = y, y.prototype._refreshViews = function() {
+                this.uint8 = new Uint8Array(this.arrayBuffer), this.uint32 = new Uint32Array(this.arrayBuffer);
+              }, y.prototype.emplaceBack = function(V) {
+                var $ = this.length;
+                return this.resize($ + 1), this.emplace($, V);
+              }, y.prototype.emplace = function(V, $) {
+                var ae = V * 1;
+                return this.uint32[ae + 0] = $, V;
+              }, y;
+            }(en);
+            li.prototype.bytesPerElement = 4, X("StructArrayLayout1ul4", li);
+            var mn = function(m) {
+              function y() {
+                m.apply(this, arguments);
+              }
+              return m && (y.__proto__ = m), y.prototype = Object.create(m && m.prototype), y.prototype.constructor = y, y.prototype._refreshViews = function() {
+                this.uint8 = new Uint8Array(this.arrayBuffer), this.int16 = new Int16Array(this.arrayBuffer), this.uint32 = new Uint32Array(this.arrayBuffer), this.uint16 = new Uint16Array(this.arrayBuffer);
+              }, y.prototype.emplaceBack = function(V, $, ae, he, ze, rt, gt, Et, or) {
+                var _r = this.length;
+                return this.resize(_r + 1), this.emplace(_r, V, $, ae, he, ze, rt, gt, Et, or);
+              }, y.prototype.emplace = function(V, $, ae, he, ze, rt, gt, Et, or, _r) {
+                var pr = V * 10, Fr = V * 5;
+                return this.int16[pr + 0] = $, this.int16[pr + 1] = ae, this.int16[pr + 2] = he, this.int16[pr + 3] = ze, this.int16[pr + 4] = rt, this.int16[pr + 5] = gt, this.uint32[Fr + 3] = Et, this.uint16[pr + 8] = or, this.uint16[pr + 9] = _r, V;
+              }, y;
+            }(en);
+            mn.prototype.bytesPerElement = 20, X("StructArrayLayout6i1ul2ui20", mn);
+            var Ji = function(m) {
+              function y() {
+                m.apply(this, arguments);
+              }
+              return m && (y.__proto__ = m), y.prototype = Object.create(m && m.prototype), y.prototype.constructor = y, y.prototype._refreshViews = function() {
+                this.uint8 = new Uint8Array(this.arrayBuffer), this.int16 = new Int16Array(this.arrayBuffer);
+              }, y.prototype.emplaceBack = function(V, $, ae, he, ze, rt) {
+                var gt = this.length;
+                return this.resize(gt + 1), this.emplace(gt, V, $, ae, he, ze, rt);
+              }, y.prototype.emplace = function(V, $, ae, he, ze, rt, gt) {
+                var Et = V * 6;
+                return this.int16[Et + 0] = $, this.int16[Et + 1] = ae, this.int16[Et + 2] = he, this.int16[Et + 3] = ze, this.int16[Et + 4] = rt, this.int16[Et + 5] = gt, V;
+              }, y;
+            }(en);
+            Ji.prototype.bytesPerElement = 12, X("StructArrayLayout2i2i2i12", Ji);
+            var Vi = function(m) {
+              function y() {
+                m.apply(this, arguments);
+              }
+              return m && (y.__proto__ = m), y.prototype = Object.create(m && m.prototype), y.prototype.constructor = y, y.prototype._refreshViews = function() {
+                this.uint8 = new Uint8Array(this.arrayBuffer), this.float32 = new Float32Array(this.arrayBuffer), this.int16 = new Int16Array(this.arrayBuffer);
+              }, y.prototype.emplaceBack = function(V, $, ae, he, ze) {
+                var rt = this.length;
+                return this.resize(rt + 1), this.emplace(rt, V, $, ae, he, ze);
+              }, y.prototype.emplace = function(V, $, ae, he, ze, rt) {
+                var gt = V * 4, Et = V * 8;
+                return this.float32[gt + 0] = $, this.float32[gt + 1] = ae, this.float32[gt + 2] = he, this.int16[Et + 6] = ze, this.int16[Et + 7] = rt, V;
+              }, y;
+            }(en);
+            Vi.prototype.bytesPerElement = 16, X("StructArrayLayout2f1f2i16", Vi);
+            var Ni = function(m) {
+              function y() {
+                m.apply(this, arguments);
+              }
+              return m && (y.__proto__ = m), y.prototype = Object.create(m && m.prototype), y.prototype.constructor = y, y.prototype._refreshViews = function() {
+                this.uint8 = new Uint8Array(this.arrayBuffer), this.float32 = new Float32Array(this.arrayBuffer);
+              }, y.prototype.emplaceBack = function(V, $, ae, he) {
+                var ze = this.length;
+                return this.resize(ze + 1), this.emplace(ze, V, $, ae, he);
+              }, y.prototype.emplace = function(V, $, ae, he, ze) {
+                var rt = V * 12, gt = V * 3;
+                return this.uint8[rt + 0] = $, this.uint8[rt + 1] = ae, this.float32[gt + 1] = he, this.float32[gt + 2] = ze, V;
+              }, y;
+            }(en);
+            Ni.prototype.bytesPerElement = 12, X("StructArrayLayout2ub2f12", Ni);
+            var pn = function(m) {
+              function y() {
+                m.apply(this, arguments);
+              }
+              return m && (y.__proto__ = m), y.prototype = Object.create(m && m.prototype), y.prototype.constructor = y, y.prototype._refreshViews = function() {
+                this.uint8 = new Uint8Array(this.arrayBuffer), this.uint16 = new Uint16Array(this.arrayBuffer);
+              }, y.prototype.emplaceBack = function(V, $, ae) {
+                var he = this.length;
+                return this.resize(he + 1), this.emplace(he, V, $, ae);
+              }, y.prototype.emplace = function(V, $, ae, he) {
+                var ze = V * 3;
+                return this.uint16[ze + 0] = $, this.uint16[ze + 1] = ae, this.uint16[ze + 2] = he, V;
+              }, y;
+            }(en);
+            pn.prototype.bytesPerElement = 6, X("StructArrayLayout3ui6", pn);
+            var Vn = function(m) {
+              function y() {
+                m.apply(this, arguments);
+              }
+              return m && (y.__proto__ = m), y.prototype = Object.create(m && m.prototype), y.prototype.constructor = y, y.prototype._refreshViews = function() {
+                this.uint8 = new Uint8Array(this.arrayBuffer), this.int16 = new Int16Array(this.arrayBuffer), this.uint16 = new Uint16Array(this.arrayBuffer), this.uint32 = new Uint32Array(this.arrayBuffer), this.float32 = new Float32Array(this.arrayBuffer);
+              }, y.prototype.emplaceBack = function(V, $, ae, he, ze, rt, gt, Et, or, _r, pr, Fr, oi, Hi, Ai, bn, nn) {
+                var xn = this.length;
+                return this.resize(xn + 1), this.emplace(xn, V, $, ae, he, ze, rt, gt, Et, or, _r, pr, Fr, oi, Hi, Ai, bn, nn);
+              }, y.prototype.emplace = function(V, $, ae, he, ze, rt, gt, Et, or, _r, pr, Fr, oi, Hi, Ai, bn, nn, xn) {
+                var Pn = V * 24, Zn = V * 12, ga = V * 48;
+                return this.int16[Pn + 0] = $, this.int16[Pn + 1] = ae, this.uint16[Pn + 2] = he, this.uint16[Pn + 3] = ze, this.uint32[Zn + 2] = rt, this.uint32[Zn + 3] = gt, this.uint32[Zn + 4] = Et, this.uint16[Pn + 10] = or, this.uint16[Pn + 11] = _r, this.uint16[Pn + 12] = pr, this.float32[Zn + 7] = Fr, this.float32[Zn + 8] = oi, this.uint8[ga + 36] = Hi, this.uint8[ga + 37] = Ai, this.uint8[ga + 38] = bn, this.uint32[Zn + 10] = nn, this.int16[Pn + 22] = xn, V;
+              }, y;
+            }(en);
+            Vn.prototype.bytesPerElement = 48, X("StructArrayLayout2i2ui3ul3ui2f3ub1ul1i48", Vn);
+            var na = function(m) {
+              function y() {
+                m.apply(this, arguments);
+              }
+              return m && (y.__proto__ = m), y.prototype = Object.create(m && m.prototype), y.prototype.constructor = y, y.prototype._refreshViews = function() {
+                this.uint8 = new Uint8Array(this.arrayBuffer), this.int16 = new Int16Array(this.arrayBuffer), this.uint16 = new Uint16Array(this.arrayBuffer), this.uint32 = new Uint32Array(this.arrayBuffer), this.float32 = new Float32Array(this.arrayBuffer);
+              }, y.prototype.emplaceBack = function(V, $, ae, he, ze, rt, gt, Et, or, _r, pr, Fr, oi, Hi, Ai, bn, nn, xn, Pn, Zn, ga, ha, eo, za, Za, Jo, to, ao) {
+                var _s = this.length;
+                return this.resize(_s + 1), this.emplace(_s, V, $, ae, he, ze, rt, gt, Et, or, _r, pr, Fr, oi, Hi, Ai, bn, nn, xn, Pn, Zn, ga, ha, eo, za, Za, Jo, to, ao);
+              }, y.prototype.emplace = function(V, $, ae, he, ze, rt, gt, Et, or, _r, pr, Fr, oi, Hi, Ai, bn, nn, xn, Pn, Zn, ga, ha, eo, za, Za, Jo, to, ao, _s) {
+                var jo = V * 34, El = V * 17;
+                return this.int16[jo + 0] = $, this.int16[jo + 1] = ae, this.int16[jo + 2] = he, this.int16[jo + 3] = ze, this.int16[jo + 4] = rt, this.int16[jo + 5] = gt, this.int16[jo + 6] = Et, this.int16[jo + 7] = or, this.uint16[jo + 8] = _r, this.uint16[jo + 9] = pr, this.uint16[jo + 10] = Fr, this.uint16[jo + 11] = oi, this.uint16[jo + 12] = Hi, this.uint16[jo + 13] = Ai, this.uint16[jo + 14] = bn, this.uint16[jo + 15] = nn, this.uint16[jo + 16] = xn, this.uint16[jo + 17] = Pn, this.uint16[jo + 18] = Zn, this.uint16[jo + 19] = ga, this.uint16[jo + 20] = ha, this.uint16[jo + 21] = eo, this.uint16[jo + 22] = za, this.uint32[El + 12] = Za, this.float32[El + 13] = Jo, this.float32[El + 14] = to, this.float32[El + 15] = ao, this.float32[El + 16] = _s, V;
+              }, y;
+            }(en);
+            na.prototype.bytesPerElement = 68, X("StructArrayLayout8i15ui1ul4f68", na);
+            var Ki = function(m) {
+              function y() {
+                m.apply(this, arguments);
+              }
+              return m && (y.__proto__ = m), y.prototype = Object.create(m && m.prototype), y.prototype.constructor = y, y.prototype._refreshViews = function() {
+                this.uint8 = new Uint8Array(this.arrayBuffer), this.float32 = new Float32Array(this.arrayBuffer);
+              }, y.prototype.emplaceBack = function(V) {
+                var $ = this.length;
+                return this.resize($ + 1), this.emplace($, V);
+              }, y.prototype.emplace = function(V, $) {
+                var ae = V * 1;
+                return this.float32[ae + 0] = $, V;
+              }, y;
+            }(en);
+            Ki.prototype.bytesPerElement = 4, X("StructArrayLayout1f4", Ki);
+            var kn = function(m) {
+              function y() {
+                m.apply(this, arguments);
+              }
+              return m && (y.__proto__ = m), y.prototype = Object.create(m && m.prototype), y.prototype.constructor = y, y.prototype._refreshViews = function() {
+                this.uint8 = new Uint8Array(this.arrayBuffer), this.int16 = new Int16Array(this.arrayBuffer);
+              }, y.prototype.emplaceBack = function(V, $, ae) {
+                var he = this.length;
+                return this.resize(he + 1), this.emplace(he, V, $, ae);
+              }, y.prototype.emplace = function(V, $, ae, he) {
+                var ze = V * 3;
+                return this.int16[ze + 0] = $, this.int16[ze + 1] = ae, this.int16[ze + 2] = he, V;
+              }, y;
+            }(en);
+            kn.prototype.bytesPerElement = 6, X("StructArrayLayout3i6", kn);
+            var ta = function(m) {
+              function y() {
+                m.apply(this, arguments);
+              }
+              return m && (y.__proto__ = m), y.prototype = Object.create(m && m.prototype), y.prototype.constructor = y, y.prototype._refreshViews = function() {
+                this.uint8 = new Uint8Array(this.arrayBuffer), this.uint32 = new Uint32Array(this.arrayBuffer), this.uint16 = new Uint16Array(this.arrayBuffer);
+              }, y.prototype.emplaceBack = function(V, $, ae) {
+                var he = this.length;
+                return this.resize(he + 1), this.emplace(he, V, $, ae);
+              }, y.prototype.emplace = function(V, $, ae, he) {
+                var ze = V * 2, rt = V * 4;
+                return this.uint32[ze + 0] = $, this.uint16[rt + 2] = ae, this.uint16[rt + 3] = he, V;
+              }, y;
+            }(en);
+            ta.prototype.bytesPerElement = 8, X("StructArrayLayout1ul2ui8", ta);
+            var oa = function(m) {
+              function y() {
+                m.apply(this, arguments);
+              }
+              return m && (y.__proto__ = m), y.prototype = Object.create(m && m.prototype), y.prototype.constructor = y, y.prototype._refreshViews = function() {
+                this.uint8 = new Uint8Array(this.arrayBuffer), this.uint16 = new Uint16Array(this.arrayBuffer);
+              }, y.prototype.emplaceBack = function(V, $) {
+                var ae = this.length;
+                return this.resize(ae + 1), this.emplace(ae, V, $);
+              }, y.prototype.emplace = function(V, $, ae) {
+                var he = V * 2;
+                return this.uint16[he + 0] = $, this.uint16[he + 1] = ae, V;
+              }, y;
+            }(en);
+            oa.prototype.bytesPerElement = 4, X("StructArrayLayout2ui4", oa);
+            var ba = function(m) {
+              function y() {
+                m.apply(this, arguments);
+              }
+              return m && (y.__proto__ = m), y.prototype = Object.create(m && m.prototype), y.prototype.constructor = y, y.prototype._refreshViews = function() {
+                this.uint8 = new Uint8Array(this.arrayBuffer), this.uint16 = new Uint16Array(this.arrayBuffer);
+              }, y.prototype.emplaceBack = function(V) {
+                var $ = this.length;
+                return this.resize($ + 1), this.emplace($, V);
+              }, y.prototype.emplace = function(V, $) {
+                var ae = V * 1;
+                return this.uint16[ae + 0] = $, V;
+              }, y;
+            }(en);
+            ba.prototype.bytesPerElement = 2, X("StructArrayLayout1ui2", ba);
+            var is = function(m) {
+              function y() {
+                m.apply(this, arguments);
+              }
+              return m && (y.__proto__ = m), y.prototype = Object.create(m && m.prototype), y.prototype.constructor = y, y.prototype._refreshViews = function() {
+                this.uint8 = new Uint8Array(this.arrayBuffer), this.float32 = new Float32Array(this.arrayBuffer);
+              }, y.prototype.emplaceBack = function(V, $, ae, he) {
+                var ze = this.length;
+                return this.resize(ze + 1), this.emplace(ze, V, $, ae, he);
+              }, y.prototype.emplace = function(V, $, ae, he, ze) {
+                var rt = V * 4;
+                return this.float32[rt + 0] = $, this.float32[rt + 1] = ae, this.float32[rt + 2] = he, this.float32[rt + 3] = ze, V;
+              }, y;
+            }(en);
+            is.prototype.bytesPerElement = 16, X("StructArrayLayout4f16", is);
+            var Zs = function(m) {
+              function y() {
+                m.apply(this, arguments);
+              }
+              m && (y.__proto__ = m), y.prototype = Object.create(m && m.prototype), y.prototype.constructor = y;
+              var I = { anchorPointX: { configurable: true }, anchorPointY: { configurable: true }, x1: { configurable: true }, y1: { configurable: true }, x2: { configurable: true }, y2: { configurable: true }, featureIndex: { configurable: true }, sourceLayerIndex: { configurable: true }, bucketIndex: { configurable: true }, anchorPoint: { configurable: true } };
+              return I.anchorPointX.get = function() {
+                return this._structArray.int16[this._pos2 + 0];
+              }, I.anchorPointY.get = function() {
+                return this._structArray.int16[this._pos2 + 1];
+              }, I.x1.get = function() {
+                return this._structArray.int16[this._pos2 + 2];
+              }, I.y1.get = function() {
+                return this._structArray.int16[this._pos2 + 3];
+              }, I.x2.get = function() {
+                return this._structArray.int16[this._pos2 + 4];
+              }, I.y2.get = function() {
+                return this._structArray.int16[this._pos2 + 5];
+              }, I.featureIndex.get = function() {
+                return this._structArray.uint32[this._pos4 + 3];
+              }, I.sourceLayerIndex.get = function() {
+                return this._structArray.uint16[this._pos2 + 8];
+              }, I.bucketIndex.get = function() {
+                return this._structArray.uint16[this._pos2 + 9];
+              }, I.anchorPoint.get = function() {
+                return new u(this.anchorPointX, this.anchorPointY);
+              }, Object.defineProperties(y.prototype, I), y;
+            }(qi);
+            Zs.prototype.size = 20;
+            var Va = function(m) {
+              function y() {
+                m.apply(this, arguments);
+              }
+              return m && (y.__proto__ = m), y.prototype = Object.create(m && m.prototype), y.prototype.constructor = y, y.prototype.get = function(V) {
+                return new Zs(this, V);
+              }, y;
+            }(mn);
+            X("CollisionBoxArray", Va);
+            var Ml = function(m) {
+              function y() {
+                m.apply(this, arguments);
+              }
+              m && (y.__proto__ = m), y.prototype = Object.create(m && m.prototype), y.prototype.constructor = y;
+              var I = { anchorX: { configurable: true }, anchorY: { configurable: true }, glyphStartIndex: { configurable: true }, numGlyphs: { configurable: true }, vertexStartIndex: { configurable: true }, lineStartIndex: { configurable: true }, lineLength: { configurable: true }, segment: { configurable: true }, lowerSize: { configurable: true }, upperSize: { configurable: true }, lineOffsetX: { configurable: true }, lineOffsetY: { configurable: true }, writingMode: { configurable: true }, placedOrientation: { configurable: true }, hidden: { configurable: true }, crossTileID: { configurable: true }, associatedIconIndex: { configurable: true } };
+              return I.anchorX.get = function() {
+                return this._structArray.int16[this._pos2 + 0];
+              }, I.anchorY.get = function() {
+                return this._structArray.int16[this._pos2 + 1];
+              }, I.glyphStartIndex.get = function() {
+                return this._structArray.uint16[this._pos2 + 2];
+              }, I.numGlyphs.get = function() {
+                return this._structArray.uint16[this._pos2 + 3];
+              }, I.vertexStartIndex.get = function() {
+                return this._structArray.uint32[this._pos4 + 2];
+              }, I.lineStartIndex.get = function() {
+                return this._structArray.uint32[this._pos4 + 3];
+              }, I.lineLength.get = function() {
+                return this._structArray.uint32[this._pos4 + 4];
+              }, I.segment.get = function() {
+                return this._structArray.uint16[this._pos2 + 10];
+              }, I.lowerSize.get = function() {
+                return this._structArray.uint16[this._pos2 + 11];
+              }, I.upperSize.get = function() {
+                return this._structArray.uint16[this._pos2 + 12];
+              }, I.lineOffsetX.get = function() {
+                return this._structArray.float32[this._pos4 + 7];
+              }, I.lineOffsetY.get = function() {
+                return this._structArray.float32[this._pos4 + 8];
+              }, I.writingMode.get = function() {
+                return this._structArray.uint8[this._pos1 + 36];
+              }, I.placedOrientation.get = function() {
+                return this._structArray.uint8[this._pos1 + 37];
+              }, I.placedOrientation.set = function(V) {
+                this._structArray.uint8[this._pos1 + 37] = V;
+              }, I.hidden.get = function() {
+                return this._structArray.uint8[this._pos1 + 38];
+              }, I.hidden.set = function(V) {
+                this._structArray.uint8[this._pos1 + 38] = V;
+              }, I.crossTileID.get = function() {
+                return this._structArray.uint32[this._pos4 + 10];
+              }, I.crossTileID.set = function(V) {
+                this._structArray.uint32[this._pos4 + 10] = V;
+              }, I.associatedIconIndex.get = function() {
+                return this._structArray.int16[this._pos2 + 22];
+              }, Object.defineProperties(y.prototype, I), y;
+            }(qi);
+            Ml.prototype.size = 48;
+            var zo = function(m) {
+              function y() {
+                m.apply(this, arguments);
+              }
+              return m && (y.__proto__ = m), y.prototype = Object.create(m && m.prototype), y.prototype.constructor = y, y.prototype.get = function(V) {
+                return new Ml(this, V);
+              }, y;
+            }(Vn);
+            X("PlacedSymbolArray", zo);
+            var Qs = function(m) {
+              function y() {
+                m.apply(this, arguments);
+              }
+              m && (y.__proto__ = m), y.prototype = Object.create(m && m.prototype), y.prototype.constructor = y;
+              var I = { anchorX: { configurable: true }, anchorY: { configurable: true }, rightJustifiedTextSymbolIndex: { configurable: true }, centerJustifiedTextSymbolIndex: { configurable: true }, leftJustifiedTextSymbolIndex: { configurable: true }, verticalPlacedTextSymbolIndex: { configurable: true }, placedIconSymbolIndex: { configurable: true }, verticalPlacedIconSymbolIndex: { configurable: true }, key: { configurable: true }, textBoxStartIndex: { configurable: true }, textBoxEndIndex: { configurable: true }, verticalTextBoxStartIndex: { configurable: true }, verticalTextBoxEndIndex: { configurable: true }, iconBoxStartIndex: { configurable: true }, iconBoxEndIndex: { configurable: true }, verticalIconBoxStartIndex: { configurable: true }, verticalIconBoxEndIndex: { configurable: true }, featureIndex: { configurable: true }, numHorizontalGlyphVertices: { configurable: true }, numVerticalGlyphVertices: { configurable: true }, numIconVertices: { configurable: true }, numVerticalIconVertices: { configurable: true }, useRuntimeCollisionCircles: { configurable: true }, crossTileID: { configurable: true }, textBoxScale: { configurable: true }, textOffset0: { configurable: true }, textOffset1: { configurable: true }, collisionCircleDiameter: { configurable: true } };
+              return I.anchorX.get = function() {
+                return this._structArray.int16[this._pos2 + 0];
+              }, I.anchorY.get = function() {
+                return this._structArray.int16[this._pos2 + 1];
+              }, I.rightJustifiedTextSymbolIndex.get = function() {
+                return this._structArray.int16[this._pos2 + 2];
+              }, I.centerJustifiedTextSymbolIndex.get = function() {
+                return this._structArray.int16[this._pos2 + 3];
+              }, I.leftJustifiedTextSymbolIndex.get = function() {
+                return this._structArray.int16[this._pos2 + 4];
+              }, I.verticalPlacedTextSymbolIndex.get = function() {
+                return this._structArray.int16[this._pos2 + 5];
+              }, I.placedIconSymbolIndex.get = function() {
+                return this._structArray.int16[this._pos2 + 6];
+              }, I.verticalPlacedIconSymbolIndex.get = function() {
+                return this._structArray.int16[this._pos2 + 7];
+              }, I.key.get = function() {
+                return this._structArray.uint16[this._pos2 + 8];
+              }, I.textBoxStartIndex.get = function() {
+                return this._structArray.uint16[this._pos2 + 9];
+              }, I.textBoxEndIndex.get = function() {
+                return this._structArray.uint16[this._pos2 + 10];
+              }, I.verticalTextBoxStartIndex.get = function() {
+                return this._structArray.uint16[this._pos2 + 11];
+              }, I.verticalTextBoxEndIndex.get = function() {
+                return this._structArray.uint16[this._pos2 + 12];
+              }, I.iconBoxStartIndex.get = function() {
+                return this._structArray.uint16[this._pos2 + 13];
+              }, I.iconBoxEndIndex.get = function() {
+                return this._structArray.uint16[this._pos2 + 14];
+              }, I.verticalIconBoxStartIndex.get = function() {
+                return this._structArray.uint16[this._pos2 + 15];
+              }, I.verticalIconBoxEndIndex.get = function() {
+                return this._structArray.uint16[this._pos2 + 16];
+              }, I.featureIndex.get = function() {
+                return this._structArray.uint16[this._pos2 + 17];
+              }, I.numHorizontalGlyphVertices.get = function() {
+                return this._structArray.uint16[this._pos2 + 18];
+              }, I.numVerticalGlyphVertices.get = function() {
+                return this._structArray.uint16[this._pos2 + 19];
+              }, I.numIconVertices.get = function() {
+                return this._structArray.uint16[this._pos2 + 20];
+              }, I.numVerticalIconVertices.get = function() {
+                return this._structArray.uint16[this._pos2 + 21];
+              }, I.useRuntimeCollisionCircles.get = function() {
+                return this._structArray.uint16[this._pos2 + 22];
+              }, I.crossTileID.get = function() {
+                return this._structArray.uint32[this._pos4 + 12];
+              }, I.crossTileID.set = function(V) {
+                this._structArray.uint32[this._pos4 + 12] = V;
+              }, I.textBoxScale.get = function() {
+                return this._structArray.float32[this._pos4 + 13];
+              }, I.textOffset0.get = function() {
+                return this._structArray.float32[this._pos4 + 14];
+              }, I.textOffset1.get = function() {
+                return this._structArray.float32[this._pos4 + 15];
+              }, I.collisionCircleDiameter.get = function() {
+                return this._structArray.float32[this._pos4 + 16];
+              }, Object.defineProperties(y.prototype, I), y;
+            }(qi);
+            Qs.prototype.size = 68;
+            var al = function(m) {
+              function y() {
+                m.apply(this, arguments);
+              }
+              return m && (y.__proto__ = m), y.prototype = Object.create(m && m.prototype), y.prototype.constructor = y, y.prototype.get = function(V) {
+                return new Qs(this, V);
+              }, y;
+            }(na);
+            X("SymbolInstanceArray", al);
+            var Vl = function(m) {
+              function y() {
+                m.apply(this, arguments);
+              }
+              return m && (y.__proto__ = m), y.prototype = Object.create(m && m.prototype), y.prototype.constructor = y, y.prototype.getoffsetX = function(V) {
+                return this.float32[V * 1 + 0];
+              }, y;
+            }(Ki);
+            X("GlyphOffsetArray", Vl);
+            var ss = function(m) {
+              function y() {
+                m.apply(this, arguments);
+              }
+              return m && (y.__proto__ = m), y.prototype = Object.create(m && m.prototype), y.prototype.constructor = y, y.prototype.getx = function(V) {
+                return this.int16[V * 3 + 0];
+              }, y.prototype.gety = function(V) {
+                return this.int16[V * 3 + 1];
+              }, y.prototype.gettileUnitDistanceFromAnchor = function(V) {
+                return this.int16[V * 3 + 2];
+              }, y;
+            }(kn);
+            X("SymbolLineVertexArray", ss);
+            var Vs = function(m) {
+              function y() {
+                m.apply(this, arguments);
+              }
+              m && (y.__proto__ = m), y.prototype = Object.create(m && m.prototype), y.prototype.constructor = y;
+              var I = { featureIndex: { configurable: true }, sourceLayerIndex: { configurable: true }, bucketIndex: { configurable: true } };
+              return I.featureIndex.get = function() {
+                return this._structArray.uint32[this._pos4 + 0];
+              }, I.sourceLayerIndex.get = function() {
+                return this._structArray.uint16[this._pos2 + 2];
+              }, I.bucketIndex.get = function() {
+                return this._structArray.uint16[this._pos2 + 3];
+              }, Object.defineProperties(y.prototype, I), y;
+            }(qi);
+            Vs.prototype.size = 8;
+            var Ys = function(m) {
+              function y() {
+                m.apply(this, arguments);
+              }
+              return m && (y.__proto__ = m), y.prototype = Object.create(m && m.prototype), y.prototype.constructor = y, y.prototype.get = function(V) {
+                return new Vs(this, V);
+              }, y;
+            }(ta);
+            X("FeatureIndexArray", Ys);
+            var wa = Wi([{ name: "a_pos", components: 2, type: "Int16" }], 4), ol = wa.members, io = function(y) {
+              y === void 0 && (y = []), this.segments = y;
+            };
+            io.prototype.prepareSegment = function(y, I, V, $) {
+              var ae = this.segments[this.segments.length - 1];
+              return y > io.MAX_VERTEX_ARRAY_LENGTH && re("Max vertices per segment is " + io.MAX_VERTEX_ARRAY_LENGTH + ": bucket requested " + y), (!ae || ae.vertexLength + y > io.MAX_VERTEX_ARRAY_LENGTH || ae.sortKey !== $) && (ae = { vertexOffset: I.length, primitiveOffset: V.length, vertexLength: 0, primitiveLength: 0 }, $ !== void 0 && (ae.sortKey = $), this.segments.push(ae)), ae;
+            }, io.prototype.get = function() {
+              return this.segments;
+            }, io.prototype.destroy = function() {
+              for (var y = 0, I = this.segments; y < I.length; y += 1) {
+                var V = I[y];
+                for (var $ in V.vaos) V.vaos[$].destroy();
+              }
+            }, io.simpleSegment = function(y, I, V, $) {
+              return new io([{ vertexOffset: y, primitiveOffset: I, vertexLength: V, primitiveLength: $, vaos: {}, sortKey: 0 }]);
+            }, io.MAX_VERTEX_ARRAY_LENGTH = Math.pow(2, 16) - 1, X("SegmentVector", io);
+            function Y(m, y) {
+              return m = p(Math.floor(m), 0, 255), y = p(Math.floor(y), 0, 255), 256 * m + y;
+            }
+            var D = Wi([{ name: "a_pattern_from", components: 4, type: "Uint16" }, { name: "a_pattern_to", components: 4, type: "Uint16" }, { name: "a_pixel_ratio_from", components: 1, type: "Uint16" }, { name: "a_pixel_ratio_to", components: 1, type: "Uint16" }]), J = a(function(m) {
+              function y(I, V) {
+                var $, ae, he, ze, rt, gt, Et, or;
+                for ($ = I.length & 3, ae = I.length - $, he = V, rt = 3432918353, gt = 461845907, or = 0; or < ae; ) Et = I.charCodeAt(or) & 255 | (I.charCodeAt(++or) & 255) << 8 | (I.charCodeAt(++or) & 255) << 16 | (I.charCodeAt(++or) & 255) << 24, ++or, Et = (Et & 65535) * rt + (((Et >>> 16) * rt & 65535) << 16) & 4294967295, Et = Et << 15 | Et >>> 17, Et = (Et & 65535) * gt + (((Et >>> 16) * gt & 65535) << 16) & 4294967295, he ^= Et, he = he << 13 | he >>> 19, ze = (he & 65535) * 5 + (((he >>> 16) * 5 & 65535) << 16) & 4294967295, he = (ze & 65535) + 27492 + (((ze >>> 16) + 58964 & 65535) << 16);
+                switch (Et = 0, $) {
+                  case 3:
+                    Et ^= (I.charCodeAt(or + 2) & 255) << 16;
+                  case 2:
+                    Et ^= (I.charCodeAt(or + 1) & 255) << 8;
+                  case 1:
+                    Et ^= I.charCodeAt(or) & 255, Et = (Et & 65535) * rt + (((Et >>> 16) * rt & 65535) << 16) & 4294967295, Et = Et << 15 | Et >>> 17, Et = (Et & 65535) * gt + (((Et >>> 16) * gt & 65535) << 16) & 4294967295, he ^= Et;
+                }
+                return he ^= I.length, he ^= he >>> 16, he = (he & 65535) * 2246822507 + (((he >>> 16) * 2246822507 & 65535) << 16) & 4294967295, he ^= he >>> 13, he = (he & 65535) * 3266489909 + (((he >>> 16) * 3266489909 & 65535) << 16) & 4294967295, he ^= he >>> 16, he >>> 0;
+              }
+              m.exports = y;
+            }), q = a(function(m) {
+              function y(I, V) {
+                for (var $ = I.length, ae = V ^ $, he = 0, ze; $ >= 4; ) ze = I.charCodeAt(he) & 255 | (I.charCodeAt(++he) & 255) << 8 | (I.charCodeAt(++he) & 255) << 16 | (I.charCodeAt(++he) & 255) << 24, ze = (ze & 65535) * 1540483477 + (((ze >>> 16) * 1540483477 & 65535) << 16), ze ^= ze >>> 24, ze = (ze & 65535) * 1540483477 + (((ze >>> 16) * 1540483477 & 65535) << 16), ae = (ae & 65535) * 1540483477 + (((ae >>> 16) * 1540483477 & 65535) << 16) ^ ze, $ -= 4, ++he;
+                switch ($) {
+                  case 3:
+                    ae ^= (I.charCodeAt(he + 2) & 255) << 16;
+                  case 2:
+                    ae ^= (I.charCodeAt(he + 1) & 255) << 8;
+                  case 1:
+                    ae ^= I.charCodeAt(he) & 255, ae = (ae & 65535) * 1540483477 + (((ae >>> 16) * 1540483477 & 65535) << 16);
+                }
+                return ae ^= ae >>> 13, ae = (ae & 65535) * 1540483477 + (((ae >>> 16) * 1540483477 & 65535) << 16), ae ^= ae >>> 15, ae >>> 0;
+              }
+              m.exports = y;
+            }), K = J, de = J, ne = q;
+            K.murmur3 = de, K.murmur2 = ne;
+            var we = function() {
+              this.ids = [], this.positions = [], this.indexed = false;
+            };
+            we.prototype.add = function(y, I, V, $) {
+              this.ids.push(ft(y)), this.positions.push(I, V, $);
+            }, we.prototype.getPositions = function(y) {
+              for (var I = ft(y), V = 0, $ = this.ids.length - 1; V < $; ) {
+                var ae = V + $ >> 1;
+                this.ids[ae] >= I ? $ = ae : V = ae + 1;
+              }
+              for (var he = []; this.ids[V] === I; ) {
+                var ze = this.positions[3 * V], rt = this.positions[3 * V + 1], gt = this.positions[3 * V + 2];
+                he.push({ index: ze, start: rt, end: gt }), V++;
+              }
+              return he;
+            }, we.serialize = function(y, I) {
+              var V = new Float64Array(y.ids), $ = new Uint32Array(y.positions);
+              return Zt(V, $, 0, V.length - 1), I && I.push(V.buffer, $.buffer), { ids: V, positions: $ };
+            }, we.deserialize = function(y) {
+              var I = new we();
+              return I.ids = y.ids, I.positions = y.positions, I.indexed = true, I;
+            };
+            var Ue = Math.pow(2, 53) - 1;
+            function ft(m) {
+              var y = +m;
+              return !isNaN(y) && y <= Ue ? y : K(String(m));
+            }
+            function Zt(m, y, I, V) {
+              for (; I < V; ) {
+                for (var $ = m[I + V >> 1], ae = I - 1, he = V + 1; ; ) {
+                  do
+                    ae++;
+                  while (m[ae] < $);
+                  do
+                    he--;
+                  while (m[he] > $);
+                  if (ae >= he) break;
+                  hr(m, ae, he), hr(y, 3 * ae, 3 * he), hr(y, 3 * ae + 1, 3 * he + 1), hr(y, 3 * ae + 2, 3 * he + 2);
+                }
+                he - I < V - he ? (Zt(m, y, I, he), I = he + 1) : (Zt(m, y, he + 1, V), V = he);
+              }
+            }
+            function hr(m, y, I) {
+              var V = m[y];
+              m[y] = m[I], m[I] = V;
+            }
+            X("FeaturePositionMap", we);
+            var qt = function(y, I) {
+              this.gl = y.gl, this.location = I;
+            }, Ve = function(m) {
+              function y(I, V) {
+                m.call(this, I, V), this.current = 0;
+              }
+              return m && (y.__proto__ = m), y.prototype = Object.create(m && m.prototype), y.prototype.constructor = y, y.prototype.set = function(V) {
+                this.current !== V && (this.current = V, this.gl.uniform1i(this.location, V));
+              }, y;
+            }(qt), Qe = function(m) {
+              function y(I, V) {
+                m.call(this, I, V), this.current = 0;
+              }
+              return m && (y.__proto__ = m), y.prototype = Object.create(m && m.prototype), y.prototype.constructor = y, y.prototype.set = function(V) {
+                this.current !== V && (this.current = V, this.gl.uniform1f(this.location, V));
+              }, y;
+            }(qt), at = function(m) {
+              function y(I, V) {
+                m.call(this, I, V), this.current = [0, 0];
+              }
+              return m && (y.__proto__ = m), y.prototype = Object.create(m && m.prototype), y.prototype.constructor = y, y.prototype.set = function(V) {
+                (V[0] !== this.current[0] || V[1] !== this.current[1]) && (this.current = V, this.gl.uniform2f(this.location, V[0], V[1]));
+              }, y;
+            }(qt), Ct = function(m) {
+              function y(I, V) {
+                m.call(this, I, V), this.current = [0, 0, 0];
+              }
+              return m && (y.__proto__ = m), y.prototype = Object.create(m && m.prototype), y.prototype.constructor = y, y.prototype.set = function(V) {
+                (V[0] !== this.current[0] || V[1] !== this.current[1] || V[2] !== this.current[2]) && (this.current = V, this.gl.uniform3f(this.location, V[0], V[1], V[2]));
+              }, y;
+            }(qt), Ot = function(m) {
+              function y(I, V) {
+                m.call(this, I, V), this.current = [0, 0, 0, 0];
+              }
+              return m && (y.__proto__ = m), y.prototype = Object.create(m && m.prototype), y.prototype.constructor = y, y.prototype.set = function(V) {
+                (V[0] !== this.current[0] || V[1] !== this.current[1] || V[2] !== this.current[2] || V[3] !== this.current[3]) && (this.current = V, this.gl.uniform4f(this.location, V[0], V[1], V[2], V[3]));
+              }, y;
+            }(qt), Rt = function(m) {
+              function y(I, V) {
+                m.call(this, I, V), this.current = cs.transparent;
+              }
+              return m && (y.__proto__ = m), y.prototype = Object.create(m && m.prototype), y.prototype.constructor = y, y.prototype.set = function(V) {
+                (V.r !== this.current.r || V.g !== this.current.g || V.b !== this.current.b || V.a !== this.current.a) && (this.current = V, this.gl.uniform4f(this.location, V.r, V.g, V.b, V.a));
+              }, y;
+            }(qt), Bt = new Float32Array(16), Dt = function(m) {
+              function y(I, V) {
+                m.call(this, I, V), this.current = Bt;
+              }
+              return m && (y.__proto__ = m), y.prototype = Object.create(m && m.prototype), y.prototype.constructor = y, y.prototype.set = function(V) {
+                if (V[12] !== this.current[12] || V[0] !== this.current[0]) {
+                  this.current = V, this.gl.uniformMatrix4fv(this.location, false, V);
+                  return;
+                }
+                for (var $ = 1; $ < 16; $++) if (V[$] !== this.current[$]) {
+                  this.current = V, this.gl.uniformMatrix4fv(this.location, false, V);
+                  break;
+                }
+              }, y;
+            }(qt);
+            function yt(m) {
+              return [Y(255 * m.r, 255 * m.g), Y(255 * m.b, 255 * m.a)];
+            }
+            var Pt = function(y, I, V) {
+              this.value = y, this.uniformNames = I.map(function($) {
+                return "u_" + $;
+              }), this.type = V;
+            };
+            Pt.prototype.setUniform = function(y, I, V) {
+              y.set(V.constantOr(this.value));
+            }, Pt.prototype.getBinding = function(y, I, V) {
+              return this.type === "color" ? new Rt(y, I) : new Qe(y, I);
+            };
+            var ht = function(y, I) {
+              this.uniformNames = I.map(function(V) {
+                return "u_" + V;
+              }), this.patternFrom = null, this.patternTo = null, this.pixelRatioFrom = 1, this.pixelRatioTo = 1;
+            };
+            ht.prototype.setConstantPatternPositions = function(y, I) {
+              this.pixelRatioFrom = I.pixelRatio, this.pixelRatioTo = y.pixelRatio, this.patternFrom = I.tlbr, this.patternTo = y.tlbr;
+            }, ht.prototype.setUniform = function(y, I, V, $) {
+              var ae = $ === "u_pattern_to" ? this.patternTo : $ === "u_pattern_from" ? this.patternFrom : $ === "u_pixel_ratio_to" ? this.pixelRatioTo : $ === "u_pixel_ratio_from" ? this.pixelRatioFrom : null;
+              ae && y.set(ae);
+            }, ht.prototype.getBinding = function(y, I, V) {
+              return V.substr(0, 9) === "u_pattern" ? new Ot(y, I) : new Qe(y, I);
+            };
+            var ur = function(y, I, V, $) {
+              this.expression = y, this.type = V, this.maxValue = 0, this.paintVertexAttributes = I.map(function(ae) {
+                return { name: "a_" + ae, type: "Float32", components: V === "color" ? 2 : 1, offset: 0 };
+              }), this.paintVertexArray = new $();
+            };
+            ur.prototype.populatePaintArray = function(y, I, V, $, ae) {
+              var he = this.paintVertexArray.length, ze = this.expression.evaluate(new Gn(0), I, {}, $, [], ae);
+              this.paintVertexArray.resize(y), this._setPaintValue(he, y, ze);
+            }, ur.prototype.updatePaintArray = function(y, I, V, $) {
+              var ae = this.expression.evaluate({ zoom: 0 }, V, $);
+              this._setPaintValue(y, I, ae);
+            }, ur.prototype._setPaintValue = function(y, I, V) {
+              if (this.type === "color") for (var $ = yt(V), ae = y; ae < I; ae++) this.paintVertexArray.emplace(ae, $[0], $[1]);
+              else {
+                for (var he = y; he < I; he++) this.paintVertexArray.emplace(he, V);
+                this.maxValue = Math.max(this.maxValue, Math.abs(V));
+              }
+            }, ur.prototype.upload = function(y) {
+              this.paintVertexArray && this.paintVertexArray.arrayBuffer && (this.paintVertexBuffer && this.paintVertexBuffer.buffer ? this.paintVertexBuffer.updateData(this.paintVertexArray) : this.paintVertexBuffer = y.createVertexBuffer(this.paintVertexArray, this.paintVertexAttributes, this.expression.isStateDependent));
+            }, ur.prototype.destroy = function() {
+              this.paintVertexBuffer && this.paintVertexBuffer.destroy();
+            };
+            var br = function(y, I, V, $, ae, he) {
+              this.expression = y, this.uniformNames = I.map(function(ze) {
+                return "u_" + ze + "_t";
+              }), this.type = V, this.useIntegerZoom = $, this.zoom = ae, this.maxValue = 0, this.paintVertexAttributes = I.map(function(ze) {
+                return { name: "a_" + ze, type: "Float32", components: V === "color" ? 4 : 2, offset: 0 };
+              }), this.paintVertexArray = new he();
+            };
+            br.prototype.populatePaintArray = function(y, I, V, $, ae) {
+              var he = this.expression.evaluate(new Gn(this.zoom), I, {}, $, [], ae), ze = this.expression.evaluate(new Gn(this.zoom + 1), I, {}, $, [], ae), rt = this.paintVertexArray.length;
+              this.paintVertexArray.resize(y), this._setPaintValue(rt, y, he, ze);
+            }, br.prototype.updatePaintArray = function(y, I, V, $) {
+              var ae = this.expression.evaluate({ zoom: this.zoom }, V, $), he = this.expression.evaluate({ zoom: this.zoom + 1 }, V, $);
+              this._setPaintValue(y, I, ae, he);
+            }, br.prototype._setPaintValue = function(y, I, V, $) {
+              if (this.type === "color") for (var ae = yt(V), he = yt($), ze = y; ze < I; ze++) this.paintVertexArray.emplace(ze, ae[0], ae[1], he[0], he[1]);
+              else {
+                for (var rt = y; rt < I; rt++) this.paintVertexArray.emplace(rt, V, $);
+                this.maxValue = Math.max(this.maxValue, Math.abs(V), Math.abs($));
+              }
+            }, br.prototype.upload = function(y) {
+              this.paintVertexArray && this.paintVertexArray.arrayBuffer && (this.paintVertexBuffer && this.paintVertexBuffer.buffer ? this.paintVertexBuffer.updateData(this.paintVertexArray) : this.paintVertexBuffer = y.createVertexBuffer(this.paintVertexArray, this.paintVertexAttributes, this.expression.isStateDependent));
+            }, br.prototype.destroy = function() {
+              this.paintVertexBuffer && this.paintVertexBuffer.destroy();
+            }, br.prototype.setUniform = function(y, I) {
+              var V = this.useIntegerZoom ? Math.floor(I.zoom) : I.zoom, $ = p(this.expression.interpolationFactor(V, this.zoom, this.zoom + 1), 0, 1);
+              y.set($);
+            }, br.prototype.getBinding = function(y, I, V) {
+              return new Qe(y, I);
+            };
+            var Ur = function(y, I, V, $, ae, he) {
+              this.expression = y, this.type = I, this.useIntegerZoom = V, this.zoom = $, this.layerId = he, this.zoomInPaintVertexArray = new ae(), this.zoomOutPaintVertexArray = new ae();
+            };
+            Ur.prototype.populatePaintArray = function(y, I, V) {
+              var $ = this.zoomInPaintVertexArray.length;
+              this.zoomInPaintVertexArray.resize(y), this.zoomOutPaintVertexArray.resize(y), this._setPaintValues($, y, I.patterns && I.patterns[this.layerId], V);
+            }, Ur.prototype.updatePaintArray = function(y, I, V, $, ae) {
+              this._setPaintValues(y, I, V.patterns && V.patterns[this.layerId], ae);
+            }, Ur.prototype._setPaintValues = function(y, I, V, $) {
+              if (!(!$ || !V)) {
+                var ae = V.min, he = V.mid, ze = V.max, rt = $[ae], gt = $[he], Et = $[ze];
+                if (!(!rt || !gt || !Et)) for (var or = y; or < I; or++) this.zoomInPaintVertexArray.emplace(or, gt.tl[0], gt.tl[1], gt.br[0], gt.br[1], rt.tl[0], rt.tl[1], rt.br[0], rt.br[1], gt.pixelRatio, rt.pixelRatio), this.zoomOutPaintVertexArray.emplace(or, gt.tl[0], gt.tl[1], gt.br[0], gt.br[1], Et.tl[0], Et.tl[1], Et.br[0], Et.br[1], gt.pixelRatio, Et.pixelRatio);
+              }
+            }, Ur.prototype.upload = function(y) {
+              this.zoomInPaintVertexArray && this.zoomInPaintVertexArray.arrayBuffer && this.zoomOutPaintVertexArray && this.zoomOutPaintVertexArray.arrayBuffer && (this.zoomInPaintVertexBuffer = y.createVertexBuffer(this.zoomInPaintVertexArray, D.members, this.expression.isStateDependent), this.zoomOutPaintVertexBuffer = y.createVertexBuffer(this.zoomOutPaintVertexArray, D.members, this.expression.isStateDependent));
+            }, Ur.prototype.destroy = function() {
+              this.zoomOutPaintVertexBuffer && this.zoomOutPaintVertexBuffer.destroy(), this.zoomInPaintVertexBuffer && this.zoomInPaintVertexBuffer.destroy();
+            };
+            var Di = function(y, I, V) {
+              this.binders = {}, this._buffers = [];
+              var $ = [];
+              for (var ae in y.paint._values) if (V(ae)) {
+                var he = y.paint.get(ae);
+                if (!(!(he instanceof dl) || !Ws(he.property.specification))) {
+                  var ze = Ti(ae, y.type), rt = he.value, gt = he.property.specification.type, Et = he.property.useIntegerZoom, or = he.property.specification["property-type"], _r = or === "cross-faded" || or === "cross-faded-data-driven";
+                  if (rt.kind === "constant") this.binders[ae] = _r ? new ht(rt.value, ze) : new Pt(rt.value, ze, gt), $.push("/u_" + ae);
+                  else if (rt.kind === "source" || _r) {
+                    var pr = rn(ae, gt, "source");
+                    this.binders[ae] = _r ? new Ur(rt, gt, Et, I, pr, y.id) : new ur(rt, ze, gt, pr), $.push("/a_" + ae);
+                  } else {
+                    var Fr = rn(ae, gt, "composite");
+                    this.binders[ae] = new br(rt, ze, gt, Et, I, Fr), $.push("/z_" + ae);
+                  }
+                }
+              }
+              this.cacheKey = $.sort().join("");
+            };
+            Di.prototype.getMaxValue = function(y) {
+              var I = this.binders[y];
+              return I instanceof ur || I instanceof br ? I.maxValue : 0;
+            }, Di.prototype.populatePaintArrays = function(y, I, V, $, ae) {
+              for (var he in this.binders) {
+                var ze = this.binders[he];
+                (ze instanceof ur || ze instanceof br || ze instanceof Ur) && ze.populatePaintArray(y, I, V, $, ae);
+              }
+            }, Di.prototype.setConstantPatternPositions = function(y, I) {
+              for (var V in this.binders) {
+                var $ = this.binders[V];
+                $ instanceof ht && $.setConstantPatternPositions(y, I);
+              }
+            }, Di.prototype.updatePaintArrays = function(y, I, V, $, ae) {
+              var he = false;
+              for (var ze in y) for (var rt = I.getPositions(ze), gt = 0, Et = rt; gt < Et.length; gt += 1) {
+                var or = Et[gt], _r = V.feature(or.index);
+                for (var pr in this.binders) {
+                  var Fr = this.binders[pr];
+                  if ((Fr instanceof ur || Fr instanceof br || Fr instanceof Ur) && Fr.expression.isStateDependent === true) {
+                    var oi = $.paint.get(pr);
+                    Fr.expression = oi.value, Fr.updatePaintArray(or.start, or.end, _r, y[ze], ae), he = true;
+                  }
+                }
+              }
+              return he;
+            }, Di.prototype.defines = function() {
+              var y = [];
+              for (var I in this.binders) {
+                var V = this.binders[I];
+                (V instanceof Pt || V instanceof ht) && y.push.apply(y, V.uniformNames.map(function($) {
+                  return "#define HAS_UNIFORM_" + $;
+                }));
+              }
+              return y;
+            }, Di.prototype.getBinderAttributes = function() {
+              var y = [];
+              for (var I in this.binders) {
+                var V = this.binders[I];
+                if (V instanceof ur || V instanceof br) for (var $ = 0; $ < V.paintVertexAttributes.length; $++) y.push(V.paintVertexAttributes[$].name);
+                else if (V instanceof Ur) for (var ae = 0; ae < D.members.length; ae++) y.push(D.members[ae].name);
+              }
+              return y;
+            }, Di.prototype.getBinderUniforms = function() {
+              var y = [];
+              for (var I in this.binders) {
+                var V = this.binders[I];
+                if (V instanceof Pt || V instanceof ht || V instanceof br) for (var $ = 0, ae = V.uniformNames; $ < ae.length; $ += 1) {
+                  var he = ae[$];
+                  y.push(he);
+                }
+              }
+              return y;
+            }, Di.prototype.getPaintVertexBuffers = function() {
+              return this._buffers;
+            }, Di.prototype.getUniforms = function(y, I) {
+              var V = [];
+              for (var $ in this.binders) {
+                var ae = this.binders[$];
+                if (ae instanceof Pt || ae instanceof ht || ae instanceof br) for (var he = 0, ze = ae.uniformNames; he < ze.length; he += 1) {
+                  var rt = ze[he];
+                  if (I[rt]) {
+                    var gt = ae.getBinding(y, I[rt], rt);
+                    V.push({ name: rt, property: $, binding: gt });
+                  }
+                }
+              }
+              return V;
+            }, Di.prototype.setUniforms = function(y, I, V, $) {
+              for (var ae = 0, he = I; ae < he.length; ae += 1) {
+                var ze = he[ae], rt = ze.name, gt = ze.property, Et = ze.binding;
+                this.binders[gt].setUniform(Et, $, V.get(gt), rt);
+              }
+            }, Di.prototype.updatePaintBuffers = function(y) {
+              this._buffers = [];
+              for (var I in this.binders) {
+                var V = this.binders[I];
+                if (y && V instanceof Ur) {
+                  var $ = y.fromScale === 2 ? V.zoomInPaintVertexBuffer : V.zoomOutPaintVertexBuffer;
+                  $ && this._buffers.push($);
+                } else (V instanceof ur || V instanceof br) && V.paintVertexBuffer && this._buffers.push(V.paintVertexBuffer);
+              }
+            }, Di.prototype.upload = function(y) {
+              for (var I in this.binders) {
+                var V = this.binders[I];
+                (V instanceof ur || V instanceof br || V instanceof Ur) && V.upload(y);
+              }
+              this.updatePaintBuffers();
+            }, Di.prototype.destroy = function() {
+              for (var y in this.binders) {
+                var I = this.binders[y];
+                (I instanceof ur || I instanceof br || I instanceof Ur) && I.destroy();
+              }
+            };
+            var fi = function(y, I, V) {
+              V === void 0 && (V = function() {
+                return true;
+              }), this.programConfigurations = {};
+              for (var $ = 0, ae = y; $ < ae.length; $ += 1) {
+                var he = ae[$];
+                this.programConfigurations[he.id] = new Di(he, I, V);
+              }
+              this.needsUpload = false, this._featureMap = new we(), this._bufferOffset = 0;
+            };
+            fi.prototype.populatePaintArrays = function(y, I, V, $, ae, he) {
+              for (var ze in this.programConfigurations) this.programConfigurations[ze].populatePaintArrays(y, I, $, ae, he);
+              I.id !== void 0 && this._featureMap.add(I.id, V, this._bufferOffset, y), this._bufferOffset = y, this.needsUpload = true;
+            }, fi.prototype.updatePaintArrays = function(y, I, V, $) {
+              for (var ae = 0, he = V; ae < he.length; ae += 1) {
+                var ze = he[ae];
+                this.needsUpload = this.programConfigurations[ze.id].updatePaintArrays(y, this._featureMap, I, ze, $) || this.needsUpload;
+              }
+            }, fi.prototype.get = function(y) {
+              return this.programConfigurations[y];
+            }, fi.prototype.upload = function(y) {
+              if (this.needsUpload) {
+                for (var I in this.programConfigurations) this.programConfigurations[I].upload(y);
+                this.needsUpload = false;
+              }
+            }, fi.prototype.destroy = function() {
+              for (var y in this.programConfigurations) this.programConfigurations[y].destroy();
+            };
+            function Ti(m, y) {
+              var I = { "text-opacity": ["opacity"], "icon-opacity": ["opacity"], "text-color": ["fill_color"], "icon-color": ["fill_color"], "text-halo-color": ["halo_color"], "icon-halo-color": ["halo_color"], "text-halo-blur": ["halo_blur"], "icon-halo-blur": ["halo_blur"], "text-halo-width": ["halo_width"], "icon-halo-width": ["halo_width"], "line-gap-width": ["gapwidth"], "line-pattern": ["pattern_to", "pattern_from", "pixel_ratio_to", "pixel_ratio_from"], "fill-pattern": ["pattern_to", "pattern_from", "pixel_ratio_to", "pixel_ratio_from"], "fill-extrusion-pattern": ["pattern_to", "pattern_from", "pixel_ratio_to", "pixel_ratio_from"] };
+              return I[m] || [m.replace(y + "-", "").replace(/-/g, "_")];
+            }
+            function gn(m) {
+              var y = { "line-pattern": { source: Zi, composite: Zi }, "fill-pattern": { source: Zi, composite: Zi }, "fill-extrusion-pattern": { source: Zi, composite: Zi } };
+              return y[m];
+            }
+            function rn(m, y, I) {
+              var V = { color: { source: an, composite: is }, number: { source: Ki, composite: an } }, $ = gn(m);
+              return $ && $[I] || V[y][I];
+            }
+            X("ConstantBinder", Pt), X("CrossFadedConstantBinder", ht), X("SourceExpressionBinder", ur), X("CrossFadedCompositeBinder", Ur), X("CompositeExpressionBinder", br), X("ProgramConfiguration", Di, { omit: ["_buffers"] }), X("ProgramConfigurationSet", fi);
+            var Ci = 8192, Bi = 15, Gi = Math.pow(2, Bi - 1) - 1, sn = -Gi - 1;
+            function zn(m) {
+              for (var y = Ci / m.extent, I = m.loadGeometry(), V = 0; V < I.length; V++) for (var $ = I[V], ae = 0; ae < $.length; ae++) {
+                var he = $[ae], ze = Math.round(he.x * y), rt = Math.round(he.y * y);
+                he.x = p(ze, sn, Gi), he.y = p(rt, sn, Gi), (ze < he.x || ze > he.x + 1 || rt < he.y || rt > he.y + 1) && re("Geometry exceeds allowed extent, reduce your vector tile buffer size");
+              }
+              return I;
+            }
+            function Ja(m, y) {
+              return { type: m.type, id: m.id, properties: m.properties, geometry: y ? zn(m) : [] };
+            }
+            function co(m, y, I, V, $) {
+              m.emplaceBack(y * 2 + (V + 1) / 2, I * 2 + ($ + 1) / 2);
+            }
+            var ts = function(y) {
+              this.zoom = y.zoom, this.overscaling = y.overscaling, this.layers = y.layers, this.layerIds = this.layers.map(function(I) {
+                return I.id;
+              }), this.index = y.index, this.hasPattern = false, this.layoutVertexArray = new Yr(), this.indexArray = new pn(), this.segments = new io(), this.programConfigurations = new fi(y.layers, y.zoom), this.stateDependentLayerIds = this.layers.filter(function(I) {
+                return I.isStateDependent();
+              }).map(function(I) {
+                return I.id;
+              });
+            };
+            ts.prototype.populate = function(y, I, V) {
+              var $ = this.layers[0], ae = [], he = null;
+              $.type === "circle" && (he = $.layout.get("circle-sort-key"));
+              for (var ze = 0, rt = y; ze < rt.length; ze += 1) {
+                var gt = rt[ze], Et = gt.feature, or = gt.id, _r = gt.index, pr = gt.sourceLayerIndex, Fr = this.layers[0]._featureFilter.needGeometry, oi = Ja(Et, Fr);
+                if (this.layers[0]._featureFilter.filter(new Gn(this.zoom), oi, V)) {
+                  var Hi = he ? he.evaluate(oi, {}, V) : void 0, Ai = { id: or, properties: Et.properties, type: Et.type, sourceLayerIndex: pr, index: _r, geometry: Fr ? oi.geometry : zn(Et), patterns: {}, sortKey: Hi };
+                  ae.push(Ai);
+                }
+              }
+              he && ae.sort(function(za, Za) {
+                return za.sortKey - Za.sortKey;
+              });
+              for (var bn = 0, nn = ae; bn < nn.length; bn += 1) {
+                var xn = nn[bn], Pn = xn, Zn = Pn.geometry, ga = Pn.index, ha = Pn.sourceLayerIndex, eo = y[ga].feature;
+                this.addFeature(xn, Zn, ga, V), I.featureIndex.insert(eo, Zn, ga, ha, this.index);
+              }
+            }, ts.prototype.update = function(y, I, V) {
+              this.stateDependentLayers.length && this.programConfigurations.updatePaintArrays(y, I, this.stateDependentLayers, V);
+            }, ts.prototype.isEmpty = function() {
+              return this.layoutVertexArray.length === 0;
+            }, ts.prototype.uploadPending = function() {
+              return !this.uploaded || this.programConfigurations.needsUpload;
+            }, ts.prototype.upload = function(y) {
+              this.uploaded || (this.layoutVertexBuffer = y.createVertexBuffer(this.layoutVertexArray, ol), this.indexBuffer = y.createIndexBuffer(this.indexArray)), this.programConfigurations.upload(y), this.uploaded = true;
+            }, ts.prototype.destroy = function() {
+              this.layoutVertexBuffer && (this.layoutVertexBuffer.destroy(), this.indexBuffer.destroy(), this.programConfigurations.destroy(), this.segments.destroy());
+            }, ts.prototype.addFeature = function(y, I, V, $) {
+              for (var ae = 0, he = I; ae < he.length; ae += 1) for (var ze = he[ae], rt = 0, gt = ze; rt < gt.length; rt += 1) {
+                var Et = gt[rt], or = Et.x, _r = Et.y;
+                if (!(or < 0 || or >= Ci || _r < 0 || _r >= Ci)) {
+                  var pr = this.segments.prepareSegment(4, this.layoutVertexArray, this.indexArray, y.sortKey), Fr = pr.vertexLength;
+                  co(this.layoutVertexArray, or, _r, -1, -1), co(this.layoutVertexArray, or, _r, 1, -1), co(this.layoutVertexArray, or, _r, 1, 1), co(this.layoutVertexArray, or, _r, -1, 1), this.indexArray.emplaceBack(Fr, Fr + 1, Fr + 2), this.indexArray.emplaceBack(Fr, Fr + 3, Fr + 2), pr.vertexLength += 4, pr.primitiveLength += 2;
+                }
+              }
+              this.programConfigurations.populatePaintArrays(this.layoutVertexArray.length, y, V, {}, $);
+            }, X("CircleBucket", ts, { omit: ["layers"] });
+            function so(m, y) {
+              for (var I = 0; I < m.length; I++) if (Td(y, m[I])) return true;
+              for (var V = 0; V < y.length; V++) if (Td(m, y[V])) return true;
+              return !!Lv(m, y);
+            }
+            function Yo(m, y, I) {
+              return !!(Td(m, y) || Kv(y, m, I));
+            }
+            function ms(m, y) {
+              if (m.length === 1) return gp(y, m[0]);
+              for (var I = 0; I < y.length; I++) for (var V = y[I], $ = 0; $ < V.length; $++) if (Td(m, V[$])) return true;
+              for (var ae = 0; ae < m.length; ae++) if (gp(y, m[ae])) return true;
+              for (var he = 0; he < y.length; he++) if (Lv(m, y[he])) return true;
+              return false;
+            }
+            function ou(m, y, I) {
+              for (var V = 0; V < y.length; V++) {
+                var $ = y[V];
+                if (m.length >= 3) {
+                  for (var ae = 0; ae < $.length; ae++) if (Td(m, $[ae])) return true;
+                }
+                if (Cv(m, $, I)) return true;
+              }
+              return false;
+            }
+            function Cv(m, y, I) {
+              if (m.length > 1) {
+                if (Lv(m, y)) return true;
+                for (var V = 0; V < y.length; V++) if (Kv(y[V], m, I)) return true;
+              }
+              for (var $ = 0; $ < m.length; $++) if (Kv(m[$], y, I)) return true;
+              return false;
+            }
+            function Lv(m, y) {
+              if (m.length === 0 || y.length === 0) return false;
+              for (var I = 0; I < m.length - 1; I++) for (var V = m[I], $ = m[I + 1], ae = 0; ae < y.length - 1; ae++) {
+                var he = y[ae], ze = y[ae + 1];
+                if (wd(V, $, he, ze)) return true;
+              }
+              return false;
+            }
+            function wd(m, y, I, V) {
+              return oe(m, I, V) !== oe(y, I, V) && oe(m, y, I) !== oe(m, y, V);
+            }
+            function Kv(m, y, I) {
+              var V = I * I;
+              if (y.length === 1) return m.distSqr(y[0]) < V;
+              for (var $ = 1; $ < y.length; $++) {
+                var ae = y[$ - 1], he = y[$];
+                if (hg(m, ae, he) < V) return true;
+              }
+              return false;
+            }
+            function hg(m, y, I) {
+              var V = y.distSqr(I);
+              if (V === 0) return m.distSqr(y);
+              var $ = ((m.x - y.x) * (I.x - y.x) + (m.y - y.y) * (I.y - y.y)) / V;
+              return $ < 0 ? m.distSqr(y) : $ > 1 ? m.distSqr(I) : m.distSqr(I.sub(y)._mult($)._add(y));
+            }
+            function gp(m, y) {
+              for (var I = false, V, $, ae, he = 0; he < m.length; he++) {
+                V = m[he];
+                for (var ze = 0, rt = V.length - 1; ze < V.length; rt = ze++) $ = V[ze], ae = V[rt], $.y > y.y != ae.y > y.y && y.x < (ae.x - $.x) * (y.y - $.y) / (ae.y - $.y) + $.x && (I = !I);
+              }
+              return I;
+            }
+            function Td(m, y) {
+              for (var I = false, V = 0, $ = m.length - 1; V < m.length; $ = V++) {
+                var ae = m[V], he = m[$];
+                ae.y > y.y != he.y > y.y && y.x < (he.x - ae.x) * (y.y - ae.y) / (he.y - ae.y) + ae.x && (I = !I);
+              }
+              return I;
+            }
+            function mp(m, y, I, V, $) {
+              for (var ae = 0, he = m; ae < he.length; ae += 1) {
+                var ze = he[ae];
+                if (y <= ze.x && I <= ze.y && V >= ze.x && $ >= ze.y) return true;
+              }
+              var rt = [new u(y, I), new u(y, $), new u(V, $), new u(V, I)];
+              if (m.length > 2) for (var gt = 0, Et = rt; gt < Et.length; gt += 1) {
+                var or = Et[gt];
+                if (Td(m, or)) return true;
+              }
+              for (var _r = 0; _r < m.length - 1; _r++) {
+                var pr = m[_r], Fr = m[_r + 1];
+                if (Ud(pr, Fr, rt)) return true;
+              }
+              return false;
+            }
+            function Ud(m, y, I) {
+              var V = I[0], $ = I[2];
+              if (m.x < V.x && y.x < V.x || m.x > $.x && y.x > $.x || m.y < V.y && y.y < V.y || m.y > $.y && y.y > $.y) return false;
+              var ae = oe(m, y, I[0]);
+              return ae !== oe(m, y, I[1]) || ae !== oe(m, y, I[2]) || ae !== oe(m, y, I[3]);
+            }
+            function Ad(m, y, I) {
+              var V = y.paint.get(m).value;
+              return V.kind === "constant" ? V.value : I.programConfigurations.get(y.id).getMaxValue(m);
+            }
+            function Pv(m) {
+              return Math.sqrt(m[0] * m[0] + m[1] * m[1]);
+            }
+            function Jv(m, y, I, V, $) {
+              if (!y[0] && !y[1]) return m;
+              var ae = u.convert(y)._mult($);
+              I === "viewport" && ae._rotate(-V);
+              for (var he = [], ze = 0; ze < m.length; ze++) {
+                var rt = m[ze];
+                he.push(rt.sub(ae));
+              }
+              return he;
+            }
+            var Iv = new Nr({ "circle-sort-key": new bt(Rn.layout_circle["circle-sort-key"]) }), fy = new Nr({ "circle-radius": new bt(Rn.paint_circle["circle-radius"]), "circle-color": new bt(Rn.paint_circle["circle-color"]), "circle-blur": new bt(Rn.paint_circle["circle-blur"]), "circle-opacity": new bt(Rn.paint_circle["circle-opacity"]), "circle-translate": new Me(Rn.paint_circle["circle-translate"]), "circle-translate-anchor": new Me(Rn.paint_circle["circle-translate-anchor"]), "circle-pitch-scale": new Me(Rn.paint_circle["circle-pitch-scale"]), "circle-pitch-alignment": new Me(Rn.paint_circle["circle-pitch-alignment"]), "circle-stroke-width": new bt(Rn.paint_circle["circle-stroke-width"]), "circle-stroke-color": new bt(Rn.paint_circle["circle-stroke-color"]), "circle-stroke-opacity": new bt(Rn.paint_circle["circle-stroke-opacity"]) }), dg = { paint: fy, layout: Iv }, oh = typeof Float32Array != "undefined" ? Float32Array : Array;
+            Math.hypot || (Math.hypot = function() {
+              for (var m = arguments, y = 0, I = arguments.length; I--; ) y += m[I] * m[I];
+              return Math.sqrt(y);
+            });
+            function vg() {
+              var m = new oh(4);
+              return oh != Float32Array && (m[1] = 0, m[2] = 0), m[0] = 1, m[3] = 1, m;
+            }
+            function hy(m, y, I) {
+              var V = y[0], $ = y[1], ae = y[2], he = y[3], ze = Math.sin(I), rt = Math.cos(I);
+              return m[0] = V * rt + ae * ze, m[1] = $ * rt + he * ze, m[2] = V * -ze + ae * rt, m[3] = $ * -ze + he * rt, m;
+            }
+            function Zh() {
+              var m = new oh(9);
+              return oh != Float32Array && (m[1] = 0, m[2] = 0, m[3] = 0, m[5] = 0, m[6] = 0, m[7] = 0), m[0] = 1, m[4] = 1, m[8] = 1, m;
+            }
+            function am(m, y) {
+              var I = Math.sin(y), V = Math.cos(y);
+              return m[0] = V, m[1] = I, m[2] = 0, m[3] = -I, m[4] = V, m[5] = 0, m[6] = 0, m[7] = 0, m[8] = 1, m;
+            }
+            function k1() {
+              var m = new oh(16);
+              return oh != Float32Array && (m[1] = 0, m[2] = 0, m[3] = 0, m[4] = 0, m[6] = 0, m[7] = 0, m[8] = 0, m[9] = 0, m[11] = 0, m[12] = 0, m[13] = 0, m[14] = 0), m[0] = 1, m[5] = 1, m[10] = 1, m[15] = 1, m;
+            }
+            function C1(m) {
+              var y = new oh(16);
+              return y[0] = m[0], y[1] = m[1], y[2] = m[2], y[3] = m[3], y[4] = m[4], y[5] = m[5], y[6] = m[6], y[7] = m[7], y[8] = m[8], y[9] = m[9], y[10] = m[10], y[11] = m[11], y[12] = m[12], y[13] = m[13], y[14] = m[14], y[15] = m[15], y;
+            }
+            function dy(m) {
+              return m[0] = 1, m[1] = 0, m[2] = 0, m[3] = 0, m[4] = 0, m[5] = 1, m[6] = 0, m[7] = 0, m[8] = 0, m[9] = 0, m[10] = 1, m[11] = 0, m[12] = 0, m[13] = 0, m[14] = 0, m[15] = 1, m;
+            }
+            function om(m, y) {
+              var I = y[0], V = y[1], $ = y[2], ae = y[3], he = y[4], ze = y[5], rt = y[6], gt = y[7], Et = y[8], or = y[9], _r = y[10], pr = y[11], Fr = y[12], oi = y[13], Hi = y[14], Ai = y[15], bn = I * ze - V * he, nn = I * rt - $ * he, xn = I * gt - ae * he, Pn = V * rt - $ * ze, Zn = V * gt - ae * ze, ga = $ * gt - ae * rt, ha = Et * oi - or * Fr, eo = Et * Hi - _r * Fr, za = Et * Ai - pr * Fr, Za = or * Hi - _r * oi, Jo = or * Ai - pr * oi, to = _r * Ai - pr * Hi, ao = bn * to - nn * Jo + xn * Za + Pn * za - Zn * eo + ga * ha;
+              return ao ? (ao = 1 / ao, m[0] = (ze * to - rt * Jo + gt * Za) * ao, m[1] = ($ * Jo - V * to - ae * Za) * ao, m[2] = (oi * ga - Hi * Zn + Ai * Pn) * ao, m[3] = (_r * Zn - or * ga - pr * Pn) * ao, m[4] = (rt * za - he * to - gt * eo) * ao, m[5] = (I * to - $ * za + ae * eo) * ao, m[6] = (Hi * xn - Fr * ga - Ai * nn) * ao, m[7] = (Et * ga - _r * xn + pr * nn) * ao, m[8] = (he * Jo - ze * za + gt * ha) * ao, m[9] = (V * za - I * Jo - ae * ha) * ao, m[10] = (Fr * Zn - oi * xn + Ai * bn) * ao, m[11] = (or * xn - Et * Zn - pr * bn) * ao, m[12] = (ze * eo - he * Za - rt * ha) * ao, m[13] = (I * Za - V * eo + $ * ha) * ao, m[14] = (oi * nn - Fr * Pn - Hi * bn) * ao, m[15] = (Et * Pn - or * nn + _r * bn) * ao, m) : null;
+            }
+            function sm(m, y, I) {
+              var V = y[0], $ = y[1], ae = y[2], he = y[3], ze = y[4], rt = y[5], gt = y[6], Et = y[7], or = y[8], _r = y[9], pr = y[10], Fr = y[11], oi = y[12], Hi = y[13], Ai = y[14], bn = y[15], nn = I[0], xn = I[1], Pn = I[2], Zn = I[3];
+              return m[0] = nn * V + xn * ze + Pn * or + Zn * oi, m[1] = nn * $ + xn * rt + Pn * _r + Zn * Hi, m[2] = nn * ae + xn * gt + Pn * pr + Zn * Ai, m[3] = nn * he + xn * Et + Pn * Fr + Zn * bn, nn = I[4], xn = I[5], Pn = I[6], Zn = I[7], m[4] = nn * V + xn * ze + Pn * or + Zn * oi, m[5] = nn * $ + xn * rt + Pn * _r + Zn * Hi, m[6] = nn * ae + xn * gt + Pn * pr + Zn * Ai, m[7] = nn * he + xn * Et + Pn * Fr + Zn * bn, nn = I[8], xn = I[9], Pn = I[10], Zn = I[11], m[8] = nn * V + xn * ze + Pn * or + Zn * oi, m[9] = nn * $ + xn * rt + Pn * _r + Zn * Hi, m[10] = nn * ae + xn * gt + Pn * pr + Zn * Ai, m[11] = nn * he + xn * Et + Pn * Fr + Zn * bn, nn = I[12], xn = I[13], Pn = I[14], Zn = I[15], m[12] = nn * V + xn * ze + Pn * or + Zn * oi, m[13] = nn * $ + xn * rt + Pn * _r + Zn * Hi, m[14] = nn * ae + xn * gt + Pn * pr + Zn * Ai, m[15] = nn * he + xn * Et + Pn * Fr + Zn * bn, m;
+            }
+            function vc(m, y, I) {
+              var V = I[0], $ = I[1], ae = I[2], he, ze, rt, gt, Et, or, _r, pr, Fr, oi, Hi, Ai;
+              return y === m ? (m[12] = y[0] * V + y[4] * $ + y[8] * ae + y[12], m[13] = y[1] * V + y[5] * $ + y[9] * ae + y[13], m[14] = y[2] * V + y[6] * $ + y[10] * ae + y[14], m[15] = y[3] * V + y[7] * $ + y[11] * ae + y[15]) : (he = y[0], ze = y[1], rt = y[2], gt = y[3], Et = y[4], or = y[5], _r = y[6], pr = y[7], Fr = y[8], oi = y[9], Hi = y[10], Ai = y[11], m[0] = he, m[1] = ze, m[2] = rt, m[3] = gt, m[4] = Et, m[5] = or, m[6] = _r, m[7] = pr, m[8] = Fr, m[9] = oi, m[10] = Hi, m[11] = Ai, m[12] = he * V + Et * $ + Fr * ae + y[12], m[13] = ze * V + or * $ + oi * ae + y[13], m[14] = rt * V + _r * $ + Hi * ae + y[14], m[15] = gt * V + pr * $ + Ai * ae + y[15]), m;
+            }
+            function tu(m, y, I) {
+              var V = I[0], $ = I[1], ae = I[2];
+              return m[0] = y[0] * V, m[1] = y[1] * V, m[2] = y[2] * V, m[3] = y[3] * V, m[4] = y[4] * $, m[5] = y[5] * $, m[6] = y[6] * $, m[7] = y[7] * $, m[8] = y[8] * ae, m[9] = y[9] * ae, m[10] = y[10] * ae, m[11] = y[11] * ae, m[12] = y[12], m[13] = y[13], m[14] = y[14], m[15] = y[15], m;
+            }
+            function Sd(m, y, I) {
+              var V = Math.sin(I), $ = Math.cos(I), ae = y[4], he = y[5], ze = y[6], rt = y[7], gt = y[8], Et = y[9], or = y[10], _r = y[11];
+              return y !== m && (m[0] = y[0], m[1] = y[1], m[2] = y[2], m[3] = y[3], m[12] = y[12], m[13] = y[13], m[14] = y[14], m[15] = y[15]), m[4] = ae * $ + gt * V, m[5] = he * $ + Et * V, m[6] = ze * $ + or * V, m[7] = rt * $ + _r * V, m[8] = gt * $ - ae * V, m[9] = Et * $ - he * V, m[10] = or * $ - ze * V, m[11] = _r * $ - rt * V, m;
+            }
+            function vy(m, y, I) {
+              var V = Math.sin(I), $ = Math.cos(I), ae = y[0], he = y[1], ze = y[2], rt = y[3], gt = y[4], Et = y[5], or = y[6], _r = y[7];
+              return y !== m && (m[8] = y[8], m[9] = y[9], m[10] = y[10], m[11] = y[11], m[12] = y[12], m[13] = y[13], m[14] = y[14], m[15] = y[15]), m[0] = ae * $ + gt * V, m[1] = he * $ + Et * V, m[2] = ze * $ + or * V, m[3] = rt * $ + _r * V, m[4] = gt * $ - ae * V, m[5] = Et * $ - he * V, m[6] = or * $ - ze * V, m[7] = _r * $ - rt * V, m;
+            }
+            function L1(m, y, I, V, $) {
+              var ae = 1 / Math.tan(y / 2), he;
+              return m[0] = ae / I, m[1] = 0, m[2] = 0, m[3] = 0, m[4] = 0, m[5] = ae, m[6] = 0, m[7] = 0, m[8] = 0, m[9] = 0, m[11] = -1, m[12] = 0, m[13] = 0, m[15] = 0, $ != null && $ !== 1 / 0 ? (he = 1 / (V - $), m[10] = ($ + V) * he, m[14] = 2 * $ * V * he) : (m[10] = -1, m[14] = -2 * V), m;
+            }
+            function wu(m, y, I, V, $, ae, he) {
+              var ze = 1 / (y - I), rt = 1 / (V - $), gt = 1 / (ae - he);
+              return m[0] = -2 * ze, m[1] = 0, m[2] = 0, m[3] = 0, m[4] = 0, m[5] = -2 * rt, m[6] = 0, m[7] = 0, m[8] = 0, m[9] = 0, m[10] = 2 * gt, m[11] = 0, m[12] = (y + I) * ze, m[13] = ($ + V) * rt, m[14] = (he + ae) * gt, m[15] = 1, m;
+            }
+            var Yx = sm;
+            function lm() {
+              var m = new oh(3);
+              return oh != Float32Array && (m[0] = 0, m[1] = 0, m[2] = 0), m;
+            }
+            function Ow(m) {
+              var y = new oh(3);
+              return y[0] = m[0], y[1] = m[1], y[2] = m[2], y;
+            }
+            function Rv(m, y, I) {
+              return m[0] = y[0] + I[0], m[1] = y[1] + I[1], m[2] = y[2] + I[2], m;
+            }
+            function um(m, y, I) {
+              return m[0] = y[0] - I[0], m[1] = y[1] - I[1], m[2] = y[2] - I[2], m;
+            }
+            function qw(m, y, I) {
+              return m[0] = y[0] * I, m[1] = y[1] * I, m[2] = y[2] * I, m;
+            }
+            function Kx(m, y) {
+              var I = y[0], V = y[1], $ = y[2], ae = I * I + V * V + $ * $;
+              return ae > 0 && (ae = 1 / Math.sqrt(ae)), m[0] = y[0] * ae, m[1] = y[1] * ae, m[2] = y[2] * ae, m;
+            }
+            function V9(m, y) {
+              return m[0] * y[0] + m[1] * y[1] + m[2] * y[2];
+            }
+            function G9(m, y, I) {
+              var V = y[0], $ = y[1], ae = y[2], he = I[0], ze = I[1], rt = I[2];
+              return m[0] = $ * rt - ae * ze, m[1] = ae * he - V * rt, m[2] = V * ze - $ * he, m;
+            }
+            function H9(m, y, I) {
+              var V = y[0], $ = y[1], ae = y[2];
+              return m[0] = V * I[0] + $ * I[3] + ae * I[6], m[1] = V * I[1] + $ * I[4] + ae * I[7], m[2] = V * I[2] + $ * I[5] + ae * I[8], m;
+            }
+            var j9 = um;
+            (function() {
+              var m = lm();
+              return function(y, I, V, $, ae, he) {
+                var ze, rt;
+                for (I || (I = 3), V || (V = 0), $ ? rt = Math.min($ * I + V, y.length) : rt = y.length, ze = V; ze < rt; ze += I) m[0] = y[ze], m[1] = y[ze + 1], m[2] = y[ze + 2], ae(m, m, he), y[ze] = m[0], y[ze + 1] = m[1], y[ze + 2] = m[2];
+                return y;
+              };
+            })();
+            function W9() {
+              var m = new oh(4);
+              return oh != Float32Array && (m[0] = 0, m[1] = 0, m[2] = 0, m[3] = 0), m;
+            }
+            function X9(m, y, I) {
+              return m[0] = y[0] * I, m[1] = y[1] * I, m[2] = y[2] * I, m[3] = y[3] * I, m;
+            }
+            function Z9(m, y) {
+              return m[0] * y[0] + m[1] * y[1] + m[2] * y[2] + m[3] * y[3];
+            }
+            function py(m, y, I) {
+              var V = y[0], $ = y[1], ae = y[2], he = y[3];
+              return m[0] = I[0] * V + I[4] * $ + I[8] * ae + I[12] * he, m[1] = I[1] * V + I[5] * $ + I[9] * ae + I[13] * he, m[2] = I[2] * V + I[6] * $ + I[10] * ae + I[14] * he, m[3] = I[3] * V + I[7] * $ + I[11] * ae + I[15] * he, m;
+            }
+            (function() {
+              var m = W9();
+              return function(y, I, V, $, ae, he) {
+                var ze, rt;
+                for (I || (I = 4), V || (V = 0), $ ? rt = Math.min($ * I + V, y.length) : rt = y.length, ze = V; ze < rt; ze += I) m[0] = y[ze], m[1] = y[ze + 1], m[2] = y[ze + 2], m[3] = y[ze + 3], ae(m, m, he), y[ze] = m[0], y[ze + 1] = m[1], y[ze + 2] = m[2], y[ze + 3] = m[3];
+                return y;
+              };
+            })();
+            function SC() {
+              var m = new oh(2);
+              return oh != Float32Array && (m[0] = 0, m[1] = 0), m;
+            }
+            function lS(m) {
+              var y = m[0], I = m[1];
+              return y * y + I * I;
+            }
+            var uS = lS;
+            (function() {
+              var m = SC();
+              return function(y, I, V, $, ae, he) {
+                var ze, rt;
+                for (I || (I = 2), V || (V = 0), $ ? rt = Math.min($ * I + V, y.length) : rt = y.length, ze = V; ze < rt; ze += I) m[0] = y[ze], m[1] = y[ze + 1], ae(m, m, he), y[ze] = m[0], y[ze + 1] = m[1];
+                return y;
+              };
+            })();
+            var Y9 = function(m) {
+              function y(I) {
+                m.call(this, I, dg);
+              }
+              return m && (y.__proto__ = m), y.prototype = Object.create(m && m.prototype), y.prototype.constructor = y, y.prototype.createBucket = function(V) {
+                return new ts(V);
+              }, y.prototype.queryRadius = function(V) {
+                var $ = V;
+                return Ad("circle-radius", this, $) + Ad("circle-stroke-width", this, $) + Pv(this.paint.get("circle-translate"));
+              }, y.prototype.queryIntersectsFeature = function(V, $, ae, he, ze, rt, gt, Et) {
+                for (var or = Jv(V, this.paint.get("circle-translate"), this.paint.get("circle-translate-anchor"), rt.angle, gt), _r = this.paint.get("circle-radius").evaluate($, ae), pr = this.paint.get("circle-stroke-width").evaluate($, ae), Fr = _r + pr, oi = this.paint.get("circle-pitch-alignment") === "map", Hi = oi ? or : EC(or, Et), Ai = oi ? Fr * gt : Fr, bn = 0, nn = he; bn < nn.length; bn += 1) for (var xn = nn[bn], Pn = 0, Zn = xn; Pn < Zn.length; Pn += 1) {
+                  var ga = Zn[Pn], ha = oi ? ga : MC(ga, Et), eo = Ai, za = py([], [ga.x, ga.y, 0, 1], Et);
+                  if (this.paint.get("circle-pitch-scale") === "viewport" && this.paint.get("circle-pitch-alignment") === "map" ? eo *= za[3] / rt.cameraToCenterDistance : this.paint.get("circle-pitch-scale") === "map" && this.paint.get("circle-pitch-alignment") === "viewport" && (eo *= rt.cameraToCenterDistance / za[3]), Yo(Hi, ha, eo)) return true;
+                }
+                return false;
+              }, y;
+            }(mi);
+            function MC(m, y) {
+              var I = py([], [m.x, m.y, 0, 1], y);
+              return new u(I[0] / I[3], I[1] / I[3]);
+            }
+            function EC(m, y) {
+              return m.map(function(I) {
+                return MC(I, y);
+              });
+            }
+            var cS = function(m) {
+              function y() {
+                m.apply(this, arguments);
+              }
+              return m && (y.__proto__ = m), y.prototype = Object.create(m && m.prototype), y.prototype.constructor = y, y;
+            }(ts);
+            X("HeatmapBucket", cS, { omit: ["layers"] });
+            function Md(m, y, I, V) {
+              var $ = y.width, ae = y.height;
+              if (!V) V = new Uint8Array($ * ae * I);
+              else if (V instanceof Uint8ClampedArray) V = new Uint8Array(V.buffer);
+              else if (V.length !== $ * ae * I) throw new RangeError("mismatched image size");
+              return m.width = $, m.height = ae, m.data = V, m;
+            }
+            function Bw(m, y, I) {
+              var V = y.width, $ = y.height;
+              if (!(V === m.width && $ === m.height)) {
+                var ae = Md({}, { width: V, height: $ }, I);
+                Nw(m, ae, { x: 0, y: 0 }, { x: 0, y: 0 }, { width: Math.min(m.width, V), height: Math.min(m.height, $) }, I), m.width = V, m.height = $, m.data = ae.data;
+              }
+            }
+            function Nw(m, y, I, V, $, ae) {
+              if ($.width === 0 || $.height === 0) return y;
+              if ($.width > m.width || $.height > m.height || I.x > m.width - $.width || I.y > m.height - $.height) throw new RangeError("out of range source coordinates for image copy");
+              if ($.width > y.width || $.height > y.height || V.x > y.width - $.width || V.y > y.height - $.height) throw new RangeError("out of range destination coordinates for image copy");
+              for (var he = m.data, ze = y.data, rt = 0; rt < $.height; rt++) for (var gt = ((I.y + rt) * m.width + I.x) * ae, Et = ((V.y + rt) * y.width + V.x) * ae, or = 0; or < $.width * ae; or++) ze[Et + or] = he[gt + or];
+              return y;
+            }
+            var Dv = function(y, I) {
+              Md(this, y, 1, I);
+            };
+            Dv.prototype.resize = function(y) {
+              Bw(this, y, 1);
+            }, Dv.prototype.clone = function() {
+              return new Dv({ width: this.width, height: this.height }, new Uint8Array(this.data));
+            }, Dv.copy = function(y, I, V, $, ae) {
+              Nw(y, I, V, $, ae, 1);
+            };
+            var Eh = function(y, I) {
+              Md(this, y, 4, I);
+            };
+            Eh.prototype.resize = function(y) {
+              Bw(this, y, 4);
+            }, Eh.prototype.replace = function(y, I) {
+              I ? this.data.set(y) : y instanceof Uint8ClampedArray ? this.data = new Uint8Array(y.buffer) : this.data = y;
+            }, Eh.prototype.clone = function() {
+              return new Eh({ width: this.width, height: this.height }, new Uint8Array(this.data));
+            }, Eh.copy = function(y, I, V, $, ae) {
+              Nw(y, I, V, $, ae, 4);
+            }, X("AlphaImage", Dv), X("RGBAImage", Eh);
+            var $x = new Nr({ "heatmap-radius": new bt(Rn.paint_heatmap["heatmap-radius"]), "heatmap-weight": new bt(Rn.paint_heatmap["heatmap-weight"]), "heatmap-intensity": new Me(Rn.paint_heatmap["heatmap-intensity"]), "heatmap-color": new jr(Rn.paint_heatmap["heatmap-color"]), "heatmap-opacity": new Me(Rn.paint_heatmap["heatmap-opacity"]) }), P1 = { paint: $x };
+            function Qx(m) {
+              var y = {}, I = m.resolution || 256, V = m.clips ? m.clips.length : 1, $ = m.image || new Eh({ width: I, height: V }), ae = function(bn, nn, xn) {
+                y[m.evaluationKey] = xn;
+                var Pn = m.expression.evaluate(y);
+                $.data[bn + nn + 0] = Math.floor(Pn.r * 255 / Pn.a), $.data[bn + nn + 1] = Math.floor(Pn.g * 255 / Pn.a), $.data[bn + nn + 2] = Math.floor(Pn.b * 255 / Pn.a), $.data[bn + nn + 3] = Math.floor(Pn.a * 255);
+              };
+              if (m.clips) for (var gt = 0, Et = 0; gt < V; ++gt, Et += I * 4) for (var or = 0, _r = 0; or < I; or++, _r += 4) {
+                var pr = or / (I - 1), Fr = m.clips[gt], oi = Fr.start, Hi = Fr.end, Ai = oi * (1 - pr) + Hi * pr;
+                ae(Et, _r, Ai);
+              }
+              else for (var he = 0, ze = 0; he < I; he++, ze += 4) {
+                var rt = he / (I - 1);
+                ae(0, ze, rt);
+              }
+              return $;
+            }
+            var Uw = function(m) {
+              function y(I) {
+                m.call(this, I, P1), this._updateColorRamp();
+              }
+              return m && (y.__proto__ = m), y.prototype = Object.create(m && m.prototype), y.prototype.constructor = y, y.prototype.createBucket = function(V) {
+                return new cS(V);
+              }, y.prototype._handleSpecialPaintPropertyUpdate = function(V) {
+                V === "heatmap-color" && this._updateColorRamp();
+              }, y.prototype._updateColorRamp = function() {
+                var V = this._transitionablePaint._values["heatmap-color"].value.expression;
+                this.colorRamp = Qx({ expression: V, evaluationKey: "heatmapDensity", image: this.colorRamp }), this.colorRampTexture = null;
+              }, y.prototype.resize = function() {
+                this.heatmapFbo && (this.heatmapFbo.destroy(), this.heatmapFbo = null);
+              }, y.prototype.queryRadius = function() {
+                return 0;
+              }, y.prototype.queryIntersectsFeature = function() {
+                return false;
+              }, y.prototype.hasOffscreenPass = function() {
+                return this.paint.get("heatmap-opacity") !== 0 && this.visibility !== "none";
+              }, y;
+            }(mi), K9 = new Nr({ "hillshade-illumination-direction": new Me(Rn.paint_hillshade["hillshade-illumination-direction"]), "hillshade-illumination-anchor": new Me(Rn.paint_hillshade["hillshade-illumination-anchor"]), "hillshade-exaggeration": new Me(Rn.paint_hillshade["hillshade-exaggeration"]), "hillshade-shadow-color": new Me(Rn.paint_hillshade["hillshade-shadow-color"]), "hillshade-highlight-color": new Me(Rn.paint_hillshade["hillshade-highlight-color"]), "hillshade-accent-color": new Me(Rn.paint_hillshade["hillshade-accent-color"]) }), J9 = { paint: K9 }, kC = function(m) {
+              function y(I) {
+                m.call(this, I, J9);
+              }
+              return m && (y.__proto__ = m), y.prototype = Object.create(m && m.prototype), y.prototype.constructor = y, y.prototype.hasOffscreenPass = function() {
+                return this.paint.get("hillshade-exaggeration") !== 0 && this.visibility !== "none";
+              }, y;
+            }(mi), CC = Wi([{ name: "a_pos", components: 2, type: "Int16" }], 4), $9 = CC.members, Vw = I1, LC = I1;
+            function I1(m, y, I) {
+              I = I || 2;
+              var V = y && y.length, $ = V ? y[0] * I : m.length, ae = Gw(m, 0, $, I, true), he = [];
+              if (!ae || ae.next === ae.prev) return he;
+              var ze, rt, gt, Et, or, _r, pr;
+              if (V && (ae = fm(m, y, ae, I)), m.length > 80 * I) {
+                ze = gt = m[0], rt = Et = m[1];
+                for (var Fr = I; Fr < $; Fr += I) or = m[Fr], _r = m[Fr + 1], or < ze && (ze = or), _r < rt && (rt = _r), or > gt && (gt = or), _r > Et && (Et = _r);
+                pr = Math.max(gt - ze, Et - rt), pr = pr !== 0 ? 1 / pr : 0;
+              }
+              return eb(ae, he, I, ze, rt, pr), he;
+            }
+            function Gw(m, y, I, V, $) {
+              var ae, he;
+              if ($ === mS(m, y, I, V) > 0) for (ae = y; ae < I; ae += V) he = FC(ae, m[ae], m[ae + 1], he);
+              else for (ae = I - V; ae >= y; ae -= V) he = FC(ae, m[ae], m[ae + 1], he);
+              return he && rb(he, he.next) && (ab(he), he = he.next), he;
+            }
+            function cm(m, y) {
+              if (!m) return m;
+              y || (y = m);
+              var I = m, V;
+              do
+                if (V = false, !I.steiner && (rb(I, I.next) || Tf(I.prev, I, I.next) === 0)) {
+                  if (ab(I), I = y = I.prev, I === I.next) break;
+                  V = true;
+                } else I = I.next;
+              while (V || I !== y);
+              return y;
+            }
+            function eb(m, y, I, V, $, ae, he) {
+              if (m) {
+                !he && ae && Hw(m, V, $, ae);
+                for (var ze = m, rt, gt; m.prev !== m.next; ) {
+                  if (rt = m.prev, gt = m.next, ae ? IC(m, V, $, ae) : PC(m)) {
+                    y.push(rt.i / I), y.push(m.i / I), y.push(gt.i / I), ab(m), m = gt.next, ze = gt.next;
+                    continue;
+                  }
+                  if (m = gt, m === ze) {
+                    he ? he === 1 ? (m = tb(cm(m), y, I), eb(m, y, I, V, $, ae, 2)) : he === 2 && v0(m, y, I, V, $, ae) : eb(cm(m), y, I, V, $, ae, 1);
+                    break;
+                  }
+                }
+              }
+            }
+            function PC(m) {
+              var y = m.prev, I = m, V = m.next;
+              if (Tf(y, I, V) >= 0) return false;
+              for (var $ = m.next.next; $ !== m.prev; ) {
+                if (hm(y.x, y.y, I.x, I.y, V.x, V.y, $.x, $.y) && Tf($.prev, $, $.next) >= 0) return false;
+                $ = $.next;
+              }
+              return true;
+            }
+            function IC(m, y, I, V) {
+              var $ = m.prev, ae = m, he = m.next;
+              if (Tf($, ae, he) >= 0) return false;
+              for (var ze = $.x < ae.x ? $.x < he.x ? $.x : he.x : ae.x < he.x ? ae.x : he.x, rt = $.y < ae.y ? $.y < he.y ? $.y : he.y : ae.y < he.y ? ae.y : he.y, gt = $.x > ae.x ? $.x > he.x ? $.x : he.x : ae.x > he.x ? ae.x : he.x, Et = $.y > ae.y ? $.y > he.y ? $.y : he.y : ae.y > he.y ? ae.y : he.y, or = dS(ze, rt, y, I, V), _r = dS(gt, Et, y, I, V), pr = m.prevZ, Fr = m.nextZ; pr && pr.z >= or && Fr && Fr.z <= _r; ) {
+                if (pr !== m.prev && pr !== m.next && hm($.x, $.y, ae.x, ae.y, he.x, he.y, pr.x, pr.y) && Tf(pr.prev, pr, pr.next) >= 0 || (pr = pr.prevZ, Fr !== m.prev && Fr !== m.next && hm($.x, $.y, ae.x, ae.y, he.x, he.y, Fr.x, Fr.y) && Tf(Fr.prev, Fr, Fr.next) >= 0)) return false;
+                Fr = Fr.nextZ;
+              }
+              for (; pr && pr.z >= or; ) {
+                if (pr !== m.prev && pr !== m.next && hm($.x, $.y, ae.x, ae.y, he.x, he.y, pr.x, pr.y) && Tf(pr.prev, pr, pr.next) >= 0) return false;
+                pr = pr.prevZ;
+              }
+              for (; Fr && Fr.z <= _r; ) {
+                if (Fr !== m.prev && Fr !== m.next && hm($.x, $.y, ae.x, ae.y, he.x, he.y, Fr.x, Fr.y) && Tf(Fr.prev, Fr, Fr.next) >= 0) return false;
+                Fr = Fr.nextZ;
+              }
+              return true;
+            }
+            function tb(m, y, I) {
+              var V = m;
+              do {
+                var $ = V.prev, ae = V.next.next;
+                !rb($, ae) && jw($, V, V.next, ae) && nb($, ae) && nb(ae, $) && (y.push($.i / I), y.push(V.i / I), y.push(ae.i / I), ab(V), ab(V.next), V = m = ae), V = V.next;
+              } while (V !== m);
+              return cm(V);
+            }
+            function v0(m, y, I, V, $, ae) {
+              var he = m;
+              do {
+                for (var ze = he.next.next; ze !== he.prev; ) {
+                  if (he.i !== ze.i && R1(he, ze)) {
+                    var rt = pS(he, ze);
+                    he = cm(he, he.next), rt = cm(rt, rt.next), eb(he, y, I, V, $, ae), eb(rt, y, I, V, $, ae);
+                    return;
+                  }
+                  ze = ze.next;
+                }
+                he = he.next;
+              } while (he !== m);
+            }
+            function fm(m, y, I, V) {
+              var $ = [], ae, he, ze, rt, gt;
+              for (ae = 0, he = y.length; ae < he; ae++) ze = y[ae] * V, rt = ae < he - 1 ? y[ae + 1] * V : m.length, gt = Gw(m, ze, rt, V, false), gt === gt.next && (gt.steiner = true), $.push(vS(gt));
+              for ($.sort(RC), ae = 0; ae < $.length; ae++) fS($[ae], I), I = cm(I, I.next);
+              return I;
+            }
+            function RC(m, y) {
+              return m.x - y.x;
+            }
+            function fS(m, y) {
+              if (y = Q9(m, y), y) {
+                var I = pS(y, m);
+                cm(y, y.next), cm(I, I.next);
+              }
+            }
+            function Q9(m, y) {
+              var I = y, V = m.x, $ = m.y, ae = -1 / 0, he;
+              do {
+                if ($ <= I.y && $ >= I.next.y && I.next.y !== I.y) {
+                  var ze = I.x + ($ - I.y) * (I.next.x - I.x) / (I.next.y - I.y);
+                  if (ze <= V && ze > ae) {
+                    if (ae = ze, ze === V) {
+                      if ($ === I.y) return I;
+                      if ($ === I.next.y) return I.next;
+                    }
+                    he = I.x < I.next.x ? I : I.next;
+                  }
+                }
+                I = I.next;
+              } while (I !== y);
+              if (!he) return null;
+              if (V === ae) return he;
+              var rt = he, gt = he.x, Et = he.y, or = 1 / 0, _r;
+              I = he;
+              do
+                V >= I.x && I.x >= gt && V !== I.x && hm($ < Et ? V : ae, $, gt, Et, $ < Et ? ae : V, $, I.x, I.y) && (_r = Math.abs($ - I.y) / (V - I.x), nb(I, m) && (_r < or || _r === or && (I.x > he.x || I.x === he.x && eO(he, I))) && (he = I, or = _r)), I = I.next;
+              while (I !== rt);
+              return he;
+            }
+            function eO(m, y) {
+              return Tf(m.prev, m, y.prev) < 0 && Tf(y.next, m, m.next) < 0;
+            }
+            function Hw(m, y, I, V) {
+              var $ = m;
+              do
+                $.z === null && ($.z = dS($.x, $.y, y, I, V)), $.prevZ = $.prev, $.nextZ = $.next, $ = $.next;
+              while ($ !== m);
+              $.prevZ.nextZ = null, $.prevZ = null, hS($);
+            }
+            function hS(m) {
+              var y, I, V, $, ae, he, ze, rt, gt = 1;
+              do {
+                for (I = m, m = null, ae = null, he = 0; I; ) {
+                  for (he++, V = I, ze = 0, y = 0; y < gt && (ze++, V = V.nextZ, !!V); y++) ;
+                  for (rt = gt; ze > 0 || rt > 0 && V; ) ze !== 0 && (rt === 0 || !V || I.z <= V.z) ? ($ = I, I = I.nextZ, ze--) : ($ = V, V = V.nextZ, rt--), ae ? ae.nextZ = $ : m = $, $.prevZ = ae, ae = $;
+                  I = V;
+                }
+                ae.nextZ = null, gt *= 2;
+              } while (he > 1);
+              return m;
+            }
+            function dS(m, y, I, V, $) {
+              return m = 32767 * (m - I) * $, y = 32767 * (y - V) * $, m = (m | m << 8) & 16711935, m = (m | m << 4) & 252645135, m = (m | m << 2) & 858993459, m = (m | m << 1) & 1431655765, y = (y | y << 8) & 16711935, y = (y | y << 4) & 252645135, y = (y | y << 2) & 858993459, y = (y | y << 1) & 1431655765, m | y << 1;
+            }
+            function vS(m) {
+              var y = m, I = m;
+              do
+                (y.x < I.x || y.x === I.x && y.y < I.y) && (I = y), y = y.next;
+              while (y !== m);
+              return I;
+            }
+            function hm(m, y, I, V, $, ae, he, ze) {
+              return ($ - he) * (y - ze) - (m - he) * (ae - ze) >= 0 && (m - he) * (V - ze) - (I - he) * (y - ze) >= 0 && (I - he) * (ae - ze) - ($ - he) * (V - ze) >= 0;
+            }
+            function R1(m, y) {
+              return m.next.i !== y.i && m.prev.i !== y.i && !DC(m, y) && (nb(m, y) && nb(y, m) && tO(m, y) && (Tf(m.prev, m, y.prev) || Tf(m, y.prev, y)) || rb(m, y) && Tf(m.prev, m, m.next) > 0 && Tf(y.prev, y, y.next) > 0);
+            }
+            function Tf(m, y, I) {
+              return (y.y - m.y) * (I.x - y.x) - (y.x - m.x) * (I.y - y.y);
+            }
+            function rb(m, y) {
+              return m.x === y.x && m.y === y.y;
+            }
+            function jw(m, y, I, V) {
+              var $ = gy(Tf(m, y, I)), ae = gy(Tf(m, y, V)), he = gy(Tf(I, V, m)), ze = gy(Tf(I, V, y));
+              return !!($ !== ae && he !== ze || $ === 0 && ib(m, I, y) || ae === 0 && ib(m, V, y) || he === 0 && ib(I, m, V) || ze === 0 && ib(I, y, V));
+            }
+            function ib(m, y, I) {
+              return y.x <= Math.max(m.x, I.x) && y.x >= Math.min(m.x, I.x) && y.y <= Math.max(m.y, I.y) && y.y >= Math.min(m.y, I.y);
+            }
+            function gy(m) {
+              return m > 0 ? 1 : m < 0 ? -1 : 0;
+            }
+            function DC(m, y) {
+              var I = m;
+              do {
+                if (I.i !== m.i && I.next.i !== m.i && I.i !== y.i && I.next.i !== y.i && jw(I, I.next, m, y)) return true;
+                I = I.next;
+              } while (I !== m);
+              return false;
+            }
+            function nb(m, y) {
+              return Tf(m.prev, m, m.next) < 0 ? Tf(m, y, m.next) >= 0 && Tf(m, m.prev, y) >= 0 : Tf(m, y, m.prev) < 0 || Tf(m, m.next, y) < 0;
+            }
+            function tO(m, y) {
+              var I = m, V = false, $ = (m.x + y.x) / 2, ae = (m.y + y.y) / 2;
+              do
+                I.y > ae != I.next.y > ae && I.next.y !== I.y && $ < (I.next.x - I.x) * (ae - I.y) / (I.next.y - I.y) + I.x && (V = !V), I = I.next;
+              while (I !== m);
+              return V;
+            }
+            function pS(m, y) {
+              var I = new gS(m.i, m.x, m.y), V = new gS(y.i, y.x, y.y), $ = m.next, ae = y.prev;
+              return m.next = y, y.prev = m, I.next = $, $.prev = I, V.next = I, I.prev = V, ae.next = V, V.prev = ae, V;
+            }
+            function FC(m, y, I, V) {
+              var $ = new gS(m, y, I);
+              return V ? ($.next = V.next, $.prev = V, V.next.prev = $, V.next = $) : ($.prev = $, $.next = $), $;
+            }
+            function ab(m) {
+              m.next.prev = m.prev, m.prev.next = m.next, m.prevZ && (m.prevZ.nextZ = m.nextZ), m.nextZ && (m.nextZ.prevZ = m.prevZ);
+            }
+            function gS(m, y, I) {
+              this.i = m, this.x = y, this.y = I, this.prev = null, this.next = null, this.z = null, this.prevZ = null, this.nextZ = null, this.steiner = false;
+            }
+            I1.deviation = function(m, y, I, V) {
+              var $ = y && y.length, ae = $ ? y[0] * I : m.length, he = Math.abs(mS(m, 0, ae, I));
+              if ($) for (var ze = 0, rt = y.length; ze < rt; ze++) {
+                var gt = y[ze] * I, Et = ze < rt - 1 ? y[ze + 1] * I : m.length;
+                he -= Math.abs(mS(m, gt, Et, I));
+              }
+              var or = 0;
+              for (ze = 0; ze < V.length; ze += 3) {
+                var _r = V[ze] * I, pr = V[ze + 1] * I, Fr = V[ze + 2] * I;
+                or += Math.abs((m[_r] - m[Fr]) * (m[pr + 1] - m[_r + 1]) - (m[_r] - m[pr]) * (m[Fr + 1] - m[_r + 1]));
+              }
+              return he === 0 && or === 0 ? 0 : Math.abs((or - he) / he);
+            };
+            function mS(m, y, I, V) {
+              for (var $ = 0, ae = y, he = I - V; ae < I; ae += V) $ += (m[he] - m[ae]) * (m[ae + 1] + m[he + 1]), he = ae;
+              return $;
+            }
+            I1.flatten = function(m) {
+              for (var y = m[0][0].length, I = { vertices: [], holes: [], dimensions: y }, V = 0, $ = 0; $ < m.length; $++) {
+                for (var ae = 0; ae < m[$].length; ae++) for (var he = 0; he < y; he++) I.vertices.push(m[$][ae][he]);
+                $ > 0 && (V += m[$ - 1].length, I.holes.push(V));
+              }
+              return I;
+            }, Vw.default = LC;
+            function yS(m, y, I, V, $) {
+              pg(m, y, I, V || m.length - 1, $ || zC);
+            }
+            function pg(m, y, I, V, $) {
+              for (; V > I; ) {
+                if (V - I > 600) {
+                  var ae = V - I + 1, he = y - I + 1, ze = Math.log(ae), rt = 0.5 * Math.exp(2 * ze / 3), gt = 0.5 * Math.sqrt(ze * rt * (ae - rt) / ae) * (he - ae / 2 < 0 ? -1 : 1), Et = Math.max(I, Math.floor(y - he * rt / ae + gt)), or = Math.min(V, Math.floor(y + (ae - he) * rt / ae + gt));
+                  pg(m, y, Et, or, $);
+                }
+                var _r = m[y], pr = I, Fr = V;
+                for (D1(m, I, y), $(m[V], _r) > 0 && D1(m, I, V); pr < Fr; ) {
+                  for (D1(m, pr, Fr), pr++, Fr--; $(m[pr], _r) < 0; ) pr++;
+                  for (; $(m[Fr], _r) > 0; ) Fr--;
+                }
+                $(m[I], _r) === 0 ? D1(m, I, Fr) : (Fr++, D1(m, Fr, V)), Fr <= y && (I = Fr + 1), y <= Fr && (V = Fr - 1);
+              }
+            }
+            function D1(m, y, I) {
+              var V = m[y];
+              m[y] = m[I], m[I] = V;
+            }
+            function zC(m, y) {
+              return m < y ? -1 : m > y ? 1 : 0;
+            }
+            function Ww(m, y) {
+              var I = m.length;
+              if (I <= 1) return [m];
+              for (var V = [], $, ae, he = 0; he < I; he++) {
+                var ze = _e(m[he]);
+                ze !== 0 && (m[he].area = Math.abs(ze), ae === void 0 && (ae = ze < 0), ae === ze < 0 ? ($ && V.push($), $ = [m[he]]) : $.push(m[he]));
+              }
+              if ($ && V.push($), y > 1) for (var rt = 0; rt < V.length; rt++) V[rt].length <= y || (yS(V[rt], y, 1, V[rt].length - 1, OC), V[rt] = V[rt].slice(0, y));
+              return V;
+            }
+            function OC(m, y) {
+              return y.area - m.area;
+            }
+            function Xw(m, y, I) {
+              for (var V = I.patternDependencies, $ = false, ae = 0, he = y; ae < he.length; ae += 1) {
+                var ze = he[ae], rt = ze.paint.get(m + "-pattern");
+                rt.isConstant() || ($ = true);
+                var gt = rt.constantOr(null);
+                gt && ($ = true, V[gt.to] = true, V[gt.from] = true);
+              }
+              return $;
+            }
+            function ob(m, y, I, V, $) {
+              for (var ae = $.patternDependencies, he = 0, ze = y; he < ze.length; he += 1) {
+                var rt = ze[he], gt = rt.paint.get(m + "-pattern"), Et = gt.value;
+                if (Et.kind !== "constant") {
+                  var or = Et.evaluate({ zoom: V - 1 }, I, {}, $.availableImages), _r = Et.evaluate({ zoom: V }, I, {}, $.availableImages), pr = Et.evaluate({ zoom: V + 1 }, I, {}, $.availableImages);
+                  or = or && or.name ? or.name : or, _r = _r && _r.name ? _r.name : _r, pr = pr && pr.name ? pr.name : pr, ae[or] = true, ae[_r] = true, ae[pr] = true, I.patterns[rt.id] = { min: or, mid: _r, max: pr };
+                }
+              }
+              return I;
+            }
+            var sb = 500, yp = function(y) {
+              this.zoom = y.zoom, this.overscaling = y.overscaling, this.layers = y.layers, this.layerIds = this.layers.map(function(I) {
+                return I.id;
+              }), this.index = y.index, this.hasPattern = false, this.patternFeatures = [], this.layoutVertexArray = new Yr(), this.indexArray = new pn(), this.indexArray2 = new oa(), this.programConfigurations = new fi(y.layers, y.zoom), this.segments = new io(), this.segments2 = new io(), this.stateDependentLayerIds = this.layers.filter(function(I) {
+                return I.isStateDependent();
+              }).map(function(I) {
+                return I.id;
+              });
+            };
+            yp.prototype.populate = function(y, I, V) {
+              this.hasPattern = Xw("fill", this.layers, I);
+              for (var $ = this.layers[0].layout.get("fill-sort-key"), ae = [], he = 0, ze = y; he < ze.length; he += 1) {
+                var rt = ze[he], gt = rt.feature, Et = rt.id, or = rt.index, _r = rt.sourceLayerIndex, pr = this.layers[0]._featureFilter.needGeometry, Fr = Ja(gt, pr);
+                if (this.layers[0]._featureFilter.filter(new Gn(this.zoom), Fr, V)) {
+                  var oi = $ ? $.evaluate(Fr, {}, V, I.availableImages) : void 0, Hi = { id: Et, properties: gt.properties, type: gt.type, sourceLayerIndex: _r, index: or, geometry: pr ? Fr.geometry : zn(gt), patterns: {}, sortKey: oi };
+                  ae.push(Hi);
+                }
+              }
+              $ && ae.sort(function(za, Za) {
+                return za.sortKey - Za.sortKey;
+              });
+              for (var Ai = 0, bn = ae; Ai < bn.length; Ai += 1) {
+                var nn = bn[Ai], xn = nn, Pn = xn.geometry, Zn = xn.index, ga = xn.sourceLayerIndex;
+                if (this.hasPattern) {
+                  var ha = ob("fill", this.layers, nn, this.zoom, I);
+                  this.patternFeatures.push(ha);
+                } else this.addFeature(nn, Pn, Zn, V, {});
+                var eo = y[Zn].feature;
+                I.featureIndex.insert(eo, Pn, Zn, ga, this.index);
+              }
+            }, yp.prototype.update = function(y, I, V) {
+              this.stateDependentLayers.length && this.programConfigurations.updatePaintArrays(y, I, this.stateDependentLayers, V);
+            }, yp.prototype.addFeatures = function(y, I, V) {
+              for (var $ = 0, ae = this.patternFeatures; $ < ae.length; $ += 1) {
+                var he = ae[$];
+                this.addFeature(he, he.geometry, he.index, I, V);
+              }
+            }, yp.prototype.isEmpty = function() {
+              return this.layoutVertexArray.length === 0;
+            }, yp.prototype.uploadPending = function() {
+              return !this.uploaded || this.programConfigurations.needsUpload;
+            }, yp.prototype.upload = function(y) {
+              this.uploaded || (this.layoutVertexBuffer = y.createVertexBuffer(this.layoutVertexArray, $9), this.indexBuffer = y.createIndexBuffer(this.indexArray), this.indexBuffer2 = y.createIndexBuffer(this.indexArray2)), this.programConfigurations.upload(y), this.uploaded = true;
+            }, yp.prototype.destroy = function() {
+              this.layoutVertexBuffer && (this.layoutVertexBuffer.destroy(), this.indexBuffer.destroy(), this.indexBuffer2.destroy(), this.programConfigurations.destroy(), this.segments.destroy(), this.segments2.destroy());
+            }, yp.prototype.addFeature = function(y, I, V, $, ae) {
+              for (var he = 0, ze = Ww(I, sb); he < ze.length; he += 1) {
+                for (var rt = ze[he], gt = 0, Et = 0, or = rt; Et < or.length; Et += 1) {
+                  var _r = or[Et];
+                  gt += _r.length;
+                }
+                for (var pr = this.segments.prepareSegment(gt, this.layoutVertexArray, this.indexArray), Fr = pr.vertexLength, oi = [], Hi = [], Ai = 0, bn = rt; Ai < bn.length; Ai += 1) {
+                  var nn = bn[Ai];
+                  if (nn.length !== 0) {
+                    nn !== rt[0] && Hi.push(oi.length / 2);
+                    var xn = this.segments2.prepareSegment(nn.length, this.layoutVertexArray, this.indexArray2), Pn = xn.vertexLength;
+                    this.layoutVertexArray.emplaceBack(nn[0].x, nn[0].y), this.indexArray2.emplaceBack(Pn + nn.length - 1, Pn), oi.push(nn[0].x), oi.push(nn[0].y);
+                    for (var Zn = 1; Zn < nn.length; Zn++) this.layoutVertexArray.emplaceBack(nn[Zn].x, nn[Zn].y), this.indexArray2.emplaceBack(Pn + Zn - 1, Pn + Zn), oi.push(nn[Zn].x), oi.push(nn[Zn].y);
+                    xn.vertexLength += nn.length, xn.primitiveLength += nn.length;
+                  }
+                }
+                for (var ga = Vw(oi, Hi), ha = 0; ha < ga.length; ha += 3) this.indexArray.emplaceBack(Fr + ga[ha], Fr + ga[ha + 1], Fr + ga[ha + 2]);
+                pr.vertexLength += gt, pr.primitiveLength += ga.length / 3;
+              }
+              this.programConfigurations.populatePaintArrays(this.layoutVertexArray.length, y, V, ae, $);
+            }, X("FillBucket", yp, { omit: ["layers", "patternFeatures"] });
+            var _S = new Nr({ "fill-sort-key": new bt(Rn.layout_fill["fill-sort-key"]) }), qC = new Nr({ "fill-antialias": new Me(Rn.paint_fill["fill-antialias"]), "fill-opacity": new bt(Rn.paint_fill["fill-opacity"]), "fill-color": new bt(Rn.paint_fill["fill-color"]), "fill-outline-color": new bt(Rn.paint_fill["fill-outline-color"]), "fill-translate": new Me(Rn.paint_fill["fill-translate"]), "fill-translate-anchor": new Me(Rn.paint_fill["fill-translate-anchor"]), "fill-pattern": new zt(Rn.paint_fill["fill-pattern"]) }), $v = { paint: qC, layout: _S }, lb = function(m) {
+              function y(I) {
+                m.call(this, I, $v);
+              }
+              return m && (y.__proto__ = m), y.prototype = Object.create(m && m.prototype), y.prototype.constructor = y, y.prototype.recalculate = function(V, $) {
+                m.prototype.recalculate.call(this, V, $);
+                var ae = this.paint._values["fill-outline-color"];
+                ae.value.kind === "constant" && ae.value.value === void 0 && (this.paint._values["fill-outline-color"] = this.paint._values["fill-color"]);
+              }, y.prototype.createBucket = function(V) {
+                return new yp(V);
+              }, y.prototype.queryRadius = function() {
+                return Pv(this.paint.get("fill-translate"));
+              }, y.prototype.queryIntersectsFeature = function(V, $, ae, he, ze, rt, gt) {
+                var Et = Jv(V, this.paint.get("fill-translate"), this.paint.get("fill-translate-anchor"), rt.angle, gt);
+                return ms(Et, he);
+              }, y.prototype.isTileClipped = function() {
+                return true;
+              }, y;
+            }(mi), BC = Wi([{ name: "a_pos", components: 2, type: "Int16" }, { name: "a_normal_ed", components: 4, type: "Int16" }], 4), NC = BC.members, xS = my;
+            function my(m, y, I, V, $) {
+              this.properties = {}, this.extent = I, this.type = 0, this._pbf = m, this._geometry = -1, this._keys = V, this._values = $, m.readFields(UC, this, y);
+            }
+            function UC(m, y, I) {
+              m == 1 ? y.id = I.readVarint() : m == 2 ? VC(I, y) : m == 3 ? y.type = I.readVarint() : m == 4 && (y._geometry = I.pos);
+            }
+            function VC(m, y) {
+              for (var I = m.readVarint() + m.pos; m.pos < I; ) {
+                var V = y._keys[m.readVarint()], $ = y._values[m.readVarint()];
+                y.properties[V] = $;
+              }
+            }
+            my.types = ["Unknown", "Point", "LineString", "Polygon"], my.prototype.loadGeometry = function() {
+              var m = this._pbf;
+              m.pos = this._geometry;
+              for (var y = m.readVarint() + m.pos, I = 1, V = 0, $ = 0, ae = 0, he = [], ze; m.pos < y; ) {
+                if (V <= 0) {
+                  var rt = m.readVarint();
+                  I = rt & 7, V = rt >> 3;
+                }
+                if (V--, I === 1 || I === 2) $ += m.readSVarint(), ae += m.readSVarint(), I === 1 && (ze && he.push(ze), ze = []), ze.push(new u($, ae));
+                else if (I === 7) ze && ze.push(ze[0].clone());
+                else throw new Error("unknown command " + I);
+              }
+              return ze && he.push(ze), he;
+            }, my.prototype.bbox = function() {
+              var m = this._pbf;
+              m.pos = this._geometry;
+              for (var y = m.readVarint() + m.pos, I = 1, V = 0, $ = 0, ae = 0, he = 1 / 0, ze = -1 / 0, rt = 1 / 0, gt = -1 / 0; m.pos < y; ) {
+                if (V <= 0) {
+                  var Et = m.readVarint();
+                  I = Et & 7, V = Et >> 3;
+                }
+                if (V--, I === 1 || I === 2) $ += m.readSVarint(), ae += m.readSVarint(), $ < he && (he = $), $ > ze && (ze = $), ae < rt && (rt = ae), ae > gt && (gt = ae);
+                else if (I !== 7) throw new Error("unknown command " + I);
+              }
+              return [he, rt, ze, gt];
+            }, my.prototype.toGeoJSON = function(m, y, I) {
+              var V = this.extent * Math.pow(2, I), $ = this.extent * m, ae = this.extent * y, he = this.loadGeometry(), ze = my.types[this.type], rt, gt;
+              function Et(pr) {
+                for (var Fr = 0; Fr < pr.length; Fr++) {
+                  var oi = pr[Fr], Hi = 180 - (oi.y + ae) * 360 / V;
+                  pr[Fr] = [(oi.x + $) * 360 / V - 180, 360 / Math.PI * Math.atan(Math.exp(Hi * Math.PI / 180)) - 90];
+                }
+              }
+              switch (this.type) {
+                case 1:
+                  var or = [];
+                  for (rt = 0; rt < he.length; rt++) or[rt] = he[rt][0];
+                  he = or, Et(he);
+                  break;
+                case 2:
+                  for (rt = 0; rt < he.length; rt++) Et(he[rt]);
+                  break;
+                case 3:
+                  for (he = rO(he), rt = 0; rt < he.length; rt++) for (gt = 0; gt < he[rt].length; gt++) Et(he[rt][gt]);
+                  break;
+              }
+              he.length === 1 ? he = he[0] : ze = "Multi" + ze;
+              var _r = { type: "Feature", geometry: { type: ze, coordinates: he }, properties: this.properties };
+              return "id" in this && (_r.id = this.id), _r;
+            };
+            function rO(m) {
+              var y = m.length;
+              if (y <= 1) return [m];
+              for (var I = [], V, $, ae = 0; ae < y; ae++) {
+                var he = GC(m[ae]);
+                he !== 0 && ($ === void 0 && ($ = he < 0), $ === he < 0 ? (V && I.push(V), V = [m[ae]]) : V.push(m[ae]));
+              }
+              return V && I.push(V), I;
+            }
+            function GC(m) {
+              for (var y = 0, I = 0, V = m.length, $ = V - 1, ae, he; I < V; $ = I++) ae = m[I], he = m[$], y += (he.x - ae.x) * (ae.y + he.y);
+              return y;
+            }
+            var gg = bS;
+            function bS(m, y) {
+              this.version = 1, this.name = null, this.extent = 4096, this.length = 0, this._pbf = m, this._keys = [], this._values = [], this._features = [], m.readFields(HC, this, y), this.length = this._features.length;
+            }
+            function HC(m, y, I) {
+              m === 15 ? y.version = I.readVarint() : m === 1 ? y.name = I.readString() : m === 5 ? y.extent = I.readVarint() : m === 2 ? y._features.push(I.pos) : m === 3 ? y._keys.push(I.readString()) : m === 4 && y._values.push(jC(I));
+            }
+            function jC(m) {
+              for (var y = null, I = m.readVarint() + m.pos; m.pos < I; ) {
+                var V = m.readVarint() >> 3;
+                y = V === 1 ? m.readString() : V === 2 ? m.readFloat() : V === 3 ? m.readDouble() : V === 4 ? m.readVarint64() : V === 5 ? m.readVarint() : V === 6 ? m.readSVarint() : V === 7 ? m.readBoolean() : null;
+              }
+              return y;
+            }
+            bS.prototype.feature = function(m) {
+              if (m < 0 || m >= this._features.length) throw new Error("feature index out of bounds");
+              this._pbf.pos = this._features[m];
+              var y = this._pbf.readVarint() + this._pbf.pos;
+              return new xS(this._pbf, y, this.extent, this._keys, this._values);
+            };
+            var WC = iO;
+            function iO(m, y) {
+              this.layers = m.readFields(nO, {}, y);
+            }
+            function nO(m, y, I) {
+              if (m === 3) {
+                var V = new gg(I, I.readVarint() + I.pos);
+                V.length && (y[V.name] = V);
+              }
+            }
+            var XC = WC, F1 = xS, ZC = gg, mg = { VectorTile: XC, VectorTileFeature: F1, VectorTileLayer: ZC }, YC = mg.VectorTileFeature.types, Zw = 500, z1 = Math.pow(2, 13);
+            function dm(m, y, I, V, $, ae, he, ze) {
+              m.emplaceBack(y, I, Math.floor(V * z1) * 2 + he, $ * z1 * 2, ae * z1 * 2, Math.round(ze));
+            }
+            var Vp = function(y) {
+              this.zoom = y.zoom, this.overscaling = y.overscaling, this.layers = y.layers, this.layerIds = this.layers.map(function(I) {
+                return I.id;
+              }), this.index = y.index, this.hasPattern = false, this.layoutVertexArray = new Ri(), this.indexArray = new pn(), this.programConfigurations = new fi(y.layers, y.zoom), this.segments = new io(), this.stateDependentLayerIds = this.layers.filter(function(I) {
+                return I.isStateDependent();
+              }).map(function(I) {
+                return I.id;
+              });
+            };
+            Vp.prototype.populate = function(y, I, V) {
+              this.features = [], this.hasPattern = Xw("fill-extrusion", this.layers, I);
+              for (var $ = 0, ae = y; $ < ae.length; $ += 1) {
+                var he = ae[$], ze = he.feature, rt = he.id, gt = he.index, Et = he.sourceLayerIndex, or = this.layers[0]._featureFilter.needGeometry, _r = Ja(ze, or);
+                if (this.layers[0]._featureFilter.filter(new Gn(this.zoom), _r, V)) {
+                  var pr = { id: rt, sourceLayerIndex: Et, index: gt, geometry: or ? _r.geometry : zn(ze), properties: ze.properties, type: ze.type, patterns: {} };
+                  this.hasPattern ? this.features.push(ob("fill-extrusion", this.layers, pr, this.zoom, I)) : this.addFeature(pr, pr.geometry, gt, V, {}), I.featureIndex.insert(ze, pr.geometry, gt, Et, this.index, true);
+                }
+              }
+            }, Vp.prototype.addFeatures = function(y, I, V) {
+              for (var $ = 0, ae = this.features; $ < ae.length; $ += 1) {
+                var he = ae[$], ze = he.geometry;
+                this.addFeature(he, ze, he.index, I, V);
+              }
+            }, Vp.prototype.update = function(y, I, V) {
+              this.stateDependentLayers.length && this.programConfigurations.updatePaintArrays(y, I, this.stateDependentLayers, V);
+            }, Vp.prototype.isEmpty = function() {
+              return this.layoutVertexArray.length === 0;
+            }, Vp.prototype.uploadPending = function() {
+              return !this.uploaded || this.programConfigurations.needsUpload;
+            }, Vp.prototype.upload = function(y) {
+              this.uploaded || (this.layoutVertexBuffer = y.createVertexBuffer(this.layoutVertexArray, NC), this.indexBuffer = y.createIndexBuffer(this.indexArray)), this.programConfigurations.upload(y), this.uploaded = true;
+            }, Vp.prototype.destroy = function() {
+              this.layoutVertexBuffer && (this.layoutVertexBuffer.destroy(), this.indexBuffer.destroy(), this.programConfigurations.destroy(), this.segments.destroy());
+            }, Vp.prototype.addFeature = function(y, I, V, $, ae) {
+              for (var he = 0, ze = Ww(I, Zw); he < ze.length; he += 1) {
+                for (var rt = ze[he], gt = 0, Et = 0, or = rt; Et < or.length; Et += 1) {
+                  var _r = or[Et];
+                  gt += _r.length;
+                }
+                for (var pr = this.segments.prepareSegment(4, this.layoutVertexArray, this.indexArray), Fr = 0, oi = rt; Fr < oi.length; Fr += 1) {
+                  var Hi = oi[Fr];
+                  if (Hi.length !== 0 && !oO(Hi)) for (var Ai = 0, bn = 0; bn < Hi.length; bn++) {
+                    var nn = Hi[bn];
+                    if (bn >= 1) {
+                      var xn = Hi[bn - 1];
+                      if (!aO(nn, xn)) {
+                        pr.vertexLength + 4 > io.MAX_VERTEX_ARRAY_LENGTH && (pr = this.segments.prepareSegment(4, this.layoutVertexArray, this.indexArray));
+                        var Pn = nn.sub(xn)._perp()._unit(), Zn = xn.dist(nn);
+                        Ai + Zn > 32768 && (Ai = 0), dm(this.layoutVertexArray, nn.x, nn.y, Pn.x, Pn.y, 0, 0, Ai), dm(this.layoutVertexArray, nn.x, nn.y, Pn.x, Pn.y, 0, 1, Ai), Ai += Zn, dm(this.layoutVertexArray, xn.x, xn.y, Pn.x, Pn.y, 0, 0, Ai), dm(this.layoutVertexArray, xn.x, xn.y, Pn.x, Pn.y, 0, 1, Ai);
+                        var ga = pr.vertexLength;
+                        this.indexArray.emplaceBack(ga, ga + 2, ga + 1), this.indexArray.emplaceBack(ga + 1, ga + 2, ga + 3), pr.vertexLength += 4, pr.primitiveLength += 2;
+                      }
+                    }
+                  }
+                }
+                if (pr.vertexLength + gt > io.MAX_VERTEX_ARRAY_LENGTH && (pr = this.segments.prepareSegment(gt, this.layoutVertexArray, this.indexArray)), YC[y.type] === "Polygon") {
+                  for (var ha = [], eo = [], za = pr.vertexLength, Za = 0, Jo = rt; Za < Jo.length; Za += 1) {
+                    var to = Jo[Za];
+                    if (to.length !== 0) {
+                      to !== rt[0] && eo.push(ha.length / 2);
+                      for (var ao = 0; ao < to.length; ao++) {
+                        var _s = to[ao];
+                        dm(this.layoutVertexArray, _s.x, _s.y, 0, 0, 1, 1, 0), ha.push(_s.x), ha.push(_s.y);
+                      }
+                    }
+                  }
+                  for (var jo = Vw(ha, eo), El = 0; El < jo.length; El += 3) this.indexArray.emplaceBack(za + jo[El], za + jo[El + 2], za + jo[El + 1]);
+                  pr.primitiveLength += jo.length / 3, pr.vertexLength += gt;
+                }
+              }
+              this.programConfigurations.populatePaintArrays(this.layoutVertexArray.length, y, V, ae, $);
+            }, X("FillExtrusionBucket", Vp, { omit: ["layers", "features"] });
+            function aO(m, y) {
+              return m.x === y.x && (m.x < 0 || m.x > Ci) || m.y === y.y && (m.y < 0 || m.y > Ci);
+            }
+            function oO(m) {
+              return m.every(function(y) {
+                return y.x < 0;
+              }) || m.every(function(y) {
+                return y.x > Ci;
+              }) || m.every(function(y) {
+                return y.y < 0;
+              }) || m.every(function(y) {
+                return y.y > Ci;
+              });
+            }
+            var O1 = new Nr({ "fill-extrusion-opacity": new Me(Rn["paint_fill-extrusion"]["fill-extrusion-opacity"]), "fill-extrusion-color": new bt(Rn["paint_fill-extrusion"]["fill-extrusion-color"]), "fill-extrusion-translate": new Me(Rn["paint_fill-extrusion"]["fill-extrusion-translate"]), "fill-extrusion-translate-anchor": new Me(Rn["paint_fill-extrusion"]["fill-extrusion-translate-anchor"]), "fill-extrusion-pattern": new zt(Rn["paint_fill-extrusion"]["fill-extrusion-pattern"]), "fill-extrusion-height": new bt(Rn["paint_fill-extrusion"]["fill-extrusion-height"]), "fill-extrusion-base": new bt(Rn["paint_fill-extrusion"]["fill-extrusion-base"]), "fill-extrusion-vertical-gradient": new Me(Rn["paint_fill-extrusion"]["fill-extrusion-vertical-gradient"]) }), ld = { paint: O1 }, vm = function(m) {
+              function y(I) {
+                m.call(this, I, ld);
+              }
+              return m && (y.__proto__ = m), y.prototype = Object.create(m && m.prototype), y.prototype.constructor = y, y.prototype.createBucket = function(V) {
+                return new Vp(V);
+              }, y.prototype.queryRadius = function() {
+                return Pv(this.paint.get("fill-extrusion-translate"));
+              }, y.prototype.is3D = function() {
+                return true;
+              }, y.prototype.queryIntersectsFeature = function(V, $, ae, he, ze, rt, gt, Et) {
+                var or = Jv(V, this.paint.get("fill-extrusion-translate"), this.paint.get("fill-extrusion-translate-anchor"), rt.angle, gt), _r = this.paint.get("fill-extrusion-height").evaluate($, ae), pr = this.paint.get("fill-extrusion-base").evaluate($, ae), Fr = sO(or, Et, rt, 0), oi = TS(he, pr, _r, Et), Hi = oi[0], Ai = oi[1];
+                return KC(Hi, Ai, Fr);
+              }, y;
+            }(mi);
+            function yy(m, y) {
+              return m.x * y.x + m.y * y.y;
+            }
+            function wS(m, y) {
+              if (m.length === 1) {
+                for (var I = 0, V = y[I++], $; !$ || V.equals($); ) if ($ = y[I++], !$) return 1 / 0;
+                for (; I < y.length; I++) {
+                  var ae = y[I], he = m[0], ze = $.sub(V), rt = ae.sub(V), gt = he.sub(V), Et = yy(ze, ze), or = yy(ze, rt), _r = yy(rt, rt), pr = yy(gt, ze), Fr = yy(gt, rt), oi = Et * _r - or * or, Hi = (_r * pr - or * Fr) / oi, Ai = (Et * Fr - or * pr) / oi, bn = 1 - Hi - Ai, nn = V.z * bn + $.z * Hi + ae.z * Ai;
+                  if (isFinite(nn)) return nn;
+                }
+                return 1 / 0;
+              } else {
+                for (var xn = 1 / 0, Pn = 0, Zn = y; Pn < Zn.length; Pn += 1) {
+                  var ga = Zn[Pn];
+                  xn = Math.min(xn, ga.z);
+                }
+                return xn;
+              }
+            }
+            function KC(m, y, I) {
+              var V = 1 / 0;
+              ms(I, y) && (V = wS(I, y[0]));
+              for (var $ = 0; $ < y.length; $++) for (var ae = y[$], he = m[$], ze = 0; ze < ae.length - 1; ze++) {
+                var rt = ae[ze], gt = ae[ze + 1], Et = he[ze], or = he[ze + 1], _r = [rt, gt, or, Et, rt];
+                so(I, _r) && (V = Math.min(V, wS(I, _r)));
+              }
+              return V === 1 / 0 ? false : V;
+            }
+            function TS(m, y, I, V) {
+              for (var $ = [], ae = [], he = V[8] * y, ze = V[9] * y, rt = V[10] * y, gt = V[11] * y, Et = V[8] * I, or = V[9] * I, _r = V[10] * I, pr = V[11] * I, Fr = 0, oi = m; Fr < oi.length; Fr += 1) {
+                for (var Hi = oi[Fr], Ai = [], bn = [], nn = 0, xn = Hi; nn < xn.length; nn += 1) {
+                  var Pn = xn[nn], Zn = Pn.x, ga = Pn.y, ha = V[0] * Zn + V[4] * ga + V[12], eo = V[1] * Zn + V[5] * ga + V[13], za = V[2] * Zn + V[6] * ga + V[14], Za = V[3] * Zn + V[7] * ga + V[15], Jo = ha + he, to = eo + ze, ao = za + rt, _s = Za + gt, jo = ha + Et, El = eo + or, Iu = za + _r, kl = Za + pr, Cl = new u(Jo / _s, to / _s);
+                  Cl.z = ao / _s, Ai.push(Cl);
+                  var yl = new u(jo / kl, El / kl);
+                  yl.z = Iu / kl, bn.push(yl);
+                }
+                $.push(Ai), ae.push(bn);
+              }
+              return [$, ae];
+            }
+            function sO(m, y, I, V) {
+              for (var $ = [], ae = 0, he = m; ae < he.length; ae += 1) {
+                var ze = he[ae], rt = [ze.x, ze.y, V, 1];
+                py(rt, rt, y), $.push(new u(rt[0] / rt[3], rt[1] / rt[3]));
+              }
+              return $;
+            }
+            var JC = Wi([{ name: "a_pos_normal", components: 2, type: "Int16" }, { name: "a_data", components: 4, type: "Uint8" }], 4), $C = JC.members, lO = Wi([{ name: "a_uv_x", components: 1, type: "Float32" }, { name: "a_split_index", components: 1, type: "Float32" }]), QC = lO.members, AS = mg.VectorTileFeature.types, Yw = 63, e6 = Math.cos(75 / 2 * (Math.PI / 180)), ub = 15, SS = 20, t6 = 15, Kw = 1 / 2, cb = Math.pow(2, t6 - 1) / Kw, sh = function(y) {
+              var I = this;
+              this.zoom = y.zoom, this.overscaling = y.overscaling, this.layers = y.layers, this.layerIds = this.layers.map(function(V) {
+                return V.id;
+              }), this.index = y.index, this.hasPattern = false, this.patternFeatures = [], this.lineClipsArray = [], this.gradients = {}, this.layers.forEach(function(V) {
+                I.gradients[V.id] = {};
+              }), this.layoutVertexArray = new ci(), this.layoutVertexArray2 = new an(), this.indexArray = new pn(), this.programConfigurations = new fi(y.layers, y.zoom), this.segments = new io(), this.maxLineLength = 0, this.stateDependentLayerIds = this.layers.filter(function(V) {
+                return V.isStateDependent();
+              }).map(function(V) {
+                return V.id;
+              });
+            };
+            sh.prototype.populate = function(y, I, V) {
+              this.hasPattern = Xw("line", this.layers, I);
+              for (var $ = this.layers[0].layout.get("line-sort-key"), ae = [], he = 0, ze = y; he < ze.length; he += 1) {
+                var rt = ze[he], gt = rt.feature, Et = rt.id, or = rt.index, _r = rt.sourceLayerIndex, pr = this.layers[0]._featureFilter.needGeometry, Fr = Ja(gt, pr);
+                if (this.layers[0]._featureFilter.filter(new Gn(this.zoom), Fr, V)) {
+                  var oi = $ ? $.evaluate(Fr, {}, V) : void 0, Hi = { id: Et, properties: gt.properties, type: gt.type, sourceLayerIndex: _r, index: or, geometry: pr ? Fr.geometry : zn(gt), patterns: {}, sortKey: oi };
+                  ae.push(Hi);
+                }
+              }
+              $ && ae.sort(function(za, Za) {
+                return za.sortKey - Za.sortKey;
+              });
+              for (var Ai = 0, bn = ae; Ai < bn.length; Ai += 1) {
+                var nn = bn[Ai], xn = nn, Pn = xn.geometry, Zn = xn.index, ga = xn.sourceLayerIndex;
+                if (this.hasPattern) {
+                  var ha = ob("line", this.layers, nn, this.zoom, I);
+                  this.patternFeatures.push(ha);
+                } else this.addFeature(nn, Pn, Zn, V, {});
+                var eo = y[Zn].feature;
+                I.featureIndex.insert(eo, Pn, Zn, ga, this.index);
+              }
+            }, sh.prototype.update = function(y, I, V) {
+              this.stateDependentLayers.length && this.programConfigurations.updatePaintArrays(y, I, this.stateDependentLayers, V);
+            }, sh.prototype.addFeatures = function(y, I, V) {
+              for (var $ = 0, ae = this.patternFeatures; $ < ae.length; $ += 1) {
+                var he = ae[$];
+                this.addFeature(he, he.geometry, he.index, I, V);
+              }
+            }, sh.prototype.isEmpty = function() {
+              return this.layoutVertexArray.length === 0;
+            }, sh.prototype.uploadPending = function() {
+              return !this.uploaded || this.programConfigurations.needsUpload;
+            }, sh.prototype.upload = function(y) {
+              this.uploaded || (this.layoutVertexArray2.length !== 0 && (this.layoutVertexBuffer2 = y.createVertexBuffer(this.layoutVertexArray2, QC)), this.layoutVertexBuffer = y.createVertexBuffer(this.layoutVertexArray, $C), this.indexBuffer = y.createIndexBuffer(this.indexArray)), this.programConfigurations.upload(y), this.uploaded = true;
+            }, sh.prototype.destroy = function() {
+              this.layoutVertexBuffer && (this.layoutVertexBuffer.destroy(), this.indexBuffer.destroy(), this.programConfigurations.destroy(), this.segments.destroy());
+            }, sh.prototype.lineFeatureClips = function(y) {
+              if (y.properties && y.properties.hasOwnProperty("mapbox_clip_start") && y.properties.hasOwnProperty("mapbox_clip_end")) {
+                var I = +y.properties.mapbox_clip_start, V = +y.properties.mapbox_clip_end;
+                return { start: I, end: V };
+              }
+            }, sh.prototype.addFeature = function(y, I, V, $, ae) {
+              var he = this.layers[0].layout, ze = he.get("line-join").evaluate(y, {}), rt = he.get("line-cap"), gt = he.get("line-miter-limit"), Et = he.get("line-round-limit");
+              this.lineClips = this.lineFeatureClips(y);
+              for (var or = 0, _r = I; or < _r.length; or += 1) {
+                var pr = _r[or];
+                this.addLine(pr, y, ze, rt, gt, Et);
+              }
+              this.programConfigurations.populatePaintArrays(this.layoutVertexArray.length, y, V, ae, $);
+            }, sh.prototype.addLine = function(y, I, V, $, ae, he) {
+              if (this.distance = 0, this.scaledDistance = 0, this.totalDistance = 0, this.lineClips) {
+                this.lineClipsArray.push(this.lineClips);
+                for (var ze = 0; ze < y.length - 1; ze++) this.totalDistance += y[ze].dist(y[ze + 1]);
+                this.updateScaledDistance(), this.maxLineLength = Math.max(this.maxLineLength, this.totalDistance);
+              }
+              for (var rt = AS[I.type] === "Polygon", gt = y.length; gt >= 2 && y[gt - 1].equals(y[gt - 2]); ) gt--;
+              for (var Et = 0; Et < gt - 1 && y[Et].equals(y[Et + 1]); ) Et++;
+              if (!(gt < (rt ? 3 : 2))) {
+                V === "bevel" && (ae = 1.05);
+                var or = this.overscaling <= 16 ? ub * Ci / (512 * this.overscaling) : 0, _r = this.segments.prepareSegment(gt * 10, this.layoutVertexArray, this.indexArray), pr, Fr = void 0, oi = void 0, Hi = void 0, Ai = void 0;
+                this.e1 = this.e2 = -1, rt && (pr = y[gt - 2], Ai = y[Et].sub(pr)._unit()._perp());
+                for (var bn = Et; bn < gt; bn++) if (oi = bn === gt - 1 ? rt ? y[Et + 1] : void 0 : y[bn + 1], !(oi && y[bn].equals(oi))) {
+                  Ai && (Hi = Ai), pr && (Fr = pr), pr = y[bn], Ai = oi ? oi.sub(pr)._unit()._perp() : Hi, Hi = Hi || Ai;
+                  var nn = Hi.add(Ai);
+                  (nn.x !== 0 || nn.y !== 0) && nn._unit();
+                  var xn = Hi.x * Ai.x + Hi.y * Ai.y, Pn = nn.x * Ai.x + nn.y * Ai.y, Zn = Pn !== 0 ? 1 / Pn : 1 / 0, ga = 2 * Math.sqrt(2 - 2 * Pn), ha = Pn < e6 && Fr && oi, eo = Hi.x * Ai.y - Hi.y * Ai.x > 0;
+                  if (ha && bn > Et) {
+                    var za = pr.dist(Fr);
+                    if (za > 2 * or) {
+                      var Za = pr.sub(pr.sub(Fr)._mult(or / za)._round());
+                      this.updateDistance(Fr, Za), this.addCurrentVertex(Za, Hi, 0, 0, _r), Fr = Za;
+                    }
+                  }
+                  var Jo = Fr && oi, to = Jo ? V : rt ? "butt" : $;
+                  if (Jo && to === "round" && (Zn < he ? to = "miter" : Zn <= 2 && (to = "fakeround")), to === "miter" && Zn > ae && (to = "bevel"), to === "bevel" && (Zn > 2 && (to = "flipbevel"), Zn < ae && (to = "miter")), Fr && this.updateDistance(Fr, pr), to === "miter") nn._mult(Zn), this.addCurrentVertex(pr, nn, 0, 0, _r);
+                  else if (to === "flipbevel") {
+                    if (Zn > 100) nn = Ai.mult(-1);
+                    else {
+                      var ao = Zn * Hi.add(Ai).mag() / Hi.sub(Ai).mag();
+                      nn._perp()._mult(ao * (eo ? -1 : 1));
+                    }
+                    this.addCurrentVertex(pr, nn, 0, 0, _r), this.addCurrentVertex(pr, nn.mult(-1), 0, 0, _r);
+                  } else if (to === "bevel" || to === "fakeround") {
+                    var _s = -Math.sqrt(Zn * Zn - 1), jo = eo ? _s : 0, El = eo ? 0 : _s;
+                    if (Fr && this.addCurrentVertex(pr, Hi, jo, El, _r), to === "fakeround") for (var Iu = Math.round(ga * 180 / Math.PI / SS), kl = 1; kl < Iu; kl++) {
+                      var Cl = kl / Iu;
+                      if (Cl !== 0.5) {
+                        var yl = Cl - 0.5, Qu = 1.0904 + xn * (-3.2452 + xn * (3.55645 - xn * 1.43519)), gc = 0.848013 + xn * (-1.06021 + xn * 0.215638);
+                        Cl = Cl + Cl * yl * (Cl - 1) * (Qu * yl * yl + gc);
+                      }
+                      var Sf = Ai.sub(Hi)._mult(Cl)._add(Hi)._unit()._mult(eo ? -1 : 1);
+                      this.addHalfVertex(pr, Sf.x, Sf.y, false, eo, 0, _r);
+                    }
+                    oi && this.addCurrentVertex(pr, Ai, -jo, -El, _r);
+                  } else if (to === "butt") this.addCurrentVertex(pr, nn, 0, 0, _r);
+                  else if (to === "square") {
+                    var Ff = Fr ? 1 : -1;
+                    this.addCurrentVertex(pr, nn, Ff, Ff, _r);
+                  } else to === "round" && (Fr && (this.addCurrentVertex(pr, Hi, 0, 0, _r), this.addCurrentVertex(pr, Hi, 1, 1, _r, true)), oi && (this.addCurrentVertex(pr, Ai, -1, -1, _r, true), this.addCurrentVertex(pr, Ai, 0, 0, _r)));
+                  if (ha && bn < gt - 1) {
+                    var $h = pr.dist(oi);
+                    if ($h > 2 * or) {
+                      var ch = pr.add(oi.sub(pr)._mult(or / $h)._round());
+                      this.updateDistance(pr, ch), this.addCurrentVertex(ch, Ai, 0, 0, _r), pr = ch;
+                    }
+                  }
+                }
+              }
+            }, sh.prototype.addCurrentVertex = function(y, I, V, $, ae, he) {
+              he === void 0 && (he = false);
+              var ze = I.x + I.y * V, rt = I.y - I.x * V, gt = -I.x + I.y * $, Et = -I.y - I.x * $;
+              this.addHalfVertex(y, ze, rt, he, false, V, ae), this.addHalfVertex(y, gt, Et, he, true, -$, ae), this.distance > cb / 2 && this.totalDistance === 0 && (this.distance = 0, this.addCurrentVertex(y, I, V, $, ae, he));
+            }, sh.prototype.addHalfVertex = function(y, I, V, $, ae, he, ze) {
+              var rt = y.x, gt = y.y, Et = this.lineClips ? this.scaledDistance * (cb - 1) : this.scaledDistance, or = Et * Kw;
+              if (this.layoutVertexArray.emplaceBack((rt << 1) + ($ ? 1 : 0), (gt << 1) + (ae ? 1 : 0), Math.round(Yw * I) + 128, Math.round(Yw * V) + 128, (he === 0 ? 0 : he < 0 ? -1 : 1) + 1 | (or & 63) << 2, or >> 6), this.lineClips) {
+                var _r = this.scaledDistance - this.lineClips.start, pr = this.lineClips.end - this.lineClips.start, Fr = _r / pr;
+                this.layoutVertexArray2.emplaceBack(Fr, this.lineClipsArray.length);
+              }
+              var oi = ze.vertexLength++;
+              this.e1 >= 0 && this.e2 >= 0 && (this.indexArray.emplaceBack(this.e1, this.e2, oi), ze.primitiveLength++), ae ? this.e2 = oi : this.e1 = oi;
+            }, sh.prototype.updateScaledDistance = function() {
+              this.scaledDistance = this.lineClips ? this.lineClips.start + (this.lineClips.end - this.lineClips.start) * this.distance / this.totalDistance : this.distance;
+            }, sh.prototype.updateDistance = function(y, I) {
+              this.distance += y.dist(I), this.updateScaledDistance();
+            }, X("LineBucket", sh, { omit: ["layers", "patternFeatures"] });
+            var MS = new Nr({ "line-cap": new Me(Rn.layout_line["line-cap"]), "line-join": new bt(Rn.layout_line["line-join"]), "line-miter-limit": new Me(Rn.layout_line["line-miter-limit"]), "line-round-limit": new Me(Rn.layout_line["line-round-limit"]), "line-sort-key": new bt(Rn.layout_line["line-sort-key"]) }), ES = new Nr({ "line-opacity": new bt(Rn.paint_line["line-opacity"]), "line-color": new bt(Rn.paint_line["line-color"]), "line-translate": new Me(Rn.paint_line["line-translate"]), "line-translate-anchor": new Me(Rn.paint_line["line-translate-anchor"]), "line-width": new bt(Rn.paint_line["line-width"]), "line-gap-width": new bt(Rn.paint_line["line-gap-width"]), "line-offset": new bt(Rn.paint_line["line-offset"]), "line-blur": new bt(Rn.paint_line["line-blur"]), "line-dasharray": new Rr(Rn.paint_line["line-dasharray"]), "line-pattern": new zt(Rn.paint_line["line-pattern"]), "line-gradient": new jr(Rn.paint_line["line-gradient"]) }), Jw = { paint: ES, layout: MS }, uO = function(m) {
+              function y() {
+                m.apply(this, arguments);
+              }
+              return m && (y.__proto__ = m), y.prototype = Object.create(m && m.prototype), y.prototype.constructor = y, y.prototype.possiblyEvaluate = function(V, $) {
+                return $ = new Gn(Math.floor($.zoom), { now: $.now, fadeDuration: $.fadeDuration, zoomHistory: $.zoomHistory, transition: $.transition }), m.prototype.possiblyEvaluate.call(this, V, $);
+              }, y.prototype.evaluate = function(V, $, ae, he) {
+                return $ = x({}, $, { zoom: Math.floor($.zoom) }), m.prototype.evaluate.call(this, V, $, ae, he);
+              }, y;
+            }(bt), R = new uO(Jw.paint.properties["line-width"].specification);
+            R.useIntegerZoom = true;
+            var S = function(m) {
+              function y(I) {
+                m.call(this, I, Jw), this.gradientVersion = 0;
+              }
+              return m && (y.__proto__ = m), y.prototype = Object.create(m && m.prototype), y.prototype.constructor = y, y.prototype._handleSpecialPaintPropertyUpdate = function(V) {
+                if (V === "line-gradient") {
+                  var $ = this._transitionablePaint._values["line-gradient"].value.expression;
+                  this.stepInterpolant = $._styleExpression.expression instanceof _u, this.gradientVersion = (this.gradientVersion + 1) % d;
+                }
+              }, y.prototype.gradientExpression = function() {
+                return this._transitionablePaint._values["line-gradient"].value.expression;
+              }, y.prototype.recalculate = function(V, $) {
+                m.prototype.recalculate.call(this, V, $), this.paint._values["line-floorwidth"] = R.possiblyEvaluate(this._transitioningPaint._values["line-width"].value, V);
+              }, y.prototype.createBucket = function(V) {
+                return new sh(V);
+              }, y.prototype.queryRadius = function(V) {
+                var $ = V, ae = F(Ad("line-width", this, $), Ad("line-gap-width", this, $)), he = Ad("line-offset", this, $);
+                return ae / 2 + Math.abs(he) + Pv(this.paint.get("line-translate"));
+              }, y.prototype.queryIntersectsFeature = function(V, $, ae, he, ze, rt, gt) {
+                var Et = Jv(V, this.paint.get("line-translate"), this.paint.get("line-translate-anchor"), rt.angle, gt), or = gt / 2 * F(this.paint.get("line-width").evaluate($, ae), this.paint.get("line-gap-width").evaluate($, ae)), _r = this.paint.get("line-offset").evaluate($, ae);
+                return _r && (he = W(he, _r * gt)), ou(Et, he, or);
+              }, y.prototype.isTileClipped = function() {
+                return true;
+              }, y;
+            }(mi);
+            function F(m, y) {
+              return y > 0 ? y + 2 * m : m;
+            }
+            function W(m, y) {
+              for (var I = [], V = new u(0, 0), $ = 0; $ < m.length; $++) {
+                for (var ae = m[$], he = [], ze = 0; ze < ae.length; ze++) {
+                  var rt = ae[ze - 1], gt = ae[ze], Et = ae[ze + 1], or = ze === 0 ? V : gt.sub(rt)._unit()._perp(), _r = ze === ae.length - 1 ? V : Et.sub(gt)._unit()._perp(), pr = or._add(_r)._unit(), Fr = pr.x * _r.x + pr.y * _r.y;
+                  pr._mult(1 / Fr), he.push(pr._mult(y)._add(gt));
+                }
+                I.push(he);
+              }
+              return I;
+            }
+            var te = Wi([{ name: "a_pos_offset", components: 4, type: "Int16" }, { name: "a_data", components: 4, type: "Uint16" }, { name: "a_pixeloffset", components: 4, type: "Int16" }], 4), fe = Wi([{ name: "a_projected_pos", components: 3, type: "Float32" }], 4);
+            Wi([{ name: "a_fade_opacity", components: 1, type: "Uint32" }], 4);
+            var Fe = Wi([{ name: "a_placed", components: 2, type: "Uint8" }, { name: "a_shift", components: 2, type: "Float32" }]);
+            Wi([{ type: "Int16", name: "anchorPointX" }, { type: "Int16", name: "anchorPointY" }, { type: "Int16", name: "x1" }, { type: "Int16", name: "y1" }, { type: "Int16", name: "x2" }, { type: "Int16", name: "y2" }, { type: "Uint32", name: "featureIndex" }, { type: "Uint16", name: "sourceLayerIndex" }, { type: "Uint16", name: "bucketIndex" }]);
+            var ct = Wi([{ name: "a_pos", components: 2, type: "Int16" }, { name: "a_anchor_pos", components: 2, type: "Int16" }, { name: "a_extrude", components: 2, type: "Int16" }], 4), Lt = Wi([{ name: "a_pos", components: 2, type: "Float32" }, { name: "a_radius", components: 1, type: "Float32" }, { name: "a_flags", components: 2, type: "Int16" }], 4);
+            Wi([{ name: "triangle", components: 3, type: "Uint16" }]);
+            Wi([{ type: "Int16", name: "anchorX" }, { type: "Int16", name: "anchorY" }, { type: "Uint16", name: "glyphStartIndex" }, { type: "Uint16", name: "numGlyphs" }, { type: "Uint32", name: "vertexStartIndex" }, { type: "Uint32", name: "lineStartIndex" }, { type: "Uint32", name: "lineLength" }, { type: "Uint16", name: "segment" }, { type: "Uint16", name: "lowerSize" }, { type: "Uint16", name: "upperSize" }, { type: "Float32", name: "lineOffsetX" }, { type: "Float32", name: "lineOffsetY" }, { type: "Uint8", name: "writingMode" }, { type: "Uint8", name: "placedOrientation" }, { type: "Uint8", name: "hidden" }, { type: "Uint32", name: "crossTileID" }, { type: "Int16", name: "associatedIconIndex" }]);
+            Wi([{ type: "Int16", name: "anchorX" }, { type: "Int16", name: "anchorY" }, { type: "Int16", name: "rightJustifiedTextSymbolIndex" }, { type: "Int16", name: "centerJustifiedTextSymbolIndex" }, { type: "Int16", name: "leftJustifiedTextSymbolIndex" }, { type: "Int16", name: "verticalPlacedTextSymbolIndex" }, { type: "Int16", name: "placedIconSymbolIndex" }, { type: "Int16", name: "verticalPlacedIconSymbolIndex" }, { type: "Uint16", name: "key" }, { type: "Uint16", name: "textBoxStartIndex" }, { type: "Uint16", name: "textBoxEndIndex" }, { type: "Uint16", name: "verticalTextBoxStartIndex" }, { type: "Uint16", name: "verticalTextBoxEndIndex" }, { type: "Uint16", name: "iconBoxStartIndex" }, { type: "Uint16", name: "iconBoxEndIndex" }, { type: "Uint16", name: "verticalIconBoxStartIndex" }, { type: "Uint16", name: "verticalIconBoxEndIndex" }, { type: "Uint16", name: "featureIndex" }, { type: "Uint16", name: "numHorizontalGlyphVertices" }, { type: "Uint16", name: "numVerticalGlyphVertices" }, { type: "Uint16", name: "numIconVertices" }, { type: "Uint16", name: "numVerticalIconVertices" }, { type: "Uint16", name: "useRuntimeCollisionCircles" }, { type: "Uint32", name: "crossTileID" }, { type: "Float32", name: "textBoxScale" }, { type: "Float32", components: 2, name: "textOffset" }, { type: "Float32", name: "collisionCircleDiameter" }]);
+            Wi([{ type: "Float32", name: "offsetX" }]);
+            Wi([{ type: "Int16", name: "x" }, { type: "Int16", name: "y" }, { type: "Int16", name: "tileUnitDistanceFromAnchor" }]);
+            function ui(m, y, I) {
+              var V = y.layout.get("text-transform").evaluate(I, {});
+              return V === "uppercase" ? m = m.toLocaleUpperCase() : V === "lowercase" && (m = m.toLocaleLowerCase()), Ms.applyArabicShaping && (m = Ms.applyArabicShaping(m)), m;
+            }
+            function yi(m, y, I) {
+              return m.sections.forEach(function(V) {
+                V.text = ui(V.text, y, I);
+              }), m;
+            }
+            function vn(m) {
+              var y = {}, I = {}, V = [], $ = 0;
+              function ae(Ai) {
+                V.push(m[Ai]), $++;
+              }
+              function he(Ai, bn, nn) {
+                var xn = I[Ai];
+                return delete I[Ai], I[bn] = xn, V[xn].geometry[0].pop(), V[xn].geometry[0] = V[xn].geometry[0].concat(nn[0]), xn;
+              }
+              function ze(Ai, bn, nn) {
+                var xn = y[bn];
+                return delete y[bn], y[Ai] = xn, V[xn].geometry[0].shift(), V[xn].geometry[0] = nn[0].concat(V[xn].geometry[0]), xn;
+              }
+              function rt(Ai, bn, nn) {
+                var xn = nn ? bn[0][bn[0].length - 1] : bn[0][0];
+                return Ai + ":" + xn.x + ":" + xn.y;
+              }
+              for (var gt = 0; gt < m.length; gt++) {
+                var Et = m[gt], or = Et.geometry, _r = Et.text ? Et.text.toString() : null;
+                if (!_r) {
+                  ae(gt);
+                  continue;
+                }
+                var pr = rt(_r, or), Fr = rt(_r, or, true);
+                if (pr in I && Fr in y && I[pr] !== y[Fr]) {
+                  var oi = ze(pr, Fr, or), Hi = he(pr, Fr, V[oi].geometry);
+                  delete y[pr], delete I[Fr], I[rt(_r, V[Hi].geometry, true)] = Hi, V[oi].geometry = null;
+                } else pr in I ? he(pr, Fr, or) : Fr in y ? ze(pr, Fr, or) : (ae(gt), y[pr] = $ - 1, I[Fr] = $ - 1);
+              }
+              return V.filter(function(Ai) {
+                return Ai.geometry;
+              });
+            }
+            var zi = { "!": "︕", "#": "＃", $: "＄", "%": "％", "&": "＆", "(": "︵", ")": "︶", "*": "＊", "+": "＋", ",": "︐", "-": "︲", ".": "・", "/": "／", ":": "︓", ";": "︔", "<": "︿", "=": "＝", ">": "﹀", "?": "︖", "@": "＠", "[": "﹇", "\\": "＼", "]": "﹈", "^": "＾", _: "︳", "`": "｀", "{": "︷", "|": "―", "}": "︸", "~": "～", "¢": "￠", "£": "￡", "¥": "￥", "¦": "￤", "¬": "￢", "¯": "￣", "–": "︲", "—": "︱", "‘": "﹃", "’": "﹄", "“": "﹁", "”": "﹂", "…": "︙", "‧": "・", "₩": "￦", "、": "︑", "。": "︒", "〈": "︿", "〉": "﹀", "《": "︽", "》": "︾", "「": "﹁", "」": "﹂", "『": "﹃", "』": "﹄", "【": "︻", "】": "︼", "〔": "︹", "〕": "︺", "〖": "︗", "〗": "︘", "！": "︕", "（": "︵", "）": "︶", "，": "︐", "－": "︲", "．": "・", "：": "︓", "；": "︔", "＜": "︿", "＞": "﹀", "？": "︖", "［": "﹇", "］": "﹈", "＿": "︳", "｛": "︷", "｜": "―", "｝": "︸", "｟": "︵", "｠": "︶", "｡": "︒", "｢": "﹁", "｣": "﹂" };
+            function un(m) {
+              for (var y = "", I = 0; I < m.length; I++) {
+                var V = m.charCodeAt(I + 1) || null, $ = m.charCodeAt(I - 1) || null, ae = (!V || !bi(V) || zi[m[I + 1]]) && (!$ || !bi($) || zi[m[I - 1]]);
+                ae && zi[m[I]] ? y += zi[m[I]] : y += m[I];
+              }
+              return y;
+            }
+            var Tn = 24, pa = function(m, y, I, V, $) {
+              var ae, he, ze = $ * 8 - V - 1, rt = (1 << ze) - 1, gt = rt >> 1, Et = -7, or = I ? $ - 1 : 0, _r = I ? -1 : 1, pr = m[y + or];
+              for (or += _r, ae = pr & (1 << -Et) - 1, pr >>= -Et, Et += ze; Et > 0; ae = ae * 256 + m[y + or], or += _r, Et -= 8) ;
+              for (he = ae & (1 << -Et) - 1, ae >>= -Et, Et += V; Et > 0; he = he * 256 + m[y + or], or += _r, Et -= 8) ;
+              if (ae === 0) ae = 1 - gt;
+              else {
+                if (ae === rt) return he ? NaN : (pr ? -1 : 1) * (1 / 0);
+                he = he + Math.pow(2, V), ae = ae - gt;
+              }
+              return (pr ? -1 : 1) * he * Math.pow(2, ae - V);
+            }, ro = function(m, y, I, V, $, ae) {
+              var he, ze, rt, gt = ae * 8 - $ - 1, Et = (1 << gt) - 1, or = Et >> 1, _r = $ === 23 ? Math.pow(2, -24) - Math.pow(2, -77) : 0, pr = V ? 0 : ae - 1, Fr = V ? 1 : -1, oi = y < 0 || y === 0 && 1 / y < 0 ? 1 : 0;
+              for (y = Math.abs(y), isNaN(y) || y === 1 / 0 ? (ze = isNaN(y) ? 1 : 0, he = Et) : (he = Math.floor(Math.log(y) / Math.LN2), y * (rt = Math.pow(2, -he)) < 1 && (he--, rt *= 2), he + or >= 1 ? y += _r / rt : y += _r * Math.pow(2, 1 - or), y * rt >= 2 && (he++, rt /= 2), he + or >= Et ? (ze = 0, he = Et) : he + or >= 1 ? (ze = (y * rt - 1) * Math.pow(2, $), he = he + or) : (ze = y * Math.pow(2, or - 1) * Math.pow(2, $), he = 0)); $ >= 8; m[I + pr] = ze & 255, pr += Fr, ze /= 256, $ -= 8) ;
+              for (he = he << $ | ze, gt += $; gt > 0; m[I + pr] = he & 255, pr += Fr, he /= 256, gt -= 8) ;
+              m[I + pr - Fr] |= oi * 128;
+            }, Vo = { read: pa, write: ro }, Xa = sa;
+            function sa(m) {
+              this.buf = ArrayBuffer.isView && ArrayBuffer.isView(m) ? m : new Uint8Array(m || 0), this.pos = 0, this.type = 0, this.length = this.buf.length;
+            }
+            sa.Varint = 0, sa.Fixed64 = 1, sa.Bytes = 2, sa.Fixed32 = 5;
+            var Mo = 65536 * 65536, fo = 1 / Mo, lo = 12, Xn = typeof TextDecoder == "undefined" ? null : new TextDecoder("utf8");
+            sa.prototype = { destroy: function() {
+              this.buf = null;
+            }, readFields: function(m, y, I) {
+              for (I = I || this.length; this.pos < I; ) {
+                var V = this.readVarint(), $ = V >> 3, ae = this.pos;
+                this.type = V & 7, m($, y, this), this.pos === ae && this.skip(V);
+              }
+              return y;
+            }, readMessage: function(m, y) {
+              return this.readFields(m, y, this.readVarint() + this.pos);
+            }, readFixed32: function() {
+              var m = Yh(this.buf, this.pos);
+              return this.pos += 4, m;
+            }, readSFixed32: function() {
+              var m = Fv(this.buf, this.pos);
+              return this.pos += 4, m;
+            }, readFixed64: function() {
+              var m = Yh(this.buf, this.pos) + Yh(this.buf, this.pos + 4) * Mo;
+              return this.pos += 8, m;
+            }, readSFixed64: function() {
+              var m = Yh(this.buf, this.pos) + Fv(this.buf, this.pos + 4) * Mo;
+              return this.pos += 8, m;
+            }, readFloat: function() {
+              var m = Vo.read(this.buf, this.pos, true, 23, 4);
+              return this.pos += 4, m;
+            }, readDouble: function() {
+              var m = Vo.read(this.buf, this.pos, true, 52, 8);
+              return this.pos += 8, m;
+            }, readVarint: function(m) {
+              var y = this.buf, I, V;
+              return V = y[this.pos++], I = V & 127, V < 128 || (V = y[this.pos++], I |= (V & 127) << 7, V < 128) || (V = y[this.pos++], I |= (V & 127) << 14, V < 128) || (V = y[this.pos++], I |= (V & 127) << 21, V < 128) ? I : (V = y[this.pos], I |= (V & 15) << 28, Ro(I, m, this));
+            }, readVarint64: function() {
+              return this.readVarint(true);
+            }, readSVarint: function() {
+              var m = this.readVarint();
+              return m % 2 === 1 ? (m + 1) / -2 : m / 2;
+            }, readBoolean: function() {
+              return !!this.readVarint();
+            }, readString: function() {
+              var m = this.readVarint() + this.pos, y = this.pos;
+              return this.pos = m, m - y >= lo && Xn ? ru(this.buf, y, m) : lv(this.buf, y, m);
+            }, readBytes: function() {
+              var m = this.readVarint() + this.pos, y = this.buf.subarray(this.pos, m);
+              return this.pos = m, y;
+            }, readPackedVarint: function(m, y) {
+              if (this.type !== sa.Bytes) return m.push(this.readVarint(y));
+              var I = uo(this);
+              for (m = m || []; this.pos < I; ) m.push(this.readVarint(y));
+              return m;
+            }, readPackedSVarint: function(m) {
+              if (this.type !== sa.Bytes) return m.push(this.readSVarint());
+              var y = uo(this);
+              for (m = m || []; this.pos < y; ) m.push(this.readSVarint());
+              return m;
+            }, readPackedBoolean: function(m) {
+              if (this.type !== sa.Bytes) return m.push(this.readBoolean());
+              var y = uo(this);
+              for (m = m || []; this.pos < y; ) m.push(this.readBoolean());
+              return m;
+            }, readPackedFloat: function(m) {
+              if (this.type !== sa.Bytes) return m.push(this.readFloat());
+              var y = uo(this);
+              for (m = m || []; this.pos < y; ) m.push(this.readFloat());
+              return m;
+            }, readPackedDouble: function(m) {
+              if (this.type !== sa.Bytes) return m.push(this.readDouble());
+              var y = uo(this);
+              for (m = m || []; this.pos < y; ) m.push(this.readDouble());
+              return m;
+            }, readPackedFixed32: function(m) {
+              if (this.type !== sa.Bytes) return m.push(this.readFixed32());
+              var y = uo(this);
+              for (m = m || []; this.pos < y; ) m.push(this.readFixed32());
+              return m;
+            }, readPackedSFixed32: function(m) {
+              if (this.type !== sa.Bytes) return m.push(this.readSFixed32());
+              var y = uo(this);
+              for (m = m || []; this.pos < y; ) m.push(this.readSFixed32());
+              return m;
+            }, readPackedFixed64: function(m) {
+              if (this.type !== sa.Bytes) return m.push(this.readFixed64());
+              var y = uo(this);
+              for (m = m || []; this.pos < y; ) m.push(this.readFixed64());
+              return m;
+            }, readPackedSFixed64: function(m) {
+              if (this.type !== sa.Bytes) return m.push(this.readSFixed64());
+              var y = uo(this);
+              for (m = m || []; this.pos < y; ) m.push(this.readSFixed64());
+              return m;
+            }, skip: function(m) {
+              var y = m & 7;
+              if (y === sa.Varint) for (; this.buf[this.pos++] > 127; ) ;
+              else if (y === sa.Bytes) this.pos = this.readVarint() + this.pos;
+              else if (y === sa.Fixed32) this.pos += 4;
+              else if (y === sa.Fixed64) this.pos += 8;
+              else throw new Error("Unimplemented type: " + y);
+            }, writeTag: function(m, y) {
+              this.writeVarint(m << 3 | y);
+            }, realloc: function(m) {
+              for (var y = this.length || 16; y < this.pos + m; ) y *= 2;
+              if (y !== this.length) {
+                var I = new Uint8Array(y);
+                I.set(this.buf), this.buf = I, this.length = y;
+              }
+            }, finish: function() {
+              return this.length = this.pos, this.pos = 0, this.buf.subarray(0, this.length);
+            }, writeFixed32: function(m) {
+              this.realloc(4), Df(this.buf, m, this.pos), this.pos += 4;
+            }, writeSFixed32: function(m) {
+              this.realloc(4), Df(this.buf, m, this.pos), this.pos += 4;
+            }, writeFixed64: function(m) {
+              this.realloc(8), Df(this.buf, m & -1, this.pos), Df(this.buf, Math.floor(m * fo), this.pos + 4), this.pos += 8;
+            }, writeSFixed64: function(m) {
+              this.realloc(8), Df(this.buf, m & -1, this.pos), Df(this.buf, Math.floor(m * fo), this.pos + 4), this.pos += 8;
+            }, writeVarint: function(m) {
+              if (m = +m || 0, m > 268435455 || m < 0) {
+                Ju(m, this);
+                return;
+              }
+              this.realloc(4), this.buf[this.pos++] = m & 127 | (m > 127 ? 128 : 0), !(m <= 127) && (this.buf[this.pos++] = (m >>>= 7) & 127 | (m > 127 ? 128 : 0), !(m <= 127) && (this.buf[this.pos++] = (m >>>= 7) & 127 | (m > 127 ? 128 : 0), !(m <= 127) && (this.buf[this.pos++] = m >>> 7 & 127)));
+            }, writeSVarint: function(m) {
+              this.writeVarint(m < 0 ? -m * 2 - 1 : m * 2);
+            }, writeBoolean: function(m) {
+              this.writeVarint(!!m);
+            }, writeString: function(m) {
+              m = String(m), this.realloc(m.length * 4), this.pos++;
+              var y = this.pos;
+              this.pos = pc(this.buf, m, this.pos);
+              var I = this.pos - y;
+              I >= 128 && Qv(y, I, this), this.pos = y - 1, this.writeVarint(I), this.pos += I;
+            }, writeFloat: function(m) {
+              this.realloc(4), Vo.write(this.buf, m, this.pos, true, 23, 4), this.pos += 4;
+            }, writeDouble: function(m) {
+              this.realloc(8), Vo.write(this.buf, m, this.pos, true, 52, 8), this.pos += 8;
+            }, writeBytes: function(m) {
+              var y = m.length;
+              this.writeVarint(y), this.realloc(y);
+              for (var I = 0; I < y; I++) this.buf[this.pos++] = m[I];
+            }, writeRawMessage: function(m, y) {
+              this.pos++;
+              var I = this.pos;
+              m(y, this);
+              var V = this.pos - I;
+              V >= 128 && Qv(I, V, this), this.pos = I - 1, this.writeVarint(V), this.pos += V;
+            }, writeMessage: function(m, y, I) {
+              this.writeTag(m, sa.Bytes), this.writeRawMessage(y, I);
+            }, writePackedVarint: function(m, y) {
+              y.length && this.writeMessage(m, ud, y);
+            }, writePackedSVarint: function(m, y) {
+              y.length && this.writeMessage(m, Ch, y);
+            }, writePackedBoolean: function(m, y) {
+              y.length && this.writeMessage(m, Hd, y);
+            }, writePackedFloat: function(m, y) {
+              y.length && this.writeMessage(m, Vd, y);
+            }, writePackedDouble: function(m, y) {
+              y.length && this.writeMessage(m, Gd, y);
+            }, writePackedFixed32: function(m, y) {
+              y.length && this.writeMessage(m, Af, y);
+            }, writePackedSFixed32: function(m, y) {
+              y.length && this.writeMessage(m, Lh, y);
+            }, writePackedFixed64: function(m, y) {
+              y.length && this.writeMessage(m, Ed, y);
+            }, writePackedSFixed64: function(m, y) {
+              y.length && this.writeMessage(m, cd, y);
+            }, writeBytesField: function(m, y) {
+              this.writeTag(m, sa.Bytes), this.writeBytes(y);
+            }, writeFixed32Field: function(m, y) {
+              this.writeTag(m, sa.Fixed32), this.writeFixed32(y);
+            }, writeSFixed32Field: function(m, y) {
+              this.writeTag(m, sa.Fixed32), this.writeSFixed32(y);
+            }, writeFixed64Field: function(m, y) {
+              this.writeTag(m, sa.Fixed64), this.writeFixed64(y);
+            }, writeSFixed64Field: function(m, y) {
+              this.writeTag(m, sa.Fixed64), this.writeSFixed64(y);
+            }, writeVarintField: function(m, y) {
+              this.writeTag(m, sa.Varint), this.writeVarint(y);
+            }, writeSVarintField: function(m, y) {
+              this.writeTag(m, sa.Varint), this.writeSVarint(y);
+            }, writeStringField: function(m, y) {
+              this.writeTag(m, sa.Bytes), this.writeString(y);
+            }, writeFloatField: function(m, y) {
+              this.writeTag(m, sa.Fixed32), this.writeFloat(y);
+            }, writeDoubleField: function(m, y) {
+              this.writeTag(m, sa.Fixed64), this.writeDouble(y);
+            }, writeBooleanField: function(m, y) {
+              this.writeVarintField(m, !!y);
+            } };
+            function Ro(m, y, I) {
+              var V = I.buf, $, ae;
+              if (ae = V[I.pos++], $ = (ae & 112) >> 4, ae < 128 || (ae = V[I.pos++], $ |= (ae & 127) << 3, ae < 128) || (ae = V[I.pos++], $ |= (ae & 127) << 10, ae < 128) || (ae = V[I.pos++], $ |= (ae & 127) << 17, ae < 128) || (ae = V[I.pos++], $ |= (ae & 127) << 24, ae < 128) || (ae = V[I.pos++], $ |= (ae & 1) << 31, ae < 128)) return $o(m, $, y);
+              throw new Error("Expected varint not more than 10 bytes");
+            }
+            function uo(m) {
+              return m.type === sa.Bytes ? m.readVarint() + m.pos : m.pos + 1;
+            }
+            function $o(m, y, I) {
+              return I ? y * 4294967296 + (m >>> 0) : (y >>> 0) * 4294967296 + (m >>> 0);
+            }
+            function Ju(m, y) {
+              var I, V;
+              if (m >= 0 ? (I = m % 4294967296 | 0, V = m / 4294967296 | 0) : (I = ~(-m % 4294967296), V = ~(-m / 4294967296), I ^ 4294967295 ? I = I + 1 | 0 : (I = 0, V = V + 1 | 0)), m >= 18446744073709552e3 || m < -18446744073709552e3) throw new Error("Given varint doesn't fit into 10 bytes");
+              y.realloc(10), qu(I, V, y), kh(V, y);
+            }
+            function qu(m, y, I) {
+              I.buf[I.pos++] = m & 127 | 128, m >>>= 7, I.buf[I.pos++] = m & 127 | 128, m >>>= 7, I.buf[I.pos++] = m & 127 | 128, m >>>= 7, I.buf[I.pos++] = m & 127 | 128, m >>>= 7, I.buf[I.pos] = m & 127;
+            }
+            function kh(m, y) {
+              var I = (m & 7) << 4;
+              y.buf[y.pos++] |= I | ((m >>>= 3) ? 128 : 0), m && (y.buf[y.pos++] = m & 127 | ((m >>>= 7) ? 128 : 0), m && (y.buf[y.pos++] = m & 127 | ((m >>>= 7) ? 128 : 0), m && (y.buf[y.pos++] = m & 127 | ((m >>>= 7) ? 128 : 0), m && (y.buf[y.pos++] = m & 127 | ((m >>>= 7) ? 128 : 0), m && (y.buf[y.pos++] = m & 127)))));
+            }
+            function Qv(m, y, I) {
+              var V = y <= 16383 ? 1 : y <= 2097151 ? 2 : y <= 268435455 ? 3 : Math.floor(Math.log(y) / (Math.LN2 * 7));
+              I.realloc(V);
+              for (var $ = I.pos - 1; $ >= m; $--) I.buf[$ + V] = I.buf[$];
+            }
+            function ud(m, y) {
+              for (var I = 0; I < m.length; I++) y.writeVarint(m[I]);
+            }
+            function Ch(m, y) {
+              for (var I = 0; I < m.length; I++) y.writeSVarint(m[I]);
+            }
+            function Vd(m, y) {
+              for (var I = 0; I < m.length; I++) y.writeFloat(m[I]);
+            }
+            function Gd(m, y) {
+              for (var I = 0; I < m.length; I++) y.writeDouble(m[I]);
+            }
+            function Hd(m, y) {
+              for (var I = 0; I < m.length; I++) y.writeBoolean(m[I]);
+            }
+            function Af(m, y) {
+              for (var I = 0; I < m.length; I++) y.writeFixed32(m[I]);
+            }
+            function Lh(m, y) {
+              for (var I = 0; I < m.length; I++) y.writeSFixed32(m[I]);
+            }
+            function Ed(m, y) {
+              for (var I = 0; I < m.length; I++) y.writeFixed64(m[I]);
+            }
+            function cd(m, y) {
+              for (var I = 0; I < m.length; I++) y.writeSFixed64(m[I]);
+            }
+            function Yh(m, y) {
+              return (m[y] | m[y + 1] << 8 | m[y + 2] << 16) + m[y + 3] * 16777216;
+            }
+            function Df(m, y, I) {
+              m[I] = y, m[I + 1] = y >>> 8, m[I + 2] = y >>> 16, m[I + 3] = y >>> 24;
+            }
+            function Fv(m, y) {
+              return (m[y] | m[y + 1] << 8 | m[y + 2] << 16) + (m[y + 3] << 24);
+            }
+            function lv(m, y, I) {
+              for (var V = "", $ = y; $ < I; ) {
+                var ae = m[$], he = null, ze = ae > 239 ? 4 : ae > 223 ? 3 : ae > 191 ? 2 : 1;
+                if ($ + ze > I) break;
+                var rt, gt, Et;
+                ze === 1 ? ae < 128 && (he = ae) : ze === 2 ? (rt = m[$ + 1], (rt & 192) === 128 && (he = (ae & 31) << 6 | rt & 63, he <= 127 && (he = null))) : ze === 3 ? (rt = m[$ + 1], gt = m[$ + 2], (rt & 192) === 128 && (gt & 192) === 128 && (he = (ae & 15) << 12 | (rt & 63) << 6 | gt & 63, (he <= 2047 || he >= 55296 && he <= 57343) && (he = null))) : ze === 4 && (rt = m[$ + 1], gt = m[$ + 2], Et = m[$ + 3], (rt & 192) === 128 && (gt & 192) === 128 && (Et & 192) === 128 && (he = (ae & 15) << 18 | (rt & 63) << 12 | (gt & 63) << 6 | Et & 63, (he <= 65535 || he >= 1114112) && (he = null))), he === null ? (he = 65533, ze = 1) : he > 65535 && (he -= 65536, V += String.fromCharCode(he >>> 10 & 1023 | 55296), he = 56320 | he & 1023), V += String.fromCharCode(he), $ += ze;
+              }
+              return V;
+            }
+            function ru(m, y, I) {
+              return Xn.decode(m.subarray(y, I));
+            }
+            function pc(m, y, I) {
+              for (var V = 0, $, ae; V < y.length; V++) {
+                if ($ = y.charCodeAt(V), $ > 55295 && $ < 57344) if (ae) if ($ < 56320) {
+                  m[I++] = 239, m[I++] = 191, m[I++] = 189, ae = $;
+                  continue;
+                } else $ = ae - 55296 << 10 | $ - 56320 | 65536, ae = null;
+                else {
+                  $ > 56319 || V + 1 === y.length ? (m[I++] = 239, m[I++] = 191, m[I++] = 189) : ae = $;
+                  continue;
+                }
+                else ae && (m[I++] = 239, m[I++] = 191, m[I++] = 189, ae = null);
+                $ < 128 ? m[I++] = $ : ($ < 2048 ? m[I++] = $ >> 6 | 192 : ($ < 65536 ? m[I++] = $ >> 12 | 224 : (m[I++] = $ >> 18 | 240, m[I++] = $ >> 12 & 63 | 128), m[I++] = $ >> 6 & 63 | 128), m[I++] = $ & 63 | 128);
+              }
+              return I;
+            }
+            var $u = 3;
+            function zv(m, y, I) {
+              m === 1 && I.readMessage(ff, y);
+            }
+            function ff(m, y, I) {
+              if (m === 3) {
+                var V = I.readMessage(q1, {}), $ = V.id, ae = V.bitmap, he = V.width, ze = V.height, rt = V.left, gt = V.top, Et = V.advance;
+                y.push({ id: $, bitmap: new Dv({ width: he + 2 * $u, height: ze + 2 * $u }, ae), metrics: { width: he, height: ze, left: rt, top: gt, advance: Et } });
+              }
+            }
+            function q1(m, y, I) {
+              m === 1 ? y.id = I.readVarint() : m === 2 ? y.bitmap = I.readBytes() : m === 3 ? y.width = I.readVarint() : m === 4 ? y.height = I.readVarint() : m === 5 ? y.left = I.readSVarint() : m === 6 ? y.top = I.readSVarint() : m === 7 && (y.advance = I.readVarint());
+            }
+            function p0(m) {
+              return new Xa(m).readFields(zv, []);
+            }
+            var Gp = $u;
+            function ep(m) {
+              for (var y = 0, I = 0, V = 0, $ = m; V < $.length; V += 1) {
+                var ae = $[V];
+                y += ae.w * ae.h, I = Math.max(I, ae.w);
+              }
+              m.sort(function(Hi, Ai) {
+                return Ai.h - Hi.h;
+              });
+              for (var he = Math.max(Math.ceil(Math.sqrt(y / 0.95)), I), ze = [{ x: 0, y: 0, w: he, h: 1 / 0 }], rt = 0, gt = 0, Et = 0, or = m; Et < or.length; Et += 1) for (var _r = or[Et], pr = ze.length - 1; pr >= 0; pr--) {
+                var Fr = ze[pr];
+                if (!(_r.w > Fr.w || _r.h > Fr.h)) {
+                  if (_r.x = Fr.x, _r.y = Fr.y, gt = Math.max(gt, _r.y + _r.h), rt = Math.max(rt, _r.x + _r.w), _r.w === Fr.w && _r.h === Fr.h) {
+                    var oi = ze.pop();
+                    pr < ze.length && (ze[pr] = oi);
+                  } else _r.h === Fr.h ? (Fr.x += _r.w, Fr.w -= _r.w) : _r.w === Fr.w ? (Fr.y += _r.h, Fr.h -= _r.h) : (ze.push({ x: Fr.x + _r.w, y: Fr.y, w: Fr.w - _r.w, h: _r.h }), Fr.y += _r.h, Fr.h -= _r.h);
+                  break;
+                }
+              }
+              return { w: rt, h: gt, fill: y / (rt * gt) || 0 };
+            }
+            var Gc = 1, Yf = function(y, I) {
+              var V = I.pixelRatio, $ = I.version, ae = I.stretchX, he = I.stretchY, ze = I.content;
+              this.paddedRect = y, this.pixelRatio = V, this.stretchX = ae, this.stretchY = he, this.content = ze, this.version = $;
+            }, tp = { tl: { configurable: true }, br: { configurable: true }, tlbr: { configurable: true }, displaySize: { configurable: true } };
+            tp.tl.get = function() {
+              return [this.paddedRect.x + Gc, this.paddedRect.y + Gc];
+            }, tp.br.get = function() {
+              return [this.paddedRect.x + this.paddedRect.w - Gc, this.paddedRect.y + this.paddedRect.h - Gc];
+            }, tp.tlbr.get = function() {
+              return this.tl.concat(this.br);
+            }, tp.displaySize.get = function() {
+              return [(this.paddedRect.w - Gc * 2) / this.pixelRatio, (this.paddedRect.h - Gc * 2) / this.pixelRatio];
+            }, Object.defineProperties(Yf.prototype, tp);
+            var yg = function(y, I) {
+              var V = {}, $ = {};
+              this.haveRenderCallbacks = [];
+              var ae = [];
+              this.addImages(y, V, ae), this.addImages(I, $, ae);
+              var he = ep(ae), ze = he.w, rt = he.h, gt = new Eh({ width: ze || 1, height: rt || 1 });
+              for (var Et in y) {
+                var or = y[Et], _r = V[Et].paddedRect;
+                Eh.copy(or.data, gt, { x: 0, y: 0 }, { x: _r.x + Gc, y: _r.y + Gc }, or.data);
+              }
+              for (var pr in I) {
+                var Fr = I[pr], oi = $[pr].paddedRect, Hi = oi.x + Gc, Ai = oi.y + Gc, bn = Fr.data.width, nn = Fr.data.height;
+                Eh.copy(Fr.data, gt, { x: 0, y: 0 }, { x: Hi, y: Ai }, Fr.data), Eh.copy(Fr.data, gt, { x: 0, y: nn - 1 }, { x: Hi, y: Ai - 1 }, { width: bn, height: 1 }), Eh.copy(Fr.data, gt, { x: 0, y: 0 }, { x: Hi, y: Ai + nn }, { width: bn, height: 1 }), Eh.copy(Fr.data, gt, { x: bn - 1, y: 0 }, { x: Hi - 1, y: Ai }, { width: 1, height: nn }), Eh.copy(Fr.data, gt, { x: 0, y: 0 }, { x: Hi + bn, y: Ai }, { width: 1, height: nn });
+              }
+              this.image = gt, this.iconPositions = V, this.patternPositions = $;
+            };
+            yg.prototype.addImages = function(y, I, V) {
+              for (var $ in y) {
+                var ae = y[$], he = { x: 0, y: 0, w: ae.data.width + 2 * Gc, h: ae.data.height + 2 * Gc };
+                V.push(he), I[$] = new Yf(he, ae), ae.hasRenderCallback && this.haveRenderCallbacks.push($);
+              }
+            }, yg.prototype.patchUpdatedImages = function(y, I) {
+              y.dispatchRenderCallbacks(this.haveRenderCallbacks);
+              for (var V in y.updatedImages) this.patchUpdatedImage(this.iconPositions[V], y.getImage(V), I), this.patchUpdatedImage(this.patternPositions[V], y.getImage(V), I);
+            }, yg.prototype.patchUpdatedImage = function(y, I, V) {
+              if (!(!y || !I) && y.version !== I.version) {
+                y.version = I.version;
+                var $ = y.tl, ae = $[0], he = $[1];
+                V.update(I.data, void 0, { x: ae, y: he });
+              }
+            }, X("ImagePosition", Yf), X("ImageAtlas", yg);
+            var uv = { horizontal: 1, vertical: 2, horizontalOnly: 3 }, B1 = -17;
+            function kS(m) {
+              for (var y = 0, I = m; y < I.length; y += 1) {
+                var V = I[y];
+                if (V.positionedGlyphs.length !== 0) return false;
+              }
+              return true;
+            }
+            var $w = 57344, g0 = 63743, _y = function() {
+              this.scale = 1, this.fontStack = "", this.imageName = null;
+            };
+            _y.forText = function(y, I) {
+              var V = new _y();
+              return V.scale = y || 1, V.fontStack = I, V;
+            }, _y.forImage = function(y) {
+              var I = new _y();
+              return I.imageName = y, I;
+            };
+            var Kh = function() {
+              this.text = "", this.sectionIndex = [], this.sections = [], this.imageSectionID = null;
+            };
+            Kh.fromFeature = function(y, I) {
+              for (var V = new Kh(), $ = 0; $ < y.sections.length; $++) {
+                var ae = y.sections[$];
+                ae.image ? V.addImageSection(ae) : V.addTextSection(ae, I);
+              }
+              return V;
+            }, Kh.prototype.length = function() {
+              return this.text.length;
+            }, Kh.prototype.getSection = function(y) {
+              return this.sections[this.sectionIndex[y]];
+            }, Kh.prototype.getSectionIndex = function(y) {
+              return this.sectionIndex[y];
+            }, Kh.prototype.getCharCode = function(y) {
+              return this.text.charCodeAt(y);
+            }, Kh.prototype.verticalizePunctuation = function() {
+              this.text = un(this.text);
+            }, Kh.prototype.trim = function() {
+              for (var y = 0, I = 0; I < this.text.length && m0[this.text.charCodeAt(I)]; I++) y++;
+              for (var V = this.text.length, $ = this.text.length - 1; $ >= 0 && $ >= y && m0[this.text.charCodeAt($)]; $--) V--;
+              this.text = this.text.substring(y, V), this.sectionIndex = this.sectionIndex.slice(y, V);
+            }, Kh.prototype.substring = function(y, I) {
+              var V = new Kh();
+              return V.text = this.text.substring(y, I), V.sectionIndex = this.sectionIndex.slice(y, I), V.sections = this.sections, V;
+            }, Kh.prototype.toString = function() {
+              return this.text;
+            }, Kh.prototype.getMaxScale = function() {
+              var y = this;
+              return this.sectionIndex.reduce(function(I, V) {
+                return Math.max(I, y.sections[V].scale);
+              }, 0);
+            }, Kh.prototype.addTextSection = function(y, I) {
+              this.text += y.text, this.sections.push(_y.forText(y.scale, y.fontStack || I));
+              for (var V = this.sections.length - 1, $ = 0; $ < y.text.length; ++$) this.sectionIndex.push(V);
+            }, Kh.prototype.addImageSection = function(y) {
+              var I = y.image ? y.image.name : "";
+              if (I.length === 0) {
+                re("Can't add FormattedSection with an empty image.");
+                return;
+              }
+              var V = this.getNextImageSectionCharCode();
+              if (!V) {
+                re("Reached maximum number of images " + (g0 - $w + 2));
+                return;
+              }
+              this.text += String.fromCharCode(V), this.sections.push(_y.forImage(I)), this.sectionIndex.push(this.sections.length - 1);
+            }, Kh.prototype.getNextImageSectionCharCode = function() {
+              return this.imageSectionID ? this.imageSectionID >= g0 ? null : ++this.imageSectionID : (this.imageSectionID = $w, this.imageSectionID);
+            };
+            function cO(m, y) {
+              for (var I = [], V = m.text, $ = 0, ae = 0, he = y; ae < he.length; ae += 1) {
+                var ze = he[ae];
+                I.push(m.substring($, ze)), $ = ze;
+              }
+              return $ < V.length && I.push(m.substring($, V.length)), I;
+            }
+            function Qw(m, y, I, V, $, ae, he, ze, rt, gt, Et, or, _r, pr, Fr, oi) {
+              var Hi = Kh.fromFeature(m, $);
+              or === uv.vertical && Hi.verticalizePunctuation();
+              var Ai, bn = Ms.processBidirectionalText, nn = Ms.processStyledBidirectionalText;
+              if (bn && Hi.sections.length === 1) {
+                Ai = [];
+                for (var xn = bn(Hi.toString(), e3(Hi, gt, ae, y, V, pr, Fr)), Pn = 0, Zn = xn; Pn < Zn.length; Pn += 1) {
+                  var ga = Zn[Pn], ha = new Kh();
+                  ha.text = ga, ha.sections = Hi.sections;
+                  for (var eo = 0; eo < ga.length; eo++) ha.sectionIndex.push(0);
+                  Ai.push(ha);
+                }
+              } else if (nn) {
+                Ai = [];
+                for (var za = nn(Hi.text, Hi.sectionIndex, e3(Hi, gt, ae, y, V, pr, Fr)), Za = 0, Jo = za; Za < Jo.length; Za += 1) {
+                  var to = Jo[Za], ao = new Kh();
+                  ao.text = to[0], ao.sectionIndex = to[1], ao.sections = Hi.sections, Ai.push(ao);
+                }
+              } else Ai = cO(Hi, e3(Hi, gt, ae, y, V, pr, Fr));
+              var _s = [], jo = { positionedLines: _s, text: Hi.toString(), top: Et[1], bottom: Et[1], left: Et[0], right: Et[0], writingMode: or, iconsInText: false, verticalizable: false };
+              return dO(jo, y, I, V, Ai, he, ze, rt, or, gt, _r, oi), kS(_s) ? false : jo;
+            }
+            var m0 = {};
+            m0[9] = true, m0[10] = true, m0[11] = true, m0[12] = true, m0[13] = true, m0[32] = true;
+            var cv = {};
+            cv[10] = true, cv[32] = true, cv[38] = true, cv[40] = true, cv[41] = true, cv[43] = true, cv[45] = true, cv[47] = true, cv[173] = true, cv[183] = true, cv[8203] = true, cv[8208] = true, cv[8211] = true, cv[8231] = true;
+            function r6(m, y, I, V, $, ae) {
+              if (y.imageName) {
+                var rt = V[y.imageName];
+                return rt ? rt.displaySize[0] * y.scale * Tn / ae + $ : 0;
+              } else {
+                var he = I[y.fontStack], ze = he && he[m];
+                return ze ? ze.metrics.advance * y.scale + $ : 0;
+              }
+            }
+            function fO(m, y, I, V, $, ae) {
+              for (var he = 0, ze = 0; ze < m.length(); ze++) {
+                var rt = m.getSection(ze);
+                he += r6(m.getCharCode(ze), rt, V, $, y, ae);
+              }
+              var gt = Math.max(1, Math.ceil(he / I));
+              return he / gt;
+            }
+            function i6(m, y, I, V) {
+              var $ = Math.pow(m - y, 2);
+              return V ? m < y ? $ / 2 : $ * 2 : $ + Math.abs(I) * I;
+            }
+            function hO(m, y, I) {
+              var V = 0;
+              return m === 10 && (V -= 1e4), I && (V += 150), (m === 40 || m === 65288) && (V += 50), (y === 41 || y === 65289) && (V += 50), V;
+            }
+            function _p(m, y, I, V, $, ae) {
+              for (var he = null, ze = i6(y, I, $, ae), rt = 0, gt = V; rt < gt.length; rt += 1) {
+                var Et = gt[rt], or = y - Et.x, _r = i6(or, I, $, ae) + Et.badness;
+                _r <= ze && (he = Et, ze = _r);
+              }
+              return { index: m, x: y, priorBreak: he, badness: ze };
+            }
+            function fb(m) {
+              return m ? fb(m.priorBreak).concat(m.index) : [];
+            }
+            function e3(m, y, I, V, $, ae, he) {
+              if (ae !== "point") return [];
+              if (!m) return [];
+              for (var ze = [], rt = fO(m, y, I, V, $, he), gt = m.text.indexOf("​") >= 0, Et = 0, or = 0; or < m.length(); or++) {
+                var _r = m.getSection(or), pr = m.getCharCode(or);
+                if (m0[pr] || (Et += r6(pr, _r, V, $, y, he)), or < m.length() - 1) {
+                  var Fr = Hr(pr);
+                  (cv[pr] || Fr || _r.imageName) && ze.push(_p(or + 1, Et, rt, ze, hO(pr, m.getCharCode(or + 1), Fr && gt), false));
+                }
+              }
+              return fb(_p(m.length(), Et, rt, ze, 0, true));
+            }
+            function CS(m) {
+              var y = 0.5, I = 0.5;
+              switch (m) {
+                case "right":
+                case "top-right":
+                case "bottom-right":
+                  y = 1;
+                  break;
+                case "left":
+                case "top-left":
+                case "bottom-left":
+                  y = 0;
+                  break;
+              }
+              switch (m) {
+                case "bottom":
+                case "bottom-right":
+                case "bottom-left":
+                  I = 1;
+                  break;
+                case "top":
+                case "top-right":
+                case "top-left":
+                  I = 0;
+                  break;
+              }
+              return { horizontalAlign: y, verticalAlign: I };
+            }
+            function dO(m, y, I, V, $, ae, he, ze, rt, gt, Et, or) {
+              for (var _r = 0, pr = B1, Fr = 0, oi = 0, Hi = ze === "right" ? 1 : ze === "left" ? 0 : 0.5, Ai = 0, bn = 0, nn = $; bn < nn.length; bn += 1) {
+                var xn = nn[bn];
+                xn.trim();
+                var Pn = xn.getMaxScale(), Zn = (Pn - 1) * Tn, ga = { positionedGlyphs: [], lineOffset: 0 };
+                m.positionedLines[Ai] = ga;
+                var ha = ga.positionedGlyphs, eo = 0;
+                if (!xn.length()) {
+                  pr += ae, ++Ai;
+                  continue;
+                }
+                for (var za = 0; za < xn.length(); za++) {
+                  var Za = xn.getSection(za), Jo = xn.getSectionIndex(za), to = xn.getCharCode(za), ao = 0, _s = null, jo = null, El = null, Iu = Tn, kl = !(rt === uv.horizontal || !Et && !qr(to) || Et && (m0[to] || Zr(to)));
+                  if (Za.imageName) {
+                    var Sf = V[Za.imageName];
+                    if (!Sf) continue;
+                    El = Za.imageName, m.iconsInText = m.iconsInText || true, jo = Sf.paddedRect;
+                    var Ff = Sf.displaySize;
+                    Za.scale = Za.scale * Tn / or, _s = { width: Ff[0], height: Ff[1], left: Gc, top: -3, advance: kl ? Ff[1] : Ff[0] };
+                    var $h = Tn - Ff[1] * Za.scale;
+                    ao = Zn + $h, Iu = _s.advance;
+                    var ch = kl ? Ff[0] * Za.scale - Tn * Pn : Ff[1] * Za.scale - Tn * Pn;
+                    ch > 0 && ch > eo && (eo = ch);
+                  } else {
+                    var Cl = I[Za.fontStack], yl = Cl && Cl[to];
+                    if (yl && yl.rect) jo = yl.rect, _s = yl.metrics;
+                    else {
+                      var Qu = y[Za.fontStack], gc = Qu && Qu[to];
+                      if (!gc) continue;
+                      _s = gc.metrics;
+                    }
+                    ao = (Pn - Za.scale) * Tn;
+                  }
+                  kl ? (m.verticalizable = true, ha.push({ glyph: to, imageName: El, x: _r, y: pr + ao, vertical: kl, scale: Za.scale, fontStack: Za.fontStack, sectionIndex: Jo, metrics: _s, rect: jo }), _r += Iu * Za.scale + gt) : (ha.push({ glyph: to, imageName: El, x: _r, y: pr + ao, vertical: kl, scale: Za.scale, fontStack: Za.fontStack, sectionIndex: Jo, metrics: _s, rect: jo }), _r += _s.advance * Za.scale + gt);
+                }
+                if (ha.length !== 0) {
+                  var Wd = _r - gt;
+                  Fr = Math.max(Wd, Fr), vO(ha, 0, ha.length - 1, Hi, eo);
+                }
+                _r = 0;
+                var Xd = ae * Pn + eo;
+                ga.lineOffset = Math.max(eo, Zn), pr += Xd, oi = Math.max(Xd, oi), ++Ai;
+              }
+              var Qh = pr - B1, fv = CS(he), hv = fv.horizontalAlign, Ph = fv.verticalAlign;
+              kd(m.positionedLines, Hi, hv, Ph, Fr, oi, ae, Qh, $.length), m.top += -Ph * Qh, m.bottom = m.top + Qh, m.left += -hv * Fr, m.right = m.left + Fr;
+            }
+            function vO(m, y, I, V, $) {
+              if (!(!V && !$)) for (var ae = m[I], he = ae.metrics.advance * ae.scale, ze = (m[I].x + he) * V, rt = y; rt <= I; rt++) m[rt].x -= ze, m[rt].y += $;
+            }
+            function kd(m, y, I, V, $, ae, he, ze, rt) {
+              var gt = (y - I) * $, Et = 0;
+              ae !== he ? Et = -ze * V - B1 : Et = (-V * rt + 0.5) * he;
+              for (var or = 0, _r = m; or < _r.length; or += 1) for (var pr = _r[or], Fr = 0, oi = pr.positionedGlyphs; Fr < oi.length; Fr += 1) {
+                var Hi = oi[Fr];
+                Hi.x += gt, Hi.y += Et;
+              }
+            }
+            function rp(m, y, I) {
+              var V = CS(I), $ = V.horizontalAlign, ae = V.verticalAlign, he = y[0], ze = y[1], rt = he - m.displaySize[0] * $, gt = rt + m.displaySize[0], Et = ze - m.displaySize[1] * ae, or = Et + m.displaySize[1];
+              return { image: m, top: Et, bottom: or, left: rt, right: gt };
+            }
+            function pm(m, y, I, V, $, ae) {
+              var he = m.image, ze;
+              if (he.content) {
+                var rt = he.content, gt = he.pixelRatio || 1;
+                ze = [rt[0] / gt, rt[1] / gt, he.displaySize[0] - rt[2] / gt, he.displaySize[1] - rt[3] / gt];
+              }
+              var Et = y.left * ae, or = y.right * ae, _r, pr, Fr, oi;
+              I === "width" || I === "both" ? (oi = $[0] + Et - V[3], pr = $[0] + or + V[1]) : (oi = $[0] + (Et + or - he.displaySize[0]) / 2, pr = oi + he.displaySize[0]);
+              var Hi = y.top * ae, Ai = y.bottom * ae;
+              return I === "height" || I === "both" ? (_r = $[1] + Hi - V[0], Fr = $[1] + Ai + V[2]) : (_r = $[1] + (Hi + Ai - he.displaySize[1]) / 2, Fr = _r + he.displaySize[1]), { image: he, top: _r, right: pr, bottom: Fr, left: oi, collisionPadding: ze };
+            }
+            var jd = function(m) {
+              function y(I, V, $, ae) {
+                m.call(this, I, V), this.angle = $, ae !== void 0 && (this.segment = ae);
+              }
+              return m && (y.__proto__ = m), y.prototype = Object.create(m && m.prototype), y.prototype.constructor = y, y.prototype.clone = function() {
+                return new y(this.x, this.y, this.angle, this.segment);
+              }, y;
+            }(u);
+            X("Anchor", jd);
+            var Cd = 128;
+            function xp(m, y) {
+              var I = y.expression;
+              if (I.kind === "constant") {
+                var V = I.evaluate(new Gn(m + 1));
+                return { kind: "constant", layoutSize: V };
+              } else {
+                if (I.kind === "source") return { kind: "source" };
+                for (var $ = I.zoomStops, ae = I.interpolationType, he = 0; he < $.length && $[he] <= m; ) he++;
+                he = Math.max(0, he - 1);
+                for (var ze = he; ze < $.length && $[ze] < m + 1; ) ze++;
+                ze = Math.min($.length - 1, ze);
+                var rt = $[he], gt = $[ze];
+                if (I.kind === "composite") return { kind: "composite", minZoom: rt, maxZoom: gt, interpolationType: ae };
+                var Et = I.evaluate(new Gn(rt)), or = I.evaluate(new Gn(gt));
+                return { kind: "camera", minZoom: rt, maxZoom: gt, minSize: Et, maxSize: or, interpolationType: ae };
+              }
+            }
+            function BQ(m, y, I) {
+              var V = y.uSize, $ = y.uSizeT, ae = I.lowerSize, he = I.upperSize;
+              return m.kind === "source" ? ae / Cd : m.kind === "composite" ? nl(ae / Cd, he / Cd, $) : V;
+            }
+            function NQ(m, y) {
+              var I = 0, V = 0;
+              if (m.kind === "constant") V = m.layoutSize;
+              else if (m.kind !== "source") {
+                var $ = m.interpolationType, ae = m.minZoom, he = m.maxZoom, ze = $ ? p(Wl.interpolationFactor($, y, ae, he), 0, 1) : 0;
+                m.kind === "camera" ? V = nl(m.minSize, m.maxSize, ze) : I = ze;
+              }
+              return { uSizeT: I, uSize: V };
+            }
+            var Ret = Object.freeze({ __proto__: null, getSizeData: xp, evaluateSizeForFeature: BQ, evaluateSizeForZoom: NQ, SIZE_PACK_FACTOR: Cd });
+            function UQ(m, y, I, V, $) {
+              if (y.segment === void 0) return true;
+              for (var ae = y, he = y.segment + 1, ze = 0; ze > -I / 2; ) {
+                if (he--, he < 0) return false;
+                ze -= m[he].dist(ae), ae = m[he];
+              }
+              ze += m[he].dist(m[he + 1]), he++;
+              for (var rt = [], gt = 0; ze < I / 2; ) {
+                var Et = m[he - 1], or = m[he], _r = m[he + 1];
+                if (!_r) return false;
+                var pr = Et.angleTo(or) - or.angleTo(_r);
+                for (pr = Math.abs((pr + 3 * Math.PI) % (Math.PI * 2) - Math.PI), rt.push({ distance: ze, angleDelta: pr }), gt += pr; ze - rt[0].distance > V; ) gt -= rt.shift().angleDelta;
+                if (gt > $) return false;
+                he++, ze += or.dist(_r);
+              }
+              return true;
+            }
+            function VQ(m) {
+              for (var y = 0, I = 0; I < m.length - 1; I++) y += m[I].dist(m[I + 1]);
+              return y;
+            }
+            function GQ(m, y, I) {
+              return m ? 3 / 5 * y * I : 0;
+            }
+            function HQ(m, y) {
+              return Math.max(m ? m.right - m.left : 0, y ? y.right - y.left : 0);
+            }
+            function Det(m, y, I, V, $, ae) {
+              for (var he = GQ(I, $, ae), ze = HQ(I, V) * ae, rt = 0, gt = VQ(m) / 2, Et = 0; Et < m.length - 1; Et++) {
+                var or = m[Et], _r = m[Et + 1], pr = or.dist(_r);
+                if (rt + pr > gt) {
+                  var Fr = (gt - rt) / pr, oi = nl(or.x, _r.x, Fr), Hi = nl(or.y, _r.y, Fr), Ai = new jd(oi, Hi, _r.angleTo(or), Et);
+                  return Ai._round(), !he || UQ(m, Ai, ze, he, y) ? Ai : void 0;
+                }
+                rt += pr;
+              }
+            }
+            function Fet(m, y, I, V, $, ae, he, ze, rt) {
+              var gt = GQ(V, ae, he), Et = HQ(V, $), or = Et * he, _r = m[0].x === 0 || m[0].x === rt || m[0].y === 0 || m[0].y === rt;
+              y - or < y / 4 && (y = or + y / 4);
+              var pr = ae * 2, Fr = _r ? y / 2 * ze % y : (Et / 2 + pr) * he * ze % y;
+              return jQ(m, Fr, y, gt, I, or, _r, false, rt);
+            }
+            function jQ(m, y, I, V, $, ae, he, ze, rt) {
+              for (var gt = ae / 2, Et = VQ(m), or = 0, _r = y - I, pr = [], Fr = 0; Fr < m.length - 1; Fr++) {
+                for (var oi = m[Fr], Hi = m[Fr + 1], Ai = oi.dist(Hi), bn = Hi.angleTo(oi); _r + I < or + Ai; ) {
+                  _r += I;
+                  var nn = (_r - or) / Ai, xn = nl(oi.x, Hi.x, nn), Pn = nl(oi.y, Hi.y, nn);
+                  if (xn >= 0 && xn < rt && Pn >= 0 && Pn < rt && _r - gt >= 0 && _r + gt <= Et) {
+                    var Zn = new jd(xn, Pn, bn, Fr);
+                    Zn._round(), (!V || UQ(m, Zn, ae, V, $)) && pr.push(Zn);
+                  }
+                }
+                or += Ai;
+              }
+              return !ze && !pr.length && !he && (pr = jQ(m, or / 2, I, V, $, ae, he, true, rt)), pr;
+            }
+            function WQ(m, y, I, V, $) {
+              for (var ae = [], he = 0; he < m.length; he++) for (var ze = m[he], rt = void 0, gt = 0; gt < ze.length - 1; gt++) {
+                var Et = ze[gt], or = ze[gt + 1];
+                Et.x < y && or.x < y || (Et.x < y ? Et = new u(y, Et.y + (or.y - Et.y) * ((y - Et.x) / (or.x - Et.x)))._round() : or.x < y && (or = new u(y, Et.y + (or.y - Et.y) * ((y - Et.x) / (or.x - Et.x)))._round()), !(Et.y < I && or.y < I) && (Et.y < I ? Et = new u(Et.x + (or.x - Et.x) * ((I - Et.y) / (or.y - Et.y)), I)._round() : or.y < I && (or = new u(Et.x + (or.x - Et.x) * ((I - Et.y) / (or.y - Et.y)), I)._round()), !(Et.x >= V && or.x >= V) && (Et.x >= V ? Et = new u(V, Et.y + (or.y - Et.y) * ((V - Et.x) / (or.x - Et.x)))._round() : or.x >= V && (or = new u(V, Et.y + (or.y - Et.y) * ((V - Et.x) / (or.x - Et.x)))._round()), !(Et.y >= $ && or.y >= $) && (Et.y >= $ ? Et = new u(Et.x + (or.x - Et.x) * (($ - Et.y) / (or.y - Et.y)), $)._round() : or.y >= $ && (or = new u(Et.x + (or.x - Et.x) * (($ - Et.y) / (or.y - Et.y)), $)._round()), (!rt || !Et.equals(rt[rt.length - 1])) && (rt = [Et], ae.push(rt)), rt.push(or)))));
+              }
+              return ae;
+            }
+            var t3 = Gc;
+            function XQ(m, y, I, V) {
+              var $ = [], ae = m.image, he = ae.pixelRatio, ze = ae.paddedRect.w - 2 * t3, rt = ae.paddedRect.h - 2 * t3, gt = m.right - m.left, Et = m.bottom - m.top, or = ae.stretchX || [[0, ze]], _r = ae.stretchY || [[0, rt]], pr = function(Cl, yl) {
+                return Cl + yl[1] - yl[0];
+              }, Fr = or.reduce(pr, 0), oi = _r.reduce(pr, 0), Hi = ze - Fr, Ai = rt - oi, bn = 0, nn = Fr, xn = 0, Pn = oi, Zn = 0, ga = Hi, ha = 0, eo = Ai;
+              if (ae.content && V) {
+                var za = ae.content;
+                bn = n6(or, 0, za[0]), xn = n6(_r, 0, za[1]), nn = n6(or, za[0], za[2]), Pn = n6(_r, za[1], za[3]), Zn = za[0] - bn, ha = za[1] - xn, ga = za[2] - za[0] - nn, eo = za[3] - za[1] - Pn;
+              }
+              var Za = function(Cl, yl, Qu, gc) {
+                var Sf = a6(Cl.stretch - bn, nn, gt, m.left), Ff = o6(Cl.fixed - Zn, ga, Cl.stretch, Fr), $h = a6(yl.stretch - xn, Pn, Et, m.top), ch = o6(yl.fixed - ha, eo, yl.stretch, oi), Wd = a6(Qu.stretch - bn, nn, gt, m.left), Xd = o6(Qu.fixed - Zn, ga, Qu.stretch, Fr), Qh = a6(gc.stretch - xn, Pn, Et, m.top), fv = o6(gc.fixed - ha, eo, gc.stretch, oi), hv = new u(Sf, $h), Ph = new u(Wd, $h), dv = new u(Wd, Qh), bp = new u(Sf, Qh), wy = new u(Ff / he, ch / he), V1 = new u(Xd / he, fv / he), G1 = y * Math.PI / 180;
+                if (G1) {
+                  var H1 = Math.sin(G1), u3 = Math.cos(G1), y0 = [u3, -H1, H1, u3];
+                  hv._matMult(y0), Ph._matMult(y0), bp._matMult(y0), dv._matMult(y0);
+                }
+                var h6 = Cl.stretch + Cl.fixed, wO = Qu.stretch + Qu.fixed, d6 = yl.stretch + yl.fixed, TO = gc.stretch + gc.fixed, Hp = { x: ae.paddedRect.x + t3 + h6, y: ae.paddedRect.y + t3 + d6, w: wO - h6, h: TO - d6 }, c3 = ga / he / gt, v6 = eo / he / Et;
+                return { tl: hv, tr: Ph, bl: bp, br: dv, tex: Hp, writingMode: void 0, glyphOffset: [0, 0], sectionIndex: 0, pixelOffsetTL: wy, pixelOffsetBR: V1, minFontScaleX: c3, minFontScaleY: v6, isSDF: I };
+              };
+              if (!V || !ae.stretchX && !ae.stretchY) $.push(Za({ fixed: 0, stretch: -1 }, { fixed: 0, stretch: -1 }, { fixed: 0, stretch: ze + 1 }, { fixed: 0, stretch: rt + 1 }));
+              else for (var Jo = ZQ(or, Hi, Fr), to = ZQ(_r, Ai, oi), ao = 0; ao < Jo.length - 1; ao++) for (var _s = Jo[ao], jo = Jo[ao + 1], El = 0; El < to.length - 1; El++) {
+                var Iu = to[El], kl = to[El + 1];
+                $.push(Za(_s, Iu, jo, kl));
+              }
+              return $;
+            }
+            function n6(m, y, I) {
+              for (var V = 0, $ = 0, ae = m; $ < ae.length; $ += 1) {
+                var he = ae[$];
+                V += Math.max(y, Math.min(I, he[1])) - Math.max(y, Math.min(I, he[0]));
+              }
+              return V;
+            }
+            function ZQ(m, y, I) {
+              for (var V = [{ fixed: -1, stretch: 0 }], $ = 0, ae = m; $ < ae.length; $ += 1) {
+                var he = ae[$], ze = he[0], rt = he[1], gt = V[V.length - 1];
+                V.push({ fixed: ze - gt.stretch, stretch: gt.stretch }), V.push({ fixed: ze - gt.stretch, stretch: gt.stretch + (rt - ze) });
+              }
+              return V.push({ fixed: y + t3, stretch: I }), V;
+            }
+            function a6(m, y, I, V) {
+              return m / y * I + V;
+            }
+            function o6(m, y, I, V) {
+              return m - y * I / V;
+            }
+            function zet(m, y, I, V, $, ae, he, ze) {
+              for (var rt = V.layout.get("text-rotate").evaluate(ae, {}) * Math.PI / 180, gt = [], Et = 0, or = y.positionedLines; Et < or.length; Et += 1) for (var _r = or[Et], pr = 0, Fr = _r.positionedGlyphs; pr < Fr.length; pr += 1) {
+                var oi = Fr[pr];
+                if (oi.rect) {
+                  var Hi = oi.rect || {}, Ai = 1, bn = Gp + Ai, nn = true, xn = 1, Pn = 0, Zn = ($ || ze) && oi.vertical, ga = oi.metrics.advance * oi.scale / 2;
+                  if (ze && y.verticalizable) {
+                    var ha = (oi.scale - 1) * Tn, eo = (Tn - oi.metrics.width * oi.scale) / 2;
+                    Pn = _r.lineOffset / 2 - (oi.imageName ? -eo : ha);
+                  }
+                  if (oi.imageName) {
+                    var za = he[oi.imageName];
+                    nn = za.sdf, xn = za.pixelRatio, bn = Gc / xn;
+                  }
+                  var Za = $ ? [oi.x + ga, oi.y] : [0, 0], Jo = $ ? [0, 0] : [oi.x + ga + I[0], oi.y + I[1] - Pn], to = [0, 0];
+                  Zn && (to = Jo, Jo = [0, 0]);
+                  var ao = (oi.metrics.left - bn) * oi.scale - ga + Jo[0], _s = (-oi.metrics.top - bn) * oi.scale + Jo[1], jo = ao + Hi.w * oi.scale / xn, El = _s + Hi.h * oi.scale / xn, Iu = new u(ao, _s), kl = new u(jo, _s), Cl = new u(ao, El), yl = new u(jo, El);
+                  if (Zn) {
+                    var Qu = new u(-ga, ga - B1), gc = -Math.PI / 2, Sf = Tn / 2 - ga, Ff = oi.imageName ? Sf : 0, $h = new u(5 - B1 - Sf, -Ff), ch = new (Function.prototype.bind.apply(u, [null].concat(to)))();
+                    Iu._rotateAround(gc, Qu)._add($h)._add(ch), kl._rotateAround(gc, Qu)._add($h)._add(ch), Cl._rotateAround(gc, Qu)._add($h)._add(ch), yl._rotateAround(gc, Qu)._add($h)._add(ch);
+                  }
+                  if (rt) {
+                    var Wd = Math.sin(rt), Xd = Math.cos(rt), Qh = [Xd, -Wd, Wd, Xd];
+                    Iu._matMult(Qh), kl._matMult(Qh), Cl._matMult(Qh), yl._matMult(Qh);
+                  }
+                  var fv = new u(0, 0), hv = new u(0, 0), Ph = 0, dv = 0;
+                  gt.push({ tl: Iu, tr: kl, bl: Cl, br: yl, tex: Hi, writingMode: y.writingMode, glyphOffset: Za, sectionIndex: oi.sectionIndex, isSDF: nn, pixelOffsetTL: fv, pixelOffsetBR: hv, minFontScaleX: Ph, minFontScaleY: dv });
+                }
+              }
+              return gt;
+            }
+            var s6 = function(y, I, V, $, ae, he, ze, rt, gt, Et) {
+              if (this.boxStartIndex = y.length, gt) {
+                var or = he.top, _r = he.bottom, pr = he.collisionPadding;
+                pr && (or -= pr[1], _r += pr[3]);
+                var Fr = _r - or;
+                Fr > 0 && (Fr = Math.max(10, Fr), this.circleDiameter = Fr);
+              } else {
+                var oi = he.top * ze - rt, Hi = he.bottom * ze + rt, Ai = he.left * ze - rt, bn = he.right * ze + rt, nn = he.collisionPadding;
+                if (nn && (Ai -= nn[0] * ze, oi -= nn[1] * ze, bn += nn[2] * ze, Hi += nn[3] * ze), Et) {
+                  var xn = new u(Ai, oi), Pn = new u(bn, oi), Zn = new u(Ai, Hi), ga = new u(bn, Hi), ha = Et * Math.PI / 180;
+                  xn._rotate(ha), Pn._rotate(ha), Zn._rotate(ha), ga._rotate(ha), Ai = Math.min(xn.x, Pn.x, Zn.x, ga.x), bn = Math.max(xn.x, Pn.x, Zn.x, ga.x), oi = Math.min(xn.y, Pn.y, Zn.y, ga.y), Hi = Math.max(xn.y, Pn.y, Zn.y, ga.y);
+                }
+                y.emplaceBack(I.x, I.y, Ai, oi, bn, Hi, V, $, ae);
+              }
+              this.boxEndIndex = y.length;
+            }, r3 = function(y, I) {
+              if (y === void 0 && (y = []), I === void 0 && (I = Oet), this.data = y, this.length = this.data.length, this.compare = I, this.length > 0) for (var V = (this.length >> 1) - 1; V >= 0; V--) this._down(V);
+            };
+            r3.prototype.push = function(y) {
+              this.data.push(y), this.length++, this._up(this.length - 1);
+            }, r3.prototype.pop = function() {
+              if (this.length !== 0) {
+                var y = this.data[0], I = this.data.pop();
+                return this.length--, this.length > 0 && (this.data[0] = I, this._down(0)), y;
+              }
+            }, r3.prototype.peek = function() {
+              return this.data[0];
+            }, r3.prototype._up = function(y) {
+              for (var I = this, V = I.data, $ = I.compare, ae = V[y]; y > 0; ) {
+                var he = y - 1 >> 1, ze = V[he];
+                if ($(ae, ze) >= 0) break;
+                V[y] = ze, y = he;
+              }
+              V[y] = ae;
+            }, r3.prototype._down = function(y) {
+              for (var I = this, V = I.data, $ = I.compare, ae = this.length >> 1, he = V[y]; y < ae; ) {
+                var ze = (y << 1) + 1, rt = V[ze], gt = ze + 1;
+                if (gt < this.length && $(V[gt], rt) < 0 && (ze = gt, rt = V[gt]), $(rt, he) >= 0) break;
+                V[y] = rt, y = ze;
+              }
+              V[y] = he;
+            };
+            function Oet(m, y) {
+              return m < y ? -1 : m > y ? 1 : 0;
+            }
+            function qet(m, y, I) {
+              I === void 0 && (I = false);
+              for (var V = 1 / 0, $ = 1 / 0, ae = -1 / 0, he = -1 / 0, ze = m[0], rt = 0; rt < ze.length; rt++) {
+                var gt = ze[rt];
+                (!rt || gt.x < V) && (V = gt.x), (!rt || gt.y < $) && ($ = gt.y), (!rt || gt.x > ae) && (ae = gt.x), (!rt || gt.y > he) && (he = gt.y);
+              }
+              var Et = ae - V, or = he - $, _r = Math.min(Et, or), pr = _r / 2, Fr = new r3([], Bet);
+              if (_r === 0) return new u(V, $);
+              for (var oi = V; oi < ae; oi += _r) for (var Hi = $; Hi < he; Hi += _r) Fr.push(new i3(oi + pr, Hi + pr, pr, m));
+              for (var Ai = Uet(m), bn = Fr.length; Fr.length; ) {
+                var nn = Fr.pop();
+                (nn.d > Ai.d || !Ai.d) && (Ai = nn, I && console.log("found best %d after %d probes", Math.round(1e4 * nn.d) / 1e4, bn)), !(nn.max - Ai.d <= y) && (pr = nn.h / 2, Fr.push(new i3(nn.p.x - pr, nn.p.y - pr, pr, m)), Fr.push(new i3(nn.p.x + pr, nn.p.y - pr, pr, m)), Fr.push(new i3(nn.p.x - pr, nn.p.y + pr, pr, m)), Fr.push(new i3(nn.p.x + pr, nn.p.y + pr, pr, m)), bn += 4);
+              }
+              return I && (console.log("num probes: " + bn), console.log("best distance: " + Ai.d)), Ai.p;
+            }
+            function Bet(m, y) {
+              return y.max - m.max;
+            }
+            function i3(m, y, I, V) {
+              this.p = new u(m, y), this.h = I, this.d = Net(this.p, V), this.max = this.d + this.h * Math.SQRT2;
+            }
+            function Net(m, y) {
+              for (var I = false, V = 1 / 0, $ = 0; $ < y.length; $++) for (var ae = y[$], he = 0, ze = ae.length, rt = ze - 1; he < ze; rt = he++) {
+                var gt = ae[he], Et = ae[rt];
+                gt.y > m.y != Et.y > m.y && m.x < (Et.x - gt.x) * (m.y - gt.y) / (Et.y - gt.y) + gt.x && (I = !I), V = Math.min(V, hg(m, gt, Et));
+              }
+              return (I ? 1 : -1) * Math.sqrt(V);
+            }
+            function Uet(m) {
+              for (var y = 0, I = 0, V = 0, $ = m[0], ae = 0, he = $.length, ze = he - 1; ae < he; ze = ae++) {
+                var rt = $[ae], gt = $[ze], Et = rt.x * gt.y - gt.x * rt.y;
+                I += (rt.x + gt.x) * Et, V += (rt.y + gt.y) * Et, y += Et * 3;
+              }
+              return new i3(I / y, V / y, 0, m);
+            }
+            var n3 = 7, pO = Number.POSITIVE_INFINITY;
+            function YQ(m, y) {
+              function I($, ae) {
+                var he = 0, ze = 0;
+                ae < 0 && (ae = 0);
+                var rt = ae / Math.sqrt(2);
+                switch ($) {
+                  case "top-right":
+                  case "top-left":
+                    ze = rt - n3;
+                    break;
+                  case "bottom-right":
+                  case "bottom-left":
+                    ze = -rt + n3;
+                    break;
+                  case "bottom":
+                    ze = -ae + n3;
+                    break;
+                  case "top":
+                    ze = ae - n3;
+                    break;
+                }
+                switch ($) {
+                  case "top-right":
+                  case "bottom-right":
+                    he = -rt;
+                    break;
+                  case "top-left":
+                  case "bottom-left":
+                    he = rt;
+                    break;
+                  case "left":
+                    he = ae;
+                    break;
+                  case "right":
+                    he = -ae;
+                    break;
+                }
+                return [he, ze];
+              }
+              function V($, ae, he) {
+                var ze = 0, rt = 0;
+                switch (ae = Math.abs(ae), he = Math.abs(he), $) {
+                  case "top-right":
+                  case "top-left":
+                  case "top":
+                    rt = he - n3;
+                    break;
+                  case "bottom-right":
+                  case "bottom-left":
+                  case "bottom":
+                    rt = -he + n3;
+                    break;
+                }
+                switch ($) {
+                  case "top-right":
+                  case "bottom-right":
+                  case "right":
+                    ze = -ae;
+                    break;
+                  case "top-left":
+                  case "bottom-left":
+                  case "left":
+                    ze = ae;
+                    break;
+                }
+                return [ze, rt];
+              }
+              return y[1] !== pO ? V(m, y[0], y[1]) : I(m, y[0]);
+            }
+            function Vet(m, y, I, V, $, ae, he) {
+              m.createArrays();
+              var ze = 512 * m.overscaling;
+              m.tilePixelRatio = Ci / ze, m.compareText = {}, m.iconsNeedLinear = false;
+              var rt = m.layers[0].layout, gt = m.layers[0]._unevaluatedLayout._values, Et = {};
+              if (m.textSizeData.kind === "composite") {
+                var or = m.textSizeData, _r = or.minZoom, pr = or.maxZoom;
+                Et.compositeTextSizes = [gt["text-size"].possiblyEvaluate(new Gn(_r), he), gt["text-size"].possiblyEvaluate(new Gn(pr), he)];
+              }
+              if (m.iconSizeData.kind === "composite") {
+                var Fr = m.iconSizeData, oi = Fr.minZoom, Hi = Fr.maxZoom;
+                Et.compositeIconSizes = [gt["icon-size"].possiblyEvaluate(new Gn(oi), he), gt["icon-size"].possiblyEvaluate(new Gn(Hi), he)];
+              }
+              Et.layoutTextSize = gt["text-size"].possiblyEvaluate(new Gn(m.zoom + 1), he), Et.layoutIconSize = gt["icon-size"].possiblyEvaluate(new Gn(m.zoom + 1), he), Et.textMaxSize = gt["text-size"].possiblyEvaluate(new Gn(18));
+              for (var Ai = rt.get("text-line-height") * Tn, bn = rt.get("text-rotation-alignment") === "map" && rt.get("symbol-placement") !== "point", nn = rt.get("text-keep-upright"), xn = rt.get("text-size"), Pn = function() {
+                var ha = ga[Zn], eo = rt.get("text-font").evaluate(ha, {}, he).join(","), za = xn.evaluate(ha, {}, he), Za = Et.layoutTextSize.evaluate(ha, {}, he), Jo = Et.layoutIconSize.evaluate(ha, {}, he), to = { horizontal: {}, vertical: void 0 }, ao = ha.text, _s = [0, 0];
+                if (ao) {
+                  var jo = ao.toString(), El = rt.get("text-letter-spacing").evaluate(ha, {}, he) * Tn, Iu = gr(jo) ? El : 0, kl = rt.get("text-anchor").evaluate(ha, {}, he), Cl = rt.get("text-variable-anchor");
+                  if (!Cl) {
+                    var yl = rt.get("text-radial-offset").evaluate(ha, {}, he);
+                    yl ? _s = YQ(kl, [yl * Tn, pO]) : _s = rt.get("text-offset").evaluate(ha, {}, he).map(function(wy) {
+                      return wy * Tn;
+                    });
+                  }
+                  var Qu = bn ? "center" : rt.get("text-justify").evaluate(ha, {}, he), gc = rt.get("symbol-placement"), Sf = gc === "point" ? rt.get("text-max-width").evaluate(ha, {}, he) * Tn : 0, Ff = function() {
+                    m.allowVerticalPlacement && jt(jo) && (to.vertical = Qw(ao, y, I, $, eo, Sf, Ai, kl, "left", Iu, _s, uv.vertical, true, gc, Za, za));
+                  };
+                  if (!bn && Cl) {
+                    for (var $h = Qu === "auto" ? Cl.map(function(wy) {
+                      return gO(wy);
+                    }) : [Qu], ch = false, Wd = 0; Wd < $h.length; Wd++) {
+                      var Xd = $h[Wd];
+                      if (!to.horizontal[Xd]) if (ch) to.horizontal[Xd] = to.horizontal[0];
+                      else {
+                        var Qh = Qw(ao, y, I, $, eo, Sf, Ai, "center", Xd, Iu, _s, uv.horizontal, false, gc, Za, za);
+                        Qh && (to.horizontal[Xd] = Qh, ch = Qh.positionedLines.length === 1);
+                      }
+                    }
+                    Ff();
+                  } else {
+                    Qu === "auto" && (Qu = gO(kl));
+                    var fv = Qw(ao, y, I, $, eo, Sf, Ai, kl, Qu, Iu, _s, uv.horizontal, false, gc, Za, za);
+                    fv && (to.horizontal[Qu] = fv), Ff(), jt(jo) && bn && nn && (to.vertical = Qw(ao, y, I, $, eo, Sf, Ai, kl, Qu, Iu, _s, uv.vertical, false, gc, Za, za));
+                  }
+                }
+                var hv = void 0, Ph = false;
+                if (ha.icon && ha.icon.name) {
+                  var dv = V[ha.icon.name];
+                  dv && (hv = rp($[ha.icon.name], rt.get("icon-offset").evaluate(ha, {}, he), rt.get("icon-anchor").evaluate(ha, {}, he)), Ph = dv.sdf, m.sdfIcons === void 0 ? m.sdfIcons = dv.sdf : m.sdfIcons !== dv.sdf && re("Style sheet warning: Cannot mix SDF and non-SDF icons in one buffer"), (dv.pixelRatio !== m.pixelRatio || rt.get("icon-rotate").constantOr(1) !== 0) && (m.iconsNeedLinear = true));
+                }
+                var bp = JQ(to.horizontal) || to.vertical;
+                m.iconsInText = bp ? bp.iconsInText : false, (bp || hv) && Get(m, ha, to, hv, V, Et, Za, Jo, _s, Ph, he);
+              }, Zn = 0, ga = m.features; Zn < ga.length; Zn += 1) Pn();
+              ae && m.generateCollisionDebugBuffers();
+            }
+            function gO(m) {
+              switch (m) {
+                case "right":
+                case "top-right":
+                case "bottom-right":
+                  return "right";
+                case "left":
+                case "top-left":
+                case "bottom-left":
+                  return "left";
+              }
+              return "center";
+            }
+            function Get(m, y, I, V, $, ae, he, ze, rt, gt, Et) {
+              var or = ae.textMaxSize.evaluate(y, {});
+              or === void 0 && (or = he);
+              var _r = m.layers[0].layout, pr = _r.get("icon-offset").evaluate(y, {}, Et), Fr = JQ(I.horizontal), oi = 24, Hi = he / oi, Ai = m.tilePixelRatio * Hi, bn = m.tilePixelRatio * or / oi, nn = m.tilePixelRatio * ze, xn = m.tilePixelRatio * _r.get("symbol-spacing"), Pn = _r.get("text-padding") * m.tilePixelRatio, Zn = _r.get("icon-padding") * m.tilePixelRatio, ga = _r.get("text-max-angle") / 180 * Math.PI, ha = _r.get("text-rotation-alignment") === "map" && _r.get("symbol-placement") !== "point", eo = _r.get("icon-rotation-alignment") === "map" && _r.get("symbol-placement") !== "point", za = _r.get("symbol-placement"), Za = xn / 2, Jo = _r.get("icon-text-fit"), to;
+              V && Jo !== "none" && (m.allowVerticalPlacement && I.vertical && (to = pm(V, I.vertical, Jo, _r.get("icon-text-fit-padding"), pr, Hi)), Fr && (V = pm(V, Fr, Jo, _r.get("icon-text-fit-padding"), pr, Hi)));
+              var ao = function(u3, y0) {
+                y0.x < 0 || y0.x >= Ci || y0.y < 0 || y0.y >= Ci || Het(m, y0, u3, I, V, $, to, m.layers[0], m.collisionBoxArray, y.index, y.sourceLayerIndex, m.index, Ai, Pn, ha, rt, nn, Zn, eo, pr, y, ae, gt, Et, he);
+              };
+              if (za === "line") for (var _s = 0, jo = WQ(y.geometry, 0, 0, Ci, Ci); _s < jo.length; _s += 1) for (var El = jo[_s], Iu = Fet(El, xn, ga, I.vertical || Fr, V, oi, bn, m.overscaling, Ci), kl = 0, Cl = Iu; kl < Cl.length; kl += 1) {
+                var yl = Cl[kl], Qu = Fr;
+                (!Qu || !jet(m, Qu.text, Za, yl)) && ao(El, yl);
+              }
+              else if (za === "line-center") for (var gc = 0, Sf = y.geometry; gc < Sf.length; gc += 1) {
+                var Ff = Sf[gc];
+                if (Ff.length > 1) {
+                  var $h = Det(Ff, ga, I.vertical || Fr, V, oi, bn);
+                  $h && ao(Ff, $h);
+                }
+              }
+              else if (y.type === "Polygon") for (var ch = 0, Wd = Ww(y.geometry, 0); ch < Wd.length; ch += 1) {
+                var Xd = Wd[ch], Qh = qet(Xd, 16);
+                ao(Xd[0], new jd(Qh.x, Qh.y, 0));
+              }
+              else if (y.type === "LineString") for (var fv = 0, hv = y.geometry; fv < hv.length; fv += 1) {
+                var Ph = hv[fv];
+                ao(Ph, new jd(Ph[0].x, Ph[0].y, 0));
+              }
+              else if (y.type === "Point") for (var dv = 0, bp = y.geometry; dv < bp.length; dv += 1) for (var wy = bp[dv], V1 = 0, G1 = wy; V1 < G1.length; V1 += 1) {
+                var H1 = G1[V1];
+                ao([H1], new jd(H1.x, H1.y, 0));
+              }
+            }
+            var LS = 255, N1 = LS * Cd;
+            function KQ(m, y, I, V, $, ae, he, ze, rt, gt, Et, or, _r, pr, Fr) {
+              var oi = zet(y, I, ze, $, ae, he, V, m.allowVerticalPlacement), Hi = m.textSizeData, Ai = null;
+              Hi.kind === "source" ? (Ai = [Cd * $.layout.get("text-size").evaluate(he, {})], Ai[0] > N1 && re(m.layerIds[0] + ': Value for "text-size" is >= ' + LS + '. Reduce your "text-size".')) : Hi.kind === "composite" && (Ai = [Cd * pr.compositeTextSizes[0].evaluate(he, {}, Fr), Cd * pr.compositeTextSizes[1].evaluate(he, {}, Fr)], (Ai[0] > N1 || Ai[1] > N1) && re(m.layerIds[0] + ': Value for "text-size" is >= ' + LS + '. Reduce your "text-size".')), m.addSymbols(m.text, oi, Ai, ze, ae, he, gt, y, rt.lineStartIndex, rt.lineLength, _r, Fr);
+              for (var bn = 0, nn = Et; bn < nn.length; bn += 1) {
+                var xn = nn[bn];
+                or[xn] = m.text.placedSymbolArray.length - 1;
+              }
+              return oi.length * 4;
+            }
+            function JQ(m) {
+              for (var y in m) return m[y];
+              return null;
+            }
+            function Het(m, y, I, V, $, ae, he, ze, rt, gt, Et, or, _r, pr, Fr, oi, Hi, Ai, bn, nn, xn, Pn, Zn, ga, ha) {
+              var eo, za = m.addToLineVertexArray(y, I), Za, Jo, to, ao, _s = 0, jo = 0, El = 0, Iu = 0, kl = -1, Cl = -1, yl = {}, Qu = K(""), gc = 0, Sf = 0;
+              if (ze._unevaluatedLayout.getValue("text-radial-offset") === void 0 ? (eo = ze.layout.get("text-offset").evaluate(xn, {}, ga).map(function(RS) {
+                return RS * Tn;
+              }), gc = eo[0], Sf = eo[1]) : (gc = ze.layout.get("text-radial-offset").evaluate(xn, {}, ga) * Tn, Sf = pO), m.allowVerticalPlacement && V.vertical) {
+                var Ff = ze.layout.get("text-rotate").evaluate(xn, {}, ga), $h = Ff + 90, ch = V.vertical;
+                to = new s6(rt, y, gt, Et, or, ch, _r, pr, Fr, $h), he && (ao = new s6(rt, y, gt, Et, or, he, Hi, Ai, Fr, $h));
+              }
+              if ($) {
+                var Wd = ze.layout.get("icon-rotate").evaluate(xn, {}), Xd = ze.layout.get("icon-text-fit") !== "none", Qh = XQ($, Wd, Zn, Xd), fv = he ? XQ(he, Wd, Zn, Xd) : void 0;
+                Jo = new s6(rt, y, gt, Et, or, $, Hi, Ai, false, Wd), _s = Qh.length * 4;
+                var hv = m.iconSizeData, Ph = null;
+                hv.kind === "source" ? (Ph = [Cd * ze.layout.get("icon-size").evaluate(xn, {})], Ph[0] > N1 && re(m.layerIds[0] + ': Value for "icon-size" is >= ' + LS + '. Reduce your "icon-size".')) : hv.kind === "composite" && (Ph = [Cd * Pn.compositeIconSizes[0].evaluate(xn, {}, ga), Cd * Pn.compositeIconSizes[1].evaluate(xn, {}, ga)], (Ph[0] > N1 || Ph[1] > N1) && re(m.layerIds[0] + ': Value for "icon-size" is >= ' + LS + '. Reduce your "icon-size".')), m.addSymbols(m.icon, Qh, Ph, nn, bn, xn, false, y, za.lineStartIndex, za.lineLength, -1, ga), kl = m.icon.placedSymbolArray.length - 1, fv && (jo = fv.length * 4, m.addSymbols(m.icon, fv, Ph, nn, bn, xn, uv.vertical, y, za.lineStartIndex, za.lineLength, -1, ga), Cl = m.icon.placedSymbolArray.length - 1);
+              }
+              for (var dv in V.horizontal) {
+                var bp = V.horizontal[dv];
+                if (!Za) {
+                  Qu = K(bp.text);
+                  var wy = ze.layout.get("text-rotate").evaluate(xn, {}, ga);
+                  Za = new s6(rt, y, gt, Et, or, bp, _r, pr, Fr, wy);
+                }
+                var V1 = bp.positionedLines.length === 1;
+                if (El += KQ(m, y, bp, ae, ze, Fr, xn, oi, za, V.vertical ? uv.horizontal : uv.horizontalOnly, V1 ? Object.keys(V.horizontal) : [dv], yl, kl, Pn, ga), V1) break;
+              }
+              V.vertical && (Iu += KQ(m, y, V.vertical, ae, ze, Fr, xn, oi, za, uv.vertical, ["vertical"], yl, Cl, Pn, ga));
+              var G1 = Za ? Za.boxStartIndex : m.collisionBoxArray.length, H1 = Za ? Za.boxEndIndex : m.collisionBoxArray.length, u3 = to ? to.boxStartIndex : m.collisionBoxArray.length, y0 = to ? to.boxEndIndex : m.collisionBoxArray.length, h6 = Jo ? Jo.boxStartIndex : m.collisionBoxArray.length, wO = Jo ? Jo.boxEndIndex : m.collisionBoxArray.length, d6 = ao ? ao.boxStartIndex : m.collisionBoxArray.length, TO = ao ? ao.boxEndIndex : m.collisionBoxArray.length, Hp = -1, c3 = function(RS, dee) {
+                return RS && RS.circleDiameter ? Math.max(RS.circleDiameter, dee) : dee;
+              };
+              Hp = c3(Za, Hp), Hp = c3(to, Hp), Hp = c3(Jo, Hp), Hp = c3(ao, Hp);
+              var v6 = Hp > -1 ? 1 : 0;
+              v6 && (Hp *= ha / Tn), m.glyphOffsetArray.length >= Pu.MAX_GLYPHS && re("Too many glyphs being rendered in a tile. See https://github.com/mapbox/mapbox-gl-js/issues/2907"), xn.sortKey !== void 0 && m.addToSortKeyRanges(m.symbolInstances.length, xn.sortKey), m.symbolInstances.emplaceBack(y.x, y.y, yl.right >= 0 ? yl.right : -1, yl.center >= 0 ? yl.center : -1, yl.left >= 0 ? yl.left : -1, yl.vertical || -1, kl, Cl, Qu, G1, H1, u3, y0, h6, wO, d6, TO, gt, El, Iu, _s, jo, v6, 0, _r, gc, Sf, Hp);
+            }
+            function jet(m, y, I, V) {
+              var $ = m.compareText;
+              if (!(y in $)) $[y] = [];
+              else for (var ae = $[y], he = ae.length - 1; he >= 0; he--) if (V.dist(ae[he]) < I) return true;
+              return $[y].push(V), false;
+            }
+            var Wet = mg.VectorTileFeature.types, Xet = [{ name: "a_fade_opacity", components: 1, type: "Uint8", offset: 0 }];
+            function l6(m, y, I, V, $, ae, he, ze, rt, gt, Et, or, _r) {
+              var pr = ze ? Math.min(N1, Math.round(ze[0])) : 0, Fr = ze ? Math.min(N1, Math.round(ze[1])) : 0;
+              m.emplaceBack(y, I, Math.round(V * 32), Math.round($ * 32), ae, he, (pr << 1) + (rt ? 1 : 0), Fr, gt * 16, Et * 16, or * 256, _r * 256);
+            }
+            function mO(m, y, I) {
+              m.emplaceBack(y.x, y.y, I), m.emplaceBack(y.x, y.y, I), m.emplaceBack(y.x, y.y, I), m.emplaceBack(y.x, y.y, I);
+            }
+            function Zet(m) {
+              for (var y = 0, I = m.sections; y < I.length; y += 1) {
+                var V = I[y];
+                if (Ii(V.text)) return true;
+              }
+              return false;
+            }
+            var a3 = function(y) {
+              this.layoutVertexArray = new Bn(), this.indexArray = new pn(), this.programConfigurations = y, this.segments = new io(), this.dynamicLayoutVertexArray = new hi(), this.opacityVertexArray = new li(), this.placedSymbolArray = new zo();
+            };
+            a3.prototype.isEmpty = function() {
+              return this.layoutVertexArray.length === 0 && this.indexArray.length === 0 && this.dynamicLayoutVertexArray.length === 0 && this.opacityVertexArray.length === 0;
+            }, a3.prototype.upload = function(y, I, V, $) {
+              this.isEmpty() || (V && (this.layoutVertexBuffer = y.createVertexBuffer(this.layoutVertexArray, te.members), this.indexBuffer = y.createIndexBuffer(this.indexArray, I), this.dynamicLayoutVertexBuffer = y.createVertexBuffer(this.dynamicLayoutVertexArray, fe.members, true), this.opacityVertexBuffer = y.createVertexBuffer(this.opacityVertexArray, Xet, true), this.opacityVertexBuffer.itemSize = 1), (V || $) && this.programConfigurations.upload(y));
+            }, a3.prototype.destroy = function() {
+              this.layoutVertexBuffer && (this.layoutVertexBuffer.destroy(), this.indexBuffer.destroy(), this.programConfigurations.destroy(), this.segments.destroy(), this.dynamicLayoutVertexBuffer.destroy(), this.opacityVertexBuffer.destroy());
+            }, X("SymbolBuffers", a3);
+            var PS = function(y, I, V) {
+              this.layoutVertexArray = new y(), this.layoutAttributes = I, this.indexArray = new V(), this.segments = new io(), this.collisionVertexArray = new Ni();
+            };
+            PS.prototype.upload = function(y) {
+              this.layoutVertexBuffer = y.createVertexBuffer(this.layoutVertexArray, this.layoutAttributes), this.indexBuffer = y.createIndexBuffer(this.indexArray), this.collisionVertexBuffer = y.createVertexBuffer(this.collisionVertexArray, Fe.members, true);
+            }, PS.prototype.destroy = function() {
+              this.layoutVertexBuffer && (this.layoutVertexBuffer.destroy(), this.indexBuffer.destroy(), this.segments.destroy(), this.collisionVertexBuffer.destroy());
+            }, X("CollisionBuffers", PS);
+            var Pu = function(y) {
+              this.collisionBoxArray = y.collisionBoxArray, this.zoom = y.zoom, this.overscaling = y.overscaling, this.layers = y.layers, this.layerIds = this.layers.map(function(rt) {
+                return rt.id;
+              }), this.index = y.index, this.pixelRatio = y.pixelRatio, this.sourceLayerIndex = y.sourceLayerIndex, this.hasPattern = false, this.hasRTLText = false, this.sortKeyRanges = [], this.collisionCircleArray = [], this.placementInvProjMatrix = dy([]), this.placementViewportMatrix = dy([]);
+              var I = this.layers[0], V = I._unevaluatedLayout._values;
+              this.textSizeData = xp(this.zoom, V["text-size"]), this.iconSizeData = xp(this.zoom, V["icon-size"]);
+              var $ = this.layers[0].layout, ae = $.get("symbol-sort-key"), he = $.get("symbol-z-order");
+              this.canOverlap = $.get("text-allow-overlap") || $.get("icon-allow-overlap") || $.get("text-ignore-placement") || $.get("icon-ignore-placement"), this.sortFeaturesByKey = he !== "viewport-y" && ae.constantOr(1) !== void 0;
+              var ze = he === "viewport-y" || he === "auto" && !this.sortFeaturesByKey;
+              this.sortFeaturesByY = ze && this.canOverlap, $.get("symbol-placement") === "point" && (this.writingModes = $.get("text-writing-mode").map(function(rt) {
+                return uv[rt];
+              })), this.stateDependentLayerIds = this.layers.filter(function(rt) {
+                return rt.isStateDependent();
+              }).map(function(rt) {
+                return rt.id;
+              }), this.sourceID = y.sourceID;
+            };
+            Pu.prototype.createArrays = function() {
+              this.text = new a3(new fi(this.layers, this.zoom, function(y) {
+                return /^text/.test(y);
+              })), this.icon = new a3(new fi(this.layers, this.zoom, function(y) {
+                return /^icon/.test(y);
+              })), this.glyphOffsetArray = new Vl(), this.lineVertexArray = new ss(), this.symbolInstances = new al();
+            }, Pu.prototype.calculateGlyphDependencies = function(y, I, V, $, ae) {
+              for (var he = 0; he < y.length; he++) if (I[y.charCodeAt(he)] = true, (V || $) && ae) {
+                var ze = zi[y.charAt(he)];
+                ze && (I[ze.charCodeAt(0)] = true);
+              }
+            }, Pu.prototype.populate = function(y, I, V) {
+              var $ = this.layers[0], ae = $.layout, he = ae.get("text-font"), ze = ae.get("text-field"), rt = ae.get("icon-image"), gt = (ze.value.kind !== "constant" || ze.value.value instanceof $l && !ze.value.value.isEmpty() || ze.value.value.toString().length > 0) && (he.value.kind !== "constant" || he.value.value.length > 0), Et = rt.value.kind !== "constant" || !!rt.value.value || Object.keys(rt.parameters).length > 0, or = ae.get("symbol-sort-key");
+              if (this.features = [], !(!gt && !Et)) {
+                for (var _r = I.iconDependencies, pr = I.glyphDependencies, Fr = I.availableImages, oi = new Gn(this.zoom), Hi = 0, Ai = y; Hi < Ai.length; Hi += 1) {
+                  var bn = Ai[Hi], nn = bn.feature, xn = bn.id, Pn = bn.index, Zn = bn.sourceLayerIndex, ga = $._featureFilter.needGeometry, ha = Ja(nn, ga);
+                  if ($._featureFilter.filter(oi, ha, V)) {
+                    ga || (ha.geometry = zn(nn));
+                    var eo = void 0;
+                    if (gt) {
+                      var za = $.getValueAndResolveTokens("text-field", ha, V, Fr), Za = $l.factory(za);
+                      Zet(Za) && (this.hasRTLText = true), (!this.hasRTLText || yo() === "unavailable" || this.hasRTLText && Ms.isParsed()) && (eo = yi(Za, $, ha));
+                    }
+                    var Jo = void 0;
+                    if (Et) {
+                      var to = $.getValueAndResolveTokens("icon-image", ha, V, Fr);
+                      to instanceof fl ? Jo = to : Jo = fl.fromString(to);
+                    }
+                    if (!(!eo && !Jo)) {
+                      var ao = this.sortFeaturesByKey ? or.evaluate(ha, {}, V) : void 0, _s = { id: xn, text: eo, icon: Jo, index: Pn, sourceLayerIndex: Zn, geometry: ha.geometry, properties: nn.properties, type: Wet[nn.type], sortKey: ao };
+                      if (this.features.push(_s), Jo && (_r[Jo.name] = true), eo) {
+                        var jo = he.evaluate(ha, {}, V).join(","), El = ae.get("text-rotation-alignment") === "map" && ae.get("symbol-placement") !== "point";
+                        this.allowVerticalPlacement = this.writingModes && this.writingModes.indexOf(uv.vertical) >= 0;
+                        for (var Iu = 0, kl = eo.sections; Iu < kl.length; Iu += 1) {
+                          var Cl = kl[Iu];
+                          if (Cl.image) _r[Cl.image.name] = true;
+                          else {
+                            var yl = jt(eo.toString()), Qu = Cl.fontStack || jo, gc = pr[Qu] = pr[Qu] || {};
+                            this.calculateGlyphDependencies(Cl.text, gc, El, this.allowVerticalPlacement, yl);
+                          }
+                        }
+                      }
+                    }
+                  }
+                }
+                ae.get("symbol-placement") === "line" && (this.features = vn(this.features)), this.sortFeaturesByKey && this.features.sort(function(Sf, Ff) {
+                  return Sf.sortKey - Ff.sortKey;
+                });
+              }
+            }, Pu.prototype.update = function(y, I, V) {
+              this.stateDependentLayers.length && (this.text.programConfigurations.updatePaintArrays(y, I, this.layers, V), this.icon.programConfigurations.updatePaintArrays(y, I, this.layers, V));
+            }, Pu.prototype.isEmpty = function() {
+              return this.symbolInstances.length === 0 && !this.hasRTLText;
+            }, Pu.prototype.uploadPending = function() {
+              return !this.uploaded || this.text.programConfigurations.needsUpload || this.icon.programConfigurations.needsUpload;
+            }, Pu.prototype.upload = function(y) {
+              !this.uploaded && this.hasDebugData() && (this.textCollisionBox.upload(y), this.iconCollisionBox.upload(y)), this.text.upload(y, this.sortFeaturesByY, !this.uploaded, this.text.programConfigurations.needsUpload), this.icon.upload(y, this.sortFeaturesByY, !this.uploaded, this.icon.programConfigurations.needsUpload), this.uploaded = true;
+            }, Pu.prototype.destroyDebugData = function() {
+              this.textCollisionBox.destroy(), this.iconCollisionBox.destroy();
+            }, Pu.prototype.destroy = function() {
+              this.text.destroy(), this.icon.destroy(), this.hasDebugData() && this.destroyDebugData();
+            }, Pu.prototype.addToLineVertexArray = function(y, I) {
+              var V = this.lineVertexArray.length;
+              if (y.segment !== void 0) {
+                for (var $ = y.dist(I[y.segment + 1]), ae = y.dist(I[y.segment]), he = {}, ze = y.segment + 1; ze < I.length; ze++) he[ze] = { x: I[ze].x, y: I[ze].y, tileUnitDistanceFromAnchor: $ }, ze < I.length - 1 && ($ += I[ze + 1].dist(I[ze]));
+                for (var rt = y.segment || 0; rt >= 0; rt--) he[rt] = { x: I[rt].x, y: I[rt].y, tileUnitDistanceFromAnchor: ae }, rt > 0 && (ae += I[rt - 1].dist(I[rt]));
+                for (var gt = 0; gt < I.length; gt++) {
+                  var Et = he[gt];
+                  this.lineVertexArray.emplaceBack(Et.x, Et.y, Et.tileUnitDistanceFromAnchor);
+                }
+              }
+              return { lineStartIndex: V, lineLength: this.lineVertexArray.length - V };
+            }, Pu.prototype.addSymbols = function(y, I, V, $, ae, he, ze, rt, gt, Et, or, _r) {
+              for (var pr = y.indexArray, Fr = y.layoutVertexArray, oi = y.segments.prepareSegment(4 * I.length, Fr, pr, this.canOverlap ? he.sortKey : void 0), Hi = this.glyphOffsetArray.length, Ai = oi.vertexLength, bn = this.allowVerticalPlacement && ze === uv.vertical ? Math.PI / 2 : 0, nn = he.text && he.text.sections, xn = 0; xn < I.length; xn++) {
+                var Pn = I[xn], Zn = Pn.tl, ga = Pn.tr, ha = Pn.bl, eo = Pn.br, za = Pn.tex, Za = Pn.pixelOffsetTL, Jo = Pn.pixelOffsetBR, to = Pn.minFontScaleX, ao = Pn.minFontScaleY, _s = Pn.glyphOffset, jo = Pn.isSDF, El = Pn.sectionIndex, Iu = oi.vertexLength, kl = _s[1];
+                l6(Fr, rt.x, rt.y, Zn.x, kl + Zn.y, za.x, za.y, V, jo, Za.x, Za.y, to, ao), l6(Fr, rt.x, rt.y, ga.x, kl + ga.y, za.x + za.w, za.y, V, jo, Jo.x, Za.y, to, ao), l6(Fr, rt.x, rt.y, ha.x, kl + ha.y, za.x, za.y + za.h, V, jo, Za.x, Jo.y, to, ao), l6(Fr, rt.x, rt.y, eo.x, kl + eo.y, za.x + za.w, za.y + za.h, V, jo, Jo.x, Jo.y, to, ao), mO(y.dynamicLayoutVertexArray, rt, bn), pr.emplaceBack(Iu, Iu + 1, Iu + 2), pr.emplaceBack(Iu + 1, Iu + 2, Iu + 3), oi.vertexLength += 4, oi.primitiveLength += 2, this.glyphOffsetArray.emplaceBack(_s[0]), (xn === I.length - 1 || El !== I[xn + 1].sectionIndex) && y.programConfigurations.populatePaintArrays(Fr.length, he, he.index, {}, _r, nn && nn[El]);
+              }
+              y.placedSymbolArray.emplaceBack(rt.x, rt.y, Hi, this.glyphOffsetArray.length - Hi, Ai, gt, Et, rt.segment, V ? V[0] : 0, V ? V[1] : 0, $[0], $[1], ze, 0, false, 0, or);
+            }, Pu.prototype._addCollisionDebugVertex = function(y, I, V, $, ae, he) {
+              return I.emplaceBack(0, 0), y.emplaceBack(V.x, V.y, $, ae, Math.round(he.x), Math.round(he.y));
+            }, Pu.prototype.addCollisionDebugVertices = function(y, I, V, $, ae, he, ze) {
+              var rt = ae.segments.prepareSegment(4, ae.layoutVertexArray, ae.indexArray), gt = rt.vertexLength, Et = ae.layoutVertexArray, or = ae.collisionVertexArray, _r = ze.anchorX, pr = ze.anchorY;
+              this._addCollisionDebugVertex(Et, or, he, _r, pr, new u(y, I)), this._addCollisionDebugVertex(Et, or, he, _r, pr, new u(V, I)), this._addCollisionDebugVertex(Et, or, he, _r, pr, new u(V, $)), this._addCollisionDebugVertex(Et, or, he, _r, pr, new u(y, $)), rt.vertexLength += 4;
+              var Fr = ae.indexArray;
+              Fr.emplaceBack(gt, gt + 1), Fr.emplaceBack(gt + 1, gt + 2), Fr.emplaceBack(gt + 2, gt + 3), Fr.emplaceBack(gt + 3, gt), rt.primitiveLength += 4;
+            }, Pu.prototype.addDebugCollisionBoxes = function(y, I, V, $) {
+              for (var ae = y; ae < I; ae++) {
+                var he = this.collisionBoxArray.get(ae), ze = he.x1, rt = he.y1, gt = he.x2, Et = he.y2;
+                this.addCollisionDebugVertices(ze, rt, gt, Et, $ ? this.textCollisionBox : this.iconCollisionBox, he.anchorPoint, V);
+              }
+            }, Pu.prototype.generateCollisionDebugBuffers = function() {
+              this.hasDebugData() && this.destroyDebugData(), this.textCollisionBox = new PS(Ji, ct.members, oa), this.iconCollisionBox = new PS(Ji, ct.members, oa);
+              for (var y = 0; y < this.symbolInstances.length; y++) {
+                var I = this.symbolInstances.get(y);
+                this.addDebugCollisionBoxes(I.textBoxStartIndex, I.textBoxEndIndex, I, true), this.addDebugCollisionBoxes(I.verticalTextBoxStartIndex, I.verticalTextBoxEndIndex, I, true), this.addDebugCollisionBoxes(I.iconBoxStartIndex, I.iconBoxEndIndex, I, false), this.addDebugCollisionBoxes(I.verticalIconBoxStartIndex, I.verticalIconBoxEndIndex, I, false);
+              }
+            }, Pu.prototype._deserializeCollisionBoxesForSymbol = function(y, I, V, $, ae, he, ze, rt, gt) {
+              for (var Et = {}, or = I; or < V; or++) {
+                var _r = y.get(or);
+                Et.textBox = { x1: _r.x1, y1: _r.y1, x2: _r.x2, y2: _r.y2, anchorPointX: _r.anchorPointX, anchorPointY: _r.anchorPointY }, Et.textFeatureIndex = _r.featureIndex;
+                break;
+              }
+              for (var pr = $; pr < ae; pr++) {
+                var Fr = y.get(pr);
+                Et.verticalTextBox = { x1: Fr.x1, y1: Fr.y1, x2: Fr.x2, y2: Fr.y2, anchorPointX: Fr.anchorPointX, anchorPointY: Fr.anchorPointY }, Et.verticalTextFeatureIndex = Fr.featureIndex;
+                break;
+              }
+              for (var oi = he; oi < ze; oi++) {
+                var Hi = y.get(oi);
+                Et.iconBox = { x1: Hi.x1, y1: Hi.y1, x2: Hi.x2, y2: Hi.y2, anchorPointX: Hi.anchorPointX, anchorPointY: Hi.anchorPointY }, Et.iconFeatureIndex = Hi.featureIndex;
+                break;
+              }
+              for (var Ai = rt; Ai < gt; Ai++) {
+                var bn = y.get(Ai);
+                Et.verticalIconBox = { x1: bn.x1, y1: bn.y1, x2: bn.x2, y2: bn.y2, anchorPointX: bn.anchorPointX, anchorPointY: bn.anchorPointY }, Et.verticalIconFeatureIndex = bn.featureIndex;
+                break;
+              }
+              return Et;
+            }, Pu.prototype.deserializeCollisionBoxes = function(y) {
+              this.collisionArrays = [];
+              for (var I = 0; I < this.symbolInstances.length; I++) {
+                var V = this.symbolInstances.get(I);
+                this.collisionArrays.push(this._deserializeCollisionBoxesForSymbol(y, V.textBoxStartIndex, V.textBoxEndIndex, V.verticalTextBoxStartIndex, V.verticalTextBoxEndIndex, V.iconBoxStartIndex, V.iconBoxEndIndex, V.verticalIconBoxStartIndex, V.verticalIconBoxEndIndex));
+              }
+            }, Pu.prototype.hasTextData = function() {
+              return this.text.segments.get().length > 0;
+            }, Pu.prototype.hasIconData = function() {
+              return this.icon.segments.get().length > 0;
+            }, Pu.prototype.hasDebugData = function() {
+              return this.textCollisionBox && this.iconCollisionBox;
+            }, Pu.prototype.hasTextCollisionBoxData = function() {
+              return this.hasDebugData() && this.textCollisionBox.segments.get().length > 0;
+            }, Pu.prototype.hasIconCollisionBoxData = function() {
+              return this.hasDebugData() && this.iconCollisionBox.segments.get().length > 0;
+            }, Pu.prototype.addIndicesForPlacedSymbol = function(y, I) {
+              for (var V = y.placedSymbolArray.get(I), $ = V.vertexStartIndex + V.numGlyphs * 4, ae = V.vertexStartIndex; ae < $; ae += 4) y.indexArray.emplaceBack(ae, ae + 1, ae + 2), y.indexArray.emplaceBack(ae + 1, ae + 2, ae + 3);
+            }, Pu.prototype.getSortedSymbolIndexes = function(y) {
+              if (this.sortedAngle === y && this.symbolInstanceIndexes !== void 0) return this.symbolInstanceIndexes;
+              for (var I = Math.sin(y), V = Math.cos(y), $ = [], ae = [], he = [], ze = 0; ze < this.symbolInstances.length; ++ze) {
+                he.push(ze);
+                var rt = this.symbolInstances.get(ze);
+                $.push(Math.round(I * rt.anchorX + V * rt.anchorY) | 0), ae.push(rt.featureIndex);
+              }
+              return he.sort(function(gt, Et) {
+                return $[gt] - $[Et] || ae[Et] - ae[gt];
+              }), he;
+            }, Pu.prototype.addToSortKeyRanges = function(y, I) {
+              var V = this.sortKeyRanges[this.sortKeyRanges.length - 1];
+              V && V.sortKey === I ? V.symbolInstanceEnd = y + 1 : this.sortKeyRanges.push({ sortKey: I, symbolInstanceStart: y, symbolInstanceEnd: y + 1 });
+            }, Pu.prototype.sortFeatures = function(y) {
+              var I = this;
+              if (this.sortFeaturesByY && this.sortedAngle !== y && !(this.text.segments.get().length > 1 || this.icon.segments.get().length > 1)) {
+                this.symbolInstanceIndexes = this.getSortedSymbolIndexes(y), this.sortedAngle = y, this.text.indexArray.clear(), this.icon.indexArray.clear(), this.featureSortOrder = [];
+                for (var V = 0, $ = this.symbolInstanceIndexes; V < $.length; V += 1) {
+                  var ae = $[V], he = this.symbolInstances.get(ae);
+                  this.featureSortOrder.push(he.featureIndex), [he.rightJustifiedTextSymbolIndex, he.centerJustifiedTextSymbolIndex, he.leftJustifiedTextSymbolIndex].forEach(function(ze, rt, gt) {
+                    ze >= 0 && gt.indexOf(ze) === rt && I.addIndicesForPlacedSymbol(I.text, ze);
+                  }), he.verticalPlacedTextSymbolIndex >= 0 && this.addIndicesForPlacedSymbol(this.text, he.verticalPlacedTextSymbolIndex), he.placedIconSymbolIndex >= 0 && this.addIndicesForPlacedSymbol(this.icon, he.placedIconSymbolIndex), he.verticalPlacedIconSymbolIndex >= 0 && this.addIndicesForPlacedSymbol(this.icon, he.verticalPlacedIconSymbolIndex);
+                }
+                this.text.indexBuffer && this.text.indexBuffer.updateData(this.text.indexArray), this.icon.indexBuffer && this.icon.indexBuffer.updateData(this.icon.indexArray);
+              }
+            }, X("SymbolBucket", Pu, { omit: ["layers", "collisionBoxArray", "features", "compareText"] }), Pu.MAX_GLYPHS = 65535, Pu.addDynamicAttributes = mO;
+            function Yet(m, y) {
+              return y.replace(/{([^{}]+)}/g, function(I, V) {
+                return V in m ? String(m[V]) : "";
+              });
+            }
+            var Ket = new Nr({ "symbol-placement": new Me(Rn.layout_symbol["symbol-placement"]), "symbol-spacing": new Me(Rn.layout_symbol["symbol-spacing"]), "symbol-avoid-edges": new Me(Rn.layout_symbol["symbol-avoid-edges"]), "symbol-sort-key": new bt(Rn.layout_symbol["symbol-sort-key"]), "symbol-z-order": new Me(Rn.layout_symbol["symbol-z-order"]), "icon-allow-overlap": new Me(Rn.layout_symbol["icon-allow-overlap"]), "icon-ignore-placement": new Me(Rn.layout_symbol["icon-ignore-placement"]), "icon-optional": new Me(Rn.layout_symbol["icon-optional"]), "icon-rotation-alignment": new Me(Rn.layout_symbol["icon-rotation-alignment"]), "icon-size": new bt(Rn.layout_symbol["icon-size"]), "icon-text-fit": new Me(Rn.layout_symbol["icon-text-fit"]), "icon-text-fit-padding": new Me(Rn.layout_symbol["icon-text-fit-padding"]), "icon-image": new bt(Rn.layout_symbol["icon-image"]), "icon-rotate": new bt(Rn.layout_symbol["icon-rotate"]), "icon-padding": new Me(Rn.layout_symbol["icon-padding"]), "icon-keep-upright": new Me(Rn.layout_symbol["icon-keep-upright"]), "icon-offset": new bt(Rn.layout_symbol["icon-offset"]), "icon-anchor": new bt(Rn.layout_symbol["icon-anchor"]), "icon-pitch-alignment": new Me(Rn.layout_symbol["icon-pitch-alignment"]), "text-pitch-alignment": new Me(Rn.layout_symbol["text-pitch-alignment"]), "text-rotation-alignment": new Me(Rn.layout_symbol["text-rotation-alignment"]), "text-field": new bt(Rn.layout_symbol["text-field"]), "text-font": new bt(Rn.layout_symbol["text-font"]), "text-size": new bt(Rn.layout_symbol["text-size"]), "text-max-width": new bt(Rn.layout_symbol["text-max-width"]), "text-line-height": new Me(Rn.layout_symbol["text-line-height"]), "text-letter-spacing": new bt(Rn.layout_symbol["text-letter-spacing"]), "text-justify": new bt(Rn.layout_symbol["text-justify"]), "text-radial-offset": new bt(Rn.layout_symbol["text-radial-offset"]), "text-variable-anchor": new Me(Rn.layout_symbol["text-variable-anchor"]), "text-anchor": new bt(Rn.layout_symbol["text-anchor"]), "text-max-angle": new Me(Rn.layout_symbol["text-max-angle"]), "text-writing-mode": new Me(Rn.layout_symbol["text-writing-mode"]), "text-rotate": new bt(Rn.layout_symbol["text-rotate"]), "text-padding": new Me(Rn.layout_symbol["text-padding"]), "text-keep-upright": new Me(Rn.layout_symbol["text-keep-upright"]), "text-transform": new bt(Rn.layout_symbol["text-transform"]), "text-offset": new bt(Rn.layout_symbol["text-offset"]), "text-allow-overlap": new Me(Rn.layout_symbol["text-allow-overlap"]), "text-ignore-placement": new Me(Rn.layout_symbol["text-ignore-placement"]), "text-optional": new Me(Rn.layout_symbol["text-optional"]) }), Jet = new Nr({ "icon-opacity": new bt(Rn.paint_symbol["icon-opacity"]), "icon-color": new bt(Rn.paint_symbol["icon-color"]), "icon-halo-color": new bt(Rn.paint_symbol["icon-halo-color"]), "icon-halo-width": new bt(Rn.paint_symbol["icon-halo-width"]), "icon-halo-blur": new bt(Rn.paint_symbol["icon-halo-blur"]), "icon-translate": new Me(Rn.paint_symbol["icon-translate"]), "icon-translate-anchor": new Me(Rn.paint_symbol["icon-translate-anchor"]), "text-opacity": new bt(Rn.paint_symbol["text-opacity"]), "text-color": new bt(Rn.paint_symbol["text-color"], { runtimeType: ql, getOverride: function(m) {
+              return m.textColor;
+            }, hasOverride: function(m) {
+              return !!m.textColor;
+            } }), "text-halo-color": new bt(Rn.paint_symbol["text-halo-color"]), "text-halo-width": new bt(Rn.paint_symbol["text-halo-width"]), "text-halo-blur": new bt(Rn.paint_symbol["text-halo-blur"]), "text-translate": new Me(Rn.paint_symbol["text-translate"]), "text-translate-anchor": new Me(Rn.paint_symbol["text-translate-anchor"]) }), yO = { paint: Jet, layout: Ket }, o3 = function(y) {
+              this.type = y.property.overrides ? y.property.overrides.runtimeType : ac, this.defaultValue = y;
+            };
+            o3.prototype.evaluate = function(y) {
+              if (y.formattedSection) {
+                var I = this.defaultValue.property.overrides;
+                if (I && I.hasOverride(y.formattedSection)) return I.getOverride(y.formattedSection);
+              }
+              return y.feature && y.featureState ? this.defaultValue.evaluate(y.feature, y.featureState) : this.defaultValue.property.specification.default;
+            }, o3.prototype.eachChild = function(y) {
+              if (!this.defaultValue.isConstant()) {
+                var I = this.defaultValue.value;
+                y(I._styleExpression.expression);
+              }
+            }, o3.prototype.outputDefined = function() {
+              return false;
+            }, o3.prototype.serialize = function() {
+              return null;
+            }, X("FormatSectionOverride", o3, { omit: ["defaultValue"] });
+            var $et = function(m) {
+              function y(I) {
+                m.call(this, I, yO);
+              }
+              return m && (y.__proto__ = m), y.prototype = Object.create(m && m.prototype), y.prototype.constructor = y, y.prototype.recalculate = function(V, $) {
+                if (m.prototype.recalculate.call(this, V, $), this.layout.get("icon-rotation-alignment") === "auto" && (this.layout.get("symbol-placement") !== "point" ? this.layout._values["icon-rotation-alignment"] = "map" : this.layout._values["icon-rotation-alignment"] = "viewport"), this.layout.get("text-rotation-alignment") === "auto" && (this.layout.get("symbol-placement") !== "point" ? this.layout._values["text-rotation-alignment"] = "map" : this.layout._values["text-rotation-alignment"] = "viewport"), this.layout.get("text-pitch-alignment") === "auto" && (this.layout._values["text-pitch-alignment"] = this.layout.get("text-rotation-alignment")), this.layout.get("icon-pitch-alignment") === "auto" && (this.layout._values["icon-pitch-alignment"] = this.layout.get("icon-rotation-alignment")), this.layout.get("symbol-placement") === "point") {
+                  var ae = this.layout.get("text-writing-mode");
+                  if (ae) {
+                    for (var he = [], ze = 0, rt = ae; ze < rt.length; ze += 1) {
+                      var gt = rt[ze];
+                      he.indexOf(gt) < 0 && he.push(gt);
+                    }
+                    this.layout._values["text-writing-mode"] = he;
+                  } else this.layout._values["text-writing-mode"] = ["horizontal"];
+                }
+                this._setPaintOverrides();
+              }, y.prototype.getValueAndResolveTokens = function(V, $, ae, he) {
+                var ze = this.layout.get(V).evaluate($, {}, ae, he), rt = this._unevaluatedLayout._values[V];
+                return !rt.isDataDriven() && !Ua(rt.value) && ze ? Yet($.properties, ze) : ze;
+              }, y.prototype.createBucket = function(V) {
+                return new Pu(V);
+              }, y.prototype.queryRadius = function() {
+                return 0;
+              }, y.prototype.queryIntersectsFeature = function() {
+                return false;
+              }, y.prototype._setPaintOverrides = function() {
+                for (var V = 0, $ = yO.paint.overridableProperties; V < $.length; V += 1) {
+                  var ae = $[V];
+                  if (y.hasPaintOverride(this.layout, ae)) {
+                    var he = this.paint.get(ae), ze = new o3(he), rt = new Ac(ze, he.property.specification), gt = null;
+                    he.value.kind === "constant" || he.value.kind === "source" ? gt = new Vc("source", rt) : gt = new hc("composite", rt, he.value.zoomStops, he.value._interpolationType), this.paint._values[ae] = new dl(he.property, gt, he.parameters);
+                  }
+                }
+              }, y.prototype._handleOverridablePaintPropertyUpdate = function(V, $, ae) {
+                return !this.layout || $.isDataDriven() || ae.isDataDriven() ? false : y.hasPaintOverride(this.layout, V);
+              }, y.hasPaintOverride = function(V, $) {
+                var ae = V.get("text-field"), he = yO.paint.properties[$], ze = false, rt = function(or) {
+                  for (var _r = 0, pr = or; _r < pr.length; _r += 1) {
+                    var Fr = pr[_r];
+                    if (he.overrides && he.overrides.hasOverride(Fr)) {
+                      ze = true;
+                      return;
+                    }
+                  }
+                };
+                if (ae.value.kind === "constant" && ae.value.value instanceof $l) rt(ae.value.value.sections);
+                else if (ae.value.kind === "source") {
+                  var gt = function(or) {
+                    if (!ze) if (or instanceof Go && Es(or.value) === pl) {
+                      var _r = or.value;
+                      rt(_r.sections);
+                    } else or instanceof Gu ? rt(or.sections) : or.eachChild(gt);
+                  }, Et = ae.value;
+                  Et._styleExpression && gt(Et._styleExpression.expression);
+                }
+                return ze;
+              }, y;
+            }(mi), Qet = new Nr({ "background-color": new Me(Rn.paint_background["background-color"]), "background-pattern": new Rr(Rn.paint_background["background-pattern"]), "background-opacity": new Me(Rn.paint_background["background-opacity"]) }), ett = { paint: Qet }, ttt = function(m) {
+              function y(I) {
+                m.call(this, I, ett);
+              }
+              return m && (y.__proto__ = m), y.prototype = Object.create(m && m.prototype), y.prototype.constructor = y, y;
+            }(mi), rtt = new Nr({ "raster-opacity": new Me(Rn.paint_raster["raster-opacity"]), "raster-hue-rotate": new Me(Rn.paint_raster["raster-hue-rotate"]), "raster-brightness-min": new Me(Rn.paint_raster["raster-brightness-min"]), "raster-brightness-max": new Me(Rn.paint_raster["raster-brightness-max"]), "raster-saturation": new Me(Rn.paint_raster["raster-saturation"]), "raster-contrast": new Me(Rn.paint_raster["raster-contrast"]), "raster-resampling": new Me(Rn.paint_raster["raster-resampling"]), "raster-fade-duration": new Me(Rn.paint_raster["raster-fade-duration"]) }), itt = { paint: rtt }, ntt = function(m) {
+              function y(I) {
+                m.call(this, I, itt);
+              }
+              return m && (y.__proto__ = m), y.prototype = Object.create(m && m.prototype), y.prototype.constructor = y, y;
+            }(mi);
+            function att(m) {
+              var y = [], I = m.id;
+              return I === void 0 && y.push({ message: "layers." + I + ': missing required property "id"' }), m.render === void 0 && y.push({ message: "layers." + I + ': missing required method "render"' }), m.renderingMode && m.renderingMode !== "2d" && m.renderingMode !== "3d" && y.push({ message: "layers." + I + ': property "renderingMode" must be either "2d" or "3d"' }), y;
+            }
+            var ott = function(m) {
+              function y(I) {
+                m.call(this, I, {}), this.implementation = I;
+              }
+              return m && (y.__proto__ = m), y.prototype = Object.create(m && m.prototype), y.prototype.constructor = y, y.prototype.is3D = function() {
+                return this.implementation.renderingMode === "3d";
+              }, y.prototype.hasOffscreenPass = function() {
+                return this.implementation.prerender !== void 0;
+              }, y.prototype.recalculate = function() {
+              }, y.prototype.updateTransitions = function() {
+              }, y.prototype.hasTransition = function() {
+              }, y.prototype.serialize = function() {
+              }, y.prototype.onAdd = function(V) {
+                this.implementation.onAdd && this.implementation.onAdd(V, V.painter.context.gl);
+              }, y.prototype.onRemove = function(V) {
+                this.implementation.onRemove && this.implementation.onRemove(V, V.painter.context.gl);
+              }, y;
+            }(mi), stt = { circle: Y9, heatmap: Uw, hillshade: kC, fill: lb, "fill-extrusion": vm, line: S, symbol: $et, background: ttt, raster: ntt };
+            function ltt(m) {
+              return m.type === "custom" ? new ott(m) : new stt[m.type](m);
+            }
+            var $Q = f.HTMLImageElement, QQ = f.HTMLCanvasElement, eee = f.HTMLVideoElement, tee = f.ImageData, u6 = f.ImageBitmap, hb = function(y, I, V, $) {
+              this.context = y, this.format = V, this.texture = y.gl.createTexture(), this.update(I, $);
+            };
+            hb.prototype.update = function(y, I, V) {
+              var $ = y.width, ae = y.height, he = (!this.size || this.size[0] !== $ || this.size[1] !== ae) && !V, ze = this, rt = ze.context, gt = rt.gl;
+              if (this.useMipmap = !!(I && I.useMipmap), gt.bindTexture(gt.TEXTURE_2D, this.texture), rt.pixelStoreUnpackFlipY.set(false), rt.pixelStoreUnpack.set(1), rt.pixelStoreUnpackPremultiplyAlpha.set(this.format === gt.RGBA && (!I || I.premultiply !== false)), he) this.size = [$, ae], y instanceof $Q || y instanceof QQ || y instanceof eee || y instanceof tee || u6 && y instanceof u6 ? gt.texImage2D(gt.TEXTURE_2D, 0, this.format, this.format, gt.UNSIGNED_BYTE, y) : gt.texImage2D(gt.TEXTURE_2D, 0, this.format, $, ae, 0, this.format, gt.UNSIGNED_BYTE, y.data);
+              else {
+                var Et = V || { x: 0, y: 0 }, or = Et.x, _r = Et.y;
+                y instanceof $Q || y instanceof QQ || y instanceof eee || y instanceof tee || u6 && y instanceof u6 ? gt.texSubImage2D(gt.TEXTURE_2D, 0, or, _r, gt.RGBA, gt.UNSIGNED_BYTE, y) : gt.texSubImage2D(gt.TEXTURE_2D, 0, or, _r, $, ae, gt.RGBA, gt.UNSIGNED_BYTE, y.data);
+              }
+              this.useMipmap && this.isSizePowerOfTwo() && gt.generateMipmap(gt.TEXTURE_2D);
+            }, hb.prototype.bind = function(y, I, V) {
+              var $ = this, ae = $.context, he = ae.gl;
+              he.bindTexture(he.TEXTURE_2D, this.texture), V === he.LINEAR_MIPMAP_NEAREST && !this.isSizePowerOfTwo() && (V = he.LINEAR), y !== this.filter && (he.texParameteri(he.TEXTURE_2D, he.TEXTURE_MAG_FILTER, y), he.texParameteri(he.TEXTURE_2D, he.TEXTURE_MIN_FILTER, V || y), this.filter = y), I !== this.wrap && (he.texParameteri(he.TEXTURE_2D, he.TEXTURE_WRAP_S, I), he.texParameteri(he.TEXTURE_2D, he.TEXTURE_WRAP_T, I), this.wrap = I);
+            }, hb.prototype.isSizePowerOfTwo = function() {
+              return this.size[0] === this.size[1] && Math.log(this.size[0]) / Math.LN2 % 1 === 0;
+            }, hb.prototype.destroy = function() {
+              var y = this.context, I = y.gl;
+              I.deleteTexture(this.texture), this.texture = null;
+            };
+            var _O = function(y) {
+              var I = this;
+              this._callback = y, this._triggered = false, typeof MessageChannel != "undefined" && (this._channel = new MessageChannel(), this._channel.port2.onmessage = function() {
+                I._triggered = false, I._callback();
+              });
+            };
+            _O.prototype.trigger = function() {
+              var y = this;
+              this._triggered || (this._triggered = true, this._channel ? this._channel.port1.postMessage(true) : setTimeout(function() {
+                y._triggered = false, y._callback();
+              }, 0));
+            }, _O.prototype.remove = function() {
+              delete this._channel, this._callback = function() {
+              };
+            };
+            var s3 = function(y, I, V) {
+              this.target = y, this.parent = I, this.mapId = V, this.callbacks = {}, this.tasks = {}, this.taskQueue = [], this.cancelCallbacks = {}, O(["receive", "process"], this), this.invoker = new _O(this.process), this.target.addEventListener("message", this.receive, false), this.globalScope = Le() ? y : f;
+            };
+            s3.prototype.send = function(y, I, V, $, ae) {
+              var he = this;
+              ae === void 0 && (ae = false);
+              var ze = Math.round(Math.random() * 1e18).toString(36).substring(0, 10);
+              V && (this.callbacks[ze] = V);
+              var rt = Se(this.globalScope) ? void 0 : [];
+              return this.target.postMessage({ id: ze, type: y, hasCallback: !!V, targetMapId: $, mustQueue: ae, sourceMapId: this.mapId, data: He(I, rt) }, rt), { cancel: function() {
+                V && delete he.callbacks[ze], he.target.postMessage({ id: ze, type: "<cancel>", targetMapId: $, sourceMapId: he.mapId });
+              } };
+            }, s3.prototype.receive = function(y) {
+              var I = y.data, V = I.id;
+              if (V && !(I.targetMapId && this.mapId !== I.targetMapId)) if (I.type === "<cancel>") {
+                delete this.tasks[V];
+                var $ = this.cancelCallbacks[V];
+                delete this.cancelCallbacks[V], $ && $();
+              } else Le() || I.mustQueue ? (this.tasks[V] = I, this.taskQueue.push(V), this.invoker.trigger()) : this.processTask(V, I);
+            }, s3.prototype.process = function() {
+              if (this.taskQueue.length) {
+                var y = this.taskQueue.shift(), I = this.tasks[y];
+                delete this.tasks[y], this.taskQueue.length && this.invoker.trigger(), I && this.processTask(y, I);
+              }
+            }, s3.prototype.processTask = function(y, I) {
+              var V = this;
+              if (I.type === "<response>") {
+                var $ = this.callbacks[y];
+                delete this.callbacks[y], $ && (I.error ? $(Ye(I.error)) : $(null, Ye(I.data)));
+              } else {
+                var ae = false, he = Se(this.globalScope) ? void 0 : [], ze = I.hasCallback ? function(_r, pr) {
+                  ae = true, delete V.cancelCallbacks[y], V.target.postMessage({ id: y, type: "<response>", sourceMapId: V.mapId, error: _r ? He(_r) : null, data: He(pr, he) }, he);
+                } : function(_r) {
+                  ae = true;
+                }, rt = null, gt = Ye(I.data);
+                if (this.parent[I.type]) rt = this.parent[I.type](I.sourceMapId, gt, ze);
+                else if (this.parent.getWorkerSource) {
+                  var Et = I.type.split("."), or = this.parent.getWorkerSource(I.sourceMapId, Et[0], gt.source);
+                  rt = or[Et[1]](gt, ze);
+                } else ze(new Error("Could not find function " + I.type));
+                !ae && rt && rt.cancel && (this.cancelCallbacks[y] = rt.cancel);
+              }
+            }, s3.prototype.remove = function() {
+              this.invoker.remove(), this.target.removeEventListener("message", this.receive, false);
+            };
+            function utt(m, y, I) {
+              y = Math.pow(2, I) - y - 1;
+              var V = ree(m * 256, y * 256, I), $ = ree((m + 1) * 256, (y + 1) * 256, I);
+              return V[0] + "," + V[1] + "," + $[0] + "," + $[1];
+            }
+            function ree(m, y, I) {
+              var V = 2 * Math.PI * 6378137 / 256 / Math.pow(2, I), $ = m * V - 2 * Math.PI * 6378137 / 2, ae = y * V - 2 * Math.PI * 6378137 / 2;
+              return [$, ae];
+            }
+            var lh = function(y, I) {
+              y && (I ? this.setSouthWest(y).setNorthEast(I) : y.length === 4 ? this.setSouthWest([y[0], y[1]]).setNorthEast([y[2], y[3]]) : this.setSouthWest(y[0]).setNorthEast(y[1]));
+            };
+            lh.prototype.setNorthEast = function(y) {
+              return this._ne = y instanceof Hc ? new Hc(y.lng, y.lat) : Hc.convert(y), this;
+            }, lh.prototype.setSouthWest = function(y) {
+              return this._sw = y instanceof Hc ? new Hc(y.lng, y.lat) : Hc.convert(y), this;
+            }, lh.prototype.extend = function(y) {
+              var I = this._sw, V = this._ne, $, ae;
+              if (y instanceof Hc) $ = y, ae = y;
+              else if (y instanceof lh) {
+                if ($ = y._sw, ae = y._ne, !$ || !ae) return this;
+              } else {
+                if (Array.isArray(y)) if (y.length === 4 || y.every(Array.isArray)) {
+                  var he = y;
+                  return this.extend(lh.convert(he));
+                } else {
+                  var ze = y;
+                  return this.extend(Hc.convert(ze));
+                }
+                return this;
+              }
+              return !I && !V ? (this._sw = new Hc($.lng, $.lat), this._ne = new Hc(ae.lng, ae.lat)) : (I.lng = Math.min($.lng, I.lng), I.lat = Math.min($.lat, I.lat), V.lng = Math.max(ae.lng, V.lng), V.lat = Math.max(ae.lat, V.lat)), this;
+            }, lh.prototype.getCenter = function() {
+              return new Hc((this._sw.lng + this._ne.lng) / 2, (this._sw.lat + this._ne.lat) / 2);
+            }, lh.prototype.getSouthWest = function() {
+              return this._sw;
+            }, lh.prototype.getNorthEast = function() {
+              return this._ne;
+            }, lh.prototype.getNorthWest = function() {
+              return new Hc(this.getWest(), this.getNorth());
+            }, lh.prototype.getSouthEast = function() {
+              return new Hc(this.getEast(), this.getSouth());
+            }, lh.prototype.getWest = function() {
+              return this._sw.lng;
+            }, lh.prototype.getSouth = function() {
+              return this._sw.lat;
+            }, lh.prototype.getEast = function() {
+              return this._ne.lng;
+            }, lh.prototype.getNorth = function() {
+              return this._ne.lat;
+            }, lh.prototype.toArray = function() {
+              return [this._sw.toArray(), this._ne.toArray()];
+            }, lh.prototype.toString = function() {
+              return "LngLatBounds(" + this._sw.toString() + ", " + this._ne.toString() + ")";
+            }, lh.prototype.isEmpty = function() {
+              return !(this._sw && this._ne);
+            }, lh.prototype.contains = function(y) {
+              var I = Hc.convert(y), V = I.lng, $ = I.lat, ae = this._sw.lat <= $ && $ <= this._ne.lat, he = this._sw.lng <= V && V <= this._ne.lng;
+              return this._sw.lng > this._ne.lng && (he = this._sw.lng >= V && V >= this._ne.lng), ae && he;
+            }, lh.convert = function(y) {
+              return !y || y instanceof lh ? y : new lh(y);
+            };
+            var iee = 63710088e-1, Hc = function(y, I) {
+              if (isNaN(y) || isNaN(I)) throw new Error("Invalid LngLat object: (" + y + ", " + I + ")");
+              if (this.lng = +y, this.lat = +I, this.lat > 90 || this.lat < -90) throw new Error("Invalid LngLat latitude value: must be between -90 and 90");
+            };
+            Hc.prototype.wrap = function() {
+              return new Hc(k(this.lng, -180, 180), this.lat);
+            }, Hc.prototype.toArray = function() {
+              return [this.lng, this.lat];
+            }, Hc.prototype.toString = function() {
+              return "LngLat(" + this.lng + ", " + this.lat + ")";
+            }, Hc.prototype.distanceTo = function(y) {
+              var I = Math.PI / 180, V = this.lat * I, $ = y.lat * I, ae = Math.sin(V) * Math.sin($) + Math.cos(V) * Math.cos($) * Math.cos((y.lng - this.lng) * I), he = iee * Math.acos(Math.min(ae, 1));
+              return he;
+            }, Hc.prototype.toBounds = function(y) {
+              y === void 0 && (y = 0);
+              var I = 40075017, V = 360 * y / I, $ = V / Math.cos(Math.PI / 180 * this.lat);
+              return new lh(new Hc(this.lng - $, this.lat - V), new Hc(this.lng + $, this.lat + V));
+            }, Hc.convert = function(y) {
+              if (y instanceof Hc) return y;
+              if (Array.isArray(y) && (y.length === 2 || y.length === 3)) return new Hc(Number(y[0]), Number(y[1]));
+              if (!Array.isArray(y) && typeof y == "object" && y !== null) return new Hc(Number("lng" in y ? y.lng : y.lon), Number(y.lat));
+              throw new Error("`LngLatLike` argument must be specified as a LngLat instance, an object {lng: <lng>, lat: <lat>}, an object {lon: <lng>, lat: <lat>}, or an array of [<lng>, <lat>]");
+            };
+            var nee = 2 * Math.PI * iee;
+            function aee(m) {
+              return nee * Math.cos(m * Math.PI / 180);
+            }
+            function oee(m) {
+              return (180 + m) / 360;
+            }
+            function see(m) {
+              return (180 - 180 / Math.PI * Math.log(Math.tan(Math.PI / 4 + m * Math.PI / 360))) / 360;
+            }
+            function lee(m, y) {
+              return m / aee(y);
+            }
+            function ctt(m) {
+              return m * 360 - 180;
+            }
+            function xO(m) {
+              var y = 180 - m * 360;
+              return 360 / Math.PI * Math.atan(Math.exp(y * Math.PI / 180)) - 90;
+            }
+            function ftt(m, y) {
+              return m * aee(xO(y));
+            }
+            function htt(m) {
+              return 1 / Math.cos(m * Math.PI / 180);
+            }
+            var db = function(y, I, V) {
+              V === void 0 && (V = 0), this.x = +y, this.y = +I, this.z = +V;
+            };
+            db.fromLngLat = function(y, I) {
+              I === void 0 && (I = 0);
+              var V = Hc.convert(y);
+              return new db(oee(V.lng), see(V.lat), lee(I, V.lat));
+            }, db.prototype.toLngLat = function() {
+              return new Hc(ctt(this.x), xO(this.y));
+            }, db.prototype.toAltitude = function() {
+              return ftt(this.z, this.y);
+            }, db.prototype.meterInMercatorCoordinateUnits = function() {
+              return 1 / nee * htt(xO(this.y));
+            };
+            var vb = function(y, I, V) {
+              this.z = y, this.x = I, this.y = V, this.key = IS(0, y, y, I, V);
+            };
+            vb.prototype.equals = function(y) {
+              return this.z === y.z && this.x === y.x && this.y === y.y;
+            }, vb.prototype.url = function(y, I) {
+              var V = utt(this.x, this.y, this.z), $ = dtt(this.z, this.x, this.y);
+              return y[(this.x + this.y) % y.length].replace("{prefix}", (this.x % 16).toString(16) + (this.y % 16).toString(16)).replace("{z}", String(this.z)).replace("{x}", String(this.x)).replace("{y}", String(I === "tms" ? Math.pow(2, this.z) - this.y - 1 : this.y)).replace("{quadkey}", $).replace("{bbox-epsg-3857}", V);
+            }, vb.prototype.getTilePoint = function(y) {
+              var I = Math.pow(2, this.z);
+              return new u((y.x * I - this.x) * Ci, (y.y * I - this.y) * Ci);
+            }, vb.prototype.toString = function() {
+              return this.z + "/" + this.x + "/" + this.y;
+            };
+            var uee = function(y, I) {
+              this.wrap = y, this.canonical = I, this.key = IS(y, I.z, I.z, I.x, I.y);
+            }, uh = function(y, I, V, $, ae) {
+              this.overscaledZ = y, this.wrap = I, this.canonical = new vb(V, +$, +ae), this.key = IS(I, y, V, $, ae);
+            };
+            uh.prototype.equals = function(y) {
+              return this.overscaledZ === y.overscaledZ && this.wrap === y.wrap && this.canonical.equals(y.canonical);
+            }, uh.prototype.scaledTo = function(y) {
+              var I = this.canonical.z - y;
+              return y > this.canonical.z ? new uh(y, this.wrap, this.canonical.z, this.canonical.x, this.canonical.y) : new uh(y, this.wrap, y, this.canonical.x >> I, this.canonical.y >> I);
+            }, uh.prototype.calculateScaledKey = function(y, I) {
+              var V = this.canonical.z - y;
+              return y > this.canonical.z ? IS(this.wrap * +I, y, this.canonical.z, this.canonical.x, this.canonical.y) : IS(this.wrap * +I, y, y, this.canonical.x >> V, this.canonical.y >> V);
+            }, uh.prototype.isChildOf = function(y) {
+              if (y.wrap !== this.wrap) return false;
+              var I = this.canonical.z - y.canonical.z;
+              return y.overscaledZ === 0 || y.overscaledZ < this.overscaledZ && y.canonical.x === this.canonical.x >> I && y.canonical.y === this.canonical.y >> I;
+            }, uh.prototype.children = function(y) {
+              if (this.overscaledZ >= y) return [new uh(this.overscaledZ + 1, this.wrap, this.canonical.z, this.canonical.x, this.canonical.y)];
+              var I = this.canonical.z + 1, V = this.canonical.x * 2, $ = this.canonical.y * 2;
+              return [new uh(I, this.wrap, I, V, $), new uh(I, this.wrap, I, V + 1, $), new uh(I, this.wrap, I, V, $ + 1), new uh(I, this.wrap, I, V + 1, $ + 1)];
+            }, uh.prototype.isLessThan = function(y) {
+              return this.wrap < y.wrap ? true : this.wrap > y.wrap ? false : this.overscaledZ < y.overscaledZ ? true : this.overscaledZ > y.overscaledZ ? false : this.canonical.x < y.canonical.x ? true : this.canonical.x > y.canonical.x ? false : this.canonical.y < y.canonical.y;
+            }, uh.prototype.wrapped = function() {
+              return new uh(this.overscaledZ, 0, this.canonical.z, this.canonical.x, this.canonical.y);
+            }, uh.prototype.unwrapTo = function(y) {
+              return new uh(this.overscaledZ, y, this.canonical.z, this.canonical.x, this.canonical.y);
+            }, uh.prototype.overscaleFactor = function() {
+              return Math.pow(2, this.overscaledZ - this.canonical.z);
+            }, uh.prototype.toUnwrapped = function() {
+              return new uee(this.wrap, this.canonical);
+            }, uh.prototype.toString = function() {
+              return this.overscaledZ + "/" + this.canonical.x + "/" + this.canonical.y;
+            }, uh.prototype.getTilePoint = function(y) {
+              return this.canonical.getTilePoint(new db(y.x - this.wrap, y.y));
+            };
+            function IS(m, y, I, V, $) {
+              m *= 2, m < 0 && (m = m * -1 - 1);
+              var ae = 1 << I;
+              return (ae * ae * m + ae * $ + V).toString(36) + I.toString(36) + y.toString(36);
+            }
+            function dtt(m, y, I) {
+              for (var V = "", $, ae = m; ae > 0; ae--) $ = 1 << ae - 1, V += (y & $ ? 1 : 0) + (I & $ ? 2 : 0);
+              return V;
+            }
+            X("CanonicalTileID", vb), X("OverscaledTileID", uh, { omit: ["posMatrix"] });
+            var xy = function(y, I, V) {
+              if (this.uid = y, I.height !== I.width) throw new RangeError("DEM tiles must be square");
+              if (V && V !== "mapbox" && V !== "terrarium") return re('"' + V + '" is not a valid encoding type. Valid types include "mapbox" and "terrarium".');
+              this.stride = I.height;
+              var $ = this.dim = I.height - 2;
+              this.data = new Uint32Array(I.data.buffer), this.encoding = V || "mapbox";
+              for (var ae = 0; ae < $; ae++) this.data[this._idx(-1, ae)] = this.data[this._idx(0, ae)], this.data[this._idx($, ae)] = this.data[this._idx($ - 1, ae)], this.data[this._idx(ae, -1)] = this.data[this._idx(ae, 0)], this.data[this._idx(ae, $)] = this.data[this._idx(ae, $ - 1)];
+              this.data[this._idx(-1, -1)] = this.data[this._idx(0, 0)], this.data[this._idx($, -1)] = this.data[this._idx($ - 1, 0)], this.data[this._idx(-1, $)] = this.data[this._idx(0, $ - 1)], this.data[this._idx($, $)] = this.data[this._idx($ - 1, $ - 1)];
+            };
+            xy.prototype.get = function(y, I) {
+              var V = new Uint8Array(this.data.buffer), $ = this._idx(y, I) * 4, ae = this.encoding === "terrarium" ? this._unpackTerrarium : this._unpackMapbox;
+              return ae(V[$], V[$ + 1], V[$ + 2]);
+            }, xy.prototype.getUnpackVector = function() {
+              return this.encoding === "terrarium" ? [256, 1, 1 / 256, 32768] : [6553.6, 25.6, 0.1, 1e4];
+            }, xy.prototype._idx = function(y, I) {
+              if (y < -1 || y >= this.dim + 1 || I < -1 || I >= this.dim + 1) throw new RangeError("out of range source coordinates for DEM data");
+              return (I + 1) * this.stride + (y + 1);
+            }, xy.prototype._unpackMapbox = function(y, I, V) {
+              return (y * 256 * 256 + I * 256 + V) / 10 - 1e4;
+            }, xy.prototype._unpackTerrarium = function(y, I, V) {
+              return y * 256 + I + V / 256 - 32768;
+            }, xy.prototype.getPixels = function() {
+              return new Eh({ width: this.stride, height: this.stride }, new Uint8Array(this.data.buffer));
+            }, xy.prototype.backfillBorder = function(y, I, V) {
+              if (this.dim !== y.dim) throw new Error("dem dimension mismatch");
+              var $ = I * this.dim, ae = I * this.dim + this.dim, he = V * this.dim, ze = V * this.dim + this.dim;
+              switch (I) {
+                case -1:
+                  $ = ae - 1;
+                  break;
+                case 1:
+                  ae = $ + 1;
+                  break;
+              }
+              switch (V) {
+                case -1:
+                  he = ze - 1;
+                  break;
+                case 1:
+                  ze = he + 1;
+                  break;
+              }
+              for (var rt = -I * this.dim, gt = -V * this.dim, Et = he; Et < ze; Et++) for (var or = $; or < ae; or++) this.data[this._idx(or, Et)] = y.data[this._idx(or + rt, Et + gt)];
+            }, X("DEMData", xy);
+            function vtt(m, y) {
+              var I = {};
+              if (!y) return I;
+              for (var V = function() {
+                var he = ae[$], ze = he.layerIds.map(function(or) {
+                  return y.getLayer(or);
+                }).filter(Boolean);
+                if (ze.length !== 0) {
+                  he.layers = ze, he.stateDependentLayerIds && (he.stateDependentLayers = he.stateDependentLayerIds.map(function(or) {
+                    return ze.filter(function(_r) {
+                      return _r.id === or;
+                    })[0];
+                  }));
+                  for (var rt = 0, gt = ze; rt < gt.length; rt += 1) {
+                    var Et = gt[rt];
+                    I[Et.id] = he;
+                  }
+                }
+              }, $ = 0, ae = m; $ < ae.length; $ += 1) V();
+              return I;
+            }
+            var c6 = function(y) {
+              this._stringToNumber = {}, this._numberToString = [];
+              for (var I = 0; I < y.length; I++) {
+                var V = y[I];
+                this._stringToNumber[V] = I, this._numberToString[I] = V;
+              }
+            };
+            c6.prototype.encode = function(y) {
+              return this._stringToNumber[y];
+            }, c6.prototype.decode = function(y) {
+              return this._numberToString[y];
+            };
+            var f6 = function(y, I, V, $, ae) {
+              this.type = "Feature", this._vectorTileFeature = y, y._z = I, y._x = V, y._y = $, this.properties = y.properties, this.id = ae;
+            }, bO = { geometry: { configurable: true } };
+            bO.geometry.get = function() {
+              return this._geometry === void 0 && (this._geometry = this._vectorTileFeature.toGeoJSON(this._vectorTileFeature._x, this._vectorTileFeature._y, this._vectorTileFeature._z).geometry), this._geometry;
+            }, bO.geometry.set = function(m) {
+              this._geometry = m;
+            }, f6.prototype.toJSON = function() {
+              var y = { geometry: this.geometry };
+              for (var I in this) I === "_geometry" || I === "_vectorTileFeature" || (y[I] = this[I]);
+              return y;
+            }, Object.defineProperties(f6.prototype, bO);
+            var l3 = function() {
+              this.state = {}, this.stateChanges = {}, this.deletedStates = {};
+            };
+            l3.prototype.updateState = function(y, I, V) {
+              var $ = String(I);
+              if (this.stateChanges[y] = this.stateChanges[y] || {}, this.stateChanges[y][$] = this.stateChanges[y][$] || {}, x(this.stateChanges[y][$], V), this.deletedStates[y] === null) {
+                this.deletedStates[y] = {};
+                for (var ae in this.state[y]) ae !== $ && (this.deletedStates[y][ae] = null);
+              } else {
+                var he = this.deletedStates[y] && this.deletedStates[y][$] === null;
+                if (he) {
+                  this.deletedStates[y][$] = {};
+                  for (var ze in this.state[y][$]) V[ze] || (this.deletedStates[y][$][ze] = null);
+                } else for (var rt in V) {
+                  var gt = this.deletedStates[y] && this.deletedStates[y][$] && this.deletedStates[y][$][rt] === null;
+                  gt && delete this.deletedStates[y][$][rt];
+                }
+              }
+            }, l3.prototype.removeFeatureState = function(y, I, V) {
+              var $ = this.deletedStates[y] === null;
+              if (!$) {
+                var ae = String(I);
+                if (this.deletedStates[y] = this.deletedStates[y] || {}, V && I !== void 0) this.deletedStates[y][ae] !== null && (this.deletedStates[y][ae] = this.deletedStates[y][ae] || {}, this.deletedStates[y][ae][V] = null);
+                else if (I !== void 0) {
+                  var he = this.stateChanges[y] && this.stateChanges[y][ae];
+                  if (he) {
+                    this.deletedStates[y][ae] = {};
+                    for (V in this.stateChanges[y][ae]) this.deletedStates[y][ae][V] = null;
+                  } else this.deletedStates[y][ae] = null;
+                } else this.deletedStates[y] = null;
+              }
+            }, l3.prototype.getState = function(y, I) {
+              var V = String(I), $ = this.state[y] || {}, ae = this.stateChanges[y] || {}, he = x({}, $[V], ae[V]);
+              if (this.deletedStates[y] === null) return {};
+              if (this.deletedStates[y]) {
+                var ze = this.deletedStates[y][I];
+                if (ze === null) return {};
+                for (var rt in ze) delete he[rt];
+              }
+              return he;
+            }, l3.prototype.initializeTileState = function(y, I) {
+              y.setFeatureState(this.state, I);
+            }, l3.prototype.coalesceChanges = function(y, I) {
+              var V = {};
+              for (var $ in this.stateChanges) {
+                this.state[$] = this.state[$] || {};
+                var ae = {};
+                for (var he in this.stateChanges[$]) this.state[$][he] || (this.state[$][he] = {}), x(this.state[$][he], this.stateChanges[$][he]), ae[he] = this.state[$][he];
+                V[$] = ae;
+              }
+              for (var ze in this.deletedStates) {
+                this.state[ze] = this.state[ze] || {};
+                var rt = {};
+                if (this.deletedStates[ze] === null) for (var gt in this.state[ze]) rt[gt] = {}, this.state[ze][gt] = {};
+                else for (var Et in this.deletedStates[ze]) {
+                  var or = this.deletedStates[ze][Et] === null;
+                  if (or) this.state[ze][Et] = {};
+                  else for (var _r = 0, pr = Object.keys(this.deletedStates[ze][Et]); _r < pr.length; _r += 1) {
+                    var Fr = pr[_r];
+                    delete this.state[ze][Et][Fr];
+                  }
+                  rt[Et] = this.state[ze][Et];
+                }
+                V[ze] = V[ze] || {}, x(V[ze], rt);
+              }
+              if (this.stateChanges = {}, this.deletedStates = {}, Object.keys(V).length !== 0) for (var oi in y) {
+                var Hi = y[oi];
+                Hi.setFeatureState(V, I);
+              }
+            };
+            var by = function(y, I) {
+              this.tileID = y, this.x = y.canonical.x, this.y = y.canonical.y, this.z = y.canonical.z, this.grid = new au(Ci, 16, 0), this.grid3D = new au(Ci, 16, 0), this.featureIndexArray = new Ys(), this.promoteId = I;
+            };
+            by.prototype.insert = function(y, I, V, $, ae, he) {
+              var ze = this.featureIndexArray.length;
+              this.featureIndexArray.emplaceBack(V, $, ae);
+              for (var rt = he ? this.grid3D : this.grid, gt = 0; gt < I.length; gt++) {
+                for (var Et = I[gt], or = [1 / 0, 1 / 0, -1 / 0, -1 / 0], _r = 0; _r < Et.length; _r++) {
+                  var pr = Et[_r];
+                  or[0] = Math.min(or[0], pr.x), or[1] = Math.min(or[1], pr.y), or[2] = Math.max(or[2], pr.x), or[3] = Math.max(or[3], pr.y);
+                }
+                or[0] < Ci && or[1] < Ci && or[2] >= 0 && or[3] >= 0 && rt.insert(ze, or[0], or[1], or[2], or[3]);
+              }
+            }, by.prototype.loadVTLayers = function() {
+              return this.vtLayers || (this.vtLayers = new mg.VectorTile(new Xa(this.rawTileData)).layers, this.sourceLayerCoder = new c6(this.vtLayers ? Object.keys(this.vtLayers).sort() : ["_geojsonTileLayer"])), this.vtLayers;
+            }, by.prototype.query = function(y, I, V, $) {
+              var ae = this;
+              this.loadVTLayers();
+              for (var he = y.params || {}, ze = Ci / y.tileSize / y.scale, rt = be(he.filter), gt = y.queryGeometry, Et = y.queryPadding * ze, or = fee(gt), _r = this.grid.query(or.minX - Et, or.minY - Et, or.maxX + Et, or.maxY + Et), pr = fee(y.cameraQueryGeometry), Fr = this.grid3D.query(pr.minX - Et, pr.minY - Et, pr.maxX + Et, pr.maxY + Et, function(Zn, ga, ha, eo) {
+                return mp(y.cameraQueryGeometry, Zn - Et, ga - Et, ha + Et, eo + Et);
+              }), oi = 0, Hi = Fr; oi < Hi.length; oi += 1) {
+                var Ai = Hi[oi];
+                _r.push(Ai);
+              }
+              _r.sort(ptt);
+              for (var bn = {}, nn, xn = function(Zn) {
+                var ga = _r[Zn];
+                if (ga !== nn) {
+                  nn = ga;
+                  var ha = ae.featureIndexArray.get(ga), eo = null;
+                  ae.loadMatchingFeature(bn, ha.bucketIndex, ha.sourceLayerIndex, ha.featureIndex, rt, he.layers, he.availableImages, I, V, $, function(za, Za, Jo) {
+                    return eo || (eo = zn(za)), Za.queryIntersectsFeature(gt, za, Jo, eo, ae.z, y.transform, ze, y.pixelPosMatrix);
+                  });
+                }
+              }, Pn = 0; Pn < _r.length; Pn++) xn(Pn);
+              return bn;
+            }, by.prototype.loadMatchingFeature = function(y, I, V, $, ae, he, ze, rt, gt, Et, or) {
+              var _r = this.bucketLayerIDs[I];
+              if (!(he && !N(he, _r))) {
+                var pr = this.sourceLayerCoder.decode(V), Fr = this.vtLayers[pr], oi = Fr.feature($);
+                if (ae.needGeometry) {
+                  var Hi = Ja(oi, true);
+                  if (!ae.filter(new Gn(this.tileID.overscaledZ), Hi, this.tileID.canonical)) return;
+                } else if (!ae.filter(new Gn(this.tileID.overscaledZ), oi)) return;
+                for (var Ai = this.getId(oi, pr), bn = 0; bn < _r.length; bn++) {
+                  var nn = _r[bn];
+                  if (!(he && he.indexOf(nn) < 0)) {
+                    var xn = rt[nn];
+                    if (xn) {
+                      var Pn = {};
+                      Ai !== void 0 && Et && (Pn = Et.getState(xn.sourceLayer || "_geojsonTileLayer", Ai));
+                      var Zn = x({}, gt[nn]);
+                      Zn.paint = cee(Zn.paint, xn.paint, oi, Pn, ze), Zn.layout = cee(Zn.layout, xn.layout, oi, Pn, ze);
+                      var ga = !or || or(oi, xn, Pn);
+                      if (ga) {
+                        var ha = new f6(oi, this.z, this.x, this.y, Ai);
+                        ha.layer = Zn;
+                        var eo = y[nn];
+                        eo === void 0 && (eo = y[nn] = []), eo.push({ featureIndex: $, feature: ha, intersectionZ: ga });
+                      }
+                    }
+                  }
+                }
+              }
+            }, by.prototype.lookupSymbolFeatures = function(y, I, V, $, ae, he, ze, rt) {
+              var gt = {};
+              this.loadVTLayers();
+              for (var Et = be(ae), or = 0, _r = y; or < _r.length; or += 1) {
+                var pr = _r[or];
+                this.loadMatchingFeature(gt, V, $, pr, Et, he, ze, rt, I);
+              }
+              return gt;
+            }, by.prototype.hasLayer = function(y) {
+              for (var I = 0, V = this.bucketLayerIDs; I < V.length; I += 1) for (var $ = V[I], ae = 0, he = $; ae < he.length; ae += 1) {
+                var ze = he[ae];
+                if (y === ze) return true;
+              }
+              return false;
+            }, by.prototype.getId = function(y, I) {
+              var V = y.id;
+              if (this.promoteId) {
+                var $ = typeof this.promoteId == "string" ? this.promoteId : this.promoteId[I];
+                V = y.properties[$], typeof V == "boolean" && (V = Number(V));
+              }
+              return V;
+            }, X("FeatureIndex", by, { omit: ["rawTileData", "sourceLayerCoder"] });
+            function cee(m, y, I, V, $) {
+              return G(m, function(ae, he) {
+                var ze = y instanceof Sc ? y.get(he) : null;
+                return ze && ze.evaluate ? ze.evaluate(I, V, $) : ze;
+              });
+            }
+            function fee(m) {
+              for (var y = 1 / 0, I = 1 / 0, V = -1 / 0, $ = -1 / 0, ae = 0, he = m; ae < he.length; ae += 1) {
+                var ze = he[ae];
+                y = Math.min(y, ze.x), I = Math.min(I, ze.y), V = Math.max(V, ze.x), $ = Math.max($, ze.y);
+              }
+              return { minX: y, minY: I, maxX: V, maxY: $ };
+            }
+            function ptt(m, y) {
+              return y - m;
+            }
+            var gtt = 3e4, Jh = function(y, I) {
+              this.tileID = y, this.uid = g(), this.uses = 0, this.tileSize = I, this.buckets = {}, this.expirationTime = null, this.queryPadding = 0, this.hasSymbolBuckets = false, this.hasRTLText = false, this.dependencies = {}, this.expiredRequestCount = 0, this.state = "loading";
+            };
+            Jh.prototype.registerFadeDuration = function(y) {
+              var I = y + this.timeAdded;
+              I < lt.now() || this.fadeEndTime && I < this.fadeEndTime || (this.fadeEndTime = I);
+            }, Jh.prototype.wasRequested = function() {
+              return this.state === "errored" || this.state === "loaded" || this.state === "reloading";
+            }, Jh.prototype.loadVectorData = function(y, I, V) {
+              if (this.hasData() && this.unloadVectorData(), this.state = "loaded", !y) {
+                this.collisionBoxArray = new Va();
+                return;
+              }
+              y.featureIndex && (this.latestFeatureIndex = y.featureIndex, y.rawTileData ? (this.latestRawTileData = y.rawTileData, this.latestFeatureIndex.rawTileData = y.rawTileData) : this.latestRawTileData && (this.latestFeatureIndex.rawTileData = this.latestRawTileData)), this.collisionBoxArray = y.collisionBoxArray, this.buckets = vtt(y.buckets, I.style), this.hasSymbolBuckets = false;
+              for (var $ in this.buckets) {
+                var ae = this.buckets[$];
+                if (ae instanceof Pu) if (this.hasSymbolBuckets = true, V) ae.justReloaded = true;
+                else break;
+              }
+              if (this.hasRTLText = false, this.hasSymbolBuckets) for (var he in this.buckets) {
+                var ze = this.buckets[he];
+                if (ze instanceof Pu && ze.hasRTLText) {
+                  this.hasRTLText = true, Xs();
+                  break;
+                }
+              }
+              this.queryPadding = 0;
+              for (var rt in this.buckets) {
+                var gt = this.buckets[rt];
+                this.queryPadding = Math.max(this.queryPadding, I.style.getLayer(rt).queryRadius(gt));
+              }
+              y.imageAtlas && (this.imageAtlas = y.imageAtlas), y.glyphAtlasImage && (this.glyphAtlasImage = y.glyphAtlasImage);
+            }, Jh.prototype.unloadVectorData = function() {
+              for (var y in this.buckets) this.buckets[y].destroy();
+              this.buckets = {}, this.imageAtlasTexture && this.imageAtlasTexture.destroy(), this.imageAtlas && (this.imageAtlas = null), this.glyphAtlasTexture && this.glyphAtlasTexture.destroy(), this.latestFeatureIndex = null, this.state = "unloaded";
+            }, Jh.prototype.getBucket = function(y) {
+              return this.buckets[y.id];
+            }, Jh.prototype.upload = function(y) {
+              for (var I in this.buckets) {
+                var V = this.buckets[I];
+                V.uploadPending() && V.upload(y);
+              }
+              var $ = y.gl;
+              this.imageAtlas && !this.imageAtlas.uploaded && (this.imageAtlasTexture = new hb(y, this.imageAtlas.image, $.RGBA), this.imageAtlas.uploaded = true), this.glyphAtlasImage && (this.glyphAtlasTexture = new hb(y, this.glyphAtlasImage, $.ALPHA), this.glyphAtlasImage = null);
+            }, Jh.prototype.prepare = function(y) {
+              this.imageAtlas && this.imageAtlas.patchUpdatedImages(y, this.imageAtlasTexture);
+            }, Jh.prototype.queryRenderedFeatures = function(y, I, V, $, ae, he, ze, rt, gt, Et) {
+              return !this.latestFeatureIndex || !this.latestFeatureIndex.rawTileData ? {} : this.latestFeatureIndex.query({ queryGeometry: $, cameraQueryGeometry: ae, scale: he, tileSize: this.tileSize, pixelPosMatrix: Et, transform: rt, params: ze, queryPadding: this.queryPadding * gt }, y, I, V);
+            }, Jh.prototype.querySourceFeatures = function(y, I) {
+              var V = this.latestFeatureIndex;
+              if (!(!V || !V.rawTileData)) {
+                var $ = V.loadVTLayers(), ae = I ? I.sourceLayer : "", he = $._geojsonTileLayer || $[ae];
+                if (he) for (var ze = be(I && I.filter), rt = this.tileID.canonical, gt = rt.z, Et = rt.x, or = rt.y, _r = { z: gt, x: Et, y: or }, pr = 0; pr < he.length; pr++) {
+                  var Fr = he.feature(pr);
+                  if (ze.needGeometry) {
+                    var oi = Ja(Fr, true);
+                    if (!ze.filter(new Gn(this.tileID.overscaledZ), oi, this.tileID.canonical)) continue;
+                  } else if (!ze.filter(new Gn(this.tileID.overscaledZ), Fr)) continue;
+                  var Hi = V.getId(Fr, ae), Ai = new f6(Fr, gt, Et, or, Hi);
+                  Ai.tile = _r, y.push(Ai);
+                }
+              }
+            }, Jh.prototype.hasData = function() {
+              return this.state === "loaded" || this.state === "reloading" || this.state === "expired";
+            }, Jh.prototype.patternsLoaded = function() {
+              return this.imageAtlas && !!Object.keys(this.imageAtlas.patternPositions).length;
+            }, Jh.prototype.setExpiryData = function(y) {
+              var I = this.expirationTime;
+              if (y.cacheControl) {
+                var V = ge(y.cacheControl);
+                V["max-age"] && (this.expirationTime = Date.now() + V["max-age"] * 1e3);
+              } else y.expires && (this.expirationTime = new Date(y.expires).getTime());
+              if (this.expirationTime) {
+                var $ = Date.now(), ae = false;
+                if (this.expirationTime > $) ae = false;
+                else if (!I) ae = true;
+                else if (this.expirationTime < I) ae = true;
+                else {
+                  var he = this.expirationTime - I;
+                  he ? this.expirationTime = $ + Math.max(he, gtt) : ae = true;
+                }
+                ae ? (this.expiredRequestCount++, this.state = "expired") : this.expiredRequestCount = 0;
+              }
+            }, Jh.prototype.getExpiryTimeout = function() {
+              if (this.expirationTime) return this.expiredRequestCount ? 1e3 * (1 << Math.min(this.expiredRequestCount - 1, 31)) : Math.min(this.expirationTime - (/* @__PURE__ */ new Date()).getTime(), Math.pow(2, 31) - 1);
+            }, Jh.prototype.setFeatureState = function(y, I) {
+              if (!(!this.latestFeatureIndex || !this.latestFeatureIndex.rawTileData || Object.keys(y).length === 0)) {
+                var V = this.latestFeatureIndex.loadVTLayers();
+                for (var $ in this.buckets) if (I.style.hasLayer($)) {
+                  var ae = this.buckets[$], he = ae.layers[0].sourceLayer || "_geojsonTileLayer", ze = V[he], rt = y[he];
+                  if (!(!ze || !rt || Object.keys(rt).length === 0)) {
+                    ae.update(rt, ze, this.imageAtlas && this.imageAtlas.patternPositions || {});
+                    var gt = I && I.style && I.style.getLayer($);
+                    gt && (this.queryPadding = Math.max(this.queryPadding, gt.queryRadius(ae)));
+                  }
+                }
+              }
+            }, Jh.prototype.holdingForFade = function() {
+              return this.symbolFadeHoldUntil !== void 0;
+            }, Jh.prototype.symbolFadeFinished = function() {
+              return !this.symbolFadeHoldUntil || this.symbolFadeHoldUntil < lt.now();
+            }, Jh.prototype.clearFadeHold = function() {
+              this.symbolFadeHoldUntil = void 0;
+            }, Jh.prototype.setHoldDuration = function(y) {
+              this.symbolFadeHoldUntil = lt.now() + y;
+            }, Jh.prototype.setDependencies = function(y, I) {
+              for (var V = {}, $ = 0, ae = I; $ < ae.length; $ += 1) {
+                var he = ae[$];
+                V[he] = true;
+              }
+              this.dependencies[y] = V;
+            }, Jh.prototype.hasDependency = function(y, I) {
+              for (var V = 0, $ = y; V < $.length; V += 1) {
+                var ae = $[V], he = this.dependencies[ae];
+                if (he) for (var ze = 0, rt = I; ze < rt.length; ze += 1) {
+                  var gt = rt[ze];
+                  if (he[gt]) return true;
+                }
+              }
+              return false;
+            };
+            var mtt = ["type", "source", "source-layer", "minzoom", "maxzoom", "filter", "layout"], U1 = f.performance, hee = function(y) {
+              this._marks = { start: [y.url, "start"].join("#"), end: [y.url, "end"].join("#"), measure: y.url.toString() }, U1.mark(this._marks.start);
+            };
+            hee.prototype.finish = function() {
+              U1.mark(this._marks.end);
+              var y = U1.getEntriesByName(this._marks.measure);
+              return y.length === 0 && (U1.measure(this._marks.measure, this._marks.start, this._marks.end), y = U1.getEntriesByName(this._marks.measure), U1.clearMarks(this._marks.start), U1.clearMarks(this._marks.end), U1.clearMeasures(this._marks.measure)), y;
+            }, i.Actor = s3, i.AlphaImage = Dv, i.CanonicalTileID = vb, i.CollisionBoxArray = Va, i.Color = cs, i.DEMData = xy, i.DataConstantProperty = Me, i.DictionaryCoder = c6, i.EXTENT = Ci, i.ErrorEvent = da, i.EvaluationParameters = Gn, i.Event = Xo, i.Evented = Wn, i.FeatureIndex = by, i.FillBucket = yp, i.FillExtrusionBucket = Vp, i.ImageAtlas = yg, i.ImagePosition = Yf, i.LineBucket = sh, i.LngLat = Hc, i.LngLatBounds = lh, i.MercatorCoordinate = db, i.ONE_EM = Tn, i.OverscaledTileID = uh, i.Point = u, i.Point$1 = u, i.Properties = Nr, i.Protobuf = Xa, i.RGBAImage = Eh, i.RequestManager = $e, i.RequestPerformance = hee, i.ResourceType = ra, i.SegmentVector = io, i.SourceFeatureState = l3, i.StructArrayLayout1ui2 = ba, i.StructArrayLayout2f1f2i16 = Vi, i.StructArrayLayout2i4 = Yr, i.StructArrayLayout3ui6 = pn, i.StructArrayLayout4i8 = xi, i.SymbolBucket = Pu, i.Texture = hb, i.Tile = Jh, i.Transitionable = Uo, i.Uniform1f = Qe, i.Uniform1i = Ve, i.Uniform2f = at, i.Uniform3f = Ct, i.Uniform4f = Ot, i.UniformColor = Rt, i.UniformMatrix4f = Dt, i.UnwrappedTileID = uee, i.ValidationError = _a, i.WritingMode = uv, i.ZoomHistory = kt, i.add = Rv, i.addDynamicAttributes = mO, i.asyncAll = E, i.bezier = _, i.bindAll = O, i.browser = lt, i.cacheEntryPossiblyAdded = ji, i.clamp = p, i.clearTileCache = wi, i.clipLine = WQ, i.clone = C1, i.clone$1 = j, i.clone$2 = Ow, i.collisionCircleLayout = Lt, i.config = pt, i.create = k1, i.create$1 = Zh, i.create$2 = vg, i.createCommonjsModule = a, i.createExpression = oo, i.createLayout = Wi, i.createStyleLayer = ltt, i.cross = G9, i.deepEqual = h, i.dot = V9, i.dot$1 = Z9, i.ease = b, i.emitValidationErrors = Lu, i.endsWith = U, i.enforceCacheSizeLimit = In, i.evaluateSizeForFeature = BQ, i.evaluateSizeForZoom = NQ, i.evaluateVariableOffset = YQ, i.evented = Ia, i.extend = x, i.featureFilter = be, i.filterObject = Z, i.fromRotation = am, i.getAnchorAlignment = CS, i.getAnchorJustification = gO, i.getArrayBuffer = ri, i.getImage = ua, i.getJSON = Xr, i.getRTLTextPluginStatus = yo, i.getReferrer = Ut, i.getVideo = ma, i.identity = dy, i.invert = om, i.isChar = nt, i.isMapboxURL = St, i.keysDifference = L, i.makeRequest = Er, i.mapObject = G, i.mercatorXfromLng = oee, i.mercatorYfromLat = see, i.mercatorZfromAltitude = lee, i.mul = Yx, i.multiply = sm, i.mvt = mg, i.nextPowerOfTwo = A, i.normalize = Kx, i.number = nl, i.offscreenCanvasSupported = Fn, i.ortho = wu, i.parseGlyphPBF = p0, i.pbf = Xa, i.performSymbolLayout = Vet, i.perspective = L1, i.pick = C, i.plugin = Ms, i.polygonIntersectsPolygon = so, i.postMapLoadEvent = We, i.postTurnstileEvent = Ge, i.potpack = ep, i.refProperties = mtt, i.register = X, i.registerForPluginStateChange = Da, i.renderColorRamp = Qx, i.rotate = hy, i.rotateX = Sd, i.rotateZ = vy, i.scale = tu, i.scale$1 = X9, i.scale$2 = qw, i.setCacheLimits = On, i.setRTLTextPlugin = go, i.sphericalToCartesian = Ce, i.sqrLen = uS, i.styleSpec = Rn, i.sub = j9, i.symbolSize = Ret, i.transformMat3 = H9, i.transformMat4 = py, i.translate = vc, i.triggerPluginCompletionEvent = ia, i.uniqueId = g, i.validateCustomStyleLayer = att, i.validateLight = To, i.validateStyle = wo, i.values = T, i.vectorTile = mg, i.version = o, i.warnOnce = re, i.webpSupported = Vt, i.window = f, i.wrap = k;
+          }), n(["./shared"], function(i) {
+            function a(Ut) {
+              var wt = typeof Ut;
+              if (wt === "number" || wt === "boolean" || wt === "string" || Ut === void 0 || Ut === null) return JSON.stringify(Ut);
+              if (Array.isArray(Ut)) {
+                for (var rr = "[", nr = 0, Er = Ut; nr < Er.length; nr += 1) {
+                  var Xr = Er[nr];
+                  rr += a(Xr) + ",";
+                }
+                return rr + "]";
+              }
+              for (var ri = Object.keys(Ut).sort(), Qr = "{", Oi = 0; Oi < ri.length; Oi++) Qr += JSON.stringify(ri[Oi]) + ":" + a(Ut[ri[Oi]]) + ",";
+              return Qr + "}";
+            }
+            function o(Ut) {
+              for (var wt = "", rr = 0, nr = i.refProperties; rr < nr.length; rr += 1) {
+                var Er = nr[rr];
+                wt += "/" + a(Ut[Er]);
+              }
+              return wt;
+            }
+            function s(Ut, wt) {
+              for (var rr = {}, nr = 0; nr < Ut.length; nr++) {
+                var Er = wt && wt[Ut[nr].id] || o(Ut[nr]);
+                wt && (wt[Ut[nr].id] = Er);
+                var Xr = rr[Er];
+                Xr || (Xr = rr[Er] = []), Xr.push(Ut[nr]);
+              }
+              var ri = [];
+              for (var Qr in rr) ri.push(rr[Qr]);
+              return ri;
+            }
+            var l = function(wt) {
+              this.keyCache = {}, wt && this.replace(wt);
+            };
+            l.prototype.replace = function(wt) {
+              this._layerConfigs = {}, this._layers = {}, this.update(wt, []);
+            }, l.prototype.update = function(wt, rr) {
+              for (var nr = this, Er = 0, Xr = wt; Er < Xr.length; Er += 1) {
+                var ri = Xr[Er];
+                this._layerConfigs[ri.id] = ri;
+                var Qr = this._layers[ri.id] = i.createStyleLayer(ri);
+                Qr._featureFilter = i.featureFilter(Qr.filter), this.keyCache[ri.id] && delete this.keyCache[ri.id];
+              }
+              for (var Oi = 0, $i = rr; Oi < $i.length; Oi += 1) {
+                var tn = $i[Oi];
+                delete this.keyCache[tn], delete this._layerConfigs[tn], delete this._layers[tn];
+              }
+              this.familiesBySource = {};
+              for (var fn = s(i.values(this._layerConfigs), this.keyCache), yn = 0, Sn = fn; yn < Sn.length; yn += 1) {
+                var Ba = Sn[yn], ua = Ba.map(function(Wn) {
+                  return nr._layers[Wn.id];
+                }), ma = ua[0];
+                if (ma.visibility !== "none") {
+                  var Wa = ma.source || "", Fa = this.familiesBySource[Wa];
+                  Fa || (Fa = this.familiesBySource[Wa] = {});
+                  var Xo = ma.sourceLayer || "_geojsonTileLayer", da = Fa[Xo];
+                  da || (da = Fa[Xo] = []), da.push(ua);
+                }
+              }
+            };
+            var u = 1, c = function(wt) {
+              var rr = {}, nr = [];
+              for (var Er in wt) {
+                var Xr = wt[Er], ri = rr[Er] = {};
+                for (var Qr in Xr) {
+                  var Oi = Xr[+Qr];
+                  if (!(!Oi || Oi.bitmap.width === 0 || Oi.bitmap.height === 0)) {
+                    var $i = { x: 0, y: 0, w: Oi.bitmap.width + 2 * u, h: Oi.bitmap.height + 2 * u };
+                    nr.push($i), ri[Qr] = { rect: $i, metrics: Oi.metrics };
+                  }
+                }
+              }
+              var tn = i.potpack(nr), fn = tn.w, yn = tn.h, Sn = new i.AlphaImage({ width: fn || 1, height: yn || 1 });
+              for (var Ba in wt) {
+                var ua = wt[Ba];
+                for (var ma in ua) {
+                  var Wa = ua[+ma];
+                  if (!(!Wa || Wa.bitmap.width === 0 || Wa.bitmap.height === 0)) {
+                    var Fa = rr[Ba][ma].rect;
+                    i.AlphaImage.copy(Wa.bitmap, Sn, { x: 0, y: 0 }, { x: Fa.x + u, y: Fa.y + u }, Wa.bitmap);
+                  }
+                }
+              }
+              this.image = Sn, this.positions = rr;
+            };
+            i.register("GlyphAtlas", c);
+            var f = function(wt) {
+              this.tileID = new i.OverscaledTileID(wt.tileID.overscaledZ, wt.tileID.wrap, wt.tileID.canonical.z, wt.tileID.canonical.x, wt.tileID.canonical.y), this.uid = wt.uid, this.zoom = wt.zoom, this.pixelRatio = wt.pixelRatio, this.tileSize = wt.tileSize, this.source = wt.source, this.overscaling = this.tileID.overscaleFactor(), this.showCollisionBoxes = wt.showCollisionBoxes, this.collectResourceTiming = !!wt.collectResourceTiming, this.returnDependencies = !!wt.returnDependencies, this.promoteId = wt.promoteId;
+            };
+            f.prototype.parse = function(wt, rr, nr, Er, Xr) {
+              var ri = this;
+              this.status = "parsing", this.data = wt, this.collisionBoxArray = new i.CollisionBoxArray();
+              var Qr = new i.DictionaryCoder(Object.keys(wt.layers).sort()), Oi = new i.FeatureIndex(this.tileID, this.promoteId);
+              Oi.bucketLayerIDs = [];
+              var $i = {}, tn = { featureIndex: Oi, iconDependencies: {}, patternDependencies: {}, glyphDependencies: {}, availableImages: nr }, fn = rr.familiesBySource[this.source];
+              for (var yn in fn) {
+                var Sn = wt.layers[yn];
+                if (Sn) {
+                  Sn.version === 1 && i.warnOnce('Vector tile source "' + this.source + '" layer "' + yn + '" does not use vector tile spec v2 and therefore may have some rendering errors.');
+                  for (var Ba = Qr.encode(yn), ua = [], ma = 0; ma < Sn.length; ma++) {
+                    var Wa = Sn.feature(ma), Fa = Oi.getId(Wa, yn);
+                    ua.push({ feature: Wa, id: Fa, index: ma, sourceLayerIndex: Ba });
+                  }
+                  for (var Xo = 0, da = fn[yn]; Xo < da.length; Xo += 1) {
+                    var Wn = da[Xo], Ha = Wn[0];
+                    if (!(Ha.minzoom && this.zoom < Math.floor(Ha.minzoom)) && !(Ha.maxzoom && this.zoom >= Ha.maxzoom) && Ha.visibility !== "none") {
+                      h(Wn, this.zoom, nr);
+                      var vo = $i[Ha.id] = Ha.createBucket({ index: Oi.bucketLayerIDs.length, layers: Wn, zoom: this.zoom, pixelRatio: this.pixelRatio, overscaling: this.overscaling, collisionBoxArray: this.collisionBoxArray, sourceLayerIndex: Ba, sourceID: this.source });
+                      vo.populate(ua, tn, this.tileID.canonical), Oi.bucketLayerIDs.push(Wn.map(function(Li) {
+                        return Li.id;
+                      }));
+                    }
+                  }
+                }
+              }
+              var jn, Mt, kr, Jr, vi = i.mapObject(tn.glyphDependencies, function(Li) {
+                return Object.keys(Li).map(Number);
+              });
+              Object.keys(vi).length ? Er.send("getGlyphs", { uid: this.uid, stacks: vi }, function(Li, _n) {
+                jn || (jn = Li, Mt = _n, Mn.call(ri));
+              }) : Mt = {};
+              var hn = Object.keys(tn.iconDependencies);
+              hn.length ? Er.send("getImages", { icons: hn, source: this.source, tileID: this.tileID, type: "icons" }, function(Li, _n) {
+                jn || (jn = Li, kr = _n, Mn.call(ri));
+              }) : kr = {};
+              var An = Object.keys(tn.patternDependencies);
+              An.length ? Er.send("getImages", { icons: An, source: this.source, tileID: this.tileID, type: "patterns" }, function(Li, _n) {
+                jn || (jn = Li, Jr = _n, Mn.call(ri));
+              }) : Jr = {}, Mn.call(this);
+              function Mn() {
+                if (jn) return Xr(jn);
+                if (Mt && kr && Jr) {
+                  var Li = new c(Mt), _n = new i.ImageAtlas(kr, Jr);
+                  for (var ya in $i) {
+                    var $n = $i[ya];
+                    $n instanceof i.SymbolBucket ? (h($n.layers, this.zoom, nr), i.performSymbolLayout($n, Mt, Li.positions, kr, _n.iconPositions, this.showCollisionBoxes, this.tileID.canonical)) : $n.hasPattern && ($n instanceof i.LineBucket || $n instanceof i.FillBucket || $n instanceof i.FillExtrusionBucket) && (h($n.layers, this.zoom, nr), $n.addFeatures(tn, this.tileID.canonical, _n.patternPositions));
+                  }
+                  this.status = "done", Xr(null, { buckets: i.values($i).filter(function(Ma) {
+                    return !Ma.isEmpty();
+                  }), featureIndex: Oi, collisionBoxArray: this.collisionBoxArray, glyphAtlasImage: Li.image, imageAtlas: _n, glyphMap: this.returnDependencies ? Mt : null, iconMap: this.returnDependencies ? kr : null, glyphPositions: this.returnDependencies ? Li.positions : null });
+                }
+              }
+            };
+            function h(Ut, wt, rr) {
+              for (var nr = new i.EvaluationParameters(wt), Er = 0, Xr = Ut; Er < Xr.length; Er += 1) {
+                var ri = Xr[Er];
+                ri.recalculate(nr, rr);
+              }
+            }
+            function d(Ut, wt) {
+              var rr = i.getArrayBuffer(Ut.request, function(nr, Er, Xr, ri) {
+                nr ? wt(nr) : Er && wt(null, { vectorTile: new i.vectorTile.VectorTile(new i.pbf(Er)), rawData: Er, cacheControl: Xr, expires: ri });
+              });
+              return function() {
+                rr.cancel(), wt();
+              };
+            }
+            var v = function(wt, rr, nr, Er) {
+              this.actor = wt, this.layerIndex = rr, this.availableImages = nr, this.loadVectorData = Er || d, this.loading = {}, this.loaded = {};
+            };
+            v.prototype.loadTile = function(wt, rr) {
+              var nr = this, Er = wt.uid;
+              this.loading || (this.loading = {});
+              var Xr = wt && wt.request && wt.request.collectResourceTiming ? new i.RequestPerformance(wt.request) : false, ri = this.loading[Er] = new f(wt);
+              ri.abort = this.loadVectorData(wt, function(Qr, Oi) {
+                if (delete nr.loading[Er], Qr || !Oi) return ri.status = "done", nr.loaded[Er] = ri, rr(Qr);
+                var $i = Oi.rawData, tn = {};
+                Oi.expires && (tn.expires = Oi.expires), Oi.cacheControl && (tn.cacheControl = Oi.cacheControl);
+                var fn = {};
+                if (Xr) {
+                  var yn = Xr.finish();
+                  yn && (fn.resourceTiming = JSON.parse(JSON.stringify(yn)));
+                }
+                ri.vectorTile = Oi.vectorTile, ri.parse(Oi.vectorTile, nr.layerIndex, nr.availableImages, nr.actor, function(Sn, Ba) {
+                  if (Sn || !Ba) return rr(Sn);
+                  rr(null, i.extend({ rawTileData: $i.slice(0) }, Ba, tn, fn));
+                }), nr.loaded = nr.loaded || {}, nr.loaded[Er] = ri;
+              });
+            }, v.prototype.reloadTile = function(wt, rr) {
+              var nr = this, Er = this.loaded, Xr = wt.uid, ri = this;
+              if (Er && Er[Xr]) {
+                var Qr = Er[Xr];
+                Qr.showCollisionBoxes = wt.showCollisionBoxes;
+                var Oi = function($i, tn) {
+                  var fn = Qr.reloadCallback;
+                  fn && (delete Qr.reloadCallback, Qr.parse(Qr.vectorTile, ri.layerIndex, nr.availableImages, ri.actor, fn)), rr($i, tn);
+                };
+                Qr.status === "parsing" ? Qr.reloadCallback = Oi : Qr.status === "done" && (Qr.vectorTile ? Qr.parse(Qr.vectorTile, this.layerIndex, this.availableImages, this.actor, Oi) : Oi());
+              }
+            }, v.prototype.abortTile = function(wt, rr) {
+              var nr = this.loading, Er = wt.uid;
+              nr && nr[Er] && nr[Er].abort && (nr[Er].abort(), delete nr[Er]), rr();
+            }, v.prototype.removeTile = function(wt, rr) {
+              var nr = this.loaded, Er = wt.uid;
+              nr && nr[Er] && delete nr[Er], rr();
+            };
+            var _ = i.window.ImageBitmap, b = function() {
+              this.loaded = {};
+            };
+            b.prototype.loadTile = function(wt, rr) {
+              var nr = wt.uid, Er = wt.encoding, Xr = wt.rawImageData, ri = _ && Xr instanceof _ ? this.getImageData(Xr) : Xr, Qr = new i.DEMData(nr, ri, Er);
+              this.loaded = this.loaded || {}, this.loaded[nr] = Qr, rr(null, Qr);
+            }, b.prototype.getImageData = function(wt) {
+              (!this.offscreenCanvas || !this.offscreenCanvasContext) && (this.offscreenCanvas = new OffscreenCanvas(wt.width, wt.height), this.offscreenCanvasContext = this.offscreenCanvas.getContext("2d")), this.offscreenCanvas.width = wt.width, this.offscreenCanvas.height = wt.height, this.offscreenCanvasContext.drawImage(wt, 0, 0, wt.width, wt.height);
+              var rr = this.offscreenCanvasContext.getImageData(-1, -1, wt.width + 2, wt.height + 2);
+              return this.offscreenCanvasContext.clearRect(0, 0, this.offscreenCanvas.width, this.offscreenCanvas.height), new i.RGBAImage({ width: rr.width, height: rr.height }, rr.data);
+            }, b.prototype.removeTile = function(wt) {
+              var rr = this.loaded, nr = wt.uid;
+              rr && rr[nr] && delete rr[nr];
+            };
+            var p = k;
+            function k(Ut, wt) {
+              var rr = Ut && Ut.type, nr;
+              if (rr === "FeatureCollection") for (nr = 0; nr < Ut.features.length; nr++) k(Ut.features[nr], wt);
+              else if (rr === "GeometryCollection") for (nr = 0; nr < Ut.geometries.length; nr++) k(Ut.geometries[nr], wt);
+              else if (rr === "Feature") k(Ut.geometry, wt);
+              else if (rr === "Polygon") E(Ut.coordinates, wt);
+              else if (rr === "MultiPolygon") for (nr = 0; nr < Ut.coordinates.length; nr++) E(Ut.coordinates[nr], wt);
+              return Ut;
+            }
+            function E(Ut, wt) {
+              if (Ut.length !== 0) {
+                T(Ut[0], wt);
+                for (var rr = 1; rr < Ut.length; rr++) T(Ut[rr], !wt);
+              }
+            }
+            function T(Ut, wt) {
+              for (var rr = 0, nr = 0, Er = Ut.length, Xr = Er - 1; nr < Er; Xr = nr++) rr += (Ut[nr][0] - Ut[Xr][0]) * (Ut[Xr][1] + Ut[nr][1]);
+              rr >= 0 != !!wt && Ut.reverse();
+            }
+            var L = i.vectorTile.VectorTileFeature.prototype.toGeoJSON, x = function(wt) {
+              this._feature = wt, this.extent = i.EXTENT, this.type = wt.type, this.properties = wt.tags, "id" in wt && !isNaN(wt.id) && (this.id = parseInt(wt.id, 10));
+            };
+            x.prototype.loadGeometry = function() {
+              if (this._feature.type === 1) {
+                for (var wt = [], rr = 0, nr = this._feature.geometry; rr < nr.length; rr += 1) {
+                  var Er = nr[rr];
+                  wt.push([new i.Point$1(Er[0], Er[1])]);
+                }
+                return wt;
+              } else {
+                for (var Xr = [], ri = 0, Qr = this._feature.geometry; ri < Qr.length; ri += 1) {
+                  for (var Oi = Qr[ri], $i = [], tn = 0, fn = Oi; tn < fn.length; tn += 1) {
+                    var yn = fn[tn];
+                    $i.push(new i.Point$1(yn[0], yn[1]));
+                  }
+                  Xr.push($i);
+                }
+                return Xr;
+              }
+            }, x.prototype.toGeoJSON = function(wt, rr, nr) {
+              return L.call(this, wt, rr, nr);
+            };
+            var C = function(wt) {
+              this.layers = { _geojsonTileLayer: this }, this.name = "_geojsonTileLayer", this.extent = i.EXTENT, this.length = wt.length, this._features = wt;
+            };
+            C.prototype.feature = function(wt) {
+              return new x(this._features[wt]);
+            };
+            var M = i.vectorTile.VectorTileFeature, g = P;
+            function P(Ut, wt) {
+              this.options = wt || {}, this.features = Ut, this.length = Ut.length;
+            }
+            P.prototype.feature = function(Ut) {
+              return new A(this.features[Ut], this.options.extent);
+            };
+            function A(Ut, wt) {
+              this.id = typeof Ut.id == "number" ? Ut.id : void 0, this.type = Ut.type, this.rawGeometry = Ut.type === 1 ? [Ut.geometry] : Ut.geometry, this.properties = Ut.tags, this.extent = wt || 4096;
+            }
+            A.prototype.loadGeometry = function() {
+              var Ut = this.rawGeometry;
+              this.geometry = [];
+              for (var wt = 0; wt < Ut.length; wt++) {
+                for (var rr = Ut[wt], nr = [], Er = 0; Er < rr.length; Er++) nr.push(new i.Point$1(rr[Er][0], rr[Er][1]));
+                this.geometry.push(nr);
+              }
+              return this.geometry;
+            }, A.prototype.bbox = function() {
+              this.geometry || this.loadGeometry();
+              for (var Ut = this.geometry, wt = 1 / 0, rr = -1 / 0, nr = 1 / 0, Er = -1 / 0, Xr = 0; Xr < Ut.length; Xr++) for (var ri = Ut[Xr], Qr = 0; Qr < ri.length; Qr++) {
+                var Oi = ri[Qr];
+                wt = Math.min(wt, Oi.x), rr = Math.max(rr, Oi.x), nr = Math.min(nr, Oi.y), Er = Math.max(Er, Oi.y);
+              }
+              return [wt, nr, rr, Er];
+            }, A.prototype.toGeoJSON = M.prototype.toGeoJSON;
+            var z = Z, O = Z, U = j, G = g;
+            function Z(Ut) {
+              var wt = new i.pbf();
+              return N(Ut, wt), wt.finish();
+            }
+            function j(Ut, wt) {
+              wt = wt || {};
+              var rr = {};
+              for (var nr in Ut) rr[nr] = new g(Ut[nr].features, wt), rr[nr].name = nr, rr[nr].version = wt.version, rr[nr].extent = wt.extent;
+              return Z({ layers: rr });
+            }
+            function N(Ut, wt) {
+              for (var rr in Ut.layers) wt.writeMessage(3, H, Ut.layers[rr]);
+            }
+            function H(Ut, wt) {
+              wt.writeVarintField(15, Ut.version || 1), wt.writeStringField(1, Ut.name || ""), wt.writeVarintField(5, Ut.extent || 4096);
+              var rr, nr = { keys: [], values: [], keycache: {}, valuecache: {} };
+              for (rr = 0; rr < Ut.length; rr++) nr.feature = Ut.feature(rr), wt.writeMessage(2, re, nr);
+              var Er = nr.keys;
+              for (rr = 0; rr < Er.length; rr++) wt.writeStringField(3, Er[rr]);
+              var Xr = nr.values;
+              for (rr = 0; rr < Xr.length; rr++) wt.writeMessage(4, ge, Xr[rr]);
+            }
+            function re(Ut, wt) {
+              var rr = Ut.feature;
+              rr.id !== void 0 && wt.writeVarintField(1, rr.id), wt.writeMessage(2, oe, Ut), wt.writeVarintField(3, rr.type), wt.writeMessage(4, Le, rr);
+            }
+            function oe(Ut, wt) {
+              var rr = Ut.feature, nr = Ut.keys, Er = Ut.values, Xr = Ut.keycache, ri = Ut.valuecache;
+              for (var Qr in rr.properties) {
+                var Oi = Xr[Qr];
+                typeof Oi == "undefined" && (nr.push(Qr), Oi = nr.length - 1, Xr[Qr] = Oi), wt.writeVarint(Oi);
+                var $i = rr.properties[Qr], tn = typeof $i;
+                tn !== "string" && tn !== "boolean" && tn !== "number" && ($i = JSON.stringify($i));
+                var fn = tn + ":" + $i, yn = ri[fn];
+                typeof yn == "undefined" && (Er.push($i), yn = Er.length - 1, ri[fn] = yn), wt.writeVarint(yn);
+              }
+            }
+            function _e(Ut, wt) {
+              return (wt << 3) + (Ut & 7);
+            }
+            function Ce(Ut) {
+              return Ut << 1 ^ Ut >> 31;
+            }
+            function Le(Ut, wt) {
+              for (var rr = Ut.loadGeometry(), nr = Ut.type, Er = 0, Xr = 0, ri = rr.length, Qr = 0; Qr < ri; Qr++) {
+                var Oi = rr[Qr], $i = 1;
+                nr === 1 && ($i = Oi.length), wt.writeVarint(_e(1, $i));
+                for (var tn = nr === 3 ? Oi.length - 1 : Oi.length, fn = 0; fn < tn; fn++) {
+                  fn === 1 && nr !== 1 && wt.writeVarint(_e(2, tn - 1));
+                  var yn = Oi[fn].x - Er, Sn = Oi[fn].y - Xr;
+                  wt.writeVarint(Ce(yn)), wt.writeVarint(Ce(Sn)), Er += yn, Xr += Sn;
+                }
+                nr === 3 && wt.writeVarint(_e(7, 1));
+              }
+            }
+            function ge(Ut, wt) {
+              var rr = typeof Ut;
+              rr === "string" ? wt.writeStringField(1, Ut) : rr === "boolean" ? wt.writeBooleanField(7, Ut) : rr === "number" && (Ut % 1 !== 0 ? wt.writeDoubleField(3, Ut) : Ut < 0 ? wt.writeSVarintField(6, Ut) : wt.writeVarintField(5, Ut));
+            }
+            z.fromVectorTileJs = O, z.fromGeojsonVt = U, z.GeoJSONWrapper = G;
+            function ie(Ut, wt, rr, nr, Er, Xr) {
+              if (!(Er - nr <= rr)) {
+                var ri = nr + Er >> 1;
+                Se(Ut, wt, ri, nr, Er, Xr % 2), ie(Ut, wt, rr, nr, ri - 1, Xr + 1), ie(Ut, wt, rr, ri + 1, Er, Xr + 1);
+              }
+            }
+            function Se(Ut, wt, rr, nr, Er, Xr) {
+              for (; Er > nr; ) {
+                if (Er - nr > 600) {
+                  var ri = Er - nr + 1, Qr = rr - nr + 1, Oi = Math.log(ri), $i = 0.5 * Math.exp(2 * Oi / 3), tn = 0.5 * Math.sqrt(Oi * $i * (ri - $i) / ri) * (Qr - ri / 2 < 0 ? -1 : 1), fn = Math.max(nr, Math.floor(rr - Qr * $i / ri + tn)), yn = Math.min(Er, Math.floor(rr + (ri - Qr) * $i / ri + tn));
+                  Se(Ut, wt, rr, fn, yn, Xr);
+                }
+                var Sn = wt[2 * rr + Xr], Ba = nr, ua = Er;
+                for (Ee(Ut, wt, nr, rr), wt[2 * Er + Xr] > Sn && Ee(Ut, wt, nr, Er); Ba < ua; ) {
+                  for (Ee(Ut, wt, Ba, ua), Ba++, ua--; wt[2 * Ba + Xr] < Sn; ) Ba++;
+                  for (; wt[2 * ua + Xr] > Sn; ) ua--;
+                }
+                wt[2 * nr + Xr] === Sn ? Ee(Ut, wt, nr, ua) : (ua++, Ee(Ut, wt, ua, Er)), ua <= rr && (nr = ua + 1), rr <= ua && (Er = ua - 1);
+              }
+            }
+            function Ee(Ut, wt, rr, nr) {
+              Ae(Ut, rr, nr), Ae(wt, 2 * rr, 2 * nr), Ae(wt, 2 * rr + 1, 2 * nr + 1);
+            }
+            function Ae(Ut, wt, rr) {
+              var nr = Ut[wt];
+              Ut[wt] = Ut[rr], Ut[rr] = nr;
+            }
+            function Be(Ut, wt, rr, nr, Er, Xr, ri) {
+              for (var Qr = [0, Ut.length - 1, 0], Oi = [], $i, tn; Qr.length; ) {
+                var fn = Qr.pop(), yn = Qr.pop(), Sn = Qr.pop();
+                if (yn - Sn <= ri) {
+                  for (var Ba = Sn; Ba <= yn; Ba++) $i = wt[2 * Ba], tn = wt[2 * Ba + 1], $i >= rr && $i <= Er && tn >= nr && tn <= Xr && Oi.push(Ut[Ba]);
+                  continue;
+                }
+                var ua = Math.floor((Sn + yn) / 2);
+                $i = wt[2 * ua], tn = wt[2 * ua + 1], $i >= rr && $i <= Er && tn >= nr && tn <= Xr && Oi.push(Ut[ua]);
+                var ma = (fn + 1) % 2;
+                (fn === 0 ? rr <= $i : nr <= tn) && (Qr.push(Sn), Qr.push(ua - 1), Qr.push(ma)), (fn === 0 ? Er >= $i : Xr >= tn) && (Qr.push(ua + 1), Qr.push(yn), Qr.push(ma));
+              }
+              return Oi;
+            }
+            function Pe(Ut, wt, rr, nr, Er, Xr) {
+              for (var ri = [0, Ut.length - 1, 0], Qr = [], Oi = Er * Er; ri.length; ) {
+                var $i = ri.pop(), tn = ri.pop(), fn = ri.pop();
+                if (tn - fn <= Xr) {
+                  for (var yn = fn; yn <= tn; yn++) me(wt[2 * yn], wt[2 * yn + 1], rr, nr) <= Oi && Qr.push(Ut[yn]);
+                  continue;
+                }
+                var Sn = Math.floor((fn + tn) / 2), Ba = wt[2 * Sn], ua = wt[2 * Sn + 1];
+                me(Ba, ua, rr, nr) <= Oi && Qr.push(Ut[Sn]);
+                var ma = ($i + 1) % 2;
+                ($i === 0 ? rr - Er <= Ba : nr - Er <= ua) && (ri.push(fn), ri.push(Sn - 1), ri.push(ma)), ($i === 0 ? rr + Er >= Ba : nr + Er >= ua) && (ri.push(Sn + 1), ri.push(tn), ri.push(ma));
+              }
+              return Qr;
+            }
+            function me(Ut, wt, rr, nr) {
+              var Er = Ut - rr, Xr = wt - nr;
+              return Er * Er + Xr * Xr;
+            }
+            var De = function(Ut) {
+              return Ut[0];
+            }, ce = function(Ut) {
+              return Ut[1];
+            }, je = function(wt, rr, nr, Er, Xr) {
+              rr === void 0 && (rr = De), nr === void 0 && (nr = ce), Er === void 0 && (Er = 64), Xr === void 0 && (Xr = Float64Array), this.nodeSize = Er, this.points = wt;
+              for (var ri = wt.length < 65536 ? Uint16Array : Uint32Array, Qr = this.ids = new ri(wt.length), Oi = this.coords = new Xr(wt.length * 2), $i = 0; $i < wt.length; $i++) Qr[$i] = $i, Oi[2 * $i] = rr(wt[$i]), Oi[2 * $i + 1] = nr(wt[$i]);
+              ie(Qr, Oi, Er, 0, Qr.length - 1, 0);
+            };
+            je.prototype.range = function(wt, rr, nr, Er) {
+              return Be(this.ids, this.coords, wt, rr, nr, Er, this.nodeSize);
+            }, je.prototype.within = function(wt, rr, nr) {
+              return Pe(this.ids, this.coords, wt, rr, nr, this.nodeSize);
+            };
+            var lt = { minZoom: 0, maxZoom: 16, minPoints: 2, radius: 40, extent: 512, nodeSize: 64, log: false, generateId: false, reduce: null, map: function(Ut) {
+              return Ut;
+            } }, pt = function(wt) {
+              this.options = fr(Object.create(lt), wt), this.trees = new Array(this.options.maxZoom + 1);
+            };
+            pt.prototype.load = function(wt) {
+              var rr = this.options, nr = rr.log, Er = rr.minZoom, Xr = rr.maxZoom, ri = rr.nodeSize;
+              nr && console.time("total time");
+              var Qr = "prepare " + wt.length + " points";
+              nr && console.time(Qr), this.points = wt;
+              for (var Oi = [], $i = 0; $i < wt.length; $i++) wt[$i].geometry && Oi.push(ot(wt[$i], $i));
+              this.trees[Xr + 1] = new je(Oi, $e, St, ri, Float32Array), nr && console.timeEnd(Qr);
+              for (var tn = Xr; tn >= Er; tn--) {
+                var fn = +Date.now();
+                Oi = this._cluster(Oi, tn), this.trees[tn] = new je(Oi, $e, St, ri, Float32Array), nr && console.log("z%d: %d clusters in %dms", tn, Oi.length, +Date.now() - fn);
+              }
+              return nr && console.timeEnd("total time"), this;
+            }, pt.prototype.getClusters = function(wt, rr) {
+              var nr = ((wt[0] + 180) % 360 + 360) % 360 - 180, Er = Math.max(-90, Math.min(90, wt[1])), Xr = wt[2] === 180 ? 180 : ((wt[2] + 180) % 360 + 360) % 360 - 180, ri = Math.max(-90, Math.min(90, wt[3]));
+              if (wt[2] - wt[0] >= 360) nr = -180, Xr = 180;
+              else if (nr > Xr) {
+                var Qr = this.getClusters([nr, Er, 180, ri], rr), Oi = this.getClusters([-180, Er, Xr, ri], rr);
+                return Qr.concat(Oi);
+              }
+              for (var $i = this.trees[this._limitZoom(rr)], tn = $i.range(Nt(nr), $t(ri), Nt(Xr), $t(Er)), fn = [], yn = 0, Sn = tn; yn < Sn.length; yn += 1) {
+                var Ba = Sn[yn], ua = $i.points[Ba];
+                fn.push(ua.numPoints ? ut(ua) : this.points[ua.index]);
+              }
+              return fn;
+            }, pt.prototype.getChildren = function(wt) {
+              var rr = this._getOriginId(wt), nr = this._getOriginZoom(wt), Er = "No cluster with the specified id.", Xr = this.trees[nr];
+              if (!Xr) throw new Error(Er);
+              var ri = Xr.points[rr];
+              if (!ri) throw new Error(Er);
+              for (var Qr = this.options.radius / (this.options.extent * Math.pow(2, nr - 1)), Oi = Xr.within(ri.x, ri.y, Qr), $i = [], tn = 0, fn = Oi; tn < fn.length; tn += 1) {
+                var yn = fn[tn], Sn = Xr.points[yn];
+                Sn.parentId === wt && $i.push(Sn.numPoints ? ut(Sn) : this.points[Sn.index]);
+              }
+              if ($i.length === 0) throw new Error(Er);
+              return $i;
+            }, pt.prototype.getLeaves = function(wt, rr, nr) {
+              rr = rr || 10, nr = nr || 0;
+              var Er = [];
+              return this._appendLeaves(Er, wt, rr, nr, 0), Er;
+            }, pt.prototype.getTile = function(wt, rr, nr) {
+              var Er = this.trees[this._limitZoom(wt)], Xr = Math.pow(2, wt), ri = this.options, Qr = ri.extent, Oi = ri.radius, $i = Oi / Qr, tn = (nr - $i) / Xr, fn = (nr + 1 + $i) / Xr, yn = { features: [] };
+              return this._addTileFeatures(Er.range((rr - $i) / Xr, tn, (rr + 1 + $i) / Xr, fn), Er.points, rr, nr, Xr, yn), rr === 0 && this._addTileFeatures(Er.range(1 - $i / Xr, tn, 1, fn), Er.points, Xr, nr, Xr, yn), rr === Xr - 1 && this._addTileFeatures(Er.range(0, tn, $i / Xr, fn), Er.points, -1, nr, Xr, yn), yn.features.length ? yn : null;
+            }, pt.prototype.getClusterExpansionZoom = function(wt) {
+              for (var rr = this._getOriginZoom(wt) - 1; rr <= this.options.maxZoom; ) {
+                var nr = this.getChildren(wt);
+                if (rr++, nr.length !== 1) break;
+                wt = nr[0].properties.cluster_id;
+              }
+              return rr;
+            }, pt.prototype._appendLeaves = function(wt, rr, nr, Er, Xr) {
+              for (var ri = this.getChildren(rr), Qr = 0, Oi = ri; Qr < Oi.length; Qr += 1) {
+                var $i = Oi[Qr], tn = $i.properties;
+                if (tn && tn.cluster ? Xr + tn.point_count <= Er ? Xr += tn.point_count : Xr = this._appendLeaves(wt, tn.cluster_id, nr, Er, Xr) : Xr < Er ? Xr++ : wt.push($i), wt.length === nr) break;
+              }
+              return Xr;
+            }, pt.prototype._addTileFeatures = function(wt, rr, nr, Er, Xr, ri) {
+              for (var Qr = 0, Oi = wt; Qr < Oi.length; Qr += 1) {
+                var $i = Oi[Qr], tn = rr[$i], fn = tn.numPoints, yn = { type: 1, geometry: [[Math.round(this.options.extent * (tn.x * Xr - nr)), Math.round(this.options.extent * (tn.y * Xr - Er))]], tags: fn ? Wt(tn) : this.points[tn.index].properties }, Sn = void 0;
+                fn ? Sn = tn.id : this.options.generateId ? Sn = tn.index : this.points[tn.index].id && (Sn = this.points[tn.index].id), Sn !== void 0 && (yn.id = Sn), ri.features.push(yn);
+              }
+            }, pt.prototype._limitZoom = function(wt) {
+              return Math.max(this.options.minZoom, Math.min(+wt, this.options.maxZoom + 1));
+            }, pt.prototype._cluster = function(wt, rr) {
+              for (var nr = [], Er = this.options, Xr = Er.radius, ri = Er.extent, Qr = Er.reduce, Oi = Er.minPoints, $i = Xr / (ri * Math.pow(2, rr)), tn = 0; tn < wt.length; tn++) {
+                var fn = wt[tn];
+                if (!(fn.zoom <= rr)) {
+                  fn.zoom = rr;
+                  for (var yn = this.trees[rr + 1], Sn = yn.within(fn.x, fn.y, $i), Ba = fn.numPoints || 1, ua = Ba, ma = 0, Wa = Sn; ma < Wa.length; ma += 1) {
+                    var Fa = Wa[ma], Xo = yn.points[Fa];
+                    Xo.zoom > rr && (ua += Xo.numPoints || 1);
+                  }
+                  if (ua >= Oi) {
+                    for (var da = fn.x * Ba, Wn = fn.y * Ba, Ha = Qr && Ba > 1 ? this._map(fn, true) : null, vo = (tn << 5) + (rr + 1) + this.points.length, jn = 0, Mt = Sn; jn < Mt.length; jn += 1) {
+                      var kr = Mt[jn], Jr = yn.points[kr];
+                      if (!(Jr.zoom <= rr)) {
+                        Jr.zoom = rr;
+                        var vi = Jr.numPoints || 1;
+                        da += Jr.x * vi, Wn += Jr.y * vi, Jr.parentId = vo, Qr && (Ha || (Ha = this._map(fn, true)), Qr(Ha, this._map(Jr)));
+                      }
+                    }
+                    fn.parentId = vo, nr.push(Vt(da / ua, Wn / ua, vo, ua, Ha));
+                  } else if (nr.push(fn), ua > 1) for (var hn = 0, An = Sn; hn < An.length; hn += 1) {
+                    var Mn = An[hn], Li = yn.points[Mn];
+                    Li.zoom <= rr || (Li.zoom = rr, nr.push(Li));
+                  }
+                }
+              }
+              return nr;
+            }, pt.prototype._getOriginId = function(wt) {
+              return wt - this.points.length >> 5;
+            }, pt.prototype._getOriginZoom = function(wt) {
+              return (wt - this.points.length) % 32;
+            }, pt.prototype._map = function(wt, rr) {
+              if (wt.numPoints) return rr ? fr({}, wt.properties) : wt.properties;
+              var nr = this.points[wt.index].properties, Er = this.options.map(nr);
+              return rr && Er === nr ? fr({}, Er) : Er;
+            };
+            function Vt(Ut, wt, rr, nr, Er) {
+              return { x: Ut, y: wt, zoom: 1 / 0, id: rr, parentId: -1, numPoints: nr, properties: Er };
+            }
+            function ot(Ut, wt) {
+              var rr = Ut.geometry.coordinates, nr = rr[0], Er = rr[1];
+              return { x: Nt(nr), y: $t(Er), zoom: 1 / 0, index: wt, parentId: -1 };
+            }
+            function ut(Ut) {
+              return { type: "Feature", id: Ut.id, properties: Wt(Ut), geometry: { type: "Point", coordinates: [sr(Ut.x), Tr(Ut.y)] } };
+            }
+            function Wt(Ut) {
+              var wt = Ut.numPoints, rr = wt >= 1e4 ? Math.round(wt / 1e3) + "k" : wt >= 1e3 ? Math.round(wt / 100) / 10 + "k" : wt;
+              return fr(fr({}, Ut.properties), { cluster: true, cluster_id: Ut.id, point_count: wt, point_count_abbreviated: rr });
+            }
+            function Nt(Ut) {
+              return Ut / 360 + 0.5;
+            }
+            function $t(Ut) {
+              var wt = Math.sin(Ut * Math.PI / 180), rr = 0.5 - 0.25 * Math.log((1 + wt) / (1 - wt)) / Math.PI;
+              return rr < 0 ? 0 : rr > 1 ? 1 : rr;
+            }
+            function sr(Ut) {
+              return (Ut - 0.5) * 360;
+            }
+            function Tr(Ut) {
+              var wt = (180 - Ut * 360) * Math.PI / 180;
+              return 360 * Math.atan(Math.exp(wt)) / Math.PI - 90;
+            }
+            function fr(Ut, wt) {
+              for (var rr in wt) Ut[rr] = wt[rr];
+              return Ut;
+            }
+            function $e(Ut) {
+              return Ut.x;
+            }
+            function St(Ut) {
+              return Ut.y;
+            }
+            function Qt(Ut, wt, rr, nr) {
+              for (var Er = nr, Xr = rr - wt >> 1, ri = rr - wt, Qr, Oi = Ut[wt], $i = Ut[wt + 1], tn = Ut[rr], fn = Ut[rr + 1], yn = wt + 3; yn < rr; yn += 3) {
+                var Sn = Gt(Ut[yn], Ut[yn + 1], Oi, $i, tn, fn);
+                if (Sn > Er) Qr = yn, Er = Sn;
+                else if (Sn === Er) {
+                  var Ba = Math.abs(yn - Xr);
+                  Ba < ri && (Qr = yn, ri = Ba);
+                }
+              }
+              Er > nr && (Qr - wt > 3 && Qt(Ut, wt, Qr, nr), Ut[Qr + 2] = Er, rr - Qr > 3 && Qt(Ut, Qr, rr, nr));
+            }
+            function Gt(Ut, wt, rr, nr, Er, Xr) {
+              var ri = Er - rr, Qr = Xr - nr;
+              if (ri !== 0 || Qr !== 0) {
+                var Oi = ((Ut - rr) * ri + (wt - nr) * Qr) / (ri * ri + Qr * Qr);
+                Oi > 1 ? (rr = Er, nr = Xr) : Oi > 0 && (rr += ri * Oi, nr += Qr * Oi);
+              }
+              return ri = Ut - rr, Qr = wt - nr, ri * ri + Qr * Qr;
+            }
+            function _t(Ut, wt, rr, nr) {
+              var Er = { id: typeof Ut == "undefined" ? null : Ut, type: wt, geometry: rr, tags: nr, minX: 1 / 0, minY: 1 / 0, maxX: -1 / 0, maxY: -1 / 0 };
+              return It(Er), Er;
+            }
+            function It(Ut) {
+              var wt = Ut.geometry, rr = Ut.type;
+              if (rr === "Point" || rr === "MultiPoint" || rr === "LineString") mt(Ut, wt);
+              else if (rr === "Polygon" || rr === "MultiLineString") for (var nr = 0; nr < wt.length; nr++) mt(Ut, wt[nr]);
+              else if (rr === "MultiPolygon") for (nr = 0; nr < wt.length; nr++) for (var Er = 0; Er < wt[nr].length; Er++) mt(Ut, wt[nr][Er]);
+            }
+            function mt(Ut, wt) {
+              for (var rr = 0; rr < wt.length; rr += 3) Ut.minX = Math.min(Ut.minX, wt[rr]), Ut.minY = Math.min(Ut.minY, wt[rr + 1]), Ut.maxX = Math.max(Ut.maxX, wt[rr]), Ut.maxY = Math.max(Ut.maxY, wt[rr + 1]);
+            }
+            function er(Ut, wt) {
+              var rr = [];
+              if (Ut.type === "FeatureCollection") for (var nr = 0; nr < Ut.features.length; nr++) lr(rr, Ut.features[nr], wt, nr);
+              else Ut.type === "Feature" ? lr(rr, Ut, wt) : lr(rr, { geometry: Ut }, wt);
+              return rr;
+            }
+            function lr(Ut, wt, rr, nr) {
+              if (wt.geometry) {
+                var Er = wt.geometry.coordinates, Xr = wt.geometry.type, ri = Math.pow(rr.tolerance / ((1 << rr.maxZoom) * rr.extent), 2), Qr = [], Oi = wt.id;
+                if (rr.promoteId ? Oi = wt.properties[rr.promoteId] : rr.generateId && (Oi = nr || 0), Xr === "Point") wr(Er, Qr);
+                else if (Xr === "MultiPoint") for (var $i = 0; $i < Er.length; $i++) wr(Er[$i], Qr);
+                else if (Xr === "LineString") Lr(Er, Qr, ri, false);
+                else if (Xr === "MultiLineString") if (rr.lineMetrics) {
+                  for ($i = 0; $i < Er.length; $i++) Qr = [], Lr(Er[$i], Qr, ri, false), Ut.push(_t(Oi, "LineString", Qr, wt.properties));
+                  return;
+                } else ti(Er, Qr, ri, false);
+                else if (Xr === "Polygon") ti(Er, Qr, ri, true);
+                else if (Xr === "MultiPolygon") for ($i = 0; $i < Er.length; $i++) {
+                  var tn = [];
+                  ti(Er[$i], tn, ri, true), Qr.push(tn);
+                }
+                else if (Xr === "GeometryCollection") {
+                  for ($i = 0; $i < wt.geometry.geometries.length; $i++) lr(Ut, { id: Oi, geometry: wt.geometry.geometries[$i], properties: wt.properties }, rr, nr);
+                  return;
+                } else throw new Error("Input data is not a valid GeoJSON object.");
+                Ut.push(_t(Oi, Xr, Qr, wt.properties));
+              }
+            }
+            function wr(Ut, wt) {
+              wt.push(Br(Ut[0])), wt.push(Vr(Ut[1])), wt.push(0);
+            }
+            function Lr(Ut, wt, rr, nr) {
+              for (var Er, Xr, ri = 0, Qr = 0; Qr < Ut.length; Qr++) {
+                var Oi = Br(Ut[Qr][0]), $i = Vr(Ut[Qr][1]);
+                wt.push(Oi), wt.push($i), wt.push(0), Qr > 0 && (nr ? ri += (Er * $i - Oi * Xr) / 2 : ri += Math.sqrt(Math.pow(Oi - Er, 2) + Math.pow($i - Xr, 2))), Er = Oi, Xr = $i;
+              }
+              var tn = wt.length - 3;
+              wt[2] = 1, Qt(wt, 0, tn, rr), wt[tn + 2] = 1, wt.size = Math.abs(ri), wt.start = 0, wt.end = wt.size;
+            }
+            function ti(Ut, wt, rr, nr) {
+              for (var Er = 0; Er < Ut.length; Er++) {
+                var Xr = [];
+                Lr(Ut[Er], Xr, rr, nr), wt.push(Xr);
+              }
+            }
+            function Br(Ut) {
+              return Ut / 360 + 0.5;
+            }
+            function Vr(Ut) {
+              var wt = Math.sin(Ut * Math.PI / 180), rr = 0.5 - 0.25 * Math.log((1 + wt) / (1 - wt)) / Math.PI;
+              return rr < 0 ? 0 : rr > 1 ? 1 : rr;
+            }
+            function dt(Ut, wt, rr, nr, Er, Xr, ri, Qr) {
+              if (rr /= wt, nr /= wt, Xr >= rr && ri < nr) return Ut;
+              if (ri < rr || Xr >= nr) return null;
+              for (var Oi = [], $i = 0; $i < Ut.length; $i++) {
+                var tn = Ut[$i], fn = tn.geometry, yn = tn.type, Sn = Er === 0 ? tn.minX : tn.minY, Ba = Er === 0 ? tn.maxX : tn.maxY;
+                if (Sn >= rr && Ba < nr) {
+                  Oi.push(tn);
+                  continue;
+                } else if (Ba < rr || Sn >= nr) continue;
+                var ua = [];
+                if (yn === "Point" || yn === "MultiPoint") Ge(fn, ua, rr, nr, Er);
+                else if (yn === "LineString") Je(fn, ua, rr, nr, Er, false, Qr.lineMetrics);
+                else if (yn === "MultiLineString") tt(fn, ua, rr, nr, Er, false);
+                else if (yn === "Polygon") tt(fn, ua, rr, nr, Er, true);
+                else if (yn === "MultiPolygon") for (var ma = 0; ma < fn.length; ma++) {
+                  var Wa = [];
+                  tt(fn[ma], Wa, rr, nr, Er, true), Wa.length && ua.push(Wa);
+                }
+                if (ua.length) {
+                  if (Qr.lineMetrics && yn === "LineString") {
+                    for (ma = 0; ma < ua.length; ma++) Oi.push(_t(tn.id, yn, ua[ma], tn.tags));
+                    continue;
+                  }
+                  (yn === "LineString" || yn === "MultiLineString") && (ua.length === 1 ? (yn = "LineString", ua = ua[0]) : yn = "MultiLineString"), (yn === "Point" || yn === "MultiPoint") && (yn = ua.length === 3 ? "Point" : "MultiPoint"), Oi.push(_t(tn.id, yn, ua, tn.tags));
+                }
+              }
+              return Oi.length ? Oi : null;
+            }
+            function Ge(Ut, wt, rr, nr, Er) {
+              for (var Xr = 0; Xr < Ut.length; Xr += 3) {
+                var ri = Ut[Xr + Er];
+                ri >= rr && ri <= nr && (wt.push(Ut[Xr]), wt.push(Ut[Xr + 1]), wt.push(Ut[Xr + 2]));
+              }
+            }
+            function Je(Ut, wt, rr, nr, Er, Xr, ri) {
+              for (var Qr = We(Ut), Oi = Er === 0 ? Ie : xe, $i = Ut.start, tn, fn, yn = 0; yn < Ut.length - 3; yn += 3) {
+                var Sn = Ut[yn], Ba = Ut[yn + 1], ua = Ut[yn + 2], ma = Ut[yn + 3], Wa = Ut[yn + 4], Fa = Er === 0 ? Sn : Ba, Xo = Er === 0 ? ma : Wa, da = false;
+                ri && (tn = Math.sqrt(Math.pow(Sn - ma, 2) + Math.pow(Ba - Wa, 2))), Fa < rr ? Xo > rr && (fn = Oi(Qr, Sn, Ba, ma, Wa, rr), ri && (Qr.start = $i + tn * fn)) : Fa > nr ? Xo < nr && (fn = Oi(Qr, Sn, Ba, ma, Wa, nr), ri && (Qr.start = $i + tn * fn)) : xt(Qr, Sn, Ba, ua), Xo < rr && Fa >= rr && (fn = Oi(Qr, Sn, Ba, ma, Wa, rr), da = true), Xo > nr && Fa <= nr && (fn = Oi(Qr, Sn, Ba, ma, Wa, nr), da = true), !Xr && da && (ri && (Qr.end = $i + tn * fn), wt.push(Qr), Qr = We(Ut)), ri && ($i += tn);
+              }
+              var Wn = Ut.length - 3;
+              Sn = Ut[Wn], Ba = Ut[Wn + 1], ua = Ut[Wn + 2], Fa = Er === 0 ? Sn : Ba, Fa >= rr && Fa <= nr && xt(Qr, Sn, Ba, ua), Wn = Qr.length - 3, Xr && Wn >= 3 && (Qr[Wn] !== Qr[0] || Qr[Wn + 1] !== Qr[1]) && xt(Qr, Qr[0], Qr[1], Qr[2]), Qr.length && wt.push(Qr);
+            }
+            function We(Ut) {
+              var wt = [];
+              return wt.size = Ut.size, wt.start = Ut.start, wt.end = Ut.end, wt;
+            }
+            function tt(Ut, wt, rr, nr, Er, Xr) {
+              for (var ri = 0; ri < Ut.length; ri++) Je(Ut[ri], wt, rr, nr, Er, Xr, false);
+            }
+            function xt(Ut, wt, rr, nr) {
+              Ut.push(wt), Ut.push(rr), Ut.push(nr);
+            }
+            function Ie(Ut, wt, rr, nr, Er, Xr) {
+              var ri = (Xr - wt) / (nr - wt);
+              return Ut.push(Xr), Ut.push(rr + (Er - rr) * ri), Ut.push(1), ri;
+            }
+            function xe(Ut, wt, rr, nr, Er, Xr) {
+              var ri = (Xr - rr) / (Er - rr);
+              return Ut.push(wt + (nr - wt) * ri), Ut.push(Xr), Ut.push(1), ri;
+            }
+            function ke(Ut, wt) {
+              var rr = wt.buffer / wt.extent, nr = Ut, Er = dt(Ut, 1, -1 - rr, rr, 0, -1, 2, wt), Xr = dt(Ut, 1, 1 - rr, 2 + rr, 0, -1, 2, wt);
+              return (Er || Xr) && (nr = dt(Ut, 1, -rr, 1 + rr, 0, -1, 2, wt) || [], Er && (nr = vt(Er, 1).concat(nr)), Xr && (nr = nr.concat(vt(Xr, -1)))), nr;
+            }
+            function vt(Ut, wt) {
+              for (var rr = [], nr = 0; nr < Ut.length; nr++) {
+                var Er = Ut[nr], Xr = Er.type, ri;
+                if (Xr === "Point" || Xr === "MultiPoint" || Xr === "LineString") ri = ir(Er.geometry, wt);
+                else if (Xr === "MultiLineString" || Xr === "Polygon") {
+                  ri = [];
+                  for (var Qr = 0; Qr < Er.geometry.length; Qr++) ri.push(ir(Er.geometry[Qr], wt));
+                } else if (Xr === "MultiPolygon") for (ri = [], Qr = 0; Qr < Er.geometry.length; Qr++) {
+                  for (var Oi = [], $i = 0; $i < Er.geometry[Qr].length; $i++) Oi.push(ir(Er.geometry[Qr][$i], wt));
+                  ri.push(Oi);
+                }
+                rr.push(_t(Er.id, Xr, ri, Er.tags));
+              }
+              return rr;
+            }
+            function ir(Ut, wt) {
+              var rr = [];
+              rr.size = Ut.size, Ut.start !== void 0 && (rr.start = Ut.start, rr.end = Ut.end);
+              for (var nr = 0; nr < Ut.length; nr += 3) rr.push(Ut[nr] + wt, Ut[nr + 1], Ut[nr + 2]);
+              return rr;
+            }
+            function ar(Ut, wt) {
+              if (Ut.transformed) return Ut;
+              var rr = 1 << Ut.z, nr = Ut.x, Er = Ut.y, Xr, ri, Qr;
+              for (Xr = 0; Xr < Ut.features.length; Xr++) {
+                var Oi = Ut.features[Xr], $i = Oi.geometry, tn = Oi.type;
+                if (Oi.geometry = [], tn === 1) for (ri = 0; ri < $i.length; ri += 2) Oi.geometry.push(vr($i[ri], $i[ri + 1], wt, rr, nr, Er));
+                else for (ri = 0; ri < $i.length; ri++) {
+                  var fn = [];
+                  for (Qr = 0; Qr < $i[ri].length; Qr += 2) fn.push(vr($i[ri][Qr], $i[ri][Qr + 1], wt, rr, nr, Er));
+                  Oi.geometry.push(fn);
+                }
+              }
+              return Ut.transformed = true, Ut;
+            }
+            function vr(Ut, wt, rr, nr, Er, Xr) {
+              return [Math.round(rr * (Ut * nr - Er)), Math.round(rr * (wt * nr - Xr))];
+            }
+            function ii(Ut, wt, rr, nr, Er) {
+              for (var Xr = wt === Er.maxZoom ? 0 : Er.tolerance / ((1 << wt) * Er.extent), ri = { features: [], numPoints: 0, numSimplified: 0, numFeatures: 0, source: null, x: rr, y: nr, z: wt, transformed: false, minX: 2, minY: 1, maxX: -1, maxY: 0 }, Qr = 0; Qr < Ut.length; Qr++) {
+                ri.numFeatures++, pi(ri, Ut[Qr], Xr, Er);
+                var Oi = Ut[Qr].minX, $i = Ut[Qr].minY, tn = Ut[Qr].maxX, fn = Ut[Qr].maxY;
+                Oi < ri.minX && (ri.minX = Oi), $i < ri.minY && (ri.minY = $i), tn > ri.maxX && (ri.maxX = tn), fn > ri.maxY && (ri.maxY = fn);
+              }
+              return ri;
+            }
+            function pi(Ut, wt, rr, nr) {
+              var Er = wt.geometry, Xr = wt.type, ri = [];
+              if (Xr === "Point" || Xr === "MultiPoint") for (var Qr = 0; Qr < Er.length; Qr += 3) ri.push(Er[Qr]), ri.push(Er[Qr + 1]), Ut.numPoints++, Ut.numSimplified++;
+              else if (Xr === "LineString") $r(ri, Er, Ut, rr, false, false);
+              else if (Xr === "MultiLineString" || Xr === "Polygon") for (Qr = 0; Qr < Er.length; Qr++) $r(ri, Er[Qr], Ut, rr, Xr === "Polygon", Qr === 0);
+              else if (Xr === "MultiPolygon") for (var Oi = 0; Oi < Er.length; Oi++) {
+                var $i = Er[Oi];
+                for (Qr = 0; Qr < $i.length; Qr++) $r(ri, $i[Qr], Ut, rr, true, Qr === 0);
+              }
+              if (ri.length) {
+                var tn = wt.tags || null;
+                if (Xr === "LineString" && nr.lineMetrics) {
+                  tn = {};
+                  for (var fn in wt.tags) tn[fn] = wt.tags[fn];
+                  tn.mapbox_clip_start = Er.start / Er.size, tn.mapbox_clip_end = Er.end / Er.size;
+                }
+                var yn = { geometry: ri, type: Xr === "Polygon" || Xr === "MultiPolygon" ? 3 : Xr === "LineString" || Xr === "MultiLineString" ? 2 : 1, tags: tn };
+                wt.id !== null && (yn.id = wt.id), Ut.features.push(yn);
+              }
+            }
+            function $r(Ut, wt, rr, nr, Er, Xr) {
+              var ri = nr * nr;
+              if (nr > 0 && wt.size < (Er ? ri : nr)) {
+                rr.numPoints += wt.length / 3;
+                return;
+              }
+              for (var Qr = [], Oi = 0; Oi < wt.length; Oi += 3) (nr === 0 || wt[Oi + 2] > ri) && (rr.numSimplified++, Qr.push(wt[Oi]), Qr.push(wt[Oi + 1])), rr.numPoints++;
+              Er && di(Qr, Xr), Ut.push(Qr);
+            }
+            function di(Ut, wt) {
+              for (var rr = 0, nr = 0, Er = Ut.length, Xr = Er - 2; nr < Er; Xr = nr, nr += 2) rr += (Ut[nr] - Ut[Xr]) * (Ut[nr + 1] + Ut[Xr + 1]);
+              if (rr > 0 === wt) for (nr = 0, Er = Ut.length; nr < Er / 2; nr += 2) {
+                var ri = Ut[nr], Qr = Ut[nr + 1];
+                Ut[nr] = Ut[Er - 2 - nr], Ut[nr + 1] = Ut[Er - 1 - nr], Ut[Er - 2 - nr] = ri, Ut[Er - 1 - nr] = Qr;
+              }
+            }
+            function ji(Ut, wt) {
+              return new In(Ut, wt);
+            }
+            function In(Ut, wt) {
+              wt = this.options = On(Object.create(this.options), wt);
+              var rr = wt.debug;
+              if (rr && console.time("preprocess data"), wt.maxZoom < 0 || wt.maxZoom > 24) throw new Error("maxZoom should be in the 0-24 range");
+              if (wt.promoteId && wt.generateId) throw new Error("promoteId and generateId cannot be used together.");
+              var nr = er(Ut, wt);
+              this.tiles = {}, this.tileCoords = [], rr && (console.timeEnd("preprocess data"), console.log("index: maxZoom: %d, maxPoints: %d", wt.indexMaxZoom, wt.indexMaxPoints), console.time("generate tiles"), this.stats = {}, this.total = 0), nr = ke(nr, wt), nr.length && this.splitTile(nr, 0, 0, 0), rr && (nr.length && console.log("features: %d, points: %d", this.tiles[0].numFeatures, this.tiles[0].numPoints), console.timeEnd("generate tiles"), console.log("tiles generated:", this.total, JSON.stringify(this.stats)));
+            }
+            In.prototype.options = { maxZoom: 14, indexMaxZoom: 5, indexMaxPoints: 1e5, tolerance: 3, extent: 4096, buffer: 64, lineMetrics: false, promoteId: null, generateId: false, debug: 0 }, In.prototype.splitTile = function(Ut, wt, rr, nr, Er, Xr, ri) {
+              for (var Qr = [Ut, wt, rr, nr], Oi = this.options, $i = Oi.debug; Qr.length; ) {
+                nr = Qr.pop(), rr = Qr.pop(), wt = Qr.pop(), Ut = Qr.pop();
+                var tn = 1 << wt, fn = wi(wt, rr, nr), yn = this.tiles[fn];
+                if (!yn && ($i > 1 && console.time("creation"), yn = this.tiles[fn] = ii(Ut, wt, rr, nr, Oi), this.tileCoords.push({ z: wt, x: rr, y: nr }), $i)) {
+                  $i > 1 && (console.log("tile z%d-%d-%d (features: %d, points: %d, simplified: %d)", wt, rr, nr, yn.numFeatures, yn.numPoints, yn.numSimplified), console.timeEnd("creation"));
+                  var Sn = "z" + wt;
+                  this.stats[Sn] = (this.stats[Sn] || 0) + 1, this.total++;
+                }
+                if (yn.source = Ut, Er) {
+                  if (wt === Oi.maxZoom || wt === Er) continue;
+                  var Ba = 1 << Er - wt;
+                  if (rr !== Math.floor(Xr / Ba) || nr !== Math.floor(ri / Ba)) continue;
+                } else if (wt === Oi.indexMaxZoom || yn.numPoints <= Oi.indexMaxPoints) continue;
+                if (yn.source = null, Ut.length !== 0) {
+                  $i > 1 && console.time("clipping");
+                  var ua = 0.5 * Oi.buffer / Oi.extent, ma = 0.5 - ua, Wa = 0.5 + ua, Fa = 1 + ua, Xo, da, Wn, Ha, vo, jn;
+                  Xo = da = Wn = Ha = null, vo = dt(Ut, tn, rr - ua, rr + Wa, 0, yn.minX, yn.maxX, Oi), jn = dt(Ut, tn, rr + ma, rr + Fa, 0, yn.minX, yn.maxX, Oi), Ut = null, vo && (Xo = dt(vo, tn, nr - ua, nr + Wa, 1, yn.minY, yn.maxY, Oi), da = dt(vo, tn, nr + ma, nr + Fa, 1, yn.minY, yn.maxY, Oi), vo = null), jn && (Wn = dt(jn, tn, nr - ua, nr + Wa, 1, yn.minY, yn.maxY, Oi), Ha = dt(jn, tn, nr + ma, nr + Fa, 1, yn.minY, yn.maxY, Oi), jn = null), $i > 1 && console.timeEnd("clipping"), Qr.push(Xo || [], wt + 1, rr * 2, nr * 2), Qr.push(da || [], wt + 1, rr * 2, nr * 2 + 1), Qr.push(Wn || [], wt + 1, rr * 2 + 1, nr * 2), Qr.push(Ha || [], wt + 1, rr * 2 + 1, nr * 2 + 1);
+                }
+              }
+            }, In.prototype.getTile = function(Ut, wt, rr) {
+              var nr = this.options, Er = nr.extent, Xr = nr.debug;
+              if (Ut < 0 || Ut > 24) return null;
+              var ri = 1 << Ut;
+              wt = (wt % ri + ri) % ri;
+              var Qr = wi(Ut, wt, rr);
+              if (this.tiles[Qr]) return ar(this.tiles[Qr], Er);
+              Xr > 1 && console.log("drilling down to z%d-%d-%d", Ut, wt, rr);
+              for (var Oi = Ut, $i = wt, tn = rr, fn; !fn && Oi > 0; ) Oi--, $i = Math.floor($i / 2), tn = Math.floor(tn / 2), fn = this.tiles[wi(Oi, $i, tn)];
+              return !fn || !fn.source ? null : (Xr > 1 && console.log("found parent tile z%d-%d-%d", Oi, $i, tn), Xr > 1 && console.time("drilling down"), this.splitTile(fn.source, Oi, $i, tn, Ut, wt, rr), Xr > 1 && console.timeEnd("drilling down"), this.tiles[Qr] ? ar(this.tiles[Qr], Er) : null);
+            };
+            function wi(Ut, wt, rr) {
+              return ((1 << Ut) * rr + wt) * 32 + Ut;
+            }
+            function On(Ut, wt) {
+              for (var rr in wt) Ut[rr] = wt[rr];
+              return Ut;
+            }
+            function qn(Ut, wt) {
+              var rr = Ut.tileID.canonical;
+              if (!this._geoJSONIndex) return wt(null, null);
+              var nr = this._geoJSONIndex.getTile(rr.z, rr.x, rr.y);
+              if (!nr) return wt(null, null);
+              var Er = new C(nr.features), Xr = z(Er);
+              (Xr.byteOffset !== 0 || Xr.byteLength !== Xr.buffer.byteLength) && (Xr = new Uint8Array(Xr)), wt(null, { vectorTile: Er, rawData: Xr.buffer });
+            }
+            var Fn = function(Ut) {
+              function wt(rr, nr, Er, Xr) {
+                Ut.call(this, rr, nr, Er, qn), Xr && (this.loadGeoJSON = Xr);
+              }
+              return Ut && (wt.__proto__ = Ut), wt.prototype = Object.create(Ut && Ut.prototype), wt.prototype.constructor = wt, wt.prototype.loadData = function(nr, Er) {
+                this._pendingCallback && this._pendingCallback(null, { abandoned: true }), this._pendingCallback = Er, this._pendingLoadDataParams = nr, this._state && this._state !== "Idle" ? this._state = "NeedsLoadData" : (this._state = "Coalescing", this._loadData());
+              }, wt.prototype._loadData = function() {
+                var nr = this;
+                if (!(!this._pendingCallback || !this._pendingLoadDataParams)) {
+                  var Er = this._pendingCallback, Xr = this._pendingLoadDataParams;
+                  delete this._pendingCallback, delete this._pendingLoadDataParams;
+                  var ri = Xr && Xr.request && Xr.request.collectResourceTiming ? new i.RequestPerformance(Xr.request) : false;
+                  this.loadGeoJSON(Xr, function(Qr, Oi) {
+                    if (Qr || !Oi) return Er(Qr);
+                    if (typeof Oi != "object") return Er(new Error("Input data given to '" + Xr.source + "' is not a valid GeoJSON object."));
+                    p(Oi, true);
+                    try {
+                      if (Xr.filter) {
+                        var $i = i.createExpression(Xr.filter, { type: "boolean", "property-type": "data-driven", overridable: false, transition: false });
+                        if ($i.result === "error") throw new Error($i.value.map(function(Sn) {
+                          return Sn.key + ": " + Sn.message;
+                        }).join(", "));
+                        var tn = Oi.features.filter(function(Sn) {
+                          return $i.value.evaluate({ zoom: 0 }, Sn);
+                        });
+                        Oi = { type: "FeatureCollection", features: tn };
+                      }
+                      nr._geoJSONIndex = Xr.cluster ? new pt(ra(Xr)).load(Oi.features) : ji(Oi, Xr.geojsonVtOptions);
+                    } catch (Sn) {
+                      return Er(Sn);
+                    }
+                    nr.loaded = {};
+                    var fn = {};
+                    if (ri) {
+                      var yn = ri.finish();
+                      yn && (fn.resourceTiming = {}, fn.resourceTiming[Xr.source] = JSON.parse(JSON.stringify(yn)));
+                    }
+                    Er(null, fn);
+                  });
+                }
+              }, wt.prototype.coalesce = function() {
+                this._state === "Coalescing" ? this._state = "Idle" : this._state === "NeedsLoadData" && (this._state = "Coalescing", this._loadData());
+              }, wt.prototype.reloadTile = function(nr, Er) {
+                var Xr = this.loaded, ri = nr.uid;
+                return Xr && Xr[ri] ? Ut.prototype.reloadTile.call(this, nr, Er) : this.loadTile(nr, Er);
+              }, wt.prototype.loadGeoJSON = function(nr, Er) {
+                if (nr.request) i.getJSON(nr.request, Er);
+                else if (typeof nr.data == "string") try {
+                  return Er(null, JSON.parse(nr.data));
+                } catch (Xr) {
+                  return Er(new Error("Input data given to '" + nr.source + "' is not a valid GeoJSON object."));
+                }
+                else return Er(new Error("Input data given to '" + nr.source + "' is not a valid GeoJSON object."));
+              }, wt.prototype.removeSource = function(nr, Er) {
+                this._pendingCallback && this._pendingCallback(null, { abandoned: true }), Er();
+              }, wt.prototype.getClusterExpansionZoom = function(nr, Er) {
+                try {
+                  Er(null, this._geoJSONIndex.getClusterExpansionZoom(nr.clusterId));
+                } catch (Xr) {
+                  Er(Xr);
+                }
+              }, wt.prototype.getClusterChildren = function(nr, Er) {
+                try {
+                  Er(null, this._geoJSONIndex.getChildren(nr.clusterId));
+                } catch (Xr) {
+                  Er(Xr);
+                }
+              }, wt.prototype.getClusterLeaves = function(nr, Er) {
+                try {
+                  Er(null, this._geoJSONIndex.getLeaves(nr.clusterId, nr.limit, nr.offset));
+                } catch (Xr) {
+                  Er(Xr);
+                }
+              }, wt;
+            }(v);
+            function ra(Ut) {
+              var wt = Ut.superclusterOptions, rr = Ut.clusterProperties;
+              if (!rr || !wt) return wt;
+              for (var nr = {}, Er = {}, Xr = { accumulated: null, zoom: 0 }, ri = { properties: null }, Qr = Object.keys(rr), Oi = 0, $i = Qr; Oi < $i.length; Oi += 1) {
+                var tn = $i[Oi], fn = rr[tn], yn = fn[0], Sn = fn[1], Ba = i.createExpression(Sn), ua = i.createExpression(typeof yn == "string" ? [yn, ["accumulated"], ["get", tn]] : yn);
+                nr[tn] = Ba.value, Er[tn] = ua.value;
+              }
+              return wt.map = function(ma) {
+                ri.properties = ma;
+                for (var Wa = {}, Fa = 0, Xo = Qr; Fa < Xo.length; Fa += 1) {
+                  var da = Xo[Fa];
+                  Wa[da] = nr[da].evaluate(Xr, ri);
+                }
+                return Wa;
+              }, wt.reduce = function(ma, Wa) {
+                ri.properties = Wa;
+                for (var Fa = 0, Xo = Qr; Fa < Xo.length; Fa += 1) {
+                  var da = Xo[Fa];
+                  Xr.accumulated = ma[da], ma[da] = Er[da].evaluate(Xr, ri);
+                }
+              }, wt;
+            }
+            var la = function(wt) {
+              var rr = this;
+              this.self = wt, this.actor = new i.Actor(wt, this), this.layerIndexes = {}, this.availableImages = {}, this.workerSourceTypes = { vector: v, geojson: Fn }, this.workerSources = {}, this.demWorkerSources = {}, this.self.registerWorkerSource = function(nr, Er) {
+                if (rr.workerSourceTypes[nr]) throw new Error('Worker source with name "' + nr + '" already registered.');
+                rr.workerSourceTypes[nr] = Er;
+              }, this.self.registerRTLTextPlugin = function(nr) {
+                if (i.plugin.isParsed()) throw new Error("RTL text plugin already registered.");
+                i.plugin.applyArabicShaping = nr.applyArabicShaping, i.plugin.processBidirectionalText = nr.processBidirectionalText, i.plugin.processStyledBidirectionalText = nr.processStyledBidirectionalText;
+              };
+            };
+            return la.prototype.setReferrer = function(wt, rr) {
+              this.referrer = rr;
+            }, la.prototype.setImages = function(wt, rr, nr) {
+              this.availableImages[wt] = rr;
+              for (var Er in this.workerSources[wt]) {
+                var Xr = this.workerSources[wt][Er];
+                for (var ri in Xr) Xr[ri].availableImages = rr;
+              }
+              nr();
+            }, la.prototype.setLayers = function(wt, rr, nr) {
+              this.getLayerIndex(wt).replace(rr), nr();
+            }, la.prototype.updateLayers = function(wt, rr, nr) {
+              this.getLayerIndex(wt).update(rr.layers, rr.removedIds), nr();
+            }, la.prototype.loadTile = function(wt, rr, nr) {
+              this.getWorkerSource(wt, rr.type, rr.source).loadTile(rr, nr);
+            }, la.prototype.loadDEMTile = function(wt, rr, nr) {
+              this.getDEMWorkerSource(wt, rr.source).loadTile(rr, nr);
+            }, la.prototype.reloadTile = function(wt, rr, nr) {
+              this.getWorkerSource(wt, rr.type, rr.source).reloadTile(rr, nr);
+            }, la.prototype.abortTile = function(wt, rr, nr) {
+              this.getWorkerSource(wt, rr.type, rr.source).abortTile(rr, nr);
+            }, la.prototype.removeTile = function(wt, rr, nr) {
+              this.getWorkerSource(wt, rr.type, rr.source).removeTile(rr, nr);
+            }, la.prototype.removeDEMTile = function(wt, rr) {
+              this.getDEMWorkerSource(wt, rr.source).removeTile(rr);
+            }, la.prototype.removeSource = function(wt, rr, nr) {
+              if (!(!this.workerSources[wt] || !this.workerSources[wt][rr.type] || !this.workerSources[wt][rr.type][rr.source])) {
+                var Er = this.workerSources[wt][rr.type][rr.source];
+                delete this.workerSources[wt][rr.type][rr.source], Er.removeSource !== void 0 ? Er.removeSource(rr, nr) : nr();
+              }
+            }, la.prototype.loadWorkerSource = function(wt, rr, nr) {
+              try {
+                this.self.importScripts(rr.url), nr();
+              } catch (Er) {
+                nr(Er.toString());
+              }
+            }, la.prototype.syncRTLPluginState = function(wt, rr, nr) {
+              try {
+                i.plugin.setState(rr);
+                var Er = i.plugin.getPluginURL();
+                if (i.plugin.isLoaded() && !i.plugin.isParsed() && Er != null) {
+                  this.self.importScripts(Er);
+                  var Xr = i.plugin.isParsed(), ri = Xr ? void 0 : new Error("RTL Text Plugin failed to import scripts from " + Er);
+                  nr(ri, Xr);
+                }
+              } catch (Qr) {
+                nr(Qr.toString());
+              }
+            }, la.prototype.getAvailableImages = function(wt) {
+              var rr = this.availableImages[wt];
+              return rr || (rr = []), rr;
+            }, la.prototype.getLayerIndex = function(wt) {
+              var rr = this.layerIndexes[wt];
+              return rr || (rr = this.layerIndexes[wt] = new l()), rr;
+            }, la.prototype.getWorkerSource = function(wt, rr, nr) {
+              var Er = this;
+              if (this.workerSources[wt] || (this.workerSources[wt] = {}), this.workerSources[wt][rr] || (this.workerSources[wt][rr] = {}), !this.workerSources[wt][rr][nr]) {
+                var Xr = { send: function(ri, Qr, Oi) {
+                  Er.actor.send(ri, Qr, Oi, wt);
+                } };
+                this.workerSources[wt][rr][nr] = new this.workerSourceTypes[rr](Xr, this.getLayerIndex(wt), this.getAvailableImages(wt));
+              }
+              return this.workerSources[wt][rr][nr];
+            }, la.prototype.getDEMWorkerSource = function(wt, rr) {
+              return this.demWorkerSources[wt] || (this.demWorkerSources[wt] = {}), this.demWorkerSources[wt][rr] || (this.demWorkerSources[wt][rr] = new b()), this.demWorkerSources[wt][rr];
+            }, la.prototype.enforceCacheSizeLimit = function(wt, rr) {
+              i.enforceCacheSizeLimit(rr);
+            }, typeof WorkerGlobalScope != "undefined" && typeof self != "undefined" && self instanceof WorkerGlobalScope && (self.worker = new la(self)), la;
+          }), n(["./shared"], function(i) {
+            var a = i.createCommonjsModule(function(Y) {
+              Y.exports ? Y.exports = D : window && (window.mapboxgl = window.mapboxgl || {}, window.mapboxgl.supported = D, window.mapboxgl.notSupportedReason = J);
+              function D(Ct) {
+                return !J(Ct);
+              }
+              function J(Ct) {
+                if (!q()) return "not a browser";
+                if (!K()) return "insufficent Array support";
+                if (!de()) return "insufficient Function support";
+                if (!ne()) return "insufficient Object support";
+                if (!we()) return "insufficient JSON support";
+                if (!Ue()) return "insufficient worker support";
+                if (!ft()) return "insufficient Uint8ClampedArray support";
+                if (!Zt()) return "insufficient ArrayBuffer support";
+                if (!hr()) return "insufficient Canvas/getImageData support";
+                if (!Ve(Ct && Ct.failIfMajorPerformanceCaveat)) return "insufficient WebGL support";
+              }
+              function q() {
+                return typeof window != "undefined" && typeof document != "undefined";
+              }
+              function K() {
+                return Array.prototype && Array.prototype.every && Array.prototype.filter && Array.prototype.forEach && Array.prototype.indexOf && Array.prototype.lastIndexOf && Array.prototype.map && Array.prototype.some && Array.prototype.reduce && Array.prototype.reduceRight && Array.isArray;
+              }
+              function de() {
+                return Function.prototype && Function.prototype.bind;
+              }
+              function ne() {
+                return Object.keys && Object.create && Object.getPrototypeOf && Object.getOwnPropertyNames && Object.isSealed && Object.isFrozen && Object.isExtensible && Object.getOwnPropertyDescriptor && Object.defineProperty && Object.defineProperties && Object.seal && Object.freeze && Object.preventExtensions;
+              }
+              function we() {
+                return "JSON" in window && "parse" in JSON && "stringify" in JSON;
+              }
+              function Ue() {
+                if (!("Worker" in window && "Blob" in window && "URL" in window)) return false;
+                var Ct = new Blob([""], { type: "text/javascript" }), Ot = URL.createObjectURL(Ct), Rt, Bt;
+                try {
+                  Bt = new Worker(Ot), Rt = true;
+                } catch (Dt) {
+                  Rt = false;
+                }
+                return Bt && Bt.terminate(), URL.revokeObjectURL(Ot), Rt;
+              }
+              function ft() {
+                return "Uint8ClampedArray" in window;
+              }
+              function Zt() {
+                return ArrayBuffer.isView;
+              }
+              function hr() {
+                var Ct = document.createElement("canvas");
+                Ct.width = Ct.height = 1;
+                var Ot = Ct.getContext("2d");
+                if (!Ot) return false;
+                var Rt = Ot.getImageData(0, 0, 1, 1);
+                return Rt && Rt.width === Ct.width;
+              }
+              var qt = {};
+              function Ve(Ct) {
+                return qt[Ct] === void 0 && (qt[Ct] = at(Ct)), qt[Ct];
+              }
+              D.webGLContextAttributes = { antialias: false, alpha: true, stencil: true, depth: true };
+              function Qe(Ct) {
+                var Ot = document.createElement("canvas"), Rt = Object.create(D.webGLContextAttributes);
+                return Rt.failIfMajorPerformanceCaveat = Ct, Ot.probablySupportsContext ? Ot.probablySupportsContext("webgl", Rt) || Ot.probablySupportsContext("experimental-webgl", Rt) : Ot.supportsContext ? Ot.supportsContext("webgl", Rt) || Ot.supportsContext("experimental-webgl", Rt) : Ot.getContext("webgl", Rt) || Ot.getContext("experimental-webgl", Rt);
+              }
+              function at(Ct) {
+                var Ot = Qe(Ct);
+                if (!Ot) return false;
+                var Rt = Ot.createShader(Ot.VERTEX_SHADER);
+                return !Rt || Ot.isContextLost() ? false : (Ot.shaderSource(Rt, "void main() {}"), Ot.compileShader(Rt), Ot.getShaderParameter(Rt, Ot.COMPILE_STATUS) === true);
+              }
+            }), o = {};
+            o.create = function(Y, D, J) {
+              var q = i.window.document.createElement(Y);
+              return D !== void 0 && (q.className = D), J && J.appendChild(q), q;
+            }, o.createNS = function(Y, D) {
+              var J = i.window.document.createElementNS(Y, D);
+              return J;
+            };
+            var s = i.window.document && i.window.document.documentElement.style;
+            function l(Y) {
+              if (!s) return Y[0];
+              for (var D = 0; D < Y.length; D++) if (Y[D] in s) return Y[D];
+              return Y[0];
+            }
+            var u = l(["userSelect", "MozUserSelect", "WebkitUserSelect", "msUserSelect"]), c;
+            o.disableDrag = function() {
+              s && u && (c = s[u], s[u] = "none");
+            }, o.enableDrag = function() {
+              s && u && (s[u] = c);
+            };
+            var f = l(["transform", "WebkitTransform"]);
+            o.setTransform = function(Y, D) {
+              Y.style[f] = D;
+            };
+            var h = false;
+            try {
+              var d = Object.defineProperty({}, "passive", { get: function() {
+                h = true;
+              } });
+              i.window.addEventListener("test", d, d), i.window.removeEventListener("test", d, d);
+            } catch (Y) {
+              h = false;
+            }
+            o.addEventListener = function(Y, D, J, q) {
+              q === void 0 && (q = {}), "passive" in q && h ? Y.addEventListener(D, J, q) : Y.addEventListener(D, J, q.capture);
+            }, o.removeEventListener = function(Y, D, J, q) {
+              q === void 0 && (q = {}), "passive" in q && h ? Y.removeEventListener(D, J, q) : Y.removeEventListener(D, J, q.capture);
+            };
+            var v = function(Y) {
+              Y.preventDefault(), Y.stopPropagation(), i.window.removeEventListener("click", v, true);
+            };
+            o.suppressClick = function() {
+              i.window.addEventListener("click", v, true), i.window.setTimeout(function() {
+                i.window.removeEventListener("click", v, true);
+              }, 0);
+            }, o.mousePos = function(Y, D) {
+              var J = Y.getBoundingClientRect();
+              return new i.Point(D.clientX - J.left - Y.clientLeft, D.clientY - J.top - Y.clientTop);
+            }, o.touchPos = function(Y, D) {
+              for (var J = Y.getBoundingClientRect(), q = [], K = 0; K < D.length; K++) q.push(new i.Point(D[K].clientX - J.left - Y.clientLeft, D[K].clientY - J.top - Y.clientTop));
+              return q;
+            }, o.mouseButton = function(Y) {
+              return typeof i.window.InstallTrigger != "undefined" && Y.button === 2 && Y.ctrlKey && i.window.navigator.platform.toUpperCase().indexOf("MAC") >= 0 ? 0 : Y.button;
+            }, o.remove = function(Y) {
+              Y.parentNode && Y.parentNode.removeChild(Y);
+            };
+            function _(Y, D, J) {
+              var q, K, de, ne = i.browser.devicePixelRatio > 1 ? "@2x" : "", we = i.getJSON(D.transformRequest(D.normalizeSpriteURL(Y, ne, ".json"), i.ResourceType.SpriteJSON), function(Zt, hr) {
+                we = null, de || (de = Zt, q = hr, ft());
+              }), Ue = i.getImage(D.transformRequest(D.normalizeSpriteURL(Y, ne, ".png"), i.ResourceType.SpriteImage), function(Zt, hr) {
+                Ue = null, de || (de = Zt, K = hr, ft());
+              });
+              function ft() {
+                if (de) J(de);
+                else if (q && K) {
+                  var Zt = i.browser.getImageData(K), hr = {};
+                  for (var qt in q) {
+                    var Ve = q[qt], Qe = Ve.width, at = Ve.height, Ct = Ve.x, Ot = Ve.y, Rt = Ve.sdf, Bt = Ve.pixelRatio, Dt = Ve.stretchX, yt = Ve.stretchY, Pt = Ve.content, ht = new i.RGBAImage({ width: Qe, height: at });
+                    i.RGBAImage.copy(Zt, ht, { x: Ct, y: Ot }, { x: 0, y: 0 }, { width: Qe, height: at }), hr[qt] = { data: ht, pixelRatio: Bt, sdf: Rt, stretchX: Dt, stretchY: yt, content: Pt };
+                  }
+                  J(null, hr);
+                }
+              }
+              return { cancel: function() {
+                we && (we.cancel(), we = null), Ue && (Ue.cancel(), Ue = null);
+              } };
+            }
+            function b(Y) {
+              var D = Y.userImage;
+              if (D && D.render) {
+                var J = D.render();
+                if (J) return Y.data.replace(new Uint8Array(D.data.buffer)), true;
+              }
+              return false;
+            }
+            var p = 1, k = function(Y) {
+              function D() {
+                Y.call(this), this.images = {}, this.updatedImages = {}, this.callbackDispatchedThisFrame = {}, this.loaded = false, this.requestors = [], this.patterns = {}, this.atlasImage = new i.RGBAImage({ width: 1, height: 1 }), this.dirty = true;
+              }
+              return Y && (D.__proto__ = Y), D.prototype = Object.create(Y && Y.prototype), D.prototype.constructor = D, D.prototype.isLoaded = function() {
+                return this.loaded;
+              }, D.prototype.setLoaded = function(q) {
+                if (this.loaded !== q && (this.loaded = q, q)) {
+                  for (var K = 0, de = this.requestors; K < de.length; K += 1) {
+                    var ne = de[K], we = ne.ids, Ue = ne.callback;
+                    this._notify(we, Ue);
+                  }
+                  this.requestors = [];
+                }
+              }, D.prototype.getImage = function(q) {
+                return this.images[q];
+              }, D.prototype.addImage = function(q, K) {
+                this._validate(q, K) && (this.images[q] = K);
+              }, D.prototype._validate = function(q, K) {
+                var de = true;
+                return this._validateStretch(K.stretchX, K.data && K.data.width) || (this.fire(new i.ErrorEvent(new Error('Image "' + q + '" has invalid "stretchX" value'))), de = false), this._validateStretch(K.stretchY, K.data && K.data.height) || (this.fire(new i.ErrorEvent(new Error('Image "' + q + '" has invalid "stretchY" value'))), de = false), this._validateContent(K.content, K) || (this.fire(new i.ErrorEvent(new Error('Image "' + q + '" has invalid "content" value'))), de = false), de;
+              }, D.prototype._validateStretch = function(q, K) {
+                if (!q) return true;
+                for (var de = 0, ne = 0, we = q; ne < we.length; ne += 1) {
+                  var Ue = we[ne];
+                  if (Ue[0] < de || Ue[1] < Ue[0] || K < Ue[1]) return false;
+                  de = Ue[1];
+                }
+                return true;
+              }, D.prototype._validateContent = function(q, K) {
+                return q ? !(q.length !== 4 || q[0] < 0 || K.data.width < q[0] || q[1] < 0 || K.data.height < q[1] || q[2] < 0 || K.data.width < q[2] || q[3] < 0 || K.data.height < q[3] || q[2] < q[0] || q[3] < q[1]) : true;
+              }, D.prototype.updateImage = function(q, K) {
+                var de = this.images[q];
+                K.version = de.version + 1, this.images[q] = K, this.updatedImages[q] = true;
+              }, D.prototype.removeImage = function(q) {
+                var K = this.images[q];
+                delete this.images[q], delete this.patterns[q], K.userImage && K.userImage.onRemove && K.userImage.onRemove();
+              }, D.prototype.listImages = function() {
+                return Object.keys(this.images);
+              }, D.prototype.getImages = function(q, K) {
+                var de = true;
+                if (!this.isLoaded()) for (var ne = 0, we = q; ne < we.length; ne += 1) {
+                  var Ue = we[ne];
+                  this.images[Ue] || (de = false);
+                }
+                this.isLoaded() || de ? this._notify(q, K) : this.requestors.push({ ids: q, callback: K });
+              }, D.prototype._notify = function(q, K) {
+                for (var de = {}, ne = 0, we = q; ne < we.length; ne += 1) {
+                  var Ue = we[ne];
+                  this.images[Ue] || this.fire(new i.Event("styleimagemissing", { id: Ue }));
+                  var ft = this.images[Ue];
+                  ft ? de[Ue] = { data: ft.data.clone(), pixelRatio: ft.pixelRatio, sdf: ft.sdf, version: ft.version, stretchX: ft.stretchX, stretchY: ft.stretchY, content: ft.content, hasRenderCallback: !!(ft.userImage && ft.userImage.render) } : i.warnOnce('Image "' + Ue + '" could not be loaded. Please make sure you have added the image with map.addImage() or a "sprite" property in your style. You can provide missing images by listening for the "styleimagemissing" map event.');
+                }
+                K(null, de);
+              }, D.prototype.getPixelSize = function() {
+                var q = this.atlasImage, K = q.width, de = q.height;
+                return { width: K, height: de };
+              }, D.prototype.getPattern = function(q) {
+                var K = this.patterns[q], de = this.getImage(q);
+                if (!de) return null;
+                if (K && K.position.version === de.version) return K.position;
+                if (K) K.position.version = de.version;
+                else {
+                  var ne = de.data.width + p * 2, we = de.data.height + p * 2, Ue = { w: ne, h: we, x: 0, y: 0 }, ft = new i.ImagePosition(Ue, de);
+                  this.patterns[q] = { bin: Ue, position: ft };
+                }
+                return this._updatePatternAtlas(), this.patterns[q].position;
+              }, D.prototype.bind = function(q) {
+                var K = q.gl;
+                this.atlasTexture ? this.dirty && (this.atlasTexture.update(this.atlasImage), this.dirty = false) : this.atlasTexture = new i.Texture(q, this.atlasImage, K.RGBA), this.atlasTexture.bind(K.LINEAR, K.CLAMP_TO_EDGE);
+              }, D.prototype._updatePatternAtlas = function() {
+                var q = [];
+                for (var K in this.patterns) q.push(this.patterns[K].bin);
+                var de = i.potpack(q), ne = de.w, we = de.h, Ue = this.atlasImage;
+                Ue.resize({ width: ne || 1, height: we || 1 });
+                for (var ft in this.patterns) {
+                  var Zt = this.patterns[ft], hr = Zt.bin, qt = hr.x + p, Ve = hr.y + p, Qe = this.images[ft].data, at = Qe.width, Ct = Qe.height;
+                  i.RGBAImage.copy(Qe, Ue, { x: 0, y: 0 }, { x: qt, y: Ve }, { width: at, height: Ct }), i.RGBAImage.copy(Qe, Ue, { x: 0, y: Ct - 1 }, { x: qt, y: Ve - 1 }, { width: at, height: 1 }), i.RGBAImage.copy(Qe, Ue, { x: 0, y: 0 }, { x: qt, y: Ve + Ct }, { width: at, height: 1 }), i.RGBAImage.copy(Qe, Ue, { x: at - 1, y: 0 }, { x: qt - 1, y: Ve }, { width: 1, height: Ct }), i.RGBAImage.copy(Qe, Ue, { x: 0, y: 0 }, { x: qt + at, y: Ve }, { width: 1, height: Ct });
+                }
+                this.dirty = true;
+              }, D.prototype.beginFrame = function() {
+                this.callbackDispatchedThisFrame = {};
+              }, D.prototype.dispatchRenderCallbacks = function(q) {
+                for (var K = 0, de = q; K < de.length; K += 1) {
+                  var ne = de[K];
+                  if (!this.callbackDispatchedThisFrame[ne]) {
+                    this.callbackDispatchedThisFrame[ne] = true;
+                    var we = this.images[ne], Ue = b(we);
+                    Ue && this.updateImage(ne, we);
+                  }
+                }
+              }, D;
+            }(i.Evented);
+            function E(Y, D, J, q, K) {
+              var de = D * 256, ne = de + 255, we = q.transformRequest(q.normalizeGlyphsURL(J).replace("{fontstack}", Y).replace("{range}", de + "-" + ne), i.ResourceType.Glyphs);
+              i.getArrayBuffer(we, function(Ue, ft) {
+                if (Ue) K(Ue);
+                else if (ft) {
+                  for (var Zt = {}, hr = 0, qt = i.parseGlyphPBF(ft); hr < qt.length; hr += 1) {
+                    var Ve = qt[hr];
+                    Zt[Ve.id] = Ve;
+                  }
+                  K(null, Zt);
+                }
+              });
+            }
+            var T = C, L = C, x = 1e20;
+            function C(Y, D, J, q, K, de) {
+              this.fontSize = Y || 24, this.buffer = D === void 0 ? 3 : D, this.cutoff = q || 0.25, this.fontFamily = K || "sans-serif", this.fontWeight = de || "normal", this.radius = J || 8;
+              var ne = this.size = this.fontSize + this.buffer * 2;
+              this.canvas = document.createElement("canvas"), this.canvas.width = this.canvas.height = ne, this.ctx = this.canvas.getContext("2d"), this.ctx.font = this.fontWeight + " " + this.fontSize + "px " + this.fontFamily, this.ctx.textBaseline = "middle", this.ctx.fillStyle = "black", this.gridOuter = new Float64Array(ne * ne), this.gridInner = new Float64Array(ne * ne), this.f = new Float64Array(ne), this.d = new Float64Array(ne), this.z = new Float64Array(ne + 1), this.v = new Int16Array(ne), this.middle = Math.round(ne / 2 * (navigator.userAgent.indexOf("Gecko/") >= 0 ? 1.2 : 1));
+            }
+            C.prototype.draw = function(Y) {
+              this.ctx.clearRect(0, 0, this.size, this.size), this.ctx.fillText(Y, this.buffer, this.middle);
+              for (var D = this.ctx.getImageData(0, 0, this.size, this.size), J = new Uint8ClampedArray(this.size * this.size), q = 0; q < this.size * this.size; q++) {
+                var K = D.data[q * 4 + 3] / 255;
+                this.gridOuter[q] = K === 1 ? 0 : K === 0 ? x : Math.pow(Math.max(0, 0.5 - K), 2), this.gridInner[q] = K === 1 ? x : K === 0 ? 0 : Math.pow(Math.max(0, K - 0.5), 2);
+              }
+              for (M(this.gridOuter, this.size, this.size, this.f, this.d, this.v, this.z), M(this.gridInner, this.size, this.size, this.f, this.d, this.v, this.z), q = 0; q < this.size * this.size; q++) {
+                var de = this.gridOuter[q] - this.gridInner[q];
+                J[q] = Math.max(0, Math.min(255, Math.round(255 - 255 * (de / this.radius + this.cutoff))));
+              }
+              return J;
+            };
+            function M(Y, D, J, q, K, de, ne) {
+              for (var we = 0; we < D; we++) {
+                for (var Ue = 0; Ue < J; Ue++) q[Ue] = Y[Ue * D + we];
+                for (g(q, K, de, ne, J), Ue = 0; Ue < J; Ue++) Y[Ue * D + we] = K[Ue];
+              }
+              for (Ue = 0; Ue < J; Ue++) {
+                for (we = 0; we < D; we++) q[we] = Y[Ue * D + we];
+                for (g(q, K, de, ne, D), we = 0; we < D; we++) Y[Ue * D + we] = Math.sqrt(K[we]);
+              }
+            }
+            function g(Y, D, J, q, K) {
+              J[0] = 0, q[0] = -1e20, q[1] = 1e20;
+              for (var de = 1, ne = 0; de < K; de++) {
+                for (var we = (Y[de] + de * de - (Y[J[ne]] + J[ne] * J[ne])) / (2 * de - 2 * J[ne]); we <= q[ne]; ) ne--, we = (Y[de] + de * de - (Y[J[ne]] + J[ne] * J[ne])) / (2 * de - 2 * J[ne]);
+                ne++, J[ne] = de, q[ne] = we, q[ne + 1] = 1e20;
+              }
+              for (de = 0, ne = 0; de < K; de++) {
+                for (; q[ne + 1] < de; ) ne++;
+                D[de] = (de - J[ne]) * (de - J[ne]) + Y[J[ne]];
+              }
+            }
+            T.default = L;
+            var P = function(D, J) {
+              this.requestManager = D, this.localIdeographFontFamily = J, this.entries = {};
+            };
+            P.prototype.setURL = function(D) {
+              this.url = D;
+            }, P.prototype.getGlyphs = function(D, J) {
+              var q = this, K = [];
+              for (var de in D) for (var ne = 0, we = D[de]; ne < we.length; ne += 1) {
+                var Ue = we[ne];
+                K.push({ stack: de, id: Ue });
+              }
+              i.asyncAll(K, function(ft, Zt) {
+                var hr = ft.stack, qt = ft.id, Ve = q.entries[hr];
+                Ve || (Ve = q.entries[hr] = { glyphs: {}, requests: {}, ranges: {} });
+                var Qe = Ve.glyphs[qt];
+                if (Qe !== void 0) {
+                  Zt(null, { stack: hr, id: qt, glyph: Qe });
+                  return;
+                }
+                if (Qe = q._tinySDF(Ve, hr, qt), Qe) {
+                  Ve.glyphs[qt] = Qe, Zt(null, { stack: hr, id: qt, glyph: Qe });
+                  return;
+                }
+                var at = Math.floor(qt / 256);
+                if (at * 256 > 65535) {
+                  Zt(new Error("glyphs > 65535 not supported"));
+                  return;
+                }
+                if (Ve.ranges[at]) {
+                  Zt(null, { stack: hr, id: qt, glyph: Qe });
+                  return;
+                }
+                var Ct = Ve.requests[at];
+                Ct || (Ct = Ve.requests[at] = [], P.loadGlyphRange(hr, at, q.url, q.requestManager, function(Ot, Rt) {
+                  if (Rt) {
+                    for (var Bt in Rt) q._doesCharSupportLocalGlyph(+Bt) || (Ve.glyphs[+Bt] = Rt[+Bt]);
+                    Ve.ranges[at] = true;
+                  }
+                  for (var Dt = 0, yt = Ct; Dt < yt.length; Dt += 1) {
+                    var Pt = yt[Dt];
+                    Pt(Ot, Rt);
+                  }
+                  delete Ve.requests[at];
+                })), Ct.push(function(Ot, Rt) {
+                  Ot ? Zt(Ot) : Rt && Zt(null, { stack: hr, id: qt, glyph: Rt[qt] || null });
+                });
+              }, function(ft, Zt) {
+                if (ft) J(ft);
+                else if (Zt) {
+                  for (var hr = {}, qt = 0, Ve = Zt; qt < Ve.length; qt += 1) {
+                    var Qe = Ve[qt], at = Qe.stack, Ct = Qe.id, Ot = Qe.glyph;
+                    (hr[at] || (hr[at] = {}))[Ct] = Ot && { id: Ot.id, bitmap: Ot.bitmap.clone(), metrics: Ot.metrics };
+                  }
+                  J(null, hr);
+                }
+              });
+            }, P.prototype._doesCharSupportLocalGlyph = function(D) {
+              return !!this.localIdeographFontFamily && (i.isChar["CJK Unified Ideographs"](D) || i.isChar["Hangul Syllables"](D) || i.isChar.Hiragana(D) || i.isChar.Katakana(D));
+            }, P.prototype._tinySDF = function(D, J, q) {
+              var K = this.localIdeographFontFamily;
+              if (K && this._doesCharSupportLocalGlyph(q)) {
+                var de = D.tinySDF;
+                if (!de) {
+                  var ne = "400";
+                  /bold/i.test(J) ? ne = "900" : /medium/i.test(J) ? ne = "500" : /light/i.test(J) && (ne = "200"), de = D.tinySDF = new P.TinySDF(24, 3, 8, 0.25, K, ne);
+                }
+                return { id: q, bitmap: new i.AlphaImage({ width: 30, height: 30 }, de.draw(String.fromCharCode(q))), metrics: { width: 24, height: 24, left: 0, top: -8, advance: 24 } };
+              }
+            }, P.loadGlyphRange = E, P.TinySDF = T;
+            var A = function() {
+              this.specification = i.styleSpec.light.position;
+            };
+            A.prototype.possiblyEvaluate = function(D, J) {
+              return i.sphericalToCartesian(D.expression.evaluate(J));
+            }, A.prototype.interpolate = function(D, J, q) {
+              return { x: i.number(D.x, J.x, q), y: i.number(D.y, J.y, q), z: i.number(D.z, J.z, q) };
+            };
+            var z = new i.Properties({ anchor: new i.DataConstantProperty(i.styleSpec.light.anchor), position: new A(), color: new i.DataConstantProperty(i.styleSpec.light.color), intensity: new i.DataConstantProperty(i.styleSpec.light.intensity) }), O = "-transition", U = function(Y) {
+              function D(J) {
+                Y.call(this), this._transitionable = new i.Transitionable(z), this.setLight(J), this._transitioning = this._transitionable.untransitioned();
+              }
+              return Y && (D.__proto__ = Y), D.prototype = Object.create(Y && Y.prototype), D.prototype.constructor = D, D.prototype.getLight = function() {
+                return this._transitionable.serialize();
+              }, D.prototype.setLight = function(q, K) {
+                if (K === void 0 && (K = {}), !this._validate(i.validateLight, q, K)) for (var de in q) {
+                  var ne = q[de];
+                  i.endsWith(de, O) ? this._transitionable.setTransition(de.slice(0, -O.length), ne) : this._transitionable.setValue(de, ne);
+                }
+              }, D.prototype.updateTransitions = function(q) {
+                this._transitioning = this._transitionable.transitioned(q, this._transitioning);
+              }, D.prototype.hasTransition = function() {
+                return this._transitioning.hasTransition();
+              }, D.prototype.recalculate = function(q) {
+                this.properties = this._transitioning.possiblyEvaluate(q);
+              }, D.prototype._validate = function(q, K, de) {
+                return de && de.validate === false ? false : i.emitValidationErrors(this, q.call(i.validateStyle, i.extend({ value: K, style: { glyphs: true, sprite: true }, styleSpec: i.styleSpec })));
+              }, D;
+            }(i.Evented), G = function(D, J) {
+              this.width = D, this.height = J, this.nextRow = 0, this.data = new Uint8Array(this.width * this.height), this.dashEntry = {};
+            };
+            G.prototype.getDash = function(D, J) {
+              var q = D.join(",") + String(J);
+              return this.dashEntry[q] || (this.dashEntry[q] = this.addDash(D, J)), this.dashEntry[q];
+            }, G.prototype.getDashRanges = function(D, J, q) {
+              var K = D.length % 2 === 1, de = [], ne = K ? -D[D.length - 1] * q : 0, we = D[0] * q, Ue = true;
+              de.push({ left: ne, right: we, isDash: Ue, zeroLength: D[0] === 0 });
+              for (var ft = D[0], Zt = 1; Zt < D.length; Zt++) {
+                Ue = !Ue;
+                var hr = D[Zt];
+                ne = ft * q, ft += hr, we = ft * q, de.push({ left: ne, right: we, isDash: Ue, zeroLength: hr === 0 });
+              }
+              return de;
+            }, G.prototype.addRoundDash = function(D, J, q) {
+              for (var K = J / 2, de = -q; de <= q; de++) for (var ne = this.nextRow + q + de, we = this.width * ne, Ue = 0, ft = D[Ue], Zt = 0; Zt < this.width; Zt++) {
+                Zt / ft.right > 1 && (ft = D[++Ue]);
+                var hr = Math.abs(Zt - ft.left), qt = Math.abs(Zt - ft.right), Ve = Math.min(hr, qt), Qe = void 0, at = de / q * (K + 1);
+                if (ft.isDash) {
+                  var Ct = K - Math.abs(at);
+                  Qe = Math.sqrt(Ve * Ve + Ct * Ct);
+                } else Qe = K - Math.sqrt(Ve * Ve + at * at);
+                this.data[we + Zt] = Math.max(0, Math.min(255, Qe + 128));
+              }
+            }, G.prototype.addRegularDash = function(D) {
+              for (var J = D.length - 1; J >= 0; --J) {
+                var q = D[J], K = D[J + 1];
+                q.zeroLength ? D.splice(J, 1) : K && K.isDash === q.isDash && (K.left = q.left, D.splice(J, 1));
+              }
+              var de = D[0], ne = D[D.length - 1];
+              de.isDash === ne.isDash && (de.left = ne.left - this.width, ne.right = de.right + this.width);
+              for (var we = this.width * this.nextRow, Ue = 0, ft = D[Ue], Zt = 0; Zt < this.width; Zt++) {
+                Zt / ft.right > 1 && (ft = D[++Ue]);
+                var hr = Math.abs(Zt - ft.left), qt = Math.abs(Zt - ft.right), Ve = Math.min(hr, qt), Qe = ft.isDash ? Ve : -Ve;
+                this.data[we + Zt] = Math.max(0, Math.min(255, Qe + 128));
+              }
+            }, G.prototype.addDash = function(D, J) {
+              var q = J ? 7 : 0, K = 2 * q + 1;
+              if (this.nextRow + K > this.height) return i.warnOnce("LineAtlas out of space"), null;
+              for (var de = 0, ne = 0; ne < D.length; ne++) de += D[ne];
+              if (de !== 0) {
+                var we = this.width / de, Ue = this.getDashRanges(D, this.width, we);
+                J ? this.addRoundDash(Ue, we, q) : this.addRegularDash(Ue);
+              }
+              var ft = { y: (this.nextRow + q + 0.5) / this.height, height: 2 * q / this.height, width: de };
+              return this.nextRow += K, this.dirty = true, ft;
+            }, G.prototype.bind = function(D) {
+              var J = D.gl;
+              this.texture ? (J.bindTexture(J.TEXTURE_2D, this.texture), this.dirty && (this.dirty = false, J.texSubImage2D(J.TEXTURE_2D, 0, 0, 0, this.width, this.height, J.ALPHA, J.UNSIGNED_BYTE, this.data))) : (this.texture = J.createTexture(), J.bindTexture(J.TEXTURE_2D, this.texture), J.texParameteri(J.TEXTURE_2D, J.TEXTURE_WRAP_S, J.REPEAT), J.texParameteri(J.TEXTURE_2D, J.TEXTURE_WRAP_T, J.REPEAT), J.texParameteri(J.TEXTURE_2D, J.TEXTURE_MIN_FILTER, J.LINEAR), J.texParameteri(J.TEXTURE_2D, J.TEXTURE_MAG_FILTER, J.LINEAR), J.texImage2D(J.TEXTURE_2D, 0, J.ALPHA, this.width, this.height, 0, J.ALPHA, J.UNSIGNED_BYTE, this.data));
+            };
+            var Z = function Y(D, J) {
+              this.workerPool = D, this.actors = [], this.currentActor = 0, this.id = i.uniqueId();
+              for (var q = this.workerPool.acquire(this.id), K = 0; K < q.length; K++) {
+                var de = q[K], ne = new Y.Actor(de, J, this.id);
+                ne.name = "Worker " + K, this.actors.push(ne);
+              }
+            };
+            Z.prototype.broadcast = function(D, J, q) {
+              q = q || function() {
+              }, i.asyncAll(this.actors, function(K, de) {
+                K.send(D, J, de);
+              }, q);
+            }, Z.prototype.getActor = function() {
+              return this.currentActor = (this.currentActor + 1) % this.actors.length, this.actors[this.currentActor];
+            }, Z.prototype.remove = function() {
+              this.actors.forEach(function(D) {
+                D.remove();
+              }), this.actors = [], this.workerPool.release(this.id);
+            }, Z.Actor = i.Actor;
+            function j(Y, D, J) {
+              var q = function(K, de) {
+                if (K) return J(K);
+                if (de) {
+                  var ne = i.pick(i.extend(de, Y), ["tiles", "minzoom", "maxzoom", "attribution", "mapbox_logo", "bounds", "scheme", "tileSize", "encoding"]);
+                  de.vector_layers && (ne.vectorLayers = de.vector_layers, ne.vectorLayerIds = ne.vectorLayers.map(function(we) {
+                    return we.id;
+                  })), ne.tiles = D.canonicalizeTileset(ne, Y.url), J(null, ne);
+                }
+              };
+              return Y.url ? i.getJSON(D.transformRequest(D.normalizeSourceURL(Y.url), i.ResourceType.Source), q) : i.browser.frame(function() {
+                return q(null, Y);
+              });
+            }
+            var N = function(D, J, q) {
+              this.bounds = i.LngLatBounds.convert(this.validateBounds(D)), this.minzoom = J || 0, this.maxzoom = q || 24;
+            };
+            N.prototype.validateBounds = function(D) {
+              return !Array.isArray(D) || D.length !== 4 ? [-180, -90, 180, 90] : [Math.max(-180, D[0]), Math.max(-90, D[1]), Math.min(180, D[2]), Math.min(90, D[3])];
+            }, N.prototype.contains = function(D) {
+              var J = Math.pow(2, D.z), q = { minX: Math.floor(i.mercatorXfromLng(this.bounds.getWest()) * J), minY: Math.floor(i.mercatorYfromLat(this.bounds.getNorth()) * J), maxX: Math.ceil(i.mercatorXfromLng(this.bounds.getEast()) * J), maxY: Math.ceil(i.mercatorYfromLat(this.bounds.getSouth()) * J) }, K = D.x >= q.minX && D.x < q.maxX && D.y >= q.minY && D.y < q.maxY;
+              return K;
+            };
+            var H = function(Y) {
+              function D(J, q, K, de) {
+                if (Y.call(this), this.id = J, this.dispatcher = K, this.type = "vector", this.minzoom = 0, this.maxzoom = 22, this.scheme = "xyz", this.tileSize = 512, this.reparseOverscaled = true, this.isTileClipped = true, this._loaded = false, i.extend(this, i.pick(q, ["url", "scheme", "tileSize", "promoteId"])), this._options = i.extend({ type: "vector" }, q), this._collectResourceTiming = q.collectResourceTiming, this.tileSize !== 512) throw new Error("vector tile sources must have a tileSize of 512");
+                this.setEventedParent(de);
+              }
+              return Y && (D.__proto__ = Y), D.prototype = Object.create(Y && Y.prototype), D.prototype.constructor = D, D.prototype.load = function() {
+                var q = this;
+                this._loaded = false, this.fire(new i.Event("dataloading", { dataType: "source" })), this._tileJSONRequest = j(this._options, this.map._requestManager, function(K, de) {
+                  q._tileJSONRequest = null, q._loaded = true, K ? q.fire(new i.ErrorEvent(K)) : de && (i.extend(q, de), de.bounds && (q.tileBounds = new N(de.bounds, q.minzoom, q.maxzoom)), i.postTurnstileEvent(de.tiles, q.map._requestManager._customAccessToken), i.postMapLoadEvent(de.tiles, q.map._getMapId(), q.map._requestManager._skuToken, q.map._requestManager._customAccessToken), q.fire(new i.Event("data", { dataType: "source", sourceDataType: "metadata" })), q.fire(new i.Event("data", { dataType: "source", sourceDataType: "content" })));
+                });
+              }, D.prototype.loaded = function() {
+                return this._loaded;
+              }, D.prototype.hasTile = function(q) {
+                return !this.tileBounds || this.tileBounds.contains(q.canonical);
+              }, D.prototype.onAdd = function(q) {
+                this.map = q, this.load();
+              }, D.prototype.setSourceProperty = function(q) {
+                this._tileJSONRequest && this._tileJSONRequest.cancel(), q();
+                var K = this.map.style.sourceCaches[this.id];
+                K.clearTiles(), this.load();
+              }, D.prototype.setTiles = function(q) {
+                var K = this;
+                return this.setSourceProperty(function() {
+                  K._options.tiles = q;
+                }), this;
+              }, D.prototype.setUrl = function(q) {
+                var K = this;
+                return this.setSourceProperty(function() {
+                  K.url = q, K._options.url = q;
+                }), this;
+              }, D.prototype.onRemove = function() {
+                this._tileJSONRequest && (this._tileJSONRequest.cancel(), this._tileJSONRequest = null);
+              }, D.prototype.serialize = function() {
+                return i.extend({}, this._options);
+              }, D.prototype.loadTile = function(q, K) {
+                var de = this.map._requestManager.normalizeTileURL(q.tileID.canonical.url(this.tiles, this.scheme)), ne = { request: this.map._requestManager.transformRequest(de, i.ResourceType.Tile), uid: q.uid, tileID: q.tileID, zoom: q.tileID.overscaledZ, tileSize: this.tileSize * q.tileID.overscaleFactor(), type: this.type, source: this.id, pixelRatio: i.browser.devicePixelRatio, showCollisionBoxes: this.map.showCollisionBoxes, promoteId: this.promoteId };
+                ne.request.collectResourceTiming = this._collectResourceTiming, !q.actor || q.state === "expired" ? (q.actor = this.dispatcher.getActor(), q.request = q.actor.send("loadTile", ne, we.bind(this))) : q.state === "loading" ? q.reloadCallback = K : q.request = q.actor.send("reloadTile", ne, we.bind(this));
+                function we(Ue, ft) {
+                  if (delete q.request, q.aborted) return K(null);
+                  if (Ue && Ue.status !== 404) return K(Ue);
+                  ft && ft.resourceTiming && (q.resourceTiming = ft.resourceTiming), this.map._refreshExpiredTiles && ft && q.setExpiryData(ft), q.loadVectorData(ft, this.map.painter), i.cacheEntryPossiblyAdded(this.dispatcher), K(null), q.reloadCallback && (this.loadTile(q, q.reloadCallback), q.reloadCallback = null);
+                }
+              }, D.prototype.abortTile = function(q) {
+                q.request && (q.request.cancel(), delete q.request), q.actor && q.actor.send("abortTile", { uid: q.uid, type: this.type, source: this.id }, void 0);
+              }, D.prototype.unloadTile = function(q) {
+                q.unloadVectorData(), q.actor && q.actor.send("removeTile", { uid: q.uid, type: this.type, source: this.id }, void 0);
+              }, D.prototype.hasTransition = function() {
+                return false;
+              }, D;
+            }(i.Evented), re = function(Y) {
+              function D(J, q, K, de) {
+                Y.call(this), this.id = J, this.dispatcher = K, this.setEventedParent(de), this.type = "raster", this.minzoom = 0, this.maxzoom = 22, this.roundZoom = true, this.scheme = "xyz", this.tileSize = 512, this._loaded = false, this._options = i.extend({ type: "raster" }, q), i.extend(this, i.pick(q, ["url", "scheme", "tileSize"]));
+              }
+              return Y && (D.__proto__ = Y), D.prototype = Object.create(Y && Y.prototype), D.prototype.constructor = D, D.prototype.load = function() {
+                var q = this;
+                this._loaded = false, this.fire(new i.Event("dataloading", { dataType: "source" })), this._tileJSONRequest = j(this._options, this.map._requestManager, function(K, de) {
+                  q._tileJSONRequest = null, q._loaded = true, K ? q.fire(new i.ErrorEvent(K)) : de && (i.extend(q, de), de.bounds && (q.tileBounds = new N(de.bounds, q.minzoom, q.maxzoom)), i.postTurnstileEvent(de.tiles), i.postMapLoadEvent(de.tiles, q.map._getMapId(), q.map._requestManager._skuToken), q.fire(new i.Event("data", { dataType: "source", sourceDataType: "metadata" })), q.fire(new i.Event("data", { dataType: "source", sourceDataType: "content" })));
+                });
+              }, D.prototype.loaded = function() {
+                return this._loaded;
+              }, D.prototype.onAdd = function(q) {
+                this.map = q, this.load();
+              }, D.prototype.onRemove = function() {
+                this._tileJSONRequest && (this._tileJSONRequest.cancel(), this._tileJSONRequest = null);
+              }, D.prototype.serialize = function() {
+                return i.extend({}, this._options);
+              }, D.prototype.hasTile = function(q) {
+                return !this.tileBounds || this.tileBounds.contains(q.canonical);
+              }, D.prototype.loadTile = function(q, K) {
+                var de = this, ne = this.map._requestManager.normalizeTileURL(q.tileID.canonical.url(this.tiles, this.scheme), this.tileSize);
+                q.request = i.getImage(this.map._requestManager.transformRequest(ne, i.ResourceType.Tile), function(we, Ue) {
+                  if (delete q.request, q.aborted) q.state = "unloaded", K(null);
+                  else if (we) q.state = "errored", K(we);
+                  else if (Ue) {
+                    de.map._refreshExpiredTiles && q.setExpiryData(Ue), delete Ue.cacheControl, delete Ue.expires;
+                    var ft = de.map.painter.context, Zt = ft.gl;
+                    q.texture = de.map.painter.getTileTexture(Ue.width), q.texture ? q.texture.update(Ue, { useMipmap: true }) : (q.texture = new i.Texture(ft, Ue, Zt.RGBA, { useMipmap: true }), q.texture.bind(Zt.LINEAR, Zt.CLAMP_TO_EDGE, Zt.LINEAR_MIPMAP_NEAREST), ft.extTextureFilterAnisotropic && Zt.texParameterf(Zt.TEXTURE_2D, ft.extTextureFilterAnisotropic.TEXTURE_MAX_ANISOTROPY_EXT, ft.extTextureFilterAnisotropicMax)), q.state = "loaded", i.cacheEntryPossiblyAdded(de.dispatcher), K(null);
+                  }
+                });
+              }, D.prototype.abortTile = function(q, K) {
+                q.request && (q.request.cancel(), delete q.request), K();
+              }, D.prototype.unloadTile = function(q, K) {
+                q.texture && this.map.painter.saveTileTexture(q.texture), K();
+              }, D.prototype.hasTransition = function() {
+                return false;
+              }, D;
+            }(i.Evented), oe = function(Y) {
+              function D(J, q, K, de) {
+                Y.call(this, J, q, K, de), this.type = "raster-dem", this.maxzoom = 22, this._options = i.extend({ type: "raster-dem" }, q), this.encoding = q.encoding || "mapbox";
+              }
+              return Y && (D.__proto__ = Y), D.prototype = Object.create(Y && Y.prototype), D.prototype.constructor = D, D.prototype.serialize = function() {
+                return { type: "raster-dem", url: this.url, tileSize: this.tileSize, tiles: this.tiles, bounds: this.bounds, encoding: this.encoding };
+              }, D.prototype.loadTile = function(q, K) {
+                var de = this.map._requestManager.normalizeTileURL(q.tileID.canonical.url(this.tiles, this.scheme), this.tileSize);
+                q.request = i.getImage(this.map._requestManager.transformRequest(de, i.ResourceType.Tile), ne.bind(this)), q.neighboringTiles = this._getNeighboringTiles(q.tileID);
+                function ne(Ue, ft) {
+                  if (delete q.request, q.aborted) q.state = "unloaded", K(null);
+                  else if (Ue) q.state = "errored", K(Ue);
+                  else if (ft) {
+                    this.map._refreshExpiredTiles && q.setExpiryData(ft), delete ft.cacheControl, delete ft.expires;
+                    var Zt = i.window.ImageBitmap && ft instanceof i.window.ImageBitmap && i.offscreenCanvasSupported(), hr = Zt ? ft : i.browser.getImageData(ft, 1), qt = { uid: q.uid, coord: q.tileID, source: this.id, rawImageData: hr, encoding: this.encoding };
+                    (!q.actor || q.state === "expired") && (q.actor = this.dispatcher.getActor(), q.actor.send("loadDEMTile", qt, we.bind(this)));
+                  }
+                }
+                function we(Ue, ft) {
+                  Ue && (q.state = "errored", K(Ue)), ft && (q.dem = ft, q.needsHillshadePrepare = true, q.state = "loaded", K(null));
+                }
+              }, D.prototype._getNeighboringTiles = function(q) {
+                var K = q.canonical, de = Math.pow(2, K.z), ne = (K.x - 1 + de) % de, we = K.x === 0 ? q.wrap - 1 : q.wrap, Ue = (K.x + 1 + de) % de, ft = K.x + 1 === de ? q.wrap + 1 : q.wrap, Zt = {};
+                return Zt[new i.OverscaledTileID(q.overscaledZ, we, K.z, ne, K.y).key] = { backfilled: false }, Zt[new i.OverscaledTileID(q.overscaledZ, ft, K.z, Ue, K.y).key] = { backfilled: false }, K.y > 0 && (Zt[new i.OverscaledTileID(q.overscaledZ, we, K.z, ne, K.y - 1).key] = { backfilled: false }, Zt[new i.OverscaledTileID(q.overscaledZ, q.wrap, K.z, K.x, K.y - 1).key] = { backfilled: false }, Zt[new i.OverscaledTileID(q.overscaledZ, ft, K.z, Ue, K.y - 1).key] = { backfilled: false }), K.y + 1 < de && (Zt[new i.OverscaledTileID(q.overscaledZ, we, K.z, ne, K.y + 1).key] = { backfilled: false }, Zt[new i.OverscaledTileID(q.overscaledZ, q.wrap, K.z, K.x, K.y + 1).key] = { backfilled: false }, Zt[new i.OverscaledTileID(q.overscaledZ, ft, K.z, Ue, K.y + 1).key] = { backfilled: false }), Zt;
+              }, D.prototype.unloadTile = function(q) {
+                q.demTexture && this.map.painter.saveTileTexture(q.demTexture), q.fbo && (q.fbo.destroy(), delete q.fbo), q.dem && delete q.dem, delete q.neighboringTiles, q.state = "unloaded", q.actor && q.actor.send("removeDEMTile", { uid: q.uid, source: this.id });
+              }, D;
+            }(re), _e = function(Y) {
+              function D(J, q, K, de) {
+                Y.call(this), this.id = J, this.type = "geojson", this.minzoom = 0, this.maxzoom = 18, this.tileSize = 512, this.isTileClipped = true, this.reparseOverscaled = true, this._removed = false, this._loaded = false, this.actor = K.getActor(), this.setEventedParent(de), this._data = q.data, this._options = i.extend({}, q), this._collectResourceTiming = q.collectResourceTiming, this._resourceTiming = [], q.maxzoom !== void 0 && (this.maxzoom = q.maxzoom), q.type && (this.type = q.type), q.attribution && (this.attribution = q.attribution), this.promoteId = q.promoteId;
+                var ne = i.EXTENT / this.tileSize;
+                this.workerOptions = i.extend({ source: this.id, cluster: q.cluster || false, geojsonVtOptions: { buffer: (q.buffer !== void 0 ? q.buffer : 128) * ne, tolerance: (q.tolerance !== void 0 ? q.tolerance : 0.375) * ne, extent: i.EXTENT, maxZoom: this.maxzoom, lineMetrics: q.lineMetrics || false, generateId: q.generateId || false }, superclusterOptions: { maxZoom: q.clusterMaxZoom !== void 0 ? Math.min(q.clusterMaxZoom, this.maxzoom - 1) : this.maxzoom - 1, minPoints: Math.max(2, q.clusterMinPoints || 2), extent: i.EXTENT, radius: (q.clusterRadius || 50) * ne, log: false, generateId: q.generateId || false }, clusterProperties: q.clusterProperties, filter: q.filter }, q.workerOptions);
+              }
+              return Y && (D.__proto__ = Y), D.prototype = Object.create(Y && Y.prototype), D.prototype.constructor = D, D.prototype.load = function() {
+                var q = this;
+                this.fire(new i.Event("dataloading", { dataType: "source" })), this._updateWorkerData(function(K) {
+                  if (K) {
+                    q.fire(new i.ErrorEvent(K));
+                    return;
+                  }
+                  var de = { dataType: "source", sourceDataType: "metadata" };
+                  q._collectResourceTiming && q._resourceTiming && q._resourceTiming.length > 0 && (de.resourceTiming = q._resourceTiming, q._resourceTiming = []), q.fire(new i.Event("data", de));
+                });
+              }, D.prototype.onAdd = function(q) {
+                this.map = q, this.load();
+              }, D.prototype.setData = function(q) {
+                var K = this;
+                return this._data = q, this.fire(new i.Event("dataloading", { dataType: "source" })), this._updateWorkerData(function(de) {
+                  if (de) {
+                    K.fire(new i.ErrorEvent(de));
+                    return;
+                  }
+                  var ne = { dataType: "source", sourceDataType: "content" };
+                  K._collectResourceTiming && K._resourceTiming && K._resourceTiming.length > 0 && (ne.resourceTiming = K._resourceTiming, K._resourceTiming = []), K.fire(new i.Event("data", ne));
+                }), this;
+              }, D.prototype.getClusterExpansionZoom = function(q, K) {
+                return this.actor.send("geojson.getClusterExpansionZoom", { clusterId: q, source: this.id }, K), this;
+              }, D.prototype.getClusterChildren = function(q, K) {
+                return this.actor.send("geojson.getClusterChildren", { clusterId: q, source: this.id }, K), this;
+              }, D.prototype.getClusterLeaves = function(q, K, de, ne) {
+                return this.actor.send("geojson.getClusterLeaves", { source: this.id, clusterId: q, limit: K, offset: de }, ne), this;
+              }, D.prototype._updateWorkerData = function(q) {
+                var K = this;
+                this._loaded = false;
+                var de = i.extend({}, this.workerOptions), ne = this._data;
+                typeof ne == "string" ? (de.request = this.map._requestManager.transformRequest(i.browser.resolveURL(ne), i.ResourceType.Source), de.request.collectResourceTiming = this._collectResourceTiming) : de.data = JSON.stringify(ne), this.actor.send(this.type + ".loadData", de, function(we, Ue) {
+                  K._removed || Ue && Ue.abandoned || (K._loaded = true, Ue && Ue.resourceTiming && Ue.resourceTiming[K.id] && (K._resourceTiming = Ue.resourceTiming[K.id].slice(0)), K.actor.send(K.type + ".coalesce", { source: de.source }, null), q(we));
+                });
+              }, D.prototype.loaded = function() {
+                return this._loaded;
+              }, D.prototype.loadTile = function(q, K) {
+                var de = this, ne = q.actor ? "reloadTile" : "loadTile";
+                q.actor = this.actor;
+                var we = { type: this.type, uid: q.uid, tileID: q.tileID, zoom: q.tileID.overscaledZ, maxZoom: this.maxzoom, tileSize: this.tileSize, source: this.id, pixelRatio: i.browser.devicePixelRatio, showCollisionBoxes: this.map.showCollisionBoxes, promoteId: this.promoteId };
+                q.request = this.actor.send(ne, we, function(Ue, ft) {
+                  return delete q.request, q.unloadVectorData(), q.aborted ? K(null) : Ue ? K(Ue) : (q.loadVectorData(ft, de.map.painter, ne === "reloadTile"), K(null));
+                });
+              }, D.prototype.abortTile = function(q) {
+                q.request && (q.request.cancel(), delete q.request), q.aborted = true;
+              }, D.prototype.unloadTile = function(q) {
+                q.unloadVectorData(), this.actor.send("removeTile", { uid: q.uid, type: this.type, source: this.id });
+              }, D.prototype.onRemove = function() {
+                this._removed = true, this.actor.send("removeSource", { type: this.type, source: this.id });
+              }, D.prototype.serialize = function() {
+                return i.extend({}, this._options, { type: this.type, data: this._data });
+              }, D.prototype.hasTransition = function() {
+                return false;
+              }, D;
+            }(i.Evented), Ce = i.createLayout([{ name: "a_pos", type: "Int16", components: 2 }, { name: "a_texture_pos", type: "Int16", components: 2 }]), Le = function(Y) {
+              function D(J, q, K, de) {
+                Y.call(this), this.id = J, this.dispatcher = K, this.coordinates = q.coordinates, this.type = "image", this.minzoom = 0, this.maxzoom = 22, this.tileSize = 512, this.tiles = {}, this._loaded = false, this.setEventedParent(de), this.options = q;
+              }
+              return Y && (D.__proto__ = Y), D.prototype = Object.create(Y && Y.prototype), D.prototype.constructor = D, D.prototype.load = function(q, K) {
+                var de = this;
+                this._loaded = false, this.fire(new i.Event("dataloading", { dataType: "source" })), this.url = this.options.url, i.getImage(this.map._requestManager.transformRequest(this.url, i.ResourceType.Image), function(ne, we) {
+                  de._loaded = true, ne ? de.fire(new i.ErrorEvent(ne)) : we && (de.image = we, q && (de.coordinates = q), K && K(), de._finishLoading());
+                });
+              }, D.prototype.loaded = function() {
+                return this._loaded;
+              }, D.prototype.updateImage = function(q) {
+                var K = this;
+                return !this.image || !q.url ? this : (this.options.url = q.url, this.load(q.coordinates, function() {
+                  K.texture = null;
+                }), this);
+              }, D.prototype._finishLoading = function() {
+                this.map && (this.setCoordinates(this.coordinates), this.fire(new i.Event("data", { dataType: "source", sourceDataType: "metadata" })));
+              }, D.prototype.onAdd = function(q) {
+                this.map = q, this.load();
+              }, D.prototype.setCoordinates = function(q) {
+                var K = this;
+                this.coordinates = q;
+                var de = q.map(i.MercatorCoordinate.fromLngLat);
+                this.tileID = ge(de), this.minzoom = this.maxzoom = this.tileID.z;
+                var ne = de.map(function(we) {
+                  return K.tileID.getTilePoint(we)._round();
+                });
+                return this._boundsArray = new i.StructArrayLayout4i8(), this._boundsArray.emplaceBack(ne[0].x, ne[0].y, 0, 0), this._boundsArray.emplaceBack(ne[1].x, ne[1].y, i.EXTENT, 0), this._boundsArray.emplaceBack(ne[3].x, ne[3].y, 0, i.EXTENT), this._boundsArray.emplaceBack(ne[2].x, ne[2].y, i.EXTENT, i.EXTENT), this.boundsBuffer && (this.boundsBuffer.destroy(), delete this.boundsBuffer), this.fire(new i.Event("data", { dataType: "source", sourceDataType: "content" })), this;
+              }, D.prototype.prepare = function() {
+                if (!(Object.keys(this.tiles).length === 0 || !this.image)) {
+                  var q = this.map.painter.context, K = q.gl;
+                  this.boundsBuffer || (this.boundsBuffer = q.createVertexBuffer(this._boundsArray, Ce.members)), this.boundsSegments || (this.boundsSegments = i.SegmentVector.simpleSegment(0, 0, 4, 2)), this.texture || (this.texture = new i.Texture(q, this.image, K.RGBA), this.texture.bind(K.LINEAR, K.CLAMP_TO_EDGE));
+                  for (var de in this.tiles) {
+                    var ne = this.tiles[de];
+                    ne.state !== "loaded" && (ne.state = "loaded", ne.texture = this.texture);
+                  }
+                }
+              }, D.prototype.loadTile = function(q, K) {
+                this.tileID && this.tileID.equals(q.tileID.canonical) ? (this.tiles[String(q.tileID.wrap)] = q, q.buckets = {}, K(null)) : (q.state = "errored", K(null));
+              }, D.prototype.serialize = function() {
+                return { type: "image", url: this.options.url, coordinates: this.coordinates };
+              }, D.prototype.hasTransition = function() {
+                return false;
+              }, D;
+            }(i.Evented);
+            function ge(Y) {
+              for (var D = 1 / 0, J = 1 / 0, q = -1 / 0, K = -1 / 0, de = 0, ne = Y; de < ne.length; de += 1) {
+                var we = ne[de];
+                D = Math.min(D, we.x), J = Math.min(J, we.y), q = Math.max(q, we.x), K = Math.max(K, we.y);
+              }
+              var Ue = q - D, ft = K - J, Zt = Math.max(Ue, ft), hr = Math.max(0, Math.floor(-Math.log(Zt) / Math.LN2)), qt = Math.pow(2, hr);
+              return new i.CanonicalTileID(hr, Math.floor((D + q) / 2 * qt), Math.floor((J + K) / 2 * qt));
+            }
+            var ie = function(Y) {
+              function D(J, q, K, de) {
+                Y.call(this, J, q, K, de), this.roundZoom = true, this.type = "video", this.options = q;
+              }
+              return Y && (D.__proto__ = Y), D.prototype = Object.create(Y && Y.prototype), D.prototype.constructor = D, D.prototype.load = function() {
+                var q = this;
+                this._loaded = false;
+                var K = this.options;
+                this.urls = [];
+                for (var de = 0, ne = K.urls; de < ne.length; de += 1) {
+                  var we = ne[de];
+                  this.urls.push(this.map._requestManager.transformRequest(we, i.ResourceType.Source).url);
+                }
+                i.getVideo(this.urls, function(Ue, ft) {
+                  q._loaded = true, Ue ? q.fire(new i.ErrorEvent(Ue)) : ft && (q.video = ft, q.video.loop = true, q.video.addEventListener("playing", function() {
+                    q.map.triggerRepaint();
+                  }), q.map && q.video.play(), q._finishLoading());
+                });
+              }, D.prototype.pause = function() {
+                this.video && this.video.pause();
+              }, D.prototype.play = function() {
+                this.video && this.video.play();
+              }, D.prototype.seek = function(q) {
+                if (this.video) {
+                  var K = this.video.seekable;
+                  q < K.start(0) || q > K.end(0) ? this.fire(new i.ErrorEvent(new i.ValidationError("sources." + this.id, null, "Playback for this video can be set only between the " + K.start(0) + " and " + K.end(0) + "-second mark."))) : this.video.currentTime = q;
+                }
+              }, D.prototype.getVideo = function() {
+                return this.video;
+              }, D.prototype.onAdd = function(q) {
+                this.map || (this.map = q, this.load(), this.video && (this.video.play(), this.setCoordinates(this.coordinates)));
+              }, D.prototype.prepare = function() {
+                if (!(Object.keys(this.tiles).length === 0 || this.video.readyState < 2)) {
+                  var q = this.map.painter.context, K = q.gl;
+                  this.boundsBuffer || (this.boundsBuffer = q.createVertexBuffer(this._boundsArray, Ce.members)), this.boundsSegments || (this.boundsSegments = i.SegmentVector.simpleSegment(0, 0, 4, 2)), this.texture ? this.video.paused || (this.texture.bind(K.LINEAR, K.CLAMP_TO_EDGE), K.texSubImage2D(K.TEXTURE_2D, 0, 0, 0, K.RGBA, K.UNSIGNED_BYTE, this.video)) : (this.texture = new i.Texture(q, this.video, K.RGBA), this.texture.bind(K.LINEAR, K.CLAMP_TO_EDGE));
+                  for (var de in this.tiles) {
+                    var ne = this.tiles[de];
+                    ne.state !== "loaded" && (ne.state = "loaded", ne.texture = this.texture);
+                  }
+                }
+              }, D.prototype.serialize = function() {
+                return { type: "video", urls: this.urls, coordinates: this.coordinates };
+              }, D.prototype.hasTransition = function() {
+                return this.video && !this.video.paused;
+              }, D;
+            }(Le), Se = function(Y) {
+              function D(J, q, K, de) {
+                Y.call(this, J, q, K, de), q.coordinates ? (!Array.isArray(q.coordinates) || q.coordinates.length !== 4 || q.coordinates.some(function(ne) {
+                  return !Array.isArray(ne) || ne.length !== 2 || ne.some(function(we) {
+                    return typeof we != "number";
+                  });
+                })) && this.fire(new i.ErrorEvent(new i.ValidationError("sources." + J, null, '"coordinates" property must be an array of 4 longitude/latitude array pairs'))) : this.fire(new i.ErrorEvent(new i.ValidationError("sources." + J, null, 'missing required property "coordinates"'))), q.animate && typeof q.animate != "boolean" && this.fire(new i.ErrorEvent(new i.ValidationError("sources." + J, null, 'optional "animate" property must be a boolean value'))), q.canvas ? typeof q.canvas != "string" && !(q.canvas instanceof i.window.HTMLCanvasElement) && this.fire(new i.ErrorEvent(new i.ValidationError("sources." + J, null, '"canvas" must be either a string representing the ID of the canvas element from which to read, or an HTMLCanvasElement instance'))) : this.fire(new i.ErrorEvent(new i.ValidationError("sources." + J, null, 'missing required property "canvas"'))), this.options = q, this.animate = q.animate !== void 0 ? q.animate : true;
+              }
+              return Y && (D.__proto__ = Y), D.prototype = Object.create(Y && Y.prototype), D.prototype.constructor = D, D.prototype.load = function() {
+                if (this._loaded = true, this.canvas || (this.canvas = this.options.canvas instanceof i.window.HTMLCanvasElement ? this.options.canvas : i.window.document.getElementById(this.options.canvas)), this.width = this.canvas.width, this.height = this.canvas.height, this._hasInvalidDimensions()) {
+                  this.fire(new i.ErrorEvent(new Error("Canvas dimensions cannot be less than or equal to zero.")));
+                  return;
+                }
+                this.play = function() {
+                  this._playing = true, this.map.triggerRepaint();
+                }, this.pause = function() {
+                  this._playing && (this.prepare(), this._playing = false);
+                }, this._finishLoading();
+              }, D.prototype.getCanvas = function() {
+                return this.canvas;
+              }, D.prototype.onAdd = function(q) {
+                this.map = q, this.load(), this.canvas && this.animate && this.play();
+              }, D.prototype.onRemove = function() {
+                this.pause();
+              }, D.prototype.prepare = function() {
+                var q = false;
+                if (this.canvas.width !== this.width && (this.width = this.canvas.width, q = true), this.canvas.height !== this.height && (this.height = this.canvas.height, q = true), !this._hasInvalidDimensions() && Object.keys(this.tiles).length !== 0) {
+                  var K = this.map.painter.context, de = K.gl;
+                  this.boundsBuffer || (this.boundsBuffer = K.createVertexBuffer(this._boundsArray, Ce.members)), this.boundsSegments || (this.boundsSegments = i.SegmentVector.simpleSegment(0, 0, 4, 2)), this.texture ? (q || this._playing) && this.texture.update(this.canvas, { premultiply: true }) : this.texture = new i.Texture(K, this.canvas, de.RGBA, { premultiply: true });
+                  for (var ne in this.tiles) {
+                    var we = this.tiles[ne];
+                    we.state !== "loaded" && (we.state = "loaded", we.texture = this.texture);
+                  }
+                }
+              }, D.prototype.serialize = function() {
+                return { type: "canvas", coordinates: this.coordinates };
+              }, D.prototype.hasTransition = function() {
+                return this._playing;
+              }, D.prototype._hasInvalidDimensions = function() {
+                for (var q = 0, K = [this.canvas.width, this.canvas.height]; q < K.length; q += 1) {
+                  var de = K[q];
+                  if (isNaN(de) || de <= 0) return true;
+                }
+                return false;
+              }, D;
+            }(Le), Ee = { vector: H, raster: re, "raster-dem": oe, geojson: _e, video: ie, image: Le, canvas: Se }, Ae = function(Y, D, J, q) {
+              var K = new Ee[D.type](Y, D, J, q);
+              if (K.id !== Y) throw new Error("Expected Source id to be " + Y + " instead of " + K.id);
+              return i.bindAll(["load", "abort", "unload", "serialize", "prepare"], K), K;
+            }, Be = function(Y) {
+              return Ee[Y];
+            }, Pe = function(Y, D) {
+              Ee[Y] = D;
+            };
+            function me(Y, D) {
+              var J = i.identity([]);
+              return i.translate(J, J, [1, 1, 0]), i.scale(J, J, [Y.width * 0.5, Y.height * 0.5, 1]), i.multiply(J, J, Y.calculatePosMatrix(D.toUnwrapped()));
+            }
+            function De(Y, D, J) {
+              if (Y) for (var q = 0, K = Y; q < K.length; q += 1) {
+                var de = K[q], ne = D[de];
+                if (ne && ne.source === J && ne.type === "fill-extrusion") return true;
+              }
+              else for (var we in D) {
+                var Ue = D[we];
+                if (Ue.source === J && Ue.type === "fill-extrusion") return true;
+              }
+              return false;
+            }
+            function ce(Y, D, J, q, K, de) {
+              var ne = De(K && K.layers, D, Y.id), we = de.maxPitchScaleFactor(), Ue = Y.tilesIn(q, we, ne);
+              Ue.sort(pt);
+              for (var ft = [], Zt = 0, hr = Ue; Zt < hr.length; Zt += 1) {
+                var qt = hr[Zt];
+                ft.push({ wrappedTileID: qt.tileID.wrapped().key, queryResults: qt.tile.queryRenderedFeatures(D, J, Y._state, qt.queryGeometry, qt.cameraQueryGeometry, qt.scale, K, de, we, me(Y.transform, qt.tileID)) });
+              }
+              var Ve = Vt(ft);
+              for (var Qe in Ve) Ve[Qe].forEach(function(at) {
+                var Ct = at.feature, Ot = Y.getFeatureState(Ct.layer["source-layer"], Ct.id);
+                Ct.source = Ct.layer.source, Ct.layer["source-layer"] && (Ct.sourceLayer = Ct.layer["source-layer"]), Ct.state = Ot;
+              });
+              return Ve;
+            }
+            function je(Y, D, J, q, K, de, ne) {
+              for (var we = {}, Ue = de.queryRenderedSymbols(q), ft = [], Zt = 0, hr = Object.keys(Ue).map(Number); Zt < hr.length; Zt += 1) {
+                var qt = hr[Zt];
+                ft.push(ne[qt]);
+              }
+              ft.sort(pt);
+              for (var Ve = function() {
+                var Rt = at[Qe], Bt = Rt.featureIndex.lookupSymbolFeatures(Ue[Rt.bucketInstanceId], D, Rt.bucketIndex, Rt.sourceLayerIndex, K.filter, K.layers, K.availableImages, Y);
+                for (var Dt in Bt) {
+                  var yt = we[Dt] = we[Dt] || [], Pt = Bt[Dt];
+                  Pt.sort(function(Ur, Di) {
+                    var fi = Rt.featureSortOrder;
+                    if (fi) {
+                      var Ti = fi.indexOf(Ur.featureIndex), gn = fi.indexOf(Di.featureIndex);
+                      return gn - Ti;
+                    } else return Di.featureIndex - Ur.featureIndex;
+                  });
+                  for (var ht = 0, ur = Pt; ht < ur.length; ht += 1) {
+                    var br = ur[ht];
+                    yt.push(br);
+                  }
+                }
+              }, Qe = 0, at = ft; Qe < at.length; Qe += 1) Ve();
+              var Ct = function(Rt) {
+                we[Rt].forEach(function(Bt) {
+                  var Dt = Bt.feature, yt = Y[Rt], Pt = J[yt.source], ht = Pt.getFeatureState(Dt.layer["source-layer"], Dt.id);
+                  Dt.source = Dt.layer.source, Dt.layer["source-layer"] && (Dt.sourceLayer = Dt.layer["source-layer"]), Dt.state = ht;
+                });
+              };
+              for (var Ot in we) Ct(Ot);
+              return we;
+            }
+            function lt(Y, D) {
+              for (var J = Y.getRenderableIds().map(function(Ue) {
+                return Y.getTileByID(Ue);
+              }), q = [], K = {}, de = 0; de < J.length; de++) {
+                var ne = J[de], we = ne.tileID.canonical.key;
+                K[we] || (K[we] = true, ne.querySourceFeatures(q, D));
+              }
+              return q;
+            }
+            function pt(Y, D) {
+              var J = Y.tileID, q = D.tileID;
+              return J.overscaledZ - q.overscaledZ || J.canonical.y - q.canonical.y || J.wrap - q.wrap || J.canonical.x - q.canonical.x;
+            }
+            function Vt(Y) {
+              for (var D = {}, J = {}, q = 0, K = Y; q < K.length; q += 1) {
+                var de = K[q], ne = de.queryResults, we = de.wrappedTileID, Ue = J[we] = J[we] || {};
+                for (var ft in ne) for (var Zt = ne[ft], hr = Ue[ft] = Ue[ft] || {}, qt = D[ft] = D[ft] || [], Ve = 0, Qe = Zt; Ve < Qe.length; Ve += 1) {
+                  var at = Qe[Ve];
+                  hr[at.featureIndex] || (hr[at.featureIndex] = true, qt.push(at));
+                }
+              }
+              return D;
+            }
+            var ot = function(D, J) {
+              this.max = D, this.onRemove = J, this.reset();
+            };
+            ot.prototype.reset = function() {
+              for (var D in this.data) for (var J = 0, q = this.data[D]; J < q.length; J += 1) {
+                var K = q[J];
+                K.timeout && clearTimeout(K.timeout), this.onRemove(K.value);
+              }
+              return this.data = {}, this.order = [], this;
+            }, ot.prototype.add = function(D, J, q) {
+              var K = this, de = D.wrapped().key;
+              this.data[de] === void 0 && (this.data[de] = []);
+              var ne = { value: J, timeout: void 0 };
+              if (q !== void 0 && (ne.timeout = setTimeout(function() {
+                K.remove(D, ne);
+              }, q)), this.data[de].push(ne), this.order.push(de), this.order.length > this.max) {
+                var we = this._getAndRemoveByKey(this.order[0]);
+                we && this.onRemove(we);
+              }
+              return this;
+            }, ot.prototype.has = function(D) {
+              return D.wrapped().key in this.data;
+            }, ot.prototype.getAndRemove = function(D) {
+              return this.has(D) ? this._getAndRemoveByKey(D.wrapped().key) : null;
+            }, ot.prototype._getAndRemoveByKey = function(D) {
+              var J = this.data[D].shift();
+              return J.timeout && clearTimeout(J.timeout), this.data[D].length === 0 && delete this.data[D], this.order.splice(this.order.indexOf(D), 1), J.value;
+            }, ot.prototype.getByKey = function(D) {
+              var J = this.data[D];
+              return J ? J[0].value : null;
+            }, ot.prototype.get = function(D) {
+              if (!this.has(D)) return null;
+              var J = this.data[D.wrapped().key][0];
+              return J.value;
+            }, ot.prototype.remove = function(D, J) {
+              if (!this.has(D)) return this;
+              var q = D.wrapped().key, K = J === void 0 ? 0 : this.data[q].indexOf(J), de = this.data[q][K];
+              return this.data[q].splice(K, 1), de.timeout && clearTimeout(de.timeout), this.data[q].length === 0 && delete this.data[q], this.onRemove(de.value), this.order.splice(this.order.indexOf(q), 1), this;
+            }, ot.prototype.setMaxSize = function(D) {
+              for (this.max = D; this.order.length > this.max; ) {
+                var J = this._getAndRemoveByKey(this.order[0]);
+                J && this.onRemove(J);
+              }
+              return this;
+            }, ot.prototype.filter = function(D) {
+              var J = [];
+              for (var q in this.data) for (var K = 0, de = this.data[q]; K < de.length; K += 1) {
+                var ne = de[K];
+                D(ne.value) || J.push(ne);
+              }
+              for (var we = 0, Ue = J; we < Ue.length; we += 1) {
+                var ft = Ue[we];
+                this.remove(ft.value.tileID, ft);
+              }
+            };
+            var ut = function(D, J, q) {
+              this.context = D;
+              var K = D.gl;
+              this.buffer = K.createBuffer(), this.dynamicDraw = !!q, this.context.unbindVAO(), D.bindElementBuffer.set(this.buffer), K.bufferData(K.ELEMENT_ARRAY_BUFFER, J.arrayBuffer, this.dynamicDraw ? K.DYNAMIC_DRAW : K.STATIC_DRAW), this.dynamicDraw || delete J.arrayBuffer;
+            };
+            ut.prototype.bind = function() {
+              this.context.bindElementBuffer.set(this.buffer);
+            }, ut.prototype.updateData = function(D) {
+              var J = this.context.gl;
+              this.context.unbindVAO(), this.bind(), J.bufferSubData(J.ELEMENT_ARRAY_BUFFER, 0, D.arrayBuffer);
+            }, ut.prototype.destroy = function() {
+              var D = this.context.gl;
+              this.buffer && (D.deleteBuffer(this.buffer), delete this.buffer);
+            };
+            var Wt = { Int8: "BYTE", Uint8: "UNSIGNED_BYTE", Int16: "SHORT", Uint16: "UNSIGNED_SHORT", Int32: "INT", Uint32: "UNSIGNED_INT", Float32: "FLOAT" }, Nt = function(D, J, q, K) {
+              this.length = J.length, this.attributes = q, this.itemSize = J.bytesPerElement, this.dynamicDraw = K, this.context = D;
+              var de = D.gl;
+              this.buffer = de.createBuffer(), D.bindVertexBuffer.set(this.buffer), de.bufferData(de.ARRAY_BUFFER, J.arrayBuffer, this.dynamicDraw ? de.DYNAMIC_DRAW : de.STATIC_DRAW), this.dynamicDraw || delete J.arrayBuffer;
+            };
+            Nt.prototype.bind = function() {
+              this.context.bindVertexBuffer.set(this.buffer);
+            }, Nt.prototype.updateData = function(D) {
+              var J = this.context.gl;
+              this.bind(), J.bufferSubData(J.ARRAY_BUFFER, 0, D.arrayBuffer);
+            }, Nt.prototype.enableAttributes = function(D, J) {
+              for (var q = 0; q < this.attributes.length; q++) {
+                var K = this.attributes[q], de = J.attributes[K.name];
+                de !== void 0 && D.enableVertexAttribArray(de);
+              }
+            }, Nt.prototype.setVertexAttribPointers = function(D, J, q) {
+              for (var K = 0; K < this.attributes.length; K++) {
+                var de = this.attributes[K], ne = J.attributes[de.name];
+                ne !== void 0 && D.vertexAttribPointer(ne, de.components, D[Wt[de.type]], false, this.itemSize, de.offset + this.itemSize * (q || 0));
+              }
+            }, Nt.prototype.destroy = function() {
+              var D = this.context.gl;
+              this.buffer && (D.deleteBuffer(this.buffer), delete this.buffer);
+            };
+            var $t = function(D) {
+              this.gl = D.gl, this.default = this.getDefault(), this.current = this.default, this.dirty = false;
+            };
+            $t.prototype.get = function() {
+              return this.current;
+            }, $t.prototype.set = function(D) {
+            }, $t.prototype.getDefault = function() {
+              return this.default;
+            }, $t.prototype.setDefault = function() {
+              this.set(this.default);
+            };
+            var sr = function(Y) {
+              function D() {
+                Y.apply(this, arguments);
+              }
+              return Y && (D.__proto__ = Y), D.prototype = Object.create(Y && Y.prototype), D.prototype.constructor = D, D.prototype.getDefault = function() {
+                return i.Color.transparent;
+              }, D.prototype.set = function(q) {
+                var K = this.current;
+                q.r === K.r && q.g === K.g && q.b === K.b && q.a === K.a && !this.dirty || (this.gl.clearColor(q.r, q.g, q.b, q.a), this.current = q, this.dirty = false);
+              }, D;
+            }($t), Tr = function(Y) {
+              function D() {
+                Y.apply(this, arguments);
+              }
+              return Y && (D.__proto__ = Y), D.prototype = Object.create(Y && Y.prototype), D.prototype.constructor = D, D.prototype.getDefault = function() {
+                return 1;
+              }, D.prototype.set = function(q) {
+                q === this.current && !this.dirty || (this.gl.clearDepth(q), this.current = q, this.dirty = false);
+              }, D;
+            }($t), fr = function(Y) {
+              function D() {
+                Y.apply(this, arguments);
+              }
+              return Y && (D.__proto__ = Y), D.prototype = Object.create(Y && Y.prototype), D.prototype.constructor = D, D.prototype.getDefault = function() {
+                return 0;
+              }, D.prototype.set = function(q) {
+                q === this.current && !this.dirty || (this.gl.clearStencil(q), this.current = q, this.dirty = false);
+              }, D;
+            }($t), $e = function(Y) {
+              function D() {
+                Y.apply(this, arguments);
+              }
+              return Y && (D.__proto__ = Y), D.prototype = Object.create(Y && Y.prototype), D.prototype.constructor = D, D.prototype.getDefault = function() {
+                return [true, true, true, true];
+              }, D.prototype.set = function(q) {
+                var K = this.current;
+                q[0] === K[0] && q[1] === K[1] && q[2] === K[2] && q[3] === K[3] && !this.dirty || (this.gl.colorMask(q[0], q[1], q[2], q[3]), this.current = q, this.dirty = false);
+              }, D;
+            }($t), St = function(Y) {
+              function D() {
+                Y.apply(this, arguments);
+              }
+              return Y && (D.__proto__ = Y), D.prototype = Object.create(Y && Y.prototype), D.prototype.constructor = D, D.prototype.getDefault = function() {
+                return true;
+              }, D.prototype.set = function(q) {
+                q === this.current && !this.dirty || (this.gl.depthMask(q), this.current = q, this.dirty = false);
+              }, D;
+            }($t), Qt = function(Y) {
+              function D() {
+                Y.apply(this, arguments);
+              }
+              return Y && (D.__proto__ = Y), D.prototype = Object.create(Y && Y.prototype), D.prototype.constructor = D, D.prototype.getDefault = function() {
+                return 255;
+              }, D.prototype.set = function(q) {
+                q === this.current && !this.dirty || (this.gl.stencilMask(q), this.current = q, this.dirty = false);
+              }, D;
+            }($t), Gt = function(Y) {
+              function D() {
+                Y.apply(this, arguments);
+              }
+              return Y && (D.__proto__ = Y), D.prototype = Object.create(Y && Y.prototype), D.prototype.constructor = D, D.prototype.getDefault = function() {
+                return { func: this.gl.ALWAYS, ref: 0, mask: 255 };
+              }, D.prototype.set = function(q) {
+                var K = this.current;
+                q.func === K.func && q.ref === K.ref && q.mask === K.mask && !this.dirty || (this.gl.stencilFunc(q.func, q.ref, q.mask), this.current = q, this.dirty = false);
+              }, D;
+            }($t), _t = function(Y) {
+              function D() {
+                Y.apply(this, arguments);
+              }
+              return Y && (D.__proto__ = Y), D.prototype = Object.create(Y && Y.prototype), D.prototype.constructor = D, D.prototype.getDefault = function() {
+                var q = this.gl;
+                return [q.KEEP, q.KEEP, q.KEEP];
+              }, D.prototype.set = function(q) {
+                var K = this.current;
+                q[0] === K[0] && q[1] === K[1] && q[2] === K[2] && !this.dirty || (this.gl.stencilOp(q[0], q[1], q[2]), this.current = q, this.dirty = false);
+              }, D;
+            }($t), It = function(Y) {
+              function D() {
+                Y.apply(this, arguments);
+              }
+              return Y && (D.__proto__ = Y), D.prototype = Object.create(Y && Y.prototype), D.prototype.constructor = D, D.prototype.getDefault = function() {
+                return false;
+              }, D.prototype.set = function(q) {
+                if (!(q === this.current && !this.dirty)) {
+                  var K = this.gl;
+                  q ? K.enable(K.STENCIL_TEST) : K.disable(K.STENCIL_TEST), this.current = q, this.dirty = false;
+                }
+              }, D;
+            }($t), mt = function(Y) {
+              function D() {
+                Y.apply(this, arguments);
+              }
+              return Y && (D.__proto__ = Y), D.prototype = Object.create(Y && Y.prototype), D.prototype.constructor = D, D.prototype.getDefault = function() {
+                return [0, 1];
+              }, D.prototype.set = function(q) {
+                var K = this.current;
+                q[0] === K[0] && q[1] === K[1] && !this.dirty || (this.gl.depthRange(q[0], q[1]), this.current = q, this.dirty = false);
+              }, D;
+            }($t), er = function(Y) {
+              function D() {
+                Y.apply(this, arguments);
+              }
+              return Y && (D.__proto__ = Y), D.prototype = Object.create(Y && Y.prototype), D.prototype.constructor = D, D.prototype.getDefault = function() {
+                return false;
+              }, D.prototype.set = function(q) {
+                if (!(q === this.current && !this.dirty)) {
+                  var K = this.gl;
+                  q ? K.enable(K.DEPTH_TEST) : K.disable(K.DEPTH_TEST), this.current = q, this.dirty = false;
+                }
+              }, D;
+            }($t), lr = function(Y) {
+              function D() {
+                Y.apply(this, arguments);
+              }
+              return Y && (D.__proto__ = Y), D.prototype = Object.create(Y && Y.prototype), D.prototype.constructor = D, D.prototype.getDefault = function() {
+                return this.gl.LESS;
+              }, D.prototype.set = function(q) {
+                q === this.current && !this.dirty || (this.gl.depthFunc(q), this.current = q, this.dirty = false);
+              }, D;
+            }($t), wr = function(Y) {
+              function D() {
+                Y.apply(this, arguments);
+              }
+              return Y && (D.__proto__ = Y), D.prototype = Object.create(Y && Y.prototype), D.prototype.constructor = D, D.prototype.getDefault = function() {
+                return false;
+              }, D.prototype.set = function(q) {
+                if (!(q === this.current && !this.dirty)) {
+                  var K = this.gl;
+                  q ? K.enable(K.BLEND) : K.disable(K.BLEND), this.current = q, this.dirty = false;
+                }
+              }, D;
+            }($t), Lr = function(Y) {
+              function D() {
+                Y.apply(this, arguments);
+              }
+              return Y && (D.__proto__ = Y), D.prototype = Object.create(Y && Y.prototype), D.prototype.constructor = D, D.prototype.getDefault = function() {
+                var q = this.gl;
+                return [q.ONE, q.ZERO];
+              }, D.prototype.set = function(q) {
+                var K = this.current;
+                q[0] === K[0] && q[1] === K[1] && !this.dirty || (this.gl.blendFunc(q[0], q[1]), this.current = q, this.dirty = false);
+              }, D;
+            }($t), ti = function(Y) {
+              function D() {
+                Y.apply(this, arguments);
+              }
+              return Y && (D.__proto__ = Y), D.prototype = Object.create(Y && Y.prototype), D.prototype.constructor = D, D.prototype.getDefault = function() {
+                return i.Color.transparent;
+              }, D.prototype.set = function(q) {
+                var K = this.current;
+                q.r === K.r && q.g === K.g && q.b === K.b && q.a === K.a && !this.dirty || (this.gl.blendColor(q.r, q.g, q.b, q.a), this.current = q, this.dirty = false);
+              }, D;
+            }($t), Br = function(Y) {
+              function D() {
+                Y.apply(this, arguments);
+              }
+              return Y && (D.__proto__ = Y), D.prototype = Object.create(Y && Y.prototype), D.prototype.constructor = D, D.prototype.getDefault = function() {
+                return this.gl.FUNC_ADD;
+              }, D.prototype.set = function(q) {
+                q === this.current && !this.dirty || (this.gl.blendEquation(q), this.current = q, this.dirty = false);
+              }, D;
+            }($t), Vr = function(Y) {
+              function D() {
+                Y.apply(this, arguments);
+              }
+              return Y && (D.__proto__ = Y), D.prototype = Object.create(Y && Y.prototype), D.prototype.constructor = D, D.prototype.getDefault = function() {
+                return false;
+              }, D.prototype.set = function(q) {
+                if (!(q === this.current && !this.dirty)) {
+                  var K = this.gl;
+                  q ? K.enable(K.CULL_FACE) : K.disable(K.CULL_FACE), this.current = q, this.dirty = false;
+                }
+              }, D;
+            }($t), dt = function(Y) {
+              function D() {
+                Y.apply(this, arguments);
+              }
+              return Y && (D.__proto__ = Y), D.prototype = Object.create(Y && Y.prototype), D.prototype.constructor = D, D.prototype.getDefault = function() {
+                return this.gl.BACK;
+              }, D.prototype.set = function(q) {
+                q === this.current && !this.dirty || (this.gl.cullFace(q), this.current = q, this.dirty = false);
+              }, D;
+            }($t), Ge = function(Y) {
+              function D() {
+                Y.apply(this, arguments);
+              }
+              return Y && (D.__proto__ = Y), D.prototype = Object.create(Y && Y.prototype), D.prototype.constructor = D, D.prototype.getDefault = function() {
+                return this.gl.CCW;
+              }, D.prototype.set = function(q) {
+                q === this.current && !this.dirty || (this.gl.frontFace(q), this.current = q, this.dirty = false);
+              }, D;
+            }($t), Je = function(Y) {
+              function D() {
+                Y.apply(this, arguments);
+              }
+              return Y && (D.__proto__ = Y), D.prototype = Object.create(Y && Y.prototype), D.prototype.constructor = D, D.prototype.getDefault = function() {
+                return null;
+              }, D.prototype.set = function(q) {
+                q === this.current && !this.dirty || (this.gl.useProgram(q), this.current = q, this.dirty = false);
+              }, D;
+            }($t), We = function(Y) {
+              function D() {
+                Y.apply(this, arguments);
+              }
+              return Y && (D.__proto__ = Y), D.prototype = Object.create(Y && Y.prototype), D.prototype.constructor = D, D.prototype.getDefault = function() {
+                return this.gl.TEXTURE0;
+              }, D.prototype.set = function(q) {
+                q === this.current && !this.dirty || (this.gl.activeTexture(q), this.current = q, this.dirty = false);
+              }, D;
+            }($t), tt = function(Y) {
+              function D() {
+                Y.apply(this, arguments);
+              }
+              return Y && (D.__proto__ = Y), D.prototype = Object.create(Y && Y.prototype), D.prototype.constructor = D, D.prototype.getDefault = function() {
+                var q = this.gl;
+                return [0, 0, q.drawingBufferWidth, q.drawingBufferHeight];
+              }, D.prototype.set = function(q) {
+                var K = this.current;
+                q[0] === K[0] && q[1] === K[1] && q[2] === K[2] && q[3] === K[3] && !this.dirty || (this.gl.viewport(q[0], q[1], q[2], q[3]), this.current = q, this.dirty = false);
+              }, D;
+            }($t), xt = function(Y) {
+              function D() {
+                Y.apply(this, arguments);
+              }
+              return Y && (D.__proto__ = Y), D.prototype = Object.create(Y && Y.prototype), D.prototype.constructor = D, D.prototype.getDefault = function() {
+                return null;
+              }, D.prototype.set = function(q) {
+                if (!(q === this.current && !this.dirty)) {
+                  var K = this.gl;
+                  K.bindFramebuffer(K.FRAMEBUFFER, q), this.current = q, this.dirty = false;
+                }
+              }, D;
+            }($t), Ie = function(Y) {
+              function D() {
+                Y.apply(this, arguments);
+              }
+              return Y && (D.__proto__ = Y), D.prototype = Object.create(Y && Y.prototype), D.prototype.constructor = D, D.prototype.getDefault = function() {
+                return null;
+              }, D.prototype.set = function(q) {
+                if (!(q === this.current && !this.dirty)) {
+                  var K = this.gl;
+                  K.bindRenderbuffer(K.RENDERBUFFER, q), this.current = q, this.dirty = false;
+                }
+              }, D;
+            }($t), xe = function(Y) {
+              function D() {
+                Y.apply(this, arguments);
+              }
+              return Y && (D.__proto__ = Y), D.prototype = Object.create(Y && Y.prototype), D.prototype.constructor = D, D.prototype.getDefault = function() {
+                return null;
+              }, D.prototype.set = function(q) {
+                if (!(q === this.current && !this.dirty)) {
+                  var K = this.gl;
+                  K.bindTexture(K.TEXTURE_2D, q), this.current = q, this.dirty = false;
+                }
+              }, D;
+            }($t), ke = function(Y) {
+              function D() {
+                Y.apply(this, arguments);
+              }
+              return Y && (D.__proto__ = Y), D.prototype = Object.create(Y && Y.prototype), D.prototype.constructor = D, D.prototype.getDefault = function() {
+                return null;
+              }, D.prototype.set = function(q) {
+                if (!(q === this.current && !this.dirty)) {
+                  var K = this.gl;
+                  K.bindBuffer(K.ARRAY_BUFFER, q), this.current = q, this.dirty = false;
+                }
+              }, D;
+            }($t), vt = function(Y) {
+              function D() {
+                Y.apply(this, arguments);
+              }
+              return Y && (D.__proto__ = Y), D.prototype = Object.create(Y && Y.prototype), D.prototype.constructor = D, D.prototype.getDefault = function() {
+                return null;
+              }, D.prototype.set = function(q) {
+                var K = this.gl;
+                K.bindBuffer(K.ELEMENT_ARRAY_BUFFER, q), this.current = q, this.dirty = false;
+              }, D;
+            }($t), ir = function(Y) {
+              function D(J) {
+                Y.call(this, J), this.vao = J.extVertexArrayObject;
+              }
+              return Y && (D.__proto__ = Y), D.prototype = Object.create(Y && Y.prototype), D.prototype.constructor = D, D.prototype.getDefault = function() {
+                return null;
+              }, D.prototype.set = function(q) {
+                !this.vao || q === this.current && !this.dirty || (this.vao.bindVertexArrayOES(q), this.current = q, this.dirty = false);
+              }, D;
+            }($t), ar = function(Y) {
+              function D() {
+                Y.apply(this, arguments);
+              }
+              return Y && (D.__proto__ = Y), D.prototype = Object.create(Y && Y.prototype), D.prototype.constructor = D, D.prototype.getDefault = function() {
+                return 4;
+              }, D.prototype.set = function(q) {
+                if (!(q === this.current && !this.dirty)) {
+                  var K = this.gl;
+                  K.pixelStorei(K.UNPACK_ALIGNMENT, q), this.current = q, this.dirty = false;
+                }
+              }, D;
+            }($t), vr = function(Y) {
+              function D() {
+                Y.apply(this, arguments);
+              }
+              return Y && (D.__proto__ = Y), D.prototype = Object.create(Y && Y.prototype), D.prototype.constructor = D, D.prototype.getDefault = function() {
+                return false;
+              }, D.prototype.set = function(q) {
+                if (!(q === this.current && !this.dirty)) {
+                  var K = this.gl;
+                  K.pixelStorei(K.UNPACK_PREMULTIPLY_ALPHA_WEBGL, q), this.current = q, this.dirty = false;
+                }
+              }, D;
+            }($t), ii = function(Y) {
+              function D() {
+                Y.apply(this, arguments);
+              }
+              return Y && (D.__proto__ = Y), D.prototype = Object.create(Y && Y.prototype), D.prototype.constructor = D, D.prototype.getDefault = function() {
+                return false;
+              }, D.prototype.set = function(q) {
+                if (!(q === this.current && !this.dirty)) {
+                  var K = this.gl;
+                  K.pixelStorei(K.UNPACK_FLIP_Y_WEBGL, q), this.current = q, this.dirty = false;
+                }
+              }, D;
+            }($t), pi = function(Y) {
+              function D(J, q) {
+                Y.call(this, J), this.context = J, this.parent = q;
+              }
+              return Y && (D.__proto__ = Y), D.prototype = Object.create(Y && Y.prototype), D.prototype.constructor = D, D.prototype.getDefault = function() {
+                return null;
+              }, D;
+            }($t), $r = function(Y) {
+              function D() {
+                Y.apply(this, arguments);
+              }
+              return Y && (D.__proto__ = Y), D.prototype = Object.create(Y && Y.prototype), D.prototype.constructor = D, D.prototype.setDirty = function() {
+                this.dirty = true;
+              }, D.prototype.set = function(q) {
+                if (!(q === this.current && !this.dirty)) {
+                  this.context.bindFramebuffer.set(this.parent);
+                  var K = this.gl;
+                  K.framebufferTexture2D(K.FRAMEBUFFER, K.COLOR_ATTACHMENT0, K.TEXTURE_2D, q, 0), this.current = q, this.dirty = false;
+                }
+              }, D;
+            }(pi), di = function(Y) {
+              function D() {
+                Y.apply(this, arguments);
+              }
+              return Y && (D.__proto__ = Y), D.prototype = Object.create(Y && Y.prototype), D.prototype.constructor = D, D.prototype.set = function(q) {
+                if (!(q === this.current && !this.dirty)) {
+                  this.context.bindFramebuffer.set(this.parent);
+                  var K = this.gl;
+                  K.framebufferRenderbuffer(K.FRAMEBUFFER, K.DEPTH_ATTACHMENT, K.RENDERBUFFER, q), this.current = q, this.dirty = false;
+                }
+              }, D;
+            }(pi), ji = function(D, J, q, K) {
+              this.context = D, this.width = J, this.height = q;
+              var de = D.gl, ne = this.framebuffer = de.createFramebuffer();
+              this.colorAttachment = new $r(D, ne), K && (this.depthAttachment = new di(D, ne));
+            };
+            ji.prototype.destroy = function() {
+              var D = this.context.gl, J = this.colorAttachment.get();
+              if (J && D.deleteTexture(J), this.depthAttachment) {
+                var q = this.depthAttachment.get();
+                q && D.deleteRenderbuffer(q);
+              }
+              D.deleteFramebuffer(this.framebuffer);
+            };
+            var In = 519, wi = function(D, J, q) {
+              this.func = D, this.mask = J, this.range = q;
+            };
+            wi.ReadOnly = false, wi.ReadWrite = true, wi.disabled = new wi(In, wi.ReadOnly, [0, 1]);
+            var On = 519, qn = 7680, Fn = function(D, J, q, K, de, ne) {
+              this.test = D, this.ref = J, this.mask = q, this.fail = K, this.depthFail = de, this.pass = ne;
+            };
+            Fn.disabled = new Fn({ func: On, mask: 0 }, 0, 0, qn, qn, qn);
+            var ra = 0, la = 1, Ut = 771, wt = function(D, J, q) {
+              this.blendFunction = D, this.blendColor = J, this.mask = q;
+            };
+            wt.Replace = [la, ra], wt.disabled = new wt(wt.Replace, i.Color.transparent, [false, false, false, false]), wt.unblended = new wt(wt.Replace, i.Color.transparent, [true, true, true, true]), wt.alphaBlended = new wt([la, Ut], i.Color.transparent, [true, true, true, true]);
+            var rr = 1029, nr = 2305, Er = function(D, J, q) {
+              this.enable = D, this.mode = J, this.frontFace = q;
+            };
+            Er.disabled = new Er(false, rr, nr), Er.backCCW = new Er(true, rr, nr);
+            var Xr = function(D) {
+              this.gl = D, this.extVertexArrayObject = this.gl.getExtension("OES_vertex_array_object"), this.clearColor = new sr(this), this.clearDepth = new Tr(this), this.clearStencil = new fr(this), this.colorMask = new $e(this), this.depthMask = new St(this), this.stencilMask = new Qt(this), this.stencilFunc = new Gt(this), this.stencilOp = new _t(this), this.stencilTest = new It(this), this.depthRange = new mt(this), this.depthTest = new er(this), this.depthFunc = new lr(this), this.blend = new wr(this), this.blendFunc = new Lr(this), this.blendColor = new ti(this), this.blendEquation = new Br(this), this.cullFace = new Vr(this), this.cullFaceSide = new dt(this), this.frontFace = new Ge(this), this.program = new Je(this), this.activeTexture = new We(this), this.viewport = new tt(this), this.bindFramebuffer = new xt(this), this.bindRenderbuffer = new Ie(this), this.bindTexture = new xe(this), this.bindVertexBuffer = new ke(this), this.bindElementBuffer = new vt(this), this.bindVertexArrayOES = this.extVertexArrayObject && new ir(this), this.pixelStoreUnpack = new ar(this), this.pixelStoreUnpackPremultiplyAlpha = new vr(this), this.pixelStoreUnpackFlipY = new ii(this), this.extTextureFilterAnisotropic = D.getExtension("EXT_texture_filter_anisotropic") || D.getExtension("MOZ_EXT_texture_filter_anisotropic") || D.getExtension("WEBKIT_EXT_texture_filter_anisotropic"), this.extTextureFilterAnisotropic && (this.extTextureFilterAnisotropicMax = D.getParameter(this.extTextureFilterAnisotropic.MAX_TEXTURE_MAX_ANISOTROPY_EXT)), this.extTextureHalfFloat = D.getExtension("OES_texture_half_float"), this.extTextureHalfFloat && (D.getExtension("OES_texture_half_float_linear"), this.extRenderToTextureHalfFloat = D.getExtension("EXT_color_buffer_half_float")), this.extTimerQuery = D.getExtension("EXT_disjoint_timer_query"), this.maxTextureSize = D.getParameter(D.MAX_TEXTURE_SIZE);
+            };
+            Xr.prototype.setDefault = function() {
+              this.unbindVAO(), this.clearColor.setDefault(), this.clearDepth.setDefault(), this.clearStencil.setDefault(), this.colorMask.setDefault(), this.depthMask.setDefault(), this.stencilMask.setDefault(), this.stencilFunc.setDefault(), this.stencilOp.setDefault(), this.stencilTest.setDefault(), this.depthRange.setDefault(), this.depthTest.setDefault(), this.depthFunc.setDefault(), this.blend.setDefault(), this.blendFunc.setDefault(), this.blendColor.setDefault(), this.blendEquation.setDefault(), this.cullFace.setDefault(), this.cullFaceSide.setDefault(), this.frontFace.setDefault(), this.program.setDefault(), this.activeTexture.setDefault(), this.bindFramebuffer.setDefault(), this.pixelStoreUnpack.setDefault(), this.pixelStoreUnpackPremultiplyAlpha.setDefault(), this.pixelStoreUnpackFlipY.setDefault();
+            }, Xr.prototype.setDirty = function() {
+              this.clearColor.dirty = true, this.clearDepth.dirty = true, this.clearStencil.dirty = true, this.colorMask.dirty = true, this.depthMask.dirty = true, this.stencilMask.dirty = true, this.stencilFunc.dirty = true, this.stencilOp.dirty = true, this.stencilTest.dirty = true, this.depthRange.dirty = true, this.depthTest.dirty = true, this.depthFunc.dirty = true, this.blend.dirty = true, this.blendFunc.dirty = true, this.blendColor.dirty = true, this.blendEquation.dirty = true, this.cullFace.dirty = true, this.cullFaceSide.dirty = true, this.frontFace.dirty = true, this.program.dirty = true, this.activeTexture.dirty = true, this.viewport.dirty = true, this.bindFramebuffer.dirty = true, this.bindRenderbuffer.dirty = true, this.bindTexture.dirty = true, this.bindVertexBuffer.dirty = true, this.bindElementBuffer.dirty = true, this.extVertexArrayObject && (this.bindVertexArrayOES.dirty = true), this.pixelStoreUnpack.dirty = true, this.pixelStoreUnpackPremultiplyAlpha.dirty = true, this.pixelStoreUnpackFlipY.dirty = true;
+            }, Xr.prototype.createIndexBuffer = function(D, J) {
+              return new ut(this, D, J);
+            }, Xr.prototype.createVertexBuffer = function(D, J, q) {
+              return new Nt(this, D, J, q);
+            }, Xr.prototype.createRenderbuffer = function(D, J, q) {
+              var K = this.gl, de = K.createRenderbuffer();
+              return this.bindRenderbuffer.set(de), K.renderbufferStorage(K.RENDERBUFFER, D, J, q), this.bindRenderbuffer.set(null), de;
+            }, Xr.prototype.createFramebuffer = function(D, J, q) {
+              return new ji(this, D, J, q);
+            }, Xr.prototype.clear = function(D) {
+              var J = D.color, q = D.depth, K = this.gl, de = 0;
+              J && (de |= K.COLOR_BUFFER_BIT, this.clearColor.set(J), this.colorMask.set([true, true, true, true])), typeof q != "undefined" && (de |= K.DEPTH_BUFFER_BIT, this.depthRange.set([0, 1]), this.clearDepth.set(q), this.depthMask.set(true)), K.clear(de);
+            }, Xr.prototype.setCullFace = function(D) {
+              D.enable === false ? this.cullFace.set(false) : (this.cullFace.set(true), this.cullFaceSide.set(D.mode), this.frontFace.set(D.frontFace));
+            }, Xr.prototype.setDepthMode = function(D) {
+              D.func === this.gl.ALWAYS && !D.mask ? this.depthTest.set(false) : (this.depthTest.set(true), this.depthFunc.set(D.func), this.depthMask.set(D.mask), this.depthRange.set(D.range));
+            }, Xr.prototype.setStencilMode = function(D) {
+              D.test.func === this.gl.ALWAYS && !D.mask ? this.stencilTest.set(false) : (this.stencilTest.set(true), this.stencilMask.set(D.mask), this.stencilOp.set([D.fail, D.depthFail, D.pass]), this.stencilFunc.set({ func: D.test.func, ref: D.ref, mask: D.test.mask }));
+            }, Xr.prototype.setColorMode = function(D) {
+              i.deepEqual(D.blendFunction, wt.Replace) ? this.blend.set(false) : (this.blend.set(true), this.blendFunc.set(D.blendFunction), this.blendColor.set(D.blendColor)), this.colorMask.set(D.mask);
+            }, Xr.prototype.unbindVAO = function() {
+              this.extVertexArrayObject && this.bindVertexArrayOES.set(null);
+            };
+            var ri = function(Y) {
+              function D(J, q, K) {
+                var de = this;
+                Y.call(this), this.id = J, this.dispatcher = K, this.on("data", function(ne) {
+                  ne.dataType === "source" && ne.sourceDataType === "metadata" && (de._sourceLoaded = true), de._sourceLoaded && !de._paused && ne.dataType === "source" && ne.sourceDataType === "content" && (de.reload(), de.transform && de.update(de.transform));
+                }), this.on("error", function() {
+                  de._sourceErrored = true;
+                }), this._source = Ae(J, q, K, this), this._tiles = {}, this._cache = new ot(0, this._unloadTile.bind(this)), this._timers = {}, this._cacheTimers = {}, this._maxTileCacheSize = null, this._loadedParentTiles = {}, this._coveredTiles = {}, this._state = new i.SourceFeatureState();
+              }
+              return Y && (D.__proto__ = Y), D.prototype = Object.create(Y && Y.prototype), D.prototype.constructor = D, D.prototype.onAdd = function(q) {
+                this.map = q, this._maxTileCacheSize = q ? q._maxTileCacheSize : null, this._source && this._source.onAdd && this._source.onAdd(q);
+              }, D.prototype.onRemove = function(q) {
+                this._source && this._source.onRemove && this._source.onRemove(q);
+              }, D.prototype.loaded = function() {
+                if (this._sourceErrored) return true;
+                if (!this._sourceLoaded || !this._source.loaded()) return false;
+                for (var q in this._tiles) {
+                  var K = this._tiles[q];
+                  if (K.state !== "loaded" && K.state !== "errored") return false;
+                }
+                return true;
+              }, D.prototype.getSource = function() {
+                return this._source;
+              }, D.prototype.pause = function() {
+                this._paused = true;
+              }, D.prototype.resume = function() {
+                if (this._paused) {
+                  var q = this._shouldReloadOnResume;
+                  this._paused = false, this._shouldReloadOnResume = false, q && this.reload(), this.transform && this.update(this.transform);
+                }
+              }, D.prototype._loadTile = function(q, K) {
+                return this._source.loadTile(q, K);
+              }, D.prototype._unloadTile = function(q) {
+                if (this._source.unloadTile) return this._source.unloadTile(q, function() {
+                });
+              }, D.prototype._abortTile = function(q) {
+                if (this._source.abortTile) return this._source.abortTile(q, function() {
+                });
+              }, D.prototype.serialize = function() {
+                return this._source.serialize();
+              }, D.prototype.prepare = function(q) {
+                this._source.prepare && this._source.prepare(), this._state.coalesceChanges(this._tiles, this.map ? this.map.painter : null);
+                for (var K in this._tiles) {
+                  var de = this._tiles[K];
+                  de.upload(q), de.prepare(this.map.style.imageManager);
+                }
+              }, D.prototype.getIds = function() {
+                return i.values(this._tiles).map(function(q) {
+                  return q.tileID;
+                }).sort(Qr).map(function(q) {
+                  return q.key;
+                });
+              }, D.prototype.getRenderableIds = function(q) {
+                var K = this, de = [];
+                for (var ne in this._tiles) this._isIdRenderable(ne, q) && de.push(this._tiles[ne]);
+                return q ? de.sort(function(we, Ue) {
+                  var ft = we.tileID, Zt = Ue.tileID, hr = new i.Point(ft.canonical.x, ft.canonical.y)._rotate(K.transform.angle), qt = new i.Point(Zt.canonical.x, Zt.canonical.y)._rotate(K.transform.angle);
+                  return ft.overscaledZ - Zt.overscaledZ || qt.y - hr.y || qt.x - hr.x;
+                }).map(function(we) {
+                  return we.tileID.key;
+                }) : de.map(function(we) {
+                  return we.tileID;
+                }).sort(Qr).map(function(we) {
+                  return we.key;
+                });
+              }, D.prototype.hasRenderableParent = function(q) {
+                var K = this.findLoadedParent(q, 0);
+                return K ? this._isIdRenderable(K.tileID.key) : false;
+              }, D.prototype._isIdRenderable = function(q, K) {
+                return this._tiles[q] && this._tiles[q].hasData() && !this._coveredTiles[q] && (K || !this._tiles[q].holdingForFade());
+              }, D.prototype.reload = function() {
+                if (this._paused) {
+                  this._shouldReloadOnResume = true;
+                  return;
+                }
+                this._cache.reset();
+                for (var q in this._tiles) this._tiles[q].state !== "errored" && this._reloadTile(q, "reloading");
+              }, D.prototype._reloadTile = function(q, K) {
+                var de = this._tiles[q];
+                de && (de.state !== "loading" && (de.state = K), this._loadTile(de, this._tileLoaded.bind(this, de, q, K)));
+              }, D.prototype._tileLoaded = function(q, K, de, ne) {
+                if (ne) {
+                  q.state = "errored", ne.status !== 404 ? this._source.fire(new i.ErrorEvent(ne, { tile: q })) : this.update(this.transform);
+                  return;
+                }
+                q.timeAdded = i.browser.now(), de === "expired" && (q.refreshedUponExpiration = true), this._setTileReloadTimer(K, q), this.getSource().type === "raster-dem" && q.dem && this._backfillDEM(q), this._state.initializeTileState(q, this.map ? this.map.painter : null), this._source.fire(new i.Event("data", { dataType: "source", tile: q, coord: q.tileID }));
+              }, D.prototype._backfillDEM = function(q) {
+                for (var K = this.getRenderableIds(), de = 0; de < K.length; de++) {
+                  var ne = K[de];
+                  if (q.neighboringTiles && q.neighboringTiles[ne]) {
+                    var we = this.getTileByID(ne);
+                    Ue(q, we), Ue(we, q);
+                  }
+                }
+                function Ue(ft, Zt) {
+                  ft.needsHillshadePrepare = true;
+                  var hr = Zt.tileID.canonical.x - ft.tileID.canonical.x, qt = Zt.tileID.canonical.y - ft.tileID.canonical.y, Ve = Math.pow(2, ft.tileID.canonical.z), Qe = Zt.tileID.key;
+                  hr === 0 && qt === 0 || Math.abs(qt) > 1 || (Math.abs(hr) > 1 && (Math.abs(hr + Ve) === 1 ? hr += Ve : Math.abs(hr - Ve) === 1 && (hr -= Ve)), !(!Zt.dem || !ft.dem) && (ft.dem.backfillBorder(Zt.dem, hr, qt), ft.neighboringTiles && ft.neighboringTiles[Qe] && (ft.neighboringTiles[Qe].backfilled = true)));
+                }
+              }, D.prototype.getTile = function(q) {
+                return this.getTileByID(q.key);
+              }, D.prototype.getTileByID = function(q) {
+                return this._tiles[q];
+              }, D.prototype._retainLoadedChildren = function(q, K, de, ne) {
+                for (var we in this._tiles) {
+                  var Ue = this._tiles[we];
+                  if (!(ne[we] || !Ue.hasData() || Ue.tileID.overscaledZ <= K || Ue.tileID.overscaledZ > de)) {
+                    for (var ft = Ue.tileID; Ue && Ue.tileID.overscaledZ > K + 1; ) {
+                      var Zt = Ue.tileID.scaledTo(Ue.tileID.overscaledZ - 1);
+                      Ue = this._tiles[Zt.key], Ue && Ue.hasData() && (ft = Zt);
+                    }
+                    for (var hr = ft; hr.overscaledZ > K; ) if (hr = hr.scaledTo(hr.overscaledZ - 1), q[hr.key]) {
+                      ne[ft.key] = ft;
+                      break;
+                    }
+                  }
+                }
+              }, D.prototype.findLoadedParent = function(q, K) {
+                if (q.key in this._loadedParentTiles) {
+                  var de = this._loadedParentTiles[q.key];
+                  return de && de.tileID.overscaledZ >= K ? de : null;
+                }
+                for (var ne = q.overscaledZ - 1; ne >= K; ne--) {
+                  var we = q.scaledTo(ne), Ue = this._getLoadedTile(we);
+                  if (Ue) return Ue;
+                }
+              }, D.prototype._getLoadedTile = function(q) {
+                var K = this._tiles[q.key];
+                if (K && K.hasData()) return K;
+                var de = this._cache.getByKey(q.wrapped().key);
+                return de;
+              }, D.prototype.updateCacheSize = function(q) {
+                var K = Math.ceil(q.width / this._source.tileSize) + 1, de = Math.ceil(q.height / this._source.tileSize) + 1, ne = K * de, we = 5, Ue = Math.floor(ne * we), ft = typeof this._maxTileCacheSize == "number" ? Math.min(this._maxTileCacheSize, Ue) : Ue;
+                this._cache.setMaxSize(ft);
+              }, D.prototype.handleWrapJump = function(q) {
+                var K = this._prevLng === void 0 ? q : this._prevLng, de = q - K, ne = de / 360, we = Math.round(ne);
+                if (this._prevLng = q, we) {
+                  var Ue = {};
+                  for (var ft in this._tiles) {
+                    var Zt = this._tiles[ft];
+                    Zt.tileID = Zt.tileID.unwrapTo(Zt.tileID.wrap + we), Ue[Zt.tileID.key] = Zt;
+                  }
+                  this._tiles = Ue;
+                  for (var hr in this._timers) clearTimeout(this._timers[hr]), delete this._timers[hr];
+                  for (var qt in this._tiles) {
+                    var Ve = this._tiles[qt];
+                    this._setTileReloadTimer(qt, Ve);
+                  }
+                }
+              }, D.prototype.update = function(q) {
+                var K = this;
+                if (this.transform = q, !(!this._sourceLoaded || this._paused)) {
+                  this.updateCacheSize(q), this.handleWrapJump(this.transform.center.lng), this._coveredTiles = {};
+                  var de;
+                  this.used ? this._source.tileID ? de = q.getVisibleUnwrappedCoordinates(this._source.tileID).map(function(Ur) {
+                    return new i.OverscaledTileID(Ur.canonical.z, Ur.wrap, Ur.canonical.z, Ur.canonical.x, Ur.canonical.y);
+                  }) : (de = q.coveringTiles({ tileSize: this._source.tileSize, minzoom: this._source.minzoom, maxzoom: this._source.maxzoom, roundZoom: this._source.roundZoom, reparseOverscaled: this._source.reparseOverscaled }), this._source.hasTile && (de = de.filter(function(Ur) {
+                    return K._source.hasTile(Ur);
+                  }))) : de = [];
+                  var ne = q.coveringZoomLevel(this._source), we = Math.max(ne - D.maxOverzooming, this._source.minzoom), Ue = Math.max(ne + D.maxUnderzooming, this._source.minzoom), ft = this._updateRetainedTiles(de, ne);
+                  if (Oi(this._source.type)) {
+                    for (var Zt = {}, hr = {}, qt = Object.keys(ft), Ve = 0, Qe = qt; Ve < Qe.length; Ve += 1) {
+                      var at = Qe[Ve], Ct = ft[at], Ot = this._tiles[at];
+                      if (!(!Ot || Ot.fadeEndTime && Ot.fadeEndTime <= i.browser.now())) {
+                        var Rt = this.findLoadedParent(Ct, we);
+                        Rt && (this._addTile(Rt.tileID), Zt[Rt.tileID.key] = Rt.tileID), hr[at] = Ct;
+                      }
+                    }
+                    this._retainLoadedChildren(hr, ne, Ue, ft);
+                    for (var Bt in Zt) ft[Bt] || (this._coveredTiles[Bt] = true, ft[Bt] = Zt[Bt]);
+                  }
+                  for (var Dt in ft) this._tiles[Dt].clearFadeHold();
+                  for (var yt = i.keysDifference(this._tiles, ft), Pt = 0, ht = yt; Pt < ht.length; Pt += 1) {
+                    var ur = ht[Pt], br = this._tiles[ur];
+                    br.hasSymbolBuckets && !br.holdingForFade() ? br.setHoldDuration(this.map._fadeDuration) : (!br.hasSymbolBuckets || br.symbolFadeFinished()) && this._removeTile(ur);
+                  }
+                  this._updateLoadedParentTileCache();
+                }
+              }, D.prototype.releaseSymbolFadeTiles = function() {
+                for (var q in this._tiles) this._tiles[q].holdingForFade() && this._removeTile(q);
+              }, D.prototype._updateRetainedTiles = function(q, K) {
+                for (var de = {}, ne = {}, we = Math.max(K - D.maxOverzooming, this._source.minzoom), Ue = Math.max(K + D.maxUnderzooming, this._source.minzoom), ft = {}, Zt = 0, hr = q; Zt < hr.length; Zt += 1) {
+                  var qt = hr[Zt], Ve = this._addTile(qt);
+                  de[qt.key] = qt, !Ve.hasData() && K < this._source.maxzoom && (ft[qt.key] = qt);
+                }
+                this._retainLoadedChildren(ft, K, Ue, de);
+                for (var Qe = 0, at = q; Qe < at.length; Qe += 1) {
+                  var Ct = at[Qe], Ot = this._tiles[Ct.key];
+                  if (!Ot.hasData()) {
+                    if (K + 1 > this._source.maxzoom) {
+                      var Rt = Ct.children(this._source.maxzoom)[0], Bt = this.getTile(Rt);
+                      if (Bt && Bt.hasData()) {
+                        de[Rt.key] = Rt;
+                        continue;
+                      }
+                    } else {
+                      var Dt = Ct.children(this._source.maxzoom);
+                      if (de[Dt[0].key] && de[Dt[1].key] && de[Dt[2].key] && de[Dt[3].key]) continue;
+                    }
+                    for (var yt = Ot.wasRequested(), Pt = Ct.overscaledZ - 1; Pt >= we; --Pt) {
+                      var ht = Ct.scaledTo(Pt);
+                      if (ne[ht.key] || (ne[ht.key] = true, Ot = this.getTile(ht), !Ot && yt && (Ot = this._addTile(ht)), Ot && (de[ht.key] = ht, yt = Ot.wasRequested(), Ot.hasData()))) break;
+                    }
+                  }
+                }
+                return de;
+              }, D.prototype._updateLoadedParentTileCache = function() {
+                this._loadedParentTiles = {};
+                for (var q in this._tiles) {
+                  for (var K = [], de = void 0, ne = this._tiles[q].tileID; ne.overscaledZ > 0; ) {
+                    if (ne.key in this._loadedParentTiles) {
+                      de = this._loadedParentTiles[ne.key];
+                      break;
+                    }
+                    K.push(ne.key);
+                    var we = ne.scaledTo(ne.overscaledZ - 1);
+                    if (de = this._getLoadedTile(we), de) break;
+                    ne = we;
+                  }
+                  for (var Ue = 0, ft = K; Ue < ft.length; Ue += 1) {
+                    var Zt = ft[Ue];
+                    this._loadedParentTiles[Zt] = de;
+                  }
+                }
+              }, D.prototype._addTile = function(q) {
+                var K = this._tiles[q.key];
+                if (K) return K;
+                K = this._cache.getAndRemove(q), K && (this._setTileReloadTimer(q.key, K), K.tileID = q, this._state.initializeTileState(K, this.map ? this.map.painter : null), this._cacheTimers[q.key] && (clearTimeout(this._cacheTimers[q.key]), delete this._cacheTimers[q.key], this._setTileReloadTimer(q.key, K)));
+                var de = !!K;
+                return de || (K = new i.Tile(q, this._source.tileSize * q.overscaleFactor()), this._loadTile(K, this._tileLoaded.bind(this, K, q.key, K.state))), K ? (K.uses++, this._tiles[q.key] = K, de || this._source.fire(new i.Event("dataloading", { tile: K, coord: K.tileID, dataType: "source" })), K) : null;
+              }, D.prototype._setTileReloadTimer = function(q, K) {
+                var de = this;
+                q in this._timers && (clearTimeout(this._timers[q]), delete this._timers[q]);
+                var ne = K.getExpiryTimeout();
+                ne && (this._timers[q] = setTimeout(function() {
+                  de._reloadTile(q, "expired"), delete de._timers[q];
+                }, ne));
+              }, D.prototype._removeTile = function(q) {
+                var K = this._tiles[q];
+                K && (K.uses--, delete this._tiles[q], this._timers[q] && (clearTimeout(this._timers[q]), delete this._timers[q]), !(K.uses > 0) && (K.hasData() && K.state !== "reloading" ? this._cache.add(K.tileID, K, K.getExpiryTimeout()) : (K.aborted = true, this._abortTile(K), this._unloadTile(K))));
+              }, D.prototype.clearTiles = function() {
+                this._shouldReloadOnResume = false, this._paused = false;
+                for (var q in this._tiles) this._removeTile(q);
+                this._cache.reset();
+              }, D.prototype.tilesIn = function(q, K, de) {
+                var ne = this, we = [], Ue = this.transform;
+                if (!Ue) return we;
+                for (var ft = de ? Ue.getCameraQueryGeometry(q) : q, Zt = q.map(function(Pt) {
+                  return Ue.pointCoordinate(Pt);
+                }), hr = ft.map(function(Pt) {
+                  return Ue.pointCoordinate(Pt);
+                }), qt = this.getIds(), Ve = 1 / 0, Qe = 1 / 0, at = -1 / 0, Ct = -1 / 0, Ot = 0, Rt = hr; Ot < Rt.length; Ot += 1) {
+                  var Bt = Rt[Ot];
+                  Ve = Math.min(Ve, Bt.x), Qe = Math.min(Qe, Bt.y), at = Math.max(at, Bt.x), Ct = Math.max(Ct, Bt.y);
+                }
+                for (var Dt = function(Pt) {
+                  var ht = ne._tiles[qt[Pt]];
+                  if (!ht.holdingForFade()) {
+                    var ur = ht.tileID, br = Math.pow(2, Ue.zoom - ht.tileID.overscaledZ), Ur = K * ht.queryPadding * i.EXTENT / ht.tileSize / br, Di = [ur.getTilePoint(new i.MercatorCoordinate(Ve, Qe)), ur.getTilePoint(new i.MercatorCoordinate(at, Ct))];
+                    if (Di[0].x - Ur < i.EXTENT && Di[0].y - Ur < i.EXTENT && Di[1].x + Ur >= 0 && Di[1].y + Ur >= 0) {
+                      var fi = Zt.map(function(gn) {
+                        return ur.getTilePoint(gn);
+                      }), Ti = hr.map(function(gn) {
+                        return ur.getTilePoint(gn);
+                      });
+                      we.push({ tile: ht, tileID: ur, queryGeometry: fi, cameraQueryGeometry: Ti, scale: br });
+                    }
+                  }
+                }, yt = 0; yt < qt.length; yt++) Dt(yt);
+                return we;
+              }, D.prototype.getVisibleCoordinates = function(q) {
+                for (var K = this, de = this.getRenderableIds(q).map(function(ft) {
+                  return K._tiles[ft].tileID;
+                }), ne = 0, we = de; ne < we.length; ne += 1) {
+                  var Ue = we[ne];
+                  Ue.posMatrix = this.transform.calculatePosMatrix(Ue.toUnwrapped());
+                }
+                return de;
+              }, D.prototype.hasTransition = function() {
+                if (this._source.hasTransition()) return true;
+                if (Oi(this._source.type)) for (var q in this._tiles) {
+                  var K = this._tiles[q];
+                  if (K.fadeEndTime !== void 0 && K.fadeEndTime >= i.browser.now()) return true;
+                }
+                return false;
+              }, D.prototype.setFeatureState = function(q, K, de) {
+                q = q || "_geojsonTileLayer", this._state.updateState(q, K, de);
+              }, D.prototype.removeFeatureState = function(q, K, de) {
+                q = q || "_geojsonTileLayer", this._state.removeFeatureState(q, K, de);
+              }, D.prototype.getFeatureState = function(q, K) {
+                return q = q || "_geojsonTileLayer", this._state.getState(q, K);
+              }, D.prototype.setDependencies = function(q, K, de) {
+                var ne = this._tiles[q];
+                ne && ne.setDependencies(K, de);
+              }, D.prototype.reloadTilesForDependencies = function(q, K) {
+                for (var de in this._tiles) {
+                  var ne = this._tiles[de];
+                  ne.hasDependency(q, K) && this._reloadTile(de, "reloading");
+                }
+                this._cache.filter(function(we) {
+                  return !we.hasDependency(q, K);
+                });
+              }, D;
+            }(i.Evented);
+            ri.maxOverzooming = 10, ri.maxUnderzooming = 3;
+            function Qr(Y, D) {
+              var J = Math.abs(Y.wrap * 2) - +(Y.wrap < 0), q = Math.abs(D.wrap * 2) - +(D.wrap < 0);
+              return Y.overscaledZ - D.overscaledZ || q - J || D.canonical.y - Y.canonical.y || D.canonical.x - Y.canonical.x;
+            }
+            function Oi(Y) {
+              return Y === "raster" || Y === "image" || Y === "video";
+            }
+            function $i() {
+              return new i.window.Worker(io.workerUrl);
+            }
+            var tn = "mapboxgl_preloaded_worker_pool", fn = function() {
+              this.active = {};
+            };
+            fn.prototype.acquire = function(D) {
+              if (!this.workers) for (this.workers = []; this.workers.length < fn.workerCount; ) this.workers.push(new $i());
+              return this.active[D] = true, this.workers.slice();
+            }, fn.prototype.release = function(D) {
+              delete this.active[D], this.numActive() === 0 && (this.workers.forEach(function(J) {
+                J.terminate();
+              }), this.workers = null);
+            }, fn.prototype.isPreloaded = function() {
+              return !!this.active[tn];
+            }, fn.prototype.numActive = function() {
+              return Object.keys(this.active).length;
+            };
+            var yn = Math.floor(i.browser.hardwareConcurrency / 2);
+            fn.workerCount = Math.max(Math.min(yn, 6), 1);
+            var Sn;
+            function Ba() {
+              return Sn || (Sn = new fn()), Sn;
+            }
+            function ua() {
+              var Y = Ba();
+              Y.acquire(tn);
+            }
+            function ma() {
+              var Y = Sn;
+              Y && (Y.isPreloaded() && Y.numActive() === 1 ? (Y.release(tn), Sn = null) : console.warn("Could not clear WebWorkers since there are active Map instances that still reference it. The pre-warmed WebWorker pool can only be cleared when all map instances have been removed with map.remove()"));
+            }
+            function Wa(Y, D) {
+              var J = {};
+              for (var q in Y) q !== "ref" && (J[q] = Y[q]);
+              return i.refProperties.forEach(function(K) {
+                K in D && (J[K] = D[K]);
+              }), J;
+            }
+            function Fa(Y) {
+              Y = Y.slice();
+              for (var D = /* @__PURE__ */ Object.create(null), J = 0; J < Y.length; J++) D[Y[J].id] = Y[J];
+              for (var q = 0; q < Y.length; q++) "ref" in Y[q] && (Y[q] = Wa(Y[q], D[Y[q].ref]));
+              return Y;
+            }
+            function Xo() {
+              var Y = {}, D = i.styleSpec.$version;
+              for (var J in i.styleSpec.$root) {
+                var q = i.styleSpec.$root[J];
+                if (q.required) {
+                  var K = null;
+                  J === "version" ? K = D : q.type === "array" ? K = [] : K = {}, K != null && (Y[J] = K);
+                }
+              }
+              return Y;
+            }
+            var da = { setStyle: "setStyle", addLayer: "addLayer", removeLayer: "removeLayer", setPaintProperty: "setPaintProperty", setLayoutProperty: "setLayoutProperty", setFilter: "setFilter", addSource: "addSource", removeSource: "removeSource", setGeoJSONSourceData: "setGeoJSONSourceData", setLayerZoomRange: "setLayerZoomRange", setLayerProperty: "setLayerProperty", setCenter: "setCenter", setZoom: "setZoom", setBearing: "setBearing", setPitch: "setPitch", setSprite: "setSprite", setGlyphs: "setGlyphs", setTransition: "setTransition", setLight: "setLight" };
+            function Wn(Y, D, J) {
+              J.push({ command: da.addSource, args: [Y, D[Y]] });
+            }
+            function Ha(Y, D, J) {
+              D.push({ command: da.removeSource, args: [Y] }), J[Y] = true;
+            }
+            function vo(Y, D, J, q) {
+              Ha(Y, J, q), Wn(Y, D, J);
+            }
+            function jn(Y, D, J) {
+              var q;
+              for (q in Y[J]) if (Y[J].hasOwnProperty(q) && q !== "data" && !i.deepEqual(Y[J][q], D[J][q])) return false;
+              for (q in D[J]) if (D[J].hasOwnProperty(q) && q !== "data" && !i.deepEqual(Y[J][q], D[J][q])) return false;
+              return true;
+            }
+            function Mt(Y, D, J, q) {
+              Y = Y || {}, D = D || {};
+              var K;
+              for (K in Y) Y.hasOwnProperty(K) && (D.hasOwnProperty(K) || Ha(K, J, q));
+              for (K in D) D.hasOwnProperty(K) && (Y.hasOwnProperty(K) ? i.deepEqual(Y[K], D[K]) || (Y[K].type === "geojson" && D[K].type === "geojson" && jn(Y, D, K) ? J.push({ command: da.setGeoJSONSourceData, args: [K, D[K].data] }) : vo(K, D, J, q)) : Wn(K, D, J));
+            }
+            function kr(Y, D, J, q, K, de) {
+              Y = Y || {}, D = D || {};
+              var ne;
+              for (ne in Y) Y.hasOwnProperty(ne) && (i.deepEqual(Y[ne], D[ne]) || J.push({ command: de, args: [q, ne, D[ne], K] }));
+              for (ne in D) !D.hasOwnProperty(ne) || Y.hasOwnProperty(ne) || i.deepEqual(Y[ne], D[ne]) || J.push({ command: de, args: [q, ne, D[ne], K] });
+            }
+            function Jr(Y) {
+              return Y.id;
+            }
+            function vi(Y, D) {
+              return Y[D.id] = D, Y;
+            }
+            function hn(Y, D, J) {
+              Y = Y || [], D = D || [];
+              var q = Y.map(Jr), K = D.map(Jr), de = Y.reduce(vi, {}), ne = D.reduce(vi, {}), we = q.slice(), Ue = /* @__PURE__ */ Object.create(null), ft, Zt, hr, qt, Ve, Qe, at;
+              for (ft = 0, Zt = 0; ft < q.length; ft++) hr = q[ft], ne.hasOwnProperty(hr) ? Zt++ : (J.push({ command: da.removeLayer, args: [hr] }), we.splice(we.indexOf(hr, Zt), 1));
+              for (ft = 0, Zt = 0; ft < K.length; ft++) hr = K[K.length - 1 - ft], we[we.length - 1 - ft] !== hr && (de.hasOwnProperty(hr) ? (J.push({ command: da.removeLayer, args: [hr] }), we.splice(we.lastIndexOf(hr, we.length - Zt), 1)) : Zt++, Qe = we[we.length - ft], J.push({ command: da.addLayer, args: [ne[hr], Qe] }), we.splice(we.length - ft, 0, hr), Ue[hr] = true);
+              for (ft = 0; ft < K.length; ft++) if (hr = K[ft], qt = de[hr], Ve = ne[hr], !(Ue[hr] || i.deepEqual(qt, Ve))) {
+                if (!i.deepEqual(qt.source, Ve.source) || !i.deepEqual(qt["source-layer"], Ve["source-layer"]) || !i.deepEqual(qt.type, Ve.type)) {
+                  J.push({ command: da.removeLayer, args: [hr] }), Qe = we[we.lastIndexOf(hr) + 1], J.push({ command: da.addLayer, args: [Ve, Qe] });
+                  continue;
+                }
+                kr(qt.layout, Ve.layout, J, hr, null, da.setLayoutProperty), kr(qt.paint, Ve.paint, J, hr, null, da.setPaintProperty), i.deepEqual(qt.filter, Ve.filter) || J.push({ command: da.setFilter, args: [hr, Ve.filter] }), (!i.deepEqual(qt.minzoom, Ve.minzoom) || !i.deepEqual(qt.maxzoom, Ve.maxzoom)) && J.push({ command: da.setLayerZoomRange, args: [hr, Ve.minzoom, Ve.maxzoom] });
+                for (at in qt) qt.hasOwnProperty(at) && (at === "layout" || at === "paint" || at === "filter" || at === "metadata" || at === "minzoom" || at === "maxzoom" || (at.indexOf("paint.") === 0 ? kr(qt[at], Ve[at], J, hr, at.slice(6), da.setPaintProperty) : i.deepEqual(qt[at], Ve[at]) || J.push({ command: da.setLayerProperty, args: [hr, at, Ve[at]] })));
+                for (at in Ve) !Ve.hasOwnProperty(at) || qt.hasOwnProperty(at) || at === "layout" || at === "paint" || at === "filter" || at === "metadata" || at === "minzoom" || at === "maxzoom" || (at.indexOf("paint.") === 0 ? kr(qt[at], Ve[at], J, hr, at.slice(6), da.setPaintProperty) : i.deepEqual(qt[at], Ve[at]) || J.push({ command: da.setLayerProperty, args: [hr, at, Ve[at]] }));
+              }
+            }
+            function An(Y, D) {
+              if (!Y) return [{ command: da.setStyle, args: [D] }];
+              var J = [];
+              try {
+                if (!i.deepEqual(Y.version, D.version)) return [{ command: da.setStyle, args: [D] }];
+                i.deepEqual(Y.center, D.center) || J.push({ command: da.setCenter, args: [D.center] }), i.deepEqual(Y.zoom, D.zoom) || J.push({ command: da.setZoom, args: [D.zoom] }), i.deepEqual(Y.bearing, D.bearing) || J.push({ command: da.setBearing, args: [D.bearing] }), i.deepEqual(Y.pitch, D.pitch) || J.push({ command: da.setPitch, args: [D.pitch] }), i.deepEqual(Y.sprite, D.sprite) || J.push({ command: da.setSprite, args: [D.sprite] }), i.deepEqual(Y.glyphs, D.glyphs) || J.push({ command: da.setGlyphs, args: [D.glyphs] }), i.deepEqual(Y.transition, D.transition) || J.push({ command: da.setTransition, args: [D.transition] }), i.deepEqual(Y.light, D.light) || J.push({ command: da.setLight, args: [D.light] });
+                var q = {}, K = [];
+                Mt(Y.sources, D.sources, K, q);
+                var de = [];
+                Y.layers && Y.layers.forEach(function(ne) {
+                  q[ne.source] ? J.push({ command: da.removeLayer, args: [ne.id] }) : de.push(ne);
+                }), J = J.concat(K), hn(de, D.layers, J);
+              } catch (ne) {
+                console.warn("Unable to compute style diff:", ne), J = [{ command: da.setStyle, args: [D] }];
+              }
+              return J;
+            }
+            var Mn = function(D, J) {
+              this.reset(D, J);
+            };
+            Mn.prototype.reset = function(D, J) {
+              this.points = D || [], this._distances = [0];
+              for (var q = 1; q < this.points.length; q++) this._distances[q] = this._distances[q - 1] + this.points[q].dist(this.points[q - 1]);
+              this.length = this._distances[this._distances.length - 1], this.padding = Math.min(J || 0, this.length * 0.5), this.paddedLength = this.length - this.padding * 2;
+            }, Mn.prototype.lerp = function(D) {
+              if (this.points.length === 1) return this.points[0];
+              D = i.clamp(D, 0, 1);
+              for (var J = 1, q = this._distances[J], K = D * this.paddedLength + this.padding; q < K && J < this._distances.length; ) q = this._distances[++J];
+              var de = J - 1, ne = this._distances[de], we = q - ne, Ue = we > 0 ? (K - ne) / we : 0;
+              return this.points[de].mult(1 - Ue).add(this.points[J].mult(Ue));
+            };
+            var Li = function(D, J, q) {
+              var K = this.boxCells = [], de = this.circleCells = [];
+              this.xCellCount = Math.ceil(D / q), this.yCellCount = Math.ceil(J / q);
+              for (var ne = 0; ne < this.xCellCount * this.yCellCount; ne++) K.push([]), de.push([]);
+              this.circleKeys = [], this.boxKeys = [], this.bboxes = [], this.circles = [], this.width = D, this.height = J, this.xScale = this.xCellCount / D, this.yScale = this.yCellCount / J, this.boxUid = 0, this.circleUid = 0;
+            };
+            Li.prototype.keysLength = function() {
+              return this.boxKeys.length + this.circleKeys.length;
+            }, Li.prototype.insert = function(D, J, q, K, de) {
+              this._forEachCell(J, q, K, de, this._insertBoxCell, this.boxUid++), this.boxKeys.push(D), this.bboxes.push(J), this.bboxes.push(q), this.bboxes.push(K), this.bboxes.push(de);
+            }, Li.prototype.insertCircle = function(D, J, q, K) {
+              this._forEachCell(J - K, q - K, J + K, q + K, this._insertCircleCell, this.circleUid++), this.circleKeys.push(D), this.circles.push(J), this.circles.push(q), this.circles.push(K);
+            }, Li.prototype._insertBoxCell = function(D, J, q, K, de, ne) {
+              this.boxCells[de].push(ne);
+            }, Li.prototype._insertCircleCell = function(D, J, q, K, de, ne) {
+              this.circleCells[de].push(ne);
+            }, Li.prototype._query = function(D, J, q, K, de, ne) {
+              if (q < 0 || D > this.width || K < 0 || J > this.height) return de ? false : [];
+              var we = [];
+              if (D <= 0 && J <= 0 && this.width <= q && this.height <= K) {
+                if (de) return true;
+                for (var Ue = 0; Ue < this.boxKeys.length; Ue++) we.push({ key: this.boxKeys[Ue], x1: this.bboxes[Ue * 4], y1: this.bboxes[Ue * 4 + 1], x2: this.bboxes[Ue * 4 + 2], y2: this.bboxes[Ue * 4 + 3] });
+                for (var ft = 0; ft < this.circleKeys.length; ft++) {
+                  var Zt = this.circles[ft * 3], hr = this.circles[ft * 3 + 1], qt = this.circles[ft * 3 + 2];
+                  we.push({ key: this.circleKeys[ft], x1: Zt - qt, y1: hr - qt, x2: Zt + qt, y2: hr + qt });
+                }
+                return ne ? we.filter(ne) : we;
+              } else {
+                var Ve = { hitTest: de, seenUids: { box: {}, circle: {} } };
+                return this._forEachCell(D, J, q, K, this._queryCell, we, Ve, ne), de ? we.length > 0 : we;
+              }
+            }, Li.prototype._queryCircle = function(D, J, q, K, de) {
+              var ne = D - q, we = D + q, Ue = J - q, ft = J + q;
+              if (we < 0 || ne > this.width || ft < 0 || Ue > this.height) return K ? false : [];
+              var Zt = [], hr = { hitTest: K, circle: { x: D, y: J, radius: q }, seenUids: { box: {}, circle: {} } };
+              return this._forEachCell(ne, Ue, we, ft, this._queryCellCircle, Zt, hr, de), K ? Zt.length > 0 : Zt;
+            }, Li.prototype.query = function(D, J, q, K, de) {
+              return this._query(D, J, q, K, false, de);
+            }, Li.prototype.hitTest = function(D, J, q, K, de) {
+              return this._query(D, J, q, K, true, de);
+            }, Li.prototype.hitTestCircle = function(D, J, q, K) {
+              return this._queryCircle(D, J, q, true, K);
+            }, Li.prototype._queryCell = function(D, J, q, K, de, ne, we, Ue) {
+              var ft = we.seenUids, Zt = this.boxCells[de];
+              if (Zt !== null) for (var hr = this.bboxes, qt = 0, Ve = Zt; qt < Ve.length; qt += 1) {
+                var Qe = Ve[qt];
+                if (!ft.box[Qe]) {
+                  ft.box[Qe] = true;
+                  var at = Qe * 4;
+                  if (D <= hr[at + 2] && J <= hr[at + 3] && q >= hr[at + 0] && K >= hr[at + 1] && (!Ue || Ue(this.boxKeys[Qe]))) {
+                    if (we.hitTest) return ne.push(true), true;
+                    ne.push({ key: this.boxKeys[Qe], x1: hr[at], y1: hr[at + 1], x2: hr[at + 2], y2: hr[at + 3] });
+                  }
+                }
+              }
+              var Ct = this.circleCells[de];
+              if (Ct !== null) for (var Ot = this.circles, Rt = 0, Bt = Ct; Rt < Bt.length; Rt += 1) {
+                var Dt = Bt[Rt];
+                if (!ft.circle[Dt]) {
+                  ft.circle[Dt] = true;
+                  var yt = Dt * 3;
+                  if (this._circleAndRectCollide(Ot[yt], Ot[yt + 1], Ot[yt + 2], D, J, q, K) && (!Ue || Ue(this.circleKeys[Dt]))) {
+                    if (we.hitTest) return ne.push(true), true;
+                    var Pt = Ot[yt], ht = Ot[yt + 1], ur = Ot[yt + 2];
+                    ne.push({ key: this.circleKeys[Dt], x1: Pt - ur, y1: ht - ur, x2: Pt + ur, y2: ht + ur });
+                  }
+                }
+              }
+            }, Li.prototype._queryCellCircle = function(D, J, q, K, de, ne, we, Ue) {
+              var ft = we.circle, Zt = we.seenUids, hr = this.boxCells[de];
+              if (hr !== null) for (var qt = this.bboxes, Ve = 0, Qe = hr; Ve < Qe.length; Ve += 1) {
+                var at = Qe[Ve];
+                if (!Zt.box[at]) {
+                  Zt.box[at] = true;
+                  var Ct = at * 4;
+                  if (this._circleAndRectCollide(ft.x, ft.y, ft.radius, qt[Ct + 0], qt[Ct + 1], qt[Ct + 2], qt[Ct + 3]) && (!Ue || Ue(this.boxKeys[at]))) return ne.push(true), true;
+                }
+              }
+              var Ot = this.circleCells[de];
+              if (Ot !== null) for (var Rt = this.circles, Bt = 0, Dt = Ot; Bt < Dt.length; Bt += 1) {
+                var yt = Dt[Bt];
+                if (!Zt.circle[yt]) {
+                  Zt.circle[yt] = true;
+                  var Pt = yt * 3;
+                  if (this._circlesCollide(Rt[Pt], Rt[Pt + 1], Rt[Pt + 2], ft.x, ft.y, ft.radius) && (!Ue || Ue(this.circleKeys[yt]))) return ne.push(true), true;
+                }
+              }
+            }, Li.prototype._forEachCell = function(D, J, q, K, de, ne, we, Ue) {
+              for (var ft = this._convertToXCellCoord(D), Zt = this._convertToYCellCoord(J), hr = this._convertToXCellCoord(q), qt = this._convertToYCellCoord(K), Ve = ft; Ve <= hr; Ve++) for (var Qe = Zt; Qe <= qt; Qe++) {
+                var at = this.xCellCount * Qe + Ve;
+                if (de.call(this, D, J, q, K, at, ne, we, Ue)) return;
+              }
+            }, Li.prototype._convertToXCellCoord = function(D) {
+              return Math.max(0, Math.min(this.xCellCount - 1, Math.floor(D * this.xScale)));
+            }, Li.prototype._convertToYCellCoord = function(D) {
+              return Math.max(0, Math.min(this.yCellCount - 1, Math.floor(D * this.yScale)));
+            }, Li.prototype._circlesCollide = function(D, J, q, K, de, ne) {
+              var we = K - D, Ue = de - J, ft = q + ne;
+              return ft * ft > we * we + Ue * Ue;
+            }, Li.prototype._circleAndRectCollide = function(D, J, q, K, de, ne, we) {
+              var Ue = (ne - K) / 2, ft = Math.abs(D - (K + Ue));
+              if (ft > Ue + q) return false;
+              var Zt = (we - de) / 2, hr = Math.abs(J - (de + Zt));
+              if (hr > Zt + q) return false;
+              if (ft <= Ue || hr <= Zt) return true;
+              var qt = ft - Ue, Ve = hr - Zt;
+              return qt * qt + Ve * Ve <= q * q;
+            };
+            function _n(Y, D, J, q, K) {
+              var de = i.create();
+              return D ? (i.scale(de, de, [1 / K, 1 / K, 1]), J || i.rotateZ(de, de, q.angle)) : i.multiply(de, q.labelPlaneMatrix, Y), de;
+            }
+            function ya(Y, D, J, q, K) {
+              if (D) {
+                var de = i.clone(Y);
+                return i.scale(de, de, [K, K, 1]), J || i.rotateZ(de, de, -q.angle), de;
+              } else return q.glCoordMatrix;
+            }
+            function $n(Y, D) {
+              var J = [Y.x, Y.y, 0, 1];
+              zl(J, J, D);
+              var q = J[3];
+              return { point: new i.Point(J[0] / q, J[1] / q), signedDistanceFromCamera: q };
+            }
+            function Ma(Y, D) {
+              return 0.5 + 0.5 * (Y / D);
+            }
+            function _o(Y, D) {
+              var J = Y[0] / Y[3], q = Y[1] / Y[3], K = J >= -D[0] && J <= D[0] && q >= -D[1] && q <= D[1];
+              return K;
+            }
+            function No(Y, D, J, q, K, de, ne, we) {
+              var Ue = q ? Y.textSizeData : Y.iconSizeData, ft = i.evaluateSizeForZoom(Ue, J.transform.zoom), Zt = [256 / J.width * 2 + 1, 256 / J.height * 2 + 1], hr = q ? Y.text.dynamicLayoutVertexArray : Y.icon.dynamicLayoutVertexArray;
+              hr.clear();
+              for (var qt = Y.lineVertexArray, Ve = q ? Y.text.placedSymbolArray : Y.icon.placedSymbolArray, Qe = J.transform.width / J.transform.height, at = false, Ct = 0; Ct < Ve.length; Ct++) {
+                var Ot = Ve.get(Ct);
+                if (Ot.hidden || Ot.writingMode === i.WritingMode.vertical && !at) {
+                  ul(Ot.numGlyphs, hr);
+                  continue;
+                }
+                at = false;
+                var Rt = [Ot.anchorX, Ot.anchorY, 0, 1];
+                if (i.transformMat4(Rt, Rt, D), !_o(Rt, Zt)) {
+                  ul(Ot.numGlyphs, hr);
+                  continue;
+                }
+                var Bt = Rt[3], Dt = Ma(J.transform.cameraToCenterDistance, Bt), yt = i.evaluateSizeForFeature(Ue, ft, Ot), Pt = ne ? yt / Dt : yt * Dt, ht = new i.Point(Ot.anchorX, Ot.anchorY), ur = $n(ht, K).point, br = {}, Ur = ko(Ot, Pt, false, we, D, K, de, Y.glyphOffsetArray, qt, hr, ur, ht, br, Qe);
+                at = Ur.useVertical, (Ur.notEnoughRoom || at || Ur.needsFlipping && ko(Ot, Pt, true, we, D, K, de, Y.glyphOffsetArray, qt, hr, ur, ht, br, Qe).notEnoughRoom) && ul(Ot.numGlyphs, hr);
+              }
+              q ? Y.text.dynamicLayoutVertexBuffer.updateData(hr) : Y.icon.dynamicLayoutVertexBuffer.updateData(hr);
+            }
+            function po(Y, D, J, q, K, de, ne, we, Ue, ft, Zt) {
+              var hr = we.glyphStartIndex + we.numGlyphs, qt = we.lineStartIndex, Ve = we.lineStartIndex + we.lineLength, Qe = D.getoffsetX(we.glyphStartIndex), at = D.getoffsetX(hr - 1), Ct = Fs(Y * Qe, J, q, K, de, ne, we.segment, qt, Ve, Ue, ft, Zt);
+              if (!Ct) return null;
+              var Ot = Fs(Y * at, J, q, K, de, ne, we.segment, qt, Ve, Ue, ft, Zt);
+              return Ot ? { first: Ct, last: Ot } : null;
+            }
+            function Lo(Y, D, J, q) {
+              if (Y === i.WritingMode.horizontal) {
+                var K = Math.abs(J.y - D.y), de = Math.abs(J.x - D.x) * q;
+                if (K > de) return { useVertical: true };
+              }
+              return (Y === i.WritingMode.vertical ? D.y < J.y : D.x > J.x) ? { needsFlipping: true } : null;
+            }
+            function ko(Y, D, J, q, K, de, ne, we, Ue, ft, Zt, hr, qt, Ve) {
+              var Qe = D / 24, at = Y.lineOffsetX * Qe, Ct = Y.lineOffsetY * Qe, Ot;
+              if (Y.numGlyphs > 1) {
+                var Rt = Y.glyphStartIndex + Y.numGlyphs, Bt = Y.lineStartIndex, Dt = Y.lineStartIndex + Y.lineLength, yt = po(Qe, we, at, Ct, J, Zt, hr, Y, Ue, de, qt);
+                if (!yt) return { notEnoughRoom: true };
+                var Pt = $n(yt.first.point, ne).point, ht = $n(yt.last.point, ne).point;
+                if (q && !J) {
+                  var ur = Lo(Y.writingMode, Pt, ht, Ve);
+                  if (ur) return ur;
+                }
+                Ot = [yt.first];
+                for (var br = Y.glyphStartIndex + 1; br < Rt - 1; br++) Ot.push(Fs(Qe * we.getoffsetX(br), at, Ct, J, Zt, hr, Y.segment, Bt, Dt, Ue, de, qt));
+                Ot.push(yt.last);
+              } else {
+                if (q && !J) {
+                  var Ur = $n(hr, K).point, Di = Y.lineStartIndex + Y.segment + 1, fi = new i.Point(Ue.getx(Di), Ue.gety(Di)), Ti = $n(fi, K), gn = Ti.signedDistanceFromCamera > 0 ? Ti.point : Ds(hr, fi, Ur, 1, K), rn = Lo(Y.writingMode, Ur, gn, Ve);
+                  if (rn) return rn;
+                }
+                var Ci = Fs(Qe * we.getoffsetX(Y.glyphStartIndex), at, Ct, J, Zt, hr, Y.segment, Y.lineStartIndex, Y.lineStartIndex + Y.lineLength, Ue, de, qt);
+                if (!Ci) return { notEnoughRoom: true };
+                Ot = [Ci];
+              }
+              for (var Bi = 0, Gi = Ot; Bi < Gi.length; Bi += 1) {
+                var sn = Gi[Bi];
+                i.addDynamicAttributes(ft, sn.point, sn.angle);
+              }
+              return {};
+            }
+            function Ds(Y, D, J, q, K) {
+              var de = $n(Y.add(Y.sub(D)._unit()), K).point, ne = J.sub(de);
+              return J.add(ne._mult(q / ne.mag()));
+            }
+            function Fs(Y, D, J, q, K, de, ne, we, Ue, ft, Zt, hr) {
+              var qt = q ? Y - D : Y + D, Ve = qt > 0 ? 1 : -1, Qe = 0;
+              q && (Ve *= -1, Qe = Math.PI), Ve < 0 && (Qe += Math.PI);
+              for (var at = Ve > 0 ? we + ne : we + ne + 1, Ct = K, Ot = K, Rt = 0, Bt = 0, Dt = Math.abs(qt), yt = []; Rt + Bt <= Dt; ) {
+                if (at += Ve, at < we || at >= Ue) return null;
+                if (Ot = Ct, yt.push(Ct), Ct = hr[at], Ct === void 0) {
+                  var Pt = new i.Point(ft.getx(at), ft.gety(at)), ht = $n(Pt, Zt);
+                  if (ht.signedDistanceFromCamera > 0) Ct = hr[at] = ht.point;
+                  else {
+                    var ur = at - Ve, br = Rt === 0 ? de : new i.Point(ft.getx(ur), ft.gety(ur));
+                    Ct = Ds(br, Pt, Ot, Dt - Rt + 1, Zt);
+                  }
+                }
+                Rt += Bt, Bt = Ot.dist(Ct);
+              }
+              var Ur = (Dt - Rt) / Bt, Di = Ct.sub(Ot), fi = Di.mult(Ur)._add(Ot);
+              fi._add(Di._unit()._perp()._mult(J * Ve));
+              var Ti = Qe + Math.atan2(Ct.y - Ot.y, Ct.x - Ot.x);
+              return yt.push(fi), { point: fi, angle: Ti, path: yt };
+            }
+            var ll = new Float32Array([-1 / 0, -1 / 0, 0, -1 / 0, -1 / 0, 0, -1 / 0, -1 / 0, 0, -1 / 0, -1 / 0, 0]);
+            function ul(Y, D) {
+              for (var J = 0; J < Y; J++) {
+                var q = D.length;
+                D.resize(q + 4), D.float32.set(ll, q * 3);
+              }
+            }
+            function zl(Y, D, J) {
+              var q = D[0], K = D[1];
+              return Y[0] = J[0] * q + J[4] * K + J[12], Y[1] = J[1] * q + J[5] * K + J[13], Y[3] = J[3] * q + J[7] * K + J[15], Y;
+            }
+            var us = 100, il = function(D, J, q) {
+              J === void 0 && (J = new Li(D.width + 2 * us, D.height + 2 * us, 25)), q === void 0 && (q = new Li(D.width + 2 * us, D.height + 2 * us, 25)), this.transform = D, this.grid = J, this.ignoredGrid = q, this.pitchfactor = Math.cos(D._pitch) * D.cameraToCenterDistance, this.screenRightBoundary = D.width + us, this.screenBottomBoundary = D.height + us, this.gridRightBoundary = D.width + 2 * us, this.gridBottomBoundary = D.height + 2 * us;
+            };
+            il.prototype.placeCollisionBox = function(D, J, q, K, de) {
+              var ne = this.projectAndGetPerspectiveRatio(K, D.anchorPointX, D.anchorPointY), we = q * ne.perspectiveRatio, Ue = D.x1 * we + ne.point.x, ft = D.y1 * we + ne.point.y, Zt = D.x2 * we + ne.point.x, hr = D.y2 * we + ne.point.y;
+              return !this.isInsideGrid(Ue, ft, Zt, hr) || !J && this.grid.hitTest(Ue, ft, Zt, hr, de) ? { box: [], offscreen: false } : { box: [Ue, ft, Zt, hr], offscreen: this.isOffscreen(Ue, ft, Zt, hr) };
+            }, il.prototype.placeCollisionCircles = function(D, J, q, K, de, ne, we, Ue, ft, Zt, hr, qt, Ve) {
+              var Qe = [], at = new i.Point(J.anchorX, J.anchorY), Ct = $n(at, ne), Ot = Ma(this.transform.cameraToCenterDistance, Ct.signedDistanceFromCamera), Rt = Zt ? de / Ot : de * Ot, Bt = Rt / i.ONE_EM, Dt = $n(at, we).point, yt = {}, Pt = J.lineOffsetX * Bt, ht = J.lineOffsetY * Bt, ur = po(Bt, K, Pt, ht, false, Dt, at, J, q, we, yt), br = false, Ur = false, Di = true;
+              if (ur) {
+                for (var fi = qt * 0.5 * Ot + Ve, Ti = new i.Point(-100, -100), gn = new i.Point(this.screenRightBoundary, this.screenBottomBoundary), rn = new Mn(), Ci = ur.first, Bi = ur.last, Gi = [], sn = Ci.path.length - 1; sn >= 1; sn--) Gi.push(Ci.path[sn]);
+                for (var zn = 1; zn < Bi.path.length; zn++) Gi.push(Bi.path[zn]);
+                var Ja = fi * 2.5;
+                if (Ue) {
+                  var co = Gi.map(function(Iv) {
+                    return $n(Iv, Ue);
+                  });
+                  co.some(function(Iv) {
+                    return Iv.signedDistanceFromCamera <= 0;
+                  }) ? Gi = [] : Gi = co.map(function(Iv) {
+                    return Iv.point;
+                  });
+                }
+                var ts = [];
+                if (Gi.length > 0) {
+                  for (var so = Gi[0].clone(), Yo = Gi[0].clone(), ms = 1; ms < Gi.length; ms++) so.x = Math.min(so.x, Gi[ms].x), so.y = Math.min(so.y, Gi[ms].y), Yo.x = Math.max(Yo.x, Gi[ms].x), Yo.y = Math.max(Yo.y, Gi[ms].y);
+                  so.x >= Ti.x && Yo.x <= gn.x && so.y >= Ti.y && Yo.y <= gn.y ? ts = [Gi] : Yo.x < Ti.x || so.x > gn.x || Yo.y < Ti.y || so.y > gn.y ? ts = [] : ts = i.clipLine([Gi], Ti.x, Ti.y, gn.x, gn.y);
+                }
+                for (var ou = 0, Cv = ts; ou < Cv.length; ou += 1) {
+                  var Lv = Cv[ou];
+                  rn.reset(Lv, fi * 0.25);
+                  var wd = 0;
+                  rn.length <= 0.5 * fi ? wd = 1 : wd = Math.ceil(rn.paddedLength / Ja) + 1;
+                  for (var Kv = 0; Kv < wd; Kv++) {
+                    var hg = Kv / Math.max(wd - 1, 1), gp = rn.lerp(hg), Td = gp.x + us, mp = gp.y + us;
+                    Qe.push(Td, mp, fi, 0);
+                    var Ud = Td - fi, Ad = mp - fi, Pv = Td + fi, Jv = mp + fi;
+                    if (Di = Di && this.isOffscreen(Ud, Ad, Pv, Jv), Ur = Ur || this.isInsideGrid(Ud, Ad, Pv, Jv), !D && this.grid.hitTestCircle(Td, mp, fi, hr) && (br = true, !ft)) return { circles: [], offscreen: false, collisionDetected: br };
+                  }
+                }
+              }
+              return { circles: !ft && br || !Ur ? [] : Qe, offscreen: Di, collisionDetected: br };
+            }, il.prototype.queryRenderedSymbols = function(D) {
+              if (D.length === 0 || this.grid.keysLength() === 0 && this.ignoredGrid.keysLength() === 0) return {};
+              for (var J = [], q = 1 / 0, K = 1 / 0, de = -1 / 0, ne = -1 / 0, we = 0, Ue = D; we < Ue.length; we += 1) {
+                var ft = Ue[we], Zt = new i.Point(ft.x + us, ft.y + us);
+                q = Math.min(q, Zt.x), K = Math.min(K, Zt.y), de = Math.max(de, Zt.x), ne = Math.max(ne, Zt.y), J.push(Zt);
+              }
+              for (var hr = this.grid.query(q, K, de, ne).concat(this.ignoredGrid.query(q, K, de, ne)), qt = {}, Ve = {}, Qe = 0, at = hr; Qe < at.length; Qe += 1) {
+                var Ct = at[Qe], Ot = Ct.key;
+                if (qt[Ot.bucketInstanceId] === void 0 && (qt[Ot.bucketInstanceId] = {}), !qt[Ot.bucketInstanceId][Ot.featureIndex]) {
+                  var Rt = [new i.Point(Ct.x1, Ct.y1), new i.Point(Ct.x2, Ct.y1), new i.Point(Ct.x2, Ct.y2), new i.Point(Ct.x1, Ct.y2)];
+                  i.polygonIntersectsPolygon(J, Rt) && (qt[Ot.bucketInstanceId][Ot.featureIndex] = true, Ve[Ot.bucketInstanceId] === void 0 && (Ve[Ot.bucketInstanceId] = []), Ve[Ot.bucketInstanceId].push(Ot.featureIndex));
+                }
+              }
+              return Ve;
+            }, il.prototype.insertCollisionBox = function(D, J, q, K, de) {
+              var ne = J ? this.ignoredGrid : this.grid, we = { bucketInstanceId: q, featureIndex: K, collisionGroupID: de };
+              ne.insert(we, D[0], D[1], D[2], D[3]);
+            }, il.prototype.insertCollisionCircles = function(D, J, q, K, de) {
+              for (var ne = J ? this.ignoredGrid : this.grid, we = { bucketInstanceId: q, featureIndex: K, collisionGroupID: de }, Ue = 0; Ue < D.length; Ue += 4) ne.insertCircle(we, D[Ue], D[Ue + 1], D[Ue + 2]);
+            }, il.prototype.projectAndGetPerspectiveRatio = function(D, J, q) {
+              var K = [J, q, 0, 1];
+              zl(K, K, D);
+              var de = new i.Point((K[0] / K[3] + 1) / 2 * this.transform.width + us, (-K[1] / K[3] + 1) / 2 * this.transform.height + us);
+              return { point: de, perspectiveRatio: 0.5 + 0.5 * (this.transform.cameraToCenterDistance / K[3]) };
+            }, il.prototype.isOffscreen = function(D, J, q, K) {
+              return q < us || D >= this.screenRightBoundary || K < us || J > this.screenBottomBoundary;
+            }, il.prototype.isInsideGrid = function(D, J, q, K) {
+              return q >= 0 && D < this.gridRightBoundary && K >= 0 && J < this.gridBottomBoundary;
+            }, il.prototype.getViewportMatrix = function() {
+              var D = i.identity([]);
+              return i.translate(D, D, [-100, -100, 0]), D;
+            };
+            function As(Y, D, J) {
+              return D * (i.EXTENT / (Y.tileSize * Math.pow(2, J - Y.tileID.overscaledZ)));
+            }
+            var cl = function(D, J, q, K) {
+              D ? this.opacity = Math.max(0, Math.min(1, D.opacity + (D.placed ? J : -J))) : this.opacity = K && q ? 1 : 0, this.placed = q;
+            };
+            cl.prototype.isHidden = function() {
+              return this.opacity === 0 && !this.placed;
+            };
+            var Ks = function(D, J, q, K, de) {
+              this.text = new cl(D ? D.text : null, J, q, de), this.icon = new cl(D ? D.icon : null, J, K, de);
+            };
+            Ks.prototype.isHidden = function() {
+              return this.text.isHidden() && this.icon.isHidden();
+            };
+            var zs = function(D, J, q) {
+              this.text = D, this.icon = J, this.skipFade = q;
+            }, Io = function() {
+              this.invProjMatrix = i.create(), this.viewportMatrix = i.create(), this.circles = [];
+            }, ls = function(D, J, q, K, de) {
+              this.bucketInstanceId = D, this.featureIndex = J, this.sourceLayerIndex = q, this.bucketIndex = K, this.tileID = de;
+            }, Yl = function(D) {
+              this.crossSourceCollisions = D, this.maxGroupID = 0, this.collisionGroups = {};
+            };
+            Yl.prototype.get = function(D) {
+              if (this.crossSourceCollisions) return { ID: 0, predicate: null };
+              if (!this.collisionGroups[D]) {
+                var J = ++this.maxGroupID;
+                this.collisionGroups[D] = { ID: J, predicate: function(q) {
+                  return q.collisionGroupID === J;
+                } };
+              }
+              return this.collisionGroups[D];
+            };
+            function Su(Y, D, J, q, K) {
+              var de = i.getAnchorAlignment(Y), ne = de.horizontalAlign, we = de.verticalAlign, Ue = -(ne - 0.5) * D, ft = -(we - 0.5) * J, Zt = i.evaluateVariableOffset(Y, q);
+              return new i.Point(Ue + Zt[0] * K, ft + Zt[1] * K);
+            }
+            function nc(Y, D, J, q, K, de) {
+              var ne = Y.x1, we = Y.x2, Ue = Y.y1, ft = Y.y2, Zt = Y.anchorPointX, hr = Y.anchorPointY, qt = new i.Point(D, J);
+              return q && qt._rotate(K ? de : -de), { x1: ne + qt.x, y1: Ue + qt.y, x2: we + qt.x, y2: ft + qt.y, anchorPointX: Zt, anchorPointY: hr };
+            }
+            var bs = function(D, J, q, K) {
+              this.transform = D.clone(), this.collisionIndex = new il(this.transform), this.placements = {}, this.opacities = {}, this.variableOffsets = {}, this.stale = false, this.commitTime = 0, this.fadeDuration = J, this.retainedQueryData = {}, this.collisionGroups = new Yl(q), this.collisionCircleArrays = {}, this.prevPlacement = K, K && (K.prevPlacement = void 0), this.placedOrientations = {};
+            };
+            bs.prototype.getBucketParts = function(D, J, q, K) {
+              var de = q.getBucket(J), ne = q.latestFeatureIndex;
+              if (!(!de || !ne || J.id !== de.layerIds[0])) {
+                var we = q.collisionBoxArray, Ue = de.layers[0].layout, ft = Math.pow(2, this.transform.zoom - q.tileID.overscaledZ), Zt = q.tileSize / i.EXTENT, hr = this.transform.calculatePosMatrix(q.tileID.toUnwrapped()), qt = Ue.get("text-pitch-alignment") === "map", Ve = Ue.get("text-rotation-alignment") === "map", Qe = As(q, 1, this.transform.zoom), at = _n(hr, qt, Ve, this.transform, Qe), Ct = null;
+                if (qt) {
+                  var Ot = ya(hr, qt, Ve, this.transform, Qe);
+                  Ct = i.multiply([], this.transform.labelPlaneMatrix, Ot);
+                }
+                this.retainedQueryData[de.bucketInstanceId] = new ls(de.bucketInstanceId, ne, de.sourceLayerIndex, de.index, q.tileID);
+                var Rt = { bucket: de, layout: Ue, posMatrix: hr, textLabelPlaneMatrix: at, labelToScreenMatrix: Ct, scale: ft, textPixelRatio: Zt, holdingForFade: q.holdingForFade(), collisionBoxArray: we, partiallyEvaluatedTextSize: i.evaluateSizeForZoom(de.textSizeData, this.transform.zoom), collisionGroup: this.collisionGroups.get(de.sourceID) };
+                if (K) for (var Bt = 0, Dt = de.sortKeyRanges; Bt < Dt.length; Bt += 1) {
+                  var yt = Dt[Bt], Pt = yt.sortKey, ht = yt.symbolInstanceStart, ur = yt.symbolInstanceEnd;
+                  D.push({ sortKey: Pt, symbolInstanceStart: ht, symbolInstanceEnd: ur, parameters: Rt });
+                }
+                else D.push({ symbolInstanceStart: 0, symbolInstanceEnd: de.symbolInstances.length, parameters: Rt });
+              }
+            }, bs.prototype.attemptAnchorPlacement = function(D, J, q, K, de, ne, we, Ue, ft, Zt, hr, qt, Ve, Qe, at) {
+              var Ct = [qt.textOffset0, qt.textOffset1], Ot = Su(D, q, K, Ct, de), Rt = this.collisionIndex.placeCollisionBox(nc(J, Ot.x, Ot.y, ne, we, this.transform.angle), hr, Ue, ft, Zt.predicate);
+              if (at) {
+                var Bt = this.collisionIndex.placeCollisionBox(nc(at, Ot.x, Ot.y, ne, we, this.transform.angle), hr, Ue, ft, Zt.predicate);
+                if (Bt.box.length === 0) return;
+              }
+              if (Rt.box.length > 0) {
+                var Dt;
+                return this.prevPlacement && this.prevPlacement.variableOffsets[qt.crossTileID] && this.prevPlacement.placements[qt.crossTileID] && this.prevPlacement.placements[qt.crossTileID].text && (Dt = this.prevPlacement.variableOffsets[qt.crossTileID].anchor), this.variableOffsets[qt.crossTileID] = { textOffset: Ct, width: q, height: K, anchor: D, textBoxScale: de, prevAnchor: Dt }, this.markUsedJustification(Ve, D, qt, Qe), Ve.allowVerticalPlacement && (this.markUsedOrientation(Ve, Qe, qt), this.placedOrientations[qt.crossTileID] = Qe), { shift: Ot, placedGlyphBoxes: Rt };
+              }
+            }, bs.prototype.placeLayerBucketPart = function(D, J, q) {
+              var K = this, de = D.parameters, ne = de.bucket, we = de.layout, Ue = de.posMatrix, ft = de.textLabelPlaneMatrix, Zt = de.labelToScreenMatrix, hr = de.textPixelRatio, qt = de.holdingForFade, Ve = de.collisionBoxArray, Qe = de.partiallyEvaluatedTextSize, at = de.collisionGroup, Ct = we.get("text-optional"), Ot = we.get("icon-optional"), Rt = we.get("text-allow-overlap"), Bt = we.get("icon-allow-overlap"), Dt = we.get("text-rotation-alignment") === "map", yt = we.get("text-pitch-alignment") === "map", Pt = we.get("icon-text-fit") !== "none", ht = we.get("symbol-z-order") === "viewport-y", ur = Rt && (Bt || !ne.hasIconData() || Ot), br = Bt && (Rt || !ne.hasTextData() || Ct);
+              !ne.collisionArrays && Ve && ne.deserializeCollisionBoxes(Ve);
+              var Ur = function(Ci, Bi) {
+                if (!J[Ci.crossTileID]) {
+                  if (qt) {
+                    K.placements[Ci.crossTileID] = new zs(false, false, false);
+                    return;
+                  }
+                  var Gi = false, sn = false, zn = true, Ja = null, co = { box: null, offscreen: null }, ts = { box: null, offscreen: null }, so = null, Yo = null, ms = null, ou = 0, Cv = 0, Lv = 0;
+                  Bi.textFeatureIndex ? ou = Bi.textFeatureIndex : Ci.useRuntimeCollisionCircles && (ou = Ci.featureIndex), Bi.verticalTextFeatureIndex && (Cv = Bi.verticalTextFeatureIndex);
+                  var wd = Bi.textBox;
+                  if (wd) {
+                    var Kv = function(vc) {
+                      var tu = i.WritingMode.horizontal;
+                      if (ne.allowVerticalPlacement && !vc && K.prevPlacement) {
+                        var Sd = K.prevPlacement.placedOrientations[Ci.crossTileID];
+                        Sd && (K.placedOrientations[Ci.crossTileID] = Sd, tu = Sd, K.markUsedOrientation(ne, tu, Ci));
+                      }
+                      return tu;
+                    }, hg = function(vc, tu) {
+                      if (ne.allowVerticalPlacement && Ci.numVerticalGlyphVertices > 0 && Bi.verticalTextBox) for (var Sd = 0, vy = ne.writingModes; Sd < vy.length; Sd += 1) {
+                        var L1 = vy[Sd];
+                        if (L1 === i.WritingMode.vertical ? (co = tu(), ts = co) : co = vc(), co && co.box && co.box.length) break;
+                      }
+                      else co = vc();
+                    };
+                    if (we.get("text-variable-anchor")) {
+                      var Ud = we.get("text-variable-anchor");
+                      if (K.prevPlacement && K.prevPlacement.variableOffsets[Ci.crossTileID]) {
+                        var Ad = K.prevPlacement.variableOffsets[Ci.crossTileID];
+                        Ud.indexOf(Ad.anchor) > 0 && (Ud = Ud.filter(function(vc) {
+                          return vc !== Ad.anchor;
+                        }), Ud.unshift(Ad.anchor));
+                      }
+                      var Pv = function(vc, tu, Sd) {
+                        for (var vy = vc.x2 - vc.x1, L1 = vc.y2 - vc.y1, wu = Ci.textBoxScale, Yx = Pt && !Bt ? tu : null, lm = { box: [], offscreen: false }, Ow = Rt ? Ud.length * 2 : Ud.length, Rv = 0; Rv < Ow; ++Rv) {
+                          var um = Ud[Rv % Ud.length], qw = Rv >= Ud.length, Kx = K.attemptAnchorPlacement(um, vc, vy, L1, wu, Dt, yt, hr, Ue, at, qw, Ci, ne, Sd, Yx);
+                          if (Kx && (lm = Kx.placedGlyphBoxes, lm && lm.box && lm.box.length)) {
+                            Gi = true, Ja = Kx.shift;
+                            break;
+                          }
+                        }
+                        return lm;
+                      }, Jv = function() {
+                        return Pv(wd, Bi.iconBox, i.WritingMode.horizontal);
+                      }, Iv = function() {
+                        var vc = Bi.verticalTextBox, tu = co && co.box && co.box.length;
+                        return ne.allowVerticalPlacement && !tu && Ci.numVerticalGlyphVertices > 0 && vc ? Pv(vc, Bi.verticalIconBox, i.WritingMode.vertical) : { box: null, offscreen: null };
+                      };
+                      hg(Jv, Iv), co && (Gi = co.box, zn = co.offscreen);
+                      var fy = Kv(co && co.box);
+                      if (!Gi && K.prevPlacement) {
+                        var dg = K.prevPlacement.variableOffsets[Ci.crossTileID];
+                        dg && (K.variableOffsets[Ci.crossTileID] = dg, K.markUsedJustification(ne, dg.anchor, Ci, fy));
+                      }
+                    } else {
+                      var gp = function(vc, tu) {
+                        var Sd = K.collisionIndex.placeCollisionBox(vc, Rt, hr, Ue, at.predicate);
+                        return Sd && Sd.box && Sd.box.length && (K.markUsedOrientation(ne, tu, Ci), K.placedOrientations[Ci.crossTileID] = tu), Sd;
+                      }, Td = function() {
+                        return gp(wd, i.WritingMode.horizontal);
+                      }, mp = function() {
+                        var vc = Bi.verticalTextBox;
+                        return ne.allowVerticalPlacement && Ci.numVerticalGlyphVertices > 0 && vc ? gp(vc, i.WritingMode.vertical) : { box: null, offscreen: null };
+                      };
+                      hg(Td, mp), Kv(co && co.box && co.box.length);
+                    }
+                  }
+                  if (so = co, Gi = so && so.box && so.box.length > 0, zn = so && so.offscreen, Ci.useRuntimeCollisionCircles) {
+                    var oh = ne.text.placedSymbolArray.get(Ci.centerJustifiedTextSymbolIndex), vg = i.evaluateSizeForFeature(ne.textSizeData, Qe, oh), hy = we.get("text-padding"), Zh = Ci.collisionCircleDiameter;
+                    Yo = K.collisionIndex.placeCollisionCircles(Rt, oh, ne.lineVertexArray, ne.glyphOffsetArray, vg, Ue, ft, Zt, q, yt, at.predicate, Zh, hy), Gi = Rt || Yo.circles.length > 0 && !Yo.collisionDetected, zn = zn && Yo.offscreen;
+                  }
+                  if (Bi.iconFeatureIndex && (Lv = Bi.iconFeatureIndex), Bi.iconBox) {
+                    var am = function(vc) {
+                      var tu = Pt && Ja ? nc(vc, Ja.x, Ja.y, Dt, yt, K.transform.angle) : vc;
+                      return K.collisionIndex.placeCollisionBox(tu, Bt, hr, Ue, at.predicate);
+                    };
+                    ts && ts.box && ts.box.length && Bi.verticalIconBox ? (ms = am(Bi.verticalIconBox), sn = ms.box.length > 0) : (ms = am(Bi.iconBox), sn = ms.box.length > 0), zn = zn && ms.offscreen;
+                  }
+                  var k1 = Ct || Ci.numHorizontalGlyphVertices === 0 && Ci.numVerticalGlyphVertices === 0, C1 = Ot || Ci.numIconVertices === 0;
+                  if (!k1 && !C1 ? sn = Gi = sn && Gi : C1 ? k1 || (sn = sn && Gi) : Gi = sn && Gi, Gi && so && so.box && (ts && ts.box && Cv ? K.collisionIndex.insertCollisionBox(so.box, we.get("text-ignore-placement"), ne.bucketInstanceId, Cv, at.ID) : K.collisionIndex.insertCollisionBox(so.box, we.get("text-ignore-placement"), ne.bucketInstanceId, ou, at.ID)), sn && ms && K.collisionIndex.insertCollisionBox(ms.box, we.get("icon-ignore-placement"), ne.bucketInstanceId, Lv, at.ID), Yo && (Gi && K.collisionIndex.insertCollisionCircles(Yo.circles, we.get("text-ignore-placement"), ne.bucketInstanceId, ou, at.ID), q)) {
+                    var dy = ne.bucketInstanceId, om = K.collisionCircleArrays[dy];
+                    om === void 0 && (om = K.collisionCircleArrays[dy] = new Io());
+                    for (var sm = 0; sm < Yo.circles.length; sm += 4) om.circles.push(Yo.circles[sm + 0]), om.circles.push(Yo.circles[sm + 1]), om.circles.push(Yo.circles[sm + 2]), om.circles.push(Yo.collisionDetected ? 1 : 0);
+                  }
+                  K.placements[Ci.crossTileID] = new zs(Gi || ur, sn || br, zn || ne.justReloaded), J[Ci.crossTileID] = true;
+                }
+              };
+              if (ht) for (var Di = ne.getSortedSymbolIndexes(this.transform.angle), fi = Di.length - 1; fi >= 0; --fi) {
+                var Ti = Di[fi];
+                Ur(ne.symbolInstances.get(Ti), ne.collisionArrays[Ti]);
+              }
+              else for (var gn = D.symbolInstanceStart; gn < D.symbolInstanceEnd; gn++) Ur(ne.symbolInstances.get(gn), ne.collisionArrays[gn]);
+              if (q && ne.bucketInstanceId in this.collisionCircleArrays) {
+                var rn = this.collisionCircleArrays[ne.bucketInstanceId];
+                i.invert(rn.invProjMatrix, Ue), rn.viewportMatrix = this.collisionIndex.getViewportMatrix();
+              }
+              ne.justReloaded = false;
+            }, bs.prototype.markUsedJustification = function(D, J, q, K) {
+              var de = { left: q.leftJustifiedTextSymbolIndex, center: q.centerJustifiedTextSymbolIndex, right: q.rightJustifiedTextSymbolIndex }, ne;
+              K === i.WritingMode.vertical ? ne = q.verticalPlacedTextSymbolIndex : ne = de[i.getAnchorJustification(J)];
+              for (var we = [q.leftJustifiedTextSymbolIndex, q.centerJustifiedTextSymbolIndex, q.rightJustifiedTextSymbolIndex, q.verticalPlacedTextSymbolIndex], Ue = 0, ft = we; Ue < ft.length; Ue += 1) {
+                var Zt = ft[Ue];
+                Zt >= 0 && (ne >= 0 && Zt !== ne ? D.text.placedSymbolArray.get(Zt).crossTileID = 0 : D.text.placedSymbolArray.get(Zt).crossTileID = q.crossTileID);
+              }
+            }, bs.prototype.markUsedOrientation = function(D, J, q) {
+              for (var K = J === i.WritingMode.horizontal || J === i.WritingMode.horizontalOnly ? J : 0, de = J === i.WritingMode.vertical ? J : 0, ne = [q.leftJustifiedTextSymbolIndex, q.centerJustifiedTextSymbolIndex, q.rightJustifiedTextSymbolIndex], we = 0, Ue = ne; we < Ue.length; we += 1) {
+                var ft = Ue[we];
+                D.text.placedSymbolArray.get(ft).placedOrientation = K;
+              }
+              q.verticalPlacedTextSymbolIndex && (D.text.placedSymbolArray.get(q.verticalPlacedTextSymbolIndex).placedOrientation = de);
+            }, bs.prototype.commit = function(D) {
+              this.commitTime = D, this.zoomAtLastRecencyCheck = this.transform.zoom;
+              var J = this.prevPlacement, q = false;
+              this.prevZoomAdjustment = J ? J.zoomAdjustment(this.transform.zoom) : 0;
+              var K = J ? J.symbolFadeChange(D) : 1, de = J ? J.opacities : {}, ne = J ? J.variableOffsets : {}, we = J ? J.placedOrientations : {};
+              for (var Ue in this.placements) {
+                var ft = this.placements[Ue], Zt = de[Ue];
+                Zt ? (this.opacities[Ue] = new Ks(Zt, K, ft.text, ft.icon), q = q || ft.text !== Zt.text.placed || ft.icon !== Zt.icon.placed) : (this.opacities[Ue] = new Ks(null, K, ft.text, ft.icon, ft.skipFade), q = q || ft.text || ft.icon);
+              }
+              for (var hr in de) {
+                var qt = de[hr];
+                if (!this.opacities[hr]) {
+                  var Ve = new Ks(qt, K, false, false);
+                  Ve.isHidden() || (this.opacities[hr] = Ve, q = q || qt.text.placed || qt.icon.placed);
+                }
+              }
+              for (var Qe in ne) !this.variableOffsets[Qe] && this.opacities[Qe] && !this.opacities[Qe].isHidden() && (this.variableOffsets[Qe] = ne[Qe]);
+              for (var at in we) !this.placedOrientations[at] && this.opacities[at] && !this.opacities[at].isHidden() && (this.placedOrientations[at] = we[at]);
+              q ? this.lastPlacementChangeTime = D : typeof this.lastPlacementChangeTime != "number" && (this.lastPlacementChangeTime = J ? J.lastPlacementChangeTime : D);
+            }, bs.prototype.updateLayerOpacities = function(D, J) {
+              for (var q = {}, K = 0, de = J; K < de.length; K += 1) {
+                var ne = de[K], we = ne.getBucket(D);
+                we && ne.latestFeatureIndex && D.id === we.layerIds[0] && this.updateBucketOpacities(we, q, ne.collisionBoxArray);
+              }
+            }, bs.prototype.updateBucketOpacities = function(D, J, q) {
+              var K = this;
+              D.hasTextData() && D.text.opacityVertexArray.clear(), D.hasIconData() && D.icon.opacityVertexArray.clear(), D.hasIconCollisionBoxData() && D.iconCollisionBox.collisionVertexArray.clear(), D.hasTextCollisionBoxData() && D.textCollisionBox.collisionVertexArray.clear();
+              var de = D.layers[0].layout, ne = new Ks(null, 0, false, false, true), we = de.get("text-allow-overlap"), Ue = de.get("icon-allow-overlap"), ft = de.get("text-variable-anchor"), Zt = de.get("text-rotation-alignment") === "map", hr = de.get("text-pitch-alignment") === "map", qt = de.get("icon-text-fit") !== "none", Ve = new Ks(null, 0, we && (Ue || !D.hasIconData() || de.get("icon-optional")), Ue && (we || !D.hasTextData() || de.get("text-optional")), true);
+              !D.collisionArrays && q && (D.hasIconCollisionBoxData() || D.hasTextCollisionBoxData()) && D.deserializeCollisionBoxes(q);
+              for (var Qe = function(Rt, Bt, Dt) {
+                for (var yt = 0; yt < Bt / 4; yt++) Rt.opacityVertexArray.emplaceBack(Dt);
+              }, at = function(Rt) {
+                var Bt = D.symbolInstances.get(Rt), Dt = Bt.numHorizontalGlyphVertices, yt = Bt.numVerticalGlyphVertices, Pt = Bt.crossTileID, ht = J[Pt], ur = K.opacities[Pt];
+                ht ? ur = ne : ur || (ur = Ve, K.opacities[Pt] = ur), J[Pt] = true;
+                var br = Dt > 0 || yt > 0, Ur = Bt.numIconVertices > 0, Di = K.placedOrientations[Bt.crossTileID], fi = Di === i.WritingMode.vertical, Ti = Di === i.WritingMode.horizontal || Di === i.WritingMode.horizontalOnly;
+                if (br) {
+                  var gn = ac(ur.text), rn = fi ? aa : gn;
+                  Qe(D.text, Dt, rn);
+                  var Ci = Ti ? aa : gn;
+                  Qe(D.text, yt, Ci);
+                  var Bi = ur.text.isHidden();
+                  [Bt.rightJustifiedTextSymbolIndex, Bt.centerJustifiedTextSymbolIndex, Bt.leftJustifiedTextSymbolIndex].forEach(function(Lv) {
+                    Lv >= 0 && (D.text.placedSymbolArray.get(Lv).hidden = Bi || fi ? 1 : 0);
+                  }), Bt.verticalPlacedTextSymbolIndex >= 0 && (D.text.placedSymbolArray.get(Bt.verticalPlacedTextSymbolIndex).hidden = Bi || Ti ? 1 : 0);
+                  var Gi = K.variableOffsets[Bt.crossTileID];
+                  Gi && K.markUsedJustification(D, Gi.anchor, Bt, Di);
+                  var sn = K.placedOrientations[Bt.crossTileID];
+                  sn && (K.markUsedJustification(D, "left", Bt, sn), K.markUsedOrientation(D, sn, Bt));
+                }
+                if (Ur) {
+                  var zn = ac(ur.icon), Ja = !(qt && Bt.verticalPlacedIconSymbolIndex && fi);
+                  if (Bt.placedIconSymbolIndex >= 0) {
+                    var co = Ja ? zn : aa;
+                    Qe(D.icon, Bt.numIconVertices, co), D.icon.placedSymbolArray.get(Bt.placedIconSymbolIndex).hidden = ur.icon.isHidden();
+                  }
+                  if (Bt.verticalPlacedIconSymbolIndex >= 0) {
+                    var ts = Ja ? aa : zn;
+                    Qe(D.icon, Bt.numVerticalIconVertices, ts), D.icon.placedSymbolArray.get(Bt.verticalPlacedIconSymbolIndex).hidden = ur.icon.isHidden();
+                  }
+                }
+                if (D.hasIconCollisionBoxData() || D.hasTextCollisionBoxData()) {
+                  var so = D.collisionArrays[Rt];
+                  if (so) {
+                    var Yo = new i.Point(0, 0);
+                    if (so.textBox || so.verticalTextBox) {
+                      var ms = true;
+                      if (ft) {
+                        var ou = K.variableOffsets[Pt];
+                        ou ? (Yo = Su(ou.anchor, ou.width, ou.height, ou.textOffset, ou.textBoxScale), Zt && Yo._rotate(hr ? K.transform.angle : -K.transform.angle)) : ms = false;
+                      }
+                      so.textBox && Rn(D.textCollisionBox.collisionVertexArray, ur.text.placed, !ms || fi, Yo.x, Yo.y), so.verticalTextBox && Rn(D.textCollisionBox.collisionVertexArray, ur.text.placed, !ms || Ti, Yo.x, Yo.y);
+                    }
+                    var Cv = !!(!Ti && so.verticalIconBox);
+                    so.iconBox && Rn(D.iconCollisionBox.collisionVertexArray, ur.icon.placed, Cv, qt ? Yo.x : 0, qt ? Yo.y : 0), so.verticalIconBox && Rn(D.iconCollisionBox.collisionVertexArray, ur.icon.placed, !Cv, qt ? Yo.x : 0, qt ? Yo.y : 0);
+                  }
+                }
+              }, Ct = 0; Ct < D.symbolInstances.length; Ct++) at(Ct);
+              if (D.sortFeatures(this.transform.angle), this.retainedQueryData[D.bucketInstanceId] && (this.retainedQueryData[D.bucketInstanceId].featureSortOrder = D.featureSortOrder), D.hasTextData() && D.text.opacityVertexBuffer && D.text.opacityVertexBuffer.updateData(D.text.opacityVertexArray), D.hasIconData() && D.icon.opacityVertexBuffer && D.icon.opacityVertexBuffer.updateData(D.icon.opacityVertexArray), D.hasIconCollisionBoxData() && D.iconCollisionBox.collisionVertexBuffer && D.iconCollisionBox.collisionVertexBuffer.updateData(D.iconCollisionBox.collisionVertexArray), D.hasTextCollisionBoxData() && D.textCollisionBox.collisionVertexBuffer && D.textCollisionBox.collisionVertexBuffer.updateData(D.textCollisionBox.collisionVertexArray), D.bucketInstanceId in this.collisionCircleArrays) {
+                var Ot = this.collisionCircleArrays[D.bucketInstanceId];
+                D.placementInvProjMatrix = Ot.invProjMatrix, D.placementViewportMatrix = Ot.viewportMatrix, D.collisionCircleArray = Ot.circles, delete this.collisionCircleArrays[D.bucketInstanceId];
+              }
+            }, bs.prototype.symbolFadeChange = function(D) {
+              return this.fadeDuration === 0 ? 1 : (D - this.commitTime) / this.fadeDuration + this.prevZoomAdjustment;
+            }, bs.prototype.zoomAdjustment = function(D) {
+              return Math.max(0, (this.transform.zoom - D) / 1.5);
+            }, bs.prototype.hasTransitions = function(D) {
+              return this.stale || D - this.lastPlacementChangeTime < this.fadeDuration;
+            }, bs.prototype.stillRecent = function(D, J) {
+              var q = this.zoomAtLastRecencyCheck === J ? 1 - this.zoomAdjustment(J) : 1;
+              return this.zoomAtLastRecencyCheck = J, this.commitTime + this.fadeDuration * q > D;
+            }, bs.prototype.setStale = function() {
+              this.stale = true;
+            };
+            function Rn(Y, D, J, q, K) {
+              Y.emplaceBack(D ? 1 : 0, J ? 1 : 0, q || 0, K || 0), Y.emplaceBack(D ? 1 : 0, J ? 1 : 0, q || 0, K || 0), Y.emplaceBack(D ? 1 : 0, J ? 1 : 0, q || 0, K || 0), Y.emplaceBack(D ? 1 : 0, J ? 1 : 0, q || 0, K || 0);
+            }
+            var _a = Math.pow(2, 25), Vu = Math.pow(2, 24), Ol = Math.pow(2, 17), xo = Math.pow(2, 16), Kl = Math.pow(2, 9), Ns = Math.pow(2, 8), Hl = Math.pow(2, 1);
+            function ac(Y) {
+              if (Y.opacity === 0 && !Y.placed) return 0;
+              if (Y.opacity === 1 && Y.placed) return 4294967295;
+              var D = Y.placed ? 1 : 0, J = Math.floor(Y.opacity * 127);
+              return J * _a + D * Vu + J * Ol + D * xo + J * Kl + D * Ns + J * Hl + D;
+            }
+            var aa = 0, Oo = function(D) {
+              this._sortAcrossTiles = D.layout.get("symbol-z-order") !== "viewport-y" && D.layout.get("symbol-sort-key").constantOr(1) !== void 0, this._currentTileIndex = 0, this._currentPartIndex = 0, this._seenCrossTileIDs = {}, this._bucketParts = [];
+            };
+            Oo.prototype.continuePlacement = function(D, J, q, K, de) {
+              for (var ne = this._bucketParts; this._currentTileIndex < D.length; ) {
+                var we = D[this._currentTileIndex];
+                if (J.getBucketParts(ne, K, we, this._sortAcrossTiles), this._currentTileIndex++, de()) return true;
+              }
+              for (this._sortAcrossTiles && (this._sortAcrossTiles = false, ne.sort(function(ft, Zt) {
+                return ft.sortKey - Zt.sortKey;
+              })); this._currentPartIndex < ne.length; ) {
+                var Ue = ne[this._currentPartIndex];
+                if (J.placeLayerBucketPart(Ue, this._seenCrossTileIDs, q), this._currentPartIndex++, de()) return true;
+              }
+              return false;
+            };
+            var qo = function(D, J, q, K, de, ne, we) {
+              this.placement = new bs(D, de, ne, we), this._currentPlacementIndex = J.length - 1, this._forceFullPlacement = q, this._showCollisionBoxes = K, this._done = false;
+            };
+            qo.prototype.isDone = function() {
+              return this._done;
+            }, qo.prototype.continuePlacement = function(D, J, q) {
+              for (var K = this, de = i.browser.now(), ne = function() {
+                var hr = i.browser.now() - de;
+                return K._forceFullPlacement ? false : hr > 2;
+              }; this._currentPlacementIndex >= 0; ) {
+                var we = D[this._currentPlacementIndex], Ue = J[we], ft = this.placement.collisionIndex.transform.zoom;
+                if (Ue.type === "symbol" && (!Ue.minzoom || Ue.minzoom <= ft) && (!Ue.maxzoom || Ue.maxzoom > ft)) {
+                  this._inProgressLayer || (this._inProgressLayer = new Oo(Ue));
+                  var Zt = this._inProgressLayer.continuePlacement(q[Ue.source], this.placement, this._showCollisionBoxes, Ue, ne);
+                  if (Zt) return;
+                  delete this._inProgressLayer;
+                }
+                this._currentPlacementIndex--;
+              }
+              this._done = true;
+            }, qo.prototype.commit = function(D) {
+              return this.placement.commit(D), this.placement;
+            };
+            var ql = 512 / i.EXTENT / 2, Pc = function(D, J, q) {
+              this.tileID = D, this.indexedSymbolInstances = {}, this.bucketInstanceId = q;
+              for (var K = 0; K < J.length; K++) {
+                var de = J.get(K), ne = de.key;
+                this.indexedSymbolInstances[ne] || (this.indexedSymbolInstances[ne] = []), this.indexedSymbolInstances[ne].push({ crossTileID: de.crossTileID, coord: this.getScaledCoordinates(de, D) });
+              }
+            };
+            Pc.prototype.getScaledCoordinates = function(D, J) {
+              var q = J.canonical.z - this.tileID.canonical.z, K = ql / Math.pow(2, q);
+              return { x: Math.floor((J.canonical.x * i.EXTENT + D.anchorX) * K), y: Math.floor((J.canonical.y * i.EXTENT + D.anchorY) * K) };
+            }, Pc.prototype.findMatches = function(D, J, q) {
+              for (var K = this.tileID.canonical.z < J.canonical.z ? 1 : Math.pow(2, this.tileID.canonical.z - J.canonical.z), de = 0; de < D.length; de++) {
+                var ne = D.get(de);
+                if (!ne.crossTileID) {
+                  var we = this.indexedSymbolInstances[ne.key];
+                  if (we) for (var Ue = this.getScaledCoordinates(ne, J), ft = 0, Zt = we; ft < Zt.length; ft += 1) {
+                    var hr = Zt[ft];
+                    if (Math.abs(hr.coord.x - Ue.x) <= K && Math.abs(hr.coord.y - Ue.y) <= K && !q[hr.crossTileID]) {
+                      q[hr.crossTileID] = true, ne.crossTileID = hr.crossTileID;
+                      break;
+                    }
+                  }
+                }
+              }
+            };
+            var Do = function() {
+              this.maxCrossTileID = 0;
+            };
+            Do.prototype.generate = function() {
+              return ++this.maxCrossTileID;
+            };
+            var rf = function() {
+              this.indexes = {}, this.usedCrossTileIDs = {}, this.lng = 0;
+            };
+            rf.prototype.handleWrapJump = function(D) {
+              var J = Math.round((D - this.lng) / 360);
+              if (J !== 0) for (var q in this.indexes) {
+                var K = this.indexes[q], de = {};
+                for (var ne in K) {
+                  var we = K[ne];
+                  we.tileID = we.tileID.unwrapTo(we.tileID.wrap + J), de[we.tileID.key] = we;
+                }
+                this.indexes[q] = de;
+              }
+              this.lng = D;
+            }, rf.prototype.addBucket = function(D, J, q) {
+              if (this.indexes[D.overscaledZ] && this.indexes[D.overscaledZ][D.key]) {
+                if (this.indexes[D.overscaledZ][D.key].bucketInstanceId === J.bucketInstanceId) return false;
+                this.removeBucketCrossTileIDs(D.overscaledZ, this.indexes[D.overscaledZ][D.key]);
+              }
+              for (var K = 0; K < J.symbolInstances.length; K++) {
+                var de = J.symbolInstances.get(K);
+                de.crossTileID = 0;
+              }
+              this.usedCrossTileIDs[D.overscaledZ] || (this.usedCrossTileIDs[D.overscaledZ] = {});
+              var ne = this.usedCrossTileIDs[D.overscaledZ];
+              for (var we in this.indexes) {
+                var Ue = this.indexes[we];
+                if (Number(we) > D.overscaledZ) for (var ft in Ue) {
+                  var Zt = Ue[ft];
+                  Zt.tileID.isChildOf(D) && Zt.findMatches(J.symbolInstances, D, ne);
+                }
+                else {
+                  var hr = D.scaledTo(Number(we)), qt = Ue[hr.key];
+                  qt && qt.findMatches(J.symbolInstances, D, ne);
+                }
+              }
+              for (var Ve = 0; Ve < J.symbolInstances.length; Ve++) {
+                var Qe = J.symbolInstances.get(Ve);
+                Qe.crossTileID || (Qe.crossTileID = q.generate(), ne[Qe.crossTileID] = true);
+              }
+              return this.indexes[D.overscaledZ] === void 0 && (this.indexes[D.overscaledZ] = {}), this.indexes[D.overscaledZ][D.key] = new Pc(D, J.symbolInstances, J.bucketInstanceId), true;
+            }, rf.prototype.removeBucketCrossTileIDs = function(D, J) {
+              for (var q in J.indexedSymbolInstances) for (var K = 0, de = J.indexedSymbolInstances[q]; K < de.length; K += 1) {
+                var ne = de[K];
+                delete this.usedCrossTileIDs[D][ne.crossTileID];
+              }
+            }, rf.prototype.removeStaleBuckets = function(D) {
+              var J = false;
+              for (var q in this.indexes) {
+                var K = this.indexes[q];
+                for (var de in K) D[K[de].bucketInstanceId] || (this.removeBucketCrossTileIDs(q, K[de]), delete K[de], J = true);
+              }
+              return J;
+            };
+            var Vf = function() {
+              this.layerIndexes = {}, this.crossTileIDs = new Do(), this.maxBucketInstanceId = 0, this.bucketsInCurrentPlacement = {};
+            };
+            Vf.prototype.addLayer = function(D, J, q) {
+              var K = this.layerIndexes[D.id];
+              K === void 0 && (K = this.layerIndexes[D.id] = new rf());
+              var de = false, ne = {};
+              K.handleWrapJump(q);
+              for (var we = 0, Ue = J; we < Ue.length; we += 1) {
+                var ft = Ue[we], Zt = ft.getBucket(D);
+                !Zt || D.id !== Zt.layerIds[0] || (Zt.bucketInstanceId || (Zt.bucketInstanceId = ++this.maxBucketInstanceId), K.addBucket(ft.tileID, Zt, this.crossTileIDs) && (de = true), ne[Zt.bucketInstanceId] = true);
+              }
+              return K.removeStaleBuckets(ne) && (de = true), de;
+            }, Vf.prototype.pruneUnusedLayers = function(D) {
+              var J = {};
+              D.forEach(function(K) {
+                J[K] = true;
+              });
+              for (var q in this.layerIndexes) J[q] || delete this.layerIndexes[q];
+            };
+            var pl = function(Y, D) {
+              return i.emitValidationErrors(Y, D && D.filter(function(J) {
+                return J.identifier !== "source.canvas";
+              }));
+            }, Zc = i.pick(da, ["addLayer", "removeLayer", "setPaintProperty", "setLayoutProperty", "setFilter", "addSource", "removeSource", "setLayerZoomRange", "setLight", "setTransition", "setGeoJSONSourceData"]), Jl = i.pick(da, ["setCenter", "setZoom", "setBearing", "setPitch"]), Os = Xo(), yu = function(Y) {
+              function D(J, q) {
+                var K = this;
+                q === void 0 && (q = {}), Y.call(this), this.map = J, this.dispatcher = new Z(Ba(), this), this.imageManager = new k(), this.imageManager.setEventedParent(this), this.glyphManager = new P(J._requestManager, q.localIdeographFontFamily), this.lineAtlas = new G(256, 512), this.crossTileSymbolIndex = new Vf(), this._layers = {}, this._serializedLayers = {}, this._order = [], this.sourceCaches = {}, this.zoomHistory = new i.ZoomHistory(), this._loaded = false, this._availableImages = [], this._resetUpdates(), this.dispatcher.broadcast("setReferrer", i.getReferrer());
+                var de = this;
+                this._rtlTextPluginCallback = D.registerForPluginStateChange(function(ne) {
+                  var we = { pluginStatus: ne.pluginStatus, pluginURL: ne.pluginURL };
+                  de.dispatcher.broadcast("syncRTLPluginState", we, function(Ue, ft) {
+                    if (i.triggerPluginCompletionEvent(Ue), ft) {
+                      var Zt = ft.every(function(qt) {
+                        return qt;
+                      });
+                      if (Zt) for (var hr in de.sourceCaches) de.sourceCaches[hr].reload();
+                    }
+                  });
+                }), this.on("data", function(ne) {
+                  if (!(ne.dataType !== "source" || ne.sourceDataType !== "metadata")) {
+                    var we = K.sourceCaches[ne.sourceId];
+                    if (we) {
+                      var Ue = we.getSource();
+                      if (!(!Ue || !Ue.vectorLayerIds)) for (var ft in K._layers) {
+                        var Zt = K._layers[ft];
+                        Zt.source === Ue.id && K._validateLayer(Zt);
+                      }
+                    }
+                  }
+                });
+              }
+              return Y && (D.__proto__ = Y), D.prototype = Object.create(Y && Y.prototype), D.prototype.constructor = D, D.prototype.loadURL = function(q, K) {
+                var de = this;
+                K === void 0 && (K = {}), this.fire(new i.Event("dataloading", { dataType: "style" }));
+                var ne = typeof K.validate == "boolean" ? K.validate : !i.isMapboxURL(q);
+                q = this.map._requestManager.normalizeStyleURL(q, K.accessToken);
+                var we = this.map._requestManager.transformRequest(q, i.ResourceType.Style);
+                this._request = i.getJSON(we, function(Ue, ft) {
+                  de._request = null, Ue ? de.fire(new i.ErrorEvent(Ue)) : ft && de._load(ft, ne);
+                });
+              }, D.prototype.loadJSON = function(q, K) {
+                var de = this;
+                K === void 0 && (K = {}), this.fire(new i.Event("dataloading", { dataType: "style" })), this._request = i.browser.frame(function() {
+                  de._request = null, de._load(q, K.validate !== false);
+                });
+              }, D.prototype.loadEmpty = function() {
+                this.fire(new i.Event("dataloading", { dataType: "style" })), this._load(Os, false);
+              }, D.prototype._load = function(q, K) {
+                if (!(K && pl(this, i.validateStyle(q)))) {
+                  this._loaded = true, this.stylesheet = q;
+                  for (var de in q.sources) this.addSource(de, q.sources[de], { validate: false });
+                  q.sprite ? this._loadSprite(q.sprite) : this.imageManager.setLoaded(true), this.glyphManager.setURL(q.glyphs);
+                  var ne = Fa(this.stylesheet.layers);
+                  this._order = ne.map(function(Zt) {
+                    return Zt.id;
+                  }), this._layers = {}, this._serializedLayers = {};
+                  for (var we = 0, Ue = ne; we < Ue.length; we += 1) {
+                    var ft = Ue[we];
+                    ft = i.createStyleLayer(ft), ft.setEventedParent(this, { layer: { id: ft.id } }), this._layers[ft.id] = ft, this._serializedLayers[ft.id] = ft.serialize();
+                  }
+                  this.dispatcher.broadcast("setLayers", this._serializeLayers(this._order)), this.light = new U(this.stylesheet.light), this.fire(new i.Event("data", { dataType: "style" })), this.fire(new i.Event("style.load"));
+                }
+              }, D.prototype._loadSprite = function(q) {
+                var K = this;
+                this._spriteRequest = _(q, this.map._requestManager, function(de, ne) {
+                  if (K._spriteRequest = null, de) K.fire(new i.ErrorEvent(de));
+                  else if (ne) for (var we in ne) K.imageManager.addImage(we, ne[we]);
+                  K.imageManager.setLoaded(true), K._availableImages = K.imageManager.listImages(), K.dispatcher.broadcast("setImages", K._availableImages), K.fire(new i.Event("data", { dataType: "style" }));
+                });
+              }, D.prototype._validateLayer = function(q) {
+                var K = this.sourceCaches[q.source];
+                if (K) {
+                  var de = q.sourceLayer;
+                  if (de) {
+                    var ne = K.getSource();
+                    (ne.type === "geojson" || ne.vectorLayerIds && ne.vectorLayerIds.indexOf(de) === -1) && this.fire(new i.ErrorEvent(new Error('Source layer "' + de + '" does not exist on source "' + ne.id + '" as specified by style layer "' + q.id + '"')));
+                  }
+                }
+              }, D.prototype.loaded = function() {
+                if (!this._loaded || Object.keys(this._updatedSources).length) return false;
+                for (var q in this.sourceCaches) if (!this.sourceCaches[q].loaded()) return false;
+                return !!this.imageManager.isLoaded();
+              }, D.prototype._serializeLayers = function(q) {
+                for (var K = [], de = 0, ne = q; de < ne.length; de += 1) {
+                  var we = ne[de], Ue = this._layers[we];
+                  Ue.type !== "custom" && K.push(Ue.serialize());
+                }
+                return K;
+              }, D.prototype.hasTransitions = function() {
+                if (this.light && this.light.hasTransition()) return true;
+                for (var q in this.sourceCaches) if (this.sourceCaches[q].hasTransition()) return true;
+                for (var K in this._layers) if (this._layers[K].hasTransition()) return true;
+                return false;
+              }, D.prototype._checkLoaded = function() {
+                if (!this._loaded) throw new Error("Style is not done loading");
+              }, D.prototype.update = function(q) {
+                if (this._loaded) {
+                  var K = this._changed;
+                  if (this._changed) {
+                    var de = Object.keys(this._updatedLayers), ne = Object.keys(this._removedLayers);
+                    (de.length || ne.length) && this._updateWorkerLayers(de, ne);
+                    for (var we in this._updatedSources) {
+                      var Ue = this._updatedSources[we];
+                      Ue === "reload" ? this._reloadSource(we) : Ue === "clear" && this._clearSource(we);
+                    }
+                    this._updateTilesForChangedImages();
+                    for (var ft in this._updatedPaintProps) this._layers[ft].updateTransitions(q);
+                    this.light.updateTransitions(q), this._resetUpdates();
+                  }
+                  var Zt = {};
+                  for (var hr in this.sourceCaches) {
+                    var qt = this.sourceCaches[hr];
+                    Zt[hr] = qt.used, qt.used = false;
+                  }
+                  for (var Ve = 0, Qe = this._order; Ve < Qe.length; Ve += 1) {
+                    var at = Qe[Ve], Ct = this._layers[at];
+                    Ct.recalculate(q, this._availableImages), !Ct.isHidden(q.zoom) && Ct.source && (this.sourceCaches[Ct.source].used = true);
+                  }
+                  for (var Ot in Zt) {
+                    var Rt = this.sourceCaches[Ot];
+                    Zt[Ot] !== Rt.used && Rt.fire(new i.Event("data", { sourceDataType: "visibility", dataType: "source", sourceId: Ot }));
+                  }
+                  this.light.recalculate(q), this.z = q.zoom, K && this.fire(new i.Event("data", { dataType: "style" }));
+                }
+              }, D.prototype._updateTilesForChangedImages = function() {
+                var q = Object.keys(this._changedImages);
+                if (q.length) {
+                  for (var K in this.sourceCaches) this.sourceCaches[K].reloadTilesForDependencies(["icons", "patterns"], q);
+                  this._changedImages = {};
+                }
+              }, D.prototype._updateWorkerLayers = function(q, K) {
+                this.dispatcher.broadcast("updateLayers", { layers: this._serializeLayers(q), removedIds: K });
+              }, D.prototype._resetUpdates = function() {
+                this._changed = false, this._updatedLayers = {}, this._removedLayers = {}, this._updatedSources = {}, this._updatedPaintProps = {}, this._changedImages = {};
+              }, D.prototype.setState = function(q) {
+                var K = this;
+                if (this._checkLoaded(), pl(this, i.validateStyle(q))) return false;
+                q = i.clone$1(q), q.layers = Fa(q.layers);
+                var de = An(this.serialize(), q).filter(function(we) {
+                  return !(we.command in Jl);
+                });
+                if (de.length === 0) return false;
+                var ne = de.filter(function(we) {
+                  return !(we.command in Zc);
+                });
+                if (ne.length > 0) throw new Error("Unimplemented: " + ne.map(function(we) {
+                  return we.command;
+                }).join(", ") + ".");
+                return de.forEach(function(we) {
+                  we.command !== "setTransition" && K[we.command].apply(K, we.args);
+                }), this.stylesheet = q, true;
+              }, D.prototype.addImage = function(q, K) {
+                if (this.getImage(q)) return this.fire(new i.ErrorEvent(new Error("An image with this name already exists.")));
+                this.imageManager.addImage(q, K), this._afterImageUpdated(q);
+              }, D.prototype.updateImage = function(q, K) {
+                this.imageManager.updateImage(q, K);
+              }, D.prototype.getImage = function(q) {
+                return this.imageManager.getImage(q);
+              }, D.prototype.removeImage = function(q) {
+                if (!this.getImage(q)) return this.fire(new i.ErrorEvent(new Error("No image with this name exists.")));
+                this.imageManager.removeImage(q), this._afterImageUpdated(q);
+              }, D.prototype._afterImageUpdated = function(q) {
+                this._availableImages = this.imageManager.listImages(), this._changedImages[q] = true, this._changed = true, this.dispatcher.broadcast("setImages", this._availableImages), this.fire(new i.Event("data", { dataType: "style" }));
+              }, D.prototype.listImages = function() {
+                return this._checkLoaded(), this.imageManager.listImages();
+              }, D.prototype.addSource = function(q, K, de) {
+                var ne = this;
+                if (de === void 0 && (de = {}), this._checkLoaded(), this.sourceCaches[q] !== void 0) throw new Error("There is already a source with this ID");
+                if (!K.type) throw new Error("The type property must be defined, but only the following properties were given: " + Object.keys(K).join(", ") + ".");
+                var we = ["vector", "raster", "geojson", "video", "image"], Ue = we.indexOf(K.type) >= 0;
+                if (!(Ue && this._validate(i.validateStyle.source, "sources." + q, K, null, de))) {
+                  this.map && this.map._collectResourceTiming && (K.collectResourceTiming = true);
+                  var ft = this.sourceCaches[q] = new ri(q, K, this.dispatcher);
+                  ft.style = this, ft.setEventedParent(this, function() {
+                    return { isSourceLoaded: ne.loaded(), source: ft.serialize(), sourceId: q };
+                  }), ft.onAdd(this.map), this._changed = true;
+                }
+              }, D.prototype.removeSource = function(q) {
+                if (this._checkLoaded(), this.sourceCaches[q] === void 0) throw new Error("There is no source with this ID");
+                for (var K in this._layers) if (this._layers[K].source === q) return this.fire(new i.ErrorEvent(new Error('Source "' + q + '" cannot be removed while layer "' + K + '" is using it.')));
+                var de = this.sourceCaches[q];
+                delete this.sourceCaches[q], delete this._updatedSources[q], de.fire(new i.Event("data", { sourceDataType: "metadata", dataType: "source", sourceId: q })), de.setEventedParent(null), de.clearTiles(), de.onRemove && de.onRemove(this.map), this._changed = true;
+              }, D.prototype.setGeoJSONSourceData = function(q, K) {
+                this._checkLoaded();
+                var de = this.sourceCaches[q].getSource();
+                de.setData(K), this._changed = true;
+              }, D.prototype.getSource = function(q) {
+                return this.sourceCaches[q] && this.sourceCaches[q].getSource();
+              }, D.prototype.addLayer = function(q, K, de) {
+                de === void 0 && (de = {}), this._checkLoaded();
+                var ne = q.id;
+                if (this.getLayer(ne)) {
+                  this.fire(new i.ErrorEvent(new Error('Layer with id "' + ne + '" already exists on this map')));
+                  return;
+                }
+                var we;
+                if (q.type === "custom") {
+                  if (pl(this, i.validateCustomStyleLayer(q))) return;
+                  we = i.createStyleLayer(q);
+                } else {
+                  if (typeof q.source == "object" && (this.addSource(ne, q.source), q = i.clone$1(q), q = i.extend(q, { source: ne })), this._validate(i.validateStyle.layer, "layers." + ne, q, { arrayIndex: -1 }, de)) return;
+                  we = i.createStyleLayer(q), this._validateLayer(we), we.setEventedParent(this, { layer: { id: ne } }), this._serializedLayers[we.id] = we.serialize();
+                }
+                var Ue = K ? this._order.indexOf(K) : this._order.length;
+                if (K && Ue === -1) {
+                  this.fire(new i.ErrorEvent(new Error('Layer with id "' + K + '" does not exist on this map.')));
+                  return;
+                }
+                if (this._order.splice(Ue, 0, ne), this._layerOrderChanged = true, this._layers[ne] = we, this._removedLayers[ne] && we.source && we.type !== "custom") {
+                  var ft = this._removedLayers[ne];
+                  delete this._removedLayers[ne], ft.type !== we.type ? this._updatedSources[we.source] = "clear" : (this._updatedSources[we.source] = "reload", this.sourceCaches[we.source].pause());
+                }
+                this._updateLayer(we), we.onAdd && we.onAdd(this.map);
+              }, D.prototype.moveLayer = function(q, K) {
+                this._checkLoaded(), this._changed = true;
+                var de = this._layers[q];
+                if (!de) {
+                  this.fire(new i.ErrorEvent(new Error("The layer '" + q + "' does not exist in the map's style and cannot be moved.")));
+                  return;
+                }
+                if (q !== K) {
+                  var ne = this._order.indexOf(q);
+                  this._order.splice(ne, 1);
+                  var we = K ? this._order.indexOf(K) : this._order.length;
+                  if (K && we === -1) {
+                    this.fire(new i.ErrorEvent(new Error('Layer with id "' + K + '" does not exist on this map.')));
+                    return;
+                  }
+                  this._order.splice(we, 0, q), this._layerOrderChanged = true;
+                }
+              }, D.prototype.removeLayer = function(q) {
+                this._checkLoaded();
+                var K = this._layers[q];
+                if (!K) {
+                  this.fire(new i.ErrorEvent(new Error("The layer '" + q + "' does not exist in the map's style and cannot be removed.")));
+                  return;
+                }
+                K.setEventedParent(null);
+                var de = this._order.indexOf(q);
+                this._order.splice(de, 1), this._layerOrderChanged = true, this._changed = true, this._removedLayers[q] = K, delete this._layers[q], delete this._serializedLayers[q], delete this._updatedLayers[q], delete this._updatedPaintProps[q], K.onRemove && K.onRemove(this.map);
+              }, D.prototype.getLayer = function(q) {
+                return this._layers[q];
+              }, D.prototype.hasLayer = function(q) {
+                return q in this._layers;
+              }, D.prototype.setLayerZoomRange = function(q, K, de) {
+                this._checkLoaded();
+                var ne = this.getLayer(q);
+                if (!ne) {
+                  this.fire(new i.ErrorEvent(new Error("The layer '" + q + "' does not exist in the map's style and cannot have zoom extent.")));
+                  return;
+                }
+                ne.minzoom === K && ne.maxzoom === de || (K != null && (ne.minzoom = K), de != null && (ne.maxzoom = de), this._updateLayer(ne));
+              }, D.prototype.setFilter = function(q, K, de) {
+                de === void 0 && (de = {}), this._checkLoaded();
+                var ne = this.getLayer(q);
+                if (!ne) {
+                  this.fire(new i.ErrorEvent(new Error("The layer '" + q + "' does not exist in the map's style and cannot be filtered.")));
+                  return;
+                }
+                if (!i.deepEqual(ne.filter, K)) {
+                  if (K == null) {
+                    ne.filter = void 0, this._updateLayer(ne);
+                    return;
+                  }
+                  this._validate(i.validateStyle.filter, "layers." + ne.id + ".filter", K, null, de) || (ne.filter = i.clone$1(K), this._updateLayer(ne));
+                }
+              }, D.prototype.getFilter = function(q) {
+                return i.clone$1(this.getLayer(q).filter);
+              }, D.prototype.setLayoutProperty = function(q, K, de, ne) {
+                ne === void 0 && (ne = {}), this._checkLoaded();
+                var we = this.getLayer(q);
+                if (!we) {
+                  this.fire(new i.ErrorEvent(new Error("The layer '" + q + "' does not exist in the map's style and cannot be styled.")));
+                  return;
+                }
+                i.deepEqual(we.getLayoutProperty(K), de) || (we.setLayoutProperty(K, de, ne), this._updateLayer(we));
+              }, D.prototype.getLayoutProperty = function(q, K) {
+                var de = this.getLayer(q);
+                if (!de) {
+                  this.fire(new i.ErrorEvent(new Error("The layer '" + q + "' does not exist in the map's style.")));
+                  return;
+                }
+                return de.getLayoutProperty(K);
+              }, D.prototype.setPaintProperty = function(q, K, de, ne) {
+                ne === void 0 && (ne = {}), this._checkLoaded();
+                var we = this.getLayer(q);
+                if (!we) {
+                  this.fire(new i.ErrorEvent(new Error("The layer '" + q + "' does not exist in the map's style and cannot be styled.")));
+                  return;
+                }
+                if (!i.deepEqual(we.getPaintProperty(K), de)) {
+                  var Ue = we.setPaintProperty(K, de, ne);
+                  Ue && this._updateLayer(we), this._changed = true, this._updatedPaintProps[q] = true;
+                }
+              }, D.prototype.getPaintProperty = function(q, K) {
+                return this.getLayer(q).getPaintProperty(K);
+              }, D.prototype.setFeatureState = function(q, K) {
+                this._checkLoaded();
+                var de = q.source, ne = q.sourceLayer, we = this.sourceCaches[de];
+                if (we === void 0) {
+                  this.fire(new i.ErrorEvent(new Error("The source '" + de + "' does not exist in the map's style.")));
+                  return;
+                }
+                var Ue = we.getSource().type;
+                if (Ue === "geojson" && ne) {
+                  this.fire(new i.ErrorEvent(new Error("GeoJSON sources cannot have a sourceLayer parameter.")));
+                  return;
+                }
+                if (Ue === "vector" && !ne) {
+                  this.fire(new i.ErrorEvent(new Error("The sourceLayer parameter must be provided for vector source types.")));
+                  return;
+                }
+                q.id === void 0 && this.fire(new i.ErrorEvent(new Error("The feature id parameter must be provided."))), we.setFeatureState(ne, q.id, K);
+              }, D.prototype.removeFeatureState = function(q, K) {
+                this._checkLoaded();
+                var de = q.source, ne = this.sourceCaches[de];
+                if (ne === void 0) {
+                  this.fire(new i.ErrorEvent(new Error("The source '" + de + "' does not exist in the map's style.")));
+                  return;
+                }
+                var we = ne.getSource().type, Ue = we === "vector" ? q.sourceLayer : void 0;
+                if (we === "vector" && !Ue) {
+                  this.fire(new i.ErrorEvent(new Error("The sourceLayer parameter must be provided for vector source types.")));
+                  return;
+                }
+                if (K && typeof q.id != "string" && typeof q.id != "number") {
+                  this.fire(new i.ErrorEvent(new Error("A feature id is required to remove its specific state property.")));
+                  return;
+                }
+                ne.removeFeatureState(Ue, q.id, K);
+              }, D.prototype.getFeatureState = function(q) {
+                this._checkLoaded();
+                var K = q.source, de = q.sourceLayer, ne = this.sourceCaches[K];
+                if (ne === void 0) {
+                  this.fire(new i.ErrorEvent(new Error("The source '" + K + "' does not exist in the map's style.")));
+                  return;
+                }
+                var we = ne.getSource().type;
+                if (we === "vector" && !de) {
+                  this.fire(new i.ErrorEvent(new Error("The sourceLayer parameter must be provided for vector source types.")));
+                  return;
+                }
+                return q.id === void 0 && this.fire(new i.ErrorEvent(new Error("The feature id parameter must be provided."))), ne.getFeatureState(de, q.id);
+              }, D.prototype.getTransition = function() {
+                return i.extend({ duration: 300, delay: 0 }, this.stylesheet && this.stylesheet.transition);
+              }, D.prototype.serialize = function() {
+                return i.filterObject({ version: this.stylesheet.version, name: this.stylesheet.name, metadata: this.stylesheet.metadata, light: this.stylesheet.light, center: this.stylesheet.center, zoom: this.stylesheet.zoom, bearing: this.stylesheet.bearing, pitch: this.stylesheet.pitch, sprite: this.stylesheet.sprite, glyphs: this.stylesheet.glyphs, transition: this.stylesheet.transition, sources: i.mapObject(this.sourceCaches, function(q) {
+                  return q.serialize();
+                }), layers: this._serializeLayers(this._order) }, function(q) {
+                  return q !== void 0;
+                });
+              }, D.prototype._updateLayer = function(q) {
+                this._updatedLayers[q.id] = true, q.source && !this._updatedSources[q.source] && this.sourceCaches[q.source].getSource().type !== "raster" && (this._updatedSources[q.source] = "reload", this.sourceCaches[q.source].pause()), this._changed = true;
+              }, D.prototype._flattenAndSortRenderedFeatures = function(q) {
+                for (var K = this, de = function(Ti) {
+                  return K._layers[Ti].type === "fill-extrusion";
+                }, ne = {}, we = [], Ue = this._order.length - 1; Ue >= 0; Ue--) {
+                  var ft = this._order[Ue];
+                  if (de(ft)) {
+                    ne[ft] = Ue;
+                    for (var Zt = 0, hr = q; Zt < hr.length; Zt += 1) {
+                      var qt = hr[Zt], Ve = qt[ft];
+                      if (Ve) for (var Qe = 0, at = Ve; Qe < at.length; Qe += 1) {
+                        var Ct = at[Qe];
+                        we.push(Ct);
+                      }
+                    }
+                  }
+                }
+                we.sort(function(Ti, gn) {
+                  return gn.intersectionZ - Ti.intersectionZ;
+                });
+                for (var Ot = [], Rt = this._order.length - 1; Rt >= 0; Rt--) {
+                  var Bt = this._order[Rt];
+                  if (de(Bt)) for (var Dt = we.length - 1; Dt >= 0; Dt--) {
+                    var yt = we[Dt].feature;
+                    if (ne[yt.layer.id] < Rt) break;
+                    Ot.push(yt), we.pop();
+                  }
+                  else for (var Pt = 0, ht = q; Pt < ht.length; Pt += 1) {
+                    var ur = ht[Pt], br = ur[Bt];
+                    if (br) for (var Ur = 0, Di = br; Ur < Di.length; Ur += 1) {
+                      var fi = Di[Ur];
+                      Ot.push(fi.feature);
+                    }
+                  }
+                }
+                return Ot;
+              }, D.prototype.queryRenderedFeatures = function(q, K, de) {
+                K && K.filter && this._validate(i.validateStyle.filter, "queryRenderedFeatures.filter", K.filter, null, K);
+                var ne = {};
+                if (K && K.layers) {
+                  if (!Array.isArray(K.layers)) return this.fire(new i.ErrorEvent(new Error("parameters.layers must be an Array."))), [];
+                  for (var we = 0, Ue = K.layers; we < Ue.length; we += 1) {
+                    var ft = Ue[we], Zt = this._layers[ft];
+                    if (!Zt) return this.fire(new i.ErrorEvent(new Error("The layer '" + ft + "' does not exist in the map's style and cannot be queried for features."))), [];
+                    ne[Zt.source] = true;
+                  }
+                }
+                var hr = [];
+                K.availableImages = this._availableImages;
+                for (var qt in this.sourceCaches) K.layers && !ne[qt] || hr.push(ce(this.sourceCaches[qt], this._layers, this._serializedLayers, q, K, de));
+                return this.placement && hr.push(je(this._layers, this._serializedLayers, this.sourceCaches, q, K, this.placement.collisionIndex, this.placement.retainedQueryData)), this._flattenAndSortRenderedFeatures(hr);
+              }, D.prototype.querySourceFeatures = function(q, K) {
+                K && K.filter && this._validate(i.validateStyle.filter, "querySourceFeatures.filter", K.filter, null, K);
+                var de = this.sourceCaches[q];
+                return de ? lt(de, K) : [];
+              }, D.prototype.addSourceType = function(q, K, de) {
+                if (D.getSourceType(q)) return de(new Error('A source type called "' + q + '" already exists.'));
+                if (D.setSourceType(q, K), !K.workerSourceURL) return de(null, null);
+                this.dispatcher.broadcast("loadWorkerSource", { name: q, url: K.workerSourceURL }, de);
+              }, D.prototype.getLight = function() {
+                return this.light.getLight();
+              }, D.prototype.setLight = function(q, K) {
+                K === void 0 && (K = {}), this._checkLoaded();
+                var de = this.light.getLight(), ne = false;
+                for (var we in q) if (!i.deepEqual(q[we], de[we])) {
+                  ne = true;
+                  break;
+                }
+                if (ne) {
+                  var Ue = { now: i.browser.now(), transition: i.extend({ duration: 300, delay: 0 }, this.stylesheet.transition) };
+                  this.light.setLight(q, K), this.light.updateTransitions(Ue);
+                }
+              }, D.prototype._validate = function(q, K, de, ne, we) {
+                return we === void 0 && (we = {}), we && we.validate === false ? false : pl(this, q.call(i.validateStyle, i.extend({ key: K, style: this.serialize(), value: de, styleSpec: i.styleSpec }, ne)));
+              }, D.prototype._remove = function() {
+                this._request && (this._request.cancel(), this._request = null), this._spriteRequest && (this._spriteRequest.cancel(), this._spriteRequest = null), i.evented.off("pluginStateChange", this._rtlTextPluginCallback);
+                for (var q in this._layers) {
+                  var K = this._layers[q];
+                  K.setEventedParent(null);
+                }
+                for (var de in this.sourceCaches) this.sourceCaches[de].clearTiles(), this.sourceCaches[de].setEventedParent(null);
+                this.imageManager.setEventedParent(null), this.setEventedParent(null), this.dispatcher.remove();
+              }, D.prototype._clearSource = function(q) {
+                this.sourceCaches[q].clearTiles();
+              }, D.prototype._reloadSource = function(q) {
+                this.sourceCaches[q].resume(), this.sourceCaches[q].reload();
+              }, D.prototype._updateSources = function(q) {
+                for (var K in this.sourceCaches) this.sourceCaches[K].update(q);
+              }, D.prototype._generateCollisionBoxes = function() {
+                for (var q in this.sourceCaches) this._reloadSource(q);
+              }, D.prototype._updatePlacement = function(q, K, de, ne, we) {
+                we === void 0 && (we = false);
+                for (var Ue = false, ft = false, Zt = {}, hr = 0, qt = this._order; hr < qt.length; hr += 1) {
+                  var Ve = qt[hr], Qe = this._layers[Ve];
+                  if (Qe.type === "symbol") {
+                    if (!Zt[Qe.source]) {
+                      var at = this.sourceCaches[Qe.source];
+                      Zt[Qe.source] = at.getRenderableIds(true).map(function(Pt) {
+                        return at.getTileByID(Pt);
+                      }).sort(function(Pt, ht) {
+                        return ht.tileID.overscaledZ - Pt.tileID.overscaledZ || (Pt.tileID.isLessThan(ht.tileID) ? -1 : 1);
+                      });
+                    }
+                    var Ct = this.crossTileSymbolIndex.addLayer(Qe, Zt[Qe.source], q.center.lng);
+                    Ue = Ue || Ct;
+                  }
+                }
+                if (this.crossTileSymbolIndex.pruneUnusedLayers(this._order), we = we || this._layerOrderChanged || de === 0, (we || !this.pauseablePlacement || this.pauseablePlacement.isDone() && !this.placement.stillRecent(i.browser.now(), q.zoom)) && (this.pauseablePlacement = new qo(q, this._order, we, K, de, ne, this.placement), this._layerOrderChanged = false), this.pauseablePlacement.isDone() ? this.placement.setStale() : (this.pauseablePlacement.continuePlacement(this._order, this._layers, Zt), this.pauseablePlacement.isDone() && (this.placement = this.pauseablePlacement.commit(i.browser.now()), ft = true), Ue && this.pauseablePlacement.placement.setStale()), ft || Ue) for (var Ot = 0, Rt = this._order; Ot < Rt.length; Ot += 1) {
+                  var Bt = Rt[Ot], Dt = this._layers[Bt];
+                  Dt.type === "symbol" && this.placement.updateLayerOpacities(Dt, Zt[Dt.source]);
+                }
+                var yt = !this.pauseablePlacement.isDone() || this.placement.hasTransitions(i.browser.now());
+                return yt;
+              }, D.prototype._releaseSymbolFadeTiles = function() {
+                for (var q in this.sourceCaches) this.sourceCaches[q].releaseSymbolFadeTiles();
+              }, D.prototype.getImages = function(q, K, de) {
+                this.imageManager.getImages(K.icons, de), this._updateTilesForChangedImages();
+                var ne = this.sourceCaches[K.source];
+                ne && ne.setDependencies(K.tileID.key, K.type, K.icons);
+              }, D.prototype.getGlyphs = function(q, K, de) {
+                this.glyphManager.getGlyphs(K.stacks, de);
+              }, D.prototype.getResource = function(q, K, de) {
+                return i.makeRequest(K, de);
+              }, D;
+            }(i.Evented);
+            yu.getSourceType = Be, yu.setSourceType = Pe, yu.registerForPluginStateChange = i.registerForPluginStateChange;
+            var oc = i.createLayout([{ name: "a_pos", type: "Int16", components: 2 }]), Cf = `#ifdef GL_ES
+precision mediump float;
+#else
+#if !defined(lowp)
+#define lowp
+#endif
+#if !defined(mediump)
+#define mediump
+#endif
+#if !defined(highp)
+#define highp
+#endif
+#endif`, sc = `#ifdef GL_ES
+precision highp float;
+#else
+#if !defined(lowp)
+#define lowp
+#endif
+#if !defined(mediump)
+#define mediump
+#endif
+#if !defined(highp)
+#define highp
+#endif
+#endif
+vec2 unpack_float(const float packedValue) {int packedIntValue=int(packedValue);int v0=packedIntValue/256;return vec2(v0,packedIntValue-v0*256);}vec2 unpack_opacity(const float packedOpacity) {int intOpacity=int(packedOpacity)/2;return vec2(float(intOpacity)/127.0,mod(packedOpacity,2.0));}vec4 decode_color(const vec2 encodedColor) {return vec4(unpack_float(encodedColor[0])/255.0,unpack_float(encodedColor[1])/255.0
+);}float unpack_mix_vec2(const vec2 packedValue,const float t) {return mix(packedValue[0],packedValue[1],t);}vec4 unpack_mix_color(const vec4 packedColors,const float t) {vec4 minColor=decode_color(vec2(packedColors[0],packedColors[1]));vec4 maxColor=decode_color(vec2(packedColors[2],packedColors[3]));return mix(minColor,maxColor,t);}vec2 get_pattern_pos(const vec2 pixel_coord_upper,const vec2 pixel_coord_lower,const vec2 pattern_size,const float tile_units_to_pixels,const vec2 pos) {vec2 offset=mod(mod(mod(pixel_coord_upper,pattern_size)*256.0,pattern_size)*256.0+pixel_coord_lower,pattern_size);return (tile_units_to_pixels*pos+offset)/pattern_size;}`, jh = `uniform vec4 u_color;uniform float u_opacity;void main() {gl_FragColor=u_color*u_opacity;
+#ifdef OVERDRAW_INSPECTOR
+gl_FragColor=vec4(1.0);
+#endif
+}`, Lf = "attribute vec2 a_pos;uniform mat4 u_matrix;void main() {gl_Position=u_matrix*vec4(a_pos,0,1);}", cs = `uniform vec2 u_pattern_tl_a;uniform vec2 u_pattern_br_a;uniform vec2 u_pattern_tl_b;uniform vec2 u_pattern_br_b;uniform vec2 u_texsize;uniform float u_mix;uniform float u_opacity;uniform sampler2D u_image;varying vec2 v_pos_a;varying vec2 v_pos_b;void main() {vec2 imagecoord=mod(v_pos_a,1.0);vec2 pos=mix(u_pattern_tl_a/u_texsize,u_pattern_br_a/u_texsize,imagecoord);vec4 color1=texture2D(u_image,pos);vec2 imagecoord_b=mod(v_pos_b,1.0);vec2 pos2=mix(u_pattern_tl_b/u_texsize,u_pattern_br_b/u_texsize,imagecoord_b);vec4 color2=texture2D(u_image,pos2);gl_FragColor=mix(color1,color2,u_mix)*u_opacity;
+#ifdef OVERDRAW_INSPECTOR
+gl_FragColor=vec4(1.0);
+#endif
+}`, nf = "uniform mat4 u_matrix;uniform vec2 u_pattern_size_a;uniform vec2 u_pattern_size_b;uniform vec2 u_pixel_coord_upper;uniform vec2 u_pixel_coord_lower;uniform float u_scale_a;uniform float u_scale_b;uniform float u_tile_units_to_pixels;attribute vec2 a_pos;varying vec2 v_pos_a;varying vec2 v_pos_b;void main() {gl_Position=u_matrix*vec4(a_pos,0,1);v_pos_a=get_pattern_pos(u_pixel_coord_upper,u_pixel_coord_lower,u_scale_a*u_pattern_size_a,u_tile_units_to_pixels,a_pos);v_pos_b=get_pattern_pos(u_pixel_coord_upper,u_pixel_coord_lower,u_scale_b*u_pattern_size_b,u_tile_units_to_pixels,a_pos);}", Gf = `varying vec3 v_data;
+#pragma mapbox: define highp vec4 color
+#pragma mapbox: define mediump float radius
+#pragma mapbox: define lowp float blur
+#pragma mapbox: define lowp float opacity
+#pragma mapbox: define highp vec4 stroke_color
+#pragma mapbox: define mediump float stroke_width
+#pragma mapbox: define lowp float stroke_opacity
+void main() {
+#pragma mapbox: initialize highp vec4 color
+#pragma mapbox: initialize mediump float radius
+#pragma mapbox: initialize lowp float blur
+#pragma mapbox: initialize lowp float opacity
+#pragma mapbox: initialize highp vec4 stroke_color
+#pragma mapbox: initialize mediump float stroke_width
+#pragma mapbox: initialize lowp float stroke_opacity
+vec2 extrude=v_data.xy;float extrude_length=length(extrude);lowp float antialiasblur=v_data.z;float antialiased_blur=-max(blur,antialiasblur);float opacity_t=smoothstep(0.0,antialiased_blur,extrude_length-1.0);float color_t=stroke_width < 0.01 ? 0.0 : smoothstep(antialiased_blur,0.0,extrude_length-radius/(radius+stroke_width));gl_FragColor=opacity_t*mix(color*opacity,stroke_color*stroke_opacity,color_t);
+#ifdef OVERDRAW_INSPECTOR
+gl_FragColor=vec4(1.0);
+#endif
+}`, $l = `uniform mat4 u_matrix;uniform bool u_scale_with_map;uniform bool u_pitch_with_map;uniform vec2 u_extrude_scale;uniform lowp float u_device_pixel_ratio;uniform highp float u_camera_to_center_distance;attribute vec2 a_pos;varying vec3 v_data;
+#pragma mapbox: define highp vec4 color
+#pragma mapbox: define mediump float radius
+#pragma mapbox: define lowp float blur
+#pragma mapbox: define lowp float opacity
+#pragma mapbox: define highp vec4 stroke_color
+#pragma mapbox: define mediump float stroke_width
+#pragma mapbox: define lowp float stroke_opacity
+void main(void) {
+#pragma mapbox: initialize highp vec4 color
+#pragma mapbox: initialize mediump float radius
+#pragma mapbox: initialize lowp float blur
+#pragma mapbox: initialize lowp float opacity
+#pragma mapbox: initialize highp vec4 stroke_color
+#pragma mapbox: initialize mediump float stroke_width
+#pragma mapbox: initialize lowp float stroke_opacity
+vec2 extrude=vec2(mod(a_pos,2.0)*2.0-1.0);vec2 circle_center=floor(a_pos*0.5);if (u_pitch_with_map) {vec2 corner_position=circle_center;if (u_scale_with_map) {corner_position+=extrude*(radius+stroke_width)*u_extrude_scale;} else {vec4 projected_center=u_matrix*vec4(circle_center,0,1);corner_position+=extrude*(radius+stroke_width)*u_extrude_scale*(projected_center.w/u_camera_to_center_distance);}gl_Position=u_matrix*vec4(corner_position,0,1);} else {gl_Position=u_matrix*vec4(circle_center,0,1);if (u_scale_with_map) {gl_Position.xy+=extrude*(radius+stroke_width)*u_extrude_scale*u_camera_to_center_distance;} else {gl_Position.xy+=extrude*(radius+stroke_width)*u_extrude_scale*gl_Position.w;}}lowp float antialiasblur=1.0/u_device_pixel_ratio/(radius+stroke_width);v_data=vec3(extrude.x,extrude.y,antialiasblur);}`, fl = "void main() {gl_FragColor=vec4(1.0);}", lc = "attribute vec2 a_pos;uniform mat4 u_matrix;void main() {gl_Position=u_matrix*vec4(a_pos,0,1);}", Fu = `uniform highp float u_intensity;varying vec2 v_extrude;
+#pragma mapbox: define highp float weight
+#define GAUSS_COEF 0.3989422804014327
+void main() {
+#pragma mapbox: initialize highp float weight
+float d=-0.5*3.0*3.0*dot(v_extrude,v_extrude);float val=weight*u_intensity*GAUSS_COEF*exp(d);gl_FragColor=vec4(val,1.0,1.0,1.0);
+#ifdef OVERDRAW_INSPECTOR
+gl_FragColor=vec4(1.0);
+#endif
+}`, Es = `uniform mat4 u_matrix;uniform float u_extrude_scale;uniform float u_opacity;uniform float u_intensity;attribute vec2 a_pos;varying vec2 v_extrude;
+#pragma mapbox: define highp float weight
+#pragma mapbox: define mediump float radius
+const highp float ZERO=1.0/255.0/16.0;
+#define GAUSS_COEF 0.3989422804014327
+void main(void) {
+#pragma mapbox: initialize highp float weight
+#pragma mapbox: initialize mediump float radius
+vec2 unscaled_extrude=vec2(mod(a_pos,2.0)*2.0-1.0);float S=sqrt(-2.0*log(ZERO/weight/u_intensity/GAUSS_COEF))/3.0;v_extrude=S*unscaled_extrude;vec2 extrude=v_extrude*radius*u_extrude_scale;vec4 pos=vec4(floor(a_pos*0.5)+extrude,0,1);gl_Position=u_matrix*pos;}`, Hs = `uniform sampler2D u_image;uniform sampler2D u_color_ramp;uniform float u_opacity;varying vec2 v_pos;void main() {float t=texture2D(u_image,v_pos).r;vec4 color=texture2D(u_color_ramp,vec2(t,0.5));gl_FragColor=color*u_opacity;
+#ifdef OVERDRAW_INSPECTOR
+gl_FragColor=vec4(0.0);
+#endif
+}`, Go = "uniform mat4 u_matrix;uniform vec2 u_world;attribute vec2 a_pos;varying vec2 v_pos;void main() {gl_Position=u_matrix*vec4(a_pos*u_world,0,1);v_pos.x=a_pos.x;v_pos.y=1.0-a_pos.y;}", ps = "varying float v_placed;varying float v_notUsed;void main() {float alpha=0.5;gl_FragColor=vec4(1.0,0.0,0.0,1.0)*alpha;if (v_placed > 0.5) {gl_FragColor=vec4(0.0,0.0,1.0,0.5)*alpha;}if (v_notUsed > 0.5) {gl_FragColor*=.1;}}", uc = "attribute vec2 a_pos;attribute vec2 a_anchor_pos;attribute vec2 a_extrude;attribute vec2 a_placed;attribute vec2 a_shift;uniform mat4 u_matrix;uniform vec2 u_extrude_scale;uniform float u_camera_to_center_distance;varying float v_placed;varying float v_notUsed;void main() {vec4 projectedPoint=u_matrix*vec4(a_anchor_pos,0,1);highp float camera_to_anchor_distance=projectedPoint.w;highp float collision_perspective_ratio=clamp(0.5+0.5*(u_camera_to_center_distance/camera_to_anchor_distance),0.0,4.0);gl_Position=u_matrix*vec4(a_pos,0.0,1.0);gl_Position.xy+=(a_extrude+a_shift)*u_extrude_scale*gl_Position.w*collision_perspective_ratio;v_placed=a_placed.x;v_notUsed=a_placed.y;}", xl = "varying float v_radius;varying vec2 v_extrude;varying float v_perspective_ratio;varying float v_collision;void main() {float alpha=0.5*min(v_perspective_ratio,1.0);float stroke_radius=0.9*max(v_perspective_ratio,1.0);float distance_to_center=length(v_extrude);float distance_to_edge=abs(distance_to_center-v_radius);float opacity_t=smoothstep(-stroke_radius,0.0,-distance_to_edge);vec4 color=mix(vec4(0.0,0.0,1.0,0.5),vec4(1.0,0.0,0.0,1.0),v_collision);gl_FragColor=color*alpha*opacity_t;}", Gu = "attribute vec2 a_pos;attribute float a_radius;attribute vec2 a_flags;uniform mat4 u_matrix;uniform mat4 u_inv_matrix;uniform vec2 u_viewport_size;uniform float u_camera_to_center_distance;varying float v_radius;varying vec2 v_extrude;varying float v_perspective_ratio;varying float v_collision;vec3 toTilePosition(vec2 screenPos) {vec4 rayStart=u_inv_matrix*vec4(screenPos,-1.0,1.0);vec4 rayEnd  =u_inv_matrix*vec4(screenPos, 1.0,1.0);rayStart.xyz/=rayStart.w;rayEnd.xyz  /=rayEnd.w;highp float t=(0.0-rayStart.z)/(rayEnd.z-rayStart.z);return mix(rayStart.xyz,rayEnd.xyz,t);}void main() {vec2 quadCenterPos=a_pos;float radius=a_radius;float collision=a_flags.x;float vertexIdx=a_flags.y;vec2 quadVertexOffset=vec2(mix(-1.0,1.0,float(vertexIdx >=2.0)),mix(-1.0,1.0,float(vertexIdx >=1.0 && vertexIdx <=2.0)));vec2 quadVertexExtent=quadVertexOffset*radius;vec3 tilePos=toTilePosition(quadCenterPos);vec4 clipPos=u_matrix*vec4(tilePos,1.0);highp float camera_to_anchor_distance=clipPos.w;highp float collision_perspective_ratio=clamp(0.5+0.5*(u_camera_to_center_distance/camera_to_anchor_distance),0.0,4.0);float padding_factor=1.2;v_radius=radius;v_extrude=quadVertexExtent*padding_factor;v_perspective_ratio=collision_perspective_ratio;v_collision=collision;gl_Position=vec4(clipPos.xyz/clipPos.w,1.0)+vec4(quadVertexExtent*padding_factor/u_viewport_size*2.0,0.0,0.0);}", qs = "uniform highp vec4 u_color;uniform sampler2D u_overlay;varying vec2 v_uv;void main() {vec4 overlay_color=texture2D(u_overlay,v_uv);gl_FragColor=mix(u_color,overlay_color,overlay_color.a);}", od = "attribute vec2 a_pos;varying vec2 v_uv;uniform mat4 u_matrix;uniform float u_overlay_scale;void main() {v_uv=a_pos/8192.0;gl_Position=u_matrix*vec4(a_pos*u_overlay_scale,0,1);}", Po = `#pragma mapbox: define highp vec4 color
+#pragma mapbox: define lowp float opacity
+void main() {
+#pragma mapbox: initialize highp vec4 color
+#pragma mapbox: initialize lowp float opacity
+gl_FragColor=color*opacity;
+#ifdef OVERDRAW_INSPECTOR
+gl_FragColor=vec4(1.0);
+#endif
+}`, sd = `attribute vec2 a_pos;uniform mat4 u_matrix;
+#pragma mapbox: define highp vec4 color
+#pragma mapbox: define lowp float opacity
+void main() {
+#pragma mapbox: initialize highp vec4 color
+#pragma mapbox: initialize lowp float opacity
+gl_Position=u_matrix*vec4(a_pos,0,1);}`, Ko = `varying vec2 v_pos;
+#pragma mapbox: define highp vec4 outline_color
+#pragma mapbox: define lowp float opacity
+void main() {
+#pragma mapbox: initialize highp vec4 outline_color
+#pragma mapbox: initialize lowp float opacity
+float dist=length(v_pos-gl_FragCoord.xy);float alpha=1.0-smoothstep(0.0,1.0,dist);gl_FragColor=outline_color*(alpha*opacity);
+#ifdef OVERDRAW_INSPECTOR
+gl_FragColor=vec4(1.0);
+#endif
+}`, Pa = `attribute vec2 a_pos;uniform mat4 u_matrix;uniform vec2 u_world;varying vec2 v_pos;
+#pragma mapbox: define highp vec4 outline_color
+#pragma mapbox: define lowp float opacity
+void main() {
+#pragma mapbox: initialize highp vec4 outline_color
+#pragma mapbox: initialize lowp float opacity
+gl_Position=u_matrix*vec4(a_pos,0,1);v_pos=(gl_Position.xy/gl_Position.w+1.0)/2.0*u_world;}`, af = `uniform vec2 u_texsize;uniform sampler2D u_image;uniform float u_fade;varying vec2 v_pos_a;varying vec2 v_pos_b;varying vec2 v_pos;
+#pragma mapbox: define lowp float opacity
+#pragma mapbox: define lowp vec4 pattern_from
+#pragma mapbox: define lowp vec4 pattern_to
+void main() {
+#pragma mapbox: initialize lowp float opacity
+#pragma mapbox: initialize mediump vec4 pattern_from
+#pragma mapbox: initialize mediump vec4 pattern_to
+vec2 pattern_tl_a=pattern_from.xy;vec2 pattern_br_a=pattern_from.zw;vec2 pattern_tl_b=pattern_to.xy;vec2 pattern_br_b=pattern_to.zw;vec2 imagecoord=mod(v_pos_a,1.0);vec2 pos=mix(pattern_tl_a/u_texsize,pattern_br_a/u_texsize,imagecoord);vec4 color1=texture2D(u_image,pos);vec2 imagecoord_b=mod(v_pos_b,1.0);vec2 pos2=mix(pattern_tl_b/u_texsize,pattern_br_b/u_texsize,imagecoord_b);vec4 color2=texture2D(u_image,pos2);float dist=length(v_pos-gl_FragCoord.xy);float alpha=1.0-smoothstep(0.0,1.0,dist);gl_FragColor=mix(color1,color2,u_fade)*alpha*opacity;
+#ifdef OVERDRAW_INSPECTOR
+gl_FragColor=vec4(1.0);
+#endif
+}`, Hu = `uniform mat4 u_matrix;uniform vec2 u_world;uniform vec2 u_pixel_coord_upper;uniform vec2 u_pixel_coord_lower;uniform vec3 u_scale;attribute vec2 a_pos;varying vec2 v_pos_a;varying vec2 v_pos_b;varying vec2 v_pos;
+#pragma mapbox: define lowp float opacity
+#pragma mapbox: define lowp vec4 pattern_from
+#pragma mapbox: define lowp vec4 pattern_to
+#pragma mapbox: define lowp float pixel_ratio_from
+#pragma mapbox: define lowp float pixel_ratio_to
+void main() {
+#pragma mapbox: initialize lowp float opacity
+#pragma mapbox: initialize mediump vec4 pattern_from
+#pragma mapbox: initialize mediump vec4 pattern_to
+#pragma mapbox: initialize lowp float pixel_ratio_from
+#pragma mapbox: initialize lowp float pixel_ratio_to
+vec2 pattern_tl_a=pattern_from.xy;vec2 pattern_br_a=pattern_from.zw;vec2 pattern_tl_b=pattern_to.xy;vec2 pattern_br_b=pattern_to.zw;float tileRatio=u_scale.x;float fromScale=u_scale.y;float toScale=u_scale.z;gl_Position=u_matrix*vec4(a_pos,0,1);vec2 display_size_a=(pattern_br_a-pattern_tl_a)/pixel_ratio_from;vec2 display_size_b=(pattern_br_b-pattern_tl_b)/pixel_ratio_to;v_pos_a=get_pattern_pos(u_pixel_coord_upper,u_pixel_coord_lower,fromScale*display_size_a,tileRatio,a_pos);v_pos_b=get_pattern_pos(u_pixel_coord_upper,u_pixel_coord_lower,toScale*display_size_b,tileRatio,a_pos);v_pos=(gl_Position.xy/gl_Position.w+1.0)/2.0*u_world;}`, bl = `uniform vec2 u_texsize;uniform float u_fade;uniform sampler2D u_image;varying vec2 v_pos_a;varying vec2 v_pos_b;
+#pragma mapbox: define lowp float opacity
+#pragma mapbox: define lowp vec4 pattern_from
+#pragma mapbox: define lowp vec4 pattern_to
+void main() {
+#pragma mapbox: initialize lowp float opacity
+#pragma mapbox: initialize mediump vec4 pattern_from
+#pragma mapbox: initialize mediump vec4 pattern_to
+vec2 pattern_tl_a=pattern_from.xy;vec2 pattern_br_a=pattern_from.zw;vec2 pattern_tl_b=pattern_to.xy;vec2 pattern_br_b=pattern_to.zw;vec2 imagecoord=mod(v_pos_a,1.0);vec2 pos=mix(pattern_tl_a/u_texsize,pattern_br_a/u_texsize,imagecoord);vec4 color1=texture2D(u_image,pos);vec2 imagecoord_b=mod(v_pos_b,1.0);vec2 pos2=mix(pattern_tl_b/u_texsize,pattern_br_b/u_texsize,imagecoord_b);vec4 color2=texture2D(u_image,pos2);gl_FragColor=mix(color1,color2,u_fade)*opacity;
+#ifdef OVERDRAW_INSPECTOR
+gl_FragColor=vec4(1.0);
+#endif
+}`, Hf = `uniform mat4 u_matrix;uniform vec2 u_pixel_coord_upper;uniform vec2 u_pixel_coord_lower;uniform vec3 u_scale;attribute vec2 a_pos;varying vec2 v_pos_a;varying vec2 v_pos_b;
+#pragma mapbox: define lowp float opacity
+#pragma mapbox: define lowp vec4 pattern_from
+#pragma mapbox: define lowp vec4 pattern_to
+#pragma mapbox: define lowp float pixel_ratio_from
+#pragma mapbox: define lowp float pixel_ratio_to
+void main() {
+#pragma mapbox: initialize lowp float opacity
+#pragma mapbox: initialize mediump vec4 pattern_from
+#pragma mapbox: initialize mediump vec4 pattern_to
+#pragma mapbox: initialize lowp float pixel_ratio_from
+#pragma mapbox: initialize lowp float pixel_ratio_to
+vec2 pattern_tl_a=pattern_from.xy;vec2 pattern_br_a=pattern_from.zw;vec2 pattern_tl_b=pattern_to.xy;vec2 pattern_br_b=pattern_to.zw;float tileZoomRatio=u_scale.x;float fromScale=u_scale.y;float toScale=u_scale.z;vec2 display_size_a=(pattern_br_a-pattern_tl_a)/pixel_ratio_from;vec2 display_size_b=(pattern_br_b-pattern_tl_b)/pixel_ratio_to;gl_Position=u_matrix*vec4(a_pos,0,1);v_pos_a=get_pattern_pos(u_pixel_coord_upper,u_pixel_coord_lower,fromScale*display_size_a,tileZoomRatio,a_pos);v_pos_b=get_pattern_pos(u_pixel_coord_upper,u_pixel_coord_lower,toScale*display_size_b,tileZoomRatio,a_pos);}`, Ic = `varying vec4 v_color;void main() {gl_FragColor=v_color;
+#ifdef OVERDRAW_INSPECTOR
+gl_FragColor=vec4(1.0);
+#endif
+}`, yf = `uniform mat4 u_matrix;uniform vec3 u_lightcolor;uniform lowp vec3 u_lightpos;uniform lowp float u_lightintensity;uniform float u_vertical_gradient;uniform lowp float u_opacity;attribute vec2 a_pos;attribute vec4 a_normal_ed;varying vec4 v_color;
+#pragma mapbox: define highp float base
+#pragma mapbox: define highp float height
+#pragma mapbox: define highp vec4 color
+void main() {
+#pragma mapbox: initialize highp float base
+#pragma mapbox: initialize highp float height
+#pragma mapbox: initialize highp vec4 color
+vec3 normal=a_normal_ed.xyz;base=max(0.0,base);height=max(0.0,height);float t=mod(normal.x,2.0);gl_Position=u_matrix*vec4(a_pos,t > 0.0 ? height : base,1);float colorvalue=color.r*0.2126+color.g*0.7152+color.b*0.0722;v_color=vec4(0.0,0.0,0.0,1.0);vec4 ambientlight=vec4(0.03,0.03,0.03,1.0);color+=ambientlight;float directional=clamp(dot(normal/16384.0,u_lightpos),0.0,1.0);directional=mix((1.0-u_lightintensity),max((1.0-colorvalue+u_lightintensity),1.0),directional);if (normal.y !=0.0) {directional*=((1.0-u_vertical_gradient)+(u_vertical_gradient*clamp((t+base)*pow(height/150.0,0.5),mix(0.7,0.98,1.0-u_lightintensity),1.0)));}v_color.r+=clamp(color.r*directional*u_lightcolor.r,mix(0.0,0.3,1.0-u_lightcolor.r),1.0);v_color.g+=clamp(color.g*directional*u_lightcolor.g,mix(0.0,0.3,1.0-u_lightcolor.g),1.0);v_color.b+=clamp(color.b*directional*u_lightcolor.b,mix(0.0,0.3,1.0-u_lightcolor.b),1.0);v_color*=u_opacity;}`, Bl = `uniform vec2 u_texsize;uniform float u_fade;uniform sampler2D u_image;varying vec2 v_pos_a;varying vec2 v_pos_b;varying vec4 v_lighting;
+#pragma mapbox: define lowp float base
+#pragma mapbox: define lowp float height
+#pragma mapbox: define lowp vec4 pattern_from
+#pragma mapbox: define lowp vec4 pattern_to
+#pragma mapbox: define lowp float pixel_ratio_from
+#pragma mapbox: define lowp float pixel_ratio_to
+void main() {
+#pragma mapbox: initialize lowp float base
+#pragma mapbox: initialize lowp float height
+#pragma mapbox: initialize mediump vec4 pattern_from
+#pragma mapbox: initialize mediump vec4 pattern_to
+#pragma mapbox: initialize lowp float pixel_ratio_from
+#pragma mapbox: initialize lowp float pixel_ratio_to
+vec2 pattern_tl_a=pattern_from.xy;vec2 pattern_br_a=pattern_from.zw;vec2 pattern_tl_b=pattern_to.xy;vec2 pattern_br_b=pattern_to.zw;vec2 imagecoord=mod(v_pos_a,1.0);vec2 pos=mix(pattern_tl_a/u_texsize,pattern_br_a/u_texsize,imagecoord);vec4 color1=texture2D(u_image,pos);vec2 imagecoord_b=mod(v_pos_b,1.0);vec2 pos2=mix(pattern_tl_b/u_texsize,pattern_br_b/u_texsize,imagecoord_b);vec4 color2=texture2D(u_image,pos2);vec4 mixedColor=mix(color1,color2,u_fade);gl_FragColor=mixedColor*v_lighting;
+#ifdef OVERDRAW_INSPECTOR
+gl_FragColor=vec4(1.0);
+#endif
+}`, Ah = `uniform mat4 u_matrix;uniform vec2 u_pixel_coord_upper;uniform vec2 u_pixel_coord_lower;uniform float u_height_factor;uniform vec3 u_scale;uniform float u_vertical_gradient;uniform lowp float u_opacity;uniform vec3 u_lightcolor;uniform lowp vec3 u_lightpos;uniform lowp float u_lightintensity;attribute vec2 a_pos;attribute vec4 a_normal_ed;varying vec2 v_pos_a;varying vec2 v_pos_b;varying vec4 v_lighting;
+#pragma mapbox: define lowp float base
+#pragma mapbox: define lowp float height
+#pragma mapbox: define lowp vec4 pattern_from
+#pragma mapbox: define lowp vec4 pattern_to
+#pragma mapbox: define lowp float pixel_ratio_from
+#pragma mapbox: define lowp float pixel_ratio_to
+void main() {
+#pragma mapbox: initialize lowp float base
+#pragma mapbox: initialize lowp float height
+#pragma mapbox: initialize mediump vec4 pattern_from
+#pragma mapbox: initialize mediump vec4 pattern_to
+#pragma mapbox: initialize lowp float pixel_ratio_from
+#pragma mapbox: initialize lowp float pixel_ratio_to
+vec2 pattern_tl_a=pattern_from.xy;vec2 pattern_br_a=pattern_from.zw;vec2 pattern_tl_b=pattern_to.xy;vec2 pattern_br_b=pattern_to.zw;float tileRatio=u_scale.x;float fromScale=u_scale.y;float toScale=u_scale.z;vec3 normal=a_normal_ed.xyz;float edgedistance=a_normal_ed.w;vec2 display_size_a=(pattern_br_a-pattern_tl_a)/pixel_ratio_from;vec2 display_size_b=(pattern_br_b-pattern_tl_b)/pixel_ratio_to;base=max(0.0,base);height=max(0.0,height);float t=mod(normal.x,2.0);float z=t > 0.0 ? height : base;gl_Position=u_matrix*vec4(a_pos,z,1);vec2 pos=normal.x==1.0 && normal.y==0.0 && normal.z==16384.0
+? a_pos
+: vec2(edgedistance,z*u_height_factor);v_pos_a=get_pattern_pos(u_pixel_coord_upper,u_pixel_coord_lower,fromScale*display_size_a,tileRatio,pos);v_pos_b=get_pattern_pos(u_pixel_coord_upper,u_pixel_coord_lower,toScale*display_size_b,tileRatio,pos);v_lighting=vec4(0.0,0.0,0.0,1.0);float directional=clamp(dot(normal/16383.0,u_lightpos),0.0,1.0);directional=mix((1.0-u_lightintensity),max((0.5+u_lightintensity),1.0),directional);if (normal.y !=0.0) {directional*=((1.0-u_vertical_gradient)+(u_vertical_gradient*clamp((t+base)*pow(height/150.0,0.5),mix(0.7,0.98,1.0-u_lightintensity),1.0)));}v_lighting.rgb+=clamp(directional*u_lightcolor,mix(vec3(0.0),vec3(0.3),1.0-u_lightcolor),vec3(1.0));v_lighting*=u_opacity;}`, Qf = `#ifdef GL_ES
+precision highp float;
+#endif
+uniform sampler2D u_image;varying vec2 v_pos;uniform vec2 u_dimension;uniform float u_zoom;uniform vec4 u_unpack;float getElevation(vec2 coord,float bias) {vec4 data=texture2D(u_image,coord)*255.0;data.a=-1.0;return dot(data,u_unpack)/4.0;}void main() {vec2 epsilon=1.0/u_dimension;float a=getElevation(v_pos+vec2(-epsilon.x,-epsilon.y),0.0);float b=getElevation(v_pos+vec2(0,-epsilon.y),0.0);float c=getElevation(v_pos+vec2(epsilon.x,-epsilon.y),0.0);float d=getElevation(v_pos+vec2(-epsilon.x,0),0.0);float e=getElevation(v_pos,0.0);float f=getElevation(v_pos+vec2(epsilon.x,0),0.0);float g=getElevation(v_pos+vec2(-epsilon.x,epsilon.y),0.0);float h=getElevation(v_pos+vec2(0,epsilon.y),0.0);float i=getElevation(v_pos+vec2(epsilon.x,epsilon.y),0.0);float exaggerationFactor=u_zoom < 2.0 ? 0.4 : u_zoom < 4.5 ? 0.35 : 0.3;float exaggeration=u_zoom < 15.0 ? (u_zoom-15.0)*exaggerationFactor : 0.0;vec2 deriv=vec2((c+f+f+i)-(a+d+d+g),(g+h+h+i)-(a+b+b+c))/pow(2.0,exaggeration+(19.2562-u_zoom));gl_FragColor=clamp(vec4(deriv.x/2.0+0.5,deriv.y/2.0+0.5,1.0,1.0),0.0,1.0);
+#ifdef OVERDRAW_INSPECTOR
+gl_FragColor=vec4(1.0);
+#endif
+}`, _f = "uniform mat4 u_matrix;uniform vec2 u_dimension;attribute vec2 a_pos;attribute vec2 a_texture_pos;varying vec2 v_pos;void main() {gl_Position=u_matrix*vec4(a_pos,0,1);highp vec2 epsilon=1.0/u_dimension;float scale=(u_dimension.x-2.0)/u_dimension.x;v_pos=(a_texture_pos/8192.0)*scale+epsilon;}", Yc = `uniform sampler2D u_image;varying vec2 v_pos;uniform vec2 u_latrange;uniform vec2 u_light;uniform vec4 u_shadow;uniform vec4 u_highlight;uniform vec4 u_accent;
+#define PI 3.141592653589793
+void main() {vec4 pixel=texture2D(u_image,v_pos);vec2 deriv=((pixel.rg*2.0)-1.0);float scaleFactor=cos(radians((u_latrange[0]-u_latrange[1])*(1.0-v_pos.y)+u_latrange[1]));float slope=atan(1.25*length(deriv)/scaleFactor);float aspect=deriv.x !=0.0 ? atan(deriv.y,-deriv.x) : PI/2.0*(deriv.y > 0.0 ? 1.0 :-1.0);float intensity=u_light.x;float azimuth=u_light.y+PI;float base=1.875-intensity*1.75;float maxValue=0.5*PI;float scaledSlope=intensity !=0.5 ? ((pow(base,slope)-1.0)/(pow(base,maxValue)-1.0))*maxValue : slope;float accent=cos(scaledSlope);vec4 accent_color=(1.0-accent)*u_accent*clamp(intensity*2.0,0.0,1.0);float shade=abs(mod((aspect+azimuth)/PI+0.5,2.0)-1.0);vec4 shade_color=mix(u_shadow,u_highlight,shade)*sin(scaledSlope)*clamp(intensity*2.0,0.0,1.0);gl_FragColor=accent_color*(1.0-shade_color.a)+shade_color;
+#ifdef OVERDRAW_INSPECTOR
+gl_FragColor=vec4(1.0);
+#endif
+}`, eh = "uniform mat4 u_matrix;attribute vec2 a_pos;attribute vec2 a_texture_pos;varying vec2 v_pos;void main() {gl_Position=u_matrix*vec4(a_pos,0,1);v_pos=a_texture_pos/8192.0;}", th = `uniform lowp float u_device_pixel_ratio;varying vec2 v_width2;varying vec2 v_normal;varying float v_gamma_scale;
+#pragma mapbox: define highp vec4 color
+#pragma mapbox: define lowp float blur
+#pragma mapbox: define lowp float opacity
+void main() {
+#pragma mapbox: initialize highp vec4 color
+#pragma mapbox: initialize lowp float blur
+#pragma mapbox: initialize lowp float opacity
+float dist=length(v_normal)*v_width2.s;float blur2=(blur+1.0/u_device_pixel_ratio)*v_gamma_scale;float alpha=clamp(min(dist-(v_width2.t-blur2),v_width2.s-dist)/blur2,0.0,1.0);gl_FragColor=color*(alpha*opacity);
+#ifdef OVERDRAW_INSPECTOR
+gl_FragColor=vec4(1.0);
+#endif
+}`, ju = `
+#define scale 0.015873016
+attribute vec2 a_pos_normal;attribute vec4 a_data;uniform mat4 u_matrix;uniform mediump float u_ratio;uniform vec2 u_units_to_pixels;uniform lowp float u_device_pixel_ratio;varying vec2 v_normal;varying vec2 v_width2;varying float v_gamma_scale;varying highp float v_linesofar;
+#pragma mapbox: define highp vec4 color
+#pragma mapbox: define lowp float blur
+#pragma mapbox: define lowp float opacity
+#pragma mapbox: define mediump float gapwidth
+#pragma mapbox: define lowp float offset
+#pragma mapbox: define mediump float width
+void main() {
+#pragma mapbox: initialize highp vec4 color
+#pragma mapbox: initialize lowp float blur
+#pragma mapbox: initialize lowp float opacity
+#pragma mapbox: initialize mediump float gapwidth
+#pragma mapbox: initialize lowp float offset
+#pragma mapbox: initialize mediump float width
+float ANTIALIASING=1.0/u_device_pixel_ratio/2.0;vec2 a_extrude=a_data.xy-128.0;float a_direction=mod(a_data.z,4.0)-1.0;v_linesofar=(floor(a_data.z/4.0)+a_data.w*64.0)*2.0;vec2 pos=floor(a_pos_normal*0.5);mediump vec2 normal=a_pos_normal-2.0*pos;normal.y=normal.y*2.0-1.0;v_normal=normal;gapwidth=gapwidth/2.0;float halfwidth=width/2.0;offset=-1.0*offset;float inset=gapwidth+(gapwidth > 0.0 ? ANTIALIASING : 0.0);float outset=gapwidth+halfwidth*(gapwidth > 0.0 ? 2.0 : 1.0)+(halfwidth==0.0 ? 0.0 : ANTIALIASING);mediump vec2 dist=outset*a_extrude*scale;mediump float u=0.5*a_direction;mediump float t=1.0-abs(u);mediump vec2 offset2=offset*a_extrude*scale*normal.y*mat2(t,-u,u,t);vec4 projected_extrude=u_matrix*vec4(dist/u_ratio,0.0,0.0);gl_Position=u_matrix*vec4(pos+offset2/u_ratio,0.0,1.0)+projected_extrude;float extrude_length_without_perspective=length(dist);float extrude_length_with_perspective=length(projected_extrude.xy/gl_Position.w*u_units_to_pixels);v_gamma_scale=extrude_length_without_perspective/extrude_length_with_perspective;v_width2=vec2(outset,inset);}`, jf = `uniform lowp float u_device_pixel_ratio;uniform sampler2D u_image;varying vec2 v_width2;varying vec2 v_normal;varying float v_gamma_scale;varying highp vec2 v_uv;
+#pragma mapbox: define lowp float blur
+#pragma mapbox: define lowp float opacity
+void main() {
+#pragma mapbox: initialize lowp float blur
+#pragma mapbox: initialize lowp float opacity
+float dist=length(v_normal)*v_width2.s;float blur2=(blur+1.0/u_device_pixel_ratio)*v_gamma_scale;float alpha=clamp(min(dist-(v_width2.t-blur2),v_width2.s-dist)/blur2,0.0,1.0);vec4 color=texture2D(u_image,v_uv);gl_FragColor=color*(alpha*opacity);
+#ifdef OVERDRAW_INSPECTOR
+gl_FragColor=vec4(1.0);
+#endif
+}`, cc = `
+#define scale 0.015873016
+attribute vec2 a_pos_normal;attribute vec4 a_data;attribute float a_uv_x;attribute float a_split_index;uniform mat4 u_matrix;uniform mediump float u_ratio;uniform lowp float u_device_pixel_ratio;uniform vec2 u_units_to_pixels;uniform float u_image_height;varying vec2 v_normal;varying vec2 v_width2;varying float v_gamma_scale;varying highp vec2 v_uv;
+#pragma mapbox: define lowp float blur
+#pragma mapbox: define lowp float opacity
+#pragma mapbox: define mediump float gapwidth
+#pragma mapbox: define lowp float offset
+#pragma mapbox: define mediump float width
+void main() {
+#pragma mapbox: initialize lowp float blur
+#pragma mapbox: initialize lowp float opacity
+#pragma mapbox: initialize mediump float gapwidth
+#pragma mapbox: initialize lowp float offset
+#pragma mapbox: initialize mediump float width
+float ANTIALIASING=1.0/u_device_pixel_ratio/2.0;vec2 a_extrude=a_data.xy-128.0;float a_direction=mod(a_data.z,4.0)-1.0;highp float texel_height=1.0/u_image_height;highp float half_texel_height=0.5*texel_height;v_uv=vec2(a_uv_x,a_split_index*texel_height-half_texel_height);vec2 pos=floor(a_pos_normal*0.5);mediump vec2 normal=a_pos_normal-2.0*pos;normal.y=normal.y*2.0-1.0;v_normal=normal;gapwidth=gapwidth/2.0;float halfwidth=width/2.0;offset=-1.0*offset;float inset=gapwidth+(gapwidth > 0.0 ? ANTIALIASING : 0.0);float outset=gapwidth+halfwidth*(gapwidth > 0.0 ? 2.0 : 1.0)+(halfwidth==0.0 ? 0.0 : ANTIALIASING);mediump vec2 dist=outset*a_extrude*scale;mediump float u=0.5*a_direction;mediump float t=1.0-abs(u);mediump vec2 offset2=offset*a_extrude*scale*normal.y*mat2(t,-u,u,t);vec4 projected_extrude=u_matrix*vec4(dist/u_ratio,0.0,0.0);gl_Position=u_matrix*vec4(pos+offset2/u_ratio,0.0,1.0)+projected_extrude;float extrude_length_without_perspective=length(dist);float extrude_length_with_perspective=length(projected_extrude.xy/gl_Position.w*u_units_to_pixels);v_gamma_scale=extrude_length_without_perspective/extrude_length_with_perspective;v_width2=vec2(outset,inset);}`, of = `uniform lowp float u_device_pixel_ratio;uniform vec2 u_texsize;uniform float u_fade;uniform mediump vec3 u_scale;uniform sampler2D u_image;varying vec2 v_normal;varying vec2 v_width2;varying float v_linesofar;varying float v_gamma_scale;varying float v_width;
+#pragma mapbox: define lowp vec4 pattern_from
+#pragma mapbox: define lowp vec4 pattern_to
+#pragma mapbox: define lowp float pixel_ratio_from
+#pragma mapbox: define lowp float pixel_ratio_to
+#pragma mapbox: define lowp float blur
+#pragma mapbox: define lowp float opacity
+void main() {
+#pragma mapbox: initialize mediump vec4 pattern_from
+#pragma mapbox: initialize mediump vec4 pattern_to
+#pragma mapbox: initialize lowp float pixel_ratio_from
+#pragma mapbox: initialize lowp float pixel_ratio_to
+#pragma mapbox: initialize lowp float blur
+#pragma mapbox: initialize lowp float opacity
+vec2 pattern_tl_a=pattern_from.xy;vec2 pattern_br_a=pattern_from.zw;vec2 pattern_tl_b=pattern_to.xy;vec2 pattern_br_b=pattern_to.zw;float tileZoomRatio=u_scale.x;float fromScale=u_scale.y;float toScale=u_scale.z;vec2 display_size_a=(pattern_br_a-pattern_tl_a)/pixel_ratio_from;vec2 display_size_b=(pattern_br_b-pattern_tl_b)/pixel_ratio_to;vec2 pattern_size_a=vec2(display_size_a.x*fromScale/tileZoomRatio,display_size_a.y);vec2 pattern_size_b=vec2(display_size_b.x*toScale/tileZoomRatio,display_size_b.y);float aspect_a=display_size_a.y/v_width;float aspect_b=display_size_b.y/v_width;float dist=length(v_normal)*v_width2.s;float blur2=(blur+1.0/u_device_pixel_ratio)*v_gamma_scale;float alpha=clamp(min(dist-(v_width2.t-blur2),v_width2.s-dist)/blur2,0.0,1.0);float x_a=mod(v_linesofar/pattern_size_a.x*aspect_a,1.0);float x_b=mod(v_linesofar/pattern_size_b.x*aspect_b,1.0);float y=0.5*v_normal.y+0.5;vec2 texel_size=1.0/u_texsize;vec2 pos_a=mix(pattern_tl_a*texel_size-texel_size,pattern_br_a*texel_size+texel_size,vec2(x_a,y));vec2 pos_b=mix(pattern_tl_b*texel_size-texel_size,pattern_br_b*texel_size+texel_size,vec2(x_b,y));vec4 color=mix(texture2D(u_image,pos_a),texture2D(u_image,pos_b),u_fade);gl_FragColor=color*alpha*opacity;
+#ifdef OVERDRAW_INSPECTOR
+gl_FragColor=vec4(1.0);
+#endif
+}`, Nl = `
+#define scale 0.015873016
+#define LINE_DISTANCE_SCALE 2.0
+attribute vec2 a_pos_normal;attribute vec4 a_data;uniform mat4 u_matrix;uniform vec2 u_units_to_pixels;uniform mediump float u_ratio;uniform lowp float u_device_pixel_ratio;varying vec2 v_normal;varying vec2 v_width2;varying float v_linesofar;varying float v_gamma_scale;varying float v_width;
+#pragma mapbox: define lowp float blur
+#pragma mapbox: define lowp float opacity
+#pragma mapbox: define lowp float offset
+#pragma mapbox: define mediump float gapwidth
+#pragma mapbox: define mediump float width
+#pragma mapbox: define lowp float floorwidth
+#pragma mapbox: define lowp vec4 pattern_from
+#pragma mapbox: define lowp vec4 pattern_to
+#pragma mapbox: define lowp float pixel_ratio_from
+#pragma mapbox: define lowp float pixel_ratio_to
+void main() {
+#pragma mapbox: initialize lowp float blur
+#pragma mapbox: initialize lowp float opacity
+#pragma mapbox: initialize lowp float offset
+#pragma mapbox: initialize mediump float gapwidth
+#pragma mapbox: initialize mediump float width
+#pragma mapbox: initialize lowp float floorwidth
+#pragma mapbox: initialize mediump vec4 pattern_from
+#pragma mapbox: initialize mediump vec4 pattern_to
+#pragma mapbox: initialize lowp float pixel_ratio_from
+#pragma mapbox: initialize lowp float pixel_ratio_to
+float ANTIALIASING=1.0/u_device_pixel_ratio/2.0;vec2 a_extrude=a_data.xy-128.0;float a_direction=mod(a_data.z,4.0)-1.0;float a_linesofar=(floor(a_data.z/4.0)+a_data.w*64.0)*LINE_DISTANCE_SCALE;vec2 pos=floor(a_pos_normal*0.5);mediump vec2 normal=a_pos_normal-2.0*pos;normal.y=normal.y*2.0-1.0;v_normal=normal;gapwidth=gapwidth/2.0;float halfwidth=width/2.0;offset=-1.0*offset;float inset=gapwidth+(gapwidth > 0.0 ? ANTIALIASING : 0.0);float outset=gapwidth+halfwidth*(gapwidth > 0.0 ? 2.0 : 1.0)+(halfwidth==0.0 ? 0.0 : ANTIALIASING);mediump vec2 dist=outset*a_extrude*scale;mediump float u=0.5*a_direction;mediump float t=1.0-abs(u);mediump vec2 offset2=offset*a_extrude*scale*normal.y*mat2(t,-u,u,t);vec4 projected_extrude=u_matrix*vec4(dist/u_ratio,0.0,0.0);gl_Position=u_matrix*vec4(pos+offset2/u_ratio,0.0,1.0)+projected_extrude;float extrude_length_without_perspective=length(dist);float extrude_length_with_perspective=length(projected_extrude.xy/gl_Position.w*u_units_to_pixels);v_gamma_scale=extrude_length_without_perspective/extrude_length_with_perspective;v_linesofar=a_linesofar;v_width2=vec2(outset,inset);v_width=floorwidth;}`, Kc = `uniform lowp float u_device_pixel_ratio;uniform sampler2D u_image;uniform float u_sdfgamma;uniform float u_mix;varying vec2 v_normal;varying vec2 v_width2;varying vec2 v_tex_a;varying vec2 v_tex_b;varying float v_gamma_scale;
+#pragma mapbox: define highp vec4 color
+#pragma mapbox: define lowp float blur
+#pragma mapbox: define lowp float opacity
+#pragma mapbox: define mediump float width
+#pragma mapbox: define lowp float floorwidth
+void main() {
+#pragma mapbox: initialize highp vec4 color
+#pragma mapbox: initialize lowp float blur
+#pragma mapbox: initialize lowp float opacity
+#pragma mapbox: initialize mediump float width
+#pragma mapbox: initialize lowp float floorwidth
+float dist=length(v_normal)*v_width2.s;float blur2=(blur+1.0/u_device_pixel_ratio)*v_gamma_scale;float alpha=clamp(min(dist-(v_width2.t-blur2),v_width2.s-dist)/blur2,0.0,1.0);float sdfdist_a=texture2D(u_image,v_tex_a).a;float sdfdist_b=texture2D(u_image,v_tex_b).a;float sdfdist=mix(sdfdist_a,sdfdist_b,u_mix);alpha*=smoothstep(0.5-u_sdfgamma/floorwidth,0.5+u_sdfgamma/floorwidth,sdfdist);gl_FragColor=color*(alpha*opacity);
+#ifdef OVERDRAW_INSPECTOR
+gl_FragColor=vec4(1.0);
+#endif
+}`, Rc = `
+#define scale 0.015873016
+#define LINE_DISTANCE_SCALE 2.0
+attribute vec2 a_pos_normal;attribute vec4 a_data;uniform mat4 u_matrix;uniform mediump float u_ratio;uniform lowp float u_device_pixel_ratio;uniform vec2 u_patternscale_a;uniform float u_tex_y_a;uniform vec2 u_patternscale_b;uniform float u_tex_y_b;uniform vec2 u_units_to_pixels;varying vec2 v_normal;varying vec2 v_width2;varying vec2 v_tex_a;varying vec2 v_tex_b;varying float v_gamma_scale;
+#pragma mapbox: define highp vec4 color
+#pragma mapbox: define lowp float blur
+#pragma mapbox: define lowp float opacity
+#pragma mapbox: define mediump float gapwidth
+#pragma mapbox: define lowp float offset
+#pragma mapbox: define mediump float width
+#pragma mapbox: define lowp float floorwidth
+void main() {
+#pragma mapbox: initialize highp vec4 color
+#pragma mapbox: initialize lowp float blur
+#pragma mapbox: initialize lowp float opacity
+#pragma mapbox: initialize mediump float gapwidth
+#pragma mapbox: initialize lowp float offset
+#pragma mapbox: initialize mediump float width
+#pragma mapbox: initialize lowp float floorwidth
+float ANTIALIASING=1.0/u_device_pixel_ratio/2.0;vec2 a_extrude=a_data.xy-128.0;float a_direction=mod(a_data.z,4.0)-1.0;float a_linesofar=(floor(a_data.z/4.0)+a_data.w*64.0)*LINE_DISTANCE_SCALE;vec2 pos=floor(a_pos_normal*0.5);mediump vec2 normal=a_pos_normal-2.0*pos;normal.y=normal.y*2.0-1.0;v_normal=normal;gapwidth=gapwidth/2.0;float halfwidth=width/2.0;offset=-1.0*offset;float inset=gapwidth+(gapwidth > 0.0 ? ANTIALIASING : 0.0);float outset=gapwidth+halfwidth*(gapwidth > 0.0 ? 2.0 : 1.0)+(halfwidth==0.0 ? 0.0 : ANTIALIASING);mediump vec2 dist=outset*a_extrude*scale;mediump float u=0.5*a_direction;mediump float t=1.0-abs(u);mediump vec2 offset2=offset*a_extrude*scale*normal.y*mat2(t,-u,u,t);vec4 projected_extrude=u_matrix*vec4(dist/u_ratio,0.0,0.0);gl_Position=u_matrix*vec4(pos+offset2/u_ratio,0.0,1.0)+projected_extrude;float extrude_length_without_perspective=length(dist);float extrude_length_with_perspective=length(projected_extrude.xy/gl_Position.w*u_units_to_pixels);v_gamma_scale=extrude_length_without_perspective/extrude_length_with_perspective;v_tex_a=vec2(a_linesofar*u_patternscale_a.x/floorwidth,normal.y*u_patternscale_a.y+u_tex_y_a);v_tex_b=vec2(a_linesofar*u_patternscale_b.x/floorwidth,normal.y*u_patternscale_b.y+u_tex_y_b);v_width2=vec2(outset,inset);}`, gs = `uniform float u_fade_t;uniform float u_opacity;uniform sampler2D u_image0;uniform sampler2D u_image1;varying vec2 v_pos0;varying vec2 v_pos1;uniform float u_brightness_low;uniform float u_brightness_high;uniform float u_saturation_factor;uniform float u_contrast_factor;uniform vec3 u_spin_weights;void main() {vec4 color0=texture2D(u_image0,v_pos0);vec4 color1=texture2D(u_image1,v_pos1);if (color0.a > 0.0) {color0.rgb=color0.rgb/color0.a;}if (color1.a > 0.0) {color1.rgb=color1.rgb/color1.a;}vec4 color=mix(color0,color1,u_fade_t);color.a*=u_opacity;vec3 rgb=color.rgb;rgb=vec3(dot(rgb,u_spin_weights.xyz),dot(rgb,u_spin_weights.zxy),dot(rgb,u_spin_weights.yzx));float average=(color.r+color.g+color.b)/3.0;rgb+=(average-rgb)*u_saturation_factor;rgb=(rgb-0.5)*u_contrast_factor+0.5;vec3 u_high_vec=vec3(u_brightness_low,u_brightness_low,u_brightness_low);vec3 u_low_vec=vec3(u_brightness_high,u_brightness_high,u_brightness_high);gl_FragColor=vec4(mix(u_high_vec,u_low_vec,rgb)*color.a,color.a);
+#ifdef OVERDRAW_INSPECTOR
+gl_FragColor=vec4(1.0);
+#endif
+}`, Wf = "uniform mat4 u_matrix;uniform vec2 u_tl_parent;uniform float u_scale_parent;uniform float u_buffer_scale;attribute vec2 a_pos;attribute vec2 a_texture_pos;varying vec2 v_pos0;varying vec2 v_pos1;void main() {gl_Position=u_matrix*vec4(a_pos,0,1);v_pos0=(((a_texture_pos/8192.0)-0.5)/u_buffer_scale )+0.5;v_pos1=(v_pos0*u_scale_parent)+u_tl_parent;}", Wh = `uniform sampler2D u_texture;varying vec2 v_tex;varying float v_fade_opacity;
+#pragma mapbox: define lowp float opacity
+void main() {
+#pragma mapbox: initialize lowp float opacity
+lowp float alpha=opacity*v_fade_opacity;gl_FragColor=texture2D(u_texture,v_tex)*alpha;
+#ifdef OVERDRAW_INSPECTOR
+gl_FragColor=vec4(1.0);
+#endif
+}`, rh = `const float PI=3.141592653589793;attribute vec4 a_pos_offset;attribute vec4 a_data;attribute vec4 a_pixeloffset;attribute vec3 a_projected_pos;attribute float a_fade_opacity;uniform bool u_is_size_zoom_constant;uniform bool u_is_size_feature_constant;uniform highp float u_size_t;uniform highp float u_size;uniform highp float u_camera_to_center_distance;uniform highp float u_pitch;uniform bool u_rotate_symbol;uniform highp float u_aspect_ratio;uniform float u_fade_change;uniform mat4 u_matrix;uniform mat4 u_label_plane_matrix;uniform mat4 u_coord_matrix;uniform bool u_is_text;uniform bool u_pitch_with_map;uniform vec2 u_texsize;varying vec2 v_tex;varying float v_fade_opacity;
+#pragma mapbox: define lowp float opacity
+void main() {
+#pragma mapbox: initialize lowp float opacity
+vec2 a_pos=a_pos_offset.xy;vec2 a_offset=a_pos_offset.zw;vec2 a_tex=a_data.xy;vec2 a_size=a_data.zw;float a_size_min=floor(a_size[0]*0.5);vec2 a_pxoffset=a_pixeloffset.xy;vec2 a_minFontScale=a_pixeloffset.zw/256.0;highp float segment_angle=-a_projected_pos[2];float size;if (!u_is_size_zoom_constant && !u_is_size_feature_constant) {size=mix(a_size_min,a_size[1],u_size_t)/128.0;} else if (u_is_size_zoom_constant && !u_is_size_feature_constant) {size=a_size_min/128.0;} else {size=u_size;}vec4 projectedPoint=u_matrix*vec4(a_pos,0,1);highp float camera_to_anchor_distance=projectedPoint.w;highp float distance_ratio=u_pitch_with_map ?
+camera_to_anchor_distance/u_camera_to_center_distance :
+u_camera_to_center_distance/camera_to_anchor_distance;highp float perspective_ratio=clamp(0.5+0.5*distance_ratio,0.0,4.0);size*=perspective_ratio;float fontScale=u_is_text ? size/24.0 : size;highp float symbol_rotation=0.0;if (u_rotate_symbol) {vec4 offsetProjectedPoint=u_matrix*vec4(a_pos+vec2(1,0),0,1);vec2 a=projectedPoint.xy/projectedPoint.w;vec2 b=offsetProjectedPoint.xy/offsetProjectedPoint.w;symbol_rotation=atan((b.y-a.y)/u_aspect_ratio,b.x-a.x);}highp float angle_sin=sin(segment_angle+symbol_rotation);highp float angle_cos=cos(segment_angle+symbol_rotation);mat2 rotation_matrix=mat2(angle_cos,-1.0*angle_sin,angle_sin,angle_cos);vec4 projected_pos=u_label_plane_matrix*vec4(a_projected_pos.xy,0.0,1.0);gl_Position=u_coord_matrix*vec4(projected_pos.xy/projected_pos.w+rotation_matrix*(a_offset/32.0*max(a_minFontScale,fontScale)+a_pxoffset/16.0),0.0,1.0);v_tex=a_tex/u_texsize;vec2 fade_opacity=unpack_opacity(a_fade_opacity);float fade_change=fade_opacity[1] > 0.5 ? u_fade_change :-u_fade_change;v_fade_opacity=max(0.0,min(1.0,fade_opacity[0]+fade_change));}`, sf = `#define SDF_PX 8.0
+uniform bool u_is_halo;uniform sampler2D u_texture;uniform highp float u_gamma_scale;uniform lowp float u_device_pixel_ratio;uniform bool u_is_text;varying vec2 v_data0;varying vec3 v_data1;
+#pragma mapbox: define highp vec4 fill_color
+#pragma mapbox: define highp vec4 halo_color
+#pragma mapbox: define lowp float opacity
+#pragma mapbox: define lowp float halo_width
+#pragma mapbox: define lowp float halo_blur
+void main() {
+#pragma mapbox: initialize highp vec4 fill_color
+#pragma mapbox: initialize highp vec4 halo_color
+#pragma mapbox: initialize lowp float opacity
+#pragma mapbox: initialize lowp float halo_width
+#pragma mapbox: initialize lowp float halo_blur
+float EDGE_GAMMA=0.105/u_device_pixel_ratio;vec2 tex=v_data0.xy;float gamma_scale=v_data1.x;float size=v_data1.y;float fade_opacity=v_data1[2];float fontScale=u_is_text ? size/24.0 : size;lowp vec4 color=fill_color;highp float gamma=EDGE_GAMMA/(fontScale*u_gamma_scale);lowp float buff=(256.0-64.0)/256.0;if (u_is_halo) {color=halo_color;gamma=(halo_blur*1.19/SDF_PX+EDGE_GAMMA)/(fontScale*u_gamma_scale);buff=(6.0-halo_width/fontScale)/SDF_PX;}lowp float dist=texture2D(u_texture,tex).a;highp float gamma_scaled=gamma*gamma_scale;highp float alpha=smoothstep(buff-gamma_scaled,buff+gamma_scaled,dist);gl_FragColor=color*(alpha*opacity*fade_opacity);
+#ifdef OVERDRAW_INSPECTOR
+gl_FragColor=vec4(1.0);
+#endif
+}`, Sh = `const float PI=3.141592653589793;attribute vec4 a_pos_offset;attribute vec4 a_data;attribute vec4 a_pixeloffset;attribute vec3 a_projected_pos;attribute float a_fade_opacity;uniform bool u_is_size_zoom_constant;uniform bool u_is_size_feature_constant;uniform highp float u_size_t;uniform highp float u_size;uniform mat4 u_matrix;uniform mat4 u_label_plane_matrix;uniform mat4 u_coord_matrix;uniform bool u_is_text;uniform bool u_pitch_with_map;uniform highp float u_pitch;uniform bool u_rotate_symbol;uniform highp float u_aspect_ratio;uniform highp float u_camera_to_center_distance;uniform float u_fade_change;uniform vec2 u_texsize;varying vec2 v_data0;varying vec3 v_data1;
+#pragma mapbox: define highp vec4 fill_color
+#pragma mapbox: define highp vec4 halo_color
+#pragma mapbox: define lowp float opacity
+#pragma mapbox: define lowp float halo_width
+#pragma mapbox: define lowp float halo_blur
+void main() {
+#pragma mapbox: initialize highp vec4 fill_color
+#pragma mapbox: initialize highp vec4 halo_color
+#pragma mapbox: initialize lowp float opacity
+#pragma mapbox: initialize lowp float halo_width
+#pragma mapbox: initialize lowp float halo_blur
+vec2 a_pos=a_pos_offset.xy;vec2 a_offset=a_pos_offset.zw;vec2 a_tex=a_data.xy;vec2 a_size=a_data.zw;float a_size_min=floor(a_size[0]*0.5);vec2 a_pxoffset=a_pixeloffset.xy;highp float segment_angle=-a_projected_pos[2];float size;if (!u_is_size_zoom_constant && !u_is_size_feature_constant) {size=mix(a_size_min,a_size[1],u_size_t)/128.0;} else if (u_is_size_zoom_constant && !u_is_size_feature_constant) {size=a_size_min/128.0;} else {size=u_size;}vec4 projectedPoint=u_matrix*vec4(a_pos,0,1);highp float camera_to_anchor_distance=projectedPoint.w;highp float distance_ratio=u_pitch_with_map ?
+camera_to_anchor_distance/u_camera_to_center_distance :
+u_camera_to_center_distance/camera_to_anchor_distance;highp float perspective_ratio=clamp(0.5+0.5*distance_ratio,0.0,4.0);size*=perspective_ratio;float fontScale=u_is_text ? size/24.0 : size;highp float symbol_rotation=0.0;if (u_rotate_symbol) {vec4 offsetProjectedPoint=u_matrix*vec4(a_pos+vec2(1,0),0,1);vec2 a=projectedPoint.xy/projectedPoint.w;vec2 b=offsetProjectedPoint.xy/offsetProjectedPoint.w;symbol_rotation=atan((b.y-a.y)/u_aspect_ratio,b.x-a.x);}highp float angle_sin=sin(segment_angle+symbol_rotation);highp float angle_cos=cos(segment_angle+symbol_rotation);mat2 rotation_matrix=mat2(angle_cos,-1.0*angle_sin,angle_sin,angle_cos);vec4 projected_pos=u_label_plane_matrix*vec4(a_projected_pos.xy,0.0,1.0);gl_Position=u_coord_matrix*vec4(projected_pos.xy/projected_pos.w+rotation_matrix*(a_offset/32.0*fontScale+a_pxoffset),0.0,1.0);float gamma_scale=gl_Position.w;vec2 fade_opacity=unpack_opacity(a_fade_opacity);float fade_change=fade_opacity[1] > 0.5 ? u_fade_change :-u_fade_change;float interpolated_fade_opacity=max(0.0,min(1.0,fade_opacity[0]+fade_change));v_data0=a_tex/u_texsize;v_data1=vec3(gamma_scale,size,interpolated_fade_opacity);}`, Mu = `#define SDF_PX 8.0
+#define SDF 1.0
+#define ICON 0.0
+uniform bool u_is_halo;uniform sampler2D u_texture;uniform sampler2D u_texture_icon;uniform highp float u_gamma_scale;uniform lowp float u_device_pixel_ratio;varying vec4 v_data0;varying vec4 v_data1;
+#pragma mapbox: define highp vec4 fill_color
+#pragma mapbox: define highp vec4 halo_color
+#pragma mapbox: define lowp float opacity
+#pragma mapbox: define lowp float halo_width
+#pragma mapbox: define lowp float halo_blur
+void main() {
+#pragma mapbox: initialize highp vec4 fill_color
+#pragma mapbox: initialize highp vec4 halo_color
+#pragma mapbox: initialize lowp float opacity
+#pragma mapbox: initialize lowp float halo_width
+#pragma mapbox: initialize lowp float halo_blur
+float fade_opacity=v_data1[2];if (v_data1.w==ICON) {vec2 tex_icon=v_data0.zw;lowp float alpha=opacity*fade_opacity;gl_FragColor=texture2D(u_texture_icon,tex_icon)*alpha;
+#ifdef OVERDRAW_INSPECTOR
+gl_FragColor=vec4(1.0);
+#endif
+return;}vec2 tex=v_data0.xy;float EDGE_GAMMA=0.105/u_device_pixel_ratio;float gamma_scale=v_data1.x;float size=v_data1.y;float fontScale=size/24.0;lowp vec4 color=fill_color;highp float gamma=EDGE_GAMMA/(fontScale*u_gamma_scale);lowp float buff=(256.0-64.0)/256.0;if (u_is_halo) {color=halo_color;gamma=(halo_blur*1.19/SDF_PX+EDGE_GAMMA)/(fontScale*u_gamma_scale);buff=(6.0-halo_width/fontScale)/SDF_PX;}lowp float dist=texture2D(u_texture,tex).a;highp float gamma_scaled=gamma*gamma_scale;highp float alpha=smoothstep(buff-gamma_scaled,buff+gamma_scaled,dist);gl_FragColor=color*(alpha*opacity*fade_opacity);
+#ifdef OVERDRAW_INSPECTOR
+gl_FragColor=vec4(1.0);
+#endif
+}`, ih = `const float PI=3.141592653589793;attribute vec4 a_pos_offset;attribute vec4 a_data;attribute vec3 a_projected_pos;attribute float a_fade_opacity;uniform bool u_is_size_zoom_constant;uniform bool u_is_size_feature_constant;uniform highp float u_size_t;uniform highp float u_size;uniform mat4 u_matrix;uniform mat4 u_label_plane_matrix;uniform mat4 u_coord_matrix;uniform bool u_is_text;uniform bool u_pitch_with_map;uniform highp float u_pitch;uniform bool u_rotate_symbol;uniform highp float u_aspect_ratio;uniform highp float u_camera_to_center_distance;uniform float u_fade_change;uniform vec2 u_texsize;uniform vec2 u_texsize_icon;varying vec4 v_data0;varying vec4 v_data1;
+#pragma mapbox: define highp vec4 fill_color
+#pragma mapbox: define highp vec4 halo_color
+#pragma mapbox: define lowp float opacity
+#pragma mapbox: define lowp float halo_width
+#pragma mapbox: define lowp float halo_blur
+void main() {
+#pragma mapbox: initialize highp vec4 fill_color
+#pragma mapbox: initialize highp vec4 halo_color
+#pragma mapbox: initialize lowp float opacity
+#pragma mapbox: initialize lowp float halo_width
+#pragma mapbox: initialize lowp float halo_blur
+vec2 a_pos=a_pos_offset.xy;vec2 a_offset=a_pos_offset.zw;vec2 a_tex=a_data.xy;vec2 a_size=a_data.zw;float a_size_min=floor(a_size[0]*0.5);float is_sdf=a_size[0]-2.0*a_size_min;highp float segment_angle=-a_projected_pos[2];float size;if (!u_is_size_zoom_constant && !u_is_size_feature_constant) {size=mix(a_size_min,a_size[1],u_size_t)/128.0;} else if (u_is_size_zoom_constant && !u_is_size_feature_constant) {size=a_size_min/128.0;} else {size=u_size;}vec4 projectedPoint=u_matrix*vec4(a_pos,0,1);highp float camera_to_anchor_distance=projectedPoint.w;highp float distance_ratio=u_pitch_with_map ?
+camera_to_anchor_distance/u_camera_to_center_distance :
+u_camera_to_center_distance/camera_to_anchor_distance;highp float perspective_ratio=clamp(0.5+0.5*distance_ratio,0.0,4.0);size*=perspective_ratio;float fontScale=size/24.0;highp float symbol_rotation=0.0;if (u_rotate_symbol) {vec4 offsetProjectedPoint=u_matrix*vec4(a_pos+vec2(1,0),0,1);vec2 a=projectedPoint.xy/projectedPoint.w;vec2 b=offsetProjectedPoint.xy/offsetProjectedPoint.w;symbol_rotation=atan((b.y-a.y)/u_aspect_ratio,b.x-a.x);}highp float angle_sin=sin(segment_angle+symbol_rotation);highp float angle_cos=cos(segment_angle+symbol_rotation);mat2 rotation_matrix=mat2(angle_cos,-1.0*angle_sin,angle_sin,angle_cos);vec4 projected_pos=u_label_plane_matrix*vec4(a_projected_pos.xy,0.0,1.0);gl_Position=u_coord_matrix*vec4(projected_pos.xy/projected_pos.w+rotation_matrix*(a_offset/32.0*fontScale),0.0,1.0);float gamma_scale=gl_Position.w;vec2 fade_opacity=unpack_opacity(a_fade_opacity);float fade_change=fade_opacity[1] > 0.5 ? u_fade_change :-u_fade_change;float interpolated_fade_opacity=max(0.0,min(1.0,fade_opacity[0]+fade_change));v_data0.xy=a_tex/u_texsize;v_data0.zw=a_tex/u_texsize_icon;v_data1=vec4(gamma_scale,size,interpolated_fade_opacity,is_sdf);}`, js = Us(Cf, sc), Eu = Us(jh, Lf), Dc = Us(cs, nf), ks = Us(Gf, $l), bc = Us(fl, lc), hu = Us(Fu, Es), _u = Us(Hs, Go), nl = Us(ps, uc), nh = Us(xl, Gu), Mh = Us(qs, od), zu = Us(Po, sd), Fc = Us(Ko, Pa), wc = Us(af, Hu), bd = Us(bl, Hf), xf = Us(Ic, yf), Pf = Us(Bl, Ah), Ou = Us(Qf, _f), bf = Us(Yc, eh), jl = Us(th, ju), lf = Us(jf, cc), Xh = Us(of, Nl), If = Us(Kc, Rc), Cs = Us(gs, Wf), du = Us(Wh, rh), ku = Us(sf, Sh), Xf = Us(Mu, ih);
+            function Us(Y, D) {
+              var J = /#pragma mapbox: ([\w]+) ([\w]+) ([\w]+) ([\w]+)/g, q = D.match(/attribute ([\w]+) ([\w]+)/g), K = Y.match(/uniform ([\w]+) ([\w]+)([\s]*)([\w]*)/g), de = D.match(/uniform ([\w]+) ([\w]+)([\s]*)([\w]*)/g), ne = de ? de.concat(K) : K, we = {};
+              return Y = Y.replace(J, function(Ue, ft, Zt, hr, qt) {
+                return we[qt] = true, ft === "define" ? `
+#ifndef HAS_UNIFORM_u_` + qt + `
+varying ` + Zt + " " + hr + " " + qt + `;
+#else
+uniform ` + Zt + " " + hr + " u_" + qt + `;
+#endif
+` : `
+#ifdef HAS_UNIFORM_u_` + qt + `
+    ` + Zt + " " + hr + " " + qt + " = u_" + qt + `;
+#endif
+`;
+              }), D = D.replace(J, function(Ue, ft, Zt, hr, qt) {
+                var Ve = hr === "float" ? "vec2" : "vec4", Qe = qt.match(/color/) ? "color" : Ve;
+                return we[qt] ? ft === "define" ? `
+#ifndef HAS_UNIFORM_u_` + qt + `
+uniform lowp float u_` + qt + `_t;
+attribute ` + Zt + " " + Ve + " a_" + qt + `;
+varying ` + Zt + " " + hr + " " + qt + `;
+#else
+uniform ` + Zt + " " + hr + " u_" + qt + `;
+#endif
+` : Qe === "vec4" ? `
+#ifndef HAS_UNIFORM_u_` + qt + `
+    ` + qt + " = a_" + qt + `;
+#else
+    ` + Zt + " " + hr + " " + qt + " = u_" + qt + `;
+#endif
+` : `
+#ifndef HAS_UNIFORM_u_` + qt + `
+    ` + qt + " = unpack_mix_" + Qe + "(a_" + qt + ", u_" + qt + `_t);
+#else
+    ` + Zt + " " + hr + " " + qt + " = u_" + qt + `;
+#endif
+` : ft === "define" ? `
+#ifndef HAS_UNIFORM_u_` + qt + `
+uniform lowp float u_` + qt + `_t;
+attribute ` + Zt + " " + Ve + " a_" + qt + `;
+#else
+uniform ` + Zt + " " + hr + " u_" + qt + `;
+#endif
+` : Qe === "vec4" ? `
+#ifndef HAS_UNIFORM_u_` + qt + `
+    ` + Zt + " " + hr + " " + qt + " = a_" + qt + `;
+#else
+    ` + Zt + " " + hr + " " + qt + " = u_" + qt + `;
+#endif
+` : `
+#ifndef HAS_UNIFORM_u_` + qt + `
+    ` + Zt + " " + hr + " " + qt + " = unpack_mix_" + Qe + "(a_" + qt + ", u_" + qt + `_t);
+#else
+    ` + Zt + " " + hr + " " + qt + " = u_" + qt + `;
+#endif
+`;
+              }), { fragmentSource: Y, vertexSource: D, staticAttributes: q, staticUniforms: ne };
+            }
+            var wf = Object.freeze({ __proto__: null, prelude: js, background: Eu, backgroundPattern: Dc, circle: ks, clippingMask: bc, heatmap: hu, heatmapTexture: _u, collisionBox: nl, collisionCircle: nh, debug: Mh, fill: zu, fillOutline: Fc, fillOutlinePattern: wc, fillPattern: bd, fillExtrusion: xf, fillExtrusionPattern: Pf, hillshadePrepare: Ou, hillshade: bf, line: jl, lineGradient: lf, linePattern: Xh, lineSDF: If, raster: Cs, symbolIcon: du, symbolSDF: ku, symbolTextAndIcon: Xf }), zc = function() {
+              this.boundProgram = null, this.boundLayoutVertexBuffer = null, this.boundPaintVertexBuffers = [], this.boundIndexBuffer = null, this.boundVertexOffset = null, this.boundDynamicVertexBuffer = null, this.vao = null;
+            };
+            zc.prototype.bind = function(D, J, q, K, de, ne, we, Ue) {
+              this.context = D;
+              for (var ft = this.boundPaintVertexBuffers.length !== K.length, Zt = 0; !ft && Zt < K.length; Zt++) this.boundPaintVertexBuffers[Zt] !== K[Zt] && (ft = true);
+              var hr = !this.vao || this.boundProgram !== J || this.boundLayoutVertexBuffer !== q || ft || this.boundIndexBuffer !== de || this.boundVertexOffset !== ne || this.boundDynamicVertexBuffer !== we || this.boundDynamicVertexBuffer2 !== Ue;
+              !D.extVertexArrayObject || hr ? this.freshBind(J, q, K, de, ne, we, Ue) : (D.bindVertexArrayOES.set(this.vao), we && we.bind(), de && de.dynamicDraw && de.bind(), Ue && Ue.bind());
+            }, zc.prototype.freshBind = function(D, J, q, K, de, ne, we) {
+              var Ue, ft = D.numAttributes, Zt = this.context, hr = Zt.gl;
+              if (Zt.extVertexArrayObject) this.vao && this.destroy(), this.vao = Zt.extVertexArrayObject.createVertexArrayOES(), Zt.bindVertexArrayOES.set(this.vao), Ue = 0, this.boundProgram = D, this.boundLayoutVertexBuffer = J, this.boundPaintVertexBuffers = q, this.boundIndexBuffer = K, this.boundVertexOffset = de, this.boundDynamicVertexBuffer = ne, this.boundDynamicVertexBuffer2 = we;
+              else {
+                Ue = Zt.currentNumAttributes || 0;
+                for (var qt = ft; qt < Ue; qt++) hr.disableVertexAttribArray(qt);
+              }
+              J.enableAttributes(hr, D);
+              for (var Ve = 0, Qe = q; Ve < Qe.length; Ve += 1) {
+                var at = Qe[Ve];
+                at.enableAttributes(hr, D);
+              }
+              ne && ne.enableAttributes(hr, D), we && we.enableAttributes(hr, D), J.bind(), J.setVertexAttribPointers(hr, D, de);
+              for (var Ct = 0, Ot = q; Ct < Ot.length; Ct += 1) {
+                var Rt = Ot[Ct];
+                Rt.bind(), Rt.setVertexAttribPointers(hr, D, de);
+              }
+              ne && (ne.bind(), ne.setVertexAttribPointers(hr, D, de)), K && K.bind(), we && (we.bind(), we.setVertexAttribPointers(hr, D, de)), Zt.currentNumAttributes = ft;
+            }, zc.prototype.destroy = function() {
+              this.vao && (this.context.extVertexArrayObject.deleteVertexArrayOES(this.vao), this.vao = null);
+            };
+            function Wu(Y) {
+              for (var D = [], J = 0; J < Y.length; J++) if (Y[J] !== null) {
+                var q = Y[J].split(" ");
+                D.push(q.pop());
+              }
+              return D;
+            }
+            var Rf = function(D, J, q, K, de, ne) {
+              var we = D.gl;
+              this.program = we.createProgram();
+              for (var Ue = Wu(q.staticAttributes), ft = K ? K.getBinderAttributes() : [], Zt = Ue.concat(ft), hr = q.staticUniforms ? Wu(q.staticUniforms) : [], qt = K ? K.getBinderUniforms() : [], Ve = hr.concat(qt), Qe = [], at = 0, Ct = Ve; at < Ct.length; at += 1) {
+                var Ot = Ct[at];
+                Qe.indexOf(Ot) < 0 && Qe.push(Ot);
+              }
+              var Rt = K ? K.defines() : [];
+              ne && Rt.push("#define OVERDRAW_INSPECTOR;");
+              var Bt = Rt.concat(js.fragmentSource, q.fragmentSource).join(`
+`), Dt = Rt.concat(js.vertexSource, q.vertexSource).join(`
+`), yt = we.createShader(we.FRAGMENT_SHADER);
+              if (we.isContextLost()) {
+                this.failedToCreate = true;
+                return;
+              }
+              we.shaderSource(yt, Bt), we.compileShader(yt), we.attachShader(this.program, yt);
+              var Pt = we.createShader(we.VERTEX_SHADER);
+              if (we.isContextLost()) {
+                this.failedToCreate = true;
+                return;
+              }
+              we.shaderSource(Pt, Dt), we.compileShader(Pt), we.attachShader(this.program, Pt), this.attributes = {};
+              var ht = {};
+              this.numAttributes = Zt.length;
+              for (var ur = 0; ur < this.numAttributes; ur++) Zt[ur] && (we.bindAttribLocation(this.program, ur, Zt[ur]), this.attributes[Zt[ur]] = ur);
+              we.linkProgram(this.program), we.deleteShader(Pt), we.deleteShader(yt);
+              for (var br = 0; br < Qe.length; br++) {
+                var Ur = Qe[br];
+                if (Ur && !ht[Ur]) {
+                  var Di = we.getUniformLocation(this.program, Ur);
+                  Di && (ht[Ur] = Di);
+                }
+              }
+              this.fixedUniforms = de(D, ht), this.binderUniforms = K ? K.getUniforms(D, ht) : [];
+            };
+            Rf.prototype.draw = function(D, J, q, K, de, ne, we, Ue, ft, Zt, hr, qt, Ve, Qe, at, Ct) {
+              var Ot, Rt = D.gl;
+              if (!this.failedToCreate) {
+                D.program.set(this.program), D.setDepthMode(q), D.setStencilMode(K), D.setColorMode(de), D.setCullFace(ne);
+                for (var Bt in this.fixedUniforms) this.fixedUniforms[Bt].set(we[Bt]);
+                Qe && Qe.setUniforms(D, this.binderUniforms, qt, { zoom: Ve });
+                for (var Dt = (Ot = {}, Ot[Rt.LINES] = 2, Ot[Rt.TRIANGLES] = 3, Ot[Rt.LINE_STRIP] = 1, Ot)[J], yt = 0, Pt = hr.get(); yt < Pt.length; yt += 1) {
+                  var ht = Pt[yt], ur = ht.vaos || (ht.vaos = {}), br = ur[Ue] || (ur[Ue] = new zc());
+                  br.bind(D, this, ft, Qe ? Qe.getPaintVertexBuffers() : [], Zt, ht.vertexOffset, at, Ct), Rt.drawElements(J, ht.primitiveLength * Dt, Rt.UNSIGNED_SHORT, ht.primitiveOffset * Dt * 2);
+                }
+              }
+            };
+            function Xu(Y, D, J) {
+              var q = 1 / As(J, 1, D.transform.tileZoom), K = Math.pow(2, J.tileID.overscaledZ), de = J.tileSize * Math.pow(2, D.transform.tileZoom) / K, ne = de * (J.tileID.canonical.x + J.tileID.wrap * K), we = de * J.tileID.canonical.y;
+              return { u_image: 0, u_texsize: J.imageAtlasTexture.size, u_scale: [q, Y.fromScale, Y.toScale], u_fade: Y.t, u_pixel_coord_upper: [ne >> 16, we >> 16], u_pixel_coord_lower: [ne & 65535, we & 65535] };
+            }
+            function uf(Y, D, J, q) {
+              var K = J.imageManager.getPattern(Y.from.toString()), de = J.imageManager.getPattern(Y.to.toString()), ne = J.imageManager.getPixelSize(), we = ne.width, Ue = ne.height, ft = Math.pow(2, q.tileID.overscaledZ), Zt = q.tileSize * Math.pow(2, J.transform.tileZoom) / ft, hr = Zt * (q.tileID.canonical.x + q.tileID.wrap * ft), qt = Zt * q.tileID.canonical.y;
+              return { u_image: 0, u_pattern_tl_a: K.tl, u_pattern_br_a: K.br, u_pattern_tl_b: de.tl, u_pattern_br_b: de.br, u_texsize: [we, Ue], u_mix: D.t, u_pattern_size_a: K.displaySize, u_pattern_size_b: de.displaySize, u_scale_a: D.fromScale, u_scale_b: D.toScale, u_tile_units_to_pixels: 1 / As(q, 1, J.transform.tileZoom), u_pixel_coord_upper: [hr >> 16, qt >> 16], u_pixel_coord_lower: [hr & 65535, qt & 65535] };
+            }
+            var Zf = function(Y, D) {
+              return { u_matrix: new i.UniformMatrix4f(Y, D.u_matrix), u_lightpos: new i.Uniform3f(Y, D.u_lightpos), u_lightintensity: new i.Uniform1f(Y, D.u_lightintensity), u_lightcolor: new i.Uniform3f(Y, D.u_lightcolor), u_vertical_gradient: new i.Uniform1f(Y, D.u_vertical_gradient), u_opacity: new i.Uniform1f(Y, D.u_opacity) };
+            }, Wl = function(Y, D) {
+              return { u_matrix: new i.UniformMatrix4f(Y, D.u_matrix), u_lightpos: new i.Uniform3f(Y, D.u_lightpos), u_lightintensity: new i.Uniform1f(Y, D.u_lightintensity), u_lightcolor: new i.Uniform3f(Y, D.u_lightcolor), u_vertical_gradient: new i.Uniform1f(Y, D.u_vertical_gradient), u_height_factor: new i.Uniform1f(Y, D.u_height_factor), u_image: new i.Uniform1i(Y, D.u_image), u_texsize: new i.Uniform2f(Y, D.u_texsize), u_pixel_coord_upper: new i.Uniform2f(Y, D.u_pixel_coord_upper), u_pixel_coord_lower: new i.Uniform2f(Y, D.u_pixel_coord_lower), u_scale: new i.Uniform3f(Y, D.u_scale), u_fade: new i.Uniform1f(Y, D.u_fade), u_opacity: new i.Uniform1f(Y, D.u_opacity) };
+            }, ah = function(Y, D, J, q) {
+              var K = D.style.light, de = K.properties.get("position"), ne = [de.x, de.y, de.z], we = i.create$1();
+              K.properties.get("anchor") === "viewport" && i.fromRotation(we, -D.transform.angle), i.transformMat3(ne, ne, we);
+              var Ue = K.properties.get("color");
+              return { u_matrix: Y, u_lightpos: ne, u_lightintensity: K.properties.get("intensity"), u_lightcolor: [Ue.r, Ue.g, Ue.b], u_vertical_gradient: +J, u_opacity: q };
+            }, Zu = function(Y, D, J, q, K, de, ne) {
+              return i.extend(ah(Y, D, J, q), Xu(de, D, ne), { u_height_factor: -Math.pow(2, K.overscaledZ) / ne.tileSize / 8 });
+            }, Oc = function(Y, D) {
+              return { u_matrix: new i.UniformMatrix4f(Y, D.u_matrix) };
+            }, Tc = function(Y, D) {
+              return { u_matrix: new i.UniformMatrix4f(Y, D.u_matrix), u_image: new i.Uniform1i(Y, D.u_image), u_texsize: new i.Uniform2f(Y, D.u_texsize), u_pixel_coord_upper: new i.Uniform2f(Y, D.u_pixel_coord_upper), u_pixel_coord_lower: new i.Uniform2f(Y, D.u_pixel_coord_lower), u_scale: new i.Uniform3f(Y, D.u_scale), u_fade: new i.Uniform1f(Y, D.u_fade) };
+            }, wl = function(Y, D) {
+              return { u_matrix: new i.UniformMatrix4f(Y, D.u_matrix), u_world: new i.Uniform2f(Y, D.u_world) };
+            }, vu = function(Y, D) {
+              return { u_matrix: new i.UniformMatrix4f(Y, D.u_matrix), u_world: new i.Uniform2f(Y, D.u_world), u_image: new i.Uniform1i(Y, D.u_image), u_texsize: new i.Uniform2f(Y, D.u_texsize), u_pixel_coord_upper: new i.Uniform2f(Y, D.u_pixel_coord_upper), u_pixel_coord_lower: new i.Uniform2f(Y, D.u_pixel_coord_lower), u_scale: new i.Uniform3f(Y, D.u_scale), u_fade: new i.Uniform1f(Y, D.u_fade) };
+            }, qc = function(Y) {
+              return { u_matrix: Y };
+            }, cf = function(Y, D, J, q) {
+              return i.extend(qc(Y), Xu(J, D, q));
+            }, fc = function(Y, D) {
+              return { u_matrix: Y, u_world: D };
+            }, Bc = function(Y, D, J, q, K) {
+              return i.extend(cf(Y, D, J, q), { u_world: K });
+            }, At = function(Y, D) {
+              return { u_camera_to_center_distance: new i.Uniform1f(Y, D.u_camera_to_center_distance), u_scale_with_map: new i.Uniform1i(Y, D.u_scale_with_map), u_pitch_with_map: new i.Uniform1i(Y, D.u_pitch_with_map), u_extrude_scale: new i.Uniform2f(Y, D.u_extrude_scale), u_device_pixel_ratio: new i.Uniform1f(Y, D.u_device_pixel_ratio), u_matrix: new i.UniformMatrix4f(Y, D.u_matrix) };
+            }, Xt = function(Y, D, J, q) {
+              var K = Y.transform, de, ne;
+              if (q.paint.get("circle-pitch-alignment") === "map") {
+                var we = As(J, 1, K.zoom);
+                de = true, ne = [we, we];
+              } else de = false, ne = K.pixelsToGLUnits;
+              return { u_camera_to_center_distance: K.cameraToCenterDistance, u_scale_with_map: +(q.paint.get("circle-pitch-scale") === "map"), u_matrix: Y.translatePosMatrix(D.posMatrix, J, q.paint.get("circle-translate"), q.paint.get("circle-translate-anchor")), u_pitch_with_map: +de, u_device_pixel_ratio: i.browser.devicePixelRatio, u_extrude_scale: ne };
+            }, Cr = function(Y, D) {
+              return { u_matrix: new i.UniformMatrix4f(Y, D.u_matrix), u_camera_to_center_distance: new i.Uniform1f(Y, D.u_camera_to_center_distance), u_pixels_to_tile_units: new i.Uniform1f(Y, D.u_pixels_to_tile_units), u_extrude_scale: new i.Uniform2f(Y, D.u_extrude_scale), u_overscale_factor: new i.Uniform1f(Y, D.u_overscale_factor) };
+            }, Ar = function(Y, D) {
+              return { u_matrix: new i.UniformMatrix4f(Y, D.u_matrix), u_inv_matrix: new i.UniformMatrix4f(Y, D.u_inv_matrix), u_camera_to_center_distance: new i.Uniform1f(Y, D.u_camera_to_center_distance), u_viewport_size: new i.Uniform2f(Y, D.u_viewport_size) };
+            }, Kr = function(Y, D, J) {
+              var q = As(J, 1, D.zoom), K = Math.pow(2, D.zoom - J.tileID.overscaledZ), de = J.tileID.overscaleFactor();
+              return { u_matrix: Y, u_camera_to_center_distance: D.cameraToCenterDistance, u_pixels_to_tile_units: q, u_extrude_scale: [D.pixelsToGLUnits[0] / (q * K), D.pixelsToGLUnits[1] / (q * K)], u_overscale_factor: de };
+            }, ki = function(Y, D, J) {
+              return { u_matrix: Y, u_inv_matrix: D, u_camera_to_center_distance: J.cameraToCenterDistance, u_viewport_size: [J.width, J.height] };
+            }, Xi = function(Y, D) {
+              return { u_color: new i.UniformColor(Y, D.u_color), u_matrix: new i.UniformMatrix4f(Y, D.u_matrix), u_overlay: new i.Uniform1i(Y, D.u_overlay), u_overlay_scale: new i.Uniform1f(Y, D.u_overlay_scale) };
+            }, dn = function(Y, D, J) {
+              return J === void 0 && (J = 1), { u_matrix: Y, u_color: D, u_overlay: 0, u_overlay_scale: J };
+            }, wn = function(Y, D) {
+              return { u_matrix: new i.UniformMatrix4f(Y, D.u_matrix) };
+            }, Nn = function(Y) {
+              return { u_matrix: Y };
+            }, Yi = function(Y, D) {
+              return { u_extrude_scale: new i.Uniform1f(Y, D.u_extrude_scale), u_intensity: new i.Uniform1f(Y, D.u_intensity), u_matrix: new i.UniformMatrix4f(Y, D.u_matrix) };
+            }, Qi = function(Y, D) {
+              return { u_matrix: new i.UniformMatrix4f(Y, D.u_matrix), u_world: new i.Uniform2f(Y, D.u_world), u_image: new i.Uniform1i(Y, D.u_image), u_color_ramp: new i.Uniform1i(Y, D.u_color_ramp), u_opacity: new i.Uniform1f(Y, D.u_opacity) };
+            }, on = function(Y, D, J, q) {
+              return { u_matrix: Y, u_extrude_scale: As(D, 1, J), u_intensity: q };
+            }, Fi = function(Y, D, J, q) {
+              var K = i.create();
+              i.ortho(K, 0, Y.width, Y.height, 0, 0, 1);
+              var de = Y.context.gl;
+              return { u_matrix: K, u_world: [de.drawingBufferWidth, de.drawingBufferHeight], u_image: J, u_color_ramp: q, u_opacity: D.paint.get("heatmap-opacity") };
+            }, Qn = function(Y, D) {
+              return { u_matrix: new i.UniformMatrix4f(Y, D.u_matrix), u_image: new i.Uniform1i(Y, D.u_image), u_latrange: new i.Uniform2f(Y, D.u_latrange), u_light: new i.Uniform2f(Y, D.u_light), u_shadow: new i.UniformColor(Y, D.u_shadow), u_highlight: new i.UniformColor(Y, D.u_highlight), u_accent: new i.UniformColor(Y, D.u_accent) };
+            }, Ca = function(Y, D) {
+              return { u_matrix: new i.UniformMatrix4f(Y, D.u_matrix), u_image: new i.Uniform1i(Y, D.u_image), u_dimension: new i.Uniform2f(Y, D.u_dimension), u_zoom: new i.Uniform1f(Y, D.u_zoom), u_unpack: new i.Uniform4f(Y, D.u_unpack) };
+            }, Ra = function(Y, D, J) {
+              var q = J.paint.get("hillshade-shadow-color"), K = J.paint.get("hillshade-highlight-color"), de = J.paint.get("hillshade-accent-color"), ne = J.paint.get("hillshade-illumination-direction") * (Math.PI / 180);
+              J.paint.get("hillshade-illumination-anchor") === "viewport" && (ne -= Y.transform.angle);
+              var we = !Y.options.moving;
+              return { u_matrix: Y.transform.calculatePosMatrix(D.tileID.toUnwrapped(), we), u_image: 0, u_latrange: Na(Y, D.tileID), u_light: [J.paint.get("hillshade-exaggeration"), ne], u_shadow: q, u_highlight: K, u_accent: de };
+            }, La = function(Y, D) {
+              var J = D.stride, q = i.create();
+              return i.ortho(q, 0, i.EXTENT, -i.EXTENT, 0, 0, 1), i.translate(q, q, [0, -i.EXTENT, 0]), { u_matrix: q, u_image: 1, u_dimension: [J, J], u_zoom: Y.overscaledZ, u_unpack: D.getUnpackVector() };
+            };
+            function Na(Y, D) {
+              var J = Math.pow(2, D.canonical.z), q = D.canonical.y;
+              return [new i.MercatorCoordinate(0, q / J).toLngLat().lat, new i.MercatorCoordinate(0, (q + 1) / J).toLngLat().lat];
+            }
+            var Yn = function(Y, D) {
+              return { u_matrix: new i.UniformMatrix4f(Y, D.u_matrix), u_ratio: new i.Uniform1f(Y, D.u_ratio), u_device_pixel_ratio: new i.Uniform1f(Y, D.u_device_pixel_ratio), u_units_to_pixels: new i.Uniform2f(Y, D.u_units_to_pixels) };
+            }, Dn = function(Y, D) {
+              return { u_matrix: new i.UniformMatrix4f(Y, D.u_matrix), u_ratio: new i.Uniform1f(Y, D.u_ratio), u_device_pixel_ratio: new i.Uniform1f(Y, D.u_device_pixel_ratio), u_units_to_pixels: new i.Uniform2f(Y, D.u_units_to_pixels), u_image: new i.Uniform1i(Y, D.u_image), u_image_height: new i.Uniform1f(Y, D.u_image_height) };
+            }, Ka = function(Y, D) {
+              return { u_matrix: new i.UniformMatrix4f(Y, D.u_matrix), u_texsize: new i.Uniform2f(Y, D.u_texsize), u_ratio: new i.Uniform1f(Y, D.u_ratio), u_device_pixel_ratio: new i.Uniform1f(Y, D.u_device_pixel_ratio), u_image: new i.Uniform1i(Y, D.u_image), u_units_to_pixels: new i.Uniform2f(Y, D.u_units_to_pixels), u_scale: new i.Uniform3f(Y, D.u_scale), u_fade: new i.Uniform1f(Y, D.u_fade) };
+            }, bo = function(Y, D) {
+              return { u_matrix: new i.UniformMatrix4f(Y, D.u_matrix), u_ratio: new i.Uniform1f(Y, D.u_ratio), u_device_pixel_ratio: new i.Uniform1f(Y, D.u_device_pixel_ratio), u_units_to_pixels: new i.Uniform2f(Y, D.u_units_to_pixels), u_patternscale_a: new i.Uniform2f(Y, D.u_patternscale_a), u_patternscale_b: new i.Uniform2f(Y, D.u_patternscale_b), u_sdfgamma: new i.Uniform1f(Y, D.u_sdfgamma), u_image: new i.Uniform1i(Y, D.u_image), u_tex_y_a: new i.Uniform1f(Y, D.u_tex_y_a), u_tex_y_b: new i.Uniform1f(Y, D.u_tex_y_b), u_mix: new i.Uniform1f(Y, D.u_mix) };
+            }, Zo = function(Y, D, J) {
+              var q = Y.transform;
+              return { u_matrix: ml(Y, D, J), u_ratio: 1 / As(D, 1, q.zoom), u_device_pixel_ratio: i.browser.devicePixelRatio, u_units_to_pixels: [1 / q.pixelsToGLUnits[0], 1 / q.pixelsToGLUnits[1]] };
+            }, Ss = function(Y, D, J, q) {
+              return i.extend(Zo(Y, D, J), { u_image: 0, u_image_height: q });
+            }, as = function(Y, D, J, q) {
+              var K = Y.transform, de = Ho(D, K);
+              return { u_matrix: ml(Y, D, J), u_texsize: D.imageAtlasTexture.size, u_ratio: 1 / As(D, 1, K.zoom), u_device_pixel_ratio: i.browser.devicePixelRatio, u_image: 0, u_scale: [de, q.fromScale, q.toScale], u_fade: q.t, u_units_to_pixels: [1 / K.pixelsToGLUnits[0], 1 / K.pixelsToGLUnits[1]] };
+            }, ws = function(Y, D, J, q, K) {
+              var de = Y.transform, ne = Y.lineAtlas, we = Ho(D, de), Ue = J.layout.get("line-cap") === "round", ft = ne.getDash(q.from, Ue), Zt = ne.getDash(q.to, Ue), hr = ft.width * K.fromScale, qt = Zt.width * K.toScale;
+              return i.extend(Zo(Y, D, J), { u_patternscale_a: [we / hr, -ft.height / 2], u_patternscale_b: [we / qt, -Zt.height / 2], u_sdfgamma: ne.width / (Math.min(hr, qt) * 256 * i.browser.devicePixelRatio) / 2, u_image: 0, u_tex_y_a: ft.y, u_tex_y_b: Zt.y, u_mix: K.t });
+            };
+            function Ho(Y, D) {
+              return 1 / As(Y, 1, D.tileZoom);
+            }
+            function ml(Y, D, J) {
+              return Y.translatePosMatrix(D.tileID.posMatrix, D, J.paint.get("line-translate"), J.paint.get("line-translate-anchor"));
+            }
+            var Ws = function(Y, D) {
+              return { u_matrix: new i.UniformMatrix4f(Y, D.u_matrix), u_tl_parent: new i.Uniform2f(Y, D.u_tl_parent), u_scale_parent: new i.Uniform1f(Y, D.u_scale_parent), u_buffer_scale: new i.Uniform1f(Y, D.u_buffer_scale), u_fade_t: new i.Uniform1f(Y, D.u_fade_t), u_opacity: new i.Uniform1f(Y, D.u_opacity), u_image0: new i.Uniform1i(Y, D.u_image0), u_image1: new i.Uniform1i(Y, D.u_image1), u_brightness_low: new i.Uniform1f(Y, D.u_brightness_low), u_brightness_high: new i.Uniform1f(Y, D.u_brightness_high), u_saturation_factor: new i.Uniform1f(Y, D.u_saturation_factor), u_contrast_factor: new i.Uniform1f(Y, D.u_contrast_factor), u_spin_weights: new i.Uniform3f(Y, D.u_spin_weights) };
+            }, Ls = function(Y, D, J, q, K) {
+              return { u_matrix: Y, u_tl_parent: D, u_scale_parent: J, u_buffer_scale: 1, u_fade_t: q.mix, u_opacity: q.opacity * K.paint.get("raster-opacity"), u_image0: 0, u_image1: 1, u_brightness_low: K.paint.get("raster-brightness-min"), u_brightness_high: K.paint.get("raster-brightness-max"), u_saturation_factor: ys(K.paint.get("raster-saturation")), u_contrast_factor: no(K.paint.get("raster-contrast")), u_spin_weights: va(K.paint.get("raster-hue-rotate")) };
+            };
+            function va(Y) {
+              Y *= Math.PI / 180;
+              var D = Math.sin(Y), J = Math.cos(Y);
+              return [(2 * J + 1) / 3, (-Math.sqrt(3) * D - J + 1) / 3, (Math.sqrt(3) * D - J + 1) / 3];
+            }
+            function no(Y) {
+              return Y > 0 ? 1 / (1 - Y) : 1 + Y;
+            }
+            function ys(Y) {
+              return Y > 0 ? 1 - 1 / (1.001 - Y) : -Y;
+            }
+            var rs = function(Y, D) {
+              return { u_is_size_zoom_constant: new i.Uniform1i(Y, D.u_is_size_zoom_constant), u_is_size_feature_constant: new i.Uniform1i(Y, D.u_is_size_feature_constant), u_size_t: new i.Uniform1f(Y, D.u_size_t), u_size: new i.Uniform1f(Y, D.u_size), u_camera_to_center_distance: new i.Uniform1f(Y, D.u_camera_to_center_distance), u_pitch: new i.Uniform1f(Y, D.u_pitch), u_rotate_symbol: new i.Uniform1i(Y, D.u_rotate_symbol), u_aspect_ratio: new i.Uniform1f(Y, D.u_aspect_ratio), u_fade_change: new i.Uniform1f(Y, D.u_fade_change), u_matrix: new i.UniformMatrix4f(Y, D.u_matrix), u_label_plane_matrix: new i.UniformMatrix4f(Y, D.u_label_plane_matrix), u_coord_matrix: new i.UniformMatrix4f(Y, D.u_coord_matrix), u_is_text: new i.Uniform1i(Y, D.u_is_text), u_pitch_with_map: new i.Uniform1i(Y, D.u_pitch_with_map), u_texsize: new i.Uniform2f(Y, D.u_texsize), u_texture: new i.Uniform1i(Y, D.u_texture) };
+            }, Ql = function(Y, D) {
+              return { u_is_size_zoom_constant: new i.Uniform1i(Y, D.u_is_size_zoom_constant), u_is_size_feature_constant: new i.Uniform1i(Y, D.u_is_size_feature_constant), u_size_t: new i.Uniform1f(Y, D.u_size_t), u_size: new i.Uniform1f(Y, D.u_size), u_camera_to_center_distance: new i.Uniform1f(Y, D.u_camera_to_center_distance), u_pitch: new i.Uniform1f(Y, D.u_pitch), u_rotate_symbol: new i.Uniform1i(Y, D.u_rotate_symbol), u_aspect_ratio: new i.Uniform1f(Y, D.u_aspect_ratio), u_fade_change: new i.Uniform1f(Y, D.u_fade_change), u_matrix: new i.UniformMatrix4f(Y, D.u_matrix), u_label_plane_matrix: new i.UniformMatrix4f(Y, D.u_label_plane_matrix), u_coord_matrix: new i.UniformMatrix4f(Y, D.u_coord_matrix), u_is_text: new i.Uniform1i(Y, D.u_is_text), u_pitch_with_map: new i.Uniform1i(Y, D.u_pitch_with_map), u_texsize: new i.Uniform2f(Y, D.u_texsize), u_texture: new i.Uniform1i(Y, D.u_texture), u_gamma_scale: new i.Uniform1f(Y, D.u_gamma_scale), u_device_pixel_ratio: new i.Uniform1f(Y, D.u_device_pixel_ratio), u_is_halo: new i.Uniform1i(Y, D.u_is_halo) };
+            }, Cu = function(Y, D) {
+              return { u_is_size_zoom_constant: new i.Uniform1i(Y, D.u_is_size_zoom_constant), u_is_size_feature_constant: new i.Uniform1i(Y, D.u_is_size_feature_constant), u_size_t: new i.Uniform1f(Y, D.u_size_t), u_size: new i.Uniform1f(Y, D.u_size), u_camera_to_center_distance: new i.Uniform1f(Y, D.u_camera_to_center_distance), u_pitch: new i.Uniform1f(Y, D.u_pitch), u_rotate_symbol: new i.Uniform1i(Y, D.u_rotate_symbol), u_aspect_ratio: new i.Uniform1f(Y, D.u_aspect_ratio), u_fade_change: new i.Uniform1f(Y, D.u_fade_change), u_matrix: new i.UniformMatrix4f(Y, D.u_matrix), u_label_plane_matrix: new i.UniformMatrix4f(Y, D.u_label_plane_matrix), u_coord_matrix: new i.UniformMatrix4f(Y, D.u_coord_matrix), u_is_text: new i.Uniform1i(Y, D.u_is_text), u_pitch_with_map: new i.Uniform1i(Y, D.u_pitch_with_map), u_texsize: new i.Uniform2f(Y, D.u_texsize), u_texsize_icon: new i.Uniform2f(Y, D.u_texsize_icon), u_texture: new i.Uniform1i(Y, D.u_texture), u_texture_icon: new i.Uniform1i(Y, D.u_texture_icon), u_gamma_scale: new i.Uniform1f(Y, D.u_gamma_scale), u_device_pixel_ratio: new i.Uniform1f(Y, D.u_device_pixel_ratio), u_is_halo: new i.Uniform1i(Y, D.u_is_halo) };
+            }, Yu = function(Y, D, J, q, K, de, ne, we, Ue, ft) {
+              var Zt = K.transform;
+              return { u_is_size_zoom_constant: +(Y === "constant" || Y === "source"), u_is_size_feature_constant: +(Y === "constant" || Y === "camera"), u_size_t: D ? D.uSizeT : 0, u_size: D ? D.uSize : 0, u_camera_to_center_distance: Zt.cameraToCenterDistance, u_pitch: Zt.pitch / 360 * 2 * Math.PI, u_rotate_symbol: +J, u_aspect_ratio: Zt.width / Zt.height, u_fade_change: K.options.fadeDuration ? K.symbolFadeChange : 1, u_matrix: de, u_label_plane_matrix: ne, u_coord_matrix: we, u_is_text: +Ue, u_pitch_with_map: +q, u_texsize: ft, u_texture: 0 };
+            }, Nc = function(Y, D, J, q, K, de, ne, we, Ue, ft, Zt) {
+              var hr = K.transform;
+              return i.extend(Yu(Y, D, J, q, K, de, ne, we, Ue, ft), { u_gamma_scale: q ? Math.cos(hr._pitch) * hr.cameraToCenterDistance : 1, u_device_pixel_ratio: i.browser.devicePixelRatio, u_is_halo: 1 });
+            }, pu = function(Y, D, J, q, K, de, ne, we, Ue, ft) {
+              return i.extend(Nc(Y, D, J, q, K, de, ne, we, true, Ue), { u_texsize_icon: ft, u_texture_icon: 1 });
+            }, Uc = function(Y, D) {
+              return { u_matrix: new i.UniformMatrix4f(Y, D.u_matrix), u_opacity: new i.Uniform1f(Y, D.u_opacity), u_color: new i.UniformColor(Y, D.u_color) };
+            }, xu = function(Y, D) {
+              return { u_matrix: new i.UniformMatrix4f(Y, D.u_matrix), u_opacity: new i.Uniform1f(Y, D.u_opacity), u_image: new i.Uniform1i(Y, D.u_image), u_pattern_tl_a: new i.Uniform2f(Y, D.u_pattern_tl_a), u_pattern_br_a: new i.Uniform2f(Y, D.u_pattern_br_a), u_pattern_tl_b: new i.Uniform2f(Y, D.u_pattern_tl_b), u_pattern_br_b: new i.Uniform2f(Y, D.u_pattern_br_b), u_texsize: new i.Uniform2f(Y, D.u_texsize), u_mix: new i.Uniform1f(Y, D.u_mix), u_pattern_size_a: new i.Uniform2f(Y, D.u_pattern_size_a), u_pattern_size_b: new i.Uniform2f(Y, D.u_pattern_size_b), u_scale_a: new i.Uniform1f(Y, D.u_scale_a), u_scale_b: new i.Uniform1f(Y, D.u_scale_b), u_pixel_coord_upper: new i.Uniform2f(Y, D.u_pixel_coord_upper), u_pixel_coord_lower: new i.Uniform2f(Y, D.u_pixel_coord_lower), u_tile_units_to_pixels: new i.Uniform1f(Y, D.u_tile_units_to_pixels) };
+            }, Ac = function(Y, D, J) {
+              return { u_matrix: Y, u_opacity: D, u_color: J };
+            }, Ua = function(Y, D, J, q, K, de) {
+              return i.extend(uf(q, de, J, K), { u_matrix: Y, u_opacity: D });
+            }, oo = { fillExtrusion: Zf, fillExtrusionPattern: Wl, fill: Oc, fillPattern: Tc, fillOutline: wl, fillOutlinePattern: vu, circle: At, collisionBox: Cr, collisionCircle: Ar, debug: Xi, clippingMask: wn, heatmap: Yi, heatmapTexture: Qi, hillshade: Qn, hillshadePrepare: Ca, line: Yn, lineGradient: Dn, linePattern: Ka, lineSDF: bo, raster: Ws, symbolIcon: rs, symbolSDF: Ql, symbolTextAndIcon: Cu, background: Uc, backgroundPattern: xu }, Vc;
+            function hc(Y, D, J, q, K, de, ne) {
+              for (var we = Y.context, Ue = we.gl, ft = Y.useProgram("collisionBox"), Zt = [], hr = 0, qt = 0, Ve = 0; Ve < q.length; Ve++) {
+                var Qe = q[Ve], at = D.getTile(Qe), Ct = at.getBucket(J);
+                if (Ct) {
+                  var Ot = Qe.posMatrix;
+                  (K[0] !== 0 || K[1] !== 0) && (Ot = Y.translatePosMatrix(Qe.posMatrix, at, K, de));
+                  var Rt = ne ? Ct.textCollisionBox : Ct.iconCollisionBox, Bt = Ct.collisionCircleArray;
+                  if (Bt.length > 0) {
+                    var Dt = i.create(), yt = Ot;
+                    i.mul(Dt, Ct.placementInvProjMatrix, Y.transform.glCoordMatrix), i.mul(Dt, Dt, Ct.placementViewportMatrix), Zt.push({ circleArray: Bt, circleOffset: qt, transform: yt, invTransform: Dt }), hr += Bt.length / 4, qt = hr;
+                  }
+                  Rt && ft.draw(we, Ue.LINES, wi.disabled, Fn.disabled, Y.colorModeForRenderPass(), Er.disabled, Kr(Ot, Y.transform, at), J.id, Rt.layoutVertexBuffer, Rt.indexBuffer, Rt.segments, null, Y.transform.zoom, null, null, Rt.collisionVertexBuffer);
+                }
+              }
+              if (!(!ne || !Zt.length)) {
+                var Pt = Y.useProgram("collisionCircle"), ht = new i.StructArrayLayout2f1f2i16();
+                ht.resize(hr * 4), ht._trim();
+                for (var ur = 0, br = 0, Ur = Zt; br < Ur.length; br += 1) for (var Di = Ur[br], fi = 0; fi < Di.circleArray.length / 4; fi++) {
+                  var Ti = fi * 4, gn = Di.circleArray[Ti + 0], rn = Di.circleArray[Ti + 1], Ci = Di.circleArray[Ti + 2], Bi = Di.circleArray[Ti + 3];
+                  ht.emplace(ur++, gn, rn, Ci, Bi, 0), ht.emplace(ur++, gn, rn, Ci, Bi, 1), ht.emplace(ur++, gn, rn, Ci, Bi, 2), ht.emplace(ur++, gn, rn, Ci, Bi, 3);
+                }
+                (!Vc || Vc.length < hr * 2) && (Vc = Ku(hr));
+                for (var Gi = we.createIndexBuffer(Vc, true), sn = we.createVertexBuffer(ht, i.collisionCircleLayout.members, true), zn = 0, Ja = Zt; zn < Ja.length; zn += 1) {
+                  var co = Ja[zn], ts = ki(co.transform, co.invTransform, Y.transform);
+                  Pt.draw(we, Ue.TRIANGLES, wi.disabled, Fn.disabled, Y.colorModeForRenderPass(), Er.disabled, ts, J.id, sn, Gi, i.SegmentVector.simpleSegment(0, co.circleOffset * 2, co.circleArray.length, co.circleArray.length / 2), null, Y.transform.zoom, null, null, null);
+                }
+                sn.destroy(), Gi.destroy();
+              }
+            }
+            function Ku(Y) {
+              var D = Y * 2, J = new i.StructArrayLayout3ui6();
+              J.resize(D), J._trim();
+              for (var q = 0; q < D; q++) {
+                var K = q * 6;
+                J.uint16[K + 0] = q * 4 + 0, J.uint16[K + 1] = q * 4 + 1, J.uint16[K + 2] = q * 4 + 2, J.uint16[K + 3] = q * 4 + 2, J.uint16[K + 4] = q * 4 + 3, J.uint16[K + 5] = q * 4 + 0;
+              }
+              return J;
+            }
+            var ue = i.identity(new Float32Array(16));
+            function w(Y, D, J, q, K) {
+              if (Y.renderPass === "translucent") {
+                var de = Fn.disabled, ne = Y.colorModeForRenderPass(), we = J.layout.get("text-variable-anchor");
+                we && Q(q, Y, J, D, J.layout.get("text-rotation-alignment"), J.layout.get("text-pitch-alignment"), K), J.paint.get("icon-opacity").constantOr(1) !== 0 && Oe(Y, D, J, q, false, J.paint.get("icon-translate"), J.paint.get("icon-translate-anchor"), J.layout.get("icon-rotation-alignment"), J.layout.get("icon-pitch-alignment"), J.layout.get("icon-keep-upright"), de, ne), J.paint.get("text-opacity").constantOr(1) !== 0 && Oe(Y, D, J, q, true, J.paint.get("text-translate"), J.paint.get("text-translate-anchor"), J.layout.get("text-rotation-alignment"), J.layout.get("text-pitch-alignment"), J.layout.get("text-keep-upright"), de, ne), D.map.showCollisionBoxes && (hc(Y, D, J, q, J.paint.get("text-translate"), J.paint.get("text-translate-anchor"), true), hc(Y, D, J, q, J.paint.get("icon-translate"), J.paint.get("icon-translate-anchor"), false));
+              }
+            }
+            function B(Y, D, J, q, K, de) {
+              var ne = i.getAnchorAlignment(Y), we = ne.horizontalAlign, Ue = ne.verticalAlign, ft = -(we - 0.5) * D, Zt = -(Ue - 0.5) * J, hr = i.evaluateVariableOffset(Y, q);
+              return new i.Point((ft / K + hr[0]) * de, (Zt / K + hr[1]) * de);
+            }
+            function Q(Y, D, J, q, K, de, ne) {
+              for (var we = D.transform, Ue = K === "map", ft = de === "map", Zt = 0, hr = Y; Zt < hr.length; Zt += 1) {
+                var qt = hr[Zt], Ve = q.getTile(qt), Qe = Ve.getBucket(J);
+                if (!(!Qe || !Qe.text || !Qe.text.segments.get().length)) {
+                  var at = Qe.textSizeData, Ct = i.evaluateSizeForZoom(at, we.zoom), Ot = As(Ve, 1, D.transform.zoom), Rt = _n(qt.posMatrix, ft, Ue, D.transform, Ot), Bt = J.layout.get("icon-text-fit") !== "none" && Qe.hasIconData();
+                  if (Ct) {
+                    var Dt = Math.pow(2, we.zoom - Ve.tileID.overscaledZ);
+                    ee(Qe, Ue, ft, ne, i.symbolSize, we, Rt, qt.posMatrix, Dt, Ct, Bt);
+                  }
+                }
+              }
+            }
+            function ee(Y, D, J, q, K, de, ne, we, Ue, ft, Zt) {
+              var hr = Y.text.placedSymbolArray, qt = Y.text.dynamicLayoutVertexArray, Ve = Y.icon.dynamicLayoutVertexArray, Qe = {};
+              qt.clear();
+              for (var at = 0; at < hr.length; at++) {
+                var Ct = hr.get(at), Ot = Y.allowVerticalPlacement && !Ct.placedOrientation, Rt = !Ct.hidden && Ct.crossTileID && !Ot ? q[Ct.crossTileID] : null;
+                if (!Rt) ul(Ct.numGlyphs, qt);
+                else {
+                  var Bt = new i.Point(Ct.anchorX, Ct.anchorY), Dt = $n(Bt, J ? we : ne), yt = Ma(de.cameraToCenterDistance, Dt.signedDistanceFromCamera), Pt = K.evaluateSizeForFeature(Y.textSizeData, ft, Ct) * yt / i.ONE_EM;
+                  J && (Pt *= Y.tilePixelRatio / Ue);
+                  for (var ht = Rt.width, ur = Rt.height, br = Rt.anchor, Ur = Rt.textOffset, Di = Rt.textBoxScale, fi = B(br, ht, ur, Ur, Di, Pt), Ti = J ? $n(Bt.add(fi), ne).point : Dt.point.add(D ? fi.rotate(-de.angle) : fi), gn = Y.allowVerticalPlacement && Ct.placedOrientation === i.WritingMode.vertical ? Math.PI / 2 : 0, rn = 0; rn < Ct.numGlyphs; rn++) i.addDynamicAttributes(qt, Ti, gn);
+                  Zt && Ct.associatedIconIndex >= 0 && (Qe[Ct.associatedIconIndex] = { shiftedAnchor: Ti, angle: gn });
+                }
+              }
+              if (Zt) {
+                Ve.clear();
+                for (var Ci = Y.icon.placedSymbolArray, Bi = 0; Bi < Ci.length; Bi++) {
+                  var Gi = Ci.get(Bi);
+                  if (Gi.hidden) ul(Gi.numGlyphs, Ve);
+                  else {
+                    var sn = Qe[Bi];
+                    if (!sn) ul(Gi.numGlyphs, Ve);
+                    else for (var zn = 0; zn < Gi.numGlyphs; zn++) i.addDynamicAttributes(Ve, sn.shiftedAnchor, sn.angle);
+                  }
+                }
+                Y.icon.dynamicLayoutVertexBuffer.updateData(Ve);
+              }
+              Y.text.dynamicLayoutVertexBuffer.updateData(qt);
+            }
+            function le(Y, D, J) {
+              return J.iconsInText && D ? "symbolTextAndIcon" : Y ? "symbolSDF" : "symbolIcon";
+            }
+            function Oe(Y, D, J, q, K, de, ne, we, Ue, ft, Zt, hr) {
+              for (var qt = Y.context, Ve = qt.gl, Qe = Y.transform, at = we === "map", Ct = Ue === "map", Ot = at && J.layout.get("symbol-placement") !== "point", Rt = at && !Ct && !Ot, Bt = J.layout.get("symbol-sort-key").constantOr(1) !== void 0, Dt = false, yt = Y.depthModeForSublayer(0, wi.ReadOnly), Pt = J.layout.get("text-variable-anchor"), ht = [], ur = 0, br = q; ur < br.length; ur += 1) {
+                var Ur = br[ur], Di = D.getTile(Ur), fi = Di.getBucket(J);
+                if (fi) {
+                  var Ti = K ? fi.text : fi.icon;
+                  if (!(!Ti || !Ti.segments.get().length)) {
+                    var gn = Ti.programConfigurations.get(J.id), rn = K || fi.sdfIcons, Ci = K ? fi.textSizeData : fi.iconSizeData, Bi = Ct || Qe.pitch !== 0, Gi = Y.useProgram(le(rn, K, fi), gn), sn = i.evaluateSizeForZoom(Ci, Qe.zoom), zn = void 0, Ja = [0, 0], co = void 0, ts = void 0, so = null, Yo = void 0;
+                    if (K) {
+                      if (co = Di.glyphAtlasTexture, ts = Ve.LINEAR, zn = Di.glyphAtlasTexture.size, fi.iconsInText) {
+                        Ja = Di.imageAtlasTexture.size, so = Di.imageAtlasTexture;
+                        var ms = Ci.kind === "composite" || Ci.kind === "camera";
+                        Yo = Bi || Y.options.rotating || Y.options.zooming || ms ? Ve.LINEAR : Ve.NEAREST;
+                      }
+                    } else {
+                      var ou = J.layout.get("icon-size").constantOr(0) !== 1 || fi.iconsNeedLinear;
+                      co = Di.imageAtlasTexture, ts = rn || Y.options.rotating || Y.options.zooming || ou || Bi ? Ve.LINEAR : Ve.NEAREST, zn = Di.imageAtlasTexture.size;
+                    }
+                    var Cv = As(Di, 1, Y.transform.zoom), Lv = _n(Ur.posMatrix, Ct, at, Y.transform, Cv), wd = ya(Ur.posMatrix, Ct, at, Y.transform, Cv), Kv = Pt && fi.hasTextData(), hg = J.layout.get("icon-text-fit") !== "none" && Kv && fi.hasIconData();
+                    Ot && No(fi, Ur.posMatrix, Y, K, Lv, wd, Ct, ft);
+                    var gp = Y.translatePosMatrix(Ur.posMatrix, Di, de, ne), Td = Ot || K && Pt || hg ? ue : Lv, mp = Y.translatePosMatrix(wd, Di, de, ne, true), Ud = rn && J.paint.get(K ? "text-halo-width" : "icon-halo-width").constantOr(1) !== 0, Ad = void 0;
+                    rn ? fi.iconsInText ? Ad = pu(Ci.kind, sn, Rt, Ct, Y, gp, Td, mp, zn, Ja) : Ad = Nc(Ci.kind, sn, Rt, Ct, Y, gp, Td, mp, K, zn) : Ad = Yu(Ci.kind, sn, Rt, Ct, Y, gp, Td, mp, K, zn);
+                    var Pv = { program: Gi, buffers: Ti, uniformValues: Ad, atlasTexture: co, atlasTextureIcon: so, atlasInterpolation: ts, atlasInterpolationIcon: Yo, isSDF: rn, hasHalo: Ud };
+                    if (Bt && fi.canOverlap) {
+                      Dt = true;
+                      for (var Jv = Ti.segments.get(), Iv = 0, fy = Jv; Iv < fy.length; Iv += 1) {
+                        var dg = fy[Iv];
+                        ht.push({ segments: new i.SegmentVector([dg]), sortKey: dg.sortKey, state: Pv });
+                      }
+                    } else ht.push({ segments: Ti.segments, sortKey: 0, state: Pv });
+                  }
+                }
+              }
+              Dt && ht.sort(function(k1, C1) {
+                return k1.sortKey - C1.sortKey;
+              });
+              for (var oh = 0, vg = ht; oh < vg.length; oh += 1) {
+                var hy = vg[oh], Zh = hy.state;
+                if (qt.activeTexture.set(Ve.TEXTURE0), Zh.atlasTexture.bind(Zh.atlasInterpolation, Ve.CLAMP_TO_EDGE), Zh.atlasTextureIcon && (qt.activeTexture.set(Ve.TEXTURE1), Zh.atlasTextureIcon && Zh.atlasTextureIcon.bind(Zh.atlasInterpolationIcon, Ve.CLAMP_TO_EDGE)), Zh.isSDF) {
+                  var am = Zh.uniformValues;
+                  Zh.hasHalo && (am.u_is_halo = 1, Ze(Zh.buffers, hy.segments, J, Y, Zh.program, yt, Zt, hr, am)), am.u_is_halo = 0;
+                }
+                Ze(Zh.buffers, hy.segments, J, Y, Zh.program, yt, Zt, hr, Zh.uniformValues);
+              }
+            }
+            function Ze(Y, D, J, q, K, de, ne, we, Ue) {
+              var ft = q.context, Zt = ft.gl;
+              K.draw(ft, Zt.TRIANGLES, de, ne, we, Er.disabled, Ue, J.id, Y.layoutVertexBuffer, Y.indexBuffer, D, J.paint, q.transform.zoom, Y.programConfigurations.get(J.id), Y.dynamicLayoutVertexBuffer, Y.opacityVertexBuffer);
+            }
+            function st(Y, D, J, q) {
+              if (Y.renderPass === "translucent") {
+                var K = J.paint.get("circle-opacity"), de = J.paint.get("circle-stroke-width"), ne = J.paint.get("circle-stroke-opacity"), we = J.layout.get("circle-sort-key").constantOr(1) !== void 0;
+                if (!(K.constantOr(1) === 0 && (de.constantOr(1) === 0 || ne.constantOr(1) === 0))) {
+                  for (var Ue = Y.context, ft = Ue.gl, Zt = Y.depthModeForSublayer(0, wi.ReadOnly), hr = Fn.disabled, qt = Y.colorModeForRenderPass(), Ve = [], Qe = 0; Qe < q.length; Qe++) {
+                    var at = q[Qe], Ct = D.getTile(at), Ot = Ct.getBucket(J);
+                    if (Ot) {
+                      var Rt = Ot.programConfigurations.get(J.id), Bt = Y.useProgram("circle", Rt), Dt = Ot.layoutVertexBuffer, yt = Ot.indexBuffer, Pt = Xt(Y, at, Ct, J), ht = { programConfiguration: Rt, program: Bt, layoutVertexBuffer: Dt, indexBuffer: yt, uniformValues: Pt };
+                      if (we) for (var ur = Ot.segments.get(), br = 0, Ur = ur; br < Ur.length; br += 1) {
+                        var Di = Ur[br];
+                        Ve.push({ segments: new i.SegmentVector([Di]), sortKey: Di.sortKey, state: ht });
+                      }
+                      else Ve.push({ segments: Ot.segments, sortKey: 0, state: ht });
+                    }
+                  }
+                  we && Ve.sort(function(co, ts) {
+                    return co.sortKey - ts.sortKey;
+                  });
+                  for (var fi = 0, Ti = Ve; fi < Ti.length; fi += 1) {
+                    var gn = Ti[fi], rn = gn.state, Ci = rn.programConfiguration, Bi = rn.program, Gi = rn.layoutVertexBuffer, sn = rn.indexBuffer, zn = rn.uniformValues, Ja = gn.segments;
+                    Bi.draw(Ue, ft.TRIANGLES, Zt, hr, qt, Er.disabled, zn, J.id, Gi, sn, Ja, J.paint, Y.transform.zoom, Ci);
+                  }
+                }
+              }
+            }
+            function Tt(Y, D, J, q) {
+              if (J.paint.get("heatmap-opacity") !== 0) if (Y.renderPass === "offscreen") {
+                var K = Y.context, de = K.gl, ne = Fn.disabled, we = new wt([de.ONE, de.ONE], i.Color.transparent, [true, true, true, true]);
+                Yt(K, Y, J), K.clear({ color: i.Color.transparent });
+                for (var Ue = 0; Ue < q.length; Ue++) {
+                  var ft = q[Ue];
+                  if (!D.hasRenderableParent(ft)) {
+                    var Zt = D.getTile(ft), hr = Zt.getBucket(J);
+                    if (hr) {
+                      var qt = hr.programConfigurations.get(J.id), Ve = Y.useProgram("heatmap", qt), Qe = Y.transform, at = Qe.zoom;
+                      Ve.draw(K, de.TRIANGLES, wi.disabled, ne, we, Er.disabled, on(ft.posMatrix, Zt, at, J.paint.get("heatmap-intensity")), J.id, hr.layoutVertexBuffer, hr.indexBuffer, hr.segments, J.paint, Y.transform.zoom, qt);
+                    }
+                  }
+                }
+                K.viewport.set([0, 0, Y.width, Y.height]);
+              } else Y.renderPass === "translucent" && (Y.context.setColorMode(Y.colorModeForRenderPass()), xr(Y, J));
+            }
+            function Yt(Y, D, J) {
+              var q = Y.gl;
+              Y.activeTexture.set(q.TEXTURE1), Y.viewport.set([0, 0, D.width / 4, D.height / 4]);
+              var K = J.heatmapFbo;
+              if (K) q.bindTexture(q.TEXTURE_2D, K.colorAttachment.get()), Y.bindFramebuffer.set(K.framebuffer);
+              else {
+                var de = q.createTexture();
+                q.bindTexture(q.TEXTURE_2D, de), q.texParameteri(q.TEXTURE_2D, q.TEXTURE_WRAP_S, q.CLAMP_TO_EDGE), q.texParameteri(q.TEXTURE_2D, q.TEXTURE_WRAP_T, q.CLAMP_TO_EDGE), q.texParameteri(q.TEXTURE_2D, q.TEXTURE_MIN_FILTER, q.LINEAR), q.texParameteri(q.TEXTURE_2D, q.TEXTURE_MAG_FILTER, q.LINEAR), K = J.heatmapFbo = Y.createFramebuffer(D.width / 4, D.height / 4, false), Kt(Y, D, de, K);
+              }
+            }
+            function Kt(Y, D, J, q) {
+              var K = Y.gl, de = Y.extRenderToTextureHalfFloat ? Y.extTextureHalfFloat.HALF_FLOAT_OES : K.UNSIGNED_BYTE;
+              K.texImage2D(K.TEXTURE_2D, 0, K.RGBA, D.width / 4, D.height / 4, 0, K.RGBA, de, null), q.colorAttachment.set(J);
+            }
+            function xr(Y, D) {
+              var J = Y.context, q = J.gl, K = D.heatmapFbo;
+              if (K) {
+                J.activeTexture.set(q.TEXTURE0), q.bindTexture(q.TEXTURE_2D, K.colorAttachment.get()), J.activeTexture.set(q.TEXTURE1);
+                var de = D.colorRampTexture;
+                de || (de = D.colorRampTexture = new i.Texture(J, D.colorRamp, q.RGBA)), de.bind(q.LINEAR, q.CLAMP_TO_EDGE), Y.useProgram("heatmapTexture").draw(J, q.TRIANGLES, wi.disabled, Fn.disabled, Y.colorModeForRenderPass(), Er.disabled, Fi(Y, D, 0, 1), D.id, Y.viewportBuffer, Y.quadTriangleIndexBuffer, Y.viewportSegments, D.paint, Y.transform.zoom);
+              }
+            }
+            function Ir(Y, D, J, q) {
+              if (Y.renderPass === "translucent") {
+                var K = J.paint.get("line-opacity"), de = J.paint.get("line-width");
+                if (!(K.constantOr(1) === 0 || de.constantOr(1) === 0)) for (var ne = Y.depthModeForSublayer(0, wi.ReadOnly), we = Y.colorModeForRenderPass(), Ue = J.paint.get("line-dasharray"), ft = J.paint.get("line-pattern"), Zt = ft.constantOr(1), hr = J.paint.get("line-gradient"), qt = J.getCrossfadeParameters(), Ve = Zt ? "linePattern" : Ue ? "lineSDF" : hr ? "lineGradient" : "line", Qe = Y.context, at = Qe.gl, Ct = true, Ot = 0, Rt = q; Ot < Rt.length; Ot += 1) {
+                  var Bt = Rt[Ot], Dt = D.getTile(Bt);
+                  if (!(Zt && !Dt.patternsLoaded())) {
+                    var yt = Dt.getBucket(J);
+                    if (yt) {
+                      var Pt = yt.programConfigurations.get(J.id), ht = Y.context.program.get(), ur = Y.useProgram(Ve, Pt), br = Ct || ur.program !== ht, Ur = ft.constantOr(null);
+                      if (Ur && Dt.imageAtlas) {
+                        var Di = Dt.imageAtlas, fi = Di.patternPositions[Ur.to.toString()], Ti = Di.patternPositions[Ur.from.toString()];
+                        fi && Ti && Pt.setConstantPatternPositions(fi, Ti);
+                      }
+                      var gn = Zt ? as(Y, Dt, J, qt) : Ue ? ws(Y, Dt, J, Ue, qt) : hr ? Ss(Y, Dt, J, yt.lineClipsArray.length) : Zo(Y, Dt, J);
+                      if (Zt) Qe.activeTexture.set(at.TEXTURE0), Dt.imageAtlasTexture.bind(at.LINEAR, at.CLAMP_TO_EDGE), Pt.updatePaintBuffers(qt);
+                      else if (Ue && (br || Y.lineAtlas.dirty)) Qe.activeTexture.set(at.TEXTURE0), Y.lineAtlas.bind(Qe);
+                      else if (hr) {
+                        var rn = yt.gradients[J.id], Ci = rn.texture;
+                        if (J.gradientVersion !== rn.version) {
+                          var Bi = 256;
+                          if (J.stepInterpolant) {
+                            var Gi = D.getSource().maxzoom, sn = Bt.canonical.z === Gi ? Math.ceil(1 << Y.transform.maxZoom - Bt.canonical.z) : 1, zn = yt.maxLineLength / i.EXTENT, Ja = 1024, co = zn * Ja * sn;
+                            Bi = i.clamp(i.nextPowerOfTwo(co), 256, Qe.maxTextureSize);
+                          }
+                          rn.gradient = i.renderColorRamp({ expression: J.gradientExpression(), evaluationKey: "lineProgress", resolution: Bi, image: rn.gradient || void 0, clips: yt.lineClipsArray }), rn.texture ? rn.texture.update(rn.gradient) : rn.texture = new i.Texture(Qe, rn.gradient, at.RGBA), rn.version = J.gradientVersion, Ci = rn.texture;
+                        }
+                        Qe.activeTexture.set(at.TEXTURE0), Ci.bind(J.stepInterpolant ? at.NEAREST : at.LINEAR, at.CLAMP_TO_EDGE);
+                      }
+                      ur.draw(Qe, at.TRIANGLES, ne, Y.stencilModeForClipping(Bt), we, Er.disabled, gn, J.id, yt.layoutVertexBuffer, yt.indexBuffer, yt.segments, J.paint, Y.transform.zoom, Pt, yt.layoutVertexBuffer2), Ct = false;
+                    }
+                  }
+                }
+              }
+            }
+            function ve(Y, D, J, q) {
+              var K = J.paint.get("fill-color"), de = J.paint.get("fill-opacity");
+              if (de.constantOr(1) !== 0) {
+                var ne = Y.colorModeForRenderPass(), we = J.paint.get("fill-pattern"), Ue = Y.opaquePassEnabledForLayer() && !we.constantOr(1) && K.constantOr(i.Color.transparent).a === 1 && de.constantOr(0) === 1 ? "opaque" : "translucent";
+                if (Y.renderPass === Ue) {
+                  var ft = Y.depthModeForSublayer(1, Y.renderPass === "opaque" ? wi.ReadWrite : wi.ReadOnly);
+                  be(Y, D, J, q, ft, ne, false);
+                }
+                if (Y.renderPass === "translucent" && J.paint.get("fill-antialias")) {
+                  var Zt = Y.depthModeForSublayer(J.getPaintProperty("fill-outline-color") ? 2 : 0, wi.ReadOnly);
+                  be(Y, D, J, q, Zt, ne, true);
+                }
+              }
+            }
+            function be(Y, D, J, q, K, de, ne) {
+              var we = Y.context.gl, Ue = J.paint.get("fill-pattern"), ft = Ue && Ue.constantOr(1), Zt = J.getCrossfadeParameters(), hr, qt, Ve, Qe, at;
+              ne ? (qt = ft && !J.getPaintProperty("fill-outline-color") ? "fillOutlinePattern" : "fillOutline", hr = we.LINES) : (qt = ft ? "fillPattern" : "fill", hr = we.TRIANGLES);
+              for (var Ct = 0, Ot = q; Ct < Ot.length; Ct += 1) {
+                var Rt = Ot[Ct], Bt = D.getTile(Rt);
+                if (!(ft && !Bt.patternsLoaded())) {
+                  var Dt = Bt.getBucket(J);
+                  if (Dt) {
+                    var yt = Dt.programConfigurations.get(J.id), Pt = Y.useProgram(qt, yt);
+                    ft && (Y.context.activeTexture.set(we.TEXTURE0), Bt.imageAtlasTexture.bind(we.LINEAR, we.CLAMP_TO_EDGE), yt.updatePaintBuffers(Zt));
+                    var ht = Ue.constantOr(null);
+                    if (ht && Bt.imageAtlas) {
+                      var ur = Bt.imageAtlas, br = ur.patternPositions[ht.to.toString()], Ur = ur.patternPositions[ht.from.toString()];
+                      br && Ur && yt.setConstantPatternPositions(br, Ur);
+                    }
+                    var Di = Y.translatePosMatrix(Rt.posMatrix, Bt, J.paint.get("fill-translate"), J.paint.get("fill-translate-anchor"));
+                    if (!ne) Qe = Dt.indexBuffer, at = Dt.segments, Ve = ft ? cf(Di, Y, Zt, Bt) : qc(Di);
+                    else {
+                      Qe = Dt.indexBuffer2, at = Dt.segments2;
+                      var fi = [we.drawingBufferWidth, we.drawingBufferHeight];
+                      Ve = qt === "fillOutlinePattern" && ft ? Bc(Di, Y, Zt, Bt, fi) : fc(Di, fi);
+                    }
+                    Pt.draw(Y.context, hr, K, Y.stencilModeForClipping(Rt), de, Er.disabled, Ve, J.id, Dt.layoutVertexBuffer, Qe, at, J.paint, Y.transform.zoom, yt);
+                  }
+                }
+              }
+            }
+            function Re(Y, D, J, q) {
+              var K = J.paint.get("fill-extrusion-opacity");
+              if (K !== 0 && Y.renderPass === "translucent") {
+                var de = new wi(Y.context.gl.LEQUAL, wi.ReadWrite, Y.depthRangeFor3D);
+                if (K === 1 && !J.paint.get("fill-extrusion-pattern").constantOr(1)) {
+                  var ne = Y.colorModeForRenderPass();
+                  qe(Y, D, J, q, de, Fn.disabled, ne);
+                } else qe(Y, D, J, q, de, Fn.disabled, wt.disabled), qe(Y, D, J, q, de, Y.stencilModeFor3D(), Y.colorModeForRenderPass());
+              }
+            }
+            function qe(Y, D, J, q, K, de, ne) {
+              for (var we = Y.context, Ue = we.gl, ft = J.paint.get("fill-extrusion-pattern"), Zt = ft.constantOr(1), hr = J.getCrossfadeParameters(), qt = J.paint.get("fill-extrusion-opacity"), Ve = 0, Qe = q; Ve < Qe.length; Ve += 1) {
+                var at = Qe[Ve], Ct = D.getTile(at), Ot = Ct.getBucket(J);
+                if (Ot) {
+                  var Rt = Ot.programConfigurations.get(J.id), Bt = Y.useProgram(Zt ? "fillExtrusionPattern" : "fillExtrusion", Rt);
+                  Zt && (Y.context.activeTexture.set(Ue.TEXTURE0), Ct.imageAtlasTexture.bind(Ue.LINEAR, Ue.CLAMP_TO_EDGE), Rt.updatePaintBuffers(hr));
+                  var Dt = ft.constantOr(null);
+                  if (Dt && Ct.imageAtlas) {
+                    var yt = Ct.imageAtlas, Pt = yt.patternPositions[Dt.to.toString()], ht = yt.patternPositions[Dt.from.toString()];
+                    Pt && ht && Rt.setConstantPatternPositions(Pt, ht);
+                  }
+                  var ur = Y.translatePosMatrix(at.posMatrix, Ct, J.paint.get("fill-extrusion-translate"), J.paint.get("fill-extrusion-translate-anchor")), br = J.paint.get("fill-extrusion-vertical-gradient"), Ur = Zt ? Zu(ur, Y, br, qt, at, hr, Ct) : ah(ur, Y, br, qt);
+                  Bt.draw(we, we.gl.TRIANGLES, K, de, ne, Er.backCCW, Ur, J.id, Ot.layoutVertexBuffer, Ot.indexBuffer, Ot.segments, J.paint, Y.transform.zoom, Rt);
+                }
+              }
+            }
+            function et(Y, D, J, q) {
+              if (!(Y.renderPass !== "offscreen" && Y.renderPass !== "translucent")) {
+                for (var K = Y.context, de = Y.depthModeForSublayer(0, wi.ReadOnly), ne = Y.colorModeForRenderPass(), we = Y.renderPass === "translucent" ? Y.stencilConfigForOverlap(q) : [{}, q], Ue = we[0], ft = we[1], Zt = 0, hr = ft; Zt < hr.length; Zt += 1) {
+                  var qt = hr[Zt], Ve = D.getTile(qt);
+                  Ve.needsHillshadePrepare && Y.renderPass === "offscreen" ? it(Y, Ve, J, de, Fn.disabled, ne) : Y.renderPass === "translucent" && Xe(Y, Ve, J, de, Ue[qt.overscaledZ], ne);
+                }
+                K.viewport.set([0, 0, Y.width, Y.height]);
+              }
+            }
+            function Xe(Y, D, J, q, K, de) {
+              var ne = Y.context, we = ne.gl, Ue = D.fbo;
+              if (Ue) {
+                var ft = Y.useProgram("hillshade");
+                ne.activeTexture.set(we.TEXTURE0), we.bindTexture(we.TEXTURE_2D, Ue.colorAttachment.get());
+                var Zt = Ra(Y, D, J);
+                ft.draw(ne, we.TRIANGLES, q, K, de, Er.disabled, Zt, J.id, Y.rasterBoundsBuffer, Y.quadTriangleIndexBuffer, Y.rasterBoundsSegments);
+              }
+            }
+            function it(Y, D, J, q, K, de) {
+              var ne = Y.context, we = ne.gl, Ue = D.dem;
+              if (Ue && Ue.data) {
+                var ft = Ue.dim, Zt = Ue.stride, hr = Ue.getPixels();
+                if (ne.activeTexture.set(we.TEXTURE1), ne.pixelStoreUnpackPremultiplyAlpha.set(false), D.demTexture = D.demTexture || Y.getTileTexture(Zt), D.demTexture) {
+                  var qt = D.demTexture;
+                  qt.update(hr, { premultiply: false }), qt.bind(we.NEAREST, we.CLAMP_TO_EDGE);
+                } else D.demTexture = new i.Texture(ne, hr, we.RGBA, { premultiply: false }), D.demTexture.bind(we.NEAREST, we.CLAMP_TO_EDGE);
+                ne.activeTexture.set(we.TEXTURE0);
+                var Ve = D.fbo;
+                if (!Ve) {
+                  var Qe = new i.Texture(ne, { width: ft, height: ft, data: null }, we.RGBA);
+                  Qe.bind(we.LINEAR, we.CLAMP_TO_EDGE), Ve = D.fbo = ne.createFramebuffer(ft, ft, true), Ve.colorAttachment.set(Qe.texture);
+                }
+                ne.bindFramebuffer.set(Ve.framebuffer), ne.viewport.set([0, 0, ft, ft]), Y.useProgram("hillshadePrepare").draw(ne, we.TRIANGLES, q, K, de, Er.disabled, La(D.tileID, Ue), J.id, Y.rasterBoundsBuffer, Y.quadTriangleIndexBuffer, Y.rasterBoundsSegments), D.needsHillshadePrepare = false;
+              }
+            }
+            function Ft(Y, D, J, q) {
+              if (Y.renderPass === "translucent" && J.paint.get("raster-opacity") !== 0 && q.length) for (var K = Y.context, de = K.gl, ne = D.getSource(), we = Y.useProgram("raster"), Ue = Y.colorModeForRenderPass(), ft = ne instanceof Le ? [{}, q] : Y.stencilConfigForOverlap(q), Zt = ft[0], hr = ft[1], qt = hr[hr.length - 1].overscaledZ, Ve = !Y.options.moving, Qe = 0, at = hr; Qe < at.length; Qe += 1) {
+                var Ct = at[Qe], Ot = Y.depthModeForSublayer(Ct.overscaledZ - qt, J.paint.get("raster-opacity") === 1 ? wi.ReadWrite : wi.ReadOnly, de.LESS), Rt = D.getTile(Ct), Bt = Y.transform.calculatePosMatrix(Ct.toUnwrapped(), Ve);
+                Rt.registerFadeDuration(J.paint.get("raster-fade-duration"));
+                var Dt = D.findLoadedParent(Ct, 0), yt = Ht(Rt, Dt, D, J, Y.transform), Pt = void 0, ht = void 0, ur = J.paint.get("raster-resampling") === "nearest" ? de.NEAREST : de.LINEAR;
+                K.activeTexture.set(de.TEXTURE0), Rt.texture.bind(ur, de.CLAMP_TO_EDGE, de.LINEAR_MIPMAP_NEAREST), K.activeTexture.set(de.TEXTURE1), Dt ? (Dt.texture.bind(ur, de.CLAMP_TO_EDGE, de.LINEAR_MIPMAP_NEAREST), Pt = Math.pow(2, Dt.tileID.overscaledZ - Rt.tileID.overscaledZ), ht = [Rt.tileID.canonical.x * Pt % 1, Rt.tileID.canonical.y * Pt % 1]) : Rt.texture.bind(ur, de.CLAMP_TO_EDGE, de.LINEAR_MIPMAP_NEAREST);
+                var br = Ls(Bt, ht || [0, 0], Pt || 1, yt, J);
+                ne instanceof Le ? we.draw(K, de.TRIANGLES, Ot, Fn.disabled, Ue, Er.disabled, br, J.id, ne.boundsBuffer, Y.quadTriangleIndexBuffer, ne.boundsSegments) : we.draw(K, de.TRIANGLES, Ot, Zt[Ct.overscaledZ], Ue, Er.disabled, br, J.id, Y.rasterBoundsBuffer, Y.quadTriangleIndexBuffer, Y.rasterBoundsSegments);
+              }
+            }
+            function Ht(Y, D, J, q, K) {
+              var de = q.paint.get("raster-fade-duration");
+              if (de > 0) {
+                var ne = i.browser.now(), we = (ne - Y.timeAdded) / de, Ue = D ? (ne - D.timeAdded) / de : -1, ft = J.getSource(), Zt = K.coveringZoomLevel({ tileSize: ft.tileSize, roundZoom: ft.roundZoom }), hr = !D || Math.abs(D.tileID.overscaledZ - Zt) > Math.abs(Y.tileID.overscaledZ - Zt), qt = hr && Y.refreshedUponExpiration ? 1 : i.clamp(hr ? we : 1 - Ue, 0, 1);
+                return Y.refreshedUponExpiration && we >= 1 && (Y.refreshedUponExpiration = false), D ? { opacity: 1, mix: 1 - qt } : { opacity: qt, mix: 0 };
+              } else return { opacity: 1, mix: 0 };
+            }
+            function tr(Y, D, J) {
+              var q = J.paint.get("background-color"), K = J.paint.get("background-opacity");
+              if (K !== 0) {
+                var de = Y.context, ne = de.gl, we = Y.transform, Ue = we.tileSize, ft = J.paint.get("background-pattern");
+                if (!Y.isPatternMissing(ft)) {
+                  var Zt = !ft && q.a === 1 && K === 1 && Y.opaquePassEnabledForLayer() ? "opaque" : "translucent";
+                  if (Y.renderPass === Zt) {
+                    var hr = Fn.disabled, qt = Y.depthModeForSublayer(0, Zt === "opaque" ? wi.ReadWrite : wi.ReadOnly), Ve = Y.colorModeForRenderPass(), Qe = Y.useProgram(ft ? "backgroundPattern" : "background"), at = we.coveringTiles({ tileSize: Ue });
+                    ft && (de.activeTexture.set(ne.TEXTURE0), Y.imageManager.bind(Y.context));
+                    for (var Ct = J.getCrossfadeParameters(), Ot = 0, Rt = at; Ot < Rt.length; Ot += 1) {
+                      var Bt = Rt[Ot], Dt = Y.transform.calculatePosMatrix(Bt.toUnwrapped()), yt = ft ? Ua(Dt, K, Y, ft, { tileID: Bt, tileSize: Ue }, Ct) : Ac(Dt, K, q);
+                      Qe.draw(de, ne.TRIANGLES, qt, hr, Ve, Er.disabled, yt, J.id, Y.tileExtentBuffer, Y.quadTriangleIndexBuffer, Y.tileExtentSegments);
+                    }
+                  }
+                }
+              }
+            }
+            var dr = new i.Color(1, 0, 0, 1), Sr = new i.Color(0, 1, 0, 1), Or = new i.Color(0, 0, 1, 1), Wr = new i.Color(1, 0, 1, 1), ni = new i.Color(0, 1, 1, 1);
+            function Pi(Y) {
+              var D = Y.transform.padding, J = 3;
+              ln(Y, Y.transform.height - (D.top || 0), J, dr), ln(Y, D.bottom || 0, J, Sr), Cn(Y, D.left || 0, J, Or), Cn(Y, Y.transform.width - (D.right || 0), J, Wr);
+              var q = Y.transform.centerPoint;
+              cn(Y, q.x, Y.transform.height - q.y, ni);
+            }
+            function cn(Y, D, J, q) {
+              var K = 20, de = 2;
+              Kn(Y, D - de / 2, J - K / 2, de, K, q), Kn(Y, D - K / 2, J - de / 2, K, de, q);
+            }
+            function ln(Y, D, J, q) {
+              Kn(Y, 0, D + J / 2, Y.transform.width, J, q);
+            }
+            function Cn(Y, D, J, q) {
+              Kn(Y, D - J / 2, 0, J, Y.transform.height, q);
+            }
+            function Kn(Y, D, J, q, K, de) {
+              var ne = Y.context, we = ne.gl;
+              we.enable(we.SCISSOR_TEST), we.scissor(D * i.browser.devicePixelRatio, J * i.browser.devicePixelRatio, q * i.browser.devicePixelRatio, K * i.browser.devicePixelRatio), ne.clear({ color: de }), we.disable(we.SCISSOR_TEST);
+            }
+            function Aa(Y, D, J) {
+              for (var q = 0; q < J.length; q++) fa(Y, D, J[q]);
+            }
+            function fa(Y, D, J) {
+              var q = Y.context, K = q.gl, de = J.posMatrix, ne = Y.useProgram("debug"), we = wi.disabled, Ue = Fn.disabled, ft = Y.colorModeForRenderPass(), Zt = "$debug";
+              q.activeTexture.set(K.TEXTURE0), Y.emptyTexture.bind(K.LINEAR, K.CLAMP_TO_EDGE), ne.draw(q, K.LINE_STRIP, we, Ue, ft, Er.disabled, dn(de, i.Color.red), Zt, Y.debugBuffer, Y.tileBorderIndexBuffer, Y.debugSegments);
+              var hr = D.getTileByID(J.key).latestRawTileData, qt = hr && hr.byteLength || 0, Ve = Math.floor(qt / 1024), Qe = D.getTile(J).tileSize, at = 512 / Math.min(Qe, 512) * (J.overscaledZ / Y.transform.zoom) * 0.5, Ct = J.canonical.toString();
+              J.overscaledZ !== J.canonical.z && (Ct += " => " + J.overscaledZ);
+              var Ot = Ct + " " + Ve + "kb";
+              $a(Y, Ot), ne.draw(q, K.TRIANGLES, we, Ue, wt.alphaBlended, Er.disabled, dn(de, i.Color.transparent, at), Zt, Y.debugBuffer, Y.quadTriangleIndexBuffer, Y.debugSegments);
+            }
+            function $a(Y, D) {
+              Y.initDebugOverlayCanvas();
+              var J = Y.debugOverlayCanvas, q = Y.context.gl, K = Y.debugOverlayCanvas.getContext("2d");
+              K.clearRect(0, 0, J.width, J.height), K.shadowColor = "white", K.shadowBlur = 2, K.lineWidth = 1.5, K.strokeStyle = "white", K.textBaseline = "top", K.font = "bold 36px Open Sans, sans-serif", K.fillText(D, 5, 5), K.strokeText(D, 5, 5), Y.debugOverlayTexture.update(J), Y.debugOverlayTexture.bind(q.LINEAR, q.CLAMP_TO_EDGE);
+            }
+            function Co(Y, D, J) {
+              var q = Y.context, K = J.implementation;
+              if (Y.renderPass === "offscreen") {
+                var de = K.prerender;
+                de && (Y.setCustomLayerDefaults(), q.setColorMode(Y.colorModeForRenderPass()), de.call(K, q.gl, Y.transform.customLayerMatrix()), q.setDirty(), Y.setBaseState());
+              } else if (Y.renderPass === "translucent") {
+                Y.setCustomLayerDefaults(), q.setColorMode(Y.colorModeForRenderPass()), q.setStencilMode(Fn.disabled);
+                var ne = K.renderingMode === "3d" ? new wi(Y.context.gl.LEQUAL, wi.ReadWrite, Y.depthRangeFor3D) : Y.depthModeForSublayer(0, wi.ReadOnly);
+                q.setDepthMode(ne), K.render(q.gl, Y.transform.customLayerMatrix()), q.setDirty(), Y.setBaseState(), q.bindFramebuffer.set(null);
+              }
+            }
+            var Qa = { symbol: w, circle: st, heatmap: Tt, line: Ir, fill: ve, "fill-extrusion": Re, hillshade: et, raster: Ft, background: tr, debug: Aa, custom: Co }, mo = function(D, J) {
+              this.context = new Xr(D), this.transform = J, this._tileTextures = {}, this.setup(), this.numSublayers = ri.maxUnderzooming + ri.maxOverzooming + 1, this.depthEpsilon = 1 / Math.pow(2, 16), this.crossTileSymbolIndex = new Vf(), this.gpuTimers = {};
+            };
+            mo.prototype.resize = function(D, J) {
+              if (this.width = D * i.browser.devicePixelRatio, this.height = J * i.browser.devicePixelRatio, this.context.viewport.set([0, 0, this.width, this.height]), this.style) for (var q = 0, K = this.style._order; q < K.length; q += 1) {
+                var de = K[q];
+                this.style._layers[de].resize();
+              }
+            }, mo.prototype.setup = function() {
+              var D = this.context, J = new i.StructArrayLayout2i4();
+              J.emplaceBack(0, 0), J.emplaceBack(i.EXTENT, 0), J.emplaceBack(0, i.EXTENT), J.emplaceBack(i.EXTENT, i.EXTENT), this.tileExtentBuffer = D.createVertexBuffer(J, oc.members), this.tileExtentSegments = i.SegmentVector.simpleSegment(0, 0, 4, 2);
+              var q = new i.StructArrayLayout2i4();
+              q.emplaceBack(0, 0), q.emplaceBack(i.EXTENT, 0), q.emplaceBack(0, i.EXTENT), q.emplaceBack(i.EXTENT, i.EXTENT), this.debugBuffer = D.createVertexBuffer(q, oc.members), this.debugSegments = i.SegmentVector.simpleSegment(0, 0, 4, 5);
+              var K = new i.StructArrayLayout4i8();
+              K.emplaceBack(0, 0, 0, 0), K.emplaceBack(i.EXTENT, 0, i.EXTENT, 0), K.emplaceBack(0, i.EXTENT, 0, i.EXTENT), K.emplaceBack(i.EXTENT, i.EXTENT, i.EXTENT, i.EXTENT), this.rasterBoundsBuffer = D.createVertexBuffer(K, Ce.members), this.rasterBoundsSegments = i.SegmentVector.simpleSegment(0, 0, 4, 2);
+              var de = new i.StructArrayLayout2i4();
+              de.emplaceBack(0, 0), de.emplaceBack(1, 0), de.emplaceBack(0, 1), de.emplaceBack(1, 1), this.viewportBuffer = D.createVertexBuffer(de, oc.members), this.viewportSegments = i.SegmentVector.simpleSegment(0, 0, 4, 2);
+              var ne = new i.StructArrayLayout1ui2();
+              ne.emplaceBack(0), ne.emplaceBack(1), ne.emplaceBack(3), ne.emplaceBack(2), ne.emplaceBack(0), this.tileBorderIndexBuffer = D.createIndexBuffer(ne);
+              var we = new i.StructArrayLayout3ui6();
+              we.emplaceBack(0, 1, 2), we.emplaceBack(2, 1, 3), this.quadTriangleIndexBuffer = D.createIndexBuffer(we), this.emptyTexture = new i.Texture(D, { width: 1, height: 1, data: new Uint8Array([0, 0, 0, 0]) }, D.gl.RGBA);
+              var Ue = this.context.gl;
+              this.stencilClearMode = new Fn({ func: Ue.ALWAYS, mask: 0 }, 0, 255, Ue.ZERO, Ue.ZERO, Ue.ZERO);
+            }, mo.prototype.clearStencil = function() {
+              var D = this.context, J = D.gl;
+              this.nextStencilID = 1, this.currentStencilSource = void 0;
+              var q = i.create();
+              i.ortho(q, 0, this.width, this.height, 0, 0, 1), i.scale(q, q, [J.drawingBufferWidth, J.drawingBufferHeight, 0]), this.useProgram("clippingMask").draw(D, J.TRIANGLES, wi.disabled, this.stencilClearMode, wt.disabled, Er.disabled, Nn(q), "$clipping", this.viewportBuffer, this.quadTriangleIndexBuffer, this.viewportSegments);
+            }, mo.prototype._renderTileClippingMasks = function(D, J) {
+              if (!(this.currentStencilSource === D.source || !D.isTileClipped() || !J || !J.length)) {
+                this.currentStencilSource = D.source;
+                var q = this.context, K = q.gl;
+                this.nextStencilID + J.length > 256 && this.clearStencil(), q.setColorMode(wt.disabled), q.setDepthMode(wi.disabled);
+                var de = this.useProgram("clippingMask");
+                this._tileClippingMaskIDs = {};
+                for (var ne = 0, we = J; ne < we.length; ne += 1) {
+                  var Ue = we[ne], ft = this._tileClippingMaskIDs[Ue.key] = this.nextStencilID++;
+                  de.draw(q, K.TRIANGLES, wi.disabled, new Fn({ func: K.ALWAYS, mask: 0 }, ft, 255, K.KEEP, K.KEEP, K.REPLACE), wt.disabled, Er.disabled, Nn(Ue.posMatrix), "$clipping", this.tileExtentBuffer, this.quadTriangleIndexBuffer, this.tileExtentSegments);
+                }
+              }
+            }, mo.prototype.stencilModeFor3D = function() {
+              this.currentStencilSource = void 0, this.nextStencilID + 1 > 256 && this.clearStencil();
+              var D = this.nextStencilID++, J = this.context.gl;
+              return new Fn({ func: J.NOTEQUAL, mask: 255 }, D, 255, J.KEEP, J.KEEP, J.REPLACE);
+            }, mo.prototype.stencilModeForClipping = function(D) {
+              var J = this.context.gl;
+              return new Fn({ func: J.EQUAL, mask: 255 }, this._tileClippingMaskIDs[D.key], 0, J.KEEP, J.KEEP, J.REPLACE);
+            }, mo.prototype.stencilConfigForOverlap = function(D) {
+              var J, q = this.context.gl, K = D.sort(function(ft, Zt) {
+                return Zt.overscaledZ - ft.overscaledZ;
+              }), de = K[K.length - 1].overscaledZ, ne = K[0].overscaledZ - de + 1;
+              if (ne > 1) {
+                this.currentStencilSource = void 0, this.nextStencilID + ne > 256 && this.clearStencil();
+                for (var we = {}, Ue = 0; Ue < ne; Ue++) we[Ue + de] = new Fn({ func: q.GEQUAL, mask: 255 }, Ue + this.nextStencilID, 255, q.KEEP, q.KEEP, q.REPLACE);
+                return this.nextStencilID += ne, [we, K];
+              }
+              return [(J = {}, J[de] = Fn.disabled, J), K];
+            }, mo.prototype.colorModeForRenderPass = function() {
+              var D = this.context.gl;
+              if (this._showOverdrawInspector) {
+                var J = 8, q = 1 / J;
+                return new wt([D.CONSTANT_COLOR, D.ONE], new i.Color(q, q, q, 0), [true, true, true, true]);
+              } else return this.renderPass === "opaque" ? wt.unblended : wt.alphaBlended;
+            }, mo.prototype.depthModeForSublayer = function(D, J, q) {
+              if (!this.opaquePassEnabledForLayer()) return wi.disabled;
+              var K = 1 - ((1 + this.currentLayer) * this.numSublayers + D) * this.depthEpsilon;
+              return new wi(q || this.context.gl.LEQUAL, J, [K, K]);
+            }, mo.prototype.opaquePassEnabledForLayer = function() {
+              return this.currentLayer < this.opaquePassCutoff;
+            }, mo.prototype.render = function(D, J) {
+              var q = this;
+              this.style = D, this.options = J, this.lineAtlas = D.lineAtlas, this.imageManager = D.imageManager, this.glyphManager = D.glyphManager, this.symbolFadeChange = D.placement.symbolFadeChange(i.browser.now()), this.imageManager.beginFrame();
+              var K = this.style._order, de = this.style.sourceCaches;
+              for (var ne in de) {
+                var we = de[ne];
+                we.used && we.prepare(this.context);
+              }
+              var Ue = {}, ft = {}, Zt = {};
+              for (var hr in de) {
+                var qt = de[hr];
+                Ue[hr] = qt.getVisibleCoordinates(), ft[hr] = Ue[hr].slice().reverse(), Zt[hr] = qt.getVisibleCoordinates(true).reverse();
+              }
+              this.opaquePassCutoff = 1 / 0;
+              for (var Ve = 0; Ve < K.length; Ve++) {
+                var Qe = K[Ve];
+                if (this.style._layers[Qe].is3D()) {
+                  this.opaquePassCutoff = Ve;
+                  break;
+                }
+              }
+              this.renderPass = "offscreen";
+              for (var at = 0, Ct = K; at < Ct.length; at += 1) {
+                var Ot = Ct[at], Rt = this.style._layers[Ot];
+                if (!(!Rt.hasOffscreenPass() || Rt.isHidden(this.transform.zoom))) {
+                  var Bt = ft[Rt.source];
+                  Rt.type !== "custom" && !Bt.length || this.renderLayer(this, de[Rt.source], Rt, Bt);
+                }
+              }
+              for (this.context.bindFramebuffer.set(null), this.context.clear({ color: J.showOverdrawInspector ? i.Color.black : i.Color.transparent, depth: 1 }), this.clearStencil(), this._showOverdrawInspector = J.showOverdrawInspector, this.depthRangeFor3D = [0, 1 - (D._order.length + 2) * this.numSublayers * this.depthEpsilon], this.renderPass = "opaque", this.currentLayer = K.length - 1; this.currentLayer >= 0; this.currentLayer--) {
+                var Dt = this.style._layers[K[this.currentLayer]], yt = de[Dt.source], Pt = Ue[Dt.source];
+                this._renderTileClippingMasks(Dt, Pt), this.renderLayer(this, yt, Dt, Pt);
+              }
+              for (this.renderPass = "translucent", this.currentLayer = 0; this.currentLayer < K.length; this.currentLayer++) {
+                var ht = this.style._layers[K[this.currentLayer]], ur = de[ht.source], br = (ht.type === "symbol" ? Zt : ft)[ht.source];
+                this._renderTileClippingMasks(ht, Ue[ht.source]), this.renderLayer(this, ur, ht, br);
+              }
+              if (this.options.showTileBoundaries) {
+                var Ur, Di, fi = i.values(this.style._layers);
+                fi.forEach(function(Ti) {
+                  Ti.source && !Ti.isHidden(q.transform.zoom) && (Ti.source !== (Di && Di.id) && (Di = q.style.sourceCaches[Ti.source]), (!Ur || Ur.getSource().maxzoom < Di.getSource().maxzoom) && (Ur = Di));
+                }), Ur && Qa.debug(this, Ur, Ur.getVisibleCoordinates());
+              }
+              this.options.showPadding && Pi(this), this.context.setDefault();
+            }, mo.prototype.renderLayer = function(D, J, q, K) {
+              q.isHidden(this.transform.zoom) || q.type !== "background" && q.type !== "custom" && !K.length || (this.id = q.id, this.gpuTimingStart(q), Qa[q.type](D, J, q, K, this.style.placement.variableOffsets), this.gpuTimingEnd());
+            }, mo.prototype.gpuTimingStart = function(D) {
+              if (this.options.gpuTiming) {
+                var J = this.context.extTimerQuery, q = this.gpuTimers[D.id];
+                q || (q = this.gpuTimers[D.id] = { calls: 0, cpuTime: 0, query: J.createQueryEXT() }), q.calls++, J.beginQueryEXT(J.TIME_ELAPSED_EXT, q.query);
+              }
+            }, mo.prototype.gpuTimingEnd = function() {
+              if (this.options.gpuTiming) {
+                var D = this.context.extTimerQuery;
+                D.endQueryEXT(D.TIME_ELAPSED_EXT);
+              }
+            }, mo.prototype.collectGpuTimers = function() {
+              var D = this.gpuTimers;
+              return this.gpuTimers = {}, D;
+            }, mo.prototype.queryGpuTimers = function(D) {
+              var J = {};
+              for (var q in D) {
+                var K = D[q], de = this.context.extTimerQuery, ne = de.getQueryObjectEXT(K.query, de.QUERY_RESULT_EXT) / (1e3 * 1e3);
+                de.deleteQueryEXT(K.query), J[q] = ne;
+              }
+              return J;
+            }, mo.prototype.translatePosMatrix = function(D, J, q, K, de) {
+              if (!q[0] && !q[1]) return D;
+              var ne = de ? K === "map" ? this.transform.angle : 0 : K === "viewport" ? -this.transform.angle : 0;
+              if (ne) {
+                var we = Math.sin(ne), Ue = Math.cos(ne);
+                q = [q[0] * Ue - q[1] * we, q[0] * we + q[1] * Ue];
+              }
+              var ft = [de ? q[0] : As(J, q[0], this.transform.zoom), de ? q[1] : As(J, q[1], this.transform.zoom), 0], Zt = new Float32Array(16);
+              return i.translate(Zt, D, ft), Zt;
+            }, mo.prototype.saveTileTexture = function(D) {
+              var J = this._tileTextures[D.size[0]];
+              J ? J.push(D) : this._tileTextures[D.size[0]] = [D];
+            }, mo.prototype.getTileTexture = function(D) {
+              var J = this._tileTextures[D];
+              return J && J.length > 0 ? J.pop() : null;
+            }, mo.prototype.isPatternMissing = function(D) {
+              if (!D) return false;
+              if (!D.from || !D.to) return true;
+              var J = this.imageManager.getPattern(D.from.toString()), q = this.imageManager.getPattern(D.to.toString());
+              return !J || !q;
+            }, mo.prototype.useProgram = function(D, J) {
+              this.cache = this.cache || {};
+              var q = "" + D + (J ? J.cacheKey : "") + (this._showOverdrawInspector ? "/overdraw" : "");
+              return this.cache[q] || (this.cache[q] = new Rf(this.context, D, wf[D], J, oo[D], this._showOverdrawInspector)), this.cache[q];
+            }, mo.prototype.setCustomLayerDefaults = function() {
+              this.context.unbindVAO(), this.context.cullFace.setDefault(), this.context.activeTexture.setDefault(), this.context.pixelStoreUnpack.setDefault(), this.context.pixelStoreUnpackPremultiplyAlpha.setDefault(), this.context.pixelStoreUnpackFlipY.setDefault();
+            }, mo.prototype.setBaseState = function() {
+              var D = this.context.gl;
+              this.context.cullFace.set(false), this.context.viewport.set([0, 0, this.width, this.height]), this.context.blendEquation.set(D.FUNC_ADD);
+            }, mo.prototype.initDebugOverlayCanvas = function() {
+              if (this.debugOverlayCanvas == null) {
+                this.debugOverlayCanvas = i.window.document.createElement("canvas"), this.debugOverlayCanvas.width = 512, this.debugOverlayCanvas.height = 512;
+                var D = this.context.gl;
+                this.debugOverlayTexture = new i.Texture(this.context, this.debugOverlayCanvas, D.RGBA);
+              }
+            }, mo.prototype.destroy = function() {
+              this.emptyTexture.destroy(), this.debugOverlayTexture && this.debugOverlayTexture.destroy();
+            };
+            var Bo = function(D, J) {
+              this.points = D, this.planes = J;
+            };
+            Bo.fromInvProjectionMatrix = function(D, J, q) {
+              var K = [[-1, 1, -1, 1], [1, 1, -1, 1], [1, -1, -1, 1], [-1, -1, -1, 1], [-1, 1, 1, 1], [1, 1, 1, 1], [1, -1, 1, 1], [-1, -1, 1, 1]], de = Math.pow(2, q), ne = K.map(function(ft) {
+                return i.transformMat4([], ft, D);
+              }).map(function(ft) {
+                return i.scale$1([], ft, 1 / ft[3] / J * de);
+              }), we = [[0, 1, 2], [6, 5, 4], [0, 3, 7], [2, 1, 5], [3, 2, 6], [0, 4, 5]], Ue = we.map(function(ft) {
+                var Zt = i.sub([], ne[ft[0]], ne[ft[1]]), hr = i.sub([], ne[ft[2]], ne[ft[1]]), qt = i.normalize([], i.cross([], Zt, hr)), Ve = -i.dot(qt, ne[ft[1]]);
+                return qt.concat(Ve);
+              });
+              return new Bo(ne, Ue);
+            };
+            var Ps = function(D, J) {
+              this.min = D, this.max = J, this.center = i.scale$2([], i.add([], this.min, this.max), 0.5);
+            };
+            Ps.prototype.quadrant = function(D) {
+              for (var J = [D % 2 === 0, D < 2], q = i.clone$2(this.min), K = i.clone$2(this.max), de = 0; de < J.length; de++) q[de] = J[de] ? this.min[de] : this.center[de], K[de] = J[de] ? this.center[de] : this.max[de];
+              return K[2] = this.max[2], new Ps(q, K);
+            }, Ps.prototype.distanceX = function(D) {
+              var J = Math.max(Math.min(this.max[0], D[0]), this.min[0]);
+              return J - D[0];
+            }, Ps.prototype.distanceY = function(D) {
+              var J = Math.max(Math.min(this.max[1], D[1]), this.min[1]);
+              return J - D[1];
+            }, Ps.prototype.intersects = function(D) {
+              for (var J = [[this.min[0], this.min[1], 0, 1], [this.max[0], this.min[1], 0, 1], [this.max[0], this.max[1], 0, 1], [this.min[0], this.max[1], 0, 1]], q = true, K = 0; K < D.planes.length; K++) {
+                for (var de = D.planes[K], ne = 0, we = 0; we < J.length; we++) ne += i.dot$1(de, J[we]) >= 0;
+                if (ne === 0) return 0;
+                ne !== J.length && (q = false);
+              }
+              if (q) return 2;
+              for (var Ue = 0; Ue < 3; Ue++) {
+                for (var ft = Number.MAX_VALUE, Zt = -Number.MAX_VALUE, hr = 0; hr < D.points.length; hr++) {
+                  var qt = D.points[hr][Ue] - this.min[Ue];
+                  ft = Math.min(ft, qt), Zt = Math.max(Zt, qt);
+                }
+                if (Zt < 0 || ft > this.max[Ue] - this.min[Ue]) return 0;
+              }
+              return 1;
+            };
+            var Ts = function(D, J, q, K) {
+              if (D === void 0 && (D = 0), J === void 0 && (J = 0), q === void 0 && (q = 0), K === void 0 && (K = 0), isNaN(D) || D < 0 || isNaN(J) || J < 0 || isNaN(q) || q < 0 || isNaN(K) || K < 0) throw new Error("Invalid value for edge-insets, top, bottom, left and right must all be numbers");
+              this.top = D, this.bottom = J, this.left = q, this.right = K;
+            };
+            Ts.prototype.interpolate = function(D, J, q) {
+              return J.top != null && D.top != null && (this.top = i.number(D.top, J.top, q)), J.bottom != null && D.bottom != null && (this.bottom = i.number(D.bottom, J.bottom, q)), J.left != null && D.left != null && (this.left = i.number(D.left, J.left, q)), J.right != null && D.right != null && (this.right = i.number(D.right, J.right, q)), this;
+            }, Ts.prototype.getCenter = function(D, J) {
+              var q = i.clamp((this.left + D - this.right) / 2, 0, D), K = i.clamp((this.top + J - this.bottom) / 2, 0, J);
+              return new i.Point(q, K);
+            }, Ts.prototype.equals = function(D) {
+              return this.top === D.top && this.bottom === D.bottom && this.left === D.left && this.right === D.right;
+            }, Ts.prototype.clone = function() {
+              return new Ts(this.top, this.bottom, this.left, this.right);
+            }, Ts.prototype.toJSON = function() {
+              return { top: this.top, bottom: this.bottom, left: this.left, right: this.right };
+            };
+            var wo = function(D, J, q, K, de) {
+              this.tileSize = 512, this.maxValidLatitude = 85.051129, this._renderWorldCopies = de === void 0 ? true : de, this._minZoom = D || 0, this._maxZoom = J || 22, this._minPitch = q == null ? 0 : q, this._maxPitch = K == null ? 60 : K, this.setMaxBounds(), this.width = 0, this.height = 0, this._center = new i.LngLat(0, 0), this.zoom = 0, this.angle = 0, this._fov = 0.6435011087932844, this._pitch = 0, this._unmodified = true, this._edgeInsets = new Ts(), this._posMatrixCache = {}, this._alignedPosMatrixCache = {};
+            }, To = { minZoom: { configurable: true }, maxZoom: { configurable: true }, minPitch: { configurable: true }, maxPitch: { configurable: true }, renderWorldCopies: { configurable: true }, worldSize: { configurable: true }, centerOffset: { configurable: true }, size: { configurable: true }, bearing: { configurable: true }, pitch: { configurable: true }, fov: { configurable: true }, zoom: { configurable: true }, center: { configurable: true }, padding: { configurable: true }, centerPoint: { configurable: true }, unmodified: { configurable: true }, point: { configurable: true } };
+            wo.prototype.clone = function() {
+              var D = new wo(this._minZoom, this._maxZoom, this._minPitch, this.maxPitch, this._renderWorldCopies);
+              return D.tileSize = this.tileSize, D.latRange = this.latRange, D.width = this.width, D.height = this.height, D._center = this._center, D.zoom = this.zoom, D.angle = this.angle, D._fov = this._fov, D._pitch = this._pitch, D._unmodified = this._unmodified, D._edgeInsets = this._edgeInsets.clone(), D._calcMatrices(), D;
+            }, To.minZoom.get = function() {
+              return this._minZoom;
+            }, To.minZoom.set = function(Y) {
+              this._minZoom !== Y && (this._minZoom = Y, this.zoom = Math.max(this.zoom, Y));
+            }, To.maxZoom.get = function() {
+              return this._maxZoom;
+            }, To.maxZoom.set = function(Y) {
+              this._maxZoom !== Y && (this._maxZoom = Y, this.zoom = Math.min(this.zoom, Y));
+            }, To.minPitch.get = function() {
+              return this._minPitch;
+            }, To.minPitch.set = function(Y) {
+              this._minPitch !== Y && (this._minPitch = Y, this.pitch = Math.max(this.pitch, Y));
+            }, To.maxPitch.get = function() {
+              return this._maxPitch;
+            }, To.maxPitch.set = function(Y) {
+              this._maxPitch !== Y && (this._maxPitch = Y, this.pitch = Math.min(this.pitch, Y));
+            }, To.renderWorldCopies.get = function() {
+              return this._renderWorldCopies;
+            }, To.renderWorldCopies.set = function(Y) {
+              Y === void 0 ? Y = true : Y === null && (Y = false), this._renderWorldCopies = Y;
+            }, To.worldSize.get = function() {
+              return this.tileSize * this.scale;
+            }, To.centerOffset.get = function() {
+              return this.centerPoint._sub(this.size._div(2));
+            }, To.size.get = function() {
+              return new i.Point(this.width, this.height);
+            }, To.bearing.get = function() {
+              return -this.angle / Math.PI * 180;
+            }, To.bearing.set = function(Y) {
+              var D = -i.wrap(Y, -180, 180) * Math.PI / 180;
+              this.angle !== D && (this._unmodified = false, this.angle = D, this._calcMatrices(), this.rotationMatrix = i.create$2(), i.rotate(this.rotationMatrix, this.rotationMatrix, this.angle));
+            }, To.pitch.get = function() {
+              return this._pitch / Math.PI * 180;
+            }, To.pitch.set = function(Y) {
+              var D = i.clamp(Y, this.minPitch, this.maxPitch) / 180 * Math.PI;
+              this._pitch !== D && (this._unmodified = false, this._pitch = D, this._calcMatrices());
+            }, To.fov.get = function() {
+              return this._fov / Math.PI * 180;
+            }, To.fov.set = function(Y) {
+              Y = Math.max(0.01, Math.min(60, Y)), this._fov !== Y && (this._unmodified = false, this._fov = Y / 180 * Math.PI, this._calcMatrices());
+            }, To.zoom.get = function() {
+              return this._zoom;
+            }, To.zoom.set = function(Y) {
+              var D = Math.min(Math.max(Y, this.minZoom), this.maxZoom);
+              this._zoom !== D && (this._unmodified = false, this._zoom = D, this.scale = this.zoomScale(D), this.tileZoom = Math.floor(D), this.zoomFraction = D - this.tileZoom, this._constrain(), this._calcMatrices());
+            }, To.center.get = function() {
+              return this._center;
+            }, To.center.set = function(Y) {
+              Y.lat === this._center.lat && Y.lng === this._center.lng || (this._unmodified = false, this._center = Y, this._constrain(), this._calcMatrices());
+            }, To.padding.get = function() {
+              return this._edgeInsets.toJSON();
+            }, To.padding.set = function(Y) {
+              this._edgeInsets.equals(Y) || (this._unmodified = false, this._edgeInsets.interpolate(this._edgeInsets, Y, 1), this._calcMatrices());
+            }, To.centerPoint.get = function() {
+              return this._edgeInsets.getCenter(this.width, this.height);
+            }, wo.prototype.isPaddingEqual = function(D) {
+              return this._edgeInsets.equals(D);
+            }, wo.prototype.interpolatePadding = function(D, J, q) {
+              this._unmodified = false, this._edgeInsets.interpolate(D, J, q), this._constrain(), this._calcMatrices();
+            }, wo.prototype.coveringZoomLevel = function(D) {
+              var J = (D.roundZoom ? Math.round : Math.floor)(this.zoom + this.scaleZoom(this.tileSize / D.tileSize));
+              return Math.max(0, J);
+            }, wo.prototype.getVisibleUnwrappedCoordinates = function(D) {
+              var J = [new i.UnwrappedTileID(0, D)];
+              if (this._renderWorldCopies) for (var q = this.pointCoordinate(new i.Point(0, 0)), K = this.pointCoordinate(new i.Point(this.width, 0)), de = this.pointCoordinate(new i.Point(this.width, this.height)), ne = this.pointCoordinate(new i.Point(0, this.height)), we = Math.floor(Math.min(q.x, K.x, de.x, ne.x)), Ue = Math.floor(Math.max(q.x, K.x, de.x, ne.x)), ft = 1, Zt = we - ft; Zt <= Ue + ft; Zt++) Zt !== 0 && J.push(new i.UnwrappedTileID(Zt, D));
+              return J;
+            }, wo.prototype.coveringTiles = function(D) {
+              var J = this.coveringZoomLevel(D), q = J;
+              if (D.minzoom !== void 0 && J < D.minzoom) return [];
+              D.maxzoom !== void 0 && J > D.maxzoom && (J = D.maxzoom);
+              var K = i.MercatorCoordinate.fromLngLat(this.center), de = Math.pow(2, J), ne = [de * K.x, de * K.y, 0], we = Bo.fromInvProjectionMatrix(this.invProjMatrix, this.worldSize, J), Ue = D.minzoom || 0;
+              this.pitch <= 60 && this._edgeInsets.top < 0.1 && (Ue = J);
+              var ft = 3, Zt = function(fi) {
+                return { aabb: new Ps([fi * de, 0, 0], [(fi + 1) * de, de, 0]), zoom: 0, x: 0, y: 0, wrap: fi, fullyVisible: false };
+              }, hr = [], qt = [], Ve = J, Qe = D.reparseOverscaled ? q : J;
+              if (this._renderWorldCopies) for (var at = 1; at <= 3; at++) hr.push(Zt(-at)), hr.push(Zt(at));
+              for (hr.push(Zt(0)); hr.length > 0; ) {
+                var Ct = hr.pop(), Ot = Ct.x, Rt = Ct.y, Bt = Ct.fullyVisible;
+                if (!Bt) {
+                  var Dt = Ct.aabb.intersects(we);
+                  if (Dt === 0) continue;
+                  Bt = Dt === 2;
+                }
+                var yt = Ct.aabb.distanceX(ne), Pt = Ct.aabb.distanceY(ne), ht = Math.max(Math.abs(yt), Math.abs(Pt)), ur = ft + (1 << Ve - Ct.zoom) - 2;
+                if (Ct.zoom === Ve || ht > ur && Ct.zoom >= Ue) {
+                  qt.push({ tileID: new i.OverscaledTileID(Ct.zoom === Ve ? Qe : Ct.zoom, Ct.wrap, Ct.zoom, Ot, Rt), distanceSq: i.sqrLen([ne[0] - 0.5 - Ot, ne[1] - 0.5 - Rt]) });
+                  continue;
+                }
+                for (var br = 0; br < 4; br++) {
+                  var Ur = (Ot << 1) + br % 2, Di = (Rt << 1) + (br >> 1);
+                  hr.push({ aabb: Ct.aabb.quadrant(br), zoom: Ct.zoom + 1, x: Ur, y: Di, wrap: Ct.wrap, fullyVisible: Bt });
+                }
+              }
+              return qt.sort(function(fi, Ti) {
+                return fi.distanceSq - Ti.distanceSq;
+              }).map(function(fi) {
+                return fi.tileID;
+              });
+            }, wo.prototype.resize = function(D, J) {
+              this.width = D, this.height = J, this.pixelsToGLUnits = [2 / D, -2 / J], this._constrain(), this._calcMatrices();
+            }, To.unmodified.get = function() {
+              return this._unmodified;
+            }, wo.prototype.zoomScale = function(D) {
+              return Math.pow(2, D);
+            }, wo.prototype.scaleZoom = function(D) {
+              return Math.log(D) / Math.LN2;
+            }, wo.prototype.project = function(D) {
+              var J = i.clamp(D.lat, -this.maxValidLatitude, this.maxValidLatitude);
+              return new i.Point(i.mercatorXfromLng(D.lng) * this.worldSize, i.mercatorYfromLat(J) * this.worldSize);
+            }, wo.prototype.unproject = function(D) {
+              return new i.MercatorCoordinate(D.x / this.worldSize, D.y / this.worldSize).toLngLat();
+            }, To.point.get = function() {
+              return this.project(this.center);
+            }, wo.prototype.setLocationAtPoint = function(D, J) {
+              var q = this.pointCoordinate(J), K = this.pointCoordinate(this.centerPoint), de = this.locationCoordinate(D), ne = new i.MercatorCoordinate(de.x - (q.x - K.x), de.y - (q.y - K.y));
+              this.center = this.coordinateLocation(ne), this._renderWorldCopies && (this.center = this.center.wrap());
+            }, wo.prototype.locationPoint = function(D) {
+              return this.coordinatePoint(this.locationCoordinate(D));
+            }, wo.prototype.pointLocation = function(D) {
+              return this.coordinateLocation(this.pointCoordinate(D));
+            }, wo.prototype.locationCoordinate = function(D) {
+              return i.MercatorCoordinate.fromLngLat(D);
+            }, wo.prototype.coordinateLocation = function(D) {
+              return D.toLngLat();
+            }, wo.prototype.pointCoordinate = function(D) {
+              var J = 0, q = [D.x, D.y, 0, 1], K = [D.x, D.y, 1, 1];
+              i.transformMat4(q, q, this.pixelMatrixInverse), i.transformMat4(K, K, this.pixelMatrixInverse);
+              var de = q[3], ne = K[3], we = q[0] / de, Ue = K[0] / ne, ft = q[1] / de, Zt = K[1] / ne, hr = q[2] / de, qt = K[2] / ne, Ve = hr === qt ? 0 : (J - hr) / (qt - hr);
+              return new i.MercatorCoordinate(i.number(we, Ue, Ve) / this.worldSize, i.number(ft, Zt, Ve) / this.worldSize);
+            }, wo.prototype.coordinatePoint = function(D) {
+              var J = [D.x * this.worldSize, D.y * this.worldSize, 0, 1];
+              return i.transformMat4(J, J, this.pixelMatrix), new i.Point(J[0] / J[3], J[1] / J[3]);
+            }, wo.prototype.getBounds = function() {
+              return new i.LngLatBounds().extend(this.pointLocation(new i.Point(0, 0))).extend(this.pointLocation(new i.Point(this.width, 0))).extend(this.pointLocation(new i.Point(this.width, this.height))).extend(this.pointLocation(new i.Point(0, this.height)));
+            }, wo.prototype.getMaxBounds = function() {
+              return !this.latRange || this.latRange.length !== 2 || !this.lngRange || this.lngRange.length !== 2 ? null : new i.LngLatBounds([this.lngRange[0], this.latRange[0]], [this.lngRange[1], this.latRange[1]]);
+            }, wo.prototype.setMaxBounds = function(D) {
+              D ? (this.lngRange = [D.getWest(), D.getEast()], this.latRange = [D.getSouth(), D.getNorth()], this._constrain()) : (this.lngRange = null, this.latRange = [-this.maxValidLatitude, this.maxValidLatitude]);
+            }, wo.prototype.calculatePosMatrix = function(D, J) {
+              J === void 0 && (J = false);
+              var q = D.key, K = J ? this._alignedPosMatrixCache : this._posMatrixCache;
+              if (K[q]) return K[q];
+              var de = D.canonical, ne = this.worldSize / this.zoomScale(de.z), we = de.x + Math.pow(2, de.z) * D.wrap, Ue = i.identity(new Float64Array(16));
+              return i.translate(Ue, Ue, [we * ne, de.y * ne, 0]), i.scale(Ue, Ue, [ne / i.EXTENT, ne / i.EXTENT, 1]), i.multiply(Ue, J ? this.alignedProjMatrix : this.projMatrix, Ue), K[q] = new Float32Array(Ue), K[q];
+            }, wo.prototype.customLayerMatrix = function() {
+              return this.mercatorMatrix.slice();
+            }, wo.prototype._constrain = function() {
+              if (!(!this.center || !this.width || !this.height || this._constraining)) {
+                this._constraining = true;
+                var D = -90, J = 90, q = -180, K = 180, de, ne, we, Ue, ft = this.size, Zt = this._unmodified;
+                if (this.latRange) {
+                  var hr = this.latRange;
+                  D = i.mercatorYfromLat(hr[1]) * this.worldSize, J = i.mercatorYfromLat(hr[0]) * this.worldSize, de = J - D < ft.y ? ft.y / (J - D) : 0;
+                }
+                if (this.lngRange) {
+                  var qt = this.lngRange;
+                  q = i.mercatorXfromLng(qt[0]) * this.worldSize, K = i.mercatorXfromLng(qt[1]) * this.worldSize, ne = K - q < ft.x ? ft.x / (K - q) : 0;
+                }
+                var Ve = this.point, Qe = Math.max(ne || 0, de || 0);
+                if (Qe) {
+                  this.center = this.unproject(new i.Point(ne ? (K + q) / 2 : Ve.x, de ? (J + D) / 2 : Ve.y)), this.zoom += this.scaleZoom(Qe), this._unmodified = Zt, this._constraining = false;
+                  return;
+                }
+                if (this.latRange) {
+                  var at = Ve.y, Ct = ft.y / 2;
+                  at - Ct < D && (Ue = D + Ct), at + Ct > J && (Ue = J - Ct);
+                }
+                if (this.lngRange) {
+                  var Ot = Ve.x, Rt = ft.x / 2;
+                  Ot - Rt < q && (we = q + Rt), Ot + Rt > K && (we = K - Rt);
+                }
+                (we !== void 0 || Ue !== void 0) && (this.center = this.unproject(new i.Point(we !== void 0 ? we : Ve.x, Ue !== void 0 ? Ue : Ve.y))), this._unmodified = Zt, this._constraining = false;
+              }
+            }, wo.prototype._calcMatrices = function() {
+              if (this.height) {
+                var D = this._fov / 2, J = this.centerOffset;
+                this.cameraToCenterDistance = 0.5 / Math.tan(D) * this.height;
+                var q = Math.PI / 2 + this._pitch, K = this._fov * (0.5 + J.y / this.height), de = Math.sin(K) * this.cameraToCenterDistance / Math.sin(i.clamp(Math.PI - q - K, 0.01, Math.PI - 0.01)), ne = this.point, we = ne.x, Ue = ne.y, ft = Math.cos(Math.PI / 2 - this._pitch) * de + this.cameraToCenterDistance, Zt = ft * 1.01, hr = this.height / 50, qt = new Float64Array(16);
+                i.perspective(qt, this._fov, this.width / this.height, hr, Zt), qt[8] = -J.x * 2 / this.width, qt[9] = J.y * 2 / this.height, i.scale(qt, qt, [1, -1, 1]), i.translate(qt, qt, [0, 0, -this.cameraToCenterDistance]), i.rotateX(qt, qt, this._pitch), i.rotateZ(qt, qt, this.angle), i.translate(qt, qt, [-we, -Ue, 0]), this.mercatorMatrix = i.scale([], qt, [this.worldSize, this.worldSize, this.worldSize]), i.scale(qt, qt, [1, 1, i.mercatorZfromAltitude(1, this.center.lat) * this.worldSize, 1]), this.projMatrix = qt, this.invProjMatrix = i.invert([], this.projMatrix);
+                var Ve = this.width % 2 / 2, Qe = this.height % 2 / 2, at = Math.cos(this.angle), Ct = Math.sin(this.angle), Ot = we - Math.round(we) + at * Ve + Ct * Qe, Rt = Ue - Math.round(Ue) + at * Qe + Ct * Ve, Bt = new Float64Array(qt);
+                if (i.translate(Bt, Bt, [Ot > 0.5 ? Ot - 1 : Ot, Rt > 0.5 ? Rt - 1 : Rt, 0]), this.alignedProjMatrix = Bt, qt = i.create(), i.scale(qt, qt, [this.width / 2, -this.height / 2, 1]), i.translate(qt, qt, [1, -1, 0]), this.labelPlaneMatrix = qt, qt = i.create(), i.scale(qt, qt, [1, -1, 1]), i.translate(qt, qt, [-1, -1, 0]), i.scale(qt, qt, [2 / this.width, 2 / this.height, 1]), this.glCoordMatrix = qt, this.pixelMatrix = i.multiply(new Float64Array(16), this.labelPlaneMatrix, this.projMatrix), qt = i.invert(new Float64Array(16), this.pixelMatrix), !qt) throw new Error("failed to invert matrix");
+                this.pixelMatrixInverse = qt, this._posMatrixCache = {}, this._alignedPosMatrixCache = {};
+              }
+            }, wo.prototype.maxPitchScaleFactor = function() {
+              if (!this.pixelMatrixInverse) return 1;
+              var D = this.pointCoordinate(new i.Point(0, 0)), J = [D.x * this.worldSize, D.y * this.worldSize, 0, 1], q = i.transformMat4(J, J, this.pixelMatrix);
+              return q[3] / this.cameraToCenterDistance;
+            }, wo.prototype.getCameraPoint = function() {
+              var D = this._pitch, J = Math.tan(D) * (this.cameraToCenterDistance || 1);
+              return this.centerPoint.add(new i.Point(0, J));
+            }, wo.prototype.getCameraQueryGeometry = function(D) {
+              var J = this.getCameraPoint();
+              if (D.length === 1) return [D[0], J];
+              for (var q = J.x, K = J.y, de = J.x, ne = J.y, we = 0, Ue = D; we < Ue.length; we += 1) {
+                var ft = Ue[we];
+                q = Math.min(q, ft.x), K = Math.min(K, ft.y), de = Math.max(de, ft.x), ne = Math.max(ne, ft.y);
+              }
+              return [new i.Point(q, K), new i.Point(de, K), new i.Point(de, ne), new i.Point(q, ne), new i.Point(q, K)];
+            }, Object.defineProperties(wo.prototype, To);
+            function hl(Y, D) {
+              var J = false, q = null, K = function() {
+                q = null, J && (Y(), q = setTimeout(K, D), J = false);
+              };
+              return function() {
+                return J = true, q || K(), q;
+              };
+            }
+            var Ul = function(D) {
+              this._hashName = D && encodeURIComponent(D), i.bindAll(["_getCurrentHash", "_onHashChange", "_updateHash"], this), this._updateHash = hl(this._updateHashUnthrottled.bind(this), 30 * 1e3 / 100);
+            };
+            Ul.prototype.addTo = function(D) {
+              return this._map = D, i.window.addEventListener("hashchange", this._onHashChange, false), this._map.on("moveend", this._updateHash), this;
+            }, Ul.prototype.remove = function() {
+              return i.window.removeEventListener("hashchange", this._onHashChange, false), this._map.off("moveend", this._updateHash), clearTimeout(this._updateHash()), delete this._map, this;
+            }, Ul.prototype.getHashString = function(D) {
+              var J = this._map.getCenter(), q = Math.round(this._map.getZoom() * 100) / 100, K = Math.ceil((q * Math.LN2 + Math.log(512 / 360 / 0.5)) / Math.LN10), de = Math.pow(10, K), ne = Math.round(J.lng * de) / de, we = Math.round(J.lat * de) / de, Ue = this._map.getBearing(), ft = this._map.getPitch(), Zt = "";
+              if (D ? Zt += "/" + ne + "/" + we + "/" + q : Zt += q + "/" + we + "/" + ne, (Ue || ft) && (Zt += "/" + Math.round(Ue * 10) / 10), ft && (Zt += "/" + Math.round(ft)), this._hashName) {
+                var hr = this._hashName, qt = false, Ve = i.window.location.hash.slice(1).split("&").map(function(Qe) {
+                  var at = Qe.split("=")[0];
+                  return at === hr ? (qt = true, at + "=" + Zt) : Qe;
+                }).filter(function(Qe) {
+                  return Qe;
+                });
+                return qt || Ve.push(hr + "=" + Zt), "#" + Ve.join("&");
+              }
+              return "#" + Zt;
+            }, Ul.prototype._getCurrentHash = function() {
+              var D = this, J = i.window.location.hash.replace("#", "");
+              if (this._hashName) {
+                var q;
+                return J.split("&").map(function(K) {
+                  return K.split("=");
+                }).forEach(function(K) {
+                  K[0] === D._hashName && (q = K);
+                }), (q && q[1] || "").split("/");
+              }
+              return J.split("/");
+            }, Ul.prototype._onHashChange = function() {
+              var D = this._getCurrentHash();
+              if (D.length >= 3 && !D.some(function(q) {
+                return isNaN(q);
+              })) {
+                var J = this._map.dragRotate.isEnabled() && this._map.touchZoomRotate.isEnabled() ? +(D[3] || 0) : this._map.getBearing();
+                return this._map.jumpTo({ center: [+D[2], +D[1]], zoom: +D[0], bearing: J, pitch: +(D[4] || 0) }), true;
+              }
+              return false;
+            }, Ul.prototype._updateHashUnthrottled = function() {
+              var D = i.window.location.href.replace(/(#.+)?$/, this.getHashString());
+              try {
+                i.window.history.replaceState(i.window.history.state, null, D);
+              } catch (J) {
+              }
+            };
+            var Lu = { linearity: 0.3, easing: i.bezier(0, 0, 0.3, 1) }, au = i.extend({ deceleration: 2500, maxSpeed: 1400 }, Lu), Js = i.extend({ deceleration: 20, maxSpeed: 1400 }, Lu), eu = i.extend({ deceleration: 1e3, maxSpeed: 360 }, Lu), dc = i.extend({ deceleration: 1e3, maxSpeed: 90 }, Lu), Tl = function(D) {
+              this._map = D, this.clear();
+            };
+            Tl.prototype.clear = function() {
+              this._inertiaBuffer = [];
+            }, Tl.prototype.record = function(D) {
+              this._drainInertiaBuffer(), this._inertiaBuffer.push({ time: i.browser.now(), settings: D });
+            }, Tl.prototype._drainInertiaBuffer = function() {
+              for (var D = this._inertiaBuffer, J = i.browser.now(), q = 160; D.length > 0 && J - D[0].time > q; ) D.shift();
+            }, Tl.prototype._onMoveEnd = function(D) {
+              if (this._drainInertiaBuffer(), !(this._inertiaBuffer.length < 2)) {
+                for (var J = { zoom: 0, bearing: 0, pitch: 0, pan: new i.Point(0, 0), pinchAround: void 0, around: void 0 }, q = 0, K = this._inertiaBuffer; q < K.length; q += 1) {
+                  var de = K[q], ne = de.settings;
+                  J.zoom += ne.zoomDelta || 0, J.bearing += ne.bearingDelta || 0, J.pitch += ne.pitchDelta || 0, ne.panDelta && J.pan._add(ne.panDelta), ne.around && (J.around = ne.around), ne.pinchAround && (J.pinchAround = ne.pinchAround);
+                }
+                var we = this._inertiaBuffer[this._inertiaBuffer.length - 1], Ue = we.time - this._inertiaBuffer[0].time, ft = {};
+                if (J.pan.mag()) {
+                  var Zt = X(J.pan.mag(), Ue, i.extend({}, au, D || {}));
+                  ft.offset = J.pan.mult(Zt.amount / J.pan.mag()), ft.center = this._map.transform.center, Al(ft, Zt);
+                }
+                if (J.zoom) {
+                  var hr = X(J.zoom, Ue, Js);
+                  ft.zoom = this._map.transform.zoom + hr.amount, Al(ft, hr);
+                }
+                if (J.bearing) {
+                  var qt = X(J.bearing, Ue, eu);
+                  ft.bearing = this._map.transform.bearing + i.clamp(qt.amount, -179, 179), Al(ft, qt);
+                }
+                if (J.pitch) {
+                  var Ve = X(J.pitch, Ue, dc);
+                  ft.pitch = this._map.transform.pitch + Ve.amount, Al(ft, Ve);
+                }
+                if (ft.zoom || ft.bearing) {
+                  var Qe = J.pinchAround === void 0 ? J.around : J.pinchAround;
+                  ft.around = Qe ? this._map.unproject(Qe) : this._map.getCenter();
+                }
+                return this.clear(), i.extend(ft, { noMoveStart: true });
+              }
+            };
+            function Al(Y, D) {
+              (!Y.duration || Y.duration < D.duration) && (Y.duration = D.duration, Y.easing = D.easing);
+            }
+            function X(Y, D, J) {
+              var q = J.maxSpeed, K = J.linearity, de = J.deceleration, ne = i.clamp(Y * K / (D / 1e3), -q, q), we = Math.abs(ne) / (de * K);
+              return { easing: J.easing, duration: we * 1e3, amount: ne * (we / 2) };
+            }
+            var se = function(Y) {
+              function D(q, K, de, ne) {
+                ne === void 0 && (ne = {});
+                var we = o.mousePos(K.getCanvasContainer(), de), Ue = K.unproject(we);
+                Y.call(this, q, i.extend({ point: we, lngLat: Ue, originalEvent: de }, ne)), this._defaultPrevented = false, this.target = K;
+              }
+              Y && (D.__proto__ = Y), D.prototype = Object.create(Y && Y.prototype), D.prototype.constructor = D;
+              var J = { defaultPrevented: { configurable: true } };
+              return D.prototype.preventDefault = function() {
+                this._defaultPrevented = true;
+              }, J.defaultPrevented.get = function() {
+                return this._defaultPrevented;
+              }, Object.defineProperties(D.prototype, J), D;
+            }(i.Event), Te = function(Y) {
+              function D(q, K, de) {
+                var ne = q === "touchend" ? de.changedTouches : de.touches, we = o.touchPos(K.getCanvasContainer(), ne), Ue = we.map(function(hr) {
+                  return K.unproject(hr);
+                }), ft = we.reduce(function(hr, qt, Ve, Qe) {
+                  return hr.add(qt.div(Qe.length));
+                }, new i.Point(0, 0)), Zt = K.unproject(ft);
+                Y.call(this, q, { points: we, point: ft, lngLats: Ue, lngLat: Zt, originalEvent: de }), this._defaultPrevented = false;
+              }
+              Y && (D.__proto__ = Y), D.prototype = Object.create(Y && Y.prototype), D.prototype.constructor = D;
+              var J = { defaultPrevented: { configurable: true } };
+              return D.prototype.preventDefault = function() {
+                this._defaultPrevented = true;
+              }, J.defaultPrevented.get = function() {
+                return this._defaultPrevented;
+              }, Object.defineProperties(D.prototype, J), D;
+            }(i.Event), Ne = function(Y) {
+              function D(q, K, de) {
+                Y.call(this, q, { originalEvent: de }), this._defaultPrevented = false;
+              }
+              Y && (D.__proto__ = Y), D.prototype = Object.create(Y && Y.prototype), D.prototype.constructor = D;
+              var J = { defaultPrevented: { configurable: true } };
+              return D.prototype.preventDefault = function() {
+                this._defaultPrevented = true;
+              }, J.defaultPrevented.get = function() {
+                return this._defaultPrevented;
+              }, Object.defineProperties(D.prototype, J), D;
+            }(i.Event), He = function(D, J) {
+              this._map = D, this._clickTolerance = J.clickTolerance;
+            };
+            He.prototype.reset = function() {
+              delete this._mousedownPos;
+            }, He.prototype.wheel = function(D) {
+              return this._firePreventable(new Ne(D.type, this._map, D));
+            }, He.prototype.mousedown = function(D, J) {
+              return this._mousedownPos = J, this._firePreventable(new se(D.type, this._map, D));
+            }, He.prototype.mouseup = function(D) {
+              this._map.fire(new se(D.type, this._map, D));
+            }, He.prototype.click = function(D, J) {
+              this._mousedownPos && this._mousedownPos.dist(J) >= this._clickTolerance || this._map.fire(new se(D.type, this._map, D));
+            }, He.prototype.dblclick = function(D) {
+              return this._firePreventable(new se(D.type, this._map, D));
+            }, He.prototype.mouseover = function(D) {
+              this._map.fire(new se(D.type, this._map, D));
+            }, He.prototype.mouseout = function(D) {
+              this._map.fire(new se(D.type, this._map, D));
+            }, He.prototype.touchstart = function(D) {
+              return this._firePreventable(new Te(D.type, this._map, D));
+            }, He.prototype.touchmove = function(D) {
+              this._map.fire(new Te(D.type, this._map, D));
+            }, He.prototype.touchend = function(D) {
+              this._map.fire(new Te(D.type, this._map, D));
+            }, He.prototype.touchcancel = function(D) {
+              this._map.fire(new Te(D.type, this._map, D));
+            }, He.prototype._firePreventable = function(D) {
+              if (this._map.fire(D), D.defaultPrevented) return {};
+            }, He.prototype.isEnabled = function() {
+              return true;
+            }, He.prototype.isActive = function() {
+              return false;
+            }, He.prototype.enable = function() {
+            }, He.prototype.disable = function() {
+            };
+            var Ye = function(D) {
+              this._map = D;
+            };
+            Ye.prototype.reset = function() {
+              this._delayContextMenu = false, delete this._contextMenuEvent;
+            }, Ye.prototype.mousemove = function(D) {
+              this._map.fire(new se(D.type, this._map, D));
+            }, Ye.prototype.mousedown = function() {
+              this._delayContextMenu = true;
+            }, Ye.prototype.mouseup = function() {
+              this._delayContextMenu = false, this._contextMenuEvent && (this._map.fire(new se("contextmenu", this._map, this._contextMenuEvent)), delete this._contextMenuEvent);
+            }, Ye.prototype.contextmenu = function(D) {
+              this._delayContextMenu ? this._contextMenuEvent = D : this._map.fire(new se(D.type, this._map, D)), this._map.listens("contextmenu") && D.preventDefault();
+            }, Ye.prototype.isEnabled = function() {
+              return true;
+            }, Ye.prototype.isActive = function() {
+              return false;
+            }, Ye.prototype.enable = function() {
+            }, Ye.prototype.disable = function() {
+            };
+            var kt = function(D, J) {
+              this._map = D, this._el = D.getCanvasContainer(), this._container = D.getContainer(), this._clickTolerance = J.clickTolerance || 1;
+            };
+            kt.prototype.isEnabled = function() {
+              return !!this._enabled;
+            }, kt.prototype.isActive = function() {
+              return !!this._active;
+            }, kt.prototype.enable = function() {
+              this.isEnabled() || (this._enabled = true);
+            }, kt.prototype.disable = function() {
+              this.isEnabled() && (this._enabled = false);
+            }, kt.prototype.mousedown = function(D, J) {
+              this.isEnabled() && D.shiftKey && D.button === 0 && (o.disableDrag(), this._startPos = this._lastPos = J, this._active = true);
+            }, kt.prototype.mousemoveWindow = function(D, J) {
+              if (this._active) {
+                var q = J;
+                if (!(this._lastPos.equals(q) || !this._box && q.dist(this._startPos) < this._clickTolerance)) {
+                  var K = this._startPos;
+                  this._lastPos = q, this._box || (this._box = o.create("div", "mapboxgl-boxzoom", this._container), this._container.classList.add("mapboxgl-crosshair"), this._fireEvent("boxzoomstart", D));
+                  var de = Math.min(K.x, q.x), ne = Math.max(K.x, q.x), we = Math.min(K.y, q.y), Ue = Math.max(K.y, q.y);
+                  o.setTransform(this._box, "translate(" + de + "px," + we + "px)"), this._box.style.width = ne - de + "px", this._box.style.height = Ue - we + "px";
+                }
+              }
+            }, kt.prototype.mouseupWindow = function(D, J) {
+              var q = this;
+              if (this._active && D.button === 0) {
+                var K = this._startPos, de = J;
+                if (this.reset(), o.suppressClick(), K.x === de.x && K.y === de.y) this._fireEvent("boxzoomcancel", D);
+                else return this._map.fire(new i.Event("boxzoomend", { originalEvent: D })), { cameraAnimation: function(ne) {
+                  return ne.fitScreenCoordinates(K, de, q._map.getBearing(), { linear: true });
+                } };
+              }
+            }, kt.prototype.keydown = function(D) {
+              this._active && D.keyCode === 27 && (this.reset(), this._fireEvent("boxzoomcancel", D));
+            }, kt.prototype.reset = function() {
+              this._active = false, this._container.classList.remove("mapboxgl-crosshair"), this._box && (o.remove(this._box), this._box = null), o.enableDrag(), delete this._startPos, delete this._lastPos;
+            }, kt.prototype._fireEvent = function(D, J) {
+              return this._map.fire(new i.Event(D, { originalEvent: J }));
+            };
+            function nt(Y, D) {
+              for (var J = {}, q = 0; q < Y.length; q++) J[Y[q].identifier] = D[q];
+              return J;
+            }
+            function jt(Y) {
+              for (var D = new i.Point(0, 0), J = 0, q = Y; J < q.length; J += 1) {
+                var K = q[J];
+                D._add(K);
+              }
+              return D.div(Y.length);
+            }
+            var gr = 500, yr = 500, Hr = 30, qr = function(D) {
+              this.reset(), this.numTouches = D.numTouches;
+            };
+            qr.prototype.reset = function() {
+              delete this.centroid, delete this.startTime, delete this.touches, this.aborted = false;
+            }, qr.prototype.touchstart = function(D, J, q) {
+              (this.centroid || q.length > this.numTouches) && (this.aborted = true), !this.aborted && (this.startTime === void 0 && (this.startTime = D.timeStamp), q.length === this.numTouches && (this.centroid = jt(J), this.touches = nt(q, J)));
+            }, qr.prototype.touchmove = function(D, J, q) {
+              if (!(this.aborted || !this.centroid)) {
+                var K = nt(q, J);
+                for (var de in this.touches) {
+                  var ne = this.touches[de], we = K[de];
+                  (!we || we.dist(ne) > Hr) && (this.aborted = true);
+                }
+              }
+            }, qr.prototype.touchend = function(D, J, q) {
+              if ((!this.centroid || D.timeStamp - this.startTime > yr) && (this.aborted = true), q.length === 0) {
+                var K = !this.aborted && this.centroid;
+                if (this.reset(), K) return K;
+              }
+            };
+            var _i = function(D) {
+              this.singleTap = new qr(D), this.numTaps = D.numTaps, this.reset();
+            };
+            _i.prototype.reset = function() {
+              this.lastTime = 1 / 0, delete this.lastTap, this.count = 0, this.singleTap.reset();
+            }, _i.prototype.touchstart = function(D, J, q) {
+              this.singleTap.touchstart(D, J, q);
+            }, _i.prototype.touchmove = function(D, J, q) {
+              this.singleTap.touchmove(D, J, q);
+            }, _i.prototype.touchend = function(D, J, q) {
+              var K = this.singleTap.touchend(D, J, q);
+              if (K) {
+                var de = D.timeStamp - this.lastTime < gr, ne = !this.lastTap || this.lastTap.dist(K) < Hr;
+                if ((!de || !ne) && this.reset(), this.count++, this.lastTime = D.timeStamp, this.lastTap = K, this.count === this.numTaps) return this.reset(), K;
+              }
+            };
+            var bi = function() {
+              this._zoomIn = new _i({ numTouches: 1, numTaps: 2 }), this._zoomOut = new _i({ numTouches: 2, numTaps: 1 }), this.reset();
+            };
+            bi.prototype.reset = function() {
+              this._active = false, this._zoomIn.reset(), this._zoomOut.reset();
+            }, bi.prototype.touchstart = function(D, J, q) {
+              this._zoomIn.touchstart(D, J, q), this._zoomOut.touchstart(D, J, q);
+            }, bi.prototype.touchmove = function(D, J, q) {
+              this._zoomIn.touchmove(D, J, q), this._zoomOut.touchmove(D, J, q);
+            }, bi.prototype.touchend = function(D, J, q) {
+              var K = this, de = this._zoomIn.touchend(D, J, q), ne = this._zoomOut.touchend(D, J, q);
+              if (de) return this._active = true, D.preventDefault(), setTimeout(function() {
+                return K.reset();
+              }, 0), { cameraAnimation: function(we) {
+                return we.easeTo({ duration: 300, zoom: we.getZoom() + 1, around: we.unproject(de) }, { originalEvent: D });
+              } };
+              if (ne) return this._active = true, D.preventDefault(), setTimeout(function() {
+                return K.reset();
+              }, 0), { cameraAnimation: function(we) {
+                return we.easeTo({ duration: 300, zoom: we.getZoom() - 1, around: we.unproject(ne) }, { originalEvent: D });
+              } };
+            }, bi.prototype.touchcancel = function() {
+              this.reset();
+            }, bi.prototype.enable = function() {
+              this._enabled = true;
+            }, bi.prototype.disable = function() {
+              this._enabled = false, this.reset();
+            }, bi.prototype.isEnabled = function() {
+              return this._enabled;
+            }, bi.prototype.isActive = function() {
+              return this._active;
+            };
+            var Zr = 0, ai = 2, gi = {};
+            gi[Zr] = 1, gi[ai] = 2;
+            function Ii(Y, D) {
+              var J = gi[D];
+              return Y.buttons === void 0 || (Y.buttons & J) !== J;
+            }
+            var Si = function(D) {
+              this.reset(), this._clickTolerance = D.clickTolerance || 1;
+            };
+            Si.prototype.reset = function() {
+              this._active = false, this._moved = false, delete this._lastPoint, delete this._eventButton;
+            }, Si.prototype._correctButton = function(D, J) {
+              return false;
+            }, Si.prototype._move = function(D, J) {
+              return {};
+            }, Si.prototype.mousedown = function(D, J) {
+              if (!this._lastPoint) {
+                var q = o.mouseButton(D);
+                this._correctButton(D, q) && (this._lastPoint = J, this._eventButton = q);
+              }
+            }, Si.prototype.mousemoveWindow = function(D, J) {
+              var q = this._lastPoint;
+              if (q) {
+                if (D.preventDefault(), Ii(D, this._eventButton)) {
+                  this.reset();
+                  return;
+                }
+                if (!(!this._moved && J.dist(q) < this._clickTolerance)) return this._moved = true, this._lastPoint = J, this._move(q, J);
+              }
+            }, Si.prototype.mouseupWindow = function(D) {
+              if (this._lastPoint) {
+                var J = o.mouseButton(D);
+                J === this._eventButton && (this._moved && o.suppressClick(), this.reset());
+              }
+            }, Si.prototype.enable = function() {
+              this._enabled = true;
+            }, Si.prototype.disable = function() {
+              this._enabled = false, this.reset();
+            }, Si.prototype.isEnabled = function() {
+              return this._enabled;
+            }, Si.prototype.isActive = function() {
+              return this._active;
+            };
+            var ei = function(Y) {
+              function D() {
+                Y.apply(this, arguments);
+              }
+              return Y && (D.__proto__ = Y), D.prototype = Object.create(Y && Y.prototype), D.prototype.constructor = D, D.prototype.mousedown = function(q, K) {
+                Y.prototype.mousedown.call(this, q, K), this._lastPoint && (this._active = true);
+              }, D.prototype._correctButton = function(q, K) {
+                return K === Zr && !q.ctrlKey;
+              }, D.prototype._move = function(q, K) {
+                return { around: K, panDelta: K.sub(q) };
+              }, D;
+            }(Si), Ln = function(Y) {
+              function D() {
+                Y.apply(this, arguments);
+              }
+              return Y && (D.__proto__ = Y), D.prototype = Object.create(Y && Y.prototype), D.prototype.constructor = D, D.prototype._correctButton = function(q, K) {
+                return K === Zr && q.ctrlKey || K === ai;
+              }, D.prototype._move = function(q, K) {
+                var de = 0.8, ne = (K.x - q.x) * de;
+                if (ne) return this._active = true, { bearingDelta: ne };
+              }, D.prototype.contextmenu = function(q) {
+                q.preventDefault();
+              }, D;
+            }(Si), En = function(Y) {
+              function D() {
+                Y.apply(this, arguments);
+              }
+              return Y && (D.__proto__ = Y), D.prototype = Object.create(Y && Y.prototype), D.prototype.constructor = D, D.prototype._correctButton = function(q, K) {
+                return K === Zr && q.ctrlKey || K === ai;
+              }, D.prototype._move = function(q, K) {
+                var de = -0.5, ne = (K.y - q.y) * de;
+                if (ne) return this._active = true, { pitchDelta: ne };
+              }, D.prototype.contextmenu = function(q) {
+                q.preventDefault();
+              }, D;
+            }(Si), Un = function(D) {
+              this._minTouches = 1, this._clickTolerance = D.clickTolerance || 1, this.reset();
+            };
+            Un.prototype.reset = function() {
+              this._active = false, this._touches = {}, this._sum = new i.Point(0, 0);
+            }, Un.prototype.touchstart = function(D, J, q) {
+              return this._calculateTransform(D, J, q);
+            }, Un.prototype.touchmove = function(D, J, q) {
+              if (!(!this._active || q.length < this._minTouches)) return D.preventDefault(), this._calculateTransform(D, J, q);
+            }, Un.prototype.touchend = function(D, J, q) {
+              this._calculateTransform(D, J, q), this._active && q.length < this._minTouches && this.reset();
+            }, Un.prototype.touchcancel = function() {
+              this.reset();
+            }, Un.prototype._calculateTransform = function(D, J, q) {
+              q.length > 0 && (this._active = true);
+              var K = nt(q, J), de = new i.Point(0, 0), ne = new i.Point(0, 0), we = 0;
+              for (var Ue in K) {
+                var ft = K[Ue], Zt = this._touches[Ue];
+                Zt && (de._add(ft), ne._add(ft.sub(Zt)), we++, K[Ue] = ft);
+              }
+              if (this._touches = K, !(we < this._minTouches || !ne.mag())) {
+                var hr = ne.div(we);
+                if (this._sum._add(hr), !(this._sum.mag() < this._clickTolerance)) {
+                  var qt = de.div(we);
+                  return { around: qt, panDelta: hr };
+                }
+              }
+            }, Un.prototype.enable = function() {
+              this._enabled = true;
+            }, Un.prototype.disable = function() {
+              this._enabled = false, this.reset();
+            }, Un.prototype.isEnabled = function() {
+              return this._enabled;
+            }, Un.prototype.isActive = function() {
+              return this._active;
+            };
+            var ia = function() {
+              this.reset();
+            };
+            ia.prototype.reset = function() {
+              this._active = false, delete this._firstTwoTouches;
+            }, ia.prototype._start = function(D) {
+            }, ia.prototype._move = function(D, J, q) {
+              return {};
+            }, ia.prototype.touchstart = function(D, J, q) {
+              this._firstTwoTouches || q.length < 2 || (this._firstTwoTouches = [q[0].identifier, q[1].identifier], this._start([J[0], J[1]]));
+            }, ia.prototype.touchmove = function(D, J, q) {
+              if (this._firstTwoTouches) {
+                D.preventDefault();
+                var K = this._firstTwoTouches, de = K[0], ne = K[1], we = Ea(q, J, de), Ue = Ea(q, J, ne);
+                if (!(!we || !Ue)) {
+                  var ft = this._aroundCenter ? null : we.add(Ue).div(2);
+                  return this._move([we, Ue], ft, D);
+                }
+              }
+            }, ia.prototype.touchend = function(D, J, q) {
+              if (this._firstTwoTouches) {
+                var K = this._firstTwoTouches, de = K[0], ne = K[1], we = Ea(q, J, de), Ue = Ea(q, J, ne);
+                we && Ue || (this._active && o.suppressClick(), this.reset());
+              }
+            }, ia.prototype.touchcancel = function() {
+              this.reset();
+            }, ia.prototype.enable = function(D) {
+              this._enabled = true, this._aroundCenter = !!D && D.around === "center";
+            }, ia.prototype.disable = function() {
+              this._enabled = false, this.reset();
+            }, ia.prototype.isEnabled = function() {
+              return this._enabled;
+            }, ia.prototype.isActive = function() {
+              return this._active;
+            };
+            function Ea(Y, D, J) {
+              for (var q = 0; q < Y.length; q++) if (Y[q].identifier === J) return D[q];
+            }
+            var Ia = 0.1;
+            function yo(Y, D) {
+              return Math.log(Y / D) / Math.LN2;
+            }
+            var Da = function(Y) {
+              function D() {
+                Y.apply(this, arguments);
+              }
+              return Y && (D.__proto__ = Y), D.prototype = Object.create(Y && Y.prototype), D.prototype.constructor = D, D.prototype.reset = function() {
+                Y.prototype.reset.call(this), delete this._distance, delete this._startDistance;
+              }, D.prototype._start = function(q) {
+                this._startDistance = this._distance = q[0].dist(q[1]);
+              }, D.prototype._move = function(q, K) {
+                var de = this._distance;
+                if (this._distance = q[0].dist(q[1]), !(!this._active && Math.abs(yo(this._distance, this._startDistance)) < Ia)) return this._active = true, { zoomDelta: yo(this._distance, de), pinchAround: K };
+              }, D;
+            }(ia), go = 25;
+            function Is(Y, D) {
+              return Y.angleWith(D) * 180 / Math.PI;
+            }
+            var Ms = function(Y) {
+              function D() {
+                Y.apply(this, arguments);
+              }
+              return Y && (D.__proto__ = Y), D.prototype = Object.create(Y && Y.prototype), D.prototype.constructor = D, D.prototype.reset = function() {
+                Y.prototype.reset.call(this), delete this._minDiameter, delete this._startVector, delete this._vector;
+              }, D.prototype._start = function(q) {
+                this._startVector = this._vector = q[0].sub(q[1]), this._minDiameter = q[0].dist(q[1]);
+              }, D.prototype._move = function(q, K) {
+                var de = this._vector;
+                if (this._vector = q[0].sub(q[1]), !(!this._active && this._isBelowThreshold(this._vector))) return this._active = true, { bearingDelta: Is(this._vector, de), pinchAround: K };
+              }, D.prototype._isBelowThreshold = function(q) {
+                this._minDiameter = Math.min(this._minDiameter, q.mag());
+                var K = Math.PI * this._minDiameter, de = go / K * 360, ne = Is(q, this._startVector);
+                return Math.abs(ne) < de;
+              }, D;
+            }(ia);
+            function Xs(Y) {
+              return Math.abs(Y.y) > Math.abs(Y.x);
+            }
+            var Gn = 100, ja = function(Y) {
+              function D() {
+                Y.apply(this, arguments);
+              }
+              return Y && (D.__proto__ = Y), D.prototype = Object.create(Y && Y.prototype), D.prototype.constructor = D, D.prototype.reset = function() {
+                Y.prototype.reset.call(this), this._valid = void 0, delete this._firstMove, delete this._lastPoints;
+              }, D.prototype._start = function(q) {
+                this._lastPoints = q, Xs(q[0].sub(q[1])) && (this._valid = false);
+              }, D.prototype._move = function(q, K, de) {
+                var ne = q[0].sub(this._lastPoints[0]), we = q[1].sub(this._lastPoints[1]);
+                if (this._valid = this.gestureBeginsVertically(ne, we, de.timeStamp), !!this._valid) {
+                  this._lastPoints = q, this._active = true;
+                  var Ue = (ne.y + we.y) / 2, ft = -0.5;
+                  return { pitchDelta: Ue * ft };
+                }
+              }, D.prototype.gestureBeginsVertically = function(q, K, de) {
+                if (this._valid !== void 0) return this._valid;
+                var ne = 2, we = q.mag() >= ne, Ue = K.mag() >= ne;
+                if (!(!we && !Ue)) {
+                  if (!we || !Ue) return this._firstMove === void 0 && (this._firstMove = de), de - this._firstMove < Gn ? void 0 : false;
+                  var ft = q.y > 0 == K.y > 0;
+                  return Xs(q) && Xs(K) && ft;
+                }
+              }, D;
+            }(ia), Fo = { panStep: 100, bearingStep: 15, pitchStep: 10 }, Uo = function() {
+              var D = Fo;
+              this._panStep = D.panStep, this._bearingStep = D.bearingStep, this._pitchStep = D.pitchStep, this._rotationDisabled = false;
+            };
+            Uo.prototype.reset = function() {
+              this._active = false;
+            }, Uo.prototype.keydown = function(D) {
+              var J = this;
+              if (!(D.altKey || D.ctrlKey || D.metaKey)) {
+                var q = 0, K = 0, de = 0, ne = 0, we = 0;
+                switch (D.keyCode) {
+                  case 61:
+                  case 107:
+                  case 171:
+                  case 187:
+                    q = 1;
+                    break;
+                  case 189:
+                  case 109:
+                  case 173:
+                    q = -1;
+                    break;
+                  case 37:
+                    D.shiftKey ? K = -1 : (D.preventDefault(), ne = -1);
+                    break;
+                  case 39:
+                    D.shiftKey ? K = 1 : (D.preventDefault(), ne = 1);
+                    break;
+                  case 38:
+                    D.shiftKey ? de = 1 : (D.preventDefault(), we = -1);
+                    break;
+                  case 40:
+                    D.shiftKey ? de = -1 : (D.preventDefault(), we = 1);
+                    break;
+                  default:
+                    return;
+                }
+                return this._rotationDisabled && (K = 0, de = 0), { cameraAnimation: function(Ue) {
+                  var ft = Ue.getZoom();
+                  Ue.easeTo({ duration: 300, easeId: "keyboardHandler", easing: $s, zoom: q ? Math.round(ft) + q * (D.shiftKey ? 2 : 1) : ft, bearing: Ue.getBearing() + K * J._bearingStep, pitch: Ue.getPitch() + de * J._pitchStep, offset: [-ne * J._panStep, -we * J._panStep], center: Ue.getCenter() }, { originalEvent: D });
+                } };
+              }
+            }, Uo.prototype.enable = function() {
+              this._enabled = true;
+            }, Uo.prototype.disable = function() {
+              this._enabled = false, this.reset();
+            }, Uo.prototype.isEnabled = function() {
+              return this._enabled;
+            }, Uo.prototype.isActive = function() {
+              return this._active;
+            }, Uo.prototype.disableRotation = function() {
+              this._rotationDisabled = true;
+            }, Uo.prototype.enableRotation = function() {
+              this._rotationDisabled = false;
+            };
+            function $s(Y) {
+              return Y * (2 - Y);
+            }
+            var Sl = 4.000244140625, bu = 1 / 100, dl = 1 / 450, Sc = 2, Me = function(D, J) {
+              this._map = D, this._el = D.getCanvasContainer(), this._handler = J, this._delta = 0, this._defaultZoomRate = bu, this._wheelZoomRate = dl, i.bindAll(["_onTimeout"], this);
+            };
+            Me.prototype.setZoomRate = function(D) {
+              this._defaultZoomRate = D;
+            }, Me.prototype.setWheelZoomRate = function(D) {
+              this._wheelZoomRate = D;
+            }, Me.prototype.isEnabled = function() {
+              return !!this._enabled;
+            }, Me.prototype.isActive = function() {
+              return !!this._active || this._finishTimeout !== void 0;
+            }, Me.prototype.isZooming = function() {
+              return !!this._zooming;
+            }, Me.prototype.enable = function(D) {
+              this.isEnabled() || (this._enabled = true, this._aroundCenter = D && D.around === "center");
+            }, Me.prototype.disable = function() {
+              this.isEnabled() && (this._enabled = false);
+            }, Me.prototype.wheel = function(D) {
+              if (this.isEnabled()) {
+                var J = D.deltaMode === i.window.WheelEvent.DOM_DELTA_LINE ? D.deltaY * 40 : D.deltaY, q = i.browser.now(), K = q - (this._lastWheelEventTime || 0);
+                this._lastWheelEventTime = q, J !== 0 && J % Sl === 0 ? this._type = "wheel" : J !== 0 && Math.abs(J) < 4 ? this._type = "trackpad" : K > 400 ? (this._type = null, this._lastValue = J, this._timeout = setTimeout(this._onTimeout, 40, D)) : this._type || (this._type = Math.abs(K * J) < 200 ? "trackpad" : "wheel", this._timeout && (clearTimeout(this._timeout), this._timeout = null, J += this._lastValue)), D.shiftKey && J && (J = J / 4), this._type && (this._lastWheelEvent = D, this._delta -= J, this._active || this._start(D)), D.preventDefault();
+              }
+            }, Me.prototype._onTimeout = function(D) {
+              this._type = "wheel", this._delta -= this._lastValue, this._active || this._start(D);
+            }, Me.prototype._start = function(D) {
+              if (this._delta) {
+                this._frameId && (this._frameId = null), this._active = true, this.isZooming() || (this._zooming = true), this._finishTimeout && (clearTimeout(this._finishTimeout), delete this._finishTimeout);
+                var J = o.mousePos(this._el, D);
+                this._around = i.LngLat.convert(this._aroundCenter ? this._map.getCenter() : this._map.unproject(J)), this._aroundPoint = this._map.transform.locationPoint(this._around), this._frameId || (this._frameId = true, this._handler._triggerRenderFrame());
+              }
+            }, Me.prototype.renderFrame = function() {
+              var D = this;
+              if (this._frameId && (this._frameId = null, !!this.isActive())) {
+                var J = this._map.transform;
+                if (this._delta !== 0) {
+                  var q = this._type === "wheel" && Math.abs(this._delta) > Sl ? this._wheelZoomRate : this._defaultZoomRate, K = Sc / (1 + Math.exp(-Math.abs(this._delta * q)));
+                  this._delta < 0 && K !== 0 && (K = 1 / K);
+                  var de = typeof this._targetZoom == "number" ? J.zoomScale(this._targetZoom) : J.scale;
+                  this._targetZoom = Math.min(J.maxZoom, Math.max(J.minZoom, J.scaleZoom(de * K))), this._type === "wheel" && (this._startZoom = J.zoom, this._easing = this._smoothOutEasing(200)), this._delta = 0;
+                }
+                var ne = typeof this._targetZoom == "number" ? this._targetZoom : J.zoom, we = this._startZoom, Ue = this._easing, ft = false, Zt;
+                if (this._type === "wheel" && we && Ue) {
+                  var hr = Math.min((i.browser.now() - this._lastWheelEventTime) / 200, 1), qt = Ue(hr);
+                  Zt = i.number(we, ne, qt), hr < 1 ? this._frameId || (this._frameId = true) : ft = true;
+                } else Zt = ne, ft = true;
+                return this._active = true, ft && (this._active = false, this._finishTimeout = setTimeout(function() {
+                  D._zooming = false, D._handler._triggerRenderFrame(), delete D._targetZoom, delete D._finishTimeout;
+                }, 200)), { noInertia: true, needsRenderFrame: !ft, zoomDelta: Zt - J.zoom, around: this._aroundPoint, originalEvent: this._lastWheelEvent };
+              }
+            }, Me.prototype._smoothOutEasing = function(D) {
+              var J = i.ease;
+              if (this._prevEase) {
+                var q = this._prevEase, K = (i.browser.now() - q.start) / q.duration, de = q.easing(K + 0.01) - q.easing(K), ne = 0.27 / Math.sqrt(de * de + 1e-4) * 0.01, we = Math.sqrt(0.27 * 0.27 - ne * ne);
+                J = i.bezier(ne, we, 0.25, 1);
+              }
+              return this._prevEase = { start: i.browser.now(), duration: D, easing: J }, J;
+            }, Me.prototype.reset = function() {
+              this._active = false;
+            };
+            var bt = function(D, J) {
+              this._clickZoom = D, this._tapZoom = J;
+            };
+            bt.prototype.enable = function() {
+              this._clickZoom.enable(), this._tapZoom.enable();
+            }, bt.prototype.disable = function() {
+              this._clickZoom.disable(), this._tapZoom.disable();
+            }, bt.prototype.isEnabled = function() {
+              return this._clickZoom.isEnabled() && this._tapZoom.isEnabled();
+            }, bt.prototype.isActive = function() {
+              return this._clickZoom.isActive() || this._tapZoom.isActive();
+            };
+            var zt = function() {
+              this.reset();
+            };
+            zt.prototype.reset = function() {
+              this._active = false;
+            }, zt.prototype.dblclick = function(D, J) {
+              return D.preventDefault(), { cameraAnimation: function(q) {
+                q.easeTo({ duration: 300, zoom: q.getZoom() + (D.shiftKey ? -1 : 1), around: q.unproject(J) }, { originalEvent: D });
+              } };
+            }, zt.prototype.enable = function() {
+              this._enabled = true;
+            }, zt.prototype.disable = function() {
+              this._enabled = false, this.reset();
+            }, zt.prototype.isEnabled = function() {
+              return this._enabled;
+            }, zt.prototype.isActive = function() {
+              return this._active;
+            };
+            var Rr = function() {
+              this._tap = new _i({ numTouches: 1, numTaps: 1 }), this.reset();
+            };
+            Rr.prototype.reset = function() {
+              this._active = false, delete this._swipePoint, delete this._swipeTouch, delete this._tapTime, this._tap.reset();
+            }, Rr.prototype.touchstart = function(D, J, q) {
+              this._swipePoint || (this._tapTime && D.timeStamp - this._tapTime > gr && this.reset(), this._tapTime ? q.length > 0 && (this._swipePoint = J[0], this._swipeTouch = q[0].identifier) : this._tap.touchstart(D, J, q));
+            }, Rr.prototype.touchmove = function(D, J, q) {
+              if (!this._tapTime) this._tap.touchmove(D, J, q);
+              else if (this._swipePoint) {
+                if (q[0].identifier !== this._swipeTouch) return;
+                var K = J[0], de = K.y - this._swipePoint.y;
+                return this._swipePoint = K, D.preventDefault(), this._active = true, { zoomDelta: de / 128 };
+              }
+            }, Rr.prototype.touchend = function(D, J, q) {
+              if (this._tapTime) this._swipePoint && q.length === 0 && this.reset();
+              else {
+                var K = this._tap.touchend(D, J, q);
+                K && (this._tapTime = D.timeStamp);
+              }
+            }, Rr.prototype.touchcancel = function() {
+              this.reset();
+            }, Rr.prototype.enable = function() {
+              this._enabled = true;
+            }, Rr.prototype.disable = function() {
+              this._enabled = false, this.reset();
+            }, Rr.prototype.isEnabled = function() {
+              return this._enabled;
+            }, Rr.prototype.isActive = function() {
+              return this._active;
+            };
+            var jr = function(D, J, q) {
+              this._el = D, this._mousePan = J, this._touchPan = q;
+            };
+            jr.prototype.enable = function(D) {
+              this._inertiaOptions = D || {}, this._mousePan.enable(), this._touchPan.enable(), this._el.classList.add("mapboxgl-touch-drag-pan");
+            }, jr.prototype.disable = function() {
+              this._mousePan.disable(), this._touchPan.disable(), this._el.classList.remove("mapboxgl-touch-drag-pan");
+            }, jr.prototype.isEnabled = function() {
+              return this._mousePan.isEnabled() && this._touchPan.isEnabled();
+            }, jr.prototype.isActive = function() {
+              return this._mousePan.isActive() || this._touchPan.isActive();
+            };
+            var Nr = function(D, J, q) {
+              this._pitchWithRotate = D.pitchWithRotate, this._mouseRotate = J, this._mousePitch = q;
+            };
+            Nr.prototype.enable = function() {
+              this._mouseRotate.enable(), this._pitchWithRotate && this._mousePitch.enable();
+            }, Nr.prototype.disable = function() {
+              this._mouseRotate.disable(), this._mousePitch.disable();
+            }, Nr.prototype.isEnabled = function() {
+              return this._mouseRotate.isEnabled() && (!this._pitchWithRotate || this._mousePitch.isEnabled());
+            }, Nr.prototype.isActive = function() {
+              return this._mouseRotate.isActive() || this._mousePitch.isActive();
+            };
+            var Gr = function(D, J, q, K) {
+              this._el = D, this._touchZoom = J, this._touchRotate = q, this._tapDragZoom = K, this._rotationDisabled = false, this._enabled = true;
+            };
+            Gr.prototype.enable = function(D) {
+              this._touchZoom.enable(D), this._rotationDisabled || this._touchRotate.enable(D), this._tapDragZoom.enable(), this._el.classList.add("mapboxgl-touch-zoom-rotate");
+            }, Gr.prototype.disable = function() {
+              this._touchZoom.disable(), this._touchRotate.disable(), this._tapDragZoom.disable(), this._el.classList.remove("mapboxgl-touch-zoom-rotate");
+            }, Gr.prototype.isEnabled = function() {
+              return this._touchZoom.isEnabled() && (this._rotationDisabled || this._touchRotate.isEnabled()) && this._tapDragZoom.isEnabled();
+            }, Gr.prototype.isActive = function() {
+              return this._touchZoom.isActive() || this._touchRotate.isActive() || this._tapDragZoom.isActive();
+            }, Gr.prototype.disableRotation = function() {
+              this._rotationDisabled = true, this._touchRotate.disable();
+            }, Gr.prototype.enableRotation = function() {
+              this._rotationDisabled = false, this._touchZoom.isEnabled() && this._touchRotate.enable();
+            };
+            var mi = function(Y) {
+              return Y.zoom || Y.drag || Y.pitch || Y.rotate;
+            }, Ui = function(Y) {
+              function D() {
+                Y.apply(this, arguments);
+              }
+              return Y && (D.__proto__ = Y), D.prototype = Object.create(Y && Y.prototype), D.prototype.constructor = D, D;
+            }(i.Event);
+            function qi(Y) {
+              return Y.panDelta && Y.panDelta.mag() || Y.zoomDelta || Y.bearingDelta || Y.pitchDelta;
+            }
+            var Ei = function(D, J) {
+              this._map = D, this._el = this._map.getCanvasContainer(), this._handlers = [], this._handlersById = {}, this._changes = [], this._inertia = new Tl(D), this._bearingSnap = J.bearingSnap, this._previousActiveHandlers = {}, this._eventsInProgress = {}, this._addDefaultHandlers(J), i.bindAll(["handleEvent", "handleWindowEvent"], this);
+              var q = this._el;
+              this._listeners = [[q, "touchstart", { passive: true }], [q, "touchmove", { passive: false }], [q, "touchend", void 0], [q, "touchcancel", void 0], [q, "mousedown", void 0], [q, "mousemove", void 0], [q, "mouseup", void 0], [i.window.document, "mousemove", { capture: true }], [i.window.document, "mouseup", void 0], [q, "mouseover", void 0], [q, "mouseout", void 0], [q, "dblclick", void 0], [q, "click", void 0], [q, "keydown", { capture: false }], [q, "keyup", void 0], [q, "wheel", { passive: false }], [q, "contextmenu", void 0], [i.window, "blur", void 0]];
+              for (var K = 0, de = this._listeners; K < de.length; K += 1) {
+                var ne = de[K], we = ne[0], Ue = ne[1], ft = ne[2];
+                o.addEventListener(we, Ue, we === i.window.document ? this.handleWindowEvent : this.handleEvent, ft);
+              }
+            };
+            Ei.prototype.destroy = function() {
+              for (var D = 0, J = this._listeners; D < J.length; D += 1) {
+                var q = J[D], K = q[0], de = q[1], ne = q[2];
+                o.removeEventListener(K, de, K === i.window.document ? this.handleWindowEvent : this.handleEvent, ne);
+              }
+            }, Ei.prototype._addDefaultHandlers = function(D) {
+              var J = this._map, q = J.getCanvasContainer();
+              this._add("mapEvent", new He(J, D));
+              var K = J.boxZoom = new kt(J, D);
+              this._add("boxZoom", K);
+              var de = new bi(), ne = new zt();
+              J.doubleClickZoom = new bt(ne, de), this._add("tapZoom", de), this._add("clickZoom", ne);
+              var we = new Rr();
+              this._add("tapDragZoom", we);
+              var Ue = J.touchPitch = new ja();
+              this._add("touchPitch", Ue);
+              var ft = new Ln(D), Zt = new En(D);
+              J.dragRotate = new Nr(D, ft, Zt), this._add("mouseRotate", ft, ["mousePitch"]), this._add("mousePitch", Zt, ["mouseRotate"]);
+              var hr = new ei(D), qt = new Un(D);
+              J.dragPan = new jr(q, hr, qt), this._add("mousePan", hr), this._add("touchPan", qt, ["touchZoom", "touchRotate"]);
+              var Ve = new Ms(), Qe = new Da();
+              J.touchZoomRotate = new Gr(q, Qe, Ve, we), this._add("touchRotate", Ve, ["touchPan", "touchZoom"]), this._add("touchZoom", Qe, ["touchPan", "touchRotate"]);
+              var at = J.scrollZoom = new Me(J, this);
+              this._add("scrollZoom", at, ["mousePan"]);
+              var Ct = J.keyboard = new Uo();
+              this._add("keyboard", Ct), this._add("blockableMapEvent", new Ye(J));
+              for (var Ot = 0, Rt = ["boxZoom", "doubleClickZoom", "tapDragZoom", "touchPitch", "dragRotate", "dragPan", "touchZoomRotate", "scrollZoom", "keyboard"]; Ot < Rt.length; Ot += 1) {
+                var Bt = Rt[Ot];
+                D.interactive && D[Bt] && J[Bt].enable(D[Bt]);
+              }
+            }, Ei.prototype._add = function(D, J, q) {
+              this._handlers.push({ handlerName: D, handler: J, allowed: q }), this._handlersById[D] = J;
+            }, Ei.prototype.stop = function(D) {
+              if (!this._updatingCamera) {
+                for (var J = 0, q = this._handlers; J < q.length; J += 1) {
+                  var K = q[J], de = K.handler;
+                  de.reset();
+                }
+                this._inertia.clear(), this._fireEvents({}, {}, D), this._changes = [];
+              }
+            }, Ei.prototype.isActive = function() {
+              for (var D = 0, J = this._handlers; D < J.length; D += 1) {
+                var q = J[D], K = q.handler;
+                if (K.isActive()) return true;
+              }
+              return false;
+            }, Ei.prototype.isZooming = function() {
+              return !!this._eventsInProgress.zoom || this._map.scrollZoom.isZooming();
+            }, Ei.prototype.isRotating = function() {
+              return !!this._eventsInProgress.rotate;
+            }, Ei.prototype.isMoving = function() {
+              return !!mi(this._eventsInProgress) || this.isZooming();
+            }, Ei.prototype._blockedByActive = function(D, J, q) {
+              for (var K in D) if (K !== q && (!J || J.indexOf(K) < 0)) return true;
+              return false;
+            }, Ei.prototype.handleWindowEvent = function(D) {
+              this.handleEvent(D, D.type + "Window");
+            }, Ei.prototype._getMapTouches = function(D) {
+              for (var J = [], q = 0, K = D; q < K.length; q += 1) {
+                var de = K[q], ne = de.target;
+                this._el.contains(ne) && J.push(de);
+              }
+              return J;
+            }, Ei.prototype.handleEvent = function(D, J) {
+              if (D.type === "blur") {
+                this.stop(true);
+                return;
+              }
+              this._updatingCamera = true;
+              for (var q = D.type === "renderFrame" ? void 0 : D, K = { needsRenderFrame: false }, de = {}, ne = {}, we = D.touches ? this._getMapTouches(D.touches) : void 0, Ue = we ? o.touchPos(this._el, we) : o.mousePos(this._el, D), ft = 0, Zt = this._handlers; ft < Zt.length; ft += 1) {
+                var hr = Zt[ft], qt = hr.handlerName, Ve = hr.handler, Qe = hr.allowed;
+                if (Ve.isEnabled()) {
+                  var at = void 0;
+                  this._blockedByActive(ne, Qe, qt) ? Ve.reset() : Ve[J || D.type] && (at = Ve[J || D.type](D, Ue, we), this.mergeHandlerResult(K, de, at, qt, q), at && at.needsRenderFrame && this._triggerRenderFrame()), (at || Ve.isActive()) && (ne[qt] = Ve);
+                }
+              }
+              var Ct = {};
+              for (var Ot in this._previousActiveHandlers) ne[Ot] || (Ct[Ot] = q);
+              this._previousActiveHandlers = ne, (Object.keys(Ct).length || qi(K)) && (this._changes.push([K, de, Ct]), this._triggerRenderFrame()), (Object.keys(ne).length || qi(K)) && this._map._stop(true), this._updatingCamera = false;
+              var Rt = K.cameraAnimation;
+              Rt && (this._inertia.clear(), this._fireEvents({}, {}, true), this._changes = [], Rt(this._map));
+            }, Ei.prototype.mergeHandlerResult = function(D, J, q, K, de) {
+              if (q) {
+                i.extend(D, q);
+                var ne = { handlerName: K, originalEvent: q.originalEvent || de };
+                q.zoomDelta !== void 0 && (J.zoom = ne), q.panDelta !== void 0 && (J.drag = ne), q.pitchDelta !== void 0 && (J.pitch = ne), q.bearingDelta !== void 0 && (J.rotate = ne);
+              }
+            }, Ei.prototype._applyChanges = function() {
+              for (var D = {}, J = {}, q = {}, K = 0, de = this._changes; K < de.length; K += 1) {
+                var ne = de[K], we = ne[0], Ue = ne[1], ft = ne[2];
+                we.panDelta && (D.panDelta = (D.panDelta || new i.Point(0, 0))._add(we.panDelta)), we.zoomDelta && (D.zoomDelta = (D.zoomDelta || 0) + we.zoomDelta), we.bearingDelta && (D.bearingDelta = (D.bearingDelta || 0) + we.bearingDelta), we.pitchDelta && (D.pitchDelta = (D.pitchDelta || 0) + we.pitchDelta), we.around !== void 0 && (D.around = we.around), we.pinchAround !== void 0 && (D.pinchAround = we.pinchAround), we.noInertia && (D.noInertia = we.noInertia), i.extend(J, Ue), i.extend(q, ft);
+              }
+              this._updateMapTransform(D, J, q), this._changes = [];
+            }, Ei.prototype._updateMapTransform = function(D, J, q) {
+              var K = this._map, de = K.transform;
+              if (!qi(D)) return this._fireEvents(J, q, true);
+              var ne = D.panDelta, we = D.zoomDelta, Ue = D.bearingDelta, ft = D.pitchDelta, Zt = D.around, hr = D.pinchAround;
+              hr !== void 0 && (Zt = hr), K._stop(true), Zt = Zt || K.transform.centerPoint;
+              var qt = de.pointLocation(ne ? Zt.sub(ne) : Zt);
+              Ue && (de.bearing += Ue), ft && (de.pitch += ft), we && (de.zoom += we), de.setLocationAtPoint(qt, Zt), this._map._update(), D.noInertia || this._inertia.record(D), this._fireEvents(J, q, true);
+            }, Ei.prototype._fireEvents = function(D, J, q) {
+              var K = this, de = mi(this._eventsInProgress), ne = mi(D), we = {};
+              for (var Ue in D) {
+                var ft = D[Ue], Zt = ft.originalEvent;
+                this._eventsInProgress[Ue] || (we[Ue + "start"] = Zt), this._eventsInProgress[Ue] = D[Ue];
+              }
+              !de && ne && this._fireEvent("movestart", ne.originalEvent);
+              for (var hr in we) this._fireEvent(hr, we[hr]);
+              ne && this._fireEvent("move", ne.originalEvent);
+              for (var qt in D) {
+                var Ve = D[qt], Qe = Ve.originalEvent;
+                this._fireEvent(qt, Qe);
+              }
+              var at = {}, Ct;
+              for (var Ot in this._eventsInProgress) {
+                var Rt = this._eventsInProgress[Ot], Bt = Rt.handlerName, Dt = Rt.originalEvent;
+                this._handlersById[Bt].isActive() || (delete this._eventsInProgress[Ot], Ct = J[Bt] || Dt, at[Ot + "end"] = Ct);
+              }
+              for (var yt in at) this._fireEvent(yt, at[yt]);
+              var Pt = mi(this._eventsInProgress);
+              if (q && (de || ne) && !Pt) {
+                this._updatingCamera = true;
+                var ht = this._inertia._onMoveEnd(this._map.dragPan._inertiaOptions), ur = function(br) {
+                  return br !== 0 && -K._bearingSnap < br && br < K._bearingSnap;
+                };
+                ht ? (ur(ht.bearing || this._map.getBearing()) && (ht.bearing = 0), this._map.easeTo(ht, { originalEvent: Ct })) : (this._map.fire(new i.Event("moveend", { originalEvent: Ct })), ur(this._map.getBearing()) && this._map.resetNorth()), this._updatingCamera = false;
+              }
+            }, Ei.prototype._fireEvent = function(D, J) {
+              this._map.fire(new i.Event(D, J ? { originalEvent: J } : {}));
+            }, Ei.prototype._requestFrame = function() {
+              var D = this;
+              return this._map.triggerRepaint(), this._map._renderTaskQueue.add(function(J) {
+                delete D._frameId, D.handleEvent(new Ui("renderFrame", { timeStamp: J })), D._applyChanges();
+              });
+            }, Ei.prototype._triggerRenderFrame = function() {
+              this._frameId === void 0 && (this._frameId = this._requestFrame());
+            };
+            var Hn = function(Y) {
+              function D(J, q) {
+                Y.call(this), this._moving = false, this._zooming = false, this.transform = J, this._bearingSnap = q.bearingSnap, i.bindAll(["_renderFrameCallback"], this);
+              }
+              return Y && (D.__proto__ = Y), D.prototype = Object.create(Y && Y.prototype), D.prototype.constructor = D, D.prototype.getCenter = function() {
+                return new i.LngLat(this.transform.center.lng, this.transform.center.lat);
+              }, D.prototype.setCenter = function(q, K) {
+                return this.jumpTo({ center: q }, K);
+              }, D.prototype.panBy = function(q, K, de) {
+                return q = i.Point.convert(q).mult(-1), this.panTo(this.transform.center, i.extend({ offset: q }, K), de);
+              }, D.prototype.panTo = function(q, K, de) {
+                return this.easeTo(i.extend({ center: q }, K), de);
+              }, D.prototype.getZoom = function() {
+                return this.transform.zoom;
+              }, D.prototype.setZoom = function(q, K) {
+                return this.jumpTo({ zoom: q }, K), this;
+              }, D.prototype.zoomTo = function(q, K, de) {
+                return this.easeTo(i.extend({ zoom: q }, K), de);
+              }, D.prototype.zoomIn = function(q, K) {
+                return this.zoomTo(this.getZoom() + 1, q, K), this;
+              }, D.prototype.zoomOut = function(q, K) {
+                return this.zoomTo(this.getZoom() - 1, q, K), this;
+              }, D.prototype.getBearing = function() {
+                return this.transform.bearing;
+              }, D.prototype.setBearing = function(q, K) {
+                return this.jumpTo({ bearing: q }, K), this;
+              }, D.prototype.getPadding = function() {
+                return this.transform.padding;
+              }, D.prototype.setPadding = function(q, K) {
+                return this.jumpTo({ padding: q }, K), this;
+              }, D.prototype.rotateTo = function(q, K, de) {
+                return this.easeTo(i.extend({ bearing: q }, K), de);
+              }, D.prototype.resetNorth = function(q, K) {
+                return this.rotateTo(0, i.extend({ duration: 1e3 }, q), K), this;
+              }, D.prototype.resetNorthPitch = function(q, K) {
+                return this.easeTo(i.extend({ bearing: 0, pitch: 0, duration: 1e3 }, q), K), this;
+              }, D.prototype.snapToNorth = function(q, K) {
+                return Math.abs(this.getBearing()) < this._bearingSnap ? this.resetNorth(q, K) : this;
+              }, D.prototype.getPitch = function() {
+                return this.transform.pitch;
+              }, D.prototype.setPitch = function(q, K) {
+                return this.jumpTo({ pitch: q }, K), this;
+              }, D.prototype.cameraForBounds = function(q, K) {
+                q = i.LngLatBounds.convert(q);
+                var de = K && K.bearing || 0;
+                return this._cameraForBoxAndBearing(q.getNorthWest(), q.getSouthEast(), de, K);
+              }, D.prototype._cameraForBoxAndBearing = function(q, K, de, ne) {
+                var we = { top: 0, bottom: 0, right: 0, left: 0 };
+                if (ne = i.extend({ padding: we, offset: [0, 0], maxZoom: this.transform.maxZoom }, ne), typeof ne.padding == "number") {
+                  var Ue = ne.padding;
+                  ne.padding = { top: Ue, bottom: Ue, right: Ue, left: Ue };
+                }
+                ne.padding = i.extend(we, ne.padding);
+                var ft = this.transform, Zt = ft.padding, hr = ft.project(i.LngLat.convert(q)), qt = ft.project(i.LngLat.convert(K)), Ve = hr.rotate(-de * Math.PI / 180), Qe = qt.rotate(-de * Math.PI / 180), at = new i.Point(Math.max(Ve.x, Qe.x), Math.max(Ve.y, Qe.y)), Ct = new i.Point(Math.min(Ve.x, Qe.x), Math.min(Ve.y, Qe.y)), Ot = at.sub(Ct), Rt = (ft.width - (Zt.left + Zt.right + ne.padding.left + ne.padding.right)) / Ot.x, Bt = (ft.height - (Zt.top + Zt.bottom + ne.padding.top + ne.padding.bottom)) / Ot.y;
+                if (Bt < 0 || Rt < 0) {
+                  i.warnOnce("Map cannot fit within canvas with the given bounds, padding, and/or offset.");
+                  return;
+                }
+                var Dt = Math.min(ft.scaleZoom(ft.scale * Math.min(Rt, Bt)), ne.maxZoom), yt = typeof ne.offset.x == "number" ? new i.Point(ne.offset.x, ne.offset.y) : i.Point.convert(ne.offset), Pt = (ne.padding.left - ne.padding.right) / 2, ht = (ne.padding.top - ne.padding.bottom) / 2, ur = new i.Point(Pt, ht), br = ur.rotate(de * Math.PI / 180), Ur = yt.add(br), Di = Ur.mult(ft.scale / ft.zoomScale(Dt)), fi = ft.unproject(hr.add(qt).div(2).sub(Di));
+                return { center: fi, zoom: Dt, bearing: de };
+              }, D.prototype.fitBounds = function(q, K, de) {
+                return this._fitInternal(this.cameraForBounds(q, K), K, de);
+              }, D.prototype.fitScreenCoordinates = function(q, K, de, ne, we) {
+                return this._fitInternal(this._cameraForBoxAndBearing(this.transform.pointLocation(i.Point.convert(q)), this.transform.pointLocation(i.Point.convert(K)), de, ne), ne, we);
+              }, D.prototype._fitInternal = function(q, K, de) {
+                return q ? (K = i.extend(q, K), delete K.padding, K.linear ? this.easeTo(K, de) : this.flyTo(K, de)) : this;
+              }, D.prototype.jumpTo = function(q, K) {
+                this.stop();
+                var de = this.transform, ne = false, we = false, Ue = false;
+                return "zoom" in q && de.zoom !== +q.zoom && (ne = true, de.zoom = +q.zoom), q.center !== void 0 && (de.center = i.LngLat.convert(q.center)), "bearing" in q && de.bearing !== +q.bearing && (we = true, de.bearing = +q.bearing), "pitch" in q && de.pitch !== +q.pitch && (Ue = true, de.pitch = +q.pitch), q.padding != null && !de.isPaddingEqual(q.padding) && (de.padding = q.padding), this.fire(new i.Event("movestart", K)).fire(new i.Event("move", K)), ne && this.fire(new i.Event("zoomstart", K)).fire(new i.Event("zoom", K)).fire(new i.Event("zoomend", K)), we && this.fire(new i.Event("rotatestart", K)).fire(new i.Event("rotate", K)).fire(new i.Event("rotateend", K)), Ue && this.fire(new i.Event("pitchstart", K)).fire(new i.Event("pitch", K)).fire(new i.Event("pitchend", K)), this.fire(new i.Event("moveend", K));
+              }, D.prototype.easeTo = function(q, K) {
+                var de = this;
+                this._stop(false, q.easeId), q = i.extend({ offset: [0, 0], duration: 500, easing: i.ease }, q), (q.animate === false || !q.essential && i.browser.prefersReducedMotion) && (q.duration = 0);
+                var ne = this.transform, we = this.getZoom(), Ue = this.getBearing(), ft = this.getPitch(), Zt = this.getPadding(), hr = "zoom" in q ? +q.zoom : we, qt = "bearing" in q ? this._normalizeBearing(q.bearing, Ue) : Ue, Ve = "pitch" in q ? +q.pitch : ft, Qe = "padding" in q ? q.padding : ne.padding, at = i.Point.convert(q.offset), Ct = ne.centerPoint.add(at), Ot = ne.pointLocation(Ct), Rt = i.LngLat.convert(q.center || Ot);
+                this._normalizeCenter(Rt);
+                var Bt = ne.project(Ot), Dt = ne.project(Rt).sub(Bt), yt = ne.zoomScale(hr - we), Pt, ht;
+                q.around && (Pt = i.LngLat.convert(q.around), ht = ne.locationPoint(Pt));
+                var ur = { moving: this._moving, zooming: this._zooming, rotating: this._rotating, pitching: this._pitching };
+                return this._zooming = this._zooming || hr !== we, this._rotating = this._rotating || Ue !== qt, this._pitching = this._pitching || Ve !== ft, this._padding = !ne.isPaddingEqual(Qe), this._easeId = q.easeId, this._prepareEase(K, q.noMoveStart, ur), this._ease(function(br) {
+                  if (de._zooming && (ne.zoom = i.number(we, hr, br)), de._rotating && (ne.bearing = i.number(Ue, qt, br)), de._pitching && (ne.pitch = i.number(ft, Ve, br)), de._padding && (ne.interpolatePadding(Zt, Qe, br), Ct = ne.centerPoint.add(at)), Pt) ne.setLocationAtPoint(Pt, ht);
+                  else {
+                    var Ur = ne.zoomScale(ne.zoom - we), Di = hr > we ? Math.min(2, yt) : Math.max(0.5, yt), fi = Math.pow(Di, 1 - br), Ti = ne.unproject(Bt.add(Dt.mult(br * fi)).mult(Ur));
+                    ne.setLocationAtPoint(ne.renderWorldCopies ? Ti.wrap() : Ti, Ct);
+                  }
+                  de._fireMoveEvents(K);
+                }, function(br) {
+                  de._afterEase(K, br);
+                }, q), this;
+              }, D.prototype._prepareEase = function(q, K, de) {
+                de === void 0 && (de = {}), this._moving = true, !K && !de.moving && this.fire(new i.Event("movestart", q)), this._zooming && !de.zooming && this.fire(new i.Event("zoomstart", q)), this._rotating && !de.rotating && this.fire(new i.Event("rotatestart", q)), this._pitching && !de.pitching && this.fire(new i.Event("pitchstart", q));
+              }, D.prototype._fireMoveEvents = function(q) {
+                this.fire(new i.Event("move", q)), this._zooming && this.fire(new i.Event("zoom", q)), this._rotating && this.fire(new i.Event("rotate", q)), this._pitching && this.fire(new i.Event("pitch", q));
+              }, D.prototype._afterEase = function(q, K) {
+                if (!(this._easeId && K && this._easeId === K)) {
+                  delete this._easeId;
+                  var de = this._zooming, ne = this._rotating, we = this._pitching;
+                  this._moving = false, this._zooming = false, this._rotating = false, this._pitching = false, this._padding = false, de && this.fire(new i.Event("zoomend", q)), ne && this.fire(new i.Event("rotateend", q)), we && this.fire(new i.Event("pitchend", q)), this.fire(new i.Event("moveend", q));
+                }
+              }, D.prototype.flyTo = function(q, K) {
+                var de = this;
+                if (!q.essential && i.browser.prefersReducedMotion) {
+                  var ne = i.pick(q, ["center", "zoom", "bearing", "pitch", "around"]);
+                  return this.jumpTo(ne, K);
+                }
+                this.stop(), q = i.extend({ offset: [0, 0], speed: 1.2, curve: 1.42, easing: i.ease }, q);
+                var we = this.transform, Ue = this.getZoom(), ft = this.getBearing(), Zt = this.getPitch(), hr = this.getPadding(), qt = "zoom" in q ? i.clamp(+q.zoom, we.minZoom, we.maxZoom) : Ue, Ve = "bearing" in q ? this._normalizeBearing(q.bearing, ft) : ft, Qe = "pitch" in q ? +q.pitch : Zt, at = "padding" in q ? q.padding : we.padding, Ct = we.zoomScale(qt - Ue), Ot = i.Point.convert(q.offset), Rt = we.centerPoint.add(Ot), Bt = we.pointLocation(Rt), Dt = i.LngLat.convert(q.center || Bt);
+                this._normalizeCenter(Dt);
+                var yt = we.project(Bt), Pt = we.project(Dt).sub(yt), ht = q.curve, ur = Math.max(we.width, we.height), br = ur / Ct, Ur = Pt.mag();
+                if ("minZoom" in q) {
+                  var Di = i.clamp(Math.min(q.minZoom, Ue, qt), we.minZoom, we.maxZoom), fi = ur / we.zoomScale(Di - Ue);
+                  ht = Math.sqrt(fi / Ur * 2);
+                }
+                var Ti = ht * ht;
+                function gn(so) {
+                  var Yo = (br * br - ur * ur + (so ? -1 : 1) * Ti * Ti * Ur * Ur) / (2 * (so ? br : ur) * Ti * Ur);
+                  return Math.log(Math.sqrt(Yo * Yo + 1) - Yo);
+                }
+                function rn(so) {
+                  return (Math.exp(so) - Math.exp(-so)) / 2;
+                }
+                function Ci(so) {
+                  return (Math.exp(so) + Math.exp(-so)) / 2;
+                }
+                function Bi(so) {
+                  return rn(so) / Ci(so);
+                }
+                var Gi = gn(0), sn = function(so) {
+                  return Ci(Gi) / Ci(Gi + ht * so);
+                }, zn = function(so) {
+                  return ur * ((Ci(Gi) * Bi(Gi + ht * so) - rn(Gi)) / Ti) / Ur;
+                }, Ja = (gn(1) - Gi) / ht;
+                if (Math.abs(Ur) < 1e-6 || !isFinite(Ja)) {
+                  if (Math.abs(ur - br) < 1e-6) return this.easeTo(q, K);
+                  var co = br < ur ? -1 : 1;
+                  Ja = Math.abs(Math.log(br / ur)) / ht, zn = function() {
+                    return 0;
+                  }, sn = function(so) {
+                    return Math.exp(co * ht * so);
+                  };
+                }
+                if ("duration" in q) q.duration = +q.duration;
+                else {
+                  var ts = "screenSpeed" in q ? +q.screenSpeed / ht : +q.speed;
+                  q.duration = 1e3 * Ja / ts;
+                }
+                return q.maxDuration && q.duration > q.maxDuration && (q.duration = 0), this._zooming = true, this._rotating = ft !== Ve, this._pitching = Qe !== Zt, this._padding = !we.isPaddingEqual(at), this._prepareEase(K, false), this._ease(function(so) {
+                  var Yo = so * Ja, ms = 1 / sn(Yo);
+                  we.zoom = so === 1 ? qt : Ue + we.scaleZoom(ms), de._rotating && (we.bearing = i.number(ft, Ve, so)), de._pitching && (we.pitch = i.number(Zt, Qe, so)), de._padding && (we.interpolatePadding(hr, at, so), Rt = we.centerPoint.add(Ot));
+                  var ou = so === 1 ? Dt : we.unproject(yt.add(Pt.mult(zn(Yo))).mult(ms));
+                  we.setLocationAtPoint(we.renderWorldCopies ? ou.wrap() : ou, Rt), de._fireMoveEvents(K);
+                }, function() {
+                  return de._afterEase(K);
+                }, q), this;
+              }, D.prototype.isEasing = function() {
+                return !!this._easeFrameId;
+              }, D.prototype.stop = function() {
+                return this._stop();
+              }, D.prototype._stop = function(q, K) {
+                if (this._easeFrameId && (this._cancelRenderFrame(this._easeFrameId), delete this._easeFrameId, delete this._onEaseFrame), this._onEaseEnd) {
+                  var de = this._onEaseEnd;
+                  delete this._onEaseEnd, de.call(this, K);
+                }
+                if (!q) {
+                  var ne = this.handlers;
+                  ne && ne.stop(false);
+                }
+                return this;
+              }, D.prototype._ease = function(q, K, de) {
+                de.animate === false || de.duration === 0 ? (q(1), K()) : (this._easeStart = i.browser.now(), this._easeOptions = de, this._onEaseFrame = q, this._onEaseEnd = K, this._easeFrameId = this._requestRenderFrame(this._renderFrameCallback));
+              }, D.prototype._renderFrameCallback = function() {
+                var q = Math.min((i.browser.now() - this._easeStart) / this._easeOptions.duration, 1);
+                this._onEaseFrame(this._easeOptions.easing(q)), q < 1 ? this._easeFrameId = this._requestRenderFrame(this._renderFrameCallback) : this.stop();
+              }, D.prototype._normalizeBearing = function(q, K) {
+                q = i.wrap(q, -180, 180);
+                var de = Math.abs(q - K);
+                return Math.abs(q - 360 - K) < de && (q -= 360), Math.abs(q + 360 - K) < de && (q += 360), q;
+              }, D.prototype._normalizeCenter = function(q) {
+                var K = this.transform;
+                if (!(!K.renderWorldCopies || K.lngRange)) {
+                  var de = q.lng - K.center.lng;
+                  q.lng += de > 180 ? -360 : de < -180 ? 360 : 0;
+                }
+              }, D;
+            }(i.Evented), en = function(D) {
+              D === void 0 && (D = {}), this.options = D, i.bindAll(["_toggleAttribution", "_updateEditLink", "_updateData", "_updateCompact"], this);
+            };
+            en.prototype.getDefaultPosition = function() {
+              return "bottom-right";
+            }, en.prototype.onAdd = function(D) {
+              var J = this.options && this.options.compact;
+              return this._map = D, this._container = o.create("div", "mapboxgl-ctrl mapboxgl-ctrl-attrib"), this._compactButton = o.create("button", "mapboxgl-ctrl-attrib-button", this._container), this._compactButton.addEventListener("click", this._toggleAttribution), this._setElementTitle(this._compactButton, "ToggleAttribution"), this._innerContainer = o.create("div", "mapboxgl-ctrl-attrib-inner", this._container), this._innerContainer.setAttribute("role", "list"), J && this._container.classList.add("mapboxgl-compact"), this._updateAttributions(), this._updateEditLink(), this._map.on("styledata", this._updateData), this._map.on("sourcedata", this._updateData), this._map.on("moveend", this._updateEditLink), J === void 0 && (this._map.on("resize", this._updateCompact), this._updateCompact()), this._container;
+            }, en.prototype.onRemove = function() {
+              o.remove(this._container), this._map.off("styledata", this._updateData), this._map.off("sourcedata", this._updateData), this._map.off("moveend", this._updateEditLink), this._map.off("resize", this._updateCompact), this._map = void 0, this._attribHTML = void 0;
+            }, en.prototype._setElementTitle = function(D, J) {
+              var q = this._map._getUIString("AttributionControl." + J);
+              D.title = q, D.setAttribute("aria-label", q);
+            }, en.prototype._toggleAttribution = function() {
+              this._container.classList.contains("mapboxgl-compact-show") ? (this._container.classList.remove("mapboxgl-compact-show"), this._compactButton.setAttribute("aria-pressed", "false")) : (this._container.classList.add("mapboxgl-compact-show"), this._compactButton.setAttribute("aria-pressed", "true"));
+            }, en.prototype._updateEditLink = function() {
+              var D = this._editLink;
+              D || (D = this._editLink = this._container.querySelector(".mapbox-improve-map"));
+              var J = [{ key: "owner", value: this.styleOwner }, { key: "id", value: this.styleId }, { key: "access_token", value: this._map._requestManager._customAccessToken || i.config.ACCESS_TOKEN }];
+              if (D) {
+                var q = J.reduce(function(K, de, ne) {
+                  return de.value && (K += de.key + "=" + de.value + (ne < J.length - 1 ? "&" : "")), K;
+                }, "?");
+                D.href = i.config.FEEDBACK_URL + "/" + q + (this._map._hash ? this._map._hash.getHashString(true) : ""), D.rel = "noopener nofollow", this._setElementTitle(D, "MapFeedback");
+              }
+            }, en.prototype._updateData = function(D) {
+              D && (D.sourceDataType === "metadata" || D.sourceDataType === "visibility" || D.dataType === "style") && (this._updateAttributions(), this._updateEditLink());
+            }, en.prototype._updateAttributions = function() {
+              if (this._map.style) {
+                var D = [];
+                if (this.options.customAttribution && (Array.isArray(this.options.customAttribution) ? D = D.concat(this.options.customAttribution.map(function(Ue) {
+                  return typeof Ue != "string" ? "" : Ue;
+                })) : typeof this.options.customAttribution == "string" && D.push(this.options.customAttribution)), this._map.style.stylesheet) {
+                  var J = this._map.style.stylesheet;
+                  this.styleOwner = J.owner, this.styleId = J.id;
+                }
+                var q = this._map.style.sourceCaches;
+                for (var K in q) {
+                  var de = q[K];
+                  if (de.used) {
+                    var ne = de.getSource();
+                    ne.attribution && D.indexOf(ne.attribution) < 0 && D.push(ne.attribution);
+                  }
+                }
+                D.sort(function(Ue, ft) {
+                  return Ue.length - ft.length;
+                }), D = D.filter(function(Ue, ft) {
+                  for (var Zt = ft + 1; Zt < D.length; Zt++) if (D[Zt].indexOf(Ue) >= 0) return false;
+                  return true;
+                });
+                var we = D.join(" | ");
+                we !== this._attribHTML && (this._attribHTML = we, D.length ? (this._innerContainer.innerHTML = we, this._container.classList.remove("mapboxgl-attrib-empty")) : this._container.classList.add("mapboxgl-attrib-empty"), this._editLink = null);
+              }
+            }, en.prototype._updateCompact = function() {
+              this._map.getCanvasContainer().offsetWidth <= 640 ? this._container.classList.add("mapboxgl-compact") : this._container.classList.remove("mapboxgl-compact", "mapboxgl-compact-show");
+            };
+            var Wi = function() {
+              i.bindAll(["_updateLogo"], this), i.bindAll(["_updateCompact"], this);
+            };
+            Wi.prototype.onAdd = function(D) {
+              this._map = D, this._container = o.create("div", "mapboxgl-ctrl");
+              var J = o.create("a", "mapboxgl-ctrl-logo");
+              return J.target = "_blank", J.rel = "noopener nofollow", J.href = "https://www.mapbox.com/", J.setAttribute("aria-label", this._map._getUIString("LogoControl.Title")), J.setAttribute("rel", "noopener nofollow"), this._container.appendChild(J), this._container.style.display = "none", this._map.on("sourcedata", this._updateLogo), this._updateLogo(), this._map.on("resize", this._updateCompact), this._updateCompact(), this._container;
+            }, Wi.prototype.onRemove = function() {
+              o.remove(this._container), this._map.off("sourcedata", this._updateLogo), this._map.off("resize", this._updateCompact);
+            }, Wi.prototype.getDefaultPosition = function() {
+              return "bottom-left";
+            }, Wi.prototype._updateLogo = function(D) {
+              (!D || D.sourceDataType === "metadata") && (this._container.style.display = this._logoRequired() ? "block" : "none");
+            }, Wi.prototype._logoRequired = function() {
+              if (this._map.style) {
+                var D = this._map.style.sourceCaches;
+                for (var J in D) {
+                  var q = D[J].getSource();
+                  if (q.mapbox_logo) return true;
+                }
+                return false;
+              }
+            }, Wi.prototype._updateCompact = function() {
+              var D = this._container.children;
+              if (D.length) {
+                var J = D[0];
+                this._map.getCanvasContainer().offsetWidth < 250 ? J.classList.add("mapboxgl-compact") : J.classList.remove("mapboxgl-compact");
+              }
+            };
+            var si = function() {
+              this._queue = [], this._id = 0, this._cleared = false, this._currentlyRunning = false;
+            };
+            si.prototype.add = function(D) {
+              var J = ++this._id, q = this._queue;
+              return q.push({ callback: D, id: J, cancelled: false }), J;
+            }, si.prototype.remove = function(D) {
+              for (var J = this._currentlyRunning, q = J ? this._queue.concat(J) : this._queue, K = 0, de = q; K < de.length; K += 1) {
+                var ne = de[K];
+                if (ne.id === D) {
+                  ne.cancelled = true;
+                  return;
+                }
+              }
+            }, si.prototype.run = function(D) {
+              D === void 0 && (D = 0);
+              var J = this._currentlyRunning = this._queue;
+              this._queue = [];
+              for (var q = 0, K = J; q < K.length; q += 1) {
+                var de = K[q];
+                if (!de.cancelled && (de.callback(D), this._cleared)) break;
+              }
+              this._cleared = false, this._currentlyRunning = false;
+            }, si.prototype.clear = function() {
+              this._currentlyRunning && (this._cleared = true), this._queue = [];
+            };
+            var Mr = { "AttributionControl.ToggleAttribution": "Toggle attribution", "AttributionControl.MapFeedback": "Map feedback", "FullscreenControl.Enter": "Enter fullscreen", "FullscreenControl.Exit": "Exit fullscreen", "GeolocateControl.FindMyLocation": "Find my location", "GeolocateControl.LocationNotAvailable": "Location not available", "LogoControl.Title": "Mapbox logo", "NavigationControl.ResetBearing": "Reset bearing to north", "NavigationControl.ZoomIn": "Zoom in", "NavigationControl.ZoomOut": "Zoom out", "ScaleControl.Feet": "ft", "ScaleControl.Meters": "m", "ScaleControl.Kilometers": "km", "ScaleControl.Miles": "mi", "ScaleControl.NauticalMiles": "nm" }, Yr = i.window.HTMLImageElement, xi = i.window.HTMLElement, Ri = i.window.ImageBitmap, ci = -2, an = 22, Zi = 0, Bn = 60, hi = { center: [0, 0], zoom: 0, bearing: 0, pitch: 0, minZoom: ci, maxZoom: an, minPitch: Zi, maxPitch: Bn, interactive: true, scrollZoom: true, boxZoom: true, dragRotate: true, dragPan: true, keyboard: true, doubleClickZoom: true, touchZoomRotate: true, touchPitch: true, bearingSnap: 7, clickTolerance: 3, pitchWithRotate: true, hash: false, attributionControl: true, failIfMajorPerformanceCaveat: false, preserveDrawingBuffer: false, trackResize: true, renderWorldCopies: true, refreshExpiredTiles: true, maxTileCacheSize: null, localIdeographFontFamily: "sans-serif", transformRequest: null, accessToken: null, fadeDuration: 300, crossSourceCollisions: true }, li = function(Y) {
+              function D(q) {
+                var K = this;
+                if (q = i.extend({}, hi, q), q.minZoom != null && q.maxZoom != null && q.minZoom > q.maxZoom) throw new Error("maxZoom must be greater than or equal to minZoom");
+                if (q.minPitch != null && q.maxPitch != null && q.minPitch > q.maxPitch) throw new Error("maxPitch must be greater than or equal to minPitch");
+                if (q.minPitch != null && q.minPitch < Zi) throw new Error("minPitch must be greater than or equal to " + Zi);
+                if (q.maxPitch != null && q.maxPitch > Bn) throw new Error("maxPitch must be less than or equal to " + Bn);
+                var de = new wo(q.minZoom, q.maxZoom, q.minPitch, q.maxPitch, q.renderWorldCopies);
+                if (Y.call(this, de, q), this._interactive = q.interactive, this._maxTileCacheSize = q.maxTileCacheSize, this._failIfMajorPerformanceCaveat = q.failIfMajorPerformanceCaveat, this._preserveDrawingBuffer = q.preserveDrawingBuffer, this._antialias = q.antialias, this._trackResize = q.trackResize, this._bearingSnap = q.bearingSnap, this._refreshExpiredTiles = q.refreshExpiredTiles, this._fadeDuration = q.fadeDuration, this._crossSourceCollisions = q.crossSourceCollisions, this._crossFadingFactor = 1, this._collectResourceTiming = q.collectResourceTiming, this._renderTaskQueue = new si(), this._controls = [], this._mapId = i.uniqueId(), this._locale = i.extend({}, Mr, q.locale), this._clickTolerance = q.clickTolerance, this._requestManager = new i.RequestManager(q.transformRequest, q.accessToken), typeof q.container == "string") {
+                  if (this._container = i.window.document.getElementById(q.container), !this._container) throw new Error("Container '" + q.container + "' not found.");
+                } else if (q.container instanceof xi) this._container = q.container;
+                else throw new Error("Invalid type: 'container' must be a String or HTMLElement.");
+                if (q.maxBounds && this.setMaxBounds(q.maxBounds), i.bindAll(["_onWindowOnline", "_onWindowResize", "_onMapScroll", "_contextLost", "_contextRestored"], this), this._setupContainer(), this._setupPainter(), this.painter === void 0) throw new Error("Failed to initialize WebGL.");
+                this.on("move", function() {
+                  return K._update(false);
+                }), this.on("moveend", function() {
+                  return K._update(false);
+                }), this.on("zoom", function() {
+                  return K._update(true);
+                }), typeof i.window != "undefined" && (i.window.addEventListener("online", this._onWindowOnline, false), i.window.addEventListener("resize", this._onWindowResize, false), i.window.addEventListener("orientationchange", this._onWindowResize, false)), this.handlers = new Ei(this, q);
+                var ne = typeof q.hash == "string" && q.hash || void 0;
+                this._hash = q.hash && new Ul(ne).addTo(this), (!this._hash || !this._hash._onHashChange()) && (this.jumpTo({ center: q.center, zoom: q.zoom, bearing: q.bearing, pitch: q.pitch }), q.bounds && (this.resize(), this.fitBounds(q.bounds, i.extend({}, q.fitBoundsOptions, { duration: 0 })))), this.resize(), this._localIdeographFontFamily = q.localIdeographFontFamily, q.style && this.setStyle(q.style, { localIdeographFontFamily: q.localIdeographFontFamily }), q.attributionControl && this.addControl(new en({ customAttribution: q.customAttribution })), this.addControl(new Wi(), q.logoPosition), this.on("style.load", function() {
+                  K.transform.unmodified && K.jumpTo(K.style.stylesheet);
+                }), this.on("data", function(we) {
+                  K._update(we.dataType === "style"), K.fire(new i.Event(we.dataType + "data", we));
+                }), this.on("dataloading", function(we) {
+                  K.fire(new i.Event(we.dataType + "dataloading", we));
+                });
+              }
+              Y && (D.__proto__ = Y), D.prototype = Object.create(Y && Y.prototype), D.prototype.constructor = D;
+              var J = { showTileBoundaries: { configurable: true }, showPadding: { configurable: true }, showCollisionBoxes: { configurable: true }, showOverdrawInspector: { configurable: true }, repaint: { configurable: true }, vertices: { configurable: true }, version: { configurable: true } };
+              return D.prototype._getMapId = function() {
+                return this._mapId;
+              }, D.prototype.addControl = function(K, de) {
+                if (de === void 0 && (K.getDefaultPosition ? de = K.getDefaultPosition() : de = "top-right"), !K || !K.onAdd) return this.fire(new i.ErrorEvent(new Error("Invalid argument to map.addControl(). Argument must be a control with onAdd and onRemove methods.")));
+                var ne = K.onAdd(this);
+                this._controls.push(K);
+                var we = this._controlPositions[de];
+                return de.indexOf("bottom") !== -1 ? we.insertBefore(ne, we.firstChild) : we.appendChild(ne), this;
+              }, D.prototype.removeControl = function(K) {
+                if (!K || !K.onRemove) return this.fire(new i.ErrorEvent(new Error("Invalid argument to map.removeControl(). Argument must be a control with onAdd and onRemove methods.")));
+                var de = this._controls.indexOf(K);
+                return de > -1 && this._controls.splice(de, 1), K.onRemove(this), this;
+              }, D.prototype.hasControl = function(K) {
+                return this._controls.indexOf(K) > -1;
+              }, D.prototype.resize = function(K) {
+                var de = this._containerDimensions(), ne = de[0], we = de[1];
+                this._resizeCanvas(ne, we), this.transform.resize(ne, we), this.painter.resize(ne, we);
+                var Ue = !this._moving;
+                return Ue && (this.stop(), this.fire(new i.Event("movestart", K)).fire(new i.Event("move", K))), this.fire(new i.Event("resize", K)), Ue && this.fire(new i.Event("moveend", K)), this;
+              }, D.prototype.getBounds = function() {
+                return this.transform.getBounds();
+              }, D.prototype.getMaxBounds = function() {
+                return this.transform.getMaxBounds();
+              }, D.prototype.setMaxBounds = function(K) {
+                return this.transform.setMaxBounds(i.LngLatBounds.convert(K)), this._update();
+              }, D.prototype.setMinZoom = function(K) {
+                if (K = K == null ? ci : K, K >= ci && K <= this.transform.maxZoom) return this.transform.minZoom = K, this._update(), this.getZoom() < K && this.setZoom(K), this;
+                throw new Error("minZoom must be between " + ci + " and the current maxZoom, inclusive");
+              }, D.prototype.getMinZoom = function() {
+                return this.transform.minZoom;
+              }, D.prototype.setMaxZoom = function(K) {
+                if (K = K == null ? an : K, K >= this.transform.minZoom) return this.transform.maxZoom = K, this._update(), this.getZoom() > K && this.setZoom(K), this;
+                throw new Error("maxZoom must be greater than the current minZoom");
+              }, D.prototype.getMaxZoom = function() {
+                return this.transform.maxZoom;
+              }, D.prototype.setMinPitch = function(K) {
+                if (K = K == null ? Zi : K, K < Zi) throw new Error("minPitch must be greater than or equal to " + Zi);
+                if (K >= Zi && K <= this.transform.maxPitch) return this.transform.minPitch = K, this._update(), this.getPitch() < K && this.setPitch(K), this;
+                throw new Error("minPitch must be between " + Zi + " and the current maxPitch, inclusive");
+              }, D.prototype.getMinPitch = function() {
+                return this.transform.minPitch;
+              }, D.prototype.setMaxPitch = function(K) {
+                if (K = K == null ? Bn : K, K > Bn) throw new Error("maxPitch must be less than or equal to " + Bn);
+                if (K >= this.transform.minPitch) return this.transform.maxPitch = K, this._update(), this.getPitch() > K && this.setPitch(K), this;
+                throw new Error("maxPitch must be greater than the current minPitch");
+              }, D.prototype.getMaxPitch = function() {
+                return this.transform.maxPitch;
+              }, D.prototype.getRenderWorldCopies = function() {
+                return this.transform.renderWorldCopies;
+              }, D.prototype.setRenderWorldCopies = function(K) {
+                return this.transform.renderWorldCopies = K, this._update();
+              }, D.prototype.project = function(K) {
+                return this.transform.locationPoint(i.LngLat.convert(K));
+              }, D.prototype.unproject = function(K) {
+                return this.transform.pointLocation(i.Point.convert(K));
+              }, D.prototype.isMoving = function() {
+                return this._moving || this.handlers.isMoving();
+              }, D.prototype.isZooming = function() {
+                return this._zooming || this.handlers.isZooming();
+              }, D.prototype.isRotating = function() {
+                return this._rotating || this.handlers.isRotating();
+              }, D.prototype._createDelegatedListener = function(K, de, ne) {
+                var we = this, Ue;
+                if (K === "mouseenter" || K === "mouseover") {
+                  var ft = false, Zt = function(Ct) {
+                    var Ot = we.getLayer(de) ? we.queryRenderedFeatures(Ct.point, { layers: [de] }) : [];
+                    Ot.length ? ft || (ft = true, ne.call(we, new se(K, we, Ct.originalEvent, { features: Ot }))) : ft = false;
+                  }, hr = function() {
+                    ft = false;
+                  };
+                  return { layer: de, listener: ne, delegates: { mousemove: Zt, mouseout: hr } };
+                } else if (K === "mouseleave" || K === "mouseout") {
+                  var qt = false, Ve = function(Ct) {
+                    var Ot = we.getLayer(de) ? we.queryRenderedFeatures(Ct.point, { layers: [de] }) : [];
+                    Ot.length ? qt = true : qt && (qt = false, ne.call(we, new se(K, we, Ct.originalEvent)));
+                  }, Qe = function(Ct) {
+                    qt && (qt = false, ne.call(we, new se(K, we, Ct.originalEvent)));
+                  };
+                  return { layer: de, listener: ne, delegates: { mousemove: Ve, mouseout: Qe } };
+                } else {
+                  var at = function(Ct) {
+                    var Ot = we.getLayer(de) ? we.queryRenderedFeatures(Ct.point, { layers: [de] }) : [];
+                    Ot.length && (Ct.features = Ot, ne.call(we, Ct), delete Ct.features);
+                  };
+                  return { layer: de, listener: ne, delegates: (Ue = {}, Ue[K] = at, Ue) };
+                }
+              }, D.prototype.on = function(K, de, ne) {
+                if (ne === void 0) return Y.prototype.on.call(this, K, de);
+                var we = this._createDelegatedListener(K, de, ne);
+                this._delegatedListeners = this._delegatedListeners || {}, this._delegatedListeners[K] = this._delegatedListeners[K] || [], this._delegatedListeners[K].push(we);
+                for (var Ue in we.delegates) this.on(Ue, we.delegates[Ue]);
+                return this;
+              }, D.prototype.once = function(K, de, ne) {
+                if (ne === void 0) return Y.prototype.once.call(this, K, de);
+                var we = this._createDelegatedListener(K, de, ne);
+                for (var Ue in we.delegates) this.once(Ue, we.delegates[Ue]);
+                return this;
+              }, D.prototype.off = function(K, de, ne) {
+                var we = this;
+                if (ne === void 0) return Y.prototype.off.call(this, K, de);
+                var Ue = function(ft) {
+                  for (var Zt = ft[K], hr = 0; hr < Zt.length; hr++) {
+                    var qt = Zt[hr];
+                    if (qt.layer === de && qt.listener === ne) {
+                      for (var Ve in qt.delegates) we.off(Ve, qt.delegates[Ve]);
+                      return Zt.splice(hr, 1), we;
+                    }
+                  }
+                };
+                return this._delegatedListeners && this._delegatedListeners[K] && Ue(this._delegatedListeners), this;
+              }, D.prototype.queryRenderedFeatures = function(K, de) {
+                if (!this.style) return [];
+                de === void 0 && K !== void 0 && !(K instanceof i.Point) && !Array.isArray(K) && (de = K, K = void 0), de = de || {}, K = K || [[0, 0], [this.transform.width, this.transform.height]];
+                var ne;
+                if (K instanceof i.Point || typeof K[0] == "number") ne = [i.Point.convert(K)];
+                else {
+                  var we = i.Point.convert(K[0]), Ue = i.Point.convert(K[1]);
+                  ne = [we, new i.Point(Ue.x, we.y), Ue, new i.Point(we.x, Ue.y), we];
+                }
+                return this.style.queryRenderedFeatures(ne, de, this.transform);
+              }, D.prototype.querySourceFeatures = function(K, de) {
+                return this.style.querySourceFeatures(K, de);
+              }, D.prototype.setStyle = function(K, de) {
+                return de = i.extend({}, { localIdeographFontFamily: this._localIdeographFontFamily }, de), de.diff !== false && de.localIdeographFontFamily === this._localIdeographFontFamily && this.style && K ? (this._diffStyle(K, de), this) : (this._localIdeographFontFamily = de.localIdeographFontFamily, this._updateStyle(K, de));
+              }, D.prototype._getUIString = function(K) {
+                var de = this._locale[K];
+                if (de == null) throw new Error("Missing UI string '" + K + "'");
+                return de;
+              }, D.prototype._updateStyle = function(K, de) {
+                if (this.style && (this.style.setEventedParent(null), this.style._remove()), K) this.style = new yu(this, de || {});
+                else return delete this.style, this;
+                return this.style.setEventedParent(this, { style: this.style }), typeof K == "string" ? this.style.loadURL(K) : this.style.loadJSON(K), this;
+              }, D.prototype._lazyInitEmptyStyle = function() {
+                this.style || (this.style = new yu(this, {}), this.style.setEventedParent(this, { style: this.style }), this.style.loadEmpty());
+              }, D.prototype._diffStyle = function(K, de) {
+                var ne = this;
+                if (typeof K == "string") {
+                  var we = this._requestManager.normalizeStyleURL(K), Ue = this._requestManager.transformRequest(we, i.ResourceType.Style);
+                  i.getJSON(Ue, function(ft, Zt) {
+                    ft ? ne.fire(new i.ErrorEvent(ft)) : Zt && ne._updateDiff(Zt, de);
+                  });
+                } else typeof K == "object" && this._updateDiff(K, de);
+              }, D.prototype._updateDiff = function(K, de) {
+                try {
+                  this.style.setState(K) && this._update(true);
+                } catch (ne) {
+                  i.warnOnce("Unable to perform style diff: " + (ne.message || ne.error || ne) + ".  Rebuilding the style from scratch."), this._updateStyle(K, de);
+                }
+              }, D.prototype.getStyle = function() {
+                if (this.style) return this.style.serialize();
+              }, D.prototype.isStyleLoaded = function() {
+                return this.style ? this.style.loaded() : i.warnOnce("There is no style added to the map.");
+              }, D.prototype.addSource = function(K, de) {
+                return this._lazyInitEmptyStyle(), this.style.addSource(K, de), this._update(true);
+              }, D.prototype.isSourceLoaded = function(K) {
+                var de = this.style && this.style.sourceCaches[K];
+                if (de === void 0) {
+                  this.fire(new i.ErrorEvent(new Error("There is no source with ID '" + K + "'")));
+                  return;
+                }
+                return de.loaded();
+              }, D.prototype.areTilesLoaded = function() {
+                var K = this.style && this.style.sourceCaches;
+                for (var de in K) {
+                  var ne = K[de], we = ne._tiles;
+                  for (var Ue in we) {
+                    var ft = we[Ue];
+                    if (!(ft.state === "loaded" || ft.state === "errored")) return false;
+                  }
+                }
+                return true;
+              }, D.prototype.addSourceType = function(K, de, ne) {
+                return this._lazyInitEmptyStyle(), this.style.addSourceType(K, de, ne);
+              }, D.prototype.removeSource = function(K) {
+                return this.style.removeSource(K), this._update(true);
+              }, D.prototype.getSource = function(K) {
+                return this.style.getSource(K);
+              }, D.prototype.addImage = function(K, de, ne) {
+                ne === void 0 && (ne = {});
+                var we = ne.pixelRatio;
+                we === void 0 && (we = 1);
+                var Ue = ne.sdf;
+                Ue === void 0 && (Ue = false);
+                var ft = ne.stretchX, Zt = ne.stretchY, hr = ne.content;
+                this._lazyInitEmptyStyle();
+                var qt = 0;
+                if (de instanceof Yr || Ri && de instanceof Ri) {
+                  var Ve = i.browser.getImageData(de), Qe = Ve.width, at = Ve.height, Ct = Ve.data;
+                  this.style.addImage(K, { data: new i.RGBAImage({ width: Qe, height: at }, Ct), pixelRatio: we, stretchX: ft, stretchY: Zt, content: hr, sdf: Ue, version: qt });
+                } else {
+                  if (de.width === void 0 || de.height === void 0) return this.fire(new i.ErrorEvent(new Error("Invalid arguments to map.addImage(). The second argument must be an `HTMLImageElement`, `ImageData`, `ImageBitmap`, or object with `width`, `height`, and `data` properties with the same format as `ImageData`")));
+                  var Ot = de.width, Rt = de.height, Bt = de.data, Dt = de;
+                  this.style.addImage(K, { data: new i.RGBAImage({ width: Ot, height: Rt }, new Uint8Array(Bt)), pixelRatio: we, stretchX: ft, stretchY: Zt, content: hr, sdf: Ue, version: qt, userImage: Dt }), Dt.onAdd && Dt.onAdd(this, K);
+                }
+              }, D.prototype.updateImage = function(K, de) {
+                var ne = this.style.getImage(K);
+                if (!ne) return this.fire(new i.ErrorEvent(new Error("The map has no image with that id. If you are adding a new image use `map.addImage(...)` instead.")));
+                var we = de instanceof Yr || Ri && de instanceof Ri ? i.browser.getImageData(de) : de, Ue = we.width, ft = we.height, Zt = we.data;
+                if (Ue === void 0 || ft === void 0) return this.fire(new i.ErrorEvent(new Error("Invalid arguments to map.updateImage(). The second argument must be an `HTMLImageElement`, `ImageData`, `ImageBitmap`, or object with `width`, `height`, and `data` properties with the same format as `ImageData`")));
+                if (Ue !== ne.data.width || ft !== ne.data.height) return this.fire(new i.ErrorEvent(new Error("The width and height of the updated image must be that same as the previous version of the image")));
+                var hr = !(de instanceof Yr || Ri && de instanceof Ri);
+                ne.data.replace(Zt, hr), this.style.updateImage(K, ne);
+              }, D.prototype.hasImage = function(K) {
+                return K ? !!this.style.getImage(K) : (this.fire(new i.ErrorEvent(new Error("Missing required image id"))), false);
+              }, D.prototype.removeImage = function(K) {
+                this.style.removeImage(K);
+              }, D.prototype.loadImage = function(K, de) {
+                i.getImage(this._requestManager.transformRequest(K, i.ResourceType.Image), de);
+              }, D.prototype.listImages = function() {
+                return this.style.listImages();
+              }, D.prototype.addLayer = function(K, de) {
+                return this._lazyInitEmptyStyle(), this.style.addLayer(K, de), this._update(true);
+              }, D.prototype.moveLayer = function(K, de) {
+                return this.style.moveLayer(K, de), this._update(true);
+              }, D.prototype.removeLayer = function(K) {
+                return this.style.removeLayer(K), this._update(true);
+              }, D.prototype.getLayer = function(K) {
+                return this.style.getLayer(K);
+              }, D.prototype.setLayerZoomRange = function(K, de, ne) {
+                return this.style.setLayerZoomRange(K, de, ne), this._update(true);
+              }, D.prototype.setFilter = function(K, de, ne) {
+                return ne === void 0 && (ne = {}), this.style.setFilter(K, de, ne), this._update(true);
+              }, D.prototype.getFilter = function(K) {
+                return this.style.getFilter(K);
+              }, D.prototype.setPaintProperty = function(K, de, ne, we) {
+                return we === void 0 && (we = {}), this.style.setPaintProperty(K, de, ne, we), this._update(true);
+              }, D.prototype.getPaintProperty = function(K, de) {
+                return this.style.getPaintProperty(K, de);
+              }, D.prototype.setLayoutProperty = function(K, de, ne, we) {
+                return we === void 0 && (we = {}), this.style.setLayoutProperty(K, de, ne, we), this._update(true);
+              }, D.prototype.getLayoutProperty = function(K, de) {
+                return this.style.getLayoutProperty(K, de);
+              }, D.prototype.setLight = function(K, de) {
+                return de === void 0 && (de = {}), this._lazyInitEmptyStyle(), this.style.setLight(K, de), this._update(true);
+              }, D.prototype.getLight = function() {
+                return this.style.getLight();
+              }, D.prototype.setFeatureState = function(K, de) {
+                return this.style.setFeatureState(K, de), this._update();
+              }, D.prototype.removeFeatureState = function(K, de) {
+                return this.style.removeFeatureState(K, de), this._update();
+              }, D.prototype.getFeatureState = function(K) {
+                return this.style.getFeatureState(K);
+              }, D.prototype.getContainer = function() {
+                return this._container;
+              }, D.prototype.getCanvasContainer = function() {
+                return this._canvasContainer;
+              }, D.prototype.getCanvas = function() {
+                return this._canvas;
+              }, D.prototype._containerDimensions = function() {
+                var K = 0, de = 0;
+                return this._container && (K = this._container.clientWidth || 400, de = this._container.clientHeight || 300), [K, de];
+              }, D.prototype._detectMissingCSS = function() {
+                var K = i.window.getComputedStyle(this._missingCSSCanary).getPropertyValue("background-color");
+                K !== "rgb(250, 128, 114)" && i.warnOnce("This page appears to be missing CSS declarations for Mapbox GL JS, which may cause the map to display incorrectly. Please ensure your page includes mapbox-gl.css, as described in https://www.mapbox.com/mapbox-gl-js/api/.");
+              }, D.prototype._setupContainer = function() {
+                var K = this._container;
+                K.classList.add("mapboxgl-map");
+                var de = this._missingCSSCanary = o.create("div", "mapboxgl-canary", K);
+                de.style.visibility = "hidden", this._detectMissingCSS();
+                var ne = this._canvasContainer = o.create("div", "mapboxgl-canvas-container", K);
+                this._interactive && ne.classList.add("mapboxgl-interactive"), this._canvas = o.create("canvas", "mapboxgl-canvas", ne), this._canvas.addEventListener("webglcontextlost", this._contextLost, false), this._canvas.addEventListener("webglcontextrestored", this._contextRestored, false), this._canvas.setAttribute("tabindex", "0"), this._canvas.setAttribute("aria-label", "Map"), this._canvas.setAttribute("role", "region");
+                var we = this._containerDimensions();
+                this._resizeCanvas(we[0], we[1]);
+                var Ue = this._controlContainer = o.create("div", "mapboxgl-control-container", K), ft = this._controlPositions = {};
+                ["top-left", "top-right", "bottom-left", "bottom-right"].forEach(function(Zt) {
+                  ft[Zt] = o.create("div", "mapboxgl-ctrl-" + Zt, Ue);
+                }), this._container.addEventListener("scroll", this._onMapScroll, false);
+              }, D.prototype._resizeCanvas = function(K, de) {
+                var ne = i.browser.devicePixelRatio || 1;
+                this._canvas.width = ne * K, this._canvas.height = ne * de, this._canvas.style.width = K + "px", this._canvas.style.height = de + "px";
+              }, D.prototype._setupPainter = function() {
+                var K = i.extend({}, a.webGLContextAttributes, { failIfMajorPerformanceCaveat: this._failIfMajorPerformanceCaveat, preserveDrawingBuffer: this._preserveDrawingBuffer, antialias: this._antialias || false }), de = this._canvas.getContext("webgl", K) || this._canvas.getContext("experimental-webgl", K);
+                if (!de) {
+                  this.fire(new i.ErrorEvent(new Error("Failed to initialize WebGL")));
+                  return;
+                }
+                this.painter = new mo(de, this.transform), i.webpSupported.testSupport(de);
+              }, D.prototype._contextLost = function(K) {
+                K.preventDefault(), this._frame && (this._frame.cancel(), this._frame = null), this.fire(new i.Event("webglcontextlost", { originalEvent: K }));
+              }, D.prototype._contextRestored = function(K) {
+                this._setupPainter(), this.resize(), this._update(), this.fire(new i.Event("webglcontextrestored", { originalEvent: K }));
+              }, D.prototype._onMapScroll = function(K) {
+                if (K.target === this._container) return this._container.scrollTop = 0, this._container.scrollLeft = 0, false;
+              }, D.prototype.loaded = function() {
+                return !this._styleDirty && !this._sourcesDirty && !!this.style && this.style.loaded();
+              }, D.prototype._update = function(K) {
+                return this.style ? (this._styleDirty = this._styleDirty || K, this._sourcesDirty = true, this.triggerRepaint(), this) : this;
+              }, D.prototype._requestRenderFrame = function(K) {
+                return this._update(), this._renderTaskQueue.add(K);
+              }, D.prototype._cancelRenderFrame = function(K) {
+                this._renderTaskQueue.remove(K);
+              }, D.prototype._render = function(K) {
+                var de = this, ne, we = 0, Ue = this.painter.context.extTimerQuery;
+                if (this.listens("gpu-timing-frame") && (ne = Ue.createQueryEXT(), Ue.beginQueryEXT(Ue.TIME_ELAPSED_EXT, ne), we = i.browser.now()), this.painter.context.setDirty(), this.painter.setBaseState(), this._renderTaskQueue.run(K), !this._removed) {
+                  var ft = false;
+                  if (this.style && this._styleDirty) {
+                    this._styleDirty = false;
+                    var Zt = this.transform.zoom, hr = i.browser.now();
+                    this.style.zoomHistory.update(Zt, hr);
+                    var qt = new i.EvaluationParameters(Zt, { now: hr, fadeDuration: this._fadeDuration, zoomHistory: this.style.zoomHistory, transition: this.style.getTransition() }), Ve = qt.crossFadingFactor();
+                    (Ve !== 1 || Ve !== this._crossFadingFactor) && (ft = true, this._crossFadingFactor = Ve), this.style.update(qt);
+                  }
+                  if (this.style && this._sourcesDirty && (this._sourcesDirty = false, this.style._updateSources(this.transform)), this._placementDirty = this.style && this.style._updatePlacement(this.painter.transform, this.showCollisionBoxes, this._fadeDuration, this._crossSourceCollisions), this.painter.render(this.style, { showTileBoundaries: this.showTileBoundaries, showOverdrawInspector: this._showOverdrawInspector, rotating: this.isRotating(), zooming: this.isZooming(), moving: this.isMoving(), fadeDuration: this._fadeDuration, showPadding: this.showPadding, gpuTiming: !!this.listens("gpu-timing-layer") }), this.fire(new i.Event("render")), this.loaded() && !this._loaded && (this._loaded = true, this.fire(new i.Event("load"))), this.style && (this.style.hasTransitions() || ft) && (this._styleDirty = true), this.style && !this._placementDirty && this.style._releaseSymbolFadeTiles(), this.listens("gpu-timing-frame")) {
+                    var Qe = i.browser.now() - we;
+                    Ue.endQueryEXT(Ue.TIME_ELAPSED_EXT, ne), setTimeout(function() {
+                      var Ot = Ue.getQueryObjectEXT(ne, Ue.QUERY_RESULT_EXT) / 1e6;
+                      Ue.deleteQueryEXT(ne), de.fire(new i.Event("gpu-timing-frame", { cpuTime: Qe, gpuTime: Ot }));
+                    }, 50);
+                  }
+                  if (this.listens("gpu-timing-layer")) {
+                    var at = this.painter.collectGpuTimers();
+                    setTimeout(function() {
+                      var Ot = de.painter.queryGpuTimers(at);
+                      de.fire(new i.Event("gpu-timing-layer", { layerTimes: Ot }));
+                    }, 50);
+                  }
+                  var Ct = this._sourcesDirty || this._styleDirty || this._placementDirty;
+                  return Ct || this._repaint ? this.triggerRepaint() : !this.isMoving() && this.loaded() && this.fire(new i.Event("idle")), this._loaded && !this._fullyLoaded && !Ct && (this._fullyLoaded = true), this;
+                }
+              }, D.prototype.remove = function() {
+                this._hash && this._hash.remove();
+                for (var K = 0, de = this._controls; K < de.length; K += 1) {
+                  var ne = de[K];
+                  ne.onRemove(this);
+                }
+                this._controls = [], this._frame && (this._frame.cancel(), this._frame = null), this._renderTaskQueue.clear(), this.painter.destroy(), this.handlers.destroy(), delete this.handlers, this.setStyle(null), typeof i.window != "undefined" && (i.window.removeEventListener("resize", this._onWindowResize, false), i.window.removeEventListener("orientationchange", this._onWindowResize, false), i.window.removeEventListener("online", this._onWindowOnline, false));
+                var we = this.painter.context.gl.getExtension("WEBGL_lose_context");
+                we && we.loseContext && we.loseContext(), mn(this._canvasContainer), mn(this._controlContainer), mn(this._missingCSSCanary), this._container.classList.remove("mapboxgl-map"), this._removed = true, this.fire(new i.Event("remove"));
+              }, D.prototype.triggerRepaint = function() {
+                var K = this;
+                this.style && !this._frame && (this._frame = i.browser.frame(function(de) {
+                  K._frame = null, K._render(de);
+                }));
+              }, D.prototype._onWindowOnline = function() {
+                this._update();
+              }, D.prototype._onWindowResize = function(K) {
+                this._trackResize && this.resize({ originalEvent: K })._update();
+              }, J.showTileBoundaries.get = function() {
+                return !!this._showTileBoundaries;
+              }, J.showTileBoundaries.set = function(q) {
+                this._showTileBoundaries !== q && (this._showTileBoundaries = q, this._update());
+              }, J.showPadding.get = function() {
+                return !!this._showPadding;
+              }, J.showPadding.set = function(q) {
+                this._showPadding !== q && (this._showPadding = q, this._update());
+              }, J.showCollisionBoxes.get = function() {
+                return !!this._showCollisionBoxes;
+              }, J.showCollisionBoxes.set = function(q) {
+                this._showCollisionBoxes !== q && (this._showCollisionBoxes = q, q ? this.style._generateCollisionBoxes() : this._update());
+              }, J.showOverdrawInspector.get = function() {
+                return !!this._showOverdrawInspector;
+              }, J.showOverdrawInspector.set = function(q) {
+                this._showOverdrawInspector !== q && (this._showOverdrawInspector = q, this._update());
+              }, J.repaint.get = function() {
+                return !!this._repaint;
+              }, J.repaint.set = function(q) {
+                this._repaint !== q && (this._repaint = q, this.triggerRepaint());
+              }, J.vertices.get = function() {
+                return !!this._vertices;
+              }, J.vertices.set = function(q) {
+                this._vertices = q, this._update();
+              }, D.prototype._setCacheLimits = function(K, de) {
+                i.setCacheLimits(K, de);
+              }, J.version.get = function() {
+                return i.version;
+              }, Object.defineProperties(D.prototype, J), D;
+            }(Hn);
+            function mn(Y) {
+              Y.parentNode && Y.parentNode.removeChild(Y);
+            }
+            var Ji = { showCompass: true, showZoom: true, visualizePitch: false }, Vi = function(D) {
+              var J = this;
+              this.options = i.extend({}, Ji, D), this._container = o.create("div", "mapboxgl-ctrl mapboxgl-ctrl-group"), this._container.addEventListener("contextmenu", function(q) {
+                return q.preventDefault();
+              }), this.options.showZoom && (i.bindAll(["_setButtonTitle", "_updateZoomButtons"], this), this._zoomInButton = this._createButton("mapboxgl-ctrl-zoom-in", function(q) {
+                return J._map.zoomIn({}, { originalEvent: q });
+              }), o.create("span", "mapboxgl-ctrl-icon", this._zoomInButton).setAttribute("aria-hidden", true), this._zoomOutButton = this._createButton("mapboxgl-ctrl-zoom-out", function(q) {
+                return J._map.zoomOut({}, { originalEvent: q });
+              }), o.create("span", "mapboxgl-ctrl-icon", this._zoomOutButton).setAttribute("aria-hidden", true)), this.options.showCompass && (i.bindAll(["_rotateCompassArrow"], this), this._compass = this._createButton("mapboxgl-ctrl-compass", function(q) {
+                J.options.visualizePitch ? J._map.resetNorthPitch({}, { originalEvent: q }) : J._map.resetNorth({}, { originalEvent: q });
+              }), this._compassIcon = o.create("span", "mapboxgl-ctrl-icon", this._compass), this._compassIcon.setAttribute("aria-hidden", true));
+            };
+            Vi.prototype._updateZoomButtons = function() {
+              var D = this._map.getZoom(), J = D === this._map.getMaxZoom(), q = D === this._map.getMinZoom();
+              this._zoomInButton.disabled = J, this._zoomOutButton.disabled = q, this._zoomInButton.setAttribute("aria-disabled", J.toString()), this._zoomOutButton.setAttribute("aria-disabled", q.toString());
+            }, Vi.prototype._rotateCompassArrow = function() {
+              var D = this.options.visualizePitch ? "scale(" + 1 / Math.pow(Math.cos(this._map.transform.pitch * (Math.PI / 180)), 0.5) + ") rotateX(" + this._map.transform.pitch + "deg) rotateZ(" + this._map.transform.angle * (180 / Math.PI) + "deg)" : "rotate(" + this._map.transform.angle * (180 / Math.PI) + "deg)";
+              this._compassIcon.style.transform = D;
+            }, Vi.prototype.onAdd = function(D) {
+              return this._map = D, this.options.showZoom && (this._setButtonTitle(this._zoomInButton, "ZoomIn"), this._setButtonTitle(this._zoomOutButton, "ZoomOut"), this._map.on("zoom", this._updateZoomButtons), this._updateZoomButtons()), this.options.showCompass && (this._setButtonTitle(this._compass, "ResetBearing"), this.options.visualizePitch && this._map.on("pitch", this._rotateCompassArrow), this._map.on("rotate", this._rotateCompassArrow), this._rotateCompassArrow(), this._handler = new Ni(this._map, this._compass, this.options.visualizePitch)), this._container;
+            }, Vi.prototype.onRemove = function() {
+              o.remove(this._container), this.options.showZoom && this._map.off("zoom", this._updateZoomButtons), this.options.showCompass && (this.options.visualizePitch && this._map.off("pitch", this._rotateCompassArrow), this._map.off("rotate", this._rotateCompassArrow), this._handler.off(), delete this._handler), delete this._map;
+            }, Vi.prototype._createButton = function(D, J) {
+              var q = o.create("button", D, this._container);
+              return q.type = "button", q.addEventListener("click", J), q;
+            }, Vi.prototype._setButtonTitle = function(D, J) {
+              var q = this._map._getUIString("NavigationControl." + J);
+              D.title = q, D.setAttribute("aria-label", q);
+            };
+            var Ni = function(D, J, q) {
+              q === void 0 && (q = false), this._clickTolerance = 10, this.element = J, this.mouseRotate = new Ln({ clickTolerance: D.dragRotate._mouseRotate._clickTolerance }), this.map = D, q && (this.mousePitch = new En({ clickTolerance: D.dragRotate._mousePitch._clickTolerance })), i.bindAll(["mousedown", "mousemove", "mouseup", "touchstart", "touchmove", "touchend", "reset"], this), o.addEventListener(J, "mousedown", this.mousedown), o.addEventListener(J, "touchstart", this.touchstart, { passive: false }), o.addEventListener(J, "touchmove", this.touchmove), o.addEventListener(J, "touchend", this.touchend), o.addEventListener(J, "touchcancel", this.reset);
+            };
+            Ni.prototype.down = function(D, J) {
+              this.mouseRotate.mousedown(D, J), this.mousePitch && this.mousePitch.mousedown(D, J), o.disableDrag();
+            }, Ni.prototype.move = function(D, J) {
+              var q = this.map, K = this.mouseRotate.mousemoveWindow(D, J);
+              if (K && K.bearingDelta && q.setBearing(q.getBearing() + K.bearingDelta), this.mousePitch) {
+                var de = this.mousePitch.mousemoveWindow(D, J);
+                de && de.pitchDelta && q.setPitch(q.getPitch() + de.pitchDelta);
+              }
+            }, Ni.prototype.off = function() {
+              var D = this.element;
+              o.removeEventListener(D, "mousedown", this.mousedown), o.removeEventListener(D, "touchstart", this.touchstart, { passive: false }), o.removeEventListener(D, "touchmove", this.touchmove), o.removeEventListener(D, "touchend", this.touchend), o.removeEventListener(D, "touchcancel", this.reset), this.offTemp();
+            }, Ni.prototype.offTemp = function() {
+              o.enableDrag(), o.removeEventListener(i.window, "mousemove", this.mousemove), o.removeEventListener(i.window, "mouseup", this.mouseup);
+            }, Ni.prototype.mousedown = function(D) {
+              this.down(i.extend({}, D, { ctrlKey: true, preventDefault: function() {
+                return D.preventDefault();
+              } }), o.mousePos(this.element, D)), o.addEventListener(i.window, "mousemove", this.mousemove), o.addEventListener(i.window, "mouseup", this.mouseup);
+            }, Ni.prototype.mousemove = function(D) {
+              this.move(D, o.mousePos(this.element, D));
+            }, Ni.prototype.mouseup = function(D) {
+              this.mouseRotate.mouseupWindow(D), this.mousePitch && this.mousePitch.mouseupWindow(D), this.offTemp();
+            }, Ni.prototype.touchstart = function(D) {
+              D.targetTouches.length !== 1 ? this.reset() : (this._startPos = this._lastPos = o.touchPos(this.element, D.targetTouches)[0], this.down({ type: "mousedown", button: 0, ctrlKey: true, preventDefault: function() {
+                return D.preventDefault();
+              } }, this._startPos));
+            }, Ni.prototype.touchmove = function(D) {
+              D.targetTouches.length !== 1 ? this.reset() : (this._lastPos = o.touchPos(this.element, D.targetTouches)[0], this.move({ preventDefault: function() {
+                return D.preventDefault();
+              } }, this._lastPos));
+            }, Ni.prototype.touchend = function(D) {
+              D.targetTouches.length === 0 && this._startPos && this._lastPos && this._startPos.dist(this._lastPos) < this._clickTolerance && this.element.click(), this.reset();
+            }, Ni.prototype.reset = function() {
+              this.mouseRotate.reset(), this.mousePitch && this.mousePitch.reset(), delete this._startPos, delete this._lastPos, this.offTemp();
+            };
+            function pn(Y, D, J) {
+              if (Y = new i.LngLat(Y.lng, Y.lat), D) {
+                var q = new i.LngLat(Y.lng - 360, Y.lat), K = new i.LngLat(Y.lng + 360, Y.lat), de = J.locationPoint(Y).distSqr(D);
+                J.locationPoint(q).distSqr(D) < de ? Y = q : J.locationPoint(K).distSqr(D) < de && (Y = K);
+              }
+              for (; Math.abs(Y.lng - J.center.lng) > 180; ) {
+                var ne = J.locationPoint(Y);
+                if (ne.x >= 0 && ne.y >= 0 && ne.x <= J.width && ne.y <= J.height) break;
+                Y.lng > J.center.lng ? Y.lng -= 360 : Y.lng += 360;
+              }
+              return Y;
+            }
+            var Vn = { center: "translate(-50%,-50%)", top: "translate(-50%,0)", "top-left": "translate(0,0)", "top-right": "translate(-100%,0)", bottom: "translate(-50%,-100%)", "bottom-left": "translate(0,-100%)", "bottom-right": "translate(-100%,-100%)", left: "translate(0,-50%)", right: "translate(-100%,-50%)" };
+            function na(Y, D, J) {
+              var q = Y.classList;
+              for (var K in Vn) q.remove("mapboxgl-" + J + "-anchor-" + K);
+              q.add("mapboxgl-" + J + "-anchor-" + D);
+            }
+            var Ki = function(Y) {
+              function D(J, q) {
+                if (Y.call(this), (J instanceof i.window.HTMLElement || q) && (J = i.extend({ element: J }, q)), i.bindAll(["_update", "_onMove", "_onUp", "_addDragHandler", "_onMapClick", "_onKeyPress"], this), this._anchor = J && J.anchor || "center", this._color = J && J.color || "#3FB1CE", this._scale = J && J.scale || 1, this._draggable = J && J.draggable || false, this._clickTolerance = J && J.clickTolerance || 0, this._isDragging = false, this._state = "inactive", this._rotation = J && J.rotation || 0, this._rotationAlignment = J && J.rotationAlignment || "auto", this._pitchAlignment = J && J.pitchAlignment && J.pitchAlignment !== "auto" ? J.pitchAlignment : this._rotationAlignment, !J || !J.element) {
+                  this._defaultMarker = true, this._element = o.create("div"), this._element.setAttribute("aria-label", "Map marker");
+                  var K = o.createNS("http://www.w3.org/2000/svg", "svg"), de = 41, ne = 27;
+                  K.setAttributeNS(null, "display", "block"), K.setAttributeNS(null, "height", de + "px"), K.setAttributeNS(null, "width", ne + "px"), K.setAttributeNS(null, "viewBox", "0 0 " + ne + " " + de);
+                  var we = o.createNS("http://www.w3.org/2000/svg", "g");
+                  we.setAttributeNS(null, "stroke", "none"), we.setAttributeNS(null, "stroke-width", "1"), we.setAttributeNS(null, "fill", "none"), we.setAttributeNS(null, "fill-rule", "evenodd");
+                  var Ue = o.createNS("http://www.w3.org/2000/svg", "g");
+                  Ue.setAttributeNS(null, "fill-rule", "nonzero");
+                  var ft = o.createNS("http://www.w3.org/2000/svg", "g");
+                  ft.setAttributeNS(null, "transform", "translate(3.0, 29.0)"), ft.setAttributeNS(null, "fill", "#000000");
+                  for (var Zt = [{ rx: "10.5", ry: "5.25002273" }, { rx: "10.5", ry: "5.25002273" }, { rx: "9.5", ry: "4.77275007" }, { rx: "8.5", ry: "4.29549936" }, { rx: "7.5", ry: "3.81822308" }, { rx: "6.5", ry: "3.34094679" }, { rx: "5.5", ry: "2.86367051" }, { rx: "4.5", ry: "2.38636864" }], hr = 0, qt = Zt; hr < qt.length; hr += 1) {
+                    var Ve = qt[hr], Qe = o.createNS("http://www.w3.org/2000/svg", "ellipse");
+                    Qe.setAttributeNS(null, "opacity", "0.04"), Qe.setAttributeNS(null, "cx", "10.5"), Qe.setAttributeNS(null, "cy", "5.80029008"), Qe.setAttributeNS(null, "rx", Ve.rx), Qe.setAttributeNS(null, "ry", Ve.ry), ft.appendChild(Qe);
+                  }
+                  var at = o.createNS("http://www.w3.org/2000/svg", "g");
+                  at.setAttributeNS(null, "fill", this._color);
+                  var Ct = o.createNS("http://www.w3.org/2000/svg", "path");
+                  Ct.setAttributeNS(null, "d", "M27,13.5 C27,19.074644 20.250001,27.000002 14.75,34.500002 C14.016665,35.500004 12.983335,35.500004 12.25,34.500002 C6.7499993,27.000002 0,19.222562 0,13.5 C0,6.0441559 6.0441559,0 13.5,0 C20.955844,0 27,6.0441559 27,13.5 Z"), at.appendChild(Ct);
+                  var Ot = o.createNS("http://www.w3.org/2000/svg", "g");
+                  Ot.setAttributeNS(null, "opacity", "0.25"), Ot.setAttributeNS(null, "fill", "#000000");
+                  var Rt = o.createNS("http://www.w3.org/2000/svg", "path");
+                  Rt.setAttributeNS(null, "d", "M13.5,0 C6.0441559,0 0,6.0441559 0,13.5 C0,19.222562 6.7499993,27 12.25,34.5 C13,35.522727 14.016664,35.500004 14.75,34.5 C20.250001,27 27,19.074644 27,13.5 C27,6.0441559 20.955844,0 13.5,0 Z M13.5,1 C20.415404,1 26,6.584596 26,13.5 C26,15.898657 24.495584,19.181431 22.220703,22.738281 C19.945823,26.295132 16.705119,30.142167 13.943359,33.908203 C13.743445,34.180814 13.612715,34.322738 13.5,34.441406 C13.387285,34.322738 13.256555,34.180814 13.056641,33.908203 C10.284481,30.127985 7.4148684,26.314159 5.015625,22.773438 C2.6163816,19.232715 1,15.953538 1,13.5 C1,6.584596 6.584596,1 13.5,1 Z"), Ot.appendChild(Rt);
+                  var Bt = o.createNS("http://www.w3.org/2000/svg", "g");
+                  Bt.setAttributeNS(null, "transform", "translate(6.0, 7.0)"), Bt.setAttributeNS(null, "fill", "#FFFFFF");
+                  var Dt = o.createNS("http://www.w3.org/2000/svg", "g");
+                  Dt.setAttributeNS(null, "transform", "translate(8.0, 8.0)");
+                  var yt = o.createNS("http://www.w3.org/2000/svg", "circle");
+                  yt.setAttributeNS(null, "fill", "#000000"), yt.setAttributeNS(null, "opacity", "0.25"), yt.setAttributeNS(null, "cx", "5.5"), yt.setAttributeNS(null, "cy", "5.5"), yt.setAttributeNS(null, "r", "5.4999962");
+                  var Pt = o.createNS("http://www.w3.org/2000/svg", "circle");
+                  Pt.setAttributeNS(null, "fill", "#FFFFFF"), Pt.setAttributeNS(null, "cx", "5.5"), Pt.setAttributeNS(null, "cy", "5.5"), Pt.setAttributeNS(null, "r", "5.4999962"), Dt.appendChild(yt), Dt.appendChild(Pt), Ue.appendChild(ft), Ue.appendChild(at), Ue.appendChild(Ot), Ue.appendChild(Bt), Ue.appendChild(Dt), K.appendChild(Ue), K.setAttributeNS(null, "height", de * this._scale + "px"), K.setAttributeNS(null, "width", ne * this._scale + "px"), this._element.appendChild(K), this._offset = i.Point.convert(J && J.offset || [0, -14]);
+                } else this._element = J.element, this._offset = i.Point.convert(J && J.offset || [0, 0]);
+                this._element.classList.add("mapboxgl-marker"), this._element.addEventListener("dragstart", function(ht) {
+                  ht.preventDefault();
+                }), this._element.addEventListener("mousedown", function(ht) {
+                  ht.preventDefault();
+                }), na(this._element, this._anchor, "marker"), this._popup = null;
+              }
+              return Y && (D.__proto__ = Y), D.prototype = Object.create(Y && Y.prototype), D.prototype.constructor = D, D.prototype.addTo = function(q) {
+                return this.remove(), this._map = q, q.getCanvasContainer().appendChild(this._element), q.on("move", this._update), q.on("moveend", this._update), this.setDraggable(this._draggable), this._update(), this._map.on("click", this._onMapClick), this;
+              }, D.prototype.remove = function() {
+                return this._map && (this._map.off("click", this._onMapClick), this._map.off("move", this._update), this._map.off("moveend", this._update), this._map.off("mousedown", this._addDragHandler), this._map.off("touchstart", this._addDragHandler), this._map.off("mouseup", this._onUp), this._map.off("touchend", this._onUp), this._map.off("mousemove", this._onMove), this._map.off("touchmove", this._onMove), delete this._map), o.remove(this._element), this._popup && this._popup.remove(), this;
+              }, D.prototype.getLngLat = function() {
+                return this._lngLat;
+              }, D.prototype.setLngLat = function(q) {
+                return this._lngLat = i.LngLat.convert(q), this._pos = null, this._popup && this._popup.setLngLat(this._lngLat), this._update(), this;
+              }, D.prototype.getElement = function() {
+                return this._element;
+              }, D.prototype.setPopup = function(q) {
+                if (this._popup && (this._popup.remove(), this._popup = null, this._element.removeEventListener("keypress", this._onKeyPress), this._originalTabIndex || this._element.removeAttribute("tabindex")), q) {
+                  if (!("offset" in q.options)) {
+                    var K = 38.1, de = 13.5, ne = Math.sqrt(Math.pow(de, 2) / 2);
+                    q.options.offset = this._defaultMarker ? { top: [0, 0], "top-left": [0, 0], "top-right": [0, 0], bottom: [0, -K], "bottom-left": [ne, (K - de + ne) * -1], "bottom-right": [-ne, (K - de + ne) * -1], left: [de, (K - de) * -1], right: [-de, (K - de) * -1] } : this._offset;
+                  }
+                  this._popup = q, this._lngLat && this._popup.setLngLat(this._lngLat), this._originalTabIndex = this._element.getAttribute("tabindex"), this._originalTabIndex || this._element.setAttribute("tabindex", "0"), this._element.addEventListener("keypress", this._onKeyPress);
+                }
+                return this;
+              }, D.prototype._onKeyPress = function(q) {
+                var K = q.code, de = q.charCode || q.keyCode;
+                (K === "Space" || K === "Enter" || de === 32 || de === 13) && this.togglePopup();
+              }, D.prototype._onMapClick = function(q) {
+                var K = q.originalEvent.target, de = this._element;
+                this._popup && (K === de || de.contains(K)) && this.togglePopup();
+              }, D.prototype.getPopup = function() {
+                return this._popup;
+              }, D.prototype.togglePopup = function() {
+                var q = this._popup;
+                if (q) q.isOpen() ? q.remove() : q.addTo(this._map);
+                else return this;
+                return this;
+              }, D.prototype._update = function(q) {
+                if (this._map) {
+                  this._map.transform.renderWorldCopies && (this._lngLat = pn(this._lngLat, this._pos, this._map.transform)), this._pos = this._map.project(this._lngLat)._add(this._offset);
+                  var K = "";
+                  this._rotationAlignment === "viewport" || this._rotationAlignment === "auto" ? K = "rotateZ(" + this._rotation + "deg)" : this._rotationAlignment === "map" && (K = "rotateZ(" + (this._rotation - this._map.getBearing()) + "deg)");
+                  var de = "";
+                  this._pitchAlignment === "viewport" || this._pitchAlignment === "auto" ? de = "rotateX(0deg)" : this._pitchAlignment === "map" && (de = "rotateX(" + this._map.getPitch() + "deg)"), (!q || q.type === "moveend") && (this._pos = this._pos.round()), o.setTransform(this._element, Vn[this._anchor] + " translate(" + this._pos.x + "px, " + this._pos.y + "px) " + de + " " + K);
+                }
+              }, D.prototype.getOffset = function() {
+                return this._offset;
+              }, D.prototype.setOffset = function(q) {
+                return this._offset = i.Point.convert(q), this._update(), this;
+              }, D.prototype._onMove = function(q) {
+                if (!this._isDragging) {
+                  var K = this._clickTolerance || this._map._clickTolerance;
+                  this._isDragging = q.point.dist(this._pointerdownPos) >= K;
+                }
+                this._isDragging && (this._pos = q.point.sub(this._positionDelta), this._lngLat = this._map.unproject(this._pos), this.setLngLat(this._lngLat), this._element.style.pointerEvents = "none", this._state === "pending" && (this._state = "active", this.fire(new i.Event("dragstart"))), this.fire(new i.Event("drag")));
+              }, D.prototype._onUp = function() {
+                this._element.style.pointerEvents = "auto", this._positionDelta = null, this._pointerdownPos = null, this._isDragging = false, this._map.off("mousemove", this._onMove), this._map.off("touchmove", this._onMove), this._state === "active" && this.fire(new i.Event("dragend")), this._state = "inactive";
+              }, D.prototype._addDragHandler = function(q) {
+                this._element.contains(q.originalEvent.target) && (q.preventDefault(), this._positionDelta = q.point.sub(this._pos).add(this._offset), this._pointerdownPos = q.point, this._state = "pending", this._map.on("mousemove", this._onMove), this._map.on("touchmove", this._onMove), this._map.once("mouseup", this._onUp), this._map.once("touchend", this._onUp));
+              }, D.prototype.setDraggable = function(q) {
+                return this._draggable = !!q, this._map && (q ? (this._map.on("mousedown", this._addDragHandler), this._map.on("touchstart", this._addDragHandler)) : (this._map.off("mousedown", this._addDragHandler), this._map.off("touchstart", this._addDragHandler))), this;
+              }, D.prototype.isDraggable = function() {
+                return this._draggable;
+              }, D.prototype.setRotation = function(q) {
+                return this._rotation = q || 0, this._update(), this;
+              }, D.prototype.getRotation = function() {
+                return this._rotation;
+              }, D.prototype.setRotationAlignment = function(q) {
+                return this._rotationAlignment = q || "auto", this._update(), this;
+              }, D.prototype.getRotationAlignment = function() {
+                return this._rotationAlignment;
+              }, D.prototype.setPitchAlignment = function(q) {
+                return this._pitchAlignment = q && q !== "auto" ? q : this._rotationAlignment, this._update(), this;
+              }, D.prototype.getPitchAlignment = function() {
+                return this._pitchAlignment;
+              }, D;
+            }(i.Evented), kn = { positionOptions: { enableHighAccuracy: false, maximumAge: 0, timeout: 6e3 }, fitBoundsOptions: { maxZoom: 15 }, trackUserLocation: false, showAccuracyCircle: true, showUserLocation: true }, ta;
+            function oa(Y) {
+              ta !== void 0 ? Y(ta) : i.window.navigator.permissions !== void 0 ? i.window.navigator.permissions.query({ name: "geolocation" }).then(function(D) {
+                ta = D.state !== "denied", Y(ta);
+              }) : (ta = !!i.window.navigator.geolocation, Y(ta));
+            }
+            var ba = 0, is = false, Zs = function(Y) {
+              function D(J) {
+                Y.call(this), this.options = i.extend({}, kn, J), i.bindAll(["_onSuccess", "_onError", "_onZoom", "_finish", "_setupUI", "_updateCamera", "_updateMarker"], this);
+              }
+              return Y && (D.__proto__ = Y), D.prototype = Object.create(Y && Y.prototype), D.prototype.constructor = D, D.prototype.onAdd = function(q) {
+                return this._map = q, this._container = o.create("div", "mapboxgl-ctrl mapboxgl-ctrl-group"), oa(this._setupUI), this._container;
+              }, D.prototype.onRemove = function() {
+                this._geolocationWatchID !== void 0 && (i.window.navigator.geolocation.clearWatch(this._geolocationWatchID), this._geolocationWatchID = void 0), this.options.showUserLocation && this._userLocationDotMarker && this._userLocationDotMarker.remove(), this.options.showAccuracyCircle && this._accuracyCircleMarker && this._accuracyCircleMarker.remove(), o.remove(this._container), this._map.off("zoom", this._onZoom), this._map = void 0, ba = 0, is = false;
+              }, D.prototype._isOutOfMapMaxBounds = function(q) {
+                var K = this._map.getMaxBounds(), de = q.coords;
+                return K && (de.longitude < K.getWest() || de.longitude > K.getEast() || de.latitude < K.getSouth() || de.latitude > K.getNorth());
+              }, D.prototype._setErrorState = function() {
+                switch (this._watchState) {
+                  case "WAITING_ACTIVE":
+                    this._watchState = "ACTIVE_ERROR", this._geolocateButton.classList.remove("mapboxgl-ctrl-geolocate-active"), this._geolocateButton.classList.add("mapboxgl-ctrl-geolocate-active-error");
+                    break;
+                  case "ACTIVE_LOCK":
+                    this._watchState = "ACTIVE_ERROR", this._geolocateButton.classList.remove("mapboxgl-ctrl-geolocate-active"), this._geolocateButton.classList.add("mapboxgl-ctrl-geolocate-active-error"), this._geolocateButton.classList.add("mapboxgl-ctrl-geolocate-waiting");
+                    break;
+                  case "BACKGROUND":
+                    this._watchState = "BACKGROUND_ERROR", this._geolocateButton.classList.remove("mapboxgl-ctrl-geolocate-background"), this._geolocateButton.classList.add("mapboxgl-ctrl-geolocate-background-error"), this._geolocateButton.classList.add("mapboxgl-ctrl-geolocate-waiting");
+                    break;
+                }
+              }, D.prototype._onSuccess = function(q) {
+                if (this._map) {
+                  if (this._isOutOfMapMaxBounds(q)) {
+                    this._setErrorState(), this.fire(new i.Event("outofmaxbounds", q)), this._updateMarker(), this._finish();
+                    return;
+                  }
+                  if (this.options.trackUserLocation) switch (this._lastKnownPosition = q, this._watchState) {
+                    case "WAITING_ACTIVE":
+                    case "ACTIVE_LOCK":
+                    case "ACTIVE_ERROR":
+                      this._watchState = "ACTIVE_LOCK", this._geolocateButton.classList.remove("mapboxgl-ctrl-geolocate-waiting"), this._geolocateButton.classList.remove("mapboxgl-ctrl-geolocate-active-error"), this._geolocateButton.classList.add("mapboxgl-ctrl-geolocate-active");
+                      break;
+                    case "BACKGROUND":
+                    case "BACKGROUND_ERROR":
+                      this._watchState = "BACKGROUND", this._geolocateButton.classList.remove("mapboxgl-ctrl-geolocate-waiting"), this._geolocateButton.classList.remove("mapboxgl-ctrl-geolocate-background-error"), this._geolocateButton.classList.add("mapboxgl-ctrl-geolocate-background");
+                      break;
+                  }
+                  this.options.showUserLocation && this._watchState !== "OFF" && this._updateMarker(q), (!this.options.trackUserLocation || this._watchState === "ACTIVE_LOCK") && this._updateCamera(q), this.options.showUserLocation && this._dotElement.classList.remove("mapboxgl-user-location-dot-stale"), this.fire(new i.Event("geolocate", q)), this._finish();
+                }
+              }, D.prototype._updateCamera = function(q) {
+                var K = new i.LngLat(q.coords.longitude, q.coords.latitude), de = q.coords.accuracy, ne = this._map.getBearing(), we = i.extend({ bearing: ne }, this.options.fitBoundsOptions);
+                this._map.fitBounds(K.toBounds(de), we, { geolocateSource: true });
+              }, D.prototype._updateMarker = function(q) {
+                if (q) {
+                  var K = new i.LngLat(q.coords.longitude, q.coords.latitude);
+                  this._accuracyCircleMarker.setLngLat(K).addTo(this._map), this._userLocationDotMarker.setLngLat(K).addTo(this._map), this._accuracy = q.coords.accuracy, this.options.showUserLocation && this.options.showAccuracyCircle && this._updateCircleRadius();
+                } else this._userLocationDotMarker.remove(), this._accuracyCircleMarker.remove();
+              }, D.prototype._updateCircleRadius = function() {
+                var q = this._map._container.clientHeight / 2, K = this._map.unproject([0, q]), de = this._map.unproject([1, q]), ne = K.distanceTo(de), we = Math.ceil(2 * this._accuracy / ne);
+                this._circleElement.style.width = we + "px", this._circleElement.style.height = we + "px";
+              }, D.prototype._onZoom = function() {
+                this.options.showUserLocation && this.options.showAccuracyCircle && this._updateCircleRadius();
+              }, D.prototype._onError = function(q) {
+                if (this._map) {
+                  if (this.options.trackUserLocation) if (q.code === 1) {
+                    this._watchState = "OFF", this._geolocateButton.classList.remove("mapboxgl-ctrl-geolocate-waiting"), this._geolocateButton.classList.remove("mapboxgl-ctrl-geolocate-active"), this._geolocateButton.classList.remove("mapboxgl-ctrl-geolocate-active-error"), this._geolocateButton.classList.remove("mapboxgl-ctrl-geolocate-background"), this._geolocateButton.classList.remove("mapboxgl-ctrl-geolocate-background-error"), this._geolocateButton.disabled = true;
+                    var K = this._map._getUIString("GeolocateControl.LocationNotAvailable");
+                    this._geolocateButton.title = K, this._geolocateButton.setAttribute("aria-label", K), this._geolocationWatchID !== void 0 && this._clearWatch();
+                  } else {
+                    if (q.code === 3 && is) return;
+                    this._setErrorState();
+                  }
+                  this._watchState !== "OFF" && this.options.showUserLocation && this._dotElement.classList.add("mapboxgl-user-location-dot-stale"), this.fire(new i.Event("error", q)), this._finish();
+                }
+              }, D.prototype._finish = function() {
+                this._timeoutId && clearTimeout(this._timeoutId), this._timeoutId = void 0;
+              }, D.prototype._setupUI = function(q) {
+                var K = this;
+                if (this._container.addEventListener("contextmenu", function(we) {
+                  return we.preventDefault();
+                }), this._geolocateButton = o.create("button", "mapboxgl-ctrl-geolocate", this._container), o.create("span", "mapboxgl-ctrl-icon", this._geolocateButton).setAttribute("aria-hidden", true), this._geolocateButton.type = "button", q === false) {
+                  i.warnOnce("Geolocation support is not available so the GeolocateControl will be disabled.");
+                  var de = this._map._getUIString("GeolocateControl.LocationNotAvailable");
+                  this._geolocateButton.disabled = true, this._geolocateButton.title = de, this._geolocateButton.setAttribute("aria-label", de);
+                } else {
+                  var ne = this._map._getUIString("GeolocateControl.FindMyLocation");
+                  this._geolocateButton.title = ne, this._geolocateButton.setAttribute("aria-label", ne);
+                }
+                this.options.trackUserLocation && (this._geolocateButton.setAttribute("aria-pressed", "false"), this._watchState = "OFF"), this.options.showUserLocation && (this._dotElement = o.create("div", "mapboxgl-user-location-dot"), this._userLocationDotMarker = new Ki(this._dotElement), this._circleElement = o.create("div", "mapboxgl-user-location-accuracy-circle"), this._accuracyCircleMarker = new Ki({ element: this._circleElement, pitchAlignment: "map" }), this.options.trackUserLocation && (this._watchState = "OFF"), this._map.on("zoom", this._onZoom)), this._geolocateButton.addEventListener("click", this.trigger.bind(this)), this._setup = true, this.options.trackUserLocation && this._map.on("movestart", function(we) {
+                  var Ue = we.originalEvent && we.originalEvent.type === "resize";
+                  !we.geolocateSource && K._watchState === "ACTIVE_LOCK" && !Ue && (K._watchState = "BACKGROUND", K._geolocateButton.classList.add("mapboxgl-ctrl-geolocate-background"), K._geolocateButton.classList.remove("mapboxgl-ctrl-geolocate-active"), K.fire(new i.Event("trackuserlocationend")));
+                });
+              }, D.prototype.trigger = function() {
+                if (!this._setup) return i.warnOnce("Geolocate control triggered before added to a map"), false;
+                if (this.options.trackUserLocation) {
+                  switch (this._watchState) {
+                    case "OFF":
+                      this._watchState = "WAITING_ACTIVE", this.fire(new i.Event("trackuserlocationstart"));
+                      break;
+                    case "WAITING_ACTIVE":
+                    case "ACTIVE_LOCK":
+                    case "ACTIVE_ERROR":
+                    case "BACKGROUND_ERROR":
+                      ba--, is = false, this._watchState = "OFF", this._geolocateButton.classList.remove("mapboxgl-ctrl-geolocate-waiting"), this._geolocateButton.classList.remove("mapboxgl-ctrl-geolocate-active"), this._geolocateButton.classList.remove("mapboxgl-ctrl-geolocate-active-error"), this._geolocateButton.classList.remove("mapboxgl-ctrl-geolocate-background"), this._geolocateButton.classList.remove("mapboxgl-ctrl-geolocate-background-error"), this.fire(new i.Event("trackuserlocationend"));
+                      break;
+                    case "BACKGROUND":
+                      this._watchState = "ACTIVE_LOCK", this._geolocateButton.classList.remove("mapboxgl-ctrl-geolocate-background"), this._lastKnownPosition && this._updateCamera(this._lastKnownPosition), this.fire(new i.Event("trackuserlocationstart"));
+                      break;
+                  }
+                  switch (this._watchState) {
+                    case "WAITING_ACTIVE":
+                      this._geolocateButton.classList.add("mapboxgl-ctrl-geolocate-waiting"), this._geolocateButton.classList.add("mapboxgl-ctrl-geolocate-active");
+                      break;
+                    case "ACTIVE_LOCK":
+                      this._geolocateButton.classList.add("mapboxgl-ctrl-geolocate-active");
+                      break;
+                    case "ACTIVE_ERROR":
+                      this._geolocateButton.classList.add("mapboxgl-ctrl-geolocate-waiting"), this._geolocateButton.classList.add("mapboxgl-ctrl-geolocate-active-error");
+                      break;
+                    case "BACKGROUND":
+                      this._geolocateButton.classList.add("mapboxgl-ctrl-geolocate-background");
+                      break;
+                    case "BACKGROUND_ERROR":
+                      this._geolocateButton.classList.add("mapboxgl-ctrl-geolocate-waiting"), this._geolocateButton.classList.add("mapboxgl-ctrl-geolocate-background-error");
+                      break;
+                  }
+                  if (this._watchState === "OFF" && this._geolocationWatchID !== void 0) this._clearWatch();
+                  else if (this._geolocationWatchID === void 0) {
+                    this._geolocateButton.classList.add("mapboxgl-ctrl-geolocate-waiting"), this._geolocateButton.setAttribute("aria-pressed", "true"), ba++;
+                    var q;
+                    ba > 1 ? (q = { maximumAge: 6e5, timeout: 0 }, is = true) : (q = this.options.positionOptions, is = false), this._geolocationWatchID = i.window.navigator.geolocation.watchPosition(this._onSuccess, this._onError, q);
+                  }
+                } else i.window.navigator.geolocation.getCurrentPosition(this._onSuccess, this._onError, this.options.positionOptions), this._timeoutId = setTimeout(this._finish, 1e4);
+                return true;
+              }, D.prototype._clearWatch = function() {
+                i.window.navigator.geolocation.clearWatch(this._geolocationWatchID), this._geolocationWatchID = void 0, this._geolocateButton.classList.remove("mapboxgl-ctrl-geolocate-waiting"), this._geolocateButton.setAttribute("aria-pressed", "false"), this.options.showUserLocation && this._updateMarker(null);
+              }, D;
+            }(i.Evented), Va = { maxWidth: 100, unit: "metric" }, Ml = function(D) {
+              this.options = i.extend({}, Va, D), i.bindAll(["_onMove", "setUnit"], this);
+            };
+            Ml.prototype.getDefaultPosition = function() {
+              return "bottom-left";
+            }, Ml.prototype._onMove = function() {
+              zo(this._map, this._container, this.options);
+            }, Ml.prototype.onAdd = function(D) {
+              return this._map = D, this._container = o.create("div", "mapboxgl-ctrl mapboxgl-ctrl-scale", D.getContainer()), this._map.on("move", this._onMove), this._onMove(), this._container;
+            }, Ml.prototype.onRemove = function() {
+              o.remove(this._container), this._map.off("move", this._onMove), this._map = void 0;
+            }, Ml.prototype.setUnit = function(D) {
+              this.options.unit = D, zo(this._map, this._container, this.options);
+            };
+            function zo(Y, D, J) {
+              var q = J && J.maxWidth || 100, K = Y._container.clientHeight / 2, de = Y.unproject([0, K]), ne = Y.unproject([q, K]), we = de.distanceTo(ne);
+              if (J && J.unit === "imperial") {
+                var Ue = 3.2808 * we;
+                if (Ue > 5280) {
+                  var ft = Ue / 5280;
+                  Qs(D, q, ft, Y._getUIString("ScaleControl.Miles"));
+                } else Qs(D, q, Ue, Y._getUIString("ScaleControl.Feet"));
+              } else if (J && J.unit === "nautical") {
+                var Zt = we / 1852;
+                Qs(D, q, Zt, Y._getUIString("ScaleControl.NauticalMiles"));
+              } else we >= 1e3 ? Qs(D, q, we / 1e3, Y._getUIString("ScaleControl.Kilometers")) : Qs(D, q, we, Y._getUIString("ScaleControl.Meters"));
+            }
+            function Qs(Y, D, J, q) {
+              var K = Vl(J), de = K / J;
+              Y.style.width = D * de + "px", Y.innerHTML = K + "&nbsp;" + q;
+            }
+            function al(Y) {
+              var D = Math.pow(10, Math.ceil(-Math.log(Y) / Math.LN10));
+              return Math.round(Y * D) / D;
+            }
+            function Vl(Y) {
+              var D = Math.pow(10, ("" + Math.floor(Y)).length - 1), J = Y / D;
+              return J = J >= 10 ? 10 : J >= 5 ? 5 : J >= 3 ? 3 : J >= 2 ? 2 : J >= 1 ? 1 : al(J), D * J;
+            }
+            var ss = function(D) {
+              this._fullscreen = false, D && D.container && (D.container instanceof i.window.HTMLElement ? this._container = D.container : i.warnOnce("Full screen control 'container' must be a DOM element.")), i.bindAll(["_onClickFullscreen", "_changeIcon"], this), "onfullscreenchange" in i.window.document ? this._fullscreenchange = "fullscreenchange" : "onmozfullscreenchange" in i.window.document ? this._fullscreenchange = "mozfullscreenchange" : "onwebkitfullscreenchange" in i.window.document ? this._fullscreenchange = "webkitfullscreenchange" : "onmsfullscreenchange" in i.window.document && (this._fullscreenchange = "MSFullscreenChange");
+            };
+            ss.prototype.onAdd = function(D) {
+              return this._map = D, this._container || (this._container = this._map.getContainer()), this._controlContainer = o.create("div", "mapboxgl-ctrl mapboxgl-ctrl-group"), this._checkFullscreenSupport() ? this._setupUI() : (this._controlContainer.style.display = "none", i.warnOnce("This device does not support fullscreen mode.")), this._controlContainer;
+            }, ss.prototype.onRemove = function() {
+              o.remove(this._controlContainer), this._map = null, i.window.document.removeEventListener(this._fullscreenchange, this._changeIcon);
+            }, ss.prototype._checkFullscreenSupport = function() {
+              return !!(i.window.document.fullscreenEnabled || i.window.document.mozFullScreenEnabled || i.window.document.msFullscreenEnabled || i.window.document.webkitFullscreenEnabled);
+            }, ss.prototype._setupUI = function() {
+              var D = this._fullscreenButton = o.create("button", "mapboxgl-ctrl-fullscreen", this._controlContainer);
+              o.create("span", "mapboxgl-ctrl-icon", D).setAttribute("aria-hidden", true), D.type = "button", this._updateTitle(), this._fullscreenButton.addEventListener("click", this._onClickFullscreen), i.window.document.addEventListener(this._fullscreenchange, this._changeIcon);
+            }, ss.prototype._updateTitle = function() {
+              var D = this._getTitle();
+              this._fullscreenButton.setAttribute("aria-label", D), this._fullscreenButton.title = D;
+            }, ss.prototype._getTitle = function() {
+              return this._map._getUIString(this._isFullscreen() ? "FullscreenControl.Exit" : "FullscreenControl.Enter");
+            }, ss.prototype._isFullscreen = function() {
+              return this._fullscreen;
+            }, ss.prototype._changeIcon = function() {
+              var D = i.window.document.fullscreenElement || i.window.document.mozFullScreenElement || i.window.document.webkitFullscreenElement || i.window.document.msFullscreenElement;
+              D === this._container !== this._fullscreen && (this._fullscreen = !this._fullscreen, this._fullscreenButton.classList.toggle("mapboxgl-ctrl-shrink"), this._fullscreenButton.classList.toggle("mapboxgl-ctrl-fullscreen"), this._updateTitle());
+            }, ss.prototype._onClickFullscreen = function() {
+              this._isFullscreen() ? i.window.document.exitFullscreen ? i.window.document.exitFullscreen() : i.window.document.mozCancelFullScreen ? i.window.document.mozCancelFullScreen() : i.window.document.msExitFullscreen ? i.window.document.msExitFullscreen() : i.window.document.webkitCancelFullScreen && i.window.document.webkitCancelFullScreen() : this._container.requestFullscreen ? this._container.requestFullscreen() : this._container.mozRequestFullScreen ? this._container.mozRequestFullScreen() : this._container.msRequestFullscreen ? this._container.msRequestFullscreen() : this._container.webkitRequestFullscreen && this._container.webkitRequestFullscreen();
+            };
+            var Vs = { closeButton: true, closeOnClick: true, focusAfterOpen: true, className: "", maxWidth: "240px" }, Ys = ["a[href]", "[tabindex]:not([tabindex='-1'])", "[contenteditable]:not([contenteditable='false'])", "button:not([disabled])", "input:not([disabled])", "select:not([disabled])", "textarea:not([disabled])"].join(", "), wa = function(Y) {
+              function D(J) {
+                Y.call(this), this.options = i.extend(Object.create(Vs), J), i.bindAll(["_update", "_onClose", "remove", "_onMouseMove", "_onMouseUp", "_onDrag"], this);
+              }
+              return Y && (D.__proto__ = Y), D.prototype = Object.create(Y && Y.prototype), D.prototype.constructor = D, D.prototype.addTo = function(q) {
+                return this._map && this.remove(), this._map = q, this.options.closeOnClick && this._map.on("click", this._onClose), this.options.closeOnMove && this._map.on("move", this._onClose), this._map.on("remove", this.remove), this._update(), this._focusFirstElement(), this._trackPointer ? (this._map.on("mousemove", this._onMouseMove), this._map.on("mouseup", this._onMouseUp), this._container && this._container.classList.add("mapboxgl-popup-track-pointer"), this._map._canvasContainer.classList.add("mapboxgl-track-pointer")) : this._map.on("move", this._update), this.fire(new i.Event("open")), this;
+              }, D.prototype.isOpen = function() {
+                return !!this._map;
+              }, D.prototype.remove = function() {
+                return this._content && o.remove(this._content), this._container && (o.remove(this._container), delete this._container), this._map && (this._map.off("move", this._update), this._map.off("move", this._onClose), this._map.off("click", this._onClose), this._map.off("remove", this.remove), this._map.off("mousemove", this._onMouseMove), this._map.off("mouseup", this._onMouseUp), this._map.off("drag", this._onDrag), delete this._map), this.fire(new i.Event("close")), this;
+              }, D.prototype.getLngLat = function() {
+                return this._lngLat;
+              }, D.prototype.setLngLat = function(q) {
+                return this._lngLat = i.LngLat.convert(q), this._pos = null, this._trackPointer = false, this._update(), this._map && (this._map.on("move", this._update), this._map.off("mousemove", this._onMouseMove), this._container && this._container.classList.remove("mapboxgl-popup-track-pointer"), this._map._canvasContainer.classList.remove("mapboxgl-track-pointer")), this;
+              }, D.prototype.trackPointer = function() {
+                return this._trackPointer = true, this._pos = null, this._update(), this._map && (this._map.off("move", this._update), this._map.on("mousemove", this._onMouseMove), this._map.on("drag", this._onDrag), this._container && this._container.classList.add("mapboxgl-popup-track-pointer"), this._map._canvasContainer.classList.add("mapboxgl-track-pointer")), this;
+              }, D.prototype.getElement = function() {
+                return this._container;
+              }, D.prototype.setText = function(q) {
+                return this.setDOMContent(i.window.document.createTextNode(q));
+              }, D.prototype.setHTML = function(q) {
+                var K = i.window.document.createDocumentFragment(), de = i.window.document.createElement("body"), ne;
+                for (de.innerHTML = q; ne = de.firstChild, !!ne; ) K.appendChild(ne);
+                return this.setDOMContent(K);
+              }, D.prototype.getMaxWidth = function() {
+                return this._container && this._container.style.maxWidth;
+              }, D.prototype.setMaxWidth = function(q) {
+                return this.options.maxWidth = q, this._update(), this;
+              }, D.prototype.setDOMContent = function(q) {
+                if (this._content) for (; this._content.hasChildNodes(); ) this._content.firstChild && this._content.removeChild(this._content.firstChild);
+                else this._content = o.create("div", "mapboxgl-popup-content", this._container);
+                return this._content.appendChild(q), this._createCloseButton(), this._update(), this._focusFirstElement(), this;
+              }, D.prototype.addClassName = function(q) {
+                this._container && this._container.classList.add(q);
+              }, D.prototype.removeClassName = function(q) {
+                this._container && this._container.classList.remove(q);
+              }, D.prototype.setOffset = function(q) {
+                return this.options.offset = q, this._update(), this;
+              }, D.prototype.toggleClassName = function(q) {
+                if (this._container) return this._container.classList.toggle(q);
+              }, D.prototype._createCloseButton = function() {
+                this.options.closeButton && (this._closeButton = o.create("button", "mapboxgl-popup-close-button", this._content), this._closeButton.type = "button", this._closeButton.setAttribute("aria-label", "Close popup"), this._closeButton.innerHTML = "&#215;", this._closeButton.addEventListener("click", this._onClose));
+              }, D.prototype._onMouseUp = function(q) {
+                this._update(q.point);
+              }, D.prototype._onMouseMove = function(q) {
+                this._update(q.point);
+              }, D.prototype._onDrag = function(q) {
+                this._update(q.point);
+              }, D.prototype._update = function(q) {
+                var K = this, de = this._lngLat || this._trackPointer;
+                if (!(!this._map || !de || !this._content) && (this._container || (this._container = o.create("div", "mapboxgl-popup", this._map.getContainer()), this._tip = o.create("div", "mapboxgl-popup-tip", this._container), this._container.appendChild(this._content), this.options.className && this.options.className.split(" ").forEach(function(Ve) {
+                  return K._container.classList.add(Ve);
+                }), this._trackPointer && this._container.classList.add("mapboxgl-popup-track-pointer")), this.options.maxWidth && this._container.style.maxWidth !== this.options.maxWidth && (this._container.style.maxWidth = this.options.maxWidth), this._map.transform.renderWorldCopies && !this._trackPointer && (this._lngLat = pn(this._lngLat, this._pos, this._map.transform)), !(this._trackPointer && !q))) {
+                  var ne = this._pos = this._trackPointer && q ? q : this._map.project(this._lngLat), we = this.options.anchor, Ue = ol(this.options.offset);
+                  if (!we) {
+                    var ft = this._container.offsetWidth, Zt = this._container.offsetHeight, hr;
+                    ne.y + Ue.bottom.y < Zt ? hr = ["top"] : ne.y > this._map.transform.height - Zt ? hr = ["bottom"] : hr = [], ne.x < ft / 2 ? hr.push("left") : ne.x > this._map.transform.width - ft / 2 && hr.push("right"), hr.length === 0 ? we = "bottom" : we = hr.join("-");
+                  }
+                  var qt = ne.add(Ue[we]).round();
+                  o.setTransform(this._container, Vn[we] + " translate(" + qt.x + "px," + qt.y + "px)"), na(this._container, we, "popup");
+                }
+              }, D.prototype._focusFirstElement = function() {
+                if (!(!this.options.focusAfterOpen || !this._container)) {
+                  var q = this._container.querySelector(Ys);
+                  q && q.focus();
+                }
+              }, D.prototype._onClose = function() {
+                this.remove();
+              }, D;
+            }(i.Evented);
+            function ol(Y) {
+              if (Y) if (typeof Y == "number") {
+                var D = Math.round(Math.sqrt(0.5 * Math.pow(Y, 2)));
+                return { center: new i.Point(0, 0), top: new i.Point(0, Y), "top-left": new i.Point(D, D), "top-right": new i.Point(-D, D), bottom: new i.Point(0, -Y), "bottom-left": new i.Point(D, -D), "bottom-right": new i.Point(-D, -D), left: new i.Point(Y, 0), right: new i.Point(-Y, 0) };
+              } else if (Y instanceof i.Point || Array.isArray(Y)) {
+                var J = i.Point.convert(Y);
+                return { center: J, top: J, "top-left": J, "top-right": J, bottom: J, "bottom-left": J, "bottom-right": J, left: J, right: J };
+              } else return { center: i.Point.convert(Y.center || [0, 0]), top: i.Point.convert(Y.top || [0, 0]), "top-left": i.Point.convert(Y["top-left"] || [0, 0]), "top-right": i.Point.convert(Y["top-right"] || [0, 0]), bottom: i.Point.convert(Y.bottom || [0, 0]), "bottom-left": i.Point.convert(Y["bottom-left"] || [0, 0]), "bottom-right": i.Point.convert(Y["bottom-right"] || [0, 0]), left: i.Point.convert(Y.left || [0, 0]), right: i.Point.convert(Y.right || [0, 0]) };
+              else return ol(new i.Point(0, 0));
+            }
+            var io = { version: i.version, supported: a, setRTLTextPlugin: i.setRTLTextPlugin, getRTLTextPluginStatus: i.getRTLTextPluginStatus, Map: li, NavigationControl: Vi, GeolocateControl: Zs, AttributionControl: en, ScaleControl: Ml, FullscreenControl: ss, Popup: wa, Marker: Ki, Style: yu, LngLat: i.LngLat, LngLatBounds: i.LngLatBounds, Point: i.Point, MercatorCoordinate: i.MercatorCoordinate, Evented: i.Evented, config: i.config, prewarm: ua, clearPrewarmedResources: ma, get accessToken() {
+              return i.config.ACCESS_TOKEN;
+            }, set accessToken(Y) {
+              i.config.ACCESS_TOKEN = Y;
+            }, get baseApiUrl() {
+              return i.config.API_URL;
+            }, set baseApiUrl(Y) {
+              i.config.API_URL = Y;
+            }, get workerCount() {
+              return fn.workerCount;
+            }, set workerCount(Y) {
+              fn.workerCount = Y;
+            }, get maxParallelImageRequests() {
+              return i.config.MAX_PARALLEL_IMAGE_REQUESTS;
+            }, set maxParallelImageRequests(Y) {
+              i.config.MAX_PARALLEL_IMAGE_REQUESTS = Y;
+            }, clearStorage: function(D) {
+              i.clearTileCache(D);
+            }, workerUrl: "" };
+            return io;
+          }), r;
+        });
+      });
+      var yGe = ye((Pxr, mGe) => {
+        var hw = Dr(), Wjt = Zl().sanitizeHTML, Xjt = cJ(), vGe = m1();
+        function pGe(e, t) {
+          this.subplot = e, this.uid = e.uid + "-" + t, this.index = t, this.idSource = "source-" + this.uid, this.idLayer = vGe.layoutLayerPrefix + this.uid, this.sourceType = null, this.source = null, this.layerType = null, this.below = null, this.visible = false;
+        }
+        var ag = pGe.prototype;
+        ag.update = function(t) {
+          this.visible ? this.needsNewImage(t) ? this.updateImage(t) : this.needsNewSource(t) ? (this.removeLayer(), this.updateSource(t), this.updateLayer(t)) : this.needsNewLayer(t) ? this.updateLayer(t) : this.updateStyle(t) : (this.updateSource(t), this.updateLayer(t)), this.visible = r7(t);
+        };
+        ag.needsNewImage = function(e) {
+          var t = this.subplot.map;
+          return t.getSource(this.idSource) && this.sourceType === "image" && e.sourcetype === "image" && (this.source !== e.source || JSON.stringify(this.coordinates) !== JSON.stringify(e.coordinates));
+        };
+        ag.needsNewSource = function(e) {
+          return this.sourceType !== e.sourcetype || JSON.stringify(this.source) !== JSON.stringify(e.source) || this.layerType !== e.type;
+        };
+        ag.needsNewLayer = function(e) {
+          return this.layerType !== e.type || this.below !== this.subplot.belowLookup["layout-" + this.index];
+        };
+        ag.lookupBelow = function() {
+          return this.subplot.belowLookup["layout-" + this.index];
+        };
+        ag.updateImage = function(e) {
+          var t = this.subplot.map;
+          t.getSource(this.idSource).updateImage({ url: e.source, coordinates: e.coordinates });
+          var r = this.findFollowingMapboxLayerId(this.lookupBelow());
+          r !== null && this.subplot.map.moveLayer(this.idLayer, r);
+        };
+        ag.updateSource = function(e) {
+          var t = this.subplot.map;
+          if (t.getSource(this.idSource) && t.removeSource(this.idSource), this.sourceType = e.sourcetype, this.source = e.source, !!r7(e)) {
+            var r = Zjt(e);
+            t.addSource(this.idSource, r);
+          }
+        };
+        ag.findFollowingMapboxLayerId = function(e) {
+          if (e === "traces") for (var t = this.subplot.getMapLayers(), r = 0; r < t.length; r++) {
+            var n = t[r].id;
+            if (typeof n == "string" && n.indexOf(vGe.traceLayerPrefix) === 0) {
+              e = n;
+              break;
+            }
+          }
+          return e;
+        };
+        ag.updateLayer = function(e) {
+          var t = this.subplot, r = gGe(e), n = this.lookupBelow(), i = this.findFollowingMapboxLayerId(n);
+          this.removeLayer(), r7(e) && t.addLayer({ id: this.idLayer, source: this.idSource, "source-layer": e.sourcelayer || "", type: e.type, minzoom: e.minzoom, maxzoom: e.maxzoom, layout: r.layout, paint: r.paint }, i), this.layerType = e.type, this.below = n;
+        };
+        ag.updateStyle = function(e) {
+          if (r7(e)) {
+            var t = gGe(e);
+            this.subplot.setOptions(this.idLayer, "setLayoutProperty", t.layout), this.subplot.setOptions(this.idLayer, "setPaintProperty", t.paint);
+          }
+        };
+        ag.removeLayer = function() {
+          var e = this.subplot.map;
+          e.getLayer(this.idLayer) && e.removeLayer(this.idLayer);
+        };
+        ag.dispose = function() {
+          var e = this.subplot.map;
+          e.getLayer(this.idLayer) && e.removeLayer(this.idLayer), e.getSource(this.idSource) && e.removeSource(this.idSource);
+        };
+        function r7(e) {
+          if (!e.visible) return false;
+          var t = e.source;
+          if (Array.isArray(t) && t.length > 0) {
+            for (var r = 0; r < t.length; r++) if (typeof t[r] != "string" || t[r].length === 0) return false;
+            return true;
+          }
+          return hw.isPlainObject(t) || typeof t == "string" && t.length > 0;
+        }
+        function gGe(e) {
+          var t = {}, r = {};
+          switch (e.type) {
+            case "circle":
+              hw.extendFlat(r, { "circle-radius": e.circle.radius, "circle-color": e.color, "circle-opacity": e.opacity });
+              break;
+            case "line":
+              hw.extendFlat(r, { "line-width": e.line.width, "line-color": e.color, "line-opacity": e.opacity, "line-dasharray": e.line.dash });
+              break;
+            case "fill":
+              hw.extendFlat(r, { "fill-color": e.color, "fill-outline-color": e.fill.outlinecolor, "fill-opacity": e.opacity });
+              break;
+            case "symbol":
+              var n = e.symbol, i = Xjt(n.textposition, n.iconsize);
+              hw.extendFlat(t, { "icon-image": n.icon + "-15", "icon-size": n.iconsize / 10, "text-field": n.text, "text-size": n.textfont.size, "text-anchor": i.anchor, "text-offset": i.offset, "symbol-placement": n.placement }), hw.extendFlat(r, { "icon-color": e.color, "text-color": n.textfont.color, "text-opacity": e.opacity });
+              break;
+            case "raster":
+              hw.extendFlat(r, { "raster-fade-duration": 0, "raster-opacity": e.opacity });
+              break;
+          }
+          return { layout: t, paint: r };
+        }
+        function Zjt(e) {
+          var t = e.sourcetype, r = e.source, n = { type: t }, i;
+          return t === "geojson" ? i = "data" : t === "vector" ? i = typeof r == "string" ? "url" : "tiles" : t === "raster" ? (i = "tiles", n.tileSize = 256) : t === "image" && (i = "url", n.coordinates = e.coordinates), n[i] = r, e.sourceattribution && (n.attribution = Wjt(e.sourceattribution)), n;
+        }
+        mGe.exports = function(t, r, n) {
+          var i = new pGe(t, r);
+          return i.update(n), i;
+        };
+      });
+      var EGe = ye((Ixr, MGe) => {
+        var mJ = gJ(), yJ = Dr(), wGe = hx(), _Ge = qa(), Yjt = ho(), Kjt = yv(), i7 = vf(), TGe = Cg(), Jjt = TGe.drawMode, $jt = TGe.selectMode, Qjt = Of().prepSelect, eWt = Of().clearOutline, tWt = Of().clearSelectionsCache, rWt = Of().selectOnClick, kx = m1(), iWt = yGe();
+        function AGe(e, t) {
+          this.id = t, this.gd = e;
+          var r = e._fullLayout, n = e._context;
+          this.container = r._glcontainer.node(), this.isStatic = n.staticPlot, this.uid = r._uid + "-" + this.id, this.div = null, this.xaxis = null, this.yaxis = null, this.createFramework(r), this.map = null, this.accessToken = null, this.styleObj = null, this.traceHash = {}, this.layerList = [], this.belowLookup = {}, this.dragging = false, this.wheeling = false;
+        }
+        var Gh = AGe.prototype;
+        Gh.plot = function(e, t, r) {
+          var n = this, i = t[n.id];
+          n.map && i.accesstoken !== n.accessToken && (n.map.remove(), n.map = null, n.styleObj = null, n.traceHash = {}, n.layerList = []);
+          var a;
+          n.map ? a = new Promise(function(o, s) {
+            n.updateMap(e, t, o, s);
+          }) : a = new Promise(function(o, s) {
+            n.createMap(e, t, o, s);
+          }), r.push(a);
+        };
+        Gh.createMap = function(e, t, r, n) {
+          var i = this, a = t[i.id], o = i.styleObj = SGe(a.style, t);
+          i.accessToken = a.accesstoken;
+          var s = a.bounds, l = s ? [[s.west, s.south], [s.east, s.north]] : null, u = i.map = new mJ.Map({ container: i.div, style: o.style, center: _J(a.center), zoom: a.zoom, bearing: a.bearing, pitch: a.pitch, maxBounds: l, interactive: !i.isStatic, preserveDrawingBuffer: i.isStatic, doubleClickZoom: false, boxZoom: false, attributionControl: false }).addControl(new mJ.AttributionControl({ compact: true }));
+          u._canvas.style.left = "0px", u._canvas.style.top = "0px", i.rejectOnError(n), i.isStatic || i.initFx(e, t);
+          var c = [];
+          c.push(new Promise(function(f) {
+            u.once("load", f);
+          })), c = c.concat(wGe.fetchTraceGeoData(e)), Promise.all(c).then(function() {
+            i.fillBelowLookup(e, t), i.updateData(e), i.updateLayout(t), i.resolveOnRender(r);
+          }).catch(n);
+        };
+        Gh.updateMap = function(e, t, r, n) {
+          var i = this, a = i.map, o = t[this.id];
+          i.rejectOnError(n);
+          var s = [], l = SGe(o.style, t);
+          JSON.stringify(i.styleObj) !== JSON.stringify(l) && (i.styleObj = l, a.setStyle(l.style), i.traceHash = {}, s.push(new Promise(function(u) {
+            a.once("styledata", u);
+          }))), s = s.concat(wGe.fetchTraceGeoData(e)), Promise.all(s).then(function() {
+            i.fillBelowLookup(e, t), i.updateData(e), i.updateLayout(t), i.resolveOnRender(r);
+          }).catch(n);
+        };
+        Gh.fillBelowLookup = function(e, t) {
+          var r = t[this.id], n = r.layers, i, a, o = this.belowLookup = {}, s = false;
+          for (i = 0; i < e.length; i++) {
+            var l = e[i][0].trace, u = l._module;
+            typeof l.below == "string" ? a = l.below : u.getBelow && (a = u.getBelow(l, this)), a === "" && (s = true), o["trace-" + l.uid] = a || "";
+          }
+          for (i = 0; i < n.length; i++) {
+            var c = n[i];
+            typeof c.below == "string" ? a = c.below : s ? a = "traces" : a = "", o["layout-" + i] = a;
+          }
+          var f = {}, h, d;
+          for (h in o) a = o[h], f[a] ? f[a].push(h) : f[a] = [h];
+          for (a in f) {
+            var v = f[a];
+            if (v.length > 1) for (i = 0; i < v.length; i++) h = v[i], h.indexOf("trace-") === 0 ? (d = h.split("trace-")[1], this.traceHash[d] && (this.traceHash[d].below = null)) : h.indexOf("layout-") === 0 && (d = h.split("layout-")[1], this.layerList[d] && (this.layerList[d].below = null));
+          }
+        };
+        var xGe = { choroplethmapbox: 0, densitymapbox: 1, scattermapbox: 2 };
+        Gh.updateData = function(e) {
+          var t = this.traceHash, r, n, i, a, o = e.slice().sort(function(f, h) {
+            return xGe[f[0].trace.type] - xGe[h[0].trace.type];
+          });
+          for (i = 0; i < o.length; i++) {
+            var s = o[i];
+            n = s[0].trace, r = t[n.uid];
+            var l = false;
+            r && (r.type === n.type ? (r.update(s), l = true) : r.dispose()), !l && n._module && (t[n.uid] = n._module.plot(this, s));
+          }
+          var u = Object.keys(t);
+          e: for (i = 0; i < u.length; i++) {
+            var c = u[i];
+            for (a = 0; a < e.length; a++) if (n = e[a][0].trace, c === n.uid) continue e;
+            r = t[c], r.dispose(), delete t[c];
+          }
+        };
+        Gh.updateLayout = function(e) {
+          var t = this.map, r = e[this.id];
+          !this.dragging && !this.wheeling && (t.setCenter(_J(r.center)), t.setZoom(r.zoom), t.setBearing(r.bearing), t.setPitch(r.pitch)), this.updateLayers(e), this.updateFramework(e), this.updateFx(e), this.map.resize(), this.gd._context._scrollZoom.mapbox ? t.scrollZoom.enable() : t.scrollZoom.disable();
+        };
+        Gh.resolveOnRender = function(e) {
+          var t = this.map;
+          t.on("render", function r() {
+            t.loaded() && (t.off("render", r), setTimeout(e, 10));
+          });
+        };
+        Gh.rejectOnError = function(e) {
+          var t = this.map;
+          function r() {
+            e(new Error(kx.mapOnErrorMsg));
+          }
+          t.once("error", r), t.once("style.error", r), t.once("source.error", r), t.once("tile.error", r), t.once("layer.error", r);
+        };
+        Gh.createFramework = function(e) {
+          var t = this, r = t.div = document.createElement("div");
+          r.id = t.uid, r.style.position = "absolute", t.container.appendChild(r), t.xaxis = { _id: "x", c2p: function(n) {
+            return t.project(n).x;
+          } }, t.yaxis = { _id: "y", c2p: function(n) {
+            return t.project(n).y;
+          } }, t.updateFramework(e), t.mockAxis = { type: "linear", showexponent: "all", exponentformat: "B" }, Yjt.setConvert(t.mockAxis, e);
+        };
+        Gh.initFx = function(e, t) {
+          var r = this, n = r.gd, i = r.map;
+          i.on("moveend", function(s) {
+            if (r.map) {
+              var l = n._fullLayout;
+              if (s.originalEvent || r.wheeling) {
+                var u = l[r.id];
+                _Ge.call("_storeDirectGUIEdit", n.layout, l._preGUI, r.getViewEdits(u));
+                var c = r.getView();
+                u._input.center = u.center = c.center, u._input.zoom = u.zoom = c.zoom, u._input.bearing = u.bearing = c.bearing, u._input.pitch = u.pitch = c.pitch, n.emit("plotly_relayout", r.getViewEditsWithDerived(c));
+              }
+              s.originalEvent && s.originalEvent.type === "mouseup" ? r.dragging = false : r.wheeling && (r.wheeling = false), l._rehover && l._rehover();
+            }
+          }), i.on("wheel", function() {
+            r.wheeling = true;
+          }), i.on("mousemove", function(s) {
+            var l = r.div.getBoundingClientRect(), u = [s.originalEvent.offsetX, s.originalEvent.offsetY];
+            s.target.getBoundingClientRect = function() {
+              return l;
+            }, r.xaxis.p2c = function() {
+              return i.unproject(u).lng;
+            }, r.yaxis.p2c = function() {
+              return i.unproject(u).lat;
+            }, n._fullLayout._rehover = function() {
+              n._fullLayout._hoversubplot === r.id && n._fullLayout[r.id] && i7.hover(n, s, r.id);
+            }, i7.hover(n, s, r.id), n._fullLayout._hoversubplot = r.id;
+          });
+          function a() {
+            i7.loneUnhover(t._hoverlayer);
+          }
+          i.on("dragstart", function() {
+            r.dragging = true, a();
+          }), i.on("zoomstart", a), i.on("mouseout", function() {
+            n._fullLayout._hoversubplot = null;
+          });
+          function o() {
+            var s = r.getView();
+            n.emit("plotly_relayouting", r.getViewEditsWithDerived(s));
+          }
+          i.on("drag", o), i.on("zoom", o), i.on("dblclick", function() {
+            var s = n._fullLayout[r.id];
+            _Ge.call("_storeDirectGUIEdit", n.layout, n._fullLayout._preGUI, r.getViewEdits(s));
+            var l = r.viewInitial;
+            i.setCenter(_J(l.center)), i.setZoom(l.zoom), i.setBearing(l.bearing), i.setPitch(l.pitch);
+            var u = r.getView();
+            s._input.center = s.center = u.center, s._input.zoom = s.zoom = u.zoom, s._input.bearing = s.bearing = u.bearing, s._input.pitch = s.pitch = u.pitch, n.emit("plotly_doubleclick", null), n.emit("plotly_relayout", r.getViewEditsWithDerived(u));
+          }), r.clearOutline = function() {
+            tWt(r.dragOptions), eWt(r.dragOptions.gd);
+          }, r.onClickInPanFn = function(s) {
+            return function(l) {
+              var u = n._fullLayout.clickmode;
+              u.indexOf("select") > -1 && rWt(l.originalEvent, n, [r.xaxis], [r.yaxis], r.id, s), u.indexOf("event") > -1 && i7.click(n, l.originalEvent);
+            };
+          };
+        };
+        Gh.updateFx = function(e) {
+          var t = this, r = t.map, n = t.gd;
+          if (t.isStatic) return;
+          function i(l) {
+            var u = t.map.unproject(l);
+            return [u.lng, u.lat];
+          }
+          var a = e.dragmode, o;
+          o = function(l, u) {
+            if (u.isRect) {
+              var c = l.range = {};
+              c[t.id] = [i([u.xmin, u.ymin]), i([u.xmax, u.ymax])];
+            } else {
+              var f = l.lassoPoints = {};
+              f[t.id] = u.map(i);
+            }
+          };
+          var s = t.dragOptions;
+          t.dragOptions = yJ.extendDeep(s || {}, { dragmode: e.dragmode, element: t.div, gd: n, plotinfo: { id: t.id, domain: e[t.id].domain, xaxis: t.xaxis, yaxis: t.yaxis, fillRangeItems: o }, xaxes: [t.xaxis], yaxes: [t.yaxis], subplot: t.id }), r.off("click", t.onClickInPanHandler), $jt(a) || Jjt(a) ? (r.dragPan.disable(), r.on("zoomstart", t.clearOutline), t.dragOptions.prepFn = function(l, u, c) {
+            Qjt(l, u, c, t.dragOptions, a);
+          }, Kjt.init(t.dragOptions)) : (r.dragPan.enable(), r.off("zoomstart", t.clearOutline), t.div.onmousedown = null, t.div.ontouchstart = null, t.div.removeEventListener("touchstart", t.div._ontouchstart), t.onClickInPanHandler = t.onClickInPanFn(t.dragOptions), r.on("click", t.onClickInPanHandler));
+        };
+        Gh.updateFramework = function(e) {
+          var t = e[this.id].domain, r = e._size, n = this.div.style;
+          n.width = r.w * (t.x[1] - t.x[0]) + "px", n.height = r.h * (t.y[1] - t.y[0]) + "px", n.left = r.l + t.x[0] * r.w + "px", n.top = r.t + (1 - t.y[1]) * r.h + "px", this.xaxis._offset = r.l + t.x[0] * r.w, this.xaxis._length = r.w * (t.x[1] - t.x[0]), this.yaxis._offset = r.t + (1 - t.y[1]) * r.h, this.yaxis._length = r.h * (t.y[1] - t.y[0]);
+        };
+        Gh.updateLayers = function(e) {
+          var t = e[this.id], r = t.layers, n = this.layerList, i;
+          if (r.length !== n.length) {
+            for (i = 0; i < n.length; i++) n[i].dispose();
+            for (n = this.layerList = [], i = 0; i < r.length; i++) n.push(iWt(this, i, r[i]));
+          } else for (i = 0; i < r.length; i++) n[i].update(r[i]);
+        };
+        Gh.destroy = function() {
+          this.map && (this.map.remove(), this.map = null, this.container.removeChild(this.div));
+        };
+        Gh.toImage = function() {
+          return this.map.stop(), this.map.getCanvas().toDataURL();
+        };
+        Gh.setOptions = function(e, t, r) {
+          for (var n in r) this.map[t](e, n, r[n]);
+        };
+        Gh.getMapLayers = function() {
+          return this.map.getStyle().layers;
+        };
+        Gh.addLayer = function(e, t) {
+          var r = this.map;
+          if (typeof t == "string") {
+            if (t === "") {
+              r.addLayer(e, t);
+              return;
+            }
+            for (var n = this.getMapLayers(), i = 0; i < n.length; i++) if (t === n[i].id) {
+              r.addLayer(e, t);
+              return;
+            }
+            yJ.warn(["Trying to add layer with *below* value", t, "referencing a layer that does not exist", "or that does not yet exist."].join(" "));
+          }
+          r.addLayer(e);
+        };
+        Gh.project = function(e) {
+          return this.map.project(new mJ.LngLat(e[0], e[1]));
+        };
+        Gh.getView = function() {
+          var e = this.map, t = e.getCenter(), r = t.lng, n = t.lat, i = { lon: r, lat: n }, a = e.getCanvas(), o = parseInt(a.style.width), s = parseInt(a.style.height);
+          return { center: i, zoom: e.getZoom(), bearing: e.getBearing(), pitch: e.getPitch(), _derived: { coordinates: [e.unproject([0, 0]).toArray(), e.unproject([o, 0]).toArray(), e.unproject([o, s]).toArray(), e.unproject([0, s]).toArray()] } };
+        };
+        Gh.getViewEdits = function(e) {
+          for (var t = this.id, r = ["center", "zoom", "bearing", "pitch"], n = {}, i = 0; i < r.length; i++) {
+            var a = r[i];
+            n[t + "." + a] = e[a];
+          }
+          return n;
+        };
+        Gh.getViewEditsWithDerived = function(e) {
+          var t = this.id, r = this.getViewEdits(e);
+          return r[t + "._derived"] = e._derived, r;
+        };
+        function SGe(e, t) {
+          var r = {};
+          if (yJ.isPlainObject(e)) r.id = e.id, r.style = e;
+          else if (typeof e == "string") if (r.id = e, kx.styleValuesMapbox.indexOf(e) !== -1) r.style = bGe(e);
+          else if (kx.stylesNonMapbox[e]) {
+            r.style = kx.stylesNonMapbox[e];
+            var n = r.style.sources["plotly-" + e], i = n ? n.tiles : void 0;
+            i && i[0] && i[0].slice(-9) === "?api_key=" && (i[0] += t._mapboxAccessToken);
+          } else r.style = e;
+          else r.id = kx.styleValueDflt, r.style = bGe(kx.styleValueDflt);
+          return r.transition = { duration: 0, delay: 0 }, r;
+        }
+        function bGe(e) {
+          return kx.styleUrlPrefix + e + "-" + kx.styleUrlSuffix;
+        }
+        function _J(e) {
+          return [e.lon, e.lat];
+        }
+        MGe.exports = AGe;
+      });
+      var LGe = ye((Rxr, CGe) => {
+        var xJ = Dr(), nWt = O_(), aWt = Zd(), kGe = Zk();
+        CGe.exports = function(t, r, n) {
+          nWt(t, r, n, { type: "mapbox", attributes: kGe, handleDefaults: oWt, partition: "y", accessToken: r._mapboxAccessToken });
+        };
+        function oWt(e, t, r, n) {
+          r("accesstoken", n.accessToken), r("style"), r("center.lon"), r("center.lat"), r("zoom"), r("bearing"), r("pitch");
+          var i = r("bounds.west"), a = r("bounds.east"), o = r("bounds.south"), s = r("bounds.north");
+          (i === void 0 || a === void 0 || o === void 0 || s === void 0) && delete t.bounds, aWt(e, t, { name: "layers", handleItemDefaults: sWt }), t._input = e;
+        }
+        function sWt(e, t) {
+          function r(l, u) {
+            return xJ.coerce(e, t, kGe.layers, l, u);
+          }
+          var n = r("visible");
+          if (n) {
+            var i = r("sourcetype"), a = i === "raster" || i === "image";
+            r("source"), r("sourceattribution"), i === "vector" && r("sourcelayer"), i === "image" && r("coordinates");
+            var o;
+            a && (o = "raster");
+            var s = r("type", o);
+            a && s !== "raster" && (s = t.type = "raster", xJ.log("Source types *raster* and *image* must drawn *raster* layer type.")), r("below"), r("color"), r("opacity"), r("minzoom"), r("maxzoom"), s === "circle" && r("circle.radius"), s === "line" && (r("line.width"), r("line.dash")), s === "fill" && r("fill.outlinecolor"), s === "symbol" && (r("symbol.icon"), r("symbol.iconsize"), r("symbol.text"), xJ.coerceFont(r, "symbol.textfont", void 0, { noFontVariant: true, noFontShadow: true, noFontLineposition: true, noFontTextcase: true }), r("symbol.textposition"), r("symbol.placement"));
+          }
+        }
+      });
+      var n7 = ye((Np) => {
+        var PGe = gJ(), nm = Dr(), bJ = nm.strTranslate, lWt = nm.strScale, uWt = Id().getSubplotCalcData, cWt = Wp(), fWt = Oa(), IGe = So(), hWt = Zl(), dWt = EGe(), Cx = "mapbox", oy = Np.constants = m1();
+        Np.name = Cx;
+        Np.attr = "subplot";
+        Np.idRoot = Cx;
+        Np.idRegex = Np.attrRegex = nm.counterRegex(Cx);
+        var vWt = ["mapbox subplots and traces are deprecated!", "Please consider switching to `map` subplots and traces.", "Learn more at: https://plotly.com/python/maplibre-migration/", "as well as https://plotly.com/javascript/maplibre-migration/"].join(" ");
+        Np.attributes = { subplot: { valType: "subplotid", dflt: "mapbox", editType: "calc" } };
+        Np.layoutAttributes = Zk();
+        Np.supplyLayoutDefaults = LGe();
+        var RGe = true;
+        Np.plot = function(t) {
+          RGe && (RGe = false, nm.warn(vWt));
+          var r = t._fullLayout, n = t.calcdata, i = r._subplots[Cx];
+          if (PGe.version !== oy.requiredVersion) throw new Error(oy.wrongVersionErrorMsg);
+          var a = pWt(t, i);
+          PGe.accessToken = a;
+          for (var o = 0; o < i.length; o++) {
+            var s = i[o], l = uWt(n, Cx, s), u = r[s], c = u._subplot;
+            c || (c = new dWt(t, s), r[s]._subplot = c), c.viewInitial || (c.viewInitial = { center: nm.extendFlat({}, u.center), zoom: u.zoom, bearing: u.bearing, pitch: u.pitch }), c.plot(l, r, t._promises);
+          }
+        };
+        Np.clean = function(e, t, r, n) {
+          for (var i = n._subplots[Cx] || [], a = 0; a < i.length; a++) {
+            var o = i[a];
+            !t[o] && n[o]._subplot && n[o]._subplot.destroy();
+          }
+        };
+        Np.toSVG = function(e) {
+          for (var t = e._fullLayout, r = t._subplots[Cx], n = t._size, i = 0; i < r.length; i++) {
+            var a = t[r[i]], o = a.domain, s = a._subplot, l = s.toImage("png"), u = t._glimages.append("svg:image");
+            u.attr({ xmlns: cWt.svg, "xlink:href": l, x: n.l + n.w * o.x[0], y: n.t + n.h * (1 - o.y[1]), width: n.w * (o.x[1] - o.x[0]), height: n.h * (o.y[1] - o.y[0]), preserveAspectRatio: "none" });
+            var c = fWt.select(a._subplot.div), f = c.select(".mapboxgl-ctrl-logo").node().offsetParent === null;
+            if (!f) {
+              var h = t._glimages.append("g");
+              h.attr("transform", bJ(n.l + n.w * o.x[0] + 10, n.t + n.h * (1 - o.y[0]) - 31)), h.append("path").attr("d", oy.mapboxLogo.path0).style({ opacity: 0.9, fill: "#ffffff", "enable-background": "new" }), h.append("path").attr("d", oy.mapboxLogo.path1).style("opacity", 0.35).style("enable-background", "new"), h.append("path").attr("d", oy.mapboxLogo.path2).style("opacity", 0.35).style("enable-background", "new"), h.append("polygon").attr("points", oy.mapboxLogo.polygon).style({ opacity: 0.9, fill: "#ffffff", "enable-background": "new" });
+            }
+            var d = c.select(".mapboxgl-ctrl-attrib").text().replace("Improve this map", ""), v = t._glimages.append("g"), _ = v.append("text");
+            _.text(d).classed("static-attribution", true).attr({ "font-size": 12, "font-family": "Arial", color: "rgba(0, 0, 0, 0.75)", "text-anchor": "end", "data-unformatted": d });
+            var b = IGe.bBox(_.node()), p = n.w * (o.x[1] - o.x[0]);
+            if (b.width > p / 2) {
+              var k = d.split("|").join("<br>");
+              _.text(k).attr("data-unformatted", k).call(hWt.convertToTspans, e), b = IGe.bBox(_.node());
+            }
+            _.attr("transform", bJ(-3, -b.height + 8)), v.insert("rect", ".static-attribution").attr({ x: -b.width - 6, y: -b.height - 3, width: b.width + 6, height: b.height + 3, fill: "rgba(255, 255, 255, 0.75)" });
+            var E = 1;
+            b.width + 6 > p && (E = p / (b.width + 6));
+            var T = [n.l + n.w * o.x[1], n.t + n.h * (1 - o.y[0])];
+            v.attr("transform", bJ(T[0], T[1]) + lWt(E));
+          }
+        };
+        function pWt(e, t) {
+          var r = e._fullLayout, n = e._context;
+          if (n.mapboxAccessToken === "") return "";
+          for (var i = [], a = [], o = false, s = false, l = 0; l < t.length; l++) {
+            var u = r[t[l]], c = u.accesstoken;
+            DGe(u.style) && (c ? nm.pushUnique(i, c) : (DGe(u._input.style) && (nm.error("Uses Mapbox map style, but did not set an access token."), o = true), s = true)), c && nm.pushUnique(a, c);
+          }
+          if (s) {
+            var f = o ? oy.noAccessTokenErrorMsg : oy.missingStyleErrorMsg;
+            throw nm.error(f), new Error(f);
+          }
+          return i.length ? (i.length > 1 && nm.warn(oy.multipleTokensErrorMsg), i[0]) : (a.length && nm.log(["Listed mapbox access token(s)", a.join(","), "but did not use a Mapbox map style, ignoring token(s)."].join(" ")), "");
+        }
+        function DGe(e) {
+          return typeof e == "string" && (oy.styleValuesMapbox.indexOf(e) !== -1 || e.indexOf("mapbox://") === 0 || e.indexOf("stamen") === 0);
+        }
+        Np.updateFx = function(e) {
+          for (var t = e._fullLayout, r = t._subplots[Cx], n = 0; n < r.length; n++) {
+            var i = t[r[n]]._subplot;
+            i.updateFx(t);
+          }
+        };
+      });
+      var zGe = ye((zxr, FGe) => {
+        FGe.exports = { attributes: Kz(), supplyDefaults: XVe(), colorbar: $d(), formatLabels: uJ(), calc: _F(), plot: sGe(), hoverPoints: t7().hoverPoints, eventData: fGe(), selectPoints: dGe(), styleOnSelect: function(e, t) {
+          if (t) {
+            var r = t[0].trace;
+            r._glTrace.update(t);
+          }
+        }, moduleType: "trace", name: "scattermapbox", basePlotModule: n7(), categories: ["mapbox", "gl", "symbols", "showLegend", "scatter-like"], meta: {} };
+      });
+      var qGe = ye((Oxr, OGe) => {
+        OGe.exports = zGe();
+      });
+      var wJ = ye((qxr, BGe) => {
+        var y1 = a5(), gWt = Tu(), { hovertemplateAttrs: mWt, templatefallbackAttrs: yWt } = Ll(), _Wt = Gl(), Lx = Ao().extendFlat;
+        BGe.exports = Lx({ locations: { valType: "data_array", editType: "calc" }, z: { valType: "data_array", editType: "calc" }, geojson: { valType: "any", editType: "calc" }, featureidkey: Lx({}, y1.featureidkey, {}), below: { valType: "string", editType: "plot" }, text: y1.text, hovertext: y1.hovertext, marker: { line: { color: Lx({}, y1.marker.line.color, { editType: "plot" }), width: Lx({}, y1.marker.line.width, { editType: "plot" }), editType: "calc" }, opacity: Lx({}, y1.marker.opacity, { editType: "plot" }), editType: "calc" }, selected: { marker: { opacity: Lx({}, y1.selected.marker.opacity, { editType: "plot" }), editType: "plot" }, editType: "plot" }, unselected: { marker: { opacity: Lx({}, y1.unselected.marker.opacity, { editType: "plot" }), editType: "plot" }, editType: "plot" }, hoverinfo: y1.hoverinfo, hovertemplate: mWt({}, { keys: ["properties"] }), hovertemplatefallback: yWt(), showlegend: Lx({}, _Wt.showlegend, { dflt: false }) }, gWt("", { cLetter: "z", editTypeOverride: "calc" }));
+      });
+      var UGe = ye((Bxr, NGe) => {
+        var $k = Dr(), xWt = td(), bWt = wJ();
+        NGe.exports = function(t, r, n, i) {
+          function a(c, f) {
+            return $k.coerce(t, r, bWt, c, f);
+          }
+          var o = a("locations"), s = a("z"), l = a("geojson");
+          if (!$k.isArrayOrTypedArray(o) || !o.length || !$k.isArrayOrTypedArray(s) || !s.length || !(typeof l == "string" && l !== "" || $k.isPlainObject(l))) {
+            r.visible = false;
+            return;
+          }
+          a("featureidkey"), r._length = Math.min(o.length, s.length), a("below"), a("text"), a("hovertext"), a("hovertemplate"), a("hovertemplatefallback");
+          var u = a("marker.line.width");
+          u && a("marker.line.color"), a("marker.opacity"), xWt(t, r, i, a, { prefix: "", cLetter: "z" }), $k.coerceSelectionMarkerOpacity(r, a);
+        };
+      });
+      var TJ = ye((Nxr, HGe) => {
+        var wWt = Eo(), _1 = Dr(), TWt = tc(), AWt = So(), SWt = cx().makeBlank, VGe = hx();
+        function MWt(e) {
+          var t = e[0].trace, r = t.visible === true && t._length !== 0, n = { layout: { visibility: "none" }, paint: {} }, i = { layout: { visibility: "none" }, paint: {} }, a = t._opts = { fill: n, line: i, geojson: SWt() };
+          if (!r) return a;
+          var o = VGe.extractTraceFeature(e);
+          if (!o) return a;
+          var s = TWt.makeColorScaleFuncFromTrace(t), l = t.marker, u = l.line || {}, c;
+          _1.isArrayOrTypedArray(l.opacity) && (c = function(k) {
+            var E = k.mo;
+            return wWt(E) ? +_1.constrain(E, 0, 1) : 0;
+          });
+          var f;
+          _1.isArrayOrTypedArray(u.color) && (f = function(k) {
+            return k.mlc;
+          });
+          var h;
+          _1.isArrayOrTypedArray(u.width) && (h = function(k) {
+            return k.mlw;
+          });
+          for (var d = 0; d < e.length; d++) {
+            var v = e[d], _ = v.fOut;
+            if (_) {
+              var b = _.properties;
+              b.fc = s(v.z), c && (b.mo = c(v)), f && (b.mlc = f(v)), h && (b.mlw = h(v)), v.ct = b.ct, v._polygons = VGe.feature2polygons(_);
+            }
+          }
+          var p = c ? { type: "identity", property: "mo" } : l.opacity;
+          return _1.extendFlat(n.paint, { "fill-color": { type: "identity", property: "fc" }, "fill-opacity": p }), _1.extendFlat(i.paint, { "line-color": f ? { type: "identity", property: "mlc" } : u.color, "line-width": h ? { type: "identity", property: "mlw" } : u.width, "line-opacity": p }), n.layout.visibility = "visible", i.layout.visibility = "visible", a.geojson = { type: "FeatureCollection", features: o }, GGe(e), a;
+        }
+        function GGe(e) {
+          var t = e[0].trace, r = t._opts, n;
+          if (t.selectedpoints) {
+            for (var i = AWt.makeSelectedPointStyleFns(t), a = 0; a < e.length; a++) {
+              var o = e[a];
+              o.fOut && (o.fOut.properties.mo2 = i.selectedOpacityFn(o));
+            }
+            n = { type: "identity", property: "mo2" };
+          } else n = _1.isArrayOrTypedArray(t.marker.opacity) ? { type: "identity", property: "mo" } : t.marker.opacity;
+          return _1.extendFlat(r.fill.paint, { "fill-opacity": n }), _1.extendFlat(r.line.paint, { "line-opacity": n }), r;
+        }
+        HGe.exports = { convert: MWt, convertOnSelect: GGe };
+      });
+      var YGe = ye((Uxr, ZGe) => {
+        var WGe = TJ().convert, EWt = TJ().convertOnSelect, jGe = m1().traceLayerPrefix;
+        function XGe(e, t) {
+          this.type = "choroplethmapbox", this.subplot = e, this.uid = t, this.sourceId = "source-" + t, this.layerList = [["fill", jGe + t + "-fill"], ["line", jGe + t + "-line"]], this.below = null;
+        }
+        var L5 = XGe.prototype;
+        L5.update = function(e) {
+          this._update(WGe(e)), e[0].trace._glTrace = this;
+        };
+        L5.updateOnSelect = function(e) {
+          this._update(EWt(e));
+        };
+        L5._update = function(e) {
+          var t = this.subplot, r = this.layerList, n = t.belowLookup["trace-" + this.uid];
+          t.map.getSource(this.sourceId).setData(e.geojson), n !== this.below && (this._removeLayers(), this._addLayers(e, n), this.below = n);
+          for (var i = 0; i < r.length; i++) {
+            var a = r[i], o = a[0], s = a[1], l = e[o];
+            t.setOptions(s, "setLayoutProperty", l.layout), l.layout.visibility === "visible" && t.setOptions(s, "setPaintProperty", l.paint);
+          }
+        };
+        L5._addLayers = function(e, t) {
+          for (var r = this.subplot, n = this.layerList, i = this.sourceId, a = 0; a < n.length; a++) {
+            var o = n[a], s = o[0], l = e[s];
+            r.addLayer({ type: s, id: o[1], source: i, layout: l.layout, paint: l.paint }, t);
+          }
+        };
+        L5._removeLayers = function() {
+          for (var e = this.subplot.map, t = this.layerList, r = t.length - 1; r >= 0; r--) e.removeLayer(t[r][1]);
+        };
+        L5.dispose = function() {
+          var e = this.subplot.map;
+          this._removeLayers(), e.removeSource(this.sourceId);
+        };
+        ZGe.exports = function(t, r) {
+          var n = r[0].trace, i = new XGe(t, n.uid), a = i.sourceId, o = WGe(r), s = i.below = t.belowLookup["trace-" + n.uid];
+          return t.map.addSource(a, { type: "geojson", data: o.geojson }), i._addLayers(o, s), r[0].trace._glTrace = i, i;
+        };
+      });
+      var JGe = ye((Gxr, KGe) => {
+        KGe.exports = { attributes: wJ(), supplyDefaults: UGe(), colorbar: D_(), calc: NF(), plot: YGe(), hoverPoints: VF(), eventData: GF(), selectPoints: HF(), styleOnSelect: function(e, t) {
+          if (t) {
+            var r = t[0].trace;
+            r._glTrace.updateOnSelect(t);
+          }
+        }, getBelow: function(e, t) {
+          for (var r = t.getMapLayers(), n = r.length - 2; n >= 0; n--) {
+            var i = r[n].id;
+            if (typeof i == "string" && i.indexOf("water") === 0) {
+              for (var a = n + 1; a < r.length; a++) if (i = r[a].id, typeof i == "string" && i.indexOf("plotly-") === -1) return i;
+            }
+          }
+        }, moduleType: "trace", name: "choroplethmapbox", basePlotModule: n7(), categories: ["mapbox", "gl", "noOpacity", "showLegend"], meta: { hr_name: "choropleth_mapbox" } };
+      });
+      var QGe = ye((Hxr, $Ge) => {
+        $Ge.exports = JGe();
+      });
+      var SJ = ye((jxr, tHe) => {
+        var kWt = Tu(), { hovertemplateAttrs: CWt, templatefallbackAttrs: LWt } = Ll(), eHe = Gl(), a7 = Kz(), AJ = Ao().extendFlat;
+        tHe.exports = AJ({ lon: a7.lon, lat: a7.lat, z: { valType: "data_array", editType: "calc" }, radius: { valType: "number", editType: "plot", arrayOk: true, min: 1, dflt: 30 }, below: { valType: "string", editType: "plot" }, text: a7.text, hovertext: a7.hovertext, hoverinfo: AJ({}, eHe.hoverinfo, { flags: ["lon", "lat", "z", "text", "name"] }), hovertemplate: CWt(), hovertemplatefallback: LWt(), showlegend: AJ({}, eHe.showlegend, { dflt: false }) }, kWt("", { cLetter: "z", editTypeOverride: "calc" }));
+      });
+      var iHe = ye((Wxr, rHe) => {
+        var PWt = Dr(), IWt = td(), RWt = SJ();
+        rHe.exports = function(t, r, n, i) {
+          function a(u, c) {
+            return PWt.coerce(t, r, RWt, u, c);
+          }
+          var o = a("lon") || [], s = a("lat") || [], l = Math.min(o.length, s.length);
+          if (!l) {
+            r.visible = false;
+            return;
+          }
+          r._length = l, a("z"), a("radius"), a("below"), a("text"), a("hovertext"), a("hovertemplate"), a("hovertemplatefallback"), IWt(t, r, i, a, { prefix: "", cLetter: "z" });
+        };
+      });
+      var oHe = ye((Xxr, aHe) => {
+        var MJ = Eo(), DWt = Dr().isArrayOrTypedArray, EJ = fs().BADNUM, FWt = gv(), nHe = Dr()._;
+        aHe.exports = function(t, r) {
+          for (var n = r._length, i = new Array(n), a = r.z, o = DWt(a) && a.length, s = 0; s < n; s++) {
+            var l = i[s] = {}, u = r.lon[s], c = r.lat[s];
+            if (l.lonlat = MJ(u) && MJ(c) ? [+u, +c] : [EJ, EJ], o) {
+              var f = a[s];
+              l.z = MJ(f) ? f : EJ;
+            }
+          }
+          return FWt(t, r, { vals: o ? a : [0, 1], containerStr: "", cLetter: "z" }), n && (i[0].t = { labels: { lat: nHe(t, "lat:") + " ", lon: nHe(t, "lon:") + " " } }), i;
+        };
+      });
+      var fHe = ye((Zxr, cHe) => {
+        var zWt = Eo(), kJ = Dr(), sHe = ka(), lHe = tc(), uHe = fs().BADNUM, OWt = cx().makeBlank;
+        cHe.exports = function(t) {
+          var r = t[0].trace, n = r.visible === true && r._length !== 0, i = { layout: { visibility: "none" }, paint: {} }, a = r._opts = { heatmap: i, geojson: OWt() };
+          if (!n) return a;
+          var o = [], s, l = r.z, u = r.radius, c = kJ.isArrayOrTypedArray(l) && l.length, f = kJ.isArrayOrTypedArray(u);
+          for (s = 0; s < t.length; s++) {
+            var h = t[s], d = h.lonlat;
+            if (d[0] !== uHe) {
+              var v = {};
+              if (c) {
+                var _ = h.z;
+                v.z = _ !== uHe ? _ : 0;
+              }
+              f && (v.r = zWt(u[s]) && u[s] > 0 ? +u[s] : 0), o.push({ type: "Feature", geometry: { type: "Point", coordinates: d }, properties: v });
+            }
+          }
+          var b = lHe.extractOpts(r), p = b.reversescale ? lHe.flipScale(b.colorscale) : b.colorscale, k = p[0][1], E = sHe.opacity(k) < 1 ? k : sHe.addOpacity(k, 0), T = ["interpolate", ["linear"], ["heatmap-density"], 0, E];
+          for (s = 1; s < p.length; s++) T.push(p[s][0], p[s][1]);
+          var L = ["interpolate", ["linear"], ["get", "z"], b.min, 0, b.max, 1];
+          return kJ.extendFlat(a.heatmap.paint, { "heatmap-weight": c ? L : 1 / (b.max - b.min), "heatmap-color": T, "heatmap-radius": f ? { type: "identity", property: "r" } : r.radius, "heatmap-opacity": r.opacity }), a.geojson = { type: "FeatureCollection", features: o }, a.heatmap.layout.visibility = "visible", a;
+        };
+      });
+      var pHe = ye((Yxr, vHe) => {
+        var hHe = fHe(), qWt = m1().traceLayerPrefix;
+        function dHe(e, t) {
+          this.type = "densitymapbox", this.subplot = e, this.uid = t, this.sourceId = "source-" + t, this.layerList = [["heatmap", qWt + t + "-heatmap"]], this.below = null;
+        }
+        var o7 = dHe.prototype;
+        o7.update = function(e) {
+          var t = this.subplot, r = this.layerList, n = hHe(e), i = t.belowLookup["trace-" + this.uid];
+          t.map.getSource(this.sourceId).setData(n.geojson), i !== this.below && (this._removeLayers(), this._addLayers(n, i), this.below = i);
+          for (var a = 0; a < r.length; a++) {
+            var o = r[a], s = o[0], l = o[1], u = n[s];
+            t.setOptions(l, "setLayoutProperty", u.layout), u.layout.visibility === "visible" && t.setOptions(l, "setPaintProperty", u.paint);
+          }
+        };
+        o7._addLayers = function(e, t) {
+          for (var r = this.subplot, n = this.layerList, i = this.sourceId, a = 0; a < n.length; a++) {
+            var o = n[a], s = o[0], l = e[s];
+            r.addLayer({ type: s, id: o[1], source: i, layout: l.layout, paint: l.paint }, t);
+          }
+        };
+        o7._removeLayers = function() {
+          for (var e = this.subplot.map, t = this.layerList, r = t.length - 1; r >= 0; r--) e.removeLayer(t[r][1]);
+        };
+        o7.dispose = function() {
+          var e = this.subplot.map;
+          this._removeLayers(), e.removeSource(this.sourceId);
+        };
+        vHe.exports = function(t, r) {
+          var n = r[0].trace, i = new dHe(t, n.uid), a = i.sourceId, o = hHe(r), s = i.below = t.belowLookup["trace-" + n.uid];
+          return t.map.addSource(a, { type: "geojson", data: o.geojson }), i._addLayers(o, s), i;
+        };
+      });
+      var mHe = ye((Kxr, gHe) => {
+        var BWt = ho(), NWt = t7().hoverPoints, UWt = t7().getExtraText;
+        gHe.exports = function(t, r, n) {
+          var i = NWt(t, r, n);
+          if (i) {
+            var a = i[0], o = a.cd, s = o[0].trace, l = o[a.index];
+            if (delete a.color, "z" in l) {
+              var u = a.subplot.mockAxis;
+              a.z = l.z, a.zLabel = BWt.tickText(u, u.c2l(l.z), "hover").text;
+            }
+            return a.extraText = UWt(s, l, o[0].t.labels), [a];
+          }
+        };
+      });
+      var _He = ye((Jxr, yHe) => {
+        yHe.exports = function(t, r) {
+          return t.lon = r.lon, t.lat = r.lat, t.z = r.z, t;
+        };
+      });
+      var bHe = ye((Qxr, xHe) => {
+        xHe.exports = { attributes: SJ(), supplyDefaults: iHe(), colorbar: D_(), formatLabels: uJ(), calc: oHe(), plot: pHe(), hoverPoints: mHe(), eventData: _He(), getBelow: function(e, t) {
+          for (var r = t.getMapLayers(), n = 0; n < r.length; n++) {
+            var i = r[n], a = i.id;
+            if (i.type === "symbol" && typeof a == "string" && a.indexOf("plotly-") === -1) return a;
+          }
+        }, moduleType: "trace", name: "densitymapbox", basePlotModule: n7(), categories: ["mapbox", "gl", "showLegend"], meta: { hr_name: "density_mapbox" } };
+      });
+      var THe = ye((ebr, wHe) => {
+        wHe.exports = bHe();
+      });
+      var SHe = ye((tbr, AHe) => {
+        AHe.exports = { version: 8, name: "orto", metadata: { "maputnik:renderer": "mlgljs" }, center: [1.537786, 41.837539], zoom: 12, bearing: 0, pitch: 0, light: { anchor: "viewport", color: "white", intensity: 0.4, position: [1.15, 45, 30] }, sources: { ortoEsri: { type: "raster", tiles: ["https://server.arcgisonline.com/ArcGIS/rest/services/World_Imagery/MapServer/tile/{z}/{y}/{x}"], tileSize: 256, maxzoom: 18, attribution: "ESRI &copy; <a href='http://www.esri.com'>ESRI</a>" }, ortoInstaMaps: { type: "raster", tiles: ["https://tilemaps.icgc.cat/mapfactory/wmts/orto_8_12/CAT3857/{z}/{x}/{y}.png"], tileSize: 256, maxzoom: 13 }, ortoICGC: { type: "raster", tiles: ["https://geoserveis.icgc.cat/icc_mapesmultibase/noutm/wmts/orto/GRID3857/{z}/{x}/{y}.jpeg"], tileSize: 256, minzoom: 13.1, maxzoom: 20 }, openmaptiles: { type: "vector", url: "https://geoserveis.icgc.cat/contextmaps/basemap.json" } }, sprite: "https://geoserveis.icgc.cat/contextmaps/sprites/sprite@1", glyphs: "https://geoserveis.icgc.cat/contextmaps/glyphs/{fontstack}/{range}.pbf", layers: [{ id: "background", type: "background", paint: { "background-color": "#F4F9F4" } }, { id: "ortoEsri", type: "raster", source: "ortoEsri", maxzoom: 16, layout: { visibility: "visible" } }, { id: "ortoICGC", type: "raster", source: "ortoICGC", minzoom: 13.1, maxzoom: 19, layout: { visibility: "visible" } }, { id: "ortoInstaMaps", type: "raster", source: "ortoInstaMaps", maxzoom: 13, layout: { visibility: "visible" } }, { id: "waterway_tunnel", type: "line", source: "openmaptiles", "source-layer": "waterway", minzoom: 14, filter: ["all", ["in", "class", "river", "stream", "canal"], ["==", "brunnel", "tunnel"]], layout: { "line-cap": "round" }, paint: { "line-color": "#a0c8f0", "line-width": { base: 1.3, stops: [[13, 0.5], [20, 6]] }, "line-dasharray": [2, 4] } }, { id: "waterway-other", type: "line", metadata: { "mapbox:group": "1444849382550.77" }, source: "openmaptiles", "source-layer": "waterway", filter: ["!in", "class", "canal", "river", "stream"], layout: { "line-cap": "round" }, paint: { "line-color": "#a0c8f0", "line-width": { base: 1.3, stops: [[13, 0.5], [20, 2]] } } }, { id: "waterway-stream-canal", type: "line", metadata: { "mapbox:group": "1444849382550.77" }, source: "openmaptiles", "source-layer": "waterway", filter: ["all", ["in", "class", "canal", "stream"], ["!=", "brunnel", "tunnel"]], layout: { "line-cap": "round" }, paint: { "line-color": "#a0c8f0", "line-width": { base: 1.3, stops: [[13, 0.5], [20, 6]] } } }, { id: "waterway-river", type: "line", metadata: { "mapbox:group": "1444849382550.77" }, source: "openmaptiles", "source-layer": "waterway", filter: ["all", ["==", "class", "river"], ["!=", "brunnel", "tunnel"]], layout: { "line-cap": "round" }, paint: { "line-color": "#a0c8f0", "line-width": { base: 1.2, stops: [[10, 0.8], [20, 4]] }, "line-opacity": 0.5 } }, { id: "water-offset", type: "fill", metadata: { "mapbox:group": "1444849382550.77" }, source: "openmaptiles", "source-layer": "water", maxzoom: 8, filter: ["==", "$type", "Polygon"], layout: { visibility: "visible" }, paint: { "fill-opacity": 0, "fill-color": "#a0c8f0", "fill-translate": { base: 1, stops: [[6, [2, 0]], [8, [0, 0]]] } } }, { id: "water", type: "fill", metadata: { "mapbox:group": "1444849382550.77" }, source: "openmaptiles", "source-layer": "water", layout: { visibility: "visible" }, paint: { "fill-color": "hsl(210, 67%, 85%)", "fill-opacity": 0 } }, { id: "water-pattern", type: "fill", metadata: { "mapbox:group": "1444849382550.77" }, source: "openmaptiles", "source-layer": "water", layout: { visibility: "visible" }, paint: { "fill-translate": [0, 2.5], "fill-pattern": "wave", "fill-opacity": 1 } }, { id: "landcover-ice-shelf", type: "fill", metadata: { "mapbox:group": "1444849382550.77" }, source: "openmaptiles", "source-layer": "landcover", filter: ["==", "subclass", "ice_shelf"], layout: { visibility: "visible" }, paint: { "fill-color": "#fff", "fill-opacity": { base: 1, stops: [[0, 0.9], [10, 0.3]] } } }, { id: "tunnel-service-track-casing", type: "line", metadata: { "mapbox:group": "1444849354174.1904" }, source: "openmaptiles", "source-layer": "transportation", filter: ["all", ["==", "brunnel", "tunnel"], ["in", "class", "service", "track"]], layout: { "line-join": "round" }, paint: { "line-color": "#cfcdca", "line-dasharray": [0.5, 0.25], "line-width": { base: 1.2, stops: [[15, 1], [16, 4], [20, 11]] } } }, { id: "tunnel-minor-casing", type: "line", metadata: { "mapbox:group": "1444849354174.1904" }, source: "openmaptiles", "source-layer": "transportation", filter: ["all", ["==", "brunnel", "tunnel"], ["==", "class", "minor"]], layout: { "line-join": "round" }, paint: { "line-color": "#cfcdca", "line-opacity": { stops: [[12, 0], [12.5, 1]] }, "line-width": { base: 1.2, stops: [[12, 0.5], [13, 1], [14, 4], [20, 15]] } } }, { id: "tunnel-secondary-tertiary-casing", type: "line", metadata: { "mapbox:group": "1444849354174.1904" }, source: "openmaptiles", "source-layer": "transportation", filter: ["all", ["==", "brunnel", "tunnel"], ["in", "class", "secondary", "tertiary"]], layout: { "line-join": "round" }, paint: { "line-color": "#e9ac77", "line-opacity": 1, "line-width": { base: 1.2, stops: [[8, 1.5], [20, 17]] } } }, { id: "tunnel-trunk-primary-casing", type: "line", metadata: { "mapbox:group": "1444849354174.1904" }, source: "openmaptiles", "source-layer": "transportation", filter: ["all", ["==", "brunnel", "tunnel"], ["in", "class", "primary", "trunk"]], layout: { "line-join": "round" }, paint: { "line-color": "#e9ac77", "line-width": { base: 1.2, stops: [[5, 0.4], [6, 0.6], [7, 1.5], [20, 22]] }, "line-opacity": 0.7 } }, { id: "tunnel-motorway-casing", type: "line", metadata: { "mapbox:group": "1444849354174.1904" }, source: "openmaptiles", "source-layer": "transportation", filter: ["all", ["==", "brunnel", "tunnel"], ["==", "class", "motorway"]], layout: { "line-join": "round", visibility: "visible" }, paint: { "line-color": "#e9ac77", "line-dasharray": [0.5, 0.25], "line-width": { base: 1.2, stops: [[5, 0.4], [6, 0.6], [7, 1.5], [20, 22]] }, "line-opacity": 0.5 } }, { id: "tunnel-path", type: "line", metadata: { "mapbox:group": "1444849354174.1904" }, source: "openmaptiles", "source-layer": "transportation", filter: ["all", ["==", "$type", "LineString"], ["all", ["==", "brunnel", "tunnel"], ["==", "class", "path"]]], paint: { "line-color": "#cba", "line-dasharray": [1.5, 0.75], "line-width": { base: 1.2, stops: [[15, 1.2], [20, 4]] } } }, { id: "tunnel-service-track", type: "line", metadata: { "mapbox:group": "1444849354174.1904" }, source: "openmaptiles", "source-layer": "transportation", filter: ["all", ["==", "brunnel", "tunnel"], ["in", "class", "service", "track"]], layout: { "line-join": "round" }, paint: { "line-color": "#fff", "line-width": { base: 1.2, stops: [[15.5, 0], [16, 2], [20, 7.5]] } } }, { id: "tunnel-minor", type: "line", metadata: { "mapbox:group": "1444849354174.1904" }, source: "openmaptiles", "source-layer": "transportation", filter: ["all", ["==", "brunnel", "tunnel"], ["==", "class", "minor_road"]], layout: { "line-join": "round" }, paint: { "line-color": "#fff", "line-opacity": 1, "line-width": { base: 1.2, stops: [[13.5, 0], [14, 2.5], [20, 11.5]] } } }, { id: "tunnel-secondary-tertiary", type: "line", metadata: { "mapbox:group": "1444849354174.1904" }, source: "openmaptiles", "source-layer": "transportation", filter: ["all", ["==", "brunnel", "tunnel"], ["in", "class", "secondary", "tertiary"]], layout: { "line-join": "round" }, paint: { "line-color": "#fff4c6", "line-width": { base: 1.2, stops: [[6.5, 0], [7, 0.5], [20, 10]] } } }, { id: "tunnel-trunk-primary", type: "line", metadata: { "mapbox:group": "1444849354174.1904" }, source: "openmaptiles", "source-layer": "transportation", filter: ["all", ["==", "brunnel", "tunnel"], ["in", "class", "primary", "trunk"]], layout: { "line-join": "round" }, paint: { "line-color": "#fff4c6", "line-width": { base: 1.2, stops: [[6.5, 0], [7, 0.5], [20, 18]] }, "line-opacity": 0.5 } }, { id: "tunnel-motorway", type: "line", metadata: { "mapbox:group": "1444849354174.1904" }, source: "openmaptiles", "source-layer": "transportation", filter: ["all", ["==", "brunnel", "tunnel"], ["==", "class", "motorway"]], layout: { "line-join": "round", visibility: "visible" }, paint: { "line-color": "#ffdaa6", "line-width": { base: 1.2, stops: [[6.5, 0], [7, 0.5], [20, 18]] }, "line-opacity": 0.5 } }, { id: "tunnel-railway", type: "line", metadata: { "mapbox:group": "1444849354174.1904" }, source: "openmaptiles", "source-layer": "transportation", filter: ["all", ["==", "brunnel", "tunnel"], ["==", "class", "rail"]], paint: { "line-color": "#bbb", "line-width": { base: 1.4, stops: [[14, 0.4], [15, 0.75], [20, 2]] }, "line-dasharray": [2, 2] } }, { id: "ferry", type: "line", source: "openmaptiles", "source-layer": "transportation", filter: ["all", ["in", "class", "ferry"]], layout: { "line-join": "round", visibility: "visible" }, paint: { "line-color": "rgba(108, 159, 182, 1)", "line-width": 1.1, "line-dasharray": [2, 2] } }, { id: "aeroway-taxiway-casing", type: "line", metadata: { "mapbox:group": "1444849345966.4436" }, source: "openmaptiles", "source-layer": "aeroway", minzoom: 12, filter: ["all", ["in", "class", "taxiway"]], layout: { "line-cap": "round", "line-join": "round", visibility: "visible" }, paint: { "line-color": "rgba(153, 153, 153, 1)", "line-width": { base: 1.5, stops: [[11, 2], [17, 12]] }, "line-opacity": 1 } }, { id: "aeroway-runway-casing", type: "line", metadata: { "mapbox:group": "1444849345966.4436" }, source: "openmaptiles", "source-layer": "aeroway", minzoom: 12, filter: ["all", ["in", "class", "runway"]], layout: { "line-cap": "round", "line-join": "round", visibility: "visible" }, paint: { "line-color": "rgba(153, 153, 153, 1)", "line-width": { base: 1.5, stops: [[11, 5], [17, 55]] }, "line-opacity": 1 } }, { id: "aeroway-taxiway", type: "line", metadata: { "mapbox:group": "1444849345966.4436" }, source: "openmaptiles", "source-layer": "aeroway", minzoom: 4, filter: ["all", ["in", "class", "taxiway"], ["==", "$type", "LineString"]], layout: { "line-cap": "round", "line-join": "round", visibility: "visible" }, paint: { "line-color": "rgba(255, 255, 255, 1)", "line-width": { base: 1.5, stops: [[11, 1], [17, 10]] }, "line-opacity": { base: 1, stops: [[11, 0], [12, 1]] } } }, { id: "aeroway-runway", type: "line", metadata: { "mapbox:group": "1444849345966.4436" }, source: "openmaptiles", "source-layer": "aeroway", minzoom: 4, filter: ["all", ["in", "class", "runway"], ["==", "$type", "LineString"]], layout: { "line-cap": "round", "line-join": "round", visibility: "visible" }, paint: { "line-color": "rgba(255, 255, 255, 1)", "line-width": { base: 1.5, stops: [[11, 4], [17, 50]] }, "line-opacity": { base: 1, stops: [[11, 0], [12, 1]] } } }, { id: "highway-motorway-link-casing", type: "line", metadata: { "mapbox:group": "1444849345966.4436" }, source: "openmaptiles", "source-layer": "transportation", minzoom: 12, filter: ["all", ["!in", "brunnel", "bridge", "tunnel"], ["==", "class", "motorway_link"]], layout: { "line-cap": "round", "line-join": "round" }, paint: { "line-color": "#e9ac77", "line-opacity": 1, "line-width": { base: 1.2, stops: [[12, 1], [13, 3], [14, 4], [20, 15]] } } }, { id: "highway-link-casing", type: "line", metadata: { "mapbox:group": "1444849345966.4436" }, source: "openmaptiles", "source-layer": "transportation", minzoom: 13, filter: ["all", ["!in", "brunnel", "bridge", "tunnel"], ["in", "class", "primary_link", "secondary_link", "tertiary_link", "trunk_link"]], layout: { "line-cap": "round", "line-join": "round", visibility: "visible" }, paint: { "line-color": "#e9ac77", "line-opacity": 1, "line-width": { base: 1.2, stops: [[12, 1], [13, 3], [14, 4], [20, 15]] } } }, { id: "highway-minor-casing", type: "line", metadata: { "mapbox:group": "1444849345966.4436" }, source: "openmaptiles", "source-layer": "transportation", filter: ["all", ["==", "$type", "LineString"], ["all", ["!=", "brunnel", "tunnel"], ["in", "class", "minor", "service", "track"]]], layout: { "line-cap": "round", "line-join": "round" }, paint: { "line-color": "#cfcdca", "line-opacity": { stops: [[12, 0], [12.5, 0]] }, "line-width": { base: 1.2, stops: [[12, 0.5], [13, 1], [14, 4], [20, 15]] } } }, { id: "highway-secondary-tertiary-casing", type: "line", metadata: { "mapbox:group": "1444849345966.4436" }, source: "openmaptiles", "source-layer": "transportation", filter: ["all", ["!in", "brunnel", "bridge", "tunnel"], ["in", "class", "secondary", "tertiary"]], layout: { "line-cap": "butt", "line-join": "round", visibility: "visible" }, paint: { "line-color": "#e9ac77", "line-opacity": 0.5, "line-width": { base: 1.2, stops: [[8, 1.5], [20, 17]] } } }, { id: "highway-primary-casing", type: "line", metadata: { "mapbox:group": "1444849345966.4436" }, source: "openmaptiles", "source-layer": "transportation", minzoom: 5, filter: ["all", ["!in", "brunnel", "bridge", "tunnel"], ["in", "class", "primary"]], layout: { "line-cap": "butt", "line-join": "round", visibility: "visible" }, paint: { "line-color": "#e9ac77", "line-opacity": { stops: [[7, 0], [8, 0.6]] }, "line-width": { base: 1.2, stops: [[7, 0], [8, 0.6], [9, 1.5], [20, 22]] } } }, { id: "highway-trunk-casing", type: "line", metadata: { "mapbox:group": "1444849345966.4436" }, source: "openmaptiles", "source-layer": "transportation", minzoom: 5, filter: ["all", ["!in", "brunnel", "bridge", "tunnel"], ["in", "class", "trunk"]], layout: { "line-cap": "butt", "line-join": "round", visibility: "visible" }, paint: { "line-color": "#e9ac77", "line-opacity": { stops: [[5, 0], [6, 0.5]] }, "line-width": { base: 1.2, stops: [[5, 0], [6, 0.6], [7, 1.5], [20, 22]] } } }, { id: "highway-motorway-casing", type: "line", metadata: { "mapbox:group": "1444849345966.4436" }, source: "openmaptiles", "source-layer": "transportation", minzoom: 4, filter: ["all", ["!in", "brunnel", "bridge", "tunnel"], ["==", "class", "motorway"]], layout: { "line-cap": "butt", "line-join": "round", visibility: "visible" }, paint: { "line-color": "#e9ac77", "line-width": { base: 1.2, stops: [[4, 0], [5, 0.4], [6, 0.6], [7, 1.5], [20, 22]] }, "line-opacity": { stops: [[4, 0], [5, 0.5]] } } }, { id: "highway-path", type: "line", metadata: { "mapbox:group": "1444849345966.4436" }, source: "openmaptiles", "source-layer": "transportation", filter: ["all", ["==", "$type", "LineString"], ["all", ["!in", "brunnel", "bridge", "tunnel"], ["==", "class", "path"]]], paint: { "line-color": "#cba", "line-dasharray": [1.5, 0.75], "line-width": { base: 1.2, stops: [[15, 1.2], [20, 4]] } } }, { id: "highway-motorway-link", type: "line", metadata: { "mapbox:group": "1444849345966.4436" }, source: "openmaptiles", "source-layer": "transportation", minzoom: 12, filter: ["all", ["!in", "brunnel", "bridge", "tunnel"], ["==", "class", "motorway_link"]], layout: { "line-cap": "round", "line-join": "round" }, paint: { "line-color": "#fc8", "line-width": { base: 1.2, stops: [[12.5, 0], [13, 1.5], [14, 2.5], [20, 11.5]] } } }, { id: "highway-link", type: "line", metadata: { "mapbox:group": "1444849345966.4436" }, source: "openmaptiles", "source-layer": "transportation", minzoom: 13, filter: ["all", ["!in", "brunnel", "bridge", "tunnel"], ["in", "class", "primary_link", "secondary_link", "tertiary_link", "trunk_link"]], layout: { "line-cap": "round", "line-join": "round", visibility: "visible" }, paint: { "line-color": "#fea", "line-width": { base: 1.2, stops: [[12.5, 0], [13, 1.5], [14, 2.5], [20, 11.5]] } } }, { id: "highway-minor", type: "line", metadata: { "mapbox:group": "1444849345966.4436" }, source: "openmaptiles", "source-layer": "transportation", filter: ["all", ["==", "$type", "LineString"], ["all", ["!=", "brunnel", "tunnel"], ["in", "class", "minor", "service", "track"]]], layout: { "line-cap": "round", "line-join": "round" }, paint: { "line-color": "#fff", "line-opacity": 0.5, "line-width": { base: 1.2, stops: [[13.5, 0], [14, 2.5], [20, 11.5]] } } }, { id: "highway-secondary-tertiary", type: "line", metadata: { "mapbox:group": "1444849345966.4436" }, source: "openmaptiles", "source-layer": "transportation", filter: ["all", ["!in", "brunnel", "bridge", "tunnel"], ["in", "class", "secondary", "tertiary"]], layout: { "line-cap": "round", "line-join": "round", visibility: "visible" }, paint: { "line-color": "#fea", "line-width": { base: 1.2, stops: [[6.5, 0], [8, 0.5], [20, 13]] }, "line-opacity": 0.5 } }, { id: "highway-primary", type: "line", metadata: { "mapbox:group": "1444849345966.4436" }, source: "openmaptiles", "source-layer": "transportation", filter: ["all", ["==", "$type", "LineString"], ["all", ["!in", "brunnel", "bridge", "tunnel"], ["in", "class", "primary"]]], layout: { "line-cap": "round", "line-join": "round", visibility: "visible" }, paint: { "line-color": "#fea", "line-width": { base: 1.2, stops: [[8.5, 0], [9, 0.5], [20, 18]] }, "line-opacity": 0 } }, { id: "highway-trunk", type: "line", metadata: { "mapbox:group": "1444849345966.4436" }, source: "openmaptiles", "source-layer": "transportation", filter: ["all", ["==", "$type", "LineString"], ["all", ["!in", "brunnel", "bridge", "tunnel"], ["in", "class", "trunk"]]], layout: { "line-cap": "round", "line-join": "round", visibility: "visible" }, paint: { "line-color": "#fea", "line-width": { base: 1.2, stops: [[6.5, 0], [7, 0.5], [20, 18]] }, "line-opacity": 0.5 } }, { id: "highway-motorway", type: "line", metadata: { "mapbox:group": "1444849345966.4436" }, source: "openmaptiles", "source-layer": "transportation", minzoom: 5, filter: ["all", ["==", "$type", "LineString"], ["all", ["!in", "brunnel", "bridge", "tunnel"], ["==", "class", "motorway"]]], layout: { "line-cap": "round", "line-join": "round", visibility: "visible" }, paint: { "line-color": "#fc8", "line-width": { base: 1.2, stops: [[6.5, 0], [7, 0.5], [20, 18]] }, "line-opacity": 0.5 } }, { id: "railway-transit", type: "line", metadata: { "mapbox:group": "1444849345966.4436" }, source: "openmaptiles", "source-layer": "transportation", filter: ["all", ["==", "$type", "LineString"], ["all", ["==", "class", "transit"], ["!in", "brunnel", "tunnel"]]], layout: { visibility: "visible" }, paint: { "line-color": "hsla(0, 0%, 73%, 0.77)", "line-width": { base: 1.4, stops: [[14, 0.4], [20, 1]] } } }, { id: "railway-transit-hatching", type: "line", metadata: { "mapbox:group": "1444849345966.4436" }, source: "openmaptiles", "source-layer": "transportation", filter: ["all", ["==", "$type", "LineString"], ["all", ["==", "class", "transit"], ["!in", "brunnel", "tunnel"]]], layout: { visibility: "visible" }, paint: { "line-color": "hsla(0, 0%, 73%, 0.68)", "line-dasharray": [0.2, 8], "line-width": { base: 1.4, stops: [[14.5, 0], [15, 2], [20, 6]] } } }, { id: "railway-service", type: "line", metadata: { "mapbox:group": "1444849345966.4436" }, source: "openmaptiles", "source-layer": "transportation", filter: ["all", ["==", "$type", "LineString"], ["all", ["==", "class", "rail"], ["has", "service"]]], paint: { "line-color": "hsla(0, 0%, 73%, 0.77)", "line-width": { base: 1.4, stops: [[14, 0.4], [20, 1]] } } }, { id: "railway-service-hatching", type: "line", metadata: { "mapbox:group": "1444849345966.4436" }, source: "openmaptiles", "source-layer": "transportation", filter: ["all", ["==", "$type", "LineString"], ["all", ["==", "class", "rail"], ["has", "service"]]], layout: { visibility: "visible" }, paint: { "line-color": "hsla(0, 0%, 73%, 0.68)", "line-dasharray": [0.2, 8], "line-width": { base: 1.4, stops: [[14.5, 0], [15, 2], [20, 6]] } } }, { id: "railway", type: "line", metadata: { "mapbox:group": "1444849345966.4436" }, source: "openmaptiles", "source-layer": "transportation", filter: ["all", ["==", "$type", "LineString"], ["all", ["!has", "service"], ["!in", "brunnel", "bridge", "tunnel"], ["==", "class", "rail"]]], paint: { "line-color": "#bbb", "line-width": { base: 1.4, stops: [[14, 0.4], [15, 0.75], [20, 2]] } } }, { id: "railway-hatching", type: "line", metadata: { "mapbox:group": "1444849345966.4436" }, source: "openmaptiles", "source-layer": "transportation", filter: ["all", ["==", "$type", "LineString"], ["all", ["!has", "service"], ["!in", "brunnel", "bridge", "tunnel"], ["==", "class", "rail"]]], paint: { "line-color": "#bbb", "line-dasharray": [0.2, 8], "line-width": { base: 1.4, stops: [[14.5, 0], [15, 3], [20, 8]] } } }, { id: "bridge-motorway-link-casing", type: "line", metadata: { "mapbox:group": "1444849334699.1902" }, source: "openmaptiles", "source-layer": "transportation", filter: ["all", ["==", "brunnel", "bridge"], ["==", "class", "motorway_link"]], layout: { "line-join": "round" }, paint: { "line-color": "#e9ac77", "line-opacity": 1, "line-width": { base: 1.2, stops: [[12, 1], [13, 3], [14, 4], [20, 15]] } } }, { id: "bridge-link-casing", type: "line", metadata: { "mapbox:group": "1444849334699.1902" }, source: "openmaptiles", "source-layer": "transportation", filter: ["all", ["==", "brunnel", "bridge"], ["in", "class", "primary_link", "secondary_link", "tertiary_link", "trunk_link"]], layout: { "line-join": "round" }, paint: { "line-color": "#e9ac77", "line-opacity": 1, "line-width": { base: 1.2, stops: [[12, 1], [13, 3], [14, 4], [20, 15]] } } }, { id: "bridge-secondary-tertiary-casing", type: "line", metadata: { "mapbox:group": "1444849334699.1902" }, source: "openmaptiles", "source-layer": "transportation", filter: ["all", ["==", "brunnel", "bridge"], ["in", "class", "secondary", "tertiary"]], layout: { "line-join": "round" }, paint: { "line-color": "#e9ac77", "line-opacity": 1, "line-width": { base: 1.2, stops: [[8, 1.5], [20, 28]] } } }, { id: "bridge-trunk-primary-casing", type: "line", metadata: { "mapbox:group": "1444849334699.1902" }, source: "openmaptiles", "source-layer": "transportation", filter: ["all", ["==", "brunnel", "bridge"], ["in", "class", "primary", "trunk"]], layout: { "line-join": "round" }, paint: { "line-color": "hsl(28, 76%, 67%)", "line-width": { base: 1.2, stops: [[5, 0.4], [6, 0.6], [7, 1.5], [20, 26]] } } }, { id: "bridge-motorway-casing", type: "line", metadata: { "mapbox:group": "1444849334699.1902" }, source: "openmaptiles", "source-layer": "transportation", filter: ["all", ["==", "brunnel", "bridge"], ["==", "class", "motorway"]], layout: { "line-join": "round" }, paint: { "line-color": "#e9ac77", "line-width": { base: 1.2, stops: [[5, 0.4], [6, 0.6], [7, 1.5], [20, 22]] }, "line-opacity": 0.5 } }, { id: "bridge-path-casing", type: "line", metadata: { "mapbox:group": "1444849334699.1902" }, source: "openmaptiles", "source-layer": "transportation", filter: ["all", ["==", "$type", "LineString"], ["all", ["==", "brunnel", "bridge"], ["==", "class", "path"]]], paint: { "line-color": "#f8f4f0", "line-width": { base: 1.2, stops: [[15, 1.2], [20, 18]] } } }, { id: "bridge-path", type: "line", metadata: { "mapbox:group": "1444849334699.1902" }, source: "openmaptiles", "source-layer": "transportation", filter: ["all", ["==", "$type", "LineString"], ["all", ["==", "brunnel", "bridge"], ["==", "class", "path"]]], paint: { "line-color": "#cba", "line-width": { base: 1.2, stops: [[15, 1.2], [20, 4]] }, "line-dasharray": [1.5, 0.75] } }, { id: "bridge-motorway-link", type: "line", metadata: { "mapbox:group": "1444849334699.1902" }, source: "openmaptiles", "source-layer": "transportation", filter: ["all", ["==", "brunnel", "bridge"], ["==", "class", "motorway_link"]], layout: { "line-join": "round" }, paint: { "line-color": "#fc8", "line-width": { base: 1.2, stops: [[12.5, 0], [13, 1.5], [14, 2.5], [20, 11.5]] } } }, { id: "bridge-link", type: "line", metadata: { "mapbox:group": "1444849334699.1902" }, source: "openmaptiles", "source-layer": "transportation", filter: ["all", ["==", "brunnel", "bridge"], ["in", "class", "primary_link", "secondary_link", "tertiary_link", "trunk_link"]], layout: { "line-join": "round" }, paint: { "line-color": "#fea", "line-width": { base: 1.2, stops: [[12.5, 0], [13, 1.5], [14, 2.5], [20, 11.5]] } } }, { id: "bridge-secondary-tertiary", type: "line", metadata: { "mapbox:group": "1444849334699.1902" }, source: "openmaptiles", "source-layer": "transportation", filter: ["all", ["==", "brunnel", "bridge"], ["in", "class", "secondary", "tertiary"]], layout: { "line-join": "round" }, paint: { "line-color": "#fea", "line-width": { base: 1.2, stops: [[6.5, 0], [7, 0.5], [20, 20]] } } }, { id: "bridge-trunk-primary", type: "line", metadata: { "mapbox:group": "1444849334699.1902" }, source: "openmaptiles", "source-layer": "transportation", filter: ["all", ["==", "brunnel", "bridge"], ["in", "class", "primary", "trunk"]], layout: { "line-join": "round" }, paint: { "line-color": "#fea", "line-width": { base: 1.2, stops: [[6.5, 0], [7, 0.5], [20, 18]] } } }, { id: "bridge-motorway", type: "line", metadata: { "mapbox:group": "1444849334699.1902" }, source: "openmaptiles", "source-layer": "transportation", filter: ["all", ["==", "brunnel", "bridge"], ["==", "class", "motorway"]], layout: { "line-join": "round" }, paint: { "line-color": "#fc8", "line-width": { base: 1.2, stops: [[6.5, 0], [7, 0.5], [20, 18]] }, "line-opacity": 0.5 } }, { id: "bridge-railway", type: "line", metadata: { "mapbox:group": "1444849334699.1902" }, source: "openmaptiles", "source-layer": "transportation", filter: ["all", ["==", "brunnel", "bridge"], ["==", "class", "rail"]], paint: { "line-color": "#bbb", "line-width": { base: 1.4, stops: [[14, 0.4], [15, 0.75], [20, 2]] } } }, { id: "bridge-railway-hatching", type: "line", metadata: { "mapbox:group": "1444849334699.1902" }, source: "openmaptiles", "source-layer": "transportation", filter: ["all", ["==", "brunnel", "bridge"], ["==", "class", "rail"]], paint: { "line-color": "#bbb", "line-dasharray": [0.2, 8], "line-width": { base: 1.4, stops: [[14.5, 0], [15, 3], [20, 8]] } } }, { id: "cablecar", type: "line", source: "openmaptiles", "source-layer": "transportation", minzoom: 13, filter: ["==", "class", "cable_car"], layout: { visibility: "visible", "line-cap": "round" }, paint: { "line-color": "hsl(0, 0%, 70%)", "line-width": { base: 1, stops: [[11, 1], [19, 2.5]] } } }, { id: "cablecar-dash", type: "line", source: "openmaptiles", "source-layer": "transportation", minzoom: 13, filter: ["==", "class", "cable_car"], layout: { visibility: "visible", "line-cap": "round" }, paint: { "line-color": "hsl(0, 0%, 70%)", "line-width": { base: 1, stops: [[11, 3], [19, 5.5]] }, "line-dasharray": [2, 3] } }, { id: "boundary-land-level-4", type: "line", source: "openmaptiles", "source-layer": "boundary", filter: ["all", [">=", "admin_level", 4], ["<=", "admin_level", 8], ["!=", "maritime", 1]], layout: { "line-join": "round" }, paint: { "line-color": "#9e9cab", "line-dasharray": [3, 1, 1, 1], "line-width": { base: 1.4, stops: [[4, 0.4], [5, 1], [12, 3]] }, "line-opacity": 0.6 } }, { id: "boundary-land-level-2", type: "line", source: "openmaptiles", "source-layer": "boundary", filter: ["all", ["==", "admin_level", 2], ["!=", "maritime", 1], ["!=", "disputed", 1]], layout: { "line-cap": "round", "line-join": "round" }, paint: { "line-color": "hsl(248, 7%, 66%)", "line-width": { base: 1, stops: [[0, 0.6], [4, 1.4], [5, 2], [12, 2]] } } }, { id: "boundary-land-disputed", type: "line", source: "openmaptiles", "source-layer": "boundary", filter: ["all", ["!=", "maritime", 1], ["==", "disputed", 1]], layout: { "line-cap": "round", "line-join": "round" }, paint: { "line-color": "hsl(248, 7%, 70%)", "line-dasharray": [1, 3], "line-width": { base: 1, stops: [[0, 0.6], [4, 1.4], [5, 2], [12, 8]] } } }, { id: "boundary-water", type: "line", source: "openmaptiles", "source-layer": "boundary", filter: ["all", ["in", "admin_level", 2, 4], ["==", "maritime", 1]], layout: { "line-cap": "round", "line-join": "round" }, paint: { "line-color": "rgba(154, 189, 214, 1)", "line-width": { base: 1, stops: [[0, 0.6], [4, 1], [5, 1], [12, 1]] }, "line-opacity": { stops: [[6, 0], [10, 0]] } } }, { id: "waterway-name", type: "symbol", source: "openmaptiles", "source-layer": "waterway", minzoom: 13, filter: ["all", ["==", "$type", "LineString"], ["has", "name"]], layout: { "text-font": ["Noto Sans Italic"], "text-size": 14, "text-field": "{name:latin} {name:nonlatin}", "text-max-width": 5, "text-rotation-alignment": "map", "symbol-placement": "line", "text-letter-spacing": 0.2, "symbol-spacing": 350 }, paint: { "text-color": "#74aee9", "text-halo-width": 1.5, "text-halo-color": "rgba(255,255,255,0.7)" } }, { id: "water-name-lakeline", type: "symbol", source: "openmaptiles", "source-layer": "water_name", filter: ["==", "$type", "LineString"], layout: { "text-font": ["Noto Sans Italic"], "text-size": 14, "text-field": `{name:latin}
+{name:nonlatin}`, "text-max-width": 5, "text-rotation-alignment": "map", "symbol-placement": "line", "symbol-spacing": 350, "text-letter-spacing": 0.2 }, paint: { "text-color": "#74aee9", "text-halo-width": 1.5, "text-halo-color": "rgba(255,255,255,0.7)" } }, { id: "water-name-ocean", type: "symbol", source: "openmaptiles", "source-layer": "water_name", filter: ["all", ["==", "$type", "Point"], ["==", "class", "ocean"]], layout: { "text-font": ["Noto Sans Italic"], "text-size": 14, "text-field": "{name:latin}", "text-max-width": 5, "text-rotation-alignment": "map", "symbol-placement": "point", "symbol-spacing": 350, "text-letter-spacing": 0.2 }, paint: { "text-color": "#74aee9", "text-halo-width": 1.5, "text-halo-color": "rgba(255,255,255,0.7)" } }, { id: "water-name-other", type: "symbol", source: "openmaptiles", "source-layer": "water_name", filter: ["all", ["==", "$type", "Point"], ["!in", "class", "ocean"]], layout: { "text-font": ["Noto Sans Italic"], "text-size": { stops: [[0, 10], [6, 14]] }, "text-field": `{name:latin}
+{name:nonlatin}`, "text-max-width": 5, "text-rotation-alignment": "map", "symbol-placement": "point", "symbol-spacing": 350, "text-letter-spacing": 0.2, visibility: "visible" }, paint: { "text-color": "#74aee9", "text-halo-width": 1.5, "text-halo-color": "rgba(255,255,255,0.7)" } }, { id: "poi-level-3", type: "symbol", source: "openmaptiles", "source-layer": "poi", minzoom: 16, filter: ["all", ["==", "$type", "Point"], [">=", "rank", 25]], layout: { "text-padding": 2, "text-font": ["Noto Sans Regular"], "text-anchor": "top", "icon-image": "{class}_11", "text-field": `{name:latin}
+{name:nonlatin}`, "text-offset": [0, 0.6], "text-size": 12, "text-max-width": 9 }, paint: { "text-halo-blur": 0.5, "text-color": "#666", "text-halo-width": 1, "text-halo-color": "#ffffff" } }, { id: "poi-level-2", type: "symbol", source: "openmaptiles", "source-layer": "poi", minzoom: 15, filter: ["all", ["==", "$type", "Point"], ["<=", "rank", 24], [">=", "rank", 15]], layout: { "text-padding": 2, "text-font": ["Noto Sans Regular"], "text-anchor": "top", "icon-image": "{class}_11", "text-field": `{name:latin}
+{name:nonlatin}`, "text-offset": [0, 0.6], "text-size": 12, "text-max-width": 9 }, paint: { "text-halo-blur": 0.5, "text-color": "#666", "text-halo-width": 1, "text-halo-color": "#ffffff" } }, { id: "poi-level-1", type: "symbol", source: "openmaptiles", "source-layer": "poi", minzoom: 14, filter: ["all", ["==", "$type", "Point"], ["<=", "rank", 14], ["has", "name"]], layout: { "text-padding": 2, "text-font": ["Noto Sans Regular"], "text-anchor": "top", "icon-image": "{class}_11", "text-field": `{name:latin}
+{name:nonlatin}`, "text-offset": [0, 0.6], "text-size": 11, "text-max-width": 9 }, paint: { "text-halo-blur": 0.5, "text-color": "rgba(191, 228, 172, 1)", "text-halo-width": 1, "text-halo-color": "rgba(30, 29, 29, 1)" } }, { id: "poi-railway", type: "symbol", source: "openmaptiles", "source-layer": "poi", minzoom: 13, filter: ["all", ["==", "$type", "Point"], ["has", "name"], ["==", "class", "railway"], ["==", "subclass", "station"]], layout: { "text-padding": 2, "text-font": ["Noto Sans Regular"], "text-anchor": "top", "icon-image": "{class}_11", "text-field": `{name:latin}
+{name:nonlatin}`, "text-offset": [0, 0.6], "text-size": 12, "text-max-width": 9, "icon-optional": false, "icon-ignore-placement": false, "icon-allow-overlap": false, "text-ignore-placement": false, "text-allow-overlap": false, "text-optional": true }, paint: { "text-halo-blur": 0.5, "text-color": "#666", "text-halo-width": 1, "text-halo-color": "#ffffff" } }, { id: "road_oneway", type: "symbol", source: "openmaptiles", "source-layer": "transportation", minzoom: 15, filter: ["all", ["==", "oneway", 1], ["in", "class", "motorway", "trunk", "primary", "secondary", "tertiary", "minor", "service"]], layout: { "symbol-placement": "line", "icon-image": "oneway", "symbol-spacing": 75, "icon-padding": 2, "icon-rotation-alignment": "map", "icon-rotate": 90, "icon-size": { stops: [[15, 0.5], [19, 1]] } }, paint: { "icon-opacity": 0.5 } }, { id: "road_oneway_opposite", type: "symbol", source: "openmaptiles", "source-layer": "transportation", minzoom: 15, filter: ["all", ["==", "oneway", -1], ["in", "class", "motorway", "trunk", "primary", "secondary", "tertiary", "minor", "service"]], layout: { "symbol-placement": "line", "icon-image": "oneway", "symbol-spacing": 75, "icon-padding": 2, "icon-rotation-alignment": "map", "icon-rotate": -90, "icon-size": { stops: [[15, 0.5], [19, 1]] } }, paint: { "icon-opacity": 0.5 } }, { id: "highway-name-path", type: "symbol", source: "openmaptiles", "source-layer": "transportation_name", minzoom: 15.5, filter: ["==", "class", "path"], layout: { "text-size": { base: 1, stops: [[13, 12], [14, 13]] }, "text-font": ["Noto Sans Regular"], "text-field": "{name:latin} {name:nonlatin}", "symbol-placement": "line", "text-rotation-alignment": "map" }, paint: { "text-halo-color": "#f8f4f0", "text-color": "hsl(30, 23%, 62%)", "text-halo-width": 0.5 } }, { id: "highway-name-minor", type: "symbol", source: "openmaptiles", "source-layer": "transportation_name", minzoom: 15, filter: ["all", ["==", "$type", "LineString"], ["in", "class", "minor", "service", "track"]], layout: { "text-size": { base: 1, stops: [[13, 12], [14, 13]] }, "text-font": ["Noto Sans Regular"], "text-field": "{name:latin} {name:nonlatin}", "symbol-placement": "line", "text-rotation-alignment": "map" }, paint: { "text-halo-blur": 0.5, "text-color": "#765", "text-halo-width": 1 } }, { id: "highway-name-major", type: "symbol", source: "openmaptiles", "source-layer": "transportation_name", minzoom: 12.2, filter: ["in", "class", "primary", "secondary", "tertiary", "trunk"], layout: { "text-size": { base: 1, stops: [[13, 12], [14, 13]] }, "text-font": ["Noto Sans Regular"], "text-field": "{name:latin} {name:nonlatin}", "symbol-placement": "line", "text-rotation-alignment": "map" }, paint: { "text-halo-blur": 0.5, "text-color": "#765", "text-halo-width": 1 } }, { id: "highway-shield", type: "symbol", source: "openmaptiles", "source-layer": "transportation_name", minzoom: 8, filter: ["all", ["<=", "ref_length", 6], ["==", "$type", "LineString"], ["!in", "network", "us-interstate", "us-highway", "us-state"]], layout: { "text-size": 10, "icon-image": "road_{ref_length}", "icon-rotation-alignment": "viewport", "symbol-spacing": 200, "text-font": ["Noto Sans Regular"], "symbol-placement": { base: 1, stops: [[10, "point"], [11, "line"]] }, "text-rotation-alignment": "viewport", "icon-size": 1, "text-field": "{ref}" }, paint: { "text-opacity": 1, "text-color": "rgba(20, 19, 19, 1)", "text-halo-color": "rgba(230, 221, 221, 0)", "text-halo-width": 2, "icon-color": "rgba(183, 18, 18, 1)", "icon-opacity": 0.3, "icon-halo-color": "rgba(183, 55, 55, 0)" } }, { id: "highway-shield-us-interstate", type: "symbol", source: "openmaptiles", "source-layer": "transportation_name", minzoom: 7, filter: ["all", ["<=", "ref_length", 6], ["==", "$type", "LineString"], ["in", "network", "us-interstate"]], layout: { "text-size": 10, "icon-image": "{network}_{ref_length}", "icon-rotation-alignment": "viewport", "symbol-spacing": 200, "text-font": ["Noto Sans Regular"], "symbol-placement": { base: 1, stops: [[7, "point"], [7, "line"], [8, "line"]] }, "text-rotation-alignment": "viewport", "icon-size": 1, "text-field": "{ref}" }, paint: { "text-color": "rgba(0, 0, 0, 1)" } }, { id: "highway-shield-us-other", type: "symbol", source: "openmaptiles", "source-layer": "transportation_name", minzoom: 9, filter: ["all", ["<=", "ref_length", 6], ["==", "$type", "LineString"], ["in", "network", "us-highway", "us-state"]], layout: { "text-size": 10, "icon-image": "{network}_{ref_length}", "icon-rotation-alignment": "viewport", "symbol-spacing": 200, "text-font": ["Noto Sans Regular"], "symbol-placement": { base: 1, stops: [[10, "point"], [11, "line"]] }, "text-rotation-alignment": "viewport", "icon-size": 1, "text-field": "{ref}" }, paint: { "text-color": "rgba(0, 0, 0, 1)" } }, { id: "place-other", type: "symbol", metadata: { "mapbox:group": "1444849242106.713" }, source: "openmaptiles", "source-layer": "place", minzoom: 12, filter: ["!in", "class", "city", "town", "village", "country", "continent"], layout: { "text-letter-spacing": 0.1, "text-size": { base: 1.2, stops: [[12, 10], [15, 14]] }, "text-font": ["Noto Sans Bold"], "text-field": `{name:latin}
+{name:nonlatin}`, "text-transform": "uppercase", "text-max-width": 9, visibility: "visible" }, paint: { "text-color": "rgba(255,255,255,1)", "text-halo-width": 1.2, "text-halo-color": "rgba(57, 28, 28, 1)" } }, { id: "place-village", type: "symbol", metadata: { "mapbox:group": "1444849242106.713" }, source: "openmaptiles", "source-layer": "place", minzoom: 10, filter: ["==", "class", "village"], layout: { "text-font": ["Noto Sans Regular"], "text-size": { base: 1.2, stops: [[10, 12], [15, 16]] }, "text-field": `{name:latin}
+{name:nonlatin}`, "text-max-width": 8, visibility: "visible" }, paint: { "text-color": "rgba(255, 255, 255, 1)", "text-halo-width": 1.2, "text-halo-color": "rgba(10, 9, 9, 0.8)" } }, { id: "place-town", type: "symbol", metadata: { "mapbox:group": "1444849242106.713" }, source: "openmaptiles", "source-layer": "place", filter: ["==", "class", "town"], layout: { "text-font": ["Noto Sans Regular"], "text-size": { base: 1.2, stops: [[10, 14], [15, 24]] }, "text-field": `{name:latin}
+{name:nonlatin}`, "text-max-width": 8, visibility: "visible" }, paint: { "text-color": "rgba(255, 255, 255, 1)", "text-halo-width": 1.2, "text-halo-color": "rgba(22, 22, 22, 0.8)" } }, { id: "place-city", type: "symbol", metadata: { "mapbox:group": "1444849242106.713" }, source: "openmaptiles", "source-layer": "place", filter: ["all", ["!=", "capital", 2], ["==", "class", "city"]], layout: { "text-font": ["Noto Sans Regular"], "text-size": { base: 1.2, stops: [[7, 14], [11, 24]] }, "text-field": `{name:latin}
+{name:nonlatin}`, "text-max-width": 8, visibility: "visible" }, paint: { "text-color": "rgba(0, 0, 0, 1)", "text-halo-width": 1.2, "text-halo-color": "rgba(255,255,255,0.8)" } }, { id: "place-city-capital", type: "symbol", metadata: { "mapbox:group": "1444849242106.713" }, source: "openmaptiles", "source-layer": "place", filter: ["all", ["==", "capital", 2], ["==", "class", "city"]], layout: { "text-font": ["Noto Sans Regular"], "text-size": { base: 1.2, stops: [[7, 14], [11, 24]] }, "text-field": `{name:latin}
+{name:nonlatin}`, "text-max-width": 8, "icon-image": "star_11", "text-offset": [0.4, 0], "icon-size": 0.8, "text-anchor": "left", visibility: "visible" }, paint: { "text-color": "#333", "text-halo-width": 1.2, "text-halo-color": "rgba(255,255,255,0.8)" } }, { id: "place-country-other", type: "symbol", metadata: { "mapbox:group": "1444849242106.713" }, source: "openmaptiles", "source-layer": "place", filter: ["all", ["==", "class", "country"], [">=", "rank", 3], ["!has", "iso_a2"]], layout: { "text-font": ["Noto Sans Italic"], "text-field": "{name:latin}", "text-size": { stops: [[3, 11], [7, 17]] }, "text-transform": "uppercase", "text-max-width": 6.25, visibility: "visible" }, paint: { "text-halo-blur": 1, "text-color": "#334", "text-halo-width": 2, "text-halo-color": "rgba(255,255,255,0.8)" } }, { id: "place-country-3", type: "symbol", metadata: { "mapbox:group": "1444849242106.713" }, source: "openmaptiles", "source-layer": "place", filter: ["all", ["==", "class", "country"], [">=", "rank", 3], ["has", "iso_a2"]], layout: { "text-font": ["Noto Sans Bold"], "text-field": "{name:latin}", "text-size": { stops: [[3, 11], [7, 17]] }, "text-transform": "uppercase", "text-max-width": 6.25, visibility: "visible" }, paint: { "text-halo-blur": 1, "text-color": "#334", "text-halo-width": 2, "text-halo-color": "rgba(255,255,255,0.8)" } }, { id: "place-country-2", type: "symbol", metadata: { "mapbox:group": "1444849242106.713" }, source: "openmaptiles", "source-layer": "place", filter: ["all", ["==", "class", "country"], ["==", "rank", 2], ["has", "iso_a2"]], layout: { "text-font": ["Noto Sans Bold"], "text-field": "{name:latin}", "text-size": { stops: [[2, 11], [5, 17]] }, "text-transform": "uppercase", "text-max-width": 6.25, visibility: "visible" }, paint: { "text-halo-blur": 1, "text-color": "#334", "text-halo-width": 2, "text-halo-color": "rgba(255,255,255,0.8)" } }, { id: "place-country-1", type: "symbol", metadata: { "mapbox:group": "1444849242106.713" }, source: "openmaptiles", "source-layer": "place", filter: ["all", ["==", "class", "country"], ["==", "rank", 1], ["has", "iso_a2"]], layout: { "text-font": ["Noto Sans Bold"], "text-field": "{name:latin}", "text-size": { stops: [[1, 11], [4, 17]] }, "text-transform": "uppercase", "text-max-width": 6.25, visibility: "visible" }, paint: { "text-halo-blur": 1, "text-color": "#334", "text-halo-width": 2, "text-halo-color": "rgba(255,255,255,0.8)" } }, { id: "place-continent", type: "symbol", metadata: { "mapbox:group": "1444849242106.713" }, source: "openmaptiles", "source-layer": "place", maxzoom: 1, filter: ["==", "class", "continent"], layout: { "text-font": ["Noto Sans Bold"], "text-field": "{name:latin}", "text-size": 14, "text-max-width": 6.25, "text-transform": "uppercase", visibility: "visible" }, paint: { "text-halo-blur": 1, "text-color": "#334", "text-halo-width": 2, "text-halo-color": "rgba(255,255,255,0.8)" } }], id: "qebnlkra6" };
+      });
+      var EHe = ye((rbr, MHe) => {
+        MHe.exports = { version: 8, name: "orto", metadata: {}, center: [1.537786, 41.837539], zoom: 12, bearing: 0, pitch: 0, light: { anchor: "viewport", color: "white", intensity: 0.4, position: [1.15, 45, 30] }, sources: { ortoEsri: { type: "raster", tiles: ["https://server.arcgisonline.com/ArcGIS/rest/services/World_Imagery/MapServer/tile/{z}/{y}/{x}"], tileSize: 256, maxzoom: 18, attribution: "ESRI &copy; <a href='http://www.esri.com'>ESRI</a>" }, ortoInstaMaps: { type: "raster", tiles: ["https://tilemaps.icgc.cat/mapfactory/wmts/orto_8_12/CAT3857/{z}/{x}/{y}.png"], tileSize: 256, maxzoom: 13 }, ortoICGC: { type: "raster", tiles: ["https://geoserveis.icgc.cat/icc_mapesmultibase/noutm/wmts/orto/GRID3857/{z}/{x}/{y}.jpeg"], tileSize: 256, minzoom: 13.1, maxzoom: 20 }, openmaptiles: { type: "vector", url: "https://geoserveis.icgc.cat/contextmaps/basemap.json" } }, sprite: "https://geoserveis.icgc.cat/contextmaps/sprites/sprite@1", glyphs: "https://geoserveis.icgc.cat/contextmaps/glyphs/{fontstack}/{range}.pbf", layers: [{ id: "background", type: "background", paint: { "background-color": "#F4F9F4" } }, { id: "ortoEsri", type: "raster", source: "ortoEsri", maxzoom: 16, layout: { visibility: "visible" } }, { id: "ortoICGC", type: "raster", source: "ortoICGC", minzoom: 13.1, maxzoom: 19, layout: { visibility: "visible" } }, { id: "ortoInstaMaps", type: "raster", source: "ortoInstaMaps", maxzoom: 13, layout: { visibility: "visible" } }] };
+      });
+      var Px = ye((ibr, IHe) => {
+        var VWt = t_(), GWt = SHe(), HWt = EHe(), jWt = '© <a target="_blank" href="https://www.openstreetmap.org/copyright">OpenStreetMap</a> contributors', kHe = "https://basemaps.cartocdn.com/gl/positron-gl-style/style.json", CHe = "https://basemaps.cartocdn.com/gl/dark-matter-gl-style/style.json", s7 = "https://basemaps.cartocdn.com/gl/voyager-gl-style/style.json", WWt = "https://basemaps.cartocdn.com/gl/positron-nolabels-gl-style/style.json", XWt = "https://basemaps.cartocdn.com/gl/dark-matter-nolabels-gl-style/style.json", ZWt = "https://basemaps.cartocdn.com/gl/voyager-nolabels-gl-style/style.json", PHe = { basic: s7, streets: s7, outdoors: s7, light: kHe, dark: CHe, satellite: HWt, "satellite-streets": GWt, "open-street-map": { id: "osm", version: 8, sources: { "plotly-osm-tiles": { type: "raster", attribution: jWt, tiles: ["https://tile.openstreetmap.org/{z}/{x}/{y}.png"], tileSize: 256 } }, layers: [{ id: "plotly-osm-tiles", type: "raster", source: "plotly-osm-tiles", minzoom: 0, maxzoom: 22 }], glyphs: "https://fonts.openmaptiles.org/{fontstack}/{range}.pbf" }, "white-bg": { id: "white-bg", version: 8, sources: {}, layers: [{ id: "white-bg", type: "background", paint: { "background-color": "#FFFFFF" }, minzoom: 0, maxzoom: 22 }], glyphs: "https://fonts.openmaptiles.org/{fontstack}/{range}.pbf" }, "carto-positron": kHe, "carto-darkmatter": CHe, "carto-voyager": s7, "carto-positron-nolabels": WWt, "carto-darkmatter-nolabels": XWt, "carto-voyager-nolabels": ZWt }, LHe = VWt(PHe);
+        IHe.exports = { styleValueDflt: "basic", stylesMap: PHe, styleValuesMap: LHe, traceLayerPrefix: "plotly-trace-layer-", layoutLayerPrefix: "plotly-layout-layer-", missingStyleErrorMsg: ["No valid maplibre style found, please set `map.style` to one of:", LHe.join(", "), "or use a tile service."].join(`
+`), mapOnErrorMsg: "Map error." };
+      });
+      var Qk = ye((nbr, OHe) => {
+        var RHe = Dr(), DHe = ka().defaultLine, YWt = Cc().attributes, KWt = ec(), JWt = pf().textposition, $Wt = mc().overrideAll, QWt = vl().templatedArray, FHe = Px(), zHe = KWt({ noFontVariant: true, noFontShadow: true, noFontLineposition: true, noFontTextcase: true });
+        zHe.family.dflt = "Open Sans Regular, Arial Unicode MS Regular";
+        var eXt = OHe.exports = $Wt({ _arrayAttrRegexps: [RHe.counterRegex("map", ".layers", true)], domain: YWt({ name: "map" }), style: { valType: "any", values: FHe.styleValuesMap, dflt: FHe.styleValueDflt }, center: { lon: { valType: "number", dflt: 0 }, lat: { valType: "number", dflt: 0 } }, zoom: { valType: "number", dflt: 1 }, bearing: { valType: "number", dflt: 0 }, pitch: { valType: "number", dflt: 0 }, bounds: { west: { valType: "number" }, east: { valType: "number" }, south: { valType: "number" }, north: { valType: "number" } }, layers: QWt("layer", { visible: { valType: "boolean", dflt: true }, sourcetype: { valType: "enumerated", values: ["geojson", "vector", "raster", "image"], dflt: "geojson" }, source: { valType: "any" }, sourcelayer: { valType: "string", dflt: "" }, sourceattribution: { valType: "string" }, type: { valType: "enumerated", values: ["circle", "line", "fill", "symbol", "raster"], dflt: "circle" }, coordinates: { valType: "any" }, below: { valType: "string" }, color: { valType: "color", dflt: DHe }, opacity: { valType: "number", min: 0, max: 1, dflt: 1 }, minzoom: { valType: "number", min: 0, max: 24, dflt: 0 }, maxzoom: { valType: "number", min: 0, max: 24, dflt: 24 }, circle: { radius: { valType: "number", dflt: 15 } }, line: { width: { valType: "number", dflt: 2 }, dash: { valType: "data_array" } }, fill: { outlinecolor: { valType: "color", dflt: DHe } }, symbol: { icon: { valType: "string", dflt: "marker" }, iconsize: { valType: "number", dflt: 10 }, text: { valType: "string", dflt: "" }, placement: { valType: "enumerated", values: ["point", "line", "line-center"], dflt: "point" }, textfont: zHe, textposition: RHe.extendFlat({}, JWt, { arrayOk: false }) } }) }, "plot", "from-root");
+        eXt.uirevision = { valType: "any", editType: "none" };
+      });
+      var l7 = ye((abr, UHe) => {
+        var { hovertemplateAttrs: tXt, texttemplateAttrs: rXt, templatefallbackAttrs: qHe } = Ll(), iXt = Pg(), eC = ew(), P5 = pf(), BHe = Qk(), nXt = Gl(), aXt = Tu(), dw = Ao().extendFlat, oXt = mc().overrideAll, sXt = Qk(), NHe = eC.line, I5 = eC.marker;
+        UHe.exports = oXt({ lon: eC.lon, lat: eC.lat, cluster: { enabled: { valType: "boolean" }, maxzoom: dw({}, sXt.layers.maxzoom, {}), step: { valType: "number", arrayOk: true, dflt: -1, min: -1 }, size: { valType: "number", arrayOk: true, dflt: 20, min: 0 }, color: { valType: "color", arrayOk: true }, opacity: dw({}, I5.opacity, { dflt: 1 }) }, mode: dw({}, P5.mode, { dflt: "markers" }), text: dw({}, P5.text, {}), texttemplate: rXt({ editType: "plot" }, { keys: ["lat", "lon", "text"] }), texttemplatefallback: qHe({ editType: "plot" }), hovertext: dw({}, P5.hovertext, {}), line: { color: NHe.color, width: NHe.width }, connectgaps: P5.connectgaps, marker: dw({ symbol: { valType: "string", dflt: "circle", arrayOk: true }, angle: { valType: "number", dflt: "auto", arrayOk: true }, allowoverlap: { valType: "boolean", dflt: false }, opacity: I5.opacity, size: I5.size, sizeref: I5.sizeref, sizemin: I5.sizemin, sizemode: I5.sizemode }, aXt("marker")), fill: eC.fill, fillcolor: iXt(), textfont: BHe.layers.symbol.textfont, textposition: BHe.layers.symbol.textposition, below: { valType: "string" }, selected: { marker: P5.selected.marker }, unselected: { marker: P5.unselected.marker }, hoverinfo: dw({}, nXt.hoverinfo, { flags: ["lon", "lat", "text", "name"] }), hovertemplate: tXt(), hovertemplatefallback: qHe() }, "calc", "nested");
+      });
+      var CJ = ye((obr, VHe) => {
+        var lXt = ["Metropolis Black Italic", "Metropolis Black", "Metropolis Bold Italic", "Metropolis Bold", "Metropolis Extra Bold Italic", "Metropolis Extra Bold", "Metropolis Extra Light Italic", "Metropolis Extra Light", "Metropolis Light Italic", "Metropolis Light", "Metropolis Medium Italic", "Metropolis Medium", "Metropolis Regular Italic", "Metropolis Regular", "Metropolis Semi Bold Italic", "Metropolis Semi Bold", "Metropolis Thin Italic", "Metropolis Thin", "Open Sans Bold Italic", "Open Sans Bold", "Open Sans Extrabold Italic", "Open Sans Extrabold", "Open Sans Italic", "Open Sans Light Italic", "Open Sans Light", "Open Sans Regular", "Open Sans Semibold Italic", "Open Sans Semibold", "Klokantech Noto Sans Bold", "Klokantech Noto Sans CJK Bold", "Klokantech Noto Sans CJK Regular", "Klokantech Noto Sans Italic", "Klokantech Noto Sans Regular"];
+        VHe.exports = { isSupportedFont: function(e) {
+          return lXt.indexOf(e) !== -1;
+        } };
+      });
+      var jHe = ye((sbr, HHe) => {
+        var tC = Dr(), LJ = Ru(), uXt = $p(), cXt = D0(), fXt = F0(), hXt = Fg(), GHe = l7(), dXt = CJ().isSupportedFont;
+        HHe.exports = function(t, r, n, i) {
+          function a(p, k) {
+            return tC.coerce(t, r, GHe, p, k);
+          }
+          function o(p, k) {
+            return tC.coerce2(t, r, GHe, p, k);
+          }
+          var s = vXt(t, r, a);
+          if (!s) {
+            r.visible = false;
+            return;
+          }
+          if (a("text"), a("texttemplate"), a("texttemplatefallback"), a("hovertext"), a("hovertemplate"), a("hovertemplatefallback"), a("mode"), a("below"), LJ.hasMarkers(r)) {
+            uXt(t, r, n, i, a, { noLine: true, noAngle: true }), a("marker.allowoverlap"), a("marker.angle");
+            var l = r.marker;
+            l.symbol !== "circle" && (tC.isArrayOrTypedArray(l.size) && (l.size = l.size[0]), tC.isArrayOrTypedArray(l.color) && (l.color = l.color[0]));
+          }
+          LJ.hasLines(r) && (cXt(t, r, n, i, a, { noDash: true }), a("connectgaps"));
+          var u = o("cluster.maxzoom"), c = o("cluster.step"), f = o("cluster.color", r.marker && r.marker.color || n), h = o("cluster.size"), d = o("cluster.opacity"), v = u !== false || c !== false || f !== false || h !== false || d !== false, _ = a("cluster.enabled", v);
+          if (_ || LJ.hasText(r)) {
+            var b = i.font.family;
+            fXt(t, r, i, a, { noSelect: true, noFontVariant: true, noFontShadow: true, noFontLineposition: true, noFontTextcase: true, font: { family: dXt(b) ? b : "Open Sans Regular", weight: i.font.weight, style: i.font.style, size: i.font.size, color: i.font.color } });
+          }
+          a("fill"), r.fill !== "none" && hXt(t, r, n, a), tC.coerceSelectionMarkerOpacity(r, a);
+        };
+        function vXt(e, t, r) {
+          var n = r("lon") || [], i = r("lat") || [], a = Math.min(n.length, i.length);
+          return t._length = a, a;
+        }
+      });
+      var PJ = ye((lbr, XHe) => {
+        var WHe = ho();
+        XHe.exports = function(t, r, n) {
+          var i = {}, a = n[r.subplot]._subplot, o = a.mockAxis, s = t.lonlat;
+          return i.lonLabel = WHe.tickText(o, o.c2l(s[0]), true).text, i.latLabel = WHe.tickText(o, o.c2l(s[1]), true).text, i;
+        };
+      });
+      var IJ = ye((ubr, YHe) => {
+        var ZHe = Dr();
+        YHe.exports = function(t, r) {
+          var n = t.split(" "), i = n[0], a = n[1], o = ZHe.isArrayOrTypedArray(r) ? ZHe.mean(r) : r, s = 0.5 + o / 100, l = 1.5 + o / 100, u = ["", ""], c = [0, 0];
+          switch (i) {
+            case "top":
+              u[0] = "top", c[1] = -l;
+              break;
+            case "bottom":
+              u[0] = "bottom", c[1] = l;
+              break;
+          }
+          switch (a) {
+            case "left":
+              u[1] = "right", c[0] = -s;
+              break;
+            case "right":
+              u[1] = "left", c[0] = s;
+              break;
+          }
+          var f;
+          return u[0] && u[1] ? f = u.join("-") : u[0] ? f = u[0] : u[1] ? f = u[1] : f = "center", { anchor: f, offset: c };
+        };
+      });
+      var tje = ye((cbr, eje) => {
+        var $He = Eo(), ov = Dr(), pXt = fs().BADNUM, c7 = cx(), KHe = tc(), gXt = So(), mXt = O3(), f7 = Ru(), yXt = CJ().isSupportedFont, _Xt = IJ(), xXt = ip().appendArrayPointValue, bXt = Zl().NEWLINES, wXt = Zl().BR_TAG_ALL;
+        eje.exports = function(t, r) {
+          var n = r[0].trace, i = n.visible === true && n._length !== 0, a = n.fill !== "none", o = f7.hasLines(n), s = f7.hasMarkers(n), l = f7.hasText(n), u = s && n.marker.symbol === "circle", c = s && n.marker.symbol !== "circle", f = n.cluster && n.cluster.enabled, h = u7("fill"), d = u7("line"), v = u7("circle"), _ = u7("symbol"), b = { fill: h, line: d, circle: v, symbol: _ };
+          if (!i) return b;
+          var p;
+          if ((a || o) && (p = c7.calcTraceToLineCoords(r)), a && (h.geojson = c7.makePolygon(p), h.layout.visibility = "visible", ov.extendFlat(h.paint, { "fill-color": n.fillcolor })), o && (d.geojson = c7.makeLine(p), d.layout.visibility = "visible", ov.extendFlat(d.paint, { "line-width": n.line.width, "line-color": n.line.color, "line-opacity": n.opacity })), u) {
+            var k = TXt(r);
+            v.geojson = k.geojson, v.layout.visibility = "visible", f && (v.filter = ["!", ["has", "point_count"]], b.cluster = { type: "circle", filter: ["has", "point_count"], layout: { visibility: "visible" }, paint: { "circle-color": DJ(n.cluster.color, n.cluster.step), "circle-radius": DJ(n.cluster.size, n.cluster.step), "circle-opacity": DJ(n.cluster.opacity, n.cluster.step) } }, b.clusterCount = { type: "symbol", filter: ["has", "point_count"], paint: {}, layout: { "text-field": "{point_count_abbreviated}", "text-font": JHe(n), "text-size": 12 } }), ov.extendFlat(v.paint, { "circle-color": k.mcc, "circle-radius": k.mrc, "circle-opacity": k.mo });
+          }
+          if (u && f && (v.filter = ["!", ["has", "point_count"]]), (c || l) && (_.geojson = AXt(r, t), ov.extendFlat(_.layout, { visibility: "visible", "icon-image": "{symbol}-15", "text-field": "{text}" }), c && (ov.extendFlat(_.layout, { "icon-size": n.marker.size / 10 }), "angle" in n.marker && n.marker.angle !== "auto" && ov.extendFlat(_.layout, { "icon-rotate": { type: "identity", property: "angle" }, "icon-rotation-alignment": "map" }), _.layout["icon-allow-overlap"] = n.marker.allowoverlap, ov.extendFlat(_.paint, { "icon-opacity": n.opacity * n.marker.opacity, "icon-color": n.marker.color })), l)) {
+            var E = (n.marker || {}).size, T = _Xt(n.textposition, E);
+            ov.extendFlat(_.layout, { "text-size": n.textfont.size, "text-anchor": T.anchor, "text-offset": T.offset, "text-font": JHe(n) }), ov.extendFlat(_.paint, { "text-color": n.textfont.color, "text-opacity": n.opacity });
+          }
+          return b;
+        };
+        function u7(e) {
+          return { type: e, geojson: c7.makeBlank(), layout: { visibility: "none" }, filter: null, paint: {} };
+        }
+        function TXt(e) {
+          var t = e[0].trace, r = t.marker, n = t.selectedpoints, i = ov.isArrayOrTypedArray(r.color), a = ov.isArrayOrTypedArray(r.size), o = ov.isArrayOrTypedArray(r.opacity), s;
+          function l(E) {
+            return t.opacity * E;
+          }
+          function u(E) {
+            return E / 2;
+          }
+          var c;
+          i && (KHe.hasColorscale(t, "marker") ? c = KHe.makeColorScaleFuncFromTrace(r) : c = ov.identity);
+          var f;
+          a && (f = mXt(t));
+          var h;
+          o && (h = function(E) {
+            var T = $He(E) ? +ov.constrain(E, 0, 1) : 0;
+            return l(T);
+          });
+          var d = [];
+          for (s = 0; s < e.length; s++) {
+            var v = e[s], _ = v.lonlat;
+            if (!QHe(_)) {
+              var b = {};
+              c && (b.mcc = v.mcc = c(v.mc)), f && (b.mrc = v.mrc = f(v.ms)), h && (b.mo = h(v.mo)), n && (b.selected = v.selected || 0), d.push({ type: "Feature", id: s + 1, geometry: { type: "Point", coordinates: _ }, properties: b });
+            }
+          }
+          var p;
+          if (n) for (p = gXt.makeSelectedPointStyleFns(t), s = 0; s < d.length; s++) {
+            var k = d[s].properties;
+            p.selectedOpacityFn && (k.mo = l(p.selectedOpacityFn(k))), p.selectedColorFn && (k.mcc = p.selectedColorFn(k)), p.selectedSizeFn && (k.mrc = p.selectedSizeFn(k));
+          }
+          return { geojson: { type: "FeatureCollection", features: d }, mcc: i || p && p.selectedColorFn ? { type: "identity", property: "mcc" } : r.color, mrc: a || p && p.selectedSizeFn ? { type: "identity", property: "mrc" } : u(r.size), mo: o || p && p.selectedOpacityFn ? { type: "identity", property: "mo" } : l(r.opacity) };
+        }
+        function AXt(e, t) {
+          for (var r = t._fullLayout, n = e[0].trace, i = n.marker || {}, a = i.symbol, o = i.angle, s = a !== "circle" ? RJ(a) : h7, l = o !== "auto" ? RJ(o, true) : h7, u = f7.hasText(n) ? RJ(n.text) : h7, c = [], f = 0; f < e.length; f++) {
+            var h = e[f];
+            if (!QHe(h.lonlat)) {
+              var d = n.texttemplate, v;
+              if (d) {
+                var _ = Array.isArray(d) ? d[f] || "" : d, b = n._module.formatLabels(h, n, r), p = {};
+                xXt(p, n, h.i), v = ov.texttemplateString({ data: [p, h, n._meta], fallback: n.texttemplatefallback, labels: b, locale: r._d3locale, template: _ });
+              } else v = u(f);
+              v && (v = v.replace(bXt, "").replace(wXt, `
+`)), c.push({ type: "Feature", geometry: { type: "Point", coordinates: h.lonlat }, properties: { symbol: s(f), angle: l(f), text: v } });
+            }
+          }
+          return { type: "FeatureCollection", features: c };
+        }
+        function RJ(e, t) {
+          return ov.isArrayOrTypedArray(e) ? t ? function(r) {
+            return $He(e[r]) ? +e[r] : 0;
+          } : function(r) {
+            return e[r];
+          } : e ? function() {
+            return e;
+          } : h7;
+        }
+        function h7() {
+          return "";
+        }
+        function QHe(e) {
+          return e[0] === pXt;
+        }
+        function DJ(e, t) {
+          var r;
+          if (ov.isArrayOrTypedArray(e) && ov.isArrayOrTypedArray(t)) {
+            r = ["step", ["get", "point_count"], e[0]];
+            for (var n = 1; n < e.length; n++) r.push(t[n - 1], e[n]);
+          } else r = e;
+          return r;
+        }
+        function JHe(e) {
+          var t = e.textfont, r = t.family, n = t.style, i = t.weight, a = r.split(" "), o = a[a.length - 1] === "Italic";
+          o && a.pop(), o = o || n === "italic";
+          var s = a.join(" ");
+          i === "bold" && a.indexOf("Bold") === -1 ? s += " Bold" : i <= 1e3 && (a[0] === "Metropolis" ? (s = "Metropolis", i > 850 ? s += " Black" : i > 750 ? s += " Extra Bold" : i > 650 ? s += " Bold" : i > 550 ? s += " Semi Bold" : i > 450 ? s += " Medium" : i > 350 ? s += " Regular" : i > 250 ? s += " Light" : i > 150 ? s += " Extra Light" : s += " Thin") : a.slice(0, 2).join(" ") === "Open Sans" ? (s = "Open Sans", i > 750 ? s += " Extrabold" : i > 650 ? s += " Bold" : i > 550 ? s += " Semibold" : i > 350 ? s += " Regular" : s += " Light") : a.slice(0, 3).join(" ") === "Klokantech Noto Sans" && (s = "Klokantech Noto Sans", a[3] === "CJK" && (s += " CJK"), s += i > 500 ? " Bold" : " Regular")), o && (s += " Italic"), s === "Open Sans Regular Italic" ? s = "Open Sans Italic" : s === "Open Sans Regular Bold" ? s = "Open Sans Bold" : s === "Open Sans Regular Bold Italic" ? s = "Open Sans Bold Italic" : s === "Klokantech Noto Sans Regular Italic" && (s = "Klokantech Noto Sans Italic"), yXt(s) || (s = r);
+          var l = s.split(", ");
+          return l;
+        }
+      });
+      var aje = ye((fbr, nje) => {
+        var SXt = Dr(), rje = tje(), R5 = Px().traceLayerPrefix, og = { cluster: ["cluster", "clusterCount", "circle"], nonCluster: ["fill", "line", "circle", "symbol"] };
+        function ije(e, t, r, n) {
+          this.type = "scattermap", this.subplot = e, this.uid = t, this.clusterEnabled = r, this.isHidden = n, this.sourceIds = { fill: "source-" + t + "-fill", line: "source-" + t + "-line", circle: "source-" + t + "-circle", symbol: "source-" + t + "-symbol", cluster: "source-" + t + "-circle", clusterCount: "source-" + t + "-circle" }, this.layerIds = { fill: R5 + t + "-fill", line: R5 + t + "-line", circle: R5 + t + "-circle", symbol: R5 + t + "-symbol", cluster: R5 + t + "-cluster", clusterCount: R5 + t + "-cluster-count" }, this.below = null;
+        }
+        var rC = ije.prototype;
+        rC.addSource = function(e, t, r) {
+          var n = { type: "geojson", data: t.geojson };
+          r && r.enabled && SXt.extendFlat(n, { cluster: true, clusterMaxZoom: r.maxzoom });
+          var i = this.subplot.map.getSource(this.sourceIds[e]);
+          i ? i.setData(t.geojson) : this.subplot.map.addSource(this.sourceIds[e], n);
+        };
+        rC.setSourceData = function(e, t) {
+          this.subplot.map.getSource(this.sourceIds[e]).setData(t.geojson);
+        };
+        rC.addLayer = function(e, t, r) {
+          var n = { type: t.type, id: this.layerIds[e], source: this.sourceIds[e], layout: t.layout, paint: t.paint };
+          t.filter && (n.filter = t.filter);
+          for (var i = this.layerIds[e], a, o = this.subplot.getMapLayers(), s = 0; s < o.length; s++) if (o[s].id === i) {
+            a = true;
+            break;
+          }
+          a ? (this.subplot.setOptions(i, "setLayoutProperty", n.layout), n.layout.visibility === "visible" && this.subplot.setOptions(i, "setPaintProperty", n.paint)) : this.subplot.addLayer(n, r);
+        };
+        rC.update = function(t) {
+          var r = t[0].trace, n = this.subplot, i = n.map, a = rje(n.gd, t), o = n.belowLookup["trace-" + this.uid], s = !!(r.cluster && r.cluster.enabled), l = !!this.clusterEnabled, u = this;
+          function c(E) {
+            E || u.addSource("circle", a.circle, r.cluster);
+            for (var T = og.cluster, L = 0; L < T.length; L++) {
+              var x = T[L], C = a[x];
+              u.addLayer(x, C, o);
+            }
+          }
+          function f(E) {
+            for (var T = og.cluster, L = T.length - 1; L >= 0; L--) {
+              var x = T[L];
+              i.removeLayer(u.layerIds[x]);
+            }
+            E || i.removeSource(u.sourceIds.circle);
+          }
+          function h(E) {
+            for (var T = og.nonCluster, L = 0; L < T.length; L++) {
+              var x = T[L], C = a[x];
+              E || u.addSource(x, C), u.addLayer(x, C, o);
+            }
+          }
+          function d(E) {
+            for (var T = og.nonCluster, L = T.length - 1; L >= 0; L--) {
+              var x = T[L];
+              i.removeLayer(u.layerIds[x]), E || i.removeSource(u.sourceIds[x]);
+            }
+          }
+          function v(E) {
+            l ? f(E) : d(E);
+          }
+          function _(E) {
+            s ? c(E) : h(E);
+          }
+          function b() {
+            for (var E = s ? og.cluster : og.nonCluster, T = 0; T < E.length; T++) {
+              var L = E[T], x = a[L];
+              x && (n.setOptions(u.layerIds[L], "setLayoutProperty", x.layout), x.layout.visibility === "visible" && (L !== "cluster" && u.setSourceData(L, x), n.setOptions(u.layerIds[L], "setPaintProperty", x.paint)));
+            }
+          }
+          var p = this.isHidden, k = r.visible !== true;
+          k ? p || v() : p ? k || _() : l !== s ? (v(), _()) : (this.below !== o && (v(true), _(true)), b()), this.clusterEnabled = s, this.isHidden = k, this.below = o, t[0].trace._glTrace = this;
+        };
+        rC.dispose = function() {
+          for (var t = this.subplot.map, r = this.clusterEnabled ? og.cluster : og.nonCluster, n = r.length - 1; n >= 0; n--) {
+            var i = r[n];
+            t.removeLayer(this.layerIds[i]), t.removeSource(this.sourceIds[i]);
+          }
+        };
+        nje.exports = function(t, r) {
+          var n = r[0].trace, i = n.cluster && n.cluster.enabled, a = n.visible !== true, o = new ije(t, n.uid, i, a), s = rje(t.gd, r), l = o.below = t.belowLookup["trace-" + n.uid], u, c, f;
+          if (i) for (o.addSource("circle", s.circle, n.cluster), u = 0; u < og.cluster.length; u++) c = og.cluster[u], f = s[c], o.addLayer(c, f, l);
+          else for (u = 0; u < og.nonCluster.length; u++) c = og.nonCluster[u], f = s[c], o.addSource(c, f, n.cluster), o.addLayer(c, f, l);
+          return r[0].trace._glTrace = o, o;
+        };
+      });
+      var d7 = ye((hbr, sje) => {
+        var MXt = vf(), FJ = Dr(), EXt = gT(), kXt = FJ.fillText, CXt = fs().BADNUM, LXt = Px().traceLayerPrefix;
+        function PXt(e, t, r) {
+          var n = e.cd, i = n[0].trace, a = e.xa, o = e.ya, s = e.subplot, l = [], u = LXt + i.uid + "-circle", c = i.cluster && i.cluster.enabled;
+          if (c) {
+            var f = s.map.queryRenderedFeatures(null, { layers: [u] });
+            l = f.map(function(M) {
+              return M.id;
+            });
+          }
+          var h = t >= 0 ? Math.floor((t + 180) / 360) : Math.ceil((t - 180) / 360), d = h * 360, v = t - d;
+          function _(M) {
+            var g = M.lonlat;
+            if (g[0] === CXt || c && l.indexOf(M.i + 1) === -1) return 1 / 0;
+            var P = FJ.modHalf(g[0], 360), A = g[1], z = s.project([P, A]), O = z.x - a.c2p([v, A]), U = z.y - o.c2p([P, r]), G = Math.max(3, M.mrc || 0);
+            return Math.max(Math.sqrt(O * O + U * U) - G, 1 - 3 / G);
+          }
+          if (MXt.getClosest(n, _, e), e.index !== false) {
+            var b = n[e.index], p = b.lonlat, k = [FJ.modHalf(p[0], 360) + d, p[1]], E = a.c2p(k), T = o.c2p(k), L = b.mrc || 1;
+            e.x0 = E - L, e.x1 = E + L, e.y0 = T - L, e.y1 = T + L;
+            var x = {};
+            x[i.subplot] = { _subplot: s };
+            var C = i._module.formatLabels(b, i, x);
+            return e.lonLabel = C.lonLabel, e.latLabel = C.latLabel, e.color = EXt(i, b), e.extraText = oje(i, b, n[0].t.labels), e.hovertemplate = i.hovertemplate, [e];
+          }
+        }
+        function oje(e, t, r) {
+          if (e.hovertemplate) return;
+          var n = t.hi || e.hoverinfo, i = n.split("+"), a = i.indexOf("all") !== -1, o = i.indexOf("lon") !== -1, s = i.indexOf("lat") !== -1, l = t.lonlat, u = [];
+          function c(f) {
+            return f + "°";
+          }
+          return a || o && s ? u.push("(" + c(l[1]) + ", " + c(l[0]) + ")") : o ? u.push(r.lon + c(l[0])) : s && u.push(r.lat + c(l[1])), (a || i.indexOf("text") !== -1) && kXt(t, e, u), u.join("<br>");
+        }
+        sje.exports = { hoverPoints: PXt, getExtraText: oje };
+      });
+      var uje = ye((dbr, lje) => {
+        lje.exports = function(t, r) {
+          return t.lon = r.lon, t.lat = r.lat, t;
+        };
+      });
+      var fje = ye((vbr, cje) => {
+        var IXt = Dr(), RXt = Ru(), DXt = fs().BADNUM;
+        cje.exports = function(t, r) {
+          var n = t.cd, i = t.xaxis, a = t.yaxis, o = [], s = n[0].trace, l;
+          if (!RXt.hasMarkers(s)) return [];
+          if (r === false) for (l = 0; l < n.length; l++) n[l].selected = 0;
+          else for (l = 0; l < n.length; l++) {
+            var u = n[l], c = u.lonlat;
+            if (c[0] !== DXt) {
+              var f = [IXt.modHalf(c[0], 360), c[1]], h = [i.c2p(f), a.c2p(f)];
+              r.contains(h, null, l, t) ? (o.push({ pointNumber: l, lon: c[0], lat: c[1] }), u.selected = 1) : u.selected = 0;
+            }
+          }
+          return o;
+        };
+      });
+      var dje = ye((zJ, OJ) => {
+        (function(e, t) {
+          typeof zJ == "object" && typeof OJ != "undefined" ? OJ.exports = t() : (e = typeof globalThis != "undefined" ? globalThis : e || self, e.maplibregl = t());
+        })(zJ, function() {
+          var e = {}, t = {};
+          function r(i, a, o) {
+            if (t[i] = o, i === "index") {
+              var s = "var sharedModule = {}; (" + t.shared + ")(sharedModule); (" + t.worker + ")(sharedModule);", l = {};
+              return t.shared(l), t.index(e, l), typeof window != "undefined" && e.setWorkerUrl(window.URL.createObjectURL(new Blob([s], { type: "text/javascript" }))), e;
+            }
+          }
+          r("shared", ["exports"], function(i) {
+            function a(R, S, F, W) {
+              return new (F || (F = Promise))(function(te, fe) {
+                function pe(ct) {
+                  try {
+                    Ke(W.next(ct));
+                  } catch (Lt) {
+                    fe(Lt);
+                  }
+                }
+                function Fe(ct) {
+                  try {
+                    Ke(W.throw(ct));
+                  } catch (Lt) {
+                    fe(Lt);
+                  }
+                }
+                function Ke(ct) {
+                  var Lt;
+                  ct.done ? te(ct.value) : (Lt = ct.value, Lt instanceof F ? Lt : new F(function(Jt) {
+                    Jt(Lt);
+                  })).then(pe, Fe);
+                }
+                Ke((W = W.apply(R, S || [])).next());
+              });
+            }
+            function o(R) {
+              return R && R.__esModule && Object.prototype.hasOwnProperty.call(R, "default") ? R.default : R;
+            }
+            typeof SuppressedError == "function" && SuppressedError;
+            var s = l;
+            function l(R, S) {
+              this.x = R, this.y = S;
+            }
+            l.prototype = { clone: function() {
+              return new l(this.x, this.y);
+            }, add: function(R) {
+              return this.clone()._add(R);
+            }, sub: function(R) {
+              return this.clone()._sub(R);
+            }, multByPoint: function(R) {
+              return this.clone()._multByPoint(R);
+            }, divByPoint: function(R) {
+              return this.clone()._divByPoint(R);
+            }, mult: function(R) {
+              return this.clone()._mult(R);
+            }, div: function(R) {
+              return this.clone()._div(R);
+            }, rotate: function(R) {
+              return this.clone()._rotate(R);
+            }, rotateAround: function(R, S) {
+              return this.clone()._rotateAround(R, S);
+            }, matMult: function(R) {
+              return this.clone()._matMult(R);
+            }, unit: function() {
+              return this.clone()._unit();
+            }, perp: function() {
+              return this.clone()._perp();
+            }, round: function() {
+              return this.clone()._round();
+            }, mag: function() {
+              return Math.sqrt(this.x * this.x + this.y * this.y);
+            }, equals: function(R) {
+              return this.x === R.x && this.y === R.y;
+            }, dist: function(R) {
+              return Math.sqrt(this.distSqr(R));
+            }, distSqr: function(R) {
+              var S = R.x - this.x, F = R.y - this.y;
+              return S * S + F * F;
+            }, angle: function() {
+              return Math.atan2(this.y, this.x);
+            }, angleTo: function(R) {
+              return Math.atan2(this.y - R.y, this.x - R.x);
+            }, angleWith: function(R) {
+              return this.angleWithSep(R.x, R.y);
+            }, angleWithSep: function(R, S) {
+              return Math.atan2(this.x * S - this.y * R, this.x * R + this.y * S);
+            }, _matMult: function(R) {
+              var S = R[2] * this.x + R[3] * this.y;
+              return this.x = R[0] * this.x + R[1] * this.y, this.y = S, this;
+            }, _add: function(R) {
+              return this.x += R.x, this.y += R.y, this;
+            }, _sub: function(R) {
+              return this.x -= R.x, this.y -= R.y, this;
+            }, _mult: function(R) {
+              return this.x *= R, this.y *= R, this;
+            }, _div: function(R) {
+              return this.x /= R, this.y /= R, this;
+            }, _multByPoint: function(R) {
+              return this.x *= R.x, this.y *= R.y, this;
+            }, _divByPoint: function(R) {
+              return this.x /= R.x, this.y /= R.y, this;
+            }, _unit: function() {
+              return this._div(this.mag()), this;
+            }, _perp: function() {
+              var R = this.y;
+              return this.y = this.x, this.x = -R, this;
+            }, _rotate: function(R) {
+              var S = Math.cos(R), F = Math.sin(R), W = F * this.x + S * this.y;
+              return this.x = S * this.x - F * this.y, this.y = W, this;
+            }, _rotateAround: function(R, S) {
+              var F = Math.cos(R), W = Math.sin(R), te = S.y + W * (this.x - S.x) + F * (this.y - S.y);
+              return this.x = S.x + F * (this.x - S.x) - W * (this.y - S.y), this.y = te, this;
+            }, _round: function() {
+              return this.x = Math.round(this.x), this.y = Math.round(this.y), this;
+            } }, l.convert = function(R) {
+              return R instanceof l ? R : Array.isArray(R) ? new l(R[0], R[1]) : R;
+            };
+            var u = o(s), c = f;
+            function f(R, S, F, W) {
+              this.cx = 3 * R, this.bx = 3 * (F - R) - this.cx, this.ax = 1 - this.cx - this.bx, this.cy = 3 * S, this.by = 3 * (W - S) - this.cy, this.ay = 1 - this.cy - this.by, this.p1x = R, this.p1y = S, this.p2x = F, this.p2y = W;
+            }
+            f.prototype = { sampleCurveX: function(R) {
+              return ((this.ax * R + this.bx) * R + this.cx) * R;
+            }, sampleCurveY: function(R) {
+              return ((this.ay * R + this.by) * R + this.cy) * R;
+            }, sampleCurveDerivativeX: function(R) {
+              return (3 * this.ax * R + 2 * this.bx) * R + this.cx;
+            }, solveCurveX: function(R, S) {
+              if (S === void 0 && (S = 1e-6), R < 0) return 0;
+              if (R > 1) return 1;
+              for (var F = R, W = 0; W < 8; W++) {
+                var te = this.sampleCurveX(F) - R;
+                if (Math.abs(te) < S) return F;
+                var fe = this.sampleCurveDerivativeX(F);
+                if (Math.abs(fe) < 1e-6) break;
+                F -= te / fe;
+              }
+              var pe = 0, Fe = 1;
+              for (F = R, W = 0; W < 20 && (te = this.sampleCurveX(F), !(Math.abs(te - R) < S)); W++) R > te ? pe = F : Fe = F, F = 0.5 * (Fe - pe) + pe;
+              return F;
+            }, solve: function(R, S) {
+              return this.sampleCurveY(this.solveCurveX(R, S));
+            } };
+            var h = o(c);
+            let d, v;
+            function _() {
+              return d == null && (d = typeof OffscreenCanvas != "undefined" && new OffscreenCanvas(1, 1).getContext("2d") && typeof createImageBitmap == "function"), d;
+            }
+            function b() {
+              if (v == null && (v = false, _())) {
+                let S = new OffscreenCanvas(5, 5).getContext("2d", { willReadFrequently: true });
+                if (S) {
+                  for (let W = 0; W < 5 * 5; W++) {
+                    let te = 4 * W;
+                    S.fillStyle = `rgb(${te},${te + 1},${te + 2})`, S.fillRect(W % 5, Math.floor(W / 5), 1, 1);
+                  }
+                  let F = S.getImageData(0, 0, 5, 5).data;
+                  for (let W = 0; W < 5 * 5 * 4; W++) if (W % 4 != 3 && F[W] !== W) {
+                    v = true;
+                    break;
+                  }
+                }
+              }
+              return v || false;
+            }
+            function p(R, S, F, W) {
+              let te = new h(R, S, F, W);
+              return (fe) => te.solve(fe);
+            }
+            let k = p(0.25, 0.1, 0.25, 1);
+            function E(R, S, F) {
+              return Math.min(F, Math.max(S, R));
+            }
+            function T(R, S, F) {
+              let W = F - S, te = ((R - S) % W + W) % W + S;
+              return te === S ? F : te;
+            }
+            function L(R, ...S) {
+              for (let F of S) for (let W in F) R[W] = F[W];
+              return R;
+            }
+            let x = 1;
+            function C(R, S, F) {
+              let W = {};
+              for (let te in R) W[te] = S.call(this, R[te], te, R);
+              return W;
+            }
+            function M(R, S, F) {
+              let W = {};
+              for (let te in R) S.call(this, R[te], te, R) && (W[te] = R[te]);
+              return W;
+            }
+            function g(R) {
+              return Array.isArray(R) ? R.map(g) : typeof R == "object" && R ? C(R, g) : R;
+            }
+            let P = {};
+            function A(R) {
+              P[R] || (typeof console != "undefined" && console.warn(R), P[R] = true);
+            }
+            function z(R, S, F) {
+              return (F.y - R.y) * (S.x - R.x) > (S.y - R.y) * (F.x - R.x);
+            }
+            function O(R) {
+              return typeof WorkerGlobalScope != "undefined" && R !== void 0 && R instanceof WorkerGlobalScope;
+            }
+            let U = null;
+            function G(R) {
+              return typeof ImageBitmap != "undefined" && R instanceof ImageBitmap;
+            }
+            let Z = "data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAYAAAAfFcSJAAAAC0lEQVQYV2NgAAIAAAUAAarVyFEAAAAASUVORK5CYII=";
+            function j(R, S, F, W, te) {
+              return a(this, void 0, void 0, function* () {
+                if (typeof VideoFrame == "undefined") throw new Error("VideoFrame not supported");
+                let fe = new VideoFrame(R, { timestamp: 0 });
+                try {
+                  let pe = fe == null ? void 0 : fe.format;
+                  if (!pe || !pe.startsWith("BGR") && !pe.startsWith("RGB")) throw new Error(`Unrecognized format ${pe}`);
+                  let Fe = pe.startsWith("BGR"), Ke = new Uint8ClampedArray(W * te * 4);
+                  if (yield fe.copyTo(Ke, function(ct, Lt, Jt, cr, mr) {
+                    let Pr = 4 * Math.max(-Lt, 0), zr = (Math.max(0, Jt) - Jt) * cr * 4 + Pr, ui = 4 * cr, yi = Math.max(0, Lt), vn = Math.max(0, Jt);
+                    return { rect: { x: yi, y: vn, width: Math.min(ct.width, Lt + cr) - yi, height: Math.min(ct.height, Jt + mr) - vn }, layout: [{ offset: zr, stride: ui }] };
+                  }(R, S, F, W, te)), Fe) for (let ct = 0; ct < Ke.length; ct += 4) {
+                    let Lt = Ke[ct];
+                    Ke[ct] = Ke[ct + 2], Ke[ct + 2] = Lt;
+                  }
+                  return Ke;
+                } finally {
+                  fe.close();
+                }
+              });
+            }
+            let N, H, re = "AbortError";
+            function oe() {
+              return new Error(re);
+            }
+            let _e = { MAX_PARALLEL_IMAGE_REQUESTS: 16, MAX_PARALLEL_IMAGE_REQUESTS_PER_FRAME: 8, MAX_TILE_CACHE_ZOOM_LEVELS: 5, REGISTERED_PROTOCOLS: {}, WORKER_URL: "" };
+            function Ce(R) {
+              return _e.REGISTERED_PROTOCOLS[R.substring(0, R.indexOf("://"))];
+            }
+            let Le = "global-dispatcher";
+            class ge extends Error {
+              constructor(S, F, W, te) {
+                super(`AJAXError: ${F} (${S}): ${W}`), this.status = S, this.statusText = F, this.url = W, this.body = te;
+              }
+            }
+            let ie = () => O(self) ? self.worker && self.worker.referrer : (window.location.protocol === "blob:" ? window.parent : window).location.href, Se = function(R, S) {
+              if (/:\/\//.test(R.url) && !/^https?:|^file:/.test(R.url)) {
+                let W = Ce(R.url);
+                if (W) return W(R, S);
+                if (O(self) && self.worker && self.worker.actor) return self.worker.actor.sendAsync({ type: "GR", data: R, targetMapId: Le }, S);
+              }
+              if (!(/^file:/.test(F = R.url) || /^file:/.test(ie()) && !/^\w+:/.test(F))) {
+                if (fetch && Request && AbortController && Object.prototype.hasOwnProperty.call(Request.prototype, "signal")) return function(W, te) {
+                  return a(this, void 0, void 0, function* () {
+                    let fe = new Request(W.url, { method: W.method || "GET", body: W.body, credentials: W.credentials, headers: W.headers, cache: W.cache, referrer: ie(), signal: te.signal });
+                    W.type !== "json" || fe.headers.has("Accept") || fe.headers.set("Accept", "application/json");
+                    let pe = yield fetch(fe);
+                    if (!pe.ok) {
+                      let ct = yield pe.blob();
+                      throw new ge(pe.status, pe.statusText, W.url, ct);
+                    }
+                    let Fe;
+                    Fe = W.type === "arrayBuffer" || W.type === "image" ? pe.arrayBuffer() : W.type === "json" ? pe.json() : pe.text();
+                    let Ke = yield Fe;
+                    if (te.signal.aborted) throw oe();
+                    return { data: Ke, cacheControl: pe.headers.get("Cache-Control"), expires: pe.headers.get("Expires") };
+                  });
+                }(R, S);
+                if (O(self) && self.worker && self.worker.actor) return self.worker.actor.sendAsync({ type: "GR", data: R, mustQueue: true, targetMapId: Le }, S);
+              }
+              var F;
+              return function(W, te) {
+                return new Promise((fe, pe) => {
+                  var Fe;
+                  let Ke = new XMLHttpRequest();
+                  Ke.open(W.method || "GET", W.url, true), W.type !== "arrayBuffer" && W.type !== "image" || (Ke.responseType = "arraybuffer");
+                  for (let ct in W.headers) Ke.setRequestHeader(ct, W.headers[ct]);
+                  W.type === "json" && (Ke.responseType = "text", !((Fe = W.headers) === null || Fe === void 0) && Fe.Accept || Ke.setRequestHeader("Accept", "application/json")), Ke.withCredentials = W.credentials === "include", Ke.onerror = () => {
+                    pe(new Error(Ke.statusText));
+                  }, Ke.onload = () => {
+                    if (!te.signal.aborted) if ((Ke.status >= 200 && Ke.status < 300 || Ke.status === 0) && Ke.response !== null) {
+                      let ct = Ke.response;
+                      if (W.type === "json") try {
+                        ct = JSON.parse(Ke.response);
+                      } catch (Lt) {
+                        return void pe(Lt);
+                      }
+                      fe({ data: ct, cacheControl: Ke.getResponseHeader("Cache-Control"), expires: Ke.getResponseHeader("Expires") });
+                    } else {
+                      let ct = new Blob([Ke.response], { type: Ke.getResponseHeader("Content-Type") });
+                      pe(new ge(Ke.status, Ke.statusText, W.url, ct));
+                    }
+                  }, te.signal.addEventListener("abort", () => {
+                    Ke.abort(), pe(oe());
+                  }), Ke.send(W.body);
+                });
+              }(R, S);
+            };
+            function Ee(R) {
+              if (!R || R.indexOf("://") <= 0 || R.indexOf("data:image/") === 0 || R.indexOf("blob:") === 0) return true;
+              let S = new URL(R), F = window.location;
+              return S.protocol === F.protocol && S.host === F.host;
+            }
+            function Ae(R, S, F) {
+              F[R] && F[R].indexOf(S) !== -1 || (F[R] = F[R] || [], F[R].push(S));
+            }
+            function Be(R, S, F) {
+              if (F && F[R]) {
+                let W = F[R].indexOf(S);
+                W !== -1 && F[R].splice(W, 1);
+              }
+            }
+            class Pe {
+              constructor(S, F = {}) {
+                L(this, F), this.type = S;
+              }
+            }
+            class me extends Pe {
+              constructor(S, F = {}) {
+                super("error", L({ error: S }, F));
+              }
+            }
+            class De {
+              on(S, F) {
+                return this._listeners = this._listeners || {}, Ae(S, F, this._listeners), this;
+              }
+              off(S, F) {
+                return Be(S, F, this._listeners), Be(S, F, this._oneTimeListeners), this;
+              }
+              once(S, F) {
+                return F ? (this._oneTimeListeners = this._oneTimeListeners || {}, Ae(S, F, this._oneTimeListeners), this) : new Promise((W) => this.once(S, W));
+              }
+              fire(S, F) {
+                typeof S == "string" && (S = new Pe(S, F || {}));
+                let W = S.type;
+                if (this.listens(W)) {
+                  S.target = this;
+                  let te = this._listeners && this._listeners[W] ? this._listeners[W].slice() : [];
+                  for (let Fe of te) Fe.call(this, S);
+                  let fe = this._oneTimeListeners && this._oneTimeListeners[W] ? this._oneTimeListeners[W].slice() : [];
+                  for (let Fe of fe) Be(W, Fe, this._oneTimeListeners), Fe.call(this, S);
+                  let pe = this._eventedParent;
+                  pe && (L(S, typeof this._eventedParentData == "function" ? this._eventedParentData() : this._eventedParentData), pe.fire(S));
+                } else S instanceof me && console.error(S.error);
+                return this;
+              }
+              listens(S) {
+                return this._listeners && this._listeners[S] && this._listeners[S].length > 0 || this._oneTimeListeners && this._oneTimeListeners[S] && this._oneTimeListeners[S].length > 0 || this._eventedParent && this._eventedParent.listens(S);
+              }
+              setEventedParent(S, F) {
+                return this._eventedParent = S, this._eventedParentData = F, this;
+              }
+            }
+            var ce = { $version: 8, $root: { version: { required: true, type: "enum", values: [8] }, name: { type: "string" }, metadata: { type: "*" }, center: { type: "array", value: "number" }, zoom: { type: "number" }, bearing: { type: "number", default: 0, period: 360, units: "degrees" }, pitch: { type: "number", default: 0, units: "degrees" }, light: { type: "light" }, sky: { type: "sky" }, projection: { type: "projection" }, terrain: { type: "terrain" }, sources: { required: true, type: "sources" }, sprite: { type: "sprite" }, glyphs: { type: "string" }, transition: { type: "transition" }, layers: { required: true, type: "array", value: "layer" } }, sources: { "*": { type: "source" } }, source: ["source_vector", "source_raster", "source_raster_dem", "source_geojson", "source_video", "source_image"], source_vector: { type: { required: true, type: "enum", values: { vector: {} } }, url: { type: "string" }, tiles: { type: "array", value: "string" }, bounds: { type: "array", value: "number", length: 4, default: [-180, -85.051129, 180, 85.051129] }, scheme: { type: "enum", values: { xyz: {}, tms: {} }, default: "xyz" }, minzoom: { type: "number", default: 0 }, maxzoom: { type: "number", default: 22 }, attribution: { type: "string" }, promoteId: { type: "promoteId" }, volatile: { type: "boolean", default: false }, "*": { type: "*" } }, source_raster: { type: { required: true, type: "enum", values: { raster: {} } }, url: { type: "string" }, tiles: { type: "array", value: "string" }, bounds: { type: "array", value: "number", length: 4, default: [-180, -85.051129, 180, 85.051129] }, minzoom: { type: "number", default: 0 }, maxzoom: { type: "number", default: 22 }, tileSize: { type: "number", default: 512, units: "pixels" }, scheme: { type: "enum", values: { xyz: {}, tms: {} }, default: "xyz" }, attribution: { type: "string" }, volatile: { type: "boolean", default: false }, "*": { type: "*" } }, source_raster_dem: { type: { required: true, type: "enum", values: { "raster-dem": {} } }, url: { type: "string" }, tiles: { type: "array", value: "string" }, bounds: { type: "array", value: "number", length: 4, default: [-180, -85.051129, 180, 85.051129] }, minzoom: { type: "number", default: 0 }, maxzoom: { type: "number", default: 22 }, tileSize: { type: "number", default: 512, units: "pixels" }, attribution: { type: "string" }, encoding: { type: "enum", values: { terrarium: {}, mapbox: {}, custom: {} }, default: "mapbox" }, redFactor: { type: "number", default: 1 }, blueFactor: { type: "number", default: 1 }, greenFactor: { type: "number", default: 1 }, baseShift: { type: "number", default: 0 }, volatile: { type: "boolean", default: false }, "*": { type: "*" } }, source_geojson: { type: { required: true, type: "enum", values: { geojson: {} } }, data: { required: true, type: "*" }, maxzoom: { type: "number", default: 18 }, attribution: { type: "string" }, buffer: { type: "number", default: 128, maximum: 512, minimum: 0 }, filter: { type: "*" }, tolerance: { type: "number", default: 0.375 }, cluster: { type: "boolean", default: false }, clusterRadius: { type: "number", default: 50, minimum: 0 }, clusterMaxZoom: { type: "number" }, clusterMinPoints: { type: "number" }, clusterProperties: { type: "*" }, lineMetrics: { type: "boolean", default: false }, generateId: { type: "boolean", default: false }, promoteId: { type: "promoteId" } }, source_video: { type: { required: true, type: "enum", values: { video: {} } }, urls: { required: true, type: "array", value: "string" }, coordinates: { required: true, type: "array", length: 4, value: { type: "array", length: 2, value: "number" } } }, source_image: { type: { required: true, type: "enum", values: { image: {} } }, url: { required: true, type: "string" }, coordinates: { required: true, type: "array", length: 4, value: { type: "array", length: 2, value: "number" } } }, layer: { id: { type: "string", required: true }, type: { type: "enum", values: { fill: {}, line: {}, symbol: {}, circle: {}, heatmap: {}, "fill-extrusion": {}, raster: {}, hillshade: {}, background: {} }, required: true }, metadata: { type: "*" }, source: { type: "string" }, "source-layer": { type: "string" }, minzoom: { type: "number", minimum: 0, maximum: 24 }, maxzoom: { type: "number", minimum: 0, maximum: 24 }, filter: { type: "filter" }, layout: { type: "layout" }, paint: { type: "paint" } }, layout: ["layout_fill", "layout_line", "layout_circle", "layout_heatmap", "layout_fill-extrusion", "layout_symbol", "layout_raster", "layout_hillshade", "layout_background"], layout_background: { visibility: { type: "enum", values: { visible: {}, none: {} }, default: "visible", "property-type": "constant" } }, layout_fill: { "fill-sort-key": { type: "number", expression: { interpolated: false, parameters: ["zoom", "feature"] }, "property-type": "data-driven" }, visibility: { type: "enum", values: { visible: {}, none: {} }, default: "visible", "property-type": "constant" } }, layout_circle: { "circle-sort-key": { type: "number", expression: { interpolated: false, parameters: ["zoom", "feature"] }, "property-type": "data-driven" }, visibility: { type: "enum", values: { visible: {}, none: {} }, default: "visible", "property-type": "constant" } }, layout_heatmap: { visibility: { type: "enum", values: { visible: {}, none: {} }, default: "visible", "property-type": "constant" } }, "layout_fill-extrusion": { visibility: { type: "enum", values: { visible: {}, none: {} }, default: "visible", "property-type": "constant" } }, layout_line: { "line-cap": { type: "enum", values: { butt: {}, round: {}, square: {} }, default: "butt", expression: { interpolated: false, parameters: ["zoom"] }, "property-type": "data-constant" }, "line-join": { type: "enum", values: { bevel: {}, round: {}, miter: {} }, default: "miter", expression: { interpolated: false, parameters: ["zoom", "feature"] }, "property-type": "data-driven" }, "line-miter-limit": { type: "number", default: 2, requires: [{ "line-join": "miter" }], expression: { interpolated: true, parameters: ["zoom"] }, "property-type": "data-constant" }, "line-round-limit": { type: "number", default: 1.05, requires: [{ "line-join": "round" }], expression: { interpolated: true, parameters: ["zoom"] }, "property-type": "data-constant" }, "line-sort-key": { type: "number", expression: { interpolated: false, parameters: ["zoom", "feature"] }, "property-type": "data-driven" }, visibility: { type: "enum", values: { visible: {}, none: {} }, default: "visible", "property-type": "constant" } }, layout_symbol: { "symbol-placement": { type: "enum", values: { point: {}, line: {}, "line-center": {} }, default: "point", expression: { interpolated: false, parameters: ["zoom"] }, "property-type": "data-constant" }, "symbol-spacing": { type: "number", default: 250, minimum: 1, units: "pixels", requires: [{ "symbol-placement": "line" }], expression: { interpolated: true, parameters: ["zoom"] }, "property-type": "data-constant" }, "symbol-avoid-edges": { type: "boolean", default: false, expression: { interpolated: false, parameters: ["zoom"] }, "property-type": "data-constant" }, "symbol-sort-key": { type: "number", expression: { interpolated: false, parameters: ["zoom", "feature"] }, "property-type": "data-driven" }, "symbol-z-order": { type: "enum", values: { auto: {}, "viewport-y": {}, source: {} }, default: "auto", expression: { interpolated: false, parameters: ["zoom"] }, "property-type": "data-constant" }, "icon-allow-overlap": { type: "boolean", default: false, requires: ["icon-image", { "!": "icon-overlap" }], expression: { interpolated: false, parameters: ["zoom"] }, "property-type": "data-constant" }, "icon-overlap": { type: "enum", values: { never: {}, always: {}, cooperative: {} }, requires: ["icon-image"], expression: { interpolated: false, parameters: ["zoom"] }, "property-type": "data-constant" }, "icon-ignore-placement": { type: "boolean", default: false, requires: ["icon-image"], expression: { interpolated: false, parameters: ["zoom"] }, "property-type": "data-constant" }, "icon-optional": { type: "boolean", default: false, requires: ["icon-image", "text-field"], expression: { interpolated: false, parameters: ["zoom"] }, "property-type": "data-constant" }, "icon-rotation-alignment": { type: "enum", values: { map: {}, viewport: {}, auto: {} }, default: "auto", requires: ["icon-image"], expression: { interpolated: false, parameters: ["zoom"] }, "property-type": "data-constant" }, "icon-size": { type: "number", default: 1, minimum: 0, units: "factor of the original icon size", requires: ["icon-image"], expression: { interpolated: true, parameters: ["zoom", "feature"] }, "property-type": "data-driven" }, "icon-text-fit": { type: "enum", values: { none: {}, width: {}, height: {}, both: {} }, default: "none", requires: ["icon-image", "text-field"], expression: { interpolated: false, parameters: ["zoom"] }, "property-type": "data-constant" }, "icon-text-fit-padding": { type: "array", value: "number", length: 4, default: [0, 0, 0, 0], units: "pixels", requires: ["icon-image", "text-field", { "icon-text-fit": ["both", "width", "height"] }], expression: { interpolated: true, parameters: ["zoom"] }, "property-type": "data-constant" }, "icon-image": { type: "resolvedImage", tokens: true, expression: { interpolated: false, parameters: ["zoom", "feature"] }, "property-type": "data-driven" }, "icon-rotate": { type: "number", default: 0, period: 360, units: "degrees", requires: ["icon-image"], expression: { interpolated: true, parameters: ["zoom", "feature"] }, "property-type": "data-driven" }, "icon-padding": { type: "padding", default: [2], units: "pixels", requires: ["icon-image"], expression: { interpolated: true, parameters: ["zoom", "feature"] }, "property-type": "data-driven" }, "icon-keep-upright": { type: "boolean", default: false, requires: ["icon-image", { "icon-rotation-alignment": "map" }, { "symbol-placement": ["line", "line-center"] }], expression: { interpolated: false, parameters: ["zoom"] }, "property-type": "data-constant" }, "icon-offset": { type: "array", value: "number", length: 2, default: [0, 0], requires: ["icon-image"], expression: { interpolated: true, parameters: ["zoom", "feature"] }, "property-type": "data-driven" }, "icon-anchor": { type: "enum", values: { center: {}, left: {}, right: {}, top: {}, bottom: {}, "top-left": {}, "top-right": {}, "bottom-left": {}, "bottom-right": {} }, default: "center", requires: ["icon-image"], expression: { interpolated: false, parameters: ["zoom", "feature"] }, "property-type": "data-driven" }, "icon-pitch-alignment": { type: "enum", values: { map: {}, viewport: {}, auto: {} }, default: "auto", requires: ["icon-image"], expression: { interpolated: false, parameters: ["zoom"] }, "property-type": "data-constant" }, "text-pitch-alignment": { type: "enum", values: { map: {}, viewport: {}, auto: {} }, default: "auto", requires: ["text-field"], expression: { interpolated: false, parameters: ["zoom"] }, "property-type": "data-constant" }, "text-rotation-alignment": { type: "enum", values: { map: {}, viewport: {}, "viewport-glyph": {}, auto: {} }, default: "auto", requires: ["text-field"], expression: { interpolated: false, parameters: ["zoom"] }, "property-type": "data-constant" }, "text-field": { type: "formatted", default: "", tokens: true, expression: { interpolated: false, parameters: ["zoom", "feature"] }, "property-type": "data-driven" }, "text-font": { type: "array", value: "string", default: ["Open Sans Regular", "Arial Unicode MS Regular"], requires: ["text-field"], expression: { interpolated: false, parameters: ["zoom", "feature"] }, "property-type": "data-driven" }, "text-size": { type: "number", default: 16, minimum: 0, units: "pixels", requires: ["text-field"], expression: { interpolated: true, parameters: ["zoom", "feature"] }, "property-type": "data-driven" }, "text-max-width": { type: "number", default: 10, minimum: 0, units: "ems", requires: ["text-field"], expression: { interpolated: true, parameters: ["zoom", "feature"] }, "property-type": "data-driven" }, "text-line-height": { type: "number", default: 1.2, units: "ems", requires: ["text-field"], expression: { interpolated: true, parameters: ["zoom"] }, "property-type": "data-constant" }, "text-letter-spacing": { type: "number", default: 0, units: "ems", requires: ["text-field"], expression: { interpolated: true, parameters: ["zoom", "feature"] }, "property-type": "data-driven" }, "text-justify": { type: "enum", values: { auto: {}, left: {}, center: {}, right: {} }, default: "center", requires: ["text-field"], expression: { interpolated: false, parameters: ["zoom", "feature"] }, "property-type": "data-driven" }, "text-radial-offset": { type: "number", units: "ems", default: 0, requires: ["text-field"], "property-type": "data-driven", expression: { interpolated: true, parameters: ["zoom", "feature"] } }, "text-variable-anchor": { type: "array", value: "enum", values: { center: {}, left: {}, right: {}, top: {}, bottom: {}, "top-left": {}, "top-right": {}, "bottom-left": {}, "bottom-right": {} }, requires: ["text-field", { "symbol-placement": ["point"] }], expression: { interpolated: false, parameters: ["zoom"] }, "property-type": "data-constant" }, "text-variable-anchor-offset": { type: "variableAnchorOffsetCollection", requires: ["text-field", { "symbol-placement": ["point"] }], expression: { interpolated: true, parameters: ["zoom", "feature"] }, "property-type": "data-driven" }, "text-anchor": { type: "enum", values: { center: {}, left: {}, right: {}, top: {}, bottom: {}, "top-left": {}, "top-right": {}, "bottom-left": {}, "bottom-right": {} }, default: "center", requires: ["text-field", { "!": "text-variable-anchor" }], expression: { interpolated: false, parameters: ["zoom", "feature"] }, "property-type": "data-driven" }, "text-max-angle": { type: "number", default: 45, units: "degrees", requires: ["text-field", { "symbol-placement": ["line", "line-center"] }], expression: { interpolated: true, parameters: ["zoom"] }, "property-type": "data-constant" }, "text-writing-mode": { type: "array", value: "enum", values: { horizontal: {}, vertical: {} }, requires: ["text-field", { "symbol-placement": ["point"] }], expression: { interpolated: false, parameters: ["zoom"] }, "property-type": "data-constant" }, "text-rotate": { type: "number", default: 0, period: 360, units: "degrees", requires: ["text-field"], expression: { interpolated: true, parameters: ["zoom", "feature"] }, "property-type": "data-driven" }, "text-padding": { type: "number", default: 2, minimum: 0, units: "pixels", requires: ["text-field"], expression: { interpolated: true, parameters: ["zoom"] }, "property-type": "data-constant" }, "text-keep-upright": { type: "boolean", default: true, requires: ["text-field", { "text-rotation-alignment": "map" }, { "symbol-placement": ["line", "line-center"] }], expression: { interpolated: false, parameters: ["zoom"] }, "property-type": "data-constant" }, "text-transform": { type: "enum", values: { none: {}, uppercase: {}, lowercase: {} }, default: "none", requires: ["text-field"], expression: { interpolated: false, parameters: ["zoom", "feature"] }, "property-type": "data-driven" }, "text-offset": { type: "array", value: "number", units: "ems", length: 2, default: [0, 0], requires: ["text-field", { "!": "text-radial-offset" }], expression: { interpolated: true, parameters: ["zoom", "feature"] }, "property-type": "data-driven" }, "text-allow-overlap": { type: "boolean", default: false, requires: ["text-field", { "!": "text-overlap" }], expression: { interpolated: false, parameters: ["zoom"] }, "property-type": "data-constant" }, "text-overlap": { type: "enum", values: { never: {}, always: {}, cooperative: {} }, requires: ["text-field"], expression: { interpolated: false, parameters: ["zoom"] }, "property-type": "data-constant" }, "text-ignore-placement": { type: "boolean", default: false, requires: ["text-field"], expression: { interpolated: false, parameters: ["zoom"] }, "property-type": "data-constant" }, "text-optional": { type: "boolean", default: false, requires: ["text-field", "icon-image"], expression: { interpolated: false, parameters: ["zoom"] }, "property-type": "data-constant" }, visibility: { type: "enum", values: { visible: {}, none: {} }, default: "visible", "property-type": "constant" } }, layout_raster: { visibility: { type: "enum", values: { visible: {}, none: {} }, default: "visible", "property-type": "constant" } }, layout_hillshade: { visibility: { type: "enum", values: { visible: {}, none: {} }, default: "visible", "property-type": "constant" } }, filter: { type: "array", value: "*" }, filter_operator: { type: "enum", values: { "==": {}, "!=": {}, ">": {}, ">=": {}, "<": {}, "<=": {}, in: {}, "!in": {}, all: {}, any: {}, none: {}, has: {}, "!has": {} } }, geometry_type: { type: "enum", values: { Point: {}, LineString: {}, Polygon: {} } }, function: { expression: { type: "expression" }, stops: { type: "array", value: "function_stop" }, base: { type: "number", default: 1, minimum: 0 }, property: { type: "string", default: "$zoom" }, type: { type: "enum", values: { identity: {}, exponential: {}, interval: {}, categorical: {} }, default: "exponential" }, colorSpace: { type: "enum", values: { rgb: {}, lab: {}, hcl: {} }, default: "rgb" }, default: { type: "*", required: false } }, function_stop: { type: "array", minimum: 0, maximum: 24, value: ["number", "color"], length: 2 }, expression: { type: "array", value: "*", minimum: 1 }, light: { anchor: { type: "enum", default: "viewport", values: { map: {}, viewport: {} }, "property-type": "data-constant", transition: false, expression: { interpolated: false, parameters: ["zoom"] } }, position: { type: "array", default: [1.15, 210, 30], length: 3, value: "number", "property-type": "data-constant", transition: true, expression: { interpolated: true, parameters: ["zoom"] } }, color: { type: "color", "property-type": "data-constant", default: "#ffffff", expression: { interpolated: true, parameters: ["zoom"] }, transition: true }, intensity: { type: "number", "property-type": "data-constant", default: 0.5, minimum: 0, maximum: 1, expression: { interpolated: true, parameters: ["zoom"] }, transition: true } }, sky: { "sky-color": { type: "color", "property-type": "data-constant", default: "#88C6FC", expression: { interpolated: true, parameters: ["zoom"] }, transition: true }, "horizon-color": { type: "color", "property-type": "data-constant", default: "#ffffff", expression: { interpolated: true, parameters: ["zoom"] }, transition: true }, "fog-color": { type: "color", "property-type": "data-constant", default: "#ffffff", expression: { interpolated: true, parameters: ["zoom"] }, transition: true }, "fog-ground-blend": { type: "number", "property-type": "data-constant", default: 0.5, minimum: 0, maximum: 1, expression: { interpolated: true, parameters: ["zoom"] }, transition: true }, "horizon-fog-blend": { type: "number", "property-type": "data-constant", default: 0.8, minimum: 0, maximum: 1, expression: { interpolated: true, parameters: ["zoom"] }, transition: true }, "sky-horizon-blend": { type: "number", "property-type": "data-constant", default: 0.8, minimum: 0, maximum: 1, expression: { interpolated: true, parameters: ["zoom"] }, transition: true }, "atmosphere-blend": { type: "number", "property-type": "data-constant", default: 0.8, minimum: 0, maximum: 1, expression: { interpolated: true, parameters: ["zoom"] }, transition: true } }, terrain: { source: { type: "string", required: true }, exaggeration: { type: "number", minimum: 0, default: 1 } }, projection: { type: { type: "enum", default: "mercator", values: { mercator: {}, globe: {} } } }, paint: ["paint_fill", "paint_line", "paint_circle", "paint_heatmap", "paint_fill-extrusion", "paint_symbol", "paint_raster", "paint_hillshade", "paint_background"], paint_fill: { "fill-antialias": { type: "boolean", default: true, expression: { interpolated: false, parameters: ["zoom"] }, "property-type": "data-constant" }, "fill-opacity": { type: "number", default: 1, minimum: 0, maximum: 1, transition: true, expression: { interpolated: true, parameters: ["zoom", "feature", "feature-state"] }, "property-type": "data-driven" }, "fill-color": { type: "color", default: "#000000", transition: true, requires: [{ "!": "fill-pattern" }], expression: { interpolated: true, parameters: ["zoom", "feature", "feature-state"] }, "property-type": "data-driven" }, "fill-outline-color": { type: "color", transition: true, requires: [{ "!": "fill-pattern" }, { "fill-antialias": true }], expression: { interpolated: true, parameters: ["zoom", "feature", "feature-state"] }, "property-type": "data-driven" }, "fill-translate": { type: "array", value: "number", length: 2, default: [0, 0], transition: true, units: "pixels", expression: { interpolated: true, parameters: ["zoom"] }, "property-type": "data-constant" }, "fill-translate-anchor": { type: "enum", values: { map: {}, viewport: {} }, default: "map", requires: ["fill-translate"], expression: { interpolated: false, parameters: ["zoom"] }, "property-type": "data-constant" }, "fill-pattern": { type: "resolvedImage", transition: true, expression: { interpolated: false, parameters: ["zoom", "feature"] }, "property-type": "cross-faded-data-driven" } }, "paint_fill-extrusion": { "fill-extrusion-opacity": { type: "number", default: 1, minimum: 0, maximum: 1, transition: true, expression: { interpolated: true, parameters: ["zoom"] }, "property-type": "data-constant" }, "fill-extrusion-color": { type: "color", default: "#000000", transition: true, requires: [{ "!": "fill-extrusion-pattern" }], expression: { interpolated: true, parameters: ["zoom", "feature", "feature-state"] }, "property-type": "data-driven" }, "fill-extrusion-translate": { type: "array", value: "number", length: 2, default: [0, 0], transition: true, units: "pixels", expression: { interpolated: true, parameters: ["zoom"] }, "property-type": "data-constant" }, "fill-extrusion-translate-anchor": { type: "enum", values: { map: {}, viewport: {} }, default: "map", requires: ["fill-extrusion-translate"], expression: { interpolated: false, parameters: ["zoom"] }, "property-type": "data-constant" }, "fill-extrusion-pattern": { type: "resolvedImage", transition: true, expression: { interpolated: false, parameters: ["zoom", "feature"] }, "property-type": "cross-faded-data-driven" }, "fill-extrusion-height": { type: "number", default: 0, minimum: 0, units: "meters", transition: true, expression: { interpolated: true, parameters: ["zoom", "feature", "feature-state"] }, "property-type": "data-driven" }, "fill-extrusion-base": { type: "number", default: 0, minimum: 0, units: "meters", transition: true, requires: ["fill-extrusion-height"], expression: { interpolated: true, parameters: ["zoom", "feature", "feature-state"] }, "property-type": "data-driven" }, "fill-extrusion-vertical-gradient": { type: "boolean", default: true, transition: false, expression: { interpolated: false, parameters: ["zoom"] }, "property-type": "data-constant" } }, paint_line: { "line-opacity": { type: "number", default: 1, minimum: 0, maximum: 1, transition: true, expression: { interpolated: true, parameters: ["zoom", "feature", "feature-state"] }, "property-type": "data-driven" }, "line-color": { type: "color", default: "#000000", transition: true, requires: [{ "!": "line-pattern" }], expression: { interpolated: true, parameters: ["zoom", "feature", "feature-state"] }, "property-type": "data-driven" }, "line-translate": { type: "array", value: "number", length: 2, default: [0, 0], transition: true, units: "pixels", expression: { interpolated: true, parameters: ["zoom"] }, "property-type": "data-constant" }, "line-translate-anchor": { type: "enum", values: { map: {}, viewport: {} }, default: "map", requires: ["line-translate"], expression: { interpolated: false, parameters: ["zoom"] }, "property-type": "data-constant" }, "line-width": { type: "number", default: 1, minimum: 0, transition: true, units: "pixels", expression: { interpolated: true, parameters: ["zoom", "feature", "feature-state"] }, "property-type": "data-driven" }, "line-gap-width": { type: "number", default: 0, minimum: 0, transition: true, units: "pixels", expression: { interpolated: true, parameters: ["zoom", "feature", "feature-state"] }, "property-type": "data-driven" }, "line-offset": { type: "number", default: 0, transition: true, units: "pixels", expression: { interpolated: true, parameters: ["zoom", "feature", "feature-state"] }, "property-type": "data-driven" }, "line-blur": { type: "number", default: 0, minimum: 0, transition: true, units: "pixels", expression: { interpolated: true, parameters: ["zoom", "feature", "feature-state"] }, "property-type": "data-driven" }, "line-dasharray": { type: "array", value: "number", minimum: 0, transition: true, units: "line widths", requires: [{ "!": "line-pattern" }], expression: { interpolated: false, parameters: ["zoom"] }, "property-type": "cross-faded" }, "line-pattern": { type: "resolvedImage", transition: true, expression: { interpolated: false, parameters: ["zoom", "feature"] }, "property-type": "cross-faded-data-driven" }, "line-gradient": { type: "color", transition: false, requires: [{ "!": "line-dasharray" }, { "!": "line-pattern" }, { source: "geojson", has: { lineMetrics: true } }], expression: { interpolated: true, parameters: ["line-progress"] }, "property-type": "color-ramp" } }, paint_circle: { "circle-radius": { type: "number", default: 5, minimum: 0, transition: true, units: "pixels", expression: { interpolated: true, parameters: ["zoom", "feature", "feature-state"] }, "property-type": "data-driven" }, "circle-color": { type: "color", default: "#000000", transition: true, expression: { interpolated: true, parameters: ["zoom", "feature", "feature-state"] }, "property-type": "data-driven" }, "circle-blur": { type: "number", default: 0, transition: true, expression: { interpolated: true, parameters: ["zoom", "feature", "feature-state"] }, "property-type": "data-driven" }, "circle-opacity": { type: "number", default: 1, minimum: 0, maximum: 1, transition: true, expression: { interpolated: true, parameters: ["zoom", "feature", "feature-state"] }, "property-type": "data-driven" }, "circle-translate": { type: "array", value: "number", length: 2, default: [0, 0], transition: true, units: "pixels", expression: { interpolated: true, parameters: ["zoom"] }, "property-type": "data-constant" }, "circle-translate-anchor": { type: "enum", values: { map: {}, viewport: {} }, default: "map", requires: ["circle-translate"], expression: { interpolated: false, parameters: ["zoom"] }, "property-type": "data-constant" }, "circle-pitch-scale": { type: "enum", values: { map: {}, viewport: {} }, default: "map", expression: { interpolated: false, parameters: ["zoom"] }, "property-type": "data-constant" }, "circle-pitch-alignment": { type: "enum", values: { map: {}, viewport: {} }, default: "viewport", expression: { interpolated: false, parameters: ["zoom"] }, "property-type": "data-constant" }, "circle-stroke-width": { type: "number", default: 0, minimum: 0, transition: true, units: "pixels", expression: { interpolated: true, parameters: ["zoom", "feature", "feature-state"] }, "property-type": "data-driven" }, "circle-stroke-color": { type: "color", default: "#000000", transition: true, expression: { interpolated: true, parameters: ["zoom", "feature", "feature-state"] }, "property-type": "data-driven" }, "circle-stroke-opacity": { type: "number", default: 1, minimum: 0, maximum: 1, transition: true, expression: { interpolated: true, parameters: ["zoom", "feature", "feature-state"] }, "property-type": "data-driven" } }, paint_heatmap: { "heatmap-radius": { type: "number", default: 30, minimum: 1, transition: true, units: "pixels", expression: { interpolated: true, parameters: ["zoom", "feature", "feature-state"] }, "property-type": "data-driven" }, "heatmap-weight": { type: "number", default: 1, minimum: 0, transition: false, expression: { interpolated: true, parameters: ["zoom", "feature", "feature-state"] }, "property-type": "data-driven" }, "heatmap-intensity": { type: "number", default: 1, minimum: 0, transition: true, expression: { interpolated: true, parameters: ["zoom"] }, "property-type": "data-constant" }, "heatmap-color": { type: "color", default: ["interpolate", ["linear"], ["heatmap-density"], 0, "rgba(0, 0, 255, 0)", 0.1, "royalblue", 0.3, "cyan", 0.5, "lime", 0.7, "yellow", 1, "red"], transition: false, expression: { interpolated: true, parameters: ["heatmap-density"] }, "property-type": "color-ramp" }, "heatmap-opacity": { type: "number", default: 1, minimum: 0, maximum: 1, transition: true, expression: { interpolated: true, parameters: ["zoom"] }, "property-type": "data-constant" } }, paint_symbol: { "icon-opacity": { type: "number", default: 1, minimum: 0, maximum: 1, transition: true, requires: ["icon-image"], expression: { interpolated: true, parameters: ["zoom", "feature", "feature-state"] }, "property-type": "data-driven" }, "icon-color": { type: "color", default: "#000000", transition: true, requires: ["icon-image"], expression: { interpolated: true, parameters: ["zoom", "feature", "feature-state"] }, "property-type": "data-driven" }, "icon-halo-color": { type: "color", default: "rgba(0, 0, 0, 0)", transition: true, requires: ["icon-image"], expression: { interpolated: true, parameters: ["zoom", "feature", "feature-state"] }, "property-type": "data-driven" }, "icon-halo-width": { type: "number", default: 0, minimum: 0, transition: true, units: "pixels", requires: ["icon-image"], expression: { interpolated: true, parameters: ["zoom", "feature", "feature-state"] }, "property-type": "data-driven" }, "icon-halo-blur": { type: "number", default: 0, minimum: 0, transition: true, units: "pixels", requires: ["icon-image"], expression: { interpolated: true, parameters: ["zoom", "feature", "feature-state"] }, "property-type": "data-driven" }, "icon-translate": { type: "array", value: "number", length: 2, default: [0, 0], transition: true, units: "pixels", requires: ["icon-image"], expression: { interpolated: true, parameters: ["zoom"] }, "property-type": "data-constant" }, "icon-translate-anchor": { type: "enum", values: { map: {}, viewport: {} }, default: "map", requires: ["icon-image", "icon-translate"], expression: { interpolated: false, parameters: ["zoom"] }, "property-type": "data-constant" }, "text-opacity": { type: "number", default: 1, minimum: 0, maximum: 1, transition: true, requires: ["text-field"], expression: { interpolated: true, parameters: ["zoom", "feature", "feature-state"] }, "property-type": "data-driven" }, "text-color": { type: "color", default: "#000000", transition: true, overridable: true, requires: ["text-field"], expression: { interpolated: true, parameters: ["zoom", "feature", "feature-state"] }, "property-type": "data-driven" }, "text-halo-color": { type: "color", default: "rgba(0, 0, 0, 0)", transition: true, requires: ["text-field"], expression: { interpolated: true, parameters: ["zoom", "feature", "feature-state"] }, "property-type": "data-driven" }, "text-halo-width": { type: "number", default: 0, minimum: 0, transition: true, units: "pixels", requires: ["text-field"], expression: { interpolated: true, parameters: ["zoom", "feature", "feature-state"] }, "property-type": "data-driven" }, "text-halo-blur": { type: "number", default: 0, minimum: 0, transition: true, units: "pixels", requires: ["text-field"], expression: { interpolated: true, parameters: ["zoom", "feature", "feature-state"] }, "property-type": "data-driven" }, "text-translate": { type: "array", value: "number", length: 2, default: [0, 0], transition: true, units: "pixels", requires: ["text-field"], expression: { interpolated: true, parameters: ["zoom"] }, "property-type": "data-constant" }, "text-translate-anchor": { type: "enum", values: { map: {}, viewport: {} }, default: "map", requires: ["text-field", "text-translate"], expression: { interpolated: false, parameters: ["zoom"] }, "property-type": "data-constant" } }, paint_raster: { "raster-opacity": { type: "number", default: 1, minimum: 0, maximum: 1, transition: true, expression: { interpolated: true, parameters: ["zoom"] }, "property-type": "data-constant" }, "raster-hue-rotate": { type: "number", default: 0, period: 360, transition: true, units: "degrees", expression: { interpolated: true, parameters: ["zoom"] }, "property-type": "data-constant" }, "raster-brightness-min": { type: "number", default: 0, minimum: 0, maximum: 1, transition: true, expression: { interpolated: true, parameters: ["zoom"] }, "property-type": "data-constant" }, "raster-brightness-max": { type: "number", default: 1, minimum: 0, maximum: 1, transition: true, expression: { interpolated: true, parameters: ["zoom"] }, "property-type": "data-constant" }, "raster-saturation": { type: "number", default: 0, minimum: -1, maximum: 1, transition: true, expression: { interpolated: true, parameters: ["zoom"] }, "property-type": "data-constant" }, "raster-contrast": { type: "number", default: 0, minimum: -1, maximum: 1, transition: true, expression: { interpolated: true, parameters: ["zoom"] }, "property-type": "data-constant" }, "raster-resampling": { type: "enum", values: { linear: {}, nearest: {} }, default: "linear", expression: { interpolated: false, parameters: ["zoom"] }, "property-type": "data-constant" }, "raster-fade-duration": { type: "number", default: 300, minimum: 0, transition: false, units: "milliseconds", expression: { interpolated: true, parameters: ["zoom"] }, "property-type": "data-constant" } }, paint_hillshade: { "hillshade-illumination-direction": { type: "number", default: 335, minimum: 0, maximum: 359, transition: false, expression: { interpolated: true, parameters: ["zoom"] }, "property-type": "data-constant" }, "hillshade-illumination-anchor": { type: "enum", values: { map: {}, viewport: {} }, default: "viewport", expression: { interpolated: false, parameters: ["zoom"] }, "property-type": "data-constant" }, "hillshade-exaggeration": { type: "number", default: 0.5, minimum: 0, maximum: 1, transition: true, expression: { interpolated: true, parameters: ["zoom"] }, "property-type": "data-constant" }, "hillshade-shadow-color": { type: "color", default: "#000000", transition: true, expression: { interpolated: true, parameters: ["zoom"] }, "property-type": "data-constant" }, "hillshade-highlight-color": { type: "color", default: "#FFFFFF", transition: true, expression: { interpolated: true, parameters: ["zoom"] }, "property-type": "data-constant" }, "hillshade-accent-color": { type: "color", default: "#000000", transition: true, expression: { interpolated: true, parameters: ["zoom"] }, "property-type": "data-constant" } }, paint_background: { "background-color": { type: "color", default: "#000000", transition: true, requires: [{ "!": "background-pattern" }], expression: { interpolated: true, parameters: ["zoom"] }, "property-type": "data-constant" }, "background-pattern": { type: "resolvedImage", transition: true, expression: { interpolated: false, parameters: ["zoom"] }, "property-type": "cross-faded" }, "background-opacity": { type: "number", default: 1, minimum: 0, maximum: 1, transition: true, expression: { interpolated: true, parameters: ["zoom"] }, "property-type": "data-constant" } }, transition: { duration: { type: "number", default: 300, minimum: 0, units: "milliseconds" }, delay: { type: "number", default: 0, minimum: 0, units: "milliseconds" } }, "property-type": { "data-driven": { type: "property-type" }, "cross-faded": { type: "property-type" }, "cross-faded-data-driven": { type: "property-type" }, "color-ramp": { type: "property-type" }, "data-constant": { type: "property-type" }, constant: { type: "property-type" } }, promoteId: { "*": { type: "string" } } };
+            let je = ["type", "source", "source-layer", "minzoom", "maxzoom", "filter", "layout"];
+            function lt(R, S) {
+              let F = {};
+              for (let W in R) W !== "ref" && (F[W] = R[W]);
+              return je.forEach((W) => {
+                W in S && (F[W] = S[W]);
+              }), F;
+            }
+            function pt(R, S) {
+              if (Array.isArray(R)) {
+                if (!Array.isArray(S) || R.length !== S.length) return false;
+                for (let F = 0; F < R.length; F++) if (!pt(R[F], S[F])) return false;
+                return true;
+              }
+              if (typeof R == "object" && R !== null && S !== null) {
+                if (typeof S != "object" || Object.keys(R).length !== Object.keys(S).length) return false;
+                for (let F in R) if (!pt(R[F], S[F])) return false;
+                return true;
+              }
+              return R === S;
+            }
+            function Vt(R, S) {
+              R.push(S);
+            }
+            function ot(R, S, F) {
+              Vt(F, { command: "addSource", args: [R, S[R]] });
+            }
+            function ut(R, S, F) {
+              Vt(S, { command: "removeSource", args: [R] }), F[R] = true;
+            }
+            function Wt(R, S, F, W) {
+              ut(R, F, W), ot(R, S, F);
+            }
+            function Nt(R, S, F) {
+              let W;
+              for (W in R[F]) if (Object.prototype.hasOwnProperty.call(R[F], W) && W !== "data" && !pt(R[F][W], S[F][W])) return false;
+              for (W in S[F]) if (Object.prototype.hasOwnProperty.call(S[F], W) && W !== "data" && !pt(R[F][W], S[F][W])) return false;
+              return true;
+            }
+            function $t(R, S, F, W, te, fe) {
+              R = R || {}, S = S || {};
+              for (let pe in R) Object.prototype.hasOwnProperty.call(R, pe) && (pt(R[pe], S[pe]) || F.push({ command: fe, args: [W, pe, S[pe], te] }));
+              for (let pe in S) Object.prototype.hasOwnProperty.call(S, pe) && !Object.prototype.hasOwnProperty.call(R, pe) && (pt(R[pe], S[pe]) || F.push({ command: fe, args: [W, pe, S[pe], te] }));
+            }
+            function sr(R) {
+              return R.id;
+            }
+            function Tr(R, S) {
+              return R[S.id] = S, R;
+            }
+            class fr {
+              constructor(S, F, W, te) {
+                this.message = (S ? `${S}: ` : "") + W, te && (this.identifier = te), F != null && F.__line__ && (this.line = F.__line__);
+              }
+            }
+            function $e(R, ...S) {
+              for (let F of S) for (let W in F) R[W] = F[W];
+              return R;
+            }
+            class St extends Error {
+              constructor(S, F) {
+                super(F), this.message = F, this.key = S;
+              }
+            }
+            class Qt {
+              constructor(S, F = []) {
+                this.parent = S, this.bindings = {};
+                for (let [W, te] of F) this.bindings[W] = te;
+              }
+              concat(S) {
+                return new Qt(this, S);
+              }
+              get(S) {
+                if (this.bindings[S]) return this.bindings[S];
+                if (this.parent) return this.parent.get(S);
+                throw new Error(`${S} not found in scope.`);
+              }
+              has(S) {
+                return !!this.bindings[S] || !!this.parent && this.parent.has(S);
+              }
+            }
+            let Gt = { kind: "null" }, _t = { kind: "number" }, It = { kind: "string" }, mt = { kind: "boolean" }, er = { kind: "color" }, lr = { kind: "object" }, wr = { kind: "value" }, Lr = { kind: "collator" }, ti = { kind: "formatted" }, Br = { kind: "padding" }, Vr = { kind: "resolvedImage" }, dt = { kind: "variableAnchorOffsetCollection" };
+            function Ge(R, S) {
+              return { kind: "array", itemType: R, N: S };
+            }
+            function Je(R) {
+              if (R.kind === "array") {
+                let S = Je(R.itemType);
+                return typeof R.N == "number" ? `array<${S}, ${R.N}>` : R.itemType.kind === "value" ? "array" : `array<${S}>`;
+              }
+              return R.kind;
+            }
+            let We = [Gt, _t, It, mt, er, ti, lr, Ge(wr), Br, Vr, dt];
+            function tt(R, S) {
+              if (S.kind === "error") return null;
+              if (R.kind === "array") {
+                if (S.kind === "array" && (S.N === 0 && S.itemType.kind === "value" || !tt(R.itemType, S.itemType)) && (typeof R.N != "number" || R.N === S.N)) return null;
+              } else {
+                if (R.kind === S.kind) return null;
+                if (R.kind === "value") {
+                  for (let F of We) if (!tt(F, S)) return null;
+                }
+              }
+              return `Expected ${Je(R)} but found ${Je(S)} instead.`;
+            }
+            function xt(R, S) {
+              return S.some((F) => F.kind === R.kind);
+            }
+            function Ie(R, S) {
+              return S.some((F) => F === "null" ? R === null : F === "array" ? Array.isArray(R) : F === "object" ? R && !Array.isArray(R) && typeof R == "object" : F === typeof R);
+            }
+            function xe(R, S) {
+              return R.kind === "array" && S.kind === "array" ? R.itemType.kind === S.itemType.kind && typeof R.N == "number" : R.kind === S.kind;
+            }
+            let ke = 0.96422, vt = 0.82521, ir = 4 / 29, ar = 6 / 29, vr = 3 * ar * ar, ii = ar * ar * ar, pi = Math.PI / 180, $r = 180 / Math.PI;
+            function di(R) {
+              return (R %= 360) < 0 && (R += 360), R;
+            }
+            function ji([R, S, F, W]) {
+              let te, fe, pe = wi((0.2225045 * (R = In(R)) + 0.7168786 * (S = In(S)) + 0.0606169 * (F = In(F))) / 1);
+              R === S && S === F ? te = fe = pe : (te = wi((0.4360747 * R + 0.3850649 * S + 0.1430804 * F) / ke), fe = wi((0.0139322 * R + 0.0971045 * S + 0.7141733 * F) / vt));
+              let Fe = 116 * pe - 16;
+              return [Fe < 0 ? 0 : Fe, 500 * (te - pe), 200 * (pe - fe), W];
+            }
+            function In(R) {
+              return R <= 0.04045 ? R / 12.92 : Math.pow((R + 0.055) / 1.055, 2.4);
+            }
+            function wi(R) {
+              return R > ii ? Math.pow(R, 1 / 3) : R / vr + ir;
+            }
+            function On([R, S, F, W]) {
+              let te = (R + 16) / 116, fe = isNaN(S) ? te : te + S / 500, pe = isNaN(F) ? te : te - F / 200;
+              return te = 1 * Fn(te), fe = ke * Fn(fe), pe = vt * Fn(pe), [qn(3.1338561 * fe - 1.6168667 * te - 0.4906146 * pe), qn(-0.9787684 * fe + 1.9161415 * te + 0.033454 * pe), qn(0.0719453 * fe - 0.2289914 * te + 1.4052427 * pe), W];
+            }
+            function qn(R) {
+              return (R = R <= 304e-5 ? 12.92 * R : 1.055 * Math.pow(R, 1 / 2.4) - 0.055) < 0 ? 0 : R > 1 ? 1 : R;
+            }
+            function Fn(R) {
+              return R > ar ? R * R * R : vr * (R - ir);
+            }
+            function ra(R) {
+              return parseInt(R.padEnd(2, R), 16) / 255;
+            }
+            function la(R, S) {
+              return Ut(S ? R / 100 : R, 0, 1);
+            }
+            function Ut(R, S, F) {
+              return Math.min(Math.max(S, R), F);
+            }
+            function wt(R) {
+              return !R.some(Number.isNaN);
+            }
+            let rr = { aliceblue: [240, 248, 255], antiquewhite: [250, 235, 215], aqua: [0, 255, 255], aquamarine: [127, 255, 212], azure: [240, 255, 255], beige: [245, 245, 220], bisque: [255, 228, 196], black: [0, 0, 0], blanchedalmond: [255, 235, 205], blue: [0, 0, 255], blueviolet: [138, 43, 226], brown: [165, 42, 42], burlywood: [222, 184, 135], cadetblue: [95, 158, 160], chartreuse: [127, 255, 0], chocolate: [210, 105, 30], coral: [255, 127, 80], cornflowerblue: [100, 149, 237], cornsilk: [255, 248, 220], crimson: [220, 20, 60], cyan: [0, 255, 255], darkblue: [0, 0, 139], darkcyan: [0, 139, 139], darkgoldenrod: [184, 134, 11], darkgray: [169, 169, 169], darkgreen: [0, 100, 0], darkgrey: [169, 169, 169], darkkhaki: [189, 183, 107], darkmagenta: [139, 0, 139], darkolivegreen: [85, 107, 47], darkorange: [255, 140, 0], darkorchid: [153, 50, 204], darkred: [139, 0, 0], darksalmon: [233, 150, 122], darkseagreen: [143, 188, 143], darkslateblue: [72, 61, 139], darkslategray: [47, 79, 79], darkslategrey: [47, 79, 79], darkturquoise: [0, 206, 209], darkviolet: [148, 0, 211], deeppink: [255, 20, 147], deepskyblue: [0, 191, 255], dimgray: [105, 105, 105], dimgrey: [105, 105, 105], dodgerblue: [30, 144, 255], firebrick: [178, 34, 34], floralwhite: [255, 250, 240], forestgreen: [34, 139, 34], fuchsia: [255, 0, 255], gainsboro: [220, 220, 220], ghostwhite: [248, 248, 255], gold: [255, 215, 0], goldenrod: [218, 165, 32], gray: [128, 128, 128], green: [0, 128, 0], greenyellow: [173, 255, 47], grey: [128, 128, 128], honeydew: [240, 255, 240], hotpink: [255, 105, 180], indianred: [205, 92, 92], indigo: [75, 0, 130], ivory: [255, 255, 240], khaki: [240, 230, 140], lavender: [230, 230, 250], lavenderblush: [255, 240, 245], lawngreen: [124, 252, 0], lemonchiffon: [255, 250, 205], lightblue: [173, 216, 230], lightcoral: [240, 128, 128], lightcyan: [224, 255, 255], lightgoldenrodyellow: [250, 250, 210], lightgray: [211, 211, 211], lightgreen: [144, 238, 144], lightgrey: [211, 211, 211], lightpink: [255, 182, 193], lightsalmon: [255, 160, 122], lightseagreen: [32, 178, 170], lightskyblue: [135, 206, 250], lightslategray: [119, 136, 153], lightslategrey: [119, 136, 153], lightsteelblue: [176, 196, 222], lightyellow: [255, 255, 224], lime: [0, 255, 0], limegreen: [50, 205, 50], linen: [250, 240, 230], magenta: [255, 0, 255], maroon: [128, 0, 0], mediumaquamarine: [102, 205, 170], mediumblue: [0, 0, 205], mediumorchid: [186, 85, 211], mediumpurple: [147, 112, 219], mediumseagreen: [60, 179, 113], mediumslateblue: [123, 104, 238], mediumspringgreen: [0, 250, 154], mediumturquoise: [72, 209, 204], mediumvioletred: [199, 21, 133], midnightblue: [25, 25, 112], mintcream: [245, 255, 250], mistyrose: [255, 228, 225], moccasin: [255, 228, 181], navajowhite: [255, 222, 173], navy: [0, 0, 128], oldlace: [253, 245, 230], olive: [128, 128, 0], olivedrab: [107, 142, 35], orange: [255, 165, 0], orangered: [255, 69, 0], orchid: [218, 112, 214], palegoldenrod: [238, 232, 170], palegreen: [152, 251, 152], paleturquoise: [175, 238, 238], palevioletred: [219, 112, 147], papayawhip: [255, 239, 213], peachpuff: [255, 218, 185], peru: [205, 133, 63], pink: [255, 192, 203], plum: [221, 160, 221], powderblue: [176, 224, 230], purple: [128, 0, 128], rebeccapurple: [102, 51, 153], red: [255, 0, 0], rosybrown: [188, 143, 143], royalblue: [65, 105, 225], saddlebrown: [139, 69, 19], salmon: [250, 128, 114], sandybrown: [244, 164, 96], seagreen: [46, 139, 87], seashell: [255, 245, 238], sienna: [160, 82, 45], silver: [192, 192, 192], skyblue: [135, 206, 235], slateblue: [106, 90, 205], slategray: [112, 128, 144], slategrey: [112, 128, 144], snow: [255, 250, 250], springgreen: [0, 255, 127], steelblue: [70, 130, 180], tan: [210, 180, 140], teal: [0, 128, 128], thistle: [216, 191, 216], tomato: [255, 99, 71], turquoise: [64, 224, 208], violet: [238, 130, 238], wheat: [245, 222, 179], white: [255, 255, 255], whitesmoke: [245, 245, 245], yellow: [255, 255, 0], yellowgreen: [154, 205, 50] };
+            class nr {
+              constructor(S, F, W, te = 1, fe = true) {
+                this.r = S, this.g = F, this.b = W, this.a = te, fe || (this.r *= te, this.g *= te, this.b *= te, te || this.overwriteGetter("rgb", [S, F, W, te]));
+              }
+              static parse(S) {
+                if (S instanceof nr) return S;
+                if (typeof S != "string") return;
+                let F = function(W) {
+                  if ((W = W.toLowerCase().trim()) === "transparent") return [0, 0, 0, 0];
+                  let te = rr[W];
+                  if (te) {
+                    let [pe, Fe, Ke] = te;
+                    return [pe / 255, Fe / 255, Ke / 255, 1];
+                  }
+                  if (W.startsWith("#") && /^#(?:[0-9a-f]{3,4}|[0-9a-f]{6}|[0-9a-f]{8})$/.test(W)) {
+                    let pe = W.length < 6 ? 1 : 2, Fe = 1;
+                    return [ra(W.slice(Fe, Fe += pe)), ra(W.slice(Fe, Fe += pe)), ra(W.slice(Fe, Fe += pe)), ra(W.slice(Fe, Fe + pe) || "ff")];
+                  }
+                  if (W.startsWith("rgb")) {
+                    let pe = W.match(/^rgba?\(\s*([\de.+-]+)(%)?(?:\s+|\s*(,)\s*)([\de.+-]+)(%)?(?:\s+|\s*(,)\s*)([\de.+-]+)(%)?(?:\s*([,\/])\s*([\de.+-]+)(%)?)?\s*\)$/);
+                    if (pe) {
+                      let [Fe, Ke, ct, Lt, Jt, cr, mr, Pr, zr, ui, yi, vn] = pe, zi = [Lt || " ", mr || " ", ui].join("");
+                      if (zi === "  " || zi === "  /" || zi === ",," || zi === ",,,") {
+                        let un = [ct, cr, zr].join(""), Tn = un === "%%%" ? 100 : un === "" ? 255 : 0;
+                        if (Tn) {
+                          let pa = [Ut(+Ke / Tn, 0, 1), Ut(+Jt / Tn, 0, 1), Ut(+Pr / Tn, 0, 1), yi ? la(+yi, vn) : 1];
+                          if (wt(pa)) return pa;
+                        }
+                      }
+                      return;
+                    }
+                  }
+                  let fe = W.match(/^hsla?\(\s*([\de.+-]+)(?:deg)?(?:\s+|\s*(,)\s*)([\de.+-]+)%(?:\s+|\s*(,)\s*)([\de.+-]+)%(?:\s*([,\/])\s*([\de.+-]+)(%)?)?\s*\)$/);
+                  if (fe) {
+                    let [pe, Fe, Ke, ct, Lt, Jt, cr, mr, Pr] = fe, zr = [Ke || " ", Lt || " ", cr].join("");
+                    if (zr === "  " || zr === "  /" || zr === ",," || zr === ",,,") {
+                      let ui = [+Fe, Ut(+ct, 0, 100), Ut(+Jt, 0, 100), mr ? la(+mr, Pr) : 1];
+                      if (wt(ui)) return function([yi, vn, zi, un]) {
+                        function Tn(pa) {
+                          let ro = (pa + yi / 30) % 12, Vo = vn * Math.min(zi, 1 - zi);
+                          return zi - Vo * Math.max(-1, Math.min(ro - 3, 9 - ro, 1));
+                        }
+                        return yi = di(yi), vn /= 100, zi /= 100, [Tn(0), Tn(8), Tn(4), un];
+                      }(ui);
+                    }
+                  }
+                }(S);
+                return F ? new nr(...F, false) : void 0;
+              }
+              get rgb() {
+                let { r: S, g: F, b: W, a: te } = this, fe = te || 1 / 0;
+                return this.overwriteGetter("rgb", [S / fe, F / fe, W / fe, te]);
+              }
+              get hcl() {
+                return this.overwriteGetter("hcl", function(S) {
+                  let [F, W, te, fe] = ji(S), pe = Math.sqrt(W * W + te * te);
+                  return [Math.round(1e4 * pe) ? di(Math.atan2(te, W) * $r) : NaN, pe, F, fe];
+                }(this.rgb));
+              }
+              get lab() {
+                return this.overwriteGetter("lab", ji(this.rgb));
+              }
+              overwriteGetter(S, F) {
+                return Object.defineProperty(this, S, { value: F }), F;
+              }
+              toString() {
+                let [S, F, W, te] = this.rgb;
+                return `rgba(${[S, F, W].map((fe) => Math.round(255 * fe)).join(",")},${te})`;
+              }
+            }
+            nr.black = new nr(0, 0, 0, 1), nr.white = new nr(1, 1, 1, 1), nr.transparent = new nr(0, 0, 0, 0), nr.red = new nr(1, 0, 0, 1);
+            class Er {
+              constructor(S, F, W) {
+                this.sensitivity = S ? F ? "variant" : "case" : F ? "accent" : "base", this.locale = W, this.collator = new Intl.Collator(this.locale ? this.locale : [], { sensitivity: this.sensitivity, usage: "search" });
+              }
+              compare(S, F) {
+                return this.collator.compare(S, F);
+              }
+              resolvedLocale() {
+                return new Intl.Collator(this.locale ? this.locale : []).resolvedOptions().locale;
+              }
+            }
+            class Xr {
+              constructor(S, F, W, te, fe) {
+                this.text = S, this.image = F, this.scale = W, this.fontStack = te, this.textColor = fe;
+              }
+            }
+            class ri {
+              constructor(S) {
+                this.sections = S;
+              }
+              static fromString(S) {
+                return new ri([new Xr(S, null, null, null, null)]);
+              }
+              isEmpty() {
+                return this.sections.length === 0 || !this.sections.some((S) => S.text.length !== 0 || S.image && S.image.name.length !== 0);
+              }
+              static factory(S) {
+                return S instanceof ri ? S : ri.fromString(S);
+              }
+              toString() {
+                return this.sections.length === 0 ? "" : this.sections.map((S) => S.text).join("");
+              }
+            }
+            class Qr {
+              constructor(S) {
+                this.values = S.slice();
+              }
+              static parse(S) {
+                if (S instanceof Qr) return S;
+                if (typeof S == "number") return new Qr([S, S, S, S]);
+                if (Array.isArray(S) && !(S.length < 1 || S.length > 4)) {
+                  for (let F of S) if (typeof F != "number") return;
+                  switch (S.length) {
+                    case 1:
+                      S = [S[0], S[0], S[0], S[0]];
+                      break;
+                    case 2:
+                      S = [S[0], S[1], S[0], S[1]];
+                      break;
+                    case 3:
+                      S = [S[0], S[1], S[2], S[1]];
+                  }
+                  return new Qr(S);
+                }
+              }
+              toString() {
+                return JSON.stringify(this.values);
+              }
+            }
+            let Oi = /* @__PURE__ */ new Set(["center", "left", "right", "top", "bottom", "top-left", "top-right", "bottom-left", "bottom-right"]);
+            class $i {
+              constructor(S) {
+                this.values = S.slice();
+              }
+              static parse(S) {
+                if (S instanceof $i) return S;
+                if (Array.isArray(S) && !(S.length < 1) && S.length % 2 == 0) {
+                  for (let F = 0; F < S.length; F += 2) {
+                    let W = S[F], te = S[F + 1];
+                    if (typeof W != "string" || !Oi.has(W) || !Array.isArray(te) || te.length !== 2 || typeof te[0] != "number" || typeof te[1] != "number") return;
+                  }
+                  return new $i(S);
+                }
+              }
+              toString() {
+                return JSON.stringify(this.values);
+              }
+            }
+            class tn {
+              constructor(S) {
+                this.name = S.name, this.available = S.available;
+              }
+              toString() {
+                return this.name;
+              }
+              static fromString(S) {
+                return S ? new tn({ name: S, available: false }) : null;
+              }
+            }
+            function fn(R, S, F, W) {
+              return typeof R == "number" && R >= 0 && R <= 255 && typeof S == "number" && S >= 0 && S <= 255 && typeof F == "number" && F >= 0 && F <= 255 ? W === void 0 || typeof W == "number" && W >= 0 && W <= 1 ? null : `Invalid rgba value [${[R, S, F, W].join(", ")}]: 'a' must be between 0 and 1.` : `Invalid rgba value [${(typeof W == "number" ? [R, S, F, W] : [R, S, F]).join(", ")}]: 'r', 'g', and 'b' must be between 0 and 255.`;
+            }
+            function yn(R) {
+              if (R === null || typeof R == "string" || typeof R == "boolean" || typeof R == "number" || R instanceof nr || R instanceof Er || R instanceof ri || R instanceof Qr || R instanceof $i || R instanceof tn) return true;
+              if (Array.isArray(R)) {
+                for (let S of R) if (!yn(S)) return false;
+                return true;
+              }
+              if (typeof R == "object") {
+                for (let S in R) if (!yn(R[S])) return false;
+                return true;
+              }
+              return false;
+            }
+            function Sn(R) {
+              if (R === null) return Gt;
+              if (typeof R == "string") return It;
+              if (typeof R == "boolean") return mt;
+              if (typeof R == "number") return _t;
+              if (R instanceof nr) return er;
+              if (R instanceof Er) return Lr;
+              if (R instanceof ri) return ti;
+              if (R instanceof Qr) return Br;
+              if (R instanceof $i) return dt;
+              if (R instanceof tn) return Vr;
+              if (Array.isArray(R)) {
+                let S = R.length, F;
+                for (let W of R) {
+                  let te = Sn(W);
+                  if (F) {
+                    if (F === te) continue;
+                    F = wr;
+                    break;
+                  }
+                  F = te;
+                }
+                return Ge(F || wr, S);
+              }
+              return lr;
+            }
+            function Ba(R) {
+              let S = typeof R;
+              return R === null ? "" : S === "string" || S === "number" || S === "boolean" ? String(R) : R instanceof nr || R instanceof ri || R instanceof Qr || R instanceof $i || R instanceof tn ? R.toString() : JSON.stringify(R);
+            }
+            class ua {
+              constructor(S, F) {
+                this.type = S, this.value = F;
+              }
+              static parse(S, F) {
+                if (S.length !== 2) return F.error(`'literal' expression requires exactly one argument, but found ${S.length - 1} instead.`);
+                if (!yn(S[1])) return F.error("invalid value");
+                let W = S[1], te = Sn(W), fe = F.expectedType;
+                return te.kind !== "array" || te.N !== 0 || !fe || fe.kind !== "array" || typeof fe.N == "number" && fe.N !== 0 || (te = fe), new ua(te, W);
+              }
+              evaluate() {
+                return this.value;
+              }
+              eachChild() {
+              }
+              outputDefined() {
+                return true;
+              }
+            }
+            class ma {
+              constructor(S) {
+                this.name = "ExpressionEvaluationError", this.message = S;
+              }
+              toJSON() {
+                return this.message;
+              }
+            }
+            let Wa = { string: It, number: _t, boolean: mt, object: lr };
+            class Fa {
+              constructor(S, F) {
+                this.type = S, this.args = F;
+              }
+              static parse(S, F) {
+                if (S.length < 2) return F.error("Expected at least one argument.");
+                let W, te = 1, fe = S[0];
+                if (fe === "array") {
+                  let Fe, Ke;
+                  if (S.length > 2) {
+                    let ct = S[1];
+                    if (typeof ct != "string" || !(ct in Wa) || ct === "object") return F.error('The item type argument of "array" must be one of string, number, boolean', 1);
+                    Fe = Wa[ct], te++;
+                  } else Fe = wr;
+                  if (S.length > 3) {
+                    if (S[2] !== null && (typeof S[2] != "number" || S[2] < 0 || S[2] !== Math.floor(S[2]))) return F.error('The length argument to "array" must be a positive integer literal', 2);
+                    Ke = S[2], te++;
+                  }
+                  W = Ge(Fe, Ke);
+                } else {
+                  if (!Wa[fe]) throw new Error(`Types doesn't contain name = ${fe}`);
+                  W = Wa[fe];
+                }
+                let pe = [];
+                for (; te < S.length; te++) {
+                  let Fe = F.parse(S[te], te, wr);
+                  if (!Fe) return null;
+                  pe.push(Fe);
+                }
+                return new Fa(W, pe);
+              }
+              evaluate(S) {
+                for (let F = 0; F < this.args.length; F++) {
+                  let W = this.args[F].evaluate(S);
+                  if (!tt(this.type, Sn(W))) return W;
+                  if (F === this.args.length - 1) throw new ma(`Expected value to be of type ${Je(this.type)}, but found ${Je(Sn(W))} instead.`);
+                }
+                throw new Error();
+              }
+              eachChild(S) {
+                this.args.forEach(S);
+              }
+              outputDefined() {
+                return this.args.every((S) => S.outputDefined());
+              }
+            }
+            let Xo = { "to-boolean": mt, "to-color": er, "to-number": _t, "to-string": It };
+            class da {
+              constructor(S, F) {
+                this.type = S, this.args = F;
+              }
+              static parse(S, F) {
+                if (S.length < 2) return F.error("Expected at least one argument.");
+                let W = S[0];
+                if (!Xo[W]) throw new Error(`Can't parse ${W} as it is not part of the known types`);
+                if ((W === "to-boolean" || W === "to-string") && S.length !== 2) return F.error("Expected one argument.");
+                let te = Xo[W], fe = [];
+                for (let pe = 1; pe < S.length; pe++) {
+                  let Fe = F.parse(S[pe], pe, wr);
+                  if (!Fe) return null;
+                  fe.push(Fe);
+                }
+                return new da(te, fe);
+              }
+              evaluate(S) {
+                switch (this.type.kind) {
+                  case "boolean":
+                    return !!this.args[0].evaluate(S);
+                  case "color": {
+                    let F, W;
+                    for (let te of this.args) {
+                      if (F = te.evaluate(S), W = null, F instanceof nr) return F;
+                      if (typeof F == "string") {
+                        let fe = S.parseColor(F);
+                        if (fe) return fe;
+                      } else if (Array.isArray(F) && (W = F.length < 3 || F.length > 4 ? `Invalid rbga value ${JSON.stringify(F)}: expected an array containing either three or four numeric values.` : fn(F[0], F[1], F[2], F[3]), !W)) return new nr(F[0] / 255, F[1] / 255, F[2] / 255, F[3]);
+                    }
+                    throw new ma(W || `Could not parse color from value '${typeof F == "string" ? F : JSON.stringify(F)}'`);
+                  }
+                  case "padding": {
+                    let F;
+                    for (let W of this.args) {
+                      F = W.evaluate(S);
+                      let te = Qr.parse(F);
+                      if (te) return te;
+                    }
+                    throw new ma(`Could not parse padding from value '${typeof F == "string" ? F : JSON.stringify(F)}'`);
+                  }
+                  case "variableAnchorOffsetCollection": {
+                    let F;
+                    for (let W of this.args) {
+                      F = W.evaluate(S);
+                      let te = $i.parse(F);
+                      if (te) return te;
+                    }
+                    throw new ma(`Could not parse variableAnchorOffsetCollection from value '${typeof F == "string" ? F : JSON.stringify(F)}'`);
+                  }
+                  case "number": {
+                    let F = null;
+                    for (let W of this.args) {
+                      if (F = W.evaluate(S), F === null) return 0;
+                      let te = Number(F);
+                      if (!isNaN(te)) return te;
+                    }
+                    throw new ma(`Could not convert ${JSON.stringify(F)} to number.`);
+                  }
+                  case "formatted":
+                    return ri.fromString(Ba(this.args[0].evaluate(S)));
+                  case "resolvedImage":
+                    return tn.fromString(Ba(this.args[0].evaluate(S)));
+                  default:
+                    return Ba(this.args[0].evaluate(S));
+                }
+              }
+              eachChild(S) {
+                this.args.forEach(S);
+              }
+              outputDefined() {
+                return this.args.every((S) => S.outputDefined());
+              }
+            }
+            let Wn = ["Unknown", "Point", "LineString", "Polygon"];
+            class Ha {
+              constructor() {
+                this.globals = null, this.feature = null, this.featureState = null, this.formattedSection = null, this._parseColorCache = {}, this.availableImages = null, this.canonical = null;
+              }
+              id() {
+                return this.feature && "id" in this.feature ? this.feature.id : null;
+              }
+              geometryType() {
+                return this.feature ? typeof this.feature.type == "number" ? Wn[this.feature.type] : this.feature.type : null;
+              }
+              geometry() {
+                return this.feature && "geometry" in this.feature ? this.feature.geometry : null;
+              }
+              canonicalID() {
+                return this.canonical;
+              }
+              properties() {
+                return this.feature && this.feature.properties || {};
+              }
+              parseColor(S) {
+                let F = this._parseColorCache[S];
+                return F || (F = this._parseColorCache[S] = nr.parse(S)), F;
+              }
+            }
+            class vo {
+              constructor(S, F, W = [], te, fe = new Qt(), pe = []) {
+                this.registry = S, this.path = W, this.key = W.map((Fe) => `[${Fe}]`).join(""), this.scope = fe, this.errors = pe, this.expectedType = te, this._isConstant = F;
+              }
+              parse(S, F, W, te, fe = {}) {
+                return F ? this.concat(F, W, te)._parse(S, fe) : this._parse(S, fe);
+              }
+              _parse(S, F) {
+                function W(te, fe, pe) {
+                  return pe === "assert" ? new Fa(fe, [te]) : pe === "coerce" ? new da(fe, [te]) : te;
+                }
+                if (S !== null && typeof S != "string" && typeof S != "boolean" && typeof S != "number" || (S = ["literal", S]), Array.isArray(S)) {
+                  if (S.length === 0) return this.error('Expected an array with at least one element. If you wanted a literal array, use ["literal", []].');
+                  let te = S[0];
+                  if (typeof te != "string") return this.error(`Expression name must be a string, but found ${typeof te} instead. If you wanted a literal array, use ["literal", [...]].`, 0), null;
+                  let fe = this.registry[te];
+                  if (fe) {
+                    let pe = fe.parse(S, this);
+                    if (!pe) return null;
+                    if (this.expectedType) {
+                      let Fe = this.expectedType, Ke = pe.type;
+                      if (Fe.kind !== "string" && Fe.kind !== "number" && Fe.kind !== "boolean" && Fe.kind !== "object" && Fe.kind !== "array" || Ke.kind !== "value") if (Fe.kind !== "color" && Fe.kind !== "formatted" && Fe.kind !== "resolvedImage" || Ke.kind !== "value" && Ke.kind !== "string") if (Fe.kind !== "padding" || Ke.kind !== "value" && Ke.kind !== "number" && Ke.kind !== "array") if (Fe.kind !== "variableAnchorOffsetCollection" || Ke.kind !== "value" && Ke.kind !== "array") {
+                        if (this.checkSubtype(Fe, Ke)) return null;
+                      } else pe = W(pe, Fe, F.typeAnnotation || "coerce");
+                      else pe = W(pe, Fe, F.typeAnnotation || "coerce");
+                      else pe = W(pe, Fe, F.typeAnnotation || "coerce");
+                      else pe = W(pe, Fe, F.typeAnnotation || "assert");
+                    }
+                    if (!(pe instanceof ua) && pe.type.kind !== "resolvedImage" && this._isConstant(pe)) {
+                      let Fe = new Ha();
+                      try {
+                        pe = new ua(pe.type, pe.evaluate(Fe));
+                      } catch (Ke) {
+                        return this.error(Ke.message), null;
+                      }
+                    }
+                    return pe;
+                  }
+                  return this.error(`Unknown expression "${te}". If you wanted a literal array, use ["literal", [...]].`, 0);
+                }
+                return this.error(S === void 0 ? "'undefined' value invalid. Use null instead." : typeof S == "object" ? 'Bare objects invalid. Use ["literal", {...}] instead.' : `Expected an array, but found ${typeof S} instead.`);
+              }
+              concat(S, F, W) {
+                let te = typeof S == "number" ? this.path.concat(S) : this.path, fe = W ? this.scope.concat(W) : this.scope;
+                return new vo(this.registry, this._isConstant, te, F || null, fe, this.errors);
+              }
+              error(S, ...F) {
+                let W = `${this.key}${F.map((te) => `[${te}]`).join("")}`;
+                this.errors.push(new St(W, S));
+              }
+              checkSubtype(S, F) {
+                let W = tt(S, F);
+                return W && this.error(W), W;
+              }
+            }
+            class jn {
+              constructor(S, F) {
+                this.type = F.type, this.bindings = [].concat(S), this.result = F;
+              }
+              evaluate(S) {
+                return this.result.evaluate(S);
+              }
+              eachChild(S) {
+                for (let F of this.bindings) S(F[1]);
+                S(this.result);
+              }
+              static parse(S, F) {
+                if (S.length < 4) return F.error(`Expected at least 3 arguments, but found ${S.length - 1} instead.`);
+                let W = [];
+                for (let fe = 1; fe < S.length - 1; fe += 2) {
+                  let pe = S[fe];
+                  if (typeof pe != "string") return F.error(`Expected string, but found ${typeof pe} instead.`, fe);
+                  if (/[^a-zA-Z0-9_]/.test(pe)) return F.error("Variable names must contain only alphanumeric characters or '_'.", fe);
+                  let Fe = F.parse(S[fe + 1], fe + 1);
+                  if (!Fe) return null;
+                  W.push([pe, Fe]);
+                }
+                let te = F.parse(S[S.length - 1], S.length - 1, F.expectedType, W);
+                return te ? new jn(W, te) : null;
+              }
+              outputDefined() {
+                return this.result.outputDefined();
+              }
+            }
+            class Mt {
+              constructor(S, F) {
+                this.type = F.type, this.name = S, this.boundExpression = F;
+              }
+              static parse(S, F) {
+                if (S.length !== 2 || typeof S[1] != "string") return F.error("'var' expression requires exactly one string literal argument.");
+                let W = S[1];
+                return F.scope.has(W) ? new Mt(W, F.scope.get(W)) : F.error(`Unknown variable "${W}". Make sure "${W}" has been bound in an enclosing "let" expression before using it.`, 1);
+              }
+              evaluate(S) {
+                return this.boundExpression.evaluate(S);
+              }
+              eachChild() {
+              }
+              outputDefined() {
+                return false;
+              }
+            }
+            class kr {
+              constructor(S, F, W) {
+                this.type = S, this.index = F, this.input = W;
+              }
+              static parse(S, F) {
+                if (S.length !== 3) return F.error(`Expected 2 arguments, but found ${S.length - 1} instead.`);
+                let W = F.parse(S[1], 1, _t), te = F.parse(S[2], 2, Ge(F.expectedType || wr));
+                return W && te ? new kr(te.type.itemType, W, te) : null;
+              }
+              evaluate(S) {
+                let F = this.index.evaluate(S), W = this.input.evaluate(S);
+                if (F < 0) throw new ma(`Array index out of bounds: ${F} < 0.`);
+                if (F >= W.length) throw new ma(`Array index out of bounds: ${F} > ${W.length - 1}.`);
+                if (F !== Math.floor(F)) throw new ma(`Array index must be an integer, but found ${F} instead.`);
+                return W[F];
+              }
+              eachChild(S) {
+                S(this.index), S(this.input);
+              }
+              outputDefined() {
+                return false;
+              }
+            }
+            class Jr {
+              constructor(S, F) {
+                this.type = mt, this.needle = S, this.haystack = F;
+              }
+              static parse(S, F) {
+                if (S.length !== 3) return F.error(`Expected 2 arguments, but found ${S.length - 1} instead.`);
+                let W = F.parse(S[1], 1, wr), te = F.parse(S[2], 2, wr);
+                return W && te ? xt(W.type, [mt, It, _t, Gt, wr]) ? new Jr(W, te) : F.error(`Expected first argument to be of type boolean, string, number or null, but found ${Je(W.type)} instead`) : null;
+              }
+              evaluate(S) {
+                let F = this.needle.evaluate(S), W = this.haystack.evaluate(S);
+                if (!W) return false;
+                if (!Ie(F, ["boolean", "string", "number", "null"])) throw new ma(`Expected first argument to be of type boolean, string, number or null, but found ${Je(Sn(F))} instead.`);
+                if (!Ie(W, ["string", "array"])) throw new ma(`Expected second argument to be of type array or string, but found ${Je(Sn(W))} instead.`);
+                return W.indexOf(F) >= 0;
+              }
+              eachChild(S) {
+                S(this.needle), S(this.haystack);
+              }
+              outputDefined() {
+                return true;
+              }
+            }
+            class vi {
+              constructor(S, F, W) {
+                this.type = _t, this.needle = S, this.haystack = F, this.fromIndex = W;
+              }
+              static parse(S, F) {
+                if (S.length <= 2 || S.length >= 5) return F.error(`Expected 3 or 4 arguments, but found ${S.length - 1} instead.`);
+                let W = F.parse(S[1], 1, wr), te = F.parse(S[2], 2, wr);
+                if (!W || !te) return null;
+                if (!xt(W.type, [mt, It, _t, Gt, wr])) return F.error(`Expected first argument to be of type boolean, string, number or null, but found ${Je(W.type)} instead`);
+                if (S.length === 4) {
+                  let fe = F.parse(S[3], 3, _t);
+                  return fe ? new vi(W, te, fe) : null;
+                }
+                return new vi(W, te);
+              }
+              evaluate(S) {
+                let F = this.needle.evaluate(S), W = this.haystack.evaluate(S);
+                if (!Ie(F, ["boolean", "string", "number", "null"])) throw new ma(`Expected first argument to be of type boolean, string, number or null, but found ${Je(Sn(F))} instead.`);
+                let te;
+                if (this.fromIndex && (te = this.fromIndex.evaluate(S)), Ie(W, ["string"])) {
+                  let fe = W.indexOf(F, te);
+                  return fe === -1 ? -1 : [...W.slice(0, fe)].length;
+                }
+                if (Ie(W, ["array"])) return W.indexOf(F, te);
+                throw new ma(`Expected second argument to be of type array or string, but found ${Je(Sn(W))} instead.`);
+              }
+              eachChild(S) {
+                S(this.needle), S(this.haystack), this.fromIndex && S(this.fromIndex);
+              }
+              outputDefined() {
+                return false;
+              }
+            }
+            class hn {
+              constructor(S, F, W, te, fe, pe) {
+                this.inputType = S, this.type = F, this.input = W, this.cases = te, this.outputs = fe, this.otherwise = pe;
+              }
+              static parse(S, F) {
+                if (S.length < 5) return F.error(`Expected at least 4 arguments, but found only ${S.length - 1}.`);
+                if (S.length % 2 != 1) return F.error("Expected an even number of arguments.");
+                let W, te;
+                F.expectedType && F.expectedType.kind !== "value" && (te = F.expectedType);
+                let fe = {}, pe = [];
+                for (let ct = 2; ct < S.length - 1; ct += 2) {
+                  let Lt = S[ct], Jt = S[ct + 1];
+                  Array.isArray(Lt) || (Lt = [Lt]);
+                  let cr = F.concat(ct);
+                  if (Lt.length === 0) return cr.error("Expected at least one branch label.");
+                  for (let Pr of Lt) {
+                    if (typeof Pr != "number" && typeof Pr != "string") return cr.error("Branch labels must be numbers or strings.");
+                    if (typeof Pr == "number" && Math.abs(Pr) > Number.MAX_SAFE_INTEGER) return cr.error(`Branch labels must be integers no larger than ${Number.MAX_SAFE_INTEGER}.`);
+                    if (typeof Pr == "number" && Math.floor(Pr) !== Pr) return cr.error("Numeric branch labels must be integer values.");
+                    if (W) {
+                      if (cr.checkSubtype(W, Sn(Pr))) return null;
+                    } else W = Sn(Pr);
+                    if (fe[String(Pr)] !== void 0) return cr.error("Branch labels must be unique.");
+                    fe[String(Pr)] = pe.length;
+                  }
+                  let mr = F.parse(Jt, ct, te);
+                  if (!mr) return null;
+                  te = te || mr.type, pe.push(mr);
+                }
+                let Fe = F.parse(S[1], 1, wr);
+                if (!Fe) return null;
+                let Ke = F.parse(S[S.length - 1], S.length - 1, te);
+                return Ke ? Fe.type.kind !== "value" && F.concat(1).checkSubtype(W, Fe.type) ? null : new hn(W, te, Fe, fe, pe, Ke) : null;
+              }
+              evaluate(S) {
+                let F = this.input.evaluate(S);
+                return (Sn(F) === this.inputType && this.outputs[this.cases[F]] || this.otherwise).evaluate(S);
+              }
+              eachChild(S) {
+                S(this.input), this.outputs.forEach(S), S(this.otherwise);
+              }
+              outputDefined() {
+                return this.outputs.every((S) => S.outputDefined()) && this.otherwise.outputDefined();
+              }
+            }
+            class An {
+              constructor(S, F, W) {
+                this.type = S, this.branches = F, this.otherwise = W;
+              }
+              static parse(S, F) {
+                if (S.length < 4) return F.error(`Expected at least 3 arguments, but found only ${S.length - 1}.`);
+                if (S.length % 2 != 0) return F.error("Expected an odd number of arguments.");
+                let W;
+                F.expectedType && F.expectedType.kind !== "value" && (W = F.expectedType);
+                let te = [];
+                for (let pe = 1; pe < S.length - 1; pe += 2) {
+                  let Fe = F.parse(S[pe], pe, mt);
+                  if (!Fe) return null;
+                  let Ke = F.parse(S[pe + 1], pe + 1, W);
+                  if (!Ke) return null;
+                  te.push([Fe, Ke]), W = W || Ke.type;
+                }
+                let fe = F.parse(S[S.length - 1], S.length - 1, W);
+                if (!fe) return null;
+                if (!W) throw new Error("Can't infer output type");
+                return new An(W, te, fe);
+              }
+              evaluate(S) {
+                for (let [F, W] of this.branches) if (F.evaluate(S)) return W.evaluate(S);
+                return this.otherwise.evaluate(S);
+              }
+              eachChild(S) {
+                for (let [F, W] of this.branches) S(F), S(W);
+                S(this.otherwise);
+              }
+              outputDefined() {
+                return this.branches.every(([S, F]) => F.outputDefined()) && this.otherwise.outputDefined();
+              }
+            }
+            class Mn {
+              constructor(S, F, W, te) {
+                this.type = S, this.input = F, this.beginIndex = W, this.endIndex = te;
+              }
+              static parse(S, F) {
+                if (S.length <= 2 || S.length >= 5) return F.error(`Expected 3 or 4 arguments, but found ${S.length - 1} instead.`);
+                let W = F.parse(S[1], 1, wr), te = F.parse(S[2], 2, _t);
+                if (!W || !te) return null;
+                if (!xt(W.type, [Ge(wr), It, wr])) return F.error(`Expected first argument to be of type array or string, but found ${Je(W.type)} instead`);
+                if (S.length === 4) {
+                  let fe = F.parse(S[3], 3, _t);
+                  return fe ? new Mn(W.type, W, te, fe) : null;
+                }
+                return new Mn(W.type, W, te);
+              }
+              evaluate(S) {
+                let F = this.input.evaluate(S), W = this.beginIndex.evaluate(S), te;
+                if (this.endIndex && (te = this.endIndex.evaluate(S)), Ie(F, ["string"])) return [...F].slice(W, te).join("");
+                if (Ie(F, ["array"])) return F.slice(W, te);
+                throw new ma(`Expected first argument to be of type array or string, but found ${Je(Sn(F))} instead.`);
+              }
+              eachChild(S) {
+                S(this.input), S(this.beginIndex), this.endIndex && S(this.endIndex);
+              }
+              outputDefined() {
+                return false;
+              }
+            }
+            function Li(R, S) {
+              let F = R.length - 1, W, te, fe = 0, pe = F, Fe = 0;
+              for (; fe <= pe; ) if (Fe = Math.floor((fe + pe) / 2), W = R[Fe], te = R[Fe + 1], W <= S) {
+                if (Fe === F || S < te) return Fe;
+                fe = Fe + 1;
+              } else {
+                if (!(W > S)) throw new ma("Input is not a number.");
+                pe = Fe - 1;
+              }
+              return 0;
+            }
+            class _n {
+              constructor(S, F, W) {
+                this.type = S, this.input = F, this.labels = [], this.outputs = [];
+                for (let [te, fe] of W) this.labels.push(te), this.outputs.push(fe);
+              }
+              static parse(S, F) {
+                if (S.length - 1 < 4) return F.error(`Expected at least 4 arguments, but found only ${S.length - 1}.`);
+                if ((S.length - 1) % 2 != 0) return F.error("Expected an even number of arguments.");
+                let W = F.parse(S[1], 1, _t);
+                if (!W) return null;
+                let te = [], fe = null;
+                F.expectedType && F.expectedType.kind !== "value" && (fe = F.expectedType);
+                for (let pe = 1; pe < S.length; pe += 2) {
+                  let Fe = pe === 1 ? -1 / 0 : S[pe], Ke = S[pe + 1], ct = pe, Lt = pe + 1;
+                  if (typeof Fe != "number") return F.error('Input/output pairs for "step" expressions must be defined using literal numeric values (not computed expressions) for the input values.', ct);
+                  if (te.length && te[te.length - 1][0] >= Fe) return F.error('Input/output pairs for "step" expressions must be arranged with input values in strictly ascending order.', ct);
+                  let Jt = F.parse(Ke, Lt, fe);
+                  if (!Jt) return null;
+                  fe = fe || Jt.type, te.push([Fe, Jt]);
+                }
+                return new _n(fe, W, te);
+              }
+              evaluate(S) {
+                let F = this.labels, W = this.outputs;
+                if (F.length === 1) return W[0].evaluate(S);
+                let te = this.input.evaluate(S);
+                if (te <= F[0]) return W[0].evaluate(S);
+                let fe = F.length;
+                return te >= F[fe - 1] ? W[fe - 1].evaluate(S) : W[Li(F, te)].evaluate(S);
+              }
+              eachChild(S) {
+                S(this.input);
+                for (let F of this.outputs) S(F);
+              }
+              outputDefined() {
+                return this.outputs.every((S) => S.outputDefined());
+              }
+            }
+            function ya(R) {
+              return R && R.__esModule && Object.prototype.hasOwnProperty.call(R, "default") ? R.default : R;
+            }
+            var $n = Ma;
+            function Ma(R, S, F, W) {
+              this.cx = 3 * R, this.bx = 3 * (F - R) - this.cx, this.ax = 1 - this.cx - this.bx, this.cy = 3 * S, this.by = 3 * (W - S) - this.cy, this.ay = 1 - this.cy - this.by, this.p1x = R, this.p1y = S, this.p2x = F, this.p2y = W;
+            }
+            Ma.prototype = { sampleCurveX: function(R) {
+              return ((this.ax * R + this.bx) * R + this.cx) * R;
+            }, sampleCurveY: function(R) {
+              return ((this.ay * R + this.by) * R + this.cy) * R;
+            }, sampleCurveDerivativeX: function(R) {
+              return (3 * this.ax * R + 2 * this.bx) * R + this.cx;
+            }, solveCurveX: function(R, S) {
+              if (S === void 0 && (S = 1e-6), R < 0) return 0;
+              if (R > 1) return 1;
+              for (var F = R, W = 0; W < 8; W++) {
+                var te = this.sampleCurveX(F) - R;
+                if (Math.abs(te) < S) return F;
+                var fe = this.sampleCurveDerivativeX(F);
+                if (Math.abs(fe) < 1e-6) break;
+                F -= te / fe;
+              }
+              var pe = 0, Fe = 1;
+              for (F = R, W = 0; W < 20 && (te = this.sampleCurveX(F), !(Math.abs(te - R) < S)); W++) R > te ? pe = F : Fe = F, F = 0.5 * (Fe - pe) + pe;
+              return F;
+            }, solve: function(R, S) {
+              return this.sampleCurveY(this.solveCurveX(R, S));
+            } };
+            var _o = ya($n);
+            function No(R, S, F) {
+              return R + F * (S - R);
+            }
+            function po(R, S, F) {
+              return R.map((W, te) => No(W, S[te], F));
+            }
+            let Lo = { number: No, color: function(R, S, F, W = "rgb") {
+              switch (W) {
+                case "rgb": {
+                  let [te, fe, pe, Fe] = po(R.rgb, S.rgb, F);
+                  return new nr(te, fe, pe, Fe, false);
+                }
+                case "hcl": {
+                  let [te, fe, pe, Fe] = R.hcl, [Ke, ct, Lt, Jt] = S.hcl, cr, mr;
+                  if (isNaN(te) || isNaN(Ke)) isNaN(te) ? isNaN(Ke) ? cr = NaN : (cr = Ke, pe !== 1 && pe !== 0 || (mr = ct)) : (cr = te, Lt !== 1 && Lt !== 0 || (mr = fe));
+                  else {
+                    let vn = Ke - te;
+                    Ke > te && vn > 180 ? vn -= 360 : Ke < te && te - Ke > 180 && (vn += 360), cr = te + F * vn;
+                  }
+                  let [Pr, zr, ui, yi] = function([vn, zi, un, Tn]) {
+                    return vn = isNaN(vn) ? 0 : vn * pi, On([un, Math.cos(vn) * zi, Math.sin(vn) * zi, Tn]);
+                  }([cr, mr != null ? mr : No(fe, ct, F), No(pe, Lt, F), No(Fe, Jt, F)]);
+                  return new nr(Pr, zr, ui, yi, false);
+                }
+                case "lab": {
+                  let [te, fe, pe, Fe] = On(po(R.lab, S.lab, F));
+                  return new nr(te, fe, pe, Fe, false);
+                }
+              }
+            }, array: po, padding: function(R, S, F) {
+              return new Qr(po(R.values, S.values, F));
+            }, variableAnchorOffsetCollection: function(R, S, F) {
+              let W = R.values, te = S.values;
+              if (W.length !== te.length) throw new ma(`Cannot interpolate values of different length. from: ${R.toString()}, to: ${S.toString()}`);
+              let fe = [];
+              for (let pe = 0; pe < W.length; pe += 2) {
+                if (W[pe] !== te[pe]) throw new ma(`Cannot interpolate values containing mismatched anchors. from[${pe}]: ${W[pe]}, to[${pe}]: ${te[pe]}`);
+                fe.push(W[pe]);
+                let [Fe, Ke] = W[pe + 1], [ct, Lt] = te[pe + 1];
+                fe.push([No(Fe, ct, F), No(Ke, Lt, F)]);
+              }
+              return new $i(fe);
+            } };
+            class ko {
+              constructor(S, F, W, te, fe) {
+                this.type = S, this.operator = F, this.interpolation = W, this.input = te, this.labels = [], this.outputs = [];
+                for (let [pe, Fe] of fe) this.labels.push(pe), this.outputs.push(Fe);
+              }
+              static interpolationFactor(S, F, W, te) {
+                let fe = 0;
+                if (S.name === "exponential") fe = Ds(F, S.base, W, te);
+                else if (S.name === "linear") fe = Ds(F, 1, W, te);
+                else if (S.name === "cubic-bezier") {
+                  let pe = S.controlPoints;
+                  fe = new _o(pe[0], pe[1], pe[2], pe[3]).solve(Ds(F, 1, W, te));
+                }
+                return fe;
+              }
+              static parse(S, F) {
+                let [W, te, fe, ...pe] = S;
+                if (!Array.isArray(te) || te.length === 0) return F.error("Expected an interpolation type expression.", 1);
+                if (te[0] === "linear") te = { name: "linear" };
+                else if (te[0] === "exponential") {
+                  let ct = te[1];
+                  if (typeof ct != "number") return F.error("Exponential interpolation requires a numeric base.", 1, 1);
+                  te = { name: "exponential", base: ct };
+                } else {
+                  if (te[0] !== "cubic-bezier") return F.error(`Unknown interpolation type ${String(te[0])}`, 1, 0);
+                  {
+                    let ct = te.slice(1);
+                    if (ct.length !== 4 || ct.some((Lt) => typeof Lt != "number" || Lt < 0 || Lt > 1)) return F.error("Cubic bezier interpolation requires four numeric arguments with values between 0 and 1.", 1);
+                    te = { name: "cubic-bezier", controlPoints: ct };
+                  }
+                }
+                if (S.length - 1 < 4) return F.error(`Expected at least 4 arguments, but found only ${S.length - 1}.`);
+                if ((S.length - 1) % 2 != 0) return F.error("Expected an even number of arguments.");
+                if (fe = F.parse(fe, 2, _t), !fe) return null;
+                let Fe = [], Ke = null;
+                W === "interpolate-hcl" || W === "interpolate-lab" ? Ke = er : F.expectedType && F.expectedType.kind !== "value" && (Ke = F.expectedType);
+                for (let ct = 0; ct < pe.length; ct += 2) {
+                  let Lt = pe[ct], Jt = pe[ct + 1], cr = ct + 3, mr = ct + 4;
+                  if (typeof Lt != "number") return F.error('Input/output pairs for "interpolate" expressions must be defined using literal numeric values (not computed expressions) for the input values.', cr);
+                  if (Fe.length && Fe[Fe.length - 1][0] >= Lt) return F.error('Input/output pairs for "interpolate" expressions must be arranged with input values in strictly ascending order.', cr);
+                  let Pr = F.parse(Jt, mr, Ke);
+                  if (!Pr) return null;
+                  Ke = Ke || Pr.type, Fe.push([Lt, Pr]);
+                }
+                return xe(Ke, _t) || xe(Ke, er) || xe(Ke, Br) || xe(Ke, dt) || xe(Ke, Ge(_t)) ? new ko(Ke, W, te, fe, Fe) : F.error(`Type ${Je(Ke)} is not interpolatable.`);
+              }
+              evaluate(S) {
+                let F = this.labels, W = this.outputs;
+                if (F.length === 1) return W[0].evaluate(S);
+                let te = this.input.evaluate(S);
+                if (te <= F[0]) return W[0].evaluate(S);
+                let fe = F.length;
+                if (te >= F[fe - 1]) return W[fe - 1].evaluate(S);
+                let pe = Li(F, te), Fe = ko.interpolationFactor(this.interpolation, te, F[pe], F[pe + 1]), Ke = W[pe].evaluate(S), ct = W[pe + 1].evaluate(S);
+                switch (this.operator) {
+                  case "interpolate":
+                    return Lo[this.type.kind](Ke, ct, Fe);
+                  case "interpolate-hcl":
+                    return Lo.color(Ke, ct, Fe, "hcl");
+                  case "interpolate-lab":
+                    return Lo.color(Ke, ct, Fe, "lab");
+                }
+              }
+              eachChild(S) {
+                S(this.input);
+                for (let F of this.outputs) S(F);
+              }
+              outputDefined() {
+                return this.outputs.every((S) => S.outputDefined());
+              }
+            }
+            function Ds(R, S, F, W) {
+              let te = W - F, fe = R - F;
+              return te === 0 ? 0 : S === 1 ? fe / te : (Math.pow(S, fe) - 1) / (Math.pow(S, te) - 1);
+            }
+            class Fs {
+              constructor(S, F) {
+                this.type = S, this.args = F;
+              }
+              static parse(S, F) {
+                if (S.length < 2) return F.error("Expectected at least one argument.");
+                let W = null, te = F.expectedType;
+                te && te.kind !== "value" && (W = te);
+                let fe = [];
+                for (let Fe of S.slice(1)) {
+                  let Ke = F.parse(Fe, 1 + fe.length, W, void 0, { typeAnnotation: "omit" });
+                  if (!Ke) return null;
+                  W = W || Ke.type, fe.push(Ke);
+                }
+                if (!W) throw new Error("No output type");
+                let pe = te && fe.some((Fe) => tt(te, Fe.type));
+                return new Fs(pe ? wr : W, fe);
+              }
+              evaluate(S) {
+                let F, W = null, te = 0;
+                for (let fe of this.args) if (te++, W = fe.evaluate(S), W && W instanceof tn && !W.available && (F || (F = W.name), W = null, te === this.args.length && (W = F)), W !== null) break;
+                return W;
+              }
+              eachChild(S) {
+                this.args.forEach(S);
+              }
+              outputDefined() {
+                return this.args.every((S) => S.outputDefined());
+              }
+            }
+            function ll(R, S) {
+              return R === "==" || R === "!=" ? S.kind === "boolean" || S.kind === "string" || S.kind === "number" || S.kind === "null" || S.kind === "value" : S.kind === "string" || S.kind === "number" || S.kind === "value";
+            }
+            function ul(R, S, F, W) {
+              return W.compare(S, F) === 0;
+            }
+            function zl(R, S, F) {
+              let W = R !== "==" && R !== "!=";
+              return class hje {
+                constructor(fe, pe, Fe) {
+                  this.type = mt, this.lhs = fe, this.rhs = pe, this.collator = Fe, this.hasUntypedArgument = fe.type.kind === "value" || pe.type.kind === "value";
+                }
+                static parse(fe, pe) {
+                  if (fe.length !== 3 && fe.length !== 4) return pe.error("Expected two or three arguments.");
+                  let Fe = fe[0], Ke = pe.parse(fe[1], 1, wr);
+                  if (!Ke) return null;
+                  if (!ll(Fe, Ke.type)) return pe.concat(1).error(`"${Fe}" comparisons are not supported for type '${Je(Ke.type)}'.`);
+                  let ct = pe.parse(fe[2], 2, wr);
+                  if (!ct) return null;
+                  if (!ll(Fe, ct.type)) return pe.concat(2).error(`"${Fe}" comparisons are not supported for type '${Je(ct.type)}'.`);
+                  if (Ke.type.kind !== ct.type.kind && Ke.type.kind !== "value" && ct.type.kind !== "value") return pe.error(`Cannot compare types '${Je(Ke.type)}' and '${Je(ct.type)}'.`);
+                  W && (Ke.type.kind === "value" && ct.type.kind !== "value" ? Ke = new Fa(ct.type, [Ke]) : Ke.type.kind !== "value" && ct.type.kind === "value" && (ct = new Fa(Ke.type, [ct])));
+                  let Lt = null;
+                  if (fe.length === 4) {
+                    if (Ke.type.kind !== "string" && ct.type.kind !== "string" && Ke.type.kind !== "value" && ct.type.kind !== "value") return pe.error("Cannot use collator to compare non-string types.");
+                    if (Lt = pe.parse(fe[3], 3, Lr), !Lt) return null;
+                  }
+                  return new hje(Ke, ct, Lt);
+                }
+                evaluate(fe) {
+                  let pe = this.lhs.evaluate(fe), Fe = this.rhs.evaluate(fe);
+                  if (W && this.hasUntypedArgument) {
+                    let Ke = Sn(pe), ct = Sn(Fe);
+                    if (Ke.kind !== ct.kind || Ke.kind !== "string" && Ke.kind !== "number") throw new ma(`Expected arguments for "${R}" to be (string, string) or (number, number), but found (${Ke.kind}, ${ct.kind}) instead.`);
+                  }
+                  if (this.collator && !W && this.hasUntypedArgument) {
+                    let Ke = Sn(pe), ct = Sn(Fe);
+                    if (Ke.kind !== "string" || ct.kind !== "string") return S(fe, pe, Fe);
+                  }
+                  return this.collator ? F(fe, pe, Fe, this.collator.evaluate(fe)) : S(fe, pe, Fe);
+                }
+                eachChild(fe) {
+                  fe(this.lhs), fe(this.rhs), this.collator && fe(this.collator);
+                }
+                outputDefined() {
+                  return true;
+                }
+              };
+            }
+            let us = zl("==", function(R, S, F) {
+              return S === F;
+            }, ul), il = zl("!=", function(R, S, F) {
+              return S !== F;
+            }, function(R, S, F, W) {
+              return !ul(0, S, F, W);
+            }), As = zl("<", function(R, S, F) {
+              return S < F;
+            }, function(R, S, F, W) {
+              return W.compare(S, F) < 0;
+            }), cl = zl(">", function(R, S, F) {
+              return S > F;
+            }, function(R, S, F, W) {
+              return W.compare(S, F) > 0;
+            }), Ks = zl("<=", function(R, S, F) {
+              return S <= F;
+            }, function(R, S, F, W) {
+              return W.compare(S, F) <= 0;
+            }), zs = zl(">=", function(R, S, F) {
+              return S >= F;
+            }, function(R, S, F, W) {
+              return W.compare(S, F) >= 0;
+            });
+            class Io {
+              constructor(S, F, W) {
+                this.type = Lr, this.locale = W, this.caseSensitive = S, this.diacriticSensitive = F;
+              }
+              static parse(S, F) {
+                if (S.length !== 2) return F.error("Expected one argument.");
+                let W = S[1];
+                if (typeof W != "object" || Array.isArray(W)) return F.error("Collator options argument must be an object.");
+                let te = F.parse(W["case-sensitive"] !== void 0 && W["case-sensitive"], 1, mt);
+                if (!te) return null;
+                let fe = F.parse(W["diacritic-sensitive"] !== void 0 && W["diacritic-sensitive"], 1, mt);
+                if (!fe) return null;
+                let pe = null;
+                return W.locale && (pe = F.parse(W.locale, 1, It), !pe) ? null : new Io(te, fe, pe);
+              }
+              evaluate(S) {
+                return new Er(this.caseSensitive.evaluate(S), this.diacriticSensitive.evaluate(S), this.locale ? this.locale.evaluate(S) : null);
+              }
+              eachChild(S) {
+                S(this.caseSensitive), S(this.diacriticSensitive), this.locale && S(this.locale);
+              }
+              outputDefined() {
+                return false;
+              }
+            }
+            class ls {
+              constructor(S, F, W, te, fe) {
+                this.type = It, this.number = S, this.locale = F, this.currency = W, this.minFractionDigits = te, this.maxFractionDigits = fe;
+              }
+              static parse(S, F) {
+                if (S.length !== 3) return F.error("Expected two arguments.");
+                let W = F.parse(S[1], 1, _t);
+                if (!W) return null;
+                let te = S[2];
+                if (typeof te != "object" || Array.isArray(te)) return F.error("NumberFormat options argument must be an object.");
+                let fe = null;
+                if (te.locale && (fe = F.parse(te.locale, 1, It), !fe)) return null;
+                let pe = null;
+                if (te.currency && (pe = F.parse(te.currency, 1, It), !pe)) return null;
+                let Fe = null;
+                if (te["min-fraction-digits"] && (Fe = F.parse(te["min-fraction-digits"], 1, _t), !Fe)) return null;
+                let Ke = null;
+                return te["max-fraction-digits"] && (Ke = F.parse(te["max-fraction-digits"], 1, _t), !Ke) ? null : new ls(W, fe, pe, Fe, Ke);
+              }
+              evaluate(S) {
+                return new Intl.NumberFormat(this.locale ? this.locale.evaluate(S) : [], { style: this.currency ? "currency" : "decimal", currency: this.currency ? this.currency.evaluate(S) : void 0, minimumFractionDigits: this.minFractionDigits ? this.minFractionDigits.evaluate(S) : void 0, maximumFractionDigits: this.maxFractionDigits ? this.maxFractionDigits.evaluate(S) : void 0 }).format(this.number.evaluate(S));
+              }
+              eachChild(S) {
+                S(this.number), this.locale && S(this.locale), this.currency && S(this.currency), this.minFractionDigits && S(this.minFractionDigits), this.maxFractionDigits && S(this.maxFractionDigits);
+              }
+              outputDefined() {
+                return false;
+              }
+            }
+            class Yl {
+              constructor(S) {
+                this.type = ti, this.sections = S;
+              }
+              static parse(S, F) {
+                if (S.length < 2) return F.error("Expected at least one argument.");
+                let W = S[1];
+                if (!Array.isArray(W) && typeof W == "object") return F.error("First argument must be an image or text section.");
+                let te = [], fe = false;
+                for (let pe = 1; pe <= S.length - 1; ++pe) {
+                  let Fe = S[pe];
+                  if (fe && typeof Fe == "object" && !Array.isArray(Fe)) {
+                    fe = false;
+                    let Ke = null;
+                    if (Fe["font-scale"] && (Ke = F.parse(Fe["font-scale"], 1, _t), !Ke)) return null;
+                    let ct = null;
+                    if (Fe["text-font"] && (ct = F.parse(Fe["text-font"], 1, Ge(It)), !ct)) return null;
+                    let Lt = null;
+                    if (Fe["text-color"] && (Lt = F.parse(Fe["text-color"], 1, er), !Lt)) return null;
+                    let Jt = te[te.length - 1];
+                    Jt.scale = Ke, Jt.font = ct, Jt.textColor = Lt;
+                  } else {
+                    let Ke = F.parse(S[pe], 1, wr);
+                    if (!Ke) return null;
+                    let ct = Ke.type.kind;
+                    if (ct !== "string" && ct !== "value" && ct !== "null" && ct !== "resolvedImage") return F.error("Formatted text type must be 'string', 'value', 'image' or 'null'.");
+                    fe = true, te.push({ content: Ke, scale: null, font: null, textColor: null });
+                  }
+                }
+                return new Yl(te);
+              }
+              evaluate(S) {
+                return new ri(this.sections.map((F) => {
+                  let W = F.content.evaluate(S);
+                  return Sn(W) === Vr ? new Xr("", W, null, null, null) : new Xr(Ba(W), null, F.scale ? F.scale.evaluate(S) : null, F.font ? F.font.evaluate(S).join(",") : null, F.textColor ? F.textColor.evaluate(S) : null);
+                }));
+              }
+              eachChild(S) {
+                for (let F of this.sections) S(F.content), F.scale && S(F.scale), F.font && S(F.font), F.textColor && S(F.textColor);
+              }
+              outputDefined() {
+                return false;
+              }
+            }
+            class Su {
+              constructor(S) {
+                this.type = Vr, this.input = S;
+              }
+              static parse(S, F) {
+                if (S.length !== 2) return F.error("Expected two arguments.");
+                let W = F.parse(S[1], 1, It);
+                return W ? new Su(W) : F.error("No image name provided.");
+              }
+              evaluate(S) {
+                let F = this.input.evaluate(S), W = tn.fromString(F);
+                return W && S.availableImages && (W.available = S.availableImages.indexOf(F) > -1), W;
+              }
+              eachChild(S) {
+                S(this.input);
+              }
+              outputDefined() {
+                return false;
+              }
+            }
+            class nc {
+              constructor(S) {
+                this.type = _t, this.input = S;
+              }
+              static parse(S, F) {
+                if (S.length !== 2) return F.error(`Expected 1 argument, but found ${S.length - 1} instead.`);
+                let W = F.parse(S[1], 1);
+                return W ? W.type.kind !== "array" && W.type.kind !== "string" && W.type.kind !== "value" ? F.error(`Expected argument of type string or array, but found ${Je(W.type)} instead.`) : new nc(W) : null;
+              }
+              evaluate(S) {
+                let F = this.input.evaluate(S);
+                if (typeof F == "string") return [...F].length;
+                if (Array.isArray(F)) return F.length;
+                throw new ma(`Expected value to be of type string or array, but found ${Je(Sn(F))} instead.`);
+              }
+              eachChild(S) {
+                S(this.input);
+              }
+              outputDefined() {
+                return false;
+              }
+            }
+            let bs = 8192;
+            function Rn(R, S) {
+              let F = (180 + R[0]) / 360, W = (180 - 180 / Math.PI * Math.log(Math.tan(Math.PI / 4 + R[1] * Math.PI / 360))) / 360, te = Math.pow(2, S.z);
+              return [Math.round(F * te * bs), Math.round(W * te * bs)];
+            }
+            function _a(R, S) {
+              let F = Math.pow(2, S.z);
+              return [(te = (R[0] / bs + S.x) / F, 360 * te - 180), (W = (R[1] / bs + S.y) / F, 360 / Math.PI * Math.atan(Math.exp((180 - 360 * W) * Math.PI / 180)) - 90)];
+              var W, te;
+            }
+            function Vu(R, S) {
+              R[0] = Math.min(R[0], S[0]), R[1] = Math.min(R[1], S[1]), R[2] = Math.max(R[2], S[0]), R[3] = Math.max(R[3], S[1]);
+            }
+            function Ol(R, S) {
+              return !(R[0] <= S[0] || R[2] >= S[2] || R[1] <= S[1] || R[3] >= S[3]);
+            }
+            function xo(R, S, F) {
+              let W = R[0] - S[0], te = R[1] - S[1], fe = R[0] - F[0], pe = R[1] - F[1];
+              return W * pe - fe * te == 0 && W * fe <= 0 && te * pe <= 0;
+            }
+            function Kl(R, S, F, W) {
+              return (te = [W[0] - F[0], W[1] - F[1]])[0] * (fe = [S[0] - R[0], S[1] - R[1]])[1] - te[1] * fe[0] != 0 && !(!qo(R, S, F, W) || !qo(F, W, R, S));
+              var te, fe;
+            }
+            function Ns(R, S, F) {
+              for (let W of F) for (let te = 0; te < W.length - 1; ++te) if (Kl(R, S, W[te], W[te + 1])) return true;
+              return false;
+            }
+            function Hl(R, S, F = false) {
+              let W = false;
+              for (let Fe of S) for (let Ke = 0; Ke < Fe.length - 1; Ke++) {
+                if (xo(R, Fe[Ke], Fe[Ke + 1])) return F;
+                (fe = Fe[Ke])[1] > (te = R)[1] != (pe = Fe[Ke + 1])[1] > te[1] && te[0] < (pe[0] - fe[0]) * (te[1] - fe[1]) / (pe[1] - fe[1]) + fe[0] && (W = !W);
+              }
+              var te, fe, pe;
+              return W;
+            }
+            function ac(R, S) {
+              for (let F of S) if (Hl(R, F)) return true;
+              return false;
+            }
+            function aa(R, S) {
+              for (let F of R) if (!Hl(F, S)) return false;
+              for (let F = 0; F < R.length - 1; ++F) if (Ns(R[F], R[F + 1], S)) return false;
+              return true;
+            }
+            function Oo(R, S) {
+              for (let F of S) if (aa(R, F)) return true;
+              return false;
+            }
+            function qo(R, S, F, W) {
+              let te = W[0] - F[0], fe = W[1] - F[1], pe = (R[0] - F[0]) * fe - te * (R[1] - F[1]), Fe = (S[0] - F[0]) * fe - te * (S[1] - F[1]);
+              return pe > 0 && Fe < 0 || pe < 0 && Fe > 0;
+            }
+            function ql(R, S, F) {
+              let W = [];
+              for (let te = 0; te < R.length; te++) {
+                let fe = [];
+                for (let pe = 0; pe < R[te].length; pe++) {
+                  let Fe = Rn(R[te][pe], F);
+                  Vu(S, Fe), fe.push(Fe);
+                }
+                W.push(fe);
+              }
+              return W;
+            }
+            function Pc(R, S, F) {
+              let W = [];
+              for (let te = 0; te < R.length; te++) {
+                let fe = ql(R[te], S, F);
+                W.push(fe);
+              }
+              return W;
+            }
+            function Do(R, S, F, W) {
+              if (R[0] < F[0] || R[0] > F[2]) {
+                let te = 0.5 * W, fe = R[0] - F[0] > te ? -W : F[0] - R[0] > te ? W : 0;
+                fe === 0 && (fe = R[0] - F[2] > te ? -W : F[2] - R[0] > te ? W : 0), R[0] += fe;
+              }
+              Vu(S, R);
+            }
+            function rf(R, S, F, W) {
+              let te = Math.pow(2, W.z) * bs, fe = [W.x * bs, W.y * bs], pe = [];
+              for (let Fe of R) for (let Ke of Fe) {
+                let ct = [Ke.x + fe[0], Ke.y + fe[1]];
+                Do(ct, S, F, te), pe.push(ct);
+              }
+              return pe;
+            }
+            function Vf(R, S, F, W) {
+              let te = Math.pow(2, W.z) * bs, fe = [W.x * bs, W.y * bs], pe = [];
+              for (let Ke of R) {
+                let ct = [];
+                for (let Lt of Ke) {
+                  let Jt = [Lt.x + fe[0], Lt.y + fe[1]];
+                  Vu(S, Jt), ct.push(Jt);
+                }
+                pe.push(ct);
+              }
+              if (S[2] - S[0] <= te / 2) {
+                (Fe = S)[0] = Fe[1] = 1 / 0, Fe[2] = Fe[3] = -1 / 0;
+                for (let Ke of pe) for (let ct of Ke) Do(ct, S, F, te);
+              }
+              var Fe;
+              return pe;
+            }
+            class pl {
+              constructor(S, F) {
+                this.type = mt, this.geojson = S, this.geometries = F;
+              }
+              static parse(S, F) {
+                if (S.length !== 2) return F.error(`'within' expression requires exactly one argument, but found ${S.length - 1} instead.`);
+                if (yn(S[1])) {
+                  let W = S[1];
+                  if (W.type === "FeatureCollection") {
+                    let te = [];
+                    for (let fe of W.features) {
+                      let { type: pe, coordinates: Fe } = fe.geometry;
+                      pe === "Polygon" && te.push(Fe), pe === "MultiPolygon" && te.push(...Fe);
+                    }
+                    if (te.length) return new pl(W, { type: "MultiPolygon", coordinates: te });
+                  } else if (W.type === "Feature") {
+                    let te = W.geometry.type;
+                    if (te === "Polygon" || te === "MultiPolygon") return new pl(W, W.geometry);
+                  } else if (W.type === "Polygon" || W.type === "MultiPolygon") return new pl(W, W);
+                }
+                return F.error("'within' expression requires valid geojson object that contains polygon geometry type.");
+              }
+              evaluate(S) {
+                if (S.geometry() != null && S.canonicalID() != null) {
+                  if (S.geometryType() === "Point") return function(F, W) {
+                    let te = [1 / 0, 1 / 0, -1 / 0, -1 / 0], fe = [1 / 0, 1 / 0, -1 / 0, -1 / 0], pe = F.canonicalID();
+                    if (W.type === "Polygon") {
+                      let Fe = ql(W.coordinates, fe, pe), Ke = rf(F.geometry(), te, fe, pe);
+                      if (!Ol(te, fe)) return false;
+                      for (let ct of Ke) if (!Hl(ct, Fe)) return false;
+                    }
+                    if (W.type === "MultiPolygon") {
+                      let Fe = Pc(W.coordinates, fe, pe), Ke = rf(F.geometry(), te, fe, pe);
+                      if (!Ol(te, fe)) return false;
+                      for (let ct of Ke) if (!ac(ct, Fe)) return false;
+                    }
+                    return true;
+                  }(S, this.geometries);
+                  if (S.geometryType() === "LineString") return function(F, W) {
+                    let te = [1 / 0, 1 / 0, -1 / 0, -1 / 0], fe = [1 / 0, 1 / 0, -1 / 0, -1 / 0], pe = F.canonicalID();
+                    if (W.type === "Polygon") {
+                      let Fe = ql(W.coordinates, fe, pe), Ke = Vf(F.geometry(), te, fe, pe);
+                      if (!Ol(te, fe)) return false;
+                      for (let ct of Ke) if (!aa(ct, Fe)) return false;
+                    }
+                    if (W.type === "MultiPolygon") {
+                      let Fe = Pc(W.coordinates, fe, pe), Ke = Vf(F.geometry(), te, fe, pe);
+                      if (!Ol(te, fe)) return false;
+                      for (let ct of Ke) if (!Oo(ct, Fe)) return false;
+                    }
+                    return true;
+                  }(S, this.geometries);
+                }
+                return false;
+              }
+              eachChild() {
+              }
+              outputDefined() {
+                return true;
+              }
+            }
+            let Zc = class {
+              constructor(R = [], S = (F, W) => F < W ? -1 : F > W ? 1 : 0) {
+                if (this.data = R, this.length = this.data.length, this.compare = S, this.length > 0) for (let F = (this.length >> 1) - 1; F >= 0; F--) this._down(F);
+              }
+              push(R) {
+                this.data.push(R), this._up(this.length++);
+              }
+              pop() {
+                if (this.length === 0) return;
+                let R = this.data[0], S = this.data.pop();
+                return --this.length > 0 && (this.data[0] = S, this._down(0)), R;
+              }
+              peek() {
+                return this.data[0];
+              }
+              _up(R) {
+                let { data: S, compare: F } = this, W = S[R];
+                for (; R > 0; ) {
+                  let te = R - 1 >> 1, fe = S[te];
+                  if (F(W, fe) >= 0) break;
+                  S[R] = fe, R = te;
+                }
+                S[R] = W;
+              }
+              _down(R) {
+                let { data: S, compare: F } = this, W = this.length >> 1, te = S[R];
+                for (; R < W; ) {
+                  let fe = 1 + (R << 1), pe = fe + 1;
+                  if (pe < this.length && F(S[pe], S[fe]) < 0 && (fe = pe), F(S[fe], te) >= 0) break;
+                  S[R] = S[fe], R = fe;
+                }
+                S[R] = te;
+              }
+            };
+            function Jl(R, S, F, W, te) {
+              Os(R, S, F, W || R.length - 1, te || oc);
+            }
+            function Os(R, S, F, W, te) {
+              for (; W > F; ) {
+                if (W - F > 600) {
+                  var fe = W - F + 1, pe = S - F + 1, Fe = Math.log(fe), Ke = 0.5 * Math.exp(2 * Fe / 3), ct = 0.5 * Math.sqrt(Fe * Ke * (fe - Ke) / fe) * (pe - fe / 2 < 0 ? -1 : 1);
+                  Os(R, S, Math.max(F, Math.floor(S - pe * Ke / fe + ct)), Math.min(W, Math.floor(S + (fe - pe) * Ke / fe + ct)), te);
+                }
+                var Lt = R[S], Jt = F, cr = W;
+                for (yu(R, F, S), te(R[W], Lt) > 0 && yu(R, F, W); Jt < cr; ) {
+                  for (yu(R, Jt, cr), Jt++, cr--; te(R[Jt], Lt) < 0; ) Jt++;
+                  for (; te(R[cr], Lt) > 0; ) cr--;
+                }
+                te(R[F], Lt) === 0 ? yu(R, F, cr) : yu(R, ++cr, W), cr <= S && (F = cr + 1), S <= cr && (W = cr - 1);
+              }
+            }
+            function yu(R, S, F) {
+              var W = R[S];
+              R[S] = R[F], R[F] = W;
+            }
+            function oc(R, S) {
+              return R < S ? -1 : R > S ? 1 : 0;
+            }
+            function Cf(R, S) {
+              if (R.length <= 1) return [R];
+              let F = [], W, te;
+              for (let fe of R) {
+                let pe = jh(fe);
+                pe !== 0 && (fe.area = Math.abs(pe), te === void 0 && (te = pe < 0), te === pe < 0 ? (W && F.push(W), W = [fe]) : W.push(fe));
+              }
+              if (W && F.push(W), S > 1) for (let fe = 0; fe < F.length; fe++) F[fe].length <= S || (Jl(F[fe], S, 1, F[fe].length - 1, sc), F[fe] = F[fe].slice(0, S));
+              return F;
+            }
+            function sc(R, S) {
+              return S.area - R.area;
+            }
+            function jh(R) {
+              let S = 0;
+              for (let F, W, te = 0, fe = R.length, pe = fe - 1; te < fe; pe = te++) F = R[te], W = R[pe], S += (W.x - F.x) * (F.y + W.y);
+              return S;
+            }
+            let Lf = 1 / 298.257223563, cs = Lf * (2 - Lf), nf = Math.PI / 180;
+            class Gf {
+              constructor(S) {
+                let F = 6378.137 * nf * 1e3, W = Math.cos(S * nf), te = 1 / (1 - cs * (1 - W * W)), fe = Math.sqrt(te);
+                this.kx = F * fe * W, this.ky = F * fe * te * (1 - cs);
+              }
+              distance(S, F) {
+                let W = this.wrap(S[0] - F[0]) * this.kx, te = (S[1] - F[1]) * this.ky;
+                return Math.sqrt(W * W + te * te);
+              }
+              pointOnLine(S, F) {
+                let W, te, fe, pe, Fe = 1 / 0;
+                for (let Ke = 0; Ke < S.length - 1; Ke++) {
+                  let ct = S[Ke][0], Lt = S[Ke][1], Jt = this.wrap(S[Ke + 1][0] - ct) * this.kx, cr = (S[Ke + 1][1] - Lt) * this.ky, mr = 0;
+                  Jt === 0 && cr === 0 || (mr = (this.wrap(F[0] - ct) * this.kx * Jt + (F[1] - Lt) * this.ky * cr) / (Jt * Jt + cr * cr), mr > 1 ? (ct = S[Ke + 1][0], Lt = S[Ke + 1][1]) : mr > 0 && (ct += Jt / this.kx * mr, Lt += cr / this.ky * mr)), Jt = this.wrap(F[0] - ct) * this.kx, cr = (F[1] - Lt) * this.ky;
+                  let Pr = Jt * Jt + cr * cr;
+                  Pr < Fe && (Fe = Pr, W = ct, te = Lt, fe = Ke, pe = mr);
+                }
+                return { point: [W, te], index: fe, t: Math.max(0, Math.min(1, pe)) };
+              }
+              wrap(S) {
+                for (; S < -180; ) S += 360;
+                for (; S > 180; ) S -= 360;
+                return S;
+              }
+            }
+            function $l(R, S) {
+              return S[0] - R[0];
+            }
+            function fl(R) {
+              return R[1] - R[0] + 1;
+            }
+            function lc(R, S) {
+              return R[1] >= R[0] && R[1] < S;
+            }
+            function Fu(R, S) {
+              if (R[0] > R[1]) return [null, null];
+              let F = fl(R);
+              if (S) {
+                if (F === 2) return [R, null];
+                let te = Math.floor(F / 2);
+                return [[R[0], R[0] + te], [R[0] + te, R[1]]];
+              }
+              if (F === 1) return [R, null];
+              let W = Math.floor(F / 2) - 1;
+              return [[R[0], R[0] + W], [R[0] + W + 1, R[1]]];
+            }
+            function Es(R, S) {
+              if (!lc(S, R.length)) return [1 / 0, 1 / 0, -1 / 0, -1 / 0];
+              let F = [1 / 0, 1 / 0, -1 / 0, -1 / 0];
+              for (let W = S[0]; W <= S[1]; ++W) Vu(F, R[W]);
+              return F;
+            }
+            function Hs(R) {
+              let S = [1 / 0, 1 / 0, -1 / 0, -1 / 0];
+              for (let F of R) for (let W of F) Vu(S, W);
+              return S;
+            }
+            function Go(R) {
+              return R[0] !== -1 / 0 && R[1] !== -1 / 0 && R[2] !== 1 / 0 && R[3] !== 1 / 0;
+            }
+            function ps(R, S, F) {
+              if (!Go(R) || !Go(S)) return NaN;
+              let W = 0, te = 0;
+              return R[2] < S[0] && (W = S[0] - R[2]), R[0] > S[2] && (W = R[0] - S[2]), R[1] > S[3] && (te = R[1] - S[3]), R[3] < S[1] && (te = S[1] - R[3]), F.distance([0, 0], [W, te]);
+            }
+            function uc(R, S, F) {
+              let W = F.pointOnLine(S, R);
+              return F.distance(R, W.point);
+            }
+            function xl(R, S, F, W, te) {
+              let fe = Math.min(uc(R, [F, W], te), uc(S, [F, W], te)), pe = Math.min(uc(F, [R, S], te), uc(W, [R, S], te));
+              return Math.min(fe, pe);
+            }
+            function Gu(R, S, F, W, te) {
+              if (!lc(S, R.length) || !lc(W, F.length)) return 1 / 0;
+              let fe = 1 / 0;
+              for (let pe = S[0]; pe < S[1]; ++pe) {
+                let Fe = R[pe], Ke = R[pe + 1];
+                for (let ct = W[0]; ct < W[1]; ++ct) {
+                  let Lt = F[ct], Jt = F[ct + 1];
+                  if (Kl(Fe, Ke, Lt, Jt)) return 0;
+                  fe = Math.min(fe, xl(Fe, Ke, Lt, Jt, te));
+                }
+              }
+              return fe;
+            }
+            function qs(R, S, F, W, te) {
+              if (!lc(S, R.length) || !lc(W, F.length)) return NaN;
+              let fe = 1 / 0;
+              for (let pe = S[0]; pe <= S[1]; ++pe) for (let Fe = W[0]; Fe <= W[1]; ++Fe) if (fe = Math.min(fe, te.distance(R[pe], F[Fe])), fe === 0) return fe;
+              return fe;
+            }
+            function od(R, S, F) {
+              if (Hl(R, S, true)) return 0;
+              let W = 1 / 0;
+              for (let te of S) {
+                let fe = te[0], pe = te[te.length - 1];
+                if (fe !== pe && (W = Math.min(W, uc(R, [pe, fe], F)), W === 0)) return W;
+                let Fe = F.pointOnLine(te, R);
+                if (W = Math.min(W, F.distance(R, Fe.point)), W === 0) return W;
+              }
+              return W;
+            }
+            function Po(R, S, F, W) {
+              if (!lc(S, R.length)) return NaN;
+              for (let fe = S[0]; fe <= S[1]; ++fe) if (Hl(R[fe], F, true)) return 0;
+              let te = 1 / 0;
+              for (let fe = S[0]; fe < S[1]; ++fe) {
+                let pe = R[fe], Fe = R[fe + 1];
+                for (let Ke of F) for (let ct = 0, Lt = Ke.length, Jt = Lt - 1; ct < Lt; Jt = ct++) {
+                  let cr = Ke[Jt], mr = Ke[ct];
+                  if (Kl(pe, Fe, cr, mr)) return 0;
+                  te = Math.min(te, xl(pe, Fe, cr, mr, W));
+                }
+              }
+              return te;
+            }
+            function sd(R, S) {
+              for (let F of R) for (let W of F) if (Hl(W, S, true)) return true;
+              return false;
+            }
+            function Ko(R, S, F, W = 1 / 0) {
+              let te = Hs(R), fe = Hs(S);
+              if (W !== 1 / 0 && ps(te, fe, F) >= W) return W;
+              if (Ol(te, fe)) {
+                if (sd(R, S)) return 0;
+              } else if (sd(S, R)) return 0;
+              let pe = 1 / 0;
+              for (let Fe of R) for (let Ke = 0, ct = Fe.length, Lt = ct - 1; Ke < ct; Lt = Ke++) {
+                let Jt = Fe[Lt], cr = Fe[Ke];
+                for (let mr of S) for (let Pr = 0, zr = mr.length, ui = zr - 1; Pr < zr; ui = Pr++) {
+                  let yi = mr[ui], vn = mr[Pr];
+                  if (Kl(Jt, cr, yi, vn)) return 0;
+                  pe = Math.min(pe, xl(Jt, cr, yi, vn, F));
+                }
+              }
+              return pe;
+            }
+            function Pa(R, S, F, W, te, fe) {
+              if (!fe) return;
+              let pe = ps(Es(W, fe), te, F);
+              pe < S && R.push([pe, fe, [0, 0]]);
+            }
+            function af(R, S, F, W, te, fe, pe) {
+              if (!fe || !pe) return;
+              let Fe = ps(Es(W, fe), Es(te, pe), F);
+              Fe < S && R.push([Fe, fe, pe]);
+            }
+            function Hu(R, S, F, W, te = 1 / 0) {
+              let fe = Math.min(W.distance(R[0], F[0][0]), te);
+              if (fe === 0) return fe;
+              let pe = new Zc([[0, [0, R.length - 1], [0, 0]]], $l), Fe = Hs(F);
+              for (; pe.length > 0; ) {
+                let Ke = pe.pop();
+                if (Ke[0] >= fe) continue;
+                let ct = Ke[1], Lt = S ? 50 : 100;
+                if (fl(ct) <= Lt) {
+                  if (!lc(ct, R.length)) return NaN;
+                  if (S) {
+                    let Jt = Po(R, ct, F, W);
+                    if (isNaN(Jt) || Jt === 0) return Jt;
+                    fe = Math.min(fe, Jt);
+                  } else for (let Jt = ct[0]; Jt <= ct[1]; ++Jt) {
+                    let cr = od(R[Jt], F, W);
+                    if (fe = Math.min(fe, cr), fe === 0) return 0;
+                  }
+                } else {
+                  let Jt = Fu(ct, S);
+                  Pa(pe, fe, W, R, Fe, Jt[0]), Pa(pe, fe, W, R, Fe, Jt[1]);
+                }
+              }
+              return fe;
+            }
+            function bl(R, S, F, W, te, fe = 1 / 0) {
+              let pe = Math.min(fe, te.distance(R[0], F[0]));
+              if (pe === 0) return pe;
+              let Fe = new Zc([[0, [0, R.length - 1], [0, F.length - 1]]], $l);
+              for (; Fe.length > 0; ) {
+                let Ke = Fe.pop();
+                if (Ke[0] >= pe) continue;
+                let ct = Ke[1], Lt = Ke[2], Jt = S ? 50 : 100, cr = W ? 50 : 100;
+                if (fl(ct) <= Jt && fl(Lt) <= cr) {
+                  if (!lc(ct, R.length) && lc(Lt, F.length)) return NaN;
+                  let mr;
+                  if (S && W) mr = Gu(R, ct, F, Lt, te), pe = Math.min(pe, mr);
+                  else if (S && !W) {
+                    let Pr = R.slice(ct[0], ct[1] + 1);
+                    for (let zr = Lt[0]; zr <= Lt[1]; ++zr) if (mr = uc(F[zr], Pr, te), pe = Math.min(pe, mr), pe === 0) return pe;
+                  } else if (!S && W) {
+                    let Pr = F.slice(Lt[0], Lt[1] + 1);
+                    for (let zr = ct[0]; zr <= ct[1]; ++zr) if (mr = uc(R[zr], Pr, te), pe = Math.min(pe, mr), pe === 0) return pe;
+                  } else mr = qs(R, ct, F, Lt, te), pe = Math.min(pe, mr);
+                } else {
+                  let mr = Fu(ct, S), Pr = Fu(Lt, W);
+                  af(Fe, pe, te, R, F, mr[0], Pr[0]), af(Fe, pe, te, R, F, mr[0], Pr[1]), af(Fe, pe, te, R, F, mr[1], Pr[0]), af(Fe, pe, te, R, F, mr[1], Pr[1]);
+                }
+              }
+              return pe;
+            }
+            function Hf(R) {
+              return R.type === "MultiPolygon" ? R.coordinates.map((S) => ({ type: "Polygon", coordinates: S })) : R.type === "MultiLineString" ? R.coordinates.map((S) => ({ type: "LineString", coordinates: S })) : R.type === "MultiPoint" ? R.coordinates.map((S) => ({ type: "Point", coordinates: S })) : [R];
+            }
+            class Ic {
+              constructor(S, F) {
+                this.type = _t, this.geojson = S, this.geometries = F;
+              }
+              static parse(S, F) {
+                if (S.length !== 2) return F.error(`'distance' expression requires exactly one argument, but found ${S.length - 1} instead.`);
+                if (yn(S[1])) {
+                  let W = S[1];
+                  if (W.type === "FeatureCollection") return new Ic(W, W.features.map((te) => Hf(te.geometry)).flat());
+                  if (W.type === "Feature") return new Ic(W, Hf(W.geometry));
+                  if ("type" in W && "coordinates" in W) return new Ic(W, Hf(W));
+                }
+                return F.error("'distance' expression requires valid geojson object that contains polygon geometry type.");
+              }
+              evaluate(S) {
+                if (S.geometry() != null && S.canonicalID() != null) {
+                  if (S.geometryType() === "Point") return function(F, W) {
+                    let te = F.geometry(), fe = te.flat().map((Ke) => _a([Ke.x, Ke.y], F.canonical));
+                    if (te.length === 0) return NaN;
+                    let pe = new Gf(fe[0][1]), Fe = 1 / 0;
+                    for (let Ke of W) {
+                      switch (Ke.type) {
+                        case "Point":
+                          Fe = Math.min(Fe, bl(fe, false, [Ke.coordinates], false, pe, Fe));
+                          break;
+                        case "LineString":
+                          Fe = Math.min(Fe, bl(fe, false, Ke.coordinates, true, pe, Fe));
+                          break;
+                        case "Polygon":
+                          Fe = Math.min(Fe, Hu(fe, false, Ke.coordinates, pe, Fe));
+                      }
+                      if (Fe === 0) return Fe;
+                    }
+                    return Fe;
+                  }(S, this.geometries);
+                  if (S.geometryType() === "LineString") return function(F, W) {
+                    let te = F.geometry(), fe = te.flat().map((Ke) => _a([Ke.x, Ke.y], F.canonical));
+                    if (te.length === 0) return NaN;
+                    let pe = new Gf(fe[0][1]), Fe = 1 / 0;
+                    for (let Ke of W) {
+                      switch (Ke.type) {
+                        case "Point":
+                          Fe = Math.min(Fe, bl(fe, true, [Ke.coordinates], false, pe, Fe));
+                          break;
+                        case "LineString":
+                          Fe = Math.min(Fe, bl(fe, true, Ke.coordinates, true, pe, Fe));
+                          break;
+                        case "Polygon":
+                          Fe = Math.min(Fe, Hu(fe, true, Ke.coordinates, pe, Fe));
+                      }
+                      if (Fe === 0) return Fe;
+                    }
+                    return Fe;
+                  }(S, this.geometries);
+                  if (S.geometryType() === "Polygon") return function(F, W) {
+                    let te = F.geometry();
+                    if (te.length === 0 || te[0].length === 0) return NaN;
+                    let fe = Cf(te, 0).map((Ke) => Ke.map((ct) => ct.map((Lt) => _a([Lt.x, Lt.y], F.canonical)))), pe = new Gf(fe[0][0][0][1]), Fe = 1 / 0;
+                    for (let Ke of W) for (let ct of fe) {
+                      switch (Ke.type) {
+                        case "Point":
+                          Fe = Math.min(Fe, Hu([Ke.coordinates], false, ct, pe, Fe));
+                          break;
+                        case "LineString":
+                          Fe = Math.min(Fe, Hu(Ke.coordinates, true, ct, pe, Fe));
+                          break;
+                        case "Polygon":
+                          Fe = Math.min(Fe, Ko(ct, Ke.coordinates, pe, Fe));
+                      }
+                      if (Fe === 0) return Fe;
+                    }
+                    return Fe;
+                  }(S, this.geometries);
+                }
+                return NaN;
+              }
+              eachChild() {
+              }
+              outputDefined() {
+                return true;
+              }
+            }
+            let yf = { "==": us, "!=": il, ">": cl, "<": As, ">=": zs, "<=": Ks, array: Fa, at: kr, boolean: Fa, case: An, coalesce: Fs, collator: Io, format: Yl, image: Su, in: Jr, "index-of": vi, interpolate: ko, "interpolate-hcl": ko, "interpolate-lab": ko, length: nc, let: jn, literal: ua, match: hn, number: Fa, "number-format": ls, object: Fa, slice: Mn, step: _n, string: Fa, "to-boolean": da, "to-color": da, "to-number": da, "to-string": da, var: Mt, within: pl, distance: Ic };
+            class Bl {
+              constructor(S, F, W, te) {
+                this.name = S, this.type = F, this._evaluate = W, this.args = te;
+              }
+              evaluate(S) {
+                return this._evaluate(S, this.args);
+              }
+              eachChild(S) {
+                this.args.forEach(S);
+              }
+              outputDefined() {
+                return false;
+              }
+              static parse(S, F) {
+                let W = S[0], te = Bl.definitions[W];
+                if (!te) return F.error(`Unknown expression "${W}". If you wanted a literal array, use ["literal", [...]].`, 0);
+                let fe = Array.isArray(te) ? te[0] : te.type, pe = Array.isArray(te) ? [[te[1], te[2]]] : te.overloads, Fe = pe.filter(([ct]) => !Array.isArray(ct) || ct.length === S.length - 1), Ke = null;
+                for (let [ct, Lt] of Fe) {
+                  Ke = new vo(F.registry, eh, F.path, null, F.scope);
+                  let Jt = [], cr = false;
+                  for (let mr = 1; mr < S.length; mr++) {
+                    let Pr = S[mr], zr = Array.isArray(ct) ? ct[mr - 1] : ct.type, ui = Ke.parse(Pr, 1 + Jt.length, zr);
+                    if (!ui) {
+                      cr = true;
+                      break;
+                    }
+                    Jt.push(ui);
+                  }
+                  if (!cr) if (Array.isArray(ct) && ct.length !== Jt.length) Ke.error(`Expected ${ct.length} arguments, but found ${Jt.length} instead.`);
+                  else {
+                    for (let mr = 0; mr < Jt.length; mr++) {
+                      let Pr = Array.isArray(ct) ? ct[mr] : ct.type, zr = Jt[mr];
+                      Ke.concat(mr + 1).checkSubtype(Pr, zr.type);
+                    }
+                    if (Ke.errors.length === 0) return new Bl(W, fe, Lt, Jt);
+                  }
+                }
+                if (Fe.length === 1) F.errors.push(...Ke.errors);
+                else {
+                  let ct = (Fe.length ? Fe : pe).map(([Jt]) => {
+                    return cr = Jt, Array.isArray(cr) ? `(${cr.map(Je).join(", ")})` : `(${Je(cr.type)}...)`;
+                    var cr;
+                  }).join(" | "), Lt = [];
+                  for (let Jt = 1; Jt < S.length; Jt++) {
+                    let cr = F.parse(S[Jt], 1 + Lt.length);
+                    if (!cr) return null;
+                    Lt.push(Je(cr.type));
+                  }
+                  F.error(`Expected arguments of type ${ct}, but found (${Lt.join(", ")}) instead.`);
+                }
+                return null;
+              }
+              static register(S, F) {
+                Bl.definitions = F;
+                for (let W in F) S[W] = Bl;
+              }
+            }
+            function Ah(R, [S, F, W, te]) {
+              S = S.evaluate(R), F = F.evaluate(R), W = W.evaluate(R);
+              let fe = te ? te.evaluate(R) : 1, pe = fn(S, F, W, fe);
+              if (pe) throw new ma(pe);
+              return new nr(S / 255, F / 255, W / 255, fe, false);
+            }
+            function Qf(R, S) {
+              return R in S;
+            }
+            function _f(R, S) {
+              let F = S[R];
+              return F === void 0 ? null : F;
+            }
+            function Yc(R) {
+              return { type: R };
+            }
+            function eh(R) {
+              if (R instanceof Mt) return eh(R.boundExpression);
+              if (R instanceof Bl && R.name === "error" || R instanceof Io || R instanceof pl || R instanceof Ic) return false;
+              let S = R instanceof da || R instanceof Fa, F = true;
+              return R.eachChild((W) => {
+                F = S ? F && eh(W) : F && W instanceof ua;
+              }), !!F && th(R) && jf(R, ["zoom", "heatmap-density", "line-progress", "accumulated", "is-supported-script"]);
+            }
+            function th(R) {
+              if (R instanceof Bl && (R.name === "get" && R.args.length === 1 || R.name === "feature-state" || R.name === "has" && R.args.length === 1 || R.name === "properties" || R.name === "geometry-type" || R.name === "id" || /^filter-/.test(R.name)) || R instanceof pl || R instanceof Ic) return false;
+              let S = true;
+              return R.eachChild((F) => {
+                S && !th(F) && (S = false);
+              }), S;
+            }
+            function ju(R) {
+              if (R instanceof Bl && R.name === "feature-state") return false;
+              let S = true;
+              return R.eachChild((F) => {
+                S && !ju(F) && (S = false);
+              }), S;
+            }
+            function jf(R, S) {
+              if (R instanceof Bl && S.indexOf(R.name) >= 0) return false;
+              let F = true;
+              return R.eachChild((W) => {
+                F && !jf(W, S) && (F = false);
+              }), F;
+            }
+            function cc(R) {
+              return { result: "success", value: R };
+            }
+            function of(R) {
+              return { result: "error", value: R };
+            }
+            function Nl(R) {
+              return R["property-type"] === "data-driven" || R["property-type"] === "cross-faded-data-driven";
+            }
+            function Kc(R) {
+              return !!R.expression && R.expression.parameters.indexOf("zoom") > -1;
+            }
+            function Rc(R) {
+              return !!R.expression && R.expression.interpolated;
+            }
+            function gs(R) {
+              return R instanceof Number ? "number" : R instanceof String ? "string" : R instanceof Boolean ? "boolean" : Array.isArray(R) ? "array" : R === null ? "null" : typeof R;
+            }
+            function Wf(R) {
+              return typeof R == "object" && R !== null && !Array.isArray(R);
+            }
+            function Wh(R) {
+              return R;
+            }
+            function rh(R, S) {
+              let F = S.type === "color", W = R.stops && typeof R.stops[0][0] == "object", te = W || !(W || R.property !== void 0), fe = R.type || (Rc(S) ? "exponential" : "interval");
+              if (F || S.type === "padding") {
+                let Lt = F ? nr.parse : Qr.parse;
+                (R = $e({}, R)).stops && (R.stops = R.stops.map((Jt) => [Jt[0], Lt(Jt[1])])), R.default = Lt(R.default ? R.default : S.default);
+              }
+              if (R.colorSpace && (pe = R.colorSpace) !== "rgb" && pe !== "hcl" && pe !== "lab") throw new Error(`Unknown color space: "${R.colorSpace}"`);
+              var pe;
+              let Fe, Ke, ct;
+              if (fe === "exponential") Fe = ih;
+              else if (fe === "interval") Fe = Mu;
+              else if (fe === "categorical") {
+                Fe = Sh, Ke = /* @__PURE__ */ Object.create(null);
+                for (let Lt of R.stops) Ke[Lt[0]] = Lt[1];
+                ct = typeof R.stops[0][0];
+              } else {
+                if (fe !== "identity") throw new Error(`Unknown function type "${fe}"`);
+                Fe = js;
+              }
+              if (W) {
+                let Lt = {}, Jt = [];
+                for (let Pr = 0; Pr < R.stops.length; Pr++) {
+                  let zr = R.stops[Pr], ui = zr[0].zoom;
+                  Lt[ui] === void 0 && (Lt[ui] = { zoom: ui, type: R.type, property: R.property, default: R.default, stops: [] }, Jt.push(ui)), Lt[ui].stops.push([zr[0].value, zr[1]]);
+                }
+                let cr = [];
+                for (let Pr of Jt) cr.push([Lt[Pr].zoom, rh(Lt[Pr], S)]);
+                let mr = { name: "linear" };
+                return { kind: "composite", interpolationType: mr, interpolationFactor: ko.interpolationFactor.bind(void 0, mr), zoomStops: cr.map((Pr) => Pr[0]), evaluate: ({ zoom: Pr }, zr) => ih({ stops: cr, base: R.base }, S, Pr).evaluate(Pr, zr) };
+              }
+              if (te) {
+                let Lt = fe === "exponential" ? { name: "exponential", base: R.base !== void 0 ? R.base : 1 } : null;
+                return { kind: "camera", interpolationType: Lt, interpolationFactor: ko.interpolationFactor.bind(void 0, Lt), zoomStops: R.stops.map((Jt) => Jt[0]), evaluate: ({ zoom: Jt }) => Fe(R, S, Jt, Ke, ct) };
+              }
+              return { kind: "source", evaluate(Lt, Jt) {
+                let cr = Jt && Jt.properties ? Jt.properties[R.property] : void 0;
+                return cr === void 0 ? sf(R.default, S.default) : Fe(R, S, cr, Ke, ct);
+              } };
+            }
+            function sf(R, S, F) {
+              return R !== void 0 ? R : S !== void 0 ? S : F !== void 0 ? F : void 0;
+            }
+            function Sh(R, S, F, W, te) {
+              return sf(typeof F === te ? W[F] : void 0, R.default, S.default);
+            }
+            function Mu(R, S, F) {
+              if (gs(F) !== "number") return sf(R.default, S.default);
+              let W = R.stops.length;
+              if (W === 1 || F <= R.stops[0][0]) return R.stops[0][1];
+              if (F >= R.stops[W - 1][0]) return R.stops[W - 1][1];
+              let te = Li(R.stops.map((fe) => fe[0]), F);
+              return R.stops[te][1];
+            }
+            function ih(R, S, F) {
+              let W = R.base !== void 0 ? R.base : 1;
+              if (gs(F) !== "number") return sf(R.default, S.default);
+              let te = R.stops.length;
+              if (te === 1 || F <= R.stops[0][0]) return R.stops[0][1];
+              if (F >= R.stops[te - 1][0]) return R.stops[te - 1][1];
+              let fe = Li(R.stops.map((Lt) => Lt[0]), F), pe = function(Lt, Jt, cr, mr) {
+                let Pr = mr - cr, zr = Lt - cr;
+                return Pr === 0 ? 0 : Jt === 1 ? zr / Pr : (Math.pow(Jt, zr) - 1) / (Math.pow(Jt, Pr) - 1);
+              }(F, W, R.stops[fe][0], R.stops[fe + 1][0]), Fe = R.stops[fe][1], Ke = R.stops[fe + 1][1], ct = Lo[S.type] || Wh;
+              return typeof Fe.evaluate == "function" ? { evaluate(...Lt) {
+                let Jt = Fe.evaluate.apply(void 0, Lt), cr = Ke.evaluate.apply(void 0, Lt);
+                if (Jt !== void 0 && cr !== void 0) return ct(Jt, cr, pe, R.colorSpace);
+              } } : ct(Fe, Ke, pe, R.colorSpace);
+            }
+            function js(R, S, F) {
+              switch (S.type) {
+                case "color":
+                  F = nr.parse(F);
+                  break;
+                case "formatted":
+                  F = ri.fromString(F.toString());
+                  break;
+                case "resolvedImage":
+                  F = tn.fromString(F.toString());
+                  break;
+                case "padding":
+                  F = Qr.parse(F);
+                  break;
+                default:
+                  gs(F) === S.type || S.type === "enum" && S.values[F] || (F = void 0);
+              }
+              return sf(F, R.default, S.default);
+            }
+            Bl.register(yf, { error: [{ kind: "error" }, [It], (R, [S]) => {
+              throw new ma(S.evaluate(R));
+            }], typeof: [It, [wr], (R, [S]) => Je(Sn(S.evaluate(R)))], "to-rgba": [Ge(_t, 4), [er], (R, [S]) => {
+              let [F, W, te, fe] = S.evaluate(R).rgb;
+              return [255 * F, 255 * W, 255 * te, fe];
+            }], rgb: [er, [_t, _t, _t], Ah], rgba: [er, [_t, _t, _t, _t], Ah], has: { type: mt, overloads: [[[It], (R, [S]) => Qf(S.evaluate(R), R.properties())], [[It, lr], (R, [S, F]) => Qf(S.evaluate(R), F.evaluate(R))]] }, get: { type: wr, overloads: [[[It], (R, [S]) => _f(S.evaluate(R), R.properties())], [[It, lr], (R, [S, F]) => _f(S.evaluate(R), F.evaluate(R))]] }, "feature-state": [wr, [It], (R, [S]) => _f(S.evaluate(R), R.featureState || {})], properties: [lr, [], (R) => R.properties()], "geometry-type": [It, [], (R) => R.geometryType()], id: [wr, [], (R) => R.id()], zoom: [_t, [], (R) => R.globals.zoom], "heatmap-density": [_t, [], (R) => R.globals.heatmapDensity || 0], "line-progress": [_t, [], (R) => R.globals.lineProgress || 0], accumulated: [wr, [], (R) => R.globals.accumulated === void 0 ? null : R.globals.accumulated], "+": [_t, Yc(_t), (R, S) => {
+              let F = 0;
+              for (let W of S) F += W.evaluate(R);
+              return F;
+            }], "*": [_t, Yc(_t), (R, S) => {
+              let F = 1;
+              for (let W of S) F *= W.evaluate(R);
+              return F;
+            }], "-": { type: _t, overloads: [[[_t, _t], (R, [S, F]) => S.evaluate(R) - F.evaluate(R)], [[_t], (R, [S]) => -S.evaluate(R)]] }, "/": [_t, [_t, _t], (R, [S, F]) => S.evaluate(R) / F.evaluate(R)], "%": [_t, [_t, _t], (R, [S, F]) => S.evaluate(R) % F.evaluate(R)], ln2: [_t, [], () => Math.LN2], pi: [_t, [], () => Math.PI], e: [_t, [], () => Math.E], "^": [_t, [_t, _t], (R, [S, F]) => Math.pow(S.evaluate(R), F.evaluate(R))], sqrt: [_t, [_t], (R, [S]) => Math.sqrt(S.evaluate(R))], log10: [_t, [_t], (R, [S]) => Math.log(S.evaluate(R)) / Math.LN10], ln: [_t, [_t], (R, [S]) => Math.log(S.evaluate(R))], log2: [_t, [_t], (R, [S]) => Math.log(S.evaluate(R)) / Math.LN2], sin: [_t, [_t], (R, [S]) => Math.sin(S.evaluate(R))], cos: [_t, [_t], (R, [S]) => Math.cos(S.evaluate(R))], tan: [_t, [_t], (R, [S]) => Math.tan(S.evaluate(R))], asin: [_t, [_t], (R, [S]) => Math.asin(S.evaluate(R))], acos: [_t, [_t], (R, [S]) => Math.acos(S.evaluate(R))], atan: [_t, [_t], (R, [S]) => Math.atan(S.evaluate(R))], min: [_t, Yc(_t), (R, S) => Math.min(...S.map((F) => F.evaluate(R)))], max: [_t, Yc(_t), (R, S) => Math.max(...S.map((F) => F.evaluate(R)))], abs: [_t, [_t], (R, [S]) => Math.abs(S.evaluate(R))], round: [_t, [_t], (R, [S]) => {
+              let F = S.evaluate(R);
+              return F < 0 ? -Math.round(-F) : Math.round(F);
+            }], floor: [_t, [_t], (R, [S]) => Math.floor(S.evaluate(R))], ceil: [_t, [_t], (R, [S]) => Math.ceil(S.evaluate(R))], "filter-==": [mt, [It, wr], (R, [S, F]) => R.properties()[S.value] === F.value], "filter-id-==": [mt, [wr], (R, [S]) => R.id() === S.value], "filter-type-==": [mt, [It], (R, [S]) => R.geometryType() === S.value], "filter-<": [mt, [It, wr], (R, [S, F]) => {
+              let W = R.properties()[S.value], te = F.value;
+              return typeof W == typeof te && W < te;
+            }], "filter-id-<": [mt, [wr], (R, [S]) => {
+              let F = R.id(), W = S.value;
+              return typeof F == typeof W && F < W;
+            }], "filter->": [mt, [It, wr], (R, [S, F]) => {
+              let W = R.properties()[S.value], te = F.value;
+              return typeof W == typeof te && W > te;
+            }], "filter-id->": [mt, [wr], (R, [S]) => {
+              let F = R.id(), W = S.value;
+              return typeof F == typeof W && F > W;
+            }], "filter-<=": [mt, [It, wr], (R, [S, F]) => {
+              let W = R.properties()[S.value], te = F.value;
+              return typeof W == typeof te && W <= te;
+            }], "filter-id-<=": [mt, [wr], (R, [S]) => {
+              let F = R.id(), W = S.value;
+              return typeof F == typeof W && F <= W;
+            }], "filter->=": [mt, [It, wr], (R, [S, F]) => {
+              let W = R.properties()[S.value], te = F.value;
+              return typeof W == typeof te && W >= te;
+            }], "filter-id->=": [mt, [wr], (R, [S]) => {
+              let F = R.id(), W = S.value;
+              return typeof F == typeof W && F >= W;
+            }], "filter-has": [mt, [wr], (R, [S]) => S.value in R.properties()], "filter-has-id": [mt, [], (R) => R.id() !== null && R.id() !== void 0], "filter-type-in": [mt, [Ge(It)], (R, [S]) => S.value.indexOf(R.geometryType()) >= 0], "filter-id-in": [mt, [Ge(wr)], (R, [S]) => S.value.indexOf(R.id()) >= 0], "filter-in-small": [mt, [It, Ge(wr)], (R, [S, F]) => F.value.indexOf(R.properties()[S.value]) >= 0], "filter-in-large": [mt, [It, Ge(wr)], (R, [S, F]) => function(W, te, fe, pe) {
+              for (; fe <= pe; ) {
+                let Fe = fe + pe >> 1;
+                if (te[Fe] === W) return true;
+                te[Fe] > W ? pe = Fe - 1 : fe = Fe + 1;
+              }
+              return false;
+            }(R.properties()[S.value], F.value, 0, F.value.length - 1)], all: { type: mt, overloads: [[[mt, mt], (R, [S, F]) => S.evaluate(R) && F.evaluate(R)], [Yc(mt), (R, S) => {
+              for (let F of S) if (!F.evaluate(R)) return false;
+              return true;
+            }]] }, any: { type: mt, overloads: [[[mt, mt], (R, [S, F]) => S.evaluate(R) || F.evaluate(R)], [Yc(mt), (R, S) => {
+              for (let F of S) if (F.evaluate(R)) return true;
+              return false;
+            }]] }, "!": [mt, [mt], (R, [S]) => !S.evaluate(R)], "is-supported-script": [mt, [It], (R, [S]) => {
+              let F = R.globals && R.globals.isSupportedScript;
+              return !F || F(S.evaluate(R));
+            }], upcase: [It, [It], (R, [S]) => S.evaluate(R).toUpperCase()], downcase: [It, [It], (R, [S]) => S.evaluate(R).toLowerCase()], concat: [It, Yc(wr), (R, S) => S.map((F) => Ba(F.evaluate(R))).join("")], "resolved-locale": [It, [Lr], (R, [S]) => S.evaluate(R).resolvedLocale()] });
+            class Eu {
+              constructor(S, F) {
+                var W;
+                this.expression = S, this._warningHistory = {}, this._evaluator = new Ha(), this._defaultValue = F ? (W = F).type === "color" && Wf(W.default) ? new nr(0, 0, 0, 0) : W.type === "color" ? nr.parse(W.default) || null : W.type === "padding" ? Qr.parse(W.default) || null : W.type === "variableAnchorOffsetCollection" ? $i.parse(W.default) || null : W.default === void 0 ? null : W.default : null, this._enumValues = F && F.type === "enum" ? F.values : null;
+              }
+              evaluateWithoutErrorHandling(S, F, W, te, fe, pe) {
+                return this._evaluator.globals = S, this._evaluator.feature = F, this._evaluator.featureState = W, this._evaluator.canonical = te, this._evaluator.availableImages = fe || null, this._evaluator.formattedSection = pe, this.expression.evaluate(this._evaluator);
+              }
+              evaluate(S, F, W, te, fe, pe) {
+                this._evaluator.globals = S, this._evaluator.feature = F || null, this._evaluator.featureState = W || null, this._evaluator.canonical = te, this._evaluator.availableImages = fe || null, this._evaluator.formattedSection = pe || null;
+                try {
+                  let Fe = this.expression.evaluate(this._evaluator);
+                  if (Fe == null || typeof Fe == "number" && Fe != Fe) return this._defaultValue;
+                  if (this._enumValues && !(Fe in this._enumValues)) throw new ma(`Expected value to be one of ${Object.keys(this._enumValues).map((Ke) => JSON.stringify(Ke)).join(", ")}, but found ${JSON.stringify(Fe)} instead.`);
+                  return Fe;
+                } catch (Fe) {
+                  return this._warningHistory[Fe.message] || (this._warningHistory[Fe.message] = true, typeof console != "undefined" && console.warn(Fe.message)), this._defaultValue;
+                }
+              }
+            }
+            function Dc(R) {
+              return Array.isArray(R) && R.length > 0 && typeof R[0] == "string" && R[0] in yf;
+            }
+            function ks(R, S) {
+              let F = new vo(yf, eh, [], S ? function(te) {
+                let fe = { color: er, string: It, number: _t, enum: It, boolean: mt, formatted: ti, padding: Br, resolvedImage: Vr, variableAnchorOffsetCollection: dt };
+                return te.type === "array" ? Ge(fe[te.value] || wr, te.length) : fe[te.type];
+              }(S) : void 0), W = F.parse(R, void 0, void 0, void 0, S && S.type === "string" ? { typeAnnotation: "coerce" } : void 0);
+              return W ? cc(new Eu(W, S)) : of(F.errors);
+            }
+            class bc {
+              constructor(S, F) {
+                this.kind = S, this._styleExpression = F, this.isStateDependent = S !== "constant" && !ju(F.expression);
+              }
+              evaluateWithoutErrorHandling(S, F, W, te, fe, pe) {
+                return this._styleExpression.evaluateWithoutErrorHandling(S, F, W, te, fe, pe);
+              }
+              evaluate(S, F, W, te, fe, pe) {
+                return this._styleExpression.evaluate(S, F, W, te, fe, pe);
+              }
+            }
+            class hu {
+              constructor(S, F, W, te) {
+                this.kind = S, this.zoomStops = W, this._styleExpression = F, this.isStateDependent = S !== "camera" && !ju(F.expression), this.interpolationType = te;
+              }
+              evaluateWithoutErrorHandling(S, F, W, te, fe, pe) {
+                return this._styleExpression.evaluateWithoutErrorHandling(S, F, W, te, fe, pe);
+              }
+              evaluate(S, F, W, te, fe, pe) {
+                return this._styleExpression.evaluate(S, F, W, te, fe, pe);
+              }
+              interpolationFactor(S, F, W) {
+                return this.interpolationType ? ko.interpolationFactor(this.interpolationType, S, F, W) : 0;
+              }
+            }
+            function _u(R, S) {
+              let F = ks(R, S);
+              if (F.result === "error") return F;
+              let W = F.value.expression, te = th(W);
+              if (!te && !Nl(S)) return of([new St("", "data expressions not supported")]);
+              let fe = jf(W, ["zoom"]);
+              if (!fe && !Kc(S)) return of([new St("", "zoom expressions not supported")]);
+              let pe = nh(W);
+              return pe || fe ? pe instanceof St ? of([pe]) : pe instanceof ko && !Rc(S) ? of([new St("", '"interpolate" expressions cannot be used with this property')]) : cc(pe ? new hu(te ? "camera" : "composite", F.value, pe.labels, pe instanceof ko ? pe.interpolation : void 0) : new bc(te ? "constant" : "source", F.value)) : of([new St("", '"zoom" expression may only be used as input to a top-level "step" or "interpolate" expression.')]);
+            }
+            class nl {
+              constructor(S, F) {
+                this._parameters = S, this._specification = F, $e(this, rh(this._parameters, this._specification));
+              }
+              static deserialize(S) {
+                return new nl(S._parameters, S._specification);
+              }
+              static serialize(S) {
+                return { _parameters: S._parameters, _specification: S._specification };
+              }
+            }
+            function nh(R) {
+              let S = null;
+              if (R instanceof jn) S = nh(R.result);
+              else if (R instanceof Fs) {
+                for (let F of R.args) if (S = nh(F), S) break;
+              } else (R instanceof _n || R instanceof ko) && R.input instanceof Bl && R.input.name === "zoom" && (S = R);
+              return S instanceof St || R.eachChild((F) => {
+                let W = nh(F);
+                W instanceof St ? S = W : !S && W ? S = new St("", '"zoom" expression may only be used as input to a top-level "step" or "interpolate" expression.') : S && W && S !== W && (S = new St("", 'Only one zoom-based "step" or "interpolate" subexpression may be used in an expression.'));
+              }), S;
+            }
+            function Mh(R) {
+              if (R === true || R === false) return true;
+              if (!Array.isArray(R) || R.length === 0) return false;
+              switch (R[0]) {
+                case "has":
+                  return R.length >= 2 && R[1] !== "$id" && R[1] !== "$type";
+                case "in":
+                  return R.length >= 3 && (typeof R[1] != "string" || Array.isArray(R[2]));
+                case "!in":
+                case "!has":
+                case "none":
+                  return false;
+                case "==":
+                case "!=":
+                case ">":
+                case ">=":
+                case "<":
+                case "<=":
+                  return R.length !== 3 || Array.isArray(R[1]) || Array.isArray(R[2]);
+                case "any":
+                case "all":
+                  for (let S of R.slice(1)) if (!Mh(S) && typeof S != "boolean") return false;
+                  return true;
+                default:
+                  return true;
+              }
+            }
+            let zu = { type: "boolean", default: false, transition: false, "property-type": "data-driven", expression: { interpolated: false, parameters: ["zoom", "feature"] } };
+            function Fc(R) {
+              if (R == null) return { filter: () => true, needGeometry: false };
+              Mh(R) || (R = xf(R));
+              let S = ks(R, zu);
+              if (S.result === "error") throw new Error(S.value.map((F) => `${F.key}: ${F.message}`).join(", "));
+              return { filter: (F, W, te) => S.value.evaluate(F, W, {}, te), needGeometry: bd(R) };
+            }
+            function wc(R, S) {
+              return R < S ? -1 : R > S ? 1 : 0;
+            }
+            function bd(R) {
+              if (!Array.isArray(R)) return false;
+              if (R[0] === "within" || R[0] === "distance") return true;
+              for (let S = 1; S < R.length; S++) if (bd(R[S])) return true;
+              return false;
+            }
+            function xf(R) {
+              if (!R) return true;
+              let S = R[0];
+              return R.length <= 1 ? S !== "any" : S === "==" ? Pf(R[1], R[2], "==") : S === "!=" ? jl(Pf(R[1], R[2], "==")) : S === "<" || S === ">" || S === "<=" || S === ">=" ? Pf(R[1], R[2], S) : S === "any" ? (F = R.slice(1), ["any"].concat(F.map(xf))) : S === "all" ? ["all"].concat(R.slice(1).map(xf)) : S === "none" ? ["all"].concat(R.slice(1).map(xf).map(jl)) : S === "in" ? Ou(R[1], R.slice(2)) : S === "!in" ? jl(Ou(R[1], R.slice(2))) : S === "has" ? bf(R[1]) : S !== "!has" || jl(bf(R[1]));
+              var F;
+            }
+            function Pf(R, S, F) {
+              switch (R) {
+                case "$type":
+                  return [`filter-type-${F}`, S];
+                case "$id":
+                  return [`filter-id-${F}`, S];
+                default:
+                  return [`filter-${F}`, R, S];
+              }
+            }
+            function Ou(R, S) {
+              if (S.length === 0) return false;
+              switch (R) {
+                case "$type":
+                  return ["filter-type-in", ["literal", S]];
+                case "$id":
+                  return ["filter-id-in", ["literal", S]];
+                default:
+                  return S.length > 200 && !S.some((F) => typeof F != typeof S[0]) ? ["filter-in-large", R, ["literal", S.sort(wc)]] : ["filter-in-small", R, ["literal", S]];
+              }
+            }
+            function bf(R) {
+              switch (R) {
+                case "$type":
+                  return true;
+                case "$id":
+                  return ["filter-has-id"];
+                default:
+                  return ["filter-has", R];
+              }
+            }
+            function jl(R) {
+              return ["!", R];
+            }
+            function lf(R) {
+              let S = typeof R;
+              if (S === "number" || S === "boolean" || S === "string" || R == null) return JSON.stringify(R);
+              if (Array.isArray(R)) {
+                let te = "[";
+                for (let fe of R) te += `${lf(fe)},`;
+                return `${te}]`;
+              }
+              let F = Object.keys(R).sort(), W = "{";
+              for (let te = 0; te < F.length; te++) W += `${JSON.stringify(F[te])}:${lf(R[F[te]])},`;
+              return `${W}}`;
+            }
+            function Xh(R) {
+              let S = "";
+              for (let F of je) S += `/${lf(R[F])}`;
+              return S;
+            }
+            function If(R) {
+              let S = R.value;
+              return S ? [new fr(R.key, S, "constants have been deprecated as of v8")] : [];
+            }
+            function Cs(R) {
+              return R instanceof Number || R instanceof String || R instanceof Boolean ? R.valueOf() : R;
+            }
+            function du(R) {
+              if (Array.isArray(R)) return R.map(du);
+              if (R instanceof Object && !(R instanceof Number || R instanceof String || R instanceof Boolean)) {
+                let S = {};
+                for (let F in R) S[F] = du(R[F]);
+                return S;
+              }
+              return Cs(R);
+            }
+            function ku(R) {
+              let S = R.key, F = R.value, W = R.valueSpec || {}, te = R.objectElementValidators || {}, fe = R.style, pe = R.styleSpec, Fe = R.validateSpec, Ke = [], ct = gs(F);
+              if (ct !== "object") return [new fr(S, F, `object expected, ${ct} found`)];
+              for (let Lt in F) {
+                let Jt = Lt.split(".")[0], cr = W[Jt] || W["*"], mr;
+                if (te[Jt]) mr = te[Jt];
+                else if (W[Jt]) mr = Fe;
+                else if (te["*"]) mr = te["*"];
+                else {
+                  if (!W["*"]) {
+                    Ke.push(new fr(S, F[Lt], `unknown property "${Lt}"`));
+                    continue;
+                  }
+                  mr = Fe;
+                }
+                Ke = Ke.concat(mr({ key: (S && `${S}.`) + Lt, value: F[Lt], valueSpec: cr, style: fe, styleSpec: pe, object: F, objectKey: Lt, validateSpec: Fe }, F));
+              }
+              for (let Lt in W) te[Lt] || W[Lt].required && W[Lt].default === void 0 && F[Lt] === void 0 && Ke.push(new fr(S, F, `missing required property "${Lt}"`));
+              return Ke;
+            }
+            function Xf(R) {
+              let S = R.value, F = R.valueSpec, W = R.style, te = R.styleSpec, fe = R.key, pe = R.arrayElementValidator || R.validateSpec;
+              if (gs(S) !== "array") return [new fr(fe, S, `array expected, ${gs(S)} found`)];
+              if (F.length && S.length !== F.length) return [new fr(fe, S, `array length ${F.length} expected, length ${S.length} found`)];
+              if (F["min-length"] && S.length < F["min-length"]) return [new fr(fe, S, `array length at least ${F["min-length"]} expected, length ${S.length} found`)];
+              let Fe = { type: F.value, values: F.values };
+              te.$version < 7 && (Fe.function = F.function), gs(F.value) === "object" && (Fe = F.value);
+              let Ke = [];
+              for (let ct = 0; ct < S.length; ct++) Ke = Ke.concat(pe({ array: S, arrayIndex: ct, value: S[ct], valueSpec: Fe, validateSpec: R.validateSpec, style: W, styleSpec: te, key: `${fe}[${ct}]` }));
+              return Ke;
+            }
+            function Us(R) {
+              let S = R.key, F = R.value, W = R.valueSpec, te = gs(F);
+              return te === "number" && F != F && (te = "NaN"), te !== "number" ? [new fr(S, F, `number expected, ${te} found`)] : "minimum" in W && F < W.minimum ? [new fr(S, F, `${F} is less than the minimum value ${W.minimum}`)] : "maximum" in W && F > W.maximum ? [new fr(S, F, `${F} is greater than the maximum value ${W.maximum}`)] : [];
+            }
+            function wf(R) {
+              let S = R.valueSpec, F = Cs(R.value.type), W, te, fe, pe = {}, Fe = F !== "categorical" && R.value.property === void 0, Ke = !Fe, ct = gs(R.value.stops) === "array" && gs(R.value.stops[0]) === "array" && gs(R.value.stops[0][0]) === "object", Lt = ku({ key: R.key, value: R.value, valueSpec: R.styleSpec.function, validateSpec: R.validateSpec, style: R.style, styleSpec: R.styleSpec, objectElementValidators: { stops: function(mr) {
+                if (F === "identity") return [new fr(mr.key, mr.value, 'identity function may not have a "stops" property')];
+                let Pr = [], zr = mr.value;
+                return Pr = Pr.concat(Xf({ key: mr.key, value: zr, valueSpec: mr.valueSpec, validateSpec: mr.validateSpec, style: mr.style, styleSpec: mr.styleSpec, arrayElementValidator: Jt })), gs(zr) === "array" && zr.length === 0 && Pr.push(new fr(mr.key, zr, "array must have at least one stop")), Pr;
+              }, default: function(mr) {
+                return mr.validateSpec({ key: mr.key, value: mr.value, valueSpec: S, validateSpec: mr.validateSpec, style: mr.style, styleSpec: mr.styleSpec });
+              } } });
+              return F === "identity" && Fe && Lt.push(new fr(R.key, R.value, 'missing required property "property"')), F === "identity" || R.value.stops || Lt.push(new fr(R.key, R.value, 'missing required property "stops"')), F === "exponential" && R.valueSpec.expression && !Rc(R.valueSpec) && Lt.push(new fr(R.key, R.value, "exponential functions not supported")), R.styleSpec.$version >= 8 && (Ke && !Nl(R.valueSpec) ? Lt.push(new fr(R.key, R.value, "property functions not supported")) : Fe && !Kc(R.valueSpec) && Lt.push(new fr(R.key, R.value, "zoom functions not supported"))), F !== "categorical" && !ct || R.value.property !== void 0 || Lt.push(new fr(R.key, R.value, '"property" property is required')), Lt;
+              function Jt(mr) {
+                let Pr = [], zr = mr.value, ui = mr.key;
+                if (gs(zr) !== "array") return [new fr(ui, zr, `array expected, ${gs(zr)} found`)];
+                if (zr.length !== 2) return [new fr(ui, zr, `array length 2 expected, length ${zr.length} found`)];
+                if (ct) {
+                  if (gs(zr[0]) !== "object") return [new fr(ui, zr, `object expected, ${gs(zr[0])} found`)];
+                  if (zr[0].zoom === void 0) return [new fr(ui, zr, "object stop key must have zoom")];
+                  if (zr[0].value === void 0) return [new fr(ui, zr, "object stop key must have value")];
+                  if (fe && fe > Cs(zr[0].zoom)) return [new fr(ui, zr[0].zoom, "stop zoom values must appear in ascending order")];
+                  Cs(zr[0].zoom) !== fe && (fe = Cs(zr[0].zoom), te = void 0, pe = {}), Pr = Pr.concat(ku({ key: `${ui}[0]`, value: zr[0], valueSpec: { zoom: {} }, validateSpec: mr.validateSpec, style: mr.style, styleSpec: mr.styleSpec, objectElementValidators: { zoom: Us, value: cr } }));
+                } else Pr = Pr.concat(cr({ key: `${ui}[0]`, value: zr[0], validateSpec: mr.validateSpec, style: mr.style, styleSpec: mr.styleSpec }, zr));
+                return Dc(du(zr[1])) ? Pr.concat([new fr(`${ui}[1]`, zr[1], "expressions are not allowed in function stops.")]) : Pr.concat(mr.validateSpec({ key: `${ui}[1]`, value: zr[1], valueSpec: S, validateSpec: mr.validateSpec, style: mr.style, styleSpec: mr.styleSpec }));
+              }
+              function cr(mr, Pr) {
+                let zr = gs(mr.value), ui = Cs(mr.value), yi = mr.value !== null ? mr.value : Pr;
+                if (W) {
+                  if (zr !== W) return [new fr(mr.key, yi, `${zr} stop domain type must match previous stop domain type ${W}`)];
+                } else W = zr;
+                if (zr !== "number" && zr !== "string" && zr !== "boolean") return [new fr(mr.key, yi, "stop domain value must be a number, string, or boolean")];
+                if (zr !== "number" && F !== "categorical") {
+                  let vn = `number expected, ${zr} found`;
+                  return Nl(S) && F === void 0 && (vn += '\nIf you intended to use a categorical function, specify `"type": "categorical"`.'), [new fr(mr.key, yi, vn)];
+                }
+                return F !== "categorical" || zr !== "number" || isFinite(ui) && Math.floor(ui) === ui ? F !== "categorical" && zr === "number" && te !== void 0 && ui < te ? [new fr(mr.key, yi, "stop domain values must appear in ascending order")] : (te = ui, F === "categorical" && ui in pe ? [new fr(mr.key, yi, "stop domain values must be unique")] : (pe[ui] = true, [])) : [new fr(mr.key, yi, `integer expected, found ${ui}`)];
+              }
+            }
+            function zc(R) {
+              let S = (R.expressionContext === "property" ? _u : ks)(du(R.value), R.valueSpec);
+              if (S.result === "error") return S.value.map((W) => new fr(`${R.key}${W.key}`, R.value, W.message));
+              let F = S.value.expression || S.value._styleExpression.expression;
+              if (R.expressionContext === "property" && R.propertyKey === "text-font" && !F.outputDefined()) return [new fr(R.key, R.value, `Invalid data expression for "${R.propertyKey}". Output values must be contained as literals within the expression.`)];
+              if (R.expressionContext === "property" && R.propertyType === "layout" && !ju(F)) return [new fr(R.key, R.value, '"feature-state" data expressions are not supported with layout properties.')];
+              if (R.expressionContext === "filter" && !ju(F)) return [new fr(R.key, R.value, '"feature-state" data expressions are not supported with filters.')];
+              if (R.expressionContext && R.expressionContext.indexOf("cluster") === 0) {
+                if (!jf(F, ["zoom", "feature-state"])) return [new fr(R.key, R.value, '"zoom" and "feature-state" expressions are not supported with cluster properties.')];
+                if (R.expressionContext === "cluster-initial" && !th(F)) return [new fr(R.key, R.value, "Feature data expressions are not supported with initial expression part of cluster properties.")];
+              }
+              return [];
+            }
+            function Wu(R) {
+              let S = R.key, F = R.value, W = R.valueSpec, te = [];
+              return Array.isArray(W.values) ? W.values.indexOf(Cs(F)) === -1 && te.push(new fr(S, F, `expected one of [${W.values.join(", ")}], ${JSON.stringify(F)} found`)) : Object.keys(W.values).indexOf(Cs(F)) === -1 && te.push(new fr(S, F, `expected one of [${Object.keys(W.values).join(", ")}], ${JSON.stringify(F)} found`)), te;
+            }
+            function Rf(R) {
+              return Mh(du(R.value)) ? zc($e({}, R, { expressionContext: "filter", valueSpec: { value: "boolean" } })) : Xu(R);
+            }
+            function Xu(R) {
+              let S = R.value, F = R.key;
+              if (gs(S) !== "array") return [new fr(F, S, `array expected, ${gs(S)} found`)];
+              let W = R.styleSpec, te, fe = [];
+              if (S.length < 1) return [new fr(F, S, "filter array must have at least 1 element")];
+              switch (fe = fe.concat(Wu({ key: `${F}[0]`, value: S[0], valueSpec: W.filter_operator, style: R.style, styleSpec: R.styleSpec })), Cs(S[0])) {
+                case "<":
+                case "<=":
+                case ">":
+                case ">=":
+                  S.length >= 2 && Cs(S[1]) === "$type" && fe.push(new fr(F, S, `"$type" cannot be use with operator "${S[0]}"`));
+                case "==":
+                case "!=":
+                  S.length !== 3 && fe.push(new fr(F, S, `filter array for operator "${S[0]}" must have 3 elements`));
+                case "in":
+                case "!in":
+                  S.length >= 2 && (te = gs(S[1]), te !== "string" && fe.push(new fr(`${F}[1]`, S[1], `string expected, ${te} found`)));
+                  for (let pe = 2; pe < S.length; pe++) te = gs(S[pe]), Cs(S[1]) === "$type" ? fe = fe.concat(Wu({ key: `${F}[${pe}]`, value: S[pe], valueSpec: W.geometry_type, style: R.style, styleSpec: R.styleSpec })) : te !== "string" && te !== "number" && te !== "boolean" && fe.push(new fr(`${F}[${pe}]`, S[pe], `string, number, or boolean expected, ${te} found`));
+                  break;
+                case "any":
+                case "all":
+                case "none":
+                  for (let pe = 1; pe < S.length; pe++) fe = fe.concat(Xu({ key: `${F}[${pe}]`, value: S[pe], style: R.style, styleSpec: R.styleSpec }));
+                  break;
+                case "has":
+                case "!has":
+                  te = gs(S[1]), S.length !== 2 ? fe.push(new fr(F, S, `filter array for "${S[0]}" operator must have 2 elements`)) : te !== "string" && fe.push(new fr(`${F}[1]`, S[1], `string expected, ${te} found`));
+              }
+              return fe;
+            }
+            function uf(R, S) {
+              let F = R.key, W = R.validateSpec, te = R.style, fe = R.styleSpec, pe = R.value, Fe = R.objectKey, Ke = fe[`${S}_${R.layerType}`];
+              if (!Ke) return [];
+              let ct = Fe.match(/^(.*)-transition$/);
+              if (S === "paint" && ct && Ke[ct[1]] && Ke[ct[1]].transition) return W({ key: F, value: pe, valueSpec: fe.transition, style: te, styleSpec: fe });
+              let Lt = R.valueSpec || Ke[Fe];
+              if (!Lt) return [new fr(F, pe, `unknown property "${Fe}"`)];
+              let Jt;
+              if (gs(pe) === "string" && Nl(Lt) && !Lt.tokens && (Jt = /^{([^}]+)}$/.exec(pe))) return [new fr(F, pe, `"${Fe}" does not support interpolation syntax
+Use an identity property function instead: \`{ "type": "identity", "property": ${JSON.stringify(Jt[1])} }\`.`)];
+              let cr = [];
+              return R.layerType === "symbol" && (Fe === "text-field" && te && !te.glyphs && cr.push(new fr(F, pe, 'use of "text-field" requires a style "glyphs" property')), Fe === "text-font" && Wf(du(pe)) && Cs(pe.type) === "identity" && cr.push(new fr(F, pe, '"text-font" does not support identity functions'))), cr.concat(W({ key: R.key, value: pe, valueSpec: Lt, style: te, styleSpec: fe, expressionContext: "property", propertyType: S, propertyKey: Fe }));
+            }
+            function Zf(R) {
+              return uf(R, "paint");
+            }
+            function Wl(R) {
+              return uf(R, "layout");
+            }
+            function ah(R) {
+              let S = [], F = R.value, W = R.key, te = R.style, fe = R.styleSpec;
+              F.type || F.ref || S.push(new fr(W, F, 'either "type" or "ref" is required'));
+              let pe = Cs(F.type), Fe = Cs(F.ref);
+              if (F.id) {
+                let Ke = Cs(F.id);
+                for (let ct = 0; ct < R.arrayIndex; ct++) {
+                  let Lt = te.layers[ct];
+                  Cs(Lt.id) === Ke && S.push(new fr(W, F.id, `duplicate layer id "${F.id}", previously used at line ${Lt.id.__line__}`));
+                }
+              }
+              if ("ref" in F) {
+                let Ke;
+                ["type", "source", "source-layer", "filter", "layout"].forEach((ct) => {
+                  ct in F && S.push(new fr(W, F[ct], `"${ct}" is prohibited for ref layers`));
+                }), te.layers.forEach((ct) => {
+                  Cs(ct.id) === Fe && (Ke = ct);
+                }), Ke ? Ke.ref ? S.push(new fr(W, F.ref, "ref cannot reference another ref layer")) : pe = Cs(Ke.type) : S.push(new fr(W, F.ref, `ref layer "${Fe}" not found`));
+              } else if (pe !== "background") if (F.source) {
+                let Ke = te.sources && te.sources[F.source], ct = Ke && Cs(Ke.type);
+                Ke ? ct === "vector" && pe === "raster" ? S.push(new fr(W, F.source, `layer "${F.id}" requires a raster source`)) : ct !== "raster-dem" && pe === "hillshade" ? S.push(new fr(W, F.source, `layer "${F.id}" requires a raster-dem source`)) : ct === "raster" && pe !== "raster" ? S.push(new fr(W, F.source, `layer "${F.id}" requires a vector source`)) : ct !== "vector" || F["source-layer"] ? ct === "raster-dem" && pe !== "hillshade" ? S.push(new fr(W, F.source, "raster-dem source can only be used with layer type 'hillshade'.")) : pe !== "line" || !F.paint || !F.paint["line-gradient"] || ct === "geojson" && Ke.lineMetrics || S.push(new fr(W, F, `layer "${F.id}" specifies a line-gradient, which requires a GeoJSON source with \`lineMetrics\` enabled.`)) : S.push(new fr(W, F, `layer "${F.id}" must specify a "source-layer"`)) : S.push(new fr(W, F.source, `source "${F.source}" not found`));
+              } else S.push(new fr(W, F, 'missing required property "source"'));
+              return S = S.concat(ku({ key: W, value: F, valueSpec: fe.layer, style: R.style, styleSpec: R.styleSpec, validateSpec: R.validateSpec, objectElementValidators: { "*": () => [], type: () => R.validateSpec({ key: `${W}.type`, value: F.type, valueSpec: fe.layer.type, style: R.style, styleSpec: R.styleSpec, validateSpec: R.validateSpec, object: F, objectKey: "type" }), filter: Rf, layout: (Ke) => ku({ layer: F, key: Ke.key, value: Ke.value, style: Ke.style, styleSpec: Ke.styleSpec, validateSpec: Ke.validateSpec, objectElementValidators: { "*": (ct) => Wl($e({ layerType: pe }, ct)) } }), paint: (Ke) => ku({ layer: F, key: Ke.key, value: Ke.value, style: Ke.style, styleSpec: Ke.styleSpec, validateSpec: Ke.validateSpec, objectElementValidators: { "*": (ct) => Zf($e({ layerType: pe }, ct)) } }) } })), S;
+            }
+            function Zu(R) {
+              let S = R.value, F = R.key, W = gs(S);
+              return W !== "string" ? [new fr(F, S, `string expected, ${W} found`)] : [];
+            }
+            let Oc = { promoteId: function({ key: R, value: S }) {
+              if (gs(S) === "string") return Zu({ key: R, value: S });
+              {
+                let F = [];
+                for (let W in S) F.push(...Zu({ key: `${R}.${W}`, value: S[W] }));
+                return F;
+              }
+            } };
+            function Tc(R) {
+              let S = R.value, F = R.key, W = R.styleSpec, te = R.style, fe = R.validateSpec;
+              if (!S.type) return [new fr(F, S, '"type" is required')];
+              let pe = Cs(S.type), Fe;
+              switch (pe) {
+                case "vector":
+                case "raster":
+                  return Fe = ku({ key: F, value: S, valueSpec: W[`source_${pe.replace("-", "_")}`], style: R.style, styleSpec: W, objectElementValidators: Oc, validateSpec: fe }), Fe;
+                case "raster-dem":
+                  return Fe = function(Ke) {
+                    var ct;
+                    let Lt = (ct = Ke.sourceName) !== null && ct !== void 0 ? ct : "", Jt = Ke.value, cr = Ke.styleSpec, mr = cr.source_raster_dem, Pr = Ke.style, zr = [], ui = gs(Jt);
+                    if (Jt === void 0) return zr;
+                    if (ui !== "object") return zr.push(new fr("source_raster_dem", Jt, `object expected, ${ui} found`)), zr;
+                    let yi = Cs(Jt.encoding) === "custom", vn = ["redFactor", "greenFactor", "blueFactor", "baseShift"], zi = Ke.value.encoding ? `"${Ke.value.encoding}"` : "Default";
+                    for (let un in Jt) !yi && vn.includes(un) ? zr.push(new fr(un, Jt[un], `In "${Lt}": "${un}" is only valid when "encoding" is set to "custom". ${zi} encoding found`)) : mr[un] ? zr = zr.concat(Ke.validateSpec({ key: un, value: Jt[un], valueSpec: mr[un], validateSpec: Ke.validateSpec, style: Pr, styleSpec: cr })) : zr.push(new fr(un, Jt[un], `unknown property "${un}"`));
+                    return zr;
+                  }({ sourceName: F, value: S, style: R.style, styleSpec: W, validateSpec: fe }), Fe;
+                case "geojson":
+                  if (Fe = ku({ key: F, value: S, valueSpec: W.source_geojson, style: te, styleSpec: W, validateSpec: fe, objectElementValidators: Oc }), S.cluster) for (let Ke in S.clusterProperties) {
+                    let [ct, Lt] = S.clusterProperties[Ke], Jt = typeof ct == "string" ? [ct, ["accumulated"], ["get", Ke]] : ct;
+                    Fe.push(...zc({ key: `${F}.${Ke}.map`, value: Lt, expressionContext: "cluster-map" })), Fe.push(...zc({ key: `${F}.${Ke}.reduce`, value: Jt, expressionContext: "cluster-reduce" }));
+                  }
+                  return Fe;
+                case "video":
+                  return ku({ key: F, value: S, valueSpec: W.source_video, style: te, validateSpec: fe, styleSpec: W });
+                case "image":
+                  return ku({ key: F, value: S, valueSpec: W.source_image, style: te, validateSpec: fe, styleSpec: W });
+                case "canvas":
+                  return [new fr(F, null, "Please use runtime APIs to add canvas sources, rather than including them in stylesheets.", "source.canvas")];
+                default:
+                  return Wu({ key: `${F}.type`, value: S.type, valueSpec: { values: ["vector", "raster", "raster-dem", "geojson", "video", "image"] } });
+              }
+            }
+            function wl(R) {
+              let S = R.value, F = R.styleSpec, W = F.light, te = R.style, fe = [], pe = gs(S);
+              if (S === void 0) return fe;
+              if (pe !== "object") return fe = fe.concat([new fr("light", S, `object expected, ${pe} found`)]), fe;
+              for (let Fe in S) {
+                let Ke = Fe.match(/^(.*)-transition$/);
+                fe = fe.concat(Ke && W[Ke[1]] && W[Ke[1]].transition ? R.validateSpec({ key: Fe, value: S[Fe], valueSpec: F.transition, validateSpec: R.validateSpec, style: te, styleSpec: F }) : W[Fe] ? R.validateSpec({ key: Fe, value: S[Fe], valueSpec: W[Fe], validateSpec: R.validateSpec, style: te, styleSpec: F }) : [new fr(Fe, S[Fe], `unknown property "${Fe}"`)]);
+              }
+              return fe;
+            }
+            function vu(R) {
+              let S = R.value, F = R.styleSpec, W = F.sky, te = R.style, fe = gs(S);
+              if (S === void 0) return [];
+              if (fe !== "object") return [new fr("sky", S, `object expected, ${fe} found`)];
+              let pe = [];
+              for (let Fe in S) pe = pe.concat(W[Fe] ? R.validateSpec({ key: Fe, value: S[Fe], valueSpec: W[Fe], style: te, styleSpec: F }) : [new fr(Fe, S[Fe], `unknown property "${Fe}"`)]);
+              return pe;
+            }
+            function qc(R) {
+              let S = R.value, F = R.styleSpec, W = F.terrain, te = R.style, fe = [], pe = gs(S);
+              if (S === void 0) return fe;
+              if (pe !== "object") return fe = fe.concat([new fr("terrain", S, `object expected, ${pe} found`)]), fe;
+              for (let Fe in S) fe = fe.concat(W[Fe] ? R.validateSpec({ key: Fe, value: S[Fe], valueSpec: W[Fe], validateSpec: R.validateSpec, style: te, styleSpec: F }) : [new fr(Fe, S[Fe], `unknown property "${Fe}"`)]);
+              return fe;
+            }
+            function cf(R) {
+              let S = [], F = R.value, W = R.key;
+              if (Array.isArray(F)) {
+                let te = [], fe = [];
+                for (let pe in F) F[pe].id && te.includes(F[pe].id) && S.push(new fr(W, F, `all the sprites' ids must be unique, but ${F[pe].id} is duplicated`)), te.push(F[pe].id), F[pe].url && fe.includes(F[pe].url) && S.push(new fr(W, F, `all the sprites' URLs must be unique, but ${F[pe].url} is duplicated`)), fe.push(F[pe].url), S = S.concat(ku({ key: `${W}[${pe}]`, value: F[pe], valueSpec: { id: { type: "string", required: true }, url: { type: "string", required: true } }, validateSpec: R.validateSpec }));
+                return S;
+              }
+              return Zu({ key: W, value: F });
+            }
+            let fc = { "*": () => [], array: Xf, boolean: function(R) {
+              let S = R.value, F = R.key, W = gs(S);
+              return W !== "boolean" ? [new fr(F, S, `boolean expected, ${W} found`)] : [];
+            }, number: Us, color: function(R) {
+              let S = R.key, F = R.value, W = gs(F);
+              return W !== "string" ? [new fr(S, F, `color expected, ${W} found`)] : nr.parse(String(F)) ? [] : [new fr(S, F, `color expected, "${F}" found`)];
+            }, constants: If, enum: Wu, filter: Rf, function: wf, layer: ah, object: ku, source: Tc, light: wl, sky: vu, terrain: qc, projection: function(R) {
+              let S = R.value, F = R.styleSpec, W = F.projection, te = R.style, fe = gs(S);
+              if (S === void 0) return [];
+              if (fe !== "object") return [new fr("projection", S, `object expected, ${fe} found`)];
+              let pe = [];
+              for (let Fe in S) pe = pe.concat(W[Fe] ? R.validateSpec({ key: Fe, value: S[Fe], valueSpec: W[Fe], style: te, styleSpec: F }) : [new fr(Fe, S[Fe], `unknown property "${Fe}"`)]);
+              return pe;
+            }, string: Zu, formatted: function(R) {
+              return Zu(R).length === 0 ? [] : zc(R);
+            }, resolvedImage: function(R) {
+              return Zu(R).length === 0 ? [] : zc(R);
+            }, padding: function(R) {
+              let S = R.key, F = R.value;
+              if (gs(F) === "array") {
+                if (F.length < 1 || F.length > 4) return [new fr(S, F, `padding requires 1 to 4 values; ${F.length} values found`)];
+                let W = { type: "number" }, te = [];
+                for (let fe = 0; fe < F.length; fe++) te = te.concat(R.validateSpec({ key: `${S}[${fe}]`, value: F[fe], validateSpec: R.validateSpec, valueSpec: W }));
+                return te;
+              }
+              return Us({ key: S, value: F, valueSpec: {} });
+            }, variableAnchorOffsetCollection: function(R) {
+              let S = R.key, F = R.value, W = gs(F), te = R.styleSpec;
+              if (W !== "array" || F.length < 1 || F.length % 2 != 0) return [new fr(S, F, "variableAnchorOffsetCollection requires a non-empty array of even length")];
+              let fe = [];
+              for (let pe = 0; pe < F.length; pe += 2) fe = fe.concat(Wu({ key: `${S}[${pe}]`, value: F[pe], valueSpec: te.layout_symbol["text-anchor"] })), fe = fe.concat(Xf({ key: `${S}[${pe + 1}]`, value: F[pe + 1], valueSpec: { length: 2, value: "number" }, validateSpec: R.validateSpec, style: R.style, styleSpec: te }));
+              return fe;
+            }, sprite: cf };
+            function Bc(R) {
+              let S = R.value, F = R.valueSpec, W = R.styleSpec;
+              return R.validateSpec = Bc, F.expression && Wf(Cs(S)) ? wf(R) : F.expression && Dc(du(S)) ? zc(R) : F.type && fc[F.type] ? fc[F.type](R) : ku($e({}, R, { valueSpec: F.type ? W[F.type] : F }));
+            }
+            function At(R) {
+              let S = R.value, F = R.key, W = Zu(R);
+              return W.length || (S.indexOf("{fontstack}") === -1 && W.push(new fr(F, S, '"glyphs" url must include a "{fontstack}" token')), S.indexOf("{range}") === -1 && W.push(new fr(F, S, '"glyphs" url must include a "{range}" token'))), W;
+            }
+            function Xt(R, S = ce) {
+              let F = [];
+              return F = F.concat(Bc({ key: "", value: R, valueSpec: S.$root, styleSpec: S, style: R, validateSpec: Bc, objectElementValidators: { glyphs: At, "*": () => [] } })), R.constants && (F = F.concat(If({ key: "constants", value: R.constants }))), Ar(F);
+            }
+            function Cr(R) {
+              return function(S) {
+                return R(j1(_g({}, S), { validateSpec: Bc }));
+              };
+            }
+            function Ar(R) {
+              return [].concat(R).sort((S, F) => S.line - F.line);
+            }
+            function Kr(R) {
+              return function(...S) {
+                return Ar(R.apply(this, S));
+              };
+            }
+            Xt.source = Kr(Cr(Tc)), Xt.sprite = Kr(Cr(cf)), Xt.glyphs = Kr(Cr(At)), Xt.light = Kr(Cr(wl)), Xt.sky = Kr(Cr(vu)), Xt.terrain = Kr(Cr(qc)), Xt.layer = Kr(Cr(ah)), Xt.filter = Kr(Cr(Rf)), Xt.paintProperty = Kr(Cr(Zf)), Xt.layoutProperty = Kr(Cr(Wl));
+            let ki = Xt, Xi = ki.light, dn = ki.sky, wn = ki.paintProperty, Nn = ki.layoutProperty;
+            function Yi(R, S) {
+              let F = false;
+              if (S && S.length) for (let W of S) R.fire(new me(new Error(W.message))), F = true;
+              return F;
+            }
+            class Qi {
+              constructor(S, F, W) {
+                let te = this.cells = [];
+                if (S instanceof ArrayBuffer) {
+                  this.arrayBuffer = S;
+                  let pe = new Int32Array(this.arrayBuffer);
+                  S = pe[0], this.d = (F = pe[1]) + 2 * (W = pe[2]);
+                  for (let Ke = 0; Ke < this.d * this.d; Ke++) {
+                    let ct = pe[3 + Ke], Lt = pe[3 + Ke + 1];
+                    te.push(ct === Lt ? null : pe.subarray(ct, Lt));
+                  }
+                  let Fe = pe[3 + te.length + 1];
+                  this.keys = pe.subarray(pe[3 + te.length], Fe), this.bboxes = pe.subarray(Fe), this.insert = this._insertReadonly;
+                } else {
+                  this.d = F + 2 * W;
+                  for (let pe = 0; pe < this.d * this.d; pe++) te.push([]);
+                  this.keys = [], this.bboxes = [];
+                }
+                this.n = F, this.extent = S, this.padding = W, this.scale = F / S, this.uid = 0;
+                let fe = W / F * S;
+                this.min = -fe, this.max = S + fe;
+              }
+              insert(S, F, W, te, fe) {
+                this._forEachCell(F, W, te, fe, this._insertCell, this.uid++, void 0, void 0), this.keys.push(S), this.bboxes.push(F), this.bboxes.push(W), this.bboxes.push(te), this.bboxes.push(fe);
+              }
+              _insertReadonly() {
+                throw new Error("Cannot insert into a GridIndex created from an ArrayBuffer.");
+              }
+              _insertCell(S, F, W, te, fe, pe) {
+                this.cells[fe].push(pe);
+              }
+              query(S, F, W, te, fe) {
+                let pe = this.min, Fe = this.max;
+                if (S <= pe && F <= pe && Fe <= W && Fe <= te && !fe) return Array.prototype.slice.call(this.keys);
+                {
+                  let Ke = [];
+                  return this._forEachCell(S, F, W, te, this._queryCell, Ke, {}, fe), Ke;
+                }
+              }
+              _queryCell(S, F, W, te, fe, pe, Fe, Ke) {
+                let ct = this.cells[fe];
+                if (ct !== null) {
+                  let Lt = this.keys, Jt = this.bboxes;
+                  for (let cr = 0; cr < ct.length; cr++) {
+                    let mr = ct[cr];
+                    if (Fe[mr] === void 0) {
+                      let Pr = 4 * mr;
+                      (Ke ? Ke(Jt[Pr + 0], Jt[Pr + 1], Jt[Pr + 2], Jt[Pr + 3]) : S <= Jt[Pr + 2] && F <= Jt[Pr + 3] && W >= Jt[Pr + 0] && te >= Jt[Pr + 1]) ? (Fe[mr] = true, pe.push(Lt[mr])) : Fe[mr] = false;
+                    }
+                  }
+                }
+              }
+              _forEachCell(S, F, W, te, fe, pe, Fe, Ke) {
+                let ct = this._convertToCellCoord(S), Lt = this._convertToCellCoord(F), Jt = this._convertToCellCoord(W), cr = this._convertToCellCoord(te);
+                for (let mr = ct; mr <= Jt; mr++) for (let Pr = Lt; Pr <= cr; Pr++) {
+                  let zr = this.d * Pr + mr;
+                  if ((!Ke || Ke(this._convertFromCellCoord(mr), this._convertFromCellCoord(Pr), this._convertFromCellCoord(mr + 1), this._convertFromCellCoord(Pr + 1))) && fe.call(this, S, F, W, te, zr, pe, Fe, Ke)) return;
+                }
+              }
+              _convertFromCellCoord(S) {
+                return (S - this.padding) / this.scale;
+              }
+              _convertToCellCoord(S) {
+                return Math.max(0, Math.min(this.d - 1, Math.floor(S * this.scale) + this.padding));
+              }
+              toArrayBuffer() {
+                if (this.arrayBuffer) return this.arrayBuffer;
+                let S = this.cells, F = 3 + this.cells.length + 1 + 1, W = 0;
+                for (let pe = 0; pe < this.cells.length; pe++) W += this.cells[pe].length;
+                let te = new Int32Array(F + W + this.keys.length + this.bboxes.length);
+                te[0] = this.extent, te[1] = this.n, te[2] = this.padding;
+                let fe = F;
+                for (let pe = 0; pe < S.length; pe++) {
+                  let Fe = S[pe];
+                  te[3 + pe] = fe, te.set(Fe, fe), fe += Fe.length;
+                }
+                return te[3 + S.length] = fe, te.set(this.keys, fe), fe += this.keys.length, te[3 + S.length + 1] = fe, te.set(this.bboxes, fe), fe += this.bboxes.length, te.buffer;
+              }
+              static serialize(S, F) {
+                let W = S.toArrayBuffer();
+                return F && F.push(W), { buffer: W };
+              }
+              static deserialize(S) {
+                return new Qi(S.buffer);
+              }
+            }
+            let on = {};
+            function Fi(R, S, F = {}) {
+              if (on[R]) throw new Error(`${R} is already registered.`);
+              Object.defineProperty(S, "_classRegistryKey", { value: R, writeable: false }), on[R] = { klass: S, omit: F.omit || [], shallow: F.shallow || [] };
+            }
+            Fi("Object", Object), Fi("TransferableGridIndex", Qi), Fi("Color", nr), Fi("Error", Error), Fi("AJAXError", ge), Fi("ResolvedImage", tn), Fi("StylePropertyFunction", nl), Fi("StyleExpression", Eu, { omit: ["_evaluator"] }), Fi("ZoomDependentExpression", hu), Fi("ZoomConstantExpression", bc), Fi("CompoundExpression", Bl, { omit: ["_evaluate"] });
+            for (let R in yf) yf[R]._classRegistryKey || Fi(`Expression_${R}`, yf[R]);
+            function Qn(R) {
+              return R && typeof ArrayBuffer != "undefined" && (R instanceof ArrayBuffer || R.constructor && R.constructor.name === "ArrayBuffer");
+            }
+            function Ca(R) {
+              return R.$name || R.constructor._classRegistryKey;
+            }
+            function Ra(R) {
+              return !function(S) {
+                if (S === null || typeof S != "object") return false;
+                let F = Ca(S);
+                return !(!F || F === "Object");
+              }(R) && (R == null || typeof R == "boolean" || typeof R == "number" || typeof R == "string" || R instanceof Boolean || R instanceof Number || R instanceof String || R instanceof Date || R instanceof RegExp || R instanceof Blob || R instanceof Error || Qn(R) || G(R) || ArrayBuffer.isView(R) || R instanceof ImageData);
+            }
+            function La(R, S) {
+              if (Ra(R)) return (Qn(R) || G(R)) && S && S.push(R), ArrayBuffer.isView(R) && S && S.push(R.buffer), R instanceof ImageData && S && S.push(R.data.buffer), R;
+              if (Array.isArray(R)) {
+                let fe = [];
+                for (let pe of R) fe.push(La(pe, S));
+                return fe;
+              }
+              if (typeof R != "object") throw new Error("can't serialize object of type " + typeof R);
+              let F = Ca(R);
+              if (!F) throw new Error(`can't serialize object of unregistered class ${R.constructor.name}`);
+              if (!on[F]) throw new Error(`${F} is not registered.`);
+              let { klass: W } = on[F], te = W.serialize ? W.serialize(R, S) : {};
+              if (W.serialize) {
+                if (S && te === S[S.length - 1]) throw new Error("statically serialized object won't survive transfer of $name property");
+              } else {
+                for (let fe in R) {
+                  if (!R.hasOwnProperty(fe) || on[F].omit.indexOf(fe) >= 0) continue;
+                  let pe = R[fe];
+                  te[fe] = on[F].shallow.indexOf(fe) >= 0 ? pe : La(pe, S);
+                }
+                R instanceof Error && (te.message = R.message);
+              }
+              if (te.$name) throw new Error("$name property is reserved for worker serialization logic.");
+              return F !== "Object" && (te.$name = F), te;
+            }
+            function Na(R) {
+              if (Ra(R)) return R;
+              if (Array.isArray(R)) return R.map(Na);
+              if (typeof R != "object") throw new Error("can't deserialize object of type " + typeof R);
+              let S = Ca(R) || "Object";
+              if (!on[S]) throw new Error(`can't deserialize unregistered class ${S}`);
+              let { klass: F } = on[S];
+              if (!F) throw new Error(`can't deserialize unregistered class ${S}`);
+              if (F.deserialize) return F.deserialize(R);
+              let W = Object.create(F.prototype);
+              for (let te of Object.keys(R)) {
+                if (te === "$name") continue;
+                let fe = R[te];
+                W[te] = on[S].shallow.indexOf(te) >= 0 ? fe : Na(fe);
+              }
+              return W;
+            }
+            class Yn {
+              constructor() {
+                this.first = true;
+              }
+              update(S, F) {
+                let W = Math.floor(S);
+                return this.first ? (this.first = false, this.lastIntegerZoom = W, this.lastIntegerZoomTime = 0, this.lastZoom = S, this.lastFloorZoom = W, true) : (this.lastFloorZoom > W ? (this.lastIntegerZoom = W + 1, this.lastIntegerZoomTime = F) : this.lastFloorZoom < W && (this.lastIntegerZoom = W, this.lastIntegerZoomTime = F), S !== this.lastZoom && (this.lastZoom = S, this.lastFloorZoom = W, true));
+              }
+            }
+            let Dn = { "Latin-1 Supplement": (R) => R >= 128 && R <= 255, "Hangul Jamo": (R) => R >= 4352 && R <= 4607, Khmer: (R) => R >= 6016 && R <= 6143, "General Punctuation": (R) => R >= 8192 && R <= 8303, "Letterlike Symbols": (R) => R >= 8448 && R <= 8527, "Number Forms": (R) => R >= 8528 && R <= 8591, "Miscellaneous Technical": (R) => R >= 8960 && R <= 9215, "Control Pictures": (R) => R >= 9216 && R <= 9279, "Optical Character Recognition": (R) => R >= 9280 && R <= 9311, "Enclosed Alphanumerics": (R) => R >= 9312 && R <= 9471, "Geometric Shapes": (R) => R >= 9632 && R <= 9727, "Miscellaneous Symbols": (R) => R >= 9728 && R <= 9983, "Miscellaneous Symbols and Arrows": (R) => R >= 11008 && R <= 11263, "Ideographic Description Characters": (R) => R >= 12272 && R <= 12287, "CJK Symbols and Punctuation": (R) => R >= 12288 && R <= 12351, Katakana: (R) => R >= 12448 && R <= 12543, Kanbun: (R) => R >= 12688 && R <= 12703, "CJK Strokes": (R) => R >= 12736 && R <= 12783, "Enclosed CJK Letters and Months": (R) => R >= 12800 && R <= 13055, "CJK Compatibility": (R) => R >= 13056 && R <= 13311, "Yijing Hexagram Symbols": (R) => R >= 19904 && R <= 19967, "Private Use Area": (R) => R >= 57344 && R <= 63743, "Vertical Forms": (R) => R >= 65040 && R <= 65055, "CJK Compatibility Forms": (R) => R >= 65072 && R <= 65103, "Small Form Variants": (R) => R >= 65104 && R <= 65135, "Halfwidth and Fullwidth Forms": (R) => R >= 65280 && R <= 65519 };
+            function Ka(R) {
+              for (let S of R) if (Ho(S.charCodeAt(0))) return true;
+              return false;
+            }
+            function bo(R) {
+              for (let S of R) if (!as(S.charCodeAt(0))) return false;
+              return true;
+            }
+            function Zo(R) {
+              let S = R.map((F) => {
+                try {
+                  return new RegExp(`\\p{sc=${F}}`, "u").source;
+                } catch (W) {
+                  return null;
+                }
+              }).filter((F) => F);
+              return new RegExp(S.join("|"), "u");
+            }
+            let Ss = Zo(["Arab", "Dupl", "Mong", "Ougr", "Syrc"]);
+            function as(R) {
+              return !Ss.test(String.fromCodePoint(R));
+            }
+            let ws = Zo(["Bopo", "Hani", "Hira", "Kana", "Kits", "Nshu", "Tang", "Yiii"]);
+            function Ho(R) {
+              return !(R !== 746 && R !== 747 && (R < 4352 || !(Dn["CJK Compatibility Forms"](R) && !(R >= 65097 && R <= 65103) || Dn["CJK Compatibility"](R) || Dn["CJK Strokes"](R) || !(!Dn["CJK Symbols and Punctuation"](R) || R >= 12296 && R <= 12305 || R >= 12308 && R <= 12319 || R === 12336) || Dn["Enclosed CJK Letters and Months"](R) || Dn["Ideographic Description Characters"](R) || Dn.Kanbun(R) || Dn.Katakana(R) && R !== 12540 || !(!Dn["Halfwidth and Fullwidth Forms"](R) || R === 65288 || R === 65289 || R === 65293 || R >= 65306 && R <= 65310 || R === 65339 || R === 65341 || R === 65343 || R >= 65371 && R <= 65503 || R === 65507 || R >= 65512 && R <= 65519) || !(!Dn["Small Form Variants"](R) || R >= 65112 && R <= 65118 || R >= 65123 && R <= 65126) || Dn["Vertical Forms"](R) || Dn["Yijing Hexagram Symbols"](R) || new RegExp("\\p{sc=Cans}", "u").test(String.fromCodePoint(R)) || new RegExp("\\p{sc=Hang}", "u").test(String.fromCodePoint(R)) || ws.test(String.fromCodePoint(R)))));
+            }
+            function ml(R) {
+              return !(Ho(R) || function(S) {
+                return !!(Dn["Latin-1 Supplement"](S) && (S === 167 || S === 169 || S === 174 || S === 177 || S === 188 || S === 189 || S === 190 || S === 215 || S === 247) || Dn["General Punctuation"](S) && (S === 8214 || S === 8224 || S === 8225 || S === 8240 || S === 8241 || S === 8251 || S === 8252 || S === 8258 || S === 8263 || S === 8264 || S === 8265 || S === 8273) || Dn["Letterlike Symbols"](S) || Dn["Number Forms"](S) || Dn["Miscellaneous Technical"](S) && (S >= 8960 && S <= 8967 || S >= 8972 && S <= 8991 || S >= 8996 && S <= 9e3 || S === 9003 || S >= 9085 && S <= 9114 || S >= 9150 && S <= 9165 || S === 9167 || S >= 9169 && S <= 9179 || S >= 9186 && S <= 9215) || Dn["Control Pictures"](S) && S !== 9251 || Dn["Optical Character Recognition"](S) || Dn["Enclosed Alphanumerics"](S) || Dn["Geometric Shapes"](S) || Dn["Miscellaneous Symbols"](S) && !(S >= 9754 && S <= 9759) || Dn["Miscellaneous Symbols and Arrows"](S) && (S >= 11026 && S <= 11055 || S >= 11088 && S <= 11097 || S >= 11192 && S <= 11243) || Dn["CJK Symbols and Punctuation"](S) || Dn.Katakana(S) || Dn["Private Use Area"](S) || Dn["CJK Compatibility Forms"](S) || Dn["Small Form Variants"](S) || Dn["Halfwidth and Fullwidth Forms"](S) || S === 8734 || S === 8756 || S === 8757 || S >= 9984 && S <= 10087 || S >= 10102 && S <= 10131 || S === 65532 || S === 65533);
+              }(R));
+            }
+            let Ws = Zo(["Adlm", "Arab", "Armi", "Avst", "Chrs", "Cprt", "Egyp", "Elym", "Gara", "Hatr", "Hebr", "Hung", "Khar", "Lydi", "Mand", "Mani", "Mend", "Merc", "Mero", "Narb", "Nbat", "Nkoo", "Orkh", "Palm", "Phli", "Phlp", "Phnx", "Prti", "Rohg", "Samr", "Sarb", "Sogo", "Syrc", "Thaa", "Todr", "Yezi"]);
+            function Ls(R) {
+              return Ws.test(String.fromCodePoint(R));
+            }
+            function va(R, S) {
+              return !(!S && Ls(R) || R >= 2304 && R <= 3583 || R >= 3840 && R <= 4255 || Dn.Khmer(R));
+            }
+            function no(R) {
+              for (let S of R) if (Ls(S.charCodeAt(0))) return true;
+              return false;
+            }
+            let ys = new class {
+              constructor() {
+                this.applyArabicShaping = null, this.processBidirectionalText = null, this.processStyledBidirectionalText = null, this.pluginStatus = "unavailable", this.pluginURL = null;
+              }
+              setState(R) {
+                this.pluginStatus = R.pluginStatus, this.pluginURL = R.pluginURL;
+              }
+              getState() {
+                return { pluginStatus: this.pluginStatus, pluginURL: this.pluginURL };
+              }
+              setMethods(R) {
+                this.applyArabicShaping = R.applyArabicShaping, this.processBidirectionalText = R.processBidirectionalText, this.processStyledBidirectionalText = R.processStyledBidirectionalText;
+              }
+              isParsed() {
+                return this.applyArabicShaping != null && this.processBidirectionalText != null && this.processStyledBidirectionalText != null;
+              }
+              getPluginURL() {
+                return this.pluginURL;
+              }
+              getRTLTextPluginStatus() {
+                return this.pluginStatus;
+              }
+            }();
+            class rs {
+              constructor(S, F) {
+                this.zoom = S, F ? (this.now = F.now, this.fadeDuration = F.fadeDuration, this.zoomHistory = F.zoomHistory, this.transition = F.transition) : (this.now = 0, this.fadeDuration = 0, this.zoomHistory = new Yn(), this.transition = {});
+              }
+              isSupportedScript(S) {
+                return function(F, W) {
+                  for (let te of F) if (!va(te.charCodeAt(0), W)) return false;
+                  return true;
+                }(S, ys.getRTLTextPluginStatus() === "loaded");
+              }
+              crossFadingFactor() {
+                return this.fadeDuration === 0 ? 1 : Math.min((this.now - this.zoomHistory.lastIntegerZoomTime) / this.fadeDuration, 1);
+              }
+              getCrossfadeParameters() {
+                let S = this.zoom, F = S - Math.floor(S), W = this.crossFadingFactor();
+                return S > this.zoomHistory.lastIntegerZoom ? { fromScale: 2, toScale: 1, t: F + (1 - F) * W } : { fromScale: 0.5, toScale: 1, t: 1 - (1 - W) * F };
+              }
+            }
+            class Ql {
+              constructor(S, F) {
+                this.property = S, this.value = F, this.expression = function(W, te) {
+                  if (Wf(W)) return new nl(W, te);
+                  if (Dc(W)) {
+                    let fe = _u(W, te);
+                    if (fe.result === "error") throw new Error(fe.value.map((pe) => `${pe.key}: ${pe.message}`).join(", "));
+                    return fe.value;
+                  }
+                  {
+                    let fe = W;
+                    return te.type === "color" && typeof W == "string" ? fe = nr.parse(W) : te.type !== "padding" || typeof W != "number" && !Array.isArray(W) ? te.type === "variableAnchorOffsetCollection" && Array.isArray(W) && (fe = $i.parse(W)) : fe = Qr.parse(W), { kind: "constant", evaluate: () => fe };
+                  }
+                }(F === void 0 ? S.specification.default : F, S.specification);
+              }
+              isDataDriven() {
+                return this.expression.kind === "source" || this.expression.kind === "composite";
+              }
+              possiblyEvaluate(S, F, W) {
+                return this.property.possiblyEvaluate(this, S, F, W);
+              }
+            }
+            class Cu {
+              constructor(S) {
+                this.property = S, this.value = new Ql(S, void 0);
+              }
+              transitioned(S, F) {
+                return new Nc(this.property, this.value, F, L({}, S.transition, this.transition), S.now);
+              }
+              untransitioned() {
+                return new Nc(this.property, this.value, null, {}, 0);
+              }
+            }
+            class Yu {
+              constructor(S) {
+                this._properties = S, this._values = Object.create(S.defaultTransitionablePropertyValues);
+              }
+              getValue(S) {
+                return g(this._values[S].value.value);
+              }
+              setValue(S, F) {
+                Object.prototype.hasOwnProperty.call(this._values, S) || (this._values[S] = new Cu(this._values[S].property)), this._values[S].value = new Ql(this._values[S].property, F === null ? void 0 : g(F));
+              }
+              getTransition(S) {
+                return g(this._values[S].transition);
+              }
+              setTransition(S, F) {
+                Object.prototype.hasOwnProperty.call(this._values, S) || (this._values[S] = new Cu(this._values[S].property)), this._values[S].transition = g(F) || void 0;
+              }
+              serialize() {
+                let S = {};
+                for (let F of Object.keys(this._values)) {
+                  let W = this.getValue(F);
+                  W !== void 0 && (S[F] = W);
+                  let te = this.getTransition(F);
+                  te !== void 0 && (S[`${F}-transition`] = te);
+                }
+                return S;
+              }
+              transitioned(S, F) {
+                let W = new pu(this._properties);
+                for (let te of Object.keys(this._values)) W._values[te] = this._values[te].transitioned(S, F._values[te]);
+                return W;
+              }
+              untransitioned() {
+                let S = new pu(this._properties);
+                for (let F of Object.keys(this._values)) S._values[F] = this._values[F].untransitioned();
+                return S;
+              }
+            }
+            class Nc {
+              constructor(S, F, W, te, fe) {
+                this.property = S, this.value = F, this.begin = fe + te.delay || 0, this.end = this.begin + te.duration || 0, S.specification.transition && (te.delay || te.duration) && (this.prior = W);
+              }
+              possiblyEvaluate(S, F, W) {
+                let te = S.now || 0, fe = this.value.possiblyEvaluate(S, F, W), pe = this.prior;
+                if (pe) {
+                  if (te > this.end) return this.prior = null, fe;
+                  if (this.value.isDataDriven()) return this.prior = null, fe;
+                  if (te < this.begin) return pe.possiblyEvaluate(S, F, W);
+                  {
+                    let Fe = (te - this.begin) / (this.end - this.begin);
+                    return this.property.interpolate(pe.possiblyEvaluate(S, F, W), fe, function(Ke) {
+                      if (Ke <= 0) return 0;
+                      if (Ke >= 1) return 1;
+                      let ct = Ke * Ke, Lt = ct * Ke;
+                      return 4 * (Ke < 0.5 ? Lt : 3 * (Ke - ct) + Lt - 0.75);
+                    }(Fe));
+                  }
+                }
+                return fe;
+              }
+            }
+            class pu {
+              constructor(S) {
+                this._properties = S, this._values = Object.create(S.defaultTransitioningPropertyValues);
+              }
+              possiblyEvaluate(S, F, W) {
+                let te = new Ac(this._properties);
+                for (let fe of Object.keys(this._values)) te._values[fe] = this._values[fe].possiblyEvaluate(S, F, W);
+                return te;
+              }
+              hasTransition() {
+                for (let S of Object.keys(this._values)) if (this._values[S].prior) return true;
+                return false;
+              }
+            }
+            class Uc {
+              constructor(S) {
+                this._properties = S, this._values = Object.create(S.defaultPropertyValues);
+              }
+              hasValue(S) {
+                return this._values[S].value !== void 0;
+              }
+              getValue(S) {
+                return g(this._values[S].value);
+              }
+              setValue(S, F) {
+                this._values[S] = new Ql(this._values[S].property, F === null ? void 0 : g(F));
+              }
+              serialize() {
+                let S = {};
+                for (let F of Object.keys(this._values)) {
+                  let W = this.getValue(F);
+                  W !== void 0 && (S[F] = W);
+                }
+                return S;
+              }
+              possiblyEvaluate(S, F, W) {
+                let te = new Ac(this._properties);
+                for (let fe of Object.keys(this._values)) te._values[fe] = this._values[fe].possiblyEvaluate(S, F, W);
+                return te;
+              }
+            }
+            class xu {
+              constructor(S, F, W) {
+                this.property = S, this.value = F, this.parameters = W;
+              }
+              isConstant() {
+                return this.value.kind === "constant";
+              }
+              constantOr(S) {
+                return this.value.kind === "constant" ? this.value.value : S;
+              }
+              evaluate(S, F, W, te) {
+                return this.property.evaluate(this.value, this.parameters, S, F, W, te);
+              }
+            }
+            class Ac {
+              constructor(S) {
+                this._properties = S, this._values = Object.create(S.defaultPossiblyEvaluatedValues);
+              }
+              get(S) {
+                return this._values[S];
+              }
+            }
+            class Ua {
+              constructor(S) {
+                this.specification = S;
+              }
+              possiblyEvaluate(S, F) {
+                if (S.isDataDriven()) throw new Error("Value should not be data driven");
+                return S.expression.evaluate(F);
+              }
+              interpolate(S, F, W) {
+                let te = Lo[this.specification.type];
+                return te ? te(S, F, W) : S;
+              }
+            }
+            class oo {
+              constructor(S, F) {
+                this.specification = S, this.overrides = F;
+              }
+              possiblyEvaluate(S, F, W, te) {
+                return new xu(this, S.expression.kind === "constant" || S.expression.kind === "camera" ? { kind: "constant", value: S.expression.evaluate(F, null, {}, W, te) } : S.expression, F);
+              }
+              interpolate(S, F, W) {
+                if (S.value.kind !== "constant" || F.value.kind !== "constant") return S;
+                if (S.value.value === void 0 || F.value.value === void 0) return new xu(this, { kind: "constant", value: void 0 }, S.parameters);
+                let te = Lo[this.specification.type];
+                if (te) {
+                  let fe = te(S.value.value, F.value.value, W);
+                  return new xu(this, { kind: "constant", value: fe }, S.parameters);
+                }
+                return S;
+              }
+              evaluate(S, F, W, te, fe, pe) {
+                return S.kind === "constant" ? S.value : S.evaluate(F, W, te, fe, pe);
+              }
+            }
+            class Vc extends oo {
+              possiblyEvaluate(S, F, W, te) {
+                if (S.value === void 0) return new xu(this, { kind: "constant", value: void 0 }, F);
+                if (S.expression.kind === "constant") {
+                  let fe = S.expression.evaluate(F, null, {}, W, te), pe = S.property.specification.type === "resolvedImage" && typeof fe != "string" ? fe.name : fe, Fe = this._calculate(pe, pe, pe, F);
+                  return new xu(this, { kind: "constant", value: Fe }, F);
+                }
+                if (S.expression.kind === "camera") {
+                  let fe = this._calculate(S.expression.evaluate({ zoom: F.zoom - 1 }), S.expression.evaluate({ zoom: F.zoom }), S.expression.evaluate({ zoom: F.zoom + 1 }), F);
+                  return new xu(this, { kind: "constant", value: fe }, F);
+                }
+                return new xu(this, S.expression, F);
+              }
+              evaluate(S, F, W, te, fe, pe) {
+                if (S.kind === "source") {
+                  let Fe = S.evaluate(F, W, te, fe, pe);
+                  return this._calculate(Fe, Fe, Fe, F);
+                }
+                return S.kind === "composite" ? this._calculate(S.evaluate({ zoom: Math.floor(F.zoom) - 1 }, W, te), S.evaluate({ zoom: Math.floor(F.zoom) }, W, te), S.evaluate({ zoom: Math.floor(F.zoom) + 1 }, W, te), F) : S.value;
+              }
+              _calculate(S, F, W, te) {
+                return te.zoom > te.zoomHistory.lastIntegerZoom ? { from: S, to: F } : { from: W, to: F };
+              }
+              interpolate(S) {
+                return S;
+              }
+            }
+            class hc {
+              constructor(S) {
+                this.specification = S;
+              }
+              possiblyEvaluate(S, F, W, te) {
+                if (S.value !== void 0) {
+                  if (S.expression.kind === "constant") {
+                    let fe = S.expression.evaluate(F, null, {}, W, te);
+                    return this._calculate(fe, fe, fe, F);
+                  }
+                  return this._calculate(S.expression.evaluate(new rs(Math.floor(F.zoom - 1), F)), S.expression.evaluate(new rs(Math.floor(F.zoom), F)), S.expression.evaluate(new rs(Math.floor(F.zoom + 1), F)), F);
+                }
+              }
+              _calculate(S, F, W, te) {
+                return te.zoom > te.zoomHistory.lastIntegerZoom ? { from: S, to: F } : { from: W, to: F };
+              }
+              interpolate(S) {
+                return S;
+              }
+            }
+            class Ku {
+              constructor(S) {
+                this.specification = S;
+              }
+              possiblyEvaluate(S, F, W, te) {
+                return !!S.expression.evaluate(F, null, {}, W, te);
+              }
+              interpolate() {
+                return false;
+              }
+            }
+            class ue {
+              constructor(S) {
+                this.properties = S, this.defaultPropertyValues = {}, this.defaultTransitionablePropertyValues = {}, this.defaultTransitioningPropertyValues = {}, this.defaultPossiblyEvaluatedValues = {}, this.overridableProperties = [];
+                for (let F in S) {
+                  let W = S[F];
+                  W.specification.overridable && this.overridableProperties.push(F);
+                  let te = this.defaultPropertyValues[F] = new Ql(W, void 0), fe = this.defaultTransitionablePropertyValues[F] = new Cu(W);
+                  this.defaultTransitioningPropertyValues[F] = fe.untransitioned(), this.defaultPossiblyEvaluatedValues[F] = te.possiblyEvaluate({});
+                }
+              }
+            }
+            Fi("DataDrivenProperty", oo), Fi("DataConstantProperty", Ua), Fi("CrossFadedDataDrivenProperty", Vc), Fi("CrossFadedProperty", hc), Fi("ColorRampProperty", Ku);
+            let w = "-transition";
+            class B extends De {
+              constructor(S, F) {
+                if (super(), this.id = S.id, this.type = S.type, this._featureFilter = { filter: () => true, needGeometry: false }, S.type !== "custom" && (this.metadata = S.metadata, this.minzoom = S.minzoom, this.maxzoom = S.maxzoom, S.type !== "background" && (this.source = S.source, this.sourceLayer = S["source-layer"], this.filter = S.filter), F.layout && (this._unevaluatedLayout = new Uc(F.layout)), F.paint)) {
+                  this._transitionablePaint = new Yu(F.paint);
+                  for (let W in S.paint) this.setPaintProperty(W, S.paint[W], { validate: false });
+                  for (let W in S.layout) this.setLayoutProperty(W, S.layout[W], { validate: false });
+                  this._transitioningPaint = this._transitionablePaint.untransitioned(), this.paint = new Ac(F.paint);
+                }
+              }
+              getCrossfadeParameters() {
+                return this._crossfadeParameters;
+              }
+              getLayoutProperty(S) {
+                return S === "visibility" ? this.visibility : this._unevaluatedLayout.getValue(S);
+              }
+              setLayoutProperty(S, F, W = {}) {
+                F != null && this._validate(Nn, `layers.${this.id}.layout.${S}`, S, F, W) || (S !== "visibility" ? this._unevaluatedLayout.setValue(S, F) : this.visibility = F);
+              }
+              getPaintProperty(S) {
+                return S.endsWith(w) ? this._transitionablePaint.getTransition(S.slice(0, -11)) : this._transitionablePaint.getValue(S);
+              }
+              setPaintProperty(S, F, W = {}) {
+                if (F != null && this._validate(wn, `layers.${this.id}.paint.${S}`, S, F, W)) return false;
+                if (S.endsWith(w)) return this._transitionablePaint.setTransition(S.slice(0, -11), F || void 0), false;
+                {
+                  let te = this._transitionablePaint._values[S], fe = te.property.specification["property-type"] === "cross-faded-data-driven", pe = te.value.isDataDriven(), Fe = te.value;
+                  this._transitionablePaint.setValue(S, F), this._handleSpecialPaintPropertyUpdate(S);
+                  let Ke = this._transitionablePaint._values[S].value;
+                  return Ke.isDataDriven() || pe || fe || this._handleOverridablePaintPropertyUpdate(S, Fe, Ke);
+                }
+              }
+              _handleSpecialPaintPropertyUpdate(S) {
+              }
+              _handleOverridablePaintPropertyUpdate(S, F, W) {
+                return false;
+              }
+              isHidden(S) {
+                return !!(this.minzoom && S < this.minzoom) || !!(this.maxzoom && S >= this.maxzoom) || this.visibility === "none";
+              }
+              updateTransitions(S) {
+                this._transitioningPaint = this._transitionablePaint.transitioned(S, this._transitioningPaint);
+              }
+              hasTransition() {
+                return this._transitioningPaint.hasTransition();
+              }
+              recalculate(S, F) {
+                S.getCrossfadeParameters && (this._crossfadeParameters = S.getCrossfadeParameters()), this._unevaluatedLayout && (this.layout = this._unevaluatedLayout.possiblyEvaluate(S, void 0, F)), this.paint = this._transitioningPaint.possiblyEvaluate(S, void 0, F);
+              }
+              serialize() {
+                let S = { id: this.id, type: this.type, source: this.source, "source-layer": this.sourceLayer, metadata: this.metadata, minzoom: this.minzoom, maxzoom: this.maxzoom, filter: this.filter, layout: this._unevaluatedLayout && this._unevaluatedLayout.serialize(), paint: this._transitionablePaint && this._transitionablePaint.serialize() };
+                return this.visibility && (S.layout = S.layout || {}, S.layout.visibility = this.visibility), M(S, (F, W) => !(F === void 0 || W === "layout" && !Object.keys(F).length || W === "paint" && !Object.keys(F).length));
+              }
+              _validate(S, F, W, te, fe = {}) {
+                return (!fe || fe.validate !== false) && Yi(this, S.call(ki, { key: F, layerType: this.type, objectKey: W, value: te, styleSpec: ce, style: { glyphs: true, sprite: true } }));
+              }
+              is3D() {
+                return false;
+              }
+              isTileClipped() {
+                return false;
+              }
+              hasOffscreenPass() {
+                return false;
+              }
+              resize() {
+              }
+              isStateDependent() {
+                for (let S in this.paint._values) {
+                  let F = this.paint.get(S);
+                  if (F instanceof xu && Nl(F.property.specification) && (F.value.kind === "source" || F.value.kind === "composite") && F.value.isStateDependent) return true;
+                }
+                return false;
+              }
+            }
+            let Q = { Int8: Int8Array, Uint8: Uint8Array, Int16: Int16Array, Uint16: Uint16Array, Int32: Int32Array, Uint32: Uint32Array, Float32: Float32Array };
+            class ee {
+              constructor(S, F) {
+                this._structArray = S, this._pos1 = F * this.size, this._pos2 = this._pos1 / 2, this._pos4 = this._pos1 / 4, this._pos8 = this._pos1 / 8;
+              }
+            }
+            class le {
+              constructor() {
+                this.isTransferred = false, this.capacity = -1, this.resize(0);
+              }
+              static serialize(S, F) {
+                return S._trim(), F && (S.isTransferred = true, F.push(S.arrayBuffer)), { length: S.length, arrayBuffer: S.arrayBuffer };
+              }
+              static deserialize(S) {
+                let F = Object.create(this.prototype);
+                return F.arrayBuffer = S.arrayBuffer, F.length = S.length, F.capacity = S.arrayBuffer.byteLength / F.bytesPerElement, F._refreshViews(), F;
+              }
+              _trim() {
+                this.length !== this.capacity && (this.capacity = this.length, this.arrayBuffer = this.arrayBuffer.slice(0, this.length * this.bytesPerElement), this._refreshViews());
+              }
+              clear() {
+                this.length = 0;
+              }
+              resize(S) {
+                this.reserve(S), this.length = S;
+              }
+              reserve(S) {
+                if (S > this.capacity) {
+                  this.capacity = Math.max(S, Math.floor(5 * this.capacity), 128), this.arrayBuffer = new ArrayBuffer(this.capacity * this.bytesPerElement);
+                  let F = this.uint8;
+                  this._refreshViews(), F && this.uint8.set(F);
+                }
+              }
+              _refreshViews() {
+                throw new Error("_refreshViews() must be implemented by each concrete StructArray layout");
+              }
+            }
+            function Oe(R, S = 1) {
+              let F = 0, W = 0;
+              return { members: R.map((te) => {
+                let fe = Q[te.type].BYTES_PER_ELEMENT, pe = F = Ze(F, Math.max(S, fe)), Fe = te.components || 1;
+                return W = Math.max(W, fe), F += fe * Fe, { name: te.name, type: te.type, components: Fe, offset: pe };
+              }), size: Ze(F, Math.max(W, S)), alignment: S };
+            }
+            function Ze(R, S) {
+              return Math.ceil(R / S) * S;
+            }
+            class st extends le {
+              _refreshViews() {
+                this.uint8 = new Uint8Array(this.arrayBuffer), this.int16 = new Int16Array(this.arrayBuffer);
+              }
+              emplaceBack(S, F) {
+                let W = this.length;
+                return this.resize(W + 1), this.emplace(W, S, F);
+              }
+              emplace(S, F, W) {
+                let te = 2 * S;
+                return this.int16[te + 0] = F, this.int16[te + 1] = W, S;
+              }
+            }
+            st.prototype.bytesPerElement = 4, Fi("StructArrayLayout2i4", st);
+            class Tt extends le {
+              _refreshViews() {
+                this.uint8 = new Uint8Array(this.arrayBuffer), this.int16 = new Int16Array(this.arrayBuffer);
+              }
+              emplaceBack(S, F, W) {
+                let te = this.length;
+                return this.resize(te + 1), this.emplace(te, S, F, W);
+              }
+              emplace(S, F, W, te) {
+                let fe = 3 * S;
+                return this.int16[fe + 0] = F, this.int16[fe + 1] = W, this.int16[fe + 2] = te, S;
+              }
+            }
+            Tt.prototype.bytesPerElement = 6, Fi("StructArrayLayout3i6", Tt);
+            class Yt extends le {
+              _refreshViews() {
+                this.uint8 = new Uint8Array(this.arrayBuffer), this.int16 = new Int16Array(this.arrayBuffer);
+              }
+              emplaceBack(S, F, W, te) {
+                let fe = this.length;
+                return this.resize(fe + 1), this.emplace(fe, S, F, W, te);
+              }
+              emplace(S, F, W, te, fe) {
+                let pe = 4 * S;
+                return this.int16[pe + 0] = F, this.int16[pe + 1] = W, this.int16[pe + 2] = te, this.int16[pe + 3] = fe, S;
+              }
+            }
+            Yt.prototype.bytesPerElement = 8, Fi("StructArrayLayout4i8", Yt);
+            class Kt extends le {
+              _refreshViews() {
+                this.uint8 = new Uint8Array(this.arrayBuffer), this.int16 = new Int16Array(this.arrayBuffer);
+              }
+              emplaceBack(S, F, W, te, fe, pe) {
+                let Fe = this.length;
+                return this.resize(Fe + 1), this.emplace(Fe, S, F, W, te, fe, pe);
+              }
+              emplace(S, F, W, te, fe, pe, Fe) {
+                let Ke = 6 * S;
+                return this.int16[Ke + 0] = F, this.int16[Ke + 1] = W, this.int16[Ke + 2] = te, this.int16[Ke + 3] = fe, this.int16[Ke + 4] = pe, this.int16[Ke + 5] = Fe, S;
+              }
+            }
+            Kt.prototype.bytesPerElement = 12, Fi("StructArrayLayout2i4i12", Kt);
+            class xr extends le {
+              _refreshViews() {
+                this.uint8 = new Uint8Array(this.arrayBuffer), this.int16 = new Int16Array(this.arrayBuffer);
+              }
+              emplaceBack(S, F, W, te, fe, pe) {
+                let Fe = this.length;
+                return this.resize(Fe + 1), this.emplace(Fe, S, F, W, te, fe, pe);
+              }
+              emplace(S, F, W, te, fe, pe, Fe) {
+                let Ke = 4 * S, ct = 8 * S;
+                return this.int16[Ke + 0] = F, this.int16[Ke + 1] = W, this.uint8[ct + 4] = te, this.uint8[ct + 5] = fe, this.uint8[ct + 6] = pe, this.uint8[ct + 7] = Fe, S;
+              }
+            }
+            xr.prototype.bytesPerElement = 8, Fi("StructArrayLayout2i4ub8", xr);
+            class Ir extends le {
+              _refreshViews() {
+                this.uint8 = new Uint8Array(this.arrayBuffer), this.float32 = new Float32Array(this.arrayBuffer);
+              }
+              emplaceBack(S, F) {
+                let W = this.length;
+                return this.resize(W + 1), this.emplace(W, S, F);
+              }
+              emplace(S, F, W) {
+                let te = 2 * S;
+                return this.float32[te + 0] = F, this.float32[te + 1] = W, S;
+              }
+            }
+            Ir.prototype.bytesPerElement = 8, Fi("StructArrayLayout2f8", Ir);
+            class ve extends le {
+              _refreshViews() {
+                this.uint8 = new Uint8Array(this.arrayBuffer), this.uint16 = new Uint16Array(this.arrayBuffer);
+              }
+              emplaceBack(S, F, W, te, fe, pe, Fe, Ke, ct, Lt) {
+                let Jt = this.length;
+                return this.resize(Jt + 1), this.emplace(Jt, S, F, W, te, fe, pe, Fe, Ke, ct, Lt);
+              }
+              emplace(S, F, W, te, fe, pe, Fe, Ke, ct, Lt, Jt) {
+                let cr = 10 * S;
+                return this.uint16[cr + 0] = F, this.uint16[cr + 1] = W, this.uint16[cr + 2] = te, this.uint16[cr + 3] = fe, this.uint16[cr + 4] = pe, this.uint16[cr + 5] = Fe, this.uint16[cr + 6] = Ke, this.uint16[cr + 7] = ct, this.uint16[cr + 8] = Lt, this.uint16[cr + 9] = Jt, S;
+              }
+            }
+            ve.prototype.bytesPerElement = 20, Fi("StructArrayLayout10ui20", ve);
+            class be extends le {
+              _refreshViews() {
+                this.uint8 = new Uint8Array(this.arrayBuffer), this.int16 = new Int16Array(this.arrayBuffer), this.uint16 = new Uint16Array(this.arrayBuffer);
+              }
+              emplaceBack(S, F, W, te, fe, pe, Fe, Ke, ct, Lt, Jt, cr) {
+                let mr = this.length;
+                return this.resize(mr + 1), this.emplace(mr, S, F, W, te, fe, pe, Fe, Ke, ct, Lt, Jt, cr);
+              }
+              emplace(S, F, W, te, fe, pe, Fe, Ke, ct, Lt, Jt, cr, mr) {
+                let Pr = 12 * S;
+                return this.int16[Pr + 0] = F, this.int16[Pr + 1] = W, this.int16[Pr + 2] = te, this.int16[Pr + 3] = fe, this.uint16[Pr + 4] = pe, this.uint16[Pr + 5] = Fe, this.uint16[Pr + 6] = Ke, this.uint16[Pr + 7] = ct, this.int16[Pr + 8] = Lt, this.int16[Pr + 9] = Jt, this.int16[Pr + 10] = cr, this.int16[Pr + 11] = mr, S;
+              }
+            }
+            be.prototype.bytesPerElement = 24, Fi("StructArrayLayout4i4ui4i24", be);
+            class Re extends le {
+              _refreshViews() {
+                this.uint8 = new Uint8Array(this.arrayBuffer), this.float32 = new Float32Array(this.arrayBuffer);
+              }
+              emplaceBack(S, F, W) {
+                let te = this.length;
+                return this.resize(te + 1), this.emplace(te, S, F, W);
+              }
+              emplace(S, F, W, te) {
+                let fe = 3 * S;
+                return this.float32[fe + 0] = F, this.float32[fe + 1] = W, this.float32[fe + 2] = te, S;
+              }
+            }
+            Re.prototype.bytesPerElement = 12, Fi("StructArrayLayout3f12", Re);
+            class qe extends le {
+              _refreshViews() {
+                this.uint8 = new Uint8Array(this.arrayBuffer), this.uint32 = new Uint32Array(this.arrayBuffer);
+              }
+              emplaceBack(S) {
+                let F = this.length;
+                return this.resize(F + 1), this.emplace(F, S);
+              }
+              emplace(S, F) {
+                return this.uint32[1 * S + 0] = F, S;
+              }
+            }
+            qe.prototype.bytesPerElement = 4, Fi("StructArrayLayout1ul4", qe);
+            class et extends le {
+              _refreshViews() {
+                this.uint8 = new Uint8Array(this.arrayBuffer), this.int16 = new Int16Array(this.arrayBuffer), this.uint32 = new Uint32Array(this.arrayBuffer), this.uint16 = new Uint16Array(this.arrayBuffer);
+              }
+              emplaceBack(S, F, W, te, fe, pe, Fe, Ke, ct) {
+                let Lt = this.length;
+                return this.resize(Lt + 1), this.emplace(Lt, S, F, W, te, fe, pe, Fe, Ke, ct);
+              }
+              emplace(S, F, W, te, fe, pe, Fe, Ke, ct, Lt) {
+                let Jt = 10 * S, cr = 5 * S;
+                return this.int16[Jt + 0] = F, this.int16[Jt + 1] = W, this.int16[Jt + 2] = te, this.int16[Jt + 3] = fe, this.int16[Jt + 4] = pe, this.int16[Jt + 5] = Fe, this.uint32[cr + 3] = Ke, this.uint16[Jt + 8] = ct, this.uint16[Jt + 9] = Lt, S;
+              }
+            }
+            et.prototype.bytesPerElement = 20, Fi("StructArrayLayout6i1ul2ui20", et);
+            class Xe extends le {
+              _refreshViews() {
+                this.uint8 = new Uint8Array(this.arrayBuffer), this.int16 = new Int16Array(this.arrayBuffer);
+              }
+              emplaceBack(S, F, W, te, fe, pe) {
+                let Fe = this.length;
+                return this.resize(Fe + 1), this.emplace(Fe, S, F, W, te, fe, pe);
+              }
+              emplace(S, F, W, te, fe, pe, Fe) {
+                let Ke = 6 * S;
+                return this.int16[Ke + 0] = F, this.int16[Ke + 1] = W, this.int16[Ke + 2] = te, this.int16[Ke + 3] = fe, this.int16[Ke + 4] = pe, this.int16[Ke + 5] = Fe, S;
+              }
+            }
+            Xe.prototype.bytesPerElement = 12, Fi("StructArrayLayout2i2i2i12", Xe);
+            class it extends le {
+              _refreshViews() {
+                this.uint8 = new Uint8Array(this.arrayBuffer), this.float32 = new Float32Array(this.arrayBuffer), this.int16 = new Int16Array(this.arrayBuffer);
+              }
+              emplaceBack(S, F, W, te, fe) {
+                let pe = this.length;
+                return this.resize(pe + 1), this.emplace(pe, S, F, W, te, fe);
+              }
+              emplace(S, F, W, te, fe, pe) {
+                let Fe = 4 * S, Ke = 8 * S;
+                return this.float32[Fe + 0] = F, this.float32[Fe + 1] = W, this.float32[Fe + 2] = te, this.int16[Ke + 6] = fe, this.int16[Ke + 7] = pe, S;
+              }
+            }
+            it.prototype.bytesPerElement = 16, Fi("StructArrayLayout2f1f2i16", it);
+            class Ft extends le {
+              _refreshViews() {
+                this.uint8 = new Uint8Array(this.arrayBuffer), this.float32 = new Float32Array(this.arrayBuffer), this.int16 = new Int16Array(this.arrayBuffer);
+              }
+              emplaceBack(S, F, W, te, fe, pe) {
+                let Fe = this.length;
+                return this.resize(Fe + 1), this.emplace(Fe, S, F, W, te, fe, pe);
+              }
+              emplace(S, F, W, te, fe, pe, Fe) {
+                let Ke = 16 * S, ct = 4 * S, Lt = 8 * S;
+                return this.uint8[Ke + 0] = F, this.uint8[Ke + 1] = W, this.float32[ct + 1] = te, this.float32[ct + 2] = fe, this.int16[Lt + 6] = pe, this.int16[Lt + 7] = Fe, S;
+              }
+            }
+            Ft.prototype.bytesPerElement = 16, Fi("StructArrayLayout2ub2f2i16", Ft);
+            class Ht extends le {
+              _refreshViews() {
+                this.uint8 = new Uint8Array(this.arrayBuffer), this.uint16 = new Uint16Array(this.arrayBuffer);
+              }
+              emplaceBack(S, F, W) {
+                let te = this.length;
+                return this.resize(te + 1), this.emplace(te, S, F, W);
+              }
+              emplace(S, F, W, te) {
+                let fe = 3 * S;
+                return this.uint16[fe + 0] = F, this.uint16[fe + 1] = W, this.uint16[fe + 2] = te, S;
+              }
+            }
+            Ht.prototype.bytesPerElement = 6, Fi("StructArrayLayout3ui6", Ht);
+            class tr extends le {
+              _refreshViews() {
+                this.uint8 = new Uint8Array(this.arrayBuffer), this.int16 = new Int16Array(this.arrayBuffer), this.uint16 = new Uint16Array(this.arrayBuffer), this.uint32 = new Uint32Array(this.arrayBuffer), this.float32 = new Float32Array(this.arrayBuffer);
+              }
+              emplaceBack(S, F, W, te, fe, pe, Fe, Ke, ct, Lt, Jt, cr, mr, Pr, zr, ui, yi) {
+                let vn = this.length;
+                return this.resize(vn + 1), this.emplace(vn, S, F, W, te, fe, pe, Fe, Ke, ct, Lt, Jt, cr, mr, Pr, zr, ui, yi);
+              }
+              emplace(S, F, W, te, fe, pe, Fe, Ke, ct, Lt, Jt, cr, mr, Pr, zr, ui, yi, vn) {
+                let zi = 24 * S, un = 12 * S, Tn = 48 * S;
+                return this.int16[zi + 0] = F, this.int16[zi + 1] = W, this.uint16[zi + 2] = te, this.uint16[zi + 3] = fe, this.uint32[un + 2] = pe, this.uint32[un + 3] = Fe, this.uint32[un + 4] = Ke, this.uint16[zi + 10] = ct, this.uint16[zi + 11] = Lt, this.uint16[zi + 12] = Jt, this.float32[un + 7] = cr, this.float32[un + 8] = mr, this.uint8[Tn + 36] = Pr, this.uint8[Tn + 37] = zr, this.uint8[Tn + 38] = ui, this.uint32[un + 10] = yi, this.int16[zi + 22] = vn, S;
+              }
+            }
+            tr.prototype.bytesPerElement = 48, Fi("StructArrayLayout2i2ui3ul3ui2f3ub1ul1i48", tr);
+            class dr extends le {
+              _refreshViews() {
+                this.uint8 = new Uint8Array(this.arrayBuffer), this.int16 = new Int16Array(this.arrayBuffer), this.uint16 = new Uint16Array(this.arrayBuffer), this.uint32 = new Uint32Array(this.arrayBuffer), this.float32 = new Float32Array(this.arrayBuffer);
+              }
+              emplaceBack(S, F, W, te, fe, pe, Fe, Ke, ct, Lt, Jt, cr, mr, Pr, zr, ui, yi, vn, zi, un, Tn, pa, ro, Vo, Xa, sa, Mo, fo) {
+                let lo = this.length;
+                return this.resize(lo + 1), this.emplace(lo, S, F, W, te, fe, pe, Fe, Ke, ct, Lt, Jt, cr, mr, Pr, zr, ui, yi, vn, zi, un, Tn, pa, ro, Vo, Xa, sa, Mo, fo);
+              }
+              emplace(S, F, W, te, fe, pe, Fe, Ke, ct, Lt, Jt, cr, mr, Pr, zr, ui, yi, vn, zi, un, Tn, pa, ro, Vo, Xa, sa, Mo, fo, lo) {
+                let Xn = 32 * S, Ro = 16 * S;
+                return this.int16[Xn + 0] = F, this.int16[Xn + 1] = W, this.int16[Xn + 2] = te, this.int16[Xn + 3] = fe, this.int16[Xn + 4] = pe, this.int16[Xn + 5] = Fe, this.int16[Xn + 6] = Ke, this.int16[Xn + 7] = ct, this.uint16[Xn + 8] = Lt, this.uint16[Xn + 9] = Jt, this.uint16[Xn + 10] = cr, this.uint16[Xn + 11] = mr, this.uint16[Xn + 12] = Pr, this.uint16[Xn + 13] = zr, this.uint16[Xn + 14] = ui, this.uint16[Xn + 15] = yi, this.uint16[Xn + 16] = vn, this.uint16[Xn + 17] = zi, this.uint16[Xn + 18] = un, this.uint16[Xn + 19] = Tn, this.uint16[Xn + 20] = pa, this.uint16[Xn + 21] = ro, this.uint16[Xn + 22] = Vo, this.uint32[Ro + 12] = Xa, this.float32[Ro + 13] = sa, this.float32[Ro + 14] = Mo, this.uint16[Xn + 30] = fo, this.uint16[Xn + 31] = lo, S;
+              }
+            }
+            dr.prototype.bytesPerElement = 64, Fi("StructArrayLayout8i15ui1ul2f2ui64", dr);
+            class Sr extends le {
+              _refreshViews() {
+                this.uint8 = new Uint8Array(this.arrayBuffer), this.float32 = new Float32Array(this.arrayBuffer);
+              }
+              emplaceBack(S) {
+                let F = this.length;
+                return this.resize(F + 1), this.emplace(F, S);
+              }
+              emplace(S, F) {
+                return this.float32[1 * S + 0] = F, S;
+              }
+            }
+            Sr.prototype.bytesPerElement = 4, Fi("StructArrayLayout1f4", Sr);
+            class Or extends le {
+              _refreshViews() {
+                this.uint8 = new Uint8Array(this.arrayBuffer), this.uint16 = new Uint16Array(this.arrayBuffer), this.float32 = new Float32Array(this.arrayBuffer);
+              }
+              emplaceBack(S, F, W) {
+                let te = this.length;
+                return this.resize(te + 1), this.emplace(te, S, F, W);
+              }
+              emplace(S, F, W, te) {
+                let fe = 3 * S;
+                return this.uint16[6 * S + 0] = F, this.float32[fe + 1] = W, this.float32[fe + 2] = te, S;
+              }
+            }
+            Or.prototype.bytesPerElement = 12, Fi("StructArrayLayout1ui2f12", Or);
+            class Wr extends le {
+              _refreshViews() {
+                this.uint8 = new Uint8Array(this.arrayBuffer), this.uint32 = new Uint32Array(this.arrayBuffer), this.uint16 = new Uint16Array(this.arrayBuffer);
+              }
+              emplaceBack(S, F, W) {
+                let te = this.length;
+                return this.resize(te + 1), this.emplace(te, S, F, W);
+              }
+              emplace(S, F, W, te) {
+                let fe = 4 * S;
+                return this.uint32[2 * S + 0] = F, this.uint16[fe + 2] = W, this.uint16[fe + 3] = te, S;
+              }
+            }
+            Wr.prototype.bytesPerElement = 8, Fi("StructArrayLayout1ul2ui8", Wr);
+            class ni extends le {
+              _refreshViews() {
+                this.uint8 = new Uint8Array(this.arrayBuffer), this.uint16 = new Uint16Array(this.arrayBuffer);
+              }
+              emplaceBack(S, F) {
+                let W = this.length;
+                return this.resize(W + 1), this.emplace(W, S, F);
+              }
+              emplace(S, F, W) {
+                let te = 2 * S;
+                return this.uint16[te + 0] = F, this.uint16[te + 1] = W, S;
+              }
+            }
+            ni.prototype.bytesPerElement = 4, Fi("StructArrayLayout2ui4", ni);
+            class Pi extends le {
+              _refreshViews() {
+                this.uint8 = new Uint8Array(this.arrayBuffer), this.uint16 = new Uint16Array(this.arrayBuffer);
+              }
+              emplaceBack(S) {
+                let F = this.length;
+                return this.resize(F + 1), this.emplace(F, S);
+              }
+              emplace(S, F) {
+                return this.uint16[1 * S + 0] = F, S;
+              }
+            }
+            Pi.prototype.bytesPerElement = 2, Fi("StructArrayLayout1ui2", Pi);
+            class cn extends le {
+              _refreshViews() {
+                this.uint8 = new Uint8Array(this.arrayBuffer), this.float32 = new Float32Array(this.arrayBuffer);
+              }
+              emplaceBack(S, F, W, te) {
+                let fe = this.length;
+                return this.resize(fe + 1), this.emplace(fe, S, F, W, te);
+              }
+              emplace(S, F, W, te, fe) {
+                let pe = 4 * S;
+                return this.float32[pe + 0] = F, this.float32[pe + 1] = W, this.float32[pe + 2] = te, this.float32[pe + 3] = fe, S;
+              }
+            }
+            cn.prototype.bytesPerElement = 16, Fi("StructArrayLayout4f16", cn);
+            class ln extends ee {
+              get anchorPointX() {
+                return this._structArray.int16[this._pos2 + 0];
+              }
+              get anchorPointY() {
+                return this._structArray.int16[this._pos2 + 1];
+              }
+              get x1() {
+                return this._structArray.int16[this._pos2 + 2];
+              }
+              get y1() {
+                return this._structArray.int16[this._pos2 + 3];
+              }
+              get x2() {
+                return this._structArray.int16[this._pos2 + 4];
+              }
+              get y2() {
+                return this._structArray.int16[this._pos2 + 5];
+              }
+              get featureIndex() {
+                return this._structArray.uint32[this._pos4 + 3];
+              }
+              get sourceLayerIndex() {
+                return this._structArray.uint16[this._pos2 + 8];
+              }
+              get bucketIndex() {
+                return this._structArray.uint16[this._pos2 + 9];
+              }
+              get anchorPoint() {
+                return new u(this.anchorPointX, this.anchorPointY);
+              }
+            }
+            ln.prototype.size = 20;
+            class Cn extends et {
+              get(S) {
+                return new ln(this, S);
+              }
+            }
+            Fi("CollisionBoxArray", Cn);
+            class Kn extends ee {
+              get anchorX() {
+                return this._structArray.int16[this._pos2 + 0];
+              }
+              get anchorY() {
+                return this._structArray.int16[this._pos2 + 1];
+              }
+              get glyphStartIndex() {
+                return this._structArray.uint16[this._pos2 + 2];
+              }
+              get numGlyphs() {
+                return this._structArray.uint16[this._pos2 + 3];
+              }
+              get vertexStartIndex() {
+                return this._structArray.uint32[this._pos4 + 2];
+              }
+              get lineStartIndex() {
+                return this._structArray.uint32[this._pos4 + 3];
+              }
+              get lineLength() {
+                return this._structArray.uint32[this._pos4 + 4];
+              }
+              get segment() {
+                return this._structArray.uint16[this._pos2 + 10];
+              }
+              get lowerSize() {
+                return this._structArray.uint16[this._pos2 + 11];
+              }
+              get upperSize() {
+                return this._structArray.uint16[this._pos2 + 12];
+              }
+              get lineOffsetX() {
+                return this._structArray.float32[this._pos4 + 7];
+              }
+              get lineOffsetY() {
+                return this._structArray.float32[this._pos4 + 8];
+              }
+              get writingMode() {
+                return this._structArray.uint8[this._pos1 + 36];
+              }
+              get placedOrientation() {
+                return this._structArray.uint8[this._pos1 + 37];
+              }
+              set placedOrientation(S) {
+                this._structArray.uint8[this._pos1 + 37] = S;
+              }
+              get hidden() {
+                return this._structArray.uint8[this._pos1 + 38];
+              }
+              set hidden(S) {
+                this._structArray.uint8[this._pos1 + 38] = S;
+              }
+              get crossTileID() {
+                return this._structArray.uint32[this._pos4 + 10];
+              }
+              set crossTileID(S) {
+                this._structArray.uint32[this._pos4 + 10] = S;
+              }
+              get associatedIconIndex() {
+                return this._structArray.int16[this._pos2 + 22];
+              }
+            }
+            Kn.prototype.size = 48;
+            class Aa extends tr {
+              get(S) {
+                return new Kn(this, S);
+              }
+            }
+            Fi("PlacedSymbolArray", Aa);
+            class fa extends ee {
+              get anchorX() {
+                return this._structArray.int16[this._pos2 + 0];
+              }
+              get anchorY() {
+                return this._structArray.int16[this._pos2 + 1];
+              }
+              get rightJustifiedTextSymbolIndex() {
+                return this._structArray.int16[this._pos2 + 2];
+              }
+              get centerJustifiedTextSymbolIndex() {
+                return this._structArray.int16[this._pos2 + 3];
+              }
+              get leftJustifiedTextSymbolIndex() {
+                return this._structArray.int16[this._pos2 + 4];
+              }
+              get verticalPlacedTextSymbolIndex() {
+                return this._structArray.int16[this._pos2 + 5];
+              }
+              get placedIconSymbolIndex() {
+                return this._structArray.int16[this._pos2 + 6];
+              }
+              get verticalPlacedIconSymbolIndex() {
+                return this._structArray.int16[this._pos2 + 7];
+              }
+              get key() {
+                return this._structArray.uint16[this._pos2 + 8];
+              }
+              get textBoxStartIndex() {
+                return this._structArray.uint16[this._pos2 + 9];
+              }
+              get textBoxEndIndex() {
+                return this._structArray.uint16[this._pos2 + 10];
+              }
+              get verticalTextBoxStartIndex() {
+                return this._structArray.uint16[this._pos2 + 11];
+              }
+              get verticalTextBoxEndIndex() {
+                return this._structArray.uint16[this._pos2 + 12];
+              }
+              get iconBoxStartIndex() {
+                return this._structArray.uint16[this._pos2 + 13];
+              }
+              get iconBoxEndIndex() {
+                return this._structArray.uint16[this._pos2 + 14];
+              }
+              get verticalIconBoxStartIndex() {
+                return this._structArray.uint16[this._pos2 + 15];
+              }
+              get verticalIconBoxEndIndex() {
+                return this._structArray.uint16[this._pos2 + 16];
+              }
+              get featureIndex() {
+                return this._structArray.uint16[this._pos2 + 17];
+              }
+              get numHorizontalGlyphVertices() {
+                return this._structArray.uint16[this._pos2 + 18];
+              }
+              get numVerticalGlyphVertices() {
+                return this._structArray.uint16[this._pos2 + 19];
+              }
+              get numIconVertices() {
+                return this._structArray.uint16[this._pos2 + 20];
+              }
+              get numVerticalIconVertices() {
+                return this._structArray.uint16[this._pos2 + 21];
+              }
+              get useRuntimeCollisionCircles() {
+                return this._structArray.uint16[this._pos2 + 22];
+              }
+              get crossTileID() {
+                return this._structArray.uint32[this._pos4 + 12];
+              }
+              set crossTileID(S) {
+                this._structArray.uint32[this._pos4 + 12] = S;
+              }
+              get textBoxScale() {
+                return this._structArray.float32[this._pos4 + 13];
+              }
+              get collisionCircleDiameter() {
+                return this._structArray.float32[this._pos4 + 14];
+              }
+              get textAnchorOffsetStartIndex() {
+                return this._structArray.uint16[this._pos2 + 30];
+              }
+              get textAnchorOffsetEndIndex() {
+                return this._structArray.uint16[this._pos2 + 31];
+              }
+            }
+            fa.prototype.size = 64;
+            class $a extends dr {
+              get(S) {
+                return new fa(this, S);
+              }
+            }
+            Fi("SymbolInstanceArray", $a);
+            class Co extends Sr {
+              getoffsetX(S) {
+                return this.float32[1 * S + 0];
+              }
+            }
+            Fi("GlyphOffsetArray", Co);
+            class Qa extends Tt {
+              getx(S) {
+                return this.int16[3 * S + 0];
+              }
+              gety(S) {
+                return this.int16[3 * S + 1];
+              }
+              gettileUnitDistanceFromAnchor(S) {
+                return this.int16[3 * S + 2];
+              }
+            }
+            Fi("SymbolLineVertexArray", Qa);
+            class mo extends ee {
+              get textAnchor() {
+                return this._structArray.uint16[this._pos2 + 0];
+              }
+              get textOffset0() {
+                return this._structArray.float32[this._pos4 + 1];
+              }
+              get textOffset1() {
+                return this._structArray.float32[this._pos4 + 2];
+              }
+            }
+            mo.prototype.size = 12;
+            class Bo extends Or {
+              get(S) {
+                return new mo(this, S);
+              }
+            }
+            Fi("TextAnchorOffsetArray", Bo);
+            class Ps extends ee {
+              get featureIndex() {
+                return this._structArray.uint32[this._pos4 + 0];
+              }
+              get sourceLayerIndex() {
+                return this._structArray.uint16[this._pos2 + 2];
+              }
+              get bucketIndex() {
+                return this._structArray.uint16[this._pos2 + 3];
+              }
+            }
+            Ps.prototype.size = 8;
+            class Ts extends Wr {
+              get(S) {
+                return new Ps(this, S);
+              }
+            }
+            Fi("FeatureIndexArray", Ts);
+            class wo extends st {
+            }
+            class To extends st {
+            }
+            class hl extends st {
+            }
+            class Ul extends Kt {
+            }
+            class Lu extends xr {
+            }
+            class au extends Ir {
+            }
+            class Js extends ve {
+            }
+            class eu extends be {
+            }
+            class dc extends Re {
+            }
+            class Tl extends qe {
+            }
+            class Al extends Xe {
+            }
+            class X extends Ft {
+            }
+            class se extends Ht {
+            }
+            class Te extends ni {
+            }
+            let Ne = Oe([{ name: "a_pos", components: 2, type: "Int16" }], 4), { members: He } = Ne;
+            class Ye {
+              constructor(S = []) {
+                this.segments = S;
+              }
+              prepareSegment(S, F, W, te) {
+                let fe = this.segments[this.segments.length - 1];
+                return S > Ye.MAX_VERTEX_ARRAY_LENGTH && A(`Max vertices per segment is ${Ye.MAX_VERTEX_ARRAY_LENGTH}: bucket requested ${S}`), (!fe || fe.vertexLength + S > Ye.MAX_VERTEX_ARRAY_LENGTH || fe.sortKey !== te) && (fe = { vertexOffset: F.length, primitiveOffset: W.length, vertexLength: 0, primitiveLength: 0 }, te !== void 0 && (fe.sortKey = te), this.segments.push(fe)), fe;
+              }
+              get() {
+                return this.segments;
+              }
+              destroy() {
+                for (let S of this.segments) for (let F in S.vaos) S.vaos[F].destroy();
+              }
+              static simpleSegment(S, F, W, te) {
+                return new Ye([{ vertexOffset: S, primitiveOffset: F, vertexLength: W, primitiveLength: te, vaos: {}, sortKey: 0 }]);
+              }
+            }
+            function kt(R, S) {
+              return 256 * (R = E(Math.floor(R), 0, 255)) + E(Math.floor(S), 0, 255);
+            }
+            Ye.MAX_VERTEX_ARRAY_LENGTH = Math.pow(2, 16) - 1, Fi("SegmentVector", Ye);
+            let nt = Oe([{ name: "a_pattern_from", components: 4, type: "Uint16" }, { name: "a_pattern_to", components: 4, type: "Uint16" }, { name: "a_pixel_ratio_from", components: 1, type: "Uint16" }, { name: "a_pixel_ratio_to", components: 1, type: "Uint16" }]);
+            var jt = { exports: {} }, gr = { exports: {} };
+            gr.exports = function(R, S) {
+              var F, W, te, fe, pe, Fe, Ke, ct;
+              for (W = R.length - (F = 3 & R.length), te = S, pe = 3432918353, Fe = 461845907, ct = 0; ct < W; ) Ke = 255 & R.charCodeAt(ct) | (255 & R.charCodeAt(++ct)) << 8 | (255 & R.charCodeAt(++ct)) << 16 | (255 & R.charCodeAt(++ct)) << 24, ++ct, te = 27492 + (65535 & (fe = 5 * (65535 & (te = (te ^= Ke = (65535 & (Ke = (Ke = (65535 & Ke) * pe + (((Ke >>> 16) * pe & 65535) << 16) & 4294967295) << 15 | Ke >>> 17)) * Fe + (((Ke >>> 16) * Fe & 65535) << 16) & 4294967295) << 13 | te >>> 19)) + ((5 * (te >>> 16) & 65535) << 16) & 4294967295)) + ((58964 + (fe >>> 16) & 65535) << 16);
+              switch (Ke = 0, F) {
+                case 3:
+                  Ke ^= (255 & R.charCodeAt(ct + 2)) << 16;
+                case 2:
+                  Ke ^= (255 & R.charCodeAt(ct + 1)) << 8;
+                case 1:
+                  te ^= Ke = (65535 & (Ke = (Ke = (65535 & (Ke ^= 255 & R.charCodeAt(ct))) * pe + (((Ke >>> 16) * pe & 65535) << 16) & 4294967295) << 15 | Ke >>> 17)) * Fe + (((Ke >>> 16) * Fe & 65535) << 16) & 4294967295;
+              }
+              return te ^= R.length, te = 2246822507 * (65535 & (te ^= te >>> 16)) + ((2246822507 * (te >>> 16) & 65535) << 16) & 4294967295, te = 3266489909 * (65535 & (te ^= te >>> 13)) + ((3266489909 * (te >>> 16) & 65535) << 16) & 4294967295, (te ^= te >>> 16) >>> 0;
+            };
+            var yr = gr.exports, Hr = { exports: {} };
+            Hr.exports = function(R, S) {
+              for (var F, W = R.length, te = S ^ W, fe = 0; W >= 4; ) F = 1540483477 * (65535 & (F = 255 & R.charCodeAt(fe) | (255 & R.charCodeAt(++fe)) << 8 | (255 & R.charCodeAt(++fe)) << 16 | (255 & R.charCodeAt(++fe)) << 24)) + ((1540483477 * (F >>> 16) & 65535) << 16), te = 1540483477 * (65535 & te) + ((1540483477 * (te >>> 16) & 65535) << 16) ^ (F = 1540483477 * (65535 & (F ^= F >>> 24)) + ((1540483477 * (F >>> 16) & 65535) << 16)), W -= 4, ++fe;
+              switch (W) {
+                case 3:
+                  te ^= (255 & R.charCodeAt(fe + 2)) << 16;
+                case 2:
+                  te ^= (255 & R.charCodeAt(fe + 1)) << 8;
+                case 1:
+                  te = 1540483477 * (65535 & (te ^= 255 & R.charCodeAt(fe))) + ((1540483477 * (te >>> 16) & 65535) << 16);
+              }
+              return te = 1540483477 * (65535 & (te ^= te >>> 13)) + ((1540483477 * (te >>> 16) & 65535) << 16), (te ^= te >>> 15) >>> 0;
+            };
+            var qr = yr, _i = Hr.exports;
+            jt.exports = qr, jt.exports.murmur3 = qr, jt.exports.murmur2 = _i;
+            var bi = o(jt.exports);
+            class Zr {
+              constructor() {
+                this.ids = [], this.positions = [], this.indexed = false;
+              }
+              add(S, F, W, te) {
+                this.ids.push(ai(S)), this.positions.push(F, W, te);
+              }
+              getPositions(S) {
+                if (!this.indexed) throw new Error("Trying to get index, but feature positions are not indexed");
+                let F = ai(S), W = 0, te = this.ids.length - 1;
+                for (; W < te; ) {
+                  let pe = W + te >> 1;
+                  this.ids[pe] >= F ? te = pe : W = pe + 1;
+                }
+                let fe = [];
+                for (; this.ids[W] === F; ) fe.push({ index: this.positions[3 * W], start: this.positions[3 * W + 1], end: this.positions[3 * W + 2] }), W++;
+                return fe;
+              }
+              static serialize(S, F) {
+                let W = new Float64Array(S.ids), te = new Uint32Array(S.positions);
+                return gi(W, te, 0, W.length - 1), F && F.push(W.buffer, te.buffer), { ids: W, positions: te };
+              }
+              static deserialize(S) {
+                let F = new Zr();
+                return F.ids = S.ids, F.positions = S.positions, F.indexed = true, F;
+              }
+            }
+            function ai(R) {
+              let S = +R;
+              return !isNaN(S) && S <= Number.MAX_SAFE_INTEGER ? S : bi(String(R));
+            }
+            function gi(R, S, F, W) {
+              for (; F < W; ) {
+                let te = R[F + W >> 1], fe = F - 1, pe = W + 1;
+                for (; ; ) {
+                  do
+                    fe++;
+                  while (R[fe] < te);
+                  do
+                    pe--;
+                  while (R[pe] > te);
+                  if (fe >= pe) break;
+                  Ii(R, fe, pe), Ii(S, 3 * fe, 3 * pe), Ii(S, 3 * fe + 1, 3 * pe + 1), Ii(S, 3 * fe + 2, 3 * pe + 2);
+                }
+                pe - F < W - pe ? (gi(R, S, F, pe), F = pe + 1) : (gi(R, S, pe + 1, W), W = pe);
+              }
+            }
+            function Ii(R, S, F) {
+              let W = R[S];
+              R[S] = R[F], R[F] = W;
+            }
+            Fi("FeaturePositionMap", Zr);
+            class Si {
+              constructor(S, F) {
+                this.gl = S.gl, this.location = F;
+              }
+            }
+            class ei extends Si {
+              constructor(S, F) {
+                super(S, F), this.current = 0;
+              }
+              set(S) {
+                this.current !== S && (this.current = S, this.gl.uniform1f(this.location, S));
+              }
+            }
+            class Ln extends Si {
+              constructor(S, F) {
+                super(S, F), this.current = [0, 0, 0, 0];
+              }
+              set(S) {
+                S[0] === this.current[0] && S[1] === this.current[1] && S[2] === this.current[2] && S[3] === this.current[3] || (this.current = S, this.gl.uniform4f(this.location, S[0], S[1], S[2], S[3]));
+              }
+            }
+            class En extends Si {
+              constructor(S, F) {
+                super(S, F), this.current = nr.transparent;
+              }
+              set(S) {
+                S.r === this.current.r && S.g === this.current.g && S.b === this.current.b && S.a === this.current.a || (this.current = S, this.gl.uniform4f(this.location, S.r, S.g, S.b, S.a));
+              }
+            }
+            let Un = new Float32Array(16);
+            function ia(R) {
+              return [kt(255 * R.r, 255 * R.g), kt(255 * R.b, 255 * R.a)];
+            }
+            class Ea {
+              constructor(S, F, W) {
+                this.value = S, this.uniformNames = F.map((te) => `u_${te}`), this.type = W;
+              }
+              setUniform(S, F, W) {
+                S.set(W.constantOr(this.value));
+              }
+              getBinding(S, F, W) {
+                return this.type === "color" ? new En(S, F) : new ei(S, F);
+              }
+            }
+            class Ia {
+              constructor(S, F) {
+                this.uniformNames = F.map((W) => `u_${W}`), this.patternFrom = null, this.patternTo = null, this.pixelRatioFrom = 1, this.pixelRatioTo = 1;
+              }
+              setConstantPatternPositions(S, F) {
+                this.pixelRatioFrom = F.pixelRatio, this.pixelRatioTo = S.pixelRatio, this.patternFrom = F.tlbr, this.patternTo = S.tlbr;
+              }
+              setUniform(S, F, W, te) {
+                let fe = te === "u_pattern_to" ? this.patternTo : te === "u_pattern_from" ? this.patternFrom : te === "u_pixel_ratio_to" ? this.pixelRatioTo : te === "u_pixel_ratio_from" ? this.pixelRatioFrom : null;
+                fe && S.set(fe);
+              }
+              getBinding(S, F, W) {
+                return W.substr(0, 9) === "u_pattern" ? new Ln(S, F) : new ei(S, F);
+              }
+            }
+            class yo {
+              constructor(S, F, W, te) {
+                this.expression = S, this.type = W, this.maxValue = 0, this.paintVertexAttributes = F.map((fe) => ({ name: `a_${fe}`, type: "Float32", components: W === "color" ? 2 : 1, offset: 0 })), this.paintVertexArray = new te();
+              }
+              populatePaintArray(S, F, W, te, fe) {
+                let pe = this.paintVertexArray.length, Fe = this.expression.evaluate(new rs(0), F, {}, te, [], fe);
+                this.paintVertexArray.resize(S), this._setPaintValue(pe, S, Fe);
+              }
+              updatePaintArray(S, F, W, te) {
+                let fe = this.expression.evaluate({ zoom: 0 }, W, te);
+                this._setPaintValue(S, F, fe);
+              }
+              _setPaintValue(S, F, W) {
+                if (this.type === "color") {
+                  let te = ia(W);
+                  for (let fe = S; fe < F; fe++) this.paintVertexArray.emplace(fe, te[0], te[1]);
+                } else {
+                  for (let te = S; te < F; te++) this.paintVertexArray.emplace(te, W);
+                  this.maxValue = Math.max(this.maxValue, Math.abs(W));
+                }
+              }
+              upload(S) {
+                this.paintVertexArray && this.paintVertexArray.arrayBuffer && (this.paintVertexBuffer && this.paintVertexBuffer.buffer ? this.paintVertexBuffer.updateData(this.paintVertexArray) : this.paintVertexBuffer = S.createVertexBuffer(this.paintVertexArray, this.paintVertexAttributes, this.expression.isStateDependent));
+              }
+              destroy() {
+                this.paintVertexBuffer && this.paintVertexBuffer.destroy();
+              }
+            }
+            class Da {
+              constructor(S, F, W, te, fe, pe) {
+                this.expression = S, this.uniformNames = F.map((Fe) => `u_${Fe}_t`), this.type = W, this.useIntegerZoom = te, this.zoom = fe, this.maxValue = 0, this.paintVertexAttributes = F.map((Fe) => ({ name: `a_${Fe}`, type: "Float32", components: W === "color" ? 4 : 2, offset: 0 })), this.paintVertexArray = new pe();
+              }
+              populatePaintArray(S, F, W, te, fe) {
+                let pe = this.expression.evaluate(new rs(this.zoom), F, {}, te, [], fe), Fe = this.expression.evaluate(new rs(this.zoom + 1), F, {}, te, [], fe), Ke = this.paintVertexArray.length;
+                this.paintVertexArray.resize(S), this._setPaintValue(Ke, S, pe, Fe);
+              }
+              updatePaintArray(S, F, W, te) {
+                let fe = this.expression.evaluate({ zoom: this.zoom }, W, te), pe = this.expression.evaluate({ zoom: this.zoom + 1 }, W, te);
+                this._setPaintValue(S, F, fe, pe);
+              }
+              _setPaintValue(S, F, W, te) {
+                if (this.type === "color") {
+                  let fe = ia(W), pe = ia(te);
+                  for (let Fe = S; Fe < F; Fe++) this.paintVertexArray.emplace(Fe, fe[0], fe[1], pe[0], pe[1]);
+                } else {
+                  for (let fe = S; fe < F; fe++) this.paintVertexArray.emplace(fe, W, te);
+                  this.maxValue = Math.max(this.maxValue, Math.abs(W), Math.abs(te));
+                }
+              }
+              upload(S) {
+                this.paintVertexArray && this.paintVertexArray.arrayBuffer && (this.paintVertexBuffer && this.paintVertexBuffer.buffer ? this.paintVertexBuffer.updateData(this.paintVertexArray) : this.paintVertexBuffer = S.createVertexBuffer(this.paintVertexArray, this.paintVertexAttributes, this.expression.isStateDependent));
+              }
+              destroy() {
+                this.paintVertexBuffer && this.paintVertexBuffer.destroy();
+              }
+              setUniform(S, F) {
+                let W = this.useIntegerZoom ? Math.floor(F.zoom) : F.zoom, te = E(this.expression.interpolationFactor(W, this.zoom, this.zoom + 1), 0, 1);
+                S.set(te);
+              }
+              getBinding(S, F, W) {
+                return new ei(S, F);
+              }
+            }
+            class go {
+              constructor(S, F, W, te, fe, pe) {
+                this.expression = S, this.type = F, this.useIntegerZoom = W, this.zoom = te, this.layerId = pe, this.zoomInPaintVertexArray = new fe(), this.zoomOutPaintVertexArray = new fe();
+              }
+              populatePaintArray(S, F, W) {
+                let te = this.zoomInPaintVertexArray.length;
+                this.zoomInPaintVertexArray.resize(S), this.zoomOutPaintVertexArray.resize(S), this._setPaintValues(te, S, F.patterns && F.patterns[this.layerId], W);
+              }
+              updatePaintArray(S, F, W, te, fe) {
+                this._setPaintValues(S, F, W.patterns && W.patterns[this.layerId], fe);
+              }
+              _setPaintValues(S, F, W, te) {
+                if (!te || !W) return;
+                let { min: fe, mid: pe, max: Fe } = W, Ke = te[fe], ct = te[pe], Lt = te[Fe];
+                if (Ke && ct && Lt) for (let Jt = S; Jt < F; Jt++) this.zoomInPaintVertexArray.emplace(Jt, ct.tl[0], ct.tl[1], ct.br[0], ct.br[1], Ke.tl[0], Ke.tl[1], Ke.br[0], Ke.br[1], ct.pixelRatio, Ke.pixelRatio), this.zoomOutPaintVertexArray.emplace(Jt, ct.tl[0], ct.tl[1], ct.br[0], ct.br[1], Lt.tl[0], Lt.tl[1], Lt.br[0], Lt.br[1], ct.pixelRatio, Lt.pixelRatio);
+              }
+              upload(S) {
+                this.zoomInPaintVertexArray && this.zoomInPaintVertexArray.arrayBuffer && this.zoomOutPaintVertexArray && this.zoomOutPaintVertexArray.arrayBuffer && (this.zoomInPaintVertexBuffer = S.createVertexBuffer(this.zoomInPaintVertexArray, nt.members, this.expression.isStateDependent), this.zoomOutPaintVertexBuffer = S.createVertexBuffer(this.zoomOutPaintVertexArray, nt.members, this.expression.isStateDependent));
+              }
+              destroy() {
+                this.zoomOutPaintVertexBuffer && this.zoomOutPaintVertexBuffer.destroy(), this.zoomInPaintVertexBuffer && this.zoomInPaintVertexBuffer.destroy();
+              }
+            }
+            class Is {
+              constructor(S, F, W) {
+                this.binders = {}, this._buffers = [];
+                let te = [];
+                for (let fe in S.paint._values) {
+                  if (!W(fe)) continue;
+                  let pe = S.paint.get(fe);
+                  if (!(pe instanceof xu && Nl(pe.property.specification))) continue;
+                  let Fe = Xs(fe, S.type), Ke = pe.value, ct = pe.property.specification.type, Lt = pe.property.useIntegerZoom, Jt = pe.property.specification["property-type"], cr = Jt === "cross-faded" || Jt === "cross-faded-data-driven";
+                  if (Ke.kind === "constant") this.binders[fe] = cr ? new Ia(Ke.value, Fe) : new Ea(Ke.value, Fe, ct), te.push(`/u_${fe}`);
+                  else if (Ke.kind === "source" || cr) {
+                    let mr = Gn(fe, ct, "source");
+                    this.binders[fe] = cr ? new go(Ke, ct, Lt, F, mr, S.id) : new yo(Ke, Fe, ct, mr), te.push(`/a_${fe}`);
+                  } else {
+                    let mr = Gn(fe, ct, "composite");
+                    this.binders[fe] = new Da(Ke, Fe, ct, Lt, F, mr), te.push(`/z_${fe}`);
+                  }
+                }
+                this.cacheKey = te.sort().join("");
+              }
+              getMaxValue(S) {
+                let F = this.binders[S];
+                return F instanceof yo || F instanceof Da ? F.maxValue : 0;
+              }
+              populatePaintArrays(S, F, W, te, fe) {
+                for (let pe in this.binders) {
+                  let Fe = this.binders[pe];
+                  (Fe instanceof yo || Fe instanceof Da || Fe instanceof go) && Fe.populatePaintArray(S, F, W, te, fe);
+                }
+              }
+              setConstantPatternPositions(S, F) {
+                for (let W in this.binders) {
+                  let te = this.binders[W];
+                  te instanceof Ia && te.setConstantPatternPositions(S, F);
+                }
+              }
+              updatePaintArrays(S, F, W, te, fe) {
+                let pe = false;
+                for (let Fe in S) {
+                  let Ke = F.getPositions(Fe);
+                  for (let ct of Ke) {
+                    let Lt = W.feature(ct.index);
+                    for (let Jt in this.binders) {
+                      let cr = this.binders[Jt];
+                      if ((cr instanceof yo || cr instanceof Da || cr instanceof go) && cr.expression.isStateDependent === true) {
+                        let mr = te.paint.get(Jt);
+                        cr.expression = mr.value, cr.updatePaintArray(ct.start, ct.end, Lt, S[Fe], fe), pe = true;
+                      }
+                    }
+                  }
+                }
+                return pe;
+              }
+              defines() {
+                let S = [];
+                for (let F in this.binders) {
+                  let W = this.binders[F];
+                  (W instanceof Ea || W instanceof Ia) && S.push(...W.uniformNames.map((te) => `#define HAS_UNIFORM_${te}`));
+                }
+                return S;
+              }
+              getBinderAttributes() {
+                let S = [];
+                for (let F in this.binders) {
+                  let W = this.binders[F];
+                  if (W instanceof yo || W instanceof Da) for (let te = 0; te < W.paintVertexAttributes.length; te++) S.push(W.paintVertexAttributes[te].name);
+                  else if (W instanceof go) for (let te = 0; te < nt.members.length; te++) S.push(nt.members[te].name);
+                }
+                return S;
+              }
+              getBinderUniforms() {
+                let S = [];
+                for (let F in this.binders) {
+                  let W = this.binders[F];
+                  if (W instanceof Ea || W instanceof Ia || W instanceof Da) for (let te of W.uniformNames) S.push(te);
+                }
+                return S;
+              }
+              getPaintVertexBuffers() {
+                return this._buffers;
+              }
+              getUniforms(S, F) {
+                let W = [];
+                for (let te in this.binders) {
+                  let fe = this.binders[te];
+                  if (fe instanceof Ea || fe instanceof Ia || fe instanceof Da) {
+                    for (let pe of fe.uniformNames) if (F[pe]) {
+                      let Fe = fe.getBinding(S, F[pe], pe);
+                      W.push({ name: pe, property: te, binding: Fe });
+                    }
+                  }
+                }
+                return W;
+              }
+              setUniforms(S, F, W, te) {
+                for (let { name: fe, property: pe, binding: Fe } of F) this.binders[pe].setUniform(Fe, te, W.get(pe), fe);
+              }
+              updatePaintBuffers(S) {
+                this._buffers = [];
+                for (let F in this.binders) {
+                  let W = this.binders[F];
+                  if (S && W instanceof go) {
+                    let te = S.fromScale === 2 ? W.zoomInPaintVertexBuffer : W.zoomOutPaintVertexBuffer;
+                    te && this._buffers.push(te);
+                  } else (W instanceof yo || W instanceof Da) && W.paintVertexBuffer && this._buffers.push(W.paintVertexBuffer);
+                }
+              }
+              upload(S) {
+                for (let F in this.binders) {
+                  let W = this.binders[F];
+                  (W instanceof yo || W instanceof Da || W instanceof go) && W.upload(S);
+                }
+                this.updatePaintBuffers();
+              }
+              destroy() {
+                for (let S in this.binders) {
+                  let F = this.binders[S];
+                  (F instanceof yo || F instanceof Da || F instanceof go) && F.destroy();
+                }
+              }
+            }
+            class Ms {
+              constructor(S, F, W = () => true) {
+                this.programConfigurations = {};
+                for (let te of S) this.programConfigurations[te.id] = new Is(te, F, W);
+                this.needsUpload = false, this._featureMap = new Zr(), this._bufferOffset = 0;
+              }
+              populatePaintArrays(S, F, W, te, fe, pe) {
+                for (let Fe in this.programConfigurations) this.programConfigurations[Fe].populatePaintArrays(S, F, te, fe, pe);
+                F.id !== void 0 && this._featureMap.add(F.id, W, this._bufferOffset, S), this._bufferOffset = S, this.needsUpload = true;
+              }
+              updatePaintArrays(S, F, W, te) {
+                for (let fe of W) this.needsUpload = this.programConfigurations[fe.id].updatePaintArrays(S, this._featureMap, F, fe, te) || this.needsUpload;
+              }
+              get(S) {
+                return this.programConfigurations[S];
+              }
+              upload(S) {
+                if (this.needsUpload) {
+                  for (let F in this.programConfigurations) this.programConfigurations[F].upload(S);
+                  this.needsUpload = false;
+                }
+              }
+              destroy() {
+                for (let S in this.programConfigurations) this.programConfigurations[S].destroy();
+              }
+            }
+            function Xs(R, S) {
+              return { "text-opacity": ["opacity"], "icon-opacity": ["opacity"], "text-color": ["fill_color"], "icon-color": ["fill_color"], "text-halo-color": ["halo_color"], "icon-halo-color": ["halo_color"], "text-halo-blur": ["halo_blur"], "icon-halo-blur": ["halo_blur"], "text-halo-width": ["halo_width"], "icon-halo-width": ["halo_width"], "line-gap-width": ["gapwidth"], "line-pattern": ["pattern_to", "pattern_from", "pixel_ratio_to", "pixel_ratio_from"], "fill-pattern": ["pattern_to", "pattern_from", "pixel_ratio_to", "pixel_ratio_from"], "fill-extrusion-pattern": ["pattern_to", "pattern_from", "pixel_ratio_to", "pixel_ratio_from"] }[R] || [R.replace(`${S}-`, "").replace(/-/g, "_")];
+            }
+            function Gn(R, S, F) {
+              let W = { color: { source: Ir, composite: cn }, number: { source: Sr, composite: Ir } }, te = function(fe) {
+                return { "line-pattern": { source: Js, composite: Js }, "fill-pattern": { source: Js, composite: Js }, "fill-extrusion-pattern": { source: Js, composite: Js } }[fe];
+              }(R);
+              return te && te[F] || W[S][F];
+            }
+            Fi("ConstantBinder", Ea), Fi("CrossFadedConstantBinder", Ia), Fi("SourceExpressionBinder", yo), Fi("CrossFadedCompositeBinder", go), Fi("CompositeExpressionBinder", Da), Fi("ProgramConfiguration", Is, { omit: ["_buffers"] }), Fi("ProgramConfigurationSet", Ms);
+            let ja = 8192, Fo = Math.pow(2, 14) - 1, Uo = -Fo - 1;
+            function $s(R) {
+              let S = ja / R.extent, F = R.loadGeometry();
+              for (let W = 0; W < F.length; W++) {
+                let te = F[W];
+                for (let fe = 0; fe < te.length; fe++) {
+                  let pe = te[fe], Fe = Math.round(pe.x * S), Ke = Math.round(pe.y * S);
+                  pe.x = E(Fe, Uo, Fo), pe.y = E(Ke, Uo, Fo), (Fe < pe.x || Fe > pe.x + 1 || Ke < pe.y || Ke > pe.y + 1) && A("Geometry exceeds allowed extent, reduce your vector tile buffer size");
+                }
+              }
+              return F;
+            }
+            function Sl(R, S) {
+              return { type: R.type, id: R.id, properties: R.properties, geometry: S ? $s(R) : [] };
+            }
+            function bu(R, S, F, W, te) {
+              R.emplaceBack(2 * S + (W + 1) / 2, 2 * F + (te + 1) / 2);
+            }
+            class dl {
+              constructor(S) {
+                this.zoom = S.zoom, this.overscaling = S.overscaling, this.layers = S.layers, this.layerIds = this.layers.map((F) => F.id), this.index = S.index, this.hasPattern = false, this.layoutVertexArray = new To(), this.indexArray = new se(), this.segments = new Ye(), this.programConfigurations = new Ms(S.layers, S.zoom), this.stateDependentLayerIds = this.layers.filter((F) => F.isStateDependent()).map((F) => F.id);
+              }
+              populate(S, F, W) {
+                let te = this.layers[0], fe = [], pe = null, Fe = false;
+                te.type === "circle" && (pe = te.layout.get("circle-sort-key"), Fe = !pe.isConstant());
+                for (let { feature: Ke, id: ct, index: Lt, sourceLayerIndex: Jt } of S) {
+                  let cr = this.layers[0]._featureFilter.needGeometry, mr = Sl(Ke, cr);
+                  if (!this.layers[0]._featureFilter.filter(new rs(this.zoom), mr, W)) continue;
+                  let Pr = Fe ? pe.evaluate(mr, {}, W) : void 0, zr = { id: ct, properties: Ke.properties, type: Ke.type, sourceLayerIndex: Jt, index: Lt, geometry: cr ? mr.geometry : $s(Ke), patterns: {}, sortKey: Pr };
+                  fe.push(zr);
+                }
+                Fe && fe.sort((Ke, ct) => Ke.sortKey - ct.sortKey);
+                for (let Ke of fe) {
+                  let { geometry: ct, index: Lt, sourceLayerIndex: Jt } = Ke, cr = S[Lt].feature;
+                  this.addFeature(Ke, ct, Lt, W), F.featureIndex.insert(cr, ct, Lt, Jt, this.index);
+                }
+              }
+              update(S, F, W) {
+                this.stateDependentLayers.length && this.programConfigurations.updatePaintArrays(S, F, this.stateDependentLayers, W);
+              }
+              isEmpty() {
+                return this.layoutVertexArray.length === 0;
+              }
+              uploadPending() {
+                return !this.uploaded || this.programConfigurations.needsUpload;
+              }
+              upload(S) {
+                this.uploaded || (this.layoutVertexBuffer = S.createVertexBuffer(this.layoutVertexArray, He), this.indexBuffer = S.createIndexBuffer(this.indexArray)), this.programConfigurations.upload(S), this.uploaded = true;
+              }
+              destroy() {
+                this.layoutVertexBuffer && (this.layoutVertexBuffer.destroy(), this.indexBuffer.destroy(), this.programConfigurations.destroy(), this.segments.destroy());
+              }
+              addFeature(S, F, W, te) {
+                for (let fe of F) for (let pe of fe) {
+                  let Fe = pe.x, Ke = pe.y;
+                  if (Fe < 0 || Fe >= ja || Ke < 0 || Ke >= ja) continue;
+                  let ct = this.segments.prepareSegment(4, this.layoutVertexArray, this.indexArray, S.sortKey), Lt = ct.vertexLength;
+                  bu(this.layoutVertexArray, Fe, Ke, -1, -1), bu(this.layoutVertexArray, Fe, Ke, 1, -1), bu(this.layoutVertexArray, Fe, Ke, 1, 1), bu(this.layoutVertexArray, Fe, Ke, -1, 1), this.indexArray.emplaceBack(Lt, Lt + 1, Lt + 2), this.indexArray.emplaceBack(Lt, Lt + 3, Lt + 2), ct.vertexLength += 4, ct.primitiveLength += 2;
+                }
+                this.programConfigurations.populatePaintArrays(this.layoutVertexArray.length, S, W, {}, te);
+              }
+            }
+            function Sc(R, S) {
+              for (let F = 0; F < R.length; F++) if (Ui(S, R[F])) return true;
+              for (let F = 0; F < S.length; F++) if (Ui(R, S[F])) return true;
+              return !!Rr(R, S);
+            }
+            function Me(R, S, F) {
+              return !!Ui(R, S) || !!Nr(S, R, F);
+            }
+            function bt(R, S) {
+              if (R.length === 1) return mi(S, R[0]);
+              for (let F = 0; F < S.length; F++) {
+                let W = S[F];
+                for (let te = 0; te < W.length; te++) if (Ui(R, W[te])) return true;
+              }
+              for (let F = 0; F < R.length; F++) if (mi(S, R[F])) return true;
+              for (let F = 0; F < S.length; F++) if (Rr(R, S[F])) return true;
+              return false;
+            }
+            function zt(R, S, F) {
+              if (R.length > 1) {
+                if (Rr(R, S)) return true;
+                for (let W = 0; W < S.length; W++) if (Nr(S[W], R, F)) return true;
+              }
+              for (let W = 0; W < R.length; W++) if (Nr(R[W], S, F)) return true;
+              return false;
+            }
+            function Rr(R, S) {
+              if (R.length === 0 || S.length === 0) return false;
+              for (let F = 0; F < R.length - 1; F++) {
+                let W = R[F], te = R[F + 1];
+                for (let fe = 0; fe < S.length - 1; fe++) if (jr(W, te, S[fe], S[fe + 1])) return true;
+              }
+              return false;
+            }
+            function jr(R, S, F, W) {
+              return z(R, F, W) !== z(S, F, W) && z(R, S, F) !== z(R, S, W);
+            }
+            function Nr(R, S, F) {
+              let W = F * F;
+              if (S.length === 1) return R.distSqr(S[0]) < W;
+              for (let te = 1; te < S.length; te++) if (Gr(R, S[te - 1], S[te]) < W) return true;
+              return false;
+            }
+            function Gr(R, S, F) {
+              let W = S.distSqr(F);
+              if (W === 0) return R.distSqr(S);
+              let te = ((R.x - S.x) * (F.x - S.x) + (R.y - S.y) * (F.y - S.y)) / W;
+              return R.distSqr(te < 0 ? S : te > 1 ? F : F.sub(S)._mult(te)._add(S));
+            }
+            function mi(R, S) {
+              let F, W, te, fe = false;
+              for (let pe = 0; pe < R.length; pe++) {
+                F = R[pe];
+                for (let Fe = 0, Ke = F.length - 1; Fe < F.length; Ke = Fe++) W = F[Fe], te = F[Ke], W.y > S.y != te.y > S.y && S.x < (te.x - W.x) * (S.y - W.y) / (te.y - W.y) + W.x && (fe = !fe);
+              }
+              return fe;
+            }
+            function Ui(R, S) {
+              let F = false;
+              for (let W = 0, te = R.length - 1; W < R.length; te = W++) {
+                let fe = R[W], pe = R[te];
+                fe.y > S.y != pe.y > S.y && S.x < (pe.x - fe.x) * (S.y - fe.y) / (pe.y - fe.y) + fe.x && (F = !F);
+              }
+              return F;
+            }
+            function qi(R, S, F) {
+              let W = F[0], te = F[2];
+              if (R.x < W.x && S.x < W.x || R.x > te.x && S.x > te.x || R.y < W.y && S.y < W.y || R.y > te.y && S.y > te.y) return false;
+              let fe = z(R, S, F[0]);
+              return fe !== z(R, S, F[1]) || fe !== z(R, S, F[2]) || fe !== z(R, S, F[3]);
+            }
+            function Ei(R, S, F) {
+              let W = S.paint.get(R).value;
+              return W.kind === "constant" ? W.value : F.programConfigurations.get(S.id).getMaxValue(R);
+            }
+            function Hn(R) {
+              return Math.sqrt(R[0] * R[0] + R[1] * R[1]);
+            }
+            function en(R, S, F, W, te) {
+              if (!S[0] && !S[1]) return R;
+              let fe = u.convert(S)._mult(te);
+              F === "viewport" && fe._rotate(-W);
+              let pe = [];
+              for (let Fe = 0; Fe < R.length; Fe++) pe.push(R[Fe].sub(fe));
+              return pe;
+            }
+            let Wi, si;
+            Fi("CircleBucket", dl, { omit: ["layers"] });
+            var Mr = { get paint() {
+              return si = si || new ue({ "circle-radius": new oo(ce.paint_circle["circle-radius"]), "circle-color": new oo(ce.paint_circle["circle-color"]), "circle-blur": new oo(ce.paint_circle["circle-blur"]), "circle-opacity": new oo(ce.paint_circle["circle-opacity"]), "circle-translate": new Ua(ce.paint_circle["circle-translate"]), "circle-translate-anchor": new Ua(ce.paint_circle["circle-translate-anchor"]), "circle-pitch-scale": new Ua(ce.paint_circle["circle-pitch-scale"]), "circle-pitch-alignment": new Ua(ce.paint_circle["circle-pitch-alignment"]), "circle-stroke-width": new oo(ce.paint_circle["circle-stroke-width"]), "circle-stroke-color": new oo(ce.paint_circle["circle-stroke-color"]), "circle-stroke-opacity": new oo(ce.paint_circle["circle-stroke-opacity"]) });
+            }, get layout() {
+              return Wi = Wi || new ue({ "circle-sort-key": new oo(ce.layout_circle["circle-sort-key"]) });
+            } }, Yr = 1e-6, xi = typeof Float32Array != "undefined" ? Float32Array : Array;
+            function Ri(R) {
+              return R[0] = 1, R[1] = 0, R[2] = 0, R[3] = 0, R[4] = 0, R[5] = 1, R[6] = 0, R[7] = 0, R[8] = 0, R[9] = 0, R[10] = 1, R[11] = 0, R[12] = 0, R[13] = 0, R[14] = 0, R[15] = 1, R;
+            }
+            function ci(R, S, F) {
+              var W = S[0], te = S[1], fe = S[2], pe = S[3], Fe = S[4], Ke = S[5], ct = S[6], Lt = S[7], Jt = S[8], cr = S[9], mr = S[10], Pr = S[11], zr = S[12], ui = S[13], yi = S[14], vn = S[15], zi = F[0], un = F[1], Tn = F[2], pa = F[3];
+              return R[0] = zi * W + un * Fe + Tn * Jt + pa * zr, R[1] = zi * te + un * Ke + Tn * cr + pa * ui, R[2] = zi * fe + un * ct + Tn * mr + pa * yi, R[3] = zi * pe + un * Lt + Tn * Pr + pa * vn, R[4] = (zi = F[4]) * W + (un = F[5]) * Fe + (Tn = F[6]) * Jt + (pa = F[7]) * zr, R[5] = zi * te + un * Ke + Tn * cr + pa * ui, R[6] = zi * fe + un * ct + Tn * mr + pa * yi, R[7] = zi * pe + un * Lt + Tn * Pr + pa * vn, R[8] = (zi = F[8]) * W + (un = F[9]) * Fe + (Tn = F[10]) * Jt + (pa = F[11]) * zr, R[9] = zi * te + un * Ke + Tn * cr + pa * ui, R[10] = zi * fe + un * ct + Tn * mr + pa * yi, R[11] = zi * pe + un * Lt + Tn * Pr + pa * vn, R[12] = (zi = F[12]) * W + (un = F[13]) * Fe + (Tn = F[14]) * Jt + (pa = F[15]) * zr, R[13] = zi * te + un * Ke + Tn * cr + pa * ui, R[14] = zi * fe + un * ct + Tn * mr + pa * yi, R[15] = zi * pe + un * Lt + Tn * Pr + pa * vn, R;
+            }
+            Math.hypot || (Math.hypot = function() {
+              for (var R = 0, S = arguments.length; S--; ) R += arguments[S] * arguments[S];
+              return Math.sqrt(R);
+            });
+            var an, Zi = ci;
+            function Bn(R, S, F) {
+              var W = S[0], te = S[1], fe = S[2], pe = S[3];
+              return R[0] = F[0] * W + F[4] * te + F[8] * fe + F[12] * pe, R[1] = F[1] * W + F[5] * te + F[9] * fe + F[13] * pe, R[2] = F[2] * W + F[6] * te + F[10] * fe + F[14] * pe, R[3] = F[3] * W + F[7] * te + F[11] * fe + F[15] * pe, R;
+            }
+            an = new xi(4), xi != Float32Array && (an[0] = 0, an[1] = 0, an[2] = 0, an[3] = 0);
+            class hi extends B {
+              constructor(S) {
+                super(S, Mr);
+              }
+              createBucket(S) {
+                return new dl(S);
+              }
+              queryRadius(S) {
+                let F = S;
+                return Ei("circle-radius", this, F) + Ei("circle-stroke-width", this, F) + Hn(this.paint.get("circle-translate"));
+              }
+              queryIntersectsFeature(S, F, W, te, fe, pe, Fe, Ke) {
+                let ct = en(S, this.paint.get("circle-translate"), this.paint.get("circle-translate-anchor"), pe.angle, Fe), Lt = this.paint.get("circle-radius").evaluate(F, W) + this.paint.get("circle-stroke-width").evaluate(F, W), Jt = this.paint.get("circle-pitch-alignment") === "map", cr = Jt ? ct : function(Pr, zr) {
+                  return Pr.map((ui) => li(ui, zr));
+                }(ct, Ke), mr = Jt ? Lt * Fe : Lt;
+                for (let Pr of te) for (let zr of Pr) {
+                  let ui = Jt ? zr : li(zr, Ke), yi = mr, vn = Bn([], [zr.x, zr.y, 0, 1], Ke);
+                  if (this.paint.get("circle-pitch-scale") === "viewport" && this.paint.get("circle-pitch-alignment") === "map" ? yi *= vn[3] / pe.cameraToCenterDistance : this.paint.get("circle-pitch-scale") === "map" && this.paint.get("circle-pitch-alignment") === "viewport" && (yi *= pe.cameraToCenterDistance / vn[3]), Me(cr, ui, yi)) return true;
+                }
+                return false;
+              }
+            }
+            function li(R, S) {
+              let F = Bn([], [R.x, R.y, 0, 1], S);
+              return new u(F[0] / F[3], F[1] / F[3]);
+            }
+            class mn extends dl {
+            }
+            let Ji;
+            Fi("HeatmapBucket", mn, { omit: ["layers"] });
+            var Vi = { get paint() {
+              return Ji = Ji || new ue({ "heatmap-radius": new oo(ce.paint_heatmap["heatmap-radius"]), "heatmap-weight": new oo(ce.paint_heatmap["heatmap-weight"]), "heatmap-intensity": new Ua(ce.paint_heatmap["heatmap-intensity"]), "heatmap-color": new Ku(ce.paint_heatmap["heatmap-color"]), "heatmap-opacity": new Ua(ce.paint_heatmap["heatmap-opacity"]) });
+            } };
+            function Ni(R, { width: S, height: F }, W, te) {
+              if (te) {
+                if (te instanceof Uint8ClampedArray) te = new Uint8Array(te.buffer);
+                else if (te.length !== S * F * W) throw new RangeError(`mismatched image size. expected: ${te.length} but got: ${S * F * W}`);
+              } else te = new Uint8Array(S * F * W);
+              return R.width = S, R.height = F, R.data = te, R;
+            }
+            function pn(R, { width: S, height: F }, W) {
+              if (S === R.width && F === R.height) return;
+              let te = Ni({}, { width: S, height: F }, W);
+              Vn(R, te, { x: 0, y: 0 }, { x: 0, y: 0 }, { width: Math.min(R.width, S), height: Math.min(R.height, F) }, W), R.width = S, R.height = F, R.data = te.data;
+            }
+            function Vn(R, S, F, W, te, fe) {
+              if (te.width === 0 || te.height === 0) return S;
+              if (te.width > R.width || te.height > R.height || F.x > R.width - te.width || F.y > R.height - te.height) throw new RangeError("out of range source coordinates for image copy");
+              if (te.width > S.width || te.height > S.height || W.x > S.width - te.width || W.y > S.height - te.height) throw new RangeError("out of range destination coordinates for image copy");
+              let pe = R.data, Fe = S.data;
+              if (pe === Fe) throw new Error("srcData equals dstData, so image is already copied");
+              for (let Ke = 0; Ke < te.height; Ke++) {
+                let ct = ((F.y + Ke) * R.width + F.x) * fe, Lt = ((W.y + Ke) * S.width + W.x) * fe;
+                for (let Jt = 0; Jt < te.width * fe; Jt++) Fe[Lt + Jt] = pe[ct + Jt];
+              }
+              return S;
+            }
+            class na {
+              constructor(S, F) {
+                Ni(this, S, 1, F);
+              }
+              resize(S) {
+                pn(this, S, 1);
+              }
+              clone() {
+                return new na({ width: this.width, height: this.height }, new Uint8Array(this.data));
+              }
+              static copy(S, F, W, te, fe) {
+                Vn(S, F, W, te, fe, 1);
+              }
+            }
+            class Ki {
+              constructor(S, F) {
+                Ni(this, S, 4, F);
+              }
+              resize(S) {
+                pn(this, S, 4);
+              }
+              replace(S, F) {
+                F ? this.data.set(S) : this.data = S instanceof Uint8ClampedArray ? new Uint8Array(S.buffer) : S;
+              }
+              clone() {
+                return new Ki({ width: this.width, height: this.height }, new Uint8Array(this.data));
+              }
+              static copy(S, F, W, te, fe) {
+                Vn(S, F, W, te, fe, 4);
+              }
+            }
+            function kn(R) {
+              let S = {}, F = R.resolution || 256, W = R.clips ? R.clips.length : 1, te = R.image || new Ki({ width: F, height: W });
+              if (Math.log(F) / Math.LN2 % 1 != 0) throw new Error(`width is not a power of 2 - ${F}`);
+              let fe = (pe, Fe, Ke) => {
+                S[R.evaluationKey] = Ke;
+                let ct = R.expression.evaluate(S);
+                te.data[pe + Fe + 0] = Math.floor(255 * ct.r / ct.a), te.data[pe + Fe + 1] = Math.floor(255 * ct.g / ct.a), te.data[pe + Fe + 2] = Math.floor(255 * ct.b / ct.a), te.data[pe + Fe + 3] = Math.floor(255 * ct.a);
+              };
+              if (R.clips) for (let pe = 0, Fe = 0; pe < W; ++pe, Fe += 4 * F) for (let Ke = 0, ct = 0; Ke < F; Ke++, ct += 4) {
+                let Lt = Ke / (F - 1), { start: Jt, end: cr } = R.clips[pe];
+                fe(Fe, ct, Jt * (1 - Lt) + cr * Lt);
+              }
+              else for (let pe = 0, Fe = 0; pe < F; pe++, Fe += 4) fe(0, Fe, pe / (F - 1));
+              return te;
+            }
+            Fi("AlphaImage", na), Fi("RGBAImage", Ki);
+            let ta = "big-fb";
+            class oa extends B {
+              createBucket(S) {
+                return new mn(S);
+              }
+              constructor(S) {
+                super(S, Vi), this.heatmapFbos = /* @__PURE__ */ new Map(), this._updateColorRamp();
+              }
+              _handleSpecialPaintPropertyUpdate(S) {
+                S === "heatmap-color" && this._updateColorRamp();
+              }
+              _updateColorRamp() {
+                this.colorRamp = kn({ expression: this._transitionablePaint._values["heatmap-color"].value.expression, evaluationKey: "heatmapDensity", image: this.colorRamp }), this.colorRampTexture = null;
+              }
+              resize() {
+                this.heatmapFbos.has(ta) && this.heatmapFbos.delete(ta);
+              }
+              queryRadius() {
+                return 0;
+              }
+              queryIntersectsFeature() {
+                return false;
+              }
+              hasOffscreenPass() {
+                return this.paint.get("heatmap-opacity") !== 0 && this.visibility !== "none";
+              }
+            }
+            let ba;
+            var is = { get paint() {
+              return ba = ba || new ue({ "hillshade-illumination-direction": new Ua(ce.paint_hillshade["hillshade-illumination-direction"]), "hillshade-illumination-anchor": new Ua(ce.paint_hillshade["hillshade-illumination-anchor"]), "hillshade-exaggeration": new Ua(ce.paint_hillshade["hillshade-exaggeration"]), "hillshade-shadow-color": new Ua(ce.paint_hillshade["hillshade-shadow-color"]), "hillshade-highlight-color": new Ua(ce.paint_hillshade["hillshade-highlight-color"]), "hillshade-accent-color": new Ua(ce.paint_hillshade["hillshade-accent-color"]) });
+            } };
+            class Zs extends B {
+              constructor(S) {
+                super(S, is);
+              }
+              hasOffscreenPass() {
+                return this.paint.get("hillshade-exaggeration") !== 0 && this.visibility !== "none";
+              }
+            }
+            let Va = Oe([{ name: "a_pos", components: 2, type: "Int16" }], 4), { members: Ml } = Va;
+            function zo(R, S, F = 2) {
+              let W = S && S.length, te = W ? S[0] * F : R.length, fe = Qs(R, 0, te, F, true), pe = [];
+              if (!fe || fe.next === fe.prev) return pe;
+              let Fe, Ke, ct;
+              if (W && (fe = function(Lt, Jt, cr, mr) {
+                let Pr = [];
+                for (let zr = 0, ui = Jt.length; zr < ui; zr++) {
+                  let yi = Qs(Lt, Jt[zr] * mr, zr < ui - 1 ? Jt[zr + 1] * mr : Lt.length, mr, false);
+                  yi === yi.next && (yi.steiner = true), Pr.push(J(yi));
+                }
+                Pr.sort(ol);
+                for (let zr = 0; zr < Pr.length; zr++) cr = io(Pr[zr], cr);
+                return cr;
+              }(R, S, fe, F)), R.length > 80 * F) {
+                Fe = 1 / 0, Ke = 1 / 0;
+                let Lt = -1 / 0, Jt = -1 / 0;
+                for (let cr = F; cr < te; cr += F) {
+                  let mr = R[cr], Pr = R[cr + 1];
+                  mr < Fe && (Fe = mr), Pr < Ke && (Ke = Pr), mr > Lt && (Lt = mr), Pr > Jt && (Jt = Pr);
+                }
+                ct = Math.max(Lt - Fe, Jt - Ke), ct = ct !== 0 ? 32767 / ct : 0;
+              }
+              return Vl(fe, pe, F, Fe, Ke, ct, 0), pe;
+            }
+            function Qs(R, S, F, W, te) {
+              let fe;
+              if (te === function(pe, Fe, Ke, ct) {
+                let Lt = 0;
+                for (let Jt = Fe, cr = Ke - ct; Jt < Ke; Jt += ct) Lt += (pe[cr] - pe[Jt]) * (pe[Jt + 1] + pe[cr + 1]), cr = Jt;
+                return Lt;
+              }(R, S, F, W) > 0) for (let pe = S; pe < F; pe += W) fe = qt(pe / W | 0, R[pe], R[pe + 1], fe);
+              else for (let pe = F - W; pe >= S; pe -= W) fe = qt(pe / W | 0, R[pe], R[pe + 1], fe);
+              return fe && ne(fe, fe.next) && (Ve(fe), fe = fe.next), fe;
+            }
+            function al(R, S) {
+              if (!R) return R;
+              S || (S = R);
+              let F, W = R;
+              do
+                if (F = false, W.steiner || !ne(W, W.next) && de(W.prev, W, W.next) !== 0) W = W.next;
+                else {
+                  if (Ve(W), W = S = W.prev, W === W.next) break;
+                  F = true;
+                }
+              while (F || W !== S);
+              return S;
+            }
+            function Vl(R, S, F, W, te, fe, pe) {
+              if (!R) return;
+              !pe && fe && function(Ke, ct, Lt, Jt) {
+                let cr = Ke;
+                do
+                  cr.z === 0 && (cr.z = D(cr.x, cr.y, ct, Lt, Jt)), cr.prevZ = cr.prev, cr.nextZ = cr.next, cr = cr.next;
+                while (cr !== Ke);
+                cr.prevZ.nextZ = null, cr.prevZ = null, function(mr) {
+                  let Pr, zr = 1;
+                  do {
+                    let ui, yi = mr;
+                    mr = null;
+                    let vn = null;
+                    for (Pr = 0; yi; ) {
+                      Pr++;
+                      let zi = yi, un = 0;
+                      for (let pa = 0; pa < zr && (un++, zi = zi.nextZ, zi); pa++) ;
+                      let Tn = zr;
+                      for (; un > 0 || Tn > 0 && zi; ) un !== 0 && (Tn === 0 || !zi || yi.z <= zi.z) ? (ui = yi, yi = yi.nextZ, un--) : (ui = zi, zi = zi.nextZ, Tn--), vn ? vn.nextZ = ui : mr = ui, ui.prevZ = vn, vn = ui;
+                      yi = zi;
+                    }
+                    vn.nextZ = null, zr *= 2;
+                  } while (Pr > 1);
+                }(cr);
+              }(R, W, te, fe);
+              let Fe = R;
+              for (; R.prev !== R.next; ) {
+                let Ke = R.prev, ct = R.next;
+                if (fe ? Vs(R, W, te, fe) : ss(R)) S.push(Ke.i, R.i, ct.i), Ve(R), R = ct.next, Fe = ct.next;
+                else if ((R = ct) === Fe) {
+                  pe ? pe === 1 ? Vl(R = Ys(al(R), S), S, F, W, te, fe, 2) : pe === 2 && wa(R, S, F, W, te, fe) : Vl(al(R), S, F, W, te, fe, 1);
+                  break;
+                }
+              }
+            }
+            function ss(R) {
+              let S = R.prev, F = R, W = R.next;
+              if (de(S, F, W) >= 0) return false;
+              let te = S.x, fe = F.x, pe = W.x, Fe = S.y, Ke = F.y, ct = W.y, Lt = te < fe ? te < pe ? te : pe : fe < pe ? fe : pe, Jt = Fe < Ke ? Fe < ct ? Fe : ct : Ke < ct ? Ke : ct, cr = te > fe ? te > pe ? te : pe : fe > pe ? fe : pe, mr = Fe > Ke ? Fe > ct ? Fe : ct : Ke > ct ? Ke : ct, Pr = W.next;
+              for (; Pr !== S; ) {
+                if (Pr.x >= Lt && Pr.x <= cr && Pr.y >= Jt && Pr.y <= mr && q(te, Fe, fe, Ke, pe, ct, Pr.x, Pr.y) && de(Pr.prev, Pr, Pr.next) >= 0) return false;
+                Pr = Pr.next;
+              }
+              return true;
+            }
+            function Vs(R, S, F, W) {
+              let te = R.prev, fe = R, pe = R.next;
+              if (de(te, fe, pe) >= 0) return false;
+              let Fe = te.x, Ke = fe.x, ct = pe.x, Lt = te.y, Jt = fe.y, cr = pe.y, mr = Fe < Ke ? Fe < ct ? Fe : ct : Ke < ct ? Ke : ct, Pr = Lt < Jt ? Lt < cr ? Lt : cr : Jt < cr ? Jt : cr, zr = Fe > Ke ? Fe > ct ? Fe : ct : Ke > ct ? Ke : ct, ui = Lt > Jt ? Lt > cr ? Lt : cr : Jt > cr ? Jt : cr, yi = D(mr, Pr, S, F, W), vn = D(zr, ui, S, F, W), zi = R.prevZ, un = R.nextZ;
+              for (; zi && zi.z >= yi && un && un.z <= vn; ) {
+                if (zi.x >= mr && zi.x <= zr && zi.y >= Pr && zi.y <= ui && zi !== te && zi !== pe && q(Fe, Lt, Ke, Jt, ct, cr, zi.x, zi.y) && de(zi.prev, zi, zi.next) >= 0 || (zi = zi.prevZ, un.x >= mr && un.x <= zr && un.y >= Pr && un.y <= ui && un !== te && un !== pe && q(Fe, Lt, Ke, Jt, ct, cr, un.x, un.y) && de(un.prev, un, un.next) >= 0)) return false;
+                un = un.nextZ;
+              }
+              for (; zi && zi.z >= yi; ) {
+                if (zi.x >= mr && zi.x <= zr && zi.y >= Pr && zi.y <= ui && zi !== te && zi !== pe && q(Fe, Lt, Ke, Jt, ct, cr, zi.x, zi.y) && de(zi.prev, zi, zi.next) >= 0) return false;
+                zi = zi.prevZ;
+              }
+              for (; un && un.z <= vn; ) {
+                if (un.x >= mr && un.x <= zr && un.y >= Pr && un.y <= ui && un !== te && un !== pe && q(Fe, Lt, Ke, Jt, ct, cr, un.x, un.y) && de(un.prev, un, un.next) >= 0) return false;
+                un = un.nextZ;
+              }
+              return true;
+            }
+            function Ys(R, S) {
+              let F = R;
+              do {
+                let W = F.prev, te = F.next.next;
+                !ne(W, te) && we(W, F, F.next, te) && Zt(W, te) && Zt(te, W) && (S.push(W.i, F.i, te.i), Ve(F), Ve(F.next), F = R = te), F = F.next;
+              } while (F !== R);
+              return al(F);
+            }
+            function wa(R, S, F, W, te, fe) {
+              let pe = R;
+              do {
+                let Fe = pe.next.next;
+                for (; Fe !== pe.prev; ) {
+                  if (pe.i !== Fe.i && K(pe, Fe)) {
+                    let Ke = hr(pe, Fe);
+                    return pe = al(pe, pe.next), Ke = al(Ke, Ke.next), Vl(pe, S, F, W, te, fe, 0), void Vl(Ke, S, F, W, te, fe, 0);
+                  }
+                  Fe = Fe.next;
+                }
+                pe = pe.next;
+              } while (pe !== R);
+            }
+            function ol(R, S) {
+              return R.x - S.x;
+            }
+            function io(R, S) {
+              let F = function(te, fe) {
+                let pe = fe, Fe = te.x, Ke = te.y, ct, Lt = -1 / 0;
+                do {
+                  if (Ke <= pe.y && Ke >= pe.next.y && pe.next.y !== pe.y) {
+                    let zr = pe.x + (Ke - pe.y) * (pe.next.x - pe.x) / (pe.next.y - pe.y);
+                    if (zr <= Fe && zr > Lt && (Lt = zr, ct = pe.x < pe.next.x ? pe : pe.next, zr === Fe)) return ct;
+                  }
+                  pe = pe.next;
+                } while (pe !== fe);
+                if (!ct) return null;
+                let Jt = ct, cr = ct.x, mr = ct.y, Pr = 1 / 0;
+                pe = ct;
+                do {
+                  if (Fe >= pe.x && pe.x >= cr && Fe !== pe.x && q(Ke < mr ? Fe : Lt, Ke, cr, mr, Ke < mr ? Lt : Fe, Ke, pe.x, pe.y)) {
+                    let zr = Math.abs(Ke - pe.y) / (Fe - pe.x);
+                    Zt(pe, te) && (zr < Pr || zr === Pr && (pe.x > ct.x || pe.x === ct.x && Y(ct, pe))) && (ct = pe, Pr = zr);
+                  }
+                  pe = pe.next;
+                } while (pe !== Jt);
+                return ct;
+              }(R, S);
+              if (!F) return S;
+              let W = hr(F, R);
+              return al(W, W.next), al(F, F.next);
+            }
+            function Y(R, S) {
+              return de(R.prev, R, S.prev) < 0 && de(S.next, R, R.next) < 0;
+            }
+            function D(R, S, F, W, te) {
+              return (R = 1431655765 & ((R = 858993459 & ((R = 252645135 & ((R = 16711935 & ((R = (R - F) * te | 0) | R << 8)) | R << 4)) | R << 2)) | R << 1)) | (S = 1431655765 & ((S = 858993459 & ((S = 252645135 & ((S = 16711935 & ((S = (S - W) * te | 0) | S << 8)) | S << 4)) | S << 2)) | S << 1)) << 1;
+            }
+            function J(R) {
+              let S = R, F = R;
+              do
+                (S.x < F.x || S.x === F.x && S.y < F.y) && (F = S), S = S.next;
+              while (S !== R);
+              return F;
+            }
+            function q(R, S, F, W, te, fe, pe, Fe) {
+              return (te - pe) * (S - Fe) >= (R - pe) * (fe - Fe) && (R - pe) * (W - Fe) >= (F - pe) * (S - Fe) && (F - pe) * (fe - Fe) >= (te - pe) * (W - Fe);
+            }
+            function K(R, S) {
+              return R.next.i !== S.i && R.prev.i !== S.i && !function(F, W) {
+                let te = F;
+                do {
+                  if (te.i !== F.i && te.next.i !== F.i && te.i !== W.i && te.next.i !== W.i && we(te, te.next, F, W)) return true;
+                  te = te.next;
+                } while (te !== F);
+                return false;
+              }(R, S) && (Zt(R, S) && Zt(S, R) && function(F, W) {
+                let te = F, fe = false, pe = (F.x + W.x) / 2, Fe = (F.y + W.y) / 2;
+                do
+                  te.y > Fe != te.next.y > Fe && te.next.y !== te.y && pe < (te.next.x - te.x) * (Fe - te.y) / (te.next.y - te.y) + te.x && (fe = !fe), te = te.next;
+                while (te !== F);
+                return fe;
+              }(R, S) && (de(R.prev, R, S.prev) || de(R, S.prev, S)) || ne(R, S) && de(R.prev, R, R.next) > 0 && de(S.prev, S, S.next) > 0);
+            }
+            function de(R, S, F) {
+              return (S.y - R.y) * (F.x - S.x) - (S.x - R.x) * (F.y - S.y);
+            }
+            function ne(R, S) {
+              return R.x === S.x && R.y === S.y;
+            }
+            function we(R, S, F, W) {
+              let te = ft(de(R, S, F)), fe = ft(de(R, S, W)), pe = ft(de(F, W, R)), Fe = ft(de(F, W, S));
+              return te !== fe && pe !== Fe || !(te !== 0 || !Ue(R, F, S)) || !(fe !== 0 || !Ue(R, W, S)) || !(pe !== 0 || !Ue(F, R, W)) || !(Fe !== 0 || !Ue(F, S, W));
+            }
+            function Ue(R, S, F) {
+              return S.x <= Math.max(R.x, F.x) && S.x >= Math.min(R.x, F.x) && S.y <= Math.max(R.y, F.y) && S.y >= Math.min(R.y, F.y);
+            }
+            function ft(R) {
+              return R > 0 ? 1 : R < 0 ? -1 : 0;
+            }
+            function Zt(R, S) {
+              return de(R.prev, R, R.next) < 0 ? de(R, S, R.next) >= 0 && de(R, R.prev, S) >= 0 : de(R, S, R.prev) < 0 || de(R, R.next, S) < 0;
+            }
+            function hr(R, S) {
+              let F = Qe(R.i, R.x, R.y), W = Qe(S.i, S.x, S.y), te = R.next, fe = S.prev;
+              return R.next = S, S.prev = R, F.next = te, te.prev = F, W.next = F, F.prev = W, fe.next = W, W.prev = fe, W;
+            }
+            function qt(R, S, F, W) {
+              let te = Qe(R, S, F);
+              return W ? (te.next = W.next, te.prev = W, W.next.prev = te, W.next = te) : (te.prev = te, te.next = te), te;
+            }
+            function Ve(R) {
+              R.next.prev = R.prev, R.prev.next = R.next, R.prevZ && (R.prevZ.nextZ = R.nextZ), R.nextZ && (R.nextZ.prevZ = R.prevZ);
+            }
+            function Qe(R, S, F) {
+              return { i: R, x: S, y: F, prev: null, next: null, z: 0, prevZ: null, nextZ: null, steiner: false };
+            }
+            function at(R, S, F) {
+              let W = F.patternDependencies, te = false;
+              for (let fe of S) {
+                let pe = fe.paint.get(`${R}-pattern`);
+                pe.isConstant() || (te = true);
+                let Fe = pe.constantOr(null);
+                Fe && (te = true, W[Fe.to] = true, W[Fe.from] = true);
+              }
+              return te;
+            }
+            function Ct(R, S, F, W, te) {
+              let fe = te.patternDependencies;
+              for (let pe of S) {
+                let Fe = pe.paint.get(`${R}-pattern`).value;
+                if (Fe.kind !== "constant") {
+                  let Ke = Fe.evaluate({ zoom: W - 1 }, F, {}, te.availableImages), ct = Fe.evaluate({ zoom: W }, F, {}, te.availableImages), Lt = Fe.evaluate({ zoom: W + 1 }, F, {}, te.availableImages);
+                  Ke = Ke && Ke.name ? Ke.name : Ke, ct = ct && ct.name ? ct.name : ct, Lt = Lt && Lt.name ? Lt.name : Lt, fe[Ke] = true, fe[ct] = true, fe[Lt] = true, F.patterns[pe.id] = { min: Ke, mid: ct, max: Lt };
+                }
+              }
+              return F;
+            }
+            class Ot {
+              constructor(S) {
+                this.zoom = S.zoom, this.overscaling = S.overscaling, this.layers = S.layers, this.layerIds = this.layers.map((F) => F.id), this.index = S.index, this.hasPattern = false, this.patternFeatures = [], this.layoutVertexArray = new hl(), this.indexArray = new se(), this.indexArray2 = new Te(), this.programConfigurations = new Ms(S.layers, S.zoom), this.segments = new Ye(), this.segments2 = new Ye(), this.stateDependentLayerIds = this.layers.filter((F) => F.isStateDependent()).map((F) => F.id);
+              }
+              populate(S, F, W) {
+                this.hasPattern = at("fill", this.layers, F);
+                let te = this.layers[0].layout.get("fill-sort-key"), fe = !te.isConstant(), pe = [];
+                for (let { feature: Fe, id: Ke, index: ct, sourceLayerIndex: Lt } of S) {
+                  let Jt = this.layers[0]._featureFilter.needGeometry, cr = Sl(Fe, Jt);
+                  if (!this.layers[0]._featureFilter.filter(new rs(this.zoom), cr, W)) continue;
+                  let mr = fe ? te.evaluate(cr, {}, W, F.availableImages) : void 0, Pr = { id: Ke, properties: Fe.properties, type: Fe.type, sourceLayerIndex: Lt, index: ct, geometry: Jt ? cr.geometry : $s(Fe), patterns: {}, sortKey: mr };
+                  pe.push(Pr);
+                }
+                fe && pe.sort((Fe, Ke) => Fe.sortKey - Ke.sortKey);
+                for (let Fe of pe) {
+                  let { geometry: Ke, index: ct, sourceLayerIndex: Lt } = Fe;
+                  if (this.hasPattern) {
+                    let Jt = Ct("fill", this.layers, Fe, this.zoom, F);
+                    this.patternFeatures.push(Jt);
+                  } else this.addFeature(Fe, Ke, ct, W, {});
+                  F.featureIndex.insert(S[ct].feature, Ke, ct, Lt, this.index);
+                }
+              }
+              update(S, F, W) {
+                this.stateDependentLayers.length && this.programConfigurations.updatePaintArrays(S, F, this.stateDependentLayers, W);
+              }
+              addFeatures(S, F, W) {
+                for (let te of this.patternFeatures) this.addFeature(te, te.geometry, te.index, F, W);
+              }
+              isEmpty() {
+                return this.layoutVertexArray.length === 0;
+              }
+              uploadPending() {
+                return !this.uploaded || this.programConfigurations.needsUpload;
+              }
+              upload(S) {
+                this.uploaded || (this.layoutVertexBuffer = S.createVertexBuffer(this.layoutVertexArray, Ml), this.indexBuffer = S.createIndexBuffer(this.indexArray), this.indexBuffer2 = S.createIndexBuffer(this.indexArray2)), this.programConfigurations.upload(S), this.uploaded = true;
+              }
+              destroy() {
+                this.layoutVertexBuffer && (this.layoutVertexBuffer.destroy(), this.indexBuffer.destroy(), this.indexBuffer2.destroy(), this.programConfigurations.destroy(), this.segments.destroy(), this.segments2.destroy());
+              }
+              addFeature(S, F, W, te, fe) {
+                for (let pe of Cf(F, 500)) {
+                  let Fe = 0;
+                  for (let mr of pe) Fe += mr.length;
+                  let Ke = this.segments.prepareSegment(Fe, this.layoutVertexArray, this.indexArray), ct = Ke.vertexLength, Lt = [], Jt = [];
+                  for (let mr of pe) {
+                    if (mr.length === 0) continue;
+                    mr !== pe[0] && Jt.push(Lt.length / 2);
+                    let Pr = this.segments2.prepareSegment(mr.length, this.layoutVertexArray, this.indexArray2), zr = Pr.vertexLength;
+                    this.layoutVertexArray.emplaceBack(mr[0].x, mr[0].y), this.indexArray2.emplaceBack(zr + mr.length - 1, zr), Lt.push(mr[0].x), Lt.push(mr[0].y);
+                    for (let ui = 1; ui < mr.length; ui++) this.layoutVertexArray.emplaceBack(mr[ui].x, mr[ui].y), this.indexArray2.emplaceBack(zr + ui - 1, zr + ui), Lt.push(mr[ui].x), Lt.push(mr[ui].y);
+                    Pr.vertexLength += mr.length, Pr.primitiveLength += mr.length;
+                  }
+                  let cr = zo(Lt, Jt);
+                  for (let mr = 0; mr < cr.length; mr += 3) this.indexArray.emplaceBack(ct + cr[mr], ct + cr[mr + 1], ct + cr[mr + 2]);
+                  Ke.vertexLength += Fe, Ke.primitiveLength += cr.length / 3;
+                }
+                this.programConfigurations.populatePaintArrays(this.layoutVertexArray.length, S, W, fe, te);
+              }
+            }
+            let Rt, Bt;
+            Fi("FillBucket", Ot, { omit: ["layers", "patternFeatures"] });
+            var Dt = { get paint() {
+              return Bt = Bt || new ue({ "fill-antialias": new Ua(ce.paint_fill["fill-antialias"]), "fill-opacity": new oo(ce.paint_fill["fill-opacity"]), "fill-color": new oo(ce.paint_fill["fill-color"]), "fill-outline-color": new oo(ce.paint_fill["fill-outline-color"]), "fill-translate": new Ua(ce.paint_fill["fill-translate"]), "fill-translate-anchor": new Ua(ce.paint_fill["fill-translate-anchor"]), "fill-pattern": new Vc(ce.paint_fill["fill-pattern"]) });
+            }, get layout() {
+              return Rt = Rt || new ue({ "fill-sort-key": new oo(ce.layout_fill["fill-sort-key"]) });
+            } };
+            class yt extends B {
+              constructor(S) {
+                super(S, Dt);
+              }
+              recalculate(S, F) {
+                super.recalculate(S, F);
+                let W = this.paint._values["fill-outline-color"];
+                W.value.kind === "constant" && W.value.value === void 0 && (this.paint._values["fill-outline-color"] = this.paint._values["fill-color"]);
+              }
+              createBucket(S) {
+                return new Ot(S);
+              }
+              queryRadius() {
+                return Hn(this.paint.get("fill-translate"));
+              }
+              queryIntersectsFeature(S, F, W, te, fe, pe, Fe) {
+                return bt(en(S, this.paint.get("fill-translate"), this.paint.get("fill-translate-anchor"), pe.angle, Fe), te);
+              }
+              isTileClipped() {
+                return true;
+              }
+            }
+            let Pt = Oe([{ name: "a_pos", components: 2, type: "Int16" }, { name: "a_normal_ed", components: 4, type: "Int16" }], 4), ht = Oe([{ name: "a_centroid", components: 2, type: "Int16" }], 4), { members: ur } = Pt;
+            var br = {}, Ur = s, Di = fi;
+            function fi(R, S, F, W, te) {
+              this.properties = {}, this.extent = F, this.type = 0, this._pbf = R, this._geometry = -1, this._keys = W, this._values = te, R.readFields(Ti, this, S);
+            }
+            function Ti(R, S, F) {
+              R == 1 ? S.id = F.readVarint() : R == 2 ? function(W, te) {
+                for (var fe = W.readVarint() + W.pos; W.pos < fe; ) {
+                  var pe = te._keys[W.readVarint()], Fe = te._values[W.readVarint()];
+                  te.properties[pe] = Fe;
+                }
+              }(F, S) : R == 3 ? S.type = F.readVarint() : R == 4 && (S._geometry = F.pos);
+            }
+            function gn(R) {
+              for (var S, F, W = 0, te = 0, fe = R.length, pe = fe - 1; te < fe; pe = te++) W += ((F = R[pe]).x - (S = R[te]).x) * (S.y + F.y);
+              return W;
+            }
+            fi.types = ["Unknown", "Point", "LineString", "Polygon"], fi.prototype.loadGeometry = function() {
+              var R = this._pbf;
+              R.pos = this._geometry;
+              for (var S, F = R.readVarint() + R.pos, W = 1, te = 0, fe = 0, pe = 0, Fe = []; R.pos < F; ) {
+                if (te <= 0) {
+                  var Ke = R.readVarint();
+                  W = 7 & Ke, te = Ke >> 3;
+                }
+                if (te--, W === 1 || W === 2) fe += R.readSVarint(), pe += R.readSVarint(), W === 1 && (S && Fe.push(S), S = []), S.push(new Ur(fe, pe));
+                else {
+                  if (W !== 7) throw new Error("unknown command " + W);
+                  S && S.push(S[0].clone());
+                }
+              }
+              return S && Fe.push(S), Fe;
+            }, fi.prototype.bbox = function() {
+              var R = this._pbf;
+              R.pos = this._geometry;
+              for (var S = R.readVarint() + R.pos, F = 1, W = 0, te = 0, fe = 0, pe = 1 / 0, Fe = -1 / 0, Ke = 1 / 0, ct = -1 / 0; R.pos < S; ) {
+                if (W <= 0) {
+                  var Lt = R.readVarint();
+                  F = 7 & Lt, W = Lt >> 3;
+                }
+                if (W--, F === 1 || F === 2) (te += R.readSVarint()) < pe && (pe = te), te > Fe && (Fe = te), (fe += R.readSVarint()) < Ke && (Ke = fe), fe > ct && (ct = fe);
+                else if (F !== 7) throw new Error("unknown command " + F);
+              }
+              return [pe, Ke, Fe, ct];
+            }, fi.prototype.toGeoJSON = function(R, S, F) {
+              var W, te, fe = this.extent * Math.pow(2, F), pe = this.extent * R, Fe = this.extent * S, Ke = this.loadGeometry(), ct = fi.types[this.type];
+              function Lt(mr) {
+                for (var Pr = 0; Pr < mr.length; Pr++) {
+                  var zr = mr[Pr];
+                  mr[Pr] = [360 * (zr.x + pe) / fe - 180, 360 / Math.PI * Math.atan(Math.exp((180 - 360 * (zr.y + Fe) / fe) * Math.PI / 180)) - 90];
+                }
+              }
+              switch (this.type) {
+                case 1:
+                  var Jt = [];
+                  for (W = 0; W < Ke.length; W++) Jt[W] = Ke[W][0];
+                  Lt(Ke = Jt);
+                  break;
+                case 2:
+                  for (W = 0; W < Ke.length; W++) Lt(Ke[W]);
+                  break;
+                case 3:
+                  for (Ke = function(mr) {
+                    var Pr = mr.length;
+                    if (Pr <= 1) return [mr];
+                    for (var zr, ui, yi = [], vn = 0; vn < Pr; vn++) {
+                      var zi = gn(mr[vn]);
+                      zi !== 0 && (ui === void 0 && (ui = zi < 0), ui === zi < 0 ? (zr && yi.push(zr), zr = [mr[vn]]) : zr.push(mr[vn]));
+                    }
+                    return zr && yi.push(zr), yi;
+                  }(Ke), W = 0; W < Ke.length; W++) for (te = 0; te < Ke[W].length; te++) Lt(Ke[W][te]);
+              }
+              Ke.length === 1 ? Ke = Ke[0] : ct = "Multi" + ct;
+              var cr = { type: "Feature", geometry: { type: ct, coordinates: Ke }, properties: this.properties };
+              return "id" in this && (cr.id = this.id), cr;
+            };
+            var rn = Di, Ci = Bi;
+            function Bi(R, S) {
+              this.version = 1, this.name = null, this.extent = 4096, this.length = 0, this._pbf = R, this._keys = [], this._values = [], this._features = [], R.readFields(Gi, this, S), this.length = this._features.length;
+            }
+            function Gi(R, S, F) {
+              R === 15 ? S.version = F.readVarint() : R === 1 ? S.name = F.readString() : R === 5 ? S.extent = F.readVarint() : R === 2 ? S._features.push(F.pos) : R === 3 ? S._keys.push(F.readString()) : R === 4 && S._values.push(function(W) {
+                for (var te = null, fe = W.readVarint() + W.pos; W.pos < fe; ) {
+                  var pe = W.readVarint() >> 3;
+                  te = pe === 1 ? W.readString() : pe === 2 ? W.readFloat() : pe === 3 ? W.readDouble() : pe === 4 ? W.readVarint64() : pe === 5 ? W.readVarint() : pe === 6 ? W.readSVarint() : pe === 7 ? W.readBoolean() : null;
+                }
+                return te;
+              }(F));
+            }
+            Bi.prototype.feature = function(R) {
+              if (R < 0 || R >= this._features.length) throw new Error("feature index out of bounds");
+              this._pbf.pos = this._features[R];
+              var S = this._pbf.readVarint() + this._pbf.pos;
+              return new rn(this._pbf, S, this.extent, this._keys, this._values);
+            };
+            var sn = Ci;
+            function zn(R, S, F) {
+              if (R === 3) {
+                var W = new sn(F, F.readVarint() + F.pos);
+                W.length && (S[W.name] = W);
+              }
+            }
+            br.VectorTile = function(R, S) {
+              this.layers = R.readFields(zn, {}, S);
+            }, br.VectorTileFeature = Di, br.VectorTileLayer = Ci;
+            let Ja = br.VectorTileFeature.types, co = Math.pow(2, 13);
+            function ts(R, S, F, W, te, fe, pe, Fe) {
+              R.emplaceBack(S, F, 2 * Math.floor(W * co) + pe, te * co * 2, fe * co * 2, Math.round(Fe));
+            }
+            class so {
+              constructor(S) {
+                this.zoom = S.zoom, this.overscaling = S.overscaling, this.layers = S.layers, this.layerIds = this.layers.map((F) => F.id), this.index = S.index, this.hasPattern = false, this.layoutVertexArray = new Ul(), this.centroidVertexArray = new wo(), this.indexArray = new se(), this.programConfigurations = new Ms(S.layers, S.zoom), this.segments = new Ye(), this.stateDependentLayerIds = this.layers.filter((F) => F.isStateDependent()).map((F) => F.id);
+              }
+              populate(S, F, W) {
+                this.features = [], this.hasPattern = at("fill-extrusion", this.layers, F);
+                for (let { feature: te, id: fe, index: pe, sourceLayerIndex: Fe } of S) {
+                  let Ke = this.layers[0]._featureFilter.needGeometry, ct = Sl(te, Ke);
+                  if (!this.layers[0]._featureFilter.filter(new rs(this.zoom), ct, W)) continue;
+                  let Lt = { id: fe, sourceLayerIndex: Fe, index: pe, geometry: Ke ? ct.geometry : $s(te), properties: te.properties, type: te.type, patterns: {} };
+                  this.hasPattern ? this.features.push(Ct("fill-extrusion", this.layers, Lt, this.zoom, F)) : this.addFeature(Lt, Lt.geometry, pe, W, {}), F.featureIndex.insert(te, Lt.geometry, pe, Fe, this.index, true);
+                }
+              }
+              addFeatures(S, F, W) {
+                for (let te of this.features) {
+                  let { geometry: fe } = te;
+                  this.addFeature(te, fe, te.index, F, W);
+                }
+              }
+              update(S, F, W) {
+                this.stateDependentLayers.length && this.programConfigurations.updatePaintArrays(S, F, this.stateDependentLayers, W);
+              }
+              isEmpty() {
+                return this.layoutVertexArray.length === 0 && this.centroidVertexArray.length === 0;
+              }
+              uploadPending() {
+                return !this.uploaded || this.programConfigurations.needsUpload;
+              }
+              upload(S) {
+                this.uploaded || (this.layoutVertexBuffer = S.createVertexBuffer(this.layoutVertexArray, ur), this.centroidVertexBuffer = S.createVertexBuffer(this.centroidVertexArray, ht.members, true), this.indexBuffer = S.createIndexBuffer(this.indexArray)), this.programConfigurations.upload(S), this.uploaded = true;
+              }
+              destroy() {
+                this.layoutVertexBuffer && (this.layoutVertexBuffer.destroy(), this.indexBuffer.destroy(), this.programConfigurations.destroy(), this.segments.destroy(), this.centroidVertexBuffer.destroy());
+              }
+              addFeature(S, F, W, te, fe) {
+                for (let pe of Cf(F, 500)) {
+                  let Fe = { x: 0, y: 0, vertexCount: 0 }, Ke = 0;
+                  for (let Pr of pe) Ke += Pr.length;
+                  let ct = this.segments.prepareSegment(4, this.layoutVertexArray, this.indexArray);
+                  for (let Pr of pe) {
+                    if (Pr.length === 0 || ms(Pr)) continue;
+                    let zr = 0;
+                    for (let ui = 0; ui < Pr.length; ui++) {
+                      let yi = Pr[ui];
+                      if (ui >= 1) {
+                        let vn = Pr[ui - 1];
+                        if (!Yo(yi, vn)) {
+                          ct.vertexLength + 4 > Ye.MAX_VERTEX_ARRAY_LENGTH && (ct = this.segments.prepareSegment(4, this.layoutVertexArray, this.indexArray));
+                          let zi = yi.sub(vn)._perp()._unit(), un = vn.dist(yi);
+                          zr + un > 32768 && (zr = 0), ts(this.layoutVertexArray, yi.x, yi.y, zi.x, zi.y, 0, 0, zr), ts(this.layoutVertexArray, yi.x, yi.y, zi.x, zi.y, 0, 1, zr), Fe.x += 2 * yi.x, Fe.y += 2 * yi.y, Fe.vertexCount += 2, zr += un, ts(this.layoutVertexArray, vn.x, vn.y, zi.x, zi.y, 0, 0, zr), ts(this.layoutVertexArray, vn.x, vn.y, zi.x, zi.y, 0, 1, zr), Fe.x += 2 * vn.x, Fe.y += 2 * vn.y, Fe.vertexCount += 2;
+                          let Tn = ct.vertexLength;
+                          this.indexArray.emplaceBack(Tn, Tn + 2, Tn + 1), this.indexArray.emplaceBack(Tn + 1, Tn + 2, Tn + 3), ct.vertexLength += 4, ct.primitiveLength += 2;
+                        }
+                      }
+                    }
+                  }
+                  if (ct.vertexLength + Ke > Ye.MAX_VERTEX_ARRAY_LENGTH && (ct = this.segments.prepareSegment(Ke, this.layoutVertexArray, this.indexArray)), Ja[S.type] !== "Polygon") continue;
+                  let Lt = [], Jt = [], cr = ct.vertexLength;
+                  for (let Pr of pe) if (Pr.length !== 0) {
+                    Pr !== pe[0] && Jt.push(Lt.length / 2);
+                    for (let zr = 0; zr < Pr.length; zr++) {
+                      let ui = Pr[zr];
+                      ts(this.layoutVertexArray, ui.x, ui.y, 0, 0, 1, 1, 0), Fe.x += ui.x, Fe.y += ui.y, Fe.vertexCount += 1, Lt.push(ui.x), Lt.push(ui.y);
+                    }
+                  }
+                  let mr = zo(Lt, Jt);
+                  for (let Pr = 0; Pr < mr.length; Pr += 3) this.indexArray.emplaceBack(cr + mr[Pr], cr + mr[Pr + 2], cr + mr[Pr + 1]);
+                  ct.primitiveLength += mr.length / 3, ct.vertexLength += Ke;
+                  for (let Pr = 0; Pr < Fe.vertexCount; Pr++) {
+                    let zr = Math.floor(Fe.x / Fe.vertexCount), ui = Math.floor(Fe.y / Fe.vertexCount);
+                    this.centroidVertexArray.emplaceBack(zr, ui);
+                  }
+                }
+                this.programConfigurations.populatePaintArrays(this.layoutVertexArray.length, S, W, fe, te);
+              }
+            }
+            function Yo(R, S) {
+              return R.x === S.x && (R.x < 0 || R.x > ja) || R.y === S.y && (R.y < 0 || R.y > ja);
+            }
+            function ms(R) {
+              return R.every((S) => S.x < 0) || R.every((S) => S.x > ja) || R.every((S) => S.y < 0) || R.every((S) => S.y > ja);
+            }
+            let ou;
+            Fi("FillExtrusionBucket", so, { omit: ["layers", "features"] });
+            var Cv = { get paint() {
+              return ou = ou || new ue({ "fill-extrusion-opacity": new Ua(ce["paint_fill-extrusion"]["fill-extrusion-opacity"]), "fill-extrusion-color": new oo(ce["paint_fill-extrusion"]["fill-extrusion-color"]), "fill-extrusion-translate": new Ua(ce["paint_fill-extrusion"]["fill-extrusion-translate"]), "fill-extrusion-translate-anchor": new Ua(ce["paint_fill-extrusion"]["fill-extrusion-translate-anchor"]), "fill-extrusion-pattern": new Vc(ce["paint_fill-extrusion"]["fill-extrusion-pattern"]), "fill-extrusion-height": new oo(ce["paint_fill-extrusion"]["fill-extrusion-height"]), "fill-extrusion-base": new oo(ce["paint_fill-extrusion"]["fill-extrusion-base"]), "fill-extrusion-vertical-gradient": new Ua(ce["paint_fill-extrusion"]["fill-extrusion-vertical-gradient"]) });
+            } };
+            class Lv extends B {
+              constructor(S) {
+                super(S, Cv);
+              }
+              createBucket(S) {
+                return new so(S);
+              }
+              queryRadius() {
+                return Hn(this.paint.get("fill-extrusion-translate"));
+              }
+              is3D() {
+                return true;
+              }
+              queryIntersectsFeature(S, F, W, te, fe, pe, Fe, Ke) {
+                let ct = en(S, this.paint.get("fill-extrusion-translate"), this.paint.get("fill-extrusion-translate-anchor"), pe.angle, Fe), Lt = this.paint.get("fill-extrusion-height").evaluate(F, W), Jt = this.paint.get("fill-extrusion-base").evaluate(F, W), cr = function(Pr, zr, ui, yi) {
+                  let vn = [];
+                  for (let zi of Pr) {
+                    let un = [zi.x, zi.y, 0, 1];
+                    Bn(un, un, zr), vn.push(new u(un[0] / un[3], un[1] / un[3]));
+                  }
+                  return vn;
+                }(ct, Ke), mr = function(Pr, zr, ui, yi) {
+                  let vn = [], zi = [], un = yi[8] * zr, Tn = yi[9] * zr, pa = yi[10] * zr, ro = yi[11] * zr, Vo = yi[8] * ui, Xa = yi[9] * ui, sa = yi[10] * ui, Mo = yi[11] * ui;
+                  for (let fo of Pr) {
+                    let lo = [], Xn = [];
+                    for (let Ro of fo) {
+                      let uo = Ro.x, $o = Ro.y, Ju = yi[0] * uo + yi[4] * $o + yi[12], qu = yi[1] * uo + yi[5] * $o + yi[13], kh = yi[2] * uo + yi[6] * $o + yi[14], Qv = yi[3] * uo + yi[7] * $o + yi[15], ud = kh + pa, Ch = Qv + ro, Vd = Ju + Vo, Gd = qu + Xa, Hd = kh + sa, Af = Qv + Mo, Lh = new u((Ju + un) / Ch, (qu + Tn) / Ch);
+                      Lh.z = ud / Ch, lo.push(Lh);
+                      let Ed = new u(Vd / Af, Gd / Af);
+                      Ed.z = Hd / Af, Xn.push(Ed);
+                    }
+                    vn.push(lo), zi.push(Xn);
+                  }
+                  return [vn, zi];
+                }(te, Jt, Lt, Ke);
+                return function(Pr, zr, ui) {
+                  let yi = 1 / 0;
+                  bt(ui, zr) && (yi = Kv(ui, zr[0]));
+                  for (let vn = 0; vn < zr.length; vn++) {
+                    let zi = zr[vn], un = Pr[vn];
+                    for (let Tn = 0; Tn < zi.length - 1; Tn++) {
+                      let pa = zi[Tn], ro = [pa, zi[Tn + 1], un[Tn + 1], un[Tn], pa];
+                      Sc(ui, ro) && (yi = Math.min(yi, Kv(ui, ro)));
+                    }
+                  }
+                  return yi !== 1 / 0 && yi;
+                }(mr[0], mr[1], cr);
+              }
+            }
+            function wd(R, S) {
+              return R.x * S.x + R.y * S.y;
+            }
+            function Kv(R, S) {
+              if (R.length === 1) {
+                let F = 0, W = S[F++], te;
+                for (; !te || W.equals(te); ) if (te = S[F++], !te) return 1 / 0;
+                for (; F < S.length; F++) {
+                  let fe = S[F], pe = R[0], Fe = te.sub(W), Ke = fe.sub(W), ct = pe.sub(W), Lt = wd(Fe, Fe), Jt = wd(Fe, Ke), cr = wd(Ke, Ke), mr = wd(ct, Fe), Pr = wd(ct, Ke), zr = Lt * cr - Jt * Jt, ui = (cr * mr - Jt * Pr) / zr, yi = (Lt * Pr - Jt * mr) / zr, vn = W.z * (1 - ui - yi) + te.z * ui + fe.z * yi;
+                  if (isFinite(vn)) return vn;
+                }
+                return 1 / 0;
+              }
+              {
+                let F = 1 / 0;
+                for (let W of S) F = Math.min(F, W.z);
+                return F;
+              }
+            }
+            let hg = Oe([{ name: "a_pos_normal", components: 2, type: "Int16" }, { name: "a_data", components: 4, type: "Uint8" }], 4), { members: gp } = hg, Td = Oe([{ name: "a_uv_x", components: 1, type: "Float32" }, { name: "a_split_index", components: 1, type: "Float32" }]), { members: mp } = Td, Ud = br.VectorTileFeature.types, Ad = Math.cos(Math.PI / 180 * 37.5), Pv = Math.pow(2, 14) / 0.5;
+            class Jv {
+              constructor(S) {
+                this.zoom = S.zoom, this.overscaling = S.overscaling, this.layers = S.layers, this.layerIds = this.layers.map((F) => F.id), this.index = S.index, this.hasPattern = false, this.patternFeatures = [], this.lineClipsArray = [], this.gradients = {}, this.layers.forEach((F) => {
+                  this.gradients[F.id] = {};
+                }), this.layoutVertexArray = new Lu(), this.layoutVertexArray2 = new au(), this.indexArray = new se(), this.programConfigurations = new Ms(S.layers, S.zoom), this.segments = new Ye(), this.maxLineLength = 0, this.stateDependentLayerIds = this.layers.filter((F) => F.isStateDependent()).map((F) => F.id);
+              }
+              populate(S, F, W) {
+                this.hasPattern = at("line", this.layers, F);
+                let te = this.layers[0].layout.get("line-sort-key"), fe = !te.isConstant(), pe = [];
+                for (let { feature: Fe, id: Ke, index: ct, sourceLayerIndex: Lt } of S) {
+                  let Jt = this.layers[0]._featureFilter.needGeometry, cr = Sl(Fe, Jt);
+                  if (!this.layers[0]._featureFilter.filter(new rs(this.zoom), cr, W)) continue;
+                  let mr = fe ? te.evaluate(cr, {}, W) : void 0, Pr = { id: Ke, properties: Fe.properties, type: Fe.type, sourceLayerIndex: Lt, index: ct, geometry: Jt ? cr.geometry : $s(Fe), patterns: {}, sortKey: mr };
+                  pe.push(Pr);
+                }
+                fe && pe.sort((Fe, Ke) => Fe.sortKey - Ke.sortKey);
+                for (let Fe of pe) {
+                  let { geometry: Ke, index: ct, sourceLayerIndex: Lt } = Fe;
+                  if (this.hasPattern) {
+                    let Jt = Ct("line", this.layers, Fe, this.zoom, F);
+                    this.patternFeatures.push(Jt);
+                  } else this.addFeature(Fe, Ke, ct, W, {});
+                  F.featureIndex.insert(S[ct].feature, Ke, ct, Lt, this.index);
+                }
+              }
+              update(S, F, W) {
+                this.stateDependentLayers.length && this.programConfigurations.updatePaintArrays(S, F, this.stateDependentLayers, W);
+              }
+              addFeatures(S, F, W) {
+                for (let te of this.patternFeatures) this.addFeature(te, te.geometry, te.index, F, W);
+              }
+              isEmpty() {
+                return this.layoutVertexArray.length === 0;
+              }
+              uploadPending() {
+                return !this.uploaded || this.programConfigurations.needsUpload;
+              }
+              upload(S) {
+                this.uploaded || (this.layoutVertexArray2.length !== 0 && (this.layoutVertexBuffer2 = S.createVertexBuffer(this.layoutVertexArray2, mp)), this.layoutVertexBuffer = S.createVertexBuffer(this.layoutVertexArray, gp), this.indexBuffer = S.createIndexBuffer(this.indexArray)), this.programConfigurations.upload(S), this.uploaded = true;
+              }
+              destroy() {
+                this.layoutVertexBuffer && (this.layoutVertexBuffer.destroy(), this.indexBuffer.destroy(), this.programConfigurations.destroy(), this.segments.destroy());
+              }
+              lineFeatureClips(S) {
+                if (S.properties && Object.prototype.hasOwnProperty.call(S.properties, "mapbox_clip_start") && Object.prototype.hasOwnProperty.call(S.properties, "mapbox_clip_end")) return { start: +S.properties.mapbox_clip_start, end: +S.properties.mapbox_clip_end };
+              }
+              addFeature(S, F, W, te, fe) {
+                let pe = this.layers[0].layout, Fe = pe.get("line-join").evaluate(S, {}), Ke = pe.get("line-cap"), ct = pe.get("line-miter-limit"), Lt = pe.get("line-round-limit");
+                this.lineClips = this.lineFeatureClips(S);
+                for (let Jt of F) this.addLine(Jt, S, Fe, Ke, ct, Lt);
+                this.programConfigurations.populatePaintArrays(this.layoutVertexArray.length, S, W, fe, te);
+              }
+              addLine(S, F, W, te, fe, pe) {
+                if (this.distance = 0, this.scaledDistance = 0, this.totalDistance = 0, this.lineClips) {
+                  this.lineClipsArray.push(this.lineClips);
+                  for (let yi = 0; yi < S.length - 1; yi++) this.totalDistance += S[yi].dist(S[yi + 1]);
+                  this.updateScaledDistance(), this.maxLineLength = Math.max(this.maxLineLength, this.totalDistance);
+                }
+                let Fe = Ud[F.type] === "Polygon", Ke = S.length;
+                for (; Ke >= 2 && S[Ke - 1].equals(S[Ke - 2]); ) Ke--;
+                let ct = 0;
+                for (; ct < Ke - 1 && S[ct].equals(S[ct + 1]); ) ct++;
+                if (Ke < (Fe ? 3 : 2)) return;
+                W === "bevel" && (fe = 1.05);
+                let Lt = this.overscaling <= 16 ? 15 * ja / (512 * this.overscaling) : 0, Jt = this.segments.prepareSegment(10 * Ke, this.layoutVertexArray, this.indexArray), cr, mr, Pr, zr, ui;
+                this.e1 = this.e2 = -1, Fe && (cr = S[Ke - 2], ui = S[ct].sub(cr)._unit()._perp());
+                for (let yi = ct; yi < Ke; yi++) {
+                  if (Pr = yi === Ke - 1 ? Fe ? S[ct + 1] : void 0 : S[yi + 1], Pr && S[yi].equals(Pr)) continue;
+                  ui && (zr = ui), cr && (mr = cr), cr = S[yi], ui = Pr ? Pr.sub(cr)._unit()._perp() : zr, zr = zr || ui;
+                  let vn = zr.add(ui);
+                  vn.x === 0 && vn.y === 0 || vn._unit();
+                  let zi = zr.x * ui.x + zr.y * ui.y, un = vn.x * ui.x + vn.y * ui.y, Tn = un !== 0 ? 1 / un : 1 / 0, pa = 2 * Math.sqrt(2 - 2 * un), ro = un < Ad && mr && Pr, Vo = zr.x * ui.y - zr.y * ui.x > 0;
+                  if (ro && yi > ct) {
+                    let Mo = cr.dist(mr);
+                    if (Mo > 2 * Lt) {
+                      let fo = cr.sub(cr.sub(mr)._mult(Lt / Mo)._round());
+                      this.updateDistance(mr, fo), this.addCurrentVertex(fo, zr, 0, 0, Jt), mr = fo;
+                    }
+                  }
+                  let Xa = mr && Pr, sa = Xa ? W : Fe ? "butt" : te;
+                  if (Xa && sa === "round" && (Tn < pe ? sa = "miter" : Tn <= 2 && (sa = "fakeround")), sa === "miter" && Tn > fe && (sa = "bevel"), sa === "bevel" && (Tn > 2 && (sa = "flipbevel"), Tn < fe && (sa = "miter")), mr && this.updateDistance(mr, cr), sa === "miter") vn._mult(Tn), this.addCurrentVertex(cr, vn, 0, 0, Jt);
+                  else if (sa === "flipbevel") {
+                    if (Tn > 100) vn = ui.mult(-1);
+                    else {
+                      let Mo = Tn * zr.add(ui).mag() / zr.sub(ui).mag();
+                      vn._perp()._mult(Mo * (Vo ? -1 : 1));
+                    }
+                    this.addCurrentVertex(cr, vn, 0, 0, Jt), this.addCurrentVertex(cr, vn.mult(-1), 0, 0, Jt);
+                  } else if (sa === "bevel" || sa === "fakeround") {
+                    let Mo = -Math.sqrt(Tn * Tn - 1), fo = Vo ? Mo : 0, lo = Vo ? 0 : Mo;
+                    if (mr && this.addCurrentVertex(cr, zr, fo, lo, Jt), sa === "fakeround") {
+                      let Xn = Math.round(180 * pa / Math.PI / 20);
+                      for (let Ro = 1; Ro < Xn; Ro++) {
+                        let uo = Ro / Xn;
+                        if (uo !== 0.5) {
+                          let Ju = uo - 0.5;
+                          uo += uo * Ju * (uo - 1) * ((1.0904 + zi * (zi * (3.55645 - 1.43519 * zi) - 3.2452)) * Ju * Ju + (0.848013 + zi * (0.215638 * zi - 1.06021)));
+                        }
+                        let $o = ui.sub(zr)._mult(uo)._add(zr)._unit()._mult(Vo ? -1 : 1);
+                        this.addHalfVertex(cr, $o.x, $o.y, false, Vo, 0, Jt);
+                      }
+                    }
+                    Pr && this.addCurrentVertex(cr, ui, -fo, -lo, Jt);
+                  } else if (sa === "butt") this.addCurrentVertex(cr, vn, 0, 0, Jt);
+                  else if (sa === "square") {
+                    let Mo = mr ? 1 : -1;
+                    this.addCurrentVertex(cr, vn, Mo, Mo, Jt);
+                  } else sa === "round" && (mr && (this.addCurrentVertex(cr, zr, 0, 0, Jt), this.addCurrentVertex(cr, zr, 1, 1, Jt, true)), Pr && (this.addCurrentVertex(cr, ui, -1, -1, Jt, true), this.addCurrentVertex(cr, ui, 0, 0, Jt)));
+                  if (ro && yi < Ke - 1) {
+                    let Mo = cr.dist(Pr);
+                    if (Mo > 2 * Lt) {
+                      let fo = cr.add(Pr.sub(cr)._mult(Lt / Mo)._round());
+                      this.updateDistance(cr, fo), this.addCurrentVertex(fo, ui, 0, 0, Jt), cr = fo;
+                    }
+                  }
+                }
+              }
+              addCurrentVertex(S, F, W, te, fe, pe = false) {
+                let Fe = F.y * te - F.x, Ke = -F.y - F.x * te;
+                this.addHalfVertex(S, F.x + F.y * W, F.y - F.x * W, pe, false, W, fe), this.addHalfVertex(S, Fe, Ke, pe, true, -te, fe), this.distance > Pv / 2 && this.totalDistance === 0 && (this.distance = 0, this.updateScaledDistance(), this.addCurrentVertex(S, F, W, te, fe, pe));
+              }
+              addHalfVertex({ x: S, y: F }, W, te, fe, pe, Fe, Ke) {
+                let ct = 0.5 * (this.lineClips ? this.scaledDistance * (Pv - 1) : this.scaledDistance);
+                this.layoutVertexArray.emplaceBack((S << 1) + (fe ? 1 : 0), (F << 1) + (pe ? 1 : 0), Math.round(63 * W) + 128, Math.round(63 * te) + 128, 1 + (Fe === 0 ? 0 : Fe < 0 ? -1 : 1) | (63 & ct) << 2, ct >> 6), this.lineClips && this.layoutVertexArray2.emplaceBack((this.scaledDistance - this.lineClips.start) / (this.lineClips.end - this.lineClips.start), this.lineClipsArray.length);
+                let Lt = Ke.vertexLength++;
+                this.e1 >= 0 && this.e2 >= 0 && (this.indexArray.emplaceBack(this.e1, this.e2, Lt), Ke.primitiveLength++), pe ? this.e2 = Lt : this.e1 = Lt;
+              }
+              updateScaledDistance() {
+                this.scaledDistance = this.lineClips ? this.lineClips.start + (this.lineClips.end - this.lineClips.start) * this.distance / this.totalDistance : this.distance;
+              }
+              updateDistance(S, F) {
+                this.distance += S.dist(F), this.updateScaledDistance();
+              }
+            }
+            let Iv, fy;
+            Fi("LineBucket", Jv, { omit: ["layers", "patternFeatures"] });
+            var dg = { get paint() {
+              return fy = fy || new ue({ "line-opacity": new oo(ce.paint_line["line-opacity"]), "line-color": new oo(ce.paint_line["line-color"]), "line-translate": new Ua(ce.paint_line["line-translate"]), "line-translate-anchor": new Ua(ce.paint_line["line-translate-anchor"]), "line-width": new oo(ce.paint_line["line-width"]), "line-gap-width": new oo(ce.paint_line["line-gap-width"]), "line-offset": new oo(ce.paint_line["line-offset"]), "line-blur": new oo(ce.paint_line["line-blur"]), "line-dasharray": new hc(ce.paint_line["line-dasharray"]), "line-pattern": new Vc(ce.paint_line["line-pattern"]), "line-gradient": new Ku(ce.paint_line["line-gradient"]) });
+            }, get layout() {
+              return Iv = Iv || new ue({ "line-cap": new Ua(ce.layout_line["line-cap"]), "line-join": new oo(ce.layout_line["line-join"]), "line-miter-limit": new Ua(ce.layout_line["line-miter-limit"]), "line-round-limit": new Ua(ce.layout_line["line-round-limit"]), "line-sort-key": new oo(ce.layout_line["line-sort-key"]) });
+            } };
+            class oh extends oo {
+              possiblyEvaluate(S, F) {
+                return F = new rs(Math.floor(F.zoom), { now: F.now, fadeDuration: F.fadeDuration, zoomHistory: F.zoomHistory, transition: F.transition }), super.possiblyEvaluate(S, F);
+              }
+              evaluate(S, F, W, te) {
+                return F = L({}, F, { zoom: Math.floor(F.zoom) }), super.evaluate(S, F, W, te);
+              }
+            }
+            let vg;
+            class hy extends B {
+              constructor(S) {
+                super(S, dg), this.gradientVersion = 0, vg || (vg = new oh(dg.paint.properties["line-width"].specification), vg.useIntegerZoom = true);
+              }
+              _handleSpecialPaintPropertyUpdate(S) {
+                if (S === "line-gradient") {
+                  let F = this.gradientExpression();
+                  this.stepInterpolant = !!function(W) {
+                    return W._styleExpression !== void 0;
+                  }(F) && F._styleExpression.expression instanceof _n, this.gradientVersion = (this.gradientVersion + 1) % Number.MAX_SAFE_INTEGER;
+                }
+              }
+              gradientExpression() {
+                return this._transitionablePaint._values["line-gradient"].value.expression;
+              }
+              recalculate(S, F) {
+                super.recalculate(S, F), this.paint._values["line-floorwidth"] = vg.possiblyEvaluate(this._transitioningPaint._values["line-width"].value, S);
+              }
+              createBucket(S) {
+                return new Jv(S);
+              }
+              queryRadius(S) {
+                let F = S, W = Zh(Ei("line-width", this, F), Ei("line-gap-width", this, F)), te = Ei("line-offset", this, F);
+                return W / 2 + Math.abs(te) + Hn(this.paint.get("line-translate"));
+              }
+              queryIntersectsFeature(S, F, W, te, fe, pe, Fe) {
+                let Ke = en(S, this.paint.get("line-translate"), this.paint.get("line-translate-anchor"), pe.angle, Fe), ct = Fe / 2 * Zh(this.paint.get("line-width").evaluate(F, W), this.paint.get("line-gap-width").evaluate(F, W)), Lt = this.paint.get("line-offset").evaluate(F, W);
+                return Lt && (te = function(Jt, cr) {
+                  let mr = [];
+                  for (let Pr = 0; Pr < Jt.length; Pr++) {
+                    let zr = Jt[Pr], ui = [];
+                    for (let yi = 0; yi < zr.length; yi++) {
+                      let vn = zr[yi - 1], zi = zr[yi], un = zr[yi + 1], Tn = yi === 0 ? new u(0, 0) : zi.sub(vn)._unit()._perp(), pa = yi === zr.length - 1 ? new u(0, 0) : un.sub(zi)._unit()._perp(), ro = Tn._add(pa)._unit(), Vo = ro.x * pa.x + ro.y * pa.y;
+                      Vo !== 0 && ro._mult(1 / Vo), ui.push(ro._mult(cr)._add(zi));
+                    }
+                    mr.push(ui);
+                  }
+                  return mr;
+                }(te, Lt * Fe)), function(Jt, cr, mr) {
+                  for (let Pr = 0; Pr < cr.length; Pr++) {
+                    let zr = cr[Pr];
+                    if (Jt.length >= 3) {
+                      for (let ui = 0; ui < zr.length; ui++) if (Ui(Jt, zr[ui])) return true;
+                    }
+                    if (zt(Jt, zr, mr)) return true;
+                  }
+                  return false;
+                }(Ke, te, ct);
+              }
+              isTileClipped() {
+                return true;
+              }
+            }
+            function Zh(R, S) {
+              return S > 0 ? S + 2 * R : R;
+            }
+            let am = Oe([{ name: "a_pos_offset", components: 4, type: "Int16" }, { name: "a_data", components: 4, type: "Uint16" }, { name: "a_pixeloffset", components: 4, type: "Int16" }], 4), k1 = Oe([{ name: "a_projected_pos", components: 3, type: "Float32" }], 4);
+            Oe([{ name: "a_fade_opacity", components: 1, type: "Uint32" }], 4);
+            let C1 = Oe([{ name: "a_placed", components: 2, type: "Uint8" }, { name: "a_shift", components: 2, type: "Float32" }, { name: "a_box_real", components: 2, type: "Int16" }]);
+            Oe([{ type: "Int16", name: "anchorPointX" }, { type: "Int16", name: "anchorPointY" }, { type: "Int16", name: "x1" }, { type: "Int16", name: "y1" }, { type: "Int16", name: "x2" }, { type: "Int16", name: "y2" }, { type: "Uint32", name: "featureIndex" }, { type: "Uint16", name: "sourceLayerIndex" }, { type: "Uint16", name: "bucketIndex" }]);
+            let dy = Oe([{ name: "a_pos", components: 2, type: "Int16" }, { name: "a_anchor_pos", components: 2, type: "Int16" }, { name: "a_extrude", components: 2, type: "Int16" }], 4), om = Oe([{ name: "a_pos", components: 2, type: "Float32" }, { name: "a_radius", components: 1, type: "Float32" }, { name: "a_flags", components: 2, type: "Int16" }], 4);
+            function sm(R, S, F) {
+              return R.sections.forEach((W) => {
+                W.text = function(te, fe, pe) {
+                  let Fe = fe.layout.get("text-transform").evaluate(pe, {});
+                  return Fe === "uppercase" ? te = te.toLocaleUpperCase() : Fe === "lowercase" && (te = te.toLocaleLowerCase()), ys.applyArabicShaping && (te = ys.applyArabicShaping(te)), te;
+                }(W.text, S, F);
+              }), R;
+            }
+            Oe([{ name: "triangle", components: 3, type: "Uint16" }]), Oe([{ type: "Int16", name: "anchorX" }, { type: "Int16", name: "anchorY" }, { type: "Uint16", name: "glyphStartIndex" }, { type: "Uint16", name: "numGlyphs" }, { type: "Uint32", name: "vertexStartIndex" }, { type: "Uint32", name: "lineStartIndex" }, { type: "Uint32", name: "lineLength" }, { type: "Uint16", name: "segment" }, { type: "Uint16", name: "lowerSize" }, { type: "Uint16", name: "upperSize" }, { type: "Float32", name: "lineOffsetX" }, { type: "Float32", name: "lineOffsetY" }, { type: "Uint8", name: "writingMode" }, { type: "Uint8", name: "placedOrientation" }, { type: "Uint8", name: "hidden" }, { type: "Uint32", name: "crossTileID" }, { type: "Int16", name: "associatedIconIndex" }]), Oe([{ type: "Int16", name: "anchorX" }, { type: "Int16", name: "anchorY" }, { type: "Int16", name: "rightJustifiedTextSymbolIndex" }, { type: "Int16", name: "centerJustifiedTextSymbolIndex" }, { type: "Int16", name: "leftJustifiedTextSymbolIndex" }, { type: "Int16", name: "verticalPlacedTextSymbolIndex" }, { type: "Int16", name: "placedIconSymbolIndex" }, { type: "Int16", name: "verticalPlacedIconSymbolIndex" }, { type: "Uint16", name: "key" }, { type: "Uint16", name: "textBoxStartIndex" }, { type: "Uint16", name: "textBoxEndIndex" }, { type: "Uint16", name: "verticalTextBoxStartIndex" }, { type: "Uint16", name: "verticalTextBoxEndIndex" }, { type: "Uint16", name: "iconBoxStartIndex" }, { type: "Uint16", name: "iconBoxEndIndex" }, { type: "Uint16", name: "verticalIconBoxStartIndex" }, { type: "Uint16", name: "verticalIconBoxEndIndex" }, { type: "Uint16", name: "featureIndex" }, { type: "Uint16", name: "numHorizontalGlyphVertices" }, { type: "Uint16", name: "numVerticalGlyphVertices" }, { type: "Uint16", name: "numIconVertices" }, { type: "Uint16", name: "numVerticalIconVertices" }, { type: "Uint16", name: "useRuntimeCollisionCircles" }, { type: "Uint32", name: "crossTileID" }, { type: "Float32", name: "textBoxScale" }, { type: "Float32", name: "collisionCircleDiameter" }, { type: "Uint16", name: "textAnchorOffsetStartIndex" }, { type: "Uint16", name: "textAnchorOffsetEndIndex" }]), Oe([{ type: "Float32", name: "offsetX" }]), Oe([{ type: "Int16", name: "x" }, { type: "Int16", name: "y" }, { type: "Int16", name: "tileUnitDistanceFromAnchor" }]), Oe([{ type: "Uint16", name: "textAnchor" }, { type: "Float32", components: 2, name: "textOffset" }]);
+            let vc = { "!": "︕", "#": "＃", $: "＄", "%": "％", "&": "＆", "(": "︵", ")": "︶", "*": "＊", "+": "＋", ",": "︐", "-": "︲", ".": "・", "/": "／", ":": "︓", ";": "︔", "<": "︿", "=": "＝", ">": "﹀", "?": "︖", "@": "＠", "[": "﹇", "\\": "＼", "]": "﹈", "^": "＾", _: "︳", "`": "｀", "{": "︷", "|": "―", "}": "︸", "~": "～", "¢": "￠", "£": "￡", "¥": "￥", "¦": "￤", "¬": "￢", "¯": "￣", "–": "︲", "—": "︱", "‘": "﹃", "’": "﹄", "“": "﹁", "”": "﹂", "…": "︙", "‧": "・", "₩": "￦", "、": "︑", "。": "︒", "〈": "︿", "〉": "﹀", "《": "︽", "》": "︾", "「": "﹁", "」": "﹂", "『": "﹃", "』": "﹄", "【": "︻", "】": "︼", "〔": "︹", "〕": "︺", "〖": "︗", "〗": "︘", "！": "︕", "（": "︵", "）": "︶", "，": "︐", "－": "︲", "．": "・", "：": "︓", "；": "︔", "＜": "︿", "＞": "﹀", "？": "︖", "［": "﹇", "］": "﹈", "＿": "︳", "｛": "︷", "｜": "―", "｝": "︸", "｟": "︵", "｠": "︶", "｡": "︒", "｢": "﹁", "｣": "﹂" };
+            var tu = 24, Sd = wu, vy = function(R, S, F, W, te) {
+              var fe, pe, Fe = 8 * te - W - 1, Ke = (1 << Fe) - 1, ct = Ke >> 1, Lt = -7, Jt = te - 1, cr = -1, mr = R[S + Jt];
+              for (Jt += cr, fe = mr & (1 << -Lt) - 1, mr >>= -Lt, Lt += Fe; Lt > 0; fe = 256 * fe + R[S + Jt], Jt += cr, Lt -= 8) ;
+              for (pe = fe & (1 << -Lt) - 1, fe >>= -Lt, Lt += W; Lt > 0; pe = 256 * pe + R[S + Jt], Jt += cr, Lt -= 8) ;
+              if (fe === 0) fe = 1 - ct;
+              else {
+                if (fe === Ke) return pe ? NaN : 1 / 0 * (mr ? -1 : 1);
+                pe += Math.pow(2, W), fe -= ct;
+              }
+              return (mr ? -1 : 1) * pe * Math.pow(2, fe - W);
+            }, L1 = function(R, S, F, W, te, fe) {
+              var pe, Fe, Ke, ct = 8 * fe - te - 1, Lt = (1 << ct) - 1, Jt = Lt >> 1, cr = te === 23 ? Math.pow(2, -24) - Math.pow(2, -77) : 0, mr = 0, Pr = 1, zr = S < 0 || S === 0 && 1 / S < 0 ? 1 : 0;
+              for (S = Math.abs(S), isNaN(S) || S === 1 / 0 ? (Fe = isNaN(S) ? 1 : 0, pe = Lt) : (pe = Math.floor(Math.log(S) / Math.LN2), S * (Ke = Math.pow(2, -pe)) < 1 && (pe--, Ke *= 2), (S += pe + Jt >= 1 ? cr / Ke : cr * Math.pow(2, 1 - Jt)) * Ke >= 2 && (pe++, Ke /= 2), pe + Jt >= Lt ? (Fe = 0, pe = Lt) : pe + Jt >= 1 ? (Fe = (S * Ke - 1) * Math.pow(2, te), pe += Jt) : (Fe = S * Math.pow(2, Jt - 1) * Math.pow(2, te), pe = 0)); te >= 8; R[F + mr] = 255 & Fe, mr += Pr, Fe /= 256, te -= 8) ;
+              for (pe = pe << te | Fe, ct += te; ct > 0; R[F + mr] = 255 & pe, mr += Pr, pe /= 256, ct -= 8) ;
+              R[F + mr - Pr] |= 128 * zr;
+            };
+            function wu(R) {
+              this.buf = ArrayBuffer.isView && ArrayBuffer.isView(R) ? R : new Uint8Array(R || 0), this.pos = 0, this.type = 0, this.length = this.buf.length;
+            }
+            wu.Varint = 0, wu.Fixed64 = 1, wu.Bytes = 2, wu.Fixed32 = 5;
+            var Yx = 4294967296, lm = 1 / Yx, Ow = typeof TextDecoder == "undefined" ? null : new TextDecoder("utf-8");
+            function Rv(R) {
+              return R.type === wu.Bytes ? R.readVarint() + R.pos : R.pos + 1;
+            }
+            function um(R, S, F) {
+              return F ? 4294967296 * S + (R >>> 0) : 4294967296 * (S >>> 0) + (R >>> 0);
+            }
+            function qw(R, S, F) {
+              var W = S <= 16383 ? 1 : S <= 2097151 ? 2 : S <= 268435455 ? 3 : Math.floor(Math.log(S) / (7 * Math.LN2));
+              F.realloc(W);
+              for (var te = F.pos - 1; te >= R; te--) F.buf[te + W] = F.buf[te];
+            }
+            function Kx(R, S) {
+              for (var F = 0; F < R.length; F++) S.writeVarint(R[F]);
+            }
+            function V9(R, S) {
+              for (var F = 0; F < R.length; F++) S.writeSVarint(R[F]);
+            }
+            function G9(R, S) {
+              for (var F = 0; F < R.length; F++) S.writeFloat(R[F]);
+            }
+            function H9(R, S) {
+              for (var F = 0; F < R.length; F++) S.writeDouble(R[F]);
+            }
+            function j9(R, S) {
+              for (var F = 0; F < R.length; F++) S.writeBoolean(R[F]);
+            }
+            function OQ(R, S) {
+              for (var F = 0; F < R.length; F++) S.writeFixed32(R[F]);
+            }
+            function W9(R, S) {
+              for (var F = 0; F < R.length; F++) S.writeSFixed32(R[F]);
+            }
+            function X9(R, S) {
+              for (var F = 0; F < R.length; F++) S.writeFixed64(R[F]);
+            }
+            function Z9(R, S) {
+              for (var F = 0; F < R.length; F++) S.writeSFixed64(R[F]);
+            }
+            function py(R, S) {
+              return (R[S] | R[S + 1] << 8 | R[S + 2] << 16) + 16777216 * R[S + 3];
+            }
+            function Jx(R, S, F) {
+              R[F] = S, R[F + 1] = S >>> 8, R[F + 2] = S >>> 16, R[F + 3] = S >>> 24;
+            }
+            function SC(R, S) {
+              return (R[S] | R[S + 1] << 8 | R[S + 2] << 16) + (R[S + 3] << 24);
+            }
+            wu.prototype = { destroy: function() {
+              this.buf = null;
+            }, readFields: function(R, S, F) {
+              for (F = F || this.length; this.pos < F; ) {
+                var W = this.readVarint(), te = W >> 3, fe = this.pos;
+                this.type = 7 & W, R(te, S, this), this.pos === fe && this.skip(W);
+              }
+              return S;
+            }, readMessage: function(R, S) {
+              return this.readFields(R, S, this.readVarint() + this.pos);
+            }, readFixed32: function() {
+              var R = py(this.buf, this.pos);
+              return this.pos += 4, R;
+            }, readSFixed32: function() {
+              var R = SC(this.buf, this.pos);
+              return this.pos += 4, R;
+            }, readFixed64: function() {
+              var R = py(this.buf, this.pos) + py(this.buf, this.pos + 4) * Yx;
+              return this.pos += 8, R;
+            }, readSFixed64: function() {
+              var R = py(this.buf, this.pos) + SC(this.buf, this.pos + 4) * Yx;
+              return this.pos += 8, R;
+            }, readFloat: function() {
+              var R = vy(this.buf, this.pos, true, 23, 4);
+              return this.pos += 4, R;
+            }, readDouble: function() {
+              var R = vy(this.buf, this.pos, true, 52, 8);
+              return this.pos += 8, R;
+            }, readVarint: function(R) {
+              var S, F, W = this.buf;
+              return S = 127 & (F = W[this.pos++]), F < 128 ? S : (S |= (127 & (F = W[this.pos++])) << 7, F < 128 ? S : (S |= (127 & (F = W[this.pos++])) << 14, F < 128 ? S : (S |= (127 & (F = W[this.pos++])) << 21, F < 128 ? S : function(te, fe, pe) {
+                var Fe, Ke, ct = pe.buf;
+                if (Fe = (112 & (Ke = ct[pe.pos++])) >> 4, Ke < 128 || (Fe |= (127 & (Ke = ct[pe.pos++])) << 3, Ke < 128) || (Fe |= (127 & (Ke = ct[pe.pos++])) << 10, Ke < 128) || (Fe |= (127 & (Ke = ct[pe.pos++])) << 17, Ke < 128) || (Fe |= (127 & (Ke = ct[pe.pos++])) << 24, Ke < 128) || (Fe |= (1 & (Ke = ct[pe.pos++])) << 31, Ke < 128)) return um(te, Fe, fe);
+                throw new Error("Expected varint not more than 10 bytes");
+              }(S |= (15 & (F = W[this.pos])) << 28, R, this))));
+            }, readVarint64: function() {
+              return this.readVarint(true);
+            }, readSVarint: function() {
+              var R = this.readVarint();
+              return R % 2 == 1 ? (R + 1) / -2 : R / 2;
+            }, readBoolean: function() {
+              return !!this.readVarint();
+            }, readString: function() {
+              var R = this.readVarint() + this.pos, S = this.pos;
+              return this.pos = R, R - S >= 12 && Ow ? function(F, W, te) {
+                return Ow.decode(F.subarray(W, te));
+              }(this.buf, S, R) : function(F, W, te) {
+                for (var fe = "", pe = W; pe < te; ) {
+                  var Fe, Ke, ct, Lt = F[pe], Jt = null, cr = Lt > 239 ? 4 : Lt > 223 ? 3 : Lt > 191 ? 2 : 1;
+                  if (pe + cr > te) break;
+                  cr === 1 ? Lt < 128 && (Jt = Lt) : cr === 2 ? (192 & (Fe = F[pe + 1])) == 128 && (Jt = (31 & Lt) << 6 | 63 & Fe) <= 127 && (Jt = null) : cr === 3 ? (Ke = F[pe + 2], (192 & (Fe = F[pe + 1])) == 128 && (192 & Ke) == 128 && ((Jt = (15 & Lt) << 12 | (63 & Fe) << 6 | 63 & Ke) <= 2047 || Jt >= 55296 && Jt <= 57343) && (Jt = null)) : cr === 4 && (Ke = F[pe + 2], ct = F[pe + 3], (192 & (Fe = F[pe + 1])) == 128 && (192 & Ke) == 128 && (192 & ct) == 128 && ((Jt = (15 & Lt) << 18 | (63 & Fe) << 12 | (63 & Ke) << 6 | 63 & ct) <= 65535 || Jt >= 1114112) && (Jt = null)), Jt === null ? (Jt = 65533, cr = 1) : Jt > 65535 && (Jt -= 65536, fe += String.fromCharCode(Jt >>> 10 & 1023 | 55296), Jt = 56320 | 1023 & Jt), fe += String.fromCharCode(Jt), pe += cr;
+                }
+                return fe;
+              }(this.buf, S, R);
+            }, readBytes: function() {
+              var R = this.readVarint() + this.pos, S = this.buf.subarray(this.pos, R);
+              return this.pos = R, S;
+            }, readPackedVarint: function(R, S) {
+              if (this.type !== wu.Bytes) return R.push(this.readVarint(S));
+              var F = Rv(this);
+              for (R = R || []; this.pos < F; ) R.push(this.readVarint(S));
+              return R;
+            }, readPackedSVarint: function(R) {
+              if (this.type !== wu.Bytes) return R.push(this.readSVarint());
+              var S = Rv(this);
+              for (R = R || []; this.pos < S; ) R.push(this.readSVarint());
+              return R;
+            }, readPackedBoolean: function(R) {
+              if (this.type !== wu.Bytes) return R.push(this.readBoolean());
+              var S = Rv(this);
+              for (R = R || []; this.pos < S; ) R.push(this.readBoolean());
+              return R;
+            }, readPackedFloat: function(R) {
+              if (this.type !== wu.Bytes) return R.push(this.readFloat());
+              var S = Rv(this);
+              for (R = R || []; this.pos < S; ) R.push(this.readFloat());
+              return R;
+            }, readPackedDouble: function(R) {
+              if (this.type !== wu.Bytes) return R.push(this.readDouble());
+              var S = Rv(this);
+              for (R = R || []; this.pos < S; ) R.push(this.readDouble());
+              return R;
+            }, readPackedFixed32: function(R) {
+              if (this.type !== wu.Bytes) return R.push(this.readFixed32());
+              var S = Rv(this);
+              for (R = R || []; this.pos < S; ) R.push(this.readFixed32());
+              return R;
+            }, readPackedSFixed32: function(R) {
+              if (this.type !== wu.Bytes) return R.push(this.readSFixed32());
+              var S = Rv(this);
+              for (R = R || []; this.pos < S; ) R.push(this.readSFixed32());
+              return R;
+            }, readPackedFixed64: function(R) {
+              if (this.type !== wu.Bytes) return R.push(this.readFixed64());
+              var S = Rv(this);
+              for (R = R || []; this.pos < S; ) R.push(this.readFixed64());
+              return R;
+            }, readPackedSFixed64: function(R) {
+              if (this.type !== wu.Bytes) return R.push(this.readSFixed64());
+              var S = Rv(this);
+              for (R = R || []; this.pos < S; ) R.push(this.readSFixed64());
+              return R;
+            }, skip: function(R) {
+              var S = 7 & R;
+              if (S === wu.Varint) for (; this.buf[this.pos++] > 127; ) ;
+              else if (S === wu.Bytes) this.pos = this.readVarint() + this.pos;
+              else if (S === wu.Fixed32) this.pos += 4;
+              else {
+                if (S !== wu.Fixed64) throw new Error("Unimplemented type: " + S);
+                this.pos += 8;
+              }
+            }, writeTag: function(R, S) {
+              this.writeVarint(R << 3 | S);
+            }, realloc: function(R) {
+              for (var S = this.length || 16; S < this.pos + R; ) S *= 2;
+              if (S !== this.length) {
+                var F = new Uint8Array(S);
+                F.set(this.buf), this.buf = F, this.length = S;
+              }
+            }, finish: function() {
+              return this.length = this.pos, this.pos = 0, this.buf.subarray(0, this.length);
+            }, writeFixed32: function(R) {
+              this.realloc(4), Jx(this.buf, R, this.pos), this.pos += 4;
+            }, writeSFixed32: function(R) {
+              this.realloc(4), Jx(this.buf, R, this.pos), this.pos += 4;
+            }, writeFixed64: function(R) {
+              this.realloc(8), Jx(this.buf, -1 & R, this.pos), Jx(this.buf, Math.floor(R * lm), this.pos + 4), this.pos += 8;
+            }, writeSFixed64: function(R) {
+              this.realloc(8), Jx(this.buf, -1 & R, this.pos), Jx(this.buf, Math.floor(R * lm), this.pos + 4), this.pos += 8;
+            }, writeVarint: function(R) {
+              (R = +R || 0) > 268435455 || R < 0 ? function(S, F) {
+                var W, te;
+                if (S >= 0 ? (W = S % 4294967296 | 0, te = S / 4294967296 | 0) : (te = ~(-S / 4294967296), 4294967295 ^ (W = ~(-S % 4294967296)) ? W = W + 1 | 0 : (W = 0, te = te + 1 | 0)), S >= 18446744073709552e3 || S < -18446744073709552e3) throw new Error("Given varint doesn't fit into 10 bytes");
+                F.realloc(10), function(fe, pe, Fe) {
+                  Fe.buf[Fe.pos++] = 127 & fe | 128, fe >>>= 7, Fe.buf[Fe.pos++] = 127 & fe | 128, fe >>>= 7, Fe.buf[Fe.pos++] = 127 & fe | 128, fe >>>= 7, Fe.buf[Fe.pos++] = 127 & fe | 128, Fe.buf[Fe.pos] = 127 & (fe >>>= 7);
+                }(W, 0, F), function(fe, pe) {
+                  var Fe = (7 & fe) << 4;
+                  pe.buf[pe.pos++] |= Fe | ((fe >>>= 3) ? 128 : 0), fe && (pe.buf[pe.pos++] = 127 & fe | ((fe >>>= 7) ? 128 : 0), fe && (pe.buf[pe.pos++] = 127 & fe | ((fe >>>= 7) ? 128 : 0), fe && (pe.buf[pe.pos++] = 127 & fe | ((fe >>>= 7) ? 128 : 0), fe && (pe.buf[pe.pos++] = 127 & fe | ((fe >>>= 7) ? 128 : 0), fe && (pe.buf[pe.pos++] = 127 & fe)))));
+                }(te, F);
+              }(R, this) : (this.realloc(4), this.buf[this.pos++] = 127 & R | (R > 127 ? 128 : 0), R <= 127 || (this.buf[this.pos++] = 127 & (R >>>= 7) | (R > 127 ? 128 : 0), R <= 127 || (this.buf[this.pos++] = 127 & (R >>>= 7) | (R > 127 ? 128 : 0), R <= 127 || (this.buf[this.pos++] = R >>> 7 & 127))));
+            }, writeSVarint: function(R) {
+              this.writeVarint(R < 0 ? 2 * -R - 1 : 2 * R);
+            }, writeBoolean: function(R) {
+              this.writeVarint(!!R);
+            }, writeString: function(R) {
+              R = String(R), this.realloc(4 * R.length), this.pos++;
+              var S = this.pos;
+              this.pos = function(W, te, fe) {
+                for (var pe, Fe, Ke = 0; Ke < te.length; Ke++) {
+                  if ((pe = te.charCodeAt(Ke)) > 55295 && pe < 57344) {
+                    if (!Fe) {
+                      pe > 56319 || Ke + 1 === te.length ? (W[fe++] = 239, W[fe++] = 191, W[fe++] = 189) : Fe = pe;
+                      continue;
+                    }
+                    if (pe < 56320) {
+                      W[fe++] = 239, W[fe++] = 191, W[fe++] = 189, Fe = pe;
+                      continue;
+                    }
+                    pe = Fe - 55296 << 10 | pe - 56320 | 65536, Fe = null;
+                  } else Fe && (W[fe++] = 239, W[fe++] = 191, W[fe++] = 189, Fe = null);
+                  pe < 128 ? W[fe++] = pe : (pe < 2048 ? W[fe++] = pe >> 6 | 192 : (pe < 65536 ? W[fe++] = pe >> 12 | 224 : (W[fe++] = pe >> 18 | 240, W[fe++] = pe >> 12 & 63 | 128), W[fe++] = pe >> 6 & 63 | 128), W[fe++] = 63 & pe | 128);
+                }
+                return fe;
+              }(this.buf, R, this.pos);
+              var F = this.pos - S;
+              F >= 128 && qw(S, F, this), this.pos = S - 1, this.writeVarint(F), this.pos += F;
+            }, writeFloat: function(R) {
+              this.realloc(4), L1(this.buf, R, this.pos, true, 23, 4), this.pos += 4;
+            }, writeDouble: function(R) {
+              this.realloc(8), L1(this.buf, R, this.pos, true, 52, 8), this.pos += 8;
+            }, writeBytes: function(R) {
+              var S = R.length;
+              this.writeVarint(S), this.realloc(S);
+              for (var F = 0; F < S; F++) this.buf[this.pos++] = R[F];
+            }, writeRawMessage: function(R, S) {
+              this.pos++;
+              var F = this.pos;
+              R(S, this);
+              var W = this.pos - F;
+              W >= 128 && qw(F, W, this), this.pos = F - 1, this.writeVarint(W), this.pos += W;
+            }, writeMessage: function(R, S, F) {
+              this.writeTag(R, wu.Bytes), this.writeRawMessage(S, F);
+            }, writePackedVarint: function(R, S) {
+              S.length && this.writeMessage(R, Kx, S);
+            }, writePackedSVarint: function(R, S) {
+              S.length && this.writeMessage(R, V9, S);
+            }, writePackedBoolean: function(R, S) {
+              S.length && this.writeMessage(R, j9, S);
+            }, writePackedFloat: function(R, S) {
+              S.length && this.writeMessage(R, G9, S);
+            }, writePackedDouble: function(R, S) {
+              S.length && this.writeMessage(R, H9, S);
+            }, writePackedFixed32: function(R, S) {
+              S.length && this.writeMessage(R, OQ, S);
+            }, writePackedSFixed32: function(R, S) {
+              S.length && this.writeMessage(R, W9, S);
+            }, writePackedFixed64: function(R, S) {
+              S.length && this.writeMessage(R, X9, S);
+            }, writePackedSFixed64: function(R, S) {
+              S.length && this.writeMessage(R, Z9, S);
+            }, writeBytesField: function(R, S) {
+              this.writeTag(R, wu.Bytes), this.writeBytes(S);
+            }, writeFixed32Field: function(R, S) {
+              this.writeTag(R, wu.Fixed32), this.writeFixed32(S);
+            }, writeSFixed32Field: function(R, S) {
+              this.writeTag(R, wu.Fixed32), this.writeSFixed32(S);
+            }, writeFixed64Field: function(R, S) {
+              this.writeTag(R, wu.Fixed64), this.writeFixed64(S);
+            }, writeSFixed64Field: function(R, S) {
+              this.writeTag(R, wu.Fixed64), this.writeSFixed64(S);
+            }, writeVarintField: function(R, S) {
+              this.writeTag(R, wu.Varint), this.writeVarint(S);
+            }, writeSVarintField: function(R, S) {
+              this.writeTag(R, wu.Varint), this.writeSVarint(S);
+            }, writeStringField: function(R, S) {
+              this.writeTag(R, wu.Bytes), this.writeString(S);
+            }, writeFloatField: function(R, S) {
+              this.writeTag(R, wu.Fixed32), this.writeFloat(S);
+            }, writeDoubleField: function(R, S) {
+              this.writeTag(R, wu.Fixed64), this.writeDouble(S);
+            }, writeBooleanField: function(R, S) {
+              this.writeVarintField(R, !!S);
+            } };
+            var lS = o(Sd);
+            let uS = 3;
+            function qQ(R, S, F) {
+              R === 1 && F.readMessage(Y9, S);
+            }
+            function Y9(R, S, F) {
+              if (R === 3) {
+                let { id: W, bitmap: te, width: fe, height: pe, left: Fe, top: Ke, advance: ct } = F.readMessage(MC, {});
+                S.push({ id: W, bitmap: new na({ width: fe + 2 * uS, height: pe + 2 * uS }, te), metrics: { width: fe, height: pe, left: Fe, top: Ke, advance: ct } });
+              }
+            }
+            function MC(R, S, F) {
+              R === 1 ? S.id = F.readVarint() : R === 2 ? S.bitmap = F.readBytes() : R === 3 ? S.width = F.readVarint() : R === 4 ? S.height = F.readVarint() : R === 5 ? S.left = F.readSVarint() : R === 6 ? S.top = F.readSVarint() : R === 7 && (S.advance = F.readVarint());
+            }
+            let EC = uS;
+            function cS(R) {
+              let S = 0, F = 0;
+              for (let pe of R) S += pe.w * pe.h, F = Math.max(F, pe.w);
+              R.sort((pe, Fe) => Fe.h - pe.h);
+              let W = [{ x: 0, y: 0, w: Math.max(Math.ceil(Math.sqrt(S / 0.95)), F), h: 1 / 0 }], te = 0, fe = 0;
+              for (let pe of R) for (let Fe = W.length - 1; Fe >= 0; Fe--) {
+                let Ke = W[Fe];
+                if (!(pe.w > Ke.w || pe.h > Ke.h)) {
+                  if (pe.x = Ke.x, pe.y = Ke.y, fe = Math.max(fe, pe.y + pe.h), te = Math.max(te, pe.x + pe.w), pe.w === Ke.w && pe.h === Ke.h) {
+                    let ct = W.pop();
+                    Fe < W.length && (W[Fe] = ct);
+                  } else pe.h === Ke.h ? (Ke.x += pe.w, Ke.w -= pe.w) : pe.w === Ke.w ? (Ke.y += pe.h, Ke.h -= pe.h) : (W.push({ x: Ke.x + pe.w, y: Ke.y, w: Ke.w - pe.w, h: pe.h }), Ke.y += pe.h, Ke.h -= pe.h);
+                  break;
+                }
+              }
+              return { w: te, h: fe, fill: S / (te * fe) || 0 };
+            }
+            let Md = 1;
+            class Bw {
+              constructor(S, { pixelRatio: F, version: W, stretchX: te, stretchY: fe, content: pe, textFitWidth: Fe, textFitHeight: Ke }) {
+                this.paddedRect = S, this.pixelRatio = F, this.stretchX = te, this.stretchY = fe, this.content = pe, this.version = W, this.textFitWidth = Fe, this.textFitHeight = Ke;
+              }
+              get tl() {
+                return [this.paddedRect.x + Md, this.paddedRect.y + Md];
+              }
+              get br() {
+                return [this.paddedRect.x + this.paddedRect.w - Md, this.paddedRect.y + this.paddedRect.h - Md];
+              }
+              get tlbr() {
+                return this.tl.concat(this.br);
+              }
+              get displaySize() {
+                return [(this.paddedRect.w - 2 * Md) / this.pixelRatio, (this.paddedRect.h - 2 * Md) / this.pixelRatio];
+              }
+            }
+            class Nw {
+              constructor(S, F) {
+                let W = {}, te = {};
+                this.haveRenderCallbacks = [];
+                let fe = [];
+                this.addImages(S, W, fe), this.addImages(F, te, fe);
+                let { w: pe, h: Fe } = cS(fe), Ke = new Ki({ width: pe || 1, height: Fe || 1 });
+                for (let ct in S) {
+                  let Lt = S[ct], Jt = W[ct].paddedRect;
+                  Ki.copy(Lt.data, Ke, { x: 0, y: 0 }, { x: Jt.x + Md, y: Jt.y + Md }, Lt.data);
+                }
+                for (let ct in F) {
+                  let Lt = F[ct], Jt = te[ct].paddedRect, cr = Jt.x + Md, mr = Jt.y + Md, Pr = Lt.data.width, zr = Lt.data.height;
+                  Ki.copy(Lt.data, Ke, { x: 0, y: 0 }, { x: cr, y: mr }, Lt.data), Ki.copy(Lt.data, Ke, { x: 0, y: zr - 1 }, { x: cr, y: mr - 1 }, { width: Pr, height: 1 }), Ki.copy(Lt.data, Ke, { x: 0, y: 0 }, { x: cr, y: mr + zr }, { width: Pr, height: 1 }), Ki.copy(Lt.data, Ke, { x: Pr - 1, y: 0 }, { x: cr - 1, y: mr }, { width: 1, height: zr }), Ki.copy(Lt.data, Ke, { x: 0, y: 0 }, { x: cr + Pr, y: mr }, { width: 1, height: zr });
+                }
+                this.image = Ke, this.iconPositions = W, this.patternPositions = te;
+              }
+              addImages(S, F, W) {
+                for (let te in S) {
+                  let fe = S[te], pe = { x: 0, y: 0, w: fe.data.width + 2 * Md, h: fe.data.height + 2 * Md };
+                  W.push(pe), F[te] = new Bw(pe, fe), fe.hasRenderCallback && this.haveRenderCallbacks.push(te);
+                }
+              }
+              patchUpdatedImages(S, F) {
+                S.dispatchRenderCallbacks(this.haveRenderCallbacks);
+                for (let W in S.updatedImages) this.patchUpdatedImage(this.iconPositions[W], S.getImage(W), F), this.patchUpdatedImage(this.patternPositions[W], S.getImage(W), F);
+              }
+              patchUpdatedImage(S, F, W) {
+                if (!S || !F || S.version === F.version) return;
+                S.version = F.version;
+                let [te, fe] = S.tl;
+                W.update(F.data, void 0, { x: te, y: fe });
+              }
+            }
+            var Dv;
+            Fi("ImagePosition", Bw), Fi("ImageAtlas", Nw), i.ah = void 0, (Dv = i.ah || (i.ah = {}))[Dv.none = 0] = "none", Dv[Dv.horizontal = 1] = "horizontal", Dv[Dv.vertical = 2] = "vertical", Dv[Dv.horizontalOnly = 3] = "horizontalOnly";
+            let Eh = -17;
+            class $x {
+              constructor() {
+                this.scale = 1, this.fontStack = "", this.imageName = null;
+              }
+              static forText(S, F) {
+                let W = new $x();
+                return W.scale = S || 1, W.fontStack = F, W;
+              }
+              static forImage(S) {
+                let F = new $x();
+                return F.imageName = S, F;
+              }
+            }
+            class P1 {
+              constructor() {
+                this.text = "", this.sectionIndex = [], this.sections = [], this.imageSectionID = null;
+              }
+              static fromFeature(S, F) {
+                let W = new P1();
+                for (let te = 0; te < S.sections.length; te++) {
+                  let fe = S.sections[te];
+                  fe.image ? W.addImageSection(fe) : W.addTextSection(fe, F);
+                }
+                return W;
+              }
+              length() {
+                return this.text.length;
+              }
+              getSection(S) {
+                return this.sections[this.sectionIndex[S]];
+              }
+              getSectionIndex(S) {
+                return this.sectionIndex[S];
+              }
+              getCharCode(S) {
+                return this.text.charCodeAt(S);
+              }
+              verticalizePunctuation() {
+                this.text = function(S) {
+                  let F = "";
+                  for (let W = 0; W < S.length; W++) {
+                    let te = S.charCodeAt(W + 1) || null, fe = S.charCodeAt(W - 1) || null;
+                    F += te && ml(te) && !vc[S[W + 1]] || fe && ml(fe) && !vc[S[W - 1]] || !vc[S[W]] ? S[W] : vc[S[W]];
+                  }
+                  return F;
+                }(this.text);
+              }
+              trim() {
+                let S = 0;
+                for (let W = 0; W < this.text.length && Uw[this.text.charCodeAt(W)]; W++) S++;
+                let F = this.text.length;
+                for (let W = this.text.length - 1; W >= 0 && W >= S && Uw[this.text.charCodeAt(W)]; W--) F--;
+                this.text = this.text.substring(S, F), this.sectionIndex = this.sectionIndex.slice(S, F);
+              }
+              substring(S, F) {
+                let W = new P1();
+                return W.text = this.text.substring(S, F), W.sectionIndex = this.sectionIndex.slice(S, F), W.sections = this.sections, W;
+              }
+              toString() {
+                return this.text;
+              }
+              getMaxScale() {
+                return this.sectionIndex.reduce((S, F) => Math.max(S, this.sections[F].scale), 0);
+              }
+              addTextSection(S, F) {
+                this.text += S.text, this.sections.push($x.forText(S.scale, S.fontStack || F));
+                let W = this.sections.length - 1;
+                for (let te = 0; te < S.text.length; ++te) this.sectionIndex.push(W);
+              }
+              addImageSection(S) {
+                let F = S.image ? S.image.name : "";
+                if (F.length === 0) return void A("Can't add FormattedSection with an empty image.");
+                let W = this.getNextImageSectionCharCode();
+                W ? (this.text += String.fromCharCode(W), this.sections.push($x.forImage(F)), this.sectionIndex.push(this.sections.length - 1)) : A("Reached maximum number of images 6401");
+              }
+              getNextImageSectionCharCode() {
+                return this.imageSectionID ? this.imageSectionID >= 63743 ? null : ++this.imageSectionID : (this.imageSectionID = 57344, this.imageSectionID);
+              }
+            }
+            function Qx(R, S, F, W, te, fe, pe, Fe, Ke, ct, Lt, Jt, cr, mr, Pr) {
+              let zr = P1.fromFeature(R, te), ui;
+              Jt === i.ah.vertical && zr.verticalizePunctuation();
+              let { processBidirectionalText: yi, processStyledBidirectionalText: vn } = ys;
+              if (yi && zr.sections.length === 1) {
+                ui = [];
+                let Tn = yi(zr.toString(), I1(zr, ct, fe, S, W, mr));
+                for (let pa of Tn) {
+                  let ro = new P1();
+                  ro.text = pa, ro.sections = zr.sections;
+                  for (let Vo = 0; Vo < pa.length; Vo++) ro.sectionIndex.push(0);
+                  ui.push(ro);
+                }
+              } else if (vn) {
+                ui = [];
+                let Tn = vn(zr.text, zr.sectionIndex, I1(zr, ct, fe, S, W, mr));
+                for (let pa of Tn) {
+                  let ro = new P1();
+                  ro.text = pa[0], ro.sectionIndex = pa[1], ro.sections = zr.sections, ui.push(ro);
+                }
+              } else ui = function(Tn, pa) {
+                let ro = [], Vo = Tn.text, Xa = 0;
+                for (let sa of pa) ro.push(Tn.substring(Xa, sa)), Xa = sa;
+                return Xa < Vo.length && ro.push(Tn.substring(Xa, Vo.length)), ro;
+              }(zr, I1(zr, ct, fe, S, W, mr));
+              let zi = [], un = { positionedLines: zi, text: zr.toString(), top: Lt[1], bottom: Lt[1], left: Lt[0], right: Lt[0], writingMode: Jt, iconsInText: false, verticalizable: false };
+              return function(Tn, pa, ro, Vo, Xa, sa, Mo, fo, lo, Xn, Ro, uo) {
+                let $o = 0, Ju = Eh, qu = 0, kh = 0, Qv = fo === "right" ? 1 : fo === "left" ? 0 : 0.5, ud = 0;
+                for (let Af of Xa) {
+                  Af.trim();
+                  let Lh = Af.getMaxScale(), Ed = (Lh - 1) * tu, cd = { positionedGlyphs: [], lineOffset: 0 };
+                  Tn.positionedLines[ud] = cd;
+                  let Yh = cd.positionedGlyphs, Df = 0;
+                  if (!Af.length()) {
+                    Ju += sa, ++ud;
+                    continue;
+                  }
+                  for (let lv = 0; lv < Af.length(); lv++) {
+                    let ru = Af.getSection(lv), pc = Af.getSectionIndex(lv), $u = Af.getCharCode(lv), zv = 0, ff = null, q1 = null, p0 = null, Gp = tu, ep = !(lo === i.ah.horizontal || !Ro && !Ho($u) || Ro && (Uw[$u] || (Ch = $u, new RegExp("\\p{sc=Arab}", "u").test(String.fromCodePoint(Ch)))));
+                    if (ru.imageName) {
+                      let Gc = Vo[ru.imageName];
+                      if (!Gc) continue;
+                      p0 = ru.imageName, Tn.iconsInText = Tn.iconsInText || true, q1 = Gc.paddedRect;
+                      let Yf = Gc.displaySize;
+                      ru.scale = ru.scale * tu / uo, ff = { width: Yf[0], height: Yf[1], left: Md, top: -3, advance: ep ? Yf[1] : Yf[0] }, zv = Ed + (tu - Yf[1] * ru.scale), Gp = ff.advance;
+                      let tp = ep ? Yf[0] * ru.scale - tu * Lh : Yf[1] * ru.scale - tu * Lh;
+                      tp > 0 && tp > Df && (Df = tp);
+                    } else {
+                      let Gc = ro[ru.fontStack], Yf = Gc && Gc[$u];
+                      if (Yf && Yf.rect) q1 = Yf.rect, ff = Yf.metrics;
+                      else {
+                        let tp = pa[ru.fontStack], yg = tp && tp[$u];
+                        if (!yg) continue;
+                        ff = yg.metrics;
+                      }
+                      zv = (Lh - ru.scale) * tu;
+                    }
+                    ep ? (Tn.verticalizable = true, Yh.push({ glyph: $u, imageName: p0, x: $o, y: Ju + zv, vertical: ep, scale: ru.scale, fontStack: ru.fontStack, sectionIndex: pc, metrics: ff, rect: q1 }), $o += Gp * ru.scale + Xn) : (Yh.push({ glyph: $u, imageName: p0, x: $o, y: Ju + zv, vertical: ep, scale: ru.scale, fontStack: ru.fontStack, sectionIndex: pc, metrics: ff, rect: q1 }), $o += ff.advance * ru.scale + Xn);
+                  }
+                  Yh.length !== 0 && (qu = Math.max($o - Xn, qu), cm(Yh, 0, Yh.length - 1, Qv, Df)), $o = 0;
+                  let Fv = sa * Lh + Df;
+                  cd.lineOffset = Math.max(Df, Ed), Ju += Fv, kh = Math.max(Fv, kh), ++ud;
+                }
+                var Ch;
+                let Vd = Ju - Eh, { horizontalAlign: Gd, verticalAlign: Hd } = Gw(Mo);
+                (function(Af, Lh, Ed, cd, Yh, Df, Fv, lv, ru) {
+                  let pc = (Lh - Ed) * Yh, $u = 0;
+                  $u = Df !== Fv ? -lv * cd - Eh : (-cd * ru + 0.5) * Fv;
+                  for (let zv of Af) for (let ff of zv.positionedGlyphs) ff.x += pc, ff.y += $u;
+                })(Tn.positionedLines, Qv, Gd, Hd, qu, kh, sa, Vd, Xa.length), Tn.top += -Hd * Vd, Tn.bottom = Tn.top + Vd, Tn.left += -Gd * qu, Tn.right = Tn.left + qu;
+              }(un, S, F, W, ui, pe, Fe, Ke, Jt, ct, cr, Pr), !function(Tn) {
+                for (let pa of Tn) if (pa.positionedGlyphs.length !== 0) return false;
+                return true;
+              }(zi) && un;
+            }
+            let Uw = { 9: true, 10: true, 11: true, 12: true, 13: true, 32: true }, K9 = { 10: true, 32: true, 38: true, 41: true, 43: true, 45: true, 47: true, 173: true, 183: true, 8203: true, 8208: true, 8211: true, 8231: true }, J9 = { 40: true };
+            function kC(R, S, F, W, te, fe) {
+              if (S.imageName) {
+                let pe = W[S.imageName];
+                return pe ? pe.displaySize[0] * S.scale * tu / fe + te : 0;
+              }
+              {
+                let pe = F[S.fontStack], Fe = pe && pe[R];
+                return Fe ? Fe.metrics.advance * S.scale + te : 0;
+              }
+            }
+            function CC(R, S, F, W) {
+              let te = Math.pow(R - S, 2);
+              return W ? R < S ? te / 2 : 2 * te : te + Math.abs(F) * F;
+            }
+            function $9(R, S, F) {
+              let W = 0;
+              return R === 10 && (W -= 1e4), F && (W += 150), R !== 40 && R !== 65288 || (W += 50), S !== 41 && S !== 65289 || (W += 50), W;
+            }
+            function Vw(R, S, F, W, te, fe) {
+              let pe = null, Fe = CC(S, F, te, fe);
+              for (let Ke of W) {
+                let ct = CC(S - Ke.x, F, te, fe) + Ke.badness;
+                ct <= Fe && (pe = Ke, Fe = ct);
+              }
+              return { index: R, x: S, priorBreak: pe, badness: Fe };
+            }
+            function LC(R) {
+              return R ? LC(R.priorBreak).concat(R.index) : [];
+            }
+            function I1(R, S, F, W, te, fe) {
+              if (!R) return [];
+              let pe = [], Fe = function(Jt, cr, mr, Pr, zr, ui) {
+                let yi = 0;
+                for (let vn = 0; vn < Jt.length(); vn++) {
+                  let zi = Jt.getSection(vn);
+                  yi += kC(Jt.getCharCode(vn), zi, Pr, zr, cr, ui);
+                }
+                return yi / Math.max(1, Math.ceil(yi / mr));
+              }(R, S, F, W, te, fe), Ke = R.text.indexOf("​") >= 0, ct = 0;
+              for (let Jt = 0; Jt < R.length(); Jt++) {
+                let cr = R.getSection(Jt), mr = R.getCharCode(Jt);
+                if (Uw[mr] || (ct += kC(mr, cr, W, te, S, fe)), Jt < R.length() - 1) {
+                  let Pr = !((Lt = mr) < 11904) && (!!Dn["CJK Compatibility Forms"](Lt) || !!Dn["CJK Compatibility"](Lt) || !!Dn["CJK Strokes"](Lt) || !!Dn["CJK Symbols and Punctuation"](Lt) || !!Dn["Enclosed CJK Letters and Months"](Lt) || !!Dn["Halfwidth and Fullwidth Forms"](Lt) || !!Dn["Ideographic Description Characters"](Lt) || !!Dn["Vertical Forms"](Lt) || ws.test(String.fromCodePoint(Lt)));
+                  (K9[mr] || Pr || cr.imageName || Jt !== R.length() - 2 && J9[R.getCharCode(Jt + 1)]) && pe.push(Vw(Jt + 1, ct, Fe, pe, $9(mr, R.getCharCode(Jt + 1), Pr && Ke), false));
+                }
+              }
+              var Lt;
+              return LC(Vw(R.length(), ct, Fe, pe, 0, true));
+            }
+            function Gw(R) {
+              let S = 0.5, F = 0.5;
+              switch (R) {
+                case "right":
+                case "top-right":
+                case "bottom-right":
+                  S = 1;
+                  break;
+                case "left":
+                case "top-left":
+                case "bottom-left":
+                  S = 0;
+              }
+              switch (R) {
+                case "bottom":
+                case "bottom-right":
+                case "bottom-left":
+                  F = 1;
+                  break;
+                case "top":
+                case "top-right":
+                case "top-left":
+                  F = 0;
+              }
+              return { horizontalAlign: S, verticalAlign: F };
+            }
+            function cm(R, S, F, W, te) {
+              if (!W && !te) return;
+              let fe = R[F], pe = (R[F].x + fe.metrics.advance * fe.scale) * W;
+              for (let Fe = S; Fe <= F; Fe++) R[Fe].x -= pe, R[Fe].y += te;
+            }
+            function eb(R, S, F) {
+              let { horizontalAlign: W, verticalAlign: te } = Gw(F), fe = S[0] - R.displaySize[0] * W, pe = S[1] - R.displaySize[1] * te;
+              return { image: R, top: pe, bottom: pe + R.displaySize[1], left: fe, right: fe + R.displaySize[0] };
+            }
+            function PC(R) {
+              var S, F;
+              let W = R.left, te = R.top, fe = R.right - W, pe = R.bottom - te, Fe = (S = R.image.textFitWidth) !== null && S !== void 0 ? S : "stretchOrShrink", Ke = (F = R.image.textFitHeight) !== null && F !== void 0 ? F : "stretchOrShrink", ct = (R.image.content[2] - R.image.content[0]) / (R.image.content[3] - R.image.content[1]);
+              if (Ke === "proportional") {
+                if (Fe === "stretchOnly" && fe / pe < ct || Fe === "proportional") {
+                  let Lt = Math.ceil(pe * ct);
+                  W *= Lt / fe, fe = Lt;
+                }
+              } else if (Fe === "proportional" && Ke === "stretchOnly" && ct !== 0 && fe / pe > ct) {
+                let Lt = Math.ceil(fe / ct);
+                te *= Lt / pe, pe = Lt;
+              }
+              return { x1: W, y1: te, x2: W + fe, y2: te + pe };
+            }
+            function IC(R, S, F, W, te, fe) {
+              let pe = R.image, Fe;
+              if (pe.content) {
+                let ui = pe.content, yi = pe.pixelRatio || 1;
+                Fe = [ui[0] / yi, ui[1] / yi, pe.displaySize[0] - ui[2] / yi, pe.displaySize[1] - ui[3] / yi];
+              }
+              let Ke = S.left * fe, ct = S.right * fe, Lt, Jt, cr, mr;
+              F === "width" || F === "both" ? (mr = te[0] + Ke - W[3], Jt = te[0] + ct + W[1]) : (mr = te[0] + (Ke + ct - pe.displaySize[0]) / 2, Jt = mr + pe.displaySize[0]);
+              let Pr = S.top * fe, zr = S.bottom * fe;
+              return F === "height" || F === "both" ? (Lt = te[1] + Pr - W[0], cr = te[1] + zr + W[2]) : (Lt = te[1] + (Pr + zr - pe.displaySize[1]) / 2, cr = Lt + pe.displaySize[1]), { image: pe, top: Lt, right: Jt, bottom: cr, left: mr, collisionPadding: Fe };
+            }
+            let tb = 255, v0 = 128, fm = tb * v0;
+            function RC(R, S) {
+              let { expression: F } = S;
+              if (F.kind === "constant") return { kind: "constant", layoutSize: F.evaluate(new rs(R + 1)) };
+              if (F.kind === "source") return { kind: "source" };
+              {
+                let { zoomStops: W, interpolationType: te } = F, fe = 0;
+                for (; fe < W.length && W[fe] <= R; ) fe++;
+                fe = Math.max(0, fe - 1);
+                let pe = fe;
+                for (; pe < W.length && W[pe] < R + 1; ) pe++;
+                pe = Math.min(W.length - 1, pe);
+                let Fe = W[fe], Ke = W[pe];
+                return F.kind === "composite" ? { kind: "composite", minZoom: Fe, maxZoom: Ke, interpolationType: te } : { kind: "camera", minZoom: Fe, maxZoom: Ke, minSize: F.evaluate(new rs(Fe)), maxSize: F.evaluate(new rs(Ke)), interpolationType: te };
+              }
+            }
+            function fS(R, S, F) {
+              let W = "never", te = R.get(S);
+              return te ? W = te : R.get(F) && (W = "always"), W;
+            }
+            let Q9 = br.VectorTileFeature.types, eO = [{ name: "a_fade_opacity", components: 1, type: "Uint8", offset: 0 }];
+            function Hw(R, S, F, W, te, fe, pe, Fe, Ke, ct, Lt, Jt, cr) {
+              let mr = Fe ? Math.min(fm, Math.round(Fe[0])) : 0, Pr = Fe ? Math.min(fm, Math.round(Fe[1])) : 0;
+              R.emplaceBack(S, F, Math.round(32 * W), Math.round(32 * te), fe, pe, (mr << 1) + (Ke ? 1 : 0), Pr, 16 * ct, 16 * Lt, 256 * Jt, 256 * cr);
+            }
+            function hS(R, S, F) {
+              R.emplaceBack(S.x, S.y, F), R.emplaceBack(S.x, S.y, F), R.emplaceBack(S.x, S.y, F), R.emplaceBack(S.x, S.y, F);
+            }
+            function dS(R) {
+              for (let S of R.sections) if (no(S.text)) return true;
+              return false;
+            }
+            class vS {
+              constructor(S) {
+                this.layoutVertexArray = new eu(), this.indexArray = new se(), this.programConfigurations = S, this.segments = new Ye(), this.dynamicLayoutVertexArray = new dc(), this.opacityVertexArray = new Tl(), this.hasVisibleVertices = false, this.placedSymbolArray = new Aa();
+              }
+              isEmpty() {
+                return this.layoutVertexArray.length === 0 && this.indexArray.length === 0 && this.dynamicLayoutVertexArray.length === 0 && this.opacityVertexArray.length === 0;
+              }
+              upload(S, F, W, te) {
+                this.isEmpty() || (W && (this.layoutVertexBuffer = S.createVertexBuffer(this.layoutVertexArray, am.members), this.indexBuffer = S.createIndexBuffer(this.indexArray, F), this.dynamicLayoutVertexBuffer = S.createVertexBuffer(this.dynamicLayoutVertexArray, k1.members, true), this.opacityVertexBuffer = S.createVertexBuffer(this.opacityVertexArray, eO, true), this.opacityVertexBuffer.itemSize = 1), (W || te) && this.programConfigurations.upload(S));
+              }
+              destroy() {
+                this.layoutVertexBuffer && (this.layoutVertexBuffer.destroy(), this.indexBuffer.destroy(), this.programConfigurations.destroy(), this.segments.destroy(), this.dynamicLayoutVertexBuffer.destroy(), this.opacityVertexBuffer.destroy());
+              }
+            }
+            Fi("SymbolBuffers", vS);
+            class hm {
+              constructor(S, F, W) {
+                this.layoutVertexArray = new S(), this.layoutAttributes = F, this.indexArray = new W(), this.segments = new Ye(), this.collisionVertexArray = new X();
+              }
+              upload(S) {
+                this.layoutVertexBuffer = S.createVertexBuffer(this.layoutVertexArray, this.layoutAttributes), this.indexBuffer = S.createIndexBuffer(this.indexArray), this.collisionVertexBuffer = S.createVertexBuffer(this.collisionVertexArray, C1.members, true);
+              }
+              destroy() {
+                this.layoutVertexBuffer && (this.layoutVertexBuffer.destroy(), this.indexBuffer.destroy(), this.segments.destroy(), this.collisionVertexBuffer.destroy());
+              }
+            }
+            Fi("CollisionBuffers", hm);
+            class R1 {
+              constructor(S) {
+                this.collisionBoxArray = S.collisionBoxArray, this.zoom = S.zoom, this.overscaling = S.overscaling, this.layers = S.layers, this.layerIds = this.layers.map((pe) => pe.id), this.index = S.index, this.pixelRatio = S.pixelRatio, this.sourceLayerIndex = S.sourceLayerIndex, this.hasPattern = false, this.hasRTLText = false, this.sortKeyRanges = [], this.collisionCircleArray = [], this.placementInvProjMatrix = Ri([]), this.placementViewportMatrix = Ri([]);
+                let F = this.layers[0]._unevaluatedLayout._values;
+                this.textSizeData = RC(this.zoom, F["text-size"]), this.iconSizeData = RC(this.zoom, F["icon-size"]);
+                let W = this.layers[0].layout, te = W.get("symbol-sort-key"), fe = W.get("symbol-z-order");
+                this.canOverlap = fS(W, "text-overlap", "text-allow-overlap") !== "never" || fS(W, "icon-overlap", "icon-allow-overlap") !== "never" || W.get("text-ignore-placement") || W.get("icon-ignore-placement"), this.sortFeaturesByKey = fe !== "viewport-y" && !te.isConstant(), this.sortFeaturesByY = (fe === "viewport-y" || fe === "auto" && !this.sortFeaturesByKey) && this.canOverlap, W.get("symbol-placement") === "point" && (this.writingModes = W.get("text-writing-mode").map((pe) => i.ah[pe])), this.stateDependentLayerIds = this.layers.filter((pe) => pe.isStateDependent()).map((pe) => pe.id), this.sourceID = S.sourceID;
+              }
+              createArrays() {
+                this.text = new vS(new Ms(this.layers, this.zoom, (S) => /^text/.test(S))), this.icon = new vS(new Ms(this.layers, this.zoom, (S) => /^icon/.test(S))), this.glyphOffsetArray = new Co(), this.lineVertexArray = new Qa(), this.symbolInstances = new $a(), this.textAnchorOffsets = new Bo();
+              }
+              calculateGlyphDependencies(S, F, W, te, fe) {
+                for (let pe = 0; pe < S.length; pe++) if (F[S.charCodeAt(pe)] = true, (W || te) && fe) {
+                  let Fe = vc[S.charAt(pe)];
+                  Fe && (F[Fe.charCodeAt(0)] = true);
+                }
+              }
+              populate(S, F, W) {
+                let te = this.layers[0], fe = te.layout, pe = fe.get("text-font"), Fe = fe.get("text-field"), Ke = fe.get("icon-image"), ct = (Fe.value.kind !== "constant" || Fe.value.value instanceof ri && !Fe.value.value.isEmpty() || Fe.value.value.toString().length > 0) && (pe.value.kind !== "constant" || pe.value.value.length > 0), Lt = Ke.value.kind !== "constant" || !!Ke.value.value || Object.keys(Ke.parameters).length > 0, Jt = fe.get("symbol-sort-key");
+                if (this.features = [], !ct && !Lt) return;
+                let cr = F.iconDependencies, mr = F.glyphDependencies, Pr = F.availableImages, zr = new rs(this.zoom);
+                for (let { feature: ui, id: yi, index: vn, sourceLayerIndex: zi } of S) {
+                  let un = te._featureFilter.needGeometry, Tn = Sl(ui, un);
+                  if (!te._featureFilter.filter(zr, Tn, W)) continue;
+                  let pa, ro;
+                  if (un || (Tn.geometry = $s(ui)), ct) {
+                    let Xa = te.getValueAndResolveTokens("text-field", Tn, W, Pr), sa = ri.factory(Xa), Mo = this.hasRTLText = this.hasRTLText || dS(sa);
+                    (!Mo || ys.getRTLTextPluginStatus() === "unavailable" || Mo && ys.isParsed()) && (pa = sm(sa, te, Tn));
+                  }
+                  if (Lt) {
+                    let Xa = te.getValueAndResolveTokens("icon-image", Tn, W, Pr);
+                    ro = Xa instanceof tn ? Xa : tn.fromString(Xa);
+                  }
+                  if (!pa && !ro) continue;
+                  let Vo = this.sortFeaturesByKey ? Jt.evaluate(Tn, {}, W) : void 0;
+                  if (this.features.push({ id: yi, text: pa, icon: ro, index: vn, sourceLayerIndex: zi, geometry: Tn.geometry, properties: ui.properties, type: Q9[ui.type], sortKey: Vo }), ro && (cr[ro.name] = true), pa) {
+                    let Xa = pe.evaluate(Tn, {}, W).join(","), sa = fe.get("text-rotation-alignment") !== "viewport" && fe.get("symbol-placement") !== "point";
+                    this.allowVerticalPlacement = this.writingModes && this.writingModes.indexOf(i.ah.vertical) >= 0;
+                    for (let Mo of pa.sections) if (Mo.image) cr[Mo.image.name] = true;
+                    else {
+                      let fo = Ka(pa.toString()), lo = Mo.fontStack || Xa, Xn = mr[lo] = mr[lo] || {};
+                      this.calculateGlyphDependencies(Mo.text, Xn, sa, this.allowVerticalPlacement, fo);
+                    }
+                  }
+                }
+                fe.get("symbol-placement") === "line" && (this.features = function(ui) {
+                  let yi = {}, vn = {}, zi = [], un = 0;
+                  function Tn(Xa) {
+                    zi.push(ui[Xa]), un++;
+                  }
+                  function pa(Xa, sa, Mo) {
+                    let fo = vn[Xa];
+                    return delete vn[Xa], vn[sa] = fo, zi[fo].geometry[0].pop(), zi[fo].geometry[0] = zi[fo].geometry[0].concat(Mo[0]), fo;
+                  }
+                  function ro(Xa, sa, Mo) {
+                    let fo = yi[sa];
+                    return delete yi[sa], yi[Xa] = fo, zi[fo].geometry[0].shift(), zi[fo].geometry[0] = Mo[0].concat(zi[fo].geometry[0]), fo;
+                  }
+                  function Vo(Xa, sa, Mo) {
+                    let fo = Mo ? sa[0][sa[0].length - 1] : sa[0][0];
+                    return `${Xa}:${fo.x}:${fo.y}`;
+                  }
+                  for (let Xa = 0; Xa < ui.length; Xa++) {
+                    let sa = ui[Xa], Mo = sa.geometry, fo = sa.text ? sa.text.toString() : null;
+                    if (!fo) {
+                      Tn(Xa);
+                      continue;
+                    }
+                    let lo = Vo(fo, Mo), Xn = Vo(fo, Mo, true);
+                    if (lo in vn && Xn in yi && vn[lo] !== yi[Xn]) {
+                      let Ro = ro(lo, Xn, Mo), uo = pa(lo, Xn, zi[Ro].geometry);
+                      delete yi[lo], delete vn[Xn], vn[Vo(fo, zi[uo].geometry, true)] = uo, zi[Ro].geometry = null;
+                    } else lo in vn ? pa(lo, Xn, Mo) : Xn in yi ? ro(lo, Xn, Mo) : (Tn(Xa), yi[lo] = un - 1, vn[Xn] = un - 1);
+                  }
+                  return zi.filter((Xa) => Xa.geometry);
+                }(this.features)), this.sortFeaturesByKey && this.features.sort((ui, yi) => ui.sortKey - yi.sortKey);
+              }
+              update(S, F, W) {
+                this.stateDependentLayers.length && (this.text.programConfigurations.updatePaintArrays(S, F, this.layers, W), this.icon.programConfigurations.updatePaintArrays(S, F, this.layers, W));
+              }
+              isEmpty() {
+                return this.symbolInstances.length === 0 && !this.hasRTLText;
+              }
+              uploadPending() {
+                return !this.uploaded || this.text.programConfigurations.needsUpload || this.icon.programConfigurations.needsUpload;
+              }
+              upload(S) {
+                !this.uploaded && this.hasDebugData() && (this.textCollisionBox.upload(S), this.iconCollisionBox.upload(S)), this.text.upload(S, this.sortFeaturesByY, !this.uploaded, this.text.programConfigurations.needsUpload), this.icon.upload(S, this.sortFeaturesByY, !this.uploaded, this.icon.programConfigurations.needsUpload), this.uploaded = true;
+              }
+              destroyDebugData() {
+                this.textCollisionBox.destroy(), this.iconCollisionBox.destroy();
+              }
+              destroy() {
+                this.text.destroy(), this.icon.destroy(), this.hasDebugData() && this.destroyDebugData();
+              }
+              addToLineVertexArray(S, F) {
+                let W = this.lineVertexArray.length;
+                if (S.segment !== void 0) {
+                  let te = S.dist(F[S.segment + 1]), fe = S.dist(F[S.segment]), pe = {};
+                  for (let Fe = S.segment + 1; Fe < F.length; Fe++) pe[Fe] = { x: F[Fe].x, y: F[Fe].y, tileUnitDistanceFromAnchor: te }, Fe < F.length - 1 && (te += F[Fe + 1].dist(F[Fe]));
+                  for (let Fe = S.segment || 0; Fe >= 0; Fe--) pe[Fe] = { x: F[Fe].x, y: F[Fe].y, tileUnitDistanceFromAnchor: fe }, Fe > 0 && (fe += F[Fe - 1].dist(F[Fe]));
+                  for (let Fe = 0; Fe < F.length; Fe++) {
+                    let Ke = pe[Fe];
+                    this.lineVertexArray.emplaceBack(Ke.x, Ke.y, Ke.tileUnitDistanceFromAnchor);
+                  }
+                }
+                return { lineStartIndex: W, lineLength: this.lineVertexArray.length - W };
+              }
+              addSymbols(S, F, W, te, fe, pe, Fe, Ke, ct, Lt, Jt, cr) {
+                let mr = S.indexArray, Pr = S.layoutVertexArray, zr = S.segments.prepareSegment(4 * F.length, Pr, mr, this.canOverlap ? pe.sortKey : void 0), ui = this.glyphOffsetArray.length, yi = zr.vertexLength, vn = this.allowVerticalPlacement && Fe === i.ah.vertical ? Math.PI / 2 : 0, zi = pe.text && pe.text.sections;
+                for (let un = 0; un < F.length; un++) {
+                  let { tl: Tn, tr: pa, bl: ro, br: Vo, tex: Xa, pixelOffsetTL: sa, pixelOffsetBR: Mo, minFontScaleX: fo, minFontScaleY: lo, glyphOffset: Xn, isSDF: Ro, sectionIndex: uo } = F[un], $o = zr.vertexLength, Ju = Xn[1];
+                  Hw(Pr, Ke.x, Ke.y, Tn.x, Ju + Tn.y, Xa.x, Xa.y, W, Ro, sa.x, sa.y, fo, lo), Hw(Pr, Ke.x, Ke.y, pa.x, Ju + pa.y, Xa.x + Xa.w, Xa.y, W, Ro, Mo.x, sa.y, fo, lo), Hw(Pr, Ke.x, Ke.y, ro.x, Ju + ro.y, Xa.x, Xa.y + Xa.h, W, Ro, sa.x, Mo.y, fo, lo), Hw(Pr, Ke.x, Ke.y, Vo.x, Ju + Vo.y, Xa.x + Xa.w, Xa.y + Xa.h, W, Ro, Mo.x, Mo.y, fo, lo), hS(S.dynamicLayoutVertexArray, Ke, vn), mr.emplaceBack($o, $o + 1, $o + 2), mr.emplaceBack($o + 1, $o + 2, $o + 3), zr.vertexLength += 4, zr.primitiveLength += 2, this.glyphOffsetArray.emplaceBack(Xn[0]), un !== F.length - 1 && uo === F[un + 1].sectionIndex || S.programConfigurations.populatePaintArrays(Pr.length, pe, pe.index, {}, cr, zi && zi[uo]);
+                }
+                S.placedSymbolArray.emplaceBack(Ke.x, Ke.y, ui, this.glyphOffsetArray.length - ui, yi, ct, Lt, Ke.segment, W ? W[0] : 0, W ? W[1] : 0, te[0], te[1], Fe, 0, false, 0, Jt);
+              }
+              _addCollisionDebugVertex(S, F, W, te, fe, pe) {
+                return F.emplaceBack(0, 0), S.emplaceBack(W.x, W.y, te, fe, Math.round(pe.x), Math.round(pe.y));
+              }
+              addCollisionDebugVertices(S, F, W, te, fe, pe, Fe) {
+                let Ke = fe.segments.prepareSegment(4, fe.layoutVertexArray, fe.indexArray), ct = Ke.vertexLength, Lt = fe.layoutVertexArray, Jt = fe.collisionVertexArray, cr = Fe.anchorX, mr = Fe.anchorY;
+                this._addCollisionDebugVertex(Lt, Jt, pe, cr, mr, new u(S, F)), this._addCollisionDebugVertex(Lt, Jt, pe, cr, mr, new u(W, F)), this._addCollisionDebugVertex(Lt, Jt, pe, cr, mr, new u(W, te)), this._addCollisionDebugVertex(Lt, Jt, pe, cr, mr, new u(S, te)), Ke.vertexLength += 4;
+                let Pr = fe.indexArray;
+                Pr.emplaceBack(ct, ct + 1), Pr.emplaceBack(ct + 1, ct + 2), Pr.emplaceBack(ct + 2, ct + 3), Pr.emplaceBack(ct + 3, ct), Ke.primitiveLength += 4;
+              }
+              addDebugCollisionBoxes(S, F, W, te) {
+                for (let fe = S; fe < F; fe++) {
+                  let pe = this.collisionBoxArray.get(fe);
+                  this.addCollisionDebugVertices(pe.x1, pe.y1, pe.x2, pe.y2, te ? this.textCollisionBox : this.iconCollisionBox, pe.anchorPoint, W);
+                }
+              }
+              generateCollisionDebugBuffers() {
+                this.hasDebugData() && this.destroyDebugData(), this.textCollisionBox = new hm(Al, dy.members, Te), this.iconCollisionBox = new hm(Al, dy.members, Te);
+                for (let S = 0; S < this.symbolInstances.length; S++) {
+                  let F = this.symbolInstances.get(S);
+                  this.addDebugCollisionBoxes(F.textBoxStartIndex, F.textBoxEndIndex, F, true), this.addDebugCollisionBoxes(F.verticalTextBoxStartIndex, F.verticalTextBoxEndIndex, F, true), this.addDebugCollisionBoxes(F.iconBoxStartIndex, F.iconBoxEndIndex, F, false), this.addDebugCollisionBoxes(F.verticalIconBoxStartIndex, F.verticalIconBoxEndIndex, F, false);
+                }
+              }
+              _deserializeCollisionBoxesForSymbol(S, F, W, te, fe, pe, Fe, Ke, ct) {
+                let Lt = {};
+                for (let Jt = F; Jt < W; Jt++) {
+                  let cr = S.get(Jt);
+                  Lt.textBox = { x1: cr.x1, y1: cr.y1, x2: cr.x2, y2: cr.y2, anchorPointX: cr.anchorPointX, anchorPointY: cr.anchorPointY }, Lt.textFeatureIndex = cr.featureIndex;
+                  break;
+                }
+                for (let Jt = te; Jt < fe; Jt++) {
+                  let cr = S.get(Jt);
+                  Lt.verticalTextBox = { x1: cr.x1, y1: cr.y1, x2: cr.x2, y2: cr.y2, anchorPointX: cr.anchorPointX, anchorPointY: cr.anchorPointY }, Lt.verticalTextFeatureIndex = cr.featureIndex;
+                  break;
+                }
+                for (let Jt = pe; Jt < Fe; Jt++) {
+                  let cr = S.get(Jt);
+                  Lt.iconBox = { x1: cr.x1, y1: cr.y1, x2: cr.x2, y2: cr.y2, anchorPointX: cr.anchorPointX, anchorPointY: cr.anchorPointY }, Lt.iconFeatureIndex = cr.featureIndex;
+                  break;
+                }
+                for (let Jt = Ke; Jt < ct; Jt++) {
+                  let cr = S.get(Jt);
+                  Lt.verticalIconBox = { x1: cr.x1, y1: cr.y1, x2: cr.x2, y2: cr.y2, anchorPointX: cr.anchorPointX, anchorPointY: cr.anchorPointY }, Lt.verticalIconFeatureIndex = cr.featureIndex;
+                  break;
+                }
+                return Lt;
+              }
+              deserializeCollisionBoxes(S) {
+                this.collisionArrays = [];
+                for (let F = 0; F < this.symbolInstances.length; F++) {
+                  let W = this.symbolInstances.get(F);
+                  this.collisionArrays.push(this._deserializeCollisionBoxesForSymbol(S, W.textBoxStartIndex, W.textBoxEndIndex, W.verticalTextBoxStartIndex, W.verticalTextBoxEndIndex, W.iconBoxStartIndex, W.iconBoxEndIndex, W.verticalIconBoxStartIndex, W.verticalIconBoxEndIndex));
+                }
+              }
+              hasTextData() {
+                return this.text.segments.get().length > 0;
+              }
+              hasIconData() {
+                return this.icon.segments.get().length > 0;
+              }
+              hasDebugData() {
+                return this.textCollisionBox && this.iconCollisionBox;
+              }
+              hasTextCollisionBoxData() {
+                return this.hasDebugData() && this.textCollisionBox.segments.get().length > 0;
+              }
+              hasIconCollisionBoxData() {
+                return this.hasDebugData() && this.iconCollisionBox.segments.get().length > 0;
+              }
+              addIndicesForPlacedSymbol(S, F) {
+                let W = S.placedSymbolArray.get(F), te = W.vertexStartIndex + 4 * W.numGlyphs;
+                for (let fe = W.vertexStartIndex; fe < te; fe += 4) S.indexArray.emplaceBack(fe, fe + 1, fe + 2), S.indexArray.emplaceBack(fe + 1, fe + 2, fe + 3);
+              }
+              getSortedSymbolIndexes(S) {
+                if (this.sortedAngle === S && this.symbolInstanceIndexes !== void 0) return this.symbolInstanceIndexes;
+                let F = Math.sin(S), W = Math.cos(S), te = [], fe = [], pe = [];
+                for (let Fe = 0; Fe < this.symbolInstances.length; ++Fe) {
+                  pe.push(Fe);
+                  let Ke = this.symbolInstances.get(Fe);
+                  te.push(0 | Math.round(F * Ke.anchorX + W * Ke.anchorY)), fe.push(Ke.featureIndex);
+                }
+                return pe.sort((Fe, Ke) => te[Fe] - te[Ke] || fe[Ke] - fe[Fe]), pe;
+              }
+              addToSortKeyRanges(S, F) {
+                let W = this.sortKeyRanges[this.sortKeyRanges.length - 1];
+                W && W.sortKey === F ? W.symbolInstanceEnd = S + 1 : this.sortKeyRanges.push({ sortKey: F, symbolInstanceStart: S, symbolInstanceEnd: S + 1 });
+              }
+              sortFeatures(S) {
+                if (this.sortFeaturesByY && this.sortedAngle !== S && !(this.text.segments.get().length > 1 || this.icon.segments.get().length > 1)) {
+                  this.symbolInstanceIndexes = this.getSortedSymbolIndexes(S), this.sortedAngle = S, this.text.indexArray.clear(), this.icon.indexArray.clear(), this.featureSortOrder = [];
+                  for (let F of this.symbolInstanceIndexes) {
+                    let W = this.symbolInstances.get(F);
+                    this.featureSortOrder.push(W.featureIndex), [W.rightJustifiedTextSymbolIndex, W.centerJustifiedTextSymbolIndex, W.leftJustifiedTextSymbolIndex].forEach((te, fe, pe) => {
+                      te >= 0 && pe.indexOf(te) === fe && this.addIndicesForPlacedSymbol(this.text, te);
+                    }), W.verticalPlacedTextSymbolIndex >= 0 && this.addIndicesForPlacedSymbol(this.text, W.verticalPlacedTextSymbolIndex), W.placedIconSymbolIndex >= 0 && this.addIndicesForPlacedSymbol(this.icon, W.placedIconSymbolIndex), W.verticalPlacedIconSymbolIndex >= 0 && this.addIndicesForPlacedSymbol(this.icon, W.verticalPlacedIconSymbolIndex);
+                  }
+                  this.text.indexBuffer && this.text.indexBuffer.updateData(this.text.indexArray), this.icon.indexBuffer && this.icon.indexBuffer.updateData(this.icon.indexArray);
+                }
+              }
+            }
+            let Tf, rb;
+            Fi("SymbolBucket", R1, { omit: ["layers", "collisionBoxArray", "features", "compareText"] }), R1.MAX_GLYPHS = 65535, R1.addDynamicAttributes = hS;
+            var jw = { get paint() {
+              return rb = rb || new ue({ "icon-opacity": new oo(ce.paint_symbol["icon-opacity"]), "icon-color": new oo(ce.paint_symbol["icon-color"]), "icon-halo-color": new oo(ce.paint_symbol["icon-halo-color"]), "icon-halo-width": new oo(ce.paint_symbol["icon-halo-width"]), "icon-halo-blur": new oo(ce.paint_symbol["icon-halo-blur"]), "icon-translate": new Ua(ce.paint_symbol["icon-translate"]), "icon-translate-anchor": new Ua(ce.paint_symbol["icon-translate-anchor"]), "text-opacity": new oo(ce.paint_symbol["text-opacity"]), "text-color": new oo(ce.paint_symbol["text-color"], { runtimeType: er, getOverride: (R) => R.textColor, hasOverride: (R) => !!R.textColor }), "text-halo-color": new oo(ce.paint_symbol["text-halo-color"]), "text-halo-width": new oo(ce.paint_symbol["text-halo-width"]), "text-halo-blur": new oo(ce.paint_symbol["text-halo-blur"]), "text-translate": new Ua(ce.paint_symbol["text-translate"]), "text-translate-anchor": new Ua(ce.paint_symbol["text-translate-anchor"]) });
+            }, get layout() {
+              return Tf = Tf || new ue({ "symbol-placement": new Ua(ce.layout_symbol["symbol-placement"]), "symbol-spacing": new Ua(ce.layout_symbol["symbol-spacing"]), "symbol-avoid-edges": new Ua(ce.layout_symbol["symbol-avoid-edges"]), "symbol-sort-key": new oo(ce.layout_symbol["symbol-sort-key"]), "symbol-z-order": new Ua(ce.layout_symbol["symbol-z-order"]), "icon-allow-overlap": new Ua(ce.layout_symbol["icon-allow-overlap"]), "icon-overlap": new Ua(ce.layout_symbol["icon-overlap"]), "icon-ignore-placement": new Ua(ce.layout_symbol["icon-ignore-placement"]), "icon-optional": new Ua(ce.layout_symbol["icon-optional"]), "icon-rotation-alignment": new Ua(ce.layout_symbol["icon-rotation-alignment"]), "icon-size": new oo(ce.layout_symbol["icon-size"]), "icon-text-fit": new Ua(ce.layout_symbol["icon-text-fit"]), "icon-text-fit-padding": new Ua(ce.layout_symbol["icon-text-fit-padding"]), "icon-image": new oo(ce.layout_symbol["icon-image"]), "icon-rotate": new oo(ce.layout_symbol["icon-rotate"]), "icon-padding": new oo(ce.layout_symbol["icon-padding"]), "icon-keep-upright": new Ua(ce.layout_symbol["icon-keep-upright"]), "icon-offset": new oo(ce.layout_symbol["icon-offset"]), "icon-anchor": new oo(ce.layout_symbol["icon-anchor"]), "icon-pitch-alignment": new Ua(ce.layout_symbol["icon-pitch-alignment"]), "text-pitch-alignment": new Ua(ce.layout_symbol["text-pitch-alignment"]), "text-rotation-alignment": new Ua(ce.layout_symbol["text-rotation-alignment"]), "text-field": new oo(ce.layout_symbol["text-field"]), "text-font": new oo(ce.layout_symbol["text-font"]), "text-size": new oo(ce.layout_symbol["text-size"]), "text-max-width": new oo(ce.layout_symbol["text-max-width"]), "text-line-height": new Ua(ce.layout_symbol["text-line-height"]), "text-letter-spacing": new oo(ce.layout_symbol["text-letter-spacing"]), "text-justify": new oo(ce.layout_symbol["text-justify"]), "text-radial-offset": new oo(ce.layout_symbol["text-radial-offset"]), "text-variable-anchor": new Ua(ce.layout_symbol["text-variable-anchor"]), "text-variable-anchor-offset": new oo(ce.layout_symbol["text-variable-anchor-offset"]), "text-anchor": new oo(ce.layout_symbol["text-anchor"]), "text-max-angle": new Ua(ce.layout_symbol["text-max-angle"]), "text-writing-mode": new Ua(ce.layout_symbol["text-writing-mode"]), "text-rotate": new oo(ce.layout_symbol["text-rotate"]), "text-padding": new Ua(ce.layout_symbol["text-padding"]), "text-keep-upright": new Ua(ce.layout_symbol["text-keep-upright"]), "text-transform": new oo(ce.layout_symbol["text-transform"]), "text-offset": new oo(ce.layout_symbol["text-offset"]), "text-allow-overlap": new Ua(ce.layout_symbol["text-allow-overlap"]), "text-overlap": new Ua(ce.layout_symbol["text-overlap"]), "text-ignore-placement": new Ua(ce.layout_symbol["text-ignore-placement"]), "text-optional": new Ua(ce.layout_symbol["text-optional"]) });
+            } };
+            class ib {
+              constructor(S) {
+                if (S.property.overrides === void 0) throw new Error("overrides must be provided to instantiate FormatSectionOverride class");
+                this.type = S.property.overrides ? S.property.overrides.runtimeType : Gt, this.defaultValue = S;
+              }
+              evaluate(S) {
+                if (S.formattedSection) {
+                  let F = this.defaultValue.property.overrides;
+                  if (F && F.hasOverride(S.formattedSection)) return F.getOverride(S.formattedSection);
+                }
+                return S.feature && S.featureState ? this.defaultValue.evaluate(S.feature, S.featureState) : this.defaultValue.property.specification.default;
+              }
+              eachChild(S) {
+                this.defaultValue.isConstant() || S(this.defaultValue.value._styleExpression.expression);
+              }
+              outputDefined() {
+                return false;
+              }
+              serialize() {
+                return null;
+              }
+            }
+            Fi("FormatSectionOverride", ib, { omit: ["defaultValue"] });
+            class gy extends B {
+              constructor(S) {
+                super(S, jw);
+              }
+              recalculate(S, F) {
+                if (super.recalculate(S, F), this.layout.get("icon-rotation-alignment") === "auto" && (this.layout._values["icon-rotation-alignment"] = this.layout.get("symbol-placement") !== "point" ? "map" : "viewport"), this.layout.get("text-rotation-alignment") === "auto" && (this.layout._values["text-rotation-alignment"] = this.layout.get("symbol-placement") !== "point" ? "map" : "viewport"), this.layout.get("text-pitch-alignment") === "auto" && (this.layout._values["text-pitch-alignment"] = this.layout.get("text-rotation-alignment") === "map" ? "map" : "viewport"), this.layout.get("icon-pitch-alignment") === "auto" && (this.layout._values["icon-pitch-alignment"] = this.layout.get("icon-rotation-alignment")), this.layout.get("symbol-placement") === "point") {
+                  let W = this.layout.get("text-writing-mode");
+                  if (W) {
+                    let te = [];
+                    for (let fe of W) te.indexOf(fe) < 0 && te.push(fe);
+                    this.layout._values["text-writing-mode"] = te;
+                  } else this.layout._values["text-writing-mode"] = ["horizontal"];
+                }
+                this._setPaintOverrides();
+              }
+              getValueAndResolveTokens(S, F, W, te) {
+                let fe = this.layout.get(S).evaluate(F, {}, W, te), pe = this._unevaluatedLayout._values[S];
+                return pe.isDataDriven() || Dc(pe.value) || !fe ? fe : function(Fe, Ke) {
+                  return Ke.replace(/{([^{}]+)}/g, (ct, Lt) => Fe && Lt in Fe ? String(Fe[Lt]) : "");
+                }(F.properties, fe);
+              }
+              createBucket(S) {
+                return new R1(S);
+              }
+              queryRadius() {
+                return 0;
+              }
+              queryIntersectsFeature() {
+                throw new Error("Should take a different path in FeatureIndex");
+              }
+              _setPaintOverrides() {
+                for (let S of jw.paint.overridableProperties) {
+                  if (!gy.hasPaintOverride(this.layout, S)) continue;
+                  let F = this.paint.get(S), W = new ib(F), te = new Eu(W, F.property.specification), fe = null;
+                  fe = F.value.kind === "constant" || F.value.kind === "source" ? new bc("source", te) : new hu("composite", te, F.value.zoomStops), this.paint._values[S] = new xu(F.property, fe, F.parameters);
+                }
+              }
+              _handleOverridablePaintPropertyUpdate(S, F, W) {
+                return !(!this.layout || F.isDataDriven() || W.isDataDriven()) && gy.hasPaintOverride(this.layout, S);
+              }
+              static hasPaintOverride(S, F) {
+                let W = S.get("text-field"), te = jw.paint.properties[F], fe = false, pe = (Fe) => {
+                  for (let Ke of Fe) if (te.overrides && te.overrides.hasOverride(Ke)) return void (fe = true);
+                };
+                if (W.value.kind === "constant" && W.value.value instanceof ri) pe(W.value.value.sections);
+                else if (W.value.kind === "source") {
+                  let Fe = (ct) => {
+                    fe || (ct instanceof ua && Sn(ct.value) === ti ? pe(ct.value.sections) : ct instanceof Yl ? pe(ct.sections) : ct.eachChild(Fe));
+                  }, Ke = W.value;
+                  Ke._styleExpression && Fe(Ke._styleExpression.expression);
+                }
+                return fe;
+              }
+            }
+            let DC;
+            var nb = { get paint() {
+              return DC = DC || new ue({ "background-color": new Ua(ce.paint_background["background-color"]), "background-pattern": new hc(ce.paint_background["background-pattern"]), "background-opacity": new Ua(ce.paint_background["background-opacity"]) });
+            } };
+            class tO extends B {
+              constructor(S) {
+                super(S, nb);
+              }
+            }
+            let pS;
+            var FC = { get paint() {
+              return pS = pS || new ue({ "raster-opacity": new Ua(ce.paint_raster["raster-opacity"]), "raster-hue-rotate": new Ua(ce.paint_raster["raster-hue-rotate"]), "raster-brightness-min": new Ua(ce.paint_raster["raster-brightness-min"]), "raster-brightness-max": new Ua(ce.paint_raster["raster-brightness-max"]), "raster-saturation": new Ua(ce.paint_raster["raster-saturation"]), "raster-contrast": new Ua(ce.paint_raster["raster-contrast"]), "raster-resampling": new Ua(ce.paint_raster["raster-resampling"]), "raster-fade-duration": new Ua(ce.paint_raster["raster-fade-duration"]) });
+            } };
+            class ab extends B {
+              constructor(S) {
+                super(S, FC);
+              }
+            }
+            class gS extends B {
+              constructor(S) {
+                super(S, {}), this.onAdd = (F) => {
+                  this.implementation.onAdd && this.implementation.onAdd(F, F.painter.context.gl);
+                }, this.onRemove = (F) => {
+                  this.implementation.onRemove && this.implementation.onRemove(F, F.painter.context.gl);
+                }, this.implementation = S;
+              }
+              is3D() {
+                return this.implementation.renderingMode === "3d";
+              }
+              hasOffscreenPass() {
+                return this.implementation.prerender !== void 0;
+              }
+              recalculate() {
+              }
+              updateTransitions() {
+              }
+              hasTransition() {
+                return false;
+              }
+              serialize() {
+                throw new Error("Custom layers cannot be serialized");
+              }
+            }
+            class mS {
+              constructor(S) {
+                this._methodToThrottle = S, this._triggered = false, typeof MessageChannel != "undefined" && (this._channel = new MessageChannel(), this._channel.port2.onmessage = () => {
+                  this._triggered = false, this._methodToThrottle();
+                });
+              }
+              trigger() {
+                this._triggered || (this._triggered = true, this._channel ? this._channel.port1.postMessage(true) : setTimeout(() => {
+                  this._triggered = false, this._methodToThrottle();
+                }, 0));
+              }
+              remove() {
+                delete this._channel, this._methodToThrottle = () => {
+                };
+              }
+            }
+            let yS = 63710088e-1;
+            class pg {
+              constructor(S, F) {
+                if (isNaN(S) || isNaN(F)) throw new Error(`Invalid LngLat object: (${S}, ${F})`);
+                if (this.lng = +S, this.lat = +F, this.lat > 90 || this.lat < -90) throw new Error("Invalid LngLat latitude value: must be between -90 and 90");
+              }
+              wrap() {
+                return new pg(T(this.lng, -180, 180), this.lat);
+              }
+              toArray() {
+                return [this.lng, this.lat];
+              }
+              toString() {
+                return `LngLat(${this.lng}, ${this.lat})`;
+              }
+              distanceTo(S) {
+                let F = Math.PI / 180, W = this.lat * F, te = S.lat * F, fe = Math.sin(W) * Math.sin(te) + Math.cos(W) * Math.cos(te) * Math.cos((S.lng - this.lng) * F);
+                return yS * Math.acos(Math.min(fe, 1));
+              }
+              static convert(S) {
+                if (S instanceof pg) return S;
+                if (Array.isArray(S) && (S.length === 2 || S.length === 3)) return new pg(Number(S[0]), Number(S[1]));
+                if (!Array.isArray(S) && typeof S == "object" && S !== null) return new pg(Number("lng" in S ? S.lng : S.lon), Number(S.lat));
+                throw new Error("`LngLatLike` argument must be specified as a LngLat instance, an object {lng: <lng>, lat: <lat>}, an object {lon: <lng>, lat: <lat>}, or an array of [<lng>, <lat>]");
+              }
+            }
+            let D1 = 2 * Math.PI * yS;
+            function zC(R) {
+              return D1 * Math.cos(R * Math.PI / 180);
+            }
+            function Ww(R) {
+              return (180 + R) / 360;
+            }
+            function OC(R) {
+              return (180 - 180 / Math.PI * Math.log(Math.tan(Math.PI / 4 + R * Math.PI / 360))) / 360;
+            }
+            function Xw(R, S) {
+              return R / zC(S);
+            }
+            function ob(R) {
+              return 360 / Math.PI * Math.atan(Math.exp((180 - 360 * R) * Math.PI / 180)) - 90;
+            }
+            class sb {
+              constructor(S, F, W = 0) {
+                this.x = +S, this.y = +F, this.z = +W;
+              }
+              static fromLngLat(S, F = 0) {
+                let W = pg.convert(S);
+                return new sb(Ww(W.lng), OC(W.lat), Xw(F, W.lat));
+              }
+              toLngLat() {
+                return new pg(360 * this.x - 180, ob(this.y));
+              }
+              toAltitude() {
+                return this.z * zC(ob(this.y));
+              }
+              meterInMercatorCoordinateUnits() {
+                return 1 / D1 * (S = ob(this.y), 1 / Math.cos(S * Math.PI / 180));
+                var S;
+              }
+            }
+            function yp(R, S, F) {
+              var W = 2 * Math.PI * 6378137 / 256 / Math.pow(2, F);
+              return [R * W - 2 * Math.PI * 6378137 / 2, S * W - 2 * Math.PI * 6378137 / 2];
+            }
+            class _S {
+              constructor(S, F, W) {
+                if (!function(te, fe, pe) {
+                  return !(te < 0 || te > 25 || pe < 0 || pe >= Math.pow(2, te) || fe < 0 || fe >= Math.pow(2, te));
+                }(S, F, W)) throw new Error(`x=${F}, y=${W}, z=${S} outside of bounds. 0<=x<${Math.pow(2, S)}, 0<=y<${Math.pow(2, S)} 0<=z<=25 `);
+                this.z = S, this.x = F, this.y = W, this.key = lb(0, S, S, F, W);
+              }
+              equals(S) {
+                return this.z === S.z && this.x === S.x && this.y === S.y;
+              }
+              url(S, F, W) {
+                let te = (pe = this.y, Fe = this.z, Ke = yp(256 * (fe = this.x), 256 * (pe = Math.pow(2, Fe) - pe - 1), Fe), ct = yp(256 * (fe + 1), 256 * (pe + 1), Fe), Ke[0] + "," + Ke[1] + "," + ct[0] + "," + ct[1]);
+                var fe, pe, Fe, Ke, ct;
+                let Lt = function(Jt, cr, mr) {
+                  let Pr, zr = "";
+                  for (let ui = Jt; ui > 0; ui--) Pr = 1 << ui - 1, zr += (cr & Pr ? 1 : 0) + (mr & Pr ? 2 : 0);
+                  return zr;
+                }(this.z, this.x, this.y);
+                return S[(this.x + this.y) % S.length].replace(/{prefix}/g, (this.x % 16).toString(16) + (this.y % 16).toString(16)).replace(/{z}/g, String(this.z)).replace(/{x}/g, String(this.x)).replace(/{y}/g, String(W === "tms" ? Math.pow(2, this.z) - this.y - 1 : this.y)).replace(/{ratio}/g, F > 1 ? "@2x" : "").replace(/{quadkey}/g, Lt).replace(/{bbox-epsg-3857}/g, te);
+              }
+              isChildOf(S) {
+                let F = this.z - S.z;
+                return F > 0 && S.x === this.x >> F && S.y === this.y >> F;
+              }
+              getTilePoint(S) {
+                let F = Math.pow(2, this.z);
+                return new u((S.x * F - this.x) * ja, (S.y * F - this.y) * ja);
+              }
+              toString() {
+                return `${this.z}/${this.x}/${this.y}`;
+              }
+            }
+            class qC {
+              constructor(S, F) {
+                this.wrap = S, this.canonical = F, this.key = lb(S, F.z, F.z, F.x, F.y);
+              }
+            }
+            class $v {
+              constructor(S, F, W, te, fe) {
+                if (S < W) throw new Error(`overscaledZ should be >= z; overscaledZ = ${S}; z = ${W}`);
+                this.overscaledZ = S, this.wrap = F, this.canonical = new _S(W, +te, +fe), this.key = lb(F, S, W, te, fe);
+              }
+              clone() {
+                return new $v(this.overscaledZ, this.wrap, this.canonical.z, this.canonical.x, this.canonical.y);
+              }
+              equals(S) {
+                return this.overscaledZ === S.overscaledZ && this.wrap === S.wrap && this.canonical.equals(S.canonical);
+              }
+              scaledTo(S) {
+                if (S > this.overscaledZ) throw new Error(`targetZ > this.overscaledZ; targetZ = ${S}; overscaledZ = ${this.overscaledZ}`);
+                let F = this.canonical.z - S;
+                return S > this.canonical.z ? new $v(S, this.wrap, this.canonical.z, this.canonical.x, this.canonical.y) : new $v(S, this.wrap, S, this.canonical.x >> F, this.canonical.y >> F);
+              }
+              calculateScaledKey(S, F) {
+                if (S > this.overscaledZ) throw new Error(`targetZ > this.overscaledZ; targetZ = ${S}; overscaledZ = ${this.overscaledZ}`);
+                let W = this.canonical.z - S;
+                return S > this.canonical.z ? lb(this.wrap * +F, S, this.canonical.z, this.canonical.x, this.canonical.y) : lb(this.wrap * +F, S, S, this.canonical.x >> W, this.canonical.y >> W);
+              }
+              isChildOf(S) {
+                if (S.wrap !== this.wrap) return false;
+                let F = this.canonical.z - S.canonical.z;
+                return S.overscaledZ === 0 || S.overscaledZ < this.overscaledZ && S.canonical.x === this.canonical.x >> F && S.canonical.y === this.canonical.y >> F;
+              }
+              children(S) {
+                if (this.overscaledZ >= S) return [new $v(this.overscaledZ + 1, this.wrap, this.canonical.z, this.canonical.x, this.canonical.y)];
+                let F = this.canonical.z + 1, W = 2 * this.canonical.x, te = 2 * this.canonical.y;
+                return [new $v(F, this.wrap, F, W, te), new $v(F, this.wrap, F, W + 1, te), new $v(F, this.wrap, F, W, te + 1), new $v(F, this.wrap, F, W + 1, te + 1)];
+              }
+              isLessThan(S) {
+                return this.wrap < S.wrap || !(this.wrap > S.wrap) && (this.overscaledZ < S.overscaledZ || !(this.overscaledZ > S.overscaledZ) && (this.canonical.x < S.canonical.x || !(this.canonical.x > S.canonical.x) && this.canonical.y < S.canonical.y));
+              }
+              wrapped() {
+                return new $v(this.overscaledZ, 0, this.canonical.z, this.canonical.x, this.canonical.y);
+              }
+              unwrapTo(S) {
+                return new $v(this.overscaledZ, S, this.canonical.z, this.canonical.x, this.canonical.y);
+              }
+              overscaleFactor() {
+                return Math.pow(2, this.overscaledZ - this.canonical.z);
+              }
+              toUnwrapped() {
+                return new qC(this.wrap, this.canonical);
+              }
+              toString() {
+                return `${this.overscaledZ}/${this.canonical.x}/${this.canonical.y}`;
+              }
+              getTilePoint(S) {
+                return this.canonical.getTilePoint(new sb(S.x - this.wrap, S.y));
+              }
+            }
+            function lb(R, S, F, W, te) {
+              (R *= 2) < 0 && (R = -1 * R - 1);
+              let fe = 1 << F;
+              return (fe * fe * R + fe * te + W).toString(36) + F.toString(36) + S.toString(36);
+            }
+            Fi("CanonicalTileID", _S), Fi("OverscaledTileID", $v, { omit: ["posMatrix"] });
+            class BC {
+              constructor(S, F, W, te = 1, fe = 1, pe = 1, Fe = 0) {
+                if (this.uid = S, F.height !== F.width) throw new RangeError("DEM tiles must be square");
+                if (W && !["mapbox", "terrarium", "custom"].includes(W)) return void A(`"${W}" is not a valid encoding type. Valid types include "mapbox", "terrarium" and "custom".`);
+                this.stride = F.height;
+                let Ke = this.dim = F.height - 2;
+                switch (this.data = new Uint32Array(F.data.buffer), W) {
+                  case "terrarium":
+                    this.redFactor = 256, this.greenFactor = 1, this.blueFactor = 1 / 256, this.baseShift = 32768;
+                    break;
+                  case "custom":
+                    this.redFactor = te, this.greenFactor = fe, this.blueFactor = pe, this.baseShift = Fe;
+                    break;
+                  default:
+                    this.redFactor = 6553.6, this.greenFactor = 25.6, this.blueFactor = 0.1, this.baseShift = 1e4;
+                }
+                for (let ct = 0; ct < Ke; ct++) this.data[this._idx(-1, ct)] = this.data[this._idx(0, ct)], this.data[this._idx(Ke, ct)] = this.data[this._idx(Ke - 1, ct)], this.data[this._idx(ct, -1)] = this.data[this._idx(ct, 0)], this.data[this._idx(ct, Ke)] = this.data[this._idx(ct, Ke - 1)];
+                this.data[this._idx(-1, -1)] = this.data[this._idx(0, 0)], this.data[this._idx(Ke, -1)] = this.data[this._idx(Ke - 1, 0)], this.data[this._idx(-1, Ke)] = this.data[this._idx(0, Ke - 1)], this.data[this._idx(Ke, Ke)] = this.data[this._idx(Ke - 1, Ke - 1)], this.min = Number.MAX_SAFE_INTEGER, this.max = Number.MIN_SAFE_INTEGER;
+                for (let ct = 0; ct < Ke; ct++) for (let Lt = 0; Lt < Ke; Lt++) {
+                  let Jt = this.get(ct, Lt);
+                  Jt > this.max && (this.max = Jt), Jt < this.min && (this.min = Jt);
+                }
+              }
+              get(S, F) {
+                let W = new Uint8Array(this.data.buffer), te = 4 * this._idx(S, F);
+                return this.unpack(W[te], W[te + 1], W[te + 2]);
+              }
+              getUnpackVector() {
+                return [this.redFactor, this.greenFactor, this.blueFactor, this.baseShift];
+              }
+              _idx(S, F) {
+                if (S < -1 || S >= this.dim + 1 || F < -1 || F >= this.dim + 1) throw new RangeError("out of range source coordinates for DEM data");
+                return (F + 1) * this.stride + (S + 1);
+              }
+              unpack(S, F, W) {
+                return S * this.redFactor + F * this.greenFactor + W * this.blueFactor - this.baseShift;
+              }
+              getPixels() {
+                return new Ki({ width: this.stride, height: this.stride }, new Uint8Array(this.data.buffer));
+              }
+              backfillBorder(S, F, W) {
+                if (this.dim !== S.dim) throw new Error("dem dimension mismatch");
+                let te = F * this.dim, fe = F * this.dim + this.dim, pe = W * this.dim, Fe = W * this.dim + this.dim;
+                switch (F) {
+                  case -1:
+                    te = fe - 1;
+                    break;
+                  case 1:
+                    fe = te + 1;
+                }
+                switch (W) {
+                  case -1:
+                    pe = Fe - 1;
+                    break;
+                  case 1:
+                    Fe = pe + 1;
+                }
+                let Ke = -F * this.dim, ct = -W * this.dim;
+                for (let Lt = pe; Lt < Fe; Lt++) for (let Jt = te; Jt < fe; Jt++) this.data[this._idx(Jt, Lt)] = S.data[this._idx(Jt + Ke, Lt + ct)];
+              }
+            }
+            Fi("DEMData", BC);
+            class NC {
+              constructor(S) {
+                this._stringToNumber = {}, this._numberToString = [];
+                for (let F = 0; F < S.length; F++) {
+                  let W = S[F];
+                  this._stringToNumber[W] = F, this._numberToString[F] = W;
+                }
+              }
+              encode(S) {
+                return this._stringToNumber[S];
+              }
+              decode(S) {
+                if (S >= this._numberToString.length) throw new Error(`Out of bounds. Index requested n=${S} can't be >= this._numberToString.length ${this._numberToString.length}`);
+                return this._numberToString[S];
+              }
+            }
+            class xS {
+              constructor(S, F, W, te, fe) {
+                this.type = "Feature", this._vectorTileFeature = S, S._z = F, S._x = W, S._y = te, this.properties = S.properties, this.id = fe;
+              }
+              get geometry() {
+                return this._geometry === void 0 && (this._geometry = this._vectorTileFeature.toGeoJSON(this._vectorTileFeature._x, this._vectorTileFeature._y, this._vectorTileFeature._z).geometry), this._geometry;
+              }
+              set geometry(S) {
+                this._geometry = S;
+              }
+              toJSON() {
+                let S = { geometry: this.geometry };
+                for (let F in this) F !== "_geometry" && F !== "_vectorTileFeature" && (S[F] = this[F]);
+                return S;
+              }
+            }
+            class my {
+              constructor(S, F) {
+                this.tileID = S, this.x = S.canonical.x, this.y = S.canonical.y, this.z = S.canonical.z, this.grid = new Qi(ja, 16, 0), this.grid3D = new Qi(ja, 16, 0), this.featureIndexArray = new Ts(), this.promoteId = F;
+              }
+              insert(S, F, W, te, fe, pe) {
+                let Fe = this.featureIndexArray.length;
+                this.featureIndexArray.emplaceBack(W, te, fe);
+                let Ke = pe ? this.grid3D : this.grid;
+                for (let ct = 0; ct < F.length; ct++) {
+                  let Lt = F[ct], Jt = [1 / 0, 1 / 0, -1 / 0, -1 / 0];
+                  for (let cr = 0; cr < Lt.length; cr++) {
+                    let mr = Lt[cr];
+                    Jt[0] = Math.min(Jt[0], mr.x), Jt[1] = Math.min(Jt[1], mr.y), Jt[2] = Math.max(Jt[2], mr.x), Jt[3] = Math.max(Jt[3], mr.y);
+                  }
+                  Jt[0] < ja && Jt[1] < ja && Jt[2] >= 0 && Jt[3] >= 0 && Ke.insert(Fe, Jt[0], Jt[1], Jt[2], Jt[3]);
+                }
+              }
+              loadVTLayers() {
+                return this.vtLayers || (this.vtLayers = new br.VectorTile(new lS(this.rawTileData)).layers, this.sourceLayerCoder = new NC(this.vtLayers ? Object.keys(this.vtLayers).sort() : ["_geojsonTileLayer"])), this.vtLayers;
+              }
+              query(S, F, W, te) {
+                this.loadVTLayers();
+                let fe = S.params || {}, pe = ja / S.tileSize / S.scale, Fe = Fc(fe.filter), Ke = S.queryGeometry, ct = S.queryPadding * pe, Lt = VC(Ke), Jt = this.grid.query(Lt.minX - ct, Lt.minY - ct, Lt.maxX + ct, Lt.maxY + ct), cr = VC(S.cameraQueryGeometry), mr = this.grid3D.query(cr.minX - ct, cr.minY - ct, cr.maxX + ct, cr.maxY + ct, (ui, yi, vn, zi) => function(un, Tn, pa, ro, Vo) {
+                  for (let sa of un) if (Tn <= sa.x && pa <= sa.y && ro >= sa.x && Vo >= sa.y) return true;
+                  let Xa = [new u(Tn, pa), new u(Tn, Vo), new u(ro, Vo), new u(ro, pa)];
+                  if (un.length > 2) {
+                    for (let sa of Xa) if (Ui(un, sa)) return true;
+                  }
+                  for (let sa = 0; sa < un.length - 1; sa++) if (qi(un[sa], un[sa + 1], Xa)) return true;
+                  return false;
+                }(S.cameraQueryGeometry, ui - ct, yi - ct, vn + ct, zi + ct));
+                for (let ui of mr) Jt.push(ui);
+                Jt.sort(rO);
+                let Pr = {}, zr;
+                for (let ui = 0; ui < Jt.length; ui++) {
+                  let yi = Jt[ui];
+                  if (yi === zr) continue;
+                  zr = yi;
+                  let vn = this.featureIndexArray.get(yi), zi = null;
+                  this.loadMatchingFeature(Pr, vn.bucketIndex, vn.sourceLayerIndex, vn.featureIndex, Fe, fe.layers, fe.availableImages, F, W, te, (un, Tn, pa) => (zi || (zi = $s(un)), Tn.queryIntersectsFeature(Ke, un, pa, zi, this.z, S.transform, pe, S.pixelPosMatrix)));
+                }
+                return Pr;
+              }
+              loadMatchingFeature(S, F, W, te, fe, pe, Fe, Ke, ct, Lt, Jt) {
+                let cr = this.bucketLayerIDs[F];
+                if (pe && !function(ui, yi) {
+                  for (let vn = 0; vn < ui.length; vn++) if (yi.indexOf(ui[vn]) >= 0) return true;
+                  return false;
+                }(pe, cr)) return;
+                let mr = this.sourceLayerCoder.decode(W), Pr = this.vtLayers[mr].feature(te);
+                if (fe.needGeometry) {
+                  let ui = Sl(Pr, true);
+                  if (!fe.filter(new rs(this.tileID.overscaledZ), ui, this.tileID.canonical)) return;
+                } else if (!fe.filter(new rs(this.tileID.overscaledZ), Pr)) return;
+                let zr = this.getId(Pr, mr);
+                for (let ui = 0; ui < cr.length; ui++) {
+                  let yi = cr[ui];
+                  if (pe && pe.indexOf(yi) < 0) continue;
+                  let vn = Ke[yi];
+                  if (!vn) continue;
+                  let zi = {};
+                  zr && Lt && (zi = Lt.getState(vn.sourceLayer || "_geojsonTileLayer", zr));
+                  let un = L({}, ct[yi]);
+                  un.paint = UC(un.paint, vn.paint, Pr, zi, Fe), un.layout = UC(un.layout, vn.layout, Pr, zi, Fe);
+                  let Tn = !Jt || Jt(Pr, vn, zi);
+                  if (!Tn) continue;
+                  let pa = new xS(Pr, this.z, this.x, this.y, zr);
+                  pa.layer = un;
+                  let ro = S[yi];
+                  ro === void 0 && (ro = S[yi] = []), ro.push({ featureIndex: te, feature: pa, intersectionZ: Tn });
+                }
+              }
+              lookupSymbolFeatures(S, F, W, te, fe, pe, Fe, Ke) {
+                let ct = {};
+                this.loadVTLayers();
+                let Lt = Fc(fe);
+                for (let Jt of S) this.loadMatchingFeature(ct, W, te, Jt, Lt, pe, Fe, Ke, F);
+                return ct;
+              }
+              hasLayer(S) {
+                for (let F of this.bucketLayerIDs) for (let W of F) if (S === W) return true;
+                return false;
+              }
+              getId(S, F) {
+                let W = S.id;
+                return this.promoteId && (W = S.properties[typeof this.promoteId == "string" ? this.promoteId : this.promoteId[F]], typeof W == "boolean" && (W = Number(W))), W;
+              }
+            }
+            function UC(R, S, F, W, te) {
+              return C(R, (fe, pe) => {
+                let Fe = S instanceof Ac ? S.get(pe) : null;
+                return Fe && Fe.evaluate ? Fe.evaluate(F, W, te) : Fe;
+              });
+            }
+            function VC(R) {
+              let S = 1 / 0, F = 1 / 0, W = -1 / 0, te = -1 / 0;
+              for (let fe of R) S = Math.min(S, fe.x), F = Math.min(F, fe.y), W = Math.max(W, fe.x), te = Math.max(te, fe.y);
+              return { minX: S, minY: F, maxX: W, maxY: te };
+            }
+            function rO(R, S) {
+              return S - R;
+            }
+            function GC(R, S, F, W, te) {
+              let fe = [];
+              for (let pe = 0; pe < R.length; pe++) {
+                let Fe = R[pe], Ke;
+                for (let ct = 0; ct < Fe.length - 1; ct++) {
+                  let Lt = Fe[ct], Jt = Fe[ct + 1];
+                  Lt.x < S && Jt.x < S || (Lt.x < S ? Lt = new u(S, Lt.y + (S - Lt.x) / (Jt.x - Lt.x) * (Jt.y - Lt.y))._round() : Jt.x < S && (Jt = new u(S, Lt.y + (S - Lt.x) / (Jt.x - Lt.x) * (Jt.y - Lt.y))._round()), Lt.y < F && Jt.y < F || (Lt.y < F ? Lt = new u(Lt.x + (F - Lt.y) / (Jt.y - Lt.y) * (Jt.x - Lt.x), F)._round() : Jt.y < F && (Jt = new u(Lt.x + (F - Lt.y) / (Jt.y - Lt.y) * (Jt.x - Lt.x), F)._round()), Lt.x >= W && Jt.x >= W || (Lt.x >= W ? Lt = new u(W, Lt.y + (W - Lt.x) / (Jt.x - Lt.x) * (Jt.y - Lt.y))._round() : Jt.x >= W && (Jt = new u(W, Lt.y + (W - Lt.x) / (Jt.x - Lt.x) * (Jt.y - Lt.y))._round()), Lt.y >= te && Jt.y >= te || (Lt.y >= te ? Lt = new u(Lt.x + (te - Lt.y) / (Jt.y - Lt.y) * (Jt.x - Lt.x), te)._round() : Jt.y >= te && (Jt = new u(Lt.x + (te - Lt.y) / (Jt.y - Lt.y) * (Jt.x - Lt.x), te)._round()), Ke && Lt.equals(Ke[Ke.length - 1]) || (Ke = [Lt], fe.push(Ke)), Ke.push(Jt)))));
+                }
+              }
+              return fe;
+            }
+            Fi("FeatureIndex", my, { omit: ["rawTileData", "sourceLayerCoder"] });
+            class gg extends u {
+              constructor(S, F, W, te) {
+                super(S, F), this.angle = W, te !== void 0 && (this.segment = te);
+              }
+              clone() {
+                return new gg(this.x, this.y, this.angle, this.segment);
+              }
+            }
+            function bS(R, S, F, W, te) {
+              if (S.segment === void 0 || F === 0) return true;
+              let fe = S, pe = S.segment + 1, Fe = 0;
+              for (; Fe > -F / 2; ) {
+                if (pe--, pe < 0) return false;
+                Fe -= R[pe].dist(fe), fe = R[pe];
+              }
+              Fe += R[pe].dist(R[pe + 1]), pe++;
+              let Ke = [], ct = 0;
+              for (; Fe < F / 2; ) {
+                let Lt = R[pe], Jt = R[pe + 1];
+                if (!Jt) return false;
+                let cr = R[pe - 1].angleTo(Lt) - Lt.angleTo(Jt);
+                for (cr = Math.abs((cr + 3 * Math.PI) % (2 * Math.PI) - Math.PI), Ke.push({ distance: Fe, angleDelta: cr }), ct += cr; Fe - Ke[0].distance > W; ) ct -= Ke.shift().angleDelta;
+                if (ct > te) return false;
+                pe++, Fe += Lt.dist(Jt);
+              }
+              return true;
+            }
+            function HC(R) {
+              let S = 0;
+              for (let F = 0; F < R.length - 1; F++) S += R[F].dist(R[F + 1]);
+              return S;
+            }
+            function jC(R, S, F) {
+              return R ? 0.6 * S * F : 0;
+            }
+            function WC(R, S) {
+              return Math.max(R ? R.right - R.left : 0, S ? S.right - S.left : 0);
+            }
+            function iO(R, S, F, W, te, fe) {
+              let pe = jC(F, te, fe), Fe = WC(F, W) * fe, Ke = 0, ct = HC(R) / 2;
+              for (let Lt = 0; Lt < R.length - 1; Lt++) {
+                let Jt = R[Lt], cr = R[Lt + 1], mr = Jt.dist(cr);
+                if (Ke + mr > ct) {
+                  let Pr = (ct - Ke) / mr, zr = Lo.number(Jt.x, cr.x, Pr), ui = Lo.number(Jt.y, cr.y, Pr), yi = new gg(zr, ui, cr.angleTo(Jt), Lt);
+                  return yi._round(), !pe || bS(R, yi, Fe, pe, S) ? yi : void 0;
+                }
+                Ke += mr;
+              }
+            }
+            function nO(R, S, F, W, te, fe, pe, Fe, Ke) {
+              let ct = jC(W, fe, pe), Lt = WC(W, te), Jt = Lt * pe, cr = R[0].x === 0 || R[0].x === Ke || R[0].y === 0 || R[0].y === Ke;
+              return S - Jt < S / 4 && (S = Jt + S / 4), XC(R, cr ? S / 2 * Fe % S : (Lt / 2 + 2 * fe) * pe * Fe % S, S, ct, F, Jt, cr, false, Ke);
+            }
+            function XC(R, S, F, W, te, fe, pe, Fe, Ke) {
+              let ct = fe / 2, Lt = HC(R), Jt = 0, cr = S - F, mr = [];
+              for (let Pr = 0; Pr < R.length - 1; Pr++) {
+                let zr = R[Pr], ui = R[Pr + 1], yi = zr.dist(ui), vn = ui.angleTo(zr);
+                for (; cr + F < Jt + yi; ) {
+                  cr += F;
+                  let zi = (cr - Jt) / yi, un = Lo.number(zr.x, ui.x, zi), Tn = Lo.number(zr.y, ui.y, zi);
+                  if (un >= 0 && un < Ke && Tn >= 0 && Tn < Ke && cr - ct >= 0 && cr + ct <= Lt) {
+                    let pa = new gg(un, Tn, vn, Pr);
+                    pa._round(), W && !bS(R, pa, fe, W, te) || mr.push(pa);
+                  }
+                }
+                Jt += yi;
+              }
+              return Fe || mr.length || pe || (mr = XC(R, Jt / 2, F, W, te, fe, pe, true, Ke)), mr;
+            }
+            Fi("Anchor", gg);
+            let F1 = Md;
+            function ZC(R, S, F, W) {
+              let te = [], fe = R.image, pe = fe.pixelRatio, Fe = fe.paddedRect.w - 2 * F1, Ke = fe.paddedRect.h - 2 * F1, ct = { x1: R.left, y1: R.top, x2: R.right, y2: R.bottom }, Lt = fe.stretchX || [[0, Fe]], Jt = fe.stretchY || [[0, Ke]], cr = (Xn, Ro) => Xn + Ro[1] - Ro[0], mr = Lt.reduce(cr, 0), Pr = Jt.reduce(cr, 0), zr = Fe - mr, ui = Ke - Pr, yi = 0, vn = mr, zi = 0, un = Pr, Tn = 0, pa = zr, ro = 0, Vo = ui;
+              if (fe.content && W) {
+                let Xn = fe.content, Ro = Xn[2] - Xn[0], uo = Xn[3] - Xn[1];
+                (fe.textFitWidth || fe.textFitHeight) && (ct = PC(R)), yi = mg(Lt, 0, Xn[0]), zi = mg(Jt, 0, Xn[1]), vn = mg(Lt, Xn[0], Xn[2]), un = mg(Jt, Xn[1], Xn[3]), Tn = Xn[0] - yi, ro = Xn[1] - zi, pa = Ro - vn, Vo = uo - un;
+              }
+              let Xa = ct.x1, sa = ct.y1, Mo = ct.x2 - Xa, fo = ct.y2 - sa, lo = (Xn, Ro, uo, $o) => {
+                let Ju = Zw(Xn.stretch - yi, vn, Mo, Xa), qu = z1(Xn.fixed - Tn, pa, Xn.stretch, mr), kh = Zw(Ro.stretch - zi, un, fo, sa), Qv = z1(Ro.fixed - ro, Vo, Ro.stretch, Pr), ud = Zw(uo.stretch - yi, vn, Mo, Xa), Ch = z1(uo.fixed - Tn, pa, uo.stretch, mr), Vd = Zw($o.stretch - zi, un, fo, sa), Gd = z1($o.fixed - ro, Vo, $o.stretch, Pr), Hd = new u(Ju, kh), Af = new u(ud, kh), Lh = new u(ud, Vd), Ed = new u(Ju, Vd), cd = new u(qu / pe, Qv / pe), Yh = new u(Ch / pe, Gd / pe), Df = S * Math.PI / 180;
+                if (Df) {
+                  let ru = Math.sin(Df), pc = Math.cos(Df), $u = [pc, -ru, ru, pc];
+                  Hd._matMult($u), Af._matMult($u), Ed._matMult($u), Lh._matMult($u);
+                }
+                let Fv = Xn.stretch + Xn.fixed, lv = Ro.stretch + Ro.fixed;
+                return { tl: Hd, tr: Af, bl: Ed, br: Lh, tex: { x: fe.paddedRect.x + F1 + Fv, y: fe.paddedRect.y + F1 + lv, w: uo.stretch + uo.fixed - Fv, h: $o.stretch + $o.fixed - lv }, writingMode: void 0, glyphOffset: [0, 0], sectionIndex: 0, pixelOffsetTL: cd, pixelOffsetBR: Yh, minFontScaleX: pa / pe / Mo, minFontScaleY: Vo / pe / fo, isSDF: F };
+              };
+              if (W && (fe.stretchX || fe.stretchY)) {
+                let Xn = YC(Lt, zr, mr), Ro = YC(Jt, ui, Pr);
+                for (let uo = 0; uo < Xn.length - 1; uo++) {
+                  let $o = Xn[uo], Ju = Xn[uo + 1];
+                  for (let qu = 0; qu < Ro.length - 1; qu++) te.push(lo($o, Ro[qu], Ju, Ro[qu + 1]));
+                }
+              } else te.push(lo({ fixed: 0, stretch: -1 }, { fixed: 0, stretch: -1 }, { fixed: 0, stretch: Fe + 1 }, { fixed: 0, stretch: Ke + 1 }));
+              return te;
+            }
+            function mg(R, S, F) {
+              let W = 0;
+              for (let te of R) W += Math.max(S, Math.min(F, te[1])) - Math.max(S, Math.min(F, te[0]));
+              return W;
+            }
+            function YC(R, S, F) {
+              let W = [{ fixed: -1, stretch: 0 }];
+              for (let [te, fe] of R) {
+                let pe = W[W.length - 1];
+                W.push({ fixed: te - pe.stretch, stretch: pe.stretch }), W.push({ fixed: te - pe.stretch, stretch: pe.stretch + (fe - te) });
+              }
+              return W.push({ fixed: S + F1, stretch: F }), W;
+            }
+            function Zw(R, S, F, W) {
+              return R / S * F + W;
+            }
+            function z1(R, S, F, W) {
+              return R - S * F / W;
+            }
+            class dm {
+              constructor(S, F, W, te, fe, pe, Fe, Ke, ct, Lt) {
+                var Jt;
+                if (this.boxStartIndex = S.length, ct) {
+                  let cr = pe.top, mr = pe.bottom, Pr = pe.collisionPadding;
+                  Pr && (cr -= Pr[1], mr += Pr[3]);
+                  let zr = mr - cr;
+                  zr > 0 && (zr = Math.max(10, zr), this.circleDiameter = zr);
+                } else {
+                  let cr = !((Jt = pe.image) === null || Jt === void 0) && Jt.content && (pe.image.textFitWidth || pe.image.textFitHeight) ? PC(pe) : { x1: pe.left, y1: pe.top, x2: pe.right, y2: pe.bottom };
+                  cr.y1 = cr.y1 * Fe - Ke[0], cr.y2 = cr.y2 * Fe + Ke[2], cr.x1 = cr.x1 * Fe - Ke[3], cr.x2 = cr.x2 * Fe + Ke[1];
+                  let mr = pe.collisionPadding;
+                  if (mr && (cr.x1 -= mr[0] * Fe, cr.y1 -= mr[1] * Fe, cr.x2 += mr[2] * Fe, cr.y2 += mr[3] * Fe), Lt) {
+                    let Pr = new u(cr.x1, cr.y1), zr = new u(cr.x2, cr.y1), ui = new u(cr.x1, cr.y2), yi = new u(cr.x2, cr.y2), vn = Lt * Math.PI / 180;
+                    Pr._rotate(vn), zr._rotate(vn), ui._rotate(vn), yi._rotate(vn), cr.x1 = Math.min(Pr.x, zr.x, ui.x, yi.x), cr.x2 = Math.max(Pr.x, zr.x, ui.x, yi.x), cr.y1 = Math.min(Pr.y, zr.y, ui.y, yi.y), cr.y2 = Math.max(Pr.y, zr.y, ui.y, yi.y);
+                  }
+                  S.emplaceBack(F.x, F.y, cr.x1, cr.y1, cr.x2, cr.y2, W, te, fe);
+                }
+                this.boxEndIndex = S.length;
+              }
+            }
+            class Vp {
+              constructor(S = [], F = (W, te) => W < te ? -1 : W > te ? 1 : 0) {
+                if (this.data = S, this.length = this.data.length, this.compare = F, this.length > 0) for (let W = (this.length >> 1) - 1; W >= 0; W--) this._down(W);
+              }
+              push(S) {
+                this.data.push(S), this._up(this.length++);
+              }
+              pop() {
+                if (this.length === 0) return;
+                let S = this.data[0], F = this.data.pop();
+                return --this.length > 0 && (this.data[0] = F, this._down(0)), S;
+              }
+              peek() {
+                return this.data[0];
+              }
+              _up(S) {
+                let { data: F, compare: W } = this, te = F[S];
+                for (; S > 0; ) {
+                  let fe = S - 1 >> 1, pe = F[fe];
+                  if (W(te, pe) >= 0) break;
+                  F[S] = pe, S = fe;
+                }
+                F[S] = te;
+              }
+              _down(S) {
+                let { data: F, compare: W } = this, te = this.length >> 1, fe = F[S];
+                for (; S < te; ) {
+                  let pe = 1 + (S << 1), Fe = pe + 1;
+                  if (Fe < this.length && W(F[Fe], F[pe]) < 0 && (pe = Fe), W(F[pe], fe) >= 0) break;
+                  F[S] = F[pe], S = pe;
+                }
+                F[S] = fe;
+              }
+            }
+            function aO(R, S = 1, F = false) {
+              let W = 1 / 0, te = 1 / 0, fe = -1 / 0, pe = -1 / 0, Fe = R[0];
+              for (let mr = 0; mr < Fe.length; mr++) {
+                let Pr = Fe[mr];
+                (!mr || Pr.x < W) && (W = Pr.x), (!mr || Pr.y < te) && (te = Pr.y), (!mr || Pr.x > fe) && (fe = Pr.x), (!mr || Pr.y > pe) && (pe = Pr.y);
+              }
+              let Ke = Math.min(fe - W, pe - te), ct = Ke / 2, Lt = new Vp([], oO);
+              if (Ke === 0) return new u(W, te);
+              for (let mr = W; mr < fe; mr += Ke) for (let Pr = te; Pr < pe; Pr += Ke) Lt.push(new O1(mr + ct, Pr + ct, ct, R));
+              let Jt = function(mr) {
+                let Pr = 0, zr = 0, ui = 0, yi = mr[0];
+                for (let vn = 0, zi = yi.length, un = zi - 1; vn < zi; un = vn++) {
+                  let Tn = yi[vn], pa = yi[un], ro = Tn.x * pa.y - pa.x * Tn.y;
+                  zr += (Tn.x + pa.x) * ro, ui += (Tn.y + pa.y) * ro, Pr += 3 * ro;
+                }
+                return new O1(zr / Pr, ui / Pr, 0, mr);
+              }(R), cr = Lt.length;
+              for (; Lt.length; ) {
+                let mr = Lt.pop();
+                (mr.d > Jt.d || !Jt.d) && (Jt = mr, F && console.log("found best %d after %d probes", Math.round(1e4 * mr.d) / 1e4, cr)), mr.max - Jt.d <= S || (ct = mr.h / 2, Lt.push(new O1(mr.p.x - ct, mr.p.y - ct, ct, R)), Lt.push(new O1(mr.p.x + ct, mr.p.y - ct, ct, R)), Lt.push(new O1(mr.p.x - ct, mr.p.y + ct, ct, R)), Lt.push(new O1(mr.p.x + ct, mr.p.y + ct, ct, R)), cr += 4);
+              }
+              return F && (console.log(`num probes: ${cr}`), console.log(`best distance: ${Jt.d}`)), Jt.p;
+            }
+            function oO(R, S) {
+              return S.max - R.max;
+            }
+            function O1(R, S, F, W) {
+              this.p = new u(R, S), this.h = F, this.d = function(te, fe) {
+                let pe = false, Fe = 1 / 0;
+                for (let Ke = 0; Ke < fe.length; Ke++) {
+                  let ct = fe[Ke];
+                  for (let Lt = 0, Jt = ct.length, cr = Jt - 1; Lt < Jt; cr = Lt++) {
+                    let mr = ct[Lt], Pr = ct[cr];
+                    mr.y > te.y != Pr.y > te.y && te.x < (Pr.x - mr.x) * (te.y - mr.y) / (Pr.y - mr.y) + mr.x && (pe = !pe), Fe = Math.min(Fe, Gr(te, mr, Pr));
+                  }
+                }
+                return (pe ? 1 : -1) * Math.sqrt(Fe);
+              }(this.p, W), this.max = this.d + this.h * Math.SQRT2;
+            }
+            var ld;
+            i.aq = void 0, (ld = i.aq || (i.aq = {}))[ld.center = 1] = "center", ld[ld.left = 2] = "left", ld[ld.right = 3] = "right", ld[ld.top = 4] = "top", ld[ld.bottom = 5] = "bottom", ld[ld["top-left"] = 6] = "top-left", ld[ld["top-right"] = 7] = "top-right", ld[ld["bottom-left"] = 8] = "bottom-left", ld[ld["bottom-right"] = 9] = "bottom-right";
+            let vm = 7, yy = Number.POSITIVE_INFINITY;
+            function wS(R, S) {
+              return S[1] !== yy ? function(F, W, te) {
+                let fe = 0, pe = 0;
+                switch (W = Math.abs(W), te = Math.abs(te), F) {
+                  case "top-right":
+                  case "top-left":
+                  case "top":
+                    pe = te - vm;
+                    break;
+                  case "bottom-right":
+                  case "bottom-left":
+                  case "bottom":
+                    pe = -te + vm;
+                }
+                switch (F) {
+                  case "top-right":
+                  case "bottom-right":
+                  case "right":
+                    fe = -W;
+                    break;
+                  case "top-left":
+                  case "bottom-left":
+                  case "left":
+                    fe = W;
+                }
+                return [fe, pe];
+              }(R, S[0], S[1]) : function(F, W) {
+                let te = 0, fe = 0;
+                W < 0 && (W = 0);
+                let pe = W / Math.SQRT2;
+                switch (F) {
+                  case "top-right":
+                  case "top-left":
+                    fe = pe - vm;
+                    break;
+                  case "bottom-right":
+                  case "bottom-left":
+                    fe = -pe + vm;
+                    break;
+                  case "bottom":
+                    fe = -W + vm;
+                    break;
+                  case "top":
+                    fe = W - vm;
+                }
+                switch (F) {
+                  case "top-right":
+                  case "bottom-right":
+                    te = -pe;
+                    break;
+                  case "top-left":
+                  case "bottom-left":
+                    te = pe;
+                    break;
+                  case "left":
+                    te = W;
+                    break;
+                  case "right":
+                    te = -W;
+                }
+                return [te, fe];
+              }(R, S[0]);
+            }
+            function KC(R, S, F) {
+              var W;
+              let te = R.layout, fe = (W = te.get("text-variable-anchor-offset")) === null || W === void 0 ? void 0 : W.evaluate(S, {}, F);
+              if (fe) {
+                let Fe = fe.values, Ke = [];
+                for (let ct = 0; ct < Fe.length; ct += 2) {
+                  let Lt = Ke[ct] = Fe[ct], Jt = Fe[ct + 1].map((cr) => cr * tu);
+                  Lt.startsWith("top") ? Jt[1] -= vm : Lt.startsWith("bottom") && (Jt[1] += vm), Ke[ct + 1] = Jt;
+                }
+                return new $i(Ke);
+              }
+              let pe = te.get("text-variable-anchor");
+              if (pe) {
+                let Fe;
+                Fe = R._unevaluatedLayout.getValue("text-radial-offset") !== void 0 ? [te.get("text-radial-offset").evaluate(S, {}, F) * tu, yy] : te.get("text-offset").evaluate(S, {}, F).map((ct) => ct * tu);
+                let Ke = [];
+                for (let ct of pe) Ke.push(ct, wS(ct, Fe));
+                return new $i(Ke);
+              }
+              return null;
+            }
+            function TS(R) {
+              switch (R) {
+                case "right":
+                case "top-right":
+                case "bottom-right":
+                  return "right";
+                case "left":
+                case "top-left":
+                case "bottom-left":
+                  return "left";
+              }
+              return "center";
+            }
+            function sO(R, S, F, W, te, fe, pe, Fe, Ke, ct, Lt) {
+              let Jt = fe.textMaxSize.evaluate(S, {});
+              Jt === void 0 && (Jt = pe);
+              let cr = R.layers[0].layout, mr = cr.get("icon-offset").evaluate(S, {}, Lt), Pr = $C(F.horizontal), zr = pe / 24, ui = R.tilePixelRatio * zr, yi = R.tilePixelRatio * Jt / 24, vn = R.tilePixelRatio * Fe, zi = R.tilePixelRatio * cr.get("symbol-spacing"), un = cr.get("text-padding") * R.tilePixelRatio, Tn = function(Xn, Ro, uo, $o = 1) {
+                let Ju = Xn.get("icon-padding").evaluate(Ro, {}, uo), qu = Ju && Ju.values;
+                return [qu[0] * $o, qu[1] * $o, qu[2] * $o, qu[3] * $o];
+              }(cr, S, Lt, R.tilePixelRatio), pa = cr.get("text-max-angle") / 180 * Math.PI, ro = cr.get("text-rotation-alignment") !== "viewport" && cr.get("symbol-placement") !== "point", Vo = cr.get("icon-rotation-alignment") === "map" && cr.get("symbol-placement") !== "point", Xa = cr.get("symbol-placement"), sa = zi / 2, Mo = cr.get("icon-text-fit"), fo;
+              W && Mo !== "none" && (R.allowVerticalPlacement && F.vertical && (fo = IC(W, F.vertical, Mo, cr.get("icon-text-fit-padding"), mr, zr)), Pr && (W = IC(W, Pr, Mo, cr.get("icon-text-fit-padding"), mr, zr)));
+              let lo = (Xn, Ro) => {
+                Ro.x < 0 || Ro.x >= ja || Ro.y < 0 || Ro.y >= ja || function(uo, $o, Ju, qu, kh, Qv, ud, Ch, Vd, Gd, Hd, Af, Lh, Ed, cd, Yh, Df, Fv, lv, ru, pc, $u, zv, ff, q1) {
+                  let p0 = uo.addToLineVertexArray($o, Ju), Gp, ep, Gc, Yf, tp = 0, yg = 0, uv = 0, B1 = 0, kS = -1, $w = -1, g0 = {}, _y = bi("");
+                  if (uo.allowVerticalPlacement && qu.vertical) {
+                    let kd = Ch.layout.get("text-rotate").evaluate(pc, {}, ff) + 90;
+                    Gc = new dm(Vd, $o, Gd, Hd, Af, qu.vertical, Lh, Ed, cd, kd), ud && (Yf = new dm(Vd, $o, Gd, Hd, Af, ud, Df, Fv, cd, kd));
+                  }
+                  if (kh) {
+                    let kd = Ch.layout.get("icon-rotate").evaluate(pc, {}), rp = Ch.layout.get("icon-text-fit") !== "none", pm = ZC(kh, kd, zv, rp), jd = ud ? ZC(ud, kd, zv, rp) : void 0;
+                    ep = new dm(Vd, $o, Gd, Hd, Af, kh, Df, Fv, false, kd), tp = 4 * pm.length;
+                    let Cd = uo.iconSizeData, xp = null;
+                    Cd.kind === "source" ? (xp = [v0 * Ch.layout.get("icon-size").evaluate(pc, {})], xp[0] > fm && A(`${uo.layerIds[0]}: Value for "icon-size" is >= ${tb}. Reduce your "icon-size".`)) : Cd.kind === "composite" && (xp = [v0 * $u.compositeIconSizes[0].evaluate(pc, {}, ff), v0 * $u.compositeIconSizes[1].evaluate(pc, {}, ff)], (xp[0] > fm || xp[1] > fm) && A(`${uo.layerIds[0]}: Value for "icon-size" is >= ${tb}. Reduce your "icon-size".`)), uo.addSymbols(uo.icon, pm, xp, ru, lv, pc, i.ah.none, $o, p0.lineStartIndex, p0.lineLength, -1, ff), kS = uo.icon.placedSymbolArray.length - 1, jd && (yg = 4 * jd.length, uo.addSymbols(uo.icon, jd, xp, ru, lv, pc, i.ah.vertical, $o, p0.lineStartIndex, p0.lineLength, -1, ff), $w = uo.icon.placedSymbolArray.length - 1);
+                  }
+                  let Kh = Object.keys(qu.horizontal);
+                  for (let kd of Kh) {
+                    let rp = qu.horizontal[kd];
+                    if (!Gp) {
+                      _y = bi(rp.text);
+                      let jd = Ch.layout.get("text-rotate").evaluate(pc, {}, ff);
+                      Gp = new dm(Vd, $o, Gd, Hd, Af, rp, Lh, Ed, cd, jd);
+                    }
+                    let pm = rp.positionedLines.length === 1;
+                    if (uv += JC(uo, $o, rp, Qv, Ch, cd, pc, Yh, p0, qu.vertical ? i.ah.horizontal : i.ah.horizontalOnly, pm ? Kh : [kd], g0, kS, $u, ff), pm) break;
+                  }
+                  qu.vertical && (B1 += JC(uo, $o, qu.vertical, Qv, Ch, cd, pc, Yh, p0, i.ah.vertical, ["vertical"], g0, $w, $u, ff));
+                  let cO = Gp ? Gp.boxStartIndex : uo.collisionBoxArray.length, Qw = Gp ? Gp.boxEndIndex : uo.collisionBoxArray.length, m0 = Gc ? Gc.boxStartIndex : uo.collisionBoxArray.length, cv = Gc ? Gc.boxEndIndex : uo.collisionBoxArray.length, r6 = ep ? ep.boxStartIndex : uo.collisionBoxArray.length, fO = ep ? ep.boxEndIndex : uo.collisionBoxArray.length, i6 = Yf ? Yf.boxStartIndex : uo.collisionBoxArray.length, hO = Yf ? Yf.boxEndIndex : uo.collisionBoxArray.length, _p = -1, fb = (kd, rp) => kd && kd.circleDiameter ? Math.max(kd.circleDiameter, rp) : rp;
+                  _p = fb(Gp, _p), _p = fb(Gc, _p), _p = fb(ep, _p), _p = fb(Yf, _p);
+                  let e3 = _p > -1 ? 1 : 0;
+                  e3 && (_p *= q1 / tu), uo.glyphOffsetArray.length >= R1.MAX_GLYPHS && A("Too many glyphs being rendered in a tile. See https://github.com/mapbox/mapbox-gl-js/issues/2907"), pc.sortKey !== void 0 && uo.addToSortKeyRanges(uo.symbolInstances.length, pc.sortKey);
+                  let CS = KC(Ch, pc, ff), [dO, vO] = function(kd, rp) {
+                    let pm = kd.length, jd = rp == null ? void 0 : rp.values;
+                    if ((jd == null ? void 0 : jd.length) > 0) for (let Cd = 0; Cd < jd.length; Cd += 2) {
+                      let xp = jd[Cd + 1];
+                      kd.emplaceBack(i.aq[jd[Cd]], xp[0], xp[1]);
+                    }
+                    return [pm, kd.length];
+                  }(uo.textAnchorOffsets, CS);
+                  uo.symbolInstances.emplaceBack($o.x, $o.y, g0.right >= 0 ? g0.right : -1, g0.center >= 0 ? g0.center : -1, g0.left >= 0 ? g0.left : -1, g0.vertical || -1, kS, $w, _y, cO, Qw, m0, cv, r6, fO, i6, hO, Gd, uv, B1, tp, yg, e3, 0, Lh, _p, dO, vO);
+                }(R, Ro, Xn, F, W, te, fo, R.layers[0], R.collisionBoxArray, S.index, S.sourceLayerIndex, R.index, ui, [un, un, un, un], ro, Ke, vn, Tn, Vo, mr, S, fe, ct, Lt, pe);
+              };
+              if (Xa === "line") for (let Xn of GC(S.geometry, 0, 0, ja, ja)) {
+                let Ro = nO(Xn, zi, pa, F.vertical || Pr, W, 24, yi, R.overscaling, ja);
+                for (let uo of Ro) Pr && lO(R, Pr.text, sa, uo) || lo(Xn, uo);
+              }
+              else if (Xa === "line-center") {
+                for (let Xn of S.geometry) if (Xn.length > 1) {
+                  let Ro = iO(Xn, pa, F.vertical || Pr, W, 24, yi);
+                  Ro && lo(Xn, Ro);
+                }
+              } else if (S.type === "Polygon") for (let Xn of Cf(S.geometry, 0)) {
+                let Ro = aO(Xn, 16);
+                lo(Xn[0], new gg(Ro.x, Ro.y, 0));
+              }
+              else if (S.type === "LineString") for (let Xn of S.geometry) lo(Xn, new gg(Xn[0].x, Xn[0].y, 0));
+              else if (S.type === "Point") for (let Xn of S.geometry) for (let Ro of Xn) lo([Ro], new gg(Ro.x, Ro.y, 0));
+            }
+            function JC(R, S, F, W, te, fe, pe, Fe, Ke, ct, Lt, Jt, cr, mr, Pr) {
+              let zr = function(vn, zi, un, Tn, pa, ro, Vo, Xa) {
+                let sa = Tn.layout.get("text-rotate").evaluate(ro, {}) * Math.PI / 180, Mo = [];
+                for (let fo of zi.positionedLines) for (let lo of fo.positionedGlyphs) {
+                  if (!lo.rect) continue;
+                  let Xn = lo.rect || {}, Ro = EC + 1, uo = true, $o = 1, Ju = 0, qu = (pa || Xa) && lo.vertical, kh = lo.metrics.advance * lo.scale / 2;
+                  if (Xa && zi.verticalizable && (Ju = fo.lineOffset / 2 - (lo.imageName ? -(tu - lo.metrics.width * lo.scale) / 2 : (lo.scale - 1) * tu)), lo.imageName) {
+                    let ru = Vo[lo.imageName];
+                    uo = ru.sdf, $o = ru.pixelRatio, Ro = Md / $o;
+                  }
+                  let Qv = pa ? [lo.x + kh, lo.y] : [0, 0], ud = pa ? [0, 0] : [lo.x + kh + un[0], lo.y + un[1] - Ju], Ch = [0, 0];
+                  qu && (Ch = ud, ud = [0, 0]);
+                  let Vd = lo.metrics.isDoubleResolution ? 2 : 1, Gd = (lo.metrics.left - Ro) * lo.scale - kh + ud[0], Hd = (-lo.metrics.top - Ro) * lo.scale + ud[1], Af = Gd + Xn.w / Vd * lo.scale / $o, Lh = Hd + Xn.h / Vd * lo.scale / $o, Ed = new u(Gd, Hd), cd = new u(Af, Hd), Yh = new u(Gd, Lh), Df = new u(Af, Lh);
+                  if (qu) {
+                    let ru = new u(-kh, kh - Eh), pc = -Math.PI / 2, $u = tu / 2 - kh, zv = new u(5 - Eh - $u, -(lo.imageName ? $u : 0)), ff = new u(...Ch);
+                    Ed._rotateAround(pc, ru)._add(zv)._add(ff), cd._rotateAround(pc, ru)._add(zv)._add(ff), Yh._rotateAround(pc, ru)._add(zv)._add(ff), Df._rotateAround(pc, ru)._add(zv)._add(ff);
+                  }
+                  if (sa) {
+                    let ru = Math.sin(sa), pc = Math.cos(sa), $u = [pc, -ru, ru, pc];
+                    Ed._matMult($u), cd._matMult($u), Yh._matMult($u), Df._matMult($u);
+                  }
+                  let Fv = new u(0, 0), lv = new u(0, 0);
+                  Mo.push({ tl: Ed, tr: cd, bl: Yh, br: Df, tex: Xn, writingMode: zi.writingMode, glyphOffset: Qv, sectionIndex: lo.sectionIndex, isSDF: uo, pixelOffsetTL: Fv, pixelOffsetBR: lv, minFontScaleX: 0, minFontScaleY: 0 });
+                }
+                return Mo;
+              }(0, F, Fe, te, fe, pe, W, R.allowVerticalPlacement), ui = R.textSizeData, yi = null;
+              ui.kind === "source" ? (yi = [v0 * te.layout.get("text-size").evaluate(pe, {})], yi[0] > fm && A(`${R.layerIds[0]}: Value for "text-size" is >= ${tb}. Reduce your "text-size".`)) : ui.kind === "composite" && (yi = [v0 * mr.compositeTextSizes[0].evaluate(pe, {}, Pr), v0 * mr.compositeTextSizes[1].evaluate(pe, {}, Pr)], (yi[0] > fm || yi[1] > fm) && A(`${R.layerIds[0]}: Value for "text-size" is >= ${tb}. Reduce your "text-size".`)), R.addSymbols(R.text, zr, yi, Fe, fe, pe, ct, S, Ke.lineStartIndex, Ke.lineLength, cr, Pr);
+              for (let vn of Lt) Jt[vn] = R.text.placedSymbolArray.length - 1;
+              return 4 * zr.length;
+            }
+            function $C(R) {
+              for (let S in R) return R[S];
+              return null;
+            }
+            function lO(R, S, F, W) {
+              let te = R.compareText;
+              if (S in te) {
+                let fe = te[S];
+                for (let pe = fe.length - 1; pe >= 0; pe--) if (W.dist(fe[pe]) < F) return true;
+              } else te[S] = [];
+              return te[S].push(W), false;
+            }
+            let QC = [Int8Array, Uint8Array, Uint8ClampedArray, Int16Array, Uint16Array, Int32Array, Uint32Array, Float32Array, Float64Array];
+            class AS {
+              static from(S) {
+                if (!(S instanceof ArrayBuffer)) throw new Error("Data must be an instance of ArrayBuffer.");
+                let [F, W] = new Uint8Array(S, 0, 2);
+                if (F !== 219) throw new Error("Data does not appear to be in a KDBush format.");
+                let te = W >> 4;
+                if (te !== 1) throw new Error(`Got v${te} data when expected v1.`);
+                let fe = QC[15 & W];
+                if (!fe) throw new Error("Unrecognized array type.");
+                let [pe] = new Uint16Array(S, 2, 1), [Fe] = new Uint32Array(S, 4, 1);
+                return new AS(Fe, pe, fe, S);
+              }
+              constructor(S, F = 64, W = Float64Array, te) {
+                if (isNaN(S) || S < 0) throw new Error(`Unpexpected numItems value: ${S}.`);
+                this.numItems = +S, this.nodeSize = Math.min(Math.max(+F, 2), 65535), this.ArrayType = W, this.IndexArrayType = S < 65536 ? Uint16Array : Uint32Array;
+                let fe = QC.indexOf(this.ArrayType), pe = 2 * S * this.ArrayType.BYTES_PER_ELEMENT, Fe = S * this.IndexArrayType.BYTES_PER_ELEMENT, Ke = (8 - Fe % 8) % 8;
+                if (fe < 0) throw new Error(`Unexpected typed array class: ${W}.`);
+                te && te instanceof ArrayBuffer ? (this.data = te, this.ids = new this.IndexArrayType(this.data, 8, S), this.coords = new this.ArrayType(this.data, 8 + Fe + Ke, 2 * S), this._pos = 2 * S, this._finished = true) : (this.data = new ArrayBuffer(8 + pe + Fe + Ke), this.ids = new this.IndexArrayType(this.data, 8, S), this.coords = new this.ArrayType(this.data, 8 + Fe + Ke, 2 * S), this._pos = 0, this._finished = false, new Uint8Array(this.data, 0, 2).set([219, 16 + fe]), new Uint16Array(this.data, 2, 1)[0] = F, new Uint32Array(this.data, 4, 1)[0] = S);
+              }
+              add(S, F) {
+                let W = this._pos >> 1;
+                return this.ids[W] = W, this.coords[this._pos++] = S, this.coords[this._pos++] = F, W;
+              }
+              finish() {
+                let S = this._pos >> 1;
+                if (S !== this.numItems) throw new Error(`Added ${S} items when expected ${this.numItems}.`);
+                return Yw(this.ids, this.coords, this.nodeSize, 0, this.numItems - 1, 0), this._finished = true, this;
+              }
+              range(S, F, W, te) {
+                if (!this._finished) throw new Error("Data not yet indexed - call index.finish().");
+                let { ids: fe, coords: pe, nodeSize: Fe } = this, Ke = [0, fe.length - 1, 0], ct = [];
+                for (; Ke.length; ) {
+                  let Lt = Ke.pop() || 0, Jt = Ke.pop() || 0, cr = Ke.pop() || 0;
+                  if (Jt - cr <= Fe) {
+                    for (let ui = cr; ui <= Jt; ui++) {
+                      let yi = pe[2 * ui], vn = pe[2 * ui + 1];
+                      yi >= S && yi <= W && vn >= F && vn <= te && ct.push(fe[ui]);
+                    }
+                    continue;
+                  }
+                  let mr = cr + Jt >> 1, Pr = pe[2 * mr], zr = pe[2 * mr + 1];
+                  Pr >= S && Pr <= W && zr >= F && zr <= te && ct.push(fe[mr]), (Lt === 0 ? S <= Pr : F <= zr) && (Ke.push(cr), Ke.push(mr - 1), Ke.push(1 - Lt)), (Lt === 0 ? W >= Pr : te >= zr) && (Ke.push(mr + 1), Ke.push(Jt), Ke.push(1 - Lt));
+                }
+                return ct;
+              }
+              within(S, F, W) {
+                if (!this._finished) throw new Error("Data not yet indexed - call index.finish().");
+                let { ids: te, coords: fe, nodeSize: pe } = this, Fe = [0, te.length - 1, 0], Ke = [], ct = W * W;
+                for (; Fe.length; ) {
+                  let Lt = Fe.pop() || 0, Jt = Fe.pop() || 0, cr = Fe.pop() || 0;
+                  if (Jt - cr <= pe) {
+                    for (let ui = cr; ui <= Jt; ui++) t6(fe[2 * ui], fe[2 * ui + 1], S, F) <= ct && Ke.push(te[ui]);
+                    continue;
+                  }
+                  let mr = cr + Jt >> 1, Pr = fe[2 * mr], zr = fe[2 * mr + 1];
+                  t6(Pr, zr, S, F) <= ct && Ke.push(te[mr]), (Lt === 0 ? S - W <= Pr : F - W <= zr) && (Fe.push(cr), Fe.push(mr - 1), Fe.push(1 - Lt)), (Lt === 0 ? S + W >= Pr : F + W >= zr) && (Fe.push(mr + 1), Fe.push(Jt), Fe.push(1 - Lt));
+                }
+                return Ke;
+              }
+            }
+            function Yw(R, S, F, W, te, fe) {
+              if (te - W <= F) return;
+              let pe = W + te >> 1;
+              e6(R, S, pe, W, te, fe), Yw(R, S, F, W, pe - 1, 1 - fe), Yw(R, S, F, pe + 1, te, 1 - fe);
+            }
+            function e6(R, S, F, W, te, fe) {
+              for (; te > W; ) {
+                if (te - W > 600) {
+                  let ct = te - W + 1, Lt = F - W + 1, Jt = Math.log(ct), cr = 0.5 * Math.exp(2 * Jt / 3), mr = 0.5 * Math.sqrt(Jt * cr * (ct - cr) / ct) * (Lt - ct / 2 < 0 ? -1 : 1);
+                  e6(R, S, F, Math.max(W, Math.floor(F - Lt * cr / ct + mr)), Math.min(te, Math.floor(F + (ct - Lt) * cr / ct + mr)), fe);
+                }
+                let pe = S[2 * F + fe], Fe = W, Ke = te;
+                for (ub(R, S, W, F), S[2 * te + fe] > pe && ub(R, S, W, te); Fe < Ke; ) {
+                  for (ub(R, S, Fe, Ke), Fe++, Ke--; S[2 * Fe + fe] < pe; ) Fe++;
+                  for (; S[2 * Ke + fe] > pe; ) Ke--;
+                }
+                S[2 * W + fe] === pe ? ub(R, S, W, Ke) : (Ke++, ub(R, S, Ke, te)), Ke <= F && (W = Ke + 1), F <= Ke && (te = Ke - 1);
+              }
+            }
+            function ub(R, S, F, W) {
+              SS(R, F, W), SS(S, 2 * F, 2 * W), SS(S, 2 * F + 1, 2 * W + 1);
+            }
+            function SS(R, S, F) {
+              let W = R[S];
+              R[S] = R[F], R[F] = W;
+            }
+            function t6(R, S, F, W) {
+              let te = R - F, fe = S - W;
+              return te * te + fe * fe;
+            }
+            var Kw;
+            i.bg = void 0, (Kw = i.bg || (i.bg = {})).create = "create", Kw.load = "load", Kw.fullLoad = "fullLoad";
+            let cb = null, sh = [], MS = 1e3 / 60, ES = "loadTime", Jw = "fullLoadTime", uO = { mark(R) {
+              performance.mark(R);
+            }, frame(R) {
+              let S = R;
+              cb != null && sh.push(S - cb), cb = S;
+            }, clearMetrics() {
+              cb = null, sh = [], performance.clearMeasures(ES), performance.clearMeasures(Jw);
+              for (let R in i.bg) performance.clearMarks(i.bg[R]);
+            }, getPerformanceMetrics() {
+              performance.measure(ES, i.bg.create, i.bg.load), performance.measure(Jw, i.bg.create, i.bg.fullLoad);
+              let R = performance.getEntriesByName(ES)[0].duration, S = performance.getEntriesByName(Jw)[0].duration, F = sh.length, W = 1 / (sh.reduce((fe, pe) => fe + pe, 0) / F / 1e3), te = sh.filter((fe) => fe > MS).reduce((fe, pe) => fe + (pe - MS) / MS, 0);
+              return { loadTime: R, fullLoadTime: S, fps: W, percentDroppedFrames: te / (F + te) * 100, totalFrames: F };
+            } };
+            i.$ = class extends Yt {
+            }, i.A = xi, i.B = dn, i.C = function(R) {
+              if (U == null) {
+                let S = R.navigator ? R.navigator.userAgent : null;
+                U = !!R.safari || !(!S || !(/\b(iPad|iPhone|iPod)\b/.test(S) || S.match("Safari") && !S.match("Chrome")));
+              }
+              return U;
+            }, i.D = Ua, i.E = De, i.F = class {
+              constructor(R, S) {
+                this.target = R, this.mapId = S, this.resolveRejects = {}, this.tasks = {}, this.taskQueue = [], this.abortControllers = {}, this.messageHandlers = {}, this.invoker = new mS(() => this.process()), this.subscription = function(F, W, te, fe) {
+                  return F.addEventListener(W, te, false), { unsubscribe: () => {
+                    F.removeEventListener(W, te, false);
+                  } };
+                }(this.target, "message", (F) => this.receive(F)), this.globalScope = O(self) ? R : window;
+              }
+              registerMessageHandler(R, S) {
+                this.messageHandlers[R] = S;
+              }
+              sendAsync(R, S) {
+                return new Promise((F, W) => {
+                  let te = Math.round(1e18 * Math.random()).toString(36).substring(0, 10);
+                  this.resolveRejects[te] = { resolve: F, reject: W }, S && S.signal.addEventListener("abort", () => {
+                    delete this.resolveRejects[te];
+                    let Fe = { id: te, type: "<cancel>", origin: location.origin, targetMapId: R.targetMapId, sourceMapId: this.mapId };
+                    this.target.postMessage(Fe);
+                  }, { once: true });
+                  let fe = [], pe = Object.assign(Object.assign({}, R), { id: te, sourceMapId: this.mapId, origin: location.origin, data: La(R.data, fe) });
+                  this.target.postMessage(pe, { transfer: fe });
+                });
+              }
+              receive(R) {
+                let S = R.data, F = S.id;
+                if (!(S.origin !== "file://" && location.origin !== "file://" && S.origin !== "resource://android" && location.origin !== "resource://android" && S.origin !== location.origin || S.targetMapId && this.mapId !== S.targetMapId)) {
+                  if (S.type === "<cancel>") {
+                    delete this.tasks[F];
+                    let W = this.abortControllers[F];
+                    return delete this.abortControllers[F], void (W && W.abort());
+                  }
+                  if (O(self) || S.mustQueue) return this.tasks[F] = S, this.taskQueue.push(F), void this.invoker.trigger();
+                  this.processTask(F, S);
+                }
+              }
+              process() {
+                if (this.taskQueue.length === 0) return;
+                let R = this.taskQueue.shift(), S = this.tasks[R];
+                delete this.tasks[R], this.taskQueue.length > 0 && this.invoker.trigger(), S && this.processTask(R, S);
+              }
+              processTask(R, S) {
+                return a(this, void 0, void 0, function* () {
+                  if (S.type === "<response>") {
+                    let te = this.resolveRejects[R];
+                    return delete this.resolveRejects[R], te ? void (S.error ? te.reject(Na(S.error)) : te.resolve(Na(S.data))) : void 0;
+                  }
+                  if (!this.messageHandlers[S.type]) return void this.completeTask(R, new Error(`Could not find a registered handler for ${S.type}, map ID: ${this.mapId}, available handlers: ${Object.keys(this.messageHandlers).join(", ")}`));
+                  let F = Na(S.data), W = new AbortController();
+                  this.abortControllers[R] = W;
+                  try {
+                    let te = yield this.messageHandlers[S.type](S.sourceMapId, F, W);
+                    this.completeTask(R, null, te);
+                  } catch (te) {
+                    this.completeTask(R, te);
+                  }
+                });
+              }
+              completeTask(R, S, F) {
+                let W = [];
+                delete this.abortControllers[R];
+                let te = { id: R, type: "<response>", sourceMapId: this.mapId, origin: location.origin, error: S ? La(S) : null, data: La(F, W) };
+                this.target.postMessage(te, { transfer: W });
+              }
+              remove() {
+                this.invoker.remove(), this.subscription.unsubscribe();
+              }
+            }, i.G = Le, i.H = function() {
+              var R = new xi(16);
+              return xi != Float32Array && (R[1] = 0, R[2] = 0, R[3] = 0, R[4] = 0, R[6] = 0, R[7] = 0, R[8] = 0, R[9] = 0, R[11] = 0, R[12] = 0, R[13] = 0, R[14] = 0), R[0] = 1, R[5] = 1, R[10] = 1, R[15] = 1, R;
+            }, i.I = Bw, i.J = function(R, S, F) {
+              var W, te, fe, pe, Fe, Ke, ct, Lt, Jt, cr, mr, Pr, zr = F[0], ui = F[1], yi = F[2];
+              return S === R ? (R[12] = S[0] * zr + S[4] * ui + S[8] * yi + S[12], R[13] = S[1] * zr + S[5] * ui + S[9] * yi + S[13], R[14] = S[2] * zr + S[6] * ui + S[10] * yi + S[14], R[15] = S[3] * zr + S[7] * ui + S[11] * yi + S[15]) : (te = S[1], fe = S[2], pe = S[3], Fe = S[4], Ke = S[5], ct = S[6], Lt = S[7], Jt = S[8], cr = S[9], mr = S[10], Pr = S[11], R[0] = W = S[0], R[1] = te, R[2] = fe, R[3] = pe, R[4] = Fe, R[5] = Ke, R[6] = ct, R[7] = Lt, R[8] = Jt, R[9] = cr, R[10] = mr, R[11] = Pr, R[12] = W * zr + Fe * ui + Jt * yi + S[12], R[13] = te * zr + Ke * ui + cr * yi + S[13], R[14] = fe * zr + ct * ui + mr * yi + S[14], R[15] = pe * zr + Lt * ui + Pr * yi + S[15]), R;
+            }, i.K = function(R, S, F) {
+              var W = F[0], te = F[1], fe = F[2];
+              return R[0] = S[0] * W, R[1] = S[1] * W, R[2] = S[2] * W, R[3] = S[3] * W, R[4] = S[4] * te, R[5] = S[5] * te, R[6] = S[6] * te, R[7] = S[7] * te, R[8] = S[8] * fe, R[9] = S[9] * fe, R[10] = S[10] * fe, R[11] = S[11] * fe, R[12] = S[12], R[13] = S[13], R[14] = S[14], R[15] = S[15], R;
+            }, i.L = ci, i.M = function(R, S) {
+              let F = {};
+              for (let W = 0; W < S.length; W++) {
+                let te = S[W];
+                te in R && (F[te] = R[te]);
+              }
+              return F;
+            }, i.N = pg, i.O = Ww, i.P = u, i.Q = OC, i.R = Ki, i.S = $v, i.T = Yu, i.U = _, i.V = b, i.W = j, i.X = ja, i.Y = Oe, i.Z = sb, i._ = a, i.a = _e, i.a$ = function(R, S) {
+              var F = R[0], W = R[1], te = R[2], fe = R[3], pe = R[4], Fe = R[5], Ke = R[6], ct = R[7], Lt = R[8], Jt = R[9], cr = R[10], mr = R[11], Pr = R[12], zr = R[13], ui = R[14], yi = R[15], vn = S[0], zi = S[1], un = S[2], Tn = S[3], pa = S[4], ro = S[5], Vo = S[6], Xa = S[7], sa = S[8], Mo = S[9], fo = S[10], lo = S[11], Xn = S[12], Ro = S[13], uo = S[14], $o = S[15];
+              return Math.abs(F - vn) <= Yr * Math.max(1, Math.abs(F), Math.abs(vn)) && Math.abs(W - zi) <= Yr * Math.max(1, Math.abs(W), Math.abs(zi)) && Math.abs(te - un) <= Yr * Math.max(1, Math.abs(te), Math.abs(un)) && Math.abs(fe - Tn) <= Yr * Math.max(1, Math.abs(fe), Math.abs(Tn)) && Math.abs(pe - pa) <= Yr * Math.max(1, Math.abs(pe), Math.abs(pa)) && Math.abs(Fe - ro) <= Yr * Math.max(1, Math.abs(Fe), Math.abs(ro)) && Math.abs(Ke - Vo) <= Yr * Math.max(1, Math.abs(Ke), Math.abs(Vo)) && Math.abs(ct - Xa) <= Yr * Math.max(1, Math.abs(ct), Math.abs(Xa)) && Math.abs(Lt - sa) <= Yr * Math.max(1, Math.abs(Lt), Math.abs(sa)) && Math.abs(Jt - Mo) <= Yr * Math.max(1, Math.abs(Jt), Math.abs(Mo)) && Math.abs(cr - fo) <= Yr * Math.max(1, Math.abs(cr), Math.abs(fo)) && Math.abs(mr - lo) <= Yr * Math.max(1, Math.abs(mr), Math.abs(lo)) && Math.abs(Pr - Xn) <= Yr * Math.max(1, Math.abs(Pr), Math.abs(Xn)) && Math.abs(zr - Ro) <= Yr * Math.max(1, Math.abs(zr), Math.abs(Ro)) && Math.abs(ui - uo) <= Yr * Math.max(1, Math.abs(ui), Math.abs(uo)) && Math.abs(yi - $o) <= Yr * Math.max(1, Math.abs(yi), Math.abs($o));
+            }, i.a0 = Ye, i.a1 = _S, i.a2 = fr, i.a3 = (R) => {
+              let S = window.document.createElement("video");
+              return S.muted = true, new Promise((F) => {
+                S.onloadstart = () => {
+                  F(S);
+                };
+                for (let W of R) {
+                  let te = window.document.createElement("source");
+                  Ee(W) || (S.crossOrigin = "Anonymous"), te.src = W, S.appendChild(te);
+                }
+              });
+            }, i.a4 = function() {
+              return x++;
+            }, i.a5 = Cn, i.a6 = R1, i.a7 = Fc, i.a8 = Sl, i.a9 = xS, i.aA = function(R) {
+              if (R.type === "custom") return new gS(R);
+              switch (R.type) {
+                case "background":
+                  return new tO(R);
+                case "circle":
+                  return new hi(R);
+                case "fill":
+                  return new yt(R);
+                case "fill-extrusion":
+                  return new Lv(R);
+                case "heatmap":
+                  return new oa(R);
+                case "hillshade":
+                  return new Zs(R);
+                case "line":
+                  return new hy(R);
+                case "raster":
+                  return new ab(R);
+                case "symbol":
+                  return new gy(R);
+              }
+            }, i.aB = g, i.aC = function(R, S) {
+              if (!R) return [{ command: "setStyle", args: [S] }];
+              let F = [];
+              try {
+                if (!pt(R.version, S.version)) return [{ command: "setStyle", args: [S] }];
+                pt(R.center, S.center) || F.push({ command: "setCenter", args: [S.center] }), pt(R.zoom, S.zoom) || F.push({ command: "setZoom", args: [S.zoom] }), pt(R.bearing, S.bearing) || F.push({ command: "setBearing", args: [S.bearing] }), pt(R.pitch, S.pitch) || F.push({ command: "setPitch", args: [S.pitch] }), pt(R.sprite, S.sprite) || F.push({ command: "setSprite", args: [S.sprite] }), pt(R.glyphs, S.glyphs) || F.push({ command: "setGlyphs", args: [S.glyphs] }), pt(R.transition, S.transition) || F.push({ command: "setTransition", args: [S.transition] }), pt(R.light, S.light) || F.push({ command: "setLight", args: [S.light] }), pt(R.terrain, S.terrain) || F.push({ command: "setTerrain", args: [S.terrain] }), pt(R.sky, S.sky) || F.push({ command: "setSky", args: [S.sky] }), pt(R.projection, S.projection) || F.push({ command: "setProjection", args: [S.projection] });
+                let W = {}, te = [];
+                (function(pe, Fe, Ke, ct) {
+                  let Lt;
+                  for (Lt in Fe = Fe || {}, pe = pe || {}) Object.prototype.hasOwnProperty.call(pe, Lt) && (Object.prototype.hasOwnProperty.call(Fe, Lt) || ut(Lt, Ke, ct));
+                  for (Lt in Fe) Object.prototype.hasOwnProperty.call(Fe, Lt) && (Object.prototype.hasOwnProperty.call(pe, Lt) ? pt(pe[Lt], Fe[Lt]) || (pe[Lt].type === "geojson" && Fe[Lt].type === "geojson" && Nt(pe, Fe, Lt) ? Vt(Ke, { command: "setGeoJSONSourceData", args: [Lt, Fe[Lt].data] }) : Wt(Lt, Fe, Ke, ct)) : ot(Lt, Fe, Ke));
+                })(R.sources, S.sources, te, W);
+                let fe = [];
+                R.layers && R.layers.forEach((pe) => {
+                  "source" in pe && W[pe.source] ? F.push({ command: "removeLayer", args: [pe.id] }) : fe.push(pe);
+                }), F = F.concat(te), function(pe, Fe, Ke) {
+                  Fe = Fe || [];
+                  let ct = (pe = pe || []).map(sr), Lt = Fe.map(sr), Jt = pe.reduce(Tr, {}), cr = Fe.reduce(Tr, {}), mr = ct.slice(), Pr = /* @__PURE__ */ Object.create(null), zr, ui, yi, vn, zi;
+                  for (let un = 0, Tn = 0; un < ct.length; un++) zr = ct[un], Object.prototype.hasOwnProperty.call(cr, zr) ? Tn++ : (Vt(Ke, { command: "removeLayer", args: [zr] }), mr.splice(mr.indexOf(zr, Tn), 1));
+                  for (let un = 0, Tn = 0; un < Lt.length; un++) zr = Lt[Lt.length - 1 - un], mr[mr.length - 1 - un] !== zr && (Object.prototype.hasOwnProperty.call(Jt, zr) ? (Vt(Ke, { command: "removeLayer", args: [zr] }), mr.splice(mr.lastIndexOf(zr, mr.length - Tn), 1)) : Tn++, vn = mr[mr.length - un], Vt(Ke, { command: "addLayer", args: [cr[zr], vn] }), mr.splice(mr.length - un, 0, zr), Pr[zr] = true);
+                  for (let un = 0; un < Lt.length; un++) if (zr = Lt[un], ui = Jt[zr], yi = cr[zr], !Pr[zr] && !pt(ui, yi)) if (pt(ui.source, yi.source) && pt(ui["source-layer"], yi["source-layer"]) && pt(ui.type, yi.type)) {
+                    for (zi in $t(ui.layout, yi.layout, Ke, zr, null, "setLayoutProperty"), $t(ui.paint, yi.paint, Ke, zr, null, "setPaintProperty"), pt(ui.filter, yi.filter) || Vt(Ke, { command: "setFilter", args: [zr, yi.filter] }), pt(ui.minzoom, yi.minzoom) && pt(ui.maxzoom, yi.maxzoom) || Vt(Ke, { command: "setLayerZoomRange", args: [zr, yi.minzoom, yi.maxzoom] }), ui) Object.prototype.hasOwnProperty.call(ui, zi) && zi !== "layout" && zi !== "paint" && zi !== "filter" && zi !== "metadata" && zi !== "minzoom" && zi !== "maxzoom" && (zi.indexOf("paint.") === 0 ? $t(ui[zi], yi[zi], Ke, zr, zi.slice(6), "setPaintProperty") : pt(ui[zi], yi[zi]) || Vt(Ke, { command: "setLayerProperty", args: [zr, zi, yi[zi]] }));
+                    for (zi in yi) Object.prototype.hasOwnProperty.call(yi, zi) && !Object.prototype.hasOwnProperty.call(ui, zi) && zi !== "layout" && zi !== "paint" && zi !== "filter" && zi !== "metadata" && zi !== "minzoom" && zi !== "maxzoom" && (zi.indexOf("paint.") === 0 ? $t(ui[zi], yi[zi], Ke, zr, zi.slice(6), "setPaintProperty") : pt(ui[zi], yi[zi]) || Vt(Ke, { command: "setLayerProperty", args: [zr, zi, yi[zi]] }));
+                  } else Vt(Ke, { command: "removeLayer", args: [zr] }), vn = mr[mr.lastIndexOf(zr) + 1], Vt(Ke, { command: "addLayer", args: [yi, vn] });
+                }(fe, S.layers, F);
+              } catch (W) {
+                console.warn("Unable to compute style diff:", W), F = [{ command: "setStyle", args: [S] }];
+              }
+              return F;
+            }, i.aD = function(R) {
+              let S = [], F = R.id;
+              return F === void 0 && S.push({ message: `layers.${F}: missing required property "id"` }), R.render === void 0 && S.push({ message: `layers.${F}: missing required method "render"` }), R.renderingMode && R.renderingMode !== "2d" && R.renderingMode !== "3d" && S.push({ message: `layers.${F}: property "renderingMode" must be either "2d" or "3d"` }), S;
+            }, i.aE = function R(S, F) {
+              if (Array.isArray(S)) {
+                if (!Array.isArray(F) || S.length !== F.length) return false;
+                for (let W = 0; W < S.length; W++) if (!R(S[W], F[W])) return false;
+                return true;
+              }
+              if (typeof S == "object" && S !== null && F !== null) {
+                if (typeof F != "object" || Object.keys(S).length !== Object.keys(F).length) return false;
+                for (let W in S) if (!R(S[W], F[W])) return false;
+                return true;
+              }
+              return S === F;
+            }, i.aF = C, i.aG = M, i.aH = class extends Si {
+              constructor(R, S) {
+                super(R, S), this.current = 0;
+              }
+              set(R) {
+                this.current !== R && (this.current = R, this.gl.uniform1i(this.location, R));
+              }
+            }, i.aI = ei, i.aJ = class extends Si {
+              constructor(R, S) {
+                super(R, S), this.current = Un;
+              }
+              set(R) {
+                if (R[12] !== this.current[12] || R[0] !== this.current[0]) return this.current = R, void this.gl.uniformMatrix4fv(this.location, false, R);
+                for (let S = 1; S < 16; S++) if (R[S] !== this.current[S]) {
+                  this.current = R, this.gl.uniformMatrix4fv(this.location, false, R);
+                  break;
+                }
+              }
+            }, i.aK = Ln, i.aL = En, i.aM = nr, i.aN = class extends Si {
+              constructor(R, S) {
+                super(R, S), this.current = [0, 0, 0];
+              }
+              set(R) {
+                R[0] === this.current[0] && R[1] === this.current[1] && R[2] === this.current[2] || (this.current = R, this.gl.uniform3f(this.location, R[0], R[1], R[2]));
+              }
+            }, i.aO = class extends Si {
+              constructor(R, S) {
+                super(R, S), this.current = [0, 0];
+              }
+              set(R) {
+                R[0] === this.current[0] && R[1] === this.current[1] || (this.current = R, this.gl.uniform2f(this.location, R[0], R[1]));
+              }
+            }, i.aP = function(R, S, F, W, te, fe, pe) {
+              var Fe = 1 / (S - F), Ke = 1 / (W - te), ct = 1 / (fe - pe);
+              return R[0] = -2 * Fe, R[1] = 0, R[2] = 0, R[3] = 0, R[4] = 0, R[5] = -2 * Ke, R[6] = 0, R[7] = 0, R[8] = 0, R[9] = 0, R[10] = 2 * ct, R[11] = 0, R[12] = (S + F) * Fe, R[13] = (te + W) * Ke, R[14] = (pe + fe) * ct, R[15] = 1, R;
+            }, i.aQ = Zi, i.aR = class extends it {
+            }, i.aS = om, i.aT = class extends Ht {
+            }, i.aU = ta, i.aV = function(R) {
+              return R <= 1 ? 1 : Math.pow(2, Math.ceil(Math.log(R) / Math.LN2));
+            }, i.aW = kn, i.aX = wo, i.aY = se, i.aZ = class extends Pi {
+            }, i.a_ = function(R, S) {
+              return R[0] === S[0] && R[1] === S[1] && R[2] === S[2] && R[3] === S[3] && R[4] === S[4] && R[5] === S[5] && R[6] === S[6] && R[7] === S[7] && R[8] === S[8] && R[9] === S[9] && R[10] === S[10] && R[11] === S[11] && R[12] === S[12] && R[13] === S[13] && R[14] === S[14] && R[15] === S[15];
+            }, i.aa = function(R) {
+              let S = {};
+              if (R.replace(/(?:^|(?:\s*\,\s*))([^\x00-\x20\(\)<>@\,;\:\\"\/\[\]\?\=\{\}\x7F]+)(?:\=(?:([^\x00-\x20\(\)<>@\,;\:\\"\/\[\]\?\=\{\}\x7F]+)|(?:\"((?:[^"\\]|\\.)*)\")))?/g, (F, W, te, fe) => {
+                let pe = te || fe;
+                return S[W] = !pe || pe.toLowerCase(), "";
+              }), S["max-age"]) {
+                let F = parseInt(S["max-age"], 10);
+                isNaN(F) ? delete S["max-age"] : S["max-age"] = F;
+              }
+              return S;
+            }, i.ab = function(R, S) {
+              let F = [];
+              for (let W in R) W in S || F.push(W);
+              return F;
+            }, i.ac = E, i.ad = function(R, S, F) {
+              var W = Math.sin(F), te = Math.cos(F), fe = S[0], pe = S[1], Fe = S[2], Ke = S[3], ct = S[4], Lt = S[5], Jt = S[6], cr = S[7];
+              return S !== R && (R[8] = S[8], R[9] = S[9], R[10] = S[10], R[11] = S[11], R[12] = S[12], R[13] = S[13], R[14] = S[14], R[15] = S[15]), R[0] = fe * te + ct * W, R[1] = pe * te + Lt * W, R[2] = Fe * te + Jt * W, R[3] = Ke * te + cr * W, R[4] = ct * te - fe * W, R[5] = Lt * te - pe * W, R[6] = Jt * te - Fe * W, R[7] = cr * te - Ke * W, R;
+            }, i.ae = function(R) {
+              var S = new xi(16);
+              return S[0] = R[0], S[1] = R[1], S[2] = R[2], S[3] = R[3], S[4] = R[4], S[5] = R[5], S[6] = R[6], S[7] = R[7], S[8] = R[8], S[9] = R[9], S[10] = R[10], S[11] = R[11], S[12] = R[12], S[13] = R[13], S[14] = R[14], S[15] = R[15], S;
+            }, i.af = Bn, i.ag = function(R, S) {
+              let F = 0, W = 0;
+              if (R.kind === "constant") W = R.layoutSize;
+              else if (R.kind !== "source") {
+                let { interpolationType: te, minZoom: fe, maxZoom: pe } = R, Fe = te ? E(ko.interpolationFactor(te, S, fe, pe), 0, 1) : 0;
+                R.kind === "camera" ? W = Lo.number(R.minSize, R.maxSize, Fe) : F = Fe;
+              }
+              return { uSizeT: F, uSize: W };
+            }, i.ai = function(R, { uSize: S, uSizeT: F }, { lowerSize: W, upperSize: te }) {
+              return R.kind === "source" ? W / v0 : R.kind === "composite" ? Lo.number(W / v0, te / v0, F) : S;
+            }, i.aj = hS, i.ak = function(R, S, F, W) {
+              let te = S.y - R.y, fe = S.x - R.x, pe = W.y - F.y, Fe = W.x - F.x, Ke = pe * fe - Fe * te;
+              if (Ke === 0) return null;
+              let ct = (Fe * (R.y - F.y) - pe * (R.x - F.x)) / Ke;
+              return new u(R.x + ct * fe, R.y + ct * te);
+            }, i.al = GC, i.am = Sc, i.an = Ri, i.ao = function(R) {
+              let S = 1 / 0, F = 1 / 0, W = -1 / 0, te = -1 / 0;
+              for (let fe of R) S = Math.min(S, fe.x), F = Math.min(F, fe.y), W = Math.max(W, fe.x), te = Math.max(te, fe.y);
+              return [S, F, W, te];
+            }, i.ap = tu, i.ar = fS, i.as = function(R, S) {
+              var F = S[0], W = S[1], te = S[2], fe = S[3], pe = S[4], Fe = S[5], Ke = S[6], ct = S[7], Lt = S[8], Jt = S[9], cr = S[10], mr = S[11], Pr = S[12], zr = S[13], ui = S[14], yi = S[15], vn = F * Fe - W * pe, zi = F * Ke - te * pe, un = F * ct - fe * pe, Tn = W * Ke - te * Fe, pa = W * ct - fe * Fe, ro = te * ct - fe * Ke, Vo = Lt * zr - Jt * Pr, Xa = Lt * ui - cr * Pr, sa = Lt * yi - mr * Pr, Mo = Jt * ui - cr * zr, fo = Jt * yi - mr * zr, lo = cr * yi - mr * ui, Xn = vn * lo - zi * fo + un * Mo + Tn * sa - pa * Xa + ro * Vo;
+              return Xn ? (R[0] = (Fe * lo - Ke * fo + ct * Mo) * (Xn = 1 / Xn), R[1] = (te * fo - W * lo - fe * Mo) * Xn, R[2] = (zr * ro - ui * pa + yi * Tn) * Xn, R[3] = (cr * pa - Jt * ro - mr * Tn) * Xn, R[4] = (Ke * sa - pe * lo - ct * Xa) * Xn, R[5] = (F * lo - te * sa + fe * Xa) * Xn, R[6] = (ui * un - Pr * ro - yi * zi) * Xn, R[7] = (Lt * ro - cr * un + mr * zi) * Xn, R[8] = (pe * fo - Fe * sa + ct * Vo) * Xn, R[9] = (W * sa - F * fo - fe * Vo) * Xn, R[10] = (Pr * pa - zr * un + yi * vn) * Xn, R[11] = (Jt * un - Lt * pa - mr * vn) * Xn, R[12] = (Fe * Xa - pe * Mo - Ke * Vo) * Xn, R[13] = (F * Mo - W * Xa + te * Vo) * Xn, R[14] = (zr * zi - Pr * Tn - ui * vn) * Xn, R[15] = (Lt * Tn - Jt * zi + cr * vn) * Xn, R) : null;
+            }, i.at = TS, i.au = Gw, i.av = AS, i.aw = function() {
+              let R = {}, S = ce.$version;
+              for (let F in ce.$root) {
+                let W = ce.$root[F];
+                if (W.required) {
+                  let te = null;
+                  te = F === "version" ? S : W.type === "array" ? [] : {}, te != null && (R[F] = te);
+                }
+              }
+              return R;
+            }, i.ax = Yn, i.ay = ie, i.az = function(R) {
+              R = R.slice();
+              let S = /* @__PURE__ */ Object.create(null);
+              for (let F = 0; F < R.length; F++) S[R[F].id] = R[F];
+              for (let F = 0; F < R.length; F++) "ref" in R[F] && (R[F] = lt(R[F], S[R[F].ref]));
+              return R;
+            }, i.b = G, i.b0 = function(R, S) {
+              return R[0] = S[0], R[1] = S[1], R[2] = S[2], R[3] = S[3], R[4] = S[4], R[5] = S[5], R[6] = S[6], R[7] = S[7], R[8] = S[8], R[9] = S[9], R[10] = S[10], R[11] = S[11], R[12] = S[12], R[13] = S[13], R[14] = S[14], R[15] = S[15], R;
+            }, i.b1 = function(R, S, F) {
+              return R[0] = S[0] * F[0], R[1] = S[1] * F[1], R[2] = S[2] * F[2], R[3] = S[3] * F[3], R;
+            }, i.b2 = function(R, S) {
+              return R[0] * S[0] + R[1] * S[1] + R[2] * S[2] + R[3] * S[3];
+            }, i.b3 = T, i.b4 = qC, i.b5 = Xw, i.b6 = function(R, S, F, W, te) {
+              var fe, pe = 1 / Math.tan(S / 2);
+              return R[0] = pe / F, R[1] = 0, R[2] = 0, R[3] = 0, R[4] = 0, R[5] = pe, R[6] = 0, R[7] = 0, R[8] = 0, R[9] = 0, R[11] = -1, R[12] = 0, R[13] = 0, R[15] = 0, te != null && te !== 1 / 0 ? (R[10] = (te + W) * (fe = 1 / (W - te)), R[14] = 2 * te * W * fe) : (R[10] = -1, R[14] = -2 * W), R;
+            }, i.b7 = function(R, S, F) {
+              var W = Math.sin(F), te = Math.cos(F), fe = S[4], pe = S[5], Fe = S[6], Ke = S[7], ct = S[8], Lt = S[9], Jt = S[10], cr = S[11];
+              return S !== R && (R[0] = S[0], R[1] = S[1], R[2] = S[2], R[3] = S[3], R[12] = S[12], R[13] = S[13], R[14] = S[14], R[15] = S[15]), R[4] = fe * te + ct * W, R[5] = pe * te + Lt * W, R[6] = Fe * te + Jt * W, R[7] = Ke * te + cr * W, R[8] = ct * te - fe * W, R[9] = Lt * te - pe * W, R[10] = Jt * te - Fe * W, R[11] = cr * te - Ke * W, R;
+            }, i.b8 = p, i.b9 = k, i.bA = Sd, i.bB = function(R) {
+              return R.message === re;
+            }, i.bC = ks, i.bD = ys, i.ba = function(R) {
+              return R * Math.PI / 180;
+            }, i.bb = function(R, S) {
+              let { x: F, y: W } = sb.fromLngLat(S);
+              return !(R < 0 || R > 25 || W < 0 || W >= 1 || F < 0 || F >= 1);
+            }, i.bc = function(R, S) {
+              return R[0] = S[0], R[1] = 0, R[2] = 0, R[3] = 0, R[4] = 0, R[5] = S[1], R[6] = 0, R[7] = 0, R[8] = 0, R[9] = 0, R[10] = S[2], R[11] = 0, R[12] = 0, R[13] = 0, R[14] = 0, R[15] = 1, R;
+            }, i.bd = class extends Tt {
+            }, i.be = yS, i.bf = uO, i.bh = ge, i.bi = function(R, S) {
+              _e.REGISTERED_PROTOCOLS[R] = S;
+            }, i.bj = function(R) {
+              delete _e.REGISTERED_PROTOCOLS[R];
+            }, i.bk = function(R, S) {
+              let F = {};
+              for (let te = 0; te < R.length; te++) {
+                let fe = S && S[R[te].id] || Xh(R[te]);
+                S && (S[R[te].id] = fe);
+                let pe = F[fe];
+                pe || (pe = F[fe] = []), pe.push(R[te]);
+              }
+              let W = [];
+              for (let te in F) W.push(F[te]);
+              return W;
+            }, i.bl = Fi, i.bm = NC, i.bn = my, i.bo = Nw, i.bp = function(R) {
+              R.bucket.createArrays(), R.bucket.tilePixelRatio = ja / (512 * R.bucket.overscaling), R.bucket.compareText = {}, R.bucket.iconsNeedLinear = false;
+              let S = R.bucket.layers[0], F = S.layout, W = S._unevaluatedLayout._values, te = { layoutIconSize: W["icon-size"].possiblyEvaluate(new rs(R.bucket.zoom + 1), R.canonical), layoutTextSize: W["text-size"].possiblyEvaluate(new rs(R.bucket.zoom + 1), R.canonical), textMaxSize: W["text-size"].possiblyEvaluate(new rs(18)) };
+              if (R.bucket.textSizeData.kind === "composite") {
+                let { minZoom: ct, maxZoom: Lt } = R.bucket.textSizeData;
+                te.compositeTextSizes = [W["text-size"].possiblyEvaluate(new rs(ct), R.canonical), W["text-size"].possiblyEvaluate(new rs(Lt), R.canonical)];
+              }
+              if (R.bucket.iconSizeData.kind === "composite") {
+                let { minZoom: ct, maxZoom: Lt } = R.bucket.iconSizeData;
+                te.compositeIconSizes = [W["icon-size"].possiblyEvaluate(new rs(ct), R.canonical), W["icon-size"].possiblyEvaluate(new rs(Lt), R.canonical)];
+              }
+              let fe = F.get("text-line-height") * tu, pe = F.get("text-rotation-alignment") !== "viewport" && F.get("symbol-placement") !== "point", Fe = F.get("text-keep-upright"), Ke = F.get("text-size");
+              for (let ct of R.bucket.features) {
+                let Lt = F.get("text-font").evaluate(ct, {}, R.canonical).join(","), Jt = Ke.evaluate(ct, {}, R.canonical), cr = te.layoutTextSize.evaluate(ct, {}, R.canonical), mr = te.layoutIconSize.evaluate(ct, {}, R.canonical), Pr = { horizontal: {}, vertical: void 0 }, zr = ct.text, ui, yi = [0, 0];
+                if (zr) {
+                  let un = zr.toString(), Tn = F.get("text-letter-spacing").evaluate(ct, {}, R.canonical) * tu, pa = bo(un) ? Tn : 0, ro = F.get("text-anchor").evaluate(ct, {}, R.canonical), Vo = KC(S, ct, R.canonical);
+                  if (!Vo) {
+                    let fo = F.get("text-radial-offset").evaluate(ct, {}, R.canonical);
+                    yi = fo ? wS(ro, [fo * tu, yy]) : F.get("text-offset").evaluate(ct, {}, R.canonical).map((lo) => lo * tu);
+                  }
+                  let Xa = pe ? "center" : F.get("text-justify").evaluate(ct, {}, R.canonical), sa = F.get("symbol-placement") === "point" ? F.get("text-max-width").evaluate(ct, {}, R.canonical) * tu : 1 / 0, Mo = () => {
+                    R.bucket.allowVerticalPlacement && Ka(un) && (Pr.vertical = Qx(zr, R.glyphMap, R.glyphPositions, R.imagePositions, Lt, sa, fe, ro, "left", pa, yi, i.ah.vertical, true, cr, Jt));
+                  };
+                  if (!pe && Vo) {
+                    let fo = /* @__PURE__ */ new Set();
+                    if (Xa === "auto") for (let Xn = 0; Xn < Vo.values.length; Xn += 2) fo.add(TS(Vo.values[Xn]));
+                    else fo.add(Xa);
+                    let lo = false;
+                    for (let Xn of fo) if (!Pr.horizontal[Xn]) if (lo) Pr.horizontal[Xn] = Pr.horizontal[0];
+                    else {
+                      let Ro = Qx(zr, R.glyphMap, R.glyphPositions, R.imagePositions, Lt, sa, fe, "center", Xn, pa, yi, i.ah.horizontal, false, cr, Jt);
+                      Ro && (Pr.horizontal[Xn] = Ro, lo = Ro.positionedLines.length === 1);
+                    }
+                    Mo();
+                  } else {
+                    Xa === "auto" && (Xa = TS(ro));
+                    let fo = Qx(zr, R.glyphMap, R.glyphPositions, R.imagePositions, Lt, sa, fe, ro, Xa, pa, yi, i.ah.horizontal, false, cr, Jt);
+                    fo && (Pr.horizontal[Xa] = fo), Mo(), Ka(un) && pe && Fe && (Pr.vertical = Qx(zr, R.glyphMap, R.glyphPositions, R.imagePositions, Lt, sa, fe, ro, Xa, pa, yi, i.ah.vertical, false, cr, Jt));
+                  }
+                }
+                let vn = false;
+                if (ct.icon && ct.icon.name) {
+                  let un = R.imageMap[ct.icon.name];
+                  un && (ui = eb(R.imagePositions[ct.icon.name], F.get("icon-offset").evaluate(ct, {}, R.canonical), F.get("icon-anchor").evaluate(ct, {}, R.canonical)), vn = !!un.sdf, R.bucket.sdfIcons === void 0 ? R.bucket.sdfIcons = vn : R.bucket.sdfIcons !== vn && A("Style sheet warning: Cannot mix SDF and non-SDF icons in one buffer"), (un.pixelRatio !== R.bucket.pixelRatio || F.get("icon-rotate").constantOr(1) !== 0) && (R.bucket.iconsNeedLinear = true));
+                }
+                let zi = $C(Pr.horizontal) || Pr.vertical;
+                R.bucket.iconsInText = !!zi && zi.iconsInText, (zi || ui) && sO(R.bucket, ct, Pr, ui, R.imageMap, te, cr, mr, yi, vn, R.canonical);
+              }
+              R.showCollisionBoxes && R.bucket.generateCollisionDebugBuffers();
+            }, i.bq = Jv, i.br = Ot, i.bs = so, i.bt = br, i.bu = lS, i.bv = class {
+              constructor(R) {
+                this._marks = { start: [R.url, "start"].join("#"), end: [R.url, "end"].join("#"), measure: R.url.toString() }, performance.mark(this._marks.start);
+              }
+              finish() {
+                performance.mark(this._marks.end);
+                let R = performance.getEntriesByName(this._marks.measure);
+                return R.length === 0 && (performance.measure(this._marks.measure, this._marks.start, this._marks.end), R = performance.getEntriesByName(this._marks.measure), performance.clearMarks(this._marks.start), performance.clearMarks(this._marks.end), performance.clearMeasures(this._marks.measure)), R;
+              }
+            }, i.bw = function(R, S, F, W, te) {
+              return a(this, void 0, void 0, function* () {
+                if (b()) try {
+                  return yield j(R, S, F, W, te);
+                } catch (fe) {
+                }
+                return function(fe, pe, Fe, Ke, ct) {
+                  let Lt = fe.width, Jt = fe.height;
+                  N && H || (N = new OffscreenCanvas(Lt, Jt), H = N.getContext("2d", { willReadFrequently: true })), N.width = Lt, N.height = Jt, H.drawImage(fe, 0, 0, Lt, Jt);
+                  let cr = H.getImageData(pe, Fe, Ke, ct);
+                  return H.clearRect(0, 0, Lt, Jt), cr.data;
+                }(R, S, F, W, te);
+              });
+            }, i.bx = BC, i.by = o, i.bz = s, i.c = oe, i.d = (R) => a(void 0, void 0, void 0, function* () {
+              if (R.byteLength === 0) return createImageBitmap(new ImageData(1, 1));
+              let S = new Blob([new Uint8Array(R)], { type: "image/png" });
+              try {
+                return createImageBitmap(S);
+              } catch (F) {
+                throw new Error(`Could not load image because of ${F.message}. Please make sure to use a supported image type such as PNG or JPEG. Note that SVGs are not supported.`);
+              }
+            }), i.e = L, i.f = (R) => new Promise((S, F) => {
+              let W = new Image();
+              W.onload = () => {
+                S(W), URL.revokeObjectURL(W.src), W.onload = null, window.requestAnimationFrame(() => {
+                  W.src = Z;
+                });
+              }, W.onerror = () => F(new Error("Could not load image. Please make sure to use a supported image type such as PNG or JPEG. Note that SVGs are not supported."));
+              let te = new Blob([new Uint8Array(R)], { type: "image/png" });
+              W.src = R.byteLength ? URL.createObjectURL(te) : Z;
+            }), i.g = Ce, i.h = (R, S) => Se(L(R, { type: "json" }), S), i.i = O, i.j = me, i.k = Pe, i.l = (R, S) => Se(L(R, { type: "arrayBuffer" }), S), i.m = Se, i.n = function(R) {
+              return new lS(R).readFields(qQ, []);
+            }, i.o = na, i.p = cS, i.q = ue, i.r = Xi, i.s = Ee, i.t = Yi, i.u = ki, i.v = ce, i.w = A, i.x = function([R, S, F]) {
+              return S += 90, S *= Math.PI / 180, F *= Math.PI / 180, { x: R * Math.cos(S) * Math.sin(F), y: R * Math.sin(S) * Math.sin(F), z: R * Math.cos(F) };
+            }, i.y = Lo, i.z = rs;
+          }), r("worker", ["./shared"], function(i) {
+            class a {
+              constructor(Ge) {
+                this.keyCache = {}, Ge && this.replace(Ge);
+              }
+              replace(Ge) {
+                this._layerConfigs = {}, this._layers = {}, this.update(Ge, []);
+              }
+              update(Ge, Je) {
+                for (let tt of Ge) {
+                  this._layerConfigs[tt.id] = tt;
+                  let xt = this._layers[tt.id] = i.aA(tt);
+                  xt._featureFilter = i.a7(xt.filter), this.keyCache[tt.id] && delete this.keyCache[tt.id];
+                }
+                for (let tt of Je) delete this.keyCache[tt], delete this._layerConfigs[tt], delete this._layers[tt];
+                this.familiesBySource = {};
+                let We = i.bk(Object.values(this._layerConfigs), this.keyCache);
+                for (let tt of We) {
+                  let xt = tt.map((ar) => this._layers[ar.id]), Ie = xt[0];
+                  if (Ie.visibility === "none") continue;
+                  let xe = Ie.source || "", ke = this.familiesBySource[xe];
+                  ke || (ke = this.familiesBySource[xe] = {});
+                  let vt = Ie.sourceLayer || "_geojsonTileLayer", ir = ke[vt];
+                  ir || (ir = ke[vt] = []), ir.push(xt);
+                }
+              }
+            }
+            class o {
+              constructor(Ge) {
+                let Je = {}, We = [];
+                for (let xe in Ge) {
+                  let ke = Ge[xe], vt = Je[xe] = {};
+                  for (let ir in ke) {
+                    let ar = ke[+ir];
+                    if (!ar || ar.bitmap.width === 0 || ar.bitmap.height === 0) continue;
+                    let vr = { x: 0, y: 0, w: ar.bitmap.width + 2, h: ar.bitmap.height + 2 };
+                    We.push(vr), vt[ir] = { rect: vr, metrics: ar.metrics };
+                  }
+                }
+                let { w: tt, h: xt } = i.p(We), Ie = new i.o({ width: tt || 1, height: xt || 1 });
+                for (let xe in Ge) {
+                  let ke = Ge[xe];
+                  for (let vt in ke) {
+                    let ir = ke[+vt];
+                    if (!ir || ir.bitmap.width === 0 || ir.bitmap.height === 0) continue;
+                    let ar = Je[xe][vt].rect;
+                    i.o.copy(ir.bitmap, Ie, { x: 0, y: 0 }, { x: ar.x + 1, y: ar.y + 1 }, ir.bitmap);
+                  }
+                }
+                this.image = Ie, this.positions = Je;
+              }
+            }
+            i.bl("GlyphAtlas", o);
+            class s {
+              constructor(Ge) {
+                this.tileID = new i.S(Ge.tileID.overscaledZ, Ge.tileID.wrap, Ge.tileID.canonical.z, Ge.tileID.canonical.x, Ge.tileID.canonical.y), this.uid = Ge.uid, this.zoom = Ge.zoom, this.pixelRatio = Ge.pixelRatio, this.tileSize = Ge.tileSize, this.source = Ge.source, this.overscaling = this.tileID.overscaleFactor(), this.showCollisionBoxes = Ge.showCollisionBoxes, this.collectResourceTiming = !!Ge.collectResourceTiming, this.returnDependencies = !!Ge.returnDependencies, this.promoteId = Ge.promoteId, this.inFlightDependencies = [];
+              }
+              parse(Ge, Je, We, tt) {
+                return i._(this, void 0, void 0, function* () {
+                  this.status = "parsing", this.data = Ge, this.collisionBoxArray = new i.a5();
+                  let xt = new i.bm(Object.keys(Ge.layers).sort()), Ie = new i.bn(this.tileID, this.promoteId);
+                  Ie.bucketLayerIDs = [];
+                  let xe = {}, ke = { featureIndex: Ie, iconDependencies: {}, patternDependencies: {}, glyphDependencies: {}, availableImages: We }, vt = Je.familiesBySource[this.source];
+                  for (let qn in vt) {
+                    let Fn = Ge.layers[qn];
+                    if (!Fn) continue;
+                    Fn.version === 1 && i.w(`Vector tile source "${this.source}" layer "${qn}" does not use vector tile spec v2 and therefore may have some rendering errors.`);
+                    let ra = xt.encode(qn), la = [];
+                    for (let Ut = 0; Ut < Fn.length; Ut++) {
+                      let wt = Fn.feature(Ut), rr = Ie.getId(wt, qn);
+                      la.push({ feature: wt, id: rr, index: Ut, sourceLayerIndex: ra });
+                    }
+                    for (let Ut of vt[qn]) {
+                      let wt = Ut[0];
+                      wt.source !== this.source && i.w(`layer.source = ${wt.source} does not equal this.source = ${this.source}`), wt.minzoom && this.zoom < Math.floor(wt.minzoom) || wt.maxzoom && this.zoom >= wt.maxzoom || wt.visibility !== "none" && (l(Ut, this.zoom, We), (xe[wt.id] = wt.createBucket({ index: Ie.bucketLayerIDs.length, layers: Ut, zoom: this.zoom, pixelRatio: this.pixelRatio, overscaling: this.overscaling, collisionBoxArray: this.collisionBoxArray, sourceLayerIndex: ra, sourceID: this.source })).populate(la, ke, this.tileID.canonical), Ie.bucketLayerIDs.push(Ut.map((rr) => rr.id)));
+                    }
+                  }
+                  let ir = i.aF(ke.glyphDependencies, (qn) => Object.keys(qn).map(Number));
+                  this.inFlightDependencies.forEach((qn) => qn == null ? void 0 : qn.abort()), this.inFlightDependencies = [];
+                  let ar = Promise.resolve({});
+                  if (Object.keys(ir).length) {
+                    let qn = new AbortController();
+                    this.inFlightDependencies.push(qn), ar = tt.sendAsync({ type: "GG", data: { stacks: ir, source: this.source, tileID: this.tileID, type: "glyphs" } }, qn);
+                  }
+                  let vr = Object.keys(ke.iconDependencies), ii = Promise.resolve({});
+                  if (vr.length) {
+                    let qn = new AbortController();
+                    this.inFlightDependencies.push(qn), ii = tt.sendAsync({ type: "GI", data: { icons: vr, source: this.source, tileID: this.tileID, type: "icons" } }, qn);
+                  }
+                  let pi = Object.keys(ke.patternDependencies), $r = Promise.resolve({});
+                  if (pi.length) {
+                    let qn = new AbortController();
+                    this.inFlightDependencies.push(qn), $r = tt.sendAsync({ type: "GI", data: { icons: pi, source: this.source, tileID: this.tileID, type: "patterns" } }, qn);
+                  }
+                  let [di, ji, In] = yield Promise.all([ar, ii, $r]), wi = new o(di), On = new i.bo(ji, In);
+                  for (let qn in xe) {
+                    let Fn = xe[qn];
+                    Fn instanceof i.a6 ? (l(Fn.layers, this.zoom, We), i.bp({ bucket: Fn, glyphMap: di, glyphPositions: wi.positions, imageMap: ji, imagePositions: On.iconPositions, showCollisionBoxes: this.showCollisionBoxes, canonical: this.tileID.canonical })) : Fn.hasPattern && (Fn instanceof i.bq || Fn instanceof i.br || Fn instanceof i.bs) && (l(Fn.layers, this.zoom, We), Fn.addFeatures(ke, this.tileID.canonical, On.patternPositions));
+                  }
+                  return this.status = "done", { buckets: Object.values(xe).filter((qn) => !qn.isEmpty()), featureIndex: Ie, collisionBoxArray: this.collisionBoxArray, glyphAtlasImage: wi.image, imageAtlas: On, glyphMap: this.returnDependencies ? di : null, iconMap: this.returnDependencies ? ji : null, glyphPositions: this.returnDependencies ? wi.positions : null };
+                });
+              }
+            }
+            function l(dt, Ge, Je) {
+              let We = new i.z(Ge);
+              for (let tt of dt) tt.recalculate(We, Je);
+            }
+            class u {
+              constructor(Ge, Je, We) {
+                this.actor = Ge, this.layerIndex = Je, this.availableImages = We, this.fetching = {}, this.loading = {}, this.loaded = {};
+              }
+              loadVectorTile(Ge, Je) {
+                return i._(this, void 0, void 0, function* () {
+                  let We = yield i.l(Ge.request, Je);
+                  try {
+                    return { vectorTile: new i.bt.VectorTile(new i.bu(We.data)), rawData: We.data, cacheControl: We.cacheControl, expires: We.expires };
+                  } catch (tt) {
+                    let xt = new Uint8Array(We.data), Ie = `Unable to parse the tile at ${Ge.request.url}, `;
+                    throw Ie += xt[0] === 31 && xt[1] === 139 ? "please make sure the data is not gzipped and that you have configured the relevant header in the server" : `got error: ${tt.message}`, new Error(Ie);
+                  }
+                });
+              }
+              loadTile(Ge) {
+                return i._(this, void 0, void 0, function* () {
+                  let Je = Ge.uid, We = !!(Ge && Ge.request && Ge.request.collectResourceTiming) && new i.bv(Ge.request), tt = new s(Ge);
+                  this.loading[Je] = tt;
+                  let xt = new AbortController();
+                  tt.abort = xt;
+                  try {
+                    let Ie = yield this.loadVectorTile(Ge, xt);
+                    if (delete this.loading[Je], !Ie) return null;
+                    let xe = Ie.rawData, ke = {};
+                    Ie.expires && (ke.expires = Ie.expires), Ie.cacheControl && (ke.cacheControl = Ie.cacheControl);
+                    let vt = {};
+                    if (We) {
+                      let ar = We.finish();
+                      ar && (vt.resourceTiming = JSON.parse(JSON.stringify(ar)));
+                    }
+                    tt.vectorTile = Ie.vectorTile;
+                    let ir = tt.parse(Ie.vectorTile, this.layerIndex, this.availableImages, this.actor);
+                    this.loaded[Je] = tt, this.fetching[Je] = { rawTileData: xe, cacheControl: ke, resourceTiming: vt };
+                    try {
+                      let ar = yield ir;
+                      return i.e({ rawTileData: xe.slice(0) }, ar, ke, vt);
+                    } finally {
+                      delete this.fetching[Je];
+                    }
+                  } catch (Ie) {
+                    throw delete this.loading[Je], tt.status = "done", this.loaded[Je] = tt, Ie;
+                  }
+                });
+              }
+              reloadTile(Ge) {
+                return i._(this, void 0, void 0, function* () {
+                  let Je = Ge.uid;
+                  if (!this.loaded || !this.loaded[Je]) throw new Error("Should not be trying to reload a tile that was never loaded or has been removed");
+                  let We = this.loaded[Je];
+                  if (We.showCollisionBoxes = Ge.showCollisionBoxes, We.status === "parsing") {
+                    let tt = yield We.parse(We.vectorTile, this.layerIndex, this.availableImages, this.actor), xt;
+                    if (this.fetching[Je]) {
+                      let { rawTileData: Ie, cacheControl: xe, resourceTiming: ke } = this.fetching[Je];
+                      delete this.fetching[Je], xt = i.e({ rawTileData: Ie.slice(0) }, tt, xe, ke);
+                    } else xt = tt;
+                    return xt;
+                  }
+                  if (We.status === "done" && We.vectorTile) return We.parse(We.vectorTile, this.layerIndex, this.availableImages, this.actor);
+                });
+              }
+              abortTile(Ge) {
+                return i._(this, void 0, void 0, function* () {
+                  let Je = this.loading, We = Ge.uid;
+                  Je && Je[We] && Je[We].abort && (Je[We].abort.abort(), delete Je[We]);
+                });
+              }
+              removeTile(Ge) {
+                return i._(this, void 0, void 0, function* () {
+                  this.loaded && this.loaded[Ge.uid] && delete this.loaded[Ge.uid];
+                });
+              }
+            }
+            class c {
+              constructor() {
+                this.loaded = {};
+              }
+              loadTile(Ge) {
+                return i._(this, void 0, void 0, function* () {
+                  let { uid: Je, encoding: We, rawImageData: tt, redFactor: xt, greenFactor: Ie, blueFactor: xe, baseShift: ke } = Ge, vt = tt.width + 2, ir = tt.height + 2, ar = i.b(tt) ? new i.R({ width: vt, height: ir }, yield i.bw(tt, -1, -1, vt, ir)) : tt, vr = new i.bx(Je, ar, We, xt, Ie, xe, ke);
+                  return this.loaded = this.loaded || {}, this.loaded[Je] = vr, vr;
+                });
+              }
+              removeTile(Ge) {
+                let Je = this.loaded, We = Ge.uid;
+                Je && Je[We] && delete Je[We];
+              }
+            }
+            function f(dt, Ge) {
+              if (dt.length !== 0) {
+                h(dt[0], Ge);
+                for (var Je = 1; Je < dt.length; Je++) h(dt[Je], !Ge);
+              }
+            }
+            function h(dt, Ge) {
+              for (var Je = 0, We = 0, tt = 0, xt = dt.length, Ie = xt - 1; tt < xt; Ie = tt++) {
+                var xe = (dt[tt][0] - dt[Ie][0]) * (dt[Ie][1] + dt[tt][1]), ke = Je + xe;
+                We += Math.abs(Je) >= Math.abs(xe) ? Je - ke + xe : xe - ke + Je, Je = ke;
+              }
+              Je + We >= 0 != !!Ge && dt.reverse();
+            }
+            var d = i.by(function dt(Ge, Je) {
+              var We, tt = Ge && Ge.type;
+              if (tt === "FeatureCollection") for (We = 0; We < Ge.features.length; We++) dt(Ge.features[We], Je);
+              else if (tt === "GeometryCollection") for (We = 0; We < Ge.geometries.length; We++) dt(Ge.geometries[We], Je);
+              else if (tt === "Feature") dt(Ge.geometry, Je);
+              else if (tt === "Polygon") f(Ge.coordinates, Je);
+              else if (tt === "MultiPolygon") for (We = 0; We < Ge.coordinates.length; We++) f(Ge.coordinates[We], Je);
+              return Ge;
+            });
+            let v = i.bt.VectorTileFeature.prototype.toGeoJSON;
+            var _ = { exports: {} }, b = i.bz, p = i.bt.VectorTileFeature, k = E;
+            function E(dt, Ge) {
+              this.options = Ge || {}, this.features = dt, this.length = dt.length;
+            }
+            function T(dt, Ge) {
+              this.id = typeof dt.id == "number" ? dt.id : void 0, this.type = dt.type, this.rawGeometry = dt.type === 1 ? [dt.geometry] : dt.geometry, this.properties = dt.tags, this.extent = Ge || 4096;
+            }
+            E.prototype.feature = function(dt) {
+              return new T(this.features[dt], this.options.extent);
+            }, T.prototype.loadGeometry = function() {
+              var dt = this.rawGeometry;
+              this.geometry = [];
+              for (var Ge = 0; Ge < dt.length; Ge++) {
+                for (var Je = dt[Ge], We = [], tt = 0; tt < Je.length; tt++) We.push(new b(Je[tt][0], Je[tt][1]));
+                this.geometry.push(We);
+              }
+              return this.geometry;
+            }, T.prototype.bbox = function() {
+              this.geometry || this.loadGeometry();
+              for (var dt = this.geometry, Ge = 1 / 0, Je = -1 / 0, We = 1 / 0, tt = -1 / 0, xt = 0; xt < dt.length; xt++) for (var Ie = dt[xt], xe = 0; xe < Ie.length; xe++) {
+                var ke = Ie[xe];
+                Ge = Math.min(Ge, ke.x), Je = Math.max(Je, ke.x), We = Math.min(We, ke.y), tt = Math.max(tt, ke.y);
+              }
+              return [Ge, We, Je, tt];
+            }, T.prototype.toGeoJSON = p.prototype.toGeoJSON;
+            var L = i.bA, x = k;
+            function C(dt) {
+              var Ge = new L();
+              return function(Je, We) {
+                for (var tt in Je.layers) We.writeMessage(3, M, Je.layers[tt]);
+              }(dt, Ge), Ge.finish();
+            }
+            function M(dt, Ge) {
+              var Je;
+              Ge.writeVarintField(15, dt.version || 1), Ge.writeStringField(1, dt.name || ""), Ge.writeVarintField(5, dt.extent || 4096);
+              var We = { keys: [], values: [], keycache: {}, valuecache: {} };
+              for (Je = 0; Je < dt.length; Je++) We.feature = dt.feature(Je), Ge.writeMessage(2, g, We);
+              var tt = We.keys;
+              for (Je = 0; Je < tt.length; Je++) Ge.writeStringField(3, tt[Je]);
+              var xt = We.values;
+              for (Je = 0; Je < xt.length; Je++) Ge.writeMessage(4, U, xt[Je]);
+            }
+            function g(dt, Ge) {
+              var Je = dt.feature;
+              Je.id !== void 0 && Ge.writeVarintField(1, Je.id), Ge.writeMessage(2, P, dt), Ge.writeVarintField(3, Je.type), Ge.writeMessage(4, O, Je);
+            }
+            function P(dt, Ge) {
+              var Je = dt.feature, We = dt.keys, tt = dt.values, xt = dt.keycache, Ie = dt.valuecache;
+              for (var xe in Je.properties) {
+                var ke = Je.properties[xe], vt = xt[xe];
+                if (ke !== null) {
+                  vt === void 0 && (We.push(xe), xt[xe] = vt = We.length - 1), Ge.writeVarint(vt);
+                  var ir = typeof ke;
+                  ir !== "string" && ir !== "boolean" && ir !== "number" && (ke = JSON.stringify(ke));
+                  var ar = ir + ":" + ke, vr = Ie[ar];
+                  vr === void 0 && (tt.push(ke), Ie[ar] = vr = tt.length - 1), Ge.writeVarint(vr);
+                }
+              }
+            }
+            function A(dt, Ge) {
+              return (Ge << 3) + (7 & dt);
+            }
+            function z(dt) {
+              return dt << 1 ^ dt >> 31;
+            }
+            function O(dt, Ge) {
+              for (var Je = dt.loadGeometry(), We = dt.type, tt = 0, xt = 0, Ie = Je.length, xe = 0; xe < Ie; xe++) {
+                var ke = Je[xe], vt = 1;
+                We === 1 && (vt = ke.length), Ge.writeVarint(A(1, vt));
+                for (var ir = We === 3 ? ke.length - 1 : ke.length, ar = 0; ar < ir; ar++) {
+                  ar === 1 && We !== 1 && Ge.writeVarint(A(2, ir - 1));
+                  var vr = ke[ar].x - tt, ii = ke[ar].y - xt;
+                  Ge.writeVarint(z(vr)), Ge.writeVarint(z(ii)), tt += vr, xt += ii;
+                }
+                We === 3 && Ge.writeVarint(A(7, 1));
+              }
+            }
+            function U(dt, Ge) {
+              var Je = typeof dt;
+              Je === "string" ? Ge.writeStringField(1, dt) : Je === "boolean" ? Ge.writeBooleanField(7, dt) : Je === "number" && (dt % 1 != 0 ? Ge.writeDoubleField(3, dt) : dt < 0 ? Ge.writeSVarintField(6, dt) : Ge.writeVarintField(5, dt));
+            }
+            _.exports = C, _.exports.fromVectorTileJs = C, _.exports.fromGeojsonVt = function(dt, Ge) {
+              Ge = Ge || {};
+              var Je = {};
+              for (var We in dt) Je[We] = new x(dt[We].features, Ge), Je[We].name = We, Je[We].version = Ge.version, Je[We].extent = Ge.extent;
+              return C({ layers: Je });
+            }, _.exports.GeoJSONWrapper = x;
+            var G = i.by(_.exports);
+            let Z = { minZoom: 0, maxZoom: 16, minPoints: 2, radius: 40, extent: 512, nodeSize: 64, log: false, generateId: false, reduce: null, map: (dt) => dt }, j = Math.fround || (N = new Float32Array(1), (dt) => (N[0] = +dt, N[0]));
+            var N;
+            let H = 3, re = 5, oe = 6;
+            class _e {
+              constructor(Ge) {
+                this.options = Object.assign(Object.create(Z), Ge), this.trees = new Array(this.options.maxZoom + 1), this.stride = this.options.reduce ? 7 : 6, this.clusterProps = [];
+              }
+              load(Ge) {
+                let { log: Je, minZoom: We, maxZoom: tt } = this.options;
+                Je && console.time("total time");
+                let xt = `prepare ${Ge.length} points`;
+                Je && console.time(xt), this.points = Ge;
+                let Ie = [];
+                for (let ke = 0; ke < Ge.length; ke++) {
+                  let vt = Ge[ke];
+                  if (!vt.geometry) continue;
+                  let [ir, ar] = vt.geometry.coordinates, vr = j(ge(ir)), ii = j(ie(ar));
+                  Ie.push(vr, ii, 1 / 0, ke, -1, 1), this.options.reduce && Ie.push(0);
+                }
+                let xe = this.trees[tt + 1] = this._createTree(Ie);
+                Je && console.timeEnd(xt);
+                for (let ke = tt; ke >= We; ke--) {
+                  let vt = +Date.now();
+                  xe = this.trees[ke] = this._createTree(this._cluster(xe, ke)), Je && console.log("z%d: %d clusters in %dms", ke, xe.numItems, +Date.now() - vt);
+                }
+                return Je && console.timeEnd("total time"), this;
+              }
+              getClusters(Ge, Je) {
+                let We = ((Ge[0] + 180) % 360 + 360) % 360 - 180, tt = Math.max(-90, Math.min(90, Ge[1])), xt = Ge[2] === 180 ? 180 : ((Ge[2] + 180) % 360 + 360) % 360 - 180, Ie = Math.max(-90, Math.min(90, Ge[3]));
+                if (Ge[2] - Ge[0] >= 360) We = -180, xt = 180;
+                else if (We > xt) {
+                  let ar = this.getClusters([We, tt, 180, Ie], Je), vr = this.getClusters([-180, tt, xt, Ie], Je);
+                  return ar.concat(vr);
+                }
+                let xe = this.trees[this._limitZoom(Je)], ke = xe.range(ge(We), ie(Ie), ge(xt), ie(tt)), vt = xe.data, ir = [];
+                for (let ar of ke) {
+                  let vr = this.stride * ar;
+                  ir.push(vt[vr + re] > 1 ? Ce(vt, vr, this.clusterProps) : this.points[vt[vr + H]]);
+                }
+                return ir;
+              }
+              getChildren(Ge) {
+                let Je = this._getOriginId(Ge), We = this._getOriginZoom(Ge), tt = "No cluster with the specified id.", xt = this.trees[We];
+                if (!xt) throw new Error(tt);
+                let Ie = xt.data;
+                if (Je * this.stride >= Ie.length) throw new Error(tt);
+                let xe = this.options.radius / (this.options.extent * Math.pow(2, We - 1)), ke = xt.within(Ie[Je * this.stride], Ie[Je * this.stride + 1], xe), vt = [];
+                for (let ir of ke) {
+                  let ar = ir * this.stride;
+                  Ie[ar + 4] === Ge && vt.push(Ie[ar + re] > 1 ? Ce(Ie, ar, this.clusterProps) : this.points[Ie[ar + H]]);
+                }
+                if (vt.length === 0) throw new Error(tt);
+                return vt;
+              }
+              getLeaves(Ge, Je, We) {
+                let tt = [];
+                return this._appendLeaves(tt, Ge, Je = Je || 10, We = We || 0, 0), tt;
+              }
+              getTile(Ge, Je, We) {
+                let tt = this.trees[this._limitZoom(Ge)], xt = Math.pow(2, Ge), { extent: Ie, radius: xe } = this.options, ke = xe / Ie, vt = (We - ke) / xt, ir = (We + 1 + ke) / xt, ar = { features: [] };
+                return this._addTileFeatures(tt.range((Je - ke) / xt, vt, (Je + 1 + ke) / xt, ir), tt.data, Je, We, xt, ar), Je === 0 && this._addTileFeatures(tt.range(1 - ke / xt, vt, 1, ir), tt.data, xt, We, xt, ar), Je === xt - 1 && this._addTileFeatures(tt.range(0, vt, ke / xt, ir), tt.data, -1, We, xt, ar), ar.features.length ? ar : null;
+              }
+              getClusterExpansionZoom(Ge) {
+                let Je = this._getOriginZoom(Ge) - 1;
+                for (; Je <= this.options.maxZoom; ) {
+                  let We = this.getChildren(Ge);
+                  if (Je++, We.length !== 1) break;
+                  Ge = We[0].properties.cluster_id;
+                }
+                return Je;
+              }
+              _appendLeaves(Ge, Je, We, tt, xt) {
+                let Ie = this.getChildren(Je);
+                for (let xe of Ie) {
+                  let ke = xe.properties;
+                  if (ke && ke.cluster ? xt + ke.point_count <= tt ? xt += ke.point_count : xt = this._appendLeaves(Ge, ke.cluster_id, We, tt, xt) : xt < tt ? xt++ : Ge.push(xe), Ge.length === We) break;
+                }
+                return xt;
+              }
+              _createTree(Ge) {
+                let Je = new i.av(Ge.length / this.stride | 0, this.options.nodeSize, Float32Array);
+                for (let We = 0; We < Ge.length; We += this.stride) Je.add(Ge[We], Ge[We + 1]);
+                return Je.finish(), Je.data = Ge, Je;
+              }
+              _addTileFeatures(Ge, Je, We, tt, xt, Ie) {
+                for (let xe of Ge) {
+                  let ke = xe * this.stride, vt = Je[ke + re] > 1, ir, ar, vr;
+                  if (vt) ir = Le(Je, ke, this.clusterProps), ar = Je[ke], vr = Je[ke + 1];
+                  else {
+                    let $r = this.points[Je[ke + H]];
+                    ir = $r.properties;
+                    let [di, ji] = $r.geometry.coordinates;
+                    ar = ge(di), vr = ie(ji);
+                  }
+                  let ii = { type: 1, geometry: [[Math.round(this.options.extent * (ar * xt - We)), Math.round(this.options.extent * (vr * xt - tt))]], tags: ir }, pi;
+                  pi = vt || this.options.generateId ? Je[ke + H] : this.points[Je[ke + H]].id, pi !== void 0 && (ii.id = pi), Ie.features.push(ii);
+                }
+              }
+              _limitZoom(Ge) {
+                return Math.max(this.options.minZoom, Math.min(Math.floor(+Ge), this.options.maxZoom + 1));
+              }
+              _cluster(Ge, Je) {
+                let { radius: We, extent: tt, reduce: xt, minPoints: Ie } = this.options, xe = We / (tt * Math.pow(2, Je)), ke = Ge.data, vt = [], ir = this.stride;
+                for (let ar = 0; ar < ke.length; ar += ir) {
+                  if (ke[ar + 2] <= Je) continue;
+                  ke[ar + 2] = Je;
+                  let vr = ke[ar], ii = ke[ar + 1], pi = Ge.within(ke[ar], ke[ar + 1], xe), $r = ke[ar + re], di = $r;
+                  for (let ji of pi) {
+                    let In = ji * ir;
+                    ke[In + 2] > Je && (di += ke[In + re]);
+                  }
+                  if (di > $r && di >= Ie) {
+                    let ji, In = vr * $r, wi = ii * $r, On = -1, qn = ((ar / ir | 0) << 5) + (Je + 1) + this.points.length;
+                    for (let Fn of pi) {
+                      let ra = Fn * ir;
+                      if (ke[ra + 2] <= Je) continue;
+                      ke[ra + 2] = Je;
+                      let la = ke[ra + re];
+                      In += ke[ra] * la, wi += ke[ra + 1] * la, ke[ra + 4] = qn, xt && (ji || (ji = this._map(ke, ar, true), On = this.clusterProps.length, this.clusterProps.push(ji)), xt(ji, this._map(ke, ra)));
+                    }
+                    ke[ar + 4] = qn, vt.push(In / di, wi / di, 1 / 0, qn, -1, di), xt && vt.push(On);
+                  } else {
+                    for (let ji = 0; ji < ir; ji++) vt.push(ke[ar + ji]);
+                    if (di > 1) for (let ji of pi) {
+                      let In = ji * ir;
+                      if (!(ke[In + 2] <= Je)) {
+                        ke[In + 2] = Je;
+                        for (let wi = 0; wi < ir; wi++) vt.push(ke[In + wi]);
+                      }
+                    }
+                  }
+                }
+                return vt;
+              }
+              _getOriginId(Ge) {
+                return Ge - this.points.length >> 5;
+              }
+              _getOriginZoom(Ge) {
+                return (Ge - this.points.length) % 32;
+              }
+              _map(Ge, Je, We) {
+                if (Ge[Je + re] > 1) {
+                  let Ie = this.clusterProps[Ge[Je + oe]];
+                  return We ? Object.assign({}, Ie) : Ie;
+                }
+                let tt = this.points[Ge[Je + H]].properties, xt = this.options.map(tt);
+                return We && xt === tt ? Object.assign({}, xt) : xt;
+              }
+            }
+            function Ce(dt, Ge, Je) {
+              return { type: "Feature", id: dt[Ge + H], properties: Le(dt, Ge, Je), geometry: { type: "Point", coordinates: [(We = dt[Ge], 360 * (We - 0.5)), Se(dt[Ge + 1])] } };
+              var We;
+            }
+            function Le(dt, Ge, Je) {
+              let We = dt[Ge + re], tt = We >= 1e4 ? `${Math.round(We / 1e3)}k` : We >= 1e3 ? Math.round(We / 100) / 10 + "k" : We, xt = dt[Ge + oe], Ie = xt === -1 ? {} : Object.assign({}, Je[xt]);
+              return Object.assign(Ie, { cluster: true, cluster_id: dt[Ge + H], point_count: We, point_count_abbreviated: tt });
+            }
+            function ge(dt) {
+              return dt / 360 + 0.5;
+            }
+            function ie(dt) {
+              let Ge = Math.sin(dt * Math.PI / 180), Je = 0.5 - 0.25 * Math.log((1 + Ge) / (1 - Ge)) / Math.PI;
+              return Je < 0 ? 0 : Je > 1 ? 1 : Je;
+            }
+            function Se(dt) {
+              let Ge = (180 - 360 * dt) * Math.PI / 180;
+              return 360 * Math.atan(Math.exp(Ge)) / Math.PI - 90;
+            }
+            function Ee(dt, Ge, Je, We) {
+              let tt = We, xt = Ge + (Je - Ge >> 1), Ie, xe = Je - Ge, ke = dt[Ge], vt = dt[Ge + 1], ir = dt[Je], ar = dt[Je + 1];
+              for (let vr = Ge + 3; vr < Je; vr += 3) {
+                let ii = Ae(dt[vr], dt[vr + 1], ke, vt, ir, ar);
+                if (ii > tt) Ie = vr, tt = ii;
+                else if (ii === tt) {
+                  let pi = Math.abs(vr - xt);
+                  pi < xe && (Ie = vr, xe = pi);
+                }
+              }
+              tt > We && (Ie - Ge > 3 && Ee(dt, Ge, Ie, We), dt[Ie + 2] = tt, Je - Ie > 3 && Ee(dt, Ie, Je, We));
+            }
+            function Ae(dt, Ge, Je, We, tt, xt) {
+              let Ie = tt - Je, xe = xt - We;
+              if (Ie !== 0 || xe !== 0) {
+                let ke = ((dt - Je) * Ie + (Ge - We) * xe) / (Ie * Ie + xe * xe);
+                ke > 1 ? (Je = tt, We = xt) : ke > 0 && (Je += Ie * ke, We += xe * ke);
+              }
+              return Ie = dt - Je, xe = Ge - We, Ie * Ie + xe * xe;
+            }
+            function Be(dt, Ge, Je, We) {
+              let tt = { id: dt == null ? null : dt, type: Ge, geometry: Je, tags: We, minX: 1 / 0, minY: 1 / 0, maxX: -1 / 0, maxY: -1 / 0 };
+              if (Ge === "Point" || Ge === "MultiPoint" || Ge === "LineString") Pe(tt, Je);
+              else if (Ge === "Polygon") Pe(tt, Je[0]);
+              else if (Ge === "MultiLineString") for (let xt of Je) Pe(tt, xt);
+              else if (Ge === "MultiPolygon") for (let xt of Je) Pe(tt, xt[0]);
+              return tt;
+            }
+            function Pe(dt, Ge) {
+              for (let Je = 0; Je < Ge.length; Je += 3) dt.minX = Math.min(dt.minX, Ge[Je]), dt.minY = Math.min(dt.minY, Ge[Je + 1]), dt.maxX = Math.max(dt.maxX, Ge[Je]), dt.maxY = Math.max(dt.maxY, Ge[Je + 1]);
+            }
+            function me(dt, Ge, Je, We) {
+              if (!Ge.geometry) return;
+              let tt = Ge.geometry.coordinates;
+              if (tt && tt.length === 0) return;
+              let xt = Ge.geometry.type, Ie = Math.pow(Je.tolerance / ((1 << Je.maxZoom) * Je.extent), 2), xe = [], ke = Ge.id;
+              if (Je.promoteId ? ke = Ge.properties[Je.promoteId] : Je.generateId && (ke = We || 0), xt === "Point") De(tt, xe);
+              else if (xt === "MultiPoint") for (let vt of tt) De(vt, xe);
+              else if (xt === "LineString") ce(tt, xe, Ie, false);
+              else if (xt === "MultiLineString") {
+                if (Je.lineMetrics) {
+                  for (let vt of tt) xe = [], ce(vt, xe, Ie, false), dt.push(Be(ke, "LineString", xe, Ge.properties));
+                  return;
+                }
+                je(tt, xe, Ie, false);
+              } else if (xt === "Polygon") je(tt, xe, Ie, true);
+              else {
+                if (xt !== "MultiPolygon") {
+                  if (xt === "GeometryCollection") {
+                    for (let vt of Ge.geometry.geometries) me(dt, { id: ke, geometry: vt, properties: Ge.properties }, Je, We);
+                    return;
+                  }
+                  throw new Error("Input data is not a valid GeoJSON object.");
+                }
+                for (let vt of tt) {
+                  let ir = [];
+                  je(vt, ir, Ie, true), xe.push(ir);
+                }
+              }
+              dt.push(Be(ke, xt, xe, Ge.properties));
+            }
+            function De(dt, Ge) {
+              Ge.push(lt(dt[0]), pt(dt[1]), 0);
+            }
+            function ce(dt, Ge, Je, We) {
+              let tt, xt, Ie = 0;
+              for (let ke = 0; ke < dt.length; ke++) {
+                let vt = lt(dt[ke][0]), ir = pt(dt[ke][1]);
+                Ge.push(vt, ir, 0), ke > 0 && (Ie += We ? (tt * ir - vt * xt) / 2 : Math.sqrt(Math.pow(vt - tt, 2) + Math.pow(ir - xt, 2))), tt = vt, xt = ir;
+              }
+              let xe = Ge.length - 3;
+              Ge[2] = 1, Ee(Ge, 0, xe, Je), Ge[xe + 2] = 1, Ge.size = Math.abs(Ie), Ge.start = 0, Ge.end = Ge.size;
+            }
+            function je(dt, Ge, Je, We) {
+              for (let tt = 0; tt < dt.length; tt++) {
+                let xt = [];
+                ce(dt[tt], xt, Je, We), Ge.push(xt);
+              }
+            }
+            function lt(dt) {
+              return dt / 360 + 0.5;
+            }
+            function pt(dt) {
+              let Ge = Math.sin(dt * Math.PI / 180), Je = 0.5 - 0.25 * Math.log((1 + Ge) / (1 - Ge)) / Math.PI;
+              return Je < 0 ? 0 : Je > 1 ? 1 : Je;
+            }
+            function Vt(dt, Ge, Je, We, tt, xt, Ie, xe) {
+              if (We /= Ge, xt >= (Je /= Ge) && Ie < We) return dt;
+              if (Ie < Je || xt >= We) return null;
+              let ke = [];
+              for (let vt of dt) {
+                let ir = vt.geometry, ar = vt.type, vr = tt === 0 ? vt.minX : vt.minY, ii = tt === 0 ? vt.maxX : vt.maxY;
+                if (vr >= Je && ii < We) {
+                  ke.push(vt);
+                  continue;
+                }
+                if (ii < Je || vr >= We) continue;
+                let pi = [];
+                if (ar === "Point" || ar === "MultiPoint") ot(ir, pi, Je, We, tt);
+                else if (ar === "LineString") ut(ir, pi, Je, We, tt, false, xe.lineMetrics);
+                else if (ar === "MultiLineString") Nt(ir, pi, Je, We, tt, false);
+                else if (ar === "Polygon") Nt(ir, pi, Je, We, tt, true);
+                else if (ar === "MultiPolygon") for (let $r of ir) {
+                  let di = [];
+                  Nt($r, di, Je, We, tt, true), di.length && pi.push(di);
+                }
+                if (pi.length) {
+                  if (xe.lineMetrics && ar === "LineString") {
+                    for (let $r of pi) ke.push(Be(vt.id, ar, $r, vt.tags));
+                    continue;
+                  }
+                  ar !== "LineString" && ar !== "MultiLineString" || (pi.length === 1 ? (ar = "LineString", pi = pi[0]) : ar = "MultiLineString"), ar !== "Point" && ar !== "MultiPoint" || (ar = pi.length === 3 ? "Point" : "MultiPoint"), ke.push(Be(vt.id, ar, pi, vt.tags));
+                }
+              }
+              return ke.length ? ke : null;
+            }
+            function ot(dt, Ge, Je, We, tt) {
+              for (let xt = 0; xt < dt.length; xt += 3) {
+                let Ie = dt[xt + tt];
+                Ie >= Je && Ie <= We && $t(Ge, dt[xt], dt[xt + 1], dt[xt + 2]);
+              }
+            }
+            function ut(dt, Ge, Je, We, tt, xt, Ie) {
+              let xe = Wt(dt), ke = tt === 0 ? sr : Tr, vt, ir, ar = dt.start;
+              for (let di = 0; di < dt.length - 3; di += 3) {
+                let ji = dt[di], In = dt[di + 1], wi = dt[di + 2], On = dt[di + 3], qn = dt[di + 4], Fn = tt === 0 ? ji : In, ra = tt === 0 ? On : qn, la = false;
+                Ie && (vt = Math.sqrt(Math.pow(ji - On, 2) + Math.pow(In - qn, 2))), Fn < Je ? ra > Je && (ir = ke(xe, ji, In, On, qn, Je), Ie && (xe.start = ar + vt * ir)) : Fn > We ? ra < We && (ir = ke(xe, ji, In, On, qn, We), Ie && (xe.start = ar + vt * ir)) : $t(xe, ji, In, wi), ra < Je && Fn >= Je && (ir = ke(xe, ji, In, On, qn, Je), la = true), ra > We && Fn <= We && (ir = ke(xe, ji, In, On, qn, We), la = true), !xt && la && (Ie && (xe.end = ar + vt * ir), Ge.push(xe), xe = Wt(dt)), Ie && (ar += vt);
+              }
+              let vr = dt.length - 3, ii = dt[vr], pi = dt[vr + 1], $r = tt === 0 ? ii : pi;
+              $r >= Je && $r <= We && $t(xe, ii, pi, dt[vr + 2]), vr = xe.length - 3, xt && vr >= 3 && (xe[vr] !== xe[0] || xe[vr + 1] !== xe[1]) && $t(xe, xe[0], xe[1], xe[2]), xe.length && Ge.push(xe);
+            }
+            function Wt(dt) {
+              let Ge = [];
+              return Ge.size = dt.size, Ge.start = dt.start, Ge.end = dt.end, Ge;
+            }
+            function Nt(dt, Ge, Je, We, tt, xt) {
+              for (let Ie of dt) ut(Ie, Ge, Je, We, tt, xt, false);
+            }
+            function $t(dt, Ge, Je, We) {
+              dt.push(Ge, Je, We);
+            }
+            function sr(dt, Ge, Je, We, tt, xt) {
+              let Ie = (xt - Ge) / (We - Ge);
+              return $t(dt, xt, Je + (tt - Je) * Ie, 1), Ie;
+            }
+            function Tr(dt, Ge, Je, We, tt, xt) {
+              let Ie = (xt - Je) / (tt - Je);
+              return $t(dt, Ge + (We - Ge) * Ie, xt, 1), Ie;
+            }
+            function fr(dt, Ge) {
+              let Je = [];
+              for (let We = 0; We < dt.length; We++) {
+                let tt = dt[We], xt = tt.type, Ie;
+                if (xt === "Point" || xt === "MultiPoint" || xt === "LineString") Ie = $e(tt.geometry, Ge);
+                else if (xt === "MultiLineString" || xt === "Polygon") {
+                  Ie = [];
+                  for (let xe of tt.geometry) Ie.push($e(xe, Ge));
+                } else if (xt === "MultiPolygon") {
+                  Ie = [];
+                  for (let xe of tt.geometry) {
+                    let ke = [];
+                    for (let vt of xe) ke.push($e(vt, Ge));
+                    Ie.push(ke);
+                  }
+                }
+                Je.push(Be(tt.id, xt, Ie, tt.tags));
+              }
+              return Je;
+            }
+            function $e(dt, Ge) {
+              let Je = [];
+              Je.size = dt.size, dt.start !== void 0 && (Je.start = dt.start, Je.end = dt.end);
+              for (let We = 0; We < dt.length; We += 3) Je.push(dt[We] + Ge, dt[We + 1], dt[We + 2]);
+              return Je;
+            }
+            function St(dt, Ge) {
+              if (dt.transformed) return dt;
+              let Je = 1 << dt.z, We = dt.x, tt = dt.y;
+              for (let xt of dt.features) {
+                let Ie = xt.geometry, xe = xt.type;
+                if (xt.geometry = [], xe === 1) for (let ke = 0; ke < Ie.length; ke += 2) xt.geometry.push(Qt(Ie[ke], Ie[ke + 1], Ge, Je, We, tt));
+                else for (let ke = 0; ke < Ie.length; ke++) {
+                  let vt = [];
+                  for (let ir = 0; ir < Ie[ke].length; ir += 2) vt.push(Qt(Ie[ke][ir], Ie[ke][ir + 1], Ge, Je, We, tt));
+                  xt.geometry.push(vt);
+                }
+              }
+              return dt.transformed = true, dt;
+            }
+            function Qt(dt, Ge, Je, We, tt, xt) {
+              return [Math.round(Je * (dt * We - tt)), Math.round(Je * (Ge * We - xt))];
+            }
+            function Gt(dt, Ge, Je, We, tt) {
+              let xt = Ge === tt.maxZoom ? 0 : tt.tolerance / ((1 << Ge) * tt.extent), Ie = { features: [], numPoints: 0, numSimplified: 0, numFeatures: dt.length, source: null, x: Je, y: We, z: Ge, transformed: false, minX: 2, minY: 1, maxX: -1, maxY: 0 };
+              for (let xe of dt) _t(Ie, xe, xt, tt);
+              return Ie;
+            }
+            function _t(dt, Ge, Je, We) {
+              let tt = Ge.geometry, xt = Ge.type, Ie = [];
+              if (dt.minX = Math.min(dt.minX, Ge.minX), dt.minY = Math.min(dt.minY, Ge.minY), dt.maxX = Math.max(dt.maxX, Ge.maxX), dt.maxY = Math.max(dt.maxY, Ge.maxY), xt === "Point" || xt === "MultiPoint") for (let xe = 0; xe < tt.length; xe += 3) Ie.push(tt[xe], tt[xe + 1]), dt.numPoints++, dt.numSimplified++;
+              else if (xt === "LineString") It(Ie, tt, dt, Je, false, false);
+              else if (xt === "MultiLineString" || xt === "Polygon") for (let xe = 0; xe < tt.length; xe++) It(Ie, tt[xe], dt, Je, xt === "Polygon", xe === 0);
+              else if (xt === "MultiPolygon") for (let xe = 0; xe < tt.length; xe++) {
+                let ke = tt[xe];
+                for (let vt = 0; vt < ke.length; vt++) It(Ie, ke[vt], dt, Je, true, vt === 0);
+              }
+              if (Ie.length) {
+                let xe = Ge.tags || null;
+                if (xt === "LineString" && We.lineMetrics) {
+                  xe = {};
+                  for (let vt in Ge.tags) xe[vt] = Ge.tags[vt];
+                  xe.mapbox_clip_start = tt.start / tt.size, xe.mapbox_clip_end = tt.end / tt.size;
+                }
+                let ke = { geometry: Ie, type: xt === "Polygon" || xt === "MultiPolygon" ? 3 : xt === "LineString" || xt === "MultiLineString" ? 2 : 1, tags: xe };
+                Ge.id !== null && (ke.id = Ge.id), dt.features.push(ke);
+              }
+            }
+            function It(dt, Ge, Je, We, tt, xt) {
+              let Ie = We * We;
+              if (We > 0 && Ge.size < (tt ? Ie : We)) return void (Je.numPoints += Ge.length / 3);
+              let xe = [];
+              for (let ke = 0; ke < Ge.length; ke += 3) (We === 0 || Ge[ke + 2] > Ie) && (Je.numSimplified++, xe.push(Ge[ke], Ge[ke + 1])), Je.numPoints++;
+              tt && function(ke, vt) {
+                let ir = 0;
+                for (let ar = 0, vr = ke.length, ii = vr - 2; ar < vr; ii = ar, ar += 2) ir += (ke[ar] - ke[ii]) * (ke[ar + 1] + ke[ii + 1]);
+                if (ir > 0 === vt) for (let ar = 0, vr = ke.length; ar < vr / 2; ar += 2) {
+                  let ii = ke[ar], pi = ke[ar + 1];
+                  ke[ar] = ke[vr - 2 - ar], ke[ar + 1] = ke[vr - 1 - ar], ke[vr - 2 - ar] = ii, ke[vr - 1 - ar] = pi;
+                }
+              }(xe, xt), dt.push(xe);
+            }
+            let mt = { maxZoom: 14, indexMaxZoom: 5, indexMaxPoints: 1e5, tolerance: 3, extent: 4096, buffer: 64, lineMetrics: false, promoteId: null, generateId: false, debug: 0 };
+            class er {
+              constructor(Ge, Je) {
+                let We = (Je = this.options = function(xt, Ie) {
+                  for (let xe in Ie) xt[xe] = Ie[xe];
+                  return xt;
+                }(Object.create(mt), Je)).debug;
+                if (We && console.time("preprocess data"), Je.maxZoom < 0 || Je.maxZoom > 24) throw new Error("maxZoom should be in the 0-24 range");
+                if (Je.promoteId && Je.generateId) throw new Error("promoteId and generateId cannot be used together.");
+                let tt = function(xt, Ie) {
+                  let xe = [];
+                  if (xt.type === "FeatureCollection") for (let ke = 0; ke < xt.features.length; ke++) me(xe, xt.features[ke], Ie, ke);
+                  else me(xe, xt.type === "Feature" ? xt : { geometry: xt }, Ie);
+                  return xe;
+                }(Ge, Je);
+                this.tiles = {}, this.tileCoords = [], We && (console.timeEnd("preprocess data"), console.log("index: maxZoom: %d, maxPoints: %d", Je.indexMaxZoom, Je.indexMaxPoints), console.time("generate tiles"), this.stats = {}, this.total = 0), tt = function(xt, Ie) {
+                  let xe = Ie.buffer / Ie.extent, ke = xt, vt = Vt(xt, 1, -1 - xe, xe, 0, -1, 2, Ie), ir = Vt(xt, 1, 1 - xe, 2 + xe, 0, -1, 2, Ie);
+                  return (vt || ir) && (ke = Vt(xt, 1, -xe, 1 + xe, 0, -1, 2, Ie) || [], vt && (ke = fr(vt, 1).concat(ke)), ir && (ke = ke.concat(fr(ir, -1)))), ke;
+                }(tt, Je), tt.length && this.splitTile(tt, 0, 0, 0), We && (tt.length && console.log("features: %d, points: %d", this.tiles[0].numFeatures, this.tiles[0].numPoints), console.timeEnd("generate tiles"), console.log("tiles generated:", this.total, JSON.stringify(this.stats)));
+              }
+              splitTile(Ge, Je, We, tt, xt, Ie, xe) {
+                let ke = [Ge, Je, We, tt], vt = this.options, ir = vt.debug;
+                for (; ke.length; ) {
+                  tt = ke.pop(), We = ke.pop(), Je = ke.pop(), Ge = ke.pop();
+                  let ar = 1 << Je, vr = lr(Je, We, tt), ii = this.tiles[vr];
+                  if (!ii && (ir > 1 && console.time("creation"), ii = this.tiles[vr] = Gt(Ge, Je, We, tt, vt), this.tileCoords.push({ z: Je, x: We, y: tt }), ir)) {
+                    ir > 1 && (console.log("tile z%d-%d-%d (features: %d, points: %d, simplified: %d)", Je, We, tt, ii.numFeatures, ii.numPoints, ii.numSimplified), console.timeEnd("creation"));
+                    let la = `z${Je}`;
+                    this.stats[la] = (this.stats[la] || 0) + 1, this.total++;
+                  }
+                  if (ii.source = Ge, xt == null) {
+                    if (Je === vt.indexMaxZoom || ii.numPoints <= vt.indexMaxPoints) continue;
+                  } else {
+                    if (Je === vt.maxZoom || Je === xt) continue;
+                    if (xt != null) {
+                      let la = xt - Je;
+                      if (We !== Ie >> la || tt !== xe >> la) continue;
+                    }
+                  }
+                  if (ii.source = null, Ge.length === 0) continue;
+                  ir > 1 && console.time("clipping");
+                  let pi = 0.5 * vt.buffer / vt.extent, $r = 0.5 - pi, di = 0.5 + pi, ji = 1 + pi, In = null, wi = null, On = null, qn = null, Fn = Vt(Ge, ar, We - pi, We + di, 0, ii.minX, ii.maxX, vt), ra = Vt(Ge, ar, We + $r, We + ji, 0, ii.minX, ii.maxX, vt);
+                  Ge = null, Fn && (In = Vt(Fn, ar, tt - pi, tt + di, 1, ii.minY, ii.maxY, vt), wi = Vt(Fn, ar, tt + $r, tt + ji, 1, ii.minY, ii.maxY, vt), Fn = null), ra && (On = Vt(ra, ar, tt - pi, tt + di, 1, ii.minY, ii.maxY, vt), qn = Vt(ra, ar, tt + $r, tt + ji, 1, ii.minY, ii.maxY, vt), ra = null), ir > 1 && console.timeEnd("clipping"), ke.push(In || [], Je + 1, 2 * We, 2 * tt), ke.push(wi || [], Je + 1, 2 * We, 2 * tt + 1), ke.push(On || [], Je + 1, 2 * We + 1, 2 * tt), ke.push(qn || [], Je + 1, 2 * We + 1, 2 * tt + 1);
+                }
+              }
+              getTile(Ge, Je, We) {
+                Ge = +Ge, Je = +Je, We = +We;
+                let tt = this.options, { extent: xt, debug: Ie } = tt;
+                if (Ge < 0 || Ge > 24) return null;
+                let xe = 1 << Ge, ke = lr(Ge, Je = Je + xe & xe - 1, We);
+                if (this.tiles[ke]) return St(this.tiles[ke], xt);
+                Ie > 1 && console.log("drilling down to z%d-%d-%d", Ge, Je, We);
+                let vt, ir = Ge, ar = Je, vr = We;
+                for (; !vt && ir > 0; ) ir--, ar >>= 1, vr >>= 1, vt = this.tiles[lr(ir, ar, vr)];
+                return vt && vt.source ? (Ie > 1 && (console.log("found parent tile z%d-%d-%d", ir, ar, vr), console.time("drilling down")), this.splitTile(vt.source, ir, ar, vr, Ge, Je, We), Ie > 1 && console.timeEnd("drilling down"), this.tiles[ke] ? St(this.tiles[ke], xt) : null) : null;
+              }
+            }
+            function lr(dt, Ge, Je) {
+              return 32 * ((1 << dt) * Je + Ge) + dt;
+            }
+            function wr(dt, Ge) {
+              return Ge ? dt.properties[Ge] : dt.id;
+            }
+            function Lr(dt, Ge) {
+              if (dt == null) return true;
+              if (dt.type === "Feature") return wr(dt, Ge) != null;
+              if (dt.type === "FeatureCollection") {
+                let Je = /* @__PURE__ */ new Set();
+                for (let We of dt.features) {
+                  let tt = wr(We, Ge);
+                  if (tt == null || Je.has(tt)) return false;
+                  Je.add(tt);
+                }
+                return true;
+              }
+              return false;
+            }
+            function ti(dt, Ge) {
+              let Je = /* @__PURE__ */ new Map();
+              if (dt != null) if (dt.type === "Feature") Je.set(wr(dt, Ge), dt);
+              else for (let We of dt.features) Je.set(wr(We, Ge), We);
+              return Je;
+            }
+            class Br extends u {
+              constructor() {
+                super(...arguments), this._dataUpdateable = /* @__PURE__ */ new Map();
+              }
+              loadVectorTile(Ge, Je) {
+                return i._(this, void 0, void 0, function* () {
+                  let We = Ge.tileID.canonical;
+                  if (!this._geoJSONIndex) throw new Error("Unable to parse the data into a cluster or geojson");
+                  let tt = this._geoJSONIndex.getTile(We.z, We.x, We.y);
+                  if (!tt) return null;
+                  let xt = new class {
+                    constructor(xe) {
+                      this.layers = { _geojsonTileLayer: this }, this.name = "_geojsonTileLayer", this.extent = i.X, this.length = xe.length, this._features = xe;
+                    }
+                    feature(xe) {
+                      return new class {
+                        constructor(ke) {
+                          this._feature = ke, this.extent = i.X, this.type = ke.type, this.properties = ke.tags, "id" in ke && !isNaN(ke.id) && (this.id = parseInt(ke.id, 10));
+                        }
+                        loadGeometry() {
+                          if (this._feature.type === 1) {
+                            let ke = [];
+                            for (let vt of this._feature.geometry) ke.push([new i.P(vt[0], vt[1])]);
+                            return ke;
+                          }
+                          {
+                            let ke = [];
+                            for (let vt of this._feature.geometry) {
+                              let ir = [];
+                              for (let ar of vt) ir.push(new i.P(ar[0], ar[1]));
+                              ke.push(ir);
+                            }
+                            return ke;
+                          }
+                        }
+                        toGeoJSON(ke, vt, ir) {
+                          return v.call(this, ke, vt, ir);
+                        }
+                      }(this._features[xe]);
+                    }
+                  }(tt.features), Ie = G(xt);
+                  return Ie.byteOffset === 0 && Ie.byteLength === Ie.buffer.byteLength || (Ie = new Uint8Array(Ie)), { vectorTile: xt, rawData: Ie.buffer };
+                });
+              }
+              loadData(Ge) {
+                return i._(this, void 0, void 0, function* () {
+                  var Je;
+                  (Je = this._pendingRequest) === null || Je === void 0 || Je.abort();
+                  let We = !!(Ge && Ge.request && Ge.request.collectResourceTiming) && new i.bv(Ge.request);
+                  this._pendingRequest = new AbortController();
+                  try {
+                    this._pendingData = this.loadAndProcessGeoJSON(Ge, this._pendingRequest), this._geoJSONIndex = Ge.cluster ? new _e(function({ superclusterOptions: Ie, clusterProperties: xe }) {
+                      if (!xe || !Ie) return Ie;
+                      let ke = {}, vt = {}, ir = { accumulated: null, zoom: 0 }, ar = { properties: null }, vr = Object.keys(xe);
+                      for (let ii of vr) {
+                        let [pi, $r] = xe[ii], di = i.bC($r), ji = i.bC(typeof pi == "string" ? [pi, ["accumulated"], ["get", ii]] : pi);
+                        ke[ii] = di.value, vt[ii] = ji.value;
+                      }
+                      return Ie.map = (ii) => {
+                        ar.properties = ii;
+                        let pi = {};
+                        for (let $r of vr) pi[$r] = ke[$r].evaluate(ir, ar);
+                        return pi;
+                      }, Ie.reduce = (ii, pi) => {
+                        ar.properties = pi;
+                        for (let $r of vr) ir.accumulated = ii[$r], ii[$r] = vt[$r].evaluate(ir, ar);
+                      }, Ie;
+                    }(Ge)).load((yield this._pendingData).features) : (tt = yield this._pendingData, new er(tt, Ge.geojsonVtOptions)), this.loaded = {};
+                    let xt = {};
+                    if (We) {
+                      let Ie = We.finish();
+                      Ie && (xt.resourceTiming = {}, xt.resourceTiming[Ge.source] = JSON.parse(JSON.stringify(Ie)));
+                    }
+                    return xt;
+                  } catch (xt) {
+                    if (delete this._pendingRequest, i.bB(xt)) return { abandoned: true };
+                    throw xt;
+                  }
+                  var tt;
+                });
+              }
+              getData() {
+                return i._(this, void 0, void 0, function* () {
+                  return this._pendingData;
+                });
+              }
+              reloadTile(Ge) {
+                let Je = this.loaded;
+                return Je && Je[Ge.uid] ? super.reloadTile(Ge) : this.loadTile(Ge);
+              }
+              loadAndProcessGeoJSON(Ge, Je) {
+                return i._(this, void 0, void 0, function* () {
+                  let We = yield this.loadGeoJSON(Ge, Je);
+                  if (delete this._pendingRequest, typeof We != "object") throw new Error(`Input data given to '${Ge.source}' is not a valid GeoJSON object.`);
+                  if (d(We, true), Ge.filter) {
+                    let tt = i.bC(Ge.filter, { type: "boolean", "property-type": "data-driven", overridable: false, transition: false });
+                    if (tt.result === "error") throw new Error(tt.value.map((Ie) => `${Ie.key}: ${Ie.message}`).join(", "));
+                    We = { type: "FeatureCollection", features: We.features.filter((Ie) => tt.value.evaluate({ zoom: 0 }, Ie)) };
+                  }
+                  return We;
+                });
+              }
+              loadGeoJSON(Ge, Je) {
+                return i._(this, void 0, void 0, function* () {
+                  let { promoteId: We } = Ge;
+                  if (Ge.request) {
+                    let tt = yield i.h(Ge.request, Je);
+                    return this._dataUpdateable = Lr(tt.data, We) ? ti(tt.data, We) : void 0, tt.data;
+                  }
+                  if (typeof Ge.data == "string") try {
+                    let tt = JSON.parse(Ge.data);
+                    return this._dataUpdateable = Lr(tt, We) ? ti(tt, We) : void 0, tt;
+                  } catch (tt) {
+                    throw new Error(`Input data given to '${Ge.source}' is not a valid GeoJSON object.`);
+                  }
+                  if (!Ge.dataDiff) throw new Error(`Input data given to '${Ge.source}' is not a valid GeoJSON object.`);
+                  if (!this._dataUpdateable) throw new Error(`Cannot update existing geojson data in ${Ge.source}`);
+                  return function(tt, xt, Ie) {
+                    var xe, ke, vt, ir;
+                    if (xt.removeAll && tt.clear(), xt.remove) for (let ar of xt.remove) tt.delete(ar);
+                    if (xt.add) for (let ar of xt.add) {
+                      let vr = wr(ar, Ie);
+                      vr != null && tt.set(vr, ar);
+                    }
+                    if (xt.update) for (let ar of xt.update) {
+                      let vr = tt.get(ar.id);
+                      if (vr == null) continue;
+                      let ii = !ar.removeAllProperties && (((xe = ar.removeProperties) === null || xe === void 0 ? void 0 : xe.length) > 0 || ((ke = ar.addOrUpdateProperties) === null || ke === void 0 ? void 0 : ke.length) > 0);
+                      if ((ar.newGeometry || ar.removeAllProperties || ii) && (vr = Object.assign({}, vr), tt.set(ar.id, vr), ii && (vr.properties = Object.assign({}, vr.properties))), ar.newGeometry && (vr.geometry = ar.newGeometry), ar.removeAllProperties) vr.properties = {};
+                      else if (((vt = ar.removeProperties) === null || vt === void 0 ? void 0 : vt.length) > 0) for (let pi of ar.removeProperties) Object.prototype.hasOwnProperty.call(vr.properties, pi) && delete vr.properties[pi];
+                      if (((ir = ar.addOrUpdateProperties) === null || ir === void 0 ? void 0 : ir.length) > 0) for (let { key: pi, value: $r } of ar.addOrUpdateProperties) vr.properties[pi] = $r;
+                    }
+                  }(this._dataUpdateable, Ge.dataDiff, We), { type: "FeatureCollection", features: Array.from(this._dataUpdateable.values()) };
+                });
+              }
+              removeSource(Ge) {
+                return i._(this, void 0, void 0, function* () {
+                  this._pendingRequest && this._pendingRequest.abort();
+                });
+              }
+              getClusterExpansionZoom(Ge) {
+                return this._geoJSONIndex.getClusterExpansionZoom(Ge.clusterId);
+              }
+              getClusterChildren(Ge) {
+                return this._geoJSONIndex.getChildren(Ge.clusterId);
+              }
+              getClusterLeaves(Ge) {
+                return this._geoJSONIndex.getLeaves(Ge.clusterId, Ge.limit, Ge.offset);
+              }
+            }
+            class Vr {
+              constructor(Ge) {
+                this.self = Ge, this.actor = new i.F(Ge), this.layerIndexes = {}, this.availableImages = {}, this.workerSources = {}, this.demWorkerSources = {}, this.externalWorkerSourceTypes = {}, this.self.registerWorkerSource = (Je, We) => {
+                  if (this.externalWorkerSourceTypes[Je]) throw new Error(`Worker source with name "${Je}" already registered.`);
+                  this.externalWorkerSourceTypes[Je] = We;
+                }, this.self.addProtocol = i.bi, this.self.removeProtocol = i.bj, this.self.registerRTLTextPlugin = (Je) => {
+                  if (i.bD.isParsed()) throw new Error("RTL text plugin already registered.");
+                  i.bD.setMethods(Je);
+                }, this.actor.registerMessageHandler("LDT", (Je, We) => this._getDEMWorkerSource(Je, We.source).loadTile(We)), this.actor.registerMessageHandler("RDT", (Je, We) => i._(this, void 0, void 0, function* () {
+                  this._getDEMWorkerSource(Je, We.source).removeTile(We);
+                })), this.actor.registerMessageHandler("GCEZ", (Je, We) => i._(this, void 0, void 0, function* () {
+                  return this._getWorkerSource(Je, We.type, We.source).getClusterExpansionZoom(We);
+                })), this.actor.registerMessageHandler("GCC", (Je, We) => i._(this, void 0, void 0, function* () {
+                  return this._getWorkerSource(Je, We.type, We.source).getClusterChildren(We);
+                })), this.actor.registerMessageHandler("GCL", (Je, We) => i._(this, void 0, void 0, function* () {
+                  return this._getWorkerSource(Je, We.type, We.source).getClusterLeaves(We);
+                })), this.actor.registerMessageHandler("LD", (Je, We) => this._getWorkerSource(Je, We.type, We.source).loadData(We)), this.actor.registerMessageHandler("GD", (Je, We) => this._getWorkerSource(Je, We.type, We.source).getData()), this.actor.registerMessageHandler("LT", (Je, We) => this._getWorkerSource(Je, We.type, We.source).loadTile(We)), this.actor.registerMessageHandler("RT", (Je, We) => this._getWorkerSource(Je, We.type, We.source).reloadTile(We)), this.actor.registerMessageHandler("AT", (Je, We) => this._getWorkerSource(Je, We.type, We.source).abortTile(We)), this.actor.registerMessageHandler("RMT", (Je, We) => this._getWorkerSource(Je, We.type, We.source).removeTile(We)), this.actor.registerMessageHandler("RS", (Je, We) => i._(this, void 0, void 0, function* () {
+                  if (!this.workerSources[Je] || !this.workerSources[Je][We.type] || !this.workerSources[Je][We.type][We.source]) return;
+                  let tt = this.workerSources[Je][We.type][We.source];
+                  delete this.workerSources[Je][We.type][We.source], tt.removeSource !== void 0 && tt.removeSource(We);
+                })), this.actor.registerMessageHandler("RM", (Je) => i._(this, void 0, void 0, function* () {
+                  delete this.layerIndexes[Je], delete this.availableImages[Je], delete this.workerSources[Je], delete this.demWorkerSources[Je];
+                })), this.actor.registerMessageHandler("SR", (Je, We) => i._(this, void 0, void 0, function* () {
+                  this.referrer = We;
+                })), this.actor.registerMessageHandler("SRPS", (Je, We) => this._syncRTLPluginState(Je, We)), this.actor.registerMessageHandler("IS", (Je, We) => i._(this, void 0, void 0, function* () {
+                  this.self.importScripts(We);
+                })), this.actor.registerMessageHandler("SI", (Je, We) => this._setImages(Je, We)), this.actor.registerMessageHandler("UL", (Je, We) => i._(this, void 0, void 0, function* () {
+                  this._getLayerIndex(Je).update(We.layers, We.removedIds);
+                })), this.actor.registerMessageHandler("SL", (Je, We) => i._(this, void 0, void 0, function* () {
+                  this._getLayerIndex(Je).replace(We);
+                }));
+              }
+              _setImages(Ge, Je) {
+                return i._(this, void 0, void 0, function* () {
+                  this.availableImages[Ge] = Je;
+                  for (let We in this.workerSources[Ge]) {
+                    let tt = this.workerSources[Ge][We];
+                    for (let xt in tt) tt[xt].availableImages = Je;
+                  }
+                });
+              }
+              _syncRTLPluginState(Ge, Je) {
+                return i._(this, void 0, void 0, function* () {
+                  if (i.bD.isParsed()) return i.bD.getState();
+                  if (Je.pluginStatus !== "loading") return i.bD.setState(Je), Je;
+                  let We = Je.pluginURL;
+                  if (this.self.importScripts(We), i.bD.isParsed()) {
+                    let tt = { pluginStatus: "loaded", pluginURL: We };
+                    return i.bD.setState(tt), tt;
+                  }
+                  throw i.bD.setState({ pluginStatus: "error", pluginURL: "" }), new Error(`RTL Text Plugin failed to import scripts from ${We}`);
+                });
+              }
+              _getAvailableImages(Ge) {
+                let Je = this.availableImages[Ge];
+                return Je || (Je = []), Je;
+              }
+              _getLayerIndex(Ge) {
+                let Je = this.layerIndexes[Ge];
+                return Je || (Je = this.layerIndexes[Ge] = new a()), Je;
+              }
+              _getWorkerSource(Ge, Je, We) {
+                if (this.workerSources[Ge] || (this.workerSources[Ge] = {}), this.workerSources[Ge][Je] || (this.workerSources[Ge][Je] = {}), !this.workerSources[Ge][Je][We]) {
+                  let tt = { sendAsync: (xt, Ie) => (xt.targetMapId = Ge, this.actor.sendAsync(xt, Ie)) };
+                  switch (Je) {
+                    case "vector":
+                      this.workerSources[Ge][Je][We] = new u(tt, this._getLayerIndex(Ge), this._getAvailableImages(Ge));
+                      break;
+                    case "geojson":
+                      this.workerSources[Ge][Je][We] = new Br(tt, this._getLayerIndex(Ge), this._getAvailableImages(Ge));
+                      break;
+                    default:
+                      this.workerSources[Ge][Je][We] = new this.externalWorkerSourceTypes[Je](tt, this._getLayerIndex(Ge), this._getAvailableImages(Ge));
+                  }
+                }
+                return this.workerSources[Ge][Je][We];
+              }
+              _getDEMWorkerSource(Ge, Je) {
+                return this.demWorkerSources[Ge] || (this.demWorkerSources[Ge] = {}), this.demWorkerSources[Ge][Je] || (this.demWorkerSources[Ge][Je] = new c()), this.demWorkerSources[Ge][Je];
+              }
+            }
+            return i.i(self) && (self.worker = new Vr(self)), Vr;
+          }), r("index", ["exports", "./shared"], function(i, a) {
+            var o = "4.7.1";
+            let s, l, u = { now: typeof performance != "undefined" && performance && performance.now ? performance.now.bind(performance) : Date.now.bind(Date), frameAsync: (ue) => new Promise((w, B) => {
+              let Q = requestAnimationFrame(w);
+              ue.signal.addEventListener("abort", () => {
+                cancelAnimationFrame(Q), B(a.c());
+              });
+            }), getImageData(ue, w = 0) {
+              return this.getImageCanvasContext(ue).getImageData(-w, -w, ue.width + 2 * w, ue.height + 2 * w);
+            }, getImageCanvasContext(ue) {
+              let w = window.document.createElement("canvas"), B = w.getContext("2d", { willReadFrequently: true });
+              if (!B) throw new Error("failed to create canvas 2d context");
+              return w.width = ue.width, w.height = ue.height, B.drawImage(ue, 0, 0, ue.width, ue.height), B;
+            }, resolveURL: (ue) => (s || (s = document.createElement("a")), s.href = ue, s.href), hardwareConcurrency: typeof navigator != "undefined" && navigator.hardwareConcurrency || 4, get prefersReducedMotion() {
+              return !!matchMedia && (l == null && (l = matchMedia("(prefers-reduced-motion: reduce)")), l.matches);
+            } };
+            class c {
+              static testProp(w) {
+                if (!c.docStyle) return w[0];
+                for (let B = 0; B < w.length; B++) if (w[B] in c.docStyle) return w[B];
+                return w[0];
+              }
+              static create(w, B, Q) {
+                let ee = window.document.createElement(w);
+                return B !== void 0 && (ee.className = B), Q && Q.appendChild(ee), ee;
+              }
+              static createNS(w, B) {
+                return window.document.createElementNS(w, B);
+              }
+              static disableDrag() {
+                c.docStyle && c.selectProp && (c.userSelect = c.docStyle[c.selectProp], c.docStyle[c.selectProp] = "none");
+              }
+              static enableDrag() {
+                c.docStyle && c.selectProp && (c.docStyle[c.selectProp] = c.userSelect);
+              }
+              static setTransform(w, B) {
+                w.style[c.transformProp] = B;
+              }
+              static addEventListener(w, B, Q, ee = {}) {
+                w.addEventListener(B, Q, "passive" in ee ? ee : ee.capture);
+              }
+              static removeEventListener(w, B, Q, ee = {}) {
+                w.removeEventListener(B, Q, "passive" in ee ? ee : ee.capture);
+              }
+              static suppressClickInternal(w) {
+                w.preventDefault(), w.stopPropagation(), window.removeEventListener("click", c.suppressClickInternal, true);
+              }
+              static suppressClick() {
+                window.addEventListener("click", c.suppressClickInternal, true), window.setTimeout(() => {
+                  window.removeEventListener("click", c.suppressClickInternal, true);
+                }, 0);
+              }
+              static getScale(w) {
+                let B = w.getBoundingClientRect();
+                return { x: B.width / w.offsetWidth || 1, y: B.height / w.offsetHeight || 1, boundingClientRect: B };
+              }
+              static getPoint(w, B, Q) {
+                let ee = B.boundingClientRect;
+                return new a.P((Q.clientX - ee.left) / B.x - w.clientLeft, (Q.clientY - ee.top) / B.y - w.clientTop);
+              }
+              static mousePos(w, B) {
+                let Q = c.getScale(w);
+                return c.getPoint(w, Q, B);
+              }
+              static touchPos(w, B) {
+                let Q = [], ee = c.getScale(w);
+                for (let le = 0; le < B.length; le++) Q.push(c.getPoint(w, ee, B[le]));
+                return Q;
+              }
+              static mouseButton(w) {
+                return w.button;
+              }
+              static remove(w) {
+                w.parentNode && w.parentNode.removeChild(w);
+              }
+            }
+            c.docStyle = typeof window != "undefined" && window.document && window.document.documentElement.style, c.selectProp = c.testProp(["userSelect", "MozUserSelect", "WebkitUserSelect", "msUserSelect"]), c.transformProp = c.testProp(["transform", "WebkitTransform"]);
+            let f = { supported: false, testSupport: function(ue) {
+              !v && d && (_ ? b(ue) : h = ue);
+            } }, h, d, v = false, _ = false;
+            function b(ue) {
+              let w = ue.createTexture();
+              ue.bindTexture(ue.TEXTURE_2D, w);
+              try {
+                if (ue.texImage2D(ue.TEXTURE_2D, 0, ue.RGBA, ue.RGBA, ue.UNSIGNED_BYTE, d), ue.isContextLost()) return;
+                f.supported = true;
+              } catch (B) {
+              }
+              ue.deleteTexture(w), v = true;
+            }
+            var p;
+            typeof document != "undefined" && (d = document.createElement("img"), d.onload = () => {
+              h && b(h), h = null, _ = true;
+            }, d.onerror = () => {
+              v = true, h = null;
+            }, d.src = "data:image/webp;base64,UklGRh4AAABXRUJQVlA4TBEAAAAvAQAAAAfQ//73v/+BiOh/AAA="), function(ue) {
+              let w, B, Q, ee;
+              ue.resetRequestQueue = () => {
+                w = [], B = 0, Q = 0, ee = {};
+              }, ue.addThrottleControl = (st) => {
+                let Tt = Q++;
+                return ee[Tt] = st, Tt;
+              }, ue.removeThrottleControl = (st) => {
+                delete ee[st], Oe();
+              }, ue.getImage = (st, Tt, Yt = true) => new Promise((Kt, xr) => {
+                f.supported && (st.headers || (st.headers = {}), st.headers.accept = "image/webp,*/*"), a.e(st, { type: "image" }), w.push({ abortController: Tt, requestParameters: st, supportImageRefresh: Yt, state: "queued", onError: (Ir) => {
+                  xr(Ir);
+                }, onSuccess: (Ir) => {
+                  Kt(Ir);
+                } }), Oe();
+              });
+              let le = (st) => a._(this, void 0, void 0, function* () {
+                st.state = "running";
+                let { requestParameters: Tt, supportImageRefresh: Yt, onError: Kt, onSuccess: xr, abortController: Ir } = st, ve = Yt === false && !a.i(self) && !a.g(Tt.url) && (!Tt.headers || Object.keys(Tt.headers).reduce((qe, et) => qe && et === "accept", true));
+                B++;
+                let be = ve ? Ze(Tt, Ir) : a.m(Tt, Ir);
+                try {
+                  let qe = yield be;
+                  delete st.abortController, st.state = "completed", qe.data instanceof HTMLImageElement || a.b(qe.data) ? xr(qe) : qe.data && xr({ data: yield (Re = qe.data, typeof createImageBitmap == "function" ? a.d(Re) : a.f(Re)), cacheControl: qe.cacheControl, expires: qe.expires });
+                } catch (qe) {
+                  delete st.abortController, Kt(qe);
+                } finally {
+                  B--, Oe();
+                }
+                var Re;
+              }), Oe = () => {
+                let st = (() => {
+                  for (let Tt of Object.keys(ee)) if (ee[Tt]()) return true;
+                  return false;
+                })() ? a.a.MAX_PARALLEL_IMAGE_REQUESTS_PER_FRAME : a.a.MAX_PARALLEL_IMAGE_REQUESTS;
+                for (let Tt = B; Tt < st && w.length > 0; Tt++) {
+                  let Yt = w.shift();
+                  Yt.abortController.signal.aborted ? Tt-- : le(Yt);
+                }
+              }, Ze = (st, Tt) => new Promise((Yt, Kt) => {
+                let xr = new Image(), Ir = st.url, ve = st.credentials;
+                ve && ve === "include" ? xr.crossOrigin = "use-credentials" : (ve && ve === "same-origin" || !a.s(Ir)) && (xr.crossOrigin = "anonymous"), Tt.signal.addEventListener("abort", () => {
+                  xr.src = "", Kt(a.c());
+                }), xr.fetchPriority = "high", xr.onload = () => {
+                  xr.onerror = xr.onload = null, Yt({ data: xr });
+                }, xr.onerror = () => {
+                  xr.onerror = xr.onload = null, Tt.signal.aborted || Kt(new Error("Could not load image. Please make sure to use a supported image type such as PNG or JPEG. Note that SVGs are not supported."));
+                }, xr.src = Ir;
+              });
+            }(p || (p = {})), p.resetRequestQueue();
+            class k {
+              constructor(w) {
+                this._transformRequestFn = w;
+              }
+              transformRequest(w, B) {
+                return this._transformRequestFn && this._transformRequestFn(w, B) || { url: w };
+              }
+              setTransformRequest(w) {
+                this._transformRequestFn = w;
+              }
+            }
+            function E(ue) {
+              var w = new a.A(3);
+              return w[0] = ue[0], w[1] = ue[1], w[2] = ue[2], w;
+            }
+            var T, L = function(ue, w, B) {
+              return ue[0] = w[0] - B[0], ue[1] = w[1] - B[1], ue[2] = w[2] - B[2], ue;
+            };
+            T = new a.A(3), a.A != Float32Array && (T[0] = 0, T[1] = 0, T[2] = 0);
+            var x = function(ue) {
+              var w = ue[0], B = ue[1];
+              return w * w + B * B;
+            };
+            function C(ue) {
+              let w = [];
+              if (typeof ue == "string") w.push({ id: "default", url: ue });
+              else if (ue && ue.length > 0) {
+                let B = [];
+                for (let { id: Q, url: ee } of ue) {
+                  let le = `${Q}${ee}`;
+                  B.indexOf(le) === -1 && (B.push(le), w.push({ id: Q, url: ee }));
+                }
+              }
+              return w;
+            }
+            function M(ue, w, B) {
+              let Q = ue.split("?");
+              return Q[0] += `${w}${B}`, Q.join("?");
+            }
+            (function() {
+              var ue = new a.A(2);
+              a.A != Float32Array && (ue[0] = 0, ue[1] = 0);
+            })();
+            class g {
+              constructor(w, B, Q, ee) {
+                this.context = w, this.format = Q, this.texture = w.gl.createTexture(), this.update(B, ee);
+              }
+              update(w, B, Q) {
+                let { width: ee, height: le } = w, Oe = !(this.size && this.size[0] === ee && this.size[1] === le || Q), { context: Ze } = this, { gl: st } = Ze;
+                if (this.useMipmap = !!(B && B.useMipmap), st.bindTexture(st.TEXTURE_2D, this.texture), Ze.pixelStoreUnpackFlipY.set(false), Ze.pixelStoreUnpack.set(1), Ze.pixelStoreUnpackPremultiplyAlpha.set(this.format === st.RGBA && (!B || B.premultiply !== false)), Oe) this.size = [ee, le], w instanceof HTMLImageElement || w instanceof HTMLCanvasElement || w instanceof HTMLVideoElement || w instanceof ImageData || a.b(w) ? st.texImage2D(st.TEXTURE_2D, 0, this.format, this.format, st.UNSIGNED_BYTE, w) : st.texImage2D(st.TEXTURE_2D, 0, this.format, ee, le, 0, this.format, st.UNSIGNED_BYTE, w.data);
+                else {
+                  let { x: Tt, y: Yt } = Q || { x: 0, y: 0 };
+                  w instanceof HTMLImageElement || w instanceof HTMLCanvasElement || w instanceof HTMLVideoElement || w instanceof ImageData || a.b(w) ? st.texSubImage2D(st.TEXTURE_2D, 0, Tt, Yt, st.RGBA, st.UNSIGNED_BYTE, w) : st.texSubImage2D(st.TEXTURE_2D, 0, Tt, Yt, ee, le, st.RGBA, st.UNSIGNED_BYTE, w.data);
+                }
+                this.useMipmap && this.isSizePowerOfTwo() && st.generateMipmap(st.TEXTURE_2D);
+              }
+              bind(w, B, Q) {
+                let { context: ee } = this, { gl: le } = ee;
+                le.bindTexture(le.TEXTURE_2D, this.texture), Q !== le.LINEAR_MIPMAP_NEAREST || this.isSizePowerOfTwo() || (Q = le.LINEAR), w !== this.filter && (le.texParameteri(le.TEXTURE_2D, le.TEXTURE_MAG_FILTER, w), le.texParameteri(le.TEXTURE_2D, le.TEXTURE_MIN_FILTER, Q || w), this.filter = w), B !== this.wrap && (le.texParameteri(le.TEXTURE_2D, le.TEXTURE_WRAP_S, B), le.texParameteri(le.TEXTURE_2D, le.TEXTURE_WRAP_T, B), this.wrap = B);
+              }
+              isSizePowerOfTwo() {
+                return this.size[0] === this.size[1] && Math.log(this.size[0]) / Math.LN2 % 1 == 0;
+              }
+              destroy() {
+                let { gl: w } = this.context;
+                w.deleteTexture(this.texture), this.texture = null;
+              }
+            }
+            function P(ue) {
+              let { userImage: w } = ue;
+              return !!(w && w.render && w.render()) && (ue.data.replace(new Uint8Array(w.data.buffer)), true);
+            }
+            class A extends a.E {
+              constructor() {
+                super(), this.images = {}, this.updatedImages = {}, this.callbackDispatchedThisFrame = {}, this.loaded = false, this.requestors = [], this.patterns = {}, this.atlasImage = new a.R({ width: 1, height: 1 }), this.dirty = true;
+              }
+              isLoaded() {
+                return this.loaded;
+              }
+              setLoaded(w) {
+                if (this.loaded !== w && (this.loaded = w, w)) {
+                  for (let { ids: B, promiseResolve: Q } of this.requestors) Q(this._getImagesForIds(B));
+                  this.requestors = [];
+                }
+              }
+              getImage(w) {
+                let B = this.images[w];
+                if (B && !B.data && B.spriteData) {
+                  let Q = B.spriteData;
+                  B.data = new a.R({ width: Q.width, height: Q.height }, Q.context.getImageData(Q.x, Q.y, Q.width, Q.height).data), B.spriteData = null;
+                }
+                return B;
+              }
+              addImage(w, B) {
+                if (this.images[w]) throw new Error(`Image id ${w} already exist, use updateImage instead`);
+                this._validate(w, B) && (this.images[w] = B);
+              }
+              _validate(w, B) {
+                let Q = true, ee = B.data || B.spriteData;
+                return this._validateStretch(B.stretchX, ee && ee.width) || (this.fire(new a.j(new Error(`Image "${w}" has invalid "stretchX" value`))), Q = false), this._validateStretch(B.stretchY, ee && ee.height) || (this.fire(new a.j(new Error(`Image "${w}" has invalid "stretchY" value`))), Q = false), this._validateContent(B.content, B) || (this.fire(new a.j(new Error(`Image "${w}" has invalid "content" value`))), Q = false), Q;
+              }
+              _validateStretch(w, B) {
+                if (!w) return true;
+                let Q = 0;
+                for (let ee of w) {
+                  if (ee[0] < Q || ee[1] < ee[0] || B < ee[1]) return false;
+                  Q = ee[1];
+                }
+                return true;
+              }
+              _validateContent(w, B) {
+                if (!w) return true;
+                if (w.length !== 4) return false;
+                let Q = B.spriteData, ee = Q && Q.width || B.data.width, le = Q && Q.height || B.data.height;
+                return !(w[0] < 0 || ee < w[0] || w[1] < 0 || le < w[1] || w[2] < 0 || ee < w[2] || w[3] < 0 || le < w[3] || w[2] < w[0] || w[3] < w[1]);
+              }
+              updateImage(w, B, Q = true) {
+                let ee = this.getImage(w);
+                if (Q && (ee.data.width !== B.data.width || ee.data.height !== B.data.height)) throw new Error(`size mismatch between old image (${ee.data.width}x${ee.data.height}) and new image (${B.data.width}x${B.data.height}).`);
+                B.version = ee.version + 1, this.images[w] = B, this.updatedImages[w] = true;
+              }
+              removeImage(w) {
+                let B = this.images[w];
+                delete this.images[w], delete this.patterns[w], B.userImage && B.userImage.onRemove && B.userImage.onRemove();
+              }
+              listImages() {
+                return Object.keys(this.images);
+              }
+              getImages(w) {
+                return new Promise((B, Q) => {
+                  let ee = true;
+                  if (!this.isLoaded()) for (let le of w) this.images[le] || (ee = false);
+                  this.isLoaded() || ee ? B(this._getImagesForIds(w)) : this.requestors.push({ ids: w, promiseResolve: B });
+                });
+              }
+              _getImagesForIds(w) {
+                let B = {};
+                for (let Q of w) {
+                  let ee = this.getImage(Q);
+                  ee || (this.fire(new a.k("styleimagemissing", { id: Q })), ee = this.getImage(Q)), ee ? B[Q] = { data: ee.data.clone(), pixelRatio: ee.pixelRatio, sdf: ee.sdf, version: ee.version, stretchX: ee.stretchX, stretchY: ee.stretchY, content: ee.content, textFitWidth: ee.textFitWidth, textFitHeight: ee.textFitHeight, hasRenderCallback: !!(ee.userImage && ee.userImage.render) } : a.w(`Image "${Q}" could not be loaded. Please make sure you have added the image with map.addImage() or a "sprite" property in your style. You can provide missing images by listening for the "styleimagemissing" map event.`);
+                }
+                return B;
+              }
+              getPixelSize() {
+                let { width: w, height: B } = this.atlasImage;
+                return { width: w, height: B };
+              }
+              getPattern(w) {
+                let B = this.patterns[w], Q = this.getImage(w);
+                if (!Q) return null;
+                if (B && B.position.version === Q.version) return B.position;
+                if (B) B.position.version = Q.version;
+                else {
+                  let ee = { w: Q.data.width + 2, h: Q.data.height + 2, x: 0, y: 0 }, le = new a.I(ee, Q);
+                  this.patterns[w] = { bin: ee, position: le };
+                }
+                return this._updatePatternAtlas(), this.patterns[w].position;
+              }
+              bind(w) {
+                let B = w.gl;
+                this.atlasTexture ? this.dirty && (this.atlasTexture.update(this.atlasImage), this.dirty = false) : this.atlasTexture = new g(w, this.atlasImage, B.RGBA), this.atlasTexture.bind(B.LINEAR, B.CLAMP_TO_EDGE);
+              }
+              _updatePatternAtlas() {
+                let w = [];
+                for (let le in this.patterns) w.push(this.patterns[le].bin);
+                let { w: B, h: Q } = a.p(w), ee = this.atlasImage;
+                ee.resize({ width: B || 1, height: Q || 1 });
+                for (let le in this.patterns) {
+                  let { bin: Oe } = this.patterns[le], Ze = Oe.x + 1, st = Oe.y + 1, Tt = this.getImage(le).data, Yt = Tt.width, Kt = Tt.height;
+                  a.R.copy(Tt, ee, { x: 0, y: 0 }, { x: Ze, y: st }, { width: Yt, height: Kt }), a.R.copy(Tt, ee, { x: 0, y: Kt - 1 }, { x: Ze, y: st - 1 }, { width: Yt, height: 1 }), a.R.copy(Tt, ee, { x: 0, y: 0 }, { x: Ze, y: st + Kt }, { width: Yt, height: 1 }), a.R.copy(Tt, ee, { x: Yt - 1, y: 0 }, { x: Ze - 1, y: st }, { width: 1, height: Kt }), a.R.copy(Tt, ee, { x: 0, y: 0 }, { x: Ze + Yt, y: st }, { width: 1, height: Kt });
+                }
+                this.dirty = true;
+              }
+              beginFrame() {
+                this.callbackDispatchedThisFrame = {};
+              }
+              dispatchRenderCallbacks(w) {
+                for (let B of w) {
+                  if (this.callbackDispatchedThisFrame[B]) continue;
+                  this.callbackDispatchedThisFrame[B] = true;
+                  let Q = this.getImage(B);
+                  Q || a.w(`Image with ID: "${B}" was not found`), P(Q) && this.updateImage(B, Q);
+                }
+              }
+            }
+            let z = 1e20;
+            function O(ue, w, B, Q, ee, le, Oe, Ze, st) {
+              for (let Tt = w; Tt < w + Q; Tt++) U(ue, B * le + Tt, le, ee, Oe, Ze, st);
+              for (let Tt = B; Tt < B + ee; Tt++) U(ue, Tt * le + w, 1, Q, Oe, Ze, st);
+            }
+            function U(ue, w, B, Q, ee, le, Oe) {
+              le[0] = 0, Oe[0] = -1e20, Oe[1] = z, ee[0] = ue[w];
+              for (let Ze = 1, st = 0, Tt = 0; Ze < Q; Ze++) {
+                ee[Ze] = ue[w + Ze * B];
+                let Yt = Ze * Ze;
+                do {
+                  let Kt = le[st];
+                  Tt = (ee[Ze] - ee[Kt] + Yt - Kt * Kt) / (Ze - Kt) / 2;
+                } while (Tt <= Oe[st] && --st > -1);
+                st++, le[st] = Ze, Oe[st] = Tt, Oe[st + 1] = z;
+              }
+              for (let Ze = 0, st = 0; Ze < Q; Ze++) {
+                for (; Oe[st + 1] < Ze; ) st++;
+                let Tt = le[st], Yt = Ze - Tt;
+                ue[w + Ze * B] = ee[Tt] + Yt * Yt;
+              }
+            }
+            class G {
+              constructor(w, B) {
+                this.requestManager = w, this.localIdeographFontFamily = B, this.entries = {};
+              }
+              setURL(w) {
+                this.url = w;
+              }
+              getGlyphs(w) {
+                return a._(this, void 0, void 0, function* () {
+                  let B = [];
+                  for (let le in w) for (let Oe of w[le]) B.push(this._getAndCacheGlyphsPromise(le, Oe));
+                  let Q = yield Promise.all(B), ee = {};
+                  for (let { stack: le, id: Oe, glyph: Ze } of Q) ee[le] || (ee[le] = {}), ee[le][Oe] = Ze && { id: Ze.id, bitmap: Ze.bitmap.clone(), metrics: Ze.metrics };
+                  return ee;
+                });
+              }
+              _getAndCacheGlyphsPromise(w, B) {
+                return a._(this, void 0, void 0, function* () {
+                  let Q = this.entries[w];
+                  Q || (Q = this.entries[w] = { glyphs: {}, requests: {}, ranges: {} });
+                  let ee = Q.glyphs[B];
+                  if (ee !== void 0) return { stack: w, id: B, glyph: ee };
+                  if (ee = this._tinySDF(Q, w, B), ee) return Q.glyphs[B] = ee, { stack: w, id: B, glyph: ee };
+                  let le = Math.floor(B / 256);
+                  if (256 * le > 65535) throw new Error("glyphs > 65535 not supported");
+                  if (Q.ranges[le]) return { stack: w, id: B, glyph: ee };
+                  if (!this.url) throw new Error("glyphsUrl is not set");
+                  if (!Q.requests[le]) {
+                    let Ze = G.loadGlyphRange(w, le, this.url, this.requestManager);
+                    Q.requests[le] = Ze;
+                  }
+                  let Oe = yield Q.requests[le];
+                  for (let Ze in Oe) this._doesCharSupportLocalGlyph(+Ze) || (Q.glyphs[+Ze] = Oe[+Ze]);
+                  return Q.ranges[le] = true, { stack: w, id: B, glyph: Oe[B] || null };
+                });
+              }
+              _doesCharSupportLocalGlyph(w) {
+                return !!this.localIdeographFontFamily && new RegExp("\\p{Ideo}|\\p{sc=Hang}|\\p{sc=Hira}|\\p{sc=Kana}", "u").test(String.fromCodePoint(w));
+              }
+              _tinySDF(w, B, Q) {
+                let ee = this.localIdeographFontFamily;
+                if (!ee || !this._doesCharSupportLocalGlyph(Q)) return;
+                let le = w.tinySDF;
+                if (!le) {
+                  let Ze = "400";
+                  /bold/i.test(B) ? Ze = "900" : /medium/i.test(B) ? Ze = "500" : /light/i.test(B) && (Ze = "200"), le = w.tinySDF = new G.TinySDF({ fontSize: 48, buffer: 6, radius: 16, cutoff: 0.25, fontFamily: ee, fontWeight: Ze });
+                }
+                let Oe = le.draw(String.fromCharCode(Q));
+                return { id: Q, bitmap: new a.o({ width: Oe.width || 60, height: Oe.height || 60 }, Oe.data), metrics: { width: Oe.glyphWidth / 2 || 24, height: Oe.glyphHeight / 2 || 24, left: Oe.glyphLeft / 2 + 0.5 || 0, top: Oe.glyphTop / 2 - 27.5 || -8, advance: Oe.glyphAdvance / 2 || 24, isDoubleResolution: true } };
+              }
+            }
+            G.loadGlyphRange = function(ue, w, B, Q) {
+              return a._(this, void 0, void 0, function* () {
+                let ee = 256 * w, le = ee + 255, Oe = Q.transformRequest(B.replace("{fontstack}", ue).replace("{range}", `${ee}-${le}`), "Glyphs"), Ze = yield a.l(Oe, new AbortController());
+                if (!Ze || !Ze.data) throw new Error(`Could not load glyph range. range: ${w}, ${ee}-${le}`);
+                let st = {};
+                for (let Tt of a.n(Ze.data)) st[Tt.id] = Tt;
+                return st;
+              });
+            }, G.TinySDF = class {
+              constructor({ fontSize: ue = 24, buffer: w = 3, radius: B = 8, cutoff: Q = 0.25, fontFamily: ee = "sans-serif", fontWeight: le = "normal", fontStyle: Oe = "normal" } = {}) {
+                this.buffer = w, this.cutoff = Q, this.radius = B;
+                let Ze = this.size = ue + 4 * w, st = this._createCanvas(Ze), Tt = this.ctx = st.getContext("2d", { willReadFrequently: true });
+                Tt.font = `${Oe} ${le} ${ue}px ${ee}`, Tt.textBaseline = "alphabetic", Tt.textAlign = "left", Tt.fillStyle = "black", this.gridOuter = new Float64Array(Ze * Ze), this.gridInner = new Float64Array(Ze * Ze), this.f = new Float64Array(Ze), this.z = new Float64Array(Ze + 1), this.v = new Uint16Array(Ze);
+              }
+              _createCanvas(ue) {
+                let w = document.createElement("canvas");
+                return w.width = w.height = ue, w;
+              }
+              draw(ue) {
+                let { width: w, actualBoundingBoxAscent: B, actualBoundingBoxDescent: Q, actualBoundingBoxLeft: ee, actualBoundingBoxRight: le } = this.ctx.measureText(ue), Oe = Math.ceil(B), Ze = Math.max(0, Math.min(this.size - this.buffer, Math.ceil(le - ee))), st = Math.min(this.size - this.buffer, Oe + Math.ceil(Q)), Tt = Ze + 2 * this.buffer, Yt = st + 2 * this.buffer, Kt = Math.max(Tt * Yt, 0), xr = new Uint8ClampedArray(Kt), Ir = { data: xr, width: Tt, height: Yt, glyphWidth: Ze, glyphHeight: st, glyphTop: Oe, glyphLeft: 0, glyphAdvance: w };
+                if (Ze === 0 || st === 0) return Ir;
+                let { ctx: ve, buffer: be, gridInner: Re, gridOuter: qe } = this;
+                ve.clearRect(be, be, Ze, st), ve.fillText(ue, be, be + Oe);
+                let et = ve.getImageData(be, be, Ze, st);
+                qe.fill(z, 0, Kt), Re.fill(0, 0, Kt);
+                for (let Xe = 0; Xe < st; Xe++) for (let it = 0; it < Ze; it++) {
+                  let Ft = et.data[4 * (Xe * Ze + it) + 3] / 255;
+                  if (Ft === 0) continue;
+                  let Ht = (Xe + be) * Tt + it + be;
+                  if (Ft === 1) qe[Ht] = 0, Re[Ht] = z;
+                  else {
+                    let tr = 0.5 - Ft;
+                    qe[Ht] = tr > 0 ? tr * tr : 0, Re[Ht] = tr < 0 ? tr * tr : 0;
+                  }
+                }
+                O(qe, 0, 0, Tt, Yt, Tt, this.f, this.v, this.z), O(Re, be, be, Ze, st, Tt, this.f, this.v, this.z);
+                for (let Xe = 0; Xe < Kt; Xe++) {
+                  let it = Math.sqrt(qe[Xe]) - Math.sqrt(Re[Xe]);
+                  xr[Xe] = Math.round(255 - 255 * (it / this.radius + this.cutoff));
+                }
+                return Ir;
+              }
+            };
+            class Z {
+              constructor() {
+                this.specification = a.v.light.position;
+              }
+              possiblyEvaluate(w, B) {
+                return a.x(w.expression.evaluate(B));
+              }
+              interpolate(w, B, Q) {
+                return { x: a.y.number(w.x, B.x, Q), y: a.y.number(w.y, B.y, Q), z: a.y.number(w.z, B.z, Q) };
+              }
+            }
+            let j;
+            class N extends a.E {
+              constructor(w) {
+                super(), j = j || new a.q({ anchor: new a.D(a.v.light.anchor), position: new Z(), color: new a.D(a.v.light.color), intensity: new a.D(a.v.light.intensity) }), this._transitionable = new a.T(j), this.setLight(w), this._transitioning = this._transitionable.untransitioned();
+              }
+              getLight() {
+                return this._transitionable.serialize();
+              }
+              setLight(w, B = {}) {
+                if (!this._validate(a.r, w, B)) for (let Q in w) {
+                  let ee = w[Q];
+                  Q.endsWith("-transition") ? this._transitionable.setTransition(Q.slice(0, -11), ee) : this._transitionable.setValue(Q, ee);
+                }
+              }
+              updateTransitions(w) {
+                this._transitioning = this._transitionable.transitioned(w, this._transitioning);
+              }
+              hasTransition() {
+                return this._transitioning.hasTransition();
+              }
+              recalculate(w) {
+                this.properties = this._transitioning.possiblyEvaluate(w);
+              }
+              _validate(w, B, Q) {
+                return (!Q || Q.validate !== false) && a.t(this, w.call(a.u, { value: B, style: { glyphs: true, sprite: true }, styleSpec: a.v }));
+              }
+            }
+            let H = new a.q({ "sky-color": new a.D(a.v.sky["sky-color"]), "horizon-color": new a.D(a.v.sky["horizon-color"]), "fog-color": new a.D(a.v.sky["fog-color"]), "fog-ground-blend": new a.D(a.v.sky["fog-ground-blend"]), "horizon-fog-blend": new a.D(a.v.sky["horizon-fog-blend"]), "sky-horizon-blend": new a.D(a.v.sky["sky-horizon-blend"]), "atmosphere-blend": new a.D(a.v.sky["atmosphere-blend"]) });
+            class re extends a.E {
+              constructor(w) {
+                super(), this._transitionable = new a.T(H), this.setSky(w), this._transitioning = this._transitionable.untransitioned(), this.recalculate(new a.z(0));
+              }
+              setSky(w, B = {}) {
+                if (!this._validate(a.B, w, B)) {
+                  w || (w = { "sky-color": "transparent", "horizon-color": "transparent", "fog-color": "transparent", "fog-ground-blend": 1, "atmosphere-blend": 0 });
+                  for (let Q in w) {
+                    let ee = w[Q];
+                    Q.endsWith("-transition") ? this._transitionable.setTransition(Q.slice(0, -11), ee) : this._transitionable.setValue(Q, ee);
+                  }
+                }
+              }
+              getSky() {
+                return this._transitionable.serialize();
+              }
+              updateTransitions(w) {
+                this._transitioning = this._transitionable.transitioned(w, this._transitioning);
+              }
+              hasTransition() {
+                return this._transitioning.hasTransition();
+              }
+              recalculate(w) {
+                this.properties = this._transitioning.possiblyEvaluate(w);
+              }
+              _validate(w, B, Q = {}) {
+                return (Q == null ? void 0 : Q.validate) !== false && a.t(this, w.call(a.u, a.e({ value: B, style: { glyphs: true, sprite: true }, styleSpec: a.v })));
+              }
+              calculateFogBlendOpacity(w) {
+                return w < 60 ? 0 : w < 70 ? (w - 60) / 10 : 1;
+              }
+            }
+            class oe {
+              constructor(w, B) {
+                this.width = w, this.height = B, this.nextRow = 0, this.data = new Uint8Array(this.width * this.height), this.dashEntry = {};
+              }
+              getDash(w, B) {
+                let Q = w.join(",") + String(B);
+                return this.dashEntry[Q] || (this.dashEntry[Q] = this.addDash(w, B)), this.dashEntry[Q];
+              }
+              getDashRanges(w, B, Q) {
+                let ee = [], le = w.length % 2 == 1 ? -w[w.length - 1] * Q : 0, Oe = w[0] * Q, Ze = true;
+                ee.push({ left: le, right: Oe, isDash: Ze, zeroLength: w[0] === 0 });
+                let st = w[0];
+                for (let Tt = 1; Tt < w.length; Tt++) {
+                  Ze = !Ze;
+                  let Yt = w[Tt];
+                  le = st * Q, st += Yt, Oe = st * Q, ee.push({ left: le, right: Oe, isDash: Ze, zeroLength: Yt === 0 });
+                }
+                return ee;
+              }
+              addRoundDash(w, B, Q) {
+                let ee = B / 2;
+                for (let le = -Q; le <= Q; le++) {
+                  let Oe = this.width * (this.nextRow + Q + le), Ze = 0, st = w[Ze];
+                  for (let Tt = 0; Tt < this.width; Tt++) {
+                    Tt / st.right > 1 && (st = w[++Ze]);
+                    let Yt = Math.abs(Tt - st.left), Kt = Math.abs(Tt - st.right), xr = Math.min(Yt, Kt), Ir, ve = le / Q * (ee + 1);
+                    if (st.isDash) {
+                      let be = ee - Math.abs(ve);
+                      Ir = Math.sqrt(xr * xr + be * be);
+                    } else Ir = ee - Math.sqrt(xr * xr + ve * ve);
+                    this.data[Oe + Tt] = Math.max(0, Math.min(255, Ir + 128));
+                  }
+                }
+              }
+              addRegularDash(w) {
+                for (let Ze = w.length - 1; Ze >= 0; --Ze) {
+                  let st = w[Ze], Tt = w[Ze + 1];
+                  st.zeroLength ? w.splice(Ze, 1) : Tt && Tt.isDash === st.isDash && (Tt.left = st.left, w.splice(Ze, 1));
+                }
+                let B = w[0], Q = w[w.length - 1];
+                B.isDash === Q.isDash && (B.left = Q.left - this.width, Q.right = B.right + this.width);
+                let ee = this.width * this.nextRow, le = 0, Oe = w[le];
+                for (let Ze = 0; Ze < this.width; Ze++) {
+                  Ze / Oe.right > 1 && (Oe = w[++le]);
+                  let st = Math.abs(Ze - Oe.left), Tt = Math.abs(Ze - Oe.right), Yt = Math.min(st, Tt);
+                  this.data[ee + Ze] = Math.max(0, Math.min(255, (Oe.isDash ? Yt : -Yt) + 128));
+                }
+              }
+              addDash(w, B) {
+                let Q = B ? 7 : 0, ee = 2 * Q + 1;
+                if (this.nextRow + ee > this.height) return a.w("LineAtlas out of space"), null;
+                let le = 0;
+                for (let Ze = 0; Ze < w.length; Ze++) le += w[Ze];
+                if (le !== 0) {
+                  let Ze = this.width / le, st = this.getDashRanges(w, this.width, Ze);
+                  B ? this.addRoundDash(st, Ze, Q) : this.addRegularDash(st);
+                }
+                let Oe = { y: (this.nextRow + Q + 0.5) / this.height, height: 2 * Q / this.height, width: le };
+                return this.nextRow += ee, this.dirty = true, Oe;
+              }
+              bind(w) {
+                let B = w.gl;
+                this.texture ? (B.bindTexture(B.TEXTURE_2D, this.texture), this.dirty && (this.dirty = false, B.texSubImage2D(B.TEXTURE_2D, 0, 0, 0, this.width, this.height, B.ALPHA, B.UNSIGNED_BYTE, this.data))) : (this.texture = B.createTexture(), B.bindTexture(B.TEXTURE_2D, this.texture), B.texParameteri(B.TEXTURE_2D, B.TEXTURE_WRAP_S, B.REPEAT), B.texParameteri(B.TEXTURE_2D, B.TEXTURE_WRAP_T, B.REPEAT), B.texParameteri(B.TEXTURE_2D, B.TEXTURE_MIN_FILTER, B.LINEAR), B.texParameteri(B.TEXTURE_2D, B.TEXTURE_MAG_FILTER, B.LINEAR), B.texImage2D(B.TEXTURE_2D, 0, B.ALPHA, this.width, this.height, 0, B.ALPHA, B.UNSIGNED_BYTE, this.data));
+              }
+            }
+            let _e = "maplibre_preloaded_worker_pool";
+            class Ce {
+              constructor() {
+                this.active = {};
+              }
+              acquire(w) {
+                if (!this.workers) for (this.workers = []; this.workers.length < Ce.workerCount; ) this.workers.push(new Worker(a.a.WORKER_URL));
+                return this.active[w] = true, this.workers.slice();
+              }
+              release(w) {
+                delete this.active[w], this.numActive() === 0 && (this.workers.forEach((B) => {
+                  B.terminate();
+                }), this.workers = null);
+              }
+              isPreloaded() {
+                return !!this.active[_e];
+              }
+              numActive() {
+                return Object.keys(this.active).length;
+              }
+            }
+            let Le = Math.floor(u.hardwareConcurrency / 2), ge, ie;
+            function Se() {
+              return ge || (ge = new Ce()), ge;
+            }
+            Ce.workerCount = a.C(globalThis) ? Math.max(Math.min(Le, 3), 1) : 1;
+            class Ee {
+              constructor(w, B) {
+                this.workerPool = w, this.actors = [], this.currentActor = 0, this.id = B;
+                let Q = this.workerPool.acquire(B);
+                for (let ee = 0; ee < Q.length; ee++) {
+                  let le = new a.F(Q[ee], B);
+                  le.name = `Worker ${ee}`, this.actors.push(le);
+                }
+                if (!this.actors.length) throw new Error("No actors found");
+              }
+              broadcast(w, B) {
+                let Q = [];
+                for (let ee of this.actors) Q.push(ee.sendAsync({ type: w, data: B }));
+                return Promise.all(Q);
+              }
+              getActor() {
+                return this.currentActor = (this.currentActor + 1) % this.actors.length, this.actors[this.currentActor];
+              }
+              remove(w = true) {
+                this.actors.forEach((B) => {
+                  B.remove();
+                }), this.actors = [], w && this.workerPool.release(this.id);
+              }
+              registerMessageHandler(w, B) {
+                for (let Q of this.actors) Q.registerMessageHandler(w, B);
+              }
+            }
+            function Ae() {
+              return ie || (ie = new Ee(Se(), a.G), ie.registerMessageHandler("GR", (ue, w, B) => a.m(w, B))), ie;
+            }
+            function Be(ue, w) {
+              let B = a.H();
+              return a.J(B, B, [1, 1, 0]), a.K(B, B, [0.5 * ue.width, 0.5 * ue.height, 1]), a.L(B, B, ue.calculatePosMatrix(w.toUnwrapped()));
+            }
+            function Pe(ue, w, B, Q, ee, le) {
+              let Oe = function(Kt, xr, Ir) {
+                if (Kt) for (let ve of Kt) {
+                  let be = xr[ve];
+                  if (be && be.source === Ir && be.type === "fill-extrusion") return true;
+                }
+                else for (let ve in xr) {
+                  let be = xr[ve];
+                  if (be.source === Ir && be.type === "fill-extrusion") return true;
+                }
+                return false;
+              }(ee && ee.layers, w, ue.id), Ze = le.maxPitchScaleFactor(), st = ue.tilesIn(Q, Ze, Oe);
+              st.sort(me);
+              let Tt = [];
+              for (let Kt of st) Tt.push({ wrappedTileID: Kt.tileID.wrapped().key, queryResults: Kt.tile.queryRenderedFeatures(w, B, ue._state, Kt.queryGeometry, Kt.cameraQueryGeometry, Kt.scale, ee, le, Ze, Be(ue.transform, Kt.tileID)) });
+              let Yt = function(Kt) {
+                let xr = {}, Ir = {};
+                for (let ve of Kt) {
+                  let be = ve.queryResults, Re = ve.wrappedTileID, qe = Ir[Re] = Ir[Re] || {};
+                  for (let et in be) {
+                    let Xe = be[et], it = qe[et] = qe[et] || {}, Ft = xr[et] = xr[et] || [];
+                    for (let Ht of Xe) it[Ht.featureIndex] || (it[Ht.featureIndex] = true, Ft.push(Ht));
+                  }
+                }
+                return xr;
+              }(Tt);
+              for (let Kt in Yt) Yt[Kt].forEach((xr) => {
+                let Ir = xr.feature, ve = ue.getFeatureState(Ir.layer["source-layer"], Ir.id);
+                Ir.source = Ir.layer.source, Ir.layer["source-layer"] && (Ir.sourceLayer = Ir.layer["source-layer"]), Ir.state = ve;
+              });
+              return Yt;
+            }
+            function me(ue, w) {
+              let B = ue.tileID, Q = w.tileID;
+              return B.overscaledZ - Q.overscaledZ || B.canonical.y - Q.canonical.y || B.wrap - Q.wrap || B.canonical.x - Q.canonical.x;
+            }
+            function De(ue, w, B) {
+              return a._(this, void 0, void 0, function* () {
+                let Q = ue;
+                if (ue.url ? Q = (yield a.h(w.transformRequest(ue.url, "Source"), B)).data : yield u.frameAsync(B), !Q) return null;
+                let ee = a.M(a.e(Q, ue), ["tiles", "minzoom", "maxzoom", "attribution", "bounds", "scheme", "tileSize", "encoding"]);
+                return "vector_layers" in Q && Q.vector_layers && (ee.vectorLayerIds = Q.vector_layers.map((le) => le.id)), ee;
+              });
+            }
+            class ce {
+              constructor(w, B) {
+                w && (B ? this.setSouthWest(w).setNorthEast(B) : Array.isArray(w) && (w.length === 4 ? this.setSouthWest([w[0], w[1]]).setNorthEast([w[2], w[3]]) : this.setSouthWest(w[0]).setNorthEast(w[1])));
+              }
+              setNorthEast(w) {
+                return this._ne = w instanceof a.N ? new a.N(w.lng, w.lat) : a.N.convert(w), this;
+              }
+              setSouthWest(w) {
+                return this._sw = w instanceof a.N ? new a.N(w.lng, w.lat) : a.N.convert(w), this;
+              }
+              extend(w) {
+                let B = this._sw, Q = this._ne, ee, le;
+                if (w instanceof a.N) ee = w, le = w;
+                else {
+                  if (!(w instanceof ce)) return Array.isArray(w) ? w.length === 4 || w.every(Array.isArray) ? this.extend(ce.convert(w)) : this.extend(a.N.convert(w)) : w && ("lng" in w || "lon" in w) && "lat" in w ? this.extend(a.N.convert(w)) : this;
+                  if (ee = w._sw, le = w._ne, !ee || !le) return this;
+                }
+                return B || Q ? (B.lng = Math.min(ee.lng, B.lng), B.lat = Math.min(ee.lat, B.lat), Q.lng = Math.max(le.lng, Q.lng), Q.lat = Math.max(le.lat, Q.lat)) : (this._sw = new a.N(ee.lng, ee.lat), this._ne = new a.N(le.lng, le.lat)), this;
+              }
+              getCenter() {
+                return new a.N((this._sw.lng + this._ne.lng) / 2, (this._sw.lat + this._ne.lat) / 2);
+              }
+              getSouthWest() {
+                return this._sw;
+              }
+              getNorthEast() {
+                return this._ne;
+              }
+              getNorthWest() {
+                return new a.N(this.getWest(), this.getNorth());
+              }
+              getSouthEast() {
+                return new a.N(this.getEast(), this.getSouth());
+              }
+              getWest() {
+                return this._sw.lng;
+              }
+              getSouth() {
+                return this._sw.lat;
+              }
+              getEast() {
+                return this._ne.lng;
+              }
+              getNorth() {
+                return this._ne.lat;
+              }
+              toArray() {
+                return [this._sw.toArray(), this._ne.toArray()];
+              }
+              toString() {
+                return `LngLatBounds(${this._sw.toString()}, ${this._ne.toString()})`;
+              }
+              isEmpty() {
+                return !(this._sw && this._ne);
+              }
+              contains(w) {
+                let { lng: B, lat: Q } = a.N.convert(w), ee = this._sw.lng <= B && B <= this._ne.lng;
+                return this._sw.lng > this._ne.lng && (ee = this._sw.lng >= B && B >= this._ne.lng), this._sw.lat <= Q && Q <= this._ne.lat && ee;
+              }
+              static convert(w) {
+                return w instanceof ce ? w : w && new ce(w);
+              }
+              static fromLngLat(w, B = 0) {
+                let Q = 360 * B / 40075017, ee = Q / Math.cos(Math.PI / 180 * w.lat);
+                return new ce(new a.N(w.lng - ee, w.lat - Q), new a.N(w.lng + ee, w.lat + Q));
+              }
+              adjustAntiMeridian() {
+                let w = new a.N(this._sw.lng, this._sw.lat), B = new a.N(this._ne.lng, this._ne.lat);
+                return new ce(w, w.lng > B.lng ? new a.N(B.lng + 360, B.lat) : B);
+              }
+            }
+            class je {
+              constructor(w, B, Q) {
+                this.bounds = ce.convert(this.validateBounds(w)), this.minzoom = B || 0, this.maxzoom = Q || 24;
+              }
+              validateBounds(w) {
+                return Array.isArray(w) && w.length === 4 ? [Math.max(-180, w[0]), Math.max(-90, w[1]), Math.min(180, w[2]), Math.min(90, w[3])] : [-180, -90, 180, 90];
+              }
+              contains(w) {
+                let B = Math.pow(2, w.z), Q = Math.floor(a.O(this.bounds.getWest()) * B), ee = Math.floor(a.Q(this.bounds.getNorth()) * B), le = Math.ceil(a.O(this.bounds.getEast()) * B), Oe = Math.ceil(a.Q(this.bounds.getSouth()) * B);
+                return w.x >= Q && w.x < le && w.y >= ee && w.y < Oe;
+              }
+            }
+            class lt extends a.E {
+              constructor(w, B, Q, ee) {
+                if (super(), this.id = w, this.dispatcher = Q, this.type = "vector", this.minzoom = 0, this.maxzoom = 22, this.scheme = "xyz", this.tileSize = 512, this.reparseOverscaled = true, this.isTileClipped = true, this._loaded = false, a.e(this, a.M(B, ["url", "scheme", "tileSize", "promoteId"])), this._options = a.e({ type: "vector" }, B), this._collectResourceTiming = B.collectResourceTiming, this.tileSize !== 512) throw new Error("vector tile sources must have a tileSize of 512");
+                this.setEventedParent(ee);
+              }
+              load() {
+                return a._(this, void 0, void 0, function* () {
+                  this._loaded = false, this.fire(new a.k("dataloading", { dataType: "source" })), this._tileJSONRequest = new AbortController();
+                  try {
+                    let w = yield De(this._options, this.map._requestManager, this._tileJSONRequest);
+                    this._tileJSONRequest = null, this._loaded = true, this.map.style.sourceCaches[this.id].clearTiles(), w && (a.e(this, w), w.bounds && (this.tileBounds = new je(w.bounds, this.minzoom, this.maxzoom)), this.fire(new a.k("data", { dataType: "source", sourceDataType: "metadata" })), this.fire(new a.k("data", { dataType: "source", sourceDataType: "content" })));
+                  } catch (w) {
+                    this._tileJSONRequest = null, this.fire(new a.j(w));
+                  }
+                });
+              }
+              loaded() {
+                return this._loaded;
+              }
+              hasTile(w) {
+                return !this.tileBounds || this.tileBounds.contains(w.canonical);
+              }
+              onAdd(w) {
+                this.map = w, this.load();
+              }
+              setSourceProperty(w) {
+                this._tileJSONRequest && this._tileJSONRequest.abort(), w(), this.load();
+              }
+              setTiles(w) {
+                return this.setSourceProperty(() => {
+                  this._options.tiles = w;
+                }), this;
+              }
+              setUrl(w) {
+                return this.setSourceProperty(() => {
+                  this.url = w, this._options.url = w;
+                }), this;
+              }
+              onRemove() {
+                this._tileJSONRequest && (this._tileJSONRequest.abort(), this._tileJSONRequest = null);
+              }
+              serialize() {
+                return a.e({}, this._options);
+              }
+              loadTile(w) {
+                return a._(this, void 0, void 0, function* () {
+                  let B = w.tileID.canonical.url(this.tiles, this.map.getPixelRatio(), this.scheme), Q = { request: this.map._requestManager.transformRequest(B, "Tile"), uid: w.uid, tileID: w.tileID, zoom: w.tileID.overscaledZ, tileSize: this.tileSize * w.tileID.overscaleFactor(), type: this.type, source: this.id, pixelRatio: this.map.getPixelRatio(), showCollisionBoxes: this.map.showCollisionBoxes, promoteId: this.promoteId };
+                  Q.request.collectResourceTiming = this._collectResourceTiming;
+                  let ee = "RT";
+                  if (w.actor && w.state !== "expired") {
+                    if (w.state === "loading") return new Promise((le, Oe) => {
+                      w.reloadPromise = { resolve: le, reject: Oe };
+                    });
+                  } else w.actor = this.dispatcher.getActor(), ee = "LT";
+                  w.abortController = new AbortController();
+                  try {
+                    let le = yield w.actor.sendAsync({ type: ee, data: Q }, w.abortController);
+                    if (delete w.abortController, w.aborted) return;
+                    this._afterTileLoadWorkerResponse(w, le);
+                  } catch (le) {
+                    if (delete w.abortController, w.aborted) return;
+                    if (le && le.status !== 404) throw le;
+                    this._afterTileLoadWorkerResponse(w, null);
+                  }
+                });
+              }
+              _afterTileLoadWorkerResponse(w, B) {
+                if (B && B.resourceTiming && (w.resourceTiming = B.resourceTiming), B && this.map._refreshExpiredTiles && w.setExpiryData(B), w.loadVectorData(B, this.map.painter), w.reloadPromise) {
+                  let Q = w.reloadPromise;
+                  w.reloadPromise = null, this.loadTile(w).then(Q.resolve).catch(Q.reject);
+                }
+              }
+              abortTile(w) {
+                return a._(this, void 0, void 0, function* () {
+                  w.abortController && (w.abortController.abort(), delete w.abortController), w.actor && (yield w.actor.sendAsync({ type: "AT", data: { uid: w.uid, type: this.type, source: this.id } }));
+                });
+              }
+              unloadTile(w) {
+                return a._(this, void 0, void 0, function* () {
+                  w.unloadVectorData(), w.actor && (yield w.actor.sendAsync({ type: "RMT", data: { uid: w.uid, type: this.type, source: this.id } }));
+                });
+              }
+              hasTransition() {
+                return false;
+              }
+            }
+            class pt extends a.E {
+              constructor(w, B, Q, ee) {
+                super(), this.id = w, this.dispatcher = Q, this.setEventedParent(ee), this.type = "raster", this.minzoom = 0, this.maxzoom = 22, this.roundZoom = true, this.scheme = "xyz", this.tileSize = 512, this._loaded = false, this._options = a.e({ type: "raster" }, B), a.e(this, a.M(B, ["url", "scheme", "tileSize"]));
+              }
+              load() {
+                return a._(this, void 0, void 0, function* () {
+                  this._loaded = false, this.fire(new a.k("dataloading", { dataType: "source" })), this._tileJSONRequest = new AbortController();
+                  try {
+                    let w = yield De(this._options, this.map._requestManager, this._tileJSONRequest);
+                    this._tileJSONRequest = null, this._loaded = true, w && (a.e(this, w), w.bounds && (this.tileBounds = new je(w.bounds, this.minzoom, this.maxzoom)), this.fire(new a.k("data", { dataType: "source", sourceDataType: "metadata" })), this.fire(new a.k("data", { dataType: "source", sourceDataType: "content" })));
+                  } catch (w) {
+                    this._tileJSONRequest = null, this.fire(new a.j(w));
+                  }
+                });
+              }
+              loaded() {
+                return this._loaded;
+              }
+              onAdd(w) {
+                this.map = w, this.load();
+              }
+              onRemove() {
+                this._tileJSONRequest && (this._tileJSONRequest.abort(), this._tileJSONRequest = null);
+              }
+              setSourceProperty(w) {
+                this._tileJSONRequest && (this._tileJSONRequest.abort(), this._tileJSONRequest = null), w(), this.load();
+              }
+              setTiles(w) {
+                return this.setSourceProperty(() => {
+                  this._options.tiles = w;
+                }), this;
+              }
+              setUrl(w) {
+                return this.setSourceProperty(() => {
+                  this.url = w, this._options.url = w;
+                }), this;
+              }
+              serialize() {
+                return a.e({}, this._options);
+              }
+              hasTile(w) {
+                return !this.tileBounds || this.tileBounds.contains(w.canonical);
+              }
+              loadTile(w) {
+                return a._(this, void 0, void 0, function* () {
+                  let B = w.tileID.canonical.url(this.tiles, this.map.getPixelRatio(), this.scheme);
+                  w.abortController = new AbortController();
+                  try {
+                    let Q = yield p.getImage(this.map._requestManager.transformRequest(B, "Tile"), w.abortController, this.map._refreshExpiredTiles);
+                    if (delete w.abortController, w.aborted) return void (w.state = "unloaded");
+                    if (Q && Q.data) {
+                      this.map._refreshExpiredTiles && Q.cacheControl && Q.expires && w.setExpiryData({ cacheControl: Q.cacheControl, expires: Q.expires });
+                      let ee = this.map.painter.context, le = ee.gl, Oe = Q.data;
+                      w.texture = this.map.painter.getTileTexture(Oe.width), w.texture ? w.texture.update(Oe, { useMipmap: true }) : (w.texture = new g(ee, Oe, le.RGBA, { useMipmap: true }), w.texture.bind(le.LINEAR, le.CLAMP_TO_EDGE, le.LINEAR_MIPMAP_NEAREST)), w.state = "loaded";
+                    }
+                  } catch (Q) {
+                    if (delete w.abortController, w.aborted) w.state = "unloaded";
+                    else if (Q) throw w.state = "errored", Q;
+                  }
+                });
+              }
+              abortTile(w) {
+                return a._(this, void 0, void 0, function* () {
+                  w.abortController && (w.abortController.abort(), delete w.abortController);
+                });
+              }
+              unloadTile(w) {
+                return a._(this, void 0, void 0, function* () {
+                  w.texture && this.map.painter.saveTileTexture(w.texture);
+                });
+              }
+              hasTransition() {
+                return false;
+              }
+            }
+            class Vt extends pt {
+              constructor(w, B, Q, ee) {
+                super(w, B, Q, ee), this.type = "raster-dem", this.maxzoom = 22, this._options = a.e({ type: "raster-dem" }, B), this.encoding = B.encoding || "mapbox", this.redFactor = B.redFactor, this.greenFactor = B.greenFactor, this.blueFactor = B.blueFactor, this.baseShift = B.baseShift;
+              }
+              loadTile(w) {
+                return a._(this, void 0, void 0, function* () {
+                  let B = w.tileID.canonical.url(this.tiles, this.map.getPixelRatio(), this.scheme), Q = this.map._requestManager.transformRequest(B, "Tile");
+                  w.neighboringTiles = this._getNeighboringTiles(w.tileID), w.abortController = new AbortController();
+                  try {
+                    let ee = yield p.getImage(Q, w.abortController, this.map._refreshExpiredTiles);
+                    if (delete w.abortController, w.aborted) return void (w.state = "unloaded");
+                    if (ee && ee.data) {
+                      let le = ee.data;
+                      this.map._refreshExpiredTiles && ee.cacheControl && ee.expires && w.setExpiryData({ cacheControl: ee.cacheControl, expires: ee.expires });
+                      let Oe = a.b(le) && a.U() ? le : yield this.readImageNow(le), Ze = { type: this.type, uid: w.uid, source: this.id, rawImageData: Oe, encoding: this.encoding, redFactor: this.redFactor, greenFactor: this.greenFactor, blueFactor: this.blueFactor, baseShift: this.baseShift };
+                      if (!w.actor || w.state === "expired") {
+                        w.actor = this.dispatcher.getActor();
+                        let st = yield w.actor.sendAsync({ type: "LDT", data: Ze });
+                        w.dem = st, w.needsHillshadePrepare = true, w.needsTerrainPrepare = true, w.state = "loaded";
+                      }
+                    }
+                  } catch (ee) {
+                    if (delete w.abortController, w.aborted) w.state = "unloaded";
+                    else if (ee) throw w.state = "errored", ee;
+                  }
+                });
+              }
+              readImageNow(w) {
+                return a._(this, void 0, void 0, function* () {
+                  if (typeof VideoFrame != "undefined" && a.V()) {
+                    let B = w.width + 2, Q = w.height + 2;
+                    try {
+                      return new a.R({ width: B, height: Q }, yield a.W(w, -1, -1, B, Q));
+                    } catch (ee) {
+                    }
+                  }
+                  return u.getImageData(w, 1);
+                });
+              }
+              _getNeighboringTiles(w) {
+                let B = w.canonical, Q = Math.pow(2, B.z), ee = (B.x - 1 + Q) % Q, le = B.x === 0 ? w.wrap - 1 : w.wrap, Oe = (B.x + 1 + Q) % Q, Ze = B.x + 1 === Q ? w.wrap + 1 : w.wrap, st = {};
+                return st[new a.S(w.overscaledZ, le, B.z, ee, B.y).key] = { backfilled: false }, st[new a.S(w.overscaledZ, Ze, B.z, Oe, B.y).key] = { backfilled: false }, B.y > 0 && (st[new a.S(w.overscaledZ, le, B.z, ee, B.y - 1).key] = { backfilled: false }, st[new a.S(w.overscaledZ, w.wrap, B.z, B.x, B.y - 1).key] = { backfilled: false }, st[new a.S(w.overscaledZ, Ze, B.z, Oe, B.y - 1).key] = { backfilled: false }), B.y + 1 < Q && (st[new a.S(w.overscaledZ, le, B.z, ee, B.y + 1).key] = { backfilled: false }, st[new a.S(w.overscaledZ, w.wrap, B.z, B.x, B.y + 1).key] = { backfilled: false }, st[new a.S(w.overscaledZ, Ze, B.z, Oe, B.y + 1).key] = { backfilled: false }), st;
+              }
+              unloadTile(w) {
+                return a._(this, void 0, void 0, function* () {
+                  w.demTexture && this.map.painter.saveTileTexture(w.demTexture), w.fbo && (w.fbo.destroy(), delete w.fbo), w.dem && delete w.dem, delete w.neighboringTiles, w.state = "unloaded", w.actor && (yield w.actor.sendAsync({ type: "RDT", data: { type: this.type, uid: w.uid, source: this.id } }));
+                });
+              }
+            }
+            class ot extends a.E {
+              constructor(w, B, Q, ee) {
+                super(), this.id = w, this.type = "geojson", this.minzoom = 0, this.maxzoom = 18, this.tileSize = 512, this.isTileClipped = true, this.reparseOverscaled = true, this._removed = false, this._pendingLoads = 0, this.actor = Q.getActor(), this.setEventedParent(ee), this._data = B.data, this._options = a.e({}, B), this._collectResourceTiming = B.collectResourceTiming, B.maxzoom !== void 0 && (this.maxzoom = B.maxzoom), B.type && (this.type = B.type), B.attribution && (this.attribution = B.attribution), this.promoteId = B.promoteId;
+                let le = a.X / this.tileSize;
+                B.clusterMaxZoom !== void 0 && this.maxzoom <= B.clusterMaxZoom && a.w(`The maxzoom value "${this.maxzoom}" is expected to be greater than the clusterMaxZoom value "${B.clusterMaxZoom}".`), this.workerOptions = a.e({ source: this.id, cluster: B.cluster || false, geojsonVtOptions: { buffer: (B.buffer !== void 0 ? B.buffer : 128) * le, tolerance: (B.tolerance !== void 0 ? B.tolerance : 0.375) * le, extent: a.X, maxZoom: this.maxzoom, lineMetrics: B.lineMetrics || false, generateId: B.generateId || false }, superclusterOptions: { maxZoom: B.clusterMaxZoom !== void 0 ? B.clusterMaxZoom : this.maxzoom - 1, minPoints: Math.max(2, B.clusterMinPoints || 2), extent: a.X, radius: (B.clusterRadius || 50) * le, log: false, generateId: B.generateId || false }, clusterProperties: B.clusterProperties, filter: B.filter }, B.workerOptions), typeof this.promoteId == "string" && (this.workerOptions.promoteId = this.promoteId);
+              }
+              load() {
+                return a._(this, void 0, void 0, function* () {
+                  yield this._updateWorkerData();
+                });
+              }
+              onAdd(w) {
+                this.map = w, this.load();
+              }
+              setData(w) {
+                return this._data = w, this._updateWorkerData(), this;
+              }
+              updateData(w) {
+                return this._updateWorkerData(w), this;
+              }
+              getData() {
+                return a._(this, void 0, void 0, function* () {
+                  let w = a.e({ type: this.type }, this.workerOptions);
+                  return this.actor.sendAsync({ type: "GD", data: w });
+                });
+              }
+              setClusterOptions(w) {
+                return this.workerOptions.cluster = w.cluster, w && (w.clusterRadius !== void 0 && (this.workerOptions.superclusterOptions.radius = w.clusterRadius), w.clusterMaxZoom !== void 0 && (this.workerOptions.superclusterOptions.maxZoom = w.clusterMaxZoom)), this._updateWorkerData(), this;
+              }
+              getClusterExpansionZoom(w) {
+                return this.actor.sendAsync({ type: "GCEZ", data: { type: this.type, clusterId: w, source: this.id } });
+              }
+              getClusterChildren(w) {
+                return this.actor.sendAsync({ type: "GCC", data: { type: this.type, clusterId: w, source: this.id } });
+              }
+              getClusterLeaves(w, B, Q) {
+                return this.actor.sendAsync({ type: "GCL", data: { type: this.type, source: this.id, clusterId: w, limit: B, offset: Q } });
+              }
+              _updateWorkerData(w) {
+                return a._(this, void 0, void 0, function* () {
+                  let B = a.e({ type: this.type }, this.workerOptions);
+                  w ? B.dataDiff = w : typeof this._data == "string" ? (B.request = this.map._requestManager.transformRequest(u.resolveURL(this._data), "Source"), B.request.collectResourceTiming = this._collectResourceTiming) : B.data = JSON.stringify(this._data), this._pendingLoads++, this.fire(new a.k("dataloading", { dataType: "source" }));
+                  try {
+                    let Q = yield this.actor.sendAsync({ type: "LD", data: B });
+                    if (this._pendingLoads--, this._removed || Q.abandoned) return void this.fire(new a.k("dataabort", { dataType: "source" }));
+                    let ee = null;
+                    Q.resourceTiming && Q.resourceTiming[this.id] && (ee = Q.resourceTiming[this.id].slice(0));
+                    let le = { dataType: "source" };
+                    this._collectResourceTiming && ee && ee.length > 0 && a.e(le, { resourceTiming: ee }), this.fire(new a.k("data", Object.assign(Object.assign({}, le), { sourceDataType: "metadata" }))), this.fire(new a.k("data", Object.assign(Object.assign({}, le), { sourceDataType: "content" })));
+                  } catch (Q) {
+                    if (this._pendingLoads--, this._removed) return void this.fire(new a.k("dataabort", { dataType: "source" }));
+                    this.fire(new a.j(Q));
+                  }
+                });
+              }
+              loaded() {
+                return this._pendingLoads === 0;
+              }
+              loadTile(w) {
+                return a._(this, void 0, void 0, function* () {
+                  let B = w.actor ? "RT" : "LT";
+                  w.actor = this.actor;
+                  let Q = { type: this.type, uid: w.uid, tileID: w.tileID, zoom: w.tileID.overscaledZ, maxZoom: this.maxzoom, tileSize: this.tileSize, source: this.id, pixelRatio: this.map.getPixelRatio(), showCollisionBoxes: this.map.showCollisionBoxes, promoteId: this.promoteId };
+                  w.abortController = new AbortController();
+                  let ee = yield this.actor.sendAsync({ type: B, data: Q }, w.abortController);
+                  delete w.abortController, w.unloadVectorData(), w.aborted || w.loadVectorData(ee, this.map.painter, B === "RT");
+                });
+              }
+              abortTile(w) {
+                return a._(this, void 0, void 0, function* () {
+                  w.abortController && (w.abortController.abort(), delete w.abortController), w.aborted = true;
+                });
+              }
+              unloadTile(w) {
+                return a._(this, void 0, void 0, function* () {
+                  w.unloadVectorData(), yield this.actor.sendAsync({ type: "RMT", data: { uid: w.uid, type: this.type, source: this.id } });
+                });
+              }
+              onRemove() {
+                this._removed = true, this.actor.sendAsync({ type: "RS", data: { type: this.type, source: this.id } });
+              }
+              serialize() {
+                return a.e({}, this._options, { type: this.type, data: this._data });
+              }
+              hasTransition() {
+                return false;
+              }
+            }
+            var ut = a.Y([{ name: "a_pos", type: "Int16", components: 2 }, { name: "a_texture_pos", type: "Int16", components: 2 }]);
+            class Wt extends a.E {
+              constructor(w, B, Q, ee) {
+                super(), this.id = w, this.dispatcher = Q, this.coordinates = B.coordinates, this.type = "image", this.minzoom = 0, this.maxzoom = 22, this.tileSize = 512, this.tiles = {}, this._loaded = false, this.setEventedParent(ee), this.options = B;
+              }
+              load(w) {
+                return a._(this, void 0, void 0, function* () {
+                  this._loaded = false, this.fire(new a.k("dataloading", { dataType: "source" })), this.url = this.options.url, this._request = new AbortController();
+                  try {
+                    let B = yield p.getImage(this.map._requestManager.transformRequest(this.url, "Image"), this._request);
+                    this._request = null, this._loaded = true, B && B.data && (this.image = B.data, w && (this.coordinates = w), this._finishLoading());
+                  } catch (B) {
+                    this._request = null, this._loaded = true, this.fire(new a.j(B));
+                  }
+                });
+              }
+              loaded() {
+                return this._loaded;
+              }
+              updateImage(w) {
+                return w.url ? (this._request && (this._request.abort(), this._request = null), this.options.url = w.url, this.load(w.coordinates).finally(() => {
+                  this.texture = null;
+                }), this) : this;
+              }
+              _finishLoading() {
+                this.map && (this.setCoordinates(this.coordinates), this.fire(new a.k("data", { dataType: "source", sourceDataType: "metadata" })));
+              }
+              onAdd(w) {
+                this.map = w, this.load();
+              }
+              onRemove() {
+                this._request && (this._request.abort(), this._request = null);
+              }
+              setCoordinates(w) {
+                this.coordinates = w;
+                let B = w.map(a.Z.fromLngLat);
+                this.tileID = function(ee) {
+                  let le = 1 / 0, Oe = 1 / 0, Ze = -1 / 0, st = -1 / 0;
+                  for (let xr of ee) le = Math.min(le, xr.x), Oe = Math.min(Oe, xr.y), Ze = Math.max(Ze, xr.x), st = Math.max(st, xr.y);
+                  let Tt = Math.max(Ze - le, st - Oe), Yt = Math.max(0, Math.floor(-Math.log(Tt) / Math.LN2)), Kt = Math.pow(2, Yt);
+                  return new a.a1(Yt, Math.floor((le + Ze) / 2 * Kt), Math.floor((Oe + st) / 2 * Kt));
+                }(B), this.minzoom = this.maxzoom = this.tileID.z;
+                let Q = B.map((ee) => this.tileID.getTilePoint(ee)._round());
+                return this._boundsArray = new a.$(), this._boundsArray.emplaceBack(Q[0].x, Q[0].y, 0, 0), this._boundsArray.emplaceBack(Q[1].x, Q[1].y, a.X, 0), this._boundsArray.emplaceBack(Q[3].x, Q[3].y, 0, a.X), this._boundsArray.emplaceBack(Q[2].x, Q[2].y, a.X, a.X), this.boundsBuffer && (this.boundsBuffer.destroy(), delete this.boundsBuffer), this.fire(new a.k("data", { dataType: "source", sourceDataType: "content" })), this;
+              }
+              prepare() {
+                if (Object.keys(this.tiles).length === 0 || !this.image) return;
+                let w = this.map.painter.context, B = w.gl;
+                this.boundsBuffer || (this.boundsBuffer = w.createVertexBuffer(this._boundsArray, ut.members)), this.boundsSegments || (this.boundsSegments = a.a0.simpleSegment(0, 0, 4, 2)), this.texture || (this.texture = new g(w, this.image, B.RGBA), this.texture.bind(B.LINEAR, B.CLAMP_TO_EDGE));
+                let Q = false;
+                for (let ee in this.tiles) {
+                  let le = this.tiles[ee];
+                  le.state !== "loaded" && (le.state = "loaded", le.texture = this.texture, Q = true);
+                }
+                Q && this.fire(new a.k("data", { dataType: "source", sourceDataType: "idle", sourceId: this.id }));
+              }
+              loadTile(w) {
+                return a._(this, void 0, void 0, function* () {
+                  this.tileID && this.tileID.equals(w.tileID.canonical) ? (this.tiles[String(w.tileID.wrap)] = w, w.buckets = {}) : w.state = "errored";
+                });
+              }
+              serialize() {
+                return { type: "image", url: this.options.url, coordinates: this.coordinates };
+              }
+              hasTransition() {
+                return false;
+              }
+            }
+            class Nt extends Wt {
+              constructor(w, B, Q, ee) {
+                super(w, B, Q, ee), this.roundZoom = true, this.type = "video", this.options = B;
+              }
+              load() {
+                return a._(this, void 0, void 0, function* () {
+                  this._loaded = false;
+                  let w = this.options;
+                  this.urls = [];
+                  for (let B of w.urls) this.urls.push(this.map._requestManager.transformRequest(B, "Source").url);
+                  try {
+                    let B = yield a.a3(this.urls);
+                    if (this._loaded = true, !B) return;
+                    this.video = B, this.video.loop = true, this.video.addEventListener("playing", () => {
+                      this.map.triggerRepaint();
+                    }), this.map && this.video.play(), this._finishLoading();
+                  } catch (B) {
+                    this.fire(new a.j(B));
+                  }
+                });
+              }
+              pause() {
+                this.video && this.video.pause();
+              }
+              play() {
+                this.video && this.video.play();
+              }
+              seek(w) {
+                if (this.video) {
+                  let B = this.video.seekable;
+                  w < B.start(0) || w > B.end(0) ? this.fire(new a.j(new a.a2(`sources.${this.id}`, null, `Playback for this video can be set only between the ${B.start(0)} and ${B.end(0)}-second mark.`))) : this.video.currentTime = w;
+                }
+              }
+              getVideo() {
+                return this.video;
+              }
+              onAdd(w) {
+                this.map || (this.map = w, this.load(), this.video && (this.video.play(), this.setCoordinates(this.coordinates)));
+              }
+              prepare() {
+                if (Object.keys(this.tiles).length === 0 || this.video.readyState < 2) return;
+                let w = this.map.painter.context, B = w.gl;
+                this.boundsBuffer || (this.boundsBuffer = w.createVertexBuffer(this._boundsArray, ut.members)), this.boundsSegments || (this.boundsSegments = a.a0.simpleSegment(0, 0, 4, 2)), this.texture ? this.video.paused || (this.texture.bind(B.LINEAR, B.CLAMP_TO_EDGE), B.texSubImage2D(B.TEXTURE_2D, 0, 0, 0, B.RGBA, B.UNSIGNED_BYTE, this.video)) : (this.texture = new g(w, this.video, B.RGBA), this.texture.bind(B.LINEAR, B.CLAMP_TO_EDGE));
+                let Q = false;
+                for (let ee in this.tiles) {
+                  let le = this.tiles[ee];
+                  le.state !== "loaded" && (le.state = "loaded", le.texture = this.texture, Q = true);
+                }
+                Q && this.fire(new a.k("data", { dataType: "source", sourceDataType: "idle", sourceId: this.id }));
+              }
+              serialize() {
+                return { type: "video", urls: this.urls, coordinates: this.coordinates };
+              }
+              hasTransition() {
+                return this.video && !this.video.paused;
+              }
+            }
+            class $t extends Wt {
+              constructor(w, B, Q, ee) {
+                super(w, B, Q, ee), B.coordinates ? Array.isArray(B.coordinates) && B.coordinates.length === 4 && !B.coordinates.some((le) => !Array.isArray(le) || le.length !== 2 || le.some((Oe) => typeof Oe != "number")) || this.fire(new a.j(new a.a2(`sources.${w}`, null, '"coordinates" property must be an array of 4 longitude/latitude array pairs'))) : this.fire(new a.j(new a.a2(`sources.${w}`, null, 'missing required property "coordinates"'))), B.animate && typeof B.animate != "boolean" && this.fire(new a.j(new a.a2(`sources.${w}`, null, 'optional "animate" property must be a boolean value'))), B.canvas ? typeof B.canvas == "string" || B.canvas instanceof HTMLCanvasElement || this.fire(new a.j(new a.a2(`sources.${w}`, null, '"canvas" must be either a string representing the ID of the canvas element from which to read, or an HTMLCanvasElement instance'))) : this.fire(new a.j(new a.a2(`sources.${w}`, null, 'missing required property "canvas"'))), this.options = B, this.animate = B.animate === void 0 || B.animate;
+              }
+              load() {
+                return a._(this, void 0, void 0, function* () {
+                  this._loaded = true, this.canvas || (this.canvas = this.options.canvas instanceof HTMLCanvasElement ? this.options.canvas : document.getElementById(this.options.canvas)), this.width = this.canvas.width, this.height = this.canvas.height, this._hasInvalidDimensions() ? this.fire(new a.j(new Error("Canvas dimensions cannot be less than or equal to zero."))) : (this.play = function() {
+                    this._playing = true, this.map.triggerRepaint();
+                  }, this.pause = function() {
+                    this._playing && (this.prepare(), this._playing = false);
+                  }, this._finishLoading());
+                });
+              }
+              getCanvas() {
+                return this.canvas;
+              }
+              onAdd(w) {
+                this.map = w, this.load(), this.canvas && this.animate && this.play();
+              }
+              onRemove() {
+                this.pause();
+              }
+              prepare() {
+                let w = false;
+                if (this.canvas.width !== this.width && (this.width = this.canvas.width, w = true), this.canvas.height !== this.height && (this.height = this.canvas.height, w = true), this._hasInvalidDimensions() || Object.keys(this.tiles).length === 0) return;
+                let B = this.map.painter.context, Q = B.gl;
+                this.boundsBuffer || (this.boundsBuffer = B.createVertexBuffer(this._boundsArray, ut.members)), this.boundsSegments || (this.boundsSegments = a.a0.simpleSegment(0, 0, 4, 2)), this.texture ? (w || this._playing) && this.texture.update(this.canvas, { premultiply: true }) : this.texture = new g(B, this.canvas, Q.RGBA, { premultiply: true });
+                let ee = false;
+                for (let le in this.tiles) {
+                  let Oe = this.tiles[le];
+                  Oe.state !== "loaded" && (Oe.state = "loaded", Oe.texture = this.texture, ee = true);
+                }
+                ee && this.fire(new a.k("data", { dataType: "source", sourceDataType: "idle", sourceId: this.id }));
+              }
+              serialize() {
+                return { type: "canvas", coordinates: this.coordinates };
+              }
+              hasTransition() {
+                return this._playing;
+              }
+              _hasInvalidDimensions() {
+                for (let w of [this.canvas.width, this.canvas.height]) if (isNaN(w) || w <= 0) return true;
+                return false;
+              }
+            }
+            let sr = {}, Tr = (ue) => {
+              switch (ue) {
+                case "geojson":
+                  return ot;
+                case "image":
+                  return Wt;
+                case "raster":
+                  return pt;
+                case "raster-dem":
+                  return Vt;
+                case "vector":
+                  return lt;
+                case "video":
+                  return Nt;
+                case "canvas":
+                  return $t;
+              }
+              return sr[ue];
+            }, fr = "RTLPluginLoaded";
+            class $e extends a.E {
+              constructor() {
+                super(...arguments), this.status = "unavailable", this.url = null, this.dispatcher = Ae();
+              }
+              _syncState(w) {
+                return this.status = w, this.dispatcher.broadcast("SRPS", { pluginStatus: w, pluginURL: this.url }).catch((B) => {
+                  throw this.status = "error", B;
+                });
+              }
+              getRTLTextPluginStatus() {
+                return this.status;
+              }
+              clearRTLTextPlugin() {
+                this.status = "unavailable", this.url = null;
+              }
+              setRTLTextPlugin(w) {
+                return a._(this, arguments, void 0, function* (B, Q = false) {
+                  if (this.url) throw new Error("setRTLTextPlugin cannot be called multiple times.");
+                  if (this.url = u.resolveURL(B), !this.url) throw new Error(`requested url ${B} is invalid`);
+                  if (this.status === "unavailable") {
+                    if (!Q) return this._requestImport();
+                    this.status = "deferred", this._syncState(this.status);
+                  } else if (this.status === "requested") return this._requestImport();
+                });
+              }
+              _requestImport() {
+                return a._(this, void 0, void 0, function* () {
+                  yield this._syncState("loading"), this.status = "loaded", this.fire(new a.k(fr));
+                });
+              }
+              lazyLoad() {
+                this.status === "unavailable" ? this.status = "requested" : this.status === "deferred" && this._requestImport();
+              }
+            }
+            let St = null;
+            function Qt() {
+              return St || (St = new $e()), St;
+            }
+            class Gt {
+              constructor(w, B) {
+                this.timeAdded = 0, this.fadeEndTime = 0, this.tileID = w, this.uid = a.a4(), this.uses = 0, this.tileSize = B, this.buckets = {}, this.expirationTime = null, this.queryPadding = 0, this.hasSymbolBuckets = false, this.hasRTLText = false, this.dependencies = {}, this.rtt = [], this.rttCoords = {}, this.expiredRequestCount = 0, this.state = "loading";
+              }
+              registerFadeDuration(w) {
+                let B = w + this.timeAdded;
+                B < this.fadeEndTime || (this.fadeEndTime = B);
+              }
+              wasRequested() {
+                return this.state === "errored" || this.state === "loaded" || this.state === "reloading";
+              }
+              clearTextures(w) {
+                this.demTexture && w.saveTileTexture(this.demTexture), this.demTexture = null;
+              }
+              loadVectorData(w, B, Q) {
+                if (this.hasData() && this.unloadVectorData(), this.state = "loaded", w) {
+                  w.featureIndex && (this.latestFeatureIndex = w.featureIndex, w.rawTileData ? (this.latestRawTileData = w.rawTileData, this.latestFeatureIndex.rawTileData = w.rawTileData) : this.latestRawTileData && (this.latestFeatureIndex.rawTileData = this.latestRawTileData)), this.collisionBoxArray = w.collisionBoxArray, this.buckets = function(ee, le) {
+                    let Oe = {};
+                    if (!le) return Oe;
+                    for (let Ze of ee) {
+                      let st = Ze.layerIds.map((Tt) => le.getLayer(Tt)).filter(Boolean);
+                      if (st.length !== 0) {
+                        Ze.layers = st, Ze.stateDependentLayerIds && (Ze.stateDependentLayers = Ze.stateDependentLayerIds.map((Tt) => st.filter((Yt) => Yt.id === Tt)[0]));
+                        for (let Tt of st) Oe[Tt.id] = Ze;
+                      }
+                    }
+                    return Oe;
+                  }(w.buckets, B.style), this.hasSymbolBuckets = false;
+                  for (let ee in this.buckets) {
+                    let le = this.buckets[ee];
+                    if (le instanceof a.a6) {
+                      if (this.hasSymbolBuckets = true, !Q) break;
+                      le.justReloaded = true;
+                    }
+                  }
+                  if (this.hasRTLText = false, this.hasSymbolBuckets) for (let ee in this.buckets) {
+                    let le = this.buckets[ee];
+                    if (le instanceof a.a6 && le.hasRTLText) {
+                      this.hasRTLText = true, Qt().lazyLoad();
+                      break;
+                    }
+                  }
+                  this.queryPadding = 0;
+                  for (let ee in this.buckets) {
+                    let le = this.buckets[ee];
+                    this.queryPadding = Math.max(this.queryPadding, B.style.getLayer(ee).queryRadius(le));
+                  }
+                  w.imageAtlas && (this.imageAtlas = w.imageAtlas), w.glyphAtlasImage && (this.glyphAtlasImage = w.glyphAtlasImage);
+                } else this.collisionBoxArray = new a.a5();
+              }
+              unloadVectorData() {
+                for (let w in this.buckets) this.buckets[w].destroy();
+                this.buckets = {}, this.imageAtlasTexture && this.imageAtlasTexture.destroy(), this.imageAtlas && (this.imageAtlas = null), this.glyphAtlasTexture && this.glyphAtlasTexture.destroy(), this.latestFeatureIndex = null, this.state = "unloaded";
+              }
+              getBucket(w) {
+                return this.buckets[w.id];
+              }
+              upload(w) {
+                for (let Q in this.buckets) {
+                  let ee = this.buckets[Q];
+                  ee.uploadPending() && ee.upload(w);
+                }
+                let B = w.gl;
+                this.imageAtlas && !this.imageAtlas.uploaded && (this.imageAtlasTexture = new g(w, this.imageAtlas.image, B.RGBA), this.imageAtlas.uploaded = true), this.glyphAtlasImage && (this.glyphAtlasTexture = new g(w, this.glyphAtlasImage, B.ALPHA), this.glyphAtlasImage = null);
+              }
+              prepare(w) {
+                this.imageAtlas && this.imageAtlas.patchUpdatedImages(w, this.imageAtlasTexture);
+              }
+              queryRenderedFeatures(w, B, Q, ee, le, Oe, Ze, st, Tt, Yt) {
+                return this.latestFeatureIndex && this.latestFeatureIndex.rawTileData ? this.latestFeatureIndex.query({ queryGeometry: ee, cameraQueryGeometry: le, scale: Oe, tileSize: this.tileSize, pixelPosMatrix: Yt, transform: st, params: Ze, queryPadding: this.queryPadding * Tt }, w, B, Q) : {};
+              }
+              querySourceFeatures(w, B) {
+                let Q = this.latestFeatureIndex;
+                if (!Q || !Q.rawTileData) return;
+                let ee = Q.loadVTLayers(), le = B && B.sourceLayer ? B.sourceLayer : "", Oe = ee._geojsonTileLayer || ee[le];
+                if (!Oe) return;
+                let Ze = a.a7(B && B.filter), { z: st, x: Tt, y: Yt } = this.tileID.canonical, Kt = { z: st, x: Tt, y: Yt };
+                for (let xr = 0; xr < Oe.length; xr++) {
+                  let Ir = Oe.feature(xr);
+                  if (Ze.needGeometry) {
+                    let Re = a.a8(Ir, true);
+                    if (!Ze.filter(new a.z(this.tileID.overscaledZ), Re, this.tileID.canonical)) continue;
+                  } else if (!Ze.filter(new a.z(this.tileID.overscaledZ), Ir)) continue;
+                  let ve = Q.getId(Ir, le), be = new a.a9(Ir, st, Tt, Yt, ve);
+                  be.tile = Kt, w.push(be);
+                }
+              }
+              hasData() {
+                return this.state === "loaded" || this.state === "reloading" || this.state === "expired";
+              }
+              patternsLoaded() {
+                return this.imageAtlas && !!Object.keys(this.imageAtlas.patternPositions).length;
+              }
+              setExpiryData(w) {
+                let B = this.expirationTime;
+                if (w.cacheControl) {
+                  let Q = a.aa(w.cacheControl);
+                  Q["max-age"] && (this.expirationTime = Date.now() + 1e3 * Q["max-age"]);
+                } else w.expires && (this.expirationTime = new Date(w.expires).getTime());
+                if (this.expirationTime) {
+                  let Q = Date.now(), ee = false;
+                  if (this.expirationTime > Q) ee = false;
+                  else if (B) if (this.expirationTime < B) ee = true;
+                  else {
+                    let le = this.expirationTime - B;
+                    le ? this.expirationTime = Q + Math.max(le, 3e4) : ee = true;
+                  }
+                  else ee = true;
+                  ee ? (this.expiredRequestCount++, this.state = "expired") : this.expiredRequestCount = 0;
+                }
+              }
+              getExpiryTimeout() {
+                if (this.expirationTime) return this.expiredRequestCount ? 1e3 * (1 << Math.min(this.expiredRequestCount - 1, 31)) : Math.min(this.expirationTime - (/* @__PURE__ */ new Date()).getTime(), Math.pow(2, 31) - 1);
+              }
+              setFeatureState(w, B) {
+                if (!this.latestFeatureIndex || !this.latestFeatureIndex.rawTileData || Object.keys(w).length === 0) return;
+                let Q = this.latestFeatureIndex.loadVTLayers();
+                for (let ee in this.buckets) {
+                  if (!B.style.hasLayer(ee)) continue;
+                  let le = this.buckets[ee], Oe = le.layers[0].sourceLayer || "_geojsonTileLayer", Ze = Q[Oe], st = w[Oe];
+                  if (!Ze || !st || Object.keys(st).length === 0) continue;
+                  le.update(st, Ze, this.imageAtlas && this.imageAtlas.patternPositions || {});
+                  let Tt = B && B.style && B.style.getLayer(ee);
+                  Tt && (this.queryPadding = Math.max(this.queryPadding, Tt.queryRadius(le)));
+                }
+              }
+              holdingForFade() {
+                return this.symbolFadeHoldUntil !== void 0;
+              }
+              symbolFadeFinished() {
+                return !this.symbolFadeHoldUntil || this.symbolFadeHoldUntil < u.now();
+              }
+              clearFadeHold() {
+                this.symbolFadeHoldUntil = void 0;
+              }
+              setHoldDuration(w) {
+                this.symbolFadeHoldUntil = u.now() + w;
+              }
+              setDependencies(w, B) {
+                let Q = {};
+                for (let ee of B) Q[ee] = true;
+                this.dependencies[w] = Q;
+              }
+              hasDependency(w, B) {
+                for (let Q of w) {
+                  let ee = this.dependencies[Q];
+                  if (ee) {
+                    for (let le of B) if (ee[le]) return true;
+                  }
+                }
+                return false;
+              }
+            }
+            class _t {
+              constructor(w, B) {
+                this.max = w, this.onRemove = B, this.reset();
+              }
+              reset() {
+                for (let w in this.data) for (let B of this.data[w]) B.timeout && clearTimeout(B.timeout), this.onRemove(B.value);
+                return this.data = {}, this.order = [], this;
+              }
+              add(w, B, Q) {
+                let ee = w.wrapped().key;
+                this.data[ee] === void 0 && (this.data[ee] = []);
+                let le = { value: B, timeout: void 0 };
+                if (Q !== void 0 && (le.timeout = setTimeout(() => {
+                  this.remove(w, le);
+                }, Q)), this.data[ee].push(le), this.order.push(ee), this.order.length > this.max) {
+                  let Oe = this._getAndRemoveByKey(this.order[0]);
+                  Oe && this.onRemove(Oe);
+                }
+                return this;
+              }
+              has(w) {
+                return w.wrapped().key in this.data;
+              }
+              getAndRemove(w) {
+                return this.has(w) ? this._getAndRemoveByKey(w.wrapped().key) : null;
+              }
+              _getAndRemoveByKey(w) {
+                let B = this.data[w].shift();
+                return B.timeout && clearTimeout(B.timeout), this.data[w].length === 0 && delete this.data[w], this.order.splice(this.order.indexOf(w), 1), B.value;
+              }
+              getByKey(w) {
+                let B = this.data[w];
+                return B ? B[0].value : null;
+              }
+              get(w) {
+                return this.has(w) ? this.data[w.wrapped().key][0].value : null;
+              }
+              remove(w, B) {
+                if (!this.has(w)) return this;
+                let Q = w.wrapped().key, ee = B === void 0 ? 0 : this.data[Q].indexOf(B), le = this.data[Q][ee];
+                return this.data[Q].splice(ee, 1), le.timeout && clearTimeout(le.timeout), this.data[Q].length === 0 && delete this.data[Q], this.onRemove(le.value), this.order.splice(this.order.indexOf(Q), 1), this;
+              }
+              setMaxSize(w) {
+                for (this.max = w; this.order.length > this.max; ) {
+                  let B = this._getAndRemoveByKey(this.order[0]);
+                  B && this.onRemove(B);
+                }
+                return this;
+              }
+              filter(w) {
+                let B = [];
+                for (let Q in this.data) for (let ee of this.data[Q]) w(ee.value) || B.push(ee);
+                for (let Q of B) this.remove(Q.value.tileID, Q);
+              }
+            }
+            class It {
+              constructor() {
+                this.state = {}, this.stateChanges = {}, this.deletedStates = {};
+              }
+              updateState(w, B, Q) {
+                let ee = String(B);
+                if (this.stateChanges[w] = this.stateChanges[w] || {}, this.stateChanges[w][ee] = this.stateChanges[w][ee] || {}, a.e(this.stateChanges[w][ee], Q), this.deletedStates[w] === null) {
+                  this.deletedStates[w] = {};
+                  for (let le in this.state[w]) le !== ee && (this.deletedStates[w][le] = null);
+                } else if (this.deletedStates[w] && this.deletedStates[w][ee] === null) {
+                  this.deletedStates[w][ee] = {};
+                  for (let le in this.state[w][ee]) Q[le] || (this.deletedStates[w][ee][le] = null);
+                } else for (let le in Q) this.deletedStates[w] && this.deletedStates[w][ee] && this.deletedStates[w][ee][le] === null && delete this.deletedStates[w][ee][le];
+              }
+              removeFeatureState(w, B, Q) {
+                if (this.deletedStates[w] === null) return;
+                let ee = String(B);
+                if (this.deletedStates[w] = this.deletedStates[w] || {}, Q && B !== void 0) this.deletedStates[w][ee] !== null && (this.deletedStates[w][ee] = this.deletedStates[w][ee] || {}, this.deletedStates[w][ee][Q] = null);
+                else if (B !== void 0) if (this.stateChanges[w] && this.stateChanges[w][ee]) for (Q in this.deletedStates[w][ee] = {}, this.stateChanges[w][ee]) this.deletedStates[w][ee][Q] = null;
+                else this.deletedStates[w][ee] = null;
+                else this.deletedStates[w] = null;
+              }
+              getState(w, B) {
+                let Q = String(B), ee = a.e({}, (this.state[w] || {})[Q], (this.stateChanges[w] || {})[Q]);
+                if (this.deletedStates[w] === null) return {};
+                if (this.deletedStates[w]) {
+                  let le = this.deletedStates[w][B];
+                  if (le === null) return {};
+                  for (let Oe in le) delete ee[Oe];
+                }
+                return ee;
+              }
+              initializeTileState(w, B) {
+                w.setFeatureState(this.state, B);
+              }
+              coalesceChanges(w, B) {
+                let Q = {};
+                for (let ee in this.stateChanges) {
+                  this.state[ee] = this.state[ee] || {};
+                  let le = {};
+                  for (let Oe in this.stateChanges[ee]) this.state[ee][Oe] || (this.state[ee][Oe] = {}), a.e(this.state[ee][Oe], this.stateChanges[ee][Oe]), le[Oe] = this.state[ee][Oe];
+                  Q[ee] = le;
+                }
+                for (let ee in this.deletedStates) {
+                  this.state[ee] = this.state[ee] || {};
+                  let le = {};
+                  if (this.deletedStates[ee] === null) for (let Oe in this.state[ee]) le[Oe] = {}, this.state[ee][Oe] = {};
+                  else for (let Oe in this.deletedStates[ee]) {
+                    if (this.deletedStates[ee][Oe] === null) this.state[ee][Oe] = {};
+                    else for (let Ze of Object.keys(this.deletedStates[ee][Oe])) delete this.state[ee][Oe][Ze];
+                    le[Oe] = this.state[ee][Oe];
+                  }
+                  Q[ee] = Q[ee] || {}, a.e(Q[ee], le);
+                }
+                if (this.stateChanges = {}, this.deletedStates = {}, Object.keys(Q).length !== 0) for (let ee in w) w[ee].setFeatureState(Q, B);
+              }
+            }
+            class mt extends a.E {
+              constructor(w, B, Q) {
+                super(), this.id = w, this.dispatcher = Q, this.on("data", (ee) => this._dataHandler(ee)), this.on("dataloading", () => {
+                  this._sourceErrored = false;
+                }), this.on("error", () => {
+                  this._sourceErrored = this._source.loaded();
+                }), this._source = ((ee, le, Oe, Ze) => {
+                  let st = new (Tr(le.type))(ee, le, Oe, Ze);
+                  if (st.id !== ee) throw new Error(`Expected Source id to be ${ee} instead of ${st.id}`);
+                  return st;
+                })(w, B, Q, this), this._tiles = {}, this._cache = new _t(0, (ee) => this._unloadTile(ee)), this._timers = {}, this._cacheTimers = {}, this._maxTileCacheSize = null, this._maxTileCacheZoomLevels = null, this._loadedParentTiles = {}, this._coveredTiles = {}, this._state = new It(), this._didEmitContent = false, this._updated = false;
+              }
+              onAdd(w) {
+                this.map = w, this._maxTileCacheSize = w ? w._maxTileCacheSize : null, this._maxTileCacheZoomLevels = w ? w._maxTileCacheZoomLevels : null, this._source && this._source.onAdd && this._source.onAdd(w);
+              }
+              onRemove(w) {
+                this.clearTiles(), this._source && this._source.onRemove && this._source.onRemove(w);
+              }
+              loaded() {
+                if (this._sourceErrored) return true;
+                if (!this._sourceLoaded || !this._source.loaded()) return false;
+                if (!(this.used === void 0 && this.usedForTerrain === void 0 || this.used || this.usedForTerrain)) return true;
+                if (!this._updated) return false;
+                for (let w in this._tiles) {
+                  let B = this._tiles[w];
+                  if (B.state !== "loaded" && B.state !== "errored") return false;
+                }
+                return true;
+              }
+              getSource() {
+                return this._source;
+              }
+              pause() {
+                this._paused = true;
+              }
+              resume() {
+                if (!this._paused) return;
+                let w = this._shouldReloadOnResume;
+                this._paused = false, this._shouldReloadOnResume = false, w && this.reload(), this.transform && this.update(this.transform, this.terrain);
+              }
+              _loadTile(w, B, Q) {
+                return a._(this, void 0, void 0, function* () {
+                  try {
+                    yield this._source.loadTile(w), this._tileLoaded(w, B, Q);
+                  } catch (ee) {
+                    w.state = "errored", ee.status !== 404 ? this._source.fire(new a.j(ee, { tile: w })) : this.update(this.transform, this.terrain);
+                  }
+                });
+              }
+              _unloadTile(w) {
+                this._source.unloadTile && this._source.unloadTile(w);
+              }
+              _abortTile(w) {
+                this._source.abortTile && this._source.abortTile(w), this._source.fire(new a.k("dataabort", { tile: w, coord: w.tileID, dataType: "source" }));
+              }
+              serialize() {
+                return this._source.serialize();
+              }
+              prepare(w) {
+                this._source.prepare && this._source.prepare(), this._state.coalesceChanges(this._tiles, this.map ? this.map.painter : null);
+                for (let B in this._tiles) {
+                  let Q = this._tiles[B];
+                  Q.upload(w), Q.prepare(this.map.style.imageManager);
+                }
+              }
+              getIds() {
+                return Object.values(this._tiles).map((w) => w.tileID).sort(er).map((w) => w.key);
+              }
+              getRenderableIds(w) {
+                let B = [];
+                for (let Q in this._tiles) this._isIdRenderable(Q, w) && B.push(this._tiles[Q]);
+                return w ? B.sort((Q, ee) => {
+                  let le = Q.tileID, Oe = ee.tileID, Ze = new a.P(le.canonical.x, le.canonical.y)._rotate(this.transform.angle), st = new a.P(Oe.canonical.x, Oe.canonical.y)._rotate(this.transform.angle);
+                  return le.overscaledZ - Oe.overscaledZ || st.y - Ze.y || st.x - Ze.x;
+                }).map((Q) => Q.tileID.key) : B.map((Q) => Q.tileID).sort(er).map((Q) => Q.key);
+              }
+              hasRenderableParent(w) {
+                let B = this.findLoadedParent(w, 0);
+                return !!B && this._isIdRenderable(B.tileID.key);
+              }
+              _isIdRenderable(w, B) {
+                return this._tiles[w] && this._tiles[w].hasData() && !this._coveredTiles[w] && (B || !this._tiles[w].holdingForFade());
+              }
+              reload() {
+                if (this._paused) this._shouldReloadOnResume = true;
+                else {
+                  this._cache.reset();
+                  for (let w in this._tiles) this._tiles[w].state !== "errored" && this._reloadTile(w, "reloading");
+                }
+              }
+              _reloadTile(w, B) {
+                return a._(this, void 0, void 0, function* () {
+                  let Q = this._tiles[w];
+                  Q && (Q.state !== "loading" && (Q.state = B), yield this._loadTile(Q, w, B));
+                });
+              }
+              _tileLoaded(w, B, Q) {
+                w.timeAdded = u.now(), Q === "expired" && (w.refreshedUponExpiration = true), this._setTileReloadTimer(B, w), this.getSource().type === "raster-dem" && w.dem && this._backfillDEM(w), this._state.initializeTileState(w, this.map ? this.map.painter : null), w.aborted || this._source.fire(new a.k("data", { dataType: "source", tile: w, coord: w.tileID }));
+              }
+              _backfillDEM(w) {
+                let B = this.getRenderableIds();
+                for (let ee = 0; ee < B.length; ee++) {
+                  let le = B[ee];
+                  if (w.neighboringTiles && w.neighboringTiles[le]) {
+                    let Oe = this.getTileByID(le);
+                    Q(w, Oe), Q(Oe, w);
+                  }
+                }
+                function Q(ee, le) {
+                  ee.needsHillshadePrepare = true, ee.needsTerrainPrepare = true;
+                  let Oe = le.tileID.canonical.x - ee.tileID.canonical.x, Ze = le.tileID.canonical.y - ee.tileID.canonical.y, st = Math.pow(2, ee.tileID.canonical.z), Tt = le.tileID.key;
+                  Oe === 0 && Ze === 0 || Math.abs(Ze) > 1 || (Math.abs(Oe) > 1 && (Math.abs(Oe + st) === 1 ? Oe += st : Math.abs(Oe - st) === 1 && (Oe -= st)), le.dem && ee.dem && (ee.dem.backfillBorder(le.dem, Oe, Ze), ee.neighboringTiles && ee.neighboringTiles[Tt] && (ee.neighboringTiles[Tt].backfilled = true)));
+                }
+              }
+              getTile(w) {
+                return this.getTileByID(w.key);
+              }
+              getTileByID(w) {
+                return this._tiles[w];
+              }
+              _retainLoadedChildren(w, B, Q, ee) {
+                for (let le in this._tiles) {
+                  let Oe = this._tiles[le];
+                  if (ee[le] || !Oe.hasData() || Oe.tileID.overscaledZ <= B || Oe.tileID.overscaledZ > Q) continue;
+                  let Ze = Oe.tileID;
+                  for (; Oe && Oe.tileID.overscaledZ > B + 1; ) {
+                    let Tt = Oe.tileID.scaledTo(Oe.tileID.overscaledZ - 1);
+                    Oe = this._tiles[Tt.key], Oe && Oe.hasData() && (Ze = Tt);
+                  }
+                  let st = Ze;
+                  for (; st.overscaledZ > B; ) if (st = st.scaledTo(st.overscaledZ - 1), w[st.key]) {
+                    ee[Ze.key] = Ze;
+                    break;
+                  }
+                }
+              }
+              findLoadedParent(w, B) {
+                if (w.key in this._loadedParentTiles) {
+                  let Q = this._loadedParentTiles[w.key];
+                  return Q && Q.tileID.overscaledZ >= B ? Q : null;
+                }
+                for (let Q = w.overscaledZ - 1; Q >= B; Q--) {
+                  let ee = w.scaledTo(Q), le = this._getLoadedTile(ee);
+                  if (le) return le;
+                }
+              }
+              findLoadedSibling(w) {
+                return this._getLoadedTile(w);
+              }
+              _getLoadedTile(w) {
+                let B = this._tiles[w.key];
+                return B && B.hasData() ? B : this._cache.getByKey(w.wrapped().key);
+              }
+              updateCacheSize(w) {
+                let B = Math.ceil(w.width / this._source.tileSize) + 1, Q = Math.ceil(w.height / this._source.tileSize) + 1, ee = Math.floor(B * Q * (this._maxTileCacheZoomLevels === null ? a.a.MAX_TILE_CACHE_ZOOM_LEVELS : this._maxTileCacheZoomLevels)), le = typeof this._maxTileCacheSize == "number" ? Math.min(this._maxTileCacheSize, ee) : ee;
+                this._cache.setMaxSize(le);
+              }
+              handleWrapJump(w) {
+                let B = Math.round((w - (this._prevLng === void 0 ? w : this._prevLng)) / 360);
+                if (this._prevLng = w, B) {
+                  let Q = {};
+                  for (let ee in this._tiles) {
+                    let le = this._tiles[ee];
+                    le.tileID = le.tileID.unwrapTo(le.tileID.wrap + B), Q[le.tileID.key] = le;
+                  }
+                  this._tiles = Q;
+                  for (let ee in this._timers) clearTimeout(this._timers[ee]), delete this._timers[ee];
+                  for (let ee in this._tiles) this._setTileReloadTimer(ee, this._tiles[ee]);
+                }
+              }
+              _updateCoveredAndRetainedTiles(w, B, Q, ee, le, Oe) {
+                let Ze = {}, st = {}, Tt = Object.keys(w), Yt = u.now();
+                for (let Kt of Tt) {
+                  let xr = w[Kt], Ir = this._tiles[Kt];
+                  if (!Ir || Ir.fadeEndTime !== 0 && Ir.fadeEndTime <= Yt) continue;
+                  let ve = this.findLoadedParent(xr, B), be = this.findLoadedSibling(xr), Re = ve || be || null;
+                  Re && (this._addTile(Re.tileID), Ze[Re.tileID.key] = Re.tileID), st[Kt] = xr;
+                }
+                this._retainLoadedChildren(st, ee, Q, w);
+                for (let Kt in Ze) w[Kt] || (this._coveredTiles[Kt] = true, w[Kt] = Ze[Kt]);
+                if (Oe) {
+                  let Kt = {}, xr = {};
+                  for (let Ir of le) this._tiles[Ir.key].hasData() ? Kt[Ir.key] = Ir : xr[Ir.key] = Ir;
+                  for (let Ir in xr) {
+                    let ve = xr[Ir].children(this._source.maxzoom);
+                    this._tiles[ve[0].key] && this._tiles[ve[1].key] && this._tiles[ve[2].key] && this._tiles[ve[3].key] && (Kt[ve[0].key] = w[ve[0].key] = ve[0], Kt[ve[1].key] = w[ve[1].key] = ve[1], Kt[ve[2].key] = w[ve[2].key] = ve[2], Kt[ve[3].key] = w[ve[3].key] = ve[3], delete xr[Ir]);
+                  }
+                  for (let Ir in xr) {
+                    let ve = xr[Ir], be = this.findLoadedParent(ve, this._source.minzoom), Re = this.findLoadedSibling(ve), qe = be || Re || null;
+                    if (qe) {
+                      Kt[qe.tileID.key] = w[qe.tileID.key] = qe.tileID;
+                      for (let et in Kt) Kt[et].isChildOf(qe.tileID) && delete Kt[et];
+                    }
+                  }
+                  for (let Ir in this._tiles) Kt[Ir] || (this._coveredTiles[Ir] = true);
+                }
+              }
+              update(w, B) {
+                if (!this._sourceLoaded || this._paused) return;
+                let Q;
+                this.transform = w, this.terrain = B, this.updateCacheSize(w), this.handleWrapJump(this.transform.center.lng), this._coveredTiles = {}, this.used || this.usedForTerrain ? this._source.tileID ? Q = w.getVisibleUnwrappedCoordinates(this._source.tileID).map((Yt) => new a.S(Yt.canonical.z, Yt.wrap, Yt.canonical.z, Yt.canonical.x, Yt.canonical.y)) : (Q = w.coveringTiles({ tileSize: this.usedForTerrain ? this.tileSize : this._source.tileSize, minzoom: this._source.minzoom, maxzoom: this._source.maxzoom, roundZoom: !this.usedForTerrain && this._source.roundZoom, reparseOverscaled: this._source.reparseOverscaled, terrain: B }), this._source.hasTile && (Q = Q.filter((Yt) => this._source.hasTile(Yt)))) : Q = [];
+                let ee = w.coveringZoomLevel(this._source), le = Math.max(ee - mt.maxOverzooming, this._source.minzoom), Oe = Math.max(ee + mt.maxUnderzooming, this._source.minzoom);
+                if (this.usedForTerrain) {
+                  let Yt = {};
+                  for (let Kt of Q) if (Kt.canonical.z > this._source.minzoom) {
+                    let xr = Kt.scaledTo(Kt.canonical.z - 1);
+                    Yt[xr.key] = xr;
+                    let Ir = Kt.scaledTo(Math.max(this._source.minzoom, Math.min(Kt.canonical.z, 5)));
+                    Yt[Ir.key] = Ir;
+                  }
+                  Q = Q.concat(Object.values(Yt));
+                }
+                let Ze = Q.length === 0 && !this._updated && this._didEmitContent;
+                this._updated = true, Ze && this.fire(new a.k("data", { sourceDataType: "idle", dataType: "source", sourceId: this.id }));
+                let st = this._updateRetainedTiles(Q, ee);
+                lr(this._source.type) && this._updateCoveredAndRetainedTiles(st, le, Oe, ee, Q, B);
+                for (let Yt in st) this._tiles[Yt].clearFadeHold();
+                let Tt = a.ab(this._tiles, st);
+                for (let Yt of Tt) {
+                  let Kt = this._tiles[Yt];
+                  Kt.hasSymbolBuckets && !Kt.holdingForFade() ? Kt.setHoldDuration(this.map._fadeDuration) : Kt.hasSymbolBuckets && !Kt.symbolFadeFinished() || this._removeTile(Yt);
+                }
+                this._updateLoadedParentTileCache(), this._updateLoadedSiblingTileCache();
+              }
+              releaseSymbolFadeTiles() {
+                for (let w in this._tiles) this._tiles[w].holdingForFade() && this._removeTile(w);
+              }
+              _updateRetainedTiles(w, B) {
+                var Q;
+                let ee = {}, le = {}, Oe = Math.max(B - mt.maxOverzooming, this._source.minzoom), Ze = Math.max(B + mt.maxUnderzooming, this._source.minzoom), st = {};
+                for (let Tt of w) {
+                  let Yt = this._addTile(Tt);
+                  ee[Tt.key] = Tt, Yt.hasData() || B < this._source.maxzoom && (st[Tt.key] = Tt);
+                }
+                this._retainLoadedChildren(st, B, Ze, ee);
+                for (let Tt of w) {
+                  let Yt = this._tiles[Tt.key];
+                  if (Yt.hasData()) continue;
+                  if (B + 1 > this._source.maxzoom) {
+                    let xr = Tt.children(this._source.maxzoom)[0], Ir = this.getTile(xr);
+                    if (Ir && Ir.hasData()) {
+                      ee[xr.key] = xr;
+                      continue;
+                    }
+                  } else {
+                    let xr = Tt.children(this._source.maxzoom);
+                    if (ee[xr[0].key] && ee[xr[1].key] && ee[xr[2].key] && ee[xr[3].key]) continue;
+                  }
+                  let Kt = Yt.wasRequested();
+                  for (let xr = Tt.overscaledZ - 1; xr >= Oe; --xr) {
+                    let Ir = Tt.scaledTo(xr);
+                    if (le[Ir.key]) break;
+                    if (le[Ir.key] = true, Yt = this.getTile(Ir), !Yt && Kt && (Yt = this._addTile(Ir)), Yt) {
+                      let ve = Yt.hasData();
+                      if ((ve || !(!((Q = this.map) === null || Q === void 0) && Q.cancelPendingTileRequestsWhileZooming) || Kt) && (ee[Ir.key] = Ir), Kt = Yt.wasRequested(), ve) break;
+                    }
+                  }
+                }
+                return ee;
+              }
+              _updateLoadedParentTileCache() {
+                this._loadedParentTiles = {};
+                for (let w in this._tiles) {
+                  let B = [], Q, ee = this._tiles[w].tileID;
+                  for (; ee.overscaledZ > 0; ) {
+                    if (ee.key in this._loadedParentTiles) {
+                      Q = this._loadedParentTiles[ee.key];
+                      break;
+                    }
+                    B.push(ee.key);
+                    let le = ee.scaledTo(ee.overscaledZ - 1);
+                    if (Q = this._getLoadedTile(le), Q) break;
+                    ee = le;
+                  }
+                  for (let le of B) this._loadedParentTiles[le] = Q;
+                }
+              }
+              _updateLoadedSiblingTileCache() {
+                this._loadedSiblingTiles = {};
+                for (let w in this._tiles) {
+                  let B = this._tiles[w].tileID, Q = this._getLoadedTile(B);
+                  this._loadedSiblingTiles[B.key] = Q;
+                }
+              }
+              _addTile(w) {
+                let B = this._tiles[w.key];
+                if (B) return B;
+                B = this._cache.getAndRemove(w), B && (this._setTileReloadTimer(w.key, B), B.tileID = w, this._state.initializeTileState(B, this.map ? this.map.painter : null), this._cacheTimers[w.key] && (clearTimeout(this._cacheTimers[w.key]), delete this._cacheTimers[w.key], this._setTileReloadTimer(w.key, B)));
+                let Q = B;
+                return B || (B = new Gt(w, this._source.tileSize * w.overscaleFactor()), this._loadTile(B, w.key, B.state)), B.uses++, this._tiles[w.key] = B, Q || this._source.fire(new a.k("dataloading", { tile: B, coord: B.tileID, dataType: "source" })), B;
+              }
+              _setTileReloadTimer(w, B) {
+                w in this._timers && (clearTimeout(this._timers[w]), delete this._timers[w]);
+                let Q = B.getExpiryTimeout();
+                Q && (this._timers[w] = setTimeout(() => {
+                  this._reloadTile(w, "expired"), delete this._timers[w];
+                }, Q));
+              }
+              _removeTile(w) {
+                let B = this._tiles[w];
+                B && (B.uses--, delete this._tiles[w], this._timers[w] && (clearTimeout(this._timers[w]), delete this._timers[w]), B.uses > 0 || (B.hasData() && B.state !== "reloading" ? this._cache.add(B.tileID, B, B.getExpiryTimeout()) : (B.aborted = true, this._abortTile(B), this._unloadTile(B))));
+              }
+              _dataHandler(w) {
+                let B = w.sourceDataType;
+                w.dataType === "source" && B === "metadata" && (this._sourceLoaded = true), this._sourceLoaded && !this._paused && w.dataType === "source" && B === "content" && (this.reload(), this.transform && this.update(this.transform, this.terrain), this._didEmitContent = true);
+              }
+              clearTiles() {
+                this._shouldReloadOnResume = false, this._paused = false;
+                for (let w in this._tiles) this._removeTile(w);
+                this._cache.reset();
+              }
+              tilesIn(w, B, Q) {
+                let ee = [], le = this.transform;
+                if (!le) return ee;
+                let Oe = Q ? le.getCameraQueryGeometry(w) : w, Ze = w.map((ve) => le.pointCoordinate(ve, this.terrain)), st = Oe.map((ve) => le.pointCoordinate(ve, this.terrain)), Tt = this.getIds(), Yt = 1 / 0, Kt = 1 / 0, xr = -1 / 0, Ir = -1 / 0;
+                for (let ve of st) Yt = Math.min(Yt, ve.x), Kt = Math.min(Kt, ve.y), xr = Math.max(xr, ve.x), Ir = Math.max(Ir, ve.y);
+                for (let ve = 0; ve < Tt.length; ve++) {
+                  let be = this._tiles[Tt[ve]];
+                  if (be.holdingForFade()) continue;
+                  let Re = be.tileID, qe = Math.pow(2, le.zoom - be.tileID.overscaledZ), et = B * be.queryPadding * a.X / be.tileSize / qe, Xe = [Re.getTilePoint(new a.Z(Yt, Kt)), Re.getTilePoint(new a.Z(xr, Ir))];
+                  if (Xe[0].x - et < a.X && Xe[0].y - et < a.X && Xe[1].x + et >= 0 && Xe[1].y + et >= 0) {
+                    let it = Ze.map((Ht) => Re.getTilePoint(Ht)), Ft = st.map((Ht) => Re.getTilePoint(Ht));
+                    ee.push({ tile: be, tileID: Re, queryGeometry: it, cameraQueryGeometry: Ft, scale: qe });
+                  }
+                }
+                return ee;
+              }
+              getVisibleCoordinates(w) {
+                let B = this.getRenderableIds(w).map((Q) => this._tiles[Q].tileID);
+                for (let Q of B) Q.posMatrix = this.transform.calculatePosMatrix(Q.toUnwrapped());
+                return B;
+              }
+              hasTransition() {
+                if (this._source.hasTransition()) return true;
+                if (lr(this._source.type)) {
+                  let w = u.now();
+                  for (let B in this._tiles) if (this._tiles[B].fadeEndTime >= w) return true;
+                }
+                return false;
+              }
+              setFeatureState(w, B, Q) {
+                this._state.updateState(w = w || "_geojsonTileLayer", B, Q);
+              }
+              removeFeatureState(w, B, Q) {
+                this._state.removeFeatureState(w = w || "_geojsonTileLayer", B, Q);
+              }
+              getFeatureState(w, B) {
+                return this._state.getState(w = w || "_geojsonTileLayer", B);
+              }
+              setDependencies(w, B, Q) {
+                let ee = this._tiles[w];
+                ee && ee.setDependencies(B, Q);
+              }
+              reloadTilesForDependencies(w, B) {
+                for (let Q in this._tiles) this._tiles[Q].hasDependency(w, B) && this._reloadTile(Q, "reloading");
+                this._cache.filter((Q) => !Q.hasDependency(w, B));
+              }
+            }
+            function er(ue, w) {
+              let B = Math.abs(2 * ue.wrap) - +(ue.wrap < 0), Q = Math.abs(2 * w.wrap) - +(w.wrap < 0);
+              return ue.overscaledZ - w.overscaledZ || Q - B || w.canonical.y - ue.canonical.y || w.canonical.x - ue.canonical.x;
+            }
+            function lr(ue) {
+              return ue === "raster" || ue === "image" || ue === "video";
+            }
+            mt.maxOverzooming = 10, mt.maxUnderzooming = 3;
+            class wr {
+              constructor(w, B) {
+                this.reset(w, B);
+              }
+              reset(w, B) {
+                this.points = w || [], this._distances = [0];
+                for (let Q = 1; Q < this.points.length; Q++) this._distances[Q] = this._distances[Q - 1] + this.points[Q].dist(this.points[Q - 1]);
+                this.length = this._distances[this._distances.length - 1], this.padding = Math.min(B || 0, 0.5 * this.length), this.paddedLength = this.length - 2 * this.padding;
+              }
+              lerp(w) {
+                if (this.points.length === 1) return this.points[0];
+                w = a.ac(w, 0, 1);
+                let B = 1, Q = this._distances[B], ee = w * this.paddedLength + this.padding;
+                for (; Q < ee && B < this._distances.length; ) Q = this._distances[++B];
+                let le = B - 1, Oe = this._distances[le], Ze = Q - Oe, st = Ze > 0 ? (ee - Oe) / Ze : 0;
+                return this.points[le].mult(1 - st).add(this.points[B].mult(st));
+              }
+            }
+            function Lr(ue, w) {
+              let B = true;
+              return ue === "always" || ue !== "never" && w !== "never" || (B = false), B;
+            }
+            class ti {
+              constructor(w, B, Q) {
+                let ee = this.boxCells = [], le = this.circleCells = [];
+                this.xCellCount = Math.ceil(w / Q), this.yCellCount = Math.ceil(B / Q);
+                for (let Oe = 0; Oe < this.xCellCount * this.yCellCount; Oe++) ee.push([]), le.push([]);
+                this.circleKeys = [], this.boxKeys = [], this.bboxes = [], this.circles = [], this.width = w, this.height = B, this.xScale = this.xCellCount / w, this.yScale = this.yCellCount / B, this.boxUid = 0, this.circleUid = 0;
+              }
+              keysLength() {
+                return this.boxKeys.length + this.circleKeys.length;
+              }
+              insert(w, B, Q, ee, le) {
+                this._forEachCell(B, Q, ee, le, this._insertBoxCell, this.boxUid++), this.boxKeys.push(w), this.bboxes.push(B), this.bboxes.push(Q), this.bboxes.push(ee), this.bboxes.push(le);
+              }
+              insertCircle(w, B, Q, ee) {
+                this._forEachCell(B - ee, Q - ee, B + ee, Q + ee, this._insertCircleCell, this.circleUid++), this.circleKeys.push(w), this.circles.push(B), this.circles.push(Q), this.circles.push(ee);
+              }
+              _insertBoxCell(w, B, Q, ee, le, Oe) {
+                this.boxCells[le].push(Oe);
+              }
+              _insertCircleCell(w, B, Q, ee, le, Oe) {
+                this.circleCells[le].push(Oe);
+              }
+              _query(w, B, Q, ee, le, Oe, Ze) {
+                if (Q < 0 || w > this.width || ee < 0 || B > this.height) return [];
+                let st = [];
+                if (w <= 0 && B <= 0 && this.width <= Q && this.height <= ee) {
+                  if (le) return [{ key: null, x1: w, y1: B, x2: Q, y2: ee }];
+                  for (let Tt = 0; Tt < this.boxKeys.length; Tt++) st.push({ key: this.boxKeys[Tt], x1: this.bboxes[4 * Tt], y1: this.bboxes[4 * Tt + 1], x2: this.bboxes[4 * Tt + 2], y2: this.bboxes[4 * Tt + 3] });
+                  for (let Tt = 0; Tt < this.circleKeys.length; Tt++) {
+                    let Yt = this.circles[3 * Tt], Kt = this.circles[3 * Tt + 1], xr = this.circles[3 * Tt + 2];
+                    st.push({ key: this.circleKeys[Tt], x1: Yt - xr, y1: Kt - xr, x2: Yt + xr, y2: Kt + xr });
+                  }
+                } else this._forEachCell(w, B, Q, ee, this._queryCell, st, { hitTest: le, overlapMode: Oe, seenUids: { box: {}, circle: {} } }, Ze);
+                return st;
+              }
+              query(w, B, Q, ee) {
+                return this._query(w, B, Q, ee, false, null);
+              }
+              hitTest(w, B, Q, ee, le, Oe) {
+                return this._query(w, B, Q, ee, true, le, Oe).length > 0;
+              }
+              hitTestCircle(w, B, Q, ee, le) {
+                let Oe = w - Q, Ze = w + Q, st = B - Q, Tt = B + Q;
+                if (Ze < 0 || Oe > this.width || Tt < 0 || st > this.height) return false;
+                let Yt = [];
+                return this._forEachCell(Oe, st, Ze, Tt, this._queryCellCircle, Yt, { hitTest: true, overlapMode: ee, circle: { x: w, y: B, radius: Q }, seenUids: { box: {}, circle: {} } }, le), Yt.length > 0;
+              }
+              _queryCell(w, B, Q, ee, le, Oe, Ze, st) {
+                let { seenUids: Tt, hitTest: Yt, overlapMode: Kt } = Ze, xr = this.boxCells[le];
+                if (xr !== null) {
+                  let ve = this.bboxes;
+                  for (let be of xr) if (!Tt.box[be]) {
+                    Tt.box[be] = true;
+                    let Re = 4 * be, qe = this.boxKeys[be];
+                    if (w <= ve[Re + 2] && B <= ve[Re + 3] && Q >= ve[Re + 0] && ee >= ve[Re + 1] && (!st || st(qe)) && (!Yt || !Lr(Kt, qe.overlapMode)) && (Oe.push({ key: qe, x1: ve[Re], y1: ve[Re + 1], x2: ve[Re + 2], y2: ve[Re + 3] }), Yt)) return true;
+                  }
+                }
+                let Ir = this.circleCells[le];
+                if (Ir !== null) {
+                  let ve = this.circles;
+                  for (let be of Ir) if (!Tt.circle[be]) {
+                    Tt.circle[be] = true;
+                    let Re = 3 * be, qe = this.circleKeys[be];
+                    if (this._circleAndRectCollide(ve[Re], ve[Re + 1], ve[Re + 2], w, B, Q, ee) && (!st || st(qe)) && (!Yt || !Lr(Kt, qe.overlapMode))) {
+                      let et = ve[Re], Xe = ve[Re + 1], it = ve[Re + 2];
+                      if (Oe.push({ key: qe, x1: et - it, y1: Xe - it, x2: et + it, y2: Xe + it }), Yt) return true;
+                    }
+                  }
+                }
+                return false;
+              }
+              _queryCellCircle(w, B, Q, ee, le, Oe, Ze, st) {
+                let { circle: Tt, seenUids: Yt, overlapMode: Kt } = Ze, xr = this.boxCells[le];
+                if (xr !== null) {
+                  let ve = this.bboxes;
+                  for (let be of xr) if (!Yt.box[be]) {
+                    Yt.box[be] = true;
+                    let Re = 4 * be, qe = this.boxKeys[be];
+                    if (this._circleAndRectCollide(Tt.x, Tt.y, Tt.radius, ve[Re + 0], ve[Re + 1], ve[Re + 2], ve[Re + 3]) && (!st || st(qe)) && !Lr(Kt, qe.overlapMode)) return Oe.push(true), true;
+                  }
+                }
+                let Ir = this.circleCells[le];
+                if (Ir !== null) {
+                  let ve = this.circles;
+                  for (let be of Ir) if (!Yt.circle[be]) {
+                    Yt.circle[be] = true;
+                    let Re = 3 * be, qe = this.circleKeys[be];
+                    if (this._circlesCollide(ve[Re], ve[Re + 1], ve[Re + 2], Tt.x, Tt.y, Tt.radius) && (!st || st(qe)) && !Lr(Kt, qe.overlapMode)) return Oe.push(true), true;
+                  }
+                }
+              }
+              _forEachCell(w, B, Q, ee, le, Oe, Ze, st) {
+                let Tt = this._convertToXCellCoord(w), Yt = this._convertToYCellCoord(B), Kt = this._convertToXCellCoord(Q), xr = this._convertToYCellCoord(ee);
+                for (let Ir = Tt; Ir <= Kt; Ir++) for (let ve = Yt; ve <= xr; ve++) if (le.call(this, w, B, Q, ee, this.xCellCount * ve + Ir, Oe, Ze, st)) return;
+              }
+              _convertToXCellCoord(w) {
+                return Math.max(0, Math.min(this.xCellCount - 1, Math.floor(w * this.xScale)));
+              }
+              _convertToYCellCoord(w) {
+                return Math.max(0, Math.min(this.yCellCount - 1, Math.floor(w * this.yScale)));
+              }
+              _circlesCollide(w, B, Q, ee, le, Oe) {
+                let Ze = ee - w, st = le - B, Tt = Q + Oe;
+                return Tt * Tt > Ze * Ze + st * st;
+              }
+              _circleAndRectCollide(w, B, Q, ee, le, Oe, Ze) {
+                let st = (Oe - ee) / 2, Tt = Math.abs(w - (ee + st));
+                if (Tt > st + Q) return false;
+                let Yt = (Ze - le) / 2, Kt = Math.abs(B - (le + Yt));
+                if (Kt > Yt + Q) return false;
+                if (Tt <= st || Kt <= Yt) return true;
+                let xr = Tt - st, Ir = Kt - Yt;
+                return xr * xr + Ir * Ir <= Q * Q;
+              }
+            }
+            function Br(ue, w, B, Q, ee) {
+              let le = a.H();
+              return w ? (a.K(le, le, [1 / ee, 1 / ee, 1]), B || a.ad(le, le, Q.angle)) : a.L(le, Q.labelPlaneMatrix, ue), le;
+            }
+            function Vr(ue, w, B, Q, ee) {
+              if (w) {
+                let le = a.ae(ue);
+                return a.K(le, le, [ee, ee, 1]), B || a.ad(le, le, -Q.angle), le;
+              }
+              return Q.glCoordMatrix;
+            }
+            function dt(ue, w, B, Q) {
+              let ee;
+              Q ? (ee = [ue, w, Q(ue, w), 1], a.af(ee, ee, B)) : (ee = [ue, w, 0, 1], $r(ee, ee, B));
+              let le = ee[3];
+              return { point: new a.P(ee[0] / le, ee[1] / le), signedDistanceFromCamera: le, isOccluded: false };
+            }
+            function Ge(ue, w) {
+              return 0.5 + ue / w * 0.5;
+            }
+            function Je(ue, w) {
+              return ue.x >= -w[0] && ue.x <= w[0] && ue.y >= -w[1] && ue.y <= w[1];
+            }
+            function We(ue, w, B, Q, ee, le, Oe, Ze, st, Tt, Yt, Kt, xr, Ir, ve) {
+              let be = Q ? ue.textSizeData : ue.iconSizeData, Re = a.ag(be, B.transform.zoom), qe = [256 / B.width * 2 + 1, 256 / B.height * 2 + 1], et = Q ? ue.text.dynamicLayoutVertexArray : ue.icon.dynamicLayoutVertexArray;
+              et.clear();
+              let Xe = ue.lineVertexArray, it = Q ? ue.text.placedSymbolArray : ue.icon.placedSymbolArray, Ft = B.transform.width / B.transform.height, Ht = false;
+              for (let tr = 0; tr < it.length; tr++) {
+                let dr = it.get(tr);
+                if (dr.hidden || dr.writingMode === a.ah.vertical && !Ht) {
+                  pi(dr.numGlyphs, et);
+                  continue;
+                }
+                Ht = false;
+                let Sr = dt(dr.anchorX, dr.anchorY, w, ve);
+                if (!Je(Sr.point, qe)) {
+                  pi(dr.numGlyphs, et);
+                  continue;
+                }
+                let Or = Ge(B.transform.cameraToCenterDistance, Sr.signedDistanceFromCamera), Wr = a.ai(be, Re, dr), ni = Oe ? Wr / Or : Wr * Or, Pi = { getElevation: ve, labelPlaneMatrix: ee, lineVertexArray: Xe, pitchWithMap: Oe, projectionCache: { projections: {}, offsets: {}, cachedAnchorPoint: void 0, anyProjectionOccluded: false }, projection: Tt, tileAnchorPoint: new a.P(dr.anchorX, dr.anchorY), unwrappedTileID: Yt, width: Kt, height: xr, translation: Ir }, cn = Ie(Pi, dr, ni, false, Ze, w, le, ue.glyphOffsetArray, et, Ft, st);
+                Ht = cn.useVertical, (cn.notEnoughRoom || Ht || cn.needsFlipping && Ie(Pi, dr, ni, true, Ze, w, le, ue.glyphOffsetArray, et, Ft, st).notEnoughRoom) && pi(dr.numGlyphs, et);
+              }
+              Q ? ue.text.dynamicLayoutVertexBuffer.updateData(et) : ue.icon.dynamicLayoutVertexBuffer.updateData(et);
+            }
+            function tt(ue, w, B, Q, ee, le, Oe, Ze) {
+              let st = le.glyphStartIndex + le.numGlyphs, Tt = le.lineStartIndex, Yt = le.lineStartIndex + le.lineLength, Kt = w.getoffsetX(le.glyphStartIndex), xr = w.getoffsetX(st - 1), Ir = vr(ue * Kt, B, Q, ee, le.segment, Tt, Yt, Ze, Oe);
+              if (!Ir) return null;
+              let ve = vr(ue * xr, B, Q, ee, le.segment, Tt, Yt, Ze, Oe);
+              return ve ? Ze.projectionCache.anyProjectionOccluded ? null : { first: Ir, last: ve } : null;
+            }
+            function xt(ue, w, B, Q) {
+              return ue === a.ah.horizontal && Math.abs(B.y - w.y) > Math.abs(B.x - w.x) * Q ? { useVertical: true } : (ue === a.ah.vertical ? w.y < B.y : w.x > B.x) ? { needsFlipping: true } : null;
+            }
+            function Ie(ue, w, B, Q, ee, le, Oe, Ze, st, Tt, Yt) {
+              let Kt = B / 24, xr = w.lineOffsetX * Kt, Ir = w.lineOffsetY * Kt, ve;
+              if (w.numGlyphs > 1) {
+                let be = w.glyphStartIndex + w.numGlyphs, Re = w.lineStartIndex, qe = w.lineStartIndex + w.lineLength, et = tt(Kt, Ze, xr, Ir, Q, w, Yt, ue);
+                if (!et) return { notEnoughRoom: true };
+                let Xe = dt(et.first.point.x, et.first.point.y, Oe, ue.getElevation).point, it = dt(et.last.point.x, et.last.point.y, Oe, ue.getElevation).point;
+                if (ee && !Q) {
+                  let Ft = xt(w.writingMode, Xe, it, Tt);
+                  if (Ft) return Ft;
+                }
+                ve = [et.first];
+                for (let Ft = w.glyphStartIndex + 1; Ft < be - 1; Ft++) ve.push(vr(Kt * Ze.getoffsetX(Ft), xr, Ir, Q, w.segment, Re, qe, ue, Yt));
+                ve.push(et.last);
+              } else {
+                if (ee && !Q) {
+                  let Re = dt(ue.tileAnchorPoint.x, ue.tileAnchorPoint.y, le, ue.getElevation).point, qe = w.lineStartIndex + w.segment + 1, et = new a.P(ue.lineVertexArray.getx(qe), ue.lineVertexArray.gety(qe)), Xe = dt(et.x, et.y, le, ue.getElevation), it = Xe.signedDistanceFromCamera > 0 ? Xe.point : function(Ht, tr, dr, Sr, Or, Wr) {
+                    return xe(Ht, tr, dr, 1, Or, Wr);
+                  }(ue.tileAnchorPoint, et, Re, 0, le, ue), Ft = xt(w.writingMode, Re, it, Tt);
+                  if (Ft) return Ft;
+                }
+                let be = vr(Kt * Ze.getoffsetX(w.glyphStartIndex), xr, Ir, Q, w.segment, w.lineStartIndex, w.lineStartIndex + w.lineLength, ue, Yt);
+                if (!be || ue.projectionCache.anyProjectionOccluded) return { notEnoughRoom: true };
+                ve = [be];
+              }
+              for (let be of ve) a.aj(st, be.point, be.angle);
+              return {};
+            }
+            function xe(ue, w, B, Q, ee, le) {
+              let Oe = ue.add(ue.sub(w)._unit()), Ze = ee !== void 0 ? dt(Oe.x, Oe.y, ee, le.getElevation).point : vt(Oe.x, Oe.y, le).point, st = B.sub(Ze);
+              return B.add(st._mult(Q / st.mag()));
+            }
+            function ke(ue, w, B) {
+              let Q = w.projectionCache;
+              if (Q.projections[ue]) return Q.projections[ue];
+              let ee = new a.P(w.lineVertexArray.getx(ue), w.lineVertexArray.gety(ue)), le = vt(ee.x, ee.y, w);
+              if (le.signedDistanceFromCamera > 0) return Q.projections[ue] = le.point, Q.anyProjectionOccluded = Q.anyProjectionOccluded || le.isOccluded, le.point;
+              let Oe = ue - B.direction;
+              return function(Ze, st, Tt, Yt, Kt) {
+                return xe(Ze, st, Tt, Yt, void 0, Kt);
+              }(B.distanceFromAnchor === 0 ? w.tileAnchorPoint : new a.P(w.lineVertexArray.getx(Oe), w.lineVertexArray.gety(Oe)), ee, B.previousVertex, B.absOffsetX - B.distanceFromAnchor + 1, w);
+            }
+            function vt(ue, w, B) {
+              let Q = ue + B.translation[0], ee = w + B.translation[1], le;
+              return !B.pitchWithMap && B.projection.useSpecialProjectionForSymbols ? (le = B.projection.projectTileCoordinates(Q, ee, B.unwrappedTileID, B.getElevation), le.point.x = (0.5 * le.point.x + 0.5) * B.width, le.point.y = (0.5 * -le.point.y + 0.5) * B.height) : (le = dt(Q, ee, B.labelPlaneMatrix, B.getElevation), le.isOccluded = false), le;
+            }
+            function ir(ue, w, B) {
+              return ue._unit()._perp()._mult(w * B);
+            }
+            function ar(ue, w, B, Q, ee, le, Oe, Ze, st) {
+              if (Ze.projectionCache.offsets[ue]) return Ze.projectionCache.offsets[ue];
+              let Tt = B.add(w);
+              if (ue + st.direction < Q || ue + st.direction >= ee) return Ze.projectionCache.offsets[ue] = Tt, Tt;
+              let Yt = ke(ue + st.direction, Ze, st), Kt = ir(Yt.sub(B), Oe, st.direction), xr = B.add(Kt), Ir = Yt.add(Kt);
+              return Ze.projectionCache.offsets[ue] = a.ak(le, Tt, xr, Ir) || Tt, Ze.projectionCache.offsets[ue];
+            }
+            function vr(ue, w, B, Q, ee, le, Oe, Ze, st) {
+              let Tt = Q ? ue - w : ue + w, Yt = Tt > 0 ? 1 : -1, Kt = 0;
+              Q && (Yt *= -1, Kt = Math.PI), Yt < 0 && (Kt += Math.PI);
+              let xr, Ir = Yt > 0 ? le + ee : le + ee + 1;
+              Ze.projectionCache.cachedAnchorPoint ? xr = Ze.projectionCache.cachedAnchorPoint : (xr = vt(Ze.tileAnchorPoint.x, Ze.tileAnchorPoint.y, Ze).point, Ze.projectionCache.cachedAnchorPoint = xr);
+              let ve, be, Re = xr, qe = xr, et = 0, Xe = 0, it = Math.abs(Tt), Ft = [], Ht;
+              for (; et + Xe <= it; ) {
+                if (Ir += Yt, Ir < le || Ir >= Oe) return null;
+                et += Xe, qe = Re, be = ve;
+                let Sr = { absOffsetX: it, direction: Yt, distanceFromAnchor: et, previousVertex: qe };
+                if (Re = ke(Ir, Ze, Sr), B === 0) Ft.push(qe), Ht = Re.sub(qe);
+                else {
+                  let Or, Wr = Re.sub(qe);
+                  Or = Wr.mag() === 0 ? ir(ke(Ir + Yt, Ze, Sr).sub(Re), B, Yt) : ir(Wr, B, Yt), be || (be = qe.add(Or)), ve = ar(Ir, Or, Re, le, Oe, be, B, Ze, Sr), Ft.push(be), Ht = ve.sub(be);
+                }
+                Xe = Ht.mag();
+              }
+              let tr = Ht._mult((it - et) / Xe)._add(be || qe), dr = Kt + Math.atan2(Re.y - qe.y, Re.x - qe.x);
+              return Ft.push(tr), { point: tr, angle: st ? dr : 0, path: Ft };
+            }
+            let ii = new Float32Array([-1 / 0, -1 / 0, 0, -1 / 0, -1 / 0, 0, -1 / 0, -1 / 0, 0, -1 / 0, -1 / 0, 0]);
+            function pi(ue, w) {
+              for (let B = 0; B < ue; B++) {
+                let Q = w.length;
+                w.resize(Q + 4), w.float32.set(ii, 3 * Q);
+              }
+            }
+            function $r(ue, w, B) {
+              let Q = w[0], ee = w[1];
+              return ue[0] = B[0] * Q + B[4] * ee + B[12], ue[1] = B[1] * Q + B[5] * ee + B[13], ue[3] = B[3] * Q + B[7] * ee + B[15], ue;
+            }
+            let di = 100;
+            class ji {
+              constructor(w, B, Q = new ti(w.width + 200, w.height + 200, 25), ee = new ti(w.width + 200, w.height + 200, 25)) {
+                this.transform = w, this.mapProjection = B, this.grid = Q, this.ignoredGrid = ee, this.pitchFactor = Math.cos(w._pitch) * w.cameraToCenterDistance, this.screenRightBoundary = w.width + di, this.screenBottomBoundary = w.height + di, this.gridRightBoundary = w.width + 200, this.gridBottomBoundary = w.height + 200, this.perspectiveRatioCutoff = 0.6;
+              }
+              placeCollisionBox(w, B, Q, ee, le, Oe, Ze, st, Tt, Yt, Kt) {
+                let xr = w.anchorPointX + st[0], Ir = w.anchorPointY + st[1], ve = this.projectAndGetPerspectiveRatio(ee, xr, Ir, le, Yt), be = Q * ve.perspectiveRatio, Re;
+                if (Oe || Ze) Re = this._projectCollisionBox(w, be, ee, le, Oe, Ze, st, ve, Yt, Kt);
+                else {
+                  let Ft = ve.point.x + (Kt ? Kt.x * be : 0), Ht = ve.point.y + (Kt ? Kt.y * be : 0);
+                  Re = { allPointsOccluded: false, box: [Ft + w.x1 * be, Ht + w.y1 * be, Ft + w.x2 * be, Ht + w.y2 * be] };
+                }
+                let [qe, et, Xe, it] = Re.box;
+                return this.mapProjection.useSpecialProjectionForSymbols && (Oe ? Re.allPointsOccluded : this.mapProjection.isOccluded(xr, Ir, le)) || ve.perspectiveRatio < this.perspectiveRatioCutoff || !this.isInsideGrid(qe, et, Xe, it) || B !== "always" && this.grid.hitTest(qe, et, Xe, it, B, Tt) ? { box: [qe, et, Xe, it], placeable: false, offscreen: false } : { box: [qe, et, Xe, it], placeable: true, offscreen: this.isOffscreen(qe, et, Xe, it) };
+              }
+              placeCollisionCircles(w, B, Q, ee, le, Oe, Ze, st, Tt, Yt, Kt, xr, Ir, ve, be, Re) {
+                let qe = [], et = new a.P(B.anchorX, B.anchorY), Xe = this.getPerspectiveRatio(Oe, et.x, et.y, Ze, Re), it = (Kt ? le / Xe : le * Xe) / a.ap, Ft = { getElevation: Re, labelPlaneMatrix: st, lineVertexArray: Q, pitchWithMap: Kt, projectionCache: { projections: {}, offsets: {}, cachedAnchorPoint: void 0, anyProjectionOccluded: false }, projection: this.mapProjection, tileAnchorPoint: et, unwrappedTileID: Ze, width: this.transform.width, height: this.transform.height, translation: be }, Ht = tt(it, ee, B.lineOffsetX * it, B.lineOffsetY * it, false, B, false, Ft), tr = false, dr = false, Sr = true;
+                if (Ht) {
+                  let Or = 0.5 * Ir * Xe + ve, Wr = new a.P(-100, -100), ni = new a.P(this.screenRightBoundary, this.screenBottomBoundary), Pi = new wr(), cn = Ht.first, ln = Ht.last, Cn = [];
+                  for (let fa = cn.path.length - 1; fa >= 1; fa--) Cn.push(cn.path[fa]);
+                  for (let fa = 1; fa < ln.path.length; fa++) Cn.push(ln.path[fa]);
+                  let Kn = 2.5 * Or;
+                  if (Tt) {
+                    let fa = this.projectPathToScreenSpace(Cn, Ft, Tt);
+                    Cn = fa.some(($a) => $a.signedDistanceFromCamera <= 0) ? [] : fa.map(($a) => $a.point);
+                  }
+                  let Aa = [];
+                  if (Cn.length > 0) {
+                    let fa = Cn[0].clone(), $a = Cn[0].clone();
+                    for (let Co = 1; Co < Cn.length; Co++) fa.x = Math.min(fa.x, Cn[Co].x), fa.y = Math.min(fa.y, Cn[Co].y), $a.x = Math.max($a.x, Cn[Co].x), $a.y = Math.max($a.y, Cn[Co].y);
+                    Aa = fa.x >= Wr.x && $a.x <= ni.x && fa.y >= Wr.y && $a.y <= ni.y ? [Cn] : $a.x < Wr.x || fa.x > ni.x || $a.y < Wr.y || fa.y > ni.y ? [] : a.al([Cn], Wr.x, Wr.y, ni.x, ni.y);
+                  }
+                  for (let fa of Aa) {
+                    Pi.reset(fa, 0.25 * Or);
+                    let $a = 0;
+                    $a = Pi.length <= 0.5 * Or ? 1 : Math.ceil(Pi.paddedLength / Kn) + 1;
+                    for (let Co = 0; Co < $a; Co++) {
+                      let Qa = Co / Math.max($a - 1, 1), mo = Pi.lerp(Qa), Bo = mo.x + di, Ps = mo.y + di;
+                      qe.push(Bo, Ps, Or, 0);
+                      let Ts = Bo - Or, wo = Ps - Or, To = Bo + Or, hl = Ps + Or;
+                      if (Sr = Sr && this.isOffscreen(Ts, wo, To, hl), dr = dr || this.isInsideGrid(Ts, wo, To, hl), w !== "always" && this.grid.hitTestCircle(Bo, Ps, Or, w, xr) && (tr = true, !Yt)) return { circles: [], offscreen: false, collisionDetected: tr };
+                    }
+                  }
+                }
+                return { circles: !Yt && tr || !dr || Xe < this.perspectiveRatioCutoff ? [] : qe, offscreen: Sr, collisionDetected: tr };
+              }
+              projectPathToScreenSpace(w, B, Q) {
+                return w.map((ee) => dt(ee.x, ee.y, Q, B.getElevation));
+              }
+              queryRenderedSymbols(w) {
+                if (w.length === 0 || this.grid.keysLength() === 0 && this.ignoredGrid.keysLength() === 0) return {};
+                let B = [], Q = 1 / 0, ee = 1 / 0, le = -1 / 0, Oe = -1 / 0;
+                for (let Yt of w) {
+                  let Kt = new a.P(Yt.x + di, Yt.y + di);
+                  Q = Math.min(Q, Kt.x), ee = Math.min(ee, Kt.y), le = Math.max(le, Kt.x), Oe = Math.max(Oe, Kt.y), B.push(Kt);
+                }
+                let Ze = this.grid.query(Q, ee, le, Oe).concat(this.ignoredGrid.query(Q, ee, le, Oe)), st = {}, Tt = {};
+                for (let Yt of Ze) {
+                  let Kt = Yt.key;
+                  if (st[Kt.bucketInstanceId] === void 0 && (st[Kt.bucketInstanceId] = {}), st[Kt.bucketInstanceId][Kt.featureIndex]) continue;
+                  let xr = [new a.P(Yt.x1, Yt.y1), new a.P(Yt.x2, Yt.y1), new a.P(Yt.x2, Yt.y2), new a.P(Yt.x1, Yt.y2)];
+                  a.am(B, xr) && (st[Kt.bucketInstanceId][Kt.featureIndex] = true, Tt[Kt.bucketInstanceId] === void 0 && (Tt[Kt.bucketInstanceId] = []), Tt[Kt.bucketInstanceId].push(Kt.featureIndex));
+                }
+                return Tt;
+              }
+              insertCollisionBox(w, B, Q, ee, le, Oe) {
+                (Q ? this.ignoredGrid : this.grid).insert({ bucketInstanceId: ee, featureIndex: le, collisionGroupID: Oe, overlapMode: B }, w[0], w[1], w[2], w[3]);
+              }
+              insertCollisionCircles(w, B, Q, ee, le, Oe) {
+                let Ze = Q ? this.ignoredGrid : this.grid, st = { bucketInstanceId: ee, featureIndex: le, collisionGroupID: Oe, overlapMode: B };
+                for (let Tt = 0; Tt < w.length; Tt += 4) Ze.insertCircle(st, w[Tt], w[Tt + 1], w[Tt + 2]);
+              }
+              projectAndGetPerspectiveRatio(w, B, Q, ee, le) {
+                let Oe;
+                le ? (Oe = [B, Q, le(B, Q), 1], a.af(Oe, Oe, w)) : (Oe = [B, Q, 0, 1], $r(Oe, Oe, w));
+                let Ze = Oe[3];
+                return { point: new a.P((Oe[0] / Ze + 1) / 2 * this.transform.width + di, (-Oe[1] / Ze + 1) / 2 * this.transform.height + di), perspectiveRatio: 0.5 + this.transform.cameraToCenterDistance / Ze * 0.5, isOccluded: false, signedDistanceFromCamera: Ze };
+              }
+              getPerspectiveRatio(w, B, Q, ee, le) {
+                let Oe = this.mapProjection.useSpecialProjectionForSymbols ? this.mapProjection.projectTileCoordinates(B, Q, ee, le) : dt(B, Q, w, le);
+                return 0.5 + this.transform.cameraToCenterDistance / Oe.signedDistanceFromCamera * 0.5;
+              }
+              isOffscreen(w, B, Q, ee) {
+                return Q < di || w >= this.screenRightBoundary || ee < di || B > this.screenBottomBoundary;
+              }
+              isInsideGrid(w, B, Q, ee) {
+                return Q >= 0 && w < this.gridRightBoundary && ee >= 0 && B < this.gridBottomBoundary;
+              }
+              getViewportMatrix() {
+                let w = a.an([]);
+                return a.J(w, w, [-100, -100, 0]), w;
+              }
+              _projectCollisionBox(w, B, Q, ee, le, Oe, Ze, st, Tt, Yt) {
+                let Kt = new a.P(1, 0), xr = new a.P(0, 1), Ir = new a.P(w.anchorPointX + Ze[0], w.anchorPointY + Ze[1]);
+                if (Oe && !le) {
+                  let Sr = this.projectAndGetPerspectiveRatio(Q, Ir.x + 1, Ir.y, ee, Tt).point.sub(st.point).unit(), Or = Math.atan(Sr.y / Sr.x) + (Sr.x < 0 ? Math.PI : 0), Wr = Math.sin(Or), ni = Math.cos(Or);
+                  Kt = new a.P(ni, Wr), xr = new a.P(-Wr, ni);
+                } else if (!Oe && le) {
+                  let Sr = -this.transform.angle, Or = Math.sin(Sr), Wr = Math.cos(Sr);
+                  Kt = new a.P(Wr, Or), xr = new a.P(-Or, Wr);
+                }
+                let ve = st.point, be = B;
+                if (le) {
+                  ve = Ir;
+                  let Sr = this.transform.zoom - Math.floor(this.transform.zoom);
+                  be = Math.pow(2, -Sr), be *= this.mapProjection.getPitchedTextCorrection(this.transform, Ir, ee), Yt || (be *= a.ac(0.5 + st.signedDistanceFromCamera / this.transform.cameraToCenterDistance * 0.5, 0, 4));
+                }
+                Yt && (ve = ve.add(Kt.mult(Yt.x * be)).add(xr.mult(Yt.y * be)));
+                let Re = w.x1 * be, qe = w.x2 * be, et = (Re + qe) / 2, Xe = w.y1 * be, it = w.y2 * be, Ft = (Xe + it) / 2, Ht = [{ offsetX: Re, offsetY: Xe }, { offsetX: et, offsetY: Xe }, { offsetX: qe, offsetY: Xe }, { offsetX: qe, offsetY: Ft }, { offsetX: qe, offsetY: it }, { offsetX: et, offsetY: it }, { offsetX: Re, offsetY: it }, { offsetX: Re, offsetY: Ft }], tr = [];
+                for (let { offsetX: Sr, offsetY: Or } of Ht) tr.push(new a.P(ve.x + Kt.x * Sr + xr.x * Or, ve.y + Kt.y * Sr + xr.y * Or));
+                let dr = false;
+                if (le) {
+                  let Sr = tr.map((Or) => this.projectAndGetPerspectiveRatio(Q, Or.x, Or.y, ee, Tt));
+                  dr = Sr.some((Or) => !Or.isOccluded), tr = Sr.map((Or) => Or.point);
+                } else dr = true;
+                return { box: a.ao(tr), allPointsOccluded: !dr };
+              }
+            }
+            function In(ue, w, B) {
+              return w * (a.X / (ue.tileSize * Math.pow(2, B - ue.tileID.overscaledZ)));
+            }
+            class wi {
+              constructor(w, B, Q, ee) {
+                this.opacity = w ? Math.max(0, Math.min(1, w.opacity + (w.placed ? B : -B))) : ee && Q ? 1 : 0, this.placed = Q;
+              }
+              isHidden() {
+                return this.opacity === 0 && !this.placed;
+              }
+            }
+            class On {
+              constructor(w, B, Q, ee, le) {
+                this.text = new wi(w ? w.text : null, B, Q, le), this.icon = new wi(w ? w.icon : null, B, ee, le);
+              }
+              isHidden() {
+                return this.text.isHidden() && this.icon.isHidden();
+              }
+            }
+            class qn {
+              constructor(w, B, Q) {
+                this.text = w, this.icon = B, this.skipFade = Q;
+              }
+            }
+            class Fn {
+              constructor() {
+                this.invProjMatrix = a.H(), this.viewportMatrix = a.H(), this.circles = [];
+              }
+            }
+            class ra {
+              constructor(w, B, Q, ee, le) {
+                this.bucketInstanceId = w, this.featureIndex = B, this.sourceLayerIndex = Q, this.bucketIndex = ee, this.tileID = le;
+              }
+            }
+            class la {
+              constructor(w) {
+                this.crossSourceCollisions = w, this.maxGroupID = 0, this.collisionGroups = {};
+              }
+              get(w) {
+                if (this.crossSourceCollisions) return { ID: 0, predicate: null };
+                if (!this.collisionGroups[w]) {
+                  let B = ++this.maxGroupID;
+                  this.collisionGroups[w] = { ID: B, predicate: (Q) => Q.collisionGroupID === B };
+                }
+                return this.collisionGroups[w];
+              }
+            }
+            function Ut(ue, w, B, Q, ee) {
+              let { horizontalAlign: le, verticalAlign: Oe } = a.au(ue);
+              return new a.P(-(le - 0.5) * w + Q[0] * ee, -(Oe - 0.5) * B + Q[1] * ee);
+            }
+            class wt {
+              constructor(w, B, Q, ee, le, Oe) {
+                this.transform = w.clone(), this.terrain = Q, this.collisionIndex = new ji(this.transform, B), this.placements = {}, this.opacities = {}, this.variableOffsets = {}, this.stale = false, this.commitTime = 0, this.fadeDuration = ee, this.retainedQueryData = {}, this.collisionGroups = new la(le), this.collisionCircleArrays = {}, this.collisionBoxArrays = /* @__PURE__ */ new Map(), this.prevPlacement = Oe, Oe && (Oe.prevPlacement = void 0), this.placedOrientations = {};
+              }
+              _getTerrainElevationFunc(w) {
+                let B = this.terrain;
+                return B ? (Q, ee) => B.getElevation(w, Q, ee) : null;
+              }
+              getBucketParts(w, B, Q, ee) {
+                let le = Q.getBucket(B), Oe = Q.latestFeatureIndex;
+                if (!le || !Oe || B.id !== le.layerIds[0]) return;
+                let Ze = Q.collisionBoxArray, st = le.layers[0].layout, Tt = le.layers[0].paint, Yt = Math.pow(2, this.transform.zoom - Q.tileID.overscaledZ), Kt = Q.tileSize / a.X, xr = Q.tileID.toUnwrapped(), Ir = this.transform.calculatePosMatrix(xr), ve = st.get("text-pitch-alignment") === "map", be = st.get("text-rotation-alignment") === "map", Re = In(Q, 1, this.transform.zoom), qe = this.collisionIndex.mapProjection.translatePosition(this.transform, Q, Tt.get("text-translate"), Tt.get("text-translate-anchor")), et = this.collisionIndex.mapProjection.translatePosition(this.transform, Q, Tt.get("icon-translate"), Tt.get("icon-translate-anchor")), Xe = Br(Ir, ve, be, this.transform, Re), it = null;
+                if (ve) {
+                  let Ht = Vr(Ir, ve, be, this.transform, Re);
+                  it = a.L([], this.transform.labelPlaneMatrix, Ht);
+                }
+                this.retainedQueryData[le.bucketInstanceId] = new ra(le.bucketInstanceId, Oe, le.sourceLayerIndex, le.index, Q.tileID);
+                let Ft = { bucket: le, layout: st, translationText: qe, translationIcon: et, posMatrix: Ir, unwrappedTileID: xr, textLabelPlaneMatrix: Xe, labelToScreenMatrix: it, scale: Yt, textPixelRatio: Kt, holdingForFade: Q.holdingForFade(), collisionBoxArray: Ze, partiallyEvaluatedTextSize: a.ag(le.textSizeData, this.transform.zoom), collisionGroup: this.collisionGroups.get(le.sourceID) };
+                if (ee) for (let Ht of le.sortKeyRanges) {
+                  let { sortKey: tr, symbolInstanceStart: dr, symbolInstanceEnd: Sr } = Ht;
+                  w.push({ sortKey: tr, symbolInstanceStart: dr, symbolInstanceEnd: Sr, parameters: Ft });
+                }
+                else w.push({ symbolInstanceStart: 0, symbolInstanceEnd: le.symbolInstances.length, parameters: Ft });
+              }
+              attemptAnchorPlacement(w, B, Q, ee, le, Oe, Ze, st, Tt, Yt, Kt, xr, Ir, ve, be, Re, qe, et, Xe) {
+                let it = a.aq[w.textAnchor], Ft = [w.textOffset0, w.textOffset1], Ht = Ut(it, Q, ee, Ft, le), tr = this.collisionIndex.placeCollisionBox(B, xr, st, Tt, Yt, Ze, Oe, Re, Kt.predicate, Xe, Ht);
+                if ((!et || this.collisionIndex.placeCollisionBox(et, xr, st, Tt, Yt, Ze, Oe, qe, Kt.predicate, Xe, Ht).placeable) && tr.placeable) {
+                  let dr;
+                  if (this.prevPlacement && this.prevPlacement.variableOffsets[Ir.crossTileID] && this.prevPlacement.placements[Ir.crossTileID] && this.prevPlacement.placements[Ir.crossTileID].text && (dr = this.prevPlacement.variableOffsets[Ir.crossTileID].anchor), Ir.crossTileID === 0) throw new Error("symbolInstance.crossTileID can't be 0");
+                  return this.variableOffsets[Ir.crossTileID] = { textOffset: Ft, width: Q, height: ee, anchor: it, textBoxScale: le, prevAnchor: dr }, this.markUsedJustification(ve, it, Ir, be), ve.allowVerticalPlacement && (this.markUsedOrientation(ve, be, Ir), this.placedOrientations[Ir.crossTileID] = be), { shift: Ht, placedGlyphBoxes: tr };
+                }
+              }
+              placeLayerBucketPart(w, B, Q) {
+                let { bucket: ee, layout: le, translationText: Oe, translationIcon: Ze, posMatrix: st, unwrappedTileID: Tt, textLabelPlaneMatrix: Yt, labelToScreenMatrix: Kt, textPixelRatio: xr, holdingForFade: Ir, collisionBoxArray: ve, partiallyEvaluatedTextSize: be, collisionGroup: Re } = w.parameters, qe = le.get("text-optional"), et = le.get("icon-optional"), Xe = a.ar(le, "text-overlap", "text-allow-overlap"), it = Xe === "always", Ft = a.ar(le, "icon-overlap", "icon-allow-overlap"), Ht = Ft === "always", tr = le.get("text-rotation-alignment") === "map", dr = le.get("text-pitch-alignment") === "map", Sr = le.get("icon-text-fit") !== "none", Or = le.get("symbol-z-order") === "viewport-y", Wr = it && (Ht || !ee.hasIconData() || et), ni = Ht && (it || !ee.hasTextData() || qe);
+                !ee.collisionArrays && ve && ee.deserializeCollisionBoxes(ve);
+                let Pi = this._getTerrainElevationFunc(this.retainedQueryData[ee.bucketInstanceId].tileID), cn = (ln, Cn, Kn) => {
+                  var Aa, fa;
+                  if (B[ln.crossTileID]) return;
+                  if (Ir) return void (this.placements[ln.crossTileID] = new qn(false, false, false));
+                  let $a = false, Co = false, Qa = true, mo = null, Bo = { box: null, placeable: false, offscreen: null }, Ps = { placeable: false }, Ts = null, wo = null, To = null, hl = 0, Ul = 0, Lu = 0;
+                  Cn.textFeatureIndex ? hl = Cn.textFeatureIndex : ln.useRuntimeCollisionCircles && (hl = ln.featureIndex), Cn.verticalTextFeatureIndex && (Ul = Cn.verticalTextFeatureIndex);
+                  let au = Cn.textBox;
+                  if (au) {
+                    let Tl = (Te) => {
+                      let Ne = a.ah.horizontal;
+                      if (ee.allowVerticalPlacement && !Te && this.prevPlacement) {
+                        let He = this.prevPlacement.placedOrientations[ln.crossTileID];
+                        He && (this.placedOrientations[ln.crossTileID] = He, Ne = He, this.markUsedOrientation(ee, Ne, ln));
+                      }
+                      return Ne;
+                    }, Al = (Te, Ne) => {
+                      if (ee.allowVerticalPlacement && ln.numVerticalGlyphVertices > 0 && Cn.verticalTextBox) {
+                        for (let He of ee.writingModes) if (He === a.ah.vertical ? (Bo = Ne(), Ps = Bo) : Bo = Te(), Bo && Bo.placeable) break;
+                      } else Bo = Te();
+                    }, X = ln.textAnchorOffsetStartIndex, se = ln.textAnchorOffsetEndIndex;
+                    if (se === X) {
+                      let Te = (Ne, He) => {
+                        let Ye = this.collisionIndex.placeCollisionBox(Ne, Xe, xr, st, Tt, dr, tr, Oe, Re.predicate, Pi);
+                        return Ye && Ye.placeable && (this.markUsedOrientation(ee, He, ln), this.placedOrientations[ln.crossTileID] = He), Ye;
+                      };
+                      Al(() => Te(au, a.ah.horizontal), () => {
+                        let Ne = Cn.verticalTextBox;
+                        return ee.allowVerticalPlacement && ln.numVerticalGlyphVertices > 0 && Ne ? Te(Ne, a.ah.vertical) : { box: null, offscreen: null };
+                      }), Tl(Bo && Bo.placeable);
+                    } else {
+                      let Te = a.aq[(fa = (Aa = this.prevPlacement) === null || Aa === void 0 ? void 0 : Aa.variableOffsets[ln.crossTileID]) === null || fa === void 0 ? void 0 : fa.anchor], Ne = (Ye, kt, nt) => {
+                        let jt = Ye.x2 - Ye.x1, gr = Ye.y2 - Ye.y1, yr = ln.textBoxScale, Hr = Sr && Ft === "never" ? kt : null, qr = null, _i = Xe === "never" ? 1 : 2, bi = "never";
+                        Te && _i++;
+                        for (let Zr = 0; Zr < _i; Zr++) {
+                          for (let ai = X; ai < se; ai++) {
+                            let gi = ee.textAnchorOffsets.get(ai);
+                            if (Te && gi.textAnchor !== Te) continue;
+                            let Ii = this.attemptAnchorPlacement(gi, Ye, jt, gr, yr, tr, dr, xr, st, Tt, Re, bi, ln, ee, nt, Oe, Ze, Hr, Pi);
+                            if (Ii && (qr = Ii.placedGlyphBoxes, qr && qr.placeable)) return $a = true, mo = Ii.shift, qr;
+                          }
+                          Te ? Te = null : bi = Xe;
+                        }
+                        return Q && !qr && (qr = { box: this.collisionIndex.placeCollisionBox(au, "always", xr, st, Tt, dr, tr, Oe, Re.predicate, Pi, new a.P(0, 0)).box, offscreen: false, placeable: false }), qr;
+                      };
+                      Al(() => Ne(au, Cn.iconBox, a.ah.horizontal), () => {
+                        let Ye = Cn.verticalTextBox;
+                        return ee.allowVerticalPlacement && (!Bo || !Bo.placeable) && ln.numVerticalGlyphVertices > 0 && Ye ? Ne(Ye, Cn.verticalIconBox, a.ah.vertical) : { box: null, occluded: true, offscreen: null };
+                      }), Bo && ($a = Bo.placeable, Qa = Bo.offscreen);
+                      let He = Tl(Bo && Bo.placeable);
+                      if (!$a && this.prevPlacement) {
+                        let Ye = this.prevPlacement.variableOffsets[ln.crossTileID];
+                        Ye && (this.variableOffsets[ln.crossTileID] = Ye, this.markUsedJustification(ee, Ye.anchor, ln, He));
+                      }
+                    }
+                  }
+                  if (Ts = Bo, $a = Ts && Ts.placeable, Qa = Ts && Ts.offscreen, ln.useRuntimeCollisionCircles) {
+                    let Tl = ee.text.placedSymbolArray.get(ln.centerJustifiedTextSymbolIndex), Al = a.ai(ee.textSizeData, be, Tl), X = le.get("text-padding");
+                    wo = this.collisionIndex.placeCollisionCircles(Xe, Tl, ee.lineVertexArray, ee.glyphOffsetArray, Al, st, Tt, Yt, Kt, Q, dr, Re.predicate, ln.collisionCircleDiameter, X, Oe, Pi), wo.circles.length && wo.collisionDetected && !Q && a.w("Collisions detected, but collision boxes are not shown"), $a = it || wo.circles.length > 0 && !wo.collisionDetected, Qa = Qa && wo.offscreen;
+                  }
+                  if (Cn.iconFeatureIndex && (Lu = Cn.iconFeatureIndex), Cn.iconBox) {
+                    let Tl = (Al) => this.collisionIndex.placeCollisionBox(Al, Ft, xr, st, Tt, dr, tr, Ze, Re.predicate, Pi, Sr && mo ? mo : void 0);
+                    Ps && Ps.placeable && Cn.verticalIconBox ? (To = Tl(Cn.verticalIconBox), Co = To.placeable) : (To = Tl(Cn.iconBox), Co = To.placeable), Qa = Qa && To.offscreen;
+                  }
+                  let Js = qe || ln.numHorizontalGlyphVertices === 0 && ln.numVerticalGlyphVertices === 0, eu = et || ln.numIconVertices === 0;
+                  Js || eu ? eu ? Js || (Co = Co && $a) : $a = Co && $a : Co = $a = Co && $a;
+                  let dc = Co && To.placeable;
+                  if ($a && Ts.placeable && this.collisionIndex.insertCollisionBox(Ts.box, Xe, le.get("text-ignore-placement"), ee.bucketInstanceId, Ps && Ps.placeable && Ul ? Ul : hl, Re.ID), dc && this.collisionIndex.insertCollisionBox(To.box, Ft, le.get("icon-ignore-placement"), ee.bucketInstanceId, Lu, Re.ID), wo && $a && this.collisionIndex.insertCollisionCircles(wo.circles, Xe, le.get("text-ignore-placement"), ee.bucketInstanceId, hl, Re.ID), Q && this.storeCollisionData(ee.bucketInstanceId, Kn, Cn, Ts, To, wo), ln.crossTileID === 0) throw new Error("symbolInstance.crossTileID can't be 0");
+                  if (ee.bucketInstanceId === 0) throw new Error("bucket.bucketInstanceId can't be 0");
+                  this.placements[ln.crossTileID] = new qn($a || Wr, Co || ni, Qa || ee.justReloaded), B[ln.crossTileID] = true;
+                };
+                if (Or) {
+                  if (w.symbolInstanceStart !== 0) throw new Error("bucket.bucketInstanceId should be 0");
+                  let ln = ee.getSortedSymbolIndexes(this.transform.angle);
+                  for (let Cn = ln.length - 1; Cn >= 0; --Cn) {
+                    let Kn = ln[Cn];
+                    cn(ee.symbolInstances.get(Kn), ee.collisionArrays[Kn], Kn);
+                  }
+                } else for (let ln = w.symbolInstanceStart; ln < w.symbolInstanceEnd; ln++) cn(ee.symbolInstances.get(ln), ee.collisionArrays[ln], ln);
+                if (Q && ee.bucketInstanceId in this.collisionCircleArrays) {
+                  let ln = this.collisionCircleArrays[ee.bucketInstanceId];
+                  a.as(ln.invProjMatrix, st), ln.viewportMatrix = this.collisionIndex.getViewportMatrix();
+                }
+                ee.justReloaded = false;
+              }
+              storeCollisionData(w, B, Q, ee, le, Oe) {
+                if (Q.textBox || Q.iconBox) {
+                  let Ze, st;
+                  this.collisionBoxArrays.has(w) ? Ze = this.collisionBoxArrays.get(w) : (Ze = /* @__PURE__ */ new Map(), this.collisionBoxArrays.set(w, Ze)), Ze.has(B) ? st = Ze.get(B) : (st = { text: null, icon: null }, Ze.set(B, st)), Q.textBox && (st.text = ee.box), Q.iconBox && (st.icon = le.box);
+                }
+                if (Oe) {
+                  let Ze = this.collisionCircleArrays[w];
+                  Ze === void 0 && (Ze = this.collisionCircleArrays[w] = new Fn());
+                  for (let st = 0; st < Oe.circles.length; st += 4) Ze.circles.push(Oe.circles[st + 0]), Ze.circles.push(Oe.circles[st + 1]), Ze.circles.push(Oe.circles[st + 2]), Ze.circles.push(Oe.collisionDetected ? 1 : 0);
+                }
+              }
+              markUsedJustification(w, B, Q, ee) {
+                let le;
+                le = ee === a.ah.vertical ? Q.verticalPlacedTextSymbolIndex : { left: Q.leftJustifiedTextSymbolIndex, center: Q.centerJustifiedTextSymbolIndex, right: Q.rightJustifiedTextSymbolIndex }[a.at(B)];
+                let Oe = [Q.leftJustifiedTextSymbolIndex, Q.centerJustifiedTextSymbolIndex, Q.rightJustifiedTextSymbolIndex, Q.verticalPlacedTextSymbolIndex];
+                for (let Ze of Oe) Ze >= 0 && (w.text.placedSymbolArray.get(Ze).crossTileID = le >= 0 && Ze !== le ? 0 : Q.crossTileID);
+              }
+              markUsedOrientation(w, B, Q) {
+                let ee = B === a.ah.horizontal || B === a.ah.horizontalOnly ? B : 0, le = B === a.ah.vertical ? B : 0, Oe = [Q.leftJustifiedTextSymbolIndex, Q.centerJustifiedTextSymbolIndex, Q.rightJustifiedTextSymbolIndex];
+                for (let Ze of Oe) w.text.placedSymbolArray.get(Ze).placedOrientation = ee;
+                Q.verticalPlacedTextSymbolIndex && (w.text.placedSymbolArray.get(Q.verticalPlacedTextSymbolIndex).placedOrientation = le);
+              }
+              commit(w) {
+                this.commitTime = w, this.zoomAtLastRecencyCheck = this.transform.zoom;
+                let B = this.prevPlacement, Q = false;
+                this.prevZoomAdjustment = B ? B.zoomAdjustment(this.transform.zoom) : 0;
+                let ee = B ? B.symbolFadeChange(w) : 1, le = B ? B.opacities : {}, Oe = B ? B.variableOffsets : {}, Ze = B ? B.placedOrientations : {};
+                for (let st in this.placements) {
+                  let Tt = this.placements[st], Yt = le[st];
+                  Yt ? (this.opacities[st] = new On(Yt, ee, Tt.text, Tt.icon), Q = Q || Tt.text !== Yt.text.placed || Tt.icon !== Yt.icon.placed) : (this.opacities[st] = new On(null, ee, Tt.text, Tt.icon, Tt.skipFade), Q = Q || Tt.text || Tt.icon);
+                }
+                for (let st in le) {
+                  let Tt = le[st];
+                  if (!this.opacities[st]) {
+                    let Yt = new On(Tt, ee, false, false);
+                    Yt.isHidden() || (this.opacities[st] = Yt, Q = Q || Tt.text.placed || Tt.icon.placed);
+                  }
+                }
+                for (let st in Oe) this.variableOffsets[st] || !this.opacities[st] || this.opacities[st].isHidden() || (this.variableOffsets[st] = Oe[st]);
+                for (let st in Ze) this.placedOrientations[st] || !this.opacities[st] || this.opacities[st].isHidden() || (this.placedOrientations[st] = Ze[st]);
+                if (B && B.lastPlacementChangeTime === void 0) throw new Error("Last placement time for previous placement is not defined");
+                Q ? this.lastPlacementChangeTime = w : typeof this.lastPlacementChangeTime != "number" && (this.lastPlacementChangeTime = B ? B.lastPlacementChangeTime : w);
+              }
+              updateLayerOpacities(w, B) {
+                let Q = {};
+                for (let ee of B) {
+                  let le = ee.getBucket(w);
+                  le && ee.latestFeatureIndex && w.id === le.layerIds[0] && this.updateBucketOpacities(le, ee.tileID, Q, ee.collisionBoxArray);
+                }
+              }
+              updateBucketOpacities(w, B, Q, ee) {
+                w.hasTextData() && (w.text.opacityVertexArray.clear(), w.text.hasVisibleVertices = false), w.hasIconData() && (w.icon.opacityVertexArray.clear(), w.icon.hasVisibleVertices = false), w.hasIconCollisionBoxData() && w.iconCollisionBox.collisionVertexArray.clear(), w.hasTextCollisionBoxData() && w.textCollisionBox.collisionVertexArray.clear();
+                let le = w.layers[0], Oe = le.layout, Ze = new On(null, 0, false, false, true), st = Oe.get("text-allow-overlap"), Tt = Oe.get("icon-allow-overlap"), Yt = le._unevaluatedLayout.hasValue("text-variable-anchor") || le._unevaluatedLayout.hasValue("text-variable-anchor-offset"), Kt = Oe.get("text-rotation-alignment") === "map", xr = Oe.get("text-pitch-alignment") === "map", Ir = Oe.get("icon-text-fit") !== "none", ve = new On(null, 0, st && (Tt || !w.hasIconData() || Oe.get("icon-optional")), Tt && (st || !w.hasTextData() || Oe.get("text-optional")), true);
+                !w.collisionArrays && ee && (w.hasIconCollisionBoxData() || w.hasTextCollisionBoxData()) && w.deserializeCollisionBoxes(ee);
+                let be = (qe, et, Xe) => {
+                  for (let it = 0; it < et / 4; it++) qe.opacityVertexArray.emplaceBack(Xe);
+                  qe.hasVisibleVertices = qe.hasVisibleVertices || Xe !== fn;
+                }, Re = this.collisionBoxArrays.get(w.bucketInstanceId);
+                for (let qe = 0; qe < w.symbolInstances.length; qe++) {
+                  let et = w.symbolInstances.get(qe), { numHorizontalGlyphVertices: Xe, numVerticalGlyphVertices: it, crossTileID: Ft } = et, Ht = this.opacities[Ft];
+                  Q[Ft] ? Ht = Ze : Ht || (Ht = ve, this.opacities[Ft] = Ht), Q[Ft] = true;
+                  let tr = et.numIconVertices > 0, dr = this.placedOrientations[et.crossTileID], Sr = dr === a.ah.vertical, Or = dr === a.ah.horizontal || dr === a.ah.horizontalOnly;
+                  if (Xe > 0 || it > 0) {
+                    let ni = tn(Ht.text);
+                    be(w.text, Xe, Sr ? fn : ni), be(w.text, it, Or ? fn : ni);
+                    let Pi = Ht.text.isHidden();
+                    [et.rightJustifiedTextSymbolIndex, et.centerJustifiedTextSymbolIndex, et.leftJustifiedTextSymbolIndex].forEach((Cn) => {
+                      Cn >= 0 && (w.text.placedSymbolArray.get(Cn).hidden = Pi || Sr ? 1 : 0);
+                    }), et.verticalPlacedTextSymbolIndex >= 0 && (w.text.placedSymbolArray.get(et.verticalPlacedTextSymbolIndex).hidden = Pi || Or ? 1 : 0);
+                    let cn = this.variableOffsets[et.crossTileID];
+                    cn && this.markUsedJustification(w, cn.anchor, et, dr);
+                    let ln = this.placedOrientations[et.crossTileID];
+                    ln && (this.markUsedJustification(w, "left", et, ln), this.markUsedOrientation(w, ln, et));
+                  }
+                  if (tr) {
+                    let ni = tn(Ht.icon), Pi = !(Ir && et.verticalPlacedIconSymbolIndex && Sr);
+                    et.placedIconSymbolIndex >= 0 && (be(w.icon, et.numIconVertices, Pi ? ni : fn), w.icon.placedSymbolArray.get(et.placedIconSymbolIndex).hidden = Ht.icon.isHidden()), et.verticalPlacedIconSymbolIndex >= 0 && (be(w.icon, et.numVerticalIconVertices, Pi ? fn : ni), w.icon.placedSymbolArray.get(et.verticalPlacedIconSymbolIndex).hidden = Ht.icon.isHidden());
+                  }
+                  let Wr = Re && Re.has(qe) ? Re.get(qe) : { text: null, icon: null };
+                  if (w.hasIconCollisionBoxData() || w.hasTextCollisionBoxData()) {
+                    let ni = w.collisionArrays[qe];
+                    if (ni) {
+                      let Pi = new a.P(0, 0);
+                      if (ni.textBox || ni.verticalTextBox) {
+                        let cn = true;
+                        if (Yt) {
+                          let ln = this.variableOffsets[Ft];
+                          ln ? (Pi = Ut(ln.anchor, ln.width, ln.height, ln.textOffset, ln.textBoxScale), Kt && Pi._rotate(xr ? this.transform.angle : -this.transform.angle)) : cn = false;
+                        }
+                        if (ni.textBox || ni.verticalTextBox) {
+                          let ln;
+                          ni.textBox && (ln = Sr), ni.verticalTextBox && (ln = Or), rr(w.textCollisionBox.collisionVertexArray, Ht.text.placed, !cn || ln, Wr.text, Pi.x, Pi.y);
+                        }
+                      }
+                      if (ni.iconBox || ni.verticalIconBox) {
+                        let cn = !!(!Or && ni.verticalIconBox), ln;
+                        ni.iconBox && (ln = cn), ni.verticalIconBox && (ln = !cn), rr(w.iconCollisionBox.collisionVertexArray, Ht.icon.placed, ln, Wr.icon, Ir ? Pi.x : 0, Ir ? Pi.y : 0);
+                      }
+                    }
+                  }
+                }
+                if (w.sortFeatures(this.transform.angle), this.retainedQueryData[w.bucketInstanceId] && (this.retainedQueryData[w.bucketInstanceId].featureSortOrder = w.featureSortOrder), w.hasTextData() && w.text.opacityVertexBuffer && w.text.opacityVertexBuffer.updateData(w.text.opacityVertexArray), w.hasIconData() && w.icon.opacityVertexBuffer && w.icon.opacityVertexBuffer.updateData(w.icon.opacityVertexArray), w.hasIconCollisionBoxData() && w.iconCollisionBox.collisionVertexBuffer && w.iconCollisionBox.collisionVertexBuffer.updateData(w.iconCollisionBox.collisionVertexArray), w.hasTextCollisionBoxData() && w.textCollisionBox.collisionVertexBuffer && w.textCollisionBox.collisionVertexBuffer.updateData(w.textCollisionBox.collisionVertexArray), w.text.opacityVertexArray.length !== w.text.layoutVertexArray.length / 4) throw new Error(`bucket.text.opacityVertexArray.length (= ${w.text.opacityVertexArray.length}) !== bucket.text.layoutVertexArray.length (= ${w.text.layoutVertexArray.length}) / 4`);
+                if (w.icon.opacityVertexArray.length !== w.icon.layoutVertexArray.length / 4) throw new Error(`bucket.icon.opacityVertexArray.length (= ${w.icon.opacityVertexArray.length}) !== bucket.icon.layoutVertexArray.length (= ${w.icon.layoutVertexArray.length}) / 4`);
+                if (w.bucketInstanceId in this.collisionCircleArrays) {
+                  let qe = this.collisionCircleArrays[w.bucketInstanceId];
+                  w.placementInvProjMatrix = qe.invProjMatrix, w.placementViewportMatrix = qe.viewportMatrix, w.collisionCircleArray = qe.circles, delete this.collisionCircleArrays[w.bucketInstanceId];
+                }
+              }
+              symbolFadeChange(w) {
+                return this.fadeDuration === 0 ? 1 : (w - this.commitTime) / this.fadeDuration + this.prevZoomAdjustment;
+              }
+              zoomAdjustment(w) {
+                return Math.max(0, (this.transform.zoom - w) / 1.5);
+              }
+              hasTransitions(w) {
+                return this.stale || w - this.lastPlacementChangeTime < this.fadeDuration;
+              }
+              stillRecent(w, B) {
+                let Q = this.zoomAtLastRecencyCheck === B ? 1 - this.zoomAdjustment(B) : 1;
+                return this.zoomAtLastRecencyCheck = B, this.commitTime + this.fadeDuration * Q > w;
+              }
+              setStale() {
+                this.stale = true;
+              }
+            }
+            function rr(ue, w, B, Q, ee, le) {
+              Q && Q.length !== 0 || (Q = [0, 0, 0, 0]);
+              let Oe = Q[0] - di, Ze = Q[1] - di, st = Q[2] - di, Tt = Q[3] - di;
+              ue.emplaceBack(w ? 1 : 0, B ? 1 : 0, ee || 0, le || 0, Oe, Ze), ue.emplaceBack(w ? 1 : 0, B ? 1 : 0, ee || 0, le || 0, st, Ze), ue.emplaceBack(w ? 1 : 0, B ? 1 : 0, ee || 0, le || 0, st, Tt), ue.emplaceBack(w ? 1 : 0, B ? 1 : 0, ee || 0, le || 0, Oe, Tt);
+            }
+            let nr = Math.pow(2, 25), Er = Math.pow(2, 24), Xr = Math.pow(2, 17), ri = Math.pow(2, 16), Qr = Math.pow(2, 9), Oi = Math.pow(2, 8), $i = Math.pow(2, 1);
+            function tn(ue) {
+              if (ue.opacity === 0 && !ue.placed) return 0;
+              if (ue.opacity === 1 && ue.placed) return 4294967295;
+              let w = ue.placed ? 1 : 0, B = Math.floor(127 * ue.opacity);
+              return B * nr + w * Er + B * Xr + w * ri + B * Qr + w * Oi + B * $i + w;
+            }
+            let fn = 0;
+            function yn() {
+              return { isOccluded: (ue, w, B) => false, getPitchedTextCorrection: (ue, w, B) => 1, get useSpecialProjectionForSymbols() {
+                return false;
+              }, projectTileCoordinates(ue, w, B, Q) {
+                throw new Error("Not implemented.");
+              }, translatePosition: (ue, w, B, Q) => function(ee, le, Oe, Ze, st = false) {
+                if (!Oe[0] && !Oe[1]) return [0, 0];
+                let Tt = st ? Ze === "map" ? ee.angle : 0 : Ze === "viewport" ? -ee.angle : 0;
+                if (Tt) {
+                  let Yt = Math.sin(Tt), Kt = Math.cos(Tt);
+                  Oe = [Oe[0] * Kt - Oe[1] * Yt, Oe[0] * Yt + Oe[1] * Kt];
+                }
+                return [st ? Oe[0] : In(le, Oe[0], ee.zoom), st ? Oe[1] : In(le, Oe[1], ee.zoom)];
+              }(ue, w, B, Q), getCircleRadiusCorrection: (ue) => 1 };
+            }
+            class Sn {
+              constructor(w) {
+                this._sortAcrossTiles = w.layout.get("symbol-z-order") !== "viewport-y" && !w.layout.get("symbol-sort-key").isConstant(), this._currentTileIndex = 0, this._currentPartIndex = 0, this._seenCrossTileIDs = {}, this._bucketParts = [];
+              }
+              continuePlacement(w, B, Q, ee, le) {
+                let Oe = this._bucketParts;
+                for (; this._currentTileIndex < w.length; ) if (B.getBucketParts(Oe, ee, w[this._currentTileIndex], this._sortAcrossTiles), this._currentTileIndex++, le()) return true;
+                for (this._sortAcrossTiles && (this._sortAcrossTiles = false, Oe.sort((Ze, st) => Ze.sortKey - st.sortKey)); this._currentPartIndex < Oe.length; ) if (B.placeLayerBucketPart(Oe[this._currentPartIndex], this._seenCrossTileIDs, Q), this._currentPartIndex++, le()) return true;
+                return false;
+              }
+            }
+            class Ba {
+              constructor(w, B, Q, ee, le, Oe, Ze, st) {
+                this.placement = new wt(w, yn(), B, Oe, Ze, st), this._currentPlacementIndex = Q.length - 1, this._forceFullPlacement = ee, this._showCollisionBoxes = le, this._done = false;
+              }
+              isDone() {
+                return this._done;
+              }
+              continuePlacement(w, B, Q) {
+                let ee = u.now(), le = () => !this._forceFullPlacement && u.now() - ee > 2;
+                for (; this._currentPlacementIndex >= 0; ) {
+                  let Oe = B[w[this._currentPlacementIndex]], Ze = this.placement.collisionIndex.transform.zoom;
+                  if (Oe.type === "symbol" && (!Oe.minzoom || Oe.minzoom <= Ze) && (!Oe.maxzoom || Oe.maxzoom > Ze)) {
+                    if (this._inProgressLayer || (this._inProgressLayer = new Sn(Oe)), this._inProgressLayer.continuePlacement(Q[Oe.source], this.placement, this._showCollisionBoxes, Oe, le)) return;
+                    delete this._inProgressLayer;
+                  }
+                  this._currentPlacementIndex--;
+                }
+                this._done = true;
+              }
+              commit(w) {
+                return this.placement.commit(w), this.placement;
+              }
+            }
+            let ua = 512 / a.X / 2;
+            class ma {
+              constructor(w, B, Q) {
+                this.tileID = w, this.bucketInstanceId = Q, this._symbolsByKey = {};
+                let ee = /* @__PURE__ */ new Map();
+                for (let le = 0; le < B.length; le++) {
+                  let Oe = B.get(le), Ze = Oe.key, st = ee.get(Ze);
+                  st ? st.push(Oe) : ee.set(Ze, [Oe]);
+                }
+                for (let [le, Oe] of ee) {
+                  let Ze = { positions: Oe.map((st) => ({ x: Math.floor(st.anchorX * ua), y: Math.floor(st.anchorY * ua) })), crossTileIDs: Oe.map((st) => st.crossTileID) };
+                  if (Ze.positions.length > 128) {
+                    let st = new a.av(Ze.positions.length, 16, Uint16Array);
+                    for (let { x: Tt, y: Yt } of Ze.positions) st.add(Tt, Yt);
+                    st.finish(), delete Ze.positions, Ze.index = st;
+                  }
+                  this._symbolsByKey[le] = Ze;
+                }
+              }
+              getScaledCoordinates(w, B) {
+                let { x: Q, y: ee, z: le } = this.tileID.canonical, { x: Oe, y: Ze, z: st } = B.canonical, Tt = ua / Math.pow(2, st - le), Yt = (Ze * a.X + w.anchorY) * Tt, Kt = ee * a.X * ua;
+                return { x: Math.floor((Oe * a.X + w.anchorX) * Tt - Q * a.X * ua), y: Math.floor(Yt - Kt) };
+              }
+              findMatches(w, B, Q) {
+                let ee = this.tileID.canonical.z < B.canonical.z ? 1 : Math.pow(2, this.tileID.canonical.z - B.canonical.z);
+                for (let le = 0; le < w.length; le++) {
+                  let Oe = w.get(le);
+                  if (Oe.crossTileID) continue;
+                  let Ze = this._symbolsByKey[Oe.key];
+                  if (!Ze) continue;
+                  let st = this.getScaledCoordinates(Oe, B);
+                  if (Ze.index) {
+                    let Tt = Ze.index.range(st.x - ee, st.y - ee, st.x + ee, st.y + ee).sort();
+                    for (let Yt of Tt) {
+                      let Kt = Ze.crossTileIDs[Yt];
+                      if (!Q[Kt]) {
+                        Q[Kt] = true, Oe.crossTileID = Kt;
+                        break;
+                      }
+                    }
+                  } else if (Ze.positions) for (let Tt = 0; Tt < Ze.positions.length; Tt++) {
+                    let Yt = Ze.positions[Tt], Kt = Ze.crossTileIDs[Tt];
+                    if (Math.abs(Yt.x - st.x) <= ee && Math.abs(Yt.y - st.y) <= ee && !Q[Kt]) {
+                      Q[Kt] = true, Oe.crossTileID = Kt;
+                      break;
+                    }
+                  }
+                }
+              }
+              getCrossTileIDsLists() {
+                return Object.values(this._symbolsByKey).map(({ crossTileIDs: w }) => w);
+              }
+            }
+            class Wa {
+              constructor() {
+                this.maxCrossTileID = 0;
+              }
+              generate() {
+                return ++this.maxCrossTileID;
+              }
+            }
+            class Fa {
+              constructor() {
+                this.indexes = {}, this.usedCrossTileIDs = {}, this.lng = 0;
+              }
+              handleWrapJump(w) {
+                let B = Math.round((w - this.lng) / 360);
+                if (B !== 0) for (let Q in this.indexes) {
+                  let ee = this.indexes[Q], le = {};
+                  for (let Oe in ee) {
+                    let Ze = ee[Oe];
+                    Ze.tileID = Ze.tileID.unwrapTo(Ze.tileID.wrap + B), le[Ze.tileID.key] = Ze;
+                  }
+                  this.indexes[Q] = le;
+                }
+                this.lng = w;
+              }
+              addBucket(w, B, Q) {
+                if (this.indexes[w.overscaledZ] && this.indexes[w.overscaledZ][w.key]) {
+                  if (this.indexes[w.overscaledZ][w.key].bucketInstanceId === B.bucketInstanceId) return false;
+                  this.removeBucketCrossTileIDs(w.overscaledZ, this.indexes[w.overscaledZ][w.key]);
+                }
+                for (let le = 0; le < B.symbolInstances.length; le++) B.symbolInstances.get(le).crossTileID = 0;
+                this.usedCrossTileIDs[w.overscaledZ] || (this.usedCrossTileIDs[w.overscaledZ] = {});
+                let ee = this.usedCrossTileIDs[w.overscaledZ];
+                for (let le in this.indexes) {
+                  let Oe = this.indexes[le];
+                  if (Number(le) > w.overscaledZ) for (let Ze in Oe) {
+                    let st = Oe[Ze];
+                    st.tileID.isChildOf(w) && st.findMatches(B.symbolInstances, w, ee);
+                  }
+                  else {
+                    let Ze = Oe[w.scaledTo(Number(le)).key];
+                    Ze && Ze.findMatches(B.symbolInstances, w, ee);
+                  }
+                }
+                for (let le = 0; le < B.symbolInstances.length; le++) {
+                  let Oe = B.symbolInstances.get(le);
+                  Oe.crossTileID || (Oe.crossTileID = Q.generate(), ee[Oe.crossTileID] = true);
+                }
+                return this.indexes[w.overscaledZ] === void 0 && (this.indexes[w.overscaledZ] = {}), this.indexes[w.overscaledZ][w.key] = new ma(w, B.symbolInstances, B.bucketInstanceId), true;
+              }
+              removeBucketCrossTileIDs(w, B) {
+                for (let Q of B.getCrossTileIDsLists()) for (let ee of Q) delete this.usedCrossTileIDs[w][ee];
+              }
+              removeStaleBuckets(w) {
+                let B = false;
+                for (let Q in this.indexes) {
+                  let ee = this.indexes[Q];
+                  for (let le in ee) w[ee[le].bucketInstanceId] || (this.removeBucketCrossTileIDs(Q, ee[le]), delete ee[le], B = true);
+                }
+                return B;
+              }
+            }
+            class Xo {
+              constructor() {
+                this.layerIndexes = {}, this.crossTileIDs = new Wa(), this.maxBucketInstanceId = 0, this.bucketsInCurrentPlacement = {};
+              }
+              addLayer(w, B, Q) {
+                let ee = this.layerIndexes[w.id];
+                ee === void 0 && (ee = this.layerIndexes[w.id] = new Fa());
+                let le = false, Oe = {};
+                ee.handleWrapJump(Q);
+                for (let Ze of B) {
+                  let st = Ze.getBucket(w);
+                  st && w.id === st.layerIds[0] && (st.bucketInstanceId || (st.bucketInstanceId = ++this.maxBucketInstanceId), ee.addBucket(Ze.tileID, st, this.crossTileIDs) && (le = true), Oe[st.bucketInstanceId] = true);
+                }
+                return ee.removeStaleBuckets(Oe) && (le = true), le;
+              }
+              pruneUnusedLayers(w) {
+                let B = {};
+                w.forEach((Q) => {
+                  B[Q] = true;
+                });
+                for (let Q in this.layerIndexes) B[Q] || delete this.layerIndexes[Q];
+              }
+            }
+            let da = (ue, w) => a.t(ue, w && w.filter((B) => B.identifier !== "source.canvas")), Wn = a.aw();
+            class Ha extends a.E {
+              constructor(w, B = {}) {
+                super(), this._rtlPluginLoaded = () => {
+                  for (let Q in this.sourceCaches) {
+                    let ee = this.sourceCaches[Q].getSource().type;
+                    ee !== "vector" && ee !== "geojson" || this.sourceCaches[Q].reload();
+                  }
+                }, this.map = w, this.dispatcher = new Ee(Se(), w._getMapId()), this.dispatcher.registerMessageHandler("GG", (Q, ee) => this.getGlyphs(Q, ee)), this.dispatcher.registerMessageHandler("GI", (Q, ee) => this.getImages(Q, ee)), this.imageManager = new A(), this.imageManager.setEventedParent(this), this.glyphManager = new G(w._requestManager, B.localIdeographFontFamily), this.lineAtlas = new oe(256, 512), this.crossTileSymbolIndex = new Xo(), this._spritesImagesIds = {}, this._layers = {}, this._order = [], this.sourceCaches = {}, this.zoomHistory = new a.ax(), this._loaded = false, this._availableImages = [], this._resetUpdates(), this.dispatcher.broadcast("SR", a.ay()), Qt().on(fr, this._rtlPluginLoaded), this.on("data", (Q) => {
+                  if (Q.dataType !== "source" || Q.sourceDataType !== "metadata") return;
+                  let ee = this.sourceCaches[Q.sourceId];
+                  if (!ee) return;
+                  let le = ee.getSource();
+                  if (le && le.vectorLayerIds) for (let Oe in this._layers) {
+                    let Ze = this._layers[Oe];
+                    Ze.source === le.id && this._validateLayer(Ze);
+                  }
+                });
+              }
+              loadURL(w, B = {}, Q) {
+                this.fire(new a.k("dataloading", { dataType: "style" })), B.validate = typeof B.validate != "boolean" || B.validate;
+                let ee = this.map._requestManager.transformRequest(w, "Style");
+                this._loadStyleRequest = new AbortController();
+                let le = this._loadStyleRequest;
+                a.h(ee, this._loadStyleRequest).then((Oe) => {
+                  this._loadStyleRequest = null, this._load(Oe.data, B, Q);
+                }).catch((Oe) => {
+                  this._loadStyleRequest = null, Oe && !le.signal.aborted && this.fire(new a.j(Oe));
+                });
+              }
+              loadJSON(w, B = {}, Q) {
+                this.fire(new a.k("dataloading", { dataType: "style" })), this._frameRequest = new AbortController(), u.frameAsync(this._frameRequest).then(() => {
+                  this._frameRequest = null, B.validate = B.validate !== false, this._load(w, B, Q);
+                }).catch(() => {
+                });
+              }
+              loadEmpty() {
+                this.fire(new a.k("dataloading", { dataType: "style" })), this._load(Wn, { validate: false });
+              }
+              _load(w, B, Q) {
+                var ee;
+                let le = B.transformStyle ? B.transformStyle(Q, w) : w;
+                if (!B.validate || !da(this, a.u(le))) {
+                  this._loaded = true, this.stylesheet = le;
+                  for (let Oe in le.sources) this.addSource(Oe, le.sources[Oe], { validate: false });
+                  le.sprite ? this._loadSprite(le.sprite) : this.imageManager.setLoaded(true), this.glyphManager.setURL(le.glyphs), this._createLayers(), this.light = new N(this.stylesheet.light), this.sky = new re(this.stylesheet.sky), this.map.setTerrain((ee = this.stylesheet.terrain) !== null && ee !== void 0 ? ee : null), this.fire(new a.k("data", { dataType: "style" })), this.fire(new a.k("style.load"));
+                }
+              }
+              _createLayers() {
+                let w = a.az(this.stylesheet.layers);
+                this.dispatcher.broadcast("SL", w), this._order = w.map((B) => B.id), this._layers = {}, this._serializedLayers = null;
+                for (let B of w) {
+                  let Q = a.aA(B);
+                  Q.setEventedParent(this, { layer: { id: B.id } }), this._layers[B.id] = Q;
+                }
+              }
+              _loadSprite(w, B = false, Q = void 0) {
+                let ee;
+                this.imageManager.setLoaded(false), this._spriteRequest = new AbortController(), function(le, Oe, Ze, st) {
+                  return a._(this, void 0, void 0, function* () {
+                    let Tt = C(le), Yt = Ze > 1 ? "@2x" : "", Kt = {}, xr = {};
+                    for (let { id: Ir, url: ve } of Tt) {
+                      let be = Oe.transformRequest(M(ve, Yt, ".json"), "SpriteJSON");
+                      Kt[Ir] = a.h(be, st);
+                      let Re = Oe.transformRequest(M(ve, Yt, ".png"), "SpriteImage");
+                      xr[Ir] = p.getImage(Re, st);
+                    }
+                    return yield Promise.all([...Object.values(Kt), ...Object.values(xr)]), function(Ir, ve) {
+                      return a._(this, void 0, void 0, function* () {
+                        let be = {};
+                        for (let Re in Ir) {
+                          be[Re] = {};
+                          let qe = u.getImageCanvasContext((yield ve[Re]).data), et = (yield Ir[Re]).data;
+                          for (let Xe in et) {
+                            let { width: it, height: Ft, x: Ht, y: tr, sdf: dr, pixelRatio: Sr, stretchX: Or, stretchY: Wr, content: ni, textFitWidth: Pi, textFitHeight: cn } = et[Xe];
+                            be[Re][Xe] = { data: null, pixelRatio: Sr, sdf: dr, stretchX: Or, stretchY: Wr, content: ni, textFitWidth: Pi, textFitHeight: cn, spriteData: { width: it, height: Ft, x: Ht, y: tr, context: qe } };
+                          }
+                        }
+                        return be;
+                      });
+                    }(Kt, xr);
+                  });
+                }(w, this.map._requestManager, this.map.getPixelRatio(), this._spriteRequest).then((le) => {
+                  if (this._spriteRequest = null, le) for (let Oe in le) {
+                    this._spritesImagesIds[Oe] = [];
+                    let Ze = this._spritesImagesIds[Oe] ? this._spritesImagesIds[Oe].filter((st) => !(st in le)) : [];
+                    for (let st of Ze) this.imageManager.removeImage(st), this._changedImages[st] = true;
+                    for (let st in le[Oe]) {
+                      let Tt = Oe === "default" ? st : `${Oe}:${st}`;
+                      this._spritesImagesIds[Oe].push(Tt), Tt in this.imageManager.images ? this.imageManager.updateImage(Tt, le[Oe][st], false) : this.imageManager.addImage(Tt, le[Oe][st]), B && (this._changedImages[Tt] = true);
+                    }
+                  }
+                }).catch((le) => {
+                  this._spriteRequest = null, ee = le, this.fire(new a.j(ee));
+                }).finally(() => {
+                  this.imageManager.setLoaded(true), this._availableImages = this.imageManager.listImages(), B && (this._changed = true), this.dispatcher.broadcast("SI", this._availableImages), this.fire(new a.k("data", { dataType: "style" })), Q && Q(ee);
+                });
+              }
+              _unloadSprite() {
+                for (let w of Object.values(this._spritesImagesIds).flat()) this.imageManager.removeImage(w), this._changedImages[w] = true;
+                this._spritesImagesIds = {}, this._availableImages = this.imageManager.listImages(), this._changed = true, this.dispatcher.broadcast("SI", this._availableImages), this.fire(new a.k("data", { dataType: "style" }));
+              }
+              _validateLayer(w) {
+                let B = this.sourceCaches[w.source];
+                if (!B) return;
+                let Q = w.sourceLayer;
+                if (!Q) return;
+                let ee = B.getSource();
+                (ee.type === "geojson" || ee.vectorLayerIds && ee.vectorLayerIds.indexOf(Q) === -1) && this.fire(new a.j(new Error(`Source layer "${Q}" does not exist on source "${ee.id}" as specified by style layer "${w.id}".`)));
+              }
+              loaded() {
+                if (!this._loaded || Object.keys(this._updatedSources).length) return false;
+                for (let w in this.sourceCaches) if (!this.sourceCaches[w].loaded()) return false;
+                return !!this.imageManager.isLoaded();
+              }
+              _serializeByIds(w, B = false) {
+                let Q = this._serializedAllLayers();
+                if (!w || w.length === 0) return Object.values(B ? a.aB(Q) : Q);
+                let ee = [];
+                for (let le of w) if (Q[le]) {
+                  let Oe = B ? a.aB(Q[le]) : Q[le];
+                  ee.push(Oe);
+                }
+                return ee;
+              }
+              _serializedAllLayers() {
+                let w = this._serializedLayers;
+                if (w) return w;
+                w = this._serializedLayers = {};
+                let B = Object.keys(this._layers);
+                for (let Q of B) {
+                  let ee = this._layers[Q];
+                  ee.type !== "custom" && (w[Q] = ee.serialize());
+                }
+                return w;
+              }
+              hasTransitions() {
+                if (this.light && this.light.hasTransition() || this.sky && this.sky.hasTransition()) return true;
+                for (let w in this.sourceCaches) if (this.sourceCaches[w].hasTransition()) return true;
+                for (let w in this._layers) if (this._layers[w].hasTransition()) return true;
+                return false;
+              }
+              _checkLoaded() {
+                if (!this._loaded) throw new Error("Style is not done loading.");
+              }
+              update(w) {
+                if (!this._loaded) return;
+                let B = this._changed;
+                if (B) {
+                  let ee = Object.keys(this._updatedLayers), le = Object.keys(this._removedLayers);
+                  (ee.length || le.length) && this._updateWorkerLayers(ee, le);
+                  for (let Oe in this._updatedSources) {
+                    let Ze = this._updatedSources[Oe];
+                    if (Ze === "reload") this._reloadSource(Oe);
+                    else {
+                      if (Ze !== "clear") throw new Error(`Invalid action ${Ze}`);
+                      this._clearSource(Oe);
+                    }
+                  }
+                  this._updateTilesForChangedImages(), this._updateTilesForChangedGlyphs();
+                  for (let Oe in this._updatedPaintProps) this._layers[Oe].updateTransitions(w);
+                  this.light.updateTransitions(w), this.sky.updateTransitions(w), this._resetUpdates();
+                }
+                let Q = {};
+                for (let ee in this.sourceCaches) {
+                  let le = this.sourceCaches[ee];
+                  Q[ee] = le.used, le.used = false;
+                }
+                for (let ee of this._order) {
+                  let le = this._layers[ee];
+                  le.recalculate(w, this._availableImages), !le.isHidden(w.zoom) && le.source && (this.sourceCaches[le.source].used = true);
+                }
+                for (let ee in Q) {
+                  let le = this.sourceCaches[ee];
+                  !!Q[ee] != !!le.used && le.fire(new a.k("data", { sourceDataType: "visibility", dataType: "source", sourceId: ee }));
+                }
+                this.light.recalculate(w), this.sky.recalculate(w), this.z = w.zoom, B && this.fire(new a.k("data", { dataType: "style" }));
+              }
+              _updateTilesForChangedImages() {
+                let w = Object.keys(this._changedImages);
+                if (w.length) {
+                  for (let B in this.sourceCaches) this.sourceCaches[B].reloadTilesForDependencies(["icons", "patterns"], w);
+                  this._changedImages = {};
+                }
+              }
+              _updateTilesForChangedGlyphs() {
+                if (this._glyphsDidChange) {
+                  for (let w in this.sourceCaches) this.sourceCaches[w].reloadTilesForDependencies(["glyphs"], [""]);
+                  this._glyphsDidChange = false;
+                }
+              }
+              _updateWorkerLayers(w, B) {
+                this.dispatcher.broadcast("UL", { layers: this._serializeByIds(w, false), removedIds: B });
+              }
+              _resetUpdates() {
+                this._changed = false, this._updatedLayers = {}, this._removedLayers = {}, this._updatedSources = {}, this._updatedPaintProps = {}, this._changedImages = {}, this._glyphsDidChange = false;
+              }
+              setState(w, B = {}) {
+                var Q;
+                this._checkLoaded();
+                let ee = this.serialize();
+                if (w = B.transformStyle ? B.transformStyle(ee, w) : w, ((Q = B.validate) === null || Q === void 0 || Q) && da(this, a.u(w))) return false;
+                (w = a.aB(w)).layers = a.az(w.layers);
+                let le = a.aC(ee, w), Oe = this._getOperationsToPerform(le);
+                if (Oe.unimplemented.length > 0) throw new Error(`Unimplemented: ${Oe.unimplemented.join(", ")}.`);
+                if (Oe.operations.length === 0) return false;
+                for (let Ze of Oe.operations) Ze();
+                return this.stylesheet = w, this._serializedLayers = null, true;
+              }
+              _getOperationsToPerform(w) {
+                let B = [], Q = [];
+                for (let ee of w) switch (ee.command) {
+                  case "setCenter":
+                  case "setZoom":
+                  case "setBearing":
+                  case "setPitch":
+                    continue;
+                  case "addLayer":
+                    B.push(() => this.addLayer.apply(this, ee.args));
+                    break;
+                  case "removeLayer":
+                    B.push(() => this.removeLayer.apply(this, ee.args));
+                    break;
+                  case "setPaintProperty":
+                    B.push(() => this.setPaintProperty.apply(this, ee.args));
+                    break;
+                  case "setLayoutProperty":
+                    B.push(() => this.setLayoutProperty.apply(this, ee.args));
+                    break;
+                  case "setFilter":
+                    B.push(() => this.setFilter.apply(this, ee.args));
+                    break;
+                  case "addSource":
+                    B.push(() => this.addSource.apply(this, ee.args));
+                    break;
+                  case "removeSource":
+                    B.push(() => this.removeSource.apply(this, ee.args));
+                    break;
+                  case "setLayerZoomRange":
+                    B.push(() => this.setLayerZoomRange.apply(this, ee.args));
+                    break;
+                  case "setLight":
+                    B.push(() => this.setLight.apply(this, ee.args));
+                    break;
+                  case "setGeoJSONSourceData":
+                    B.push(() => this.setGeoJSONSourceData.apply(this, ee.args));
+                    break;
+                  case "setGlyphs":
+                    B.push(() => this.setGlyphs.apply(this, ee.args));
+                    break;
+                  case "setSprite":
+                    B.push(() => this.setSprite.apply(this, ee.args));
+                    break;
+                  case "setSky":
+                    B.push(() => this.setSky.apply(this, ee.args));
+                    break;
+                  case "setTerrain":
+                    B.push(() => this.map.setTerrain.apply(this, ee.args));
+                    break;
+                  case "setTransition":
+                    B.push(() => {
+                    });
+                    break;
+                  default:
+                    Q.push(ee.command);
+                }
+                return { operations: B, unimplemented: Q };
+              }
+              addImage(w, B) {
+                if (this.getImage(w)) return this.fire(new a.j(new Error(`An image named "${w}" already exists.`)));
+                this.imageManager.addImage(w, B), this._afterImageUpdated(w);
+              }
+              updateImage(w, B) {
+                this.imageManager.updateImage(w, B);
+              }
+              getImage(w) {
+                return this.imageManager.getImage(w);
+              }
+              removeImage(w) {
+                if (!this.getImage(w)) return this.fire(new a.j(new Error(`An image named "${w}" does not exist.`)));
+                this.imageManager.removeImage(w), this._afterImageUpdated(w);
+              }
+              _afterImageUpdated(w) {
+                this._availableImages = this.imageManager.listImages(), this._changedImages[w] = true, this._changed = true, this.dispatcher.broadcast("SI", this._availableImages), this.fire(new a.k("data", { dataType: "style" }));
+              }
+              listImages() {
+                return this._checkLoaded(), this.imageManager.listImages();
+              }
+              addSource(w, B, Q = {}) {
+                if (this._checkLoaded(), this.sourceCaches[w] !== void 0) throw new Error(`Source "${w}" already exists.`);
+                if (!B.type) throw new Error(`The type property must be defined, but only the following properties were given: ${Object.keys(B).join(", ")}.`);
+                if (["vector", "raster", "geojson", "video", "image"].indexOf(B.type) >= 0 && this._validate(a.u.source, `sources.${w}`, B, null, Q)) return;
+                this.map && this.map._collectResourceTiming && (B.collectResourceTiming = true);
+                let ee = this.sourceCaches[w] = new mt(w, B, this.dispatcher);
+                ee.style = this, ee.setEventedParent(this, () => ({ isSourceLoaded: ee.loaded(), source: ee.serialize(), sourceId: w })), ee.onAdd(this.map), this._changed = true;
+              }
+              removeSource(w) {
+                if (this._checkLoaded(), this.sourceCaches[w] === void 0) throw new Error("There is no source with this ID");
+                for (let Q in this._layers) if (this._layers[Q].source === w) return this.fire(new a.j(new Error(`Source "${w}" cannot be removed while layer "${Q}" is using it.`)));
+                let B = this.sourceCaches[w];
+                delete this.sourceCaches[w], delete this._updatedSources[w], B.fire(new a.k("data", { sourceDataType: "metadata", dataType: "source", sourceId: w })), B.setEventedParent(null), B.onRemove(this.map), this._changed = true;
+              }
+              setGeoJSONSourceData(w, B) {
+                if (this._checkLoaded(), this.sourceCaches[w] === void 0) throw new Error(`There is no source with this ID=${w}`);
+                let Q = this.sourceCaches[w].getSource();
+                if (Q.type !== "geojson") throw new Error(`geojsonSource.type is ${Q.type}, which is !== 'geojson`);
+                Q.setData(B), this._changed = true;
+              }
+              getSource(w) {
+                return this.sourceCaches[w] && this.sourceCaches[w].getSource();
+              }
+              addLayer(w, B, Q = {}) {
+                this._checkLoaded();
+                let ee = w.id;
+                if (this.getLayer(ee)) return void this.fire(new a.j(new Error(`Layer "${ee}" already exists on this map.`)));
+                let le;
+                if (w.type === "custom") {
+                  if (da(this, a.aD(w))) return;
+                  le = a.aA(w);
+                } else {
+                  if ("source" in w && typeof w.source == "object" && (this.addSource(ee, w.source), w = a.aB(w), w = a.e(w, { source: ee })), this._validate(a.u.layer, `layers.${ee}`, w, { arrayIndex: -1 }, Q)) return;
+                  le = a.aA(w), this._validateLayer(le), le.setEventedParent(this, { layer: { id: ee } });
+                }
+                let Oe = B ? this._order.indexOf(B) : this._order.length;
+                if (B && Oe === -1) this.fire(new a.j(new Error(`Cannot add layer "${ee}" before non-existing layer "${B}".`)));
+                else {
+                  if (this._order.splice(Oe, 0, ee), this._layerOrderChanged = true, this._layers[ee] = le, this._removedLayers[ee] && le.source && le.type !== "custom") {
+                    let Ze = this._removedLayers[ee];
+                    delete this._removedLayers[ee], Ze.type !== le.type ? this._updatedSources[le.source] = "clear" : (this._updatedSources[le.source] = "reload", this.sourceCaches[le.source].pause());
+                  }
+                  this._updateLayer(le), le.onAdd && le.onAdd(this.map);
+                }
+              }
+              moveLayer(w, B) {
+                if (this._checkLoaded(), this._changed = true, !this._layers[w]) return void this.fire(new a.j(new Error(`The layer '${w}' does not exist in the map's style and cannot be moved.`)));
+                if (w === B) return;
+                let Q = this._order.indexOf(w);
+                this._order.splice(Q, 1);
+                let ee = B ? this._order.indexOf(B) : this._order.length;
+                B && ee === -1 ? this.fire(new a.j(new Error(`Cannot move layer "${w}" before non-existing layer "${B}".`))) : (this._order.splice(ee, 0, w), this._layerOrderChanged = true);
+              }
+              removeLayer(w) {
+                this._checkLoaded();
+                let B = this._layers[w];
+                if (!B) return void this.fire(new a.j(new Error(`Cannot remove non-existing layer "${w}".`)));
+                B.setEventedParent(null);
+                let Q = this._order.indexOf(w);
+                this._order.splice(Q, 1), this._layerOrderChanged = true, this._changed = true, this._removedLayers[w] = B, delete this._layers[w], this._serializedLayers && delete this._serializedLayers[w], delete this._updatedLayers[w], delete this._updatedPaintProps[w], B.onRemove && B.onRemove(this.map);
+              }
+              getLayer(w) {
+                return this._layers[w];
+              }
+              getLayersOrder() {
+                return [...this._order];
+              }
+              hasLayer(w) {
+                return w in this._layers;
+              }
+              setLayerZoomRange(w, B, Q) {
+                this._checkLoaded();
+                let ee = this.getLayer(w);
+                ee ? ee.minzoom === B && ee.maxzoom === Q || (B != null && (ee.minzoom = B), Q != null && (ee.maxzoom = Q), this._updateLayer(ee)) : this.fire(new a.j(new Error(`Cannot set the zoom range of non-existing layer "${w}".`)));
+              }
+              setFilter(w, B, Q = {}) {
+                this._checkLoaded();
+                let ee = this.getLayer(w);
+                if (ee) {
+                  if (!a.aE(ee.filter, B)) return B == null ? (ee.filter = void 0, void this._updateLayer(ee)) : void (this._validate(a.u.filter, `layers.${ee.id}.filter`, B, null, Q) || (ee.filter = a.aB(B), this._updateLayer(ee)));
+                } else this.fire(new a.j(new Error(`Cannot filter non-existing layer "${w}".`)));
+              }
+              getFilter(w) {
+                return a.aB(this.getLayer(w).filter);
+              }
+              setLayoutProperty(w, B, Q, ee = {}) {
+                this._checkLoaded();
+                let le = this.getLayer(w);
+                le ? a.aE(le.getLayoutProperty(B), Q) || (le.setLayoutProperty(B, Q, ee), this._updateLayer(le)) : this.fire(new a.j(new Error(`Cannot style non-existing layer "${w}".`)));
+              }
+              getLayoutProperty(w, B) {
+                let Q = this.getLayer(w);
+                if (Q) return Q.getLayoutProperty(B);
+                this.fire(new a.j(new Error(`Cannot get style of non-existing layer "${w}".`)));
+              }
+              setPaintProperty(w, B, Q, ee = {}) {
+                this._checkLoaded();
+                let le = this.getLayer(w);
+                le ? a.aE(le.getPaintProperty(B), Q) || (le.setPaintProperty(B, Q, ee) && this._updateLayer(le), this._changed = true, this._updatedPaintProps[w] = true, this._serializedLayers = null) : this.fire(new a.j(new Error(`Cannot style non-existing layer "${w}".`)));
+              }
+              getPaintProperty(w, B) {
+                return this.getLayer(w).getPaintProperty(B);
+              }
+              setFeatureState(w, B) {
+                this._checkLoaded();
+                let Q = w.source, ee = w.sourceLayer, le = this.sourceCaches[Q];
+                if (le === void 0) return void this.fire(new a.j(new Error(`The source '${Q}' does not exist in the map's style.`)));
+                let Oe = le.getSource().type;
+                Oe === "geojson" && ee ? this.fire(new a.j(new Error("GeoJSON sources cannot have a sourceLayer parameter."))) : Oe !== "vector" || ee ? (w.id === void 0 && this.fire(new a.j(new Error("The feature id parameter must be provided."))), le.setFeatureState(ee, w.id, B)) : this.fire(new a.j(new Error("The sourceLayer parameter must be provided for vector source types.")));
+              }
+              removeFeatureState(w, B) {
+                this._checkLoaded();
+                let Q = w.source, ee = this.sourceCaches[Q];
+                if (ee === void 0) return void this.fire(new a.j(new Error(`The source '${Q}' does not exist in the map's style.`)));
+                let le = ee.getSource().type, Oe = le === "vector" ? w.sourceLayer : void 0;
+                le !== "vector" || Oe ? B && typeof w.id != "string" && typeof w.id != "number" ? this.fire(new a.j(new Error("A feature id is required to remove its specific state property."))) : ee.removeFeatureState(Oe, w.id, B) : this.fire(new a.j(new Error("The sourceLayer parameter must be provided for vector source types.")));
+              }
+              getFeatureState(w) {
+                this._checkLoaded();
+                let B = w.source, Q = w.sourceLayer, ee = this.sourceCaches[B];
+                if (ee !== void 0) return ee.getSource().type !== "vector" || Q ? (w.id === void 0 && this.fire(new a.j(new Error("The feature id parameter must be provided."))), ee.getFeatureState(Q, w.id)) : void this.fire(new a.j(new Error("The sourceLayer parameter must be provided for vector source types.")));
+                this.fire(new a.j(new Error(`The source '${B}' does not exist in the map's style.`)));
+              }
+              getTransition() {
+                return a.e({ duration: 300, delay: 0 }, this.stylesheet && this.stylesheet.transition);
+              }
+              serialize() {
+                if (!this._loaded) return;
+                let w = a.aF(this.sourceCaches, (le) => le.serialize()), B = this._serializeByIds(this._order, true), Q = this.map.getTerrain() || void 0, ee = this.stylesheet;
+                return a.aG({ version: ee.version, name: ee.name, metadata: ee.metadata, light: ee.light, sky: ee.sky, center: ee.center, zoom: ee.zoom, bearing: ee.bearing, pitch: ee.pitch, sprite: ee.sprite, glyphs: ee.glyphs, transition: ee.transition, sources: w, layers: B, terrain: Q }, (le) => le !== void 0);
+              }
+              _updateLayer(w) {
+                this._updatedLayers[w.id] = true, w.source && !this._updatedSources[w.source] && this.sourceCaches[w.source].getSource().type !== "raster" && (this._updatedSources[w.source] = "reload", this.sourceCaches[w.source].pause()), this._serializedLayers = null, this._changed = true;
+              }
+              _flattenAndSortRenderedFeatures(w) {
+                let B = (Oe) => this._layers[Oe].type === "fill-extrusion", Q = {}, ee = [];
+                for (let Oe = this._order.length - 1; Oe >= 0; Oe--) {
+                  let Ze = this._order[Oe];
+                  if (B(Ze)) {
+                    Q[Ze] = Oe;
+                    for (let st of w) {
+                      let Tt = st[Ze];
+                      if (Tt) for (let Yt of Tt) ee.push(Yt);
+                    }
+                  }
+                }
+                ee.sort((Oe, Ze) => Ze.intersectionZ - Oe.intersectionZ);
+                let le = [];
+                for (let Oe = this._order.length - 1; Oe >= 0; Oe--) {
+                  let Ze = this._order[Oe];
+                  if (B(Ze)) for (let st = ee.length - 1; st >= 0; st--) {
+                    let Tt = ee[st].feature;
+                    if (Q[Tt.layer.id] < Oe) break;
+                    le.push(Tt), ee.pop();
+                  }
+                  else for (let st of w) {
+                    let Tt = st[Ze];
+                    if (Tt) for (let Yt of Tt) le.push(Yt.feature);
+                  }
+                }
+                return le;
+              }
+              queryRenderedFeatures(w, B, Q) {
+                B && B.filter && this._validate(a.u.filter, "queryRenderedFeatures.filter", B.filter, null, B);
+                let ee = {};
+                if (B && B.layers) {
+                  if (!Array.isArray(B.layers)) return this.fire(new a.j(new Error("parameters.layers must be an Array."))), [];
+                  for (let Ze of B.layers) {
+                    let st = this._layers[Ze];
+                    if (!st) return this.fire(new a.j(new Error(`The layer '${Ze}' does not exist in the map's style and cannot be queried for features.`))), [];
+                    ee[st.source] = true;
+                  }
+                }
+                let le = [];
+                B.availableImages = this._availableImages;
+                let Oe = this._serializedAllLayers();
+                for (let Ze in this.sourceCaches) B.layers && !ee[Ze] || le.push(Pe(this.sourceCaches[Ze], this._layers, Oe, w, B, Q));
+                return this.placement && le.push(function(Ze, st, Tt, Yt, Kt, xr, Ir) {
+                  let ve = {}, be = xr.queryRenderedSymbols(Yt), Re = [];
+                  for (let qe of Object.keys(be).map(Number)) Re.push(Ir[qe]);
+                  Re.sort(me);
+                  for (let qe of Re) {
+                    let et = qe.featureIndex.lookupSymbolFeatures(be[qe.bucketInstanceId], st, qe.bucketIndex, qe.sourceLayerIndex, Kt.filter, Kt.layers, Kt.availableImages, Ze);
+                    for (let Xe in et) {
+                      let it = ve[Xe] = ve[Xe] || [], Ft = et[Xe];
+                      Ft.sort((Ht, tr) => {
+                        let dr = qe.featureSortOrder;
+                        if (dr) {
+                          let Sr = dr.indexOf(Ht.featureIndex);
+                          return dr.indexOf(tr.featureIndex) - Sr;
+                        }
+                        return tr.featureIndex - Ht.featureIndex;
+                      });
+                      for (let Ht of Ft) it.push(Ht);
+                    }
+                  }
+                  for (let qe in ve) ve[qe].forEach((et) => {
+                    let Xe = et.feature, it = Tt[Ze[qe].source].getFeatureState(Xe.layer["source-layer"], Xe.id);
+                    Xe.source = Xe.layer.source, Xe.layer["source-layer"] && (Xe.sourceLayer = Xe.layer["source-layer"]), Xe.state = it;
+                  });
+                  return ve;
+                }(this._layers, Oe, this.sourceCaches, w, B, this.placement.collisionIndex, this.placement.retainedQueryData)), this._flattenAndSortRenderedFeatures(le);
+              }
+              querySourceFeatures(w, B) {
+                B && B.filter && this._validate(a.u.filter, "querySourceFeatures.filter", B.filter, null, B);
+                let Q = this.sourceCaches[w];
+                return Q ? function(ee, le) {
+                  let Oe = ee.getRenderableIds().map((Tt) => ee.getTileByID(Tt)), Ze = [], st = {};
+                  for (let Tt = 0; Tt < Oe.length; Tt++) {
+                    let Yt = Oe[Tt], Kt = Yt.tileID.canonical.key;
+                    st[Kt] || (st[Kt] = true, Yt.querySourceFeatures(Ze, le));
+                  }
+                  return Ze;
+                }(Q, B) : [];
+              }
+              getLight() {
+                return this.light.getLight();
+              }
+              setLight(w, B = {}) {
+                this._checkLoaded();
+                let Q = this.light.getLight(), ee = false;
+                for (let Oe in w) if (!a.aE(w[Oe], Q[Oe])) {
+                  ee = true;
+                  break;
+                }
+                if (!ee) return;
+                let le = { now: u.now(), transition: a.e({ duration: 300, delay: 0 }, this.stylesheet.transition) };
+                this.light.setLight(w, B), this.light.updateTransitions(le);
+              }
+              getSky() {
+                var w;
+                return (w = this.stylesheet) === null || w === void 0 ? void 0 : w.sky;
+              }
+              setSky(w, B = {}) {
+                let Q = this.getSky(), ee = false;
+                if (!w && !Q) return;
+                if (w && !Q) ee = true;
+                else if (!w && Q) ee = true;
+                else for (let Oe in w) if (!a.aE(w[Oe], Q[Oe])) {
+                  ee = true;
+                  break;
+                }
+                if (!ee) return;
+                let le = { now: u.now(), transition: a.e({ duration: 300, delay: 0 }, this.stylesheet.transition) };
+                this.stylesheet.sky = w, this.sky.setSky(w, B), this.sky.updateTransitions(le);
+              }
+              _validate(w, B, Q, ee, le = {}) {
+                return (!le || le.validate !== false) && da(this, w.call(a.u, a.e({ key: B, style: this.serialize(), value: Q, styleSpec: a.v }, ee)));
+              }
+              _remove(w = true) {
+                this._frameRequest && (this._frameRequest.abort(), this._frameRequest = null), this._loadStyleRequest && (this._loadStyleRequest.abort(), this._loadStyleRequest = null), this._spriteRequest && (this._spriteRequest.abort(), this._spriteRequest = null), Qt().off(fr, this._rtlPluginLoaded);
+                for (let B in this._layers) this._layers[B].setEventedParent(null);
+                for (let B in this.sourceCaches) {
+                  let Q = this.sourceCaches[B];
+                  Q.setEventedParent(null), Q.onRemove(this.map);
+                }
+                this.imageManager.setEventedParent(null), this.setEventedParent(null), w && this.dispatcher.broadcast("RM", void 0), this.dispatcher.remove(w);
+              }
+              _clearSource(w) {
+                this.sourceCaches[w].clearTiles();
+              }
+              _reloadSource(w) {
+                this.sourceCaches[w].resume(), this.sourceCaches[w].reload();
+              }
+              _updateSources(w) {
+                for (let B in this.sourceCaches) this.sourceCaches[B].update(w, this.map.terrain);
+              }
+              _generateCollisionBoxes() {
+                for (let w in this.sourceCaches) this._reloadSource(w);
+              }
+              _updatePlacement(w, B, Q, ee, le = false) {
+                let Oe = false, Ze = false, st = {};
+                for (let Tt of this._order) {
+                  let Yt = this._layers[Tt];
+                  if (Yt.type !== "symbol") continue;
+                  if (!st[Yt.source]) {
+                    let xr = this.sourceCaches[Yt.source];
+                    st[Yt.source] = xr.getRenderableIds(true).map((Ir) => xr.getTileByID(Ir)).sort((Ir, ve) => ve.tileID.overscaledZ - Ir.tileID.overscaledZ || (Ir.tileID.isLessThan(ve.tileID) ? -1 : 1));
+                  }
+                  let Kt = this.crossTileSymbolIndex.addLayer(Yt, st[Yt.source], w.center.lng);
+                  Oe = Oe || Kt;
+                }
+                if (this.crossTileSymbolIndex.pruneUnusedLayers(this._order), ((le = le || this._layerOrderChanged || Q === 0) || !this.pauseablePlacement || this.pauseablePlacement.isDone() && !this.placement.stillRecent(u.now(), w.zoom)) && (this.pauseablePlacement = new Ba(w, this.map.terrain, this._order, le, B, Q, ee, this.placement), this._layerOrderChanged = false), this.pauseablePlacement.isDone() ? this.placement.setStale() : (this.pauseablePlacement.continuePlacement(this._order, this._layers, st), this.pauseablePlacement.isDone() && (this.placement = this.pauseablePlacement.commit(u.now()), Ze = true), Oe && this.pauseablePlacement.placement.setStale()), Ze || Oe) for (let Tt of this._order) {
+                  let Yt = this._layers[Tt];
+                  Yt.type === "symbol" && this.placement.updateLayerOpacities(Yt, st[Yt.source]);
+                }
+                return !this.pauseablePlacement.isDone() || this.placement.hasTransitions(u.now());
+              }
+              _releaseSymbolFadeTiles() {
+                for (let w in this.sourceCaches) this.sourceCaches[w].releaseSymbolFadeTiles();
+              }
+              getImages(w, B) {
+                return a._(this, void 0, void 0, function* () {
+                  let Q = yield this.imageManager.getImages(B.icons);
+                  this._updateTilesForChangedImages();
+                  let ee = this.sourceCaches[B.source];
+                  return ee && ee.setDependencies(B.tileID.key, B.type, B.icons), Q;
+                });
+              }
+              getGlyphs(w, B) {
+                return a._(this, void 0, void 0, function* () {
+                  let Q = yield this.glyphManager.getGlyphs(B.stacks), ee = this.sourceCaches[B.source];
+                  return ee && ee.setDependencies(B.tileID.key, B.type, [""]), Q;
+                });
+              }
+              getGlyphsUrl() {
+                return this.stylesheet.glyphs || null;
+              }
+              setGlyphs(w, B = {}) {
+                this._checkLoaded(), w && this._validate(a.u.glyphs, "glyphs", w, null, B) || (this._glyphsDidChange = true, this.stylesheet.glyphs = w, this.glyphManager.entries = {}, this.glyphManager.setURL(w));
+              }
+              addSprite(w, B, Q = {}, ee) {
+                this._checkLoaded();
+                let le = [{ id: w, url: B }], Oe = [...C(this.stylesheet.sprite), ...le];
+                this._validate(a.u.sprite, "sprite", Oe, null, Q) || (this.stylesheet.sprite = Oe, this._loadSprite(le, true, ee));
+              }
+              removeSprite(w) {
+                this._checkLoaded();
+                let B = C(this.stylesheet.sprite);
+                if (B.find((Q) => Q.id === w)) {
+                  if (this._spritesImagesIds[w]) for (let Q of this._spritesImagesIds[w]) this.imageManager.removeImage(Q), this._changedImages[Q] = true;
+                  B.splice(B.findIndex((Q) => Q.id === w), 1), this.stylesheet.sprite = B.length > 0 ? B : void 0, delete this._spritesImagesIds[w], this._availableImages = this.imageManager.listImages(), this._changed = true, this.dispatcher.broadcast("SI", this._availableImages), this.fire(new a.k("data", { dataType: "style" }));
+                } else this.fire(new a.j(new Error(`Sprite "${w}" doesn't exists on this map.`)));
+              }
+              getSprite() {
+                return C(this.stylesheet.sprite);
+              }
+              setSprite(w, B = {}, Q) {
+                this._checkLoaded(), w && this._validate(a.u.sprite, "sprite", w, null, B) || (this.stylesheet.sprite = w, w ? this._loadSprite(w, true, Q) : (this._unloadSprite(), Q && Q(null)));
+              }
+            }
+            var vo = a.Y([{ name: "a_pos", type: "Int16", components: 2 }]);
+            let jn = { prelude: Mt(`#ifdef GL_ES
+precision mediump float;
+#else
+#if !defined(lowp)
+#define lowp
+#endif
+#if !defined(mediump)
+#define mediump
+#endif
+#if !defined(highp)
+#define highp
+#endif
+#endif
+`, `#ifdef GL_ES
+precision highp float;
+#else
+#if !defined(lowp)
+#define lowp
+#endif
+#if !defined(mediump)
+#define mediump
+#endif
+#if !defined(highp)
+#define highp
+#endif
+#endif
+vec2 unpack_float(const float packedValue) {int packedIntValue=int(packedValue);int v0=packedIntValue/256;return vec2(v0,packedIntValue-v0*256);}vec2 unpack_opacity(const float packedOpacity) {int intOpacity=int(packedOpacity)/2;return vec2(float(intOpacity)/127.0,mod(packedOpacity,2.0));}vec4 decode_color(const vec2 encodedColor) {return vec4(unpack_float(encodedColor[0])/255.0,unpack_float(encodedColor[1])/255.0
+);}float unpack_mix_vec2(const vec2 packedValue,const float t) {return mix(packedValue[0],packedValue[1],t);}vec4 unpack_mix_color(const vec4 packedColors,const float t) {vec4 minColor=decode_color(vec2(packedColors[0],packedColors[1]));vec4 maxColor=decode_color(vec2(packedColors[2],packedColors[3]));return mix(minColor,maxColor,t);}vec2 get_pattern_pos(const vec2 pixel_coord_upper,const vec2 pixel_coord_lower,const vec2 pattern_size,const float tile_units_to_pixels,const vec2 pos) {vec2 offset=mod(mod(mod(pixel_coord_upper,pattern_size)*256.0,pattern_size)*256.0+pixel_coord_lower,pattern_size);return (tile_units_to_pixels*pos+offset)/pattern_size;}
+#ifdef TERRAIN3D
+uniform sampler2D u_terrain;uniform float u_terrain_dim;uniform mat4 u_terrain_matrix;uniform vec4 u_terrain_unpack;uniform float u_terrain_exaggeration;uniform highp sampler2D u_depth;
+#endif
+const highp vec4 bitSh=vec4(256.*256.*256.,256.*256.,256.,1.);const highp vec4 bitShifts=vec4(1.)/bitSh;highp float unpack(highp vec4 color) {return dot(color,bitShifts);}highp float depthOpacity(vec3 frag) {
+#ifdef TERRAIN3D
+highp float d=unpack(texture2D(u_depth,frag.xy*0.5+0.5))+0.0001-frag.z;return 1.0-max(0.0,min(1.0,-d*500.0));
+#else
+return 1.0;
+#endif
+}float calculate_visibility(vec4 pos) {
+#ifdef TERRAIN3D
+vec3 frag=pos.xyz/pos.w;highp float d=depthOpacity(frag);if (d > 0.95) return 1.0;return (d+depthOpacity(frag+vec3(0.0,0.01,0.0)))/2.0;
+#else
+return 1.0;
+#endif
+}float ele(vec2 pos) {
+#ifdef TERRAIN3D
+vec4 rgb=(texture2D(u_terrain,pos)*255.0)*u_terrain_unpack;return rgb.r+rgb.g+rgb.b-u_terrain_unpack.a;
+#else
+return 0.0;
+#endif
+}float get_elevation(vec2 pos) {
+#ifdef TERRAIN3D
+vec2 coord=(u_terrain_matrix*vec4(pos,0.0,1.0)).xy*u_terrain_dim+1.0;vec2 f=fract(coord);vec2 c=(floor(coord)+0.5)/(u_terrain_dim+2.0);float d=1.0/(u_terrain_dim+2.0);float tl=ele(c);float tr=ele(c+vec2(d,0.0));float bl=ele(c+vec2(0.0,d));float br=ele(c+vec2(d,d));float elevation=mix(mix(tl,tr,f.x),mix(bl,br,f.x),f.y);return elevation*u_terrain_exaggeration;
+#else
+return 0.0;
+#endif
+}`), background: Mt(`uniform vec4 u_color;uniform float u_opacity;void main() {gl_FragColor=u_color*u_opacity;
+#ifdef OVERDRAW_INSPECTOR
+gl_FragColor=vec4(1.0);
+#endif
+}`, "attribute vec2 a_pos;uniform mat4 u_matrix;void main() {gl_Position=u_matrix*vec4(a_pos,0,1);}"), backgroundPattern: Mt(`uniform vec2 u_pattern_tl_a;uniform vec2 u_pattern_br_a;uniform vec2 u_pattern_tl_b;uniform vec2 u_pattern_br_b;uniform vec2 u_texsize;uniform float u_mix;uniform float u_opacity;uniform sampler2D u_image;varying vec2 v_pos_a;varying vec2 v_pos_b;void main() {vec2 imagecoord=mod(v_pos_a,1.0);vec2 pos=mix(u_pattern_tl_a/u_texsize,u_pattern_br_a/u_texsize,imagecoord);vec4 color1=texture2D(u_image,pos);vec2 imagecoord_b=mod(v_pos_b,1.0);vec2 pos2=mix(u_pattern_tl_b/u_texsize,u_pattern_br_b/u_texsize,imagecoord_b);vec4 color2=texture2D(u_image,pos2);gl_FragColor=mix(color1,color2,u_mix)*u_opacity;
+#ifdef OVERDRAW_INSPECTOR
+gl_FragColor=vec4(1.0);
+#endif
+}`, "uniform mat4 u_matrix;uniform vec2 u_pattern_size_a;uniform vec2 u_pattern_size_b;uniform vec2 u_pixel_coord_upper;uniform vec2 u_pixel_coord_lower;uniform float u_scale_a;uniform float u_scale_b;uniform float u_tile_units_to_pixels;attribute vec2 a_pos;varying vec2 v_pos_a;varying vec2 v_pos_b;void main() {gl_Position=u_matrix*vec4(a_pos,0,1);v_pos_a=get_pattern_pos(u_pixel_coord_upper,u_pixel_coord_lower,u_scale_a*u_pattern_size_a,u_tile_units_to_pixels,a_pos);v_pos_b=get_pattern_pos(u_pixel_coord_upper,u_pixel_coord_lower,u_scale_b*u_pattern_size_b,u_tile_units_to_pixels,a_pos);}"), circle: Mt(`varying vec3 v_data;varying float v_visibility;
+#pragma mapbox: define highp vec4 color
+#pragma mapbox: define mediump float radius
+#pragma mapbox: define lowp float blur
+#pragma mapbox: define lowp float opacity
+#pragma mapbox: define highp vec4 stroke_color
+#pragma mapbox: define mediump float stroke_width
+#pragma mapbox: define lowp float stroke_opacity
+void main() {
+#pragma mapbox: initialize highp vec4 color
+#pragma mapbox: initialize mediump float radius
+#pragma mapbox: initialize lowp float blur
+#pragma mapbox: initialize lowp float opacity
+#pragma mapbox: initialize highp vec4 stroke_color
+#pragma mapbox: initialize mediump float stroke_width
+#pragma mapbox: initialize lowp float stroke_opacity
+vec2 extrude=v_data.xy;float extrude_length=length(extrude);float antialiased_blur=v_data.z;float opacity_t=smoothstep(0.0,antialiased_blur,extrude_length-1.0);float color_t=stroke_width < 0.01 ? 0.0 : smoothstep(antialiased_blur,0.0,extrude_length-radius/(radius+stroke_width));gl_FragColor=v_visibility*opacity_t*mix(color*opacity,stroke_color*stroke_opacity,color_t);
+#ifdef OVERDRAW_INSPECTOR
+gl_FragColor=vec4(1.0);
+#endif
+}`, `uniform mat4 u_matrix;uniform bool u_scale_with_map;uniform bool u_pitch_with_map;uniform vec2 u_extrude_scale;uniform lowp float u_device_pixel_ratio;uniform highp float u_camera_to_center_distance;attribute vec2 a_pos;varying vec3 v_data;varying float v_visibility;
+#pragma mapbox: define highp vec4 color
+#pragma mapbox: define mediump float radius
+#pragma mapbox: define lowp float blur
+#pragma mapbox: define lowp float opacity
+#pragma mapbox: define highp vec4 stroke_color
+#pragma mapbox: define mediump float stroke_width
+#pragma mapbox: define lowp float stroke_opacity
+void main(void) {
+#pragma mapbox: initialize highp vec4 color
+#pragma mapbox: initialize mediump float radius
+#pragma mapbox: initialize lowp float blur
+#pragma mapbox: initialize lowp float opacity
+#pragma mapbox: initialize highp vec4 stroke_color
+#pragma mapbox: initialize mediump float stroke_width
+#pragma mapbox: initialize lowp float stroke_opacity
+vec2 extrude=vec2(mod(a_pos,2.0)*2.0-1.0);vec2 circle_center=floor(a_pos*0.5);float ele=get_elevation(circle_center);v_visibility=calculate_visibility(u_matrix*vec4(circle_center,ele,1.0));if (u_pitch_with_map) {vec2 corner_position=circle_center;if (u_scale_with_map) {corner_position+=extrude*(radius+stroke_width)*u_extrude_scale;} else {vec4 projected_center=u_matrix*vec4(circle_center,0,1);corner_position+=extrude*(radius+stroke_width)*u_extrude_scale*(projected_center.w/u_camera_to_center_distance);}gl_Position=u_matrix*vec4(corner_position,ele,1);} else {gl_Position=u_matrix*vec4(circle_center,ele,1);if (u_scale_with_map) {gl_Position.xy+=extrude*(radius+stroke_width)*u_extrude_scale*u_camera_to_center_distance;} else {gl_Position.xy+=extrude*(radius+stroke_width)*u_extrude_scale*gl_Position.w;}}float antialiasblur=-max(1.0/u_device_pixel_ratio/(radius+stroke_width),blur);v_data=vec3(extrude.x,extrude.y,antialiasblur);}`), clippingMask: Mt("void main() {gl_FragColor=vec4(1.0);}", "attribute vec2 a_pos;uniform mat4 u_matrix;void main() {gl_Position=u_matrix*vec4(a_pos,0,1);}"), heatmap: Mt(`uniform highp float u_intensity;varying vec2 v_extrude;
+#pragma mapbox: define highp float weight
+#define GAUSS_COEF 0.3989422804014327
+void main() {
+#pragma mapbox: initialize highp float weight
+float d=-0.5*3.0*3.0*dot(v_extrude,v_extrude);float val=weight*u_intensity*GAUSS_COEF*exp(d);gl_FragColor=vec4(val,1.0,1.0,1.0);
+#ifdef OVERDRAW_INSPECTOR
+gl_FragColor=vec4(1.0);
+#endif
+}`, `uniform mat4 u_matrix;uniform float u_extrude_scale;uniform float u_opacity;uniform float u_intensity;attribute vec2 a_pos;varying vec2 v_extrude;
+#pragma mapbox: define highp float weight
+#pragma mapbox: define mediump float radius
+const highp float ZERO=1.0/255.0/16.0;
+#define GAUSS_COEF 0.3989422804014327
+void main(void) {
+#pragma mapbox: initialize highp float weight
+#pragma mapbox: initialize mediump float radius
+vec2 unscaled_extrude=vec2(mod(a_pos,2.0)*2.0-1.0);float S=sqrt(-2.0*log(ZERO/weight/u_intensity/GAUSS_COEF))/3.0;v_extrude=S*unscaled_extrude;vec2 extrude=v_extrude*radius*u_extrude_scale;vec4 pos=vec4(floor(a_pos*0.5)+extrude,get_elevation(floor(a_pos*0.5)),1);gl_Position=u_matrix*pos;}`), heatmapTexture: Mt(`uniform sampler2D u_image;uniform sampler2D u_color_ramp;uniform float u_opacity;varying vec2 v_pos;void main() {float t=texture2D(u_image,v_pos).r;vec4 color=texture2D(u_color_ramp,vec2(t,0.5));gl_FragColor=color*u_opacity;
+#ifdef OVERDRAW_INSPECTOR
+gl_FragColor=vec4(0.0);
+#endif
+}`, "uniform mat4 u_matrix;uniform vec2 u_world;attribute vec2 a_pos;varying vec2 v_pos;void main() {gl_Position=u_matrix*vec4(a_pos*u_world,0,1);v_pos.x=a_pos.x;v_pos.y=1.0-a_pos.y;}"), collisionBox: Mt("varying float v_placed;varying float v_notUsed;void main() {float alpha=0.5;gl_FragColor=vec4(1.0,0.0,0.0,1.0)*alpha;if (v_placed > 0.5) {gl_FragColor=vec4(0.0,0.0,1.0,0.5)*alpha;}if (v_notUsed > 0.5) {gl_FragColor*=.1;}}", "attribute vec2 a_anchor_pos;attribute vec2 a_placed;attribute vec2 a_box_real;uniform mat4 u_matrix;uniform vec2 u_pixel_extrude_scale;varying float v_placed;varying float v_notUsed;vec4 projectTileWithElevation(vec2 posInTile,float elevation) {return u_matrix*vec4(posInTile,elevation,1.0);}void main() {gl_Position=projectTileWithElevation(a_anchor_pos,get_elevation(a_anchor_pos));gl_Position.xy=((a_box_real+0.5)*u_pixel_extrude_scale*2.0-1.0)*vec2(1.0,-1.0)*gl_Position.w;if (gl_Position.z/gl_Position.w < 1.1) {gl_Position.z=0.5;}v_placed=a_placed.x;v_notUsed=a_placed.y;}"), collisionCircle: Mt("varying float v_radius;varying vec2 v_extrude;varying float v_perspective_ratio;varying float v_collision;void main() {float alpha=0.5*min(v_perspective_ratio,1.0);float stroke_radius=0.9*max(v_perspective_ratio,1.0);float distance_to_center=length(v_extrude);float distance_to_edge=abs(distance_to_center-v_radius);float opacity_t=smoothstep(-stroke_radius,0.0,-distance_to_edge);vec4 color=mix(vec4(0.0,0.0,1.0,0.5),vec4(1.0,0.0,0.0,1.0),v_collision);gl_FragColor=color*alpha*opacity_t;}", "attribute vec2 a_pos;attribute float a_radius;attribute vec2 a_flags;uniform mat4 u_matrix;uniform mat4 u_inv_matrix;uniform vec2 u_viewport_size;uniform float u_camera_to_center_distance;varying float v_radius;varying vec2 v_extrude;varying float v_perspective_ratio;varying float v_collision;vec3 toTilePosition(vec2 screenPos) {vec4 rayStart=u_inv_matrix*vec4(screenPos,-1.0,1.0);vec4 rayEnd  =u_inv_matrix*vec4(screenPos, 1.0,1.0);rayStart.xyz/=rayStart.w;rayEnd.xyz  /=rayEnd.w;highp float t=(0.0-rayStart.z)/(rayEnd.z-rayStart.z);return mix(rayStart.xyz,rayEnd.xyz,t);}void main() {vec2 quadCenterPos=a_pos;float radius=a_radius;float collision=a_flags.x;float vertexIdx=a_flags.y;vec2 quadVertexOffset=vec2(mix(-1.0,1.0,float(vertexIdx >=2.0)),mix(-1.0,1.0,float(vertexIdx >=1.0 && vertexIdx <=2.0)));vec2 quadVertexExtent=quadVertexOffset*radius;vec3 tilePos=toTilePosition(quadCenterPos);vec4 clipPos=u_matrix*vec4(tilePos,1.0);highp float camera_to_anchor_distance=clipPos.w;highp float collision_perspective_ratio=clamp(0.5+0.5*(u_camera_to_center_distance/camera_to_anchor_distance),0.0,4.0);float padding_factor=1.2;v_radius=radius;v_extrude=quadVertexExtent*padding_factor;v_perspective_ratio=collision_perspective_ratio;v_collision=collision;gl_Position=vec4(clipPos.xyz/clipPos.w,1.0)+vec4(quadVertexExtent*padding_factor/u_viewport_size*2.0,0.0,0.0);}"), debug: Mt("uniform highp vec4 u_color;uniform sampler2D u_overlay;varying vec2 v_uv;void main() {vec4 overlay_color=texture2D(u_overlay,v_uv);gl_FragColor=mix(u_color,overlay_color,overlay_color.a);}", "attribute vec2 a_pos;varying vec2 v_uv;uniform mat4 u_matrix;uniform float u_overlay_scale;void main() {v_uv=a_pos/8192.0;gl_Position=u_matrix*vec4(a_pos*u_overlay_scale,get_elevation(a_pos),1);}"), fill: Mt(`#pragma mapbox: define highp vec4 color
+#pragma mapbox: define lowp float opacity
+void main() {
+#pragma mapbox: initialize highp vec4 color
+#pragma mapbox: initialize lowp float opacity
+gl_FragColor=color*opacity;
+#ifdef OVERDRAW_INSPECTOR
+gl_FragColor=vec4(1.0);
+#endif
+}`, `attribute vec2 a_pos;uniform mat4 u_matrix;
+#pragma mapbox: define highp vec4 color
+#pragma mapbox: define lowp float opacity
+void main() {
+#pragma mapbox: initialize highp vec4 color
+#pragma mapbox: initialize lowp float opacity
+gl_Position=u_matrix*vec4(a_pos,0,1);}`), fillOutline: Mt(`varying vec2 v_pos;
+#pragma mapbox: define highp vec4 outline_color
+#pragma mapbox: define lowp float opacity
+void main() {
+#pragma mapbox: initialize highp vec4 outline_color
+#pragma mapbox: initialize lowp float opacity
+float dist=length(v_pos-gl_FragCoord.xy);float alpha=1.0-smoothstep(0.0,1.0,dist);gl_FragColor=outline_color*(alpha*opacity);
+#ifdef OVERDRAW_INSPECTOR
+gl_FragColor=vec4(1.0);
+#endif
+}`, `attribute vec2 a_pos;uniform mat4 u_matrix;uniform vec2 u_world;varying vec2 v_pos;
+#pragma mapbox: define highp vec4 outline_color
+#pragma mapbox: define lowp float opacity
+void main() {
+#pragma mapbox: initialize highp vec4 outline_color
+#pragma mapbox: initialize lowp float opacity
+gl_Position=u_matrix*vec4(a_pos,0,1);v_pos=(gl_Position.xy/gl_Position.w+1.0)/2.0*u_world;}`), fillOutlinePattern: Mt(`uniform vec2 u_texsize;uniform sampler2D u_image;uniform float u_fade;varying vec2 v_pos_a;varying vec2 v_pos_b;varying vec2 v_pos;
+#pragma mapbox: define lowp float opacity
+#pragma mapbox: define lowp vec4 pattern_from
+#pragma mapbox: define lowp vec4 pattern_to
+void main() {
+#pragma mapbox: initialize lowp float opacity
+#pragma mapbox: initialize mediump vec4 pattern_from
+#pragma mapbox: initialize mediump vec4 pattern_to
+vec2 pattern_tl_a=pattern_from.xy;vec2 pattern_br_a=pattern_from.zw;vec2 pattern_tl_b=pattern_to.xy;vec2 pattern_br_b=pattern_to.zw;vec2 imagecoord=mod(v_pos_a,1.0);vec2 pos=mix(pattern_tl_a/u_texsize,pattern_br_a/u_texsize,imagecoord);vec4 color1=texture2D(u_image,pos);vec2 imagecoord_b=mod(v_pos_b,1.0);vec2 pos2=mix(pattern_tl_b/u_texsize,pattern_br_b/u_texsize,imagecoord_b);vec4 color2=texture2D(u_image,pos2);float dist=length(v_pos-gl_FragCoord.xy);float alpha=1.0-smoothstep(0.0,1.0,dist);gl_FragColor=mix(color1,color2,u_fade)*alpha*opacity;
+#ifdef OVERDRAW_INSPECTOR
+gl_FragColor=vec4(1.0);
+#endif
+}`, `uniform mat4 u_matrix;uniform vec2 u_world;uniform vec2 u_pixel_coord_upper;uniform vec2 u_pixel_coord_lower;uniform vec3 u_scale;attribute vec2 a_pos;varying vec2 v_pos_a;varying vec2 v_pos_b;varying vec2 v_pos;
+#pragma mapbox: define lowp float opacity
+#pragma mapbox: define lowp vec4 pattern_from
+#pragma mapbox: define lowp vec4 pattern_to
+#pragma mapbox: define lowp float pixel_ratio_from
+#pragma mapbox: define lowp float pixel_ratio_to
+void main() {
+#pragma mapbox: initialize lowp float opacity
+#pragma mapbox: initialize mediump vec4 pattern_from
+#pragma mapbox: initialize mediump vec4 pattern_to
+#pragma mapbox: initialize lowp float pixel_ratio_from
+#pragma mapbox: initialize lowp float pixel_ratio_to
+vec2 pattern_tl_a=pattern_from.xy;vec2 pattern_br_a=pattern_from.zw;vec2 pattern_tl_b=pattern_to.xy;vec2 pattern_br_b=pattern_to.zw;float tileRatio=u_scale.x;float fromScale=u_scale.y;float toScale=u_scale.z;gl_Position=u_matrix*vec4(a_pos,0,1);vec2 display_size_a=(pattern_br_a-pattern_tl_a)/pixel_ratio_from;vec2 display_size_b=(pattern_br_b-pattern_tl_b)/pixel_ratio_to;v_pos_a=get_pattern_pos(u_pixel_coord_upper,u_pixel_coord_lower,fromScale*display_size_a,tileRatio,a_pos);v_pos_b=get_pattern_pos(u_pixel_coord_upper,u_pixel_coord_lower,toScale*display_size_b,tileRatio,a_pos);v_pos=(gl_Position.xy/gl_Position.w+1.0)/2.0*u_world;}`), fillPattern: Mt(`#ifdef GL_ES
+precision highp float;
+#endif
+uniform vec2 u_texsize;uniform float u_fade;uniform sampler2D u_image;varying vec2 v_pos_a;varying vec2 v_pos_b;
+#pragma mapbox: define lowp float opacity
+#pragma mapbox: define lowp vec4 pattern_from
+#pragma mapbox: define lowp vec4 pattern_to
+void main() {
+#pragma mapbox: initialize lowp float opacity
+#pragma mapbox: initialize mediump vec4 pattern_from
+#pragma mapbox: initialize mediump vec4 pattern_to
+vec2 pattern_tl_a=pattern_from.xy;vec2 pattern_br_a=pattern_from.zw;vec2 pattern_tl_b=pattern_to.xy;vec2 pattern_br_b=pattern_to.zw;vec2 imagecoord=mod(v_pos_a,1.0);vec2 pos=mix(pattern_tl_a/u_texsize,pattern_br_a/u_texsize,imagecoord);vec4 color1=texture2D(u_image,pos);vec2 imagecoord_b=mod(v_pos_b,1.0);vec2 pos2=mix(pattern_tl_b/u_texsize,pattern_br_b/u_texsize,imagecoord_b);vec4 color2=texture2D(u_image,pos2);gl_FragColor=mix(color1,color2,u_fade)*opacity;
+#ifdef OVERDRAW_INSPECTOR
+gl_FragColor=vec4(1.0);
+#endif
+}`, `uniform mat4 u_matrix;uniform vec2 u_pixel_coord_upper;uniform vec2 u_pixel_coord_lower;uniform vec3 u_scale;attribute vec2 a_pos;varying vec2 v_pos_a;varying vec2 v_pos_b;
+#pragma mapbox: define lowp float opacity
+#pragma mapbox: define lowp vec4 pattern_from
+#pragma mapbox: define lowp vec4 pattern_to
+#pragma mapbox: define lowp float pixel_ratio_from
+#pragma mapbox: define lowp float pixel_ratio_to
+void main() {
+#pragma mapbox: initialize lowp float opacity
+#pragma mapbox: initialize mediump vec4 pattern_from
+#pragma mapbox: initialize mediump vec4 pattern_to
+#pragma mapbox: initialize lowp float pixel_ratio_from
+#pragma mapbox: initialize lowp float pixel_ratio_to
+vec2 pattern_tl_a=pattern_from.xy;vec2 pattern_br_a=pattern_from.zw;vec2 pattern_tl_b=pattern_to.xy;vec2 pattern_br_b=pattern_to.zw;float tileZoomRatio=u_scale.x;float fromScale=u_scale.y;float toScale=u_scale.z;vec2 display_size_a=(pattern_br_a-pattern_tl_a)/pixel_ratio_from;vec2 display_size_b=(pattern_br_b-pattern_tl_b)/pixel_ratio_to;gl_Position=u_matrix*vec4(a_pos,0,1);v_pos_a=get_pattern_pos(u_pixel_coord_upper,u_pixel_coord_lower,fromScale*display_size_a,tileZoomRatio,a_pos);v_pos_b=get_pattern_pos(u_pixel_coord_upper,u_pixel_coord_lower,toScale*display_size_b,tileZoomRatio,a_pos);}`), fillExtrusion: Mt(`varying vec4 v_color;void main() {gl_FragColor=v_color;
+#ifdef OVERDRAW_INSPECTOR
+gl_FragColor=vec4(1.0);
+#endif
+}`, `uniform mat4 u_matrix;uniform vec3 u_lightcolor;uniform lowp vec3 u_lightpos;uniform lowp float u_lightintensity;uniform float u_vertical_gradient;uniform lowp float u_opacity;attribute vec2 a_pos;attribute vec4 a_normal_ed;
+#ifdef TERRAIN3D
+attribute vec2 a_centroid;
+#endif
+varying vec4 v_color;
+#pragma mapbox: define highp float base
+#pragma mapbox: define highp float height
+#pragma mapbox: define highp vec4 color
+void main() {
+#pragma mapbox: initialize highp float base
+#pragma mapbox: initialize highp float height
+#pragma mapbox: initialize highp vec4 color
+vec3 normal=a_normal_ed.xyz;
+#ifdef TERRAIN3D
+float height_terrain3d_offset=get_elevation(a_centroid);float base_terrain3d_offset=height_terrain3d_offset-(base > 0.0 ? 0.0 : 10.0);
+#else
+float height_terrain3d_offset=0.0;float base_terrain3d_offset=0.0;
+#endif
+base=max(0.0,base)+base_terrain3d_offset;height=max(0.0,height)+height_terrain3d_offset;float t=mod(normal.x,2.0);gl_Position=u_matrix*vec4(a_pos,t > 0.0 ? height : base,1);float colorvalue=color.r*0.2126+color.g*0.7152+color.b*0.0722;v_color=vec4(0.0,0.0,0.0,1.0);vec4 ambientlight=vec4(0.03,0.03,0.03,1.0);color+=ambientlight;float directional=clamp(dot(normal/16384.0,u_lightpos),0.0,1.0);directional=mix((1.0-u_lightintensity),max((1.0-colorvalue+u_lightintensity),1.0),directional);if (normal.y !=0.0) {directional*=((1.0-u_vertical_gradient)+(u_vertical_gradient*clamp((t+base)*pow(height/150.0,0.5),mix(0.7,0.98,1.0-u_lightintensity),1.0)));}v_color.r+=clamp(color.r*directional*u_lightcolor.r,mix(0.0,0.3,1.0-u_lightcolor.r),1.0);v_color.g+=clamp(color.g*directional*u_lightcolor.g,mix(0.0,0.3,1.0-u_lightcolor.g),1.0);v_color.b+=clamp(color.b*directional*u_lightcolor.b,mix(0.0,0.3,1.0-u_lightcolor.b),1.0);v_color*=u_opacity;}`), fillExtrusionPattern: Mt(`uniform vec2 u_texsize;uniform float u_fade;uniform sampler2D u_image;varying vec2 v_pos_a;varying vec2 v_pos_b;varying vec4 v_lighting;
+#pragma mapbox: define lowp float base
+#pragma mapbox: define lowp float height
+#pragma mapbox: define lowp vec4 pattern_from
+#pragma mapbox: define lowp vec4 pattern_to
+#pragma mapbox: define lowp float pixel_ratio_from
+#pragma mapbox: define lowp float pixel_ratio_to
+void main() {
+#pragma mapbox: initialize lowp float base
+#pragma mapbox: initialize lowp float height
+#pragma mapbox: initialize mediump vec4 pattern_from
+#pragma mapbox: initialize mediump vec4 pattern_to
+#pragma mapbox: initialize lowp float pixel_ratio_from
+#pragma mapbox: initialize lowp float pixel_ratio_to
+vec2 pattern_tl_a=pattern_from.xy;vec2 pattern_br_a=pattern_from.zw;vec2 pattern_tl_b=pattern_to.xy;vec2 pattern_br_b=pattern_to.zw;vec2 imagecoord=mod(v_pos_a,1.0);vec2 pos=mix(pattern_tl_a/u_texsize,pattern_br_a/u_texsize,imagecoord);vec4 color1=texture2D(u_image,pos);vec2 imagecoord_b=mod(v_pos_b,1.0);vec2 pos2=mix(pattern_tl_b/u_texsize,pattern_br_b/u_texsize,imagecoord_b);vec4 color2=texture2D(u_image,pos2);vec4 mixedColor=mix(color1,color2,u_fade);gl_FragColor=mixedColor*v_lighting;
+#ifdef OVERDRAW_INSPECTOR
+gl_FragColor=vec4(1.0);
+#endif
+}`, `uniform mat4 u_matrix;uniform vec2 u_pixel_coord_upper;uniform vec2 u_pixel_coord_lower;uniform float u_height_factor;uniform vec3 u_scale;uniform float u_vertical_gradient;uniform lowp float u_opacity;uniform vec3 u_lightcolor;uniform lowp vec3 u_lightpos;uniform lowp float u_lightintensity;attribute vec2 a_pos;attribute vec4 a_normal_ed;
+#ifdef TERRAIN3D
+attribute vec2 a_centroid;
+#endif
+varying vec2 v_pos_a;varying vec2 v_pos_b;varying vec4 v_lighting;
+#pragma mapbox: define lowp float base
+#pragma mapbox: define lowp float height
+#pragma mapbox: define lowp vec4 pattern_from
+#pragma mapbox: define lowp vec4 pattern_to
+#pragma mapbox: define lowp float pixel_ratio_from
+#pragma mapbox: define lowp float pixel_ratio_to
+void main() {
+#pragma mapbox: initialize lowp float base
+#pragma mapbox: initialize lowp float height
+#pragma mapbox: initialize mediump vec4 pattern_from
+#pragma mapbox: initialize mediump vec4 pattern_to
+#pragma mapbox: initialize lowp float pixel_ratio_from
+#pragma mapbox: initialize lowp float pixel_ratio_to
+vec2 pattern_tl_a=pattern_from.xy;vec2 pattern_br_a=pattern_from.zw;vec2 pattern_tl_b=pattern_to.xy;vec2 pattern_br_b=pattern_to.zw;float tileRatio=u_scale.x;float fromScale=u_scale.y;float toScale=u_scale.z;vec3 normal=a_normal_ed.xyz;float edgedistance=a_normal_ed.w;vec2 display_size_a=(pattern_br_a-pattern_tl_a)/pixel_ratio_from;vec2 display_size_b=(pattern_br_b-pattern_tl_b)/pixel_ratio_to;
+#ifdef TERRAIN3D
+float height_terrain3d_offset=get_elevation(a_centroid);float base_terrain3d_offset=height_terrain3d_offset-(base > 0.0 ? 0.0 : 10.0);
+#else
+float height_terrain3d_offset=0.0;float base_terrain3d_offset=0.0;
+#endif
+base=max(0.0,base)+base_terrain3d_offset;height=max(0.0,height)+height_terrain3d_offset;float t=mod(normal.x,2.0);float z=t > 0.0 ? height : base;gl_Position=u_matrix*vec4(a_pos,z,1);vec2 pos=normal.x==1.0 && normal.y==0.0 && normal.z==16384.0
+? a_pos
+: vec2(edgedistance,z*u_height_factor);v_pos_a=get_pattern_pos(u_pixel_coord_upper,u_pixel_coord_lower,fromScale*display_size_a,tileRatio,pos);v_pos_b=get_pattern_pos(u_pixel_coord_upper,u_pixel_coord_lower,toScale*display_size_b,tileRatio,pos);v_lighting=vec4(0.0,0.0,0.0,1.0);float directional=clamp(dot(normal/16383.0,u_lightpos),0.0,1.0);directional=mix((1.0-u_lightintensity),max((0.5+u_lightintensity),1.0),directional);if (normal.y !=0.0) {directional*=((1.0-u_vertical_gradient)+(u_vertical_gradient*clamp((t+base)*pow(height/150.0,0.5),mix(0.7,0.98,1.0-u_lightintensity),1.0)));}v_lighting.rgb+=clamp(directional*u_lightcolor,mix(vec3(0.0),vec3(0.3),1.0-u_lightcolor),vec3(1.0));v_lighting*=u_opacity;}`), hillshadePrepare: Mt(`#ifdef GL_ES
+precision highp float;
+#endif
+uniform sampler2D u_image;varying vec2 v_pos;uniform vec2 u_dimension;uniform float u_zoom;uniform vec4 u_unpack;float getElevation(vec2 coord,float bias) {vec4 data=texture2D(u_image,coord)*255.0;data.a=-1.0;return dot(data,u_unpack)/4.0;}void main() {vec2 epsilon=1.0/u_dimension;float a=getElevation(v_pos+vec2(-epsilon.x,-epsilon.y),0.0);float b=getElevation(v_pos+vec2(0,-epsilon.y),0.0);float c=getElevation(v_pos+vec2(epsilon.x,-epsilon.y),0.0);float d=getElevation(v_pos+vec2(-epsilon.x,0),0.0);float e=getElevation(v_pos,0.0);float f=getElevation(v_pos+vec2(epsilon.x,0),0.0);float g=getElevation(v_pos+vec2(-epsilon.x,epsilon.y),0.0);float h=getElevation(v_pos+vec2(0,epsilon.y),0.0);float i=getElevation(v_pos+vec2(epsilon.x,epsilon.y),0.0);float exaggerationFactor=u_zoom < 2.0 ? 0.4 : u_zoom < 4.5 ? 0.35 : 0.3;float exaggeration=u_zoom < 15.0 ? (u_zoom-15.0)*exaggerationFactor : 0.0;vec2 deriv=vec2((c+f+f+i)-(a+d+d+g),(g+h+h+i)-(a+b+b+c))/pow(2.0,exaggeration+(19.2562-u_zoom));gl_FragColor=clamp(vec4(deriv.x/2.0+0.5,deriv.y/2.0+0.5,1.0,1.0),0.0,1.0);
+#ifdef OVERDRAW_INSPECTOR
+gl_FragColor=vec4(1.0);
+#endif
+}`, "uniform mat4 u_matrix;uniform vec2 u_dimension;attribute vec2 a_pos;attribute vec2 a_texture_pos;varying vec2 v_pos;void main() {gl_Position=u_matrix*vec4(a_pos,0,1);highp vec2 epsilon=1.0/u_dimension;float scale=(u_dimension.x-2.0)/u_dimension.x;v_pos=(a_texture_pos/8192.0)*scale+epsilon;}"), hillshade: Mt(`uniform sampler2D u_image;varying vec2 v_pos;uniform vec2 u_latrange;uniform vec2 u_light;uniform vec4 u_shadow;uniform vec4 u_highlight;uniform vec4 u_accent;
+#define PI 3.141592653589793
+void main() {vec4 pixel=texture2D(u_image,v_pos);vec2 deriv=((pixel.rg*2.0)-1.0);float scaleFactor=cos(radians((u_latrange[0]-u_latrange[1])*(1.0-v_pos.y)+u_latrange[1]));float slope=atan(1.25*length(deriv)/scaleFactor);float aspect=deriv.x !=0.0 ? atan(deriv.y,-deriv.x) : PI/2.0*(deriv.y > 0.0 ? 1.0 :-1.0);float intensity=u_light.x;float azimuth=u_light.y+PI;float base=1.875-intensity*1.75;float maxValue=0.5*PI;float scaledSlope=intensity !=0.5 ? ((pow(base,slope)-1.0)/(pow(base,maxValue)-1.0))*maxValue : slope;float accent=cos(scaledSlope);vec4 accent_color=(1.0-accent)*u_accent*clamp(intensity*2.0,0.0,1.0);float shade=abs(mod((aspect+azimuth)/PI+0.5,2.0)-1.0);vec4 shade_color=mix(u_shadow,u_highlight,shade)*sin(scaledSlope)*clamp(intensity*2.0,0.0,1.0);gl_FragColor=accent_color*(1.0-shade_color.a)+shade_color;
+#ifdef OVERDRAW_INSPECTOR
+gl_FragColor=vec4(1.0);
+#endif
+}`, "uniform mat4 u_matrix;attribute vec2 a_pos;attribute vec2 a_texture_pos;varying vec2 v_pos;void main() {gl_Position=u_matrix*vec4(a_pos,0,1);v_pos=a_texture_pos/8192.0;}"), line: Mt(`uniform lowp float u_device_pixel_ratio;varying vec2 v_width2;varying vec2 v_normal;varying float v_gamma_scale;
+#pragma mapbox: define highp vec4 color
+#pragma mapbox: define lowp float blur
+#pragma mapbox: define lowp float opacity
+void main() {
+#pragma mapbox: initialize highp vec4 color
+#pragma mapbox: initialize lowp float blur
+#pragma mapbox: initialize lowp float opacity
+float dist=length(v_normal)*v_width2.s;float blur2=(blur+1.0/u_device_pixel_ratio)*v_gamma_scale;float alpha=clamp(min(dist-(v_width2.t-blur2),v_width2.s-dist)/blur2,0.0,1.0);gl_FragColor=color*(alpha*opacity);
+#ifdef OVERDRAW_INSPECTOR
+gl_FragColor=vec4(1.0);
+#endif
+}`, `
+#define scale 0.015873016
+attribute vec2 a_pos_normal;attribute vec4 a_data;uniform mat4 u_matrix;uniform mediump float u_ratio;uniform vec2 u_units_to_pixels;uniform lowp float u_device_pixel_ratio;varying vec2 v_normal;varying vec2 v_width2;varying float v_gamma_scale;varying highp float v_linesofar;
+#pragma mapbox: define highp vec4 color
+#pragma mapbox: define lowp float blur
+#pragma mapbox: define lowp float opacity
+#pragma mapbox: define mediump float gapwidth
+#pragma mapbox: define lowp float offset
+#pragma mapbox: define mediump float width
+void main() {
+#pragma mapbox: initialize highp vec4 color
+#pragma mapbox: initialize lowp float blur
+#pragma mapbox: initialize lowp float opacity
+#pragma mapbox: initialize mediump float gapwidth
+#pragma mapbox: initialize lowp float offset
+#pragma mapbox: initialize mediump float width
+float ANTIALIASING=1.0/u_device_pixel_ratio/2.0;vec2 a_extrude=a_data.xy-128.0;float a_direction=mod(a_data.z,4.0)-1.0;v_linesofar=(floor(a_data.z/4.0)+a_data.w*64.0)*2.0;vec2 pos=floor(a_pos_normal*0.5);mediump vec2 normal=a_pos_normal-2.0*pos;normal.y=normal.y*2.0-1.0;v_normal=normal;gapwidth=gapwidth/2.0;float halfwidth=width/2.0;offset=-1.0*offset;float inset=gapwidth+(gapwidth > 0.0 ? ANTIALIASING : 0.0);float outset=gapwidth+halfwidth*(gapwidth > 0.0 ? 2.0 : 1.0)+(halfwidth==0.0 ? 0.0 : ANTIALIASING);mediump vec2 dist=outset*a_extrude*scale;mediump float u=0.5*a_direction;mediump float t=1.0-abs(u);mediump vec2 offset2=offset*a_extrude*scale*normal.y*mat2(t,-u,u,t);vec4 projected_extrude=u_matrix*vec4(dist/u_ratio,0.0,0.0);gl_Position=u_matrix*vec4(pos+offset2/u_ratio,0.0,1.0)+projected_extrude;
+#ifdef TERRAIN3D
+v_gamma_scale=1.0;
+#else
+float extrude_length_without_perspective=length(dist);float extrude_length_with_perspective=length(projected_extrude.xy/gl_Position.w*u_units_to_pixels);v_gamma_scale=extrude_length_without_perspective/extrude_length_with_perspective;
+#endif
+v_width2=vec2(outset,inset);}`), lineGradient: Mt(`uniform lowp float u_device_pixel_ratio;uniform sampler2D u_image;varying vec2 v_width2;varying vec2 v_normal;varying float v_gamma_scale;varying highp vec2 v_uv;
+#pragma mapbox: define lowp float blur
+#pragma mapbox: define lowp float opacity
+void main() {
+#pragma mapbox: initialize lowp float blur
+#pragma mapbox: initialize lowp float opacity
+float dist=length(v_normal)*v_width2.s;float blur2=(blur+1.0/u_device_pixel_ratio)*v_gamma_scale;float alpha=clamp(min(dist-(v_width2.t-blur2),v_width2.s-dist)/blur2,0.0,1.0);vec4 color=texture2D(u_image,v_uv);gl_FragColor=color*(alpha*opacity);
+#ifdef OVERDRAW_INSPECTOR
+gl_FragColor=vec4(1.0);
+#endif
+}`, `
+#define scale 0.015873016
+attribute vec2 a_pos_normal;attribute vec4 a_data;attribute float a_uv_x;attribute float a_split_index;uniform mat4 u_matrix;uniform mediump float u_ratio;uniform lowp float u_device_pixel_ratio;uniform vec2 u_units_to_pixels;uniform float u_image_height;varying vec2 v_normal;varying vec2 v_width2;varying float v_gamma_scale;varying highp vec2 v_uv;
+#pragma mapbox: define lowp float blur
+#pragma mapbox: define lowp float opacity
+#pragma mapbox: define mediump float gapwidth
+#pragma mapbox: define lowp float offset
+#pragma mapbox: define mediump float width
+void main() {
+#pragma mapbox: initialize lowp float blur
+#pragma mapbox: initialize lowp float opacity
+#pragma mapbox: initialize mediump float gapwidth
+#pragma mapbox: initialize lowp float offset
+#pragma mapbox: initialize mediump float width
+float ANTIALIASING=1.0/u_device_pixel_ratio/2.0;vec2 a_extrude=a_data.xy-128.0;float a_direction=mod(a_data.z,4.0)-1.0;highp float texel_height=1.0/u_image_height;highp float half_texel_height=0.5*texel_height;v_uv=vec2(a_uv_x,a_split_index*texel_height-half_texel_height);vec2 pos=floor(a_pos_normal*0.5);mediump vec2 normal=a_pos_normal-2.0*pos;normal.y=normal.y*2.0-1.0;v_normal=normal;gapwidth=gapwidth/2.0;float halfwidth=width/2.0;offset=-1.0*offset;float inset=gapwidth+(gapwidth > 0.0 ? ANTIALIASING : 0.0);float outset=gapwidth+halfwidth*(gapwidth > 0.0 ? 2.0 : 1.0)+(halfwidth==0.0 ? 0.0 : ANTIALIASING);mediump vec2 dist=outset*a_extrude*scale;mediump float u=0.5*a_direction;mediump float t=1.0-abs(u);mediump vec2 offset2=offset*a_extrude*scale*normal.y*mat2(t,-u,u,t);vec4 projected_extrude=u_matrix*vec4(dist/u_ratio,0.0,0.0);gl_Position=u_matrix*vec4(pos+offset2/u_ratio,0.0,1.0)+projected_extrude;
+#ifdef TERRAIN3D
+v_gamma_scale=1.0;
+#else
+float extrude_length_without_perspective=length(dist);float extrude_length_with_perspective=length(projected_extrude.xy/gl_Position.w*u_units_to_pixels);v_gamma_scale=extrude_length_without_perspective/extrude_length_with_perspective;
+#endif
+v_width2=vec2(outset,inset);}`), linePattern: Mt(`#ifdef GL_ES
+precision highp float;
+#endif
+uniform lowp float u_device_pixel_ratio;uniform vec2 u_texsize;uniform float u_fade;uniform mediump vec3 u_scale;uniform sampler2D u_image;varying vec2 v_normal;varying vec2 v_width2;varying float v_linesofar;varying float v_gamma_scale;varying float v_width;
+#pragma mapbox: define lowp vec4 pattern_from
+#pragma mapbox: define lowp vec4 pattern_to
+#pragma mapbox: define lowp float pixel_ratio_from
+#pragma mapbox: define lowp float pixel_ratio_to
+#pragma mapbox: define lowp float blur
+#pragma mapbox: define lowp float opacity
+void main() {
+#pragma mapbox: initialize mediump vec4 pattern_from
+#pragma mapbox: initialize mediump vec4 pattern_to
+#pragma mapbox: initialize lowp float pixel_ratio_from
+#pragma mapbox: initialize lowp float pixel_ratio_to
+#pragma mapbox: initialize lowp float blur
+#pragma mapbox: initialize lowp float opacity
+vec2 pattern_tl_a=pattern_from.xy;vec2 pattern_br_a=pattern_from.zw;vec2 pattern_tl_b=pattern_to.xy;vec2 pattern_br_b=pattern_to.zw;float tileZoomRatio=u_scale.x;float fromScale=u_scale.y;float toScale=u_scale.z;vec2 display_size_a=(pattern_br_a-pattern_tl_a)/pixel_ratio_from;vec2 display_size_b=(pattern_br_b-pattern_tl_b)/pixel_ratio_to;vec2 pattern_size_a=vec2(display_size_a.x*fromScale/tileZoomRatio,display_size_a.y);vec2 pattern_size_b=vec2(display_size_b.x*toScale/tileZoomRatio,display_size_b.y);float aspect_a=display_size_a.y/v_width;float aspect_b=display_size_b.y/v_width;float dist=length(v_normal)*v_width2.s;float blur2=(blur+1.0/u_device_pixel_ratio)*v_gamma_scale;float alpha=clamp(min(dist-(v_width2.t-blur2),v_width2.s-dist)/blur2,0.0,1.0);float x_a=mod(v_linesofar/pattern_size_a.x*aspect_a,1.0);float x_b=mod(v_linesofar/pattern_size_b.x*aspect_b,1.0);float y=0.5*v_normal.y+0.5;vec2 texel_size=1.0/u_texsize;vec2 pos_a=mix(pattern_tl_a*texel_size-texel_size,pattern_br_a*texel_size+texel_size,vec2(x_a,y));vec2 pos_b=mix(pattern_tl_b*texel_size-texel_size,pattern_br_b*texel_size+texel_size,vec2(x_b,y));vec4 color=mix(texture2D(u_image,pos_a),texture2D(u_image,pos_b),u_fade);gl_FragColor=color*alpha*opacity;
+#ifdef OVERDRAW_INSPECTOR
+gl_FragColor=vec4(1.0);
+#endif
+}`, `
+#define scale 0.015873016
+#define LINE_DISTANCE_SCALE 2.0
+attribute vec2 a_pos_normal;attribute vec4 a_data;uniform mat4 u_matrix;uniform vec2 u_units_to_pixels;uniform mediump float u_ratio;uniform lowp float u_device_pixel_ratio;varying vec2 v_normal;varying vec2 v_width2;varying float v_linesofar;varying float v_gamma_scale;varying float v_width;
+#pragma mapbox: define lowp float blur
+#pragma mapbox: define lowp float opacity
+#pragma mapbox: define lowp float offset
+#pragma mapbox: define mediump float gapwidth
+#pragma mapbox: define mediump float width
+#pragma mapbox: define lowp float floorwidth
+#pragma mapbox: define lowp vec4 pattern_from
+#pragma mapbox: define lowp vec4 pattern_to
+#pragma mapbox: define lowp float pixel_ratio_from
+#pragma mapbox: define lowp float pixel_ratio_to
+void main() {
+#pragma mapbox: initialize lowp float blur
+#pragma mapbox: initialize lowp float opacity
+#pragma mapbox: initialize lowp float offset
+#pragma mapbox: initialize mediump float gapwidth
+#pragma mapbox: initialize mediump float width
+#pragma mapbox: initialize lowp float floorwidth
+#pragma mapbox: initialize mediump vec4 pattern_from
+#pragma mapbox: initialize mediump vec4 pattern_to
+#pragma mapbox: initialize lowp float pixel_ratio_from
+#pragma mapbox: initialize lowp float pixel_ratio_to
+float ANTIALIASING=1.0/u_device_pixel_ratio/2.0;vec2 a_extrude=a_data.xy-128.0;float a_direction=mod(a_data.z,4.0)-1.0;float a_linesofar=(floor(a_data.z/4.0)+a_data.w*64.0)*LINE_DISTANCE_SCALE;vec2 pos=floor(a_pos_normal*0.5);mediump vec2 normal=a_pos_normal-2.0*pos;normal.y=normal.y*2.0-1.0;v_normal=normal;gapwidth=gapwidth/2.0;float halfwidth=width/2.0;offset=-1.0*offset;float inset=gapwidth+(gapwidth > 0.0 ? ANTIALIASING : 0.0);float outset=gapwidth+halfwidth*(gapwidth > 0.0 ? 2.0 : 1.0)+(halfwidth==0.0 ? 0.0 : ANTIALIASING);mediump vec2 dist=outset*a_extrude*scale;mediump float u=0.5*a_direction;mediump float t=1.0-abs(u);mediump vec2 offset2=offset*a_extrude*scale*normal.y*mat2(t,-u,u,t);vec4 projected_extrude=u_matrix*vec4(dist/u_ratio,0.0,0.0);gl_Position=u_matrix*vec4(pos+offset2/u_ratio,0.0,1.0)+projected_extrude;
+#ifdef TERRAIN3D
+v_gamma_scale=1.0;
+#else
+float extrude_length_without_perspective=length(dist);float extrude_length_with_perspective=length(projected_extrude.xy/gl_Position.w*u_units_to_pixels);v_gamma_scale=extrude_length_without_perspective/extrude_length_with_perspective;
+#endif
+v_linesofar=a_linesofar;v_width2=vec2(outset,inset);v_width=floorwidth;}`), lineSDF: Mt(`uniform lowp float u_device_pixel_ratio;uniform sampler2D u_image;uniform float u_sdfgamma;uniform float u_mix;varying vec2 v_normal;varying vec2 v_width2;varying vec2 v_tex_a;varying vec2 v_tex_b;varying float v_gamma_scale;
+#pragma mapbox: define highp vec4 color
+#pragma mapbox: define lowp float blur
+#pragma mapbox: define lowp float opacity
+#pragma mapbox: define mediump float width
+#pragma mapbox: define lowp float floorwidth
+void main() {
+#pragma mapbox: initialize highp vec4 color
+#pragma mapbox: initialize lowp float blur
+#pragma mapbox: initialize lowp float opacity
+#pragma mapbox: initialize mediump float width
+#pragma mapbox: initialize lowp float floorwidth
+float dist=length(v_normal)*v_width2.s;float blur2=(blur+1.0/u_device_pixel_ratio)*v_gamma_scale;float alpha=clamp(min(dist-(v_width2.t-blur2),v_width2.s-dist)/blur2,0.0,1.0);float sdfdist_a=texture2D(u_image,v_tex_a).a;float sdfdist_b=texture2D(u_image,v_tex_b).a;float sdfdist=mix(sdfdist_a,sdfdist_b,u_mix);alpha*=smoothstep(0.5-u_sdfgamma/floorwidth,0.5+u_sdfgamma/floorwidth,sdfdist);gl_FragColor=color*(alpha*opacity);
+#ifdef OVERDRAW_INSPECTOR
+gl_FragColor=vec4(1.0);
+#endif
+}`, `
+#define scale 0.015873016
+#define LINE_DISTANCE_SCALE 2.0
+attribute vec2 a_pos_normal;attribute vec4 a_data;uniform mat4 u_matrix;uniform mediump float u_ratio;uniform lowp float u_device_pixel_ratio;uniform vec2 u_patternscale_a;uniform float u_tex_y_a;uniform vec2 u_patternscale_b;uniform float u_tex_y_b;uniform vec2 u_units_to_pixels;varying vec2 v_normal;varying vec2 v_width2;varying vec2 v_tex_a;varying vec2 v_tex_b;varying float v_gamma_scale;
+#pragma mapbox: define highp vec4 color
+#pragma mapbox: define lowp float blur
+#pragma mapbox: define lowp float opacity
+#pragma mapbox: define mediump float gapwidth
+#pragma mapbox: define lowp float offset
+#pragma mapbox: define mediump float width
+#pragma mapbox: define lowp float floorwidth
+void main() {
+#pragma mapbox: initialize highp vec4 color
+#pragma mapbox: initialize lowp float blur
+#pragma mapbox: initialize lowp float opacity
+#pragma mapbox: initialize mediump float gapwidth
+#pragma mapbox: initialize lowp float offset
+#pragma mapbox: initialize mediump float width
+#pragma mapbox: initialize lowp float floorwidth
+float ANTIALIASING=1.0/u_device_pixel_ratio/2.0;vec2 a_extrude=a_data.xy-128.0;float a_direction=mod(a_data.z,4.0)-1.0;float a_linesofar=(floor(a_data.z/4.0)+a_data.w*64.0)*LINE_DISTANCE_SCALE;vec2 pos=floor(a_pos_normal*0.5);mediump vec2 normal=a_pos_normal-2.0*pos;normal.y=normal.y*2.0-1.0;v_normal=normal;gapwidth=gapwidth/2.0;float halfwidth=width/2.0;offset=-1.0*offset;float inset=gapwidth+(gapwidth > 0.0 ? ANTIALIASING : 0.0);float outset=gapwidth+halfwidth*(gapwidth > 0.0 ? 2.0 : 1.0)+(halfwidth==0.0 ? 0.0 : ANTIALIASING);mediump vec2 dist=outset*a_extrude*scale;mediump float u=0.5*a_direction;mediump float t=1.0-abs(u);mediump vec2 offset2=offset*a_extrude*scale*normal.y*mat2(t,-u,u,t);vec4 projected_extrude=u_matrix*vec4(dist/u_ratio,0.0,0.0);gl_Position=u_matrix*vec4(pos+offset2/u_ratio,0.0,1.0)+projected_extrude;
+#ifdef TERRAIN3D
+v_gamma_scale=1.0;
+#else
+float extrude_length_without_perspective=length(dist);float extrude_length_with_perspective=length(projected_extrude.xy/gl_Position.w*u_units_to_pixels);v_gamma_scale=extrude_length_without_perspective/extrude_length_with_perspective;
+#endif
+v_tex_a=vec2(a_linesofar*u_patternscale_a.x/floorwidth,normal.y*u_patternscale_a.y+u_tex_y_a);v_tex_b=vec2(a_linesofar*u_patternscale_b.x/floorwidth,normal.y*u_patternscale_b.y+u_tex_y_b);v_width2=vec2(outset,inset);}`), raster: Mt(`uniform float u_fade_t;uniform float u_opacity;uniform sampler2D u_image0;uniform sampler2D u_image1;varying vec2 v_pos0;varying vec2 v_pos1;uniform float u_brightness_low;uniform float u_brightness_high;uniform float u_saturation_factor;uniform float u_contrast_factor;uniform vec3 u_spin_weights;void main() {vec4 color0=texture2D(u_image0,v_pos0);vec4 color1=texture2D(u_image1,v_pos1);if (color0.a > 0.0) {color0.rgb=color0.rgb/color0.a;}if (color1.a > 0.0) {color1.rgb=color1.rgb/color1.a;}vec4 color=mix(color0,color1,u_fade_t);color.a*=u_opacity;vec3 rgb=color.rgb;rgb=vec3(dot(rgb,u_spin_weights.xyz),dot(rgb,u_spin_weights.zxy),dot(rgb,u_spin_weights.yzx));float average=(color.r+color.g+color.b)/3.0;rgb+=(average-rgb)*u_saturation_factor;rgb=(rgb-0.5)*u_contrast_factor+0.5;vec3 u_high_vec=vec3(u_brightness_low,u_brightness_low,u_brightness_low);vec3 u_low_vec=vec3(u_brightness_high,u_brightness_high,u_brightness_high);gl_FragColor=vec4(mix(u_high_vec,u_low_vec,rgb)*color.a,color.a);
+#ifdef OVERDRAW_INSPECTOR
+gl_FragColor=vec4(1.0);
+#endif
+}`, "uniform mat4 u_matrix;uniform vec2 u_tl_parent;uniform float u_scale_parent;uniform float u_buffer_scale;attribute vec2 a_pos;attribute vec2 a_texture_pos;varying vec2 v_pos0;varying vec2 v_pos1;void main() {gl_Position=u_matrix*vec4(a_pos,0,1);v_pos0=(((a_texture_pos/8192.0)-0.5)/u_buffer_scale )+0.5;v_pos1=(v_pos0*u_scale_parent)+u_tl_parent;}"), symbolIcon: Mt(`uniform sampler2D u_texture;varying vec2 v_tex;varying float v_fade_opacity;
+#pragma mapbox: define lowp float opacity
+void main() {
+#pragma mapbox: initialize lowp float opacity
+lowp float alpha=opacity*v_fade_opacity;gl_FragColor=texture2D(u_texture,v_tex)*alpha;
+#ifdef OVERDRAW_INSPECTOR
+gl_FragColor=vec4(1.0);
+#endif
+}`, `attribute vec4 a_pos_offset;attribute vec4 a_data;attribute vec4 a_pixeloffset;attribute vec3 a_projected_pos;attribute float a_fade_opacity;uniform bool u_is_size_zoom_constant;uniform bool u_is_size_feature_constant;uniform highp float u_size_t;uniform highp float u_size;uniform highp float u_camera_to_center_distance;uniform highp float u_pitch;uniform bool u_rotate_symbol;uniform highp float u_aspect_ratio;uniform float u_fade_change;uniform mat4 u_matrix;uniform mat4 u_label_plane_matrix;uniform mat4 u_coord_matrix;uniform bool u_is_text;uniform bool u_pitch_with_map;uniform vec2 u_texsize;uniform bool u_is_along_line;uniform bool u_is_variable_anchor;uniform vec2 u_translation;uniform float u_pitched_scale;varying vec2 v_tex;varying float v_fade_opacity;vec4 projectTileWithElevation(vec2 posInTile,float elevation) {return u_matrix*vec4(posInTile,elevation,1.0);}
+#pragma mapbox: define lowp float opacity
+void main() {
+#pragma mapbox: initialize lowp float opacity
+vec2 a_pos=a_pos_offset.xy;vec2 a_offset=a_pos_offset.zw;vec2 a_tex=a_data.xy;vec2 a_size=a_data.zw;float a_size_min=floor(a_size[0]*0.5);vec2 a_pxoffset=a_pixeloffset.xy;vec2 a_minFontScale=a_pixeloffset.zw/256.0;float ele=get_elevation(a_pos);highp float segment_angle=-a_projected_pos[2];float size;if (!u_is_size_zoom_constant && !u_is_size_feature_constant) {size=mix(a_size_min,a_size[1],u_size_t)/128.0;} else if (u_is_size_zoom_constant && !u_is_size_feature_constant) {size=a_size_min/128.0;} else {size=u_size;}vec2 translated_a_pos=a_pos+u_translation;vec4 projectedPoint=projectTileWithElevation(translated_a_pos,ele);highp float camera_to_anchor_distance=projectedPoint.w;highp float distance_ratio=u_pitch_with_map ?
+camera_to_anchor_distance/u_camera_to_center_distance :
+u_camera_to_center_distance/camera_to_anchor_distance;highp float perspective_ratio=clamp(0.5+0.5*distance_ratio,0.0,4.0);size*=perspective_ratio;float fontScale=u_is_text ? size/24.0 : size;highp float symbol_rotation=0.0;if (u_rotate_symbol) {vec4 offsetProjectedPoint=projectTileWithElevation(translated_a_pos+vec2(1,0),ele);vec2 a=projectedPoint.xy/projectedPoint.w;vec2 b=offsetProjectedPoint.xy/offsetProjectedPoint.w;symbol_rotation=atan((b.y-a.y)/u_aspect_ratio,b.x-a.x);}highp float angle_sin=sin(segment_angle+symbol_rotation);highp float angle_cos=cos(segment_angle+symbol_rotation);mat2 rotation_matrix=mat2(angle_cos,-1.0*angle_sin,angle_sin,angle_cos);vec4 projected_pos;if (u_is_along_line || u_is_variable_anchor) {projected_pos=vec4(a_projected_pos.xy,ele,1.0);} else if (u_pitch_with_map) {projected_pos=u_label_plane_matrix*vec4(a_projected_pos.xy+u_translation,ele,1.0);} else {projected_pos=u_label_plane_matrix*projectTileWithElevation(a_projected_pos.xy+u_translation,ele);}float z=float(u_pitch_with_map)*projected_pos.z/projected_pos.w;float projectionScaling=1.0;vec4 finalPos=u_coord_matrix*vec4(projected_pos.xy/projected_pos.w+rotation_matrix*(a_offset/32.0*max(a_minFontScale,fontScale)+a_pxoffset/16.0)*projectionScaling,z,1.0);if(u_pitch_with_map) {finalPos=projectTileWithElevation(finalPos.xy,finalPos.z);}gl_Position=finalPos;v_tex=a_tex/u_texsize;vec2 fade_opacity=unpack_opacity(a_fade_opacity);float fade_change=fade_opacity[1] > 0.5 ? u_fade_change :-u_fade_change;float visibility=calculate_visibility(projectedPoint);v_fade_opacity=max(0.0,min(visibility,fade_opacity[0]+fade_change));}`), symbolSDF: Mt(`#define SDF_PX 8.0
+uniform bool u_is_halo;uniform sampler2D u_texture;uniform highp float u_gamma_scale;uniform lowp float u_device_pixel_ratio;uniform bool u_is_text;varying vec2 v_data0;varying vec3 v_data1;
+#pragma mapbox: define highp vec4 fill_color
+#pragma mapbox: define highp vec4 halo_color
+#pragma mapbox: define lowp float opacity
+#pragma mapbox: define lowp float halo_width
+#pragma mapbox: define lowp float halo_blur
+void main() {
+#pragma mapbox: initialize highp vec4 fill_color
+#pragma mapbox: initialize highp vec4 halo_color
+#pragma mapbox: initialize lowp float opacity
+#pragma mapbox: initialize lowp float halo_width
+#pragma mapbox: initialize lowp float halo_blur
+float EDGE_GAMMA=0.105/u_device_pixel_ratio;vec2 tex=v_data0.xy;float gamma_scale=v_data1.x;float size=v_data1.y;float fade_opacity=v_data1[2];float fontScale=u_is_text ? size/24.0 : size;lowp vec4 color=fill_color;highp float gamma=EDGE_GAMMA/(fontScale*u_gamma_scale);lowp float inner_edge=(256.0-64.0)/256.0;if (u_is_halo) {color=halo_color;gamma=(halo_blur*1.19/SDF_PX+EDGE_GAMMA)/(fontScale*u_gamma_scale);inner_edge=inner_edge+gamma*gamma_scale;}lowp float dist=texture2D(u_texture,tex).a;highp float gamma_scaled=gamma*gamma_scale;highp float alpha=smoothstep(inner_edge-gamma_scaled,inner_edge+gamma_scaled,dist);if (u_is_halo) {lowp float halo_edge=(6.0-halo_width/fontScale)/SDF_PX;alpha=min(smoothstep(halo_edge-gamma_scaled,halo_edge+gamma_scaled,dist),1.0-alpha);}gl_FragColor=color*(alpha*opacity*fade_opacity);
+#ifdef OVERDRAW_INSPECTOR
+gl_FragColor=vec4(1.0);
+#endif
+}`, `attribute vec4 a_pos_offset;attribute vec4 a_data;attribute vec4 a_pixeloffset;attribute vec3 a_projected_pos;attribute float a_fade_opacity;uniform bool u_is_size_zoom_constant;uniform bool u_is_size_feature_constant;uniform highp float u_size_t;uniform highp float u_size;uniform mat4 u_matrix;uniform mat4 u_label_plane_matrix;uniform mat4 u_coord_matrix;uniform bool u_is_text;uniform bool u_pitch_with_map;uniform bool u_is_along_line;uniform bool u_is_variable_anchor;uniform highp float u_pitch;uniform bool u_rotate_symbol;uniform highp float u_aspect_ratio;uniform highp float u_camera_to_center_distance;uniform float u_fade_change;uniform vec2 u_texsize;uniform vec2 u_translation;uniform float u_pitched_scale;varying vec2 v_data0;varying vec3 v_data1;vec4 projectTileWithElevation(vec2 posInTile,float elevation) {return u_matrix*vec4(posInTile,elevation,1.0);}
+#pragma mapbox: define highp vec4 fill_color
+#pragma mapbox: define highp vec4 halo_color
+#pragma mapbox: define lowp float opacity
+#pragma mapbox: define lowp float halo_width
+#pragma mapbox: define lowp float halo_blur
+void main() {
+#pragma mapbox: initialize highp vec4 fill_color
+#pragma mapbox: initialize highp vec4 halo_color
+#pragma mapbox: initialize lowp float opacity
+#pragma mapbox: initialize lowp float halo_width
+#pragma mapbox: initialize lowp float halo_blur
+vec2 a_pos=a_pos_offset.xy;vec2 a_offset=a_pos_offset.zw;vec2 a_tex=a_data.xy;vec2 a_size=a_data.zw;float a_size_min=floor(a_size[0]*0.5);vec2 a_pxoffset=a_pixeloffset.xy;float ele=get_elevation(a_pos);highp float segment_angle=-a_projected_pos[2];float size;if (!u_is_size_zoom_constant && !u_is_size_feature_constant) {size=mix(a_size_min,a_size[1],u_size_t)/128.0;} else if (u_is_size_zoom_constant && !u_is_size_feature_constant) {size=a_size_min/128.0;} else {size=u_size;}vec2 translated_a_pos=a_pos+u_translation;vec4 projectedPoint=projectTileWithElevation(translated_a_pos,ele);highp float camera_to_anchor_distance=projectedPoint.w;highp float distance_ratio=u_pitch_with_map ?
+camera_to_anchor_distance/u_camera_to_center_distance :
+u_camera_to_center_distance/camera_to_anchor_distance;highp float perspective_ratio=clamp(0.5+0.5*distance_ratio,0.0,4.0);size*=perspective_ratio;float fontScale=u_is_text ? size/24.0 : size;highp float symbol_rotation=0.0;if (u_rotate_symbol) {vec4 offsetProjectedPoint=projectTileWithElevation(translated_a_pos+vec2(1,0),ele);vec2 a=projectedPoint.xy/projectedPoint.w;vec2 b=offsetProjectedPoint.xy/offsetProjectedPoint.w;symbol_rotation=atan((b.y-a.y)/u_aspect_ratio,b.x-a.x);}highp float angle_sin=sin(segment_angle+symbol_rotation);highp float angle_cos=cos(segment_angle+symbol_rotation);mat2 rotation_matrix=mat2(angle_cos,-1.0*angle_sin,angle_sin,angle_cos);vec4 projected_pos;if (u_is_along_line || u_is_variable_anchor) {projected_pos=vec4(a_projected_pos.xy,ele,1.0);} else if (u_pitch_with_map) {projected_pos=u_label_plane_matrix*vec4(a_projected_pos.xy+u_translation,ele,1.0);} else {projected_pos=u_label_plane_matrix*projectTileWithElevation(a_projected_pos.xy+u_translation,ele);}float z=float(u_pitch_with_map)*projected_pos.z/projected_pos.w;float projectionScaling=1.0;vec4 finalPos=u_coord_matrix*vec4(projected_pos.xy/projected_pos.w+rotation_matrix*(a_offset/32.0*fontScale+a_pxoffset)*projectionScaling,z,1.0);if(u_pitch_with_map) {finalPos=projectTileWithElevation(finalPos.xy,finalPos.z);}float gamma_scale=finalPos.w;gl_Position=finalPos;vec2 fade_opacity=unpack_opacity(a_fade_opacity);float visibility=calculate_visibility(projectedPoint);float fade_change=fade_opacity[1] > 0.5 ? u_fade_change :-u_fade_change;float interpolated_fade_opacity=max(0.0,min(visibility,fade_opacity[0]+fade_change));v_data0=a_tex/u_texsize;v_data1=vec3(gamma_scale,size,interpolated_fade_opacity);}`), symbolTextAndIcon: Mt(`#define SDF_PX 8.0
+#define SDF 1.0
+#define ICON 0.0
+uniform bool u_is_halo;uniform sampler2D u_texture;uniform sampler2D u_texture_icon;uniform highp float u_gamma_scale;uniform lowp float u_device_pixel_ratio;varying vec4 v_data0;varying vec4 v_data1;
+#pragma mapbox: define highp vec4 fill_color
+#pragma mapbox: define highp vec4 halo_color
+#pragma mapbox: define lowp float opacity
+#pragma mapbox: define lowp float halo_width
+#pragma mapbox: define lowp float halo_blur
+void main() {
+#pragma mapbox: initialize highp vec4 fill_color
+#pragma mapbox: initialize highp vec4 halo_color
+#pragma mapbox: initialize lowp float opacity
+#pragma mapbox: initialize lowp float halo_width
+#pragma mapbox: initialize lowp float halo_blur
+float fade_opacity=v_data1[2];if (v_data1.w==ICON) {vec2 tex_icon=v_data0.zw;lowp float alpha=opacity*fade_opacity;gl_FragColor=texture2D(u_texture_icon,tex_icon)*alpha;
+#ifdef OVERDRAW_INSPECTOR
+gl_FragColor=vec4(1.0);
+#endif
+return;}vec2 tex=v_data0.xy;float EDGE_GAMMA=0.105/u_device_pixel_ratio;float gamma_scale=v_data1.x;float size=v_data1.y;float fontScale=size/24.0;lowp vec4 color=fill_color;highp float gamma=EDGE_GAMMA/(fontScale*u_gamma_scale);lowp float buff=(256.0-64.0)/256.0;if (u_is_halo) {color=halo_color;gamma=(halo_blur*1.19/SDF_PX+EDGE_GAMMA)/(fontScale*u_gamma_scale);buff=(6.0-halo_width/fontScale)/SDF_PX;}lowp float dist=texture2D(u_texture,tex).a;highp float gamma_scaled=gamma*gamma_scale;highp float alpha=smoothstep(buff-gamma_scaled,buff+gamma_scaled,dist);gl_FragColor=color*(alpha*opacity*fade_opacity);
+#ifdef OVERDRAW_INSPECTOR
+gl_FragColor=vec4(1.0);
+#endif
+}`, `attribute vec4 a_pos_offset;attribute vec4 a_data;attribute vec3 a_projected_pos;attribute float a_fade_opacity;uniform bool u_is_size_zoom_constant;uniform bool u_is_size_feature_constant;uniform highp float u_size_t;uniform highp float u_size;uniform mat4 u_matrix;uniform mat4 u_label_plane_matrix;uniform mat4 u_coord_matrix;uniform bool u_is_text;uniform bool u_pitch_with_map;uniform highp float u_pitch;uniform bool u_rotate_symbol;uniform highp float u_aspect_ratio;uniform highp float u_camera_to_center_distance;uniform float u_fade_change;uniform vec2 u_texsize;uniform vec2 u_texsize_icon;uniform bool u_is_along_line;uniform bool u_is_variable_anchor;uniform vec2 u_translation;uniform float u_pitched_scale;varying vec4 v_data0;varying vec4 v_data1;vec4 projectTileWithElevation(vec2 posInTile,float elevation) {return u_matrix*vec4(posInTile,elevation,1.0);}
+#pragma mapbox: define highp vec4 fill_color
+#pragma mapbox: define highp vec4 halo_color
+#pragma mapbox: define lowp float opacity
+#pragma mapbox: define lowp float halo_width
+#pragma mapbox: define lowp float halo_blur
+void main() {
+#pragma mapbox: initialize highp vec4 fill_color
+#pragma mapbox: initialize highp vec4 halo_color
+#pragma mapbox: initialize lowp float opacity
+#pragma mapbox: initialize lowp float halo_width
+#pragma mapbox: initialize lowp float halo_blur
+vec2 a_pos=a_pos_offset.xy;vec2 a_offset=a_pos_offset.zw;vec2 a_tex=a_data.xy;vec2 a_size=a_data.zw;float a_size_min=floor(a_size[0]*0.5);float is_sdf=a_size[0]-2.0*a_size_min;float ele=get_elevation(a_pos);highp float segment_angle=-a_projected_pos[2];float size;if (!u_is_size_zoom_constant && !u_is_size_feature_constant) {size=mix(a_size_min,a_size[1],u_size_t)/128.0;} else if (u_is_size_zoom_constant && !u_is_size_feature_constant) {size=a_size_min/128.0;} else {size=u_size;}vec2 translated_a_pos=a_pos+u_translation;vec4 projectedPoint=projectTileWithElevation(translated_a_pos,ele);highp float camera_to_anchor_distance=projectedPoint.w;highp float distance_ratio=u_pitch_with_map ?
+camera_to_anchor_distance/u_camera_to_center_distance :
+u_camera_to_center_distance/camera_to_anchor_distance;highp float perspective_ratio=clamp(0.5+0.5*distance_ratio,0.0,4.0);size*=perspective_ratio;float fontScale=size/24.0;highp float symbol_rotation=0.0;if (u_rotate_symbol) {vec4 offsetProjectedPoint=projectTileWithElevation(translated_a_pos+vec2(1,0),ele);vec2 a=projectedPoint.xy/projectedPoint.w;vec2 b=offsetProjectedPoint.xy/offsetProjectedPoint.w;symbol_rotation=atan((b.y-a.y)/u_aspect_ratio,b.x-a.x);}highp float angle_sin=sin(segment_angle+symbol_rotation);highp float angle_cos=cos(segment_angle+symbol_rotation);mat2 rotation_matrix=mat2(angle_cos,-1.0*angle_sin,angle_sin,angle_cos);vec4 projected_pos;if (u_is_along_line || u_is_variable_anchor) {projected_pos=vec4(a_projected_pos.xy,ele,1.0);} else if (u_pitch_with_map) {projected_pos=u_label_plane_matrix*vec4(a_projected_pos.xy+u_translation,ele,1.0);} else {projected_pos=u_label_plane_matrix*projectTileWithElevation(a_projected_pos.xy+u_translation,ele);}float z=float(u_pitch_with_map)*projected_pos.z/projected_pos.w;float projectionScaling=1.0;vec4 finalPos=u_coord_matrix*vec4(projected_pos.xy/projected_pos.w+rotation_matrix*(a_offset/32.0*fontScale)*projectionScaling,z,1.0);if(u_pitch_with_map) {finalPos=projectTileWithElevation(finalPos.xy,finalPos.z);}float gamma_scale=finalPos.w;gl_Position=finalPos;vec2 fade_opacity=unpack_opacity(a_fade_opacity);float visibility=calculate_visibility(projectedPoint);float fade_change=fade_opacity[1] > 0.5 ? u_fade_change :-u_fade_change;float interpolated_fade_opacity=max(0.0,min(visibility,fade_opacity[0]+fade_change));v_data0.xy=a_tex/u_texsize;v_data0.zw=a_tex/u_texsize_icon;v_data1=vec4(gamma_scale,size,interpolated_fade_opacity,is_sdf);}`), terrain: Mt("uniform sampler2D u_texture;uniform vec4 u_fog_color;uniform vec4 u_horizon_color;uniform float u_fog_ground_blend;uniform float u_fog_ground_blend_opacity;uniform float u_horizon_fog_blend;varying vec2 v_texture_pos;varying float v_fog_depth;const float gamma=2.2;vec4 gammaToLinear(vec4 color) {return pow(color,vec4(gamma));}vec4 linearToGamma(vec4 color) {return pow(color,vec4(1.0/gamma));}void main() {vec4 surface_color=texture2D(u_texture,v_texture_pos);if (v_fog_depth > u_fog_ground_blend) {vec4 surface_color_linear=gammaToLinear(surface_color);float blend_color=smoothstep(0.0,1.0,max((v_fog_depth-u_horizon_fog_blend)/(1.0-u_horizon_fog_blend),0.0));vec4 fog_horizon_color_linear=mix(gammaToLinear(u_fog_color),gammaToLinear(u_horizon_color),blend_color);float factor_fog=max(v_fog_depth-u_fog_ground_blend,0.0)/(1.0-u_fog_ground_blend);gl_FragColor=linearToGamma(mix(surface_color_linear,fog_horizon_color_linear,pow(factor_fog,2.0)*u_fog_ground_blend_opacity));} else {gl_FragColor=surface_color;}}", "attribute vec3 a_pos3d;uniform mat4 u_matrix;uniform mat4 u_fog_matrix;uniform float u_ele_delta;varying vec2 v_texture_pos;varying float v_fog_depth;void main() {float ele=get_elevation(a_pos3d.xy);float ele_delta=a_pos3d.z==1.0 ? u_ele_delta : 0.0;v_texture_pos=a_pos3d.xy/8192.0;gl_Position=u_matrix*vec4(a_pos3d.xy,ele-ele_delta,1.0);vec4 pos=u_fog_matrix*vec4(a_pos3d.xy,ele,1.0);v_fog_depth=pos.z/pos.w*0.5+0.5;}"), terrainDepth: Mt("varying float v_depth;const highp vec4 bitSh=vec4(256.*256.*256.,256.*256.,256.,1.);const highp vec4 bitMsk=vec4(0.,vec3(1./256.0));highp vec4 pack(highp float value) {highp vec4 comp=fract(value*bitSh);comp-=comp.xxyz*bitMsk;return comp;}void main() {gl_FragColor=pack(v_depth);}", "attribute vec3 a_pos3d;uniform mat4 u_matrix;uniform float u_ele_delta;varying float v_depth;void main() {float ele=get_elevation(a_pos3d.xy);float ele_delta=a_pos3d.z==1.0 ? u_ele_delta : 0.0;gl_Position=u_matrix*vec4(a_pos3d.xy,ele-ele_delta,1.0);v_depth=gl_Position.z/gl_Position.w;}"), terrainCoords: Mt("precision mediump float;uniform sampler2D u_texture;uniform float u_terrain_coords_id;varying vec2 v_texture_pos;void main() {vec4 rgba=texture2D(u_texture,v_texture_pos);gl_FragColor=vec4(rgba.r,rgba.g,rgba.b,u_terrain_coords_id);}", "attribute vec3 a_pos3d;uniform mat4 u_matrix;uniform float u_ele_delta;varying vec2 v_texture_pos;void main() {float ele=get_elevation(a_pos3d.xy);float ele_delta=a_pos3d.z==1.0 ? u_ele_delta : 0.0;v_texture_pos=a_pos3d.xy/8192.0;gl_Position=u_matrix*vec4(a_pos3d.xy,ele-ele_delta,1.0);}"), sky: Mt("uniform vec4 u_sky_color;uniform vec4 u_horizon_color;uniform float u_horizon;uniform float u_sky_horizon_blend;void main() {float y=gl_FragCoord.y;if (y > u_horizon) {float blend=y-u_horizon;if (blend < u_sky_horizon_blend) {gl_FragColor=mix(u_sky_color,u_horizon_color,pow(1.0-blend/u_sky_horizon_blend,2.0));} else {gl_FragColor=u_sky_color;}}}", "attribute vec2 a_pos;void main() {gl_Position=vec4(a_pos,1.0,1.0);}") };
+            function Mt(ue, w) {
+              let B = /#pragma mapbox: ([\w]+) ([\w]+) ([\w]+) ([\w]+)/g, Q = w.match(/attribute ([\w]+) ([\w]+)/g), ee = ue.match(/uniform ([\w]+) ([\w]+)([\s]*)([\w]*)/g), le = w.match(/uniform ([\w]+) ([\w]+)([\s]*)([\w]*)/g), Oe = le ? le.concat(ee) : ee, Ze = {};
+              return { fragmentSource: ue = ue.replace(B, (st, Tt, Yt, Kt, xr) => (Ze[xr] = true, Tt === "define" ? `
+#ifndef HAS_UNIFORM_u_${xr}
+varying ${Yt} ${Kt} ${xr};
+#else
+uniform ${Yt} ${Kt} u_${xr};
+#endif
+` : `
+#ifdef HAS_UNIFORM_u_${xr}
+    ${Yt} ${Kt} ${xr} = u_${xr};
+#endif
+`)), vertexSource: w = w.replace(B, (st, Tt, Yt, Kt, xr) => {
+                let Ir = Kt === "float" ? "vec2" : "vec4", ve = xr.match(/color/) ? "color" : Ir;
+                return Ze[xr] ? Tt === "define" ? `
+#ifndef HAS_UNIFORM_u_${xr}
+uniform lowp float u_${xr}_t;
+attribute ${Yt} ${Ir} a_${xr};
+varying ${Yt} ${Kt} ${xr};
+#else
+uniform ${Yt} ${Kt} u_${xr};
+#endif
+` : ve === "vec4" ? `
+#ifndef HAS_UNIFORM_u_${xr}
+    ${xr} = a_${xr};
+#else
+    ${Yt} ${Kt} ${xr} = u_${xr};
+#endif
+` : `
+#ifndef HAS_UNIFORM_u_${xr}
+    ${xr} = unpack_mix_${ve}(a_${xr}, u_${xr}_t);
+#else
+    ${Yt} ${Kt} ${xr} = u_${xr};
+#endif
+` : Tt === "define" ? `
+#ifndef HAS_UNIFORM_u_${xr}
+uniform lowp float u_${xr}_t;
+attribute ${Yt} ${Ir} a_${xr};
+#else
+uniform ${Yt} ${Kt} u_${xr};
+#endif
+` : ve === "vec4" ? `
+#ifndef HAS_UNIFORM_u_${xr}
+    ${Yt} ${Kt} ${xr} = a_${xr};
+#else
+    ${Yt} ${Kt} ${xr} = u_${xr};
+#endif
+` : `
+#ifndef HAS_UNIFORM_u_${xr}
+    ${Yt} ${Kt} ${xr} = unpack_mix_${ve}(a_${xr}, u_${xr}_t);
+#else
+    ${Yt} ${Kt} ${xr} = u_${xr};
+#endif
+`;
+              }), staticAttributes: Q, staticUniforms: Oe };
+            }
+            class kr {
+              constructor() {
+                this.boundProgram = null, this.boundLayoutVertexBuffer = null, this.boundPaintVertexBuffers = [], this.boundIndexBuffer = null, this.boundVertexOffset = null, this.boundDynamicVertexBuffer = null, this.vao = null;
+              }
+              bind(w, B, Q, ee, le, Oe, Ze, st, Tt) {
+                this.context = w;
+                let Yt = this.boundPaintVertexBuffers.length !== ee.length;
+                for (let Kt = 0; !Yt && Kt < ee.length; Kt++) this.boundPaintVertexBuffers[Kt] !== ee[Kt] && (Yt = true);
+                !this.vao || this.boundProgram !== B || this.boundLayoutVertexBuffer !== Q || Yt || this.boundIndexBuffer !== le || this.boundVertexOffset !== Oe || this.boundDynamicVertexBuffer !== Ze || this.boundDynamicVertexBuffer2 !== st || this.boundDynamicVertexBuffer3 !== Tt ? this.freshBind(B, Q, ee, le, Oe, Ze, st, Tt) : (w.bindVertexArray.set(this.vao), Ze && Ze.bind(), le && le.dynamicDraw && le.bind(), st && st.bind(), Tt && Tt.bind());
+              }
+              freshBind(w, B, Q, ee, le, Oe, Ze, st) {
+                let Tt = w.numAttributes, Yt = this.context, Kt = Yt.gl;
+                this.vao && this.destroy(), this.vao = Yt.createVertexArray(), Yt.bindVertexArray.set(this.vao), this.boundProgram = w, this.boundLayoutVertexBuffer = B, this.boundPaintVertexBuffers = Q, this.boundIndexBuffer = ee, this.boundVertexOffset = le, this.boundDynamicVertexBuffer = Oe, this.boundDynamicVertexBuffer2 = Ze, this.boundDynamicVertexBuffer3 = st, B.enableAttributes(Kt, w);
+                for (let xr of Q) xr.enableAttributes(Kt, w);
+                Oe && Oe.enableAttributes(Kt, w), Ze && Ze.enableAttributes(Kt, w), st && st.enableAttributes(Kt, w), B.bind(), B.setVertexAttribPointers(Kt, w, le);
+                for (let xr of Q) xr.bind(), xr.setVertexAttribPointers(Kt, w, le);
+                Oe && (Oe.bind(), Oe.setVertexAttribPointers(Kt, w, le)), ee && ee.bind(), Ze && (Ze.bind(), Ze.setVertexAttribPointers(Kt, w, le)), st && (st.bind(), st.setVertexAttribPointers(Kt, w, le)), Yt.currentNumAttributes = Tt;
+              }
+              destroy() {
+                this.vao && (this.context.deleteVertexArray(this.vao), this.vao = null);
+              }
+            }
+            let Jr = (ue, w, B, Q, ee) => ({ u_matrix: ue, u_texture: 0, u_ele_delta: w, u_fog_matrix: B, u_fog_color: Q ? Q.properties.get("fog-color") : a.aM.white, u_fog_ground_blend: Q ? Q.properties.get("fog-ground-blend") : 1, u_fog_ground_blend_opacity: Q ? Q.calculateFogBlendOpacity(ee) : 0, u_horizon_color: Q ? Q.properties.get("horizon-color") : a.aM.white, u_horizon_fog_blend: Q ? Q.properties.get("horizon-fog-blend") : 1 });
+            function vi(ue) {
+              let w = [];
+              for (let B = 0; B < ue.length; B++) {
+                if (ue[B] === null) continue;
+                let Q = ue[B].split(" ");
+                w.push(Q.pop());
+              }
+              return w;
+            }
+            class hn {
+              constructor(w, B, Q, ee, le, Oe) {
+                let Ze = w.gl;
+                this.program = Ze.createProgram();
+                let st = vi(B.staticAttributes), Tt = Q ? Q.getBinderAttributes() : [], Yt = st.concat(Tt), Kt = jn.prelude.staticUniforms ? vi(jn.prelude.staticUniforms) : [], xr = B.staticUniforms ? vi(B.staticUniforms) : [], Ir = Q ? Q.getBinderUniforms() : [], ve = Kt.concat(xr).concat(Ir), be = [];
+                for (let Ht of ve) be.indexOf(Ht) < 0 && be.push(Ht);
+                let Re = Q ? Q.defines() : [];
+                le && Re.push("#define OVERDRAW_INSPECTOR;"), Oe && Re.push("#define TERRAIN3D;");
+                let qe = Re.concat(jn.prelude.fragmentSource, B.fragmentSource).join(`
+`), et = Re.concat(jn.prelude.vertexSource, B.vertexSource).join(`
+`), Xe = Ze.createShader(Ze.FRAGMENT_SHADER);
+                if (Ze.isContextLost()) return void (this.failedToCreate = true);
+                if (Ze.shaderSource(Xe, qe), Ze.compileShader(Xe), !Ze.getShaderParameter(Xe, Ze.COMPILE_STATUS)) throw new Error(`Could not compile fragment shader: ${Ze.getShaderInfoLog(Xe)}`);
+                Ze.attachShader(this.program, Xe);
+                let it = Ze.createShader(Ze.VERTEX_SHADER);
+                if (Ze.isContextLost()) return void (this.failedToCreate = true);
+                if (Ze.shaderSource(it, et), Ze.compileShader(it), !Ze.getShaderParameter(it, Ze.COMPILE_STATUS)) throw new Error(`Could not compile vertex shader: ${Ze.getShaderInfoLog(it)}`);
+                Ze.attachShader(this.program, it), this.attributes = {};
+                let Ft = {};
+                this.numAttributes = Yt.length;
+                for (let Ht = 0; Ht < this.numAttributes; Ht++) Yt[Ht] && (Ze.bindAttribLocation(this.program, Ht, Yt[Ht]), this.attributes[Yt[Ht]] = Ht);
+                if (Ze.linkProgram(this.program), !Ze.getProgramParameter(this.program, Ze.LINK_STATUS)) throw new Error(`Program failed to link: ${Ze.getProgramInfoLog(this.program)}`);
+                Ze.deleteShader(it), Ze.deleteShader(Xe);
+                for (let Ht = 0; Ht < be.length; Ht++) {
+                  let tr = be[Ht];
+                  if (tr && !Ft[tr]) {
+                    let dr = Ze.getUniformLocation(this.program, tr);
+                    dr && (Ft[tr] = dr);
+                  }
+                }
+                this.fixedUniforms = ee(w, Ft), this.terrainUniforms = ((Ht, tr) => ({ u_depth: new a.aH(Ht, tr.u_depth), u_terrain: new a.aH(Ht, tr.u_terrain), u_terrain_dim: new a.aI(Ht, tr.u_terrain_dim), u_terrain_matrix: new a.aJ(Ht, tr.u_terrain_matrix), u_terrain_unpack: new a.aK(Ht, tr.u_terrain_unpack), u_terrain_exaggeration: new a.aI(Ht, tr.u_terrain_exaggeration) }))(w, Ft), this.binderUniforms = Q ? Q.getUniforms(w, Ft) : [];
+              }
+              draw(w, B, Q, ee, le, Oe, Ze, st, Tt, Yt, Kt, xr, Ir, ve, be, Re, qe, et) {
+                let Xe = w.gl;
+                if (this.failedToCreate) return;
+                if (w.program.set(this.program), w.setDepthMode(Q), w.setStencilMode(ee), w.setColorMode(le), w.setCullFace(Oe), st) {
+                  w.activeTexture.set(Xe.TEXTURE2), Xe.bindTexture(Xe.TEXTURE_2D, st.depthTexture), w.activeTexture.set(Xe.TEXTURE3), Xe.bindTexture(Xe.TEXTURE_2D, st.texture);
+                  for (let Ft in this.terrainUniforms) this.terrainUniforms[Ft].set(st[Ft]);
+                }
+                for (let Ft in this.fixedUniforms) this.fixedUniforms[Ft].set(Ze[Ft]);
+                be && be.setUniforms(w, this.binderUniforms, Ir, { zoom: ve });
+                let it = 0;
+                switch (B) {
+                  case Xe.LINES:
+                    it = 2;
+                    break;
+                  case Xe.TRIANGLES:
+                    it = 3;
+                    break;
+                  case Xe.LINE_STRIP:
+                    it = 1;
+                }
+                for (let Ft of xr.get()) {
+                  let Ht = Ft.vaos || (Ft.vaos = {});
+                  (Ht[Tt] || (Ht[Tt] = new kr())).bind(w, this, Yt, be ? be.getPaintVertexBuffers() : [], Kt, Ft.vertexOffset, Re, qe, et), Xe.drawElements(B, Ft.primitiveLength * it, Xe.UNSIGNED_SHORT, Ft.primitiveOffset * it * 2);
+                }
+              }
+            }
+            function An(ue, w, B) {
+              let Q = 1 / In(B, 1, w.transform.tileZoom), ee = Math.pow(2, B.tileID.overscaledZ), le = B.tileSize * Math.pow(2, w.transform.tileZoom) / ee, Oe = le * (B.tileID.canonical.x + B.tileID.wrap * ee), Ze = le * B.tileID.canonical.y;
+              return { u_image: 0, u_texsize: B.imageAtlasTexture.size, u_scale: [Q, ue.fromScale, ue.toScale], u_fade: ue.t, u_pixel_coord_upper: [Oe >> 16, Ze >> 16], u_pixel_coord_lower: [65535 & Oe, 65535 & Ze] };
+            }
+            let Mn = (ue, w, B, Q) => {
+              let ee = w.style.light, le = ee.properties.get("position"), Oe = [le.x, le.y, le.z], Ze = function() {
+                var Tt = new a.A(9);
+                return a.A != Float32Array && (Tt[1] = 0, Tt[2] = 0, Tt[3] = 0, Tt[5] = 0, Tt[6] = 0, Tt[7] = 0), Tt[0] = 1, Tt[4] = 1, Tt[8] = 1, Tt;
+              }();
+              ee.properties.get("anchor") === "viewport" && function(Tt, Yt) {
+                var Kt = Math.sin(Yt), xr = Math.cos(Yt);
+                Tt[0] = xr, Tt[1] = Kt, Tt[2] = 0, Tt[3] = -Kt, Tt[4] = xr, Tt[5] = 0, Tt[6] = 0, Tt[7] = 0, Tt[8] = 1;
+              }(Ze, -w.transform.angle), function(Tt, Yt, Kt) {
+                var xr = Yt[0], Ir = Yt[1], ve = Yt[2];
+                Tt[0] = xr * Kt[0] + Ir * Kt[3] + ve * Kt[6], Tt[1] = xr * Kt[1] + Ir * Kt[4] + ve * Kt[7], Tt[2] = xr * Kt[2] + Ir * Kt[5] + ve * Kt[8];
+              }(Oe, Oe, Ze);
+              let st = ee.properties.get("color");
+              return { u_matrix: ue, u_lightpos: Oe, u_lightintensity: ee.properties.get("intensity"), u_lightcolor: [st.r, st.g, st.b], u_vertical_gradient: +B, u_opacity: Q };
+            }, Li = (ue, w, B, Q, ee, le, Oe) => a.e(Mn(ue, w, B, Q), An(le, w, Oe), { u_height_factor: -Math.pow(2, ee.overscaledZ) / Oe.tileSize / 8 }), _n = (ue) => ({ u_matrix: ue }), ya = (ue, w, B, Q) => a.e(_n(ue), An(B, w, Q)), $n = (ue, w) => ({ u_matrix: ue, u_world: w }), Ma = (ue, w, B, Q, ee) => a.e(ya(ue, w, B, Q), { u_world: ee }), _o = (ue, w, B, Q) => {
+              let ee = ue.transform, le, Oe;
+              if (Q.paint.get("circle-pitch-alignment") === "map") {
+                let Ze = In(B, 1, ee.zoom);
+                le = true, Oe = [Ze, Ze];
+              } else le = false, Oe = ee.pixelsToGLUnits;
+              return { u_camera_to_center_distance: ee.cameraToCenterDistance, u_scale_with_map: +(Q.paint.get("circle-pitch-scale") === "map"), u_matrix: ue.translatePosMatrix(w.posMatrix, B, Q.paint.get("circle-translate"), Q.paint.get("circle-translate-anchor")), u_pitch_with_map: +le, u_device_pixel_ratio: ue.pixelRatio, u_extrude_scale: Oe };
+            }, No = (ue, w, B) => ({ u_matrix: ue, u_inv_matrix: w, u_camera_to_center_distance: B.cameraToCenterDistance, u_viewport_size: [B.width, B.height] }), po = (ue, w, B = 1) => ({ u_matrix: ue, u_color: w, u_overlay: 0, u_overlay_scale: B }), Lo = (ue) => ({ u_matrix: ue }), ko = (ue, w, B, Q) => ({ u_matrix: ue, u_extrude_scale: In(w, 1, B), u_intensity: Q }), Ds = (ue, w, B, Q) => {
+              let ee = a.H();
+              a.aP(ee, 0, ue.width, ue.height, 0, 0, 1);
+              let le = ue.context.gl;
+              return { u_matrix: ee, u_world: [le.drawingBufferWidth, le.drawingBufferHeight], u_image: B, u_color_ramp: Q, u_opacity: w.paint.get("heatmap-opacity") };
+            };
+            function Fs(ue, w) {
+              let B = Math.pow(2, w.canonical.z), Q = w.canonical.y;
+              return [new a.Z(0, Q / B).toLngLat().lat, new a.Z(0, (Q + 1) / B).toLngLat().lat];
+            }
+            let ll = (ue, w, B, Q) => {
+              let ee = ue.transform;
+              return { u_matrix: As(ue, w, B, Q), u_ratio: 1 / In(w, 1, ee.zoom), u_device_pixel_ratio: ue.pixelRatio, u_units_to_pixels: [1 / ee.pixelsToGLUnits[0], 1 / ee.pixelsToGLUnits[1]] };
+            }, ul = (ue, w, B, Q, ee) => a.e(ll(ue, w, B, ee), { u_image: 0, u_image_height: Q }), zl = (ue, w, B, Q, ee) => {
+              let le = ue.transform, Oe = il(w, le);
+              return { u_matrix: As(ue, w, B, ee), u_texsize: w.imageAtlasTexture.size, u_ratio: 1 / In(w, 1, le.zoom), u_device_pixel_ratio: ue.pixelRatio, u_image: 0, u_scale: [Oe, Q.fromScale, Q.toScale], u_fade: Q.t, u_units_to_pixels: [1 / le.pixelsToGLUnits[0], 1 / le.pixelsToGLUnits[1]] };
+            }, us = (ue, w, B, Q, ee, le) => {
+              let Oe = ue.lineAtlas, Ze = il(w, ue.transform), st = B.layout.get("line-cap") === "round", Tt = Oe.getDash(Q.from, st), Yt = Oe.getDash(Q.to, st), Kt = Tt.width * ee.fromScale, xr = Yt.width * ee.toScale;
+              return a.e(ll(ue, w, B, le), { u_patternscale_a: [Ze / Kt, -Tt.height / 2], u_patternscale_b: [Ze / xr, -Yt.height / 2], u_sdfgamma: Oe.width / (256 * Math.min(Kt, xr) * ue.pixelRatio) / 2, u_image: 0, u_tex_y_a: Tt.y, u_tex_y_b: Yt.y, u_mix: ee.t });
+            };
+            function il(ue, w) {
+              return 1 / In(ue, 1, w.tileZoom);
+            }
+            function As(ue, w, B, Q) {
+              return ue.translatePosMatrix(Q ? Q.posMatrix : w.tileID.posMatrix, w, B.paint.get("line-translate"), B.paint.get("line-translate-anchor"));
+            }
+            let cl = (ue, w, B, Q, ee) => {
+              return { u_matrix: ue, u_tl_parent: w, u_scale_parent: B, u_buffer_scale: 1, u_fade_t: Q.mix, u_opacity: Q.opacity * ee.paint.get("raster-opacity"), u_image0: 0, u_image1: 1, u_brightness_low: ee.paint.get("raster-brightness-min"), u_brightness_high: ee.paint.get("raster-brightness-max"), u_saturation_factor: (Oe = ee.paint.get("raster-saturation"), Oe > 0 ? 1 - 1 / (1.001 - Oe) : -Oe), u_contrast_factor: (le = ee.paint.get("raster-contrast"), le > 0 ? 1 / (1 - le) : 1 + le), u_spin_weights: Ks(ee.paint.get("raster-hue-rotate")) };
+              var le, Oe;
+            };
+            function Ks(ue) {
+              ue *= Math.PI / 180;
+              let w = Math.sin(ue), B = Math.cos(ue);
+              return [(2 * B + 1) / 3, (-Math.sqrt(3) * w - B + 1) / 3, (Math.sqrt(3) * w - B + 1) / 3];
+            }
+            let zs = (ue, w, B, Q, ee, le, Oe, Ze, st, Tt, Yt, Kt, xr, Ir) => {
+              let ve = Oe.transform;
+              return { u_is_size_zoom_constant: +(ue === "constant" || ue === "source"), u_is_size_feature_constant: +(ue === "constant" || ue === "camera"), u_size_t: w ? w.uSizeT : 0, u_size: w ? w.uSize : 0, u_camera_to_center_distance: ve.cameraToCenterDistance, u_pitch: ve.pitch / 360 * 2 * Math.PI, u_rotate_symbol: +B, u_aspect_ratio: ve.width / ve.height, u_fade_change: Oe.options.fadeDuration ? Oe.symbolFadeChange : 1, u_matrix: Ze, u_label_plane_matrix: st, u_coord_matrix: Tt, u_is_text: +Kt, u_pitch_with_map: +Q, u_is_along_line: ee, u_is_variable_anchor: le, u_texsize: xr, u_texture: 0, u_translation: Yt, u_pitched_scale: Ir };
+            }, Io = (ue, w, B, Q, ee, le, Oe, Ze, st, Tt, Yt, Kt, xr, Ir, ve) => {
+              let be = Oe.transform;
+              return a.e(zs(ue, w, B, Q, ee, le, Oe, Ze, st, Tt, Yt, Kt, xr, ve), { u_gamma_scale: Q ? Math.cos(be._pitch) * be.cameraToCenterDistance : 1, u_device_pixel_ratio: Oe.pixelRatio, u_is_halo: 1 });
+            }, ls = (ue, w, B, Q, ee, le, Oe, Ze, st, Tt, Yt, Kt, xr, Ir) => a.e(Io(ue, w, B, Q, ee, le, Oe, Ze, st, Tt, Yt, true, Kt, true, Ir), { u_texsize_icon: xr, u_texture_icon: 1 }), Yl = (ue, w, B) => ({ u_matrix: ue, u_opacity: w, u_color: B }), Su = (ue, w, B, Q, ee, le) => a.e(function(Oe, Ze, st, Tt) {
+              let Yt = st.imageManager.getPattern(Oe.from.toString()), Kt = st.imageManager.getPattern(Oe.to.toString()), { width: xr, height: Ir } = st.imageManager.getPixelSize(), ve = Math.pow(2, Tt.tileID.overscaledZ), be = Tt.tileSize * Math.pow(2, st.transform.tileZoom) / ve, Re = be * (Tt.tileID.canonical.x + Tt.tileID.wrap * ve), qe = be * Tt.tileID.canonical.y;
+              return { u_image: 0, u_pattern_tl_a: Yt.tl, u_pattern_br_a: Yt.br, u_pattern_tl_b: Kt.tl, u_pattern_br_b: Kt.br, u_texsize: [xr, Ir], u_mix: Ze.t, u_pattern_size_a: Yt.displaySize, u_pattern_size_b: Kt.displaySize, u_scale_a: Ze.fromScale, u_scale_b: Ze.toScale, u_tile_units_to_pixels: 1 / In(Tt, 1, st.transform.tileZoom), u_pixel_coord_upper: [Re >> 16, qe >> 16], u_pixel_coord_lower: [65535 & Re, 65535 & qe] };
+            }(Q, le, B, ee), { u_matrix: ue, u_opacity: w }), nc = { fillExtrusion: (ue, w) => ({ u_matrix: new a.aJ(ue, w.u_matrix), u_lightpos: new a.aN(ue, w.u_lightpos), u_lightintensity: new a.aI(ue, w.u_lightintensity), u_lightcolor: new a.aN(ue, w.u_lightcolor), u_vertical_gradient: new a.aI(ue, w.u_vertical_gradient), u_opacity: new a.aI(ue, w.u_opacity) }), fillExtrusionPattern: (ue, w) => ({ u_matrix: new a.aJ(ue, w.u_matrix), u_lightpos: new a.aN(ue, w.u_lightpos), u_lightintensity: new a.aI(ue, w.u_lightintensity), u_lightcolor: new a.aN(ue, w.u_lightcolor), u_vertical_gradient: new a.aI(ue, w.u_vertical_gradient), u_height_factor: new a.aI(ue, w.u_height_factor), u_image: new a.aH(ue, w.u_image), u_texsize: new a.aO(ue, w.u_texsize), u_pixel_coord_upper: new a.aO(ue, w.u_pixel_coord_upper), u_pixel_coord_lower: new a.aO(ue, w.u_pixel_coord_lower), u_scale: new a.aN(ue, w.u_scale), u_fade: new a.aI(ue, w.u_fade), u_opacity: new a.aI(ue, w.u_opacity) }), fill: (ue, w) => ({ u_matrix: new a.aJ(ue, w.u_matrix) }), fillPattern: (ue, w) => ({ u_matrix: new a.aJ(ue, w.u_matrix), u_image: new a.aH(ue, w.u_image), u_texsize: new a.aO(ue, w.u_texsize), u_pixel_coord_upper: new a.aO(ue, w.u_pixel_coord_upper), u_pixel_coord_lower: new a.aO(ue, w.u_pixel_coord_lower), u_scale: new a.aN(ue, w.u_scale), u_fade: new a.aI(ue, w.u_fade) }), fillOutline: (ue, w) => ({ u_matrix: new a.aJ(ue, w.u_matrix), u_world: new a.aO(ue, w.u_world) }), fillOutlinePattern: (ue, w) => ({ u_matrix: new a.aJ(ue, w.u_matrix), u_world: new a.aO(ue, w.u_world), u_image: new a.aH(ue, w.u_image), u_texsize: new a.aO(ue, w.u_texsize), u_pixel_coord_upper: new a.aO(ue, w.u_pixel_coord_upper), u_pixel_coord_lower: new a.aO(ue, w.u_pixel_coord_lower), u_scale: new a.aN(ue, w.u_scale), u_fade: new a.aI(ue, w.u_fade) }), circle: (ue, w) => ({ u_camera_to_center_distance: new a.aI(ue, w.u_camera_to_center_distance), u_scale_with_map: new a.aH(ue, w.u_scale_with_map), u_pitch_with_map: new a.aH(ue, w.u_pitch_with_map), u_extrude_scale: new a.aO(ue, w.u_extrude_scale), u_device_pixel_ratio: new a.aI(ue, w.u_device_pixel_ratio), u_matrix: new a.aJ(ue, w.u_matrix) }), collisionBox: (ue, w) => ({ u_matrix: new a.aJ(ue, w.u_matrix), u_pixel_extrude_scale: new a.aO(ue, w.u_pixel_extrude_scale) }), collisionCircle: (ue, w) => ({ u_matrix: new a.aJ(ue, w.u_matrix), u_inv_matrix: new a.aJ(ue, w.u_inv_matrix), u_camera_to_center_distance: new a.aI(ue, w.u_camera_to_center_distance), u_viewport_size: new a.aO(ue, w.u_viewport_size) }), debug: (ue, w) => ({ u_color: new a.aL(ue, w.u_color), u_matrix: new a.aJ(ue, w.u_matrix), u_overlay: new a.aH(ue, w.u_overlay), u_overlay_scale: new a.aI(ue, w.u_overlay_scale) }), clippingMask: (ue, w) => ({ u_matrix: new a.aJ(ue, w.u_matrix) }), heatmap: (ue, w) => ({ u_extrude_scale: new a.aI(ue, w.u_extrude_scale), u_intensity: new a.aI(ue, w.u_intensity), u_matrix: new a.aJ(ue, w.u_matrix) }), heatmapTexture: (ue, w) => ({ u_matrix: new a.aJ(ue, w.u_matrix), u_world: new a.aO(ue, w.u_world), u_image: new a.aH(ue, w.u_image), u_color_ramp: new a.aH(ue, w.u_color_ramp), u_opacity: new a.aI(ue, w.u_opacity) }), hillshade: (ue, w) => ({ u_matrix: new a.aJ(ue, w.u_matrix), u_image: new a.aH(ue, w.u_image), u_latrange: new a.aO(ue, w.u_latrange), u_light: new a.aO(ue, w.u_light), u_shadow: new a.aL(ue, w.u_shadow), u_highlight: new a.aL(ue, w.u_highlight), u_accent: new a.aL(ue, w.u_accent) }), hillshadePrepare: (ue, w) => ({ u_matrix: new a.aJ(ue, w.u_matrix), u_image: new a.aH(ue, w.u_image), u_dimension: new a.aO(ue, w.u_dimension), u_zoom: new a.aI(ue, w.u_zoom), u_unpack: new a.aK(ue, w.u_unpack) }), line: (ue, w) => ({ u_matrix: new a.aJ(ue, w.u_matrix), u_ratio: new a.aI(ue, w.u_ratio), u_device_pixel_ratio: new a.aI(ue, w.u_device_pixel_ratio), u_units_to_pixels: new a.aO(ue, w.u_units_to_pixels) }), lineGradient: (ue, w) => ({ u_matrix: new a.aJ(ue, w.u_matrix), u_ratio: new a.aI(ue, w.u_ratio), u_device_pixel_ratio: new a.aI(ue, w.u_device_pixel_ratio), u_units_to_pixels: new a.aO(ue, w.u_units_to_pixels), u_image: new a.aH(ue, w.u_image), u_image_height: new a.aI(ue, w.u_image_height) }), linePattern: (ue, w) => ({ u_matrix: new a.aJ(ue, w.u_matrix), u_texsize: new a.aO(ue, w.u_texsize), u_ratio: new a.aI(ue, w.u_ratio), u_device_pixel_ratio: new a.aI(ue, w.u_device_pixel_ratio), u_image: new a.aH(ue, w.u_image), u_units_to_pixels: new a.aO(ue, w.u_units_to_pixels), u_scale: new a.aN(ue, w.u_scale), u_fade: new a.aI(ue, w.u_fade) }), lineSDF: (ue, w) => ({ u_matrix: new a.aJ(ue, w.u_matrix), u_ratio: new a.aI(ue, w.u_ratio), u_device_pixel_ratio: new a.aI(ue, w.u_device_pixel_ratio), u_units_to_pixels: new a.aO(ue, w.u_units_to_pixels), u_patternscale_a: new a.aO(ue, w.u_patternscale_a), u_patternscale_b: new a.aO(ue, w.u_patternscale_b), u_sdfgamma: new a.aI(ue, w.u_sdfgamma), u_image: new a.aH(ue, w.u_image), u_tex_y_a: new a.aI(ue, w.u_tex_y_a), u_tex_y_b: new a.aI(ue, w.u_tex_y_b), u_mix: new a.aI(ue, w.u_mix) }), raster: (ue, w) => ({ u_matrix: new a.aJ(ue, w.u_matrix), u_tl_parent: new a.aO(ue, w.u_tl_parent), u_scale_parent: new a.aI(ue, w.u_scale_parent), u_buffer_scale: new a.aI(ue, w.u_buffer_scale), u_fade_t: new a.aI(ue, w.u_fade_t), u_opacity: new a.aI(ue, w.u_opacity), u_image0: new a.aH(ue, w.u_image0), u_image1: new a.aH(ue, w.u_image1), u_brightness_low: new a.aI(ue, w.u_brightness_low), u_brightness_high: new a.aI(ue, w.u_brightness_high), u_saturation_factor: new a.aI(ue, w.u_saturation_factor), u_contrast_factor: new a.aI(ue, w.u_contrast_factor), u_spin_weights: new a.aN(ue, w.u_spin_weights) }), symbolIcon: (ue, w) => ({ u_is_size_zoom_constant: new a.aH(ue, w.u_is_size_zoom_constant), u_is_size_feature_constant: new a.aH(ue, w.u_is_size_feature_constant), u_size_t: new a.aI(ue, w.u_size_t), u_size: new a.aI(ue, w.u_size), u_camera_to_center_distance: new a.aI(ue, w.u_camera_to_center_distance), u_pitch: new a.aI(ue, w.u_pitch), u_rotate_symbol: new a.aH(ue, w.u_rotate_symbol), u_aspect_ratio: new a.aI(ue, w.u_aspect_ratio), u_fade_change: new a.aI(ue, w.u_fade_change), u_matrix: new a.aJ(ue, w.u_matrix), u_label_plane_matrix: new a.aJ(ue, w.u_label_plane_matrix), u_coord_matrix: new a.aJ(ue, w.u_coord_matrix), u_is_text: new a.aH(ue, w.u_is_text), u_pitch_with_map: new a.aH(ue, w.u_pitch_with_map), u_is_along_line: new a.aH(ue, w.u_is_along_line), u_is_variable_anchor: new a.aH(ue, w.u_is_variable_anchor), u_texsize: new a.aO(ue, w.u_texsize), u_texture: new a.aH(ue, w.u_texture), u_translation: new a.aO(ue, w.u_translation), u_pitched_scale: new a.aI(ue, w.u_pitched_scale) }), symbolSDF: (ue, w) => ({ u_is_size_zoom_constant: new a.aH(ue, w.u_is_size_zoom_constant), u_is_size_feature_constant: new a.aH(ue, w.u_is_size_feature_constant), u_size_t: new a.aI(ue, w.u_size_t), u_size: new a.aI(ue, w.u_size), u_camera_to_center_distance: new a.aI(ue, w.u_camera_to_center_distance), u_pitch: new a.aI(ue, w.u_pitch), u_rotate_symbol: new a.aH(ue, w.u_rotate_symbol), u_aspect_ratio: new a.aI(ue, w.u_aspect_ratio), u_fade_change: new a.aI(ue, w.u_fade_change), u_matrix: new a.aJ(ue, w.u_matrix), u_label_plane_matrix: new a.aJ(ue, w.u_label_plane_matrix), u_coord_matrix: new a.aJ(ue, w.u_coord_matrix), u_is_text: new a.aH(ue, w.u_is_text), u_pitch_with_map: new a.aH(ue, w.u_pitch_with_map), u_is_along_line: new a.aH(ue, w.u_is_along_line), u_is_variable_anchor: new a.aH(ue, w.u_is_variable_anchor), u_texsize: new a.aO(ue, w.u_texsize), u_texture: new a.aH(ue, w.u_texture), u_gamma_scale: new a.aI(ue, w.u_gamma_scale), u_device_pixel_ratio: new a.aI(ue, w.u_device_pixel_ratio), u_is_halo: new a.aH(ue, w.u_is_halo), u_translation: new a.aO(ue, w.u_translation), u_pitched_scale: new a.aI(ue, w.u_pitched_scale) }), symbolTextAndIcon: (ue, w) => ({ u_is_size_zoom_constant: new a.aH(ue, w.u_is_size_zoom_constant), u_is_size_feature_constant: new a.aH(ue, w.u_is_size_feature_constant), u_size_t: new a.aI(ue, w.u_size_t), u_size: new a.aI(ue, w.u_size), u_camera_to_center_distance: new a.aI(ue, w.u_camera_to_center_distance), u_pitch: new a.aI(ue, w.u_pitch), u_rotate_symbol: new a.aH(ue, w.u_rotate_symbol), u_aspect_ratio: new a.aI(ue, w.u_aspect_ratio), u_fade_change: new a.aI(ue, w.u_fade_change), u_matrix: new a.aJ(ue, w.u_matrix), u_label_plane_matrix: new a.aJ(ue, w.u_label_plane_matrix), u_coord_matrix: new a.aJ(ue, w.u_coord_matrix), u_is_text: new a.aH(ue, w.u_is_text), u_pitch_with_map: new a.aH(ue, w.u_pitch_with_map), u_is_along_line: new a.aH(ue, w.u_is_along_line), u_is_variable_anchor: new a.aH(ue, w.u_is_variable_anchor), u_texsize: new a.aO(ue, w.u_texsize), u_texsize_icon: new a.aO(ue, w.u_texsize_icon), u_texture: new a.aH(ue, w.u_texture), u_texture_icon: new a.aH(ue, w.u_texture_icon), u_gamma_scale: new a.aI(ue, w.u_gamma_scale), u_device_pixel_ratio: new a.aI(ue, w.u_device_pixel_ratio), u_is_halo: new a.aH(ue, w.u_is_halo), u_translation: new a.aO(ue, w.u_translation), u_pitched_scale: new a.aI(ue, w.u_pitched_scale) }), background: (ue, w) => ({ u_matrix: new a.aJ(ue, w.u_matrix), u_opacity: new a.aI(ue, w.u_opacity), u_color: new a.aL(ue, w.u_color) }), backgroundPattern: (ue, w) => ({ u_matrix: new a.aJ(ue, w.u_matrix), u_opacity: new a.aI(ue, w.u_opacity), u_image: new a.aH(ue, w.u_image), u_pattern_tl_a: new a.aO(ue, w.u_pattern_tl_a), u_pattern_br_a: new a.aO(ue, w.u_pattern_br_a), u_pattern_tl_b: new a.aO(ue, w.u_pattern_tl_b), u_pattern_br_b: new a.aO(ue, w.u_pattern_br_b), u_texsize: new a.aO(ue, w.u_texsize), u_mix: new a.aI(ue, w.u_mix), u_pattern_size_a: new a.aO(ue, w.u_pattern_size_a), u_pattern_size_b: new a.aO(ue, w.u_pattern_size_b), u_scale_a: new a.aI(ue, w.u_scale_a), u_scale_b: new a.aI(ue, w.u_scale_b), u_pixel_coord_upper: new a.aO(ue, w.u_pixel_coord_upper), u_pixel_coord_lower: new a.aO(ue, w.u_pixel_coord_lower), u_tile_units_to_pixels: new a.aI(ue, w.u_tile_units_to_pixels) }), terrain: (ue, w) => ({ u_matrix: new a.aJ(ue, w.u_matrix), u_texture: new a.aH(ue, w.u_texture), u_ele_delta: new a.aI(ue, w.u_ele_delta), u_fog_matrix: new a.aJ(ue, w.u_fog_matrix), u_fog_color: new a.aL(ue, w.u_fog_color), u_fog_ground_blend: new a.aI(ue, w.u_fog_ground_blend), u_fog_ground_blend_opacity: new a.aI(ue, w.u_fog_ground_blend_opacity), u_horizon_color: new a.aL(ue, w.u_horizon_color), u_horizon_fog_blend: new a.aI(ue, w.u_horizon_fog_blend) }), terrainDepth: (ue, w) => ({ u_matrix: new a.aJ(ue, w.u_matrix), u_ele_delta: new a.aI(ue, w.u_ele_delta) }), terrainCoords: (ue, w) => ({ u_matrix: new a.aJ(ue, w.u_matrix), u_texture: new a.aH(ue, w.u_texture), u_terrain_coords_id: new a.aI(ue, w.u_terrain_coords_id), u_ele_delta: new a.aI(ue, w.u_ele_delta) }), sky: (ue, w) => ({ u_sky_color: new a.aL(ue, w.u_sky_color), u_horizon_color: new a.aL(ue, w.u_horizon_color), u_horizon: new a.aI(ue, w.u_horizon), u_sky_horizon_blend: new a.aI(ue, w.u_sky_horizon_blend) }) };
+            class bs {
+              constructor(w, B, Q) {
+                this.context = w;
+                let ee = w.gl;
+                this.buffer = ee.createBuffer(), this.dynamicDraw = !!Q, this.context.unbindVAO(), w.bindElementBuffer.set(this.buffer), ee.bufferData(ee.ELEMENT_ARRAY_BUFFER, B.arrayBuffer, this.dynamicDraw ? ee.DYNAMIC_DRAW : ee.STATIC_DRAW), this.dynamicDraw || delete B.arrayBuffer;
+              }
+              bind() {
+                this.context.bindElementBuffer.set(this.buffer);
+              }
+              updateData(w) {
+                let B = this.context.gl;
+                if (!this.dynamicDraw) throw new Error("Attempted to update data while not in dynamic mode.");
+                this.context.unbindVAO(), this.bind(), B.bufferSubData(B.ELEMENT_ARRAY_BUFFER, 0, w.arrayBuffer);
+              }
+              destroy() {
+                this.buffer && (this.context.gl.deleteBuffer(this.buffer), delete this.buffer);
+              }
+            }
+            let Rn = { Int8: "BYTE", Uint8: "UNSIGNED_BYTE", Int16: "SHORT", Uint16: "UNSIGNED_SHORT", Int32: "INT", Uint32: "UNSIGNED_INT", Float32: "FLOAT" };
+            class _a {
+              constructor(w, B, Q, ee) {
+                this.length = B.length, this.attributes = Q, this.itemSize = B.bytesPerElement, this.dynamicDraw = ee, this.context = w;
+                let le = w.gl;
+                this.buffer = le.createBuffer(), w.bindVertexBuffer.set(this.buffer), le.bufferData(le.ARRAY_BUFFER, B.arrayBuffer, this.dynamicDraw ? le.DYNAMIC_DRAW : le.STATIC_DRAW), this.dynamicDraw || delete B.arrayBuffer;
+              }
+              bind() {
+                this.context.bindVertexBuffer.set(this.buffer);
+              }
+              updateData(w) {
+                if (w.length !== this.length) throw new Error(`Length of new data is ${w.length}, which doesn't match current length of ${this.length}`);
+                let B = this.context.gl;
+                this.bind(), B.bufferSubData(B.ARRAY_BUFFER, 0, w.arrayBuffer);
+              }
+              enableAttributes(w, B) {
+                for (let Q = 0; Q < this.attributes.length; Q++) {
+                  let ee = B.attributes[this.attributes[Q].name];
+                  ee !== void 0 && w.enableVertexAttribArray(ee);
+                }
+              }
+              setVertexAttribPointers(w, B, Q) {
+                for (let ee = 0; ee < this.attributes.length; ee++) {
+                  let le = this.attributes[ee], Oe = B.attributes[le.name];
+                  Oe !== void 0 && w.vertexAttribPointer(Oe, le.components, w[Rn[le.type]], false, this.itemSize, le.offset + this.itemSize * (Q || 0));
+                }
+              }
+              destroy() {
+                this.buffer && (this.context.gl.deleteBuffer(this.buffer), delete this.buffer);
+              }
+            }
+            let Vu = /* @__PURE__ */ new WeakMap();
+            function Ol(ue) {
+              var w;
+              if (Vu.has(ue)) return Vu.get(ue);
+              {
+                let B = (w = ue.getParameter(ue.VERSION)) === null || w === void 0 ? void 0 : w.startsWith("WebGL 2.0");
+                return Vu.set(ue, B), B;
+              }
+            }
+            class xo {
+              constructor(w) {
+                this.gl = w.gl, this.default = this.getDefault(), this.current = this.default, this.dirty = false;
+              }
+              get() {
+                return this.current;
+              }
+              set(w) {
+              }
+              getDefault() {
+                return this.default;
+              }
+              setDefault() {
+                this.set(this.default);
+              }
+            }
+            class Kl extends xo {
+              getDefault() {
+                return a.aM.transparent;
+              }
+              set(w) {
+                let B = this.current;
+                (w.r !== B.r || w.g !== B.g || w.b !== B.b || w.a !== B.a || this.dirty) && (this.gl.clearColor(w.r, w.g, w.b, w.a), this.current = w, this.dirty = false);
+              }
+            }
+            class Ns extends xo {
+              getDefault() {
+                return 1;
+              }
+              set(w) {
+                (w !== this.current || this.dirty) && (this.gl.clearDepth(w), this.current = w, this.dirty = false);
+              }
+            }
+            class Hl extends xo {
+              getDefault() {
+                return 0;
+              }
+              set(w) {
+                (w !== this.current || this.dirty) && (this.gl.clearStencil(w), this.current = w, this.dirty = false);
+              }
+            }
+            class ac extends xo {
+              getDefault() {
+                return [true, true, true, true];
+              }
+              set(w) {
+                let B = this.current;
+                (w[0] !== B[0] || w[1] !== B[1] || w[2] !== B[2] || w[3] !== B[3] || this.dirty) && (this.gl.colorMask(w[0], w[1], w[2], w[3]), this.current = w, this.dirty = false);
+              }
+            }
+            class aa extends xo {
+              getDefault() {
+                return true;
+              }
+              set(w) {
+                (w !== this.current || this.dirty) && (this.gl.depthMask(w), this.current = w, this.dirty = false);
+              }
+            }
+            class Oo extends xo {
+              getDefault() {
+                return 255;
+              }
+              set(w) {
+                (w !== this.current || this.dirty) && (this.gl.stencilMask(w), this.current = w, this.dirty = false);
+              }
+            }
+            class qo extends xo {
+              getDefault() {
+                return { func: this.gl.ALWAYS, ref: 0, mask: 255 };
+              }
+              set(w) {
+                let B = this.current;
+                (w.func !== B.func || w.ref !== B.ref || w.mask !== B.mask || this.dirty) && (this.gl.stencilFunc(w.func, w.ref, w.mask), this.current = w, this.dirty = false);
+              }
+            }
+            class ql extends xo {
+              getDefault() {
+                let w = this.gl;
+                return [w.KEEP, w.KEEP, w.KEEP];
+              }
+              set(w) {
+                let B = this.current;
+                (w[0] !== B[0] || w[1] !== B[1] || w[2] !== B[2] || this.dirty) && (this.gl.stencilOp(w[0], w[1], w[2]), this.current = w, this.dirty = false);
+              }
+            }
+            class Pc extends xo {
+              getDefault() {
+                return false;
+              }
+              set(w) {
+                if (w === this.current && !this.dirty) return;
+                let B = this.gl;
+                w ? B.enable(B.STENCIL_TEST) : B.disable(B.STENCIL_TEST), this.current = w, this.dirty = false;
+              }
+            }
+            class Do extends xo {
+              getDefault() {
+                return [0, 1];
+              }
+              set(w) {
+                let B = this.current;
+                (w[0] !== B[0] || w[1] !== B[1] || this.dirty) && (this.gl.depthRange(w[0], w[1]), this.current = w, this.dirty = false);
+              }
+            }
+            class rf extends xo {
+              getDefault() {
+                return false;
+              }
+              set(w) {
+                if (w === this.current && !this.dirty) return;
+                let B = this.gl;
+                w ? B.enable(B.DEPTH_TEST) : B.disable(B.DEPTH_TEST), this.current = w, this.dirty = false;
+              }
+            }
+            class Vf extends xo {
+              getDefault() {
+                return this.gl.LESS;
+              }
+              set(w) {
+                (w !== this.current || this.dirty) && (this.gl.depthFunc(w), this.current = w, this.dirty = false);
+              }
+            }
+            class pl extends xo {
+              getDefault() {
+                return false;
+              }
+              set(w) {
+                if (w === this.current && !this.dirty) return;
+                let B = this.gl;
+                w ? B.enable(B.BLEND) : B.disable(B.BLEND), this.current = w, this.dirty = false;
+              }
+            }
+            class Zc extends xo {
+              getDefault() {
+                let w = this.gl;
+                return [w.ONE, w.ZERO];
+              }
+              set(w) {
+                let B = this.current;
+                (w[0] !== B[0] || w[1] !== B[1] || this.dirty) && (this.gl.blendFunc(w[0], w[1]), this.current = w, this.dirty = false);
+              }
+            }
+            class Jl extends xo {
+              getDefault() {
+                return a.aM.transparent;
+              }
+              set(w) {
+                let B = this.current;
+                (w.r !== B.r || w.g !== B.g || w.b !== B.b || w.a !== B.a || this.dirty) && (this.gl.blendColor(w.r, w.g, w.b, w.a), this.current = w, this.dirty = false);
+              }
+            }
+            class Os extends xo {
+              getDefault() {
+                return this.gl.FUNC_ADD;
+              }
+              set(w) {
+                (w !== this.current || this.dirty) && (this.gl.blendEquation(w), this.current = w, this.dirty = false);
+              }
+            }
+            class yu extends xo {
+              getDefault() {
+                return false;
+              }
+              set(w) {
+                if (w === this.current && !this.dirty) return;
+                let B = this.gl;
+                w ? B.enable(B.CULL_FACE) : B.disable(B.CULL_FACE), this.current = w, this.dirty = false;
+              }
+            }
+            class oc extends xo {
+              getDefault() {
+                return this.gl.BACK;
+              }
+              set(w) {
+                (w !== this.current || this.dirty) && (this.gl.cullFace(w), this.current = w, this.dirty = false);
+              }
+            }
+            class Cf extends xo {
+              getDefault() {
+                return this.gl.CCW;
+              }
+              set(w) {
+                (w !== this.current || this.dirty) && (this.gl.frontFace(w), this.current = w, this.dirty = false);
+              }
+            }
+            class sc extends xo {
+              getDefault() {
+                return null;
+              }
+              set(w) {
+                (w !== this.current || this.dirty) && (this.gl.useProgram(w), this.current = w, this.dirty = false);
+              }
+            }
+            class jh extends xo {
+              getDefault() {
+                return this.gl.TEXTURE0;
+              }
+              set(w) {
+                (w !== this.current || this.dirty) && (this.gl.activeTexture(w), this.current = w, this.dirty = false);
+              }
+            }
+            class Lf extends xo {
+              getDefault() {
+                let w = this.gl;
+                return [0, 0, w.drawingBufferWidth, w.drawingBufferHeight];
+              }
+              set(w) {
+                let B = this.current;
+                (w[0] !== B[0] || w[1] !== B[1] || w[2] !== B[2] || w[3] !== B[3] || this.dirty) && (this.gl.viewport(w[0], w[1], w[2], w[3]), this.current = w, this.dirty = false);
+              }
+            }
+            class cs extends xo {
+              getDefault() {
+                return null;
+              }
+              set(w) {
+                if (w === this.current && !this.dirty) return;
+                let B = this.gl;
+                B.bindFramebuffer(B.FRAMEBUFFER, w), this.current = w, this.dirty = false;
+              }
+            }
+            class nf extends xo {
+              getDefault() {
+                return null;
+              }
+              set(w) {
+                if (w === this.current && !this.dirty) return;
+                let B = this.gl;
+                B.bindRenderbuffer(B.RENDERBUFFER, w), this.current = w, this.dirty = false;
+              }
+            }
+            class Gf extends xo {
+              getDefault() {
+                return null;
+              }
+              set(w) {
+                if (w === this.current && !this.dirty) return;
+                let B = this.gl;
+                B.bindTexture(B.TEXTURE_2D, w), this.current = w, this.dirty = false;
+              }
+            }
+            class $l extends xo {
+              getDefault() {
+                return null;
+              }
+              set(w) {
+                if (w === this.current && !this.dirty) return;
+                let B = this.gl;
+                B.bindBuffer(B.ARRAY_BUFFER, w), this.current = w, this.dirty = false;
+              }
+            }
+            class fl extends xo {
+              getDefault() {
+                return null;
+              }
+              set(w) {
+                let B = this.gl;
+                B.bindBuffer(B.ELEMENT_ARRAY_BUFFER, w), this.current = w, this.dirty = false;
+              }
+            }
+            class lc extends xo {
+              getDefault() {
+                return null;
+              }
+              set(w) {
+                var B;
+                if (w === this.current && !this.dirty) return;
+                let Q = this.gl;
+                Ol(Q) ? Q.bindVertexArray(w) : (B = Q.getExtension("OES_vertex_array_object")) === null || B === void 0 || B.bindVertexArrayOES(w), this.current = w, this.dirty = false;
+              }
+            }
+            class Fu extends xo {
+              getDefault() {
+                return 4;
+              }
+              set(w) {
+                if (w === this.current && !this.dirty) return;
+                let B = this.gl;
+                B.pixelStorei(B.UNPACK_ALIGNMENT, w), this.current = w, this.dirty = false;
+              }
+            }
+            class Es extends xo {
+              getDefault() {
+                return false;
+              }
+              set(w) {
+                if (w === this.current && !this.dirty) return;
+                let B = this.gl;
+                B.pixelStorei(B.UNPACK_PREMULTIPLY_ALPHA_WEBGL, w), this.current = w, this.dirty = false;
+              }
+            }
+            class Hs extends xo {
+              getDefault() {
+                return false;
+              }
+              set(w) {
+                if (w === this.current && !this.dirty) return;
+                let B = this.gl;
+                B.pixelStorei(B.UNPACK_FLIP_Y_WEBGL, w), this.current = w, this.dirty = false;
+              }
+            }
+            class Go extends xo {
+              constructor(w, B) {
+                super(w), this.context = w, this.parent = B;
+              }
+              getDefault() {
+                return null;
+              }
+            }
+            class ps extends Go {
+              setDirty() {
+                this.dirty = true;
+              }
+              set(w) {
+                if (w === this.current && !this.dirty) return;
+                this.context.bindFramebuffer.set(this.parent);
+                let B = this.gl;
+                B.framebufferTexture2D(B.FRAMEBUFFER, B.COLOR_ATTACHMENT0, B.TEXTURE_2D, w, 0), this.current = w, this.dirty = false;
+              }
+            }
+            class uc extends Go {
+              set(w) {
+                if (w === this.current && !this.dirty) return;
+                this.context.bindFramebuffer.set(this.parent);
+                let B = this.gl;
+                B.framebufferRenderbuffer(B.FRAMEBUFFER, B.DEPTH_ATTACHMENT, B.RENDERBUFFER, w), this.current = w, this.dirty = false;
+              }
+            }
+            class xl extends Go {
+              set(w) {
+                if (w === this.current && !this.dirty) return;
+                this.context.bindFramebuffer.set(this.parent);
+                let B = this.gl;
+                B.framebufferRenderbuffer(B.FRAMEBUFFER, B.DEPTH_STENCIL_ATTACHMENT, B.RENDERBUFFER, w), this.current = w, this.dirty = false;
+              }
+            }
+            class Gu {
+              constructor(w, B, Q, ee, le) {
+                this.context = w, this.width = B, this.height = Q;
+                let Oe = w.gl, Ze = this.framebuffer = Oe.createFramebuffer();
+                if (this.colorAttachment = new ps(w, Ze), ee) this.depthAttachment = le ? new xl(w, Ze) : new uc(w, Ze);
+                else if (le) throw new Error("Stencil cannot be set without depth");
+                if (Oe.checkFramebufferStatus(Oe.FRAMEBUFFER) !== Oe.FRAMEBUFFER_COMPLETE) throw new Error("Framebuffer is not complete");
+              }
+              destroy() {
+                let w = this.context.gl, B = this.colorAttachment.get();
+                if (B && w.deleteTexture(B), this.depthAttachment) {
+                  let Q = this.depthAttachment.get();
+                  Q && w.deleteRenderbuffer(Q);
+                }
+                w.deleteFramebuffer(this.framebuffer);
+              }
+            }
+            class qs {
+              constructor(w, B, Q) {
+                this.blendFunction = w, this.blendColor = B, this.mask = Q;
+              }
+            }
+            qs.Replace = [1, 0], qs.disabled = new qs(qs.Replace, a.aM.transparent, [false, false, false, false]), qs.unblended = new qs(qs.Replace, a.aM.transparent, [true, true, true, true]), qs.alphaBlended = new qs([1, 771], a.aM.transparent, [true, true, true, true]);
+            class od {
+              constructor(w) {
+                var B, Q;
+                if (this.gl = w, this.clearColor = new Kl(this), this.clearDepth = new Ns(this), this.clearStencil = new Hl(this), this.colorMask = new ac(this), this.depthMask = new aa(this), this.stencilMask = new Oo(this), this.stencilFunc = new qo(this), this.stencilOp = new ql(this), this.stencilTest = new Pc(this), this.depthRange = new Do(this), this.depthTest = new rf(this), this.depthFunc = new Vf(this), this.blend = new pl(this), this.blendFunc = new Zc(this), this.blendColor = new Jl(this), this.blendEquation = new Os(this), this.cullFace = new yu(this), this.cullFaceSide = new oc(this), this.frontFace = new Cf(this), this.program = new sc(this), this.activeTexture = new jh(this), this.viewport = new Lf(this), this.bindFramebuffer = new cs(this), this.bindRenderbuffer = new nf(this), this.bindTexture = new Gf(this), this.bindVertexBuffer = new $l(this), this.bindElementBuffer = new fl(this), this.bindVertexArray = new lc(this), this.pixelStoreUnpack = new Fu(this), this.pixelStoreUnpackPremultiplyAlpha = new Es(this), this.pixelStoreUnpackFlipY = new Hs(this), this.extTextureFilterAnisotropic = w.getExtension("EXT_texture_filter_anisotropic") || w.getExtension("MOZ_EXT_texture_filter_anisotropic") || w.getExtension("WEBKIT_EXT_texture_filter_anisotropic"), this.extTextureFilterAnisotropic && (this.extTextureFilterAnisotropicMax = w.getParameter(this.extTextureFilterAnisotropic.MAX_TEXTURE_MAX_ANISOTROPY_EXT)), this.maxTextureSize = w.getParameter(w.MAX_TEXTURE_SIZE), Ol(w)) {
+                  this.HALF_FLOAT = w.HALF_FLOAT;
+                  let ee = w.getExtension("EXT_color_buffer_half_float");
+                  this.RGBA16F = (B = w.RGBA16F) !== null && B !== void 0 ? B : ee == null ? void 0 : ee.RGBA16F_EXT, this.RGB16F = (Q = w.RGB16F) !== null && Q !== void 0 ? Q : ee == null ? void 0 : ee.RGB16F_EXT, w.getExtension("EXT_color_buffer_float");
+                } else {
+                  w.getExtension("EXT_color_buffer_half_float"), w.getExtension("OES_texture_half_float_linear");
+                  let ee = w.getExtension("OES_texture_half_float");
+                  this.HALF_FLOAT = ee == null ? void 0 : ee.HALF_FLOAT_OES;
+                }
+              }
+              setDefault() {
+                this.unbindVAO(), this.clearColor.setDefault(), this.clearDepth.setDefault(), this.clearStencil.setDefault(), this.colorMask.setDefault(), this.depthMask.setDefault(), this.stencilMask.setDefault(), this.stencilFunc.setDefault(), this.stencilOp.setDefault(), this.stencilTest.setDefault(), this.depthRange.setDefault(), this.depthTest.setDefault(), this.depthFunc.setDefault(), this.blend.setDefault(), this.blendFunc.setDefault(), this.blendColor.setDefault(), this.blendEquation.setDefault(), this.cullFace.setDefault(), this.cullFaceSide.setDefault(), this.frontFace.setDefault(), this.program.setDefault(), this.activeTexture.setDefault(), this.bindFramebuffer.setDefault(), this.pixelStoreUnpack.setDefault(), this.pixelStoreUnpackPremultiplyAlpha.setDefault(), this.pixelStoreUnpackFlipY.setDefault();
+              }
+              setDirty() {
+                this.clearColor.dirty = true, this.clearDepth.dirty = true, this.clearStencil.dirty = true, this.colorMask.dirty = true, this.depthMask.dirty = true, this.stencilMask.dirty = true, this.stencilFunc.dirty = true, this.stencilOp.dirty = true, this.stencilTest.dirty = true, this.depthRange.dirty = true, this.depthTest.dirty = true, this.depthFunc.dirty = true, this.blend.dirty = true, this.blendFunc.dirty = true, this.blendColor.dirty = true, this.blendEquation.dirty = true, this.cullFace.dirty = true, this.cullFaceSide.dirty = true, this.frontFace.dirty = true, this.program.dirty = true, this.activeTexture.dirty = true, this.viewport.dirty = true, this.bindFramebuffer.dirty = true, this.bindRenderbuffer.dirty = true, this.bindTexture.dirty = true, this.bindVertexBuffer.dirty = true, this.bindElementBuffer.dirty = true, this.bindVertexArray.dirty = true, this.pixelStoreUnpack.dirty = true, this.pixelStoreUnpackPremultiplyAlpha.dirty = true, this.pixelStoreUnpackFlipY.dirty = true;
+              }
+              createIndexBuffer(w, B) {
+                return new bs(this, w, B);
+              }
+              createVertexBuffer(w, B, Q) {
+                return new _a(this, w, B, Q);
+              }
+              createRenderbuffer(w, B, Q) {
+                let ee = this.gl, le = ee.createRenderbuffer();
+                return this.bindRenderbuffer.set(le), ee.renderbufferStorage(ee.RENDERBUFFER, w, B, Q), this.bindRenderbuffer.set(null), le;
+              }
+              createFramebuffer(w, B, Q, ee) {
+                return new Gu(this, w, B, Q, ee);
+              }
+              clear({ color: w, depth: B, stencil: Q }) {
+                let ee = this.gl, le = 0;
+                w && (le |= ee.COLOR_BUFFER_BIT, this.clearColor.set(w), this.colorMask.set([true, true, true, true])), B !== void 0 && (le |= ee.DEPTH_BUFFER_BIT, this.depthRange.set([0, 1]), this.clearDepth.set(B), this.depthMask.set(true)), Q !== void 0 && (le |= ee.STENCIL_BUFFER_BIT, this.clearStencil.set(Q), this.stencilMask.set(255)), ee.clear(le);
+              }
+              setCullFace(w) {
+                w.enable === false ? this.cullFace.set(false) : (this.cullFace.set(true), this.cullFaceSide.set(w.mode), this.frontFace.set(w.frontFace));
+              }
+              setDepthMode(w) {
+                w.func !== this.gl.ALWAYS || w.mask ? (this.depthTest.set(true), this.depthFunc.set(w.func), this.depthMask.set(w.mask), this.depthRange.set(w.range)) : this.depthTest.set(false);
+              }
+              setStencilMode(w) {
+                w.test.func !== this.gl.ALWAYS || w.mask ? (this.stencilTest.set(true), this.stencilMask.set(w.mask), this.stencilOp.set([w.fail, w.depthFail, w.pass]), this.stencilFunc.set({ func: w.test.func, ref: w.ref, mask: w.test.mask })) : this.stencilTest.set(false);
+              }
+              setColorMode(w) {
+                a.aE(w.blendFunction, qs.Replace) ? this.blend.set(false) : (this.blend.set(true), this.blendFunc.set(w.blendFunction), this.blendColor.set(w.blendColor)), this.colorMask.set(w.mask);
+              }
+              createVertexArray() {
+                var w;
+                return Ol(this.gl) ? this.gl.createVertexArray() : (w = this.gl.getExtension("OES_vertex_array_object")) === null || w === void 0 ? void 0 : w.createVertexArrayOES();
+              }
+              deleteVertexArray(w) {
+                var B;
+                return Ol(this.gl) ? this.gl.deleteVertexArray(w) : (B = this.gl.getExtension("OES_vertex_array_object")) === null || B === void 0 ? void 0 : B.deleteVertexArrayOES(w);
+              }
+              unbindVAO() {
+                this.bindVertexArray.set(null);
+              }
+            }
+            class Po {
+              constructor(w, B, Q) {
+                this.func = w, this.mask = B, this.range = Q;
+              }
+            }
+            Po.ReadOnly = false, Po.ReadWrite = true, Po.disabled = new Po(519, Po.ReadOnly, [0, 1]);
+            let sd = 7680;
+            class Ko {
+              constructor(w, B, Q, ee, le, Oe) {
+                this.test = w, this.ref = B, this.mask = Q, this.fail = ee, this.depthFail = le, this.pass = Oe;
+              }
+            }
+            Ko.disabled = new Ko({ func: 519, mask: 0 }, 0, 0, sd, sd, sd);
+            class Pa {
+              constructor(w, B, Q) {
+                this.enable = w, this.mode = B, this.frontFace = Q;
+              }
+            }
+            let af;
+            function Hu(ue, w, B, Q, ee) {
+              let le = ue.context, Oe = le.gl, Ze = ue.useProgram("collisionBox"), st = [], Tt = 0, Yt = 0;
+              for (let qe = 0; qe < Q.length; qe++) {
+                let et = Q[qe], Xe = w.getTile(et).getBucket(B);
+                if (!Xe) continue;
+                let it = ee ? Xe.textCollisionBox : Xe.iconCollisionBox, Ft = Xe.collisionCircleArray;
+                if (Ft.length > 0) {
+                  let Ht = a.H();
+                  a.aQ(Ht, Xe.placementInvProjMatrix, ue.transform.glCoordMatrix), a.aQ(Ht, Ht, Xe.placementViewportMatrix), st.push({ circleArray: Ft, circleOffset: Yt, transform: et.posMatrix, invTransform: Ht, coord: et }), Tt += Ft.length / 4, Yt = Tt;
+                }
+                it && Ze.draw(le, Oe.LINES, Po.disabled, Ko.disabled, ue.colorModeForRenderPass(), Pa.disabled, { u_matrix: et.posMatrix, u_pixel_extrude_scale: [1 / (Kt = ue.transform).width, 1 / Kt.height] }, ue.style.map.terrain && ue.style.map.terrain.getTerrainData(et), B.id, it.layoutVertexBuffer, it.indexBuffer, it.segments, null, ue.transform.zoom, null, null, it.collisionVertexBuffer);
+              }
+              var Kt;
+              if (!ee || !st.length) return;
+              let xr = ue.useProgram("collisionCircle"), Ir = new a.aR();
+              Ir.resize(4 * Tt), Ir._trim();
+              let ve = 0;
+              for (let qe of st) for (let et = 0; et < qe.circleArray.length / 4; et++) {
+                let Xe = 4 * et, it = qe.circleArray[Xe + 0], Ft = qe.circleArray[Xe + 1], Ht = qe.circleArray[Xe + 2], tr = qe.circleArray[Xe + 3];
+                Ir.emplace(ve++, it, Ft, Ht, tr, 0), Ir.emplace(ve++, it, Ft, Ht, tr, 1), Ir.emplace(ve++, it, Ft, Ht, tr, 2), Ir.emplace(ve++, it, Ft, Ht, tr, 3);
+              }
+              (!af || af.length < 2 * Tt) && (af = function(qe) {
+                let et = 2 * qe, Xe = new a.aT();
+                Xe.resize(et), Xe._trim();
+                for (let it = 0; it < et; it++) {
+                  let Ft = 6 * it;
+                  Xe.uint16[Ft + 0] = 4 * it + 0, Xe.uint16[Ft + 1] = 4 * it + 1, Xe.uint16[Ft + 2] = 4 * it + 2, Xe.uint16[Ft + 3] = 4 * it + 2, Xe.uint16[Ft + 4] = 4 * it + 3, Xe.uint16[Ft + 5] = 4 * it + 0;
+                }
+                return Xe;
+              }(Tt));
+              let be = le.createIndexBuffer(af, true), Re = le.createVertexBuffer(Ir, a.aS.members, true);
+              for (let qe of st) {
+                let et = No(qe.transform, qe.invTransform, ue.transform);
+                xr.draw(le, Oe.TRIANGLES, Po.disabled, Ko.disabled, ue.colorModeForRenderPass(), Pa.disabled, et, ue.style.map.terrain && ue.style.map.terrain.getTerrainData(qe.coord), B.id, Re, be, a.a0.simpleSegment(0, 2 * qe.circleOffset, qe.circleArray.length, qe.circleArray.length / 2), null, ue.transform.zoom, null, null, null);
+              }
+              Re.destroy(), be.destroy();
+            }
+            Pa.disabled = new Pa(false, 1029, 2305), Pa.backCCW = new Pa(true, 1029, 2305);
+            let bl = a.an(new Float32Array(16));
+            function Hf(ue, w, B, Q, ee, le) {
+              let { horizontalAlign: Oe, verticalAlign: Ze } = a.au(ue);
+              return new a.P((-(Oe - 0.5) * w / ee + Q[0]) * le, (-(Ze - 0.5) * B / ee + Q[1]) * le);
+            }
+            function Ic(ue, w, B, Q, ee, le) {
+              let Oe = w.tileAnchorPoint.add(new a.P(w.translation[0], w.translation[1]));
+              if (w.pitchWithMap) {
+                let Ze = Q.mult(le);
+                B || (Ze = Ze.rotate(-ee));
+                let st = Oe.add(Ze);
+                return dt(st.x, st.y, w.labelPlaneMatrix, w.getElevation).point;
+              }
+              if (B) {
+                let Ze = vt(w.tileAnchorPoint.x + 1, w.tileAnchorPoint.y, w).point.sub(ue), st = Math.atan(Ze.y / Ze.x) + (Ze.x < 0 ? Math.PI : 0);
+                return ue.add(Q.rotate(st));
+              }
+              return ue.add(Q);
+            }
+            function yf(ue, w, B, Q, ee, le, Oe, Ze, st, Tt, Yt, Kt, xr, Ir) {
+              let ve = ue.text.placedSymbolArray, be = ue.text.dynamicLayoutVertexArray, Re = ue.icon.dynamicLayoutVertexArray, qe = {};
+              be.clear();
+              for (let et = 0; et < ve.length; et++) {
+                let Xe = ve.get(et), it = Xe.hidden || !Xe.crossTileID || ue.allowVerticalPlacement && !Xe.placedOrientation ? null : Q[Xe.crossTileID];
+                if (it) {
+                  let Ft = new a.P(Xe.anchorX, Xe.anchorY), Ht = { getElevation: Ir, width: ee.width, height: ee.height, labelPlaneMatrix: le, pitchWithMap: B, projection: Yt, tileAnchorPoint: Ft, translation: Kt, unwrappedTileID: xr }, tr = B ? dt(Ft.x, Ft.y, Oe, Ir) : vt(Ft.x, Ft.y, Ht), dr = Ge(ee.cameraToCenterDistance, tr.signedDistanceFromCamera), Sr = a.ai(ue.textSizeData, st, Xe) * dr / a.ap;
+                  B && (Sr *= ue.tilePixelRatio / Ze);
+                  let { width: Or, height: Wr, anchor: ni, textOffset: Pi, textBoxScale: cn } = it, ln = Hf(ni, Or, Wr, Pi, cn, Sr), Cn = Yt.getPitchedTextCorrection(ee, Ft.add(new a.P(Kt[0], Kt[1])), xr), Kn = Ic(tr.point, Ht, w, ln, ee.angle, Cn), Aa = ue.allowVerticalPlacement && Xe.placedOrientation === a.ah.vertical ? Math.PI / 2 : 0;
+                  for (let fa = 0; fa < Xe.numGlyphs; fa++) a.aj(be, Kn, Aa);
+                  Tt && Xe.associatedIconIndex >= 0 && (qe[Xe.associatedIconIndex] = { shiftedAnchor: Kn, angle: Aa });
+                } else pi(Xe.numGlyphs, be);
+              }
+              if (Tt) {
+                Re.clear();
+                let et = ue.icon.placedSymbolArray;
+                for (let Xe = 0; Xe < et.length; Xe++) {
+                  let it = et.get(Xe);
+                  if (it.hidden) pi(it.numGlyphs, Re);
+                  else {
+                    let Ft = qe[Xe];
+                    if (Ft) for (let Ht = 0; Ht < it.numGlyphs; Ht++) a.aj(Re, Ft.shiftedAnchor, Ft.angle);
+                    else pi(it.numGlyphs, Re);
+                  }
+                }
+                ue.icon.dynamicLayoutVertexBuffer.updateData(Re);
+              }
+              ue.text.dynamicLayoutVertexBuffer.updateData(be);
+            }
+            function Bl(ue, w, B) {
+              return B.iconsInText && w ? "symbolTextAndIcon" : ue ? "symbolSDF" : "symbolIcon";
+            }
+            function Ah(ue, w, B, Q, ee, le, Oe, Ze, st, Tt, Yt, Kt) {
+              let xr = ue.context, Ir = xr.gl, ve = ue.transform, be = yn(), Re = Ze === "map", qe = st === "map", et = Ze !== "viewport" && B.layout.get("symbol-placement") !== "point", Xe = Re && !qe && !et, it = !qe && et, Ft = !B.layout.get("symbol-sort-key").isConstant(), Ht = false, tr = ue.depthModeForSublayer(0, Po.ReadOnly), dr = B._unevaluatedLayout.hasValue("text-variable-anchor") || B._unevaluatedLayout.hasValue("text-variable-anchor-offset"), Sr = [], Or = be.getCircleRadiusCorrection(ve);
+              for (let Wr of Q) {
+                let ni = w.getTile(Wr), Pi = ni.getBucket(B);
+                if (!Pi) continue;
+                let cn = ee ? Pi.text : Pi.icon;
+                if (!cn || !cn.segments.get().length || !cn.hasVisibleVertices) continue;
+                let ln = cn.programConfigurations.get(B.id), Cn = ee || Pi.sdfIcons, Kn = ee ? Pi.textSizeData : Pi.iconSizeData, Aa = qe || ve.pitch !== 0, fa = ue.useProgram(Bl(Cn, ee, Pi), ln), $a = a.ag(Kn, ve.zoom), Co = ue.style.map.terrain && ue.style.map.terrain.getTerrainData(Wr), Qa, mo, Bo, Ps, Ts = [0, 0], wo = null;
+                if (ee) mo = ni.glyphAtlasTexture, Bo = Ir.LINEAR, Qa = ni.glyphAtlasTexture.size, Pi.iconsInText && (Ts = ni.imageAtlasTexture.size, wo = ni.imageAtlasTexture, Ps = Aa || ue.options.rotating || ue.options.zooming || Kn.kind === "composite" || Kn.kind === "camera" ? Ir.LINEAR : Ir.NEAREST);
+                else {
+                  let Ye = B.layout.get("icon-size").constantOr(0) !== 1 || Pi.iconsNeedLinear;
+                  mo = ni.imageAtlasTexture, Bo = Cn || ue.options.rotating || ue.options.zooming || Ye || Aa ? Ir.LINEAR : Ir.NEAREST, Qa = ni.imageAtlasTexture.size;
+                }
+                let To = In(ni, 1, ue.transform.zoom), hl = it ? Wr.posMatrix : bl, Ul = Br(hl, qe, Re, ue.transform, To), Lu = Vr(hl, qe, Re, ue.transform, To), au = Vr(Wr.posMatrix, qe, Re, ue.transform, To), Js = be.translatePosition(ue.transform, ni, le, Oe), eu = dr && Pi.hasTextData(), dc = B.layout.get("icon-text-fit") !== "none" && eu && Pi.hasIconData();
+                if (et) {
+                  let Ye = ue.style.map.terrain ? (nt, jt) => ue.style.map.terrain.getElevation(Wr, nt, jt) : null, kt = B.layout.get("text-rotation-alignment") === "map";
+                  We(Pi, Wr.posMatrix, ue, ee, Ul, au, qe, Tt, kt, be, Wr.toUnwrapped(), ve.width, ve.height, Js, Ye);
+                }
+                let Tl = Wr.posMatrix, Al = ee && dr || dc, X = et || Al ? bl : Ul, se = Lu, Te = Cn && B.paint.get(ee ? "text-halo-width" : "icon-halo-width").constantOr(1) !== 0, Ne;
+                Ne = Cn ? Pi.iconsInText ? ls(Kn.kind, $a, Xe, qe, et, Al, ue, Tl, X, se, Js, Qa, Ts, Or) : Io(Kn.kind, $a, Xe, qe, et, Al, ue, Tl, X, se, Js, ee, Qa, true, Or) : zs(Kn.kind, $a, Xe, qe, et, Al, ue, Tl, X, se, Js, ee, Qa, Or);
+                let He = { program: fa, buffers: cn, uniformValues: Ne, atlasTexture: mo, atlasTextureIcon: wo, atlasInterpolation: Bo, atlasInterpolationIcon: Ps, isSDF: Cn, hasHalo: Te };
+                if (Ft && Pi.canOverlap) {
+                  Ht = true;
+                  let Ye = cn.segments.get();
+                  for (let kt of Ye) Sr.push({ segments: new a.a0([kt]), sortKey: kt.sortKey, state: He, terrainData: Co });
+                } else Sr.push({ segments: cn.segments, sortKey: 0, state: He, terrainData: Co });
+              }
+              Ht && Sr.sort((Wr, ni) => Wr.sortKey - ni.sortKey);
+              for (let Wr of Sr) {
+                let ni = Wr.state;
+                if (xr.activeTexture.set(Ir.TEXTURE0), ni.atlasTexture.bind(ni.atlasInterpolation, Ir.CLAMP_TO_EDGE), ni.atlasTextureIcon && (xr.activeTexture.set(Ir.TEXTURE1), ni.atlasTextureIcon && ni.atlasTextureIcon.bind(ni.atlasInterpolationIcon, Ir.CLAMP_TO_EDGE)), ni.isSDF) {
+                  let Pi = ni.uniformValues;
+                  ni.hasHalo && (Pi.u_is_halo = 1, Qf(ni.buffers, Wr.segments, B, ue, ni.program, tr, Yt, Kt, Pi, Wr.terrainData)), Pi.u_is_halo = 0;
+                }
+                Qf(ni.buffers, Wr.segments, B, ue, ni.program, tr, Yt, Kt, ni.uniformValues, Wr.terrainData);
+              }
+            }
+            function Qf(ue, w, B, Q, ee, le, Oe, Ze, st, Tt) {
+              let Yt = Q.context;
+              ee.draw(Yt, Yt.gl.TRIANGLES, le, Oe, Ze, Pa.disabled, st, Tt, B.id, ue.layoutVertexBuffer, ue.indexBuffer, w, B.paint, Q.transform.zoom, ue.programConfigurations.get(B.id), ue.dynamicLayoutVertexBuffer, ue.opacityVertexBuffer);
+            }
+            function _f(ue, w, B, Q) {
+              let ee = ue.context, le = ee.gl, Oe = Ko.disabled, Ze = new qs([le.ONE, le.ONE], a.aM.transparent, [true, true, true, true]), st = w.getBucket(B);
+              if (!st) return;
+              let Tt = Q.key, Yt = B.heatmapFbos.get(Tt);
+              Yt || (Yt = eh(ee, w.tileSize, w.tileSize), B.heatmapFbos.set(Tt, Yt)), ee.bindFramebuffer.set(Yt.framebuffer), ee.viewport.set([0, 0, w.tileSize, w.tileSize]), ee.clear({ color: a.aM.transparent });
+              let Kt = st.programConfigurations.get(B.id), xr = ue.useProgram("heatmap", Kt), Ir = ue.style.map.terrain.getTerrainData(Q);
+              xr.draw(ee, le.TRIANGLES, Po.disabled, Oe, Ze, Pa.disabled, ko(Q.posMatrix, w, ue.transform.zoom, B.paint.get("heatmap-intensity")), Ir, B.id, st.layoutVertexBuffer, st.indexBuffer, st.segments, B.paint, ue.transform.zoom, Kt);
+            }
+            function Yc(ue, w, B) {
+              let Q = ue.context, ee = Q.gl;
+              Q.setColorMode(ue.colorModeForRenderPass());
+              let le = th(Q, w), Oe = B.key, Ze = w.heatmapFbos.get(Oe);
+              Ze && (Q.activeTexture.set(ee.TEXTURE0), ee.bindTexture(ee.TEXTURE_2D, Ze.colorAttachment.get()), Q.activeTexture.set(ee.TEXTURE1), le.bind(ee.LINEAR, ee.CLAMP_TO_EDGE), ue.useProgram("heatmapTexture").draw(Q, ee.TRIANGLES, Po.disabled, Ko.disabled, ue.colorModeForRenderPass(), Pa.disabled, Ds(ue, w, 0, 1), null, w.id, ue.rasterBoundsBuffer, ue.quadTriangleIndexBuffer, ue.rasterBoundsSegments, w.paint, ue.transform.zoom), Ze.destroy(), w.heatmapFbos.delete(Oe));
+            }
+            function eh(ue, w, B) {
+              var Q, ee;
+              let le = ue.gl, Oe = le.createTexture();
+              le.bindTexture(le.TEXTURE_2D, Oe), le.texParameteri(le.TEXTURE_2D, le.TEXTURE_WRAP_S, le.CLAMP_TO_EDGE), le.texParameteri(le.TEXTURE_2D, le.TEXTURE_WRAP_T, le.CLAMP_TO_EDGE), le.texParameteri(le.TEXTURE_2D, le.TEXTURE_MIN_FILTER, le.LINEAR), le.texParameteri(le.TEXTURE_2D, le.TEXTURE_MAG_FILTER, le.LINEAR);
+              let Ze = (Q = ue.HALF_FLOAT) !== null && Q !== void 0 ? Q : le.UNSIGNED_BYTE, st = (ee = ue.RGBA16F) !== null && ee !== void 0 ? ee : le.RGBA;
+              le.texImage2D(le.TEXTURE_2D, 0, st, w, B, 0, le.RGBA, Ze, null);
+              let Tt = ue.createFramebuffer(w, B, false, false);
+              return Tt.colorAttachment.set(Oe), Tt;
+            }
+            function th(ue, w) {
+              return w.colorRampTexture || (w.colorRampTexture = new g(ue, w.colorRamp, ue.gl.RGBA)), w.colorRampTexture;
+            }
+            function ju(ue, w, B, Q, ee) {
+              if (!B || !Q || !Q.imageAtlas) return;
+              let le = Q.imageAtlas.patternPositions, Oe = le[B.to.toString()], Ze = le[B.from.toString()];
+              if (!Oe && Ze && (Oe = Ze), !Ze && Oe && (Ze = Oe), !Oe || !Ze) {
+                let st = ee.getPaintProperty(w);
+                Oe = le[st], Ze = le[st];
+              }
+              Oe && Ze && ue.setConstantPatternPositions(Oe, Ze);
+            }
+            function jf(ue, w, B, Q, ee, le, Oe) {
+              let Ze = ue.context.gl, st = "fill-pattern", Tt = B.paint.get(st), Yt = Tt && Tt.constantOr(1), Kt = B.getCrossfadeParameters(), xr, Ir, ve, be, Re;
+              Oe ? (Ir = Yt && !B.getPaintProperty("fill-outline-color") ? "fillOutlinePattern" : "fillOutline", xr = Ze.LINES) : (Ir = Yt ? "fillPattern" : "fill", xr = Ze.TRIANGLES);
+              let qe = Tt.constantOr(null);
+              for (let et of Q) {
+                let Xe = w.getTile(et);
+                if (Yt && !Xe.patternsLoaded()) continue;
+                let it = Xe.getBucket(B);
+                if (!it) continue;
+                let Ft = it.programConfigurations.get(B.id), Ht = ue.useProgram(Ir, Ft), tr = ue.style.map.terrain && ue.style.map.terrain.getTerrainData(et);
+                Yt && (ue.context.activeTexture.set(Ze.TEXTURE0), Xe.imageAtlasTexture.bind(Ze.LINEAR, Ze.CLAMP_TO_EDGE), Ft.updatePaintBuffers(Kt)), ju(Ft, st, qe, Xe, B);
+                let dr = tr ? et : null, Sr = ue.translatePosMatrix(dr ? dr.posMatrix : et.posMatrix, Xe, B.paint.get("fill-translate"), B.paint.get("fill-translate-anchor"));
+                if (Oe) {
+                  be = it.indexBuffer2, Re = it.segments2;
+                  let Or = [Ze.drawingBufferWidth, Ze.drawingBufferHeight];
+                  ve = Ir === "fillOutlinePattern" && Yt ? Ma(Sr, ue, Kt, Xe, Or) : $n(Sr, Or);
+                } else be = it.indexBuffer, Re = it.segments, ve = Yt ? ya(Sr, ue, Kt, Xe) : _n(Sr);
+                Ht.draw(ue.context, xr, ee, ue.stencilModeForClipping(et), le, Pa.disabled, ve, tr, B.id, it.layoutVertexBuffer, be, Re, B.paint, ue.transform.zoom, Ft);
+              }
+            }
+            function cc(ue, w, B, Q, ee, le, Oe) {
+              let Ze = ue.context, st = Ze.gl, Tt = "fill-extrusion-pattern", Yt = B.paint.get(Tt), Kt = Yt.constantOr(1), xr = B.getCrossfadeParameters(), Ir = B.paint.get("fill-extrusion-opacity"), ve = Yt.constantOr(null);
+              for (let be of Q) {
+                let Re = w.getTile(be), qe = Re.getBucket(B);
+                if (!qe) continue;
+                let et = ue.style.map.terrain && ue.style.map.terrain.getTerrainData(be), Xe = qe.programConfigurations.get(B.id), it = ue.useProgram(Kt ? "fillExtrusionPattern" : "fillExtrusion", Xe);
+                Kt && (ue.context.activeTexture.set(st.TEXTURE0), Re.imageAtlasTexture.bind(st.LINEAR, st.CLAMP_TO_EDGE), Xe.updatePaintBuffers(xr)), ju(Xe, Tt, ve, Re, B);
+                let Ft = ue.translatePosMatrix(be.posMatrix, Re, B.paint.get("fill-extrusion-translate"), B.paint.get("fill-extrusion-translate-anchor")), Ht = B.paint.get("fill-extrusion-vertical-gradient"), tr = Kt ? Li(Ft, ue, Ht, Ir, be, xr, Re) : Mn(Ft, ue, Ht, Ir);
+                it.draw(Ze, Ze.gl.TRIANGLES, ee, le, Oe, Pa.backCCW, tr, et, B.id, qe.layoutVertexBuffer, qe.indexBuffer, qe.segments, B.paint, ue.transform.zoom, Xe, ue.style.map.terrain && qe.centroidVertexBuffer);
+              }
+            }
+            function of(ue, w, B, Q, ee, le, Oe) {
+              let Ze = ue.context, st = Ze.gl, Tt = B.fbo;
+              if (!Tt) return;
+              let Yt = ue.useProgram("hillshade"), Kt = ue.style.map.terrain && ue.style.map.terrain.getTerrainData(w);
+              Ze.activeTexture.set(st.TEXTURE0), st.bindTexture(st.TEXTURE_2D, Tt.colorAttachment.get()), Yt.draw(Ze, st.TRIANGLES, ee, le, Oe, Pa.disabled, ((xr, Ir, ve, be) => {
+                let Re = ve.paint.get("hillshade-shadow-color"), qe = ve.paint.get("hillshade-highlight-color"), et = ve.paint.get("hillshade-accent-color"), Xe = ve.paint.get("hillshade-illumination-direction") * (Math.PI / 180);
+                ve.paint.get("hillshade-illumination-anchor") === "viewport" && (Xe -= xr.transform.angle);
+                let it = !xr.options.moving;
+                return { u_matrix: be ? be.posMatrix : xr.transform.calculatePosMatrix(Ir.tileID.toUnwrapped(), it), u_image: 0, u_latrange: Fs(0, Ir.tileID), u_light: [ve.paint.get("hillshade-exaggeration"), Xe], u_shadow: Re, u_highlight: qe, u_accent: et };
+              })(ue, B, Q, Kt ? w : null), Kt, Q.id, ue.rasterBoundsBuffer, ue.quadTriangleIndexBuffer, ue.rasterBoundsSegments);
+            }
+            function Nl(ue, w, B, Q, ee, le) {
+              let Oe = ue.context, Ze = Oe.gl, st = w.dem;
+              if (st && st.data) {
+                let Tt = st.dim, Yt = st.stride, Kt = st.getPixels();
+                if (Oe.activeTexture.set(Ze.TEXTURE1), Oe.pixelStoreUnpackPremultiplyAlpha.set(false), w.demTexture = w.demTexture || ue.getTileTexture(Yt), w.demTexture) {
+                  let Ir = w.demTexture;
+                  Ir.update(Kt, { premultiply: false }), Ir.bind(Ze.NEAREST, Ze.CLAMP_TO_EDGE);
+                } else w.demTexture = new g(Oe, Kt, Ze.RGBA, { premultiply: false }), w.demTexture.bind(Ze.NEAREST, Ze.CLAMP_TO_EDGE);
+                Oe.activeTexture.set(Ze.TEXTURE0);
+                let xr = w.fbo;
+                if (!xr) {
+                  let Ir = new g(Oe, { width: Tt, height: Tt, data: null }, Ze.RGBA);
+                  Ir.bind(Ze.LINEAR, Ze.CLAMP_TO_EDGE), xr = w.fbo = Oe.createFramebuffer(Tt, Tt, true, false), xr.colorAttachment.set(Ir.texture);
+                }
+                Oe.bindFramebuffer.set(xr.framebuffer), Oe.viewport.set([0, 0, Tt, Tt]), ue.useProgram("hillshadePrepare").draw(Oe, Ze.TRIANGLES, Q, ee, le, Pa.disabled, ((Ir, ve) => {
+                  let be = ve.stride, Re = a.H();
+                  return a.aP(Re, 0, a.X, -a.X, 0, 0, 1), a.J(Re, Re, [0, -a.X, 0]), { u_matrix: Re, u_image: 1, u_dimension: [be, be], u_zoom: Ir.overscaledZ, u_unpack: ve.getUnpackVector() };
+                })(w.tileID, st), null, B.id, ue.rasterBoundsBuffer, ue.quadTriangleIndexBuffer, ue.rasterBoundsSegments), w.needsHillshadePrepare = false;
+              }
+            }
+            function Kc(ue, w, B, Q, ee, le) {
+              let Oe = Q.paint.get("raster-fade-duration");
+              if (!le && Oe > 0) {
+                let Ze = u.now(), st = (Ze - ue.timeAdded) / Oe, Tt = w ? (Ze - w.timeAdded) / Oe : -1, Yt = B.getSource(), Kt = ee.coveringZoomLevel({ tileSize: Yt.tileSize, roundZoom: Yt.roundZoom }), xr = !w || Math.abs(w.tileID.overscaledZ - Kt) > Math.abs(ue.tileID.overscaledZ - Kt), Ir = xr && ue.refreshedUponExpiration ? 1 : a.ac(xr ? st : 1 - Tt, 0, 1);
+                return ue.refreshedUponExpiration && st >= 1 && (ue.refreshedUponExpiration = false), w ? { opacity: 1, mix: 1 - Ir } : { opacity: Ir, mix: 0 };
+              }
+              return { opacity: 1, mix: 0 };
+            }
+            let Rc = new a.aM(1, 0, 0, 1), gs = new a.aM(0, 1, 0, 1), Wf = new a.aM(0, 0, 1, 1), Wh = new a.aM(1, 0, 1, 1), rh = new a.aM(0, 1, 1, 1);
+            function sf(ue, w, B, Q) {
+              Mu(ue, 0, w + B / 2, ue.transform.width, B, Q);
+            }
+            function Sh(ue, w, B, Q) {
+              Mu(ue, w - B / 2, 0, B, ue.transform.height, Q);
+            }
+            function Mu(ue, w, B, Q, ee, le) {
+              let Oe = ue.context, Ze = Oe.gl;
+              Ze.enable(Ze.SCISSOR_TEST), Ze.scissor(w * ue.pixelRatio, B * ue.pixelRatio, Q * ue.pixelRatio, ee * ue.pixelRatio), Oe.clear({ color: le }), Ze.disable(Ze.SCISSOR_TEST);
+            }
+            function ih(ue, w, B) {
+              let Q = ue.context, ee = Q.gl, le = B.posMatrix, Oe = ue.useProgram("debug"), Ze = Po.disabled, st = Ko.disabled, Tt = ue.colorModeForRenderPass(), Yt = "$debug", Kt = ue.style.map.terrain && ue.style.map.terrain.getTerrainData(B);
+              Q.activeTexture.set(ee.TEXTURE0);
+              let xr = w.getTileByID(B.key).latestRawTileData, Ir = Math.floor((xr && xr.byteLength || 0) / 1024), ve = w.getTile(B).tileSize, be = 512 / Math.min(ve, 512) * (B.overscaledZ / ue.transform.zoom) * 0.5, Re = B.canonical.toString();
+              B.overscaledZ !== B.canonical.z && (Re += ` => ${B.overscaledZ}`), function(qe, et) {
+                qe.initDebugOverlayCanvas();
+                let Xe = qe.debugOverlayCanvas, it = qe.context.gl, Ft = qe.debugOverlayCanvas.getContext("2d");
+                Ft.clearRect(0, 0, Xe.width, Xe.height), Ft.shadowColor = "white", Ft.shadowBlur = 2, Ft.lineWidth = 1.5, Ft.strokeStyle = "white", Ft.textBaseline = "top", Ft.font = "bold 36px Open Sans, sans-serif", Ft.fillText(et, 5, 5), Ft.strokeText(et, 5, 5), qe.debugOverlayTexture.update(Xe), qe.debugOverlayTexture.bind(it.LINEAR, it.CLAMP_TO_EDGE);
+              }(ue, `${Re} ${Ir}kB`), Oe.draw(Q, ee.TRIANGLES, Ze, st, qs.alphaBlended, Pa.disabled, po(le, a.aM.transparent, be), null, Yt, ue.debugBuffer, ue.quadTriangleIndexBuffer, ue.debugSegments), Oe.draw(Q, ee.LINE_STRIP, Ze, st, Tt, Pa.disabled, po(le, a.aM.red), Kt, Yt, ue.debugBuffer, ue.tileBorderIndexBuffer, ue.debugSegments);
+            }
+            function js(ue, w, B) {
+              let Q = ue.context, ee = Q.gl, le = ue.colorModeForRenderPass(), Oe = new Po(ee.LEQUAL, Po.ReadWrite, ue.depthRangeFor3D), Ze = ue.useProgram("terrain"), st = w.getTerrainMesh();
+              Q.bindFramebuffer.set(null), Q.viewport.set([0, 0, ue.width, ue.height]);
+              for (let Tt of B) {
+                let Yt = ue.renderToTexture.getTexture(Tt), Kt = w.getTerrainData(Tt.tileID);
+                Q.activeTexture.set(ee.TEXTURE0), ee.bindTexture(ee.TEXTURE_2D, Yt.texture);
+                let xr = ue.transform.calculatePosMatrix(Tt.tileID.toUnwrapped()), Ir = w.getMeshFrameDelta(ue.transform.zoom), ve = ue.transform.calculateFogMatrix(Tt.tileID.toUnwrapped()), be = Jr(xr, Ir, ve, ue.style.sky, ue.transform.pitch);
+                Ze.draw(Q, ee.TRIANGLES, Oe, Ko.disabled, le, Pa.backCCW, be, Kt, "terrain", st.vertexBuffer, st.indexBuffer, st.segments);
+              }
+            }
+            class Eu {
+              constructor(w, B, Q) {
+                this.vertexBuffer = w, this.indexBuffer = B, this.segments = Q;
+              }
+              destroy() {
+                this.vertexBuffer.destroy(), this.indexBuffer.destroy(), this.segments.destroy(), this.vertexBuffer = null, this.indexBuffer = null, this.segments = null;
+              }
+            }
+            class Dc {
+              constructor(w, B) {
+                this.context = new od(w), this.transform = B, this._tileTextures = {}, this.terrainFacilitator = { dirty: true, matrix: a.an(new Float64Array(16)), renderTime: 0 }, this.setup(), this.numSublayers = mt.maxUnderzooming + mt.maxOverzooming + 1, this.depthEpsilon = 1 / Math.pow(2, 16), this.crossTileSymbolIndex = new Xo();
+              }
+              resize(w, B, Q) {
+                if (this.width = Math.floor(w * Q), this.height = Math.floor(B * Q), this.pixelRatio = Q, this.context.viewport.set([0, 0, this.width, this.height]), this.style) for (let ee of this.style._order) this.style._layers[ee].resize();
+              }
+              setup() {
+                let w = this.context, B = new a.aX();
+                B.emplaceBack(0, 0), B.emplaceBack(a.X, 0), B.emplaceBack(0, a.X), B.emplaceBack(a.X, a.X), this.tileExtentBuffer = w.createVertexBuffer(B, vo.members), this.tileExtentSegments = a.a0.simpleSegment(0, 0, 4, 2);
+                let Q = new a.aX();
+                Q.emplaceBack(0, 0), Q.emplaceBack(a.X, 0), Q.emplaceBack(0, a.X), Q.emplaceBack(a.X, a.X), this.debugBuffer = w.createVertexBuffer(Q, vo.members), this.debugSegments = a.a0.simpleSegment(0, 0, 4, 5);
+                let ee = new a.$();
+                ee.emplaceBack(0, 0, 0, 0), ee.emplaceBack(a.X, 0, a.X, 0), ee.emplaceBack(0, a.X, 0, a.X), ee.emplaceBack(a.X, a.X, a.X, a.X), this.rasterBoundsBuffer = w.createVertexBuffer(ee, ut.members), this.rasterBoundsSegments = a.a0.simpleSegment(0, 0, 4, 2);
+                let le = new a.aX();
+                le.emplaceBack(0, 0), le.emplaceBack(1, 0), le.emplaceBack(0, 1), le.emplaceBack(1, 1), this.viewportBuffer = w.createVertexBuffer(le, vo.members), this.viewportSegments = a.a0.simpleSegment(0, 0, 4, 2);
+                let Oe = new a.aZ();
+                Oe.emplaceBack(0), Oe.emplaceBack(1), Oe.emplaceBack(3), Oe.emplaceBack(2), Oe.emplaceBack(0), this.tileBorderIndexBuffer = w.createIndexBuffer(Oe);
+                let Ze = new a.aY();
+                Ze.emplaceBack(0, 1, 2), Ze.emplaceBack(2, 1, 3), this.quadTriangleIndexBuffer = w.createIndexBuffer(Ze);
+                let st = this.context.gl;
+                this.stencilClearMode = new Ko({ func: st.ALWAYS, mask: 0 }, 0, 255, st.ZERO, st.ZERO, st.ZERO);
+              }
+              clearStencil() {
+                let w = this.context, B = w.gl;
+                this.nextStencilID = 1, this.currentStencilSource = void 0;
+                let Q = a.H();
+                a.aP(Q, 0, this.width, this.height, 0, 0, 1), a.K(Q, Q, [B.drawingBufferWidth, B.drawingBufferHeight, 0]), this.useProgram("clippingMask").draw(w, B.TRIANGLES, Po.disabled, this.stencilClearMode, qs.disabled, Pa.disabled, Lo(Q), null, "$clipping", this.viewportBuffer, this.quadTriangleIndexBuffer, this.viewportSegments);
+              }
+              _renderTileClippingMasks(w, B) {
+                if (this.currentStencilSource === w.source || !w.isTileClipped() || !B || !B.length) return;
+                this.currentStencilSource = w.source;
+                let Q = this.context, ee = Q.gl;
+                this.nextStencilID + B.length > 256 && this.clearStencil(), Q.setColorMode(qs.disabled), Q.setDepthMode(Po.disabled);
+                let le = this.useProgram("clippingMask");
+                this._tileClippingMaskIDs = {};
+                for (let Oe of B) {
+                  let Ze = this._tileClippingMaskIDs[Oe.key] = this.nextStencilID++, st = this.style.map.terrain && this.style.map.terrain.getTerrainData(Oe);
+                  le.draw(Q, ee.TRIANGLES, Po.disabled, new Ko({ func: ee.ALWAYS, mask: 0 }, Ze, 255, ee.KEEP, ee.KEEP, ee.REPLACE), qs.disabled, Pa.disabled, Lo(Oe.posMatrix), st, "$clipping", this.tileExtentBuffer, this.quadTriangleIndexBuffer, this.tileExtentSegments);
+                }
+              }
+              stencilModeFor3D() {
+                this.currentStencilSource = void 0, this.nextStencilID + 1 > 256 && this.clearStencil();
+                let w = this.nextStencilID++, B = this.context.gl;
+                return new Ko({ func: B.NOTEQUAL, mask: 255 }, w, 255, B.KEEP, B.KEEP, B.REPLACE);
+              }
+              stencilModeForClipping(w) {
+                let B = this.context.gl;
+                return new Ko({ func: B.EQUAL, mask: 255 }, this._tileClippingMaskIDs[w.key], 0, B.KEEP, B.KEEP, B.REPLACE);
+              }
+              stencilConfigForOverlap(w) {
+                let B = this.context.gl, Q = w.sort((Oe, Ze) => Ze.overscaledZ - Oe.overscaledZ), ee = Q[Q.length - 1].overscaledZ, le = Q[0].overscaledZ - ee + 1;
+                if (le > 1) {
+                  this.currentStencilSource = void 0, this.nextStencilID + le > 256 && this.clearStencil();
+                  let Oe = {};
+                  for (let Ze = 0; Ze < le; Ze++) Oe[Ze + ee] = new Ko({ func: B.GEQUAL, mask: 255 }, Ze + this.nextStencilID, 255, B.KEEP, B.KEEP, B.REPLACE);
+                  return this.nextStencilID += le, [Oe, Q];
+                }
+                return [{ [ee]: Ko.disabled }, Q];
+              }
+              colorModeForRenderPass() {
+                let w = this.context.gl;
+                return this._showOverdrawInspector ? new qs([w.CONSTANT_COLOR, w.ONE], new a.aM(0.125, 0.125, 0.125, 0), [true, true, true, true]) : this.renderPass === "opaque" ? qs.unblended : qs.alphaBlended;
+              }
+              depthModeForSublayer(w, B, Q) {
+                if (!this.opaquePassEnabledForLayer()) return Po.disabled;
+                let ee = 1 - ((1 + this.currentLayer) * this.numSublayers + w) * this.depthEpsilon;
+                return new Po(Q || this.context.gl.LEQUAL, B, [ee, ee]);
+              }
+              opaquePassEnabledForLayer() {
+                return this.currentLayer < this.opaquePassCutoff;
+              }
+              render(w, B) {
+                this.style = w, this.options = B, this.lineAtlas = w.lineAtlas, this.imageManager = w.imageManager, this.glyphManager = w.glyphManager, this.symbolFadeChange = w.placement.symbolFadeChange(u.now()), this.imageManager.beginFrame();
+                let Q = this.style._order, ee = this.style.sourceCaches, le = {}, Oe = {}, Ze = {};
+                for (let st in ee) {
+                  let Tt = ee[st];
+                  Tt.used && Tt.prepare(this.context), le[st] = Tt.getVisibleCoordinates(), Oe[st] = le[st].slice().reverse(), Ze[st] = Tt.getVisibleCoordinates(true).reverse();
+                }
+                this.opaquePassCutoff = 1 / 0;
+                for (let st = 0; st < Q.length; st++) if (this.style._layers[Q[st]].is3D()) {
+                  this.opaquePassCutoff = st;
+                  break;
+                }
+                this.maybeDrawDepthAndCoords(false), this.renderToTexture && (this.renderToTexture.prepareForRender(this.style, this.transform.zoom), this.opaquePassCutoff = 0), this.renderPass = "offscreen";
+                for (let st of Q) {
+                  let Tt = this.style._layers[st];
+                  if (!Tt.hasOffscreenPass() || Tt.isHidden(this.transform.zoom)) continue;
+                  let Yt = Oe[Tt.source];
+                  (Tt.type === "custom" || Yt.length) && this.renderLayer(this, ee[Tt.source], Tt, Yt);
+                }
+                if (this.context.bindFramebuffer.set(null), this.context.clear({ color: B.showOverdrawInspector ? a.aM.black : a.aM.transparent, depth: 1 }), this.clearStencil(), this.style.sky && function(st, Tt) {
+                  let Yt = st.context, Kt = Yt.gl, xr = ((qe, et, Xe) => ({ u_sky_color: qe.properties.get("sky-color"), u_horizon_color: qe.properties.get("horizon-color"), u_horizon: (et.height / 2 + et.getHorizon()) * Xe, u_sky_horizon_blend: qe.properties.get("sky-horizon-blend") * et.height / 2 * Xe }))(Tt, st.style.map.transform, st.pixelRatio), Ir = new Po(Kt.LEQUAL, Po.ReadWrite, [0, 1]), ve = Ko.disabled, be = st.colorModeForRenderPass(), Re = st.useProgram("sky");
+                  if (!Tt.mesh) {
+                    let qe = new a.aX();
+                    qe.emplaceBack(-1, -1), qe.emplaceBack(1, -1), qe.emplaceBack(1, 1), qe.emplaceBack(-1, 1);
+                    let et = new a.aY();
+                    et.emplaceBack(0, 1, 2), et.emplaceBack(0, 2, 3), Tt.mesh = new Eu(Yt.createVertexBuffer(qe, vo.members), Yt.createIndexBuffer(et), a.a0.simpleSegment(0, 0, qe.length, et.length));
+                  }
+                  Re.draw(Yt, Kt.TRIANGLES, Ir, ve, be, Pa.disabled, xr, void 0, "sky", Tt.mesh.vertexBuffer, Tt.mesh.indexBuffer, Tt.mesh.segments);
+                }(this, this.style.sky), this._showOverdrawInspector = B.showOverdrawInspector, this.depthRangeFor3D = [0, 1 - (w._order.length + 2) * this.numSublayers * this.depthEpsilon], !this.renderToTexture) for (this.renderPass = "opaque", this.currentLayer = Q.length - 1; this.currentLayer >= 0; this.currentLayer--) {
+                  let st = this.style._layers[Q[this.currentLayer]], Tt = ee[st.source], Yt = le[st.source];
+                  this._renderTileClippingMasks(st, Yt), this.renderLayer(this, Tt, st, Yt);
+                }
+                for (this.renderPass = "translucent", this.currentLayer = 0; this.currentLayer < Q.length; this.currentLayer++) {
+                  let st = this.style._layers[Q[this.currentLayer]], Tt = ee[st.source];
+                  if (this.renderToTexture && this.renderToTexture.renderLayer(st)) continue;
+                  let Yt = (st.type === "symbol" ? Ze : Oe)[st.source];
+                  this._renderTileClippingMasks(st, le[st.source]), this.renderLayer(this, Tt, st, Yt);
+                }
+                if (this.options.showTileBoundaries) {
+                  let st = function(Tt, Yt) {
+                    let Kt = null, xr = Object.values(Tt._layers).flatMap((Re) => Re.source && !Re.isHidden(Yt) ? [Tt.sourceCaches[Re.source]] : []), Ir = xr.filter((Re) => Re.getSource().type === "vector"), ve = xr.filter((Re) => Re.getSource().type !== "vector"), be = (Re) => {
+                      (!Kt || Kt.getSource().maxzoom < Re.getSource().maxzoom) && (Kt = Re);
+                    };
+                    return Ir.forEach((Re) => be(Re)), Kt || ve.forEach((Re) => be(Re)), Kt;
+                  }(this.style, this.transform.zoom);
+                  st && function(Tt, Yt, Kt) {
+                    for (let xr = 0; xr < Kt.length; xr++) ih(Tt, Yt, Kt[xr]);
+                  }(this, st, st.getVisibleCoordinates());
+                }
+                this.options.showPadding && function(st) {
+                  let Tt = st.transform.padding;
+                  sf(st, st.transform.height - (Tt.top || 0), 3, Rc), sf(st, Tt.bottom || 0, 3, gs), Sh(st, Tt.left || 0, 3, Wf), Sh(st, st.transform.width - (Tt.right || 0), 3, Wh);
+                  let Yt = st.transform.centerPoint;
+                  (function(Kt, xr, Ir, ve) {
+                    Mu(Kt, xr - 1, Ir - 10, 2, 20, ve), Mu(Kt, xr - 10, Ir - 1, 20, 2, ve);
+                  })(st, Yt.x, st.transform.height - Yt.y, rh);
+                }(this), this.context.setDefault();
+              }
+              maybeDrawDepthAndCoords(w) {
+                if (!this.style || !this.style.map || !this.style.map.terrain) return;
+                let B = this.terrainFacilitator.matrix, Q = this.transform.modelViewProjectionMatrix, ee = this.terrainFacilitator.dirty;
+                ee || (ee = w ? !a.a_(B, Q) : !a.a$(B, Q)), ee || (ee = this.style.map.terrain.sourceCache.tilesAfterTime(this.terrainFacilitator.renderTime).length > 0), ee && (a.b0(B, Q), this.terrainFacilitator.renderTime = Date.now(), this.terrainFacilitator.dirty = false, function(le, Oe) {
+                  let Ze = le.context, st = Ze.gl, Tt = qs.unblended, Yt = new Po(st.LEQUAL, Po.ReadWrite, [0, 1]), Kt = Oe.getTerrainMesh(), xr = Oe.sourceCache.getRenderableTiles(), Ir = le.useProgram("terrainDepth");
+                  Ze.bindFramebuffer.set(Oe.getFramebuffer("depth").framebuffer), Ze.viewport.set([0, 0, le.width / devicePixelRatio, le.height / devicePixelRatio]), Ze.clear({ color: a.aM.transparent, depth: 1 });
+                  for (let ve of xr) {
+                    let be = Oe.getTerrainData(ve.tileID), Re = { u_matrix: le.transform.calculatePosMatrix(ve.tileID.toUnwrapped()), u_ele_delta: Oe.getMeshFrameDelta(le.transform.zoom) };
+                    Ir.draw(Ze, st.TRIANGLES, Yt, Ko.disabled, Tt, Pa.backCCW, Re, be, "terrain", Kt.vertexBuffer, Kt.indexBuffer, Kt.segments);
+                  }
+                  Ze.bindFramebuffer.set(null), Ze.viewport.set([0, 0, le.width, le.height]);
+                }(this, this.style.map.terrain), function(le, Oe) {
+                  let Ze = le.context, st = Ze.gl, Tt = qs.unblended, Yt = new Po(st.LEQUAL, Po.ReadWrite, [0, 1]), Kt = Oe.getTerrainMesh(), xr = Oe.getCoordsTexture(), Ir = Oe.sourceCache.getRenderableTiles(), ve = le.useProgram("terrainCoords");
+                  Ze.bindFramebuffer.set(Oe.getFramebuffer("coords").framebuffer), Ze.viewport.set([0, 0, le.width / devicePixelRatio, le.height / devicePixelRatio]), Ze.clear({ color: a.aM.transparent, depth: 1 }), Oe.coordsIndex = [];
+                  for (let be of Ir) {
+                    let Re = Oe.getTerrainData(be.tileID);
+                    Ze.activeTexture.set(st.TEXTURE0), st.bindTexture(st.TEXTURE_2D, xr.texture);
+                    let qe = { u_matrix: le.transform.calculatePosMatrix(be.tileID.toUnwrapped()), u_terrain_coords_id: (255 - Oe.coordsIndex.length) / 255, u_texture: 0, u_ele_delta: Oe.getMeshFrameDelta(le.transform.zoom) };
+                    ve.draw(Ze, st.TRIANGLES, Yt, Ko.disabled, Tt, Pa.backCCW, qe, Re, "terrain", Kt.vertexBuffer, Kt.indexBuffer, Kt.segments), Oe.coordsIndex.push(be.tileID.key);
+                  }
+                  Ze.bindFramebuffer.set(null), Ze.viewport.set([0, 0, le.width, le.height]);
+                }(this, this.style.map.terrain));
+              }
+              renderLayer(w, B, Q, ee) {
+                if (!Q.isHidden(this.transform.zoom) && (Q.type === "background" || Q.type === "custom" || (ee || []).length)) switch (this.id = Q.id, Q.type) {
+                  case "symbol":
+                    (function(le, Oe, Ze, st, Tt) {
+                      if (le.renderPass !== "translucent") return;
+                      let Yt = Ko.disabled, Kt = le.colorModeForRenderPass();
+                      (Ze._unevaluatedLayout.hasValue("text-variable-anchor") || Ze._unevaluatedLayout.hasValue("text-variable-anchor-offset")) && function(xr, Ir, ve, be, Re, qe, et, Xe, it) {
+                        let Ft = Ir.transform, Ht = yn(), tr = Re === "map", dr = qe === "map";
+                        for (let Sr of xr) {
+                          let Or = be.getTile(Sr), Wr = Or.getBucket(ve);
+                          if (!Wr || !Wr.text || !Wr.text.segments.get().length) continue;
+                          let ni = a.ag(Wr.textSizeData, Ft.zoom), Pi = In(Or, 1, Ir.transform.zoom), cn = Br(Sr.posMatrix, dr, tr, Ir.transform, Pi), ln = ve.layout.get("icon-text-fit") !== "none" && Wr.hasIconData();
+                          if (ni) {
+                            let Cn = Math.pow(2, Ft.zoom - Or.tileID.overscaledZ), Kn = Ir.style.map.terrain ? (fa, $a) => Ir.style.map.terrain.getElevation(Sr, fa, $a) : null, Aa = Ht.translatePosition(Ft, Or, et, Xe);
+                            yf(Wr, tr, dr, it, Ft, cn, Sr.posMatrix, Cn, ni, ln, Ht, Aa, Sr.toUnwrapped(), Kn);
+                          }
+                        }
+                      }(st, le, Ze, Oe, Ze.layout.get("text-rotation-alignment"), Ze.layout.get("text-pitch-alignment"), Ze.paint.get("text-translate"), Ze.paint.get("text-translate-anchor"), Tt), Ze.paint.get("icon-opacity").constantOr(1) !== 0 && Ah(le, Oe, Ze, st, false, Ze.paint.get("icon-translate"), Ze.paint.get("icon-translate-anchor"), Ze.layout.get("icon-rotation-alignment"), Ze.layout.get("icon-pitch-alignment"), Ze.layout.get("icon-keep-upright"), Yt, Kt), Ze.paint.get("text-opacity").constantOr(1) !== 0 && Ah(le, Oe, Ze, st, true, Ze.paint.get("text-translate"), Ze.paint.get("text-translate-anchor"), Ze.layout.get("text-rotation-alignment"), Ze.layout.get("text-pitch-alignment"), Ze.layout.get("text-keep-upright"), Yt, Kt), Oe.map.showCollisionBoxes && (Hu(le, Oe, Ze, st, true), Hu(le, Oe, Ze, st, false));
+                    })(w, B, Q, ee, this.style.placement.variableOffsets);
+                    break;
+                  case "circle":
+                    (function(le, Oe, Ze, st) {
+                      if (le.renderPass !== "translucent") return;
+                      let Tt = Ze.paint.get("circle-opacity"), Yt = Ze.paint.get("circle-stroke-width"), Kt = Ze.paint.get("circle-stroke-opacity"), xr = !Ze.layout.get("circle-sort-key").isConstant();
+                      if (Tt.constantOr(1) === 0 && (Yt.constantOr(1) === 0 || Kt.constantOr(1) === 0)) return;
+                      let Ir = le.context, ve = Ir.gl, be = le.depthModeForSublayer(0, Po.ReadOnly), Re = Ko.disabled, qe = le.colorModeForRenderPass(), et = [];
+                      for (let Xe = 0; Xe < st.length; Xe++) {
+                        let it = st[Xe], Ft = Oe.getTile(it), Ht = Ft.getBucket(Ze);
+                        if (!Ht) continue;
+                        let tr = Ht.programConfigurations.get(Ze.id), dr = le.useProgram("circle", tr), Sr = Ht.layoutVertexBuffer, Or = Ht.indexBuffer, Wr = le.style.map.terrain && le.style.map.terrain.getTerrainData(it), ni = { programConfiguration: tr, program: dr, layoutVertexBuffer: Sr, indexBuffer: Or, uniformValues: _o(le, it, Ft, Ze), terrainData: Wr };
+                        if (xr) {
+                          let Pi = Ht.segments.get();
+                          for (let cn of Pi) et.push({ segments: new a.a0([cn]), sortKey: cn.sortKey, state: ni });
+                        } else et.push({ segments: Ht.segments, sortKey: 0, state: ni });
+                      }
+                      xr && et.sort((Xe, it) => Xe.sortKey - it.sortKey);
+                      for (let Xe of et) {
+                        let { programConfiguration: it, program: Ft, layoutVertexBuffer: Ht, indexBuffer: tr, uniformValues: dr, terrainData: Sr } = Xe.state;
+                        Ft.draw(Ir, ve.TRIANGLES, be, Re, qe, Pa.disabled, dr, Sr, Ze.id, Ht, tr, Xe.segments, Ze.paint, le.transform.zoom, it);
+                      }
+                    })(w, B, Q, ee);
+                    break;
+                  case "heatmap":
+                    (function(le, Oe, Ze, st) {
+                      if (Ze.paint.get("heatmap-opacity") === 0) return;
+                      let Tt = le.context;
+                      if (le.style.map.terrain) {
+                        for (let Yt of st) {
+                          let Kt = Oe.getTile(Yt);
+                          Oe.hasRenderableParent(Yt) || (le.renderPass === "offscreen" ? _f(le, Kt, Ze, Yt) : le.renderPass === "translucent" && Yc(le, Ze, Yt));
+                        }
+                        Tt.viewport.set([0, 0, le.width, le.height]);
+                      } else le.renderPass === "offscreen" ? function(Yt, Kt, xr, Ir) {
+                        let ve = Yt.context, be = ve.gl, Re = Ko.disabled, qe = new qs([be.ONE, be.ONE], a.aM.transparent, [true, true, true, true]);
+                        (function(et, Xe, it) {
+                          let Ft = et.gl;
+                          et.activeTexture.set(Ft.TEXTURE1), et.viewport.set([0, 0, Xe.width / 4, Xe.height / 4]);
+                          let Ht = it.heatmapFbos.get(a.aU);
+                          Ht ? (Ft.bindTexture(Ft.TEXTURE_2D, Ht.colorAttachment.get()), et.bindFramebuffer.set(Ht.framebuffer)) : (Ht = eh(et, Xe.width / 4, Xe.height / 4), it.heatmapFbos.set(a.aU, Ht));
+                        })(ve, Yt, xr), ve.clear({ color: a.aM.transparent });
+                        for (let et = 0; et < Ir.length; et++) {
+                          let Xe = Ir[et];
+                          if (Kt.hasRenderableParent(Xe)) continue;
+                          let it = Kt.getTile(Xe), Ft = it.getBucket(xr);
+                          if (!Ft) continue;
+                          let Ht = Ft.programConfigurations.get(xr.id), tr = Yt.useProgram("heatmap", Ht), { zoom: dr } = Yt.transform;
+                          tr.draw(ve, be.TRIANGLES, Po.disabled, Re, qe, Pa.disabled, ko(Xe.posMatrix, it, dr, xr.paint.get("heatmap-intensity")), null, xr.id, Ft.layoutVertexBuffer, Ft.indexBuffer, Ft.segments, xr.paint, Yt.transform.zoom, Ht);
+                        }
+                        ve.viewport.set([0, 0, Yt.width, Yt.height]);
+                      }(le, Oe, Ze, st) : le.renderPass === "translucent" && function(Yt, Kt) {
+                        let xr = Yt.context, Ir = xr.gl;
+                        xr.setColorMode(Yt.colorModeForRenderPass());
+                        let ve = Kt.heatmapFbos.get(a.aU);
+                        ve && (xr.activeTexture.set(Ir.TEXTURE0), Ir.bindTexture(Ir.TEXTURE_2D, ve.colorAttachment.get()), xr.activeTexture.set(Ir.TEXTURE1), th(xr, Kt).bind(Ir.LINEAR, Ir.CLAMP_TO_EDGE), Yt.useProgram("heatmapTexture").draw(xr, Ir.TRIANGLES, Po.disabled, Ko.disabled, Yt.colorModeForRenderPass(), Pa.disabled, Ds(Yt, Kt, 0, 1), null, Kt.id, Yt.viewportBuffer, Yt.quadTriangleIndexBuffer, Yt.viewportSegments, Kt.paint, Yt.transform.zoom));
+                      }(le, Ze);
+                    })(w, B, Q, ee);
+                    break;
+                  case "line":
+                    (function(le, Oe, Ze, st) {
+                      if (le.renderPass !== "translucent") return;
+                      let Tt = Ze.paint.get("line-opacity"), Yt = Ze.paint.get("line-width");
+                      if (Tt.constantOr(1) === 0 || Yt.constantOr(1) === 0) return;
+                      let Kt = le.depthModeForSublayer(0, Po.ReadOnly), xr = le.colorModeForRenderPass(), Ir = Ze.paint.get("line-dasharray"), ve = Ze.paint.get("line-pattern"), be = ve.constantOr(1), Re = Ze.paint.get("line-gradient"), qe = Ze.getCrossfadeParameters(), et = be ? "linePattern" : Ir ? "lineSDF" : Re ? "lineGradient" : "line", Xe = le.context, it = Xe.gl, Ft = true;
+                      for (let Ht of st) {
+                        let tr = Oe.getTile(Ht);
+                        if (be && !tr.patternsLoaded()) continue;
+                        let dr = tr.getBucket(Ze);
+                        if (!dr) continue;
+                        let Sr = dr.programConfigurations.get(Ze.id), Or = le.context.program.get(), Wr = le.useProgram(et, Sr), ni = Ft || Wr.program !== Or, Pi = le.style.map.terrain && le.style.map.terrain.getTerrainData(Ht), cn = ve.constantOr(null);
+                        if (cn && tr.imageAtlas) {
+                          let Kn = tr.imageAtlas, Aa = Kn.patternPositions[cn.to.toString()], fa = Kn.patternPositions[cn.from.toString()];
+                          Aa && fa && Sr.setConstantPatternPositions(Aa, fa);
+                        }
+                        let ln = Pi ? Ht : null, Cn = be ? zl(le, tr, Ze, qe, ln) : Ir ? us(le, tr, Ze, Ir, qe, ln) : Re ? ul(le, tr, Ze, dr.lineClipsArray.length, ln) : ll(le, tr, Ze, ln);
+                        if (be) Xe.activeTexture.set(it.TEXTURE0), tr.imageAtlasTexture.bind(it.LINEAR, it.CLAMP_TO_EDGE), Sr.updatePaintBuffers(qe);
+                        else if (Ir && (ni || le.lineAtlas.dirty)) Xe.activeTexture.set(it.TEXTURE0), le.lineAtlas.bind(Xe);
+                        else if (Re) {
+                          let Kn = dr.gradients[Ze.id], Aa = Kn.texture;
+                          if (Ze.gradientVersion !== Kn.version) {
+                            let fa = 256;
+                            if (Ze.stepInterpolant) {
+                              let $a = Oe.getSource().maxzoom, Co = Ht.canonical.z === $a ? Math.ceil(1 << le.transform.maxZoom - Ht.canonical.z) : 1;
+                              fa = a.ac(a.aV(dr.maxLineLength / a.X * 1024 * Co), 256, Xe.maxTextureSize);
+                            }
+                            Kn.gradient = a.aW({ expression: Ze.gradientExpression(), evaluationKey: "lineProgress", resolution: fa, image: Kn.gradient || void 0, clips: dr.lineClipsArray }), Kn.texture ? Kn.texture.update(Kn.gradient) : Kn.texture = new g(Xe, Kn.gradient, it.RGBA), Kn.version = Ze.gradientVersion, Aa = Kn.texture;
+                          }
+                          Xe.activeTexture.set(it.TEXTURE0), Aa.bind(Ze.stepInterpolant ? it.NEAREST : it.LINEAR, it.CLAMP_TO_EDGE);
+                        }
+                        Wr.draw(Xe, it.TRIANGLES, Kt, le.stencilModeForClipping(Ht), xr, Pa.disabled, Cn, Pi, Ze.id, dr.layoutVertexBuffer, dr.indexBuffer, dr.segments, Ze.paint, le.transform.zoom, Sr, dr.layoutVertexBuffer2), Ft = false;
+                      }
+                    })(w, B, Q, ee);
+                    break;
+                  case "fill":
+                    (function(le, Oe, Ze, st) {
+                      let Tt = Ze.paint.get("fill-color"), Yt = Ze.paint.get("fill-opacity");
+                      if (Yt.constantOr(1) === 0) return;
+                      let Kt = le.colorModeForRenderPass(), xr = Ze.paint.get("fill-pattern"), Ir = le.opaquePassEnabledForLayer() && !xr.constantOr(1) && Tt.constantOr(a.aM.transparent).a === 1 && Yt.constantOr(0) === 1 ? "opaque" : "translucent";
+                      if (le.renderPass === Ir) {
+                        let ve = le.depthModeForSublayer(1, le.renderPass === "opaque" ? Po.ReadWrite : Po.ReadOnly);
+                        jf(le, Oe, Ze, st, ve, Kt, false);
+                      }
+                      if (le.renderPass === "translucent" && Ze.paint.get("fill-antialias")) {
+                        let ve = le.depthModeForSublayer(Ze.getPaintProperty("fill-outline-color") ? 2 : 0, Po.ReadOnly);
+                        jf(le, Oe, Ze, st, ve, Kt, true);
+                      }
+                    })(w, B, Q, ee);
+                    break;
+                  case "fill-extrusion":
+                    (function(le, Oe, Ze, st) {
+                      let Tt = Ze.paint.get("fill-extrusion-opacity");
+                      if (Tt !== 0 && le.renderPass === "translucent") {
+                        let Yt = new Po(le.context.gl.LEQUAL, Po.ReadWrite, le.depthRangeFor3D);
+                        if (Tt !== 1 || Ze.paint.get("fill-extrusion-pattern").constantOr(1)) cc(le, Oe, Ze, st, Yt, Ko.disabled, qs.disabled), cc(le, Oe, Ze, st, Yt, le.stencilModeFor3D(), le.colorModeForRenderPass());
+                        else {
+                          let Kt = le.colorModeForRenderPass();
+                          cc(le, Oe, Ze, st, Yt, Ko.disabled, Kt);
+                        }
+                      }
+                    })(w, B, Q, ee);
+                    break;
+                  case "hillshade":
+                    (function(le, Oe, Ze, st) {
+                      if (le.renderPass !== "offscreen" && le.renderPass !== "translucent") return;
+                      let Tt = le.context, Yt = le.depthModeForSublayer(0, Po.ReadOnly), Kt = le.colorModeForRenderPass(), [xr, Ir] = le.renderPass === "translucent" ? le.stencilConfigForOverlap(st) : [{}, st];
+                      for (let ve of Ir) {
+                        let be = Oe.getTile(ve);
+                        be.needsHillshadePrepare !== void 0 && be.needsHillshadePrepare && le.renderPass === "offscreen" ? Nl(le, be, Ze, Yt, Ko.disabled, Kt) : le.renderPass === "translucent" && of(le, ve, be, Ze, Yt, xr[ve.overscaledZ], Kt);
+                      }
+                      Tt.viewport.set([0, 0, le.width, le.height]);
+                    })(w, B, Q, ee);
+                    break;
+                  case "raster":
+                    (function(le, Oe, Ze, st) {
+                      if (le.renderPass !== "translucent" || Ze.paint.get("raster-opacity") === 0 || !st.length) return;
+                      let Tt = le.context, Yt = Tt.gl, Kt = Oe.getSource(), xr = le.useProgram("raster"), Ir = le.colorModeForRenderPass(), [ve, be] = Kt instanceof Wt ? [{}, st] : le.stencilConfigForOverlap(st), Re = be[be.length - 1].overscaledZ, qe = !le.options.moving;
+                      for (let et of be) {
+                        let Xe = le.depthModeForSublayer(et.overscaledZ - Re, Ze.paint.get("raster-opacity") === 1 ? Po.ReadWrite : Po.ReadOnly, Yt.LESS), it = Oe.getTile(et);
+                        it.registerFadeDuration(Ze.paint.get("raster-fade-duration"));
+                        let Ft = Oe.findLoadedParent(et, 0), Ht = Oe.findLoadedSibling(et), tr = Kc(it, Ft || Ht || null, Oe, Ze, le.transform, le.style.map.terrain), dr, Sr, Or = Ze.paint.get("raster-resampling") === "nearest" ? Yt.NEAREST : Yt.LINEAR;
+                        Tt.activeTexture.set(Yt.TEXTURE0), it.texture.bind(Or, Yt.CLAMP_TO_EDGE, Yt.LINEAR_MIPMAP_NEAREST), Tt.activeTexture.set(Yt.TEXTURE1), Ft ? (Ft.texture.bind(Or, Yt.CLAMP_TO_EDGE, Yt.LINEAR_MIPMAP_NEAREST), dr = Math.pow(2, Ft.tileID.overscaledZ - it.tileID.overscaledZ), Sr = [it.tileID.canonical.x * dr % 1, it.tileID.canonical.y * dr % 1]) : it.texture.bind(Or, Yt.CLAMP_TO_EDGE, Yt.LINEAR_MIPMAP_NEAREST), it.texture.useMipmap && Tt.extTextureFilterAnisotropic && le.transform.pitch > 20 && Yt.texParameterf(Yt.TEXTURE_2D, Tt.extTextureFilterAnisotropic.TEXTURE_MAX_ANISOTROPY_EXT, Tt.extTextureFilterAnisotropicMax);
+                        let Wr = le.style.map.terrain && le.style.map.terrain.getTerrainData(et), ni = Wr ? et : null, Pi = ni ? ni.posMatrix : le.transform.calculatePosMatrix(et.toUnwrapped(), qe), cn = cl(Pi, Sr || [0, 0], dr || 1, tr, Ze);
+                        Kt instanceof Wt ? xr.draw(Tt, Yt.TRIANGLES, Xe, Ko.disabled, Ir, Pa.disabled, cn, Wr, Ze.id, Kt.boundsBuffer, le.quadTriangleIndexBuffer, Kt.boundsSegments) : xr.draw(Tt, Yt.TRIANGLES, Xe, ve[et.overscaledZ], Ir, Pa.disabled, cn, Wr, Ze.id, le.rasterBoundsBuffer, le.quadTriangleIndexBuffer, le.rasterBoundsSegments);
+                      }
+                    })(w, B, Q, ee);
+                    break;
+                  case "background":
+                    (function(le, Oe, Ze, st) {
+                      let Tt = Ze.paint.get("background-color"), Yt = Ze.paint.get("background-opacity");
+                      if (Yt === 0) return;
+                      let Kt = le.context, xr = Kt.gl, Ir = le.transform, ve = Ir.tileSize, be = Ze.paint.get("background-pattern");
+                      if (le.isPatternMissing(be)) return;
+                      let Re = !be && Tt.a === 1 && Yt === 1 && le.opaquePassEnabledForLayer() ? "opaque" : "translucent";
+                      if (le.renderPass !== Re) return;
+                      let qe = Ko.disabled, et = le.depthModeForSublayer(0, Re === "opaque" ? Po.ReadWrite : Po.ReadOnly), Xe = le.colorModeForRenderPass(), it = le.useProgram(be ? "backgroundPattern" : "background"), Ft = st || Ir.coveringTiles({ tileSize: ve, terrain: le.style.map.terrain });
+                      be && (Kt.activeTexture.set(xr.TEXTURE0), le.imageManager.bind(le.context));
+                      let Ht = Ze.getCrossfadeParameters();
+                      for (let tr of Ft) {
+                        let dr = st ? tr.posMatrix : le.transform.calculatePosMatrix(tr.toUnwrapped()), Sr = be ? Su(dr, Yt, le, be, { tileID: tr, tileSize: ve }, Ht) : Yl(dr, Yt, Tt), Or = le.style.map.terrain && le.style.map.terrain.getTerrainData(tr);
+                        it.draw(Kt, xr.TRIANGLES, et, qe, Xe, Pa.disabled, Sr, Or, Ze.id, le.tileExtentBuffer, le.quadTriangleIndexBuffer, le.tileExtentSegments);
+                      }
+                    })(w, 0, Q, ee);
+                    break;
+                  case "custom":
+                    (function(le, Oe, Ze) {
+                      let st = le.context, Tt = Ze.implementation;
+                      if (le.renderPass === "offscreen") {
+                        let Yt = Tt.prerender;
+                        Yt && (le.setCustomLayerDefaults(), st.setColorMode(le.colorModeForRenderPass()), Yt.call(Tt, st.gl, le.transform.customLayerMatrix()), st.setDirty(), le.setBaseState());
+                      } else if (le.renderPass === "translucent") {
+                        le.setCustomLayerDefaults(), st.setColorMode(le.colorModeForRenderPass()), st.setStencilMode(Ko.disabled);
+                        let Yt = Tt.renderingMode === "3d" ? new Po(le.context.gl.LEQUAL, Po.ReadWrite, le.depthRangeFor3D) : le.depthModeForSublayer(0, Po.ReadOnly);
+                        st.setDepthMode(Yt), Tt.render(st.gl, le.transform.customLayerMatrix(), { farZ: le.transform.farZ, nearZ: le.transform.nearZ, fov: le.transform._fov, modelViewProjectionMatrix: le.transform.modelViewProjectionMatrix, projectionMatrix: le.transform.projectionMatrix }), st.setDirty(), le.setBaseState(), st.bindFramebuffer.set(null);
+                      }
+                    })(w, 0, Q);
+                }
+              }
+              translatePosMatrix(w, B, Q, ee, le) {
+                if (!Q[0] && !Q[1]) return w;
+                let Oe = le ? ee === "map" ? this.transform.angle : 0 : ee === "viewport" ? -this.transform.angle : 0;
+                if (Oe) {
+                  let Tt = Math.sin(Oe), Yt = Math.cos(Oe);
+                  Q = [Q[0] * Yt - Q[1] * Tt, Q[0] * Tt + Q[1] * Yt];
+                }
+                let Ze = [le ? Q[0] : In(B, Q[0], this.transform.zoom), le ? Q[1] : In(B, Q[1], this.transform.zoom), 0], st = new Float32Array(16);
+                return a.J(st, w, Ze), st;
+              }
+              saveTileTexture(w) {
+                let B = this._tileTextures[w.size[0]];
+                B ? B.push(w) : this._tileTextures[w.size[0]] = [w];
+              }
+              getTileTexture(w) {
+                let B = this._tileTextures[w];
+                return B && B.length > 0 ? B.pop() : null;
+              }
+              isPatternMissing(w) {
+                if (!w) return false;
+                if (!w.from || !w.to) return true;
+                let B = this.imageManager.getPattern(w.from.toString()), Q = this.imageManager.getPattern(w.to.toString());
+                return !B || !Q;
+              }
+              useProgram(w, B) {
+                this.cache = this.cache || {};
+                let Q = w + (B ? B.cacheKey : "") + (this._showOverdrawInspector ? "/overdraw" : "") + (this.style.map.terrain ? "/terrain" : "");
+                return this.cache[Q] || (this.cache[Q] = new hn(this.context, jn[w], B, nc[w], this._showOverdrawInspector, this.style.map.terrain)), this.cache[Q];
+              }
+              setCustomLayerDefaults() {
+                this.context.unbindVAO(), this.context.cullFace.setDefault(), this.context.activeTexture.setDefault(), this.context.pixelStoreUnpack.setDefault(), this.context.pixelStoreUnpackPremultiplyAlpha.setDefault(), this.context.pixelStoreUnpackFlipY.setDefault();
+              }
+              setBaseState() {
+                let w = this.context.gl;
+                this.context.cullFace.set(false), this.context.viewport.set([0, 0, this.width, this.height]), this.context.blendEquation.set(w.FUNC_ADD);
+              }
+              initDebugOverlayCanvas() {
+                this.debugOverlayCanvas == null && (this.debugOverlayCanvas = document.createElement("canvas"), this.debugOverlayCanvas.width = 512, this.debugOverlayCanvas.height = 512, this.debugOverlayTexture = new g(this.context, this.debugOverlayCanvas, this.context.gl.RGBA));
+              }
+              destroy() {
+                this.debugOverlayTexture && this.debugOverlayTexture.destroy();
+              }
+              overLimit() {
+                let { drawingBufferWidth: w, drawingBufferHeight: B } = this.context.gl;
+                return this.width !== w || this.height !== B;
+              }
+            }
+            class ks {
+              constructor(w, B) {
+                this.points = w, this.planes = B;
+              }
+              static fromInvProjectionMatrix(w, B, Q) {
+                let ee = Math.pow(2, Q), le = [[-1, 1, -1, 1], [1, 1, -1, 1], [1, -1, -1, 1], [-1, -1, -1, 1], [-1, 1, 1, 1], [1, 1, 1, 1], [1, -1, 1, 1], [-1, -1, 1, 1]].map((Ze) => {
+                  let st = 1 / (Ze = a.af([], Ze, w))[3] / B * ee;
+                  return a.b1(Ze, Ze, [st, st, 1 / Ze[3], st]);
+                }), Oe = [[0, 1, 2], [6, 5, 4], [0, 3, 7], [2, 1, 5], [3, 2, 6], [0, 4, 5]].map((Ze) => {
+                  let st = function(xr, Ir) {
+                    var ve = Ir[0], be = Ir[1], Re = Ir[2], qe = ve * ve + be * be + Re * Re;
+                    return qe > 0 && (qe = 1 / Math.sqrt(qe)), xr[0] = Ir[0] * qe, xr[1] = Ir[1] * qe, xr[2] = Ir[2] * qe, xr;
+                  }([], function(xr, Ir, ve) {
+                    var be = Ir[0], Re = Ir[1], qe = Ir[2], et = ve[0], Xe = ve[1], it = ve[2];
+                    return xr[0] = Re * it - qe * Xe, xr[1] = qe * et - be * it, xr[2] = be * Xe - Re * et, xr;
+                  }([], L([], le[Ze[0]], le[Ze[1]]), L([], le[Ze[2]], le[Ze[1]]))), Tt = -((Yt = st)[0] * (Kt = le[Ze[1]])[0] + Yt[1] * Kt[1] + Yt[2] * Kt[2]);
+                  var Yt, Kt;
+                  return st.concat(Tt);
+                });
+                return new ks(le, Oe);
+              }
+            }
+            class bc {
+              constructor(w, B) {
+                this.min = w, this.max = B, this.center = function(Q, ee, le) {
+                  return Q[0] = 0.5 * ee[0], Q[1] = 0.5 * ee[1], Q[2] = 0.5 * ee[2], Q;
+                }([], function(Q, ee, le) {
+                  return Q[0] = ee[0] + le[0], Q[1] = ee[1] + le[1], Q[2] = ee[2] + le[2], Q;
+                }([], this.min, this.max));
+              }
+              quadrant(w) {
+                let B = [w % 2 == 0, w < 2], Q = E(this.min), ee = E(this.max);
+                for (let le = 0; le < B.length; le++) Q[le] = B[le] ? this.min[le] : this.center[le], ee[le] = B[le] ? this.center[le] : this.max[le];
+                return ee[2] = this.max[2], new bc(Q, ee);
+              }
+              distanceX(w) {
+                return Math.max(Math.min(this.max[0], w[0]), this.min[0]) - w[0];
+              }
+              distanceY(w) {
+                return Math.max(Math.min(this.max[1], w[1]), this.min[1]) - w[1];
+              }
+              intersects(w) {
+                let B = [[this.min[0], this.min[1], this.min[2], 1], [this.max[0], this.min[1], this.min[2], 1], [this.max[0], this.max[1], this.min[2], 1], [this.min[0], this.max[1], this.min[2], 1], [this.min[0], this.min[1], this.max[2], 1], [this.max[0], this.min[1], this.max[2], 1], [this.max[0], this.max[1], this.max[2], 1], [this.min[0], this.max[1], this.max[2], 1]], Q = true;
+                for (let ee = 0; ee < w.planes.length; ee++) {
+                  let le = w.planes[ee], Oe = 0;
+                  for (let Ze = 0; Ze < B.length; Ze++) a.b2(le, B[Ze]) >= 0 && Oe++;
+                  if (Oe === 0) return 0;
+                  Oe !== B.length && (Q = false);
+                }
+                if (Q) return 2;
+                for (let ee = 0; ee < 3; ee++) {
+                  let le = Number.MAX_VALUE, Oe = -Number.MAX_VALUE;
+                  for (let Ze = 0; Ze < w.points.length; Ze++) {
+                    let st = w.points[Ze][ee] - this.min[ee];
+                    le = Math.min(le, st), Oe = Math.max(Oe, st);
+                  }
+                  if (Oe < 0 || le > this.max[ee] - this.min[ee]) return 0;
+                }
+                return 1;
+              }
+            }
+            class hu {
+              constructor(w = 0, B = 0, Q = 0, ee = 0) {
+                if (isNaN(w) || w < 0 || isNaN(B) || B < 0 || isNaN(Q) || Q < 0 || isNaN(ee) || ee < 0) throw new Error("Invalid value for edge-insets, top, bottom, left and right must all be numbers");
+                this.top = w, this.bottom = B, this.left = Q, this.right = ee;
+              }
+              interpolate(w, B, Q) {
+                return B.top != null && w.top != null && (this.top = a.y.number(w.top, B.top, Q)), B.bottom != null && w.bottom != null && (this.bottom = a.y.number(w.bottom, B.bottom, Q)), B.left != null && w.left != null && (this.left = a.y.number(w.left, B.left, Q)), B.right != null && w.right != null && (this.right = a.y.number(w.right, B.right, Q)), this;
+              }
+              getCenter(w, B) {
+                let Q = a.ac((this.left + w - this.right) / 2, 0, w), ee = a.ac((this.top + B - this.bottom) / 2, 0, B);
+                return new a.P(Q, ee);
+              }
+              equals(w) {
+                return this.top === w.top && this.bottom === w.bottom && this.left === w.left && this.right === w.right;
+              }
+              clone() {
+                return new hu(this.top, this.bottom, this.left, this.right);
+              }
+              toJSON() {
+                return { top: this.top, bottom: this.bottom, left: this.left, right: this.right };
+              }
+            }
+            let _u = 85.051129;
+            class nl {
+              constructor(w, B, Q, ee, le) {
+                this.tileSize = 512, this._renderWorldCopies = le === void 0 || !!le, this._minZoom = w || 0, this._maxZoom = B || 22, this._minPitch = Q == null ? 0 : Q, this._maxPitch = ee == null ? 60 : ee, this.setMaxBounds(), this.width = 0, this.height = 0, this._center = new a.N(0, 0), this._elevation = 0, this.zoom = 0, this.angle = 0, this._fov = 0.6435011087932844, this._pitch = 0, this._unmodified = true, this._edgeInsets = new hu(), this._posMatrixCache = {}, this._alignedPosMatrixCache = {}, this._fogMatrixCache = {}, this.minElevationForCurrentTile = 0;
+              }
+              clone() {
+                let w = new nl(this._minZoom, this._maxZoom, this._minPitch, this.maxPitch, this._renderWorldCopies);
+                return w.apply(this), w;
+              }
+              apply(w) {
+                this.tileSize = w.tileSize, this.latRange = w.latRange, this.lngRange = w.lngRange, this.width = w.width, this.height = w.height, this._center = w._center, this._elevation = w._elevation, this.minElevationForCurrentTile = w.minElevationForCurrentTile, this.zoom = w.zoom, this.angle = w.angle, this._fov = w._fov, this._pitch = w._pitch, this._unmodified = w._unmodified, this._edgeInsets = w._edgeInsets.clone(), this._calcMatrices();
+              }
+              get minZoom() {
+                return this._minZoom;
+              }
+              set minZoom(w) {
+                this._minZoom !== w && (this._minZoom = w, this.zoom = Math.max(this.zoom, w));
+              }
+              get maxZoom() {
+                return this._maxZoom;
+              }
+              set maxZoom(w) {
+                this._maxZoom !== w && (this._maxZoom = w, this.zoom = Math.min(this.zoom, w));
+              }
+              get minPitch() {
+                return this._minPitch;
+              }
+              set minPitch(w) {
+                this._minPitch !== w && (this._minPitch = w, this.pitch = Math.max(this.pitch, w));
+              }
+              get maxPitch() {
+                return this._maxPitch;
+              }
+              set maxPitch(w) {
+                this._maxPitch !== w && (this._maxPitch = w, this.pitch = Math.min(this.pitch, w));
+              }
+              get renderWorldCopies() {
+                return this._renderWorldCopies;
+              }
+              set renderWorldCopies(w) {
+                w === void 0 ? w = true : w === null && (w = false), this._renderWorldCopies = w;
+              }
+              get worldSize() {
+                return this.tileSize * this.scale;
+              }
+              get centerOffset() {
+                return this.centerPoint._sub(this.size._div(2));
+              }
+              get size() {
+                return new a.P(this.width, this.height);
+              }
+              get bearing() {
+                return -this.angle / Math.PI * 180;
+              }
+              set bearing(w) {
+                let B = -a.b3(w, -180, 180) * Math.PI / 180;
+                this.angle !== B && (this._unmodified = false, this.angle = B, this._calcMatrices(), this.rotationMatrix = function() {
+                  var Q = new a.A(4);
+                  return a.A != Float32Array && (Q[1] = 0, Q[2] = 0), Q[0] = 1, Q[3] = 1, Q;
+                }(), function(Q, ee, le) {
+                  var Oe = ee[0], Ze = ee[1], st = ee[2], Tt = ee[3], Yt = Math.sin(le), Kt = Math.cos(le);
+                  Q[0] = Oe * Kt + st * Yt, Q[1] = Ze * Kt + Tt * Yt, Q[2] = Oe * -Yt + st * Kt, Q[3] = Ze * -Yt + Tt * Kt;
+                }(this.rotationMatrix, this.rotationMatrix, this.angle));
+              }
+              get pitch() {
+                return this._pitch / Math.PI * 180;
+              }
+              set pitch(w) {
+                let B = a.ac(w, this.minPitch, this.maxPitch) / 180 * Math.PI;
+                this._pitch !== B && (this._unmodified = false, this._pitch = B, this._calcMatrices());
+              }
+              get fov() {
+                return this._fov / Math.PI * 180;
+              }
+              set fov(w) {
+                w = Math.max(0.01, Math.min(60, w)), this._fov !== w && (this._unmodified = false, this._fov = w / 180 * Math.PI, this._calcMatrices());
+              }
+              get zoom() {
+                return this._zoom;
+              }
+              set zoom(w) {
+                let B = Math.min(Math.max(w, this.minZoom), this.maxZoom);
+                this._zoom !== B && (this._unmodified = false, this._zoom = B, this.tileZoom = Math.max(0, Math.floor(B)), this.scale = this.zoomScale(B), this._constrain(), this._calcMatrices());
+              }
+              get center() {
+                return this._center;
+              }
+              set center(w) {
+                w.lat === this._center.lat && w.lng === this._center.lng || (this._unmodified = false, this._center = w, this._constrain(), this._calcMatrices());
+              }
+              get elevation() {
+                return this._elevation;
+              }
+              set elevation(w) {
+                w !== this._elevation && (this._elevation = w, this._constrain(), this._calcMatrices());
+              }
+              get padding() {
+                return this._edgeInsets.toJSON();
+              }
+              set padding(w) {
+                this._edgeInsets.equals(w) || (this._unmodified = false, this._edgeInsets.interpolate(this._edgeInsets, w, 1), this._calcMatrices());
+              }
+              get centerPoint() {
+                return this._edgeInsets.getCenter(this.width, this.height);
+              }
+              isPaddingEqual(w) {
+                return this._edgeInsets.equals(w);
+              }
+              interpolatePadding(w, B, Q) {
+                this._unmodified = false, this._edgeInsets.interpolate(w, B, Q), this._constrain(), this._calcMatrices();
+              }
+              coveringZoomLevel(w) {
+                let B = (w.roundZoom ? Math.round : Math.floor)(this.zoom + this.scaleZoom(this.tileSize / w.tileSize));
+                return Math.max(0, B);
+              }
+              getVisibleUnwrappedCoordinates(w) {
+                let B = [new a.b4(0, w)];
+                if (this._renderWorldCopies) {
+                  let Q = this.pointCoordinate(new a.P(0, 0)), ee = this.pointCoordinate(new a.P(this.width, 0)), le = this.pointCoordinate(new a.P(this.width, this.height)), Oe = this.pointCoordinate(new a.P(0, this.height)), Ze = Math.floor(Math.min(Q.x, ee.x, le.x, Oe.x)), st = Math.floor(Math.max(Q.x, ee.x, le.x, Oe.x)), Tt = 1;
+                  for (let Yt = Ze - Tt; Yt <= st + Tt; Yt++) Yt !== 0 && B.push(new a.b4(Yt, w));
+                }
+                return B;
+              }
+              coveringTiles(w) {
+                var B, Q;
+                let ee = this.coveringZoomLevel(w), le = ee;
+                if (w.minzoom !== void 0 && ee < w.minzoom) return [];
+                w.maxzoom !== void 0 && ee > w.maxzoom && (ee = w.maxzoom);
+                let Oe = this.pointCoordinate(this.getCameraPoint()), Ze = a.Z.fromLngLat(this.center), st = Math.pow(2, ee), Tt = [st * Oe.x, st * Oe.y, 0], Yt = [st * Ze.x, st * Ze.y, 0], Kt = ks.fromInvProjectionMatrix(this.invModelViewProjectionMatrix, this.worldSize, ee), xr = w.minzoom || 0;
+                !w.terrain && this.pitch <= 60 && this._edgeInsets.top < 0.1 && (xr = ee);
+                let Ir = w.terrain ? 2 / Math.min(this.tileSize, w.tileSize) * this.tileSize : 3, ve = (Xe) => ({ aabb: new bc([Xe * st, 0, 0], [(Xe + 1) * st, st, 0]), zoom: 0, x: 0, y: 0, wrap: Xe, fullyVisible: false }), be = [], Re = [], qe = ee, et = w.reparseOverscaled ? le : ee;
+                if (this._renderWorldCopies) for (let Xe = 1; Xe <= 3; Xe++) be.push(ve(-Xe)), be.push(ve(Xe));
+                for (be.push(ve(0)); be.length > 0; ) {
+                  let Xe = be.pop(), it = Xe.x, Ft = Xe.y, Ht = Xe.fullyVisible;
+                  if (!Ht) {
+                    let Wr = Xe.aabb.intersects(Kt);
+                    if (Wr === 0) continue;
+                    Ht = Wr === 2;
+                  }
+                  let tr = w.terrain ? Tt : Yt, dr = Xe.aabb.distanceX(tr), Sr = Xe.aabb.distanceY(tr), Or = Math.max(Math.abs(dr), Math.abs(Sr));
+                  if (Xe.zoom === qe || Or > Ir + (1 << qe - Xe.zoom) - 2 && Xe.zoom >= xr) {
+                    let Wr = qe - Xe.zoom, ni = Tt[0] - 0.5 - (it << Wr), Pi = Tt[1] - 0.5 - (Ft << Wr);
+                    Re.push({ tileID: new a.S(Xe.zoom === qe ? et : Xe.zoom, Xe.wrap, Xe.zoom, it, Ft), distanceSq: x([Yt[0] - 0.5 - it, Yt[1] - 0.5 - Ft]), tileDistanceToCamera: Math.sqrt(ni * ni + Pi * Pi) });
+                  } else for (let Wr = 0; Wr < 4; Wr++) {
+                    let ni = (it << 1) + Wr % 2, Pi = (Ft << 1) + (Wr >> 1), cn = Xe.zoom + 1, ln = Xe.aabb.quadrant(Wr);
+                    if (w.terrain) {
+                      let Cn = new a.S(cn, Xe.wrap, cn, ni, Pi), Kn = w.terrain.getMinMaxElevation(Cn), Aa = (B = Kn.minElevation) !== null && B !== void 0 ? B : this.elevation, fa = (Q = Kn.maxElevation) !== null && Q !== void 0 ? Q : this.elevation;
+                      ln = new bc([ln.min[0], ln.min[1], Aa], [ln.max[0], ln.max[1], fa]);
+                    }
+                    be.push({ aabb: ln, zoom: cn, x: ni, y: Pi, wrap: Xe.wrap, fullyVisible: Ht });
+                  }
+                }
+                return Re.sort((Xe, it) => Xe.distanceSq - it.distanceSq).map((Xe) => Xe.tileID);
+              }
+              resize(w, B) {
+                this.width = w, this.height = B, this.pixelsToGLUnits = [2 / w, -2 / B], this._constrain(), this._calcMatrices();
+              }
+              get unmodified() {
+                return this._unmodified;
+              }
+              zoomScale(w) {
+                return Math.pow(2, w);
+              }
+              scaleZoom(w) {
+                return Math.log(w) / Math.LN2;
+              }
+              project(w) {
+                let B = a.ac(w.lat, -85.051129, _u);
+                return new a.P(a.O(w.lng) * this.worldSize, a.Q(B) * this.worldSize);
+              }
+              unproject(w) {
+                return new a.Z(w.x / this.worldSize, w.y / this.worldSize).toLngLat();
+              }
+              get point() {
+                return this.project(this.center);
+              }
+              getCameraPosition() {
+                return { lngLat: this.pointLocation(this.getCameraPoint()), altitude: Math.cos(this._pitch) * this.cameraToCenterDistance / this._pixelPerMeter + this.elevation };
+              }
+              recalculateZoom(w) {
+                let B = this.elevation, Q = Math.cos(this._pitch) * this.cameraToCenterDistance / this._pixelPerMeter, ee = this.pointLocation(this.centerPoint, w), le = w.getElevationForLngLatZoom(ee, this.tileZoom);
+                if (!(this.elevation - le)) return;
+                let Oe = Q + B - le, Ze = Math.cos(this._pitch) * this.cameraToCenterDistance / Oe / a.b5(1, ee.lat), st = this.scaleZoom(Ze / this.tileSize);
+                this._elevation = le, this._center = ee, this.zoom = st;
+              }
+              setLocationAtPoint(w, B) {
+                let Q = this.pointCoordinate(B), ee = this.pointCoordinate(this.centerPoint), le = this.locationCoordinate(w), Oe = new a.Z(le.x - (Q.x - ee.x), le.y - (Q.y - ee.y));
+                this.center = this.coordinateLocation(Oe), this._renderWorldCopies && (this.center = this.center.wrap());
+              }
+              locationPoint(w, B) {
+                return B ? this.coordinatePoint(this.locationCoordinate(w), B.getElevationForLngLatZoom(w, this.tileZoom), this.pixelMatrix3D) : this.coordinatePoint(this.locationCoordinate(w));
+              }
+              pointLocation(w, B) {
+                return this.coordinateLocation(this.pointCoordinate(w, B));
+              }
+              locationCoordinate(w) {
+                return a.Z.fromLngLat(w);
+              }
+              coordinateLocation(w) {
+                return w && w.toLngLat();
+              }
+              pointCoordinate(w, B) {
+                if (B) {
+                  let xr = B.pointCoordinate(w);
+                  if (xr != null) return xr;
+                }
+                let Q = [w.x, w.y, 0, 1], ee = [w.x, w.y, 1, 1];
+                a.af(Q, Q, this.pixelMatrixInverse), a.af(ee, ee, this.pixelMatrixInverse);
+                let le = Q[3], Oe = ee[3], Ze = Q[1] / le, st = ee[1] / Oe, Tt = Q[2] / le, Yt = ee[2] / Oe, Kt = Tt === Yt ? 0 : (0 - Tt) / (Yt - Tt);
+                return new a.Z(a.y.number(Q[0] / le, ee[0] / Oe, Kt) / this.worldSize, a.y.number(Ze, st, Kt) / this.worldSize);
+              }
+              coordinatePoint(w, B = 0, Q = this.pixelMatrix) {
+                let ee = [w.x * this.worldSize, w.y * this.worldSize, B, 1];
+                return a.af(ee, ee, Q), new a.P(ee[0] / ee[3], ee[1] / ee[3]);
+              }
+              getBounds() {
+                let w = Math.max(0, this.height / 2 - this.getHorizon());
+                return new ce().extend(this.pointLocation(new a.P(0, w))).extend(this.pointLocation(new a.P(this.width, w))).extend(this.pointLocation(new a.P(this.width, this.height))).extend(this.pointLocation(new a.P(0, this.height)));
+              }
+              getMaxBounds() {
+                return this.latRange && this.latRange.length === 2 && this.lngRange && this.lngRange.length === 2 ? new ce([this.lngRange[0], this.latRange[0]], [this.lngRange[1], this.latRange[1]]) : null;
+              }
+              getHorizon() {
+                return Math.tan(Math.PI / 2 - this._pitch) * this.cameraToCenterDistance * 0.85;
+              }
+              setMaxBounds(w) {
+                w ? (this.lngRange = [w.getWest(), w.getEast()], this.latRange = [w.getSouth(), w.getNorth()], this._constrain()) : (this.lngRange = null, this.latRange = [-85.051129, _u]);
+              }
+              calculateTileMatrix(w) {
+                let B = w.canonical, Q = this.worldSize / this.zoomScale(B.z), ee = B.x + Math.pow(2, B.z) * w.wrap, le = a.an(new Float64Array(16));
+                return a.J(le, le, [ee * Q, B.y * Q, 0]), a.K(le, le, [Q / a.X, Q / a.X, 1]), le;
+              }
+              calculatePosMatrix(w, B = false) {
+                let Q = w.key, ee = B ? this._alignedPosMatrixCache : this._posMatrixCache;
+                if (ee[Q]) return ee[Q];
+                let le = this.calculateTileMatrix(w);
+                return a.L(le, B ? this.alignedModelViewProjectionMatrix : this.modelViewProjectionMatrix, le), ee[Q] = new Float32Array(le), ee[Q];
+              }
+              calculateFogMatrix(w) {
+                let B = w.key, Q = this._fogMatrixCache;
+                if (Q[B]) return Q[B];
+                let ee = this.calculateTileMatrix(w);
+                return a.L(ee, this.fogMatrix, ee), Q[B] = new Float32Array(ee), Q[B];
+              }
+              customLayerMatrix() {
+                return this.mercatorMatrix.slice();
+              }
+              getConstrained(w, B) {
+                B = a.ac(+B, this.minZoom, this.maxZoom);
+                let Q = { center: new a.N(w.lng, w.lat), zoom: B }, ee = this.lngRange;
+                if (!this._renderWorldCopies && ee === null) {
+                  let Xe = 179.9999999999;
+                  ee = [-179.9999999999, Xe];
+                }
+                let le = this.tileSize * this.zoomScale(Q.zoom), Oe = 0, Ze = le, st = 0, Tt = le, Yt = 0, Kt = 0, { x: xr, y: Ir } = this.size;
+                if (this.latRange) {
+                  let Xe = this.latRange;
+                  Oe = a.Q(Xe[1]) * le, Ze = a.Q(Xe[0]) * le, Ze - Oe < Ir && (Yt = Ir / (Ze - Oe));
+                }
+                ee && (st = a.b3(a.O(ee[0]) * le, 0, le), Tt = a.b3(a.O(ee[1]) * le, 0, le), Tt < st && (Tt += le), Tt - st < xr && (Kt = xr / (Tt - st)));
+                let { x: ve, y: be } = this.project.call({ worldSize: le }, w), Re, qe, et = Math.max(Kt || 0, Yt || 0);
+                if (et) {
+                  let Xe = new a.P(Kt ? (Tt + st) / 2 : ve, Yt ? (Ze + Oe) / 2 : be);
+                  return Q.center = this.unproject.call({ worldSize: le }, Xe).wrap(), Q.zoom += this.scaleZoom(et), Q;
+                }
+                if (this.latRange) {
+                  let Xe = Ir / 2;
+                  be - Xe < Oe && (qe = Oe + Xe), be + Xe > Ze && (qe = Ze - Xe);
+                }
+                if (ee) {
+                  let Xe = (st + Tt) / 2, it = ve;
+                  this._renderWorldCopies && (it = a.b3(ve, Xe - le / 2, Xe + le / 2));
+                  let Ft = xr / 2;
+                  it - Ft < st && (Re = st + Ft), it + Ft > Tt && (Re = Tt - Ft);
+                }
+                if (Re !== void 0 || qe !== void 0) {
+                  let Xe = new a.P(Re != null ? Re : ve, qe != null ? qe : be);
+                  Q.center = this.unproject.call({ worldSize: le }, Xe).wrap();
+                }
+                return Q;
+              }
+              _constrain() {
+                if (!this.center || !this.width || !this.height || this._constraining) return;
+                this._constraining = true;
+                let w = this._unmodified, { center: B, zoom: Q } = this.getConstrained(this.center, this.zoom);
+                this.center = B, this.zoom = Q, this._unmodified = w, this._constraining = false;
+              }
+              _calcMatrices() {
+                if (!this.height) return;
+                let w = this.centerOffset, B = this.point.x, Q = this.point.y;
+                this.cameraToCenterDistance = 0.5 / Math.tan(this._fov / 2) * this.height, this._pixelPerMeter = a.b5(1, this.center.lat) * this.worldSize;
+                let ee = a.an(new Float64Array(16));
+                a.K(ee, ee, [this.width / 2, -this.height / 2, 1]), a.J(ee, ee, [1, -1, 0]), this.labelPlaneMatrix = ee, ee = a.an(new Float64Array(16)), a.K(ee, ee, [1, -1, 1]), a.J(ee, ee, [-1, -1, 0]), a.K(ee, ee, [2 / this.width, 2 / this.height, 1]), this.glCoordMatrix = ee;
+                let le = this.cameraToCenterDistance + this._elevation * this._pixelPerMeter / Math.cos(this._pitch), Oe = Math.min(this.elevation, this.minElevationForCurrentTile), Ze = le - Oe * this._pixelPerMeter / Math.cos(this._pitch), st = Oe < 0 ? Ze : le, Tt = Math.PI / 2 + this._pitch, Yt = this._fov * (0.5 + w.y / this.height), Kt = Math.sin(Yt) * st / Math.sin(a.ac(Math.PI - Tt - Yt, 0.01, Math.PI - 0.01)), xr = this.getHorizon(), Ir = 2 * Math.atan(xr / this.cameraToCenterDistance) * (0.5 + w.y / (2 * xr)), ve = Math.sin(Ir) * st / Math.sin(a.ac(Math.PI - Tt - Ir, 0.01, Math.PI - 0.01)), be = Math.min(Kt, ve);
+                this.farZ = 1.01 * (Math.cos(Math.PI / 2 - this._pitch) * be + st), this.nearZ = this.height / 50, ee = new Float64Array(16), a.b6(ee, this._fov, this.width / this.height, this.nearZ, this.farZ), ee[8] = 2 * -w.x / this.width, ee[9] = 2 * w.y / this.height, this.projectionMatrix = a.ae(ee), a.K(ee, ee, [1, -1, 1]), a.J(ee, ee, [0, 0, -this.cameraToCenterDistance]), a.b7(ee, ee, this._pitch), a.ad(ee, ee, this.angle), a.J(ee, ee, [-B, -Q, 0]), this.mercatorMatrix = a.K([], ee, [this.worldSize, this.worldSize, this.worldSize]), a.K(ee, ee, [1, 1, this._pixelPerMeter]), this.pixelMatrix = a.L(new Float64Array(16), this.labelPlaneMatrix, ee), a.J(ee, ee, [0, 0, -this.elevation]), this.modelViewProjectionMatrix = ee, this.invModelViewProjectionMatrix = a.as([], ee), this.fogMatrix = new Float64Array(16), a.b6(this.fogMatrix, this._fov, this.width / this.height, le, this.farZ), this.fogMatrix[8] = 2 * -w.x / this.width, this.fogMatrix[9] = 2 * w.y / this.height, a.K(this.fogMatrix, this.fogMatrix, [1, -1, 1]), a.J(this.fogMatrix, this.fogMatrix, [0, 0, -this.cameraToCenterDistance]), a.b7(this.fogMatrix, this.fogMatrix, this._pitch), a.ad(this.fogMatrix, this.fogMatrix, this.angle), a.J(this.fogMatrix, this.fogMatrix, [-B, -Q, 0]), a.K(this.fogMatrix, this.fogMatrix, [1, 1, this._pixelPerMeter]), a.J(this.fogMatrix, this.fogMatrix, [0, 0, -this.elevation]), this.pixelMatrix3D = a.L(new Float64Array(16), this.labelPlaneMatrix, ee);
+                let Re = this.width % 2 / 2, qe = this.height % 2 / 2, et = Math.cos(this.angle), Xe = Math.sin(this.angle), it = B - Math.round(B) + et * Re + Xe * qe, Ft = Q - Math.round(Q) + et * qe + Xe * Re, Ht = new Float64Array(ee);
+                if (a.J(Ht, Ht, [it > 0.5 ? it - 1 : it, Ft > 0.5 ? Ft - 1 : Ft, 0]), this.alignedModelViewProjectionMatrix = Ht, ee = a.as(new Float64Array(16), this.pixelMatrix), !ee) throw new Error("failed to invert matrix");
+                this.pixelMatrixInverse = ee, this._posMatrixCache = {}, this._alignedPosMatrixCache = {}, this._fogMatrixCache = {};
+              }
+              maxPitchScaleFactor() {
+                if (!this.pixelMatrixInverse) return 1;
+                let w = this.pointCoordinate(new a.P(0, 0)), B = [w.x * this.worldSize, w.y * this.worldSize, 0, 1];
+                return a.af(B, B, this.pixelMatrix)[3] / this.cameraToCenterDistance;
+              }
+              getCameraPoint() {
+                let w = Math.tan(this._pitch) * (this.cameraToCenterDistance || 1);
+                return this.centerPoint.add(new a.P(0, w));
+              }
+              getCameraQueryGeometry(w) {
+                let B = this.getCameraPoint();
+                if (w.length === 1) return [w[0], B];
+                {
+                  let Q = B.x, ee = B.y, le = B.x, Oe = B.y;
+                  for (let Ze of w) Q = Math.min(Q, Ze.x), ee = Math.min(ee, Ze.y), le = Math.max(le, Ze.x), Oe = Math.max(Oe, Ze.y);
+                  return [new a.P(Q, ee), new a.P(le, ee), new a.P(le, Oe), new a.P(Q, Oe), new a.P(Q, ee)];
+                }
+              }
+              lngLatToCameraDepth(w, B) {
+                let Q = this.locationCoordinate(w), ee = [Q.x * this.worldSize, Q.y * this.worldSize, B, 1];
+                return a.af(ee, ee, this.modelViewProjectionMatrix), ee[2] / ee[3];
+              }
+            }
+            function nh(ue, w) {
+              let B, Q = false, ee = null, le = null, Oe = () => {
+                ee = null, Q && (ue.apply(le, B), ee = setTimeout(Oe, w), Q = false);
+              };
+              return (...Ze) => (Q = true, le = this, B = Ze, ee || Oe(), ee);
+            }
+            class Mh {
+              constructor(w) {
+                this._getCurrentHash = () => {
+                  let B = window.location.hash.replace("#", "");
+                  if (this._hashName) {
+                    let Q;
+                    return B.split("&").map((ee) => ee.split("=")).forEach((ee) => {
+                      ee[0] === this._hashName && (Q = ee);
+                    }), (Q && Q[1] || "").split("/");
+                  }
+                  return B.split("/");
+                }, this._onHashChange = () => {
+                  let B = this._getCurrentHash();
+                  if (B.length >= 3 && !B.some((Q) => isNaN(Q))) {
+                    let Q = this._map.dragRotate.isEnabled() && this._map.touchZoomRotate.isEnabled() ? +(B[3] || 0) : this._map.getBearing();
+                    return this._map.jumpTo({ center: [+B[2], +B[1]], zoom: +B[0], bearing: Q, pitch: +(B[4] || 0) }), true;
+                  }
+                  return false;
+                }, this._updateHashUnthrottled = () => {
+                  let B = window.location.href.replace(/(#.*)?$/, this.getHashString());
+                  window.history.replaceState(window.history.state, null, B);
+                }, this._removeHash = () => {
+                  let B = this._getCurrentHash();
+                  if (B.length === 0) return;
+                  let Q = B.join("/"), ee = Q;
+                  ee.split("&").length > 0 && (ee = ee.split("&")[0]), this._hashName && (ee = `${this._hashName}=${Q}`);
+                  let le = window.location.hash.replace(ee, "");
+                  le.startsWith("#&") ? le = le.slice(0, 1) + le.slice(2) : le === "#" && (le = "");
+                  let Oe = window.location.href.replace(/(#.+)?$/, le);
+                  Oe = Oe.replace("&&", "&"), window.history.replaceState(window.history.state, null, Oe);
+                }, this._updateHash = nh(this._updateHashUnthrottled, 300), this._hashName = w && encodeURIComponent(w);
+              }
+              addTo(w) {
+                return this._map = w, addEventListener("hashchange", this._onHashChange, false), this._map.on("moveend", this._updateHash), this;
+              }
+              remove() {
+                return removeEventListener("hashchange", this._onHashChange, false), this._map.off("moveend", this._updateHash), clearTimeout(this._updateHash()), this._removeHash(), delete this._map, this;
+              }
+              getHashString(w) {
+                let B = this._map.getCenter(), Q = Math.round(100 * this._map.getZoom()) / 100, ee = Math.ceil((Q * Math.LN2 + Math.log(512 / 360 / 0.5)) / Math.LN10), le = Math.pow(10, ee), Oe = Math.round(B.lng * le) / le, Ze = Math.round(B.lat * le) / le, st = this._map.getBearing(), Tt = this._map.getPitch(), Yt = "";
+                if (Yt += w ? `/${Oe}/${Ze}/${Q}` : `${Q}/${Ze}/${Oe}`, (st || Tt) && (Yt += "/" + Math.round(10 * st) / 10), Tt && (Yt += `/${Math.round(Tt)}`), this._hashName) {
+                  let Kt = this._hashName, xr = false, Ir = window.location.hash.slice(1).split("&").map((ve) => {
+                    let be = ve.split("=")[0];
+                    return be === Kt ? (xr = true, `${be}=${Yt}`) : ve;
+                  }).filter((ve) => ve);
+                  return xr || Ir.push(`${Kt}=${Yt}`), `#${Ir.join("&")}`;
+                }
+                return `#${Yt}`;
+              }
+            }
+            let zu = { linearity: 0.3, easing: a.b8(0, 0, 0.3, 1) }, Fc = a.e({ deceleration: 2500, maxSpeed: 1400 }, zu), wc = a.e({ deceleration: 20, maxSpeed: 1400 }, zu), bd = a.e({ deceleration: 1e3, maxSpeed: 360 }, zu), xf = a.e({ deceleration: 1e3, maxSpeed: 90 }, zu);
+            class Pf {
+              constructor(w) {
+                this._map = w, this.clear();
+              }
+              clear() {
+                this._inertiaBuffer = [];
+              }
+              record(w) {
+                this._drainInertiaBuffer(), this._inertiaBuffer.push({ time: u.now(), settings: w });
+              }
+              _drainInertiaBuffer() {
+                let w = this._inertiaBuffer, B = u.now();
+                for (; w.length > 0 && B - w[0].time > 160; ) w.shift();
+              }
+              _onMoveEnd(w) {
+                if (this._drainInertiaBuffer(), this._inertiaBuffer.length < 2) return;
+                let B = { zoom: 0, bearing: 0, pitch: 0, pan: new a.P(0, 0), pinchAround: void 0, around: void 0 };
+                for (let { settings: le } of this._inertiaBuffer) B.zoom += le.zoomDelta || 0, B.bearing += le.bearingDelta || 0, B.pitch += le.pitchDelta || 0, le.panDelta && B.pan._add(le.panDelta), le.around && (B.around = le.around), le.pinchAround && (B.pinchAround = le.pinchAround);
+                let Q = this._inertiaBuffer[this._inertiaBuffer.length - 1].time - this._inertiaBuffer[0].time, ee = {};
+                if (B.pan.mag()) {
+                  let le = bf(B.pan.mag(), Q, a.e({}, Fc, w || {}));
+                  ee.offset = B.pan.mult(le.amount / B.pan.mag()), ee.center = this._map.transform.center, Ou(ee, le);
+                }
+                if (B.zoom) {
+                  let le = bf(B.zoom, Q, wc);
+                  ee.zoom = this._map.transform.zoom + le.amount, Ou(ee, le);
+                }
+                if (B.bearing) {
+                  let le = bf(B.bearing, Q, bd);
+                  ee.bearing = this._map.transform.bearing + a.ac(le.amount, -179, 179), Ou(ee, le);
+                }
+                if (B.pitch) {
+                  let le = bf(B.pitch, Q, xf);
+                  ee.pitch = this._map.transform.pitch + le.amount, Ou(ee, le);
+                }
+                if (ee.zoom || ee.bearing) {
+                  let le = B.pinchAround === void 0 ? B.around : B.pinchAround;
+                  ee.around = le ? this._map.unproject(le) : this._map.getCenter();
+                }
+                return this.clear(), a.e(ee, { noMoveStart: true });
+              }
+            }
+            function Ou(ue, w) {
+              (!ue.duration || ue.duration < w.duration) && (ue.duration = w.duration, ue.easing = w.easing);
+            }
+            function bf(ue, w, B) {
+              let { maxSpeed: Q, linearity: ee, deceleration: le } = B, Oe = a.ac(ue * ee / (w / 1e3), -Q, Q), Ze = Math.abs(Oe) / (le * ee);
+              return { easing: B.easing, duration: 1e3 * Ze, amount: Oe * (Ze / 2) };
+            }
+            class jl extends a.k {
+              preventDefault() {
+                this._defaultPrevented = true;
+              }
+              get defaultPrevented() {
+                return this._defaultPrevented;
+              }
+              constructor(w, B, Q, ee = {}) {
+                let le = c.mousePos(B.getCanvas(), Q), Oe = B.unproject(le);
+                super(w, a.e({ point: le, lngLat: Oe, originalEvent: Q }, ee)), this._defaultPrevented = false, this.target = B;
+              }
+            }
+            class lf extends a.k {
+              preventDefault() {
+                this._defaultPrevented = true;
+              }
+              get defaultPrevented() {
+                return this._defaultPrevented;
+              }
+              constructor(w, B, Q) {
+                let ee = w === "touchend" ? Q.changedTouches : Q.touches, le = c.touchPos(B.getCanvasContainer(), ee), Oe = le.map((st) => B.unproject(st)), Ze = le.reduce((st, Tt, Yt, Kt) => st.add(Tt.div(Kt.length)), new a.P(0, 0));
+                super(w, { points: le, point: Ze, lngLats: Oe, lngLat: B.unproject(Ze), originalEvent: Q }), this._defaultPrevented = false;
+              }
+            }
+            class Xh extends a.k {
+              preventDefault() {
+                this._defaultPrevented = true;
+              }
+              get defaultPrevented() {
+                return this._defaultPrevented;
+              }
+              constructor(w, B, Q) {
+                super(w, { originalEvent: Q }), this._defaultPrevented = false;
+              }
+            }
+            class If {
+              constructor(w, B) {
+                this._map = w, this._clickTolerance = B.clickTolerance;
+              }
+              reset() {
+                delete this._mousedownPos;
+              }
+              wheel(w) {
+                return this._firePreventable(new Xh(w.type, this._map, w));
+              }
+              mousedown(w, B) {
+                return this._mousedownPos = B, this._firePreventable(new jl(w.type, this._map, w));
+              }
+              mouseup(w) {
+                this._map.fire(new jl(w.type, this._map, w));
+              }
+              click(w, B) {
+                this._mousedownPos && this._mousedownPos.dist(B) >= this._clickTolerance || this._map.fire(new jl(w.type, this._map, w));
+              }
+              dblclick(w) {
+                return this._firePreventable(new jl(w.type, this._map, w));
+              }
+              mouseover(w) {
+                this._map.fire(new jl(w.type, this._map, w));
+              }
+              mouseout(w) {
+                this._map.fire(new jl(w.type, this._map, w));
+              }
+              touchstart(w) {
+                return this._firePreventable(new lf(w.type, this._map, w));
+              }
+              touchmove(w) {
+                this._map.fire(new lf(w.type, this._map, w));
+              }
+              touchend(w) {
+                this._map.fire(new lf(w.type, this._map, w));
+              }
+              touchcancel(w) {
+                this._map.fire(new lf(w.type, this._map, w));
+              }
+              _firePreventable(w) {
+                if (this._map.fire(w), w.defaultPrevented) return {};
+              }
+              isEnabled() {
+                return true;
+              }
+              isActive() {
+                return false;
+              }
+              enable() {
+              }
+              disable() {
+              }
+            }
+            class Cs {
+              constructor(w) {
+                this._map = w;
+              }
+              reset() {
+                this._delayContextMenu = false, this._ignoreContextMenu = true, delete this._contextMenuEvent;
+              }
+              mousemove(w) {
+                this._map.fire(new jl(w.type, this._map, w));
+              }
+              mousedown() {
+                this._delayContextMenu = true, this._ignoreContextMenu = false;
+              }
+              mouseup() {
+                this._delayContextMenu = false, this._contextMenuEvent && (this._map.fire(new jl("contextmenu", this._map, this._contextMenuEvent)), delete this._contextMenuEvent);
+              }
+              contextmenu(w) {
+                this._delayContextMenu ? this._contextMenuEvent = w : this._ignoreContextMenu || this._map.fire(new jl(w.type, this._map, w)), this._map.listens("contextmenu") && w.preventDefault();
+              }
+              isEnabled() {
+                return true;
+              }
+              isActive() {
+                return false;
+              }
+              enable() {
+              }
+              disable() {
+              }
+            }
+            class du {
+              constructor(w) {
+                this._map = w;
+              }
+              get transform() {
+                return this._map._requestedCameraState || this._map.transform;
+              }
+              get center() {
+                return { lng: this.transform.center.lng, lat: this.transform.center.lat };
+              }
+              get zoom() {
+                return this.transform.zoom;
+              }
+              get pitch() {
+                return this.transform.pitch;
+              }
+              get bearing() {
+                return this.transform.bearing;
+              }
+              unproject(w) {
+                return this.transform.pointLocation(a.P.convert(w), this._map.terrain);
+              }
+            }
+            class ku {
+              constructor(w, B) {
+                this._map = w, this._tr = new du(w), this._el = w.getCanvasContainer(), this._container = w.getContainer(), this._clickTolerance = B.clickTolerance || 1;
+              }
+              isEnabled() {
+                return !!this._enabled;
+              }
+              isActive() {
+                return !!this._active;
+              }
+              enable() {
+                this.isEnabled() || (this._enabled = true);
+              }
+              disable() {
+                this.isEnabled() && (this._enabled = false);
+              }
+              mousedown(w, B) {
+                this.isEnabled() && w.shiftKey && w.button === 0 && (c.disableDrag(), this._startPos = this._lastPos = B, this._active = true);
+              }
+              mousemoveWindow(w, B) {
+                if (!this._active) return;
+                let Q = B;
+                if (this._lastPos.equals(Q) || !this._box && Q.dist(this._startPos) < this._clickTolerance) return;
+                let ee = this._startPos;
+                this._lastPos = Q, this._box || (this._box = c.create("div", "maplibregl-boxzoom", this._container), this._container.classList.add("maplibregl-crosshair"), this._fireEvent("boxzoomstart", w));
+                let le = Math.min(ee.x, Q.x), Oe = Math.max(ee.x, Q.x), Ze = Math.min(ee.y, Q.y), st = Math.max(ee.y, Q.y);
+                c.setTransform(this._box, `translate(${le}px,${Ze}px)`), this._box.style.width = Oe - le + "px", this._box.style.height = st - Ze + "px";
+              }
+              mouseupWindow(w, B) {
+                if (!this._active || w.button !== 0) return;
+                let Q = this._startPos, ee = B;
+                if (this.reset(), c.suppressClick(), Q.x !== ee.x || Q.y !== ee.y) return this._map.fire(new a.k("boxzoomend", { originalEvent: w })), { cameraAnimation: (le) => le.fitScreenCoordinates(Q, ee, this._tr.bearing, { linear: true }) };
+                this._fireEvent("boxzoomcancel", w);
+              }
+              keydown(w) {
+                this._active && w.keyCode === 27 && (this.reset(), this._fireEvent("boxzoomcancel", w));
+              }
+              reset() {
+                this._active = false, this._container.classList.remove("maplibregl-crosshair"), this._box && (c.remove(this._box), this._box = null), c.enableDrag(), delete this._startPos, delete this._lastPos;
+              }
+              _fireEvent(w, B) {
+                return this._map.fire(new a.k(w, { originalEvent: B }));
+              }
+            }
+            function Xf(ue, w) {
+              if (ue.length !== w.length) throw new Error(`The number of touches and points are not equal - touches ${ue.length}, points ${w.length}`);
+              let B = {};
+              for (let Q = 0; Q < ue.length; Q++) B[ue[Q].identifier] = w[Q];
+              return B;
+            }
+            class Us {
+              constructor(w) {
+                this.reset(), this.numTouches = w.numTouches;
+              }
+              reset() {
+                delete this.centroid, delete this.startTime, delete this.touches, this.aborted = false;
+              }
+              touchstart(w, B, Q) {
+                (this.centroid || Q.length > this.numTouches) && (this.aborted = true), this.aborted || (this.startTime === void 0 && (this.startTime = w.timeStamp), Q.length === this.numTouches && (this.centroid = function(ee) {
+                  let le = new a.P(0, 0);
+                  for (let Oe of ee) le._add(Oe);
+                  return le.div(ee.length);
+                }(B), this.touches = Xf(Q, B)));
+              }
+              touchmove(w, B, Q) {
+                if (this.aborted || !this.centroid) return;
+                let ee = Xf(Q, B);
+                for (let le in this.touches) {
+                  let Oe = ee[le];
+                  (!Oe || Oe.dist(this.touches[le]) > 30) && (this.aborted = true);
+                }
+              }
+              touchend(w, B, Q) {
+                if ((!this.centroid || w.timeStamp - this.startTime > 500) && (this.aborted = true), Q.length === 0) {
+                  let ee = !this.aborted && this.centroid;
+                  if (this.reset(), ee) return ee;
+                }
+              }
+            }
+            class wf {
+              constructor(w) {
+                this.singleTap = new Us(w), this.numTaps = w.numTaps, this.reset();
+              }
+              reset() {
+                this.lastTime = 1 / 0, delete this.lastTap, this.count = 0, this.singleTap.reset();
+              }
+              touchstart(w, B, Q) {
+                this.singleTap.touchstart(w, B, Q);
+              }
+              touchmove(w, B, Q) {
+                this.singleTap.touchmove(w, B, Q);
+              }
+              touchend(w, B, Q) {
+                let ee = this.singleTap.touchend(w, B, Q);
+                if (ee) {
+                  let le = w.timeStamp - this.lastTime < 500, Oe = !this.lastTap || this.lastTap.dist(ee) < 30;
+                  if (le && Oe || this.reset(), this.count++, this.lastTime = w.timeStamp, this.lastTap = ee, this.count === this.numTaps) return this.reset(), ee;
+                }
+              }
+            }
+            class zc {
+              constructor(w) {
+                this._tr = new du(w), this._zoomIn = new wf({ numTouches: 1, numTaps: 2 }), this._zoomOut = new wf({ numTouches: 2, numTaps: 1 }), this.reset();
+              }
+              reset() {
+                this._active = false, this._zoomIn.reset(), this._zoomOut.reset();
+              }
+              touchstart(w, B, Q) {
+                this._zoomIn.touchstart(w, B, Q), this._zoomOut.touchstart(w, B, Q);
+              }
+              touchmove(w, B, Q) {
+                this._zoomIn.touchmove(w, B, Q), this._zoomOut.touchmove(w, B, Q);
+              }
+              touchend(w, B, Q) {
+                let ee = this._zoomIn.touchend(w, B, Q), le = this._zoomOut.touchend(w, B, Q), Oe = this._tr;
+                return ee ? (this._active = true, w.preventDefault(), setTimeout(() => this.reset(), 0), { cameraAnimation: (Ze) => Ze.easeTo({ duration: 300, zoom: Oe.zoom + 1, around: Oe.unproject(ee) }, { originalEvent: w }) }) : le ? (this._active = true, w.preventDefault(), setTimeout(() => this.reset(), 0), { cameraAnimation: (Ze) => Ze.easeTo({ duration: 300, zoom: Oe.zoom - 1, around: Oe.unproject(le) }, { originalEvent: w }) }) : void 0;
+              }
+              touchcancel() {
+                this.reset();
+              }
+              enable() {
+                this._enabled = true;
+              }
+              disable() {
+                this._enabled = false, this.reset();
+              }
+              isEnabled() {
+                return this._enabled;
+              }
+              isActive() {
+                return this._active;
+              }
+            }
+            class Wu {
+              constructor(w) {
+                this._enabled = !!w.enable, this._moveStateManager = w.moveStateManager, this._clickTolerance = w.clickTolerance || 1, this._moveFunction = w.move, this._activateOnStart = !!w.activateOnStart, w.assignEvents(this), this.reset();
+              }
+              reset(w) {
+                this._active = false, this._moved = false, delete this._lastPoint, this._moveStateManager.endMove(w);
+              }
+              _move(...w) {
+                let B = this._moveFunction(...w);
+                if (B.bearingDelta || B.pitchDelta || B.around || B.panDelta) return this._active = true, B;
+              }
+              dragStart(w, B) {
+                this.isEnabled() && !this._lastPoint && this._moveStateManager.isValidStartEvent(w) && (this._moveStateManager.startMove(w), this._lastPoint = B.length ? B[0] : B, this._activateOnStart && this._lastPoint && (this._active = true));
+              }
+              dragMove(w, B) {
+                if (!this.isEnabled()) return;
+                let Q = this._lastPoint;
+                if (!Q) return;
+                if (w.preventDefault(), !this._moveStateManager.isValidMoveEvent(w)) return void this.reset(w);
+                let ee = B.length ? B[0] : B;
+                return !this._moved && ee.dist(Q) < this._clickTolerance ? void 0 : (this._moved = true, this._lastPoint = ee, this._move(Q, ee));
+              }
+              dragEnd(w) {
+                this.isEnabled() && this._lastPoint && this._moveStateManager.isValidEndEvent(w) && (this._moved && c.suppressClick(), this.reset(w));
+              }
+              enable() {
+                this._enabled = true;
+              }
+              disable() {
+                this._enabled = false, this.reset();
+              }
+              isEnabled() {
+                return this._enabled;
+              }
+              isActive() {
+                return this._active;
+              }
+              getClickTolerance() {
+                return this._clickTolerance;
+              }
+            }
+            let Rf = { 0: 1, 2: 2 };
+            class Xu {
+              constructor(w) {
+                this._correctEvent = w.checkCorrectEvent;
+              }
+              startMove(w) {
+                let B = c.mouseButton(w);
+                this._eventButton = B;
+              }
+              endMove(w) {
+                delete this._eventButton;
+              }
+              isValidStartEvent(w) {
+                return this._correctEvent(w);
+              }
+              isValidMoveEvent(w) {
+                return !function(B, Q) {
+                  let ee = Rf[Q];
+                  return B.buttons === void 0 || (B.buttons & ee) !== ee;
+                }(w, this._eventButton);
+              }
+              isValidEndEvent(w) {
+                return c.mouseButton(w) === this._eventButton;
+              }
+            }
+            class uf {
+              constructor() {
+                this._firstTouch = void 0;
+              }
+              _isOneFingerTouch(w) {
+                return w.targetTouches.length === 1;
+              }
+              _isSameTouchEvent(w) {
+                return w.targetTouches[0].identifier === this._firstTouch;
+              }
+              startMove(w) {
+                this._firstTouch = w.targetTouches[0].identifier;
+              }
+              endMove(w) {
+                delete this._firstTouch;
+              }
+              isValidStartEvent(w) {
+                return this._isOneFingerTouch(w);
+              }
+              isValidMoveEvent(w) {
+                return this._isOneFingerTouch(w) && this._isSameTouchEvent(w);
+              }
+              isValidEndEvent(w) {
+                return this._isOneFingerTouch(w) && this._isSameTouchEvent(w);
+              }
+            }
+            let Zf = (ue) => {
+              ue.mousedown = ue.dragStart, ue.mousemoveWindow = ue.dragMove, ue.mouseup = ue.dragEnd, ue.contextmenu = (w) => {
+                w.preventDefault();
+              };
+            }, Wl = ({ enable: ue, clickTolerance: w, bearingDegreesPerPixelMoved: B = 0.8 }) => {
+              let Q = new Xu({ checkCorrectEvent: (ee) => c.mouseButton(ee) === 0 && ee.ctrlKey || c.mouseButton(ee) === 2 });
+              return new Wu({ clickTolerance: w, move: (ee, le) => ({ bearingDelta: (le.x - ee.x) * B }), moveStateManager: Q, enable: ue, assignEvents: Zf });
+            }, ah = ({ enable: ue, clickTolerance: w, pitchDegreesPerPixelMoved: B = -0.5 }) => {
+              let Q = new Xu({ checkCorrectEvent: (ee) => c.mouseButton(ee) === 0 && ee.ctrlKey || c.mouseButton(ee) === 2 });
+              return new Wu({ clickTolerance: w, move: (ee, le) => ({ pitchDelta: (le.y - ee.y) * B }), moveStateManager: Q, enable: ue, assignEvents: Zf });
+            };
+            class Zu {
+              constructor(w, B) {
+                this._clickTolerance = w.clickTolerance || 1, this._map = B, this.reset();
+              }
+              reset() {
+                this._active = false, this._touches = {}, this._sum = new a.P(0, 0);
+              }
+              _shouldBePrevented(w) {
+                return w < (this._map.cooperativeGestures.isEnabled() ? 2 : 1);
+              }
+              touchstart(w, B, Q) {
+                return this._calculateTransform(w, B, Q);
+              }
+              touchmove(w, B, Q) {
+                if (this._active) {
+                  if (!this._shouldBePrevented(Q.length)) return w.preventDefault(), this._calculateTransform(w, B, Q);
+                  this._map.cooperativeGestures.notifyGestureBlocked("touch_pan", w);
+                }
+              }
+              touchend(w, B, Q) {
+                this._calculateTransform(w, B, Q), this._active && this._shouldBePrevented(Q.length) && this.reset();
+              }
+              touchcancel() {
+                this.reset();
+              }
+              _calculateTransform(w, B, Q) {
+                Q.length > 0 && (this._active = true);
+                let ee = Xf(Q, B), le = new a.P(0, 0), Oe = new a.P(0, 0), Ze = 0;
+                for (let Tt in ee) {
+                  let Yt = ee[Tt], Kt = this._touches[Tt];
+                  Kt && (le._add(Yt), Oe._add(Yt.sub(Kt)), Ze++, ee[Tt] = Yt);
+                }
+                if (this._touches = ee, this._shouldBePrevented(Ze) || !Oe.mag()) return;
+                let st = Oe.div(Ze);
+                return this._sum._add(st), this._sum.mag() < this._clickTolerance ? void 0 : { around: le.div(Ze), panDelta: st };
+              }
+              enable() {
+                this._enabled = true;
+              }
+              disable() {
+                this._enabled = false, this.reset();
+              }
+              isEnabled() {
+                return this._enabled;
+              }
+              isActive() {
+                return this._active;
+              }
+            }
+            class Oc {
+              constructor() {
+                this.reset();
+              }
+              reset() {
+                this._active = false, delete this._firstTwoTouches;
+              }
+              touchstart(w, B, Q) {
+                this._firstTwoTouches || Q.length < 2 || (this._firstTwoTouches = [Q[0].identifier, Q[1].identifier], this._start([B[0], B[1]]));
+              }
+              touchmove(w, B, Q) {
+                if (!this._firstTwoTouches) return;
+                w.preventDefault();
+                let [ee, le] = this._firstTwoTouches, Oe = Tc(Q, B, ee), Ze = Tc(Q, B, le);
+                if (!Oe || !Ze) return;
+                let st = this._aroundCenter ? null : Oe.add(Ze).div(2);
+                return this._move([Oe, Ze], st, w);
+              }
+              touchend(w, B, Q) {
+                if (!this._firstTwoTouches) return;
+                let [ee, le] = this._firstTwoTouches, Oe = Tc(Q, B, ee), Ze = Tc(Q, B, le);
+                Oe && Ze || (this._active && c.suppressClick(), this.reset());
+              }
+              touchcancel() {
+                this.reset();
+              }
+              enable(w) {
+                this._enabled = true, this._aroundCenter = !!w && w.around === "center";
+              }
+              disable() {
+                this._enabled = false, this.reset();
+              }
+              isEnabled() {
+                return !!this._enabled;
+              }
+              isActive() {
+                return !!this._active;
+              }
+            }
+            function Tc(ue, w, B) {
+              for (let Q = 0; Q < ue.length; Q++) if (ue[Q].identifier === B) return w[Q];
+            }
+            function wl(ue, w) {
+              return Math.log(ue / w) / Math.LN2;
+            }
+            class vu extends Oc {
+              reset() {
+                super.reset(), delete this._distance, delete this._startDistance;
+              }
+              _start(w) {
+                this._startDistance = this._distance = w[0].dist(w[1]);
+              }
+              _move(w, B) {
+                let Q = this._distance;
+                if (this._distance = w[0].dist(w[1]), this._active || !(Math.abs(wl(this._distance, this._startDistance)) < 0.1)) return this._active = true, { zoomDelta: wl(this._distance, Q), pinchAround: B };
+              }
+            }
+            function qc(ue, w) {
+              return 180 * ue.angleWith(w) / Math.PI;
+            }
+            class cf extends Oc {
+              reset() {
+                super.reset(), delete this._minDiameter, delete this._startVector, delete this._vector;
+              }
+              _start(w) {
+                this._startVector = this._vector = w[0].sub(w[1]), this._minDiameter = w[0].dist(w[1]);
+              }
+              _move(w, B, Q) {
+                let ee = this._vector;
+                if (this._vector = w[0].sub(w[1]), this._active || !this._isBelowThreshold(this._vector)) return this._active = true, { bearingDelta: qc(this._vector, ee), pinchAround: B };
+              }
+              _isBelowThreshold(w) {
+                this._minDiameter = Math.min(this._minDiameter, w.mag());
+                let B = 25 / (Math.PI * this._minDiameter) * 360, Q = qc(w, this._startVector);
+                return Math.abs(Q) < B;
+              }
+            }
+            function fc(ue) {
+              return Math.abs(ue.y) > Math.abs(ue.x);
+            }
+            class Bc extends Oc {
+              constructor(w) {
+                super(), this._currentTouchCount = 0, this._map = w;
+              }
+              reset() {
+                super.reset(), this._valid = void 0, delete this._firstMove, delete this._lastPoints;
+              }
+              touchstart(w, B, Q) {
+                super.touchstart(w, B, Q), this._currentTouchCount = Q.length;
+              }
+              _start(w) {
+                this._lastPoints = w, fc(w[0].sub(w[1])) && (this._valid = false);
+              }
+              _move(w, B, Q) {
+                if (this._map.cooperativeGestures.isEnabled() && this._currentTouchCount < 3) return;
+                let ee = w[0].sub(this._lastPoints[0]), le = w[1].sub(this._lastPoints[1]);
+                return this._valid = this.gestureBeginsVertically(ee, le, Q.timeStamp), this._valid ? (this._lastPoints = w, this._active = true, { pitchDelta: (ee.y + le.y) / 2 * -0.5 }) : void 0;
+              }
+              gestureBeginsVertically(w, B, Q) {
+                if (this._valid !== void 0) return this._valid;
+                let ee = w.mag() >= 2, le = B.mag() >= 2;
+                if (!ee && !le) return;
+                if (!ee || !le) return this._firstMove === void 0 && (this._firstMove = Q), Q - this._firstMove < 100 && void 0;
+                let Oe = w.y > 0 == B.y > 0;
+                return fc(w) && fc(B) && Oe;
+              }
+            }
+            let At = { panStep: 100, bearingStep: 15, pitchStep: 10 };
+            class Xt {
+              constructor(w) {
+                this._tr = new du(w);
+                let B = At;
+                this._panStep = B.panStep, this._bearingStep = B.bearingStep, this._pitchStep = B.pitchStep, this._rotationDisabled = false;
+              }
+              reset() {
+                this._active = false;
+              }
+              keydown(w) {
+                if (w.altKey || w.ctrlKey || w.metaKey) return;
+                let B = 0, Q = 0, ee = 0, le = 0, Oe = 0;
+                switch (w.keyCode) {
+                  case 61:
+                  case 107:
+                  case 171:
+                  case 187:
+                    B = 1;
+                    break;
+                  case 189:
+                  case 109:
+                  case 173:
+                    B = -1;
+                    break;
+                  case 37:
+                    w.shiftKey ? Q = -1 : (w.preventDefault(), le = -1);
+                    break;
+                  case 39:
+                    w.shiftKey ? Q = 1 : (w.preventDefault(), le = 1);
+                    break;
+                  case 38:
+                    w.shiftKey ? ee = 1 : (w.preventDefault(), Oe = -1);
+                    break;
+                  case 40:
+                    w.shiftKey ? ee = -1 : (w.preventDefault(), Oe = 1);
+                    break;
+                  default:
+                    return;
+                }
+                return this._rotationDisabled && (Q = 0, ee = 0), { cameraAnimation: (Ze) => {
+                  let st = this._tr;
+                  Ze.easeTo({ duration: 300, easeId: "keyboardHandler", easing: Cr, zoom: B ? Math.round(st.zoom) + B * (w.shiftKey ? 2 : 1) : st.zoom, bearing: st.bearing + Q * this._bearingStep, pitch: st.pitch + ee * this._pitchStep, offset: [-le * this._panStep, -Oe * this._panStep], center: st.center }, { originalEvent: w });
+                } };
+              }
+              enable() {
+                this._enabled = true;
+              }
+              disable() {
+                this._enabled = false, this.reset();
+              }
+              isEnabled() {
+                return this._enabled;
+              }
+              isActive() {
+                return this._active;
+              }
+              disableRotation() {
+                this._rotationDisabled = true;
+              }
+              enableRotation() {
+                this._rotationDisabled = false;
+              }
+            }
+            function Cr(ue) {
+              return ue * (2 - ue);
+            }
+            let Ar = 4.000244140625;
+            class Kr {
+              constructor(w, B) {
+                this._onTimeout = (Q) => {
+                  this._type = "wheel", this._delta -= this._lastValue, this._active || this._start(Q);
+                }, this._map = w, this._tr = new du(w), this._triggerRenderFrame = B, this._delta = 0, this._defaultZoomRate = 0.01, this._wheelZoomRate = 0.0022222222222222222;
+              }
+              setZoomRate(w) {
+                this._defaultZoomRate = w;
+              }
+              setWheelZoomRate(w) {
+                this._wheelZoomRate = w;
+              }
+              isEnabled() {
+                return !!this._enabled;
+              }
+              isActive() {
+                return !!this._active || this._finishTimeout !== void 0;
+              }
+              isZooming() {
+                return !!this._zooming;
+              }
+              enable(w) {
+                this.isEnabled() || (this._enabled = true, this._aroundCenter = !!w && w.around === "center");
+              }
+              disable() {
+                this.isEnabled() && (this._enabled = false);
+              }
+              _shouldBePrevented(w) {
+                return !!this._map.cooperativeGestures.isEnabled() && !(w.ctrlKey || this._map.cooperativeGestures.isBypassed(w));
+              }
+              wheel(w) {
+                if (!this.isEnabled()) return;
+                if (this._shouldBePrevented(w)) return void this._map.cooperativeGestures.notifyGestureBlocked("wheel_zoom", w);
+                let B = w.deltaMode === WheelEvent.DOM_DELTA_LINE ? 40 * w.deltaY : w.deltaY, Q = u.now(), ee = Q - (this._lastWheelEventTime || 0);
+                this._lastWheelEventTime = Q, B !== 0 && B % Ar == 0 ? this._type = "wheel" : B !== 0 && Math.abs(B) < 4 ? this._type = "trackpad" : ee > 400 ? (this._type = null, this._lastValue = B, this._timeout = setTimeout(this._onTimeout, 40, w)) : this._type || (this._type = Math.abs(ee * B) < 200 ? "trackpad" : "wheel", this._timeout && (clearTimeout(this._timeout), this._timeout = null, B += this._lastValue)), w.shiftKey && B && (B /= 4), this._type && (this._lastWheelEvent = w, this._delta -= B, this._active || this._start(w)), w.preventDefault();
+              }
+              _start(w) {
+                if (!this._delta) return;
+                this._frameId && (this._frameId = null), this._active = true, this.isZooming() || (this._zooming = true), this._finishTimeout && (clearTimeout(this._finishTimeout), delete this._finishTimeout);
+                let B = c.mousePos(this._map.getCanvas(), w), Q = this._tr;
+                this._around = B.y > Q.transform.height / 2 - Q.transform.getHorizon() ? a.N.convert(this._aroundCenter ? Q.center : Q.unproject(B)) : a.N.convert(Q.center), this._aroundPoint = Q.transform.locationPoint(this._around), this._frameId || (this._frameId = true, this._triggerRenderFrame());
+              }
+              renderFrame() {
+                if (!this._frameId || (this._frameId = null, !this.isActive())) return;
+                let w = this._tr.transform;
+                if (this._delta !== 0) {
+                  let st = this._type === "wheel" && Math.abs(this._delta) > Ar ? this._wheelZoomRate : this._defaultZoomRate, Tt = 2 / (1 + Math.exp(-Math.abs(this._delta * st)));
+                  this._delta < 0 && Tt !== 0 && (Tt = 1 / Tt);
+                  let Yt = typeof this._targetZoom == "number" ? w.zoomScale(this._targetZoom) : w.scale;
+                  this._targetZoom = Math.min(w.maxZoom, Math.max(w.minZoom, w.scaleZoom(Yt * Tt))), this._type === "wheel" && (this._startZoom = w.zoom, this._easing = this._smoothOutEasing(200)), this._delta = 0;
+                }
+                let B = typeof this._targetZoom == "number" ? this._targetZoom : w.zoom, Q = this._startZoom, ee = this._easing, le, Oe = false, Ze = u.now() - this._lastWheelEventTime;
+                if (this._type === "wheel" && Q && ee && Ze) {
+                  let st = Math.min(Ze / 200, 1), Tt = ee(st);
+                  le = a.y.number(Q, B, Tt), st < 1 ? this._frameId || (this._frameId = true) : Oe = true;
+                } else le = B, Oe = true;
+                return this._active = true, Oe && (this._active = false, this._finishTimeout = setTimeout(() => {
+                  this._zooming = false, this._triggerRenderFrame(), delete this._targetZoom, delete this._finishTimeout;
+                }, 200)), { noInertia: true, needsRenderFrame: !Oe, zoomDelta: le - w.zoom, around: this._aroundPoint, originalEvent: this._lastWheelEvent };
+              }
+              _smoothOutEasing(w) {
+                let B = a.b9;
+                if (this._prevEase) {
+                  let Q = this._prevEase, ee = (u.now() - Q.start) / Q.duration, le = Q.easing(ee + 0.01) - Q.easing(ee), Oe = 0.27 / Math.sqrt(le * le + 1e-4) * 0.01, Ze = Math.sqrt(0.0729 - Oe * Oe);
+                  B = a.b8(Oe, Ze, 0.25, 1);
+                }
+                return this._prevEase = { start: u.now(), duration: w, easing: B }, B;
+              }
+              reset() {
+                this._active = false, this._zooming = false, delete this._targetZoom, this._finishTimeout && (clearTimeout(this._finishTimeout), delete this._finishTimeout);
+              }
+            }
+            class ki {
+              constructor(w, B) {
+                this._clickZoom = w, this._tapZoom = B;
+              }
+              enable() {
+                this._clickZoom.enable(), this._tapZoom.enable();
+              }
+              disable() {
+                this._clickZoom.disable(), this._tapZoom.disable();
+              }
+              isEnabled() {
+                return this._clickZoom.isEnabled() && this._tapZoom.isEnabled();
+              }
+              isActive() {
+                return this._clickZoom.isActive() || this._tapZoom.isActive();
+              }
+            }
+            class Xi {
+              constructor(w) {
+                this._tr = new du(w), this.reset();
+              }
+              reset() {
+                this._active = false;
+              }
+              dblclick(w, B) {
+                return w.preventDefault(), { cameraAnimation: (Q) => {
+                  Q.easeTo({ duration: 300, zoom: this._tr.zoom + (w.shiftKey ? -1 : 1), around: this._tr.unproject(B) }, { originalEvent: w });
+                } };
+              }
+              enable() {
+                this._enabled = true;
+              }
+              disable() {
+                this._enabled = false, this.reset();
+              }
+              isEnabled() {
+                return this._enabled;
+              }
+              isActive() {
+                return this._active;
+              }
+            }
+            class dn {
+              constructor() {
+                this._tap = new wf({ numTouches: 1, numTaps: 1 }), this.reset();
+              }
+              reset() {
+                this._active = false, delete this._swipePoint, delete this._swipeTouch, delete this._tapTime, delete this._tapPoint, this._tap.reset();
+              }
+              touchstart(w, B, Q) {
+                if (!this._swipePoint) if (this._tapTime) {
+                  let ee = B[0], le = w.timeStamp - this._tapTime < 500, Oe = this._tapPoint.dist(ee) < 30;
+                  le && Oe ? Q.length > 0 && (this._swipePoint = ee, this._swipeTouch = Q[0].identifier) : this.reset();
+                } else this._tap.touchstart(w, B, Q);
+              }
+              touchmove(w, B, Q) {
+                if (this._tapTime) {
+                  if (this._swipePoint) {
+                    if (Q[0].identifier !== this._swipeTouch) return;
+                    let ee = B[0], le = ee.y - this._swipePoint.y;
+                    return this._swipePoint = ee, w.preventDefault(), this._active = true, { zoomDelta: le / 128 };
+                  }
+                } else this._tap.touchmove(w, B, Q);
+              }
+              touchend(w, B, Q) {
+                if (this._tapTime) this._swipePoint && Q.length === 0 && this.reset();
+                else {
+                  let ee = this._tap.touchend(w, B, Q);
+                  ee && (this._tapTime = w.timeStamp, this._tapPoint = ee);
+                }
+              }
+              touchcancel() {
+                this.reset();
+              }
+              enable() {
+                this._enabled = true;
+              }
+              disable() {
+                this._enabled = false, this.reset();
+              }
+              isEnabled() {
+                return this._enabled;
+              }
+              isActive() {
+                return this._active;
+              }
+            }
+            class wn {
+              constructor(w, B, Q) {
+                this._el = w, this._mousePan = B, this._touchPan = Q;
+              }
+              enable(w) {
+                this._inertiaOptions = w || {}, this._mousePan.enable(), this._touchPan.enable(), this._el.classList.add("maplibregl-touch-drag-pan");
+              }
+              disable() {
+                this._mousePan.disable(), this._touchPan.disable(), this._el.classList.remove("maplibregl-touch-drag-pan");
+              }
+              isEnabled() {
+                return this._mousePan.isEnabled() && this._touchPan.isEnabled();
+              }
+              isActive() {
+                return this._mousePan.isActive() || this._touchPan.isActive();
+              }
+            }
+            class Nn {
+              constructor(w, B, Q) {
+                this._pitchWithRotate = w.pitchWithRotate, this._mouseRotate = B, this._mousePitch = Q;
+              }
+              enable() {
+                this._mouseRotate.enable(), this._pitchWithRotate && this._mousePitch.enable();
+              }
+              disable() {
+                this._mouseRotate.disable(), this._mousePitch.disable();
+              }
+              isEnabled() {
+                return this._mouseRotate.isEnabled() && (!this._pitchWithRotate || this._mousePitch.isEnabled());
+              }
+              isActive() {
+                return this._mouseRotate.isActive() || this._mousePitch.isActive();
+              }
+            }
+            class Yi {
+              constructor(w, B, Q, ee) {
+                this._el = w, this._touchZoom = B, this._touchRotate = Q, this._tapDragZoom = ee, this._rotationDisabled = false, this._enabled = true;
+              }
+              enable(w) {
+                this._touchZoom.enable(w), this._rotationDisabled || this._touchRotate.enable(w), this._tapDragZoom.enable(), this._el.classList.add("maplibregl-touch-zoom-rotate");
+              }
+              disable() {
+                this._touchZoom.disable(), this._touchRotate.disable(), this._tapDragZoom.disable(), this._el.classList.remove("maplibregl-touch-zoom-rotate");
+              }
+              isEnabled() {
+                return this._touchZoom.isEnabled() && (this._rotationDisabled || this._touchRotate.isEnabled()) && this._tapDragZoom.isEnabled();
+              }
+              isActive() {
+                return this._touchZoom.isActive() || this._touchRotate.isActive() || this._tapDragZoom.isActive();
+              }
+              disableRotation() {
+                this._rotationDisabled = true, this._touchRotate.disable();
+              }
+              enableRotation() {
+                this._rotationDisabled = false, this._touchZoom.isEnabled() && this._touchRotate.enable();
+              }
+            }
+            class Qi {
+              constructor(w, B) {
+                this._bypassKey = navigator.userAgent.indexOf("Mac") !== -1 ? "metaKey" : "ctrlKey", this._map = w, this._options = B, this._enabled = false;
+              }
+              isActive() {
+                return false;
+              }
+              reset() {
+              }
+              _setupUI() {
+                if (this._container) return;
+                let w = this._map.getCanvasContainer();
+                w.classList.add("maplibregl-cooperative-gestures"), this._container = c.create("div", "maplibregl-cooperative-gesture-screen", w);
+                let B = this._map._getUIString("CooperativeGesturesHandler.WindowsHelpText");
+                this._bypassKey === "metaKey" && (B = this._map._getUIString("CooperativeGesturesHandler.MacHelpText"));
+                let Q = this._map._getUIString("CooperativeGesturesHandler.MobileHelpText"), ee = document.createElement("div");
+                ee.className = "maplibregl-desktop-message", ee.textContent = B, this._container.appendChild(ee);
+                let le = document.createElement("div");
+                le.className = "maplibregl-mobile-message", le.textContent = Q, this._container.appendChild(le), this._container.setAttribute("aria-hidden", "true");
+              }
+              _destroyUI() {
+                this._container && (c.remove(this._container), this._map.getCanvasContainer().classList.remove("maplibregl-cooperative-gestures")), delete this._container;
+              }
+              enable() {
+                this._setupUI(), this._enabled = true;
+              }
+              disable() {
+                this._enabled = false, this._destroyUI();
+              }
+              isEnabled() {
+                return this._enabled;
+              }
+              isBypassed(w) {
+                return w[this._bypassKey];
+              }
+              notifyGestureBlocked(w, B) {
+                this._enabled && (this._map.fire(new a.k("cooperativegestureprevented", { gestureType: w, originalEvent: B })), this._container.classList.add("maplibregl-show"), setTimeout(() => {
+                  this._container.classList.remove("maplibregl-show");
+                }, 100));
+              }
+            }
+            let on = (ue) => ue.zoom || ue.drag || ue.pitch || ue.rotate;
+            class Fi extends a.k {
+            }
+            function Qn(ue) {
+              return ue.panDelta && ue.panDelta.mag() || ue.zoomDelta || ue.bearingDelta || ue.pitchDelta;
+            }
+            class Ca {
+              constructor(w, B) {
+                this.handleWindowEvent = (ee) => {
+                  this.handleEvent(ee, `${ee.type}Window`);
+                }, this.handleEvent = (ee, le) => {
+                  if (ee.type === "blur") return void this.stop(true);
+                  this._updatingCamera = true;
+                  let Oe = ee.type === "renderFrame" ? void 0 : ee, Ze = { needsRenderFrame: false }, st = {}, Tt = {}, Yt = ee.touches, Kt = Yt ? this._getMapTouches(Yt) : void 0, xr = Kt ? c.touchPos(this._map.getCanvas(), Kt) : c.mousePos(this._map.getCanvas(), ee);
+                  for (let { handlerName: be, handler: Re, allowed: qe } of this._handlers) {
+                    if (!Re.isEnabled()) continue;
+                    let et;
+                    this._blockedByActive(Tt, qe, be) ? Re.reset() : Re[le || ee.type] && (et = Re[le || ee.type](ee, xr, Kt), this.mergeHandlerResult(Ze, st, et, be, Oe), et && et.needsRenderFrame && this._triggerRenderFrame()), (et || Re.isActive()) && (Tt[be] = Re);
+                  }
+                  let Ir = {};
+                  for (let be in this._previousActiveHandlers) Tt[be] || (Ir[be] = Oe);
+                  this._previousActiveHandlers = Tt, (Object.keys(Ir).length || Qn(Ze)) && (this._changes.push([Ze, st, Ir]), this._triggerRenderFrame()), (Object.keys(Tt).length || Qn(Ze)) && this._map._stop(true), this._updatingCamera = false;
+                  let { cameraAnimation: ve } = Ze;
+                  ve && (this._inertia.clear(), this._fireEvents({}, {}, true), this._changes = [], ve(this._map));
+                }, this._map = w, this._el = this._map.getCanvasContainer(), this._handlers = [], this._handlersById = {}, this._changes = [], this._inertia = new Pf(w), this._bearingSnap = B.bearingSnap, this._previousActiveHandlers = {}, this._eventsInProgress = {}, this._addDefaultHandlers(B);
+                let Q = this._el;
+                this._listeners = [[Q, "touchstart", { passive: true }], [Q, "touchmove", { passive: false }], [Q, "touchend", void 0], [Q, "touchcancel", void 0], [Q, "mousedown", void 0], [Q, "mousemove", void 0], [Q, "mouseup", void 0], [document, "mousemove", { capture: true }], [document, "mouseup", void 0], [Q, "mouseover", void 0], [Q, "mouseout", void 0], [Q, "dblclick", void 0], [Q, "click", void 0], [Q, "keydown", { capture: false }], [Q, "keyup", void 0], [Q, "wheel", { passive: false }], [Q, "contextmenu", void 0], [window, "blur", void 0]];
+                for (let [ee, le, Oe] of this._listeners) c.addEventListener(ee, le, ee === document ? this.handleWindowEvent : this.handleEvent, Oe);
+              }
+              destroy() {
+                for (let [w, B, Q] of this._listeners) c.removeEventListener(w, B, w === document ? this.handleWindowEvent : this.handleEvent, Q);
+              }
+              _addDefaultHandlers(w) {
+                let B = this._map, Q = B.getCanvasContainer();
+                this._add("mapEvent", new If(B, w));
+                let ee = B.boxZoom = new ku(B, w);
+                this._add("boxZoom", ee), w.interactive && w.boxZoom && ee.enable();
+                let le = B.cooperativeGestures = new Qi(B, w.cooperativeGestures);
+                this._add("cooperativeGestures", le), w.cooperativeGestures && le.enable();
+                let Oe = new zc(B), Ze = new Xi(B);
+                B.doubleClickZoom = new ki(Ze, Oe), this._add("tapZoom", Oe), this._add("clickZoom", Ze), w.interactive && w.doubleClickZoom && B.doubleClickZoom.enable();
+                let st = new dn();
+                this._add("tapDragZoom", st);
+                let Tt = B.touchPitch = new Bc(B);
+                this._add("touchPitch", Tt), w.interactive && w.touchPitch && B.touchPitch.enable(w.touchPitch);
+                let Yt = Wl(w), Kt = ah(w);
+                B.dragRotate = new Nn(w, Yt, Kt), this._add("mouseRotate", Yt, ["mousePitch"]), this._add("mousePitch", Kt, ["mouseRotate"]), w.interactive && w.dragRotate && B.dragRotate.enable();
+                let xr = (({ enable: et, clickTolerance: Xe }) => {
+                  let it = new Xu({ checkCorrectEvent: (Ft) => c.mouseButton(Ft) === 0 && !Ft.ctrlKey });
+                  return new Wu({ clickTolerance: Xe, move: (Ft, Ht) => ({ around: Ht, panDelta: Ht.sub(Ft) }), activateOnStart: true, moveStateManager: it, enable: et, assignEvents: Zf });
+                })(w), Ir = new Zu(w, B);
+                B.dragPan = new wn(Q, xr, Ir), this._add("mousePan", xr), this._add("touchPan", Ir, ["touchZoom", "touchRotate"]), w.interactive && w.dragPan && B.dragPan.enable(w.dragPan);
+                let ve = new cf(), be = new vu();
+                B.touchZoomRotate = new Yi(Q, be, ve, st), this._add("touchRotate", ve, ["touchPan", "touchZoom"]), this._add("touchZoom", be, ["touchPan", "touchRotate"]), w.interactive && w.touchZoomRotate && B.touchZoomRotate.enable(w.touchZoomRotate);
+                let Re = B.scrollZoom = new Kr(B, () => this._triggerRenderFrame());
+                this._add("scrollZoom", Re, ["mousePan"]), w.interactive && w.scrollZoom && B.scrollZoom.enable(w.scrollZoom);
+                let qe = B.keyboard = new Xt(B);
+                this._add("keyboard", qe), w.interactive && w.keyboard && B.keyboard.enable(), this._add("blockableMapEvent", new Cs(B));
+              }
+              _add(w, B, Q) {
+                this._handlers.push({ handlerName: w, handler: B, allowed: Q }), this._handlersById[w] = B;
+              }
+              stop(w) {
+                if (!this._updatingCamera) {
+                  for (let { handler: B } of this._handlers) B.reset();
+                  this._inertia.clear(), this._fireEvents({}, {}, w), this._changes = [];
+                }
+              }
+              isActive() {
+                for (let { handler: w } of this._handlers) if (w.isActive()) return true;
+                return false;
+              }
+              isZooming() {
+                return !!this._eventsInProgress.zoom || this._map.scrollZoom.isZooming();
+              }
+              isRotating() {
+                return !!this._eventsInProgress.rotate;
+              }
+              isMoving() {
+                return !!on(this._eventsInProgress) || this.isZooming();
+              }
+              _blockedByActive(w, B, Q) {
+                for (let ee in w) if (ee !== Q && (!B || B.indexOf(ee) < 0)) return true;
+                return false;
+              }
+              _getMapTouches(w) {
+                let B = [];
+                for (let Q of w) this._el.contains(Q.target) && B.push(Q);
+                return B;
+              }
+              mergeHandlerResult(w, B, Q, ee, le) {
+                if (!Q) return;
+                a.e(w, Q);
+                let Oe = { handlerName: ee, originalEvent: Q.originalEvent || le };
+                Q.zoomDelta !== void 0 && (B.zoom = Oe), Q.panDelta !== void 0 && (B.drag = Oe), Q.pitchDelta !== void 0 && (B.pitch = Oe), Q.bearingDelta !== void 0 && (B.rotate = Oe);
+              }
+              _applyChanges() {
+                let w = {}, B = {}, Q = {};
+                for (let [ee, le, Oe] of this._changes) ee.panDelta && (w.panDelta = (w.panDelta || new a.P(0, 0))._add(ee.panDelta)), ee.zoomDelta && (w.zoomDelta = (w.zoomDelta || 0) + ee.zoomDelta), ee.bearingDelta && (w.bearingDelta = (w.bearingDelta || 0) + ee.bearingDelta), ee.pitchDelta && (w.pitchDelta = (w.pitchDelta || 0) + ee.pitchDelta), ee.around !== void 0 && (w.around = ee.around), ee.pinchAround !== void 0 && (w.pinchAround = ee.pinchAround), ee.noInertia && (w.noInertia = ee.noInertia), a.e(B, le), a.e(Q, Oe);
+                this._updateMapTransform(w, B, Q), this._changes = [];
+              }
+              _updateMapTransform(w, B, Q) {
+                let ee = this._map, le = ee._getTransformForUpdate(), Oe = ee.terrain;
+                if (!(Qn(w) || Oe && this._terrainMovement)) return this._fireEvents(B, Q, true);
+                let { panDelta: Ze, zoomDelta: st, bearingDelta: Tt, pitchDelta: Yt, around: Kt, pinchAround: xr } = w;
+                xr !== void 0 && (Kt = xr), ee._stop(true), Kt = Kt || ee.transform.centerPoint;
+                let Ir = le.pointLocation(Ze ? Kt.sub(Ze) : Kt);
+                Tt && (le.bearing += Tt), Yt && (le.pitch += Yt), st && (le.zoom += st), Oe ? this._terrainMovement || !B.drag && !B.zoom ? B.drag && this._terrainMovement ? le.center = le.pointLocation(le.centerPoint.sub(Ze)) : le.setLocationAtPoint(Ir, Kt) : (this._terrainMovement = true, this._map._elevationFreeze = true, le.setLocationAtPoint(Ir, Kt)) : le.setLocationAtPoint(Ir, Kt), ee._applyUpdatedTransform(le), this._map._update(), w.noInertia || this._inertia.record(w), this._fireEvents(B, Q, true);
+              }
+              _fireEvents(w, B, Q) {
+                let ee = on(this._eventsInProgress), le = on(w), Oe = {};
+                for (let Kt in w) {
+                  let { originalEvent: xr } = w[Kt];
+                  this._eventsInProgress[Kt] || (Oe[`${Kt}start`] = xr), this._eventsInProgress[Kt] = w[Kt];
+                }
+                !ee && le && this._fireEvent("movestart", le.originalEvent);
+                for (let Kt in Oe) this._fireEvent(Kt, Oe[Kt]);
+                le && this._fireEvent("move", le.originalEvent);
+                for (let Kt in w) {
+                  let { originalEvent: xr } = w[Kt];
+                  this._fireEvent(Kt, xr);
+                }
+                let Ze = {}, st;
+                for (let Kt in this._eventsInProgress) {
+                  let { handlerName: xr, originalEvent: Ir } = this._eventsInProgress[Kt];
+                  this._handlersById[xr].isActive() || (delete this._eventsInProgress[Kt], st = B[xr] || Ir, Ze[`${Kt}end`] = st);
+                }
+                for (let Kt in Ze) this._fireEvent(Kt, Ze[Kt]);
+                let Tt = on(this._eventsInProgress), Yt = (ee || le) && !Tt;
+                if (Yt && this._terrainMovement) {
+                  this._map._elevationFreeze = false, this._terrainMovement = false;
+                  let Kt = this._map._getTransformForUpdate();
+                  Kt.recalculateZoom(this._map.terrain), this._map._applyUpdatedTransform(Kt);
+                }
+                if (Q && Yt) {
+                  this._updatingCamera = true;
+                  let Kt = this._inertia._onMoveEnd(this._map.dragPan._inertiaOptions), xr = (Ir) => Ir !== 0 && -this._bearingSnap < Ir && Ir < this._bearingSnap;
+                  !Kt || !Kt.essential && u.prefersReducedMotion ? (this._map.fire(new a.k("moveend", { originalEvent: st })), xr(this._map.getBearing()) && this._map.resetNorth()) : (xr(Kt.bearing || this._map.getBearing()) && (Kt.bearing = 0), Kt.freezeElevation = true, this._map.easeTo(Kt, { originalEvent: st })), this._updatingCamera = false;
+                }
+              }
+              _fireEvent(w, B) {
+                this._map.fire(new a.k(w, B ? { originalEvent: B } : {}));
+              }
+              _requestFrame() {
+                return this._map.triggerRepaint(), this._map._renderTaskQueue.add((w) => {
+                  delete this._frameId, this.handleEvent(new Fi("renderFrame", { timeStamp: w })), this._applyChanges();
+                });
+              }
+              _triggerRenderFrame() {
+                this._frameId === void 0 && (this._frameId = this._requestFrame());
+              }
+            }
+            class Ra extends a.E {
+              constructor(w, B) {
+                super(), this._renderFrameCallback = () => {
+                  let Q = Math.min((u.now() - this._easeStart) / this._easeOptions.duration, 1);
+                  this._onEaseFrame(this._easeOptions.easing(Q)), Q < 1 && this._easeFrameId ? this._easeFrameId = this._requestRenderFrame(this._renderFrameCallback) : this.stop();
+                }, this._moving = false, this._zooming = false, this.transform = w, this._bearingSnap = B.bearingSnap, this.on("moveend", () => {
+                  delete this._requestedCameraState;
+                });
+              }
+              getCenter() {
+                return new a.N(this.transform.center.lng, this.transform.center.lat);
+              }
+              setCenter(w, B) {
+                return this.jumpTo({ center: w }, B);
+              }
+              panBy(w, B, Q) {
+                return w = a.P.convert(w).mult(-1), this.panTo(this.transform.center, a.e({ offset: w }, B), Q);
+              }
+              panTo(w, B, Q) {
+                return this.easeTo(a.e({ center: w }, B), Q);
+              }
+              getZoom() {
+                return this.transform.zoom;
+              }
+              setZoom(w, B) {
+                return this.jumpTo({ zoom: w }, B), this;
+              }
+              zoomTo(w, B, Q) {
+                return this.easeTo(a.e({ zoom: w }, B), Q);
+              }
+              zoomIn(w, B) {
+                return this.zoomTo(this.getZoom() + 1, w, B), this;
+              }
+              zoomOut(w, B) {
+                return this.zoomTo(this.getZoom() - 1, w, B), this;
+              }
+              getBearing() {
+                return this.transform.bearing;
+              }
+              setBearing(w, B) {
+                return this.jumpTo({ bearing: w }, B), this;
+              }
+              getPadding() {
+                return this.transform.padding;
+              }
+              setPadding(w, B) {
+                return this.jumpTo({ padding: w }, B), this;
+              }
+              rotateTo(w, B, Q) {
+                return this.easeTo(a.e({ bearing: w }, B), Q);
+              }
+              resetNorth(w, B) {
+                return this.rotateTo(0, a.e({ duration: 1e3 }, w), B), this;
+              }
+              resetNorthPitch(w, B) {
+                return this.easeTo(a.e({ bearing: 0, pitch: 0, duration: 1e3 }, w), B), this;
+              }
+              snapToNorth(w, B) {
+                return Math.abs(this.getBearing()) < this._bearingSnap ? this.resetNorth(w, B) : this;
+              }
+              getPitch() {
+                return this.transform.pitch;
+              }
+              setPitch(w, B) {
+                return this.jumpTo({ pitch: w }, B), this;
+              }
+              cameraForBounds(w, B) {
+                w = ce.convert(w).adjustAntiMeridian();
+                let Q = B && B.bearing || 0;
+                return this._cameraForBoxAndBearing(w.getNorthWest(), w.getSouthEast(), Q, B);
+              }
+              _cameraForBoxAndBearing(w, B, Q, ee) {
+                let le = { top: 0, bottom: 0, right: 0, left: 0 };
+                if (typeof (ee = a.e({ padding: le, offset: [0, 0], maxZoom: this.transform.maxZoom }, ee)).padding == "number") {
+                  let Wr = ee.padding;
+                  ee.padding = { top: Wr, bottom: Wr, right: Wr, left: Wr };
+                }
+                ee.padding = a.e(le, ee.padding);
+                let Oe = this.transform, Ze = Oe.padding, st = new ce(w, B), Tt = Oe.project(st.getNorthWest()), Yt = Oe.project(st.getNorthEast()), Kt = Oe.project(st.getSouthEast()), xr = Oe.project(st.getSouthWest()), Ir = a.ba(-Q), ve = Tt.rotate(Ir), be = Yt.rotate(Ir), Re = Kt.rotate(Ir), qe = xr.rotate(Ir), et = new a.P(Math.max(ve.x, be.x, qe.x, Re.x), Math.max(ve.y, be.y, qe.y, Re.y)), Xe = new a.P(Math.min(ve.x, be.x, qe.x, Re.x), Math.min(ve.y, be.y, qe.y, Re.y)), it = et.sub(Xe), Ft = (Oe.width - (Ze.left + Ze.right + ee.padding.left + ee.padding.right)) / it.x, Ht = (Oe.height - (Ze.top + Ze.bottom + ee.padding.top + ee.padding.bottom)) / it.y;
+                if (Ht < 0 || Ft < 0) return void a.w("Map cannot fit within canvas with the given bounds, padding, and/or offset.");
+                let tr = Math.min(Oe.scaleZoom(Oe.scale * Math.min(Ft, Ht)), ee.maxZoom), dr = a.P.convert(ee.offset), Sr = new a.P((ee.padding.left - ee.padding.right) / 2, (ee.padding.top - ee.padding.bottom) / 2).rotate(a.ba(Q)), Or = dr.add(Sr).mult(Oe.scale / Oe.zoomScale(tr));
+                return { center: Oe.unproject(Tt.add(Kt).div(2).sub(Or)), zoom: tr, bearing: Q };
+              }
+              fitBounds(w, B, Q) {
+                return this._fitInternal(this.cameraForBounds(w, B), B, Q);
+              }
+              fitScreenCoordinates(w, B, Q, ee, le) {
+                return this._fitInternal(this._cameraForBoxAndBearing(this.transform.pointLocation(a.P.convert(w)), this.transform.pointLocation(a.P.convert(B)), Q, ee), ee, le);
+              }
+              _fitInternal(w, B, Q) {
+                return w ? (delete (B = a.e(w, B)).padding, B.linear ? this.easeTo(B, Q) : this.flyTo(B, Q)) : this;
+              }
+              jumpTo(w, B) {
+                this.stop();
+                let Q = this._getTransformForUpdate(), ee = false, le = false, Oe = false;
+                return "zoom" in w && Q.zoom !== +w.zoom && (ee = true, Q.zoom = +w.zoom), w.center !== void 0 && (Q.center = a.N.convert(w.center)), "bearing" in w && Q.bearing !== +w.bearing && (le = true, Q.bearing = +w.bearing), "pitch" in w && Q.pitch !== +w.pitch && (Oe = true, Q.pitch = +w.pitch), w.padding == null || Q.isPaddingEqual(w.padding) || (Q.padding = w.padding), this._applyUpdatedTransform(Q), this.fire(new a.k("movestart", B)).fire(new a.k("move", B)), ee && this.fire(new a.k("zoomstart", B)).fire(new a.k("zoom", B)).fire(new a.k("zoomend", B)), le && this.fire(new a.k("rotatestart", B)).fire(new a.k("rotate", B)).fire(new a.k("rotateend", B)), Oe && this.fire(new a.k("pitchstart", B)).fire(new a.k("pitch", B)).fire(new a.k("pitchend", B)), this.fire(new a.k("moveend", B));
+              }
+              calculateCameraOptionsFromTo(w, B, Q, ee = 0) {
+                let le = a.Z.fromLngLat(w, B), Oe = a.Z.fromLngLat(Q, ee), Ze = Oe.x - le.x, st = Oe.y - le.y, Tt = Oe.z - le.z, Yt = Math.hypot(Ze, st, Tt);
+                if (Yt === 0) throw new Error("Can't calculate camera options with same From and To");
+                let Kt = Math.hypot(Ze, st), xr = this.transform.scaleZoom(this.transform.cameraToCenterDistance / Yt / this.transform.tileSize), Ir = 180 * Math.atan2(Ze, -st) / Math.PI, ve = 180 * Math.acos(Kt / Yt) / Math.PI;
+                return ve = Tt < 0 ? 90 - ve : 90 + ve, { center: Oe.toLngLat(), zoom: xr, pitch: ve, bearing: Ir };
+              }
+              easeTo(w, B) {
+                var Q;
+                this._stop(false, w.easeId), ((w = a.e({ offset: [0, 0], duration: 500, easing: a.b9 }, w)).animate === false || !w.essential && u.prefersReducedMotion) && (w.duration = 0);
+                let ee = this._getTransformForUpdate(), le = ee.zoom, Oe = ee.bearing, Ze = ee.pitch, st = ee.padding, Tt = "bearing" in w ? this._normalizeBearing(w.bearing, Oe) : Oe, Yt = "pitch" in w ? +w.pitch : Ze, Kt = "padding" in w ? w.padding : ee.padding, xr = a.P.convert(w.offset), Ir = ee.centerPoint.add(xr), ve = ee.pointLocation(Ir), { center: be, zoom: Re } = ee.getConstrained(a.N.convert(w.center || ve), (Q = w.zoom) !== null && Q !== void 0 ? Q : le);
+                this._normalizeCenter(be, ee);
+                let qe = ee.project(ve), et = ee.project(be).sub(qe), Xe = ee.zoomScale(Re - le), it, Ft;
+                w.around && (it = a.N.convert(w.around), Ft = ee.locationPoint(it));
+                let Ht = { moving: this._moving, zooming: this._zooming, rotating: this._rotating, pitching: this._pitching };
+                return this._zooming = this._zooming || Re !== le, this._rotating = this._rotating || Oe !== Tt, this._pitching = this._pitching || Yt !== Ze, this._padding = !ee.isPaddingEqual(Kt), this._easeId = w.easeId, this._prepareEase(B, w.noMoveStart, Ht), this.terrain && this._prepareElevation(be), this._ease((tr) => {
+                  if (this._zooming && (ee.zoom = a.y.number(le, Re, tr)), this._rotating && (ee.bearing = a.y.number(Oe, Tt, tr)), this._pitching && (ee.pitch = a.y.number(Ze, Yt, tr)), this._padding && (ee.interpolatePadding(st, Kt, tr), Ir = ee.centerPoint.add(xr)), this.terrain && !w.freezeElevation && this._updateElevation(tr), it) ee.setLocationAtPoint(it, Ft);
+                  else {
+                    let dr = ee.zoomScale(ee.zoom - le), Sr = Re > le ? Math.min(2, Xe) : Math.max(0.5, Xe), Or = Math.pow(Sr, 1 - tr), Wr = ee.unproject(qe.add(et.mult(tr * Or)).mult(dr));
+                    ee.setLocationAtPoint(ee.renderWorldCopies ? Wr.wrap() : Wr, Ir);
+                  }
+                  this._applyUpdatedTransform(ee), this._fireMoveEvents(B);
+                }, (tr) => {
+                  this.terrain && w.freezeElevation && this._finalizeElevation(), this._afterEase(B, tr);
+                }, w), this;
+              }
+              _prepareEase(w, B, Q = {}) {
+                this._moving = true, B || Q.moving || this.fire(new a.k("movestart", w)), this._zooming && !Q.zooming && this.fire(new a.k("zoomstart", w)), this._rotating && !Q.rotating && this.fire(new a.k("rotatestart", w)), this._pitching && !Q.pitching && this.fire(new a.k("pitchstart", w));
+              }
+              _prepareElevation(w) {
+                this._elevationCenter = w, this._elevationStart = this.transform.elevation, this._elevationTarget = this.terrain.getElevationForLngLatZoom(w, this.transform.tileZoom), this._elevationFreeze = true;
+              }
+              _updateElevation(w) {
+                this.transform.minElevationForCurrentTile = this.terrain.getMinTileElevationForLngLatZoom(this._elevationCenter, this.transform.tileZoom);
+                let B = this.terrain.getElevationForLngLatZoom(this._elevationCenter, this.transform.tileZoom);
+                if (w < 1 && B !== this._elevationTarget) {
+                  let Q = this._elevationTarget - this._elevationStart;
+                  this._elevationStart += w * (Q - (B - (Q * w + this._elevationStart)) / (1 - w)), this._elevationTarget = B;
+                }
+                this.transform.elevation = a.y.number(this._elevationStart, this._elevationTarget, w);
+              }
+              _finalizeElevation() {
+                this._elevationFreeze = false, this.transform.recalculateZoom(this.terrain);
+              }
+              _getTransformForUpdate() {
+                return this.transformCameraUpdate || this.terrain ? (this._requestedCameraState || (this._requestedCameraState = this.transform.clone()), this._requestedCameraState) : this.transform;
+              }
+              _elevateCameraIfInsideTerrain(w) {
+                let B = w.getCameraPosition(), Q = this.terrain.getElevationForLngLatZoom(B.lngLat, w.zoom);
+                if (B.altitude < Q) {
+                  let ee = this.calculateCameraOptionsFromTo(B.lngLat, Q, w.center, w.elevation);
+                  return { pitch: ee.pitch, zoom: ee.zoom };
+                }
+                return {};
+              }
+              _applyUpdatedTransform(w) {
+                let B = [];
+                if (this.terrain && B.push((ee) => this._elevateCameraIfInsideTerrain(ee)), this.transformCameraUpdate && B.push((ee) => this.transformCameraUpdate(ee)), !B.length) return;
+                let Q = w.clone();
+                for (let ee of B) {
+                  let le = Q.clone(), { center: Oe, zoom: Ze, pitch: st, bearing: Tt, elevation: Yt } = ee(le);
+                  Oe && (le.center = Oe), Ze !== void 0 && (le.zoom = Ze), st !== void 0 && (le.pitch = st), Tt !== void 0 && (le.bearing = Tt), Yt !== void 0 && (le.elevation = Yt), Q.apply(le);
+                }
+                this.transform.apply(Q);
+              }
+              _fireMoveEvents(w) {
+                this.fire(new a.k("move", w)), this._zooming && this.fire(new a.k("zoom", w)), this._rotating && this.fire(new a.k("rotate", w)), this._pitching && this.fire(new a.k("pitch", w));
+              }
+              _afterEase(w, B) {
+                if (this._easeId && B && this._easeId === B) return;
+                delete this._easeId;
+                let Q = this._zooming, ee = this._rotating, le = this._pitching;
+                this._moving = false, this._zooming = false, this._rotating = false, this._pitching = false, this._padding = false, Q && this.fire(new a.k("zoomend", w)), ee && this.fire(new a.k("rotateend", w)), le && this.fire(new a.k("pitchend", w)), this.fire(new a.k("moveend", w));
+              }
+              flyTo(w, B) {
+                var Q;
+                if (!w.essential && u.prefersReducedMotion) {
+                  let Cn = a.M(w, ["center", "zoom", "bearing", "pitch", "around"]);
+                  return this.jumpTo(Cn, B);
+                }
+                this.stop(), w = a.e({ offset: [0, 0], speed: 1.2, curve: 1.42, easing: a.b9 }, w);
+                let ee = this._getTransformForUpdate(), le = ee.zoom, Oe = ee.bearing, Ze = ee.pitch, st = ee.padding, Tt = "bearing" in w ? this._normalizeBearing(w.bearing, Oe) : Oe, Yt = "pitch" in w ? +w.pitch : Ze, Kt = "padding" in w ? w.padding : ee.padding, xr = a.P.convert(w.offset), Ir = ee.centerPoint.add(xr), ve = ee.pointLocation(Ir), { center: be, zoom: Re } = ee.getConstrained(a.N.convert(w.center || ve), (Q = w.zoom) !== null && Q !== void 0 ? Q : le);
+                this._normalizeCenter(be, ee);
+                let qe = ee.zoomScale(Re - le), et = ee.project(ve), Xe = ee.project(be).sub(et), it = w.curve, Ft = Math.max(ee.width, ee.height), Ht = Ft / qe, tr = Xe.mag();
+                if ("minZoom" in w) {
+                  let Cn = a.ac(Math.min(w.minZoom, le, Re), ee.minZoom, ee.maxZoom), Kn = Ft / ee.zoomScale(Cn - le);
+                  it = Math.sqrt(Kn / tr * 2);
+                }
+                let dr = it * it;
+                function Sr(Cn) {
+                  let Kn = (Ht * Ht - Ft * Ft + (Cn ? -1 : 1) * dr * dr * tr * tr) / (2 * (Cn ? Ht : Ft) * dr * tr);
+                  return Math.log(Math.sqrt(Kn * Kn + 1) - Kn);
+                }
+                function Or(Cn) {
+                  return (Math.exp(Cn) - Math.exp(-Cn)) / 2;
+                }
+                function Wr(Cn) {
+                  return (Math.exp(Cn) + Math.exp(-Cn)) / 2;
+                }
+                let ni = Sr(false), Pi = function(Cn) {
+                  return Wr(ni) / Wr(ni + it * Cn);
+                }, cn = function(Cn) {
+                  return Ft * ((Wr(ni) * (Or(Kn = ni + it * Cn) / Wr(Kn)) - Or(ni)) / dr) / tr;
+                  var Kn;
+                }, ln = (Sr(true) - ni) / it;
+                if (Math.abs(tr) < 1e-6 || !isFinite(ln)) {
+                  if (Math.abs(Ft - Ht) < 1e-6) return this.easeTo(w, B);
+                  let Cn = Ht < Ft ? -1 : 1;
+                  ln = Math.abs(Math.log(Ht / Ft)) / it, cn = () => 0, Pi = (Kn) => Math.exp(Cn * it * Kn);
+                }
+                return w.duration = "duration" in w ? +w.duration : 1e3 * ln / ("screenSpeed" in w ? +w.screenSpeed / it : +w.speed), w.maxDuration && w.duration > w.maxDuration && (w.duration = 0), this._zooming = true, this._rotating = Oe !== Tt, this._pitching = Yt !== Ze, this._padding = !ee.isPaddingEqual(Kt), this._prepareEase(B, false), this.terrain && this._prepareElevation(be), this._ease((Cn) => {
+                  let Kn = Cn * ln, Aa = 1 / Pi(Kn);
+                  ee.zoom = Cn === 1 ? Re : le + ee.scaleZoom(Aa), this._rotating && (ee.bearing = a.y.number(Oe, Tt, Cn)), this._pitching && (ee.pitch = a.y.number(Ze, Yt, Cn)), this._padding && (ee.interpolatePadding(st, Kt, Cn), Ir = ee.centerPoint.add(xr)), this.terrain && !w.freezeElevation && this._updateElevation(Cn);
+                  let fa = Cn === 1 ? be : ee.unproject(et.add(Xe.mult(cn(Kn))).mult(Aa));
+                  ee.setLocationAtPoint(ee.renderWorldCopies ? fa.wrap() : fa, Ir), this._applyUpdatedTransform(ee), this._fireMoveEvents(B);
+                }, () => {
+                  this.terrain && w.freezeElevation && this._finalizeElevation(), this._afterEase(B);
+                }, w), this;
+              }
+              isEasing() {
+                return !!this._easeFrameId;
+              }
+              stop() {
+                return this._stop();
+              }
+              _stop(w, B) {
+                var Q;
+                if (this._easeFrameId && (this._cancelRenderFrame(this._easeFrameId), delete this._easeFrameId, delete this._onEaseFrame), this._onEaseEnd) {
+                  let ee = this._onEaseEnd;
+                  delete this._onEaseEnd, ee.call(this, B);
+                }
+                return w || (Q = this.handlers) === null || Q === void 0 || Q.stop(false), this;
+              }
+              _ease(w, B, Q) {
+                Q.animate === false || Q.duration === 0 ? (w(1), B()) : (this._easeStart = u.now(), this._easeOptions = Q, this._onEaseFrame = w, this._onEaseEnd = B, this._easeFrameId = this._requestRenderFrame(this._renderFrameCallback));
+              }
+              _normalizeBearing(w, B) {
+                w = a.b3(w, -180, 180);
+                let Q = Math.abs(w - B);
+                return Math.abs(w - 360 - B) < Q && (w -= 360), Math.abs(w + 360 - B) < Q && (w += 360), w;
+              }
+              _normalizeCenter(w, B) {
+                if (!B.renderWorldCopies || B.lngRange) return;
+                let Q = w.lng - B.center.lng;
+                w.lng += Q > 180 ? -360 : Q < -180 ? 360 : 0;
+              }
+              queryTerrainElevation(w) {
+                return this.terrain ? this.terrain.getElevationForLngLatZoom(a.N.convert(w), this.transform.tileZoom) - this.transform.elevation : null;
+              }
+            }
+            let La = { compact: true, customAttribution: '<a href="https://maplibre.org/" target="_blank">MapLibre</a>' };
+            class Na {
+              constructor(w = La) {
+                this._toggleAttribution = () => {
+                  this._container.classList.contains("maplibregl-compact") && (this._container.classList.contains("maplibregl-compact-show") ? (this._container.setAttribute("open", ""), this._container.classList.remove("maplibregl-compact-show")) : (this._container.classList.add("maplibregl-compact-show"), this._container.removeAttribute("open")));
+                }, this._updateData = (B) => {
+                  !B || B.sourceDataType !== "metadata" && B.sourceDataType !== "visibility" && B.dataType !== "style" && B.type !== "terrain" || this._updateAttributions();
+                }, this._updateCompact = () => {
+                  this._map.getCanvasContainer().offsetWidth <= 640 || this._compact ? this._compact === false ? this._container.setAttribute("open", "") : this._container.classList.contains("maplibregl-compact") || this._container.classList.contains("maplibregl-attrib-empty") || (this._container.setAttribute("open", ""), this._container.classList.add("maplibregl-compact", "maplibregl-compact-show")) : (this._container.setAttribute("open", ""), this._container.classList.contains("maplibregl-compact") && this._container.classList.remove("maplibregl-compact", "maplibregl-compact-show"));
+                }, this._updateCompactMinimize = () => {
+                  this._container.classList.contains("maplibregl-compact") && this._container.classList.contains("maplibregl-compact-show") && this._container.classList.remove("maplibregl-compact-show");
+                }, this.options = w;
+              }
+              getDefaultPosition() {
+                return "bottom-right";
+              }
+              onAdd(w) {
+                return this._map = w, this._compact = this.options.compact, this._container = c.create("details", "maplibregl-ctrl maplibregl-ctrl-attrib"), this._compactButton = c.create("summary", "maplibregl-ctrl-attrib-button", this._container), this._compactButton.addEventListener("click", this._toggleAttribution), this._setElementTitle(this._compactButton, "ToggleAttribution"), this._innerContainer = c.create("div", "maplibregl-ctrl-attrib-inner", this._container), this._updateAttributions(), this._updateCompact(), this._map.on("styledata", this._updateData), this._map.on("sourcedata", this._updateData), this._map.on("terrain", this._updateData), this._map.on("resize", this._updateCompact), this._map.on("drag", this._updateCompactMinimize), this._container;
+              }
+              onRemove() {
+                c.remove(this._container), this._map.off("styledata", this._updateData), this._map.off("sourcedata", this._updateData), this._map.off("terrain", this._updateData), this._map.off("resize", this._updateCompact), this._map.off("drag", this._updateCompactMinimize), this._map = void 0, this._compact = void 0, this._attribHTML = void 0;
+              }
+              _setElementTitle(w, B) {
+                let Q = this._map._getUIString(`AttributionControl.${B}`);
+                w.title = Q, w.setAttribute("aria-label", Q);
+              }
+              _updateAttributions() {
+                if (!this._map.style) return;
+                let w = [];
+                if (this.options.customAttribution && (Array.isArray(this.options.customAttribution) ? w = w.concat(this.options.customAttribution.map((ee) => typeof ee != "string" ? "" : ee)) : typeof this.options.customAttribution == "string" && w.push(this.options.customAttribution)), this._map.style.stylesheet) {
+                  let ee = this._map.style.stylesheet;
+                  this.styleOwner = ee.owner, this.styleId = ee.id;
+                }
+                let B = this._map.style.sourceCaches;
+                for (let ee in B) {
+                  let le = B[ee];
+                  if (le.used || le.usedForTerrain) {
+                    let Oe = le.getSource();
+                    Oe.attribution && w.indexOf(Oe.attribution) < 0 && w.push(Oe.attribution);
+                  }
+                }
+                w = w.filter((ee) => String(ee).trim()), w.sort((ee, le) => ee.length - le.length), w = w.filter((ee, le) => {
+                  for (let Oe = le + 1; Oe < w.length; Oe++) if (w[Oe].indexOf(ee) >= 0) return false;
+                  return true;
+                });
+                let Q = w.join(" | ");
+                Q !== this._attribHTML && (this._attribHTML = Q, w.length ? (this._innerContainer.innerHTML = Q, this._container.classList.remove("maplibregl-attrib-empty")) : this._container.classList.add("maplibregl-attrib-empty"), this._updateCompact(), this._editLink = null);
+              }
+            }
+            class Yn {
+              constructor(w = {}) {
+                this._updateCompact = () => {
+                  let B = this._container.children;
+                  if (B.length) {
+                    let Q = B[0];
+                    this._map.getCanvasContainer().offsetWidth <= 640 || this._compact ? this._compact !== false && Q.classList.add("maplibregl-compact") : Q.classList.remove("maplibregl-compact");
+                  }
+                }, this.options = w;
+              }
+              getDefaultPosition() {
+                return "bottom-left";
+              }
+              onAdd(w) {
+                this._map = w, this._compact = this.options && this.options.compact, this._container = c.create("div", "maplibregl-ctrl");
+                let B = c.create("a", "maplibregl-ctrl-logo");
+                return B.target = "_blank", B.rel = "noopener nofollow", B.href = "https://maplibre.org/", B.setAttribute("aria-label", this._map._getUIString("LogoControl.Title")), B.setAttribute("rel", "noopener nofollow"), this._container.appendChild(B), this._container.style.display = "block", this._map.on("resize", this._updateCompact), this._updateCompact(), this._container;
+              }
+              onRemove() {
+                c.remove(this._container), this._map.off("resize", this._updateCompact), this._map = void 0, this._compact = void 0;
+              }
+            }
+            class Dn {
+              constructor() {
+                this._queue = [], this._id = 0, this._cleared = false, this._currentlyRunning = false;
+              }
+              add(w) {
+                let B = ++this._id;
+                return this._queue.push({ callback: w, id: B, cancelled: false }), B;
+              }
+              remove(w) {
+                let B = this._currentlyRunning, Q = B ? this._queue.concat(B) : this._queue;
+                for (let ee of Q) if (ee.id === w) return void (ee.cancelled = true);
+              }
+              run(w = 0) {
+                if (this._currentlyRunning) throw new Error("Attempting to run(), but is already running.");
+                let B = this._currentlyRunning = this._queue;
+                this._queue = [];
+                for (let Q of B) if (!Q.cancelled && (Q.callback(w), this._cleared)) break;
+                this._cleared = false, this._currentlyRunning = false;
+              }
+              clear() {
+                this._currentlyRunning && (this._cleared = true), this._queue = [];
+              }
+            }
+            var Ka = a.Y([{ name: "a_pos3d", type: "Int16", components: 3 }]);
+            class bo extends a.E {
+              constructor(w) {
+                super(), this.sourceCache = w, this._tiles = {}, this._renderableTilesKeys = [], this._sourceTileCache = {}, this.minzoom = 0, this.maxzoom = 22, this.tileSize = 512, this.deltaZoom = 1, w.usedForTerrain = true, w.tileSize = this.tileSize * 2 ** this.deltaZoom;
+              }
+              destruct() {
+                this.sourceCache.usedForTerrain = false, this.sourceCache.tileSize = null;
+              }
+              update(w, B) {
+                this.sourceCache.update(w, B), this._renderableTilesKeys = [];
+                let Q = {};
+                for (let ee of w.coveringTiles({ tileSize: this.tileSize, minzoom: this.minzoom, maxzoom: this.maxzoom, reparseOverscaled: false, terrain: B })) Q[ee.key] = true, this._renderableTilesKeys.push(ee.key), this._tiles[ee.key] || (ee.posMatrix = new Float64Array(16), a.aP(ee.posMatrix, 0, a.X, 0, a.X, 0, 1), this._tiles[ee.key] = new Gt(ee, this.tileSize));
+                for (let ee in this._tiles) Q[ee] || delete this._tiles[ee];
+              }
+              freeRtt(w) {
+                for (let B in this._tiles) {
+                  let Q = this._tiles[B];
+                  (!w || Q.tileID.equals(w) || Q.tileID.isChildOf(w) || w.isChildOf(Q.tileID)) && (Q.rtt = []);
+                }
+              }
+              getRenderableTiles() {
+                return this._renderableTilesKeys.map((w) => this.getTileByID(w));
+              }
+              getTileByID(w) {
+                return this._tiles[w];
+              }
+              getTerrainCoords(w) {
+                let B = {};
+                for (let Q of this._renderableTilesKeys) {
+                  let ee = this._tiles[Q].tileID;
+                  if (ee.canonical.equals(w.canonical)) {
+                    let le = w.clone();
+                    le.posMatrix = new Float64Array(16), a.aP(le.posMatrix, 0, a.X, 0, a.X, 0, 1), B[Q] = le;
+                  } else if (ee.canonical.isChildOf(w.canonical)) {
+                    let le = w.clone();
+                    le.posMatrix = new Float64Array(16);
+                    let Oe = ee.canonical.z - w.canonical.z, Ze = ee.canonical.x - (ee.canonical.x >> Oe << Oe), st = ee.canonical.y - (ee.canonical.y >> Oe << Oe), Tt = a.X >> Oe;
+                    a.aP(le.posMatrix, 0, Tt, 0, Tt, 0, 1), a.J(le.posMatrix, le.posMatrix, [-Ze * Tt, -st * Tt, 0]), B[Q] = le;
+                  } else if (w.canonical.isChildOf(ee.canonical)) {
+                    let le = w.clone();
+                    le.posMatrix = new Float64Array(16);
+                    let Oe = w.canonical.z - ee.canonical.z, Ze = w.canonical.x - (w.canonical.x >> Oe << Oe), st = w.canonical.y - (w.canonical.y >> Oe << Oe), Tt = a.X >> Oe;
+                    a.aP(le.posMatrix, 0, a.X, 0, a.X, 0, 1), a.J(le.posMatrix, le.posMatrix, [Ze * Tt, st * Tt, 0]), a.K(le.posMatrix, le.posMatrix, [1 / 2 ** Oe, 1 / 2 ** Oe, 0]), B[Q] = le;
+                  }
+                }
+                return B;
+              }
+              getSourceTile(w, B) {
+                let Q = this.sourceCache._source, ee = w.overscaledZ - this.deltaZoom;
+                if (ee > Q.maxzoom && (ee = Q.maxzoom), ee < Q.minzoom) return null;
+                this._sourceTileCache[w.key] || (this._sourceTileCache[w.key] = w.scaledTo(ee).key);
+                let le = this.sourceCache.getTileByID(this._sourceTileCache[w.key]);
+                if ((!le || !le.dem) && B) for (; ee >= Q.minzoom && (!le || !le.dem); ) le = this.sourceCache.getTileByID(w.scaledTo(ee--).key);
+                return le;
+              }
+              tilesAfterTime(w = Date.now()) {
+                return Object.values(this._tiles).filter((B) => B.timeAdded >= w);
+              }
+            }
+            class Zo {
+              constructor(w, B, Q) {
+                this.painter = w, this.sourceCache = new bo(B), this.options = Q, this.exaggeration = typeof Q.exaggeration == "number" ? Q.exaggeration : 1, this.qualityFactor = 2, this.meshSize = 128, this._demMatrixCache = {}, this.coordsIndex = [], this._coordsTextureSize = 1024;
+              }
+              getDEMElevation(w, B, Q, ee = a.X) {
+                var le;
+                if (!(B >= 0 && B < ee && Q >= 0 && Q < ee)) return 0;
+                let Oe = this.getTerrainData(w), Ze = (le = Oe.tile) === null || le === void 0 ? void 0 : le.dem;
+                if (!Ze) return 0;
+                let st = function(ve, be, Re) {
+                  var qe = be[0], et = be[1];
+                  return ve[0] = Re[0] * qe + Re[4] * et + Re[12], ve[1] = Re[1] * qe + Re[5] * et + Re[13], ve;
+                }([], [B / ee * a.X, Q / ee * a.X], Oe.u_terrain_matrix), Tt = [st[0] * Ze.dim, st[1] * Ze.dim], Yt = Math.floor(Tt[0]), Kt = Math.floor(Tt[1]), xr = Tt[0] - Yt, Ir = Tt[1] - Kt;
+                return Ze.get(Yt, Kt) * (1 - xr) * (1 - Ir) + Ze.get(Yt + 1, Kt) * xr * (1 - Ir) + Ze.get(Yt, Kt + 1) * (1 - xr) * Ir + Ze.get(Yt + 1, Kt + 1) * xr * Ir;
+              }
+              getElevationForLngLatZoom(w, B) {
+                if (!a.bb(B, w.wrap())) return 0;
+                let { tileID: Q, mercatorX: ee, mercatorY: le } = this._getOverscaledTileIDFromLngLatZoom(w, B);
+                return this.getElevation(Q, ee % a.X, le % a.X, a.X);
+              }
+              getElevation(w, B, Q, ee = a.X) {
+                return this.getDEMElevation(w, B, Q, ee) * this.exaggeration;
+              }
+              getTerrainData(w) {
+                if (!this._emptyDemTexture) {
+                  let ee = this.painter.context, le = new a.R({ width: 1, height: 1 }, new Uint8Array(4));
+                  this._emptyDepthTexture = new g(ee, le, ee.gl.RGBA, { premultiply: false }), this._emptyDemUnpack = [0, 0, 0, 0], this._emptyDemTexture = new g(ee, new a.R({ width: 1, height: 1 }), ee.gl.RGBA, { premultiply: false }), this._emptyDemTexture.bind(ee.gl.NEAREST, ee.gl.CLAMP_TO_EDGE), this._emptyDemMatrix = a.an([]);
+                }
+                let B = this.sourceCache.getSourceTile(w, true);
+                if (B && B.dem && (!B.demTexture || B.needsTerrainPrepare)) {
+                  let ee = this.painter.context;
+                  B.demTexture = this.painter.getTileTexture(B.dem.stride), B.demTexture ? B.demTexture.update(B.dem.getPixels(), { premultiply: false }) : B.demTexture = new g(ee, B.dem.getPixels(), ee.gl.RGBA, { premultiply: false }), B.demTexture.bind(ee.gl.NEAREST, ee.gl.CLAMP_TO_EDGE), B.needsTerrainPrepare = false;
+                }
+                let Q = B && B + B.tileID.key + w.key;
+                if (Q && !this._demMatrixCache[Q]) {
+                  let ee = this.sourceCache.sourceCache._source.maxzoom, le = w.canonical.z - B.tileID.canonical.z;
+                  w.overscaledZ > w.canonical.z && (w.canonical.z >= ee ? le = w.canonical.z - ee : a.w("cannot calculate elevation if elevation maxzoom > source.maxzoom"));
+                  let Oe = w.canonical.x - (w.canonical.x >> le << le), Ze = w.canonical.y - (w.canonical.y >> le << le), st = a.bc(new Float64Array(16), [1 / (a.X << le), 1 / (a.X << le), 0]);
+                  a.J(st, st, [Oe * a.X, Ze * a.X, 0]), this._demMatrixCache[w.key] = { matrix: st, coord: w };
+                }
+                return { u_depth: 2, u_terrain: 3, u_terrain_dim: B && B.dem && B.dem.dim || 1, u_terrain_matrix: Q ? this._demMatrixCache[w.key].matrix : this._emptyDemMatrix, u_terrain_unpack: B && B.dem && B.dem.getUnpackVector() || this._emptyDemUnpack, u_terrain_exaggeration: this.exaggeration, texture: (B && B.demTexture || this._emptyDemTexture).texture, depthTexture: (this._fboDepthTexture || this._emptyDepthTexture).texture, tile: B };
+              }
+              getFramebuffer(w) {
+                let B = this.painter, Q = B.width / devicePixelRatio, ee = B.height / devicePixelRatio;
+                return !this._fbo || this._fbo.width === Q && this._fbo.height === ee || (this._fbo.destroy(), this._fboCoordsTexture.destroy(), this._fboDepthTexture.destroy(), delete this._fbo, delete this._fboDepthTexture, delete this._fboCoordsTexture), this._fboCoordsTexture || (this._fboCoordsTexture = new g(B.context, { width: Q, height: ee, data: null }, B.context.gl.RGBA, { premultiply: false }), this._fboCoordsTexture.bind(B.context.gl.NEAREST, B.context.gl.CLAMP_TO_EDGE)), this._fboDepthTexture || (this._fboDepthTexture = new g(B.context, { width: Q, height: ee, data: null }, B.context.gl.RGBA, { premultiply: false }), this._fboDepthTexture.bind(B.context.gl.NEAREST, B.context.gl.CLAMP_TO_EDGE)), this._fbo || (this._fbo = B.context.createFramebuffer(Q, ee, true, false), this._fbo.depthAttachment.set(B.context.createRenderbuffer(B.context.gl.DEPTH_COMPONENT16, Q, ee))), this._fbo.colorAttachment.set(w === "coords" ? this._fboCoordsTexture.texture : this._fboDepthTexture.texture), this._fbo;
+              }
+              getCoordsTexture() {
+                let w = this.painter.context;
+                if (this._coordsTexture) return this._coordsTexture;
+                let B = new Uint8Array(this._coordsTextureSize * this._coordsTextureSize * 4);
+                for (let le = 0, Oe = 0; le < this._coordsTextureSize; le++) for (let Ze = 0; Ze < this._coordsTextureSize; Ze++, Oe += 4) B[Oe + 0] = 255 & Ze, B[Oe + 1] = 255 & le, B[Oe + 2] = Ze >> 8 << 4 | le >> 8, B[Oe + 3] = 0;
+                let Q = new a.R({ width: this._coordsTextureSize, height: this._coordsTextureSize }, new Uint8Array(B.buffer)), ee = new g(w, Q, w.gl.RGBA, { premultiply: false });
+                return ee.bind(w.gl.NEAREST, w.gl.CLAMP_TO_EDGE), this._coordsTexture = ee, ee;
+              }
+              pointCoordinate(w) {
+                this.painter.maybeDrawDepthAndCoords(true);
+                let B = new Uint8Array(4), Q = this.painter.context, ee = Q.gl, le = Math.round(w.x * this.painter.pixelRatio / devicePixelRatio), Oe = Math.round(w.y * this.painter.pixelRatio / devicePixelRatio), Ze = Math.round(this.painter.height / devicePixelRatio);
+                Q.bindFramebuffer.set(this.getFramebuffer("coords").framebuffer), ee.readPixels(le, Ze - Oe - 1, 1, 1, ee.RGBA, ee.UNSIGNED_BYTE, B), Q.bindFramebuffer.set(null);
+                let st = B[0] + (B[2] >> 4 << 8), Tt = B[1] + ((15 & B[2]) << 8), Yt = this.coordsIndex[255 - B[3]], Kt = Yt && this.sourceCache.getTileByID(Yt);
+                if (!Kt) return null;
+                let xr = this._coordsTextureSize, Ir = (1 << Kt.tileID.canonical.z) * xr;
+                return new a.Z((Kt.tileID.canonical.x * xr + st) / Ir + Kt.tileID.wrap, (Kt.tileID.canonical.y * xr + Tt) / Ir, this.getElevation(Kt.tileID, st, Tt, xr));
+              }
+              depthAtPoint(w) {
+                let B = new Uint8Array(4), Q = this.painter.context, ee = Q.gl;
+                return Q.bindFramebuffer.set(this.getFramebuffer("depth").framebuffer), ee.readPixels(w.x, this.painter.height / devicePixelRatio - w.y - 1, 1, 1, ee.RGBA, ee.UNSIGNED_BYTE, B), Q.bindFramebuffer.set(null), (B[0] / 16777216 + B[1] / 65536 + B[2] / 256 + B[3]) / 256;
+              }
+              getTerrainMesh() {
+                if (this._mesh) return this._mesh;
+                let w = this.painter.context, B = new a.bd(), Q = new a.aY(), ee = this.meshSize, le = a.X / ee, Oe = ee * ee;
+                for (let Kt = 0; Kt <= ee; Kt++) for (let xr = 0; xr <= ee; xr++) B.emplaceBack(xr * le, Kt * le, 0);
+                for (let Kt = 0; Kt < Oe; Kt += ee + 1) for (let xr = 0; xr < ee; xr++) Q.emplaceBack(xr + Kt, ee + xr + Kt + 1, ee + xr + Kt + 2), Q.emplaceBack(xr + Kt, ee + xr + Kt + 2, xr + Kt + 1);
+                let Ze = B.length, st = Ze + 2 * (ee + 1);
+                for (let Kt of [0, 1]) for (let xr = 0; xr <= ee; xr++) for (let Ir of [0, 1]) B.emplaceBack(xr * le, Kt * a.X, Ir);
+                for (let Kt = 0; Kt < 2 * ee; Kt += 2) Q.emplaceBack(st + Kt, st + Kt + 1, st + Kt + 3), Q.emplaceBack(st + Kt, st + Kt + 3, st + Kt + 2), Q.emplaceBack(Ze + Kt, Ze + Kt + 3, Ze + Kt + 1), Q.emplaceBack(Ze + Kt, Ze + Kt + 2, Ze + Kt + 3);
+                let Tt = B.length, Yt = Tt + 2 * (ee + 1);
+                for (let Kt of [0, 1]) for (let xr = 0; xr <= ee; xr++) for (let Ir of [0, 1]) B.emplaceBack(Kt * a.X, xr * le, Ir);
+                for (let Kt = 0; Kt < 2 * ee; Kt += 2) Q.emplaceBack(Tt + Kt, Tt + Kt + 1, Tt + Kt + 3), Q.emplaceBack(Tt + Kt, Tt + Kt + 3, Tt + Kt + 2), Q.emplaceBack(Yt + Kt, Yt + Kt + 3, Yt + Kt + 1), Q.emplaceBack(Yt + Kt, Yt + Kt + 2, Yt + Kt + 3);
+                return this._mesh = new Eu(w.createVertexBuffer(B, Ka.members), w.createIndexBuffer(Q), a.a0.simpleSegment(0, 0, B.length, Q.length)), this._mesh;
+              }
+              getMeshFrameDelta(w) {
+                return 2 * Math.PI * a.be / Math.pow(2, w) / 5;
+              }
+              getMinTileElevationForLngLatZoom(w, B) {
+                var Q;
+                let { tileID: ee } = this._getOverscaledTileIDFromLngLatZoom(w, B);
+                return (Q = this.getMinMaxElevation(ee).minElevation) !== null && Q !== void 0 ? Q : 0;
+              }
+              getMinMaxElevation(w) {
+                let B = this.getTerrainData(w).tile, Q = { minElevation: null, maxElevation: null };
+                return B && B.dem && (Q.minElevation = B.dem.min * this.exaggeration, Q.maxElevation = B.dem.max * this.exaggeration), Q;
+              }
+              _getOverscaledTileIDFromLngLatZoom(w, B) {
+                let Q = a.Z.fromLngLat(w.wrap()), ee = (1 << B) * a.X, le = Q.x * ee, Oe = Q.y * ee, Ze = Math.floor(le / a.X), st = Math.floor(Oe / a.X);
+                return { tileID: new a.S(B, 0, B, Ze, st), mercatorX: le, mercatorY: Oe };
+              }
+            }
+            class Ss {
+              constructor(w, B, Q) {
+                this._context = w, this._size = B, this._tileSize = Q, this._objects = [], this._recentlyUsed = [], this._stamp = 0;
+              }
+              destruct() {
+                for (let w of this._objects) w.texture.destroy(), w.fbo.destroy();
+              }
+              _createObject(w) {
+                let B = this._context.createFramebuffer(this._tileSize, this._tileSize, true, true), Q = new g(this._context, { width: this._tileSize, height: this._tileSize, data: null }, this._context.gl.RGBA);
+                return Q.bind(this._context.gl.LINEAR, this._context.gl.CLAMP_TO_EDGE), B.depthAttachment.set(this._context.createRenderbuffer(this._context.gl.DEPTH_STENCIL, this._tileSize, this._tileSize)), B.colorAttachment.set(Q.texture), { id: w, fbo: B, texture: Q, stamp: -1, inUse: false };
+              }
+              getObjectForId(w) {
+                return this._objects[w];
+              }
+              useObject(w) {
+                w.inUse = true, this._recentlyUsed = this._recentlyUsed.filter((B) => w.id !== B), this._recentlyUsed.push(w.id);
+              }
+              stampObject(w) {
+                w.stamp = ++this._stamp;
+              }
+              getOrCreateFreeObject() {
+                for (let B of this._recentlyUsed) if (!this._objects[B].inUse) return this._objects[B];
+                if (this._objects.length >= this._size) throw new Error("No free RenderPool available, call freeAllObjects() required!");
+                let w = this._createObject(this._objects.length);
+                return this._objects.push(w), w;
+              }
+              freeObject(w) {
+                w.inUse = false;
+              }
+              freeAllObjects() {
+                for (let w of this._objects) this.freeObject(w);
+              }
+              isFull() {
+                return !(this._objects.length < this._size) && this._objects.some((w) => !w.inUse) === false;
+              }
+            }
+            let as = { background: true, fill: true, line: true, raster: true, hillshade: true };
+            class ws {
+              constructor(w, B) {
+                this.painter = w, this.terrain = B, this.pool = new Ss(w.context, 30, B.sourceCache.tileSize * B.qualityFactor);
+              }
+              destruct() {
+                this.pool.destruct();
+              }
+              getTexture(w) {
+                return this.pool.getObjectForId(w.rtt[this._stacks.length - 1].id).texture;
+              }
+              prepareForRender(w, B) {
+                this._stacks = [], this._prevType = null, this._rttTiles = [], this._renderableTiles = this.terrain.sourceCache.getRenderableTiles(), this._renderableLayerIds = w._order.filter((Q) => !w._layers[Q].isHidden(B)), this._coordsDescendingInv = {};
+                for (let Q in w.sourceCaches) {
+                  this._coordsDescendingInv[Q] = {};
+                  let ee = w.sourceCaches[Q].getVisibleCoordinates();
+                  for (let le of ee) {
+                    let Oe = this.terrain.sourceCache.getTerrainCoords(le);
+                    for (let Ze in Oe) this._coordsDescendingInv[Q][Ze] || (this._coordsDescendingInv[Q][Ze] = []), this._coordsDescendingInv[Q][Ze].push(Oe[Ze]);
+                  }
+                }
+                this._coordsDescendingInvStr = {};
+                for (let Q of w._order) {
+                  let ee = w._layers[Q], le = ee.source;
+                  if (as[ee.type] && !this._coordsDescendingInvStr[le]) {
+                    this._coordsDescendingInvStr[le] = {};
+                    for (let Oe in this._coordsDescendingInv[le]) this._coordsDescendingInvStr[le][Oe] = this._coordsDescendingInv[le][Oe].map((Ze) => Ze.key).sort().join();
+                  }
+                }
+                for (let Q of this._renderableTiles) for (let ee in this._coordsDescendingInvStr) {
+                  let le = this._coordsDescendingInvStr[ee][Q.tileID.key];
+                  le && le !== Q.rttCoords[ee] && (Q.rtt = []);
+                }
+              }
+              renderLayer(w) {
+                if (w.isHidden(this.painter.transform.zoom)) return false;
+                let B = w.type, Q = this.painter, ee = this._renderableLayerIds[this._renderableLayerIds.length - 1] === w.id;
+                if (as[B] && (this._prevType && as[this._prevType] || this._stacks.push([]), this._prevType = B, this._stacks[this._stacks.length - 1].push(w.id), !ee)) return true;
+                if (as[this._prevType] || as[B] && ee) {
+                  this._prevType = B;
+                  let le = this._stacks.length - 1, Oe = this._stacks[le] || [];
+                  for (let Ze of this._renderableTiles) {
+                    if (this.pool.isFull() && (js(this.painter, this.terrain, this._rttTiles), this._rttTiles = [], this.pool.freeAllObjects()), this._rttTiles.push(Ze), Ze.rtt[le]) {
+                      let Tt = this.pool.getObjectForId(Ze.rtt[le].id);
+                      if (Tt.stamp === Ze.rtt[le].stamp) {
+                        this.pool.useObject(Tt);
+                        continue;
+                      }
+                    }
+                    let st = this.pool.getOrCreateFreeObject();
+                    this.pool.useObject(st), this.pool.stampObject(st), Ze.rtt[le] = { id: st.id, stamp: st.stamp }, Q.context.bindFramebuffer.set(st.fbo.framebuffer), Q.context.clear({ color: a.aM.transparent, stencil: 0 }), Q.currentStencilSource = void 0;
+                    for (let Tt = 0; Tt < Oe.length; Tt++) {
+                      let Yt = Q.style._layers[Oe[Tt]], Kt = Yt.source ? this._coordsDescendingInv[Yt.source][Ze.tileID.key] : [Ze.tileID];
+                      Q.context.viewport.set([0, 0, st.fbo.width, st.fbo.height]), Q._renderTileClippingMasks(Yt, Kt), Q.renderLayer(Q, Q.style.sourceCaches[Yt.source], Yt, Kt), Yt.source && (Ze.rttCoords[Yt.source] = this._coordsDescendingInvStr[Yt.source][Ze.tileID.key]);
+                    }
+                  }
+                  return js(this.painter, this.terrain, this._rttTiles), this._rttTiles = [], this.pool.freeAllObjects(), as[B];
+                }
+                return false;
+              }
+            }
+            let Ho = { "AttributionControl.ToggleAttribution": "Toggle attribution", "AttributionControl.MapFeedback": "Map feedback", "FullscreenControl.Enter": "Enter fullscreen", "FullscreenControl.Exit": "Exit fullscreen", "GeolocateControl.FindMyLocation": "Find my location", "GeolocateControl.LocationNotAvailable": "Location not available", "LogoControl.Title": "MapLibre logo", "Map.Title": "Map", "Marker.Title": "Map marker", "NavigationControl.ResetBearing": "Reset bearing to north", "NavigationControl.ZoomIn": "Zoom in", "NavigationControl.ZoomOut": "Zoom out", "Popup.Close": "Close popup", "ScaleControl.Feet": "ft", "ScaleControl.Meters": "m", "ScaleControl.Kilometers": "km", "ScaleControl.Miles": "mi", "ScaleControl.NauticalMiles": "nm", "TerrainControl.Enable": "Enable terrain", "TerrainControl.Disable": "Disable terrain", "CooperativeGesturesHandler.WindowsHelpText": "Use Ctrl + scroll to zoom the map", "CooperativeGesturesHandler.MacHelpText": "Use ⌘ + scroll to zoom the map", "CooperativeGesturesHandler.MobileHelpText": "Use two fingers to move the map" }, ml = o, Ws = { hash: false, interactive: true, bearingSnap: 7, attributionControl: La, maplibreLogo: false, failIfMajorPerformanceCaveat: false, preserveDrawingBuffer: false, refreshExpiredTiles: true, scrollZoom: true, minZoom: -2, maxZoom: 22, minPitch: 0, maxPitch: 60, boxZoom: true, dragRotate: true, dragPan: true, keyboard: true, doubleClickZoom: true, touchZoomRotate: true, touchPitch: true, cooperativeGestures: false, trackResize: true, center: [0, 0], zoom: 0, bearing: 0, pitch: 0, renderWorldCopies: true, maxTileCacheSize: null, maxTileCacheZoomLevels: a.a.MAX_TILE_CACHE_ZOOM_LEVELS, transformRequest: null, transformCameraUpdate: null, fadeDuration: 300, crossSourceCollisions: true, clickTolerance: 3, localIdeographFontFamily: "sans-serif", pitchWithRotate: true, validateStyle: true, maxCanvasSize: [4096, 4096], cancelPendingTileRequestsWhileZooming: true }, Ls = (ue) => {
+              ue.touchstart = ue.dragStart, ue.touchmoveWindow = ue.dragMove, ue.touchend = ue.dragEnd;
+            }, va = { showCompass: true, showZoom: true, visualizePitch: false };
+            class no {
+              constructor(w, B, Q = false) {
+                this.mousedown = (Oe) => {
+                  this.startMouse(a.e({}, Oe, { ctrlKey: true, preventDefault: () => Oe.preventDefault() }), c.mousePos(this.element, Oe)), c.addEventListener(window, "mousemove", this.mousemove), c.addEventListener(window, "mouseup", this.mouseup);
+                }, this.mousemove = (Oe) => {
+                  this.moveMouse(Oe, c.mousePos(this.element, Oe));
+                }, this.mouseup = (Oe) => {
+                  this.mouseRotate.dragEnd(Oe), this.mousePitch && this.mousePitch.dragEnd(Oe), this.offTemp();
+                }, this.touchstart = (Oe) => {
+                  Oe.targetTouches.length !== 1 ? this.reset() : (this._startPos = this._lastPos = c.touchPos(this.element, Oe.targetTouches)[0], this.startTouch(Oe, this._startPos), c.addEventListener(window, "touchmove", this.touchmove, { passive: false }), c.addEventListener(window, "touchend", this.touchend));
+                }, this.touchmove = (Oe) => {
+                  Oe.targetTouches.length !== 1 ? this.reset() : (this._lastPos = c.touchPos(this.element, Oe.targetTouches)[0], this.moveTouch(Oe, this._lastPos));
+                }, this.touchend = (Oe) => {
+                  Oe.targetTouches.length === 0 && this._startPos && this._lastPos && this._startPos.dist(this._lastPos) < this._clickTolerance && this.element.click(), delete this._startPos, delete this._lastPos, this.offTemp();
+                }, this.reset = () => {
+                  this.mouseRotate.reset(), this.mousePitch && this.mousePitch.reset(), this.touchRotate.reset(), this.touchPitch && this.touchPitch.reset(), delete this._startPos, delete this._lastPos, this.offTemp();
+                }, this._clickTolerance = 10;
+                let ee = w.dragRotate._mouseRotate.getClickTolerance(), le = w.dragRotate._mousePitch.getClickTolerance();
+                this.element = B, this.mouseRotate = Wl({ clickTolerance: ee, enable: true }), this.touchRotate = (({ enable: Oe, clickTolerance: Ze, bearingDegreesPerPixelMoved: st = 0.8 }) => {
+                  let Tt = new uf();
+                  return new Wu({ clickTolerance: Ze, move: (Yt, Kt) => ({ bearingDelta: (Kt.x - Yt.x) * st }), moveStateManager: Tt, enable: Oe, assignEvents: Ls });
+                })({ clickTolerance: ee, enable: true }), this.map = w, Q && (this.mousePitch = ah({ clickTolerance: le, enable: true }), this.touchPitch = (({ enable: Oe, clickTolerance: Ze, pitchDegreesPerPixelMoved: st = -0.5 }) => {
+                  let Tt = new uf();
+                  return new Wu({ clickTolerance: Ze, move: (Yt, Kt) => ({ pitchDelta: (Kt.y - Yt.y) * st }), moveStateManager: Tt, enable: Oe, assignEvents: Ls });
+                })({ clickTolerance: le, enable: true })), c.addEventListener(B, "mousedown", this.mousedown), c.addEventListener(B, "touchstart", this.touchstart, { passive: false }), c.addEventListener(B, "touchcancel", this.reset);
+              }
+              startMouse(w, B) {
+                this.mouseRotate.dragStart(w, B), this.mousePitch && this.mousePitch.dragStart(w, B), c.disableDrag();
+              }
+              startTouch(w, B) {
+                this.touchRotate.dragStart(w, B), this.touchPitch && this.touchPitch.dragStart(w, B), c.disableDrag();
+              }
+              moveMouse(w, B) {
+                let Q = this.map, { bearingDelta: ee } = this.mouseRotate.dragMove(w, B) || {};
+                if (ee && Q.setBearing(Q.getBearing() + ee), this.mousePitch) {
+                  let { pitchDelta: le } = this.mousePitch.dragMove(w, B) || {};
+                  le && Q.setPitch(Q.getPitch() + le);
+                }
+              }
+              moveTouch(w, B) {
+                let Q = this.map, { bearingDelta: ee } = this.touchRotate.dragMove(w, B) || {};
+                if (ee && Q.setBearing(Q.getBearing() + ee), this.touchPitch) {
+                  let { pitchDelta: le } = this.touchPitch.dragMove(w, B) || {};
+                  le && Q.setPitch(Q.getPitch() + le);
+                }
+              }
+              off() {
+                let w = this.element;
+                c.removeEventListener(w, "mousedown", this.mousedown), c.removeEventListener(w, "touchstart", this.touchstart, { passive: false }), c.removeEventListener(window, "touchmove", this.touchmove, { passive: false }), c.removeEventListener(window, "touchend", this.touchend), c.removeEventListener(w, "touchcancel", this.reset), this.offTemp();
+              }
+              offTemp() {
+                c.enableDrag(), c.removeEventListener(window, "mousemove", this.mousemove), c.removeEventListener(window, "mouseup", this.mouseup), c.removeEventListener(window, "touchmove", this.touchmove, { passive: false }), c.removeEventListener(window, "touchend", this.touchend);
+              }
+            }
+            let ys;
+            function rs(ue, w, B) {
+              let Q = new a.N(ue.lng, ue.lat);
+              if (ue = new a.N(ue.lng, ue.lat), w) {
+                let ee = new a.N(ue.lng - 360, ue.lat), le = new a.N(ue.lng + 360, ue.lat), Oe = B.locationPoint(ue).distSqr(w);
+                B.locationPoint(ee).distSqr(w) < Oe ? ue = ee : B.locationPoint(le).distSqr(w) < Oe && (ue = le);
+              }
+              for (; Math.abs(ue.lng - B.center.lng) > 180; ) {
+                let ee = B.locationPoint(ue);
+                if (ee.x >= 0 && ee.y >= 0 && ee.x <= B.width && ee.y <= B.height) break;
+                ue.lng > B.center.lng ? ue.lng -= 360 : ue.lng += 360;
+              }
+              return ue.lng !== Q.lng && B.locationPoint(ue).y > B.height / 2 - B.getHorizon() ? ue : Q;
+            }
+            let Ql = { center: "translate(-50%,-50%)", top: "translate(-50%,0)", "top-left": "translate(0,0)", "top-right": "translate(-100%,0)", bottom: "translate(-50%,-100%)", "bottom-left": "translate(0,-100%)", "bottom-right": "translate(-100%,-100%)", left: "translate(0,-50%)", right: "translate(-100%,-50%)" };
+            function Cu(ue, w, B) {
+              let Q = ue.classList;
+              for (let ee in Ql) Q.remove(`maplibregl-${B}-anchor-${ee}`);
+              Q.add(`maplibregl-${B}-anchor-${w}`);
+            }
+            class Yu extends a.E {
+              constructor(w) {
+                if (super(), this._onKeyPress = (B) => {
+                  let Q = B.code, ee = B.charCode || B.keyCode;
+                  Q !== "Space" && Q !== "Enter" && ee !== 32 && ee !== 13 || this.togglePopup();
+                }, this._onMapClick = (B) => {
+                  let Q = B.originalEvent.target, ee = this._element;
+                  this._popup && (Q === ee || ee.contains(Q)) && this.togglePopup();
+                }, this._update = (B) => {
+                  var Q;
+                  if (!this._map) return;
+                  let ee = this._map.loaded() && !this._map.isMoving();
+                  ((B == null ? void 0 : B.type) === "terrain" || (B == null ? void 0 : B.type) === "render" && !ee) && this._map.once("render", this._update), this._lngLat = this._map.transform.renderWorldCopies ? rs(this._lngLat, this._flatPos, this._map.transform) : (Q = this._lngLat) === null || Q === void 0 ? void 0 : Q.wrap(), this._flatPos = this._pos = this._map.project(this._lngLat)._add(this._offset), this._map.terrain && (this._flatPos = this._map.transform.locationPoint(this._lngLat)._add(this._offset));
+                  let le = "";
+                  this._rotationAlignment === "viewport" || this._rotationAlignment === "auto" ? le = `rotateZ(${this._rotation}deg)` : this._rotationAlignment === "map" && (le = `rotateZ(${this._rotation - this._map.getBearing()}deg)`);
+                  let Oe = "";
+                  this._pitchAlignment === "viewport" || this._pitchAlignment === "auto" ? Oe = "rotateX(0deg)" : this._pitchAlignment === "map" && (Oe = `rotateX(${this._map.getPitch()}deg)`), this._subpixelPositioning || B && B.type !== "moveend" || (this._pos = this._pos.round()), c.setTransform(this._element, `${Ql[this._anchor]} translate(${this._pos.x}px, ${this._pos.y}px) ${Oe} ${le}`), u.frameAsync(new AbortController()).then(() => {
+                    this._updateOpacity(B && B.type === "moveend");
+                  }).catch(() => {
+                  });
+                }, this._onMove = (B) => {
+                  if (!this._isDragging) {
+                    let Q = this._clickTolerance || this._map._clickTolerance;
+                    this._isDragging = B.point.dist(this._pointerdownPos) >= Q;
+                  }
+                  this._isDragging && (this._pos = B.point.sub(this._positionDelta), this._lngLat = this._map.unproject(this._pos), this.setLngLat(this._lngLat), this._element.style.pointerEvents = "none", this._state === "pending" && (this._state = "active", this.fire(new a.k("dragstart"))), this.fire(new a.k("drag")));
+                }, this._onUp = () => {
+                  this._element.style.pointerEvents = "auto", this._positionDelta = null, this._pointerdownPos = null, this._isDragging = false, this._map.off("mousemove", this._onMove), this._map.off("touchmove", this._onMove), this._state === "active" && this.fire(new a.k("dragend")), this._state = "inactive";
+                }, this._addDragHandler = (B) => {
+                  this._element.contains(B.originalEvent.target) && (B.preventDefault(), this._positionDelta = B.point.sub(this._pos).add(this._offset), this._pointerdownPos = B.point, this._state = "pending", this._map.on("mousemove", this._onMove), this._map.on("touchmove", this._onMove), this._map.once("mouseup", this._onUp), this._map.once("touchend", this._onUp));
+                }, this._anchor = w && w.anchor || "center", this._color = w && w.color || "#3FB1CE", this._scale = w && w.scale || 1, this._draggable = w && w.draggable || false, this._clickTolerance = w && w.clickTolerance || 0, this._subpixelPositioning = w && w.subpixelPositioning || false, this._isDragging = false, this._state = "inactive", this._rotation = w && w.rotation || 0, this._rotationAlignment = w && w.rotationAlignment || "auto", this._pitchAlignment = w && w.pitchAlignment && w.pitchAlignment !== "auto" ? w.pitchAlignment : this._rotationAlignment, this.setOpacity(), this.setOpacity(w == null ? void 0 : w.opacity, w == null ? void 0 : w.opacityWhenCovered), w && w.element) this._element = w.element, this._offset = a.P.convert(w && w.offset || [0, 0]);
+                else {
+                  this._defaultMarker = true, this._element = c.create("div");
+                  let B = c.createNS("http://www.w3.org/2000/svg", "svg"), Q = 41, ee = 27;
+                  B.setAttributeNS(null, "display", "block"), B.setAttributeNS(null, "height", `${Q}px`), B.setAttributeNS(null, "width", `${ee}px`), B.setAttributeNS(null, "viewBox", `0 0 ${ee} ${Q}`);
+                  let le = c.createNS("http://www.w3.org/2000/svg", "g");
+                  le.setAttributeNS(null, "stroke", "none"), le.setAttributeNS(null, "stroke-width", "1"), le.setAttributeNS(null, "fill", "none"), le.setAttributeNS(null, "fill-rule", "evenodd");
+                  let Oe = c.createNS("http://www.w3.org/2000/svg", "g");
+                  Oe.setAttributeNS(null, "fill-rule", "nonzero");
+                  let Ze = c.createNS("http://www.w3.org/2000/svg", "g");
+                  Ze.setAttributeNS(null, "transform", "translate(3.0, 29.0)"), Ze.setAttributeNS(null, "fill", "#000000");
+                  let st = [{ rx: "10.5", ry: "5.25002273" }, { rx: "10.5", ry: "5.25002273" }, { rx: "9.5", ry: "4.77275007" }, { rx: "8.5", ry: "4.29549936" }, { rx: "7.5", ry: "3.81822308" }, { rx: "6.5", ry: "3.34094679" }, { rx: "5.5", ry: "2.86367051" }, { rx: "4.5", ry: "2.38636864" }];
+                  for (let qe of st) {
+                    let et = c.createNS("http://www.w3.org/2000/svg", "ellipse");
+                    et.setAttributeNS(null, "opacity", "0.04"), et.setAttributeNS(null, "cx", "10.5"), et.setAttributeNS(null, "cy", "5.80029008"), et.setAttributeNS(null, "rx", qe.rx), et.setAttributeNS(null, "ry", qe.ry), Ze.appendChild(et);
+                  }
+                  let Tt = c.createNS("http://www.w3.org/2000/svg", "g");
+                  Tt.setAttributeNS(null, "fill", this._color);
+                  let Yt = c.createNS("http://www.w3.org/2000/svg", "path");
+                  Yt.setAttributeNS(null, "d", "M27,13.5 C27,19.074644 20.250001,27.000002 14.75,34.500002 C14.016665,35.500004 12.983335,35.500004 12.25,34.500002 C6.7499993,27.000002 0,19.222562 0,13.5 C0,6.0441559 6.0441559,0 13.5,0 C20.955844,0 27,6.0441559 27,13.5 Z"), Tt.appendChild(Yt);
+                  let Kt = c.createNS("http://www.w3.org/2000/svg", "g");
+                  Kt.setAttributeNS(null, "opacity", "0.25"), Kt.setAttributeNS(null, "fill", "#000000");
+                  let xr = c.createNS("http://www.w3.org/2000/svg", "path");
+                  xr.setAttributeNS(null, "d", "M13.5,0 C6.0441559,0 0,6.0441559 0,13.5 C0,19.222562 6.7499993,27 12.25,34.5 C13,35.522727 14.016664,35.500004 14.75,34.5 C20.250001,27 27,19.074644 27,13.5 C27,6.0441559 20.955844,0 13.5,0 Z M13.5,1 C20.415404,1 26,6.584596 26,13.5 C26,15.898657 24.495584,19.181431 22.220703,22.738281 C19.945823,26.295132 16.705119,30.142167 13.943359,33.908203 C13.743445,34.180814 13.612715,34.322738 13.5,34.441406 C13.387285,34.322738 13.256555,34.180814 13.056641,33.908203 C10.284481,30.127985 7.4148684,26.314159 5.015625,22.773438 C2.6163816,19.232715 1,15.953538 1,13.5 C1,6.584596 6.584596,1 13.5,1 Z"), Kt.appendChild(xr);
+                  let Ir = c.createNS("http://www.w3.org/2000/svg", "g");
+                  Ir.setAttributeNS(null, "transform", "translate(6.0, 7.0)"), Ir.setAttributeNS(null, "fill", "#FFFFFF");
+                  let ve = c.createNS("http://www.w3.org/2000/svg", "g");
+                  ve.setAttributeNS(null, "transform", "translate(8.0, 8.0)");
+                  let be = c.createNS("http://www.w3.org/2000/svg", "circle");
+                  be.setAttributeNS(null, "fill", "#000000"), be.setAttributeNS(null, "opacity", "0.25"), be.setAttributeNS(null, "cx", "5.5"), be.setAttributeNS(null, "cy", "5.5"), be.setAttributeNS(null, "r", "5.4999962");
+                  let Re = c.createNS("http://www.w3.org/2000/svg", "circle");
+                  Re.setAttributeNS(null, "fill", "#FFFFFF"), Re.setAttributeNS(null, "cx", "5.5"), Re.setAttributeNS(null, "cy", "5.5"), Re.setAttributeNS(null, "r", "5.4999962"), ve.appendChild(be), ve.appendChild(Re), Oe.appendChild(Ze), Oe.appendChild(Tt), Oe.appendChild(Kt), Oe.appendChild(Ir), Oe.appendChild(ve), B.appendChild(Oe), B.setAttributeNS(null, "height", Q * this._scale + "px"), B.setAttributeNS(null, "width", ee * this._scale + "px"), this._element.appendChild(B), this._offset = a.P.convert(w && w.offset || [0, -14]);
+                }
+                if (this._element.classList.add("maplibregl-marker"), this._element.addEventListener("dragstart", (B) => {
+                  B.preventDefault();
+                }), this._element.addEventListener("mousedown", (B) => {
+                  B.preventDefault();
+                }), Cu(this._element, this._anchor, "marker"), w && w.className) for (let B of w.className.split(" ")) this._element.classList.add(B);
+                this._popup = null;
+              }
+              addTo(w) {
+                return this.remove(), this._map = w, this._element.setAttribute("aria-label", w._getUIString("Marker.Title")), w.getCanvasContainer().appendChild(this._element), w.on("move", this._update), w.on("moveend", this._update), w.on("terrain", this._update), this.setDraggable(this._draggable), this._update(), this._map.on("click", this._onMapClick), this;
+              }
+              remove() {
+                return this._opacityTimeout && (clearTimeout(this._opacityTimeout), delete this._opacityTimeout), this._map && (this._map.off("click", this._onMapClick), this._map.off("move", this._update), this._map.off("moveend", this._update), this._map.off("terrain", this._update), this._map.off("mousedown", this._addDragHandler), this._map.off("touchstart", this._addDragHandler), this._map.off("mouseup", this._onUp), this._map.off("touchend", this._onUp), this._map.off("mousemove", this._onMove), this._map.off("touchmove", this._onMove), delete this._map), c.remove(this._element), this._popup && this._popup.remove(), this;
+              }
+              getLngLat() {
+                return this._lngLat;
+              }
+              setLngLat(w) {
+                return this._lngLat = a.N.convert(w), this._pos = null, this._popup && this._popup.setLngLat(this._lngLat), this._update(), this;
+              }
+              getElement() {
+                return this._element;
+              }
+              setPopup(w) {
+                if (this._popup && (this._popup.remove(), this._popup = null, this._element.removeEventListener("keypress", this._onKeyPress), this._originalTabIndex || this._element.removeAttribute("tabindex")), w) {
+                  if (!("offset" in w.options)) {
+                    let ee = Math.abs(13.5) / Math.SQRT2;
+                    w.options.offset = this._defaultMarker ? { top: [0, 0], "top-left": [0, 0], "top-right": [0, 0], bottom: [0, -38.1], "bottom-left": [ee, -1 * (38.1 - 13.5 + ee)], "bottom-right": [-ee, -1 * (38.1 - 13.5 + ee)], left: [13.5, -1 * (38.1 - 13.5)], right: [-13.5, -1 * (38.1 - 13.5)] } : this._offset;
+                  }
+                  this._popup = w, this._originalTabIndex = this._element.getAttribute("tabindex"), this._originalTabIndex || this._element.setAttribute("tabindex", "0"), this._element.addEventListener("keypress", this._onKeyPress);
+                }
+                return this;
+              }
+              setSubpixelPositioning(w) {
+                return this._subpixelPositioning = w, this;
+              }
+              getPopup() {
+                return this._popup;
+              }
+              togglePopup() {
+                let w = this._popup;
+                return this._element.style.opacity === this._opacityWhenCovered ? this : w ? (w.isOpen() ? w.remove() : (w.setLngLat(this._lngLat), w.addTo(this._map)), this) : this;
+              }
+              _updateOpacity(w = false) {
+                var B, Q;
+                if (!(!((B = this._map) === null || B === void 0) && B.terrain)) return void (this._element.style.opacity !== this._opacity && (this._element.style.opacity = this._opacity));
+                if (w) this._opacityTimeout = null;
+                else {
+                  if (this._opacityTimeout) return;
+                  this._opacityTimeout = setTimeout(() => {
+                    this._opacityTimeout = null;
+                  }, 100);
+                }
+                let ee = this._map, le = ee.terrain.depthAtPoint(this._pos), Oe = ee.terrain.getElevationForLngLatZoom(this._lngLat, ee.transform.tileZoom);
+                if (ee.transform.lngLatToCameraDepth(this._lngLat, Oe) - le < 6e-3) return void (this._element.style.opacity = this._opacity);
+                let Ze = -this._offset.y / ee.transform._pixelPerMeter, st = Math.sin(ee.getPitch() * Math.PI / 180) * Ze, Tt = ee.terrain.depthAtPoint(new a.P(this._pos.x, this._pos.y - this._offset.y)), Yt = ee.transform.lngLatToCameraDepth(this._lngLat, Oe + st) - Tt > 6e-3;
+                !((Q = this._popup) === null || Q === void 0) && Q.isOpen() && Yt && this._popup.remove(), this._element.style.opacity = Yt ? this._opacityWhenCovered : this._opacity;
+              }
+              getOffset() {
+                return this._offset;
+              }
+              setOffset(w) {
+                return this._offset = a.P.convert(w), this._update(), this;
+              }
+              addClassName(w) {
+                this._element.classList.add(w);
+              }
+              removeClassName(w) {
+                this._element.classList.remove(w);
+              }
+              toggleClassName(w) {
+                return this._element.classList.toggle(w);
+              }
+              setDraggable(w) {
+                return this._draggable = !!w, this._map && (w ? (this._map.on("mousedown", this._addDragHandler), this._map.on("touchstart", this._addDragHandler)) : (this._map.off("mousedown", this._addDragHandler), this._map.off("touchstart", this._addDragHandler))), this;
+              }
+              isDraggable() {
+                return this._draggable;
+              }
+              setRotation(w) {
+                return this._rotation = w || 0, this._update(), this;
+              }
+              getRotation() {
+                return this._rotation;
+              }
+              setRotationAlignment(w) {
+                return this._rotationAlignment = w || "auto", this._update(), this;
+              }
+              getRotationAlignment() {
+                return this._rotationAlignment;
+              }
+              setPitchAlignment(w) {
+                return this._pitchAlignment = w && w !== "auto" ? w : this._rotationAlignment, this._update(), this;
+              }
+              getPitchAlignment() {
+                return this._pitchAlignment;
+              }
+              setOpacity(w, B) {
+                return w === void 0 && B === void 0 && (this._opacity = "1", this._opacityWhenCovered = "0.2"), w !== void 0 && (this._opacity = w), B !== void 0 && (this._opacityWhenCovered = B), this._map && this._updateOpacity(true), this;
+              }
+            }
+            let Nc = { positionOptions: { enableHighAccuracy: false, maximumAge: 0, timeout: 6e3 }, fitBoundsOptions: { maxZoom: 15 }, trackUserLocation: false, showAccuracyCircle: true, showUserLocation: true }, pu = 0, Uc = false, xu = { maxWidth: 100, unit: "metric" };
+            function Ac(ue, w, B) {
+              let Q = B && B.maxWidth || 100, ee = ue._container.clientHeight / 2, le = ue.unproject([0, ee]), Oe = ue.unproject([Q, ee]), Ze = le.distanceTo(Oe);
+              if (B && B.unit === "imperial") {
+                let st = 3.2808 * Ze;
+                st > 5280 ? Ua(w, Q, st / 5280, ue._getUIString("ScaleControl.Miles")) : Ua(w, Q, st, ue._getUIString("ScaleControl.Feet"));
+              } else B && B.unit === "nautical" ? Ua(w, Q, Ze / 1852, ue._getUIString("ScaleControl.NauticalMiles")) : Ze >= 1e3 ? Ua(w, Q, Ze / 1e3, ue._getUIString("ScaleControl.Kilometers")) : Ua(w, Q, Ze, ue._getUIString("ScaleControl.Meters"));
+            }
+            function Ua(ue, w, B, Q) {
+              let ee = function(le) {
+                let Oe = Math.pow(10, `${Math.floor(le)}`.length - 1), Ze = le / Oe;
+                return Ze = Ze >= 10 ? 10 : Ze >= 5 ? 5 : Ze >= 3 ? 3 : Ze >= 2 ? 2 : Ze >= 1 ? 1 : function(st) {
+                  let Tt = Math.pow(10, Math.ceil(-Math.log(st) / Math.LN10));
+                  return Math.round(st * Tt) / Tt;
+                }(Ze), Oe * Ze;
+              }(B);
+              ue.style.width = w * (ee / B) + "px", ue.innerHTML = `${ee}&nbsp;${Q}`;
+            }
+            let oo = { closeButton: true, closeOnClick: true, focusAfterOpen: true, className: "", maxWidth: "240px", subpixelPositioning: false }, Vc = ["a[href]", "[tabindex]:not([tabindex='-1'])", "[contenteditable]:not([contenteditable='false'])", "button:not([disabled])", "input:not([disabled])", "select:not([disabled])", "textarea:not([disabled])"].join(", ");
+            function hc(ue) {
+              if (ue) {
+                if (typeof ue == "number") {
+                  let w = Math.round(Math.abs(ue) / Math.SQRT2);
+                  return { center: new a.P(0, 0), top: new a.P(0, ue), "top-left": new a.P(w, w), "top-right": new a.P(-w, w), bottom: new a.P(0, -ue), "bottom-left": new a.P(w, -w), "bottom-right": new a.P(-w, -w), left: new a.P(ue, 0), right: new a.P(-ue, 0) };
+                }
+                if (ue instanceof a.P || Array.isArray(ue)) {
+                  let w = a.P.convert(ue);
+                  return { center: w, top: w, "top-left": w, "top-right": w, bottom: w, "bottom-left": w, "bottom-right": w, left: w, right: w };
+                }
+                return { center: a.P.convert(ue.center || [0, 0]), top: a.P.convert(ue.top || [0, 0]), "top-left": a.P.convert(ue["top-left"] || [0, 0]), "top-right": a.P.convert(ue["top-right"] || [0, 0]), bottom: a.P.convert(ue.bottom || [0, 0]), "bottom-left": a.P.convert(ue["bottom-left"] || [0, 0]), "bottom-right": a.P.convert(ue["bottom-right"] || [0, 0]), left: a.P.convert(ue.left || [0, 0]), right: a.P.convert(ue.right || [0, 0]) };
+              }
+              return hc(new a.P(0, 0));
+            }
+            let Ku = o;
+            i.AJAXError = a.bh, i.Evented = a.E, i.LngLat = a.N, i.MercatorCoordinate = a.Z, i.Point = a.P, i.addProtocol = a.bi, i.config = a.a, i.removeProtocol = a.bj, i.AttributionControl = Na, i.BoxZoomHandler = ku, i.CanvasSource = $t, i.CooperativeGesturesHandler = Qi, i.DoubleClickZoomHandler = ki, i.DragPanHandler = wn, i.DragRotateHandler = Nn, i.EdgeInsets = hu, i.FullscreenControl = class extends a.E {
+              constructor(ue = {}) {
+                super(), this._onFullscreenChange = () => {
+                  var w;
+                  let B = window.document.fullscreenElement || window.document.mozFullScreenElement || window.document.webkitFullscreenElement || window.document.msFullscreenElement;
+                  for (; !((w = B == null ? void 0 : B.shadowRoot) === null || w === void 0) && w.fullscreenElement; ) B = B.shadowRoot.fullscreenElement;
+                  B === this._container !== this._fullscreen && this._handleFullscreenChange();
+                }, this._onClickFullscreen = () => {
+                  this._isFullscreen() ? this._exitFullscreen() : this._requestFullscreen();
+                }, this._fullscreen = false, ue && ue.container && (ue.container instanceof HTMLElement ? this._container = ue.container : a.w("Full screen control 'container' must be a DOM element.")), "onfullscreenchange" in document ? this._fullscreenchange = "fullscreenchange" : "onmozfullscreenchange" in document ? this._fullscreenchange = "mozfullscreenchange" : "onwebkitfullscreenchange" in document ? this._fullscreenchange = "webkitfullscreenchange" : "onmsfullscreenchange" in document && (this._fullscreenchange = "MSFullscreenChange");
+              }
+              onAdd(ue) {
+                return this._map = ue, this._container || (this._container = this._map.getContainer()), this._controlContainer = c.create("div", "maplibregl-ctrl maplibregl-ctrl-group"), this._setupUI(), this._controlContainer;
+              }
+              onRemove() {
+                c.remove(this._controlContainer), this._map = null, window.document.removeEventListener(this._fullscreenchange, this._onFullscreenChange);
+              }
+              _setupUI() {
+                let ue = this._fullscreenButton = c.create("button", "maplibregl-ctrl-fullscreen", this._controlContainer);
+                c.create("span", "maplibregl-ctrl-icon", ue).setAttribute("aria-hidden", "true"), ue.type = "button", this._updateTitle(), this._fullscreenButton.addEventListener("click", this._onClickFullscreen), window.document.addEventListener(this._fullscreenchange, this._onFullscreenChange);
+              }
+              _updateTitle() {
+                let ue = this._getTitle();
+                this._fullscreenButton.setAttribute("aria-label", ue), this._fullscreenButton.title = ue;
+              }
+              _getTitle() {
+                return this._map._getUIString(this._isFullscreen() ? "FullscreenControl.Exit" : "FullscreenControl.Enter");
+              }
+              _isFullscreen() {
+                return this._fullscreen;
+              }
+              _handleFullscreenChange() {
+                this._fullscreen = !this._fullscreen, this._fullscreenButton.classList.toggle("maplibregl-ctrl-shrink"), this._fullscreenButton.classList.toggle("maplibregl-ctrl-fullscreen"), this._updateTitle(), this._fullscreen ? (this.fire(new a.k("fullscreenstart")), this._prevCooperativeGesturesEnabled = this._map.cooperativeGestures.isEnabled(), this._map.cooperativeGestures.disable()) : (this.fire(new a.k("fullscreenend")), this._prevCooperativeGesturesEnabled && this._map.cooperativeGestures.enable());
+              }
+              _exitFullscreen() {
+                window.document.exitFullscreen ? window.document.exitFullscreen() : window.document.mozCancelFullScreen ? window.document.mozCancelFullScreen() : window.document.msExitFullscreen ? window.document.msExitFullscreen() : window.document.webkitCancelFullScreen ? window.document.webkitCancelFullScreen() : this._togglePseudoFullScreen();
+              }
+              _requestFullscreen() {
+                this._container.requestFullscreen ? this._container.requestFullscreen() : this._container.mozRequestFullScreen ? this._container.mozRequestFullScreen() : this._container.msRequestFullscreen ? this._container.msRequestFullscreen() : this._container.webkitRequestFullscreen ? this._container.webkitRequestFullscreen() : this._togglePseudoFullScreen();
+              }
+              _togglePseudoFullScreen() {
+                this._container.classList.toggle("maplibregl-pseudo-fullscreen"), this._handleFullscreenChange(), this._map.resize();
+              }
+            }, i.GeoJSONSource = ot, i.GeolocateControl = class extends a.E {
+              constructor(ue) {
+                super(), this._onSuccess = (w) => {
+                  if (this._map) {
+                    if (this._isOutOfMapMaxBounds(w)) return this._setErrorState(), this.fire(new a.k("outofmaxbounds", w)), this._updateMarker(), void this._finish();
+                    if (this.options.trackUserLocation) switch (this._lastKnownPosition = w, this._watchState) {
+                      case "WAITING_ACTIVE":
+                      case "ACTIVE_LOCK":
+                      case "ACTIVE_ERROR":
+                        this._watchState = "ACTIVE_LOCK", this._geolocateButton.classList.remove("maplibregl-ctrl-geolocate-waiting"), this._geolocateButton.classList.remove("maplibregl-ctrl-geolocate-active-error"), this._geolocateButton.classList.add("maplibregl-ctrl-geolocate-active");
+                        break;
+                      case "BACKGROUND":
+                      case "BACKGROUND_ERROR":
+                        this._watchState = "BACKGROUND", this._geolocateButton.classList.remove("maplibregl-ctrl-geolocate-waiting"), this._geolocateButton.classList.remove("maplibregl-ctrl-geolocate-background-error"), this._geolocateButton.classList.add("maplibregl-ctrl-geolocate-background");
+                        break;
+                      default:
+                        throw new Error(`Unexpected watchState ${this._watchState}`);
+                    }
+                    this.options.showUserLocation && this._watchState !== "OFF" && this._updateMarker(w), this.options.trackUserLocation && this._watchState !== "ACTIVE_LOCK" || this._updateCamera(w), this.options.showUserLocation && this._dotElement.classList.remove("maplibregl-user-location-dot-stale"), this.fire(new a.k("geolocate", w)), this._finish();
+                  }
+                }, this._updateCamera = (w) => {
+                  let B = new a.N(w.coords.longitude, w.coords.latitude), Q = w.coords.accuracy, ee = this._map.getBearing(), le = a.e({ bearing: ee }, this.options.fitBoundsOptions), Oe = ce.fromLngLat(B, Q);
+                  this._map.fitBounds(Oe, le, { geolocateSource: true });
+                }, this._updateMarker = (w) => {
+                  if (w) {
+                    let B = new a.N(w.coords.longitude, w.coords.latitude);
+                    this._accuracyCircleMarker.setLngLat(B).addTo(this._map), this._userLocationDotMarker.setLngLat(B).addTo(this._map), this._accuracy = w.coords.accuracy, this.options.showUserLocation && this.options.showAccuracyCircle && this._updateCircleRadius();
+                  } else this._userLocationDotMarker.remove(), this._accuracyCircleMarker.remove();
+                }, this._onZoom = () => {
+                  this.options.showUserLocation && this.options.showAccuracyCircle && this._updateCircleRadius();
+                }, this._onError = (w) => {
+                  if (this._map) {
+                    if (this.options.trackUserLocation) if (w.code === 1) {
+                      this._watchState = "OFF", this._geolocateButton.classList.remove("maplibregl-ctrl-geolocate-waiting"), this._geolocateButton.classList.remove("maplibregl-ctrl-geolocate-active"), this._geolocateButton.classList.remove("maplibregl-ctrl-geolocate-active-error"), this._geolocateButton.classList.remove("maplibregl-ctrl-geolocate-background"), this._geolocateButton.classList.remove("maplibregl-ctrl-geolocate-background-error"), this._geolocateButton.disabled = true;
+                      let B = this._map._getUIString("GeolocateControl.LocationNotAvailable");
+                      this._geolocateButton.title = B, this._geolocateButton.setAttribute("aria-label", B), this._geolocationWatchID !== void 0 && this._clearWatch();
+                    } else {
+                      if (w.code === 3 && Uc) return;
+                      this._setErrorState();
+                    }
+                    this._watchState !== "OFF" && this.options.showUserLocation && this._dotElement.classList.add("maplibregl-user-location-dot-stale"), this.fire(new a.k("error", w)), this._finish();
+                  }
+                }, this._finish = () => {
+                  this._timeoutId && clearTimeout(this._timeoutId), this._timeoutId = void 0;
+                }, this._setupUI = () => {
+                  this._map && (this._container.addEventListener("contextmenu", (w) => w.preventDefault()), this._geolocateButton = c.create("button", "maplibregl-ctrl-geolocate", this._container), c.create("span", "maplibregl-ctrl-icon", this._geolocateButton).setAttribute("aria-hidden", "true"), this._geolocateButton.type = "button", this._geolocateButton.disabled = true);
+                }, this._finishSetupUI = (w) => {
+                  if (this._map) {
+                    if (w === false) {
+                      a.w("Geolocation support is not available so the GeolocateControl will be disabled.");
+                      let B = this._map._getUIString("GeolocateControl.LocationNotAvailable");
+                      this._geolocateButton.disabled = true, this._geolocateButton.title = B, this._geolocateButton.setAttribute("aria-label", B);
+                    } else {
+                      let B = this._map._getUIString("GeolocateControl.FindMyLocation");
+                      this._geolocateButton.disabled = false, this._geolocateButton.title = B, this._geolocateButton.setAttribute("aria-label", B);
+                    }
+                    this.options.trackUserLocation && (this._geolocateButton.setAttribute("aria-pressed", "false"), this._watchState = "OFF"), this.options.showUserLocation && (this._dotElement = c.create("div", "maplibregl-user-location-dot"), this._userLocationDotMarker = new Yu({ element: this._dotElement }), this._circleElement = c.create("div", "maplibregl-user-location-accuracy-circle"), this._accuracyCircleMarker = new Yu({ element: this._circleElement, pitchAlignment: "map" }), this.options.trackUserLocation && (this._watchState = "OFF"), this._map.on("zoom", this._onZoom)), this._geolocateButton.addEventListener("click", () => this.trigger()), this._setup = true, this.options.trackUserLocation && this._map.on("movestart", (B) => {
+                      B.geolocateSource || this._watchState !== "ACTIVE_LOCK" || B.originalEvent && B.originalEvent.type === "resize" || (this._watchState = "BACKGROUND", this._geolocateButton.classList.add("maplibregl-ctrl-geolocate-background"), this._geolocateButton.classList.remove("maplibregl-ctrl-geolocate-active"), this.fire(new a.k("trackuserlocationend")), this.fire(new a.k("userlocationlostfocus")));
+                    });
+                  }
+                }, this.options = a.e({}, Nc, ue);
+              }
+              onAdd(ue) {
+                return this._map = ue, this._container = c.create("div", "maplibregl-ctrl maplibregl-ctrl-group"), this._setupUI(), function() {
+                  return a._(this, arguments, void 0, function* (w = false) {
+                    if (ys !== void 0 && !w) return ys;
+                    if (window.navigator.permissions === void 0) return ys = !!window.navigator.geolocation, ys;
+                    try {
+                      ys = (yield window.navigator.permissions.query({ name: "geolocation" })).state !== "denied";
+                    } catch (B) {
+                      ys = !!window.navigator.geolocation;
+                    }
+                    return ys;
+                  });
+                }().then((w) => this._finishSetupUI(w)), this._container;
+              }
+              onRemove() {
+                this._geolocationWatchID !== void 0 && (window.navigator.geolocation.clearWatch(this._geolocationWatchID), this._geolocationWatchID = void 0), this.options.showUserLocation && this._userLocationDotMarker && this._userLocationDotMarker.remove(), this.options.showAccuracyCircle && this._accuracyCircleMarker && this._accuracyCircleMarker.remove(), c.remove(this._container), this._map.off("zoom", this._onZoom), this._map = void 0, pu = 0, Uc = false;
+              }
+              _isOutOfMapMaxBounds(ue) {
+                let w = this._map.getMaxBounds(), B = ue.coords;
+                return w && (B.longitude < w.getWest() || B.longitude > w.getEast() || B.latitude < w.getSouth() || B.latitude > w.getNorth());
+              }
+              _setErrorState() {
+                switch (this._watchState) {
+                  case "WAITING_ACTIVE":
+                    this._watchState = "ACTIVE_ERROR", this._geolocateButton.classList.remove("maplibregl-ctrl-geolocate-active"), this._geolocateButton.classList.add("maplibregl-ctrl-geolocate-active-error");
+                    break;
+                  case "ACTIVE_LOCK":
+                    this._watchState = "ACTIVE_ERROR", this._geolocateButton.classList.remove("maplibregl-ctrl-geolocate-active"), this._geolocateButton.classList.add("maplibregl-ctrl-geolocate-active-error"), this._geolocateButton.classList.add("maplibregl-ctrl-geolocate-waiting");
+                    break;
+                  case "BACKGROUND":
+                    this._watchState = "BACKGROUND_ERROR", this._geolocateButton.classList.remove("maplibregl-ctrl-geolocate-background"), this._geolocateButton.classList.add("maplibregl-ctrl-geolocate-background-error"), this._geolocateButton.classList.add("maplibregl-ctrl-geolocate-waiting");
+                    break;
+                  case "ACTIVE_ERROR":
+                    break;
+                  default:
+                    throw new Error(`Unexpected watchState ${this._watchState}`);
+                }
+              }
+              _updateCircleRadius() {
+                let ue = this._map.getBounds(), w = ue.getSouthEast(), B = ue.getNorthEast(), Q = w.distanceTo(B), ee = Math.ceil(this._accuracy / (Q / this._map._container.clientHeight) * 2);
+                this._circleElement.style.width = `${ee}px`, this._circleElement.style.height = `${ee}px`;
+              }
+              trigger() {
+                if (!this._setup) return a.w("Geolocate control triggered before added to a map"), false;
+                if (this.options.trackUserLocation) {
+                  switch (this._watchState) {
+                    case "OFF":
+                      this._watchState = "WAITING_ACTIVE", this.fire(new a.k("trackuserlocationstart"));
+                      break;
+                    case "WAITING_ACTIVE":
+                    case "ACTIVE_LOCK":
+                    case "ACTIVE_ERROR":
+                    case "BACKGROUND_ERROR":
+                      pu--, Uc = false, this._watchState = "OFF", this._geolocateButton.classList.remove("maplibregl-ctrl-geolocate-waiting"), this._geolocateButton.classList.remove("maplibregl-ctrl-geolocate-active"), this._geolocateButton.classList.remove("maplibregl-ctrl-geolocate-active-error"), this._geolocateButton.classList.remove("maplibregl-ctrl-geolocate-background"), this._geolocateButton.classList.remove("maplibregl-ctrl-geolocate-background-error"), this.fire(new a.k("trackuserlocationend"));
+                      break;
+                    case "BACKGROUND":
+                      this._watchState = "ACTIVE_LOCK", this._geolocateButton.classList.remove("maplibregl-ctrl-geolocate-background"), this._lastKnownPosition && this._updateCamera(this._lastKnownPosition), this.fire(new a.k("trackuserlocationstart")), this.fire(new a.k("userlocationfocus"));
+                      break;
+                    default:
+                      throw new Error(`Unexpected watchState ${this._watchState}`);
+                  }
+                  switch (this._watchState) {
+                    case "WAITING_ACTIVE":
+                      this._geolocateButton.classList.add("maplibregl-ctrl-geolocate-waiting"), this._geolocateButton.classList.add("maplibregl-ctrl-geolocate-active");
+                      break;
+                    case "ACTIVE_LOCK":
+                      this._geolocateButton.classList.add("maplibregl-ctrl-geolocate-active");
+                      break;
+                    case "OFF":
+                      break;
+                    default:
+                      throw new Error(`Unexpected watchState ${this._watchState}`);
+                  }
+                  if (this._watchState === "OFF" && this._geolocationWatchID !== void 0) this._clearWatch();
+                  else if (this._geolocationWatchID === void 0) {
+                    let ue;
+                    this._geolocateButton.classList.add("maplibregl-ctrl-geolocate-waiting"), this._geolocateButton.setAttribute("aria-pressed", "true"), pu++, pu > 1 ? (ue = { maximumAge: 6e5, timeout: 0 }, Uc = true) : (ue = this.options.positionOptions, Uc = false), this._geolocationWatchID = window.navigator.geolocation.watchPosition(this._onSuccess, this._onError, ue);
+                  }
+                } else window.navigator.geolocation.getCurrentPosition(this._onSuccess, this._onError, this.options.positionOptions), this._timeoutId = setTimeout(this._finish, 1e4);
+                return true;
+              }
+              _clearWatch() {
+                window.navigator.geolocation.clearWatch(this._geolocationWatchID), this._geolocationWatchID = void 0, this._geolocateButton.classList.remove("maplibregl-ctrl-geolocate-waiting"), this._geolocateButton.setAttribute("aria-pressed", "false"), this.options.showUserLocation && this._updateMarker(null);
+              }
+            }, i.Hash = Mh, i.ImageSource = Wt, i.KeyboardHandler = Xt, i.LngLatBounds = ce, i.LogoControl = Yn, i.Map = class extends Ra {
+              constructor(ue) {
+                a.bf.mark(a.bg.create);
+                let w = Object.assign(Object.assign({}, Ws), ue);
+                if (w.minZoom != null && w.maxZoom != null && w.minZoom > w.maxZoom) throw new Error("maxZoom must be greater than or equal to minZoom");
+                if (w.minPitch != null && w.maxPitch != null && w.minPitch > w.maxPitch) throw new Error("maxPitch must be greater than or equal to minPitch");
+                if (w.minPitch != null && w.minPitch < 0) throw new Error("minPitch must be greater than or equal to 0");
+                if (w.maxPitch != null && w.maxPitch > 85) throw new Error("maxPitch must be less than or equal to 85");
+                if (super(new nl(w.minZoom, w.maxZoom, w.minPitch, w.maxPitch, w.renderWorldCopies), { bearingSnap: w.bearingSnap }), this._idleTriggered = false, this._crossFadingFactor = 1, this._renderTaskQueue = new Dn(), this._controls = [], this._mapId = a.a4(), this._contextLost = (B) => {
+                  B.preventDefault(), this._frameRequest && (this._frameRequest.abort(), this._frameRequest = null), this.fire(new a.k("webglcontextlost", { originalEvent: B }));
+                }, this._contextRestored = (B) => {
+                  this._setupPainter(), this.resize(), this._update(), this.fire(new a.k("webglcontextrestored", { originalEvent: B }));
+                }, this._onMapScroll = (B) => {
+                  if (B.target === this._container) return this._container.scrollTop = 0, this._container.scrollLeft = 0, false;
+                }, this._onWindowOnline = () => {
+                  this._update();
+                }, this._interactive = w.interactive, this._maxTileCacheSize = w.maxTileCacheSize, this._maxTileCacheZoomLevels = w.maxTileCacheZoomLevels, this._failIfMajorPerformanceCaveat = w.failIfMajorPerformanceCaveat === true, this._preserveDrawingBuffer = w.preserveDrawingBuffer === true, this._antialias = w.antialias === true, this._trackResize = w.trackResize === true, this._bearingSnap = w.bearingSnap, this._refreshExpiredTiles = w.refreshExpiredTiles === true, this._fadeDuration = w.fadeDuration, this._crossSourceCollisions = w.crossSourceCollisions === true, this._collectResourceTiming = w.collectResourceTiming === true, this._locale = Object.assign(Object.assign({}, Ho), w.locale), this._clickTolerance = w.clickTolerance, this._overridePixelRatio = w.pixelRatio, this._maxCanvasSize = w.maxCanvasSize, this.transformCameraUpdate = w.transformCameraUpdate, this.cancelPendingTileRequestsWhileZooming = w.cancelPendingTileRequestsWhileZooming === true, this._imageQueueHandle = p.addThrottleControl(() => this.isMoving()), this._requestManager = new k(w.transformRequest), typeof w.container == "string") {
+                  if (this._container = document.getElementById(w.container), !this._container) throw new Error(`Container '${w.container}' not found.`);
+                } else {
+                  if (!(w.container instanceof HTMLElement)) throw new Error("Invalid type: 'container' must be a String or HTMLElement.");
+                  this._container = w.container;
+                }
+                if (w.maxBounds && this.setMaxBounds(w.maxBounds), this._setupContainer(), this._setupPainter(), this.on("move", () => this._update(false)).on("moveend", () => this._update(false)).on("zoom", () => this._update(true)).on("terrain", () => {
+                  this.painter.terrainFacilitator.dirty = true, this._update(true);
+                }).once("idle", () => {
+                  this._idleTriggered = true;
+                }), typeof window != "undefined") {
+                  addEventListener("online", this._onWindowOnline, false);
+                  let B = false, Q = nh((ee) => {
+                    this._trackResize && !this._removed && (this.resize(ee), this.redraw());
+                  }, 50);
+                  this._resizeObserver = new ResizeObserver((ee) => {
+                    B ? Q(ee) : B = true;
+                  }), this._resizeObserver.observe(this._container);
+                }
+                this.handlers = new Ca(this, w), this._hash = w.hash && new Mh(typeof w.hash == "string" && w.hash || void 0).addTo(this), this._hash && this._hash._onHashChange() || (this.jumpTo({ center: w.center, zoom: w.zoom, bearing: w.bearing, pitch: w.pitch }), w.bounds && (this.resize(), this.fitBounds(w.bounds, a.e({}, w.fitBoundsOptions, { duration: 0 })))), this.resize(), this._localIdeographFontFamily = w.localIdeographFontFamily, this._validateStyle = w.validateStyle, w.style && this.setStyle(w.style, { localIdeographFontFamily: w.localIdeographFontFamily }), w.attributionControl && this.addControl(new Na(typeof w.attributionControl == "boolean" ? void 0 : w.attributionControl)), w.maplibreLogo && this.addControl(new Yn(), w.logoPosition), this.on("style.load", () => {
+                  this.transform.unmodified && this.jumpTo(this.style.stylesheet);
+                }), this.on("data", (B) => {
+                  this._update(B.dataType === "style"), this.fire(new a.k(`${B.dataType}data`, B));
+                }), this.on("dataloading", (B) => {
+                  this.fire(new a.k(`${B.dataType}dataloading`, B));
+                }), this.on("dataabort", (B) => {
+                  this.fire(new a.k("sourcedataabort", B));
+                });
+              }
+              _getMapId() {
+                return this._mapId;
+              }
+              addControl(ue, w) {
+                if (w === void 0 && (w = ue.getDefaultPosition ? ue.getDefaultPosition() : "top-right"), !ue || !ue.onAdd) return this.fire(new a.j(new Error("Invalid argument to map.addControl(). Argument must be a control with onAdd and onRemove methods.")));
+                let B = ue.onAdd(this);
+                this._controls.push(ue);
+                let Q = this._controlPositions[w];
+                return w.indexOf("bottom") !== -1 ? Q.insertBefore(B, Q.firstChild) : Q.appendChild(B), this;
+              }
+              removeControl(ue) {
+                if (!ue || !ue.onRemove) return this.fire(new a.j(new Error("Invalid argument to map.removeControl(). Argument must be a control with onAdd and onRemove methods.")));
+                let w = this._controls.indexOf(ue);
+                return w > -1 && this._controls.splice(w, 1), ue.onRemove(this), this;
+              }
+              hasControl(ue) {
+                return this._controls.indexOf(ue) > -1;
+              }
+              calculateCameraOptionsFromTo(ue, w, B, Q) {
+                return Q == null && this.terrain && (Q = this.terrain.getElevationForLngLatZoom(B, this.transform.tileZoom)), super.calculateCameraOptionsFromTo(ue, w, B, Q);
+              }
+              resize(ue) {
+                var w;
+                let B = this._containerDimensions(), Q = B[0], ee = B[1], le = this._getClampedPixelRatio(Q, ee);
+                if (this._resizeCanvas(Q, ee, le), this.painter.resize(Q, ee, le), this.painter.overLimit()) {
+                  let Ze = this.painter.context.gl;
+                  this._maxCanvasSize = [Ze.drawingBufferWidth, Ze.drawingBufferHeight];
+                  let st = this._getClampedPixelRatio(Q, ee);
+                  this._resizeCanvas(Q, ee, st), this.painter.resize(Q, ee, st);
+                }
+                this.transform.resize(Q, ee), (w = this._requestedCameraState) === null || w === void 0 || w.resize(Q, ee);
+                let Oe = !this._moving;
+                return Oe && (this.stop(), this.fire(new a.k("movestart", ue)).fire(new a.k("move", ue))), this.fire(new a.k("resize", ue)), Oe && this.fire(new a.k("moveend", ue)), this;
+              }
+              _getClampedPixelRatio(ue, w) {
+                let { 0: B, 1: Q } = this._maxCanvasSize, ee = this.getPixelRatio(), le = ue * ee, Oe = w * ee;
+                return Math.min(le > B ? B / le : 1, Oe > Q ? Q / Oe : 1) * ee;
+              }
+              getPixelRatio() {
+                var ue;
+                return (ue = this._overridePixelRatio) !== null && ue !== void 0 ? ue : devicePixelRatio;
+              }
+              setPixelRatio(ue) {
+                this._overridePixelRatio = ue, this.resize();
+              }
+              getBounds() {
+                return this.transform.getBounds();
+              }
+              getMaxBounds() {
+                return this.transform.getMaxBounds();
+              }
+              setMaxBounds(ue) {
+                return this.transform.setMaxBounds(ce.convert(ue)), this._update();
+              }
+              setMinZoom(ue) {
+                if ((ue = ue == null ? -2 : ue) >= -2 && ue <= this.transform.maxZoom) return this.transform.minZoom = ue, this._update(), this.getZoom() < ue && this.setZoom(ue), this;
+                throw new Error("minZoom must be between -2 and the current maxZoom, inclusive");
+              }
+              getMinZoom() {
+                return this.transform.minZoom;
+              }
+              setMaxZoom(ue) {
+                if ((ue = ue == null ? 22 : ue) >= this.transform.minZoom) return this.transform.maxZoom = ue, this._update(), this.getZoom() > ue && this.setZoom(ue), this;
+                throw new Error("maxZoom must be greater than the current minZoom");
+              }
+              getMaxZoom() {
+                return this.transform.maxZoom;
+              }
+              setMinPitch(ue) {
+                if ((ue = ue == null ? 0 : ue) < 0) throw new Error("minPitch must be greater than or equal to 0");
+                if (ue >= 0 && ue <= this.transform.maxPitch) return this.transform.minPitch = ue, this._update(), this.getPitch() < ue && this.setPitch(ue), this;
+                throw new Error("minPitch must be between 0 and the current maxPitch, inclusive");
+              }
+              getMinPitch() {
+                return this.transform.minPitch;
+              }
+              setMaxPitch(ue) {
+                if ((ue = ue == null ? 60 : ue) > 85) throw new Error("maxPitch must be less than or equal to 85");
+                if (ue >= this.transform.minPitch) return this.transform.maxPitch = ue, this._update(), this.getPitch() > ue && this.setPitch(ue), this;
+                throw new Error("maxPitch must be greater than the current minPitch");
+              }
+              getMaxPitch() {
+                return this.transform.maxPitch;
+              }
+              getRenderWorldCopies() {
+                return this.transform.renderWorldCopies;
+              }
+              setRenderWorldCopies(ue) {
+                return this.transform.renderWorldCopies = ue, this._update();
+              }
+              project(ue) {
+                return this.transform.locationPoint(a.N.convert(ue), this.style && this.terrain);
+              }
+              unproject(ue) {
+                return this.transform.pointLocation(a.P.convert(ue), this.terrain);
+              }
+              isMoving() {
+                var ue;
+                return this._moving || ((ue = this.handlers) === null || ue === void 0 ? void 0 : ue.isMoving());
+              }
+              isZooming() {
+                var ue;
+                return this._zooming || ((ue = this.handlers) === null || ue === void 0 ? void 0 : ue.isZooming());
+              }
+              isRotating() {
+                var ue;
+                return this._rotating || ((ue = this.handlers) === null || ue === void 0 ? void 0 : ue.isRotating());
+              }
+              _createDelegatedListener(ue, w, B) {
+                if (ue === "mouseenter" || ue === "mouseover") {
+                  let Q = false;
+                  return { layers: w, listener: B, delegates: { mousemove: (le) => {
+                    let Oe = w.filter((st) => this.getLayer(st)), Ze = Oe.length !== 0 ? this.queryRenderedFeatures(le.point, { layers: Oe }) : [];
+                    Ze.length ? Q || (Q = true, B.call(this, new jl(ue, this, le.originalEvent, { features: Ze }))) : Q = false;
+                  }, mouseout: () => {
+                    Q = false;
+                  } } };
+                }
+                if (ue === "mouseleave" || ue === "mouseout") {
+                  let Q = false;
+                  return { layers: w, listener: B, delegates: { mousemove: (Oe) => {
+                    let Ze = w.filter((st) => this.getLayer(st));
+                    (Ze.length !== 0 ? this.queryRenderedFeatures(Oe.point, { layers: Ze }) : []).length ? Q = true : Q && (Q = false, B.call(this, new jl(ue, this, Oe.originalEvent)));
+                  }, mouseout: (Oe) => {
+                    Q && (Q = false, B.call(this, new jl(ue, this, Oe.originalEvent)));
+                  } } };
+                }
+                {
+                  let Q = (ee) => {
+                    let le = w.filter((Ze) => this.getLayer(Ze)), Oe = le.length !== 0 ? this.queryRenderedFeatures(ee.point, { layers: le }) : [];
+                    Oe.length && (ee.features = Oe, B.call(this, ee), delete ee.features);
+                  };
+                  return { layers: w, listener: B, delegates: { [ue]: Q } };
+                }
+              }
+              _saveDelegatedListener(ue, w) {
+                this._delegatedListeners = this._delegatedListeners || {}, this._delegatedListeners[ue] = this._delegatedListeners[ue] || [], this._delegatedListeners[ue].push(w);
+              }
+              _removeDelegatedListener(ue, w, B) {
+                if (!this._delegatedListeners || !this._delegatedListeners[ue]) return;
+                let Q = this._delegatedListeners[ue];
+                for (let ee = 0; ee < Q.length; ee++) {
+                  let le = Q[ee];
+                  if (le.listener === B && le.layers.length === w.length && le.layers.every((Oe) => w.includes(Oe))) {
+                    for (let Oe in le.delegates) this.off(Oe, le.delegates[Oe]);
+                    return void Q.splice(ee, 1);
+                  }
+                }
+              }
+              on(ue, w, B) {
+                if (B === void 0) return super.on(ue, w);
+                let Q = this._createDelegatedListener(ue, typeof w == "string" ? [w] : w, B);
+                this._saveDelegatedListener(ue, Q);
+                for (let ee in Q.delegates) this.on(ee, Q.delegates[ee]);
+                return this;
+              }
+              once(ue, w, B) {
+                if (B === void 0) return super.once(ue, w);
+                let Q = typeof w == "string" ? [w] : w, ee = this._createDelegatedListener(ue, Q, B);
+                for (let le in ee.delegates) {
+                  let Oe = ee.delegates[le];
+                  ee.delegates[le] = (...Ze) => {
+                    this._removeDelegatedListener(ue, Q, B), Oe(...Ze);
+                  };
+                }
+                this._saveDelegatedListener(ue, ee);
+                for (let le in ee.delegates) this.once(le, ee.delegates[le]);
+                return this;
+              }
+              off(ue, w, B) {
+                return B === void 0 ? super.off(ue, w) : (this._removeDelegatedListener(ue, typeof w == "string" ? [w] : w, B), this);
+              }
+              queryRenderedFeatures(ue, w) {
+                if (!this.style) return [];
+                let B, Q = ue instanceof a.P || Array.isArray(ue), ee = Q ? ue : [[0, 0], [this.transform.width, this.transform.height]];
+                if (w = w || (Q ? {} : ue) || {}, ee instanceof a.P || typeof ee[0] == "number") B = [a.P.convert(ee)];
+                else {
+                  let le = a.P.convert(ee[0]), Oe = a.P.convert(ee[1]);
+                  B = [le, new a.P(Oe.x, le.y), Oe, new a.P(le.x, Oe.y), le];
+                }
+                return this.style.queryRenderedFeatures(B, w, this.transform);
+              }
+              querySourceFeatures(ue, w) {
+                return this.style.querySourceFeatures(ue, w);
+              }
+              setStyle(ue, w) {
+                return (w = a.e({}, { localIdeographFontFamily: this._localIdeographFontFamily, validate: this._validateStyle }, w)).diff !== false && w.localIdeographFontFamily === this._localIdeographFontFamily && this.style && ue ? (this._diffStyle(ue, w), this) : (this._localIdeographFontFamily = w.localIdeographFontFamily, this._updateStyle(ue, w));
+              }
+              setTransformRequest(ue) {
+                return this._requestManager.setTransformRequest(ue), this;
+              }
+              _getUIString(ue) {
+                let w = this._locale[ue];
+                if (w == null) throw new Error(`Missing UI string '${ue}'`);
+                return w;
+              }
+              _updateStyle(ue, w) {
+                if (w.transformStyle && this.style && !this.style._loaded) return void this.style.once("style.load", () => this._updateStyle(ue, w));
+                let B = this.style && w.transformStyle ? this.style.serialize() : void 0;
+                return this.style && (this.style.setEventedParent(null), this.style._remove(!ue)), ue ? (this.style = new Ha(this, w || {}), this.style.setEventedParent(this, { style: this.style }), typeof ue == "string" ? this.style.loadURL(ue, w, B) : this.style.loadJSON(ue, w, B), this) : (delete this.style, this);
+              }
+              _lazyInitEmptyStyle() {
+                this.style || (this.style = new Ha(this, {}), this.style.setEventedParent(this, { style: this.style }), this.style.loadEmpty());
+              }
+              _diffStyle(ue, w) {
+                if (typeof ue == "string") {
+                  let B = this._requestManager.transformRequest(ue, "Style");
+                  a.h(B, new AbortController()).then((Q) => {
+                    this._updateDiff(Q.data, w);
+                  }).catch((Q) => {
+                    Q && this.fire(new a.j(Q));
+                  });
+                } else typeof ue == "object" && this._updateDiff(ue, w);
+              }
+              _updateDiff(ue, w) {
+                try {
+                  this.style.setState(ue, w) && this._update(true);
+                } catch (B) {
+                  a.w(`Unable to perform style diff: ${B.message || B.error || B}.  Rebuilding the style from scratch.`), this._updateStyle(ue, w);
+                }
+              }
+              getStyle() {
+                if (this.style) return this.style.serialize();
+              }
+              isStyleLoaded() {
+                return this.style ? this.style.loaded() : a.w("There is no style added to the map.");
+              }
+              addSource(ue, w) {
+                return this._lazyInitEmptyStyle(), this.style.addSource(ue, w), this._update(true);
+              }
+              isSourceLoaded(ue) {
+                let w = this.style && this.style.sourceCaches[ue];
+                if (w !== void 0) return w.loaded();
+                this.fire(new a.j(new Error(`There is no source with ID '${ue}'`)));
+              }
+              setTerrain(ue) {
+                if (this.style._checkLoaded(), this._terrainDataCallback && this.style.off("data", this._terrainDataCallback), ue) {
+                  let w = this.style.sourceCaches[ue.source];
+                  if (!w) throw new Error(`cannot load terrain, because there exists no source with ID: ${ue.source}`);
+                  this.terrain === null && w.reload();
+                  for (let B in this.style._layers) {
+                    let Q = this.style._layers[B];
+                    Q.type === "hillshade" && Q.source === ue.source && a.w("You are using the same source for a hillshade layer and for 3D terrain. Please consider using two separate sources to improve rendering quality.");
+                  }
+                  this.terrain = new Zo(this.painter, w, ue), this.painter.renderToTexture = new ws(this.painter, this.terrain), this.transform.minElevationForCurrentTile = this.terrain.getMinTileElevationForLngLatZoom(this.transform.center, this.transform.tileZoom), this.transform.elevation = this.terrain.getElevationForLngLatZoom(this.transform.center, this.transform.tileZoom), this._terrainDataCallback = (B) => {
+                    B.dataType === "style" ? this.terrain.sourceCache.freeRtt() : B.dataType === "source" && B.tile && (B.sourceId !== ue.source || this._elevationFreeze || (this.transform.minElevationForCurrentTile = this.terrain.getMinTileElevationForLngLatZoom(this.transform.center, this.transform.tileZoom), this.transform.elevation = this.terrain.getElevationForLngLatZoom(this.transform.center, this.transform.tileZoom)), this.terrain.sourceCache.freeRtt(B.tile.tileID));
+                  }, this.style.on("data", this._terrainDataCallback);
+                } else this.terrain && this.terrain.sourceCache.destruct(), this.terrain = null, this.painter.renderToTexture && this.painter.renderToTexture.destruct(), this.painter.renderToTexture = null, this.transform.minElevationForCurrentTile = 0, this.transform.elevation = 0;
+                return this.fire(new a.k("terrain", { terrain: ue })), this;
+              }
+              getTerrain() {
+                var ue, w;
+                return (w = (ue = this.terrain) === null || ue === void 0 ? void 0 : ue.options) !== null && w !== void 0 ? w : null;
+              }
+              areTilesLoaded() {
+                let ue = this.style && this.style.sourceCaches;
+                for (let w in ue) {
+                  let B = ue[w]._tiles;
+                  for (let Q in B) {
+                    let ee = B[Q];
+                    if (ee.state !== "loaded" && ee.state !== "errored") return false;
+                  }
+                }
+                return true;
+              }
+              removeSource(ue) {
+                return this.style.removeSource(ue), this._update(true);
+              }
+              getSource(ue) {
+                return this.style.getSource(ue);
+              }
+              addImage(ue, w, B = {}) {
+                let { pixelRatio: Q = 1, sdf: ee = false, stretchX: le, stretchY: Oe, content: Ze, textFitWidth: st, textFitHeight: Tt } = B;
+                if (this._lazyInitEmptyStyle(), !(w instanceof HTMLImageElement || a.b(w))) {
+                  if (w.width === void 0 || w.height === void 0) return this.fire(new a.j(new Error("Invalid arguments to map.addImage(). The second argument must be an `HTMLImageElement`, `ImageData`, `ImageBitmap`, or object with `width`, `height`, and `data` properties with the same format as `ImageData`")));
+                  {
+                    let { width: Yt, height: Kt, data: xr } = w, Ir = w;
+                    return this.style.addImage(ue, { data: new a.R({ width: Yt, height: Kt }, new Uint8Array(xr)), pixelRatio: Q, stretchX: le, stretchY: Oe, content: Ze, textFitWidth: st, textFitHeight: Tt, sdf: ee, version: 0, userImage: Ir }), Ir.onAdd && Ir.onAdd(this, ue), this;
+                  }
+                }
+                {
+                  let { width: Yt, height: Kt, data: xr } = u.getImageData(w);
+                  this.style.addImage(ue, { data: new a.R({ width: Yt, height: Kt }, xr), pixelRatio: Q, stretchX: le, stretchY: Oe, content: Ze, textFitWidth: st, textFitHeight: Tt, sdf: ee, version: 0 });
+                }
+              }
+              updateImage(ue, w) {
+                let B = this.style.getImage(ue);
+                if (!B) return this.fire(new a.j(new Error("The map has no image with that id. If you are adding a new image use `map.addImage(...)` instead.")));
+                let Q = w instanceof HTMLImageElement || a.b(w) ? u.getImageData(w) : w, { width: ee, height: le, data: Oe } = Q;
+                if (ee === void 0 || le === void 0) return this.fire(new a.j(new Error("Invalid arguments to map.updateImage(). The second argument must be an `HTMLImageElement`, `ImageData`, `ImageBitmap`, or object with `width`, `height`, and `data` properties with the same format as `ImageData`")));
+                if (ee !== B.data.width || le !== B.data.height) return this.fire(new a.j(new Error("The width and height of the updated image must be that same as the previous version of the image")));
+                let Ze = !(w instanceof HTMLImageElement || a.b(w));
+                return B.data.replace(Oe, Ze), this.style.updateImage(ue, B), this;
+              }
+              getImage(ue) {
+                return this.style.getImage(ue);
+              }
+              hasImage(ue) {
+                return ue ? !!this.style.getImage(ue) : (this.fire(new a.j(new Error("Missing required image id"))), false);
+              }
+              removeImage(ue) {
+                this.style.removeImage(ue);
+              }
+              loadImage(ue) {
+                return p.getImage(this._requestManager.transformRequest(ue, "Image"), new AbortController());
+              }
+              listImages() {
+                return this.style.listImages();
+              }
+              addLayer(ue, w) {
+                return this._lazyInitEmptyStyle(), this.style.addLayer(ue, w), this._update(true);
+              }
+              moveLayer(ue, w) {
+                return this.style.moveLayer(ue, w), this._update(true);
+              }
+              removeLayer(ue) {
+                return this.style.removeLayer(ue), this._update(true);
+              }
+              getLayer(ue) {
+                return this.style.getLayer(ue);
+              }
+              getLayersOrder() {
+                return this.style.getLayersOrder();
+              }
+              setLayerZoomRange(ue, w, B) {
+                return this.style.setLayerZoomRange(ue, w, B), this._update(true);
+              }
+              setFilter(ue, w, B = {}) {
+                return this.style.setFilter(ue, w, B), this._update(true);
+              }
+              getFilter(ue) {
+                return this.style.getFilter(ue);
+              }
+              setPaintProperty(ue, w, B, Q = {}) {
+                return this.style.setPaintProperty(ue, w, B, Q), this._update(true);
+              }
+              getPaintProperty(ue, w) {
+                return this.style.getPaintProperty(ue, w);
+              }
+              setLayoutProperty(ue, w, B, Q = {}) {
+                return this.style.setLayoutProperty(ue, w, B, Q), this._update(true);
+              }
+              getLayoutProperty(ue, w) {
+                return this.style.getLayoutProperty(ue, w);
+              }
+              setGlyphs(ue, w = {}) {
+                return this._lazyInitEmptyStyle(), this.style.setGlyphs(ue, w), this._update(true);
+              }
+              getGlyphs() {
+                return this.style.getGlyphsUrl();
+              }
+              addSprite(ue, w, B = {}) {
+                return this._lazyInitEmptyStyle(), this.style.addSprite(ue, w, B, (Q) => {
+                  Q || this._update(true);
+                }), this;
+              }
+              removeSprite(ue) {
+                return this._lazyInitEmptyStyle(), this.style.removeSprite(ue), this._update(true);
+              }
+              getSprite() {
+                return this.style.getSprite();
+              }
+              setSprite(ue, w = {}) {
+                return this._lazyInitEmptyStyle(), this.style.setSprite(ue, w, (B) => {
+                  B || this._update(true);
+                }), this;
+              }
+              setLight(ue, w = {}) {
+                return this._lazyInitEmptyStyle(), this.style.setLight(ue, w), this._update(true);
+              }
+              getLight() {
+                return this.style.getLight();
+              }
+              setSky(ue) {
+                return this._lazyInitEmptyStyle(), this.style.setSky(ue), this._update(true);
+              }
+              getSky() {
+                return this.style.getSky();
+              }
+              setFeatureState(ue, w) {
+                return this.style.setFeatureState(ue, w), this._update();
+              }
+              removeFeatureState(ue, w) {
+                return this.style.removeFeatureState(ue, w), this._update();
+              }
+              getFeatureState(ue) {
+                return this.style.getFeatureState(ue);
+              }
+              getContainer() {
+                return this._container;
+              }
+              getCanvasContainer() {
+                return this._canvasContainer;
+              }
+              getCanvas() {
+                return this._canvas;
+              }
+              _containerDimensions() {
+                let ue = 0, w = 0;
+                return this._container && (ue = this._container.clientWidth || 400, w = this._container.clientHeight || 300), [ue, w];
+              }
+              _setupContainer() {
+                let ue = this._container;
+                ue.classList.add("maplibregl-map");
+                let w = this._canvasContainer = c.create("div", "maplibregl-canvas-container", ue);
+                this._interactive && w.classList.add("maplibregl-interactive"), this._canvas = c.create("canvas", "maplibregl-canvas", w), this._canvas.addEventListener("webglcontextlost", this._contextLost, false), this._canvas.addEventListener("webglcontextrestored", this._contextRestored, false), this._canvas.setAttribute("tabindex", this._interactive ? "0" : "-1"), this._canvas.setAttribute("aria-label", this._getUIString("Map.Title")), this._canvas.setAttribute("role", "region");
+                let B = this._containerDimensions(), Q = this._getClampedPixelRatio(B[0], B[1]);
+                this._resizeCanvas(B[0], B[1], Q);
+                let ee = this._controlContainer = c.create("div", "maplibregl-control-container", ue), le = this._controlPositions = {};
+                ["top-left", "top-right", "bottom-left", "bottom-right"].forEach((Oe) => {
+                  le[Oe] = c.create("div", `maplibregl-ctrl-${Oe} `, ee);
+                }), this._container.addEventListener("scroll", this._onMapScroll, false);
+              }
+              _resizeCanvas(ue, w, B) {
+                this._canvas.width = Math.floor(B * ue), this._canvas.height = Math.floor(B * w), this._canvas.style.width = `${ue}px`, this._canvas.style.height = `${w}px`;
+              }
+              _setupPainter() {
+                let ue = { alpha: true, stencil: true, depth: true, failIfMajorPerformanceCaveat: this._failIfMajorPerformanceCaveat, preserveDrawingBuffer: this._preserveDrawingBuffer, antialias: this._antialias || false }, w = null;
+                this._canvas.addEventListener("webglcontextcreationerror", (Q) => {
+                  w = { requestedAttributes: ue }, Q && (w.statusMessage = Q.statusMessage, w.type = Q.type);
+                }, { once: true });
+                let B = this._canvas.getContext("webgl2", ue) || this._canvas.getContext("webgl", ue);
+                if (!B) {
+                  let Q = "Failed to initialize WebGL";
+                  throw w ? (w.message = Q, new Error(JSON.stringify(w))) : new Error(Q);
+                }
+                this.painter = new Dc(B, this.transform), f.testSupport(B);
+              }
+              loaded() {
+                return !this._styleDirty && !this._sourcesDirty && !!this.style && this.style.loaded();
+              }
+              _update(ue) {
+                return this.style && this.style._loaded ? (this._styleDirty = this._styleDirty || ue, this._sourcesDirty = true, this.triggerRepaint(), this) : this;
+              }
+              _requestRenderFrame(ue) {
+                return this._update(), this._renderTaskQueue.add(ue);
+              }
+              _cancelRenderFrame(ue) {
+                this._renderTaskQueue.remove(ue);
+              }
+              _render(ue) {
+                let w = this._idleTriggered ? this._fadeDuration : 0;
+                if (this.painter.context.setDirty(), this.painter.setBaseState(), this._renderTaskQueue.run(ue), this._removed) return;
+                let B = false;
+                if (this.style && this._styleDirty) {
+                  this._styleDirty = false;
+                  let ee = this.transform.zoom, le = u.now();
+                  this.style.zoomHistory.update(ee, le);
+                  let Oe = new a.z(ee, { now: le, fadeDuration: w, zoomHistory: this.style.zoomHistory, transition: this.style.getTransition() }), Ze = Oe.crossFadingFactor();
+                  Ze === 1 && Ze === this._crossFadingFactor || (B = true, this._crossFadingFactor = Ze), this.style.update(Oe);
+                }
+                this.style && this._sourcesDirty && (this._sourcesDirty = false, this.style._updateSources(this.transform)), this.terrain ? (this.terrain.sourceCache.update(this.transform, this.terrain), this.transform.minElevationForCurrentTile = this.terrain.getMinTileElevationForLngLatZoom(this.transform.center, this.transform.tileZoom), this._elevationFreeze || (this.transform.elevation = this.terrain.getElevationForLngLatZoom(this.transform.center, this.transform.tileZoom))) : (this.transform.minElevationForCurrentTile = 0, this.transform.elevation = 0), this._placementDirty = this.style && this.style._updatePlacement(this.painter.transform, this.showCollisionBoxes, w, this._crossSourceCollisions), this.painter.render(this.style, { showTileBoundaries: this.showTileBoundaries, showOverdrawInspector: this._showOverdrawInspector, rotating: this.isRotating(), zooming: this.isZooming(), moving: this.isMoving(), fadeDuration: w, showPadding: this.showPadding }), this.fire(new a.k("render")), this.loaded() && !this._loaded && (this._loaded = true, a.bf.mark(a.bg.load), this.fire(new a.k("load"))), this.style && (this.style.hasTransitions() || B) && (this._styleDirty = true), this.style && !this._placementDirty && this.style._releaseSymbolFadeTiles();
+                let Q = this._sourcesDirty || this._styleDirty || this._placementDirty;
+                return Q || this._repaint ? this.triggerRepaint() : !this.isMoving() && this.loaded() && this.fire(new a.k("idle")), !this._loaded || this._fullyLoaded || Q || (this._fullyLoaded = true, a.bf.mark(a.bg.fullLoad)), this;
+              }
+              redraw() {
+                return this.style && (this._frameRequest && (this._frameRequest.abort(), this._frameRequest = null), this._render(0)), this;
+              }
+              remove() {
+                var ue;
+                this._hash && this._hash.remove();
+                for (let B of this._controls) B.onRemove(this);
+                this._controls = [], this._frameRequest && (this._frameRequest.abort(), this._frameRequest = null), this._renderTaskQueue.clear(), this.painter.destroy(), this.handlers.destroy(), delete this.handlers, this.setStyle(null), typeof window != "undefined" && removeEventListener("online", this._onWindowOnline, false), p.removeThrottleControl(this._imageQueueHandle), (ue = this._resizeObserver) === null || ue === void 0 || ue.disconnect();
+                let w = this.painter.context.gl.getExtension("WEBGL_lose_context");
+                w != null && w.loseContext && w.loseContext(), this._canvas.removeEventListener("webglcontextrestored", this._contextRestored, false), this._canvas.removeEventListener("webglcontextlost", this._contextLost, false), c.remove(this._canvasContainer), c.remove(this._controlContainer), this._container.classList.remove("maplibregl-map"), a.bf.clearMetrics(), this._removed = true, this.fire(new a.k("remove"));
+              }
+              triggerRepaint() {
+                this.style && !this._frameRequest && (this._frameRequest = new AbortController(), u.frameAsync(this._frameRequest).then((ue) => {
+                  a.bf.frame(ue), this._frameRequest = null, this._render(ue);
+                }).catch(() => {
+                }));
+              }
+              get showTileBoundaries() {
+                return !!this._showTileBoundaries;
+              }
+              set showTileBoundaries(ue) {
+                this._showTileBoundaries !== ue && (this._showTileBoundaries = ue, this._update());
+              }
+              get showPadding() {
+                return !!this._showPadding;
+              }
+              set showPadding(ue) {
+                this._showPadding !== ue && (this._showPadding = ue, this._update());
+              }
+              get showCollisionBoxes() {
+                return !!this._showCollisionBoxes;
+              }
+              set showCollisionBoxes(ue) {
+                this._showCollisionBoxes !== ue && (this._showCollisionBoxes = ue, ue ? this.style._generateCollisionBoxes() : this._update());
+              }
+              get showOverdrawInspector() {
+                return !!this._showOverdrawInspector;
+              }
+              set showOverdrawInspector(ue) {
+                this._showOverdrawInspector !== ue && (this._showOverdrawInspector = ue, this._update());
+              }
+              get repaint() {
+                return !!this._repaint;
+              }
+              set repaint(ue) {
+                this._repaint !== ue && (this._repaint = ue, this.triggerRepaint());
+              }
+              get vertices() {
+                return !!this._vertices;
+              }
+              set vertices(ue) {
+                this._vertices = ue, this._update();
+              }
+              get version() {
+                return ml;
+              }
+              getCameraTargetElevation() {
+                return this.transform.elevation;
+              }
+            }, i.MapMouseEvent = jl, i.MapTouchEvent = lf, i.MapWheelEvent = Xh, i.Marker = Yu, i.NavigationControl = class {
+              constructor(ue) {
+                this._updateZoomButtons = () => {
+                  let w = this._map.getZoom(), B = w === this._map.getMaxZoom(), Q = w === this._map.getMinZoom();
+                  this._zoomInButton.disabled = B, this._zoomOutButton.disabled = Q, this._zoomInButton.setAttribute("aria-disabled", B.toString()), this._zoomOutButton.setAttribute("aria-disabled", Q.toString());
+                }, this._rotateCompassArrow = () => {
+                  let w = this.options.visualizePitch ? `scale(${1 / Math.pow(Math.cos(this._map.transform.pitch * (Math.PI / 180)), 0.5)}) rotateX(${this._map.transform.pitch}deg) rotateZ(${this._map.transform.angle * (180 / Math.PI)}deg)` : `rotate(${this._map.transform.angle * (180 / Math.PI)}deg)`;
+                  this._compassIcon.style.transform = w;
+                }, this._setButtonTitle = (w, B) => {
+                  let Q = this._map._getUIString(`NavigationControl.${B}`);
+                  w.title = Q, w.setAttribute("aria-label", Q);
+                }, this.options = a.e({}, va, ue), this._container = c.create("div", "maplibregl-ctrl maplibregl-ctrl-group"), this._container.addEventListener("contextmenu", (w) => w.preventDefault()), this.options.showZoom && (this._zoomInButton = this._createButton("maplibregl-ctrl-zoom-in", (w) => this._map.zoomIn({}, { originalEvent: w })), c.create("span", "maplibregl-ctrl-icon", this._zoomInButton).setAttribute("aria-hidden", "true"), this._zoomOutButton = this._createButton("maplibregl-ctrl-zoom-out", (w) => this._map.zoomOut({}, { originalEvent: w })), c.create("span", "maplibregl-ctrl-icon", this._zoomOutButton).setAttribute("aria-hidden", "true")), this.options.showCompass && (this._compass = this._createButton("maplibregl-ctrl-compass", (w) => {
+                  this.options.visualizePitch ? this._map.resetNorthPitch({}, { originalEvent: w }) : this._map.resetNorth({}, { originalEvent: w });
+                }), this._compassIcon = c.create("span", "maplibregl-ctrl-icon", this._compass), this._compassIcon.setAttribute("aria-hidden", "true"));
+              }
+              onAdd(ue) {
+                return this._map = ue, this.options.showZoom && (this._setButtonTitle(this._zoomInButton, "ZoomIn"), this._setButtonTitle(this._zoomOutButton, "ZoomOut"), this._map.on("zoom", this._updateZoomButtons), this._updateZoomButtons()), this.options.showCompass && (this._setButtonTitle(this._compass, "ResetBearing"), this.options.visualizePitch && this._map.on("pitch", this._rotateCompassArrow), this._map.on("rotate", this._rotateCompassArrow), this._rotateCompassArrow(), this._handler = new no(this._map, this._compass, this.options.visualizePitch)), this._container;
+              }
+              onRemove() {
+                c.remove(this._container), this.options.showZoom && this._map.off("zoom", this._updateZoomButtons), this.options.showCompass && (this.options.visualizePitch && this._map.off("pitch", this._rotateCompassArrow), this._map.off("rotate", this._rotateCompassArrow), this._handler.off(), delete this._handler), delete this._map;
+              }
+              _createButton(ue, w) {
+                let B = c.create("button", ue, this._container);
+                return B.type = "button", B.addEventListener("click", w), B;
+              }
+            }, i.Popup = class extends a.E {
+              constructor(ue) {
+                super(), this.remove = () => (this._content && c.remove(this._content), this._container && (c.remove(this._container), delete this._container), this._map && (this._map.off("move", this._update), this._map.off("move", this._onClose), this._map.off("click", this._onClose), this._map.off("remove", this.remove), this._map.off("mousemove", this._onMouseMove), this._map.off("mouseup", this._onMouseUp), this._map.off("drag", this._onDrag), this._map._canvasContainer.classList.remove("maplibregl-track-pointer"), delete this._map, this.fire(new a.k("close"))), this), this._onMouseUp = (w) => {
+                  this._update(w.point);
+                }, this._onMouseMove = (w) => {
+                  this._update(w.point);
+                }, this._onDrag = (w) => {
+                  this._update(w.point);
+                }, this._update = (w) => {
+                  var B;
+                  if (!this._map || !this._lngLat && !this._trackPointer || !this._content) return;
+                  if (!this._container) {
+                    if (this._container = c.create("div", "maplibregl-popup", this._map.getContainer()), this._tip = c.create("div", "maplibregl-popup-tip", this._container), this._container.appendChild(this._content), this.options.className) for (let Ze of this.options.className.split(" ")) this._container.classList.add(Ze);
+                    this._closeButton && this._closeButton.setAttribute("aria-label", this._map._getUIString("Popup.Close")), this._trackPointer && this._container.classList.add("maplibregl-popup-track-pointer");
+                  }
+                  if (this.options.maxWidth && this._container.style.maxWidth !== this.options.maxWidth && (this._container.style.maxWidth = this.options.maxWidth), this._lngLat = this._map.transform.renderWorldCopies && !this._trackPointer ? rs(this._lngLat, this._flatPos, this._map.transform) : (B = this._lngLat) === null || B === void 0 ? void 0 : B.wrap(), this._trackPointer && !w) return;
+                  let Q = this._flatPos = this._pos = this._trackPointer && w ? w : this._map.project(this._lngLat);
+                  this._map.terrain && (this._flatPos = this._trackPointer && w ? w : this._map.transform.locationPoint(this._lngLat));
+                  let ee = this.options.anchor, le = hc(this.options.offset);
+                  if (!ee) {
+                    let Ze = this._container.offsetWidth, st = this._container.offsetHeight, Tt;
+                    Tt = Q.y + le.bottom.y < st ? ["top"] : Q.y > this._map.transform.height - st ? ["bottom"] : [], Q.x < Ze / 2 ? Tt.push("left") : Q.x > this._map.transform.width - Ze / 2 && Tt.push("right"), ee = Tt.length === 0 ? "bottom" : Tt.join("-");
+                  }
+                  let Oe = Q.add(le[ee]);
+                  this.options.subpixelPositioning || (Oe = Oe.round()), c.setTransform(this._container, `${Ql[ee]} translate(${Oe.x}px,${Oe.y}px)`), Cu(this._container, ee, "popup");
+                }, this._onClose = () => {
+                  this.remove();
+                }, this.options = a.e(Object.create(oo), ue);
+              }
+              addTo(ue) {
+                return this._map && this.remove(), this._map = ue, this.options.closeOnClick && this._map.on("click", this._onClose), this.options.closeOnMove && this._map.on("move", this._onClose), this._map.on("remove", this.remove), this._update(), this._focusFirstElement(), this._trackPointer ? (this._map.on("mousemove", this._onMouseMove), this._map.on("mouseup", this._onMouseUp), this._container && this._container.classList.add("maplibregl-popup-track-pointer"), this._map._canvasContainer.classList.add("maplibregl-track-pointer")) : this._map.on("move", this._update), this.fire(new a.k("open")), this;
+              }
+              isOpen() {
+                return !!this._map;
+              }
+              getLngLat() {
+                return this._lngLat;
+              }
+              setLngLat(ue) {
+                return this._lngLat = a.N.convert(ue), this._pos = null, this._flatPos = null, this._trackPointer = false, this._update(), this._map && (this._map.on("move", this._update), this._map.off("mousemove", this._onMouseMove), this._container && this._container.classList.remove("maplibregl-popup-track-pointer"), this._map._canvasContainer.classList.remove("maplibregl-track-pointer")), this;
+              }
+              trackPointer() {
+                return this._trackPointer = true, this._pos = null, this._flatPos = null, this._update(), this._map && (this._map.off("move", this._update), this._map.on("mousemove", this._onMouseMove), this._map.on("drag", this._onDrag), this._container && this._container.classList.add("maplibregl-popup-track-pointer"), this._map._canvasContainer.classList.add("maplibregl-track-pointer")), this;
+              }
+              getElement() {
+                return this._container;
+              }
+              setText(ue) {
+                return this.setDOMContent(document.createTextNode(ue));
+              }
+              setHTML(ue) {
+                let w = document.createDocumentFragment(), B = document.createElement("body"), Q;
+                for (B.innerHTML = ue; Q = B.firstChild, Q; ) w.appendChild(Q);
+                return this.setDOMContent(w);
+              }
+              getMaxWidth() {
+                var ue;
+                return (ue = this._container) === null || ue === void 0 ? void 0 : ue.style.maxWidth;
+              }
+              setMaxWidth(ue) {
+                return this.options.maxWidth = ue, this._update(), this;
+              }
+              setDOMContent(ue) {
+                if (this._content) for (; this._content.hasChildNodes(); ) this._content.firstChild && this._content.removeChild(this._content.firstChild);
+                else this._content = c.create("div", "maplibregl-popup-content", this._container);
+                return this._content.appendChild(ue), this._createCloseButton(), this._update(), this._focusFirstElement(), this;
+              }
+              addClassName(ue) {
+                return this._container && this._container.classList.add(ue), this;
+              }
+              removeClassName(ue) {
+                return this._container && this._container.classList.remove(ue), this;
+              }
+              setOffset(ue) {
+                return this.options.offset = ue, this._update(), this;
+              }
+              toggleClassName(ue) {
+                if (this._container) return this._container.classList.toggle(ue);
+              }
+              setSubpixelPositioning(ue) {
+                this.options.subpixelPositioning = ue;
+              }
+              _createCloseButton() {
+                this.options.closeButton && (this._closeButton = c.create("button", "maplibregl-popup-close-button", this._content), this._closeButton.type = "button", this._closeButton.innerHTML = "&#215;", this._closeButton.addEventListener("click", this._onClose));
+              }
+              _focusFirstElement() {
+                if (!this.options.focusAfterOpen || !this._container) return;
+                let ue = this._container.querySelector(Vc);
+                ue && ue.focus();
+              }
+            }, i.RasterDEMTileSource = Vt, i.RasterTileSource = pt, i.ScaleControl = class {
+              constructor(ue) {
+                this._onMove = () => {
+                  Ac(this._map, this._container, this.options);
+                }, this.setUnit = (w) => {
+                  this.options.unit = w, Ac(this._map, this._container, this.options);
+                }, this.options = Object.assign(Object.assign({}, xu), ue);
+              }
+              getDefaultPosition() {
+                return "bottom-left";
+              }
+              onAdd(ue) {
+                return this._map = ue, this._container = c.create("div", "maplibregl-ctrl maplibregl-ctrl-scale", ue.getContainer()), this._map.on("move", this._onMove), this._onMove(), this._container;
+              }
+              onRemove() {
+                c.remove(this._container), this._map.off("move", this._onMove), this._map = void 0;
+              }
+            }, i.ScrollZoomHandler = Kr, i.Style = Ha, i.TerrainControl = class {
+              constructor(ue) {
+                this._toggleTerrain = () => {
+                  this._map.getTerrain() ? this._map.setTerrain(null) : this._map.setTerrain(this.options), this._updateTerrainIcon();
+                }, this._updateTerrainIcon = () => {
+                  this._terrainButton.classList.remove("maplibregl-ctrl-terrain"), this._terrainButton.classList.remove("maplibregl-ctrl-terrain-enabled"), this._map.terrain ? (this._terrainButton.classList.add("maplibregl-ctrl-terrain-enabled"), this._terrainButton.title = this._map._getUIString("TerrainControl.Disable")) : (this._terrainButton.classList.add("maplibregl-ctrl-terrain"), this._terrainButton.title = this._map._getUIString("TerrainControl.Enable"));
+                }, this.options = ue;
+              }
+              onAdd(ue) {
+                return this._map = ue, this._container = c.create("div", "maplibregl-ctrl maplibregl-ctrl-group"), this._terrainButton = c.create("button", "maplibregl-ctrl-terrain", this._container), c.create("span", "maplibregl-ctrl-icon", this._terrainButton).setAttribute("aria-hidden", "true"), this._terrainButton.type = "button", this._terrainButton.addEventListener("click", this._toggleTerrain), this._updateTerrainIcon(), this._map.on("terrain", this._updateTerrainIcon), this._container;
+              }
+              onRemove() {
+                c.remove(this._container), this._map.off("terrain", this._updateTerrainIcon), this._map = void 0;
+              }
+            }, i.TwoFingersTouchPitchHandler = Bc, i.TwoFingersTouchRotateHandler = cf, i.TwoFingersTouchZoomHandler = vu, i.TwoFingersTouchZoomRotateHandler = Yi, i.VectorTileSource = lt, i.VideoSource = Nt, i.addSourceType = (ue, w) => a._(void 0, void 0, void 0, function* () {
+              if (Tr(ue)) throw new Error(`A source type called "${ue}" already exists.`);
+              ((B, Q) => {
+                sr[B] = Q;
+              })(ue, w);
+            }), i.clearPrewarmedResources = function() {
+              let ue = ge;
+              ue && (ue.isPreloaded() && ue.numActive() === 1 ? (ue.release(_e), ge = null) : console.warn("Could not clear WebWorkers since there are active Map instances that still reference it. The pre-warmed WebWorker pool can only be cleared when all map instances have been removed with map.remove()"));
+            }, i.getMaxParallelImageRequests = function() {
+              return a.a.MAX_PARALLEL_IMAGE_REQUESTS;
+            }, i.getRTLTextPluginStatus = function() {
+              return Qt().getRTLTextPluginStatus();
+            }, i.getVersion = function() {
+              return Ku;
+            }, i.getWorkerCount = function() {
+              return Ce.workerCount;
+            }, i.getWorkerUrl = function() {
+              return a.a.WORKER_URL;
+            }, i.importScriptInWorkers = function(ue) {
+              return Ae().broadcast("IS", ue);
+            }, i.prewarm = function() {
+              Se().acquire(_e);
+            }, i.setMaxParallelImageRequests = function(ue) {
+              a.a.MAX_PARALLEL_IMAGE_REQUESTS = ue;
+            }, i.setRTLTextPlugin = function(ue, w) {
+              return Qt().setRTLTextPlugin(ue, w);
+            }, i.setWorkerCount = function(ue) {
+              Ce.workerCount = ue;
+            }, i.setWorkerUrl = function(ue) {
+              a.a.WORKER_URL = ue;
+            };
+          });
+          var n = e;
+          return n;
+        });
+      });
+      var yje = ye((Bbr, mje) => {
+        var vw = Dr(), FXt = Zl().sanitizeHTML, zXt = IJ(), vje = Px();
+        function pje(e, t) {
+          this.subplot = e, this.uid = e.uid + "-" + t, this.index = t, this.idSource = "source-" + this.uid, this.idLayer = vje.layoutLayerPrefix + this.uid, this.sourceType = null, this.source = null, this.layerType = null, this.below = null, this.visible = false;
+        }
+        var sg = pje.prototype;
+        sg.update = function(t) {
+          this.visible ? this.needsNewImage(t) ? this.updateImage(t) : this.needsNewSource(t) ? (this.removeLayer(), this.updateSource(t), this.updateLayer(t)) : this.needsNewLayer(t) ? this.updateLayer(t) : this.updateStyle(t) : (this.updateSource(t), this.updateLayer(t)), this.visible = v7(t);
+        };
+        sg.needsNewImage = function(e) {
+          var t = this.subplot.map;
+          return t.getSource(this.idSource) && this.sourceType === "image" && e.sourcetype === "image" && (this.source !== e.source || JSON.stringify(this.coordinates) !== JSON.stringify(e.coordinates));
+        };
+        sg.needsNewSource = function(e) {
+          return this.sourceType !== e.sourcetype || JSON.stringify(this.source) !== JSON.stringify(e.source) || this.layerType !== e.type;
+        };
+        sg.needsNewLayer = function(e) {
+          return this.layerType !== e.type || this.below !== this.subplot.belowLookup["layout-" + this.index];
+        };
+        sg.lookupBelow = function() {
+          return this.subplot.belowLookup["layout-" + this.index];
+        };
+        sg.updateImage = function(e) {
+          var t = this.subplot.map;
+          t.getSource(this.idSource).updateImage({ url: e.source, coordinates: e.coordinates });
+          var r = this.findFollowingMapLayerId(this.lookupBelow());
+          r !== null && this.subplot.map.moveLayer(this.idLayer, r);
+        };
+        sg.updateSource = function(e) {
+          var t = this.subplot.map;
+          if (t.getSource(this.idSource) && t.removeSource(this.idSource), this.sourceType = e.sourcetype, this.source = e.source, !!v7(e)) {
+            var r = OXt(e);
+            t.addSource(this.idSource, r);
+          }
+        };
+        sg.findFollowingMapLayerId = function(e) {
+          if (e === "traces") for (var t = this.subplot.getMapLayers(), r = 0; r < t.length; r++) {
+            var n = t[r].id;
+            if (typeof n == "string" && n.indexOf(vje.traceLayerPrefix) === 0) {
+              e = n;
+              break;
+            }
+          }
+          return e;
+        };
+        sg.updateLayer = function(e) {
+          var t = this.subplot, r = gje(e), n = this.lookupBelow(), i = this.findFollowingMapLayerId(n);
+          this.removeLayer(), v7(e) && t.addLayer({ id: this.idLayer, source: this.idSource, "source-layer": e.sourcelayer || "", type: e.type, minzoom: e.minzoom, maxzoom: e.maxzoom, layout: r.layout, paint: r.paint }, i), this.layerType = e.type, this.below = n;
+        };
+        sg.updateStyle = function(e) {
+          if (v7(e)) {
+            var t = gje(e);
+            this.subplot.setOptions(this.idLayer, "setLayoutProperty", t.layout), this.subplot.setOptions(this.idLayer, "setPaintProperty", t.paint);
+          }
+        };
+        sg.removeLayer = function() {
+          var e = this.subplot.map;
+          e.getLayer(this.idLayer) && e.removeLayer(this.idLayer);
+        };
+        sg.dispose = function() {
+          var e = this.subplot.map;
+          e.getLayer(this.idLayer) && e.removeLayer(this.idLayer), e.getSource(this.idSource) && e.removeSource(this.idSource);
+        };
+        function v7(e) {
+          if (!e.visible) return false;
+          var t = e.source;
+          if (Array.isArray(t) && t.length > 0) {
+            for (var r = 0; r < t.length; r++) if (typeof t[r] != "string" || t[r].length === 0) return false;
+            return true;
+          }
+          return vw.isPlainObject(t) || typeof t == "string" && t.length > 0;
+        }
+        function gje(e) {
+          var t = {}, r = {};
+          switch (e.type) {
+            case "circle":
+              vw.extendFlat(r, { "circle-radius": e.circle.radius, "circle-color": e.color, "circle-opacity": e.opacity });
+              break;
+            case "line":
+              vw.extendFlat(r, { "line-width": e.line.width, "line-color": e.color, "line-opacity": e.opacity, "line-dasharray": e.line.dash });
+              break;
+            case "fill":
+              vw.extendFlat(r, { "fill-color": e.color, "fill-outline-color": e.fill.outlinecolor, "fill-opacity": e.opacity });
+              break;
+            case "symbol":
+              var n = e.symbol, i = zXt(n.textposition, n.iconsize);
+              vw.extendFlat(t, { "icon-image": n.icon + "-15", "icon-size": n.iconsize / 10, "text-field": n.text, "text-size": n.textfont.size, "text-anchor": i.anchor, "text-offset": i.offset, "symbol-placement": n.placement }), vw.extendFlat(r, { "icon-color": e.color, "text-color": n.textfont.color, "text-opacity": e.opacity });
+              break;
+            case "raster":
+              vw.extendFlat(r, { "raster-fade-duration": 0, "raster-opacity": e.opacity });
+              break;
+          }
+          return { layout: t, paint: r };
+        }
+        function OXt(e) {
+          var t = e.sourcetype, r = e.source, n = { type: t }, i;
+          return t === "geojson" ? i = "data" : t === "vector" ? i = typeof r == "string" ? "url" : "tiles" : t === "raster" ? (i = "tiles", n.tileSize = 256) : t === "image" && (i = "url", n.coordinates = e.coordinates), n[i] = r, e.sourceattribution && (n.attribution = FXt(e.sourceattribution)), n;
+        }
+        mje.exports = function(t, r, n) {
+          var i = new pje(t, r);
+          return i.update(n), i;
+        };
+      });
+      var Mje = ye((Nbr, Sje) => {
+        var qJ = dje(), BJ = Dr(), bje = hx(), _je = qa(), qXt = ho(), BXt = yv(), p7 = vf(), wje = Cg(), NXt = wje.drawMode, UXt = wje.selectMode, VXt = Of().prepSelect, GXt = Of().clearOutline, HXt = Of().clearSelectionsCache, jXt = Of().selectOnClick, pw = Px(), WXt = yje();
+        function Tje(e, t) {
+          this.id = t, this.gd = e;
+          var r = e._fullLayout, n = e._context;
+          this.container = r._glcontainer.node(), this.isStatic = n.staticPlot, this.uid = r._uid + "-" + this.id, this.div = null, this.xaxis = null, this.yaxis = null, this.createFramework(r), this.map = null, this.styleObj = null, this.traceHash = {}, this.layerList = [], this.belowLookup = {}, this.dragging = false, this.wheeling = false;
+        }
+        var Hh = Tje.prototype;
+        Hh.plot = function(e, t, r) {
+          var n = this, i;
+          n.map ? i = new Promise(function(a, o) {
+            n.updateMap(e, t, a, o);
+          }) : i = new Promise(function(a, o) {
+            n.createMap(e, t, a, o);
+          }), r.push(i);
+        };
+        Hh.createMap = function(e, t, r, n) {
+          var i = this, a = t[i.id], o = i.styleObj = Aje(a.style), s = a.bounds, l = s ? [[s.west, s.south], [s.east, s.north]] : null, u = i.map = new qJ.Map({ container: i.div, style: o.style, center: NJ(a.center), zoom: a.zoom, bearing: a.bearing, pitch: a.pitch, maxBounds: l, interactive: !i.isStatic, preserveDrawingBuffer: i.isStatic, doubleClickZoom: false, boxZoom: false, attributionControl: false }).addControl(new qJ.AttributionControl({ compact: true })), c = {};
+          u.on("styleimagemissing", function(h) {
+            var d = h.id;
+            if (!c[d] && d.includes("-15")) {
+              c[d] = true;
+              var v = new Image(15, 15);
+              v.onload = function() {
+                u.addImage(d, v);
+              }, v.crossOrigin = "Anonymous", v.src = "https://unpkg.com/maki@2.1.0/icons/" + d + ".svg";
+            }
+          }), u.setTransformRequest(function(h) {
+            return h = h.replace("https://fonts.openmaptiles.org/Open Sans Extrabold", "https://fonts.openmaptiles.org/Open Sans Extra Bold"), h = h.replace("https://tiles.basemaps.cartocdn.com/fonts/Open Sans Extrabold", "https://fonts.openmaptiles.org/Open Sans Extra Bold"), h = h.replace("https://fonts.openmaptiles.org/Open Sans Regular,Arial Unicode MS Regular", "https://fonts.openmaptiles.org/Klokantech Noto Sans Regular"), { url: h };
+          }), u._canvas.style.left = "0px", u._canvas.style.top = "0px", i.rejectOnError(n), i.isStatic || i.initFx(e, t);
+          var f = [];
+          f.push(new Promise(function(h) {
+            u.once("load", h);
+          })), f = f.concat(bje.fetchTraceGeoData(e)), Promise.all(f).then(function() {
+            i.fillBelowLookup(e, t), i.updateData(e), i.updateLayout(t), i.resolveOnRender(r);
+          }).catch(n);
+        };
+        Hh.updateMap = function(e, t, r, n) {
+          var i = this, a = i.map, o = t[this.id];
+          i.rejectOnError(n);
+          var s = [], l = Aje(o.style);
+          JSON.stringify(i.styleObj) !== JSON.stringify(l) && (i.styleObj = l, a.setStyle(l.style), i.traceHash = {}, s.push(new Promise(function(u) {
+            a.once("styledata", u);
+          }))), s = s.concat(bje.fetchTraceGeoData(e)), Promise.all(s).then(function() {
+            i.fillBelowLookup(e, t), i.updateData(e), i.updateLayout(t), i.resolveOnRender(r);
+          }).catch(n);
+        };
+        Hh.fillBelowLookup = function(e, t) {
+          var r = t[this.id], n = r.layers, i, a, o = this.belowLookup = {}, s = false;
+          for (i = 0; i < e.length; i++) {
+            var l = e[i][0].trace, u = l._module;
+            typeof l.below == "string" ? a = l.below : u.getBelow && (a = u.getBelow(l, this)), a === "" && (s = true), o["trace-" + l.uid] = a || "";
+          }
+          for (i = 0; i < n.length; i++) {
+            var c = n[i];
+            typeof c.below == "string" ? a = c.below : s ? a = "traces" : a = "", o["layout-" + i] = a;
+          }
+          var f = {}, h, d;
+          for (h in o) a = o[h], f[a] ? f[a].push(h) : f[a] = [h];
+          for (a in f) {
+            var v = f[a];
+            if (v.length > 1) for (i = 0; i < v.length; i++) h = v[i], h.indexOf("trace-") === 0 ? (d = h.split("trace-")[1], this.traceHash[d] && (this.traceHash[d].below = null)) : h.indexOf("layout-") === 0 && (d = h.split("layout-")[1], this.layerList[d] && (this.layerList[d].below = null));
+          }
+        };
+        var xje = { choroplethmap: 0, densitymap: 1, scattermap: 2 };
+        Hh.updateData = function(e) {
+          var t = this.traceHash, r, n, i, a, o = e.slice().sort(function(f, h) {
+            return xje[f[0].trace.type] - xje[h[0].trace.type];
+          });
+          for (i = 0; i < o.length; i++) {
+            var s = o[i];
+            n = s[0].trace, r = t[n.uid];
+            var l = false;
+            r && (r.type === n.type ? (r.update(s), l = true) : r.dispose()), !l && n._module && (t[n.uid] = n._module.plot(this, s));
+          }
+          var u = Object.keys(t);
+          e: for (i = 0; i < u.length; i++) {
+            var c = u[i];
+            for (a = 0; a < e.length; a++) if (n = e[a][0].trace, c === n.uid) continue e;
+            r = t[c], r.dispose(), delete t[c];
+          }
+        };
+        Hh.updateLayout = function(e) {
+          var t = this.map, r = e[this.id];
+          !this.dragging && !this.wheeling && (t.setCenter(NJ(r.center)), t.setZoom(r.zoom), t.setBearing(r.bearing), t.setPitch(r.pitch)), this.updateLayers(e), this.updateFramework(e), this.updateFx(e), this.map.resize(), this.gd._context._scrollZoom.map ? t.scrollZoom.enable() : t.scrollZoom.disable();
+        };
+        Hh.resolveOnRender = function(e) {
+          var t = this.map;
+          t.on("render", function r() {
+            t.loaded() && (t.off("render", r), setTimeout(e, 10));
+          });
+        };
+        Hh.rejectOnError = function(e) {
+          var t = this.map;
+          function r() {
+            e(new Error(pw.mapOnErrorMsg));
+          }
+          t.once("error", r), t.once("style.error", r), t.once("source.error", r), t.once("tile.error", r), t.once("layer.error", r);
+        };
+        Hh.createFramework = function(e) {
+          var t = this, r = t.div = document.createElement("div");
+          r.id = t.uid, r.style.position = "absolute", t.container.appendChild(r), t.xaxis = { _id: "x", c2p: function(n) {
+            return t.project(n).x;
+          } }, t.yaxis = { _id: "y", c2p: function(n) {
+            return t.project(n).y;
+          } }, t.updateFramework(e), t.mockAxis = { type: "linear", showexponent: "all", exponentformat: "B" }, qXt.setConvert(t.mockAxis, e);
+        };
+        Hh.initFx = function(e, t) {
+          var r = this, n = r.gd, i = r.map;
+          i.on("moveend", function(s) {
+            if (r.map) {
+              var l = n._fullLayout;
+              if (s.originalEvent || r.wheeling) {
+                var u = l[r.id];
+                _je.call("_storeDirectGUIEdit", n.layout, l._preGUI, r.getViewEdits(u));
+                var c = r.getView();
+                u._input.center = u.center = c.center, u._input.zoom = u.zoom = c.zoom, u._input.bearing = u.bearing = c.bearing, u._input.pitch = u.pitch = c.pitch, n.emit("plotly_relayout", r.getViewEditsWithDerived(c));
+              }
+              s.originalEvent && s.originalEvent.type === "mouseup" ? r.dragging = false : r.wheeling && (r.wheeling = false), l && l._rehover && l._rehover();
+            }
+          }), i.on("wheel", function() {
+            r.wheeling = true;
+          }), i.on("mousemove", function(s) {
+            var l = r.div.getBoundingClientRect(), u = [s.originalEvent.offsetX, s.originalEvent.offsetY];
+            s.target.getBoundingClientRect = function() {
+              return l;
+            }, r.xaxis.p2c = function() {
+              return i.unproject(u).lng;
+            }, r.yaxis.p2c = function() {
+              return i.unproject(u).lat;
+            }, n._fullLayout._rehover = function() {
+              n._fullLayout._hoversubplot === r.id && n._fullLayout[r.id] && p7.hover(n, s, r.id);
+            }, p7.hover(n, s, r.id), n._fullLayout._hoversubplot = r.id;
+          });
+          function a() {
+            p7.loneUnhover(t._hoverlayer);
+          }
+          i.on("dragstart", function() {
+            r.dragging = true, a();
+          }), i.on("zoomstart", a), i.on("mouseout", function() {
+            n._fullLayout._hoversubplot = null;
+          });
+          function o() {
+            var s = r.getView();
+            n.emit("plotly_relayouting", r.getViewEditsWithDerived(s));
+          }
+          i.on("drag", o), i.on("zoom", o), i.on("dblclick", function() {
+            var s = n._fullLayout[r.id];
+            _je.call("_storeDirectGUIEdit", n.layout, n._fullLayout._preGUI, r.getViewEdits(s));
+            var l = r.viewInitial;
+            i.setCenter(NJ(l.center)), i.setZoom(l.zoom), i.setBearing(l.bearing), i.setPitch(l.pitch);
+            var u = r.getView();
+            s._input.center = s.center = u.center, s._input.zoom = s.zoom = u.zoom, s._input.bearing = s.bearing = u.bearing, s._input.pitch = s.pitch = u.pitch, n.emit("plotly_doubleclick", null), n.emit("plotly_relayout", r.getViewEditsWithDerived(u));
+          }), r.clearOutline = function() {
+            HXt(r.dragOptions), GXt(r.dragOptions.gd);
+          }, r.onClickInPanFn = function(s) {
+            return function(l) {
+              var u = n._fullLayout.clickmode;
+              u.indexOf("select") > -1 && jXt(l.originalEvent, n, [r.xaxis], [r.yaxis], r.id, s), u.indexOf("event") > -1 && p7.click(n, l.originalEvent);
+            };
+          };
+        };
+        Hh.updateFx = function(e) {
+          var t = this, r = t.map, n = t.gd;
+          if (t.isStatic) return;
+          function i(l) {
+            var u = t.map.unproject(l);
+            return [u.lng, u.lat];
+          }
+          var a = e.dragmode, o;
+          o = function(l, u) {
+            if (u.isRect) {
+              var c = l.range = {};
+              c[t.id] = [i([u.xmin, u.ymin]), i([u.xmax, u.ymax])];
+            } else {
+              var f = l.lassoPoints = {};
+              f[t.id] = u.map(i);
+            }
+          };
+          var s = t.dragOptions;
+          t.dragOptions = BJ.extendDeep(s || {}, { dragmode: e.dragmode, element: t.div, gd: n, plotinfo: { id: t.id, domain: e[t.id].domain, xaxis: t.xaxis, yaxis: t.yaxis, fillRangeItems: o }, xaxes: [t.xaxis], yaxes: [t.yaxis], subplot: t.id }), r.off("click", t.onClickInPanHandler), UXt(a) || NXt(a) ? (r.dragPan.disable(), r.on("zoomstart", t.clearOutline), t.dragOptions.prepFn = function(l, u, c) {
+            VXt(l, u, c, t.dragOptions, a);
+          }, BXt.init(t.dragOptions)) : (r.dragPan.enable(), r.off("zoomstart", t.clearOutline), t.div.onmousedown = null, t.div.ontouchstart = null, t.div.removeEventListener("touchstart", t.div._ontouchstart), t.onClickInPanHandler = t.onClickInPanFn(t.dragOptions), r.on("click", t.onClickInPanHandler));
+        };
+        Hh.updateFramework = function(e) {
+          var t = e[this.id].domain, r = e._size, n = this.div.style;
+          n.width = r.w * (t.x[1] - t.x[0]) + "px", n.height = r.h * (t.y[1] - t.y[0]) + "px", n.left = r.l + t.x[0] * r.w + "px", n.top = r.t + (1 - t.y[1]) * r.h + "px", this.xaxis._offset = r.l + t.x[0] * r.w, this.xaxis._length = r.w * (t.x[1] - t.x[0]), this.yaxis._offset = r.t + (1 - t.y[1]) * r.h, this.yaxis._length = r.h * (t.y[1] - t.y[0]);
+        };
+        Hh.updateLayers = function(e) {
+          var t = e[this.id], r = t.layers, n = this.layerList, i;
+          if (r.length !== n.length) {
+            for (i = 0; i < n.length; i++) n[i].dispose();
+            for (n = this.layerList = [], i = 0; i < r.length; i++) n.push(WXt(this, i, r[i]));
+          } else for (i = 0; i < r.length; i++) n[i].update(r[i]);
+        };
+        Hh.destroy = function() {
+          this.map && (this.map.remove(), this.map = null, this.container.removeChild(this.div));
+        };
+        Hh.toImage = function() {
+          return this.map.stop(), this.map.getCanvas().toDataURL();
+        };
+        Hh.setOptions = function(e, t, r) {
+          for (var n in r) this.map[t](e, n, r[n]);
+        };
+        Hh.getMapLayers = function() {
+          return this.map.getStyle().layers;
+        };
+        Hh.addLayer = function(e, t) {
+          var r = this.map;
+          if (typeof t == "string") {
+            if (t === "") {
+              r.addLayer(e, t);
+              return;
+            }
+            for (var n = this.getMapLayers(), i = 0; i < n.length; i++) if (t === n[i].id) {
+              r.addLayer(e, t);
+              return;
+            }
+            BJ.warn(["Trying to add layer with *below* value", t, "referencing a layer that does not exist", "or that does not yet exist."].join(" "));
+          }
+          r.addLayer(e);
+        };
+        Hh.project = function(e) {
+          return this.map.project(new qJ.LngLat(e[0], e[1]));
+        };
+        Hh.getView = function() {
+          var e = this.map, t = e.getCenter(), r = t.lng, n = t.lat, i = { lon: r, lat: n }, a = e.getCanvas(), o = parseInt(a.style.width), s = parseInt(a.style.height);
+          return { center: i, zoom: e.getZoom(), bearing: e.getBearing(), pitch: e.getPitch(), _derived: { coordinates: [e.unproject([0, 0]).toArray(), e.unproject([o, 0]).toArray(), e.unproject([o, s]).toArray(), e.unproject([0, s]).toArray()] } };
+        };
+        Hh.getViewEdits = function(e) {
+          for (var t = this.id, r = ["center", "zoom", "bearing", "pitch"], n = {}, i = 0; i < r.length; i++) {
+            var a = r[i];
+            n[t + "." + a] = e[a];
+          }
+          return n;
+        };
+        Hh.getViewEditsWithDerived = function(e) {
+          var t = this.id, r = this.getViewEdits(e);
+          return r[t + "._derived"] = e._derived, r;
+        };
+        function Aje(e) {
+          var t = {};
+          return BJ.isPlainObject(e) ? (t.id = e.id, t.style = e) : typeof e == "string" ? (t.id = e, pw.stylesMap[e] ? t.style = pw.stylesMap[e] : t.style = e) : (t.id = pw.styleValueDflt, t.style = XXt(pw.styleValueDflt)), t.transition = { duration: 0, delay: 0 }, t;
+        }
+        function XXt(e) {
+          return pw.styleUrlPrefix + e + "-" + pw.styleUrlSuffix;
+        }
+        function NJ(e) {
+          return [e.lon, e.lat];
+        }
+        Sje.exports = Tje;
+      });
+      var Cje = ye((Ubr, kje) => {
+        var UJ = Dr(), ZXt = O_(), YXt = Zd(), Eje = Qk();
+        kje.exports = function(t, r, n) {
+          ZXt(t, r, n, { type: "map", attributes: Eje, handleDefaults: KXt, partition: "y" });
+        };
+        function KXt(e, t, r) {
+          r("style"), r("center.lon"), r("center.lat"), r("zoom"), r("bearing"), r("pitch");
+          var n = r("bounds.west"), i = r("bounds.east"), a = r("bounds.south"), o = r("bounds.north");
+          (n === void 0 || i === void 0 || a === void 0 || o === void 0) && delete t.bounds, YXt(e, t, { name: "layers", handleItemDefaults: JXt }), t._input = e;
+        }
+        function JXt(e, t) {
+          function r(l, u) {
+            return UJ.coerce(e, t, Eje.layers, l, u);
+          }
+          var n = r("visible");
+          if (n) {
+            var i = r("sourcetype"), a = i === "raster" || i === "image";
+            r("source"), r("sourceattribution"), i === "vector" && r("sourcelayer"), i === "image" && r("coordinates");
+            var o;
+            a && (o = "raster");
+            var s = r("type", o);
+            a && s !== "raster" && (s = t.type = "raster", UJ.log("Source types *raster* and *image* must drawn *raster* layer type.")), r("below"), r("color"), r("opacity"), r("minzoom"), r("maxzoom"), s === "circle" && r("circle.radius"), s === "line" && (r("line.width"), r("line.dash")), s === "fill" && r("fill.outlinecolor"), s === "symbol" && (r("symbol.icon"), r("symbol.iconsize"), r("symbol.text"), UJ.coerceFont(r, "symbol.textfont", void 0, { noFontVariant: true, noFontShadow: true, noFontLineposition: true, noFontTextcase: true }), r("symbol.textposition"), r("symbol.placement"));
+          }
+        }
+      });
+      var m7 = ye((u0) => {
+        var g7 = Dr(), Lje = g7.strTranslate, $Xt = g7.strScale, QXt = Id().getSubplotCalcData, eZt = Wp(), tZt = Oa(), Pje = So(), rZt = Zl(), iZt = Mje(), Ix = "map";
+        u0.name = Ix;
+        u0.attr = "subplot";
+        u0.idRoot = Ix;
+        u0.idRegex = u0.attrRegex = g7.counterRegex(Ix);
+        u0.attributes = { subplot: { valType: "subplotid", dflt: "map", editType: "calc" } };
+        u0.layoutAttributes = Qk();
+        u0.supplyLayoutDefaults = Cje();
+        u0.plot = function(t) {
+          for (var r = t._fullLayout, n = t.calcdata, i = r._subplots[Ix], a = 0; a < i.length; a++) {
+            var o = i[a], s = QXt(n, Ix, o), l = r[o], u = l._subplot;
+            u || (u = new iZt(t, o), r[o]._subplot = u), u.viewInitial || (u.viewInitial = { center: g7.extendFlat({}, l.center), zoom: l.zoom, bearing: l.bearing, pitch: l.pitch }), u.plot(s, r, t._promises);
+          }
+        };
+        u0.clean = function(e, t, r, n) {
+          for (var i = n._subplots[Ix] || [], a = 0; a < i.length; a++) {
+            var o = i[a];
+            !t[o] && n[o]._subplot && n[o]._subplot.destroy();
+          }
+        };
+        u0.toSVG = function(e) {
+          for (var t = e._fullLayout, r = t._subplots[Ix], n = t._size, i = 0; i < r.length; i++) {
+            var a = t[r[i]], o = a.domain, s = a._subplot, l = s.toImage("png"), u = t._glimages.append("svg:image");
+            u.attr({ xmlns: eZt.svg, "xlink:href": l, x: n.l + n.w * o.x[0], y: n.t + n.h * (1 - o.y[1]), width: n.w * (o.x[1] - o.x[0]), height: n.h * (o.y[1] - o.y[0]), preserveAspectRatio: "none" });
+            var c = tZt.select(a._subplot.div), f = c.select(".maplibregl-ctrl-attrib").text().replace("Improve this map", ""), h = t._glimages.append("g"), d = h.append("text");
+            d.text(f).classed("static-attribution", true).attr({ "font-size": 12, "font-family": "Arial", color: "rgba(0, 0, 0, 0.75)", "text-anchor": "end", "data-unformatted": f });
+            var v = Pje.bBox(d.node()), _ = n.w * (o.x[1] - o.x[0]);
+            if (v.width > _ / 2) {
+              var b = f.split("|").join("<br>");
+              d.text(b).attr("data-unformatted", b).call(rZt.convertToTspans, e), v = Pje.bBox(d.node());
+            }
+            d.attr("transform", Lje(-3, -v.height + 8)), h.insert("rect", ".static-attribution").attr({ x: -v.width - 6, y: -v.height - 3, width: v.width + 6, height: v.height + 3, fill: "rgba(255, 255, 255, 0.75)" });
+            var p = 1;
+            v.width + 6 > _ && (p = _ / (v.width + 6));
+            var k = [n.l + n.w * o.x[1], n.t + n.h * (1 - o.y[0])];
+            h.attr("transform", Lje(k[0], k[1]) + $Xt(p));
+          }
+        };
+        u0.updateFx = function(e) {
+          for (var t = e._fullLayout, r = t._subplots[Ix], n = 0; n < r.length; n++) {
+            var i = t[r[n]]._subplot;
+            i.updateFx(t);
+          }
+        };
+      });
+      var Rje = ye((Gbr, Ije) => {
+        Ije.exports = { attributes: l7(), supplyDefaults: jHe(), colorbar: $d(), formatLabels: PJ(), calc: _F(), plot: aje(), hoverPoints: d7().hoverPoints, eventData: uje(), selectPoints: fje(), styleOnSelect: function(e, t) {
+          if (t) {
+            var r = t[0].trace;
+            r._glTrace.update(t);
+          }
+        }, moduleType: "trace", name: "scattermap", basePlotModule: m7(), categories: ["map", "gl", "symbols", "showLegend", "scatter-like"], meta: {} };
+      });
+      var Fje = ye((Hbr, Dje) => {
+        Dje.exports = Rje();
+      });
+      var VJ = ye((jbr, zje) => {
+        var x1 = a5(), nZt = Tu(), { hovertemplateAttrs: aZt, templatefallbackAttrs: oZt } = Ll(), sZt = Gl(), Rx = Ao().extendFlat;
+        zje.exports = Rx({ locations: { valType: "data_array", editType: "calc" }, z: { valType: "data_array", editType: "calc" }, geojson: { valType: "any", editType: "calc" }, featureidkey: Rx({}, x1.featureidkey, {}), below: { valType: "string", editType: "plot" }, text: x1.text, hovertext: x1.hovertext, marker: { line: { color: Rx({}, x1.marker.line.color, { editType: "plot" }), width: Rx({}, x1.marker.line.width, { editType: "plot" }), editType: "calc" }, opacity: Rx({}, x1.marker.opacity, { editType: "plot" }), editType: "calc" }, selected: { marker: { opacity: Rx({}, x1.selected.marker.opacity, { editType: "plot" }), editType: "plot" }, editType: "plot" }, unselected: { marker: { opacity: Rx({}, x1.unselected.marker.opacity, { editType: "plot" }), editType: "plot" }, editType: "plot" }, hoverinfo: x1.hoverinfo, hovertemplate: aZt({}, { keys: ["properties"] }), hovertemplatefallback: oZt(), showlegend: Rx({}, sZt.showlegend, { dflt: false }) }, nZt("", { cLetter: "z", editTypeOverride: "calc" }));
+      });
+      var qje = ye((Wbr, Oje) => {
+        var iC = Dr(), lZt = td(), uZt = VJ();
+        Oje.exports = function(t, r, n, i) {
+          function a(c, f) {
+            return iC.coerce(t, r, uZt, c, f);
+          }
+          var o = a("locations"), s = a("z"), l = a("geojson");
+          if (!iC.isArrayOrTypedArray(o) || !o.length || !iC.isArrayOrTypedArray(s) || !s.length || !(typeof l == "string" && l !== "" || iC.isPlainObject(l))) {
+            r.visible = false;
+            return;
+          }
+          a("featureidkey"), r._length = Math.min(o.length, s.length), a("below"), a("text"), a("hovertext"), a("hovertemplate"), a("hovertemplatefallback");
+          var u = a("marker.line.width");
+          u && a("marker.line.color"), a("marker.opacity"), lZt(t, r, i, a, { prefix: "", cLetter: "z" }), iC.coerceSelectionMarkerOpacity(r, a);
+        };
+      });
+      var GJ = ye((Xbr, Uje) => {
+        var cZt = Eo(), b1 = Dr(), fZt = tc(), hZt = So(), dZt = cx().makeBlank, Bje = hx();
+        function vZt(e) {
+          var t = e[0].trace, r = t.visible === true && t._length !== 0, n = { layout: { visibility: "none" }, paint: {} }, i = { layout: { visibility: "none" }, paint: {} }, a = t._opts = { fill: n, line: i, geojson: dZt() };
+          if (!r) return a;
+          var o = Bje.extractTraceFeature(e);
+          if (!o) return a;
+          var s = fZt.makeColorScaleFuncFromTrace(t), l = t.marker, u = l.line || {}, c;
+          b1.isArrayOrTypedArray(l.opacity) && (c = function(k) {
+            var E = k.mo;
+            return cZt(E) ? +b1.constrain(E, 0, 1) : 0;
+          });
+          var f;
+          b1.isArrayOrTypedArray(u.color) && (f = function(k) {
+            return k.mlc;
+          });
+          var h;
+          b1.isArrayOrTypedArray(u.width) && (h = function(k) {
+            return k.mlw;
+          });
+          for (var d = 0; d < e.length; d++) {
+            var v = e[d], _ = v.fOut;
+            if (_) {
+              var b = _.properties;
+              b.fc = s(v.z), c && (b.mo = c(v)), f && (b.mlc = f(v)), h && (b.mlw = h(v)), v.ct = b.ct, v._polygons = Bje.feature2polygons(_);
+            }
+          }
+          var p = c ? { type: "identity", property: "mo" } : l.opacity;
+          return b1.extendFlat(n.paint, { "fill-color": { type: "identity", property: "fc" }, "fill-opacity": p }), b1.extendFlat(i.paint, { "line-color": f ? { type: "identity", property: "mlc" } : u.color, "line-width": h ? { type: "identity", property: "mlw" } : u.width, "line-opacity": p }), n.layout.visibility = "visible", i.layout.visibility = "visible", a.geojson = { type: "FeatureCollection", features: o }, Nje(e), a;
+        }
+        function Nje(e) {
+          var t = e[0].trace, r = t._opts, n;
+          if (t.selectedpoints) {
+            for (var i = hZt.makeSelectedPointStyleFns(t), a = 0; a < e.length; a++) {
+              var o = e[a];
+              o.fOut && (o.fOut.properties.mo2 = i.selectedOpacityFn(o));
+            }
+            n = { type: "identity", property: "mo2" };
+          } else n = b1.isArrayOrTypedArray(t.marker.opacity) ? { type: "identity", property: "mo" } : t.marker.opacity;
+          return b1.extendFlat(r.fill.paint, { "fill-opacity": n }), b1.extendFlat(r.line.paint, { "line-opacity": n }), r;
+        }
+        Uje.exports = { convert: vZt, convertOnSelect: Nje };
+      });
+      var Wje = ye((Zbr, jje) => {
+        var Gje = GJ().convert, pZt = GJ().convertOnSelect, Vje = Px().traceLayerPrefix;
+        function Hje(e, t) {
+          this.type = "choroplethmap", this.subplot = e, this.uid = t, this.sourceId = "source-" + t, this.layerList = [["fill", Vje + t + "-fill"], ["line", Vje + t + "-line"]], this.below = null;
+        }
+        var D5 = Hje.prototype;
+        D5.update = function(e) {
+          this._update(Gje(e)), e[0].trace._glTrace = this;
+        };
+        D5.updateOnSelect = function(e) {
+          this._update(pZt(e));
+        };
+        D5._update = function(e) {
+          var t = this.subplot, r = this.layerList, n = t.belowLookup["trace-" + this.uid];
+          t.map.getSource(this.sourceId).setData(e.geojson), n !== this.below && (this._removeLayers(), this._addLayers(e, n), this.below = n);
+          for (var i = 0; i < r.length; i++) {
+            var a = r[i], o = a[0], s = a[1], l = e[o];
+            t.setOptions(s, "setLayoutProperty", l.layout), l.layout.visibility === "visible" && t.setOptions(s, "setPaintProperty", l.paint);
+          }
+        };
+        D5._addLayers = function(e, t) {
+          for (var r = this.subplot, n = this.layerList, i = this.sourceId, a = 0; a < n.length; a++) {
+            var o = n[a], s = o[0], l = e[s];
+            r.addLayer({ type: s, id: o[1], source: i, layout: l.layout, paint: l.paint }, t);
+          }
+        };
+        D5._removeLayers = function() {
+          for (var e = this.subplot.map, t = this.layerList, r = t.length - 1; r >= 0; r--) e.removeLayer(t[r][1]);
+        };
+        D5.dispose = function() {
+          var e = this.subplot.map;
+          this._removeLayers(), e.removeSource(this.sourceId);
+        };
+        jje.exports = function(t, r) {
+          var n = r[0].trace, i = new Hje(t, n.uid), a = i.sourceId, o = Gje(r), s = i.below = t.belowLookup["trace-" + n.uid];
+          return t.map.addSource(a, { type: "geojson", data: o.geojson }), i._addLayers(o, s), r[0].trace._glTrace = i, i;
+        };
+      });
+      var Zje = ye((Ybr, Xje) => {
+        Xje.exports = { attributes: VJ(), supplyDefaults: qje(), colorbar: D_(), calc: NF(), plot: Wje(), hoverPoints: VF(), eventData: GF(), selectPoints: HF(), styleOnSelect: function(e, t) {
+          if (t) {
+            var r = t[0].trace;
+            r._glTrace.updateOnSelect(t);
+          }
+        }, getBelow: function(e, t) {
+          for (var r = t.getMapLayers(), n = r.length - 2; n >= 0; n--) {
+            var i = r[n].id;
+            if (typeof i == "string" && i.indexOf("water") === 0) {
+              for (var a = n + 1; a < r.length; a++) if (i = r[a].id, typeof i == "string" && i.indexOf("plotly-") === -1) return i;
+            }
+          }
+        }, moduleType: "trace", name: "choroplethmap", basePlotModule: m7(), categories: ["map", "gl", "noOpacity", "showLegend"], meta: { hr_name: "choropleth_map" } };
+      });
+      var Kje = ye((Kbr, Yje) => {
+        Yje.exports = Zje();
+      });
+      var jJ = ye((Jbr, $je) => {
+        var gZt = Tu(), { hovertemplateAttrs: mZt, templatefallbackAttrs: yZt } = Ll(), Jje = Gl(), y7 = l7(), HJ = Ao().extendFlat;
+        $je.exports = HJ({ lon: y7.lon, lat: y7.lat, z: { valType: "data_array", editType: "calc" }, radius: { valType: "number", editType: "plot", arrayOk: true, min: 1, dflt: 30 }, below: { valType: "string", editType: "plot" }, text: y7.text, hovertext: y7.hovertext, hoverinfo: HJ({}, Jje.hoverinfo, { flags: ["lon", "lat", "z", "text", "name"] }), hovertemplate: mZt(), hovertemplatefallback: yZt(), showlegend: HJ({}, Jje.showlegend, { dflt: false }) }, gZt("", { cLetter: "z", editTypeOverride: "calc" }));
+      });
+      var eWe = ye(($br, Qje) => {
+        var _Zt = Dr(), xZt = td(), bZt = jJ();
+        Qje.exports = function(t, r, n, i) {
+          function a(u, c) {
+            return _Zt.coerce(t, r, bZt, u, c);
+          }
+          var o = a("lon") || [], s = a("lat") || [], l = Math.min(o.length, s.length);
+          if (!l) {
+            r.visible = false;
+            return;
+          }
+          r._length = l, a("z"), a("radius"), a("below"), a("text"), a("hovertext"), a("hovertemplate"), a("hovertemplatefallback"), xZt(t, r, i, a, { prefix: "", cLetter: "z" });
+        };
+      });
+      var iWe = ye((Qbr, rWe) => {
+        var WJ = Eo(), wZt = Dr().isArrayOrTypedArray, XJ = fs().BADNUM, TZt = gv(), tWe = Dr()._;
+        rWe.exports = function(t, r) {
+          for (var n = r._length, i = new Array(n), a = r.z, o = wZt(a) && a.length, s = 0; s < n; s++) {
+            var l = i[s] = {}, u = r.lon[s], c = r.lat[s];
+            if (l.lonlat = WJ(u) && WJ(c) ? [+u, +c] : [XJ, XJ], o) {
+              var f = a[s];
+              l.z = WJ(f) ? f : XJ;
+            }
+          }
+          return TZt(t, r, { vals: o ? a : [0, 1], containerStr: "", cLetter: "z" }), n && (i[0].t = { labels: { lat: tWe(t, "lat:") + " ", lon: tWe(t, "lon:") + " " } }), i;
+        };
+      });
+      var lWe = ye((e2r, sWe) => {
+        var AZt = Eo(), ZJ = Dr(), nWe = ka(), aWe = tc(), oWe = fs().BADNUM, SZt = cx().makeBlank;
+        sWe.exports = function(t) {
+          var r = t[0].trace, n = r.visible === true && r._length !== 0, i = { layout: { visibility: "none" }, paint: {} }, a = r._opts = { heatmap: i, geojson: SZt() };
+          if (!n) return a;
+          var o = [], s, l = r.z, u = r.radius, c = ZJ.isArrayOrTypedArray(l) && l.length, f = ZJ.isArrayOrTypedArray(u);
+          for (s = 0; s < t.length; s++) {
+            var h = t[s], d = h.lonlat;
+            if (d[0] !== oWe) {
+              var v = {};
+              if (c) {
+                var _ = h.z;
+                v.z = _ !== oWe ? _ : 0;
+              }
+              f && (v.r = AZt(u[s]) && u[s] > 0 ? +u[s] : 0), o.push({ type: "Feature", geometry: { type: "Point", coordinates: d }, properties: v });
+            }
+          }
+          var b = aWe.extractOpts(r), p = b.reversescale ? aWe.flipScale(b.colorscale) : b.colorscale, k = p[0][1], E = nWe.opacity(k) < 1 ? k : nWe.addOpacity(k, 0), T = ["interpolate", ["linear"], ["heatmap-density"], 0, E];
+          for (s = 1; s < p.length; s++) T.push(p[s][0], p[s][1]);
+          var L = ["interpolate", ["linear"], ["get", "z"], b.min, 0, b.max, 1];
+          return ZJ.extendFlat(a.heatmap.paint, { "heatmap-weight": c ? L : 1 / (b.max - b.min), "heatmap-color": T, "heatmap-radius": f ? { type: "identity", property: "r" } : r.radius, "heatmap-opacity": r.opacity }), a.geojson = { type: "FeatureCollection", features: o }, a.heatmap.layout.visibility = "visible", a;
+        };
+      });
+      var hWe = ye((t2r, fWe) => {
+        var uWe = lWe(), MZt = Px().traceLayerPrefix;
+        function cWe(e, t) {
+          this.type = "densitymap", this.subplot = e, this.uid = t, this.sourceId = "source-" + t, this.layerList = [["heatmap", MZt + t + "-heatmap"]], this.below = null;
+        }
+        var _7 = cWe.prototype;
+        _7.update = function(e) {
+          var t = this.subplot, r = this.layerList, n = uWe(e), i = t.belowLookup["trace-" + this.uid];
+          t.map.getSource(this.sourceId).setData(n.geojson), i !== this.below && (this._removeLayers(), this._addLayers(n, i), this.below = i);
+          for (var a = 0; a < r.length; a++) {
+            var o = r[a], s = o[0], l = o[1], u = n[s];
+            t.setOptions(l, "setLayoutProperty", u.layout), u.layout.visibility === "visible" && t.setOptions(l, "setPaintProperty", u.paint);
+          }
+        };
+        _7._addLayers = function(e, t) {
+          for (var r = this.subplot, n = this.layerList, i = this.sourceId, a = 0; a < n.length; a++) {
+            var o = n[a], s = o[0], l = e[s];
+            r.addLayer({ type: s, id: o[1], source: i, layout: l.layout, paint: l.paint }, t);
+          }
+        };
+        _7._removeLayers = function() {
+          for (var e = this.subplot.map, t = this.layerList, r = t.length - 1; r >= 0; r--) e.removeLayer(t[r][1]);
+        };
+        _7.dispose = function() {
+          var e = this.subplot.map;
+          this._removeLayers(), e.removeSource(this.sourceId);
+        };
+        fWe.exports = function(t, r) {
+          var n = r[0].trace, i = new cWe(t, n.uid), a = i.sourceId, o = uWe(r), s = i.below = t.belowLookup["trace-" + n.uid];
+          return t.map.addSource(a, { type: "geojson", data: o.geojson }), i._addLayers(o, s), i;
+        };
+      });
+      var vWe = ye((r2r, dWe) => {
+        var EZt = ho(), kZt = d7().hoverPoints, CZt = d7().getExtraText;
+        dWe.exports = function(t, r, n) {
+          var i = kZt(t, r, n);
+          if (i) {
+            var a = i[0], o = a.cd, s = o[0].trace, l = o[a.index];
+            if (delete a.color, "z" in l) {
+              var u = a.subplot.mockAxis;
+              a.z = l.z, a.zLabel = EZt.tickText(u, u.c2l(l.z), "hover").text;
+            }
+            return a.extraText = CZt(s, l, o[0].t.labels), [a];
+          }
+        };
+      });
+      var gWe = ye((i2r, pWe) => {
+        pWe.exports = function(t, r) {
+          return t.lon = r.lon, t.lat = r.lat, t.z = r.z, t;
+        };
+      });
+      var yWe = ye((n2r, mWe) => {
+        mWe.exports = { attributes: jJ(), supplyDefaults: eWe(), colorbar: D_(), formatLabels: PJ(), calc: iWe(), plot: hWe(), hoverPoints: vWe(), eventData: gWe(), getBelow: function(e, t) {
+          for (var r = t.getMapLayers(), n = 0; n < r.length; n++) {
+            var i = r[n], a = i.id;
+            if (i.type === "symbol" && typeof a == "string" && a.indexOf("plotly-") === -1) return a;
+          }
+        }, moduleType: "trace", name: "densitymap", basePlotModule: m7(), categories: ["map", "gl", "showLegend"], meta: { hr_name: "density_map" } };
+      });
+      var xWe = ye((a2r, _We) => {
+        _We.exports = yWe();
+      });
+      var KJ = ye((s2r, SWe) => {
+        var LZt = ec(), PZt = Gl(), bWe = Ih(), YJ = v3(), IZt = Cc().attributes, { hovertemplateAttrs: wWe, templatefallbackAttrs: TWe } = Ll(), RZt = Tu(), DZt = vl().templatedArray, FZt = df().descriptionOnlyNumbers, AWe = Ao().extendFlat, zZt = mc().overrideAll;
+        SWe.exports = zZt({ hoverinfo: AWe({}, PZt.hoverinfo, { flags: [], arrayOk: false }), hoverlabel: YJ.hoverlabel, domain: IZt({ name: "sankey", trace: true }), orientation: { valType: "enumerated", values: ["v", "h"], dflt: "h" }, valueformat: { valType: "string", dflt: ".3s", description: FZt("value") }, valuesuffix: { valType: "string", dflt: "" }, arrangement: { valType: "enumerated", values: ["snap", "perpendicular", "freeform", "fixed"], dflt: "snap" }, textfont: LZt({ autoShadowDflt: true }), customdata: void 0, node: { label: { valType: "data_array", dflt: [] }, groups: { valType: "info_array", impliedEdits: { x: [], y: [] }, dimensions: 2, freeLength: true, dflt: [], items: { valType: "number", editType: "calc" } }, x: { valType: "data_array", dflt: [] }, y: { valType: "data_array", dflt: [] }, color: { valType: "color", arrayOk: true }, customdata: { valType: "data_array", editType: "calc" }, line: { color: { valType: "color", dflt: bWe.defaultLine, arrayOk: true }, width: { valType: "number", min: 0, dflt: 0.5, arrayOk: true } }, pad: { valType: "number", arrayOk: false, min: 0, dflt: 20 }, thickness: { valType: "number", arrayOk: false, min: 1, dflt: 20 }, hoverinfo: { valType: "enumerated", values: ["all", "none", "skip"], dflt: "all" }, hoverlabel: YJ.hoverlabel, hovertemplate: wWe({}, { keys: ["value", "label"] }), hovertemplatefallback: TWe(), align: { valType: "enumerated", values: ["justify", "left", "right", "center"], dflt: "justify" } }, link: { arrowlen: { valType: "number", min: 0, dflt: 0 }, label: { valType: "data_array", dflt: [] }, color: { valType: "color", arrayOk: true }, hovercolor: { valType: "color", arrayOk: true }, customdata: { valType: "data_array", editType: "calc" }, line: { color: { valType: "color", dflt: bWe.defaultLine, arrayOk: true }, width: { valType: "number", min: 0, dflt: 0, arrayOk: true } }, source: { valType: "data_array", dflt: [] }, target: { valType: "data_array", dflt: [] }, value: { valType: "data_array", dflt: [] }, hoverinfo: { valType: "enumerated", values: ["all", "none", "skip"], dflt: "all" }, hoverlabel: YJ.hoverlabel, hovertemplate: wWe({}, { keys: ["value", "label"] }), hovertemplatefallback: TWe(), colorscales: DZt("concentrationscales", { editType: "calc", label: { valType: "string", editType: "calc", dflt: "" }, cmax: { valType: "number", editType: "calc", dflt: 1 }, cmin: { valType: "number", editType: "calc", dflt: 0 }, colorscale: AWe(RZt().colorscale, { dflt: [[0, "white"], [1, "black"]] }) }) } }, "calc", "nested");
+      });
+      var LWe = ye((l2r, CWe) => {
+        var F5 = Dr(), x7 = KJ(), OZt = ka(), MWe = fd(), qZt = Cc().defaults, EWe = _M(), kWe = vl(), BZt = Zd();
+        CWe.exports = function(t, r, n, i) {
+          function a(T, L) {
+            return F5.coerce(t, r, x7, T, L);
+          }
+          var o = F5.extendDeep(i.hoverlabel, t.hoverlabel), s = t.node, l = kWe.newContainer(r, "node");
+          function u(T, L) {
+            return F5.coerce(s, l, x7.node, T, L);
+          }
+          u("label"), u("groups"), u("x"), u("y"), u("pad"), u("thickness"), u("line.color"), u("line.width"), u("hoverinfo", t.hoverinfo), EWe(s, l, u, o), u("hovertemplate"), u("align");
+          var c = i.colorway, f = function(T) {
+            return c[T % c.length];
+          };
+          u("color", l.label.map(function(T, L) {
+            return OZt.addOpacity(f(L), 0.8);
+          })), u("customdata");
+          var h = t.link || {}, d = kWe.newContainer(r, "link");
+          function v(T, L) {
+            return F5.coerce(h, d, x7.link, T, L);
+          }
+          v("label"), v("arrowlen"), v("source"), v("target"), v("value"), v("line.color"), v("line.width"), v("hoverinfo", t.hoverinfo), EWe(h, d, v, o), v("hovertemplate");
+          var _ = MWe(i.paper_bgcolor).getLuminance() < 0.333, b = _ ? "rgba(255, 255, 255, 0.6)" : "rgba(0, 0, 0, 0.2)", p = v("color", b);
+          function k(T) {
+            var L = MWe(T);
+            if (!L.isValid()) return T;
+            var x = L.getAlpha();
+            return x <= 0.8 ? L.setAlpha(x + 0.2) : L = _ ? L.brighten() : L.darken(), L.toRgbString();
+          }
+          v("hovercolor", Array.isArray(p) ? p.map(k) : k(p)), v("customdata"), BZt(h, d, { name: "colorscales", handleItemDefaults: NZt }), qZt(r, i, a), a("orientation"), a("valueformat"), a("valuesuffix");
+          var E;
+          l.x.length && l.y.length && (E = "freeform"), a("arrangement", E), F5.coerceFont(a, "textfont", i.font, { autoShadowDflt: true }), r._length = null;
+        };
+        function NZt(e, t) {
+          function r(n, i) {
+            return F5.coerce(e, t, x7.link.colorscales, n, i);
+          }
+          r("label"), r("cmin"), r("cmax"), r("colorscale");
+        }
+      });
+      var JJ = ye((u2r, PWe) => {
+        PWe.exports = UZt;
+        function UZt(e) {
+          for (var t = e.length, r = new Array(t), n = new Array(t), i = new Array(t), a = new Array(t), o = new Array(t), s = new Array(t), l = 0; l < t; ++l) r[l] = -1, n[l] = 0, i[l] = false, a[l] = 0, o[l] = -1, s[l] = [];
+          var u = 0, c = [], f = [];
+          function h(b) {
+            var p = [b], k = [b];
+            for (r[b] = n[b] = u, i[b] = true, u += 1; k.length > 0; ) {
+              b = k[k.length - 1];
+              var E = e[b];
+              if (a[b] < E.length) {
+                for (var T = a[b]; T < E.length; ++T) {
+                  var L = E[T];
+                  if (r[L] < 0) {
+                    r[L] = n[L] = u, i[L] = true, u += 1, p.push(L), k.push(L);
+                    break;
+                  } else i[L] && (n[b] = Math.min(n[b], n[L]) | 0);
+                  o[L] >= 0 && s[b].push(o[L]);
+                }
+                a[b] = T;
+              } else {
+                if (n[b] === r[b]) {
+                  for (var x = [], C = [], M = 0, T = p.length - 1; T >= 0; --T) {
+                    var g = p[T];
+                    if (i[g] = false, x.push(g), C.push(s[g]), M += s[g].length, o[g] = c.length, g === b) {
+                      p.length = T;
+                      break;
+                    }
+                  }
+                  c.push(x);
+                  for (var P = new Array(M), T = 0; T < C.length; T++) for (var A = 0; A < C[T].length; A++) P[--M] = C[T][A];
+                  f.push(P);
+                }
+                k.pop();
+              }
+            }
+          }
+          for (var l = 0; l < t; ++l) r[l] < 0 && h(l);
+          for (var d, l = 0; l < f.length; l++) {
+            var v = f[l];
+            if (v.length !== 0) {
+              v.sort(function(p, k) {
+                return p - k;
+              }), d = [v[0]];
+              for (var _ = 1; _ < v.length; _++) v[_] !== v[_ - 1] && d.push(v[_]);
+              f[l] = d;
+            }
+          }
+          return { components: c, adjacencyList: f };
+        }
+      });
+      var FWe = ye((c2r, DWe) => {
+        var VZt = JJ(), z5 = Dr(), GZt = iy().wrap, nC = z5.isArrayOrTypedArray, IWe = z5.isIndex, RWe = tc();
+        function HZt(e) {
+          var t = e.node, r = e.link, n = [], i = nC(r.color), a = nC(r.hovercolor), o = nC(r.customdata), s = {}, l = {}, u = r.colorscales.length, c;
+          for (c = 0; c < u; c++) {
+            var f = r.colorscales[c], h = RWe.extractScale(f, { cLetter: "c" }), d = RWe.makeColorScaleFunc(h);
+            l[f.label] = d;
+          }
+          var v = 0;
+          for (c = 0; c < r.value.length; c++) r.source[c] > v && (v = r.source[c]), r.target[c] > v && (v = r.target[c]);
+          var _ = v + 1;
+          e.node._count = _;
+          var b, p = e.node.groups, k = {};
+          for (c = 0; c < p.length; c++) {
+            var E = p[c];
+            for (b = 0; b < E.length; b++) {
+              var T = E[b], L = _ + c;
+              k.hasOwnProperty(T) ? z5.warn("Node " + T + " is already part of a group.") : k[T] = L;
+            }
+          }
+          var x = { source: [], target: [] };
+          for (c = 0; c < r.value.length; c++) {
+            var C = r.value[c], M = r.source[c], g = r.target[c];
+            if (C > 0 && IWe(M, _) && IWe(g, _) && !(k.hasOwnProperty(M) && k.hasOwnProperty(g) && k[M] === k[g])) {
+              k.hasOwnProperty(g) && (g = k[g]), k.hasOwnProperty(M) && (M = k[M]), M = +M, g = +g, s[M] = s[g] = true;
+              var P = "";
+              r.label && r.label[c] && (P = r.label[c]);
+              var A = null;
+              P && l.hasOwnProperty(P) && (A = l[P]), n.push({ pointNumber: c, label: P, color: i ? r.color[c] : r.color, hovercolor: a ? r.hovercolor[c] : r.hovercolor, customdata: o ? r.customdata[c] : r.customdata, concentrationscale: A, source: M, target: g, value: +C }), x.source.push(M), x.target.push(g);
+            }
+          }
+          var z = _ + p.length, O = nC(t.color), U = nC(t.customdata), G = [];
+          for (c = 0; c < z; c++) if (s[c]) {
+            var Z = t.label[c];
+            G.push({ group: c > _ - 1, childrenNodes: [], pointNumber: c, label: Z, color: O ? t.color[c] : t.color, customdata: U ? t.customdata[c] : t.customdata });
+          }
+          var j = false;
+          return jZt(z, x.source, x.target) && (j = true), { circular: j, links: n, nodes: G, groups: p, groupLookup: k };
+        }
+        function jZt(e, t, r) {
+          for (var n = z5.init2dArray(e, 0), i = 0; i < Math.min(t.length, r.length); i++) if (z5.isIndex(t[i], e) && z5.isIndex(r[i], e)) {
+            if (t[i] === r[i]) return true;
+            n[t[i]].push(r[i]);
+          }
+          var a = VZt(n);
+          return a.components.some(function(o) {
+            return o.length > 1;
+          });
+        }
+        DWe.exports = function(t, r) {
+          var n = HZt(r);
+          return GZt({ circular: n.circular, _nodes: n.nodes, _links: n.links, _groups: n.groups, _groupLookup: n.groupLookup });
+        };
+      });
+      var OWe = ye((b7, zWe) => {
+        (function(e, t) {
+          typeof b7 == "object" && typeof zWe != "undefined" ? t(b7) : (e = e || self, t(e.d3 = e.d3 || {}));
+        })(b7, function(e) {
+          function t(C) {
+            var M = +this._x.call(null, C), g = +this._y.call(null, C);
+            return r(this.cover(M, g), M, g, C);
+          }
+          function r(C, M, g, P) {
+            if (isNaN(M) || isNaN(g)) return C;
+            var A, z = C._root, O = { data: P }, U = C._x0, G = C._y0, Z = C._x1, j = C._y1, N, H, re, oe, _e, Ce, Le, ge;
+            if (!z) return C._root = O, C;
+            for (; z.length; ) if ((_e = M >= (N = (U + Z) / 2)) ? U = N : Z = N, (Ce = g >= (H = (G + j) / 2)) ? G = H : j = H, A = z, !(z = z[Le = Ce << 1 | _e])) return A[Le] = O, C;
+            if (re = +C._x.call(null, z.data), oe = +C._y.call(null, z.data), M === re && g === oe) return O.next = z, A ? A[Le] = O : C._root = O, C;
+            do
+              A = A ? A[Le] = new Array(4) : C._root = new Array(4), (_e = M >= (N = (U + Z) / 2)) ? U = N : Z = N, (Ce = g >= (H = (G + j) / 2)) ? G = H : j = H;
+            while ((Le = Ce << 1 | _e) === (ge = (oe >= H) << 1 | re >= N));
+            return A[ge] = z, A[Le] = O, C;
+          }
+          function n(C) {
+            var M, g, P = C.length, A, z, O = new Array(P), U = new Array(P), G = 1 / 0, Z = 1 / 0, j = -1 / 0, N = -1 / 0;
+            for (g = 0; g < P; ++g) isNaN(A = +this._x.call(null, M = C[g])) || isNaN(z = +this._y.call(null, M)) || (O[g] = A, U[g] = z, A < G && (G = A), A > j && (j = A), z < Z && (Z = z), z > N && (N = z));
+            if (G > j || Z > N) return this;
+            for (this.cover(G, Z).cover(j, N), g = 0; g < P; ++g) r(this, O[g], U[g], C[g]);
+            return this;
+          }
+          function i(C, M) {
+            if (isNaN(C = +C) || isNaN(M = +M)) return this;
+            var g = this._x0, P = this._y0, A = this._x1, z = this._y1;
+            if (isNaN(g)) A = (g = Math.floor(C)) + 1, z = (P = Math.floor(M)) + 1;
+            else {
+              for (var O = A - g, U = this._root, G, Z; g > C || C >= A || P > M || M >= z; ) switch (Z = (M < P) << 1 | C < g, G = new Array(4), G[Z] = U, U = G, O *= 2, Z) {
+                case 0:
+                  A = g + O, z = P + O;
+                  break;
+                case 1:
+                  g = A - O, z = P + O;
+                  break;
+                case 2:
+                  A = g + O, P = z - O;
+                  break;
+                case 3:
+                  g = A - O, P = z - O;
+                  break;
+              }
+              this._root && this._root.length && (this._root = U);
+            }
+            return this._x0 = g, this._y0 = P, this._x1 = A, this._y1 = z, this;
+          }
+          function a() {
+            var C = [];
+            return this.visit(function(M) {
+              if (!M.length) do
+                C.push(M.data);
+              while (M = M.next);
+            }), C;
+          }
+          function o(C) {
+            return arguments.length ? this.cover(+C[0][0], +C[0][1]).cover(+C[1][0], +C[1][1]) : isNaN(this._x0) ? void 0 : [[this._x0, this._y0], [this._x1, this._y1]];
+          }
+          function s(C, M, g, P, A) {
+            this.node = C, this.x0 = M, this.y0 = g, this.x1 = P, this.y1 = A;
+          }
+          function l(C, M, g) {
+            var P, A = this._x0, z = this._y0, O, U, G, Z, j = this._x1, N = this._y1, H = [], re = this._root, oe, _e;
+            for (re && H.push(new s(re, A, z, j, N)), g == null ? g = 1 / 0 : (A = C - g, z = M - g, j = C + g, N = M + g, g *= g); oe = H.pop(); ) if (!(!(re = oe.node) || (O = oe.x0) > j || (U = oe.y0) > N || (G = oe.x1) < A || (Z = oe.y1) < z)) if (re.length) {
+              var Ce = (O + G) / 2, Le = (U + Z) / 2;
+              H.push(new s(re[3], Ce, Le, G, Z), new s(re[2], O, Le, Ce, Z), new s(re[1], Ce, U, G, Le), new s(re[0], O, U, Ce, Le)), (_e = (M >= Le) << 1 | C >= Ce) && (oe = H[H.length - 1], H[H.length - 1] = H[H.length - 1 - _e], H[H.length - 1 - _e] = oe);
+            } else {
+              var ge = C - +this._x.call(null, re.data), ie = M - +this._y.call(null, re.data), Se = ge * ge + ie * ie;
+              if (Se < g) {
+                var Ee = Math.sqrt(g = Se);
+                A = C - Ee, z = M - Ee, j = C + Ee, N = M + Ee, P = re.data;
+              }
+            }
+            return P;
+          }
+          function u(C) {
+            if (isNaN(j = +this._x.call(null, C)) || isNaN(N = +this._y.call(null, C))) return this;
+            var M, g = this._root, P, A, z, O = this._x0, U = this._y0, G = this._x1, Z = this._y1, j, N, H, re, oe, _e, Ce, Le;
+            if (!g) return this;
+            if (g.length) for (; ; ) {
+              if ((oe = j >= (H = (O + G) / 2)) ? O = H : G = H, (_e = N >= (re = (U + Z) / 2)) ? U = re : Z = re, M = g, !(g = g[Ce = _e << 1 | oe])) return this;
+              if (!g.length) break;
+              (M[Ce + 1 & 3] || M[Ce + 2 & 3] || M[Ce + 3 & 3]) && (P = M, Le = Ce);
+            }
+            for (; g.data !== C; ) if (A = g, !(g = g.next)) return this;
+            return (z = g.next) && delete g.next, A ? (z ? A.next = z : delete A.next, this) : M ? (z ? M[Ce] = z : delete M[Ce], (g = M[0] || M[1] || M[2] || M[3]) && g === (M[3] || M[2] || M[1] || M[0]) && !g.length && (P ? P[Le] = g : this._root = g), this) : (this._root = z, this);
+          }
+          function c(C) {
+            for (var M = 0, g = C.length; M < g; ++M) this.remove(C[M]);
+            return this;
+          }
+          function f() {
+            return this._root;
+          }
+          function h() {
+            var C = 0;
+            return this.visit(function(M) {
+              if (!M.length) do
+                ++C;
+              while (M = M.next);
+            }), C;
+          }
+          function d(C) {
+            var M = [], g, P = this._root, A, z, O, U, G;
+            for (P && M.push(new s(P, this._x0, this._y0, this._x1, this._y1)); g = M.pop(); ) if (!C(P = g.node, z = g.x0, O = g.y0, U = g.x1, G = g.y1) && P.length) {
+              var Z = (z + U) / 2, j = (O + G) / 2;
+              (A = P[3]) && M.push(new s(A, Z, j, U, G)), (A = P[2]) && M.push(new s(A, z, j, Z, G)), (A = P[1]) && M.push(new s(A, Z, O, U, j)), (A = P[0]) && M.push(new s(A, z, O, Z, j));
+            }
+            return this;
+          }
+          function v(C) {
+            var M = [], g = [], P;
+            for (this._root && M.push(new s(this._root, this._x0, this._y0, this._x1, this._y1)); P = M.pop(); ) {
+              var A = P.node;
+              if (A.length) {
+                var z, O = P.x0, U = P.y0, G = P.x1, Z = P.y1, j = (O + G) / 2, N = (U + Z) / 2;
+                (z = A[0]) && M.push(new s(z, O, U, j, N)), (z = A[1]) && M.push(new s(z, j, U, G, N)), (z = A[2]) && M.push(new s(z, O, N, j, Z)), (z = A[3]) && M.push(new s(z, j, N, G, Z));
+              }
+              g.push(P);
+            }
+            for (; P = g.pop(); ) C(P.node, P.x0, P.y0, P.x1, P.y1);
+            return this;
+          }
+          function _(C) {
+            return C[0];
+          }
+          function b(C) {
+            return arguments.length ? (this._x = C, this) : this._x;
+          }
+          function p(C) {
+            return C[1];
+          }
+          function k(C) {
+            return arguments.length ? (this._y = C, this) : this._y;
+          }
+          function E(C, M, g) {
+            var P = new T(M == null ? _ : M, g == null ? p : g, NaN, NaN, NaN, NaN);
+            return C == null ? P : P.addAll(C);
+          }
+          function T(C, M, g, P, A, z) {
+            this._x = C, this._y = M, this._x0 = g, this._y0 = P, this._x1 = A, this._y1 = z, this._root = void 0;
+          }
+          function L(C) {
+            for (var M = { data: C.data }, g = M; C = C.next; ) g = g.next = { data: C.data };
+            return M;
+          }
+          var x = E.prototype = T.prototype;
+          x.copy = function() {
+            var C = new T(this._x, this._y, this._x0, this._y0, this._x1, this._y1), M = this._root, g, P;
+            if (!M) return C;
+            if (!M.length) return C._root = L(M), C;
+            for (g = [{ source: M, target: C._root = new Array(4) }]; M = g.pop(); ) for (var A = 0; A < 4; ++A) (P = M.source[A]) && (P.length ? g.push({ source: P, target: M.target[A] = new Array(4) }) : M.target[A] = L(P));
+            return C;
+          }, x.add = t, x.addAll = n, x.cover = i, x.data = a, x.extent = o, x.find = l, x.remove = u, x.removeAll = c, x.root = f, x.size = h, x.visit = d, x.visitAfter = v, x.x = b, x.y = k, e.quadtree = E, Object.defineProperty(e, "__esModule", { value: true });
+        });
+      });
+      var T7 = ye((w7, qWe) => {
+        (function(e, t) {
+          t(typeof w7 == "object" && typeof qWe != "undefined" ? w7 : e.d3 = e.d3 || {});
+        })(w7, function(e) {
+          var t = "$";
+          function r() {
+          }
+          r.prototype = n.prototype = { constructor: r, has: function(_) {
+            return t + _ in this;
+          }, get: function(_) {
+            return this[t + _];
+          }, set: function(_, b) {
+            return this[t + _] = b, this;
+          }, remove: function(_) {
+            var b = t + _;
+            return b in this && delete this[b];
+          }, clear: function() {
+            for (var _ in this) _[0] === t && delete this[_];
+          }, keys: function() {
+            var _ = [];
+            for (var b in this) b[0] === t && _.push(b.slice(1));
+            return _;
+          }, values: function() {
+            var _ = [];
+            for (var b in this) b[0] === t && _.push(this[b]);
+            return _;
+          }, entries: function() {
+            var _ = [];
+            for (var b in this) b[0] === t && _.push({ key: b.slice(1), value: this[b] });
+            return _;
+          }, size: function() {
+            var _ = 0;
+            for (var b in this) b[0] === t && ++_;
+            return _;
+          }, empty: function() {
+            for (var _ in this) if (_[0] === t) return false;
+            return true;
+          }, each: function(_) {
+            for (var b in this) b[0] === t && _(this[b], b.slice(1), this);
+          } };
+          function n(_, b) {
+            var p = new r();
+            if (_ instanceof r) _.each(function(x, C) {
+              p.set(C, x);
+            });
+            else if (Array.isArray(_)) {
+              var k = -1, E = _.length, T;
+              if (b == null) for (; ++k < E; ) p.set(k, _[k]);
+              else for (; ++k < E; ) p.set(b(T = _[k], k, _), T);
+            } else if (_) for (var L in _) p.set(L, _[L]);
+            return p;
+          }
+          function i() {
+            var _ = [], b = [], p, k, E;
+            function T(x, C, M, g) {
+              if (C >= _.length) return p != null && x.sort(p), k != null ? k(x) : x;
+              for (var P = -1, A = x.length, z = _[C++], O, U, G = n(), Z, j = M(); ++P < A; ) (Z = G.get(O = z(U = x[P]) + "")) ? Z.push(U) : G.set(O, [U]);
+              return G.each(function(N, H) {
+                g(j, H, T(N, C, M, g));
+              }), j;
+            }
+            function L(x, C) {
+              if (++C > _.length) return x;
+              var M, g = b[C - 1];
+              return k != null && C >= _.length ? M = x.entries() : (M = [], x.each(function(P, A) {
+                M.push({ key: A, values: L(P, C) });
+              })), g != null ? M.sort(function(P, A) {
+                return g(P.key, A.key);
+              }) : M;
+            }
+            return E = { object: function(x) {
+              return T(x, 0, a, o);
+            }, map: function(x) {
+              return T(x, 0, s, l);
+            }, entries: function(x) {
+              return L(T(x, 0, s, l), 0);
+            }, key: function(x) {
+              return _.push(x), E;
+            }, sortKeys: function(x) {
+              return b[_.length - 1] = x, E;
+            }, sortValues: function(x) {
+              return p = x, E;
+            }, rollup: function(x) {
+              return k = x, E;
+            } };
+          }
+          function a() {
+            return {};
+          }
+          function o(_, b, p) {
+            _[b] = p;
+          }
+          function s() {
+            return n();
+          }
+          function l(_, b, p) {
+            _.set(b, p);
+          }
+          function u() {
+          }
+          var c = n.prototype;
+          u.prototype = f.prototype = { constructor: u, has: c.has, add: function(_) {
+            return _ += "", this[t + _] = _, this;
+          }, remove: c.remove, clear: c.clear, values: c.keys, size: c.size, empty: c.empty, each: c.each };
+          function f(_, b) {
+            var p = new u();
+            if (_ instanceof u) _.each(function(T) {
+              p.add(T);
+            });
+            else if (_) {
+              var k = -1, E = _.length;
+              if (b == null) for (; ++k < E; ) p.add(_[k]);
+              else for (; ++k < E; ) p.add(b(_[k], k, _));
+            }
+            return p;
+          }
+          function h(_) {
+            var b = [];
+            for (var p in _) b.push(p);
+            return b;
+          }
+          function d(_) {
+            var b = [];
+            for (var p in _) b.push(_[p]);
+            return b;
+          }
+          function v(_) {
+            var b = [];
+            for (var p in _) b.push({ key: p, value: _[p] });
+            return b;
+          }
+          e.nest = i, e.set = f, e.map = n, e.keys = h, e.values = d, e.entries = v, Object.defineProperty(e, "__esModule", { value: true });
+        });
+      });
+      var NWe = ye((A7, BWe) => {
+        (function(e, t) {
+          typeof A7 == "object" && typeof BWe != "undefined" ? t(A7) : (e = e || self, t(e.d3 = e.d3 || {}));
+        })(A7, function(e) {
+          var t = { value: function() {
+          } };
+          function r() {
+            for (var s = 0, l = arguments.length, u = {}, c; s < l; ++s) {
+              if (!(c = arguments[s] + "") || c in u || /[\s.]/.test(c)) throw new Error("illegal type: " + c);
+              u[c] = [];
+            }
+            return new n(u);
+          }
+          function n(s) {
+            this._ = s;
+          }
+          function i(s, l) {
+            return s.trim().split(/^|\s+/).map(function(u) {
+              var c = "", f = u.indexOf(".");
+              if (f >= 0 && (c = u.slice(f + 1), u = u.slice(0, f)), u && !l.hasOwnProperty(u)) throw new Error("unknown type: " + u);
+              return { type: u, name: c };
+            });
+          }
+          n.prototype = r.prototype = { constructor: n, on: function(s, l) {
+            var u = this._, c = i(s + "", u), f, h = -1, d = c.length;
+            if (arguments.length < 2) {
+              for (; ++h < d; ) if ((f = (s = c[h]).type) && (f = a(u[f], s.name))) return f;
+              return;
+            }
+            if (l != null && typeof l != "function") throw new Error("invalid callback: " + l);
+            for (; ++h < d; ) if (f = (s = c[h]).type) u[f] = o(u[f], s.name, l);
+            else if (l == null) for (f in u) u[f] = o(u[f], s.name, null);
+            return this;
+          }, copy: function() {
+            var s = {}, l = this._;
+            for (var u in l) s[u] = l[u].slice();
+            return new n(s);
+          }, call: function(s, l) {
+            if ((f = arguments.length - 2) > 0) for (var u = new Array(f), c = 0, f, h; c < f; ++c) u[c] = arguments[c + 2];
+            if (!this._.hasOwnProperty(s)) throw new Error("unknown type: " + s);
+            for (h = this._[s], c = 0, f = h.length; c < f; ++c) h[c].value.apply(l, u);
+          }, apply: function(s, l, u) {
+            if (!this._.hasOwnProperty(s)) throw new Error("unknown type: " + s);
+            for (var c = this._[s], f = 0, h = c.length; f < h; ++f) c[f].value.apply(l, u);
+          } };
+          function a(s, l) {
+            for (var u = 0, c = s.length, f; u < c; ++u) if ((f = s[u]).name === l) return f.value;
+          }
+          function o(s, l, u) {
+            for (var c = 0, f = s.length; c < f; ++c) if (s[c].name === l) {
+              s[c] = t, s = s.slice(0, c).concat(s.slice(c + 1));
+              break;
+            }
+            return u != null && s.push({ name: l, value: u }), s;
+          }
+          e.dispatch = r, Object.defineProperty(e, "__esModule", { value: true });
+        });
+      });
+      var VWe = ye((S7, UWe) => {
+        (function(e, t) {
+          typeof S7 == "object" && typeof UWe != "undefined" ? t(S7) : (e = e || self, t(e.d3 = e.d3 || {}));
+        })(S7, function(e) {
+          var t = 0, r = 0, n = 0, i = 1e3, a, o, s = 0, l = 0, u = 0, c = typeof performance == "object" && performance.now ? performance : Date, f = typeof window == "object" && window.requestAnimationFrame ? window.requestAnimationFrame.bind(window) : function(C) {
+            setTimeout(C, 17);
+          };
+          function h() {
+            return l || (f(d), l = c.now() + u);
+          }
+          function d() {
+            l = 0;
+          }
+          function v() {
+            this._call = this._time = this._next = null;
+          }
+          v.prototype = _.prototype = { constructor: v, restart: function(C, M, g) {
+            if (typeof C != "function") throw new TypeError("callback is not a function");
+            g = (g == null ? h() : +g) + (M == null ? 0 : +M), !this._next && o !== this && (o ? o._next = this : a = this, o = this), this._call = C, this._time = g, T();
+          }, stop: function() {
+            this._call && (this._call = null, this._time = 1 / 0, T());
+          } };
+          function _(C, M, g) {
+            var P = new v();
+            return P.restart(C, M, g), P;
+          }
+          function b() {
+            h(), ++t;
+            for (var C = a, M; C; ) (M = l - C._time) >= 0 && C._call.call(null, M), C = C._next;
+            --t;
+          }
+          function p() {
+            l = (s = c.now()) + u, t = r = 0;
+            try {
+              b();
+            } finally {
+              t = 0, E(), l = 0;
+            }
+          }
+          function k() {
+            var C = c.now(), M = C - s;
+            M > i && (u -= M, s = C);
+          }
+          function E() {
+            for (var C, M = a, g, P = 1 / 0; M; ) M._call ? (P > M._time && (P = M._time), C = M, M = M._next) : (g = M._next, M._next = null, M = C ? C._next = g : a = g);
+            o = C, T(P);
+          }
+          function T(C) {
+            if (!t) {
+              r && (r = clearTimeout(r));
+              var M = C - l;
+              M > 24 ? (C < 1 / 0 && (r = setTimeout(p, C - c.now() - u)), n && (n = clearInterval(n))) : (n || (s = c.now(), n = setInterval(k, i)), t = 1, f(p));
+            }
+          }
+          function L(C, M, g) {
+            var P = new v();
+            return M = M == null ? 0 : +M, P.restart(function(A) {
+              P.stop(), C(A + M);
+            }, M, g), P;
+          }
+          function x(C, M, g) {
+            var P = new v(), A = M;
+            return M == null ? (P.restart(C, M, g), P) : (M = +M, g = g == null ? h() : +g, P.restart(function z(O) {
+              O += A, P.restart(z, A += M, g), C(O);
+            }, M, g), P);
+          }
+          e.interval = x, e.now = h, e.timeout = L, e.timer = _, e.timerFlush = b, Object.defineProperty(e, "__esModule", { value: true });
+        });
+      });
+      var HWe = ye((M7, GWe) => {
+        (function(e, t) {
+          typeof M7 == "object" && typeof GWe != "undefined" ? t(M7, OWe(), T7(), NWe(), VWe()) : t(e.d3 = e.d3 || {}, e.d3, e.d3, e.d3, e.d3);
+        })(M7, function(e, t, r, n, i) {
+          function a(C, M) {
+            var g;
+            C == null && (C = 0), M == null && (M = 0);
+            function P() {
+              var A, z = g.length, O, U = 0, G = 0;
+              for (A = 0; A < z; ++A) O = g[A], U += O.x, G += O.y;
+              for (U = U / z - C, G = G / z - M, A = 0; A < z; ++A) O = g[A], O.x -= U, O.y -= G;
+            }
+            return P.initialize = function(A) {
+              g = A;
+            }, P.x = function(A) {
+              return arguments.length ? (C = +A, P) : C;
+            }, P.y = function(A) {
+              return arguments.length ? (M = +A, P) : M;
+            }, P;
+          }
+          function o(C) {
+            return function() {
+              return C;
+            };
+          }
+          function s() {
+            return (Math.random() - 0.5) * 1e-6;
+          }
+          function l(C) {
+            return C.x + C.vx;
+          }
+          function u(C) {
+            return C.y + C.vy;
+          }
+          function c(C) {
+            var M, g, P = 1, A = 1;
+            typeof C != "function" && (C = o(C == null ? 1 : +C));
+            function z() {
+              for (var G, Z = M.length, j, N, H, re, oe, _e, Ce = 0; Ce < A; ++Ce) for (j = t.quadtree(M, l, u).visitAfter(O), G = 0; G < Z; ++G) N = M[G], oe = g[N.index], _e = oe * oe, H = N.x + N.vx, re = N.y + N.vy, j.visit(Le);
+              function Le(ge, ie, Se, Ee, Ae) {
+                var Be = ge.data, Pe = ge.r, me = oe + Pe;
+                if (Be) {
+                  if (Be.index > N.index) {
+                    var De = H - Be.x - Be.vx, ce = re - Be.y - Be.vy, je = De * De + ce * ce;
+                    je < me * me && (De === 0 && (De = s(), je += De * De), ce === 0 && (ce = s(), je += ce * ce), je = (me - (je = Math.sqrt(je))) / je * P, N.vx += (De *= je) * (me = (Pe *= Pe) / (_e + Pe)), N.vy += (ce *= je) * me, Be.vx -= De * (me = 1 - me), Be.vy -= ce * me);
+                  }
+                  return;
+                }
+                return ie > H + me || Ee < H - me || Se > re + me || Ae < re - me;
+              }
+            }
+            function O(G) {
+              if (G.data) return G.r = g[G.data.index];
+              for (var Z = G.r = 0; Z < 4; ++Z) G[Z] && G[Z].r > G.r && (G.r = G[Z].r);
+            }
+            function U() {
+              if (M) {
+                var G, Z = M.length, j;
+                for (g = new Array(Z), G = 0; G < Z; ++G) j = M[G], g[j.index] = +C(j, G, M);
+              }
+            }
+            return z.initialize = function(G) {
+              M = G, U();
+            }, z.iterations = function(G) {
+              return arguments.length ? (A = +G, z) : A;
+            }, z.strength = function(G) {
+              return arguments.length ? (P = +G, z) : P;
+            }, z.radius = function(G) {
+              return arguments.length ? (C = typeof G == "function" ? G : o(+G), U(), z) : C;
+            }, z;
+          }
+          function f(C) {
+            return C.index;
+          }
+          function h(C, M) {
+            var g = C.get(M);
+            if (!g) throw new Error("missing: " + M);
+            return g;
+          }
+          function d(C) {
+            var M = f, g = j, P, A = o(30), z, O, U, G, Z = 1;
+            C == null && (C = []);
+            function j(_e) {
+              return 1 / Math.min(U[_e.source.index], U[_e.target.index]);
+            }
+            function N(_e) {
+              for (var Ce = 0, Le = C.length; Ce < Z; ++Ce) for (var ge = 0, ie, Se, Ee, Ae, Be, Pe, me; ge < Le; ++ge) ie = C[ge], Se = ie.source, Ee = ie.target, Ae = Ee.x + Ee.vx - Se.x - Se.vx || s(), Be = Ee.y + Ee.vy - Se.y - Se.vy || s(), Pe = Math.sqrt(Ae * Ae + Be * Be), Pe = (Pe - z[ge]) / Pe * _e * P[ge], Ae *= Pe, Be *= Pe, Ee.vx -= Ae * (me = G[ge]), Ee.vy -= Be * me, Se.vx += Ae * (me = 1 - me), Se.vy += Be * me;
+            }
+            function H() {
+              if (O) {
+                var _e, Ce = O.length, Le = C.length, ge = r.map(O, M), ie;
+                for (_e = 0, U = new Array(Ce); _e < Le; ++_e) ie = C[_e], ie.index = _e, typeof ie.source != "object" && (ie.source = h(ge, ie.source)), typeof ie.target != "object" && (ie.target = h(ge, ie.target)), U[ie.source.index] = (U[ie.source.index] || 0) + 1, U[ie.target.index] = (U[ie.target.index] || 0) + 1;
+                for (_e = 0, G = new Array(Le); _e < Le; ++_e) ie = C[_e], G[_e] = U[ie.source.index] / (U[ie.source.index] + U[ie.target.index]);
+                P = new Array(Le), re(), z = new Array(Le), oe();
+              }
+            }
+            function re() {
+              if (O) for (var _e = 0, Ce = C.length; _e < Ce; ++_e) P[_e] = +g(C[_e], _e, C);
+            }
+            function oe() {
+              if (O) for (var _e = 0, Ce = C.length; _e < Ce; ++_e) z[_e] = +A(C[_e], _e, C);
+            }
+            return N.initialize = function(_e) {
+              O = _e, H();
+            }, N.links = function(_e) {
+              return arguments.length ? (C = _e, H(), N) : C;
+            }, N.id = function(_e) {
+              return arguments.length ? (M = _e, N) : M;
+            }, N.iterations = function(_e) {
+              return arguments.length ? (Z = +_e, N) : Z;
+            }, N.strength = function(_e) {
+              return arguments.length ? (g = typeof _e == "function" ? _e : o(+_e), re(), N) : g;
+            }, N.distance = function(_e) {
+              return arguments.length ? (A = typeof _e == "function" ? _e : o(+_e), oe(), N) : A;
+            }, N;
+          }
+          function v(C) {
+            return C.x;
+          }
+          function _(C) {
+            return C.y;
+          }
+          var b = 10, p = Math.PI * (3 - Math.sqrt(5));
+          function k(C) {
+            var M, g = 1, P = 1e-3, A = 1 - Math.pow(P, 1 / 300), z = 0, O = 0.6, U = r.map(), G = i.timer(j), Z = n.dispatch("tick", "end");
+            C == null && (C = []);
+            function j() {
+              N(), Z.call("tick", M), g < P && (G.stop(), Z.call("end", M));
+            }
+            function N(oe) {
+              var _e, Ce = C.length, Le;
+              oe === void 0 && (oe = 1);
+              for (var ge = 0; ge < oe; ++ge) for (g += (z - g) * A, U.each(function(ie) {
+                ie(g);
+              }), _e = 0; _e < Ce; ++_e) Le = C[_e], Le.fx == null ? Le.x += Le.vx *= O : (Le.x = Le.fx, Le.vx = 0), Le.fy == null ? Le.y += Le.vy *= O : (Le.y = Le.fy, Le.vy = 0);
+              return M;
+            }
+            function H() {
+              for (var oe = 0, _e = C.length, Ce; oe < _e; ++oe) {
+                if (Ce = C[oe], Ce.index = oe, Ce.fx != null && (Ce.x = Ce.fx), Ce.fy != null && (Ce.y = Ce.fy), isNaN(Ce.x) || isNaN(Ce.y)) {
+                  var Le = b * Math.sqrt(oe), ge = oe * p;
+                  Ce.x = Le * Math.cos(ge), Ce.y = Le * Math.sin(ge);
+                }
+                (isNaN(Ce.vx) || isNaN(Ce.vy)) && (Ce.vx = Ce.vy = 0);
+              }
+            }
+            function re(oe) {
+              return oe.initialize && oe.initialize(C), oe;
+            }
+            return H(), M = { tick: N, restart: function() {
+              return G.restart(j), M;
+            }, stop: function() {
+              return G.stop(), M;
+            }, nodes: function(oe) {
+              return arguments.length ? (C = oe, H(), U.each(re), M) : C;
+            }, alpha: function(oe) {
+              return arguments.length ? (g = +oe, M) : g;
+            }, alphaMin: function(oe) {
+              return arguments.length ? (P = +oe, M) : P;
+            }, alphaDecay: function(oe) {
+              return arguments.length ? (A = +oe, M) : +A;
+            }, alphaTarget: function(oe) {
+              return arguments.length ? (z = +oe, M) : z;
+            }, velocityDecay: function(oe) {
+              return arguments.length ? (O = 1 - oe, M) : 1 - O;
+            }, force: function(oe, _e) {
+              return arguments.length > 1 ? (_e == null ? U.remove(oe) : U.set(oe, re(_e)), M) : U.get(oe);
+            }, find: function(oe, _e, Ce) {
+              var Le = 0, ge = C.length, ie, Se, Ee, Ae, Be;
+              for (Ce == null ? Ce = 1 / 0 : Ce *= Ce, Le = 0; Le < ge; ++Le) Ae = C[Le], ie = oe - Ae.x, Se = _e - Ae.y, Ee = ie * ie + Se * Se, Ee < Ce && (Be = Ae, Ce = Ee);
+              return Be;
+            }, on: function(oe, _e) {
+              return arguments.length > 1 ? (Z.on(oe, _e), M) : Z.on(oe);
+            } };
+          }
+          function E() {
+            var C, M, g, P = o(-30), A, z = 1, O = 1 / 0, U = 0.81;
+            function G(H) {
+              var re, oe = C.length, _e = t.quadtree(C, v, _).visitAfter(j);
+              for (g = H, re = 0; re < oe; ++re) M = C[re], _e.visit(N);
+            }
+            function Z() {
+              if (C) {
+                var H, re = C.length, oe;
+                for (A = new Array(re), H = 0; H < re; ++H) oe = C[H], A[oe.index] = +P(oe, H, C);
+              }
+            }
+            function j(H) {
+              var re = 0, oe, _e, Ce = 0, Le, ge, ie;
+              if (H.length) {
+                for (Le = ge = ie = 0; ie < 4; ++ie) (oe = H[ie]) && (_e = Math.abs(oe.value)) && (re += oe.value, Ce += _e, Le += _e * oe.x, ge += _e * oe.y);
+                H.x = Le / Ce, H.y = ge / Ce;
+              } else {
+                oe = H, oe.x = oe.data.x, oe.y = oe.data.y;
+                do
+                  re += A[oe.data.index];
+                while (oe = oe.next);
+              }
+              H.value = re;
+            }
+            function N(H, re, oe, _e) {
+              if (!H.value) return true;
+              var Ce = H.x - M.x, Le = H.y - M.y, ge = _e - re, ie = Ce * Ce + Le * Le;
+              if (ge * ge / U < ie) return ie < O && (Ce === 0 && (Ce = s(), ie += Ce * Ce), Le === 0 && (Le = s(), ie += Le * Le), ie < z && (ie = Math.sqrt(z * ie)), M.vx += Ce * H.value * g / ie, M.vy += Le * H.value * g / ie), true;
+              if (H.length || ie >= O) return;
+              (H.data !== M || H.next) && (Ce === 0 && (Ce = s(), ie += Ce * Ce), Le === 0 && (Le = s(), ie += Le * Le), ie < z && (ie = Math.sqrt(z * ie)));
+              do
+                H.data !== M && (ge = A[H.data.index] * g / ie, M.vx += Ce * ge, M.vy += Le * ge);
+              while (H = H.next);
+            }
+            return G.initialize = function(H) {
+              C = H, Z();
+            }, G.strength = function(H) {
+              return arguments.length ? (P = typeof H == "function" ? H : o(+H), Z(), G) : P;
+            }, G.distanceMin = function(H) {
+              return arguments.length ? (z = H * H, G) : Math.sqrt(z);
+            }, G.distanceMax = function(H) {
+              return arguments.length ? (O = H * H, G) : Math.sqrt(O);
+            }, G.theta = function(H) {
+              return arguments.length ? (U = H * H, G) : Math.sqrt(U);
+            }, G;
+          }
+          function T(C, M, g) {
+            var P, A = o(0.1), z, O;
+            typeof C != "function" && (C = o(+C)), M == null && (M = 0), g == null && (g = 0);
+            function U(Z) {
+              for (var j = 0, N = P.length; j < N; ++j) {
+                var H = P[j], re = H.x - M || 1e-6, oe = H.y - g || 1e-6, _e = Math.sqrt(re * re + oe * oe), Ce = (O[j] - _e) * z[j] * Z / _e;
+                H.vx += re * Ce, H.vy += oe * Ce;
+              }
+            }
+            function G() {
+              if (P) {
+                var Z, j = P.length;
+                for (z = new Array(j), O = new Array(j), Z = 0; Z < j; ++Z) O[Z] = +C(P[Z], Z, P), z[Z] = isNaN(O[Z]) ? 0 : +A(P[Z], Z, P);
+              }
+            }
+            return U.initialize = function(Z) {
+              P = Z, G();
+            }, U.strength = function(Z) {
+              return arguments.length ? (A = typeof Z == "function" ? Z : o(+Z), G(), U) : A;
+            }, U.radius = function(Z) {
+              return arguments.length ? (C = typeof Z == "function" ? Z : o(+Z), G(), U) : C;
+            }, U.x = function(Z) {
+              return arguments.length ? (M = +Z, U) : M;
+            }, U.y = function(Z) {
+              return arguments.length ? (g = +Z, U) : g;
+            }, U;
+          }
+          function L(C) {
+            var M = o(0.1), g, P, A;
+            typeof C != "function" && (C = o(C == null ? 0 : +C));
+            function z(U) {
+              for (var G = 0, Z = g.length, j; G < Z; ++G) j = g[G], j.vx += (A[G] - j.x) * P[G] * U;
+            }
+            function O() {
+              if (g) {
+                var U, G = g.length;
+                for (P = new Array(G), A = new Array(G), U = 0; U < G; ++U) P[U] = isNaN(A[U] = +C(g[U], U, g)) ? 0 : +M(g[U], U, g);
+              }
+            }
+            return z.initialize = function(U) {
+              g = U, O();
+            }, z.strength = function(U) {
+              return arguments.length ? (M = typeof U == "function" ? U : o(+U), O(), z) : M;
+            }, z.x = function(U) {
+              return arguments.length ? (C = typeof U == "function" ? U : o(+U), O(), z) : C;
+            }, z;
+          }
+          function x(C) {
+            var M = o(0.1), g, P, A;
+            typeof C != "function" && (C = o(C == null ? 0 : +C));
+            function z(U) {
+              for (var G = 0, Z = g.length, j; G < Z; ++G) j = g[G], j.vy += (A[G] - j.y) * P[G] * U;
+            }
+            function O() {
+              if (g) {
+                var U, G = g.length;
+                for (P = new Array(G), A = new Array(G), U = 0; U < G; ++U) P[U] = isNaN(A[U] = +C(g[U], U, g)) ? 0 : +M(g[U], U, g);
+              }
+            }
+            return z.initialize = function(U) {
+              g = U, O();
+            }, z.strength = function(U) {
+              return arguments.length ? (M = typeof U == "function" ? U : o(+U), O(), z) : M;
+            }, z.y = function(U) {
+              return arguments.length ? (C = typeof U == "function" ? U : o(+U), O(), z) : C;
+            }, z;
+          }
+          e.forceCenter = a, e.forceCollide = c, e.forceLink = d, e.forceManyBody = E, e.forceRadial = T, e.forceSimulation = k, e.forceX = L, e.forceY = x, Object.defineProperty(e, "__esModule", { value: true });
+        });
+      });
+      var WWe = ye((E7, jWe) => {
+        (function(e, t) {
+          typeof E7 == "object" && typeof jWe != "undefined" ? t(E7) : (e = e || self, t(e.d3 = e.d3 || {}));
+        })(E7, function(e) {
+          var t = Math.PI, r = 2 * t, n = 1e-6, i = r - n;
+          function a() {
+            this._x0 = this._y0 = this._x1 = this._y1 = null, this._ = "";
+          }
+          function o() {
+            return new a();
+          }
+          a.prototype = o.prototype = { constructor: a, moveTo: function(s, l) {
+            this._ += "M" + (this._x0 = this._x1 = +s) + "," + (this._y0 = this._y1 = +l);
+          }, closePath: function() {
+            this._x1 !== null && (this._x1 = this._x0, this._y1 = this._y0, this._ += "Z");
+          }, lineTo: function(s, l) {
+            this._ += "L" + (this._x1 = +s) + "," + (this._y1 = +l);
+          }, quadraticCurveTo: function(s, l, u, c) {
+            this._ += "Q" + +s + "," + +l + "," + (this._x1 = +u) + "," + (this._y1 = +c);
+          }, bezierCurveTo: function(s, l, u, c, f, h) {
+            this._ += "C" + +s + "," + +l + "," + +u + "," + +c + "," + (this._x1 = +f) + "," + (this._y1 = +h);
+          }, arcTo: function(s, l, u, c, f) {
+            s = +s, l = +l, u = +u, c = +c, f = +f;
+            var h = this._x1, d = this._y1, v = u - s, _ = c - l, b = h - s, p = d - l, k = b * b + p * p;
+            if (f < 0) throw new Error("negative radius: " + f);
+            if (this._x1 === null) this._ += "M" + (this._x1 = s) + "," + (this._y1 = l);
+            else if (k > n) if (!(Math.abs(p * v - _ * b) > n) || !f) this._ += "L" + (this._x1 = s) + "," + (this._y1 = l);
+            else {
+              var E = u - h, T = c - d, L = v * v + _ * _, x = E * E + T * T, C = Math.sqrt(L), M = Math.sqrt(k), g = f * Math.tan((t - Math.acos((L + k - x) / (2 * C * M))) / 2), P = g / M, A = g / C;
+              Math.abs(P - 1) > n && (this._ += "L" + (s + P * b) + "," + (l + P * p)), this._ += "A" + f + "," + f + ",0,0," + +(p * E > b * T) + "," + (this._x1 = s + A * v) + "," + (this._y1 = l + A * _);
+            }
+          }, arc: function(s, l, u, c, f, h) {
+            s = +s, l = +l, u = +u, h = !!h;
+            var d = u * Math.cos(c), v = u * Math.sin(c), _ = s + d, b = l + v, p = 1 ^ h, k = h ? c - f : f - c;
+            if (u < 0) throw new Error("negative radius: " + u);
+            this._x1 === null ? this._ += "M" + _ + "," + b : (Math.abs(this._x1 - _) > n || Math.abs(this._y1 - b) > n) && (this._ += "L" + _ + "," + b), u && (k < 0 && (k = k % r + r), k > i ? this._ += "A" + u + "," + u + ",0,1," + p + "," + (s - d) + "," + (l - v) + "A" + u + "," + u + ",0,1," + p + "," + (this._x1 = _) + "," + (this._y1 = b) : k > n && (this._ += "A" + u + "," + u + ",0," + +(k >= t) + "," + p + "," + (this._x1 = s + u * Math.cos(f)) + "," + (this._y1 = l + u * Math.sin(f))));
+          }, rect: function(s, l, u, c) {
+            this._ += "M" + (this._x0 = this._x1 = +s) + "," + (this._y0 = this._y1 = +l) + "h" + +u + "v" + +c + "h" + -u + "Z";
+          }, toString: function() {
+            return this._;
+          } }, e.path = o, Object.defineProperty(e, "__esModule", { value: true });
+        });
+      });
+      var $J = ye((k7, XWe) => {
+        (function(e, t) {
+          typeof k7 == "object" && typeof XWe != "undefined" ? t(k7, WWe()) : (e = e || self, t(e.d3 = e.d3 || {}, e.d3));
+        })(k7, function(e, t) {
+          function r(Mt) {
+            return function() {
+              return Mt;
+            };
+          }
+          var n = Math.abs, i = Math.atan2, a = Math.cos, o = Math.max, s = Math.min, l = Math.sin, u = Math.sqrt, c = 1e-12, f = Math.PI, h = f / 2, d = 2 * f;
+          function v(Mt) {
+            return Mt > 1 ? 0 : Mt < -1 ? f : Math.acos(Mt);
+          }
+          function _(Mt) {
+            return Mt >= 1 ? h : Mt <= -1 ? -h : Math.asin(Mt);
+          }
+          function b(Mt) {
+            return Mt.innerRadius;
+          }
+          function p(Mt) {
+            return Mt.outerRadius;
+          }
+          function k(Mt) {
+            return Mt.startAngle;
+          }
+          function E(Mt) {
+            return Mt.endAngle;
+          }
+          function T(Mt) {
+            return Mt && Mt.padAngle;
+          }
+          function L(Mt, kr, Jr, vi, hn, An, Mn, Li) {
+            var _n = Jr - Mt, ya = vi - kr, $n = Mn - hn, Ma = Li - An, _o = Ma * _n - $n * ya;
+            if (!(_o * _o < c)) return _o = ($n * (kr - An) - Ma * (Mt - hn)) / _o, [Mt + _o * _n, kr + _o * ya];
+          }
+          function x(Mt, kr, Jr, vi, hn, An, Mn) {
+            var Li = Mt - Jr, _n = kr - vi, ya = (Mn ? An : -An) / u(Li * Li + _n * _n), $n = ya * _n, Ma = -ya * Li, _o = Mt + $n, No = kr + Ma, po = Jr + $n, Lo = vi + Ma, ko = (_o + po) / 2, Ds = (No + Lo) / 2, Fs = po - _o, ll = Lo - No, ul = Fs * Fs + ll * ll, zl = hn - An, us = _o * Lo - po * No, il = (ll < 0 ? -1 : 1) * u(o(0, zl * zl * ul - us * us)), As = (us * ll - Fs * il) / ul, cl = (-us * Fs - ll * il) / ul, Ks = (us * ll + Fs * il) / ul, zs = (-us * Fs + ll * il) / ul, Io = As - ko, ls = cl - Ds, Yl = Ks - ko, Su = zs - Ds;
+            return Io * Io + ls * ls > Yl * Yl + Su * Su && (As = Ks, cl = zs), { cx: As, cy: cl, x01: -$n, y01: -Ma, x11: As * (hn / zl - 1), y11: cl * (hn / zl - 1) };
+          }
+          function C() {
+            var Mt = b, kr = p, Jr = r(0), vi = null, hn = k, An = E, Mn = T, Li = null;
+            function _n() {
+              var ya, $n, Ma = +Mt.apply(this, arguments), _o = +kr.apply(this, arguments), No = hn.apply(this, arguments) - h, po = An.apply(this, arguments) - h, Lo = n(po - No), ko = po > No;
+              if (Li || (Li = ya = t.path()), _o < Ma && ($n = _o, _o = Ma, Ma = $n), !(_o > c)) Li.moveTo(0, 0);
+              else if (Lo > d - c) Li.moveTo(_o * a(No), _o * l(No)), Li.arc(0, 0, _o, No, po, !ko), Ma > c && (Li.moveTo(Ma * a(po), Ma * l(po)), Li.arc(0, 0, Ma, po, No, ko));
+              else {
+                var Ds = No, Fs = po, ll = No, ul = po, zl = Lo, us = Lo, il = Mn.apply(this, arguments) / 2, As = il > c && (vi ? +vi.apply(this, arguments) : u(Ma * Ma + _o * _o)), cl = s(n(_o - Ma) / 2, +Jr.apply(this, arguments)), Ks = cl, zs = cl, Io, ls;
+                if (As > c) {
+                  var Yl = _(As / Ma * l(il)), Su = _(As / _o * l(il));
+                  (zl -= Yl * 2) > c ? (Yl *= ko ? 1 : -1, ll += Yl, ul -= Yl) : (zl = 0, ll = ul = (No + po) / 2), (us -= Su * 2) > c ? (Su *= ko ? 1 : -1, Ds += Su, Fs -= Su) : (us = 0, Ds = Fs = (No + po) / 2);
+                }
+                var nc = _o * a(Ds), bs = _o * l(Ds), Rn = Ma * a(ul), _a = Ma * l(ul);
+                if (cl > c) {
+                  var Vu = _o * a(Fs), Ol = _o * l(Fs), xo = Ma * a(ll), Kl = Ma * l(ll), Ns;
+                  if (Lo < f && (Ns = L(nc, bs, xo, Kl, Vu, Ol, Rn, _a))) {
+                    var Hl = nc - Ns[0], ac = bs - Ns[1], aa = Vu - Ns[0], Oo = Ol - Ns[1], qo = 1 / l(v((Hl * aa + ac * Oo) / (u(Hl * Hl + ac * ac) * u(aa * aa + Oo * Oo))) / 2), ql = u(Ns[0] * Ns[0] + Ns[1] * Ns[1]);
+                    Ks = s(cl, (Ma - ql) / (qo - 1)), zs = s(cl, (_o - ql) / (qo + 1));
+                  }
+                }
+                us > c ? zs > c ? (Io = x(xo, Kl, nc, bs, _o, zs, ko), ls = x(Vu, Ol, Rn, _a, _o, zs, ko), Li.moveTo(Io.cx + Io.x01, Io.cy + Io.y01), zs < cl ? Li.arc(Io.cx, Io.cy, zs, i(Io.y01, Io.x01), i(ls.y01, ls.x01), !ko) : (Li.arc(Io.cx, Io.cy, zs, i(Io.y01, Io.x01), i(Io.y11, Io.x11), !ko), Li.arc(0, 0, _o, i(Io.cy + Io.y11, Io.cx + Io.x11), i(ls.cy + ls.y11, ls.cx + ls.x11), !ko), Li.arc(ls.cx, ls.cy, zs, i(ls.y11, ls.x11), i(ls.y01, ls.x01), !ko))) : (Li.moveTo(nc, bs), Li.arc(0, 0, _o, Ds, Fs, !ko)) : Li.moveTo(nc, bs), !(Ma > c) || !(zl > c) ? Li.lineTo(Rn, _a) : Ks > c ? (Io = x(Rn, _a, Vu, Ol, Ma, -Ks, ko), ls = x(nc, bs, xo, Kl, Ma, -Ks, ko), Li.lineTo(Io.cx + Io.x01, Io.cy + Io.y01), Ks < cl ? Li.arc(Io.cx, Io.cy, Ks, i(Io.y01, Io.x01), i(ls.y01, ls.x01), !ko) : (Li.arc(Io.cx, Io.cy, Ks, i(Io.y01, Io.x01), i(Io.y11, Io.x11), !ko), Li.arc(0, 0, Ma, i(Io.cy + Io.y11, Io.cx + Io.x11), i(ls.cy + ls.y11, ls.cx + ls.x11), ko), Li.arc(ls.cx, ls.cy, Ks, i(ls.y11, ls.x11), i(ls.y01, ls.x01), !ko))) : Li.arc(0, 0, Ma, ul, ll, ko);
+              }
+              if (Li.closePath(), ya) return Li = null, ya + "" || null;
+            }
+            return _n.centroid = function() {
+              var ya = (+Mt.apply(this, arguments) + +kr.apply(this, arguments)) / 2, $n = (+hn.apply(this, arguments) + +An.apply(this, arguments)) / 2 - f / 2;
+              return [a($n) * ya, l($n) * ya];
+            }, _n.innerRadius = function(ya) {
+              return arguments.length ? (Mt = typeof ya == "function" ? ya : r(+ya), _n) : Mt;
+            }, _n.outerRadius = function(ya) {
+              return arguments.length ? (kr = typeof ya == "function" ? ya : r(+ya), _n) : kr;
+            }, _n.cornerRadius = function(ya) {
+              return arguments.length ? (Jr = typeof ya == "function" ? ya : r(+ya), _n) : Jr;
+            }, _n.padRadius = function(ya) {
+              return arguments.length ? (vi = ya == null ? null : typeof ya == "function" ? ya : r(+ya), _n) : vi;
+            }, _n.startAngle = function(ya) {
+              return arguments.length ? (hn = typeof ya == "function" ? ya : r(+ya), _n) : hn;
+            }, _n.endAngle = function(ya) {
+              return arguments.length ? (An = typeof ya == "function" ? ya : r(+ya), _n) : An;
+            }, _n.padAngle = function(ya) {
+              return arguments.length ? (Mn = typeof ya == "function" ? ya : r(+ya), _n) : Mn;
+            }, _n.context = function(ya) {
+              return arguments.length ? (Li = ya == null ? null : ya, _n) : Li;
+            }, _n;
+          }
+          function M(Mt) {
+            this._context = Mt;
+          }
+          M.prototype = { areaStart: function() {
+            this._line = 0;
+          }, areaEnd: function() {
+            this._line = NaN;
+          }, lineStart: function() {
+            this._point = 0;
+          }, lineEnd: function() {
+            (this._line || this._line !== 0 && this._point === 1) && this._context.closePath(), this._line = 1 - this._line;
+          }, point: function(Mt, kr) {
+            switch (Mt = +Mt, kr = +kr, this._point) {
+              case 0:
+                this._point = 1, this._line ? this._context.lineTo(Mt, kr) : this._context.moveTo(Mt, kr);
+                break;
+              case 1:
+                this._point = 2;
+              default:
+                this._context.lineTo(Mt, kr);
+                break;
+            }
+          } };
+          function g(Mt) {
+            return new M(Mt);
+          }
+          function P(Mt) {
+            return Mt[0];
+          }
+          function A(Mt) {
+            return Mt[1];
+          }
+          function z() {
+            var Mt = P, kr = A, Jr = r(true), vi = null, hn = g, An = null;
+            function Mn(Li) {
+              var _n, ya = Li.length, $n, Ma = false, _o;
+              for (vi == null && (An = hn(_o = t.path())), _n = 0; _n <= ya; ++_n) !(_n < ya && Jr($n = Li[_n], _n, Li)) === Ma && ((Ma = !Ma) ? An.lineStart() : An.lineEnd()), Ma && An.point(+Mt($n, _n, Li), +kr($n, _n, Li));
+              if (_o) return An = null, _o + "" || null;
+            }
+            return Mn.x = function(Li) {
+              return arguments.length ? (Mt = typeof Li == "function" ? Li : r(+Li), Mn) : Mt;
+            }, Mn.y = function(Li) {
+              return arguments.length ? (kr = typeof Li == "function" ? Li : r(+Li), Mn) : kr;
+            }, Mn.defined = function(Li) {
+              return arguments.length ? (Jr = typeof Li == "function" ? Li : r(!!Li), Mn) : Jr;
+            }, Mn.curve = function(Li) {
+              return arguments.length ? (hn = Li, vi != null && (An = hn(vi)), Mn) : hn;
+            }, Mn.context = function(Li) {
+              return arguments.length ? (Li == null ? vi = An = null : An = hn(vi = Li), Mn) : vi;
+            }, Mn;
+          }
+          function O() {
+            var Mt = P, kr = null, Jr = r(0), vi = A, hn = r(true), An = null, Mn = g, Li = null;
+            function _n($n) {
+              var Ma, _o, No, po = $n.length, Lo, ko = false, Ds, Fs = new Array(po), ll = new Array(po);
+              for (An == null && (Li = Mn(Ds = t.path())), Ma = 0; Ma <= po; ++Ma) {
+                if (!(Ma < po && hn(Lo = $n[Ma], Ma, $n)) === ko) if (ko = !ko) _o = Ma, Li.areaStart(), Li.lineStart();
+                else {
+                  for (Li.lineEnd(), Li.lineStart(), No = Ma - 1; No >= _o; --No) Li.point(Fs[No], ll[No]);
+                  Li.lineEnd(), Li.areaEnd();
+                }
+                ko && (Fs[Ma] = +Mt(Lo, Ma, $n), ll[Ma] = +Jr(Lo, Ma, $n), Li.point(kr ? +kr(Lo, Ma, $n) : Fs[Ma], vi ? +vi(Lo, Ma, $n) : ll[Ma]));
+              }
+              if (Ds) return Li = null, Ds + "" || null;
+            }
+            function ya() {
+              return z().defined(hn).curve(Mn).context(An);
+            }
+            return _n.x = function($n) {
+              return arguments.length ? (Mt = typeof $n == "function" ? $n : r(+$n), kr = null, _n) : Mt;
+            }, _n.x0 = function($n) {
+              return arguments.length ? (Mt = typeof $n == "function" ? $n : r(+$n), _n) : Mt;
+            }, _n.x1 = function($n) {
+              return arguments.length ? (kr = $n == null ? null : typeof $n == "function" ? $n : r(+$n), _n) : kr;
+            }, _n.y = function($n) {
+              return arguments.length ? (Jr = typeof $n == "function" ? $n : r(+$n), vi = null, _n) : Jr;
+            }, _n.y0 = function($n) {
+              return arguments.length ? (Jr = typeof $n == "function" ? $n : r(+$n), _n) : Jr;
+            }, _n.y1 = function($n) {
+              return arguments.length ? (vi = $n == null ? null : typeof $n == "function" ? $n : r(+$n), _n) : vi;
+            }, _n.lineX0 = _n.lineY0 = function() {
+              return ya().x(Mt).y(Jr);
+            }, _n.lineY1 = function() {
+              return ya().x(Mt).y(vi);
+            }, _n.lineX1 = function() {
+              return ya().x(kr).y(Jr);
+            }, _n.defined = function($n) {
+              return arguments.length ? (hn = typeof $n == "function" ? $n : r(!!$n), _n) : hn;
+            }, _n.curve = function($n) {
+              return arguments.length ? (Mn = $n, An != null && (Li = Mn(An)), _n) : Mn;
+            }, _n.context = function($n) {
+              return arguments.length ? ($n == null ? An = Li = null : Li = Mn(An = $n), _n) : An;
+            }, _n;
+          }
+          function U(Mt, kr) {
+            return kr < Mt ? -1 : kr > Mt ? 1 : kr >= Mt ? 0 : NaN;
+          }
+          function G(Mt) {
+            return Mt;
+          }
+          function Z() {
+            var Mt = G, kr = U, Jr = null, vi = r(0), hn = r(d), An = r(0);
+            function Mn(Li) {
+              var _n, ya = Li.length, $n, Ma, _o = 0, No = new Array(ya), po = new Array(ya), Lo = +vi.apply(this, arguments), ko = Math.min(d, Math.max(-d, hn.apply(this, arguments) - Lo)), Ds, Fs = Math.min(Math.abs(ko) / ya, An.apply(this, arguments)), ll = Fs * (ko < 0 ? -1 : 1), ul;
+              for (_n = 0; _n < ya; ++_n) (ul = po[No[_n] = _n] = +Mt(Li[_n], _n, Li)) > 0 && (_o += ul);
+              for (kr != null ? No.sort(function(zl, us) {
+                return kr(po[zl], po[us]);
+              }) : Jr != null && No.sort(function(zl, us) {
+                return Jr(Li[zl], Li[us]);
+              }), _n = 0, Ma = _o ? (ko - ya * ll) / _o : 0; _n < ya; ++_n, Lo = Ds) $n = No[_n], ul = po[$n], Ds = Lo + (ul > 0 ? ul * Ma : 0) + ll, po[$n] = { data: Li[$n], index: _n, value: ul, startAngle: Lo, endAngle: Ds, padAngle: Fs };
+              return po;
+            }
+            return Mn.value = function(Li) {
+              return arguments.length ? (Mt = typeof Li == "function" ? Li : r(+Li), Mn) : Mt;
+            }, Mn.sortValues = function(Li) {
+              return arguments.length ? (kr = Li, Jr = null, Mn) : kr;
+            }, Mn.sort = function(Li) {
+              return arguments.length ? (Jr = Li, kr = null, Mn) : Jr;
+            }, Mn.startAngle = function(Li) {
+              return arguments.length ? (vi = typeof Li == "function" ? Li : r(+Li), Mn) : vi;
+            }, Mn.endAngle = function(Li) {
+              return arguments.length ? (hn = typeof Li == "function" ? Li : r(+Li), Mn) : hn;
+            }, Mn.padAngle = function(Li) {
+              return arguments.length ? (An = typeof Li == "function" ? Li : r(+Li), Mn) : An;
+            }, Mn;
+          }
+          var j = H(g);
+          function N(Mt) {
+            this._curve = Mt;
+          }
+          N.prototype = { areaStart: function() {
+            this._curve.areaStart();
+          }, areaEnd: function() {
+            this._curve.areaEnd();
+          }, lineStart: function() {
+            this._curve.lineStart();
+          }, lineEnd: function() {
+            this._curve.lineEnd();
+          }, point: function(Mt, kr) {
+            this._curve.point(kr * Math.sin(Mt), kr * -Math.cos(Mt));
+          } };
+          function H(Mt) {
+            function kr(Jr) {
+              return new N(Mt(Jr));
+            }
+            return kr._curve = Mt, kr;
+          }
+          function re(Mt) {
+            var kr = Mt.curve;
+            return Mt.angle = Mt.x, delete Mt.x, Mt.radius = Mt.y, delete Mt.y, Mt.curve = function(Jr) {
+              return arguments.length ? kr(H(Jr)) : kr()._curve;
+            }, Mt;
+          }
+          function oe() {
+            return re(z().curve(j));
+          }
+          function _e() {
+            var Mt = O().curve(j), kr = Mt.curve, Jr = Mt.lineX0, vi = Mt.lineX1, hn = Mt.lineY0, An = Mt.lineY1;
+            return Mt.angle = Mt.x, delete Mt.x, Mt.startAngle = Mt.x0, delete Mt.x0, Mt.endAngle = Mt.x1, delete Mt.x1, Mt.radius = Mt.y, delete Mt.y, Mt.innerRadius = Mt.y0, delete Mt.y0, Mt.outerRadius = Mt.y1, delete Mt.y1, Mt.lineStartAngle = function() {
+              return re(Jr());
+            }, delete Mt.lineX0, Mt.lineEndAngle = function() {
+              return re(vi());
+            }, delete Mt.lineX1, Mt.lineInnerRadius = function() {
+              return re(hn());
+            }, delete Mt.lineY0, Mt.lineOuterRadius = function() {
+              return re(An());
+            }, delete Mt.lineY1, Mt.curve = function(Mn) {
+              return arguments.length ? kr(H(Mn)) : kr()._curve;
+            }, Mt;
+          }
+          function Ce(Mt, kr) {
+            return [(kr = +kr) * Math.cos(Mt -= Math.PI / 2), kr * Math.sin(Mt)];
+          }
+          var Le = Array.prototype.slice;
+          function ge(Mt) {
+            return Mt.source;
+          }
+          function ie(Mt) {
+            return Mt.target;
+          }
+          function Se(Mt) {
+            var kr = ge, Jr = ie, vi = P, hn = A, An = null;
+            function Mn() {
+              var Li, _n = Le.call(arguments), ya = kr.apply(this, _n), $n = Jr.apply(this, _n);
+              if (An || (An = Li = t.path()), Mt(An, +vi.apply(this, (_n[0] = ya, _n)), +hn.apply(this, _n), +vi.apply(this, (_n[0] = $n, _n)), +hn.apply(this, _n)), Li) return An = null, Li + "" || null;
+            }
+            return Mn.source = function(Li) {
+              return arguments.length ? (kr = Li, Mn) : kr;
+            }, Mn.target = function(Li) {
+              return arguments.length ? (Jr = Li, Mn) : Jr;
+            }, Mn.x = function(Li) {
+              return arguments.length ? (vi = typeof Li == "function" ? Li : r(+Li), Mn) : vi;
+            }, Mn.y = function(Li) {
+              return arguments.length ? (hn = typeof Li == "function" ? Li : r(+Li), Mn) : hn;
+            }, Mn.context = function(Li) {
+              return arguments.length ? (An = Li == null ? null : Li, Mn) : An;
+            }, Mn;
+          }
+          function Ee(Mt, kr, Jr, vi, hn) {
+            Mt.moveTo(kr, Jr), Mt.bezierCurveTo(kr = (kr + vi) / 2, Jr, kr, hn, vi, hn);
+          }
+          function Ae(Mt, kr, Jr, vi, hn) {
+            Mt.moveTo(kr, Jr), Mt.bezierCurveTo(kr, Jr = (Jr + hn) / 2, vi, Jr, vi, hn);
+          }
+          function Be(Mt, kr, Jr, vi, hn) {
+            var An = Ce(kr, Jr), Mn = Ce(kr, Jr = (Jr + hn) / 2), Li = Ce(vi, Jr), _n = Ce(vi, hn);
+            Mt.moveTo(An[0], An[1]), Mt.bezierCurveTo(Mn[0], Mn[1], Li[0], Li[1], _n[0], _n[1]);
+          }
+          function Pe() {
+            return Se(Ee);
+          }
+          function me() {
+            return Se(Ae);
+          }
+          function De() {
+            var Mt = Se(Be);
+            return Mt.angle = Mt.x, delete Mt.x, Mt.radius = Mt.y, delete Mt.y, Mt;
+          }
+          var ce = { draw: function(Mt, kr) {
+            var Jr = Math.sqrt(kr / f);
+            Mt.moveTo(Jr, 0), Mt.arc(0, 0, Jr, 0, d);
+          } }, je = { draw: function(Mt, kr) {
+            var Jr = Math.sqrt(kr / 5) / 2;
+            Mt.moveTo(-3 * Jr, -Jr), Mt.lineTo(-Jr, -Jr), Mt.lineTo(-Jr, -3 * Jr), Mt.lineTo(Jr, -3 * Jr), Mt.lineTo(Jr, -Jr), Mt.lineTo(3 * Jr, -Jr), Mt.lineTo(3 * Jr, Jr), Mt.lineTo(Jr, Jr), Mt.lineTo(Jr, 3 * Jr), Mt.lineTo(-Jr, 3 * Jr), Mt.lineTo(-Jr, Jr), Mt.lineTo(-3 * Jr, Jr), Mt.closePath();
+          } }, lt = Math.sqrt(1 / 3), pt = lt * 2, Vt = { draw: function(Mt, kr) {
+            var Jr = Math.sqrt(kr / pt), vi = Jr * lt;
+            Mt.moveTo(0, -Jr), Mt.lineTo(vi, 0), Mt.lineTo(0, Jr), Mt.lineTo(-vi, 0), Mt.closePath();
+          } }, ot = 0.8908130915292852, ut = Math.sin(f / 10) / Math.sin(7 * f / 10), Wt = Math.sin(d / 10) * ut, Nt = -Math.cos(d / 10) * ut, $t = { draw: function(Mt, kr) {
+            var Jr = Math.sqrt(kr * ot), vi = Wt * Jr, hn = Nt * Jr;
+            Mt.moveTo(0, -Jr), Mt.lineTo(vi, hn);
+            for (var An = 1; An < 5; ++An) {
+              var Mn = d * An / 5, Li = Math.cos(Mn), _n = Math.sin(Mn);
+              Mt.lineTo(_n * Jr, -Li * Jr), Mt.lineTo(Li * vi - _n * hn, _n * vi + Li * hn);
+            }
+            Mt.closePath();
+          } }, sr = { draw: function(Mt, kr) {
+            var Jr = Math.sqrt(kr), vi = -Jr / 2;
+            Mt.rect(vi, vi, Jr, Jr);
+          } }, Tr = Math.sqrt(3), fr = { draw: function(Mt, kr) {
+            var Jr = -Math.sqrt(kr / (Tr * 3));
+            Mt.moveTo(0, Jr * 2), Mt.lineTo(-Tr * Jr, -Jr), Mt.lineTo(Tr * Jr, -Jr), Mt.closePath();
+          } }, $e = -0.5, St = Math.sqrt(3) / 2, Qt = 1 / Math.sqrt(12), Gt = (Qt / 2 + 1) * 3, _t = { draw: function(Mt, kr) {
+            var Jr = Math.sqrt(kr / Gt), vi = Jr / 2, hn = Jr * Qt, An = vi, Mn = Jr * Qt + Jr, Li = -An, _n = Mn;
+            Mt.moveTo(vi, hn), Mt.lineTo(An, Mn), Mt.lineTo(Li, _n), Mt.lineTo($e * vi - St * hn, St * vi + $e * hn), Mt.lineTo($e * An - St * Mn, St * An + $e * Mn), Mt.lineTo($e * Li - St * _n, St * Li + $e * _n), Mt.lineTo($e * vi + St * hn, $e * hn - St * vi), Mt.lineTo($e * An + St * Mn, $e * Mn - St * An), Mt.lineTo($e * Li + St * _n, $e * _n - St * Li), Mt.closePath();
+          } }, It = [ce, je, Vt, sr, $t, fr, _t];
+          function mt() {
+            var Mt = r(ce), kr = r(64), Jr = null;
+            function vi() {
+              var hn;
+              if (Jr || (Jr = hn = t.path()), Mt.apply(this, arguments).draw(Jr, +kr.apply(this, arguments)), hn) return Jr = null, hn + "" || null;
+            }
+            return vi.type = function(hn) {
+              return arguments.length ? (Mt = typeof hn == "function" ? hn : r(hn), vi) : Mt;
+            }, vi.size = function(hn) {
+              return arguments.length ? (kr = typeof hn == "function" ? hn : r(+hn), vi) : kr;
+            }, vi.context = function(hn) {
+              return arguments.length ? (Jr = hn == null ? null : hn, vi) : Jr;
+            }, vi;
+          }
+          function er() {
+          }
+          function lr(Mt, kr, Jr) {
+            Mt._context.bezierCurveTo((2 * Mt._x0 + Mt._x1) / 3, (2 * Mt._y0 + Mt._y1) / 3, (Mt._x0 + 2 * Mt._x1) / 3, (Mt._y0 + 2 * Mt._y1) / 3, (Mt._x0 + 4 * Mt._x1 + kr) / 6, (Mt._y0 + 4 * Mt._y1 + Jr) / 6);
+          }
+          function wr(Mt) {
+            this._context = Mt;
+          }
+          wr.prototype = { areaStart: function() {
+            this._line = 0;
+          }, areaEnd: function() {
+            this._line = NaN;
+          }, lineStart: function() {
+            this._x0 = this._x1 = this._y0 = this._y1 = NaN, this._point = 0;
+          }, lineEnd: function() {
+            switch (this._point) {
+              case 3:
+                lr(this, this._x1, this._y1);
+              case 2:
+                this._context.lineTo(this._x1, this._y1);
+                break;
+            }
+            (this._line || this._line !== 0 && this._point === 1) && this._context.closePath(), this._line = 1 - this._line;
+          }, point: function(Mt, kr) {
+            switch (Mt = +Mt, kr = +kr, this._point) {
+              case 0:
+                this._point = 1, this._line ? this._context.lineTo(Mt, kr) : this._context.moveTo(Mt, kr);
+                break;
+              case 1:
+                this._point = 2;
+                break;
+              case 2:
+                this._point = 3, this._context.lineTo((5 * this._x0 + this._x1) / 6, (5 * this._y0 + this._y1) / 6);
+              default:
+                lr(this, Mt, kr);
+                break;
+            }
+            this._x0 = this._x1, this._x1 = Mt, this._y0 = this._y1, this._y1 = kr;
+          } };
+          function Lr(Mt) {
+            return new wr(Mt);
+          }
+          function ti(Mt) {
+            this._context = Mt;
+          }
+          ti.prototype = { areaStart: er, areaEnd: er, lineStart: function() {
+            this._x0 = this._x1 = this._x2 = this._x3 = this._x4 = this._y0 = this._y1 = this._y2 = this._y3 = this._y4 = NaN, this._point = 0;
+          }, lineEnd: function() {
+            switch (this._point) {
+              case 1: {
+                this._context.moveTo(this._x2, this._y2), this._context.closePath();
+                break;
+              }
+              case 2: {
+                this._context.moveTo((this._x2 + 2 * this._x3) / 3, (this._y2 + 2 * this._y3) / 3), this._context.lineTo((this._x3 + 2 * this._x2) / 3, (this._y3 + 2 * this._y2) / 3), this._context.closePath();
+                break;
+              }
+              case 3: {
+                this.point(this._x2, this._y2), this.point(this._x3, this._y3), this.point(this._x4, this._y4);
+                break;
+              }
+            }
+          }, point: function(Mt, kr) {
+            switch (Mt = +Mt, kr = +kr, this._point) {
+              case 0:
+                this._point = 1, this._x2 = Mt, this._y2 = kr;
+                break;
+              case 1:
+                this._point = 2, this._x3 = Mt, this._y3 = kr;
+                break;
+              case 2:
+                this._point = 3, this._x4 = Mt, this._y4 = kr, this._context.moveTo((this._x0 + 4 * this._x1 + Mt) / 6, (this._y0 + 4 * this._y1 + kr) / 6);
+                break;
+              default:
+                lr(this, Mt, kr);
+                break;
+            }
+            this._x0 = this._x1, this._x1 = Mt, this._y0 = this._y1, this._y1 = kr;
+          } };
+          function Br(Mt) {
+            return new ti(Mt);
+          }
+          function Vr(Mt) {
+            this._context = Mt;
+          }
+          Vr.prototype = { areaStart: function() {
+            this._line = 0;
+          }, areaEnd: function() {
+            this._line = NaN;
+          }, lineStart: function() {
+            this._x0 = this._x1 = this._y0 = this._y1 = NaN, this._point = 0;
+          }, lineEnd: function() {
+            (this._line || this._line !== 0 && this._point === 3) && this._context.closePath(), this._line = 1 - this._line;
+          }, point: function(Mt, kr) {
+            switch (Mt = +Mt, kr = +kr, this._point) {
+              case 0:
+                this._point = 1;
+                break;
+              case 1:
+                this._point = 2;
+                break;
+              case 2:
+                this._point = 3;
+                var Jr = (this._x0 + 4 * this._x1 + Mt) / 6, vi = (this._y0 + 4 * this._y1 + kr) / 6;
+                this._line ? this._context.lineTo(Jr, vi) : this._context.moveTo(Jr, vi);
+                break;
+              case 3:
+                this._point = 4;
+              default:
+                lr(this, Mt, kr);
+                break;
+            }
+            this._x0 = this._x1, this._x1 = Mt, this._y0 = this._y1, this._y1 = kr;
+          } };
+          function dt(Mt) {
+            return new Vr(Mt);
+          }
+          function Ge(Mt, kr) {
+            this._basis = new wr(Mt), this._beta = kr;
+          }
+          Ge.prototype = { lineStart: function() {
+            this._x = [], this._y = [], this._basis.lineStart();
+          }, lineEnd: function() {
+            var Mt = this._x, kr = this._y, Jr = Mt.length - 1;
+            if (Jr > 0) for (var vi = Mt[0], hn = kr[0], An = Mt[Jr] - vi, Mn = kr[Jr] - hn, Li = -1, _n; ++Li <= Jr; ) _n = Li / Jr, this._basis.point(this._beta * Mt[Li] + (1 - this._beta) * (vi + _n * An), this._beta * kr[Li] + (1 - this._beta) * (hn + _n * Mn));
+            this._x = this._y = null, this._basis.lineEnd();
+          }, point: function(Mt, kr) {
+            this._x.push(+Mt), this._y.push(+kr);
+          } };
+          var Je = function Mt(kr) {
+            function Jr(vi) {
+              return kr === 1 ? new wr(vi) : new Ge(vi, kr);
+            }
+            return Jr.beta = function(vi) {
+              return Mt(+vi);
+            }, Jr;
+          }(0.85);
+          function We(Mt, kr, Jr) {
+            Mt._context.bezierCurveTo(Mt._x1 + Mt._k * (Mt._x2 - Mt._x0), Mt._y1 + Mt._k * (Mt._y2 - Mt._y0), Mt._x2 + Mt._k * (Mt._x1 - kr), Mt._y2 + Mt._k * (Mt._y1 - Jr), Mt._x2, Mt._y2);
+          }
+          function tt(Mt, kr) {
+            this._context = Mt, this._k = (1 - kr) / 6;
+          }
+          tt.prototype = { areaStart: function() {
+            this._line = 0;
+          }, areaEnd: function() {
+            this._line = NaN;
+          }, lineStart: function() {
+            this._x0 = this._x1 = this._x2 = this._y0 = this._y1 = this._y2 = NaN, this._point = 0;
+          }, lineEnd: function() {
+            switch (this._point) {
+              case 2:
+                this._context.lineTo(this._x2, this._y2);
+                break;
+              case 3:
+                We(this, this._x1, this._y1);
+                break;
+            }
+            (this._line || this._line !== 0 && this._point === 1) && this._context.closePath(), this._line = 1 - this._line;
+          }, point: function(Mt, kr) {
+            switch (Mt = +Mt, kr = +kr, this._point) {
+              case 0:
+                this._point = 1, this._line ? this._context.lineTo(Mt, kr) : this._context.moveTo(Mt, kr);
+                break;
+              case 1:
+                this._point = 2, this._x1 = Mt, this._y1 = kr;
+                break;
+              case 2:
+                this._point = 3;
+              default:
+                We(this, Mt, kr);
+                break;
+            }
+            this._x0 = this._x1, this._x1 = this._x2, this._x2 = Mt, this._y0 = this._y1, this._y1 = this._y2, this._y2 = kr;
+          } };
+          var xt = function Mt(kr) {
+            function Jr(vi) {
+              return new tt(vi, kr);
+            }
+            return Jr.tension = function(vi) {
+              return Mt(+vi);
+            }, Jr;
+          }(0);
+          function Ie(Mt, kr) {
+            this._context = Mt, this._k = (1 - kr) / 6;
+          }
+          Ie.prototype = { areaStart: er, areaEnd: er, lineStart: function() {
+            this._x0 = this._x1 = this._x2 = this._x3 = this._x4 = this._x5 = this._y0 = this._y1 = this._y2 = this._y3 = this._y4 = this._y5 = NaN, this._point = 0;
+          }, lineEnd: function() {
+            switch (this._point) {
+              case 1: {
+                this._context.moveTo(this._x3, this._y3), this._context.closePath();
+                break;
+              }
+              case 2: {
+                this._context.lineTo(this._x3, this._y3), this._context.closePath();
+                break;
+              }
+              case 3: {
+                this.point(this._x3, this._y3), this.point(this._x4, this._y4), this.point(this._x5, this._y5);
+                break;
+              }
+            }
+          }, point: function(Mt, kr) {
+            switch (Mt = +Mt, kr = +kr, this._point) {
+              case 0:
+                this._point = 1, this._x3 = Mt, this._y3 = kr;
+                break;
+              case 1:
+                this._point = 2, this._context.moveTo(this._x4 = Mt, this._y4 = kr);
+                break;
+              case 2:
+                this._point = 3, this._x5 = Mt, this._y5 = kr;
+                break;
+              default:
+                We(this, Mt, kr);
+                break;
+            }
+            this._x0 = this._x1, this._x1 = this._x2, this._x2 = Mt, this._y0 = this._y1, this._y1 = this._y2, this._y2 = kr;
+          } };
+          var xe = function Mt(kr) {
+            function Jr(vi) {
+              return new Ie(vi, kr);
+            }
+            return Jr.tension = function(vi) {
+              return Mt(+vi);
+            }, Jr;
+          }(0);
+          function ke(Mt, kr) {
+            this._context = Mt, this._k = (1 - kr) / 6;
+          }
+          ke.prototype = { areaStart: function() {
+            this._line = 0;
+          }, areaEnd: function() {
+            this._line = NaN;
+          }, lineStart: function() {
+            this._x0 = this._x1 = this._x2 = this._y0 = this._y1 = this._y2 = NaN, this._point = 0;
+          }, lineEnd: function() {
+            (this._line || this._line !== 0 && this._point === 3) && this._context.closePath(), this._line = 1 - this._line;
+          }, point: function(Mt, kr) {
+            switch (Mt = +Mt, kr = +kr, this._point) {
+              case 0:
+                this._point = 1;
+                break;
+              case 1:
+                this._point = 2;
+                break;
+              case 2:
+                this._point = 3, this._line ? this._context.lineTo(this._x2, this._y2) : this._context.moveTo(this._x2, this._y2);
+                break;
+              case 3:
+                this._point = 4;
+              default:
+                We(this, Mt, kr);
+                break;
+            }
+            this._x0 = this._x1, this._x1 = this._x2, this._x2 = Mt, this._y0 = this._y1, this._y1 = this._y2, this._y2 = kr;
+          } };
+          var vt = function Mt(kr) {
+            function Jr(vi) {
+              return new ke(vi, kr);
+            }
+            return Jr.tension = function(vi) {
+              return Mt(+vi);
+            }, Jr;
+          }(0);
+          function ir(Mt, kr, Jr) {
+            var vi = Mt._x1, hn = Mt._y1, An = Mt._x2, Mn = Mt._y2;
+            if (Mt._l01_a > c) {
+              var Li = 2 * Mt._l01_2a + 3 * Mt._l01_a * Mt._l12_a + Mt._l12_2a, _n = 3 * Mt._l01_a * (Mt._l01_a + Mt._l12_a);
+              vi = (vi * Li - Mt._x0 * Mt._l12_2a + Mt._x2 * Mt._l01_2a) / _n, hn = (hn * Li - Mt._y0 * Mt._l12_2a + Mt._y2 * Mt._l01_2a) / _n;
+            }
+            if (Mt._l23_a > c) {
+              var ya = 2 * Mt._l23_2a + 3 * Mt._l23_a * Mt._l12_a + Mt._l12_2a, $n = 3 * Mt._l23_a * (Mt._l23_a + Mt._l12_a);
+              An = (An * ya + Mt._x1 * Mt._l23_2a - kr * Mt._l12_2a) / $n, Mn = (Mn * ya + Mt._y1 * Mt._l23_2a - Jr * Mt._l12_2a) / $n;
+            }
+            Mt._context.bezierCurveTo(vi, hn, An, Mn, Mt._x2, Mt._y2);
+          }
+          function ar(Mt, kr) {
+            this._context = Mt, this._alpha = kr;
+          }
+          ar.prototype = { areaStart: function() {
+            this._line = 0;
+          }, areaEnd: function() {
+            this._line = NaN;
+          }, lineStart: function() {
+            this._x0 = this._x1 = this._x2 = this._y0 = this._y1 = this._y2 = NaN, this._l01_a = this._l12_a = this._l23_a = this._l01_2a = this._l12_2a = this._l23_2a = this._point = 0;
+          }, lineEnd: function() {
+            switch (this._point) {
+              case 2:
+                this._context.lineTo(this._x2, this._y2);
+                break;
+              case 3:
+                this.point(this._x2, this._y2);
+                break;
+            }
+            (this._line || this._line !== 0 && this._point === 1) && this._context.closePath(), this._line = 1 - this._line;
+          }, point: function(Mt, kr) {
+            if (Mt = +Mt, kr = +kr, this._point) {
+              var Jr = this._x2 - Mt, vi = this._y2 - kr;
+              this._l23_a = Math.sqrt(this._l23_2a = Math.pow(Jr * Jr + vi * vi, this._alpha));
+            }
+            switch (this._point) {
+              case 0:
+                this._point = 1, this._line ? this._context.lineTo(Mt, kr) : this._context.moveTo(Mt, kr);
+                break;
+              case 1:
+                this._point = 2;
+                break;
+              case 2:
+                this._point = 3;
+              default:
+                ir(this, Mt, kr);
+                break;
+            }
+            this._l01_a = this._l12_a, this._l12_a = this._l23_a, this._l01_2a = this._l12_2a, this._l12_2a = this._l23_2a, this._x0 = this._x1, this._x1 = this._x2, this._x2 = Mt, this._y0 = this._y1, this._y1 = this._y2, this._y2 = kr;
+          } };
+          var vr = function Mt(kr) {
+            function Jr(vi) {
+              return kr ? new ar(vi, kr) : new tt(vi, 0);
+            }
+            return Jr.alpha = function(vi) {
+              return Mt(+vi);
+            }, Jr;
+          }(0.5);
+          function ii(Mt, kr) {
+            this._context = Mt, this._alpha = kr;
+          }
+          ii.prototype = { areaStart: er, areaEnd: er, lineStart: function() {
+            this._x0 = this._x1 = this._x2 = this._x3 = this._x4 = this._x5 = this._y0 = this._y1 = this._y2 = this._y3 = this._y4 = this._y5 = NaN, this._l01_a = this._l12_a = this._l23_a = this._l01_2a = this._l12_2a = this._l23_2a = this._point = 0;
+          }, lineEnd: function() {
+            switch (this._point) {
+              case 1: {
+                this._context.moveTo(this._x3, this._y3), this._context.closePath();
+                break;
+              }
+              case 2: {
+                this._context.lineTo(this._x3, this._y3), this._context.closePath();
+                break;
+              }
+              case 3: {
+                this.point(this._x3, this._y3), this.point(this._x4, this._y4), this.point(this._x5, this._y5);
+                break;
+              }
+            }
+          }, point: function(Mt, kr) {
+            if (Mt = +Mt, kr = +kr, this._point) {
+              var Jr = this._x2 - Mt, vi = this._y2 - kr;
+              this._l23_a = Math.sqrt(this._l23_2a = Math.pow(Jr * Jr + vi * vi, this._alpha));
+            }
+            switch (this._point) {
+              case 0:
+                this._point = 1, this._x3 = Mt, this._y3 = kr;
+                break;
+              case 1:
+                this._point = 2, this._context.moveTo(this._x4 = Mt, this._y4 = kr);
+                break;
+              case 2:
+                this._point = 3, this._x5 = Mt, this._y5 = kr;
+                break;
+              default:
+                ir(this, Mt, kr);
+                break;
+            }
+            this._l01_a = this._l12_a, this._l12_a = this._l23_a, this._l01_2a = this._l12_2a, this._l12_2a = this._l23_2a, this._x0 = this._x1, this._x1 = this._x2, this._x2 = Mt, this._y0 = this._y1, this._y1 = this._y2, this._y2 = kr;
+          } };
+          var pi = function Mt(kr) {
+            function Jr(vi) {
+              return kr ? new ii(vi, kr) : new Ie(vi, 0);
+            }
+            return Jr.alpha = function(vi) {
+              return Mt(+vi);
+            }, Jr;
+          }(0.5);
+          function $r(Mt, kr) {
+            this._context = Mt, this._alpha = kr;
+          }
+          $r.prototype = { areaStart: function() {
+            this._line = 0;
+          }, areaEnd: function() {
+            this._line = NaN;
+          }, lineStart: function() {
+            this._x0 = this._x1 = this._x2 = this._y0 = this._y1 = this._y2 = NaN, this._l01_a = this._l12_a = this._l23_a = this._l01_2a = this._l12_2a = this._l23_2a = this._point = 0;
+          }, lineEnd: function() {
+            (this._line || this._line !== 0 && this._point === 3) && this._context.closePath(), this._line = 1 - this._line;
+          }, point: function(Mt, kr) {
+            if (Mt = +Mt, kr = +kr, this._point) {
+              var Jr = this._x2 - Mt, vi = this._y2 - kr;
+              this._l23_a = Math.sqrt(this._l23_2a = Math.pow(Jr * Jr + vi * vi, this._alpha));
+            }
+            switch (this._point) {
+              case 0:
+                this._point = 1;
+                break;
+              case 1:
+                this._point = 2;
+                break;
+              case 2:
+                this._point = 3, this._line ? this._context.lineTo(this._x2, this._y2) : this._context.moveTo(this._x2, this._y2);
+                break;
+              case 3:
+                this._point = 4;
+              default:
+                ir(this, Mt, kr);
+                break;
+            }
+            this._l01_a = this._l12_a, this._l12_a = this._l23_a, this._l01_2a = this._l12_2a, this._l12_2a = this._l23_2a, this._x0 = this._x1, this._x1 = this._x2, this._x2 = Mt, this._y0 = this._y1, this._y1 = this._y2, this._y2 = kr;
+          } };
+          var di = function Mt(kr) {
+            function Jr(vi) {
+              return kr ? new $r(vi, kr) : new ke(vi, 0);
+            }
+            return Jr.alpha = function(vi) {
+              return Mt(+vi);
+            }, Jr;
+          }(0.5);
+          function ji(Mt) {
+            this._context = Mt;
+          }
+          ji.prototype = { areaStart: er, areaEnd: er, lineStart: function() {
+            this._point = 0;
+          }, lineEnd: function() {
+            this._point && this._context.closePath();
+          }, point: function(Mt, kr) {
+            Mt = +Mt, kr = +kr, this._point ? this._context.lineTo(Mt, kr) : (this._point = 1, this._context.moveTo(Mt, kr));
+          } };
+          function In(Mt) {
+            return new ji(Mt);
+          }
+          function wi(Mt) {
+            return Mt < 0 ? -1 : 1;
+          }
+          function On(Mt, kr, Jr) {
+            var vi = Mt._x1 - Mt._x0, hn = kr - Mt._x1, An = (Mt._y1 - Mt._y0) / (vi || hn < 0 && -0), Mn = (Jr - Mt._y1) / (hn || vi < 0 && -0), Li = (An * hn + Mn * vi) / (vi + hn);
+            return (wi(An) + wi(Mn)) * Math.min(Math.abs(An), Math.abs(Mn), 0.5 * Math.abs(Li)) || 0;
+          }
+          function qn(Mt, kr) {
+            var Jr = Mt._x1 - Mt._x0;
+            return Jr ? (3 * (Mt._y1 - Mt._y0) / Jr - kr) / 2 : kr;
+          }
+          function Fn(Mt, kr, Jr) {
+            var vi = Mt._x0, hn = Mt._y0, An = Mt._x1, Mn = Mt._y1, Li = (An - vi) / 3;
+            Mt._context.bezierCurveTo(vi + Li, hn + Li * kr, An - Li, Mn - Li * Jr, An, Mn);
+          }
+          function ra(Mt) {
+            this._context = Mt;
+          }
+          ra.prototype = { areaStart: function() {
+            this._line = 0;
+          }, areaEnd: function() {
+            this._line = NaN;
+          }, lineStart: function() {
+            this._x0 = this._x1 = this._y0 = this._y1 = this._t0 = NaN, this._point = 0;
+          }, lineEnd: function() {
+            switch (this._point) {
+              case 2:
+                this._context.lineTo(this._x1, this._y1);
+                break;
+              case 3:
+                Fn(this, this._t0, qn(this, this._t0));
+                break;
+            }
+            (this._line || this._line !== 0 && this._point === 1) && this._context.closePath(), this._line = 1 - this._line;
+          }, point: function(Mt, kr) {
+            var Jr = NaN;
+            if (Mt = +Mt, kr = +kr, !(Mt === this._x1 && kr === this._y1)) {
+              switch (this._point) {
+                case 0:
+                  this._point = 1, this._line ? this._context.lineTo(Mt, kr) : this._context.moveTo(Mt, kr);
+                  break;
+                case 1:
+                  this._point = 2;
+                  break;
+                case 2:
+                  this._point = 3, Fn(this, qn(this, Jr = On(this, Mt, kr)), Jr);
+                  break;
+                default:
+                  Fn(this, this._t0, Jr = On(this, Mt, kr));
+                  break;
+              }
+              this._x0 = this._x1, this._x1 = Mt, this._y0 = this._y1, this._y1 = kr, this._t0 = Jr;
+            }
+          } };
+          function la(Mt) {
+            this._context = new Ut(Mt);
+          }
+          (la.prototype = Object.create(ra.prototype)).point = function(Mt, kr) {
+            ra.prototype.point.call(this, kr, Mt);
+          };
+          function Ut(Mt) {
+            this._context = Mt;
+          }
+          Ut.prototype = { moveTo: function(Mt, kr) {
+            this._context.moveTo(kr, Mt);
+          }, closePath: function() {
+            this._context.closePath();
+          }, lineTo: function(Mt, kr) {
+            this._context.lineTo(kr, Mt);
+          }, bezierCurveTo: function(Mt, kr, Jr, vi, hn, An) {
+            this._context.bezierCurveTo(kr, Mt, vi, Jr, An, hn);
+          } };
+          function wt(Mt) {
+            return new ra(Mt);
+          }
+          function rr(Mt) {
+            return new la(Mt);
+          }
+          function nr(Mt) {
+            this._context = Mt;
+          }
+          nr.prototype = { areaStart: function() {
+            this._line = 0;
+          }, areaEnd: function() {
+            this._line = NaN;
+          }, lineStart: function() {
+            this._x = [], this._y = [];
+          }, lineEnd: function() {
+            var Mt = this._x, kr = this._y, Jr = Mt.length;
+            if (Jr) if (this._line ? this._context.lineTo(Mt[0], kr[0]) : this._context.moveTo(Mt[0], kr[0]), Jr === 2) this._context.lineTo(Mt[1], kr[1]);
+            else for (var vi = Er(Mt), hn = Er(kr), An = 0, Mn = 1; Mn < Jr; ++An, ++Mn) this._context.bezierCurveTo(vi[0][An], hn[0][An], vi[1][An], hn[1][An], Mt[Mn], kr[Mn]);
+            (this._line || this._line !== 0 && Jr === 1) && this._context.closePath(), this._line = 1 - this._line, this._x = this._y = null;
+          }, point: function(Mt, kr) {
+            this._x.push(+Mt), this._y.push(+kr);
+          } };
+          function Er(Mt) {
+            var kr, Jr = Mt.length - 1, vi, hn = new Array(Jr), An = new Array(Jr), Mn = new Array(Jr);
+            for (hn[0] = 0, An[0] = 2, Mn[0] = Mt[0] + 2 * Mt[1], kr = 1; kr < Jr - 1; ++kr) hn[kr] = 1, An[kr] = 4, Mn[kr] = 4 * Mt[kr] + 2 * Mt[kr + 1];
+            for (hn[Jr - 1] = 2, An[Jr - 1] = 7, Mn[Jr - 1] = 8 * Mt[Jr - 1] + Mt[Jr], kr = 1; kr < Jr; ++kr) vi = hn[kr] / An[kr - 1], An[kr] -= vi, Mn[kr] -= vi * Mn[kr - 1];
+            for (hn[Jr - 1] = Mn[Jr - 1] / An[Jr - 1], kr = Jr - 2; kr >= 0; --kr) hn[kr] = (Mn[kr] - hn[kr + 1]) / An[kr];
+            for (An[Jr - 1] = (Mt[Jr] + hn[Jr - 1]) / 2, kr = 0; kr < Jr - 1; ++kr) An[kr] = 2 * Mt[kr + 1] - hn[kr + 1];
+            return [hn, An];
+          }
+          function Xr(Mt) {
+            return new nr(Mt);
+          }
+          function ri(Mt, kr) {
+            this._context = Mt, this._t = kr;
+          }
+          ri.prototype = { areaStart: function() {
+            this._line = 0;
+          }, areaEnd: function() {
+            this._line = NaN;
+          }, lineStart: function() {
+            this._x = this._y = NaN, this._point = 0;
+          }, lineEnd: function() {
+            0 < this._t && this._t < 1 && this._point === 2 && this._context.lineTo(this._x, this._y), (this._line || this._line !== 0 && this._point === 1) && this._context.closePath(), this._line >= 0 && (this._t = 1 - this._t, this._line = 1 - this._line);
+          }, point: function(Mt, kr) {
+            switch (Mt = +Mt, kr = +kr, this._point) {
+              case 0:
+                this._point = 1, this._line ? this._context.lineTo(Mt, kr) : this._context.moveTo(Mt, kr);
+                break;
+              case 1:
+                this._point = 2;
+              default: {
+                if (this._t <= 0) this._context.lineTo(this._x, kr), this._context.lineTo(Mt, kr);
+                else {
+                  var Jr = this._x * (1 - this._t) + Mt * this._t;
+                  this._context.lineTo(Jr, this._y), this._context.lineTo(Jr, kr);
+                }
+                break;
+              }
+            }
+            this._x = Mt, this._y = kr;
+          } };
+          function Qr(Mt) {
+            return new ri(Mt, 0.5);
+          }
+          function Oi(Mt) {
+            return new ri(Mt, 0);
+          }
+          function $i(Mt) {
+            return new ri(Mt, 1);
+          }
+          function tn(Mt, kr) {
+            if ((Mn = Mt.length) > 1) for (var Jr = 1, vi, hn, An = Mt[kr[0]], Mn, Li = An.length; Jr < Mn; ++Jr) for (hn = An, An = Mt[kr[Jr]], vi = 0; vi < Li; ++vi) An[vi][1] += An[vi][0] = isNaN(hn[vi][1]) ? hn[vi][0] : hn[vi][1];
+          }
+          function fn(Mt) {
+            for (var kr = Mt.length, Jr = new Array(kr); --kr >= 0; ) Jr[kr] = kr;
+            return Jr;
+          }
+          function yn(Mt, kr) {
+            return Mt[kr];
+          }
+          function Sn() {
+            var Mt = r([]), kr = fn, Jr = tn, vi = yn;
+            function hn(An) {
+              var Mn = Mt.apply(this, arguments), Li, _n = An.length, ya = Mn.length, $n = new Array(ya), Ma;
+              for (Li = 0; Li < ya; ++Li) {
+                for (var _o = Mn[Li], No = $n[Li] = new Array(_n), po = 0, Lo; po < _n; ++po) No[po] = Lo = [0, +vi(An[po], _o, po, An)], Lo.data = An[po];
+                No.key = _o;
+              }
+              for (Li = 0, Ma = kr($n); Li < ya; ++Li) $n[Ma[Li]].index = Li;
+              return Jr($n, Ma), $n;
+            }
+            return hn.keys = function(An) {
+              return arguments.length ? (Mt = typeof An == "function" ? An : r(Le.call(An)), hn) : Mt;
+            }, hn.value = function(An) {
+              return arguments.length ? (vi = typeof An == "function" ? An : r(+An), hn) : vi;
+            }, hn.order = function(An) {
+              return arguments.length ? (kr = An == null ? fn : typeof An == "function" ? An : r(Le.call(An)), hn) : kr;
+            }, hn.offset = function(An) {
+              return arguments.length ? (Jr = An == null ? tn : An, hn) : Jr;
+            }, hn;
+          }
+          function Ba(Mt, kr) {
+            if ((vi = Mt.length) > 0) {
+              for (var Jr, vi, hn = 0, An = Mt[0].length, Mn; hn < An; ++hn) {
+                for (Mn = Jr = 0; Jr < vi; ++Jr) Mn += Mt[Jr][hn][1] || 0;
+                if (Mn) for (Jr = 0; Jr < vi; ++Jr) Mt[Jr][hn][1] /= Mn;
+              }
+              tn(Mt, kr);
+            }
+          }
+          function ua(Mt, kr) {
+            if ((_n = Mt.length) > 0) for (var Jr, vi = 0, hn, An, Mn, Li, _n, ya = Mt[kr[0]].length; vi < ya; ++vi) for (Mn = Li = 0, Jr = 0; Jr < _n; ++Jr) (An = (hn = Mt[kr[Jr]][vi])[1] - hn[0]) > 0 ? (hn[0] = Mn, hn[1] = Mn += An) : An < 0 ? (hn[1] = Li, hn[0] = Li += An) : (hn[0] = 0, hn[1] = An);
+          }
+          function ma(Mt, kr) {
+            if ((hn = Mt.length) > 0) {
+              for (var Jr = 0, vi = Mt[kr[0]], hn, An = vi.length; Jr < An; ++Jr) {
+                for (var Mn = 0, Li = 0; Mn < hn; ++Mn) Li += Mt[Mn][Jr][1] || 0;
+                vi[Jr][1] += vi[Jr][0] = -Li / 2;
+              }
+              tn(Mt, kr);
+            }
+          }
+          function Wa(Mt, kr) {
+            if (!(!((Mn = Mt.length) > 0) || !((An = (hn = Mt[kr[0]]).length) > 0))) {
+              for (var Jr = 0, vi = 1, hn, An, Mn; vi < An; ++vi) {
+                for (var Li = 0, _n = 0, ya = 0; Li < Mn; ++Li) {
+                  for (var $n = Mt[kr[Li]], Ma = $n[vi][1] || 0, _o = $n[vi - 1][1] || 0, No = (Ma - _o) / 2, po = 0; po < Li; ++po) {
+                    var Lo = Mt[kr[po]], ko = Lo[vi][1] || 0, Ds = Lo[vi - 1][1] || 0;
+                    No += ko - Ds;
+                  }
+                  _n += Ma, ya += No * Ma;
+                }
+                hn[vi - 1][1] += hn[vi - 1][0] = Jr, _n && (Jr -= ya / _n);
+              }
+              hn[vi - 1][1] += hn[vi - 1][0] = Jr, tn(Mt, kr);
+            }
+          }
+          function Fa(Mt) {
+            var kr = Mt.map(Xo);
+            return fn(Mt).sort(function(Jr, vi) {
+              return kr[Jr] - kr[vi];
+            });
+          }
+          function Xo(Mt) {
+            for (var kr = -1, Jr = 0, vi = Mt.length, hn, An = -1 / 0; ++kr < vi; ) (hn = +Mt[kr][1]) > An && (An = hn, Jr = kr);
+            return Jr;
+          }
+          function da(Mt) {
+            var kr = Mt.map(Wn);
+            return fn(Mt).sort(function(Jr, vi) {
+              return kr[Jr] - kr[vi];
+            });
+          }
+          function Wn(Mt) {
+            for (var kr = 0, Jr = -1, vi = Mt.length, hn; ++Jr < vi; ) (hn = +Mt[Jr][1]) && (kr += hn);
+            return kr;
+          }
+          function Ha(Mt) {
+            return da(Mt).reverse();
+          }
+          function vo(Mt) {
+            var kr = Mt.length, Jr, vi, hn = Mt.map(Wn), An = Fa(Mt), Mn = 0, Li = 0, _n = [], ya = [];
+            for (Jr = 0; Jr < kr; ++Jr) vi = An[Jr], Mn < Li ? (Mn += hn[vi], _n.push(vi)) : (Li += hn[vi], ya.push(vi));
+            return ya.reverse().concat(_n);
+          }
+          function jn(Mt) {
+            return fn(Mt).reverse();
+          }
+          e.arc = C, e.area = O, e.areaRadial = _e, e.curveBasis = Lr, e.curveBasisClosed = Br, e.curveBasisOpen = dt, e.curveBundle = Je, e.curveCardinal = xt, e.curveCardinalClosed = xe, e.curveCardinalOpen = vt, e.curveCatmullRom = vr, e.curveCatmullRomClosed = pi, e.curveCatmullRomOpen = di, e.curveLinear = g, e.curveLinearClosed = In, e.curveMonotoneX = wt, e.curveMonotoneY = rr, e.curveNatural = Xr, e.curveStep = Qr, e.curveStepAfter = $i, e.curveStepBefore = Oi, e.line = z, e.lineRadial = oe, e.linkHorizontal = Pe, e.linkRadial = De, e.linkVertical = me, e.pie = Z, e.pointRadial = Ce, e.radialArea = _e, e.radialLine = oe, e.stack = Sn, e.stackOffsetDiverging = ua, e.stackOffsetExpand = Ba, e.stackOffsetNone = tn, e.stackOffsetSilhouette = ma, e.stackOffsetWiggle = Wa, e.stackOrderAppearance = Fa, e.stackOrderAscending = da, e.stackOrderDescending = Ha, e.stackOrderInsideOut = vo, e.stackOrderNone = fn, e.stackOrderReverse = jn, e.symbol = mt, e.symbolCircle = ce, e.symbolCross = je, e.symbolDiamond = Vt, e.symbolSquare = sr, e.symbolStar = $t, e.symbolTriangle = fr, e.symbolWye = _t, e.symbols = It, Object.defineProperty(e, "__esModule", { value: true });
+        });
+      });
+      var YWe = ye((C7, ZWe) => {
+        (function(e, t) {
+          typeof C7 == "object" && typeof ZWe != "undefined" ? t(C7, hk(), T7(), $J()) : t(e.d3 = e.d3 || {}, e.d3, e.d3, e.d3);
+        })(C7, function(e, t, r, n) {
+          function i(g) {
+            return g.target.depth;
+          }
+          function a(g) {
+            return g.depth;
+          }
+          function o(g, P) {
+            return P - 1 - g.height;
+          }
+          function s(g, P) {
+            return g.sourceLinks.length ? g.depth : P - 1;
+          }
+          function l(g) {
+            return g.targetLinks.length ? g.depth : g.sourceLinks.length ? t.min(g.sourceLinks, i) - 1 : 0;
+          }
+          function u(g) {
+            return function() {
+              return g;
+            };
+          }
+          function c(g, P) {
+            return h(g.source, P.source) || g.index - P.index;
+          }
+          function f(g, P) {
+            return h(g.target, P.target) || g.index - P.index;
+          }
+          function h(g, P) {
+            return g.y0 - P.y0;
+          }
+          function d(g) {
+            return g.value;
+          }
+          function v(g) {
+            return (g.y0 + g.y1) / 2;
+          }
+          function _(g) {
+            return v(g.source) * g.value;
+          }
+          function b(g) {
+            return v(g.target) * g.value;
+          }
+          function p(g) {
+            return g.index;
+          }
+          function k(g) {
+            return g.nodes;
+          }
+          function E(g) {
+            return g.links;
+          }
+          function T(g, P) {
+            var A = g.get(P);
+            if (!A) throw new Error("missing: " + P);
+            return A;
+          }
+          var L = function() {
+            var g = 0, P = 0, A = 1, z = 1, O = 24, U = 8, G = p, Z = s, j = k, N = E, H = 32, re = 2 / 3;
+            function oe() {
+              var Se = { nodes: j.apply(null, arguments), links: N.apply(null, arguments) };
+              return _e(Se), Ce(Se), Le(Se), ge(Se), ie(Se), Se;
+            }
+            oe.update = function(Se) {
+              return ie(Se), Se;
+            }, oe.nodeId = function(Se) {
+              return arguments.length ? (G = typeof Se == "function" ? Se : u(Se), oe) : G;
+            }, oe.nodeAlign = function(Se) {
+              return arguments.length ? (Z = typeof Se == "function" ? Se : u(Se), oe) : Z;
+            }, oe.nodeWidth = function(Se) {
+              return arguments.length ? (O = +Se, oe) : O;
+            }, oe.nodePadding = function(Se) {
+              return arguments.length ? (U = +Se, oe) : U;
+            }, oe.nodes = function(Se) {
+              return arguments.length ? (j = typeof Se == "function" ? Se : u(Se), oe) : j;
+            }, oe.links = function(Se) {
+              return arguments.length ? (N = typeof Se == "function" ? Se : u(Se), oe) : N;
+            }, oe.size = function(Se) {
+              return arguments.length ? (g = P = 0, A = +Se[0], z = +Se[1], oe) : [A - g, z - P];
+            }, oe.extent = function(Se) {
+              return arguments.length ? (g = +Se[0][0], A = +Se[1][0], P = +Se[0][1], z = +Se[1][1], oe) : [[g, P], [A, z]];
+            }, oe.iterations = function(Se) {
+              return arguments.length ? (H = +Se, oe) : H;
+            };
+            function _e(Se) {
+              Se.nodes.forEach(function(Ae, Be) {
+                Ae.index = Be, Ae.sourceLinks = [], Ae.targetLinks = [];
+              });
+              var Ee = r.map(Se.nodes, G);
+              Se.links.forEach(function(Ae, Be) {
+                Ae.index = Be;
+                var Pe = Ae.source, me = Ae.target;
+                typeof Pe != "object" && (Pe = Ae.source = T(Ee, Pe)), typeof me != "object" && (me = Ae.target = T(Ee, me)), Pe.sourceLinks.push(Ae), me.targetLinks.push(Ae);
+              });
+            }
+            function Ce(Se) {
+              Se.nodes.forEach(function(Ee) {
+                Ee.value = Math.max(t.sum(Ee.sourceLinks, d), t.sum(Ee.targetLinks, d));
+              });
+            }
+            function Le(Se) {
+              var Ee, Ae, Be;
+              for (Ee = Se.nodes, Ae = [], Be = 0; Ee.length; ++Be, Ee = Ae, Ae = []) Ee.forEach(function(me) {
+                me.depth = Be, me.sourceLinks.forEach(function(De) {
+                  Ae.indexOf(De.target) < 0 && Ae.push(De.target);
+                });
+              });
+              for (Ee = Se.nodes, Ae = [], Be = 0; Ee.length; ++Be, Ee = Ae, Ae = []) Ee.forEach(function(me) {
+                me.height = Be, me.targetLinks.forEach(function(De) {
+                  Ae.indexOf(De.source) < 0 && Ae.push(De.source);
+                });
+              });
+              var Pe = (A - g - O) / (Be - 1);
+              Se.nodes.forEach(function(me) {
+                me.x1 = (me.x0 = g + Math.max(0, Math.min(Be - 1, Math.floor(Z.call(null, me, Be)))) * Pe) + O;
+              });
+            }
+            function ge(Se) {
+              var Ee = r.nest().key(function(je) {
+                return je.x0;
+              }).sortKeys(t.ascending).entries(Se.nodes).map(function(je) {
+                return je.values;
+              });
+              Pe(), ce();
+              for (var Ae = 1, Be = H; Be > 0; --Be) De(Ae *= 0.99), ce(), me(Ae), ce();
+              function Pe() {
+                var je = t.max(Ee, function(Vt) {
+                  return Vt.length;
+                }), lt = re * (z - P) / (je - 1);
+                U > lt && (U = lt);
+                var pt = t.min(Ee, function(Vt) {
+                  return (z - P - (Vt.length - 1) * U) / t.sum(Vt, d);
+                });
+                Ee.forEach(function(Vt) {
+                  Vt.forEach(function(ot, ut) {
+                    ot.y1 = (ot.y0 = ut) + ot.value * pt;
+                  });
+                }), Se.links.forEach(function(Vt) {
+                  Vt.width = Vt.value * pt;
+                });
+              }
+              function me(je) {
+                Ee.forEach(function(lt) {
+                  lt.forEach(function(pt) {
+                    if (pt.targetLinks.length) {
+                      var Vt = (t.sum(pt.targetLinks, _) / t.sum(pt.targetLinks, d) - v(pt)) * je;
+                      pt.y0 += Vt, pt.y1 += Vt;
+                    }
+                  });
+                });
+              }
+              function De(je) {
+                Ee.slice().reverse().forEach(function(lt) {
+                  lt.forEach(function(pt) {
+                    if (pt.sourceLinks.length) {
+                      var Vt = (t.sum(pt.sourceLinks, b) / t.sum(pt.sourceLinks, d) - v(pt)) * je;
+                      pt.y0 += Vt, pt.y1 += Vt;
+                    }
+                  });
+                });
+              }
+              function ce() {
+                Ee.forEach(function(je) {
+                  var lt, pt, Vt = P, ot = je.length, ut;
+                  for (je.sort(h), ut = 0; ut < ot; ++ut) lt = je[ut], pt = Vt - lt.y0, pt > 0 && (lt.y0 += pt, lt.y1 += pt), Vt = lt.y1 + U;
+                  if (pt = Vt - U - z, pt > 0) for (Vt = lt.y0 -= pt, lt.y1 -= pt, ut = ot - 2; ut >= 0; --ut) lt = je[ut], pt = lt.y1 + U - Vt, pt > 0 && (lt.y0 -= pt, lt.y1 -= pt), Vt = lt.y0;
+                });
+              }
+            }
+            function ie(Se) {
+              Se.nodes.forEach(function(Ee) {
+                Ee.sourceLinks.sort(f), Ee.targetLinks.sort(c);
+              }), Se.nodes.forEach(function(Ee) {
+                var Ae = Ee.y0, Be = Ae;
+                Ee.sourceLinks.forEach(function(Pe) {
+                  Pe.y0 = Ae + Pe.width / 2, Ae += Pe.width;
+                }), Ee.targetLinks.forEach(function(Pe) {
+                  Pe.y1 = Be + Pe.width / 2, Be += Pe.width;
+                });
+              });
+            }
+            return oe;
+          };
+          function x(g) {
+            return [g.source.x1, g.y0];
+          }
+          function C(g) {
+            return [g.target.x0, g.y1];
+          }
+          var M = function() {
+            return n.linkHorizontal().source(x).target(C);
+          };
+          e.sankey = L, e.sankeyCenter = l, e.sankeyLeft = a, e.sankeyRight = o, e.sankeyJustify = s, e.sankeyLinkHorizontal = M, Object.defineProperty(e, "__esModule", { value: true });
+        });
+      });
+      var JWe = ye((f2r, KWe) => {
+        var WZt = JJ();
+        KWe.exports = function(t, r) {
+          var n = [], i = [], a = [], o = {}, s = [], l;
+          function u(E) {
+            a[E] = false, o.hasOwnProperty(E) && Object.keys(o[E]).forEach(function(T) {
+              delete o[E][T], a[T] && u(T);
+            });
+          }
+          function c(E) {
+            var T = false;
+            i.push(E), a[E] = true;
+            var L, x;
+            for (L = 0; L < s[E].length; L++) x = s[E][L], x === l ? (f(l, i), T = true) : a[x] || (T = c(x));
+            if (T) u(E);
+            else for (L = 0; L < s[E].length; L++) {
+              x = s[E][L];
+              var C = o[x];
+              C || (C = {}, o[x] = C), C[x] = true;
+            }
+            return i.pop(), T;
+          }
+          function f(E, T) {
+            var L = [].concat(T).concat(E);
+            r ? r(c) : n.push(L);
+          }
+          function h(E) {
+            for (var T = 0; T < t.length; T++) T < E && (t[T] = []), t[T] = t[T].filter(function(L) {
+              return L >= E;
+            });
+          }
+          function d(E) {
+            h(E);
+            for (var T = t, L = WZt(T), x = L.components.filter(function(O) {
+              return O.length > 1;
+            }), C = 1 / 0, M, g = 0; g < x.length; g++) for (var P = 0; P < x[g].length; P++) x[g][P] < C && (C = x[g][P], M = g);
+            var A = x[M];
+            if (!A) return false;
+            var z = t.map(function(O, U) {
+              return A.indexOf(U) === -1 ? [] : O.filter(function(G) {
+                return A.indexOf(G) !== -1;
+              });
+            });
+            return { leastVertex: C, adjList: z };
+          }
+          l = 0;
+          for (var v = t.length; l < v; ) {
+            var _ = d(l);
+            if (l = _.leastVertex, s = _.adjList, s) {
+              for (var b = 0; b < s.length; b++) for (var p = 0; p < s[b].length; p++) {
+                var k = s[b][p];
+                a[+k] = false, o[k] = {};
+              }
+              c(l), l = l + 1;
+            } else l = v;
+          }
+          if (!r) return n;
+        };
+      });
+      var QWe = ye((L7, $We) => {
+        (function(e, t) {
+          typeof L7 == "object" && typeof $We != "undefined" ? t(L7, hk(), T7(), $J(), JWe()) : t(e.d3 = e.d3 || {}, e.d3, e.d3, e.d3, null);
+        })(L7, function(e, t, r, n, i) {
+          i = i && i.hasOwnProperty("default") ? i.default : i;
+          function a(ot) {
+            return ot.target.depth;
+          }
+          function o(ot) {
+            return ot.depth;
+          }
+          function s(ot, ut) {
+            return ut - 1 - ot.height;
+          }
+          function l(ot, ut) {
+            return ot.sourceLinks.length ? ot.depth : ut - 1;
+          }
+          function u(ot) {
+            return ot.targetLinks.length ? ot.depth : ot.sourceLinks.length ? t.min(ot.sourceLinks, a) - 1 : 0;
+          }
+          function c(ot) {
+            return function() {
+              return ot;
+            };
+          }
+          var f = typeof Symbol == "function" && typeof Symbol.iterator == "symbol" ? function(ot) {
+            return typeof ot;
+          } : function(ot) {
+            return ot && typeof Symbol == "function" && ot.constructor === Symbol && ot !== Symbol.prototype ? "symbol" : typeof ot;
+          };
+          function h(ot, ut) {
+            return v(ot.source, ut.source) || ot.index - ut.index;
+          }
+          function d(ot, ut) {
+            return v(ot.target, ut.target) || ot.index - ut.index;
+          }
+          function v(ot, ut) {
+            return ot.partOfCycle === ut.partOfCycle ? ot.y0 - ut.y0 : ot.circularLinkType === "top" || ut.circularLinkType === "bottom" ? -1 : 1;
+          }
+          function _(ot) {
+            return ot.value;
+          }
+          function b(ot) {
+            return (ot.y0 + ot.y1) / 2;
+          }
+          function p(ot) {
+            return b(ot.source);
+          }
+          function k(ot) {
+            return b(ot.target);
+          }
+          function E(ot) {
+            return ot.index;
+          }
+          function T(ot) {
+            return ot.nodes;
+          }
+          function L(ot) {
+            return ot.links;
+          }
+          function x(ot, ut) {
+            var Wt = ot.get(ut);
+            if (!Wt) throw new Error("missing: " + ut);
+            return Wt;
+          }
+          function C(ot, ut) {
+            return ut(ot);
+          }
+          var M = 25, g = 10, P = 0.3;
+          function A() {
+            var ot = 0, ut = 0, Wt = 1, Nt = 1, $t = 24, sr, Tr = E, fr = l, $e = T, St = L, Qt = 32, Gt = 2, _t, It = null;
+            function mt() {
+              var dt = { nodes: $e.apply(null, arguments), links: St.apply(null, arguments) };
+              er(dt), z(dt, Tr, It), lr(dt), ti(dt), O(dt, Tr), Br(dt, Qt, Tr), Vr(dt);
+              for (var Ge = 4, Je = 0; Je < Ge; Je++) De(dt, Nt, Tr), ce(dt, Nt, Tr), Be(dt, ut, Nt, Tr), De(dt, Nt, Tr), ce(dt, Nt, Tr);
+              return Vt(dt, ut, Nt), H(dt, Gt, Nt, Tr), dt;
+            }
+            mt.nodeId = function(dt) {
+              return arguments.length ? (Tr = typeof dt == "function" ? dt : c(dt), mt) : Tr;
+            }, mt.nodeAlign = function(dt) {
+              return arguments.length ? (fr = typeof dt == "function" ? dt : c(dt), mt) : fr;
+            }, mt.nodeWidth = function(dt) {
+              return arguments.length ? ($t = +dt, mt) : $t;
+            }, mt.nodePadding = function(dt) {
+              return arguments.length ? (sr = +dt, mt) : sr;
+            }, mt.nodes = function(dt) {
+              return arguments.length ? ($e = typeof dt == "function" ? dt : c(dt), mt) : $e;
+            }, mt.links = function(dt) {
+              return arguments.length ? (St = typeof dt == "function" ? dt : c(dt), mt) : St;
+            }, mt.size = function(dt) {
+              return arguments.length ? (ot = ut = 0, Wt = +dt[0], Nt = +dt[1], mt) : [Wt - ot, Nt - ut];
+            }, mt.extent = function(dt) {
+              return arguments.length ? (ot = +dt[0][0], Wt = +dt[1][0], ut = +dt[0][1], Nt = +dt[1][1], mt) : [[ot, ut], [Wt, Nt]];
+            }, mt.iterations = function(dt) {
+              return arguments.length ? (Qt = +dt, mt) : Qt;
+            }, mt.circularLinkGap = function(dt) {
+              return arguments.length ? (Gt = +dt, mt) : Gt;
+            }, mt.nodePaddingRatio = function(dt) {
+              return arguments.length ? (_t = +dt, mt) : _t;
+            }, mt.sortNodes = function(dt) {
+              return arguments.length ? (It = dt, mt) : It;
+            }, mt.update = function(dt) {
+              return O(dt, Tr), Vr(dt), dt.links.forEach(function(Ge) {
+                Ge.circular && (Ge.circularLinkType = Ge.y0 + Ge.y1 < Nt ? "top" : "bottom", Ge.source.circularLinkType = Ge.circularLinkType, Ge.target.circularLinkType = Ge.circularLinkType);
+              }), De(dt, Nt, Tr, false), ce(dt, Nt, Tr), H(dt, Gt, Nt, Tr), dt;
+            };
+            function er(dt) {
+              dt.nodes.forEach(function(Je, We) {
+                Je.index = We, Je.sourceLinks = [], Je.targetLinks = [];
+              });
+              var Ge = r.map(dt.nodes, Tr);
+              return dt.links.forEach(function(Je, We) {
+                Je.index = We;
+                var tt = Je.source, xt = Je.target;
+                (typeof tt == "undefined" ? "undefined" : f(tt)) !== "object" && (tt = Je.source = x(Ge, tt)), (typeof xt == "undefined" ? "undefined" : f(xt)) !== "object" && (xt = Je.target = x(Ge, xt)), tt.sourceLinks.push(Je), xt.targetLinks.push(Je);
+              }), dt;
+            }
+            function lr(dt) {
+              dt.nodes.forEach(function(Ge) {
+                Ge.partOfCycle = false, Ge.value = Math.max(t.sum(Ge.sourceLinks, _), t.sum(Ge.targetLinks, _)), Ge.sourceLinks.forEach(function(Je) {
+                  Je.circular && (Ge.partOfCycle = true, Ge.circularLinkType = Je.circularLinkType);
+                }), Ge.targetLinks.forEach(function(Je) {
+                  Je.circular && (Ge.partOfCycle = true, Ge.circularLinkType = Je.circularLinkType);
+                });
+              });
+            }
+            function wr(dt) {
+              var Ge = 0, Je = 0, We = 0, tt = 0, xt = t.max(dt.nodes, function(Ie) {
+                return Ie.column;
+              });
+              return dt.links.forEach(function(Ie) {
+                Ie.circular && (Ie.circularLinkType == "top" ? Ge = Ge + Ie.width : Je = Je + Ie.width, Ie.target.column == 0 && (tt = tt + Ie.width), Ie.source.column == xt && (We = We + Ie.width));
+              }), Ge = Ge > 0 ? Ge + M + g : Ge, Je = Je > 0 ? Je + M + g : Je, We = We > 0 ? We + M + g : We, tt = tt > 0 ? tt + M + g : tt, { top: Ge, bottom: Je, left: tt, right: We };
+            }
+            function Lr(dt, Ge) {
+              var Je = t.max(dt.nodes, function(vt) {
+                return vt.column;
+              }), We = Wt - ot, tt = Nt - ut, xt = We + Ge.right + Ge.left, Ie = tt + Ge.top + Ge.bottom, xe = We / xt, ke = tt / Ie;
+              return ot = ot * xe + Ge.left, Wt = Ge.right == 0 ? Wt : Wt * xe, ut = ut * ke + Ge.top, Nt = Nt * ke, dt.nodes.forEach(function(vt) {
+                vt.x0 = ot + vt.column * ((Wt - ot - $t) / Je), vt.x1 = vt.x0 + $t;
+              }), ke;
+            }
+            function ti(dt) {
+              var Ge, Je, We;
+              for (Ge = dt.nodes, Je = [], We = 0; Ge.length; ++We, Ge = Je, Je = []) Ge.forEach(function(tt) {
+                tt.depth = We, tt.sourceLinks.forEach(function(xt) {
+                  Je.indexOf(xt.target) < 0 && !xt.circular && Je.push(xt.target);
+                });
+              });
+              for (Ge = dt.nodes, Je = [], We = 0; Ge.length; ++We, Ge = Je, Je = []) Ge.forEach(function(tt) {
+                tt.height = We, tt.targetLinks.forEach(function(xt) {
+                  Je.indexOf(xt.source) < 0 && !xt.circular && Je.push(xt.source);
+                });
+              });
+              dt.nodes.forEach(function(tt) {
+                tt.column = Math.floor(fr.call(null, tt, We));
+              });
+            }
+            function Br(dt, Ge, Je) {
+              var We = r.nest().key(function(vt) {
+                return vt.column;
+              }).sortKeys(t.ascending).entries(dt.nodes).map(function(vt) {
+                return vt.values;
+              });
+              Ie(Je), ke();
+              for (var tt = 1, xt = Ge; xt > 0; --xt) xe(tt *= 0.99, Je), ke();
+              function Ie(vt) {
+                if (_t) {
+                  var ir = 1 / 0;
+                  We.forEach(function(pi) {
+                    var $r = Nt * _t / (pi.length + 1);
+                    ir = $r < ir ? $r : ir;
+                  }), sr = ir;
+                }
+                var ar = t.min(We, function(pi) {
+                  return (Nt - ut - (pi.length - 1) * sr) / t.sum(pi, _);
+                });
+                ar = ar * P, dt.links.forEach(function(pi) {
+                  pi.width = pi.value * ar;
+                });
+                var vr = wr(dt), ii = Lr(dt, vr);
+                ar = ar * ii, dt.links.forEach(function(pi) {
+                  pi.width = pi.value * ar;
+                }), We.forEach(function(pi) {
+                  var $r = pi.length;
+                  pi.forEach(function(di, ji) {
+                    di.depth == We.length - 1 && $r == 1 || di.depth == 0 && $r == 1 ? (di.y0 = Nt / 2 - di.value * ar, di.y1 = di.y0 + di.value * ar) : di.partOfCycle ? Z(di, vt) == 0 ? (di.y0 = Nt / 2 + ji, di.y1 = di.y0 + di.value * ar) : di.circularLinkType == "top" ? (di.y0 = ut + ji, di.y1 = di.y0 + di.value * ar) : (di.y0 = Nt - di.value * ar - ji, di.y1 = di.y0 + di.value * ar) : vr.top == 0 || vr.bottom == 0 ? (di.y0 = (Nt - ut) / $r * ji, di.y1 = di.y0 + di.value * ar) : (di.y0 = (Nt - ut) / 2 - $r / 2 + ji, di.y1 = di.y0 + di.value * ar);
+                  });
+                });
+              }
+              function xe(vt, ir) {
+                var ar = We.length;
+                We.forEach(function(vr) {
+                  var ii = vr.length, pi = vr[0].depth;
+                  vr.forEach(function($r) {
+                    var di;
+                    if (($r.sourceLinks.length || $r.targetLinks.length) && !($r.partOfCycle && Z($r, ir) > 0)) if (pi == 0 && ii == 1) di = $r.y1 - $r.y0, $r.y0 = Nt / 2 - di / 2, $r.y1 = Nt / 2 + di / 2;
+                    else if (pi == ar - 1 && ii == 1) di = $r.y1 - $r.y0, $r.y0 = Nt / 2 - di / 2, $r.y1 = Nt / 2 + di / 2;
+                    else {
+                      var ji = 0, In = t.mean($r.sourceLinks, k), wi = t.mean($r.targetLinks, p);
+                      In && wi ? ji = (In + wi) / 2 : ji = In || wi;
+                      var On = (ji - b($r)) * vt;
+                      $r.y0 += On, $r.y1 += On;
+                    }
+                  });
+                });
+              }
+              function ke() {
+                We.forEach(function(vt) {
+                  var ir, ar, vr = ut, ii = vt.length, pi;
+                  for (vt.sort(v), pi = 0; pi < ii; ++pi) ir = vt[pi], ar = vr - ir.y0, ar > 0 && (ir.y0 += ar, ir.y1 += ar), vr = ir.y1 + sr;
+                  if (ar = vr - sr - Nt, ar > 0) for (vr = ir.y0 -= ar, ir.y1 -= ar, pi = ii - 2; pi >= 0; --pi) ir = vt[pi], ar = ir.y1 + sr - vr, ar > 0 && (ir.y0 -= ar, ir.y1 -= ar), vr = ir.y0;
+                });
+              }
+            }
+            function Vr(dt) {
+              dt.nodes.forEach(function(Ge) {
+                Ge.sourceLinks.sort(d), Ge.targetLinks.sort(h);
+              }), dt.nodes.forEach(function(Ge) {
+                var Je = Ge.y0, We = Je, tt = Ge.y1, xt = tt;
+                Ge.sourceLinks.forEach(function(Ie) {
+                  Ie.circular ? (Ie.y0 = tt - Ie.width / 2, tt = tt - Ie.width) : (Ie.y0 = Je + Ie.width / 2, Je += Ie.width);
+                }), Ge.targetLinks.forEach(function(Ie) {
+                  Ie.circular ? (Ie.y1 = xt - Ie.width / 2, xt = xt - Ie.width) : (Ie.y1 = We + Ie.width / 2, We += Ie.width);
+                });
+              });
+            }
+            return mt;
+          }
+          function z(ot, ut, Wt) {
+            var Nt = 0;
+            if (Wt === null) {
+              for (var $t = [], sr = 0; sr < ot.links.length; sr++) {
+                var Tr = ot.links[sr], fr = Tr.source.index, $e = Tr.target.index;
+                $t[fr] || ($t[fr] = []), $t[$e] || ($t[$e] = []), $t[fr].indexOf($e) === -1 && $t[fr].push($e);
+              }
+              var St = i($t);
+              St.sort(function(It, mt) {
+                return It.length - mt.length;
+              });
+              var Qt = {};
+              for (sr = 0; sr < St.length; sr++) {
+                var Gt = St[sr], _t = Gt.slice(-2);
+                Qt[_t[0]] || (Qt[_t[0]] = {}), Qt[_t[0]][_t[1]] = true;
+              }
+              ot.links.forEach(function(It) {
+                var mt = It.target.index, er = It.source.index;
+                mt === er || Qt[er] && Qt[er][mt] ? (It.circular = true, It.circularLinkID = Nt, Nt = Nt + 1) : It.circular = false;
+              });
+            } else ot.links.forEach(function(It) {
+              It.source[Wt] < It.target[Wt] ? It.circular = false : (It.circular = true, It.circularLinkID = Nt, Nt = Nt + 1);
+            });
+          }
+          function O(ot, ut) {
+            var Wt = 0, Nt = 0;
+            ot.links.forEach(function($t) {
+              $t.circular && ($t.source.circularLinkType || $t.target.circularLinkType ? $t.circularLinkType = $t.source.circularLinkType ? $t.source.circularLinkType : $t.target.circularLinkType : $t.circularLinkType = Wt < Nt ? "top" : "bottom", $t.circularLinkType == "top" ? Wt = Wt + 1 : Nt = Nt + 1, ot.nodes.forEach(function(sr) {
+                (C(sr, ut) == C($t.source, ut) || C(sr, ut) == C($t.target, ut)) && (sr.circularLinkType = $t.circularLinkType);
+              }));
+            }), ot.links.forEach(function($t) {
+              $t.circular && ($t.source.circularLinkType == $t.target.circularLinkType && ($t.circularLinkType = $t.source.circularLinkType), pt($t, ut) && ($t.circularLinkType = $t.source.circularLinkType));
+            });
+          }
+          function U(ot) {
+            var ut = Math.abs(ot.y1 - ot.y0), Wt = Math.abs(ot.target.x0 - ot.source.x1);
+            return Math.atan(Wt / ut);
+          }
+          function G(ot, ut) {
+            return ot.source.column < ut.target.column ? false : !(ot.target.column > ut.source.column);
+          }
+          function Z(ot, ut) {
+            var Wt = 0;
+            ot.sourceLinks.forEach(function($t) {
+              Wt = $t.circular && !pt($t, ut) ? Wt + 1 : Wt;
+            });
+            var Nt = 0;
+            return ot.targetLinks.forEach(function($t) {
+              Nt = $t.circular && !pt($t, ut) ? Nt + 1 : Nt;
+            }), Wt + Nt;
+          }
+          function j(ot) {
+            var ut = ot.source.sourceLinks, Wt = 0;
+            ut.forEach(function(sr) {
+              Wt = sr.circular ? Wt + 1 : Wt;
+            });
+            var Nt = ot.target.targetLinks, $t = 0;
+            return Nt.forEach(function(sr) {
+              $t = sr.circular ? $t + 1 : $t;
+            }), !(Wt > 1 || $t > 1);
+          }
+          function N(ot, ut, Wt) {
+            return ot.sort(oe), ot.forEach(function(Nt, $t) {
+              var sr = 0;
+              if (pt(Nt, Wt) && j(Nt)) Nt.circularPathData.verticalBuffer = sr + Nt.width / 2;
+              else {
+                var Tr = 0;
+                for (Tr; Tr < $t; Tr++) if (G(ot[$t], ot[Tr])) {
+                  var fr = ot[Tr].circularPathData.verticalBuffer + ot[Tr].width / 2 + ut;
+                  sr = fr > sr ? fr : sr;
+                }
+                Nt.circularPathData.verticalBuffer = sr + Nt.width / 2;
+              }
+            }), ot;
+          }
+          function H(ot, ut, Wt, Nt) {
+            var $t = 5, sr = t.min(ot.links, function($e) {
+              return $e.source.y0;
+            });
+            ot.links.forEach(function($e) {
+              $e.circular && ($e.circularPathData = {});
+            });
+            var Tr = ot.links.filter(function($e) {
+              return $e.circularLinkType == "top";
+            });
+            N(Tr, ut, Nt);
+            var fr = ot.links.filter(function($e) {
+              return $e.circularLinkType == "bottom";
+            });
+            N(fr, ut, Nt), ot.links.forEach(function($e) {
+              if ($e.circular) {
+                if ($e.circularPathData.arcRadius = $e.width + g, $e.circularPathData.leftNodeBuffer = $t, $e.circularPathData.rightNodeBuffer = $t, $e.circularPathData.sourceWidth = $e.source.x1 - $e.source.x0, $e.circularPathData.sourceX = $e.source.x0 + $e.circularPathData.sourceWidth, $e.circularPathData.targetX = $e.target.x0, $e.circularPathData.sourceY = $e.y0, $e.circularPathData.targetY = $e.y1, pt($e, Nt) && j($e)) $e.circularPathData.leftSmallArcRadius = g + $e.width / 2, $e.circularPathData.leftLargeArcRadius = g + $e.width / 2, $e.circularPathData.rightSmallArcRadius = g + $e.width / 2, $e.circularPathData.rightLargeArcRadius = g + $e.width / 2, $e.circularLinkType == "bottom" ? ($e.circularPathData.verticalFullExtent = $e.source.y1 + M + $e.circularPathData.verticalBuffer, $e.circularPathData.verticalLeftInnerExtent = $e.circularPathData.verticalFullExtent - $e.circularPathData.leftLargeArcRadius, $e.circularPathData.verticalRightInnerExtent = $e.circularPathData.verticalFullExtent - $e.circularPathData.rightLargeArcRadius) : ($e.circularPathData.verticalFullExtent = $e.source.y0 - M - $e.circularPathData.verticalBuffer, $e.circularPathData.verticalLeftInnerExtent = $e.circularPathData.verticalFullExtent + $e.circularPathData.leftLargeArcRadius, $e.circularPathData.verticalRightInnerExtent = $e.circularPathData.verticalFullExtent + $e.circularPathData.rightLargeArcRadius);
+                else {
+                  var St = $e.source.column, Qt = $e.circularLinkType, Gt = ot.links.filter(function(mt) {
+                    return mt.source.column == St && mt.circularLinkType == Qt;
+                  });
+                  $e.circularLinkType == "bottom" ? Gt.sort(Ce) : Gt.sort(_e);
+                  var _t = 0;
+                  Gt.forEach(function(mt, er) {
+                    mt.circularLinkID == $e.circularLinkID && ($e.circularPathData.leftSmallArcRadius = g + $e.width / 2 + _t, $e.circularPathData.leftLargeArcRadius = g + $e.width / 2 + er * ut + _t), _t = _t + mt.width;
+                  }), St = $e.target.column, Gt = ot.links.filter(function(mt) {
+                    return mt.target.column == St && mt.circularLinkType == Qt;
+                  }), $e.circularLinkType == "bottom" ? Gt.sort(ge) : Gt.sort(Le), _t = 0, Gt.forEach(function(mt, er) {
+                    mt.circularLinkID == $e.circularLinkID && ($e.circularPathData.rightSmallArcRadius = g + $e.width / 2 + _t, $e.circularPathData.rightLargeArcRadius = g + $e.width / 2 + er * ut + _t), _t = _t + mt.width;
+                  }), $e.circularLinkType == "bottom" ? ($e.circularPathData.verticalFullExtent = Math.max(Wt, $e.source.y1, $e.target.y1) + M + $e.circularPathData.verticalBuffer, $e.circularPathData.verticalLeftInnerExtent = $e.circularPathData.verticalFullExtent - $e.circularPathData.leftLargeArcRadius, $e.circularPathData.verticalRightInnerExtent = $e.circularPathData.verticalFullExtent - $e.circularPathData.rightLargeArcRadius) : ($e.circularPathData.verticalFullExtent = sr - M - $e.circularPathData.verticalBuffer, $e.circularPathData.verticalLeftInnerExtent = $e.circularPathData.verticalFullExtent + $e.circularPathData.leftLargeArcRadius, $e.circularPathData.verticalRightInnerExtent = $e.circularPathData.verticalFullExtent + $e.circularPathData.rightLargeArcRadius);
+                }
+                $e.circularPathData.leftInnerExtent = $e.circularPathData.sourceX + $e.circularPathData.leftNodeBuffer, $e.circularPathData.rightInnerExtent = $e.circularPathData.targetX - $e.circularPathData.rightNodeBuffer, $e.circularPathData.leftFullExtent = $e.circularPathData.sourceX + $e.circularPathData.leftLargeArcRadius + $e.circularPathData.leftNodeBuffer, $e.circularPathData.rightFullExtent = $e.circularPathData.targetX - $e.circularPathData.rightLargeArcRadius - $e.circularPathData.rightNodeBuffer;
+              }
+              if ($e.circular) $e.path = re($e);
+              else {
+                var It = n.linkHorizontal().source(function(mt) {
+                  var er = mt.source.x0 + (mt.source.x1 - mt.source.x0), lr = mt.y0;
+                  return [er, lr];
+                }).target(function(mt) {
+                  var er = mt.target.x0, lr = mt.y1;
+                  return [er, lr];
+                });
+                $e.path = It($e);
+              }
+            });
+          }
+          function re(ot) {
+            var ut = "";
+            return ot.circularLinkType == "top" ? ut = "M" + ot.circularPathData.sourceX + " " + ot.circularPathData.sourceY + " L" + ot.circularPathData.leftInnerExtent + " " + ot.circularPathData.sourceY + " A" + ot.circularPathData.leftLargeArcRadius + " " + ot.circularPathData.leftSmallArcRadius + " 0 0 0 " + ot.circularPathData.leftFullExtent + " " + (ot.circularPathData.sourceY - ot.circularPathData.leftSmallArcRadius) + " L" + ot.circularPathData.leftFullExtent + " " + ot.circularPathData.verticalLeftInnerExtent + " A" + ot.circularPathData.leftLargeArcRadius + " " + ot.circularPathData.leftLargeArcRadius + " 0 0 0 " + ot.circularPathData.leftInnerExtent + " " + ot.circularPathData.verticalFullExtent + " L" + ot.circularPathData.rightInnerExtent + " " + ot.circularPathData.verticalFullExtent + " A" + ot.circularPathData.rightLargeArcRadius + " " + ot.circularPathData.rightLargeArcRadius + " 0 0 0 " + ot.circularPathData.rightFullExtent + " " + ot.circularPathData.verticalRightInnerExtent + " L" + ot.circularPathData.rightFullExtent + " " + (ot.circularPathData.targetY - ot.circularPathData.rightSmallArcRadius) + " A" + ot.circularPathData.rightLargeArcRadius + " " + ot.circularPathData.rightSmallArcRadius + " 0 0 0 " + ot.circularPathData.rightInnerExtent + " " + ot.circularPathData.targetY + " L" + ot.circularPathData.targetX + " " + ot.circularPathData.targetY : ut = "M" + ot.circularPathData.sourceX + " " + ot.circularPathData.sourceY + " L" + ot.circularPathData.leftInnerExtent + " " + ot.circularPathData.sourceY + " A" + ot.circularPathData.leftLargeArcRadius + " " + ot.circularPathData.leftSmallArcRadius + " 0 0 1 " + ot.circularPathData.leftFullExtent + " " + (ot.circularPathData.sourceY + ot.circularPathData.leftSmallArcRadius) + " L" + ot.circularPathData.leftFullExtent + " " + ot.circularPathData.verticalLeftInnerExtent + " A" + ot.circularPathData.leftLargeArcRadius + " " + ot.circularPathData.leftLargeArcRadius + " 0 0 1 " + ot.circularPathData.leftInnerExtent + " " + ot.circularPathData.verticalFullExtent + " L" + ot.circularPathData.rightInnerExtent + " " + ot.circularPathData.verticalFullExtent + " A" + ot.circularPathData.rightLargeArcRadius + " " + ot.circularPathData.rightLargeArcRadius + " 0 0 1 " + ot.circularPathData.rightFullExtent + " " + ot.circularPathData.verticalRightInnerExtent + " L" + ot.circularPathData.rightFullExtent + " " + (ot.circularPathData.targetY + ot.circularPathData.rightSmallArcRadius) + " A" + ot.circularPathData.rightLargeArcRadius + " " + ot.circularPathData.rightSmallArcRadius + " 0 0 1 " + ot.circularPathData.rightInnerExtent + " " + ot.circularPathData.targetY + " L" + ot.circularPathData.targetX + " " + ot.circularPathData.targetY, ut;
+          }
+          function oe(ot, ut) {
+            return ie(ot) == ie(ut) ? ot.circularLinkType == "bottom" ? Ce(ot, ut) : _e(ot, ut) : ie(ut) - ie(ot);
+          }
+          function _e(ot, ut) {
+            return ot.y0 - ut.y0;
+          }
+          function Ce(ot, ut) {
+            return ut.y0 - ot.y0;
+          }
+          function Le(ot, ut) {
+            return ot.y1 - ut.y1;
+          }
+          function ge(ot, ut) {
+            return ut.y1 - ot.y1;
+          }
+          function ie(ot) {
+            return ot.target.column - ot.source.column;
+          }
+          function Se(ot) {
+            return ot.target.x0 - ot.source.x1;
+          }
+          function Ee(ot, ut) {
+            var Wt = U(ot), Nt = Se(ut) / Math.tan(Wt), $t = lt(ot) == "up" ? ot.y1 + Nt : ot.y1 - Nt;
+            return $t;
+          }
+          function Ae(ot, ut) {
+            var Wt = U(ot), Nt = Se(ut) / Math.tan(Wt), $t = lt(ot) == "up" ? ot.y1 - Nt : ot.y1 + Nt;
+            return $t;
+          }
+          function Be(ot, ut, Wt, Nt) {
+            ot.links.forEach(function($t) {
+              if (!$t.circular && $t.target.column - $t.source.column > 1) {
+                var sr = $t.source.column + 1, Tr = $t.target.column - 1, fr = 1, $e = Tr - sr + 1;
+                for (fr = 1; sr <= Tr; sr++, fr++) ot.nodes.forEach(function(St) {
+                  if (St.column == sr) {
+                    var Qt = fr / ($e + 1), Gt = Math.pow(1 - Qt, 3), _t = 3 * Qt * Math.pow(1 - Qt, 2), It = 3 * Math.pow(Qt, 2) * (1 - Qt), mt = Math.pow(Qt, 3), er = Gt * $t.y0 + _t * $t.y0 + It * $t.y1 + mt * $t.y1, lr = er - $t.width / 2, wr = er + $t.width / 2, Lr;
+                    lr > St.y0 && lr < St.y1 ? (Lr = St.y1 - lr + 10, Lr = St.circularLinkType == "bottom" ? Lr : -Lr, St = me(St, Lr, ut, Wt), ot.nodes.forEach(function(ti) {
+                      C(ti, Nt) == C(St, Nt) || ti.column != St.column || Pe(St, ti) && me(ti, Lr, ut, Wt);
+                    })) : wr > St.y0 && wr < St.y1 ? (Lr = wr - St.y0 + 10, St = me(St, Lr, ut, Wt), ot.nodes.forEach(function(ti) {
+                      C(ti, Nt) == C(St, Nt) || ti.column != St.column || ti.y0 < St.y1 && ti.y1 > St.y1 && me(ti, Lr, ut, Wt);
+                    })) : lr < St.y0 && wr > St.y1 && (Lr = wr - St.y0 + 10, St = me(St, Lr, ut, Wt), ot.nodes.forEach(function(ti) {
+                      C(ti, Nt) == C(St, Nt) || ti.column != St.column || ti.y0 < St.y1 && ti.y1 > St.y1 && me(ti, Lr, ut, Wt);
+                    }));
+                  }
+                });
+              }
+            });
+          }
+          function Pe(ot, ut) {
+            return ot.y0 > ut.y0 && ot.y0 < ut.y1 || ot.y1 > ut.y0 && ot.y1 < ut.y1 ? true : ot.y0 < ut.y0 && ot.y1 > ut.y1;
+          }
+          function me(ot, ut, Wt, Nt) {
+            return ot.y0 + ut >= Wt && ot.y1 + ut <= Nt && (ot.y0 = ot.y0 + ut, ot.y1 = ot.y1 + ut, ot.targetLinks.forEach(function($t) {
+              $t.y1 = $t.y1 + ut;
+            }), ot.sourceLinks.forEach(function($t) {
+              $t.y0 = $t.y0 + ut;
+            })), ot;
+          }
+          function De(ot, ut, Wt, Nt) {
+            ot.nodes.forEach(function($t) {
+              Nt && $t.y + ($t.y1 - $t.y0) > ut && ($t.y = $t.y - ($t.y + ($t.y1 - $t.y0) - ut));
+              var sr = ot.links.filter(function($e) {
+                return C($e.source, Wt) == C($t, Wt);
+              }), Tr = sr.length;
+              Tr > 1 && sr.sort(function($e, St) {
+                if (!$e.circular && !St.circular) {
+                  if ($e.target.column == St.target.column) return $e.y1 - St.y1;
+                  if (je($e, St)) {
+                    if ($e.target.column > St.target.column) {
+                      var Qt = Ae(St, $e);
+                      return $e.y1 - Qt;
+                    }
+                    if (St.target.column > $e.target.column) {
+                      var Gt = Ae($e, St);
+                      return Gt - St.y1;
+                    }
+                  } else return $e.y1 - St.y1;
+                }
+                if ($e.circular && !St.circular) return $e.circularLinkType == "top" ? -1 : 1;
+                if (St.circular && !$e.circular) return St.circularLinkType == "top" ? 1 : -1;
+                if ($e.circular && St.circular) return $e.circularLinkType === St.circularLinkType && $e.circularLinkType == "top" ? $e.target.column === St.target.column ? $e.target.y1 - St.target.y1 : St.target.column - $e.target.column : $e.circularLinkType === St.circularLinkType && $e.circularLinkType == "bottom" ? $e.target.column === St.target.column ? St.target.y1 - $e.target.y1 : $e.target.column - St.target.column : $e.circularLinkType == "top" ? -1 : 1;
+              });
+              var fr = $t.y0;
+              sr.forEach(function($e) {
+                $e.y0 = fr + $e.width / 2, fr = fr + $e.width;
+              }), sr.forEach(function($e, St) {
+                if ($e.circularLinkType == "bottom") {
+                  var Qt = St + 1, Gt = 0;
+                  for (Qt; Qt < Tr; Qt++) Gt = Gt + sr[Qt].width;
+                  $e.y0 = $t.y1 - Gt - $e.width / 2;
+                }
+              });
+            });
+          }
+          function ce(ot, ut, Wt) {
+            ot.nodes.forEach(function(Nt) {
+              var $t = ot.links.filter(function(fr) {
+                return C(fr.target, Wt) == C(Nt, Wt);
+              }), sr = $t.length;
+              sr > 1 && $t.sort(function(fr, $e) {
+                if (!fr.circular && !$e.circular) {
+                  if (fr.source.column == $e.source.column) return fr.y0 - $e.y0;
+                  if (je(fr, $e)) {
+                    if ($e.source.column < fr.source.column) {
+                      var St = Ee($e, fr);
+                      return fr.y0 - St;
+                    }
+                    if (fr.source.column < $e.source.column) {
+                      var Qt = Ee(fr, $e);
+                      return Qt - $e.y0;
+                    }
+                  } else return fr.y0 - $e.y0;
+                }
+                if (fr.circular && !$e.circular) return fr.circularLinkType == "top" ? -1 : 1;
+                if ($e.circular && !fr.circular) return $e.circularLinkType == "top" ? 1 : -1;
+                if (fr.circular && $e.circular) return fr.circularLinkType === $e.circularLinkType && fr.circularLinkType == "top" ? fr.source.column === $e.source.column ? fr.source.y1 - $e.source.y1 : fr.source.column - $e.source.column : fr.circularLinkType === $e.circularLinkType && fr.circularLinkType == "bottom" ? fr.source.column === $e.source.column ? fr.source.y1 - $e.source.y1 : $e.source.column - fr.source.column : fr.circularLinkType == "top" ? -1 : 1;
+              });
+              var Tr = Nt.y0;
+              $t.forEach(function(fr) {
+                fr.y1 = Tr + fr.width / 2, Tr = Tr + fr.width;
+              }), $t.forEach(function(fr, $e) {
+                if (fr.circularLinkType == "bottom") {
+                  var St = $e + 1, Qt = 0;
+                  for (St; St < sr; St++) Qt = Qt + $t[St].width;
+                  fr.y1 = Nt.y1 - Qt - fr.width / 2;
+                }
+              });
+            });
+          }
+          function je(ot, ut) {
+            return lt(ot) == lt(ut);
+          }
+          function lt(ot) {
+            return ot.y0 - ot.y1 > 0 ? "up" : "down";
+          }
+          function pt(ot, ut) {
+            return C(ot.source, ut) == C(ot.target, ut);
+          }
+          function Vt(ot, ut, Wt) {
+            var Nt = ot.nodes, $t = ot.links, sr = false, Tr = false;
+            if ($t.forEach(function(_t) {
+              _t.circularLinkType == "top" ? sr = true : _t.circularLinkType == "bottom" && (Tr = true);
+            }), sr == false || Tr == false) {
+              var fr = t.min(Nt, function(_t) {
+                return _t.y0;
+              }), $e = t.max(Nt, function(_t) {
+                return _t.y1;
+              }), St = $e - fr, Qt = Wt - ut, Gt = Qt / St;
+              Nt.forEach(function(_t) {
+                var It = (_t.y1 - _t.y0) * Gt;
+                _t.y0 = (_t.y0 - fr) * Gt, _t.y1 = _t.y0 + It;
+              }), $t.forEach(function(_t) {
+                _t.y0 = (_t.y0 - fr) * Gt, _t.y1 = (_t.y1 - fr) * Gt, _t.width = _t.width * Gt;
+              });
+            }
+          }
+          e.sankeyCircular = A, e.sankeyCenter = u, e.sankeyLeft = o, e.sankeyRight = s, e.sankeyJustify = l, Object.defineProperty(e, "__esModule", { value: true });
+        });
+      });
+      var QJ = ye((h2r, eXe) => {
+        eXe.exports = { nodeTextOffsetHorizontal: 4, nodeTextOffsetVertical: 3, nodePadAcross: 10, sankeyIterations: 50, forceIterations: 5, forceTicksPerFrame: 10, duration: 500, ease: "linear", cn: { sankey: "sankey", sankeyLinks: "sankey-links", sankeyLink: "sankey-link", sankeyNodeSet: "sankey-node-set", sankeyNode: "sankey-node", nodeRect: "node-rect", nodeLabel: "node-label" } };
+      });
+      var dXe = ye((d2r, hXe) => {
+        var tXe = HWe(), XZt = (H2(), pb(G2)).interpolateNumber, O5 = Oa(), aC = YWe(), ZZt = QWe(), Nu = QJ(), q5 = fd(), gw = ka(), YZt = So(), w1 = Dr(), r$ = w1.strTranslate, KZt = w1.strRotate, i$ = iy(), oC = i$.keyFun, P7 = i$.repeat, sXe = i$.unwrap, rXe = Zl(), JZt = qa(), lXe = Dh(), $Zt = lXe.CAP_SHIFT, QZt = lXe.LINE_SPACING, eYt = 3;
+        function tYt(e, t, r) {
+          var n = sXe(t), i = n.trace, a = i.domain, o = i.orientation === "h", s = i.node.pad, l = i.node.thickness, u = { justify: aC.sankeyJustify, left: aC.sankeyLeft, right: aC.sankeyRight, center: aC.sankeyCenter }[i.node.align], c = e.width * (a.x[1] - a.x[0]), f = e.height * (a.y[1] - a.y[0]), h = n._nodes, d = n._links, v = n.circular, _;
+          v ? _ = ZZt.sankeyCircular().circularLinkGap(0) : _ = aC.sankey(), _.iterations(Nu.sankeyIterations).size(o ? [c, f] : [f, c]).nodeWidth(l).nodePadding(s).nodeId(function(U) {
+            return U.pointNumber;
+          }).nodeAlign(u).nodes(h).links(d);
+          var b = _();
+          _.nodePadding() < s && w1.warn("node.pad was reduced to ", _.nodePadding(), " to fit within the figure.");
+          var p, k, E;
+          for (var T in n._groupLookup) {
+            var L = parseInt(n._groupLookup[T]), x;
+            for (p = 0; p < b.nodes.length; p++) if (b.nodes[p].pointNumber === L) {
+              x = b.nodes[p];
+              break;
+            }
+            if (x) {
+              var C = { pointNumber: parseInt(T), x0: x.x0, x1: x.x1, y0: x.y0, y1: x.y1, partOfGroup: true, sourceLinks: [], targetLinks: [] };
+              b.nodes.unshift(C), x.childrenNodes.unshift(C);
+            }
+          }
+          function M() {
+            for (p = 0; p < b.nodes.length; p++) {
+              var U = b.nodes[p], G = {}, Z, j;
+              for (k = 0; k < U.targetLinks.length; k++) j = U.targetLinks[k], Z = j.source.pointNumber + ":" + j.target.pointNumber, G.hasOwnProperty(Z) || (G[Z] = []), G[Z].push(j);
+              var N = Object.keys(G);
+              for (k = 0; k < N.length; k++) {
+                Z = N[k];
+                var H = G[Z], re = 0, oe = {};
+                for (E = 0; E < H.length; E++) j = H[E], oe[j.label] || (oe[j.label] = 0), oe[j.label] += j.value, re += j.value;
+                for (E = 0; E < H.length; E++) j = H[E], j.flow = { value: re, labelConcentration: oe[j.label] / re, concentration: j.value / re, links: H }, j.concentrationscale && (j.color = q5(j.concentrationscale(j.flow.labelConcentration)));
+              }
+              var _e = 0;
+              for (k = 0; k < U.sourceLinks.length; k++) _e += U.sourceLinks[k].value;
+              for (k = 0; k < U.sourceLinks.length; k++) j = U.sourceLinks[k], j.concentrationOut = j.value / _e;
+              var Ce = 0;
+              for (k = 0; k < U.targetLinks.length; k++) Ce += U.targetLinks[k].value;
+              for (k = 0; k < U.targetLinks.length; k++) j = U.targetLinks[k], j.concenrationIn = j.value / Ce;
+            }
+          }
+          M();
+          function g(U) {
+            U.forEach(function(G) {
+              var Z, j, N = 0, H = G.length, re;
+              for (G.sort(function(oe, _e) {
+                return oe.y0 - _e.y0;
+              }), re = 0; re < H; ++re) Z = G[re], Z.y0 >= N || (j = N - Z.y0, j > 1e-6 && (Z.y0 += j, Z.y1 += j)), N = Z.y1 + s;
+            });
+          }
+          function P(U) {
+            var G = U.map(function(_e, Ce) {
+              return { x0: _e.x0, index: Ce };
+            }).sort(function(_e, Ce) {
+              return _e.x0 - Ce.x0;
+            }), Z = [], j = -1, N, H = -1 / 0, re;
+            for (p = 0; p < G.length; p++) {
+              var oe = U[G[p].index];
+              oe.x0 > H + l && (j += 1, N = oe.x0), H = oe.x0, Z[j] || (Z[j] = []), Z[j].push(oe), re = N - oe.x0, oe.x0 += re, oe.x1 += re;
+            }
+            return Z;
+          }
+          if (i.node.x.length && i.node.y.length) {
+            for (p = 0; p < Math.min(i.node.x.length, i.node.y.length, b.nodes.length); p++) if (i.node.x[p] && i.node.y[p]) {
+              var A = [i.node.x[p] * c, i.node.y[p] * f];
+              b.nodes[p].x0 = A[0] - l / 2, b.nodes[p].x1 = A[0] + l / 2;
+              var z = b.nodes[p].y1 - b.nodes[p].y0;
+              b.nodes[p].y0 = A[1] - z / 2, b.nodes[p].y1 = A[1] + z / 2;
+            }
+            if (i.arrangement === "snap") {
+              h = b.nodes;
+              var O = P(h);
+              g(O);
+            }
+            _.update(b);
+          }
+          return { circular: v, key: r, trace: i, guid: w1.randstr(), horizontal: o, width: c, height: f, nodePad: i.node.pad, nodeLineColor: i.node.line.color, nodeLineWidth: i.node.line.width, linkLineColor: i.link.line.color, linkLineWidth: i.link.line.width, linkArrowLength: i.link.arrowlen, valueFormat: i.valueformat, valueSuffix: i.valuesuffix, textFont: i.textfont, translateX: a.x[0] * e.width + e.margin.l, translateY: e.height - a.y[1] * e.height + e.margin.t, dragParallel: o ? f : c, dragPerpendicular: o ? c : f, arrangement: i.arrangement, sankey: _, graph: b, forceLayouts: {}, interactionState: { dragInProgress: false, hovered: false } };
+        }
+        function rYt(e, t, r) {
+          var n = q5(t.color), i = q5(t.hovercolor), a = t.source.label + "|" + t.target.label, o = a + "__" + r;
+          return t.trace = e.trace, t.curveNumber = e.trace.index, { circular: e.circular, key: o, traceId: e.key, pointNumber: t.pointNumber, link: t, tinyColorHue: gw.tinyRGB(n), tinyColorAlpha: n.getAlpha(), tinyColorHoverHue: gw.tinyRGB(i), tinyColorHoverAlpha: i.getAlpha(), linkPath: n$, linkLineColor: e.linkLineColor, linkLineWidth: e.linkLineWidth, linkArrowLength: e.linkArrowLength, valueFormat: e.valueFormat, valueSuffix: e.valueSuffix, sankey: e.sankey, parent: e, interactionState: e.interactionState, flow: t.flow };
+        }
+        function iYt(e, t) {
+          var r = "", n = e.width / 2, i = e.circularPathData, a = i.sourceX + i.verticalBuffer < i.targetX, o = i.rightFullExtent - i.rightLargeArcRadius - t <= i.leftFullExtent - n;
+          Math.abs(i.rightFullExtent - i.leftFullExtent - n) < n;
+          return e.circularLinkType === "top" ? (r = "M " + (i.targetX - t) + " " + (i.targetY + n) + " L " + (i.rightInnerExtent - t) + " " + (i.targetY + n) + "A " + (i.rightLargeArcRadius + n) + " " + (i.rightSmallArcRadius + n) + " 0 0 1 " + (i.rightFullExtent - n - t) + " " + (i.targetY - i.rightSmallArcRadius) + "L " + (i.rightFullExtent - n - t) + " " + i.verticalRightInnerExtent, a && o ? r += " A " + (i.rightLargeArcRadius + n) + " " + (i.rightLargeArcRadius + n) + " 0 0 1 " + (i.rightFullExtent + n - t - (i.rightLargeArcRadius - n)) + " " + (i.verticalRightInnerExtent - (i.rightLargeArcRadius + n)) + " L " + (i.rightFullExtent + n - (i.rightLargeArcRadius - n) - t) + " " + (i.verticalRightInnerExtent - (i.rightLargeArcRadius + n)) + " A " + (i.leftLargeArcRadius + n) + " " + (i.leftLargeArcRadius + n) + " 0 0 1 " + (i.leftFullExtent + n) + " " + i.verticalRightInnerExtent : a ? r += " A " + (i.rightLargeArcRadius - n) + " " + (i.rightLargeArcRadius - n) + " 0 0 0 " + (i.rightFullExtent - n - t - (i.rightLargeArcRadius - n)) + " " + (i.verticalRightInnerExtent - (i.rightLargeArcRadius - n)) + " L " + (i.leftFullExtent + n + (i.rightLargeArcRadius - n)) + " " + (i.verticalRightInnerExtent - (i.rightLargeArcRadius - n)) + " A " + (i.leftLargeArcRadius - n) + " " + (i.leftLargeArcRadius - n) + " 0 0 0 " + (i.leftFullExtent + n) + " " + i.verticalLeftInnerExtent : r += " A " + (i.rightLargeArcRadius + n) + " " + (i.rightLargeArcRadius + n) + " 0 0 1 " + (i.rightInnerExtent - t) + " " + (i.verticalFullExtent - n) + " L " + i.leftInnerExtent + " " + (i.verticalFullExtent - n) + " A " + (i.leftLargeArcRadius + n) + " " + (i.leftLargeArcRadius + n) + " 0 0 1 " + (i.leftFullExtent + n) + " " + i.verticalLeftInnerExtent, r += " L " + (i.leftFullExtent + n) + " " + (i.sourceY - i.leftSmallArcRadius) + " A " + (i.leftLargeArcRadius + n) + " " + (i.leftSmallArcRadius + n) + " 0 0 1 " + i.leftInnerExtent + " " + (i.sourceY + n) + " L " + i.sourceX + " " + (i.sourceY + n) + " L " + i.sourceX + " " + (i.sourceY - n) + " L " + i.leftInnerExtent + " " + (i.sourceY - n) + " A " + (i.leftLargeArcRadius - n) + " " + (i.leftSmallArcRadius - n) + " 0 0 0 " + (i.leftFullExtent - n) + " " + (i.sourceY - i.leftSmallArcRadius) + " L " + (i.leftFullExtent - n) + " " + i.verticalLeftInnerExtent, a && o ? r += " A " + (i.leftLargeArcRadius + n) + " " + (i.leftSmallArcRadius + n) + " 0 0 0 " + (i.leftFullExtent - n) + " " + (i.verticalFullExtent + n) + "L" + (i.rightFullExtent + n - t) + " " + (i.verticalFullExtent + n) + " A " + (i.leftLargeArcRadius + n) + " " + (i.leftSmallArcRadius + n) + " 0 0 0 " + (i.rightFullExtent + n - t) + " " + i.verticalRightInnerExtent : a ? r += " A " + (i.leftLargeArcRadius + n) + " " + (i.leftSmallArcRadius + n) + " 0 0 1 " + (i.leftFullExtent + n) + " " + (i.verticalFullExtent - n) + " L " + (i.rightFullExtent - n - t) + " " + (i.verticalFullExtent - n) + " A " + (i.leftLargeArcRadius + n) + " " + (i.leftSmallArcRadius + n) + " 0 0 1 " + (i.rightFullExtent + n - t) + " " + i.verticalRightInnerExtent : r += " A " + (i.leftLargeArcRadius - n) + " " + (i.leftLargeArcRadius - n) + " 0 0 0 " + i.leftInnerExtent + " " + (i.verticalFullExtent + n) + " L " + (i.rightInnerExtent - t) + " " + (i.verticalFullExtent + n) + " A " + (i.rightLargeArcRadius - n) + " " + (i.rightLargeArcRadius - n) + " 0 0 0 " + (i.rightFullExtent + n - t) + " " + i.verticalRightInnerExtent, r += " L " + (i.rightFullExtent + n - t) + " " + (i.targetY - i.rightSmallArcRadius) + " A " + (i.rightLargeArcRadius - n) + " " + (i.rightSmallArcRadius - n) + " 0 0 0 " + (i.rightInnerExtent - t) + " " + (i.targetY - n) + " L " + (i.targetX - t) + " " + (i.targetY - n) + (t > 0 ? " L " + i.targetX + " " + i.targetY : "") + "Z") : (r = "M " + (i.targetX - t) + " " + (i.targetY - n) + "  L " + (i.rightInnerExtent - t) + " " + (i.targetY - n) + " A " + (i.rightLargeArcRadius + n) + " " + (i.rightSmallArcRadius + n) + " 0 0 0 " + (i.rightFullExtent - n - t) + " " + (i.targetY + i.rightSmallArcRadius) + " L " + (i.rightFullExtent - n - t) + " " + i.verticalRightInnerExtent, a && o ? r += " A " + (i.rightLargeArcRadius + n) + " " + (i.rightLargeArcRadius + n) + " 0 0 0 " + (i.rightInnerExtent - n - t) + " " + (i.verticalFullExtent + n) + " L " + (i.rightFullExtent + n - t - (i.rightLargeArcRadius - n)) + " " + (i.verticalFullExtent + n) + " A " + (i.rightLargeArcRadius + n) + " " + (i.rightLargeArcRadius + n) + " 0 0 0 " + (i.leftFullExtent + n) + " " + i.verticalLeftInnerExtent : a ? r += " A " + (i.rightLargeArcRadius - n) + " " + (i.rightSmallArcRadius - n) + " 0 0 1 " + (i.rightFullExtent - t - n - (i.rightLargeArcRadius - n)) + " " + (i.verticalFullExtent - n) + " L " + (i.leftFullExtent + n + (i.rightLargeArcRadius - n)) + " " + (i.verticalFullExtent - n) + " A " + (i.rightLargeArcRadius - n) + " " + (i.rightSmallArcRadius - n) + " 0 0 1 " + (i.leftFullExtent + n) + " " + i.verticalLeftInnerExtent : r += " A " + (i.rightLargeArcRadius + n) + " " + (i.rightLargeArcRadius + n) + " 0 0 0 " + (i.rightInnerExtent - t) + " " + (i.verticalFullExtent + n) + " L " + i.leftInnerExtent + " " + (i.verticalFullExtent + n) + " A " + (i.leftLargeArcRadius + n) + " " + (i.leftLargeArcRadius + n) + " 0 0 0 " + (i.leftFullExtent + n) + " " + i.verticalLeftInnerExtent, r += " L " + (i.leftFullExtent + n) + " " + (i.sourceY + i.leftSmallArcRadius) + " A " + (i.leftLargeArcRadius + n) + " " + (i.leftSmallArcRadius + n) + " 0 0 0 " + i.leftInnerExtent + " " + (i.sourceY - n) + " L " + i.sourceX + " " + (i.sourceY - n) + " L " + i.sourceX + " " + (i.sourceY + n) + " L " + i.leftInnerExtent + " " + (i.sourceY + n) + " A " + (i.leftLargeArcRadius - n) + " " + (i.leftSmallArcRadius - n) + " 0 0 1 " + (i.leftFullExtent - n) + " " + (i.sourceY + i.leftSmallArcRadius) + " L " + (i.leftFullExtent - n) + " " + i.verticalLeftInnerExtent, a && o ? r += " A " + (i.rightLargeArcRadius - n) + " " + (i.rightSmallArcRadius - n) + " 0 0 1 " + (i.leftFullExtent - n - (i.rightLargeArcRadius - n)) + " " + (i.verticalFullExtent - n) + " L " + (i.rightFullExtent + n - t + (i.rightLargeArcRadius - n)) + " " + (i.verticalFullExtent - n) + " A " + (i.rightLargeArcRadius - n) + " " + (i.rightSmallArcRadius - n) + " 0 0 1 " + (i.rightFullExtent + n - t) + " " + i.verticalRightInnerExtent : a ? r += " A " + (i.rightLargeArcRadius + n) + " " + (i.rightLargeArcRadius + n) + " 0 0 0 " + (i.leftFullExtent + n) + " " + (i.verticalFullExtent + n) + " L " + (i.rightFullExtent - t - n) + " " + (i.verticalFullExtent + n) + " A " + (i.rightLargeArcRadius + n) + " " + (i.rightLargeArcRadius + n) + " 0 0 0 " + (i.rightFullExtent + n - t) + " " + i.verticalRightInnerExtent : r += " A " + (i.leftLargeArcRadius - n) + " " + (i.leftLargeArcRadius - n) + " 0 0 1 " + i.leftInnerExtent + " " + (i.verticalFullExtent - n) + " L " + (i.rightInnerExtent - t) + " " + (i.verticalFullExtent - n) + " A " + (i.rightLargeArcRadius - n) + " " + (i.rightLargeArcRadius - n) + " 0 0 1 " + (i.rightFullExtent + n - t) + " " + i.verticalRightInnerExtent, r += " L " + (i.rightFullExtent + n - t) + " " + (i.targetY + i.rightSmallArcRadius) + " A " + (i.rightLargeArcRadius - n) + " " + (i.rightSmallArcRadius - n) + " 0 0 1 " + (i.rightInnerExtent - t) + " " + (i.targetY + n) + " L " + (i.targetX - t) + " " + (i.targetY + n) + (t > 0 ? " L " + i.targetX + " " + i.targetY : "") + "Z"), r;
+        }
+        function n$() {
+          var e = 0.5;
+          function t(r) {
+            var n = r.linkArrowLength;
+            if (r.link.circular) return iYt(r.link, n);
+            var i = Math.abs((r.link.target.x0 - r.link.source.x1) / 2);
+            n > i && (n = i);
+            var a = r.link.source.x1, o = r.link.target.x0 - n, s = XZt(a, o), l = s(e), u = s(1 - e), c = r.link.y0 - r.link.width / 2, f = r.link.y0 + r.link.width / 2, h = r.link.y1 - r.link.width / 2, d = r.link.y1 + r.link.width / 2, v = "M" + a + "," + c, _ = "C" + l + "," + c + " " + u + "," + h + " " + o + "," + h, b = "C" + u + "," + d + " " + l + "," + f + " " + a + "," + f, p = n > 0 ? "L" + (o + n) + "," + (h + r.link.width / 2) : "";
+            return p += "L" + o + "," + d, v + _ + p + b + "Z";
+          }
+          return t;
+        }
+        function nYt(e, t) {
+          var r = q5(t.color), n = Nu.nodePadAcross, i = e.nodePad / 2;
+          t.dx = t.x1 - t.x0, t.dy = t.y1 - t.y0;
+          var a = t.dx, o = Math.max(0.5, t.dy), s = "node_" + t.pointNumber;
+          return t.group && (s = w1.randstr()), t.trace = e.trace, t.curveNumber = e.trace.index, { index: t.pointNumber, key: s, partOfGroup: t.partOfGroup || false, group: t.group, traceId: e.key, trace: e.trace, node: t, nodePad: e.nodePad, nodeLineColor: e.nodeLineColor, nodeLineWidth: e.nodeLineWidth, textFont: e.textFont, size: e.horizontal ? e.height : e.width, visibleWidth: Math.ceil(a), visibleHeight: o, zoneX: -n, zoneY: -i, zoneWidth: a + 2 * n, zoneHeight: o + 2 * i, labelY: e.horizontal ? t.dy / 2 + 1 : t.dx / 2 + 1, left: t.originalLayer === 1, sizeAcross: e.width, forceLayouts: e.forceLayouts, horizontal: e.horizontal, darkBackground: r.getBrightness() <= 128, tinyColorHue: gw.tinyRGB(r), tinyColorAlpha: r.getAlpha(), valueFormat: e.valueFormat, valueSuffix: e.valueSuffix, sankey: e.sankey, graph: e.graph, arrangement: e.arrangement, uniqueNodeLabelPathId: [e.guid, e.key, s].join("_"), interactionState: e.interactionState, figure: e };
+        }
+        function t$(e) {
+          e.attr("transform", function(t) {
+            return r$(t.node.x0.toFixed(3), t.node.y0.toFixed(3));
+          });
+        }
+        function aYt(e) {
+          e.call(t$);
+        }
+        function uXe(e, t) {
+          e.call(aYt), t.attr("d", n$());
+        }
+        function iXe(e) {
+          e.attr("width", function(t) {
+            return t.node.x1 - t.node.x0;
+          }).attr("height", function(t) {
+            return t.visibleHeight;
+          });
+        }
+        function e$(e) {
+          return e.link.width > 1 || e.linkLineWidth > 0;
+        }
+        function nXe(e) {
+          var t = r$(e.translateX, e.translateY);
+          return t + (e.horizontal ? "matrix(1 0 0 1 0 0)" : "matrix(0 1 1 0 0 0)");
+        }
+        function aXe(e, t, r) {
+          e.on(".basic", null).on("mouseover.basic", function(n) {
+            !n.interactionState.dragInProgress && !n.partOfGroup && (r.hover(this, n, t), n.interactionState.hovered = [this, n]);
+          }).on("mousemove.basic", function(n) {
+            !n.interactionState.dragInProgress && !n.partOfGroup && (r.follow(this, n), n.interactionState.hovered = [this, n]);
+          }).on("mouseout.basic", function(n) {
+            !n.interactionState.dragInProgress && !n.partOfGroup && (r.unhover(this, n, t), n.interactionState.hovered = false);
+          }).on("click.basic", function(n) {
+            n.interactionState.hovered && (r.unhover(this, n, t), n.interactionState.hovered = false), !n.interactionState.dragInProgress && !n.partOfGroup && r.select(this, n, t);
+          });
+        }
+        function oYt(e, t, r, n) {
+          var i = O5.behavior.drag().origin(function(a) {
+            return { x: a.node.x0 + a.visibleWidth / 2, y: a.node.y0 + a.visibleHeight / 2 };
+          }).on("dragstart", function(a) {
+            if (a.arrangement !== "fixed" && (w1.ensureSingle(n._fullLayout._infolayer, "g", "dragcover", function(s) {
+              n._fullLayout._dragCover = s;
+            }), w1.raiseToTop(this), a.interactionState.dragInProgress = a.node, oXe(a.node), a.interactionState.hovered && (r.nodeEvents.unhover.apply(0, a.interactionState.hovered), a.interactionState.hovered = false), a.arrangement === "snap")) {
+              var o = a.traceId + "|" + a.key;
+              a.forceLayouts[o] ? a.forceLayouts[o].alpha(1) : sYt(e, o, a), lYt(e, t, a, o, n);
+            }
+          }).on("drag", function(a) {
+            if (a.arrangement !== "fixed") {
+              var o = O5.event.x, s = O5.event.y;
+              a.arrangement === "snap" ? (a.node.x0 = o - a.visibleWidth / 2, a.node.x1 = o + a.visibleWidth / 2, a.node.y0 = s - a.visibleHeight / 2, a.node.y1 = s + a.visibleHeight / 2) : (a.arrangement === "freeform" && (a.node.x0 = o - a.visibleWidth / 2, a.node.x1 = o + a.visibleWidth / 2), s = Math.max(0, Math.min(a.size - a.visibleHeight / 2, s)), a.node.y0 = s - a.visibleHeight / 2, a.node.y1 = s + a.visibleHeight / 2), oXe(a.node), a.arrangement !== "snap" && (a.sankey.update(a.graph), uXe(e.filter(fXe(a)), t));
+            }
+          }).on("dragend", function(a) {
+            if (a.arrangement !== "fixed") {
+              a.interactionState.dragInProgress = false;
+              for (var o = 0; o < a.node.childrenNodes.length; o++) a.node.childrenNodes[o].x = a.node.x, a.node.childrenNodes[o].y = a.node.y;
+              a.arrangement !== "snap" && cXe(a, n);
+            }
+          });
+          e.on(".drag", null).call(i);
+        }
+        function sYt(e, t, r, n) {
+          fYt(r.graph.nodes);
+          var i = r.graph.nodes.filter(function(a) {
+            return a.originalX === r.node.originalX;
+          }).filter(function(a) {
+            return !a.partOfGroup;
+          });
+          r.forceLayouts[t] = tXe.forceSimulation(i).alphaDecay(0).force("collide", tXe.forceCollide().radius(function(a) {
+            return a.dy / 2 + r.nodePad / 2;
+          }).strength(1).iterations(Nu.forceIterations)).force("constrain", uYt(e, t, i, r)).stop();
+        }
+        function lYt(e, t, r, n, i) {
+          window.requestAnimationFrame(function a() {
+            var o;
+            for (o = 0; o < Nu.forceTicksPerFrame; o++) r.forceLayouts[n].tick();
+            var s = r.graph.nodes;
+            if (hYt(s), r.sankey.update(r.graph), uXe(e.filter(fXe(r)), t), r.forceLayouts[n].alpha() > 0) window.requestAnimationFrame(a);
+            else {
+              var l = r.node.originalX;
+              r.node.x0 = l - r.visibleWidth / 2, r.node.x1 = l + r.visibleWidth / 2, cXe(r, i);
+            }
+          });
+        }
+        function uYt(e, t, r, n) {
+          return function() {
+            for (var a = 0, o = 0; o < r.length; o++) {
+              var s = r[o];
+              s === n.interactionState.dragInProgress ? (s.x = s.lastDraggedX, s.y = s.lastDraggedY) : (s.vx = (s.originalX - s.x) / Nu.forceTicksPerFrame, s.y = Math.min(n.size - s.dy / 2, Math.max(s.dy / 2, s.y))), a = Math.max(a, Math.abs(s.vx), Math.abs(s.vy));
+            }
+            !n.interactionState.dragInProgress && a < 0.1 && n.forceLayouts[t].alpha() > 0 && n.forceLayouts[t].alpha(0);
+          };
+        }
+        function cXe(e, t) {
+          for (var r = [], n = [], i = 0; i < e.graph.nodes.length; i++) {
+            var a = (e.graph.nodes[i].x0 + e.graph.nodes[i].x1) / 2, o = (e.graph.nodes[i].y0 + e.graph.nodes[i].y1) / 2;
+            r.push(a / e.figure.width), n.push(o / e.figure.height);
+          }
+          JZt.call("_guiRestyle", t, { "node.x": [r], "node.y": [n] }, e.trace.index).then(function() {
+            t._fullLayout._dragCover && t._fullLayout._dragCover.remove();
+          });
+        }
+        function cYt(e) {
+          var t = [], r;
+          for (r = 0; r < e.length; r++) e[r].originalX = (e[r].x0 + e[r].x1) / 2, e[r].originalY = (e[r].y0 + e[r].y1) / 2, t.indexOf(e[r].originalX) === -1 && t.push(e[r].originalX);
+          for (t.sort(function(n, i) {
+            return n - i;
+          }), r = 0; r < e.length; r++) e[r].originalLayerIndex = t.indexOf(e[r].originalX), e[r].originalLayer = e[r].originalLayerIndex / (t.length - 1);
+        }
+        function oXe(e) {
+          e.lastDraggedX = e.x0 + e.dx / 2, e.lastDraggedY = e.y0 + e.dy / 2;
+        }
+        function fXe(e) {
+          return function(t) {
+            return t.node.originalX === e.node.originalX;
+          };
+        }
+        function fYt(e) {
+          for (var t = 0; t < e.length; t++) e[t].y = (e[t].y0 + e[t].y1) / 2, e[t].x = (e[t].x0 + e[t].x1) / 2;
+        }
+        function hYt(e) {
+          for (var t = 0; t < e.length; t++) e[t].y0 = e[t].y - e[t].dy / 2, e[t].y1 = e[t].y0 + e[t].dy, e[t].x0 = e[t].x - e[t].dx / 2, e[t].x1 = e[t].x0 + e[t].dx;
+        }
+        hXe.exports = function(e, t, r, n, i) {
+          var a = e._context.staticPlot, o = false;
+          w1.ensureSingle(e._fullLayout._infolayer, "g", "first-render", function() {
+            o = true;
+          });
+          var s = e._fullLayout._dragCover, l = r.filter(function(b) {
+            return sXe(b).trace.visible;
+          }).map(tYt.bind(null, n)), u = t.selectAll("." + Nu.cn.sankey).data(l, oC);
+          u.exit().remove(), u.enter().append("g").classed(Nu.cn.sankey, true).style("box-sizing", "content-box").style("position", "absolute").style("left", 0).style("shape-rendering", "geometricPrecision").style("pointer-events", a ? "none" : "auto").attr("transform", nXe), u.each(function(b, p) {
+            e._fullData[p]._sankey = b;
+            var k = "bgsankey-" + b.trace.uid + "-" + p;
+            w1.ensureSingle(e._fullLayout._draggers, "rect", k), e._fullData[p]._bgRect = O5.select("." + k), e._fullData[p]._bgRect.style("pointer-events", a ? "none" : "all").attr("width", b.width).attr("height", b.height).attr("x", b.translateX).attr("y", b.translateY).classed("bgsankey", true).style({ fill: "transparent", "stroke-width": 0 });
+          }), u.transition().ease(Nu.ease).duration(Nu.duration).attr("transform", nXe);
+          var c = u.selectAll("." + Nu.cn.sankeyLinks).data(P7, oC);
+          c.enter().append("g").classed(Nu.cn.sankeyLinks, true).style("fill", "none");
+          var f = c.selectAll("." + Nu.cn.sankeyLink).data(function(b) {
+            var p = b.graph.links;
+            return p.filter(function(k) {
+              return k.value;
+            }).map(rYt.bind(null, b));
+          }, oC);
+          f.enter().append("path").classed(Nu.cn.sankeyLink, true).call(aXe, u, i.linkEvents), f.style("stroke", function(b) {
+            return e$(b) ? gw.tinyRGB(q5(b.linkLineColor)) : b.tinyColorHue;
+          }).style("stroke-opacity", function(b) {
+            return e$(b) ? gw.opacity(b.linkLineColor) : b.tinyColorAlpha;
+          }).style("fill", function(b) {
+            return b.tinyColorHue;
+          }).style("fill-opacity", function(b) {
+            return b.tinyColorAlpha;
+          }).style("stroke-width", function(b) {
+            return e$(b) ? b.linkLineWidth : 1;
+          }).attr("d", n$()), f.style("opacity", function() {
+            return e._context.staticPlot || o || s ? 1 : 0;
+          }).transition().ease(Nu.ease).duration(Nu.duration).style("opacity", 1), f.exit().transition().ease(Nu.ease).duration(Nu.duration).style("opacity", 0).remove();
+          var h = u.selectAll("." + Nu.cn.sankeyNodeSet).data(P7, oC);
+          h.enter().append("g").classed(Nu.cn.sankeyNodeSet, true), h.style("cursor", function(b) {
+            switch (b.arrangement) {
+              case "fixed":
+                return "default";
+              case "perpendicular":
+                return "ns-resize";
+              default:
+                return "move";
+            }
+          });
+          var d = h.selectAll("." + Nu.cn.sankeyNode).data(function(b) {
+            var p = b.graph.nodes;
+            return cYt(p), p.map(nYt.bind(null, b));
+          }, oC);
+          d.enter().append("g").classed(Nu.cn.sankeyNode, true).call(t$).style("opacity", function(b) {
+            return (e._context.staticPlot || o) && !b.partOfGroup ? 1 : 0;
+          }), d.call(aXe, u, i.nodeEvents).call(oYt, f, i, e), d.transition().ease(Nu.ease).duration(Nu.duration).call(t$).style("opacity", function(b) {
+            return b.partOfGroup ? 0 : 1;
+          }), d.exit().transition().ease(Nu.ease).duration(Nu.duration).style("opacity", 0).remove();
+          var v = d.selectAll("." + Nu.cn.nodeRect).data(P7);
+          v.enter().append("rect").classed(Nu.cn.nodeRect, true).call(iXe), v.style("stroke-width", function(b) {
+            return b.nodeLineWidth;
+          }).style("stroke", function(b) {
+            return gw.tinyRGB(q5(b.nodeLineColor));
+          }).style("stroke-opacity", function(b) {
+            return gw.opacity(b.nodeLineColor);
+          }).style("fill", function(b) {
+            return b.tinyColorHue;
+          }).style("fill-opacity", function(b) {
+            return b.tinyColorAlpha;
+          }), v.transition().ease(Nu.ease).duration(Nu.duration).call(iXe);
+          var _ = d.selectAll("." + Nu.cn.nodeLabel).data(P7);
+          _.enter().append("text").classed(Nu.cn.nodeLabel, true).style("cursor", "default"), _.attr("data-notex", 1).text(function(b) {
+            return b.node.label;
+          }).each(function(b) {
+            var p = O5.select(this);
+            YZt.font(p, b.textFont), rXe.convertToTspans(p, e);
+          }).attr("text-anchor", function(b) {
+            return b.horizontal && b.left ? "end" : "start";
+          }).attr("transform", function(b) {
+            var p = O5.select(this), k = rXe.lineCount(p), E = b.textFont.size * ((k - 1) * QZt - $Zt), T = b.nodeLineWidth / 2 + eYt, L = ((b.horizontal ? b.visibleHeight : b.visibleWidth) - E) / 2;
+            b.horizontal && (b.left ? T = -T : T += b.visibleWidth);
+            var x = b.horizontal ? "" : "scale(-1,1)" + KZt(90);
+            return r$(b.horizontal ? T : L, b.horizontal ? L : T) + x;
+          }), _.transition().ease(Nu.ease).duration(Nu.duration);
+        };
+      });
+      var s$ = ye((v2r, wXe) => {
+        var Zv = Oa(), o$ = Dr(), I7 = o$.numberFormat, dYt = dXe(), B5 = vf(), vYt = ka(), Dx = QJ().cn, sC = o$._;
+        function vXe(e) {
+          return e !== "";
+        }
+        function N5(e, t) {
+          return e.filter(function(r) {
+            return r.key === t.traceId;
+          });
+        }
+        function pXe(e, t) {
+          Zv.select(e).select("path").style("fill-opacity", t), Zv.select(e).select("rect").style("fill-opacity", t);
+        }
+        function gXe(e) {
+          Zv.select(e).select("text.name").style("fill", "black");
+        }
+        function mXe(e) {
+          return function(t) {
+            return e.node.sourceLinks.indexOf(t.link) !== -1 || e.node.targetLinks.indexOf(t.link) !== -1;
+          };
+        }
+        function yXe(e) {
+          return function(t) {
+            return t.node.sourceLinks.indexOf(e.link) !== -1 || t.node.targetLinks.indexOf(e.link) !== -1;
+          };
+        }
+        function _Xe(e, t, r) {
+          t && r && N5(r, t).selectAll("." + Dx.sankeyLink).filter(mXe(t)).call(xXe.bind(0, t, r, false));
+        }
+        function a$(e, t, r) {
+          t && r && N5(r, t).selectAll("." + Dx.sankeyLink).filter(mXe(t)).call(bXe.bind(0, t, r, false));
+        }
+        function xXe(e, t, r, n) {
+          n.style("fill", function(i) {
+            if (!i.link.concentrationscale) return i.tinyColorHoverHue;
+          }).style("fill-opacity", function(i) {
+            if (!i.link.concentrationscale) return i.tinyColorHoverAlpha;
+          }), n.each(function(i) {
+            var a = i.link.label;
+            a !== "" && N5(t, e).selectAll("." + Dx.sankeyLink).filter(function(o) {
+              return o.link.label === a;
+            }).style("fill", function(o) {
+              if (!o.link.concentrationscale) return o.tinyColorHoverHue;
+            }).style("fill-opacity", function(o) {
+              if (!o.link.concentrationscale) return o.tinyColorHoverAlpha;
+            });
+          }), r && N5(t, e).selectAll("." + Dx.sankeyNode).filter(yXe(e)).call(_Xe);
+        }
+        function bXe(e, t, r, n) {
+          n.style("fill", function(i) {
+            return i.tinyColorHue;
+          }).style("fill-opacity", function(i) {
+            return i.tinyColorAlpha;
+          }), n.each(function(i) {
+            var a = i.link.label;
+            a !== "" && N5(t, e).selectAll("." + Dx.sankeyLink).filter(function(o) {
+              return o.link.label === a;
+            }).style("fill", function(o) {
+              return o.tinyColorHue;
+            }).style("fill-opacity", function(o) {
+              return o.tinyColorAlpha;
+            });
+          }), r && N5(t, e).selectAll(Dx.sankeyNode).filter(yXe(e)).call(a$);
+        }
+        function kf(e, t) {
+          var r = e.hoverlabel || {}, n = o$.nestedProperty(r, t).get();
+          return Array.isArray(n) ? false : n;
+        }
+        wXe.exports = function(t, r) {
+          for (var n = t._fullLayout, i = n._paper, a = n._size, o = 0; o < t._fullData.length; o++) if (t._fullData[o].visible && t._fullData[o].type === Dx.sankey && !t._fullData[o]._viewInitial) {
+            var s = t._fullData[o].node;
+            t._fullData[o]._viewInitial = { node: { groups: s.groups.slice(), x: s.x.slice(), y: s.y.slice() } };
+          }
+          var l = function(L, x) {
+            var C = x.link;
+            C.originalEvent = Zv.event, t._hoverdata = [C], B5.click(t, { target: true });
+          }, u = function(L, x, C) {
+            t._fullLayout.hovermode !== false && (Zv.select(L).call(xXe.bind(0, x, C, true)), x.link.trace.link.hoverinfo !== "skip" && (x.link.fullData = x.link.trace, t.emit("plotly_hover", { event: Zv.event, points: [x.link] })));
+          }, c = sC(t, "source:") + " ", f = sC(t, "target:") + " ", h = sC(t, "concentration:") + " ", d = sC(t, "incoming flow count:") + " ", v = sC(t, "outgoing flow count:") + " ", _ = function(L, x) {
+            if (t._fullLayout.hovermode === false) return;
+            var C = x.link.trace.link;
+            if (C.hoverinfo === "none" || C.hoverinfo === "skip") return;
+            var M = [];
+            function g(Z) {
+              var j, N;
+              Z.circular ? (j = (Z.circularPathData.leftInnerExtent + Z.circularPathData.rightInnerExtent) / 2, N = Z.circularPathData.verticalFullExtent) : (j = (Z.source.x1 + Z.target.x0) / 2, N = (Z.y0 + Z.y1) / 2);
+              var H = [j, N];
+              return Z.trace.orientation === "v" && H.reverse(), H[0] += x.parent.translateX, H[1] += x.parent.translateY, H;
+            }
+            for (var P = 0, A = 0; A < x.flow.links.length; A++) {
+              var z = x.flow.links[A];
+              if (!(t._fullLayout.hovermode === "closest" && x.link.pointNumber !== z.pointNumber)) {
+                x.link.pointNumber === z.pointNumber && (P = A), z.fullData = z.trace, C = x.link.trace.link;
+                var O = g(z), U = { valueLabel: I7(x.valueFormat)(z.value) + x.valueSuffix };
+                M.push({ x: O[0], y: O[1], name: U.valueLabel, text: [z.label || "", c + z.source.label, f + z.target.label, z.concentrationscale ? h + I7("%0.2f")(z.flow.labelConcentration) : ""].filter(vXe).join("<br>"), color: kf(C, "bgcolor") || vYt.addOpacity(z.color, 1), borderColor: kf(C, "bordercolor"), fontFamily: kf(C, "font.family"), fontSize: kf(C, "font.size"), fontColor: kf(C, "font.color"), fontWeight: kf(C, "font.weight"), fontStyle: kf(C, "font.style"), fontVariant: kf(C, "font.variant"), fontTextcase: kf(C, "font.textcase"), fontLineposition: kf(C, "font.lineposition"), fontShadow: kf(C, "font.shadow"), nameLength: kf(C, "namelength"), textAlign: kf(C, "align"), idealAlign: Zv.event.x < O[0] ? "right" : "left", hovertemplate: C.hovertemplate, hovertemplateLabels: U, eventData: [z] });
+              }
+            }
+            var G = B5.loneHover(M, { container: n._hoverlayer.node(), outerContainer: n._paper.node(), gd: t, anchorIndex: P });
+            G.each(function() {
+              var Z = this;
+              x.link.concentrationscale || pXe(Z, 0.65), gXe(Z);
+            });
+          }, b = function(L, x, C) {
+            t._fullLayout.hovermode !== false && (Zv.select(L).call(bXe.bind(0, x, C, true)), x.link.trace.link.hoverinfo !== "skip" && (x.link.fullData = x.link.trace, t.emit("plotly_unhover", { event: Zv.event, points: [x.link] })), B5.loneUnhover(n._hoverlayer.node()));
+          }, p = function(L, x, C) {
+            var M = x.node;
+            M.originalEvent = Zv.event, t._hoverdata = [M], Zv.select(L).call(a$, x, C), B5.click(t, { target: true });
+          }, k = function(L, x, C) {
+            t._fullLayout.hovermode !== false && (Zv.select(L).call(_Xe, x, C), x.node.trace.node.hoverinfo !== "skip" && (x.node.fullData = x.node.trace, t.emit("plotly_hover", { event: Zv.event, points: [x.node] })));
+          }, E = function(L, x) {
+            if (t._fullLayout.hovermode !== false) {
+              var C = x.node.trace.node;
+              if (!(C.hoverinfo === "none" || C.hoverinfo === "skip")) {
+                var M = Zv.select(L).select("." + Dx.nodeRect), g = t._fullLayout._paperdiv.node().getBoundingClientRect(), P = M.node().getBoundingClientRect(), A = P.left - 2 - g.left, z = P.right + 2 - g.left, O = P.top + P.height / 4 - g.top, U = { valueLabel: I7(x.valueFormat)(x.node.value) + x.valueSuffix };
+                x.node.fullData = x.node.trace, t._fullLayout._calcInverseTransform(t);
+                var G = t._fullLayout._invScaleX, Z = t._fullLayout._invScaleY, j = B5.loneHover({ x0: G * A, x1: G * z, y: Z * O, name: I7(x.valueFormat)(x.node.value) + x.valueSuffix, text: [x.node.label, d + x.node.targetLinks.length, v + x.node.sourceLinks.length].filter(vXe).join("<br>"), color: kf(C, "bgcolor") || x.tinyColorHue, borderColor: kf(C, "bordercolor"), fontFamily: kf(C, "font.family"), fontSize: kf(C, "font.size"), fontColor: kf(C, "font.color"), fontWeight: kf(C, "font.weight"), fontStyle: kf(C, "font.style"), fontVariant: kf(C, "font.variant"), fontTextcase: kf(C, "font.textcase"), fontLineposition: kf(C, "font.lineposition"), fontShadow: kf(C, "font.shadow"), nameLength: kf(C, "namelength"), textAlign: kf(C, "align"), idealAlign: "left", hovertemplate: C.hovertemplate, hovertemplateLabels: U, eventData: [x.node] }, { container: n._hoverlayer.node(), outerContainer: n._paper.node(), gd: t });
+                pXe(j, 0.85), gXe(j);
+              }
+            }
+          }, T = function(L, x, C) {
+            t._fullLayout.hovermode !== false && (Zv.select(L).call(a$, x, C), x.node.trace.node.hoverinfo !== "skip" && (x.node.fullData = x.node.trace, t.emit("plotly_unhover", { event: Zv.event, points: [x.node] })), B5.loneUnhover(n._hoverlayer.node()));
+          };
+          dYt(t, i, r, { width: a.w, height: a.h, margin: { t: a.t, r: a.r, b: a.b, l: a.l } }, { linkEvents: { hover: u, follow: _, unhover: b, select: l }, nodeEvents: { hover: k, follow: E, unhover: T, select: p } });
+        };
+      });
+      var TXe = ye((mw) => {
+        var pYt = mc().overrideAll, gYt = Id().getModuleCalcData, mYt = s$(), yYt = W1(), _Yt = Eg(), xYt = yv(), bYt = Of().prepSelect, l$ = Dr(), wYt = qa(), R7 = "sankey";
+        mw.name = R7;
+        mw.baseLayoutAttrOverrides = pYt({ hoverlabel: yYt.hoverlabel }, "plot", "nested");
+        mw.plot = function(e) {
+          var t = gYt(e.calcdata, R7)[0];
+          mYt(e, t), mw.updateFx(e);
+        };
+        mw.clean = function(e, t, r, n) {
+          var i = n._has && n._has(R7), a = t._has && t._has(R7);
+          i && !a && (n._paperdiv.selectAll(".sankey").remove(), n._paperdiv.selectAll(".bgsankey").remove());
+        };
+        mw.updateFx = function(e) {
+          for (var t = 0; t < e._fullData.length; t++) TYt(e, t);
+        };
+        function TYt(e, t) {
+          var r = e._fullData[t], n = e._fullLayout, i = n.dragmode, a = n.dragmode === "pan" ? "move" : "crosshair", o = r._bgRect;
+          if (o && !(i === "pan" || i === "zoom")) {
+            _Yt(o, a);
+            var s = { _id: "x", c2p: l$.identity, _offset: r._sankey.translateX, _length: r._sankey.width }, l = { _id: "y", c2p: l$.identity, _offset: r._sankey.translateY, _length: r._sankey.height }, u = { gd: e, element: o.node(), plotinfo: { id: t, xaxis: s, yaxis: l, fillRangeItems: l$.noop }, subplot: t, xaxes: [s], yaxes: [l], doneFnCompleted: function(c) {
+              var f = e._fullData[t], h, d = f.node.groups.slice(), v = [];
+              function _(E) {
+                for (var T = f._sankey.graph.nodes, L = 0; L < T.length; L++) if (T[L].pointNumber === E) return T[L];
+              }
+              for (var b = 0; b < c.length; b++) {
+                var p = _(c[b].pointNumber);
+                if (p) if (p.group) {
+                  for (var k = 0; k < p.childrenNodes.length; k++) v.push(p.childrenNodes[k].pointNumber);
+                  d[p.pointNumber - f.node._count] = false;
+                } else v.push(p.pointNumber);
+              }
+              h = d.filter(Boolean).concat([v]), wYt.call("_guiRestyle", e, { "node.groups": [h] }, t);
+            } };
+            u.prepFn = function(c, f, h) {
+              bYt(c, f, h, u, i);
+            }, xYt.init(u);
+          }
+        }
+      });
+      var SXe = ye((g2r, AXe) => {
+        AXe.exports = function(t, r) {
+          for (var n = t.cd, i = [], a = n[0].trace, o = a._sankey.graph.nodes, s = 0; s < o.length; s++) {
+            var l = o[s];
+            if (!l.partOfGroup) {
+              var u = [(l.x0 + l.x1) / 2, (l.y0 + l.y1) / 2];
+              a.orientation === "v" && u.reverse(), r && r.contains(u, false, s, t) && i.push({ pointNumber: l.pointNumber });
+            }
+          }
+          return i;
+        };
+      });
+      var EXe = ye((m2r, MXe) => {
+        MXe.exports = { attributes: KJ(), supplyDefaults: LWe(), calc: FWe(), plot: s$(), moduleType: "trace", name: "sankey", basePlotModule: TXe(), selectPoints: SXe(), categories: ["noOpacity"], meta: {} };
+      });
+      var CXe = ye((y2r, kXe) => {
+        kXe.exports = EXe();
+      });
+      var PXe = ye((U5) => {
+        var LXe = Mc();
+        U5.name = "indicator";
+        U5.plot = function(e, t, r, n) {
+          LXe.plotBasePlot(U5.name, e, t, r, n);
+        };
+        U5.clean = function(e, t, r, n) {
+          LXe.cleanBasePlot(U5.name, e, t, r, n);
+        };
+      });
+      var c$ = ye((x2r, OXe) => {
+        var Fx = Ao().extendFlat, RXe = Ao().extendDeep, AYt = mc().overrideAll, DXe = ec(), FXe = Ih(), SYt = Cc().attributes, Nf = Rd(), MYt = vl().templatedArray, D7 = JT(), IXe = df().descriptionOnlyNumbers, u$ = DXe({ editType: "plot", colorEditType: "plot" }), lC = { color: { valType: "color", editType: "plot" }, line: { color: { valType: "color", dflt: FXe.defaultLine, editType: "plot" }, width: { valType: "number", min: 0, dflt: 0, editType: "plot" }, editType: "calc" }, thickness: { valType: "number", min: 0, max: 1, dflt: 1, editType: "plot" }, editType: "calc" }, zXe = { valType: "info_array", items: [{ valType: "number", editType: "plot" }, { valType: "number", editType: "plot" }], editType: "plot" }, EYt = MYt("step", RXe({}, lC, { range: zXe }));
+        OXe.exports = { mode: { valType: "flaglist", editType: "calc", flags: ["number", "delta", "gauge"], dflt: "number" }, value: { valType: "number", editType: "calc", anim: true }, align: { valType: "enumerated", values: ["left", "center", "right"], editType: "plot" }, domain: SYt({ name: "indicator", trace: true, editType: "calc" }), title: { text: { valType: "string", editType: "plot" }, align: { valType: "enumerated", values: ["left", "center", "right"], editType: "plot" }, font: Fx({}, u$, {}), editType: "plot" }, number: { valueformat: { valType: "string", dflt: "", editType: "plot", description: IXe("value") }, font: Fx({}, u$, {}), prefix: { valType: "string", dflt: "", editType: "plot" }, suffix: { valType: "string", dflt: "", editType: "plot" }, editType: "plot" }, delta: { reference: { valType: "number", editType: "calc" }, position: { valType: "enumerated", values: ["top", "bottom", "left", "right"], dflt: "bottom", editType: "plot" }, relative: { valType: "boolean", editType: "plot", dflt: false }, valueformat: { valType: "string", editType: "plot", description: IXe("value") }, increasing: { symbol: { valType: "string", dflt: D7.INCREASING.SYMBOL, editType: "plot" }, color: { valType: "color", dflt: D7.INCREASING.COLOR, editType: "plot" }, editType: "plot" }, decreasing: { symbol: { valType: "string", dflt: D7.DECREASING.SYMBOL, editType: "plot" }, color: { valType: "color", dflt: D7.DECREASING.COLOR, editType: "plot" }, editType: "plot" }, font: Fx({}, u$, {}), prefix: { valType: "string", dflt: "", editType: "plot" }, suffix: { valType: "string", dflt: "", editType: "plot" }, editType: "calc" }, gauge: { shape: { valType: "enumerated", editType: "plot", dflt: "angular", values: ["angular", "bullet"] }, bar: RXe({}, lC, { color: { dflt: "green" } }), bgcolor: { valType: "color", editType: "plot" }, bordercolor: { valType: "color", dflt: FXe.defaultLine, editType: "plot" }, borderwidth: { valType: "number", min: 0, dflt: 1, editType: "plot" }, axis: AYt({ range: zXe, visible: Fx({}, Nf.visible, { dflt: true }), tickmode: Nf.minor.tickmode, nticks: Nf.nticks, tick0: Nf.tick0, dtick: Nf.dtick, tickvals: Nf.tickvals, ticktext: Nf.ticktext, ticks: Fx({}, Nf.ticks, { dflt: "outside" }), ticklen: Nf.ticklen, tickwidth: Nf.tickwidth, tickcolor: Nf.tickcolor, ticklabelstep: Nf.ticklabelstep, showticklabels: Nf.showticklabels, labelalias: Nf.labelalias, tickfont: DXe({}), tickangle: Nf.tickangle, tickformat: Nf.tickformat, tickformatstops: Nf.tickformatstops, tickprefix: Nf.tickprefix, showtickprefix: Nf.showtickprefix, ticksuffix: Nf.ticksuffix, showticksuffix: Nf.showticksuffix, separatethousands: Nf.separatethousands, exponentformat: Nf.exponentformat, minexponent: Nf.minexponent, showexponent: Nf.showexponent, editType: "plot" }, "plot"), steps: EYt, threshold: { line: { color: Fx({}, lC.line.color, {}), width: Fx({}, lC.line.width, { dflt: 1 }), editType: "plot" }, thickness: Fx({}, lC.thickness, { dflt: 0.85 }), value: { valType: "number", editType: "calc", dflt: false }, editType: "plot" }, editType: "plot" } };
+      });
+      var f$ = ye((b2r, qXe) => {
+        qXe.exports = { defaultNumberFontSize: 80, bulletNumberDomainSize: 0.25, bulletPadding: 0.025, innerRadius: 0.75, valueThickness: 0.5, titlePadding: 5, horizontalPadding: 10 };
+      });
+      var UXe = ye((w2r, NXe) => {
+        var sy = Dr(), z7 = c$(), kYt = Cc().defaults, BXe = vl(), CYt = Zd(), F7 = f$(), LYt = Lb(), PYt = F3(), IYt = s_(), RYt = l_();
+        function DYt(e, t, r, n) {
+          function i(x, C) {
+            return sy.coerce(e, t, z7, x, C);
+          }
+          kYt(t, n, i), i("mode"), t._hasNumber = t.mode.indexOf("number") !== -1, t._hasDelta = t.mode.indexOf("delta") !== -1, t._hasGauge = t.mode.indexOf("gauge") !== -1;
+          var a = i("value");
+          t._range = [0, typeof a == "number" ? 1.5 * a : 1];
+          var o = new Array(2), s;
+          if (t._hasNumber) {
+            i("number.valueformat");
+            var l = sy.extendFlat({}, n.font);
+            l.size = void 0, sy.coerceFont(i, "number.font", l), t.number.font.size === void 0 && (t.number.font.size = F7.defaultNumberFontSize, o[0] = true), i("number.prefix"), i("number.suffix"), s = t.number.font.size;
+          }
+          var u;
+          if (t._hasDelta) {
+            var c = sy.extendFlat({}, n.font);
+            c.size = void 0, sy.coerceFont(i, "delta.font", c), t.delta.font.size === void 0 && (t.delta.font.size = (t._hasNumber ? 0.5 : 1) * (s || F7.defaultNumberFontSize), o[1] = true), i("delta.reference", t.value), i("delta.relative"), i("delta.valueformat", t.delta.relative ? "2%" : ""), i("delta.increasing.symbol"), i("delta.increasing.color"), i("delta.decreasing.symbol"), i("delta.decreasing.color"), i("delta.position"), i("delta.prefix"), i("delta.suffix"), u = t.delta.font.size;
+          }
+          t._scaleNumbers = (!t._hasNumber || o[0]) && (!t._hasDelta || o[1]) || false;
+          var f = sy.extendFlat({}, n.font);
+          f.size = 0.25 * (s || u || F7.defaultNumberFontSize), sy.coerceFont(i, "title.font", f), i("title.text");
+          var h, d, v, _;
+          function b(x, C) {
+            return sy.coerce(h, d, z7.gauge, x, C);
+          }
+          function p(x, C) {
+            return sy.coerce(v, _, z7.gauge.axis, x, C);
+          }
+          if (t._hasGauge) {
+            h = e.gauge, h || (h = {}), d = BXe.newContainer(t, "gauge"), b("shape");
+            var k = t._isBullet = t.gauge.shape === "bullet";
+            k || i("title.align", "center");
+            var E = t._isAngular = t.gauge.shape === "angular";
+            E || i("align", "center"), b("bgcolor", n.paper_bgcolor), b("borderwidth"), b("bordercolor"), b("bar.color"), b("bar.line.color"), b("bar.line.width");
+            var T = F7.valueThickness * (t.gauge.shape === "bullet" ? 0.5 : 1);
+            b("bar.thickness", T), CYt(h, d, { name: "steps", handleItemDefaults: FYt }), b("threshold.value"), b("threshold.thickness"), b("threshold.line.width"), b("threshold.line.color"), v = {}, h && (v = h.axis || {}), _ = BXe.newContainer(d, "axis"), p("visible"), t._range = p("range", t._range);
+            var L = { font: n.font, noAutotickangles: true, outerTicks: true, noTicklabelshift: true, noTicklabelstandoff: true };
+            LYt(v, _, p, "linear"), RYt(v, _, p, "linear", L), IYt(v, _, p, "linear", L), PYt(v, _, p, L);
+          } else i("title.align", "center"), i("align", "center"), t._isAngular = t._isBullet = false;
+          t._length = null;
+        }
+        function FYt(e, t) {
+          function r(n, i) {
+            return sy.coerce(e, t, z7.gauge.steps, n, i);
+          }
+          r("color"), r("line.color"), r("line.width"), r("range"), r("thickness");
+        }
+        NXe.exports = { supplyDefaults: DYt };
+      });
+      var GXe = ye((T2r, VXe) => {
+        function zYt(e, t) {
+          var r = [], n = t.value;
+          typeof t._lastValue != "number" && (t._lastValue = t.value);
+          var i = t._lastValue, a = i;
+          return t._hasDelta && typeof t.delta.reference == "number" && (a = t.delta.reference), r[0] = { y: n, lastY: i, delta: n - a, relativeDelta: (n - a) / a }, r;
+        }
+        VXe.exports = { calc: zYt };
+      });
+      var YXe = ye((A2r, ZXe) => {
+        var ww = Oa(), OYt = (H2(), pb(G2)).interpolate, HXe = (H2(), pb(G2)).interpolateNumber, zx = Dr(), qYt = zx.strScale, cC = zx.strTranslate, BYt = zx.rad2deg, NYt = Dh().MID_SHIFT, bw = So(), yw = f$(), q7 = Zl(), sv = ho(), UYt = f4(), VYt = dI(), GYt = Rd(), V5 = ka(), h$ = { left: "start", center: "middle", right: "end" }, _w = { left: 0, center: 0.5, right: 1 }, jXe = /[yzafpnµmkMGTPEZY]/;
+        function fC(e) {
+          return e && e.duration > 0;
+        }
+        ZXe.exports = function(t, r, n, i) {
+          var a = t._fullLayout, o;
+          fC(n) && i && (o = i()), zx.makeTraceGroups(a._indicatorlayer, r, "trace").each(function(s) {
+            var l = s[0], u = l.trace, c = ww.select(this), f = u._hasGauge, h = u._isAngular, d = u._isBullet, v = u.domain, _ = { w: a._size.w * (v.x[1] - v.x[0]), h: a._size.h * (v.y[1] - v.y[0]), l: a._size.l + a._size.w * v.x[0], r: a._size.r + a._size.w * (1 - v.x[1]), t: a._size.t + a._size.h * (1 - v.y[1]), b: a._size.b + a._size.h * v.y[0] }, b = _.l + _.w / 2, p = _.t + _.h / 2, k = Math.min(_.w / 2, _.h), E = yw.innerRadius * k, T, L, x, C = u.align || "center";
+            if (L = p, !f) T = _.l + _w[C] * _.w, x = function(j) {
+              return WXe(j, _.w, _.h);
+            };
+            else if (h && (T = b, L = p + k / 2, x = function(j) {
+              return ZYt(j, 0.9 * E);
+            }), d) {
+              var M = yw.bulletPadding, g = 1 - yw.bulletNumberDomainSize + M;
+              T = _.l + (g + (1 - g) * _w[C]) * _.w, x = function(j) {
+                return WXe(j, (yw.bulletNumberDomainSize - M) * _.w, _.h);
+              };
+            }
+            WYt(t, c, s, { numbersX: T, numbersY: L, numbersScaler: x, transitionOpts: n, onComplete: o });
+            var P, A;
+            f && (P = { range: u.gauge.axis.range, color: u.gauge.bgcolor, line: { color: u.gauge.bordercolor, width: 0 }, thickness: 1 }, A = { range: u.gauge.axis.range, color: "rgba(0, 0, 0, 0)", line: { color: u.gauge.bordercolor, width: u.gauge.borderwidth }, thickness: 1 });
+            var z = c.selectAll("g.angular").data(h ? s : []);
+            z.exit().remove();
+            var O = c.selectAll("g.angularaxis").data(h ? s : []);
+            O.exit().remove(), h && jYt(t, c, s, { radius: k, innerRadius: E, gauge: z, layer: O, size: _, gaugeBg: P, gaugeOutline: A, transitionOpts: n, onComplete: o });
+            var U = c.selectAll("g.bullet").data(d ? s : []);
+            U.exit().remove();
+            var G = c.selectAll("g.bulletaxis").data(d ? s : []);
+            G.exit().remove(), d && HYt(t, c, s, { gauge: U, layer: G, size: _, gaugeBg: P, gaugeOutline: A, transitionOpts: n, onComplete: o });
+            var Z = c.selectAll("text.title").data(s);
+            Z.exit().remove(), Z.enter().append("text").classed("title", true), Z.attr("text-anchor", function() {
+              return d ? h$.right : h$[u.title.align];
+            }).text(u.title.text).call(bw.font, u.title.font).call(q7.convertToTspans, t), Z.attr("transform", function() {
+              var j = _.l + _.w * _w[u.title.align], N, H = yw.titlePadding, re = bw.bBox(Z.node());
+              if (f) {
+                if (h) if (u.gauge.axis.visible) {
+                  var oe = bw.bBox(O.node());
+                  N = oe.top - H - re.bottom;
+                } else N = _.t + _.h / 2 - k / 2 - re.bottom - H;
+                d && (N = L - (re.top + re.bottom) / 2, j = _.l - yw.bulletPadding * _.w);
+              } else N = u._numbersTop - H - re.bottom;
+              return cC(j, N);
+            });
+          });
+        };
+        function HYt(e, t, r, n) {
+          var i = r[0].trace, a = n.gauge, o = n.layer, s = n.gaugeBg, l = n.gaugeOutline, u = n.size, c = i.domain, f = n.transitionOpts, h = n.onComplete, d, v, _, b, p;
+          a.enter().append("g").classed("bullet", true), a.attr("transform", cC(u.l, u.t)), o.enter().append("g").classed("bulletaxis", true).classed("crisp", true), o.selectAll("g.xbulletaxistick,path,text").remove();
+          var k = u.h, E = i.gauge.bar.thickness * k, T = c.x[0], L = c.x[0] + (c.x[1] - c.x[0]) * (i._hasNumber || i._hasDelta ? 1 - yw.bulletNumberDomainSize : 1);
+          d = uC(e, i.gauge.axis), d._id = "xbulletaxis", d.domain = [T, L], d.setScale(), v = sv.calcTicks(d), _ = sv.makeTransTickFn(d), b = sv.getTickSigns(d)[2], p = u.t + u.h, d.visible && (sv.drawTicks(e, d, { vals: d.ticks === "inside" ? sv.clipEnds(d, v) : v, layer: o, path: sv.makeTickPath(d, p, b), transFn: _ }), sv.drawLabels(e, d, { vals: v, layer: o, transFn: _, labelFns: sv.makeLabelFns(d, p) }));
+          function x(O) {
+            O.attr("width", function(U) {
+              return Math.max(0, d.c2p(U.range[1]) - d.c2p(U.range[0]));
+            }).attr("x", function(U) {
+              return d.c2p(U.range[0]);
+            }).attr("y", function(U) {
+              return 0.5 * (1 - U.thickness) * k;
+            }).attr("height", function(U) {
+              return U.thickness * k;
+            });
+          }
+          var C = [s].concat(i.gauge.steps), M = a.selectAll("g.bg-bullet").data(C);
+          M.enter().append("g").classed("bg-bullet", true).append("rect"), M.select("rect").call(x).call(xw), M.exit().remove();
+          var g = a.selectAll("g.value-bullet").data([i.gauge.bar]);
+          g.enter().append("g").classed("value-bullet", true).append("rect"), g.select("rect").attr("height", E).attr("y", (k - E) / 2).call(xw), fC(f) ? g.select("rect").transition().duration(f.duration).ease(f.easing).each("end", function() {
+            h && h();
+          }).each("interrupt", function() {
+            h && h();
+          }).attr("width", Math.max(0, d.c2p(Math.min(i.gauge.axis.range[1], r[0].y)))) : g.select("rect").attr("width", typeof r[0].y == "number" ? Math.max(0, d.c2p(Math.min(i.gauge.axis.range[1], r[0].y))) : 0), g.exit().remove();
+          var P = r.filter(function() {
+            return i.gauge.threshold.value || i.gauge.threshold.value === 0;
+          }), A = a.selectAll("g.threshold-bullet").data(P);
+          A.enter().append("g").classed("threshold-bullet", true).append("line"), A.select("line").attr("x1", d.c2p(i.gauge.threshold.value)).attr("x2", d.c2p(i.gauge.threshold.value)).attr("y1", (1 - i.gauge.threshold.thickness) / 2 * k).attr("y2", (1 - (1 - i.gauge.threshold.thickness) / 2) * k).call(V5.stroke, i.gauge.threshold.line.color).style("stroke-width", i.gauge.threshold.line.width), A.exit().remove();
+          var z = a.selectAll("g.gauge-outline").data([l]);
+          z.enter().append("g").classed("gauge-outline", true).append("rect"), z.select("rect").call(x).call(xw), z.exit().remove();
+        }
+        function jYt(e, t, r, n) {
+          var i = r[0].trace, a = n.size, o = n.radius, s = n.innerRadius, l = n.gaugeBg, u = n.gaugeOutline, c = [a.l + a.w / 2, a.t + a.h / 2 + o / 2], f = n.gauge, h = n.layer, d = n.transitionOpts, v = n.onComplete, _ = Math.PI / 2;
+          function b(_e) {
+            var Ce = i.gauge.axis.range[0], Le = i.gauge.axis.range[1], ge = (_e - Ce) / (Le - Ce) * Math.PI - _;
+            return ge < -_ ? -_ : ge > _ ? _ : ge;
+          }
+          function p(_e) {
+            return ww.svg.arc().innerRadius((s + o) / 2 - _e / 2 * (o - s)).outerRadius((s + o) / 2 + _e / 2 * (o - s)).startAngle(-_);
+          }
+          function k(_e) {
+            _e.attr("d", function(Ce) {
+              return p(Ce.thickness).startAngle(b(Ce.range[0])).endAngle(b(Ce.range[1]))();
+            });
+          }
+          var E, T, L, x;
+          f.enter().append("g").classed("angular", true), f.attr("transform", cC(c[0], c[1])), h.enter().append("g").classed("angularaxis", true).classed("crisp", true), h.selectAll("g.xangularaxistick,path,text").remove(), E = uC(e, i.gauge.axis), E.type = "linear", E.range = i.gauge.axis.range, E._id = "xangularaxis", E.ticklabeloverflow = "allow", E.setScale();
+          var C = function(_e) {
+            return (E.range[0] - _e.x) / (E.range[1] - E.range[0]) * Math.PI + Math.PI;
+          }, M = {}, g = sv.makeLabelFns(E, 0), P = g.labelStandoff;
+          M.xFn = function(_e) {
+            var Ce = C(_e);
+            return Math.cos(Ce) * P;
+          }, M.yFn = function(_e) {
+            var Ce = C(_e), Le = Math.sin(Ce) > 0 ? 0.2 : 1;
+            return -Math.sin(Ce) * (P + _e.fontSize * Le) + Math.abs(Math.cos(Ce)) * (_e.fontSize * NYt);
+          }, M.anchorFn = function(_e) {
+            var Ce = C(_e), Le = Math.cos(Ce);
+            return Math.abs(Le) < 0.1 ? "middle" : Le > 0 ? "start" : "end";
+          }, M.heightFn = function(_e, Ce, Le) {
+            var ge = C(_e);
+            return -0.5 * (1 + Math.sin(ge)) * Le;
+          };
+          var A = function(_e) {
+            return cC(c[0] + o * Math.cos(_e), c[1] - o * Math.sin(_e));
+          };
+          L = function(_e) {
+            return A(C(_e));
+          };
+          var z = function(_e) {
+            var Ce = C(_e);
+            return A(Ce) + "rotate(" + -BYt(Ce) + ")";
+          };
+          if (T = sv.calcTicks(E), x = sv.getTickSigns(E)[2], E.visible) {
+            x = E.ticks === "inside" ? -1 : 1;
+            var O = (E.linewidth || 1) / 2;
+            sv.drawTicks(e, E, { vals: T, layer: h, path: "M" + x * O + ",0h" + x * E.ticklen, transFn: z }), sv.drawLabels(e, E, { vals: T, layer: h, transFn: L, labelFns: M });
+          }
+          var U = [l].concat(i.gauge.steps), G = f.selectAll("g.bg-arc").data(U);
+          G.enter().append("g").classed("bg-arc", true).append("path"), G.select("path").call(k).call(xw), G.exit().remove();
+          var Z = p(i.gauge.bar.thickness), j = f.selectAll("g.value-arc").data([i.gauge.bar]);
+          j.enter().append("g").classed("value-arc", true).append("path");
+          var N = j.select("path");
+          fC(d) ? (N.transition().duration(d.duration).ease(d.easing).each("end", function() {
+            v && v();
+          }).each("interrupt", function() {
+            v && v();
+          }).attrTween("d", XYt(Z, b(r[0].lastY), b(r[0].y))), i._lastValue = r[0].y) : N.attr("d", typeof r[0].y == "number" ? Z.endAngle(b(r[0].y)) : "M0,0Z"), N.call(xw), j.exit().remove(), U = [];
+          var H = i.gauge.threshold.value;
+          (H || H === 0) && U.push({ range: [H, H], color: i.gauge.threshold.color, line: { color: i.gauge.threshold.line.color, width: i.gauge.threshold.line.width }, thickness: i.gauge.threshold.thickness });
+          var re = f.selectAll("g.threshold-arc").data(U);
+          re.enter().append("g").classed("threshold-arc", true).append("path"), re.select("path").call(k).call(xw), re.exit().remove();
+          var oe = f.selectAll("g.gauge-outline").data([u]);
+          oe.enter().append("g").classed("gauge-outline", true).append("path"), oe.select("path").call(k).call(xw), oe.exit().remove();
+        }
+        function WYt(e, t, r, n) {
+          var i = r[0].trace, a = n.numbersX, o = n.numbersY, s = i.align || "center", l = h$[s], u = n.transitionOpts, c = n.onComplete, f = zx.ensureSingle(t, "g", "numbers"), h, d, v, _ = [];
+          i._hasNumber && _.push("number"), i._hasDelta && (_.push("delta"), i.delta.position === "left" && _.reverse());
+          var b = f.selectAll("text").data(_);
+          b.enter().append("text"), b.attr("text-anchor", function() {
+            return l;
+          }).attr("class", function(A) {
+            return A;
+          }).attr("x", null).attr("y", null).attr("dx", null).attr("dy", null), b.exit().remove();
+          function p(A, z, O, U) {
+            if (A.match("s") && O >= 0 != U >= 0 && !z(O).slice(-1).match(jXe) && !z(U).slice(-1).match(jXe)) {
+              var G = A.slice().replace("s", "f").replace(/\d+/, function(j) {
+                return parseInt(j) - 1;
+              }), Z = uC(e, { tickformat: G });
+              return function(j) {
+                return Math.abs(j) < 1 ? sv.tickText(Z, j).text : z(j);
+              };
+            } else return z;
+          }
+          function k() {
+            var A = uC(e, { tickformat: i.number.valueformat }, i._range);
+            A.setScale(), sv.prepTicks(A);
+            var z = function(j) {
+              return sv.tickText(A, j).text;
+            }, O = i.number.suffix, U = i.number.prefix, G = f.select("text.number");
+            function Z() {
+              var j = typeof r[0].y == "number" ? U + z(r[0].y) + O : "-";
+              G.text(j).call(bw.font, i.number.font).call(q7.convertToTspans, e);
+            }
+            return fC(u) ? G.transition().duration(u.duration).ease(u.easing).each("end", function() {
+              Z(), c && c();
+            }).each("interrupt", function() {
+              Z(), c && c();
+            }).attrTween("text", function() {
+              var j = ww.select(this), N = HXe(r[0].lastY, r[0].y);
+              i._lastValue = r[0].y;
+              var H = p(i.number.valueformat, z, r[0].lastY, r[0].y);
+              return function(re) {
+                j.text(U + H(N(re)) + O);
+              };
+            }) : Z(), h = XXe(U + z(r[0].y) + O, i.number.font, l, e), G;
+          }
+          function E() {
+            var A = uC(e, { tickformat: i.delta.valueformat }, i._range);
+            A.setScale(), sv.prepTicks(A);
+            var z = function(re) {
+              return sv.tickText(A, re).text;
+            }, O = i.delta.suffix, U = i.delta.prefix, G = function(re) {
+              var oe = i.delta.relative ? re.relativeDelta : re.delta;
+              return oe;
+            }, Z = function(re, oe) {
+              return re === 0 || typeof re != "number" || isNaN(re) ? "-" : (re > 0 ? i.delta.increasing.symbol : i.delta.decreasing.symbol) + U + oe(re) + O;
+            }, j = function(re) {
+              return re.delta >= 0 ? i.delta.increasing.color : i.delta.decreasing.color;
+            };
+            i._deltaLastValue === void 0 && (i._deltaLastValue = G(r[0]));
+            var N = f.select("text.delta");
+            N.call(bw.font, i.delta.font).call(V5.fill, j({ delta: i._deltaLastValue }));
+            function H() {
+              N.text(Z(G(r[0]), z)).call(V5.fill, j(r[0])).call(q7.convertToTspans, e);
+            }
+            return fC(u) ? N.transition().duration(u.duration).ease(u.easing).tween("text", function() {
+              var re = ww.select(this), oe = G(r[0]), _e = i._deltaLastValue, Ce = p(i.delta.valueformat, z, _e, oe), Le = HXe(_e, oe);
+              return i._deltaLastValue = oe, function(ge) {
+                re.text(Z(Le(ge), Ce)), re.call(V5.fill, j({ delta: Le(ge) }));
+              };
+            }).each("end", function() {
+              H(), c && c();
+            }).each("interrupt", function() {
+              H(), c && c();
+            }) : H(), d = XXe(Z(G(r[0]), z), i.delta.font, l, e), N;
+          }
+          var T = i.mode + i.align, L;
+          if (i._hasDelta && (L = E(), T += i.delta.position + i.delta.font.size + i.delta.font.family + i.delta.valueformat, T += i.delta.increasing.symbol + i.delta.decreasing.symbol, v = d), i._hasNumber && (k(), T += i.number.font.size + i.number.font.family + i.number.valueformat + i.number.suffix + i.number.prefix, v = h), i._hasDelta && i._hasNumber) {
+            var x = [(h.left + h.right) / 2, (h.top + h.bottom) / 2], C = [(d.left + d.right) / 2, (d.top + d.bottom) / 2], M, g, P = 0.75 * i.delta.font.size;
+            i.delta.position === "left" && (M = O7(i, "deltaPos", 0, -1 * (h.width * _w[i.align] + d.width * (1 - _w[i.align]) + P), T, Math.min), g = x[1] - C[1], v = { width: h.width + d.width + P, height: Math.max(h.height, d.height), left: d.left + M, right: h.right, top: Math.min(h.top, d.top + g), bottom: Math.max(h.bottom, d.bottom + g) }), i.delta.position === "right" && (M = O7(i, "deltaPos", 0, h.width * (1 - _w[i.align]) + d.width * _w[i.align] + P, T, Math.max), g = x[1] - C[1], v = { width: h.width + d.width + P, height: Math.max(h.height, d.height), left: h.left, right: d.right + M, top: Math.min(h.top, d.top + g), bottom: Math.max(h.bottom, d.bottom + g) }), i.delta.position === "bottom" && (M = null, g = d.height, v = { width: Math.max(h.width, d.width), height: h.height + d.height, left: Math.min(h.left, d.left), right: Math.max(h.right, d.right), top: h.bottom - h.height, bottom: h.bottom + d.height }), i.delta.position === "top" && (M = null, g = h.top, v = { width: Math.max(h.width, d.width), height: h.height + d.height, left: Math.min(h.left, d.left), right: Math.max(h.right, d.right), top: h.bottom - h.height - d.height, bottom: h.bottom }), L.attr({ dx: M, dy: g });
+          }
+          (i._hasNumber || i._hasDelta) && f.attr("transform", function() {
+            var A = n.numbersScaler(v);
+            T += A[2];
+            var z = O7(i, "numbersScale", 1, A[0], T, Math.min), O;
+            i._scaleNumbers || (z = 1), i._isAngular ? O = o - z * v.bottom : O = o - z * (v.top + v.bottom) / 2, i._numbersTop = z * v.top + O;
+            var U = v[s];
+            s === "center" && (U = (v.left + v.right) / 2);
+            var G = a - z * U;
+            return G = O7(i, "numbersTranslate", 0, G, T, Math.max), cC(G, O) + qYt(z);
+          });
+        }
+        function xw(e) {
+          e.each(function(t) {
+            V5.stroke(ww.select(this), t.line.color);
+          }).each(function(t) {
+            V5.fill(ww.select(this), t.color);
+          }).style("stroke-width", function(t) {
+            return t.line.width;
+          });
+        }
+        function XYt(e, t, r) {
+          return function() {
+            var n = OYt(t, r);
+            return function(i) {
+              return e.endAngle(n(i))();
+            };
+          };
+        }
+        function uC(e, t, r) {
+          var n = e._fullLayout, i = zx.extendFlat({ type: "linear", ticks: "outside", range: r, showline: true }, t), a = { type: "linear", _id: "x" + t._id }, o = { letter: "x", font: n.font, noAutotickangles: true, noHover: true, noTickson: true };
+          function s(l, u) {
+            return zx.coerce(i, a, GYt, l, u);
+          }
+          return UYt(i, a, s, o, n), VYt(i, a, s, o), a;
+        }
+        function WXe(e, t, r) {
+          var n = Math.min(t / e.width, r / e.height);
+          return [n, e, t + "x" + r];
+        }
+        function ZYt(e, t) {
+          var r = Math.sqrt(e.width / 2 * (e.width / 2) + e.height * e.height), n = t / r;
+          return [n, e, t];
+        }
+        function XXe(e, t, r, n) {
+          var i = document.createElementNS("http://www.w3.org/2000/svg", "text"), a = ww.select(i);
+          return a.text(e).attr("x", 0).attr("y", 0).attr("text-anchor", r).attr("data-unformatted", e).call(q7.convertToTspans, n).call(bw.font, t), bw.bBox(a.node());
+        }
+        function O7(e, t, r, n, i, a) {
+          var o = "_cache" + t;
+          e[o] && e[o].key === i || (e[o] = { key: i, value: r });
+          var s = zx.aggNums(a, null, [e[o].value, n], 2);
+          return e[o].value = s, s;
+        }
+      });
+      var JXe = ye((S2r, KXe) => {
+        KXe.exports = { moduleType: "trace", name: "indicator", basePlotModule: PXe(), categories: ["svg", "noOpacity", "noHover"], animatable: true, attributes: c$(), supplyDefaults: UXe().supplyDefaults, calc: GXe().calc, plot: YXe(), meta: {} };
+      });
+      var QXe = ye((M2r, $Xe) => {
+        $Xe.exports = JXe();
+      });
+      var d$ = ye((k2r, iZe) => {
+        var eZe = Jb(), B7 = Ao().extendFlat, YYt = mc().overrideAll, tZe = ec(), KYt = Cc().attributes, rZe = df().descriptionOnlyNumbers;
+        iZe.exports = YYt({ domain: KYt({ name: "table", trace: true }), columnwidth: { valType: "number", arrayOk: true, dflt: null }, columnorder: { valType: "data_array" }, header: { values: { valType: "data_array", dflt: [] }, format: { valType: "data_array", dflt: [], description: rZe("cell value") }, prefix: { valType: "string", arrayOk: true, dflt: null }, suffix: { valType: "string", arrayOk: true, dflt: null }, height: { valType: "number", dflt: 28 }, align: B7({}, eZe.align, { arrayOk: true }), line: { width: { valType: "number", arrayOk: true, dflt: 1 }, color: { valType: "color", arrayOk: true, dflt: "grey" } }, fill: { color: { valType: "color", arrayOk: true, dflt: "white" } }, font: B7({}, tZe({ arrayOk: true })) }, cells: { values: { valType: "data_array", dflt: [] }, format: { valType: "data_array", dflt: [], description: rZe("cell value") }, prefix: { valType: "string", arrayOk: true, dflt: null }, suffix: { valType: "string", arrayOk: true, dflt: null }, height: { valType: "number", dflt: 20 }, align: B7({}, eZe.align, { arrayOk: true }), line: { width: { valType: "number", arrayOk: true, dflt: 1 }, color: { valType: "color", arrayOk: true, dflt: "grey" } }, fill: { color: { valType: "color", arrayOk: true, dflt: "white" } }, font: B7({}, tZe({ arrayOk: true })) } }, "calc", "from-root");
+      });
+      var aZe = ye((C2r, nZe) => {
+        var v$ = Dr(), JYt = d$(), $Yt = Cc().defaults;
+        function QYt(e, t) {
+          for (var r = e.columnorder || [], n = e.header.values.length, i = r.slice(0, n), a = i.slice().sort(function(l, u) {
+            return l - u;
+          }), o = i.map(function(l) {
+            return a.indexOf(l);
+          }), s = o.length; s < n; s++) o.push(s);
+          t("columnorder", o);
+        }
+        nZe.exports = function(t, r, n, i) {
+          function a(o, s) {
+            return v$.coerce(t, r, JYt, o, s);
+          }
+          $Yt(r, i, a), a("columnwidth"), a("header.values"), a("header.format"), a("header.align"), a("header.prefix"), a("header.suffix"), a("header.height"), a("header.line.width"), a("header.line.color"), a("header.fill.color"), v$.coerceFont(a, "header.font", i.font), QYt(r, a), a("cells.values"), a("cells.format"), a("cells.align"), a("cells.prefix"), a("cells.suffix"), a("cells.height"), a("cells.line.width"), a("cells.line.color"), a("cells.fill.color"), v$.coerceFont(a, "cells.font", i.font), r._length = null;
+        };
+      });
+      var sZe = ye((L2r, oZe) => {
+        var eKt = iy().wrap;
+        oZe.exports = function() {
+          return eKt({});
+        };
+      });
+      var p$ = ye((P2r, lZe) => {
+        lZe.exports = { cellPad: 8, columnExtentOffset: 10, columnTitleOffset: 28, emptyHeaderHeight: 16, latexCheck: /^\$.*\$$/, goldenRatio: 1.618, lineBreaker: "<br>", maxDimensionCount: 60, overdrag: 45, releaseTransitionDuration: 120, releaseTransitionEase: "cubic-out", scrollbarCaptureWidth: 18, scrollbarHideDelay: 1e3, scrollbarHideDuration: 1e3, scrollbarOffset: 5, scrollbarWidth: 8, transitionDuration: 100, transitionEase: "cubic-out", uplift: 5, wrapSpacer: " ", wrapSplitCharacter: " ", cn: { table: "table", tableControlView: "table-control-view", scrollBackground: "scroll-background", yColumn: "y-column", columnBlock: "column-block", scrollAreaClip: "scroll-area-clip", scrollAreaClipRect: "scroll-area-clip-rect", columnBoundary: "column-boundary", columnBoundaryClippath: "column-boundary-clippath", columnBoundaryRect: "column-boundary-rect", columnCells: "column-cells", columnCell: "column-cell", cellRect: "cell-rect", cellText: "cell-text", cellTextHolder: "cell-text-holder", scrollbarKit: "scrollbar-kit", scrollbar: "scrollbar", scrollbarSlider: "scrollbar-slider", scrollbarGlyph: "scrollbar-glyph", scrollbarCaptureZone: "scrollbar-capture-zone" } };
+      });
+      var mZe = ye((I2r, gZe) => {
+        var uZe = p$(), m$ = Ao().extendFlat, tKt = Eo(), rKt = vv().isTypedArray, N7 = vv().isArrayOrTypedArray;
+        gZe.exports = function(t, r) {
+          var n = g$(r.cells.values), i = function(g) {
+            return g.slice(r.header.values.length, g.length);
+          }, a = g$(r.header.values);
+          a.length && !a[0].length && (a[0] = [""], a = g$(a));
+          var o = a.concat(i(n).map(function() {
+            return pZe((a[0] || [""]).length);
+          })), s = r.domain, l = Math.floor(t._fullLayout._size.w * (s.x[1] - s.x[0])), u = Math.floor(t._fullLayout._size.h * (s.y[1] - s.y[0])), c = r.header.values.length ? o[0].map(function() {
+            return r.header.height;
+          }) : [uZe.emptyHeaderHeight], f = n.length ? n[0].map(function() {
+            return r.cells.height;
+          }) : [], h = c.reduce(cZe, 0), d = u - h, v = d + uZe.uplift, _ = dZe(f, v), b = dZe(c, h), p = hZe(b, []), k = hZe(_, p), E = {}, T = r._fullInput.columnorder;
+          N7(T) && (T = Array.from(T)), T = T.concat(i(n.map(function(g, P) {
+            return P;
+          })));
+          var L = o.map(function(g, P) {
+            var A = N7(r.columnwidth) ? r.columnwidth[Math.min(P, r.columnwidth.length - 1)] : r.columnwidth;
+            return tKt(A) ? Number(A) : 1;
+          }), x = L.reduce(cZe, 0);
+          L = L.map(function(g) {
+            return g / x * l;
+          });
+          var C = Math.max(y$(r.header.line.width), y$(r.cells.line.width)), M = { key: r.uid + t._context.staticPlot, translateX: s.x[0] * t._fullLayout._size.w, translateY: t._fullLayout._size.h * (1 - s.y[1]), size: t._fullLayout._size, width: l, maxLineWidth: C, height: u, columnOrder: T, groupHeight: u, rowBlocks: k, headerRowBlocks: p, scrollY: 0, cells: m$({}, r.cells, { values: n }), headerCells: m$({}, r.header, { values: o }), gdColumns: o.map(function(g) {
+            return g[0];
+          }), gdColumnsOriginalOrder: o.map(function(g) {
+            return g[0];
+          }), prevPages: [0, 0], scrollbarState: { scrollbarScrollInProgress: false }, columns: o.map(function(g, P) {
+            var A = E[g];
+            E[g] = (A || 0) + 1;
+            var z = g + "__" + E[g];
+            return { key: z, label: g, specIndex: P, xIndex: T[P], xScale: fZe, x: void 0, calcdata: void 0, columnWidth: L[P] };
+          }) };
+          return M.columns.forEach(function(g) {
+            g.calcdata = M, g.x = fZe(g);
+          }), M;
+        };
+        function y$(e) {
+          if (N7(e)) {
+            for (var t = 0, r = 0; r < e.length; r++) t = Math.max(t, y$(e[r]));
+            return t;
+          }
+          return e;
+        }
+        function cZe(e, t) {
+          return e + t;
+        }
+        function g$(e) {
+          var t = e.slice(), r = 1 / 0, n = 0, i;
+          for (i = 0; i < t.length; i++) rKt(t[i]) ? t[i] = Array.from(t[i]) : N7(t[i]) || (t[i] = [t[i]]), r = Math.min(r, t[i].length), n = Math.max(n, t[i].length);
+          if (r !== n) for (i = 0; i < t.length; i++) {
+            var a = n - t[i].length;
+            a && (t[i] = t[i].concat(pZe(a)));
+          }
+          return t;
+        }
+        function pZe(e) {
+          for (var t = new Array(e), r = 0; r < e; r++) t[r] = "";
+          return t;
+        }
+        function fZe(e) {
+          return e.calcdata.columns.reduce(function(t, r) {
+            return r.xIndex < e.xIndex ? t + r.columnWidth : t;
+          }, 0);
+        }
+        function hZe(e, t) {
+          var r = Object.keys(e);
+          return r.map(function(n) {
+            return m$({}, e[n], { auxiliaryBlocks: t });
+          });
+        }
+        function dZe(e, t) {
+          for (var r = {}, n, i = 0, a = 0, o = vZe(), s = 0, l = 0, u = 0; u < e.length; u++) n = e[u], o.rows.push({ rowIndex: u, rowHeight: n }), a += n, (a >= t || u === e.length - 1) && (r[i] = o, o.key = l++, o.firstRowIndex = s, o.lastRowIndex = u, o = vZe(), i += a, s = u + 1, a = 0);
+          return r;
+        }
+        function vZe() {
+          return { firstRowIndex: null, lastRowIndex: null, rows: [] };
+        }
+      });
+      var yZe = ye((_$) => {
+        var U7 = Ao().extendFlat;
+        _$.splitToPanels = function(e) {
+          var t = [0, 0], r = U7({}, e, { key: "header", type: "header", page: 0, prevPages: t, currentRepaint: [null, null], dragHandle: true, values: e.calcdata.headerCells.values[e.specIndex], rowBlocks: e.calcdata.headerRowBlocks, calcdata: U7({}, e.calcdata, { cells: e.calcdata.headerCells }) }), n = U7({}, e, { key: "cells1", type: "cells", page: 0, prevPages: t, currentRepaint: [null, null], dragHandle: false, values: e.calcdata.cells.values[e.specIndex], rowBlocks: e.calcdata.rowBlocks }), i = U7({}, e, { key: "cells2", type: "cells", page: 1, prevPages: t, currentRepaint: [null, null], dragHandle: false, values: e.calcdata.cells.values[e.specIndex], rowBlocks: e.calcdata.rowBlocks });
+          return [n, i, r];
+        };
+        _$.splitToCells = function(e) {
+          var t = iKt(e);
+          return (e.values || []).slice(t[0], t[1]).map(function(r, n) {
+            var i = typeof r == "string" && r.match(/[<$&> ]/) ? "_keybuster_" + Math.random() : "";
+            return { keyWithinBlock: n + i, key: t[0] + n, column: e, calcdata: e.calcdata, page: e.page, rowBlocks: e.rowBlocks, value: r };
+          });
+        };
+        function iKt(e) {
+          var t = e.rowBlocks[e.page], r = t ? t.rows[0].rowIndex : 0, n = t ? r + t.rows.length : 0;
+          return [r, n];
+        }
+      });
+      var C$ = ye((D2r, CZe) => {
+        var Ya = p$(), tf = Oa(), x$ = Dr(), nKt = x$.numberFormat, Uu = iy(), b$ = So(), aKt = Zl(), oKt = Dr().raiseToTop, lg = Dr().strTranslate, sKt = Dr().cancelTransition, lKt = mZe(), SZe = yZe(), _Ze = ka();
+        CZe.exports = function(t, r) {
+          var n = !t._context.staticPlot, i = t._fullLayout._paper.selectAll("." + Ya.cn.table).data(r.map(function(k) {
+            var E = Uu.unwrap(k), T = E.trace;
+            return lKt(t, T);
+          }), Uu.keyFun);
+          i.exit().remove(), i.enter().append("g").classed(Ya.cn.table, true).attr("overflow", "visible").style("box-sizing", "content-box").style("position", "absolute").style("left", 0).style("overflow", "visible").style("shape-rendering", "crispEdges").style("pointer-events", "all"), i.attr("width", function(k) {
+            return k.width + k.size.l + k.size.r;
+          }).attr("height", function(k) {
+            return k.height + k.size.t + k.size.b;
+          }).attr("transform", function(k) {
+            return lg(k.translateX, k.translateY);
+          });
+          var a = i.selectAll("." + Ya.cn.tableControlView).data(Uu.repeat, Uu.keyFun), o = a.enter().append("g").classed(Ya.cn.tableControlView, true).style("box-sizing", "content-box");
+          if (n) {
+            var s = "onwheel" in document ? "wheel" : "mousewheel";
+            o.on("mousemove", function(k) {
+              a.filter(function(E) {
+                return k === E;
+              }).call(hC, t);
+            }).on(s, function(k) {
+              if (!k.scrollbarState.wheeling) {
+                k.scrollbarState.wheeling = true;
+                var E = k.scrollY + tf.event.deltaY, T = G7(t, a, null, E)(k);
+                T || (tf.event.stopPropagation(), tf.event.preventDefault()), k.scrollbarState.wheeling = false;
+              }
+            }).call(hC, t, true);
+          }
+          a.attr("transform", function(k) {
+            return lg(k.size.l, k.size.t);
+          });
+          var l = a.selectAll("." + Ya.cn.scrollBackground).data(Uu.repeat, Uu.keyFun);
+          l.enter().append("rect").classed(Ya.cn.scrollBackground, true).attr("fill", "none"), l.attr("width", function(k) {
+            return k.width;
+          }).attr("height", function(k) {
+            return k.height;
+          }), a.each(function(k) {
+            b$.setClipUrl(tf.select(this), xZe(t, k), t);
+          });
+          var u = a.selectAll("." + Ya.cn.yColumn).data(function(k) {
+            return k.columns;
+          }, Uu.keyFun);
+          u.enter().append("g").classed(Ya.cn.yColumn, true), u.exit().remove(), u.attr("transform", function(k) {
+            return lg(k.x, 0);
+          }), n && u.call(tf.behavior.drag().origin(function(k) {
+            var E = tf.select(this);
+            return TZe(E, k, -Ya.uplift), oKt(this), k.calcdata.columnDragInProgress = true, hC(a.filter(function(T) {
+              return k.calcdata.key === T.key;
+            }), t), k;
+          }).on("drag", function(k) {
+            var E = tf.select(this), T = function(C) {
+              return (k === C ? tf.event.x : C.x) + C.columnWidth / 2;
+            };
+            k.x = Math.max(-Ya.overdrag, Math.min(k.calcdata.width + Ya.overdrag - k.columnWidth, tf.event.x));
+            var L = MZe(u).filter(function(C) {
+              return C.calcdata.key === k.calcdata.key;
+            }), x = L.sort(function(C, M) {
+              return T(C) - T(M);
+            });
+            x.forEach(function(C, M) {
+              C.xIndex = M, C.x = k === C ? C.x : C.xScale(C);
+            }), u.filter(function(C) {
+              return k !== C;
+            }).transition().ease(Ya.transitionEase).duration(Ya.transitionDuration).attr("transform", function(C) {
+              return lg(C.x, 0);
+            }), E.call(sKt).attr("transform", lg(k.x, -Ya.uplift));
+          }).on("dragend", function(k) {
+            var E = tf.select(this), T = k.calcdata;
+            k.x = k.xScale(k), k.calcdata.columnDragInProgress = false, TZe(E, k, 0), yKt(t, T, T.columns.map(function(L) {
+              return L.xIndex;
+            }));
+          })), u.each(function(k) {
+            b$.setClipUrl(tf.select(this), bZe(t, k), t);
+          });
+          var c = u.selectAll("." + Ya.cn.columnBlock).data(SZe.splitToPanels, Uu.keyFun);
+          c.enter().append("g").classed(Ya.cn.columnBlock, true).attr("id", function(k) {
+            return k.key;
+          }), c.style("cursor", function(k) {
+            return k.dragHandle ? "ew-resize" : k.calcdata.scrollbarState.barWiggleRoom ? "ns-resize" : "default";
+          });
+          var f = c.filter(_Kt), h = c.filter(M$);
+          n && h.call(tf.behavior.drag().origin(function(k) {
+            return tf.event.stopPropagation(), k;
+          }).on("drag", G7(t, a, -1)).on("dragend", function() {
+          })), w$(t, a, f, c), w$(t, a, h, c);
+          var d = a.selectAll("." + Ya.cn.scrollAreaClip).data(Uu.repeat, Uu.keyFun);
+          d.enter().append("clipPath").classed(Ya.cn.scrollAreaClip, true).attr("id", function(k) {
+            return xZe(t, k);
+          });
+          var v = d.selectAll("." + Ya.cn.scrollAreaClipRect).data(Uu.repeat, Uu.keyFun);
+          v.enter().append("rect").classed(Ya.cn.scrollAreaClipRect, true).attr("x", -Ya.overdrag).attr("y", -Ya.uplift).attr("fill", "none"), v.attr("width", function(k) {
+            return k.width + 2 * Ya.overdrag;
+          }).attr("height", function(k) {
+            return k.height + Ya.uplift;
+          });
+          var _ = u.selectAll("." + Ya.cn.columnBoundary).data(Uu.repeat, Uu.keyFun);
+          _.enter().append("g").classed(Ya.cn.columnBoundary, true);
+          var b = u.selectAll("." + Ya.cn.columnBoundaryClippath).data(Uu.repeat, Uu.keyFun);
+          b.enter().append("clipPath").classed(Ya.cn.columnBoundaryClippath, true), b.attr("id", function(k) {
+            return bZe(t, k);
+          });
+          var p = b.selectAll("." + Ya.cn.columnBoundaryRect).data(Uu.repeat, Uu.keyFun);
+          p.enter().append("rect").classed(Ya.cn.columnBoundaryRect, true).attr("fill", "none"), p.attr("width", function(k) {
+            return k.columnWidth + 2 * V7(k);
+          }).attr("height", function(k) {
+            return k.calcdata.height + 2 * V7(k) + Ya.uplift;
+          }).attr("x", function(k) {
+            return -V7(k);
+          }).attr("y", function(k) {
+            return -V7(k);
+          }), E$(null, h, a);
+        };
+        function V7(e) {
+          return Math.ceil(e.calcdata.maxLineWidth / 2);
+        }
+        function xZe(e, t) {
+          return "clip" + e._fullLayout._uid + "_scrollAreaBottomClip_" + t.key;
+        }
+        function bZe(e, t) {
+          return "clip" + e._fullLayout._uid + "_columnBoundaryClippath_" + t.calcdata.key + "_" + t.specIndex;
+        }
+        function MZe(e) {
+          return [].concat.apply([], e.map(function(t) {
+            return t;
+          })).map(function(t) {
+            return t.__data__;
+          });
+        }
+        function hC(e, t, r) {
+          function n(u) {
+            var c = u.rowBlocks;
+            return A$(c, c.length - 1) + (c.length ? H7(c[c.length - 1], 1 / 0) : 1);
+          }
+          var i = e.selectAll("." + Ya.cn.scrollbarKit).data(Uu.repeat, Uu.keyFun);
+          i.enter().append("g").classed(Ya.cn.scrollbarKit, true).style("shape-rendering", "geometricPrecision"), i.each(function(u) {
+            var c = u.scrollbarState;
+            c.totalHeight = n(u), c.scrollableAreaHeight = u.groupHeight - T$(u), c.currentlyVisibleHeight = Math.min(c.totalHeight, c.scrollableAreaHeight), c.ratio = c.currentlyVisibleHeight / c.totalHeight, c.barLength = Math.max(c.ratio * c.currentlyVisibleHeight, Ya.goldenRatio * Ya.scrollbarWidth), c.barWiggleRoom = c.currentlyVisibleHeight - c.barLength, c.wiggleRoom = Math.max(0, c.totalHeight - c.scrollableAreaHeight), c.topY = c.barWiggleRoom === 0 ? 0 : u.scrollY / c.wiggleRoom * c.barWiggleRoom, c.bottomY = c.topY + c.barLength, c.dragMultiplier = c.wiggleRoom / c.barWiggleRoom;
+          }).attr("transform", function(u) {
+            var c = u.width + Ya.scrollbarWidth / 2 + Ya.scrollbarOffset;
+            return lg(c, T$(u));
+          });
+          var a = i.selectAll("." + Ya.cn.scrollbar).data(Uu.repeat, Uu.keyFun);
+          a.enter().append("g").classed(Ya.cn.scrollbar, true);
+          var o = a.selectAll("." + Ya.cn.scrollbarSlider).data(Uu.repeat, Uu.keyFun);
+          o.enter().append("g").classed(Ya.cn.scrollbarSlider, true), o.attr("transform", function(u) {
+            return lg(0, u.scrollbarState.topY || 0);
+          });
+          var s = o.selectAll("." + Ya.cn.scrollbarGlyph).data(Uu.repeat, Uu.keyFun);
+          s.enter().append("line").classed(Ya.cn.scrollbarGlyph, true).attr("stroke", "black").attr("stroke-width", Ya.scrollbarWidth).attr("stroke-linecap", "round").attr("y1", Ya.scrollbarWidth / 2), s.attr("y2", function(u) {
+            return u.scrollbarState.barLength - Ya.scrollbarWidth / 2;
+          }).attr("stroke-opacity", function(u) {
+            return u.columnDragInProgress || !u.scrollbarState.barWiggleRoom || r ? 0 : 0.4;
+          }), s.transition().delay(0).duration(0), s.transition().delay(Ya.scrollbarHideDelay).duration(Ya.scrollbarHideDuration).attr("stroke-opacity", 0);
+          var l = a.selectAll("." + Ya.cn.scrollbarCaptureZone).data(Uu.repeat, Uu.keyFun);
+          l.enter().append("line").classed(Ya.cn.scrollbarCaptureZone, true).attr("stroke", "white").attr("stroke-opacity", 0.01).attr("stroke-width", Ya.scrollbarCaptureWidth).attr("stroke-linecap", "butt").attr("y1", 0).on("mousedown", function(u) {
+            var c = tf.event.y, f = this.getBoundingClientRect(), h = u.scrollbarState, d = c - f.top, v = tf.scale.linear().domain([0, h.scrollableAreaHeight]).range([0, h.totalHeight]).clamp(true);
+            h.topY <= d && d <= h.bottomY || G7(t, e, null, v(d - h.barLength / 2))(u);
+          }).call(tf.behavior.drag().origin(function(u) {
+            return tf.event.stopPropagation(), u.scrollbarState.scrollbarScrollInProgress = true, u;
+          }).on("drag", G7(t, e)).on("dragend", function() {
+          })), l.attr("y2", function(u) {
+            return u.scrollbarState.scrollableAreaHeight;
+          }), t._context.staticPlot && (s.remove(), l.remove());
+        }
+        function w$(e, t, r, n) {
+          var i = uKt(r), a = cKt(i);
+          vKt(a);
+          var o = fKt(a);
+          gKt(o);
+          var s = dKt(a), l = hKt(s);
+          pKt(l), EZe(l, t, n, e), k$(a);
+        }
+        function uKt(e) {
+          var t = e.selectAll("." + Ya.cn.columnCells).data(Uu.repeat, Uu.keyFun);
+          return t.enter().append("g").classed(Ya.cn.columnCells, true), t.exit().remove(), t;
+        }
+        function cKt(e) {
+          var t = e.selectAll("." + Ya.cn.columnCell).data(SZe.splitToCells, function(r) {
+            return r.keyWithinBlock;
+          });
+          return t.enter().append("g").classed(Ya.cn.columnCell, true), t.exit().remove(), t;
+        }
+        function fKt(e) {
+          var t = e.selectAll("." + Ya.cn.cellRect).data(Uu.repeat, function(r) {
+            return r.keyWithinBlock;
+          });
+          return t.enter().append("rect").classed(Ya.cn.cellRect, true), t;
+        }
+        function hKt(e) {
+          var t = e.selectAll("." + Ya.cn.cellText).data(Uu.repeat, function(r) {
+            return r.keyWithinBlock;
+          });
+          return t.enter().append("text").classed(Ya.cn.cellText, true).style("cursor", function() {
+            return "auto";
+          }).on("mousedown", function() {
+            tf.event.stopPropagation();
+          }), t;
+        }
+        function dKt(e) {
+          var t = e.selectAll("." + Ya.cn.cellTextHolder).data(Uu.repeat, function(r) {
+            return r.keyWithinBlock;
+          });
+          return t.enter().append("g").classed(Ya.cn.cellTextHolder, true).style("shape-rendering", "geometricPrecision"), t;
+        }
+        function vKt(e) {
+          e.each(function(t, r) {
+            var n = t.calcdata.cells.font, i = t.column.specIndex, a = { size: Yv(n.size, i, r), color: Yv(n.color, i, r), family: Yv(n.family, i, r), weight: Yv(n.weight, i, r), style: Yv(n.style, i, r), variant: Yv(n.variant, i, r), textcase: Yv(n.textcase, i, r), lineposition: Yv(n.lineposition, i, r), shadow: Yv(n.shadow, i, r) };
+            t.rowNumber = t.key, t.align = Yv(t.calcdata.cells.align, i, r), t.cellBorderWidth = Yv(t.calcdata.cells.line.width, i, r), t.font = a;
+          });
+        }
+        function pKt(e) {
+          e.each(function(t) {
+            b$.font(tf.select(this), t.font);
+          });
+        }
+        function gKt(e) {
+          e.attr("width", function(t) {
+            return t.column.columnWidth;
+          }).attr("stroke-width", function(t) {
+            return t.cellBorderWidth;
+          }).each(function(t) {
+            var r = tf.select(this);
+            _Ze.stroke(r, Yv(t.calcdata.cells.line.color, t.column.specIndex, t.rowNumber)), _Ze.fill(r, Yv(t.calcdata.cells.fill.color, t.column.specIndex, t.rowNumber));
+          });
+        }
+        function EZe(e, t, r, n) {
+          e.text(function(i) {
+            var a = i.column.specIndex, o = i.rowNumber, s = i.value, l = typeof s == "string", u = l && s.match(/<br>/i), c = !l || u;
+            i.mayHaveMarkup = l && s.match(/[<&>]/);
+            var f = mKt(s);
+            i.latex = f;
+            var h = f ? "" : Yv(i.calcdata.cells.prefix, a, o) || "", d = f ? "" : Yv(i.calcdata.cells.suffix, a, o) || "", v = f ? null : Yv(i.calcdata.cells.format, a, o) || null, _ = h + (v ? nKt(v)(i.value) : i.value) + d, b;
+            i.wrappingNeeded = !i.wrapped && !c && !f && (b = wZe(_)), i.cellHeightMayIncrease = u || f || i.mayHaveMarkup || (b === void 0 ? wZe(_) : b), i.needsConvertToTspans = i.mayHaveMarkup || i.wrappingNeeded || i.latex;
+            var p;
+            if (i.wrappingNeeded) {
+              var k = Ya.wrapSplitCharacter === " " ? _.replace(/<a href=/ig, "<a_href=") : _, E = k.split(Ya.wrapSplitCharacter), T = Ya.wrapSplitCharacter === " " ? E.map(function(L) {
+                return L.replace(/<a_href=/ig, "<a href=");
+              }) : E;
+              i.fragments = T.map(function(L) {
+                return { text: L, width: null };
+              }), i.fragments.push({ fragment: Ya.wrapSpacer, width: null }), p = T.join(Ya.lineBreaker) + Ya.lineBreaker + Ya.wrapSpacer;
+            } else delete i.fragments, p = _;
+            return p;
+          }).attr("dy", function(i) {
+            return i.needsConvertToTspans ? 0 : "0.75em";
+          }).each(function(i) {
+            var a = this, o = tf.select(a), s = i.wrappingNeeded ? bKt : wKt;
+            i.needsConvertToTspans ? aKt.convertToTspans(o, n, s(r, a, t, n, i)) : tf.select(a.parentNode).attr("transform", function(l) {
+              return lg(kZe(l), Ya.cellPad);
+            }).attr("text-anchor", function(l) {
+              return { left: "start", center: "middle", right: "end" }[l.align];
+            });
+          });
+        }
+        function mKt(e) {
+          return typeof e == "string" && e.match(Ya.latexCheck);
+        }
+        function wZe(e) {
+          return e.indexOf(Ya.wrapSplitCharacter) !== -1;
+        }
+        function yKt(e, t, r) {
+          var n = t.gdColumnsOriginalOrder;
+          t.gdColumns.sort(function(i, a) {
+            return r[n.indexOf(i)] - r[n.indexOf(a)];
+          }), t.columnorder = r, e.emit("plotly_restyle");
+        }
+        function Yv(e, t, r) {
+          if (x$.isArrayOrTypedArray(e)) {
+            var n = e[Math.min(t, e.length - 1)];
+            return x$.isArrayOrTypedArray(n) ? n[Math.min(r, n.length - 1)] : n;
+          } else return e;
+        }
+        function TZe(e, t, r) {
+          e.transition().ease(Ya.releaseTransitionEase).duration(Ya.releaseTransitionDuration).attr("transform", lg(t.x, r));
+        }
+        function M$(e) {
+          return e.type === "cells";
+        }
+        function _Kt(e) {
+          return e.type === "header";
+        }
+        function T$(e) {
+          var t = e.rowBlocks.length ? e.rowBlocks[0].auxiliaryBlocks : [];
+          return t.reduce(function(r, n) {
+            return r + H7(n, 1 / 0);
+          }, 0);
+        }
+        function xKt(e, t, r) {
+          for (var n = [], i = 0, a = 0; a < e.length; a++) {
+            for (var o = e[a], s = o.rows, l = 0, u = 0; u < s.length; u++) l += s[u].rowHeight;
+            o.allRowsHeight = l;
+            var c = i + l, f = t, h = f + r;
+            f < c && h > i && n.push(a), i += l;
+          }
+          return n;
+        }
+        function E$(e, t, r) {
+          var n = MZe(t)[0];
+          if (n !== void 0) {
+            var i = n.rowBlocks, a = n.calcdata, o = A$(i, i.length), s = n.calcdata.groupHeight - T$(n), l = a.scrollY = Math.max(0, Math.min(o - s, a.scrollY)), u = xKt(i, l, s);
+            u.length === 1 && (u[0] === i.length - 1 ? u.unshift(u[0] - 1) : u.push(u[0] + 1)), u[0] % 2 && u.reverse(), t.each(function(c, f) {
+              c.page = u[f], c.scrollY = l;
+            }), t.attr("transform", function(c) {
+              var f = A$(c.rowBlocks, c.page) - c.scrollY;
+              return lg(0, f);
+            }), e && (AZe(e, r, t, u, n.prevPages, n, 0), AZe(e, r, t, u, n.prevPages, n, 1), hC(r, e));
+          }
+        }
+        function G7(e, t, r, n) {
+          return function(a) {
+            var o = a.calcdata ? a.calcdata : a, s = t.filter(function(f) {
+              return o.key === f.key;
+            }), l = r || o.scrollbarState.dragMultiplier, u = o.scrollY;
+            o.scrollY = n === void 0 ? o.scrollY + l * tf.event.dy : n;
+            var c = s.selectAll("." + Ya.cn.yColumn).selectAll("." + Ya.cn.columnBlock).filter(M$);
+            return E$(e, c, s), o.scrollY === u;
+          };
+        }
+        function AZe(e, t, r, n, i, a, o) {
+          var s = n[o] !== i[o];
+          s && (clearTimeout(a.currentRepaint[o]), a.currentRepaint[o] = setTimeout(function() {
+            var l = r.filter(function(u, c) {
+              return c === o && n[c] !== i[c];
+            });
+            w$(e, t, l, r), i[o] = n[o];
+          }));
+        }
+        function bKt(e, t, r, n) {
+          return function() {
+            var a = tf.select(t.parentNode);
+            a.each(function(o) {
+              var s = o.fragments;
+              a.selectAll("tspan.line").each(function(_, b) {
+                s[b].width = this.getComputedTextLength();
+              });
+              var l = s[s.length - 1].width, u = s.slice(0, -1), c = [], f, h, d = 0, v = o.column.columnWidth - 2 * Ya.cellPad;
+              for (o.value = ""; u.length; ) f = u.shift(), h = f.width + l, d + h > v && (o.value += c.join(Ya.wrapSpacer) + Ya.lineBreaker, c = [], d = 0), c.push(f.text), d += h;
+              d && (o.value += c.join(Ya.wrapSpacer)), o.wrapped = true;
+            }), a.selectAll("tspan.line").remove(), EZe(a.select("." + Ya.cn.cellText), r, e, n), tf.select(t.parentNode.parentNode).call(k$);
+          };
+        }
+        function wKt(e, t, r, n, i) {
+          return function() {
+            if (!i.settledY) {
+              var o = tf.select(t.parentNode), s = S$(i), l = i.key - s.firstRowIndex, u = s.rows[l].rowHeight, c = i.cellHeightMayIncrease ? t.parentNode.getBoundingClientRect().height + 2 * Ya.cellPad : u, f = Math.max(c, u), h = f - s.rows[l].rowHeight;
+              h && (s.rows[l].rowHeight = f, e.selectAll("." + Ya.cn.columnCell).call(k$), E$(null, e.filter(M$), 0), hC(r, n, true)), o.attr("transform", function() {
+                var d = this, v = d.parentNode, _ = v.getBoundingClientRect(), b = tf.select(d.parentNode).select("." + Ya.cn.cellRect).node().getBoundingClientRect(), p = d.transform.baseVal.consolidate(), k = b.top - _.top + (p ? p.matrix.f : Ya.cellPad);
+                return lg(kZe(i, tf.select(d.parentNode).select("." + Ya.cn.cellTextHolder).node().getBoundingClientRect().width), k);
+              }), i.settledY = true;
+            }
+          };
+        }
+        function kZe(e, t) {
+          switch (e.align) {
+            case "left":
+              return Ya.cellPad;
+            case "right":
+              return e.column.columnWidth - (t || 0) - Ya.cellPad;
+            case "center":
+              return (e.column.columnWidth - (t || 0)) / 2;
+            default:
+              return Ya.cellPad;
+          }
+        }
+        function k$(e) {
+          e.attr("transform", function(t) {
+            var r = t.rowBlocks[0].auxiliaryBlocks.reduce(function(o, s) {
+              return o + H7(s, 1 / 0);
+            }, 0), n = S$(t), i = H7(n, t.key), a = i + r;
+            return lg(0, a);
+          }).selectAll("." + Ya.cn.cellRect).attr("height", function(t) {
+            return AKt(S$(t), t.key).rowHeight;
+          });
+        }
+        function A$(e, t) {
+          for (var r = 0, n = t - 1; n >= 0; n--) r += TKt(e[n]);
+          return r;
+        }
+        function H7(e, t) {
+          for (var r = 0, n = 0; n < e.rows.length && e.rows[n].rowIndex < t; n++) r += e.rows[n].rowHeight;
+          return r;
+        }
+        function TKt(e) {
+          var t = e.allRowsHeight;
+          if (t !== void 0) return t;
+          for (var r = 0, n = 0; n < e.rows.length; n++) r += e.rows[n].rowHeight;
+          return e.allRowsHeight = r, r;
+        }
+        function S$(e) {
+          return e.rowBlocks[e.page];
+        }
+        function AKt(e, t) {
+          return e.rows[t - e.firstRowIndex];
+        }
+      });
+      var LZe = ye((W7) => {
+        var SKt = Id().getModuleCalcData, MKt = C$(), j7 = "table";
+        W7.name = j7;
+        W7.plot = function(e) {
+          var t = SKt(e.calcdata, j7)[0];
+          t.length && MKt(e, t);
+        };
+        W7.clean = function(e, t, r, n) {
+          var i = n._has && n._has(j7), a = t._has && t._has(j7);
+          i && !a && n._paperdiv.selectAll(".table").remove();
+        };
+      });
+      var IZe = ye((z2r, PZe) => {
+        PZe.exports = { attributes: d$(), supplyDefaults: aZe(), calc: sZe(), plot: C$(), moduleType: "trace", name: "table", basePlotModule: LZe(), categories: ["noOpacity"], meta: {} };
+      });
+      var DZe = ye((O2r, RZe) => {
+        RZe.exports = IZe();
+      });
+      var BZe = ye((q2r, qZe) => {
+        var FZe = ec(), zZe = Ih(), L$ = Rd(), EKt = df().descriptionWithDates, kKt = mc().overrideAll, OZe = Pd().dash, P$ = Ao().extendFlat;
+        qZe.exports = { color: { valType: "color", editType: "calc" }, smoothing: { valType: "number", dflt: 1, min: 0, max: 1.3, editType: "calc" }, title: { text: { valType: "string", dflt: "", editType: "calc" }, font: FZe({ editType: "calc" }), offset: { valType: "number", dflt: 10, editType: "calc" }, editType: "calc" }, type: { valType: "enumerated", values: ["-", "linear", "date", "category"], dflt: "-", editType: "calc" }, autotypenumbers: L$.autotypenumbers, autorange: { valType: "enumerated", values: [true, false, "reversed"], dflt: true, editType: "calc" }, rangemode: { valType: "enumerated", values: ["normal", "tozero", "nonnegative"], dflt: "normal", editType: "calc" }, range: { valType: "info_array", editType: "calc", items: [{ valType: "any", editType: "calc" }, { valType: "any", editType: "calc" }] }, fixedrange: { valType: "boolean", dflt: false, editType: "calc" }, cheatertype: { valType: "enumerated", values: ["index", "value"], dflt: "value", editType: "calc" }, tickmode: { valType: "enumerated", values: ["linear", "array"], dflt: "array", editType: "calc" }, nticks: { valType: "integer", min: 0, dflt: 0, editType: "calc" }, tickvals: { valType: "data_array", editType: "calc" }, ticktext: { valType: "data_array", editType: "calc" }, showticklabels: { valType: "enumerated", values: ["start", "end", "both", "none"], dflt: "start", editType: "calc" }, labelalias: P$({}, L$.labelalias, { editType: "calc" }), tickfont: FZe({ editType: "calc" }), tickangle: { valType: "angle", dflt: "auto", editType: "calc" }, tickprefix: { valType: "string", dflt: "", editType: "calc" }, showtickprefix: { valType: "enumerated", values: ["all", "first", "last", "none"], dflt: "all", editType: "calc" }, ticksuffix: { valType: "string", dflt: "", editType: "calc" }, showticksuffix: { valType: "enumerated", values: ["all", "first", "last", "none"], dflt: "all", editType: "calc" }, showexponent: { valType: "enumerated", values: ["all", "first", "last", "none"], dflt: "all", editType: "calc" }, exponentformat: { valType: "enumerated", values: ["none", "e", "E", "power", "SI", "B", "SI extended"], dflt: "B", editType: "calc" }, minexponent: { valType: "number", dflt: 3, min: 0, editType: "calc" }, separatethousands: { valType: "boolean", dflt: false, editType: "calc" }, tickformat: { valType: "string", dflt: "", editType: "calc", description: EKt("tick label") }, tickformatstops: kKt(L$.tickformatstops, "calc", "from-root"), categoryorder: { valType: "enumerated", values: ["trace", "category ascending", "category descending", "array"], dflt: "trace", editType: "calc" }, categoryarray: { valType: "data_array", editType: "calc" }, labelpadding: { valType: "integer", dflt: 10, editType: "calc" }, labelprefix: { valType: "string", editType: "calc" }, labelsuffix: { valType: "string", dflt: "", editType: "calc" }, showline: { valType: "boolean", dflt: false, editType: "calc" }, linecolor: { valType: "color", dflt: zZe.defaultLine, editType: "calc" }, linewidth: { valType: "number", min: 0, dflt: 1, editType: "calc" }, gridcolor: { valType: "color", editType: "calc" }, gridwidth: { valType: "number", min: 0, dflt: 1, editType: "calc" }, griddash: P$({}, OZe, { editType: "calc" }), showgrid: { valType: "boolean", dflt: true, editType: "calc" }, minorgridcount: { valType: "integer", min: 0, dflt: 0, editType: "calc" }, minorgridwidth: { valType: "number", min: 0, dflt: 1, editType: "calc" }, minorgriddash: P$({}, OZe, { editType: "calc" }), minorgridcolor: { valType: "color", dflt: zZe.lightLine, editType: "calc" }, startline: { valType: "boolean", editType: "calc" }, startlinecolor: { valType: "color", editType: "calc" }, startlinewidth: { valType: "number", dflt: 1, editType: "calc" }, endline: { valType: "boolean", editType: "calc" }, endlinewidth: { valType: "number", dflt: 1, editType: "calc" }, endlinecolor: { valType: "color", editType: "calc" }, tick0: { valType: "number", min: 0, dflt: 0, editType: "calc" }, dtick: { valType: "number", min: 0, dflt: 1, editType: "calc" }, arraytick0: { valType: "integer", min: 0, dflt: 0, editType: "calc" }, arraydtick: { valType: "integer", min: 1, dflt: 1, editType: "calc" }, editType: "calc" };
+      });
+      var Z7 = ye((B2r, VZe) => {
+        var CKt = ec(), NZe = BZe(), UZe = Ih(), X7 = CKt({ editType: "calc" }), LKt = pf().zorder;
+        X7.family.dflt = '"Open Sans", verdana, arial, sans-serif';
+        X7.size.dflt = 12;
+        X7.color.dflt = UZe.defaultLine;
+        VZe.exports = { carpet: { valType: "string", editType: "calc" }, x: { valType: "data_array", editType: "calc+clearAxisTypes" }, y: { valType: "data_array", editType: "calc+clearAxisTypes" }, a: { valType: "data_array", editType: "calc" }, a0: { valType: "number", dflt: 0, editType: "calc" }, da: { valType: "number", dflt: 1, editType: "calc" }, b: { valType: "data_array", editType: "calc" }, b0: { valType: "number", dflt: 0, editType: "calc" }, db: { valType: "number", dflt: 1, editType: "calc" }, cheaterslope: { valType: "number", dflt: 1, editType: "calc" }, aaxis: NZe, baxis: NZe, font: X7, color: { valType: "color", dflt: UZe.defaultLine, editType: "plot" }, zorder: LKt };
+      });
+      var jZe = ye((N2r, HZe) => {
+        var GZe = Dr().isArray1D;
+        HZe.exports = function(t, r, n) {
+          var i = n("x"), a = i && i.length, o = n("y"), s = o && o.length;
+          if (!a && !s) return false;
+          if (r._cheater = !i, (!a || GZe(i)) && (!s || GZe(o))) {
+            var l = a ? i.length : 1 / 0;
+            s && (l = Math.min(l, o.length)), r.a && r.a.length && (l = Math.min(l, r.a.length)), r.b && r.b.length && (l = Math.min(l, r.b.length)), r._length = l;
+          } else r._length = null;
+          return true;
+        };
+      });
+      var ZZe = ye((U2r, XZe) => {
+        var PKt = Z7(), WZe = ka().addOpacity, IKt = qa(), dC = Dr(), RKt = Lb(), DKt = s_(), FKt = l_(), zKt = cI(), OKt = xm(), qKt = V3();
+        XZe.exports = function(t, r, n) {
+          var i = n.letter, a = n.font || {}, o = PKt[i + "axis"];
+          function s(g, P) {
+            return dC.coerce(t, r, o, g, P);
+          }
+          function l(g, P) {
+            return dC.coerce2(t, r, o, g, P);
+          }
+          n.name && (r._name = n.name, r._id = n.name), s("autotypenumbers", n.autotypenumbersDflt);
+          var u = s("type");
+          if (u === "-" && (n.data && BKt(r, n.data), r.type === "-" ? r.type = "linear" : u = t.type = r.type), s("smoothing"), s("cheatertype"), s("showticklabels"), s("labelprefix", i + " = "), s("labelsuffix"), s("showtickprefix"), s("showticksuffix"), s("separatethousands"), s("tickformat"), s("exponentformat"), s("minexponent"), s("showexponent"), s("categoryorder"), s("tickmode"), s("tickvals"), s("ticktext"), s("tick0"), s("dtick"), r.tickmode === "array" && (s("arraytick0"), s("arraydtick")), s("labelpadding"), r._hovertitle = i, u === "date") {
+            var c = IKt.getComponentMethod("calendars", "handleDefaults");
+            c(t, r, "calendar", n.calendar);
+          }
+          OKt(r, n.fullLayout), r.c2p = dC.identity;
+          var f = s("color", n.dfltColor), h = f === t.color ? f : a.color, d = s("title.text");
+          d && (dC.coerceFont(s, "title.font", a, { overrideDflt: { size: dC.bigFont(a.size), color: h } }), s("title.offset")), s("tickangle");
+          var v = s("autorange", !r.isValidRange(t.range));
+          v && s("rangemode"), s("range"), r.cleanRange(), s("fixedrange"), RKt(t, r, s, u), FKt(t, r, s, u, n), DKt(t, r, s, u, n), zKt(t, r, s, { data: n.data, dataAttr: i });
+          var _ = l("gridcolor", WZe(f, 0.3)), b = l("gridwidth"), p = l("griddash"), k = s("showgrid");
+          k || (delete r.gridcolor, delete r.gridwidth, delete r.griddash);
+          var E = l("startlinecolor", f), T = l("startlinewidth", b), L = s("startline", r.showgrid || !!E || !!T);
+          L || (delete r.startlinecolor, delete r.startlinewidth);
+          var x = l("endlinecolor", f), C = l("endlinewidth", b), M = s("endline", r.showgrid || !!x || !!C);
+          return M || (delete r.endlinecolor, delete r.endlinewidth), k ? (s("minorgridcount"), s("minorgridwidth", b), s("minorgriddash", p), s("minorgridcolor", WZe(_, 0.06)), r.minorgridcount || (delete r.minorgridwidth, delete r.minorgriddash, delete r.minorgridcolor)) : (delete r.gridcolor, delete r.gridwidth, delete r.griddash), r.showticklabels === "none" && (delete r.tickfont, delete r.tickangle, delete r.showexponent, delete r.exponentformat, delete r.minexponent, delete r.tickformat, delete r.showticksuffix, delete r.showtickprefix), r.showticksuffix || delete r.ticksuffix, r.showtickprefix || delete r.tickprefix, s("tickmode"), r;
+        };
+        function BKt(e, t) {
+          if (e.type === "-") {
+            var r = e._id, n = r.charAt(0), i = n + "calendar", a = e[i];
+            e.type = qKt(t, a, { autotypenumbers: e.autotypenumbers });
+          }
+        }
+      });
+      var KZe = ye((V2r, YZe) => {
+        var NKt = ZZe(), UKt = vl();
+        YZe.exports = function(t, r, n, i, a) {
+          var o = i("a");
+          o || (i("da"), i("a0"));
+          var s = i("b");
+          s || (i("db"), i("b0")), VKt(t, r, n, a);
+        };
+        function VKt(e, t, r, n) {
+          var i = ["aaxis", "baxis"];
+          i.forEach(function(a) {
+            var o = a.charAt(0), s = e[a] || {}, l = UKt.newContainer(t, a), u = { noAutotickangles: true, noTicklabelshift: true, noTicklabelstandoff: true, noTicklabelstep: true, tickfont: "x", id: o + "axis", letter: o, font: t.font, name: a, data: e[o], calendar: t.calendar, dfltColor: n, bgColor: r.paper_bgcolor, autotypenumbersDflt: r.autotypenumbers, fullLayout: r };
+            NKt(s, l, u), l._categories = l._categories || [], !e[a] && s.type !== "-" && (e[a] = { type: s.type });
+          });
+        }
+      });
+      var QZe = ye((G2r, $Ze) => {
+        var JZe = Dr(), GKt = jZe(), HKt = KZe(), jKt = Z7(), WKt = Ih();
+        $Ze.exports = function(t, r, n, i) {
+          function a(l, u) {
+            return JZe.coerce(t, r, jKt, l, u);
+          }
+          r._clipPathId = "clip" + r.uid + "carpet";
+          var o = a("color", WKt.defaultLine);
+          if (JZe.coerceFont(a, "font", i.font), a("carpet"), HKt(t, r, i, a, o), !r.a || !r.b) {
+            r.visible = false;
+            return;
+          }
+          r.a.length < 3 && (r.aaxis.smoothing = 0), r.b.length < 3 && (r.baxis.smoothing = 0);
+          var s = GKt(t, r, a);
+          s || (r.visible = false), r._cheater && a("cheaterslope"), a("zorder");
+        };
+      });
+      var I$ = ye((H2r, eYe) => {
+        var XKt = Dr().isArrayOrTypedArray;
+        eYe.exports = function(t, r, n) {
+          var i;
+          for (XKt(t) ? t.length > r.length && (t = t.slice(0, r.length)) : t = [], i = 0; i < r.length; i++) t[i] = n(r[i]);
+          return t;
+        };
+      });
+      var R$ = ye((j2r, tYe) => {
+        tYe.exports = function(t, r, n) {
+          if (t.length === 0) return "";
+          var i, a = [], o = n ? 3 : 1;
+          for (i = 0; i < t.length; i += o) a.push(t[i] + "," + r[i]), n && i < t.length - o && (a.push("C"), a.push([t[i + 1] + "," + r[i + 1], t[i + 2] + "," + r[i + 2] + " "].join(" ")));
+          return a.join(n ? "" : "L");
+        };
+      });
+      var iYe = ye((W2r, rYe) => {
+        rYe.exports = function(t, r, n, i, a, o) {
+          var s = a[0] * t.dpdx(r), l = a[1] * t.dpdy(n), u = 1, c = 1;
+          if (o) {
+            var f = Math.sqrt(a[0] * a[0] + a[1] * a[1]), h = Math.sqrt(o[0] * o[0] + o[1] * o[1]), d = (a[0] * o[0] + a[1] * o[1]) / f / h;
+            c = Math.max(0, d);
+          }
+          var v = Math.atan2(l, s) * 180 / Math.PI;
+          return v < -90 ? (v += 180, u = -u) : v > 90 && (v -= 180, u = -u), { angle: v, flip: u, p: t.c2p(i, r, n), offsetMultplier: c };
+        };
+      });
+      var fYe = ye((X2r, cYe) => {
+        var $7 = Oa(), Y7 = So(), K7 = I$(), oYe = R$(), vC = iYe(), D$ = Zl(), Up = Dr(), sYe = Up.strRotate, J7 = Up.strTranslate, lYe = Dh();
+        cYe.exports = function(t, r, n, i) {
+          var a = t._context.staticPlot, o = r.xaxis, s = r.yaxis, l = t._fullLayout, u = l._clips;
+          Up.makeTraceGroups(i, n, "trace").each(function(c) {
+            var f = $7.select(this), h = c[0], d = h.trace, v = d.aaxis, _ = d.baxis, b = Up.ensureSingle(f, "g", "minorlayer"), p = Up.ensureSingle(f, "g", "majorlayer"), k = Up.ensureSingle(f, "g", "boundarylayer"), E = Up.ensureSingle(f, "g", "labellayer");
+            f.style("opacity", d.opacity), G5(o, s, p, v, "a", v._gridlines, true), G5(o, s, p, _, "b", _._gridlines, true), G5(o, s, b, v, "a", v._minorgridlines, true), G5(o, s, b, _, "b", _._minorgridlines, true), G5(o, s, k, v, "a-boundary", v._boundarylines, a), G5(o, s, k, _, "b-boundary", _._boundarylines, a);
+            var T = nYe(t, o, s, d, h, E, v._labels, "a-label"), L = nYe(t, o, s, d, h, E, _._labels, "b-label");
+            YKt(t, E, d, h, o, s, T, L), ZKt(d, h, u, o, s);
+          });
+        };
+        function ZKt(e, t, r, n, i) {
+          var a, o, s, l, u = r.select("#" + e._clipPathId);
+          u.size() || (u = r.append("clipPath").classed("carpetclip", true));
+          var c = Up.ensureSingle(u, "path", "carpetboundary"), f = t.clipsegments, h = [];
+          for (l = 0; l < f.length; l++) a = f[l], o = K7([], a.x, n.c2p), s = K7([], a.y, i.c2p), h.push(oYe(o, s, a.bicubic));
+          var d = "M" + h.join("L") + "Z";
+          u.attr("id", e._clipPathId), c.attr("d", d);
+        }
+        function G5(e, t, r, n, i, a, o) {
+          var s = "const-" + i + "-lines", l = r.selectAll("." + s).data(a);
+          l.enter().append("path").classed(s, true).style("vector-effect", o ? "none" : "non-scaling-stroke"), l.each(function(u) {
+            var c = u, f = c.x, h = c.y, d = K7([], f, e.c2p), v = K7([], h, t.c2p), _ = "M" + oYe(d, v, c.smoothing), b = $7.select(this);
+            b.attr("d", _).style("stroke-width", c.width).style("stroke", c.color).style("stroke-dasharray", Y7.dashStyle(c.dash, c.width)).style("fill", "none");
+          }), l.exit().remove();
+        }
+        function nYe(e, t, r, n, i, a, o, s) {
+          var l = a.selectAll("text." + s).data(o);
+          l.enter().append("text").classed(s, true);
+          var u = 0, c = {};
+          return l.each(function(f, h) {
+            var d;
+            if (f.axis.tickangle === "auto") d = vC(n, t, r, f.xy, f.dxy);
+            else {
+              var v = (f.axis.tickangle + 180) * Math.PI / 180;
+              d = vC(n, t, r, f.xy, [Math.cos(v), Math.sin(v)]);
+            }
+            h || (c = { angle: d.angle, flip: d.flip });
+            var _ = (f.endAnchor ? -1 : 1) * d.flip, b = $7.select(this).attr({ "text-anchor": _ > 0 ? "start" : "end", "data-notex": 1 }).call(Y7.font, f.font).text(f.text).call(D$.convertToTspans, e), p = Y7.bBox(this);
+            b.attr("transform", J7(d.p[0], d.p[1]) + sYe(d.angle) + J7(f.axis.labelpadding * _, p.height * 0.3)), u = Math.max(u, p.width + f.axis.labelpadding);
+          }), l.exit().remove(), c.maxExtent = u, c;
+        }
+        function YKt(e, t, r, n, i, a, o, s) {
+          var l, u, c, f, h = Up.aggNums(Math.min, null, r.a), d = Up.aggNums(Math.max, null, r.a), v = Up.aggNums(Math.min, null, r.b), _ = Up.aggNums(Math.max, null, r.b);
+          l = 0.5 * (h + d), u = v, c = r.ab2xy(l, u, true), f = r.dxyda_rough(l, u), o.angle === void 0 && Up.extendFlat(o, vC(r, i, a, c, r.dxydb_rough(l, u))), aYe(e, t, r, n, c, f, r.aaxis, i, a, o, "a-title"), l = h, u = 0.5 * (v + _), c = r.ab2xy(l, u, true), f = r.dxydb_rough(l, u), s.angle === void 0 && Up.extendFlat(s, vC(r, i, a, c, r.dxyda_rough(l, u))), aYe(e, t, r, n, c, f, r.baxis, i, a, s, "b-title");
+        }
+        var uYe = lYe.LINE_SPACING, KKt = (1 - lYe.MID_SHIFT) / uYe + 1;
+        function aYe(e, t, r, n, i, a, o, s, l, u, c) {
+          var f = [];
+          o.title.text && f.push(o.title.text);
+          var h = t.selectAll("text." + c).data(f), d = u.maxExtent;
+          h.enter().append("text").classed(c, true), h.each(function() {
+            var v = vC(r, s, l, i, a);
+            ["start", "both"].indexOf(o.showticklabels) === -1 && (d = 0);
+            var _ = o.title.font.size;
+            d += _ + o.title.offset;
+            var b = u.angle + (u.flip < 0 ? 180 : 0), p = (b - v.angle + 450) % 360, k = p > 90 && p < 270, E = $7.select(this);
+            E.text(o.title.text).call(D$.convertToTspans, e), k && (d = (-D$.lineCount(E) + KKt) * uYe * _ - d), E.attr("transform", J7(v.p[0], v.p[1]) + sYe(v.angle) + J7(0, d)).attr("text-anchor", "middle").call(Y7.font, o.title.font);
+          }), h.exit().remove();
+        }
+      });
+      var dYe = ye((Z2r, hYe) => {
+        var Q7 = Dr().isArrayOrTypedArray;
+        hYe.exports = function(e, t, r) {
+          var n, i, a, o, s, l, u = [], c = Q7(e) ? e.length : e, f = Q7(t) ? t.length : t, h = Q7(e) ? e : null, d = Q7(t) ? t : null;
+          h && (a = (h.length - 1) / (h[h.length - 1] - h[0]) / (c - 1)), d && (o = (d.length - 1) / (d[d.length - 1] - d[0]) / (f - 1));
+          var v, _ = 1 / 0, b = -1 / 0;
+          for (i = 0; i < f; i++) for (u[i] = [], l = d ? (d[i] - d[0]) * o : i / (f - 1), n = 0; n < c; n++) s = h ? (h[n] - h[0]) * a : n / (c - 1), v = s - l * r, _ = Math.min(v, _), b = Math.max(v, b), u[i][n] = v;
+          var p = 1 / (b - _), k = -_ * p;
+          for (i = 0; i < f; i++) for (n = 0; n < c; n++) u[i][n] = p * u[i][n] + k;
+          return u;
+        };
+      });
+      var mYe = ye((Y2r, gYe) => {
+        var vYe = Dr().isArrayOrTypedArray;
+        gYe.exports = function(e) {
+          return pYe(e, 0);
+        };
+        function pYe(e, t) {
+          if (!vYe(e) || t >= 10) return null;
+          for (var r = 1 / 0, n = -1 / 0, i = e.length, a = 0; a < i; a++) {
+            var o = e[a];
+            if (vYe(o)) {
+              var s = pYe(o, t + 1);
+              s && (r = Math.min(s[0], r), n = Math.max(s[1], n));
+            } else r = Math.min(o, r), n = Math.max(o, n);
+          }
+          return [r, n];
+        }
+      });
+      var _Ye = ye((K2r, yYe) => {
+        var JKt = ho(), Ox = Ao().extendFlat;
+        yYe.exports = function(t, r, n) {
+          var i, a, o, s, l, u, c, f, h, d, v, _, b, p, k = t["_" + r], E = t[r + "axis"], T = E._gridlines = [], L = E._minorgridlines = [], x = E._boundarylines = [], C = t["_" + n], M = t[n + "axis"];
+          E.tickmode === "array" && (E.tickvals = k.slice());
+          var g = t._xctrl, P = t._yctrl, A = g[0].length, z = g.length, O = t._a.length, U = t._b.length;
+          JKt.prepTicks(E), E.tickmode === "array" && delete E.tickvals;
+          var G = E.smoothing ? 3 : 1;
+          function Z(N) {
+            var H, re, oe, _e, Ce, Le, ge, ie, Se, Ee, Ae, Be, Pe = [], me = [], De = {};
+            if (r === "b") for (re = t.b2j(N), oe = Math.floor(Math.max(0, Math.min(U - 2, re))), _e = re - oe, De.length = U, De.crossLength = O, De.xy = function(ce) {
+              return t.evalxy([], ce, re);
+            }, De.dxy = function(ce, je) {
+              return t.dxydi([], ce, oe, je, _e);
+            }, H = 0; H < O; H++) Le = Math.min(O - 2, H), ge = H - Le, ie = t.evalxy([], H, re), M.smoothing && H > 0 && (Se = t.dxydi([], H - 1, oe, 0, _e), Pe.push(Ce[0] + Se[0] / 3), me.push(Ce[1] + Se[1] / 3), Ee = t.dxydi([], H - 1, oe, 1, _e), Pe.push(ie[0] - Ee[0] / 3), me.push(ie[1] - Ee[1] / 3)), Pe.push(ie[0]), me.push(ie[1]), Ce = ie;
+            else for (H = t.a2i(N), Le = Math.floor(Math.max(0, Math.min(O - 2, H))), ge = H - Le, De.length = O, De.crossLength = U, De.xy = function(ce) {
+              return t.evalxy([], H, ce);
+            }, De.dxy = function(ce, je) {
+              return t.dxydj([], Le, ce, ge, je);
+            }, re = 0; re < U; re++) oe = Math.min(U - 2, re), _e = re - oe, ie = t.evalxy([], H, re), M.smoothing && re > 0 && (Ae = t.dxydj([], Le, re - 1, ge, 0), Pe.push(Ce[0] + Ae[0] / 3), me.push(Ce[1] + Ae[1] / 3), Be = t.dxydj([], Le, re - 1, ge, 1), Pe.push(ie[0] - Be[0] / 3), me.push(ie[1] - Be[1] / 3)), Pe.push(ie[0]), me.push(ie[1]), Ce = ie;
+            return De.axisLetter = r, De.axis = E, De.crossAxis = M, De.value = N, De.constvar = n, De.index = f, De.x = Pe, De.y = me, De.smoothing = M.smoothing, De;
+          }
+          function j(N) {
+            var H, re, oe, _e, Ce, Le = [], ge = [], ie = {};
+            if (ie.length = k.length, ie.crossLength = C.length, r === "b") for (oe = Math.max(0, Math.min(U - 2, N)), Ce = Math.min(1, Math.max(0, N - oe)), ie.xy = function(Se) {
+              return t.evalxy([], Se, N);
+            }, ie.dxy = function(Se, Ee) {
+              return t.dxydi([], Se, oe, Ee, Ce);
+            }, H = 0; H < A; H++) Le[H] = g[N * G][H], ge[H] = P[N * G][H];
+            else for (re = Math.max(0, Math.min(O - 2, N)), _e = Math.min(1, Math.max(0, N - re)), ie.xy = function(Se) {
+              return t.evalxy([], N, Se);
+            }, ie.dxy = function(Se, Ee) {
+              return t.dxydj([], re, Se, _e, Ee);
+            }, H = 0; H < z; H++) Le[H] = g[H][N * G], ge[H] = P[H][N * G];
+            return ie.axisLetter = r, ie.axis = E, ie.crossAxis = M, ie.value = k[N], ie.constvar = n, ie.index = N, ie.x = Le, ie.y = ge, ie.smoothing = M.smoothing, ie;
+          }
+          if (E.tickmode === "array") {
+            for (s = 5e-15, l = [Math.floor((k.length - 1 - E.arraytick0) / E.arraydtick * (1 + s)), Math.ceil(-E.arraytick0 / E.arraydtick / (1 + s))].sort(function(N, H) {
+              return N - H;
+            }), u = l[0] - 1, c = l[1] + 1, f = u; f < c; f++) a = E.arraytick0 + E.arraydtick * f, !(a < 0 || a > k.length - 1) && T.push(Ox(j(a), { color: E.gridcolor, width: E.gridwidth, dash: E.griddash }));
+            for (f = u; f < c; f++) if (o = E.arraytick0 + E.arraydtick * f, v = Math.min(o + E.arraydtick, k.length - 1), !(o < 0 || o > k.length - 1) && !(v < 0 || v > k.length - 1)) for (_ = k[o], b = k[v], i = 0; i < E.minorgridcount; i++) p = v - o, !(p <= 0) && (d = _ + (b - _) * (i + 1) / (E.minorgridcount + 1) * (E.arraydtick / p), !(d < k[0] || d > k[k.length - 1]) && L.push(Ox(Z(d), { color: E.minorgridcolor, width: E.minorgridwidth, dash: E.minorgriddash })));
+            E.startline && x.push(Ox(j(0), { color: E.startlinecolor, width: E.startlinewidth })), E.endline && x.push(Ox(j(k.length - 1), { color: E.endlinecolor, width: E.endlinewidth }));
+          } else {
+            for (s = 5e-15, l = [Math.floor((k[k.length - 1] - E.tick0) / E.dtick * (1 + s)), Math.ceil((k[0] - E.tick0) / E.dtick / (1 + s))].sort(function(N, H) {
+              return N - H;
+            }), u = l[0], c = l[1], f = u; f <= c; f++) h = E.tick0 + E.dtick * f, T.push(Ox(Z(h), { color: E.gridcolor, width: E.gridwidth, dash: E.griddash }));
+            for (f = u - 1; f < c + 1; f++) for (h = E.tick0 + E.dtick * f, i = 0; i < E.minorgridcount; i++) d = h + E.dtick * (i + 1) / (E.minorgridcount + 1), !(d < k[0] || d > k[k.length - 1]) && L.push(Ox(Z(d), { color: E.minorgridcolor, width: E.minorgridwidth, dash: E.minorgriddash }));
+            E.startline && x.push(Ox(Z(k[0]), { color: E.startlinecolor, width: E.startlinewidth })), E.endline && x.push(Ox(Z(k[k.length - 1]), { color: E.endlinecolor, width: E.endlinewidth }));
+          }
+        };
+      });
+      var TYe = ye((J2r, wYe) => {
+        var xYe = ho(), bYe = Ao().extendFlat;
+        wYe.exports = function(t, r) {
+          var n, i, a, o, s, l = r._labels = [], u = r._gridlines;
+          for (n = 0; n < u.length; n++) s = u[n], ["start", "both"].indexOf(r.showticklabels) !== -1 && (i = xYe.tickText(r, s.value), bYe(i, { prefix: a, suffix: o, endAnchor: true, xy: s.xy(0), dxy: s.dxy(0, 0), axis: s.axis, length: s.crossAxis.length, font: s.axis.tickfont, isFirst: n === 0, isLast: n === u.length - 1 }), l.push(i)), ["end", "both"].indexOf(r.showticklabels) !== -1 && (i = xYe.tickText(r, s.value), bYe(i, { endAnchor: false, xy: s.xy(s.crossLength - 1), dxy: s.dxy(s.crossLength - 2, 1), axis: s.axis, length: s.crossAxis.length, font: s.axis.tickfont, isFirst: n === 0, isLast: n === u.length - 1 }), l.push(i));
+        };
+      });
+      var SYe = ye(($2r, AYe) => {
+        AYe.exports = function(t, r, n, i) {
+          var a, o, s, l = [], u = !!n.smoothing, c = !!i.smoothing, f = t[0].length - 1, h = t.length - 1;
+          for (a = 0, o = [], s = []; a <= f; a++) o[a] = t[0][a], s[a] = r[0][a];
+          for (l.push({ x: o, y: s, bicubic: u }), a = 0, o = [], s = []; a <= h; a++) o[a] = t[a][f], s[a] = r[a][f];
+          for (l.push({ x: o, y: s, bicubic: c }), a = f, o = [], s = []; a >= 0; a--) o[f - a] = t[h][a], s[f - a] = r[h][a];
+          for (l.push({ x: o, y: s, bicubic: u }), a = h, o = [], s = []; a >= 0; a--) o[h - a] = t[a][0], s[h - a] = r[a][0];
+          return l.push({ x: o, y: s, bicubic: c }), l;
+        };
+      });
+      var EYe = ye((Q2r, MYe) => {
+        var $Kt = Dr();
+        MYe.exports = function(t, r, n) {
+          var i, a, o, s = [], l = [], u = t[0].length, c = t.length;
+          function f(oe, _e) {
+            var Ce = 0, Le, ge = 0;
+            return oe > 0 && (Le = t[_e][oe - 1]) !== void 0 && (ge++, Ce += Le), oe < u - 1 && (Le = t[_e][oe + 1]) !== void 0 && (ge++, Ce += Le), _e > 0 && (Le = t[_e - 1][oe]) !== void 0 && (ge++, Ce += Le), _e < c - 1 && (Le = t[_e + 1][oe]) !== void 0 && (ge++, Ce += Le), Ce / Math.max(1, ge);
+          }
+          var h = 0;
+          for (i = 0; i < u; i++) for (a = 0; a < c; a++) t[a][i] === void 0 && (s.push(i), l.push(a), t[a][i] = f(i, a)), h = Math.max(h, Math.abs(t[a][i]));
+          if (!s.length) return t;
+          var d, v, _, b, p, k, E, T, L, x, C, M = 1e-5, g = 0, P = 100, A = 0, z = s.length;
+          do {
+            for (g = 0, o = 0; o < z; o++) {
+              i = s[o], a = l[o];
+              var O = 0, U = 0, G, Z, j, N, H, re;
+              i === 0 ? (H = Math.min(u - 1, 2), j = r[H], N = r[1], G = t[a][H], Z = t[a][1], U += Z + (Z - G) * (r[0] - N) / (N - j), O++) : i === u - 1 && (H = Math.max(0, u - 3), j = r[H], N = r[u - 2], G = t[a][H], Z = t[a][u - 2], U += Z + (Z - G) * (r[u - 1] - N) / (N - j), O++), (i === 0 || i === u - 1) && a > 0 && a < c - 1 && (d = n[a + 1] - n[a], v = n[a] - n[a - 1], U += (v * t[a + 1][i] + d * t[a - 1][i]) / (v + d), O++), a === 0 ? (re = Math.min(c - 1, 2), j = n[re], N = n[1], G = t[re][i], Z = t[1][i], U += Z + (Z - G) * (n[0] - N) / (N - j), O++) : a === c - 1 && (re = Math.max(0, c - 3), j = n[re], N = n[c - 2], G = t[re][i], Z = t[c - 2][i], U += Z + (Z - G) * (n[c - 1] - N) / (N - j), O++), (a === 0 || a === c - 1) && i > 0 && i < u - 1 && (d = r[i + 1] - r[i], v = r[i] - r[i - 1], U += (v * t[a][i + 1] + d * t[a][i - 1]) / (v + d), O++), O ? U /= O : (_ = r[i + 1] - r[i], b = r[i] - r[i - 1], p = n[a + 1] - n[a], k = n[a] - n[a - 1], E = _ * b * (_ + b), T = p * k * (p + k), U = (E * (k * t[a + 1][i] + p * t[a - 1][i]) + T * (b * t[a][i + 1] + _ * t[a][i - 1])) / (T * (b + _) + E * (k + p))), L = U - t[a][i], x = L / h, g += x * x, C = O ? 0 : 0.85, t[a][i] += L * (1 + C);
+            }
+            g = Math.sqrt(g);
+          } while (A++ < P && g > M);
+          return $Kt.log("Smoother converged to", g, "after", A, "iterations"), t;
+        };
+      });
+      var CYe = ye((ewr, kYe) => {
+        kYe.exports = { RELATIVE_CULL_TOLERANCE: 1e-6 };
+      });
+      var IYe = ye((twr, PYe) => {
+        var LYe = 0.5;
+        PYe.exports = function(t, r, n, i) {
+          var a = t[0] - r[0], o = t[1] - r[1], s = n[0] - r[0], l = n[1] - r[1], u = Math.pow(a * a + o * o, LYe / 2), c = Math.pow(s * s + l * l, LYe / 2), f = (c * c * a - u * u * s) * i, h = (c * c * o - u * u * l) * i, d = c * (u + c) * 3, v = u * (u + c) * 3;
+          return [[r[0] + (d && f / d), r[1] + (d && h / d)], [r[0] - (v && f / v), r[1] - (v && h / v)]];
+        };
+      });
+      var DYe = ye((rwr, RYe) => {
+        var F$ = IYe(), e9 = Dr().ensureArray;
+        function H5(e, t, r) {
+          var n = -0.5 * r[0] + 1.5 * t[0], i = -0.5 * r[1] + 1.5 * t[1];
+          return [(2 * n + e[0]) / 3, (2 * i + e[1]) / 3];
+        }
+        RYe.exports = function(t, r, n, i, a, o) {
+          var s, l, u, c, f, h, d, v, _, b, p = n[0].length, k = n.length, E = a ? 3 * p - 2 : p, T = o ? 3 * k - 2 : k;
+          for (t = e9(t, T), r = e9(r, T), u = 0; u < T; u++) t[u] = e9(t[u], E), r[u] = e9(r[u], E);
+          for (l = 0, c = 0; l < k; l++, c += o ? 3 : 1) for (f = t[c], h = r[c], d = n[l], v = i[l], s = 0, u = 0; s < p; s++, u += a ? 3 : 1) f[u] = d[s], h[u] = v[s];
+          if (a) for (l = 0, c = 0; l < k; l++, c += o ? 3 : 1) {
+            for (s = 1, u = 3; s < p - 1; s++, u += 3) _ = F$([n[l][s - 1], i[l][s - 1]], [n[l][s], i[l][s]], [n[l][s + 1], i[l][s + 1]], a), t[c][u - 1] = _[0][0], r[c][u - 1] = _[0][1], t[c][u + 1] = _[1][0], r[c][u + 1] = _[1][1];
+            b = H5([t[c][0], r[c][0]], [t[c][2], r[c][2]], [t[c][3], r[c][3]]), t[c][1] = b[0], r[c][1] = b[1], b = H5([t[c][E - 1], r[c][E - 1]], [t[c][E - 3], r[c][E - 3]], [t[c][E - 4], r[c][E - 4]]), t[c][E - 2] = b[0], r[c][E - 2] = b[1];
+          }
+          if (o) for (u = 0; u < E; u++) {
+            for (c = 3; c < T - 3; c += 3) _ = F$([t[c - 3][u], r[c - 3][u]], [t[c][u], r[c][u]], [t[c + 3][u], r[c + 3][u]], o), t[c - 1][u] = _[0][0], r[c - 1][u] = _[0][1], t[c + 1][u] = _[1][0], r[c + 1][u] = _[1][1];
+            b = H5([t[0][u], r[0][u]], [t[2][u], r[2][u]], [t[3][u], r[3][u]]), t[1][u] = b[0], r[1][u] = b[1], b = H5([t[T - 1][u], r[T - 1][u]], [t[T - 3][u], r[T - 3][u]], [t[T - 4][u], r[T - 4][u]]), t[T - 2][u] = b[0], r[T - 2][u] = b[1];
+          }
+          if (a && o) for (c = 1; c < T; c += (c + 1) % 3 === 0 ? 2 : 1) {
+            for (u = 3; u < E - 3; u += 3) _ = F$([t[c][u - 3], r[c][u - 3]], [t[c][u], r[c][u]], [t[c][u + 3], r[c][u + 3]], a), t[c][u - 1] = 0.5 * (t[c][u - 1] + _[0][0]), r[c][u - 1] = 0.5 * (r[c][u - 1] + _[0][1]), t[c][u + 1] = 0.5 * (t[c][u + 1] + _[1][0]), r[c][u + 1] = 0.5 * (r[c][u + 1] + _[1][1]);
+            b = H5([t[c][0], r[c][0]], [t[c][2], r[c][2]], [t[c][3], r[c][3]]), t[c][1] = 0.5 * (t[c][1] + b[0]), r[c][1] = 0.5 * (r[c][1] + b[1]), b = H5([t[c][E - 1], r[c][E - 1]], [t[c][E - 3], r[c][E - 3]], [t[c][E - 4], r[c][E - 4]]), t[c][E - 2] = 0.5 * (t[c][E - 2] + b[0]), r[c][E - 2] = 0.5 * (r[c][E - 2] + b[1]);
+          }
+          return [t, r];
+        };
+      });
+      var zYe = ye((iwr, FYe) => {
+        FYe.exports = function(e, t, r, n, i) {
+          var a = t - 2, o = r - 2;
+          return n && i ? function(s, l, u) {
+            s || (s = []);
+            var c, f, h, d, v, _, b = Math.max(0, Math.min(Math.floor(l), a)), p = Math.max(0, Math.min(Math.floor(u), o)), k = Math.max(0, Math.min(1, l - b)), E = Math.max(0, Math.min(1, u - p));
+            b *= 3, p *= 3;
+            var T = k * k, L = T * k, x = 1 - k, C = x * x, M = C * x, g = E * E, P = g * E, A = 1 - E, z = A * A, O = z * A;
+            for (_ = 0; _ < e.length; _++) v = e[_], c = M * v[p][b] + 3 * (C * k * v[p][b + 1] + x * T * v[p][b + 2]) + L * v[p][b + 3], f = M * v[p + 1][b] + 3 * (C * k * v[p + 1][b + 1] + x * T * v[p + 1][b + 2]) + L * v[p + 1][b + 3], h = M * v[p + 2][b] + 3 * (C * k * v[p + 2][b + 1] + x * T * v[p + 2][b + 2]) + L * v[p + 2][b + 3], d = M * v[p + 3][b] + 3 * (C * k * v[p + 3][b + 1] + x * T * v[p + 3][b + 2]) + L * v[p + 3][b + 3], s[_] = O * c + 3 * (z * E * f + A * g * h) + P * d;
+            return s;
+          } : n ? function(s, l, u) {
+            s || (s = []);
+            var c = Math.max(0, Math.min(Math.floor(l), a)), f = Math.max(0, Math.min(Math.floor(u), o)), h = Math.max(0, Math.min(1, l - c)), d = Math.max(0, Math.min(1, u - f)), v, _, b, p, k, E;
+            c *= 3;
+            var T = h * h, L = T * h, x = 1 - h, C = x * x, M = C * x, g = 1 - d;
+            for (k = 0; k < e.length; k++) E = e[k], v = g * E[f][c] + d * E[f + 1][c], _ = g * E[f][c + 1] + d * E[f + 1][c + 1], b = g * E[f][c + 2] + d * E[f + 1][c + 1], p = g * E[f][c + 3] + d * E[f + 1][c + 1], s[k] = M * v + 3 * (C * h * _ + x * T * b) + L * p;
+            return s;
+          } : i ? function(s, l, u) {
+            s || (s = []);
+            var c = Math.max(0, Math.min(Math.floor(l), a)), f = Math.max(0, Math.min(Math.floor(u), o)), h = Math.max(0, Math.min(1, l - c)), d = Math.max(0, Math.min(1, u - f)), v, _, b, p, k, E;
+            f *= 3;
+            var T = d * d, L = T * d, x = 1 - d, C = x * x, M = C * x, g = 1 - h;
+            for (k = 0; k < e.length; k++) E = e[k], v = g * E[f][c] + h * E[f][c + 1], _ = g * E[f + 1][c] + h * E[f + 1][c + 1], b = g * E[f + 2][c] + h * E[f + 2][c + 1], p = g * E[f + 3][c] + h * E[f + 3][c + 1], s[k] = M * v + 3 * (C * d * _ + x * T * b) + L * p;
+            return s;
+          } : function(s, l, u) {
+            s || (s = []);
+            var c = Math.max(0, Math.min(Math.floor(l), a)), f = Math.max(0, Math.min(Math.floor(u), o)), h = Math.max(0, Math.min(1, l - c)), d = Math.max(0, Math.min(1, u - f)), v, _, b, p, k = 1 - d, E = 1 - h;
+            for (b = 0; b < e.length; b++) p = e[b], v = E * p[f][c] + h * p[f][c + 1], _ = E * p[f + 1][c] + h * p[f + 1][c + 1], s[b] = k * v + d * _;
+            return s;
+          };
+        };
+      });
+      var qYe = ye((nwr, OYe) => {
+        OYe.exports = function(e, t, r) {
+          return t && r ? function(n, i, a, o, s) {
+            n || (n = []);
+            var l, u, c, f, h, d;
+            i *= 3, a *= 3;
+            var v = o * o, _ = 1 - o, b = _ * _, p = _ * o * 2, k = -3 * b, E = 3 * (b - p), T = 3 * (p - v), L = 3 * v, x = s * s, C = x * s, M = 1 - s, g = M * M, P = g * M;
+            for (d = 0; d < e.length; d++) h = e[d], l = k * h[a][i] + E * h[a][i + 1] + T * h[a][i + 2] + L * h[a][i + 3], u = k * h[a + 1][i] + E * h[a + 1][i + 1] + T * h[a + 1][i + 2] + L * h[a + 1][i + 3], c = k * h[a + 2][i] + E * h[a + 2][i + 1] + T * h[a + 2][i + 2] + L * h[a + 2][i + 3], f = k * h[a + 3][i] + E * h[a + 3][i + 1] + T * h[a + 3][i + 2] + L * h[a + 3][i + 3], n[d] = P * l + 3 * (g * s * u + M * x * c) + C * f;
+            return n;
+          } : t ? function(n, i, a, o, s) {
+            n || (n = []);
+            var l, u, c, f;
+            i *= 3;
+            var h = o * o, d = 1 - o, v = d * d, _ = d * o * 2, b = -3 * v, p = 3 * (v - _), k = 3 * (_ - h), E = 3 * h, T = 1 - s;
+            for (c = 0; c < e.length; c++) f = e[c], l = b * f[a][i] + p * f[a][i + 1] + k * f[a][i + 2] + E * f[a][i + 3], u = b * f[a + 1][i] + p * f[a + 1][i + 1] + k * f[a + 1][i + 2] + E * f[a + 1][i + 3], n[c] = T * l + s * u;
+            return n;
+          } : r ? function(n, i, a, o, s) {
+            n || (n = []);
+            var l, u, c, f, h, d;
+            a *= 3;
+            var v = s * s, _ = v * s, b = 1 - s, p = b * b, k = p * b;
+            for (h = 0; h < e.length; h++) d = e[h], l = d[a][i + 1] - d[a][i], u = d[a + 1][i + 1] - d[a + 1][i], c = d[a + 2][i + 1] - d[a + 2][i], f = d[a + 3][i + 1] - d[a + 3][i], n[h] = k * l + 3 * (p * s * u + b * v * c) + _ * f;
+            return n;
+          } : function(n, i, a, o, s) {
+            n || (n = []);
+            var l, u, c, f, h = 1 - s;
+            for (c = 0; c < e.length; c++) f = e[c], l = f[a][i + 1] - f[a][i], u = f[a + 1][i + 1] - f[a + 1][i], n[c] = h * l + s * u;
+            return n;
+          };
+        };
+      });
+      var NYe = ye((awr, BYe) => {
+        BYe.exports = function(e, t, r) {
+          return t && r ? function(n, i, a, o, s) {
+            n || (n = []);
+            var l, u, c, f, h, d;
+            i *= 3, a *= 3;
+            var v = o * o, _ = v * o, b = 1 - o, p = b * b, k = p * b, E = s * s, T = 1 - s, L = T * T, x = T * s * 2, C = -3 * L, M = 3 * (L - x), g = 3 * (x - E), P = 3 * E;
+            for (d = 0; d < e.length; d++) h = e[d], l = C * h[a][i] + M * h[a + 1][i] + g * h[a + 2][i] + P * h[a + 3][i], u = C * h[a][i + 1] + M * h[a + 1][i + 1] + g * h[a + 2][i + 1] + P * h[a + 3][i + 1], c = C * h[a][i + 2] + M * h[a + 1][i + 2] + g * h[a + 2][i + 2] + P * h[a + 3][i + 2], f = C * h[a][i + 3] + M * h[a + 1][i + 3] + g * h[a + 2][i + 3] + P * h[a + 3][i + 3], n[d] = k * l + 3 * (p * o * u + b * v * c) + _ * f;
+            return n;
+          } : t ? function(n, i, a, o, s) {
+            n || (n = []);
+            var l, u, c, f, h, d;
+            i *= 3;
+            var v = s * s, _ = v * s, b = 1 - s, p = b * b, k = p * b;
+            for (h = 0; h < e.length; h++) d = e[h], l = d[a + 1][i] - d[a][i], u = d[a + 1][i + 1] - d[a][i + 1], c = d[a + 1][i + 2] - d[a][i + 2], f = d[a + 1][i + 3] - d[a][i + 3], n[h] = k * l + 3 * (p * s * u + b * v * c) + _ * f;
+            return n;
+          } : r ? function(n, i, a, o, s) {
+            n || (n = []);
+            var l, u, c, f;
+            a *= 3;
+            var h = 1 - o, d = s * s, v = 1 - s, _ = v * v, b = v * s * 2, p = -3 * _, k = 3 * (_ - b), E = 3 * (b - d), T = 3 * d;
+            for (c = 0; c < e.length; c++) f = e[c], l = p * f[a][i] + k * f[a + 1][i] + E * f[a + 2][i] + T * f[a + 3][i], u = p * f[a][i + 1] + k * f[a + 1][i + 1] + E * f[a + 2][i + 1] + T * f[a + 3][i + 1], n[c] = h * l + o * u;
+            return n;
+          } : function(n, i, a, o, s) {
+            n || (n = []);
+            var l, u, c, f, h = 1 - o;
+            for (c = 0; c < e.length; c++) f = e[c], l = f[a + 1][i] - f[a][i], u = f[a + 1][i + 1] - f[a][i + 1], n[c] = h * l + o * u;
+            return n;
+          };
+        };
+      });
+      var HYe = ye((owr, GYe) => {
+        var UYe = CYe(), VYe = U6().findBin, QKt = DYe(), eJt = zYe(), tJt = qYe(), rJt = NYe();
+        GYe.exports = function(t) {
+          var r = t._a, n = t._b, i = r.length, a = n.length, o = t.aaxis, s = t.baxis, l = r[0], u = r[i - 1], c = n[0], f = n[a - 1], h = r[r.length - 1] - r[0], d = n[n.length - 1] - n[0], v = h * UYe.RELATIVE_CULL_TOLERANCE, _ = d * UYe.RELATIVE_CULL_TOLERANCE;
+          l -= v, u += v, c -= _, f += _, t.isVisible = function(b, p) {
+            return b > l && b < u && p > c && p < f;
+          }, t.isOccluded = function(b, p) {
+            return b < l || b > u || p < c || p > f;
+          }, t.setScale = function() {
+            var b = t._x, p = t._y, k = QKt(t._xctrl, t._yctrl, b, p, o.smoothing, s.smoothing);
+            t._xctrl = k[0], t._yctrl = k[1], t.evalxy = eJt([t._xctrl, t._yctrl], i, a, o.smoothing, s.smoothing), t.dxydi = tJt([t._xctrl, t._yctrl], o.smoothing, s.smoothing), t.dxydj = rJt([t._xctrl, t._yctrl], o.smoothing, s.smoothing);
+          }, t.i2a = function(b) {
+            var p = Math.max(0, Math.floor(b[0]), i - 2), k = b[0] - p;
+            return (1 - k) * r[p] + k * r[p + 1];
+          }, t.j2b = function(b) {
+            var p = Math.max(0, Math.floor(b[1]), i - 2), k = b[1] - p;
+            return (1 - k) * n[p] + k * n[p + 1];
+          }, t.ij2ab = function(b) {
+            return [t.i2a(b[0]), t.j2b(b[1])];
+          }, t.a2i = function(b) {
+            var p = Math.max(0, Math.min(VYe(b, r), i - 2)), k = r[p], E = r[p + 1];
+            return Math.max(0, Math.min(i - 1, p + (b - k) / (E - k)));
+          }, t.b2j = function(b) {
+            var p = Math.max(0, Math.min(VYe(b, n), a - 2)), k = n[p], E = n[p + 1];
+            return Math.max(0, Math.min(a - 1, p + (b - k) / (E - k)));
+          }, t.ab2ij = function(b) {
+            return [t.a2i(b[0]), t.b2j(b[1])];
+          }, t.i2c = function(b, p) {
+            return t.evalxy([], b, p);
+          }, t.ab2xy = function(b, p, k) {
+            if (!k && (b < r[0] || b > r[i - 1] | p < n[0] || p > n[a - 1])) return [false, false];
+            var E = t.a2i(b), T = t.b2j(p), L = t.evalxy([], E, T);
+            if (k) {
+              var x = 0, C = 0, M = [], g, P, A, z;
+              b < r[0] ? (g = 0, P = 0, x = (b - r[0]) / (r[1] - r[0])) : b > r[i - 1] ? (g = i - 2, P = 1, x = (b - r[i - 1]) / (r[i - 1] - r[i - 2])) : (g = Math.max(0, Math.min(i - 2, Math.floor(E))), P = E - g), p < n[0] ? (A = 0, z = 0, C = (p - n[0]) / (n[1] - n[0])) : p > n[a - 1] ? (A = a - 2, z = 1, C = (p - n[a - 1]) / (n[a - 1] - n[a - 2])) : (A = Math.max(0, Math.min(a - 2, Math.floor(T))), z = T - A), x && (t.dxydi(M, g, A, P, z), L[0] += M[0] * x, L[1] += M[1] * x), C && (t.dxydj(M, g, A, P, z), L[0] += M[0] * C, L[1] += M[1] * C);
+            }
+            return L;
+          }, t.c2p = function(b, p, k) {
+            return [p.c2p(b[0]), k.c2p(b[1])];
+          }, t.p2x = function(b, p, k) {
+            return [p.p2c(b[0]), k.p2c(b[1])];
+          }, t.dadi = function(b) {
+            var p = Math.max(0, Math.min(r.length - 2, b));
+            return r[p + 1] - r[p];
+          }, t.dbdj = function(b) {
+            var p = Math.max(0, Math.min(n.length - 2, b));
+            return n[p + 1] - n[p];
+          }, t.dxyda = function(b, p, k, E) {
+            var T = t.dxydi(null, b, p, k, E), L = t.dadi(b, k);
+            return [T[0] / L, T[1] / L];
+          }, t.dxydb = function(b, p, k, E) {
+            var T = t.dxydj(null, b, p, k, E), L = t.dbdj(p, E);
+            return [T[0] / L, T[1] / L];
+          }, t.dxyda_rough = function(b, p, k) {
+            var E = h * (k || 0.1), T = t.ab2xy(b + E, p, true), L = t.ab2xy(b - E, p, true);
+            return [(T[0] - L[0]) * 0.5 / E, (T[1] - L[1]) * 0.5 / E];
+          }, t.dxydb_rough = function(b, p, k) {
+            var E = d * (k || 0.1), T = t.ab2xy(b, p + E, true), L = t.ab2xy(b, p - E, true);
+            return [(T[0] - L[0]) * 0.5 / E, (T[1] - L[1]) * 0.5 / E];
+          }, t.dpdx = function(b) {
+            return b._m;
+          }, t.dpdy = function(b) {
+            return b._m;
+          };
+        };
+      });
+      var $Ye = ye((swr, JYe) => {
+        var t9 = ho(), jYe = Dr().isArray1D, iJt = dYe(), WYe = mYe(), XYe = _Ye(), ZYe = TYe(), nJt = SYe(), YYe = u8(), KYe = EYe(), aJt = s8(), oJt = HYe();
+        JYe.exports = function(t, r) {
+          var n = t9.getFromId(t, r.xaxis), i = t9.getFromId(t, r.yaxis), a = r.aaxis, o = r.baxis, s = r.x, l = r.y, u = [];
+          s && jYe(s) && u.push("x"), l && jYe(l) && u.push("y"), u.length && aJt(r, a, o, "a", "b", u);
+          var c = r._a = r._a || r.a, f = r._b = r._b || r.b;
+          s = r._x || r.x, l = r._y || r.y;
+          var h = {};
+          if (r._cheater) {
+            var d = a.cheatertype === "index" ? c.length : c, v = o.cheatertype === "index" ? f.length : f;
+            s = iJt(d, v, r.cheaterslope);
+          }
+          r._x = s = YYe(s), r._y = l = YYe(l), KYe(s, c, f), KYe(l, c, f), oJt(r), r.setScale();
+          var _ = WYe(s), b = WYe(l), p = 0.5 * (_[1] - _[0]), k = 0.5 * (_[1] + _[0]), E = 0.5 * (b[1] - b[0]), T = 0.5 * (b[1] + b[0]), L = 1.3;
+          return _ = [k - p * L, k + p * L], b = [T - E * L, T + E * L], r._extremes[n._id] = t9.findExtremes(n, _, { padded: true }), r._extremes[i._id] = t9.findExtremes(i, b, { padded: true }), XYe(r, "a", "b"), XYe(r, "b", "a"), ZYe(r, a), ZYe(r, o), h.clipsegments = nJt(r._xctrl, r._yctrl, a, o), h.x = s, h.y = l, h.a = c, h.b = f, [h];
+        };
+      });
+      var eKe = ye((lwr, QYe) => {
+        QYe.exports = { attributes: Z7(), supplyDefaults: QZe(), plot: fYe(), calc: $Ye(), animatable: true, isContainer: true, moduleType: "trace", name: "carpet", basePlotModule: mh(), categories: ["cartesian", "svg", "carpet", "carpetAxis", "notLegendIsolatable", "noMultiCategory", "noHover", "noSortingByValue"], meta: {} };
+      });
+      var rKe = ye((uwr, tKe) => {
+        tKe.exports = eKe();
+      });
+      var z$ = ye((cwr, oKe) => {
+        var sJt = Pg(), c0 = pf(), lJt = Gl(), { hovertemplateAttrs: uJt, texttemplateAttrs: cJt, templatefallbackAttrs: iKe } = Ll(), nKe = Tu(), qx = Ao().extendFlat, ug = c0.marker, j5 = c0.line, aKe = ug.line;
+        oKe.exports = { carpet: { valType: "string", editType: "calc" }, a: { valType: "data_array", editType: "calc" }, b: { valType: "data_array", editType: "calc" }, mode: qx({}, c0.mode, { dflt: "markers" }), text: qx({}, c0.text, {}), texttemplate: cJt({ editType: "plot" }, { keys: ["a", "b", "text"] }), texttemplatefallback: iKe({ editType: "plot" }), hovertext: qx({}, c0.hovertext, {}), line: { color: j5.color, width: j5.width, dash: j5.dash, backoff: j5.backoff, shape: qx({}, j5.shape, { values: ["linear", "spline"] }), smoothing: j5.smoothing, editType: "calc" }, connectgaps: c0.connectgaps, fill: qx({}, c0.fill, { values: ["none", "toself", "tonext"], dflt: "none" }), fillcolor: sJt(), marker: qx({ symbol: ug.symbol, opacity: ug.opacity, maxdisplayed: ug.maxdisplayed, angle: ug.angle, angleref: ug.angleref, standoff: ug.standoff, size: ug.size, sizeref: ug.sizeref, sizemin: ug.sizemin, sizemode: ug.sizemode, line: qx({ width: aKe.width, dash: aKe.dash, editType: "calc" }, nKe("marker.line")), gradient: ug.gradient, editType: "calc" }, nKe("marker")), textfont: c0.textfont, textposition: c0.textposition, selected: c0.selected, unselected: c0.unselected, hoverinfo: qx({}, lJt.hoverinfo, { flags: ["a", "b", "text", "name"] }), hoveron: c0.hoveron, hovertemplate: uJt(), hovertemplatefallback: iKe(), zorder: c0.zorder };
+      });
+      var cKe = ye((fwr, uKe) => {
+        var sKe = Dr(), fJt = Lm(), W5 = Ru(), hJt = $p(), dJt = D0(), lKe = sT(), vJt = F0(), pJt = Fg(), gJt = z$();
+        uKe.exports = function(t, r, n, i) {
+          function a(h, d) {
+            return sKe.coerce(t, r, gJt, h, d);
+          }
+          a("carpet"), r.xaxis = "x", r.yaxis = "y";
+          var o = a("a"), s = a("b"), l = Math.min(o.length, s.length);
+          if (!l) {
+            r.visible = false;
+            return;
+          }
+          r._length = l, a("text"), a("texttemplate"), a("texttemplatefallback"), a("hovertext");
+          var u = l < fJt.PTS_LINESONLY ? "lines+markers" : "lines";
+          a("mode", u), W5.hasMarkers(r) && hJt(t, r, n, i, a, { gradient: true }), W5.hasLines(r) && (dJt(t, r, n, i, a, { backoff: true }), lKe(t, r, a), a("connectgaps")), W5.hasText(r) && vJt(t, r, i, a);
+          var c = [];
+          (W5.hasMarkers(r) || W5.hasText(r)) && (a("marker.maxdisplayed"), c.push("points")), a("fill"), r.fill !== "none" && (pJt(t, r, n, a), W5.hasLines(r) || lKe(t, r, a)), (r.fill === "tonext" || r.fill === "toself") && c.push("fills");
+          var f = a("hoveron", c.join("+") || "points");
+          f !== "fills" && (a("hovertemplate"), a("hovertemplatefallback")), a("zorder"), sKe.coerceSelectionMarkerOpacity(r, a);
+        };
+      });
+      var hKe = ye((hwr, fKe) => {
+        fKe.exports = function(t, r) {
+          var n = {}, i = r._carpet, a = i.ab2ij([t.a, t.b]), o = Math.floor(a[0]), s = a[0] - o, l = Math.floor(a[1]), u = a[1] - l, c = i.evalxy([], o, l, s, u);
+          return n.yLabel = c[1].toFixed(3), n;
+        };
+      });
+      var r9 = ye((dwr, dKe) => {
+        dKe.exports = function(e, t) {
+          for (var r = e._fullData.length, n, i = 0; i < r; i++) {
+            var a = e._fullData[i];
+            if (a.index !== t.index && a.type === "carpet" && (n || (n = a), a.carpet === t.carpet)) return a;
+          }
+          return n;
+        };
+      });
+      var gKe = ye((vwr, pKe) => {
+        var vKe = Eo(), mJt = z0(), yJt = Rm(), _Jt = O0(), xJt = q0().calcMarkerSize, bJt = r9();
+        pKe.exports = function(t, r) {
+          var n = r._carpetTrace = bJt(t, r);
+          if (!(!n || !n.visible || n.visible === "legendonly")) {
+            var i;
+            r.xaxis = n.xaxis, r.yaxis = n.yaxis;
+            var a = r._length, o = new Array(a), s, l, u = false;
+            for (i = 0; i < a; i++) if (s = r.a[i], l = r.b[i], vKe(s) && vKe(l)) {
+              var c = n.ab2xy(+s, +l, true), f = n.isVisible(+s, +l);
+              f || (u = true), o[i] = { x: c[0], y: c[1], a: s, b: l, vis: f };
+            } else o[i] = { x: false, y: false };
+            return r._needsCull = u, o[0].carpet = n, o[0].trace = r, xJt(r, a), mJt(t, r), yJt(o, r), _Jt(o, r), o;
+          }
+        };
+      });
+      var _Ke = ye((pwr, yKe) => {
+        var wJt = dT(), mKe = ho(), TJt = So();
+        yKe.exports = function(t, r, n, i) {
+          var a, o, s, l = n[0][0].carpet, u = mKe.getFromId(t, l.xaxis || "x"), c = mKe.getFromId(t, l.yaxis || "y"), f = { xaxis: u, yaxis: c, plot: r.plot };
+          for (a = 0; a < n.length; a++) o = n[a][0].trace, o._xA = u, o._yA = c;
+          for (wJt(t, f, n, i), a = 0; a < n.length; a++) o = n[a][0].trace, s = i.selectAll("g.trace" + o.uid + " .js-line"), TJt.setClipUrl(s, n[a][0].carpet._clipPathId, t);
+        };
+      });
+      var bKe = ye((gwr, xKe) => {
+        var AJt = mT(), SJt = Dr().fillText;
+        xKe.exports = function(t, r, n, i) {
+          var a = AJt(t, r, n, i);
+          if (!a || a[0].index === false) return;
+          var o = a[0];
+          if (o.index === void 0) {
+            var s = 1 - o.y0 / t.ya._length, l = t.xa._length, u = l * s / 2, c = l - u;
+            return o.x0 = Math.max(Math.min(o.x0, c), u), o.x1 = Math.max(Math.min(o.x1, c), u), a;
+          }
+          var f = o.cd[o.index];
+          o.a = f.a, o.b = f.b, o.xLabelVal = void 0, o.yLabelVal = void 0;
+          var h = o.trace, d = h._carpet, v = h._module.formatLabels(f, h);
+          o.yLabel = v.yLabel, delete o.text;
+          var _ = [];
+          function b(E, T) {
+            var L;
+            E.labelprefix && E.labelprefix.length > 0 ? L = E.labelprefix.replace(/ = $/, "") : L = E._hovertitle, _.push(L + ": " + T.toFixed(3) + E.labelsuffix);
+          }
+          if (!h.hovertemplate) {
+            var p = f.hi || h.hoverinfo, k = p.split("+");
+            k.indexOf("all") !== -1 && (k = ["a", "b", "text"]), k.indexOf("a") !== -1 && b(d.aaxis, f.a), k.indexOf("b") !== -1 && b(d.baxis, f.b), _.push("y: " + o.yLabel), k.indexOf("text") !== -1 && SJt(f, h, _), o.extraText = _.join("<br>");
+          }
+          return a;
+        };
+      });
+      var TKe = ye((mwr, wKe) => {
+        wKe.exports = function(t, r, n, i, a) {
+          var o = i[a];
+          return t.a = o.a, t.b = o.b, t.y = o.y, t;
+        };
+      });
+      var SKe = ye((ywr, AKe) => {
+        AKe.exports = { attributes: z$(), supplyDefaults: cKe(), colorbar: $d(), formatLabels: hKe(), calc: gKe(), plot: _Ke(), style: sp().style, styleOnSelect: sp().styleOnSelect, hoverPoints: bKe(), selectPoints: yT(), eventData: TKe(), moduleType: "trace", name: "scattercarpet", basePlotModule: mh(), categories: ["svg", "carpet", "symbols", "showLegend", "carpetDependent", "zoomScale"], meta: {} };
+      });
+      var EKe = ye((_wr, MKe) => {
+        MKe.exports = SKe();
+      });
+      var O$ = ye((xwr, kKe) => {
+        var cg = FT(), T1 = O4(), MJt = Tu(), EJt = Ao().extendFlat, ly = T1.contours;
+        kKe.exports = EJt({ carpet: { valType: "string", editType: "calc" }, z: cg.z, a: cg.x, a0: cg.x0, da: cg.dx, b: cg.y, b0: cg.y0, db: cg.dy, text: cg.text, hovertext: cg.hovertext, transpose: cg.transpose, atype: cg.xtype, btype: cg.ytype, fillcolor: T1.fillcolor, autocontour: T1.autocontour, ncontours: T1.ncontours, contours: { type: ly.type, start: ly.start, end: ly.end, size: ly.size, coloring: { valType: "enumerated", values: ["fill", "lines", "none"], dflt: "fill", editType: "calc" }, showlines: ly.showlines, showlabels: ly.showlabels, labelfont: ly.labelfont, labelformat: ly.labelformat, operation: ly.operation, value: ly.value, editType: "calc", impliedEdits: { autocontour: false } }, line: { color: T1.line.color, width: T1.line.width, dash: T1.line.dash, smoothing: T1.line.smoothing, editType: "plot" }, zorder: T1.zorder }, MJt("", { cLetter: "z", autoColorDflt: false }));
+      });
+      var q$ = ye((bwr, PKe) => {
+        var CKe = Dr(), kJt = n8(), LKe = O$(), CJt = RG(), LJt = k8(), PJt = C8();
+        PKe.exports = function(t, r, n, i) {
+          function a(u, c) {
+            return CKe.coerce(t, r, LKe, u, c);
+          }
+          function o(u) {
+            return CKe.coerce2(t, r, LKe, u);
+          }
+          if (a("carpet"), t.a && t.b) {
+            var s = kJt(t, r, a, i, "a", "b");
+            if (!s) {
+              r.visible = false;
+              return;
+            }
+            a("text");
+            var l = a("contours.type") === "constraint";
+            l ? CJt(t, r, a, i, n, { hasHover: false }) : (LJt(t, r, a, o), PJt(t, r, a, i, { hasHover: false }));
+          } else r._defaultColor = n, r._length = null;
+          a("zorder");
+        };
+      });
+      var FKe = ye((wwr, DKe) => {
+        var IJt = gv(), IKe = Dr(), RJt = s8(), DJt = u8(), FJt = c8(), zJt = f8(), RKe = rG(), OJt = q$(), qJt = r9(), BJt = bG();
+        DKe.exports = function(t, r) {
+          var n = r._carpetTrace = qJt(t, r);
+          if (!(!n || !n.visible || n.visible === "legendonly")) {
+            if (!r.a || !r.b) {
+              var i = t.data[n.index], a = t.data[r.index];
+              a.a || (a.a = i.a), a.b || (a.b = i.b), OJt(a, r, r._defaultColor, t._fullLayout);
+            }
+            var o = NJt(t, r);
+            return BJt(r, r._z), o;
+          }
+        };
+        function NJt(e, t) {
+          var r = t._carpetTrace, n = r.aaxis, i = r.baxis, a, o, s, l, u, c, f;
+          n._minDtick = 0, i._minDtick = 0, IKe.isArray1D(t.z) && RJt(t, n, i, "a", "b", ["z"]), a = t._a = t._a || t.a, l = t._b = t._b || t.b, a = a ? n.makeCalcdata(t, "_a") : [], l = l ? i.makeCalcdata(t, "_b") : [], o = t.a0 || 0, s = t.da || 1, u = t.b0 || 0, c = t.db || 1, f = t._z = DJt(t._z || t.z, t.transpose), t._emptypoints = zJt(f), FJt(f, t._emptypoints);
+          var h = IKe.maxRowLength(f), d = t.xtype === "scaled" ? "" : a, v = RKe(t, d, o, s, h, n), _ = t.ytype === "scaled" ? "" : l, b = RKe(t, _, u, c, f.length, i), p = { a: v, b, z: f };
+          return t.contours.type === "levels" && t.contours.coloring !== "none" && IJt(e, t, { vals: f, containerStr: "", cLetter: "z" }), [p];
+        }
+      });
+      var OKe = ye((Twr, zKe) => {
+        var UJt = Dr().isArrayOrTypedArray;
+        zKe.exports = function(e, t, r, n) {
+          var i, a, o, s, l, u, c, f, h, d, v, _, b, p = UJt(r) ? "a" : "b", k = p === "a" ? e.aaxis : e.baxis, E = k.smoothing, T = p === "a" ? e.a2i : e.b2j, L = p === "a" ? r : n, x = p === "a" ? n : r, C = p === "a" ? t.a.length : t.b.length, M = p === "a" ? t.b.length : t.a.length, g = Math.floor(p === "a" ? e.b2j(x) : e.a2i(x)), P = p === "a" ? function(_e) {
+            return e.evalxy([], _e, g);
+          } : function(_e) {
+            return e.evalxy([], g, _e);
+          };
+          E && (o = Math.max(0, Math.min(M - 2, g)), s = g - o, a = p === "a" ? function(_e, Ce) {
+            return e.dxydi([], _e, o, Ce, s);
+          } : function(_e, Ce) {
+            return e.dxydj([], o, _e, s, Ce);
+          });
+          var A = T(L[0]), z = T(L[1]), O = A < z ? 1 : -1, U = (z - A) * 1e-8, G = O > 0 ? Math.floor : Math.ceil, Z = O > 0 ? Math.ceil : Math.floor, j = O > 0 ? Math.min : Math.max, N = O > 0 ? Math.max : Math.min, H = G(A + U), re = Z(z - U);
+          c = P(A);
+          var oe = [[c]];
+          for (i = H; i * O < re * O; i += O) l = [], v = N(A, i), _ = j(z, i + O), b = _ - v, u = Math.max(0, Math.min(C - 2, Math.floor(0.5 * (v + _)))), f = P(_), E && (h = a(u, v - u), d = a(u, _ - u), l.push([c[0] + h[0] / 3 * b, c[1] + h[1] / 3 * b]), l.push([f[0] - d[0] / 3 * b, f[1] - d[1] / 3 * b])), l.push(f), oe.push(l), c = f;
+          return oe;
+        };
+      });
+      var HKe = ye((Awr, GKe) => {
+        var n9 = Oa(), a9 = I$(), VKe = R$(), pC = So(), A1 = Dr(), VJt = TG(), GJt = AG(), Tw = I8(), i9 = B4(), HJt = kG(), jJt = EG(), WJt = CG(), XJt = r9(), qKe = OKe();
+        GKe.exports = function(t, r, n, i) {
+          var a = r.xaxis, o = r.yaxis;
+          A1.makeTraceGroups(i, n, "contour").each(function(s) {
+            var l = n9.select(this), u = s[0], c = u.trace, f = c._carpetTrace = XJt(t, c), h = t.calcdata[f.index][0];
+            if (!f.visible || f.visible === "legendonly") return;
+            var d = u.a, v = u.b, _ = c.contours, b = jJt(_, r, u), p = _.type === "constraint", k = _._operation, E = p ? k === "=" ? "lines" : "fill" : _.coloring;
+            function T(G) {
+              var Z = f.ab2xy(G[0], G[1], true);
+              return [a.c2p(Z[0]), o.c2p(Z[1])];
+            }
+            var L = [[d[0], v[v.length - 1]], [d[d.length - 1], v[v.length - 1]], [d[d.length - 1], v[0]], [d[0], v[0]]];
+            VJt(b);
+            var x = (d[d.length - 1] - d[0]) * 1e-8, C = (v[v.length - 1] - v[0]) * 1e-8;
+            GJt(b, x, C);
+            var M = b;
+            _.type === "constraint" && (M = HJt(b, k)), ZJt(b, T);
+            var g, P, A, z, O = [];
+            for (z = h.clipsegments.length - 1; z >= 0; z--) g = h.clipsegments[z], P = a9([], g.x, a.c2p), A = a9([], g.y, o.c2p), P.reverse(), A.reverse(), O.push(VKe(P, A, g.bicubic));
+            var U = "M" + O.join("L") + "Z";
+            JJt(l, h.clipsegments, a, o, p, E), $Jt(c, l, a, o, M, L, T, f, h, E, U), YJt(l, b, t, u, _, r, f), pC.setClipUrl(l, f._clipPathId, t);
+          });
+        };
+        function ZJt(e, t) {
+          var r, n, i, a, o, s, l, u, c;
+          for (r = 0; r < e.length; r++) {
+            for (a = e[r], o = a.pedgepaths = [], s = a.ppaths = [], n = 0; n < a.edgepaths.length; n++) {
+              for (c = a.edgepaths[n], l = [], i = 0; i < c.length; i++) l[i] = t(c[i]);
+              o.push(l);
+            }
+            for (n = 0; n < a.paths.length; n++) {
+              for (c = a.paths[n], u = [], i = 0; i < c.length; i++) u[i] = t(c[i]);
+              s.push(u);
+            }
+          }
+        }
+        function YJt(e, t, r, n, i, a, o) {
+          var s = r._context.staticPlot, l = A1.ensureSingle(e, "g", "contourlines"), u = i.showlines !== false, c = i.showlabels, f = u && c, h = Tw.createLines(l, u || c, t, s), d = Tw.createLineClip(l, f, r, n.trace.uid), v = e.selectAll("g.contourlabels").data(c ? [0] : []);
+          if (v.exit().remove(), v.enter().append("g").classed("contourlabels", true), c) {
+            var _ = a.xaxis, b = a.yaxis, p = _._length, k = b._length, E = [[[0, 0], [p, 0], [p, k], [0, k]]], T = [];
+            A1.clearLocationCache();
+            var L = Tw.labelFormatter(r, n), x = pC.tester.append("text").attr("data-notex", 1).call(pC.font, i.labelfont), C = { left: 0, right: p, center: p / 2, top: 0, bottom: k, middle: k / 2 }, M = Math.sqrt(p * p + k * k), g = i9.LABELDISTANCE * M / Math.max(1, t.length / i9.LABELINCREASE);
+            h.each(function(P) {
+              var A = Tw.calcTextOpts(P.level, L, x, r);
+              n9.select(this).selectAll("path").each(function(z) {
+                var O = this, U = A1.getVisibleSegment(O, C, A.height / 2);
+                if (U && (KJt(O, z, P, U, o, A.height), !(U.len < (A.width + A.height) * i9.LABELMIN))) for (var G = Math.min(Math.ceil(U.len / g), i9.LABELMAX), Z = 0; Z < G; Z++) {
+                  var j = Tw.findBestTextLocation(O, U, A, T, C);
+                  if (!j) break;
+                  Tw.addLabelData(j, A, T, E);
+                }
+              });
+            }), x.remove(), Tw.drawLabels(v, T, r, d, f ? E : null);
+          }
+          c && !u && h.remove();
+        }
+        function KJt(e, t, r, n, i, a) {
+          for (var o, s = 0; s < r.pedgepaths.length; s++) t === r.pedgepaths[s] && (o = r.edgepaths[s]);
+          if (!o) return;
+          var l = i.a[0], u = i.a[i.a.length - 1], c = i.b[0], f = i.b[i.b.length - 1];
+          function h(p, k) {
+            var E = 0, T, L = 0.1;
+            return (Math.abs(p[0] - l) < L || Math.abs(p[0] - u) < L) && (T = NKe(i.dxydb_rough(p[0], p[1], L)), E = Math.max(E, a * UKe(k, T) / 2)), (Math.abs(p[1] - c) < L || Math.abs(p[1] - f) < L) && (T = NKe(i.dxyda_rough(p[0], p[1], L)), E = Math.max(E, a * UKe(k, T) / 2)), E;
+          }
+          var d = BKe(e, 0, 1), v = BKe(e, n.total, n.total - 1), _ = h(o[0], d), b = n.total - h(o[o.length - 1], v);
+          n.min < _ && (n.min = _), n.max > b && (n.max = b), n.len = n.max - n.min;
+        }
+        function BKe(e, t, r) {
+          var n = e.getPointAtLength(t), i = e.getPointAtLength(r), a = i.x - n.x, o = i.y - n.y, s = Math.sqrt(a * a + o * o);
+          return [a / s, o / s];
+        }
+        function NKe(e) {
+          var t = Math.sqrt(e[0] * e[0] + e[1] * e[1]);
+          return [e[0] / t, e[1] / t];
+        }
+        function UKe(e, t) {
+          var r = Math.abs(e[0] * t[0] + e[1] * t[1]), n = Math.sqrt(1 - r * r);
+          return n / r;
+        }
+        function JJt(e, t, r, n, i, a) {
+          var o, s, l, u, c = A1.ensureSingle(e, "g", "contourbg"), f = c.selectAll("path").data(a === "fill" && !i ? [0] : []);
+          f.enter().append("path"), f.exit().remove();
+          var h = [];
+          for (u = 0; u < t.length; u++) o = t[u], s = a9([], o.x, r.c2p), l = a9([], o.y, n.c2p), h.push(VKe(s, l, o.bicubic));
+          f.attr("d", "M" + h.join("L") + "Z").style("stroke", "none");
+        }
+        function $Jt(e, t, r, n, i, a, o, s, l, u, c) {
+          var f = u === "fill";
+          f && WJt(i, e.contours);
+          var h = A1.ensureSingle(t, "g", "contourfill"), d = h.selectAll("path").data(f ? i : []);
+          d.enter().append("path"), d.exit().remove(), d.each(function(v) {
+            var _ = (v.prefixBoundary ? c : "") + QJt(e, v, a, o, s, l, r, n);
+            _ ? n9.select(this).attr("d", _).style("stroke", "none") : n9.select(this).remove();
+          });
+        }
+        function QJt(e, t, r, n, i, a, o, s) {
+          var l, u = "", c = t.edgepaths.map(function(A, z) {
+            return z;
+          }), f = true, h, d, v, _, b, p, k = Math.abs(r[0][0] - r[2][0]) * 1e-4, E = Math.abs(r[0][1] - r[2][1]) * 1e-4;
+          function T(A) {
+            return Math.abs(A[1] - r[0][1]) < E;
+          }
+          function L(A) {
+            return Math.abs(A[1] - r[2][1]) < E;
+          }
+          function x(A) {
+            return Math.abs(A[0] - r[0][0]) < k;
+          }
+          function C(A) {
+            return Math.abs(A[0] - r[2][0]) < k;
+          }
+          function M(A, z) {
+            var O, U, G, Z, j = "";
+            for (T(A) && !C(A) || L(A) && !x(A) ? (Z = i.aaxis, G = qKe(i, a, [A[0], z[0]], 0.5 * (A[1] + z[1]))) : (Z = i.baxis, G = qKe(i, a, 0.5 * (A[0] + z[0]), [A[1], z[1]])), O = 1; O < G.length; O++) for (j += Z.smoothing ? "C" : "L", U = 0; U < G[O].length; U++) {
+              var N = G[O][U];
+              j += [o.c2p(N[0]), s.c2p(N[1])] + " ";
+            }
+            return j;
+          }
+          for (l = 0, h = null; c.length; ) {
+            var g = t.edgepaths[l][0];
+            for (h && (u += M(h, g)), p = pC.smoothopen(t.edgepaths[l].map(n), t.smoothing), u += f ? p : p.replace(/^M/, "L"), c.splice(c.indexOf(l), 1), h = t.edgepaths[l][t.edgepaths[l].length - 1], _ = -1, v = 0; v < 4; v++) {
+              if (!h) {
+                A1.log("Missing end?", l, t);
+                break;
+              }
+              for (T(h) && !C(h) ? d = r[1] : x(h) ? d = r[0] : L(h) ? d = r[3] : C(h) && (d = r[2]), b = 0; b < t.edgepaths.length; b++) {
+                var P = t.edgepaths[b][0];
+                Math.abs(h[0] - d[0]) < k ? Math.abs(h[0] - P[0]) < k && (P[1] - h[1]) * (d[1] - P[1]) >= 0 && (d = P, _ = b) : Math.abs(h[1] - d[1]) < E ? Math.abs(h[1] - P[1]) < E && (P[0] - h[0]) * (d[0] - P[0]) >= 0 && (d = P, _ = b) : A1.log("endpt to newendpt is not vert. or horz.", h, d, P);
+              }
+              if (_ >= 0) break;
+              u += M(h, d), h = d;
+            }
+            if (_ === t.edgepaths.length) {
+              A1.log("unclosed perimeter path");
+              break;
+            }
+            l = _, f = c.indexOf(l) === -1, f && (l = c[0], u += M(h, d) + "Z", h = null);
+          }
+          for (l = 0; l < t.paths.length; l++) u += pC.smoothclosed(t.paths[l].map(n), t.smoothing);
+          return u;
+        }
+      });
+      var WKe = ye((Swr, jKe) => {
+        jKe.exports = { attributes: O$(), supplyDefaults: q$(), colorbar: F8(), calc: FKe(), plot: HKe(), style: D8(), moduleType: "trace", name: "contourcarpet", basePlotModule: mh(), categories: ["cartesian", "svg", "carpet", "contour", "symbols", "showLegend", "hasLines", "carpetDependent", "noHover", "noSortingByValue"], meta: {} };
+      });
+      var ZKe = ye((Mwr, XKe) => {
+        XKe.exports = WKe();
+      });
+      var s9 = ye((Ewr, QKe) => {
+        var o9 = Dr().extendFlat, gC = pf(), YKe = df().axisHoverFormat, { hovertemplateAttrs: e$t, templatefallbackAttrs: t$t } = Ll(), JKe = Pd().dash, r$t = v3(), $Ke = JT(), i$t = $Ke.INCREASING.COLOR, n$t = $Ke.DECREASING.COLOR, B$ = gC.line;
+        function KKe(e) {
+          return { line: { color: o9({}, B$.color, { dflt: e }), width: B$.width, dash: JKe, editType: "style" }, editType: "style" };
+        }
+        QKe.exports = { xperiod: gC.xperiod, xperiod0: gC.xperiod0, xperiodalignment: gC.xperiodalignment, xhoverformat: YKe("x"), yhoverformat: YKe("y"), x: { valType: "data_array", editType: "calc+clearAxisTypes" }, open: { valType: "data_array", editType: "calc" }, high: { valType: "data_array", editType: "calc" }, low: { valType: "data_array", editType: "calc" }, close: { valType: "data_array", editType: "calc" }, line: { width: o9({}, B$.width, {}), dash: o9({}, JKe, {}), editType: "style" }, increasing: KKe(i$t), decreasing: KKe(n$t), text: { valType: "string", dflt: "", arrayOk: true, editType: "calc" }, hovertext: { valType: "string", dflt: "", arrayOk: true, editType: "calc" }, hovertemplate: e$t({}, { keys: ["open", "high", "low", "close"] }), hovertemplatefallback: t$t(), tickwidth: { valType: "number", min: 0, max: 0.5, dflt: 0.3, editType: "calc" }, hoverlabel: o9({}, r$t.hoverlabel, { split: { valType: "boolean", dflt: false, editType: "style" } }), zorder: gC.zorder };
+      });
+      var N$ = ye((kwr, eJe) => {
+        var a$t = qa(), o$t = Dr();
+        eJe.exports = function(t, r, n, i) {
+          var a = n("x"), o = n("open"), s = n("high"), l = n("low"), u = n("close");
+          n("hoverlabel.split");
+          var c = a$t.getComponentMethod("calendars", "handleTraceDefaults");
+          if (c(t, r, ["x"], i), !!(o && s && l && u)) {
+            var f = Math.min(o.length, s.length, l.length, u.length);
+            return a && (f = Math.min(f, o$t.minRowLength(a))), r._length = f, f;
+          }
+        };
+      });
+      var iJe = ye((Cwr, rJe) => {
+        var s$t = Dr(), l$t = N$(), u$t = Dg(), c$t = s9();
+        rJe.exports = function(t, r, n, i) {
+          function a(s, l) {
+            return s$t.coerce(t, r, c$t, s, l);
+          }
+          var o = l$t(t, r, a, i);
+          if (!o) {
+            r.visible = false;
+            return;
+          }
+          u$t(t, r, i, a, { x: true }), a("xhoverformat"), a("yhoverformat"), a("line.width"), a("line.dash"), tJe(t, r, a, "increasing"), tJe(t, r, a, "decreasing"), a("text"), a("hovertext"), a("hovertemplate"), a("hovertemplatefallback"), a("tickwidth"), i._requestRangeslider[r.xaxis] = true, a("zorder");
+        };
+        function tJe(e, t, r, n) {
+          r(n + ".line.color"), r(n + ".line.width", t.line.width), r(n + ".line.dash", t.line.dash);
+        }
+      });
+      var U$ = ye((Lwr, aJe) => {
+        var X5 = Dr(), l9 = X5._, u9 = ho(), f$t = zg(), mC = fs().BADNUM;
+        function h$t(e, t) {
+          var r = u9.getFromId(e, t.xaxis), n = u9.getFromId(e, t.yaxis), i = v$t(e, r, t), a = t._minDiff;
+          t._minDiff = null;
+          var o = t._origX;
+          t._origX = null;
+          var s = t._xcalc;
+          t._xcalc = null;
+          var l = nJe(e, t, o, s, n, d$t);
+          return t._extremes[r._id] = u9.findExtremes(r, s, { vpad: a / 2 }), l.length ? (X5.extendFlat(l[0].t, { wHover: a / 2, tickLen: i }), l) : [{ t: { empty: true } }];
+        }
+        function d$t(e, t, r, n) {
+          return { o: e, h: t, l: r, c: n };
+        }
+        function nJe(e, t, r, n, i, a) {
+          for (var o = i.makeCalcdata(t, "open"), s = i.makeCalcdata(t, "high"), l = i.makeCalcdata(t, "low"), u = i.makeCalcdata(t, "close"), c = X5.isArrayOrTypedArray(t.text), f = X5.isArrayOrTypedArray(t.hovertext), h = true, d = null, v = !!t.xperiodalignment, _ = [], b = 0; b < n.length; b++) {
+            var p = n[b], k = o[b], E = s[b], T = l[b], L = u[b];
+            if (p !== mC && k !== mC && E !== mC && T !== mC && L !== mC) {
+              L === k ? d !== null && L !== d && (h = L > d) : h = L > k, d = L;
+              var x = a(k, E, T, L);
+              x.pos = p, x.yc = (k + L) / 2, x.i = b, x.dir = h ? "increasing" : "decreasing", x.x = x.pos, x.y = [T, E], v && (x.orig_p = r[b]), c && (x.tx = t.text[b]), f && (x.htx = t.hovertext[b]), _.push(x);
+            } else _.push({ pos: p, empty: true });
+          }
+          return t._extremes[i._id] = u9.findExtremes(i, X5.concat(l, s), { padded: true }), _.length && (_[0].t = { labels: { open: l9(e, "open:") + " ", high: l9(e, "high:") + " ", low: l9(e, "low:") + " ", close: l9(e, "close:") + " " } }), _;
+        }
+        function v$t(e, t, r) {
+          var n = r._minDiff;
+          if (!n) {
+            var i = e._fullData, a = [];
+            n = 1 / 0;
+            var o;
+            for (o = 0; o < i.length; o++) {
+              var s = i[o];
+              if (s.type === "ohlc" && s.visible === true && s.xaxis === t._id) {
+                a.push(s);
+                var l = t.makeCalcdata(s, "x");
+                s._origX = l;
+                var u = f$t(r, t, "x", l).vals;
+                s._xcalc = u;
+                var c = X5.distinctVals(u).minDiff;
+                c && isFinite(c) && (n = Math.min(n, c));
+              }
+            }
+            for (n === 1 / 0 && (n = 1), o = 0; o < a.length; o++) a[o]._minDiff = n;
+          }
+          return n * r.tickwidth;
+        }
+        aJe.exports = { calc: h$t, calcCommon: nJe };
+      });
+      var lJe = ye((Pwr, sJe) => {
+        var p$t = Oa(), oJe = Dr();
+        sJe.exports = function(t, r, n, i) {
+          var a = r.yaxis, o = r.xaxis, s = !!o.rangebreaks;
+          oJe.makeTraceGroups(i, n, "trace ohlc").each(function(l) {
+            var u = p$t.select(this), c = l[0], f = c.t, h = c.trace;
+            if (h.visible !== true || f.empty) {
+              u.remove();
+              return;
+            }
+            var d = f.tickLen, v = u.selectAll("path").data(oJe.identity);
+            v.enter().append("path"), v.exit().remove(), v.attr("d", function(_) {
+              if (_.empty) return "M0,0Z";
+              var b = o.c2p(_.pos - d, true), p = o.c2p(_.pos + d, true), k = s ? (b + p) / 2 : o.c2p(_.pos, true), E = a.c2p(_.o, true), T = a.c2p(_.h, true), L = a.c2p(_.l, true), x = a.c2p(_.c, true);
+              return "M" + b + "," + E + "H" + k + "M" + k + "," + T + "V" + L + "M" + p + "," + x + "H" + k;
+            });
+          });
+        };
+      });
+      var cJe = ye((Iwr, uJe) => {
+        var V$ = Oa(), g$t = So(), m$t = ka();
+        uJe.exports = function(t, r, n) {
+          var i = n || V$.select(t).selectAll("g.ohlclayer").selectAll("g.trace");
+          i.style("opacity", function(a) {
+            return a[0].trace.opacity;
+          }), i.each(function(a) {
+            var o = a[0].trace;
+            V$.select(this).selectAll("path").each(function(s) {
+              if (!s.empty) {
+                var l = o[s.dir].line;
+                V$.select(this).style("fill", "none").call(m$t.stroke, l.color).call(g$t.dashLine, l.dash, l.width).style("opacity", o.selectedpoints && !s.selected ? 0.3 : 1);
+              }
+            });
+          });
+        };
+      });
+      var H$ = ye((Rwr, pJe) => {
+        var G$ = ho(), y$t = Dr(), c9 = vf(), _$t = ka(), x$t = Dr().fillText, fJe = JT(), b$t = { increasing: fJe.INCREASING.SYMBOL, decreasing: fJe.DECREASING.SYMBOL };
+        function w$t(e, t, r, n) {
+          var i = e.cd, a = i[0].trace;
+          return a.hoverlabel.split ? dJe(e, t, r, n) : vJe(e, t, r, n);
+        }
+        function hJe(e, t, r, n) {
+          var i = e.cd, a = e.xa, o = i[0].trace, s = i[0].t, l = o.type, u = l === "ohlc" ? "l" : "min", c = l === "ohlc" ? "h" : "max", f, h, d = s.bPos || 0, v = function(P) {
+            return P.pos + d - t;
+          }, _ = s.bdPos || s.tickLen, b = s.wHover, p = Math.min(1, _ / Math.abs(a.r2c(a.range[1]) - a.r2c(a.range[0])));
+          f = e.maxHoverDistance - p, h = e.maxSpikeDistance - p;
+          function k(P) {
+            var A = v(P);
+            return c9.inbox(A - b, A + b, f);
+          }
+          function E(P) {
+            var A = P[u], z = P[c];
+            return A === z || c9.inbox(A - r, z - r, f);
+          }
+          function T(P) {
+            return (k(P) + E(P)) / 2;
+          }
+          var L = c9.getDistanceFunction(n, k, E, T);
+          if (c9.getClosest(i, L, e), e.index === false) return null;
+          var x = i[e.index];
+          if (x.empty) return null;
+          var C = x.dir, M = o[C], g = M.line.color;
+          return _$t.opacity(g) && M.line.width ? e.color = g : e.color = M.fillcolor, e.x0 = a.c2p(x.pos + d - _, true), e.x1 = a.c2p(x.pos + d + _, true), e.xLabelVal = x.orig_p !== void 0 ? x.orig_p : x.pos, e.spikeDistance = T(x) * h / f, e.xSpike = a.c2p(x.pos, true), e;
+        }
+        function dJe(e, t, r, n) {
+          var i = e.cd, a = e.ya, o = i[0].trace, s = i[0].t, l = [], u = hJe(e, t, r, n);
+          if (!u) return [];
+          var c = i[u.index], f = c.hi || o.hoverinfo || "";
+          if (f === "none" || f === "skip") return [];
+          for (var h = ["high", "open", "close", "low"], d = {}, v = 0; v < h.length; v++) {
+            var _ = h[v], b = o[_][u.index], p = a.c2p(b, true), k;
+            b in d ? (k = d[b], k.yLabel += "<br>" + s.labels[_] + G$.hoverLabelText(a, b, o.yhoverformat)) : (k = y$t.extendFlat({}, u), k.y0 = k.y1 = p, k.yLabelVal = b, k.yLabel = s.labels[_] + G$.hoverLabelText(a, b, o.yhoverformat), k.name = "", l.push(k), d[b] = k);
+          }
+          return l;
+        }
+        function vJe(e, t, r, n) {
+          var i = e.cd, a = e.ya, o = i[0].trace, s = i[0].t, l = hJe(e, t, r, n);
+          if (!l) return [];
+          var u = l.index, c = i[u], f = l.index = c.i, h = c.dir;
+          function d(T) {
+            return s.labels[T] + G$.hoverLabelText(a, o[T][f], o.yhoverformat);
+          }
+          var v = c.hi || o.hoverinfo || "", _ = v.split("+"), b = v === "all", p = b || _.indexOf("y") !== -1, k = b || _.indexOf("text") !== -1, E = p ? [d("open"), d("high"), d("low"), d("close") + "  " + b$t[h]] : [];
+          return k && x$t(c, o, E), l.extraText = E.join("<br>"), l.y0 = l.y1 = a.c2p(c.yc, true), [l];
+        }
+        pJe.exports = { hoverPoints: w$t, hoverSplit: dJe, hoverOnPoints: vJe };
+      });
+      var j$ = ye((Dwr, gJe) => {
+        gJe.exports = function(t, r) {
+          var n = t.cd, i = t.xaxis, a = t.yaxis, o = [], s, l = n[0].t.bPos || 0;
+          if (r === false) for (s = 0; s < n.length; s++) n[s].selected = 0;
+          else for (s = 0; s < n.length; s++) {
+            var u = n[s];
+            r.contains([i.c2p(u.pos + l), a.c2p(u.yc)], null, u.i, t) ? (o.push({ pointNumber: u.i, x: i.c2d(u.pos), y: a.c2d(u.yc) }), u.selected = 1) : u.selected = 0;
+          }
+          return o;
+        };
+      });
+      var yJe = ye((Fwr, mJe) => {
+        mJe.exports = { moduleType: "trace", name: "ohlc", basePlotModule: mh(), categories: ["cartesian", "svg", "showLegend"], meta: {}, attributes: s9(), supplyDefaults: iJe(), calc: U$().calc, plot: lJe(), style: cJe(), hoverPoints: H$().hoverPoints, selectPoints: j$() };
+      });
+      var xJe = ye((zwr, _Je) => {
+        _Je.exports = yJe();
+      });
+      var X$ = ye((Owr, TJe) => {
+        var W$ = Dr().extendFlat, bJe = df().axisHoverFormat, vp = s9(), Z5 = k4();
+        function wJe(e) {
+          return { line: { color: W$({}, Z5.line.color, { dflt: e }), width: Z5.line.width, editType: "style" }, fillcolor: Z5.fillcolor, editType: "style" };
+        }
+        TJe.exports = { xperiod: vp.xperiod, xperiod0: vp.xperiod0, xperiodalignment: vp.xperiodalignment, xhoverformat: bJe("x"), yhoverformat: bJe("y"), x: vp.x, open: vp.open, high: vp.high, low: vp.low, close: vp.close, line: { width: W$({}, Z5.line.width, {}), editType: "style" }, increasing: wJe(vp.increasing.line.color.dflt), decreasing: wJe(vp.decreasing.line.color.dflt), text: vp.text, hovertext: vp.hovertext, hovertemplate: vp.hovertemplate, hovertemplatefallback: vp.hovertemplatefallback, whiskerwidth: W$({}, Z5.whiskerwidth, { dflt: 0 }), hoverlabel: vp.hoverlabel, zorder: Z5.zorder };
+      });
+      var MJe = ye((qwr, SJe) => {
+        var T$t = Dr(), A$t = ka(), S$t = N$(), M$t = Dg(), E$t = X$();
+        SJe.exports = function(t, r, n, i) {
+          function a(s, l) {
+            return T$t.coerce(t, r, E$t, s, l);
+          }
+          var o = S$t(t, r, a, i);
+          if (!o) {
+            r.visible = false;
+            return;
+          }
+          M$t(t, r, i, a, { x: true }), a("xhoverformat"), a("yhoverformat"), a("line.width"), AJe(t, r, a, "increasing"), AJe(t, r, a, "decreasing"), a("text"), a("hovertext"), a("hovertemplate"), a("hovertemplatefallback"), a("whiskerwidth"), i._requestRangeslider[r.xaxis] = true, a("zorder");
+        };
+        function AJe(e, t, r, n) {
+          var i = r(n + ".line.color");
+          r(n + ".line.width", t.line.width), r(n + ".fillcolor", A$t.addOpacity(i, 0.5));
+        }
+      });
+      var LJe = ye((Bwr, CJe) => {
+        var EJe = Dr(), kJe = ho(), k$t = zg(), C$t = U$().calcCommon;
+        CJe.exports = function(e, t) {
+          var r = e._fullLayout, n = kJe.getFromId(e, t.xaxis), i = kJe.getFromId(e, t.yaxis), a = n.makeCalcdata(t, "x"), o = k$t(t, n, "x", a).vals, s = C$t(e, t, a, o, i, L$t);
+          return s.length ? (EJe.extendFlat(s[0].t, { num: r._numBoxes, dPos: EJe.distinctVals(o).minDiff / 2, posLetter: "x", valLetter: "y" }), r._numBoxes++, s) : [{ t: { empty: true } }];
+        };
+        function L$t(e, t, r, n) {
+          return { min: r, q1: Math.min(e, n), med: n, q3: Math.max(e, n), max: t };
+        }
+      });
+      var IJe = ye((Nwr, PJe) => {
+        PJe.exports = { moduleType: "trace", name: "candlestick", basePlotModule: mh(), categories: ["cartesian", "svg", "showLegend", "candlestick", "boxLayout"], meta: {}, attributes: X$(), layoutAttributes: C4(), supplyLayoutDefaults: $I().supplyLayoutDefaults, crossTraceCalc: e8().crossTraceCalc, supplyDefaults: MJe(), calc: LJe(), plot: t8().plot, layerName: "boxlayer", style: r8().style, hoverPoints: H$().hoverPoints, selectPoints: j$() };
+      });
+      var DJe = ye((Uwr, RJe) => {
+        RJe.exports = IJe();
+      });
+      var Y$ = ye((Vwr, FJe) => {
+        var h9 = Dr(), P$t = xm(), f9 = h9.deg2rad, Z$ = h9.rad2deg;
+        FJe.exports = function(t, r, n) {
+          switch (P$t(t, n), t._id) {
+            case "x":
+            case "radialaxis":
+              I$t(t, r);
+              break;
+            case "angularaxis":
+              F$t(t, r);
+              break;
+          }
+        };
+        function I$t(e, t) {
+          var r = t._subplot;
+          e.setGeometry = function() {
+            var n = e._rl[0], i = e._rl[1], a = r.innerRadius, o = (r.radius - a) / (i - n), s = a / o, l = n > i ? function(u) {
+              return u <= 0;
+            } : function(u) {
+              return u >= 0;
+            };
+            e.c2g = function(u) {
+              var c = e.c2l(u) - n;
+              return (l(c) ? c : 0) + s;
+            }, e.g2c = function(u) {
+              return e.l2c(u + n - s);
+            }, e.g2p = function(u) {
+              return u * o;
+            }, e.c2p = function(u) {
+              return e.g2p(e.c2g(u));
+            };
+          };
+        }
+        function R$t(e, t) {
+          return t === "degrees" ? f9(e) : e;
+        }
+        function D$t(e, t) {
+          return t === "degrees" ? Z$(e) : e;
+        }
+        function F$t(e, t) {
+          var r = e.type;
+          if (r === "linear") {
+            var n = e.d2c, i = e.c2d;
+            e.d2c = function(a, o) {
+              return R$t(n(a), o);
+            }, e.c2d = function(a, o) {
+              return i(D$t(a, o));
+            };
+          }
+          e.makeCalcdata = function(a, o) {
+            var s = a[o], l = a._length, u, c, f = function(b) {
+              return e.d2c(b, a.thetaunit);
+            };
+            if (s) for (u = new Array(l), c = 0; c < l; c++) u[c] = f(s[c]);
+            else {
+              var h = o + "0", d = "d" + o, v = h in a ? f(a[h]) : 0, _ = a[d] ? f(a[d]) : (e.period || 2 * Math.PI) / l;
+              for (u = new Array(l), c = 0; c < l; c++) u[c] = v + c * _;
+            }
+            return u;
+          }, e.setGeometry = function() {
+            var a = t.sector, o = a.map(f9), s = { clockwise: -1, counterclockwise: 1 }[e.direction], l = f9(e.rotation), u = function(p) {
+              return s * p + l;
+            }, c = function(p) {
+              return (p - l) / s;
+            }, f, h, d, v;
+            switch (r) {
+              case "linear":
+                h = f = h9.identity, v = f9, d = Z$, e.range = h9.isFullCircle(o) ? [a[0], a[0] + 360] : o.map(c).map(Z$);
+                break;
+              case "category":
+                var _ = e._categories.length, b = e.period ? Math.max(e.period, _) : _;
+                b === 0 && (b = 1), h = v = function(p) {
+                  return p * 2 * Math.PI / b;
+                }, f = d = function(p) {
+                  return p * b / Math.PI / 2;
+                }, e.range = [0, b];
+                break;
+            }
+            e.c2g = function(p) {
+              return u(h(p));
+            }, e.g2c = function(p) {
+              return f(c(p));
+            }, e.t2g = function(p) {
+              return u(v(p));
+            }, e.g2t = function(p) {
+              return d(c(p));
+            };
+          };
+        }
+      });
+      var d9 = ye((Gwr, zJe) => {
+        zJe.exports = { attr: "subplot", name: "polar", axisNames: ["angularaxis", "radialaxis"], axisName2dataArray: { angularaxis: "theta", radialaxis: "r" }, layerNames: ["draglayer", "plotbg", "backplot", "angular-grid", "radial-grid", "frontplot", "angular-line", "radial-line", "angular-axis", "radial-axis"], radialDragBoxSize: 50, angularDragBoxSize: 30, cornerLen: 25, cornerHalfWidth: 2, MINDRAG: 8, MINZOOM: 20, OFFEDGE: 20 };
+      });
+      var p9 = ye((Hwr, UJe) => {
+        var Aw = Dr(), OJe = FM().tester, K$ = Aw.findIndexOfMin, BJe = Aw.isAngleInsideSector, z$t = Aw.angleDelta, qJe = Aw.angleDist;
+        function O$t(e, t, r, n, i) {
+          if (!BJe(t, n)) return false;
+          var a, o;
+          r[0] < r[1] ? (a = r[0], o = r[1]) : (a = r[1], o = r[0]);
+          var s = OJe(Y5(a, n[0], n[1], i)), l = OJe(Y5(o, n[0], n[1], i)), u = [e * Math.cos(t), e * Math.sin(t)];
+          return l.contains(u) && !s.contains(u);
+        }
+        function NJe(e, t, r, n) {
+          var i, a, o = n[0], s = n[1], l = v9(Math.sin(t) - Math.sin(e)), u = v9(Math.cos(t) - Math.cos(e)), c = Math.tan(r), f = v9(1 / c), h = l / u, d = s - h * o;
+          return f ? l && u ? (i = d / (c - h), a = c * i) : u ? (i = s * f, a = s) : (i = o, a = o * c) : l && u ? (i = 0, a = d) : u ? (i = 0, a = s) : i = a = NaN, [i, a];
+        }
+        function q$t(e, t, r, n) {
+          var i = -t * r, a = t * t + 1, o = 2 * (t * i - r), s = i * i + r * r - e * e, l = Math.sqrt(o * o - 4 * a * s), u = (-o + l) / (2 * a), c = (-o - l) / (2 * a);
+          return [[u, t * u + i + n], [c, t * c + i + n]];
+        }
+        function B$t(e, t) {
+          var r = t.length, n = new Array(r + 1), i;
+          for (i = 0; i < r; i++) {
+            var a = t[i];
+            n[i] = [e * Math.cos(a), e * Math.sin(a)];
+          }
+          return n[i] = n[0].slice(), n;
+        }
+        function N$t(e, t, r, n) {
+          var i = n.length, a = [], o, s;
+          function l(p) {
+            return [e * Math.cos(p), e * Math.sin(p)];
+          }
+          function u(p, k, E) {
+            return NJe(p, k, E, l(p));
+          }
+          function c(p) {
+            return Aw.mod(p, i);
+          }
+          function f(p) {
+            return BJe(p, [t, r]);
+          }
+          var h = K$(n, function(p) {
+            return f(p) ? qJe(p, t) : 1 / 0;
+          }), d = u(n[h], n[c(h - 1)], t);
+          for (a.push(d), o = h, s = 0; s < i; o++, s++) {
+            var v = n[c(o)];
+            if (!f(v)) break;
+            a.push(l(v));
+          }
+          var _ = K$(n, function(p) {
+            return f(p) ? qJe(p, r) : 1 / 0;
+          }), b = u(n[_], n[c(_ + 1)], r);
+          return a.push(b), a.push([0, 0]), a.push(a[0].slice()), a;
+        }
+        function Y5(e, t, r, n) {
+          return Aw.isFullCircle([t, r]) ? B$t(e, n) : N$t(e, t, r, n);
+        }
+        function U$t(e, t, r, n) {
+          for (var i = 1 / 0, a = 1 / 0, o = Y5(e, t, r, n), s = 0; s < o.length; s++) {
+            var l = o[s];
+            i = Math.min(i, l[0]), a = Math.min(a, -l[1]);
+          }
+          return [i, a];
+        }
+        function V$t(e, t) {
+          var r = function(a) {
+            var o = z$t(a, e);
+            return o > 0 ? o : 1 / 0;
+          }, n = K$(t, r), i = Aw.mod(n + 1, t.length);
+          return [t[n], t[i]];
+        }
+        function v9(e) {
+          return Math.abs(e) > 1e-10 ? e : 0;
+        }
+        function J$(e, t, r) {
+          t = t || 0, r = r || 0;
+          for (var n = e.length, i = new Array(n), a = 0; a < n; a++) {
+            var o = e[a];
+            i[a] = [t + o[0], r - o[1]];
+          }
+          return i;
+        }
+        function G$t(e, t, r, n, i, a) {
+          var o = Y5(e, t, r, n);
+          return "M" + J$(o, i, a).join("L");
+        }
+        function H$t(e, t, r, n, i, a, o) {
+          var s, l;
+          e < t ? (s = e, l = t) : (s = t, l = e);
+          var u = J$(Y5(s, r, n, i), a, o), c = J$(Y5(l, r, n, i), a, o);
+          return "M" + c.reverse().join("L") + "M" + u.join("L");
+        }
+        UJe.exports = { isPtInsidePolygon: O$t, findPolygonOffset: U$t, findEnclosingVertexAngles: V$t, findIntersectionXY: NJe, findXYatLength: q$t, clampTiny: v9, pathPolygon: G$t, pathPolygonAnnulus: H$t };
+      });
+      var $$ = ye((jwr, HJe) => {
+        function VJe(e) {
+          return e < 0 ? -1 : e > 0 ? 1 : 0;
+        }
+        function K5(e) {
+          var t = e[0], r = e[1];
+          if (!isFinite(t) || !isFinite(r)) return [1, 0];
+          var n = (t + 1) * (t + 1) + r * r;
+          return [(t * t + r * r - 1) / n, 2 * r / n];
+        }
+        function J5(e, t) {
+          var r = t[0], n = t[1];
+          return [r * e.radius + e.cx, -n * e.radius + e.cy];
+        }
+        function GJe(e, t) {
+          return t * e.radius;
+        }
+        function j$t(e, t, r, n) {
+          var i = J5(e, K5([r, t])), a = i[0], o = i[1], s = J5(e, K5([n, t])), l = s[0], u = s[1];
+          if (t === 0) return ["M" + a + "," + o, "L" + l + "," + u].join(" ");
+          var c = GJe(e, 1 / Math.abs(t));
+          return ["M" + a + "," + o, "A" + c + "," + c + " 0 0," + (t < 0 ? 1 : 0) + " " + l + "," + u].join(" ");
+        }
+        function W$t(e, t, r, n) {
+          var i = GJe(e, 1 / (t + 1)), a = J5(e, K5([t, r])), o = a[0], s = a[1], l = J5(e, K5([t, n])), u = l[0], c = l[1];
+          if (VJe(r) !== VJe(n)) {
+            var f = J5(e, K5([t, 0])), h = f[0], d = f[1];
+            return ["M" + o + "," + s, "A" + i + "," + i + " 0 0," + (0 < r ? 0 : 1) + " " + h + "," + d, "A" + i + "," + i + " 0 0," + (n < 0 ? 0 : 1) + u + "," + c].join(" ");
+          }
+          return ["M" + o + "," + s, "A" + i + "," + i + " 0 0," + (n < r ? 0 : 1) + " " + u + "," + c].join(" ");
+        }
+        HJe.exports = { smith: K5, reactanceArc: j$t, resistanceArc: W$t, smithTransform: J5 };
+      });
+      var tQ = ye((Wwr, QJe) => {
+        var Sw = Oa(), X$t = fd(), Ew = qa(), Xc = Dr(), uy = Xc.strRotate, xd = Xc.strTranslate, Q$ = ka(), yC = So(), Z$t = Mc(), pp = ho(), Y$t = xm(), K$t = Y$(), J$t = Mg().doAutoRange, S1 = jN(), y9 = yv(), jJe = vf(), $$t = zb(), Q$t = Of().prepSelect, eQt = Of().selectOnClick, eQ = Of().clearOutline, WJe = Eg(), XJe = bM(), ZJe = CM().redrawReglTraces, tQt = Dh().MID_SHIFT, Bx = d9(), M1 = p9(), _9 = $$(), g9 = _9.smith, rQt = _9.reactanceArc, iQt = _9.resistanceArc, m9 = _9.smithTransform, nQt = Xc._, YJe = Xc.mod, Nx = Xc.deg2rad, Mw = Xc.rad2deg;
+        function KJe(e, t, r) {
+          this.isSmith = r || false, this.id = t, this.gd = e, this._hasClipOnAxisFalse = null, this.vangles = null, this.radialAxisAngle = null, this.traceHash = {}, this.layers = {}, this.clipPaths = {}, this.clipIds = {}, this.viewInitial = {};
+          var n = e._fullLayout, i = "clip" + n._uid + t;
+          this.clipIds.forTraces = i + "-for-traces", this.clipPaths.forTraces = n._clips.append("clipPath").attr("id", this.clipIds.forTraces), this.clipPaths.forTraces.append("path"), this.framework = n["_" + (r ? "smith" : "polar") + "layer"].append("g").attr("class", t), this.getHole = function(a) {
+            return this.isSmith ? 0 : a.hole;
+          }, this.getSector = function(a) {
+            return this.isSmith ? [0, 360] : a.sector;
+          }, this.getRadial = function(a) {
+            return this.isSmith ? a.realaxis : a.radialaxis;
+          }, this.getAngular = function(a) {
+            return this.isSmith ? a.imaginaryaxis : a.angularaxis;
+          }, r || (this.radialTickLayout = null, this.angularTickLayout = null);
+        }
+        var Bd = KJe.prototype;
+        QJe.exports = function(t, r, n) {
+          return new KJe(t, r, n);
+        };
+        Bd.plot = function(e, t) {
+          for (var r = this, n = t[r.id], i = false, a = 0; a < e.length; a++) {
+            var o = e[a][0].trace;
+            if (o.cliponaxis === false) {
+              i = true;
+              break;
+            }
+          }
+          r._hasClipOnAxisFalse = i, r.updateLayers(t, n), r.updateLayout(t, n), Z$t.generalUpdatePerTraceModule(r.gd, r, e, n), r.updateFx(t, n), r.isSmith && (delete n.realaxis.range, delete n.imaginaryaxis.range);
+        };
+        Bd.updateLayers = function(e, t) {
+          var r = this, n = r.isSmith, i = r.layers, a = r.getRadial(t), o = r.getAngular(t), s = Bx.layerNames, l = s.indexOf("frontplot"), u = s.slice(0, l), c = o.layer === "below traces", f = a.layer === "below traces";
+          c && u.push("angular-line"), f && u.push("radial-line"), c && u.push("angular-axis"), f && u.push("radial-axis"), u.push("frontplot"), c || u.push("angular-line"), f || u.push("radial-line"), c || u.push("angular-axis"), f || u.push("radial-axis");
+          var h = (n ? "smith" : "polar") + "sublayer", d = r.framework.selectAll("." + h).data(u, String);
+          d.enter().append("g").attr("class", function(v) {
+            return h + " " + v;
+          }).each(function(v) {
+            var _ = i[v] = Sw.select(this);
+            switch (v) {
+              case "frontplot":
+                n || _.append("g").classed("barlayer", true), _.append("g").classed("scatterlayer", true);
+                break;
+              case "backplot":
+                _.append("g").classed("maplayer", true);
+                break;
+              case "plotbg":
+                i.bg = _.append("path");
+                break;
+              case "radial-grid":
+                _.style("fill", "none");
+                break;
+              case "angular-grid":
+                _.style("fill", "none");
+                break;
+              case "radial-line":
+                _.append("line").style("fill", "none");
+                break;
+              case "angular-line":
+                _.append("path").style("fill", "none");
+                break;
+            }
+          }), d.order();
+        };
+        Bd.updateLayout = function(e, t) {
+          var r = this, n = r.layers, i = e._size, a = r.getRadial(t), o = r.getAngular(t), s = t.domain.x, l = t.domain.y;
+          r.xOffset = i.l + i.w * s[0], r.yOffset = i.t + i.h * (1 - l[1]);
+          var u = r.xLength = i.w * (s[1] - s[0]), c = r.yLength = i.h * (l[1] - l[0]), f = r.getSector(t);
+          r.sectorInRad = f.map(Nx);
+          var h = r.sectorBBox = aQt(f), d = h[2] - h[0], v = h[3] - h[1], _ = c / u, b = Math.abs(v / d), p, k, E, T, L;
+          _ > b ? (p = u, k = u * b, L = (c - k) / i.h / 2, E = [s[0], s[1]], T = [l[0] + L, l[1] - L]) : (p = c / b, k = c, L = (u - p) / i.w / 2, E = [s[0] + L, s[1] - L], T = [l[0], l[1]]), r.xLength2 = p, r.yLength2 = k, r.xDomain2 = E, r.yDomain2 = T;
+          var x = r.xOffset2 = i.l + i.w * E[0], C = r.yOffset2 = i.t + i.h * (1 - T[1]), M = r.radius = p / d, g = r.innerRadius = r.getHole(t) * M, P = r.cx = x - M * h[0], A = r.cy = C + M * h[3], z = r.cxx = P - x, O = r.cyy = A - C, U = a.side, G;
+          U === "counterclockwise" ? (G = U, U = "top") : U === "clockwise" && (G = U, U = "bottom"), r.radialAxis = r.mockAxis(e, t, a, { _id: "x", side: U, _trueSide: G, domain: [g / i.w, M / i.w] }), r.angularAxis = r.mockAxis(e, t, o, { side: "right", domain: [0, Math.PI], autorange: false }), r.doAutoRange(e, t), r.updateAngularAxis(e, t), r.updateRadialAxis(e, t), r.updateRadialAxisTitle(e, t), r.xaxis = r.mockCartesianAxis(e, t, { _id: "x", domain: E }), r.yaxis = r.mockCartesianAxis(e, t, { _id: "y", domain: T });
+          var Z = r.pathSubplot();
+          r.clipPaths.forTraces.select("path").attr("d", Z).attr("transform", xd(z, O)), n.frontplot.attr("transform", xd(x, C)).call(yC.setClipUrl, r._hasClipOnAxisFalse ? null : r.clipIds.forTraces, r.gd), n.bg.attr("d", Z).attr("transform", xd(P, A)).call(Q$.fill, t.bgcolor);
+        };
+        Bd.mockAxis = function(e, t, r, n) {
+          var i = Xc.extendFlat({}, r, n);
+          return K$t(i, t, e), i;
+        };
+        Bd.mockCartesianAxis = function(e, t, r) {
+          var n = this, i = n.isSmith, a = r._id, o = Xc.extendFlat({ type: "linear" }, r);
+          Y$t(o, e);
+          var s = { x: [0, 2], y: [1, 3] };
+          return o.setRange = function() {
+            var l = n.sectorBBox, u = s[a], c = n.radialAxis._rl, f = (c[1] - c[0]) / (1 - n.getHole(t));
+            o.range = [l[u[0]] * f, l[u[1]] * f];
+          }, o.isPtWithinRange = a === "x" && !i ? function(l) {
+            return n.isPtInside(l);
+          } : function() {
+            return true;
+          }, o.setRange(), o.setScale(), o;
+        };
+        Bd.doAutoRange = function(e, t) {
+          var r = this, n = r.gd, i = r.radialAxis, a = r.getRadial(t);
+          J$t(n, i);
+          var o = i.range;
+          if (a.range = o.slice(), a._input.range = o.slice(), i._rl = [i.r2l(o[0], null, "gregorian"), i.r2l(o[1], null, "gregorian")], i.minallowed !== void 0) {
+            var s = i.r2l(i.minallowed);
+            i._rl[0] > i._rl[1] ? i._rl[1] = Math.max(i._rl[1], s) : i._rl[0] = Math.max(i._rl[0], s);
+          }
+          if (i.maxallowed !== void 0) {
+            var l = i.r2l(i.maxallowed);
+            i._rl[0] < i._rl[1] ? i._rl[1] = Math.min(i._rl[1], l) : i._rl[0] = Math.min(i._rl[0], l);
+          }
+        };
+        Bd.updateRadialAxis = function(e, t) {
+          var r = this, n = r.gd, i = r.layers, a = r.radius, o = r.innerRadius, s = r.cx, l = r.cy, u = r.getRadial(t), c = YJe(r.getSector(t)[0], 360), f = r.radialAxis, h = o < a, d = r.isSmith;
+          d || (r.fillViewInitialKey("radialaxis.angle", u.angle), r.fillViewInitialKey("radialaxis.range", f.range.slice()), f.setGeometry()), f.tickangle === "auto" && c > 90 && c <= 270 && (f.tickangle = 180);
+          var v = d ? function(M) {
+            var g = m9(r, g9([M.x, 0]));
+            return xd(g[0] - s, g[1] - l);
+          } : function(M) {
+            return xd(f.l2p(M.x) + o, 0);
+          }, _ = d ? function(M) {
+            return iQt(r, M.x, -1 / 0, 1 / 0);
+          } : function(M) {
+            return r.pathArc(f.r2p(M.x) + o);
+          }, b = JJe(u);
+          if (r.radialTickLayout !== b && (i["radial-axis"].selectAll(".xtick").remove(), r.radialTickLayout = b), h) {
+            f.setScale();
+            var p = 0, k = d ? (f.tickvals || []).filter(function(M) {
+              return M >= 0;
+            }).map(function(M) {
+              return pp.tickText(f, M, true, false);
+            }) : pp.calcTicks(f), E = d ? k : pp.clipEnds(f, k), T = pp.getTickSigns(f)[2];
+            d && ((f.ticks === "top" && f.side === "bottom" || f.ticks === "bottom" && f.side === "top") && (T = -T), f.ticks === "top" && f.side === "top" && (p = -f.ticklen), f.ticks === "bottom" && f.side === "bottom" && (p = f.ticklen)), pp.drawTicks(n, f, { vals: k, layer: i["radial-axis"], path: pp.makeTickPath(f, 0, T), transFn: v, crisp: false }), pp.drawGrid(n, f, { vals: E, layer: i["radial-grid"], path: _, transFn: Xc.noop, crisp: false }), pp.drawLabels(n, f, { vals: k, layer: i["radial-axis"], transFn: v, labelFns: pp.makeLabelFns(f, p) });
+          }
+          var L = r.radialAxisAngle = r.vangles ? Mw($Je(Nx(u.angle), r.vangles)) : u.angle, x = xd(s, l), C = x + uy(-L);
+          _C(i["radial-axis"], h && (u.showticklabels || u.ticks), { transform: C }), _C(i["radial-grid"], h && u.showgrid, { transform: d ? "" : x }), _C(i["radial-line"].select("line"), h && u.showline, { x1: d ? -a : o, y1: 0, x2: a, y2: 0, transform: C }).attr("stroke-width", u.linewidth).call(Q$.stroke, u.linecolor);
+        };
+        Bd.updateRadialAxisTitle = function(e, t, r) {
+          if (!this.isSmith) {
+            var n = this, i = n.gd, a = n.radius, o = n.cx, s = n.cy, l = n.getRadial(t), u = n.id + "title", c = 0;
+            if (l.title) {
+              var f = yC.bBox(n.layers["radial-axis"].node()).height, h = l.title.font.size, d = l.side;
+              c = d === "top" ? h : d === "counterclockwise" ? -(f + h * 0.4) : f + h * 0.8;
+            }
+            var v = r !== void 0 ? r : n.radialAxisAngle, _ = Nx(v), b = Math.cos(_), p = Math.sin(_), k = o + a / 2 * b + c * p, E = s - a / 2 * p + c * b;
+            n.layers["radial-axis-title"] = $$t.draw(i, u, { propContainer: l, propName: n.id + ".radialaxis.title.text", placeholder: nQt(i, "Click to enter radial axis title"), attributes: { x: k, y: E, "text-anchor": "middle" }, transform: { rotate: -v } });
+          }
+        };
+        Bd.updateAngularAxis = function(e, t) {
+          var r = this, n = r.gd, i = r.layers, a = r.radius, o = r.innerRadius, s = r.cx, l = r.cy, u = r.getAngular(t), c = r.angularAxis, f = r.isSmith;
+          f || (r.fillViewInitialKey("angularaxis.rotation", u.rotation), c.setGeometry(), c.setScale());
+          var h = f ? function(g) {
+            var P = m9(r, g9([0, g.x]));
+            return Math.atan2(P[0] - s, P[1] - l) - Math.PI / 2;
+          } : function(g) {
+            return c.t2g(g.x);
+          };
+          c.type === "linear" && c.thetaunit === "radians" && (c.tick0 = Mw(c.tick0), c.dtick = Mw(c.dtick));
+          var d = function(g) {
+            return xd(s + a * Math.cos(g), l - a * Math.sin(g));
+          }, v = f ? function(g) {
+            var P = m9(r, g9([0, g.x]));
+            return xd(P[0], P[1]);
+          } : function(g) {
+            return d(h(g));
+          }, _ = f ? function(g) {
+            var P = m9(r, g9([0, g.x])), A = Math.atan2(P[0] - s, P[1] - l) - Math.PI / 2;
+            return xd(P[0], P[1]) + uy(-Mw(A));
+          } : function(g) {
+            var P = h(g);
+            return d(P) + uy(-Mw(P));
+          }, b = f ? function(g) {
+            return rQt(r, g.x, 0, 1 / 0);
+          } : function(g) {
+            var P = h(g), A = Math.cos(P), z = Math.sin(P);
+            return "M" + [s + o * A, l - o * z] + "L" + [s + a * A, l - a * z];
+          }, p = pp.makeLabelFns(c, 0), k = p.labelStandoff, E = {};
+          E.xFn = function(g) {
+            var P = h(g);
+            return Math.cos(P) * k;
+          }, E.yFn = function(g) {
+            var P = h(g), A = Math.sin(P) > 0 ? 0.2 : 1;
+            return -Math.sin(P) * (k + g.fontSize * A) + Math.abs(Math.cos(P)) * (g.fontSize * tQt);
+          }, E.anchorFn = function(g) {
+            var P = h(g), A = Math.cos(P);
+            return Math.abs(A) < 0.1 ? "middle" : A > 0 ? "start" : "end";
+          }, E.heightFn = function(g, P, A) {
+            var z = h(g);
+            return -0.5 * (1 + Math.sin(z)) * A;
+          };
+          var T = JJe(u);
+          r.angularTickLayout !== T && (i["angular-axis"].selectAll("." + c._id + "tick").remove(), r.angularTickLayout = T);
+          var L = f ? [1 / 0].concat(c.tickvals || []).map(function(g) {
+            return pp.tickText(c, g, true, false);
+          }) : pp.calcTicks(c);
+          f && (L[0].text = "∞", L[0].fontSize *= 1.75);
+          var x;
+          if (t.gridshape === "linear" ? (x = L.map(h), Xc.angleDelta(x[0], x[1]) < 0 && (x = x.slice().reverse())) : x = null, r.vangles = x, c.type === "category" && (L = L.filter(function(g) {
+            return Xc.isAngleInsideSector(h(g), r.sectorInRad);
+          })), c.visible) {
+            var C = c.ticks === "inside" ? -1 : 1, M = (c.linewidth || 1) / 2;
+            pp.drawTicks(n, c, { vals: L, layer: i["angular-axis"], path: "M" + C * M + ",0h" + C * c.ticklen, transFn: _, crisp: false }), pp.drawGrid(n, c, { vals: L, layer: i["angular-grid"], path: b, transFn: Xc.noop, crisp: false }), pp.drawLabels(n, c, { vals: L, layer: i["angular-axis"], repositionOnUpdate: true, transFn: v, labelFns: E });
+          }
+          _C(i["angular-line"].select("path"), u.showline, { d: r.pathSubplot(), transform: xd(s, l) }).attr("stroke-width", u.linewidth).call(Q$.stroke, u.linecolor);
+        };
+        Bd.updateFx = function(e, t) {
+          if (!this.gd._context.staticPlot) {
+            var r = !this.isSmith;
+            r && (this.updateAngularDrag(e), this.updateRadialDrag(e, t, 0), this.updateRadialDrag(e, t, 1)), this.updateHoverAndMainDrag(e);
+          }
+        };
+        Bd.updateHoverAndMainDrag = function(e) {
+          var t = this, r = t.isSmith, n = t.gd, i = t.layers, a = e._zoomlayer, o = Bx.MINZOOM, s = Bx.OFFEDGE, l = t.radius, u = t.innerRadius, c = t.cx, f = t.cy, h = t.cxx, d = t.cyy, v = t.sectorInRad, _ = t.vangles, b = t.radialAxis, p = M1.clampTiny, k = M1.findXYatLength, E = M1.findEnclosingVertexAngles, T = Bx.cornerHalfWidth, L = Bx.cornerLen / 2, x, C, M = S1.makeDragger(i, "path", "maindrag", e.dragmode === false ? "none" : "crosshair");
+          Sw.select(M).attr("d", t.pathSubplot()).attr("transform", xd(c, f)), M.onmousemove = function(ce) {
+            jJe.hover(n, ce, t.id), n._fullLayout._lasthover = M, n._fullLayout._hoversubplot = t.id;
+          }, M.onmouseout = function(ce) {
+            n._dragging || y9.unhover(n, ce);
+          };
+          var g = { element: M, gd: n, subplot: t.id, plotinfo: { id: t.id, xaxis: t.xaxis, yaxis: t.yaxis }, xaxes: [t.xaxis], yaxes: [t.yaxis] }, P, A, z, O, U, G, Z, j, N;
+          function H(ce, je) {
+            return Math.sqrt(ce * ce + je * je);
+          }
+          function re(ce, je) {
+            return H(ce - h, je - d);
+          }
+          function oe(ce, je) {
+            return Math.atan2(d - je, ce - h);
+          }
+          function _e(ce, je) {
+            return [ce * Math.cos(je), ce * Math.sin(-je)];
+          }
+          function Ce(ce, je) {
+            if (ce === 0) return t.pathSector(2 * T);
+            var lt = L / ce, pt = je - lt, Vt = je + lt, ot = Math.max(0, Math.min(ce, l)), ut = ot - T, Wt = ot + T;
+            return "M" + _e(ut, pt) + "A" + [ut, ut] + " 0,0,0 " + _e(ut, Vt) + "L" + _e(Wt, Vt) + "A" + [Wt, Wt] + " 0,0,1 " + _e(Wt, pt) + "Z";
+          }
+          function Le(ce, je, lt) {
+            if (ce === 0) return t.pathSector(2 * T);
+            var pt = _e(ce, je), Vt = _e(ce, lt), ot = p((pt[0] + Vt[0]) / 2), ut = p((pt[1] + Vt[1]) / 2), Wt, Nt;
+            if (ot && ut) {
+              var $t = ut / ot, sr = -1 / $t, Tr = k(T, $t, ot, ut);
+              Wt = k(L, sr, Tr[0][0], Tr[0][1]), Nt = k(L, sr, Tr[1][0], Tr[1][1]);
+            } else {
+              var fr, $e;
+              ut ? (fr = L, $e = T) : (fr = T, $e = L), Wt = [[ot - fr, ut - $e], [ot + fr, ut - $e]], Nt = [[ot - fr, ut + $e], [ot + fr, ut + $e]];
+            }
+            return "M" + Wt.join("L") + "L" + Nt.reverse().join("L") + "Z";
+          }
+          function ge() {
+            z = null, O = null, U = t.pathSubplot(), G = false;
+            var ce = n._fullLayout[t.id];
+            Z = X$t(ce.bgcolor).getLuminance(), j = S1.makeZoombox(a, Z, c, f, U), j.attr("fill-rule", "evenodd"), N = S1.makeCorners(a, c, f), eQ(n);
+          }
+          function ie(ce, je) {
+            return je = Math.max(Math.min(je, l), u), ce < s ? ce = 0 : l - ce < s ? ce = l : je < s ? je = 0 : l - je < s && (je = l), Math.abs(je - ce) > o ? (ce < je ? (z = ce, O = je) : (z = je, O = ce), true) : (z = null, O = null, false);
+          }
+          function Se(ce, je) {
+            ce = ce || U, je = je || "M0,0Z", j.attr("d", ce), N.attr("d", je), S1.transitionZoombox(j, N, G, Z), G = true;
+            var lt = {};
+            me(lt), n.emit("plotly_relayouting", lt);
+          }
+          function Ee(ce, je) {
+            ce = ce * x, je = je * C;
+            var lt = P + ce, pt = A + je, Vt = re(P, A), ot = Math.min(re(lt, pt), l), ut = oe(P, A), Wt, Nt;
+            ie(Vt, ot) && (Wt = U + t.pathSector(O), z && (Wt += t.pathSector(z)), Nt = Ce(z, ut) + Ce(O, ut)), Se(Wt, Nt);
+          }
+          function Ae(ce, je, lt, pt) {
+            var Vt = M1.findIntersectionXY(lt, pt, lt, [ce - h, d - je]);
+            return H(Vt[0], Vt[1]);
+          }
+          function Be(ce, je) {
+            var lt = P + ce, pt = A + je, Vt = oe(P, A), ot = oe(lt, pt), ut = E(Vt, _), Wt = E(ot, _), Nt = Ae(P, A, ut[0], ut[1]), $t = Math.min(Ae(lt, pt, Wt[0], Wt[1]), l), sr, Tr;
+            ie(Nt, $t) && (sr = U + t.pathSector(O), z && (sr += t.pathSector(z)), Tr = [Le(z, ut[0], ut[1]), Le(O, ut[0], ut[1])].join(" ")), Se(sr, Tr);
+          }
+          function Pe() {
+            if (S1.removeZoombox(n), !(z === null || O === null)) {
+              var ce = {};
+              me(ce), S1.showDoubleClickNotifier(n), Ew.call("_guiRelayout", n, ce);
+            }
+          }
+          function me(ce) {
+            var je = b._rl, lt = (je[1] - je[0]) / (1 - u / l) / l, pt = [je[0] + (z - u) * lt, je[0] + (O - u) * lt];
+            ce[t.id + ".radialaxis.range"] = pt;
+          }
+          function De(ce, je) {
+            var lt = n._fullLayout.clickmode;
+            if (S1.removeZoombox(n), ce === 2) {
+              var pt = {};
+              for (var Vt in t.viewInitial) pt[t.id + "." + Vt] = t.viewInitial[Vt];
+              n.emit("plotly_doubleclick", null), Ew.call("_guiRelayout", n, pt);
+            }
+            lt.indexOf("select") > -1 && ce === 1 && eQt(je, n, [t.xaxis], [t.yaxis], t.id, g), lt.indexOf("event") > -1 && jJe.click(n, je, t.id);
+          }
+          g.prepFn = function(ce, je, lt) {
+            var pt = n._fullLayout.dragmode, Vt = M.getBoundingClientRect();
+            n._fullLayout._calcInverseTransform(n);
+            var ot = n._fullLayout._invTransform;
+            x = n._fullLayout._invScaleX, C = n._fullLayout._invScaleY;
+            var ut = Xc.apply3DTransform(ot)(je - Vt.left, lt - Vt.top);
+            if (P = ut[0], A = ut[1], _) {
+              var Wt = M1.findPolygonOffset(l, v[0], v[1], _);
+              P += h + Wt[0], A += d + Wt[1];
+            }
+            switch (pt) {
+              case "zoom":
+                g.clickFn = De, r || (_ ? g.moveFn = Be : g.moveFn = Ee, g.doneFn = Pe, ge());
+                break;
+              case "select":
+              case "lasso":
+                Q$t(ce, je, lt, g, pt);
+                break;
+            }
+          }, y9.init(g);
+        };
+        Bd.updateRadialDrag = function(e, t, r) {
+          var n = this, i = n.gd, a = n.layers, o = n.radius, s = n.innerRadius, l = n.cx, u = n.cy, c = n.radialAxis, f = Bx.radialDragBoxSize, h = f / 2;
+          if (!c.visible) return;
+          var d = Nx(n.radialAxisAngle), v = c._rl, _ = v[0], b = v[1], p = v[r], k = 0.75 * (v[1] - v[0]) / (1 - n.getHole(t)) / o, E, T, L;
+          r ? (E = l + (o + h) * Math.cos(d), T = u - (o + h) * Math.sin(d), L = "radialdrag") : (E = l + (s - h) * Math.cos(d), T = u - (s - h) * Math.sin(d), L = "radialdrag-inner");
+          var x = S1.makeRectDragger(a, L, "crosshair", -h, -h, f, f), C = { element: x, gd: i };
+          e.dragmode === false && (C.dragmode = false), _C(Sw.select(x), c.visible && s < o, { transform: xd(E, T) });
+          var M, g, P;
+          function A(Z, j) {
+            if (M) M(Z, j);
+            else {
+              var N = [Z, -j], H = [Math.cos(d), Math.sin(d)], re = Math.abs(Xc.dot(N, H) / Math.sqrt(Xc.dot(N, N)));
+              isNaN(re) || (M = re < 0.5 ? U : G);
+            }
+            var oe = {};
+            z(oe), i.emit("plotly_relayouting", oe);
+          }
+          function z(Z) {
+            g !== null ? Z[n.id + ".radialaxis.angle"] = g : P !== null && (Z[n.id + ".radialaxis.range[" + r + "]"] = P);
+          }
+          function O() {
+            g !== null ? Ew.call("_guiRelayout", i, n.id + ".radialaxis.angle", g) : P !== null && Ew.call("_guiRelayout", i, n.id + ".radialaxis.range[" + r + "]", P);
+          }
+          function U(Z, j) {
+            if (r !== 0) {
+              var N = E + Z, H = T + j;
+              g = Math.atan2(u - H, N - l), n.vangles && (g = $Je(g, n.vangles)), g = Mw(g);
+              var re = xd(l, u) + uy(-g);
+              a["radial-axis"].attr("transform", re), a["radial-line"].select("line").attr("transform", re);
+              var oe = n.gd._fullLayout, _e = oe[n.id];
+              n.updateRadialAxisTitle(oe, _e, g);
+            }
+          }
+          function G(Z, j) {
+            var N = Xc.dot([Z, -j], [Math.cos(d), Math.sin(d)]);
+            if (P = p - k * N, k > 0 != (r ? P > _ : P < b)) {
+              P = null;
+              return;
+            }
+            var H = i._fullLayout, re = H[n.id];
+            c.range[r] = P, c._rl[r] = P, n.updateRadialAxis(H, re), n.xaxis.setRange(), n.xaxis.setScale(), n.yaxis.setRange(), n.yaxis.setScale();
+            var oe = false;
+            for (var _e in n.traceHash) {
+              var Ce = n.traceHash[_e], Le = Xc.filterVisible(Ce), ge = Ce[0][0].trace._module;
+              ge.plot(i, n, Le, re), Ew.traceIs(_e, "gl") && Le.length && (oe = true);
+            }
+            oe && (XJe(i), ZJe(i));
+          }
+          C.prepFn = function() {
+            M = null, g = null, P = null, C.moveFn = A, C.doneFn = O, eQ(i);
+          }, C.clampFn = function(Z, j) {
+            return Math.sqrt(Z * Z + j * j) < Bx.MINDRAG && (Z = 0, j = 0), [Z, j];
+          }, y9.init(C);
+        };
+        Bd.updateAngularDrag = function(e) {
+          var t = this, r = t.gd, n = t.layers, i = t.radius, a = t.angularAxis, o = t.cx, s = t.cy, l = t.cxx, u = t.cyy, c = Bx.angularDragBoxSize, f = S1.makeDragger(n, "path", "angulardrag", e.dragmode === false ? "none" : "move"), h = { element: f, gd: r };
+          e.dragmode === false ? h.dragmode = false : Sw.select(f).attr("d", t.pathAnnulus(i, i + c)).attr("transform", xd(o, s)).call(WJe, "move");
+          function d(P, A) {
+            return Math.atan2(u + c - A, P - l - c);
+          }
+          var v = n.frontplot.select(".scatterlayer").selectAll(".trace"), _ = v.selectAll(".point"), b = v.selectAll(".textpoint"), p, k, E, T, L, x;
+          function C(P, A) {
+            var z = t.gd._fullLayout, O = z[t.id], U = p + P * e._invScaleX, G = k + A * e._invScaleY, Z = d(U, G), j = Mw(Z - x);
+            if (T = E + j, n.frontplot.attr("transform", xd(t.xOffset2, t.yOffset2) + uy([-j, l, u])), t.vangles) {
+              L = t.radialAxisAngle + j;
+              var N = xd(o, s) + uy(-j), H = xd(o, s) + uy(-L);
+              n.bg.attr("transform", N), n["radial-grid"].attr("transform", N), n["radial-axis"].attr("transform", H), n["radial-line"].select("line").attr("transform", H), t.updateRadialAxisTitle(z, O, L);
+            } else t.clipPaths.forTraces.select("path").attr("transform", xd(l, u) + uy(j));
+            _.each(function() {
+              var ie = Sw.select(this), Se = yC.getTranslate(ie);
+              ie.attr("transform", xd(Se.x, Se.y) + uy([j]));
+            }), b.each(function() {
+              var ie = Sw.select(this), Se = ie.select("text"), Ee = yC.getTranslate(ie);
+              ie.attr("transform", uy([j, Se.attr("x"), Se.attr("y")]) + xd(Ee.x, Ee.y));
+            }), a.rotation = Xc.modHalf(T, 360), t.updateAngularAxis(z, O), t._hasClipOnAxisFalse && !Xc.isFullCircle(t.sectorInRad) && v.call(yC.hideOutsideRangePoints, t);
+            var re = false;
+            for (var oe in t.traceHash) if (Ew.traceIs(oe, "gl")) {
+              var _e = t.traceHash[oe], Ce = Xc.filterVisible(_e), Le = _e[0][0].trace._module;
+              Le.plot(r, t, Ce, O), Ce.length && (re = true);
+            }
+            re && (XJe(r), ZJe(r));
+            var ge = {};
+            M(ge), r.emit("plotly_relayouting", ge);
+          }
+          function M(P) {
+            P[t.id + ".angularaxis.rotation"] = T, t.vangles && (P[t.id + ".radialaxis.angle"] = L);
+          }
+          function g() {
+            b.select("text").attr("transform", null);
+            var P = {};
+            M(P), Ew.call("_guiRelayout", r, P);
+          }
+          h.prepFn = function(P, A, z) {
+            var O = e[t.id];
+            E = O.angularaxis.rotation;
+            var U = f.getBoundingClientRect();
+            p = A - U.left, k = z - U.top, r._fullLayout._calcInverseTransform(r);
+            var G = Xc.apply3DTransform(e._invTransform)(p, k);
+            p = G[0], k = G[1], x = d(p, k), h.moveFn = C, h.doneFn = g, eQ(r);
+          }, t.vangles && !Xc.isFullCircle(t.sectorInRad) && (h.prepFn = Xc.noop, WJe(Sw.select(f), null)), y9.init(h);
+        };
+        Bd.isPtInside = function(e) {
+          if (this.isSmith) return true;
+          var t = this.sectorInRad, r = this.vangles, n = this.angularAxis.c2g(e.theta), i = this.radialAxis, a = i.c2l(e.r), o = i._rl, s = r ? M1.isPtInsidePolygon : Xc.isPtInsideSector;
+          return s(a, n, o, t, r);
+        };
+        Bd.pathArc = function(e) {
+          var t = this.sectorInRad, r = this.vangles, n = r ? M1.pathPolygon : Xc.pathArc;
+          return n(e, t[0], t[1], r);
+        };
+        Bd.pathSector = function(e) {
+          var t = this.sectorInRad, r = this.vangles, n = r ? M1.pathPolygon : Xc.pathSector;
+          return n(e, t[0], t[1], r);
+        };
+        Bd.pathAnnulus = function(e, t) {
+          var r = this.sectorInRad, n = this.vangles, i = n ? M1.pathPolygonAnnulus : Xc.pathAnnulus;
+          return i(e, t, r[0], r[1], n);
+        };
+        Bd.pathSubplot = function() {
+          var e = this.innerRadius, t = this.radius;
+          return e ? this.pathAnnulus(e, t) : this.pathSector(t);
+        };
+        Bd.fillViewInitialKey = function(e, t) {
+          e in this.viewInitial || (this.viewInitial[e] = t);
+        };
+        function JJe(e) {
+          var t = e.ticks + String(e.ticklen) + String(e.showticklabels);
+          return "side" in e && (t += e.side), t;
+        }
+        function aQt(e) {
+          var t = e[0], r = e[1], n = r - t, i = YJe(t, 360), a = i + n, o = Math.cos(Nx(i)), s = Math.sin(Nx(i)), l = Math.cos(Nx(a)), u = Math.sin(Nx(a)), c, f, h, d;
+          return i <= 90 && a >= 90 || i > 90 && a >= 450 ? d = 1 : s <= 0 && u <= 0 ? d = 0 : d = Math.max(s, u), i <= 180 && a >= 180 || i > 180 && a >= 540 ? c = -1 : o >= 0 && l >= 0 ? c = 0 : c = Math.min(o, l), i <= 270 && a >= 270 || i > 270 && a >= 630 ? f = -1 : s >= 0 && u >= 0 ? f = 0 : f = Math.min(s, u), a >= 360 ? h = 1 : o <= 0 && l <= 0 ? h = 0 : h = Math.max(o, l), [c, f, h, d];
+        }
+        function $Je(e, t) {
+          var r = function(i) {
+            return Xc.angleDist(e, i);
+          }, n = Xc.findIndexOfMin(t, r);
+          return t[n];
+        }
+        function _C(e, t, r) {
+          return t ? (e.attr("display", null), e.attr(r)) : e && e.attr("display", "none"), e;
+        }
+      });
+      var rQ = ye((Xwr, a$e) => {
+        var oQt = Ih(), os = Rd(), sQt = Cc().attributes, f0 = Dr().extendFlat, e$e = mc().overrideAll, t$e = e$e({ color: os.color, showline: f0({}, os.showline, { dflt: true }), linecolor: os.linecolor, linewidth: os.linewidth, showgrid: f0({}, os.showgrid, { dflt: true }), gridcolor: os.gridcolor, gridwidth: os.gridwidth, griddash: os.griddash }, "plot", "from-root"), r$e = e$e({ tickmode: os.minor.tickmode, nticks: os.nticks, tick0: os.tick0, dtick: os.dtick, tickvals: os.tickvals, ticktext: os.ticktext, ticks: os.ticks, ticklen: os.ticklen, tickwidth: os.tickwidth, tickcolor: os.tickcolor, ticklabelstep: os.ticklabelstep, showticklabels: os.showticklabels, labelalias: os.labelalias, minorloglabels: os.minorloglabels, showtickprefix: os.showtickprefix, tickprefix: os.tickprefix, showticksuffix: os.showticksuffix, ticksuffix: os.ticksuffix, showexponent: os.showexponent, exponentformat: os.exponentformat, minexponent: os.minexponent, separatethousands: os.separatethousands, tickfont: os.tickfont, tickangle: os.tickangle, tickformat: os.tickformat, tickformatstops: os.tickformatstops, layer: os.layer }, "plot", "from-root"), i$e = { visible: f0({}, os.visible, { dflt: true }), type: f0({}, os.type, { values: ["-", "linear", "log", "date", "category"] }), autotypenumbers: os.autotypenumbers, autorangeoptions: { minallowed: os.autorangeoptions.minallowed, maxallowed: os.autorangeoptions.maxallowed, clipmin: os.autorangeoptions.clipmin, clipmax: os.autorangeoptions.clipmax, include: os.autorangeoptions.include, editType: "plot" }, autorange: f0({}, os.autorange, { editType: "plot" }), rangemode: { valType: "enumerated", values: ["tozero", "nonnegative", "normal"], dflt: "tozero", editType: "calc" }, minallowed: f0({}, os.minallowed, { editType: "plot" }), maxallowed: f0({}, os.maxallowed, { editType: "plot" }), range: f0({}, os.range, { items: [{ valType: "any", editType: "plot", impliedEdits: { "^autorange": false } }, { valType: "any", editType: "plot", impliedEdits: { "^autorange": false } }], editType: "plot" }), categoryorder: os.categoryorder, categoryarray: os.categoryarray, angle: { valType: "angle", editType: "plot" }, autotickangles: os.autotickangles, side: { valType: "enumerated", values: ["clockwise", "counterclockwise"], dflt: "clockwise", editType: "plot" }, title: { text: f0({}, os.title.text, { editType: "plot", dflt: "" }), font: f0({}, os.title.font, { editType: "plot" }), editType: "plot" }, hoverformat: os.hoverformat, uirevision: { valType: "any", editType: "none" }, editType: "calc" };
+        f0(i$e, t$e, r$e);
+        var n$e = { visible: f0({}, os.visible, { dflt: true }), type: { valType: "enumerated", values: ["-", "linear", "category"], dflt: "-", editType: "calc", _noTemplating: true }, autotypenumbers: os.autotypenumbers, categoryorder: os.categoryorder, categoryarray: os.categoryarray, thetaunit: { valType: "enumerated", values: ["radians", "degrees"], dflt: "degrees", editType: "calc" }, period: { valType: "number", editType: "calc", min: 0 }, direction: { valType: "enumerated", values: ["counterclockwise", "clockwise"], dflt: "counterclockwise", editType: "calc" }, rotation: { valType: "angle", editType: "calc" }, hoverformat: os.hoverformat, uirevision: { valType: "any", editType: "none" }, editType: "calc" };
+        f0(n$e, t$e, r$e);
+        a$e.exports = { domain: sQt({ name: "polar", editType: "plot" }), sector: { valType: "info_array", items: [{ valType: "number", editType: "plot" }, { valType: "number", editType: "plot" }], dflt: [0, 360], editType: "plot" }, hole: { valType: "number", min: 0, max: 1, dflt: 0, editType: "plot" }, bgcolor: { valType: "color", editType: "plot", dflt: oQt.background }, radialaxis: i$e, angularaxis: n$e, gridshape: { valType: "enumerated", values: ["circular", "linear"], dflt: "circular", editType: "plot" }, uirevision: { valType: "any", editType: "none" }, editType: "calc" };
+      });
+      var u$e = ye((Zwr, l$e) => {
+        var x9 = Dr(), lQt = ka(), uQt = vl(), cQt = O_(), fQt = Id().getSubplotData, hQt = Lb(), dQt = F3(), vQt = s_(), pQt = l_(), gQt = cI(), mQt = u4(), yQt = TB(), _Qt = V3(), s$e = rQ(), xQt = Y$(), b9 = d9(), o$e = b9.axisNames;
+        function bQt(e, t, r, n) {
+          var i = r("bgcolor");
+          n.bgColor = lQt.combine(i, n.paper_bgcolor);
+          var a = r("sector");
+          r("hole");
+          var o = fQt(n.fullData, b9.name, n.id), s = n.layoutOut, l;
+          function u(j, N) {
+            return r(l + "." + j, N);
+          }
+          for (var c = 0; c < o$e.length; c++) {
+            l = o$e[c], x9.isPlainObject(e[l]) || (e[l] = {});
+            var f = e[l], h = uQt.newContainer(t, l);
+            h._id = h._name = l, h._attr = n.id + "." + l, h._traceIndices = o.map(function(j) {
+              return j.index;
+            });
+            var d = b9.axisName2dataArray[l], v = wQt(f, h, u, o, d, n);
+            gQt(f, h, u, { axData: o, dataAttr: d });
+            var _ = u("visible");
+            switch (xQt(h, t, s), u("uirevision", t.uirevision), h._m = 1, l) {
+              case "radialaxis":
+                u("minallowed"), u("maxallowed");
+                var b = u("range"), p = h.getAutorangeDflt(b), k = u("autorange", p), E;
+                b && (b[0] === null && b[1] === null || (b[0] === null || b[1] === null) && (k === "reversed" || k === true) || b[0] !== null && (k === "min" || k === "max reversed") || b[1] !== null && (k === "max" || k === "min reversed")) && (b = void 0, delete h.range, h.autorange = true, E = true), E || (p = h.getAutorangeDflt(b), k = u("autorange", p)), f.autorange = k, k && (yQt(u, k, b), (v === "linear" || v === "-") && u("rangemode"), h.isReversed() && (h._m = -1)), h.cleanRange("range", { dfltRange: [0, 1] });
+                break;
+              case "angularaxis":
+                if (v === "date") {
+                  x9.log("Polar plots do not support date angular axes yet.");
+                  for (var T = 0; T < o.length; T++) o[T].visible = false;
+                  v = f.type = h.type = "linear";
+                }
+                u(v === "linear" ? "thetaunit" : "period");
+                var L = u("direction");
+                u("rotation", { counterclockwise: 0, clockwise: 90 }[L]);
+                break;
+            }
+            if (pQt(f, h, u, h.type, { tickSuffixDflt: h.thetaunit === "degrees" ? "°" : void 0 }), _) {
+              var x, C, M, g, P, A, z, O, U, G, Z = n.font || {};
+              x = u("color"), C = x === f.color ? x : Z.color, M = Z.size, g = Z.family, P = Z.weight, A = Z.style, z = Z.variant, O = Z.textcase, U = Z.lineposition, G = Z.shadow, hQt(f, h, u, h.type), vQt(f, h, u, h.type, { font: { weight: P, style: A, variant: z, textcase: O, lineposition: U, shadow: G, color: C, size: M, family: g }, noAutotickangles: l === "angularaxis", noTicklabelshift: true, noTicklabelstandoff: true }), dQt(f, h, u, { outerTicks: true }), mQt(f, h, u, { dfltColor: x, bgColor: n.bgColor, blend: 60, showLine: true, showGrid: true, noZeroLine: true, attributes: s$e[l] }), u("layer"), l === "radialaxis" && (u("side"), u("angle", a[0]), u("title.text"), x9.coerceFont(u, "title.font", { weight: P, style: A, variant: z, textcase: O, lineposition: U, shadow: G, color: C, size: x9.bigFont(M), family: g }));
+            }
+            v !== "category" && u("hoverformat"), h._input = f;
+          }
+          t.angularaxis.type === "category" && r("gridshape");
+        }
+        function wQt(e, t, r, n, i, a) {
+          var o = r("autotypenumbers", a.autotypenumbersDflt), s = r("type");
+          if (s === "-") {
+            for (var l, u = 0; u < n.length; u++) if (n[u].visible) {
+              l = n[u];
+              break;
+            }
+            l && l[i] && (t.type = _Qt(l[i], "gregorian", { noMultiCategory: true, autotypenumbers: o })), t.type === "-" ? t.type = "linear" : e.type = t.type;
+          }
+          return t.type;
+        }
+        l$e.exports = function(t, r, n) {
+          cQt(t, r, n, { type: b9.name, attributes: s$e, handleDefaults: bQt, font: r.font, autotypenumbersDflt: r.autotypenumbers, paper_bgcolor: r.paper_bgcolor, fullData: n, layoutOut: r });
+        };
+      });
+      var w9 = ye((Ywr, v$e) => {
+        var TQt = Id().getSubplotCalcData, AQt = Dr().counterRegex, SQt = tQ(), f$e = d9(), h$e = f$e.attr, kw = f$e.name, c$e = AQt(kw), d$e = {};
+        d$e[h$e] = { valType: "subplotid", dflt: kw, editType: "calc" };
+        function MQt(e) {
+          for (var t = e._fullLayout, r = e.calcdata, n = t._subplots[kw], i = 0; i < n.length; i++) {
+            var a = n[i], o = TQt(r, kw, a), s = t[a]._subplot;
+            s || (s = SQt(e, a), t[a]._subplot = s), s.plot(o, t, e._promises);
+          }
+        }
+        function EQt(e, t, r, n) {
+          for (var i = n._subplots[kw] || [], a = n._has && n._has("gl"), o = t._has && t._has("gl"), s = a && !o, l = 0; l < i.length; l++) {
+            var u = i[l], c = n[u]._subplot;
+            if (!t[u] && c) {
+              c.framework.remove(), c.layers["radial-axis-title"].remove();
+              for (var f in c.clipPaths) c.clipPaths[f].remove();
+            }
+            s && c._scene && (c._scene.destroy(), c._scene = null);
+          }
+        }
+        v$e.exports = { attr: h$e, name: kw, idRoot: kw, idRegex: c$e, attrRegex: c$e, attributes: d$e, layoutAttributes: rQ(), supplyLayoutDefaults: u$e(), plot: MQt, clean: EQt, toSVG: mh().toSVG };
+      });
+      var xC = ye((Kwr, g$e) => {
+        var { hovertemplateAttrs: kQt, texttemplateAttrs: CQt, templatefallbackAttrs: p$e } = Ll(), T9 = Ao().extendFlat, LQt = Pg(), h0 = pf(), PQt = Gl(), $5 = h0.line;
+        g$e.exports = { mode: h0.mode, r: { valType: "data_array", editType: "calc+clearAxisTypes" }, theta: { valType: "data_array", editType: "calc+clearAxisTypes" }, r0: { valType: "any", dflt: 0, editType: "calc+clearAxisTypes" }, dr: { valType: "number", dflt: 1, editType: "calc" }, theta0: { valType: "any", dflt: 0, editType: "calc+clearAxisTypes" }, dtheta: { valType: "number", editType: "calc" }, thetaunit: { valType: "enumerated", values: ["radians", "degrees", "gradians"], dflt: "degrees", editType: "calc+clearAxisTypes" }, text: h0.text, texttemplate: CQt({ editType: "plot" }, { keys: ["r", "theta", "text"] }), texttemplatefallback: p$e({ editType: "plot" }), hovertext: h0.hovertext, line: { color: $5.color, width: $5.width, dash: $5.dash, backoff: $5.backoff, shape: T9({}, $5.shape, { values: ["linear", "spline"] }), smoothing: $5.smoothing, editType: "calc" }, connectgaps: h0.connectgaps, marker: h0.marker, cliponaxis: T9({}, h0.cliponaxis, { dflt: false }), textposition: h0.textposition, textfont: h0.textfont, fill: T9({}, h0.fill, { values: ["none", "toself", "tonext"], dflt: "none" }), fillcolor: LQt(), hoverinfo: T9({}, PQt.hoverinfo, { flags: ["r", "theta", "text", "name"] }), hoveron: h0.hoveron, hovertemplate: kQt(), hovertemplatefallback: p$e(), selected: h0.selected, unselected: h0.unselected };
+      });
+      var S9 = ye((Jwr, _$e) => {
+        var A9 = Dr(), Q5 = Ru(), IQt = $p(), RQt = D0(), m$e = sT(), DQt = F0(), FQt = Fg(), zQt = Lm().PTS_LINESONLY, OQt = xC();
+        function qQt(e, t, r, n) {
+          function i(s, l) {
+            return A9.coerce(e, t, OQt, s, l);
+          }
+          var a = y$e(e, t, n, i);
+          if (!a) {
+            t.visible = false;
+            return;
+          }
+          i("thetaunit"), i("mode", a < zQt ? "lines+markers" : "lines"), i("text"), i("hovertext"), t.hoveron !== "fills" && (i("hovertemplate"), i("hovertemplatefallback")), Q5.hasMarkers(t) && IQt(e, t, r, n, i, { gradient: true }), Q5.hasLines(t) && (RQt(e, t, r, n, i, { backoff: true }), m$e(e, t, i), i("connectgaps")), Q5.hasText(t) && (i("texttemplate"), i("texttemplatefallback"), DQt(e, t, n, i));
+          var o = [];
+          (Q5.hasMarkers(t) || Q5.hasText(t)) && (i("cliponaxis"), i("marker.maxdisplayed"), o.push("points")), i("fill"), t.fill !== "none" && (FQt(e, t, r, i), Q5.hasLines(t) || m$e(e, t, i)), (t.fill === "tonext" || t.fill === "toself") && o.push("fills"), i("hoveron", o.join("+") || "points"), A9.coerceSelectionMarkerOpacity(t, i);
+        }
+        function y$e(e, t, r, n) {
+          var i = n("r"), a = n("theta");
+          A9.isTypedArray(i) && (t.r = i = Array.from(i)), A9.isTypedArray(a) && (t.theta = a = Array.from(a));
+          var o;
+          if (i) a ? o = Math.min(i.length, a.length) : (o = i.length, n("theta0"), n("dtheta"));
+          else {
+            if (!a) return 0;
+            o = t.theta.length, n("r0"), n("dr");
+          }
+          return t._length = o, o;
+        }
+        _$e.exports = { handleRThetaDefaults: y$e, supplyDefaults: qQt };
+      });
+      var M9 = ye(($wr, b$e) => {
+        var BQt = Dr(), x$e = ho();
+        b$e.exports = function(t, r, n) {
+          var i = {}, a = n[r.subplot]._subplot, o, s;
+          a ? (o = a.radialAxis, s = a.angularAxis) : (a = n[r.subplot], o = a.radialaxis, s = a.angularaxis);
+          var l = o.c2l(t.r);
+          i.rLabel = x$e.tickText(o, l, true).text;
+          var u = s.thetaunit === "degrees" ? BQt.rad2deg(t.theta) : t.theta;
+          return i.thetaLabel = x$e.tickText(s, u, true).text, i;
+        };
+      });
+      var A$e = ye((Qwr, T$e) => {
+        var w$e = Eo(), NQt = fs().BADNUM, UQt = ho(), VQt = z0(), GQt = Rm(), HQt = O0(), jQt = q0().calcMarkerSize;
+        T$e.exports = function(t, r) {
+          for (var n = t._fullLayout, i = r.subplot, a = n[i].radialaxis, o = n[i].angularaxis, s = a.makeCalcdata(r, "r"), l = o.makeCalcdata(r, "theta"), u = r._length, c = new Array(u), f = 0; f < u; f++) {
+            var h = s[f], d = l[f], v = c[f] = {};
+            w$e(h) && w$e(d) ? (v.r = h, v.theta = d) : v.r = NQt;
+          }
+          var _ = jQt(r, u);
+          return r._extremes.x = UQt.findExtremes(a, s, { ppad: _ }), VQt(t, r), GQt(c, r), HQt(c, r), c;
+        };
+      });
+      var E$e = ye((e3r, M$e) => {
+        var WQt = dT(), S$e = fs().BADNUM;
+        M$e.exports = function(t, r, n) {
+          for (var i = r.layers.frontplot.select("g.scatterlayer"), a = r.xaxis, o = r.yaxis, s = { xaxis: a, yaxis: o, plot: r.framework, layerClipId: r._hasClipOnAxisFalse ? r.clipIds.forTraces : null }, l = r.radialAxis, u = r.angularAxis, c = 0; c < n.length; c++) for (var f = n[c], h = 0; h < f.length; h++) {
+            h === 0 && (f[0].trace._xA = a, f[0].trace._yA = o);
+            var d = f[h], v = d.r;
+            if (v === S$e) d.x = d.y = S$e;
+            else {
+              var _ = l.c2g(v), b = u.c2g(d.theta);
+              d.x = _ * Math.cos(b), d.y = _ * Math.sin(b);
+            }
+          }
+          WQt(t, s, n, i);
+        };
+      });
+      var E9 = ye((t3r, C$e) => {
+        var XQt = mT();
+        function ZQt(e, t, r, n) {
+          var i = XQt(e, t, r, n);
+          if (!(!i || i[0].index === false)) {
+            var a = i[0];
+            if (a.index === void 0) return i;
+            var o = e.subplot, s = a.cd[a.index], l = a.trace;
+            if (o.isPtInside(s)) return a.xLabelVal = void 0, a.yLabelVal = void 0, k$e(s, l, o, a), a.hovertemplate = l.hovertemplate, i;
+          }
+        }
+        function k$e(e, t, r, n) {
+          var i = r.radialAxis, a = r.angularAxis;
+          i._hovertitle = "r", a._hovertitle = "θ";
+          var o = {};
+          o[t.subplot] = { _subplot: r };
+          var s = t._module.formatLabels(e, t, o);
+          n.rLabel = s.rLabel, n.thetaLabel = s.thetaLabel;
+          var l = e.hi || t.hoverinfo, u = [];
+          function c(h, d) {
+            u.push(h._hovertitle + ": " + d);
+          }
+          if (!t.hovertemplate) {
+            var f = l.split("+");
+            f.indexOf("all") !== -1 && (f = ["r", "theta", "text"]), f.indexOf("r") !== -1 && c(i, n.rLabel), f.indexOf("theta") !== -1 && c(a, n.thetaLabel), f.indexOf("text") !== -1 && n.text && (u.push(n.text), delete n.text), n.extraText = u.join("<br>");
+          }
+        }
+        C$e.exports = { hoverPoints: ZQt, makeHoverPointText: k$e };
+      });
+      var P$e = ye((r3r, L$e) => {
+        L$e.exports = { moduleType: "trace", name: "scatterpolar", basePlotModule: w9(), categories: ["polar", "symbols", "showLegend", "scatter-like"], attributes: xC(), supplyDefaults: S9().supplyDefaults, colorbar: $d(), formatLabels: M9(), calc: A$e(), plot: E$e(), style: sp().style, styleOnSelect: sp().styleOnSelect, hoverPoints: E9().hoverPoints, selectPoints: yT(), meta: {} };
+      });
+      var R$e = ye((i3r, I$e) => {
+        I$e.exports = P$e();
+      });
+      var iQ = ye((o3r, F$e) => {
+        var D$e = xC(), { cliponaxis: n3r, hoveron: a3r } = D$e, YQt = gee(D$e, ["cliponaxis", "hoveron"]), { connectgaps: KQt, line: { color: JQt, dash: $Qt, width: QQt }, fill: eer, fillcolor: ter, marker: rer, textfont: ier, textposition: ner } = gk();
+        F$e.exports = j1(_g({}, YQt), { connectgaps: KQt, fill: eer, fillcolor: ter, line: { color: JQt, dash: $Qt, editType: "calc", width: QQt }, marker: rer, textfont: ier, textposition: ner });
+      });
+      var q$e = ye((l3r, O$e) => {
+        var z$e = Dr(), nQ = Ru(), aer = S9().handleRThetaDefaults, oer = $p(), ser = D0(), ler = F0(), uer = Fg(), cer = Lm().PTS_LINESONLY, fer = iQ();
+        O$e.exports = function(t, r, n, i) {
+          function a(s, l) {
+            return z$e.coerce(t, r, fer, s, l);
+          }
+          var o = aer(t, r, i, a);
+          if (!o) {
+            r.visible = false;
+            return;
+          }
+          a("thetaunit"), a("mode", o < cer ? "lines+markers" : "lines"), a("text"), a("hovertext"), r.hoveron !== "fills" && (a("hovertemplate"), a("hovertemplatefallback")), nQ.hasMarkers(r) && oer(t, r, n, i, a, { noAngleRef: true, noLineDash: true, noStandOff: true }), nQ.hasLines(r) && (ser(t, r, n, i, a), a("connectgaps")), nQ.hasText(r) && (a("texttemplate"), a("texttemplatefallback"), ler(t, r, i, a, { noFontShadow: true, noFontLineposition: true, noFontTextcase: true })), a("fill"), r.fill !== "none" && uer(t, r, n, a), z$e.coerceSelectionMarkerOpacity(r, a);
+        };
+      });
+      var N$e = ye((u3r, B$e) => {
+        var her = M9();
+        B$e.exports = function(t, r, n) {
+          var i = t.i;
+          return "r" in t || (t.r = r._r[i]), "theta" in t || (t.theta = r._theta[i]), her(t, r, n);
+        };
+      });
+      var V$e = ye((c3r, U$e) => {
+        var der = z0(), ver = q0().calcMarkerSize, per = ow(), ger = ho(), mer = px().TOO_MANY_POINTS;
+        U$e.exports = function(t, r) {
+          var n = t._fullLayout, i = r.subplot, a = n[i].radialaxis, o = n[i].angularaxis, s = r._r = a.makeCalcdata(r, "r"), l = r._theta = o.makeCalcdata(r, "theta"), u = r._length, c = {};
+          u < s.length && (s = s.slice(0, u)), u < l.length && (l = l.slice(0, u)), c.r = s, c.theta = l, der(t, r);
+          var f = c.opts = per.style(t, r), h;
+          return u < mer ? h = ver(r, u) : f.marker && (h = 2 * (f.marker.sizeAvg || Math.max(f.marker.size, 3))), r._extremes.x = ger.findExtremes(a, s, { ppad: h }), [{ x: false, y: false, t: c, trace: r }];
+        };
+      });
+      var H$e = ye((f3r, G$e) => {
+        var yer = jF(), _er = E9().makeHoverPointText;
+        function xer(e, t, r, n) {
+          var i = e.cd, a = i[0].t, o = a.r, s = a.theta, l = yer.hoverPoints(e, t, r, n);
+          if (!(!l || l[0].index === false)) {
+            var u = l[0];
+            if (u.index === void 0) return l;
+            var c = e.subplot, f = u.cd[u.index], h = u.trace;
+            if (f.r = o[u.index], f.theta = s[u.index], !!c.isPtInside(f)) return u.xLabelVal = void 0, u.yLabelVal = void 0, _er(f, h, c, u), l;
+          }
+        }
+        G$e.exports = { hoverPoints: xer };
+      });
+      var W$e = ye((h3r, j$e) => {
+        j$e.exports = { moduleType: "trace", name: "scatterpolargl", basePlotModule: w9(), categories: ["gl", "regl", "polar", "symbols", "showLegend", "scatter-like"], attributes: iQ(), supplyDefaults: q$e(), colorbar: $d(), formatLabels: N$e(), calc: V$e(), hoverPoints: H$e().hoverPoints, selectPoints: gY(), meta: {} };
+      });
+      var X$e = ye((d3r, aQ) => {
+        var ber = ZF(), wer = Eo(), Ter = xK(), Aer = dY(), k9 = ow(), C9 = Dr(), Ser = px().TOO_MANY_POINTS, Mer = {};
+        aQ.exports = function(t, r, n) {
+          if (n.length) {
+            var i = r.radialAxis, a = r.angularAxis, o = Aer(t, r);
+            return n.forEach(function(s) {
+              if (!(!s || !s[0] || !s[0].trace)) {
+                var l = s[0], u = l.trace, c = l.t, f = u._length, h = c.r, d = c.theta, v = c.opts, _, b = h.slice(), p = d.slice();
+                for (_ = 0; _ < h.length; _++) r.isPtInside({ r: h[_], theta: d[_] }) || (b[_] = NaN, p[_] = NaN);
+                var k = new Array(f * 2), E = Array(f), T = Array(f);
+                for (_ = 0; _ < f; _++) {
+                  var L = b[_], x, C;
+                  if (wer(L)) {
+                    var M = i.c2g(L), g = a.c2g(p[_], u.thetaunit);
+                    x = M * Math.cos(g), C = M * Math.sin(g);
+                  } else x = C = NaN;
+                  E[_] = k[_ * 2] = x, T[_] = k[_ * 2 + 1] = C;
+                }
+                c.tree = ber(k), v.marker && f >= Ser && (v.marker.cluster = c.tree), v.marker && (v.markerSel.positions = v.markerUnsel.positions = v.marker.positions = k), v.line && k.length > 1 && C9.extendFlat(v.line, k9.linePositions(t, u, k)), v.text && (C9.extendFlat(v.text, { positions: k }, k9.textPosition(t, u, v.text, v.marker)), C9.extendFlat(v.textSel, { positions: k }, k9.textPosition(t, u, v.text, v.markerSel)), C9.extendFlat(v.textUnsel, { positions: k }, k9.textPosition(t, u, v.text, v.markerUnsel))), v.fill && !o.fill2d && (o.fill2d = true), v.marker && !o.scatter2d && (o.scatter2d = true), v.line && !o.line2d && (o.line2d = true), v.text && !o.glText && (o.glText = true), o.lineOptions.push(v.line), o.fillOptions.push(v.fill), o.markerOptions.push(v.marker), o.markerSelectedOptions.push(v.markerSel), o.markerUnselectedOptions.push(v.markerUnsel), o.textOptions.push(v.text), o.textSelectedOptions.push(v.textSel), o.textUnselectedOptions.push(v.textUnsel), o.selectBatch.push([]), o.unselectBatch.push([]), c.x = E, c.y = T, c.rawx = E, c.rawy = T, c.r = h, c.theta = d, c.positions = k, c._scene = o, c.index = o.count, o.count++;
+              }
+            }), Ter(t, r, n);
+          }
+        };
+        aQ.exports.reglPrecompiled = Mer;
+      });
+      var K$e = ye((v3r, Y$e) => {
+        var Z$e = W$e();
+        Z$e.plot = X$e();
+        Y$e.exports = Z$e;
+      });
+      var $$e = ye((p3r, J$e) => {
+        J$e.exports = K$e();
+      });
+      var oQ = ye((g3r, Q$e) => {
+        var { hovertemplateAttrs: Eer, templatefallbackAttrs: ker } = Ll(), eS = Ao().extendFlat, Ux = xC(), Vx = zm();
+        Q$e.exports = { r: Ux.r, theta: Ux.theta, r0: Ux.r0, dr: Ux.dr, theta0: Ux.theta0, dtheta: Ux.dtheta, thetaunit: Ux.thetaunit, base: eS({}, Vx.base, {}), offset: eS({}, Vx.offset, {}), width: eS({}, Vx.width, {}), text: eS({}, Vx.text, {}), hovertext: eS({}, Vx.hovertext, {}), marker: Cer(), hoverinfo: Ux.hoverinfo, hovertemplate: Eer(), hovertemplatefallback: ker(), selected: Vx.selected, unselected: Vx.unselected };
+        function Cer() {
+          var e = eS({}, Vx.marker);
+          return delete e.cornerradius, e;
+        }
+      });
+      var sQ = ye((m3r, eQe) => {
+        eQe.exports = { barmode: { valType: "enumerated", values: ["stack", "overlay"], dflt: "stack", editType: "calc" }, bargap: { valType: "number", dflt: 0.1, min: 0, max: 1, editType: "calc" } };
+      });
+      var iQe = ye((y3r, rQe) => {
+        var tQe = Dr(), Ler = S9().handleRThetaDefaults, Per = WI(), Ier = oQ();
+        rQe.exports = function(t, r, n, i) {
+          function a(s, l) {
+            return tQe.coerce(t, r, Ier, s, l);
+          }
+          var o = Ler(t, r, i, a);
+          if (!o) {
+            r.visible = false;
+            return;
+          }
+          a("thetaunit"), a("base"), a("offset"), a("width"), a("text"), a("hovertext"), a("hovertemplate"), a("hovertemplatefallback"), Per(t, r, a, n, i), tQe.coerceSelectionMarkerOpacity(r, a);
+        };
+      });
+      var aQe = ye((_3r, nQe) => {
+        var Rer = Dr(), Der = sQ();
+        nQe.exports = function(e, t, r) {
+          var n = {}, i;
+          function a(l, u) {
+            return Rer.coerce(e[i] || {}, t[i], Der, l, u);
+          }
+          for (var o = 0; o < r.length; o++) {
+            var s = r[o];
+            s.type === "barpolar" && s.visible === true && (i = s.subplot, n[i] || (a("barmode"), a("bargap"), n[i] = 1));
+          }
+        };
+      });
+      var lQ = ye((x3r, lQe) => {
+        var oQe = pv().hasColorscale, sQe = gv(), Fer = Dr().isArrayOrTypedArray, zer = A4(), Oer = t2().setGroupPositions, qer = O0(), Ber = qa().traceIs, Ner = Dr().extendFlat;
+        function Uer(e, t) {
+          for (var r = e._fullLayout, n = t.subplot, i = r[n].radialaxis, a = r[n].angularaxis, o = i.makeCalcdata(t, "r"), s = a.makeCalcdata(t, "theta"), l = t._length, u = new Array(l), c = o, f = s, h = 0; h < l; h++) u[h] = { p: f[h], s: c[h] };
+          function d(v) {
+            var _ = t[v];
+            _ !== void 0 && (t["_" + v] = Fer(_) ? a.makeCalcdata(t, v) : a.d2c(_, t.thetaunit));
+          }
+          return a.type === "linear" && (d("width"), d("offset")), oQe(t, "marker") && sQe(e, t, { vals: t.marker.color, containerStr: "marker", cLetter: "c" }), oQe(t, "marker.line") && sQe(e, t, { vals: t.marker.line.color, containerStr: "marker.line", cLetter: "c" }), zer(u, t), qer(u, t), u;
+        }
+        function Ver(e, t, r) {
+          for (var n = e.calcdata, i = [], a = 0; a < n.length; a++) {
+            var o = n[a], s = o[0].trace;
+            s.visible === true && Ber(s, "bar") && s.subplot === r && i.push(o);
+          }
+          var l = Ner({}, t.radialaxis, { _id: "x" }), u = t.angularaxis;
+          Oer(e, u, l, i, { mode: t.barmode, norm: t.barnorm, gap: t.bargap, groupgap: t.bargroupgap });
+        }
+        lQe.exports = { calc: Uer, crossTraceCalc: Ver };
+      });
+      var fQe = ye((b3r, cQe) => {
+        var uQe = Oa(), L9 = Eo(), tS = Dr(), Ger = So(), uQ = p9();
+        cQe.exports = function(t, r, n) {
+          var i = t._context.staticPlot, a = r.xaxis, o = r.yaxis, s = r.radialAxis, l = r.angularAxis, u = Her(r), c = r.layers.frontplot.select("g.barlayer");
+          tS.makeTraceGroups(c, n, "trace bars").each(function() {
+            var f = uQe.select(this), h = tS.ensureSingle(f, "g", "points"), d = h.selectAll("g.point").data(tS.identity);
+            d.enter().append("g").style("vector-effect", i ? "none" : "non-scaling-stroke").style("stroke-miterlimit", 2).classed("point", true), d.exit().remove(), d.each(function(v) {
+              var _ = uQe.select(this), b = v.rp0 = s.c2p(v.s0), p = v.rp1 = s.c2p(v.s1), k = v.thetag0 = l.c2g(v.p0), E = v.thetag1 = l.c2g(v.p1), T;
+              if (!L9(b) || !L9(p) || !L9(k) || !L9(E) || b === p || k === E) T = "M0,0Z";
+              else {
+                var L = s.c2g(v.s1), x = (k + E) / 2;
+                v.ct = [a.c2p(L * Math.cos(x)), o.c2p(L * Math.sin(x))], T = u(b, p, k, E);
+              }
+              tS.ensureSingle(_, "path").attr("d", T);
+            }), Ger.setClipUrl(f, r._hasClipOnAxisFalse ? r.clipIds.forTraces : null, t);
+          });
+        };
+        function Her(e) {
+          var t = e.cxx, r = e.cyy;
+          return e.vangles ? function(n, i, a, o) {
+            var s, l;
+            tS.angleDelta(a, o) > 0 ? (s = a, l = o) : (s = o, l = a);
+            var u = uQ.findEnclosingVertexAngles(s, e.vangles)[0], c = uQ.findEnclosingVertexAngles(l, e.vangles)[1], f = [u, (s + l) / 2, c];
+            return uQ.pathPolygonAnnulus(n, i, s, l, f, t, r);
+          } : function(n, i, a, o) {
+            return tS.pathAnnulus(n, i, a, o, t, r);
+          };
+        }
+      });
+      var dQe = ye((w3r, hQe) => {
+        var jer = vf(), cQ = Dr(), Wer = PT().getTraceColor, Xer = cQ.fillText, Zer = E9().makeHoverPointText, Yer = p9().isPtInsidePolygon;
+        hQe.exports = function(t, r, n) {
+          var i = t.cd, a = i[0].trace, o = t.subplot, s = o.radialAxis, l = o.angularAxis, u = o.vangles, c = u ? Yer : cQ.isPtInsideSector, f = t.maxHoverDistance, h = l._period || 2 * Math.PI, d = Math.abs(s.g2p(Math.sqrt(r * r + n * n))), v = Math.atan2(n, r);
+          s.range[0] > s.range[1] && (v += Math.PI);
+          var _ = function(E) {
+            return c(d, v, [E.rp0, E.rp1], [E.thetag0, E.thetag1], u) ? f + Math.min(1, Math.abs(E.thetag1 - E.thetag0) / h) - 1 + (E.rp1 - d) / (E.rp1 - E.rp0) - 1 : 1 / 0;
+          };
+          if (jer.getClosest(i, _, t), t.index !== false) {
+            var b = t.index, p = i[b];
+            t.x0 = t.x1 = p.ct[0], t.y0 = t.y1 = p.ct[1];
+            var k = cQ.extendFlat({}, p, { r: p.s, theta: p.p });
+            return Xer(p, a, t), Zer(k, a, o, t), t.hovertemplate = a.hovertemplate, t.color = Wer(a, p), t.xLabelVal = t.yLabelVal = void 0, p.s < 0 && (t.idealAlign = "left"), [t];
+          }
+        };
+      });
+      var pQe = ye((T3r, vQe) => {
+        vQe.exports = { moduleType: "trace", name: "barpolar", basePlotModule: w9(), categories: ["polar", "bar", "showLegend"], attributes: oQ(), layoutAttributes: sQ(), supplyDefaults: iQe(), supplyLayoutDefaults: aQe(), calc: lQ().calc, crossTraceCalc: lQ().crossTraceCalc, plot: fQe(), colorbar: $d(), formatLabels: M9(), style: V0().style, styleOnSelect: V0().styleOnSelect, hoverPoints: dQe(), selectPoints: IT(), meta: {} };
+      });
+      var mQe = ye((A3r, gQe) => {
+        gQe.exports = pQe();
+      });
+      var fQ = ye((S3r, yQe) => {
+        yQe.exports = { attr: "subplot", name: "smith", axisNames: ["realaxis", "imaginaryaxis"], axisName2dataArray: { imaginaryaxis: "imag", realaxis: "real" } };
+      });
+      var hQ = ye((M3r, wQe) => {
+        var Ker = Ih(), Uf = Rd(), Jer = Cc().attributes, Gx = Dr().extendFlat, _Qe = mc().overrideAll, xQe = _Qe({ color: Uf.color, showline: Gx({}, Uf.showline, { dflt: true }), linecolor: Uf.linecolor, linewidth: Uf.linewidth, showgrid: Gx({}, Uf.showgrid, { dflt: true }), gridcolor: Uf.gridcolor, gridwidth: Uf.gridwidth, griddash: Uf.griddash }, "plot", "from-root"), bQe = _Qe({ ticklen: Uf.ticklen, tickwidth: Gx({}, Uf.tickwidth, { dflt: 2 }), tickcolor: Uf.tickcolor, showticklabels: Uf.showticklabels, labelalias: Uf.labelalias, showtickprefix: Uf.showtickprefix, tickprefix: Uf.tickprefix, showticksuffix: Uf.showticksuffix, ticksuffix: Uf.ticksuffix, tickfont: Uf.tickfont, tickformat: Uf.tickformat, hoverformat: Uf.hoverformat, layer: Uf.layer }, "plot", "from-root"), $er = Gx({ visible: Gx({}, Uf.visible, { dflt: true }), tickvals: { dflt: [0.2, 0.5, 1, 2, 5], valType: "data_array", editType: "plot" }, tickangle: Gx({}, Uf.tickangle, { dflt: 90 }), ticks: { valType: "enumerated", values: ["top", "bottom", ""], editType: "ticks" }, side: { valType: "enumerated", values: ["top", "bottom"], dflt: "top", editType: "plot" }, editType: "calc" }, xQe, bQe), Qer = Gx({ visible: Gx({}, Uf.visible, { dflt: true }), tickvals: { valType: "data_array", editType: "plot" }, ticks: Uf.ticks, editType: "calc" }, xQe, bQe);
+        wQe.exports = { domain: Jer({ name: "smith", editType: "plot" }), bgcolor: { valType: "color", editType: "plot", dflt: Ker.background }, realaxis: $er, imaginaryaxis: Qer, editType: "calc" };
+      });
+      var SQe = ye((E3r, AQe) => {
+        var rS = Dr(), etr = ka(), ttr = vl(), rtr = O_(), itr = Id().getSubplotData, ntr = l_(), atr = s_(), otr = u4(), str = xm(), iS = hQ(), dQ = fQ(), TQe = dQ.axisNames, ltr = ctr(function(e) {
+          return rS.isTypedArray(e) && (e = Array.from(e)), e.slice().reverse().map(function(t) {
+            return -t;
+          }).concat([0]).concat(e);
+        }, String);
+        function utr(e, t, r, n) {
+          var i = r("bgcolor");
+          n.bgColor = etr.combine(i, n.paper_bgcolor);
+          var a = itr(n.fullData, dQ.name, n.id), o = n.layoutOut, s;
+          function l(L, x) {
+            return r(s + "." + L, x);
+          }
+          for (var u = 0; u < TQe.length; u++) {
+            s = TQe[u], rS.isPlainObject(e[s]) || (e[s] = {});
+            var c = e[s], f = ttr.newContainer(t, s);
+            f._id = f._name = s, f._attr = n.id + "." + s, f._traceIndices = a.map(function(L) {
+              return L.index;
+            });
+            var h = l("visible");
+            if (f.type = "linear", str(f, o), ntr(c, f, l, f.type), h) {
+              var d = s === "realaxis";
+              if (d && l("side"), d) l("tickvals");
+              else {
+                var v = ltr(t.realaxis.tickvals || iS.realaxis.tickvals.dflt);
+                l("tickvals", v);
+              }
+              rS.isTypedArray(f.tickvals) && (f.tickvals = Array.from(f.tickvals));
+              var _, b, p, k, E = n.font || {};
+              h && (_ = l("color"), b = _ === c.color ? _ : E.color, p = E.size, k = E.family), atr(c, f, l, f.type, { noAutotickangles: true, noTicklabelshift: true, noTicklabelstandoff: true, noTicklabelstep: true, noAng: !d, noExp: true, font: { color: b, size: p, family: k } }), rS.coerce2(e, t, iS, s + ".ticklen"), rS.coerce2(e, t, iS, s + ".tickwidth"), rS.coerce2(e, t, iS, s + ".tickcolor", t.color);
+              var T = l("ticks");
+              T || (delete t[s].ticklen, delete t[s].tickwidth, delete t[s].tickcolor), otr(c, f, l, { dfltColor: _, bgColor: n.bgColor, blend: 60, showLine: true, showGrid: true, noZeroLine: true, attributes: iS[s] }), l("layer");
+            }
+            l("hoverformat"), delete f.type, f._input = c;
+          }
+        }
+        AQe.exports = function(t, r, n) {
+          rtr(t, r, n, { noUirevision: true, type: dQ.name, attributes: iS, handleDefaults: utr, font: r.font, paper_bgcolor: r.paper_bgcolor, fullData: n, layoutOut: r });
+        };
+        function ctr(e, t) {
+          var r = {};
+          return function(n) {
+            var i = t ? t(n) : n;
+            if (i in r) return r[i];
+            var a = e(n);
+            return r[i] = a, a;
+          };
+        }
+      });
+      var PQe = ye((k3r, LQe) => {
+        var ftr = Id().getSubplotCalcData, htr = Dr().counterRegex, dtr = tQ(), EQe = fQ(), kQe = EQe.attr, Cw = EQe.name, MQe = htr(Cw), CQe = {};
+        CQe[kQe] = { valType: "subplotid", dflt: Cw, editType: "calc" };
+        function vtr(e) {
+          for (var t = e._fullLayout, r = e.calcdata, n = t._subplots[Cw], i = 0; i < n.length; i++) {
+            var a = n[i], o = ftr(r, Cw, a), s = t[a]._subplot;
+            s || (s = dtr(e, a, true), t[a]._subplot = s), s.plot(o, t, e._promises);
+          }
+        }
+        function ptr(e, t, r, n) {
+          for (var i = n._subplots[Cw] || [], a = 0; a < i.length; a++) {
+            var o = i[a], s = n[o]._subplot;
+            if (!t[o] && s) {
+              s.framework.remove();
+              for (var l in s.clipPaths) s.clipPaths[l].remove();
+            }
+          }
+        }
+        LQe.exports = { attr: kQe, name: Cw, idRoot: Cw, idRegex: MQe, attrRegex: MQe, attributes: CQe, layoutAttributes: hQ(), supplyLayoutDefaults: SQe(), plot: vtr, clean: ptr, toSVG: mh().toSVG };
+      });
+      var vQ = ye((C3r, RQe) => {
+        var { hovertemplateAttrs: gtr, texttemplateAttrs: mtr, templatefallbackAttrs: IQe } = Ll(), P9 = Ao().extendFlat, ytr = Pg(), d0 = pf(), _tr = Gl(), nS = d0.line;
+        RQe.exports = { mode: d0.mode, real: { valType: "data_array", editType: "calc+clearAxisTypes" }, imag: { valType: "data_array", editType: "calc+clearAxisTypes" }, text: d0.text, texttemplate: mtr({ editType: "plot" }, { keys: ["real", "imag", "text"] }), texttemplatefallback: IQe({ editType: "plot" }), hovertext: d0.hovertext, line: { color: nS.color, width: nS.width, dash: nS.dash, backoff: nS.backoff, shape: P9({}, nS.shape, { values: ["linear", "spline"] }), smoothing: nS.smoothing, editType: "calc" }, connectgaps: d0.connectgaps, marker: d0.marker, cliponaxis: P9({}, d0.cliponaxis, { dflt: false }), textposition: d0.textposition, textfont: d0.textfont, fill: P9({}, d0.fill, { values: ["none", "toself", "tonext"], dflt: "none" }), fillcolor: ytr(), hoverinfo: P9({}, _tr.hoverinfo, { flags: ["real", "imag", "text", "name"] }), hoveron: d0.hoveron, hovertemplate: gtr(), hovertemplatefallback: IQe(), selected: d0.selected, unselected: d0.unselected };
+      });
+      var zQe = ye((L3r, FQe) => {
+        var I9 = Dr(), aS = Ru(), xtr = $p(), btr = D0(), DQe = sT(), wtr = F0(), Ttr = Fg(), Atr = Lm().PTS_LINESONLY, Str = vQ();
+        FQe.exports = function(t, r, n, i) {
+          function a(l, u) {
+            return I9.coerce(t, r, Str, l, u);
+          }
+          var o = Mtr(t, r, i, a);
+          if (!o) {
+            r.visible = false;
+            return;
+          }
+          a("mode", o < Atr ? "lines+markers" : "lines"), a("text"), a("hovertext"), r.hoveron !== "fills" && (a("hovertemplate"), a("hovertemplatefallback")), aS.hasMarkers(r) && xtr(t, r, n, i, a, { gradient: true }), aS.hasLines(r) && (btr(t, r, n, i, a, { backoff: true }), DQe(t, r, a), a("connectgaps")), aS.hasText(r) && (a("texttemplate"), a("texttemplatefallback"), wtr(t, r, i, a));
+          var s = [];
+          (aS.hasMarkers(r) || aS.hasText(r)) && (a("cliponaxis"), a("marker.maxdisplayed"), s.push("points")), a("fill"), r.fill !== "none" && (Ttr(t, r, n, a), aS.hasLines(r) || DQe(t, r, a)), (r.fill === "tonext" || r.fill === "toself") && s.push("fills"), a("hoveron", s.join("+") || "points"), I9.coerceSelectionMarkerOpacity(r, a);
+        };
+        function Mtr(e, t, r, n) {
+          var i = n("real"), a = n("imag"), o;
+          return i && a && (o = Math.min(i.length, a.length)), I9.isTypedArray(i) && (t.real = i = Array.from(i)), I9.isTypedArray(a) && (t.imag = a = Array.from(a)), t._length = o, o;
+        }
+      });
+      var BQe = ye((P3r, qQe) => {
+        var OQe = ho();
+        qQe.exports = function(t, r, n) {
+          var i = {}, a = n[r.subplot]._subplot;
+          return i.realLabel = OQe.tickText(a.radialAxis, t.real, true).text, i.imagLabel = OQe.tickText(a.angularAxis, t.imag, true).text, i;
+        };
+      });
+      var VQe = ye((I3r, UQe) => {
+        var NQe = Eo(), Etr = fs().BADNUM, ktr = z0(), Ctr = Rm(), Ltr = O0(), Ptr = q0().calcMarkerSize;
+        UQe.exports = function(t, r) {
+          for (var n = t._fullLayout, i = r.subplot, a = n[i].realaxis, o = n[i].imaginaryaxis, s = a.makeCalcdata(r, "real"), l = o.makeCalcdata(r, "imag"), u = r._length, c = new Array(u), f = 0; f < u; f++) {
+            var h = s[f], d = l[f], v = c[f] = {};
+            NQe(h) && NQe(d) ? (v.real = h, v.imag = d) : v.real = Etr;
+          }
+          return Ptr(r, u), ktr(t, r), Ctr(c, r), Ltr(c, r), c;
+        };
+      });
+      var jQe = ye((R3r, HQe) => {
+        var Itr = dT(), GQe = fs().BADNUM, Rtr = $$(), Dtr = Rtr.smith;
+        HQe.exports = function(t, r, n) {
+          for (var i = r.layers.frontplot.select("g.scatterlayer"), a = r.xaxis, o = r.yaxis, s = { xaxis: a, yaxis: o, plot: r.framework, layerClipId: r._hasClipOnAxisFalse ? r.clipIds.forTraces : null }, l = 0; l < n.length; l++) for (var u = n[l], c = 0; c < u.length; c++) {
+            c === 0 && (u[0].trace._xA = a, u[0].trace._yA = o);
+            var f = u[c], h = f.real;
+            if (h === GQe) f.x = f.y = GQe;
+            else {
+              var d = Dtr([h, f.imag]);
+              f.x = d[0], f.y = d[1];
+            }
+          }
+          Itr(t, s, n, i);
+        };
+      });
+      var ZQe = ye((D3r, XQe) => {
+        var Ftr = mT();
+        function ztr(e, t, r, n) {
+          var i = Ftr(e, t, r, n);
+          if (!(!i || i[0].index === false)) {
+            var a = i[0];
+            if (a.index === void 0) return i;
+            var o = e.subplot, s = a.cd[a.index], l = a.trace;
+            if (o.isPtInside(s)) return a.xLabelVal = void 0, a.yLabelVal = void 0, WQe(s, l, o, a), a.hovertemplate = l.hovertemplate, i;
+          }
+        }
+        function WQe(e, t, r, n) {
+          var i = r.radialAxis, a = r.angularAxis;
+          i._hovertitle = "real", a._hovertitle = "imag";
+          var o = {};
+          o[t.subplot] = { _subplot: r };
+          var s = t._module.formatLabels(e, t, o);
+          n.realLabel = s.realLabel, n.imagLabel = s.imagLabel;
+          var l = e.hi || t.hoverinfo, u = [];
+          function c(h, d) {
+            u.push(h._hovertitle + ": " + d);
+          }
+          if (!t.hovertemplate) {
+            var f = l.split("+");
+            f.indexOf("all") !== -1 && (f = ["real", "imag", "text"]), f.indexOf("real") !== -1 && c(i, n.realLabel), f.indexOf("imag") !== -1 && c(a, n.imagLabel), f.indexOf("text") !== -1 && n.text && (u.push(n.text), delete n.text), n.extraText = u.join("<br>");
+          }
+        }
+        XQe.exports = { hoverPoints: ztr, makeHoverPointText: WQe };
+      });
+      var KQe = ye((F3r, YQe) => {
+        YQe.exports = { moduleType: "trace", name: "scattersmith", basePlotModule: PQe(), categories: ["smith", "symbols", "showLegend", "scatter-like"], attributes: vQ(), supplyDefaults: zQe(), colorbar: $d(), formatLabels: BQe(), calc: VQe(), plot: jQe(), style: sp().style, styleOnSelect: sp().styleOnSelect, hoverPoints: ZQe().hoverPoints, selectPoints: yT(), meta: {} };
+      });
+      var $Qe = ye((z3r, JQe) => {
+        JQe.exports = KQe();
+      });
+      var kv = ye((O3r, eet) => {
+        var D9 = Nh();
+        function QQe() {
+          this.regionalOptions = [], this.regionalOptions[""] = { invalidCalendar: "Calendar {0} not found", invalidDate: "Invalid {0} date", invalidMonth: "Invalid {0} month", invalidYear: "Invalid {0} year", differentCalendars: "Cannot mix {0} and {1} dates" }, this.local = this.regionalOptions[""], this.calendars = {}, this._localCals = {};
+        }
+        D9(QQe.prototype, { instance: function(e, t) {
+          e = (e || "gregorian").toLowerCase(), t = t || "";
+          var r = this._localCals[e + "-" + t];
+          if (!r && this.calendars[e] && (r = new this.calendars[e](t), this._localCals[e + "-" + t] = r), !r) throw (this.local.invalidCalendar || this.regionalOptions[""].invalidCalendar).replace(/\{0\}/, e);
+          return r;
+        }, newDate: function(e, t, r, n, i) {
+          return n = (e != null && e.year ? e.calendar() : typeof n == "string" ? this.instance(n, i) : n) || this.instance(), n.newDate(e, t, r);
+        }, substituteDigits: function(e) {
+          return function(t) {
+            return (t + "").replace(/[0-9]/g, function(r) {
+              return e[r];
+            });
+          };
+        }, substituteChineseDigits: function(e, t) {
+          return function(r) {
+            for (var n = "", i = 0; r > 0; ) {
+              var a = r % 10;
+              n = (a === 0 ? "" : e[a] + t[i]) + n, i++, r = Math.floor(r / 10);
+            }
+            return n.indexOf(e[1] + t[1]) === 0 && (n = n.substr(1)), n || e[0];
+          };
+        } });
+        function pQ(e, t, r, n) {
+          if (this._calendar = e, this._year = t, this._month = r, this._day = n, this._calendar._validateLevel === 0 && !this._calendar.isValid(this._year, this._month, this._day)) throw (Gs.local.invalidDate || Gs.regionalOptions[""].invalidDate).replace(/\{0\}/, this._calendar.local.name);
+        }
+        function R9(e, t) {
+          return e = "" + e, "000000".substring(0, t - e.length) + e;
+        }
+        D9(pQ.prototype, { newDate: function(e, t, r) {
+          return this._calendar.newDate(e == null ? this : e, t, r);
+        }, year: function(e) {
+          return arguments.length === 0 ? this._year : this.set(e, "y");
+        }, month: function(e) {
+          return arguments.length === 0 ? this._month : this.set(e, "m");
+        }, day: function(e) {
+          return arguments.length === 0 ? this._day : this.set(e, "d");
+        }, date: function(e, t, r) {
+          if (!this._calendar.isValid(e, t, r)) throw (Gs.local.invalidDate || Gs.regionalOptions[""].invalidDate).replace(/\{0\}/, this._calendar.local.name);
+          return this._year = e, this._month = t, this._day = r, this;
+        }, leapYear: function() {
+          return this._calendar.leapYear(this);
+        }, epoch: function() {
+          return this._calendar.epoch(this);
+        }, formatYear: function() {
+          return this._calendar.formatYear(this);
+        }, monthOfYear: function() {
+          return this._calendar.monthOfYear(this);
+        }, weekOfYear: function() {
+          return this._calendar.weekOfYear(this);
+        }, daysInYear: function() {
+          return this._calendar.daysInYear(this);
+        }, dayOfYear: function() {
+          return this._calendar.dayOfYear(this);
+        }, daysInMonth: function() {
+          return this._calendar.daysInMonth(this);
+        }, dayOfWeek: function() {
+          return this._calendar.dayOfWeek(this);
+        }, weekDay: function() {
+          return this._calendar.weekDay(this);
+        }, extraInfo: function() {
+          return this._calendar.extraInfo(this);
+        }, add: function(e, t) {
+          return this._calendar.add(this, e, t);
+        }, set: function(e, t) {
+          return this._calendar.set(this, e, t);
+        }, compareTo: function(e) {
+          if (this._calendar.name !== e._calendar.name) throw (Gs.local.differentCalendars || Gs.regionalOptions[""].differentCalendars).replace(/\{0\}/, this._calendar.local.name).replace(/\{1\}/, e._calendar.local.name);
+          var t = this._year !== e._year ? this._year - e._year : this._month !== e._month ? this.monthOfYear() - e.monthOfYear() : this._day - e._day;
+          return t === 0 ? 0 : t < 0 ? -1 : 1;
+        }, calendar: function() {
+          return this._calendar;
+        }, toJD: function() {
+          return this._calendar.toJD(this);
+        }, fromJD: function(e) {
+          return this._calendar.fromJD(e);
+        }, toJSDate: function() {
+          return this._calendar.toJSDate(this);
+        }, fromJSDate: function(e) {
+          return this._calendar.fromJSDate(e);
+        }, toString: function() {
+          return (this.year() < 0 ? "-" : "") + R9(Math.abs(this.year()), 4) + "-" + R9(this.month(), 2) + "-" + R9(this.day(), 2);
+        } });
+        function gQ() {
+          this.shortYearCutoff = "+10";
+        }
+        D9(gQ.prototype, { _validateLevel: 0, newDate: function(e, t, r) {
+          return e == null ? this.today() : (e.year && (this._validate(e, t, r, Gs.local.invalidDate || Gs.regionalOptions[""].invalidDate), r = e.day(), t = e.month(), e = e.year()), new pQ(this, e, t, r));
+        }, today: function() {
+          return this.fromJSDate(/* @__PURE__ */ new Date());
+        }, epoch: function(e) {
+          var t = this._validate(e, this.minMonth, this.minDay, Gs.local.invalidYear || Gs.regionalOptions[""].invalidYear);
+          return t.year() < 0 ? this.local.epochs[0] : this.local.epochs[1];
+        }, formatYear: function(e) {
+          var t = this._validate(e, this.minMonth, this.minDay, Gs.local.invalidYear || Gs.regionalOptions[""].invalidYear);
+          return (t.year() < 0 ? "-" : "") + R9(Math.abs(t.year()), 4);
+        }, monthsInYear: function(e) {
+          return this._validate(e, this.minMonth, this.minDay, Gs.local.invalidYear || Gs.regionalOptions[""].invalidYear), 12;
+        }, monthOfYear: function(e, t) {
+          var r = this._validate(e, t, this.minDay, Gs.local.invalidMonth || Gs.regionalOptions[""].invalidMonth);
+          return (r.month() + this.monthsInYear(r) - this.firstMonth) % this.monthsInYear(r) + this.minMonth;
+        }, fromMonthOfYear: function(e, t) {
+          var r = (t + this.firstMonth - 2 * this.minMonth) % this.monthsInYear(e) + this.minMonth;
+          return this._validate(e, r, this.minDay, Gs.local.invalidMonth || Gs.regionalOptions[""].invalidMonth), r;
+        }, daysInYear: function(e) {
+          var t = this._validate(e, this.minMonth, this.minDay, Gs.local.invalidYear || Gs.regionalOptions[""].invalidYear);
+          return this.leapYear(t) ? 366 : 365;
+        }, dayOfYear: function(e, t, r) {
+          var n = this._validate(e, t, r, Gs.local.invalidDate || Gs.regionalOptions[""].invalidDate);
+          return n.toJD() - this.newDate(n.year(), this.fromMonthOfYear(n.year(), this.minMonth), this.minDay).toJD() + 1;
+        }, daysInWeek: function() {
+          return 7;
+        }, dayOfWeek: function(e, t, r) {
+          var n = this._validate(e, t, r, Gs.local.invalidDate || Gs.regionalOptions[""].invalidDate);
+          return (Math.floor(this.toJD(n)) + 2) % this.daysInWeek();
+        }, extraInfo: function(e, t, r) {
+          return this._validate(e, t, r, Gs.local.invalidDate || Gs.regionalOptions[""].invalidDate), {};
+        }, add: function(e, t, r) {
+          return this._validate(e, this.minMonth, this.minDay, Gs.local.invalidDate || Gs.regionalOptions[""].invalidDate), this._correctAdd(e, this._add(e, t, r), t, r);
+        }, _add: function(e, t, r) {
+          if (this._validateLevel++, r === "d" || r === "w") {
+            var n = e.toJD() + t * (r === "w" ? this.daysInWeek() : 1), i = e.calendar().fromJD(n);
+            return this._validateLevel--, [i.year(), i.month(), i.day()];
+          }
+          try {
+            var a = e.year() + (r === "y" ? t : 0), o = e.monthOfYear() + (r === "m" ? t : 0), i = e.day(), s = function(c) {
+              for (; o < c.minMonth; ) a--, o += c.monthsInYear(a);
+              for (var f = c.monthsInYear(a); o > f - 1 + c.minMonth; ) a++, o -= f, f = c.monthsInYear(a);
+            };
+            r === "y" ? (e.month() !== this.fromMonthOfYear(a, o) && (o = this.newDate(a, e.month(), this.minDay).monthOfYear()), o = Math.min(o, this.monthsInYear(a)), i = Math.min(i, this.daysInMonth(a, this.fromMonthOfYear(a, o)))) : r === "m" && (s(this), i = Math.min(i, this.daysInMonth(a, this.fromMonthOfYear(a, o))));
+            var l = [a, this.fromMonthOfYear(a, o), i];
+            return this._validateLevel--, l;
+          } catch (u) {
+            throw this._validateLevel--, u;
+          }
+        }, _correctAdd: function(e, t, r, n) {
+          if (!this.hasYearZero && (n === "y" || n === "m") && (t[0] === 0 || e.year() > 0 != t[0] > 0)) {
+            var i = { y: [1, 1, "y"], m: [1, this.monthsInYear(-1), "m"], w: [this.daysInWeek(), this.daysInYear(-1), "d"], d: [1, this.daysInYear(-1), "d"] }[n], a = r < 0 ? -1 : 1;
+            t = this._add(e, r * i[0] + a * i[1], i[2]);
+          }
+          return e.date(t[0], t[1], t[2]);
+        }, set: function(e, t, r) {
+          this._validate(e, this.minMonth, this.minDay, Gs.local.invalidDate || Gs.regionalOptions[""].invalidDate);
+          var n = r === "y" ? t : e.year(), i = r === "m" ? t : e.month(), a = r === "d" ? t : e.day();
+          return (r === "y" || r === "m") && (a = Math.min(a, this.daysInMonth(n, i))), e.date(n, i, a);
+        }, isValid: function(e, t, r) {
+          this._validateLevel++;
+          var n = this.hasYearZero || e !== 0;
+          if (n) {
+            var i = this.newDate(e, t, this.minDay);
+            n = t >= this.minMonth && t - this.minMonth < this.monthsInYear(i) && r >= this.minDay && r - this.minDay < this.daysInMonth(i);
+          }
+          return this._validateLevel--, n;
+        }, toJSDate: function(e, t, r) {
+          var n = this._validate(e, t, r, Gs.local.invalidDate || Gs.regionalOptions[""].invalidDate);
+          return Gs.instance().fromJD(this.toJD(n)).toJSDate();
+        }, fromJSDate: function(e) {
+          return this.fromJD(Gs.instance().fromJSDate(e).toJD());
+        }, _validate: function(e, t, r, n) {
+          if (e.year) {
+            if (this._validateLevel === 0 && this.name !== e.calendar().name) throw (Gs.local.differentCalendars || Gs.regionalOptions[""].differentCalendars).replace(/\{0\}/, this.local.name).replace(/\{1\}/, e.calendar().local.name);
+            return e;
+          }
+          try {
+            if (this._validateLevel++, this._validateLevel === 1 && !this.isValid(e, t, r)) throw n.replace(/\{0\}/, this.local.name);
+            var i = this.newDate(e, t, r);
+            return this._validateLevel--, i;
+          } catch (a) {
+            throw this._validateLevel--, a;
+          }
+        } });
+        function mQ(e) {
+          this.local = this.regionalOptions[e] || this.regionalOptions[""];
+        }
+        mQ.prototype = new gQ();
+        D9(mQ.prototype, { name: "Gregorian", jdEpoch: 17214255e-1, daysPerMonth: [31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31], hasYearZero: false, minMonth: 1, firstMonth: 1, minDay: 1, regionalOptions: { "": { name: "Gregorian", epochs: ["BCE", "CE"], monthNames: ["January", "February", "March", "April", "May", "June", "July", "August", "September", "October", "November", "December"], monthNamesShort: ["Jan", "Feb", "Mar", "Apr", "May", "Jun", "Jul", "Aug", "Sep", "Oct", "Nov", "Dec"], dayNames: ["Sunday", "Monday", "Tuesday", "Wednesday", "Thursday", "Friday", "Saturday"], dayNamesShort: ["Sun", "Mon", "Tue", "Wed", "Thu", "Fri", "Sat"], dayNamesMin: ["Su", "Mo", "Tu", "We", "Th", "Fr", "Sa"], digits: null, dateFormat: "mm/dd/yyyy", firstDay: 0, isRTL: false } }, leapYear: function(r) {
+          var t = this._validate(r, this.minMonth, this.minDay, Gs.local.invalidYear || Gs.regionalOptions[""].invalidYear), r = t.year() + (t.year() < 0 ? 1 : 0);
+          return r % 4 === 0 && (r % 100 !== 0 || r % 400 === 0);
+        }, weekOfYear: function(e, t, r) {
+          var n = this.newDate(e, t, r);
+          return n.add(4 - (n.dayOfWeek() || 7), "d"), Math.floor((n.dayOfYear() - 1) / 7) + 1;
+        }, daysInMonth: function(e, t) {
+          var r = this._validate(e, t, this.minDay, Gs.local.invalidMonth || Gs.regionalOptions[""].invalidMonth);
+          return this.daysPerMonth[r.month() - 1] + (r.month() === 2 && this.leapYear(r.year()) ? 1 : 0);
+        }, weekDay: function(e, t, r) {
+          return (this.dayOfWeek(e, t, r) || 7) < 6;
+        }, toJD: function(e, t, r) {
+          var n = this._validate(e, t, r, Gs.local.invalidDate || Gs.regionalOptions[""].invalidDate);
+          e = n.year(), t = n.month(), r = n.day(), e < 0 && e++, t < 3 && (t += 12, e--);
+          var i = Math.floor(e / 100), a = 2 - i + Math.floor(i / 4);
+          return Math.floor(365.25 * (e + 4716)) + Math.floor(30.6001 * (t + 1)) + r + a - 1524.5;
+        }, fromJD: function(e) {
+          var t = Math.floor(e + 0.5), r = Math.floor((t - 186721625e-2) / 36524.25);
+          r = t + 1 + r - Math.floor(r / 4);
+          var n = r + 1524, i = Math.floor((n - 122.1) / 365.25), a = Math.floor(365.25 * i), o = Math.floor((n - a) / 30.6001), s = n - a - Math.floor(o * 30.6001), l = o - (o > 13.5 ? 13 : 1), u = i - (l > 2.5 ? 4716 : 4715);
+          return u <= 0 && u--, this.newDate(u, l, s);
+        }, toJSDate: function(e, t, r) {
+          var n = this._validate(e, t, r, Gs.local.invalidDate || Gs.regionalOptions[""].invalidDate), i = new Date(n.year(), n.month() - 1, n.day());
+          return i.setHours(0), i.setMinutes(0), i.setSeconds(0), i.setMilliseconds(0), i.setHours(i.getHours() > 12 ? i.getHours() + 2 : 0), i;
+        }, fromJSDate: function(e) {
+          return this.newDate(e.getFullYear(), e.getMonth() + 1, e.getDate());
+        } });
+        var Gs = eet.exports = new QQe();
+        Gs.cdate = pQ;
+        Gs.baseCalendar = gQ;
+        Gs.calendars.gregorian = mQ;
+      });
+      var tet = ye(() => {
+        var yQ = Nh(), Nd = kv();
+        yQ(Nd.regionalOptions[""], { invalidArguments: "Invalid arguments", invalidFormat: "Cannot format a date from another calendar", missingNumberAt: "Missing number at position {0}", unknownNameAt: "Unknown name at position {0}", unexpectedLiteralAt: "Unexpected literal at position {0}", unexpectedText: "Additional text found at end" });
+        Nd.local = Nd.regionalOptions[""];
+        yQ(Nd.cdate.prototype, { formatDate: function(e, t) {
+          return typeof e != "string" && (t = e, e = ""), this._calendar.formatDate(e || "", this, t);
+        } });
+        yQ(Nd.baseCalendar.prototype, { UNIX_EPOCH: Nd.instance().newDate(1970, 1, 1).toJD(), SECS_PER_DAY: 24 * 60 * 60, TICKS_EPOCH: Nd.instance().jdEpoch, TICKS_PER_DAY: 24 * 60 * 60 * 1e7, ATOM: "yyyy-mm-dd", COOKIE: "D, dd M yyyy", FULL: "DD, MM d, yyyy", ISO_8601: "yyyy-mm-dd", JULIAN: "J", RFC_822: "D, d M yy", RFC_850: "DD, dd-M-yy", RFC_1036: "D, d M yy", RFC_1123: "D, d M yyyy", RFC_2822: "D, d M yyyy", RSS: "D, d M yy", TICKS: "!", TIMESTAMP: "@", W3C: "yyyy-mm-dd", formatDate: function(e, t, r) {
+          if (typeof e != "string" && (r = t, t = e, e = ""), !t) return "";
+          if (t.calendar() !== this) throw Nd.local.invalidFormat || Nd.regionalOptions[""].invalidFormat;
+          e = e || this.local.dateFormat, r = r || {};
+          for (var n = r.dayNamesShort || this.local.dayNamesShort, i = r.dayNames || this.local.dayNames, a = r.monthNumbers || this.local.monthNumbers, o = r.monthNamesShort || this.local.monthNamesShort, s = r.monthNames || this.local.monthNames, l = r.calculateWeek || this.local.calculateWeek, u = function(T, L) {
+            for (var x = 1; E + x < e.length && e.charAt(E + x) === T; ) x++;
+            return E += x - 1, Math.floor(x / (L || 1)) > 1;
+          }, c = function(T, L, x, C) {
+            var M = "" + L;
+            if (u(T, C)) for (; M.length < x; ) M = "0" + M;
+            return M;
+          }, f = function(T, L, x, C) {
+            return u(T) ? C[L] : x[L];
+          }, h = this, d = function(T) {
+            return typeof a == "function" ? a.call(h, T, u("m")) : b(c("m", T.month(), 2));
+          }, v = function(T, L) {
+            return L ? typeof s == "function" ? s.call(h, T) : s[T.month() - h.minMonth] : typeof o == "function" ? o.call(h, T) : o[T.month() - h.minMonth];
+          }, _ = this.local.digits, b = function(T) {
+            return r.localNumbers && _ ? _(T) : T;
+          }, p = "", k = false, E = 0; E < e.length; E++) if (k) e.charAt(E) === "'" && !u("'") ? k = false : p += e.charAt(E);
+          else switch (e.charAt(E)) {
+            case "d":
+              p += b(c("d", t.day(), 2));
+              break;
+            case "D":
+              p += f("D", t.dayOfWeek(), n, i);
+              break;
+            case "o":
+              p += c("o", t.dayOfYear(), 3);
+              break;
+            case "w":
+              p += c("w", t.weekOfYear(), 2);
+              break;
+            case "m":
+              p += d(t);
+              break;
+            case "M":
+              p += v(t, u("M"));
+              break;
+            case "y":
+              p += u("y", 2) ? t.year() : (t.year() % 100 < 10 ? "0" : "") + t.year() % 100;
+              break;
+            case "Y":
+              u("Y", 2), p += t.formatYear();
+              break;
+            case "J":
+              p += t.toJD();
+              break;
+            case "@":
+              p += (t.toJD() - this.UNIX_EPOCH) * this.SECS_PER_DAY;
+              break;
+            case "!":
+              p += (t.toJD() - this.TICKS_EPOCH) * this.TICKS_PER_DAY;
+              break;
+            case "'":
+              u("'") ? p += "'" : k = true;
+              break;
+            default:
+              p += e.charAt(E);
+          }
+          return p;
+        }, parseDate: function(e, t, r) {
+          if (t == null) throw Nd.local.invalidArguments || Nd.regionalOptions[""].invalidArguments;
+          if (t = typeof t == "object" ? t.toString() : t + "", t === "") return null;
+          e = e || this.local.dateFormat, r = r || {};
+          var n = r.shortYearCutoff || this.shortYearCutoff;
+          n = typeof n != "string" ? n : this.today().year() % 100 + parseInt(n, 10);
+          for (var i = r.dayNamesShort || this.local.dayNamesShort, a = r.dayNames || this.local.dayNames, o = r.parseMonth || this.local.parseMonth, s = r.monthNumbers || this.local.monthNumbers, l = r.monthNamesShort || this.local.monthNamesShort, u = r.monthNames || this.local.monthNames, c = -1, f = -1, h = -1, d = -1, v = -1, _ = false, b = false, p = function(z, O) {
+            for (var U = 1; g + U < e.length && e.charAt(g + U) === z; ) U++;
+            return g += U - 1, Math.floor(U / (O || 1)) > 1;
+          }, k = function(z, O) {
+            var U = p(z, O), G = [2, 3, U ? 4 : 2, U ? 4 : 2, 10, 11, 20]["oyYJ@!".indexOf(z) + 1], Z = new RegExp("^-?\\d{1," + G + "}"), j = t.substring(M).match(Z);
+            if (!j) throw (Nd.local.missingNumberAt || Nd.regionalOptions[""].missingNumberAt).replace(/\{0\}/, M);
+            return M += j[0].length, parseInt(j[0], 10);
+          }, E = this, T = function() {
+            if (typeof s == "function") {
+              p("m");
+              var z = s.call(E, t.substring(M));
+              return M += z.length, z;
+            }
+            return k("m");
+          }, L = function(z, O, U, G) {
+            for (var Z = p(z, G) ? U : O, j = 0; j < Z.length; j++) if (t.substr(M, Z[j].length).toLowerCase() === Z[j].toLowerCase()) return M += Z[j].length, j + E.minMonth;
+            throw (Nd.local.unknownNameAt || Nd.regionalOptions[""].unknownNameAt).replace(/\{0\}/, M);
+          }, x = function() {
+            if (typeof u == "function") {
+              var z = p("M") ? u.call(E, t.substring(M)) : l.call(E, t.substring(M));
+              return M += z.length, z;
+            }
+            return L("M", l, u);
+          }, C = function() {
+            if (t.charAt(M) !== e.charAt(g)) throw (Nd.local.unexpectedLiteralAt || Nd.regionalOptions[""].unexpectedLiteralAt).replace(/\{0\}/, M);
+            M++;
+          }, M = 0, g = 0; g < e.length; g++) if (b) e.charAt(g) === "'" && !p("'") ? b = false : C();
+          else switch (e.charAt(g)) {
+            case "d":
+              d = k("d");
+              break;
+            case "D":
+              L("D", i, a);
+              break;
+            case "o":
+              v = k("o");
+              break;
+            case "w":
+              k("w");
+              break;
+            case "m":
+              h = T();
+              break;
+            case "M":
+              h = x();
+              break;
+            case "y":
+              var P = g;
+              _ = !p("y", 2), g = P, f = k("y", 2);
+              break;
+            case "Y":
+              f = k("Y", 2);
+              break;
+            case "J":
+              c = k("J") + 0.5, t.charAt(M) === "." && (M++, k("J"));
+              break;
+            case "@":
+              c = k("@") / this.SECS_PER_DAY + this.UNIX_EPOCH;
+              break;
+            case "!":
+              c = k("!") / this.TICKS_PER_DAY + this.TICKS_EPOCH;
+              break;
+            case "*":
+              M = t.length;
+              break;
+            case "'":
+              p("'") ? C() : b = true;
+              break;
+            default:
+              C();
+          }
+          if (M < t.length) throw Nd.local.unexpectedText || Nd.regionalOptions[""].unexpectedText;
+          if (f === -1 ? f = this.today().year() : f < 100 && _ && (f += n === -1 ? 1900 : this.today().year() - this.today().year() % 100 - (f <= n ? 0 : 100)), typeof h == "string" && (h = o.call(this, f, h)), v > -1) {
+            h = 1, d = v;
+            for (var A = this.daysInMonth(f, h); d > A; A = this.daysInMonth(f, h)) h++, d -= A;
+          }
+          return c > -1 ? this.fromJD(c) : this.newDate(f, h, d);
+        }, determineDate: function(e, t, r, n, i) {
+          r && typeof r != "object" && (i = n, n = r, r = null), typeof n != "string" && (i = n, n = "");
+          var a = this, o = function(s) {
+            try {
+              return a.parseDate(n, s, i);
+            } catch (f) {
+            }
+            s = s.toLowerCase();
+            for (var l = (s.match(/^c/) && r ? r.newDate() : null) || a.today(), u = /([+-]?[0-9]+)\s*(d|w|m|y)?/g, c = u.exec(s); c; ) l.add(parseInt(c[1], 10), c[2] || "d"), c = u.exec(s);
+            return l;
+          };
+          return t = t ? t.newDate() : null, e = e == null ? t : typeof e == "string" ? o(e) : typeof e == "number" ? isNaN(e) || e === 1 / 0 || e === -1 / 0 ? t : a.today().add(e, "d") : a.newDate(e), e;
+        } });
+      });
+      var ret = ye(() => {
+        var Hx = kv(), Otr = Nh(), _Q = Hx.instance();
+        function F9(e) {
+          this.local = this.regionalOptions[e || ""] || this.regionalOptions[""];
+        }
+        F9.prototype = new Hx.baseCalendar();
+        Otr(F9.prototype, { name: "Chinese", jdEpoch: 17214255e-1, hasYearZero: false, minMonth: 0, firstMonth: 0, minDay: 1, regionalOptions: { "": { name: "Chinese", epochs: ["BEC", "EC"], monthNumbers: function(e, t) {
+          if (typeof e == "string") {
+            var r = e.match(Btr);
+            return r ? r[0] : "";
+          }
+          var n = this._validateYear(e), i = e.month(), a = "" + this.toChineseMonth(n, i);
+          return t && a.length < 2 && (a = "0" + a), this.isIntercalaryMonth(n, i) && (a += "i"), a;
+        }, monthNames: function(e) {
+          if (typeof e == "string") {
+            var t = e.match(Ntr);
+            return t ? t[0] : "";
+          }
+          var r = this._validateYear(e), n = e.month(), i = this.toChineseMonth(r, n), a = ["一月", "二月", "三月", "四月", "五月", "六月", "七月", "八月", "九月", "十月", "十一月", "十二月"][i - 1];
+          return this.isIntercalaryMonth(r, n) && (a = "闰" + a), a;
+        }, monthNamesShort: function(e) {
+          if (typeof e == "string") {
+            var t = e.match(Utr);
+            return t ? t[0] : "";
+          }
+          var r = this._validateYear(e), n = e.month(), i = this.toChineseMonth(r, n), a = ["一", "二", "三", "四", "五", "六", "七", "八", "九", "十", "十一", "十二"][i - 1];
+          return this.isIntercalaryMonth(r, n) && (a = "闰" + a), a;
+        }, parseMonth: function(e, t) {
+          e = this._validateYear(e);
+          var r = parseInt(t), n;
+          if (isNaN(r)) t[0] === "闰" && (n = true, t = t.substring(1)), t[t.length - 1] === "月" && (t = t.substring(0, t.length - 1)), r = 1 + ["一", "二", "三", "四", "五", "六", "七", "八", "九", "十", "十一", "十二"].indexOf(t);
+          else {
+            var i = t[t.length - 1];
+            n = i === "i" || i === "I";
+          }
+          var a = this.toMonthIndex(e, r, n);
+          return a;
+        }, dayNames: ["Sunday", "Monday", "Tuesday", "Wednesday", "Thursday", "Friday", "Saturday"], dayNamesShort: ["Sun", "Mon", "Tue", "Wed", "Thu", "Fri", "Sat"], dayNamesMin: ["Su", "Mo", "Tu", "We", "Th", "Fr", "Sa"], digits: null, dateFormat: "yyyy/mm/dd", firstDay: 1, isRTL: false } }, _validateYear: function(e, t) {
+          if (e.year && (e = e.year()), typeof e != "number" || e < 1888 || e > 2111) throw t.replace(/\{0\}/, this.local.name);
+          return e;
+        }, toMonthIndex: function(e, t, r) {
+          var n = this.intercalaryMonth(e), i = r && t !== n;
+          if (i || t < 1 || t > 12) throw Hx.local.invalidMonth.replace(/\{0\}/, this.local.name);
+          var a;
+          return n ? !r && t <= n ? a = t - 1 : a = t : a = t - 1, a;
+        }, toChineseMonth: function(e, t) {
+          e.year && (e = e.year(), t = e.month());
+          var r = this.intercalaryMonth(e), n = r ? 12 : 11;
+          if (t < 0 || t > n) throw Hx.local.invalidMonth.replace(/\{0\}/, this.local.name);
+          var i;
+          return r ? t < r ? i = t + 1 : i = t : i = t + 1, i;
+        }, intercalaryMonth: function(e) {
+          e = this._validateYear(e);
+          var t = jx[e - jx[0]], r = t >> 13;
+          return r;
+        }, isIntercalaryMonth: function(e, t) {
+          e.year && (e = e.year(), t = e.month());
+          var r = this.intercalaryMonth(e);
+          return !!r && r === t;
+        }, leapYear: function(e) {
+          return this.intercalaryMonth(e) !== 0;
+        }, weekOfYear: function(e, t, r) {
+          var n = this._validateYear(e, Hx.local.invalidyear), i = Wx[n - Wx[0]], a = i >> 9 & 4095, o = i >> 5 & 15, s = i & 31, l;
+          l = _Q.newDate(a, o, s), l.add(4 - (l.dayOfWeek() || 7), "d");
+          var u = this.toJD(e, t, r) - l.toJD();
+          return 1 + Math.floor(u / 7);
+        }, monthsInYear: function(e) {
+          return this.leapYear(e) ? 13 : 12;
+        }, daysInMonth: function(e, t) {
+          e.year && (t = e.month(), e = e.year()), e = this._validateYear(e);
+          var r = jx[e - jx[0]], n = r >> 13, i = n ? 12 : 11;
+          if (t > i) throw Hx.local.invalidMonth.replace(/\{0\}/, this.local.name);
+          var a = r & 1 << 12 - t ? 30 : 29;
+          return a;
+        }, weekDay: function(e, t, r) {
+          return (this.dayOfWeek(e, t, r) || 7) < 6;
+        }, toJD: function(e, t, r) {
+          var n = this._validate(e, a, r, Hx.local.invalidDate);
+          e = this._validateYear(n.year()), t = n.month(), r = n.day();
+          var i = this.isIntercalaryMonth(e, t), a = this.toChineseMonth(e, t), o = Gtr(e, a, r, i);
+          return _Q.toJD(o.year, o.month, o.day);
+        }, fromJD: function(e) {
+          var t = _Q.fromJD(e), r = Vtr(t.year(), t.month(), t.day()), n = this.toMonthIndex(r.year, r.month, r.isIntercalary);
+          return this.newDate(r.year, n, r.day);
+        }, fromString: function(e) {
+          var t = e.match(qtr), r = this._validateYear(+t[1]), n = +t[2], i = !!t[3], a = this.toMonthIndex(r, n, i), o = +t[4];
+          return this.newDate(r, a, o);
+        }, add: function(e, t, r) {
+          var n = e.year(), i = e.month(), a = this.isIntercalaryMonth(n, i), o = this.toChineseMonth(n, i), s = Object.getPrototypeOf(F9.prototype).add.call(this, e, t, r);
+          if (r === "y") {
+            var l = s.year(), u = s.month(), c = this.isIntercalaryMonth(l, o), f = a && c ? this.toMonthIndex(l, o, true) : this.toMonthIndex(l, o, false);
+            f !== u && s.month(f);
+          }
+          return s;
+        } });
+        var qtr = /^\s*(-?\d\d\d\d|\d\d)[-/](\d?\d)([iI]?)[-/](\d?\d)/m, Btr = /^\d?\d[iI]?/m, Ntr = /^闰?十?[一二三四五六七八九]?月/m, Utr = /^闰?十?[一二三四五六七八九]?/m;
+        Hx.calendars.chinese = F9;
+        var jx = [1887, 5780, 5802, 19157, 2742, 50359, 1198, 2646, 46378, 7466, 3412, 30122, 5482, 67949, 2396, 5294, 43597, 6732, 6954, 36181, 2772, 4954, 18781, 2396, 54427, 5274, 6730, 47781, 5800, 6868, 21210, 4790, 59703, 2350, 5270, 46667, 3402, 3496, 38325, 1388, 4782, 18735, 2350, 52374, 6804, 7498, 44457, 2906, 1388, 29294, 4700, 63789, 6442, 6804, 56138, 5802, 2772, 38235, 1210, 4698, 22827, 5418, 63125, 3476, 5802, 43701, 2484, 5302, 27223, 2646, 70954, 7466, 3412, 54698, 5482, 2412, 38062, 5294, 2636, 32038, 6954, 60245, 2772, 4826, 43357, 2394, 5274, 39501, 6730, 72357, 5800, 5844, 53978, 4790, 2358, 38039, 5270, 87627, 3402, 3496, 54708, 5484, 4782, 43311, 2350, 3222, 27978, 7498, 68965, 2904, 5484, 45677, 4700, 6444, 39573, 6804, 6986, 19285, 2772, 62811, 1210, 4698, 47403, 5418, 5780, 38570, 5546, 76469, 2420, 5302, 51799, 2646, 5414, 36501, 3412, 5546, 18869, 2412, 54446, 5276, 6732, 48422, 6822, 2900, 28010, 4826, 92509, 2394, 5274, 55883, 6730, 6820, 47956, 5812, 2778, 18779, 2358, 62615, 5270, 5450, 46757, 3492, 5556, 27318, 4718, 67887, 2350, 3222, 52554, 7498, 3428, 38252, 5468, 4700, 31022, 6444, 64149, 6804, 6986, 43861, 2772, 5338, 35421, 2650, 70955, 5418, 5780, 54954, 5546, 2740, 38074, 5302, 2646, 29991, 3366, 61011, 3412, 5546, 43445, 2412, 5294, 35406, 6732, 72998, 6820, 6996, 52586, 2778, 2396, 38045, 5274, 6698, 23333, 6820, 64338, 5812, 2746, 43355, 2358, 5270, 39499, 5450, 79525, 3492, 5548], Wx = [1887, 966732, 967231, 967733, 968265, 968766, 969297, 969798, 970298, 970829, 971330, 971830, 972362, 972863, 973395, 973896, 974397, 974928, 975428, 975929, 976461, 976962, 977462, 977994, 978494, 979026, 979526, 980026, 980558, 981059, 981559, 982091, 982593, 983124, 983624, 984124, 984656, 985157, 985656, 986189, 986690, 987191, 987722, 988222, 988753, 989254, 989754, 990286, 990788, 991288, 991819, 992319, 992851, 993352, 993851, 994383, 994885, 995385, 995917, 996418, 996918, 997450, 997949, 998481, 998982, 999483, 1000014, 1000515, 1001016, 1001548, 1002047, 1002578, 1003080, 1003580, 1004111, 1004613, 1005113, 1005645, 1006146, 1006645, 1007177, 1007678, 1008209, 1008710, 1009211, 1009743, 1010243, 1010743, 1011275, 1011775, 1012306, 1012807, 1013308, 1013840, 1014341, 1014841, 1015373, 1015874, 1016404, 1016905, 1017405, 1017937, 1018438, 1018939, 1019471, 1019972, 1020471, 1021002, 1021503, 1022035, 1022535, 1023036, 1023568, 1024069, 1024568, 1025100, 1025601, 1026102, 1026633, 1027133, 1027666, 1028167, 1028666, 1029198, 1029699, 1030199, 1030730, 1031231, 1031763, 1032264, 1032764, 1033296, 1033797, 1034297, 1034828, 1035329, 1035830, 1036362, 1036861, 1037393, 1037894, 1038394, 1038925, 1039427, 1039927, 1040459, 1040959, 1041491, 1041992, 1042492, 1043023, 1043524, 1044024, 1044556, 1045057, 1045558, 1046090, 1046590, 1047121, 1047622, 1048122, 1048654, 1049154, 1049655, 1050187, 1050689, 1051219, 1051720, 1052220, 1052751, 1053252, 1053752, 1054284, 1054786, 1055285, 1055817, 1056317, 1056849, 1057349, 1057850, 1058382, 1058883, 1059383, 1059915, 1060415, 1060947, 1061447, 1061947, 1062479, 1062981, 1063480, 1064012, 1064514, 1065014, 1065545, 1066045, 1066577, 1067078, 1067578, 1068110, 1068611, 1069112, 1069642, 1070142, 1070674, 1071175, 1071675, 1072207, 1072709, 1073209, 1073740, 1074241, 1074741, 1075273, 1075773, 1076305, 1076807, 1077308, 1077839, 1078340, 1078840, 1079372, 1079871, 1080403, 1080904];
+        function Vtr(e, t, r, n) {
+          var i, a;
+          if (typeof e == "object") i = e, a = t || {};
+          else {
+            var o = typeof e == "number" && e >= 1888 && e <= 2111;
+            if (!o) throw new Error("Solar year outside range 1888-2111");
+            var s = typeof t == "number" && t >= 1 && t <= 12;
+            if (!s) throw new Error("Solar month outside range 1 - 12");
+            var l = typeof r == "number" && r >= 1 && r <= 31;
+            if (!l) throw new Error("Solar day outside range 1 - 31");
+            i = { year: e, month: t, day: r }, a = {};
+          }
+          var u = Wx[i.year - Wx[0]], c = i.year << 9 | i.month << 5 | i.day;
+          a.year = c >= u ? i.year : i.year - 1, u = Wx[a.year - Wx[0]];
+          var f = u >> 9 & 4095, h = u >> 5 & 15, d = u & 31, v, _ = new Date(f, h - 1, d), b = new Date(i.year, i.month - 1, i.day);
+          v = Math.round((b - _) / (24 * 3600 * 1e3));
+          var p = jx[a.year - jx[0]], k;
+          for (k = 0; k < 13; k++) {
+            var E = p & 1 << 12 - k ? 30 : 29;
+            if (v < E) break;
+            v -= E;
+          }
+          var T = p >> 13;
+          return !T || k < T ? (a.isIntercalary = false, a.month = 1 + k) : k === T ? (a.isIntercalary = true, a.month = k) : (a.isIntercalary = false, a.month = k), a.day = 1 + v, a;
+        }
+        function Gtr(e, t, r, n, i) {
+          var a, o;
+          if (typeof e == "object") o = e, a = t || {};
+          else {
+            var s = typeof e == "number" && e >= 1888 && e <= 2111;
+            if (!s) throw new Error("Lunar year outside range 1888-2111");
+            var l = typeof t == "number" && t >= 1 && t <= 12;
+            if (!l) throw new Error("Lunar month outside range 1 - 12");
+            var u = typeof r == "number" && r >= 1 && r <= 30;
+            if (!u) throw new Error("Lunar day outside range 1 - 30");
+            var c;
+            typeof n == "object" ? (c = false, a = n) : (c = !!n, a = {}), o = { year: e, month: t, day: r, isIntercalary: c };
+          }
+          var f;
+          f = o.day - 1;
+          var h = jx[o.year - jx[0]], d = h >> 13, v;
+          d && (o.month > d || o.isIntercalary) ? v = o.month : v = o.month - 1;
+          for (var _ = 0; _ < v; _++) {
+            var b = h & 1 << 12 - _ ? 30 : 29;
+            f += b;
+          }
+          var p = Wx[o.year - Wx[0]], k = p >> 9 & 4095, E = p >> 5 & 15, T = p & 31, L = new Date(k, E - 1, T + f);
+          return a.year = L.getFullYear(), a.month = 1 + L.getMonth(), a.day = L.getDate(), a;
+        }
+      });
+      var iet = ye(() => {
+        var Lw = kv(), Htr = Nh();
+        function xQ(e) {
+          this.local = this.regionalOptions[e || ""] || this.regionalOptions[""];
+        }
+        xQ.prototype = new Lw.baseCalendar();
+        Htr(xQ.prototype, { name: "Coptic", jdEpoch: 18250295e-1, daysPerMonth: [30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 5], hasYearZero: false, minMonth: 1, firstMonth: 1, minDay: 1, regionalOptions: { "": { name: "Coptic", epochs: ["BAM", "AM"], monthNames: ["Thout", "Paopi", "Hathor", "Koiak", "Tobi", "Meshir", "Paremhat", "Paremoude", "Pashons", "Paoni", "Epip", "Mesori", "Pi Kogi Enavot"], monthNamesShort: ["Tho", "Pao", "Hath", "Koi", "Tob", "Mesh", "Pat", "Pad", "Pash", "Pao", "Epi", "Meso", "PiK"], dayNames: ["Tkyriaka", "Pesnau", "Pshoment", "Peftoou", "Ptiou", "Psoou", "Psabbaton"], dayNamesShort: ["Tky", "Pes", "Psh", "Pef", "Pti", "Pso", "Psa"], dayNamesMin: ["Tk", "Pes", "Psh", "Pef", "Pt", "Pso", "Psa"], digits: null, dateFormat: "dd/mm/yyyy", firstDay: 0, isRTL: false } }, leapYear: function(r) {
+          var t = this._validate(r, this.minMonth, this.minDay, Lw.local.invalidYear), r = t.year() + (t.year() < 0 ? 1 : 0);
+          return r % 4 === 3 || r % 4 === -1;
+        }, monthsInYear: function(e) {
+          return this._validate(e, this.minMonth, this.minDay, Lw.local.invalidYear || Lw.regionalOptions[""].invalidYear), 13;
+        }, weekOfYear: function(e, t, r) {
+          var n = this.newDate(e, t, r);
+          return n.add(-n.dayOfWeek(), "d"), Math.floor((n.dayOfYear() - 1) / 7) + 1;
+        }, daysInMonth: function(e, t) {
+          var r = this._validate(e, t, this.minDay, Lw.local.invalidMonth);
+          return this.daysPerMonth[r.month() - 1] + (r.month() === 13 && this.leapYear(r.year()) ? 1 : 0);
+        }, weekDay: function(e, t, r) {
+          return (this.dayOfWeek(e, t, r) || 7) < 6;
+        }, toJD: function(e, t, r) {
+          var n = this._validate(e, t, r, Lw.local.invalidDate);
+          return e = n.year(), e < 0 && e++, n.day() + (n.month() - 1) * 30 + (e - 1) * 365 + Math.floor(e / 4) + this.jdEpoch - 1;
+        }, fromJD: function(e) {
+          var t = Math.floor(e) + 0.5 - this.jdEpoch, r = Math.floor((t - Math.floor((t + 366) / 1461)) / 365) + 1;
+          r <= 0 && r--, t = Math.floor(e) + 0.5 - this.newDate(r, 1, 1).toJD();
+          var n = Math.floor(t / 30) + 1, i = t - (n - 1) * 30 + 1;
+          return this.newDate(r, n, i);
+        } });
+        Lw.calendars.coptic = xQ;
+      });
+      var net = ye(() => {
+        var E1 = kv(), jtr = Nh();
+        function bQ(e) {
+          this.local = this.regionalOptions[e || ""] || this.regionalOptions[""];
+        }
+        bQ.prototype = new E1.baseCalendar();
+        jtr(bQ.prototype, { name: "Discworld", jdEpoch: 17214255e-1, daysPerMonth: [16, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32], hasYearZero: false, minMonth: 1, firstMonth: 1, minDay: 1, regionalOptions: { "": { name: "Discworld", epochs: ["BUC", "UC"], monthNames: ["Ick", "Offle", "February", "March", "April", "May", "June", "Grune", "August", "Spune", "Sektober", "Ember", "December"], monthNamesShort: ["Ick", "Off", "Feb", "Mar", "Apr", "May", "Jun", "Gru", "Aug", "Spu", "Sek", "Emb", "Dec"], dayNames: ["Sunday", "Octeday", "Monday", "Tuesday", "Wednesday", "Thursday", "Friday", "Saturday"], dayNamesShort: ["Sun", "Oct", "Mon", "Tue", "Wed", "Thu", "Fri", "Sat"], dayNamesMin: ["Su", "Oc", "Mo", "Tu", "We", "Th", "Fr", "Sa"], digits: null, dateFormat: "yyyy/mm/dd", firstDay: 2, isRTL: false } }, leapYear: function(e) {
+          return this._validate(e, this.minMonth, this.minDay, E1.local.invalidYear), false;
+        }, monthsInYear: function(e) {
+          return this._validate(e, this.minMonth, this.minDay, E1.local.invalidYear), 13;
+        }, daysInYear: function(e) {
+          return this._validate(e, this.minMonth, this.minDay, E1.local.invalidYear), 400;
+        }, weekOfYear: function(e, t, r) {
+          var n = this.newDate(e, t, r);
+          return n.add(-n.dayOfWeek(), "d"), Math.floor((n.dayOfYear() - 1) / 8) + 1;
+        }, daysInMonth: function(e, t) {
+          var r = this._validate(e, t, this.minDay, E1.local.invalidMonth);
+          return this.daysPerMonth[r.month() - 1];
+        }, daysInWeek: function() {
+          return 8;
+        }, dayOfWeek: function(e, t, r) {
+          var n = this._validate(e, t, r, E1.local.invalidDate);
+          return (n.day() + 1) % 8;
+        }, weekDay: function(e, t, r) {
+          var n = this.dayOfWeek(e, t, r);
+          return n >= 2 && n <= 6;
+        }, extraInfo: function(e, t, r) {
+          var n = this._validate(e, t, r, E1.local.invalidDate);
+          return { century: Wtr[Math.floor((n.year() - 1) / 100) + 1] || "" };
+        }, toJD: function(e, t, r) {
+          var n = this._validate(e, t, r, E1.local.invalidDate);
+          return e = n.year() + (n.year() < 0 ? 1 : 0), t = n.month(), r = n.day(), r + (t > 1 ? 16 : 0) + (t > 2 ? (t - 2) * 32 : 0) + (e - 1) * 400 + this.jdEpoch - 1;
+        }, fromJD: function(e) {
+          e = Math.floor(e + 0.5) - Math.floor(this.jdEpoch) - 1;
+          var t = Math.floor(e / 400) + 1;
+          e -= (t - 1) * 400, e += e > 15 ? 16 : 0;
+          var r = Math.floor(e / 32) + 1, n = e - (r - 1) * 32 + 1;
+          return this.newDate(t <= 0 ? t - 1 : t, r, n);
+        } });
+        var Wtr = { 20: "Fruitbat", 21: "Anchovy" };
+        E1.calendars.discworld = bQ;
+      });
+      var aet = ye(() => {
+        var Pw = kv(), Xtr = Nh();
+        function wQ(e) {
+          this.local = this.regionalOptions[e || ""] || this.regionalOptions[""];
+        }
+        wQ.prototype = new Pw.baseCalendar();
+        Xtr(wQ.prototype, { name: "Ethiopian", jdEpoch: 17242205e-1, daysPerMonth: [30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 5], hasYearZero: false, minMonth: 1, firstMonth: 1, minDay: 1, regionalOptions: { "": { name: "Ethiopian", epochs: ["BEE", "EE"], monthNames: ["Meskerem", "Tikemet", "Hidar", "Tahesas", "Tir", "Yekatit", "Megabit", "Miazia", "Genbot", "Sene", "Hamle", "Nehase", "Pagume"], monthNamesShort: ["Mes", "Tik", "Hid", "Tah", "Tir", "Yek", "Meg", "Mia", "Gen", "Sen", "Ham", "Neh", "Pag"], dayNames: ["Ehud", "Segno", "Maksegno", "Irob", "Hamus", "Arb", "Kidame"], dayNamesShort: ["Ehu", "Seg", "Mak", "Iro", "Ham", "Arb", "Kid"], dayNamesMin: ["Eh", "Se", "Ma", "Ir", "Ha", "Ar", "Ki"], digits: null, dateFormat: "dd/mm/yyyy", firstDay: 0, isRTL: false } }, leapYear: function(r) {
+          var t = this._validate(r, this.minMonth, this.minDay, Pw.local.invalidYear), r = t.year() + (t.year() < 0 ? 1 : 0);
+          return r % 4 === 3 || r % 4 === -1;
+        }, monthsInYear: function(e) {
+          return this._validate(e, this.minMonth, this.minDay, Pw.local.invalidYear || Pw.regionalOptions[""].invalidYear), 13;
+        }, weekOfYear: function(e, t, r) {
+          var n = this.newDate(e, t, r);
+          return n.add(-n.dayOfWeek(), "d"), Math.floor((n.dayOfYear() - 1) / 7) + 1;
+        }, daysInMonth: function(e, t) {
+          var r = this._validate(e, t, this.minDay, Pw.local.invalidMonth);
+          return this.daysPerMonth[r.month() - 1] + (r.month() === 13 && this.leapYear(r.year()) ? 1 : 0);
+        }, weekDay: function(e, t, r) {
+          return (this.dayOfWeek(e, t, r) || 7) < 6;
+        }, toJD: function(e, t, r) {
+          var n = this._validate(e, t, r, Pw.local.invalidDate);
+          return e = n.year(), e < 0 && e++, n.day() + (n.month() - 1) * 30 + (e - 1) * 365 + Math.floor(e / 4) + this.jdEpoch - 1;
+        }, fromJD: function(e) {
+          var t = Math.floor(e) + 0.5 - this.jdEpoch, r = Math.floor((t - Math.floor((t + 366) / 1461)) / 365) + 1;
+          r <= 0 && r--, t = Math.floor(e) + 0.5 - this.newDate(r, 1, 1).toJD();
+          var n = Math.floor(t / 30) + 1, i = t - (n - 1) * 30 + 1;
+          return this.newDate(r, n, i);
+        } });
+        Pw.calendars.ethiopian = wQ;
+      });
+      var oet = ye(() => {
+        var Xx = kv(), Ztr = Nh();
+        function TQ(e) {
+          this.local = this.regionalOptions[e || ""] || this.regionalOptions[""];
+        }
+        TQ.prototype = new Xx.baseCalendar();
+        Ztr(TQ.prototype, { name: "Hebrew", jdEpoch: 347995.5, daysPerMonth: [30, 29, 30, 29, 30, 29, 30, 29, 30, 29, 30, 29, 29], hasYearZero: false, minMonth: 1, firstMonth: 7, minDay: 1, regionalOptions: { "": { name: "Hebrew", epochs: ["BAM", "AM"], monthNames: ["Nisan", "Iyar", "Sivan", "Tammuz", "Av", "Elul", "Tishrei", "Cheshvan", "Kislev", "Tevet", "Shevat", "Adar", "Adar II"], monthNamesShort: ["Nis", "Iya", "Siv", "Tam", "Av", "Elu", "Tis", "Che", "Kis", "Tev", "She", "Ada", "Ad2"], dayNames: ["Yom Rishon", "Yom Sheni", "Yom Shlishi", "Yom Revi'i", "Yom Chamishi", "Yom Shishi", "Yom Shabbat"], dayNamesShort: ["Ris", "She", "Shl", "Rev", "Cha", "Shi", "Sha"], dayNamesMin: ["Ri", "She", "Shl", "Re", "Ch", "Shi", "Sha"], digits: null, dateFormat: "dd/mm/yyyy", firstDay: 0, isRTL: false } }, leapYear: function(e) {
+          var t = this._validate(e, this.minMonth, this.minDay, Xx.local.invalidYear);
+          return this._leapYear(t.year());
+        }, _leapYear: function(e) {
+          return e = e < 0 ? e + 1 : e, z9(e * 7 + 1, 19) < 7;
+        }, monthsInYear: function(e) {
+          return this._validate(e, this.minMonth, this.minDay, Xx.local.invalidYear), this._leapYear(e.year ? e.year() : e) ? 13 : 12;
+        }, weekOfYear: function(e, t, r) {
+          var n = this.newDate(e, t, r);
+          return n.add(-n.dayOfWeek(), "d"), Math.floor((n.dayOfYear() - 1) / 7) + 1;
+        }, daysInYear: function(e) {
+          var t = this._validate(e, this.minMonth, this.minDay, Xx.local.invalidYear);
+          return e = t.year(), this.toJD(e === -1 ? 1 : e + 1, 7, 1) - this.toJD(e, 7, 1);
+        }, daysInMonth: function(e, t) {
+          return e.year && (t = e.month(), e = e.year()), this._validate(e, t, this.minDay, Xx.local.invalidMonth), t === 12 && this.leapYear(e) || t === 8 && z9(this.daysInYear(e), 10) === 5 ? 30 : t === 9 && z9(this.daysInYear(e), 10) === 3 ? 29 : this.daysPerMonth[t - 1];
+        }, weekDay: function(e, t, r) {
+          return this.dayOfWeek(e, t, r) !== 6;
+        }, extraInfo: function(e, t, r) {
+          var n = this._validate(e, t, r, Xx.local.invalidDate);
+          return { yearType: (this.leapYear(n) ? "embolismic" : "common") + " " + ["deficient", "regular", "complete"][this.daysInYear(n) % 10 - 3] };
+        }, toJD: function(e, t, r) {
+          var n = this._validate(e, t, r, Xx.local.invalidDate);
+          e = n.year(), t = n.month(), r = n.day();
+          var i = e <= 0 ? e + 1 : e, a = this.jdEpoch + this._delay1(i) + this._delay2(i) + r + 1;
+          if (t < 7) {
+            for (var o = 7; o <= this.monthsInYear(e); o++) a += this.daysInMonth(e, o);
+            for (var o = 1; o < t; o++) a += this.daysInMonth(e, o);
+          } else for (var o = 7; o < t; o++) a += this.daysInMonth(e, o);
+          return a;
+        }, _delay1: function(e) {
+          var t = Math.floor((235 * e - 234) / 19), r = 12084 + 13753 * t, n = t * 29 + Math.floor(r / 25920);
+          return z9(3 * (n + 1), 7) < 3 && n++, n;
+        }, _delay2: function(e) {
+          var t = this._delay1(e - 1), r = this._delay1(e), n = this._delay1(e + 1);
+          return n - r === 356 ? 2 : r - t === 382 ? 1 : 0;
+        }, fromJD: function(e) {
+          e = Math.floor(e) + 0.5;
+          for (var t = Math.floor((e - this.jdEpoch) * 98496 / 35975351) - 1; e >= this.toJD(t === -1 ? 1 : t + 1, 7, 1); ) t++;
+          for (var r = e < this.toJD(t, 1, 1) ? 7 : 1; e > this.toJD(t, r, this.daysInMonth(t, r)); ) r++;
+          var n = e - this.toJD(t, r, 1) + 1;
+          return this.newDate(t, r, n);
+        } });
+        function z9(e, t) {
+          return e - t * Math.floor(e / t);
+        }
+        Xx.calendars.hebrew = TQ;
+      });
+      var set = ye(() => {
+        var bC = kv(), Ytr = Nh();
+        function AQ(e) {
+          this.local = this.regionalOptions[e || ""] || this.regionalOptions[""];
+        }
+        AQ.prototype = new bC.baseCalendar();
+        Ytr(AQ.prototype, { name: "Islamic", jdEpoch: 19484395e-1, daysPerMonth: [30, 29, 30, 29, 30, 29, 30, 29, 30, 29, 30, 29], hasYearZero: false, minMonth: 1, firstMonth: 1, minDay: 1, regionalOptions: { "": { name: "Islamic", epochs: ["BH", "AH"], monthNames: ["Muharram", "Safar", "Rabi' al-awwal", "Rabi' al-thani", "Jumada al-awwal", "Jumada al-thani", "Rajab", "Sha'aban", "Ramadan", "Shawwal", "Dhu al-Qi'dah", "Dhu al-Hijjah"], monthNamesShort: ["Muh", "Saf", "Rab1", "Rab2", "Jum1", "Jum2", "Raj", "Sha'", "Ram", "Shaw", "DhuQ", "DhuH"], dayNames: ["Yawm al-ahad", "Yawm al-ithnayn", "Yawm ath-thulaathaa'", "Yawm al-arbi'aa'", "Yawm al-khamīs", "Yawm al-jum'a", "Yawm as-sabt"], dayNamesShort: ["Aha", "Ith", "Thu", "Arb", "Kha", "Jum", "Sab"], dayNamesMin: ["Ah", "It", "Th", "Ar", "Kh", "Ju", "Sa"], digits: null, dateFormat: "yyyy/mm/dd", firstDay: 6, isRTL: false } }, leapYear: function(e) {
+          var t = this._validate(e, this.minMonth, this.minDay, bC.local.invalidYear);
+          return (t.year() * 11 + 14) % 30 < 11;
+        }, weekOfYear: function(e, t, r) {
+          var n = this.newDate(e, t, r);
+          return n.add(-n.dayOfWeek(), "d"), Math.floor((n.dayOfYear() - 1) / 7) + 1;
+        }, daysInYear: function(e) {
+          return this.leapYear(e) ? 355 : 354;
+        }, daysInMonth: function(e, t) {
+          var r = this._validate(e, t, this.minDay, bC.local.invalidMonth);
+          return this.daysPerMonth[r.month() - 1] + (r.month() === 12 && this.leapYear(r.year()) ? 1 : 0);
+        }, weekDay: function(e, t, r) {
+          return this.dayOfWeek(e, t, r) !== 5;
+        }, toJD: function(e, t, r) {
+          var n = this._validate(e, t, r, bC.local.invalidDate);
+          return e = n.year(), t = n.month(), r = n.day(), e = e <= 0 ? e + 1 : e, r + Math.ceil(29.5 * (t - 1)) + (e - 1) * 354 + Math.floor((3 + 11 * e) / 30) + this.jdEpoch - 1;
+        }, fromJD: function(e) {
+          e = Math.floor(e) + 0.5;
+          var t = Math.floor((30 * (e - this.jdEpoch) + 10646) / 10631);
+          t = t <= 0 ? t - 1 : t;
+          var r = Math.min(12, Math.ceil((e - 29 - this.toJD(t, 1, 1)) / 29.5) + 1), n = e - this.toJD(t, r, 1) + 1;
+          return this.newDate(t, r, n);
+        } });
+        bC.calendars.islamic = AQ;
+      });
+      var uet = ye(() => {
+        var wC = kv(), Ktr = Nh();
+        function SQ(e) {
+          this.local = this.regionalOptions[e || ""] || this.regionalOptions[""];
+        }
+        SQ.prototype = new wC.baseCalendar();
+        Ktr(SQ.prototype, { name: "Julian", jdEpoch: 17214235e-1, daysPerMonth: [31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31], hasYearZero: false, minMonth: 1, firstMonth: 1, minDay: 1, regionalOptions: { "": { name: "Julian", epochs: ["BC", "AD"], monthNames: ["January", "February", "March", "April", "May", "June", "July", "August", "September", "October", "November", "December"], monthNamesShort: ["Jan", "Feb", "Mar", "Apr", "May", "Jun", "Jul", "Aug", "Sep", "Oct", "Nov", "Dec"], dayNames: ["Sunday", "Monday", "Tuesday", "Wednesday", "Thursday", "Friday", "Saturday"], dayNamesShort: ["Sun", "Mon", "Tue", "Wed", "Thu", "Fri", "Sat"], dayNamesMin: ["Su", "Mo", "Tu", "We", "Th", "Fr", "Sa"], digits: null, dateFormat: "mm/dd/yyyy", firstDay: 0, isRTL: false } }, leapYear: function(r) {
+          var t = this._validate(r, this.minMonth, this.minDay, wC.local.invalidYear), r = t.year() < 0 ? t.year() + 1 : t.year();
+          return r % 4 === 0;
+        }, weekOfYear: function(e, t, r) {
+          var n = this.newDate(e, t, r);
+          return n.add(4 - (n.dayOfWeek() || 7), "d"), Math.floor((n.dayOfYear() - 1) / 7) + 1;
+        }, daysInMonth: function(e, t) {
+          var r = this._validate(e, t, this.minDay, wC.local.invalidMonth);
+          return this.daysPerMonth[r.month() - 1] + (r.month() === 2 && this.leapYear(r.year()) ? 1 : 0);
+        }, weekDay: function(e, t, r) {
+          return (this.dayOfWeek(e, t, r) || 7) < 6;
+        }, toJD: function(e, t, r) {
+          var n = this._validate(e, t, r, wC.local.invalidDate);
+          return e = n.year(), t = n.month(), r = n.day(), e < 0 && e++, t <= 2 && (e--, t += 12), Math.floor(365.25 * (e + 4716)) + Math.floor(30.6001 * (t + 1)) + r - 1524.5;
+        }, fromJD: function(e) {
+          var t = Math.floor(e + 0.5), r = t + 1524, n = Math.floor((r - 122.1) / 365.25), i = Math.floor(365.25 * n), a = Math.floor((r - i) / 30.6001), o = a - Math.floor(a < 14 ? 1 : 13), s = n - Math.floor(o > 2 ? 4716 : 4715), l = r - i - Math.floor(30.6001 * a);
+          return s <= 0 && s--, this.newDate(s, o, l);
+        } });
+        wC.calendars.julian = SQ;
+      });
+      var fet = ye(() => {
+        var fg = kv(), Jtr = Nh();
+        function EQ(e) {
+          this.local = this.regionalOptions[e || ""] || this.regionalOptions[""];
+        }
+        EQ.prototype = new fg.baseCalendar();
+        Jtr(EQ.prototype, { name: "Mayan", jdEpoch: 584282.5, hasYearZero: true, minMonth: 0, firstMonth: 0, minDay: 0, regionalOptions: { "": { name: "Mayan", epochs: ["", ""], monthNames: ["0", "1", "2", "3", "4", "5", "6", "7", "8", "9", "10", "11", "12", "13", "14", "15", "16", "17"], monthNamesShort: ["0", "1", "2", "3", "4", "5", "6", "7", "8", "9", "10", "11", "12", "13", "14", "15", "16", "17"], dayNames: ["0", "1", "2", "3", "4", "5", "6", "7", "8", "9", "10", "11", "12", "13", "14", "15", "16", "17", "18", "19"], dayNamesShort: ["0", "1", "2", "3", "4", "5", "6", "7", "8", "9", "10", "11", "12", "13", "14", "15", "16", "17", "18", "19"], dayNamesMin: ["0", "1", "2", "3", "4", "5", "6", "7", "8", "9", "10", "11", "12", "13", "14", "15", "16", "17", "18", "19"], digits: null, dateFormat: "YYYY.m.d", firstDay: 0, isRTL: false, haabMonths: ["Pop", "Uo", "Zip", "Zotz", "Tzec", "Xul", "Yaxkin", "Mol", "Chen", "Yax", "Zac", "Ceh", "Mac", "Kankin", "Muan", "Pax", "Kayab", "Cumku", "Uayeb"], tzolkinMonths: ["Imix", "Ik", "Akbal", "Kan", "Chicchan", "Cimi", "Manik", "Lamat", "Muluc", "Oc", "Chuen", "Eb", "Ben", "Ix", "Men", "Cib", "Caban", "Etznab", "Cauac", "Ahau"] } }, leapYear: function(e) {
+          return this._validate(e, this.minMonth, this.minDay, fg.local.invalidYear), false;
+        }, formatYear: function(e) {
+          var t = this._validate(e, this.minMonth, this.minDay, fg.local.invalidYear);
+          e = t.year();
+          var r = Math.floor(e / 400);
+          e = e % 400, e += e < 0 ? 400 : 0;
+          var n = Math.floor(e / 20);
+          return r + "." + n + "." + e % 20;
+        }, forYear: function(e) {
+          if (e = e.split("."), e.length < 3) throw "Invalid Mayan year";
+          for (var t = 0, r = 0; r < e.length; r++) {
+            var n = parseInt(e[r], 10);
+            if (Math.abs(n) > 19 || r > 0 && n < 0) throw "Invalid Mayan year";
+            t = t * 20 + n;
+          }
+          return t;
+        }, monthsInYear: function(e) {
+          return this._validate(e, this.minMonth, this.minDay, fg.local.invalidYear), 18;
+        }, weekOfYear: function(e, t, r) {
+          return this._validate(e, t, r, fg.local.invalidDate), 0;
+        }, daysInYear: function(e) {
+          return this._validate(e, this.minMonth, this.minDay, fg.local.invalidYear), 360;
+        }, daysInMonth: function(e, t) {
+          return this._validate(e, t, this.minDay, fg.local.invalidMonth), 20;
+        }, daysInWeek: function() {
+          return 5;
+        }, dayOfWeek: function(e, t, r) {
+          var n = this._validate(e, t, r, fg.local.invalidDate);
+          return n.day();
+        }, weekDay: function(e, t, r) {
+          return this._validate(e, t, r, fg.local.invalidDate), true;
+        }, extraInfo: function(e, t, r) {
+          var n = this._validate(e, t, r, fg.local.invalidDate), i = n.toJD(), a = this._toHaab(i), o = this._toTzolkin(i);
+          return { haabMonthName: this.local.haabMonths[a[0] - 1], haabMonth: a[0], haabDay: a[1], tzolkinDayName: this.local.tzolkinMonths[o[0] - 1], tzolkinDay: o[0], tzolkinTrecena: o[1] };
+        }, _toHaab: function(e) {
+          e -= this.jdEpoch;
+          var t = MQ(e + 8 + 17 * 20, 365);
+          return [Math.floor(t / 20) + 1, MQ(t, 20)];
+        }, _toTzolkin: function(e) {
+          return e -= this.jdEpoch, [cet(e + 20, 20), cet(e + 4, 13)];
+        }, toJD: function(e, t, r) {
+          var n = this._validate(e, t, r, fg.local.invalidDate);
+          return n.day() + n.month() * 20 + n.year() * 360 + this.jdEpoch;
+        }, fromJD: function(e) {
+          e = Math.floor(e) + 0.5 - this.jdEpoch;
+          var t = Math.floor(e / 360);
+          e = e % 360, e += e < 0 ? 360 : 0;
+          var r = Math.floor(e / 20), n = e % 20;
+          return this.newDate(t, r, n);
+        } });
+        function MQ(e, t) {
+          return e - t * Math.floor(e / t);
+        }
+        function cet(e, t) {
+          return MQ(e - 1, t) + 1;
+        }
+        fg.calendars.mayan = EQ;
+      });
+      var det = ye(() => {
+        var Iw = kv(), $tr = Nh();
+        function kQ(e) {
+          this.local = this.regionalOptions[e || ""] || this.regionalOptions[""];
+        }
+        kQ.prototype = new Iw.baseCalendar();
+        var het = Iw.instance("gregorian");
+        $tr(kQ.prototype, { name: "Nanakshahi", jdEpoch: 22576735e-1, daysPerMonth: [31, 31, 31, 31, 31, 30, 30, 30, 30, 30, 30, 30], hasYearZero: false, minMonth: 1, firstMonth: 1, minDay: 1, regionalOptions: { "": { name: "Nanakshahi", epochs: ["BN", "AN"], monthNames: ["Chet", "Vaisakh", "Jeth", "Harh", "Sawan", "Bhadon", "Assu", "Katak", "Maghar", "Poh", "Magh", "Phagun"], monthNamesShort: ["Che", "Vai", "Jet", "Har", "Saw", "Bha", "Ass", "Kat", "Mgr", "Poh", "Mgh", "Pha"], dayNames: ["Somvaar", "Mangalvar", "Budhvaar", "Veervaar", "Shukarvaar", "Sanicharvaar", "Etvaar"], dayNamesShort: ["Som", "Mangal", "Budh", "Veer", "Shukar", "Sanichar", "Et"], dayNamesMin: ["So", "Ma", "Bu", "Ve", "Sh", "Sa", "Et"], digits: null, dateFormat: "dd-mm-yyyy", firstDay: 0, isRTL: false } }, leapYear: function(e) {
+          var t = this._validate(e, this.minMonth, this.minDay, Iw.local.invalidYear || Iw.regionalOptions[""].invalidYear);
+          return het.leapYear(t.year() + (t.year() < 1 ? 1 : 0) + 1469);
+        }, weekOfYear: function(e, t, r) {
+          var n = this.newDate(e, t, r);
+          return n.add(1 - (n.dayOfWeek() || 7), "d"), Math.floor((n.dayOfYear() - 1) / 7) + 1;
+        }, daysInMonth: function(e, t) {
+          var r = this._validate(e, t, this.minDay, Iw.local.invalidMonth);
+          return this.daysPerMonth[r.month() - 1] + (r.month() === 12 && this.leapYear(r.year()) ? 1 : 0);
+        }, weekDay: function(e, t, r) {
+          return (this.dayOfWeek(e, t, r) || 7) < 6;
+        }, toJD: function(i, t, r) {
+          var n = this._validate(i, t, r, Iw.local.invalidMonth), i = n.year();
+          i < 0 && i++;
+          for (var a = n.day(), o = 1; o < n.month(); o++) a += this.daysPerMonth[o - 1];
+          return a + het.toJD(i + 1468, 3, 13);
+        }, fromJD: function(e) {
+          e = Math.floor(e + 0.5);
+          for (var t = Math.floor((e - (this.jdEpoch - 1)) / 366); e >= this.toJD(t + 1, 1, 1); ) t++;
+          for (var r = e - Math.floor(this.toJD(t, 1, 1) + 0.5) + 1, n = 1; r > this.daysInMonth(t, n); ) r -= this.daysInMonth(t, n), n++;
+          return this.newDate(t, n, r);
+        } });
+        Iw.calendars.nanakshahi = kQ;
+      });
+      var vet = ye(() => {
+        var Rw = kv(), Qtr = Nh();
+        function CQ(e) {
+          this.local = this.regionalOptions[e || ""] || this.regionalOptions[""];
+        }
+        CQ.prototype = new Rw.baseCalendar();
+        Qtr(CQ.prototype, { name: "Nepali", jdEpoch: 17007095e-1, daysPerMonth: [31, 31, 32, 32, 31, 30, 30, 29, 30, 29, 30, 30], hasYearZero: false, minMonth: 1, firstMonth: 1, minDay: 1, daysPerYear: 365, regionalOptions: { "": { name: "Nepali", epochs: ["BBS", "ABS"], monthNames: ["Baisakh", "Jestha", "Ashadh", "Shrawan", "Bhadra", "Ashwin", "Kartik", "Mangsir", "Paush", "Mangh", "Falgun", "Chaitra"], monthNamesShort: ["Bai", "Je", "As", "Shra", "Bha", "Ash", "Kar", "Mang", "Pau", "Ma", "Fal", "Chai"], dayNames: ["Aaitabaar", "Sombaar", "Manglbaar", "Budhabaar", "Bihibaar", "Shukrabaar", "Shanibaar"], dayNamesShort: ["Aaita", "Som", "Mangl", "Budha", "Bihi", "Shukra", "Shani"], dayNamesMin: ["Aai", "So", "Man", "Bu", "Bi", "Shu", "Sha"], digits: null, dateFormat: "dd/mm/yyyy", firstDay: 1, isRTL: false } }, leapYear: function(e) {
+          return this.daysInYear(e) !== this.daysPerYear;
+        }, weekOfYear: function(e, t, r) {
+          var n = this.newDate(e, t, r);
+          return n.add(-n.dayOfWeek(), "d"), Math.floor((n.dayOfYear() - 1) / 7) + 1;
+        }, daysInYear: function(e) {
+          var t = this._validate(e, this.minMonth, this.minDay, Rw.local.invalidYear);
+          if (e = t.year(), typeof this.NEPALI_CALENDAR_DATA[e] == "undefined") return this.daysPerYear;
+          for (var r = 0, n = this.minMonth; n <= 12; n++) r += this.NEPALI_CALENDAR_DATA[e][n];
+          return r;
+        }, daysInMonth: function(e, t) {
+          return e.year && (t = e.month(), e = e.year()), this._validate(e, t, this.minDay, Rw.local.invalidMonth), typeof this.NEPALI_CALENDAR_DATA[e] == "undefined" ? this.daysPerMonth[t - 1] : this.NEPALI_CALENDAR_DATA[e][t];
+        }, weekDay: function(e, t, r) {
+          return this.dayOfWeek(e, t, r) !== 6;
+        }, toJD: function(e, t, r) {
+          var n = this._validate(e, t, r, Rw.local.invalidDate);
+          e = n.year(), t = n.month(), r = n.day();
+          var i = Rw.instance(), a = 0, o = t, s = e;
+          this._createMissingCalendarData(e);
+          var l = e - (o > 9 || o === 9 && r >= this.NEPALI_CALENDAR_DATA[s][0] ? 56 : 57);
+          for (t !== 9 && (a = r, o--); o !== 9; ) o <= 0 && (o = 12, s--), a += this.NEPALI_CALENDAR_DATA[s][o], o--;
+          return t === 9 ? (a += r - this.NEPALI_CALENDAR_DATA[s][0], a < 0 && (a += i.daysInYear(l))) : a += this.NEPALI_CALENDAR_DATA[s][9] - this.NEPALI_CALENDAR_DATA[s][0], i.newDate(l, 1, 1).add(a, "d").toJD();
+        }, fromJD: function(e) {
+          var t = Rw.instance(), r = t.fromJD(e), n = r.year(), i = r.dayOfYear(), a = n + 56;
+          this._createMissingCalendarData(a);
+          for (var o = 9, s = this.NEPALI_CALENDAR_DATA[a][0], l = this.NEPALI_CALENDAR_DATA[a][o] - s + 1; i > l; ) o++, o > 12 && (o = 1, a++), l += this.NEPALI_CALENDAR_DATA[a][o];
+          var u = this.NEPALI_CALENDAR_DATA[a][o] - (l - i);
+          return this.newDate(a, o, u);
+        }, _createMissingCalendarData: function(e) {
+          var t = this.daysPerMonth.slice(0);
+          t.unshift(17);
+          for (var r = e - 1; r < e + 2; r++) typeof this.NEPALI_CALENDAR_DATA[r] == "undefined" && (this.NEPALI_CALENDAR_DATA[r] = t);
+        }, NEPALI_CALENDAR_DATA: { 1970: [18, 31, 31, 32, 31, 31, 31, 30, 29, 30, 29, 30, 30], 1971: [18, 31, 31, 32, 31, 32, 30, 30, 29, 30, 29, 30, 30], 1972: [17, 31, 32, 31, 32, 31, 30, 30, 30, 29, 29, 30, 30], 1973: [19, 30, 32, 31, 32, 31, 30, 30, 30, 29, 30, 29, 31], 1974: [19, 31, 31, 32, 30, 31, 31, 30, 29, 30, 29, 30, 30], 1975: [18, 31, 31, 32, 32, 30, 31, 30, 29, 30, 29, 30, 30], 1976: [17, 31, 32, 31, 32, 31, 30, 30, 30, 29, 29, 30, 31], 1977: [18, 31, 32, 31, 32, 31, 31, 29, 30, 29, 30, 29, 31], 1978: [18, 31, 31, 32, 31, 31, 31, 30, 29, 30, 29, 30, 30], 1979: [18, 31, 31, 32, 32, 31, 30, 30, 29, 30, 29, 30, 30], 1980: [17, 31, 32, 31, 32, 31, 30, 30, 30, 29, 29, 30, 31], 1981: [18, 31, 31, 31, 32, 31, 31, 29, 30, 30, 29, 30, 30], 1982: [18, 31, 31, 32, 31, 31, 31, 30, 29, 30, 29, 30, 30], 1983: [18, 31, 31, 32, 32, 31, 30, 30, 29, 30, 29, 30, 30], 1984: [17, 31, 32, 31, 32, 31, 30, 30, 30, 29, 29, 30, 31], 1985: [18, 31, 31, 31, 32, 31, 31, 29, 30, 30, 29, 30, 30], 1986: [18, 31, 31, 32, 31, 31, 31, 30, 29, 30, 29, 30, 30], 1987: [18, 31, 32, 31, 32, 31, 30, 30, 29, 30, 29, 30, 30], 1988: [17, 31, 32, 31, 32, 31, 30, 30, 30, 29, 29, 30, 31], 1989: [18, 31, 31, 31, 32, 31, 31, 30, 29, 30, 29, 30, 30], 1990: [18, 31, 31, 32, 31, 31, 31, 30, 29, 30, 29, 30, 30], 1991: [18, 31, 32, 31, 32, 31, 30, 30, 29, 30, 29, 30, 30], 1992: [17, 31, 32, 31, 32, 31, 30, 30, 30, 29, 30, 29, 31], 1993: [18, 31, 31, 31, 32, 31, 31, 30, 29, 30, 29, 30, 30], 1994: [18, 31, 31, 32, 31, 31, 31, 30, 29, 30, 29, 30, 30], 1995: [17, 31, 32, 31, 32, 31, 30, 30, 30, 29, 29, 30, 30], 1996: [17, 31, 32, 31, 32, 31, 30, 30, 30, 29, 30, 29, 31], 1997: [18, 31, 31, 32, 31, 31, 31, 30, 29, 30, 29, 30, 30], 1998: [18, 31, 31, 32, 31, 31, 31, 30, 29, 30, 29, 30, 30], 1999: [17, 31, 32, 31, 32, 31, 30, 30, 30, 29, 29, 30, 31], 2e3: [17, 30, 32, 31, 32, 31, 30, 30, 30, 29, 30, 29, 31], 2001: [18, 31, 31, 32, 31, 31, 31, 30, 29, 30, 29, 30, 30], 2002: [18, 31, 31, 32, 32, 31, 30, 30, 29, 30, 29, 30, 30], 2003: [17, 31, 32, 31, 32, 31, 30, 30, 30, 29, 29, 30, 31], 2004: [17, 30, 32, 31, 32, 31, 30, 30, 30, 29, 30, 29, 31], 2005: [18, 31, 31, 32, 31, 31, 31, 30, 29, 30, 29, 30, 30], 2006: [18, 31, 31, 32, 32, 31, 30, 30, 29, 30, 29, 30, 30], 2007: [17, 31, 32, 31, 32, 31, 30, 30, 30, 29, 29, 30, 31], 2008: [17, 31, 31, 31, 32, 31, 31, 29, 30, 30, 29, 29, 31], 2009: [18, 31, 31, 32, 31, 31, 31, 30, 29, 30, 29, 30, 30], 2010: [18, 31, 31, 32, 32, 31, 30, 30, 29, 30, 29, 30, 30], 2011: [17, 31, 32, 31, 32, 31, 30, 30, 30, 29, 29, 30, 31], 2012: [17, 31, 31, 31, 32, 31, 31, 29, 30, 30, 29, 30, 30], 2013: [18, 31, 31, 32, 31, 31, 31, 30, 29, 30, 29, 30, 30], 2014: [18, 31, 31, 32, 32, 31, 30, 30, 29, 30, 29, 30, 30], 2015: [17, 31, 32, 31, 32, 31, 30, 30, 30, 29, 29, 30, 31], 2016: [17, 31, 31, 31, 32, 31, 31, 29, 30, 30, 29, 30, 30], 2017: [18, 31, 31, 32, 31, 31, 31, 30, 29, 30, 29, 30, 30], 2018: [18, 31, 32, 31, 32, 31, 30, 30, 29, 30, 29, 30, 30], 2019: [17, 31, 32, 31, 32, 31, 30, 30, 30, 29, 30, 29, 31], 2020: [17, 31, 31, 31, 32, 31, 31, 30, 29, 30, 29, 30, 30], 2021: [18, 31, 31, 32, 31, 31, 31, 30, 29, 30, 29, 30, 30], 2022: [17, 31, 32, 31, 32, 31, 30, 30, 30, 29, 29, 30, 30], 2023: [17, 31, 32, 31, 32, 31, 30, 30, 30, 29, 30, 29, 31], 2024: [17, 31, 31, 31, 32, 31, 31, 30, 29, 30, 29, 30, 30], 2025: [18, 31, 31, 32, 31, 31, 31, 30, 29, 30, 29, 30, 30], 2026: [17, 31, 32, 31, 32, 31, 30, 30, 30, 29, 29, 30, 31], 2027: [17, 30, 32, 31, 32, 31, 30, 30, 30, 29, 30, 29, 31], 2028: [17, 31, 31, 32, 31, 31, 31, 30, 29, 30, 29, 30, 30], 2029: [18, 31, 31, 32, 31, 32, 30, 30, 29, 30, 29, 30, 30], 2030: [17, 31, 32, 31, 32, 31, 30, 30, 30, 30, 30, 30, 31], 2031: [17, 31, 32, 31, 32, 31, 31, 31, 31, 31, 31, 31, 31], 2032: [17, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32], 2033: [18, 31, 31, 32, 32, 31, 30, 30, 29, 30, 29, 30, 30], 2034: [17, 31, 32, 31, 32, 31, 30, 30, 30, 29, 29, 30, 31], 2035: [17, 30, 32, 31, 32, 31, 31, 29, 30, 30, 29, 29, 31], 2036: [17, 31, 31, 32, 31, 31, 31, 30, 29, 30, 29, 30, 30], 2037: [18, 31, 31, 32, 32, 31, 30, 30, 29, 30, 29, 30, 30], 2038: [17, 31, 32, 31, 32, 31, 30, 30, 30, 29, 29, 30, 31], 2039: [17, 31, 31, 31, 32, 31, 31, 29, 30, 30, 29, 30, 30], 2040: [17, 31, 31, 32, 31, 31, 31, 30, 29, 30, 29, 30, 30], 2041: [18, 31, 31, 32, 32, 31, 30, 30, 29, 30, 29, 30, 30], 2042: [17, 31, 32, 31, 32, 31, 30, 30, 30, 29, 29, 30, 31], 2043: [17, 31, 31, 31, 32, 31, 31, 29, 30, 30, 29, 30, 30], 2044: [17, 31, 31, 32, 31, 31, 31, 30, 29, 30, 29, 30, 30], 2045: [18, 31, 32, 31, 32, 31, 30, 30, 29, 30, 29, 30, 30], 2046: [17, 31, 32, 31, 32, 31, 30, 30, 30, 29, 29, 30, 31], 2047: [17, 31, 31, 31, 32, 31, 31, 30, 29, 30, 29, 30, 30], 2048: [17, 31, 31, 32, 31, 31, 31, 30, 29, 30, 29, 30, 30], 2049: [17, 31, 32, 31, 32, 31, 30, 30, 30, 29, 29, 30, 30], 2050: [17, 31, 32, 31, 32, 31, 30, 30, 30, 29, 30, 29, 31], 2051: [17, 31, 31, 31, 32, 31, 31, 30, 29, 30, 29, 30, 30], 2052: [17, 31, 31, 32, 31, 31, 31, 30, 29, 30, 29, 30, 30], 2053: [17, 31, 32, 31, 32, 31, 30, 30, 30, 29, 29, 30, 30], 2054: [17, 31, 32, 31, 32, 31, 30, 30, 30, 29, 30, 29, 31], 2055: [17, 31, 31, 32, 31, 31, 31, 30, 29, 30, 30, 29, 30], 2056: [17, 31, 31, 32, 31, 32, 30, 30, 29, 30, 29, 30, 30], 2057: [17, 31, 32, 31, 32, 31, 30, 30, 30, 29, 29, 30, 31], 2058: [17, 30, 32, 31, 32, 31, 30, 30, 30, 29, 30, 29, 31], 2059: [17, 31, 31, 32, 31, 31, 31, 30, 29, 30, 29, 30, 30], 2060: [17, 31, 31, 32, 32, 31, 30, 30, 29, 30, 29, 30, 30], 2061: [17, 31, 32, 31, 32, 31, 30, 30, 30, 29, 29, 30, 31], 2062: [17, 30, 32, 31, 32, 31, 31, 29, 30, 29, 30, 29, 31], 2063: [17, 31, 31, 32, 31, 31, 31, 30, 29, 30, 29, 30, 30], 2064: [17, 31, 31, 32, 32, 31, 30, 30, 29, 30, 29, 30, 30], 2065: [17, 31, 32, 31, 32, 31, 30, 30, 30, 29, 29, 30, 31], 2066: [17, 31, 31, 31, 32, 31, 31, 29, 30, 30, 29, 29, 31], 2067: [17, 31, 31, 32, 31, 31, 31, 30, 29, 30, 29, 30, 30], 2068: [17, 31, 31, 32, 32, 31, 30, 30, 29, 30, 29, 30, 30], 2069: [17, 31, 32, 31, 32, 31, 30, 30, 30, 29, 29, 30, 31], 2070: [17, 31, 31, 31, 32, 31, 31, 29, 30, 30, 29, 30, 30], 2071: [17, 31, 31, 32, 31, 31, 31, 30, 29, 30, 29, 30, 30], 2072: [17, 31, 32, 31, 32, 31, 30, 30, 29, 30, 29, 30, 30], 2073: [17, 31, 32, 31, 32, 31, 30, 30, 30, 29, 29, 30, 31], 2074: [17, 31, 31, 31, 32, 31, 31, 30, 29, 30, 29, 30, 30], 2075: [17, 31, 31, 32, 31, 31, 31, 30, 29, 30, 29, 30, 30], 2076: [16, 31, 32, 31, 32, 31, 30, 30, 30, 29, 29, 30, 30], 2077: [17, 31, 32, 31, 32, 31, 30, 30, 30, 29, 30, 29, 31], 2078: [17, 31, 31, 31, 32, 31, 31, 30, 29, 30, 29, 30, 30], 2079: [17, 31, 31, 32, 31, 31, 31, 30, 29, 30, 29, 30, 30], 2080: [16, 31, 32, 31, 32, 31, 30, 30, 30, 29, 29, 30, 30], 2081: [17, 31, 31, 32, 32, 31, 30, 30, 30, 29, 30, 30, 30], 2082: [17, 31, 32, 31, 32, 31, 30, 30, 30, 29, 30, 30, 30], 2083: [17, 31, 31, 32, 31, 31, 30, 30, 30, 29, 30, 30, 30], 2084: [17, 31, 31, 32, 31, 31, 30, 30, 30, 29, 30, 30, 30], 2085: [17, 31, 32, 31, 32, 31, 31, 30, 30, 29, 30, 30, 30], 2086: [17, 31, 32, 31, 32, 31, 30, 30, 30, 29, 30, 30, 30], 2087: [16, 31, 31, 32, 31, 31, 31, 30, 30, 29, 30, 30, 30], 2088: [16, 30, 31, 32, 32, 30, 31, 30, 30, 29, 30, 30, 30], 2089: [17, 31, 32, 31, 32, 31, 30, 30, 30, 29, 30, 30, 30], 2090: [17, 31, 32, 31, 32, 31, 30, 30, 30, 29, 30, 30, 30], 2091: [16, 31, 31, 32, 31, 31, 31, 30, 30, 29, 30, 30, 30], 2092: [16, 31, 31, 32, 32, 31, 30, 30, 30, 29, 30, 30, 30], 2093: [17, 31, 32, 31, 32, 31, 30, 30, 30, 29, 30, 30, 30], 2094: [17, 31, 31, 32, 31, 31, 30, 30, 30, 29, 30, 30, 30], 2095: [17, 31, 31, 32, 31, 31, 31, 30, 29, 30, 30, 30, 30], 2096: [17, 30, 31, 32, 32, 31, 30, 30, 29, 30, 29, 30, 30], 2097: [17, 31, 32, 31, 32, 31, 30, 30, 30, 29, 30, 30, 30], 2098: [17, 31, 31, 32, 31, 31, 31, 29, 30, 29, 30, 30, 31], 2099: [17, 31, 31, 32, 31, 31, 31, 30, 29, 29, 30, 30, 30], 2100: [17, 31, 32, 31, 32, 30, 31, 30, 29, 30, 29, 30, 30] } });
+        Rw.calendars.nepali = CQ;
+      });
+      var pet = ye(() => {
+        var oS = kv(), err = Nh();
+        function q9(e) {
+          this.local = this.regionalOptions[e || ""] || this.regionalOptions[""];
+        }
+        function O9(e) {
+          var t = e - 475;
+          e < 0 && t++;
+          var r = 0.242197, n = r * t, i = r * (t + 1), a = n - Math.floor(n), o = i - Math.floor(i);
+          return a > o;
+        }
+        q9.prototype = new oS.baseCalendar();
+        err(q9.prototype, { name: "Persian", jdEpoch: 19483205e-1, daysPerMonth: [31, 31, 31, 31, 31, 31, 30, 30, 30, 30, 30, 29], hasYearZero: false, minMonth: 1, firstMonth: 1, minDay: 1, regionalOptions: { "": { name: "Persian", epochs: ["BP", "AP"], monthNames: ["Farvardin", "Ordibehesht", "Khordad", "Tir", "Mordad", "Shahrivar", "Mehr", "Aban", "Azar", "Dey", "Bahman", "Esfand"], monthNamesShort: ["Far", "Ord", "Kho", "Tir", "Mor", "Sha", "Meh", "Aba", "Aza", "Dey", "Bah", "Esf"], dayNames: ["Yekshanbeh", "Doshanbeh", "Seshanbeh", "Chahārshanbeh", "Panjshanbeh", "Jom'eh", "Shanbeh"], dayNamesShort: ["Yek", "Do", "Se", "Cha", "Panj", "Jom", "Sha"], dayNamesMin: ["Ye", "Do", "Se", "Ch", "Pa", "Jo", "Sh"], digits: null, dateFormat: "yyyy/mm/dd", firstDay: 6, isRTL: false } }, leapYear: function(e) {
+          var t = this._validate(e, this.minMonth, this.minDay, oS.local.invalidYear);
+          return O9(t.year());
+        }, weekOfYear: function(e, t, r) {
+          var n = this.newDate(e, t, r);
+          return n.add(-((n.dayOfWeek() + 1) % 7), "d"), Math.floor((n.dayOfYear() - 1) / 7) + 1;
+        }, daysInMonth: function(e, t) {
+          var r = this._validate(e, t, this.minDay, oS.local.invalidMonth);
+          return this.daysPerMonth[r.month() - 1] + (r.month() === 12 && this.leapYear(r.year()) ? 1 : 0);
+        }, weekDay: function(e, t, r) {
+          return this.dayOfWeek(e, t, r) !== 5;
+        }, toJD: function(e, t, r) {
+          var n = this._validate(e, t, r, oS.local.invalidDate);
+          e = n.year(), t = n.month(), r = n.day();
+          var i = 0;
+          if (e > 0) for (var a = 1; a < e; a++) O9(a) && i++;
+          else if (e < 0) for (var a = e; a < 0; a++) O9(a) && i--;
+          return r + (t <= 7 ? (t - 1) * 31 : (t - 1) * 30 + 6) + (e > 0 ? e - 1 : e) * 365 + i + this.jdEpoch - 1;
+        }, fromJD: function(e) {
+          e = Math.floor(e) + 0.5;
+          var t = 475 + (e - this.toJD(475, 1, 1)) / 365.242197, r = Math.floor(t);
+          r <= 0 && r--, e > this.toJD(r, 12, O9(r) ? 30 : 29) && (r++, r === 0 && r++);
+          var n = e - this.toJD(r, 1, 1) + 1, i = n <= 186 ? Math.ceil(n / 31) : Math.ceil((n - 6) / 30), a = e - this.toJD(r, i, 1) + 1;
+          return this.newDate(r, i, a);
+        } });
+        oS.calendars.persian = q9;
+        oS.calendars.jalali = q9;
+      });
+      var get = ye(() => {
+        var Dw = kv(), trr = Nh(), B9 = Dw.instance();
+        function LQ(e) {
+          this.local = this.regionalOptions[e || ""] || this.regionalOptions[""];
+        }
+        LQ.prototype = new Dw.baseCalendar();
+        trr(LQ.prototype, { name: "Taiwan", jdEpoch: 24194025e-1, yearsOffset: 1911, daysPerMonth: [31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31], hasYearZero: false, minMonth: 1, firstMonth: 1, minDay: 1, regionalOptions: { "": { name: "Taiwan", epochs: ["BROC", "ROC"], monthNames: ["January", "February", "March", "April", "May", "June", "July", "August", "September", "October", "November", "December"], monthNamesShort: ["Jan", "Feb", "Mar", "Apr", "May", "Jun", "Jul", "Aug", "Sep", "Oct", "Nov", "Dec"], dayNames: ["Sunday", "Monday", "Tuesday", "Wednesday", "Thursday", "Friday", "Saturday"], dayNamesShort: ["Sun", "Mon", "Tue", "Wed", "Thu", "Fri", "Sat"], dayNamesMin: ["Su", "Mo", "Tu", "We", "Th", "Fr", "Sa"], digits: null, dateFormat: "yyyy/mm/dd", firstDay: 1, isRTL: false } }, leapYear: function(r) {
+          var t = this._validate(r, this.minMonth, this.minDay, Dw.local.invalidYear), r = this._t2gYear(t.year());
+          return B9.leapYear(r);
+        }, weekOfYear: function(i, t, r) {
+          var n = this._validate(i, this.minMonth, this.minDay, Dw.local.invalidYear), i = this._t2gYear(n.year());
+          return B9.weekOfYear(i, n.month(), n.day());
+        }, daysInMonth: function(e, t) {
+          var r = this._validate(e, t, this.minDay, Dw.local.invalidMonth);
+          return this.daysPerMonth[r.month() - 1] + (r.month() === 2 && this.leapYear(r.year()) ? 1 : 0);
+        }, weekDay: function(e, t, r) {
+          return (this.dayOfWeek(e, t, r) || 7) < 6;
+        }, toJD: function(i, t, r) {
+          var n = this._validate(i, t, r, Dw.local.invalidDate), i = this._t2gYear(n.year());
+          return B9.toJD(i, n.month(), n.day());
+        }, fromJD: function(e) {
+          var t = B9.fromJD(e), r = this._g2tYear(t.year());
+          return this.newDate(r, t.month(), t.day());
+        }, _t2gYear: function(e) {
+          return e + this.yearsOffset + (e >= -this.yearsOffset && e <= -1 ? 1 : 0);
+        }, _g2tYear: function(e) {
+          return e - this.yearsOffset - (e >= 1 && e <= this.yearsOffset ? 1 : 0);
+        } });
+        Dw.calendars.taiwan = LQ;
+      });
+      var met = ye(() => {
+        var Fw = kv(), rrr = Nh(), N9 = Fw.instance();
+        function PQ(e) {
+          this.local = this.regionalOptions[e || ""] || this.regionalOptions[""];
+        }
+        PQ.prototype = new Fw.baseCalendar();
+        rrr(PQ.prototype, { name: "Thai", jdEpoch: 15230985e-1, yearsOffset: 543, daysPerMonth: [31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31], hasYearZero: false, minMonth: 1, firstMonth: 1, minDay: 1, regionalOptions: { "": { name: "Thai", epochs: ["BBE", "BE"], monthNames: ["January", "February", "March", "April", "May", "June", "July", "August", "September", "October", "November", "December"], monthNamesShort: ["Jan", "Feb", "Mar", "Apr", "May", "Jun", "Jul", "Aug", "Sep", "Oct", "Nov", "Dec"], dayNames: ["Sunday", "Monday", "Tuesday", "Wednesday", "Thursday", "Friday", "Saturday"], dayNamesShort: ["Sun", "Mon", "Tue", "Wed", "Thu", "Fri", "Sat"], dayNamesMin: ["Su", "Mo", "Tu", "We", "Th", "Fr", "Sa"], digits: null, dateFormat: "dd/mm/yyyy", firstDay: 0, isRTL: false } }, leapYear: function(r) {
+          var t = this._validate(r, this.minMonth, this.minDay, Fw.local.invalidYear), r = this._t2gYear(t.year());
+          return N9.leapYear(r);
+        }, weekOfYear: function(i, t, r) {
+          var n = this._validate(i, this.minMonth, this.minDay, Fw.local.invalidYear), i = this._t2gYear(n.year());
+          return N9.weekOfYear(i, n.month(), n.day());
+        }, daysInMonth: function(e, t) {
+          var r = this._validate(e, t, this.minDay, Fw.local.invalidMonth);
+          return this.daysPerMonth[r.month() - 1] + (r.month() === 2 && this.leapYear(r.year()) ? 1 : 0);
+        }, weekDay: function(e, t, r) {
+          return (this.dayOfWeek(e, t, r) || 7) < 6;
+        }, toJD: function(i, t, r) {
+          var n = this._validate(i, t, r, Fw.local.invalidDate), i = this._t2gYear(n.year());
+          return N9.toJD(i, n.month(), n.day());
+        }, fromJD: function(e) {
+          var t = N9.fromJD(e), r = this._g2tYear(t.year());
+          return this.newDate(r, t.month(), t.day());
+        }, _t2gYear: function(e) {
+          return e - this.yearsOffset - (e >= 1 && e <= this.yearsOffset ? 1 : 0);
+        }, _g2tYear: function(e) {
+          return e + this.yearsOffset + (e >= -this.yearsOffset && e <= -1 ? 1 : 0);
+        } });
+        Fw.calendars.thai = PQ;
+      });
+      var yet = ye(() => {
+        var zw = kv(), irr = Nh();
+        function IQ(e) {
+          this.local = this.regionalOptions[e || ""] || this.regionalOptions[""];
+        }
+        IQ.prototype = new zw.baseCalendar();
+        irr(IQ.prototype, { name: "UmmAlQura", hasYearZero: false, minMonth: 1, firstMonth: 1, minDay: 1, regionalOptions: { "": { name: "Umm al-Qura", epochs: ["BH", "AH"], monthNames: ["Al-Muharram", "Safar", "Rabi' al-awwal", "Rabi' Al-Thani", "Jumada Al-Awwal", "Jumada Al-Thani", "Rajab", "Sha'aban", "Ramadan", "Shawwal", "Dhu al-Qi'dah", "Dhu al-Hijjah"], monthNamesShort: ["Muh", "Saf", "Rab1", "Rab2", "Jum1", "Jum2", "Raj", "Sha'", "Ram", "Shaw", "DhuQ", "DhuH"], dayNames: ["Yawm al-Ahad", "Yawm al-Ithnain", "Yawm al-Thalāthā’", "Yawm al-Arba‘ā’", "Yawm al-Khamīs", "Yawm al-Jum‘a", "Yawm al-Sabt"], dayNamesMin: ["Ah", "Ith", "Th", "Ar", "Kh", "Ju", "Sa"], digits: null, dateFormat: "yyyy/mm/dd", firstDay: 6, isRTL: true } }, leapYear: function(e) {
+          var t = this._validate(e, this.minMonth, this.minDay, zw.local.invalidYear);
+          return this.daysInYear(t.year()) === 355;
+        }, weekOfYear: function(e, t, r) {
+          var n = this.newDate(e, t, r);
+          return n.add(-n.dayOfWeek(), "d"), Math.floor((n.dayOfYear() - 1) / 7) + 1;
+        }, daysInYear: function(e) {
+          for (var t = 0, r = 1; r <= 12; r++) t += this.daysInMonth(e, r);
+          return t;
+        }, daysInMonth: function(e, t) {
+          for (var r = this._validate(e, t, this.minDay, zw.local.invalidMonth), n = r.toJD() - 24e5 + 0.5, i = 0, a = 0; a < Zx.length; a++) {
+            if (Zx[a] > n) return Zx[i] - Zx[i - 1];
+            i++;
+          }
+          return 30;
+        }, weekDay: function(e, t, r) {
+          return this.dayOfWeek(e, t, r) !== 5;
+        }, toJD: function(e, t, r) {
+          var n = this._validate(e, t, r, zw.local.invalidDate), i = 12 * (n.year() - 1) + n.month() - 15292, a = n.day() + Zx[i - 1] - 1;
+          return a + 24e5 - 0.5;
+        }, fromJD: function(e) {
+          for (var t = e - 24e5 + 0.5, r = 0, n = 0; n < Zx.length && !(Zx[n] > t); n++) r++;
+          var i = r + 15292, a = Math.floor((i - 1) / 12), o = a + 1, s = i - 12 * a, l = t - Zx[r - 1] + 1;
+          return this.newDate(o, s, l);
+        }, isValid: function(e, t, r) {
+          var n = zw.baseCalendar.prototype.isValid.apply(this, arguments);
+          return n && (e = e.year != null ? e.year : e, n = e >= 1276 && e <= 1500), n;
+        }, _validate: function(e, t, r, n) {
+          var i = zw.baseCalendar.prototype._validate.apply(this, arguments);
+          if (i.year < 1276 || i.year > 1500) throw n.replace(/\{0\}/, this.local.name);
+          return i;
+        } });
+        zw.calendars.ummalqura = IQ;
+        var Zx = [20, 50, 79, 109, 138, 168, 197, 227, 256, 286, 315, 345, 374, 404, 433, 463, 492, 522, 551, 581, 611, 641, 670, 700, 729, 759, 788, 818, 847, 877, 906, 936, 965, 995, 1024, 1054, 1083, 1113, 1142, 1172, 1201, 1231, 1260, 1290, 1320, 1350, 1379, 1409, 1438, 1468, 1497, 1527, 1556, 1586, 1615, 1645, 1674, 1704, 1733, 1763, 1792, 1822, 1851, 1881, 1910, 1940, 1969, 1999, 2028, 2058, 2087, 2117, 2146, 2176, 2205, 2235, 2264, 2294, 2323, 2353, 2383, 2413, 2442, 2472, 2501, 2531, 2560, 2590, 2619, 2649, 2678, 2708, 2737, 2767, 2796, 2826, 2855, 2885, 2914, 2944, 2973, 3003, 3032, 3062, 3091, 3121, 3150, 3180, 3209, 3239, 3268, 3298, 3327, 3357, 3386, 3416, 3446, 3476, 3505, 3535, 3564, 3594, 3623, 3653, 3682, 3712, 3741, 3771, 3800, 3830, 3859, 3889, 3918, 3948, 3977, 4007, 4036, 4066, 4095, 4125, 4155, 4185, 4214, 4244, 4273, 4303, 4332, 4362, 4391, 4421, 4450, 4480, 4509, 4539, 4568, 4598, 4627, 4657, 4686, 4716, 4745, 4775, 4804, 4834, 4863, 4893, 4922, 4952, 4981, 5011, 5040, 5070, 5099, 5129, 5158, 5188, 5218, 5248, 5277, 5307, 5336, 5366, 5395, 5425, 5454, 5484, 5513, 5543, 5572, 5602, 5631, 5661, 5690, 5720, 5749, 5779, 5808, 5838, 5867, 5897, 5926, 5956, 5985, 6015, 6044, 6074, 6103, 6133, 6162, 6192, 6221, 6251, 6281, 6311, 6340, 6370, 6399, 6429, 6458, 6488, 6517, 6547, 6576, 6606, 6635, 6665, 6694, 6724, 6753, 6783, 6812, 6842, 6871, 6901, 6930, 6960, 6989, 7019, 7048, 7078, 7107, 7137, 7166, 7196, 7225, 7255, 7284, 7314, 7344, 7374, 7403, 7433, 7462, 7492, 7521, 7551, 7580, 7610, 7639, 7669, 7698, 7728, 7757, 7787, 7816, 7846, 7875, 7905, 7934, 7964, 7993, 8023, 8053, 8083, 8112, 8142, 8171, 8201, 8230, 8260, 8289, 8319, 8348, 8378, 8407, 8437, 8466, 8496, 8525, 8555, 8584, 8614, 8643, 8673, 8702, 8732, 8761, 8791, 8821, 8850, 8880, 8909, 8938, 8968, 8997, 9027, 9056, 9086, 9115, 9145, 9175, 9205, 9234, 9264, 9293, 9322, 9352, 9381, 9410, 9440, 9470, 9499, 9529, 9559, 9589, 9618, 9648, 9677, 9706, 9736, 9765, 9794, 9824, 9853, 9883, 9913, 9943, 9972, 10002, 10032, 10061, 10090, 10120, 10149, 10178, 10208, 10237, 10267, 10297, 10326, 10356, 10386, 10415, 10445, 10474, 10504, 10533, 10562, 10592, 10621, 10651, 10680, 10710, 10740, 10770, 10799, 10829, 10858, 10888, 10917, 10947, 10976, 11005, 11035, 11064, 11094, 11124, 11153, 11183, 11213, 11242, 11272, 11301, 11331, 11360, 11389, 11419, 11448, 11478, 11507, 11537, 11567, 11596, 11626, 11655, 11685, 11715, 11744, 11774, 11803, 11832, 11862, 11891, 11921, 11950, 11980, 12010, 12039, 12069, 12099, 12128, 12158, 12187, 12216, 12246, 12275, 12304, 12334, 12364, 12393, 12423, 12453, 12483, 12512, 12542, 12571, 12600, 12630, 12659, 12688, 12718, 12747, 12777, 12807, 12837, 12866, 12896, 12926, 12955, 12984, 13014, 13043, 13072, 13102, 13131, 13161, 13191, 13220, 13250, 13280, 13310, 13339, 13368, 13398, 13427, 13456, 13486, 13515, 13545, 13574, 13604, 13634, 13664, 13693, 13723, 13752, 13782, 13811, 13840, 13870, 13899, 13929, 13958, 13988, 14018, 14047, 14077, 14107, 14136, 14166, 14195, 14224, 14254, 14283, 14313, 14342, 14372, 14401, 14431, 14461, 14490, 14520, 14550, 14579, 14609, 14638, 14667, 14697, 14726, 14756, 14785, 14815, 14844, 14874, 14904, 14933, 14963, 14993, 15021, 15051, 15081, 15110, 15140, 15169, 15199, 15228, 15258, 15287, 15317, 15347, 15377, 15406, 15436, 15465, 15494, 15524, 15553, 15582, 15612, 15641, 15671, 15701, 15731, 15760, 15790, 15820, 15849, 15878, 15908, 15937, 15966, 15996, 16025, 16055, 16085, 16114, 16144, 16174, 16204, 16233, 16262, 16292, 16321, 16350, 16380, 16409, 16439, 16468, 16498, 16528, 16558, 16587, 16617, 16646, 16676, 16705, 16734, 16764, 16793, 16823, 16852, 16882, 16912, 16941, 16971, 17001, 17030, 17060, 17089, 17118, 17148, 17177, 17207, 17236, 17266, 17295, 17325, 17355, 17384, 17414, 17444, 17473, 17502, 17532, 17561, 17591, 17620, 17650, 17679, 17709, 17738, 17768, 17798, 17827, 17857, 17886, 17916, 17945, 17975, 18004, 18034, 18063, 18093, 18122, 18152, 18181, 18211, 18241, 18270, 18300, 18330, 18359, 18388, 18418, 18447, 18476, 18506, 18535, 18565, 18595, 18625, 18654, 18684, 18714, 18743, 18772, 18802, 18831, 18860, 18890, 18919, 18949, 18979, 19008, 19038, 19068, 19098, 19127, 19156, 19186, 19215, 19244, 19274, 19303, 19333, 19362, 19392, 19422, 19452, 19481, 19511, 19540, 19570, 19599, 19628, 19658, 19687, 19717, 19746, 19776, 19806, 19836, 19865, 19895, 19924, 19954, 19983, 20012, 20042, 20071, 20101, 20130, 20160, 20190, 20219, 20249, 20279, 20308, 20338, 20367, 20396, 20426, 20455, 20485, 20514, 20544, 20573, 20603, 20633, 20662, 20692, 20721, 20751, 20780, 20810, 20839, 20869, 20898, 20928, 20957, 20987, 21016, 21046, 21076, 21105, 21135, 21164, 21194, 21223, 21253, 21282, 21312, 21341, 21371, 21400, 21430, 21459, 21489, 21519, 21548, 21578, 21607, 21637, 21666, 21696, 21725, 21754, 21784, 21813, 21843, 21873, 21902, 21932, 21962, 21991, 22021, 22050, 22080, 22109, 22138, 22168, 22197, 22227, 22256, 22286, 22316, 22346, 22375, 22405, 22434, 22464, 22493, 22522, 22552, 22581, 22611, 22640, 22670, 22700, 22730, 22759, 22789, 22818, 22848, 22877, 22906, 22936, 22965, 22994, 23024, 23054, 23083, 23113, 23143, 23173, 23202, 23232, 23261, 23290, 23320, 23349, 23379, 23408, 23438, 23467, 23497, 23527, 23556, 23586, 23616, 23645, 23674, 23704, 23733, 23763, 23792, 23822, 23851, 23881, 23910, 23940, 23970, 23999, 24029, 24058, 24088, 24117, 24147, 24176, 24206, 24235, 24265, 24294, 24324, 24353, 24383, 24413, 24442, 24472, 24501, 24531, 24560, 24590, 24619, 24648, 24678, 24707, 24737, 24767, 24796, 24826, 24856, 24885, 24915, 24944, 24974, 25003, 25032, 25062, 25091, 25121, 25150, 25180, 25210, 25240, 25269, 25299, 25328, 25358, 25387, 25416, 25446, 25475, 25505, 25534, 25564, 25594, 25624, 25653, 25683, 25712, 25742, 25771, 25800, 25830, 25859, 25888, 25918, 25948, 25977, 26007, 26037, 26067, 26096, 26126, 26155, 26184, 26214, 26243, 26272, 26302, 26332, 26361, 26391, 26421, 26451, 26480, 26510, 26539, 26568, 26598, 26627, 26656, 26686, 26715, 26745, 26775, 26805, 26834, 26864, 26893, 26923, 26952, 26982, 27011, 27041, 27070, 27099, 27129, 27159, 27188, 27218, 27248, 27277, 27307, 27336, 27366, 27395, 27425, 27454, 27484, 27513, 27542, 27572, 27602, 27631, 27661, 27691, 27720, 27750, 27779, 27809, 27838, 27868, 27897, 27926, 27956, 27985, 28015, 28045, 28074, 28104, 28134, 28163, 28193, 28222, 28252, 28281, 28310, 28340, 28369, 28399, 28428, 28458, 28488, 28517, 28547, 28577, 28607, 28636, 28665, 28695, 28724, 28754, 28783, 28813, 28843, 28872, 28901, 28931, 28960, 28990, 29019, 29049, 29078, 29108, 29137, 29167, 29196, 29226, 29255, 29285, 29315, 29345, 29375, 29404, 29434, 29463, 29492, 29522, 29551, 29580, 29610, 29640, 29669, 29699, 29729, 29759, 29788, 29818, 29847, 29876, 29906, 29935, 29964, 29994, 30023, 30053, 30082, 30112, 30141, 30171, 30200, 30230, 30259, 30289, 30318, 30348, 30378, 30408, 30437, 30467, 30496, 30526, 30555, 30585, 30614, 30644, 30673, 30703, 30732, 30762, 30791, 30821, 30850, 30880, 30909, 30939, 30968, 30998, 31027, 31057, 31086, 31116, 31145, 31175, 31204, 31234, 31263, 31293, 31322, 31352, 31381, 31411, 31441, 31471, 31500, 31530, 31559, 31589, 31618, 31648, 31676, 31706, 31736, 31766, 31795, 31825, 31854, 31884, 31913, 31943, 31972, 32002, 32031, 32061, 32090, 32120, 32150, 32180, 32209, 32239, 32268, 32298, 32327, 32357, 32386, 32416, 32445, 32475, 32504, 32534, 32563, 32593, 32622, 32652, 32681, 32711, 32740, 32770, 32799, 32829, 32858, 32888, 32917, 32947, 32976, 33006, 33035, 33065, 33094, 33124, 33153, 33183, 33213, 33243, 33272, 33302, 33331, 33361, 33390, 33420, 33450, 33479, 33509, 33539, 33568, 33598, 33627, 33657, 33686, 33716, 33745, 33775, 33804, 33834, 33863, 33893, 33922, 33952, 33981, 34011, 34040, 34069, 34099, 34128, 34158, 34187, 34217, 34247, 34277, 34306, 34336, 34365, 34395, 34424, 34454, 34483, 34512, 34542, 34571, 34601, 34631, 34660, 34690, 34719, 34749, 34778, 34808, 34837, 34867, 34896, 34926, 34955, 34985, 35015, 35044, 35074, 35103, 35133, 35162, 35192, 35222, 35251, 35280, 35310, 35340, 35370, 35399, 35429, 35458, 35488, 35517, 35547, 35576, 35605, 35635, 35665, 35694, 35723, 35753, 35782, 35811, 35841, 35871, 35901, 35930, 35960, 35989, 36019, 36048, 36078, 36107, 36136, 36166, 36195, 36225, 36254, 36284, 36314, 36343, 36373, 36403, 36433, 36462, 36492, 36521, 36551, 36580, 36610, 36639, 36669, 36698, 36728, 36757, 36786, 36816, 36845, 36875, 36904, 36934, 36963, 36993, 37022, 37052, 37081, 37111, 37141, 37170, 37200, 37229, 37259, 37288, 37318, 37347, 37377, 37406, 37436, 37465, 37495, 37524, 37554, 37584, 37613, 37643, 37672, 37701, 37731, 37760, 37790, 37819, 37849, 37878, 37908, 37938, 37967, 37997, 38027, 38056, 38085, 38115, 38144, 38174, 38203, 38233, 38262, 38292, 38322, 38351, 38381, 38410, 38440, 38469, 38499, 38528, 38558, 38587, 38617, 38646, 38676, 38705, 38735, 38764, 38794, 38823, 38853, 38882, 38912, 38941, 38971, 39001, 39030, 39059, 39089, 39118, 39148, 39178, 39208, 39237, 39267, 39297, 39326, 39355, 39385, 39414, 39444, 39473, 39503, 39532, 39562, 39592, 39621, 39650, 39680, 39709, 39739, 39768, 39798, 39827, 39857, 39886, 39916, 39946, 39975, 40005, 40035, 40064, 40094, 40123, 40153, 40182, 40212, 40241, 40271, 40300, 40330, 40359, 40389, 40418, 40448, 40477, 40507, 40536, 40566, 40595, 40625, 40655, 40685, 40714, 40744, 40773, 40803, 40832, 40862, 40892, 40921, 40951, 40980, 41009, 41039, 41068, 41098, 41127, 41157, 41186, 41216, 41245, 41275, 41304, 41334, 41364, 41393, 41422, 41452, 41481, 41511, 41540, 41570, 41599, 41629, 41658, 41688, 41718, 41748, 41777, 41807, 41836, 41865, 41894, 41924, 41953, 41983, 42012, 42042, 42072, 42102, 42131, 42161, 42190, 42220, 42249, 42279, 42308, 42337, 42367, 42397, 42426, 42456, 42485, 42515, 42545, 42574, 42604, 42633, 42662, 42692, 42721, 42751, 42780, 42810, 42839, 42869, 42899, 42929, 42958, 42988, 43017, 43046, 43076, 43105, 43135, 43164, 43194, 43223, 43253, 43283, 43312, 43342, 43371, 43401, 43430, 43460, 43489, 43519, 43548, 43578, 43607, 43637, 43666, 43696, 43726, 43755, 43785, 43814, 43844, 43873, 43903, 43932, 43962, 43991, 44021, 44050, 44080, 44109, 44139, 44169, 44198, 44228, 44258, 44287, 44317, 44346, 44375, 44405, 44434, 44464, 44493, 44523, 44553, 44582, 44612, 44641, 44671, 44700, 44730, 44759, 44788, 44818, 44847, 44877, 44906, 44936, 44966, 44996, 45025, 45055, 45084, 45114, 45143, 45172, 45202, 45231, 45261, 45290, 45320, 45350, 45380, 45409, 45439, 45468, 45498, 45527, 45556, 45586, 45615, 45644, 45674, 45704, 45733, 45763, 45793, 45823, 45852, 45882, 45911, 45940, 45970, 45999, 46028, 46058, 46088, 46117, 46147, 46177, 46206, 46236, 46265, 46295, 46324, 46354, 46383, 46413, 46442, 46472, 46501, 46531, 46560, 46590, 46620, 46649, 46679, 46708, 46738, 46767, 46797, 46826, 46856, 46885, 46915, 46944, 46974, 47003, 47033, 47063, 47092, 47122, 47151, 47181, 47210, 47240, 47269, 47298, 47328, 47357, 47387, 47417, 47446, 47476, 47506, 47535, 47565, 47594, 47624, 47653, 47682, 47712, 47741, 47771, 47800, 47830, 47860, 47890, 47919, 47949, 47978, 48008, 48037, 48066, 48096, 48125, 48155, 48184, 48214, 48244, 48273, 48303, 48333, 48362, 48392, 48421, 48450, 48480, 48509, 48538, 48568, 48598, 48627, 48657, 48687, 48717, 48746, 48776, 48805, 48834, 48864, 48893, 48922, 48952, 48982, 49011, 49041, 49071, 49100, 49130, 49160, 49189, 49218, 49248, 49277, 49306, 49336, 49365, 49395, 49425, 49455, 49484, 49514, 49543, 49573, 49602, 49632, 49661, 49690, 49720, 49749, 49779, 49809, 49838, 49868, 49898, 49927, 49957, 49986, 50016, 50045, 50075, 50104, 50133, 50163, 50192, 50222, 50252, 50281, 50311, 50340, 50370, 50400, 50429, 50459, 50488, 50518, 50547, 50576, 50606, 50635, 50665, 50694, 50724, 50754, 50784, 50813, 50843, 50872, 50902, 50931, 50960, 50990, 51019, 51049, 51078, 51108, 51138, 51167, 51197, 51227, 51256, 51286, 51315, 51345, 51374, 51403, 51433, 51462, 51492, 51522, 51552, 51582, 51611, 51641, 51670, 51699, 51729, 51758, 51787, 51816, 51846, 51876, 51906, 51936, 51965, 51995, 52025, 52054, 52083, 52113, 52142, 52171, 52200, 52230, 52260, 52290, 52319, 52349, 52379, 52408, 52438, 52467, 52497, 52526, 52555, 52585, 52614, 52644, 52673, 52703, 52733, 52762, 52792, 52822, 52851, 52881, 52910, 52939, 52969, 52998, 53028, 53057, 53087, 53116, 53146, 53176, 53205, 53235, 53264, 53294, 53324, 53353, 53383, 53412, 53441, 53471, 53500, 53530, 53559, 53589, 53619, 53648, 53678, 53708, 53737, 53767, 53796, 53825, 53855, 53884, 53913, 53943, 53973, 54003, 54032, 54062, 54092, 54121, 54151, 54180, 54209, 54239, 54268, 54297, 54327, 54357, 54387, 54416, 54446, 54476, 54505, 54535, 54564, 54593, 54623, 54652, 54681, 54711, 54741, 54770, 54800, 54830, 54859, 54889, 54919, 54948, 54977, 55007, 55036, 55066, 55095, 55125, 55154, 55184, 55213, 55243, 55273, 55302, 55332, 55361, 55391, 55420, 55450, 55479, 55508, 55538, 55567, 55597, 55627, 55657, 55686, 55716, 55745, 55775, 55804, 55834, 55863, 55892, 55922, 55951, 55981, 56011, 56040, 56070, 56100, 56129, 56159, 56188, 56218, 56247, 56276, 56306, 56335, 56365, 56394, 56424, 56454, 56483, 56513, 56543, 56572, 56601, 56631, 56660, 56690, 56719, 56749, 56778, 56808, 56837, 56867, 56897, 56926, 56956, 56985, 57015, 57044, 57074, 57103, 57133, 57162, 57192, 57221, 57251, 57280, 57310, 57340, 57369, 57399, 57429, 57458, 57487, 57517, 57546, 57576, 57605, 57634, 57664, 57694, 57723, 57753, 57783, 57813, 57842, 57871, 57901, 57930, 57959, 57989, 58018, 58048, 58077, 58107, 58137, 58167, 58196, 58226, 58255, 58285, 58314, 58343, 58373, 58402, 58432, 58461, 58491, 58521, 58551, 58580, 58610, 58639, 58669, 58698, 58727, 58757, 58786, 58816, 58845, 58875, 58905, 58934, 58964, 58994, 59023, 59053, 59082, 59111, 59141, 59170, 59200, 59229, 59259, 59288, 59318, 59348, 59377, 59407, 59436, 59466, 59495, 59525, 59554, 59584, 59613, 59643, 59672, 59702, 59731, 59761, 59791, 59820, 59850, 59879, 59909, 59939, 59968, 59997, 60027, 60056, 60086, 60115, 60145, 60174, 60204, 60234, 60264, 60293, 60323, 60352, 60381, 60411, 60440, 60469, 60499, 60528, 60558, 60588, 60618, 60648, 60677, 60707, 60736, 60765, 60795, 60824, 60853, 60883, 60912, 60942, 60972, 61002, 61031, 61061, 61090, 61120, 61149, 61179, 61208, 61237, 61267, 61296, 61326, 61356, 61385, 61415, 61445, 61474, 61504, 61533, 61563, 61592, 61621, 61651, 61680, 61710, 61739, 61769, 61799, 61828, 61858, 61888, 61917, 61947, 61976, 62006, 62035, 62064, 62094, 62123, 62153, 62182, 62212, 62242, 62271, 62301, 62331, 62360, 62390, 62419, 62448, 62478, 62507, 62537, 62566, 62596, 62625, 62655, 62685, 62715, 62744, 62774, 62803, 62832, 62862, 62891, 62921, 62950, 62980, 63009, 63039, 63069, 63099, 63128, 63157, 63187, 63216, 63246, 63275, 63305, 63334, 63363, 63393, 63423, 63453, 63482, 63512, 63541, 63571, 63600, 63630, 63659, 63689, 63718, 63747, 63777, 63807, 63836, 63866, 63895, 63925, 63955, 63984, 64014, 64043, 64073, 64102, 64131, 64161, 64190, 64220, 64249, 64279, 64309, 64339, 64368, 64398, 64427, 64457, 64486, 64515, 64545, 64574, 64603, 64633, 64663, 64692, 64722, 64752, 64782, 64811, 64841, 64870, 64899, 64929, 64958, 64987, 65017, 65047, 65076, 65106, 65136, 65166, 65195, 65225, 65254, 65283, 65313, 65342, 65371, 65401, 65431, 65460, 65490, 65520, 65549, 65579, 65608, 65638, 65667, 65697, 65726, 65755, 65785, 65815, 65844, 65874, 65903, 65933, 65963, 65992, 66022, 66051, 66081, 66110, 66140, 66169, 66199, 66228, 66258, 66287, 66317, 66346, 66376, 66405, 66435, 66465, 66494, 66524, 66553, 66583, 66612, 66641, 66671, 66700, 66730, 66760, 66789, 66819, 66849, 66878, 66908, 66937, 66967, 66996, 67025, 67055, 67084, 67114, 67143, 67173, 67203, 67233, 67262, 67292, 67321, 67351, 67380, 67409, 67439, 67468, 67497, 67527, 67557, 67587, 67617, 67646, 67676, 67705, 67735, 67764, 67793, 67823, 67852, 67882, 67911, 67941, 67971, 68e3, 68030, 68060, 68089, 68119, 68148, 68177, 68207, 68236, 68266, 68295, 68325, 68354, 68384, 68414, 68443, 68473, 68502, 68532, 68561, 68591, 68620, 68650, 68679, 68708, 68738, 68768, 68797, 68827, 68857, 68886, 68916, 68946, 68975, 69004, 69034, 69063, 69092, 69122, 69152, 69181, 69211, 69240, 69270, 69300, 69330, 69359, 69388, 69418, 69447, 69476, 69506, 69535, 69565, 69595, 69624, 69654, 69684, 69713, 69743, 69772, 69802, 69831, 69861, 69890, 69919, 69949, 69978, 70008, 70038, 70067, 70097, 70126, 70156, 70186, 70215, 70245, 70274, 70303, 70333, 70362, 70392, 70421, 70451, 70481, 70510, 70540, 70570, 70599, 70629, 70658, 70687, 70717, 70746, 70776, 70805, 70835, 70864, 70894, 70924, 70954, 70983, 71013, 71042, 71071, 71101, 71130, 71159, 71189, 71218, 71248, 71278, 71308, 71337, 71367, 71397, 71426, 71455, 71485, 71514, 71543, 71573, 71602, 71632, 71662, 71691, 71721, 71751, 71781, 71810, 71839, 71869, 71898, 71927, 71957, 71986, 72016, 72046, 72075, 72105, 72135, 72164, 72194, 72223, 72253, 72282, 72311, 72341, 72370, 72400, 72429, 72459, 72489, 72518, 72548, 72577, 72607, 72637, 72666, 72695, 72725, 72754, 72784, 72813, 72843, 72872, 72902, 72931, 72961, 72991, 73020, 73050, 73080, 73109, 73139, 73168, 73197, 73227, 73256, 73286, 73315, 73345, 73375, 73404, 73434, 73464, 73493, 73523, 73552, 73581, 73611, 73640, 73669, 73699, 73729, 73758, 73788, 73818, 73848, 73877, 73907, 73936, 73965, 73995, 74024, 74053, 74083, 74113, 74142, 74172, 74202, 74231, 74261, 74291, 74320, 74349, 74379, 74408, 74437, 74467, 74497, 74526, 74556, 74586, 74615, 74645, 74675, 74704, 74733, 74763, 74792, 74822, 74851, 74881, 74910, 74940, 74969, 74999, 75029, 75058, 75088, 75117, 75147, 75176, 75206, 75235, 75264, 75294, 75323, 75353, 75383, 75412, 75442, 75472, 75501, 75531, 75560, 75590, 75619, 75648, 75678, 75707, 75737, 75766, 75796, 75826, 75856, 75885, 75915, 75944, 75974, 76003, 76032, 76062, 76091, 76121, 76150, 76180, 76210, 76239, 76269, 76299, 76328, 76358, 76387, 76416, 76446, 76475, 76505, 76534, 76564, 76593, 76623, 76653, 76682, 76712, 76741, 76771, 76801, 76830, 76859, 76889, 76918, 76948, 76977, 77007, 77036, 77066, 77096, 77125, 77155, 77185, 77214, 77243, 77273, 77302, 77332, 77361, 77390, 77420, 77450, 77479, 77509, 77539, 77569, 77598, 77627, 77657, 77686, 77715, 77745, 77774, 77804, 77833, 77863, 77893, 77923, 77952, 77982, 78011, 78041, 78070, 78099, 78129, 78158, 78188, 78217, 78247, 78277, 78307, 78336, 78366, 78395, 78425, 78454, 78483, 78513, 78542, 78572, 78601, 78631, 78661, 78690, 78720, 78750, 78779, 78808, 78838, 78867, 78897, 78926, 78956, 78985, 79015, 79044, 79074, 79104, 79133, 79163, 79192, 79222, 79251, 79281, 79310, 79340, 79369, 79399, 79428, 79458, 79487, 79517, 79546, 79576, 79606, 79635, 79665, 79695, 79724, 79753, 79783, 79812, 79841, 79871, 79900, 79930, 79960, 79990];
+      });
+      var xet = ye((vTr, _et) => {
+        _et.exports = kv();
+        tet();
+        ret();
+        iet();
+        net();
+        aet();
+        oet();
+        set();
+        uet();
+        fet();
+        det();
+        vet();
+        pet();
+        get();
+        met();
+        yet();
+      });
+      var ket = ye((pTr, Eet) => {
+        var wet = xet(), TC = Dr(), Tet = fs(), nrr = Tet.EPOCHJD, arr = Tet.ONEDAY, FQ = { valType: "enumerated", values: TC.sortObjectKeys(wet.calendars), editType: "calc", dflt: "gregorian" }, Aet = function(e, t, r, n) {
+          var i = {};
+          return i[r] = FQ, TC.coerce(e, t, i, r, n);
+        }, orr = function(e, t, r, n) {
+          for (var i = 0; i < r.length; i++) Aet(e, t, r[i] + "calendar", n.calendar);
+        }, srr = { chinese: "2000-01-01", coptic: "2000-01-01", discworld: "2000-01-01", ethiopian: "2000-01-01", hebrew: "5000-01-01", islamic: "1000-01-01", julian: "2000-01-01", mayan: "5000-01-01", nanakshahi: "1000-01-01", nepali: "2000-01-01", persian: "1000-01-01", jalali: "1000-01-01", taiwan: "1000-01-01", thai: "2000-01-01", ummalqura: "1400-01-01" }, lrr = { chinese: "2000-01-02", coptic: "2000-01-03", discworld: "2000-01-03", ethiopian: "2000-01-05", hebrew: "5000-01-01", islamic: "1000-01-02", julian: "2000-01-03", mayan: "5000-01-01", nanakshahi: "1000-01-05", nepali: "2000-01-05", persian: "1000-01-01", jalali: "1000-01-01", taiwan: "1000-01-04", thai: "2000-01-04", ummalqura: "1400-01-06" }, urr = { chinese: ["2000-01-01", "2001-01-01"], coptic: ["1700-01-01", "1701-01-01"], discworld: ["1800-01-01", "1801-01-01"], ethiopian: ["2000-01-01", "2001-01-01"], hebrew: ["5700-01-01", "5701-01-01"], islamic: ["1400-01-01", "1401-01-01"], julian: ["2000-01-01", "2001-01-01"], mayan: ["5200-01-01", "5201-01-01"], nanakshahi: ["0500-01-01", "0501-01-01"], nepali: ["2000-01-01", "2001-01-01"], persian: ["1400-01-01", "1401-01-01"], jalali: ["1400-01-01", "1401-01-01"], taiwan: ["0100-01-01", "0101-01-01"], thai: ["2500-01-01", "2501-01-01"], ummalqura: ["1400-01-01", "1401-01-01"] }, U9 = "##", crr = { d: { 0: "dd", "-": "d" }, e: { 0: "d", "-": "d" }, a: { 0: "D", "-": "D" }, A: { 0: "DD", "-": "DD" }, j: { 0: "oo", "-": "o" }, W: { 0: "ww", "-": "w" }, m: { 0: "mm", "-": "m" }, b: { 0: "M", "-": "M" }, B: { 0: "MM", "-": "MM" }, y: { 0: "yy", "-": "yy" }, Y: { 0: "yyyy", "-": "yyyy" }, U: U9, w: U9, c: { 0: "D M d %X yyyy", "-": "D M d %X yyyy" }, x: { 0: "mm/dd/yyyy", "-": "mm/dd/yyyy" } };
+        function frr(e, t, r) {
+          for (var n = Math.floor((t + 0.05) / arr) + nrr, i = Met(r).fromJD(n), a = 0, o, s, l, u, c; (a = e.indexOf("%", a)) !== -1; ) o = e.charAt(a + 1), o === "0" || o === "-" || o === "_" ? (l = 3, s = e.charAt(a + 2), o === "_" && (o = "-")) : (s = o, o = "0", l = 2), u = crr[s], u ? (u === U9 ? c = U9 : c = i.formatDate(u[o]), e = e.slice(0, a) + c + e.slice(a + l), a += c.length) : a += l;
+          return e;
+        }
+        var bet = {};
+        function Met(e) {
+          var t = bet[e];
+          return t || (t = bet[e] = wet.instance(e), t);
+        }
+        function AC(e) {
+          return TC.extendFlat({}, FQ, { description: e });
+        }
+        function zQ(e) {
+          return "Sets the calendar system to use with `" + e + "` date data.";
+        }
+        var DQ = { xcalendar: AC(zQ("x")) }, cy = TC.extendFlat({}, DQ, { ycalendar: AC(zQ("y")) }), RQ = TC.extendFlat({}, cy, { zcalendar: AC(zQ("z")) }), sS = AC(["Sets the calendar system to use for `range` and `tick0`", "if this is a date axis. This does not set the calendar for", "interpreting data on this axis, that's specified in the trace", "or via the global `layout.calendar`"].join(" "));
+        Eet.exports = { moduleType: "component", name: "calendars", schema: { traces: { scatter: cy, bar: cy, box: cy, heatmap: cy, contour: cy, histogram: cy, histogram2d: cy, histogram2dcontour: cy, scatter3d: RQ, surface: RQ, mesh3d: RQ, scattergl: cy, ohlc: DQ, candlestick: DQ }, layout: { calendar: AC(["Sets the default calendar system to use for interpreting and", "displaying dates throughout the plot."].join(" ")) }, subplots: { xaxis: { calendar: sS }, yaxis: { calendar: sS }, scene: { xaxis: { calendar: sS }, yaxis: { calendar: sS }, zaxis: { calendar: sS } }, polar: { radialaxis: { calendar: sS } } } }, layoutAttributes: FQ, handleDefaults: Aet, handleTraceDefaults: orr, CANONICAL_SUNDAY: lrr, CANONICAL_TICK: srr, DFLTRANGE: urr, getCal: Met, worldCalFmt: frr };
+      });
+      var Let = ye((gTr, Cet) => {
+        Cet.exports = ket();
+      });
+      var hrr = ye((mTr, Iet) => {
+        var Pet = uye();
+        Pet.register([f1e(), $1e(), hxe(), Rxe(), Xxe(), Gbe(), r2e(), H2e(), _we(), t3e(), V3e(), eke(), Gke(), D6e(), wLe(), QLe(), TPe(), ZIe(), d8e(), P8e(), G8e(), iRe(), yRe(), DRe(), uFe(), CFe(), WBe(), WNe(), rVe(), kVe(), qGe(), QGe(), THe(), Fje(), Kje(), xWe(), CXe(), QXe(), DZe(), rKe(), EKe(), ZKe(), xJe(), DJe(), R$e(), $$e(), mQe(), $Qe(), Let()]);
+        Iet.exports = Pet;
+      });
+      return hrr();
+    })();
+    /*!
+     * pad-left <https://github.com/jonschlinkert/pad-left>
+     *
+     * Copyright (c) 2014-2015, Jon Schlinkert.
+     * Licensed under the MIT license.
+     */
+    /*!
+     * repeat-string <https://github.com/jonschlinkert/repeat-string>
+     *
+     * Copyright (c) 2014-2015, Jon Schlinkert.
+     * Licensed under the MIT License.
+     */
+    /*! ieee754. BSD-3-Clause License. Feross Aboukhadijeh <https://feross.org/opensource> */
+    /*!
+     * The buffer module from node.js, for the browser.
+     *
+     * @author   Feross Aboukhadijeh <https://feross.org>
+     * @license  MIT
+     */
+    /*!
+     * Determine if an object is a Buffer
+     *
+     * @author   Feross Aboukhadijeh <https://feross.org>
+     * @license  MIT
+     */
+    /*! Bundled license information:
+
+    native-promise-only/lib/npo.src.js:
+      (*! Native Promise Only
+          v0.8.1 (c) Kyle Simpson
+          MIT License: http://getify.mit-license.org
+      *)
+
+    polybooljs/index.js:
+      (*
+       * @copyright 2016 Sean Connelly (@voidqk), http://syntheti.cc
+       * @license MIT
+       * @preserve Project Home: https://github.com/voidqk/polybooljs
+       *)
+
+    ieee754/index.js:
+      (*! ieee754. BSD-3-Clause License. Feross Aboukhadijeh <https://feross.org/opensource> *)
+
+    buffer/index.js:
+      (*!
+       * The buffer module from node.js, for the browser.
+       *
+       * @author   Feross Aboukhadijeh <https://feross.org>
+       * @license  MIT
+       *)
+
+    safe-buffer/index.js:
+      (*! safe-buffer. MIT License. Feross Aboukhadijeh <https://feross.org/opensource> *)
+
+    assert/build/internal/util/comparisons.js:
+      (*!
+       * The buffer module from node.js, for the browser.
+       *
+       * @author   Feross Aboukhadijeh <feross@feross.org> <http://feross.org>
+       * @license  MIT
+       *)
+
+    object-assign/index.js:
+      (*
+      object-assign
+      (c) Sindre Sorhus
+      @license MIT
+      *)
+
+    maplibre-gl/dist/maplibre-gl.js:
+      (**
+       * MapLibre GL JS
+       * @license 3-Clause BSD. Full text of license: https://github.com/maplibre/maplibre-gl-js/blob/v4.7.1/LICENSE.txt
+       *)
+    */
+    window.Plotly = Plotly;
+    return Plotly;
+  });
+})(plotly_min$2);
+var plotly_minExports = plotly_min$2.exports;
+const plotly_min = /* @__PURE__ */ getDefaultExportFromCjs(plotly_minExports);
+const plotly_min$1 = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
+  __proto__: null,
+  default: plotly_min
+}, Symbol.toStringTag, { value: "Module" }));
+export {
+  plotly_min$1 as p
+};
diff --git a/src/bowser/dist/index.css b/src/bowser/dist/index.css
index 723d266..f2c4463 100644
--- a/src/bowser/dist/index.css
+++ b/src/bowser/dist/index.css
@@ -1,665 +1,4 @@
-/* required styles */
-
-.leaflet-pane,
-.leaflet-tile,
-.leaflet-marker-icon,
-.leaflet-marker-shadow,
-.leaflet-tile-container,
-.leaflet-pane > svg,
-.leaflet-pane > canvas,
-.leaflet-zoom-box,
-.leaflet-image-layer,
-.leaflet-layer {
-	position: absolute;
-	left: 0;
-	top: 0;
-	}
-.leaflet-container {
-	overflow: hidden;
-	}
-.leaflet-tile,
-.leaflet-marker-icon,
-.leaflet-marker-shadow {
-	-webkit-user-select: none;
-	   -moz-user-select: none;
-	        user-select: none;
-	  -webkit-user-drag: none;
-	}
-/* Prevents IE11 from highlighting tiles in blue */
-.leaflet-tile::selection {
-	background: transparent;
-}
-/* Safari renders non-retina tile on retina better with this, but Chrome is worse */
-.leaflet-safari .leaflet-tile {
-	image-rendering: -webkit-optimize-contrast;
-	}
-/* hack that prevents hw layers "stretching" when loading new tiles */
-.leaflet-safari .leaflet-tile-container {
-	width: 1600px;
-	height: 1600px;
-	-webkit-transform-origin: 0 0;
-	}
-.leaflet-marker-icon,
-.leaflet-marker-shadow {
-	display: block;
-	}
-/* .leaflet-container svg: reset svg max-width decleration shipped in Joomla! (joomla.org) 3.x */
-/* .leaflet-container img: map is broken in FF if you have max-width: 100% on tiles */
-.leaflet-container .leaflet-overlay-pane svg {
-	max-width: none !important;
-	max-height: none !important;
-	}
-.leaflet-container .leaflet-marker-pane img,
-.leaflet-container .leaflet-shadow-pane img,
-.leaflet-container .leaflet-tile-pane img,
-.leaflet-container img.leaflet-image-layer,
-.leaflet-container .leaflet-tile {
-	max-width: none !important;
-	max-height: none !important;
-	width: auto;
-	padding: 0;
-	}
-
-.leaflet-container img.leaflet-tile {
-	/* See: https://bugs.chromium.org/p/chromium/issues/detail?id=600120 */
-	mix-blend-mode: plus-lighter;
-}
-
-.leaflet-container.leaflet-touch-zoom {
-	-ms-touch-action: pan-x pan-y;
-	touch-action: pan-x pan-y;
-	}
-.leaflet-container.leaflet-touch-drag {
-	-ms-touch-action: pinch-zoom;
-	/* Fallback for FF which doesn't support pinch-zoom */
-	touch-action: none;
-	touch-action: pinch-zoom;
-}
-.leaflet-container.leaflet-touch-drag.leaflet-touch-zoom {
-	-ms-touch-action: none;
-	touch-action: none;
-}
-.leaflet-container {
-	-webkit-tap-highlight-color: transparent;
-}
-.leaflet-container a {
-	-webkit-tap-highlight-color: rgba(51, 181, 229, 0.4);
-}
-.leaflet-tile {
-	filter: inherit;
-	visibility: hidden;
-	}
-.leaflet-tile-loaded {
-	visibility: inherit;
-	}
-.leaflet-zoom-box {
-	width: 0;
-	height: 0;
-	-moz-box-sizing: border-box;
-	     box-sizing: border-box;
-	z-index: 800;
-	}
-/* workaround for https://bugzilla.mozilla.org/show_bug.cgi?id=888319 */
-.leaflet-overlay-pane svg {
-	-moz-user-select: none;
-	}
-
-.leaflet-pane         { z-index: 400; }
-
-.leaflet-tile-pane    { z-index: 200; }
-.leaflet-overlay-pane { z-index: 400; }
-.leaflet-shadow-pane  { z-index: 500; }
-.leaflet-marker-pane  { z-index: 600; }
-.leaflet-tooltip-pane   { z-index: 650; }
-.leaflet-popup-pane   { z-index: 700; }
-
-.leaflet-map-pane canvas { z-index: 100; }
-.leaflet-map-pane svg    { z-index: 200; }
-
-.leaflet-vml-shape {
-	width: 1px;
-	height: 1px;
-	}
-.lvml {
-	behavior: url(#default#VML);
-	display: inline-block;
-	position: absolute;
-	}
-
-
-/* control positioning */
-
-.leaflet-control {
-	position: relative;
-	z-index: 800;
-	pointer-events: visiblePainted; /* IE 9-10 doesn't have auto */
-	pointer-events: auto;
-	}
-.leaflet-top,
-.leaflet-bottom {
-	position: absolute;
-	z-index: 1000;
-	pointer-events: none;
-	}
-.leaflet-top {
-	top: 0;
-	}
-.leaflet-right {
-	right: 0;
-	}
-.leaflet-bottom {
-	bottom: 0;
-	}
-.leaflet-left {
-	left: 0;
-	}
-.leaflet-control {
-	float: left;
-	clear: both;
-	}
-.leaflet-right .leaflet-control {
-	float: right;
-	}
-.leaflet-top .leaflet-control {
-	margin-top: 10px;
-	}
-.leaflet-bottom .leaflet-control {
-	margin-bottom: 10px;
-	}
-.leaflet-left .leaflet-control {
-	margin-left: 10px;
-	}
-.leaflet-right .leaflet-control {
-	margin-right: 10px;
-	}
-
-
-/* zoom and fade animations */
-
-.leaflet-fade-anim .leaflet-popup {
-	opacity: 0;
-	-webkit-transition: opacity 0.2s linear;
-	   -moz-transition: opacity 0.2s linear;
-	        transition: opacity 0.2s linear;
-	}
-.leaflet-fade-anim .leaflet-map-pane .leaflet-popup {
-	opacity: 1;
-	}
-.leaflet-zoom-animated {
-	-webkit-transform-origin: 0 0;
-	    -ms-transform-origin: 0 0;
-	        transform-origin: 0 0;
-	}
-svg.leaflet-zoom-animated {
-	will-change: transform;
-}
-
-.leaflet-zoom-anim .leaflet-zoom-animated {
-	-webkit-transition: -webkit-transform 0.25s cubic-bezier(0,0,0.25,1);
-	   -moz-transition:    -moz-transform 0.25s cubic-bezier(0,0,0.25,1);
-	        transition:         transform 0.25s cubic-bezier(0,0,0.25,1);
-	}
-.leaflet-zoom-anim .leaflet-tile,
-.leaflet-pan-anim .leaflet-tile {
-	-webkit-transition: none;
-	   -moz-transition: none;
-	        transition: none;
-	}
-
-.leaflet-zoom-anim .leaflet-zoom-hide {
-	visibility: hidden;
-	}
-
-
-/* cursors */
-
-.leaflet-interactive {
-	cursor: pointer;
-	}
-.leaflet-grab {
-	cursor: -webkit-grab;
-	cursor:    -moz-grab;
-	cursor:         grab;
-	}
-.leaflet-crosshair,
-.leaflet-crosshair .leaflet-interactive {
-	cursor: crosshair;
-	}
-.leaflet-popup-pane,
-.leaflet-control {
-	cursor: auto;
-	}
-.leaflet-dragging .leaflet-grab,
-.leaflet-dragging .leaflet-grab .leaflet-interactive,
-.leaflet-dragging .leaflet-marker-draggable {
-	cursor: move;
-	cursor: -webkit-grabbing;
-	cursor:    -moz-grabbing;
-	cursor:         grabbing;
-	}
-
-/* marker & overlays interactivity */
-.leaflet-marker-icon,
-.leaflet-marker-shadow,
-.leaflet-image-layer,
-.leaflet-pane > svg path,
-.leaflet-tile-container {
-	pointer-events: none;
-	}
-
-.leaflet-marker-icon.leaflet-interactive,
-.leaflet-image-layer.leaflet-interactive,
-.leaflet-pane > svg path.leaflet-interactive,
-svg.leaflet-image-layer.leaflet-interactive path {
-	pointer-events: visiblePainted; /* IE 9-10 doesn't have auto */
-	pointer-events: auto;
-	}
-
-/* visual tweaks */
-
-.leaflet-container {
-	background: #ddd;
-	outline-offset: 1px;
-	}
-.leaflet-container a {
-	color: #0078A8;
-	}
-.leaflet-zoom-box {
-	border: 2px dotted #38f;
-	background: rgba(255,255,255,0.5);
-	}
-
-
-/* general typography */
-.leaflet-container {
-	font-family: "Helvetica Neue", Arial, Helvetica, sans-serif;
-	font-size: 12px;
-	font-size: 0.75rem;
-	line-height: 1.5;
-	}
-
-
-/* general toolbar styles */
-
-.leaflet-bar {
-	box-shadow: 0 1px 5px rgba(0,0,0,0.65);
-	border-radius: 4px;
-	}
-.leaflet-bar a {
-	background-color: #fff;
-	border-bottom: 1px solid #ccc;
-	width: 26px;
-	height: 26px;
-	line-height: 26px;
-	display: block;
-	text-align: center;
-	text-decoration: none;
-	color: black;
-	}
-.leaflet-bar a,
-.leaflet-control-layers-toggle {
-	background-position: 50% 50%;
-	background-repeat: no-repeat;
-	display: block;
-	}
-.leaflet-bar a:hover,
-.leaflet-bar a:focus {
-	background-color: #f4f4f4;
-	}
-.leaflet-bar a:first-child {
-	border-top-left-radius: 4px;
-	border-top-right-radius: 4px;
-	}
-.leaflet-bar a:last-child {
-	border-bottom-left-radius: 4px;
-	border-bottom-right-radius: 4px;
-	border-bottom: none;
-	}
-.leaflet-bar a.leaflet-disabled {
-	cursor: default;
-	background-color: #f4f4f4;
-	color: #bbb;
-	}
-
-.leaflet-touch .leaflet-bar a {
-	width: 30px;
-	height: 30px;
-	line-height: 30px;
-	}
-.leaflet-touch .leaflet-bar a:first-child {
-	border-top-left-radius: 2px;
-	border-top-right-radius: 2px;
-	}
-.leaflet-touch .leaflet-bar a:last-child {
-	border-bottom-left-radius: 2px;
-	border-bottom-right-radius: 2px;
-	}
-
-/* zoom control */
-
-.leaflet-control-zoom-in,
-.leaflet-control-zoom-out {
-	font: bold 18px 'Lucida Console', Monaco, monospace;
-	text-indent: 1px;
-	}
-
-.leaflet-touch .leaflet-control-zoom-in, .leaflet-touch .leaflet-control-zoom-out  {
-	font-size: 22px;
-	}
-
-
-/* layers control */
-
-.leaflet-control-layers {
-	box-shadow: 0 1px 5px rgba(0,0,0,0.4);
-	background: #fff;
-	border-radius: 5px;
-	}
-.leaflet-control-layers-toggle {
-	background-image: url(data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABoAAAAaCAQAAAADQ4RFAAACf0lEQVR4AY1UM3gkARTePdvdoTxXKc+qTl3aU5U6b2Kbkz3Gtq3Zw6ziLGNPzrYx7946Tr6/ee/XeCQ4D3ykPtL5tHno4n0d/h3+xfuWHGLX81cn7r0iTNzjr7LrlxCqPtkbTQEHeqOrTy4Yyt3VCi/IOB0v7rVC7q45Q3Gr5K6jt+3Gl5nCoDD4MtO+j96Wu8atmhGqcNGHObuf8OM/x3AMx38+4Z2sPqzCxRFK2aF2e5Jol56XTLyggAMTL56XOMoS1W4pOyjUcGGQdZxU6qRh7B9Zp+PfpOFlqt0zyDZckPi1ttmIp03jX8gyJ8a/PG2yutpS/Vol7peZIbZcKBAEEheEIAgFbDkz5H6Zrkm2hVWGiXKiF4Ycw0RWKdtC16Q7qe3X4iOMxruonzegJzWaXFrU9utOSsLUmrc0YjeWYjCW4PDMADElpJSSQ0vQvA1Tm6/JlKnqFs1EGyZiFCqnRZTEJJJiKRYzVYzJck2Rm6P4iH+cmSY0YzimYa8l0EtTODFWhcMIMVqdsI2uiTvKmTisIDHJ3od5GILVhBCarCfVRmo4uTjkhrhzkiBV7SsaqS+TzrzM1qpGGUFt28pIySQHR6h7F6KSwGWm97ay+Z+ZqMcEjEWebE7wxCSQwpkhJqoZA5ivCdZDjJepuJ9IQjGGUmuXJdBFUygxVqVsxFsLMbDe8ZbDYVCGKxs+W080max1hFCarCfV+C1KATwcnvE9gRRuMP2prdbWGowm1KB1y+zwMMENkM755cJ2yPDtqhTI6ED1M/82yIDtC/4j4BijjeObflpO9I9MwXTCsSX8jWAFeHr05WoLTJ5G8IQVS/7vwR6ohirYM7f6HzYpogfS3R2OAAAAAElFTkSuQmCC);
-	width: 36px;
-	height: 36px;
-	}
-.leaflet-retina .leaflet-control-layers-toggle {
-	background-image: url(data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAADQAAAA0CAQAAABvcdNgAAAEsklEQVR4AWL4TydIhpZK1kpWOlg0w3ZXP6D2soBtG42jeI6ZmQTHzAxiTbSJsYLjO9HhP+WOmcuhciVnmHVQcJnp7DFvScowZorad/+V/fVzMdMT2g9Cv9guXGv/7pYOrXh2U+RRR3dSd9JRx6bIFc/ekqHI29JC6pJ5ZEh1yWkhkbcFeSjxgx3L2m1cb1C7bceyxA+CNjT/Ifff+/kDk2u/w/33/IeCMOSaWZ4glosqT3DNnNZQ7Cs58/3Ce5HL78iZH/vKVIaYlqzfdLu8Vi7dnvUbEza5Idt36tquZFldl6N5Z/POLof0XLK61mZCmJSWjVF9tEjUluu74IUXvgttuVIHE7YxSkaYhJZam7yiM9Pv82JYfl9nptxZaxMJE4YSPty+vF0+Y2up9d3wwijfjZbabqm/3bZ9ecKHsiGmRflnn1MW4pjHf9oLufyn2z3y1D6n8g8TZhxyzipLNPnAUpsOiuWimg52psrTZYnOWYNDTMuWBWa0tJb4rgq1UvmutpaYEbZlwU3CLJm/ayYjHW5/h7xWLn9Hh1vepDkyf7dE7MtT5LR4e7yYpHrkhOUpEfssBLq2pPhAqoSWKUkk7EDqkmK6RrCEzqDjhNDWNE+XSMvkJRDWlZTmCW0l0PHQGRZY5t1L83kT0Y3l2SItk5JAWHl2dCOBm+fPu3fo5/3v61RMCO9Jx2EEYYhb0rmNQMX/vm7gqOEJLcXTGw3CAuRNeyaPWwjR8PRqKQ1PDA/dpv+on9Shox52WFnx0KY8onHayrJzm87i5h9xGw/tfkev0jGsQizqezUKjk12hBMKJ4kbCqGPVNXudyyrShovGw5CgxsRICxF6aRmSjlBnHRzg7Gx8fKqEubI2rahQYdR1YgDIRQO7JvQyD52hoIQx0mxa0ODtW2Iozn1le2iIRdzwWewedyZzewidueOGqlsn1MvcnQpuVwLGG3/IR1hIKxCjelIDZ8ldqWz25jWAsnldEnK0Zxro19TGVb2ffIZEsIO89EIEDvKMPrzmBOQcKQ+rroye6NgRRxqR4U8EAkz0CL6uSGOm6KQCdWjvjRiSP1BPalCRS5iQYiEIvxuBMJEWgzSoHADcVMuN7IuqqTeyUPq22qFimFtxDyBBJEwNyt6TM88blFHao/6tWWhuuOM4SAK4EI4QmFHA+SEyWlp4EQoJ13cYGzMu7yszEIBOm2rVmHUNqwAIQabISNMRstmdhNWcFLsSm+0tjJH1MdRxO5Nx0WDMhCtgD6OKgZeljJqJKc9po8juskR9XN0Y1lZ3mWjLR9JCO1jRDMd0fpYC2VnvjBSEFg7wBENc0R9HFlb0xvF1+TBEpF68d+DHR6IOWVv2BECtxo46hOFUBd/APU57WIoEwJhIi2CdpyZX0m93BZicktMj1AS9dClteUFAUNUIEygRZCtik5zSxI9MubTBH1GOiHsiLJ3OCoSZkILa9PxiN0EbvhsAo8tdAf9Seepd36lGWHmtNANTv5Jd0z4QYyeo/UEJqxKRpg5LZx6btLPsOaEmdMyxYdlc8LMaJnikDlhclqmPiQnTEpLUIZEwkRagjYkEibQErwhkTAKCLQEbUgkzJQWc/0PstHHcfEdQ+UAAAAASUVORK5CYII=);
-	background-size: 26px 26px;
-	}
-.leaflet-touch .leaflet-control-layers-toggle {
-	width: 44px;
-	height: 44px;
-	}
-.leaflet-control-layers .leaflet-control-layers-list,
-.leaflet-control-layers-expanded .leaflet-control-layers-toggle {
-	display: none;
-	}
-.leaflet-control-layers-expanded .leaflet-control-layers-list {
-	display: block;
-	position: relative;
-	}
-.leaflet-control-layers-expanded {
-	padding: 6px 10px 6px 6px;
-	color: #333;
-	background: #fff;
-	}
-.leaflet-control-layers-scrollbar {
-	overflow-y: scroll;
-	overflow-x: hidden;
-	padding-right: 5px;
-	}
-.leaflet-control-layers-selector {
-	margin-top: 2px;
-	position: relative;
-	top: 1px;
-	}
-.leaflet-control-layers label {
-	display: block;
-	font-size: 13px;
-	font-size: 1.08333em;
-	}
-.leaflet-control-layers-separator {
-	height: 0;
-	border-top: 1px solid #ddd;
-	margin: 5px -10px 5px -6px;
-	}
-
-/* Default icon URLs */
-.leaflet-default-icon-path { /* used only in path-guessing heuristic, see L.Icon.Default */
-	background-image: url(data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABkAAAApCAYAAADAk4LOAAAFgUlEQVR4Aa1XA5BjWRTN2oW17d3YaZtr2962HUzbDNpjszW24mRt28p47v7zq/bXZtrp/lWnXr337j3nPCe85NcypgSFdugCpW5YoDAMRaIMqRi6aKq5E3YqDQO3qAwjVWrD8Ncq/RBpykd8oZUb/kaJutow8r1aP9II0WmLKLIsJyv1w/kqw9Ch2MYdB++12Onxee/QMwvf4/Dk/Lfp/i4nxTXtOoQ4pW5Aj7wpici1A9erdAN2OH64x8OSP9j3Ft3b7aWkTg/Fm91siTra0f9on5sQr9INejH6CUUUpavjFNq1B+Oadhxmnfa8RfEmN8VNAsQhPqF55xHkMzz3jSmChWU6f7/XZKNH+9+hBLOHYozuKQPxyMPUKkrX/K0uWnfFaJGS1QPRtZsOPtr3NsW0uyh6NNCOkU3Yz+bXbT3I8G3xE5EXLXtCXbbqwCO9zPQYPRTZ5vIDXD7U+w7rFDEoUUf7ibHIR4y6bLVPXrz8JVZEql13trxwue/uDivd3fkWRbS6/IA2bID4uk0UpF1N8qLlbBlXs4Ee7HLTfV1j54APvODnSfOWBqtKVvjgLKzF5YdEk5ewRkGlK0i33Eofffc7HT56jD7/6U+qH3Cx7SBLNntH5YIPvODnyfIXZYRVDPqgHtLs5ABHD3YzLuespb7t79FY34DjMwrVrcTuwlT55YMPvOBnRrJ4VXTdNnYug5ucHLBjEpt30701A3Ts+HEa73u6dT3FNWwflY86eMHPk+Yu+i6pzUpRrW7SNDg5JHR4KapmM5Wv2E8Tfcb1HoqqHMHU+uWDD7zg54mz5/2BSnizi9T1Dg4QQXLToGNCkb6tb1NU+QAlGr1++eADrzhn/u8Q2YZhQVlZ5+CAOtqfbhmaUCS1ezNFVm2imDbPmPng5wmz+gwh+oHDce0eUtQ6OGDIyR0uUhUsoO3vfDmmgOezH0mZN59x7MBi++WDL1g/eEiU3avlidO671bkLfwbw5XV2P8Pzo0ydy4t2/0eu33xYSOMOD8hTf4CrBtGMSoXfPLchX+J0ruSePw3LZeK0juPJbYzrhkH0io7B3k164hiGvawhOKMLkrQLyVpZg8rHFW7E2uHOL888IBPlNZ1FPzstSJM694fWr6RwpvcJK60+0HCILTBzZLFNdtAzJaohze60T8qBzyh5ZuOg5e7uwQppofEmf2++DYvmySqGBuKaicF1blQjhuHdvCIMvp8whTTfZzI7RldpwtSzL+F1+wkdZ2TBOW2gIF88PBTzD/gpeREAMEbxnJcaJHNHrpzji0gQCS6hdkEeYt9DF/2qPcEC8RM28Hwmr3sdNyht00byAut2k3gufWNtgtOEOFGUwcXWNDbdNbpgBGxEvKkOQsxivJx33iow0Vw5S6SVTrpVq11ysA2Rp7gTfPfktc6zhtXBBC+adRLshf6sG2RfHPZ5EAc4sVZ83yCN00Fk/4kggu40ZTvIEm5g24qtU4KjBrx/BTTH8ifVASAG7gKrnWxJDcU7x8X6Ecczhm3o6YicvsLXWfh3Ch1W0k8x0nXF+0fFxgt4phz8QvypiwCCFKMqXCnqXExjq10beH+UUA7+nG6mdG/Pu0f3LgFcGrl2s0kNNjpmoJ9o4B29CMO8dMT4Q5ox8uitF6fqsrJOr8qnwNbRzv6hSnG5wP+64C7h9lp30hKNtKdWjtdkbuPA19nJ7Tz3zR/ibgARbhb4AlhavcBebmTHcFl2fvYEnW0ox9xMxKBS8btJ+KiEbq9zA4RthQXDhPa0T9TEe69gWupwc6uBUphquXgf+/FrIjweHQS4/pduMe5ERUMHUd9xv8ZR98CxkS4F2n3EUrUZ10EYNw7BWm9x1GiPssi3GgiGRDKWRYZfXlON+dfNbM+GgIwYdwAAAAASUVORK5CYII=);
-	}
-
-
-/* attribution and scale controls */
-
-.leaflet-container .leaflet-control-attribution {
-	background: #fff;
-	background: rgba(255, 255, 255, 0.8);
-	margin: 0;
-	}
-.leaflet-control-attribution,
-.leaflet-control-scale-line {
-	padding: 0 5px;
-	color: #333;
-	line-height: 1.4;
-	}
-.leaflet-control-attribution a {
-	text-decoration: none;
-	}
-.leaflet-control-attribution a:hover,
-.leaflet-control-attribution a:focus {
-	text-decoration: underline;
-	}
-.leaflet-attribution-flag {
-	display: inline !important;
-	vertical-align: baseline !important;
-	width: 1em;
-	height: 0.6669em;
-	}
-.leaflet-left .leaflet-control-scale {
-	margin-left: 5px;
-	}
-.leaflet-bottom .leaflet-control-scale {
-	margin-bottom: 5px;
-	}
-.leaflet-control-scale-line {
-	border: 2px solid #777;
-	border-top: none;
-	line-height: 1.1;
-	padding: 2px 5px 1px;
-	white-space: nowrap;
-	-moz-box-sizing: border-box;
-	     box-sizing: border-box;
-	background: rgba(255, 255, 255, 0.8);
-	text-shadow: 1px 1px #fff;
-	}
-.leaflet-control-scale-line:not(:first-child) {
-	border-top: 2px solid #777;
-	border-bottom: none;
-	margin-top: -2px;
-	}
-.leaflet-control-scale-line:not(:first-child):not(:last-child) {
-	border-bottom: 2px solid #777;
-	}
-
-.leaflet-touch .leaflet-control-attribution,
-.leaflet-touch .leaflet-control-layers,
-.leaflet-touch .leaflet-bar {
-	box-shadow: none;
-	}
-.leaflet-touch .leaflet-control-layers,
-.leaflet-touch .leaflet-bar {
-	border: 2px solid rgba(0,0,0,0.2);
-	background-clip: padding-box;
-	}
-
-
-/* popup */
-
-.leaflet-popup {
-	position: absolute;
-	text-align: center;
-	margin-bottom: 20px;
-	}
-.leaflet-popup-content-wrapper {
-	padding: 1px;
-	text-align: left;
-	border-radius: 12px;
-	}
-.leaflet-popup-content {
-	margin: 13px 24px 13px 20px;
-	line-height: 1.3;
-	font-size: 13px;
-	font-size: 1.08333em;
-	min-height: 1px;
-	}
-.leaflet-popup-content p {
-	margin: 17px 0;
-	margin: 1.3em 0;
-	}
-.leaflet-popup-tip-container {
-	width: 40px;
-	height: 20px;
-	position: absolute;
-	left: 50%;
-	margin-top: -1px;
-	margin-left: -20px;
-	overflow: hidden;
-	pointer-events: none;
-	}
-.leaflet-popup-tip {
-	width: 17px;
-	height: 17px;
-	padding: 1px;
-
-	margin: -10px auto 0;
-	pointer-events: auto;
-
-	-webkit-transform: rotate(45deg);
-	   -moz-transform: rotate(45deg);
-	    -ms-transform: rotate(45deg);
-	        transform: rotate(45deg);
-	}
-.leaflet-popup-content-wrapper,
-.leaflet-popup-tip {
-	background: white;
-	color: #333;
-	box-shadow: 0 3px 14px rgba(0,0,0,0.4);
-	}
-.leaflet-container a.leaflet-popup-close-button {
-	position: absolute;
-	top: 0;
-	right: 0;
-	border: none;
-	text-align: center;
-	width: 24px;
-	height: 24px;
-	font: 16px/24px Tahoma, Verdana, sans-serif;
-	color: #757575;
-	text-decoration: none;
-	background: transparent;
-	}
-.leaflet-container a.leaflet-popup-close-button:hover,
-.leaflet-container a.leaflet-popup-close-button:focus {
-	color: #585858;
-	}
-.leaflet-popup-scrolled {
-	overflow: auto;
-	}
-
-.leaflet-oldie .leaflet-popup-content-wrapper {
-	-ms-zoom: 1;
-	}
-.leaflet-oldie .leaflet-popup-tip {
-	width: 24px;
-	margin: 0 auto;
-
-	-ms-filter: "progid:DXImageTransform.Microsoft.Matrix(M11=0.70710678, M12=0.70710678, M21=-0.70710678, M22=0.70710678)";
-	filter: progid:DXImageTransform.Microsoft.Matrix(M11=0.70710678, M12=0.70710678, M21=-0.70710678, M22=0.70710678);
-	}
-
-.leaflet-oldie .leaflet-control-zoom,
-.leaflet-oldie .leaflet-control-layers,
-.leaflet-oldie .leaflet-popup-content-wrapper,
-.leaflet-oldie .leaflet-popup-tip {
-	border: 1px solid #999;
-	}
-
-
-/* div icon */
-
-.leaflet-div-icon {
-	background: #fff;
-	border: 1px solid #666;
-	}
-
-
-/* Tooltip */
-/* Base styles for the element that has a tooltip */
-.leaflet-tooltip {
-	position: absolute;
-	padding: 6px;
-	background-color: #fff;
-	border: 1px solid #fff;
-	border-radius: 3px;
-	color: #222;
-	white-space: nowrap;
-	-webkit-user-select: none;
-	-moz-user-select: none;
-	-ms-user-select: none;
-	user-select: none;
-	pointer-events: none;
-	box-shadow: 0 1px 3px rgba(0,0,0,0.4);
-	}
-.leaflet-tooltip.leaflet-interactive {
-	cursor: pointer;
-	pointer-events: auto;
-	}
-.leaflet-tooltip-top:before,
-.leaflet-tooltip-bottom:before,
-.leaflet-tooltip-left:before,
-.leaflet-tooltip-right:before {
-	position: absolute;
-	pointer-events: none;
-	border: 6px solid transparent;
-	background: transparent;
-	content: "";
-	}
-
-/* Directions */
-
-.leaflet-tooltip-bottom {
-	margin-top: 6px;
-}
-.leaflet-tooltip-top {
-	margin-top: -6px;
-}
-.leaflet-tooltip-bottom:before,
-.leaflet-tooltip-top:before {
-	left: 50%;
-	margin-left: -6px;
-	}
-.leaflet-tooltip-top:before {
-	bottom: 0;
-	margin-bottom: -12px;
-	border-top-color: #fff;
-	}
-.leaflet-tooltip-bottom:before {
-	top: 0;
-	margin-top: -12px;
-	margin-left: -6px;
-	border-bottom-color: #fff;
-	}
-.leaflet-tooltip-left {
-	margin-left: -6px;
-}
-.leaflet-tooltip-right {
-	margin-left: 6px;
-}
-.leaflet-tooltip-left:before,
-.leaflet-tooltip-right:before {
-	top: 50%;
-	margin-top: -6px;
-	}
-.leaflet-tooltip-left:before {
-	right: 0;
-	margin-right: -12px;
-	border-left-color: #fff;
-	}
-.leaflet-tooltip-right:before {
-	left: 0;
-	margin-left: -12px;
-	border-right-color: #fff;
-	}
-
-/* Printing */
-
-@media print {
-	/* Prevent printers from removing background-images of controls. */
-	.leaflet-control {
-		-webkit-print-color-adjust: exact;
-		print-color-adjust: exact;
-		}
-	}
-:root {
+.maplibregl-map{font:12px/20px Helvetica Neue,Arial,Helvetica,sans-serif;overflow:hidden;position:relative;-webkit-tap-highlight-color:rgb(0,0,0,0)}.maplibregl-canvas{left:0;position:absolute;top:0}.maplibregl-map:fullscreen{height:100%;width:100%}.maplibregl-ctrl-group button.maplibregl-ctrl-compass{touch-action:none}.maplibregl-canvas-container.maplibregl-interactive,.maplibregl-ctrl-group button.maplibregl-ctrl-compass{cursor:grab;-webkit-user-select:none;-moz-user-select:none;user-select:none}.maplibregl-canvas-container.maplibregl-interactive.maplibregl-track-pointer{cursor:pointer}.maplibregl-canvas-container.maplibregl-interactive:active,.maplibregl-ctrl-group button.maplibregl-ctrl-compass:active{cursor:grabbing}.maplibregl-canvas-container.maplibregl-touch-zoom-rotate,.maplibregl-canvas-container.maplibregl-touch-zoom-rotate .maplibregl-canvas{touch-action:pan-x pan-y}.maplibregl-canvas-container.maplibregl-touch-drag-pan,.maplibregl-canvas-container.maplibregl-touch-drag-pan .maplibregl-canvas{touch-action:pinch-zoom}.maplibregl-canvas-container.maplibregl-touch-zoom-rotate.maplibregl-touch-drag-pan,.maplibregl-canvas-container.maplibregl-touch-zoom-rotate.maplibregl-touch-drag-pan .maplibregl-canvas{touch-action:none}.maplibregl-canvas-container.maplibregl-touch-drag-pan.maplibregl-cooperative-gestures,.maplibregl-canvas-container.maplibregl-touch-drag-pan.maplibregl-cooperative-gestures .maplibregl-canvas{touch-action:pan-x pan-y}.maplibregl-ctrl-bottom-left,.maplibregl-ctrl-bottom-right,.maplibregl-ctrl-top-left,.maplibregl-ctrl-top-right{pointer-events:none;position:absolute;z-index:2}.maplibregl-ctrl-top-left{left:0;top:0}.maplibregl-ctrl-top-right{right:0;top:0}.maplibregl-ctrl-bottom-left{bottom:0;left:0}.maplibregl-ctrl-bottom-right{bottom:0;right:0}.maplibregl-ctrl{clear:both;pointer-events:auto;transform:translate(0)}.maplibregl-ctrl-top-left .maplibregl-ctrl{float:left;margin:10px 0 0 10px}.maplibregl-ctrl-top-right .maplibregl-ctrl{float:right;margin:10px 10px 0 0}.maplibregl-ctrl-bottom-left .maplibregl-ctrl{float:left;margin:0 0 10px 10px}.maplibregl-ctrl-bottom-right .maplibregl-ctrl{float:right;margin:0 10px 10px 0}.maplibregl-ctrl-group{background:#fff;border-radius:4px}.maplibregl-ctrl-group:not(:empty){box-shadow:0 0 0 2px rgba(0,0,0,.1)}@media (forced-colors:active){.maplibregl-ctrl-group:not(:empty){box-shadow:0 0 0 2px ButtonText}}.maplibregl-ctrl-group button{background-color:transparent;border:0;box-sizing:border-box;cursor:pointer;display:block;height:29px;outline:none;padding:0;width:29px}.maplibregl-ctrl-group button+button{border-top:1px solid #ddd}.maplibregl-ctrl button .maplibregl-ctrl-icon{background-position:50%;background-repeat:no-repeat;display:block;height:100%;width:100%}@media (forced-colors:active){.maplibregl-ctrl-icon{background-color:transparent}.maplibregl-ctrl-group button+button{border-top:1px solid ButtonText}}.maplibregl-ctrl button::-moz-focus-inner{border:0;padding:0}.maplibregl-ctrl-attrib-button:focus,.maplibregl-ctrl-group button:focus{box-shadow:0 0 2px 2px #0096ff}.maplibregl-ctrl button:disabled{cursor:not-allowed}.maplibregl-ctrl button:disabled .maplibregl-ctrl-icon{opacity:.25}@media (hover:hover){.maplibregl-ctrl button:not(:disabled):hover{background-color:rgba(0,0,0,.05)}}.maplibregl-ctrl button:not(:disabled):active{background-color:rgba(0,0,0,.05)}.maplibregl-ctrl-group button:focus:focus-visible{box-shadow:0 0 2px 2px #0096ff}.maplibregl-ctrl-group button:focus:not(:focus-visible){box-shadow:none}.maplibregl-ctrl-group button:focus:first-child{border-radius:4px 4px 0 0}.maplibregl-ctrl-group button:focus:last-child{border-radius:0 0 4px 4px}.maplibregl-ctrl-group button:focus:only-child{border-radius:inherit}.maplibregl-ctrl button.maplibregl-ctrl-zoom-out .maplibregl-ctrl-icon{background-image:url("data:image/svg+xml;charset=utf-8,%3Csvg xmlns='http://www.w3.org/2000/svg' width='29' height='29' fill='%23333' viewBox='0 0 29 29'%3E%3Cpath d='M10 13c-.75 0-1.5.75-1.5 1.5S9.25 16 10 16h9c.75 0 1.5-.75 1.5-1.5S19.75 13 19 13z'/%3E%3C/svg%3E")}.maplibregl-ctrl button.maplibregl-ctrl-zoom-in .maplibregl-ctrl-icon{background-image:url("data:image/svg+xml;charset=utf-8,%3Csvg xmlns='http://www.w3.org/2000/svg' width='29' height='29' fill='%23333' viewBox='0 0 29 29'%3E%3Cpath d='M14.5 8.5c-.75 0-1.5.75-1.5 1.5v3h-3c-.75 0-1.5.75-1.5 1.5S9.25 16 10 16h3v3c0 .75.75 1.5 1.5 1.5S16 19.75 16 19v-3h3c.75 0 1.5-.75 1.5-1.5S19.75 13 19 13h-3v-3c0-.75-.75-1.5-1.5-1.5'/%3E%3C/svg%3E")}@media (forced-colors:active){.maplibregl-ctrl button.maplibregl-ctrl-zoom-out .maplibregl-ctrl-icon{background-image:url("data:image/svg+xml;charset=utf-8,%3Csvg xmlns='http://www.w3.org/2000/svg' width='29' height='29' fill='%23fff' viewBox='0 0 29 29'%3E%3Cpath d='M10 13c-.75 0-1.5.75-1.5 1.5S9.25 16 10 16h9c.75 0 1.5-.75 1.5-1.5S19.75 13 19 13z'/%3E%3C/svg%3E")}.maplibregl-ctrl button.maplibregl-ctrl-zoom-in .maplibregl-ctrl-icon{background-image:url("data:image/svg+xml;charset=utf-8,%3Csvg xmlns='http://www.w3.org/2000/svg' width='29' height='29' fill='%23fff' viewBox='0 0 29 29'%3E%3Cpath d='M14.5 8.5c-.75 0-1.5.75-1.5 1.5v3h-3c-.75 0-1.5.75-1.5 1.5S9.25 16 10 16h3v3c0 .75.75 1.5 1.5 1.5S16 19.75 16 19v-3h3c.75 0 1.5-.75 1.5-1.5S19.75 13 19 13h-3v-3c0-.75-.75-1.5-1.5-1.5'/%3E%3C/svg%3E")}}@media (forced-colors:active) and (prefers-color-scheme:light){.maplibregl-ctrl button.maplibregl-ctrl-zoom-out .maplibregl-ctrl-icon{background-image:url("data:image/svg+xml;charset=utf-8,%3Csvg xmlns='http://www.w3.org/2000/svg' width='29' height='29' viewBox='0 0 29 29'%3E%3Cpath d='M10 13c-.75 0-1.5.75-1.5 1.5S9.25 16 10 16h9c.75 0 1.5-.75 1.5-1.5S19.75 13 19 13z'/%3E%3C/svg%3E")}.maplibregl-ctrl button.maplibregl-ctrl-zoom-in .maplibregl-ctrl-icon{background-image:url("data:image/svg+xml;charset=utf-8,%3Csvg xmlns='http://www.w3.org/2000/svg' width='29' height='29' viewBox='0 0 29 29'%3E%3Cpath d='M14.5 8.5c-.75 0-1.5.75-1.5 1.5v3h-3c-.75 0-1.5.75-1.5 1.5S9.25 16 10 16h3v3c0 .75.75 1.5 1.5 1.5S16 19.75 16 19v-3h3c.75 0 1.5-.75 1.5-1.5S19.75 13 19 13h-3v-3c0-.75-.75-1.5-1.5-1.5'/%3E%3C/svg%3E")}}.maplibregl-ctrl button.maplibregl-ctrl-fullscreen .maplibregl-ctrl-icon{background-image:url("data:image/svg+xml;charset=utf-8,%3Csvg xmlns='http://www.w3.org/2000/svg' width='29' height='29' fill='%23333' viewBox='0 0 29 29'%3E%3Cpath d='M24 16v5.5c0 1.75-.75 2.5-2.5 2.5H16v-1l3-1.5-4-5.5 1-1 5.5 4 1.5-3zM6 16l1.5 3 5.5-4 1 1-4 5.5 3 1.5v1H7.5C5.75 24 5 23.25 5 21.5V16zm7-11v1l-3 1.5 4 5.5-1 1-5.5-4L6 13H5V7.5C5 5.75 5.75 5 7.5 5zm11 2.5c0-1.75-.75-2.5-2.5-2.5H16v1l3 1.5-4 5.5 1 1 5.5-4 1.5 3h1z'/%3E%3C/svg%3E")}.maplibregl-ctrl button.maplibregl-ctrl-shrink .maplibregl-ctrl-icon{background-image:url("data:image/svg+xml;charset=utf-8,%3Csvg xmlns='http://www.w3.org/2000/svg' width='29' height='29' viewBox='0 0 29 29'%3E%3Cpath d='M18.5 16c-1.75 0-2.5.75-2.5 2.5V24h1l1.5-3 5.5 4 1-1-4-5.5 3-1.5v-1zM13 18.5c0-1.75-.75-2.5-2.5-2.5H5v1l3 1.5L4 24l1 1 5.5-4 1.5 3h1zm3-8c0 1.75.75 2.5 2.5 2.5H24v-1l-3-1.5L25 5l-1-1-5.5 4L17 5h-1zM10.5 13c1.75 0 2.5-.75 2.5-2.5V5h-1l-1.5 3L5 4 4 5l4 5.5L5 12v1z'/%3E%3C/svg%3E")}@media (forced-colors:active){.maplibregl-ctrl button.maplibregl-ctrl-fullscreen .maplibregl-ctrl-icon{background-image:url("data:image/svg+xml;charset=utf-8,%3Csvg xmlns='http://www.w3.org/2000/svg' width='29' height='29' fill='%23fff' viewBox='0 0 29 29'%3E%3Cpath d='M24 16v5.5c0 1.75-.75 2.5-2.5 2.5H16v-1l3-1.5-4-5.5 1-1 5.5 4 1.5-3zM6 16l1.5 3 5.5-4 1 1-4 5.5 3 1.5v1H7.5C5.75 24 5 23.25 5 21.5V16zm7-11v1l-3 1.5 4 5.5-1 1-5.5-4L6 13H5V7.5C5 5.75 5.75 5 7.5 5zm11 2.5c0-1.75-.75-2.5-2.5-2.5H16v1l3 1.5-4 5.5 1 1 5.5-4 1.5 3h1z'/%3E%3C/svg%3E")}.maplibregl-ctrl button.maplibregl-ctrl-shrink .maplibregl-ctrl-icon{background-image:url("data:image/svg+xml;charset=utf-8,%3Csvg xmlns='http://www.w3.org/2000/svg' width='29' height='29' fill='%23fff' viewBox='0 0 29 29'%3E%3Cpath d='M18.5 16c-1.75 0-2.5.75-2.5 2.5V24h1l1.5-3 5.5 4 1-1-4-5.5 3-1.5v-1zM13 18.5c0-1.75-.75-2.5-2.5-2.5H5v1l3 1.5L4 24l1 1 5.5-4 1.5 3h1zm3-8c0 1.75.75 2.5 2.5 2.5H24v-1l-3-1.5L25 5l-1-1-5.5 4L17 5h-1zM10.5 13c1.75 0 2.5-.75 2.5-2.5V5h-1l-1.5 3L5 4 4 5l4 5.5L5 12v1z'/%3E%3C/svg%3E")}}@media (forced-colors:active) and (prefers-color-scheme:light){.maplibregl-ctrl button.maplibregl-ctrl-fullscreen .maplibregl-ctrl-icon{background-image:url("data:image/svg+xml;charset=utf-8,%3Csvg xmlns='http://www.w3.org/2000/svg' width='29' height='29' viewBox='0 0 29 29'%3E%3Cpath d='M24 16v5.5c0 1.75-.75 2.5-2.5 2.5H16v-1l3-1.5-4-5.5 1-1 5.5 4 1.5-3zM6 16l1.5 3 5.5-4 1 1-4 5.5 3 1.5v1H7.5C5.75 24 5 23.25 5 21.5V16zm7-11v1l-3 1.5 4 5.5-1 1-5.5-4L6 13H5V7.5C5 5.75 5.75 5 7.5 5zm11 2.5c0-1.75-.75-2.5-2.5-2.5H16v1l3 1.5-4 5.5 1 1 5.5-4 1.5 3h1z'/%3E%3C/svg%3E")}.maplibregl-ctrl button.maplibregl-ctrl-shrink .maplibregl-ctrl-icon{background-image:url("data:image/svg+xml;charset=utf-8,%3Csvg xmlns='http://www.w3.org/2000/svg' width='29' height='29' viewBox='0 0 29 29'%3E%3Cpath d='M18.5 16c-1.75 0-2.5.75-2.5 2.5V24h1l1.5-3 5.5 4 1-1-4-5.5 3-1.5v-1zM13 18.5c0-1.75-.75-2.5-2.5-2.5H5v1l3 1.5L4 24l1 1 5.5-4 1.5 3h1zm3-8c0 1.75.75 2.5 2.5 2.5H24v-1l-3-1.5L25 5l-1-1-5.5 4L17 5h-1zM10.5 13c1.75 0 2.5-.75 2.5-2.5V5h-1l-1.5 3L5 4 4 5l4 5.5L5 12v1z'/%3E%3C/svg%3E")}}.maplibregl-ctrl button.maplibregl-ctrl-compass .maplibregl-ctrl-icon{background-image:url("data:image/svg+xml;charset=utf-8,%3Csvg xmlns='http://www.w3.org/2000/svg' width='29' height='29' fill='%23333' viewBox='0 0 29 29'%3E%3Cpath d='m10.5 14 4-8 4 8z'/%3E%3Cpath fill='%23ccc' d='m10.5 16 4 8 4-8z'/%3E%3C/svg%3E")}@media (forced-colors:active){.maplibregl-ctrl button.maplibregl-ctrl-compass .maplibregl-ctrl-icon{background-image:url("data:image/svg+xml;charset=utf-8,%3Csvg xmlns='http://www.w3.org/2000/svg' width='29' height='29' fill='%23fff' viewBox='0 0 29 29'%3E%3Cpath d='m10.5 14 4-8 4 8z'/%3E%3Cpath fill='%23ccc' d='m10.5 16 4 8 4-8z'/%3E%3C/svg%3E")}}@media (forced-colors:active) and (prefers-color-scheme:light){.maplibregl-ctrl button.maplibregl-ctrl-compass .maplibregl-ctrl-icon{background-image:url("data:image/svg+xml;charset=utf-8,%3Csvg xmlns='http://www.w3.org/2000/svg' width='29' height='29' viewBox='0 0 29 29'%3E%3Cpath d='m10.5 14 4-8 4 8z'/%3E%3Cpath fill='%23ccc' d='m10.5 16 4 8 4-8z'/%3E%3C/svg%3E")}}.maplibregl-ctrl button.maplibregl-ctrl-globe .maplibregl-ctrl-icon{background-image:url("data:image/svg+xml;charset=utf-8,%3Csvg xmlns='http://www.w3.org/2000/svg' width='22' height='22' fill='none' stroke='%23333' viewBox='0 0 22 22'%3E%3Ccircle cx='11' cy='11' r='8.5'/%3E%3Cpath d='M17.5 11c0 4.819-3.02 8.5-6.5 8.5S4.5 15.819 4.5 11 7.52 2.5 11 2.5s6.5 3.681 6.5 8.5Z'/%3E%3Cpath d='M13.5 11c0 2.447-.331 4.64-.853 6.206-.262.785-.562 1.384-.872 1.777-.314.399-.58.517-.775.517s-.461-.118-.775-.517c-.31-.393-.61-.992-.872-1.777C8.831 15.64 8.5 13.446 8.5 11s.331-4.64.853-6.206c.262-.785.562-1.384.872-1.777.314-.399.58-.517.775-.517s.461.118.775.517c.31.393.61.992.872 1.777.522 1.565.853 3.76.853 6.206Z'/%3E%3Cpath d='M11 7.5c-1.909 0-3.622-.166-4.845-.428-.616-.132-1.08-.283-1.379-.434a1.3 1.3 0 0 1-.224-.138q.07-.058.224-.138c.299-.151.763-.302 1.379-.434C7.378 5.666 9.091 5.5 11 5.5s3.622.166 4.845.428c.616.132 1.08.283 1.379.434.105.053.177.1.224.138q-.07.058-.224.138c-.299.151-.763.302-1.379.434-1.223.262-2.936.428-4.845.428ZM4.486 6.436ZM11 16.5c-1.909 0-3.622-.166-4.845-.428-.616-.132-1.08-.283-1.379-.434a1.3 1.3 0 0 1-.224-.138 1.3 1.3 0 0 1 .224-.138c.299-.151.763-.302 1.379-.434C7.378 14.666 9.091 14.5 11 14.5s3.622.166 4.845.428c.616.132 1.08.283 1.379.434.105.053.177.1.224.138a1.3 1.3 0 0 1-.224.138c-.299.151-.763.302-1.379.434-1.223.262-2.936.428-4.845.428Zm-6.514-1.064ZM11 12.5c-2.46 0-4.672-.222-6.255-.574-.796-.177-1.406-.38-1.805-.59a1.5 1.5 0 0 1-.39-.272.3.3 0 0 1-.047-.064.3.3 0 0 1 .048-.064c.066-.073.189-.167.389-.272.399-.21 1.009-.413 1.805-.59C6.328 9.722 8.54 9.5 11 9.5s4.672.222 6.256.574c.795.177 1.405.38 1.804.59.2.105.323.2.39.272a.3.3 0 0 1 .047.064.3.3 0 0 1-.048.064 1.4 1.4 0 0 1-.389.272c-.399.21-1.009.413-1.804.59-1.584.352-3.796.574-6.256.574Zm-8.501-1.51v.002zm0 .018v.002zm17.002.002v-.002zm0-.018v-.002z'/%3E%3C/svg%3E")}.maplibregl-ctrl button.maplibregl-ctrl-globe-enabled .maplibregl-ctrl-icon{background-image:url("data:image/svg+xml;charset=utf-8,%3Csvg xmlns='http://www.w3.org/2000/svg' width='22' height='22' fill='none' stroke='%2333b5e5' viewBox='0 0 22 22'%3E%3Ccircle cx='11' cy='11' r='8.5'/%3E%3Cpath d='M17.5 11c0 4.819-3.02 8.5-6.5 8.5S4.5 15.819 4.5 11 7.52 2.5 11 2.5s6.5 3.681 6.5 8.5Z'/%3E%3Cpath d='M13.5 11c0 2.447-.331 4.64-.853 6.206-.262.785-.562 1.384-.872 1.777-.314.399-.58.517-.775.517s-.461-.118-.775-.517c-.31-.393-.61-.992-.872-1.777C8.831 15.64 8.5 13.446 8.5 11s.331-4.64.853-6.206c.262-.785.562-1.384.872-1.777.314-.399.58-.517.775-.517s.461.118.775.517c.31.393.61.992.872 1.777.522 1.565.853 3.76.853 6.206Z'/%3E%3Cpath d='M11 7.5c-1.909 0-3.622-.166-4.845-.428-.616-.132-1.08-.283-1.379-.434a1.3 1.3 0 0 1-.224-.138q.07-.058.224-.138c.299-.151.763-.302 1.379-.434C7.378 5.666 9.091 5.5 11 5.5s3.622.166 4.845.428c.616.132 1.08.283 1.379.434.105.053.177.1.224.138q-.07.058-.224.138c-.299.151-.763.302-1.379.434-1.223.262-2.936.428-4.845.428ZM4.486 6.436ZM11 16.5c-1.909 0-3.622-.166-4.845-.428-.616-.132-1.08-.283-1.379-.434a1.3 1.3 0 0 1-.224-.138 1.3 1.3 0 0 1 .224-.138c.299-.151.763-.302 1.379-.434C7.378 14.666 9.091 14.5 11 14.5s3.622.166 4.845.428c.616.132 1.08.283 1.379.434.105.053.177.1.224.138a1.3 1.3 0 0 1-.224.138c-.299.151-.763.302-1.379.434-1.223.262-2.936.428-4.845.428Zm-6.514-1.064ZM11 12.5c-2.46 0-4.672-.222-6.255-.574-.796-.177-1.406-.38-1.805-.59a1.5 1.5 0 0 1-.39-.272.3.3 0 0 1-.047-.064.3.3 0 0 1 .048-.064c.066-.073.189-.167.389-.272.399-.21 1.009-.413 1.805-.59C6.328 9.722 8.54 9.5 11 9.5s4.672.222 6.256.574c.795.177 1.405.38 1.804.59.2.105.323.2.39.272a.3.3 0 0 1 .047.064.3.3 0 0 1-.048.064 1.4 1.4 0 0 1-.389.272c-.399.21-1.009.413-1.804.59-1.584.352-3.796.574-6.256.574Zm-8.501-1.51v.002zm0 .018v.002zm17.002.002v-.002zm0-.018v-.002z'/%3E%3C/svg%3E")}.maplibregl-ctrl button.maplibregl-ctrl-terrain .maplibregl-ctrl-icon{background-image:url("data:image/svg+xml;charset=utf-8,%3Csvg xmlns='http://www.w3.org/2000/svg' width='22' height='22' fill='%23333' viewBox='0 0 22 22'%3E%3Cpath d='m1.754 13.406 4.453-4.851 3.09 3.09 3.281 3.277.969-.969-3.309-3.312 3.844-4.121 6.148 6.886h1.082v-.855l-7.207-8.07-4.84 5.187L6.169 6.57l-5.48 5.965v.871ZM.688 16.844h20.625v1.375H.688Zm0 0'/%3E%3C/svg%3E")}.maplibregl-ctrl button.maplibregl-ctrl-terrain-enabled .maplibregl-ctrl-icon{background-image:url("data:image/svg+xml;charset=utf-8,%3Csvg xmlns='http://www.w3.org/2000/svg' width='22' height='22' fill='%2333b5e5' viewBox='0 0 22 22'%3E%3Cpath d='m1.754 13.406 4.453-4.851 3.09 3.09 3.281 3.277.969-.969-3.309-3.312 3.844-4.121 6.148 6.886h1.082v-.855l-7.207-8.07-4.84 5.187L6.169 6.57l-5.48 5.965v.871ZM.688 16.844h20.625v1.375H.688Zm0 0'/%3E%3C/svg%3E")}.maplibregl-ctrl button.maplibregl-ctrl-geolocate .maplibregl-ctrl-icon{background-image:url("data:image/svg+xml;charset=utf-8,%3Csvg xmlns='http://www.w3.org/2000/svg' width='29' height='29' fill='%23333' viewBox='0 0 20 20'%3E%3Cpath d='M10 4C9 4 9 5 9 5v.1A5 5 0 0 0 5.1 9H5s-1 0-1 1 1 1 1 1h.1A5 5 0 0 0 9 14.9v.1s0 1 1 1 1-1 1-1v-.1a5 5 0 0 0 3.9-3.9h.1s1 0 1-1-1-1-1-1h-.1A5 5 0 0 0 11 5.1V5s0-1-1-1m0 2.5a3.5 3.5 0 1 1 0 7 3.5 3.5 0 1 1 0-7'/%3E%3Ccircle cx='10' cy='10' r='2'/%3E%3C/svg%3E")}.maplibregl-ctrl button.maplibregl-ctrl-geolocate:disabled .maplibregl-ctrl-icon{background-image:url("data:image/svg+xml;charset=utf-8,%3Csvg xmlns='http://www.w3.org/2000/svg' width='29' height='29' fill='%23aaa' viewBox='0 0 20 20'%3E%3Cpath d='M10 4C9 4 9 5 9 5v.1A5 5 0 0 0 5.1 9H5s-1 0-1 1 1 1 1 1h.1A5 5 0 0 0 9 14.9v.1s0 1 1 1 1-1 1-1v-.1a5 5 0 0 0 3.9-3.9h.1s1 0 1-1-1-1-1-1h-.1A5 5 0 0 0 11 5.1V5s0-1-1-1m0 2.5a3.5 3.5 0 1 1 0 7 3.5 3.5 0 1 1 0-7'/%3E%3Ccircle cx='10' cy='10' r='2'/%3E%3Cpath fill='red' d='m14 5 1 1-9 9-1-1z'/%3E%3C/svg%3E")}.maplibregl-ctrl button.maplibregl-ctrl-geolocate.maplibregl-ctrl-geolocate-active .maplibregl-ctrl-icon{background-image:url("data:image/svg+xml;charset=utf-8,%3Csvg xmlns='http://www.w3.org/2000/svg' width='29' height='29' fill='%2333b5e5' viewBox='0 0 20 20'%3E%3Cpath d='M10 4C9 4 9 5 9 5v.1A5 5 0 0 0 5.1 9H5s-1 0-1 1 1 1 1 1h.1A5 5 0 0 0 9 14.9v.1s0 1 1 1 1-1 1-1v-.1a5 5 0 0 0 3.9-3.9h.1s1 0 1-1-1-1-1-1h-.1A5 5 0 0 0 11 5.1V5s0-1-1-1m0 2.5a3.5 3.5 0 1 1 0 7 3.5 3.5 0 1 1 0-7'/%3E%3Ccircle cx='10' cy='10' r='2'/%3E%3C/svg%3E")}.maplibregl-ctrl button.maplibregl-ctrl-geolocate.maplibregl-ctrl-geolocate-active-error .maplibregl-ctrl-icon{background-image:url("data:image/svg+xml;charset=utf-8,%3Csvg xmlns='http://www.w3.org/2000/svg' width='29' height='29' fill='%23e58978' viewBox='0 0 20 20'%3E%3Cpath d='M10 4C9 4 9 5 9 5v.1A5 5 0 0 0 5.1 9H5s-1 0-1 1 1 1 1 1h.1A5 5 0 0 0 9 14.9v.1s0 1 1 1 1-1 1-1v-.1a5 5 0 0 0 3.9-3.9h.1s1 0 1-1-1-1-1-1h-.1A5 5 0 0 0 11 5.1V5s0-1-1-1m0 2.5a3.5 3.5 0 1 1 0 7 3.5 3.5 0 1 1 0-7'/%3E%3Ccircle cx='10' cy='10' r='2'/%3E%3C/svg%3E")}.maplibregl-ctrl button.maplibregl-ctrl-geolocate.maplibregl-ctrl-geolocate-background .maplibregl-ctrl-icon{background-image:url("data:image/svg+xml;charset=utf-8,%3Csvg xmlns='http://www.w3.org/2000/svg' width='29' height='29' fill='%2333b5e5' viewBox='0 0 20 20'%3E%3Cpath d='M10 4C9 4 9 5 9 5v.1A5 5 0 0 0 5.1 9H5s-1 0-1 1 1 1 1 1h.1A5 5 0 0 0 9 14.9v.1s0 1 1 1 1-1 1-1v-.1a5 5 0 0 0 3.9-3.9h.1s1 0 1-1-1-1-1-1h-.1A5 5 0 0 0 11 5.1V5s0-1-1-1m0 2.5a3.5 3.5 0 1 1 0 7 3.5 3.5 0 1 1 0-7'/%3E%3C/svg%3E")}.maplibregl-ctrl button.maplibregl-ctrl-geolocate.maplibregl-ctrl-geolocate-background-error .maplibregl-ctrl-icon{background-image:url("data:image/svg+xml;charset=utf-8,%3Csvg xmlns='http://www.w3.org/2000/svg' width='29' height='29' fill='%23e54e33' viewBox='0 0 20 20'%3E%3Cpath d='M10 4C9 4 9 5 9 5v.1A5 5 0 0 0 5.1 9H5s-1 0-1 1 1 1 1 1h.1A5 5 0 0 0 9 14.9v.1s0 1 1 1 1-1 1-1v-.1a5 5 0 0 0 3.9-3.9h.1s1 0 1-1-1-1-1-1h-.1A5 5 0 0 0 11 5.1V5s0-1-1-1m0 2.5a3.5 3.5 0 1 1 0 7 3.5 3.5 0 1 1 0-7'/%3E%3C/svg%3E")}.maplibregl-ctrl button.maplibregl-ctrl-geolocate.maplibregl-ctrl-geolocate-waiting .maplibregl-ctrl-icon{animation:maplibregl-spin 2s linear infinite}@media (forced-colors:active){.maplibregl-ctrl button.maplibregl-ctrl-geolocate .maplibregl-ctrl-icon{background-image:url("data:image/svg+xml;charset=utf-8,%3Csvg xmlns='http://www.w3.org/2000/svg' width='29' height='29' fill='%23fff' viewBox='0 0 20 20'%3E%3Cpath d='M10 4C9 4 9 5 9 5v.1A5 5 0 0 0 5.1 9H5s-1 0-1 1 1 1 1 1h.1A5 5 0 0 0 9 14.9v.1s0 1 1 1 1-1 1-1v-.1a5 5 0 0 0 3.9-3.9h.1s1 0 1-1-1-1-1-1h-.1A5 5 0 0 0 11 5.1V5s0-1-1-1m0 2.5a3.5 3.5 0 1 1 0 7 3.5 3.5 0 1 1 0-7'/%3E%3Ccircle cx='10' cy='10' r='2'/%3E%3C/svg%3E")}.maplibregl-ctrl button.maplibregl-ctrl-geolocate:disabled .maplibregl-ctrl-icon{background-image:url("data:image/svg+xml;charset=utf-8,%3Csvg xmlns='http://www.w3.org/2000/svg' width='29' height='29' fill='%23999' viewBox='0 0 20 20'%3E%3Cpath d='M10 4C9 4 9 5 9 5v.1A5 5 0 0 0 5.1 9H5s-1 0-1 1 1 1 1 1h.1A5 5 0 0 0 9 14.9v.1s0 1 1 1 1-1 1-1v-.1a5 5 0 0 0 3.9-3.9h.1s1 0 1-1-1-1-1-1h-.1A5 5 0 0 0 11 5.1V5s0-1-1-1m0 2.5a3.5 3.5 0 1 1 0 7 3.5 3.5 0 1 1 0-7'/%3E%3Ccircle cx='10' cy='10' r='2'/%3E%3Cpath fill='red' d='m14 5 1 1-9 9-1-1z'/%3E%3C/svg%3E")}.maplibregl-ctrl button.maplibregl-ctrl-geolocate.maplibregl-ctrl-geolocate-active .maplibregl-ctrl-icon{background-image:url("data:image/svg+xml;charset=utf-8,%3Csvg xmlns='http://www.w3.org/2000/svg' width='29' height='29' fill='%2333b5e5' viewBox='0 0 20 20'%3E%3Cpath d='M10 4C9 4 9 5 9 5v.1A5 5 0 0 0 5.1 9H5s-1 0-1 1 1 1 1 1h.1A5 5 0 0 0 9 14.9v.1s0 1 1 1 1-1 1-1v-.1a5 5 0 0 0 3.9-3.9h.1s1 0 1-1-1-1-1-1h-.1A5 5 0 0 0 11 5.1V5s0-1-1-1m0 2.5a3.5 3.5 0 1 1 0 7 3.5 3.5 0 1 1 0-7'/%3E%3Ccircle cx='10' cy='10' r='2'/%3E%3C/svg%3E")}.maplibregl-ctrl button.maplibregl-ctrl-geolocate.maplibregl-ctrl-geolocate-active-error .maplibregl-ctrl-icon{background-image:url("data:image/svg+xml;charset=utf-8,%3Csvg xmlns='http://www.w3.org/2000/svg' width='29' height='29' fill='%23e58978' viewBox='0 0 20 20'%3E%3Cpath d='M10 4C9 4 9 5 9 5v.1A5 5 0 0 0 5.1 9H5s-1 0-1 1 1 1 1 1h.1A5 5 0 0 0 9 14.9v.1s0 1 1 1 1-1 1-1v-.1a5 5 0 0 0 3.9-3.9h.1s1 0 1-1-1-1-1-1h-.1A5 5 0 0 0 11 5.1V5s0-1-1-1m0 2.5a3.5 3.5 0 1 1 0 7 3.5 3.5 0 1 1 0-7'/%3E%3Ccircle cx='10' cy='10' r='2'/%3E%3C/svg%3E")}.maplibregl-ctrl button.maplibregl-ctrl-geolocate.maplibregl-ctrl-geolocate-background .maplibregl-ctrl-icon{background-image:url("data:image/svg+xml;charset=utf-8,%3Csvg xmlns='http://www.w3.org/2000/svg' width='29' height='29' fill='%2333b5e5' viewBox='0 0 20 20'%3E%3Cpath d='M10 4C9 4 9 5 9 5v.1A5 5 0 0 0 5.1 9H5s-1 0-1 1 1 1 1 1h.1A5 5 0 0 0 9 14.9v.1s0 1 1 1 1-1 1-1v-.1a5 5 0 0 0 3.9-3.9h.1s1 0 1-1-1-1-1-1h-.1A5 5 0 0 0 11 5.1V5s0-1-1-1m0 2.5a3.5 3.5 0 1 1 0 7 3.5 3.5 0 1 1 0-7'/%3E%3C/svg%3E")}.maplibregl-ctrl button.maplibregl-ctrl-geolocate.maplibregl-ctrl-geolocate-background-error .maplibregl-ctrl-icon{background-image:url("data:image/svg+xml;charset=utf-8,%3Csvg xmlns='http://www.w3.org/2000/svg' width='29' height='29' fill='%23e54e33' viewBox='0 0 20 20'%3E%3Cpath d='M10 4C9 4 9 5 9 5v.1A5 5 0 0 0 5.1 9H5s-1 0-1 1 1 1 1 1h.1A5 5 0 0 0 9 14.9v.1s0 1 1 1 1-1 1-1v-.1a5 5 0 0 0 3.9-3.9h.1s1 0 1-1-1-1-1-1h-.1A5 5 0 0 0 11 5.1V5s0-1-1-1m0 2.5a3.5 3.5 0 1 1 0 7 3.5 3.5 0 1 1 0-7'/%3E%3C/svg%3E")}}@media (forced-colors:active) and (prefers-color-scheme:light){.maplibregl-ctrl button.maplibregl-ctrl-geolocate .maplibregl-ctrl-icon{background-image:url("data:image/svg+xml;charset=utf-8,%3Csvg xmlns='http://www.w3.org/2000/svg' width='29' height='29' viewBox='0 0 20 20'%3E%3Cpath d='M10 4C9 4 9 5 9 5v.1A5 5 0 0 0 5.1 9H5s-1 0-1 1 1 1 1 1h.1A5 5 0 0 0 9 14.9v.1s0 1 1 1 1-1 1-1v-.1a5 5 0 0 0 3.9-3.9h.1s1 0 1-1-1-1-1-1h-.1A5 5 0 0 0 11 5.1V5s0-1-1-1m0 2.5a3.5 3.5 0 1 1 0 7 3.5 3.5 0 1 1 0-7'/%3E%3Ccircle cx='10' cy='10' r='2'/%3E%3C/svg%3E")}.maplibregl-ctrl button.maplibregl-ctrl-geolocate:disabled .maplibregl-ctrl-icon{background-image:url("data:image/svg+xml;charset=utf-8,%3Csvg xmlns='http://www.w3.org/2000/svg' width='29' height='29' fill='%23666' viewBox='0 0 20 20'%3E%3Cpath d='M10 4C9 4 9 5 9 5v.1A5 5 0 0 0 5.1 9H5s-1 0-1 1 1 1 1 1h.1A5 5 0 0 0 9 14.9v.1s0 1 1 1 1-1 1-1v-.1a5 5 0 0 0 3.9-3.9h.1s1 0 1-1-1-1-1-1h-.1A5 5 0 0 0 11 5.1V5s0-1-1-1m0 2.5a3.5 3.5 0 1 1 0 7 3.5 3.5 0 1 1 0-7'/%3E%3Ccircle cx='10' cy='10' r='2'/%3E%3Cpath fill='red' d='m14 5 1 1-9 9-1-1z'/%3E%3C/svg%3E")}}@keyframes maplibregl-spin{0%{transform:rotate(0deg)}to{transform:rotate(1turn)}}a.maplibregl-ctrl-logo{background-image:url("data:image/svg+xml;charset=utf-8,%3Csvg xmlns='http://www.w3.org/2000/svg' width='88' height='23' fill='none'%3E%3Cpath fill='%23000' fill-opacity='.4' fill-rule='evenodd' d='M17.408 16.796h-1.827l2.501-12.095h.198l3.324 6.533.988 2.19.988-2.19 3.258-6.533h.181l2.6 12.095h-1.81l-1.218-5.644-.362-1.71-.658 1.71-2.929 5.644h-.098l-2.914-5.644-.757-1.71-.345 1.71zm1.958-3.42-.726 3.663a1.255 1.255 0 0 1-1.232 1.011h-1.827a1.255 1.255 0 0 1-1.229-1.509l2.501-12.095a1.255 1.255 0 0 1 1.23-1.001h.197a1.25 1.25 0 0 1 1.12.685l3.19 6.273 3.125-6.263a1.25 1.25 0 0 1 1.123-.695h.181a1.255 1.255 0 0 1 1.227.991l1.443 6.71a5 5 0 0 1 .314-.787l.009-.016a4.6 4.6 0 0 1 1.777-1.887c.782-.46 1.668-.667 2.611-.667a4.6 4.6 0 0 1 1.7.32l.306.134c.21-.16.474-.256.759-.256h1.694a1.255 1.255 0 0 1 1.212.925 1.255 1.255 0 0 1 1.212-.925h1.711c.284 0 .545.094.755.252.613-.3 1.312-.45 2.075-.45 1.356 0 2.557.445 3.482 1.4q.47.48.763 1.064V4.701a1.255 1.255 0 0 1 1.255-1.255h1.86A1.255 1.255 0 0 1 54.44 4.7v9.194h2.217c.19 0 .37.043.532.118v-4.77c0-.356.147-.678.385-.906a2.42 2.42 0 0 1-.682-1.71c0-.665.267-1.253.735-1.7a2.45 2.45 0 0 1 1.722-.674 2.43 2.43 0 0 1 1.705.675q.318.302.504.683V4.7a1.255 1.255 0 0 1 1.255-1.255h1.744A1.255 1.255 0 0 1 65.812 4.7v3.335a4.8 4.8 0 0 1 1.526-.246c.938 0 1.817.214 2.59.69a4.47 4.47 0 0 1 1.67 1.743v-.98a1.255 1.255 0 0 1 1.256-1.256h1.777c.233 0 .451.064.639.174a3.4 3.4 0 0 1 1.567-.372c.346 0 .861.02 1.285.232a1.25 1.25 0 0 1 .689 1.004 4.7 4.7 0 0 1 .853-.588c.795-.44 1.675-.647 2.61-.647 1.385 0 2.65.39 3.525 1.396.836.938 1.168 2.173 1.168 3.528q-.001.515-.056 1.051a1.255 1.255 0 0 1-.947 1.09l.408.952a1.255 1.255 0 0 1-.477 1.552c-.418.268-.92.463-1.458.612-.613.171-1.304.244-2.049.244-1.06 0-2.043-.207-2.886-.698l-.015-.008c-.798-.48-1.419-1.135-1.818-1.963l-.004-.008a5.8 5.8 0 0 1-.548-2.512q0-.429.053-.843a1.3 1.3 0 0 1-.333-.086l-.166-.004c-.223 0-.426.062-.643.228-.03.024-.142.139-.142.59v3.883a1.255 1.255 0 0 1-1.256 1.256h-1.777a1.255 1.255 0 0 1-1.256-1.256V15.69l-.032.057a4.8 4.8 0 0 1-1.86 1.833 5.04 5.04 0 0 1-2.484.634 4.5 4.5 0 0 1-1.935-.424 1.25 1.25 0 0 1-.764.258h-1.71a1.255 1.255 0 0 1-1.256-1.255V7.687a2.4 2.4 0 0 1-.428.625c.253.23.412.561.412.93v7.553a1.255 1.255 0 0 1-1.256 1.255h-1.843a1.25 1.25 0 0 1-.894-.373c-.228.23-.544.373-.894.373H51.32a1.255 1.255 0 0 1-1.256-1.255v-1.251l-.061.117a4.7 4.7 0 0 1-1.782 1.884 4.77 4.77 0 0 1-2.485.67 5.6 5.6 0 0 1-1.485-.188l.009 2.764a1.255 1.255 0 0 1-1.255 1.259h-1.729a1.255 1.255 0 0 1-1.255-1.255v-3.537a1.255 1.255 0 0 1-1.167.793h-1.679a1.25 1.25 0 0 1-.77-.263 4.5 4.5 0 0 1-1.945.429c-.885 0-1.724-.21-2.495-.632l-.017-.01a5 5 0 0 1-1.081-.836 1.255 1.255 0 0 1-1.254 1.312h-1.81a1.255 1.255 0 0 1-1.228-.99l-.782-3.625-2.044 3.939a1.25 1.25 0 0 1-1.115.676h-.098a1.25 1.25 0 0 1-1.116-.68l-2.061-3.994zM35.92 16.63l.207-.114.223-.15q.493-.356.735-.785l.061-.118.033 1.332h1.678V9.242h-1.694l-.033 1.267q-.133-.329-.526-.658l-.032-.028a3.2 3.2 0 0 0-.668-.428l-.27-.12a3.3 3.3 0 0 0-1.235-.23q-1.136-.001-1.974.493a3.36 3.36 0 0 0-1.3 1.382q-.445.89-.444 2.074 0 1.2.51 2.107a3.8 3.8 0 0 0 1.382 1.381 3.9 3.9 0 0 0 1.893.477q.795 0 1.455-.33zm-2.789-5.38q-.576.675-.575 1.762 0 1.102.559 1.794.576.675 1.645.675a2.25 2.25 0 0 0 .934-.19 2.2 2.2 0 0 0 .468-.29l.178-.161a2.2 2.2 0 0 0 .397-.561q.244-.5.244-1.15v-.115q0-.708-.296-1.267l-.043-.077a2.2 2.2 0 0 0-.633-.709l-.13-.086-.047-.028a2.1 2.1 0 0 0-1.073-.285q-1.052 0-1.629.692zm2.316 2.706c.163-.17.28-.407.28-.83v-.114c0-.292-.06-.508-.15-.68a.96.96 0 0 0-.353-.389.85.85 0 0 0-.464-.127c-.4 0-.56.114-.664.239l-.01.012c-.148.174-.275.45-.275.945 0 .506.122.801.27.99.097.11.266.224.68.224.303 0 .504-.09.687-.269zm7.545 1.705a2.6 2.6 0 0 0 .331.423q.319.33.755.548l.173.074q.65.255 1.49.255 1.02 0 1.844-.493a3.45 3.45 0 0 0 1.316-1.4q.493-.904.493-2.089 0-1.909-.988-2.913-.988-1.02-2.584-1.02-.898 0-1.575.347a3 3 0 0 0-.415.262l-.199.166a3.4 3.4 0 0 0-.64.82V9.242h-1.712v11.553h1.729l-.017-5.134zm.53-1.138q.206.29.48.5l.155.11.053.034q.51.296 1.119.297 1.07 0 1.645-.675.577-.69.576-1.762 0-1.119-.576-1.777-.558-.675-1.645-.675-.435 0-.835.16a2 2 0 0 0-.284.136 2 2 0 0 0-.363.254 2.2 2.2 0 0 0-.46.569l-.082.162a2.6 2.6 0 0 0-.213 1.072v.115q0 .707.296 1.267l.135.211zm.964-.818a1.1 1.1 0 0 0 .367.385.94.94 0 0 0 .476.118c.423 0 .59-.117.687-.23.159-.194.28-.478.28-.95 0-.53-.133-.8-.266-.952l-.021-.025c-.078-.094-.231-.221-.68-.221a1 1 0 0 0-.503.135l-.012.007a.86.86 0 0 0-.335.343c-.073.133-.132.324-.132.614v.115a1.4 1.4 0 0 0 .14.66zm15.7-6.222q.347-.346.346-.856a1.05 1.05 0 0 0-.345-.79 1.18 1.18 0 0 0-.84-.329q-.51 0-.855.33a1.05 1.05 0 0 0-.346.79q0 .51.346.855.345.346.856.346.51 0 .839-.346zm4.337 9.314.033-1.332q.191.403.59.747l.098.081a4 4 0 0 0 .316.224l.223.122a3.2 3.2 0 0 0 1.44.322 3.8 3.8 0 0 0 1.875-.477 3.5 3.5 0 0 0 1.382-1.366q.527-.89.526-2.09 0-1.184-.444-2.073a3.24 3.24 0 0 0-1.283-1.399q-.823-.51-1.942-.51a3.5 3.5 0 0 0-1.527.344l-.086.043-.165.09a3 3 0 0 0-.33.214q-.432.315-.656.707a2 2 0 0 0-.099.198l.082-1.283V4.701h-1.744v12.095zm.473-2.509a2.5 2.5 0 0 0 .566.7q.117.098.245.18l.144.08a2.1 2.1 0 0 0 .975.232q1.07 0 1.645-.675.576-.69.576-1.778 0-1.102-.576-1.777-.56-.691-1.645-.692a2.2 2.2 0 0 0-1.015.235q-.22.113-.415.282l-.15.142a2.1 2.1 0 0 0-.42.594q-.223.479-.223 1.1v.115q0 .705.293 1.26zm2.616-.293c.157-.191.28-.479.28-.967 0-.51-.13-.79-.276-.961l-.021-.026c-.082-.1-.232-.225-.67-.225a.87.87 0 0 0-.681.279l-.012.011c-.154.155-.274.38-.274.807v.115c0 .285.057.499.144.669a1.1 1.1 0 0 0 .367.405c.137.082.28.123.455.123.423 0 .59-.118.686-.23zm8.266-3.013q.345-.13.724-.14l.069-.002q.493 0 .642.099l.247-1.794q-.196-.099-.717-.099a2.3 2.3 0 0 0-.545.063 2 2 0 0 0-.411.148 2.2 2.2 0 0 0-.4.249 2.5 2.5 0 0 0-.485.499 2.7 2.7 0 0 0-.32.581l-.05.137v-1.48h-1.778v7.553h1.777v-3.884q0-.546.159-.943a1.5 1.5 0 0 1 .466-.636 2.5 2.5 0 0 1 .399-.253 2 2 0 0 1 .224-.099zm9.784 2.656.05-.922q0-1.743-.856-2.698-.838-.97-2.584-.97-1.119-.001-2.007.493a3.46 3.46 0 0 0-1.4 1.382q-.493.906-.493 2.106 0 1.07.428 1.975.428.89 1.332 1.432.906.526 2.255.526.973 0 1.668-.185l.044-.012.135-.04q.613-.184.984-.421l-.542-1.267q-.3.162-.642.274l-.297.087q-.51.131-1.3.131-.954 0-1.497-.444a1.6 1.6 0 0 1-.192-.193q-.366-.44-.512-1.234l-.004-.021zm-5.427-1.256-.003.022h3.752v-.138q-.011-.727-.288-1.118a1 1 0 0 0-.156-.176q-.46-.428-1.316-.428-.986 0-1.494.604-.379.45-.494 1.234zm-27.053 2.77V4.7h-1.86v12.095h5.333V15.15zm7.103-5.908v7.553h-1.843V9.242h1.843z'/%3E%3Cpath fill='%23fff' d='m19.63 11.151-.757-1.71-.345 1.71-1.12 5.644h-1.827L18.083 4.7h.197l3.325 6.533.988 2.19.988-2.19L26.839 4.7h.181l2.6 12.095h-1.81l-1.218-5.644-.362-1.71-.658 1.71-2.93 5.644h-.098l-2.913-5.644zm14.836 5.81q-1.02 0-1.893-.478a3.8 3.8 0 0 1-1.381-1.382q-.51-.906-.51-2.106 0-1.185.444-2.074a3.36 3.36 0 0 1 1.3-1.382q.839-.494 1.974-.494a3.3 3.3 0 0 1 1.234.231 3.3 3.3 0 0 1 .97.575q.396.33.527.659l.033-1.267h1.694v7.553H37.18l-.033-1.332q-.279.593-1.02 1.053a3.17 3.17 0 0 1-1.662.444zm.296-1.482q.938 0 1.58-.642.642-.66.642-1.711v-.115q0-.708-.296-1.267a2.2 2.2 0 0 0-.807-.872 2.1 2.1 0 0 0-1.119-.313q-1.053 0-1.629.692-.575.675-.575 1.76 0 1.103.559 1.795.577.675 1.645.675zm6.521-6.237h1.711v1.4q.906-1.597 2.83-1.597 1.596 0 2.584 1.02.988 1.005.988 2.914 0 1.185-.493 2.09a3.46 3.46 0 0 1-1.316 1.399 3.5 3.5 0 0 1-1.844.493q-.954 0-1.662-.329a2.67 2.67 0 0 1-1.086-.97l.017 5.134h-1.728zm4.048 6.22q1.07 0 1.645-.674.577-.69.576-1.762 0-1.119-.576-1.777-.558-.675-1.645-.675-.592 0-1.12.296-.51.28-.822.823-.296.527-.296 1.234v.115q0 .708.296 1.267.313.543.823.855.51.296 1.119.297z'/%3E%3Cpath fill='%23e1e3e9' d='M51.325 4.7h1.86v10.45h3.473v1.646h-5.333zm7.12 4.542h1.843v7.553h-1.843zm.905-1.415a1.16 1.16 0 0 1-.856-.346 1.17 1.17 0 0 1-.346-.856 1.05 1.05 0 0 1 .346-.79q.346-.329.856-.329.494 0 .839.33a1.05 1.05 0 0 1 .345.79 1.16 1.16 0 0 1-.345.855q-.33.346-.84.346zm7.875 9.133a3.17 3.17 0 0 1-1.662-.444q-.723-.46-1.004-1.053l-.033 1.332h-1.71V4.701h1.743v4.657l-.082 1.283q.279-.658 1.086-1.119a3.5 3.5 0 0 1 1.778-.477q1.119 0 1.942.51a3.24 3.24 0 0 1 1.283 1.4q.445.888.444 2.072 0 1.201-.526 2.09a3.5 3.5 0 0 1-1.382 1.366 3.8 3.8 0 0 1-1.876.477zm-.296-1.481q1.069 0 1.645-.675.577-.69.577-1.778 0-1.102-.577-1.776-.56-.691-1.645-.692a2.12 2.12 0 0 0-1.58.659q-.642.641-.642 1.694v.115q0 .71.296 1.267a2.4 2.4 0 0 0 .807.872 2.1 2.1 0 0 0 1.119.313zm5.927-6.237h1.777v1.481q.263-.757.856-1.217a2.14 2.14 0 0 1 1.349-.46q.527 0 .724.098l-.247 1.794q-.149-.099-.642-.099-.774 0-1.416.494-.626.493-.626 1.58v3.883h-1.777V9.242zm9.534 7.718q-1.35 0-2.255-.526-.904-.543-1.332-1.432a4.6 4.6 0 0 1-.428-1.975q0-1.2.493-2.106a3.46 3.46 0 0 1 1.4-1.382q.889-.495 2.007-.494 1.744 0 2.584.97.855.956.856 2.7 0 .444-.05.92h-5.43q.18 1.005.708 1.45.542.443 1.497.443.79 0 1.3-.131a4 4 0 0 0 .938-.362l.542 1.267q-.411.263-1.119.46-.708.198-1.711.197zm1.596-4.558q.016-1.02-.444-1.432-.46-.428-1.316-.428-1.728 0-1.991 1.86z'/%3E%3Cpath d='M5.074 15.948a.484.657 0 0 0-.486.659v1.84a.484.657 0 0 0 .486.659h4.101a.484.657 0 0 0 .486-.659v-1.84a.484.657 0 0 0-.486-.659zm3.56 1.16H5.617v.838h3.017z' style='fill:%23fff;fill-rule:evenodd;stroke-width:1.03600001'/%3E%3Cg style='stroke-width:1.12603545'%3E%3Cpath d='M-9.408-1.416c-3.833-.025-7.056 2.912-7.08 6.615-.02 3.08 1.653 4.832 3.107 6.268.903.892 1.721 1.74 2.32 2.902l-.525-.004c-.543-.003-.992.304-1.24.639a1.87 1.87 0 0 0-.362 1.121l-.011 1.877c-.003.402.104.787.347 1.125.244.338.688.653 1.23.656l4.142.028c.542.003.99-.306 1.238-.641a1.87 1.87 0 0 0 .363-1.121l.012-1.875a1.87 1.87 0 0 0-.348-1.127c-.243-.338-.688-.653-1.23-.656l-.518-.004c.597-1.145 1.425-1.983 2.348-2.87 1.473-1.414 3.18-3.149 3.2-6.226-.016-3.59-2.923-6.684-6.993-6.707m-.006 1.1v.002c3.274.02 5.92 2.532 5.9 5.6-.017 2.706-1.39 4.026-2.863 5.44-1.034.994-2.118 2.033-2.814 3.633-.018.041-.052.055-.075.065q-.013.004-.02.01a.34.34 0 0 1-.226.084.34.34 0 0 1-.224-.086l-.092-.077c-.699-1.615-1.768-2.669-2.781-3.67-1.454-1.435-2.797-2.762-2.78-5.478.02-3.067 2.7-5.545 5.975-5.523m-.02 2.826c-1.62-.01-2.944 1.315-2.955 2.96-.01 1.646 1.295 2.988 2.916 2.999h.002c1.621.01 2.943-1.316 2.953-2.961.011-1.646-1.294-2.988-2.916-2.998m-.005 1.1c1.017.006 1.829.83 1.822 1.89s-.83 1.874-1.848 1.867c-1.018-.006-1.829-.83-1.822-1.89s.83-1.874 1.848-1.868m-2.155 11.857 4.14.025c.271.002.49.305.487.676l-.013 1.875c-.003.37-.224.67-.495.668l-4.14-.025c-.27-.002-.487-.306-.485-.676l.012-1.875c.003-.37.224-.67.494-.668' style='color:%23000;font-style:normal;font-variant:normal;font-weight:400;font-stretch:normal;font-size:medium;line-height:normal;font-family:sans-serif;font-variant-ligatures:normal;font-variant-position:normal;font-variant-caps:normal;font-variant-numeric:normal;font-variant-alternates:normal;font-feature-settings:normal;text-indent:0;text-align:start;text-decoration:none;text-decoration-line:none;text-decoration-style:solid;text-decoration-color:%23000;letter-spacing:normal;word-spacing:normal;text-transform:none;writing-mode:lr-tb;direction:ltr;text-orientation:mixed;dominant-baseline:auto;baseline-shift:baseline;text-anchor:start;white-space:normal;shape-padding:0;clip-rule:evenodd;display:inline;overflow:visible;visibility:visible;opacity:1;isolation:auto;mix-blend-mode:normal;color-interpolation:sRGB;color-interpolation-filters:linearRGB;solid-color:%23000;solid-opacity:1;vector-effect:none;fill:%23000;fill-opacity:.4;fill-rule:evenodd;stroke:none;stroke-width:2.47727823;stroke-linecap:butt;stroke-linejoin:miter;stroke-miterlimit:4;stroke-dasharray:none;stroke-dashoffset:0;stroke-opacity:1;color-rendering:auto;image-rendering:auto;shape-rendering:auto;text-rendering:auto' transform='translate(15.553 2.85)scale(.88807)'/%3E%3Cpath d='M-9.415-.316C-12.69-.338-15.37 2.14-15.39 5.207c-.017 2.716 1.326 4.041 2.78 5.477 1.013 1 2.081 2.055 2.78 3.67l.092.076a.34.34 0 0 0 .225.086.34.34 0 0 0 .227-.083l.019-.01c.022-.009.057-.024.074-.064.697-1.6 1.78-2.64 2.814-3.634 1.473-1.414 2.847-2.733 2.864-5.44.02-3.067-2.627-5.58-5.901-5.601m-.057 8.784c1.621.011 2.944-1.315 2.955-2.96.01-1.646-1.295-2.988-2.916-2.999-1.622-.01-2.945 1.315-2.955 2.96s1.295 2.989 2.916 3' style='clip-rule:evenodd;fill:%23e1e3e9;fill-opacity:1;fill-rule:evenodd;stroke:none;stroke-width:2.47727823;stroke-miterlimit:4;stroke-dasharray:none;stroke-opacity:.4' transform='translate(15.553 2.85)scale(.88807)'/%3E%3Cpath d='M-11.594 15.465c-.27-.002-.492.297-.494.668l-.012 1.876c-.003.371.214.673.485.675l4.14.027c.271.002.492-.298.495-.668l.012-1.877c.003-.37-.215-.672-.485-.674z' style='clip-rule:evenodd;fill:%23fff;fill-opacity:1;fill-rule:evenodd;stroke:none;stroke-width:2.47727823;stroke-miterlimit:4;stroke-dasharray:none;stroke-opacity:.4' transform='translate(15.553 2.85)scale(.88807)'/%3E%3C/g%3E%3C/svg%3E");background-repeat:no-repeat;cursor:pointer;display:block;height:23px;margin:0 0 -4px -4px;overflow:hidden;width:88px}a.maplibregl-ctrl-logo.maplibregl-compact{width:14px}@media (forced-colors:active){a.maplibregl-ctrl-logo{background-color:transparent;background-image:url("data:image/svg+xml;charset=utf-8,%3Csvg xmlns='http://www.w3.org/2000/svg' width='88' height='23' fill='none'%3E%3Cpath fill='%23000' fill-opacity='.4' fill-rule='evenodd' d='M17.408 16.796h-1.827l2.501-12.095h.198l3.324 6.533.988 2.19.988-2.19 3.258-6.533h.181l2.6 12.095h-1.81l-1.218-5.644-.362-1.71-.658 1.71-2.929 5.644h-.098l-2.914-5.644-.757-1.71-.345 1.71zm1.958-3.42-.726 3.663a1.255 1.255 0 0 1-1.232 1.011h-1.827a1.255 1.255 0 0 1-1.229-1.509l2.501-12.095a1.255 1.255 0 0 1 1.23-1.001h.197a1.25 1.25 0 0 1 1.12.685l3.19 6.273 3.125-6.263a1.25 1.25 0 0 1 1.123-.695h.181a1.255 1.255 0 0 1 1.227.991l1.443 6.71a5 5 0 0 1 .314-.787l.009-.016a4.6 4.6 0 0 1 1.777-1.887c.782-.46 1.668-.667 2.611-.667a4.6 4.6 0 0 1 1.7.32l.306.134c.21-.16.474-.256.759-.256h1.694a1.255 1.255 0 0 1 1.212.925 1.255 1.255 0 0 1 1.212-.925h1.711c.284 0 .545.094.755.252.613-.3 1.312-.45 2.075-.45 1.356 0 2.557.445 3.482 1.4q.47.48.763 1.064V4.701a1.255 1.255 0 0 1 1.255-1.255h1.86A1.255 1.255 0 0 1 54.44 4.7v9.194h2.217c.19 0 .37.043.532.118v-4.77c0-.356.147-.678.385-.906a2.42 2.42 0 0 1-.682-1.71c0-.665.267-1.253.735-1.7a2.45 2.45 0 0 1 1.722-.674 2.43 2.43 0 0 1 1.705.675q.318.302.504.683V4.7a1.255 1.255 0 0 1 1.255-1.255h1.744A1.255 1.255 0 0 1 65.812 4.7v3.335a4.8 4.8 0 0 1 1.526-.246c.938 0 1.817.214 2.59.69a4.47 4.47 0 0 1 1.67 1.743v-.98a1.255 1.255 0 0 1 1.256-1.256h1.777c.233 0 .451.064.639.174a3.4 3.4 0 0 1 1.567-.372c.346 0 .861.02 1.285.232a1.25 1.25 0 0 1 .689 1.004 4.7 4.7 0 0 1 .853-.588c.795-.44 1.675-.647 2.61-.647 1.385 0 2.65.39 3.525 1.396.836.938 1.168 2.173 1.168 3.528q-.001.515-.056 1.051a1.255 1.255 0 0 1-.947 1.09l.408.952a1.255 1.255 0 0 1-.477 1.552c-.418.268-.92.463-1.458.612-.613.171-1.304.244-2.049.244-1.06 0-2.043-.207-2.886-.698l-.015-.008c-.798-.48-1.419-1.135-1.818-1.963l-.004-.008a5.8 5.8 0 0 1-.548-2.512q0-.429.053-.843a1.3 1.3 0 0 1-.333-.086l-.166-.004c-.223 0-.426.062-.643.228-.03.024-.142.139-.142.59v3.883a1.255 1.255 0 0 1-1.256 1.256h-1.777a1.255 1.255 0 0 1-1.256-1.256V15.69l-.032.057a4.8 4.8 0 0 1-1.86 1.833 5.04 5.04 0 0 1-2.484.634 4.5 4.5 0 0 1-1.935-.424 1.25 1.25 0 0 1-.764.258h-1.71a1.255 1.255 0 0 1-1.256-1.255V7.687a2.4 2.4 0 0 1-.428.625c.253.23.412.561.412.93v7.553a1.255 1.255 0 0 1-1.256 1.255h-1.843a1.25 1.25 0 0 1-.894-.373c-.228.23-.544.373-.894.373H51.32a1.255 1.255 0 0 1-1.256-1.255v-1.251l-.061.117a4.7 4.7 0 0 1-1.782 1.884 4.77 4.77 0 0 1-2.485.67 5.6 5.6 0 0 1-1.485-.188l.009 2.764a1.255 1.255 0 0 1-1.255 1.259h-1.729a1.255 1.255 0 0 1-1.255-1.255v-3.537a1.255 1.255 0 0 1-1.167.793h-1.679a1.25 1.25 0 0 1-.77-.263 4.5 4.5 0 0 1-1.945.429c-.885 0-1.724-.21-2.495-.632l-.017-.01a5 5 0 0 1-1.081-.836 1.255 1.255 0 0 1-1.254 1.312h-1.81a1.255 1.255 0 0 1-1.228-.99l-.782-3.625-2.044 3.939a1.25 1.25 0 0 1-1.115.676h-.098a1.25 1.25 0 0 1-1.116-.68l-2.061-3.994zM35.92 16.63l.207-.114.223-.15q.493-.356.735-.785l.061-.118.033 1.332h1.678V9.242h-1.694l-.033 1.267q-.133-.329-.526-.658l-.032-.028a3.2 3.2 0 0 0-.668-.428l-.27-.12a3.3 3.3 0 0 0-1.235-.23q-1.136-.001-1.974.493a3.36 3.36 0 0 0-1.3 1.382q-.445.89-.444 2.074 0 1.2.51 2.107a3.8 3.8 0 0 0 1.382 1.381 3.9 3.9 0 0 0 1.893.477q.795 0 1.455-.33zm-2.789-5.38q-.576.675-.575 1.762 0 1.102.559 1.794.576.675 1.645.675a2.25 2.25 0 0 0 .934-.19 2.2 2.2 0 0 0 .468-.29l.178-.161a2.2 2.2 0 0 0 .397-.561q.244-.5.244-1.15v-.115q0-.708-.296-1.267l-.043-.077a2.2 2.2 0 0 0-.633-.709l-.13-.086-.047-.028a2.1 2.1 0 0 0-1.073-.285q-1.052 0-1.629.692zm2.316 2.706c.163-.17.28-.407.28-.83v-.114c0-.292-.06-.508-.15-.68a.96.96 0 0 0-.353-.389.85.85 0 0 0-.464-.127c-.4 0-.56.114-.664.239l-.01.012c-.148.174-.275.45-.275.945 0 .506.122.801.27.99.097.11.266.224.68.224.303 0 .504-.09.687-.269zm7.545 1.705a2.6 2.6 0 0 0 .331.423q.319.33.755.548l.173.074q.65.255 1.49.255 1.02 0 1.844-.493a3.45 3.45 0 0 0 1.316-1.4q.493-.904.493-2.089 0-1.909-.988-2.913-.988-1.02-2.584-1.02-.898 0-1.575.347a3 3 0 0 0-.415.262l-.199.166a3.4 3.4 0 0 0-.64.82V9.242h-1.712v11.553h1.729l-.017-5.134zm.53-1.138q.206.29.48.5l.155.11.053.034q.51.296 1.119.297 1.07 0 1.645-.675.577-.69.576-1.762 0-1.119-.576-1.777-.558-.675-1.645-.675-.435 0-.835.16a2 2 0 0 0-.284.136 2 2 0 0 0-.363.254 2.2 2.2 0 0 0-.46.569l-.082.162a2.6 2.6 0 0 0-.213 1.072v.115q0 .707.296 1.267l.135.211zm.964-.818a1.1 1.1 0 0 0 .367.385.94.94 0 0 0 .476.118c.423 0 .59-.117.687-.23.159-.194.28-.478.28-.95 0-.53-.133-.8-.266-.952l-.021-.025c-.078-.094-.231-.221-.68-.221a1 1 0 0 0-.503.135l-.012.007a.86.86 0 0 0-.335.343c-.073.133-.132.324-.132.614v.115a1.4 1.4 0 0 0 .14.66zm15.7-6.222q.347-.346.346-.856a1.05 1.05 0 0 0-.345-.79 1.18 1.18 0 0 0-.84-.329q-.51 0-.855.33a1.05 1.05 0 0 0-.346.79q0 .51.346.855.345.346.856.346.51 0 .839-.346zm4.337 9.314.033-1.332q.191.403.59.747l.098.081a4 4 0 0 0 .316.224l.223.122a3.2 3.2 0 0 0 1.44.322 3.8 3.8 0 0 0 1.875-.477 3.5 3.5 0 0 0 1.382-1.366q.527-.89.526-2.09 0-1.184-.444-2.073a3.24 3.24 0 0 0-1.283-1.399q-.823-.51-1.942-.51a3.5 3.5 0 0 0-1.527.344l-.086.043-.165.09a3 3 0 0 0-.33.214q-.432.315-.656.707a2 2 0 0 0-.099.198l.082-1.283V4.701h-1.744v12.095zm.473-2.509a2.5 2.5 0 0 0 .566.7q.117.098.245.18l.144.08a2.1 2.1 0 0 0 .975.232q1.07 0 1.645-.675.576-.69.576-1.778 0-1.102-.576-1.777-.56-.691-1.645-.692a2.2 2.2 0 0 0-1.015.235q-.22.113-.415.282l-.15.142a2.1 2.1 0 0 0-.42.594q-.223.479-.223 1.1v.115q0 .705.293 1.26zm2.616-.293c.157-.191.28-.479.28-.967 0-.51-.13-.79-.276-.961l-.021-.026c-.082-.1-.232-.225-.67-.225a.87.87 0 0 0-.681.279l-.012.011c-.154.155-.274.38-.274.807v.115c0 .285.057.499.144.669a1.1 1.1 0 0 0 .367.405c.137.082.28.123.455.123.423 0 .59-.118.686-.23zm8.266-3.013q.345-.13.724-.14l.069-.002q.493 0 .642.099l.247-1.794q-.196-.099-.717-.099a2.3 2.3 0 0 0-.545.063 2 2 0 0 0-.411.148 2.2 2.2 0 0 0-.4.249 2.5 2.5 0 0 0-.485.499 2.7 2.7 0 0 0-.32.581l-.05.137v-1.48h-1.778v7.553h1.777v-3.884q0-.546.159-.943a1.5 1.5 0 0 1 .466-.636 2.5 2.5 0 0 1 .399-.253 2 2 0 0 1 .224-.099zm9.784 2.656.05-.922q0-1.743-.856-2.698-.838-.97-2.584-.97-1.119-.001-2.007.493a3.46 3.46 0 0 0-1.4 1.382q-.493.906-.493 2.106 0 1.07.428 1.975.428.89 1.332 1.432.906.526 2.255.526.973 0 1.668-.185l.044-.012.135-.04q.613-.184.984-.421l-.542-1.267q-.3.162-.642.274l-.297.087q-.51.131-1.3.131-.954 0-1.497-.444a1.6 1.6 0 0 1-.192-.193q-.366-.44-.512-1.234l-.004-.021zm-5.427-1.256-.003.022h3.752v-.138q-.011-.727-.288-1.118a1 1 0 0 0-.156-.176q-.46-.428-1.316-.428-.986 0-1.494.604-.379.45-.494 1.234zm-27.053 2.77V4.7h-1.86v12.095h5.333V15.15zm7.103-5.908v7.553h-1.843V9.242h1.843z'/%3E%3Cpath fill='%23fff' d='m19.63 11.151-.757-1.71-.345 1.71-1.12 5.644h-1.827L18.083 4.7h.197l3.325 6.533.988 2.19.988-2.19L26.839 4.7h.181l2.6 12.095h-1.81l-1.218-5.644-.362-1.71-.658 1.71-2.93 5.644h-.098l-2.913-5.644zm14.836 5.81q-1.02 0-1.893-.478a3.8 3.8 0 0 1-1.381-1.382q-.51-.906-.51-2.106 0-1.185.444-2.074a3.36 3.36 0 0 1 1.3-1.382q.839-.494 1.974-.494a3.3 3.3 0 0 1 1.234.231 3.3 3.3 0 0 1 .97.575q.396.33.527.659l.033-1.267h1.694v7.553H37.18l-.033-1.332q-.279.593-1.02 1.053a3.17 3.17 0 0 1-1.662.444zm.296-1.482q.938 0 1.58-.642.642-.66.642-1.711v-.115q0-.708-.296-1.267a2.2 2.2 0 0 0-.807-.872 2.1 2.1 0 0 0-1.119-.313q-1.053 0-1.629.692-.575.675-.575 1.76 0 1.103.559 1.795.577.675 1.645.675zm6.521-6.237h1.711v1.4q.906-1.597 2.83-1.597 1.596 0 2.584 1.02.988 1.005.988 2.914 0 1.185-.493 2.09a3.46 3.46 0 0 1-1.316 1.399 3.5 3.5 0 0 1-1.844.493q-.954 0-1.662-.329a2.67 2.67 0 0 1-1.086-.97l.017 5.134h-1.728zm4.048 6.22q1.07 0 1.645-.674.577-.69.576-1.762 0-1.119-.576-1.777-.558-.675-1.645-.675-.592 0-1.12.296-.51.28-.822.823-.296.527-.296 1.234v.115q0 .708.296 1.267.313.543.823.855.51.296 1.119.297z'/%3E%3Cpath fill='%23e1e3e9' d='M51.325 4.7h1.86v10.45h3.473v1.646h-5.333zm7.12 4.542h1.843v7.553h-1.843zm.905-1.415a1.16 1.16 0 0 1-.856-.346 1.17 1.17 0 0 1-.346-.856 1.05 1.05 0 0 1 .346-.79q.346-.329.856-.329.494 0 .839.33a1.05 1.05 0 0 1 .345.79 1.16 1.16 0 0 1-.345.855q-.33.346-.84.346zm7.875 9.133a3.17 3.17 0 0 1-1.662-.444q-.723-.46-1.004-1.053l-.033 1.332h-1.71V4.701h1.743v4.657l-.082 1.283q.279-.658 1.086-1.119a3.5 3.5 0 0 1 1.778-.477q1.119 0 1.942.51a3.24 3.24 0 0 1 1.283 1.4q.445.888.444 2.072 0 1.201-.526 2.09a3.5 3.5 0 0 1-1.382 1.366 3.8 3.8 0 0 1-1.876.477zm-.296-1.481q1.069 0 1.645-.675.577-.69.577-1.778 0-1.102-.577-1.776-.56-.691-1.645-.692a2.12 2.12 0 0 0-1.58.659q-.642.641-.642 1.694v.115q0 .71.296 1.267a2.4 2.4 0 0 0 .807.872 2.1 2.1 0 0 0 1.119.313zm5.927-6.237h1.777v1.481q.263-.757.856-1.217a2.14 2.14 0 0 1 1.349-.46q.527 0 .724.098l-.247 1.794q-.149-.099-.642-.099-.774 0-1.416.494-.626.493-.626 1.58v3.883h-1.777V9.242zm9.534 7.718q-1.35 0-2.255-.526-.904-.543-1.332-1.432a4.6 4.6 0 0 1-.428-1.975q0-1.2.493-2.106a3.46 3.46 0 0 1 1.4-1.382q.889-.495 2.007-.494 1.744 0 2.584.97.855.956.856 2.7 0 .444-.05.92h-5.43q.18 1.005.708 1.45.542.443 1.497.443.79 0 1.3-.131a4 4 0 0 0 .938-.362l.542 1.267q-.411.263-1.119.46-.708.198-1.711.197zm1.596-4.558q.016-1.02-.444-1.432-.46-.428-1.316-.428-1.728 0-1.991 1.86z'/%3E%3Cpath d='M5.074 15.948a.484.657 0 0 0-.486.659v1.84a.484.657 0 0 0 .486.659h4.101a.484.657 0 0 0 .486-.659v-1.84a.484.657 0 0 0-.486-.659zm3.56 1.16H5.617v.838h3.017z' style='fill:%23fff;fill-rule:evenodd;stroke-width:1.03600001'/%3E%3Cg style='stroke-width:1.12603545'%3E%3Cpath d='M-9.408-1.416c-3.833-.025-7.056 2.912-7.08 6.615-.02 3.08 1.653 4.832 3.107 6.268.903.892 1.721 1.74 2.32 2.902l-.525-.004c-.543-.003-.992.304-1.24.639a1.87 1.87 0 0 0-.362 1.121l-.011 1.877c-.003.402.104.787.347 1.125.244.338.688.653 1.23.656l4.142.028c.542.003.99-.306 1.238-.641a1.87 1.87 0 0 0 .363-1.121l.012-1.875a1.87 1.87 0 0 0-.348-1.127c-.243-.338-.688-.653-1.23-.656l-.518-.004c.597-1.145 1.425-1.983 2.348-2.87 1.473-1.414 3.18-3.149 3.2-6.226-.016-3.59-2.923-6.684-6.993-6.707m-.006 1.1v.002c3.274.02 5.92 2.532 5.9 5.6-.017 2.706-1.39 4.026-2.863 5.44-1.034.994-2.118 2.033-2.814 3.633-.018.041-.052.055-.075.065q-.013.004-.02.01a.34.34 0 0 1-.226.084.34.34 0 0 1-.224-.086l-.092-.077c-.699-1.615-1.768-2.669-2.781-3.67-1.454-1.435-2.797-2.762-2.78-5.478.02-3.067 2.7-5.545 5.975-5.523m-.02 2.826c-1.62-.01-2.944 1.315-2.955 2.96-.01 1.646 1.295 2.988 2.916 2.999h.002c1.621.01 2.943-1.316 2.953-2.961.011-1.646-1.294-2.988-2.916-2.998m-.005 1.1c1.017.006 1.829.83 1.822 1.89s-.83 1.874-1.848 1.867c-1.018-.006-1.829-.83-1.822-1.89s.83-1.874 1.848-1.868m-2.155 11.857 4.14.025c.271.002.49.305.487.676l-.013 1.875c-.003.37-.224.67-.495.668l-4.14-.025c-.27-.002-.487-.306-.485-.676l.012-1.875c.003-.37.224-.67.494-.668' style='color:%23000;font-style:normal;font-variant:normal;font-weight:400;font-stretch:normal;font-size:medium;line-height:normal;font-family:sans-serif;font-variant-ligatures:normal;font-variant-position:normal;font-variant-caps:normal;font-variant-numeric:normal;font-variant-alternates:normal;font-feature-settings:normal;text-indent:0;text-align:start;text-decoration:none;text-decoration-line:none;text-decoration-style:solid;text-decoration-color:%23000;letter-spacing:normal;word-spacing:normal;text-transform:none;writing-mode:lr-tb;direction:ltr;text-orientation:mixed;dominant-baseline:auto;baseline-shift:baseline;text-anchor:start;white-space:normal;shape-padding:0;clip-rule:evenodd;display:inline;overflow:visible;visibility:visible;opacity:1;isolation:auto;mix-blend-mode:normal;color-interpolation:sRGB;color-interpolation-filters:linearRGB;solid-color:%23000;solid-opacity:1;vector-effect:none;fill:%23000;fill-opacity:.4;fill-rule:evenodd;stroke:none;stroke-width:2.47727823;stroke-linecap:butt;stroke-linejoin:miter;stroke-miterlimit:4;stroke-dasharray:none;stroke-dashoffset:0;stroke-opacity:1;color-rendering:auto;image-rendering:auto;shape-rendering:auto;text-rendering:auto' transform='translate(15.553 2.85)scale(.88807)'/%3E%3Cpath d='M-9.415-.316C-12.69-.338-15.37 2.14-15.39 5.207c-.017 2.716 1.326 4.041 2.78 5.477 1.013 1 2.081 2.055 2.78 3.67l.092.076a.34.34 0 0 0 .225.086.34.34 0 0 0 .227-.083l.019-.01c.022-.009.057-.024.074-.064.697-1.6 1.78-2.64 2.814-3.634 1.473-1.414 2.847-2.733 2.864-5.44.02-3.067-2.627-5.58-5.901-5.601m-.057 8.784c1.621.011 2.944-1.315 2.955-2.96.01-1.646-1.295-2.988-2.916-2.999-1.622-.01-2.945 1.315-2.955 2.96s1.295 2.989 2.916 3' style='clip-rule:evenodd;fill:%23e1e3e9;fill-opacity:1;fill-rule:evenodd;stroke:none;stroke-width:2.47727823;stroke-miterlimit:4;stroke-dasharray:none;stroke-opacity:.4' transform='translate(15.553 2.85)scale(.88807)'/%3E%3Cpath d='M-11.594 15.465c-.27-.002-.492.297-.494.668l-.012 1.876c-.003.371.214.673.485.675l4.14.027c.271.002.492-.298.495-.668l.012-1.877c.003-.37-.215-.672-.485-.674z' style='clip-rule:evenodd;fill:%23fff;fill-opacity:1;fill-rule:evenodd;stroke:none;stroke-width:2.47727823;stroke-miterlimit:4;stroke-dasharray:none;stroke-opacity:.4' transform='translate(15.553 2.85)scale(.88807)'/%3E%3C/g%3E%3C/svg%3E")}}@media (forced-colors:active) and (prefers-color-scheme:light){a.maplibregl-ctrl-logo{background-image:url("data:image/svg+xml;charset=utf-8,%3Csvg xmlns='http://www.w3.org/2000/svg' width='88' height='23' fill='none'%3E%3Cpath fill='%23000' fill-opacity='.4' fill-rule='evenodd' d='M17.408 16.796h-1.827l2.501-12.095h.198l3.324 6.533.988 2.19.988-2.19 3.258-6.533h.181l2.6 12.095h-1.81l-1.218-5.644-.362-1.71-.658 1.71-2.929 5.644h-.098l-2.914-5.644-.757-1.71-.345 1.71zm1.958-3.42-.726 3.663a1.255 1.255 0 0 1-1.232 1.011h-1.827a1.255 1.255 0 0 1-1.229-1.509l2.501-12.095a1.255 1.255 0 0 1 1.23-1.001h.197a1.25 1.25 0 0 1 1.12.685l3.19 6.273 3.125-6.263a1.25 1.25 0 0 1 1.123-.695h.181a1.255 1.255 0 0 1 1.227.991l1.443 6.71a5 5 0 0 1 .314-.787l.009-.016a4.6 4.6 0 0 1 1.777-1.887c.782-.46 1.668-.667 2.611-.667a4.6 4.6 0 0 1 1.7.32l.306.134c.21-.16.474-.256.759-.256h1.694a1.255 1.255 0 0 1 1.212.925 1.255 1.255 0 0 1 1.212-.925h1.711c.284 0 .545.094.755.252.613-.3 1.312-.45 2.075-.45 1.356 0 2.557.445 3.482 1.4q.47.48.763 1.064V4.701a1.255 1.255 0 0 1 1.255-1.255h1.86A1.255 1.255 0 0 1 54.44 4.7v9.194h2.217c.19 0 .37.043.532.118v-4.77c0-.356.147-.678.385-.906a2.42 2.42 0 0 1-.682-1.71c0-.665.267-1.253.735-1.7a2.45 2.45 0 0 1 1.722-.674 2.43 2.43 0 0 1 1.705.675q.318.302.504.683V4.7a1.255 1.255 0 0 1 1.255-1.255h1.744A1.255 1.255 0 0 1 65.812 4.7v3.335a4.8 4.8 0 0 1 1.526-.246c.938 0 1.817.214 2.59.69a4.47 4.47 0 0 1 1.67 1.743v-.98a1.255 1.255 0 0 1 1.256-1.256h1.777c.233 0 .451.064.639.174a3.4 3.4 0 0 1 1.567-.372c.346 0 .861.02 1.285.232a1.25 1.25 0 0 1 .689 1.004 4.7 4.7 0 0 1 .853-.588c.795-.44 1.675-.647 2.61-.647 1.385 0 2.65.39 3.525 1.396.836.938 1.168 2.173 1.168 3.528q-.001.515-.056 1.051a1.255 1.255 0 0 1-.947 1.09l.408.952a1.255 1.255 0 0 1-.477 1.552c-.418.268-.92.463-1.458.612-.613.171-1.304.244-2.049.244-1.06 0-2.043-.207-2.886-.698l-.015-.008c-.798-.48-1.419-1.135-1.818-1.963l-.004-.008a5.8 5.8 0 0 1-.548-2.512q0-.429.053-.843a1.3 1.3 0 0 1-.333-.086l-.166-.004c-.223 0-.426.062-.643.228-.03.024-.142.139-.142.59v3.883a1.255 1.255 0 0 1-1.256 1.256h-1.777a1.255 1.255 0 0 1-1.256-1.256V15.69l-.032.057a4.8 4.8 0 0 1-1.86 1.833 5.04 5.04 0 0 1-2.484.634 4.5 4.5 0 0 1-1.935-.424 1.25 1.25 0 0 1-.764.258h-1.71a1.255 1.255 0 0 1-1.256-1.255V7.687a2.4 2.4 0 0 1-.428.625c.253.23.412.561.412.93v7.553a1.255 1.255 0 0 1-1.256 1.255h-1.843a1.25 1.25 0 0 1-.894-.373c-.228.23-.544.373-.894.373H51.32a1.255 1.255 0 0 1-1.256-1.255v-1.251l-.061.117a4.7 4.7 0 0 1-1.782 1.884 4.77 4.77 0 0 1-2.485.67 5.6 5.6 0 0 1-1.485-.188l.009 2.764a1.255 1.255 0 0 1-1.255 1.259h-1.729a1.255 1.255 0 0 1-1.255-1.255v-3.537a1.255 1.255 0 0 1-1.167.793h-1.679a1.25 1.25 0 0 1-.77-.263 4.5 4.5 0 0 1-1.945.429c-.885 0-1.724-.21-2.495-.632l-.017-.01a5 5 0 0 1-1.081-.836 1.255 1.255 0 0 1-1.254 1.312h-1.81a1.255 1.255 0 0 1-1.228-.99l-.782-3.625-2.044 3.939a1.25 1.25 0 0 1-1.115.676h-.098a1.25 1.25 0 0 1-1.116-.68l-2.061-3.994zM35.92 16.63l.207-.114.223-.15q.493-.356.735-.785l.061-.118.033 1.332h1.678V9.242h-1.694l-.033 1.267q-.133-.329-.526-.658l-.032-.028a3.2 3.2 0 0 0-.668-.428l-.27-.12a3.3 3.3 0 0 0-1.235-.23q-1.136-.001-1.974.493a3.36 3.36 0 0 0-1.3 1.382q-.445.89-.444 2.074 0 1.2.51 2.107a3.8 3.8 0 0 0 1.382 1.381 3.9 3.9 0 0 0 1.893.477q.795 0 1.455-.33zm-2.789-5.38q-.576.675-.575 1.762 0 1.102.559 1.794.576.675 1.645.675a2.25 2.25 0 0 0 .934-.19 2.2 2.2 0 0 0 .468-.29l.178-.161a2.2 2.2 0 0 0 .397-.561q.244-.5.244-1.15v-.115q0-.708-.296-1.267l-.043-.077a2.2 2.2 0 0 0-.633-.709l-.13-.086-.047-.028a2.1 2.1 0 0 0-1.073-.285q-1.052 0-1.629.692zm2.316 2.706c.163-.17.28-.407.28-.83v-.114c0-.292-.06-.508-.15-.68a.96.96 0 0 0-.353-.389.85.85 0 0 0-.464-.127c-.4 0-.56.114-.664.239l-.01.012c-.148.174-.275.45-.275.945 0 .506.122.801.27.99.097.11.266.224.68.224.303 0 .504-.09.687-.269zm7.545 1.705a2.6 2.6 0 0 0 .331.423q.319.33.755.548l.173.074q.65.255 1.49.255 1.02 0 1.844-.493a3.45 3.45 0 0 0 1.316-1.4q.493-.904.493-2.089 0-1.909-.988-2.913-.988-1.02-2.584-1.02-.898 0-1.575.347a3 3 0 0 0-.415.262l-.199.166a3.4 3.4 0 0 0-.64.82V9.242h-1.712v11.553h1.729l-.017-5.134zm.53-1.138q.206.29.48.5l.155.11.053.034q.51.296 1.119.297 1.07 0 1.645-.675.577-.69.576-1.762 0-1.119-.576-1.777-.558-.675-1.645-.675-.435 0-.835.16a2 2 0 0 0-.284.136 2 2 0 0 0-.363.254 2.2 2.2 0 0 0-.46.569l-.082.162a2.6 2.6 0 0 0-.213 1.072v.115q0 .707.296 1.267l.135.211zm.964-.818a1.1 1.1 0 0 0 .367.385.94.94 0 0 0 .476.118c.423 0 .59-.117.687-.23.159-.194.28-.478.28-.95 0-.53-.133-.8-.266-.952l-.021-.025c-.078-.094-.231-.221-.68-.221a1 1 0 0 0-.503.135l-.012.007a.86.86 0 0 0-.335.343c-.073.133-.132.324-.132.614v.115a1.4 1.4 0 0 0 .14.66zm15.7-6.222q.347-.346.346-.856a1.05 1.05 0 0 0-.345-.79 1.18 1.18 0 0 0-.84-.329q-.51 0-.855.33a1.05 1.05 0 0 0-.346.79q0 .51.346.855.345.346.856.346.51 0 .839-.346zm4.337 9.314.033-1.332q.191.403.59.747l.098.081a4 4 0 0 0 .316.224l.223.122a3.2 3.2 0 0 0 1.44.322 3.8 3.8 0 0 0 1.875-.477 3.5 3.5 0 0 0 1.382-1.366q.527-.89.526-2.09 0-1.184-.444-2.073a3.24 3.24 0 0 0-1.283-1.399q-.823-.51-1.942-.51a3.5 3.5 0 0 0-1.527.344l-.086.043-.165.09a3 3 0 0 0-.33.214q-.432.315-.656.707a2 2 0 0 0-.099.198l.082-1.283V4.701h-1.744v12.095zm.473-2.509a2.5 2.5 0 0 0 .566.7q.117.098.245.18l.144.08a2.1 2.1 0 0 0 .975.232q1.07 0 1.645-.675.576-.69.576-1.778 0-1.102-.576-1.777-.56-.691-1.645-.692a2.2 2.2 0 0 0-1.015.235q-.22.113-.415.282l-.15.142a2.1 2.1 0 0 0-.42.594q-.223.479-.223 1.1v.115q0 .705.293 1.26zm2.616-.293c.157-.191.28-.479.28-.967 0-.51-.13-.79-.276-.961l-.021-.026c-.082-.1-.232-.225-.67-.225a.87.87 0 0 0-.681.279l-.012.011c-.154.155-.274.38-.274.807v.115c0 .285.057.499.144.669a1.1 1.1 0 0 0 .367.405c.137.082.28.123.455.123.423 0 .59-.118.686-.23zm8.266-3.013q.345-.13.724-.14l.069-.002q.493 0 .642.099l.247-1.794q-.196-.099-.717-.099a2.3 2.3 0 0 0-.545.063 2 2 0 0 0-.411.148 2.2 2.2 0 0 0-.4.249 2.5 2.5 0 0 0-.485.499 2.7 2.7 0 0 0-.32.581l-.05.137v-1.48h-1.778v7.553h1.777v-3.884q0-.546.159-.943a1.5 1.5 0 0 1 .466-.636 2.5 2.5 0 0 1 .399-.253 2 2 0 0 1 .224-.099zm9.784 2.656.05-.922q0-1.743-.856-2.698-.838-.97-2.584-.97-1.119-.001-2.007.493a3.46 3.46 0 0 0-1.4 1.382q-.493.906-.493 2.106 0 1.07.428 1.975.428.89 1.332 1.432.906.526 2.255.526.973 0 1.668-.185l.044-.012.135-.04q.613-.184.984-.421l-.542-1.267q-.3.162-.642.274l-.297.087q-.51.131-1.3.131-.954 0-1.497-.444a1.6 1.6 0 0 1-.192-.193q-.366-.44-.512-1.234l-.004-.021zm-5.427-1.256-.003.022h3.752v-.138q-.011-.727-.288-1.118a1 1 0 0 0-.156-.176q-.46-.428-1.316-.428-.986 0-1.494.604-.379.45-.494 1.234zm-27.053 2.77V4.7h-1.86v12.095h5.333V15.15zm7.103-5.908v7.553h-1.843V9.242h1.843z'/%3E%3Cpath fill='%23fff' d='m19.63 11.151-.757-1.71-.345 1.71-1.12 5.644h-1.827L18.083 4.7h.197l3.325 6.533.988 2.19.988-2.19L26.839 4.7h.181l2.6 12.095h-1.81l-1.218-5.644-.362-1.71-.658 1.71-2.93 5.644h-.098l-2.913-5.644zm14.836 5.81q-1.02 0-1.893-.478a3.8 3.8 0 0 1-1.381-1.382q-.51-.906-.51-2.106 0-1.185.444-2.074a3.36 3.36 0 0 1 1.3-1.382q.839-.494 1.974-.494a3.3 3.3 0 0 1 1.234.231 3.3 3.3 0 0 1 .97.575q.396.33.527.659l.033-1.267h1.694v7.553H37.18l-.033-1.332q-.279.593-1.02 1.053a3.17 3.17 0 0 1-1.662.444zm.296-1.482q.938 0 1.58-.642.642-.66.642-1.711v-.115q0-.708-.296-1.267a2.2 2.2 0 0 0-.807-.872 2.1 2.1 0 0 0-1.119-.313q-1.053 0-1.629.692-.575.675-.575 1.76 0 1.103.559 1.795.577.675 1.645.675zm6.521-6.237h1.711v1.4q.906-1.597 2.83-1.597 1.596 0 2.584 1.02.988 1.005.988 2.914 0 1.185-.493 2.09a3.46 3.46 0 0 1-1.316 1.399 3.5 3.5 0 0 1-1.844.493q-.954 0-1.662-.329a2.67 2.67 0 0 1-1.086-.97l.017 5.134h-1.728zm4.048 6.22q1.07 0 1.645-.674.577-.69.576-1.762 0-1.119-.576-1.777-.558-.675-1.645-.675-.592 0-1.12.296-.51.28-.822.823-.296.527-.296 1.234v.115q0 .708.296 1.267.313.543.823.855.51.296 1.119.297z'/%3E%3Cpath fill='%23e1e3e9' d='M51.325 4.7h1.86v10.45h3.473v1.646h-5.333zm7.12 4.542h1.843v7.553h-1.843zm.905-1.415a1.16 1.16 0 0 1-.856-.346 1.17 1.17 0 0 1-.346-.856 1.05 1.05 0 0 1 .346-.79q.346-.329.856-.329.494 0 .839.33a1.05 1.05 0 0 1 .345.79 1.16 1.16 0 0 1-.345.855q-.33.346-.84.346zm7.875 9.133a3.17 3.17 0 0 1-1.662-.444q-.723-.46-1.004-1.053l-.033 1.332h-1.71V4.701h1.743v4.657l-.082 1.283q.279-.658 1.086-1.119a3.5 3.5 0 0 1 1.778-.477q1.119 0 1.942.51a3.24 3.24 0 0 1 1.283 1.4q.445.888.444 2.072 0 1.201-.526 2.09a3.5 3.5 0 0 1-1.382 1.366 3.8 3.8 0 0 1-1.876.477zm-.296-1.481q1.069 0 1.645-.675.577-.69.577-1.778 0-1.102-.577-1.776-.56-.691-1.645-.692a2.12 2.12 0 0 0-1.58.659q-.642.641-.642 1.694v.115q0 .71.296 1.267a2.4 2.4 0 0 0 .807.872 2.1 2.1 0 0 0 1.119.313zm5.927-6.237h1.777v1.481q.263-.757.856-1.217a2.14 2.14 0 0 1 1.349-.46q.527 0 .724.098l-.247 1.794q-.149-.099-.642-.099-.774 0-1.416.494-.626.493-.626 1.58v3.883h-1.777V9.242zm9.534 7.718q-1.35 0-2.255-.526-.904-.543-1.332-1.432a4.6 4.6 0 0 1-.428-1.975q0-1.2.493-2.106a3.46 3.46 0 0 1 1.4-1.382q.889-.495 2.007-.494 1.744 0 2.584.97.855.956.856 2.7 0 .444-.05.92h-5.43q.18 1.005.708 1.45.542.443 1.497.443.79 0 1.3-.131a4 4 0 0 0 .938-.362l.542 1.267q-.411.263-1.119.46-.708.198-1.711.197zm1.596-4.558q.016-1.02-.444-1.432-.46-.428-1.316-.428-1.728 0-1.991 1.86z'/%3E%3Cpath d='M5.074 15.948a.484.657 0 0 0-.486.659v1.84a.484.657 0 0 0 .486.659h4.101a.484.657 0 0 0 .486-.659v-1.84a.484.657 0 0 0-.486-.659zm3.56 1.16H5.617v.838h3.017z' style='fill:%23fff;fill-rule:evenodd;stroke-width:1.03600001'/%3E%3Cg style='stroke-width:1.12603545'%3E%3Cpath d='M-9.408-1.416c-3.833-.025-7.056 2.912-7.08 6.615-.02 3.08 1.653 4.832 3.107 6.268.903.892 1.721 1.74 2.32 2.902l-.525-.004c-.543-.003-.992.304-1.24.639a1.87 1.87 0 0 0-.362 1.121l-.011 1.877c-.003.402.104.787.347 1.125.244.338.688.653 1.23.656l4.142.028c.542.003.99-.306 1.238-.641a1.87 1.87 0 0 0 .363-1.121l.012-1.875a1.87 1.87 0 0 0-.348-1.127c-.243-.338-.688-.653-1.23-.656l-.518-.004c.597-1.145 1.425-1.983 2.348-2.87 1.473-1.414 3.18-3.149 3.2-6.226-.016-3.59-2.923-6.684-6.993-6.707m-.006 1.1v.002c3.274.02 5.92 2.532 5.9 5.6-.017 2.706-1.39 4.026-2.863 5.44-1.034.994-2.118 2.033-2.814 3.633-.018.041-.052.055-.075.065q-.013.004-.02.01a.34.34 0 0 1-.226.084.34.34 0 0 1-.224-.086l-.092-.077c-.699-1.615-1.768-2.669-2.781-3.67-1.454-1.435-2.797-2.762-2.78-5.478.02-3.067 2.7-5.545 5.975-5.523m-.02 2.826c-1.62-.01-2.944 1.315-2.955 2.96-.01 1.646 1.295 2.988 2.916 2.999h.002c1.621.01 2.943-1.316 2.953-2.961.011-1.646-1.294-2.988-2.916-2.998m-.005 1.1c1.017.006 1.829.83 1.822 1.89s-.83 1.874-1.848 1.867c-1.018-.006-1.829-.83-1.822-1.89s.83-1.874 1.848-1.868m-2.155 11.857 4.14.025c.271.002.49.305.487.676l-.013 1.875c-.003.37-.224.67-.495.668l-4.14-.025c-.27-.002-.487-.306-.485-.676l.012-1.875c.003-.37.224-.67.494-.668' style='color:%23000;font-style:normal;font-variant:normal;font-weight:400;font-stretch:normal;font-size:medium;line-height:normal;font-family:sans-serif;font-variant-ligatures:normal;font-variant-position:normal;font-variant-caps:normal;font-variant-numeric:normal;font-variant-alternates:normal;font-feature-settings:normal;text-indent:0;text-align:start;text-decoration:none;text-decoration-line:none;text-decoration-style:solid;text-decoration-color:%23000;letter-spacing:normal;word-spacing:normal;text-transform:none;writing-mode:lr-tb;direction:ltr;text-orientation:mixed;dominant-baseline:auto;baseline-shift:baseline;text-anchor:start;white-space:normal;shape-padding:0;clip-rule:evenodd;display:inline;overflow:visible;visibility:visible;opacity:1;isolation:auto;mix-blend-mode:normal;color-interpolation:sRGB;color-interpolation-filters:linearRGB;solid-color:%23000;solid-opacity:1;vector-effect:none;fill:%23000;fill-opacity:.4;fill-rule:evenodd;stroke:none;stroke-width:2.47727823;stroke-linecap:butt;stroke-linejoin:miter;stroke-miterlimit:4;stroke-dasharray:none;stroke-dashoffset:0;stroke-opacity:1;color-rendering:auto;image-rendering:auto;shape-rendering:auto;text-rendering:auto' transform='translate(15.553 2.85)scale(.88807)'/%3E%3Cpath d='M-9.415-.316C-12.69-.338-15.37 2.14-15.39 5.207c-.017 2.716 1.326 4.041 2.78 5.477 1.013 1 2.081 2.055 2.78 3.67l.092.076a.34.34 0 0 0 .225.086.34.34 0 0 0 .227-.083l.019-.01c.022-.009.057-.024.074-.064.697-1.6 1.78-2.64 2.814-3.634 1.473-1.414 2.847-2.733 2.864-5.44.02-3.067-2.627-5.58-5.901-5.601m-.057 8.784c1.621.011 2.944-1.315 2.955-2.96.01-1.646-1.295-2.988-2.916-2.999-1.622-.01-2.945 1.315-2.955 2.96s1.295 2.989 2.916 3' style='clip-rule:evenodd;fill:%23e1e3e9;fill-opacity:1;fill-rule:evenodd;stroke:none;stroke-width:2.47727823;stroke-miterlimit:4;stroke-dasharray:none;stroke-opacity:.4' transform='translate(15.553 2.85)scale(.88807)'/%3E%3Cpath d='M-11.594 15.465c-.27-.002-.492.297-.494.668l-.012 1.876c-.003.371.214.673.485.675l4.14.027c.271.002.492-.298.495-.668l.012-1.877c.003-.37-.215-.672-.485-.674z' style='clip-rule:evenodd;fill:%23fff;fill-opacity:1;fill-rule:evenodd;stroke:none;stroke-width:2.47727823;stroke-miterlimit:4;stroke-dasharray:none;stroke-opacity:.4' transform='translate(15.553 2.85)scale(.88807)'/%3E%3C/g%3E%3C/svg%3E")}}.maplibregl-ctrl.maplibregl-ctrl-attrib{background-color:hsla(0,0%,100%,.5);margin:0;padding:0 5px}@media screen{.maplibregl-ctrl-attrib.maplibregl-compact{background-color:#fff;border-radius:12px;box-sizing:content-box;color:#000;margin:10px;min-height:20px;padding:2px 24px 2px 0;position:relative}.maplibregl-ctrl-attrib.maplibregl-compact-show{padding:2px 28px 2px 8px;visibility:visible}.maplibregl-ctrl-bottom-left>.maplibregl-ctrl-attrib.maplibregl-compact-show,.maplibregl-ctrl-top-left>.maplibregl-ctrl-attrib.maplibregl-compact-show{border-radius:12px;padding:2px 8px 2px 28px}.maplibregl-ctrl-attrib.maplibregl-compact .maplibregl-ctrl-attrib-inner{display:none}.maplibregl-ctrl-attrib-button{background-color:hsla(0,0%,100%,.5);background-image:url("data:image/svg+xml;charset=utf-8,%3Csvg xmlns='http://www.w3.org/2000/svg' width='24' height='24' fill-rule='evenodd' viewBox='0 0 20 20'%3E%3Cpath d='M4 10a6 6 0 1 0 12 0 6 6 0 1 0-12 0m5-3a1 1 0 1 0 2 0 1 1 0 1 0-2 0m0 3a1 1 0 1 1 2 0v3a1 1 0 1 1-2 0'/%3E%3C/svg%3E");border:0;border-radius:12px;box-sizing:border-box;cursor:pointer;display:none;height:24px;outline:none;position:absolute;right:0;top:0;width:24px}.maplibregl-ctrl-attrib summary.maplibregl-ctrl-attrib-button{-webkit-appearance:none;-moz-appearance:none;appearance:none;list-style:none}.maplibregl-ctrl-attrib summary.maplibregl-ctrl-attrib-button::-webkit-details-marker{display:none}.maplibregl-ctrl-bottom-left .maplibregl-ctrl-attrib-button,.maplibregl-ctrl-top-left .maplibregl-ctrl-attrib-button{left:0}.maplibregl-ctrl-attrib.maplibregl-compact .maplibregl-ctrl-attrib-button,.maplibregl-ctrl-attrib.maplibregl-compact-show .maplibregl-ctrl-attrib-inner{display:block}.maplibregl-ctrl-attrib.maplibregl-compact-show .maplibregl-ctrl-attrib-button{background-color:rgba(0,0,0,.05)}.maplibregl-ctrl-bottom-right>.maplibregl-ctrl-attrib.maplibregl-compact:after{bottom:0;right:0}.maplibregl-ctrl-top-right>.maplibregl-ctrl-attrib.maplibregl-compact:after{right:0;top:0}.maplibregl-ctrl-top-left>.maplibregl-ctrl-attrib.maplibregl-compact:after{left:0;top:0}.maplibregl-ctrl-bottom-left>.maplibregl-ctrl-attrib.maplibregl-compact:after{bottom:0;left:0}}@media screen and (forced-colors:active){.maplibregl-ctrl-attrib.maplibregl-compact:after{background-image:url("data:image/svg+xml;charset=utf-8,%3Csvg xmlns='http://www.w3.org/2000/svg' width='24' height='24' fill='%23fff' fill-rule='evenodd' viewBox='0 0 20 20'%3E%3Cpath d='M4 10a6 6 0 1 0 12 0 6 6 0 1 0-12 0m5-3a1 1 0 1 0 2 0 1 1 0 1 0-2 0m0 3a1 1 0 1 1 2 0v3a1 1 0 1 1-2 0'/%3E%3C/svg%3E")}}@media screen and (forced-colors:active) and (prefers-color-scheme:light){.maplibregl-ctrl-attrib.maplibregl-compact:after{background-image:url("data:image/svg+xml;charset=utf-8,%3Csvg xmlns='http://www.w3.org/2000/svg' width='24' height='24' fill-rule='evenodd' viewBox='0 0 20 20'%3E%3Cpath d='M4 10a6 6 0 1 0 12 0 6 6 0 1 0-12 0m5-3a1 1 0 1 0 2 0 1 1 0 1 0-2 0m0 3a1 1 0 1 1 2 0v3a1 1 0 1 1-2 0'/%3E%3C/svg%3E")}}.maplibregl-ctrl-attrib a{color:rgba(0,0,0,.75);text-decoration:none}.maplibregl-ctrl-attrib a:hover{color:inherit;text-decoration:underline}.maplibregl-attrib-empty{display:none}.maplibregl-ctrl-scale{background-color:hsla(0,0%,100%,.75);border:2px solid #333;border-top:#333;box-sizing:border-box;color:#333;font-size:10px;padding:0 5px;white-space:nowrap}.maplibregl-popup{display:flex;left:0;pointer-events:none;position:absolute;top:0;will-change:transform}.maplibregl-popup-anchor-top,.maplibregl-popup-anchor-top-left,.maplibregl-popup-anchor-top-right{flex-direction:column}.maplibregl-popup-anchor-bottom,.maplibregl-popup-anchor-bottom-left,.maplibregl-popup-anchor-bottom-right{flex-direction:column-reverse}.maplibregl-popup-anchor-left{flex-direction:row}.maplibregl-popup-anchor-right{flex-direction:row-reverse}.maplibregl-popup-tip{border:10px solid transparent;height:0;width:0;z-index:1}.maplibregl-popup-anchor-top .maplibregl-popup-tip{align-self:center;border-bottom-color:#fff;border-top:none}.maplibregl-popup-anchor-top-left .maplibregl-popup-tip{align-self:flex-start;border-bottom-color:#fff;border-left:none;border-top:none}.maplibregl-popup-anchor-top-right .maplibregl-popup-tip{align-self:flex-end;border-bottom-color:#fff;border-right:none;border-top:none}.maplibregl-popup-anchor-bottom .maplibregl-popup-tip{align-self:center;border-bottom:none;border-top-color:#fff}.maplibregl-popup-anchor-bottom-left .maplibregl-popup-tip{align-self:flex-start;border-bottom:none;border-left:none;border-top-color:#fff}.maplibregl-popup-anchor-bottom-right .maplibregl-popup-tip{align-self:flex-end;border-bottom:none;border-right:none;border-top-color:#fff}.maplibregl-popup-anchor-left .maplibregl-popup-tip{align-self:center;border-left:none;border-right-color:#fff}.maplibregl-popup-anchor-right .maplibregl-popup-tip{align-self:center;border-left-color:#fff;border-right:none}[dir=rtl] .maplibregl-popup-anchor-left{flex-direction:row-reverse}[dir=rtl] .maplibregl-popup-anchor-right{flex-direction:row}[dir=rtl] .maplibregl-popup-anchor-top-left .maplibregl-popup-tip{align-self:flex-end}[dir=rtl] .maplibregl-popup-anchor-top-right .maplibregl-popup-tip{align-self:flex-start}[dir=rtl] .maplibregl-popup-anchor-bottom-left .maplibregl-popup-tip{align-self:flex-end}[dir=rtl] .maplibregl-popup-anchor-bottom-right .maplibregl-popup-tip{align-self:flex-start}.maplibregl-popup-close-button{background-color:transparent;border:0;border-radius:0 3px 0 0;cursor:pointer;position:absolute;right:0;top:0}.maplibregl-popup-close-button:hover{background-color:rgba(0,0,0,.05)}.maplibregl-popup-content{background:#fff;border-radius:3px;box-shadow:0 1px 2px rgba(0,0,0,.1);padding:15px 10px;pointer-events:auto;position:relative}.maplibregl-popup-anchor-top-left .maplibregl-popup-content{border-top-left-radius:0}.maplibregl-popup-anchor-top-right .maplibregl-popup-content{border-top-right-radius:0}.maplibregl-popup-anchor-bottom-left .maplibregl-popup-content{border-bottom-left-radius:0}.maplibregl-popup-anchor-bottom-right .maplibregl-popup-content{border-bottom-right-radius:0}.maplibregl-popup-track-pointer{display:none}.maplibregl-popup-track-pointer *{pointer-events:none;-webkit-user-select:none;-moz-user-select:none;user-select:none}.maplibregl-map:hover .maplibregl-popup-track-pointer{display:flex}.maplibregl-map:active .maplibregl-popup-track-pointer{display:none}.maplibregl-marker{left:0;position:absolute;top:0;transition:opacity .2s;will-change:transform}.maplibregl-user-location-dot,.maplibregl-user-location-dot:before{background-color:#1da1f2;border-radius:50%;height:15px;width:15px}.maplibregl-user-location-dot:before{animation:maplibregl-user-location-dot-pulse 2s infinite;content:"";position:absolute}.maplibregl-user-location-dot:after{border:2px solid #fff;border-radius:50%;box-shadow:0 0 3px rgba(0,0,0,.35);box-sizing:border-box;content:"";height:19px;left:-2px;position:absolute;top:-2px;width:19px}@media (prefers-reduced-motion:reduce){.maplibregl-user-location-dot:before{animation:none}}@keyframes maplibregl-user-location-dot-pulse{0%{opacity:1;transform:scale(1)}70%{opacity:0;transform:scale(3)}to{opacity:0;transform:scale(1)}}.maplibregl-user-location-dot-stale{background-color:#aaa}.maplibregl-user-location-dot-stale:after{display:none}.maplibregl-user-location-accuracy-circle{background-color:#1da1f233;border-radius:100%;height:1px;width:1px}.maplibregl-crosshair,.maplibregl-crosshair .maplibregl-interactive,.maplibregl-crosshair .maplibregl-interactive:active{cursor:crosshair}.maplibregl-boxzoom{background:#fff;border:2px dotted #202020;height:0;left:0;opacity:.5;position:absolute;top:0;width:0}.maplibregl-cooperative-gesture-screen{align-items:center;background:rgba(0,0,0,.4);color:#fff;display:flex;font-size:1.4em;inset:0;justify-content:center;line-height:1.2;opacity:0;padding:1rem;pointer-events:none;position:absolute;transition:opacity 1s ease 1s;z-index:99999}.maplibregl-cooperative-gesture-screen.maplibregl-show{opacity:1;transition:opacity .05s}.maplibregl-cooperative-gesture-screen .maplibregl-mobile-message{display:none}@media (hover:none),(pointer:coarse){.maplibregl-cooperative-gesture-screen .maplibregl-desktop-message{display:none}.maplibregl-cooperative-gesture-screen .maplibregl-mobile-message{display:block}}.maplibregl-pseudo-fullscreen{height:100%!important;left:0!important;position:fixed!important;top:0!important;width:100%!important;z-index:99999}:root {
   font-family: Inter, system-ui, Avenir, Helvetica, Arial, sans-serif;
   line-height: 1.5;
   font-weight: 400;
diff --git a/src/bowser/dist/index.html b/src/bowser/dist/index.html
index e9f8785..6d5f7eb 100644
--- a/src/bowser/dist/index.html
+++ b/src/bowser/dist/index.html
@@ -11,9 +11,6 @@
   <!-- font awesome-->
   <script src="https://kit.fontawesome.com/acadc5aab9.js" crossorigin="anonymous"></script>
 
-  <link rel="stylesheet" href="https://unpkg.com/leaflet@1.9.4/dist/leaflet.css"
-    integrity="sha256-p4NxAoJBhIIN+hmNHrzRCf9tD/miZyoHS5obTRR9BMY=" crossorigin="" />
-
   <title>Bowser</title>
   <script type="module" crossorigin src="./index.js"></script>
   <link rel="stylesheet" crossorigin href="./index.css">
diff --git a/src/bowser/dist/index.js b/src/bowser/dist/index.js
index cb6b9c0..9defcb8 100644
--- a/src/bowser/dist/index.js
+++ b/src/bowser/dist/index.js
@@ -1,7 +1,7 @@
 var __defProp = Object.defineProperty;
 var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
 var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
-var _a, _b;
+var _a2, _b2, _c2;
 (function polyfill() {
   const relList = document.createElement("link").relList;
   if (relList && relList.supports && relList.supports("modulepreload")) {
@@ -56,252 +56,252 @@ var react_production_min = {};
  * This source code is licensed under the MIT license found in the
  * LICENSE file in the root directory of this source tree.
  */
-var l$1 = Symbol.for("react.element"), n$1 = Symbol.for("react.portal"), p$2 = Symbol.for("react.fragment"), q$1 = Symbol.for("react.strict_mode"), r = Symbol.for("react.profiler"), t = Symbol.for("react.provider"), u = Symbol.for("react.context"), v$1 = Symbol.for("react.forward_ref"), w = Symbol.for("react.suspense"), x = Symbol.for("react.memo"), y = Symbol.for("react.lazy"), z$1 = Symbol.iterator;
-function A$1(a) {
-  if (null === a || "object" !== typeof a) return null;
-  a = z$1 && a[z$1] || a["@@iterator"];
-  return "function" === typeof a ? a : null;
+var l$2 = Symbol.for("react.element"), n$2 = Symbol.for("react.portal"), p$3 = Symbol.for("react.fragment"), q$2 = Symbol.for("react.strict_mode"), r$1 = Symbol.for("react.profiler"), t$1 = Symbol.for("react.provider"), u$1 = Symbol.for("react.context"), v$2 = Symbol.for("react.forward_ref"), w$1 = Symbol.for("react.suspense"), x$1 = Symbol.for("react.memo"), y$1 = Symbol.for("react.lazy"), z$2 = Symbol.iterator;
+function A$2(a2) {
+  if (null === a2 || "object" !== typeof a2) return null;
+  a2 = z$2 && a2[z$2] || a2["@@iterator"];
+  return "function" === typeof a2 ? a2 : null;
 }
-var B$1 = { isMounted: function() {
+var B$2 = { isMounted: function() {
   return false;
 }, enqueueForceUpdate: function() {
 }, enqueueReplaceState: function() {
 }, enqueueSetState: function() {
-} }, C$1 = Object.assign, D$1 = {};
-function E$1(a, b, e) {
-  this.props = a;
-  this.context = b;
-  this.refs = D$1;
-  this.updater = e || B$1;
-}
-E$1.prototype.isReactComponent = {};
-E$1.prototype.setState = function(a, b) {
-  if ("object" !== typeof a && "function" !== typeof a && null != a) throw Error("setState(...): takes an object of state variables to update or a function which returns an object of state variables.");
-  this.updater.enqueueSetState(this, a, b, "setState");
-};
-E$1.prototype.forceUpdate = function(a) {
-  this.updater.enqueueForceUpdate(this, a, "forceUpdate");
-};
-function F() {
-}
-F.prototype = E$1.prototype;
-function G$1(a, b, e) {
-  this.props = a;
-  this.context = b;
-  this.refs = D$1;
-  this.updater = e || B$1;
-}
-var H$1 = G$1.prototype = new F();
-H$1.constructor = G$1;
-C$1(H$1, E$1.prototype);
-H$1.isPureReactComponent = true;
-var I$1 = Array.isArray, J = Object.prototype.hasOwnProperty, K$1 = { current: null }, L$3 = { key: true, ref: true, __self: true, __source: true };
-function M$1(a, b, e) {
-  var d, c = {}, k2 = null, h = null;
-  if (null != b) for (d in void 0 !== b.ref && (h = b.ref), void 0 !== b.key && (k2 = "" + b.key), b) J.call(b, d) && !L$3.hasOwnProperty(d) && (c[d] = b[d]);
-  var g = arguments.length - 2;
-  if (1 === g) c.children = e;
-  else if (1 < g) {
-    for (var f2 = Array(g), m2 = 0; m2 < g; m2++) f2[m2] = arguments[m2 + 2];
-    c.children = f2;
-  }
-  if (a && a.defaultProps) for (d in g = a.defaultProps, g) void 0 === c[d] && (c[d] = g[d]);
-  return { $$typeof: l$1, type: a, key: k2, ref: h, props: c, _owner: K$1.current };
-}
-function N$1(a, b) {
-  return { $$typeof: l$1, type: a.type, key: b, ref: a.ref, props: a.props, _owner: a._owner };
-}
-function O$1(a) {
-  return "object" === typeof a && null !== a && a.$$typeof === l$1;
-}
-function escape(a) {
-  var b = { "=": "=0", ":": "=2" };
-  return "$" + a.replace(/[=:]/g, function(a2) {
-    return b[a2];
+} }, C$2 = Object.assign, D$2 = {};
+function E$2(a2, b2, e2) {
+  this.props = a2;
+  this.context = b2;
+  this.refs = D$2;
+  this.updater = e2 || B$2;
+}
+E$2.prototype.isReactComponent = {};
+E$2.prototype.setState = function(a2, b2) {
+  if ("object" !== typeof a2 && "function" !== typeof a2 && null != a2) throw Error("setState(...): takes an object of state variables to update or a function which returns an object of state variables.");
+  this.updater.enqueueSetState(this, a2, b2, "setState");
+};
+E$2.prototype.forceUpdate = function(a2) {
+  this.updater.enqueueForceUpdate(this, a2, "forceUpdate");
+};
+function F$1() {
+}
+F$1.prototype = E$2.prototype;
+function G$2(a2, b2, e2) {
+  this.props = a2;
+  this.context = b2;
+  this.refs = D$2;
+  this.updater = e2 || B$2;
+}
+var H$2 = G$2.prototype = new F$1();
+H$2.constructor = G$2;
+C$2(H$2, E$2.prototype);
+H$2.isPureReactComponent = true;
+var I$2 = Array.isArray, J$1 = Object.prototype.hasOwnProperty, K$2 = { current: null }, L$2 = { key: true, ref: true, __self: true, __source: true };
+function M$2(a2, b2, e2) {
+  var d2, c2 = {}, k2 = null, h2 = null;
+  if (null != b2) for (d2 in void 0 !== b2.ref && (h2 = b2.ref), void 0 !== b2.key && (k2 = "" + b2.key), b2) J$1.call(b2, d2) && !L$2.hasOwnProperty(d2) && (c2[d2] = b2[d2]);
+  var g2 = arguments.length - 2;
+  if (1 === g2) c2.children = e2;
+  else if (1 < g2) {
+    for (var f2 = Array(g2), m2 = 0; m2 < g2; m2++) f2[m2] = arguments[m2 + 2];
+    c2.children = f2;
+  }
+  if (a2 && a2.defaultProps) for (d2 in g2 = a2.defaultProps, g2) void 0 === c2[d2] && (c2[d2] = g2[d2]);
+  return { $$typeof: l$2, type: a2, key: k2, ref: h2, props: c2, _owner: K$2.current };
+}
+function N$2(a2, b2) {
+  return { $$typeof: l$2, type: a2.type, key: b2, ref: a2.ref, props: a2.props, _owner: a2._owner };
+}
+function O$2(a2) {
+  return "object" === typeof a2 && null !== a2 && a2.$$typeof === l$2;
+}
+function escape$1(a2) {
+  var b2 = { "=": "=0", ":": "=2" };
+  return "$" + a2.replace(/[=:]/g, function(a3) {
+    return b2[a3];
   });
 }
-var P$1 = /\/+/g;
-function Q$1(a, b) {
-  return "object" === typeof a && null !== a && null != a.key ? escape("" + a.key) : b.toString(36);
+var P$2 = /\/+/g;
+function Q$2(a2, b2) {
+  return "object" === typeof a2 && null !== a2 && null != a2.key ? escape$1("" + a2.key) : b2.toString(36);
 }
-function R$1(a, b, e, d, c) {
-  var k2 = typeof a;
-  if ("undefined" === k2 || "boolean" === k2) a = null;
-  var h = false;
-  if (null === a) h = true;
+function R$2(a2, b2, e2, d2, c2) {
+  var k2 = typeof a2;
+  if ("undefined" === k2 || "boolean" === k2) a2 = null;
+  var h2 = false;
+  if (null === a2) h2 = true;
   else switch (k2) {
     case "string":
     case "number":
-      h = true;
+      h2 = true;
       break;
     case "object":
-      switch (a.$$typeof) {
-        case l$1:
-        case n$1:
-          h = true;
+      switch (a2.$$typeof) {
+        case l$2:
+        case n$2:
+          h2 = true;
       }
   }
-  if (h) return h = a, c = c(h), a = "" === d ? "." + Q$1(h, 0) : d, I$1(c) ? (e = "", null != a && (e = a.replace(P$1, "$&/") + "/"), R$1(c, b, e, "", function(a2) {
-    return a2;
-  })) : null != c && (O$1(c) && (c = N$1(c, e + (!c.key || h && h.key === c.key ? "" : ("" + c.key).replace(P$1, "$&/") + "/") + a)), b.push(c)), 1;
-  h = 0;
-  d = "" === d ? "." : d + ":";
-  if (I$1(a)) for (var g = 0; g < a.length; g++) {
-    k2 = a[g];
-    var f2 = d + Q$1(k2, g);
-    h += R$1(k2, b, e, f2, c);
-  }
-  else if (f2 = A$1(a), "function" === typeof f2) for (a = f2.call(a), g = 0; !(k2 = a.next()).done; ) k2 = k2.value, f2 = d + Q$1(k2, g++), h += R$1(k2, b, e, f2, c);
-  else if ("object" === k2) throw b = String(a), Error("Objects are not valid as a React child (found: " + ("[object Object]" === b ? "object with keys {" + Object.keys(a).join(", ") + "}" : b) + "). If you meant to render a collection of children, use an array instead.");
-  return h;
-}
-function S$1(a, b, e) {
-  if (null == a) return a;
-  var d = [], c = 0;
-  R$1(a, d, "", "", function(a2) {
-    return b.call(e, a2, c++);
+  if (h2) return h2 = a2, c2 = c2(h2), a2 = "" === d2 ? "." + Q$2(h2, 0) : d2, I$2(c2) ? (e2 = "", null != a2 && (e2 = a2.replace(P$2, "$&/") + "/"), R$2(c2, b2, e2, "", function(a3) {
+    return a3;
+  })) : null != c2 && (O$2(c2) && (c2 = N$2(c2, e2 + (!c2.key || h2 && h2.key === c2.key ? "" : ("" + c2.key).replace(P$2, "$&/") + "/") + a2)), b2.push(c2)), 1;
+  h2 = 0;
+  d2 = "" === d2 ? "." : d2 + ":";
+  if (I$2(a2)) for (var g2 = 0; g2 < a2.length; g2++) {
+    k2 = a2[g2];
+    var f2 = d2 + Q$2(k2, g2);
+    h2 += R$2(k2, b2, e2, f2, c2);
+  }
+  else if (f2 = A$2(a2), "function" === typeof f2) for (a2 = f2.call(a2), g2 = 0; !(k2 = a2.next()).done; ) k2 = k2.value, f2 = d2 + Q$2(k2, g2++), h2 += R$2(k2, b2, e2, f2, c2);
+  else if ("object" === k2) throw b2 = String(a2), Error("Objects are not valid as a React child (found: " + ("[object Object]" === b2 ? "object with keys {" + Object.keys(a2).join(", ") + "}" : b2) + "). If you meant to render a collection of children, use an array instead.");
+  return h2;
+}
+function S$2(a2, b2, e2) {
+  if (null == a2) return a2;
+  var d2 = [], c2 = 0;
+  R$2(a2, d2, "", "", function(a3) {
+    return b2.call(e2, a3, c2++);
   });
-  return d;
-}
-function T$1(a) {
-  if (-1 === a._status) {
-    var b = a._result;
-    b = b();
-    b.then(function(b2) {
-      if (0 === a._status || -1 === a._status) a._status = 1, a._result = b2;
-    }, function(b2) {
-      if (0 === a._status || -1 === a._status) a._status = 2, a._result = b2;
+  return d2;
+}
+function T$2(a2) {
+  if (-1 === a2._status) {
+    var b2 = a2._result;
+    b2 = b2();
+    b2.then(function(b3) {
+      if (0 === a2._status || -1 === a2._status) a2._status = 1, a2._result = b3;
+    }, function(b3) {
+      if (0 === a2._status || -1 === a2._status) a2._status = 2, a2._result = b3;
     });
-    -1 === a._status && (a._status = 0, a._result = b);
+    -1 === a2._status && (a2._status = 0, a2._result = b2);
   }
-  if (1 === a._status) return a._result.default;
-  throw a._result;
+  if (1 === a2._status) return a2._result.default;
+  throw a2._result;
 }
-var U$1 = { current: null }, V$1 = { transition: null }, W$1 = { ReactCurrentDispatcher: U$1, ReactCurrentBatchConfig: V$1, ReactCurrentOwner: K$1 };
-function X$1() {
+var U$2 = { current: null }, V$2 = { transition: null }, W$2 = { ReactCurrentDispatcher: U$2, ReactCurrentBatchConfig: V$2, ReactCurrentOwner: K$2 };
+function X$2() {
   throw Error("act(...) is not supported in production builds of React.");
 }
-react_production_min.Children = { map: S$1, forEach: function(a, b, e) {
-  S$1(a, function() {
-    b.apply(this, arguments);
-  }, e);
-}, count: function(a) {
-  var b = 0;
-  S$1(a, function() {
-    b++;
+react_production_min.Children = { map: S$2, forEach: function(a2, b2, e2) {
+  S$2(a2, function() {
+    b2.apply(this, arguments);
+  }, e2);
+}, count: function(a2) {
+  var b2 = 0;
+  S$2(a2, function() {
+    b2++;
   });
-  return b;
-}, toArray: function(a) {
-  return S$1(a, function(a2) {
-    return a2;
+  return b2;
+}, toArray: function(a2) {
+  return S$2(a2, function(a3) {
+    return a3;
   }) || [];
-}, only: function(a) {
-  if (!O$1(a)) throw Error("React.Children.only expected to receive a single React element child.");
-  return a;
+}, only: function(a2) {
+  if (!O$2(a2)) throw Error("React.Children.only expected to receive a single React element child.");
+  return a2;
 } };
-react_production_min.Component = E$1;
-react_production_min.Fragment = p$2;
-react_production_min.Profiler = r;
-react_production_min.PureComponent = G$1;
-react_production_min.StrictMode = q$1;
-react_production_min.Suspense = w;
-react_production_min.__SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED = W$1;
-react_production_min.act = X$1;
-react_production_min.cloneElement = function(a, b, e) {
-  if (null === a || void 0 === a) throw Error("React.cloneElement(...): The argument must be a React element, but you passed " + a + ".");
-  var d = C$1({}, a.props), c = a.key, k2 = a.ref, h = a._owner;
-  if (null != b) {
-    void 0 !== b.ref && (k2 = b.ref, h = K$1.current);
-    void 0 !== b.key && (c = "" + b.key);
-    if (a.type && a.type.defaultProps) var g = a.type.defaultProps;
-    for (f2 in b) J.call(b, f2) && !L$3.hasOwnProperty(f2) && (d[f2] = void 0 === b[f2] && void 0 !== g ? g[f2] : b[f2]);
+react_production_min.Component = E$2;
+react_production_min.Fragment = p$3;
+react_production_min.Profiler = r$1;
+react_production_min.PureComponent = G$2;
+react_production_min.StrictMode = q$2;
+react_production_min.Suspense = w$1;
+react_production_min.__SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED = W$2;
+react_production_min.act = X$2;
+react_production_min.cloneElement = function(a2, b2, e2) {
+  if (null === a2 || void 0 === a2) throw Error("React.cloneElement(...): The argument must be a React element, but you passed " + a2 + ".");
+  var d2 = C$2({}, a2.props), c2 = a2.key, k2 = a2.ref, h2 = a2._owner;
+  if (null != b2) {
+    void 0 !== b2.ref && (k2 = b2.ref, h2 = K$2.current);
+    void 0 !== b2.key && (c2 = "" + b2.key);
+    if (a2.type && a2.type.defaultProps) var g2 = a2.type.defaultProps;
+    for (f2 in b2) J$1.call(b2, f2) && !L$2.hasOwnProperty(f2) && (d2[f2] = void 0 === b2[f2] && void 0 !== g2 ? g2[f2] : b2[f2]);
   }
   var f2 = arguments.length - 2;
-  if (1 === f2) d.children = e;
+  if (1 === f2) d2.children = e2;
   else if (1 < f2) {
-    g = Array(f2);
-    for (var m2 = 0; m2 < f2; m2++) g[m2] = arguments[m2 + 2];
-    d.children = g;
+    g2 = Array(f2);
+    for (var m2 = 0; m2 < f2; m2++) g2[m2] = arguments[m2 + 2];
+    d2.children = g2;
   }
-  return { $$typeof: l$1, type: a.type, key: c, ref: k2, props: d, _owner: h };
+  return { $$typeof: l$2, type: a2.type, key: c2, ref: k2, props: d2, _owner: h2 };
 };
-react_production_min.createContext = function(a) {
-  a = { $$typeof: u, _currentValue: a, _currentValue2: a, _threadCount: 0, Provider: null, Consumer: null, _defaultValue: null, _globalName: null };
-  a.Provider = { $$typeof: t, _context: a };
-  return a.Consumer = a;
+react_production_min.createContext = function(a2) {
+  a2 = { $$typeof: u$1, _currentValue: a2, _currentValue2: a2, _threadCount: 0, Provider: null, Consumer: null, _defaultValue: null, _globalName: null };
+  a2.Provider = { $$typeof: t$1, _context: a2 };
+  return a2.Consumer = a2;
 };
-react_production_min.createElement = M$1;
-react_production_min.createFactory = function(a) {
-  var b = M$1.bind(null, a);
-  b.type = a;
-  return b;
+react_production_min.createElement = M$2;
+react_production_min.createFactory = function(a2) {
+  var b2 = M$2.bind(null, a2);
+  b2.type = a2;
+  return b2;
 };
 react_production_min.createRef = function() {
   return { current: null };
 };
-react_production_min.forwardRef = function(a) {
-  return { $$typeof: v$1, render: a };
+react_production_min.forwardRef = function(a2) {
+  return { $$typeof: v$2, render: a2 };
 };
-react_production_min.isValidElement = O$1;
-react_production_min.lazy = function(a) {
-  return { $$typeof: y, _payload: { _status: -1, _result: a }, _init: T$1 };
+react_production_min.isValidElement = O$2;
+react_production_min.lazy = function(a2) {
+  return { $$typeof: y$1, _payload: { _status: -1, _result: a2 }, _init: T$2 };
 };
-react_production_min.memo = function(a, b) {
-  return { $$typeof: x, type: a, compare: void 0 === b ? null : b };
+react_production_min.memo = function(a2, b2) {
+  return { $$typeof: x$1, type: a2, compare: void 0 === b2 ? null : b2 };
 };
-react_production_min.startTransition = function(a) {
-  var b = V$1.transition;
-  V$1.transition = {};
+react_production_min.startTransition = function(a2) {
+  var b2 = V$2.transition;
+  V$2.transition = {};
   try {
-    a();
+    a2();
   } finally {
-    V$1.transition = b;
+    V$2.transition = b2;
   }
 };
-react_production_min.unstable_act = X$1;
-react_production_min.useCallback = function(a, b) {
-  return U$1.current.useCallback(a, b);
+react_production_min.unstable_act = X$2;
+react_production_min.useCallback = function(a2, b2) {
+  return U$2.current.useCallback(a2, b2);
 };
-react_production_min.useContext = function(a) {
-  return U$1.current.useContext(a);
+react_production_min.useContext = function(a2) {
+  return U$2.current.useContext(a2);
 };
 react_production_min.useDebugValue = function() {
 };
-react_production_min.useDeferredValue = function(a) {
-  return U$1.current.useDeferredValue(a);
+react_production_min.useDeferredValue = function(a2) {
+  return U$2.current.useDeferredValue(a2);
 };
-react_production_min.useEffect = function(a, b) {
-  return U$1.current.useEffect(a, b);
+react_production_min.useEffect = function(a2, b2) {
+  return U$2.current.useEffect(a2, b2);
 };
 react_production_min.useId = function() {
-  return U$1.current.useId();
+  return U$2.current.useId();
 };
-react_production_min.useImperativeHandle = function(a, b, e) {
-  return U$1.current.useImperativeHandle(a, b, e);
+react_production_min.useImperativeHandle = function(a2, b2, e2) {
+  return U$2.current.useImperativeHandle(a2, b2, e2);
 };
-react_production_min.useInsertionEffect = function(a, b) {
-  return U$1.current.useInsertionEffect(a, b);
+react_production_min.useInsertionEffect = function(a2, b2) {
+  return U$2.current.useInsertionEffect(a2, b2);
 };
-react_production_min.useLayoutEffect = function(a, b) {
-  return U$1.current.useLayoutEffect(a, b);
+react_production_min.useLayoutEffect = function(a2, b2) {
+  return U$2.current.useLayoutEffect(a2, b2);
 };
-react_production_min.useMemo = function(a, b) {
-  return U$1.current.useMemo(a, b);
+react_production_min.useMemo = function(a2, b2) {
+  return U$2.current.useMemo(a2, b2);
 };
-react_production_min.useReducer = function(a, b, e) {
-  return U$1.current.useReducer(a, b, e);
+react_production_min.useReducer = function(a2, b2, e2) {
+  return U$2.current.useReducer(a2, b2, e2);
 };
-react_production_min.useRef = function(a) {
-  return U$1.current.useRef(a);
+react_production_min.useRef = function(a2) {
+  return U$2.current.useRef(a2);
 };
-react_production_min.useState = function(a) {
-  return U$1.current.useState(a);
+react_production_min.useState = function(a2) {
+  return U$2.current.useState(a2);
 };
-react_production_min.useSyncExternalStore = function(a, b, e) {
-  return U$1.current.useSyncExternalStore(a, b, e);
+react_production_min.useSyncExternalStore = function(a2, b2, e2) {
+  return U$2.current.useSyncExternalStore(a2, b2, e2);
 };
 react_production_min.useTransition = function() {
-  return U$1.current.useTransition();
+  return U$2.current.useTransition();
 };
 react_production_min.version = "18.3.1";
 {
@@ -318,19 +318,19 @@ const React = /* @__PURE__ */ getDefaultExportFromCjs(reactExports);
  * This source code is licensed under the MIT license found in the
  * LICENSE file in the root directory of this source tree.
  */
-var f = reactExports, k = Symbol.for("react.element"), l = Symbol.for("react.fragment"), m$1 = Object.prototype.hasOwnProperty, n = f.__SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED.ReactCurrentOwner, p$1 = { key: true, ref: true, __self: true, __source: true };
-function q(c, a, g) {
-  var b, d = {}, e = null, h = null;
-  void 0 !== g && (e = "" + g);
-  void 0 !== a.key && (e = "" + a.key);
-  void 0 !== a.ref && (h = a.ref);
-  for (b in a) m$1.call(a, b) && !p$1.hasOwnProperty(b) && (d[b] = a[b]);
-  if (c && c.defaultProps) for (b in a = c.defaultProps, a) void 0 === d[b] && (d[b] = a[b]);
-  return { $$typeof: k, type: c, key: e, ref: h, props: d, _owner: n.current };
-}
-reactJsxRuntime_production_min.Fragment = l;
-reactJsxRuntime_production_min.jsx = q;
-reactJsxRuntime_production_min.jsxs = q;
+var f$1 = reactExports, k$1 = Symbol.for("react.element"), l$1 = Symbol.for("react.fragment"), m$2 = Object.prototype.hasOwnProperty, n$1 = f$1.__SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED.ReactCurrentOwner, p$2 = { key: true, ref: true, __self: true, __source: true };
+function q$1(c2, a2, g2) {
+  var b2, d2 = {}, e2 = null, h2 = null;
+  void 0 !== g2 && (e2 = "" + g2);
+  void 0 !== a2.key && (e2 = "" + a2.key);
+  void 0 !== a2.ref && (h2 = a2.ref);
+  for (b2 in a2) m$2.call(a2, b2) && !p$2.hasOwnProperty(b2) && (d2[b2] = a2[b2]);
+  if (c2 && c2.defaultProps) for (b2 in a2 = c2.defaultProps, a2) void 0 === d2[b2] && (d2[b2] = a2[b2]);
+  return { $$typeof: k$1, type: c2, key: e2, ref: h2, props: d2, _owner: n$1.current };
+}
+reactJsxRuntime_production_min.Fragment = l$1;
+reactJsxRuntime_production_min.jsx = q$1;
+reactJsxRuntime_production_min.jsxs = q$1;
 {
   jsxRuntime.exports = reactJsxRuntime_production_min;
 }
@@ -350,35 +350,35 @@ var scheduler_production_min = {};
  * LICENSE file in the root directory of this source tree.
  */
 (function(exports) {
-  function f2(a, b) {
-    var c = a.length;
-    a.push(b);
-    a: for (; 0 < c; ) {
-      var d = c - 1 >>> 1, e = a[d];
-      if (0 < g(e, b)) a[d] = b, a[c] = e, c = d;
+  function f2(a2, b2) {
+    var c2 = a2.length;
+    a2.push(b2);
+    a: for (; 0 < c2; ) {
+      var d2 = c2 - 1 >>> 1, e2 = a2[d2];
+      if (0 < g2(e2, b2)) a2[d2] = b2, a2[c2] = e2, c2 = d2;
       else break a;
     }
   }
-  function h(a) {
-    return 0 === a.length ? null : a[0];
-  }
-  function k2(a) {
-    if (0 === a.length) return null;
-    var b = a[0], c = a.pop();
-    if (c !== b) {
-      a[0] = c;
-      a: for (var d = 0, e = a.length, w2 = e >>> 1; d < w2; ) {
-        var m2 = 2 * (d + 1) - 1, C2 = a[m2], n2 = m2 + 1, x2 = a[n2];
-        if (0 > g(C2, c)) n2 < e && 0 > g(x2, C2) ? (a[d] = x2, a[n2] = c, d = n2) : (a[d] = C2, a[m2] = c, d = m2);
-        else if (n2 < e && 0 > g(x2, c)) a[d] = x2, a[n2] = c, d = n2;
+  function h2(a2) {
+    return 0 === a2.length ? null : a2[0];
+  }
+  function k2(a2) {
+    if (0 === a2.length) return null;
+    var b2 = a2[0], c2 = a2.pop();
+    if (c2 !== b2) {
+      a2[0] = c2;
+      a: for (var d2 = 0, e2 = a2.length, w2 = e2 >>> 1; d2 < w2; ) {
+        var m2 = 2 * (d2 + 1) - 1, C2 = a2[m2], n2 = m2 + 1, x2 = a2[n2];
+        if (0 > g2(C2, c2)) n2 < e2 && 0 > g2(x2, C2) ? (a2[d2] = x2, a2[n2] = c2, d2 = n2) : (a2[d2] = C2, a2[m2] = c2, d2 = m2);
+        else if (n2 < e2 && 0 > g2(x2, c2)) a2[d2] = x2, a2[n2] = c2, d2 = n2;
         else break a;
       }
     }
-    return b;
+    return b2;
   }
-  function g(a, b) {
-    var c = a.sortIndex - b.sortIndex;
-    return 0 !== c ? c : a.id - b.id;
+  function g2(a2, b2) {
+    var c2 = a2.sortIndex - b2.sortIndex;
+    return 0 !== c2 ? c2 : a2.id - b2.id;
   }
   if ("object" === typeof performance && "function" === typeof performance.now) {
     var l2 = performance;
@@ -393,51 +393,51 @@ var scheduler_production_min = {};
   }
   var r2 = [], t2 = [], u2 = 1, v2 = null, y2 = 3, z2 = false, A2 = false, B2 = false, D2 = "function" === typeof setTimeout ? setTimeout : null, E2 = "function" === typeof clearTimeout ? clearTimeout : null, F2 = "undefined" !== typeof setImmediate ? setImmediate : null;
   "undefined" !== typeof navigator && void 0 !== navigator.scheduling && void 0 !== navigator.scheduling.isInputPending && navigator.scheduling.isInputPending.bind(navigator.scheduling);
-  function G2(a) {
-    for (var b = h(t2); null !== b; ) {
-      if (null === b.callback) k2(t2);
-      else if (b.startTime <= a) k2(t2), b.sortIndex = b.expirationTime, f2(r2, b);
+  function G2(a2) {
+    for (var b2 = h2(t2); null !== b2; ) {
+      if (null === b2.callback) k2(t2);
+      else if (b2.startTime <= a2) k2(t2), b2.sortIndex = b2.expirationTime, f2(r2, b2);
       else break;
-      b = h(t2);
+      b2 = h2(t2);
     }
   }
-  function H2(a) {
+  function H2(a2) {
     B2 = false;
-    G2(a);
-    if (!A2) if (null !== h(r2)) A2 = true, I2(J2);
+    G2(a2);
+    if (!A2) if (null !== h2(r2)) A2 = true, I2(J2);
     else {
-      var b = h(t2);
-      null !== b && K2(H2, b.startTime - a);
+      var b2 = h2(t2);
+      null !== b2 && K2(H2, b2.startTime - a2);
     }
   }
-  function J2(a, b) {
+  function J2(a2, b2) {
     A2 = false;
     B2 && (B2 = false, E2(L2), L2 = -1);
     z2 = true;
-    var c = y2;
+    var c2 = y2;
     try {
-      G2(b);
-      for (v2 = h(r2); null !== v2 && (!(v2.expirationTime > b) || a && !M2()); ) {
-        var d = v2.callback;
-        if ("function" === typeof d) {
+      G2(b2);
+      for (v2 = h2(r2); null !== v2 && (!(v2.expirationTime > b2) || a2 && !M2()); ) {
+        var d2 = v2.callback;
+        if ("function" === typeof d2) {
           v2.callback = null;
           y2 = v2.priorityLevel;
-          var e = d(v2.expirationTime <= b);
-          b = exports.unstable_now();
-          "function" === typeof e ? v2.callback = e : v2 === h(r2) && k2(r2);
-          G2(b);
+          var e2 = d2(v2.expirationTime <= b2);
+          b2 = exports.unstable_now();
+          "function" === typeof e2 ? v2.callback = e2 : v2 === h2(r2) && k2(r2);
+          G2(b2);
         } else k2(r2);
-        v2 = h(r2);
+        v2 = h2(r2);
       }
       if (null !== v2) var w2 = true;
       else {
-        var m2 = h(t2);
-        null !== m2 && K2(H2, m2.startTime - b);
+        var m2 = h2(t2);
+        null !== m2 && K2(H2, m2.startTime - b2);
         w2 = false;
       }
       return w2;
     } finally {
-      v2 = null, y2 = c, z2 = false;
+      v2 = null, y2 = c2, z2 = false;
     }
   }
   var N2 = false, O2 = null, L2 = -1, P2 = 5, Q2 = -1;
@@ -446,13 +446,13 @@ var scheduler_production_min = {};
   }
   function R2() {
     if (null !== O2) {
-      var a = exports.unstable_now();
-      Q2 = a;
-      var b = true;
+      var a2 = exports.unstable_now();
+      Q2 = a2;
+      var b2 = true;
       try {
-        b = O2(true, a);
+        b2 = O2(true, a2);
       } finally {
-        b ? S2() : (N2 = false, O2 = null);
+        b2 ? S2() : (N2 = false, O2 = null);
       }
     } else N2 = false;
   }
@@ -469,14 +469,14 @@ var scheduler_production_min = {};
   } else S2 = function() {
     D2(R2, 0);
   };
-  function I2(a) {
-    O2 = a;
+  function I2(a2) {
+    O2 = a2;
     N2 || (N2 = true, S2());
   }
-  function K2(a, b) {
+  function K2(a2, b2) {
     L2 = D2(function() {
-      a(exports.unstable_now());
-    }, b);
+      a2(exports.unstable_now());
+    }, b2);
   }
   exports.unstable_IdlePriority = 5;
   exports.unstable_ImmediatePriority = 1;
@@ -484,45 +484,45 @@ var scheduler_production_min = {};
   exports.unstable_NormalPriority = 3;
   exports.unstable_Profiling = null;
   exports.unstable_UserBlockingPriority = 2;
-  exports.unstable_cancelCallback = function(a) {
-    a.callback = null;
+  exports.unstable_cancelCallback = function(a2) {
+    a2.callback = null;
   };
   exports.unstable_continueExecution = function() {
     A2 || z2 || (A2 = true, I2(J2));
   };
-  exports.unstable_forceFrameRate = function(a) {
-    0 > a || 125 < a ? console.error("forceFrameRate takes a positive int between 0 and 125, forcing frame rates higher than 125 fps is not supported") : P2 = 0 < a ? Math.floor(1e3 / a) : 5;
+  exports.unstable_forceFrameRate = function(a2) {
+    0 > a2 || 125 < a2 ? console.error("forceFrameRate takes a positive int between 0 and 125, forcing frame rates higher than 125 fps is not supported") : P2 = 0 < a2 ? Math.floor(1e3 / a2) : 5;
   };
   exports.unstable_getCurrentPriorityLevel = function() {
     return y2;
   };
   exports.unstable_getFirstCallbackNode = function() {
-    return h(r2);
+    return h2(r2);
   };
-  exports.unstable_next = function(a) {
+  exports.unstable_next = function(a2) {
     switch (y2) {
       case 1:
       case 2:
       case 3:
-        var b = 3;
+        var b2 = 3;
         break;
       default:
-        b = y2;
+        b2 = y2;
     }
-    var c = y2;
-    y2 = b;
+    var c2 = y2;
+    y2 = b2;
     try {
-      return a();
+      return a2();
     } finally {
-      y2 = c;
+      y2 = c2;
     }
   };
   exports.unstable_pauseExecution = function() {
   };
   exports.unstable_requestPaint = function() {
   };
-  exports.unstable_runWithPriority = function(a, b) {
-    switch (a) {
+  exports.unstable_runWithPriority = function(a2, b2) {
+    switch (a2) {
       case 1:
       case 2:
       case 3:
@@ -530,50 +530,50 @@ var scheduler_production_min = {};
       case 5:
         break;
       default:
-        a = 3;
+        a2 = 3;
     }
-    var c = y2;
-    y2 = a;
+    var c2 = y2;
+    y2 = a2;
     try {
-      return b();
+      return b2();
     } finally {
-      y2 = c;
+      y2 = c2;
     }
   };
-  exports.unstable_scheduleCallback = function(a, b, c) {
-    var d = exports.unstable_now();
-    "object" === typeof c && null !== c ? (c = c.delay, c = "number" === typeof c && 0 < c ? d + c : d) : c = d;
-    switch (a) {
+  exports.unstable_scheduleCallback = function(a2, b2, c2) {
+    var d2 = exports.unstable_now();
+    "object" === typeof c2 && null !== c2 ? (c2 = c2.delay, c2 = "number" === typeof c2 && 0 < c2 ? d2 + c2 : d2) : c2 = d2;
+    switch (a2) {
       case 1:
-        var e = -1;
+        var e2 = -1;
         break;
       case 2:
-        e = 250;
+        e2 = 250;
         break;
       case 5:
-        e = 1073741823;
+        e2 = 1073741823;
         break;
       case 4:
-        e = 1e4;
+        e2 = 1e4;
         break;
       default:
-        e = 5e3;
+        e2 = 5e3;
     }
-    e = c + e;
-    a = { id: u2++, callback: b, priorityLevel: a, startTime: c, expirationTime: e, sortIndex: -1 };
-    c > d ? (a.sortIndex = c, f2(t2, a), null === h(r2) && a === h(t2) && (B2 ? (E2(L2), L2 = -1) : B2 = true, K2(H2, c - d))) : (a.sortIndex = e, f2(r2, a), A2 || z2 || (A2 = true, I2(J2)));
-    return a;
+    e2 = c2 + e2;
+    a2 = { id: u2++, callback: b2, priorityLevel: a2, startTime: c2, expirationTime: e2, sortIndex: -1 };
+    c2 > d2 ? (a2.sortIndex = c2, f2(t2, a2), null === h2(r2) && a2 === h2(t2) && (B2 ? (E2(L2), L2 = -1) : B2 = true, K2(H2, c2 - d2))) : (a2.sortIndex = e2, f2(r2, a2), A2 || z2 || (A2 = true, I2(J2)));
+    return a2;
   };
   exports.unstable_shouldYield = M2;
-  exports.unstable_wrapCallback = function(a) {
-    var b = y2;
+  exports.unstable_wrapCallback = function(a2) {
+    var b2 = y2;
     return function() {
-      var c = y2;
-      y2 = b;
+      var c2 = y2;
+      y2 = b2;
       try {
-        return a.apply(this, arguments);
+        return a2.apply(this, arguments);
       } finally {
-        y2 = c;
+        y2 = c2;
       }
     };
   };
@@ -592,203 +592,203 @@ var schedulerExports = scheduler.exports;
  * LICENSE file in the root directory of this source tree.
  */
 var aa = reactExports, ca = schedulerExports;
-function p(a) {
-  for (var b = "https://reactjs.org/docs/error-decoder.html?invariant=" + a, c = 1; c < arguments.length; c++) b += "&args[]=" + encodeURIComponent(arguments[c]);
-  return "Minified React error #" + a + "; visit " + b + " for the full message or use the non-minified dev environment for full errors and additional helpful warnings.";
+function p$1(a2) {
+  for (var b2 = "https://reactjs.org/docs/error-decoder.html?invariant=" + a2, c2 = 1; c2 < arguments.length; c2++) b2 += "&args[]=" + encodeURIComponent(arguments[c2]);
+  return "Minified React error #" + a2 + "; visit " + b2 + " for the full message or use the non-minified dev environment for full errors and additional helpful warnings.";
 }
 var da = /* @__PURE__ */ new Set(), ea = {};
-function fa(a, b) {
-  ha(a, b);
-  ha(a + "Capture", b);
+function fa(a2, b2) {
+  ha(a2, b2);
+  ha(a2 + "Capture", b2);
 }
-function ha(a, b) {
-  ea[a] = b;
-  for (a = 0; a < b.length; a++) da.add(b[a]);
+function ha(a2, b2) {
+  ea[a2] = b2;
+  for (a2 = 0; a2 < b2.length; a2++) da.add(b2[a2]);
 }
 var ia = !("undefined" === typeof window || "undefined" === typeof window.document || "undefined" === typeof window.document.createElement), ja = Object.prototype.hasOwnProperty, ka = /^[:A-Z_a-z\u00C0-\u00D6\u00D8-\u00F6\u00F8-\u02FF\u0370-\u037D\u037F-\u1FFF\u200C-\u200D\u2070-\u218F\u2C00-\u2FEF\u3001-\uD7FF\uF900-\uFDCF\uFDF0-\uFFFD][:A-Z_a-z\u00C0-\u00D6\u00D8-\u00F6\u00F8-\u02FF\u0370-\u037D\u037F-\u1FFF\u200C-\u200D\u2070-\u218F\u2C00-\u2FEF\u3001-\uD7FF\uF900-\uFDCF\uFDF0-\uFFFD\-.0-9\u00B7\u0300-\u036F\u203F-\u2040]*$/, la = {}, ma = {};
-function oa(a) {
-  if (ja.call(ma, a)) return true;
-  if (ja.call(la, a)) return false;
-  if (ka.test(a)) return ma[a] = true;
-  la[a] = true;
+function oa(a2) {
+  if (ja.call(ma, a2)) return true;
+  if (ja.call(la, a2)) return false;
+  if (ka.test(a2)) return ma[a2] = true;
+  la[a2] = true;
   return false;
 }
-function pa(a, b, c, d) {
-  if (null !== c && 0 === c.type) return false;
-  switch (typeof b) {
+function pa(a2, b2, c2, d2) {
+  if (null !== c2 && 0 === c2.type) return false;
+  switch (typeof b2) {
     case "function":
     case "symbol":
       return true;
     case "boolean":
-      if (d) return false;
-      if (null !== c) return !c.acceptsBooleans;
-      a = a.toLowerCase().slice(0, 5);
-      return "data-" !== a && "aria-" !== a;
+      if (d2) return false;
+      if (null !== c2) return !c2.acceptsBooleans;
+      a2 = a2.toLowerCase().slice(0, 5);
+      return "data-" !== a2 && "aria-" !== a2;
     default:
       return false;
   }
 }
-function qa(a, b, c, d) {
-  if (null === b || "undefined" === typeof b || pa(a, b, c, d)) return true;
-  if (d) return false;
-  if (null !== c) switch (c.type) {
+function qa(a2, b2, c2, d2) {
+  if (null === b2 || "undefined" === typeof b2 || pa(a2, b2, c2, d2)) return true;
+  if (d2) return false;
+  if (null !== c2) switch (c2.type) {
     case 3:
-      return !b;
+      return !b2;
     case 4:
-      return false === b;
+      return false === b2;
     case 5:
-      return isNaN(b);
+      return isNaN(b2);
     case 6:
-      return isNaN(b) || 1 > b;
+      return isNaN(b2) || 1 > b2;
   }
   return false;
 }
-function v(a, b, c, d, e, f2, g) {
-  this.acceptsBooleans = 2 === b || 3 === b || 4 === b;
-  this.attributeName = d;
-  this.attributeNamespace = e;
-  this.mustUseProperty = c;
-  this.propertyName = a;
-  this.type = b;
+function v$1(a2, b2, c2, d2, e2, f2, g2) {
+  this.acceptsBooleans = 2 === b2 || 3 === b2 || 4 === b2;
+  this.attributeName = d2;
+  this.attributeNamespace = e2;
+  this.mustUseProperty = c2;
+  this.propertyName = a2;
+  this.type = b2;
   this.sanitizeURL = f2;
-  this.removeEmptyString = g;
+  this.removeEmptyString = g2;
 }
-var z = {};
-"children dangerouslySetInnerHTML defaultValue defaultChecked innerHTML suppressContentEditableWarning suppressHydrationWarning style".split(" ").forEach(function(a) {
-  z[a] = new v(a, 0, false, a, null, false, false);
+var z$1 = {};
+"children dangerouslySetInnerHTML defaultValue defaultChecked innerHTML suppressContentEditableWarning suppressHydrationWarning style".split(" ").forEach(function(a2) {
+  z$1[a2] = new v$1(a2, 0, false, a2, null, false, false);
 });
-[["acceptCharset", "accept-charset"], ["className", "class"], ["htmlFor", "for"], ["httpEquiv", "http-equiv"]].forEach(function(a) {
-  var b = a[0];
-  z[b] = new v(b, 1, false, a[1], null, false, false);
+[["acceptCharset", "accept-charset"], ["className", "class"], ["htmlFor", "for"], ["httpEquiv", "http-equiv"]].forEach(function(a2) {
+  var b2 = a2[0];
+  z$1[b2] = new v$1(b2, 1, false, a2[1], null, false, false);
 });
-["contentEditable", "draggable", "spellCheck", "value"].forEach(function(a) {
-  z[a] = new v(a, 2, false, a.toLowerCase(), null, false, false);
+["contentEditable", "draggable", "spellCheck", "value"].forEach(function(a2) {
+  z$1[a2] = new v$1(a2, 2, false, a2.toLowerCase(), null, false, false);
 });
-["autoReverse", "externalResourcesRequired", "focusable", "preserveAlpha"].forEach(function(a) {
-  z[a] = new v(a, 2, false, a, null, false, false);
+["autoReverse", "externalResourcesRequired", "focusable", "preserveAlpha"].forEach(function(a2) {
+  z$1[a2] = new v$1(a2, 2, false, a2, null, false, false);
 });
-"allowFullScreen async autoFocus autoPlay controls default defer disabled disablePictureInPicture disableRemotePlayback formNoValidate hidden loop noModule noValidate open playsInline readOnly required reversed scoped seamless itemScope".split(" ").forEach(function(a) {
-  z[a] = new v(a, 3, false, a.toLowerCase(), null, false, false);
+"allowFullScreen async autoFocus autoPlay controls default defer disabled disablePictureInPicture disableRemotePlayback formNoValidate hidden loop noModule noValidate open playsInline readOnly required reversed scoped seamless itemScope".split(" ").forEach(function(a2) {
+  z$1[a2] = new v$1(a2, 3, false, a2.toLowerCase(), null, false, false);
 });
-["checked", "multiple", "muted", "selected"].forEach(function(a) {
-  z[a] = new v(a, 3, true, a, null, false, false);
+["checked", "multiple", "muted", "selected"].forEach(function(a2) {
+  z$1[a2] = new v$1(a2, 3, true, a2, null, false, false);
 });
-["capture", "download"].forEach(function(a) {
-  z[a] = new v(a, 4, false, a, null, false, false);
+["capture", "download"].forEach(function(a2) {
+  z$1[a2] = new v$1(a2, 4, false, a2, null, false, false);
 });
-["cols", "rows", "size", "span"].forEach(function(a) {
-  z[a] = new v(a, 6, false, a, null, false, false);
+["cols", "rows", "size", "span"].forEach(function(a2) {
+  z$1[a2] = new v$1(a2, 6, false, a2, null, false, false);
 });
-["rowSpan", "start"].forEach(function(a) {
-  z[a] = new v(a, 5, false, a.toLowerCase(), null, false, false);
+["rowSpan", "start"].forEach(function(a2) {
+  z$1[a2] = new v$1(a2, 5, false, a2.toLowerCase(), null, false, false);
 });
 var ra = /[\-:]([a-z])/g;
-function sa(a) {
-  return a[1].toUpperCase();
+function sa(a2) {
+  return a2[1].toUpperCase();
 }
-"accent-height alignment-baseline arabic-form baseline-shift cap-height clip-path clip-rule color-interpolation color-interpolation-filters color-profile color-rendering dominant-baseline enable-background fill-opacity fill-rule flood-color flood-opacity font-family font-size font-size-adjust font-stretch font-style font-variant font-weight glyph-name glyph-orientation-horizontal glyph-orientation-vertical horiz-adv-x horiz-origin-x image-rendering letter-spacing lighting-color marker-end marker-mid marker-start overline-position overline-thickness paint-order panose-1 pointer-events rendering-intent shape-rendering stop-color stop-opacity strikethrough-position strikethrough-thickness stroke-dasharray stroke-dashoffset stroke-linecap stroke-linejoin stroke-miterlimit stroke-opacity stroke-width text-anchor text-decoration text-rendering underline-position underline-thickness unicode-bidi unicode-range units-per-em v-alphabetic v-hanging v-ideographic v-mathematical vector-effect vert-adv-y vert-origin-x vert-origin-y word-spacing writing-mode xmlns:xlink x-height".split(" ").forEach(function(a) {
-  var b = a.replace(
+"accent-height alignment-baseline arabic-form baseline-shift cap-height clip-path clip-rule color-interpolation color-interpolation-filters color-profile color-rendering dominant-baseline enable-background fill-opacity fill-rule flood-color flood-opacity font-family font-size font-size-adjust font-stretch font-style font-variant font-weight glyph-name glyph-orientation-horizontal glyph-orientation-vertical horiz-adv-x horiz-origin-x image-rendering letter-spacing lighting-color marker-end marker-mid marker-start overline-position overline-thickness paint-order panose-1 pointer-events rendering-intent shape-rendering stop-color stop-opacity strikethrough-position strikethrough-thickness stroke-dasharray stroke-dashoffset stroke-linecap stroke-linejoin stroke-miterlimit stroke-opacity stroke-width text-anchor text-decoration text-rendering underline-position underline-thickness unicode-bidi unicode-range units-per-em v-alphabetic v-hanging v-ideographic v-mathematical vector-effect vert-adv-y vert-origin-x vert-origin-y word-spacing writing-mode xmlns:xlink x-height".split(" ").forEach(function(a2) {
+  var b2 = a2.replace(
     ra,
     sa
   );
-  z[b] = new v(b, 1, false, a, null, false, false);
+  z$1[b2] = new v$1(b2, 1, false, a2, null, false, false);
 });
-"xlink:actuate xlink:arcrole xlink:role xlink:show xlink:title xlink:type".split(" ").forEach(function(a) {
-  var b = a.replace(ra, sa);
-  z[b] = new v(b, 1, false, a, "http://www.w3.org/1999/xlink", false, false);
+"xlink:actuate xlink:arcrole xlink:role xlink:show xlink:title xlink:type".split(" ").forEach(function(a2) {
+  var b2 = a2.replace(ra, sa);
+  z$1[b2] = new v$1(b2, 1, false, a2, "http://www.w3.org/1999/xlink", false, false);
 });
-["xml:base", "xml:lang", "xml:space"].forEach(function(a) {
-  var b = a.replace(ra, sa);
-  z[b] = new v(b, 1, false, a, "http://www.w3.org/XML/1998/namespace", false, false);
+["xml:base", "xml:lang", "xml:space"].forEach(function(a2) {
+  var b2 = a2.replace(ra, sa);
+  z$1[b2] = new v$1(b2, 1, false, a2, "http://www.w3.org/XML/1998/namespace", false, false);
 });
-["tabIndex", "crossOrigin"].forEach(function(a) {
-  z[a] = new v(a, 1, false, a.toLowerCase(), null, false, false);
+["tabIndex", "crossOrigin"].forEach(function(a2) {
+  z$1[a2] = new v$1(a2, 1, false, a2.toLowerCase(), null, false, false);
 });
-z.xlinkHref = new v("xlinkHref", 1, false, "xlink:href", "http://www.w3.org/1999/xlink", true, false);
-["src", "href", "action", "formAction"].forEach(function(a) {
-  z[a] = new v(a, 1, false, a.toLowerCase(), null, true, true);
+z$1.xlinkHref = new v$1("xlinkHref", 1, false, "xlink:href", "http://www.w3.org/1999/xlink", true, false);
+["src", "href", "action", "formAction"].forEach(function(a2) {
+  z$1[a2] = new v$1(a2, 1, false, a2.toLowerCase(), null, true, true);
 });
-function ta(a, b, c, d) {
-  var e = z.hasOwnProperty(b) ? z[b] : null;
-  if (null !== e ? 0 !== e.type : d || !(2 < b.length) || "o" !== b[0] && "O" !== b[0] || "n" !== b[1] && "N" !== b[1]) qa(b, c, e, d) && (c = null), d || null === e ? oa(b) && (null === c ? a.removeAttribute(b) : a.setAttribute(b, "" + c)) : e.mustUseProperty ? a[e.propertyName] = null === c ? 3 === e.type ? false : "" : c : (b = e.attributeName, d = e.attributeNamespace, null === c ? a.removeAttribute(b) : (e = e.type, c = 3 === e || 4 === e && true === c ? "" : "" + c, d ? a.setAttributeNS(d, b, c) : a.setAttribute(b, c)));
+function ta(a2, b2, c2, d2) {
+  var e2 = z$1.hasOwnProperty(b2) ? z$1[b2] : null;
+  if (null !== e2 ? 0 !== e2.type : d2 || !(2 < b2.length) || "o" !== b2[0] && "O" !== b2[0] || "n" !== b2[1] && "N" !== b2[1]) qa(b2, c2, e2, d2) && (c2 = null), d2 || null === e2 ? oa(b2) && (null === c2 ? a2.removeAttribute(b2) : a2.setAttribute(b2, "" + c2)) : e2.mustUseProperty ? a2[e2.propertyName] = null === c2 ? 3 === e2.type ? false : "" : c2 : (b2 = e2.attributeName, d2 = e2.attributeNamespace, null === c2 ? a2.removeAttribute(b2) : (e2 = e2.type, c2 = 3 === e2 || 4 === e2 && true === c2 ? "" : "" + c2, d2 ? a2.setAttributeNS(d2, b2, c2) : a2.setAttribute(b2, c2)));
 }
 var ua = aa.__SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED, va = Symbol.for("react.element"), wa = Symbol.for("react.portal"), ya = Symbol.for("react.fragment"), za = Symbol.for("react.strict_mode"), Aa = Symbol.for("react.profiler"), Ba = Symbol.for("react.provider"), Ca = Symbol.for("react.context"), Da = Symbol.for("react.forward_ref"), Ea = Symbol.for("react.suspense"), Fa = Symbol.for("react.suspense_list"), Ga = Symbol.for("react.memo"), Ha = Symbol.for("react.lazy");
 var Ia = Symbol.for("react.offscreen");
 var Ja = Symbol.iterator;
-function Ka(a) {
-  if (null === a || "object" !== typeof a) return null;
-  a = Ja && a[Ja] || a["@@iterator"];
-  return "function" === typeof a ? a : null;
+function Ka(a2) {
+  if (null === a2 || "object" !== typeof a2) return null;
+  a2 = Ja && a2[Ja] || a2["@@iterator"];
+  return "function" === typeof a2 ? a2 : null;
 }
-var A = Object.assign, La;
-function Ma(a) {
+var A$1 = Object.assign, La;
+function Ma(a2) {
   if (void 0 === La) try {
     throw Error();
-  } catch (c) {
-    var b = c.stack.trim().match(/\n( *(at )?)/);
-    La = b && b[1] || "";
+  } catch (c2) {
+    var b2 = c2.stack.trim().match(/\n( *(at )?)/);
+    La = b2 && b2[1] || "";
   }
-  return "\n" + La + a;
+  return "\n" + La + a2;
 }
 var Na = false;
-function Oa(a, b) {
-  if (!a || Na) return "";
+function Oa(a2, b2) {
+  if (!a2 || Na) return "";
   Na = true;
-  var c = Error.prepareStackTrace;
+  var c2 = Error.prepareStackTrace;
   Error.prepareStackTrace = void 0;
   try {
-    if (b) if (b = function() {
+    if (b2) if (b2 = function() {
       throw Error();
-    }, Object.defineProperty(b.prototype, "props", { set: function() {
+    }, Object.defineProperty(b2.prototype, "props", { set: function() {
       throw Error();
     } }), "object" === typeof Reflect && Reflect.construct) {
       try {
-        Reflect.construct(b, []);
+        Reflect.construct(b2, []);
       } catch (l2) {
-        var d = l2;
+        var d2 = l2;
       }
-      Reflect.construct(a, [], b);
+      Reflect.construct(a2, [], b2);
     } else {
       try {
-        b.call();
+        b2.call();
       } catch (l2) {
-        d = l2;
+        d2 = l2;
       }
-      a.call(b.prototype);
+      a2.call(b2.prototype);
     }
     else {
       try {
         throw Error();
       } catch (l2) {
-        d = l2;
+        d2 = l2;
       }
-      a();
+      a2();
     }
   } catch (l2) {
-    if (l2 && d && "string" === typeof l2.stack) {
-      for (var e = l2.stack.split("\n"), f2 = d.stack.split("\n"), g = e.length - 1, h = f2.length - 1; 1 <= g && 0 <= h && e[g] !== f2[h]; ) h--;
-      for (; 1 <= g && 0 <= h; g--, h--) if (e[g] !== f2[h]) {
-        if (1 !== g || 1 !== h) {
+    if (l2 && d2 && "string" === typeof l2.stack) {
+      for (var e2 = l2.stack.split("\n"), f2 = d2.stack.split("\n"), g2 = e2.length - 1, h2 = f2.length - 1; 1 <= g2 && 0 <= h2 && e2[g2] !== f2[h2]; ) h2--;
+      for (; 1 <= g2 && 0 <= h2; g2--, h2--) if (e2[g2] !== f2[h2]) {
+        if (1 !== g2 || 1 !== h2) {
           do
-            if (g--, h--, 0 > h || e[g] !== f2[h]) {
-              var k2 = "\n" + e[g].replace(" at new ", " at ");
-              a.displayName && k2.includes("<anonymous>") && (k2 = k2.replace("<anonymous>", a.displayName));
+            if (g2--, h2--, 0 > h2 || e2[g2] !== f2[h2]) {
+              var k2 = "\n" + e2[g2].replace(" at new ", " at ");
+              a2.displayName && k2.includes("<anonymous>") && (k2 = k2.replace("<anonymous>", a2.displayName));
               return k2;
             }
-          while (1 <= g && 0 <= h);
+          while (1 <= g2 && 0 <= h2);
         }
         break;
       }
     }
   } finally {
-    Na = false, Error.prepareStackTrace = c;
+    Na = false, Error.prepareStackTrace = c2;
   }
-  return (a = a ? a.displayName || a.name : "") ? Ma(a) : "";
+  return (a2 = a2 ? a2.displayName || a2.name : "") ? Ma(a2) : "";
 }
-function Pa(a) {
-  switch (a.tag) {
+function Pa(a2) {
+  switch (a2.tag) {
     case 5:
-      return Ma(a.type);
+      return Ma(a2.type);
     case 16:
       return Ma("Lazy");
     case 13:
@@ -798,20 +798,20 @@ function Pa(a) {
     case 0:
     case 2:
     case 15:
-      return a = Oa(a.type, false), a;
+      return a2 = Oa(a2.type, false), a2;
     case 11:
-      return a = Oa(a.type.render, false), a;
+      return a2 = Oa(a2.type.render, false), a2;
     case 1:
-      return a = Oa(a.type, true), a;
+      return a2 = Oa(a2.type, true), a2;
     default:
       return "";
   }
 }
-function Qa(a) {
-  if (null == a) return null;
-  if ("function" === typeof a) return a.displayName || a.name || null;
-  if ("string" === typeof a) return a;
-  switch (a) {
+function Qa(a2) {
+  if (null == a2) return null;
+  if ("function" === typeof a2) return a2.displayName || a2.name || null;
+  if ("string" === typeof a2) return a2;
+  switch (a2) {
     case ya:
       return "Fragment";
     case wa:
@@ -825,45 +825,45 @@ function Qa(a) {
     case Fa:
       return "SuspenseList";
   }
-  if ("object" === typeof a) switch (a.$$typeof) {
+  if ("object" === typeof a2) switch (a2.$$typeof) {
     case Ca:
-      return (a.displayName || "Context") + ".Consumer";
+      return (a2.displayName || "Context") + ".Consumer";
     case Ba:
-      return (a._context.displayName || "Context") + ".Provider";
+      return (a2._context.displayName || "Context") + ".Provider";
     case Da:
-      var b = a.render;
-      a = a.displayName;
-      a || (a = b.displayName || b.name || "", a = "" !== a ? "ForwardRef(" + a + ")" : "ForwardRef");
-      return a;
+      var b2 = a2.render;
+      a2 = a2.displayName;
+      a2 || (a2 = b2.displayName || b2.name || "", a2 = "" !== a2 ? "ForwardRef(" + a2 + ")" : "ForwardRef");
+      return a2;
     case Ga:
-      return b = a.displayName || null, null !== b ? b : Qa(a.type) || "Memo";
+      return b2 = a2.displayName || null, null !== b2 ? b2 : Qa(a2.type) || "Memo";
     case Ha:
-      b = a._payload;
-      a = a._init;
+      b2 = a2._payload;
+      a2 = a2._init;
       try {
-        return Qa(a(b));
-      } catch (c) {
+        return Qa(a2(b2));
+      } catch (c2) {
       }
   }
   return null;
 }
-function Ra(a) {
-  var b = a.type;
-  switch (a.tag) {
+function Ra(a2) {
+  var b2 = a2.type;
+  switch (a2.tag) {
     case 24:
       return "Cache";
     case 9:
-      return (b.displayName || "Context") + ".Consumer";
+      return (b2.displayName || "Context") + ".Consumer";
     case 10:
-      return (b._context.displayName || "Context") + ".Provider";
+      return (b2._context.displayName || "Context") + ".Provider";
     case 18:
       return "DehydratedFragment";
     case 11:
-      return a = b.render, a = a.displayName || a.name || "", b.displayName || ("" !== a ? "ForwardRef(" + a + ")" : "ForwardRef");
+      return a2 = b2.render, a2 = a2.displayName || a2.name || "", b2.displayName || ("" !== a2 ? "ForwardRef(" + a2 + ")" : "ForwardRef");
     case 7:
       return "Fragment";
     case 5:
-      return b;
+      return b2;
     case 4:
       return "Portal";
     case 3:
@@ -871,9 +871,9 @@ function Ra(a) {
     case 6:
       return "Text";
     case 16:
-      return Qa(b);
+      return Qa(b2);
     case 8:
-      return b === za ? "StrictMode" : "Mode";
+      return b2 === za ? "StrictMode" : "Mode";
     case 22:
       return "Offscreen";
     case 12:
@@ -892,167 +892,167 @@ function Ra(a) {
     case 2:
     case 14:
     case 15:
-      if ("function" === typeof b) return b.displayName || b.name || null;
-      if ("string" === typeof b) return b;
+      if ("function" === typeof b2) return b2.displayName || b2.name || null;
+      if ("string" === typeof b2) return b2;
   }
   return null;
 }
-function Sa(a) {
-  switch (typeof a) {
+function Sa(a2) {
+  switch (typeof a2) {
     case "boolean":
     case "number":
     case "string":
     case "undefined":
-      return a;
+      return a2;
     case "object":
-      return a;
+      return a2;
     default:
       return "";
   }
 }
-function Ta(a) {
-  var b = a.type;
-  return (a = a.nodeName) && "input" === a.toLowerCase() && ("checkbox" === b || "radio" === b);
+function Ta(a2) {
+  var b2 = a2.type;
+  return (a2 = a2.nodeName) && "input" === a2.toLowerCase() && ("checkbox" === b2 || "radio" === b2);
 }
-function Ua(a) {
-  var b = Ta(a) ? "checked" : "value", c = Object.getOwnPropertyDescriptor(a.constructor.prototype, b), d = "" + a[b];
-  if (!a.hasOwnProperty(b) && "undefined" !== typeof c && "function" === typeof c.get && "function" === typeof c.set) {
-    var e = c.get, f2 = c.set;
-    Object.defineProperty(a, b, { configurable: true, get: function() {
-      return e.call(this);
-    }, set: function(a2) {
-      d = "" + a2;
-      f2.call(this, a2);
+function Ua(a2) {
+  var b2 = Ta(a2) ? "checked" : "value", c2 = Object.getOwnPropertyDescriptor(a2.constructor.prototype, b2), d2 = "" + a2[b2];
+  if (!a2.hasOwnProperty(b2) && "undefined" !== typeof c2 && "function" === typeof c2.get && "function" === typeof c2.set) {
+    var e2 = c2.get, f2 = c2.set;
+    Object.defineProperty(a2, b2, { configurable: true, get: function() {
+      return e2.call(this);
+    }, set: function(a3) {
+      d2 = "" + a3;
+      f2.call(this, a3);
     } });
-    Object.defineProperty(a, b, { enumerable: c.enumerable });
+    Object.defineProperty(a2, b2, { enumerable: c2.enumerable });
     return { getValue: function() {
-      return d;
-    }, setValue: function(a2) {
-      d = "" + a2;
+      return d2;
+    }, setValue: function(a3) {
+      d2 = "" + a3;
     }, stopTracking: function() {
-      a._valueTracker = null;
-      delete a[b];
+      a2._valueTracker = null;
+      delete a2[b2];
     } };
   }
 }
-function Va(a) {
-  a._valueTracker || (a._valueTracker = Ua(a));
+function Va(a2) {
+  a2._valueTracker || (a2._valueTracker = Ua(a2));
 }
-function Wa(a) {
-  if (!a) return false;
-  var b = a._valueTracker;
-  if (!b) return true;
-  var c = b.getValue();
-  var d = "";
-  a && (d = Ta(a) ? a.checked ? "true" : "false" : a.value);
-  a = d;
-  return a !== c ? (b.setValue(a), true) : false;
+function Wa(a2) {
+  if (!a2) return false;
+  var b2 = a2._valueTracker;
+  if (!b2) return true;
+  var c2 = b2.getValue();
+  var d2 = "";
+  a2 && (d2 = Ta(a2) ? a2.checked ? "true" : "false" : a2.value);
+  a2 = d2;
+  return a2 !== c2 ? (b2.setValue(a2), true) : false;
 }
-function Xa(a) {
-  a = a || ("undefined" !== typeof document ? document : void 0);
-  if ("undefined" === typeof a) return null;
+function Xa(a2) {
+  a2 = a2 || ("undefined" !== typeof document ? document : void 0);
+  if ("undefined" === typeof a2) return null;
   try {
-    return a.activeElement || a.body;
-  } catch (b) {
-    return a.body;
-  }
-}
-function Ya(a, b) {
-  var c = b.checked;
-  return A({}, b, { defaultChecked: void 0, defaultValue: void 0, value: void 0, checked: null != c ? c : a._wrapperState.initialChecked });
-}
-function Za(a, b) {
-  var c = null == b.defaultValue ? "" : b.defaultValue, d = null != b.checked ? b.checked : b.defaultChecked;
-  c = Sa(null != b.value ? b.value : c);
-  a._wrapperState = { initialChecked: d, initialValue: c, controlled: "checkbox" === b.type || "radio" === b.type ? null != b.checked : null != b.value };
-}
-function ab(a, b) {
-  b = b.checked;
-  null != b && ta(a, "checked", b, false);
-}
-function bb(a, b) {
-  ab(a, b);
-  var c = Sa(b.value), d = b.type;
-  if (null != c) if ("number" === d) {
-    if (0 === c && "" === a.value || a.value != c) a.value = "" + c;
-  } else a.value !== "" + c && (a.value = "" + c);
-  else if ("submit" === d || "reset" === d) {
-    a.removeAttribute("value");
-    return;
+    return a2.activeElement || a2.body;
+  } catch (b2) {
+    return a2.body;
   }
-  b.hasOwnProperty("value") ? cb(a, b.type, c) : b.hasOwnProperty("defaultValue") && cb(a, b.type, Sa(b.defaultValue));
-  null == b.checked && null != b.defaultChecked && (a.defaultChecked = !!b.defaultChecked);
 }
-function db(a, b, c) {
-  if (b.hasOwnProperty("value") || b.hasOwnProperty("defaultValue")) {
-    var d = b.type;
-    if (!("submit" !== d && "reset" !== d || void 0 !== b.value && null !== b.value)) return;
-    b = "" + a._wrapperState.initialValue;
-    c || b === a.value || (a.value = b);
-    a.defaultValue = b;
+function Ya(a2, b2) {
+  var c2 = b2.checked;
+  return A$1({}, b2, { defaultChecked: void 0, defaultValue: void 0, value: void 0, checked: null != c2 ? c2 : a2._wrapperState.initialChecked });
+}
+function Za(a2, b2) {
+  var c2 = null == b2.defaultValue ? "" : b2.defaultValue, d2 = null != b2.checked ? b2.checked : b2.defaultChecked;
+  c2 = Sa(null != b2.value ? b2.value : c2);
+  a2._wrapperState = { initialChecked: d2, initialValue: c2, controlled: "checkbox" === b2.type || "radio" === b2.type ? null != b2.checked : null != b2.value };
+}
+function ab(a2, b2) {
+  b2 = b2.checked;
+  null != b2 && ta(a2, "checked", b2, false);
+}
+function bb(a2, b2) {
+  ab(a2, b2);
+  var c2 = Sa(b2.value), d2 = b2.type;
+  if (null != c2) if ("number" === d2) {
+    if (0 === c2 && "" === a2.value || a2.value != c2) a2.value = "" + c2;
+  } else a2.value !== "" + c2 && (a2.value = "" + c2);
+  else if ("submit" === d2 || "reset" === d2) {
+    a2.removeAttribute("value");
+    return;
   }
-  c = a.name;
-  "" !== c && (a.name = "");
-  a.defaultChecked = !!a._wrapperState.initialChecked;
-  "" !== c && (a.name = c);
+  b2.hasOwnProperty("value") ? cb(a2, b2.type, c2) : b2.hasOwnProperty("defaultValue") && cb(a2, b2.type, Sa(b2.defaultValue));
+  null == b2.checked && null != b2.defaultChecked && (a2.defaultChecked = !!b2.defaultChecked);
+}
+function db(a2, b2, c2) {
+  if (b2.hasOwnProperty("value") || b2.hasOwnProperty("defaultValue")) {
+    var d2 = b2.type;
+    if (!("submit" !== d2 && "reset" !== d2 || void 0 !== b2.value && null !== b2.value)) return;
+    b2 = "" + a2._wrapperState.initialValue;
+    c2 || b2 === a2.value || (a2.value = b2);
+    a2.defaultValue = b2;
+  }
+  c2 = a2.name;
+  "" !== c2 && (a2.name = "");
+  a2.defaultChecked = !!a2._wrapperState.initialChecked;
+  "" !== c2 && (a2.name = c2);
 }
-function cb(a, b, c) {
-  if ("number" !== b || Xa(a.ownerDocument) !== a) null == c ? a.defaultValue = "" + a._wrapperState.initialValue : a.defaultValue !== "" + c && (a.defaultValue = "" + c);
+function cb(a2, b2, c2) {
+  if ("number" !== b2 || Xa(a2.ownerDocument) !== a2) null == c2 ? a2.defaultValue = "" + a2._wrapperState.initialValue : a2.defaultValue !== "" + c2 && (a2.defaultValue = "" + c2);
 }
 var eb = Array.isArray;
-function fb(a, b, c, d) {
-  a = a.options;
-  if (b) {
-    b = {};
-    for (var e = 0; e < c.length; e++) b["$" + c[e]] = true;
-    for (c = 0; c < a.length; c++) e = b.hasOwnProperty("$" + a[c].value), a[c].selected !== e && (a[c].selected = e), e && d && (a[c].defaultSelected = true);
+function fb(a2, b2, c2, d2) {
+  a2 = a2.options;
+  if (b2) {
+    b2 = {};
+    for (var e2 = 0; e2 < c2.length; e2++) b2["$" + c2[e2]] = true;
+    for (c2 = 0; c2 < a2.length; c2++) e2 = b2.hasOwnProperty("$" + a2[c2].value), a2[c2].selected !== e2 && (a2[c2].selected = e2), e2 && d2 && (a2[c2].defaultSelected = true);
   } else {
-    c = "" + Sa(c);
-    b = null;
-    for (e = 0; e < a.length; e++) {
-      if (a[e].value === c) {
-        a[e].selected = true;
-        d && (a[e].defaultSelected = true);
+    c2 = "" + Sa(c2);
+    b2 = null;
+    for (e2 = 0; e2 < a2.length; e2++) {
+      if (a2[e2].value === c2) {
+        a2[e2].selected = true;
+        d2 && (a2[e2].defaultSelected = true);
         return;
       }
-      null !== b || a[e].disabled || (b = a[e]);
+      null !== b2 || a2[e2].disabled || (b2 = a2[e2]);
     }
-    null !== b && (b.selected = true);
+    null !== b2 && (b2.selected = true);
   }
 }
-function gb(a, b) {
-  if (null != b.dangerouslySetInnerHTML) throw Error(p(91));
-  return A({}, b, { value: void 0, defaultValue: void 0, children: "" + a._wrapperState.initialValue });
+function gb(a2, b2) {
+  if (null != b2.dangerouslySetInnerHTML) throw Error(p$1(91));
+  return A$1({}, b2, { value: void 0, defaultValue: void 0, children: "" + a2._wrapperState.initialValue });
 }
-function hb(a, b) {
-  var c = b.value;
-  if (null == c) {
-    c = b.children;
-    b = b.defaultValue;
-    if (null != c) {
-      if (null != b) throw Error(p(92));
-      if (eb(c)) {
-        if (1 < c.length) throw Error(p(93));
-        c = c[0];
+function hb(a2, b2) {
+  var c2 = b2.value;
+  if (null == c2) {
+    c2 = b2.children;
+    b2 = b2.defaultValue;
+    if (null != c2) {
+      if (null != b2) throw Error(p$1(92));
+      if (eb(c2)) {
+        if (1 < c2.length) throw Error(p$1(93));
+        c2 = c2[0];
       }
-      b = c;
+      b2 = c2;
     }
-    null == b && (b = "");
-    c = b;
+    null == b2 && (b2 = "");
+    c2 = b2;
   }
-  a._wrapperState = { initialValue: Sa(c) };
+  a2._wrapperState = { initialValue: Sa(c2) };
 }
-function ib(a, b) {
-  var c = Sa(b.value), d = Sa(b.defaultValue);
-  null != c && (c = "" + c, c !== a.value && (a.value = c), null == b.defaultValue && a.defaultValue !== c && (a.defaultValue = c));
-  null != d && (a.defaultValue = "" + d);
+function ib(a2, b2) {
+  var c2 = Sa(b2.value), d2 = Sa(b2.defaultValue);
+  null != c2 && (c2 = "" + c2, c2 !== a2.value && (a2.value = c2), null == b2.defaultValue && a2.defaultValue !== c2 && (a2.defaultValue = c2));
+  null != d2 && (a2.defaultValue = "" + d2);
 }
-function jb(a) {
-  var b = a.textContent;
-  b === a._wrapperState.initialValue && "" !== b && null !== b && (a.value = b);
+function jb(a2) {
+  var b2 = a2.textContent;
+  b2 === a2._wrapperState.initialValue && "" !== b2 && null !== b2 && (a2.value = b2);
 }
-function kb(a) {
-  switch (a) {
+function kb(a2) {
+  switch (a2) {
     case "svg":
       return "http://www.w3.org/2000/svg";
     case "math":
@@ -1061,33 +1061,33 @@ function kb(a) {
       return "http://www.w3.org/1999/xhtml";
   }
 }
-function lb(a, b) {
-  return null == a || "http://www.w3.org/1999/xhtml" === a ? kb(b) : "http://www.w3.org/2000/svg" === a && "foreignObject" === b ? "http://www.w3.org/1999/xhtml" : a;
+function lb(a2, b2) {
+  return null == a2 || "http://www.w3.org/1999/xhtml" === a2 ? kb(b2) : "http://www.w3.org/2000/svg" === a2 && "foreignObject" === b2 ? "http://www.w3.org/1999/xhtml" : a2;
 }
-var mb, nb = function(a) {
-  return "undefined" !== typeof MSApp && MSApp.execUnsafeLocalFunction ? function(b, c, d, e) {
+var mb, nb = function(a2) {
+  return "undefined" !== typeof MSApp && MSApp.execUnsafeLocalFunction ? function(b2, c2, d2, e2) {
     MSApp.execUnsafeLocalFunction(function() {
-      return a(b, c, d, e);
+      return a2(b2, c2, d2, e2);
     });
-  } : a;
-}(function(a, b) {
-  if ("http://www.w3.org/2000/svg" !== a.namespaceURI || "innerHTML" in a) a.innerHTML = b;
+  } : a2;
+}(function(a2, b2) {
+  if ("http://www.w3.org/2000/svg" !== a2.namespaceURI || "innerHTML" in a2) a2.innerHTML = b2;
   else {
     mb = mb || document.createElement("div");
-    mb.innerHTML = "<svg>" + b.valueOf().toString() + "</svg>";
-    for (b = mb.firstChild; a.firstChild; ) a.removeChild(a.firstChild);
-    for (; b.firstChild; ) a.appendChild(b.firstChild);
+    mb.innerHTML = "<svg>" + b2.valueOf().toString() + "</svg>";
+    for (b2 = mb.firstChild; a2.firstChild; ) a2.removeChild(a2.firstChild);
+    for (; b2.firstChild; ) a2.appendChild(b2.firstChild);
   }
 });
-function ob(a, b) {
-  if (b) {
-    var c = a.firstChild;
-    if (c && c === a.lastChild && 3 === c.nodeType) {
-      c.nodeValue = b;
+function ob(a2, b2) {
+  if (b2) {
+    var c2 = a2.firstChild;
+    if (c2 && c2 === a2.lastChild && 3 === c2.nodeType) {
+      c2.nodeValue = b2;
       return;
     }
   }
-  a.textContent = b;
+  a2.textContent = b2;
 }
 var pb = {
   animationIterationCount: true,
@@ -1134,37 +1134,37 @@ var pb = {
   strokeOpacity: true,
   strokeWidth: true
 }, qb = ["Webkit", "ms", "Moz", "O"];
-Object.keys(pb).forEach(function(a) {
-  qb.forEach(function(b) {
-    b = b + a.charAt(0).toUpperCase() + a.substring(1);
-    pb[b] = pb[a];
+Object.keys(pb).forEach(function(a2) {
+  qb.forEach(function(b2) {
+    b2 = b2 + a2.charAt(0).toUpperCase() + a2.substring(1);
+    pb[b2] = pb[a2];
   });
 });
-function rb(a, b, c) {
-  return null == b || "boolean" === typeof b || "" === b ? "" : c || "number" !== typeof b || 0 === b || pb.hasOwnProperty(a) && pb[a] ? ("" + b).trim() : b + "px";
+function rb(a2, b2, c2) {
+  return null == b2 || "boolean" === typeof b2 || "" === b2 ? "" : c2 || "number" !== typeof b2 || 0 === b2 || pb.hasOwnProperty(a2) && pb[a2] ? ("" + b2).trim() : b2 + "px";
 }
-function sb(a, b) {
-  a = a.style;
-  for (var c in b) if (b.hasOwnProperty(c)) {
-    var d = 0 === c.indexOf("--"), e = rb(c, b[c], d);
-    "float" === c && (c = "cssFloat");
-    d ? a.setProperty(c, e) : a[c] = e;
+function sb(a2, b2) {
+  a2 = a2.style;
+  for (var c2 in b2) if (b2.hasOwnProperty(c2)) {
+    var d2 = 0 === c2.indexOf("--"), e2 = rb(c2, b2[c2], d2);
+    "float" === c2 && (c2 = "cssFloat");
+    d2 ? a2.setProperty(c2, e2) : a2[c2] = e2;
   }
 }
-var tb = A({ menuitem: true }, { area: true, base: true, br: true, col: true, embed: true, hr: true, img: true, input: true, keygen: true, link: true, meta: true, param: true, source: true, track: true, wbr: true });
-function ub(a, b) {
-  if (b) {
-    if (tb[a] && (null != b.children || null != b.dangerouslySetInnerHTML)) throw Error(p(137, a));
-    if (null != b.dangerouslySetInnerHTML) {
-      if (null != b.children) throw Error(p(60));
-      if ("object" !== typeof b.dangerouslySetInnerHTML || !("__html" in b.dangerouslySetInnerHTML)) throw Error(p(61));
+var tb = A$1({ menuitem: true }, { area: true, base: true, br: true, col: true, embed: true, hr: true, img: true, input: true, keygen: true, link: true, meta: true, param: true, source: true, track: true, wbr: true });
+function ub(a2, b2) {
+  if (b2) {
+    if (tb[a2] && (null != b2.children || null != b2.dangerouslySetInnerHTML)) throw Error(p$1(137, a2));
+    if (null != b2.dangerouslySetInnerHTML) {
+      if (null != b2.children) throw Error(p$1(60));
+      if ("object" !== typeof b2.dangerouslySetInnerHTML || !("__html" in b2.dangerouslySetInnerHTML)) throw Error(p$1(61));
     }
-    if (null != b.style && "object" !== typeof b.style) throw Error(p(62));
+    if (null != b2.style && "object" !== typeof b2.style) throw Error(p$1(62));
   }
 }
-function vb(a, b) {
-  if (-1 === a.indexOf("-")) return "string" === typeof b.is;
-  switch (a) {
+function vb(a2, b2) {
+  if (-1 === a2.indexOf("-")) return "string" === typeof b2.is;
+  switch (a2) {
     case "annotation-xml":
     case "color-profile":
     case "font-face":
@@ -1179,52 +1179,52 @@ function vb(a, b) {
   }
 }
 var wb = null;
-function xb(a) {
-  a = a.target || a.srcElement || window;
-  a.correspondingUseElement && (a = a.correspondingUseElement);
-  return 3 === a.nodeType ? a.parentNode : a;
+function xb(a2) {
+  a2 = a2.target || a2.srcElement || window;
+  a2.correspondingUseElement && (a2 = a2.correspondingUseElement);
+  return 3 === a2.nodeType ? a2.parentNode : a2;
 }
 var yb = null, zb = null, Ab = null;
-function Bb(a) {
-  if (a = Cb(a)) {
-    if ("function" !== typeof yb) throw Error(p(280));
-    var b = a.stateNode;
-    b && (b = Db(b), yb(a.stateNode, a.type, b));
+function Bb(a2) {
+  if (a2 = Cb(a2)) {
+    if ("function" !== typeof yb) throw Error(p$1(280));
+    var b2 = a2.stateNode;
+    b2 && (b2 = Db(b2), yb(a2.stateNode, a2.type, b2));
   }
 }
-function Eb(a) {
-  zb ? Ab ? Ab.push(a) : Ab = [a] : zb = a;
+function Eb(a2) {
+  zb ? Ab ? Ab.push(a2) : Ab = [a2] : zb = a2;
 }
 function Fb() {
   if (zb) {
-    var a = zb, b = Ab;
+    var a2 = zb, b2 = Ab;
     Ab = zb = null;
-    Bb(a);
-    if (b) for (a = 0; a < b.length; a++) Bb(b[a]);
+    Bb(a2);
+    if (b2) for (a2 = 0; a2 < b2.length; a2++) Bb(b2[a2]);
   }
 }
-function Gb(a, b) {
-  return a(b);
+function Gb(a2, b2) {
+  return a2(b2);
 }
 function Hb() {
 }
 var Ib = false;
-function Jb(a, b, c) {
-  if (Ib) return a(b, c);
+function Jb(a2, b2, c2) {
+  if (Ib) return a2(b2, c2);
   Ib = true;
   try {
-    return Gb(a, b, c);
+    return Gb(a2, b2, c2);
   } finally {
     if (Ib = false, null !== zb || null !== Ab) Hb(), Fb();
   }
 }
-function Kb(a, b) {
-  var c = a.stateNode;
-  if (null === c) return null;
-  var d = Db(c);
-  if (null === d) return null;
-  c = d[b];
-  a: switch (b) {
+function Kb(a2, b2) {
+  var c2 = a2.stateNode;
+  if (null === c2) return null;
+  var d2 = Db(c2);
+  if (null === d2) return null;
+  c2 = d2[b2];
+  a: switch (b2) {
     case "onClick":
     case "onClickCapture":
     case "onDoubleClick":
@@ -1236,15 +1236,15 @@ function Kb(a, b) {
     case "onMouseUp":
     case "onMouseUpCapture":
     case "onMouseEnter":
-      (d = !d.disabled) || (a = a.type, d = !("button" === a || "input" === a || "select" === a || "textarea" === a));
-      a = !d;
+      (d2 = !d2.disabled) || (a2 = a2.type, d2 = !("button" === a2 || "input" === a2 || "select" === a2 || "textarea" === a2));
+      a2 = !d2;
       break a;
     default:
-      a = false;
+      a2 = false;
   }
-  if (a) return null;
-  if (c && "function" !== typeof c) throw Error(p(231, b, typeof c));
-  return c;
+  if (a2) return null;
+  if (c2 && "function" !== typeof c2) throw Error(p$1(231, b2, typeof c2));
+  return c2;
 }
 var Lb = false;
 if (ia) try {
@@ -1254,155 +1254,155 @@ if (ia) try {
   } });
   window.addEventListener("test", Mb, Mb);
   window.removeEventListener("test", Mb, Mb);
-} catch (a) {
+} catch (a2) {
   Lb = false;
 }
-function Nb(a, b, c, d, e, f2, g, h, k2) {
+function Nb(a2, b2, c2, d2, e2, f2, g2, h2, k2) {
   var l2 = Array.prototype.slice.call(arguments, 3);
   try {
-    b.apply(c, l2);
+    b2.apply(c2, l2);
   } catch (m2) {
     this.onError(m2);
   }
 }
-var Ob = false, Pb = null, Qb = false, Rb = null, Sb = { onError: function(a) {
+var Ob = false, Pb = null, Qb = false, Rb = null, Sb = { onError: function(a2) {
   Ob = true;
-  Pb = a;
+  Pb = a2;
 } };
-function Tb(a, b, c, d, e, f2, g, h, k2) {
+function Tb(a2, b2, c2, d2, e2, f2, g2, h2, k2) {
   Ob = false;
   Pb = null;
   Nb.apply(Sb, arguments);
 }
-function Ub(a, b, c, d, e, f2, g, h, k2) {
+function Ub(a2, b2, c2, d2, e2, f2, g2, h2, k2) {
   Tb.apply(this, arguments);
   if (Ob) {
     if (Ob) {
       var l2 = Pb;
       Ob = false;
       Pb = null;
-    } else throw Error(p(198));
+    } else throw Error(p$1(198));
     Qb || (Qb = true, Rb = l2);
   }
 }
-function Vb(a) {
-  var b = a, c = a;
-  if (a.alternate) for (; b.return; ) b = b.return;
+function Vb(a2) {
+  var b2 = a2, c2 = a2;
+  if (a2.alternate) for (; b2.return; ) b2 = b2.return;
   else {
-    a = b;
+    a2 = b2;
     do
-      b = a, 0 !== (b.flags & 4098) && (c = b.return), a = b.return;
-    while (a);
+      b2 = a2, 0 !== (b2.flags & 4098) && (c2 = b2.return), a2 = b2.return;
+    while (a2);
   }
-  return 3 === b.tag ? c : null;
+  return 3 === b2.tag ? c2 : null;
 }
-function Wb(a) {
-  if (13 === a.tag) {
-    var b = a.memoizedState;
-    null === b && (a = a.alternate, null !== a && (b = a.memoizedState));
-    if (null !== b) return b.dehydrated;
+function Wb(a2) {
+  if (13 === a2.tag) {
+    var b2 = a2.memoizedState;
+    null === b2 && (a2 = a2.alternate, null !== a2 && (b2 = a2.memoizedState));
+    if (null !== b2) return b2.dehydrated;
   }
   return null;
 }
-function Xb(a) {
-  if (Vb(a) !== a) throw Error(p(188));
+function Xb(a2) {
+  if (Vb(a2) !== a2) throw Error(p$1(188));
 }
-function Yb(a) {
-  var b = a.alternate;
-  if (!b) {
-    b = Vb(a);
-    if (null === b) throw Error(p(188));
-    return b !== a ? null : a;
-  }
-  for (var c = a, d = b; ; ) {
-    var e = c.return;
-    if (null === e) break;
-    var f2 = e.alternate;
+function Yb(a2) {
+  var b2 = a2.alternate;
+  if (!b2) {
+    b2 = Vb(a2);
+    if (null === b2) throw Error(p$1(188));
+    return b2 !== a2 ? null : a2;
+  }
+  for (var c2 = a2, d2 = b2; ; ) {
+    var e2 = c2.return;
+    if (null === e2) break;
+    var f2 = e2.alternate;
     if (null === f2) {
-      d = e.return;
-      if (null !== d) {
-        c = d;
+      d2 = e2.return;
+      if (null !== d2) {
+        c2 = d2;
         continue;
       }
       break;
     }
-    if (e.child === f2.child) {
-      for (f2 = e.child; f2; ) {
-        if (f2 === c) return Xb(e), a;
-        if (f2 === d) return Xb(e), b;
+    if (e2.child === f2.child) {
+      for (f2 = e2.child; f2; ) {
+        if (f2 === c2) return Xb(e2), a2;
+        if (f2 === d2) return Xb(e2), b2;
         f2 = f2.sibling;
       }
-      throw Error(p(188));
+      throw Error(p$1(188));
     }
-    if (c.return !== d.return) c = e, d = f2;
+    if (c2.return !== d2.return) c2 = e2, d2 = f2;
     else {
-      for (var g = false, h = e.child; h; ) {
-        if (h === c) {
-          g = true;
-          c = e;
-          d = f2;
+      for (var g2 = false, h2 = e2.child; h2; ) {
+        if (h2 === c2) {
+          g2 = true;
+          c2 = e2;
+          d2 = f2;
           break;
         }
-        if (h === d) {
-          g = true;
-          d = e;
-          c = f2;
+        if (h2 === d2) {
+          g2 = true;
+          d2 = e2;
+          c2 = f2;
           break;
         }
-        h = h.sibling;
+        h2 = h2.sibling;
       }
-      if (!g) {
-        for (h = f2.child; h; ) {
-          if (h === c) {
-            g = true;
-            c = f2;
-            d = e;
+      if (!g2) {
+        for (h2 = f2.child; h2; ) {
+          if (h2 === c2) {
+            g2 = true;
+            c2 = f2;
+            d2 = e2;
             break;
           }
-          if (h === d) {
-            g = true;
-            d = f2;
-            c = e;
+          if (h2 === d2) {
+            g2 = true;
+            d2 = f2;
+            c2 = e2;
             break;
           }
-          h = h.sibling;
+          h2 = h2.sibling;
         }
-        if (!g) throw Error(p(189));
+        if (!g2) throw Error(p$1(189));
       }
     }
-    if (c.alternate !== d) throw Error(p(190));
+    if (c2.alternate !== d2) throw Error(p$1(190));
   }
-  if (3 !== c.tag) throw Error(p(188));
-  return c.stateNode.current === c ? a : b;
+  if (3 !== c2.tag) throw Error(p$1(188));
+  return c2.stateNode.current === c2 ? a2 : b2;
 }
-function Zb(a) {
-  a = Yb(a);
-  return null !== a ? $b(a) : null;
+function Zb(a2) {
+  a2 = Yb(a2);
+  return null !== a2 ? $b(a2) : null;
 }
-function $b(a) {
-  if (5 === a.tag || 6 === a.tag) return a;
-  for (a = a.child; null !== a; ) {
-    var b = $b(a);
-    if (null !== b) return b;
-    a = a.sibling;
+function $b(a2) {
+  if (5 === a2.tag || 6 === a2.tag) return a2;
+  for (a2 = a2.child; null !== a2; ) {
+    var b2 = $b(a2);
+    if (null !== b2) return b2;
+    a2 = a2.sibling;
   }
   return null;
 }
-var ac = ca.unstable_scheduleCallback, bc = ca.unstable_cancelCallback, cc = ca.unstable_shouldYield, dc = ca.unstable_requestPaint, B = ca.unstable_now, ec = ca.unstable_getCurrentPriorityLevel, fc = ca.unstable_ImmediatePriority, gc = ca.unstable_UserBlockingPriority, hc = ca.unstable_NormalPriority, ic = ca.unstable_LowPriority, jc = ca.unstable_IdlePriority, kc = null, lc = null;
-function mc(a) {
+var ac = ca.unstable_scheduleCallback, bc = ca.unstable_cancelCallback, cc = ca.unstable_shouldYield, dc = ca.unstable_requestPaint, B$1 = ca.unstable_now, ec = ca.unstable_getCurrentPriorityLevel, fc = ca.unstable_ImmediatePriority, gc = ca.unstable_UserBlockingPriority, hc = ca.unstable_NormalPriority, ic = ca.unstable_LowPriority, jc = ca.unstable_IdlePriority, kc = null, lc = null;
+function mc(a2) {
   if (lc && "function" === typeof lc.onCommitFiberRoot) try {
-    lc.onCommitFiberRoot(kc, a, void 0, 128 === (a.current.flags & 128));
-  } catch (b) {
+    lc.onCommitFiberRoot(kc, a2, void 0, 128 === (a2.current.flags & 128));
+  } catch (b2) {
   }
 }
 var oc = Math.clz32 ? Math.clz32 : nc, pc = Math.log, qc = Math.LN2;
-function nc(a) {
-  a >>>= 0;
-  return 0 === a ? 32 : 31 - (pc(a) / qc | 0) | 0;
+function nc(a2) {
+  a2 >>>= 0;
+  return 0 === a2 ? 32 : 31 - (pc(a2) / qc | 0) | 0;
 }
 var rc = 64, sc = 4194304;
-function tc(a) {
-  switch (a & -a) {
+function tc(a2) {
+  switch (a2 & -a2) {
     case 1:
       return 1;
     case 2:
@@ -1431,13 +1431,13 @@ function tc(a) {
     case 524288:
     case 1048576:
     case 2097152:
-      return a & 4194240;
+      return a2 & 4194240;
     case 4194304:
     case 8388608:
     case 16777216:
     case 33554432:
     case 67108864:
-      return a & 130023424;
+      return a2 & 130023424;
     case 134217728:
       return 134217728;
     case 268435456:
@@ -1447,30 +1447,30 @@ function tc(a) {
     case 1073741824:
       return 1073741824;
     default:
-      return a;
-  }
-}
-function uc(a, b) {
-  var c = a.pendingLanes;
-  if (0 === c) return 0;
-  var d = 0, e = a.suspendedLanes, f2 = a.pingedLanes, g = c & 268435455;
-  if (0 !== g) {
-    var h = g & ~e;
-    0 !== h ? d = tc(h) : (f2 &= g, 0 !== f2 && (d = tc(f2)));
-  } else g = c & ~e, 0 !== g ? d = tc(g) : 0 !== f2 && (d = tc(f2));
-  if (0 === d) return 0;
-  if (0 !== b && b !== d && 0 === (b & e) && (e = d & -d, f2 = b & -b, e >= f2 || 16 === e && 0 !== (f2 & 4194240))) return b;
-  0 !== (d & 4) && (d |= c & 16);
-  b = a.entangledLanes;
-  if (0 !== b) for (a = a.entanglements, b &= d; 0 < b; ) c = 31 - oc(b), e = 1 << c, d |= a[c], b &= ~e;
-  return d;
-}
-function vc(a, b) {
-  switch (a) {
+      return a2;
+  }
+}
+function uc(a2, b2) {
+  var c2 = a2.pendingLanes;
+  if (0 === c2) return 0;
+  var d2 = 0, e2 = a2.suspendedLanes, f2 = a2.pingedLanes, g2 = c2 & 268435455;
+  if (0 !== g2) {
+    var h2 = g2 & ~e2;
+    0 !== h2 ? d2 = tc(h2) : (f2 &= g2, 0 !== f2 && (d2 = tc(f2)));
+  } else g2 = c2 & ~e2, 0 !== g2 ? d2 = tc(g2) : 0 !== f2 && (d2 = tc(f2));
+  if (0 === d2) return 0;
+  if (0 !== b2 && b2 !== d2 && 0 === (b2 & e2) && (e2 = d2 & -d2, f2 = b2 & -b2, e2 >= f2 || 16 === e2 && 0 !== (f2 & 4194240))) return b2;
+  0 !== (d2 & 4) && (d2 |= c2 & 16);
+  b2 = a2.entangledLanes;
+  if (0 !== b2) for (a2 = a2.entanglements, b2 &= d2; 0 < b2; ) c2 = 31 - oc(b2), e2 = 1 << c2, d2 |= a2[c2], b2 &= ~e2;
+  return d2;
+}
+function vc(a2, b2) {
+  switch (a2) {
     case 1:
     case 2:
     case 4:
-      return b + 250;
+      return b2 + 250;
     case 8:
     case 16:
     case 32:
@@ -1490,7 +1490,7 @@ function vc(a, b) {
     case 524288:
     case 1048576:
     case 2097152:
-      return b + 5e3;
+      return b2 + 5e3;
     case 4194304:
     case 8388608:
     case 16777216:
@@ -1506,70 +1506,70 @@ function vc(a, b) {
       return -1;
   }
 }
-function wc(a, b) {
-  for (var c = a.suspendedLanes, d = a.pingedLanes, e = a.expirationTimes, f2 = a.pendingLanes; 0 < f2; ) {
-    var g = 31 - oc(f2), h = 1 << g, k2 = e[g];
+function wc(a2, b2) {
+  for (var c2 = a2.suspendedLanes, d2 = a2.pingedLanes, e2 = a2.expirationTimes, f2 = a2.pendingLanes; 0 < f2; ) {
+    var g2 = 31 - oc(f2), h2 = 1 << g2, k2 = e2[g2];
     if (-1 === k2) {
-      if (0 === (h & c) || 0 !== (h & d)) e[g] = vc(h, b);
-    } else k2 <= b && (a.expiredLanes |= h);
-    f2 &= ~h;
+      if (0 === (h2 & c2) || 0 !== (h2 & d2)) e2[g2] = vc(h2, b2);
+    } else k2 <= b2 && (a2.expiredLanes |= h2);
+    f2 &= ~h2;
   }
 }
-function xc(a) {
-  a = a.pendingLanes & -1073741825;
-  return 0 !== a ? a : a & 1073741824 ? 1073741824 : 0;
+function xc(a2) {
+  a2 = a2.pendingLanes & -1073741825;
+  return 0 !== a2 ? a2 : a2 & 1073741824 ? 1073741824 : 0;
 }
 function yc() {
-  var a = rc;
+  var a2 = rc;
   rc <<= 1;
   0 === (rc & 4194240) && (rc = 64);
-  return a;
+  return a2;
 }
-function zc(a) {
-  for (var b = [], c = 0; 31 > c; c++) b.push(a);
-  return b;
+function zc(a2) {
+  for (var b2 = [], c2 = 0; 31 > c2; c2++) b2.push(a2);
+  return b2;
+}
+function Ac(a2, b2, c2) {
+  a2.pendingLanes |= b2;
+  536870912 !== b2 && (a2.suspendedLanes = 0, a2.pingedLanes = 0);
+  a2 = a2.eventTimes;
+  b2 = 31 - oc(b2);
+  a2[b2] = c2;
+}
+function Bc(a2, b2) {
+  var c2 = a2.pendingLanes & ~b2;
+  a2.pendingLanes = b2;
+  a2.suspendedLanes = 0;
+  a2.pingedLanes = 0;
+  a2.expiredLanes &= b2;
+  a2.mutableReadLanes &= b2;
+  a2.entangledLanes &= b2;
+  b2 = a2.entanglements;
+  var d2 = a2.eventTimes;
+  for (a2 = a2.expirationTimes; 0 < c2; ) {
+    var e2 = 31 - oc(c2), f2 = 1 << e2;
+    b2[e2] = 0;
+    d2[e2] = -1;
+    a2[e2] = -1;
+    c2 &= ~f2;
+  }
 }
-function Ac(a, b, c) {
-  a.pendingLanes |= b;
-  536870912 !== b && (a.suspendedLanes = 0, a.pingedLanes = 0);
-  a = a.eventTimes;
-  b = 31 - oc(b);
-  a[b] = c;
-}
-function Bc(a, b) {
-  var c = a.pendingLanes & ~b;
-  a.pendingLanes = b;
-  a.suspendedLanes = 0;
-  a.pingedLanes = 0;
-  a.expiredLanes &= b;
-  a.mutableReadLanes &= b;
-  a.entangledLanes &= b;
-  b = a.entanglements;
-  var d = a.eventTimes;
-  for (a = a.expirationTimes; 0 < c; ) {
-    var e = 31 - oc(c), f2 = 1 << e;
-    b[e] = 0;
-    d[e] = -1;
-    a[e] = -1;
-    c &= ~f2;
-  }
-}
-function Cc(a, b) {
-  var c = a.entangledLanes |= b;
-  for (a = a.entanglements; c; ) {
-    var d = 31 - oc(c), e = 1 << d;
-    e & b | a[d] & b && (a[d] |= b);
-    c &= ~e;
-  }
-}
-var C = 0;
-function Dc(a) {
-  a &= -a;
-  return 1 < a ? 4 < a ? 0 !== (a & 268435455) ? 16 : 536870912 : 4 : 1;
+function Cc(a2, b2) {
+  var c2 = a2.entangledLanes |= b2;
+  for (a2 = a2.entanglements; c2; ) {
+    var d2 = 31 - oc(c2), e2 = 1 << d2;
+    e2 & b2 | a2[d2] & b2 && (a2[d2] |= b2);
+    c2 &= ~e2;
+  }
+}
+var C$1 = 0;
+function Dc(a2) {
+  a2 &= -a2;
+  return 1 < a2 ? 4 < a2 ? 0 !== (a2 & 268435455) ? 16 : 536870912 : 4 : 1;
 }
 var Ec, Fc, Gc, Hc, Ic, Jc = false, Kc = [], Lc = null, Mc = null, Nc = null, Oc = /* @__PURE__ */ new Map(), Pc = /* @__PURE__ */ new Map(), Qc = [], Rc = "mousedown mouseup touchcancel touchend touchstart auxclick dblclick pointercancel pointerdown pointerup dragend dragstart drop compositionend compositionstart keydown keypress keyup input textInput copy cut paste click change contextmenu reset submit".split(" ");
-function Sc(a, b) {
-  switch (a) {
+function Sc(a2, b2) {
+  switch (a2) {
     case "focusin":
     case "focusout":
       Lc = null;
@@ -1584,75 +1584,75 @@ function Sc(a, b) {
       break;
     case "pointerover":
     case "pointerout":
-      Oc.delete(b.pointerId);
+      Oc.delete(b2.pointerId);
       break;
     case "gotpointercapture":
     case "lostpointercapture":
-      Pc.delete(b.pointerId);
+      Pc.delete(b2.pointerId);
   }
 }
-function Tc(a, b, c, d, e, f2) {
-  if (null === a || a.nativeEvent !== f2) return a = { blockedOn: b, domEventName: c, eventSystemFlags: d, nativeEvent: f2, targetContainers: [e] }, null !== b && (b = Cb(b), null !== b && Fc(b)), a;
-  a.eventSystemFlags |= d;
-  b = a.targetContainers;
-  null !== e && -1 === b.indexOf(e) && b.push(e);
-  return a;
+function Tc(a2, b2, c2, d2, e2, f2) {
+  if (null === a2 || a2.nativeEvent !== f2) return a2 = { blockedOn: b2, domEventName: c2, eventSystemFlags: d2, nativeEvent: f2, targetContainers: [e2] }, null !== b2 && (b2 = Cb(b2), null !== b2 && Fc(b2)), a2;
+  a2.eventSystemFlags |= d2;
+  b2 = a2.targetContainers;
+  null !== e2 && -1 === b2.indexOf(e2) && b2.push(e2);
+  return a2;
 }
-function Uc(a, b, c, d, e) {
-  switch (b) {
+function Uc(a2, b2, c2, d2, e2) {
+  switch (b2) {
     case "focusin":
-      return Lc = Tc(Lc, a, b, c, d, e), true;
+      return Lc = Tc(Lc, a2, b2, c2, d2, e2), true;
     case "dragenter":
-      return Mc = Tc(Mc, a, b, c, d, e), true;
+      return Mc = Tc(Mc, a2, b2, c2, d2, e2), true;
     case "mouseover":
-      return Nc = Tc(Nc, a, b, c, d, e), true;
+      return Nc = Tc(Nc, a2, b2, c2, d2, e2), true;
     case "pointerover":
-      var f2 = e.pointerId;
-      Oc.set(f2, Tc(Oc.get(f2) || null, a, b, c, d, e));
+      var f2 = e2.pointerId;
+      Oc.set(f2, Tc(Oc.get(f2) || null, a2, b2, c2, d2, e2));
       return true;
     case "gotpointercapture":
-      return f2 = e.pointerId, Pc.set(f2, Tc(Pc.get(f2) || null, a, b, c, d, e)), true;
+      return f2 = e2.pointerId, Pc.set(f2, Tc(Pc.get(f2) || null, a2, b2, c2, d2, e2)), true;
   }
   return false;
 }
-function Vc(a) {
-  var b = Wc(a.target);
-  if (null !== b) {
-    var c = Vb(b);
-    if (null !== c) {
-      if (b = c.tag, 13 === b) {
-        if (b = Wb(c), null !== b) {
-          a.blockedOn = b;
-          Ic(a.priority, function() {
-            Gc(c);
+function Vc(a2) {
+  var b2 = Wc(a2.target);
+  if (null !== b2) {
+    var c2 = Vb(b2);
+    if (null !== c2) {
+      if (b2 = c2.tag, 13 === b2) {
+        if (b2 = Wb(c2), null !== b2) {
+          a2.blockedOn = b2;
+          Ic(a2.priority, function() {
+            Gc(c2);
           });
           return;
         }
-      } else if (3 === b && c.stateNode.current.memoizedState.isDehydrated) {
-        a.blockedOn = 3 === c.tag ? c.stateNode.containerInfo : null;
+      } else if (3 === b2 && c2.stateNode.current.memoizedState.isDehydrated) {
+        a2.blockedOn = 3 === c2.tag ? c2.stateNode.containerInfo : null;
         return;
       }
     }
   }
-  a.blockedOn = null;
+  a2.blockedOn = null;
 }
-function Xc(a) {
-  if (null !== a.blockedOn) return false;
-  for (var b = a.targetContainers; 0 < b.length; ) {
-    var c = Yc(a.domEventName, a.eventSystemFlags, b[0], a.nativeEvent);
-    if (null === c) {
-      c = a.nativeEvent;
-      var d = new c.constructor(c.type, c);
-      wb = d;
-      c.target.dispatchEvent(d);
+function Xc(a2) {
+  if (null !== a2.blockedOn) return false;
+  for (var b2 = a2.targetContainers; 0 < b2.length; ) {
+    var c2 = Yc(a2.domEventName, a2.eventSystemFlags, b2[0], a2.nativeEvent);
+    if (null === c2) {
+      c2 = a2.nativeEvent;
+      var d2 = new c2.constructor(c2.type, c2);
+      wb = d2;
+      c2.target.dispatchEvent(d2);
       wb = null;
-    } else return b = Cb(c), null !== b && Fc(b), a.blockedOn = c, false;
-    b.shift();
+    } else return b2 = Cb(c2), null !== b2 && Fc(b2), a2.blockedOn = c2, false;
+    b2.shift();
   }
   return true;
 }
-function Zc(a, b, c) {
-  Xc(a) && c.delete(b);
+function Zc(a2, b2, c2) {
+  Xc(a2) && c2.delete(b2);
 }
 function $c() {
   Jc = false;
@@ -1662,84 +1662,84 @@ function $c() {
   Oc.forEach(Zc);
   Pc.forEach(Zc);
 }
-function ad(a, b) {
-  a.blockedOn === b && (a.blockedOn = null, Jc || (Jc = true, ca.unstable_scheduleCallback(ca.unstable_NormalPriority, $c)));
+function ad(a2, b2) {
+  a2.blockedOn === b2 && (a2.blockedOn = null, Jc || (Jc = true, ca.unstable_scheduleCallback(ca.unstable_NormalPriority, $c)));
 }
-function bd(a) {
-  function b(b2) {
-    return ad(b2, a);
+function bd(a2) {
+  function b2(b3) {
+    return ad(b3, a2);
   }
   if (0 < Kc.length) {
-    ad(Kc[0], a);
-    for (var c = 1; c < Kc.length; c++) {
-      var d = Kc[c];
-      d.blockedOn === a && (d.blockedOn = null);
+    ad(Kc[0], a2);
+    for (var c2 = 1; c2 < Kc.length; c2++) {
+      var d2 = Kc[c2];
+      d2.blockedOn === a2 && (d2.blockedOn = null);
     }
   }
-  null !== Lc && ad(Lc, a);
-  null !== Mc && ad(Mc, a);
-  null !== Nc && ad(Nc, a);
-  Oc.forEach(b);
-  Pc.forEach(b);
-  for (c = 0; c < Qc.length; c++) d = Qc[c], d.blockedOn === a && (d.blockedOn = null);
-  for (; 0 < Qc.length && (c = Qc[0], null === c.blockedOn); ) Vc(c), null === c.blockedOn && Qc.shift();
+  null !== Lc && ad(Lc, a2);
+  null !== Mc && ad(Mc, a2);
+  null !== Nc && ad(Nc, a2);
+  Oc.forEach(b2);
+  Pc.forEach(b2);
+  for (c2 = 0; c2 < Qc.length; c2++) d2 = Qc[c2], d2.blockedOn === a2 && (d2.blockedOn = null);
+  for (; 0 < Qc.length && (c2 = Qc[0], null === c2.blockedOn); ) Vc(c2), null === c2.blockedOn && Qc.shift();
 }
 var cd = ua.ReactCurrentBatchConfig, dd = true;
-function ed(a, b, c, d) {
-  var e = C, f2 = cd.transition;
+function ed(a2, b2, c2, d2) {
+  var e2 = C$1, f2 = cd.transition;
   cd.transition = null;
   try {
-    C = 1, fd(a, b, c, d);
+    C$1 = 1, fd(a2, b2, c2, d2);
   } finally {
-    C = e, cd.transition = f2;
+    C$1 = e2, cd.transition = f2;
   }
 }
-function gd(a, b, c, d) {
-  var e = C, f2 = cd.transition;
+function gd(a2, b2, c2, d2) {
+  var e2 = C$1, f2 = cd.transition;
   cd.transition = null;
   try {
-    C = 4, fd(a, b, c, d);
+    C$1 = 4, fd(a2, b2, c2, d2);
   } finally {
-    C = e, cd.transition = f2;
+    C$1 = e2, cd.transition = f2;
   }
 }
-function fd(a, b, c, d) {
+function fd(a2, b2, c2, d2) {
   if (dd) {
-    var e = Yc(a, b, c, d);
-    if (null === e) hd(a, b, d, id, c), Sc(a, d);
-    else if (Uc(e, a, b, c, d)) d.stopPropagation();
-    else if (Sc(a, d), b & 4 && -1 < Rc.indexOf(a)) {
-      for (; null !== e; ) {
-        var f2 = Cb(e);
+    var e2 = Yc(a2, b2, c2, d2);
+    if (null === e2) hd(a2, b2, d2, id, c2), Sc(a2, d2);
+    else if (Uc(e2, a2, b2, c2, d2)) d2.stopPropagation();
+    else if (Sc(a2, d2), b2 & 4 && -1 < Rc.indexOf(a2)) {
+      for (; null !== e2; ) {
+        var f2 = Cb(e2);
         null !== f2 && Ec(f2);
-        f2 = Yc(a, b, c, d);
-        null === f2 && hd(a, b, d, id, c);
-        if (f2 === e) break;
-        e = f2;
+        f2 = Yc(a2, b2, c2, d2);
+        null === f2 && hd(a2, b2, d2, id, c2);
+        if (f2 === e2) break;
+        e2 = f2;
       }
-      null !== e && d.stopPropagation();
-    } else hd(a, b, d, null, c);
+      null !== e2 && d2.stopPropagation();
+    } else hd(a2, b2, d2, null, c2);
   }
 }
 var id = null;
-function Yc(a, b, c, d) {
+function Yc(a2, b2, c2, d2) {
   id = null;
-  a = xb(d);
-  a = Wc(a);
-  if (null !== a) if (b = Vb(a), null === b) a = null;
-  else if (c = b.tag, 13 === c) {
-    a = Wb(b);
-    if (null !== a) return a;
-    a = null;
-  } else if (3 === c) {
-    if (b.stateNode.current.memoizedState.isDehydrated) return 3 === b.tag ? b.stateNode.containerInfo : null;
-    a = null;
-  } else b !== a && (a = null);
-  id = a;
+  a2 = xb(d2);
+  a2 = Wc(a2);
+  if (null !== a2) if (b2 = Vb(a2), null === b2) a2 = null;
+  else if (c2 = b2.tag, 13 === c2) {
+    a2 = Wb(b2);
+    if (null !== a2) return a2;
+    a2 = null;
+  } else if (3 === c2) {
+    if (b2.stateNode.current.memoizedState.isDehydrated) return 3 === b2.tag ? b2.stateNode.containerInfo : null;
+    a2 = null;
+  } else b2 !== a2 && (a2 = null);
+  id = a2;
   return null;
 }
-function jd(a) {
-  switch (a) {
+function jd(a2) {
+  switch (a2) {
     case "cancel":
     case "click":
     case "close":
@@ -1833,17 +1833,17 @@ function jd(a) {
 var kd = null, ld = null, md = null;
 function nd() {
   if (md) return md;
-  var a, b = ld, c = b.length, d, e = "value" in kd ? kd.value : kd.textContent, f2 = e.length;
-  for (a = 0; a < c && b[a] === e[a]; a++) ;
-  var g = c - a;
-  for (d = 1; d <= g && b[c - d] === e[f2 - d]; d++) ;
-  return md = e.slice(a, 1 < d ? 1 - d : void 0);
-}
-function od(a) {
-  var b = a.keyCode;
-  "charCode" in a ? (a = a.charCode, 0 === a && 13 === b && (a = 13)) : a = b;
-  10 === a && (a = 13);
-  return 32 <= a || 13 === a ? a : 0;
+  var a2, b2 = ld, c2 = b2.length, d2, e2 = "value" in kd ? kd.value : kd.textContent, f2 = e2.length;
+  for (a2 = 0; a2 < c2 && b2[a2] === e2[a2]; a2++) ;
+  var g2 = c2 - a2;
+  for (d2 = 1; d2 <= g2 && b2[c2 - d2] === e2[f2 - d2]; d2++) ;
+  return md = e2.slice(a2, 1 < d2 ? 1 - d2 : void 0);
+}
+function od(a2) {
+  var b2 = a2.keyCode;
+  "charCode" in a2 ? (a2 = a2.charCode, 0 === a2 && 13 === b2 && (a2 = 13)) : a2 = b2;
+  10 === a2 && (a2 = 13);
+  return 32 <= a2 || 13 === a2 ? a2 : 0;
 }
 function pd() {
   return true;
@@ -1851,43 +1851,43 @@ function pd() {
 function qd() {
   return false;
 }
-function rd(a) {
-  function b(b2, d, e, f2, g) {
-    this._reactName = b2;
-    this._targetInst = e;
-    this.type = d;
+function rd(a2) {
+  function b2(b3, d2, e2, f2, g2) {
+    this._reactName = b3;
+    this._targetInst = e2;
+    this.type = d2;
     this.nativeEvent = f2;
-    this.target = g;
+    this.target = g2;
     this.currentTarget = null;
-    for (var c in a) a.hasOwnProperty(c) && (b2 = a[c], this[c] = b2 ? b2(f2) : f2[c]);
+    for (var c2 in a2) a2.hasOwnProperty(c2) && (b3 = a2[c2], this[c2] = b3 ? b3(f2) : f2[c2]);
     this.isDefaultPrevented = (null != f2.defaultPrevented ? f2.defaultPrevented : false === f2.returnValue) ? pd : qd;
     this.isPropagationStopped = qd;
     return this;
   }
-  A(b.prototype, { preventDefault: function() {
+  A$1(b2.prototype, { preventDefault: function() {
     this.defaultPrevented = true;
-    var a2 = this.nativeEvent;
-    a2 && (a2.preventDefault ? a2.preventDefault() : "unknown" !== typeof a2.returnValue && (a2.returnValue = false), this.isDefaultPrevented = pd);
+    var a3 = this.nativeEvent;
+    a3 && (a3.preventDefault ? a3.preventDefault() : "unknown" !== typeof a3.returnValue && (a3.returnValue = false), this.isDefaultPrevented = pd);
   }, stopPropagation: function() {
-    var a2 = this.nativeEvent;
-    a2 && (a2.stopPropagation ? a2.stopPropagation() : "unknown" !== typeof a2.cancelBubble && (a2.cancelBubble = true), this.isPropagationStopped = pd);
+    var a3 = this.nativeEvent;
+    a3 && (a3.stopPropagation ? a3.stopPropagation() : "unknown" !== typeof a3.cancelBubble && (a3.cancelBubble = true), this.isPropagationStopped = pd);
   }, persist: function() {
   }, isPersistent: pd });
-  return b;
+  return b2;
 }
-var sd = { eventPhase: 0, bubbles: 0, cancelable: 0, timeStamp: function(a) {
-  return a.timeStamp || Date.now();
-}, defaultPrevented: 0, isTrusted: 0 }, td = rd(sd), ud = A({}, sd, { view: 0, detail: 0 }), vd = rd(ud), wd, xd, yd, Ad = A({}, ud, { screenX: 0, screenY: 0, clientX: 0, clientY: 0, pageX: 0, pageY: 0, ctrlKey: 0, shiftKey: 0, altKey: 0, metaKey: 0, getModifierState: zd, button: 0, buttons: 0, relatedTarget: function(a) {
-  return void 0 === a.relatedTarget ? a.fromElement === a.srcElement ? a.toElement : a.fromElement : a.relatedTarget;
-}, movementX: function(a) {
-  if ("movementX" in a) return a.movementX;
-  a !== yd && (yd && "mousemove" === a.type ? (wd = a.screenX - yd.screenX, xd = a.screenY - yd.screenY) : xd = wd = 0, yd = a);
+var sd = { eventPhase: 0, bubbles: 0, cancelable: 0, timeStamp: function(a2) {
+  return a2.timeStamp || Date.now();
+}, defaultPrevented: 0, isTrusted: 0 }, td = rd(sd), ud = A$1({}, sd, { view: 0, detail: 0 }), vd = rd(ud), wd, xd, yd, Ad = A$1({}, ud, { screenX: 0, screenY: 0, clientX: 0, clientY: 0, pageX: 0, pageY: 0, ctrlKey: 0, shiftKey: 0, altKey: 0, metaKey: 0, getModifierState: zd, button: 0, buttons: 0, relatedTarget: function(a2) {
+  return void 0 === a2.relatedTarget ? a2.fromElement === a2.srcElement ? a2.toElement : a2.fromElement : a2.relatedTarget;
+}, movementX: function(a2) {
+  if ("movementX" in a2) return a2.movementX;
+  a2 !== yd && (yd && "mousemove" === a2.type ? (wd = a2.screenX - yd.screenX, xd = a2.screenY - yd.screenY) : xd = wd = 0, yd = a2);
   return wd;
-}, movementY: function(a) {
-  return "movementY" in a ? a.movementY : xd;
-} }), Bd = rd(Ad), Cd = A({}, Ad, { dataTransfer: 0 }), Dd = rd(Cd), Ed = A({}, ud, { relatedTarget: 0 }), Fd = rd(Ed), Gd = A({}, sd, { animationName: 0, elapsedTime: 0, pseudoElement: 0 }), Hd = rd(Gd), Id = A({}, sd, { clipboardData: function(a) {
-  return "clipboardData" in a ? a.clipboardData : window.clipboardData;
-} }), Jd = rd(Id), Kd = A({}, sd, { data: 0 }), Ld = rd(Kd), Md = {
+}, movementY: function(a2) {
+  return "movementY" in a2 ? a2.movementY : xd;
+} }), Bd = rd(Ad), Cd = A$1({}, Ad, { dataTransfer: 0 }), Dd = rd(Cd), Ed = A$1({}, ud, { relatedTarget: 0 }), Fd = rd(Ed), Gd = A$1({}, sd, { animationName: 0, elapsedTime: 0, pseudoElement: 0 }), Hd = rd(Gd), Id = A$1({}, sd, { clipboardData: function(a2) {
+  return "clipboardData" in a2 ? a2.clipboardData : window.clipboardData;
+} }), Jd = rd(Id), Kd = A$1({}, sd, { data: 0 }), Ld = rd(Kd), Md = {
   Esc: "Escape",
   Spacebar: " ",
   Left: "ArrowLeft",
@@ -1938,43 +1938,43 @@ var sd = { eventPhase: 0, bubbles: 0, cancelable: 0, timeStamp: function(a) {
   145: "ScrollLock",
   224: "Meta"
 }, Od = { Alt: "altKey", Control: "ctrlKey", Meta: "metaKey", Shift: "shiftKey" };
-function Pd(a) {
-  var b = this.nativeEvent;
-  return b.getModifierState ? b.getModifierState(a) : (a = Od[a]) ? !!b[a] : false;
+function Pd(a2) {
+  var b2 = this.nativeEvent;
+  return b2.getModifierState ? b2.getModifierState(a2) : (a2 = Od[a2]) ? !!b2[a2] : false;
 }
 function zd() {
   return Pd;
 }
-var Qd = A({}, ud, { key: function(a) {
-  if (a.key) {
-    var b = Md[a.key] || a.key;
-    if ("Unidentified" !== b) return b;
-  }
-  return "keypress" === a.type ? (a = od(a), 13 === a ? "Enter" : String.fromCharCode(a)) : "keydown" === a.type || "keyup" === a.type ? Nd[a.keyCode] || "Unidentified" : "";
-}, code: 0, location: 0, ctrlKey: 0, shiftKey: 0, altKey: 0, metaKey: 0, repeat: 0, locale: 0, getModifierState: zd, charCode: function(a) {
-  return "keypress" === a.type ? od(a) : 0;
-}, keyCode: function(a) {
-  return "keydown" === a.type || "keyup" === a.type ? a.keyCode : 0;
-}, which: function(a) {
-  return "keypress" === a.type ? od(a) : "keydown" === a.type || "keyup" === a.type ? a.keyCode : 0;
-} }), Rd = rd(Qd), Sd = A({}, Ad, { pointerId: 0, width: 0, height: 0, pressure: 0, tangentialPressure: 0, tiltX: 0, tiltY: 0, twist: 0, pointerType: 0, isPrimary: 0 }), Td = rd(Sd), Ud = A({}, ud, { touches: 0, targetTouches: 0, changedTouches: 0, altKey: 0, metaKey: 0, ctrlKey: 0, shiftKey: 0, getModifierState: zd }), Vd = rd(Ud), Wd = A({}, sd, { propertyName: 0, elapsedTime: 0, pseudoElement: 0 }), Xd = rd(Wd), Yd = A({}, Ad, {
-  deltaX: function(a) {
-    return "deltaX" in a ? a.deltaX : "wheelDeltaX" in a ? -a.wheelDeltaX : 0;
+var Qd = A$1({}, ud, { key: function(a2) {
+  if (a2.key) {
+    var b2 = Md[a2.key] || a2.key;
+    if ("Unidentified" !== b2) return b2;
+  }
+  return "keypress" === a2.type ? (a2 = od(a2), 13 === a2 ? "Enter" : String.fromCharCode(a2)) : "keydown" === a2.type || "keyup" === a2.type ? Nd[a2.keyCode] || "Unidentified" : "";
+}, code: 0, location: 0, ctrlKey: 0, shiftKey: 0, altKey: 0, metaKey: 0, repeat: 0, locale: 0, getModifierState: zd, charCode: function(a2) {
+  return "keypress" === a2.type ? od(a2) : 0;
+}, keyCode: function(a2) {
+  return "keydown" === a2.type || "keyup" === a2.type ? a2.keyCode : 0;
+}, which: function(a2) {
+  return "keypress" === a2.type ? od(a2) : "keydown" === a2.type || "keyup" === a2.type ? a2.keyCode : 0;
+} }), Rd = rd(Qd), Sd = A$1({}, Ad, { pointerId: 0, width: 0, height: 0, pressure: 0, tangentialPressure: 0, tiltX: 0, tiltY: 0, twist: 0, pointerType: 0, isPrimary: 0 }), Td = rd(Sd), Ud = A$1({}, ud, { touches: 0, targetTouches: 0, changedTouches: 0, altKey: 0, metaKey: 0, ctrlKey: 0, shiftKey: 0, getModifierState: zd }), Vd = rd(Ud), Wd = A$1({}, sd, { propertyName: 0, elapsedTime: 0, pseudoElement: 0 }), Xd = rd(Wd), Yd = A$1({}, Ad, {
+  deltaX: function(a2) {
+    return "deltaX" in a2 ? a2.deltaX : "wheelDeltaX" in a2 ? -a2.wheelDeltaX : 0;
   },
-  deltaY: function(a) {
-    return "deltaY" in a ? a.deltaY : "wheelDeltaY" in a ? -a.wheelDeltaY : "wheelDelta" in a ? -a.wheelDelta : 0;
+  deltaY: function(a2) {
+    return "deltaY" in a2 ? a2.deltaY : "wheelDeltaY" in a2 ? -a2.wheelDeltaY : "wheelDelta" in a2 ? -a2.wheelDelta : 0;
   },
   deltaZ: 0,
   deltaMode: 0
-}), Zd = rd(Yd), $d = [9, 13, 27, 32], ae = ia && "CompositionEvent" in window, be = null;
+}), Zd = rd(Yd), $d = [9, 13, 27, 32], ae$1 = ia && "CompositionEvent" in window, be = null;
 ia && "documentMode" in document && (be = document.documentMode);
-var ce = ia && "TextEvent" in window && !be, de = ia && (!ae || be && 8 < be && 11 >= be), ee = String.fromCharCode(32), fe = false;
-function ge(a, b) {
-  switch (a) {
+var ce$1 = ia && "TextEvent" in window && !be, de$1 = ia && (!ae$1 || be && 8 < be && 11 >= be), ee$1 = String.fromCharCode(32), fe$1 = false;
+function ge$1(a2, b2) {
+  switch (a2) {
     case "keyup":
-      return -1 !== $d.indexOf(b.keyCode);
+      return -1 !== $d.indexOf(b2.keyCode);
     case "keydown":
-      return 229 !== b.keyCode;
+      return 229 !== b2.keyCode;
     case "keypress":
     case "mousedown":
     case "focusout":
@@ -1983,215 +1983,215 @@ function ge(a, b) {
       return false;
   }
 }
-function he(a) {
-  a = a.detail;
-  return "object" === typeof a && "data" in a ? a.data : null;
+function he$1(a2) {
+  a2 = a2.detail;
+  return "object" === typeof a2 && "data" in a2 ? a2.data : null;
 }
-var ie = false;
-function je(a, b) {
-  switch (a) {
+var ie$1 = false;
+function je$1(a2, b2) {
+  switch (a2) {
     case "compositionend":
-      return he(b);
+      return he$1(b2);
     case "keypress":
-      if (32 !== b.which) return null;
-      fe = true;
-      return ee;
+      if (32 !== b2.which) return null;
+      fe$1 = true;
+      return ee$1;
     case "textInput":
-      return a = b.data, a === ee && fe ? null : a;
+      return a2 = b2.data, a2 === ee$1 && fe$1 ? null : a2;
     default:
       return null;
   }
 }
-function ke(a, b) {
-  if (ie) return "compositionend" === a || !ae && ge(a, b) ? (a = nd(), md = ld = kd = null, ie = false, a) : null;
-  switch (a) {
+function ke$1(a2, b2) {
+  if (ie$1) return "compositionend" === a2 || !ae$1 && ge$1(a2, b2) ? (a2 = nd(), md = ld = kd = null, ie$1 = false, a2) : null;
+  switch (a2) {
     case "paste":
       return null;
     case "keypress":
-      if (!(b.ctrlKey || b.altKey || b.metaKey) || b.ctrlKey && b.altKey) {
-        if (b.char && 1 < b.char.length) return b.char;
-        if (b.which) return String.fromCharCode(b.which);
+      if (!(b2.ctrlKey || b2.altKey || b2.metaKey) || b2.ctrlKey && b2.altKey) {
+        if (b2.char && 1 < b2.char.length) return b2.char;
+        if (b2.which) return String.fromCharCode(b2.which);
       }
       return null;
     case "compositionend":
-      return de && "ko" !== b.locale ? null : b.data;
+      return de$1 && "ko" !== b2.locale ? null : b2.data;
     default:
       return null;
   }
 }
-var le = { color: true, date: true, datetime: true, "datetime-local": true, email: true, month: true, number: true, password: true, range: true, search: true, tel: true, text: true, time: true, url: true, week: true };
-function me(a) {
-  var b = a && a.nodeName && a.nodeName.toLowerCase();
-  return "input" === b ? !!le[a.type] : "textarea" === b ? true : false;
+var le$1 = { color: true, date: true, datetime: true, "datetime-local": true, email: true, month: true, number: true, password: true, range: true, search: true, tel: true, text: true, time: true, url: true, week: true };
+function me$1(a2) {
+  var b2 = a2 && a2.nodeName && a2.nodeName.toLowerCase();
+  return "input" === b2 ? !!le$1[a2.type] : "textarea" === b2 ? true : false;
 }
-function ne(a, b, c, d) {
-  Eb(d);
-  b = oe(b, "onChange");
-  0 < b.length && (c = new td("onChange", "change", null, c, d), a.push({ event: c, listeners: b }));
+function ne$1(a2, b2, c2, d2) {
+  Eb(d2);
+  b2 = oe$1(b2, "onChange");
+  0 < b2.length && (c2 = new td("onChange", "change", null, c2, d2), a2.push({ event: c2, listeners: b2 }));
 }
-var pe = null, qe = null;
-function re(a) {
-  se(a, 0);
+var pe$1 = null, qe$1 = null;
+function re$1(a2) {
+  se$1(a2, 0);
 }
-function te(a) {
-  var b = ue(a);
-  if (Wa(b)) return a;
+function te$1(a2) {
+  var b2 = ue$1(a2);
+  if (Wa(b2)) return a2;
 }
-function ve(a, b) {
-  if ("change" === a) return b;
+function ve$1(a2, b2) {
+  if ("change" === a2) return b2;
 }
-var we = false;
+var we$1 = false;
 if (ia) {
-  var xe;
+  var xe$1;
   if (ia) {
-    var ye = "oninput" in document;
-    if (!ye) {
-      var ze = document.createElement("div");
-      ze.setAttribute("oninput", "return;");
-      ye = "function" === typeof ze.oninput;
+    var ye$1 = "oninput" in document;
+    if (!ye$1) {
+      var ze$1 = document.createElement("div");
+      ze$1.setAttribute("oninput", "return;");
+      ye$1 = "function" === typeof ze$1.oninput;
     }
-    xe = ye;
-  } else xe = false;
-  we = xe && (!document.documentMode || 9 < document.documentMode);
+    xe$1 = ye$1;
+  } else xe$1 = false;
+  we$1 = xe$1 && (!document.documentMode || 9 < document.documentMode);
 }
-function Ae() {
-  pe && (pe.detachEvent("onpropertychange", Be), qe = pe = null);
+function Ae$1() {
+  pe$1 && (pe$1.detachEvent("onpropertychange", Be$1), qe$1 = pe$1 = null);
 }
-function Be(a) {
-  if ("value" === a.propertyName && te(qe)) {
-    var b = [];
-    ne(b, qe, a, xb(a));
-    Jb(re, b);
+function Be$1(a2) {
+  if ("value" === a2.propertyName && te$1(qe$1)) {
+    var b2 = [];
+    ne$1(b2, qe$1, a2, xb(a2));
+    Jb(re$1, b2);
   }
 }
-function Ce(a, b, c) {
-  "focusin" === a ? (Ae(), pe = b, qe = c, pe.attachEvent("onpropertychange", Be)) : "focusout" === a && Ae();
+function Ce$1(a2, b2, c2) {
+  "focusin" === a2 ? (Ae$1(), pe$1 = b2, qe$1 = c2, pe$1.attachEvent("onpropertychange", Be$1)) : "focusout" === a2 && Ae$1();
 }
-function De(a) {
-  if ("selectionchange" === a || "keyup" === a || "keydown" === a) return te(qe);
+function De$1(a2) {
+  if ("selectionchange" === a2 || "keyup" === a2 || "keydown" === a2) return te$1(qe$1);
 }
-function Ee(a, b) {
-  if ("click" === a) return te(b);
+function Ee$1(a2, b2) {
+  if ("click" === a2) return te$1(b2);
 }
-function Fe(a, b) {
-  if ("input" === a || "change" === a) return te(b);
+function Fe$1(a2, b2) {
+  if ("input" === a2 || "change" === a2) return te$1(b2);
 }
-function Ge(a, b) {
-  return a === b && (0 !== a || 1 / a === 1 / b) || a !== a && b !== b;
+function Ge$1(a2, b2) {
+  return a2 === b2 && (0 !== a2 || 1 / a2 === 1 / b2) || a2 !== a2 && b2 !== b2;
 }
-var He = "function" === typeof Object.is ? Object.is : Ge;
-function Ie(a, b) {
-  if (He(a, b)) return true;
-  if ("object" !== typeof a || null === a || "object" !== typeof b || null === b) return false;
-  var c = Object.keys(a), d = Object.keys(b);
-  if (c.length !== d.length) return false;
-  for (d = 0; d < c.length; d++) {
-    var e = c[d];
-    if (!ja.call(b, e) || !He(a[e], b[e])) return false;
+var He$1 = "function" === typeof Object.is ? Object.is : Ge$1;
+function Ie$1(a2, b2) {
+  if (He$1(a2, b2)) return true;
+  if ("object" !== typeof a2 || null === a2 || "object" !== typeof b2 || null === b2) return false;
+  var c2 = Object.keys(a2), d2 = Object.keys(b2);
+  if (c2.length !== d2.length) return false;
+  for (d2 = 0; d2 < c2.length; d2++) {
+    var e2 = c2[d2];
+    if (!ja.call(b2, e2) || !He$1(a2[e2], b2[e2])) return false;
   }
   return true;
 }
-function Je(a) {
-  for (; a && a.firstChild; ) a = a.firstChild;
-  return a;
+function Je$1(a2) {
+  for (; a2 && a2.firstChild; ) a2 = a2.firstChild;
+  return a2;
 }
-function Ke(a, b) {
-  var c = Je(a);
-  a = 0;
-  for (var d; c; ) {
-    if (3 === c.nodeType) {
-      d = a + c.textContent.length;
-      if (a <= b && d >= b) return { node: c, offset: b - a };
-      a = d;
+function Ke$1(a2, b2) {
+  var c2 = Je$1(a2);
+  a2 = 0;
+  for (var d2; c2; ) {
+    if (3 === c2.nodeType) {
+      d2 = a2 + c2.textContent.length;
+      if (a2 <= b2 && d2 >= b2) return { node: c2, offset: b2 - a2 };
+      a2 = d2;
     }
     a: {
-      for (; c; ) {
-        if (c.nextSibling) {
-          c = c.nextSibling;
+      for (; c2; ) {
+        if (c2.nextSibling) {
+          c2 = c2.nextSibling;
           break a;
         }
-        c = c.parentNode;
+        c2 = c2.parentNode;
       }
-      c = void 0;
+      c2 = void 0;
     }
-    c = Je(c);
+    c2 = Je$1(c2);
   }
 }
-function Le(a, b) {
-  return a && b ? a === b ? true : a && 3 === a.nodeType ? false : b && 3 === b.nodeType ? Le(a, b.parentNode) : "contains" in a ? a.contains(b) : a.compareDocumentPosition ? !!(a.compareDocumentPosition(b) & 16) : false : false;
+function Le$1(a2, b2) {
+  return a2 && b2 ? a2 === b2 ? true : a2 && 3 === a2.nodeType ? false : b2 && 3 === b2.nodeType ? Le$1(a2, b2.parentNode) : "contains" in a2 ? a2.contains(b2) : a2.compareDocumentPosition ? !!(a2.compareDocumentPosition(b2) & 16) : false : false;
 }
-function Me() {
-  for (var a = window, b = Xa(); b instanceof a.HTMLIFrameElement; ) {
+function Me$1() {
+  for (var a2 = window, b2 = Xa(); b2 instanceof a2.HTMLIFrameElement; ) {
     try {
-      var c = "string" === typeof b.contentWindow.location.href;
-    } catch (d) {
-      c = false;
+      var c2 = "string" === typeof b2.contentWindow.location.href;
+    } catch (d2) {
+      c2 = false;
     }
-    if (c) a = b.contentWindow;
+    if (c2) a2 = b2.contentWindow;
     else break;
-    b = Xa(a.document);
+    b2 = Xa(a2.document);
   }
-  return b;
+  return b2;
+}
+function Ne$1(a2) {
+  var b2 = a2 && a2.nodeName && a2.nodeName.toLowerCase();
+  return b2 && ("input" === b2 && ("text" === a2.type || "search" === a2.type || "tel" === a2.type || "url" === a2.type || "password" === a2.type) || "textarea" === b2 || "true" === a2.contentEditable);
 }
-function Ne(a) {
-  var b = a && a.nodeName && a.nodeName.toLowerCase();
-  return b && ("input" === b && ("text" === a.type || "search" === a.type || "tel" === a.type || "url" === a.type || "password" === a.type) || "textarea" === b || "true" === a.contentEditable);
-}
-function Oe(a) {
-  var b = Me(), c = a.focusedElem, d = a.selectionRange;
-  if (b !== c && c && c.ownerDocument && Le(c.ownerDocument.documentElement, c)) {
-    if (null !== d && Ne(c)) {
-      if (b = d.start, a = d.end, void 0 === a && (a = b), "selectionStart" in c) c.selectionStart = b, c.selectionEnd = Math.min(a, c.value.length);
-      else if (a = (b = c.ownerDocument || document) && b.defaultView || window, a.getSelection) {
-        a = a.getSelection();
-        var e = c.textContent.length, f2 = Math.min(d.start, e);
-        d = void 0 === d.end ? f2 : Math.min(d.end, e);
-        !a.extend && f2 > d && (e = d, d = f2, f2 = e);
-        e = Ke(c, f2);
-        var g = Ke(
-          c,
-          d
+function Oe$1(a2) {
+  var b2 = Me$1(), c2 = a2.focusedElem, d2 = a2.selectionRange;
+  if (b2 !== c2 && c2 && c2.ownerDocument && Le$1(c2.ownerDocument.documentElement, c2)) {
+    if (null !== d2 && Ne$1(c2)) {
+      if (b2 = d2.start, a2 = d2.end, void 0 === a2 && (a2 = b2), "selectionStart" in c2) c2.selectionStart = b2, c2.selectionEnd = Math.min(a2, c2.value.length);
+      else if (a2 = (b2 = c2.ownerDocument || document) && b2.defaultView || window, a2.getSelection) {
+        a2 = a2.getSelection();
+        var e2 = c2.textContent.length, f2 = Math.min(d2.start, e2);
+        d2 = void 0 === d2.end ? f2 : Math.min(d2.end, e2);
+        !a2.extend && f2 > d2 && (e2 = d2, d2 = f2, f2 = e2);
+        e2 = Ke$1(c2, f2);
+        var g2 = Ke$1(
+          c2,
+          d2
         );
-        e && g && (1 !== a.rangeCount || a.anchorNode !== e.node || a.anchorOffset !== e.offset || a.focusNode !== g.node || a.focusOffset !== g.offset) && (b = b.createRange(), b.setStart(e.node, e.offset), a.removeAllRanges(), f2 > d ? (a.addRange(b), a.extend(g.node, g.offset)) : (b.setEnd(g.node, g.offset), a.addRange(b)));
+        e2 && g2 && (1 !== a2.rangeCount || a2.anchorNode !== e2.node || a2.anchorOffset !== e2.offset || a2.focusNode !== g2.node || a2.focusOffset !== g2.offset) && (b2 = b2.createRange(), b2.setStart(e2.node, e2.offset), a2.removeAllRanges(), f2 > d2 ? (a2.addRange(b2), a2.extend(g2.node, g2.offset)) : (b2.setEnd(g2.node, g2.offset), a2.addRange(b2)));
       }
     }
-    b = [];
-    for (a = c; a = a.parentNode; ) 1 === a.nodeType && b.push({ element: a, left: a.scrollLeft, top: a.scrollTop });
-    "function" === typeof c.focus && c.focus();
-    for (c = 0; c < b.length; c++) a = b[c], a.element.scrollLeft = a.left, a.element.scrollTop = a.top;
+    b2 = [];
+    for (a2 = c2; a2 = a2.parentNode; ) 1 === a2.nodeType && b2.push({ element: a2, left: a2.scrollLeft, top: a2.scrollTop });
+    "function" === typeof c2.focus && c2.focus();
+    for (c2 = 0; c2 < b2.length; c2++) a2 = b2[c2], a2.element.scrollLeft = a2.left, a2.element.scrollTop = a2.top;
   }
 }
-var Pe = ia && "documentMode" in document && 11 >= document.documentMode, Qe = null, Re = null, Se = null, Te = false;
-function Ue(a, b, c) {
-  var d = c.window === c ? c.document : 9 === c.nodeType ? c : c.ownerDocument;
-  Te || null == Qe || Qe !== Xa(d) || (d = Qe, "selectionStart" in d && Ne(d) ? d = { start: d.selectionStart, end: d.selectionEnd } : (d = (d.ownerDocument && d.ownerDocument.defaultView || window).getSelection(), d = { anchorNode: d.anchorNode, anchorOffset: d.anchorOffset, focusNode: d.focusNode, focusOffset: d.focusOffset }), Se && Ie(Se, d) || (Se = d, d = oe(Re, "onSelect"), 0 < d.length && (b = new td("onSelect", "select", null, b, c), a.push({ event: b, listeners: d }), b.target = Qe)));
+var Pe$1 = ia && "documentMode" in document && 11 >= document.documentMode, Qe$1 = null, Re$1 = null, Se$1 = null, Te$1 = false;
+function Ue$1(a2, b2, c2) {
+  var d2 = c2.window === c2 ? c2.document : 9 === c2.nodeType ? c2 : c2.ownerDocument;
+  Te$1 || null == Qe$1 || Qe$1 !== Xa(d2) || (d2 = Qe$1, "selectionStart" in d2 && Ne$1(d2) ? d2 = { start: d2.selectionStart, end: d2.selectionEnd } : (d2 = (d2.ownerDocument && d2.ownerDocument.defaultView || window).getSelection(), d2 = { anchorNode: d2.anchorNode, anchorOffset: d2.anchorOffset, focusNode: d2.focusNode, focusOffset: d2.focusOffset }), Se$1 && Ie$1(Se$1, d2) || (Se$1 = d2, d2 = oe$1(Re$1, "onSelect"), 0 < d2.length && (b2 = new td("onSelect", "select", null, b2, c2), a2.push({ event: b2, listeners: d2 }), b2.target = Qe$1)));
 }
-function Ve(a, b) {
-  var c = {};
-  c[a.toLowerCase()] = b.toLowerCase();
-  c["Webkit" + a] = "webkit" + b;
-  c["Moz" + a] = "moz" + b;
-  return c;
+function Ve$1(a2, b2) {
+  var c2 = {};
+  c2[a2.toLowerCase()] = b2.toLowerCase();
+  c2["Webkit" + a2] = "webkit" + b2;
+  c2["Moz" + a2] = "moz" + b2;
+  return c2;
 }
-var We = { animationend: Ve("Animation", "AnimationEnd"), animationiteration: Ve("Animation", "AnimationIteration"), animationstart: Ve("Animation", "AnimationStart"), transitionend: Ve("Transition", "TransitionEnd") }, Xe = {}, Ye = {};
-ia && (Ye = document.createElement("div").style, "AnimationEvent" in window || (delete We.animationend.animation, delete We.animationiteration.animation, delete We.animationstart.animation), "TransitionEvent" in window || delete We.transitionend.transition);
-function Ze(a) {
-  if (Xe[a]) return Xe[a];
-  if (!We[a]) return a;
-  var b = We[a], c;
-  for (c in b) if (b.hasOwnProperty(c) && c in Ye) return Xe[a] = b[c];
-  return a;
+var We$1 = { animationend: Ve$1("Animation", "AnimationEnd"), animationiteration: Ve$1("Animation", "AnimationIteration"), animationstart: Ve$1("Animation", "AnimationStart"), transitionend: Ve$1("Transition", "TransitionEnd") }, Xe$1 = {}, Ye$1 = {};
+ia && (Ye$1 = document.createElement("div").style, "AnimationEvent" in window || (delete We$1.animationend.animation, delete We$1.animationiteration.animation, delete We$1.animationstart.animation), "TransitionEvent" in window || delete We$1.transitionend.transition);
+function Ze$1(a2) {
+  if (Xe$1[a2]) return Xe$1[a2];
+  if (!We$1[a2]) return a2;
+  var b2 = We$1[a2], c2;
+  for (c2 in b2) if (b2.hasOwnProperty(c2) && c2 in Ye$1) return Xe$1[a2] = b2[c2];
+  return a2;
 }
-var $e = Ze("animationend"), af = Ze("animationiteration"), bf = Ze("animationstart"), cf = Ze("transitionend"), df = /* @__PURE__ */ new Map(), ef = "abort auxClick cancel canPlay canPlayThrough click close contextMenu copy cut drag dragEnd dragEnter dragExit dragLeave dragOver dragStart drop durationChange emptied encrypted ended error gotPointerCapture input invalid keyDown keyPress keyUp load loadedData loadedMetadata loadStart lostPointerCapture mouseDown mouseMove mouseOut mouseOver mouseUp paste pause play playing pointerCancel pointerDown pointerMove pointerOut pointerOver pointerUp progress rateChange reset resize seeked seeking stalled submit suspend timeUpdate touchCancel touchEnd touchStart volumeChange scroll toggle touchMove waiting wheel".split(" ");
-function ff(a, b) {
-  df.set(a, b);
-  fa(b, [a]);
+var $e$1 = Ze$1("animationend"), af = Ze$1("animationiteration"), bf = Ze$1("animationstart"), cf = Ze$1("transitionend"), df = /* @__PURE__ */ new Map(), ef = "abort auxClick cancel canPlay canPlayThrough click close contextMenu copy cut drag dragEnd dragEnter dragExit dragLeave dragOver dragStart drop durationChange emptied encrypted ended error gotPointerCapture input invalid keyDown keyPress keyUp load loadedData loadedMetadata loadStart lostPointerCapture mouseDown mouseMove mouseOut mouseOver mouseUp paste pause play playing pointerCancel pointerDown pointerMove pointerOut pointerOver pointerUp progress rateChange reset resize seeked seeking stalled submit suspend timeUpdate touchCancel touchEnd touchStart volumeChange scroll toggle touchMove waiting wheel".split(" ");
+function ff(a2, b2) {
+  df.set(a2, b2);
+  fa(b2, [a2]);
 }
 for (var gf = 0; gf < ef.length; gf++) {
   var hf = ef[gf], jf = hf.toLowerCase(), kf = hf[0].toUpperCase() + hf.slice(1);
   ff(jf, "on" + kf);
 }
-ff($e, "onAnimationEnd");
+ff($e$1, "onAnimationEnd");
 ff(af, "onAnimationIteration");
 ff(bf, "onAnimationStart");
 ff("dblclick", "onDoubleClick");
@@ -2209,114 +2209,114 @@ fa("onCompositionEnd", "compositionend focusout keydown keypress keyup mousedown
 fa("onCompositionStart", "compositionstart focusout keydown keypress keyup mousedown".split(" "));
 fa("onCompositionUpdate", "compositionupdate focusout keydown keypress keyup mousedown".split(" "));
 var lf = "abort canplay canplaythrough durationchange emptied encrypted ended error loadeddata loadedmetadata loadstart pause play playing progress ratechange resize seeked seeking stalled suspend timeupdate volumechange waiting".split(" "), mf = new Set("cancel close invalid load scroll toggle".split(" ").concat(lf));
-function nf(a, b, c) {
-  var d = a.type || "unknown-event";
-  a.currentTarget = c;
-  Ub(d, b, void 0, a);
-  a.currentTarget = null;
-}
-function se(a, b) {
-  b = 0 !== (b & 4);
-  for (var c = 0; c < a.length; c++) {
-    var d = a[c], e = d.event;
-    d = d.listeners;
+function nf(a2, b2, c2) {
+  var d2 = a2.type || "unknown-event";
+  a2.currentTarget = c2;
+  Ub(d2, b2, void 0, a2);
+  a2.currentTarget = null;
+}
+function se$1(a2, b2) {
+  b2 = 0 !== (b2 & 4);
+  for (var c2 = 0; c2 < a2.length; c2++) {
+    var d2 = a2[c2], e2 = d2.event;
+    d2 = d2.listeners;
     a: {
       var f2 = void 0;
-      if (b) for (var g = d.length - 1; 0 <= g; g--) {
-        var h = d[g], k2 = h.instance, l2 = h.currentTarget;
-        h = h.listener;
-        if (k2 !== f2 && e.isPropagationStopped()) break a;
-        nf(e, h, l2);
+      if (b2) for (var g2 = d2.length - 1; 0 <= g2; g2--) {
+        var h2 = d2[g2], k2 = h2.instance, l2 = h2.currentTarget;
+        h2 = h2.listener;
+        if (k2 !== f2 && e2.isPropagationStopped()) break a;
+        nf(e2, h2, l2);
         f2 = k2;
       }
-      else for (g = 0; g < d.length; g++) {
-        h = d[g];
-        k2 = h.instance;
-        l2 = h.currentTarget;
-        h = h.listener;
-        if (k2 !== f2 && e.isPropagationStopped()) break a;
-        nf(e, h, l2);
+      else for (g2 = 0; g2 < d2.length; g2++) {
+        h2 = d2[g2];
+        k2 = h2.instance;
+        l2 = h2.currentTarget;
+        h2 = h2.listener;
+        if (k2 !== f2 && e2.isPropagationStopped()) break a;
+        nf(e2, h2, l2);
         f2 = k2;
       }
     }
   }
-  if (Qb) throw a = Rb, Qb = false, Rb = null, a;
+  if (Qb) throw a2 = Rb, Qb = false, Rb = null, a2;
 }
-function D(a, b) {
-  var c = b[of];
-  void 0 === c && (c = b[of] = /* @__PURE__ */ new Set());
-  var d = a + "__bubble";
-  c.has(d) || (pf(b, a, 2, false), c.add(d));
+function D$1(a2, b2) {
+  var c2 = b2[of];
+  void 0 === c2 && (c2 = b2[of] = /* @__PURE__ */ new Set());
+  var d2 = a2 + "__bubble";
+  c2.has(d2) || (pf(b2, a2, 2, false), c2.add(d2));
 }
-function qf(a, b, c) {
-  var d = 0;
-  b && (d |= 4);
-  pf(c, a, d, b);
+function qf(a2, b2, c2) {
+  var d2 = 0;
+  b2 && (d2 |= 4);
+  pf(c2, a2, d2, b2);
 }
 var rf = "_reactListening" + Math.random().toString(36).slice(2);
-function sf(a) {
-  if (!a[rf]) {
-    a[rf] = true;
-    da.forEach(function(b2) {
-      "selectionchange" !== b2 && (mf.has(b2) || qf(b2, false, a), qf(b2, true, a));
+function sf(a2) {
+  if (!a2[rf]) {
+    a2[rf] = true;
+    da.forEach(function(b3) {
+      "selectionchange" !== b3 && (mf.has(b3) || qf(b3, false, a2), qf(b3, true, a2));
     });
-    var b = 9 === a.nodeType ? a : a.ownerDocument;
-    null === b || b[rf] || (b[rf] = true, qf("selectionchange", false, b));
+    var b2 = 9 === a2.nodeType ? a2 : a2.ownerDocument;
+    null === b2 || b2[rf] || (b2[rf] = true, qf("selectionchange", false, b2));
   }
 }
-function pf(a, b, c, d) {
-  switch (jd(b)) {
+function pf(a2, b2, c2, d2) {
+  switch (jd(b2)) {
     case 1:
-      var e = ed;
+      var e2 = ed;
       break;
     case 4:
-      e = gd;
+      e2 = gd;
       break;
     default:
-      e = fd;
-  }
-  c = e.bind(null, b, c, a);
-  e = void 0;
-  !Lb || "touchstart" !== b && "touchmove" !== b && "wheel" !== b || (e = true);
-  d ? void 0 !== e ? a.addEventListener(b, c, { capture: true, passive: e }) : a.addEventListener(b, c, true) : void 0 !== e ? a.addEventListener(b, c, { passive: e }) : a.addEventListener(b, c, false);
-}
-function hd(a, b, c, d, e) {
-  var f2 = d;
-  if (0 === (b & 1) && 0 === (b & 2) && null !== d) a: for (; ; ) {
-    if (null === d) return;
-    var g = d.tag;
-    if (3 === g || 4 === g) {
-      var h = d.stateNode.containerInfo;
-      if (h === e || 8 === h.nodeType && h.parentNode === e) break;
-      if (4 === g) for (g = d.return; null !== g; ) {
-        var k2 = g.tag;
+      e2 = fd;
+  }
+  c2 = e2.bind(null, b2, c2, a2);
+  e2 = void 0;
+  !Lb || "touchstart" !== b2 && "touchmove" !== b2 && "wheel" !== b2 || (e2 = true);
+  d2 ? void 0 !== e2 ? a2.addEventListener(b2, c2, { capture: true, passive: e2 }) : a2.addEventListener(b2, c2, true) : void 0 !== e2 ? a2.addEventListener(b2, c2, { passive: e2 }) : a2.addEventListener(b2, c2, false);
+}
+function hd(a2, b2, c2, d2, e2) {
+  var f2 = d2;
+  if (0 === (b2 & 1) && 0 === (b2 & 2) && null !== d2) a: for (; ; ) {
+    if (null === d2) return;
+    var g2 = d2.tag;
+    if (3 === g2 || 4 === g2) {
+      var h2 = d2.stateNode.containerInfo;
+      if (h2 === e2 || 8 === h2.nodeType && h2.parentNode === e2) break;
+      if (4 === g2) for (g2 = d2.return; null !== g2; ) {
+        var k2 = g2.tag;
         if (3 === k2 || 4 === k2) {
-          if (k2 = g.stateNode.containerInfo, k2 === e || 8 === k2.nodeType && k2.parentNode === e) return;
+          if (k2 = g2.stateNode.containerInfo, k2 === e2 || 8 === k2.nodeType && k2.parentNode === e2) return;
         }
-        g = g.return;
+        g2 = g2.return;
       }
-      for (; null !== h; ) {
-        g = Wc(h);
-        if (null === g) return;
-        k2 = g.tag;
+      for (; null !== h2; ) {
+        g2 = Wc(h2);
+        if (null === g2) return;
+        k2 = g2.tag;
         if (5 === k2 || 6 === k2) {
-          d = f2 = g;
+          d2 = f2 = g2;
           continue a;
         }
-        h = h.parentNode;
+        h2 = h2.parentNode;
       }
     }
-    d = d.return;
+    d2 = d2.return;
   }
   Jb(function() {
-    var d2 = f2, e2 = xb(c), g2 = [];
+    var d3 = f2, e3 = xb(c2), g3 = [];
     a: {
-      var h3 = df.get(a);
+      var h3 = df.get(a2);
       if (void 0 !== h3) {
-        var k3 = td, n2 = a;
-        switch (a) {
+        var k3 = td, n2 = a2;
+        switch (a2) {
           case "keypress":
-            if (0 === od(c)) break a;
+            if (0 === od(c2)) break a;
           case "keydown":
           case "keyup":
             k3 = Rd;
@@ -2334,7 +2334,7 @@ function hd(a, b, c, d, e) {
             k3 = Fd;
             break;
           case "click":
-            if (2 === c.button) break a;
+            if (2 === c2.button) break a;
           case "auxclick":
           case "dblclick":
           case "mousedown":
@@ -2361,7 +2361,7 @@ function hd(a, b, c, d, e) {
           case "touchstart":
             k3 = Vd;
             break;
-          case $e:
+          case $e$1:
           case af:
           case bf:
             k3 = Hd;
@@ -2390,41 +2390,41 @@ function hd(a, b, c, d, e) {
           case "pointerup":
             k3 = Td;
         }
-        var t2 = 0 !== (b & 4), J2 = !t2 && "scroll" === a, x2 = t2 ? null !== h3 ? h3 + "Capture" : null : h3;
+        var t2 = 0 !== (b2 & 4), J2 = !t2 && "scroll" === a2, x2 = t2 ? null !== h3 ? h3 + "Capture" : null : h3;
         t2 = [];
-        for (var w2 = d2, u2; null !== w2; ) {
+        for (var w2 = d3, u2; null !== w2; ) {
           u2 = w2;
           var F2 = u2.stateNode;
           5 === u2.tag && null !== F2 && (u2 = F2, null !== x2 && (F2 = Kb(w2, x2), null != F2 && t2.push(tf(w2, F2, u2))));
           if (J2) break;
           w2 = w2.return;
         }
-        0 < t2.length && (h3 = new k3(h3, n2, null, c, e2), g2.push({ event: h3, listeners: t2 }));
+        0 < t2.length && (h3 = new k3(h3, n2, null, c2, e3), g3.push({ event: h3, listeners: t2 }));
       }
     }
-    if (0 === (b & 7)) {
+    if (0 === (b2 & 7)) {
       a: {
-        h3 = "mouseover" === a || "pointerover" === a;
-        k3 = "mouseout" === a || "pointerout" === a;
-        if (h3 && c !== wb && (n2 = c.relatedTarget || c.fromElement) && (Wc(n2) || n2[uf])) break a;
+        h3 = "mouseover" === a2 || "pointerover" === a2;
+        k3 = "mouseout" === a2 || "pointerout" === a2;
+        if (h3 && c2 !== wb && (n2 = c2.relatedTarget || c2.fromElement) && (Wc(n2) || n2[uf])) break a;
         if (k3 || h3) {
-          h3 = e2.window === e2 ? e2 : (h3 = e2.ownerDocument) ? h3.defaultView || h3.parentWindow : window;
+          h3 = e3.window === e3 ? e3 : (h3 = e3.ownerDocument) ? h3.defaultView || h3.parentWindow : window;
           if (k3) {
-            if (n2 = c.relatedTarget || c.toElement, k3 = d2, n2 = n2 ? Wc(n2) : null, null !== n2 && (J2 = Vb(n2), n2 !== J2 || 5 !== n2.tag && 6 !== n2.tag)) n2 = null;
-          } else k3 = null, n2 = d2;
+            if (n2 = c2.relatedTarget || c2.toElement, k3 = d3, n2 = n2 ? Wc(n2) : null, null !== n2 && (J2 = Vb(n2), n2 !== J2 || 5 !== n2.tag && 6 !== n2.tag)) n2 = null;
+          } else k3 = null, n2 = d3;
           if (k3 !== n2) {
             t2 = Bd;
             F2 = "onMouseLeave";
             x2 = "onMouseEnter";
             w2 = "mouse";
-            if ("pointerout" === a || "pointerover" === a) t2 = Td, F2 = "onPointerLeave", x2 = "onPointerEnter", w2 = "pointer";
-            J2 = null == k3 ? h3 : ue(k3);
-            u2 = null == n2 ? h3 : ue(n2);
-            h3 = new t2(F2, w2 + "leave", k3, c, e2);
+            if ("pointerout" === a2 || "pointerover" === a2) t2 = Td, F2 = "onPointerLeave", x2 = "onPointerEnter", w2 = "pointer";
+            J2 = null == k3 ? h3 : ue$1(k3);
+            u2 = null == n2 ? h3 : ue$1(n2);
+            h3 = new t2(F2, w2 + "leave", k3, c2, e3);
             h3.target = J2;
             h3.relatedTarget = u2;
             F2 = null;
-            Wc(e2) === d2 && (t2 = new t2(x2, w2 + "enter", n2, c, e2), t2.target = u2, t2.relatedTarget = J2, F2 = t2);
+            Wc(e3) === d3 && (t2 = new t2(x2, w2 + "enter", n2, c2, e3), t2.target = u2, t2.relatedTarget = J2, F2 = t2);
             J2 = F2;
             if (k3 && n2) b: {
               t2 = k3;
@@ -2443,54 +2443,54 @@ function hd(a, b, c, d, e) {
               t2 = null;
             }
             else t2 = null;
-            null !== k3 && wf(g2, h3, k3, t2, false);
-            null !== n2 && null !== J2 && wf(g2, J2, n2, t2, true);
+            null !== k3 && wf(g3, h3, k3, t2, false);
+            null !== n2 && null !== J2 && wf(g3, J2, n2, t2, true);
           }
         }
       }
       a: {
-        h3 = d2 ? ue(d2) : window;
+        h3 = d3 ? ue$1(d3) : window;
         k3 = h3.nodeName && h3.nodeName.toLowerCase();
-        if ("select" === k3 || "input" === k3 && "file" === h3.type) var na = ve;
-        else if (me(h3)) if (we) na = Fe;
+        if ("select" === k3 || "input" === k3 && "file" === h3.type) var na = ve$1;
+        else if (me$1(h3)) if (we$1) na = Fe$1;
         else {
-          na = De;
-          var xa = Ce;
+          na = De$1;
+          var xa = Ce$1;
         }
-        else (k3 = h3.nodeName) && "input" === k3.toLowerCase() && ("checkbox" === h3.type || "radio" === h3.type) && (na = Ee);
-        if (na && (na = na(a, d2))) {
-          ne(g2, na, c, e2);
+        else (k3 = h3.nodeName) && "input" === k3.toLowerCase() && ("checkbox" === h3.type || "radio" === h3.type) && (na = Ee$1);
+        if (na && (na = na(a2, d3))) {
+          ne$1(g3, na, c2, e3);
           break a;
         }
-        xa && xa(a, h3, d2);
-        "focusout" === a && (xa = h3._wrapperState) && xa.controlled && "number" === h3.type && cb(h3, "number", h3.value);
+        xa && xa(a2, h3, d3);
+        "focusout" === a2 && (xa = h3._wrapperState) && xa.controlled && "number" === h3.type && cb(h3, "number", h3.value);
       }
-      xa = d2 ? ue(d2) : window;
-      switch (a) {
+      xa = d3 ? ue$1(d3) : window;
+      switch (a2) {
         case "focusin":
-          if (me(xa) || "true" === xa.contentEditable) Qe = xa, Re = d2, Se = null;
+          if (me$1(xa) || "true" === xa.contentEditable) Qe$1 = xa, Re$1 = d3, Se$1 = null;
           break;
         case "focusout":
-          Se = Re = Qe = null;
+          Se$1 = Re$1 = Qe$1 = null;
           break;
         case "mousedown":
-          Te = true;
+          Te$1 = true;
           break;
         case "contextmenu":
         case "mouseup":
         case "dragend":
-          Te = false;
-          Ue(g2, c, e2);
+          Te$1 = false;
+          Ue$1(g3, c2, e3);
           break;
         case "selectionchange":
-          if (Pe) break;
+          if (Pe$1) break;
         case "keydown":
         case "keyup":
-          Ue(g2, c, e2);
+          Ue$1(g3, c2, e3);
       }
       var $a;
-      if (ae) b: {
-        switch (a) {
+      if (ae$1) b: {
+        switch (a2) {
           case "compositionstart":
             var ba = "onCompositionStart";
             break b;
@@ -2503,621 +2503,621 @@ function hd(a, b, c, d, e) {
         }
         ba = void 0;
       }
-      else ie ? ge(a, c) && (ba = "onCompositionEnd") : "keydown" === a && 229 === c.keyCode && (ba = "onCompositionStart");
-      ba && (de && "ko" !== c.locale && (ie || "onCompositionStart" !== ba ? "onCompositionEnd" === ba && ie && ($a = nd()) : (kd = e2, ld = "value" in kd ? kd.value : kd.textContent, ie = true)), xa = oe(d2, ba), 0 < xa.length && (ba = new Ld(ba, a, null, c, e2), g2.push({ event: ba, listeners: xa }), $a ? ba.data = $a : ($a = he(c), null !== $a && (ba.data = $a))));
-      if ($a = ce ? je(a, c) : ke(a, c)) d2 = oe(d2, "onBeforeInput"), 0 < d2.length && (e2 = new Ld("onBeforeInput", "beforeinput", null, c, e2), g2.push({ event: e2, listeners: d2 }), e2.data = $a);
+      else ie$1 ? ge$1(a2, c2) && (ba = "onCompositionEnd") : "keydown" === a2 && 229 === c2.keyCode && (ba = "onCompositionStart");
+      ba && (de$1 && "ko" !== c2.locale && (ie$1 || "onCompositionStart" !== ba ? "onCompositionEnd" === ba && ie$1 && ($a = nd()) : (kd = e3, ld = "value" in kd ? kd.value : kd.textContent, ie$1 = true)), xa = oe$1(d3, ba), 0 < xa.length && (ba = new Ld(ba, a2, null, c2, e3), g3.push({ event: ba, listeners: xa }), $a ? ba.data = $a : ($a = he$1(c2), null !== $a && (ba.data = $a))));
+      if ($a = ce$1 ? je$1(a2, c2) : ke$1(a2, c2)) d3 = oe$1(d3, "onBeforeInput"), 0 < d3.length && (e3 = new Ld("onBeforeInput", "beforeinput", null, c2, e3), g3.push({ event: e3, listeners: d3 }), e3.data = $a);
     }
-    se(g2, b);
+    se$1(g3, b2);
   });
 }
-function tf(a, b, c) {
-  return { instance: a, listener: b, currentTarget: c };
+function tf(a2, b2, c2) {
+  return { instance: a2, listener: b2, currentTarget: c2 };
 }
-function oe(a, b) {
-  for (var c = b + "Capture", d = []; null !== a; ) {
-    var e = a, f2 = e.stateNode;
-    5 === e.tag && null !== f2 && (e = f2, f2 = Kb(a, c), null != f2 && d.unshift(tf(a, f2, e)), f2 = Kb(a, b), null != f2 && d.push(tf(a, f2, e)));
-    a = a.return;
+function oe$1(a2, b2) {
+  for (var c2 = b2 + "Capture", d2 = []; null !== a2; ) {
+    var e2 = a2, f2 = e2.stateNode;
+    5 === e2.tag && null !== f2 && (e2 = f2, f2 = Kb(a2, c2), null != f2 && d2.unshift(tf(a2, f2, e2)), f2 = Kb(a2, b2), null != f2 && d2.push(tf(a2, f2, e2)));
+    a2 = a2.return;
   }
-  return d;
+  return d2;
 }
-function vf(a) {
-  if (null === a) return null;
+function vf(a2) {
+  if (null === a2) return null;
   do
-    a = a.return;
-  while (a && 5 !== a.tag);
-  return a ? a : null;
+    a2 = a2.return;
+  while (a2 && 5 !== a2.tag);
+  return a2 ? a2 : null;
 }
-function wf(a, b, c, d, e) {
-  for (var f2 = b._reactName, g = []; null !== c && c !== d; ) {
-    var h = c, k2 = h.alternate, l2 = h.stateNode;
-    if (null !== k2 && k2 === d) break;
-    5 === h.tag && null !== l2 && (h = l2, e ? (k2 = Kb(c, f2), null != k2 && g.unshift(tf(c, k2, h))) : e || (k2 = Kb(c, f2), null != k2 && g.push(tf(c, k2, h))));
-    c = c.return;
-  }
-  0 !== g.length && a.push({ event: b, listeners: g });
+function wf(a2, b2, c2, d2, e2) {
+  for (var f2 = b2._reactName, g2 = []; null !== c2 && c2 !== d2; ) {
+    var h2 = c2, k2 = h2.alternate, l2 = h2.stateNode;
+    if (null !== k2 && k2 === d2) break;
+    5 === h2.tag && null !== l2 && (h2 = l2, e2 ? (k2 = Kb(c2, f2), null != k2 && g2.unshift(tf(c2, k2, h2))) : e2 || (k2 = Kb(c2, f2), null != k2 && g2.push(tf(c2, k2, h2))));
+    c2 = c2.return;
+  }
+  0 !== g2.length && a2.push({ event: b2, listeners: g2 });
 }
 var xf = /\r\n?/g, yf = /\u0000|\uFFFD/g;
-function zf(a) {
-  return ("string" === typeof a ? a : "" + a).replace(xf, "\n").replace(yf, "");
+function zf(a2) {
+  return ("string" === typeof a2 ? a2 : "" + a2).replace(xf, "\n").replace(yf, "");
 }
-function Af(a, b, c) {
-  b = zf(b);
-  if (zf(a) !== b && c) throw Error(p(425));
+function Af(a2, b2, c2) {
+  b2 = zf(b2);
+  if (zf(a2) !== b2 && c2) throw Error(p$1(425));
 }
 function Bf() {
 }
 var Cf = null, Df = null;
-function Ef(a, b) {
-  return "textarea" === a || "noscript" === a || "string" === typeof b.children || "number" === typeof b.children || "object" === typeof b.dangerouslySetInnerHTML && null !== b.dangerouslySetInnerHTML && null != b.dangerouslySetInnerHTML.__html;
+function Ef(a2, b2) {
+  return "textarea" === a2 || "noscript" === a2 || "string" === typeof b2.children || "number" === typeof b2.children || "object" === typeof b2.dangerouslySetInnerHTML && null !== b2.dangerouslySetInnerHTML && null != b2.dangerouslySetInnerHTML.__html;
 }
-var Ff = "function" === typeof setTimeout ? setTimeout : void 0, Gf = "function" === typeof clearTimeout ? clearTimeout : void 0, Hf = "function" === typeof Promise ? Promise : void 0, Jf = "function" === typeof queueMicrotask ? queueMicrotask : "undefined" !== typeof Hf ? function(a) {
-  return Hf.resolve(null).then(a).catch(If);
+var Ff = "function" === typeof setTimeout ? setTimeout : void 0, Gf = "function" === typeof clearTimeout ? clearTimeout : void 0, Hf = "function" === typeof Promise ? Promise : void 0, Jf = "function" === typeof queueMicrotask ? queueMicrotask : "undefined" !== typeof Hf ? function(a2) {
+  return Hf.resolve(null).then(a2).catch(If);
 } : Ff;
-function If(a) {
+function If(a2) {
   setTimeout(function() {
-    throw a;
+    throw a2;
   });
 }
-function Kf(a, b) {
-  var c = b, d = 0;
+function Kf(a2, b2) {
+  var c2 = b2, d2 = 0;
   do {
-    var e = c.nextSibling;
-    a.removeChild(c);
-    if (e && 8 === e.nodeType) if (c = e.data, "/$" === c) {
-      if (0 === d) {
-        a.removeChild(e);
-        bd(b);
+    var e2 = c2.nextSibling;
+    a2.removeChild(c2);
+    if (e2 && 8 === e2.nodeType) if (c2 = e2.data, "/$" === c2) {
+      if (0 === d2) {
+        a2.removeChild(e2);
+        bd(b2);
         return;
       }
-      d--;
-    } else "$" !== c && "$?" !== c && "$!" !== c || d++;
-    c = e;
-  } while (c);
-  bd(b);
+      d2--;
+    } else "$" !== c2 && "$?" !== c2 && "$!" !== c2 || d2++;
+    c2 = e2;
+  } while (c2);
+  bd(b2);
 }
-function Lf(a) {
-  for (; null != a; a = a.nextSibling) {
-    var b = a.nodeType;
-    if (1 === b || 3 === b) break;
-    if (8 === b) {
-      b = a.data;
-      if ("$" === b || "$!" === b || "$?" === b) break;
-      if ("/$" === b) return null;
+function Lf(a2) {
+  for (; null != a2; a2 = a2.nextSibling) {
+    var b2 = a2.nodeType;
+    if (1 === b2 || 3 === b2) break;
+    if (8 === b2) {
+      b2 = a2.data;
+      if ("$" === b2 || "$!" === b2 || "$?" === b2) break;
+      if ("/$" === b2) return null;
     }
   }
-  return a;
+  return a2;
 }
-function Mf(a) {
-  a = a.previousSibling;
-  for (var b = 0; a; ) {
-    if (8 === a.nodeType) {
-      var c = a.data;
-      if ("$" === c || "$!" === c || "$?" === c) {
-        if (0 === b) return a;
-        b--;
-      } else "/$" === c && b++;
+function Mf(a2) {
+  a2 = a2.previousSibling;
+  for (var b2 = 0; a2; ) {
+    if (8 === a2.nodeType) {
+      var c2 = a2.data;
+      if ("$" === c2 || "$!" === c2 || "$?" === c2) {
+        if (0 === b2) return a2;
+        b2--;
+      } else "/$" === c2 && b2++;
     }
-    a = a.previousSibling;
+    a2 = a2.previousSibling;
   }
   return null;
 }
 var Nf = Math.random().toString(36).slice(2), Of = "__reactFiber$" + Nf, Pf = "__reactProps$" + Nf, uf = "__reactContainer$" + Nf, of = "__reactEvents$" + Nf, Qf = "__reactListeners$" + Nf, Rf = "__reactHandles$" + Nf;
-function Wc(a) {
-  var b = a[Of];
-  if (b) return b;
-  for (var c = a.parentNode; c; ) {
-    if (b = c[uf] || c[Of]) {
-      c = b.alternate;
-      if (null !== b.child || null !== c && null !== c.child) for (a = Mf(a); null !== a; ) {
-        if (c = a[Of]) return c;
-        a = Mf(a);
+function Wc(a2) {
+  var b2 = a2[Of];
+  if (b2) return b2;
+  for (var c2 = a2.parentNode; c2; ) {
+    if (b2 = c2[uf] || c2[Of]) {
+      c2 = b2.alternate;
+      if (null !== b2.child || null !== c2 && null !== c2.child) for (a2 = Mf(a2); null !== a2; ) {
+        if (c2 = a2[Of]) return c2;
+        a2 = Mf(a2);
       }
-      return b;
+      return b2;
     }
-    a = c;
-    c = a.parentNode;
+    a2 = c2;
+    c2 = a2.parentNode;
   }
   return null;
 }
-function Cb(a) {
-  a = a[Of] || a[uf];
-  return !a || 5 !== a.tag && 6 !== a.tag && 13 !== a.tag && 3 !== a.tag ? null : a;
+function Cb(a2) {
+  a2 = a2[Of] || a2[uf];
+  return !a2 || 5 !== a2.tag && 6 !== a2.tag && 13 !== a2.tag && 3 !== a2.tag ? null : a2;
 }
-function ue(a) {
-  if (5 === a.tag || 6 === a.tag) return a.stateNode;
-  throw Error(p(33));
+function ue$1(a2) {
+  if (5 === a2.tag || 6 === a2.tag) return a2.stateNode;
+  throw Error(p$1(33));
 }
-function Db(a) {
-  return a[Pf] || null;
+function Db(a2) {
+  return a2[Pf] || null;
 }
 var Sf = [], Tf = -1;
-function Uf(a) {
-  return { current: a };
+function Uf(a2) {
+  return { current: a2 };
 }
-function E(a) {
-  0 > Tf || (a.current = Sf[Tf], Sf[Tf] = null, Tf--);
+function E$1(a2) {
+  0 > Tf || (a2.current = Sf[Tf], Sf[Tf] = null, Tf--);
 }
-function G(a, b) {
+function G$1(a2, b2) {
   Tf++;
-  Sf[Tf] = a.current;
-  a.current = b;
-}
-var Vf = {}, H = Uf(Vf), Wf = Uf(false), Xf = Vf;
-function Yf(a, b) {
-  var c = a.type.contextTypes;
-  if (!c) return Vf;
-  var d = a.stateNode;
-  if (d && d.__reactInternalMemoizedUnmaskedChildContext === b) return d.__reactInternalMemoizedMaskedChildContext;
-  var e = {}, f2;
-  for (f2 in c) e[f2] = b[f2];
-  d && (a = a.stateNode, a.__reactInternalMemoizedUnmaskedChildContext = b, a.__reactInternalMemoizedMaskedChildContext = e);
-  return e;
-}
-function Zf(a) {
-  a = a.childContextTypes;
-  return null !== a && void 0 !== a;
+  Sf[Tf] = a2.current;
+  a2.current = b2;
+}
+var Vf = {}, H$1 = Uf(Vf), Wf = Uf(false), Xf = Vf;
+function Yf(a2, b2) {
+  var c2 = a2.type.contextTypes;
+  if (!c2) return Vf;
+  var d2 = a2.stateNode;
+  if (d2 && d2.__reactInternalMemoizedUnmaskedChildContext === b2) return d2.__reactInternalMemoizedMaskedChildContext;
+  var e2 = {}, f2;
+  for (f2 in c2) e2[f2] = b2[f2];
+  d2 && (a2 = a2.stateNode, a2.__reactInternalMemoizedUnmaskedChildContext = b2, a2.__reactInternalMemoizedMaskedChildContext = e2);
+  return e2;
+}
+function Zf(a2) {
+  a2 = a2.childContextTypes;
+  return null !== a2 && void 0 !== a2;
 }
 function $f() {
-  E(Wf);
-  E(H);
-}
-function ag(a, b, c) {
-  if (H.current !== Vf) throw Error(p(168));
-  G(H, b);
-  G(Wf, c);
-}
-function bg(a, b, c) {
-  var d = a.stateNode;
-  b = b.childContextTypes;
-  if ("function" !== typeof d.getChildContext) return c;
-  d = d.getChildContext();
-  for (var e in d) if (!(e in b)) throw Error(p(108, Ra(a) || "Unknown", e));
-  return A({}, c, d);
-}
-function cg(a) {
-  a = (a = a.stateNode) && a.__reactInternalMemoizedMergedChildContext || Vf;
-  Xf = H.current;
-  G(H, a);
-  G(Wf, Wf.current);
+  E$1(Wf);
+  E$1(H$1);
+}
+function ag(a2, b2, c2) {
+  if (H$1.current !== Vf) throw Error(p$1(168));
+  G$1(H$1, b2);
+  G$1(Wf, c2);
+}
+function bg(a2, b2, c2) {
+  var d2 = a2.stateNode;
+  b2 = b2.childContextTypes;
+  if ("function" !== typeof d2.getChildContext) return c2;
+  d2 = d2.getChildContext();
+  for (var e2 in d2) if (!(e2 in b2)) throw Error(p$1(108, Ra(a2) || "Unknown", e2));
+  return A$1({}, c2, d2);
+}
+function cg(a2) {
+  a2 = (a2 = a2.stateNode) && a2.__reactInternalMemoizedMergedChildContext || Vf;
+  Xf = H$1.current;
+  G$1(H$1, a2);
+  G$1(Wf, Wf.current);
   return true;
 }
-function dg(a, b, c) {
-  var d = a.stateNode;
-  if (!d) throw Error(p(169));
-  c ? (a = bg(a, b, Xf), d.__reactInternalMemoizedMergedChildContext = a, E(Wf), E(H), G(H, a)) : E(Wf);
-  G(Wf, c);
+function dg(a2, b2, c2) {
+  var d2 = a2.stateNode;
+  if (!d2) throw Error(p$1(169));
+  c2 ? (a2 = bg(a2, b2, Xf), d2.__reactInternalMemoizedMergedChildContext = a2, E$1(Wf), E$1(H$1), G$1(H$1, a2)) : E$1(Wf);
+  G$1(Wf, c2);
 }
 var eg = null, fg = false, gg = false;
-function hg(a) {
-  null === eg ? eg = [a] : eg.push(a);
+function hg(a2) {
+  null === eg ? eg = [a2] : eg.push(a2);
 }
-function ig(a) {
+function ig(a2) {
   fg = true;
-  hg(a);
+  hg(a2);
 }
 function jg() {
   if (!gg && null !== eg) {
     gg = true;
-    var a = 0, b = C;
+    var a2 = 0, b2 = C$1;
     try {
-      var c = eg;
-      for (C = 1; a < c.length; a++) {
-        var d = c[a];
+      var c2 = eg;
+      for (C$1 = 1; a2 < c2.length; a2++) {
+        var d2 = c2[a2];
         do
-          d = d(true);
-        while (null !== d);
+          d2 = d2(true);
+        while (null !== d2);
       }
       eg = null;
       fg = false;
-    } catch (e) {
-      throw null !== eg && (eg = eg.slice(a + 1)), ac(fc, jg), e;
+    } catch (e2) {
+      throw null !== eg && (eg = eg.slice(a2 + 1)), ac(fc, jg), e2;
     } finally {
-      C = b, gg = false;
+      C$1 = b2, gg = false;
     }
   }
   return null;
 }
 var kg = [], lg = 0, mg = null, ng = 0, og = [], pg = 0, qg = null, rg = 1, sg = "";
-function tg(a, b) {
+function tg(a2, b2) {
   kg[lg++] = ng;
   kg[lg++] = mg;
-  mg = a;
-  ng = b;
+  mg = a2;
+  ng = b2;
 }
-function ug(a, b, c) {
+function ug(a2, b2, c2) {
   og[pg++] = rg;
   og[pg++] = sg;
   og[pg++] = qg;
-  qg = a;
-  var d = rg;
-  a = sg;
-  var e = 32 - oc(d) - 1;
-  d &= ~(1 << e);
-  c += 1;
-  var f2 = 32 - oc(b) + e;
+  qg = a2;
+  var d2 = rg;
+  a2 = sg;
+  var e2 = 32 - oc(d2) - 1;
+  d2 &= ~(1 << e2);
+  c2 += 1;
+  var f2 = 32 - oc(b2) + e2;
   if (30 < f2) {
-    var g = e - e % 5;
-    f2 = (d & (1 << g) - 1).toString(32);
-    d >>= g;
-    e -= g;
-    rg = 1 << 32 - oc(b) + e | c << e | d;
-    sg = f2 + a;
-  } else rg = 1 << f2 | c << e | d, sg = a;
-}
-function vg(a) {
-  null !== a.return && (tg(a, 1), ug(a, 1, 0));
-}
-function wg(a) {
-  for (; a === mg; ) mg = kg[--lg], kg[lg] = null, ng = kg[--lg], kg[lg] = null;
-  for (; a === qg; ) qg = og[--pg], og[pg] = null, sg = og[--pg], og[pg] = null, rg = og[--pg], og[pg] = null;
-}
-var xg = null, yg = null, I = false, zg = null;
-function Ag(a, b) {
-  var c = Bg(5, null, null, 0);
-  c.elementType = "DELETED";
-  c.stateNode = b;
-  c.return = a;
-  b = a.deletions;
-  null === b ? (a.deletions = [c], a.flags |= 16) : b.push(c);
-}
-function Cg(a, b) {
-  switch (a.tag) {
+    var g2 = e2 - e2 % 5;
+    f2 = (d2 & (1 << g2) - 1).toString(32);
+    d2 >>= g2;
+    e2 -= g2;
+    rg = 1 << 32 - oc(b2) + e2 | c2 << e2 | d2;
+    sg = f2 + a2;
+  } else rg = 1 << f2 | c2 << e2 | d2, sg = a2;
+}
+function vg(a2) {
+  null !== a2.return && (tg(a2, 1), ug(a2, 1, 0));
+}
+function wg(a2) {
+  for (; a2 === mg; ) mg = kg[--lg], kg[lg] = null, ng = kg[--lg], kg[lg] = null;
+  for (; a2 === qg; ) qg = og[--pg], og[pg] = null, sg = og[--pg], og[pg] = null, rg = og[--pg], og[pg] = null;
+}
+var xg = null, yg = null, I$1 = false, zg = null;
+function Ag(a2, b2) {
+  var c2 = Bg(5, null, null, 0);
+  c2.elementType = "DELETED";
+  c2.stateNode = b2;
+  c2.return = a2;
+  b2 = a2.deletions;
+  null === b2 ? (a2.deletions = [c2], a2.flags |= 16) : b2.push(c2);
+}
+function Cg(a2, b2) {
+  switch (a2.tag) {
     case 5:
-      var c = a.type;
-      b = 1 !== b.nodeType || c.toLowerCase() !== b.nodeName.toLowerCase() ? null : b;
-      return null !== b ? (a.stateNode = b, xg = a, yg = Lf(b.firstChild), true) : false;
+      var c2 = a2.type;
+      b2 = 1 !== b2.nodeType || c2.toLowerCase() !== b2.nodeName.toLowerCase() ? null : b2;
+      return null !== b2 ? (a2.stateNode = b2, xg = a2, yg = Lf(b2.firstChild), true) : false;
     case 6:
-      return b = "" === a.pendingProps || 3 !== b.nodeType ? null : b, null !== b ? (a.stateNode = b, xg = a, yg = null, true) : false;
+      return b2 = "" === a2.pendingProps || 3 !== b2.nodeType ? null : b2, null !== b2 ? (a2.stateNode = b2, xg = a2, yg = null, true) : false;
     case 13:
-      return b = 8 !== b.nodeType ? null : b, null !== b ? (c = null !== qg ? { id: rg, overflow: sg } : null, a.memoizedState = { dehydrated: b, treeContext: c, retryLane: 1073741824 }, c = Bg(18, null, null, 0), c.stateNode = b, c.return = a, a.child = c, xg = a, yg = null, true) : false;
+      return b2 = 8 !== b2.nodeType ? null : b2, null !== b2 ? (c2 = null !== qg ? { id: rg, overflow: sg } : null, a2.memoizedState = { dehydrated: b2, treeContext: c2, retryLane: 1073741824 }, c2 = Bg(18, null, null, 0), c2.stateNode = b2, c2.return = a2, a2.child = c2, xg = a2, yg = null, true) : false;
     default:
       return false;
   }
 }
-function Dg(a) {
-  return 0 !== (a.mode & 1) && 0 === (a.flags & 128);
+function Dg(a2) {
+  return 0 !== (a2.mode & 1) && 0 === (a2.flags & 128);
 }
-function Eg(a) {
-  if (I) {
-    var b = yg;
-    if (b) {
-      var c = b;
-      if (!Cg(a, b)) {
-        if (Dg(a)) throw Error(p(418));
-        b = Lf(c.nextSibling);
-        var d = xg;
-        b && Cg(a, b) ? Ag(d, c) : (a.flags = a.flags & -4097 | 2, I = false, xg = a);
+function Eg(a2) {
+  if (I$1) {
+    var b2 = yg;
+    if (b2) {
+      var c2 = b2;
+      if (!Cg(a2, b2)) {
+        if (Dg(a2)) throw Error(p$1(418));
+        b2 = Lf(c2.nextSibling);
+        var d2 = xg;
+        b2 && Cg(a2, b2) ? Ag(d2, c2) : (a2.flags = a2.flags & -4097 | 2, I$1 = false, xg = a2);
       }
     } else {
-      if (Dg(a)) throw Error(p(418));
-      a.flags = a.flags & -4097 | 2;
-      I = false;
-      xg = a;
-    }
-  }
-}
-function Fg(a) {
-  for (a = a.return; null !== a && 5 !== a.tag && 3 !== a.tag && 13 !== a.tag; ) a = a.return;
-  xg = a;
-}
-function Gg(a) {
-  if (a !== xg) return false;
-  if (!I) return Fg(a), I = true, false;
-  var b;
-  (b = 3 !== a.tag) && !(b = 5 !== a.tag) && (b = a.type, b = "head" !== b && "body" !== b && !Ef(a.type, a.memoizedProps));
-  if (b && (b = yg)) {
-    if (Dg(a)) throw Hg(), Error(p(418));
-    for (; b; ) Ag(a, b), b = Lf(b.nextSibling);
-  }
-  Fg(a);
-  if (13 === a.tag) {
-    a = a.memoizedState;
-    a = null !== a ? a.dehydrated : null;
-    if (!a) throw Error(p(317));
+      if (Dg(a2)) throw Error(p$1(418));
+      a2.flags = a2.flags & -4097 | 2;
+      I$1 = false;
+      xg = a2;
+    }
+  }
+}
+function Fg(a2) {
+  for (a2 = a2.return; null !== a2 && 5 !== a2.tag && 3 !== a2.tag && 13 !== a2.tag; ) a2 = a2.return;
+  xg = a2;
+}
+function Gg(a2) {
+  if (a2 !== xg) return false;
+  if (!I$1) return Fg(a2), I$1 = true, false;
+  var b2;
+  (b2 = 3 !== a2.tag) && !(b2 = 5 !== a2.tag) && (b2 = a2.type, b2 = "head" !== b2 && "body" !== b2 && !Ef(a2.type, a2.memoizedProps));
+  if (b2 && (b2 = yg)) {
+    if (Dg(a2)) throw Hg(), Error(p$1(418));
+    for (; b2; ) Ag(a2, b2), b2 = Lf(b2.nextSibling);
+  }
+  Fg(a2);
+  if (13 === a2.tag) {
+    a2 = a2.memoizedState;
+    a2 = null !== a2 ? a2.dehydrated : null;
+    if (!a2) throw Error(p$1(317));
     a: {
-      a = a.nextSibling;
-      for (b = 0; a; ) {
-        if (8 === a.nodeType) {
-          var c = a.data;
-          if ("/$" === c) {
-            if (0 === b) {
-              yg = Lf(a.nextSibling);
+      a2 = a2.nextSibling;
+      for (b2 = 0; a2; ) {
+        if (8 === a2.nodeType) {
+          var c2 = a2.data;
+          if ("/$" === c2) {
+            if (0 === b2) {
+              yg = Lf(a2.nextSibling);
               break a;
             }
-            b--;
-          } else "$" !== c && "$!" !== c && "$?" !== c || b++;
+            b2--;
+          } else "$" !== c2 && "$!" !== c2 && "$?" !== c2 || b2++;
         }
-        a = a.nextSibling;
+        a2 = a2.nextSibling;
       }
       yg = null;
     }
-  } else yg = xg ? Lf(a.stateNode.nextSibling) : null;
+  } else yg = xg ? Lf(a2.stateNode.nextSibling) : null;
   return true;
 }
 function Hg() {
-  for (var a = yg; a; ) a = Lf(a.nextSibling);
+  for (var a2 = yg; a2; ) a2 = Lf(a2.nextSibling);
 }
 function Ig() {
   yg = xg = null;
-  I = false;
+  I$1 = false;
 }
-function Jg(a) {
-  null === zg ? zg = [a] : zg.push(a);
+function Jg(a2) {
+  null === zg ? zg = [a2] : zg.push(a2);
 }
 var Kg = ua.ReactCurrentBatchConfig;
-function Lg(a, b, c) {
-  a = c.ref;
-  if (null !== a && "function" !== typeof a && "object" !== typeof a) {
-    if (c._owner) {
-      c = c._owner;
-      if (c) {
-        if (1 !== c.tag) throw Error(p(309));
-        var d = c.stateNode;
-      }
-      if (!d) throw Error(p(147, a));
-      var e = d, f2 = "" + a;
-      if (null !== b && null !== b.ref && "function" === typeof b.ref && b.ref._stringRef === f2) return b.ref;
-      b = function(a2) {
-        var b2 = e.refs;
-        null === a2 ? delete b2[f2] : b2[f2] = a2;
+function Lg(a2, b2, c2) {
+  a2 = c2.ref;
+  if (null !== a2 && "function" !== typeof a2 && "object" !== typeof a2) {
+    if (c2._owner) {
+      c2 = c2._owner;
+      if (c2) {
+        if (1 !== c2.tag) throw Error(p$1(309));
+        var d2 = c2.stateNode;
+      }
+      if (!d2) throw Error(p$1(147, a2));
+      var e2 = d2, f2 = "" + a2;
+      if (null !== b2 && null !== b2.ref && "function" === typeof b2.ref && b2.ref._stringRef === f2) return b2.ref;
+      b2 = function(a3) {
+        var b3 = e2.refs;
+        null === a3 ? delete b3[f2] : b3[f2] = a3;
       };
-      b._stringRef = f2;
-      return b;
+      b2._stringRef = f2;
+      return b2;
     }
-    if ("string" !== typeof a) throw Error(p(284));
-    if (!c._owner) throw Error(p(290, a));
+    if ("string" !== typeof a2) throw Error(p$1(284));
+    if (!c2._owner) throw Error(p$1(290, a2));
   }
-  return a;
+  return a2;
 }
-function Mg(a, b) {
-  a = Object.prototype.toString.call(b);
-  throw Error(p(31, "[object Object]" === a ? "object with keys {" + Object.keys(b).join(", ") + "}" : a));
+function Mg(a2, b2) {
+  a2 = Object.prototype.toString.call(b2);
+  throw Error(p$1(31, "[object Object]" === a2 ? "object with keys {" + Object.keys(b2).join(", ") + "}" : a2));
 }
-function Ng(a) {
-  var b = a._init;
-  return b(a._payload);
+function Ng(a2) {
+  var b2 = a2._init;
+  return b2(a2._payload);
 }
-function Og(a) {
-  function b(b2, c2) {
-    if (a) {
-      var d2 = b2.deletions;
-      null === d2 ? (b2.deletions = [c2], b2.flags |= 16) : d2.push(c2);
+function Og(a2) {
+  function b2(b3, c3) {
+    if (a2) {
+      var d3 = b3.deletions;
+      null === d3 ? (b3.deletions = [c3], b3.flags |= 16) : d3.push(c3);
     }
   }
-  function c(c2, d2) {
-    if (!a) return null;
-    for (; null !== d2; ) b(c2, d2), d2 = d2.sibling;
+  function c2(c3, d3) {
+    if (!a2) return null;
+    for (; null !== d3; ) b2(c3, d3), d3 = d3.sibling;
     return null;
   }
-  function d(a2, b2) {
-    for (a2 = /* @__PURE__ */ new Map(); null !== b2; ) null !== b2.key ? a2.set(b2.key, b2) : a2.set(b2.index, b2), b2 = b2.sibling;
-    return a2;
-  }
-  function e(a2, b2) {
-    a2 = Pg(a2, b2);
-    a2.index = 0;
-    a2.sibling = null;
-    return a2;
-  }
-  function f2(b2, c2, d2) {
-    b2.index = d2;
-    if (!a) return b2.flags |= 1048576, c2;
-    d2 = b2.alternate;
-    if (null !== d2) return d2 = d2.index, d2 < c2 ? (b2.flags |= 2, c2) : d2;
-    b2.flags |= 2;
-    return c2;
-  }
-  function g(b2) {
-    a && null === b2.alternate && (b2.flags |= 2);
-    return b2;
-  }
-  function h(a2, b2, c2, d2) {
-    if (null === b2 || 6 !== b2.tag) return b2 = Qg(c2, a2.mode, d2), b2.return = a2, b2;
-    b2 = e(b2, c2);
-    b2.return = a2;
-    return b2;
-  }
-  function k2(a2, b2, c2, d2) {
-    var f3 = c2.type;
-    if (f3 === ya) return m2(a2, b2, c2.props.children, d2, c2.key);
-    if (null !== b2 && (b2.elementType === f3 || "object" === typeof f3 && null !== f3 && f3.$$typeof === Ha && Ng(f3) === b2.type)) return d2 = e(b2, c2.props), d2.ref = Lg(a2, b2, c2), d2.return = a2, d2;
-    d2 = Rg(c2.type, c2.key, c2.props, null, a2.mode, d2);
-    d2.ref = Lg(a2, b2, c2);
-    d2.return = a2;
-    return d2;
-  }
-  function l2(a2, b2, c2, d2) {
-    if (null === b2 || 4 !== b2.tag || b2.stateNode.containerInfo !== c2.containerInfo || b2.stateNode.implementation !== c2.implementation) return b2 = Sg(c2, a2.mode, d2), b2.return = a2, b2;
-    b2 = e(b2, c2.children || []);
-    b2.return = a2;
-    return b2;
-  }
-  function m2(a2, b2, c2, d2, f3) {
-    if (null === b2 || 7 !== b2.tag) return b2 = Tg(c2, a2.mode, d2, f3), b2.return = a2, b2;
-    b2 = e(b2, c2);
-    b2.return = a2;
-    return b2;
-  }
-  function q2(a2, b2, c2) {
-    if ("string" === typeof b2 && "" !== b2 || "number" === typeof b2) return b2 = Qg("" + b2, a2.mode, c2), b2.return = a2, b2;
-    if ("object" === typeof b2 && null !== b2) {
-      switch (b2.$$typeof) {
+  function d2(a3, b3) {
+    for (a3 = /* @__PURE__ */ new Map(); null !== b3; ) null !== b3.key ? a3.set(b3.key, b3) : a3.set(b3.index, b3), b3 = b3.sibling;
+    return a3;
+  }
+  function e2(a3, b3) {
+    a3 = Pg(a3, b3);
+    a3.index = 0;
+    a3.sibling = null;
+    return a3;
+  }
+  function f2(b3, c3, d3) {
+    b3.index = d3;
+    if (!a2) return b3.flags |= 1048576, c3;
+    d3 = b3.alternate;
+    if (null !== d3) return d3 = d3.index, d3 < c3 ? (b3.flags |= 2, c3) : d3;
+    b3.flags |= 2;
+    return c3;
+  }
+  function g2(b3) {
+    a2 && null === b3.alternate && (b3.flags |= 2);
+    return b3;
+  }
+  function h2(a3, b3, c3, d3) {
+    if (null === b3 || 6 !== b3.tag) return b3 = Qg(c3, a3.mode, d3), b3.return = a3, b3;
+    b3 = e2(b3, c3);
+    b3.return = a3;
+    return b3;
+  }
+  function k2(a3, b3, c3, d3) {
+    var f3 = c3.type;
+    if (f3 === ya) return m2(a3, b3, c3.props.children, d3, c3.key);
+    if (null !== b3 && (b3.elementType === f3 || "object" === typeof f3 && null !== f3 && f3.$$typeof === Ha && Ng(f3) === b3.type)) return d3 = e2(b3, c3.props), d3.ref = Lg(a3, b3, c3), d3.return = a3, d3;
+    d3 = Rg(c3.type, c3.key, c3.props, null, a3.mode, d3);
+    d3.ref = Lg(a3, b3, c3);
+    d3.return = a3;
+    return d3;
+  }
+  function l2(a3, b3, c3, d3) {
+    if (null === b3 || 4 !== b3.tag || b3.stateNode.containerInfo !== c3.containerInfo || b3.stateNode.implementation !== c3.implementation) return b3 = Sg(c3, a3.mode, d3), b3.return = a3, b3;
+    b3 = e2(b3, c3.children || []);
+    b3.return = a3;
+    return b3;
+  }
+  function m2(a3, b3, c3, d3, f3) {
+    if (null === b3 || 7 !== b3.tag) return b3 = Tg(c3, a3.mode, d3, f3), b3.return = a3, b3;
+    b3 = e2(b3, c3);
+    b3.return = a3;
+    return b3;
+  }
+  function q2(a3, b3, c3) {
+    if ("string" === typeof b3 && "" !== b3 || "number" === typeof b3) return b3 = Qg("" + b3, a3.mode, c3), b3.return = a3, b3;
+    if ("object" === typeof b3 && null !== b3) {
+      switch (b3.$$typeof) {
         case va:
-          return c2 = Rg(b2.type, b2.key, b2.props, null, a2.mode, c2), c2.ref = Lg(a2, null, b2), c2.return = a2, c2;
+          return c3 = Rg(b3.type, b3.key, b3.props, null, a3.mode, c3), c3.ref = Lg(a3, null, b3), c3.return = a3, c3;
         case wa:
-          return b2 = Sg(b2, a2.mode, c2), b2.return = a2, b2;
+          return b3 = Sg(b3, a3.mode, c3), b3.return = a3, b3;
         case Ha:
-          var d2 = b2._init;
-          return q2(a2, d2(b2._payload), c2);
+          var d3 = b3._init;
+          return q2(a3, d3(b3._payload), c3);
       }
-      if (eb(b2) || Ka(b2)) return b2 = Tg(b2, a2.mode, c2, null), b2.return = a2, b2;
-      Mg(a2, b2);
+      if (eb(b3) || Ka(b3)) return b3 = Tg(b3, a3.mode, c3, null), b3.return = a3, b3;
+      Mg(a3, b3);
     }
     return null;
   }
-  function r2(a2, b2, c2, d2) {
-    var e2 = null !== b2 ? b2.key : null;
-    if ("string" === typeof c2 && "" !== c2 || "number" === typeof c2) return null !== e2 ? null : h(a2, b2, "" + c2, d2);
-    if ("object" === typeof c2 && null !== c2) {
-      switch (c2.$$typeof) {
+  function r2(a3, b3, c3, d3) {
+    var e3 = null !== b3 ? b3.key : null;
+    if ("string" === typeof c3 && "" !== c3 || "number" === typeof c3) return null !== e3 ? null : h2(a3, b3, "" + c3, d3);
+    if ("object" === typeof c3 && null !== c3) {
+      switch (c3.$$typeof) {
         case va:
-          return c2.key === e2 ? k2(a2, b2, c2, d2) : null;
+          return c3.key === e3 ? k2(a3, b3, c3, d3) : null;
         case wa:
-          return c2.key === e2 ? l2(a2, b2, c2, d2) : null;
+          return c3.key === e3 ? l2(a3, b3, c3, d3) : null;
         case Ha:
-          return e2 = c2._init, r2(
-            a2,
-            b2,
-            e2(c2._payload),
-            d2
+          return e3 = c3._init, r2(
+            a3,
+            b3,
+            e3(c3._payload),
+            d3
           );
       }
-      if (eb(c2) || Ka(c2)) return null !== e2 ? null : m2(a2, b2, c2, d2, null);
-      Mg(a2, c2);
+      if (eb(c3) || Ka(c3)) return null !== e3 ? null : m2(a3, b3, c3, d3, null);
+      Mg(a3, c3);
     }
     return null;
   }
-  function y2(a2, b2, c2, d2, e2) {
-    if ("string" === typeof d2 && "" !== d2 || "number" === typeof d2) return a2 = a2.get(c2) || null, h(b2, a2, "" + d2, e2);
-    if ("object" === typeof d2 && null !== d2) {
-      switch (d2.$$typeof) {
+  function y2(a3, b3, c3, d3, e3) {
+    if ("string" === typeof d3 && "" !== d3 || "number" === typeof d3) return a3 = a3.get(c3) || null, h2(b3, a3, "" + d3, e3);
+    if ("object" === typeof d3 && null !== d3) {
+      switch (d3.$$typeof) {
         case va:
-          return a2 = a2.get(null === d2.key ? c2 : d2.key) || null, k2(b2, a2, d2, e2);
+          return a3 = a3.get(null === d3.key ? c3 : d3.key) || null, k2(b3, a3, d3, e3);
         case wa:
-          return a2 = a2.get(null === d2.key ? c2 : d2.key) || null, l2(b2, a2, d2, e2);
+          return a3 = a3.get(null === d3.key ? c3 : d3.key) || null, l2(b3, a3, d3, e3);
         case Ha:
-          var f3 = d2._init;
-          return y2(a2, b2, c2, f3(d2._payload), e2);
+          var f3 = d3._init;
+          return y2(a3, b3, c3, f3(d3._payload), e3);
       }
-      if (eb(d2) || Ka(d2)) return a2 = a2.get(c2) || null, m2(b2, a2, d2, e2, null);
-      Mg(b2, d2);
+      if (eb(d3) || Ka(d3)) return a3 = a3.get(c3) || null, m2(b3, a3, d3, e3, null);
+      Mg(b3, d3);
     }
     return null;
   }
-  function n2(e2, g2, h3, k3) {
-    for (var l3 = null, m3 = null, u2 = g2, w2 = g2 = 0, x2 = null; null !== u2 && w2 < h3.length; w2++) {
+  function n2(e3, g3, h3, k3) {
+    for (var l3 = null, m3 = null, u2 = g3, w2 = g3 = 0, x2 = null; null !== u2 && w2 < h3.length; w2++) {
       u2.index > w2 ? (x2 = u2, u2 = null) : x2 = u2.sibling;
-      var n3 = r2(e2, u2, h3[w2], k3);
+      var n3 = r2(e3, u2, h3[w2], k3);
       if (null === n3) {
         null === u2 && (u2 = x2);
         break;
       }
-      a && u2 && null === n3.alternate && b(e2, u2);
-      g2 = f2(n3, g2, w2);
+      a2 && u2 && null === n3.alternate && b2(e3, u2);
+      g3 = f2(n3, g3, w2);
       null === m3 ? l3 = n3 : m3.sibling = n3;
       m3 = n3;
       u2 = x2;
     }
-    if (w2 === h3.length) return c(e2, u2), I && tg(e2, w2), l3;
+    if (w2 === h3.length) return c2(e3, u2), I$1 && tg(e3, w2), l3;
     if (null === u2) {
-      for (; w2 < h3.length; w2++) u2 = q2(e2, h3[w2], k3), null !== u2 && (g2 = f2(u2, g2, w2), null === m3 ? l3 = u2 : m3.sibling = u2, m3 = u2);
-      I && tg(e2, w2);
+      for (; w2 < h3.length; w2++) u2 = q2(e3, h3[w2], k3), null !== u2 && (g3 = f2(u2, g3, w2), null === m3 ? l3 = u2 : m3.sibling = u2, m3 = u2);
+      I$1 && tg(e3, w2);
       return l3;
     }
-    for (u2 = d(e2, u2); w2 < h3.length; w2++) x2 = y2(u2, e2, w2, h3[w2], k3), null !== x2 && (a && null !== x2.alternate && u2.delete(null === x2.key ? w2 : x2.key), g2 = f2(x2, g2, w2), null === m3 ? l3 = x2 : m3.sibling = x2, m3 = x2);
-    a && u2.forEach(function(a2) {
-      return b(e2, a2);
+    for (u2 = d2(e3, u2); w2 < h3.length; w2++) x2 = y2(u2, e3, w2, h3[w2], k3), null !== x2 && (a2 && null !== x2.alternate && u2.delete(null === x2.key ? w2 : x2.key), g3 = f2(x2, g3, w2), null === m3 ? l3 = x2 : m3.sibling = x2, m3 = x2);
+    a2 && u2.forEach(function(a3) {
+      return b2(e3, a3);
     });
-    I && tg(e2, w2);
+    I$1 && tg(e3, w2);
     return l3;
   }
-  function t2(e2, g2, h3, k3) {
+  function t2(e3, g3, h3, k3) {
     var l3 = Ka(h3);
-    if ("function" !== typeof l3) throw Error(p(150));
+    if ("function" !== typeof l3) throw Error(p$1(150));
     h3 = l3.call(h3);
-    if (null == h3) throw Error(p(151));
-    for (var u2 = l3 = null, m3 = g2, w2 = g2 = 0, x2 = null, n3 = h3.next(); null !== m3 && !n3.done; w2++, n3 = h3.next()) {
+    if (null == h3) throw Error(p$1(151));
+    for (var u2 = l3 = null, m3 = g3, w2 = g3 = 0, x2 = null, n3 = h3.next(); null !== m3 && !n3.done; w2++, n3 = h3.next()) {
       m3.index > w2 ? (x2 = m3, m3 = null) : x2 = m3.sibling;
-      var t3 = r2(e2, m3, n3.value, k3);
+      var t3 = r2(e3, m3, n3.value, k3);
       if (null === t3) {
         null === m3 && (m3 = x2);
         break;
       }
-      a && m3 && null === t3.alternate && b(e2, m3);
-      g2 = f2(t3, g2, w2);
+      a2 && m3 && null === t3.alternate && b2(e3, m3);
+      g3 = f2(t3, g3, w2);
       null === u2 ? l3 = t3 : u2.sibling = t3;
       u2 = t3;
       m3 = x2;
     }
-    if (n3.done) return c(
-      e2,
+    if (n3.done) return c2(
+      e3,
       m3
-    ), I && tg(e2, w2), l3;
+    ), I$1 && tg(e3, w2), l3;
     if (null === m3) {
-      for (; !n3.done; w2++, n3 = h3.next()) n3 = q2(e2, n3.value, k3), null !== n3 && (g2 = f2(n3, g2, w2), null === u2 ? l3 = n3 : u2.sibling = n3, u2 = n3);
-      I && tg(e2, w2);
+      for (; !n3.done; w2++, n3 = h3.next()) n3 = q2(e3, n3.value, k3), null !== n3 && (g3 = f2(n3, g3, w2), null === u2 ? l3 = n3 : u2.sibling = n3, u2 = n3);
+      I$1 && tg(e3, w2);
       return l3;
     }
-    for (m3 = d(e2, m3); !n3.done; w2++, n3 = h3.next()) n3 = y2(m3, e2, w2, n3.value, k3), null !== n3 && (a && null !== n3.alternate && m3.delete(null === n3.key ? w2 : n3.key), g2 = f2(n3, g2, w2), null === u2 ? l3 = n3 : u2.sibling = n3, u2 = n3);
-    a && m3.forEach(function(a2) {
-      return b(e2, a2);
+    for (m3 = d2(e3, m3); !n3.done; w2++, n3 = h3.next()) n3 = y2(m3, e3, w2, n3.value, k3), null !== n3 && (a2 && null !== n3.alternate && m3.delete(null === n3.key ? w2 : n3.key), g3 = f2(n3, g3, w2), null === u2 ? l3 = n3 : u2.sibling = n3, u2 = n3);
+    a2 && m3.forEach(function(a3) {
+      return b2(e3, a3);
     });
-    I && tg(e2, w2);
+    I$1 && tg(e3, w2);
     return l3;
   }
-  function J2(a2, d2, f3, h3) {
+  function J2(a3, d3, f3, h3) {
     "object" === typeof f3 && null !== f3 && f3.type === ya && null === f3.key && (f3 = f3.props.children);
     if ("object" === typeof f3 && null !== f3) {
       switch (f3.$$typeof) {
         case va:
           a: {
-            for (var k3 = f3.key, l3 = d2; null !== l3; ) {
+            for (var k3 = f3.key, l3 = d3; null !== l3; ) {
               if (l3.key === k3) {
                 k3 = f3.type;
                 if (k3 === ya) {
                   if (7 === l3.tag) {
-                    c(a2, l3.sibling);
-                    d2 = e(l3, f3.props.children);
-                    d2.return = a2;
-                    a2 = d2;
+                    c2(a3, l3.sibling);
+                    d3 = e2(l3, f3.props.children);
+                    d3.return = a3;
+                    a3 = d3;
                     break a;
                   }
                 } else if (l3.elementType === k3 || "object" === typeof k3 && null !== k3 && k3.$$typeof === Ha && Ng(k3) === l3.type) {
-                  c(a2, l3.sibling);
-                  d2 = e(l3, f3.props);
-                  d2.ref = Lg(a2, l3, f3);
-                  d2.return = a2;
-                  a2 = d2;
+                  c2(a3, l3.sibling);
+                  d3 = e2(l3, f3.props);
+                  d3.ref = Lg(a3, l3, f3);
+                  d3.return = a3;
+                  a3 = d3;
                   break a;
                 }
-                c(a2, l3);
+                c2(a3, l3);
                 break;
-              } else b(a2, l3);
+              } else b2(a3, l3);
               l3 = l3.sibling;
             }
-            f3.type === ya ? (d2 = Tg(f3.props.children, a2.mode, h3, f3.key), d2.return = a2, a2 = d2) : (h3 = Rg(f3.type, f3.key, f3.props, null, a2.mode, h3), h3.ref = Lg(a2, d2, f3), h3.return = a2, a2 = h3);
+            f3.type === ya ? (d3 = Tg(f3.props.children, a3.mode, h3, f3.key), d3.return = a3, a3 = d3) : (h3 = Rg(f3.type, f3.key, f3.props, null, a3.mode, h3), h3.ref = Lg(a3, d3, f3), h3.return = a3, a3 = h3);
           }
-          return g(a2);
+          return g2(a3);
         case wa:
           a: {
-            for (l3 = f3.key; null !== d2; ) {
-              if (d2.key === l3) if (4 === d2.tag && d2.stateNode.containerInfo === f3.containerInfo && d2.stateNode.implementation === f3.implementation) {
-                c(a2, d2.sibling);
-                d2 = e(d2, f3.children || []);
-                d2.return = a2;
-                a2 = d2;
+            for (l3 = f3.key; null !== d3; ) {
+              if (d3.key === l3) if (4 === d3.tag && d3.stateNode.containerInfo === f3.containerInfo && d3.stateNode.implementation === f3.implementation) {
+                c2(a3, d3.sibling);
+                d3 = e2(d3, f3.children || []);
+                d3.return = a3;
+                a3 = d3;
                 break a;
               } else {
-                c(a2, d2);
+                c2(a3, d3);
                 break;
               }
-              else b(a2, d2);
-              d2 = d2.sibling;
+              else b2(a3, d3);
+              d3 = d3.sibling;
             }
-            d2 = Sg(f3, a2.mode, h3);
-            d2.return = a2;
-            a2 = d2;
+            d3 = Sg(f3, a3.mode, h3);
+            d3.return = a3;
+            a3 = d3;
           }
-          return g(a2);
+          return g2(a3);
         case Ha:
-          return l3 = f3._init, J2(a2, d2, l3(f3._payload), h3);
+          return l3 = f3._init, J2(a3, d3, l3(f3._payload), h3);
       }
-      if (eb(f3)) return n2(a2, d2, f3, h3);
-      if (Ka(f3)) return t2(a2, d2, f3, h3);
-      Mg(a2, f3);
+      if (eb(f3)) return n2(a3, d3, f3, h3);
+      if (Ka(f3)) return t2(a3, d3, f3, h3);
+      Mg(a3, f3);
     }
-    return "string" === typeof f3 && "" !== f3 || "number" === typeof f3 ? (f3 = "" + f3, null !== d2 && 6 === d2.tag ? (c(a2, d2.sibling), d2 = e(d2, f3), d2.return = a2, a2 = d2) : (c(a2, d2), d2 = Qg(f3, a2.mode, h3), d2.return = a2, a2 = d2), g(a2)) : c(a2, d2);
+    return "string" === typeof f3 && "" !== f3 || "number" === typeof f3 ? (f3 = "" + f3, null !== d3 && 6 === d3.tag ? (c2(a3, d3.sibling), d3 = e2(d3, f3), d3.return = a3, a3 = d3) : (c2(a3, d3), d3 = Qg(f3, a3.mode, h3), d3.return = a3, a3 = d3), g2(a3)) : c2(a3, d3);
   }
   return J2;
 }
@@ -3125,142 +3125,142 @@ var Ug = Og(true), Vg = Og(false), Wg = Uf(null), Xg = null, Yg = null, Zg = nul
 function $g() {
   Zg = Yg = Xg = null;
 }
-function ah(a) {
-  var b = Wg.current;
-  E(Wg);
-  a._currentValue = b;
+function ah(a2) {
+  var b2 = Wg.current;
+  E$1(Wg);
+  a2._currentValue = b2;
 }
-function bh(a, b, c) {
-  for (; null !== a; ) {
-    var d = a.alternate;
-    (a.childLanes & b) !== b ? (a.childLanes |= b, null !== d && (d.childLanes |= b)) : null !== d && (d.childLanes & b) !== b && (d.childLanes |= b);
-    if (a === c) break;
-    a = a.return;
+function bh(a2, b2, c2) {
+  for (; null !== a2; ) {
+    var d2 = a2.alternate;
+    (a2.childLanes & b2) !== b2 ? (a2.childLanes |= b2, null !== d2 && (d2.childLanes |= b2)) : null !== d2 && (d2.childLanes & b2) !== b2 && (d2.childLanes |= b2);
+    if (a2 === c2) break;
+    a2 = a2.return;
   }
 }
-function ch(a, b) {
-  Xg = a;
+function ch(a2, b2) {
+  Xg = a2;
   Zg = Yg = null;
-  a = a.dependencies;
-  null !== a && null !== a.firstContext && (0 !== (a.lanes & b) && (dh = true), a.firstContext = null);
-}
-function eh(a) {
-  var b = a._currentValue;
-  if (Zg !== a) if (a = { context: a, memoizedValue: b, next: null }, null === Yg) {
-    if (null === Xg) throw Error(p(308));
-    Yg = a;
-    Xg.dependencies = { lanes: 0, firstContext: a };
-  } else Yg = Yg.next = a;
-  return b;
+  a2 = a2.dependencies;
+  null !== a2 && null !== a2.firstContext && (0 !== (a2.lanes & b2) && (dh = true), a2.firstContext = null);
+}
+function eh(a2) {
+  var b2 = a2._currentValue;
+  if (Zg !== a2) if (a2 = { context: a2, memoizedValue: b2, next: null }, null === Yg) {
+    if (null === Xg) throw Error(p$1(308));
+    Yg = a2;
+    Xg.dependencies = { lanes: 0, firstContext: a2 };
+  } else Yg = Yg.next = a2;
+  return b2;
 }
 var fh = null;
-function gh(a) {
-  null === fh ? fh = [a] : fh.push(a);
-}
-function hh(a, b, c, d) {
-  var e = b.interleaved;
-  null === e ? (c.next = c, gh(b)) : (c.next = e.next, e.next = c);
-  b.interleaved = c;
-  return ih(a, d);
-}
-function ih(a, b) {
-  a.lanes |= b;
-  var c = a.alternate;
-  null !== c && (c.lanes |= b);
-  c = a;
-  for (a = a.return; null !== a; ) a.childLanes |= b, c = a.alternate, null !== c && (c.childLanes |= b), c = a, a = a.return;
-  return 3 === c.tag ? c.stateNode : null;
+function gh(a2) {
+  null === fh ? fh = [a2] : fh.push(a2);
+}
+function hh(a2, b2, c2, d2) {
+  var e2 = b2.interleaved;
+  null === e2 ? (c2.next = c2, gh(b2)) : (c2.next = e2.next, e2.next = c2);
+  b2.interleaved = c2;
+  return ih(a2, d2);
+}
+function ih(a2, b2) {
+  a2.lanes |= b2;
+  var c2 = a2.alternate;
+  null !== c2 && (c2.lanes |= b2);
+  c2 = a2;
+  for (a2 = a2.return; null !== a2; ) a2.childLanes |= b2, c2 = a2.alternate, null !== c2 && (c2.childLanes |= b2), c2 = a2, a2 = a2.return;
+  return 3 === c2.tag ? c2.stateNode : null;
 }
 var jh = false;
-function kh(a) {
-  a.updateQueue = { baseState: a.memoizedState, firstBaseUpdate: null, lastBaseUpdate: null, shared: { pending: null, interleaved: null, lanes: 0 }, effects: null };
-}
-function lh(a, b) {
-  a = a.updateQueue;
-  b.updateQueue === a && (b.updateQueue = { baseState: a.baseState, firstBaseUpdate: a.firstBaseUpdate, lastBaseUpdate: a.lastBaseUpdate, shared: a.shared, effects: a.effects });
-}
-function mh(a, b) {
-  return { eventTime: a, lane: b, tag: 0, payload: null, callback: null, next: null };
-}
-function nh(a, b, c) {
-  var d = a.updateQueue;
-  if (null === d) return null;
-  d = d.shared;
-  if (0 !== (K & 2)) {
-    var e = d.pending;
-    null === e ? b.next = b : (b.next = e.next, e.next = b);
-    d.pending = b;
-    return ih(a, c);
-  }
-  e = d.interleaved;
-  null === e ? (b.next = b, gh(d)) : (b.next = e.next, e.next = b);
-  d.interleaved = b;
-  return ih(a, c);
-}
-function oh(a, b, c) {
-  b = b.updateQueue;
-  if (null !== b && (b = b.shared, 0 !== (c & 4194240))) {
-    var d = b.lanes;
-    d &= a.pendingLanes;
-    c |= d;
-    b.lanes = c;
-    Cc(a, c);
-  }
-}
-function ph(a, b) {
-  var c = a.updateQueue, d = a.alternate;
-  if (null !== d && (d = d.updateQueue, c === d)) {
-    var e = null, f2 = null;
-    c = c.firstBaseUpdate;
-    if (null !== c) {
+function kh(a2) {
+  a2.updateQueue = { baseState: a2.memoizedState, firstBaseUpdate: null, lastBaseUpdate: null, shared: { pending: null, interleaved: null, lanes: 0 }, effects: null };
+}
+function lh(a2, b2) {
+  a2 = a2.updateQueue;
+  b2.updateQueue === a2 && (b2.updateQueue = { baseState: a2.baseState, firstBaseUpdate: a2.firstBaseUpdate, lastBaseUpdate: a2.lastBaseUpdate, shared: a2.shared, effects: a2.effects });
+}
+function mh(a2, b2) {
+  return { eventTime: a2, lane: b2, tag: 0, payload: null, callback: null, next: null };
+}
+function nh(a2, b2, c2) {
+  var d2 = a2.updateQueue;
+  if (null === d2) return null;
+  d2 = d2.shared;
+  if (0 !== (K$1 & 2)) {
+    var e2 = d2.pending;
+    null === e2 ? b2.next = b2 : (b2.next = e2.next, e2.next = b2);
+    d2.pending = b2;
+    return ih(a2, c2);
+  }
+  e2 = d2.interleaved;
+  null === e2 ? (b2.next = b2, gh(d2)) : (b2.next = e2.next, e2.next = b2);
+  d2.interleaved = b2;
+  return ih(a2, c2);
+}
+function oh(a2, b2, c2) {
+  b2 = b2.updateQueue;
+  if (null !== b2 && (b2 = b2.shared, 0 !== (c2 & 4194240))) {
+    var d2 = b2.lanes;
+    d2 &= a2.pendingLanes;
+    c2 |= d2;
+    b2.lanes = c2;
+    Cc(a2, c2);
+  }
+}
+function ph(a2, b2) {
+  var c2 = a2.updateQueue, d2 = a2.alternate;
+  if (null !== d2 && (d2 = d2.updateQueue, c2 === d2)) {
+    var e2 = null, f2 = null;
+    c2 = c2.firstBaseUpdate;
+    if (null !== c2) {
       do {
-        var g = { eventTime: c.eventTime, lane: c.lane, tag: c.tag, payload: c.payload, callback: c.callback, next: null };
-        null === f2 ? e = f2 = g : f2 = f2.next = g;
-        c = c.next;
-      } while (null !== c);
-      null === f2 ? e = f2 = b : f2 = f2.next = b;
-    } else e = f2 = b;
-    c = { baseState: d.baseState, firstBaseUpdate: e, lastBaseUpdate: f2, shared: d.shared, effects: d.effects };
-    a.updateQueue = c;
+        var g2 = { eventTime: c2.eventTime, lane: c2.lane, tag: c2.tag, payload: c2.payload, callback: c2.callback, next: null };
+        null === f2 ? e2 = f2 = g2 : f2 = f2.next = g2;
+        c2 = c2.next;
+      } while (null !== c2);
+      null === f2 ? e2 = f2 = b2 : f2 = f2.next = b2;
+    } else e2 = f2 = b2;
+    c2 = { baseState: d2.baseState, firstBaseUpdate: e2, lastBaseUpdate: f2, shared: d2.shared, effects: d2.effects };
+    a2.updateQueue = c2;
     return;
   }
-  a = c.lastBaseUpdate;
-  null === a ? c.firstBaseUpdate = b : a.next = b;
-  c.lastBaseUpdate = b;
+  a2 = c2.lastBaseUpdate;
+  null === a2 ? c2.firstBaseUpdate = b2 : a2.next = b2;
+  c2.lastBaseUpdate = b2;
 }
-function qh(a, b, c, d) {
-  var e = a.updateQueue;
+function qh(a2, b2, c2, d2) {
+  var e2 = a2.updateQueue;
   jh = false;
-  var f2 = e.firstBaseUpdate, g = e.lastBaseUpdate, h = e.shared.pending;
-  if (null !== h) {
-    e.shared.pending = null;
-    var k2 = h, l2 = k2.next;
+  var f2 = e2.firstBaseUpdate, g2 = e2.lastBaseUpdate, h2 = e2.shared.pending;
+  if (null !== h2) {
+    e2.shared.pending = null;
+    var k2 = h2, l2 = k2.next;
     k2.next = null;
-    null === g ? f2 = l2 : g.next = l2;
-    g = k2;
-    var m2 = a.alternate;
-    null !== m2 && (m2 = m2.updateQueue, h = m2.lastBaseUpdate, h !== g && (null === h ? m2.firstBaseUpdate = l2 : h.next = l2, m2.lastBaseUpdate = k2));
+    null === g2 ? f2 = l2 : g2.next = l2;
+    g2 = k2;
+    var m2 = a2.alternate;
+    null !== m2 && (m2 = m2.updateQueue, h2 = m2.lastBaseUpdate, h2 !== g2 && (null === h2 ? m2.firstBaseUpdate = l2 : h2.next = l2, m2.lastBaseUpdate = k2));
   }
   if (null !== f2) {
-    var q2 = e.baseState;
-    g = 0;
+    var q2 = e2.baseState;
+    g2 = 0;
     m2 = l2 = k2 = null;
-    h = f2;
+    h2 = f2;
     do {
-      var r2 = h.lane, y2 = h.eventTime;
-      if ((d & r2) === r2) {
+      var r2 = h2.lane, y2 = h2.eventTime;
+      if ((d2 & r2) === r2) {
         null !== m2 && (m2 = m2.next = {
           eventTime: y2,
           lane: 0,
-          tag: h.tag,
-          payload: h.payload,
-          callback: h.callback,
+          tag: h2.tag,
+          payload: h2.payload,
+          callback: h2.callback,
           next: null
         });
         a: {
-          var n2 = a, t2 = h;
-          r2 = b;
-          y2 = c;
+          var n2 = a2, t2 = h2;
+          r2 = b2;
+          y2 = c2;
           switch (t2.tag) {
             case 1:
               n2 = t2.payload;
@@ -3276,197 +3276,197 @@ function qh(a, b, c, d) {
               n2 = t2.payload;
               r2 = "function" === typeof n2 ? n2.call(y2, q2, r2) : n2;
               if (null === r2 || void 0 === r2) break a;
-              q2 = A({}, q2, r2);
+              q2 = A$1({}, q2, r2);
               break a;
             case 2:
               jh = true;
           }
         }
-        null !== h.callback && 0 !== h.lane && (a.flags |= 64, r2 = e.effects, null === r2 ? e.effects = [h] : r2.push(h));
-      } else y2 = { eventTime: y2, lane: r2, tag: h.tag, payload: h.payload, callback: h.callback, next: null }, null === m2 ? (l2 = m2 = y2, k2 = q2) : m2 = m2.next = y2, g |= r2;
-      h = h.next;
-      if (null === h) if (h = e.shared.pending, null === h) break;
-      else r2 = h, h = r2.next, r2.next = null, e.lastBaseUpdate = r2, e.shared.pending = null;
+        null !== h2.callback && 0 !== h2.lane && (a2.flags |= 64, r2 = e2.effects, null === r2 ? e2.effects = [h2] : r2.push(h2));
+      } else y2 = { eventTime: y2, lane: r2, tag: h2.tag, payload: h2.payload, callback: h2.callback, next: null }, null === m2 ? (l2 = m2 = y2, k2 = q2) : m2 = m2.next = y2, g2 |= r2;
+      h2 = h2.next;
+      if (null === h2) if (h2 = e2.shared.pending, null === h2) break;
+      else r2 = h2, h2 = r2.next, r2.next = null, e2.lastBaseUpdate = r2, e2.shared.pending = null;
     } while (1);
     null === m2 && (k2 = q2);
-    e.baseState = k2;
-    e.firstBaseUpdate = l2;
-    e.lastBaseUpdate = m2;
-    b = e.shared.interleaved;
-    if (null !== b) {
-      e = b;
+    e2.baseState = k2;
+    e2.firstBaseUpdate = l2;
+    e2.lastBaseUpdate = m2;
+    b2 = e2.shared.interleaved;
+    if (null !== b2) {
+      e2 = b2;
       do
-        g |= e.lane, e = e.next;
-      while (e !== b);
-    } else null === f2 && (e.shared.lanes = 0);
-    rh |= g;
-    a.lanes = g;
-    a.memoizedState = q2;
+        g2 |= e2.lane, e2 = e2.next;
+      while (e2 !== b2);
+    } else null === f2 && (e2.shared.lanes = 0);
+    rh |= g2;
+    a2.lanes = g2;
+    a2.memoizedState = q2;
   }
 }
-function sh(a, b, c) {
-  a = b.effects;
-  b.effects = null;
-  if (null !== a) for (b = 0; b < a.length; b++) {
-    var d = a[b], e = d.callback;
-    if (null !== e) {
-      d.callback = null;
-      d = c;
-      if ("function" !== typeof e) throw Error(p(191, e));
-      e.call(d);
+function sh(a2, b2, c2) {
+  a2 = b2.effects;
+  b2.effects = null;
+  if (null !== a2) for (b2 = 0; b2 < a2.length; b2++) {
+    var d2 = a2[b2], e2 = d2.callback;
+    if (null !== e2) {
+      d2.callback = null;
+      d2 = c2;
+      if ("function" !== typeof e2) throw Error(p$1(191, e2));
+      e2.call(d2);
     }
   }
 }
 var th = {}, uh = Uf(th), vh = Uf(th), wh = Uf(th);
-function xh(a) {
-  if (a === th) throw Error(p(174));
-  return a;
-}
-function yh(a, b) {
-  G(wh, b);
-  G(vh, a);
-  G(uh, th);
-  a = b.nodeType;
-  switch (a) {
+function xh(a2) {
+  if (a2 === th) throw Error(p$1(174));
+  return a2;
+}
+function yh(a2, b2) {
+  G$1(wh, b2);
+  G$1(vh, a2);
+  G$1(uh, th);
+  a2 = b2.nodeType;
+  switch (a2) {
     case 9:
     case 11:
-      b = (b = b.documentElement) ? b.namespaceURI : lb(null, "");
+      b2 = (b2 = b2.documentElement) ? b2.namespaceURI : lb(null, "");
       break;
     default:
-      a = 8 === a ? b.parentNode : b, b = a.namespaceURI || null, a = a.tagName, b = lb(b, a);
+      a2 = 8 === a2 ? b2.parentNode : b2, b2 = a2.namespaceURI || null, a2 = a2.tagName, b2 = lb(b2, a2);
   }
-  E(uh);
-  G(uh, b);
+  E$1(uh);
+  G$1(uh, b2);
 }
 function zh() {
-  E(uh);
-  E(vh);
-  E(wh);
+  E$1(uh);
+  E$1(vh);
+  E$1(wh);
 }
-function Ah(a) {
+function Ah(a2) {
   xh(wh.current);
-  var b = xh(uh.current);
-  var c = lb(b, a.type);
-  b !== c && (G(vh, a), G(uh, c));
-}
-function Bh(a) {
-  vh.current === a && (E(uh), E(vh));
-}
-var L$2 = Uf(0);
-function Ch(a) {
-  for (var b = a; null !== b; ) {
-    if (13 === b.tag) {
-      var c = b.memoizedState;
-      if (null !== c && (c = c.dehydrated, null === c || "$?" === c.data || "$!" === c.data)) return b;
-    } else if (19 === b.tag && void 0 !== b.memoizedProps.revealOrder) {
-      if (0 !== (b.flags & 128)) return b;
-    } else if (null !== b.child) {
-      b.child.return = b;
-      b = b.child;
+  var b2 = xh(uh.current);
+  var c2 = lb(b2, a2.type);
+  b2 !== c2 && (G$1(vh, a2), G$1(uh, c2));
+}
+function Bh(a2) {
+  vh.current === a2 && (E$1(uh), E$1(vh));
+}
+var L$1 = Uf(0);
+function Ch(a2) {
+  for (var b2 = a2; null !== b2; ) {
+    if (13 === b2.tag) {
+      var c2 = b2.memoizedState;
+      if (null !== c2 && (c2 = c2.dehydrated, null === c2 || "$?" === c2.data || "$!" === c2.data)) return b2;
+    } else if (19 === b2.tag && void 0 !== b2.memoizedProps.revealOrder) {
+      if (0 !== (b2.flags & 128)) return b2;
+    } else if (null !== b2.child) {
+      b2.child.return = b2;
+      b2 = b2.child;
       continue;
     }
-    if (b === a) break;
-    for (; null === b.sibling; ) {
-      if (null === b.return || b.return === a) return null;
-      b = b.return;
+    if (b2 === a2) break;
+    for (; null === b2.sibling; ) {
+      if (null === b2.return || b2.return === a2) return null;
+      b2 = b2.return;
     }
-    b.sibling.return = b.return;
-    b = b.sibling;
+    b2.sibling.return = b2.return;
+    b2 = b2.sibling;
   }
   return null;
 }
 var Dh = [];
 function Eh() {
-  for (var a = 0; a < Dh.length; a++) Dh[a]._workInProgressVersionPrimary = null;
+  for (var a2 = 0; a2 < Dh.length; a2++) Dh[a2]._workInProgressVersionPrimary = null;
   Dh.length = 0;
 }
-var Fh = ua.ReactCurrentDispatcher, Gh = ua.ReactCurrentBatchConfig, Hh = 0, M = null, N = null, O = null, Ih = false, Jh = false, Kh = 0, Lh = 0;
-function P() {
-  throw Error(p(321));
+var Fh = ua.ReactCurrentDispatcher, Gh = ua.ReactCurrentBatchConfig, Hh = 0, M$1 = null, N$1 = null, O$1 = null, Ih = false, Jh = false, Kh = 0, Lh = 0;
+function P$1() {
+  throw Error(p$1(321));
 }
-function Mh(a, b) {
-  if (null === b) return false;
-  for (var c = 0; c < b.length && c < a.length; c++) if (!He(a[c], b[c])) return false;
+function Mh(a2, b2) {
+  if (null === b2) return false;
+  for (var c2 = 0; c2 < b2.length && c2 < a2.length; c2++) if (!He$1(a2[c2], b2[c2])) return false;
   return true;
 }
-function Nh(a, b, c, d, e, f2) {
+function Nh(a2, b2, c2, d2, e2, f2) {
   Hh = f2;
-  M = b;
-  b.memoizedState = null;
-  b.updateQueue = null;
-  b.lanes = 0;
-  Fh.current = null === a || null === a.memoizedState ? Oh : Ph;
-  a = c(d, e);
+  M$1 = b2;
+  b2.memoizedState = null;
+  b2.updateQueue = null;
+  b2.lanes = 0;
+  Fh.current = null === a2 || null === a2.memoizedState ? Oh : Ph;
+  a2 = c2(d2, e2);
   if (Jh) {
     f2 = 0;
     do {
       Jh = false;
       Kh = 0;
-      if (25 <= f2) throw Error(p(301));
+      if (25 <= f2) throw Error(p$1(301));
       f2 += 1;
-      O = N = null;
-      b.updateQueue = null;
+      O$1 = N$1 = null;
+      b2.updateQueue = null;
       Fh.current = Qh;
-      a = c(d, e);
+      a2 = c2(d2, e2);
     } while (Jh);
   }
   Fh.current = Rh;
-  b = null !== N && null !== N.next;
+  b2 = null !== N$1 && null !== N$1.next;
   Hh = 0;
-  O = N = M = null;
+  O$1 = N$1 = M$1 = null;
   Ih = false;
-  if (b) throw Error(p(300));
-  return a;
+  if (b2) throw Error(p$1(300));
+  return a2;
 }
 function Sh() {
-  var a = 0 !== Kh;
+  var a2 = 0 !== Kh;
   Kh = 0;
-  return a;
+  return a2;
 }
 function Th() {
-  var a = { memoizedState: null, baseState: null, baseQueue: null, queue: null, next: null };
-  null === O ? M.memoizedState = O = a : O = O.next = a;
-  return O;
+  var a2 = { memoizedState: null, baseState: null, baseQueue: null, queue: null, next: null };
+  null === O$1 ? M$1.memoizedState = O$1 = a2 : O$1 = O$1.next = a2;
+  return O$1;
 }
 function Uh() {
-  if (null === N) {
-    var a = M.alternate;
-    a = null !== a ? a.memoizedState : null;
-  } else a = N.next;
-  var b = null === O ? M.memoizedState : O.next;
-  if (null !== b) O = b, N = a;
+  if (null === N$1) {
+    var a2 = M$1.alternate;
+    a2 = null !== a2 ? a2.memoizedState : null;
+  } else a2 = N$1.next;
+  var b2 = null === O$1 ? M$1.memoizedState : O$1.next;
+  if (null !== b2) O$1 = b2, N$1 = a2;
   else {
-    if (null === a) throw Error(p(310));
-    N = a;
-    a = { memoizedState: N.memoizedState, baseState: N.baseState, baseQueue: N.baseQueue, queue: N.queue, next: null };
-    null === O ? M.memoizedState = O = a : O = O.next = a;
+    if (null === a2) throw Error(p$1(310));
+    N$1 = a2;
+    a2 = { memoizedState: N$1.memoizedState, baseState: N$1.baseState, baseQueue: N$1.baseQueue, queue: N$1.queue, next: null };
+    null === O$1 ? M$1.memoizedState = O$1 = a2 : O$1 = O$1.next = a2;
   }
-  return O;
+  return O$1;
 }
-function Vh(a, b) {
-  return "function" === typeof b ? b(a) : b;
+function Vh(a2, b2) {
+  return "function" === typeof b2 ? b2(a2) : b2;
 }
-function Wh(a) {
-  var b = Uh(), c = b.queue;
-  if (null === c) throw Error(p(311));
-  c.lastRenderedReducer = a;
-  var d = N, e = d.baseQueue, f2 = c.pending;
+function Wh(a2) {
+  var b2 = Uh(), c2 = b2.queue;
+  if (null === c2) throw Error(p$1(311));
+  c2.lastRenderedReducer = a2;
+  var d2 = N$1, e2 = d2.baseQueue, f2 = c2.pending;
   if (null !== f2) {
-    if (null !== e) {
-      var g = e.next;
-      e.next = f2.next;
-      f2.next = g;
-    }
-    d.baseQueue = e = f2;
-    c.pending = null;
-  }
-  if (null !== e) {
-    f2 = e.next;
-    d = d.baseState;
-    var h = g = null, k2 = null, l2 = f2;
+    if (null !== e2) {
+      var g2 = e2.next;
+      e2.next = f2.next;
+      f2.next = g2;
+    }
+    d2.baseQueue = e2 = f2;
+    c2.pending = null;
+  }
+  if (null !== e2) {
+    f2 = e2.next;
+    d2 = d2.baseState;
+    var h2 = g2 = null, k2 = null, l2 = f2;
     do {
       var m2 = l2.lane;
-      if ((Hh & m2) === m2) null !== k2 && (k2 = k2.next = { lane: 0, action: l2.action, hasEagerState: l2.hasEagerState, eagerState: l2.eagerState, next: null }), d = l2.hasEagerState ? l2.eagerState : a(d, l2.action);
+      if ((Hh & m2) === m2) null !== k2 && (k2 = k2.next = { lane: 0, action: l2.action, hasEagerState: l2.hasEagerState, eagerState: l2.eagerState, next: null }), d2 = l2.hasEagerState ? l2.eagerState : a2(d2, l2.action);
       else {
         var q2 = {
           lane: m2,
@@ -3475,318 +3475,318 @@ function Wh(a) {
           eagerState: l2.eagerState,
           next: null
         };
-        null === k2 ? (h = k2 = q2, g = d) : k2 = k2.next = q2;
-        M.lanes |= m2;
+        null === k2 ? (h2 = k2 = q2, g2 = d2) : k2 = k2.next = q2;
+        M$1.lanes |= m2;
         rh |= m2;
       }
       l2 = l2.next;
     } while (null !== l2 && l2 !== f2);
-    null === k2 ? g = d : k2.next = h;
-    He(d, b.memoizedState) || (dh = true);
-    b.memoizedState = d;
-    b.baseState = g;
-    b.baseQueue = k2;
-    c.lastRenderedState = d;
-  }
-  a = c.interleaved;
-  if (null !== a) {
-    e = a;
+    null === k2 ? g2 = d2 : k2.next = h2;
+    He$1(d2, b2.memoizedState) || (dh = true);
+    b2.memoizedState = d2;
+    b2.baseState = g2;
+    b2.baseQueue = k2;
+    c2.lastRenderedState = d2;
+  }
+  a2 = c2.interleaved;
+  if (null !== a2) {
+    e2 = a2;
     do
-      f2 = e.lane, M.lanes |= f2, rh |= f2, e = e.next;
-    while (e !== a);
-  } else null === e && (c.lanes = 0);
-  return [b.memoizedState, c.dispatch];
-}
-function Xh(a) {
-  var b = Uh(), c = b.queue;
-  if (null === c) throw Error(p(311));
-  c.lastRenderedReducer = a;
-  var d = c.dispatch, e = c.pending, f2 = b.memoizedState;
-  if (null !== e) {
-    c.pending = null;
-    var g = e = e.next;
+      f2 = e2.lane, M$1.lanes |= f2, rh |= f2, e2 = e2.next;
+    while (e2 !== a2);
+  } else null === e2 && (c2.lanes = 0);
+  return [b2.memoizedState, c2.dispatch];
+}
+function Xh(a2) {
+  var b2 = Uh(), c2 = b2.queue;
+  if (null === c2) throw Error(p$1(311));
+  c2.lastRenderedReducer = a2;
+  var d2 = c2.dispatch, e2 = c2.pending, f2 = b2.memoizedState;
+  if (null !== e2) {
+    c2.pending = null;
+    var g2 = e2 = e2.next;
     do
-      f2 = a(f2, g.action), g = g.next;
-    while (g !== e);
-    He(f2, b.memoizedState) || (dh = true);
-    b.memoizedState = f2;
-    null === b.baseQueue && (b.baseState = f2);
-    c.lastRenderedState = f2;
-  }
-  return [f2, d];
+      f2 = a2(f2, g2.action), g2 = g2.next;
+    while (g2 !== e2);
+    He$1(f2, b2.memoizedState) || (dh = true);
+    b2.memoizedState = f2;
+    null === b2.baseQueue && (b2.baseState = f2);
+    c2.lastRenderedState = f2;
+  }
+  return [f2, d2];
 }
 function Yh() {
 }
-function Zh(a, b) {
-  var c = M, d = Uh(), e = b(), f2 = !He(d.memoizedState, e);
-  f2 && (d.memoizedState = e, dh = true);
-  d = d.queue;
-  $h(ai.bind(null, c, d, a), [a]);
-  if (d.getSnapshot !== b || f2 || null !== O && O.memoizedState.tag & 1) {
-    c.flags |= 2048;
-    bi(9, ci.bind(null, c, d, e, b), void 0, null);
-    if (null === Q) throw Error(p(349));
-    0 !== (Hh & 30) || di(c, b, e);
-  }
-  return e;
-}
-function di(a, b, c) {
-  a.flags |= 16384;
-  a = { getSnapshot: b, value: c };
-  b = M.updateQueue;
-  null === b ? (b = { lastEffect: null, stores: null }, M.updateQueue = b, b.stores = [a]) : (c = b.stores, null === c ? b.stores = [a] : c.push(a));
-}
-function ci(a, b, c, d) {
-  b.value = c;
-  b.getSnapshot = d;
-  ei(b) && fi(a);
-}
-function ai(a, b, c) {
-  return c(function() {
-    ei(b) && fi(a);
+function Zh(a2, b2) {
+  var c2 = M$1, d2 = Uh(), e2 = b2(), f2 = !He$1(d2.memoizedState, e2);
+  f2 && (d2.memoizedState = e2, dh = true);
+  d2 = d2.queue;
+  $h(ai.bind(null, c2, d2, a2), [a2]);
+  if (d2.getSnapshot !== b2 || f2 || null !== O$1 && O$1.memoizedState.tag & 1) {
+    c2.flags |= 2048;
+    bi(9, ci.bind(null, c2, d2, e2, b2), void 0, null);
+    if (null === Q$1) throw Error(p$1(349));
+    0 !== (Hh & 30) || di(c2, b2, e2);
+  }
+  return e2;
+}
+function di(a2, b2, c2) {
+  a2.flags |= 16384;
+  a2 = { getSnapshot: b2, value: c2 };
+  b2 = M$1.updateQueue;
+  null === b2 ? (b2 = { lastEffect: null, stores: null }, M$1.updateQueue = b2, b2.stores = [a2]) : (c2 = b2.stores, null === c2 ? b2.stores = [a2] : c2.push(a2));
+}
+function ci(a2, b2, c2, d2) {
+  b2.value = c2;
+  b2.getSnapshot = d2;
+  ei(b2) && fi(a2);
+}
+function ai(a2, b2, c2) {
+  return c2(function() {
+    ei(b2) && fi(a2);
   });
 }
-function ei(a) {
-  var b = a.getSnapshot;
-  a = a.value;
+function ei(a2) {
+  var b2 = a2.getSnapshot;
+  a2 = a2.value;
   try {
-    var c = b();
-    return !He(a, c);
-  } catch (d) {
+    var c2 = b2();
+    return !He$1(a2, c2);
+  } catch (d2) {
     return true;
   }
 }
-function fi(a) {
-  var b = ih(a, 1);
-  null !== b && gi(b, a, 1, -1);
+function fi(a2) {
+  var b2 = ih(a2, 1);
+  null !== b2 && gi(b2, a2, 1, -1);
 }
-function hi(a) {
-  var b = Th();
-  "function" === typeof a && (a = a());
-  b.memoizedState = b.baseState = a;
-  a = { pending: null, interleaved: null, lanes: 0, dispatch: null, lastRenderedReducer: Vh, lastRenderedState: a };
-  b.queue = a;
-  a = a.dispatch = ii.bind(null, M, a);
-  return [b.memoizedState, a];
+function hi(a2) {
+  var b2 = Th();
+  "function" === typeof a2 && (a2 = a2());
+  b2.memoizedState = b2.baseState = a2;
+  a2 = { pending: null, interleaved: null, lanes: 0, dispatch: null, lastRenderedReducer: Vh, lastRenderedState: a2 };
+  b2.queue = a2;
+  a2 = a2.dispatch = ii.bind(null, M$1, a2);
+  return [b2.memoizedState, a2];
 }
-function bi(a, b, c, d) {
-  a = { tag: a, create: b, destroy: c, deps: d, next: null };
-  b = M.updateQueue;
-  null === b ? (b = { lastEffect: null, stores: null }, M.updateQueue = b, b.lastEffect = a.next = a) : (c = b.lastEffect, null === c ? b.lastEffect = a.next = a : (d = c.next, c.next = a, a.next = d, b.lastEffect = a));
-  return a;
+function bi(a2, b2, c2, d2) {
+  a2 = { tag: a2, create: b2, destroy: c2, deps: d2, next: null };
+  b2 = M$1.updateQueue;
+  null === b2 ? (b2 = { lastEffect: null, stores: null }, M$1.updateQueue = b2, b2.lastEffect = a2.next = a2) : (c2 = b2.lastEffect, null === c2 ? b2.lastEffect = a2.next = a2 : (d2 = c2.next, c2.next = a2, a2.next = d2, b2.lastEffect = a2));
+  return a2;
 }
 function ji() {
   return Uh().memoizedState;
 }
-function ki(a, b, c, d) {
-  var e = Th();
-  M.flags |= a;
-  e.memoizedState = bi(1 | b, c, void 0, void 0 === d ? null : d);
+function ki(a2, b2, c2, d2) {
+  var e2 = Th();
+  M$1.flags |= a2;
+  e2.memoizedState = bi(1 | b2, c2, void 0, void 0 === d2 ? null : d2);
 }
-function li(a, b, c, d) {
-  var e = Uh();
-  d = void 0 === d ? null : d;
+function li(a2, b2, c2, d2) {
+  var e2 = Uh();
+  d2 = void 0 === d2 ? null : d2;
   var f2 = void 0;
-  if (null !== N) {
-    var g = N.memoizedState;
-    f2 = g.destroy;
-    if (null !== d && Mh(d, g.deps)) {
-      e.memoizedState = bi(b, c, f2, d);
+  if (null !== N$1) {
+    var g2 = N$1.memoizedState;
+    f2 = g2.destroy;
+    if (null !== d2 && Mh(d2, g2.deps)) {
+      e2.memoizedState = bi(b2, c2, f2, d2);
       return;
     }
   }
-  M.flags |= a;
-  e.memoizedState = bi(1 | b, c, f2, d);
+  M$1.flags |= a2;
+  e2.memoizedState = bi(1 | b2, c2, f2, d2);
 }
-function mi(a, b) {
-  return ki(8390656, 8, a, b);
+function mi(a2, b2) {
+  return ki(8390656, 8, a2, b2);
 }
-function $h(a, b) {
-  return li(2048, 8, a, b);
+function $h(a2, b2) {
+  return li(2048, 8, a2, b2);
 }
-function ni(a, b) {
-  return li(4, 2, a, b);
+function ni(a2, b2) {
+  return li(4, 2, a2, b2);
 }
-function oi(a, b) {
-  return li(4, 4, a, b);
+function oi(a2, b2) {
+  return li(4, 4, a2, b2);
 }
-function pi(a, b) {
-  if ("function" === typeof b) return a = a(), b(a), function() {
-    b(null);
+function pi(a2, b2) {
+  if ("function" === typeof b2) return a2 = a2(), b2(a2), function() {
+    b2(null);
   };
-  if (null !== b && void 0 !== b) return a = a(), b.current = a, function() {
-    b.current = null;
+  if (null !== b2 && void 0 !== b2) return a2 = a2(), b2.current = a2, function() {
+    b2.current = null;
   };
 }
-function qi(a, b, c) {
-  c = null !== c && void 0 !== c ? c.concat([a]) : null;
-  return li(4, 4, pi.bind(null, b, a), c);
+function qi(a2, b2, c2) {
+  c2 = null !== c2 && void 0 !== c2 ? c2.concat([a2]) : null;
+  return li(4, 4, pi.bind(null, b2, a2), c2);
 }
 function ri() {
 }
-function si(a, b) {
-  var c = Uh();
-  b = void 0 === b ? null : b;
-  var d = c.memoizedState;
-  if (null !== d && null !== b && Mh(b, d[1])) return d[0];
-  c.memoizedState = [a, b];
-  return a;
-}
-function ti(a, b) {
-  var c = Uh();
-  b = void 0 === b ? null : b;
-  var d = c.memoizedState;
-  if (null !== d && null !== b && Mh(b, d[1])) return d[0];
-  a = a();
-  c.memoizedState = [a, b];
-  return a;
-}
-function ui(a, b, c) {
-  if (0 === (Hh & 21)) return a.baseState && (a.baseState = false, dh = true), a.memoizedState = c;
-  He(c, b) || (c = yc(), M.lanes |= c, rh |= c, a.baseState = true);
-  return b;
+function si(a2, b2) {
+  var c2 = Uh();
+  b2 = void 0 === b2 ? null : b2;
+  var d2 = c2.memoizedState;
+  if (null !== d2 && null !== b2 && Mh(b2, d2[1])) return d2[0];
+  c2.memoizedState = [a2, b2];
+  return a2;
 }
-function vi(a, b) {
-  var c = C;
-  C = 0 !== c && 4 > c ? c : 4;
-  a(true);
-  var d = Gh.transition;
+function ti(a2, b2) {
+  var c2 = Uh();
+  b2 = void 0 === b2 ? null : b2;
+  var d2 = c2.memoizedState;
+  if (null !== d2 && null !== b2 && Mh(b2, d2[1])) return d2[0];
+  a2 = a2();
+  c2.memoizedState = [a2, b2];
+  return a2;
+}
+function ui(a2, b2, c2) {
+  if (0 === (Hh & 21)) return a2.baseState && (a2.baseState = false, dh = true), a2.memoizedState = c2;
+  He$1(c2, b2) || (c2 = yc(), M$1.lanes |= c2, rh |= c2, a2.baseState = true);
+  return b2;
+}
+function vi(a2, b2) {
+  var c2 = C$1;
+  C$1 = 0 !== c2 && 4 > c2 ? c2 : 4;
+  a2(true);
+  var d2 = Gh.transition;
   Gh.transition = {};
   try {
-    a(false), b();
+    a2(false), b2();
   } finally {
-    C = c, Gh.transition = d;
+    C$1 = c2, Gh.transition = d2;
   }
 }
 function wi() {
   return Uh().memoizedState;
 }
-function xi(a, b, c) {
-  var d = yi(a);
-  c = { lane: d, action: c, hasEagerState: false, eagerState: null, next: null };
-  if (zi(a)) Ai(b, c);
-  else if (c = hh(a, b, c, d), null !== c) {
-    var e = R();
-    gi(c, a, d, e);
-    Bi(c, b, d);
+function xi(a2, b2, c2) {
+  var d2 = yi(a2);
+  c2 = { lane: d2, action: c2, hasEagerState: false, eagerState: null, next: null };
+  if (zi(a2)) Ai(b2, c2);
+  else if (c2 = hh(a2, b2, c2, d2), null !== c2) {
+    var e2 = R$1();
+    gi(c2, a2, d2, e2);
+    Bi(c2, b2, d2);
   }
 }
-function ii(a, b, c) {
-  var d = yi(a), e = { lane: d, action: c, hasEagerState: false, eagerState: null, next: null };
-  if (zi(a)) Ai(b, e);
+function ii(a2, b2, c2) {
+  var d2 = yi(a2), e2 = { lane: d2, action: c2, hasEagerState: false, eagerState: null, next: null };
+  if (zi(a2)) Ai(b2, e2);
   else {
-    var f2 = a.alternate;
-    if (0 === a.lanes && (null === f2 || 0 === f2.lanes) && (f2 = b.lastRenderedReducer, null !== f2)) try {
-      var g = b.lastRenderedState, h = f2(g, c);
-      e.hasEagerState = true;
-      e.eagerState = h;
-      if (He(h, g)) {
-        var k2 = b.interleaved;
-        null === k2 ? (e.next = e, gh(b)) : (e.next = k2.next, k2.next = e);
-        b.interleaved = e;
+    var f2 = a2.alternate;
+    if (0 === a2.lanes && (null === f2 || 0 === f2.lanes) && (f2 = b2.lastRenderedReducer, null !== f2)) try {
+      var g2 = b2.lastRenderedState, h2 = f2(g2, c2);
+      e2.hasEagerState = true;
+      e2.eagerState = h2;
+      if (He$1(h2, g2)) {
+        var k2 = b2.interleaved;
+        null === k2 ? (e2.next = e2, gh(b2)) : (e2.next = k2.next, k2.next = e2);
+        b2.interleaved = e2;
         return;
       }
     } catch (l2) {
     } finally {
     }
-    c = hh(a, b, e, d);
-    null !== c && (e = R(), gi(c, a, d, e), Bi(c, b, d));
+    c2 = hh(a2, b2, e2, d2);
+    null !== c2 && (e2 = R$1(), gi(c2, a2, d2, e2), Bi(c2, b2, d2));
   }
 }
-function zi(a) {
-  var b = a.alternate;
-  return a === M || null !== b && b === M;
+function zi(a2) {
+  var b2 = a2.alternate;
+  return a2 === M$1 || null !== b2 && b2 === M$1;
 }
-function Ai(a, b) {
+function Ai(a2, b2) {
   Jh = Ih = true;
-  var c = a.pending;
-  null === c ? b.next = b : (b.next = c.next, c.next = b);
-  a.pending = b;
-}
-function Bi(a, b, c) {
-  if (0 !== (c & 4194240)) {
-    var d = b.lanes;
-    d &= a.pendingLanes;
-    c |= d;
-    b.lanes = c;
-    Cc(a, c);
-  }
-}
-var Rh = { readContext: eh, useCallback: P, useContext: P, useEffect: P, useImperativeHandle: P, useInsertionEffect: P, useLayoutEffect: P, useMemo: P, useReducer: P, useRef: P, useState: P, useDebugValue: P, useDeferredValue: P, useTransition: P, useMutableSource: P, useSyncExternalStore: P, useId: P, unstable_isNewReconciler: false }, Oh = { readContext: eh, useCallback: function(a, b) {
-  Th().memoizedState = [a, void 0 === b ? null : b];
-  return a;
-}, useContext: eh, useEffect: mi, useImperativeHandle: function(a, b, c) {
-  c = null !== c && void 0 !== c ? c.concat([a]) : null;
+  var c2 = a2.pending;
+  null === c2 ? b2.next = b2 : (b2.next = c2.next, c2.next = b2);
+  a2.pending = b2;
+}
+function Bi(a2, b2, c2) {
+  if (0 !== (c2 & 4194240)) {
+    var d2 = b2.lanes;
+    d2 &= a2.pendingLanes;
+    c2 |= d2;
+    b2.lanes = c2;
+    Cc(a2, c2);
+  }
+}
+var Rh = { readContext: eh, useCallback: P$1, useContext: P$1, useEffect: P$1, useImperativeHandle: P$1, useInsertionEffect: P$1, useLayoutEffect: P$1, useMemo: P$1, useReducer: P$1, useRef: P$1, useState: P$1, useDebugValue: P$1, useDeferredValue: P$1, useTransition: P$1, useMutableSource: P$1, useSyncExternalStore: P$1, useId: P$1, unstable_isNewReconciler: false }, Oh = { readContext: eh, useCallback: function(a2, b2) {
+  Th().memoizedState = [a2, void 0 === b2 ? null : b2];
+  return a2;
+}, useContext: eh, useEffect: mi, useImperativeHandle: function(a2, b2, c2) {
+  c2 = null !== c2 && void 0 !== c2 ? c2.concat([a2]) : null;
   return ki(
     4194308,
     4,
-    pi.bind(null, b, a),
-    c
+    pi.bind(null, b2, a2),
+    c2
   );
-}, useLayoutEffect: function(a, b) {
-  return ki(4194308, 4, a, b);
-}, useInsertionEffect: function(a, b) {
-  return ki(4, 2, a, b);
-}, useMemo: function(a, b) {
-  var c = Th();
-  b = void 0 === b ? null : b;
-  a = a();
-  c.memoizedState = [a, b];
-  return a;
-}, useReducer: function(a, b, c) {
-  var d = Th();
-  b = void 0 !== c ? c(b) : b;
-  d.memoizedState = d.baseState = b;
-  a = { pending: null, interleaved: null, lanes: 0, dispatch: null, lastRenderedReducer: a, lastRenderedState: b };
-  d.queue = a;
-  a = a.dispatch = xi.bind(null, M, a);
-  return [d.memoizedState, a];
-}, useRef: function(a) {
-  var b = Th();
-  a = { current: a };
-  return b.memoizedState = a;
-}, useState: hi, useDebugValue: ri, useDeferredValue: function(a) {
-  return Th().memoizedState = a;
+}, useLayoutEffect: function(a2, b2) {
+  return ki(4194308, 4, a2, b2);
+}, useInsertionEffect: function(a2, b2) {
+  return ki(4, 2, a2, b2);
+}, useMemo: function(a2, b2) {
+  var c2 = Th();
+  b2 = void 0 === b2 ? null : b2;
+  a2 = a2();
+  c2.memoizedState = [a2, b2];
+  return a2;
+}, useReducer: function(a2, b2, c2) {
+  var d2 = Th();
+  b2 = void 0 !== c2 ? c2(b2) : b2;
+  d2.memoizedState = d2.baseState = b2;
+  a2 = { pending: null, interleaved: null, lanes: 0, dispatch: null, lastRenderedReducer: a2, lastRenderedState: b2 };
+  d2.queue = a2;
+  a2 = a2.dispatch = xi.bind(null, M$1, a2);
+  return [d2.memoizedState, a2];
+}, useRef: function(a2) {
+  var b2 = Th();
+  a2 = { current: a2 };
+  return b2.memoizedState = a2;
+}, useState: hi, useDebugValue: ri, useDeferredValue: function(a2) {
+  return Th().memoizedState = a2;
 }, useTransition: function() {
-  var a = hi(false), b = a[0];
-  a = vi.bind(null, a[1]);
-  Th().memoizedState = a;
-  return [b, a];
+  var a2 = hi(false), b2 = a2[0];
+  a2 = vi.bind(null, a2[1]);
+  Th().memoizedState = a2;
+  return [b2, a2];
 }, useMutableSource: function() {
-}, useSyncExternalStore: function(a, b, c) {
-  var d = M, e = Th();
-  if (I) {
-    if (void 0 === c) throw Error(p(407));
-    c = c();
+}, useSyncExternalStore: function(a2, b2, c2) {
+  var d2 = M$1, e2 = Th();
+  if (I$1) {
+    if (void 0 === c2) throw Error(p$1(407));
+    c2 = c2();
   } else {
-    c = b();
-    if (null === Q) throw Error(p(349));
-    0 !== (Hh & 30) || di(d, b, c);
+    c2 = b2();
+    if (null === Q$1) throw Error(p$1(349));
+    0 !== (Hh & 30) || di(d2, b2, c2);
   }
-  e.memoizedState = c;
-  var f2 = { value: c, getSnapshot: b };
-  e.queue = f2;
+  e2.memoizedState = c2;
+  var f2 = { value: c2, getSnapshot: b2 };
+  e2.queue = f2;
   mi(ai.bind(
     null,
-    d,
+    d2,
     f2,
-    a
-  ), [a]);
-  d.flags |= 2048;
-  bi(9, ci.bind(null, d, f2, c, b), void 0, null);
-  return c;
+    a2
+  ), [a2]);
+  d2.flags |= 2048;
+  bi(9, ci.bind(null, d2, f2, c2, b2), void 0, null);
+  return c2;
 }, useId: function() {
-  var a = Th(), b = Q.identifierPrefix;
-  if (I) {
-    var c = sg;
-    var d = rg;
-    c = (d & ~(1 << 32 - oc(d) - 1)).toString(32) + c;
-    b = ":" + b + "R" + c;
-    c = Kh++;
-    0 < c && (b += "H" + c.toString(32));
-    b += ":";
-  } else c = Lh++, b = ":" + b + "r" + c.toString(32) + ":";
-  return a.memoizedState = b;
+  var a2 = Th(), b2 = Q$1.identifierPrefix;
+  if (I$1) {
+    var c2 = sg;
+    var d2 = rg;
+    c2 = (d2 & ~(1 << 32 - oc(d2) - 1)).toString(32) + c2;
+    b2 = ":" + b2 + "R" + c2;
+    c2 = Kh++;
+    0 < c2 && (b2 += "H" + c2.toString(32));
+    b2 += ":";
+  } else c2 = Lh++, b2 = ":" + b2 + "r" + c2.toString(32) + ":";
+  return a2.memoizedState = b2;
 }, unstable_isNewReconciler: false }, Ph = {
   readContext: eh,
   useCallback: si,
@@ -3802,13 +3802,13 @@ var Rh = { readContext: eh, useCallback: P, useContext: P, useEffect: P, useImpe
     return Wh(Vh);
   },
   useDebugValue: ri,
-  useDeferredValue: function(a) {
-    var b = Uh();
-    return ui(b, N.memoizedState, a);
+  useDeferredValue: function(a2) {
+    var b2 = Uh();
+    return ui(b2, N$1.memoizedState, a2);
   },
   useTransition: function() {
-    var a = Wh(Vh)[0], b = Uh().memoizedState;
-    return [a, b];
+    var a2 = Wh(Vh)[0], b2 = Uh().memoizedState;
+    return [a2, b2];
   },
   useMutableSource: Yh,
   useSyncExternalStore: Zh,
@@ -3816,416 +3816,416 @@ var Rh = { readContext: eh, useCallback: P, useContext: P, useEffect: P, useImpe
   unstable_isNewReconciler: false
 }, Qh = { readContext: eh, useCallback: si, useContext: eh, useEffect: $h, useImperativeHandle: qi, useInsertionEffect: ni, useLayoutEffect: oi, useMemo: ti, useReducer: Xh, useRef: ji, useState: function() {
   return Xh(Vh);
-}, useDebugValue: ri, useDeferredValue: function(a) {
-  var b = Uh();
-  return null === N ? b.memoizedState = a : ui(b, N.memoizedState, a);
+}, useDebugValue: ri, useDeferredValue: function(a2) {
+  var b2 = Uh();
+  return null === N$1 ? b2.memoizedState = a2 : ui(b2, N$1.memoizedState, a2);
 }, useTransition: function() {
-  var a = Xh(Vh)[0], b = Uh().memoizedState;
-  return [a, b];
+  var a2 = Xh(Vh)[0], b2 = Uh().memoizedState;
+  return [a2, b2];
 }, useMutableSource: Yh, useSyncExternalStore: Zh, useId: wi, unstable_isNewReconciler: false };
-function Ci(a, b) {
-  if (a && a.defaultProps) {
-    b = A({}, b);
-    a = a.defaultProps;
-    for (var c in a) void 0 === b[c] && (b[c] = a[c]);
-    return b;
+function Ci(a2, b2) {
+  if (a2 && a2.defaultProps) {
+    b2 = A$1({}, b2);
+    a2 = a2.defaultProps;
+    for (var c2 in a2) void 0 === b2[c2] && (b2[c2] = a2[c2]);
+    return b2;
   }
-  return b;
+  return b2;
+}
+function Di(a2, b2, c2, d2) {
+  b2 = a2.memoizedState;
+  c2 = c2(d2, b2);
+  c2 = null === c2 || void 0 === c2 ? b2 : A$1({}, b2, c2);
+  a2.memoizedState = c2;
+  0 === a2.lanes && (a2.updateQueue.baseState = c2);
 }
-function Di(a, b, c, d) {
-  b = a.memoizedState;
-  c = c(d, b);
-  c = null === c || void 0 === c ? b : A({}, b, c);
-  a.memoizedState = c;
-  0 === a.lanes && (a.updateQueue.baseState = c);
-}
-var Ei = { isMounted: function(a) {
-  return (a = a._reactInternals) ? Vb(a) === a : false;
-}, enqueueSetState: function(a, b, c) {
-  a = a._reactInternals;
-  var d = R(), e = yi(a), f2 = mh(d, e);
-  f2.payload = b;
-  void 0 !== c && null !== c && (f2.callback = c);
-  b = nh(a, f2, e);
-  null !== b && (gi(b, a, e, d), oh(b, a, e));
-}, enqueueReplaceState: function(a, b, c) {
-  a = a._reactInternals;
-  var d = R(), e = yi(a), f2 = mh(d, e);
+var Ei = { isMounted: function(a2) {
+  return (a2 = a2._reactInternals) ? Vb(a2) === a2 : false;
+}, enqueueSetState: function(a2, b2, c2) {
+  a2 = a2._reactInternals;
+  var d2 = R$1(), e2 = yi(a2), f2 = mh(d2, e2);
+  f2.payload = b2;
+  void 0 !== c2 && null !== c2 && (f2.callback = c2);
+  b2 = nh(a2, f2, e2);
+  null !== b2 && (gi(b2, a2, e2, d2), oh(b2, a2, e2));
+}, enqueueReplaceState: function(a2, b2, c2) {
+  a2 = a2._reactInternals;
+  var d2 = R$1(), e2 = yi(a2), f2 = mh(d2, e2);
   f2.tag = 1;
-  f2.payload = b;
-  void 0 !== c && null !== c && (f2.callback = c);
-  b = nh(a, f2, e);
-  null !== b && (gi(b, a, e, d), oh(b, a, e));
-}, enqueueForceUpdate: function(a, b) {
-  a = a._reactInternals;
-  var c = R(), d = yi(a), e = mh(c, d);
-  e.tag = 2;
-  void 0 !== b && null !== b && (e.callback = b);
-  b = nh(a, e, d);
-  null !== b && (gi(b, a, d, c), oh(b, a, d));
+  f2.payload = b2;
+  void 0 !== c2 && null !== c2 && (f2.callback = c2);
+  b2 = nh(a2, f2, e2);
+  null !== b2 && (gi(b2, a2, e2, d2), oh(b2, a2, e2));
+}, enqueueForceUpdate: function(a2, b2) {
+  a2 = a2._reactInternals;
+  var c2 = R$1(), d2 = yi(a2), e2 = mh(c2, d2);
+  e2.tag = 2;
+  void 0 !== b2 && null !== b2 && (e2.callback = b2);
+  b2 = nh(a2, e2, d2);
+  null !== b2 && (gi(b2, a2, d2, c2), oh(b2, a2, d2));
 } };
-function Fi(a, b, c, d, e, f2, g) {
-  a = a.stateNode;
-  return "function" === typeof a.shouldComponentUpdate ? a.shouldComponentUpdate(d, f2, g) : b.prototype && b.prototype.isPureReactComponent ? !Ie(c, d) || !Ie(e, f2) : true;
-}
-function Gi(a, b, c) {
-  var d = false, e = Vf;
-  var f2 = b.contextType;
-  "object" === typeof f2 && null !== f2 ? f2 = eh(f2) : (e = Zf(b) ? Xf : H.current, d = b.contextTypes, f2 = (d = null !== d && void 0 !== d) ? Yf(a, e) : Vf);
-  b = new b(c, f2);
-  a.memoizedState = null !== b.state && void 0 !== b.state ? b.state : null;
-  b.updater = Ei;
-  a.stateNode = b;
-  b._reactInternals = a;
-  d && (a = a.stateNode, a.__reactInternalMemoizedUnmaskedChildContext = e, a.__reactInternalMemoizedMaskedChildContext = f2);
-  return b;
+function Fi(a2, b2, c2, d2, e2, f2, g2) {
+  a2 = a2.stateNode;
+  return "function" === typeof a2.shouldComponentUpdate ? a2.shouldComponentUpdate(d2, f2, g2) : b2.prototype && b2.prototype.isPureReactComponent ? !Ie$1(c2, d2) || !Ie$1(e2, f2) : true;
+}
+function Gi(a2, b2, c2) {
+  var d2 = false, e2 = Vf;
+  var f2 = b2.contextType;
+  "object" === typeof f2 && null !== f2 ? f2 = eh(f2) : (e2 = Zf(b2) ? Xf : H$1.current, d2 = b2.contextTypes, f2 = (d2 = null !== d2 && void 0 !== d2) ? Yf(a2, e2) : Vf);
+  b2 = new b2(c2, f2);
+  a2.memoizedState = null !== b2.state && void 0 !== b2.state ? b2.state : null;
+  b2.updater = Ei;
+  a2.stateNode = b2;
+  b2._reactInternals = a2;
+  d2 && (a2 = a2.stateNode, a2.__reactInternalMemoizedUnmaskedChildContext = e2, a2.__reactInternalMemoizedMaskedChildContext = f2);
+  return b2;
+}
+function Hi(a2, b2, c2, d2) {
+  a2 = b2.state;
+  "function" === typeof b2.componentWillReceiveProps && b2.componentWillReceiveProps(c2, d2);
+  "function" === typeof b2.UNSAFE_componentWillReceiveProps && b2.UNSAFE_componentWillReceiveProps(c2, d2);
+  b2.state !== a2 && Ei.enqueueReplaceState(b2, b2.state, null);
+}
+function Ii(a2, b2, c2, d2) {
+  var e2 = a2.stateNode;
+  e2.props = c2;
+  e2.state = a2.memoizedState;
+  e2.refs = {};
+  kh(a2);
+  var f2 = b2.contextType;
+  "object" === typeof f2 && null !== f2 ? e2.context = eh(f2) : (f2 = Zf(b2) ? Xf : H$1.current, e2.context = Yf(a2, f2));
+  e2.state = a2.memoizedState;
+  f2 = b2.getDerivedStateFromProps;
+  "function" === typeof f2 && (Di(a2, b2, f2, c2), e2.state = a2.memoizedState);
+  "function" === typeof b2.getDerivedStateFromProps || "function" === typeof e2.getSnapshotBeforeUpdate || "function" !== typeof e2.UNSAFE_componentWillMount && "function" !== typeof e2.componentWillMount || (b2 = e2.state, "function" === typeof e2.componentWillMount && e2.componentWillMount(), "function" === typeof e2.UNSAFE_componentWillMount && e2.UNSAFE_componentWillMount(), b2 !== e2.state && Ei.enqueueReplaceState(e2, e2.state, null), qh(a2, c2, e2, d2), e2.state = a2.memoizedState);
+  "function" === typeof e2.componentDidMount && (a2.flags |= 4194308);
 }
-function Hi(a, b, c, d) {
-  a = b.state;
-  "function" === typeof b.componentWillReceiveProps && b.componentWillReceiveProps(c, d);
-  "function" === typeof b.UNSAFE_componentWillReceiveProps && b.UNSAFE_componentWillReceiveProps(c, d);
-  b.state !== a && Ei.enqueueReplaceState(b, b.state, null);
-}
-function Ii(a, b, c, d) {
-  var e = a.stateNode;
-  e.props = c;
-  e.state = a.memoizedState;
-  e.refs = {};
-  kh(a);
-  var f2 = b.contextType;
-  "object" === typeof f2 && null !== f2 ? e.context = eh(f2) : (f2 = Zf(b) ? Xf : H.current, e.context = Yf(a, f2));
-  e.state = a.memoizedState;
-  f2 = b.getDerivedStateFromProps;
-  "function" === typeof f2 && (Di(a, b, f2, c), e.state = a.memoizedState);
-  "function" === typeof b.getDerivedStateFromProps || "function" === typeof e.getSnapshotBeforeUpdate || "function" !== typeof e.UNSAFE_componentWillMount && "function" !== typeof e.componentWillMount || (b = e.state, "function" === typeof e.componentWillMount && e.componentWillMount(), "function" === typeof e.UNSAFE_componentWillMount && e.UNSAFE_componentWillMount(), b !== e.state && Ei.enqueueReplaceState(e, e.state, null), qh(a, c, e, d), e.state = a.memoizedState);
-  "function" === typeof e.componentDidMount && (a.flags |= 4194308);
-}
-function Ji(a, b) {
+function Ji(a2, b2) {
   try {
-    var c = "", d = b;
+    var c2 = "", d2 = b2;
     do
-      c += Pa(d), d = d.return;
-    while (d);
-    var e = c;
+      c2 += Pa(d2), d2 = d2.return;
+    while (d2);
+    var e2 = c2;
   } catch (f2) {
-    e = "\nError generating stack: " + f2.message + "\n" + f2.stack;
+    e2 = "\nError generating stack: " + f2.message + "\n" + f2.stack;
   }
-  return { value: a, source: b, stack: e, digest: null };
+  return { value: a2, source: b2, stack: e2, digest: null };
 }
-function Ki(a, b, c) {
-  return { value: a, source: null, stack: null != c ? c : null, digest: null != b ? b : null };
+function Ki(a2, b2, c2) {
+  return { value: a2, source: null, stack: null != c2 ? c2 : null, digest: null != b2 ? b2 : null };
 }
-function Li(a, b) {
+function Li(a2, b2) {
   try {
-    console.error(b.value);
-  } catch (c) {
+    console.error(b2.value);
+  } catch (c2) {
     setTimeout(function() {
-      throw c;
+      throw c2;
     });
   }
 }
 var Mi = "function" === typeof WeakMap ? WeakMap : Map;
-function Ni(a, b, c) {
-  c = mh(-1, c);
-  c.tag = 3;
-  c.payload = { element: null };
-  var d = b.value;
-  c.callback = function() {
-    Oi || (Oi = true, Pi = d);
-    Li(a, b);
+function Ni(a2, b2, c2) {
+  c2 = mh(-1, c2);
+  c2.tag = 3;
+  c2.payload = { element: null };
+  var d2 = b2.value;
+  c2.callback = function() {
+    Oi || (Oi = true, Pi = d2);
+    Li(a2, b2);
   };
-  return c;
-}
-function Qi(a, b, c) {
-  c = mh(-1, c);
-  c.tag = 3;
-  var d = a.type.getDerivedStateFromError;
-  if ("function" === typeof d) {
-    var e = b.value;
-    c.payload = function() {
-      return d(e);
+  return c2;
+}
+function Qi(a2, b2, c2) {
+  c2 = mh(-1, c2);
+  c2.tag = 3;
+  var d2 = a2.type.getDerivedStateFromError;
+  if ("function" === typeof d2) {
+    var e2 = b2.value;
+    c2.payload = function() {
+      return d2(e2);
     };
-    c.callback = function() {
-      Li(a, b);
+    c2.callback = function() {
+      Li(a2, b2);
     };
   }
-  var f2 = a.stateNode;
-  null !== f2 && "function" === typeof f2.componentDidCatch && (c.callback = function() {
-    Li(a, b);
-    "function" !== typeof d && (null === Ri ? Ri = /* @__PURE__ */ new Set([this]) : Ri.add(this));
-    var c2 = b.stack;
-    this.componentDidCatch(b.value, { componentStack: null !== c2 ? c2 : "" });
+  var f2 = a2.stateNode;
+  null !== f2 && "function" === typeof f2.componentDidCatch && (c2.callback = function() {
+    Li(a2, b2);
+    "function" !== typeof d2 && (null === Ri ? Ri = /* @__PURE__ */ new Set([this]) : Ri.add(this));
+    var c3 = b2.stack;
+    this.componentDidCatch(b2.value, { componentStack: null !== c3 ? c3 : "" });
   });
-  return c;
-}
-function Si(a, b, c) {
-  var d = a.pingCache;
-  if (null === d) {
-    d = a.pingCache = new Mi();
-    var e = /* @__PURE__ */ new Set();
-    d.set(b, e);
-  } else e = d.get(b), void 0 === e && (e = /* @__PURE__ */ new Set(), d.set(b, e));
-  e.has(c) || (e.add(c), a = Ti.bind(null, a, b, c), b.then(a, a));
-}
-function Ui(a) {
+  return c2;
+}
+function Si(a2, b2, c2) {
+  var d2 = a2.pingCache;
+  if (null === d2) {
+    d2 = a2.pingCache = new Mi();
+    var e2 = /* @__PURE__ */ new Set();
+    d2.set(b2, e2);
+  } else e2 = d2.get(b2), void 0 === e2 && (e2 = /* @__PURE__ */ new Set(), d2.set(b2, e2));
+  e2.has(c2) || (e2.add(c2), a2 = Ti.bind(null, a2, b2, c2), b2.then(a2, a2));
+}
+function Ui(a2) {
   do {
-    var b;
-    if (b = 13 === a.tag) b = a.memoizedState, b = null !== b ? null !== b.dehydrated ? true : false : true;
-    if (b) return a;
-    a = a.return;
-  } while (null !== a);
+    var b2;
+    if (b2 = 13 === a2.tag) b2 = a2.memoizedState, b2 = null !== b2 ? null !== b2.dehydrated ? true : false : true;
+    if (b2) return a2;
+    a2 = a2.return;
+  } while (null !== a2);
   return null;
 }
-function Vi(a, b, c, d, e) {
-  if (0 === (a.mode & 1)) return a === b ? a.flags |= 65536 : (a.flags |= 128, c.flags |= 131072, c.flags &= -52805, 1 === c.tag && (null === c.alternate ? c.tag = 17 : (b = mh(-1, 1), b.tag = 2, nh(c, b, 1))), c.lanes |= 1), a;
-  a.flags |= 65536;
-  a.lanes = e;
-  return a;
+function Vi(a2, b2, c2, d2, e2) {
+  if (0 === (a2.mode & 1)) return a2 === b2 ? a2.flags |= 65536 : (a2.flags |= 128, c2.flags |= 131072, c2.flags &= -52805, 1 === c2.tag && (null === c2.alternate ? c2.tag = 17 : (b2 = mh(-1, 1), b2.tag = 2, nh(c2, b2, 1))), c2.lanes |= 1), a2;
+  a2.flags |= 65536;
+  a2.lanes = e2;
+  return a2;
 }
 var Wi = ua.ReactCurrentOwner, dh = false;
-function Xi(a, b, c, d) {
-  b.child = null === a ? Vg(b, null, c, d) : Ug(b, a.child, c, d);
-}
-function Yi(a, b, c, d, e) {
-  c = c.render;
-  var f2 = b.ref;
-  ch(b, e);
-  d = Nh(a, b, c, d, f2, e);
-  c = Sh();
-  if (null !== a && !dh) return b.updateQueue = a.updateQueue, b.flags &= -2053, a.lanes &= ~e, Zi(a, b, e);
-  I && c && vg(b);
-  b.flags |= 1;
-  Xi(a, b, d, e);
-  return b.child;
-}
-function $i(a, b, c, d, e) {
-  if (null === a) {
-    var f2 = c.type;
-    if ("function" === typeof f2 && !aj(f2) && void 0 === f2.defaultProps && null === c.compare && void 0 === c.defaultProps) return b.tag = 15, b.type = f2, bj(a, b, f2, d, e);
-    a = Rg(c.type, null, d, b, b.mode, e);
-    a.ref = b.ref;
-    a.return = b;
-    return b.child = a;
-  }
-  f2 = a.child;
-  if (0 === (a.lanes & e)) {
-    var g = f2.memoizedProps;
-    c = c.compare;
-    c = null !== c ? c : Ie;
-    if (c(g, d) && a.ref === b.ref) return Zi(a, b, e);
-  }
-  b.flags |= 1;
-  a = Pg(f2, d);
-  a.ref = b.ref;
-  a.return = b;
-  return b.child = a;
-}
-function bj(a, b, c, d, e) {
-  if (null !== a) {
-    var f2 = a.memoizedProps;
-    if (Ie(f2, d) && a.ref === b.ref) if (dh = false, b.pendingProps = d = f2, 0 !== (a.lanes & e)) 0 !== (a.flags & 131072) && (dh = true);
-    else return b.lanes = a.lanes, Zi(a, b, e);
-  }
-  return cj(a, b, c, d, e);
-}
-function dj(a, b, c) {
-  var d = b.pendingProps, e = d.children, f2 = null !== a ? a.memoizedState : null;
-  if ("hidden" === d.mode) if (0 === (b.mode & 1)) b.memoizedState = { baseLanes: 0, cachePool: null, transitions: null }, G(ej, fj), fj |= c;
+function Xi(a2, b2, c2, d2) {
+  b2.child = null === a2 ? Vg(b2, null, c2, d2) : Ug(b2, a2.child, c2, d2);
+}
+function Yi(a2, b2, c2, d2, e2) {
+  c2 = c2.render;
+  var f2 = b2.ref;
+  ch(b2, e2);
+  d2 = Nh(a2, b2, c2, d2, f2, e2);
+  c2 = Sh();
+  if (null !== a2 && !dh) return b2.updateQueue = a2.updateQueue, b2.flags &= -2053, a2.lanes &= ~e2, Zi(a2, b2, e2);
+  I$1 && c2 && vg(b2);
+  b2.flags |= 1;
+  Xi(a2, b2, d2, e2);
+  return b2.child;
+}
+function $i(a2, b2, c2, d2, e2) {
+  if (null === a2) {
+    var f2 = c2.type;
+    if ("function" === typeof f2 && !aj(f2) && void 0 === f2.defaultProps && null === c2.compare && void 0 === c2.defaultProps) return b2.tag = 15, b2.type = f2, bj(a2, b2, f2, d2, e2);
+    a2 = Rg(c2.type, null, d2, b2, b2.mode, e2);
+    a2.ref = b2.ref;
+    a2.return = b2;
+    return b2.child = a2;
+  }
+  f2 = a2.child;
+  if (0 === (a2.lanes & e2)) {
+    var g2 = f2.memoizedProps;
+    c2 = c2.compare;
+    c2 = null !== c2 ? c2 : Ie$1;
+    if (c2(g2, d2) && a2.ref === b2.ref) return Zi(a2, b2, e2);
+  }
+  b2.flags |= 1;
+  a2 = Pg(f2, d2);
+  a2.ref = b2.ref;
+  a2.return = b2;
+  return b2.child = a2;
+}
+function bj(a2, b2, c2, d2, e2) {
+  if (null !== a2) {
+    var f2 = a2.memoizedProps;
+    if (Ie$1(f2, d2) && a2.ref === b2.ref) if (dh = false, b2.pendingProps = d2 = f2, 0 !== (a2.lanes & e2)) 0 !== (a2.flags & 131072) && (dh = true);
+    else return b2.lanes = a2.lanes, Zi(a2, b2, e2);
+  }
+  return cj(a2, b2, c2, d2, e2);
+}
+function dj(a2, b2, c2) {
+  var d2 = b2.pendingProps, e2 = d2.children, f2 = null !== a2 ? a2.memoizedState : null;
+  if ("hidden" === d2.mode) if (0 === (b2.mode & 1)) b2.memoizedState = { baseLanes: 0, cachePool: null, transitions: null }, G$1(ej, fj), fj |= c2;
   else {
-    if (0 === (c & 1073741824)) return a = null !== f2 ? f2.baseLanes | c : c, b.lanes = b.childLanes = 1073741824, b.memoizedState = { baseLanes: a, cachePool: null, transitions: null }, b.updateQueue = null, G(ej, fj), fj |= a, null;
-    b.memoizedState = { baseLanes: 0, cachePool: null, transitions: null };
-    d = null !== f2 ? f2.baseLanes : c;
-    G(ej, fj);
-    fj |= d;
-  }
-  else null !== f2 ? (d = f2.baseLanes | c, b.memoizedState = null) : d = c, G(ej, fj), fj |= d;
-  Xi(a, b, e, c);
-  return b.child;
-}
-function gj(a, b) {
-  var c = b.ref;
-  if (null === a && null !== c || null !== a && a.ref !== c) b.flags |= 512, b.flags |= 2097152;
-}
-function cj(a, b, c, d, e) {
-  var f2 = Zf(c) ? Xf : H.current;
-  f2 = Yf(b, f2);
-  ch(b, e);
-  c = Nh(a, b, c, d, f2, e);
-  d = Sh();
-  if (null !== a && !dh) return b.updateQueue = a.updateQueue, b.flags &= -2053, a.lanes &= ~e, Zi(a, b, e);
-  I && d && vg(b);
-  b.flags |= 1;
-  Xi(a, b, c, e);
-  return b.child;
-}
-function hj(a, b, c, d, e) {
-  if (Zf(c)) {
+    if (0 === (c2 & 1073741824)) return a2 = null !== f2 ? f2.baseLanes | c2 : c2, b2.lanes = b2.childLanes = 1073741824, b2.memoizedState = { baseLanes: a2, cachePool: null, transitions: null }, b2.updateQueue = null, G$1(ej, fj), fj |= a2, null;
+    b2.memoizedState = { baseLanes: 0, cachePool: null, transitions: null };
+    d2 = null !== f2 ? f2.baseLanes : c2;
+    G$1(ej, fj);
+    fj |= d2;
+  }
+  else null !== f2 ? (d2 = f2.baseLanes | c2, b2.memoizedState = null) : d2 = c2, G$1(ej, fj), fj |= d2;
+  Xi(a2, b2, e2, c2);
+  return b2.child;
+}
+function gj(a2, b2) {
+  var c2 = b2.ref;
+  if (null === a2 && null !== c2 || null !== a2 && a2.ref !== c2) b2.flags |= 512, b2.flags |= 2097152;
+}
+function cj(a2, b2, c2, d2, e2) {
+  var f2 = Zf(c2) ? Xf : H$1.current;
+  f2 = Yf(b2, f2);
+  ch(b2, e2);
+  c2 = Nh(a2, b2, c2, d2, f2, e2);
+  d2 = Sh();
+  if (null !== a2 && !dh) return b2.updateQueue = a2.updateQueue, b2.flags &= -2053, a2.lanes &= ~e2, Zi(a2, b2, e2);
+  I$1 && d2 && vg(b2);
+  b2.flags |= 1;
+  Xi(a2, b2, c2, e2);
+  return b2.child;
+}
+function hj(a2, b2, c2, d2, e2) {
+  if (Zf(c2)) {
     var f2 = true;
-    cg(b);
+    cg(b2);
   } else f2 = false;
-  ch(b, e);
-  if (null === b.stateNode) ij(a, b), Gi(b, c, d), Ii(b, c, d, e), d = true;
-  else if (null === a) {
-    var g = b.stateNode, h = b.memoizedProps;
-    g.props = h;
-    var k2 = g.context, l2 = c.contextType;
-    "object" === typeof l2 && null !== l2 ? l2 = eh(l2) : (l2 = Zf(c) ? Xf : H.current, l2 = Yf(b, l2));
-    var m2 = c.getDerivedStateFromProps, q2 = "function" === typeof m2 || "function" === typeof g.getSnapshotBeforeUpdate;
-    q2 || "function" !== typeof g.UNSAFE_componentWillReceiveProps && "function" !== typeof g.componentWillReceiveProps || (h !== d || k2 !== l2) && Hi(b, g, d, l2);
+  ch(b2, e2);
+  if (null === b2.stateNode) ij(a2, b2), Gi(b2, c2, d2), Ii(b2, c2, d2, e2), d2 = true;
+  else if (null === a2) {
+    var g2 = b2.stateNode, h2 = b2.memoizedProps;
+    g2.props = h2;
+    var k2 = g2.context, l2 = c2.contextType;
+    "object" === typeof l2 && null !== l2 ? l2 = eh(l2) : (l2 = Zf(c2) ? Xf : H$1.current, l2 = Yf(b2, l2));
+    var m2 = c2.getDerivedStateFromProps, q2 = "function" === typeof m2 || "function" === typeof g2.getSnapshotBeforeUpdate;
+    q2 || "function" !== typeof g2.UNSAFE_componentWillReceiveProps && "function" !== typeof g2.componentWillReceiveProps || (h2 !== d2 || k2 !== l2) && Hi(b2, g2, d2, l2);
     jh = false;
-    var r2 = b.memoizedState;
-    g.state = r2;
-    qh(b, d, g, e);
-    k2 = b.memoizedState;
-    h !== d || r2 !== k2 || Wf.current || jh ? ("function" === typeof m2 && (Di(b, c, m2, d), k2 = b.memoizedState), (h = jh || Fi(b, c, h, d, r2, k2, l2)) ? (q2 || "function" !== typeof g.UNSAFE_componentWillMount && "function" !== typeof g.componentWillMount || ("function" === typeof g.componentWillMount && g.componentWillMount(), "function" === typeof g.UNSAFE_componentWillMount && g.UNSAFE_componentWillMount()), "function" === typeof g.componentDidMount && (b.flags |= 4194308)) : ("function" === typeof g.componentDidMount && (b.flags |= 4194308), b.memoizedProps = d, b.memoizedState = k2), g.props = d, g.state = k2, g.context = l2, d = h) : ("function" === typeof g.componentDidMount && (b.flags |= 4194308), d = false);
+    var r2 = b2.memoizedState;
+    g2.state = r2;
+    qh(b2, d2, g2, e2);
+    k2 = b2.memoizedState;
+    h2 !== d2 || r2 !== k2 || Wf.current || jh ? ("function" === typeof m2 && (Di(b2, c2, m2, d2), k2 = b2.memoizedState), (h2 = jh || Fi(b2, c2, h2, d2, r2, k2, l2)) ? (q2 || "function" !== typeof g2.UNSAFE_componentWillMount && "function" !== typeof g2.componentWillMount || ("function" === typeof g2.componentWillMount && g2.componentWillMount(), "function" === typeof g2.UNSAFE_componentWillMount && g2.UNSAFE_componentWillMount()), "function" === typeof g2.componentDidMount && (b2.flags |= 4194308)) : ("function" === typeof g2.componentDidMount && (b2.flags |= 4194308), b2.memoizedProps = d2, b2.memoizedState = k2), g2.props = d2, g2.state = k2, g2.context = l2, d2 = h2) : ("function" === typeof g2.componentDidMount && (b2.flags |= 4194308), d2 = false);
   } else {
-    g = b.stateNode;
-    lh(a, b);
-    h = b.memoizedProps;
-    l2 = b.type === b.elementType ? h : Ci(b.type, h);
-    g.props = l2;
-    q2 = b.pendingProps;
-    r2 = g.context;
-    k2 = c.contextType;
-    "object" === typeof k2 && null !== k2 ? k2 = eh(k2) : (k2 = Zf(c) ? Xf : H.current, k2 = Yf(b, k2));
-    var y2 = c.getDerivedStateFromProps;
-    (m2 = "function" === typeof y2 || "function" === typeof g.getSnapshotBeforeUpdate) || "function" !== typeof g.UNSAFE_componentWillReceiveProps && "function" !== typeof g.componentWillReceiveProps || (h !== q2 || r2 !== k2) && Hi(b, g, d, k2);
+    g2 = b2.stateNode;
+    lh(a2, b2);
+    h2 = b2.memoizedProps;
+    l2 = b2.type === b2.elementType ? h2 : Ci(b2.type, h2);
+    g2.props = l2;
+    q2 = b2.pendingProps;
+    r2 = g2.context;
+    k2 = c2.contextType;
+    "object" === typeof k2 && null !== k2 ? k2 = eh(k2) : (k2 = Zf(c2) ? Xf : H$1.current, k2 = Yf(b2, k2));
+    var y2 = c2.getDerivedStateFromProps;
+    (m2 = "function" === typeof y2 || "function" === typeof g2.getSnapshotBeforeUpdate) || "function" !== typeof g2.UNSAFE_componentWillReceiveProps && "function" !== typeof g2.componentWillReceiveProps || (h2 !== q2 || r2 !== k2) && Hi(b2, g2, d2, k2);
     jh = false;
-    r2 = b.memoizedState;
-    g.state = r2;
-    qh(b, d, g, e);
-    var n2 = b.memoizedState;
-    h !== q2 || r2 !== n2 || Wf.current || jh ? ("function" === typeof y2 && (Di(b, c, y2, d), n2 = b.memoizedState), (l2 = jh || Fi(b, c, l2, d, r2, n2, k2) || false) ? (m2 || "function" !== typeof g.UNSAFE_componentWillUpdate && "function" !== typeof g.componentWillUpdate || ("function" === typeof g.componentWillUpdate && g.componentWillUpdate(d, n2, k2), "function" === typeof g.UNSAFE_componentWillUpdate && g.UNSAFE_componentWillUpdate(d, n2, k2)), "function" === typeof g.componentDidUpdate && (b.flags |= 4), "function" === typeof g.getSnapshotBeforeUpdate && (b.flags |= 1024)) : ("function" !== typeof g.componentDidUpdate || h === a.memoizedProps && r2 === a.memoizedState || (b.flags |= 4), "function" !== typeof g.getSnapshotBeforeUpdate || h === a.memoizedProps && r2 === a.memoizedState || (b.flags |= 1024), b.memoizedProps = d, b.memoizedState = n2), g.props = d, g.state = n2, g.context = k2, d = l2) : ("function" !== typeof g.componentDidUpdate || h === a.memoizedProps && r2 === a.memoizedState || (b.flags |= 4), "function" !== typeof g.getSnapshotBeforeUpdate || h === a.memoizedProps && r2 === a.memoizedState || (b.flags |= 1024), d = false);
-  }
-  return jj(a, b, c, d, f2, e);
-}
-function jj(a, b, c, d, e, f2) {
-  gj(a, b);
-  var g = 0 !== (b.flags & 128);
-  if (!d && !g) return e && dg(b, c, false), Zi(a, b, f2);
-  d = b.stateNode;
-  Wi.current = b;
-  var h = g && "function" !== typeof c.getDerivedStateFromError ? null : d.render();
-  b.flags |= 1;
-  null !== a && g ? (b.child = Ug(b, a.child, null, f2), b.child = Ug(b, null, h, f2)) : Xi(a, b, h, f2);
-  b.memoizedState = d.state;
-  e && dg(b, c, true);
-  return b.child;
-}
-function kj(a) {
-  var b = a.stateNode;
-  b.pendingContext ? ag(a, b.pendingContext, b.pendingContext !== b.context) : b.context && ag(a, b.context, false);
-  yh(a, b.containerInfo);
-}
-function lj(a, b, c, d, e) {
+    r2 = b2.memoizedState;
+    g2.state = r2;
+    qh(b2, d2, g2, e2);
+    var n2 = b2.memoizedState;
+    h2 !== q2 || r2 !== n2 || Wf.current || jh ? ("function" === typeof y2 && (Di(b2, c2, y2, d2), n2 = b2.memoizedState), (l2 = jh || Fi(b2, c2, l2, d2, r2, n2, k2) || false) ? (m2 || "function" !== typeof g2.UNSAFE_componentWillUpdate && "function" !== typeof g2.componentWillUpdate || ("function" === typeof g2.componentWillUpdate && g2.componentWillUpdate(d2, n2, k2), "function" === typeof g2.UNSAFE_componentWillUpdate && g2.UNSAFE_componentWillUpdate(d2, n2, k2)), "function" === typeof g2.componentDidUpdate && (b2.flags |= 4), "function" === typeof g2.getSnapshotBeforeUpdate && (b2.flags |= 1024)) : ("function" !== typeof g2.componentDidUpdate || h2 === a2.memoizedProps && r2 === a2.memoizedState || (b2.flags |= 4), "function" !== typeof g2.getSnapshotBeforeUpdate || h2 === a2.memoizedProps && r2 === a2.memoizedState || (b2.flags |= 1024), b2.memoizedProps = d2, b2.memoizedState = n2), g2.props = d2, g2.state = n2, g2.context = k2, d2 = l2) : ("function" !== typeof g2.componentDidUpdate || h2 === a2.memoizedProps && r2 === a2.memoizedState || (b2.flags |= 4), "function" !== typeof g2.getSnapshotBeforeUpdate || h2 === a2.memoizedProps && r2 === a2.memoizedState || (b2.flags |= 1024), d2 = false);
+  }
+  return jj(a2, b2, c2, d2, f2, e2);
+}
+function jj(a2, b2, c2, d2, e2, f2) {
+  gj(a2, b2);
+  var g2 = 0 !== (b2.flags & 128);
+  if (!d2 && !g2) return e2 && dg(b2, c2, false), Zi(a2, b2, f2);
+  d2 = b2.stateNode;
+  Wi.current = b2;
+  var h2 = g2 && "function" !== typeof c2.getDerivedStateFromError ? null : d2.render();
+  b2.flags |= 1;
+  null !== a2 && g2 ? (b2.child = Ug(b2, a2.child, null, f2), b2.child = Ug(b2, null, h2, f2)) : Xi(a2, b2, h2, f2);
+  b2.memoizedState = d2.state;
+  e2 && dg(b2, c2, true);
+  return b2.child;
+}
+function kj(a2) {
+  var b2 = a2.stateNode;
+  b2.pendingContext ? ag(a2, b2.pendingContext, b2.pendingContext !== b2.context) : b2.context && ag(a2, b2.context, false);
+  yh(a2, b2.containerInfo);
+}
+function lj(a2, b2, c2, d2, e2) {
   Ig();
-  Jg(e);
-  b.flags |= 256;
-  Xi(a, b, c, d);
-  return b.child;
+  Jg(e2);
+  b2.flags |= 256;
+  Xi(a2, b2, c2, d2);
+  return b2.child;
 }
 var mj = { dehydrated: null, treeContext: null, retryLane: 0 };
-function nj(a) {
-  return { baseLanes: a, cachePool: null, transitions: null };
-}
-function oj(a, b, c) {
-  var d = b.pendingProps, e = L$2.current, f2 = false, g = 0 !== (b.flags & 128), h;
-  (h = g) || (h = null !== a && null === a.memoizedState ? false : 0 !== (e & 2));
-  if (h) f2 = true, b.flags &= -129;
-  else if (null === a || null !== a.memoizedState) e |= 1;
-  G(L$2, e & 1);
-  if (null === a) {
-    Eg(b);
-    a = b.memoizedState;
-    if (null !== a && (a = a.dehydrated, null !== a)) return 0 === (b.mode & 1) ? b.lanes = 1 : "$!" === a.data ? b.lanes = 8 : b.lanes = 1073741824, null;
-    g = d.children;
-    a = d.fallback;
-    return f2 ? (d = b.mode, f2 = b.child, g = { mode: "hidden", children: g }, 0 === (d & 1) && null !== f2 ? (f2.childLanes = 0, f2.pendingProps = g) : f2 = pj(g, d, 0, null), a = Tg(a, d, c, null), f2.return = b, a.return = b, f2.sibling = a, b.child = f2, b.child.memoizedState = nj(c), b.memoizedState = mj, a) : qj(b, g);
-  }
-  e = a.memoizedState;
-  if (null !== e && (h = e.dehydrated, null !== h)) return rj(a, b, g, d, h, e, c);
+function nj(a2) {
+  return { baseLanes: a2, cachePool: null, transitions: null };
+}
+function oj(a2, b2, c2) {
+  var d2 = b2.pendingProps, e2 = L$1.current, f2 = false, g2 = 0 !== (b2.flags & 128), h2;
+  (h2 = g2) || (h2 = null !== a2 && null === a2.memoizedState ? false : 0 !== (e2 & 2));
+  if (h2) f2 = true, b2.flags &= -129;
+  else if (null === a2 || null !== a2.memoizedState) e2 |= 1;
+  G$1(L$1, e2 & 1);
+  if (null === a2) {
+    Eg(b2);
+    a2 = b2.memoizedState;
+    if (null !== a2 && (a2 = a2.dehydrated, null !== a2)) return 0 === (b2.mode & 1) ? b2.lanes = 1 : "$!" === a2.data ? b2.lanes = 8 : b2.lanes = 1073741824, null;
+    g2 = d2.children;
+    a2 = d2.fallback;
+    return f2 ? (d2 = b2.mode, f2 = b2.child, g2 = { mode: "hidden", children: g2 }, 0 === (d2 & 1) && null !== f2 ? (f2.childLanes = 0, f2.pendingProps = g2) : f2 = pj(g2, d2, 0, null), a2 = Tg(a2, d2, c2, null), f2.return = b2, a2.return = b2, f2.sibling = a2, b2.child = f2, b2.child.memoizedState = nj(c2), b2.memoizedState = mj, a2) : qj(b2, g2);
+  }
+  e2 = a2.memoizedState;
+  if (null !== e2 && (h2 = e2.dehydrated, null !== h2)) return rj(a2, b2, g2, d2, h2, e2, c2);
   if (f2) {
-    f2 = d.fallback;
-    g = b.mode;
-    e = a.child;
-    h = e.sibling;
-    var k2 = { mode: "hidden", children: d.children };
-    0 === (g & 1) && b.child !== e ? (d = b.child, d.childLanes = 0, d.pendingProps = k2, b.deletions = null) : (d = Pg(e, k2), d.subtreeFlags = e.subtreeFlags & 14680064);
-    null !== h ? f2 = Pg(h, f2) : (f2 = Tg(f2, g, c, null), f2.flags |= 2);
-    f2.return = b;
-    d.return = b;
-    d.sibling = f2;
-    b.child = d;
-    d = f2;
-    f2 = b.child;
-    g = a.child.memoizedState;
-    g = null === g ? nj(c) : { baseLanes: g.baseLanes | c, cachePool: null, transitions: g.transitions };
-    f2.memoizedState = g;
-    f2.childLanes = a.childLanes & ~c;
-    b.memoizedState = mj;
-    return d;
-  }
-  f2 = a.child;
-  a = f2.sibling;
-  d = Pg(f2, { mode: "visible", children: d.children });
-  0 === (b.mode & 1) && (d.lanes = c);
-  d.return = b;
-  d.sibling = null;
-  null !== a && (c = b.deletions, null === c ? (b.deletions = [a], b.flags |= 16) : c.push(a));
-  b.child = d;
-  b.memoizedState = null;
-  return d;
-}
-function qj(a, b) {
-  b = pj({ mode: "visible", children: b }, a.mode, 0, null);
-  b.return = a;
-  return a.child = b;
-}
-function sj(a, b, c, d) {
-  null !== d && Jg(d);
-  Ug(b, a.child, null, c);
-  a = qj(b, b.pendingProps.children);
-  a.flags |= 2;
-  b.memoizedState = null;
-  return a;
-}
-function rj(a, b, c, d, e, f2, g) {
-  if (c) {
-    if (b.flags & 256) return b.flags &= -257, d = Ki(Error(p(422))), sj(a, b, g, d);
-    if (null !== b.memoizedState) return b.child = a.child, b.flags |= 128, null;
-    f2 = d.fallback;
-    e = b.mode;
-    d = pj({ mode: "visible", children: d.children }, e, 0, null);
-    f2 = Tg(f2, e, g, null);
+    f2 = d2.fallback;
+    g2 = b2.mode;
+    e2 = a2.child;
+    h2 = e2.sibling;
+    var k2 = { mode: "hidden", children: d2.children };
+    0 === (g2 & 1) && b2.child !== e2 ? (d2 = b2.child, d2.childLanes = 0, d2.pendingProps = k2, b2.deletions = null) : (d2 = Pg(e2, k2), d2.subtreeFlags = e2.subtreeFlags & 14680064);
+    null !== h2 ? f2 = Pg(h2, f2) : (f2 = Tg(f2, g2, c2, null), f2.flags |= 2);
+    f2.return = b2;
+    d2.return = b2;
+    d2.sibling = f2;
+    b2.child = d2;
+    d2 = f2;
+    f2 = b2.child;
+    g2 = a2.child.memoizedState;
+    g2 = null === g2 ? nj(c2) : { baseLanes: g2.baseLanes | c2, cachePool: null, transitions: g2.transitions };
+    f2.memoizedState = g2;
+    f2.childLanes = a2.childLanes & ~c2;
+    b2.memoizedState = mj;
+    return d2;
+  }
+  f2 = a2.child;
+  a2 = f2.sibling;
+  d2 = Pg(f2, { mode: "visible", children: d2.children });
+  0 === (b2.mode & 1) && (d2.lanes = c2);
+  d2.return = b2;
+  d2.sibling = null;
+  null !== a2 && (c2 = b2.deletions, null === c2 ? (b2.deletions = [a2], b2.flags |= 16) : c2.push(a2));
+  b2.child = d2;
+  b2.memoizedState = null;
+  return d2;
+}
+function qj(a2, b2) {
+  b2 = pj({ mode: "visible", children: b2 }, a2.mode, 0, null);
+  b2.return = a2;
+  return a2.child = b2;
+}
+function sj(a2, b2, c2, d2) {
+  null !== d2 && Jg(d2);
+  Ug(b2, a2.child, null, c2);
+  a2 = qj(b2, b2.pendingProps.children);
+  a2.flags |= 2;
+  b2.memoizedState = null;
+  return a2;
+}
+function rj(a2, b2, c2, d2, e2, f2, g2) {
+  if (c2) {
+    if (b2.flags & 256) return b2.flags &= -257, d2 = Ki(Error(p$1(422))), sj(a2, b2, g2, d2);
+    if (null !== b2.memoizedState) return b2.child = a2.child, b2.flags |= 128, null;
+    f2 = d2.fallback;
+    e2 = b2.mode;
+    d2 = pj({ mode: "visible", children: d2.children }, e2, 0, null);
+    f2 = Tg(f2, e2, g2, null);
     f2.flags |= 2;
-    d.return = b;
-    f2.return = b;
-    d.sibling = f2;
-    b.child = d;
-    0 !== (b.mode & 1) && Ug(b, a.child, null, g);
-    b.child.memoizedState = nj(g);
-    b.memoizedState = mj;
+    d2.return = b2;
+    f2.return = b2;
+    d2.sibling = f2;
+    b2.child = d2;
+    0 !== (b2.mode & 1) && Ug(b2, a2.child, null, g2);
+    b2.child.memoizedState = nj(g2);
+    b2.memoizedState = mj;
     return f2;
   }
-  if (0 === (b.mode & 1)) return sj(a, b, g, null);
-  if ("$!" === e.data) {
-    d = e.nextSibling && e.nextSibling.dataset;
-    if (d) var h = d.dgst;
-    d = h;
-    f2 = Error(p(419));
-    d = Ki(f2, d, void 0);
-    return sj(a, b, g, d);
-  }
-  h = 0 !== (g & a.childLanes);
-  if (dh || h) {
-    d = Q;
-    if (null !== d) {
-      switch (g & -g) {
+  if (0 === (b2.mode & 1)) return sj(a2, b2, g2, null);
+  if ("$!" === e2.data) {
+    d2 = e2.nextSibling && e2.nextSibling.dataset;
+    if (d2) var h2 = d2.dgst;
+    d2 = h2;
+    f2 = Error(p$1(419));
+    d2 = Ki(f2, d2, void 0);
+    return sj(a2, b2, g2, d2);
+  }
+  h2 = 0 !== (g2 & a2.childLanes);
+  if (dh || h2) {
+    d2 = Q$1;
+    if (null !== d2) {
+      switch (g2 & -g2) {
         case 4:
-          e = 2;
+          e2 = 2;
           break;
         case 16:
-          e = 8;
+          e2 = 8;
           break;
         case 64:
         case 128:
@@ -4248,262 +4248,262 @@ function rj(a, b, c, d, e, f2, g) {
         case 16777216:
         case 33554432:
         case 67108864:
-          e = 32;
+          e2 = 32;
           break;
         case 536870912:
-          e = 268435456;
+          e2 = 268435456;
           break;
         default:
-          e = 0;
+          e2 = 0;
       }
-      e = 0 !== (e & (d.suspendedLanes | g)) ? 0 : e;
-      0 !== e && e !== f2.retryLane && (f2.retryLane = e, ih(a, e), gi(d, a, e, -1));
+      e2 = 0 !== (e2 & (d2.suspendedLanes | g2)) ? 0 : e2;
+      0 !== e2 && e2 !== f2.retryLane && (f2.retryLane = e2, ih(a2, e2), gi(d2, a2, e2, -1));
     }
     tj();
-    d = Ki(Error(p(421)));
-    return sj(a, b, g, d);
-  }
-  if ("$?" === e.data) return b.flags |= 128, b.child = a.child, b = uj.bind(null, a), e._reactRetry = b, null;
-  a = f2.treeContext;
-  yg = Lf(e.nextSibling);
-  xg = b;
-  I = true;
+    d2 = Ki(Error(p$1(421)));
+    return sj(a2, b2, g2, d2);
+  }
+  if ("$?" === e2.data) return b2.flags |= 128, b2.child = a2.child, b2 = uj.bind(null, a2), e2._reactRetry = b2, null;
+  a2 = f2.treeContext;
+  yg = Lf(e2.nextSibling);
+  xg = b2;
+  I$1 = true;
   zg = null;
-  null !== a && (og[pg++] = rg, og[pg++] = sg, og[pg++] = qg, rg = a.id, sg = a.overflow, qg = b);
-  b = qj(b, d.children);
-  b.flags |= 4096;
-  return b;
+  null !== a2 && (og[pg++] = rg, og[pg++] = sg, og[pg++] = qg, rg = a2.id, sg = a2.overflow, qg = b2);
+  b2 = qj(b2, d2.children);
+  b2.flags |= 4096;
+  return b2;
+}
+function vj(a2, b2, c2) {
+  a2.lanes |= b2;
+  var d2 = a2.alternate;
+  null !== d2 && (d2.lanes |= b2);
+  bh(a2.return, b2, c2);
+}
+function wj(a2, b2, c2, d2, e2) {
+  var f2 = a2.memoizedState;
+  null === f2 ? a2.memoizedState = { isBackwards: b2, rendering: null, renderingStartTime: 0, last: d2, tail: c2, tailMode: e2 } : (f2.isBackwards = b2, f2.rendering = null, f2.renderingStartTime = 0, f2.last = d2, f2.tail = c2, f2.tailMode = e2);
 }
-function vj(a, b, c) {
-  a.lanes |= b;
-  var d = a.alternate;
-  null !== d && (d.lanes |= b);
-  bh(a.return, b, c);
-}
-function wj(a, b, c, d, e) {
-  var f2 = a.memoizedState;
-  null === f2 ? a.memoizedState = { isBackwards: b, rendering: null, renderingStartTime: 0, last: d, tail: c, tailMode: e } : (f2.isBackwards = b, f2.rendering = null, f2.renderingStartTime = 0, f2.last = d, f2.tail = c, f2.tailMode = e);
-}
-function xj(a, b, c) {
-  var d = b.pendingProps, e = d.revealOrder, f2 = d.tail;
-  Xi(a, b, d.children, c);
-  d = L$2.current;
-  if (0 !== (d & 2)) d = d & 1 | 2, b.flags |= 128;
+function xj(a2, b2, c2) {
+  var d2 = b2.pendingProps, e2 = d2.revealOrder, f2 = d2.tail;
+  Xi(a2, b2, d2.children, c2);
+  d2 = L$1.current;
+  if (0 !== (d2 & 2)) d2 = d2 & 1 | 2, b2.flags |= 128;
   else {
-    if (null !== a && 0 !== (a.flags & 128)) a: for (a = b.child; null !== a; ) {
-      if (13 === a.tag) null !== a.memoizedState && vj(a, c, b);
-      else if (19 === a.tag) vj(a, c, b);
-      else if (null !== a.child) {
-        a.child.return = a;
-        a = a.child;
+    if (null !== a2 && 0 !== (a2.flags & 128)) a: for (a2 = b2.child; null !== a2; ) {
+      if (13 === a2.tag) null !== a2.memoizedState && vj(a2, c2, b2);
+      else if (19 === a2.tag) vj(a2, c2, b2);
+      else if (null !== a2.child) {
+        a2.child.return = a2;
+        a2 = a2.child;
         continue;
       }
-      if (a === b) break a;
-      for (; null === a.sibling; ) {
-        if (null === a.return || a.return === b) break a;
-        a = a.return;
+      if (a2 === b2) break a;
+      for (; null === a2.sibling; ) {
+        if (null === a2.return || a2.return === b2) break a;
+        a2 = a2.return;
       }
-      a.sibling.return = a.return;
-      a = a.sibling;
+      a2.sibling.return = a2.return;
+      a2 = a2.sibling;
     }
-    d &= 1;
+    d2 &= 1;
   }
-  G(L$2, d);
-  if (0 === (b.mode & 1)) b.memoizedState = null;
-  else switch (e) {
+  G$1(L$1, d2);
+  if (0 === (b2.mode & 1)) b2.memoizedState = null;
+  else switch (e2) {
     case "forwards":
-      c = b.child;
-      for (e = null; null !== c; ) a = c.alternate, null !== a && null === Ch(a) && (e = c), c = c.sibling;
-      c = e;
-      null === c ? (e = b.child, b.child = null) : (e = c.sibling, c.sibling = null);
-      wj(b, false, e, c, f2);
+      c2 = b2.child;
+      for (e2 = null; null !== c2; ) a2 = c2.alternate, null !== a2 && null === Ch(a2) && (e2 = c2), c2 = c2.sibling;
+      c2 = e2;
+      null === c2 ? (e2 = b2.child, b2.child = null) : (e2 = c2.sibling, c2.sibling = null);
+      wj(b2, false, e2, c2, f2);
       break;
     case "backwards":
-      c = null;
-      e = b.child;
-      for (b.child = null; null !== e; ) {
-        a = e.alternate;
-        if (null !== a && null === Ch(a)) {
-          b.child = e;
+      c2 = null;
+      e2 = b2.child;
+      for (b2.child = null; null !== e2; ) {
+        a2 = e2.alternate;
+        if (null !== a2 && null === Ch(a2)) {
+          b2.child = e2;
           break;
         }
-        a = e.sibling;
-        e.sibling = c;
-        c = e;
-        e = a;
+        a2 = e2.sibling;
+        e2.sibling = c2;
+        c2 = e2;
+        e2 = a2;
       }
-      wj(b, true, c, null, f2);
+      wj(b2, true, c2, null, f2);
       break;
     case "together":
-      wj(b, false, null, null, void 0);
+      wj(b2, false, null, null, void 0);
       break;
     default:
-      b.memoizedState = null;
+      b2.memoizedState = null;
   }
-  return b.child;
+  return b2.child;
 }
-function ij(a, b) {
-  0 === (b.mode & 1) && null !== a && (a.alternate = null, b.alternate = null, b.flags |= 2);
+function ij(a2, b2) {
+  0 === (b2.mode & 1) && null !== a2 && (a2.alternate = null, b2.alternate = null, b2.flags |= 2);
 }
-function Zi(a, b, c) {
-  null !== a && (b.dependencies = a.dependencies);
-  rh |= b.lanes;
-  if (0 === (c & b.childLanes)) return null;
-  if (null !== a && b.child !== a.child) throw Error(p(153));
-  if (null !== b.child) {
-    a = b.child;
-    c = Pg(a, a.pendingProps);
-    b.child = c;
-    for (c.return = b; null !== a.sibling; ) a = a.sibling, c = c.sibling = Pg(a, a.pendingProps), c.return = b;
-    c.sibling = null;
-  }
-  return b.child;
+function Zi(a2, b2, c2) {
+  null !== a2 && (b2.dependencies = a2.dependencies);
+  rh |= b2.lanes;
+  if (0 === (c2 & b2.childLanes)) return null;
+  if (null !== a2 && b2.child !== a2.child) throw Error(p$1(153));
+  if (null !== b2.child) {
+    a2 = b2.child;
+    c2 = Pg(a2, a2.pendingProps);
+    b2.child = c2;
+    for (c2.return = b2; null !== a2.sibling; ) a2 = a2.sibling, c2 = c2.sibling = Pg(a2, a2.pendingProps), c2.return = b2;
+    c2.sibling = null;
+  }
+  return b2.child;
 }
-function yj(a, b, c) {
-  switch (b.tag) {
+function yj(a2, b2, c2) {
+  switch (b2.tag) {
     case 3:
-      kj(b);
+      kj(b2);
       Ig();
       break;
     case 5:
-      Ah(b);
+      Ah(b2);
       break;
     case 1:
-      Zf(b.type) && cg(b);
+      Zf(b2.type) && cg(b2);
       break;
     case 4:
-      yh(b, b.stateNode.containerInfo);
+      yh(b2, b2.stateNode.containerInfo);
       break;
     case 10:
-      var d = b.type._context, e = b.memoizedProps.value;
-      G(Wg, d._currentValue);
-      d._currentValue = e;
+      var d2 = b2.type._context, e2 = b2.memoizedProps.value;
+      G$1(Wg, d2._currentValue);
+      d2._currentValue = e2;
       break;
     case 13:
-      d = b.memoizedState;
-      if (null !== d) {
-        if (null !== d.dehydrated) return G(L$2, L$2.current & 1), b.flags |= 128, null;
-        if (0 !== (c & b.child.childLanes)) return oj(a, b, c);
-        G(L$2, L$2.current & 1);
-        a = Zi(a, b, c);
-        return null !== a ? a.sibling : null;
-      }
-      G(L$2, L$2.current & 1);
+      d2 = b2.memoizedState;
+      if (null !== d2) {
+        if (null !== d2.dehydrated) return G$1(L$1, L$1.current & 1), b2.flags |= 128, null;
+        if (0 !== (c2 & b2.child.childLanes)) return oj(a2, b2, c2);
+        G$1(L$1, L$1.current & 1);
+        a2 = Zi(a2, b2, c2);
+        return null !== a2 ? a2.sibling : null;
+      }
+      G$1(L$1, L$1.current & 1);
       break;
     case 19:
-      d = 0 !== (c & b.childLanes);
-      if (0 !== (a.flags & 128)) {
-        if (d) return xj(a, b, c);
-        b.flags |= 128;
-      }
-      e = b.memoizedState;
-      null !== e && (e.rendering = null, e.tail = null, e.lastEffect = null);
-      G(L$2, L$2.current);
-      if (d) break;
+      d2 = 0 !== (c2 & b2.childLanes);
+      if (0 !== (a2.flags & 128)) {
+        if (d2) return xj(a2, b2, c2);
+        b2.flags |= 128;
+      }
+      e2 = b2.memoizedState;
+      null !== e2 && (e2.rendering = null, e2.tail = null, e2.lastEffect = null);
+      G$1(L$1, L$1.current);
+      if (d2) break;
       else return null;
     case 22:
     case 23:
-      return b.lanes = 0, dj(a, b, c);
+      return b2.lanes = 0, dj(a2, b2, c2);
   }
-  return Zi(a, b, c);
+  return Zi(a2, b2, c2);
 }
 var zj, Aj, Bj, Cj;
-zj = function(a, b) {
-  for (var c = b.child; null !== c; ) {
-    if (5 === c.tag || 6 === c.tag) a.appendChild(c.stateNode);
-    else if (4 !== c.tag && null !== c.child) {
-      c.child.return = c;
-      c = c.child;
+zj = function(a2, b2) {
+  for (var c2 = b2.child; null !== c2; ) {
+    if (5 === c2.tag || 6 === c2.tag) a2.appendChild(c2.stateNode);
+    else if (4 !== c2.tag && null !== c2.child) {
+      c2.child.return = c2;
+      c2 = c2.child;
       continue;
     }
-    if (c === b) break;
-    for (; null === c.sibling; ) {
-      if (null === c.return || c.return === b) return;
-      c = c.return;
+    if (c2 === b2) break;
+    for (; null === c2.sibling; ) {
+      if (null === c2.return || c2.return === b2) return;
+      c2 = c2.return;
     }
-    c.sibling.return = c.return;
-    c = c.sibling;
+    c2.sibling.return = c2.return;
+    c2 = c2.sibling;
   }
 };
 Aj = function() {
 };
-Bj = function(a, b, c, d) {
-  var e = a.memoizedProps;
-  if (e !== d) {
-    a = b.stateNode;
+Bj = function(a2, b2, c2, d2) {
+  var e2 = a2.memoizedProps;
+  if (e2 !== d2) {
+    a2 = b2.stateNode;
     xh(uh.current);
     var f2 = null;
-    switch (c) {
+    switch (c2) {
       case "input":
-        e = Ya(a, e);
-        d = Ya(a, d);
+        e2 = Ya(a2, e2);
+        d2 = Ya(a2, d2);
         f2 = [];
         break;
       case "select":
-        e = A({}, e, { value: void 0 });
-        d = A({}, d, { value: void 0 });
+        e2 = A$1({}, e2, { value: void 0 });
+        d2 = A$1({}, d2, { value: void 0 });
         f2 = [];
         break;
       case "textarea":
-        e = gb(a, e);
-        d = gb(a, d);
+        e2 = gb(a2, e2);
+        d2 = gb(a2, d2);
         f2 = [];
         break;
       default:
-        "function" !== typeof e.onClick && "function" === typeof d.onClick && (a.onclick = Bf);
-    }
-    ub(c, d);
-    var g;
-    c = null;
-    for (l2 in e) if (!d.hasOwnProperty(l2) && e.hasOwnProperty(l2) && null != e[l2]) if ("style" === l2) {
-      var h = e[l2];
-      for (g in h) h.hasOwnProperty(g) && (c || (c = {}), c[g] = "");
+        "function" !== typeof e2.onClick && "function" === typeof d2.onClick && (a2.onclick = Bf);
+    }
+    ub(c2, d2);
+    var g2;
+    c2 = null;
+    for (l2 in e2) if (!d2.hasOwnProperty(l2) && e2.hasOwnProperty(l2) && null != e2[l2]) if ("style" === l2) {
+      var h2 = e2[l2];
+      for (g2 in h2) h2.hasOwnProperty(g2) && (c2 || (c2 = {}), c2[g2] = "");
     } else "dangerouslySetInnerHTML" !== l2 && "children" !== l2 && "suppressContentEditableWarning" !== l2 && "suppressHydrationWarning" !== l2 && "autoFocus" !== l2 && (ea.hasOwnProperty(l2) ? f2 || (f2 = []) : (f2 = f2 || []).push(l2, null));
-    for (l2 in d) {
-      var k2 = d[l2];
-      h = null != e ? e[l2] : void 0;
-      if (d.hasOwnProperty(l2) && k2 !== h && (null != k2 || null != h)) if ("style" === l2) if (h) {
-        for (g in h) !h.hasOwnProperty(g) || k2 && k2.hasOwnProperty(g) || (c || (c = {}), c[g] = "");
-        for (g in k2) k2.hasOwnProperty(g) && h[g] !== k2[g] && (c || (c = {}), c[g] = k2[g]);
-      } else c || (f2 || (f2 = []), f2.push(
+    for (l2 in d2) {
+      var k2 = d2[l2];
+      h2 = null != e2 ? e2[l2] : void 0;
+      if (d2.hasOwnProperty(l2) && k2 !== h2 && (null != k2 || null != h2)) if ("style" === l2) if (h2) {
+        for (g2 in h2) !h2.hasOwnProperty(g2) || k2 && k2.hasOwnProperty(g2) || (c2 || (c2 = {}), c2[g2] = "");
+        for (g2 in k2) k2.hasOwnProperty(g2) && h2[g2] !== k2[g2] && (c2 || (c2 = {}), c2[g2] = k2[g2]);
+      } else c2 || (f2 || (f2 = []), f2.push(
         l2,
-        c
-      )), c = k2;
-      else "dangerouslySetInnerHTML" === l2 ? (k2 = k2 ? k2.__html : void 0, h = h ? h.__html : void 0, null != k2 && h !== k2 && (f2 = f2 || []).push(l2, k2)) : "children" === l2 ? "string" !== typeof k2 && "number" !== typeof k2 || (f2 = f2 || []).push(l2, "" + k2) : "suppressContentEditableWarning" !== l2 && "suppressHydrationWarning" !== l2 && (ea.hasOwnProperty(l2) ? (null != k2 && "onScroll" === l2 && D("scroll", a), f2 || h === k2 || (f2 = [])) : (f2 = f2 || []).push(l2, k2));
+        c2
+      )), c2 = k2;
+      else "dangerouslySetInnerHTML" === l2 ? (k2 = k2 ? k2.__html : void 0, h2 = h2 ? h2.__html : void 0, null != k2 && h2 !== k2 && (f2 = f2 || []).push(l2, k2)) : "children" === l2 ? "string" !== typeof k2 && "number" !== typeof k2 || (f2 = f2 || []).push(l2, "" + k2) : "suppressContentEditableWarning" !== l2 && "suppressHydrationWarning" !== l2 && (ea.hasOwnProperty(l2) ? (null != k2 && "onScroll" === l2 && D$1("scroll", a2), f2 || h2 === k2 || (f2 = [])) : (f2 = f2 || []).push(l2, k2));
     }
-    c && (f2 = f2 || []).push("style", c);
+    c2 && (f2 = f2 || []).push("style", c2);
     var l2 = f2;
-    if (b.updateQueue = l2) b.flags |= 4;
+    if (b2.updateQueue = l2) b2.flags |= 4;
   }
 };
-Cj = function(a, b, c, d) {
-  c !== d && (b.flags |= 4);
+Cj = function(a2, b2, c2, d2) {
+  c2 !== d2 && (b2.flags |= 4);
 };
-function Dj(a, b) {
-  if (!I) switch (a.tailMode) {
+function Dj(a2, b2) {
+  if (!I$1) switch (a2.tailMode) {
     case "hidden":
-      b = a.tail;
-      for (var c = null; null !== b; ) null !== b.alternate && (c = b), b = b.sibling;
-      null === c ? a.tail = null : c.sibling = null;
+      b2 = a2.tail;
+      for (var c2 = null; null !== b2; ) null !== b2.alternate && (c2 = b2), b2 = b2.sibling;
+      null === c2 ? a2.tail = null : c2.sibling = null;
       break;
     case "collapsed":
-      c = a.tail;
-      for (var d = null; null !== c; ) null !== c.alternate && (d = c), c = c.sibling;
-      null === d ? b || null === a.tail ? a.tail = null : a.tail.sibling = null : d.sibling = null;
+      c2 = a2.tail;
+      for (var d2 = null; null !== c2; ) null !== c2.alternate && (d2 = c2), c2 = c2.sibling;
+      null === d2 ? b2 || null === a2.tail ? a2.tail = null : a2.tail.sibling = null : d2.sibling = null;
   }
 }
-function S(a) {
-  var b = null !== a.alternate && a.alternate.child === a.child, c = 0, d = 0;
-  if (b) for (var e = a.child; null !== e; ) c |= e.lanes | e.childLanes, d |= e.subtreeFlags & 14680064, d |= e.flags & 14680064, e.return = a, e = e.sibling;
-  else for (e = a.child; null !== e; ) c |= e.lanes | e.childLanes, d |= e.subtreeFlags, d |= e.flags, e.return = a, e = e.sibling;
-  a.subtreeFlags |= d;
-  a.childLanes = c;
-  return b;
+function S$1(a2) {
+  var b2 = null !== a2.alternate && a2.alternate.child === a2.child, c2 = 0, d2 = 0;
+  if (b2) for (var e2 = a2.child; null !== e2; ) c2 |= e2.lanes | e2.childLanes, d2 |= e2.subtreeFlags & 14680064, d2 |= e2.flags & 14680064, e2.return = a2, e2 = e2.sibling;
+  else for (e2 = a2.child; null !== e2; ) c2 |= e2.lanes | e2.childLanes, d2 |= e2.subtreeFlags, d2 |= e2.flags, e2.return = a2, e2 = e2.sibling;
+  a2.subtreeFlags |= d2;
+  a2.childLanes = c2;
+  return b2;
 }
-function Ej(a, b, c) {
-  var d = b.pendingProps;
-  wg(b);
-  switch (b.tag) {
+function Ej(a2, b2, c2) {
+  var d2 = b2.pendingProps;
+  wg(b2);
+  switch (b2.tag) {
     case 2:
     case 16:
     case 15:
@@ -4514,346 +4514,346 @@ function Ej(a, b, c) {
     case 12:
     case 9:
     case 14:
-      return S(b), null;
+      return S$1(b2), null;
     case 1:
-      return Zf(b.type) && $f(), S(b), null;
+      return Zf(b2.type) && $f(), S$1(b2), null;
     case 3:
-      d = b.stateNode;
+      d2 = b2.stateNode;
       zh();
-      E(Wf);
-      E(H);
+      E$1(Wf);
+      E$1(H$1);
       Eh();
-      d.pendingContext && (d.context = d.pendingContext, d.pendingContext = null);
-      if (null === a || null === a.child) Gg(b) ? b.flags |= 4 : null === a || a.memoizedState.isDehydrated && 0 === (b.flags & 256) || (b.flags |= 1024, null !== zg && (Fj(zg), zg = null));
-      Aj(a, b);
-      S(b);
+      d2.pendingContext && (d2.context = d2.pendingContext, d2.pendingContext = null);
+      if (null === a2 || null === a2.child) Gg(b2) ? b2.flags |= 4 : null === a2 || a2.memoizedState.isDehydrated && 0 === (b2.flags & 256) || (b2.flags |= 1024, null !== zg && (Fj(zg), zg = null));
+      Aj(a2, b2);
+      S$1(b2);
       return null;
     case 5:
-      Bh(b);
-      var e = xh(wh.current);
-      c = b.type;
-      if (null !== a && null != b.stateNode) Bj(a, b, c, d, e), a.ref !== b.ref && (b.flags |= 512, b.flags |= 2097152);
+      Bh(b2);
+      var e2 = xh(wh.current);
+      c2 = b2.type;
+      if (null !== a2 && null != b2.stateNode) Bj(a2, b2, c2, d2, e2), a2.ref !== b2.ref && (b2.flags |= 512, b2.flags |= 2097152);
       else {
-        if (!d) {
-          if (null === b.stateNode) throw Error(p(166));
-          S(b);
+        if (!d2) {
+          if (null === b2.stateNode) throw Error(p$1(166));
+          S$1(b2);
           return null;
         }
-        a = xh(uh.current);
-        if (Gg(b)) {
-          d = b.stateNode;
-          c = b.type;
-          var f2 = b.memoizedProps;
-          d[Of] = b;
-          d[Pf] = f2;
-          a = 0 !== (b.mode & 1);
-          switch (c) {
+        a2 = xh(uh.current);
+        if (Gg(b2)) {
+          d2 = b2.stateNode;
+          c2 = b2.type;
+          var f2 = b2.memoizedProps;
+          d2[Of] = b2;
+          d2[Pf] = f2;
+          a2 = 0 !== (b2.mode & 1);
+          switch (c2) {
             case "dialog":
-              D("cancel", d);
-              D("close", d);
+              D$1("cancel", d2);
+              D$1("close", d2);
               break;
             case "iframe":
             case "object":
             case "embed":
-              D("load", d);
+              D$1("load", d2);
               break;
             case "video":
             case "audio":
-              for (e = 0; e < lf.length; e++) D(lf[e], d);
+              for (e2 = 0; e2 < lf.length; e2++) D$1(lf[e2], d2);
               break;
             case "source":
-              D("error", d);
+              D$1("error", d2);
               break;
             case "img":
             case "image":
             case "link":
-              D(
+              D$1(
                 "error",
-                d
+                d2
               );
-              D("load", d);
+              D$1("load", d2);
               break;
             case "details":
-              D("toggle", d);
+              D$1("toggle", d2);
               break;
             case "input":
-              Za(d, f2);
-              D("invalid", d);
+              Za(d2, f2);
+              D$1("invalid", d2);
               break;
             case "select":
-              d._wrapperState = { wasMultiple: !!f2.multiple };
-              D("invalid", d);
+              d2._wrapperState = { wasMultiple: !!f2.multiple };
+              D$1("invalid", d2);
               break;
             case "textarea":
-              hb(d, f2), D("invalid", d);
-          }
-          ub(c, f2);
-          e = null;
-          for (var g in f2) if (f2.hasOwnProperty(g)) {
-            var h = f2[g];
-            "children" === g ? "string" === typeof h ? d.textContent !== h && (true !== f2.suppressHydrationWarning && Af(d.textContent, h, a), e = ["children", h]) : "number" === typeof h && d.textContent !== "" + h && (true !== f2.suppressHydrationWarning && Af(
-              d.textContent,
-              h,
-              a
-            ), e = ["children", "" + h]) : ea.hasOwnProperty(g) && null != h && "onScroll" === g && D("scroll", d);
-          }
-          switch (c) {
+              hb(d2, f2), D$1("invalid", d2);
+          }
+          ub(c2, f2);
+          e2 = null;
+          for (var g2 in f2) if (f2.hasOwnProperty(g2)) {
+            var h2 = f2[g2];
+            "children" === g2 ? "string" === typeof h2 ? d2.textContent !== h2 && (true !== f2.suppressHydrationWarning && Af(d2.textContent, h2, a2), e2 = ["children", h2]) : "number" === typeof h2 && d2.textContent !== "" + h2 && (true !== f2.suppressHydrationWarning && Af(
+              d2.textContent,
+              h2,
+              a2
+            ), e2 = ["children", "" + h2]) : ea.hasOwnProperty(g2) && null != h2 && "onScroll" === g2 && D$1("scroll", d2);
+          }
+          switch (c2) {
             case "input":
-              Va(d);
-              db(d, f2, true);
+              Va(d2);
+              db(d2, f2, true);
               break;
             case "textarea":
-              Va(d);
-              jb(d);
+              Va(d2);
+              jb(d2);
               break;
             case "select":
             case "option":
               break;
             default:
-              "function" === typeof f2.onClick && (d.onclick = Bf);
+              "function" === typeof f2.onClick && (d2.onclick = Bf);
           }
-          d = e;
-          b.updateQueue = d;
-          null !== d && (b.flags |= 4);
+          d2 = e2;
+          b2.updateQueue = d2;
+          null !== d2 && (b2.flags |= 4);
         } else {
-          g = 9 === e.nodeType ? e : e.ownerDocument;
-          "http://www.w3.org/1999/xhtml" === a && (a = kb(c));
-          "http://www.w3.org/1999/xhtml" === a ? "script" === c ? (a = g.createElement("div"), a.innerHTML = "<script><\/script>", a = a.removeChild(a.firstChild)) : "string" === typeof d.is ? a = g.createElement(c, { is: d.is }) : (a = g.createElement(c), "select" === c && (g = a, d.multiple ? g.multiple = true : d.size && (g.size = d.size))) : a = g.createElementNS(a, c);
-          a[Of] = b;
-          a[Pf] = d;
-          zj(a, b, false, false);
-          b.stateNode = a;
+          g2 = 9 === e2.nodeType ? e2 : e2.ownerDocument;
+          "http://www.w3.org/1999/xhtml" === a2 && (a2 = kb(c2));
+          "http://www.w3.org/1999/xhtml" === a2 ? "script" === c2 ? (a2 = g2.createElement("div"), a2.innerHTML = "<script><\/script>", a2 = a2.removeChild(a2.firstChild)) : "string" === typeof d2.is ? a2 = g2.createElement(c2, { is: d2.is }) : (a2 = g2.createElement(c2), "select" === c2 && (g2 = a2, d2.multiple ? g2.multiple = true : d2.size && (g2.size = d2.size))) : a2 = g2.createElementNS(a2, c2);
+          a2[Of] = b2;
+          a2[Pf] = d2;
+          zj(a2, b2, false, false);
+          b2.stateNode = a2;
           a: {
-            g = vb(c, d);
-            switch (c) {
+            g2 = vb(c2, d2);
+            switch (c2) {
               case "dialog":
-                D("cancel", a);
-                D("close", a);
-                e = d;
+                D$1("cancel", a2);
+                D$1("close", a2);
+                e2 = d2;
                 break;
               case "iframe":
               case "object":
               case "embed":
-                D("load", a);
-                e = d;
+                D$1("load", a2);
+                e2 = d2;
                 break;
               case "video":
               case "audio":
-                for (e = 0; e < lf.length; e++) D(lf[e], a);
-                e = d;
+                for (e2 = 0; e2 < lf.length; e2++) D$1(lf[e2], a2);
+                e2 = d2;
                 break;
               case "source":
-                D("error", a);
-                e = d;
+                D$1("error", a2);
+                e2 = d2;
                 break;
               case "img":
               case "image":
               case "link":
-                D(
+                D$1(
                   "error",
-                  a
+                  a2
                 );
-                D("load", a);
-                e = d;
+                D$1("load", a2);
+                e2 = d2;
                 break;
               case "details":
-                D("toggle", a);
-                e = d;
+                D$1("toggle", a2);
+                e2 = d2;
                 break;
               case "input":
-                Za(a, d);
-                e = Ya(a, d);
-                D("invalid", a);
+                Za(a2, d2);
+                e2 = Ya(a2, d2);
+                D$1("invalid", a2);
                 break;
               case "option":
-                e = d;
+                e2 = d2;
                 break;
               case "select":
-                a._wrapperState = { wasMultiple: !!d.multiple };
-                e = A({}, d, { value: void 0 });
-                D("invalid", a);
+                a2._wrapperState = { wasMultiple: !!d2.multiple };
+                e2 = A$1({}, d2, { value: void 0 });
+                D$1("invalid", a2);
                 break;
               case "textarea":
-                hb(a, d);
-                e = gb(a, d);
-                D("invalid", a);
+                hb(a2, d2);
+                e2 = gb(a2, d2);
+                D$1("invalid", a2);
                 break;
               default:
-                e = d;
+                e2 = d2;
             }
-            ub(c, e);
-            h = e;
-            for (f2 in h) if (h.hasOwnProperty(f2)) {
-              var k2 = h[f2];
-              "style" === f2 ? sb(a, k2) : "dangerouslySetInnerHTML" === f2 ? (k2 = k2 ? k2.__html : void 0, null != k2 && nb(a, k2)) : "children" === f2 ? "string" === typeof k2 ? ("textarea" !== c || "" !== k2) && ob(a, k2) : "number" === typeof k2 && ob(a, "" + k2) : "suppressContentEditableWarning" !== f2 && "suppressHydrationWarning" !== f2 && "autoFocus" !== f2 && (ea.hasOwnProperty(f2) ? null != k2 && "onScroll" === f2 && D("scroll", a) : null != k2 && ta(a, f2, k2, g));
+            ub(c2, e2);
+            h2 = e2;
+            for (f2 in h2) if (h2.hasOwnProperty(f2)) {
+              var k2 = h2[f2];
+              "style" === f2 ? sb(a2, k2) : "dangerouslySetInnerHTML" === f2 ? (k2 = k2 ? k2.__html : void 0, null != k2 && nb(a2, k2)) : "children" === f2 ? "string" === typeof k2 ? ("textarea" !== c2 || "" !== k2) && ob(a2, k2) : "number" === typeof k2 && ob(a2, "" + k2) : "suppressContentEditableWarning" !== f2 && "suppressHydrationWarning" !== f2 && "autoFocus" !== f2 && (ea.hasOwnProperty(f2) ? null != k2 && "onScroll" === f2 && D$1("scroll", a2) : null != k2 && ta(a2, f2, k2, g2));
             }
-            switch (c) {
+            switch (c2) {
               case "input":
-                Va(a);
-                db(a, d, false);
+                Va(a2);
+                db(a2, d2, false);
                 break;
               case "textarea":
-                Va(a);
-                jb(a);
+                Va(a2);
+                jb(a2);
                 break;
               case "option":
-                null != d.value && a.setAttribute("value", "" + Sa(d.value));
+                null != d2.value && a2.setAttribute("value", "" + Sa(d2.value));
                 break;
               case "select":
-                a.multiple = !!d.multiple;
-                f2 = d.value;
-                null != f2 ? fb(a, !!d.multiple, f2, false) : null != d.defaultValue && fb(
-                  a,
-                  !!d.multiple,
-                  d.defaultValue,
+                a2.multiple = !!d2.multiple;
+                f2 = d2.value;
+                null != f2 ? fb(a2, !!d2.multiple, f2, false) : null != d2.defaultValue && fb(
+                  a2,
+                  !!d2.multiple,
+                  d2.defaultValue,
                   true
                 );
                 break;
               default:
-                "function" === typeof e.onClick && (a.onclick = Bf);
+                "function" === typeof e2.onClick && (a2.onclick = Bf);
             }
-            switch (c) {
+            switch (c2) {
               case "button":
               case "input":
               case "select":
               case "textarea":
-                d = !!d.autoFocus;
+                d2 = !!d2.autoFocus;
                 break a;
               case "img":
-                d = true;
+                d2 = true;
                 break a;
               default:
-                d = false;
+                d2 = false;
             }
           }
-          d && (b.flags |= 4);
+          d2 && (b2.flags |= 4);
         }
-        null !== b.ref && (b.flags |= 512, b.flags |= 2097152);
+        null !== b2.ref && (b2.flags |= 512, b2.flags |= 2097152);
       }
-      S(b);
+      S$1(b2);
       return null;
     case 6:
-      if (a && null != b.stateNode) Cj(a, b, a.memoizedProps, d);
+      if (a2 && null != b2.stateNode) Cj(a2, b2, a2.memoizedProps, d2);
       else {
-        if ("string" !== typeof d && null === b.stateNode) throw Error(p(166));
-        c = xh(wh.current);
+        if ("string" !== typeof d2 && null === b2.stateNode) throw Error(p$1(166));
+        c2 = xh(wh.current);
         xh(uh.current);
-        if (Gg(b)) {
-          d = b.stateNode;
-          c = b.memoizedProps;
-          d[Of] = b;
-          if (f2 = d.nodeValue !== c) {
-            if (a = xg, null !== a) switch (a.tag) {
+        if (Gg(b2)) {
+          d2 = b2.stateNode;
+          c2 = b2.memoizedProps;
+          d2[Of] = b2;
+          if (f2 = d2.nodeValue !== c2) {
+            if (a2 = xg, null !== a2) switch (a2.tag) {
               case 3:
-                Af(d.nodeValue, c, 0 !== (a.mode & 1));
+                Af(d2.nodeValue, c2, 0 !== (a2.mode & 1));
                 break;
               case 5:
-                true !== a.memoizedProps.suppressHydrationWarning && Af(d.nodeValue, c, 0 !== (a.mode & 1));
+                true !== a2.memoizedProps.suppressHydrationWarning && Af(d2.nodeValue, c2, 0 !== (a2.mode & 1));
             }
           }
-          f2 && (b.flags |= 4);
-        } else d = (9 === c.nodeType ? c : c.ownerDocument).createTextNode(d), d[Of] = b, b.stateNode = d;
+          f2 && (b2.flags |= 4);
+        } else d2 = (9 === c2.nodeType ? c2 : c2.ownerDocument).createTextNode(d2), d2[Of] = b2, b2.stateNode = d2;
       }
-      S(b);
+      S$1(b2);
       return null;
     case 13:
-      E(L$2);
-      d = b.memoizedState;
-      if (null === a || null !== a.memoizedState && null !== a.memoizedState.dehydrated) {
-        if (I && null !== yg && 0 !== (b.mode & 1) && 0 === (b.flags & 128)) Hg(), Ig(), b.flags |= 98560, f2 = false;
-        else if (f2 = Gg(b), null !== d && null !== d.dehydrated) {
-          if (null === a) {
-            if (!f2) throw Error(p(318));
-            f2 = b.memoizedState;
+      E$1(L$1);
+      d2 = b2.memoizedState;
+      if (null === a2 || null !== a2.memoizedState && null !== a2.memoizedState.dehydrated) {
+        if (I$1 && null !== yg && 0 !== (b2.mode & 1) && 0 === (b2.flags & 128)) Hg(), Ig(), b2.flags |= 98560, f2 = false;
+        else if (f2 = Gg(b2), null !== d2 && null !== d2.dehydrated) {
+          if (null === a2) {
+            if (!f2) throw Error(p$1(318));
+            f2 = b2.memoizedState;
             f2 = null !== f2 ? f2.dehydrated : null;
-            if (!f2) throw Error(p(317));
-            f2[Of] = b;
-          } else Ig(), 0 === (b.flags & 128) && (b.memoizedState = null), b.flags |= 4;
-          S(b);
+            if (!f2) throw Error(p$1(317));
+            f2[Of] = b2;
+          } else Ig(), 0 === (b2.flags & 128) && (b2.memoizedState = null), b2.flags |= 4;
+          S$1(b2);
           f2 = false;
         } else null !== zg && (Fj(zg), zg = null), f2 = true;
-        if (!f2) return b.flags & 65536 ? b : null;
+        if (!f2) return b2.flags & 65536 ? b2 : null;
       }
-      if (0 !== (b.flags & 128)) return b.lanes = c, b;
-      d = null !== d;
-      d !== (null !== a && null !== a.memoizedState) && d && (b.child.flags |= 8192, 0 !== (b.mode & 1) && (null === a || 0 !== (L$2.current & 1) ? 0 === T && (T = 3) : tj()));
-      null !== b.updateQueue && (b.flags |= 4);
-      S(b);
+      if (0 !== (b2.flags & 128)) return b2.lanes = c2, b2;
+      d2 = null !== d2;
+      d2 !== (null !== a2 && null !== a2.memoizedState) && d2 && (b2.child.flags |= 8192, 0 !== (b2.mode & 1) && (null === a2 || 0 !== (L$1.current & 1) ? 0 === T$1 && (T$1 = 3) : tj()));
+      null !== b2.updateQueue && (b2.flags |= 4);
+      S$1(b2);
       return null;
     case 4:
-      return zh(), Aj(a, b), null === a && sf(b.stateNode.containerInfo), S(b), null;
+      return zh(), Aj(a2, b2), null === a2 && sf(b2.stateNode.containerInfo), S$1(b2), null;
     case 10:
-      return ah(b.type._context), S(b), null;
+      return ah(b2.type._context), S$1(b2), null;
     case 17:
-      return Zf(b.type) && $f(), S(b), null;
+      return Zf(b2.type) && $f(), S$1(b2), null;
     case 19:
-      E(L$2);
-      f2 = b.memoizedState;
-      if (null === f2) return S(b), null;
-      d = 0 !== (b.flags & 128);
-      g = f2.rendering;
-      if (null === g) if (d) Dj(f2, false);
+      E$1(L$1);
+      f2 = b2.memoizedState;
+      if (null === f2) return S$1(b2), null;
+      d2 = 0 !== (b2.flags & 128);
+      g2 = f2.rendering;
+      if (null === g2) if (d2) Dj(f2, false);
       else {
-        if (0 !== T || null !== a && 0 !== (a.flags & 128)) for (a = b.child; null !== a; ) {
-          g = Ch(a);
-          if (null !== g) {
-            b.flags |= 128;
+        if (0 !== T$1 || null !== a2 && 0 !== (a2.flags & 128)) for (a2 = b2.child; null !== a2; ) {
+          g2 = Ch(a2);
+          if (null !== g2) {
+            b2.flags |= 128;
             Dj(f2, false);
-            d = g.updateQueue;
-            null !== d && (b.updateQueue = d, b.flags |= 4);
-            b.subtreeFlags = 0;
-            d = c;
-            for (c = b.child; null !== c; ) f2 = c, a = d, f2.flags &= 14680066, g = f2.alternate, null === g ? (f2.childLanes = 0, f2.lanes = a, f2.child = null, f2.subtreeFlags = 0, f2.memoizedProps = null, f2.memoizedState = null, f2.updateQueue = null, f2.dependencies = null, f2.stateNode = null) : (f2.childLanes = g.childLanes, f2.lanes = g.lanes, f2.child = g.child, f2.subtreeFlags = 0, f2.deletions = null, f2.memoizedProps = g.memoizedProps, f2.memoizedState = g.memoizedState, f2.updateQueue = g.updateQueue, f2.type = g.type, a = g.dependencies, f2.dependencies = null === a ? null : { lanes: a.lanes, firstContext: a.firstContext }), c = c.sibling;
-            G(L$2, L$2.current & 1 | 2);
-            return b.child;
+            d2 = g2.updateQueue;
+            null !== d2 && (b2.updateQueue = d2, b2.flags |= 4);
+            b2.subtreeFlags = 0;
+            d2 = c2;
+            for (c2 = b2.child; null !== c2; ) f2 = c2, a2 = d2, f2.flags &= 14680066, g2 = f2.alternate, null === g2 ? (f2.childLanes = 0, f2.lanes = a2, f2.child = null, f2.subtreeFlags = 0, f2.memoizedProps = null, f2.memoizedState = null, f2.updateQueue = null, f2.dependencies = null, f2.stateNode = null) : (f2.childLanes = g2.childLanes, f2.lanes = g2.lanes, f2.child = g2.child, f2.subtreeFlags = 0, f2.deletions = null, f2.memoizedProps = g2.memoizedProps, f2.memoizedState = g2.memoizedState, f2.updateQueue = g2.updateQueue, f2.type = g2.type, a2 = g2.dependencies, f2.dependencies = null === a2 ? null : { lanes: a2.lanes, firstContext: a2.firstContext }), c2 = c2.sibling;
+            G$1(L$1, L$1.current & 1 | 2);
+            return b2.child;
           }
-          a = a.sibling;
+          a2 = a2.sibling;
         }
-        null !== f2.tail && B() > Gj && (b.flags |= 128, d = true, Dj(f2, false), b.lanes = 4194304);
+        null !== f2.tail && B$1() > Gj && (b2.flags |= 128, d2 = true, Dj(f2, false), b2.lanes = 4194304);
       }
       else {
-        if (!d) if (a = Ch(g), null !== a) {
-          if (b.flags |= 128, d = true, c = a.updateQueue, null !== c && (b.updateQueue = c, b.flags |= 4), Dj(f2, true), null === f2.tail && "hidden" === f2.tailMode && !g.alternate && !I) return S(b), null;
-        } else 2 * B() - f2.renderingStartTime > Gj && 1073741824 !== c && (b.flags |= 128, d = true, Dj(f2, false), b.lanes = 4194304);
-        f2.isBackwards ? (g.sibling = b.child, b.child = g) : (c = f2.last, null !== c ? c.sibling = g : b.child = g, f2.last = g);
+        if (!d2) if (a2 = Ch(g2), null !== a2) {
+          if (b2.flags |= 128, d2 = true, c2 = a2.updateQueue, null !== c2 && (b2.updateQueue = c2, b2.flags |= 4), Dj(f2, true), null === f2.tail && "hidden" === f2.tailMode && !g2.alternate && !I$1) return S$1(b2), null;
+        } else 2 * B$1() - f2.renderingStartTime > Gj && 1073741824 !== c2 && (b2.flags |= 128, d2 = true, Dj(f2, false), b2.lanes = 4194304);
+        f2.isBackwards ? (g2.sibling = b2.child, b2.child = g2) : (c2 = f2.last, null !== c2 ? c2.sibling = g2 : b2.child = g2, f2.last = g2);
       }
-      if (null !== f2.tail) return b = f2.tail, f2.rendering = b, f2.tail = b.sibling, f2.renderingStartTime = B(), b.sibling = null, c = L$2.current, G(L$2, d ? c & 1 | 2 : c & 1), b;
-      S(b);
+      if (null !== f2.tail) return b2 = f2.tail, f2.rendering = b2, f2.tail = b2.sibling, f2.renderingStartTime = B$1(), b2.sibling = null, c2 = L$1.current, G$1(L$1, d2 ? c2 & 1 | 2 : c2 & 1), b2;
+      S$1(b2);
       return null;
     case 22:
     case 23:
-      return Hj(), d = null !== b.memoizedState, null !== a && null !== a.memoizedState !== d && (b.flags |= 8192), d && 0 !== (b.mode & 1) ? 0 !== (fj & 1073741824) && (S(b), b.subtreeFlags & 6 && (b.flags |= 8192)) : S(b), null;
+      return Hj(), d2 = null !== b2.memoizedState, null !== a2 && null !== a2.memoizedState !== d2 && (b2.flags |= 8192), d2 && 0 !== (b2.mode & 1) ? 0 !== (fj & 1073741824) && (S$1(b2), b2.subtreeFlags & 6 && (b2.flags |= 8192)) : S$1(b2), null;
     case 24:
       return null;
     case 25:
       return null;
   }
-  throw Error(p(156, b.tag));
+  throw Error(p$1(156, b2.tag));
 }
-function Ij(a, b) {
-  wg(b);
-  switch (b.tag) {
+function Ij(a2, b2) {
+  wg(b2);
+  switch (b2.tag) {
     case 1:
-      return Zf(b.type) && $f(), a = b.flags, a & 65536 ? (b.flags = a & -65537 | 128, b) : null;
+      return Zf(b2.type) && $f(), a2 = b2.flags, a2 & 65536 ? (b2.flags = a2 & -65537 | 128, b2) : null;
     case 3:
-      return zh(), E(Wf), E(H), Eh(), a = b.flags, 0 !== (a & 65536) && 0 === (a & 128) ? (b.flags = a & -65537 | 128, b) : null;
+      return zh(), E$1(Wf), E$1(H$1), Eh(), a2 = b2.flags, 0 !== (a2 & 65536) && 0 === (a2 & 128) ? (b2.flags = a2 & -65537 | 128, b2) : null;
     case 5:
-      return Bh(b), null;
+      return Bh(b2), null;
     case 13:
-      E(L$2);
-      a = b.memoizedState;
-      if (null !== a && null !== a.dehydrated) {
-        if (null === b.alternate) throw Error(p(340));
+      E$1(L$1);
+      a2 = b2.memoizedState;
+      if (null !== a2 && null !== a2.dehydrated) {
+        if (null === b2.alternate) throw Error(p$1(340));
         Ig();
       }
-      a = b.flags;
-      return a & 65536 ? (b.flags = a & -65537 | 128, b) : null;
+      a2 = b2.flags;
+      return a2 & 65536 ? (b2.flags = a2 & -65537 | 128, b2) : null;
     case 19:
-      return E(L$2), null;
+      return E$1(L$1), null;
     case 4:
       return zh(), null;
     case 10:
-      return ah(b.type._context), null;
+      return ah(b2.type._context), null;
     case 22:
     case 23:
       return Hj(), null;
@@ -4863,87 +4863,87 @@ function Ij(a, b) {
       return null;
   }
 }
-var Jj = false, U = false, Kj = "function" === typeof WeakSet ? WeakSet : Set, V = null;
-function Lj(a, b) {
-  var c = a.ref;
-  if (null !== c) if ("function" === typeof c) try {
-    c(null);
-  } catch (d) {
-    W(a, b, d);
-  }
-  else c.current = null;
+var Jj = false, U$1 = false, Kj = "function" === typeof WeakSet ? WeakSet : Set, V$1 = null;
+function Lj(a2, b2) {
+  var c2 = a2.ref;
+  if (null !== c2) if ("function" === typeof c2) try {
+    c2(null);
+  } catch (d2) {
+    W$1(a2, b2, d2);
+  }
+  else c2.current = null;
 }
-function Mj(a, b, c) {
+function Mj(a2, b2, c2) {
   try {
-    c();
-  } catch (d) {
-    W(a, b, d);
+    c2();
+  } catch (d2) {
+    W$1(a2, b2, d2);
   }
 }
 var Nj = false;
-function Oj(a, b) {
+function Oj(a2, b2) {
   Cf = dd;
-  a = Me();
-  if (Ne(a)) {
-    if ("selectionStart" in a) var c = { start: a.selectionStart, end: a.selectionEnd };
+  a2 = Me$1();
+  if (Ne$1(a2)) {
+    if ("selectionStart" in a2) var c2 = { start: a2.selectionStart, end: a2.selectionEnd };
     else a: {
-      c = (c = a.ownerDocument) && c.defaultView || window;
-      var d = c.getSelection && c.getSelection();
-      if (d && 0 !== d.rangeCount) {
-        c = d.anchorNode;
-        var e = d.anchorOffset, f2 = d.focusNode;
-        d = d.focusOffset;
+      c2 = (c2 = a2.ownerDocument) && c2.defaultView || window;
+      var d2 = c2.getSelection && c2.getSelection();
+      if (d2 && 0 !== d2.rangeCount) {
+        c2 = d2.anchorNode;
+        var e2 = d2.anchorOffset, f2 = d2.focusNode;
+        d2 = d2.focusOffset;
         try {
-          c.nodeType, f2.nodeType;
+          c2.nodeType, f2.nodeType;
         } catch (F2) {
-          c = null;
+          c2 = null;
           break a;
         }
-        var g = 0, h = -1, k2 = -1, l2 = 0, m2 = 0, q2 = a, r2 = null;
+        var g2 = 0, h2 = -1, k2 = -1, l2 = 0, m2 = 0, q2 = a2, r2 = null;
         b: for (; ; ) {
           for (var y2; ; ) {
-            q2 !== c || 0 !== e && 3 !== q2.nodeType || (h = g + e);
-            q2 !== f2 || 0 !== d && 3 !== q2.nodeType || (k2 = g + d);
-            3 === q2.nodeType && (g += q2.nodeValue.length);
+            q2 !== c2 || 0 !== e2 && 3 !== q2.nodeType || (h2 = g2 + e2);
+            q2 !== f2 || 0 !== d2 && 3 !== q2.nodeType || (k2 = g2 + d2);
+            3 === q2.nodeType && (g2 += q2.nodeValue.length);
             if (null === (y2 = q2.firstChild)) break;
             r2 = q2;
             q2 = y2;
           }
           for (; ; ) {
-            if (q2 === a) break b;
-            r2 === c && ++l2 === e && (h = g);
-            r2 === f2 && ++m2 === d && (k2 = g);
+            if (q2 === a2) break b;
+            r2 === c2 && ++l2 === e2 && (h2 = g2);
+            r2 === f2 && ++m2 === d2 && (k2 = g2);
             if (null !== (y2 = q2.nextSibling)) break;
             q2 = r2;
             r2 = q2.parentNode;
           }
           q2 = y2;
         }
-        c = -1 === h || -1 === k2 ? null : { start: h, end: k2 };
-      } else c = null;
+        c2 = -1 === h2 || -1 === k2 ? null : { start: h2, end: k2 };
+      } else c2 = null;
     }
-    c = c || { start: 0, end: 0 };
-  } else c = null;
-  Df = { focusedElem: a, selectionRange: c };
+    c2 = c2 || { start: 0, end: 0 };
+  } else c2 = null;
+  Df = { focusedElem: a2, selectionRange: c2 };
   dd = false;
-  for (V = b; null !== V; ) if (b = V, a = b.child, 0 !== (b.subtreeFlags & 1028) && null !== a) a.return = b, V = a;
-  else for (; null !== V; ) {
-    b = V;
+  for (V$1 = b2; null !== V$1; ) if (b2 = V$1, a2 = b2.child, 0 !== (b2.subtreeFlags & 1028) && null !== a2) a2.return = b2, V$1 = a2;
+  else for (; null !== V$1; ) {
+    b2 = V$1;
     try {
-      var n2 = b.alternate;
-      if (0 !== (b.flags & 1024)) switch (b.tag) {
+      var n2 = b2.alternate;
+      if (0 !== (b2.flags & 1024)) switch (b2.tag) {
         case 0:
         case 11:
         case 15:
           break;
         case 1:
           if (null !== n2) {
-            var t2 = n2.memoizedProps, J2 = n2.memoizedState, x2 = b.stateNode, w2 = x2.getSnapshotBeforeUpdate(b.elementType === b.type ? t2 : Ci(b.type, t2), J2);
+            var t2 = n2.memoizedProps, J2 = n2.memoizedState, x2 = b2.stateNode, w2 = x2.getSnapshotBeforeUpdate(b2.elementType === b2.type ? t2 : Ci(b2.type, t2), J2);
             x2.__reactInternalSnapshotBeforeUpdate = w2;
           }
           break;
         case 3:
-          var u2 = b.stateNode.containerInfo;
+          var u2 = b2.stateNode.containerInfo;
           1 === u2.nodeType ? u2.textContent = "" : 9 === u2.nodeType && u2.documentElement && u2.removeChild(u2.documentElement);
           break;
         case 5:
@@ -4952,340 +4952,340 @@ function Oj(a, b) {
         case 17:
           break;
         default:
-          throw Error(p(163));
+          throw Error(p$1(163));
       }
     } catch (F2) {
-      W(b, b.return, F2);
+      W$1(b2, b2.return, F2);
     }
-    a = b.sibling;
-    if (null !== a) {
-      a.return = b.return;
-      V = a;
+    a2 = b2.sibling;
+    if (null !== a2) {
+      a2.return = b2.return;
+      V$1 = a2;
       break;
     }
-    V = b.return;
+    V$1 = b2.return;
   }
   n2 = Nj;
   Nj = false;
   return n2;
 }
-function Pj(a, b, c) {
-  var d = b.updateQueue;
-  d = null !== d ? d.lastEffect : null;
-  if (null !== d) {
-    var e = d = d.next;
+function Pj(a2, b2, c2) {
+  var d2 = b2.updateQueue;
+  d2 = null !== d2 ? d2.lastEffect : null;
+  if (null !== d2) {
+    var e2 = d2 = d2.next;
     do {
-      if ((e.tag & a) === a) {
-        var f2 = e.destroy;
-        e.destroy = void 0;
-        void 0 !== f2 && Mj(b, c, f2);
+      if ((e2.tag & a2) === a2) {
+        var f2 = e2.destroy;
+        e2.destroy = void 0;
+        void 0 !== f2 && Mj(b2, c2, f2);
       }
-      e = e.next;
-    } while (e !== d);
+      e2 = e2.next;
+    } while (e2 !== d2);
   }
 }
-function Qj(a, b) {
-  b = b.updateQueue;
-  b = null !== b ? b.lastEffect : null;
-  if (null !== b) {
-    var c = b = b.next;
+function Qj(a2, b2) {
+  b2 = b2.updateQueue;
+  b2 = null !== b2 ? b2.lastEffect : null;
+  if (null !== b2) {
+    var c2 = b2 = b2.next;
     do {
-      if ((c.tag & a) === a) {
-        var d = c.create;
-        c.destroy = d();
+      if ((c2.tag & a2) === a2) {
+        var d2 = c2.create;
+        c2.destroy = d2();
       }
-      c = c.next;
-    } while (c !== b);
+      c2 = c2.next;
+    } while (c2 !== b2);
   }
 }
-function Rj(a) {
-  var b = a.ref;
-  if (null !== b) {
-    var c = a.stateNode;
-    switch (a.tag) {
+function Rj(a2) {
+  var b2 = a2.ref;
+  if (null !== b2) {
+    var c2 = a2.stateNode;
+    switch (a2.tag) {
       case 5:
-        a = c;
+        a2 = c2;
         break;
       default:
-        a = c;
-    }
-    "function" === typeof b ? b(a) : b.current = a;
-  }
-}
-function Sj(a) {
-  var b = a.alternate;
-  null !== b && (a.alternate = null, Sj(b));
-  a.child = null;
-  a.deletions = null;
-  a.sibling = null;
-  5 === a.tag && (b = a.stateNode, null !== b && (delete b[Of], delete b[Pf], delete b[of], delete b[Qf], delete b[Rf]));
-  a.stateNode = null;
-  a.return = null;
-  a.dependencies = null;
-  a.memoizedProps = null;
-  a.memoizedState = null;
-  a.pendingProps = null;
-  a.stateNode = null;
-  a.updateQueue = null;
-}
-function Tj(a) {
-  return 5 === a.tag || 3 === a.tag || 4 === a.tag;
-}
-function Uj(a) {
+        a2 = c2;
+    }
+    "function" === typeof b2 ? b2(a2) : b2.current = a2;
+  }
+}
+function Sj(a2) {
+  var b2 = a2.alternate;
+  null !== b2 && (a2.alternate = null, Sj(b2));
+  a2.child = null;
+  a2.deletions = null;
+  a2.sibling = null;
+  5 === a2.tag && (b2 = a2.stateNode, null !== b2 && (delete b2[Of], delete b2[Pf], delete b2[of], delete b2[Qf], delete b2[Rf]));
+  a2.stateNode = null;
+  a2.return = null;
+  a2.dependencies = null;
+  a2.memoizedProps = null;
+  a2.memoizedState = null;
+  a2.pendingProps = null;
+  a2.stateNode = null;
+  a2.updateQueue = null;
+}
+function Tj(a2) {
+  return 5 === a2.tag || 3 === a2.tag || 4 === a2.tag;
+}
+function Uj(a2) {
   a: for (; ; ) {
-    for (; null === a.sibling; ) {
-      if (null === a.return || Tj(a.return)) return null;
-      a = a.return;
+    for (; null === a2.sibling; ) {
+      if (null === a2.return || Tj(a2.return)) return null;
+      a2 = a2.return;
     }
-    a.sibling.return = a.return;
-    for (a = a.sibling; 5 !== a.tag && 6 !== a.tag && 18 !== a.tag; ) {
-      if (a.flags & 2) continue a;
-      if (null === a.child || 4 === a.tag) continue a;
-      else a.child.return = a, a = a.child;
+    a2.sibling.return = a2.return;
+    for (a2 = a2.sibling; 5 !== a2.tag && 6 !== a2.tag && 18 !== a2.tag; ) {
+      if (a2.flags & 2) continue a;
+      if (null === a2.child || 4 === a2.tag) continue a;
+      else a2.child.return = a2, a2 = a2.child;
     }
-    if (!(a.flags & 2)) return a.stateNode;
+    if (!(a2.flags & 2)) return a2.stateNode;
   }
 }
-function Vj(a, b, c) {
-  var d = a.tag;
-  if (5 === d || 6 === d) a = a.stateNode, b ? 8 === c.nodeType ? c.parentNode.insertBefore(a, b) : c.insertBefore(a, b) : (8 === c.nodeType ? (b = c.parentNode, b.insertBefore(a, c)) : (b = c, b.appendChild(a)), c = c._reactRootContainer, null !== c && void 0 !== c || null !== b.onclick || (b.onclick = Bf));
-  else if (4 !== d && (a = a.child, null !== a)) for (Vj(a, b, c), a = a.sibling; null !== a; ) Vj(a, b, c), a = a.sibling;
+function Vj(a2, b2, c2) {
+  var d2 = a2.tag;
+  if (5 === d2 || 6 === d2) a2 = a2.stateNode, b2 ? 8 === c2.nodeType ? c2.parentNode.insertBefore(a2, b2) : c2.insertBefore(a2, b2) : (8 === c2.nodeType ? (b2 = c2.parentNode, b2.insertBefore(a2, c2)) : (b2 = c2, b2.appendChild(a2)), c2 = c2._reactRootContainer, null !== c2 && void 0 !== c2 || null !== b2.onclick || (b2.onclick = Bf));
+  else if (4 !== d2 && (a2 = a2.child, null !== a2)) for (Vj(a2, b2, c2), a2 = a2.sibling; null !== a2; ) Vj(a2, b2, c2), a2 = a2.sibling;
 }
-function Wj(a, b, c) {
-  var d = a.tag;
-  if (5 === d || 6 === d) a = a.stateNode, b ? c.insertBefore(a, b) : c.appendChild(a);
-  else if (4 !== d && (a = a.child, null !== a)) for (Wj(a, b, c), a = a.sibling; null !== a; ) Wj(a, b, c), a = a.sibling;
+function Wj(a2, b2, c2) {
+  var d2 = a2.tag;
+  if (5 === d2 || 6 === d2) a2 = a2.stateNode, b2 ? c2.insertBefore(a2, b2) : c2.appendChild(a2);
+  else if (4 !== d2 && (a2 = a2.child, null !== a2)) for (Wj(a2, b2, c2), a2 = a2.sibling; null !== a2; ) Wj(a2, b2, c2), a2 = a2.sibling;
 }
-var X = null, Xj = false;
-function Yj(a, b, c) {
-  for (c = c.child; null !== c; ) Zj(a, b, c), c = c.sibling;
+var X$1 = null, Xj = false;
+function Yj(a2, b2, c2) {
+  for (c2 = c2.child; null !== c2; ) Zj(a2, b2, c2), c2 = c2.sibling;
 }
-function Zj(a, b, c) {
+function Zj(a2, b2, c2) {
   if (lc && "function" === typeof lc.onCommitFiberUnmount) try {
-    lc.onCommitFiberUnmount(kc, c);
-  } catch (h) {
+    lc.onCommitFiberUnmount(kc, c2);
+  } catch (h2) {
   }
-  switch (c.tag) {
+  switch (c2.tag) {
     case 5:
-      U || Lj(c, b);
+      U$1 || Lj(c2, b2);
     case 6:
-      var d = X, e = Xj;
-      X = null;
-      Yj(a, b, c);
-      X = d;
-      Xj = e;
-      null !== X && (Xj ? (a = X, c = c.stateNode, 8 === a.nodeType ? a.parentNode.removeChild(c) : a.removeChild(c)) : X.removeChild(c.stateNode));
+      var d2 = X$1, e2 = Xj;
+      X$1 = null;
+      Yj(a2, b2, c2);
+      X$1 = d2;
+      Xj = e2;
+      null !== X$1 && (Xj ? (a2 = X$1, c2 = c2.stateNode, 8 === a2.nodeType ? a2.parentNode.removeChild(c2) : a2.removeChild(c2)) : X$1.removeChild(c2.stateNode));
       break;
     case 18:
-      null !== X && (Xj ? (a = X, c = c.stateNode, 8 === a.nodeType ? Kf(a.parentNode, c) : 1 === a.nodeType && Kf(a, c), bd(a)) : Kf(X, c.stateNode));
+      null !== X$1 && (Xj ? (a2 = X$1, c2 = c2.stateNode, 8 === a2.nodeType ? Kf(a2.parentNode, c2) : 1 === a2.nodeType && Kf(a2, c2), bd(a2)) : Kf(X$1, c2.stateNode));
       break;
     case 4:
-      d = X;
-      e = Xj;
-      X = c.stateNode.containerInfo;
+      d2 = X$1;
+      e2 = Xj;
+      X$1 = c2.stateNode.containerInfo;
       Xj = true;
-      Yj(a, b, c);
-      X = d;
-      Xj = e;
+      Yj(a2, b2, c2);
+      X$1 = d2;
+      Xj = e2;
       break;
     case 0:
     case 11:
     case 14:
     case 15:
-      if (!U && (d = c.updateQueue, null !== d && (d = d.lastEffect, null !== d))) {
-        e = d = d.next;
+      if (!U$1 && (d2 = c2.updateQueue, null !== d2 && (d2 = d2.lastEffect, null !== d2))) {
+        e2 = d2 = d2.next;
         do {
-          var f2 = e, g = f2.destroy;
+          var f2 = e2, g2 = f2.destroy;
           f2 = f2.tag;
-          void 0 !== g && (0 !== (f2 & 2) ? Mj(c, b, g) : 0 !== (f2 & 4) && Mj(c, b, g));
-          e = e.next;
-        } while (e !== d);
+          void 0 !== g2 && (0 !== (f2 & 2) ? Mj(c2, b2, g2) : 0 !== (f2 & 4) && Mj(c2, b2, g2));
+          e2 = e2.next;
+        } while (e2 !== d2);
       }
-      Yj(a, b, c);
+      Yj(a2, b2, c2);
       break;
     case 1:
-      if (!U && (Lj(c, b), d = c.stateNode, "function" === typeof d.componentWillUnmount)) try {
-        d.props = c.memoizedProps, d.state = c.memoizedState, d.componentWillUnmount();
-      } catch (h) {
-        W(c, b, h);
+      if (!U$1 && (Lj(c2, b2), d2 = c2.stateNode, "function" === typeof d2.componentWillUnmount)) try {
+        d2.props = c2.memoizedProps, d2.state = c2.memoizedState, d2.componentWillUnmount();
+      } catch (h2) {
+        W$1(c2, b2, h2);
       }
-      Yj(a, b, c);
+      Yj(a2, b2, c2);
       break;
     case 21:
-      Yj(a, b, c);
+      Yj(a2, b2, c2);
       break;
     case 22:
-      c.mode & 1 ? (U = (d = U) || null !== c.memoizedState, Yj(a, b, c), U = d) : Yj(a, b, c);
+      c2.mode & 1 ? (U$1 = (d2 = U$1) || null !== c2.memoizedState, Yj(a2, b2, c2), U$1 = d2) : Yj(a2, b2, c2);
       break;
     default:
-      Yj(a, b, c);
-  }
-}
-function ak(a) {
-  var b = a.updateQueue;
-  if (null !== b) {
-    a.updateQueue = null;
-    var c = a.stateNode;
-    null === c && (c = a.stateNode = new Kj());
-    b.forEach(function(b2) {
-      var d = bk.bind(null, a, b2);
-      c.has(b2) || (c.add(b2), b2.then(d, d));
+      Yj(a2, b2, c2);
+  }
+}
+function ak(a2) {
+  var b2 = a2.updateQueue;
+  if (null !== b2) {
+    a2.updateQueue = null;
+    var c2 = a2.stateNode;
+    null === c2 && (c2 = a2.stateNode = new Kj());
+    b2.forEach(function(b3) {
+      var d2 = bk.bind(null, a2, b3);
+      c2.has(b3) || (c2.add(b3), b3.then(d2, d2));
     });
   }
 }
-function ck(a, b) {
-  var c = b.deletions;
-  if (null !== c) for (var d = 0; d < c.length; d++) {
-    var e = c[d];
+function ck(a2, b2) {
+  var c2 = b2.deletions;
+  if (null !== c2) for (var d2 = 0; d2 < c2.length; d2++) {
+    var e2 = c2[d2];
     try {
-      var f2 = a, g = b, h = g;
-      a: for (; null !== h; ) {
-        switch (h.tag) {
+      var f2 = a2, g2 = b2, h2 = g2;
+      a: for (; null !== h2; ) {
+        switch (h2.tag) {
           case 5:
-            X = h.stateNode;
+            X$1 = h2.stateNode;
             Xj = false;
             break a;
           case 3:
-            X = h.stateNode.containerInfo;
+            X$1 = h2.stateNode.containerInfo;
             Xj = true;
             break a;
           case 4:
-            X = h.stateNode.containerInfo;
+            X$1 = h2.stateNode.containerInfo;
             Xj = true;
             break a;
         }
-        h = h.return;
+        h2 = h2.return;
       }
-      if (null === X) throw Error(p(160));
-      Zj(f2, g, e);
-      X = null;
+      if (null === X$1) throw Error(p$1(160));
+      Zj(f2, g2, e2);
+      X$1 = null;
       Xj = false;
-      var k2 = e.alternate;
+      var k2 = e2.alternate;
       null !== k2 && (k2.return = null);
-      e.return = null;
+      e2.return = null;
     } catch (l2) {
-      W(e, b, l2);
+      W$1(e2, b2, l2);
     }
   }
-  if (b.subtreeFlags & 12854) for (b = b.child; null !== b; ) dk(b, a), b = b.sibling;
+  if (b2.subtreeFlags & 12854) for (b2 = b2.child; null !== b2; ) dk(b2, a2), b2 = b2.sibling;
 }
-function dk(a, b) {
-  var c = a.alternate, d = a.flags;
-  switch (a.tag) {
+function dk(a2, b2) {
+  var c2 = a2.alternate, d2 = a2.flags;
+  switch (a2.tag) {
     case 0:
     case 11:
     case 14:
     case 15:
-      ck(b, a);
-      ek(a);
-      if (d & 4) {
+      ck(b2, a2);
+      ek(a2);
+      if (d2 & 4) {
         try {
-          Pj(3, a, a.return), Qj(3, a);
+          Pj(3, a2, a2.return), Qj(3, a2);
         } catch (t2) {
-          W(a, a.return, t2);
+          W$1(a2, a2.return, t2);
         }
         try {
-          Pj(5, a, a.return);
+          Pj(5, a2, a2.return);
         } catch (t2) {
-          W(a, a.return, t2);
+          W$1(a2, a2.return, t2);
         }
       }
       break;
     case 1:
-      ck(b, a);
-      ek(a);
-      d & 512 && null !== c && Lj(c, c.return);
+      ck(b2, a2);
+      ek(a2);
+      d2 & 512 && null !== c2 && Lj(c2, c2.return);
       break;
     case 5:
-      ck(b, a);
-      ek(a);
-      d & 512 && null !== c && Lj(c, c.return);
-      if (a.flags & 32) {
-        var e = a.stateNode;
+      ck(b2, a2);
+      ek(a2);
+      d2 & 512 && null !== c2 && Lj(c2, c2.return);
+      if (a2.flags & 32) {
+        var e2 = a2.stateNode;
         try {
-          ob(e, "");
+          ob(e2, "");
         } catch (t2) {
-          W(a, a.return, t2);
+          W$1(a2, a2.return, t2);
         }
       }
-      if (d & 4 && (e = a.stateNode, null != e)) {
-        var f2 = a.memoizedProps, g = null !== c ? c.memoizedProps : f2, h = a.type, k2 = a.updateQueue;
-        a.updateQueue = null;
+      if (d2 & 4 && (e2 = a2.stateNode, null != e2)) {
+        var f2 = a2.memoizedProps, g2 = null !== c2 ? c2.memoizedProps : f2, h2 = a2.type, k2 = a2.updateQueue;
+        a2.updateQueue = null;
         if (null !== k2) try {
-          "input" === h && "radio" === f2.type && null != f2.name && ab(e, f2);
-          vb(h, g);
-          var l2 = vb(h, f2);
-          for (g = 0; g < k2.length; g += 2) {
-            var m2 = k2[g], q2 = k2[g + 1];
-            "style" === m2 ? sb(e, q2) : "dangerouslySetInnerHTML" === m2 ? nb(e, q2) : "children" === m2 ? ob(e, q2) : ta(e, m2, q2, l2);
-          }
-          switch (h) {
+          "input" === h2 && "radio" === f2.type && null != f2.name && ab(e2, f2);
+          vb(h2, g2);
+          var l2 = vb(h2, f2);
+          for (g2 = 0; g2 < k2.length; g2 += 2) {
+            var m2 = k2[g2], q2 = k2[g2 + 1];
+            "style" === m2 ? sb(e2, q2) : "dangerouslySetInnerHTML" === m2 ? nb(e2, q2) : "children" === m2 ? ob(e2, q2) : ta(e2, m2, q2, l2);
+          }
+          switch (h2) {
             case "input":
-              bb(e, f2);
+              bb(e2, f2);
               break;
             case "textarea":
-              ib(e, f2);
+              ib(e2, f2);
               break;
             case "select":
-              var r2 = e._wrapperState.wasMultiple;
-              e._wrapperState.wasMultiple = !!f2.multiple;
+              var r2 = e2._wrapperState.wasMultiple;
+              e2._wrapperState.wasMultiple = !!f2.multiple;
               var y2 = f2.value;
-              null != y2 ? fb(e, !!f2.multiple, y2, false) : r2 !== !!f2.multiple && (null != f2.defaultValue ? fb(
-                e,
+              null != y2 ? fb(e2, !!f2.multiple, y2, false) : r2 !== !!f2.multiple && (null != f2.defaultValue ? fb(
+                e2,
                 !!f2.multiple,
                 f2.defaultValue,
                 true
-              ) : fb(e, !!f2.multiple, f2.multiple ? [] : "", false));
+              ) : fb(e2, !!f2.multiple, f2.multiple ? [] : "", false));
           }
-          e[Pf] = f2;
+          e2[Pf] = f2;
         } catch (t2) {
-          W(a, a.return, t2);
+          W$1(a2, a2.return, t2);
         }
       }
       break;
     case 6:
-      ck(b, a);
-      ek(a);
-      if (d & 4) {
-        if (null === a.stateNode) throw Error(p(162));
-        e = a.stateNode;
-        f2 = a.memoizedProps;
+      ck(b2, a2);
+      ek(a2);
+      if (d2 & 4) {
+        if (null === a2.stateNode) throw Error(p$1(162));
+        e2 = a2.stateNode;
+        f2 = a2.memoizedProps;
         try {
-          e.nodeValue = f2;
+          e2.nodeValue = f2;
         } catch (t2) {
-          W(a, a.return, t2);
+          W$1(a2, a2.return, t2);
         }
       }
       break;
     case 3:
-      ck(b, a);
-      ek(a);
-      if (d & 4 && null !== c && c.memoizedState.isDehydrated) try {
-        bd(b.containerInfo);
+      ck(b2, a2);
+      ek(a2);
+      if (d2 & 4 && null !== c2 && c2.memoizedState.isDehydrated) try {
+        bd(b2.containerInfo);
       } catch (t2) {
-        W(a, a.return, t2);
+        W$1(a2, a2.return, t2);
       }
       break;
     case 4:
-      ck(b, a);
-      ek(a);
+      ck(b2, a2);
+      ek(a2);
       break;
     case 13:
-      ck(b, a);
-      ek(a);
-      e = a.child;
-      e.flags & 8192 && (f2 = null !== e.memoizedState, e.stateNode.isHidden = f2, !f2 || null !== e.alternate && null !== e.alternate.memoizedState || (fk = B()));
-      d & 4 && ak(a);
+      ck(b2, a2);
+      ek(a2);
+      e2 = a2.child;
+      e2.flags & 8192 && (f2 = null !== e2.memoizedState, e2.stateNode.isHidden = f2, !f2 || null !== e2.alternate && null !== e2.alternate.memoizedState || (fk = B$1()));
+      d2 & 4 && ak(a2);
       break;
     case 22:
-      m2 = null !== c && null !== c.memoizedState;
-      a.mode & 1 ? (U = (l2 = U) || m2, ck(b, a), U = l2) : ck(b, a);
-      ek(a);
-      if (d & 8192) {
-        l2 = null !== a.memoizedState;
-        if ((a.stateNode.isHidden = l2) && !m2 && 0 !== (a.mode & 1)) for (V = a, m2 = a.child; null !== m2; ) {
-          for (q2 = V = m2; null !== V; ) {
-            r2 = V;
+      m2 = null !== c2 && null !== c2.memoizedState;
+      a2.mode & 1 ? (U$1 = (l2 = U$1) || m2, ck(b2, a2), U$1 = l2) : ck(b2, a2);
+      ek(a2);
+      if (d2 & 8192) {
+        l2 = null !== a2.memoizedState;
+        if ((a2.stateNode.isHidden = l2) && !m2 && 0 !== (a2.mode & 1)) for (V$1 = a2, m2 = a2.child; null !== m2; ) {
+          for (q2 = V$1 = m2; null !== V$1; ) {
+            r2 = V$1;
             y2 = r2.child;
             switch (r2.tag) {
               case 0:
@@ -5298,12 +5298,12 @@ function dk(a, b) {
                 Lj(r2, r2.return);
                 var n2 = r2.stateNode;
                 if ("function" === typeof n2.componentWillUnmount) {
-                  d = r2;
-                  c = r2.return;
+                  d2 = r2;
+                  c2 = r2.return;
                   try {
-                    b = d, n2.props = b.memoizedProps, n2.state = b.memoizedState, n2.componentWillUnmount();
+                    b2 = d2, n2.props = b2.memoizedProps, n2.state = b2.memoizedState, n2.componentWillUnmount();
                   } catch (t2) {
-                    W(d, c, t2);
+                    W$1(d2, c2, t2);
                   }
                 }
                 break;
@@ -5316,34 +5316,34 @@ function dk(a, b) {
                   continue;
                 }
             }
-            null !== y2 ? (y2.return = r2, V = y2) : gk(q2);
+            null !== y2 ? (y2.return = r2, V$1 = y2) : gk(q2);
           }
           m2 = m2.sibling;
         }
-        a: for (m2 = null, q2 = a; ; ) {
+        a: for (m2 = null, q2 = a2; ; ) {
           if (5 === q2.tag) {
             if (null === m2) {
               m2 = q2;
               try {
-                e = q2.stateNode, l2 ? (f2 = e.style, "function" === typeof f2.setProperty ? f2.setProperty("display", "none", "important") : f2.display = "none") : (h = q2.stateNode, k2 = q2.memoizedProps.style, g = void 0 !== k2 && null !== k2 && k2.hasOwnProperty("display") ? k2.display : null, h.style.display = rb("display", g));
+                e2 = q2.stateNode, l2 ? (f2 = e2.style, "function" === typeof f2.setProperty ? f2.setProperty("display", "none", "important") : f2.display = "none") : (h2 = q2.stateNode, k2 = q2.memoizedProps.style, g2 = void 0 !== k2 && null !== k2 && k2.hasOwnProperty("display") ? k2.display : null, h2.style.display = rb("display", g2));
               } catch (t2) {
-                W(a, a.return, t2);
+                W$1(a2, a2.return, t2);
               }
             }
           } else if (6 === q2.tag) {
             if (null === m2) try {
               q2.stateNode.nodeValue = l2 ? "" : q2.memoizedProps;
             } catch (t2) {
-              W(a, a.return, t2);
+              W$1(a2, a2.return, t2);
             }
-          } else if ((22 !== q2.tag && 23 !== q2.tag || null === q2.memoizedState || q2 === a) && null !== q2.child) {
+          } else if ((22 !== q2.tag && 23 !== q2.tag || null === q2.memoizedState || q2 === a2) && null !== q2.child) {
             q2.child.return = q2;
             q2 = q2.child;
             continue;
           }
-          if (q2 === a) break a;
+          if (q2 === a2) break a;
           for (; null === q2.sibling; ) {
-            if (null === q2.return || q2.return === a) break a;
+            if (null === q2.return || q2.return === a2) break a;
             m2 === q2 && (m2 = null);
             q2 = q2.return;
           }
@@ -5354,129 +5354,129 @@ function dk(a, b) {
       }
       break;
     case 19:
-      ck(b, a);
-      ek(a);
-      d & 4 && ak(a);
+      ck(b2, a2);
+      ek(a2);
+      d2 & 4 && ak(a2);
       break;
     case 21:
       break;
     default:
       ck(
-        b,
-        a
-      ), ek(a);
+        b2,
+        a2
+      ), ek(a2);
   }
 }
-function ek(a) {
-  var b = a.flags;
-  if (b & 2) {
+function ek(a2) {
+  var b2 = a2.flags;
+  if (b2 & 2) {
     try {
       a: {
-        for (var c = a.return; null !== c; ) {
-          if (Tj(c)) {
-            var d = c;
+        for (var c2 = a2.return; null !== c2; ) {
+          if (Tj(c2)) {
+            var d2 = c2;
             break a;
           }
-          c = c.return;
+          c2 = c2.return;
         }
-        throw Error(p(160));
+        throw Error(p$1(160));
       }
-      switch (d.tag) {
+      switch (d2.tag) {
         case 5:
-          var e = d.stateNode;
-          d.flags & 32 && (ob(e, ""), d.flags &= -33);
-          var f2 = Uj(a);
-          Wj(a, f2, e);
+          var e2 = d2.stateNode;
+          d2.flags & 32 && (ob(e2, ""), d2.flags &= -33);
+          var f2 = Uj(a2);
+          Wj(a2, f2, e2);
           break;
         case 3:
         case 4:
-          var g = d.stateNode.containerInfo, h = Uj(a);
-          Vj(a, h, g);
+          var g2 = d2.stateNode.containerInfo, h2 = Uj(a2);
+          Vj(a2, h2, g2);
           break;
         default:
-          throw Error(p(161));
+          throw Error(p$1(161));
       }
     } catch (k2) {
-      W(a, a.return, k2);
-    }
-    a.flags &= -3;
-  }
-  b & 4096 && (a.flags &= -4097);
-}
-function hk(a, b, c) {
-  V = a;
-  ik(a);
-}
-function ik(a, b, c) {
-  for (var d = 0 !== (a.mode & 1); null !== V; ) {
-    var e = V, f2 = e.child;
-    if (22 === e.tag && d) {
-      var g = null !== e.memoizedState || Jj;
-      if (!g) {
-        var h = e.alternate, k2 = null !== h && null !== h.memoizedState || U;
-        h = Jj;
-        var l2 = U;
-        Jj = g;
-        if ((U = k2) && !l2) for (V = e; null !== V; ) g = V, k2 = g.child, 22 === g.tag && null !== g.memoizedState ? jk(e) : null !== k2 ? (k2.return = g, V = k2) : jk(e);
-        for (; null !== f2; ) V = f2, ik(f2), f2 = f2.sibling;
-        V = e;
-        Jj = h;
-        U = l2;
-      }
-      kk(a);
-    } else 0 !== (e.subtreeFlags & 8772) && null !== f2 ? (f2.return = e, V = f2) : kk(a);
-  }
-}
-function kk(a) {
-  for (; null !== V; ) {
-    var b = V;
-    if (0 !== (b.flags & 8772)) {
-      var c = b.alternate;
+      W$1(a2, a2.return, k2);
+    }
+    a2.flags &= -3;
+  }
+  b2 & 4096 && (a2.flags &= -4097);
+}
+function hk(a2, b2, c2) {
+  V$1 = a2;
+  ik(a2);
+}
+function ik(a2, b2, c2) {
+  for (var d2 = 0 !== (a2.mode & 1); null !== V$1; ) {
+    var e2 = V$1, f2 = e2.child;
+    if (22 === e2.tag && d2) {
+      var g2 = null !== e2.memoizedState || Jj;
+      if (!g2) {
+        var h2 = e2.alternate, k2 = null !== h2 && null !== h2.memoizedState || U$1;
+        h2 = Jj;
+        var l2 = U$1;
+        Jj = g2;
+        if ((U$1 = k2) && !l2) for (V$1 = e2; null !== V$1; ) g2 = V$1, k2 = g2.child, 22 === g2.tag && null !== g2.memoizedState ? jk(e2) : null !== k2 ? (k2.return = g2, V$1 = k2) : jk(e2);
+        for (; null !== f2; ) V$1 = f2, ik(f2), f2 = f2.sibling;
+        V$1 = e2;
+        Jj = h2;
+        U$1 = l2;
+      }
+      kk(a2);
+    } else 0 !== (e2.subtreeFlags & 8772) && null !== f2 ? (f2.return = e2, V$1 = f2) : kk(a2);
+  }
+}
+function kk(a2) {
+  for (; null !== V$1; ) {
+    var b2 = V$1;
+    if (0 !== (b2.flags & 8772)) {
+      var c2 = b2.alternate;
       try {
-        if (0 !== (b.flags & 8772)) switch (b.tag) {
+        if (0 !== (b2.flags & 8772)) switch (b2.tag) {
           case 0:
           case 11:
           case 15:
-            U || Qj(5, b);
+            U$1 || Qj(5, b2);
             break;
           case 1:
-            var d = b.stateNode;
-            if (b.flags & 4 && !U) if (null === c) d.componentDidMount();
+            var d2 = b2.stateNode;
+            if (b2.flags & 4 && !U$1) if (null === c2) d2.componentDidMount();
             else {
-              var e = b.elementType === b.type ? c.memoizedProps : Ci(b.type, c.memoizedProps);
-              d.componentDidUpdate(e, c.memoizedState, d.__reactInternalSnapshotBeforeUpdate);
+              var e2 = b2.elementType === b2.type ? c2.memoizedProps : Ci(b2.type, c2.memoizedProps);
+              d2.componentDidUpdate(e2, c2.memoizedState, d2.__reactInternalSnapshotBeforeUpdate);
             }
-            var f2 = b.updateQueue;
-            null !== f2 && sh(b, f2, d);
+            var f2 = b2.updateQueue;
+            null !== f2 && sh(b2, f2, d2);
             break;
           case 3:
-            var g = b.updateQueue;
-            if (null !== g) {
-              c = null;
-              if (null !== b.child) switch (b.child.tag) {
+            var g2 = b2.updateQueue;
+            if (null !== g2) {
+              c2 = null;
+              if (null !== b2.child) switch (b2.child.tag) {
                 case 5:
-                  c = b.child.stateNode;
+                  c2 = b2.child.stateNode;
                   break;
                 case 1:
-                  c = b.child.stateNode;
+                  c2 = b2.child.stateNode;
               }
-              sh(b, g, c);
+              sh(b2, g2, c2);
             }
             break;
           case 5:
-            var h = b.stateNode;
-            if (null === c && b.flags & 4) {
-              c = h;
-              var k2 = b.memoizedProps;
-              switch (b.type) {
+            var h2 = b2.stateNode;
+            if (null === c2 && b2.flags & 4) {
+              c2 = h2;
+              var k2 = b2.memoizedProps;
+              switch (b2.type) {
                 case "button":
                 case "input":
                 case "select":
                 case "textarea":
-                  k2.autoFocus && c.focus();
+                  k2.autoFocus && c2.focus();
                   break;
                 case "img":
-                  k2.src && (c.src = k2.src);
+                  k2.src && (c2.src = k2.src);
               }
             }
             break;
@@ -5487,8 +5487,8 @@ function kk(a) {
           case 12:
             break;
           case 13:
-            if (null === b.memoizedState) {
-              var l2 = b.alternate;
+            if (null === b2.memoizedState) {
+              var l2 = b2.alternate;
               if (null !== l2) {
                 var m2 = l2.memoizedState;
                 if (null !== m2) {
@@ -5506,480 +5506,480 @@ function kk(a) {
           case 25:
             break;
           default:
-            throw Error(p(163));
+            throw Error(p$1(163));
         }
-        U || b.flags & 512 && Rj(b);
+        U$1 || b2.flags & 512 && Rj(b2);
       } catch (r2) {
-        W(b, b.return, r2);
+        W$1(b2, b2.return, r2);
       }
     }
-    if (b === a) {
-      V = null;
+    if (b2 === a2) {
+      V$1 = null;
       break;
     }
-    c = b.sibling;
-    if (null !== c) {
-      c.return = b.return;
-      V = c;
+    c2 = b2.sibling;
+    if (null !== c2) {
+      c2.return = b2.return;
+      V$1 = c2;
       break;
     }
-    V = b.return;
+    V$1 = b2.return;
   }
 }
-function gk(a) {
-  for (; null !== V; ) {
-    var b = V;
-    if (b === a) {
-      V = null;
+function gk(a2) {
+  for (; null !== V$1; ) {
+    var b2 = V$1;
+    if (b2 === a2) {
+      V$1 = null;
       break;
     }
-    var c = b.sibling;
-    if (null !== c) {
-      c.return = b.return;
-      V = c;
+    var c2 = b2.sibling;
+    if (null !== c2) {
+      c2.return = b2.return;
+      V$1 = c2;
       break;
     }
-    V = b.return;
+    V$1 = b2.return;
   }
 }
-function jk(a) {
-  for (; null !== V; ) {
-    var b = V;
+function jk(a2) {
+  for (; null !== V$1; ) {
+    var b2 = V$1;
     try {
-      switch (b.tag) {
+      switch (b2.tag) {
         case 0:
         case 11:
         case 15:
-          var c = b.return;
+          var c2 = b2.return;
           try {
-            Qj(4, b);
+            Qj(4, b2);
           } catch (k2) {
-            W(b, c, k2);
+            W$1(b2, c2, k2);
           }
           break;
         case 1:
-          var d = b.stateNode;
-          if ("function" === typeof d.componentDidMount) {
-            var e = b.return;
+          var d2 = b2.stateNode;
+          if ("function" === typeof d2.componentDidMount) {
+            var e2 = b2.return;
             try {
-              d.componentDidMount();
+              d2.componentDidMount();
             } catch (k2) {
-              W(b, e, k2);
+              W$1(b2, e2, k2);
             }
           }
-          var f2 = b.return;
+          var f2 = b2.return;
           try {
-            Rj(b);
+            Rj(b2);
           } catch (k2) {
-            W(b, f2, k2);
+            W$1(b2, f2, k2);
           }
           break;
         case 5:
-          var g = b.return;
+          var g2 = b2.return;
           try {
-            Rj(b);
+            Rj(b2);
           } catch (k2) {
-            W(b, g, k2);
+            W$1(b2, g2, k2);
           }
       }
     } catch (k2) {
-      W(b, b.return, k2);
+      W$1(b2, b2.return, k2);
     }
-    if (b === a) {
-      V = null;
+    if (b2 === a2) {
+      V$1 = null;
       break;
     }
-    var h = b.sibling;
-    if (null !== h) {
-      h.return = b.return;
-      V = h;
+    var h2 = b2.sibling;
+    if (null !== h2) {
+      h2.return = b2.return;
+      V$1 = h2;
       break;
     }
-    V = b.return;
+    V$1 = b2.return;
   }
 }
-var lk = Math.ceil, mk = ua.ReactCurrentDispatcher, nk = ua.ReactCurrentOwner, ok = ua.ReactCurrentBatchConfig, K = 0, Q = null, Y = null, Z = 0, fj = 0, ej = Uf(0), T = 0, pk = null, rh = 0, qk = 0, rk = 0, sk = null, tk = null, fk = 0, Gj = Infinity, uk = null, Oi = false, Pi = null, Ri = null, vk = false, wk = null, xk = 0, yk = 0, zk = null, Ak = -1, Bk = 0;
-function R() {
-  return 0 !== (K & 6) ? B() : -1 !== Ak ? Ak : Ak = B();
+var lk = Math.ceil, mk = ua.ReactCurrentDispatcher, nk = ua.ReactCurrentOwner, ok = ua.ReactCurrentBatchConfig, K$1 = 0, Q$1 = null, Y$1 = null, Z$1 = 0, fj = 0, ej = Uf(0), T$1 = 0, pk = null, rh = 0, qk = 0, rk = 0, sk = null, tk = null, fk = 0, Gj = Infinity, uk = null, Oi = false, Pi = null, Ri = null, vk = false, wk = null, xk = 0, yk = 0, zk = null, Ak = -1, Bk = 0;
+function R$1() {
+  return 0 !== (K$1 & 6) ? B$1() : -1 !== Ak ? Ak : Ak = B$1();
 }
-function yi(a) {
-  if (0 === (a.mode & 1)) return 1;
-  if (0 !== (K & 2) && 0 !== Z) return Z & -Z;
+function yi(a2) {
+  if (0 === (a2.mode & 1)) return 1;
+  if (0 !== (K$1 & 2) && 0 !== Z$1) return Z$1 & -Z$1;
   if (null !== Kg.transition) return 0 === Bk && (Bk = yc()), Bk;
-  a = C;
-  if (0 !== a) return a;
-  a = window.event;
-  a = void 0 === a ? 16 : jd(a.type);
-  return a;
-}
-function gi(a, b, c, d) {
-  if (50 < yk) throw yk = 0, zk = null, Error(p(185));
-  Ac(a, c, d);
-  if (0 === (K & 2) || a !== Q) a === Q && (0 === (K & 2) && (qk |= c), 4 === T && Ck(a, Z)), Dk(a, d), 1 === c && 0 === K && 0 === (b.mode & 1) && (Gj = B() + 500, fg && jg());
-}
-function Dk(a, b) {
-  var c = a.callbackNode;
-  wc(a, b);
-  var d = uc(a, a === Q ? Z : 0);
-  if (0 === d) null !== c && bc(c), a.callbackNode = null, a.callbackPriority = 0;
-  else if (b = d & -d, a.callbackPriority !== b) {
-    null != c && bc(c);
-    if (1 === b) 0 === a.tag ? ig(Ek.bind(null, a)) : hg(Ek.bind(null, a)), Jf(function() {
-      0 === (K & 6) && jg();
-    }), c = null;
+  a2 = C$1;
+  if (0 !== a2) return a2;
+  a2 = window.event;
+  a2 = void 0 === a2 ? 16 : jd(a2.type);
+  return a2;
+}
+function gi(a2, b2, c2, d2) {
+  if (50 < yk) throw yk = 0, zk = null, Error(p$1(185));
+  Ac(a2, c2, d2);
+  if (0 === (K$1 & 2) || a2 !== Q$1) a2 === Q$1 && (0 === (K$1 & 2) && (qk |= c2), 4 === T$1 && Ck(a2, Z$1)), Dk(a2, d2), 1 === c2 && 0 === K$1 && 0 === (b2.mode & 1) && (Gj = B$1() + 500, fg && jg());
+}
+function Dk(a2, b2) {
+  var c2 = a2.callbackNode;
+  wc(a2, b2);
+  var d2 = uc(a2, a2 === Q$1 ? Z$1 : 0);
+  if (0 === d2) null !== c2 && bc(c2), a2.callbackNode = null, a2.callbackPriority = 0;
+  else if (b2 = d2 & -d2, a2.callbackPriority !== b2) {
+    null != c2 && bc(c2);
+    if (1 === b2) 0 === a2.tag ? ig(Ek.bind(null, a2)) : hg(Ek.bind(null, a2)), Jf(function() {
+      0 === (K$1 & 6) && jg();
+    }), c2 = null;
     else {
-      switch (Dc(d)) {
+      switch (Dc(d2)) {
         case 1:
-          c = fc;
+          c2 = fc;
           break;
         case 4:
-          c = gc;
+          c2 = gc;
           break;
         case 16:
-          c = hc;
+          c2 = hc;
           break;
         case 536870912:
-          c = jc;
+          c2 = jc;
           break;
         default:
-          c = hc;
+          c2 = hc;
       }
-      c = Fk(c, Gk.bind(null, a));
+      c2 = Fk(c2, Gk.bind(null, a2));
     }
-    a.callbackPriority = b;
-    a.callbackNode = c;
+    a2.callbackPriority = b2;
+    a2.callbackNode = c2;
   }
 }
-function Gk(a, b) {
+function Gk(a2, b2) {
   Ak = -1;
   Bk = 0;
-  if (0 !== (K & 6)) throw Error(p(327));
-  var c = a.callbackNode;
-  if (Hk() && a.callbackNode !== c) return null;
-  var d = uc(a, a === Q ? Z : 0);
-  if (0 === d) return null;
-  if (0 !== (d & 30) || 0 !== (d & a.expiredLanes) || b) b = Ik(a, d);
+  if (0 !== (K$1 & 6)) throw Error(p$1(327));
+  var c2 = a2.callbackNode;
+  if (Hk() && a2.callbackNode !== c2) return null;
+  var d2 = uc(a2, a2 === Q$1 ? Z$1 : 0);
+  if (0 === d2) return null;
+  if (0 !== (d2 & 30) || 0 !== (d2 & a2.expiredLanes) || b2) b2 = Ik(a2, d2);
   else {
-    b = d;
-    var e = K;
-    K |= 2;
+    b2 = d2;
+    var e2 = K$1;
+    K$1 |= 2;
     var f2 = Jk();
-    if (Q !== a || Z !== b) uk = null, Gj = B() + 500, Kk(a, b);
+    if (Q$1 !== a2 || Z$1 !== b2) uk = null, Gj = B$1() + 500, Kk(a2, b2);
     do
       try {
         Lk();
         break;
-      } catch (h) {
-        Mk(a, h);
+      } catch (h2) {
+        Mk(a2, h2);
       }
     while (1);
     $g();
     mk.current = f2;
-    K = e;
-    null !== Y ? b = 0 : (Q = null, Z = 0, b = T);
+    K$1 = e2;
+    null !== Y$1 ? b2 = 0 : (Q$1 = null, Z$1 = 0, b2 = T$1);
   }
-  if (0 !== b) {
-    2 === b && (e = xc(a), 0 !== e && (d = e, b = Nk(a, e)));
-    if (1 === b) throw c = pk, Kk(a, 0), Ck(a, d), Dk(a, B()), c;
-    if (6 === b) Ck(a, d);
+  if (0 !== b2) {
+    2 === b2 && (e2 = xc(a2), 0 !== e2 && (d2 = e2, b2 = Nk(a2, e2)));
+    if (1 === b2) throw c2 = pk, Kk(a2, 0), Ck(a2, d2), Dk(a2, B$1()), c2;
+    if (6 === b2) Ck(a2, d2);
     else {
-      e = a.current.alternate;
-      if (0 === (d & 30) && !Ok(e) && (b = Ik(a, d), 2 === b && (f2 = xc(a), 0 !== f2 && (d = f2, b = Nk(a, f2))), 1 === b)) throw c = pk, Kk(a, 0), Ck(a, d), Dk(a, B()), c;
-      a.finishedWork = e;
-      a.finishedLanes = d;
-      switch (b) {
+      e2 = a2.current.alternate;
+      if (0 === (d2 & 30) && !Ok(e2) && (b2 = Ik(a2, d2), 2 === b2 && (f2 = xc(a2), 0 !== f2 && (d2 = f2, b2 = Nk(a2, f2))), 1 === b2)) throw c2 = pk, Kk(a2, 0), Ck(a2, d2), Dk(a2, B$1()), c2;
+      a2.finishedWork = e2;
+      a2.finishedLanes = d2;
+      switch (b2) {
         case 0:
         case 1:
-          throw Error(p(345));
+          throw Error(p$1(345));
         case 2:
-          Pk(a, tk, uk);
+          Pk(a2, tk, uk);
           break;
         case 3:
-          Ck(a, d);
-          if ((d & 130023424) === d && (b = fk + 500 - B(), 10 < b)) {
-            if (0 !== uc(a, 0)) break;
-            e = a.suspendedLanes;
-            if ((e & d) !== d) {
-              R();
-              a.pingedLanes |= a.suspendedLanes & e;
+          Ck(a2, d2);
+          if ((d2 & 130023424) === d2 && (b2 = fk + 500 - B$1(), 10 < b2)) {
+            if (0 !== uc(a2, 0)) break;
+            e2 = a2.suspendedLanes;
+            if ((e2 & d2) !== d2) {
+              R$1();
+              a2.pingedLanes |= a2.suspendedLanes & e2;
               break;
             }
-            a.timeoutHandle = Ff(Pk.bind(null, a, tk, uk), b);
+            a2.timeoutHandle = Ff(Pk.bind(null, a2, tk, uk), b2);
             break;
           }
-          Pk(a, tk, uk);
+          Pk(a2, tk, uk);
           break;
         case 4:
-          Ck(a, d);
-          if ((d & 4194240) === d) break;
-          b = a.eventTimes;
-          for (e = -1; 0 < d; ) {
-            var g = 31 - oc(d);
-            f2 = 1 << g;
-            g = b[g];
-            g > e && (e = g);
-            d &= ~f2;
-          }
-          d = e;
-          d = B() - d;
-          d = (120 > d ? 120 : 480 > d ? 480 : 1080 > d ? 1080 : 1920 > d ? 1920 : 3e3 > d ? 3e3 : 4320 > d ? 4320 : 1960 * lk(d / 1960)) - d;
-          if (10 < d) {
-            a.timeoutHandle = Ff(Pk.bind(null, a, tk, uk), d);
+          Ck(a2, d2);
+          if ((d2 & 4194240) === d2) break;
+          b2 = a2.eventTimes;
+          for (e2 = -1; 0 < d2; ) {
+            var g2 = 31 - oc(d2);
+            f2 = 1 << g2;
+            g2 = b2[g2];
+            g2 > e2 && (e2 = g2);
+            d2 &= ~f2;
+          }
+          d2 = e2;
+          d2 = B$1() - d2;
+          d2 = (120 > d2 ? 120 : 480 > d2 ? 480 : 1080 > d2 ? 1080 : 1920 > d2 ? 1920 : 3e3 > d2 ? 3e3 : 4320 > d2 ? 4320 : 1960 * lk(d2 / 1960)) - d2;
+          if (10 < d2) {
+            a2.timeoutHandle = Ff(Pk.bind(null, a2, tk, uk), d2);
             break;
           }
-          Pk(a, tk, uk);
+          Pk(a2, tk, uk);
           break;
         case 5:
-          Pk(a, tk, uk);
+          Pk(a2, tk, uk);
           break;
         default:
-          throw Error(p(329));
+          throw Error(p$1(329));
       }
     }
   }
-  Dk(a, B());
-  return a.callbackNode === c ? Gk.bind(null, a) : null;
+  Dk(a2, B$1());
+  return a2.callbackNode === c2 ? Gk.bind(null, a2) : null;
 }
-function Nk(a, b) {
-  var c = sk;
-  a.current.memoizedState.isDehydrated && (Kk(a, b).flags |= 256);
-  a = Ik(a, b);
-  2 !== a && (b = tk, tk = c, null !== b && Fj(b));
-  return a;
+function Nk(a2, b2) {
+  var c2 = sk;
+  a2.current.memoizedState.isDehydrated && (Kk(a2, b2).flags |= 256);
+  a2 = Ik(a2, b2);
+  2 !== a2 && (b2 = tk, tk = c2, null !== b2 && Fj(b2));
+  return a2;
 }
-function Fj(a) {
-  null === tk ? tk = a : tk.push.apply(tk, a);
+function Fj(a2) {
+  null === tk ? tk = a2 : tk.push.apply(tk, a2);
 }
-function Ok(a) {
-  for (var b = a; ; ) {
-    if (b.flags & 16384) {
-      var c = b.updateQueue;
-      if (null !== c && (c = c.stores, null !== c)) for (var d = 0; d < c.length; d++) {
-        var e = c[d], f2 = e.getSnapshot;
-        e = e.value;
+function Ok(a2) {
+  for (var b2 = a2; ; ) {
+    if (b2.flags & 16384) {
+      var c2 = b2.updateQueue;
+      if (null !== c2 && (c2 = c2.stores, null !== c2)) for (var d2 = 0; d2 < c2.length; d2++) {
+        var e2 = c2[d2], f2 = e2.getSnapshot;
+        e2 = e2.value;
         try {
-          if (!He(f2(), e)) return false;
-        } catch (g) {
+          if (!He$1(f2(), e2)) return false;
+        } catch (g2) {
           return false;
         }
       }
     }
-    c = b.child;
-    if (b.subtreeFlags & 16384 && null !== c) c.return = b, b = c;
+    c2 = b2.child;
+    if (b2.subtreeFlags & 16384 && null !== c2) c2.return = b2, b2 = c2;
     else {
-      if (b === a) break;
-      for (; null === b.sibling; ) {
-        if (null === b.return || b.return === a) return true;
-        b = b.return;
+      if (b2 === a2) break;
+      for (; null === b2.sibling; ) {
+        if (null === b2.return || b2.return === a2) return true;
+        b2 = b2.return;
       }
-      b.sibling.return = b.return;
-      b = b.sibling;
+      b2.sibling.return = b2.return;
+      b2 = b2.sibling;
     }
   }
   return true;
 }
-function Ck(a, b) {
-  b &= ~rk;
-  b &= ~qk;
-  a.suspendedLanes |= b;
-  a.pingedLanes &= ~b;
-  for (a = a.expirationTimes; 0 < b; ) {
-    var c = 31 - oc(b), d = 1 << c;
-    a[c] = -1;
-    b &= ~d;
+function Ck(a2, b2) {
+  b2 &= ~rk;
+  b2 &= ~qk;
+  a2.suspendedLanes |= b2;
+  a2.pingedLanes &= ~b2;
+  for (a2 = a2.expirationTimes; 0 < b2; ) {
+    var c2 = 31 - oc(b2), d2 = 1 << c2;
+    a2[c2] = -1;
+    b2 &= ~d2;
   }
 }
-function Ek(a) {
-  if (0 !== (K & 6)) throw Error(p(327));
+function Ek(a2) {
+  if (0 !== (K$1 & 6)) throw Error(p$1(327));
   Hk();
-  var b = uc(a, 0);
-  if (0 === (b & 1)) return Dk(a, B()), null;
-  var c = Ik(a, b);
-  if (0 !== a.tag && 2 === c) {
-    var d = xc(a);
-    0 !== d && (b = d, c = Nk(a, d));
-  }
-  if (1 === c) throw c = pk, Kk(a, 0), Ck(a, b), Dk(a, B()), c;
-  if (6 === c) throw Error(p(345));
-  a.finishedWork = a.current.alternate;
-  a.finishedLanes = b;
-  Pk(a, tk, uk);
-  Dk(a, B());
+  var b2 = uc(a2, 0);
+  if (0 === (b2 & 1)) return Dk(a2, B$1()), null;
+  var c2 = Ik(a2, b2);
+  if (0 !== a2.tag && 2 === c2) {
+    var d2 = xc(a2);
+    0 !== d2 && (b2 = d2, c2 = Nk(a2, d2));
+  }
+  if (1 === c2) throw c2 = pk, Kk(a2, 0), Ck(a2, b2), Dk(a2, B$1()), c2;
+  if (6 === c2) throw Error(p$1(345));
+  a2.finishedWork = a2.current.alternate;
+  a2.finishedLanes = b2;
+  Pk(a2, tk, uk);
+  Dk(a2, B$1());
   return null;
 }
-function Qk(a, b) {
-  var c = K;
-  K |= 1;
+function Qk(a2, b2) {
+  var c2 = K$1;
+  K$1 |= 1;
   try {
-    return a(b);
+    return a2(b2);
   } finally {
-    K = c, 0 === K && (Gj = B() + 500, fg && jg());
+    K$1 = c2, 0 === K$1 && (Gj = B$1() + 500, fg && jg());
   }
 }
-function Rk(a) {
-  null !== wk && 0 === wk.tag && 0 === (K & 6) && Hk();
-  var b = K;
-  K |= 1;
-  var c = ok.transition, d = C;
+function Rk(a2) {
+  null !== wk && 0 === wk.tag && 0 === (K$1 & 6) && Hk();
+  var b2 = K$1;
+  K$1 |= 1;
+  var c2 = ok.transition, d2 = C$1;
   try {
-    if (ok.transition = null, C = 1, a) return a();
+    if (ok.transition = null, C$1 = 1, a2) return a2();
   } finally {
-    C = d, ok.transition = c, K = b, 0 === (K & 6) && jg();
+    C$1 = d2, ok.transition = c2, K$1 = b2, 0 === (K$1 & 6) && jg();
   }
 }
 function Hj() {
   fj = ej.current;
-  E(ej);
-}
-function Kk(a, b) {
-  a.finishedWork = null;
-  a.finishedLanes = 0;
-  var c = a.timeoutHandle;
-  -1 !== c && (a.timeoutHandle = -1, Gf(c));
-  if (null !== Y) for (c = Y.return; null !== c; ) {
-    var d = c;
-    wg(d);
-    switch (d.tag) {
+  E$1(ej);
+}
+function Kk(a2, b2) {
+  a2.finishedWork = null;
+  a2.finishedLanes = 0;
+  var c2 = a2.timeoutHandle;
+  -1 !== c2 && (a2.timeoutHandle = -1, Gf(c2));
+  if (null !== Y$1) for (c2 = Y$1.return; null !== c2; ) {
+    var d2 = c2;
+    wg(d2);
+    switch (d2.tag) {
       case 1:
-        d = d.type.childContextTypes;
-        null !== d && void 0 !== d && $f();
+        d2 = d2.type.childContextTypes;
+        null !== d2 && void 0 !== d2 && $f();
         break;
       case 3:
         zh();
-        E(Wf);
-        E(H);
+        E$1(Wf);
+        E$1(H$1);
         Eh();
         break;
       case 5:
-        Bh(d);
+        Bh(d2);
         break;
       case 4:
         zh();
         break;
       case 13:
-        E(L$2);
+        E$1(L$1);
         break;
       case 19:
-        E(L$2);
+        E$1(L$1);
         break;
       case 10:
-        ah(d.type._context);
+        ah(d2.type._context);
         break;
       case 22:
       case 23:
         Hj();
     }
-    c = c.return;
+    c2 = c2.return;
   }
-  Q = a;
-  Y = a = Pg(a.current, null);
-  Z = fj = b;
-  T = 0;
+  Q$1 = a2;
+  Y$1 = a2 = Pg(a2.current, null);
+  Z$1 = fj = b2;
+  T$1 = 0;
   pk = null;
   rk = qk = rh = 0;
   tk = sk = null;
   if (null !== fh) {
-    for (b = 0; b < fh.length; b++) if (c = fh[b], d = c.interleaved, null !== d) {
-      c.interleaved = null;
-      var e = d.next, f2 = c.pending;
+    for (b2 = 0; b2 < fh.length; b2++) if (c2 = fh[b2], d2 = c2.interleaved, null !== d2) {
+      c2.interleaved = null;
+      var e2 = d2.next, f2 = c2.pending;
       if (null !== f2) {
-        var g = f2.next;
-        f2.next = e;
-        d.next = g;
+        var g2 = f2.next;
+        f2.next = e2;
+        d2.next = g2;
       }
-      c.pending = d;
+      c2.pending = d2;
     }
     fh = null;
   }
-  return a;
+  return a2;
 }
-function Mk(a, b) {
+function Mk(a2, b2) {
   do {
-    var c = Y;
+    var c2 = Y$1;
     try {
       $g();
       Fh.current = Rh;
       if (Ih) {
-        for (var d = M.memoizedState; null !== d; ) {
-          var e = d.queue;
-          null !== e && (e.pending = null);
-          d = d.next;
+        for (var d2 = M$1.memoizedState; null !== d2; ) {
+          var e2 = d2.queue;
+          null !== e2 && (e2.pending = null);
+          d2 = d2.next;
         }
         Ih = false;
       }
       Hh = 0;
-      O = N = M = null;
+      O$1 = N$1 = M$1 = null;
       Jh = false;
       Kh = 0;
       nk.current = null;
-      if (null === c || null === c.return) {
-        T = 1;
-        pk = b;
-        Y = null;
+      if (null === c2 || null === c2.return) {
+        T$1 = 1;
+        pk = b2;
+        Y$1 = null;
         break;
       }
       a: {
-        var f2 = a, g = c.return, h = c, k2 = b;
-        b = Z;
-        h.flags |= 32768;
+        var f2 = a2, g2 = c2.return, h2 = c2, k2 = b2;
+        b2 = Z$1;
+        h2.flags |= 32768;
         if (null !== k2 && "object" === typeof k2 && "function" === typeof k2.then) {
-          var l2 = k2, m2 = h, q2 = m2.tag;
+          var l2 = k2, m2 = h2, q2 = m2.tag;
           if (0 === (m2.mode & 1) && (0 === q2 || 11 === q2 || 15 === q2)) {
             var r2 = m2.alternate;
             r2 ? (m2.updateQueue = r2.updateQueue, m2.memoizedState = r2.memoizedState, m2.lanes = r2.lanes) : (m2.updateQueue = null, m2.memoizedState = null);
           }
-          var y2 = Ui(g);
+          var y2 = Ui(g2);
           if (null !== y2) {
             y2.flags &= -257;
-            Vi(y2, g, h, f2, b);
-            y2.mode & 1 && Si(f2, l2, b);
-            b = y2;
+            Vi(y2, g2, h2, f2, b2);
+            y2.mode & 1 && Si(f2, l2, b2);
+            b2 = y2;
             k2 = l2;
-            var n2 = b.updateQueue;
+            var n2 = b2.updateQueue;
             if (null === n2) {
               var t2 = /* @__PURE__ */ new Set();
               t2.add(k2);
-              b.updateQueue = t2;
+              b2.updateQueue = t2;
             } else n2.add(k2);
             break a;
           } else {
-            if (0 === (b & 1)) {
-              Si(f2, l2, b);
+            if (0 === (b2 & 1)) {
+              Si(f2, l2, b2);
               tj();
               break a;
             }
-            k2 = Error(p(426));
+            k2 = Error(p$1(426));
           }
-        } else if (I && h.mode & 1) {
-          var J2 = Ui(g);
+        } else if (I$1 && h2.mode & 1) {
+          var J2 = Ui(g2);
           if (null !== J2) {
             0 === (J2.flags & 65536) && (J2.flags |= 256);
-            Vi(J2, g, h, f2, b);
-            Jg(Ji(k2, h));
+            Vi(J2, g2, h2, f2, b2);
+            Jg(Ji(k2, h2));
             break a;
           }
         }
-        f2 = k2 = Ji(k2, h);
-        4 !== T && (T = 2);
+        f2 = k2 = Ji(k2, h2);
+        4 !== T$1 && (T$1 = 2);
         null === sk ? sk = [f2] : sk.push(f2);
-        f2 = g;
+        f2 = g2;
         do {
           switch (f2.tag) {
             case 3:
               f2.flags |= 65536;
-              b &= -b;
-              f2.lanes |= b;
-              var x2 = Ni(f2, k2, b);
+              b2 &= -b2;
+              f2.lanes |= b2;
+              var x2 = Ni(f2, k2, b2);
               ph(f2, x2);
               break a;
             case 1:
-              h = k2;
+              h2 = k2;
               var w2 = f2.type, u2 = f2.stateNode;
               if (0 === (f2.flags & 128) && ("function" === typeof w2.getDerivedStateFromError || null !== u2 && "function" === typeof u2.componentDidCatch && (null === Ri || !Ri.has(u2)))) {
                 f2.flags |= 65536;
-                b &= -b;
-                f2.lanes |= b;
-                var F2 = Qi(f2, h, b);
+                b2 &= -b2;
+                f2.lanes |= b2;
+                var F2 = Qi(f2, h2, b2);
                 ph(f2, F2);
                 break a;
               }
@@ -5987,176 +5987,176 @@ function Mk(a, b) {
           f2 = f2.return;
         } while (null !== f2);
       }
-      Sk(c);
+      Sk(c2);
     } catch (na) {
-      b = na;
-      Y === c && null !== c && (Y = c = c.return);
+      b2 = na;
+      Y$1 === c2 && null !== c2 && (Y$1 = c2 = c2.return);
       continue;
     }
     break;
   } while (1);
 }
 function Jk() {
-  var a = mk.current;
+  var a2 = mk.current;
   mk.current = Rh;
-  return null === a ? Rh : a;
+  return null === a2 ? Rh : a2;
 }
 function tj() {
-  if (0 === T || 3 === T || 2 === T) T = 4;
-  null === Q || 0 === (rh & 268435455) && 0 === (qk & 268435455) || Ck(Q, Z);
-}
-function Ik(a, b) {
-  var c = K;
-  K |= 2;
-  var d = Jk();
-  if (Q !== a || Z !== b) uk = null, Kk(a, b);
+  if (0 === T$1 || 3 === T$1 || 2 === T$1) T$1 = 4;
+  null === Q$1 || 0 === (rh & 268435455) && 0 === (qk & 268435455) || Ck(Q$1, Z$1);
+}
+function Ik(a2, b2) {
+  var c2 = K$1;
+  K$1 |= 2;
+  var d2 = Jk();
+  if (Q$1 !== a2 || Z$1 !== b2) uk = null, Kk(a2, b2);
   do
     try {
       Tk();
       break;
-    } catch (e) {
-      Mk(a, e);
+    } catch (e2) {
+      Mk(a2, e2);
     }
   while (1);
   $g();
-  K = c;
-  mk.current = d;
-  if (null !== Y) throw Error(p(261));
-  Q = null;
-  Z = 0;
-  return T;
+  K$1 = c2;
+  mk.current = d2;
+  if (null !== Y$1) throw Error(p$1(261));
+  Q$1 = null;
+  Z$1 = 0;
+  return T$1;
 }
 function Tk() {
-  for (; null !== Y; ) Uk(Y);
+  for (; null !== Y$1; ) Uk(Y$1);
 }
 function Lk() {
-  for (; null !== Y && !cc(); ) Uk(Y);
+  for (; null !== Y$1 && !cc(); ) Uk(Y$1);
 }
-function Uk(a) {
-  var b = Vk(a.alternate, a, fj);
-  a.memoizedProps = a.pendingProps;
-  null === b ? Sk(a) : Y = b;
+function Uk(a2) {
+  var b2 = Vk(a2.alternate, a2, fj);
+  a2.memoizedProps = a2.pendingProps;
+  null === b2 ? Sk(a2) : Y$1 = b2;
   nk.current = null;
 }
-function Sk(a) {
-  var b = a;
+function Sk(a2) {
+  var b2 = a2;
   do {
-    var c = b.alternate;
-    a = b.return;
-    if (0 === (b.flags & 32768)) {
-      if (c = Ej(c, b, fj), null !== c) {
-        Y = c;
+    var c2 = b2.alternate;
+    a2 = b2.return;
+    if (0 === (b2.flags & 32768)) {
+      if (c2 = Ej(c2, b2, fj), null !== c2) {
+        Y$1 = c2;
         return;
       }
     } else {
-      c = Ij(c, b);
-      if (null !== c) {
-        c.flags &= 32767;
-        Y = c;
+      c2 = Ij(c2, b2);
+      if (null !== c2) {
+        c2.flags &= 32767;
+        Y$1 = c2;
         return;
       }
-      if (null !== a) a.flags |= 32768, a.subtreeFlags = 0, a.deletions = null;
+      if (null !== a2) a2.flags |= 32768, a2.subtreeFlags = 0, a2.deletions = null;
       else {
-        T = 6;
-        Y = null;
+        T$1 = 6;
+        Y$1 = null;
         return;
       }
     }
-    b = b.sibling;
-    if (null !== b) {
-      Y = b;
+    b2 = b2.sibling;
+    if (null !== b2) {
+      Y$1 = b2;
       return;
     }
-    Y = b = a;
-  } while (null !== b);
-  0 === T && (T = 5);
+    Y$1 = b2 = a2;
+  } while (null !== b2);
+  0 === T$1 && (T$1 = 5);
 }
-function Pk(a, b, c) {
-  var d = C, e = ok.transition;
+function Pk(a2, b2, c2) {
+  var d2 = C$1, e2 = ok.transition;
   try {
-    ok.transition = null, C = 1, Wk(a, b, c, d);
+    ok.transition = null, C$1 = 1, Wk(a2, b2, c2, d2);
   } finally {
-    ok.transition = e, C = d;
+    ok.transition = e2, C$1 = d2;
   }
   return null;
 }
-function Wk(a, b, c, d) {
+function Wk(a2, b2, c2, d2) {
   do
     Hk();
   while (null !== wk);
-  if (0 !== (K & 6)) throw Error(p(327));
-  c = a.finishedWork;
-  var e = a.finishedLanes;
-  if (null === c) return null;
-  a.finishedWork = null;
-  a.finishedLanes = 0;
-  if (c === a.current) throw Error(p(177));
-  a.callbackNode = null;
-  a.callbackPriority = 0;
-  var f2 = c.lanes | c.childLanes;
-  Bc(a, f2);
-  a === Q && (Y = Q = null, Z = 0);
-  0 === (c.subtreeFlags & 2064) && 0 === (c.flags & 2064) || vk || (vk = true, Fk(hc, function() {
+  if (0 !== (K$1 & 6)) throw Error(p$1(327));
+  c2 = a2.finishedWork;
+  var e2 = a2.finishedLanes;
+  if (null === c2) return null;
+  a2.finishedWork = null;
+  a2.finishedLanes = 0;
+  if (c2 === a2.current) throw Error(p$1(177));
+  a2.callbackNode = null;
+  a2.callbackPriority = 0;
+  var f2 = c2.lanes | c2.childLanes;
+  Bc(a2, f2);
+  a2 === Q$1 && (Y$1 = Q$1 = null, Z$1 = 0);
+  0 === (c2.subtreeFlags & 2064) && 0 === (c2.flags & 2064) || vk || (vk = true, Fk(hc, function() {
     Hk();
     return null;
   }));
-  f2 = 0 !== (c.flags & 15990);
-  if (0 !== (c.subtreeFlags & 15990) || f2) {
+  f2 = 0 !== (c2.flags & 15990);
+  if (0 !== (c2.subtreeFlags & 15990) || f2) {
     f2 = ok.transition;
     ok.transition = null;
-    var g = C;
-    C = 1;
-    var h = K;
-    K |= 4;
+    var g2 = C$1;
+    C$1 = 1;
+    var h2 = K$1;
+    K$1 |= 4;
     nk.current = null;
-    Oj(a, c);
-    dk(c, a);
-    Oe(Df);
+    Oj(a2, c2);
+    dk(c2, a2);
+    Oe$1(Df);
     dd = !!Cf;
     Df = Cf = null;
-    a.current = c;
-    hk(c);
+    a2.current = c2;
+    hk(c2);
     dc();
-    K = h;
-    C = g;
+    K$1 = h2;
+    C$1 = g2;
     ok.transition = f2;
-  } else a.current = c;
-  vk && (vk = false, wk = a, xk = e);
-  f2 = a.pendingLanes;
+  } else a2.current = c2;
+  vk && (vk = false, wk = a2, xk = e2);
+  f2 = a2.pendingLanes;
   0 === f2 && (Ri = null);
-  mc(c.stateNode);
-  Dk(a, B());
-  if (null !== b) for (d = a.onRecoverableError, c = 0; c < b.length; c++) e = b[c], d(e.value, { componentStack: e.stack, digest: e.digest });
-  if (Oi) throw Oi = false, a = Pi, Pi = null, a;
-  0 !== (xk & 1) && 0 !== a.tag && Hk();
-  f2 = a.pendingLanes;
-  0 !== (f2 & 1) ? a === zk ? yk++ : (yk = 0, zk = a) : yk = 0;
+  mc(c2.stateNode);
+  Dk(a2, B$1());
+  if (null !== b2) for (d2 = a2.onRecoverableError, c2 = 0; c2 < b2.length; c2++) e2 = b2[c2], d2(e2.value, { componentStack: e2.stack, digest: e2.digest });
+  if (Oi) throw Oi = false, a2 = Pi, Pi = null, a2;
+  0 !== (xk & 1) && 0 !== a2.tag && Hk();
+  f2 = a2.pendingLanes;
+  0 !== (f2 & 1) ? a2 === zk ? yk++ : (yk = 0, zk = a2) : yk = 0;
   jg();
   return null;
 }
 function Hk() {
   if (null !== wk) {
-    var a = Dc(xk), b = ok.transition, c = C;
+    var a2 = Dc(xk), b2 = ok.transition, c2 = C$1;
     try {
       ok.transition = null;
-      C = 16 > a ? 16 : a;
-      if (null === wk) var d = false;
+      C$1 = 16 > a2 ? 16 : a2;
+      if (null === wk) var d2 = false;
       else {
-        a = wk;
+        a2 = wk;
         wk = null;
         xk = 0;
-        if (0 !== (K & 6)) throw Error(p(331));
-        var e = K;
-        K |= 4;
-        for (V = a.current; null !== V; ) {
-          var f2 = V, g = f2.child;
-          if (0 !== (V.flags & 16)) {
-            var h = f2.deletions;
-            if (null !== h) {
-              for (var k2 = 0; k2 < h.length; k2++) {
-                var l2 = h[k2];
-                for (V = l2; null !== V; ) {
-                  var m2 = V;
+        if (0 !== (K$1 & 6)) throw Error(p$1(331));
+        var e2 = K$1;
+        K$1 |= 4;
+        for (V$1 = a2.current; null !== V$1; ) {
+          var f2 = V$1, g2 = f2.child;
+          if (0 !== (V$1.flags & 16)) {
+            var h2 = f2.deletions;
+            if (null !== h2) {
+              for (var k2 = 0; k2 < h2.length; k2++) {
+                var l2 = h2[k2];
+                for (V$1 = l2; null !== V$1; ) {
+                  var m2 = V$1;
                   switch (m2.tag) {
                     case 0:
                     case 11:
@@ -6164,21 +6164,21 @@ function Hk() {
                       Pj(8, m2, f2);
                   }
                   var q2 = m2.child;
-                  if (null !== q2) q2.return = m2, V = q2;
-                  else for (; null !== V; ) {
-                    m2 = V;
+                  if (null !== q2) q2.return = m2, V$1 = q2;
+                  else for (; null !== V$1; ) {
+                    m2 = V$1;
                     var r2 = m2.sibling, y2 = m2.return;
                     Sj(m2);
                     if (m2 === l2) {
-                      V = null;
+                      V$1 = null;
                       break;
                     }
                     if (null !== r2) {
                       r2.return = y2;
-                      V = r2;
+                      V$1 = r2;
                       break;
                     }
-                    V = y2;
+                    V$1 = y2;
                   }
                 }
               }
@@ -6194,12 +6194,12 @@ function Hk() {
                   } while (null !== t2);
                 }
               }
-              V = f2;
+              V$1 = f2;
             }
           }
-          if (0 !== (f2.subtreeFlags & 2064) && null !== g) g.return = f2, V = g;
-          else b: for (; null !== V; ) {
-            f2 = V;
+          if (0 !== (f2.subtreeFlags & 2064) && null !== g2) g2.return = f2, V$1 = g2;
+          else b: for (; null !== V$1; ) {
+            f2 = V$1;
             if (0 !== (f2.flags & 2048)) switch (f2.tag) {
               case 0:
               case 11:
@@ -6209,244 +6209,244 @@ function Hk() {
             var x2 = f2.sibling;
             if (null !== x2) {
               x2.return = f2.return;
-              V = x2;
+              V$1 = x2;
               break b;
             }
-            V = f2.return;
+            V$1 = f2.return;
           }
         }
-        var w2 = a.current;
-        for (V = w2; null !== V; ) {
-          g = V;
-          var u2 = g.child;
-          if (0 !== (g.subtreeFlags & 2064) && null !== u2) u2.return = g, V = u2;
-          else b: for (g = w2; null !== V; ) {
-            h = V;
-            if (0 !== (h.flags & 2048)) try {
-              switch (h.tag) {
+        var w2 = a2.current;
+        for (V$1 = w2; null !== V$1; ) {
+          g2 = V$1;
+          var u2 = g2.child;
+          if (0 !== (g2.subtreeFlags & 2064) && null !== u2) u2.return = g2, V$1 = u2;
+          else b: for (g2 = w2; null !== V$1; ) {
+            h2 = V$1;
+            if (0 !== (h2.flags & 2048)) try {
+              switch (h2.tag) {
                 case 0:
                 case 11:
                 case 15:
-                  Qj(9, h);
+                  Qj(9, h2);
               }
             } catch (na) {
-              W(h, h.return, na);
+              W$1(h2, h2.return, na);
             }
-            if (h === g) {
-              V = null;
+            if (h2 === g2) {
+              V$1 = null;
               break b;
             }
-            var F2 = h.sibling;
+            var F2 = h2.sibling;
             if (null !== F2) {
-              F2.return = h.return;
-              V = F2;
+              F2.return = h2.return;
+              V$1 = F2;
               break b;
             }
-            V = h.return;
+            V$1 = h2.return;
           }
         }
-        K = e;
+        K$1 = e2;
         jg();
         if (lc && "function" === typeof lc.onPostCommitFiberRoot) try {
-          lc.onPostCommitFiberRoot(kc, a);
+          lc.onPostCommitFiberRoot(kc, a2);
         } catch (na) {
         }
-        d = true;
+        d2 = true;
       }
-      return d;
+      return d2;
     } finally {
-      C = c, ok.transition = b;
+      C$1 = c2, ok.transition = b2;
     }
   }
   return false;
 }
-function Xk(a, b, c) {
-  b = Ji(c, b);
-  b = Ni(a, b, 1);
-  a = nh(a, b, 1);
-  b = R();
-  null !== a && (Ac(a, 1, b), Dk(a, b));
-}
-function W(a, b, c) {
-  if (3 === a.tag) Xk(a, a, c);
-  else for (; null !== b; ) {
-    if (3 === b.tag) {
-      Xk(b, a, c);
+function Xk(a2, b2, c2) {
+  b2 = Ji(c2, b2);
+  b2 = Ni(a2, b2, 1);
+  a2 = nh(a2, b2, 1);
+  b2 = R$1();
+  null !== a2 && (Ac(a2, 1, b2), Dk(a2, b2));
+}
+function W$1(a2, b2, c2) {
+  if (3 === a2.tag) Xk(a2, a2, c2);
+  else for (; null !== b2; ) {
+    if (3 === b2.tag) {
+      Xk(b2, a2, c2);
       break;
-    } else if (1 === b.tag) {
-      var d = b.stateNode;
-      if ("function" === typeof b.type.getDerivedStateFromError || "function" === typeof d.componentDidCatch && (null === Ri || !Ri.has(d))) {
-        a = Ji(c, a);
-        a = Qi(b, a, 1);
-        b = nh(b, a, 1);
-        a = R();
-        null !== b && (Ac(b, 1, a), Dk(b, a));
+    } else if (1 === b2.tag) {
+      var d2 = b2.stateNode;
+      if ("function" === typeof b2.type.getDerivedStateFromError || "function" === typeof d2.componentDidCatch && (null === Ri || !Ri.has(d2))) {
+        a2 = Ji(c2, a2);
+        a2 = Qi(b2, a2, 1);
+        b2 = nh(b2, a2, 1);
+        a2 = R$1();
+        null !== b2 && (Ac(b2, 1, a2), Dk(b2, a2));
         break;
       }
     }
-    b = b.return;
+    b2 = b2.return;
   }
 }
-function Ti(a, b, c) {
-  var d = a.pingCache;
-  null !== d && d.delete(b);
-  b = R();
-  a.pingedLanes |= a.suspendedLanes & c;
-  Q === a && (Z & c) === c && (4 === T || 3 === T && (Z & 130023424) === Z && 500 > B() - fk ? Kk(a, 0) : rk |= c);
-  Dk(a, b);
+function Ti(a2, b2, c2) {
+  var d2 = a2.pingCache;
+  null !== d2 && d2.delete(b2);
+  b2 = R$1();
+  a2.pingedLanes |= a2.suspendedLanes & c2;
+  Q$1 === a2 && (Z$1 & c2) === c2 && (4 === T$1 || 3 === T$1 && (Z$1 & 130023424) === Z$1 && 500 > B$1() - fk ? Kk(a2, 0) : rk |= c2);
+  Dk(a2, b2);
 }
-function Yk(a, b) {
-  0 === b && (0 === (a.mode & 1) ? b = 1 : (b = sc, sc <<= 1, 0 === (sc & 130023424) && (sc = 4194304)));
-  var c = R();
-  a = ih(a, b);
-  null !== a && (Ac(a, b, c), Dk(a, c));
+function Yk(a2, b2) {
+  0 === b2 && (0 === (a2.mode & 1) ? b2 = 1 : (b2 = sc, sc <<= 1, 0 === (sc & 130023424) && (sc = 4194304)));
+  var c2 = R$1();
+  a2 = ih(a2, b2);
+  null !== a2 && (Ac(a2, b2, c2), Dk(a2, c2));
 }
-function uj(a) {
-  var b = a.memoizedState, c = 0;
-  null !== b && (c = b.retryLane);
-  Yk(a, c);
+function uj(a2) {
+  var b2 = a2.memoizedState, c2 = 0;
+  null !== b2 && (c2 = b2.retryLane);
+  Yk(a2, c2);
 }
-function bk(a, b) {
-  var c = 0;
-  switch (a.tag) {
+function bk(a2, b2) {
+  var c2 = 0;
+  switch (a2.tag) {
     case 13:
-      var d = a.stateNode;
-      var e = a.memoizedState;
-      null !== e && (c = e.retryLane);
+      var d2 = a2.stateNode;
+      var e2 = a2.memoizedState;
+      null !== e2 && (c2 = e2.retryLane);
       break;
     case 19:
-      d = a.stateNode;
+      d2 = a2.stateNode;
       break;
     default:
-      throw Error(p(314));
+      throw Error(p$1(314));
   }
-  null !== d && d.delete(b);
-  Yk(a, c);
+  null !== d2 && d2.delete(b2);
+  Yk(a2, c2);
 }
 var Vk;
-Vk = function(a, b, c) {
-  if (null !== a) if (a.memoizedProps !== b.pendingProps || Wf.current) dh = true;
+Vk = function(a2, b2, c2) {
+  if (null !== a2) if (a2.memoizedProps !== b2.pendingProps || Wf.current) dh = true;
   else {
-    if (0 === (a.lanes & c) && 0 === (b.flags & 128)) return dh = false, yj(a, b, c);
-    dh = 0 !== (a.flags & 131072) ? true : false;
+    if (0 === (a2.lanes & c2) && 0 === (b2.flags & 128)) return dh = false, yj(a2, b2, c2);
+    dh = 0 !== (a2.flags & 131072) ? true : false;
   }
-  else dh = false, I && 0 !== (b.flags & 1048576) && ug(b, ng, b.index);
-  b.lanes = 0;
-  switch (b.tag) {
+  else dh = false, I$1 && 0 !== (b2.flags & 1048576) && ug(b2, ng, b2.index);
+  b2.lanes = 0;
+  switch (b2.tag) {
     case 2:
-      var d = b.type;
-      ij(a, b);
-      a = b.pendingProps;
-      var e = Yf(b, H.current);
-      ch(b, c);
-      e = Nh(null, b, d, a, e, c);
+      var d2 = b2.type;
+      ij(a2, b2);
+      a2 = b2.pendingProps;
+      var e2 = Yf(b2, H$1.current);
+      ch(b2, c2);
+      e2 = Nh(null, b2, d2, a2, e2, c2);
       var f2 = Sh();
-      b.flags |= 1;
-      "object" === typeof e && null !== e && "function" === typeof e.render && void 0 === e.$$typeof ? (b.tag = 1, b.memoizedState = null, b.updateQueue = null, Zf(d) ? (f2 = true, cg(b)) : f2 = false, b.memoizedState = null !== e.state && void 0 !== e.state ? e.state : null, kh(b), e.updater = Ei, b.stateNode = e, e._reactInternals = b, Ii(b, d, a, c), b = jj(null, b, d, true, f2, c)) : (b.tag = 0, I && f2 && vg(b), Xi(null, b, e, c), b = b.child);
-      return b;
+      b2.flags |= 1;
+      "object" === typeof e2 && null !== e2 && "function" === typeof e2.render && void 0 === e2.$$typeof ? (b2.tag = 1, b2.memoizedState = null, b2.updateQueue = null, Zf(d2) ? (f2 = true, cg(b2)) : f2 = false, b2.memoizedState = null !== e2.state && void 0 !== e2.state ? e2.state : null, kh(b2), e2.updater = Ei, b2.stateNode = e2, e2._reactInternals = b2, Ii(b2, d2, a2, c2), b2 = jj(null, b2, d2, true, f2, c2)) : (b2.tag = 0, I$1 && f2 && vg(b2), Xi(null, b2, e2, c2), b2 = b2.child);
+      return b2;
     case 16:
-      d = b.elementType;
+      d2 = b2.elementType;
       a: {
-        ij(a, b);
-        a = b.pendingProps;
-        e = d._init;
-        d = e(d._payload);
-        b.type = d;
-        e = b.tag = Zk(d);
-        a = Ci(d, a);
-        switch (e) {
+        ij(a2, b2);
+        a2 = b2.pendingProps;
+        e2 = d2._init;
+        d2 = e2(d2._payload);
+        b2.type = d2;
+        e2 = b2.tag = Zk(d2);
+        a2 = Ci(d2, a2);
+        switch (e2) {
           case 0:
-            b = cj(null, b, d, a, c);
+            b2 = cj(null, b2, d2, a2, c2);
             break a;
           case 1:
-            b = hj(null, b, d, a, c);
+            b2 = hj(null, b2, d2, a2, c2);
             break a;
           case 11:
-            b = Yi(null, b, d, a, c);
+            b2 = Yi(null, b2, d2, a2, c2);
             break a;
           case 14:
-            b = $i(null, b, d, Ci(d.type, a), c);
+            b2 = $i(null, b2, d2, Ci(d2.type, a2), c2);
             break a;
         }
-        throw Error(p(
+        throw Error(p$1(
           306,
-          d,
+          d2,
           ""
         ));
       }
-      return b;
+      return b2;
     case 0:
-      return d = b.type, e = b.pendingProps, e = b.elementType === d ? e : Ci(d, e), cj(a, b, d, e, c);
+      return d2 = b2.type, e2 = b2.pendingProps, e2 = b2.elementType === d2 ? e2 : Ci(d2, e2), cj(a2, b2, d2, e2, c2);
     case 1:
-      return d = b.type, e = b.pendingProps, e = b.elementType === d ? e : Ci(d, e), hj(a, b, d, e, c);
+      return d2 = b2.type, e2 = b2.pendingProps, e2 = b2.elementType === d2 ? e2 : Ci(d2, e2), hj(a2, b2, d2, e2, c2);
     case 3:
       a: {
-        kj(b);
-        if (null === a) throw Error(p(387));
-        d = b.pendingProps;
-        f2 = b.memoizedState;
-        e = f2.element;
-        lh(a, b);
-        qh(b, d, null, c);
-        var g = b.memoizedState;
-        d = g.element;
-        if (f2.isDehydrated) if (f2 = { element: d, isDehydrated: false, cache: g.cache, pendingSuspenseBoundaries: g.pendingSuspenseBoundaries, transitions: g.transitions }, b.updateQueue.baseState = f2, b.memoizedState = f2, b.flags & 256) {
-          e = Ji(Error(p(423)), b);
-          b = lj(a, b, d, c, e);
+        kj(b2);
+        if (null === a2) throw Error(p$1(387));
+        d2 = b2.pendingProps;
+        f2 = b2.memoizedState;
+        e2 = f2.element;
+        lh(a2, b2);
+        qh(b2, d2, null, c2);
+        var g2 = b2.memoizedState;
+        d2 = g2.element;
+        if (f2.isDehydrated) if (f2 = { element: d2, isDehydrated: false, cache: g2.cache, pendingSuspenseBoundaries: g2.pendingSuspenseBoundaries, transitions: g2.transitions }, b2.updateQueue.baseState = f2, b2.memoizedState = f2, b2.flags & 256) {
+          e2 = Ji(Error(p$1(423)), b2);
+          b2 = lj(a2, b2, d2, c2, e2);
           break a;
-        } else if (d !== e) {
-          e = Ji(Error(p(424)), b);
-          b = lj(a, b, d, c, e);
+        } else if (d2 !== e2) {
+          e2 = Ji(Error(p$1(424)), b2);
+          b2 = lj(a2, b2, d2, c2, e2);
           break a;
-        } else for (yg = Lf(b.stateNode.containerInfo.firstChild), xg = b, I = true, zg = null, c = Vg(b, null, d, c), b.child = c; c; ) c.flags = c.flags & -3 | 4096, c = c.sibling;
+        } else for (yg = Lf(b2.stateNode.containerInfo.firstChild), xg = b2, I$1 = true, zg = null, c2 = Vg(b2, null, d2, c2), b2.child = c2; c2; ) c2.flags = c2.flags & -3 | 4096, c2 = c2.sibling;
         else {
           Ig();
-          if (d === e) {
-            b = Zi(a, b, c);
+          if (d2 === e2) {
+            b2 = Zi(a2, b2, c2);
             break a;
           }
-          Xi(a, b, d, c);
+          Xi(a2, b2, d2, c2);
         }
-        b = b.child;
+        b2 = b2.child;
       }
-      return b;
+      return b2;
     case 5:
-      return Ah(b), null === a && Eg(b), d = b.type, e = b.pendingProps, f2 = null !== a ? a.memoizedProps : null, g = e.children, Ef(d, e) ? g = null : null !== f2 && Ef(d, f2) && (b.flags |= 32), gj(a, b), Xi(a, b, g, c), b.child;
+      return Ah(b2), null === a2 && Eg(b2), d2 = b2.type, e2 = b2.pendingProps, f2 = null !== a2 ? a2.memoizedProps : null, g2 = e2.children, Ef(d2, e2) ? g2 = null : null !== f2 && Ef(d2, f2) && (b2.flags |= 32), gj(a2, b2), Xi(a2, b2, g2, c2), b2.child;
     case 6:
-      return null === a && Eg(b), null;
+      return null === a2 && Eg(b2), null;
     case 13:
-      return oj(a, b, c);
+      return oj(a2, b2, c2);
     case 4:
-      return yh(b, b.stateNode.containerInfo), d = b.pendingProps, null === a ? b.child = Ug(b, null, d, c) : Xi(a, b, d, c), b.child;
+      return yh(b2, b2.stateNode.containerInfo), d2 = b2.pendingProps, null === a2 ? b2.child = Ug(b2, null, d2, c2) : Xi(a2, b2, d2, c2), b2.child;
     case 11:
-      return d = b.type, e = b.pendingProps, e = b.elementType === d ? e : Ci(d, e), Yi(a, b, d, e, c);
+      return d2 = b2.type, e2 = b2.pendingProps, e2 = b2.elementType === d2 ? e2 : Ci(d2, e2), Yi(a2, b2, d2, e2, c2);
     case 7:
-      return Xi(a, b, b.pendingProps, c), b.child;
+      return Xi(a2, b2, b2.pendingProps, c2), b2.child;
     case 8:
-      return Xi(a, b, b.pendingProps.children, c), b.child;
+      return Xi(a2, b2, b2.pendingProps.children, c2), b2.child;
     case 12:
-      return Xi(a, b, b.pendingProps.children, c), b.child;
+      return Xi(a2, b2, b2.pendingProps.children, c2), b2.child;
     case 10:
       a: {
-        d = b.type._context;
-        e = b.pendingProps;
-        f2 = b.memoizedProps;
-        g = e.value;
-        G(Wg, d._currentValue);
-        d._currentValue = g;
-        if (null !== f2) if (He(f2.value, g)) {
-          if (f2.children === e.children && !Wf.current) {
-            b = Zi(a, b, c);
+        d2 = b2.type._context;
+        e2 = b2.pendingProps;
+        f2 = b2.memoizedProps;
+        g2 = e2.value;
+        G$1(Wg, d2._currentValue);
+        d2._currentValue = g2;
+        if (null !== f2) if (He$1(f2.value, g2)) {
+          if (f2.children === e2.children && !Wf.current) {
+            b2 = Zi(a2, b2, c2);
             break a;
           }
-        } else for (f2 = b.child, null !== f2 && (f2.return = b); null !== f2; ) {
-          var h = f2.dependencies;
-          if (null !== h) {
-            g = f2.child;
-            for (var k2 = h.firstContext; null !== k2; ) {
-              if (k2.context === d) {
+        } else for (f2 = b2.child, null !== f2 && (f2.return = b2); null !== f2; ) {
+          var h2 = f2.dependencies;
+          if (null !== h2) {
+            g2 = f2.child;
+            for (var k2 = h2.firstContext; null !== k2; ) {
+              if (k2.context === d2) {
                 if (1 === f2.tag) {
-                  k2 = mh(-1, c & -c);
+                  k2 = mh(-1, c2 & -c2);
                   k2.tag = 2;
                   var l2 = f2.updateQueue;
                   if (null !== l2) {
@@ -6456,187 +6456,187 @@ Vk = function(a, b, c) {
                     l2.pending = k2;
                   }
                 }
-                f2.lanes |= c;
+                f2.lanes |= c2;
                 k2 = f2.alternate;
-                null !== k2 && (k2.lanes |= c);
+                null !== k2 && (k2.lanes |= c2);
                 bh(
                   f2.return,
-                  c,
-                  b
+                  c2,
+                  b2
                 );
-                h.lanes |= c;
+                h2.lanes |= c2;
                 break;
               }
               k2 = k2.next;
             }
-          } else if (10 === f2.tag) g = f2.type === b.type ? null : f2.child;
+          } else if (10 === f2.tag) g2 = f2.type === b2.type ? null : f2.child;
           else if (18 === f2.tag) {
-            g = f2.return;
-            if (null === g) throw Error(p(341));
-            g.lanes |= c;
-            h = g.alternate;
-            null !== h && (h.lanes |= c);
-            bh(g, c, b);
-            g = f2.sibling;
-          } else g = f2.child;
-          if (null !== g) g.return = f2;
-          else for (g = f2; null !== g; ) {
-            if (g === b) {
-              g = null;
+            g2 = f2.return;
+            if (null === g2) throw Error(p$1(341));
+            g2.lanes |= c2;
+            h2 = g2.alternate;
+            null !== h2 && (h2.lanes |= c2);
+            bh(g2, c2, b2);
+            g2 = f2.sibling;
+          } else g2 = f2.child;
+          if (null !== g2) g2.return = f2;
+          else for (g2 = f2; null !== g2; ) {
+            if (g2 === b2) {
+              g2 = null;
               break;
             }
-            f2 = g.sibling;
+            f2 = g2.sibling;
             if (null !== f2) {
-              f2.return = g.return;
-              g = f2;
+              f2.return = g2.return;
+              g2 = f2;
               break;
             }
-            g = g.return;
+            g2 = g2.return;
           }
-          f2 = g;
+          f2 = g2;
         }
-        Xi(a, b, e.children, c);
-        b = b.child;
+        Xi(a2, b2, e2.children, c2);
+        b2 = b2.child;
       }
-      return b;
+      return b2;
     case 9:
-      return e = b.type, d = b.pendingProps.children, ch(b, c), e = eh(e), d = d(e), b.flags |= 1, Xi(a, b, d, c), b.child;
+      return e2 = b2.type, d2 = b2.pendingProps.children, ch(b2, c2), e2 = eh(e2), d2 = d2(e2), b2.flags |= 1, Xi(a2, b2, d2, c2), b2.child;
     case 14:
-      return d = b.type, e = Ci(d, b.pendingProps), e = Ci(d.type, e), $i(a, b, d, e, c);
+      return d2 = b2.type, e2 = Ci(d2, b2.pendingProps), e2 = Ci(d2.type, e2), $i(a2, b2, d2, e2, c2);
     case 15:
-      return bj(a, b, b.type, b.pendingProps, c);
+      return bj(a2, b2, b2.type, b2.pendingProps, c2);
     case 17:
-      return d = b.type, e = b.pendingProps, e = b.elementType === d ? e : Ci(d, e), ij(a, b), b.tag = 1, Zf(d) ? (a = true, cg(b)) : a = false, ch(b, c), Gi(b, d, e), Ii(b, d, e, c), jj(null, b, d, true, a, c);
+      return d2 = b2.type, e2 = b2.pendingProps, e2 = b2.elementType === d2 ? e2 : Ci(d2, e2), ij(a2, b2), b2.tag = 1, Zf(d2) ? (a2 = true, cg(b2)) : a2 = false, ch(b2, c2), Gi(b2, d2, e2), Ii(b2, d2, e2, c2), jj(null, b2, d2, true, a2, c2);
     case 19:
-      return xj(a, b, c);
+      return xj(a2, b2, c2);
     case 22:
-      return dj(a, b, c);
+      return dj(a2, b2, c2);
   }
-  throw Error(p(156, b.tag));
+  throw Error(p$1(156, b2.tag));
 };
-function Fk(a, b) {
-  return ac(a, b);
+function Fk(a2, b2) {
+  return ac(a2, b2);
 }
-function $k(a, b, c, d) {
-  this.tag = a;
-  this.key = c;
+function $k(a2, b2, c2, d2) {
+  this.tag = a2;
+  this.key = c2;
   this.sibling = this.child = this.return = this.stateNode = this.type = this.elementType = null;
   this.index = 0;
   this.ref = null;
-  this.pendingProps = b;
+  this.pendingProps = b2;
   this.dependencies = this.memoizedState = this.updateQueue = this.memoizedProps = null;
-  this.mode = d;
+  this.mode = d2;
   this.subtreeFlags = this.flags = 0;
   this.deletions = null;
   this.childLanes = this.lanes = 0;
   this.alternate = null;
 }
-function Bg(a, b, c, d) {
-  return new $k(a, b, c, d);
+function Bg(a2, b2, c2, d2) {
+  return new $k(a2, b2, c2, d2);
 }
-function aj(a) {
-  a = a.prototype;
-  return !(!a || !a.isReactComponent);
+function aj(a2) {
+  a2 = a2.prototype;
+  return !(!a2 || !a2.isReactComponent);
 }
-function Zk(a) {
-  if ("function" === typeof a) return aj(a) ? 1 : 0;
-  if (void 0 !== a && null !== a) {
-    a = a.$$typeof;
-    if (a === Da) return 11;
-    if (a === Ga) return 14;
+function Zk(a2) {
+  if ("function" === typeof a2) return aj(a2) ? 1 : 0;
+  if (void 0 !== a2 && null !== a2) {
+    a2 = a2.$$typeof;
+    if (a2 === Da) return 11;
+    if (a2 === Ga) return 14;
   }
   return 2;
 }
-function Pg(a, b) {
-  var c = a.alternate;
-  null === c ? (c = Bg(a.tag, b, a.key, a.mode), c.elementType = a.elementType, c.type = a.type, c.stateNode = a.stateNode, c.alternate = a, a.alternate = c) : (c.pendingProps = b, c.type = a.type, c.flags = 0, c.subtreeFlags = 0, c.deletions = null);
-  c.flags = a.flags & 14680064;
-  c.childLanes = a.childLanes;
-  c.lanes = a.lanes;
-  c.child = a.child;
-  c.memoizedProps = a.memoizedProps;
-  c.memoizedState = a.memoizedState;
-  c.updateQueue = a.updateQueue;
-  b = a.dependencies;
-  c.dependencies = null === b ? null : { lanes: b.lanes, firstContext: b.firstContext };
-  c.sibling = a.sibling;
-  c.index = a.index;
-  c.ref = a.ref;
-  return c;
-}
-function Rg(a, b, c, d, e, f2) {
-  var g = 2;
-  d = a;
-  if ("function" === typeof a) aj(a) && (g = 1);
-  else if ("string" === typeof a) g = 5;
-  else a: switch (a) {
+function Pg(a2, b2) {
+  var c2 = a2.alternate;
+  null === c2 ? (c2 = Bg(a2.tag, b2, a2.key, a2.mode), c2.elementType = a2.elementType, c2.type = a2.type, c2.stateNode = a2.stateNode, c2.alternate = a2, a2.alternate = c2) : (c2.pendingProps = b2, c2.type = a2.type, c2.flags = 0, c2.subtreeFlags = 0, c2.deletions = null);
+  c2.flags = a2.flags & 14680064;
+  c2.childLanes = a2.childLanes;
+  c2.lanes = a2.lanes;
+  c2.child = a2.child;
+  c2.memoizedProps = a2.memoizedProps;
+  c2.memoizedState = a2.memoizedState;
+  c2.updateQueue = a2.updateQueue;
+  b2 = a2.dependencies;
+  c2.dependencies = null === b2 ? null : { lanes: b2.lanes, firstContext: b2.firstContext };
+  c2.sibling = a2.sibling;
+  c2.index = a2.index;
+  c2.ref = a2.ref;
+  return c2;
+}
+function Rg(a2, b2, c2, d2, e2, f2) {
+  var g2 = 2;
+  d2 = a2;
+  if ("function" === typeof a2) aj(a2) && (g2 = 1);
+  else if ("string" === typeof a2) g2 = 5;
+  else a: switch (a2) {
     case ya:
-      return Tg(c.children, e, f2, b);
+      return Tg(c2.children, e2, f2, b2);
     case za:
-      g = 8;
-      e |= 8;
+      g2 = 8;
+      e2 |= 8;
       break;
     case Aa:
-      return a = Bg(12, c, b, e | 2), a.elementType = Aa, a.lanes = f2, a;
+      return a2 = Bg(12, c2, b2, e2 | 2), a2.elementType = Aa, a2.lanes = f2, a2;
     case Ea:
-      return a = Bg(13, c, b, e), a.elementType = Ea, a.lanes = f2, a;
+      return a2 = Bg(13, c2, b2, e2), a2.elementType = Ea, a2.lanes = f2, a2;
     case Fa:
-      return a = Bg(19, c, b, e), a.elementType = Fa, a.lanes = f2, a;
+      return a2 = Bg(19, c2, b2, e2), a2.elementType = Fa, a2.lanes = f2, a2;
     case Ia:
-      return pj(c, e, f2, b);
+      return pj(c2, e2, f2, b2);
     default:
-      if ("object" === typeof a && null !== a) switch (a.$$typeof) {
+      if ("object" === typeof a2 && null !== a2) switch (a2.$$typeof) {
         case Ba:
-          g = 10;
+          g2 = 10;
           break a;
         case Ca:
-          g = 9;
+          g2 = 9;
           break a;
         case Da:
-          g = 11;
+          g2 = 11;
           break a;
         case Ga:
-          g = 14;
+          g2 = 14;
           break a;
         case Ha:
-          g = 16;
-          d = null;
+          g2 = 16;
+          d2 = null;
           break a;
       }
-      throw Error(p(130, null == a ? a : typeof a, ""));
+      throw Error(p$1(130, null == a2 ? a2 : typeof a2, ""));
   }
-  b = Bg(g, c, b, e);
-  b.elementType = a;
-  b.type = d;
-  b.lanes = f2;
-  return b;
+  b2 = Bg(g2, c2, b2, e2);
+  b2.elementType = a2;
+  b2.type = d2;
+  b2.lanes = f2;
+  return b2;
 }
-function Tg(a, b, c, d) {
-  a = Bg(7, a, d, b);
-  a.lanes = c;
-  return a;
-}
-function pj(a, b, c, d) {
-  a = Bg(22, a, d, b);
-  a.elementType = Ia;
-  a.lanes = c;
-  a.stateNode = { isHidden: false };
-  return a;
-}
-function Qg(a, b, c) {
-  a = Bg(6, a, null, b);
-  a.lanes = c;
-  return a;
-}
-function Sg(a, b, c) {
-  b = Bg(4, null !== a.children ? a.children : [], a.key, b);
-  b.lanes = c;
-  b.stateNode = { containerInfo: a.containerInfo, pendingChildren: null, implementation: a.implementation };
-  return b;
+function Tg(a2, b2, c2, d2) {
+  a2 = Bg(7, a2, d2, b2);
+  a2.lanes = c2;
+  return a2;
 }
-function al(a, b, c, d, e) {
-  this.tag = b;
-  this.containerInfo = a;
+function pj(a2, b2, c2, d2) {
+  a2 = Bg(22, a2, d2, b2);
+  a2.elementType = Ia;
+  a2.lanes = c2;
+  a2.stateNode = { isHidden: false };
+  return a2;
+}
+function Qg(a2, b2, c2) {
+  a2 = Bg(6, a2, null, b2);
+  a2.lanes = c2;
+  return a2;
+}
+function Sg(a2, b2, c2) {
+  b2 = Bg(4, null !== a2.children ? a2.children : [], a2.key, b2);
+  b2.lanes = c2;
+  b2.stateNode = { containerInfo: a2.containerInfo, pendingChildren: null, implementation: a2.implementation };
+  return b2;
+}
+function al(a2, b2, c2, d2, e2) {
+  this.tag = b2;
+  this.containerInfo = a2;
   this.finishedWork = this.pingCache = this.current = this.pendingChildren = null;
   this.timeoutHandle = -1;
   this.callbackNode = this.pendingContext = this.context = null;
@@ -6645,347 +6645,347 @@ function al(a, b, c, d, e) {
   this.expirationTimes = zc(-1);
   this.entangledLanes = this.finishedLanes = this.mutableReadLanes = this.expiredLanes = this.pingedLanes = this.suspendedLanes = this.pendingLanes = 0;
   this.entanglements = zc(0);
-  this.identifierPrefix = d;
-  this.onRecoverableError = e;
+  this.identifierPrefix = d2;
+  this.onRecoverableError = e2;
   this.mutableSourceEagerHydrationData = null;
 }
-function bl(a, b, c, d, e, f2, g, h, k2) {
-  a = new al(a, b, c, h, k2);
-  1 === b ? (b = 1, true === f2 && (b |= 8)) : b = 0;
-  f2 = Bg(3, null, null, b);
-  a.current = f2;
-  f2.stateNode = a;
-  f2.memoizedState = { element: d, isDehydrated: c, cache: null, transitions: null, pendingSuspenseBoundaries: null };
+function bl(a2, b2, c2, d2, e2, f2, g2, h2, k2) {
+  a2 = new al(a2, b2, c2, h2, k2);
+  1 === b2 ? (b2 = 1, true === f2 && (b2 |= 8)) : b2 = 0;
+  f2 = Bg(3, null, null, b2);
+  a2.current = f2;
+  f2.stateNode = a2;
+  f2.memoizedState = { element: d2, isDehydrated: c2, cache: null, transitions: null, pendingSuspenseBoundaries: null };
   kh(f2);
-  return a;
+  return a2;
 }
-function cl(a, b, c) {
-  var d = 3 < arguments.length && void 0 !== arguments[3] ? arguments[3] : null;
-  return { $$typeof: wa, key: null == d ? null : "" + d, children: a, containerInfo: b, implementation: c };
+function cl(a2, b2, c2) {
+  var d2 = 3 < arguments.length && void 0 !== arguments[3] ? arguments[3] : null;
+  return { $$typeof: wa, key: null == d2 ? null : "" + d2, children: a2, containerInfo: b2, implementation: c2 };
 }
-function dl(a) {
-  if (!a) return Vf;
-  a = a._reactInternals;
+function dl(a2) {
+  if (!a2) return Vf;
+  a2 = a2._reactInternals;
   a: {
-    if (Vb(a) !== a || 1 !== a.tag) throw Error(p(170));
-    var b = a;
+    if (Vb(a2) !== a2 || 1 !== a2.tag) throw Error(p$1(170));
+    var b2 = a2;
     do {
-      switch (b.tag) {
+      switch (b2.tag) {
         case 3:
-          b = b.stateNode.context;
+          b2 = b2.stateNode.context;
           break a;
         case 1:
-          if (Zf(b.type)) {
-            b = b.stateNode.__reactInternalMemoizedMergedChildContext;
+          if (Zf(b2.type)) {
+            b2 = b2.stateNode.__reactInternalMemoizedMergedChildContext;
             break a;
           }
       }
-      b = b.return;
-    } while (null !== b);
-    throw Error(p(171));
+      b2 = b2.return;
+    } while (null !== b2);
+    throw Error(p$1(171));
   }
-  if (1 === a.tag) {
-    var c = a.type;
-    if (Zf(c)) return bg(a, c, b);
+  if (1 === a2.tag) {
+    var c2 = a2.type;
+    if (Zf(c2)) return bg(a2, c2, b2);
   }
-  return b;
+  return b2;
 }
-function el(a, b, c, d, e, f2, g, h, k2) {
-  a = bl(c, d, true, a, e, f2, g, h, k2);
-  a.context = dl(null);
-  c = a.current;
-  d = R();
-  e = yi(c);
-  f2 = mh(d, e);
-  f2.callback = void 0 !== b && null !== b ? b : null;
-  nh(c, f2, e);
-  a.current.lanes = e;
-  Ac(a, e, d);
-  Dk(a, d);
-  return a;
-}
-function fl(a, b, c, d) {
-  var e = b.current, f2 = R(), g = yi(e);
-  c = dl(c);
-  null === b.context ? b.context = c : b.pendingContext = c;
-  b = mh(f2, g);
-  b.payload = { element: a };
-  d = void 0 === d ? null : d;
-  null !== d && (b.callback = d);
-  a = nh(e, b, g);
-  null !== a && (gi(a, e, g, f2), oh(a, e, g));
-  return g;
-}
-function gl(a) {
-  a = a.current;
-  if (!a.child) return null;
-  switch (a.child.tag) {
+function el(a2, b2, c2, d2, e2, f2, g2, h2, k2) {
+  a2 = bl(c2, d2, true, a2, e2, f2, g2, h2, k2);
+  a2.context = dl(null);
+  c2 = a2.current;
+  d2 = R$1();
+  e2 = yi(c2);
+  f2 = mh(d2, e2);
+  f2.callback = void 0 !== b2 && null !== b2 ? b2 : null;
+  nh(c2, f2, e2);
+  a2.current.lanes = e2;
+  Ac(a2, e2, d2);
+  Dk(a2, d2);
+  return a2;
+}
+function fl(a2, b2, c2, d2) {
+  var e2 = b2.current, f2 = R$1(), g2 = yi(e2);
+  c2 = dl(c2);
+  null === b2.context ? b2.context = c2 : b2.pendingContext = c2;
+  b2 = mh(f2, g2);
+  b2.payload = { element: a2 };
+  d2 = void 0 === d2 ? null : d2;
+  null !== d2 && (b2.callback = d2);
+  a2 = nh(e2, b2, g2);
+  null !== a2 && (gi(a2, e2, g2, f2), oh(a2, e2, g2));
+  return g2;
+}
+function gl$1(a2) {
+  a2 = a2.current;
+  if (!a2.child) return null;
+  switch (a2.child.tag) {
     case 5:
-      return a.child.stateNode;
+      return a2.child.stateNode;
     default:
-      return a.child.stateNode;
+      return a2.child.stateNode;
   }
 }
-function hl(a, b) {
-  a = a.memoizedState;
-  if (null !== a && null !== a.dehydrated) {
-    var c = a.retryLane;
-    a.retryLane = 0 !== c && c < b ? c : b;
+function hl(a2, b2) {
+  a2 = a2.memoizedState;
+  if (null !== a2 && null !== a2.dehydrated) {
+    var c2 = a2.retryLane;
+    a2.retryLane = 0 !== c2 && c2 < b2 ? c2 : b2;
   }
 }
-function il(a, b) {
-  hl(a, b);
-  (a = a.alternate) && hl(a, b);
+function il(a2, b2) {
+  hl(a2, b2);
+  (a2 = a2.alternate) && hl(a2, b2);
 }
 function jl() {
   return null;
 }
-var kl = "function" === typeof reportError ? reportError : function(a) {
-  console.error(a);
+var kl = "function" === typeof reportError ? reportError : function(a2) {
+  console.error(a2);
 };
-function ll(a) {
-  this._internalRoot = a;
+function ll(a2) {
+  this._internalRoot = a2;
 }
-ml.prototype.render = ll.prototype.render = function(a) {
-  var b = this._internalRoot;
-  if (null === b) throw Error(p(409));
-  fl(a, b, null, null);
+ml.prototype.render = ll.prototype.render = function(a2) {
+  var b2 = this._internalRoot;
+  if (null === b2) throw Error(p$1(409));
+  fl(a2, b2, null, null);
 };
 ml.prototype.unmount = ll.prototype.unmount = function() {
-  var a = this._internalRoot;
-  if (null !== a) {
+  var a2 = this._internalRoot;
+  if (null !== a2) {
     this._internalRoot = null;
-    var b = a.containerInfo;
+    var b2 = a2.containerInfo;
     Rk(function() {
-      fl(null, a, null, null);
+      fl(null, a2, null, null);
     });
-    b[uf] = null;
+    b2[uf] = null;
   }
 };
-function ml(a) {
-  this._internalRoot = a;
+function ml(a2) {
+  this._internalRoot = a2;
 }
-ml.prototype.unstable_scheduleHydration = function(a) {
-  if (a) {
-    var b = Hc();
-    a = { blockedOn: null, target: a, priority: b };
-    for (var c = 0; c < Qc.length && 0 !== b && b < Qc[c].priority; c++) ;
-    Qc.splice(c, 0, a);
-    0 === c && Vc(a);
+ml.prototype.unstable_scheduleHydration = function(a2) {
+  if (a2) {
+    var b2 = Hc();
+    a2 = { blockedOn: null, target: a2, priority: b2 };
+    for (var c2 = 0; c2 < Qc.length && 0 !== b2 && b2 < Qc[c2].priority; c2++) ;
+    Qc.splice(c2, 0, a2);
+    0 === c2 && Vc(a2);
   }
 };
-function nl(a) {
-  return !(!a || 1 !== a.nodeType && 9 !== a.nodeType && 11 !== a.nodeType);
+function nl(a2) {
+  return !(!a2 || 1 !== a2.nodeType && 9 !== a2.nodeType && 11 !== a2.nodeType);
 }
-function ol(a) {
-  return !(!a || 1 !== a.nodeType && 9 !== a.nodeType && 11 !== a.nodeType && (8 !== a.nodeType || " react-mount-point-unstable " !== a.nodeValue));
+function ol(a2) {
+  return !(!a2 || 1 !== a2.nodeType && 9 !== a2.nodeType && 11 !== a2.nodeType && (8 !== a2.nodeType || " react-mount-point-unstable " !== a2.nodeValue));
 }
 function pl() {
 }
-function ql(a, b, c, d, e) {
-  if (e) {
-    if ("function" === typeof d) {
-      var f2 = d;
-      d = function() {
-        var a2 = gl(g);
-        f2.call(a2);
+function ql(a2, b2, c2, d2, e2) {
+  if (e2) {
+    if ("function" === typeof d2) {
+      var f2 = d2;
+      d2 = function() {
+        var a3 = gl$1(g2);
+        f2.call(a3);
       };
     }
-    var g = el(b, d, a, 0, null, false, false, "", pl);
-    a._reactRootContainer = g;
-    a[uf] = g.current;
-    sf(8 === a.nodeType ? a.parentNode : a);
+    var g2 = el(b2, d2, a2, 0, null, false, false, "", pl);
+    a2._reactRootContainer = g2;
+    a2[uf] = g2.current;
+    sf(8 === a2.nodeType ? a2.parentNode : a2);
     Rk();
-    return g;
-  }
-  for (; e = a.lastChild; ) a.removeChild(e);
-  if ("function" === typeof d) {
-    var h = d;
-    d = function() {
-      var a2 = gl(k2);
-      h.call(a2);
+    return g2;
+  }
+  for (; e2 = a2.lastChild; ) a2.removeChild(e2);
+  if ("function" === typeof d2) {
+    var h2 = d2;
+    d2 = function() {
+      var a3 = gl$1(k2);
+      h2.call(a3);
     };
   }
-  var k2 = bl(a, 0, false, null, null, false, false, "", pl);
-  a._reactRootContainer = k2;
-  a[uf] = k2.current;
-  sf(8 === a.nodeType ? a.parentNode : a);
+  var k2 = bl(a2, 0, false, null, null, false, false, "", pl);
+  a2._reactRootContainer = k2;
+  a2[uf] = k2.current;
+  sf(8 === a2.nodeType ? a2.parentNode : a2);
   Rk(function() {
-    fl(b, k2, c, d);
+    fl(b2, k2, c2, d2);
   });
   return k2;
 }
-function rl(a, b, c, d, e) {
-  var f2 = c._reactRootContainer;
+function rl(a2, b2, c2, d2, e2) {
+  var f2 = c2._reactRootContainer;
   if (f2) {
-    var g = f2;
-    if ("function" === typeof e) {
-      var h = e;
-      e = function() {
-        var a2 = gl(g);
-        h.call(a2);
+    var g2 = f2;
+    if ("function" === typeof e2) {
+      var h2 = e2;
+      e2 = function() {
+        var a3 = gl$1(g2);
+        h2.call(a3);
       };
     }
-    fl(b, g, a, e);
-  } else g = ql(c, b, a, e, d);
-  return gl(g);
+    fl(b2, g2, a2, e2);
+  } else g2 = ql(c2, b2, a2, e2, d2);
+  return gl$1(g2);
 }
-Ec = function(a) {
-  switch (a.tag) {
+Ec = function(a2) {
+  switch (a2.tag) {
     case 3:
-      var b = a.stateNode;
-      if (b.current.memoizedState.isDehydrated) {
-        var c = tc(b.pendingLanes);
-        0 !== c && (Cc(b, c | 1), Dk(b, B()), 0 === (K & 6) && (Gj = B() + 500, jg()));
+      var b2 = a2.stateNode;
+      if (b2.current.memoizedState.isDehydrated) {
+        var c2 = tc(b2.pendingLanes);
+        0 !== c2 && (Cc(b2, c2 | 1), Dk(b2, B$1()), 0 === (K$1 & 6) && (Gj = B$1() + 500, jg()));
       }
       break;
     case 13:
       Rk(function() {
-        var b2 = ih(a, 1);
-        if (null !== b2) {
-          var c2 = R();
-          gi(b2, a, 1, c2);
+        var b3 = ih(a2, 1);
+        if (null !== b3) {
+          var c3 = R$1();
+          gi(b3, a2, 1, c3);
         }
-      }), il(a, 1);
+      }), il(a2, 1);
   }
 };
-Fc = function(a) {
-  if (13 === a.tag) {
-    var b = ih(a, 134217728);
-    if (null !== b) {
-      var c = R();
-      gi(b, a, 134217728, c);
+Fc = function(a2) {
+  if (13 === a2.tag) {
+    var b2 = ih(a2, 134217728);
+    if (null !== b2) {
+      var c2 = R$1();
+      gi(b2, a2, 134217728, c2);
     }
-    il(a, 134217728);
+    il(a2, 134217728);
   }
 };
-Gc = function(a) {
-  if (13 === a.tag) {
-    var b = yi(a), c = ih(a, b);
-    if (null !== c) {
-      var d = R();
-      gi(c, a, b, d);
+Gc = function(a2) {
+  if (13 === a2.tag) {
+    var b2 = yi(a2), c2 = ih(a2, b2);
+    if (null !== c2) {
+      var d2 = R$1();
+      gi(c2, a2, b2, d2);
     }
-    il(a, b);
+    il(a2, b2);
   }
 };
 Hc = function() {
-  return C;
+  return C$1;
 };
-Ic = function(a, b) {
-  var c = C;
+Ic = function(a2, b2) {
+  var c2 = C$1;
   try {
-    return C = a, b();
+    return C$1 = a2, b2();
   } finally {
-    C = c;
+    C$1 = c2;
   }
 };
-yb = function(a, b, c) {
-  switch (b) {
+yb = function(a2, b2, c2) {
+  switch (b2) {
     case "input":
-      bb(a, c);
-      b = c.name;
-      if ("radio" === c.type && null != b) {
-        for (c = a; c.parentNode; ) c = c.parentNode;
-        c = c.querySelectorAll("input[name=" + JSON.stringify("" + b) + '][type="radio"]');
-        for (b = 0; b < c.length; b++) {
-          var d = c[b];
-          if (d !== a && d.form === a.form) {
-            var e = Db(d);
-            if (!e) throw Error(p(90));
-            Wa(d);
-            bb(d, e);
+      bb(a2, c2);
+      b2 = c2.name;
+      if ("radio" === c2.type && null != b2) {
+        for (c2 = a2; c2.parentNode; ) c2 = c2.parentNode;
+        c2 = c2.querySelectorAll("input[name=" + JSON.stringify("" + b2) + '][type="radio"]');
+        for (b2 = 0; b2 < c2.length; b2++) {
+          var d2 = c2[b2];
+          if (d2 !== a2 && d2.form === a2.form) {
+            var e2 = Db(d2);
+            if (!e2) throw Error(p$1(90));
+            Wa(d2);
+            bb(d2, e2);
           }
         }
       }
       break;
     case "textarea":
-      ib(a, c);
+      ib(a2, c2);
       break;
     case "select":
-      b = c.value, null != b && fb(a, !!c.multiple, b, false);
+      b2 = c2.value, null != b2 && fb(a2, !!c2.multiple, b2, false);
   }
 };
 Gb = Qk;
 Hb = Rk;
-var sl = { usingClientEntryPoint: false, Events: [Cb, ue, Db, Eb, Fb, Qk] }, tl = { findFiberByHostInstance: Wc, bundleType: 0, version: "18.3.1", rendererPackageName: "react-dom" };
-var ul = { bundleType: tl.bundleType, version: tl.version, rendererPackageName: tl.rendererPackageName, rendererConfig: tl.rendererConfig, overrideHookState: null, overrideHookStateDeletePath: null, overrideHookStateRenamePath: null, overrideProps: null, overridePropsDeletePath: null, overridePropsRenamePath: null, setErrorHandler: null, setSuspenseHandler: null, scheduleUpdate: null, currentDispatcherRef: ua.ReactCurrentDispatcher, findHostInstanceByFiber: function(a) {
-  a = Zb(a);
-  return null === a ? null : a.stateNode;
+var sl = { usingClientEntryPoint: false, Events: [Cb, ue$1, Db, Eb, Fb, Qk] }, tl = { findFiberByHostInstance: Wc, bundleType: 0, version: "18.3.1", rendererPackageName: "react-dom" };
+var ul = { bundleType: tl.bundleType, version: tl.version, rendererPackageName: tl.rendererPackageName, rendererConfig: tl.rendererConfig, overrideHookState: null, overrideHookStateDeletePath: null, overrideHookStateRenamePath: null, overrideProps: null, overridePropsDeletePath: null, overridePropsRenamePath: null, setErrorHandler: null, setSuspenseHandler: null, scheduleUpdate: null, currentDispatcherRef: ua.ReactCurrentDispatcher, findHostInstanceByFiber: function(a2) {
+  a2 = Zb(a2);
+  return null === a2 ? null : a2.stateNode;
 }, findFiberByHostInstance: tl.findFiberByHostInstance || jl, findHostInstancesForRefresh: null, scheduleRefresh: null, scheduleRoot: null, setRefreshHandler: null, getCurrentFiber: null, reconcilerVersion: "18.3.1-next-f1338f8080-20240426" };
 if ("undefined" !== typeof __REACT_DEVTOOLS_GLOBAL_HOOK__) {
   var vl = __REACT_DEVTOOLS_GLOBAL_HOOK__;
   if (!vl.isDisabled && vl.supportsFiber) try {
     kc = vl.inject(ul), lc = vl;
-  } catch (a) {
+  } catch (a2) {
   }
 }
 reactDom_production_min.__SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED = sl;
-reactDom_production_min.createPortal = function(a, b) {
-  var c = 2 < arguments.length && void 0 !== arguments[2] ? arguments[2] : null;
-  if (!nl(b)) throw Error(p(200));
-  return cl(a, b, null, c);
-};
-reactDom_production_min.createRoot = function(a, b) {
-  if (!nl(a)) throw Error(p(299));
-  var c = false, d = "", e = kl;
-  null !== b && void 0 !== b && (true === b.unstable_strictMode && (c = true), void 0 !== b.identifierPrefix && (d = b.identifierPrefix), void 0 !== b.onRecoverableError && (e = b.onRecoverableError));
-  b = bl(a, 1, false, null, null, c, false, d, e);
-  a[uf] = b.current;
-  sf(8 === a.nodeType ? a.parentNode : a);
-  return new ll(b);
-};
-reactDom_production_min.findDOMNode = function(a) {
-  if (null == a) return null;
-  if (1 === a.nodeType) return a;
-  var b = a._reactInternals;
-  if (void 0 === b) {
-    if ("function" === typeof a.render) throw Error(p(188));
-    a = Object.keys(a).join(",");
-    throw Error(p(268, a));
-  }
-  a = Zb(b);
-  a = null === a ? null : a.stateNode;
-  return a;
-};
-reactDom_production_min.flushSync = function(a) {
-  return Rk(a);
-};
-reactDom_production_min.hydrate = function(a, b, c) {
-  if (!ol(b)) throw Error(p(200));
-  return rl(null, a, b, true, c);
-};
-reactDom_production_min.hydrateRoot = function(a, b, c) {
-  if (!nl(a)) throw Error(p(405));
-  var d = null != c && c.hydratedSources || null, e = false, f2 = "", g = kl;
-  null !== c && void 0 !== c && (true === c.unstable_strictMode && (e = true), void 0 !== c.identifierPrefix && (f2 = c.identifierPrefix), void 0 !== c.onRecoverableError && (g = c.onRecoverableError));
-  b = el(b, null, a, 1, null != c ? c : null, e, false, f2, g);
-  a[uf] = b.current;
-  sf(a);
-  if (d) for (a = 0; a < d.length; a++) c = d[a], e = c._getVersion, e = e(c._source), null == b.mutableSourceEagerHydrationData ? b.mutableSourceEagerHydrationData = [c, e] : b.mutableSourceEagerHydrationData.push(
-    c,
-    e
+reactDom_production_min.createPortal = function(a2, b2) {
+  var c2 = 2 < arguments.length && void 0 !== arguments[2] ? arguments[2] : null;
+  if (!nl(b2)) throw Error(p$1(200));
+  return cl(a2, b2, null, c2);
+};
+reactDom_production_min.createRoot = function(a2, b2) {
+  if (!nl(a2)) throw Error(p$1(299));
+  var c2 = false, d2 = "", e2 = kl;
+  null !== b2 && void 0 !== b2 && (true === b2.unstable_strictMode && (c2 = true), void 0 !== b2.identifierPrefix && (d2 = b2.identifierPrefix), void 0 !== b2.onRecoverableError && (e2 = b2.onRecoverableError));
+  b2 = bl(a2, 1, false, null, null, c2, false, d2, e2);
+  a2[uf] = b2.current;
+  sf(8 === a2.nodeType ? a2.parentNode : a2);
+  return new ll(b2);
+};
+reactDom_production_min.findDOMNode = function(a2) {
+  if (null == a2) return null;
+  if (1 === a2.nodeType) return a2;
+  var b2 = a2._reactInternals;
+  if (void 0 === b2) {
+    if ("function" === typeof a2.render) throw Error(p$1(188));
+    a2 = Object.keys(a2).join(",");
+    throw Error(p$1(268, a2));
+  }
+  a2 = Zb(b2);
+  a2 = null === a2 ? null : a2.stateNode;
+  return a2;
+};
+reactDom_production_min.flushSync = function(a2) {
+  return Rk(a2);
+};
+reactDom_production_min.hydrate = function(a2, b2, c2) {
+  if (!ol(b2)) throw Error(p$1(200));
+  return rl(null, a2, b2, true, c2);
+};
+reactDom_production_min.hydrateRoot = function(a2, b2, c2) {
+  if (!nl(a2)) throw Error(p$1(405));
+  var d2 = null != c2 && c2.hydratedSources || null, e2 = false, f2 = "", g2 = kl;
+  null !== c2 && void 0 !== c2 && (true === c2.unstable_strictMode && (e2 = true), void 0 !== c2.identifierPrefix && (f2 = c2.identifierPrefix), void 0 !== c2.onRecoverableError && (g2 = c2.onRecoverableError));
+  b2 = el(b2, null, a2, 1, null != c2 ? c2 : null, e2, false, f2, g2);
+  a2[uf] = b2.current;
+  sf(a2);
+  if (d2) for (a2 = 0; a2 < d2.length; a2++) c2 = d2[a2], e2 = c2._getVersion, e2 = e2(c2._source), null == b2.mutableSourceEagerHydrationData ? b2.mutableSourceEagerHydrationData = [c2, e2] : b2.mutableSourceEagerHydrationData.push(
+    c2,
+    e2
   );
-  return new ml(b);
-};
-reactDom_production_min.render = function(a, b, c) {
-  if (!ol(b)) throw Error(p(200));
-  return rl(null, a, b, false, c);
-};
-reactDom_production_min.unmountComponentAtNode = function(a) {
-  if (!ol(a)) throw Error(p(40));
-  return a._reactRootContainer ? (Rk(function() {
-    rl(null, null, a, false, function() {
-      a._reactRootContainer = null;
-      a[uf] = null;
+  return new ml(b2);
+};
+reactDom_production_min.render = function(a2, b2, c2) {
+  if (!ol(b2)) throw Error(p$1(200));
+  return rl(null, a2, b2, false, c2);
+};
+reactDom_production_min.unmountComponentAtNode = function(a2) {
+  if (!ol(a2)) throw Error(p$1(40));
+  return a2._reactRootContainer ? (Rk(function() {
+    rl(null, null, a2, false, function() {
+      a2._reactRootContainer = null;
+      a2[uf] = null;
     });
   }), true) : false;
 };
 reactDom_production_min.unstable_batchedUpdates = Qk;
-reactDom_production_min.unstable_renderSubtreeIntoContainer = function(a, b, c, d) {
-  if (!ol(c)) throw Error(p(200));
-  if (null == a || void 0 === a._reactInternals) throw Error(p(38));
-  return rl(a, b, c, false, d);
+reactDom_production_min.unstable_renderSubtreeIntoContainer = function(a2, b2, c2, d2) {
+  if (!ol(c2)) throw Error(p$1(200));
+  if (null == a2 || void 0 === a2._reactInternals) throw Error(p$1(38));
+  return rl(a2, b2, c2, false, d2);
 };
 reactDom_production_min.version = "18.3.1-next-f1338f8080-20240426";
 function checkDCE() {
@@ -7003,10 +7003,10 @@ function checkDCE() {
   reactDom.exports = reactDom_production_min;
 }
 var reactDomExports = reactDom.exports;
-var m = reactDomExports;
+var m$1 = reactDomExports;
 {
-  client.createRoot = m.createRoot;
-  client.hydrateRoot = m.hydrateRoot;
+  client.createRoot = m$1.createRoot;
+  client.hydrateRoot = m$1.hydrateRoot;
 }
 const POINT_COLORS = [
   "#1f77b4",
@@ -7042,7 +7042,31 @@ const initialState = {
   opacity: 1,
   showChart: false,
   selectedPointId: null,
-  showTrends: false
+  showTrends: false,
+  activePointLayer: null,
+  pointLayerBounds: null,
+  clickedPoints: [],
+  pointColorBy: "velocity",
+  pointVmin: -10,
+  pointVmax: 10,
+  pointAttributes: {},
+  pointFilter: "",
+  pointBasemap: "satellite",
+  pointColormap: "rdbu_r",
+  referencePointId: null,
+  referenceTimeseries: [],
+  chartTheme: "dark",
+  pointHistogram: null,
+  rasterLayerVisible: true,
+  pointLayerVisible: true,
+  pointOpacity: 1,
+  gpsVisible: false,
+  gpsLoading: false,
+  gpsStations: [],
+  gpsSelectedStationId: null,
+  gpsTimeseries: [],
+  gpsComponent: "los",
+  gpsLosInfo: null
 };
 function appReducer(state, action) {
   switch (action.type) {
@@ -7051,10 +7075,10 @@ function appReducer(state, action) {
     case "ADD_TIME_SERIES_POINT": {
       const id2 = generatePointId();
       const color2 = getNextColor(state.timeSeriesPoints);
-      const name = action.payload.name || `Point ${state.timeSeriesPoints.length + 1}`;
+      const name2 = action.payload.name || `Point ${state.timeSeriesPoints.length + 1}`;
       const newPoint = {
         id: id2,
-        name,
+        name: name2,
         position: action.payload.position,
         color: color2,
         visible: true,
@@ -7166,6 +7190,72 @@ function appReducer(state, action) {
       return { ...state, opacity: action.payload };
     case "TOGGLE_CHART":
       return { ...state, showChart: !state.showChart };
+    case "SET_ACTIVE_POINT_LAYER":
+      return { ...state, activePointLayer: action.payload };
+    case "SET_POINT_LAYER_BOUNDS":
+      return { ...state, pointLayerBounds: action.payload };
+    case "SET_CLICKED_POINT_TIMESERIES":
+      return {
+        ...state,
+        showChart: true,
+        clickedPoints: [
+          ...state.clickedPoints.filter((p2) => p2.pointId !== action.payload.pointId),
+          action.payload
+        ]
+      };
+    case "CLEAR_CLICKED_POINTS":
+      return { ...state, clickedPoints: [] };
+    case "REMOVE_CLICKED_POINT":
+      return {
+        ...state,
+        clickedPoints: state.clickedPoints.filter((p2) => p2.pointId !== action.payload)
+      };
+    case "SET_POINT_COLOR_BY":
+      return { ...state, pointColorBy: action.payload };
+    case "SET_POINT_VMIN":
+      return { ...state, pointVmin: action.payload };
+    case "SET_POINT_VMAX":
+      return { ...state, pointVmax: action.payload };
+    case "SET_POINT_ATTRIBUTES":
+      return { ...state, pointAttributes: action.payload };
+    case "SET_POINT_FILTER":
+      return { ...state, pointFilter: action.payload };
+    case "SET_POINT_BASEMAP":
+      return { ...state, pointBasemap: action.payload };
+    case "SET_POINT_COLORMAP":
+      return { ...state, pointColormap: action.payload };
+    case "SET_REFERENCE_POINT":
+      return {
+        ...state,
+        referencePointId: action.payload.pointId,
+        referenceTimeseries: action.payload.timeseries
+      };
+    case "CLEAR_REFERENCE_POINT":
+      return { ...state, referencePointId: null, referenceTimeseries: [] };
+    case "SET_CHART_THEME":
+      return { ...state, chartTheme: action.payload };
+    case "SET_POINT_HISTOGRAM":
+      return { ...state, pointHistogram: action.payload };
+    case "SET_RASTER_LAYER_VISIBLE":
+      return { ...state, rasterLayerVisible: action.payload };
+    case "SET_POINT_LAYER_VISIBLE":
+      return { ...state, pointLayerVisible: action.payload };
+    case "SET_POINT_OPACITY":
+      return { ...state, pointOpacity: action.payload };
+    case "SET_GPS_VISIBLE":
+      return { ...state, gpsVisible: action.payload };
+    case "SET_GPS_LOADING":
+      return { ...state, gpsLoading: action.payload };
+    case "SET_GPS_STATIONS":
+      return { ...state, gpsStations: action.payload, gpsLoading: false };
+    case "SET_GPS_SELECTED_STATION":
+      return { ...state, gpsSelectedStationId: action.payload };
+    case "SET_GPS_TIMESERIES":
+      return { ...state, gpsTimeseries: action.payload, showChart: true };
+    case "SET_GPS_COMPONENT":
+      return { ...state, gpsComponent: action.payload };
+    case "SET_GPS_LOS_INFO":
+      return { ...state, gpsLosInfo: action.payload };
     default:
       return state;
   }
@@ -7284,25483 +7374,334307 @@ function useApi() {
     fetchTimeBounds
   };
 }
-function useAttribution(map2, attribution) {
-  const attributionRef = reactExports.useRef(attribution);
-  reactExports.useEffect(function updateAttribution() {
-    if (attribution !== attributionRef.current && map2.attributionControl != null) {
-      if (attributionRef.current != null) {
-        map2.attributionControl.removeAttribution(attributionRef.current);
+function __awaiter(thisArg, _arguments, P2, generator) {
+  function adopt(value) {
+    return value instanceof P2 ? value : new P2(function(resolve) {
+      resolve(value);
+    });
+  }
+  return new (P2 || (P2 = Promise))(function(resolve, reject) {
+    function fulfilled(value) {
+      try {
+        step(generator.next(value));
+      } catch (e2) {
+        reject(e2);
       }
-      if (attribution != null) {
-        map2.attributionControl.addAttribution(attribution);
+    }
+    function rejected(value) {
+      try {
+        step(generator["throw"](value));
+      } catch (e2) {
+        reject(e2);
       }
     }
-    attributionRef.current = attribution;
-  }, [
-    map2,
-    attribution
-  ]);
-}
-const CONTEXT_VERSION = 1;
-function createLeafletContext(map2) {
-  return Object.freeze({
-    __version: CONTEXT_VERSION,
-    map: map2
+    function step(result) {
+      result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected);
+    }
+    step((generator = generator.apply(thisArg, _arguments || [])).next());
   });
 }
-function extendContext(source, extra) {
-  return Object.freeze({
-    ...source,
-    ...extra
-  });
+function __values(o2) {
+  var s2 = typeof Symbol === "function" && Symbol.iterator, m2 = s2 && o2[s2], i2 = 0;
+  if (m2) return m2.call(o2);
+  if (o2 && typeof o2.length === "number") return {
+    next: function() {
+      if (o2 && i2 >= o2.length) o2 = void 0;
+      return { value: o2 && o2[i2++], done: !o2 };
+    }
+  };
+  throw new TypeError(s2 ? "Object is not iterable." : "Symbol.iterator is not defined.");
+}
+function __await(v2) {
+  return this instanceof __await ? (this.v = v2, this) : new __await(v2);
 }
-const LeafletContext = reactExports.createContext(null);
-const LeafletProvider = LeafletContext.Provider;
-function useLeafletContext() {
-  const context = reactExports.useContext(LeafletContext);
-  if (context == null) {
-    throw new Error("No context provided: useLeafletContext() can only be used in a descendant of <MapContainer>");
+function __asyncGenerator(thisArg, _arguments, generator) {
+  if (!Symbol.asyncIterator) throw new TypeError("Symbol.asyncIterator is not defined.");
+  var g2 = generator.apply(thisArg, _arguments || []), i2, q2 = [];
+  return i2 = Object.create((typeof AsyncIterator === "function" ? AsyncIterator : Object).prototype), verb("next"), verb("throw"), verb("return", awaitReturn), i2[Symbol.asyncIterator] = function() {
+    return this;
+  }, i2;
+  function awaitReturn(f2) {
+    return function(v2) {
+      return Promise.resolve(v2).then(f2, reject);
+    };
+  }
+  function verb(n2, f2) {
+    if (g2[n2]) {
+      i2[n2] = function(v2) {
+        return new Promise(function(a2, b2) {
+          q2.push([n2, v2, a2, b2]) > 1 || resume(n2, v2);
+        });
+      };
+      if (f2) i2[n2] = f2(i2[n2]);
+    }
+  }
+  function resume(n2, v2) {
+    try {
+      step(g2[n2](v2));
+    } catch (e2) {
+      settle(q2[0][3], e2);
+    }
+  }
+  function step(r2) {
+    r2.value instanceof __await ? Promise.resolve(r2.value.v).then(fulfill, reject) : settle(q2[0][2], r2);
+  }
+  function fulfill(value) {
+    resume("next", value);
+  }
+  function reject(value) {
+    resume("throw", value);
+  }
+  function settle(f2, v2) {
+    if (f2(v2), q2.shift(), q2.length) resume(q2[0][0], q2[0][1]);
   }
-  return context;
 }
-function createContainerComponent(useElement) {
-  function ContainerComponent(props, forwardedRef) {
-    const { instance, context } = useElement(props).current;
-    reactExports.useImperativeHandle(forwardedRef, () => instance);
-    return props.children == null ? null : /* @__PURE__ */ React.createElement(LeafletProvider, {
-      value: context
-    }, props.children);
+function __asyncDelegator(o2) {
+  var i2, p2;
+  return i2 = {}, verb("next"), verb("throw", function(e2) {
+    throw e2;
+  }), verb("return"), i2[Symbol.iterator] = function() {
+    return this;
+  }, i2;
+  function verb(n2, f2) {
+    i2[n2] = o2[n2] ? function(v2) {
+      return (p2 = !p2) ? { value: __await(o2[n2](v2)), done: false } : f2 ? f2(v2) : v2;
+    } : f2;
   }
-  return /* @__PURE__ */ reactExports.forwardRef(ContainerComponent);
 }
-function createLeafComponent(useElement) {
-  function LeafComponent(props, forwardedRef) {
-    const { instance } = useElement(props).current;
-    reactExports.useImperativeHandle(forwardedRef, () => instance);
-    return null;
+function __asyncValues(o2) {
+  if (!Symbol.asyncIterator) throw new TypeError("Symbol.asyncIterator is not defined.");
+  var m2 = o2[Symbol.asyncIterator], i2;
+  return m2 ? m2.call(o2) : (o2 = typeof __values === "function" ? __values(o2) : o2[Symbol.iterator](), i2 = {}, verb("next"), verb("throw"), verb("return"), i2[Symbol.asyncIterator] = function() {
+    return this;
+  }, i2);
+  function verb(n2) {
+    i2[n2] = o2[n2] && function(v2) {
+      return new Promise(function(resolve, reject) {
+        v2 = o2[n2](v2), settle(resolve, reject, v2.done, v2.value);
+      });
+    };
+  }
+  function settle(resolve, reject, d2, v2) {
+    Promise.resolve(v2).then(function(v3) {
+      resolve({ value: v3, done: d2 });
+    }, reject);
   }
-  return /* @__PURE__ */ reactExports.forwardRef(LeafComponent);
 }
-function useEventHandlers(element, eventHandlers) {
-  const eventHandlersRef = reactExports.useRef();
-  reactExports.useEffect(function addEventHandlers() {
-    if (eventHandlers != null) {
-      element.instance.on(eventHandlers);
+typeof SuppressedError === "function" ? SuppressedError : function(error, suppressed, message2) {
+  var e2 = new Error(message2);
+  return e2.name = "SuppressedError", e2.error = error, e2.suppressed = suppressed, e2;
+};
+const decoder = new TextDecoder("utf-8");
+const decodeUtf8 = decoder.decode.bind(decoder);
+const encoder = new TextEncoder();
+const encodeUtf8 = (value) => encoder.encode(value);
+const isNumber = (x2) => typeof x2 === "number";
+const isBoolean$1 = (x2) => typeof x2 === "boolean";
+const isFunction$1 = (x2) => typeof x2 === "function";
+const isObject$2 = (x2) => x2 != null && Object(x2) === x2;
+const isPromise = (x2) => {
+  return isObject$2(x2) && isFunction$1(x2.then);
+};
+const isIterable$1 = (x2) => {
+  return isObject$2(x2) && isFunction$1(x2[Symbol.iterator]);
+};
+const isAsyncIterable$2 = (x2) => {
+  return isObject$2(x2) && isFunction$1(x2[Symbol.asyncIterator]);
+};
+const isArrowJSON = (x2) => {
+  return isObject$2(x2) && isObject$2(x2["schema"]);
+};
+const isIteratorResult = (x2) => {
+  return isObject$2(x2) && "done" in x2 && "value" in x2;
+};
+const isFileHandle = (x2) => {
+  return isObject$2(x2) && isFunction$1(x2["stat"]) && isNumber(x2["fd"]);
+};
+const isFetchResponse = (x2) => {
+  return isObject$2(x2) && isReadableDOMStream$1(x2["body"]);
+};
+const isReadableInterop = (x2) => "_getDOMStream" in x2 && "_getNodeStream" in x2;
+const isReadableDOMStream$1 = (x2) => {
+  return isObject$2(x2) && isFunction$1(x2["cancel"]) && isFunction$1(x2["getReader"]) && !isReadableInterop(x2);
+};
+const isReadableNodeStream$1 = (x2) => {
+  return isObject$2(x2) && isFunction$1(x2["read"]) && isFunction$1(x2["pipe"]) && isBoolean$1(x2["readable"]) && !isReadableInterop(x2);
+};
+const isFlatbuffersByteBuffer = (x2) => {
+  return isObject$2(x2) && isFunction$1(x2["clear"]) && isFunction$1(x2["bytes"]) && isFunction$1(x2["position"]) && isFunction$1(x2["setPosition"]) && isFunction$1(x2["capacity"]) && isFunction$1(x2["getBufferIdentifier"]) && isFunction$1(x2["createLong"]);
+};
+const SharedArrayBuf = typeof SharedArrayBuffer !== "undefined" ? SharedArrayBuffer : ArrayBuffer;
+function collapseContiguousByteRanges(chunks) {
+  const result = chunks[0] ? [chunks[0]] : [];
+  let xOffset, yOffset, xLen, yLen;
+  for (let x2, y2, i2 = 0, j2 = 0, n2 = chunks.length; ++i2 < n2; ) {
+    x2 = result[j2];
+    y2 = chunks[i2];
+    if (!x2 || !y2 || x2.buffer !== y2.buffer || y2.byteOffset < x2.byteOffset) {
+      y2 && (result[++j2] = y2);
+      continue;
     }
-    eventHandlersRef.current = eventHandlers;
-    return function removeEventHandlers() {
-      if (eventHandlersRef.current != null) {
-        element.instance.off(eventHandlersRef.current);
+    ({ byteOffset: xOffset, byteLength: xLen } = x2);
+    ({ byteOffset: yOffset, byteLength: yLen } = y2);
+    if (xOffset + xLen < yOffset || yOffset + yLen < xOffset) {
+      y2 && (result[++j2] = y2);
+      continue;
+    }
+    result[j2] = new Uint8Array(x2.buffer, xOffset, yOffset - xOffset + yLen);
+  }
+  return result;
+}
+function memcpy(target, source2, targetByteOffset = 0, sourceByteLength = source2.byteLength) {
+  const targetByteLength = target.byteLength;
+  const dst = new Uint8Array(target.buffer, target.byteOffset, targetByteLength);
+  const src = new Uint8Array(source2.buffer, source2.byteOffset, Math.min(sourceByteLength, targetByteLength));
+  dst.set(src, targetByteOffset);
+  return target;
+}
+function joinUint8Arrays(chunks, size) {
+  const result = collapseContiguousByteRanges(chunks);
+  const byteLength = result.reduce((x2, b2) => x2 + b2.byteLength, 0);
+  let source2, sliced, buffer;
+  let offset = 0, index = -1;
+  const length2 = Math.min(size || Number.POSITIVE_INFINITY, byteLength);
+  for (const n2 = result.length; ++index < n2; ) {
+    source2 = result[index];
+    sliced = source2.subarray(0, Math.min(source2.length, length2 - offset));
+    if (length2 <= offset + sliced.length) {
+      if (sliced.length < source2.length) {
+        result[index] = source2.subarray(sliced.length);
+      } else if (sliced.length === source2.length) {
+        index++;
       }
-      eventHandlersRef.current = null;
+      buffer ? memcpy(buffer, sliced, offset) : buffer = sliced;
+      break;
+    }
+    memcpy(buffer || (buffer = new Uint8Array(length2)), sliced, offset);
+    offset += sliced.length;
+  }
+  return [buffer || new Uint8Array(0), result.slice(index), byteLength - (buffer ? buffer.byteLength : 0)];
+}
+function toArrayBufferView(ArrayBufferViewCtor, input) {
+  let value = isIteratorResult(input) ? input.value : input;
+  if (value instanceof ArrayBufferViewCtor) {
+    if (ArrayBufferViewCtor === Uint8Array) {
+      return new ArrayBufferViewCtor(value.buffer, value.byteOffset, value.byteLength);
+    }
+    return value;
+  }
+  if (!value) {
+    return new ArrayBufferViewCtor(0);
+  }
+  if (typeof value === "string") {
+    value = encodeUtf8(value);
+  }
+  if (value instanceof ArrayBuffer) {
+    return new ArrayBufferViewCtor(value);
+  }
+  if (value instanceof SharedArrayBuf) {
+    return new ArrayBufferViewCtor(value);
+  }
+  if (isFlatbuffersByteBuffer(value)) {
+    return toArrayBufferView(ArrayBufferViewCtor, value.bytes());
+  }
+  return !ArrayBuffer.isView(value) ? ArrayBufferViewCtor.from(value) : value.byteLength <= 0 ? new ArrayBufferViewCtor(0) : new ArrayBufferViewCtor(value.buffer, value.byteOffset, value.byteLength / ArrayBufferViewCtor.BYTES_PER_ELEMENT);
+}
+const toInt32Array = (input) => toArrayBufferView(Int32Array, input);
+const toBigInt64Array = (input) => toArrayBufferView(BigInt64Array, input);
+const toUint8Array = (input) => toArrayBufferView(Uint8Array, input);
+const pump$1 = (iterator) => {
+  iterator.next();
+  return iterator;
+};
+function* toArrayBufferViewIterator(ArrayCtor, source2) {
+  const wrap = function* (x2) {
+    yield x2;
+  };
+  const buffers = typeof source2 === "string" ? wrap(source2) : ArrayBuffer.isView(source2) ? wrap(source2) : source2 instanceof ArrayBuffer ? wrap(source2) : source2 instanceof SharedArrayBuf ? wrap(source2) : !isIterable$1(source2) ? wrap(source2) : source2;
+  yield* pump$1(function* (it2) {
+    let r2 = null;
+    do {
+      r2 = it2.next(yield toArrayBufferView(ArrayCtor, r2));
+    } while (!r2.done);
+  }(buffers[Symbol.iterator]()));
+  return new ArrayCtor();
+}
+const toUint8ArrayIterator = (input) => toArrayBufferViewIterator(Uint8Array, input);
+function toArrayBufferViewAsyncIterator(ArrayCtor, source2) {
+  return __asyncGenerator(this, arguments, function* toArrayBufferViewAsyncIterator_1() {
+    if (isPromise(source2)) {
+      return yield __await(yield __await(yield* __asyncDelegator(__asyncValues(toArrayBufferViewAsyncIterator(ArrayCtor, yield __await(source2))))));
+    }
+    const wrap = function(x2) {
+      return __asyncGenerator(this, arguments, function* () {
+        yield yield __await(yield __await(x2));
+      });
     };
-  }, [
-    element,
-    eventHandlers
-  ]);
+    const emit = function(source3) {
+      return __asyncGenerator(this, arguments, function* () {
+        yield __await(yield* __asyncDelegator(__asyncValues(pump$1(function* (it2) {
+          let r2 = null;
+          do {
+            r2 = it2.next(yield r2 === null || r2 === void 0 ? void 0 : r2.value);
+          } while (!r2.done);
+        }(source3[Symbol.iterator]())))));
+      });
+    };
+    const buffers = typeof source2 === "string" ? wrap(source2) : ArrayBuffer.isView(source2) ? wrap(source2) : source2 instanceof ArrayBuffer ? wrap(source2) : source2 instanceof SharedArrayBuf ? wrap(source2) : isIterable$1(source2) ? emit(source2) : !isAsyncIterable$2(source2) ? wrap(source2) : source2;
+    yield __await(
+      // otherwise if AsyncIterable, use it
+      yield* __asyncDelegator(__asyncValues(pump$1(function(it2) {
+        return __asyncGenerator(this, arguments, function* () {
+          let r2 = null;
+          do {
+            r2 = yield __await(it2.next(yield yield __await(toArrayBufferView(ArrayCtor, r2))));
+          } while (!r2.done);
+        });
+      }(buffers[Symbol.asyncIterator]()))))
+    );
+    return yield __await(new ArrayCtor());
+  });
 }
-function withPane(props, context) {
-  const pane = props.pane ?? context.pane;
-  return pane ? {
-    ...props,
-    pane
-  } : props;
+const toUint8ArrayAsyncIterator = (input) => toArrayBufferViewAsyncIterator(Uint8Array, input);
+function compareArrayLike(a2, b2) {
+  let i2 = 0;
+  const n2 = a2.length;
+  if (n2 !== b2.length) {
+    return false;
+  }
+  if (n2 > 0) {
+    do {
+      if (a2[i2] !== b2[i2]) {
+        return false;
+      }
+    } while (++i2 < n2);
+  }
+  return true;
 }
-var leafletSrc = { exports: {} };
-/* @preserve
- * Leaflet 1.9.4, a JS library for interactive maps. https://leafletjs.com
- * (c) 2010-2023 Vladimir Agafonkin, (c) 2010-2011 CloudMade
- */
-(function(module, exports) {
-  (function(global2, factory) {
-    factory(exports);
-  })(commonjsGlobal, function(exports2) {
-    var version2 = "1.9.4";
-    function extend(dest) {
-      var i, j, len, src;
-      for (j = 1, len = arguments.length; j < len; j++) {
-        src = arguments[j];
-        for (i in src) {
-          dest[i] = src[i];
-        }
-      }
-      return dest;
-    }
-    var create$2 = Object.create || /* @__PURE__ */ function() {
-      function F2() {
-      }
-      return function(proto) {
-        F2.prototype = proto;
-        return new F2();
-      };
-    }();
-    function bind(fn, obj) {
-      var slice = Array.prototype.slice;
-      if (fn.bind) {
-        return fn.bind.apply(fn, slice.call(arguments, 1));
-      }
-      var args = slice.call(arguments, 2);
-      return function() {
-        return fn.apply(obj, args.length ? args.concat(slice.call(arguments)) : arguments);
-      };
+const streamAdapters = {
+  fromIterable(source2) {
+    return pump(fromIterable(source2));
+  },
+  fromAsyncIterable(source2) {
+    return pump(fromAsyncIterable(source2));
+  },
+  fromDOMStream(source2) {
+    return pump(fromDOMStream(source2));
+  },
+  fromNodeStream(stream) {
+    return pump(fromNodeStream(stream));
+  },
+  // @ts-ignore
+  toDOMStream(source2, options) {
+    throw new Error(`"toDOMStream" not available in this environment`);
+  },
+  // @ts-ignore
+  toNodeStream(source2, options) {
+    throw new Error(`"toNodeStream" not available in this environment`);
+  }
+};
+const pump = (iterator) => {
+  iterator.next();
+  return iterator;
+};
+function* fromIterable(source2) {
+  let done, threw = false;
+  let buffers = [], buffer;
+  let cmd, size, bufferLength = 0;
+  function byteRange() {
+    if (cmd === "peek") {
+      return joinUint8Arrays(buffers, size)[0];
     }
-    var lastId = 0;
-    function stamp(obj) {
-      if (!("_leaflet_id" in obj)) {
-        obj["_leaflet_id"] = ++lastId;
+    [buffer, buffers, bufferLength] = joinUint8Arrays(buffers, size);
+    return buffer;
+  }
+  ({ cmd, size } = (yield /* @__PURE__ */ (() => null)()) || { cmd: "read", size: 0 });
+  const it2 = toUint8ArrayIterator(source2)[Symbol.iterator]();
+  try {
+    do {
+      ({ done, value: buffer } = Number.isNaN(size - bufferLength) ? it2.next() : it2.next(size - bufferLength));
+      if (!done && buffer.byteLength > 0) {
+        buffers.push(buffer);
+        bufferLength += buffer.byteLength;
+      }
+      if (done || size <= bufferLength) {
+        do {
+          ({ cmd, size } = yield byteRange());
+        } while (size < bufferLength);
+      }
+    } while (!done);
+  } catch (e2) {
+    threw = true;
+    typeof it2.throw === "function" && it2.throw(e2);
+  } finally {
+    threw === false && typeof it2.return === "function" && it2.return(null);
+  }
+  return null;
+}
+function fromAsyncIterable(source2) {
+  return __asyncGenerator(this, arguments, function* fromAsyncIterable_1() {
+    let done, threw = false;
+    let buffers = [], buffer;
+    let cmd, size, bufferLength = 0;
+    function byteRange() {
+      if (cmd === "peek") {
+        return joinUint8Arrays(buffers, size)[0];
       }
-      return obj._leaflet_id;
+      [buffer, buffers, bufferLength] = joinUint8Arrays(buffers, size);
+      return buffer;
     }
-    function throttle(fn, time, context) {
-      var lock, args, wrapperFn, later;
-      later = function() {
-        lock = false;
-        if (args) {
-          wrapperFn.apply(context, args);
-          args = false;
+    ({ cmd, size } = (yield yield __await(/* @__PURE__ */ (() => null)())) || { cmd: "read", size: 0 });
+    const it2 = toUint8ArrayAsyncIterator(source2)[Symbol.asyncIterator]();
+    try {
+      do {
+        ({ done, value: buffer } = Number.isNaN(size - bufferLength) ? yield __await(it2.next()) : yield __await(it2.next(size - bufferLength)));
+        if (!done && buffer.byteLength > 0) {
+          buffers.push(buffer);
+          bufferLength += buffer.byteLength;
         }
-      };
-      wrapperFn = function() {
-        if (lock) {
-          args = arguments;
-        } else {
-          fn.apply(context, arguments);
-          setTimeout(later, time);
-          lock = true;
+        if (done || size <= bufferLength) {
+          do {
+            ({ cmd, size } = yield yield __await(byteRange()));
+          } while (size < bufferLength);
         }
-      };
-      return wrapperFn;
-    }
-    function wrapNum(x2, range, includeMax) {
-      var max = range[1], min = range[0], d = max - min;
-      return x2 === max && includeMax ? x2 : ((x2 - min) % d + d) % d + min;
-    }
-    function falseFn() {
-      return false;
+      } while (!done);
+    } catch (e2) {
+      threw = true;
+      typeof it2.throw === "function" && (yield __await(it2.throw(e2)));
+    } finally {
+      threw === false && typeof it2.return === "function" && (yield __await(it2.return(new Uint8Array(0))));
     }
-    function formatNum(num, precision) {
-      if (precision === false) {
-        return num;
+    return yield __await(null);
+  });
+}
+function fromDOMStream(source2) {
+  return __asyncGenerator(this, arguments, function* fromDOMStream_1() {
+    let done = false, threw = false;
+    let buffers = [], buffer;
+    let cmd, size, bufferLength = 0;
+    function byteRange() {
+      if (cmd === "peek") {
+        return joinUint8Arrays(buffers, size)[0];
       }
-      var pow = Math.pow(10, precision === void 0 ? 6 : precision);
-      return Math.round(num * pow) / pow;
+      [buffer, buffers, bufferLength] = joinUint8Arrays(buffers, size);
+      return buffer;
     }
-    function trim(str) {
-      return str.trim ? str.trim() : str.replace(/^\s+|\s+$/g, "");
+    ({ cmd, size } = (yield yield __await(/* @__PURE__ */ (() => null)())) || { cmd: "read", size: 0 });
+    const it2 = new AdaptiveByteReader(source2);
+    try {
+      do {
+        ({ done, value: buffer } = Number.isNaN(size - bufferLength) ? yield __await(it2["read"]()) : yield __await(it2["read"](size - bufferLength)));
+        if (!done && buffer.byteLength > 0) {
+          buffers.push(toUint8Array(buffer));
+          bufferLength += buffer.byteLength;
+        }
+        if (done || size <= bufferLength) {
+          do {
+            ({ cmd, size } = yield yield __await(byteRange()));
+          } while (size < bufferLength);
+        }
+      } while (!done);
+    } catch (e2) {
+      threw = true;
+      yield __await(it2["cancel"](e2));
+    } finally {
+      threw === false ? yield __await(it2["cancel"]()) : source2["locked"] && it2.releaseLock();
     }
-    function splitWords(str) {
-      return trim(str).split(/\s+/);
+    return yield __await(null);
+  });
+}
+class AdaptiveByteReader {
+  constructor(source2) {
+    this.source = source2;
+    this.reader = null;
+    this.reader = this.source["getReader"]();
+    this.reader["closed"].catch(() => {
+    });
+  }
+  get closed() {
+    return this.reader ? this.reader["closed"].catch(() => {
+    }) : Promise.resolve();
+  }
+  releaseLock() {
+    if (this.reader) {
+      this.reader.releaseLock();
     }
-    function setOptions2(obj, options) {
-      if (!Object.prototype.hasOwnProperty.call(obj, "options")) {
-        obj.options = obj.options ? create$2(obj.options) : {};
+    this.reader = null;
+  }
+  cancel(reason) {
+    return __awaiter(this, void 0, void 0, function* () {
+      const { reader, source: source2 } = this;
+      reader && (yield reader["cancel"](reason).catch(() => {
+      }));
+      source2 && (source2["locked"] && this.releaseLock());
+    });
+  }
+  read(size) {
+    return __awaiter(this, void 0, void 0, function* () {
+      if (size === 0) {
+        return { done: this.reader == null, value: new Uint8Array(0) };
       }
-      for (var i in options) {
-        obj.options[i] = options[i];
+      const result = yield this.reader.read();
+      !result.done && (result.value = toUint8Array(result));
+      return result;
+    });
+  }
+}
+const onEvent = (stream, event) => {
+  const handler = (_2) => resolve([event, _2]);
+  let resolve;
+  return [event, handler, new Promise((r2) => (resolve = r2) && stream["once"](event, handler))];
+};
+function fromNodeStream(stream) {
+  return __asyncGenerator(this, arguments, function* fromNodeStream_1() {
+    const events = [];
+    let event = "error";
+    let done = false, err = null;
+    let cmd, size, bufferLength = 0;
+    let buffers = [], buffer;
+    function byteRange() {
+      if (cmd === "peek") {
+        return joinUint8Arrays(buffers, size)[0];
       }
-      return obj.options;
+      [buffer, buffers, bufferLength] = joinUint8Arrays(buffers, size);
+      return buffer;
     }
-    function getParamString(obj, existingUrl, uppercase) {
-      var params = [];
-      for (var i in obj) {
-        params.push(encodeURIComponent(uppercase ? i.toUpperCase() : i) + "=" + encodeURIComponent(obj[i]));
-      }
-      return (!existingUrl || existingUrl.indexOf("?") === -1 ? "?" : "&") + params.join("&");
+    ({ cmd, size } = (yield yield __await(/* @__PURE__ */ (() => null)())) || { cmd: "read", size: 0 });
+    if (stream["isTTY"]) {
+      yield yield __await(new Uint8Array(0));
+      return yield __await(null);
     }
-    var templateRe = /\{ *([\w_ -]+) *\}/g;
-    function template(str, data) {
-      return str.replace(templateRe, function(str2, key) {
-        var value = data[key];
-        if (value === void 0) {
-          throw new Error("No value provided for variable " + str2);
-        } else if (typeof value === "function") {
-          value = value(data);
+    try {
+      events[0] = onEvent(stream, "end");
+      events[1] = onEvent(stream, "error");
+      do {
+        events[2] = onEvent(stream, "readable");
+        [event, err] = yield __await(Promise.race(events.map((x2) => x2[2])));
+        if (event === "error") {
+          break;
         }
-        return value;
-      });
+        if (!(done = event === "end")) {
+          if (!Number.isFinite(size - bufferLength)) {
+            buffer = toUint8Array(stream["read"]());
+          } else {
+            buffer = toUint8Array(stream["read"](size - bufferLength));
+            if (buffer.byteLength < size - bufferLength) {
+              buffer = toUint8Array(stream["read"]());
+            }
+          }
+          if (buffer.byteLength > 0) {
+            buffers.push(buffer);
+            bufferLength += buffer.byteLength;
+          }
+        }
+        if (done || size <= bufferLength) {
+          do {
+            ({ cmd, size } = yield yield __await(byteRange()));
+          } while (size < bufferLength);
+        }
+      } while (!done);
+    } finally {
+      yield __await(cleanup(events, event === "error" ? err : null));
     }
-    var isArray2 = Array.isArray || function(obj) {
-      return Object.prototype.toString.call(obj) === "[object Array]";
-    };
-    function indexOf(array, el2) {
-      for (var i = 0; i < array.length; i++) {
-        if (array[i] === el2) {
-          return i;
+    return yield __await(null);
+    function cleanup(events2, err2) {
+      buffer = buffers = null;
+      return new Promise((resolve, reject) => {
+        for (const [evt, fn] of events2) {
+          stream["off"](evt, fn);
         }
-      }
-      return -1;
+        try {
+          const destroy = stream["destroy"];
+          destroy && destroy.call(stream, err2);
+          err2 = void 0;
+        } catch (e2) {
+          err2 = e2 || err2;
+        } finally {
+          err2 != null ? reject(err2) : resolve();
+        }
+      });
     }
-    var emptyImageUrl = "data:image/gif;base64,R0lGODlhAQABAAD/ACwAAAAAAQABAAACADs=";
-    function getPrefixed(name) {
-      return window["webkit" + name] || window["moz" + name] || window["ms" + name];
+  });
+}
+var MetadataVersion;
+(function(MetadataVersion2) {
+  MetadataVersion2[MetadataVersion2["V1"] = 0] = "V1";
+  MetadataVersion2[MetadataVersion2["V2"] = 1] = "V2";
+  MetadataVersion2[MetadataVersion2["V3"] = 2] = "V3";
+  MetadataVersion2[MetadataVersion2["V4"] = 3] = "V4";
+  MetadataVersion2[MetadataVersion2["V5"] = 4] = "V5";
+})(MetadataVersion || (MetadataVersion = {}));
+var UnionMode;
+(function(UnionMode2) {
+  UnionMode2[UnionMode2["Sparse"] = 0] = "Sparse";
+  UnionMode2[UnionMode2["Dense"] = 1] = "Dense";
+})(UnionMode || (UnionMode = {}));
+var Precision;
+(function(Precision2) {
+  Precision2[Precision2["HALF"] = 0] = "HALF";
+  Precision2[Precision2["SINGLE"] = 1] = "SINGLE";
+  Precision2[Precision2["DOUBLE"] = 2] = "DOUBLE";
+})(Precision || (Precision = {}));
+var DateUnit;
+(function(DateUnit2) {
+  DateUnit2[DateUnit2["DAY"] = 0] = "DAY";
+  DateUnit2[DateUnit2["MILLISECOND"] = 1] = "MILLISECOND";
+})(DateUnit || (DateUnit = {}));
+var TimeUnit;
+(function(TimeUnit2) {
+  TimeUnit2[TimeUnit2["SECOND"] = 0] = "SECOND";
+  TimeUnit2[TimeUnit2["MILLISECOND"] = 1] = "MILLISECOND";
+  TimeUnit2[TimeUnit2["MICROSECOND"] = 2] = "MICROSECOND";
+  TimeUnit2[TimeUnit2["NANOSECOND"] = 3] = "NANOSECOND";
+})(TimeUnit || (TimeUnit = {}));
+var IntervalUnit;
+(function(IntervalUnit2) {
+  IntervalUnit2[IntervalUnit2["YEAR_MONTH"] = 0] = "YEAR_MONTH";
+  IntervalUnit2[IntervalUnit2["DAY_TIME"] = 1] = "DAY_TIME";
+  IntervalUnit2[IntervalUnit2["MONTH_DAY_NANO"] = 2] = "MONTH_DAY_NANO";
+})(IntervalUnit || (IntervalUnit = {}));
+const SIZEOF_SHORT = 2;
+const SIZEOF_INT = 4;
+const FILE_IDENTIFIER_LENGTH = 4;
+const SIZE_PREFIX_LENGTH = 4;
+const int32 = new Int32Array(2);
+const float32 = new Float32Array(int32.buffer);
+const float64 = new Float64Array(int32.buffer);
+const isLittleEndian = new Uint16Array(new Uint8Array([1, 0]).buffer)[0] === 1;
+var Encoding;
+(function(Encoding2) {
+  Encoding2[Encoding2["UTF8_BYTES"] = 1] = "UTF8_BYTES";
+  Encoding2[Encoding2["UTF16_STRING"] = 2] = "UTF16_STRING";
+})(Encoding || (Encoding = {}));
+let ByteBuffer$2 = class ByteBuffer {
+  /**
+   * Create a new ByteBuffer with a given array of bytes (`Uint8Array`)
+   */
+  constructor(bytes_) {
+    this.bytes_ = bytes_;
+    this.position_ = 0;
+    this.text_decoder_ = new TextDecoder();
+  }
+  /**
+   * Create and allocate a new ByteBuffer with a given size.
+   */
+  static allocate(byte_size) {
+    return new ByteBuffer(new Uint8Array(byte_size));
+  }
+  clear() {
+    this.position_ = 0;
+  }
+  /**
+   * Get the underlying `Uint8Array`.
+   */
+  bytes() {
+    return this.bytes_;
+  }
+  /**
+   * Get the buffer's position.
+   */
+  position() {
+    return this.position_;
+  }
+  /**
+   * Set the buffer's position.
+   */
+  setPosition(position) {
+    this.position_ = position;
+  }
+  /**
+   * Get the buffer's capacity.
+   */
+  capacity() {
+    return this.bytes_.length;
+  }
+  readInt8(offset) {
+    return this.readUint8(offset) << 24 >> 24;
+  }
+  readUint8(offset) {
+    return this.bytes_[offset];
+  }
+  readInt16(offset) {
+    return this.readUint16(offset) << 16 >> 16;
+  }
+  readUint16(offset) {
+    return this.bytes_[offset] | this.bytes_[offset + 1] << 8;
+  }
+  readInt32(offset) {
+    return this.bytes_[offset] | this.bytes_[offset + 1] << 8 | this.bytes_[offset + 2] << 16 | this.bytes_[offset + 3] << 24;
+  }
+  readUint32(offset) {
+    return this.readInt32(offset) >>> 0;
+  }
+  readInt64(offset) {
+    return BigInt.asIntN(64, BigInt(this.readUint32(offset)) + (BigInt(this.readUint32(offset + 4)) << BigInt(32)));
+  }
+  readUint64(offset) {
+    return BigInt.asUintN(64, BigInt(this.readUint32(offset)) + (BigInt(this.readUint32(offset + 4)) << BigInt(32)));
+  }
+  readFloat32(offset) {
+    int32[0] = this.readInt32(offset);
+    return float32[0];
+  }
+  readFloat64(offset) {
+    int32[isLittleEndian ? 0 : 1] = this.readInt32(offset);
+    int32[isLittleEndian ? 1 : 0] = this.readInt32(offset + 4);
+    return float64[0];
+  }
+  writeInt8(offset, value) {
+    this.bytes_[offset] = value;
+  }
+  writeUint8(offset, value) {
+    this.bytes_[offset] = value;
+  }
+  writeInt16(offset, value) {
+    this.bytes_[offset] = value;
+    this.bytes_[offset + 1] = value >> 8;
+  }
+  writeUint16(offset, value) {
+    this.bytes_[offset] = value;
+    this.bytes_[offset + 1] = value >> 8;
+  }
+  writeInt32(offset, value) {
+    this.bytes_[offset] = value;
+    this.bytes_[offset + 1] = value >> 8;
+    this.bytes_[offset + 2] = value >> 16;
+    this.bytes_[offset + 3] = value >> 24;
+  }
+  writeUint32(offset, value) {
+    this.bytes_[offset] = value;
+    this.bytes_[offset + 1] = value >> 8;
+    this.bytes_[offset + 2] = value >> 16;
+    this.bytes_[offset + 3] = value >> 24;
+  }
+  writeInt64(offset, value) {
+    this.writeInt32(offset, Number(BigInt.asIntN(32, value)));
+    this.writeInt32(offset + 4, Number(BigInt.asIntN(32, value >> BigInt(32))));
+  }
+  writeUint64(offset, value) {
+    this.writeUint32(offset, Number(BigInt.asUintN(32, value)));
+    this.writeUint32(offset + 4, Number(BigInt.asUintN(32, value >> BigInt(32))));
+  }
+  writeFloat32(offset, value) {
+    float32[0] = value;
+    this.writeInt32(offset, int32[0]);
+  }
+  writeFloat64(offset, value) {
+    float64[0] = value;
+    this.writeInt32(offset, int32[isLittleEndian ? 0 : 1]);
+    this.writeInt32(offset + 4, int32[isLittleEndian ? 1 : 0]);
+  }
+  /**
+   * Return the file identifier.   Behavior is undefined for FlatBuffers whose
+   * schema does not include a file_identifier (likely points at padding or the
+   * start of a the root vtable).
+   */
+  getBufferIdentifier() {
+    if (this.bytes_.length < this.position_ + SIZEOF_INT + FILE_IDENTIFIER_LENGTH) {
+      throw new Error("FlatBuffers: ByteBuffer is too short to contain an identifier.");
     }
-    var lastTime = 0;
-    function timeoutDefer(fn) {
-      var time = +/* @__PURE__ */ new Date(), timeToCall = Math.max(0, 16 - (time - lastTime));
-      lastTime = time + timeToCall;
-      return window.setTimeout(fn, timeToCall);
+    let result = "";
+    for (let i2 = 0; i2 < FILE_IDENTIFIER_LENGTH; i2++) {
+      result += String.fromCharCode(this.readInt8(this.position_ + SIZEOF_INT + i2));
     }
-    var requestFn = window.requestAnimationFrame || getPrefixed("RequestAnimationFrame") || timeoutDefer;
-    var cancelFn = window.cancelAnimationFrame || getPrefixed("CancelAnimationFrame") || getPrefixed("CancelRequestAnimationFrame") || function(id2) {
-      window.clearTimeout(id2);
-    };
-    function requestAnimFrame2(fn, context, immediate) {
-      if (immediate && requestFn === timeoutDefer) {
-        fn.call(context);
-      } else {
-        return requestFn.call(window, bind(fn, context));
+    return result;
+  }
+  /**
+   * Look up a field in the vtable, return an offset into the object, or 0 if the
+   * field is not present.
+   */
+  __offset(bb_pos, vtable_offset) {
+    const vtable = bb_pos - this.readInt32(bb_pos);
+    return vtable_offset < this.readInt16(vtable) ? this.readInt16(vtable + vtable_offset) : 0;
+  }
+  /**
+   * Initialize any Table-derived type to point to the union at the given offset.
+   */
+  __union(t2, offset) {
+    t2.bb_pos = offset + this.readInt32(offset);
+    t2.bb = this;
+    return t2;
+  }
+  /**
+   * Create a JavaScript string from UTF-8 data stored inside the FlatBuffer.
+   * This allocates a new string and converts to wide chars upon each access.
+   *
+   * To avoid the conversion to string, pass Encoding.UTF8_BYTES as the
+   * "optionalEncoding" argument. This is useful for avoiding conversion when
+   * the data will just be packaged back up in another FlatBuffer later on.
+   *
+   * @param offset
+   * @param opt_encoding Defaults to UTF16_STRING
+   */
+  __string(offset, opt_encoding) {
+    offset += this.readInt32(offset);
+    const length2 = this.readInt32(offset);
+    offset += SIZEOF_INT;
+    const utf8bytes = this.bytes_.subarray(offset, offset + length2);
+    if (opt_encoding === Encoding.UTF8_BYTES)
+      return utf8bytes;
+    else
+      return this.text_decoder_.decode(utf8bytes);
+  }
+  /**
+   * Handle unions that can contain string as its member, if a Table-derived type then initialize it,
+   * if a string then return a new one
+   *
+   * WARNING: strings are immutable in JS so we can't change the string that the user gave us, this
+   * makes the behaviour of __union_with_string different compared to __union
+   */
+  __union_with_string(o2, offset) {
+    if (typeof o2 === "string") {
+      return this.__string(offset);
+    }
+    return this.__union(o2, offset);
+  }
+  /**
+   * Retrieve the relative offset stored at "offset"
+   */
+  __indirect(offset) {
+    return offset + this.readInt32(offset);
+  }
+  /**
+   * Get the start of data of a vector whose offset is stored at "offset" in this object.
+   */
+  __vector(offset) {
+    return offset + this.readInt32(offset) + SIZEOF_INT;
+  }
+  /**
+   * Get the length of a vector whose offset is stored at "offset" in this object.
+   */
+  __vector_len(offset) {
+    return this.readInt32(offset + this.readInt32(offset));
+  }
+  __has_identifier(ident) {
+    if (ident.length != FILE_IDENTIFIER_LENGTH) {
+      throw new Error("FlatBuffers: file identifier must be length " + FILE_IDENTIFIER_LENGTH);
+    }
+    for (let i2 = 0; i2 < FILE_IDENTIFIER_LENGTH; i2++) {
+      if (ident.charCodeAt(i2) != this.readInt8(this.position() + SIZEOF_INT + i2)) {
+        return false;
       }
     }
-    function cancelAnimFrame(id2) {
-      if (id2) {
-        cancelFn.call(window, id2);
+    return true;
+  }
+  /**
+   * A helper function for generating list for obj api
+   */
+  createScalarList(listAccessor, listLength) {
+    const ret = [];
+    for (let i2 = 0; i2 < listLength; ++i2) {
+      const val = listAccessor(i2);
+      if (val !== null) {
+        ret.push(val);
       }
     }
-    var Util = {
-      __proto__: null,
-      extend,
-      create: create$2,
-      bind,
-      get lastId() {
-        return lastId;
-      },
-      stamp,
-      throttle,
-      wrapNum,
-      falseFn,
-      formatNum,
-      trim,
-      splitWords,
-      setOptions: setOptions2,
-      getParamString,
-      template,
-      isArray: isArray2,
-      indexOf,
-      emptyImageUrl,
-      requestFn,
-      cancelFn,
-      requestAnimFrame: requestAnimFrame2,
-      cancelAnimFrame
-    };
-    function Class() {
+    return ret;
+  }
+  /**
+   * A helper function for generating list for obj api
+   * @param listAccessor function that accepts an index and return data at that index
+   * @param listLength listLength
+   * @param res result list
+   */
+  createObjList(listAccessor, listLength) {
+    const ret = [];
+    for (let i2 = 0; i2 < listLength; ++i2) {
+      const val = listAccessor(i2);
+      if (val !== null) {
+        ret.push(val.unpack());
+      }
     }
-    Class.extend = function(props) {
-      var NewClass = function() {
-        setOptions2(this);
-        if (this.initialize) {
-          this.initialize.apply(this, arguments);
-        }
-        this.callInitHooks();
-      };
-      var parentProto = NewClass.__super__ = this.prototype;
-      var proto = create$2(parentProto);
-      proto.constructor = NewClass;
-      NewClass.prototype = proto;
-      for (var i in this) {
-        if (Object.prototype.hasOwnProperty.call(this, i) && i !== "prototype" && i !== "__super__") {
-          NewClass[i] = this[i];
-        }
-      }
-      if (props.statics) {
-        extend(NewClass, props.statics);
-      }
-      if (props.includes) {
-        checkDeprecatedMixinEvents(props.includes);
-        extend.apply(null, [proto].concat(props.includes));
-      }
-      extend(proto, props);
-      delete proto.statics;
-      delete proto.includes;
-      if (proto.options) {
-        proto.options = parentProto.options ? create$2(parentProto.options) : {};
-        extend(proto.options, props.options);
-      }
-      proto._initHooks = [];
-      proto.callInitHooks = function() {
-        if (this._initHooksCalled) {
-          return;
-        }
-        if (parentProto.callInitHooks) {
-          parentProto.callInitHooks.call(this);
-        }
-        this._initHooksCalled = true;
-        for (var i2 = 0, len = proto._initHooks.length; i2 < len; i2++) {
-          proto._initHooks[i2].call(this);
+    return ret;
+  }
+};
+let Builder$2 = class Builder {
+  /**
+   * Create a FlatBufferBuilder.
+   */
+  constructor(opt_initial_size) {
+    this.minalign = 1;
+    this.vtable = null;
+    this.vtable_in_use = 0;
+    this.isNested = false;
+    this.object_start = 0;
+    this.vtables = [];
+    this.vector_num_elems = 0;
+    this.force_defaults = false;
+    this.string_maps = null;
+    this.text_encoder = new TextEncoder();
+    let initial_size;
+    if (!opt_initial_size) {
+      initial_size = 1024;
+    } else {
+      initial_size = opt_initial_size;
+    }
+    this.bb = ByteBuffer$2.allocate(initial_size);
+    this.space = initial_size;
+  }
+  clear() {
+    this.bb.clear();
+    this.space = this.bb.capacity();
+    this.minalign = 1;
+    this.vtable = null;
+    this.vtable_in_use = 0;
+    this.isNested = false;
+    this.object_start = 0;
+    this.vtables = [];
+    this.vector_num_elems = 0;
+    this.force_defaults = false;
+    this.string_maps = null;
+  }
+  /**
+   * In order to save space, fields that are set to their default value
+   * don't get serialized into the buffer. Forcing defaults provides a
+   * way to manually disable this optimization.
+   *
+   * @param forceDefaults true always serializes default values
+   */
+  forceDefaults(forceDefaults) {
+    this.force_defaults = forceDefaults;
+  }
+  /**
+   * Get the ByteBuffer representing the FlatBuffer. Only call this after you've
+   * called finish(). The actual data starts at the ByteBuffer's current position,
+   * not necessarily at 0.
+   */
+  dataBuffer() {
+    return this.bb;
+  }
+  /**
+   * Get the bytes representing the FlatBuffer. Only call this after you've
+   * called finish().
+   */
+  asUint8Array() {
+    return this.bb.bytes().subarray(this.bb.position(), this.bb.position() + this.offset());
+  }
+  /**
+   * Prepare to write an element of `size` after `additional_bytes` have been
+   * written, e.g. if you write a string, you need to align such the int length
+   * field is aligned to 4 bytes, and the string data follows it directly. If all
+   * you need to do is alignment, `additional_bytes` will be 0.
+   *
+   * @param size This is the of the new element to write
+   * @param additional_bytes The padding size
+   */
+  prep(size, additional_bytes) {
+    if (size > this.minalign) {
+      this.minalign = size;
+    }
+    const align_size = ~(this.bb.capacity() - this.space + additional_bytes) + 1 & size - 1;
+    while (this.space < align_size + size + additional_bytes) {
+      const old_buf_size = this.bb.capacity();
+      this.bb = Builder.growByteBuffer(this.bb);
+      this.space += this.bb.capacity() - old_buf_size;
+    }
+    this.pad(align_size);
+  }
+  pad(byte_size) {
+    for (let i2 = 0; i2 < byte_size; i2++) {
+      this.bb.writeInt8(--this.space, 0);
+    }
+  }
+  writeInt8(value) {
+    this.bb.writeInt8(this.space -= 1, value);
+  }
+  writeInt16(value) {
+    this.bb.writeInt16(this.space -= 2, value);
+  }
+  writeInt32(value) {
+    this.bb.writeInt32(this.space -= 4, value);
+  }
+  writeInt64(value) {
+    this.bb.writeInt64(this.space -= 8, value);
+  }
+  writeFloat32(value) {
+    this.bb.writeFloat32(this.space -= 4, value);
+  }
+  writeFloat64(value) {
+    this.bb.writeFloat64(this.space -= 8, value);
+  }
+  /**
+   * Add an `int8` to the buffer, properly aligned, and grows the buffer (if necessary).
+   * @param value The `int8` to add the buffer.
+   */
+  addInt8(value) {
+    this.prep(1, 0);
+    this.writeInt8(value);
+  }
+  /**
+   * Add an `int16` to the buffer, properly aligned, and grows the buffer (if necessary).
+   * @param value The `int16` to add the buffer.
+   */
+  addInt16(value) {
+    this.prep(2, 0);
+    this.writeInt16(value);
+  }
+  /**
+   * Add an `int32` to the buffer, properly aligned, and grows the buffer (if necessary).
+   * @param value The `int32` to add the buffer.
+   */
+  addInt32(value) {
+    this.prep(4, 0);
+    this.writeInt32(value);
+  }
+  /**
+   * Add an `int64` to the buffer, properly aligned, and grows the buffer (if necessary).
+   * @param value The `int64` to add the buffer.
+   */
+  addInt64(value) {
+    this.prep(8, 0);
+    this.writeInt64(value);
+  }
+  /**
+   * Add a `float32` to the buffer, properly aligned, and grows the buffer (if necessary).
+   * @param value The `float32` to add the buffer.
+   */
+  addFloat32(value) {
+    this.prep(4, 0);
+    this.writeFloat32(value);
+  }
+  /**
+   * Add a `float64` to the buffer, properly aligned, and grows the buffer (if necessary).
+   * @param value The `float64` to add the buffer.
+   */
+  addFloat64(value) {
+    this.prep(8, 0);
+    this.writeFloat64(value);
+  }
+  addFieldInt8(voffset, value, defaultValue) {
+    if (this.force_defaults || value != defaultValue) {
+      this.addInt8(value);
+      this.slot(voffset);
+    }
+  }
+  addFieldInt16(voffset, value, defaultValue) {
+    if (this.force_defaults || value != defaultValue) {
+      this.addInt16(value);
+      this.slot(voffset);
+    }
+  }
+  addFieldInt32(voffset, value, defaultValue) {
+    if (this.force_defaults || value != defaultValue) {
+      this.addInt32(value);
+      this.slot(voffset);
+    }
+  }
+  addFieldInt64(voffset, value, defaultValue) {
+    if (this.force_defaults || value !== defaultValue) {
+      this.addInt64(value);
+      this.slot(voffset);
+    }
+  }
+  addFieldFloat32(voffset, value, defaultValue) {
+    if (this.force_defaults || value != defaultValue) {
+      this.addFloat32(value);
+      this.slot(voffset);
+    }
+  }
+  addFieldFloat64(voffset, value, defaultValue) {
+    if (this.force_defaults || value != defaultValue) {
+      this.addFloat64(value);
+      this.slot(voffset);
+    }
+  }
+  addFieldOffset(voffset, value, defaultValue) {
+    if (this.force_defaults || value != defaultValue) {
+      this.addOffset(value);
+      this.slot(voffset);
+    }
+  }
+  /**
+   * Structs are stored inline, so nothing additional is being added. `d` is always 0.
+   */
+  addFieldStruct(voffset, value, defaultValue) {
+    if (value != defaultValue) {
+      this.nested(value);
+      this.slot(voffset);
+    }
+  }
+  /**
+   * Structures are always stored inline, they need to be created right
+   * where they're used.  You'll get this assertion failure if you
+   * created it elsewhere.
+   */
+  nested(obj) {
+    if (obj != this.offset()) {
+      throw new TypeError("FlatBuffers: struct must be serialized inline.");
+    }
+  }
+  /**
+   * Should not be creating any other object, string or vector
+   * while an object is being constructed
+   */
+  notNested() {
+    if (this.isNested) {
+      throw new TypeError("FlatBuffers: object serialization must not be nested.");
+    }
+  }
+  /**
+   * Set the current vtable at `voffset` to the current location in the buffer.
+   */
+  slot(voffset) {
+    if (this.vtable !== null)
+      this.vtable[voffset] = this.offset();
+  }
+  /**
+   * @returns Offset relative to the end of the buffer.
+   */
+  offset() {
+    return this.bb.capacity() - this.space;
+  }
+  /**
+   * Doubles the size of the backing ByteBuffer and copies the old data towards
+   * the end of the new buffer (since we build the buffer backwards).
+   *
+   * @param bb The current buffer with the existing data
+   * @returns A new byte buffer with the old data copied
+   * to it. The data is located at the end of the buffer.
+   *
+   * uint8Array.set() formally takes {Array<number>|ArrayBufferView}, so to pass
+   * it a uint8Array we need to suppress the type check:
+   * @suppress {checkTypes}
+   */
+  static growByteBuffer(bb2) {
+    const old_buf_size = bb2.capacity();
+    if (old_buf_size & 3221225472) {
+      throw new Error("FlatBuffers: cannot grow buffer beyond 2 gigabytes.");
+    }
+    const new_buf_size = old_buf_size << 1;
+    const nbb = ByteBuffer$2.allocate(new_buf_size);
+    nbb.setPosition(new_buf_size - old_buf_size);
+    nbb.bytes().set(bb2.bytes(), new_buf_size - old_buf_size);
+    return nbb;
+  }
+  /**
+   * Adds on offset, relative to where it will be written.
+   *
+   * @param offset The offset to add.
+   */
+  addOffset(offset) {
+    this.prep(SIZEOF_INT, 0);
+    this.writeInt32(this.offset() - offset + SIZEOF_INT);
+  }
+  /**
+   * Start encoding a new object in the buffer.  Users will not usually need to
+   * call this directly. The FlatBuffers compiler will generate helper methods
+   * that call this method internally.
+   */
+  startObject(numfields) {
+    this.notNested();
+    if (this.vtable == null) {
+      this.vtable = [];
+    }
+    this.vtable_in_use = numfields;
+    for (let i2 = 0; i2 < numfields; i2++) {
+      this.vtable[i2] = 0;
+    }
+    this.isNested = true;
+    this.object_start = this.offset();
+  }
+  /**
+   * Finish off writing the object that is under construction.
+   *
+   * @returns The offset to the object inside `dataBuffer`
+   */
+  endObject() {
+    if (this.vtable == null || !this.isNested) {
+      throw new Error("FlatBuffers: endObject called without startObject");
+    }
+    this.addInt32(0);
+    const vtableloc = this.offset();
+    let i2 = this.vtable_in_use - 1;
+    for (; i2 >= 0 && this.vtable[i2] == 0; i2--) {
+    }
+    const trimmed_size = i2 + 1;
+    for (; i2 >= 0; i2--) {
+      this.addInt16(this.vtable[i2] != 0 ? vtableloc - this.vtable[i2] : 0);
+    }
+    const standard_fields = 2;
+    this.addInt16(vtableloc - this.object_start);
+    const len2 = (trimmed_size + standard_fields) * SIZEOF_SHORT;
+    this.addInt16(len2);
+    let existing_vtable = 0;
+    const vt1 = this.space;
+    outer_loop: for (i2 = 0; i2 < this.vtables.length; i2++) {
+      const vt2 = this.bb.capacity() - this.vtables[i2];
+      if (len2 == this.bb.readInt16(vt2)) {
+        for (let j2 = SIZEOF_SHORT; j2 < len2; j2 += SIZEOF_SHORT) {
+          if (this.bb.readInt16(vt1 + j2) != this.bb.readInt16(vt2 + j2)) {
+            continue outer_loop;
+          }
         }
-      };
-      return NewClass;
-    };
-    Class.include = function(props) {
-      var parentOptions = this.prototype.options;
-      extend(this.prototype, props);
-      if (props.options) {
-        this.prototype.options = parentOptions;
-        this.mergeOptions(props.options);
+        existing_vtable = this.vtables[i2];
+        break;
       }
-      return this;
-    };
-    Class.mergeOptions = function(options) {
-      extend(this.prototype.options, options);
-      return this;
-    };
-    Class.addInitHook = function(fn) {
-      var args = Array.prototype.slice.call(arguments, 1);
-      var init = typeof fn === "function" ? fn : function() {
-        this[fn].apply(this, args);
-      };
-      this.prototype._initHooks = this.prototype._initHooks || [];
-      this.prototype._initHooks.push(init);
-      return this;
-    };
-    function checkDeprecatedMixinEvents(includes) {
-      if (typeof L === "undefined" || !L || !L.Mixin) {
-        return;
+    }
+    if (existing_vtable) {
+      this.space = this.bb.capacity() - vtableloc;
+      this.bb.writeInt32(this.space, existing_vtable - vtableloc);
+    } else {
+      this.vtables.push(this.offset());
+      this.bb.writeInt32(this.bb.capacity() - vtableloc, this.offset() - vtableloc);
+    }
+    this.isNested = false;
+    return vtableloc;
+  }
+  /**
+   * Finalize a buffer, poiting to the given `root_table`.
+   */
+  finish(root_table, opt_file_identifier, opt_size_prefix) {
+    const size_prefix = opt_size_prefix ? SIZE_PREFIX_LENGTH : 0;
+    if (opt_file_identifier) {
+      const file_identifier = opt_file_identifier;
+      this.prep(this.minalign, SIZEOF_INT + FILE_IDENTIFIER_LENGTH + size_prefix);
+      if (file_identifier.length != FILE_IDENTIFIER_LENGTH) {
+        throw new TypeError("FlatBuffers: file identifier must be length " + FILE_IDENTIFIER_LENGTH);
       }
-      includes = isArray2(includes) ? includes : [includes];
-      for (var i = 0; i < includes.length; i++) {
-        if (includes[i] === L.Mixin.Events) {
-          console.warn("Deprecated include of L.Mixin.Events: this property will be removed in future releases, please inherit from L.Evented instead.", new Error().stack);
-        }
+      for (let i2 = FILE_IDENTIFIER_LENGTH - 1; i2 >= 0; i2--) {
+        this.writeInt8(file_identifier.charCodeAt(i2));
       }
     }
-    var Events = {
-      /* @method on(type: String, fn: Function, context?: Object): this
-       * Adds a listener function (`fn`) to a particular event type of the object. You can optionally specify the context of the listener (object the this keyword will point to). You can also pass several space-separated types (e.g. `'click dblclick'`).
-       *
-       * @alternative
-       * @method on(eventMap: Object): this
-       * Adds a set of type/listener pairs, e.g. `{click: onClick, mousemove: onMouseMove}`
-       */
-      on: function(types, fn, context) {
-        if (typeof types === "object") {
-          for (var type in types) {
-            this._on(type, types[type], fn);
-          }
-        } else {
-          types = splitWords(types);
-          for (var i = 0, len = types.length; i < len; i++) {
-            this._on(types[i], fn, context);
-          }
-        }
-        return this;
-      },
-      /* @method off(type: String, fn?: Function, context?: Object): this
-       * Removes a previously added listener function. If no function is specified, it will remove all the listeners of that particular event from the object. Note that if you passed a custom context to `on`, you must pass the same context to `off` in order to remove the listener.
-       *
-       * @alternative
-       * @method off(eventMap: Object): this
-       * Removes a set of type/listener pairs.
-       *
-       * @alternative
-       * @method off: this
-       * Removes all listeners to all events on the object. This includes implicitly attached events.
-       */
-      off: function(types, fn, context) {
-        if (!arguments.length) {
-          delete this._events;
-        } else if (typeof types === "object") {
-          for (var type in types) {
-            this._off(type, types[type], fn);
-          }
-        } else {
-          types = splitWords(types);
-          var removeAll = arguments.length === 1;
-          for (var i = 0, len = types.length; i < len; i++) {
-            if (removeAll) {
-              this._off(types[i]);
-            } else {
-              this._off(types[i], fn, context);
-            }
-          }
-        }
-        return this;
-      },
-      // attach listener (without syntactic sugar now)
-      _on: function(type, fn, context, _once) {
-        if (typeof fn !== "function") {
-          console.warn("wrong listener type: " + typeof fn);
-          return;
-        }
-        if (this._listens(type, fn, context) !== false) {
-          return;
-        }
-        if (context === this) {
-          context = void 0;
-        }
-        var newListener = { fn, ctx: context };
-        if (_once) {
-          newListener.once = true;
-        }
-        this._events = this._events || {};
-        this._events[type] = this._events[type] || [];
-        this._events[type].push(newListener);
-      },
-      _off: function(type, fn, context) {
-        var listeners, i, len;
-        if (!this._events) {
-          return;
-        }
-        listeners = this._events[type];
-        if (!listeners) {
-          return;
-        }
-        if (arguments.length === 1) {
-          if (this._firingCount) {
-            for (i = 0, len = listeners.length; i < len; i++) {
-              listeners[i].fn = falseFn;
-            }
-          }
-          delete this._events[type];
-          return;
-        }
-        if (typeof fn !== "function") {
-          console.warn("wrong listener type: " + typeof fn);
-          return;
-        }
-        var index2 = this._listens(type, fn, context);
-        if (index2 !== false) {
-          var listener = listeners[index2];
-          if (this._firingCount) {
-            listener.fn = falseFn;
-            this._events[type] = listeners = listeners.slice();
-          }
-          listeners.splice(index2, 1);
-        }
-      },
-      // @method fire(type: String, data?: Object, propagate?: Boolean): this
-      // Fires an event of the specified type. You can optionally provide a data
-      // object — the first argument of the listener function will contain its
-      // properties. The event can optionally be propagated to event parents.
-      fire: function(type, data, propagate) {
-        if (!this.listens(type, propagate)) {
-          return this;
-        }
-        var event = extend({}, data, {
-          type,
-          target: this,
-          sourceTarget: data && data.sourceTarget || this
-        });
-        if (this._events) {
-          var listeners = this._events[type];
-          if (listeners) {
-            this._firingCount = this._firingCount + 1 || 1;
-            for (var i = 0, len = listeners.length; i < len; i++) {
-              var l2 = listeners[i];
-              var fn = l2.fn;
-              if (l2.once) {
-                this.off(type, fn, l2.ctx);
-              }
-              fn.call(l2.ctx || this, event);
-            }
-            this._firingCount--;
-          }
-        }
-        if (propagate) {
-          this._propagateEvent(event);
-        }
-        return this;
-      },
-      // @method listens(type: String, propagate?: Boolean): Boolean
-      // @method listens(type: String, fn: Function, context?: Object, propagate?: Boolean): Boolean
-      // Returns `true` if a particular event type has any listeners attached to it.
-      // The verification can optionally be propagated, it will return `true` if parents have the listener attached to it.
-      listens: function(type, fn, context, propagate) {
-        if (typeof type !== "string") {
-          console.warn('"string" type argument expected');
-        }
-        var _fn = fn;
-        if (typeof fn !== "function") {
-          propagate = !!fn;
-          _fn = void 0;
-          context = void 0;
-        }
-        var listeners = this._events && this._events[type];
-        if (listeners && listeners.length) {
-          if (this._listens(type, _fn, context) !== false) {
-            return true;
-          }
-        }
-        if (propagate) {
-          for (var id2 in this._eventParents) {
-            if (this._eventParents[id2].listens(type, fn, context, propagate)) {
-              return true;
-            }
-          }
-        }
-        return false;
-      },
-      // returns the index (number) or false
-      _listens: function(type, fn, context) {
-        if (!this._events) {
-          return false;
-        }
-        var listeners = this._events[type] || [];
-        if (!fn) {
-          return !!listeners.length;
-        }
-        if (context === this) {
-          context = void 0;
-        }
-        for (var i = 0, len = listeners.length; i < len; i++) {
-          if (listeners[i].fn === fn && listeners[i].ctx === context) {
-            return i;
-          }
-        }
-        return false;
-      },
-      // @method once(…): this
-      // Behaves as [`on(…)`](#evented-on), except the listener will only get fired once and then removed.
-      once: function(types, fn, context) {
-        if (typeof types === "object") {
-          for (var type in types) {
-            this._on(type, types[type], fn, true);
-          }
-        } else {
-          types = splitWords(types);
-          for (var i = 0, len = types.length; i < len; i++) {
-            this._on(types[i], fn, context, true);
-          }
-        }
-        return this;
-      },
-      // @method addEventParent(obj: Evented): this
-      // Adds an event parent - an `Evented` that will receive propagated events
-      addEventParent: function(obj) {
-        this._eventParents = this._eventParents || {};
-        this._eventParents[stamp(obj)] = obj;
-        return this;
-      },
-      // @method removeEventParent(obj: Evented): this
-      // Removes an event parent, so it will stop receiving propagated events
-      removeEventParent: function(obj) {
-        if (this._eventParents) {
-          delete this._eventParents[stamp(obj)];
-        }
-        return this;
-      },
-      _propagateEvent: function(e) {
-        for (var id2 in this._eventParents) {
-          this._eventParents[id2].fire(e.type, extend({
-            layer: e.target,
-            propagatedFrom: e.target
-          }, e), true);
-        }
-      }
-    };
-    Events.addEventListener = Events.on;
-    Events.removeEventListener = Events.clearAllEventListeners = Events.off;
-    Events.addOneTimeEventListener = Events.once;
-    Events.fireEvent = Events.fire;
-    Events.hasEventListeners = Events.listens;
-    var Evented = Class.extend(Events);
-    function Point(x2, y2, round2) {
-      this.x = round2 ? Math.round(x2) : x2;
-      this.y = round2 ? Math.round(y2) : y2;
-    }
-    var trunc = Math.trunc || function(v2) {
-      return v2 > 0 ? Math.floor(v2) : Math.ceil(v2);
-    };
-    Point.prototype = {
-      // @method clone(): Point
-      // Returns a copy of the current point.
-      clone: function() {
-        return new Point(this.x, this.y);
-      },
-      // @method add(otherPoint: Point): Point
-      // Returns the result of addition of the current and the given points.
-      add: function(point) {
-        return this.clone()._add(toPoint(point));
-      },
-      _add: function(point) {
-        this.x += point.x;
-        this.y += point.y;
-        return this;
-      },
-      // @method subtract(otherPoint: Point): Point
-      // Returns the result of subtraction of the given point from the current.
-      subtract: function(point) {
-        return this.clone()._subtract(toPoint(point));
-      },
-      _subtract: function(point) {
-        this.x -= point.x;
-        this.y -= point.y;
-        return this;
-      },
-      // @method divideBy(num: Number): Point
-      // Returns the result of division of the current point by the given number.
-      divideBy: function(num) {
-        return this.clone()._divideBy(num);
-      },
-      _divideBy: function(num) {
-        this.x /= num;
-        this.y /= num;
-        return this;
-      },
-      // @method multiplyBy(num: Number): Point
-      // Returns the result of multiplication of the current point by the given number.
-      multiplyBy: function(num) {
-        return this.clone()._multiplyBy(num);
-      },
-      _multiplyBy: function(num) {
-        this.x *= num;
-        this.y *= num;
-        return this;
-      },
-      // @method scaleBy(scale: Point): Point
-      // Multiply each coordinate of the current point by each coordinate of
-      // `scale`. In linear algebra terms, multiply the point by the
-      // [scaling matrix](https://en.wikipedia.org/wiki/Scaling_%28geometry%29#Matrix_representation)
-      // defined by `scale`.
-      scaleBy: function(point) {
-        return new Point(this.x * point.x, this.y * point.y);
-      },
-      // @method unscaleBy(scale: Point): Point
-      // Inverse of `scaleBy`. Divide each coordinate of the current point by
-      // each coordinate of `scale`.
-      unscaleBy: function(point) {
-        return new Point(this.x / point.x, this.y / point.y);
-      },
-      // @method round(): Point
-      // Returns a copy of the current point with rounded coordinates.
-      round: function() {
-        return this.clone()._round();
-      },
-      _round: function() {
-        this.x = Math.round(this.x);
-        this.y = Math.round(this.y);
-        return this;
-      },
-      // @method floor(): Point
-      // Returns a copy of the current point with floored coordinates (rounded down).
-      floor: function() {
-        return this.clone()._floor();
-      },
-      _floor: function() {
-        this.x = Math.floor(this.x);
-        this.y = Math.floor(this.y);
-        return this;
-      },
-      // @method ceil(): Point
-      // Returns a copy of the current point with ceiled coordinates (rounded up).
-      ceil: function() {
-        return this.clone()._ceil();
-      },
-      _ceil: function() {
-        this.x = Math.ceil(this.x);
-        this.y = Math.ceil(this.y);
-        return this;
-      },
-      // @method trunc(): Point
-      // Returns a copy of the current point with truncated coordinates (rounded towards zero).
-      trunc: function() {
-        return this.clone()._trunc();
-      },
-      _trunc: function() {
-        this.x = trunc(this.x);
-        this.y = trunc(this.y);
-        return this;
-      },
-      // @method distanceTo(otherPoint: Point): Number
-      // Returns the cartesian distance between the current and the given points.
-      distanceTo: function(point) {
-        point = toPoint(point);
-        var x2 = point.x - this.x, y2 = point.y - this.y;
-        return Math.sqrt(x2 * x2 + y2 * y2);
-      },
-      // @method equals(otherPoint: Point): Boolean
-      // Returns `true` if the given point has the same coordinates.
-      equals: function(point) {
-        point = toPoint(point);
-        return point.x === this.x && point.y === this.y;
-      },
-      // @method contains(otherPoint: Point): Boolean
-      // Returns `true` if both coordinates of the given point are less than the corresponding current point coordinates (in absolute values).
-      contains: function(point) {
-        point = toPoint(point);
-        return Math.abs(point.x) <= Math.abs(this.x) && Math.abs(point.y) <= Math.abs(this.y);
-      },
-      // @method toString(): String
-      // Returns a string representation of the point for debugging purposes.
-      toString: function() {
-        return "Point(" + formatNum(this.x) + ", " + formatNum(this.y) + ")";
-      }
-    };
-    function toPoint(x2, y2, round2) {
-      if (x2 instanceof Point) {
-        return x2;
-      }
-      if (isArray2(x2)) {
-        return new Point(x2[0], x2[1]);
-      }
-      if (x2 === void 0 || x2 === null) {
-        return x2;
-      }
-      if (typeof x2 === "object" && "x" in x2 && "y" in x2) {
-        return new Point(x2.x, x2.y);
-      }
-      return new Point(x2, y2, round2);
-    }
-    function Bounds(a, b) {
-      if (!a) {
-        return;
-      }
-      var points = b ? [a, b] : a;
-      for (var i = 0, len = points.length; i < len; i++) {
-        this.extend(points[i]);
-      }
-    }
-    Bounds.prototype = {
-      // @method extend(point: Point): this
-      // Extends the bounds to contain the given point.
-      // @alternative
-      // @method extend(otherBounds: Bounds): this
-      // Extend the bounds to contain the given bounds
-      extend: function(obj) {
-        var min2, max2;
-        if (!obj) {
-          return this;
-        }
-        if (obj instanceof Point || typeof obj[0] === "number" || "x" in obj) {
-          min2 = max2 = toPoint(obj);
-        } else {
-          obj = toBounds(obj);
-          min2 = obj.min;
-          max2 = obj.max;
-          if (!min2 || !max2) {
-            return this;
-          }
-        }
-        if (!this.min && !this.max) {
-          this.min = min2.clone();
-          this.max = max2.clone();
-        } else {
-          this.min.x = Math.min(min2.x, this.min.x);
-          this.max.x = Math.max(max2.x, this.max.x);
-          this.min.y = Math.min(min2.y, this.min.y);
-          this.max.y = Math.max(max2.y, this.max.y);
-        }
-        return this;
-      },
-      // @method getCenter(round?: Boolean): Point
-      // Returns the center point of the bounds.
-      getCenter: function(round2) {
-        return toPoint(
-          (this.min.x + this.max.x) / 2,
-          (this.min.y + this.max.y) / 2,
-          round2
-        );
-      },
-      // @method getBottomLeft(): Point
-      // Returns the bottom-left point of the bounds.
-      getBottomLeft: function() {
-        return toPoint(this.min.x, this.max.y);
-      },
-      // @method getTopRight(): Point
-      // Returns the top-right point of the bounds.
-      getTopRight: function() {
-        return toPoint(this.max.x, this.min.y);
-      },
-      // @method getTopLeft(): Point
-      // Returns the top-left point of the bounds (i.e. [`this.min`](#bounds-min)).
-      getTopLeft: function() {
-        return this.min;
-      },
-      // @method getBottomRight(): Point
-      // Returns the bottom-right point of the bounds (i.e. [`this.max`](#bounds-max)).
-      getBottomRight: function() {
-        return this.max;
-      },
-      // @method getSize(): Point
-      // Returns the size of the given bounds
-      getSize: function() {
-        return this.max.subtract(this.min);
-      },
-      // @method contains(otherBounds: Bounds): Boolean
-      // Returns `true` if the rectangle contains the given one.
-      // @alternative
-      // @method contains(point: Point): Boolean
-      // Returns `true` if the rectangle contains the given point.
-      contains: function(obj) {
-        var min, max;
-        if (typeof obj[0] === "number" || obj instanceof Point) {
-          obj = toPoint(obj);
-        } else {
-          obj = toBounds(obj);
-        }
-        if (obj instanceof Bounds) {
-          min = obj.min;
-          max = obj.max;
-        } else {
-          min = max = obj;
-        }
-        return min.x >= this.min.x && max.x <= this.max.x && min.y >= this.min.y && max.y <= this.max.y;
-      },
-      // @method intersects(otherBounds: Bounds): Boolean
-      // Returns `true` if the rectangle intersects the given bounds. Two bounds
-      // intersect if they have at least one point in common.
-      intersects: function(bounds) {
-        bounds = toBounds(bounds);
-        var min = this.min, max = this.max, min2 = bounds.min, max2 = bounds.max, xIntersects = max2.x >= min.x && min2.x <= max.x, yIntersects = max2.y >= min.y && min2.y <= max.y;
-        return xIntersects && yIntersects;
-      },
-      // @method overlaps(otherBounds: Bounds): Boolean
-      // Returns `true` if the rectangle overlaps the given bounds. Two bounds
-      // overlap if their intersection is an area.
-      overlaps: function(bounds) {
-        bounds = toBounds(bounds);
-        var min = this.min, max = this.max, min2 = bounds.min, max2 = bounds.max, xOverlaps = max2.x > min.x && min2.x < max.x, yOverlaps = max2.y > min.y && min2.y < max.y;
-        return xOverlaps && yOverlaps;
-      },
-      // @method isValid(): Boolean
-      // Returns `true` if the bounds are properly initialized.
-      isValid: function() {
-        return !!(this.min && this.max);
-      },
-      // @method pad(bufferRatio: Number): Bounds
-      // Returns bounds created by extending or retracting the current bounds by a given ratio in each direction.
-      // For example, a ratio of 0.5 extends the bounds by 50% in each direction.
-      // Negative values will retract the bounds.
-      pad: function(bufferRatio) {
-        var min = this.min, max = this.max, heightBuffer = Math.abs(min.x - max.x) * bufferRatio, widthBuffer = Math.abs(min.y - max.y) * bufferRatio;
-        return toBounds(
-          toPoint(min.x - heightBuffer, min.y - widthBuffer),
-          toPoint(max.x + heightBuffer, max.y + widthBuffer)
-        );
-      },
-      // @method equals(otherBounds: Bounds): Boolean
-      // Returns `true` if the rectangle is equivalent to the given bounds.
-      equals: function(bounds) {
-        if (!bounds) {
-          return false;
-        }
-        bounds = toBounds(bounds);
-        return this.min.equals(bounds.getTopLeft()) && this.max.equals(bounds.getBottomRight());
-      }
-    };
-    function toBounds(a, b) {
-      if (!a || a instanceof Bounds) {
-        return a;
-      }
-      return new Bounds(a, b);
-    }
-    function LatLngBounds(corner1, corner2) {
-      if (!corner1) {
-        return;
-      }
-      var latlngs = corner2 ? [corner1, corner2] : corner1;
-      for (var i = 0, len = latlngs.length; i < len; i++) {
-        this.extend(latlngs[i]);
-      }
-    }
-    LatLngBounds.prototype = {
-      // @method extend(latlng: LatLng): this
-      // Extend the bounds to contain the given point
-      // @alternative
-      // @method extend(otherBounds: LatLngBounds): this
-      // Extend the bounds to contain the given bounds
-      extend: function(obj) {
-        var sw = this._southWest, ne2 = this._northEast, sw2, ne22;
-        if (obj instanceof LatLng) {
-          sw2 = obj;
-          ne22 = obj;
-        } else if (obj instanceof LatLngBounds) {
-          sw2 = obj._southWest;
-          ne22 = obj._northEast;
-          if (!sw2 || !ne22) {
-            return this;
-          }
-        } else {
-          return obj ? this.extend(toLatLng(obj) || toLatLngBounds(obj)) : this;
-        }
-        if (!sw && !ne2) {
-          this._southWest = new LatLng(sw2.lat, sw2.lng);
-          this._northEast = new LatLng(ne22.lat, ne22.lng);
-        } else {
-          sw.lat = Math.min(sw2.lat, sw.lat);
-          sw.lng = Math.min(sw2.lng, sw.lng);
-          ne2.lat = Math.max(ne22.lat, ne2.lat);
-          ne2.lng = Math.max(ne22.lng, ne2.lng);
-        }
-        return this;
-      },
-      // @method pad(bufferRatio: Number): LatLngBounds
-      // Returns bounds created by extending or retracting the current bounds by a given ratio in each direction.
-      // For example, a ratio of 0.5 extends the bounds by 50% in each direction.
-      // Negative values will retract the bounds.
-      pad: function(bufferRatio) {
-        var sw = this._southWest, ne2 = this._northEast, heightBuffer = Math.abs(sw.lat - ne2.lat) * bufferRatio, widthBuffer = Math.abs(sw.lng - ne2.lng) * bufferRatio;
-        return new LatLngBounds(
-          new LatLng(sw.lat - heightBuffer, sw.lng - widthBuffer),
-          new LatLng(ne2.lat + heightBuffer, ne2.lng + widthBuffer)
-        );
-      },
-      // @method getCenter(): LatLng
-      // Returns the center point of the bounds.
-      getCenter: function() {
-        return new LatLng(
-          (this._southWest.lat + this._northEast.lat) / 2,
-          (this._southWest.lng + this._northEast.lng) / 2
-        );
-      },
-      // @method getSouthWest(): LatLng
-      // Returns the south-west point of the bounds.
-      getSouthWest: function() {
-        return this._southWest;
-      },
-      // @method getNorthEast(): LatLng
-      // Returns the north-east point of the bounds.
-      getNorthEast: function() {
-        return this._northEast;
-      },
-      // @method getNorthWest(): LatLng
-      // Returns the north-west point of the bounds.
-      getNorthWest: function() {
-        return new LatLng(this.getNorth(), this.getWest());
-      },
-      // @method getSouthEast(): LatLng
-      // Returns the south-east point of the bounds.
-      getSouthEast: function() {
-        return new LatLng(this.getSouth(), this.getEast());
-      },
-      // @method getWest(): Number
-      // Returns the west longitude of the bounds
-      getWest: function() {
-        return this._southWest.lng;
-      },
-      // @method getSouth(): Number
-      // Returns the south latitude of the bounds
-      getSouth: function() {
-        return this._southWest.lat;
-      },
-      // @method getEast(): Number
-      // Returns the east longitude of the bounds
-      getEast: function() {
-        return this._northEast.lng;
-      },
-      // @method getNorth(): Number
-      // Returns the north latitude of the bounds
-      getNorth: function() {
-        return this._northEast.lat;
-      },
-      // @method contains(otherBounds: LatLngBounds): Boolean
-      // Returns `true` if the rectangle contains the given one.
-      // @alternative
-      // @method contains (latlng: LatLng): Boolean
-      // Returns `true` if the rectangle contains the given point.
-      contains: function(obj) {
-        if (typeof obj[0] === "number" || obj instanceof LatLng || "lat" in obj) {
-          obj = toLatLng(obj);
-        } else {
-          obj = toLatLngBounds(obj);
-        }
-        var sw = this._southWest, ne2 = this._northEast, sw2, ne22;
-        if (obj instanceof LatLngBounds) {
-          sw2 = obj.getSouthWest();
-          ne22 = obj.getNorthEast();
-        } else {
-          sw2 = ne22 = obj;
-        }
-        return sw2.lat >= sw.lat && ne22.lat <= ne2.lat && sw2.lng >= sw.lng && ne22.lng <= ne2.lng;
-      },
-      // @method intersects(otherBounds: LatLngBounds): Boolean
-      // Returns `true` if the rectangle intersects the given bounds. Two bounds intersect if they have at least one point in common.
-      intersects: function(bounds) {
-        bounds = toLatLngBounds(bounds);
-        var sw = this._southWest, ne2 = this._northEast, sw2 = bounds.getSouthWest(), ne22 = bounds.getNorthEast(), latIntersects = ne22.lat >= sw.lat && sw2.lat <= ne2.lat, lngIntersects = ne22.lng >= sw.lng && sw2.lng <= ne2.lng;
-        return latIntersects && lngIntersects;
-      },
-      // @method overlaps(otherBounds: LatLngBounds): Boolean
-      // Returns `true` if the rectangle overlaps the given bounds. Two bounds overlap if their intersection is an area.
-      overlaps: function(bounds) {
-        bounds = toLatLngBounds(bounds);
-        var sw = this._southWest, ne2 = this._northEast, sw2 = bounds.getSouthWest(), ne22 = bounds.getNorthEast(), latOverlaps = ne22.lat > sw.lat && sw2.lat < ne2.lat, lngOverlaps = ne22.lng > sw.lng && sw2.lng < ne2.lng;
-        return latOverlaps && lngOverlaps;
-      },
-      // @method toBBoxString(): String
-      // Returns a string with bounding box coordinates in a 'southwest_lng,southwest_lat,northeast_lng,northeast_lat' format. Useful for sending requests to web services that return geo data.
-      toBBoxString: function() {
-        return [this.getWest(), this.getSouth(), this.getEast(), this.getNorth()].join(",");
-      },
-      // @method equals(otherBounds: LatLngBounds, maxMargin?: Number): Boolean
-      // Returns `true` if the rectangle is equivalent (within a small margin of error) to the given bounds. The margin of error can be overridden by setting `maxMargin` to a small number.
-      equals: function(bounds, maxMargin) {
-        if (!bounds) {
-          return false;
-        }
-        bounds = toLatLngBounds(bounds);
-        return this._southWest.equals(bounds.getSouthWest(), maxMargin) && this._northEast.equals(bounds.getNorthEast(), maxMargin);
-      },
-      // @method isValid(): Boolean
-      // Returns `true` if the bounds are properly initialized.
-      isValid: function() {
-        return !!(this._southWest && this._northEast);
-      }
-    };
-    function toLatLngBounds(a, b) {
-      if (a instanceof LatLngBounds) {
-        return a;
-      }
-      return new LatLngBounds(a, b);
-    }
-    function LatLng(lat, lng, alt) {
-      if (isNaN(lat) || isNaN(lng)) {
-        throw new Error("Invalid LatLng object: (" + lat + ", " + lng + ")");
-      }
-      this.lat = +lat;
-      this.lng = +lng;
-      if (alt !== void 0) {
-        this.alt = +alt;
-      }
-    }
-    LatLng.prototype = {
-      // @method equals(otherLatLng: LatLng, maxMargin?: Number): Boolean
-      // Returns `true` if the given `LatLng` point is at the same position (within a small margin of error). The margin of error can be overridden by setting `maxMargin` to a small number.
-      equals: function(obj, maxMargin) {
-        if (!obj) {
-          return false;
-        }
-        obj = toLatLng(obj);
-        var margin = Math.max(
-          Math.abs(this.lat - obj.lat),
-          Math.abs(this.lng - obj.lng)
-        );
-        return margin <= (maxMargin === void 0 ? 1e-9 : maxMargin);
-      },
-      // @method toString(): String
-      // Returns a string representation of the point (for debugging purposes).
-      toString: function(precision) {
-        return "LatLng(" + formatNum(this.lat, precision) + ", " + formatNum(this.lng, precision) + ")";
-      },
-      // @method distanceTo(otherLatLng: LatLng): Number
-      // Returns the distance (in meters) to the given `LatLng` calculated using the [Spherical Law of Cosines](https://en.wikipedia.org/wiki/Spherical_law_of_cosines).
-      distanceTo: function(other) {
-        return Earth.distance(this, toLatLng(other));
-      },
-      // @method wrap(): LatLng
-      // Returns a new `LatLng` object with the longitude wrapped so it's always between -180 and +180 degrees.
-      wrap: function() {
-        return Earth.wrapLatLng(this);
-      },
-      // @method toBounds(sizeInMeters: Number): LatLngBounds
-      // Returns a new `LatLngBounds` object in which each boundary is `sizeInMeters/2` meters apart from the `LatLng`.
-      toBounds: function(sizeInMeters) {
-        var latAccuracy = 180 * sizeInMeters / 40075017, lngAccuracy = latAccuracy / Math.cos(Math.PI / 180 * this.lat);
-        return toLatLngBounds(
-          [this.lat - latAccuracy, this.lng - lngAccuracy],
-          [this.lat + latAccuracy, this.lng + lngAccuracy]
-        );
-      },
-      clone: function() {
-        return new LatLng(this.lat, this.lng, this.alt);
-      }
-    };
-    function toLatLng(a, b, c) {
-      if (a instanceof LatLng) {
-        return a;
-      }
-      if (isArray2(a) && typeof a[0] !== "object") {
-        if (a.length === 3) {
-          return new LatLng(a[0], a[1], a[2]);
-        }
-        if (a.length === 2) {
-          return new LatLng(a[0], a[1]);
-        }
-        return null;
-      }
-      if (a === void 0 || a === null) {
-        return a;
-      }
-      if (typeof a === "object" && "lat" in a) {
-        return new LatLng(a.lat, "lng" in a ? a.lng : a.lon, a.alt);
-      }
-      if (b === void 0) {
-        return null;
-      }
-      return new LatLng(a, b, c);
-    }
-    var CRS = {
-      // @method latLngToPoint(latlng: LatLng, zoom: Number): Point
-      // Projects geographical coordinates into pixel coordinates for a given zoom.
-      latLngToPoint: function(latlng, zoom2) {
-        var projectedPoint = this.projection.project(latlng), scale2 = this.scale(zoom2);
-        return this.transformation._transform(projectedPoint, scale2);
-      },
-      // @method pointToLatLng(point: Point, zoom: Number): LatLng
-      // The inverse of `latLngToPoint`. Projects pixel coordinates on a given
-      // zoom into geographical coordinates.
-      pointToLatLng: function(point, zoom2) {
-        var scale2 = this.scale(zoom2), untransformedPoint = this.transformation.untransform(point, scale2);
-        return this.projection.unproject(untransformedPoint);
-      },
-      // @method project(latlng: LatLng): Point
-      // Projects geographical coordinates into coordinates in units accepted for
-      // this CRS (e.g. meters for EPSG:3857, for passing it to WMS services).
-      project: function(latlng) {
-        return this.projection.project(latlng);
-      },
-      // @method unproject(point: Point): LatLng
-      // Given a projected coordinate returns the corresponding LatLng.
-      // The inverse of `project`.
-      unproject: function(point) {
-        return this.projection.unproject(point);
-      },
-      // @method scale(zoom: Number): Number
-      // Returns the scale used when transforming projected coordinates into
-      // pixel coordinates for a particular zoom. For example, it returns
-      // `256 * 2^zoom` for Mercator-based CRS.
-      scale: function(zoom2) {
-        return 256 * Math.pow(2, zoom2);
-      },
-      // @method zoom(scale: Number): Number
-      // Inverse of `scale()`, returns the zoom level corresponding to a scale
-      // factor of `scale`.
-      zoom: function(scale2) {
-        return Math.log(scale2 / 256) / Math.LN2;
-      },
-      // @method getProjectedBounds(zoom: Number): Bounds
-      // Returns the projection's bounds scaled and transformed for the provided `zoom`.
-      getProjectedBounds: function(zoom2) {
-        if (this.infinite) {
-          return null;
-        }
-        var b = this.projection.bounds, s = this.scale(zoom2), min = this.transformation.transform(b.min, s), max = this.transformation.transform(b.max, s);
-        return new Bounds(min, max);
-      },
-      // @method distance(latlng1: LatLng, latlng2: LatLng): Number
-      // Returns the distance between two geographical coordinates.
-      // @property code: String
-      // Standard code name of the CRS passed into WMS services (e.g. `'EPSG:3857'`)
-      //
-      // @property wrapLng: Number[]
-      // An array of two numbers defining whether the longitude (horizontal) coordinate
-      // axis wraps around a given range and how. Defaults to `[-180, 180]` in most
-      // geographical CRSs. If `undefined`, the longitude axis does not wrap around.
-      //
-      // @property wrapLat: Number[]
-      // Like `wrapLng`, but for the latitude (vertical) axis.
-      // wrapLng: [min, max],
-      // wrapLat: [min, max],
-      // @property infinite: Boolean
-      // If true, the coordinate space will be unbounded (infinite in both axes)
-      infinite: false,
-      // @method wrapLatLng(latlng: LatLng): LatLng
-      // Returns a `LatLng` where lat and lng has been wrapped according to the
-      // CRS's `wrapLat` and `wrapLng` properties, if they are outside the CRS's bounds.
-      wrapLatLng: function(latlng) {
-        var lng = this.wrapLng ? wrapNum(latlng.lng, this.wrapLng, true) : latlng.lng, lat = this.wrapLat ? wrapNum(latlng.lat, this.wrapLat, true) : latlng.lat, alt = latlng.alt;
-        return new LatLng(lat, lng, alt);
-      },
-      // @method wrapLatLngBounds(bounds: LatLngBounds): LatLngBounds
-      // Returns a `LatLngBounds` with the same size as the given one, ensuring
-      // that its center is within the CRS's bounds.
-      // Only accepts actual `L.LatLngBounds` instances, not arrays.
-      wrapLatLngBounds: function(bounds) {
-        var center = bounds.getCenter(), newCenter = this.wrapLatLng(center), latShift = center.lat - newCenter.lat, lngShift = center.lng - newCenter.lng;
-        if (latShift === 0 && lngShift === 0) {
-          return bounds;
-        }
-        var sw = bounds.getSouthWest(), ne2 = bounds.getNorthEast(), newSw = new LatLng(sw.lat - latShift, sw.lng - lngShift), newNe = new LatLng(ne2.lat - latShift, ne2.lng - lngShift);
-        return new LatLngBounds(newSw, newNe);
-      }
-    };
-    var Earth = extend({}, CRS, {
-      wrapLng: [-180, 180],
-      // Mean Earth Radius, as recommended for use by
-      // the International Union of Geodesy and Geophysics,
-      // see https://rosettacode.org/wiki/Haversine_formula
-      R: 6371e3,
-      // distance between two geographical points using spherical law of cosines approximation
-      distance: function(latlng1, latlng2) {
-        var rad = Math.PI / 180, lat1 = latlng1.lat * rad, lat2 = latlng2.lat * rad, sinDLat = Math.sin((latlng2.lat - latlng1.lat) * rad / 2), sinDLon = Math.sin((latlng2.lng - latlng1.lng) * rad / 2), a = sinDLat * sinDLat + Math.cos(lat1) * Math.cos(lat2) * sinDLon * sinDLon, c = 2 * Math.atan2(Math.sqrt(a), Math.sqrt(1 - a));
-        return this.R * c;
-      }
-    });
-    var earthRadius = 6378137;
-    var SphericalMercator = {
-      R: earthRadius,
-      MAX_LATITUDE: 85.0511287798,
-      project: function(latlng) {
-        var d = Math.PI / 180, max = this.MAX_LATITUDE, lat = Math.max(Math.min(max, latlng.lat), -max), sin = Math.sin(lat * d);
-        return new Point(
-          this.R * latlng.lng * d,
-          this.R * Math.log((1 + sin) / (1 - sin)) / 2
-        );
-      },
-      unproject: function(point) {
-        var d = 180 / Math.PI;
-        return new LatLng(
-          (2 * Math.atan(Math.exp(point.y / this.R)) - Math.PI / 2) * d,
-          point.x * d / this.R
-        );
-      },
-      bounds: function() {
-        var d = earthRadius * Math.PI;
-        return new Bounds([-d, -d], [d, d]);
-      }()
-    };
-    function Transformation(a, b, c, d) {
-      if (isArray2(a)) {
-        this._a = a[0];
-        this._b = a[1];
-        this._c = a[2];
-        this._d = a[3];
-        return;
-      }
-      this._a = a;
-      this._b = b;
-      this._c = c;
-      this._d = d;
-    }
-    Transformation.prototype = {
-      // @method transform(point: Point, scale?: Number): Point
-      // Returns a transformed point, optionally multiplied by the given scale.
-      // Only accepts actual `L.Point` instances, not arrays.
-      transform: function(point, scale2) {
-        return this._transform(point.clone(), scale2);
-      },
-      // destructive transform (faster)
-      _transform: function(point, scale2) {
-        scale2 = scale2 || 1;
-        point.x = scale2 * (this._a * point.x + this._b);
-        point.y = scale2 * (this._c * point.y + this._d);
-        return point;
-      },
-      // @method untransform(point: Point, scale?: Number): Point
-      // Returns the reverse transformation of the given point, optionally divided
-      // by the given scale. Only accepts actual `L.Point` instances, not arrays.
-      untransform: function(point, scale2) {
-        scale2 = scale2 || 1;
-        return new Point(
-          (point.x / scale2 - this._b) / this._a,
-          (point.y / scale2 - this._d) / this._c
-        );
-      }
-    };
-    function toTransformation(a, b, c, d) {
-      return new Transformation(a, b, c, d);
-    }
-    var EPSG3857 = extend({}, Earth, {
-      code: "EPSG:3857",
-      projection: SphericalMercator,
-      transformation: function() {
-        var scale2 = 0.5 / (Math.PI * SphericalMercator.R);
-        return toTransformation(scale2, 0.5, -scale2, 0.5);
-      }()
-    });
-    var EPSG900913 = extend({}, EPSG3857, {
-      code: "EPSG:900913"
-    });
-    function svgCreate(name) {
-      return document.createElementNS("http://www.w3.org/2000/svg", name);
-    }
-    function pointsToPath(rings, closed) {
-      var str = "", i, j, len, len2, points, p2;
-      for (i = 0, len = rings.length; i < len; i++) {
-        points = rings[i];
-        for (j = 0, len2 = points.length; j < len2; j++) {
-          p2 = points[j];
-          str += (j ? "L" : "M") + p2.x + " " + p2.y;
-        }
-        str += closed ? Browser.svg ? "z" : "x" : "";
-      }
-      return str || "M0 0";
-    }
-    var style = document.documentElement.style;
-    var ie2 = "ActiveXObject" in window;
-    var ielt9 = ie2 && !document.addEventListener;
-    var edge = "msLaunchUri" in navigator && !("documentMode" in document);
-    var webkit = userAgentContains("webkit");
-    var android = userAgentContains("android");
-    var android23 = userAgentContains("android 2") || userAgentContains("android 3");
-    var webkitVer = parseInt(/WebKit\/([0-9]+)|$/.exec(navigator.userAgent)[1], 10);
-    var androidStock = android && userAgentContains("Google") && webkitVer < 537 && !("AudioNode" in window);
-    var opera = !!window.opera;
-    var chrome = !edge && userAgentContains("chrome");
-    var gecko = userAgentContains("gecko") && !webkit && !opera && !ie2;
-    var safari = !chrome && userAgentContains("safari");
-    var phantom = userAgentContains("phantom");
-    var opera12 = "OTransition" in style;
-    var win = navigator.platform.indexOf("Win") === 0;
-    var ie3d = ie2 && "transition" in style;
-    var webkit3d = "WebKitCSSMatrix" in window && "m11" in new window.WebKitCSSMatrix() && !android23;
-    var gecko3d = "MozPerspective" in style;
-    var any3d = !window.L_DISABLE_3D && (ie3d || webkit3d || gecko3d) && !opera12 && !phantom;
-    var mobile = typeof orientation !== "undefined" || userAgentContains("mobile");
-    var mobileWebkit = mobile && webkit;
-    var mobileWebkit3d = mobile && webkit3d;
-    var msPointer = !window.PointerEvent && window.MSPointerEvent;
-    var pointer = !!(window.PointerEvent || msPointer);
-    var touchNative = "ontouchstart" in window || !!window.TouchEvent;
-    var touch = !window.L_NO_TOUCH && (touchNative || pointer);
-    var mobileOpera = mobile && opera;
-    var mobileGecko = mobile && gecko;
-    var retina = (window.devicePixelRatio || window.screen.deviceXDPI / window.screen.logicalXDPI) > 1;
-    var passiveEvents = function() {
-      var supportsPassiveOption = false;
-      try {
-        var opts = Object.defineProperty({}, "passive", {
-          get: function() {
-            supportsPassiveOption = true;
-          }
-        });
-        window.addEventListener("testPassiveEventSupport", falseFn, opts);
-        window.removeEventListener("testPassiveEventSupport", falseFn, opts);
-      } catch (e) {
-      }
-      return supportsPassiveOption;
-    }();
-    var canvas$1 = function() {
-      return !!document.createElement("canvas").getContext;
-    }();
-    var svg$1 = !!(document.createElementNS && svgCreate("svg").createSVGRect);
-    var inlineSvg = !!svg$1 && function() {
-      var div = document.createElement("div");
-      div.innerHTML = "<svg/>";
-      return (div.firstChild && div.firstChild.namespaceURI) === "http://www.w3.org/2000/svg";
-    }();
-    var vml = !svg$1 && function() {
-      try {
-        var div = document.createElement("div");
-        div.innerHTML = '<v:shape adj="1"/>';
-        var shape = div.firstChild;
-        shape.style.behavior = "url(#default#VML)";
-        return shape && typeof shape.adj === "object";
-      } catch (e) {
-        return false;
-      }
-    }();
-    var mac = navigator.platform.indexOf("Mac") === 0;
-    var linux = navigator.platform.indexOf("Linux") === 0;
-    function userAgentContains(str) {
-      return navigator.userAgent.toLowerCase().indexOf(str) >= 0;
-    }
-    var Browser = {
-      ie: ie2,
-      ielt9,
-      edge,
-      webkit,
-      android,
-      android23,
-      androidStock,
-      opera,
-      chrome,
-      gecko,
-      safari,
-      phantom,
-      opera12,
-      win,
-      ie3d,
-      webkit3d,
-      gecko3d,
-      any3d,
-      mobile,
-      mobileWebkit,
-      mobileWebkit3d,
-      msPointer,
-      pointer,
-      touch,
-      touchNative,
-      mobileOpera,
-      mobileGecko,
-      retina,
-      passiveEvents,
-      canvas: canvas$1,
-      svg: svg$1,
-      vml,
-      inlineSvg,
-      mac,
-      linux
-    };
-    var POINTER_DOWN = Browser.msPointer ? "MSPointerDown" : "pointerdown";
-    var POINTER_MOVE = Browser.msPointer ? "MSPointerMove" : "pointermove";
-    var POINTER_UP = Browser.msPointer ? "MSPointerUp" : "pointerup";
-    var POINTER_CANCEL = Browser.msPointer ? "MSPointerCancel" : "pointercancel";
-    var pEvent = {
-      touchstart: POINTER_DOWN,
-      touchmove: POINTER_MOVE,
-      touchend: POINTER_UP,
-      touchcancel: POINTER_CANCEL
-    };
-    var handle = {
-      touchstart: _onPointerStart,
-      touchmove: _handlePointer,
-      touchend: _handlePointer,
-      touchcancel: _handlePointer
-    };
-    var _pointers = {};
-    var _pointerDocListener = false;
-    function addPointerListener(obj, type, handler) {
-      if (type === "touchstart") {
-        _addPointerDocListener();
-      }
-      if (!handle[type]) {
-        console.warn("wrong event specified:", type);
-        return falseFn;
-      }
-      handler = handle[type].bind(this, handler);
-      obj.addEventListener(pEvent[type], handler, false);
-      return handler;
-    }
-    function removePointerListener(obj, type, handler) {
-      if (!pEvent[type]) {
-        console.warn("wrong event specified:", type);
-        return;
-      }
-      obj.removeEventListener(pEvent[type], handler, false);
-    }
-    function _globalPointerDown(e) {
-      _pointers[e.pointerId] = e;
-    }
-    function _globalPointerMove(e) {
-      if (_pointers[e.pointerId]) {
-        _pointers[e.pointerId] = e;
-      }
-    }
-    function _globalPointerUp(e) {
-      delete _pointers[e.pointerId];
-    }
-    function _addPointerDocListener() {
-      if (!_pointerDocListener) {
-        document.addEventListener(POINTER_DOWN, _globalPointerDown, true);
-        document.addEventListener(POINTER_MOVE, _globalPointerMove, true);
-        document.addEventListener(POINTER_UP, _globalPointerUp, true);
-        document.addEventListener(POINTER_CANCEL, _globalPointerUp, true);
-        _pointerDocListener = true;
-      }
-    }
-    function _handlePointer(handler, e) {
-      if (e.pointerType === (e.MSPOINTER_TYPE_MOUSE || "mouse")) {
-        return;
-      }
-      e.touches = [];
-      for (var i in _pointers) {
-        e.touches.push(_pointers[i]);
-      }
-      e.changedTouches = [e];
-      handler(e);
-    }
-    function _onPointerStart(handler, e) {
-      if (e.MSPOINTER_TYPE_TOUCH && e.pointerType === e.MSPOINTER_TYPE_TOUCH) {
-        preventDefault(e);
-      }
-      _handlePointer(handler, e);
-    }
-    function makeDblclick(event) {
-      var newEvent = {}, prop, i;
-      for (i in event) {
-        prop = event[i];
-        newEvent[i] = prop && prop.bind ? prop.bind(event) : prop;
-      }
-      event = newEvent;
-      newEvent.type = "dblclick";
-      newEvent.detail = 2;
-      newEvent.isTrusted = false;
-      newEvent._simulated = true;
-      return newEvent;
-    }
-    var delay = 200;
-    function addDoubleTapListener(obj, handler) {
-      obj.addEventListener("dblclick", handler);
-      var last = 0, detail;
-      function simDblclick(e) {
-        if (e.detail !== 1) {
-          detail = e.detail;
-          return;
-        }
-        if (e.pointerType === "mouse" || e.sourceCapabilities && !e.sourceCapabilities.firesTouchEvents) {
-          return;
-        }
-        var path = getPropagationPath(e);
-        if (path.some(function(el2) {
-          return el2 instanceof HTMLLabelElement && el2.attributes.for;
-        }) && !path.some(function(el2) {
-          return el2 instanceof HTMLInputElement || el2 instanceof HTMLSelectElement;
-        })) {
-          return;
-        }
-        var now = Date.now();
-        if (now - last <= delay) {
-          detail++;
-          if (detail === 2) {
-            handler(makeDblclick(e));
-          }
-        } else {
-          detail = 1;
-        }
-        last = now;
-      }
-      obj.addEventListener("click", simDblclick);
-      return {
-        dblclick: handler,
-        simDblclick
-      };
-    }
-    function removeDoubleTapListener(obj, handlers) {
-      obj.removeEventListener("dblclick", handlers.dblclick);
-      obj.removeEventListener("click", handlers.simDblclick);
-    }
-    var TRANSFORM = testProp(
-      ["transform", "webkitTransform", "OTransform", "MozTransform", "msTransform"]
-    );
-    var TRANSITION = testProp(
-      ["webkitTransition", "transition", "OTransition", "MozTransition", "msTransition"]
-    );
-    var TRANSITION_END = TRANSITION === "webkitTransition" || TRANSITION === "OTransition" ? TRANSITION + "End" : "transitionend";
-    function get(id2) {
-      return typeof id2 === "string" ? document.getElementById(id2) : id2;
-    }
-    function getStyle2(el2, style2) {
-      var value = el2.style[style2] || el2.currentStyle && el2.currentStyle[style2];
-      if ((!value || value === "auto") && document.defaultView) {
-        var css = document.defaultView.getComputedStyle(el2, null);
-        value = css ? css[style2] : null;
-      }
-      return value === "auto" ? null : value;
-    }
-    function create$1(tagName, className, container) {
-      var el2 = document.createElement(tagName);
-      el2.className = className || "";
-      if (container) {
-        container.appendChild(el2);
-      }
-      return el2;
-    }
-    function remove(el2) {
-      var parent = el2.parentNode;
-      if (parent) {
-        parent.removeChild(el2);
-      }
-    }
-    function empty(el2) {
-      while (el2.firstChild) {
-        el2.removeChild(el2.firstChild);
-      }
-    }
-    function toFront(el2) {
-      var parent = el2.parentNode;
-      if (parent && parent.lastChild !== el2) {
-        parent.appendChild(el2);
-      }
-    }
-    function toBack(el2) {
-      var parent = el2.parentNode;
-      if (parent && parent.firstChild !== el2) {
-        parent.insertBefore(el2, parent.firstChild);
-      }
-    }
-    function hasClass(el2, name) {
-      if (el2.classList !== void 0) {
-        return el2.classList.contains(name);
-      }
-      var className = getClass(el2);
-      return className.length > 0 && new RegExp("(^|\\s)" + name + "(\\s|$)").test(className);
-    }
-    function addClass(el2, name) {
-      if (el2.classList !== void 0) {
-        var classes = splitWords(name);
-        for (var i = 0, len = classes.length; i < len; i++) {
-          el2.classList.add(classes[i]);
-        }
-      } else if (!hasClass(el2, name)) {
-        var className = getClass(el2);
-        setClass(el2, (className ? className + " " : "") + name);
-      }
-    }
-    function removeClass(el2, name) {
-      if (el2.classList !== void 0) {
-        el2.classList.remove(name);
-      } else {
-        setClass(el2, trim((" " + getClass(el2) + " ").replace(" " + name + " ", " ")));
-      }
-    }
-    function setClass(el2, name) {
-      if (el2.className.baseVal === void 0) {
-        el2.className = name;
-      } else {
-        el2.className.baseVal = name;
-      }
-    }
-    function getClass(el2) {
-      if (el2.correspondingElement) {
-        el2 = el2.correspondingElement;
-      }
-      return el2.className.baseVal === void 0 ? el2.className : el2.className.baseVal;
+    this.prep(this.minalign, SIZEOF_INT + size_prefix);
+    this.addOffset(root_table);
+    if (size_prefix) {
+      this.addInt32(this.bb.capacity() - this.space);
     }
-    function setOpacity(el2, value) {
-      if ("opacity" in el2.style) {
-        el2.style.opacity = value;
-      } else if ("filter" in el2.style) {
-        _setOpacityIE(el2, value);
-      }
-    }
-    function _setOpacityIE(el2, value) {
-      var filter = false, filterName = "DXImageTransform.Microsoft.Alpha";
-      try {
-        filter = el2.filters.item(filterName);
-      } catch (e) {
-        if (value === 1) {
-          return;
-        }
-      }
-      value = Math.round(value * 100);
-      if (filter) {
-        filter.Enabled = value !== 100;
-        filter.Opacity = value;
-      } else {
-        el2.style.filter += " progid:" + filterName + "(opacity=" + value + ")";
-      }
+    this.bb.setPosition(this.space);
+  }
+  /**
+   * Finalize a size prefixed buffer, pointing to the given `root_table`.
+   */
+  finishSizePrefixed(root_table, opt_file_identifier) {
+    this.finish(root_table, opt_file_identifier, true);
+  }
+  /**
+   * This checks a required field has been set in a given table that has
+   * just been constructed.
+   */
+  requiredField(table, field) {
+    const table_start = this.bb.capacity() - table;
+    const vtable_start = table_start - this.bb.readInt32(table_start);
+    const ok2 = field < this.bb.readInt16(vtable_start) && this.bb.readInt16(vtable_start + field) != 0;
+    if (!ok2) {
+      throw new TypeError("FlatBuffers: field " + field + " must be set");
     }
-    function testProp(props) {
-      var style2 = document.documentElement.style;
-      for (var i = 0; i < props.length; i++) {
-        if (props[i] in style2) {
-          return props[i];
-        }
-      }
-      return false;
+  }
+  /**
+   * Start a new array/vector of objects.  Users usually will not call
+   * this directly. The FlatBuffers compiler will create a start/end
+   * method for vector types in generated code.
+   *
+   * @param elem_size The size of each element in the array
+   * @param num_elems The number of elements in the array
+   * @param alignment The alignment of the array
+   */
+  startVector(elem_size, num_elems, alignment) {
+    this.notNested();
+    this.vector_num_elems = num_elems;
+    this.prep(SIZEOF_INT, elem_size * num_elems);
+    this.prep(alignment, elem_size * num_elems);
+  }
+  /**
+   * Finish off the creation of an array and all its elements. The array must be
+   * created with `startVector`.
+   *
+   * @returns The offset at which the newly created array
+   * starts.
+   */
+  endVector() {
+    this.writeInt32(this.vector_num_elems);
+    return this.offset();
+  }
+  /**
+   * Encode the string `s` in the buffer using UTF-8. If the string passed has
+   * already been seen, we return the offset of the already written string
+   *
+   * @param s The string to encode
+   * @return The offset in the buffer where the encoded string starts
+   */
+  createSharedString(s2) {
+    if (!s2) {
+      return 0;
     }
-    function setTransform(el2, offset, scale2) {
-      var pos = offset || new Point(0, 0);
-      el2.style[TRANSFORM] = (Browser.ie3d ? "translate(" + pos.x + "px," + pos.y + "px)" : "translate3d(" + pos.x + "px," + pos.y + "px,0)") + (scale2 ? " scale(" + scale2 + ")" : "");
+    if (!this.string_maps) {
+      this.string_maps = /* @__PURE__ */ new Map();
     }
-    function setPosition(el2, point) {
-      el2._leaflet_pos = point;
-      if (Browser.any3d) {
-        setTransform(el2, point);
-      } else {
-        el2.style.left = point.x + "px";
-        el2.style.top = point.y + "px";
-      }
+    if (this.string_maps.has(s2)) {
+      return this.string_maps.get(s2);
     }
-    function getPosition(el2) {
-      return el2._leaflet_pos || new Point(0, 0);
+    const offset = this.createString(s2);
+    this.string_maps.set(s2, offset);
+    return offset;
+  }
+  /**
+   * Encode the string `s` in the buffer using UTF-8. If a Uint8Array is passed
+   * instead of a string, it is assumed to contain valid UTF-8 encoded data.
+   *
+   * @param s The string to encode
+   * @return The offset in the buffer where the encoded string starts
+   */
+  createString(s2) {
+    if (s2 === null || s2 === void 0) {
+      return 0;
     }
-    var disableTextSelection;
-    var enableTextSelection;
-    var _userSelect;
-    if ("onselectstart" in document) {
-      disableTextSelection = function() {
-        on(window, "selectstart", preventDefault);
-      };
-      enableTextSelection = function() {
-        off(window, "selectstart", preventDefault);
-      };
+    let utf8;
+    if (s2 instanceof Uint8Array) {
+      utf8 = s2;
     } else {
-      var userSelectProperty = testProp(
-        ["userSelect", "WebkitUserSelect", "OUserSelect", "MozUserSelect", "msUserSelect"]
-      );
-      disableTextSelection = function() {
-        if (userSelectProperty) {
-          var style2 = document.documentElement.style;
-          _userSelect = style2[userSelectProperty];
-          style2[userSelectProperty] = "none";
-        }
-      };
-      enableTextSelection = function() {
-        if (userSelectProperty) {
-          document.documentElement.style[userSelectProperty] = _userSelect;
-          _userSelect = void 0;
-        }
-      };
-    }
-    function disableImageDrag() {
-      on(window, "dragstart", preventDefault);
-    }
-    function enableImageDrag() {
-      off(window, "dragstart", preventDefault);
-    }
-    var _outlineElement, _outlineStyle;
-    function preventOutline(element) {
-      while (element.tabIndex === -1) {
-        element = element.parentNode;
-      }
-      if (!element.style) {
-        return;
-      }
-      restoreOutline();
-      _outlineElement = element;
-      _outlineStyle = element.style.outlineStyle;
-      element.style.outlineStyle = "none";
-      on(window, "keydown", restoreOutline);
-    }
-    function restoreOutline() {
-      if (!_outlineElement) {
-        return;
-      }
-      _outlineElement.style.outlineStyle = _outlineStyle;
-      _outlineElement = void 0;
-      _outlineStyle = void 0;
-      off(window, "keydown", restoreOutline);
-    }
-    function getSizedParentNode(element) {
-      do {
-        element = element.parentNode;
-      } while ((!element.offsetWidth || !element.offsetHeight) && element !== document.body);
-      return element;
-    }
-    function getScale(element) {
-      var rect = element.getBoundingClientRect();
-      return {
-        x: rect.width / element.offsetWidth || 1,
-        y: rect.height / element.offsetHeight || 1,
-        boundingClientRect: rect
-      };
-    }
-    var DomUtil = {
-      __proto__: null,
-      TRANSFORM,
-      TRANSITION,
-      TRANSITION_END,
-      get,
-      getStyle: getStyle2,
-      create: create$1,
-      remove,
-      empty,
-      toFront,
-      toBack,
-      hasClass,
-      addClass,
-      removeClass,
-      setClass,
-      getClass,
-      setOpacity,
-      testProp,
-      setTransform,
-      setPosition,
-      getPosition,
-      get disableTextSelection() {
-        return disableTextSelection;
-      },
-      get enableTextSelection() {
-        return enableTextSelection;
-      },
-      disableImageDrag,
-      enableImageDrag,
-      preventOutline,
-      restoreOutline,
-      getSizedParentNode,
-      getScale
-    };
-    function on(obj, types, fn, context) {
-      if (types && typeof types === "object") {
-        for (var type in types) {
-          addOne(obj, type, types[type], fn);
-        }
-      } else {
-        types = splitWords(types);
-        for (var i = 0, len = types.length; i < len; i++) {
-          addOne(obj, types[i], fn, context);
-        }
-      }
-      return this;
-    }
-    var eventsKey = "_leaflet_events";
-    function off(obj, types, fn, context) {
-      if (arguments.length === 1) {
-        batchRemove(obj);
-        delete obj[eventsKey];
-      } else if (types && typeof types === "object") {
-        for (var type in types) {
-          removeOne(obj, type, types[type], fn);
-        }
-      } else {
-        types = splitWords(types);
-        if (arguments.length === 2) {
-          batchRemove(obj, function(type2) {
-            return indexOf(types, type2) !== -1;
-          });
-        } else {
-          for (var i = 0, len = types.length; i < len; i++) {
-            removeOne(obj, types[i], fn, context);
-          }
-        }
-      }
-      return this;
-    }
-    function batchRemove(obj, filterFn) {
-      for (var id2 in obj[eventsKey]) {
-        var type = id2.split(/\d/)[0];
-        if (!filterFn || filterFn(type)) {
-          removeOne(obj, type, null, null, id2);
-        }
-      }
-    }
-    var mouseSubst = {
-      mouseenter: "mouseover",
-      mouseleave: "mouseout",
-      wheel: !("onwheel" in window) && "mousewheel"
-    };
-    function addOne(obj, type, fn, context) {
-      var id2 = type + stamp(fn) + (context ? "_" + stamp(context) : "");
-      if (obj[eventsKey] && obj[eventsKey][id2]) {
-        return this;
-      }
-      var handler = function(e) {
-        return fn.call(context || obj, e || window.event);
-      };
-      var originalHandler = handler;
-      if (!Browser.touchNative && Browser.pointer && type.indexOf("touch") === 0) {
-        handler = addPointerListener(obj, type, handler);
-      } else if (Browser.touch && type === "dblclick") {
-        handler = addDoubleTapListener(obj, handler);
-      } else if ("addEventListener" in obj) {
-        if (type === "touchstart" || type === "touchmove" || type === "wheel" || type === "mousewheel") {
-          obj.addEventListener(mouseSubst[type] || type, handler, Browser.passiveEvents ? { passive: false } : false);
-        } else if (type === "mouseenter" || type === "mouseleave") {
-          handler = function(e) {
-            e = e || window.event;
-            if (isExternalTarget(obj, e)) {
-              originalHandler(e);
-            }
-          };
-          obj.addEventListener(mouseSubst[type], handler, false);
-        } else {
-          obj.addEventListener(type, originalHandler, false);
-        }
-      } else {
-        obj.attachEvent("on" + type, handler);
-      }
-      obj[eventsKey] = obj[eventsKey] || {};
-      obj[eventsKey][id2] = handler;
-    }
-    function removeOne(obj, type, fn, context, id2) {
-      id2 = id2 || type + stamp(fn) + (context ? "_" + stamp(context) : "");
-      var handler = obj[eventsKey] && obj[eventsKey][id2];
-      if (!handler) {
-        return this;
-      }
-      if (!Browser.touchNative && Browser.pointer && type.indexOf("touch") === 0) {
-        removePointerListener(obj, type, handler);
-      } else if (Browser.touch && type === "dblclick") {
-        removeDoubleTapListener(obj, handler);
-      } else if ("removeEventListener" in obj) {
-        obj.removeEventListener(mouseSubst[type] || type, handler, false);
-      } else {
-        obj.detachEvent("on" + type, handler);
-      }
-      obj[eventsKey][id2] = null;
+      utf8 = this.text_encoder.encode(s2);
     }
-    function stopPropagation(e) {
-      if (e.stopPropagation) {
-        e.stopPropagation();
-      } else if (e.originalEvent) {
-        e.originalEvent._stopped = true;
-      } else {
-        e.cancelBubble = true;
-      }
-      return this;
+    this.addInt8(0);
+    this.startVector(1, utf8.length, 1);
+    this.bb.setPosition(this.space -= utf8.length);
+    this.bb.bytes().set(utf8, this.space);
+    return this.endVector();
+  }
+  /**
+   * Create a byte vector.
+   *
+   * @param v The bytes to add
+   * @returns The offset in the buffer where the byte vector starts
+   */
+  createByteVector(v2) {
+    if (v2 === null || v2 === void 0) {
+      return 0;
     }
-    function disableScrollPropagation(el2) {
-      addOne(el2, "wheel", stopPropagation);
-      return this;
+    this.startVector(1, v2.length, 1);
+    this.bb.setPosition(this.space -= v2.length);
+    this.bb.bytes().set(v2, this.space);
+    return this.endVector();
+  }
+  /**
+   * A helper function to pack an object
+   *
+   * @returns offset of obj
+   */
+  createObjectOffset(obj) {
+    if (obj === null) {
+      return 0;
     }
-    function disableClickPropagation(el2) {
-      on(el2, "mousedown touchstart dblclick contextmenu", stopPropagation);
-      el2["_leaflet_disable_click"] = true;
-      return this;
+    if (typeof obj === "string") {
+      return this.createString(obj);
+    } else {
+      return obj.pack(this);
     }
-    function preventDefault(e) {
-      if (e.preventDefault) {
-        e.preventDefault();
+  }
+  /**
+   * A helper function to pack a list of object
+   *
+   * @returns list of offsets of each non null object
+   */
+  createObjectOffsetList(list) {
+    const ret = [];
+    for (let i2 = 0; i2 < list.length; ++i2) {
+      const val = list[i2];
+      if (val !== null) {
+        ret.push(this.createObjectOffset(val));
       } else {
-        e.returnValue = false;
-      }
-      return this;
-    }
-    function stop(e) {
-      preventDefault(e);
-      stopPropagation(e);
-      return this;
-    }
-    function getPropagationPath(ev) {
-      if (ev.composedPath) {
-        return ev.composedPath();
+        throw new TypeError("FlatBuffers: Argument for createObjectOffsetList cannot contain null.");
       }
-      var path = [];
-      var el2 = ev.target;
-      while (el2) {
-        path.push(el2);
-        el2 = el2.parentNode;
-      }
-      return path;
-    }
-    function getMousePosition(e, container) {
-      if (!container) {
-        return new Point(e.clientX, e.clientY);
-      }
-      var scale2 = getScale(container), offset = scale2.boundingClientRect;
-      return new Point(
-        // offset.left/top values are in page scale (like clientX/Y),
-        // whereas clientLeft/Top (border width) values are the original values (before CSS scale applies).
-        (e.clientX - offset.left) / scale2.x - container.clientLeft,
-        (e.clientY - offset.top) / scale2.y - container.clientTop
-      );
-    }
-    var wheelPxFactor = Browser.linux && Browser.chrome ? window.devicePixelRatio : Browser.mac ? window.devicePixelRatio * 3 : window.devicePixelRatio > 0 ? 2 * window.devicePixelRatio : 1;
-    function getWheelDelta(e) {
-      return Browser.edge ? e.wheelDeltaY / 2 : (
-        // Don't trust window-geometry-based delta
-        e.deltaY && e.deltaMode === 0 ? -e.deltaY / wheelPxFactor : (
-          // Pixels
-          e.deltaY && e.deltaMode === 1 ? -e.deltaY * 20 : (
-            // Lines
-            e.deltaY && e.deltaMode === 2 ? -e.deltaY * 60 : (
-              // Pages
-              e.deltaX || e.deltaZ ? 0 : (
-                // Skip horizontal/depth wheel events
-                e.wheelDelta ? (e.wheelDeltaY || e.wheelDelta) / 2 : (
-                  // Legacy IE pixels
-                  e.detail && Math.abs(e.detail) < 32765 ? -e.detail * 20 : (
-                    // Legacy Moz lines
-                    e.detail ? e.detail / -32765 * 60 : (
-                      // Legacy Moz pages
-                      0
-                    )
-                  )
-                )
-              )
-            )
-          )
-        )
-      );
     }
-    function isExternalTarget(el2, e) {
-      var related = e.relatedTarget;
-      if (!related) {
-        return true;
-      }
-      try {
-        while (related && related !== el2) {
-          related = related.parentNode;
-        }
-      } catch (err) {
-        return false;
-      }
-      return related !== el2;
-    }
-    var DomEvent = {
-      __proto__: null,
-      on,
-      off,
-      stopPropagation,
-      disableScrollPropagation,
-      disableClickPropagation,
-      preventDefault,
-      stop,
-      getPropagationPath,
-      getMousePosition,
-      getWheelDelta,
-      isExternalTarget,
-      addListener: on,
-      removeListener: off
-    };
-    var PosAnimation = Evented.extend({
-      // @method run(el: HTMLElement, newPos: Point, duration?: Number, easeLinearity?: Number)
-      // Run an animation of a given element to a new position, optionally setting
-      // duration in seconds (`0.25` by default) and easing linearity factor (3rd
-      // argument of the [cubic bezier curve](https://cubic-bezier.com/#0,0,.5,1),
-      // `0.5` by default).
-      run: function(el2, newPos, duration, easeLinearity) {
-        this.stop();
-        this._el = el2;
-        this._inProgress = true;
-        this._duration = duration || 0.25;
-        this._easeOutPower = 1 / Math.max(easeLinearity || 0.5, 0.2);
-        this._startPos = getPosition(el2);
-        this._offset = newPos.subtract(this._startPos);
-        this._startTime = +/* @__PURE__ */ new Date();
-        this.fire("start");
-        this._animate();
-      },
-      // @method stop()
-      // Stops the animation (if currently running).
-      stop: function() {
-        if (!this._inProgress) {
-          return;
-        }
-        this._step(true);
-        this._complete();
-      },
-      _animate: function() {
-        this._animId = requestAnimFrame2(this._animate, this);
-        this._step();
-      },
-      _step: function(round2) {
-        var elapsed = +/* @__PURE__ */ new Date() - this._startTime, duration = this._duration * 1e3;
-        if (elapsed < duration) {
-          this._runFrame(this._easeOut(elapsed / duration), round2);
-        } else {
-          this._runFrame(1);
-          this._complete();
-        }
-      },
-      _runFrame: function(progress, round2) {
-        var pos = this._startPos.add(this._offset.multiplyBy(progress));
-        if (round2) {
-          pos._round();
-        }
-        setPosition(this._el, pos);
-        this.fire("step");
-      },
-      _complete: function() {
-        cancelAnimFrame(this._animId);
-        this._inProgress = false;
-        this.fire("end");
-      },
-      _easeOut: function(t2) {
-        return 1 - Math.pow(1 - t2, this._easeOutPower);
-      }
-    });
-    var Map2 = Evented.extend({
-      options: {
-        // @section Map State Options
-        // @option crs: CRS = L.CRS.EPSG3857
-        // The [Coordinate Reference System](#crs) to use. Don't change this if you're not
-        // sure what it means.
-        crs: EPSG3857,
-        // @option center: LatLng = undefined
-        // Initial geographic center of the map
-        center: void 0,
-        // @option zoom: Number = undefined
-        // Initial map zoom level
-        zoom: void 0,
-        // @option minZoom: Number = *
-        // Minimum zoom level of the map.
-        // If not specified and at least one `GridLayer` or `TileLayer` is in the map,
-        // the lowest of their `minZoom` options will be used instead.
-        minZoom: void 0,
-        // @option maxZoom: Number = *
-        // Maximum zoom level of the map.
-        // If not specified and at least one `GridLayer` or `TileLayer` is in the map,
-        // the highest of their `maxZoom` options will be used instead.
-        maxZoom: void 0,
-        // @option layers: Layer[] = []
-        // Array of layers that will be added to the map initially
-        layers: [],
-        // @option maxBounds: LatLngBounds = null
-        // When this option is set, the map restricts the view to the given
-        // geographical bounds, bouncing the user back if the user tries to pan
-        // outside the view. To set the restriction dynamically, use
-        // [`setMaxBounds`](#map-setmaxbounds) method.
-        maxBounds: void 0,
-        // @option renderer: Renderer = *
-        // The default method for drawing vector layers on the map. `L.SVG`
-        // or `L.Canvas` by default depending on browser support.
-        renderer: void 0,
-        // @section Animation Options
-        // @option zoomAnimation: Boolean = true
-        // Whether the map zoom animation is enabled. By default it's enabled
-        // in all browsers that support CSS3 Transitions except Android.
-        zoomAnimation: true,
-        // @option zoomAnimationThreshold: Number = 4
-        // Won't animate zoom if the zoom difference exceeds this value.
-        zoomAnimationThreshold: 4,
-        // @option fadeAnimation: Boolean = true
-        // Whether the tile fade animation is enabled. By default it's enabled
-        // in all browsers that support CSS3 Transitions except Android.
-        fadeAnimation: true,
-        // @option markerZoomAnimation: Boolean = true
-        // Whether markers animate their zoom with the zoom animation, if disabled
-        // they will disappear for the length of the animation. By default it's
-        // enabled in all browsers that support CSS3 Transitions except Android.
-        markerZoomAnimation: true,
-        // @option transform3DLimit: Number = 2^23
-        // Defines the maximum size of a CSS translation transform. The default
-        // value should not be changed unless a web browser positions layers in
-        // the wrong place after doing a large `panBy`.
-        transform3DLimit: 8388608,
-        // Precision limit of a 32-bit float
-        // @section Interaction Options
-        // @option zoomSnap: Number = 1
-        // Forces the map's zoom level to always be a multiple of this, particularly
-        // right after a [`fitBounds()`](#map-fitbounds) or a pinch-zoom.
-        // By default, the zoom level snaps to the nearest integer; lower values
-        // (e.g. `0.5` or `0.1`) allow for greater granularity. A value of `0`
-        // means the zoom level will not be snapped after `fitBounds` or a pinch-zoom.
-        zoomSnap: 1,
-        // @option zoomDelta: Number = 1
-        // Controls how much the map's zoom level will change after a
-        // [`zoomIn()`](#map-zoomin), [`zoomOut()`](#map-zoomout), pressing `+`
-        // or `-` on the keyboard, or using the [zoom controls](#control-zoom).
-        // Values smaller than `1` (e.g. `0.5`) allow for greater granularity.
-        zoomDelta: 1,
-        // @option trackResize: Boolean = true
-        // Whether the map automatically handles browser window resize to update itself.
-        trackResize: true
-      },
-      initialize: function(id2, options) {
-        options = setOptions2(this, options);
-        this._handlers = [];
-        this._layers = {};
-        this._zoomBoundLayers = {};
-        this._sizeChanged = true;
-        this._initContainer(id2);
-        this._initLayout();
-        this._onResize = bind(this._onResize, this);
-        this._initEvents();
-        if (options.maxBounds) {
-          this.setMaxBounds(options.maxBounds);
-        }
-        if (options.zoom !== void 0) {
-          this._zoom = this._limitZoom(options.zoom);
-        }
-        if (options.center && options.zoom !== void 0) {
-          this.setView(toLatLng(options.center), options.zoom, { reset: true });
-        }
-        this.callInitHooks();
-        this._zoomAnimated = TRANSITION && Browser.any3d && !Browser.mobileOpera && this.options.zoomAnimation;
-        if (this._zoomAnimated) {
-          this._createAnimProxy();
-          on(this._proxy, TRANSITION_END, this._catchTransitionEnd, this);
-        }
-        this._addLayers(this.options.layers);
-      },
-      // @section Methods for modifying map state
-      // @method setView(center: LatLng, zoom: Number, options?: Zoom/pan options): this
-      // Sets the view of the map (geographical center and zoom) with the given
-      // animation options.
-      setView: function(center, zoom2, options) {
-        zoom2 = zoom2 === void 0 ? this._zoom : this._limitZoom(zoom2);
-        center = this._limitCenter(toLatLng(center), zoom2, this.options.maxBounds);
-        options = options || {};
-        this._stop();
-        if (this._loaded && !options.reset && options !== true) {
-          if (options.animate !== void 0) {
-            options.zoom = extend({ animate: options.animate }, options.zoom);
-            options.pan = extend({ animate: options.animate, duration: options.duration }, options.pan);
-          }
-          var moved = this._zoom !== zoom2 ? this._tryAnimatedZoom && this._tryAnimatedZoom(center, zoom2, options.zoom) : this._tryAnimatedPan(center, options.pan);
-          if (moved) {
-            clearTimeout(this._sizeTimer);
-            return this;
-          }
-        }
-        this._resetView(center, zoom2, options.pan && options.pan.noMoveStart);
-        return this;
-      },
-      // @method setZoom(zoom: Number, options?: Zoom/pan options): this
-      // Sets the zoom of the map.
-      setZoom: function(zoom2, options) {
-        if (!this._loaded) {
-          this._zoom = zoom2;
-          return this;
-        }
-        return this.setView(this.getCenter(), zoom2, { zoom: options });
-      },
-      // @method zoomIn(delta?: Number, options?: Zoom options): this
-      // Increases the zoom of the map by `delta` ([`zoomDelta`](#map-zoomdelta) by default).
-      zoomIn: function(delta, options) {
-        delta = delta || (Browser.any3d ? this.options.zoomDelta : 1);
-        return this.setZoom(this._zoom + delta, options);
-      },
-      // @method zoomOut(delta?: Number, options?: Zoom options): this
-      // Decreases the zoom of the map by `delta` ([`zoomDelta`](#map-zoomdelta) by default).
-      zoomOut: function(delta, options) {
-        delta = delta || (Browser.any3d ? this.options.zoomDelta : 1);
-        return this.setZoom(this._zoom - delta, options);
-      },
-      // @method setZoomAround(latlng: LatLng, zoom: Number, options: Zoom options): this
-      // Zooms the map while keeping a specified geographical point on the map
-      // stationary (e.g. used internally for scroll zoom and double-click zoom).
-      // @alternative
-      // @method setZoomAround(offset: Point, zoom: Number, options: Zoom options): this
-      // Zooms the map while keeping a specified pixel on the map (relative to the top-left corner) stationary.
-      setZoomAround: function(latlng, zoom2, options) {
-        var scale2 = this.getZoomScale(zoom2), viewHalf = this.getSize().divideBy(2), containerPoint = latlng instanceof Point ? latlng : this.latLngToContainerPoint(latlng), centerOffset = containerPoint.subtract(viewHalf).multiplyBy(1 - 1 / scale2), newCenter = this.containerPointToLatLng(viewHalf.add(centerOffset));
-        return this.setView(newCenter, zoom2, { zoom: options });
-      },
-      _getBoundsCenterZoom: function(bounds, options) {
-        options = options || {};
-        bounds = bounds.getBounds ? bounds.getBounds() : toLatLngBounds(bounds);
-        var paddingTL = toPoint(options.paddingTopLeft || options.padding || [0, 0]), paddingBR = toPoint(options.paddingBottomRight || options.padding || [0, 0]), zoom2 = this.getBoundsZoom(bounds, false, paddingTL.add(paddingBR));
-        zoom2 = typeof options.maxZoom === "number" ? Math.min(options.maxZoom, zoom2) : zoom2;
-        if (zoom2 === Infinity) {
-          return {
-            center: bounds.getCenter(),
-            zoom: zoom2
-          };
-        }
-        var paddingOffset = paddingBR.subtract(paddingTL).divideBy(2), swPoint = this.project(bounds.getSouthWest(), zoom2), nePoint = this.project(bounds.getNorthEast(), zoom2), center = this.unproject(swPoint.add(nePoint).divideBy(2).add(paddingOffset), zoom2);
-        return {
-          center,
-          zoom: zoom2
-        };
-      },
-      // @method fitBounds(bounds: LatLngBounds, options?: fitBounds options): this
-      // Sets a map view that contains the given geographical bounds with the
-      // maximum zoom level possible.
-      fitBounds: function(bounds, options) {
-        bounds = toLatLngBounds(bounds);
-        if (!bounds.isValid()) {
-          throw new Error("Bounds are not valid.");
-        }
-        var target = this._getBoundsCenterZoom(bounds, options);
-        return this.setView(target.center, target.zoom, options);
-      },
-      // @method fitWorld(options?: fitBounds options): this
-      // Sets a map view that mostly contains the whole world with the maximum
-      // zoom level possible.
-      fitWorld: function(options) {
-        return this.fitBounds([[-90, -180], [90, 180]], options);
-      },
-      // @method panTo(latlng: LatLng, options?: Pan options): this
-      // Pans the map to a given center.
-      panTo: function(center, options) {
-        return this.setView(center, this._zoom, { pan: options });
-      },
-      // @method panBy(offset: Point, options?: Pan options): this
-      // Pans the map by a given number of pixels (animated).
-      panBy: function(offset, options) {
-        offset = toPoint(offset).round();
-        options = options || {};
-        if (!offset.x && !offset.y) {
-          return this.fire("moveend");
-        }
-        if (options.animate !== true && !this.getSize().contains(offset)) {
-          this._resetView(this.unproject(this.project(this.getCenter()).add(offset)), this.getZoom());
-          return this;
-        }
-        if (!this._panAnim) {
-          this._panAnim = new PosAnimation();
-          this._panAnim.on({
-            "step": this._onPanTransitionStep,
-            "end": this._onPanTransitionEnd
-          }, this);
-        }
-        if (!options.noMoveStart) {
-          this.fire("movestart");
-        }
-        if (options.animate !== false) {
-          addClass(this._mapPane, "leaflet-pan-anim");
-          var newPos = this._getMapPanePos().subtract(offset).round();
-          this._panAnim.run(this._mapPane, newPos, options.duration || 0.25, options.easeLinearity);
-        } else {
-          this._rawPanBy(offset);
-          this.fire("move").fire("moveend");
-        }
-        return this;
-      },
-      // @method flyTo(latlng: LatLng, zoom?: Number, options?: Zoom/pan options): this
-      // Sets the view of the map (geographical center and zoom) performing a smooth
-      // pan-zoom animation.
-      flyTo: function(targetCenter, targetZoom, options) {
-        options = options || {};
-        if (options.animate === false || !Browser.any3d) {
-          return this.setView(targetCenter, targetZoom, options);
-        }
-        this._stop();
-        var from2 = this.project(this.getCenter()), to2 = this.project(targetCenter), size = this.getSize(), startZoom = this._zoom;
-        targetCenter = toLatLng(targetCenter);
-        targetZoom = targetZoom === void 0 ? startZoom : targetZoom;
-        var w0 = Math.max(size.x, size.y), w1 = w0 * this.getZoomScale(startZoom, targetZoom), u1 = to2.distanceTo(from2) || 1, rho = 1.42, rho2 = rho * rho;
-        function r2(i) {
-          var s1 = i ? -1 : 1, s2 = i ? w1 : w0, t1 = w1 * w1 - w0 * w0 + s1 * rho2 * rho2 * u1 * u1, b1 = 2 * s2 * rho2 * u1, b = t1 / b1, sq = Math.sqrt(b * b + 1) - b;
-          var log = sq < 1e-9 ? -18 : Math.log(sq);
-          return log;
-        }
-        function sinh(n2) {
-          return (Math.exp(n2) - Math.exp(-n2)) / 2;
-        }
-        function cosh(n2) {
-          return (Math.exp(n2) + Math.exp(-n2)) / 2;
-        }
-        function tanh(n2) {
-          return sinh(n2) / cosh(n2);
-        }
-        var r0 = r2(0);
-        function w2(s) {
-          return w0 * (cosh(r0) / cosh(r0 + rho * s));
-        }
-        function u2(s) {
-          return w0 * (cosh(r0) * tanh(r0 + rho * s) - sinh(r0)) / rho2;
-        }
-        function easeOut(t2) {
-          return 1 - Math.pow(1 - t2, 1.5);
-        }
-        var start = Date.now(), S2 = (r2(1) - r0) / rho, duration = options.duration ? 1e3 * options.duration : 1e3 * S2 * 0.8;
-        function frame() {
-          var t2 = (Date.now() - start) / duration, s = easeOut(t2) * S2;
-          if (t2 <= 1) {
-            this._flyToFrame = requestAnimFrame2(frame, this);
-            this._move(
-              this.unproject(from2.add(to2.subtract(from2).multiplyBy(u2(s) / u1)), startZoom),
-              this.getScaleZoom(w0 / w2(s), startZoom),
-              { flyTo: true }
-            );
-          } else {
-            this._move(targetCenter, targetZoom)._moveEnd(true);
-          }
-        }
-        this._moveStart(true, options.noMoveStart);
-        frame.call(this);
-        return this;
-      },
-      // @method flyToBounds(bounds: LatLngBounds, options?: fitBounds options): this
-      // Sets the view of the map with a smooth animation like [`flyTo`](#map-flyto),
-      // but takes a bounds parameter like [`fitBounds`](#map-fitbounds).
-      flyToBounds: function(bounds, options) {
-        var target = this._getBoundsCenterZoom(bounds, options);
-        return this.flyTo(target.center, target.zoom, options);
-      },
-      // @method setMaxBounds(bounds: LatLngBounds): this
-      // Restricts the map view to the given bounds (see the [maxBounds](#map-maxbounds) option).
-      setMaxBounds: function(bounds) {
-        bounds = toLatLngBounds(bounds);
-        if (this.listens("moveend", this._panInsideMaxBounds)) {
-          this.off("moveend", this._panInsideMaxBounds);
-        }
-        if (!bounds.isValid()) {
-          this.options.maxBounds = null;
-          return this;
-        }
-        this.options.maxBounds = bounds;
-        if (this._loaded) {
-          this._panInsideMaxBounds();
-        }
-        return this.on("moveend", this._panInsideMaxBounds);
-      },
-      // @method setMinZoom(zoom: Number): this
-      // Sets the lower limit for the available zoom levels (see the [minZoom](#map-minzoom) option).
-      setMinZoom: function(zoom2) {
-        var oldZoom = this.options.minZoom;
-        this.options.minZoom = zoom2;
-        if (this._loaded && oldZoom !== zoom2) {
-          this.fire("zoomlevelschange");
-          if (this.getZoom() < this.options.minZoom) {
-            return this.setZoom(zoom2);
-          }
-        }
-        return this;
-      },
-      // @method setMaxZoom(zoom: Number): this
-      // Sets the upper limit for the available zoom levels (see the [maxZoom](#map-maxzoom) option).
-      setMaxZoom: function(zoom2) {
-        var oldZoom = this.options.maxZoom;
-        this.options.maxZoom = zoom2;
-        if (this._loaded && oldZoom !== zoom2) {
-          this.fire("zoomlevelschange");
-          if (this.getZoom() > this.options.maxZoom) {
-            return this.setZoom(zoom2);
-          }
-        }
-        return this;
-      },
-      // @method panInsideBounds(bounds: LatLngBounds, options?: Pan options): this
-      // Pans the map to the closest view that would lie inside the given bounds (if it's not already), controlling the animation using the options specific, if any.
-      panInsideBounds: function(bounds, options) {
-        this._enforcingBounds = true;
-        var center = this.getCenter(), newCenter = this._limitCenter(center, this._zoom, toLatLngBounds(bounds));
-        if (!center.equals(newCenter)) {
-          this.panTo(newCenter, options);
-        }
-        this._enforcingBounds = false;
-        return this;
-      },
-      // @method panInside(latlng: LatLng, options?: padding options): this
-      // Pans the map the minimum amount to make the `latlng` visible. Use
-      // padding options to fit the display to more restricted bounds.
-      // If `latlng` is already within the (optionally padded) display bounds,
-      // the map will not be panned.
-      panInside: function(latlng, options) {
-        options = options || {};
-        var paddingTL = toPoint(options.paddingTopLeft || options.padding || [0, 0]), paddingBR = toPoint(options.paddingBottomRight || options.padding || [0, 0]), pixelCenter = this.project(this.getCenter()), pixelPoint = this.project(latlng), pixelBounds = this.getPixelBounds(), paddedBounds = toBounds([pixelBounds.min.add(paddingTL), pixelBounds.max.subtract(paddingBR)]), paddedSize = paddedBounds.getSize();
-        if (!paddedBounds.contains(pixelPoint)) {
-          this._enforcingBounds = true;
-          var centerOffset = pixelPoint.subtract(paddedBounds.getCenter());
-          var offset = paddedBounds.extend(pixelPoint).getSize().subtract(paddedSize);
-          pixelCenter.x += centerOffset.x < 0 ? -offset.x : offset.x;
-          pixelCenter.y += centerOffset.y < 0 ? -offset.y : offset.y;
-          this.panTo(this.unproject(pixelCenter), options);
-          this._enforcingBounds = false;
-        }
-        return this;
-      },
-      // @method invalidateSize(options: Zoom/pan options): this
-      // Checks if the map container size changed and updates the map if so —
-      // call it after you've changed the map size dynamically, also animating
-      // pan by default. If `options.pan` is `false`, panning will not occur.
-      // If `options.debounceMoveend` is `true`, it will delay `moveend` event so
-      // that it doesn't happen often even if the method is called many
-      // times in a row.
-      // @alternative
-      // @method invalidateSize(animate: Boolean): this
-      // Checks if the map container size changed and updates the map if so —
-      // call it after you've changed the map size dynamically, also animating
-      // pan by default.
-      invalidateSize: function(options) {
-        if (!this._loaded) {
-          return this;
-        }
-        options = extend({
-          animate: false,
-          pan: true
-        }, options === true ? { animate: true } : options);
-        var oldSize = this.getSize();
-        this._sizeChanged = true;
-        this._lastCenter = null;
-        var newSize = this.getSize(), oldCenter = oldSize.divideBy(2).round(), newCenter = newSize.divideBy(2).round(), offset = oldCenter.subtract(newCenter);
-        if (!offset.x && !offset.y) {
-          return this;
-        }
-        if (options.animate && options.pan) {
-          this.panBy(offset);
-        } else {
-          if (options.pan) {
-            this._rawPanBy(offset);
-          }
-          this.fire("move");
-          if (options.debounceMoveend) {
-            clearTimeout(this._sizeTimer);
-            this._sizeTimer = setTimeout(bind(this.fire, this, "moveend"), 200);
-          } else {
-            this.fire("moveend");
-          }
-        }
-        return this.fire("resize", {
-          oldSize,
-          newSize
-        });
-      },
-      // @section Methods for modifying map state
-      // @method stop(): this
-      // Stops the currently running `panTo` or `flyTo` animation, if any.
-      stop: function() {
-        this.setZoom(this._limitZoom(this._zoom));
-        if (!this.options.zoomSnap) {
-          this.fire("viewreset");
-        }
-        return this._stop();
-      },
-      // @section Geolocation methods
-      // @method locate(options?: Locate options): this
-      // Tries to locate the user using the Geolocation API, firing a [`locationfound`](#map-locationfound)
-      // event with location data on success or a [`locationerror`](#map-locationerror) event on failure,
-      // and optionally sets the map view to the user's location with respect to
-      // detection accuracy (or to the world view if geolocation failed).
-      // Note that, if your page doesn't use HTTPS, this method will fail in
-      // modern browsers ([Chrome 50 and newer](https://sites.google.com/a/chromium.org/dev/Home/chromium-security/deprecating-powerful-features-on-insecure-origins))
-      // See `Locate options` for more details.
-      locate: function(options) {
-        options = this._locateOptions = extend({
-          timeout: 1e4,
-          watch: false
-          // setView: false
-          // maxZoom: <Number>
-          // maximumAge: 0
-          // enableHighAccuracy: false
-        }, options);
-        if (!("geolocation" in navigator)) {
-          this._handleGeolocationError({
-            code: 0,
-            message: "Geolocation not supported."
-          });
-          return this;
-        }
-        var onResponse = bind(this._handleGeolocationResponse, this), onError = bind(this._handleGeolocationError, this);
-        if (options.watch) {
-          this._locationWatchId = navigator.geolocation.watchPosition(onResponse, onError, options);
-        } else {
-          navigator.geolocation.getCurrentPosition(onResponse, onError, options);
-        }
-        return this;
-      },
-      // @method stopLocate(): this
-      // Stops watching location previously initiated by `map.locate({watch: true})`
-      // and aborts resetting the map view if map.locate was called with
-      // `{setView: true}`.
-      stopLocate: function() {
-        if (navigator.geolocation && navigator.geolocation.clearWatch) {
-          navigator.geolocation.clearWatch(this._locationWatchId);
-        }
-        if (this._locateOptions) {
-          this._locateOptions.setView = false;
-        }
-        return this;
-      },
-      _handleGeolocationError: function(error) {
-        if (!this._container._leaflet_id) {
-          return;
-        }
-        var c = error.code, message2 = error.message || (c === 1 ? "permission denied" : c === 2 ? "position unavailable" : "timeout");
-        if (this._locateOptions.setView && !this._loaded) {
-          this.fitWorld();
-        }
-        this.fire("locationerror", {
-          code: c,
-          message: "Geolocation error: " + message2 + "."
-        });
-      },
-      _handleGeolocationResponse: function(pos) {
-        if (!this._container._leaflet_id) {
-          return;
-        }
-        var lat = pos.coords.latitude, lng = pos.coords.longitude, latlng = new LatLng(lat, lng), bounds = latlng.toBounds(pos.coords.accuracy * 2), options = this._locateOptions;
-        if (options.setView) {
-          var zoom2 = this.getBoundsZoom(bounds);
-          this.setView(latlng, options.maxZoom ? Math.min(zoom2, options.maxZoom) : zoom2);
-        }
-        var data = {
-          latlng,
-          bounds,
-          timestamp: pos.timestamp
-        };
-        for (var i in pos.coords) {
-          if (typeof pos.coords[i] === "number") {
-            data[i] = pos.coords[i];
-          }
-        }
-        this.fire("locationfound", data);
-      },
-      // TODO Appropriate docs section?
-      // @section Other Methods
-      // @method addHandler(name: String, HandlerClass: Function): this
-      // Adds a new `Handler` to the map, given its name and constructor function.
-      addHandler: function(name, HandlerClass) {
-        if (!HandlerClass) {
-          return this;
-        }
-        var handler = this[name] = new HandlerClass(this);
-        this._handlers.push(handler);
-        if (this.options[name]) {
-          handler.enable();
-        }
-        return this;
-      },
-      // @method remove(): this
-      // Destroys the map and clears all related event listeners.
-      remove: function() {
-        this._initEvents(true);
-        if (this.options.maxBounds) {
-          this.off("moveend", this._panInsideMaxBounds);
-        }
-        if (this._containerId !== this._container._leaflet_id) {
-          throw new Error("Map container is being reused by another instance");
-        }
-        try {
-          delete this._container._leaflet_id;
-          delete this._containerId;
-        } catch (e) {
-          this._container._leaflet_id = void 0;
-          this._containerId = void 0;
-        }
-        if (this._locationWatchId !== void 0) {
-          this.stopLocate();
-        }
-        this._stop();
-        remove(this._mapPane);
-        if (this._clearControlPos) {
-          this._clearControlPos();
-        }
-        if (this._resizeRequest) {
-          cancelAnimFrame(this._resizeRequest);
-          this._resizeRequest = null;
-        }
-        this._clearHandlers();
-        if (this._loaded) {
-          this.fire("unload");
-        }
-        var i;
-        for (i in this._layers) {
-          this._layers[i].remove();
-        }
-        for (i in this._panes) {
-          remove(this._panes[i]);
-        }
-        this._layers = [];
-        this._panes = [];
-        delete this._mapPane;
-        delete this._renderer;
-        return this;
-      },
-      // @section Other Methods
-      // @method createPane(name: String, container?: HTMLElement): HTMLElement
-      // Creates a new [map pane](#map-pane) with the given name if it doesn't exist already,
-      // then returns it. The pane is created as a child of `container`, or
-      // as a child of the main map pane if not set.
-      createPane: function(name, container) {
-        var className = "leaflet-pane" + (name ? " leaflet-" + name.replace("Pane", "") + "-pane" : ""), pane = create$1("div", className, container || this._mapPane);
-        if (name) {
-          this._panes[name] = pane;
-        }
-        return pane;
-      },
-      // @section Methods for Getting Map State
-      // @method getCenter(): LatLng
-      // Returns the geographical center of the map view
-      getCenter: function() {
-        this._checkIfLoaded();
-        if (this._lastCenter && !this._moved()) {
-          return this._lastCenter.clone();
-        }
-        return this.layerPointToLatLng(this._getCenterLayerPoint());
-      },
-      // @method getZoom(): Number
-      // Returns the current zoom level of the map view
-      getZoom: function() {
-        return this._zoom;
-      },
-      // @method getBounds(): LatLngBounds
-      // Returns the geographical bounds visible in the current map view
-      getBounds: function() {
-        var bounds = this.getPixelBounds(), sw = this.unproject(bounds.getBottomLeft()), ne2 = this.unproject(bounds.getTopRight());
-        return new LatLngBounds(sw, ne2);
-      },
-      // @method getMinZoom(): Number
-      // Returns the minimum zoom level of the map (if set in the `minZoom` option of the map or of any layers), or `0` by default.
-      getMinZoom: function() {
-        return this.options.minZoom === void 0 ? this._layersMinZoom || 0 : this.options.minZoom;
-      },
-      // @method getMaxZoom(): Number
-      // Returns the maximum zoom level of the map (if set in the `maxZoom` option of the map or of any layers).
-      getMaxZoom: function() {
-        return this.options.maxZoom === void 0 ? this._layersMaxZoom === void 0 ? Infinity : this._layersMaxZoom : this.options.maxZoom;
-      },
-      // @method getBoundsZoom(bounds: LatLngBounds, inside?: Boolean, padding?: Point): Number
-      // Returns the maximum zoom level on which the given bounds fit to the map
-      // view in its entirety. If `inside` (optional) is set to `true`, the method
-      // instead returns the minimum zoom level on which the map view fits into
-      // the given bounds in its entirety.
-      getBoundsZoom: function(bounds, inside, padding) {
-        bounds = toLatLngBounds(bounds);
-        padding = toPoint(padding || [0, 0]);
-        var zoom2 = this.getZoom() || 0, min = this.getMinZoom(), max = this.getMaxZoom(), nw = bounds.getNorthWest(), se2 = bounds.getSouthEast(), size = this.getSize().subtract(padding), boundsSize = toBounds(this.project(se2, zoom2), this.project(nw, zoom2)).getSize(), snap = Browser.any3d ? this.options.zoomSnap : 1, scalex = size.x / boundsSize.x, scaley = size.y / boundsSize.y, scale2 = inside ? Math.max(scalex, scaley) : Math.min(scalex, scaley);
-        zoom2 = this.getScaleZoom(scale2, zoom2);
-        if (snap) {
-          zoom2 = Math.round(zoom2 / (snap / 100)) * (snap / 100);
-          zoom2 = inside ? Math.ceil(zoom2 / snap) * snap : Math.floor(zoom2 / snap) * snap;
-        }
-        return Math.max(min, Math.min(max, zoom2));
-      },
-      // @method getSize(): Point
-      // Returns the current size of the map container (in pixels).
-      getSize: function() {
-        if (!this._size || this._sizeChanged) {
-          this._size = new Point(
-            this._container.clientWidth || 0,
-            this._container.clientHeight || 0
-          );
-          this._sizeChanged = false;
-        }
-        return this._size.clone();
-      },
-      // @method getPixelBounds(): Bounds
-      // Returns the bounds of the current map view in projected pixel
-      // coordinates (sometimes useful in layer and overlay implementations).
-      getPixelBounds: function(center, zoom2) {
-        var topLeftPoint = this._getTopLeftPoint(center, zoom2);
-        return new Bounds(topLeftPoint, topLeftPoint.add(this.getSize()));
-      },
-      // TODO: Check semantics - isn't the pixel origin the 0,0 coord relative to
-      // the map pane? "left point of the map layer" can be confusing, specially
-      // since there can be negative offsets.
-      // @method getPixelOrigin(): Point
-      // Returns the projected pixel coordinates of the top left point of
-      // the map layer (useful in custom layer and overlay implementations).
-      getPixelOrigin: function() {
-        this._checkIfLoaded();
-        return this._pixelOrigin;
-      },
-      // @method getPixelWorldBounds(zoom?: Number): Bounds
-      // Returns the world's bounds in pixel coordinates for zoom level `zoom`.
-      // If `zoom` is omitted, the map's current zoom level is used.
-      getPixelWorldBounds: function(zoom2) {
-        return this.options.crs.getProjectedBounds(zoom2 === void 0 ? this.getZoom() : zoom2);
-      },
-      // @section Other Methods
-      // @method getPane(pane: String|HTMLElement): HTMLElement
-      // Returns a [map pane](#map-pane), given its name or its HTML element (its identity).
-      getPane: function(pane) {
-        return typeof pane === "string" ? this._panes[pane] : pane;
-      },
-      // @method getPanes(): Object
-      // Returns a plain object containing the names of all [panes](#map-pane) as keys and
-      // the panes as values.
-      getPanes: function() {
-        return this._panes;
-      },
-      // @method getContainer: HTMLElement
-      // Returns the HTML element that contains the map.
-      getContainer: function() {
-        return this._container;
-      },
-      // @section Conversion Methods
-      // @method getZoomScale(toZoom: Number, fromZoom: Number): Number
-      // Returns the scale factor to be applied to a map transition from zoom level
-      // `fromZoom` to `toZoom`. Used internally to help with zoom animations.
-      getZoomScale: function(toZoom, fromZoom) {
-        var crs = this.options.crs;
-        fromZoom = fromZoom === void 0 ? this._zoom : fromZoom;
-        return crs.scale(toZoom) / crs.scale(fromZoom);
+    return ret;
+  }
+  createStructOffsetList(list, startFunc) {
+    startFunc(this, list.length);
+    this.createObjectOffsetList(list.slice().reverse());
+    return this.endVector();
+  }
+};
+var BodyCompressionMethod;
+(function(BodyCompressionMethod2) {
+  BodyCompressionMethod2[BodyCompressionMethod2["BUFFER"] = 0] = "BUFFER";
+})(BodyCompressionMethod || (BodyCompressionMethod = {}));
+var CompressionType;
+(function(CompressionType2) {
+  CompressionType2[CompressionType2["LZ4_FRAME"] = 0] = "LZ4_FRAME";
+  CompressionType2[CompressionType2["ZSTD"] = 1] = "ZSTD";
+})(CompressionType || (CompressionType = {}));
+let BodyCompression$1 = class BodyCompression {
+  constructor() {
+    this.bb = null;
+    this.bb_pos = 0;
+  }
+  __init(i2, bb2) {
+    this.bb_pos = i2;
+    this.bb = bb2;
+    return this;
+  }
+  static getRootAsBodyCompression(bb2, obj) {
+    return (obj || new BodyCompression()).__init(bb2.readInt32(bb2.position()) + bb2.position(), bb2);
+  }
+  static getSizePrefixedRootAsBodyCompression(bb2, obj) {
+    bb2.setPosition(bb2.position() + SIZE_PREFIX_LENGTH);
+    return (obj || new BodyCompression()).__init(bb2.readInt32(bb2.position()) + bb2.position(), bb2);
+  }
+  /**
+   * Compressor library.
+   * For LZ4_FRAME, each compressed buffer must consist of a single frame.
+   */
+  codec() {
+    const offset = this.bb.__offset(this.bb_pos, 4);
+    return offset ? this.bb.readInt8(this.bb_pos + offset) : CompressionType.LZ4_FRAME;
+  }
+  /**
+   * Indicates the way the record batch body was compressed
+   */
+  method() {
+    const offset = this.bb.__offset(this.bb_pos, 6);
+    return offset ? this.bb.readInt8(this.bb_pos + offset) : BodyCompressionMethod.BUFFER;
+  }
+  static startBodyCompression(builder) {
+    builder.startObject(2);
+  }
+  static addCodec(builder, codec) {
+    builder.addFieldInt8(0, codec, CompressionType.LZ4_FRAME);
+  }
+  static addMethod(builder, method) {
+    builder.addFieldInt8(1, method, BodyCompressionMethod.BUFFER);
+  }
+  static endBodyCompression(builder) {
+    const offset = builder.endObject();
+    return offset;
+  }
+  static createBodyCompression(builder, codec, method) {
+    BodyCompression.startBodyCompression(builder);
+    BodyCompression.addCodec(builder, codec);
+    BodyCompression.addMethod(builder, method);
+    return BodyCompression.endBodyCompression(builder);
+  }
+};
+let Buffer$2 = class Buffer2 {
+  constructor() {
+    this.bb = null;
+    this.bb_pos = 0;
+  }
+  __init(i2, bb2) {
+    this.bb_pos = i2;
+    this.bb = bb2;
+    return this;
+  }
+  /**
+   * The relative offset into the shared memory page where the bytes for this
+   * buffer starts
+   */
+  offset() {
+    return this.bb.readInt64(this.bb_pos);
+  }
+  /**
+   * The absolute length (in bytes) of the memory buffer. The memory is found
+   * from offset (inclusive) to offset + length (non-inclusive). When building
+   * messages using the encapsulated IPC message, padding bytes may be written
+   * after a buffer, but such padding bytes do not need to be accounted for in
+   * the size here.
+   */
+  length() {
+    return this.bb.readInt64(this.bb_pos + 8);
+  }
+  static sizeOf() {
+    return 16;
+  }
+  static createBuffer(builder, offset, length2) {
+    builder.prep(8, 16);
+    builder.writeInt64(BigInt(length2 !== null && length2 !== void 0 ? length2 : 0));
+    builder.writeInt64(BigInt(offset !== null && offset !== void 0 ? offset : 0));
+    return builder.offset();
+  }
+};
+let FieldNode$1 = class FieldNode {
+  constructor() {
+    this.bb = null;
+    this.bb_pos = 0;
+  }
+  __init(i2, bb2) {
+    this.bb_pos = i2;
+    this.bb = bb2;
+    return this;
+  }
+  /**
+   * The number of value slots in the Arrow array at this level of a nested
+   * tree
+   */
+  length() {
+    return this.bb.readInt64(this.bb_pos);
+  }
+  /**
+   * The number of observed nulls. Fields with null_count == 0 may choose not
+   * to write their physical validity bitmap out as a materialized buffer,
+   * instead setting the length of the bitmap buffer to 0.
+   */
+  nullCount() {
+    return this.bb.readInt64(this.bb_pos + 8);
+  }
+  static sizeOf() {
+    return 16;
+  }
+  static createFieldNode(builder, length2, null_count) {
+    builder.prep(8, 16);
+    builder.writeInt64(BigInt(null_count !== null && null_count !== void 0 ? null_count : 0));
+    builder.writeInt64(BigInt(length2 !== null && length2 !== void 0 ? length2 : 0));
+    return builder.offset();
+  }
+};
+let RecordBatch$2 = class RecordBatch {
+  constructor() {
+    this.bb = null;
+    this.bb_pos = 0;
+  }
+  __init(i2, bb2) {
+    this.bb_pos = i2;
+    this.bb = bb2;
+    return this;
+  }
+  static getRootAsRecordBatch(bb2, obj) {
+    return (obj || new RecordBatch()).__init(bb2.readInt32(bb2.position()) + bb2.position(), bb2);
+  }
+  static getSizePrefixedRootAsRecordBatch(bb2, obj) {
+    bb2.setPosition(bb2.position() + SIZE_PREFIX_LENGTH);
+    return (obj || new RecordBatch()).__init(bb2.readInt32(bb2.position()) + bb2.position(), bb2);
+  }
+  /**
+   * number of records / rows. The arrays in the batch should all have this
+   * length
+   */
+  length() {
+    const offset = this.bb.__offset(this.bb_pos, 4);
+    return offset ? this.bb.readInt64(this.bb_pos + offset) : BigInt("0");
+  }
+  /**
+   * Nodes correspond to the pre-ordered flattened logical schema
+   */
+  nodes(index, obj) {
+    const offset = this.bb.__offset(this.bb_pos, 6);
+    return offset ? (obj || new FieldNode$1()).__init(this.bb.__vector(this.bb_pos + offset) + index * 16, this.bb) : null;
+  }
+  nodesLength() {
+    const offset = this.bb.__offset(this.bb_pos, 6);
+    return offset ? this.bb.__vector_len(this.bb_pos + offset) : 0;
+  }
+  /**
+   * Buffers correspond to the pre-ordered flattened buffer tree
+   *
+   * The number of buffers appended to this list depends on the schema. For
+   * example, most primitive arrays will have 2 buffers, 1 for the validity
+   * bitmap and 1 for the values. For struct arrays, there will only be a
+   * single buffer for the validity (nulls) bitmap
+   */
+  buffers(index, obj) {
+    const offset = this.bb.__offset(this.bb_pos, 8);
+    return offset ? (obj || new Buffer$2()).__init(this.bb.__vector(this.bb_pos + offset) + index * 16, this.bb) : null;
+  }
+  buffersLength() {
+    const offset = this.bb.__offset(this.bb_pos, 8);
+    return offset ? this.bb.__vector_len(this.bb_pos + offset) : 0;
+  }
+  /**
+   * Optional compression of the message body
+   */
+  compression(obj) {
+    const offset = this.bb.__offset(this.bb_pos, 10);
+    return offset ? (obj || new BodyCompression$1()).__init(this.bb.__indirect(this.bb_pos + offset), this.bb) : null;
+  }
+  static startRecordBatch(builder) {
+    builder.startObject(4);
+  }
+  static addLength(builder, length2) {
+    builder.addFieldInt64(0, length2, BigInt("0"));
+  }
+  static addNodes(builder, nodesOffset) {
+    builder.addFieldOffset(1, nodesOffset, 0);
+  }
+  static startNodesVector(builder, numElems) {
+    builder.startVector(16, numElems, 8);
+  }
+  static addBuffers(builder, buffersOffset) {
+    builder.addFieldOffset(2, buffersOffset, 0);
+  }
+  static startBuffersVector(builder, numElems) {
+    builder.startVector(16, numElems, 8);
+  }
+  static addCompression(builder, compressionOffset) {
+    builder.addFieldOffset(3, compressionOffset, 0);
+  }
+  static endRecordBatch(builder) {
+    const offset = builder.endObject();
+    return offset;
+  }
+};
+let DictionaryBatch$1 = class DictionaryBatch {
+  constructor() {
+    this.bb = null;
+    this.bb_pos = 0;
+  }
+  __init(i2, bb2) {
+    this.bb_pos = i2;
+    this.bb = bb2;
+    return this;
+  }
+  static getRootAsDictionaryBatch(bb2, obj) {
+    return (obj || new DictionaryBatch()).__init(bb2.readInt32(bb2.position()) + bb2.position(), bb2);
+  }
+  static getSizePrefixedRootAsDictionaryBatch(bb2, obj) {
+    bb2.setPosition(bb2.position() + SIZE_PREFIX_LENGTH);
+    return (obj || new DictionaryBatch()).__init(bb2.readInt32(bb2.position()) + bb2.position(), bb2);
+  }
+  id() {
+    const offset = this.bb.__offset(this.bb_pos, 4);
+    return offset ? this.bb.readInt64(this.bb_pos + offset) : BigInt("0");
+  }
+  data(obj) {
+    const offset = this.bb.__offset(this.bb_pos, 6);
+    return offset ? (obj || new RecordBatch$2()).__init(this.bb.__indirect(this.bb_pos + offset), this.bb) : null;
+  }
+  /**
+   * If isDelta is true the values in the dictionary are to be appended to a
+   * dictionary with the indicated id. If isDelta is false this dictionary
+   * should replace the existing dictionary.
+   */
+  isDelta() {
+    const offset = this.bb.__offset(this.bb_pos, 8);
+    return offset ? !!this.bb.readInt8(this.bb_pos + offset) : false;
+  }
+  static startDictionaryBatch(builder) {
+    builder.startObject(3);
+  }
+  static addId(builder, id2) {
+    builder.addFieldInt64(0, id2, BigInt("0"));
+  }
+  static addData(builder, dataOffset) {
+    builder.addFieldOffset(1, dataOffset, 0);
+  }
+  static addIsDelta(builder, isDelta) {
+    builder.addFieldInt8(2, +isDelta, 0);
+  }
+  static endDictionaryBatch(builder) {
+    const offset = builder.endObject();
+    return offset;
+  }
+};
+var Endianness;
+(function(Endianness2) {
+  Endianness2[Endianness2["Little"] = 0] = "Little";
+  Endianness2[Endianness2["Big"] = 1] = "Big";
+})(Endianness || (Endianness = {}));
+var DictionaryKind;
+(function(DictionaryKind2) {
+  DictionaryKind2[DictionaryKind2["DenseArray"] = 0] = "DenseArray";
+})(DictionaryKind || (DictionaryKind = {}));
+class Int {
+  constructor() {
+    this.bb = null;
+    this.bb_pos = 0;
+  }
+  __init(i2, bb2) {
+    this.bb_pos = i2;
+    this.bb = bb2;
+    return this;
+  }
+  static getRootAsInt(bb2, obj) {
+    return (obj || new Int()).__init(bb2.readInt32(bb2.position()) + bb2.position(), bb2);
+  }
+  static getSizePrefixedRootAsInt(bb2, obj) {
+    bb2.setPosition(bb2.position() + SIZE_PREFIX_LENGTH);
+    return (obj || new Int()).__init(bb2.readInt32(bb2.position()) + bb2.position(), bb2);
+  }
+  bitWidth() {
+    const offset = this.bb.__offset(this.bb_pos, 4);
+    return offset ? this.bb.readInt32(this.bb_pos + offset) : 0;
+  }
+  isSigned() {
+    const offset = this.bb.__offset(this.bb_pos, 6);
+    return offset ? !!this.bb.readInt8(this.bb_pos + offset) : false;
+  }
+  static startInt(builder) {
+    builder.startObject(2);
+  }
+  static addBitWidth(builder, bitWidth) {
+    builder.addFieldInt32(0, bitWidth, 0);
+  }
+  static addIsSigned(builder, isSigned) {
+    builder.addFieldInt8(1, +isSigned, 0);
+  }
+  static endInt(builder) {
+    const offset = builder.endObject();
+    return offset;
+  }
+  static createInt(builder, bitWidth, isSigned) {
+    Int.startInt(builder);
+    Int.addBitWidth(builder, bitWidth);
+    Int.addIsSigned(builder, isSigned);
+    return Int.endInt(builder);
+  }
+}
+class DictionaryEncoding {
+  constructor() {
+    this.bb = null;
+    this.bb_pos = 0;
+  }
+  __init(i2, bb2) {
+    this.bb_pos = i2;
+    this.bb = bb2;
+    return this;
+  }
+  static getRootAsDictionaryEncoding(bb2, obj) {
+    return (obj || new DictionaryEncoding()).__init(bb2.readInt32(bb2.position()) + bb2.position(), bb2);
+  }
+  static getSizePrefixedRootAsDictionaryEncoding(bb2, obj) {
+    bb2.setPosition(bb2.position() + SIZE_PREFIX_LENGTH);
+    return (obj || new DictionaryEncoding()).__init(bb2.readInt32(bb2.position()) + bb2.position(), bb2);
+  }
+  /**
+   * The known dictionary id in the application where this data is used. In
+   * the file or streaming formats, the dictionary ids are found in the
+   * DictionaryBatch messages
+   */
+  id() {
+    const offset = this.bb.__offset(this.bb_pos, 4);
+    return offset ? this.bb.readInt64(this.bb_pos + offset) : BigInt("0");
+  }
+  /**
+   * The dictionary indices are constrained to be non-negative integers. If
+   * this field is null, the indices must be signed int32. To maximize
+   * cross-language compatibility and performance, implementations are
+   * recommended to prefer signed integer types over unsigned integer types
+   * and to avoid uint64 indices unless they are required by an application.
+   */
+  indexType(obj) {
+    const offset = this.bb.__offset(this.bb_pos, 6);
+    return offset ? (obj || new Int()).__init(this.bb.__indirect(this.bb_pos + offset), this.bb) : null;
+  }
+  /**
+   * By default, dictionaries are not ordered, or the order does not have
+   * semantic meaning. In some statistical, applications, dictionary-encoding
+   * is used to represent ordered categorical data, and we provide a way to
+   * preserve that metadata here
+   */
+  isOrdered() {
+    const offset = this.bb.__offset(this.bb_pos, 8);
+    return offset ? !!this.bb.readInt8(this.bb_pos + offset) : false;
+  }
+  dictionaryKind() {
+    const offset = this.bb.__offset(this.bb_pos, 10);
+    return offset ? this.bb.readInt16(this.bb_pos + offset) : DictionaryKind.DenseArray;
+  }
+  static startDictionaryEncoding(builder) {
+    builder.startObject(4);
+  }
+  static addId(builder, id2) {
+    builder.addFieldInt64(0, id2, BigInt("0"));
+  }
+  static addIndexType(builder, indexTypeOffset) {
+    builder.addFieldOffset(1, indexTypeOffset, 0);
+  }
+  static addIsOrdered(builder, isOrdered) {
+    builder.addFieldInt8(2, +isOrdered, 0);
+  }
+  static addDictionaryKind(builder, dictionaryKind) {
+    builder.addFieldInt16(3, dictionaryKind, DictionaryKind.DenseArray);
+  }
+  static endDictionaryEncoding(builder) {
+    const offset = builder.endObject();
+    return offset;
+  }
+}
+class KeyValue {
+  constructor() {
+    this.bb = null;
+    this.bb_pos = 0;
+  }
+  __init(i2, bb2) {
+    this.bb_pos = i2;
+    this.bb = bb2;
+    return this;
+  }
+  static getRootAsKeyValue(bb2, obj) {
+    return (obj || new KeyValue()).__init(bb2.readInt32(bb2.position()) + bb2.position(), bb2);
+  }
+  static getSizePrefixedRootAsKeyValue(bb2, obj) {
+    bb2.setPosition(bb2.position() + SIZE_PREFIX_LENGTH);
+    return (obj || new KeyValue()).__init(bb2.readInt32(bb2.position()) + bb2.position(), bb2);
+  }
+  key(optionalEncoding) {
+    const offset = this.bb.__offset(this.bb_pos, 4);
+    return offset ? this.bb.__string(this.bb_pos + offset, optionalEncoding) : null;
+  }
+  value(optionalEncoding) {
+    const offset = this.bb.__offset(this.bb_pos, 6);
+    return offset ? this.bb.__string(this.bb_pos + offset, optionalEncoding) : null;
+  }
+  static startKeyValue(builder) {
+    builder.startObject(2);
+  }
+  static addKey(builder, keyOffset) {
+    builder.addFieldOffset(0, keyOffset, 0);
+  }
+  static addValue(builder, valueOffset) {
+    builder.addFieldOffset(1, valueOffset, 0);
+  }
+  static endKeyValue(builder) {
+    const offset = builder.endObject();
+    return offset;
+  }
+  static createKeyValue(builder, keyOffset, valueOffset) {
+    KeyValue.startKeyValue(builder);
+    KeyValue.addKey(builder, keyOffset);
+    KeyValue.addValue(builder, valueOffset);
+    return KeyValue.endKeyValue(builder);
+  }
+}
+let Binary$1 = class Binary {
+  constructor() {
+    this.bb = null;
+    this.bb_pos = 0;
+  }
+  __init(i2, bb2) {
+    this.bb_pos = i2;
+    this.bb = bb2;
+    return this;
+  }
+  static getRootAsBinary(bb2, obj) {
+    return (obj || new Binary()).__init(bb2.readInt32(bb2.position()) + bb2.position(), bb2);
+  }
+  static getSizePrefixedRootAsBinary(bb2, obj) {
+    bb2.setPosition(bb2.position() + SIZE_PREFIX_LENGTH);
+    return (obj || new Binary()).__init(bb2.readInt32(bb2.position()) + bb2.position(), bb2);
+  }
+  static startBinary(builder) {
+    builder.startObject(0);
+  }
+  static endBinary(builder) {
+    const offset = builder.endObject();
+    return offset;
+  }
+  static createBinary(builder) {
+    Binary.startBinary(builder);
+    return Binary.endBinary(builder);
+  }
+};
+let Bool$1 = class Bool {
+  constructor() {
+    this.bb = null;
+    this.bb_pos = 0;
+  }
+  __init(i2, bb2) {
+    this.bb_pos = i2;
+    this.bb = bb2;
+    return this;
+  }
+  static getRootAsBool(bb2, obj) {
+    return (obj || new Bool()).__init(bb2.readInt32(bb2.position()) + bb2.position(), bb2);
+  }
+  static getSizePrefixedRootAsBool(bb2, obj) {
+    bb2.setPosition(bb2.position() + SIZE_PREFIX_LENGTH);
+    return (obj || new Bool()).__init(bb2.readInt32(bb2.position()) + bb2.position(), bb2);
+  }
+  static startBool(builder) {
+    builder.startObject(0);
+  }
+  static endBool(builder) {
+    const offset = builder.endObject();
+    return offset;
+  }
+  static createBool(builder) {
+    Bool.startBool(builder);
+    return Bool.endBool(builder);
+  }
+};
+let Date$1 = class Date2 {
+  constructor() {
+    this.bb = null;
+    this.bb_pos = 0;
+  }
+  __init(i2, bb2) {
+    this.bb_pos = i2;
+    this.bb = bb2;
+    return this;
+  }
+  static getRootAsDate(bb2, obj) {
+    return (obj || new Date2()).__init(bb2.readInt32(bb2.position()) + bb2.position(), bb2);
+  }
+  static getSizePrefixedRootAsDate(bb2, obj) {
+    bb2.setPosition(bb2.position() + SIZE_PREFIX_LENGTH);
+    return (obj || new Date2()).__init(bb2.readInt32(bb2.position()) + bb2.position(), bb2);
+  }
+  unit() {
+    const offset = this.bb.__offset(this.bb_pos, 4);
+    return offset ? this.bb.readInt16(this.bb_pos + offset) : DateUnit.MILLISECOND;
+  }
+  static startDate(builder) {
+    builder.startObject(1);
+  }
+  static addUnit(builder, unit) {
+    builder.addFieldInt16(0, unit, DateUnit.MILLISECOND);
+  }
+  static endDate(builder) {
+    const offset = builder.endObject();
+    return offset;
+  }
+  static createDate(builder, unit) {
+    Date2.startDate(builder);
+    Date2.addUnit(builder, unit);
+    return Date2.endDate(builder);
+  }
+};
+let Decimal$1 = class Decimal {
+  constructor() {
+    this.bb = null;
+    this.bb_pos = 0;
+  }
+  __init(i2, bb2) {
+    this.bb_pos = i2;
+    this.bb = bb2;
+    return this;
+  }
+  static getRootAsDecimal(bb2, obj) {
+    return (obj || new Decimal()).__init(bb2.readInt32(bb2.position()) + bb2.position(), bb2);
+  }
+  static getSizePrefixedRootAsDecimal(bb2, obj) {
+    bb2.setPosition(bb2.position() + SIZE_PREFIX_LENGTH);
+    return (obj || new Decimal()).__init(bb2.readInt32(bb2.position()) + bb2.position(), bb2);
+  }
+  /**
+   * Total number of decimal digits
+   */
+  precision() {
+    const offset = this.bb.__offset(this.bb_pos, 4);
+    return offset ? this.bb.readInt32(this.bb_pos + offset) : 0;
+  }
+  /**
+   * Number of digits after the decimal point "."
+   */
+  scale() {
+    const offset = this.bb.__offset(this.bb_pos, 6);
+    return offset ? this.bb.readInt32(this.bb_pos + offset) : 0;
+  }
+  /**
+   * Number of bits per value. The only accepted widths are 128 and 256.
+   * We use bitWidth for consistency with Int::bitWidth.
+   */
+  bitWidth() {
+    const offset = this.bb.__offset(this.bb_pos, 8);
+    return offset ? this.bb.readInt32(this.bb_pos + offset) : 128;
+  }
+  static startDecimal(builder) {
+    builder.startObject(3);
+  }
+  static addPrecision(builder, precision) {
+    builder.addFieldInt32(0, precision, 0);
+  }
+  static addScale(builder, scale2) {
+    builder.addFieldInt32(1, scale2, 0);
+  }
+  static addBitWidth(builder, bitWidth) {
+    builder.addFieldInt32(2, bitWidth, 128);
+  }
+  static endDecimal(builder) {
+    const offset = builder.endObject();
+    return offset;
+  }
+  static createDecimal(builder, precision, scale2, bitWidth) {
+    Decimal.startDecimal(builder);
+    Decimal.addPrecision(builder, precision);
+    Decimal.addScale(builder, scale2);
+    Decimal.addBitWidth(builder, bitWidth);
+    return Decimal.endDecimal(builder);
+  }
+};
+let Duration$1 = class Duration {
+  constructor() {
+    this.bb = null;
+    this.bb_pos = 0;
+  }
+  __init(i2, bb2) {
+    this.bb_pos = i2;
+    this.bb = bb2;
+    return this;
+  }
+  static getRootAsDuration(bb2, obj) {
+    return (obj || new Duration()).__init(bb2.readInt32(bb2.position()) + bb2.position(), bb2);
+  }
+  static getSizePrefixedRootAsDuration(bb2, obj) {
+    bb2.setPosition(bb2.position() + SIZE_PREFIX_LENGTH);
+    return (obj || new Duration()).__init(bb2.readInt32(bb2.position()) + bb2.position(), bb2);
+  }
+  unit() {
+    const offset = this.bb.__offset(this.bb_pos, 4);
+    return offset ? this.bb.readInt16(this.bb_pos + offset) : TimeUnit.MILLISECOND;
+  }
+  static startDuration(builder) {
+    builder.startObject(1);
+  }
+  static addUnit(builder, unit) {
+    builder.addFieldInt16(0, unit, TimeUnit.MILLISECOND);
+  }
+  static endDuration(builder) {
+    const offset = builder.endObject();
+    return offset;
+  }
+  static createDuration(builder, unit) {
+    Duration.startDuration(builder);
+    Duration.addUnit(builder, unit);
+    return Duration.endDuration(builder);
+  }
+};
+let FixedSizeBinary$1 = class FixedSizeBinary {
+  constructor() {
+    this.bb = null;
+    this.bb_pos = 0;
+  }
+  __init(i2, bb2) {
+    this.bb_pos = i2;
+    this.bb = bb2;
+    return this;
+  }
+  static getRootAsFixedSizeBinary(bb2, obj) {
+    return (obj || new FixedSizeBinary()).__init(bb2.readInt32(bb2.position()) + bb2.position(), bb2);
+  }
+  static getSizePrefixedRootAsFixedSizeBinary(bb2, obj) {
+    bb2.setPosition(bb2.position() + SIZE_PREFIX_LENGTH);
+    return (obj || new FixedSizeBinary()).__init(bb2.readInt32(bb2.position()) + bb2.position(), bb2);
+  }
+  /**
+   * Number of bytes per value
+   */
+  byteWidth() {
+    const offset = this.bb.__offset(this.bb_pos, 4);
+    return offset ? this.bb.readInt32(this.bb_pos + offset) : 0;
+  }
+  static startFixedSizeBinary(builder) {
+    builder.startObject(1);
+  }
+  static addByteWidth(builder, byteWidth) {
+    builder.addFieldInt32(0, byteWidth, 0);
+  }
+  static endFixedSizeBinary(builder) {
+    const offset = builder.endObject();
+    return offset;
+  }
+  static createFixedSizeBinary(builder, byteWidth) {
+    FixedSizeBinary.startFixedSizeBinary(builder);
+    FixedSizeBinary.addByteWidth(builder, byteWidth);
+    return FixedSizeBinary.endFixedSizeBinary(builder);
+  }
+};
+let FixedSizeList$1 = class FixedSizeList {
+  constructor() {
+    this.bb = null;
+    this.bb_pos = 0;
+  }
+  __init(i2, bb2) {
+    this.bb_pos = i2;
+    this.bb = bb2;
+    return this;
+  }
+  static getRootAsFixedSizeList(bb2, obj) {
+    return (obj || new FixedSizeList()).__init(bb2.readInt32(bb2.position()) + bb2.position(), bb2);
+  }
+  static getSizePrefixedRootAsFixedSizeList(bb2, obj) {
+    bb2.setPosition(bb2.position() + SIZE_PREFIX_LENGTH);
+    return (obj || new FixedSizeList()).__init(bb2.readInt32(bb2.position()) + bb2.position(), bb2);
+  }
+  /**
+   * Number of list items per value
+   */
+  listSize() {
+    const offset = this.bb.__offset(this.bb_pos, 4);
+    return offset ? this.bb.readInt32(this.bb_pos + offset) : 0;
+  }
+  static startFixedSizeList(builder) {
+    builder.startObject(1);
+  }
+  static addListSize(builder, listSize) {
+    builder.addFieldInt32(0, listSize, 0);
+  }
+  static endFixedSizeList(builder) {
+    const offset = builder.endObject();
+    return offset;
+  }
+  static createFixedSizeList(builder, listSize) {
+    FixedSizeList.startFixedSizeList(builder);
+    FixedSizeList.addListSize(builder, listSize);
+    return FixedSizeList.endFixedSizeList(builder);
+  }
+};
+class FloatingPoint {
+  constructor() {
+    this.bb = null;
+    this.bb_pos = 0;
+  }
+  __init(i2, bb2) {
+    this.bb_pos = i2;
+    this.bb = bb2;
+    return this;
+  }
+  static getRootAsFloatingPoint(bb2, obj) {
+    return (obj || new FloatingPoint()).__init(bb2.readInt32(bb2.position()) + bb2.position(), bb2);
+  }
+  static getSizePrefixedRootAsFloatingPoint(bb2, obj) {
+    bb2.setPosition(bb2.position() + SIZE_PREFIX_LENGTH);
+    return (obj || new FloatingPoint()).__init(bb2.readInt32(bb2.position()) + bb2.position(), bb2);
+  }
+  precision() {
+    const offset = this.bb.__offset(this.bb_pos, 4);
+    return offset ? this.bb.readInt16(this.bb_pos + offset) : Precision.HALF;
+  }
+  static startFloatingPoint(builder) {
+    builder.startObject(1);
+  }
+  static addPrecision(builder, precision) {
+    builder.addFieldInt16(0, precision, Precision.HALF);
+  }
+  static endFloatingPoint(builder) {
+    const offset = builder.endObject();
+    return offset;
+  }
+  static createFloatingPoint(builder, precision) {
+    FloatingPoint.startFloatingPoint(builder);
+    FloatingPoint.addPrecision(builder, precision);
+    return FloatingPoint.endFloatingPoint(builder);
+  }
+}
+class Interval {
+  constructor() {
+    this.bb = null;
+    this.bb_pos = 0;
+  }
+  __init(i2, bb2) {
+    this.bb_pos = i2;
+    this.bb = bb2;
+    return this;
+  }
+  static getRootAsInterval(bb2, obj) {
+    return (obj || new Interval()).__init(bb2.readInt32(bb2.position()) + bb2.position(), bb2);
+  }
+  static getSizePrefixedRootAsInterval(bb2, obj) {
+    bb2.setPosition(bb2.position() + SIZE_PREFIX_LENGTH);
+    return (obj || new Interval()).__init(bb2.readInt32(bb2.position()) + bb2.position(), bb2);
+  }
+  unit() {
+    const offset = this.bb.__offset(this.bb_pos, 4);
+    return offset ? this.bb.readInt16(this.bb_pos + offset) : IntervalUnit.YEAR_MONTH;
+  }
+  static startInterval(builder) {
+    builder.startObject(1);
+  }
+  static addUnit(builder, unit) {
+    builder.addFieldInt16(0, unit, IntervalUnit.YEAR_MONTH);
+  }
+  static endInterval(builder) {
+    const offset = builder.endObject();
+    return offset;
+  }
+  static createInterval(builder, unit) {
+    Interval.startInterval(builder);
+    Interval.addUnit(builder, unit);
+    return Interval.endInterval(builder);
+  }
+}
+let LargeBinary$1 = class LargeBinary {
+  constructor() {
+    this.bb = null;
+    this.bb_pos = 0;
+  }
+  __init(i2, bb2) {
+    this.bb_pos = i2;
+    this.bb = bb2;
+    return this;
+  }
+  static getRootAsLargeBinary(bb2, obj) {
+    return (obj || new LargeBinary()).__init(bb2.readInt32(bb2.position()) + bb2.position(), bb2);
+  }
+  static getSizePrefixedRootAsLargeBinary(bb2, obj) {
+    bb2.setPosition(bb2.position() + SIZE_PREFIX_LENGTH);
+    return (obj || new LargeBinary()).__init(bb2.readInt32(bb2.position()) + bb2.position(), bb2);
+  }
+  static startLargeBinary(builder) {
+    builder.startObject(0);
+  }
+  static endLargeBinary(builder) {
+    const offset = builder.endObject();
+    return offset;
+  }
+  static createLargeBinary(builder) {
+    LargeBinary.startLargeBinary(builder);
+    return LargeBinary.endLargeBinary(builder);
+  }
+};
+let LargeUtf8$1 = class LargeUtf8 {
+  constructor() {
+    this.bb = null;
+    this.bb_pos = 0;
+  }
+  __init(i2, bb2) {
+    this.bb_pos = i2;
+    this.bb = bb2;
+    return this;
+  }
+  static getRootAsLargeUtf8(bb2, obj) {
+    return (obj || new LargeUtf8()).__init(bb2.readInt32(bb2.position()) + bb2.position(), bb2);
+  }
+  static getSizePrefixedRootAsLargeUtf8(bb2, obj) {
+    bb2.setPosition(bb2.position() + SIZE_PREFIX_LENGTH);
+    return (obj || new LargeUtf8()).__init(bb2.readInt32(bb2.position()) + bb2.position(), bb2);
+  }
+  static startLargeUtf8(builder) {
+    builder.startObject(0);
+  }
+  static endLargeUtf8(builder) {
+    const offset = builder.endObject();
+    return offset;
+  }
+  static createLargeUtf8(builder) {
+    LargeUtf8.startLargeUtf8(builder);
+    return LargeUtf8.endLargeUtf8(builder);
+  }
+};
+let List$1 = class List {
+  constructor() {
+    this.bb = null;
+    this.bb_pos = 0;
+  }
+  __init(i2, bb2) {
+    this.bb_pos = i2;
+    this.bb = bb2;
+    return this;
+  }
+  static getRootAsList(bb2, obj) {
+    return (obj || new List()).__init(bb2.readInt32(bb2.position()) + bb2.position(), bb2);
+  }
+  static getSizePrefixedRootAsList(bb2, obj) {
+    bb2.setPosition(bb2.position() + SIZE_PREFIX_LENGTH);
+    return (obj || new List()).__init(bb2.readInt32(bb2.position()) + bb2.position(), bb2);
+  }
+  static startList(builder) {
+    builder.startObject(0);
+  }
+  static endList(builder) {
+    const offset = builder.endObject();
+    return offset;
+  }
+  static createList(builder) {
+    List.startList(builder);
+    return List.endList(builder);
+  }
+};
+let Map$1 = class Map2 {
+  constructor() {
+    this.bb = null;
+    this.bb_pos = 0;
+  }
+  __init(i2, bb2) {
+    this.bb_pos = i2;
+    this.bb = bb2;
+    return this;
+  }
+  static getRootAsMap(bb2, obj) {
+    return (obj || new Map2()).__init(bb2.readInt32(bb2.position()) + bb2.position(), bb2);
+  }
+  static getSizePrefixedRootAsMap(bb2, obj) {
+    bb2.setPosition(bb2.position() + SIZE_PREFIX_LENGTH);
+    return (obj || new Map2()).__init(bb2.readInt32(bb2.position()) + bb2.position(), bb2);
+  }
+  /**
+   * Set to true if the keys within each value are sorted
+   */
+  keysSorted() {
+    const offset = this.bb.__offset(this.bb_pos, 4);
+    return offset ? !!this.bb.readInt8(this.bb_pos + offset) : false;
+  }
+  static startMap(builder) {
+    builder.startObject(1);
+  }
+  static addKeysSorted(builder, keysSorted) {
+    builder.addFieldInt8(0, +keysSorted, 0);
+  }
+  static endMap(builder) {
+    const offset = builder.endObject();
+    return offset;
+  }
+  static createMap(builder, keysSorted) {
+    Map2.startMap(builder);
+    Map2.addKeysSorted(builder, keysSorted);
+    return Map2.endMap(builder);
+  }
+};
+let Null$1 = class Null {
+  constructor() {
+    this.bb = null;
+    this.bb_pos = 0;
+  }
+  __init(i2, bb2) {
+    this.bb_pos = i2;
+    this.bb = bb2;
+    return this;
+  }
+  static getRootAsNull(bb2, obj) {
+    return (obj || new Null()).__init(bb2.readInt32(bb2.position()) + bb2.position(), bb2);
+  }
+  static getSizePrefixedRootAsNull(bb2, obj) {
+    bb2.setPosition(bb2.position() + SIZE_PREFIX_LENGTH);
+    return (obj || new Null()).__init(bb2.readInt32(bb2.position()) + bb2.position(), bb2);
+  }
+  static startNull(builder) {
+    builder.startObject(0);
+  }
+  static endNull(builder) {
+    const offset = builder.endObject();
+    return offset;
+  }
+  static createNull(builder) {
+    Null.startNull(builder);
+    return Null.endNull(builder);
+  }
+};
+class Struct_ {
+  constructor() {
+    this.bb = null;
+    this.bb_pos = 0;
+  }
+  __init(i2, bb2) {
+    this.bb_pos = i2;
+    this.bb = bb2;
+    return this;
+  }
+  static getRootAsStruct_(bb2, obj) {
+    return (obj || new Struct_()).__init(bb2.readInt32(bb2.position()) + bb2.position(), bb2);
+  }
+  static getSizePrefixedRootAsStruct_(bb2, obj) {
+    bb2.setPosition(bb2.position() + SIZE_PREFIX_LENGTH);
+    return (obj || new Struct_()).__init(bb2.readInt32(bb2.position()) + bb2.position(), bb2);
+  }
+  static startStruct_(builder) {
+    builder.startObject(0);
+  }
+  static endStruct_(builder) {
+    const offset = builder.endObject();
+    return offset;
+  }
+  static createStruct_(builder) {
+    Struct_.startStruct_(builder);
+    return Struct_.endStruct_(builder);
+  }
+}
+class Time {
+  constructor() {
+    this.bb = null;
+    this.bb_pos = 0;
+  }
+  __init(i2, bb2) {
+    this.bb_pos = i2;
+    this.bb = bb2;
+    return this;
+  }
+  static getRootAsTime(bb2, obj) {
+    return (obj || new Time()).__init(bb2.readInt32(bb2.position()) + bb2.position(), bb2);
+  }
+  static getSizePrefixedRootAsTime(bb2, obj) {
+    bb2.setPosition(bb2.position() + SIZE_PREFIX_LENGTH);
+    return (obj || new Time()).__init(bb2.readInt32(bb2.position()) + bb2.position(), bb2);
+  }
+  unit() {
+    const offset = this.bb.__offset(this.bb_pos, 4);
+    return offset ? this.bb.readInt16(this.bb_pos + offset) : TimeUnit.MILLISECOND;
+  }
+  bitWidth() {
+    const offset = this.bb.__offset(this.bb_pos, 6);
+    return offset ? this.bb.readInt32(this.bb_pos + offset) : 32;
+  }
+  static startTime(builder) {
+    builder.startObject(2);
+  }
+  static addUnit(builder, unit) {
+    builder.addFieldInt16(0, unit, TimeUnit.MILLISECOND);
+  }
+  static addBitWidth(builder, bitWidth) {
+    builder.addFieldInt32(1, bitWidth, 32);
+  }
+  static endTime(builder) {
+    const offset = builder.endObject();
+    return offset;
+  }
+  static createTime(builder, unit, bitWidth) {
+    Time.startTime(builder);
+    Time.addUnit(builder, unit);
+    Time.addBitWidth(builder, bitWidth);
+    return Time.endTime(builder);
+  }
+}
+class Timestamp {
+  constructor() {
+    this.bb = null;
+    this.bb_pos = 0;
+  }
+  __init(i2, bb2) {
+    this.bb_pos = i2;
+    this.bb = bb2;
+    return this;
+  }
+  static getRootAsTimestamp(bb2, obj) {
+    return (obj || new Timestamp()).__init(bb2.readInt32(bb2.position()) + bb2.position(), bb2);
+  }
+  static getSizePrefixedRootAsTimestamp(bb2, obj) {
+    bb2.setPosition(bb2.position() + SIZE_PREFIX_LENGTH);
+    return (obj || new Timestamp()).__init(bb2.readInt32(bb2.position()) + bb2.position(), bb2);
+  }
+  unit() {
+    const offset = this.bb.__offset(this.bb_pos, 4);
+    return offset ? this.bb.readInt16(this.bb_pos + offset) : TimeUnit.SECOND;
+  }
+  timezone(optionalEncoding) {
+    const offset = this.bb.__offset(this.bb_pos, 6);
+    return offset ? this.bb.__string(this.bb_pos + offset, optionalEncoding) : null;
+  }
+  static startTimestamp(builder) {
+    builder.startObject(2);
+  }
+  static addUnit(builder, unit) {
+    builder.addFieldInt16(0, unit, TimeUnit.SECOND);
+  }
+  static addTimezone(builder, timezoneOffset) {
+    builder.addFieldOffset(1, timezoneOffset, 0);
+  }
+  static endTimestamp(builder) {
+    const offset = builder.endObject();
+    return offset;
+  }
+  static createTimestamp(builder, unit, timezoneOffset) {
+    Timestamp.startTimestamp(builder);
+    Timestamp.addUnit(builder, unit);
+    Timestamp.addTimezone(builder, timezoneOffset);
+    return Timestamp.endTimestamp(builder);
+  }
+}
+class Union {
+  constructor() {
+    this.bb = null;
+    this.bb_pos = 0;
+  }
+  __init(i2, bb2) {
+    this.bb_pos = i2;
+    this.bb = bb2;
+    return this;
+  }
+  static getRootAsUnion(bb2, obj) {
+    return (obj || new Union()).__init(bb2.readInt32(bb2.position()) + bb2.position(), bb2);
+  }
+  static getSizePrefixedRootAsUnion(bb2, obj) {
+    bb2.setPosition(bb2.position() + SIZE_PREFIX_LENGTH);
+    return (obj || new Union()).__init(bb2.readInt32(bb2.position()) + bb2.position(), bb2);
+  }
+  mode() {
+    const offset = this.bb.__offset(this.bb_pos, 4);
+    return offset ? this.bb.readInt16(this.bb_pos + offset) : UnionMode.Sparse;
+  }
+  typeIds(index) {
+    const offset = this.bb.__offset(this.bb_pos, 6);
+    return offset ? this.bb.readInt32(this.bb.__vector(this.bb_pos + offset) + index * 4) : 0;
+  }
+  typeIdsLength() {
+    const offset = this.bb.__offset(this.bb_pos, 6);
+    return offset ? this.bb.__vector_len(this.bb_pos + offset) : 0;
+  }
+  typeIdsArray() {
+    const offset = this.bb.__offset(this.bb_pos, 6);
+    return offset ? new Int32Array(this.bb.bytes().buffer, this.bb.bytes().byteOffset + this.bb.__vector(this.bb_pos + offset), this.bb.__vector_len(this.bb_pos + offset)) : null;
+  }
+  static startUnion(builder) {
+    builder.startObject(2);
+  }
+  static addMode(builder, mode) {
+    builder.addFieldInt16(0, mode, UnionMode.Sparse);
+  }
+  static addTypeIds(builder, typeIdsOffset) {
+    builder.addFieldOffset(1, typeIdsOffset, 0);
+  }
+  static createTypeIdsVector(builder, data) {
+    builder.startVector(4, data.length, 4);
+    for (let i2 = data.length - 1; i2 >= 0; i2--) {
+      builder.addInt32(data[i2]);
+    }
+    return builder.endVector();
+  }
+  static startTypeIdsVector(builder, numElems) {
+    builder.startVector(4, numElems, 4);
+  }
+  static endUnion(builder) {
+    const offset = builder.endObject();
+    return offset;
+  }
+  static createUnion(builder, mode, typeIdsOffset) {
+    Union.startUnion(builder);
+    Union.addMode(builder, mode);
+    Union.addTypeIds(builder, typeIdsOffset);
+    return Union.endUnion(builder);
+  }
+}
+let Utf8$1 = class Utf8 {
+  constructor() {
+    this.bb = null;
+    this.bb_pos = 0;
+  }
+  __init(i2, bb2) {
+    this.bb_pos = i2;
+    this.bb = bb2;
+    return this;
+  }
+  static getRootAsUtf8(bb2, obj) {
+    return (obj || new Utf8()).__init(bb2.readInt32(bb2.position()) + bb2.position(), bb2);
+  }
+  static getSizePrefixedRootAsUtf8(bb2, obj) {
+    bb2.setPosition(bb2.position() + SIZE_PREFIX_LENGTH);
+    return (obj || new Utf8()).__init(bb2.readInt32(bb2.position()) + bb2.position(), bb2);
+  }
+  static startUtf8(builder) {
+    builder.startObject(0);
+  }
+  static endUtf8(builder) {
+    const offset = builder.endObject();
+    return offset;
+  }
+  static createUtf8(builder) {
+    Utf8.startUtf8(builder);
+    return Utf8.endUtf8(builder);
+  }
+};
+var Type$1;
+(function(Type2) {
+  Type2[Type2["NONE"] = 0] = "NONE";
+  Type2[Type2["Null"] = 1] = "Null";
+  Type2[Type2["Int"] = 2] = "Int";
+  Type2[Type2["FloatingPoint"] = 3] = "FloatingPoint";
+  Type2[Type2["Binary"] = 4] = "Binary";
+  Type2[Type2["Utf8"] = 5] = "Utf8";
+  Type2[Type2["Bool"] = 6] = "Bool";
+  Type2[Type2["Decimal"] = 7] = "Decimal";
+  Type2[Type2["Date"] = 8] = "Date";
+  Type2[Type2["Time"] = 9] = "Time";
+  Type2[Type2["Timestamp"] = 10] = "Timestamp";
+  Type2[Type2["Interval"] = 11] = "Interval";
+  Type2[Type2["List"] = 12] = "List";
+  Type2[Type2["Struct_"] = 13] = "Struct_";
+  Type2[Type2["Union"] = 14] = "Union";
+  Type2[Type2["FixedSizeBinary"] = 15] = "FixedSizeBinary";
+  Type2[Type2["FixedSizeList"] = 16] = "FixedSizeList";
+  Type2[Type2["Map"] = 17] = "Map";
+  Type2[Type2["Duration"] = 18] = "Duration";
+  Type2[Type2["LargeBinary"] = 19] = "LargeBinary";
+  Type2[Type2["LargeUtf8"] = 20] = "LargeUtf8";
+  Type2[Type2["LargeList"] = 21] = "LargeList";
+  Type2[Type2["RunEndEncoded"] = 22] = "RunEndEncoded";
+})(Type$1 || (Type$1 = {}));
+let Field$1 = class Field {
+  constructor() {
+    this.bb = null;
+    this.bb_pos = 0;
+  }
+  __init(i2, bb2) {
+    this.bb_pos = i2;
+    this.bb = bb2;
+    return this;
+  }
+  static getRootAsField(bb2, obj) {
+    return (obj || new Field()).__init(bb2.readInt32(bb2.position()) + bb2.position(), bb2);
+  }
+  static getSizePrefixedRootAsField(bb2, obj) {
+    bb2.setPosition(bb2.position() + SIZE_PREFIX_LENGTH);
+    return (obj || new Field()).__init(bb2.readInt32(bb2.position()) + bb2.position(), bb2);
+  }
+  name(optionalEncoding) {
+    const offset = this.bb.__offset(this.bb_pos, 4);
+    return offset ? this.bb.__string(this.bb_pos + offset, optionalEncoding) : null;
+  }
+  /**
+   * Whether or not this field can contain nulls. Should be true in general.
+   */
+  nullable() {
+    const offset = this.bb.__offset(this.bb_pos, 6);
+    return offset ? !!this.bb.readInt8(this.bb_pos + offset) : false;
+  }
+  typeType() {
+    const offset = this.bb.__offset(this.bb_pos, 8);
+    return offset ? this.bb.readUint8(this.bb_pos + offset) : Type$1.NONE;
+  }
+  /**
+   * This is the type of the decoded value if the field is dictionary encoded.
+   */
+  type(obj) {
+    const offset = this.bb.__offset(this.bb_pos, 10);
+    return offset ? this.bb.__union(obj, this.bb_pos + offset) : null;
+  }
+  /**
+   * Present only if the field is dictionary encoded.
+   */
+  dictionary(obj) {
+    const offset = this.bb.__offset(this.bb_pos, 12);
+    return offset ? (obj || new DictionaryEncoding()).__init(this.bb.__indirect(this.bb_pos + offset), this.bb) : null;
+  }
+  /**
+   * children apply only to nested data types like Struct, List and Union. For
+   * primitive types children will have length 0.
+   */
+  children(index, obj) {
+    const offset = this.bb.__offset(this.bb_pos, 14);
+    return offset ? (obj || new Field()).__init(this.bb.__indirect(this.bb.__vector(this.bb_pos + offset) + index * 4), this.bb) : null;
+  }
+  childrenLength() {
+    const offset = this.bb.__offset(this.bb_pos, 14);
+    return offset ? this.bb.__vector_len(this.bb_pos + offset) : 0;
+  }
+  /**
+   * User-defined metadata
+   */
+  customMetadata(index, obj) {
+    const offset = this.bb.__offset(this.bb_pos, 16);
+    return offset ? (obj || new KeyValue()).__init(this.bb.__indirect(this.bb.__vector(this.bb_pos + offset) + index * 4), this.bb) : null;
+  }
+  customMetadataLength() {
+    const offset = this.bb.__offset(this.bb_pos, 16);
+    return offset ? this.bb.__vector_len(this.bb_pos + offset) : 0;
+  }
+  static startField(builder) {
+    builder.startObject(7);
+  }
+  static addName(builder, nameOffset) {
+    builder.addFieldOffset(0, nameOffset, 0);
+  }
+  static addNullable(builder, nullable) {
+    builder.addFieldInt8(1, +nullable, 0);
+  }
+  static addTypeType(builder, typeType) {
+    builder.addFieldInt8(2, typeType, Type$1.NONE);
+  }
+  static addType(builder, typeOffset) {
+    builder.addFieldOffset(3, typeOffset, 0);
+  }
+  static addDictionary(builder, dictionaryOffset) {
+    builder.addFieldOffset(4, dictionaryOffset, 0);
+  }
+  static addChildren(builder, childrenOffset) {
+    builder.addFieldOffset(5, childrenOffset, 0);
+  }
+  static createChildrenVector(builder, data) {
+    builder.startVector(4, data.length, 4);
+    for (let i2 = data.length - 1; i2 >= 0; i2--) {
+      builder.addOffset(data[i2]);
+    }
+    return builder.endVector();
+  }
+  static startChildrenVector(builder, numElems) {
+    builder.startVector(4, numElems, 4);
+  }
+  static addCustomMetadata(builder, customMetadataOffset) {
+    builder.addFieldOffset(6, customMetadataOffset, 0);
+  }
+  static createCustomMetadataVector(builder, data) {
+    builder.startVector(4, data.length, 4);
+    for (let i2 = data.length - 1; i2 >= 0; i2--) {
+      builder.addOffset(data[i2]);
+    }
+    return builder.endVector();
+  }
+  static startCustomMetadataVector(builder, numElems) {
+    builder.startVector(4, numElems, 4);
+  }
+  static endField(builder) {
+    const offset = builder.endObject();
+    return offset;
+  }
+};
+let Schema$1 = class Schema {
+  constructor() {
+    this.bb = null;
+    this.bb_pos = 0;
+  }
+  __init(i2, bb2) {
+    this.bb_pos = i2;
+    this.bb = bb2;
+    return this;
+  }
+  static getRootAsSchema(bb2, obj) {
+    return (obj || new Schema()).__init(bb2.readInt32(bb2.position()) + bb2.position(), bb2);
+  }
+  static getSizePrefixedRootAsSchema(bb2, obj) {
+    bb2.setPosition(bb2.position() + SIZE_PREFIX_LENGTH);
+    return (obj || new Schema()).__init(bb2.readInt32(bb2.position()) + bb2.position(), bb2);
+  }
+  /**
+   * endianness of the buffer
+   * it is Little Endian by default
+   * if endianness doesn't match the underlying system then the vectors need to be converted
+   */
+  endianness() {
+    const offset = this.bb.__offset(this.bb_pos, 4);
+    return offset ? this.bb.readInt16(this.bb_pos + offset) : Endianness.Little;
+  }
+  fields(index, obj) {
+    const offset = this.bb.__offset(this.bb_pos, 6);
+    return offset ? (obj || new Field$1()).__init(this.bb.__indirect(this.bb.__vector(this.bb_pos + offset) + index * 4), this.bb) : null;
+  }
+  fieldsLength() {
+    const offset = this.bb.__offset(this.bb_pos, 6);
+    return offset ? this.bb.__vector_len(this.bb_pos + offset) : 0;
+  }
+  customMetadata(index, obj) {
+    const offset = this.bb.__offset(this.bb_pos, 8);
+    return offset ? (obj || new KeyValue()).__init(this.bb.__indirect(this.bb.__vector(this.bb_pos + offset) + index * 4), this.bb) : null;
+  }
+  customMetadataLength() {
+    const offset = this.bb.__offset(this.bb_pos, 8);
+    return offset ? this.bb.__vector_len(this.bb_pos + offset) : 0;
+  }
+  /**
+   * Features used in the stream/file.
+   */
+  features(index) {
+    const offset = this.bb.__offset(this.bb_pos, 10);
+    return offset ? this.bb.readInt64(this.bb.__vector(this.bb_pos + offset) + index * 8) : BigInt(0);
+  }
+  featuresLength() {
+    const offset = this.bb.__offset(this.bb_pos, 10);
+    return offset ? this.bb.__vector_len(this.bb_pos + offset) : 0;
+  }
+  static startSchema(builder) {
+    builder.startObject(4);
+  }
+  static addEndianness(builder, endianness) {
+    builder.addFieldInt16(0, endianness, Endianness.Little);
+  }
+  static addFields(builder, fieldsOffset) {
+    builder.addFieldOffset(1, fieldsOffset, 0);
+  }
+  static createFieldsVector(builder, data) {
+    builder.startVector(4, data.length, 4);
+    for (let i2 = data.length - 1; i2 >= 0; i2--) {
+      builder.addOffset(data[i2]);
+    }
+    return builder.endVector();
+  }
+  static startFieldsVector(builder, numElems) {
+    builder.startVector(4, numElems, 4);
+  }
+  static addCustomMetadata(builder, customMetadataOffset) {
+    builder.addFieldOffset(2, customMetadataOffset, 0);
+  }
+  static createCustomMetadataVector(builder, data) {
+    builder.startVector(4, data.length, 4);
+    for (let i2 = data.length - 1; i2 >= 0; i2--) {
+      builder.addOffset(data[i2]);
+    }
+    return builder.endVector();
+  }
+  static startCustomMetadataVector(builder, numElems) {
+    builder.startVector(4, numElems, 4);
+  }
+  static addFeatures(builder, featuresOffset) {
+    builder.addFieldOffset(3, featuresOffset, 0);
+  }
+  static createFeaturesVector(builder, data) {
+    builder.startVector(8, data.length, 8);
+    for (let i2 = data.length - 1; i2 >= 0; i2--) {
+      builder.addInt64(data[i2]);
+    }
+    return builder.endVector();
+  }
+  static startFeaturesVector(builder, numElems) {
+    builder.startVector(8, numElems, 8);
+  }
+  static endSchema(builder) {
+    const offset = builder.endObject();
+    return offset;
+  }
+  static finishSchemaBuffer(builder, offset) {
+    builder.finish(offset);
+  }
+  static finishSizePrefixedSchemaBuffer(builder, offset) {
+    builder.finish(offset, void 0, true);
+  }
+  static createSchema(builder, endianness, fieldsOffset, customMetadataOffset, featuresOffset) {
+    Schema.startSchema(builder);
+    Schema.addEndianness(builder, endianness);
+    Schema.addFields(builder, fieldsOffset);
+    Schema.addCustomMetadata(builder, customMetadataOffset);
+    Schema.addFeatures(builder, featuresOffset);
+    return Schema.endSchema(builder);
+  }
+};
+var MessageHeader;
+(function(MessageHeader2) {
+  MessageHeader2[MessageHeader2["NONE"] = 0] = "NONE";
+  MessageHeader2[MessageHeader2["Schema"] = 1] = "Schema";
+  MessageHeader2[MessageHeader2["DictionaryBatch"] = 2] = "DictionaryBatch";
+  MessageHeader2[MessageHeader2["RecordBatch"] = 3] = "RecordBatch";
+  MessageHeader2[MessageHeader2["Tensor"] = 4] = "Tensor";
+  MessageHeader2[MessageHeader2["SparseTensor"] = 5] = "SparseTensor";
+})(MessageHeader || (MessageHeader = {}));
+var Type;
+(function(Type2) {
+  Type2[Type2["NONE"] = 0] = "NONE";
+  Type2[Type2["Null"] = 1] = "Null";
+  Type2[Type2["Int"] = 2] = "Int";
+  Type2[Type2["Float"] = 3] = "Float";
+  Type2[Type2["Binary"] = 4] = "Binary";
+  Type2[Type2["Utf8"] = 5] = "Utf8";
+  Type2[Type2["Bool"] = 6] = "Bool";
+  Type2[Type2["Decimal"] = 7] = "Decimal";
+  Type2[Type2["Date"] = 8] = "Date";
+  Type2[Type2["Time"] = 9] = "Time";
+  Type2[Type2["Timestamp"] = 10] = "Timestamp";
+  Type2[Type2["Interval"] = 11] = "Interval";
+  Type2[Type2["List"] = 12] = "List";
+  Type2[Type2["Struct"] = 13] = "Struct";
+  Type2[Type2["Union"] = 14] = "Union";
+  Type2[Type2["FixedSizeBinary"] = 15] = "FixedSizeBinary";
+  Type2[Type2["FixedSizeList"] = 16] = "FixedSizeList";
+  Type2[Type2["Map"] = 17] = "Map";
+  Type2[Type2["Duration"] = 18] = "Duration";
+  Type2[Type2["LargeBinary"] = 19] = "LargeBinary";
+  Type2[Type2["LargeUtf8"] = 20] = "LargeUtf8";
+  Type2[Type2["Dictionary"] = -1] = "Dictionary";
+  Type2[Type2["Int8"] = -2] = "Int8";
+  Type2[Type2["Int16"] = -3] = "Int16";
+  Type2[Type2["Int32"] = -4] = "Int32";
+  Type2[Type2["Int64"] = -5] = "Int64";
+  Type2[Type2["Uint8"] = -6] = "Uint8";
+  Type2[Type2["Uint16"] = -7] = "Uint16";
+  Type2[Type2["Uint32"] = -8] = "Uint32";
+  Type2[Type2["Uint64"] = -9] = "Uint64";
+  Type2[Type2["Float16"] = -10] = "Float16";
+  Type2[Type2["Float32"] = -11] = "Float32";
+  Type2[Type2["Float64"] = -12] = "Float64";
+  Type2[Type2["DateDay"] = -13] = "DateDay";
+  Type2[Type2["DateMillisecond"] = -14] = "DateMillisecond";
+  Type2[Type2["TimestampSecond"] = -15] = "TimestampSecond";
+  Type2[Type2["TimestampMillisecond"] = -16] = "TimestampMillisecond";
+  Type2[Type2["TimestampMicrosecond"] = -17] = "TimestampMicrosecond";
+  Type2[Type2["TimestampNanosecond"] = -18] = "TimestampNanosecond";
+  Type2[Type2["TimeSecond"] = -19] = "TimeSecond";
+  Type2[Type2["TimeMillisecond"] = -20] = "TimeMillisecond";
+  Type2[Type2["TimeMicrosecond"] = -21] = "TimeMicrosecond";
+  Type2[Type2["TimeNanosecond"] = -22] = "TimeNanosecond";
+  Type2[Type2["DenseUnion"] = -23] = "DenseUnion";
+  Type2[Type2["SparseUnion"] = -24] = "SparseUnion";
+  Type2[Type2["IntervalDayTime"] = -25] = "IntervalDayTime";
+  Type2[Type2["IntervalYearMonth"] = -26] = "IntervalYearMonth";
+  Type2[Type2["DurationSecond"] = -27] = "DurationSecond";
+  Type2[Type2["DurationMillisecond"] = -28] = "DurationMillisecond";
+  Type2[Type2["DurationMicrosecond"] = -29] = "DurationMicrosecond";
+  Type2[Type2["DurationNanosecond"] = -30] = "DurationNanosecond";
+  Type2[Type2["IntervalMonthDayNano"] = -31] = "IntervalMonthDayNano";
+})(Type || (Type = {}));
+var BufferType;
+(function(BufferType2) {
+  BufferType2[BufferType2["OFFSET"] = 0] = "OFFSET";
+  BufferType2[BufferType2["DATA"] = 1] = "DATA";
+  BufferType2[BufferType2["VALIDITY"] = 2] = "VALIDITY";
+  BufferType2[BufferType2["TYPE"] = 3] = "TYPE";
+})(BufferType || (BufferType = {}));
+const undf = void 0;
+function valueToString(x2) {
+  if (x2 === null) {
+    return "null";
+  }
+  if (x2 === undf) {
+    return "undefined";
+  }
+  switch (typeof x2) {
+    case "number":
+      return `${x2}`;
+    case "bigint":
+      return `${x2}`;
+    case "string":
+      return `"${x2}"`;
+  }
+  if (typeof x2[Symbol.toPrimitive] === "function") {
+    return x2[Symbol.toPrimitive]("string");
+  }
+  if (ArrayBuffer.isView(x2)) {
+    if (x2 instanceof BigInt64Array || x2 instanceof BigUint64Array) {
+      return `[${[...x2].map((x3) => valueToString(x3))}]`;
+    }
+    return `[${x2}]`;
+  }
+  return ArrayBuffer.isView(x2) ? `[${x2}]` : JSON.stringify(x2, (_2, y2) => typeof y2 === "bigint" ? `${y2}` : y2);
+}
+function bigIntToNumber(number) {
+  if (typeof number === "bigint" && (number < Number.MIN_SAFE_INTEGER || number > Number.MAX_SAFE_INTEGER)) {
+    throw new TypeError(`${number} is not safe to convert to a number.`);
+  }
+  return Number(number);
+}
+function divideBigInts(number, divisor) {
+  return bigIntToNumber(number / divisor) + bigIntToNumber(number % divisor) / bigIntToNumber(divisor);
+}
+const isArrowBigNumSymbol = Symbol.for("isArrowBigNum");
+function BigNum(x2, ...xs) {
+  if (xs.length === 0) {
+    return Object.setPrototypeOf(toArrayBufferView(this["TypedArray"], x2), this.constructor.prototype);
+  }
+  return Object.setPrototypeOf(new this["TypedArray"](x2, ...xs), this.constructor.prototype);
+}
+BigNum.prototype[isArrowBigNumSymbol] = true;
+BigNum.prototype.toJSON = function() {
+  return `"${bigNumToString(this)}"`;
+};
+BigNum.prototype.valueOf = function(scale2) {
+  return bigNumToNumber(this, scale2);
+};
+BigNum.prototype.toString = function() {
+  return bigNumToString(this);
+};
+BigNum.prototype[Symbol.toPrimitive] = function(hint2 = "default") {
+  switch (hint2) {
+    case "number":
+      return bigNumToNumber(this);
+    case "string":
+      return bigNumToString(this);
+    case "default":
+      return bigNumToBigInt(this);
+  }
+  return bigNumToString(this);
+};
+function SignedBigNum(...args) {
+  return BigNum.apply(this, args);
+}
+function UnsignedBigNum(...args) {
+  return BigNum.apply(this, args);
+}
+function DecimalBigNum(...args) {
+  return BigNum.apply(this, args);
+}
+Object.setPrototypeOf(SignedBigNum.prototype, Object.create(Int32Array.prototype));
+Object.setPrototypeOf(UnsignedBigNum.prototype, Object.create(Uint32Array.prototype));
+Object.setPrototypeOf(DecimalBigNum.prototype, Object.create(Uint32Array.prototype));
+Object.assign(SignedBigNum.prototype, BigNum.prototype, { "constructor": SignedBigNum, "signed": true, "TypedArray": Int32Array, "BigIntArray": BigInt64Array });
+Object.assign(UnsignedBigNum.prototype, BigNum.prototype, { "constructor": UnsignedBigNum, "signed": false, "TypedArray": Uint32Array, "BigIntArray": BigUint64Array });
+Object.assign(DecimalBigNum.prototype, BigNum.prototype, { "constructor": DecimalBigNum, "signed": true, "TypedArray": Uint32Array, "BigIntArray": BigUint64Array });
+const TWO_TO_THE_64 = BigInt(4294967296) * BigInt(4294967296);
+const TWO_TO_THE_64_MINUS_1 = TWO_TO_THE_64 - BigInt(1);
+function bigNumToNumber(bn, scale2) {
+  const { buffer, byteOffset, byteLength, "signed": signed } = bn;
+  const words = new BigUint64Array(buffer, byteOffset, byteLength / 8);
+  const negative = signed && words.at(-1) & BigInt(1) << BigInt(63);
+  let number = BigInt(0);
+  let i2 = 0;
+  if (negative) {
+    for (const word of words) {
+      number |= (word ^ TWO_TO_THE_64_MINUS_1) * (BigInt(1) << BigInt(64 * i2++));
+    }
+    number *= BigInt(-1);
+    number -= BigInt(1);
+  } else {
+    for (const word of words) {
+      number |= word * (BigInt(1) << BigInt(64 * i2++));
+    }
+  }
+  if (typeof scale2 === "number" && scale2 > 0) {
+    const denominator = BigInt("1".padEnd(scale2 + 1, "0"));
+    const quotient = number / denominator;
+    const remainder = negative ? -(number % denominator) : number % denominator;
+    const integerPart = bigIntToNumber(quotient);
+    const fractionPart = `${remainder}`.padStart(scale2, "0");
+    const sign = negative && integerPart === 0 ? "-" : "";
+    return +`${sign}${integerPart}.${fractionPart}`;
+  }
+  return bigIntToNumber(number);
+}
+function bigNumToString(a2) {
+  if (a2.byteLength === 8) {
+    const bigIntArray = new a2["BigIntArray"](a2.buffer, a2.byteOffset, 1);
+    return `${bigIntArray[0]}`;
+  }
+  if (!a2["signed"]) {
+    return unsignedBigNumToString(a2);
+  }
+  let array = new Uint16Array(a2.buffer, a2.byteOffset, a2.byteLength / 2);
+  const highOrderWord = new Int16Array([array.at(-1)])[0];
+  if (highOrderWord >= 0) {
+    return unsignedBigNumToString(a2);
+  }
+  array = array.slice();
+  let carry = 1;
+  for (let i2 = 0; i2 < array.length; i2++) {
+    const elem = array[i2];
+    const updated = ~elem + carry;
+    array[i2] = updated;
+    carry &= elem === 0 ? 1 : 0;
+  }
+  const negated = unsignedBigNumToString(array);
+  return `-${negated}`;
+}
+function bigNumToBigInt(a2) {
+  if (a2.byteLength === 8) {
+    const bigIntArray = new a2["BigIntArray"](a2.buffer, a2.byteOffset, 1);
+    return bigIntArray[0];
+  } else {
+    return bigNumToString(a2);
+  }
+}
+function unsignedBigNumToString(a2) {
+  let digits = "";
+  const base64 = new Uint32Array(2);
+  let base32 = new Uint16Array(a2.buffer, a2.byteOffset, a2.byteLength / 2);
+  const checks = new Uint32Array((base32 = new Uint16Array(base32).reverse()).buffer);
+  let i2 = -1;
+  const n2 = base32.length - 1;
+  do {
+    for (base64[0] = base32[i2 = 0]; i2 < n2; ) {
+      base32[i2++] = base64[1] = base64[0] / 10;
+      base64[0] = (base64[0] - base64[1] * 10 << 16) + base32[i2];
+    }
+    base32[i2] = base64[1] = base64[0] / 10;
+    base64[0] = base64[0] - base64[1] * 10;
+    digits = `${base64[0]}${digits}`;
+  } while (checks[0] || checks[1] || checks[2] || checks[3]);
+  return digits !== null && digits !== void 0 ? digits : `0`;
+}
+class BN {
+  /** @nocollapse */
+  static new(num, isSigned) {
+    switch (isSigned) {
+      case true:
+        return new SignedBigNum(num);
+      case false:
+        return new UnsignedBigNum(num);
+    }
+    switch (num.constructor) {
+      case Int8Array:
+      case Int16Array:
+      case Int32Array:
+      case BigInt64Array:
+        return new SignedBigNum(num);
+    }
+    if (num.byteLength === 16) {
+      return new DecimalBigNum(num);
+    }
+    return new UnsignedBigNum(num);
+  }
+  /** @nocollapse */
+  static signed(num) {
+    return new SignedBigNum(num);
+  }
+  /** @nocollapse */
+  static unsigned(num) {
+    return new UnsignedBigNum(num);
+  }
+  /** @nocollapse */
+  static decimal(num) {
+    return new DecimalBigNum(num);
+  }
+  constructor(num, isSigned) {
+    return BN.new(num, isSigned);
+  }
+}
+var _a$3, _b, _c, _d, _e$1, _f, _g, _h, _j, _k, _l, _m, _o, _p, _q, _r, _s, _t$1, _u, _v, _w, _x;
+class DataType {
+  /** @nocollapse */
+  static isNull(x2) {
+    return (x2 === null || x2 === void 0 ? void 0 : x2.typeId) === Type.Null;
+  }
+  /** @nocollapse */
+  static isInt(x2) {
+    return (x2 === null || x2 === void 0 ? void 0 : x2.typeId) === Type.Int;
+  }
+  /** @nocollapse */
+  static isFloat(x2) {
+    return (x2 === null || x2 === void 0 ? void 0 : x2.typeId) === Type.Float;
+  }
+  /** @nocollapse */
+  static isBinary(x2) {
+    return (x2 === null || x2 === void 0 ? void 0 : x2.typeId) === Type.Binary;
+  }
+  /** @nocollapse */
+  static isLargeBinary(x2) {
+    return (x2 === null || x2 === void 0 ? void 0 : x2.typeId) === Type.LargeBinary;
+  }
+  /** @nocollapse */
+  static isUtf8(x2) {
+    return (x2 === null || x2 === void 0 ? void 0 : x2.typeId) === Type.Utf8;
+  }
+  /** @nocollapse */
+  static isLargeUtf8(x2) {
+    return (x2 === null || x2 === void 0 ? void 0 : x2.typeId) === Type.LargeUtf8;
+  }
+  /** @nocollapse */
+  static isBool(x2) {
+    return (x2 === null || x2 === void 0 ? void 0 : x2.typeId) === Type.Bool;
+  }
+  /** @nocollapse */
+  static isDecimal(x2) {
+    return (x2 === null || x2 === void 0 ? void 0 : x2.typeId) === Type.Decimal;
+  }
+  /** @nocollapse */
+  static isDate(x2) {
+    return (x2 === null || x2 === void 0 ? void 0 : x2.typeId) === Type.Date;
+  }
+  /** @nocollapse */
+  static isTime(x2) {
+    return (x2 === null || x2 === void 0 ? void 0 : x2.typeId) === Type.Time;
+  }
+  /** @nocollapse */
+  static isTimestamp(x2) {
+    return (x2 === null || x2 === void 0 ? void 0 : x2.typeId) === Type.Timestamp;
+  }
+  /** @nocollapse */
+  static isInterval(x2) {
+    return (x2 === null || x2 === void 0 ? void 0 : x2.typeId) === Type.Interval;
+  }
+  /** @nocollapse */
+  static isDuration(x2) {
+    return (x2 === null || x2 === void 0 ? void 0 : x2.typeId) === Type.Duration;
+  }
+  /** @nocollapse */
+  static isList(x2) {
+    return (x2 === null || x2 === void 0 ? void 0 : x2.typeId) === Type.List;
+  }
+  /** @nocollapse */
+  static isStruct(x2) {
+    return (x2 === null || x2 === void 0 ? void 0 : x2.typeId) === Type.Struct;
+  }
+  /** @nocollapse */
+  static isUnion(x2) {
+    return (x2 === null || x2 === void 0 ? void 0 : x2.typeId) === Type.Union;
+  }
+  /** @nocollapse */
+  static isFixedSizeBinary(x2) {
+    return (x2 === null || x2 === void 0 ? void 0 : x2.typeId) === Type.FixedSizeBinary;
+  }
+  /** @nocollapse */
+  static isFixedSizeList(x2) {
+    return (x2 === null || x2 === void 0 ? void 0 : x2.typeId) === Type.FixedSizeList;
+  }
+  /** @nocollapse */
+  static isMap(x2) {
+    return (x2 === null || x2 === void 0 ? void 0 : x2.typeId) === Type.Map;
+  }
+  /** @nocollapse */
+  static isDictionary(x2) {
+    return (x2 === null || x2 === void 0 ? void 0 : x2.typeId) === Type.Dictionary;
+  }
+  /** @nocollapse */
+  static isDenseUnion(x2) {
+    return DataType.isUnion(x2) && x2.mode === UnionMode.Dense;
+  }
+  /** @nocollapse */
+  static isSparseUnion(x2) {
+    return DataType.isUnion(x2) && x2.mode === UnionMode.Sparse;
+  }
+  constructor(typeId) {
+    this.typeId = typeId;
+  }
+}
+_a$3 = Symbol.toStringTag;
+DataType[_a$3] = ((proto) => {
+  proto.children = null;
+  proto.ArrayType = Array;
+  proto.OffsetArrayType = Int32Array;
+  return proto[Symbol.toStringTag] = "DataType";
+})(DataType.prototype);
+class Null2 extends DataType {
+  constructor() {
+    super(Type.Null);
+  }
+  toString() {
+    return `Null`;
+  }
+}
+_b = Symbol.toStringTag;
+Null2[_b] = ((proto) => proto[Symbol.toStringTag] = "Null")(Null2.prototype);
+class Int_ extends DataType {
+  constructor(isSigned, bitWidth) {
+    super(Type.Int);
+    this.isSigned = isSigned;
+    this.bitWidth = bitWidth;
+  }
+  get ArrayType() {
+    switch (this.bitWidth) {
+      case 8:
+        return this.isSigned ? Int8Array : Uint8Array;
+      case 16:
+        return this.isSigned ? Int16Array : Uint16Array;
+      case 32:
+        return this.isSigned ? Int32Array : Uint32Array;
+      case 64:
+        return this.isSigned ? BigInt64Array : BigUint64Array;
+    }
+    throw new Error(`Unrecognized ${this[Symbol.toStringTag]} type`);
+  }
+  toString() {
+    return `${this.isSigned ? `I` : `Ui`}nt${this.bitWidth}`;
+  }
+}
+_c = Symbol.toStringTag;
+Int_[_c] = ((proto) => {
+  proto.isSigned = null;
+  proto.bitWidth = null;
+  return proto[Symbol.toStringTag] = "Int";
+})(Int_.prototype);
+class Int32 extends Int_ {
+  constructor() {
+    super(true, 32);
+  }
+  get ArrayType() {
+    return Int32Array;
+  }
+}
+Object.defineProperty(Int32.prototype, "ArrayType", { value: Int32Array });
+class Float extends DataType {
+  constructor(precision) {
+    super(Type.Float);
+    this.precision = precision;
+  }
+  get ArrayType() {
+    switch (this.precision) {
+      case Precision.HALF:
+        return Uint16Array;
+      case Precision.SINGLE:
+        return Float32Array;
+      case Precision.DOUBLE:
+        return Float64Array;
+    }
+    throw new Error(`Unrecognized ${this[Symbol.toStringTag]} type`);
+  }
+  toString() {
+    return `Float${this.precision << 5 || 16}`;
+  }
+}
+_d = Symbol.toStringTag;
+Float[_d] = ((proto) => {
+  proto.precision = null;
+  return proto[Symbol.toStringTag] = "Float";
+})(Float.prototype);
+class Binary2 extends DataType {
+  constructor() {
+    super(Type.Binary);
+  }
+  toString() {
+    return `Binary`;
+  }
+}
+_e$1 = Symbol.toStringTag;
+Binary2[_e$1] = ((proto) => {
+  proto.ArrayType = Uint8Array;
+  return proto[Symbol.toStringTag] = "Binary";
+})(Binary2.prototype);
+class LargeBinary2 extends DataType {
+  constructor() {
+    super(Type.LargeBinary);
+  }
+  toString() {
+    return `LargeBinary`;
+  }
+}
+_f = Symbol.toStringTag;
+LargeBinary2[_f] = ((proto) => {
+  proto.ArrayType = Uint8Array;
+  proto.OffsetArrayType = BigInt64Array;
+  return proto[Symbol.toStringTag] = "LargeBinary";
+})(LargeBinary2.prototype);
+class Utf82 extends DataType {
+  constructor() {
+    super(Type.Utf8);
+  }
+  toString() {
+    return `Utf8`;
+  }
+}
+_g = Symbol.toStringTag;
+Utf82[_g] = ((proto) => {
+  proto.ArrayType = Uint8Array;
+  return proto[Symbol.toStringTag] = "Utf8";
+})(Utf82.prototype);
+class LargeUtf82 extends DataType {
+  constructor() {
+    super(Type.LargeUtf8);
+  }
+  toString() {
+    return `LargeUtf8`;
+  }
+}
+_h = Symbol.toStringTag;
+LargeUtf82[_h] = ((proto) => {
+  proto.ArrayType = Uint8Array;
+  proto.OffsetArrayType = BigInt64Array;
+  return proto[Symbol.toStringTag] = "LargeUtf8";
+})(LargeUtf82.prototype);
+class Bool2 extends DataType {
+  constructor() {
+    super(Type.Bool);
+  }
+  toString() {
+    return `Bool`;
+  }
+}
+_j = Symbol.toStringTag;
+Bool2[_j] = ((proto) => {
+  proto.ArrayType = Uint8Array;
+  return proto[Symbol.toStringTag] = "Bool";
+})(Bool2.prototype);
+class Decimal2 extends DataType {
+  constructor(scale2, precision, bitWidth = 128) {
+    super(Type.Decimal);
+    this.scale = scale2;
+    this.precision = precision;
+    this.bitWidth = bitWidth;
+  }
+  toString() {
+    return `Decimal[${this.precision}e${this.scale > 0 ? `+` : ``}${this.scale}]`;
+  }
+}
+_k = Symbol.toStringTag;
+Decimal2[_k] = ((proto) => {
+  proto.scale = null;
+  proto.precision = null;
+  proto.ArrayType = Uint32Array;
+  return proto[Symbol.toStringTag] = "Decimal";
+})(Decimal2.prototype);
+class Date_ extends DataType {
+  constructor(unit) {
+    super(Type.Date);
+    this.unit = unit;
+  }
+  toString() {
+    return `Date${(this.unit + 1) * 32}<${DateUnit[this.unit]}>`;
+  }
+  get ArrayType() {
+    return this.unit === DateUnit.DAY ? Int32Array : BigInt64Array;
+  }
+}
+_l = Symbol.toStringTag;
+Date_[_l] = ((proto) => {
+  proto.unit = null;
+  return proto[Symbol.toStringTag] = "Date";
+})(Date_.prototype);
+class Time_ extends DataType {
+  constructor(unit, bitWidth) {
+    super(Type.Time);
+    this.unit = unit;
+    this.bitWidth = bitWidth;
+  }
+  toString() {
+    return `Time${this.bitWidth}<${TimeUnit[this.unit]}>`;
+  }
+  get ArrayType() {
+    switch (this.bitWidth) {
+      case 32:
+        return Int32Array;
+      case 64:
+        return BigInt64Array;
+    }
+    throw new Error(`Unrecognized ${this[Symbol.toStringTag]} type`);
+  }
+}
+_m = Symbol.toStringTag;
+Time_[_m] = ((proto) => {
+  proto.unit = null;
+  proto.bitWidth = null;
+  return proto[Symbol.toStringTag] = "Time";
+})(Time_.prototype);
+class Timestamp_ extends DataType {
+  constructor(unit, timezone) {
+    super(Type.Timestamp);
+    this.unit = unit;
+    this.timezone = timezone;
+  }
+  toString() {
+    return `Timestamp<${TimeUnit[this.unit]}${this.timezone ? `, ${this.timezone}` : ``}>`;
+  }
+}
+_o = Symbol.toStringTag;
+Timestamp_[_o] = ((proto) => {
+  proto.unit = null;
+  proto.timezone = null;
+  proto.ArrayType = BigInt64Array;
+  return proto[Symbol.toStringTag] = "Timestamp";
+})(Timestamp_.prototype);
+class Interval_ extends DataType {
+  constructor(unit) {
+    super(Type.Interval);
+    this.unit = unit;
+  }
+  toString() {
+    return `Interval<${IntervalUnit[this.unit]}>`;
+  }
+}
+_p = Symbol.toStringTag;
+Interval_[_p] = ((proto) => {
+  proto.unit = null;
+  proto.ArrayType = Int32Array;
+  return proto[Symbol.toStringTag] = "Interval";
+})(Interval_.prototype);
+class Duration2 extends DataType {
+  constructor(unit) {
+    super(Type.Duration);
+    this.unit = unit;
+  }
+  toString() {
+    return `Duration<${TimeUnit[this.unit]}>`;
+  }
+}
+_q = Symbol.toStringTag;
+Duration2[_q] = ((proto) => {
+  proto.unit = null;
+  proto.ArrayType = BigInt64Array;
+  return proto[Symbol.toStringTag] = "Duration";
+})(Duration2.prototype);
+class List2 extends DataType {
+  constructor(child) {
+    super(Type.List);
+    this.children = [child];
+  }
+  toString() {
+    return `List<${this.valueType}>`;
+  }
+  get valueType() {
+    return this.children[0].type;
+  }
+  get valueField() {
+    return this.children[0];
+  }
+  get ArrayType() {
+    return this.valueType.ArrayType;
+  }
+}
+_r = Symbol.toStringTag;
+List2[_r] = ((proto) => {
+  proto.children = null;
+  return proto[Symbol.toStringTag] = "List";
+})(List2.prototype);
+class Struct extends DataType {
+  constructor(children) {
+    super(Type.Struct);
+    this.children = children;
+  }
+  toString() {
+    return `Struct<{${this.children.map((f2) => `${f2.name}:${f2.type}`).join(`, `)}}>`;
+  }
+}
+_s = Symbol.toStringTag;
+Struct[_s] = ((proto) => {
+  proto.children = null;
+  return proto[Symbol.toStringTag] = "Struct";
+})(Struct.prototype);
+class Union_ extends DataType {
+  constructor(mode, typeIds, children) {
+    super(Type.Union);
+    this.mode = mode;
+    this.children = children;
+    this.typeIds = typeIds = Int32Array.from(typeIds);
+    this.typeIdToChildIndex = typeIds.reduce((typeIdToChildIndex, typeId, idx) => (typeIdToChildIndex[typeId] = idx) && typeIdToChildIndex || typeIdToChildIndex, /* @__PURE__ */ Object.create(null));
+  }
+  toString() {
+    return `${this[Symbol.toStringTag]}<${this.children.map((x2) => `${x2.type}`).join(` | `)}>`;
+  }
+}
+_t$1 = Symbol.toStringTag;
+Union_[_t$1] = ((proto) => {
+  proto.mode = null;
+  proto.typeIds = null;
+  proto.children = null;
+  proto.typeIdToChildIndex = null;
+  proto.ArrayType = Int8Array;
+  return proto[Symbol.toStringTag] = "Union";
+})(Union_.prototype);
+class FixedSizeBinary2 extends DataType {
+  constructor(byteWidth) {
+    super(Type.FixedSizeBinary);
+    this.byteWidth = byteWidth;
+  }
+  toString() {
+    return `FixedSizeBinary[${this.byteWidth}]`;
+  }
+}
+_u = Symbol.toStringTag;
+FixedSizeBinary2[_u] = ((proto) => {
+  proto.byteWidth = null;
+  proto.ArrayType = Uint8Array;
+  return proto[Symbol.toStringTag] = "FixedSizeBinary";
+})(FixedSizeBinary2.prototype);
+class FixedSizeList2 extends DataType {
+  constructor(listSize, child) {
+    super(Type.FixedSizeList);
+    this.listSize = listSize;
+    this.children = [child];
+  }
+  get valueType() {
+    return this.children[0].type;
+  }
+  get valueField() {
+    return this.children[0];
+  }
+  get ArrayType() {
+    return this.valueType.ArrayType;
+  }
+  toString() {
+    return `FixedSizeList[${this.listSize}]<${this.valueType}>`;
+  }
+}
+_v = Symbol.toStringTag;
+FixedSizeList2[_v] = ((proto) => {
+  proto.children = null;
+  proto.listSize = null;
+  return proto[Symbol.toStringTag] = "FixedSizeList";
+})(FixedSizeList2.prototype);
+class Map_ extends DataType {
+  constructor(entries, keysSorted = false) {
+    var _y, _z, _0;
+    super(Type.Map);
+    this.children = [entries];
+    this.keysSorted = keysSorted;
+    if (entries) {
+      entries["name"] = "entries";
+      if ((_y = entries === null || entries === void 0 ? void 0 : entries.type) === null || _y === void 0 ? void 0 : _y.children) {
+        const key = (_z = entries === null || entries === void 0 ? void 0 : entries.type) === null || _z === void 0 ? void 0 : _z.children[0];
+        if (key) {
+          key["name"] = "key";
+        }
+        const val = (_0 = entries === null || entries === void 0 ? void 0 : entries.type) === null || _0 === void 0 ? void 0 : _0.children[1];
+        if (val) {
+          val["name"] = "value";
+        }
+      }
+    }
+  }
+  get keyType() {
+    return this.children[0].type.children[0].type;
+  }
+  get valueType() {
+    return this.children[0].type.children[1].type;
+  }
+  get childType() {
+    return this.children[0].type;
+  }
+  toString() {
+    return `Map<{${this.children[0].type.children.map((f2) => `${f2.name}:${f2.type}`).join(`, `)}}>`;
+  }
+}
+_w = Symbol.toStringTag;
+Map_[_w] = ((proto) => {
+  proto.children = null;
+  proto.keysSorted = null;
+  return proto[Symbol.toStringTag] = "Map_";
+})(Map_.prototype);
+const getId = /* @__PURE__ */ ((atomicDictionaryId) => () => ++atomicDictionaryId)(-1);
+class Dictionary extends DataType {
+  constructor(dictionary, indices, id2, isOrdered) {
+    super(Type.Dictionary);
+    this.indices = indices;
+    this.dictionary = dictionary;
+    this.isOrdered = isOrdered || false;
+    this.id = id2 == null ? getId() : bigIntToNumber(id2);
+  }
+  get children() {
+    return this.dictionary.children;
+  }
+  get valueType() {
+    return this.dictionary;
+  }
+  get ArrayType() {
+    return this.dictionary.ArrayType;
+  }
+  toString() {
+    return `Dictionary<${this.indices}, ${this.dictionary}>`;
+  }
+}
+_x = Symbol.toStringTag;
+Dictionary[_x] = ((proto) => {
+  proto.id = null;
+  proto.indices = null;
+  proto.isOrdered = null;
+  proto.dictionary = null;
+  return proto[Symbol.toStringTag] = "Dictionary";
+})(Dictionary.prototype);
+function strideForType(type) {
+  const t2 = type;
+  switch (type.typeId) {
+    case Type.Decimal:
+      return type.bitWidth / 32;
+    case Type.Interval: {
+      if (t2.unit === IntervalUnit.MONTH_DAY_NANO) {
+        return 4;
+      }
+      return 1 + t2.unit;
+    }
+    case Type.FixedSizeList:
+      return t2.listSize;
+    case Type.FixedSizeBinary:
+      return t2.byteWidth;
+    default:
+      return 1;
+  }
+}
+class Visitor {
+  visitMany(nodes, ...args) {
+    return nodes.map((node, i2) => this.visit(node, ...args.map((x2) => x2[i2])));
+  }
+  visit(...args) {
+    return this.getVisitFn(args[0], false).apply(this, args);
+  }
+  getVisitFn(node, throwIfNotFound = true) {
+    return getVisitFn(this, node, throwIfNotFound);
+  }
+  getVisitFnByTypeId(typeId, throwIfNotFound = true) {
+    return getVisitFnByTypeId(this, typeId, throwIfNotFound);
+  }
+  visitNull(_node, ..._args) {
+    return null;
+  }
+  visitBool(_node, ..._args) {
+    return null;
+  }
+  visitInt(_node, ..._args) {
+    return null;
+  }
+  visitFloat(_node, ..._args) {
+    return null;
+  }
+  visitUtf8(_node, ..._args) {
+    return null;
+  }
+  visitLargeUtf8(_node, ..._args) {
+    return null;
+  }
+  visitBinary(_node, ..._args) {
+    return null;
+  }
+  visitLargeBinary(_node, ..._args) {
+    return null;
+  }
+  visitFixedSizeBinary(_node, ..._args) {
+    return null;
+  }
+  visitDate(_node, ..._args) {
+    return null;
+  }
+  visitTimestamp(_node, ..._args) {
+    return null;
+  }
+  visitTime(_node, ..._args) {
+    return null;
+  }
+  visitDecimal(_node, ..._args) {
+    return null;
+  }
+  visitList(_node, ..._args) {
+    return null;
+  }
+  visitStruct(_node, ..._args) {
+    return null;
+  }
+  visitUnion(_node, ..._args) {
+    return null;
+  }
+  visitDictionary(_node, ..._args) {
+    return null;
+  }
+  visitInterval(_node, ..._args) {
+    return null;
+  }
+  visitDuration(_node, ..._args) {
+    return null;
+  }
+  visitFixedSizeList(_node, ..._args) {
+    return null;
+  }
+  visitMap(_node, ..._args) {
+    return null;
+  }
+}
+function getVisitFn(visitor, node, throwIfNotFound = true) {
+  if (typeof node === "number") {
+    return getVisitFnByTypeId(visitor, node, throwIfNotFound);
+  }
+  if (typeof node === "string" && node in Type) {
+    return getVisitFnByTypeId(visitor, Type[node], throwIfNotFound);
+  }
+  if (node && node instanceof DataType) {
+    return getVisitFnByTypeId(visitor, inferDType(node), throwIfNotFound);
+  }
+  if ((node === null || node === void 0 ? void 0 : node.type) && node.type instanceof DataType) {
+    return getVisitFnByTypeId(visitor, inferDType(node.type), throwIfNotFound);
+  }
+  return getVisitFnByTypeId(visitor, Type.NONE, throwIfNotFound);
+}
+function getVisitFnByTypeId(visitor, dtype, throwIfNotFound = true) {
+  let fn = null;
+  switch (dtype) {
+    case Type.Null:
+      fn = visitor.visitNull;
+      break;
+    case Type.Bool:
+      fn = visitor.visitBool;
+      break;
+    case Type.Int:
+      fn = visitor.visitInt;
+      break;
+    case Type.Int8:
+      fn = visitor.visitInt8 || visitor.visitInt;
+      break;
+    case Type.Int16:
+      fn = visitor.visitInt16 || visitor.visitInt;
+      break;
+    case Type.Int32:
+      fn = visitor.visitInt32 || visitor.visitInt;
+      break;
+    case Type.Int64:
+      fn = visitor.visitInt64 || visitor.visitInt;
+      break;
+    case Type.Uint8:
+      fn = visitor.visitUint8 || visitor.visitInt;
+      break;
+    case Type.Uint16:
+      fn = visitor.visitUint16 || visitor.visitInt;
+      break;
+    case Type.Uint32:
+      fn = visitor.visitUint32 || visitor.visitInt;
+      break;
+    case Type.Uint64:
+      fn = visitor.visitUint64 || visitor.visitInt;
+      break;
+    case Type.Float:
+      fn = visitor.visitFloat;
+      break;
+    case Type.Float16:
+      fn = visitor.visitFloat16 || visitor.visitFloat;
+      break;
+    case Type.Float32:
+      fn = visitor.visitFloat32 || visitor.visitFloat;
+      break;
+    case Type.Float64:
+      fn = visitor.visitFloat64 || visitor.visitFloat;
+      break;
+    case Type.Utf8:
+      fn = visitor.visitUtf8;
+      break;
+    case Type.LargeUtf8:
+      fn = visitor.visitLargeUtf8;
+      break;
+    case Type.Binary:
+      fn = visitor.visitBinary;
+      break;
+    case Type.LargeBinary:
+      fn = visitor.visitLargeBinary;
+      break;
+    case Type.FixedSizeBinary:
+      fn = visitor.visitFixedSizeBinary;
+      break;
+    case Type.Date:
+      fn = visitor.visitDate;
+      break;
+    case Type.DateDay:
+      fn = visitor.visitDateDay || visitor.visitDate;
+      break;
+    case Type.DateMillisecond:
+      fn = visitor.visitDateMillisecond || visitor.visitDate;
+      break;
+    case Type.Timestamp:
+      fn = visitor.visitTimestamp;
+      break;
+    case Type.TimestampSecond:
+      fn = visitor.visitTimestampSecond || visitor.visitTimestamp;
+      break;
+    case Type.TimestampMillisecond:
+      fn = visitor.visitTimestampMillisecond || visitor.visitTimestamp;
+      break;
+    case Type.TimestampMicrosecond:
+      fn = visitor.visitTimestampMicrosecond || visitor.visitTimestamp;
+      break;
+    case Type.TimestampNanosecond:
+      fn = visitor.visitTimestampNanosecond || visitor.visitTimestamp;
+      break;
+    case Type.Time:
+      fn = visitor.visitTime;
+      break;
+    case Type.TimeSecond:
+      fn = visitor.visitTimeSecond || visitor.visitTime;
+      break;
+    case Type.TimeMillisecond:
+      fn = visitor.visitTimeMillisecond || visitor.visitTime;
+      break;
+    case Type.TimeMicrosecond:
+      fn = visitor.visitTimeMicrosecond || visitor.visitTime;
+      break;
+    case Type.TimeNanosecond:
+      fn = visitor.visitTimeNanosecond || visitor.visitTime;
+      break;
+    case Type.Decimal:
+      fn = visitor.visitDecimal;
+      break;
+    case Type.List:
+      fn = visitor.visitList;
+      break;
+    case Type.Struct:
+      fn = visitor.visitStruct;
+      break;
+    case Type.Union:
+      fn = visitor.visitUnion;
+      break;
+    case Type.DenseUnion:
+      fn = visitor.visitDenseUnion || visitor.visitUnion;
+      break;
+    case Type.SparseUnion:
+      fn = visitor.visitSparseUnion || visitor.visitUnion;
+      break;
+    case Type.Dictionary:
+      fn = visitor.visitDictionary;
+      break;
+    case Type.Interval:
+      fn = visitor.visitInterval;
+      break;
+    case Type.IntervalDayTime:
+      fn = visitor.visitIntervalDayTime || visitor.visitInterval;
+      break;
+    case Type.IntervalYearMonth:
+      fn = visitor.visitIntervalYearMonth || visitor.visitInterval;
+      break;
+    case Type.IntervalMonthDayNano:
+      fn = visitor.visitIntervalMonthDayNano || visitor.visitInterval;
+      break;
+    case Type.Duration:
+      fn = visitor.visitDuration;
+      break;
+    case Type.DurationSecond:
+      fn = visitor.visitDurationSecond || visitor.visitDuration;
+      break;
+    case Type.DurationMillisecond:
+      fn = visitor.visitDurationMillisecond || visitor.visitDuration;
+      break;
+    case Type.DurationMicrosecond:
+      fn = visitor.visitDurationMicrosecond || visitor.visitDuration;
+      break;
+    case Type.DurationNanosecond:
+      fn = visitor.visitDurationNanosecond || visitor.visitDuration;
+      break;
+    case Type.FixedSizeList:
+      fn = visitor.visitFixedSizeList;
+      break;
+    case Type.Map:
+      fn = visitor.visitMap;
+      break;
+  }
+  if (typeof fn === "function")
+    return fn;
+  if (!throwIfNotFound)
+    return () => null;
+  throw new Error(`Unrecognized type '${Type[dtype]}'`);
+}
+function inferDType(type) {
+  switch (type.typeId) {
+    case Type.Null:
+      return Type.Null;
+    case Type.Int: {
+      const { bitWidth, isSigned } = type;
+      switch (bitWidth) {
+        case 8:
+          return isSigned ? Type.Int8 : Type.Uint8;
+        case 16:
+          return isSigned ? Type.Int16 : Type.Uint16;
+        case 32:
+          return isSigned ? Type.Int32 : Type.Uint32;
+        case 64:
+          return isSigned ? Type.Int64 : Type.Uint64;
+      }
+      return Type.Int;
+    }
+    case Type.Float:
+      switch (type.precision) {
+        case Precision.HALF:
+          return Type.Float16;
+        case Precision.SINGLE:
+          return Type.Float32;
+        case Precision.DOUBLE:
+          return Type.Float64;
+      }
+      return Type.Float;
+    case Type.Binary:
+      return Type.Binary;
+    case Type.LargeBinary:
+      return Type.LargeBinary;
+    case Type.Utf8:
+      return Type.Utf8;
+    case Type.LargeUtf8:
+      return Type.LargeUtf8;
+    case Type.Bool:
+      return Type.Bool;
+    case Type.Decimal:
+      return Type.Decimal;
+    case Type.Time:
+      switch (type.unit) {
+        case TimeUnit.SECOND:
+          return Type.TimeSecond;
+        case TimeUnit.MILLISECOND:
+          return Type.TimeMillisecond;
+        case TimeUnit.MICROSECOND:
+          return Type.TimeMicrosecond;
+        case TimeUnit.NANOSECOND:
+          return Type.TimeNanosecond;
+      }
+      return Type.Time;
+    case Type.Timestamp:
+      switch (type.unit) {
+        case TimeUnit.SECOND:
+          return Type.TimestampSecond;
+        case TimeUnit.MILLISECOND:
+          return Type.TimestampMillisecond;
+        case TimeUnit.MICROSECOND:
+          return Type.TimestampMicrosecond;
+        case TimeUnit.NANOSECOND:
+          return Type.TimestampNanosecond;
+      }
+      return Type.Timestamp;
+    case Type.Date:
+      switch (type.unit) {
+        case DateUnit.DAY:
+          return Type.DateDay;
+        case DateUnit.MILLISECOND:
+          return Type.DateMillisecond;
+      }
+      return Type.Date;
+    case Type.Interval:
+      switch (type.unit) {
+        case IntervalUnit.DAY_TIME:
+          return Type.IntervalDayTime;
+        case IntervalUnit.YEAR_MONTH:
+          return Type.IntervalYearMonth;
+        case IntervalUnit.MONTH_DAY_NANO:
+          return Type.IntervalMonthDayNano;
+      }
+      return Type.Interval;
+    case Type.Duration:
+      switch (type.unit) {
+        case TimeUnit.SECOND:
+          return Type.DurationSecond;
+        case TimeUnit.MILLISECOND:
+          return Type.DurationMillisecond;
+        case TimeUnit.MICROSECOND:
+          return Type.DurationMicrosecond;
+        case TimeUnit.NANOSECOND:
+          return Type.DurationNanosecond;
+      }
+      return Type.Duration;
+    case Type.Map:
+      return Type.Map;
+    case Type.List:
+      return Type.List;
+    case Type.Struct:
+      return Type.Struct;
+    case Type.Union:
+      switch (type.mode) {
+        case UnionMode.Dense:
+          return Type.DenseUnion;
+        case UnionMode.Sparse:
+          return Type.SparseUnion;
+      }
+      return Type.Union;
+    case Type.FixedSizeBinary:
+      return Type.FixedSizeBinary;
+    case Type.FixedSizeList:
+      return Type.FixedSizeList;
+    case Type.Dictionary:
+      return Type.Dictionary;
+  }
+  throw new Error(`Unrecognized type '${Type[type.typeId]}'`);
+}
+Visitor.prototype.visitInt8 = null;
+Visitor.prototype.visitInt16 = null;
+Visitor.prototype.visitInt32 = null;
+Visitor.prototype.visitInt64 = null;
+Visitor.prototype.visitUint8 = null;
+Visitor.prototype.visitUint16 = null;
+Visitor.prototype.visitUint32 = null;
+Visitor.prototype.visitUint64 = null;
+Visitor.prototype.visitFloat16 = null;
+Visitor.prototype.visitFloat32 = null;
+Visitor.prototype.visitFloat64 = null;
+Visitor.prototype.visitDateDay = null;
+Visitor.prototype.visitDateMillisecond = null;
+Visitor.prototype.visitTimestampSecond = null;
+Visitor.prototype.visitTimestampMillisecond = null;
+Visitor.prototype.visitTimestampMicrosecond = null;
+Visitor.prototype.visitTimestampNanosecond = null;
+Visitor.prototype.visitTimeSecond = null;
+Visitor.prototype.visitTimeMillisecond = null;
+Visitor.prototype.visitTimeMicrosecond = null;
+Visitor.prototype.visitTimeNanosecond = null;
+Visitor.prototype.visitDenseUnion = null;
+Visitor.prototype.visitSparseUnion = null;
+Visitor.prototype.visitIntervalDayTime = null;
+Visitor.prototype.visitIntervalYearMonth = null;
+Visitor.prototype.visitIntervalMonthDayNano = null;
+Visitor.prototype.visitDuration = null;
+Visitor.prototype.visitDurationSecond = null;
+Visitor.prototype.visitDurationMillisecond = null;
+Visitor.prototype.visitDurationMicrosecond = null;
+Visitor.prototype.visitDurationNanosecond = null;
+const f64 = new Float64Array(1);
+const u32 = new Uint32Array(f64.buffer);
+function uint16ToFloat64(h2) {
+  const expo = (h2 & 31744) >> 10;
+  const sigf = (h2 & 1023) / 1024;
+  const sign = Math.pow(-1, (h2 & 32768) >> 15);
+  switch (expo) {
+    case 31:
+      return sign * (sigf ? Number.NaN : 1 / 0);
+    case 0:
+      return sign * (sigf ? 6103515625e-14 * sigf : 0);
+  }
+  return sign * Math.pow(2, expo - 15) * (1 + sigf);
+}
+function float64ToUint16(d2) {
+  if (d2 !== d2) {
+    return 32256;
+  }
+  f64[0] = d2;
+  const sign = (u32[1] & 2147483648) >> 16 & 65535;
+  let expo = u32[1] & 2146435072, sigf = 0;
+  if (expo >= 1089470464) {
+    if (u32[0] > 0) {
+      expo = 31744;
+    } else {
+      expo = (expo & 2080374784) >> 16;
+      sigf = (u32[1] & 1048575) >> 10;
+    }
+  } else if (expo <= 1056964608) {
+    sigf = 1048576 + (u32[1] & 1048575);
+    sigf = 1048576 + (sigf << (expo >> 20) - 998) >> 21;
+    expo = 0;
+  } else {
+    expo = expo - 1056964608 >> 10;
+    sigf = (u32[1] & 1048575) + 512 >> 10;
+  }
+  return sign | expo | sigf & 65535;
+}
+class SetVisitor extends Visitor {
+}
+function wrapSet(fn) {
+  return (data, _1, _2) => {
+    if (data.setValid(_1, _2 != null)) {
+      return fn(data, _1, _2);
+    }
+  };
+}
+const setEpochMsToDays = (data, index, epochMs) => {
+  data[index] = Math.floor(epochMs / 864e5);
+};
+const setVariableWidthBytes = (values, valueOffsets, index, value) => {
+  if (index + 1 < valueOffsets.length) {
+    const x2 = bigIntToNumber(valueOffsets[index]);
+    const y2 = bigIntToNumber(valueOffsets[index + 1]);
+    values.set(value.subarray(0, y2 - x2), x2);
+  }
+};
+const setBool = ({ offset, values }, index, val) => {
+  const idx = offset + index;
+  val ? values[idx >> 3] |= 1 << idx % 8 : values[idx >> 3] &= ~(1 << idx % 8);
+};
+const setInt = ({ values }, index, value) => {
+  values[index] = value;
+};
+const setFloat = ({ values }, index, value) => {
+  values[index] = value;
+};
+const setFloat16 = ({ values }, index, value) => {
+  values[index] = float64ToUint16(value);
+};
+const setAnyFloat = (data, index, value) => {
+  switch (data.type.precision) {
+    case Precision.HALF:
+      return setFloat16(data, index, value);
+    case Precision.SINGLE:
+    case Precision.DOUBLE:
+      return setFloat(data, index, value);
+  }
+};
+const setDateDay = ({ values }, index, value) => {
+  setEpochMsToDays(values, index, value.valueOf());
+};
+const setDateMillisecond = ({ values }, index, value) => {
+  values[index] = BigInt(value);
+};
+const setFixedSizeBinary = ({ stride, values }, index, value) => {
+  values.set(value.subarray(0, stride), stride * index);
+};
+const setBinary = ({ values, valueOffsets }, index, value) => setVariableWidthBytes(values, valueOffsets, index, value);
+const setUtf8 = ({ values, valueOffsets }, index, value) => setVariableWidthBytes(values, valueOffsets, index, encodeUtf8(value));
+const setDate = (data, index, value) => {
+  data.type.unit === DateUnit.DAY ? setDateDay(data, index, value) : setDateMillisecond(data, index, value);
+};
+const setTimestampSecond = ({ values }, index, value) => {
+  values[index] = BigInt(value / 1e3);
+};
+const setTimestampMillisecond = ({ values }, index, value) => {
+  values[index] = BigInt(value);
+};
+const setTimestampMicrosecond = ({ values }, index, value) => {
+  values[index] = BigInt(value * 1e3);
+};
+const setTimestampNanosecond = ({ values }, index, value) => {
+  values[index] = BigInt(value * 1e6);
+};
+const setTimestamp = (data, index, value) => {
+  switch (data.type.unit) {
+    case TimeUnit.SECOND:
+      return setTimestampSecond(data, index, value);
+    case TimeUnit.MILLISECOND:
+      return setTimestampMillisecond(data, index, value);
+    case TimeUnit.MICROSECOND:
+      return setTimestampMicrosecond(data, index, value);
+    case TimeUnit.NANOSECOND:
+      return setTimestampNanosecond(data, index, value);
+  }
+};
+const setTimeSecond = ({ values }, index, value) => {
+  values[index] = value;
+};
+const setTimeMillisecond = ({ values }, index, value) => {
+  values[index] = value;
+};
+const setTimeMicrosecond = ({ values }, index, value) => {
+  values[index] = value;
+};
+const setTimeNanosecond = ({ values }, index, value) => {
+  values[index] = value;
+};
+const setTime = (data, index, value) => {
+  switch (data.type.unit) {
+    case TimeUnit.SECOND:
+      return setTimeSecond(data, index, value);
+    case TimeUnit.MILLISECOND:
+      return setTimeMillisecond(data, index, value);
+    case TimeUnit.MICROSECOND:
+      return setTimeMicrosecond(data, index, value);
+    case TimeUnit.NANOSECOND:
+      return setTimeNanosecond(data, index, value);
+  }
+};
+const setDecimal = ({ values, stride }, index, value) => {
+  values.set(value.subarray(0, stride), stride * index);
+};
+const setList = (data, index, value) => {
+  const values = data.children[0];
+  const valueOffsets = data.valueOffsets;
+  const set = instance$5.getVisitFn(values);
+  if (Array.isArray(value)) {
+    for (let idx = -1, itr = valueOffsets[index], end = valueOffsets[index + 1]; itr < end; ) {
+      set(values, itr++, value[++idx]);
+    }
+  } else {
+    for (let idx = -1, itr = valueOffsets[index], end = valueOffsets[index + 1]; itr < end; ) {
+      set(values, itr++, value.get(++idx));
+    }
+  }
+};
+const setMap = (data, index, value) => {
+  const values = data.children[0];
+  const { valueOffsets } = data;
+  const set = instance$5.getVisitFn(values);
+  let { [index]: idx, [index + 1]: end } = valueOffsets;
+  const entries = value instanceof Map ? value.entries() : Object.entries(value);
+  for (const val of entries) {
+    set(values, idx, val);
+    if (++idx >= end)
+      break;
+  }
+};
+const _setStructArrayValue = (o2, v2) => (set, c2, _2, i2) => c2 && set(c2, o2, v2[i2]);
+const _setStructVectorValue = (o2, v2) => (set, c2, _2, i2) => c2 && set(c2, o2, v2.get(i2));
+const _setStructMapValue = (o2, v2) => (set, c2, f2, _2) => c2 && set(c2, o2, v2.get(f2.name));
+const _setStructObjectValue = (o2, v2) => (set, c2, f2, _2) => c2 && set(c2, o2, v2[f2.name]);
+const setStruct = (data, index, value) => {
+  const childSetters = data.type.children.map((f2) => instance$5.getVisitFn(f2.type));
+  const set = value instanceof Map ? _setStructMapValue(index, value) : value instanceof Vector$1 ? _setStructVectorValue(index, value) : Array.isArray(value) ? _setStructArrayValue(index, value) : _setStructObjectValue(index, value);
+  data.type.children.forEach((f2, i2) => set(childSetters[i2], data.children[i2], f2, i2));
+};
+const setUnion = (data, index, value) => {
+  data.type.mode === UnionMode.Dense ? setDenseUnion(data, index, value) : setSparseUnion(data, index, value);
+};
+const setDenseUnion = (data, index, value) => {
+  const childIndex = data.type.typeIdToChildIndex[data.typeIds[index]];
+  const child = data.children[childIndex];
+  instance$5.visit(child, data.valueOffsets[index], value);
+};
+const setSparseUnion = (data, index, value) => {
+  const childIndex = data.type.typeIdToChildIndex[data.typeIds[index]];
+  const child = data.children[childIndex];
+  instance$5.visit(child, index, value);
+};
+const setDictionary = (data, index, value) => {
+  var _a3;
+  (_a3 = data.dictionary) === null || _a3 === void 0 ? void 0 : _a3.set(data.values[index], value);
+};
+const setIntervalValue = (data, index, value) => {
+  switch (data.type.unit) {
+    case IntervalUnit.YEAR_MONTH:
+      return setIntervalYearMonth(data, index, value);
+    case IntervalUnit.DAY_TIME:
+      return setIntervalDayTime(data, index, value);
+    case IntervalUnit.MONTH_DAY_NANO:
+      return setIntervalMonthDayNano(data, index, value);
+  }
+};
+const setIntervalDayTime = ({ values }, index, value) => {
+  values.set(value.subarray(0, 2), 2 * index);
+};
+const setIntervalYearMonth = ({ values }, index, value) => {
+  values[index] = value[0] * 12 + value[1] % 12;
+};
+const setIntervalMonthDayNano = ({ values, stride }, index, value) => {
+  values.set(value.subarray(0, stride), stride * index);
+};
+const setDurationSecond = ({ values }, index, value) => {
+  values[index] = value;
+};
+const setDurationMillisecond = ({ values }, index, value) => {
+  values[index] = value;
+};
+const setDurationMicrosecond = ({ values }, index, value) => {
+  values[index] = value;
+};
+const setDurationNanosecond = ({ values }, index, value) => {
+  values[index] = value;
+};
+const setDuration = (data, index, value) => {
+  switch (data.type.unit) {
+    case TimeUnit.SECOND:
+      return setDurationSecond(data, index, value);
+    case TimeUnit.MILLISECOND:
+      return setDurationMillisecond(data, index, value);
+    case TimeUnit.MICROSECOND:
+      return setDurationMicrosecond(data, index, value);
+    case TimeUnit.NANOSECOND:
+      return setDurationNanosecond(data, index, value);
+  }
+};
+const setFixedSizeList = (data, index, value) => {
+  const { stride } = data;
+  const child = data.children[0];
+  const set = instance$5.getVisitFn(child);
+  if (Array.isArray(value)) {
+    for (let idx = -1, offset = index * stride; ++idx < stride; ) {
+      set(child, offset + idx, value[idx]);
+    }
+  } else {
+    for (let idx = -1, offset = index * stride; ++idx < stride; ) {
+      set(child, offset + idx, value.get(idx));
+    }
+  }
+};
+SetVisitor.prototype.visitBool = wrapSet(setBool);
+SetVisitor.prototype.visitInt = wrapSet(setInt);
+SetVisitor.prototype.visitInt8 = wrapSet(setInt);
+SetVisitor.prototype.visitInt16 = wrapSet(setInt);
+SetVisitor.prototype.visitInt32 = wrapSet(setInt);
+SetVisitor.prototype.visitInt64 = wrapSet(setInt);
+SetVisitor.prototype.visitUint8 = wrapSet(setInt);
+SetVisitor.prototype.visitUint16 = wrapSet(setInt);
+SetVisitor.prototype.visitUint32 = wrapSet(setInt);
+SetVisitor.prototype.visitUint64 = wrapSet(setInt);
+SetVisitor.prototype.visitFloat = wrapSet(setAnyFloat);
+SetVisitor.prototype.visitFloat16 = wrapSet(setFloat16);
+SetVisitor.prototype.visitFloat32 = wrapSet(setFloat);
+SetVisitor.prototype.visitFloat64 = wrapSet(setFloat);
+SetVisitor.prototype.visitUtf8 = wrapSet(setUtf8);
+SetVisitor.prototype.visitLargeUtf8 = wrapSet(setUtf8);
+SetVisitor.prototype.visitBinary = wrapSet(setBinary);
+SetVisitor.prototype.visitLargeBinary = wrapSet(setBinary);
+SetVisitor.prototype.visitFixedSizeBinary = wrapSet(setFixedSizeBinary);
+SetVisitor.prototype.visitDate = wrapSet(setDate);
+SetVisitor.prototype.visitDateDay = wrapSet(setDateDay);
+SetVisitor.prototype.visitDateMillisecond = wrapSet(setDateMillisecond);
+SetVisitor.prototype.visitTimestamp = wrapSet(setTimestamp);
+SetVisitor.prototype.visitTimestampSecond = wrapSet(setTimestampSecond);
+SetVisitor.prototype.visitTimestampMillisecond = wrapSet(setTimestampMillisecond);
+SetVisitor.prototype.visitTimestampMicrosecond = wrapSet(setTimestampMicrosecond);
+SetVisitor.prototype.visitTimestampNanosecond = wrapSet(setTimestampNanosecond);
+SetVisitor.prototype.visitTime = wrapSet(setTime);
+SetVisitor.prototype.visitTimeSecond = wrapSet(setTimeSecond);
+SetVisitor.prototype.visitTimeMillisecond = wrapSet(setTimeMillisecond);
+SetVisitor.prototype.visitTimeMicrosecond = wrapSet(setTimeMicrosecond);
+SetVisitor.prototype.visitTimeNanosecond = wrapSet(setTimeNanosecond);
+SetVisitor.prototype.visitDecimal = wrapSet(setDecimal);
+SetVisitor.prototype.visitList = wrapSet(setList);
+SetVisitor.prototype.visitStruct = wrapSet(setStruct);
+SetVisitor.prototype.visitUnion = wrapSet(setUnion);
+SetVisitor.prototype.visitDenseUnion = wrapSet(setDenseUnion);
+SetVisitor.prototype.visitSparseUnion = wrapSet(setSparseUnion);
+SetVisitor.prototype.visitDictionary = wrapSet(setDictionary);
+SetVisitor.prototype.visitInterval = wrapSet(setIntervalValue);
+SetVisitor.prototype.visitIntervalDayTime = wrapSet(setIntervalDayTime);
+SetVisitor.prototype.visitIntervalYearMonth = wrapSet(setIntervalYearMonth);
+SetVisitor.prototype.visitIntervalMonthDayNano = wrapSet(setIntervalMonthDayNano);
+SetVisitor.prototype.visitDuration = wrapSet(setDuration);
+SetVisitor.prototype.visitDurationSecond = wrapSet(setDurationSecond);
+SetVisitor.prototype.visitDurationMillisecond = wrapSet(setDurationMillisecond);
+SetVisitor.prototype.visitDurationMicrosecond = wrapSet(setDurationMicrosecond);
+SetVisitor.prototype.visitDurationNanosecond = wrapSet(setDurationNanosecond);
+SetVisitor.prototype.visitFixedSizeList = wrapSet(setFixedSizeList);
+SetVisitor.prototype.visitMap = wrapSet(setMap);
+const instance$5 = new SetVisitor();
+const kParent = Symbol.for("parent");
+const kRowIndex = Symbol.for("rowIndex");
+class StructRow {
+  constructor(parent, rowIndex) {
+    this[kParent] = parent;
+    this[kRowIndex] = rowIndex;
+    return new Proxy(this, structRowProxyHandler);
+  }
+  toArray() {
+    return Object.values(this.toJSON());
+  }
+  toJSON() {
+    const i2 = this[kRowIndex];
+    const parent = this[kParent];
+    const keys = parent.type.children;
+    const json = {};
+    for (let j2 = -1, n2 = keys.length; ++j2 < n2; ) {
+      json[keys[j2].name] = instance$4.visit(parent.children[j2], i2);
+    }
+    return json;
+  }
+  toString() {
+    return `{${[...this].map(([key, val]) => `${valueToString(key)}: ${valueToString(val)}`).join(", ")}}`;
+  }
+  [Symbol.for("nodejs.util.inspect.custom")]() {
+    return this.toString();
+  }
+  [Symbol.iterator]() {
+    return new StructRowIterator(this[kParent], this[kRowIndex]);
+  }
+}
+class StructRowIterator {
+  constructor(data, rowIndex) {
+    this.childIndex = 0;
+    this.children = data.children;
+    this.rowIndex = rowIndex;
+    this.childFields = data.type.children;
+    this.numChildren = this.childFields.length;
+  }
+  [Symbol.iterator]() {
+    return this;
+  }
+  next() {
+    const i2 = this.childIndex;
+    if (i2 < this.numChildren) {
+      this.childIndex = i2 + 1;
+      return {
+        done: false,
+        value: [
+          this.childFields[i2].name,
+          instance$4.visit(this.children[i2], this.rowIndex)
+        ]
+      };
+    }
+    return { done: true, value: null };
+  }
+}
+Object.defineProperties(StructRow.prototype, {
+  [Symbol.toStringTag]: { enumerable: false, configurable: false, value: "Row" },
+  [kParent]: { writable: true, enumerable: false, configurable: false, value: null },
+  [kRowIndex]: { writable: true, enumerable: false, configurable: false, value: -1 }
+});
+class StructRowProxyHandler {
+  isExtensible() {
+    return false;
+  }
+  deleteProperty() {
+    return false;
+  }
+  preventExtensions() {
+    return true;
+  }
+  ownKeys(row) {
+    return row[kParent].type.children.map((f2) => f2.name);
+  }
+  has(row, key) {
+    return row[kParent].type.children.some((f2) => f2.name === key);
+  }
+  getOwnPropertyDescriptor(row, key) {
+    if (row[kParent].type.children.some((f2) => f2.name === key)) {
+      return { writable: true, enumerable: true, configurable: true };
+    }
+    return;
+  }
+  get(row, key) {
+    if (Reflect.has(row, key)) {
+      return row[key];
+    }
+    const idx = row[kParent].type.children.findIndex((f2) => f2.name === key);
+    if (idx !== -1) {
+      const val = instance$4.visit(row[kParent].children[idx], row[kRowIndex]);
+      Reflect.set(row, key, val);
+      return val;
+    }
+  }
+  set(row, key, val) {
+    const idx = row[kParent].type.children.findIndex((f2) => f2.name === key);
+    if (idx !== -1) {
+      instance$5.visit(row[kParent].children[idx], row[kRowIndex], val);
+      return Reflect.set(row, key, val);
+    } else if (Reflect.has(row, key) || typeof key === "symbol") {
+      return Reflect.set(row, key, val);
+    }
+    return false;
+  }
+}
+const structRowProxyHandler = new StructRowProxyHandler();
+class GetVisitor extends Visitor {
+}
+function wrapGet(fn) {
+  return (data, _1) => data.getValid(_1) ? fn(data, _1) : null;
+}
+const epochDaysToMs = (data, index) => 864e5 * data[index];
+const getNull = (_data, _index) => null;
+const getVariableWidthBytes = (values, valueOffsets, index) => {
+  if (index + 1 >= valueOffsets.length) {
+    return null;
+  }
+  const x2 = bigIntToNumber(valueOffsets[index]);
+  const y2 = bigIntToNumber(valueOffsets[index + 1]);
+  return values.subarray(x2, y2);
+};
+const getBool$1 = ({ offset, values }, index) => {
+  const idx = offset + index;
+  const byte = values[idx >> 3];
+  return (byte & 1 << idx % 8) !== 0;
+};
+const getDateDay = ({ values }, index) => epochDaysToMs(values, index);
+const getDateMillisecond = ({ values }, index) => bigIntToNumber(values[index]);
+const getNumeric = ({ stride, values }, index) => values[stride * index];
+const getFloat16 = ({ stride, values }, index) => uint16ToFloat64(values[stride * index]);
+const getBigInts = ({ values }, index) => values[index];
+const getFixedSizeBinary = ({ stride, values }, index) => values.subarray(stride * index, stride * (index + 1));
+const getBinary = ({ values, valueOffsets }, index) => getVariableWidthBytes(values, valueOffsets, index);
+const getUtf8 = ({ values, valueOffsets }, index) => {
+  const bytes = getVariableWidthBytes(values, valueOffsets, index);
+  return bytes !== null ? decodeUtf8(bytes) : null;
+};
+const getInt = ({ values }, index) => values[index];
+const getFloat = ({ type, values }, index) => type.precision !== Precision.HALF ? values[index] : uint16ToFloat64(values[index]);
+const getDate = (data, index) => data.type.unit === DateUnit.DAY ? getDateDay(data, index) : getDateMillisecond(data, index);
+const getTimestampSecond = ({ values }, index) => 1e3 * bigIntToNumber(values[index]);
+const getTimestampMillisecond = ({ values }, index) => bigIntToNumber(values[index]);
+const getTimestampMicrosecond = ({ values }, index) => divideBigInts(values[index], BigInt(1e3));
+const getTimestampNanosecond = ({ values }, index) => divideBigInts(values[index], BigInt(1e6));
+const getTimestamp = (data, index) => {
+  switch (data.type.unit) {
+    case TimeUnit.SECOND:
+      return getTimestampSecond(data, index);
+    case TimeUnit.MILLISECOND:
+      return getTimestampMillisecond(data, index);
+    case TimeUnit.MICROSECOND:
+      return getTimestampMicrosecond(data, index);
+    case TimeUnit.NANOSECOND:
+      return getTimestampNanosecond(data, index);
+  }
+};
+const getTimeSecond = ({ values }, index) => values[index];
+const getTimeMillisecond = ({ values }, index) => values[index];
+const getTimeMicrosecond = ({ values }, index) => values[index];
+const getTimeNanosecond = ({ values }, index) => values[index];
+const getTime = (data, index) => {
+  switch (data.type.unit) {
+    case TimeUnit.SECOND:
+      return getTimeSecond(data, index);
+    case TimeUnit.MILLISECOND:
+      return getTimeMillisecond(data, index);
+    case TimeUnit.MICROSECOND:
+      return getTimeMicrosecond(data, index);
+    case TimeUnit.NANOSECOND:
+      return getTimeNanosecond(data, index);
+  }
+};
+const getDecimal = ({ values, stride }, index) => BN.decimal(values.subarray(stride * index, stride * (index + 1)));
+const getList = (data, index) => {
+  const { valueOffsets, stride, children } = data;
+  const { [index * stride]: begin, [index * stride + 1]: end } = valueOffsets;
+  const child = children[0];
+  const slice = child.slice(begin, end - begin);
+  return new Vector$1([slice]);
+};
+const getMap = (data, index) => {
+  const { valueOffsets, children } = data;
+  const { [index]: begin, [index + 1]: end } = valueOffsets;
+  const child = children[0];
+  return new MapRow(child.slice(begin, end - begin));
+};
+const getStruct = (data, index) => {
+  return new StructRow(data, index);
+};
+const getUnion = (data, index) => {
+  return data.type.mode === UnionMode.Dense ? getDenseUnion(data, index) : getSparseUnion(data, index);
+};
+const getDenseUnion = (data, index) => {
+  const childIndex = data.type.typeIdToChildIndex[data.typeIds[index]];
+  const child = data.children[childIndex];
+  return instance$4.visit(child, data.valueOffsets[index]);
+};
+const getSparseUnion = (data, index) => {
+  const childIndex = data.type.typeIdToChildIndex[data.typeIds[index]];
+  const child = data.children[childIndex];
+  return instance$4.visit(child, index);
+};
+const getDictionary = (data, index) => {
+  var _a3;
+  return (_a3 = data.dictionary) === null || _a3 === void 0 ? void 0 : _a3.get(data.values[index]);
+};
+const getInterval = (data, index) => data.type.unit === IntervalUnit.MONTH_DAY_NANO ? getIntervalMonthDayNano(data, index) : data.type.unit === IntervalUnit.DAY_TIME ? getIntervalDayTime(data, index) : getIntervalYearMonth(data, index);
+const getIntervalDayTime = ({ values }, index) => values.subarray(2 * index, 2 * (index + 1));
+const getIntervalYearMonth = ({ values }, index) => {
+  const interval = values[index];
+  const int32s = new Int32Array(2);
+  int32s[0] = Math.trunc(interval / 12);
+  int32s[1] = Math.trunc(interval % 12);
+  return int32s;
+};
+const getIntervalMonthDayNano = ({ values }, index) => values.subarray(4 * index, 4 * (index + 1));
+const getDurationSecond = ({ values }, index) => values[index];
+const getDurationMillisecond = ({ values }, index) => values[index];
+const getDurationMicrosecond = ({ values }, index) => values[index];
+const getDurationNanosecond = ({ values }, index) => values[index];
+const getDuration = (data, index) => {
+  switch (data.type.unit) {
+    case TimeUnit.SECOND:
+      return getDurationSecond(data, index);
+    case TimeUnit.MILLISECOND:
+      return getDurationMillisecond(data, index);
+    case TimeUnit.MICROSECOND:
+      return getDurationMicrosecond(data, index);
+    case TimeUnit.NANOSECOND:
+      return getDurationNanosecond(data, index);
+  }
+};
+const getFixedSizeList = (data, index) => {
+  const { stride, children } = data;
+  const child = children[0];
+  const slice = child.slice(index * stride, stride);
+  return new Vector$1([slice]);
+};
+GetVisitor.prototype.visitNull = wrapGet(getNull);
+GetVisitor.prototype.visitBool = wrapGet(getBool$1);
+GetVisitor.prototype.visitInt = wrapGet(getInt);
+GetVisitor.prototype.visitInt8 = wrapGet(getNumeric);
+GetVisitor.prototype.visitInt16 = wrapGet(getNumeric);
+GetVisitor.prototype.visitInt32 = wrapGet(getNumeric);
+GetVisitor.prototype.visitInt64 = wrapGet(getBigInts);
+GetVisitor.prototype.visitUint8 = wrapGet(getNumeric);
+GetVisitor.prototype.visitUint16 = wrapGet(getNumeric);
+GetVisitor.prototype.visitUint32 = wrapGet(getNumeric);
+GetVisitor.prototype.visitUint64 = wrapGet(getBigInts);
+GetVisitor.prototype.visitFloat = wrapGet(getFloat);
+GetVisitor.prototype.visitFloat16 = wrapGet(getFloat16);
+GetVisitor.prototype.visitFloat32 = wrapGet(getNumeric);
+GetVisitor.prototype.visitFloat64 = wrapGet(getNumeric);
+GetVisitor.prototype.visitUtf8 = wrapGet(getUtf8);
+GetVisitor.prototype.visitLargeUtf8 = wrapGet(getUtf8);
+GetVisitor.prototype.visitBinary = wrapGet(getBinary);
+GetVisitor.prototype.visitLargeBinary = wrapGet(getBinary);
+GetVisitor.prototype.visitFixedSizeBinary = wrapGet(getFixedSizeBinary);
+GetVisitor.prototype.visitDate = wrapGet(getDate);
+GetVisitor.prototype.visitDateDay = wrapGet(getDateDay);
+GetVisitor.prototype.visitDateMillisecond = wrapGet(getDateMillisecond);
+GetVisitor.prototype.visitTimestamp = wrapGet(getTimestamp);
+GetVisitor.prototype.visitTimestampSecond = wrapGet(getTimestampSecond);
+GetVisitor.prototype.visitTimestampMillisecond = wrapGet(getTimestampMillisecond);
+GetVisitor.prototype.visitTimestampMicrosecond = wrapGet(getTimestampMicrosecond);
+GetVisitor.prototype.visitTimestampNanosecond = wrapGet(getTimestampNanosecond);
+GetVisitor.prototype.visitTime = wrapGet(getTime);
+GetVisitor.prototype.visitTimeSecond = wrapGet(getTimeSecond);
+GetVisitor.prototype.visitTimeMillisecond = wrapGet(getTimeMillisecond);
+GetVisitor.prototype.visitTimeMicrosecond = wrapGet(getTimeMicrosecond);
+GetVisitor.prototype.visitTimeNanosecond = wrapGet(getTimeNanosecond);
+GetVisitor.prototype.visitDecimal = wrapGet(getDecimal);
+GetVisitor.prototype.visitList = wrapGet(getList);
+GetVisitor.prototype.visitStruct = wrapGet(getStruct);
+GetVisitor.prototype.visitUnion = wrapGet(getUnion);
+GetVisitor.prototype.visitDenseUnion = wrapGet(getDenseUnion);
+GetVisitor.prototype.visitSparseUnion = wrapGet(getSparseUnion);
+GetVisitor.prototype.visitDictionary = wrapGet(getDictionary);
+GetVisitor.prototype.visitInterval = wrapGet(getInterval);
+GetVisitor.prototype.visitIntervalDayTime = wrapGet(getIntervalDayTime);
+GetVisitor.prototype.visitIntervalYearMonth = wrapGet(getIntervalYearMonth);
+GetVisitor.prototype.visitIntervalMonthDayNano = wrapGet(getIntervalMonthDayNano);
+GetVisitor.prototype.visitDuration = wrapGet(getDuration);
+GetVisitor.prototype.visitDurationSecond = wrapGet(getDurationSecond);
+GetVisitor.prototype.visitDurationMillisecond = wrapGet(getDurationMillisecond);
+GetVisitor.prototype.visitDurationMicrosecond = wrapGet(getDurationMicrosecond);
+GetVisitor.prototype.visitDurationNanosecond = wrapGet(getDurationNanosecond);
+GetVisitor.prototype.visitFixedSizeList = wrapGet(getFixedSizeList);
+GetVisitor.prototype.visitMap = wrapGet(getMap);
+const instance$4 = new GetVisitor();
+const kKeys = Symbol.for("keys");
+const kVals = Symbol.for("vals");
+const kKeysAsStrings = Symbol.for("kKeysAsStrings");
+const _kKeysAsStrings = Symbol.for("_kKeysAsStrings");
+class MapRow {
+  constructor(slice) {
+    this[kKeys] = new Vector$1([slice.children[0]]).memoize();
+    this[kVals] = slice.children[1];
+    return new Proxy(this, new MapRowProxyHandler());
+  }
+  /** @ignore */
+  get [kKeysAsStrings]() {
+    return this[_kKeysAsStrings] || (this[_kKeysAsStrings] = Array.from(this[kKeys].toArray(), String));
+  }
+  [Symbol.iterator]() {
+    return new MapRowIterator(this[kKeys], this[kVals]);
+  }
+  get size() {
+    return this[kKeys].length;
+  }
+  toArray() {
+    return Object.values(this.toJSON());
+  }
+  toJSON() {
+    const keys = this[kKeys];
+    const vals = this[kVals];
+    const json = {};
+    for (let i2 = -1, n2 = keys.length; ++i2 < n2; ) {
+      json[keys.get(i2)] = instance$4.visit(vals, i2);
+    }
+    return json;
+  }
+  toString() {
+    return `{${[...this].map(([key, val]) => `${valueToString(key)}: ${valueToString(val)}`).join(", ")}}`;
+  }
+  [Symbol.for("nodejs.util.inspect.custom")]() {
+    return this.toString();
+  }
+}
+class MapRowIterator {
+  constructor(keys, vals) {
+    this.keys = keys;
+    this.vals = vals;
+    this.keyIndex = 0;
+    this.numKeys = keys.length;
+  }
+  [Symbol.iterator]() {
+    return this;
+  }
+  next() {
+    const i2 = this.keyIndex;
+    if (i2 === this.numKeys) {
+      return { done: true, value: null };
+    }
+    this.keyIndex++;
+    return {
+      done: false,
+      value: [
+        this.keys.get(i2),
+        instance$4.visit(this.vals, i2)
+      ]
+    };
+  }
+}
+class MapRowProxyHandler {
+  isExtensible() {
+    return false;
+  }
+  deleteProperty() {
+    return false;
+  }
+  preventExtensions() {
+    return true;
+  }
+  ownKeys(row) {
+    return row[kKeysAsStrings];
+  }
+  has(row, key) {
+    return row[kKeysAsStrings].includes(key);
+  }
+  getOwnPropertyDescriptor(row, key) {
+    const idx = row[kKeysAsStrings].indexOf(key);
+    if (idx !== -1) {
+      return { writable: true, enumerable: true, configurable: true };
+    }
+    return;
+  }
+  get(row, key) {
+    if (Reflect.has(row, key)) {
+      return row[key];
+    }
+    const idx = row[kKeysAsStrings].indexOf(key);
+    if (idx !== -1) {
+      const val = instance$4.visit(Reflect.get(row, kVals), idx);
+      Reflect.set(row, key, val);
+      return val;
+    }
+  }
+  set(row, key, val) {
+    const idx = row[kKeysAsStrings].indexOf(key);
+    if (idx !== -1) {
+      instance$5.visit(Reflect.get(row, kVals), idx, val);
+      return Reflect.set(row, key, val);
+    } else if (Reflect.has(row, key)) {
+      return Reflect.set(row, key, val);
+    }
+    return false;
+  }
+}
+Object.defineProperties(MapRow.prototype, {
+  [Symbol.toStringTag]: { enumerable: false, configurable: false, value: "Row" },
+  [kKeys]: { writable: true, enumerable: false, configurable: false, value: null },
+  [kVals]: { writable: true, enumerable: false, configurable: false, value: null },
+  [_kKeysAsStrings]: { writable: true, enumerable: false, configurable: false, value: null }
+});
+let tmp;
+function clampRange(source2, begin, end, then) {
+  const { length: len2 = 0 } = source2;
+  let lhs = typeof begin !== "number" ? 0 : begin;
+  let rhs = typeof end !== "number" ? len2 : end;
+  lhs < 0 && (lhs = (lhs % len2 + len2) % len2);
+  rhs < 0 && (rhs = (rhs % len2 + len2) % len2);
+  rhs < lhs && (tmp = lhs, lhs = rhs, rhs = tmp);
+  rhs > len2 && (rhs = len2);
+  return then ? then(source2, lhs, rhs) : [lhs, rhs];
+}
+const wrapIndex = (index, len2) => index < 0 ? len2 + index : index;
+const isNaNFast = (value) => value !== value;
+function createElementComparator(search) {
+  const typeofSearch = typeof search;
+  if (typeofSearch !== "object" || search === null) {
+    if (isNaNFast(search)) {
+      return isNaNFast;
+    }
+    return (value) => value === search;
+  }
+  if (search instanceof Date) {
+    const valueOfSearch = search.valueOf();
+    return (value) => value instanceof Date ? value.valueOf() === valueOfSearch : false;
+  }
+  if (ArrayBuffer.isView(search)) {
+    return (value) => value ? compareArrayLike(search, value) : false;
+  }
+  if (search instanceof Map) {
+    return createMapComparator(search);
+  }
+  if (Array.isArray(search)) {
+    return createArrayLikeComparator(search);
+  }
+  if (search instanceof Vector$1) {
+    return createVectorComparator(search);
+  }
+  return createObjectComparator(search, true);
+}
+function createArrayLikeComparator(lhs) {
+  const comparators = [];
+  for (let i2 = -1, n2 = lhs.length; ++i2 < n2; ) {
+    comparators[i2] = createElementComparator(lhs[i2]);
+  }
+  return createSubElementsComparator(comparators);
+}
+function createMapComparator(lhs) {
+  let i2 = -1;
+  const comparators = [];
+  for (const v2 of lhs.values())
+    comparators[++i2] = createElementComparator(v2);
+  return createSubElementsComparator(comparators);
+}
+function createVectorComparator(lhs) {
+  const comparators = [];
+  for (let i2 = -1, n2 = lhs.length; ++i2 < n2; ) {
+    comparators[i2] = createElementComparator(lhs.get(i2));
+  }
+  return createSubElementsComparator(comparators);
+}
+function createObjectComparator(lhs, allowEmpty = false) {
+  const keys = Object.keys(lhs);
+  if (!allowEmpty && keys.length === 0) {
+    return () => false;
+  }
+  const comparators = [];
+  for (let i2 = -1, n2 = keys.length; ++i2 < n2; ) {
+    comparators[i2] = createElementComparator(lhs[keys[i2]]);
+  }
+  return createSubElementsComparator(comparators, keys);
+}
+function createSubElementsComparator(comparators, keys) {
+  return (rhs) => {
+    if (!rhs || typeof rhs !== "object") {
+      return false;
+    }
+    switch (rhs.constructor) {
+      case Array:
+        return compareArray(comparators, rhs);
+      case Map:
+        return compareObject(comparators, rhs, rhs.keys());
+      case MapRow:
+      case StructRow:
+      case Object:
+      case void 0:
+        return compareObject(comparators, rhs, keys || Object.keys(rhs));
+    }
+    return rhs instanceof Vector$1 ? compareVector(comparators, rhs) : false;
+  };
+}
+function compareArray(comparators, arr) {
+  const n2 = comparators.length;
+  if (arr.length !== n2) {
+    return false;
+  }
+  for (let i2 = -1; ++i2 < n2; ) {
+    if (!comparators[i2](arr[i2])) {
+      return false;
+    }
+  }
+  return true;
+}
+function compareVector(comparators, vec) {
+  const n2 = comparators.length;
+  if (vec.length !== n2) {
+    return false;
+  }
+  for (let i2 = -1; ++i2 < n2; ) {
+    if (!comparators[i2](vec.get(i2))) {
+      return false;
+    }
+  }
+  return true;
+}
+function compareObject(comparators, obj, keys) {
+  const lKeyItr = keys[Symbol.iterator]();
+  const rKeyItr = obj instanceof Map ? obj.keys() : Object.keys(obj)[Symbol.iterator]();
+  const rValItr = obj instanceof Map ? obj.values() : Object.values(obj)[Symbol.iterator]();
+  let i2 = 0;
+  const n2 = comparators.length;
+  let rVal = rValItr.next();
+  let lKey = lKeyItr.next();
+  let rKey = rKeyItr.next();
+  for (; i2 < n2 && !lKey.done && !rKey.done && !rVal.done; ++i2, lKey = lKeyItr.next(), rKey = rKeyItr.next(), rVal = rValItr.next()) {
+    if (lKey.value !== rKey.value || !comparators[i2](rVal.value)) {
+      break;
+    }
+  }
+  if (i2 === n2 && lKey.done && rKey.done && rVal.done) {
+    return true;
+  }
+  lKeyItr.return && lKeyItr.return();
+  rKeyItr.return && rKeyItr.return();
+  rValItr.return && rValItr.return();
+  return false;
+}
+function getBool(_data, _index, byte, bit) {
+  return (byte & 1 << bit) !== 0;
+}
+function getBit(_data, _index, byte, bit) {
+  return (byte & 1 << bit) >> bit;
+}
+function truncateBitmap(offset, length2, bitmap) {
+  const alignedSize = bitmap.byteLength + 7 & -8;
+  if (offset > 0 || bitmap.byteLength < alignedSize) {
+    const bytes = new Uint8Array(alignedSize);
+    bytes.set(offset % 8 === 0 ? bitmap.subarray(offset >> 3) : (
+      // Otherwise iterate each bit from the offset and return a new one
+      packBools(new BitIterator(bitmap, offset, length2, null, getBool)).subarray(0, alignedSize)
+    ));
+    return bytes;
+  }
+  return bitmap;
+}
+function packBools(values) {
+  const xs = [];
+  let i2 = 0, bit = 0, byte = 0;
+  for (const value of values) {
+    value && (byte |= 1 << bit);
+    if (++bit === 8) {
+      xs[i2++] = byte;
+      byte = bit = 0;
+    }
+  }
+  if (i2 === 0 || bit > 0) {
+    xs[i2++] = byte;
+  }
+  const b2 = new Uint8Array(xs.length + 7 & -8);
+  b2.set(xs);
+  return b2;
+}
+class BitIterator {
+  constructor(bytes, begin, length2, context, get) {
+    this.bytes = bytes;
+    this.length = length2;
+    this.context = context;
+    this.get = get;
+    this.bit = begin % 8;
+    this.byteIndex = begin >> 3;
+    this.byte = bytes[this.byteIndex++];
+    this.index = 0;
+  }
+  next() {
+    if (this.index < this.length) {
+      if (this.bit === 8) {
+        this.bit = 0;
+        this.byte = this.bytes[this.byteIndex++];
+      }
+      return {
+        value: this.get(this.context, this.index++, this.byte, this.bit++)
+      };
+    }
+    return { done: true, value: null };
+  }
+  [Symbol.iterator]() {
+    return this;
+  }
+}
+function popcnt_bit_range(data, lhs, rhs) {
+  if (rhs - lhs <= 0) {
+    return 0;
+  }
+  if (rhs - lhs < 8) {
+    let sum = 0;
+    for (const bit of new BitIterator(data, lhs, rhs - lhs, data, getBit)) {
+      sum += bit;
+    }
+    return sum;
+  }
+  const rhsInside = rhs >> 3 << 3;
+  const lhsInside = lhs + (lhs % 8 === 0 ? 0 : 8 - lhs % 8);
+  return (
+    // Get the popcnt of bits between the left hand side, and the next highest multiple of 8
+    popcnt_bit_range(data, lhs, lhsInside) + // Get the popcnt of bits between the right hand side, and the next lowest multiple of 8
+    popcnt_bit_range(data, rhsInside, rhs) + // Get the popcnt of all bits between the left and right hand sides' multiples of 8
+    popcnt_array(data, lhsInside >> 3, rhsInside - lhsInside >> 3)
+  );
+}
+function popcnt_array(arr, byteOffset, byteLength) {
+  let cnt = 0, pos = Math.trunc(byteOffset);
+  const view = new DataView(arr.buffer, arr.byteOffset, arr.byteLength);
+  const len2 = byteLength === void 0 ? arr.byteLength : pos + byteLength;
+  while (len2 - pos >= 4) {
+    cnt += popcnt_uint32(view.getUint32(pos));
+    pos += 4;
+  }
+  while (len2 - pos >= 2) {
+    cnt += popcnt_uint32(view.getUint16(pos));
+    pos += 2;
+  }
+  while (len2 - pos >= 1) {
+    cnt += popcnt_uint32(view.getUint8(pos));
+    pos += 1;
+  }
+  return cnt;
+}
+function popcnt_uint32(uint32) {
+  let i2 = Math.trunc(uint32);
+  i2 = i2 - (i2 >>> 1 & 1431655765);
+  i2 = (i2 & 858993459) + (i2 >>> 2 & 858993459);
+  return (i2 + (i2 >>> 4) & 252645135) * 16843009 >>> 24;
+}
+const kUnknownNullCount = -1;
+class Data {
+  get typeId() {
+    return this.type.typeId;
+  }
+  get ArrayType() {
+    return this.type.ArrayType;
+  }
+  get buffers() {
+    return [this.valueOffsets, this.values, this.nullBitmap, this.typeIds];
+  }
+  get nullable() {
+    if (this._nullCount !== 0) {
+      const { type } = this;
+      if (DataType.isSparseUnion(type)) {
+        return this.children.some((child) => child.nullable);
+      } else if (DataType.isDenseUnion(type)) {
+        return this.children.some((child) => child.nullable);
+      }
+      return this.nullBitmap && this.nullBitmap.byteLength > 0;
+    }
+    return true;
+  }
+  get byteLength() {
+    let byteLength = 0;
+    const { valueOffsets, values, nullBitmap, typeIds } = this;
+    valueOffsets && (byteLength += valueOffsets.byteLength);
+    values && (byteLength += values.byteLength);
+    nullBitmap && (byteLength += nullBitmap.byteLength);
+    typeIds && (byteLength += typeIds.byteLength);
+    return this.children.reduce((byteLength2, child) => byteLength2 + child.byteLength, byteLength);
+  }
+  get nullCount() {
+    if (DataType.isUnion(this.type)) {
+      return this.children.reduce((nullCount2, child) => nullCount2 + child.nullCount, 0);
+    }
+    let nullCount = this._nullCount;
+    let nullBitmap;
+    if (nullCount <= kUnknownNullCount && (nullBitmap = this.nullBitmap)) {
+      this._nullCount = nullCount = nullBitmap.length === 0 ? (
+        // no null bitmap, so all values are valid
+        0
+      ) : this.length - popcnt_bit_range(nullBitmap, this.offset, this.offset + this.length);
+    }
+    return nullCount;
+  }
+  constructor(type, offset, length2, nullCount, buffers, children = [], dictionary) {
+    this.type = type;
+    this.children = children;
+    this.dictionary = dictionary;
+    this.offset = Math.floor(Math.max(offset || 0, 0));
+    this.length = Math.floor(Math.max(length2 || 0, 0));
+    this._nullCount = Math.floor(Math.max(nullCount || 0, -1));
+    let buffer;
+    if (buffers instanceof Data) {
+      this.stride = buffers.stride;
+      this.values = buffers.values;
+      this.typeIds = buffers.typeIds;
+      this.nullBitmap = buffers.nullBitmap;
+      this.valueOffsets = buffers.valueOffsets;
+    } else {
+      this.stride = strideForType(type);
+      if (buffers) {
+        (buffer = buffers[0]) && (this.valueOffsets = buffer);
+        (buffer = buffers[1]) && (this.values = buffer);
+        (buffer = buffers[2]) && (this.nullBitmap = buffer);
+        (buffer = buffers[3]) && (this.typeIds = buffer);
+      }
+    }
+  }
+  getValid(index) {
+    const { type } = this;
+    if (DataType.isUnion(type)) {
+      const union = type;
+      const child = this.children[union.typeIdToChildIndex[this.typeIds[index]]];
+      const indexInChild = union.mode === UnionMode.Dense ? this.valueOffsets[index] : index;
+      return child.getValid(indexInChild);
+    }
+    if (this.nullable && this.nullCount > 0) {
+      const pos = this.offset + index;
+      const val = this.nullBitmap[pos >> 3];
+      return (val & 1 << pos % 8) !== 0;
+    }
+    return true;
+  }
+  setValid(index, value) {
+    let prev;
+    const { type } = this;
+    if (DataType.isUnion(type)) {
+      const union = type;
+      const child = this.children[union.typeIdToChildIndex[this.typeIds[index]]];
+      const indexInChild = union.mode === UnionMode.Dense ? this.valueOffsets[index] : index;
+      prev = child.getValid(indexInChild);
+      child.setValid(indexInChild, value);
+    } else {
+      let { nullBitmap } = this;
+      const { offset, length: length2 } = this;
+      const idx = offset + index;
+      const mask = 1 << idx % 8;
+      const byteOffset = idx >> 3;
+      if (!nullBitmap || nullBitmap.byteLength <= byteOffset) {
+        nullBitmap = new Uint8Array((offset + length2 + 63 & -64) >> 3).fill(255);
+        if (this.nullCount > 0) {
+          nullBitmap.set(truncateBitmap(offset, length2, this.nullBitmap), 0);
+          Object.assign(this, { nullBitmap });
+        } else {
+          Object.assign(this, { nullBitmap, _nullCount: 0 });
+        }
+      }
+      const byte = nullBitmap[byteOffset];
+      prev = (byte & mask) !== 0;
+      nullBitmap[byteOffset] = value ? byte | mask : byte & ~mask;
+    }
+    if (prev !== !!value) {
+      this._nullCount = this.nullCount + (value ? -1 : 1);
+    }
+    return value;
+  }
+  clone(type = this.type, offset = this.offset, length2 = this.length, nullCount = this._nullCount, buffers = this, children = this.children) {
+    return new Data(type, offset, length2, nullCount, buffers, children, this.dictionary);
+  }
+  slice(offset, length2) {
+    const { stride, typeId, children } = this;
+    const nullCount = +(this._nullCount === 0) - 1;
+    const childStride = typeId === 16 ? stride : 1;
+    const buffers = this._sliceBuffers(offset, length2, stride, typeId);
+    return this.clone(
+      this.type,
+      this.offset + offset,
+      length2,
+      nullCount,
+      buffers,
+      // Don't slice children if we have value offsets (the variable-width types)
+      children.length === 0 || this.valueOffsets ? children : this._sliceChildren(children, childStride * offset, childStride * length2)
+    );
+  }
+  _changeLengthAndBackfillNullBitmap(newLength) {
+    if (this.typeId === Type.Null) {
+      return this.clone(this.type, 0, newLength, 0);
+    }
+    const { length: length2, nullCount } = this;
+    const bitmap = new Uint8Array((newLength + 63 & -64) >> 3).fill(255, 0, length2 >> 3);
+    bitmap[length2 >> 3] = (1 << length2 - (length2 & -8)) - 1;
+    if (nullCount > 0) {
+      bitmap.set(truncateBitmap(this.offset, length2, this.nullBitmap), 0);
+    }
+    const buffers = this.buffers;
+    buffers[BufferType.VALIDITY] = bitmap;
+    return this.clone(this.type, 0, newLength, nullCount + (newLength - length2), buffers);
+  }
+  _sliceBuffers(offset, length2, stride, typeId) {
+    let arr;
+    const { buffers } = this;
+    (arr = buffers[BufferType.TYPE]) && (buffers[BufferType.TYPE] = arr.subarray(offset, offset + length2));
+    (arr = buffers[BufferType.OFFSET]) && (buffers[BufferType.OFFSET] = arr.subarray(offset, offset + length2 + 1)) || // Otherwise if no offsets, slice the data buffer. Don't slice the data vector for Booleans, since the offset goes by bits not bytes
+    (arr = buffers[BufferType.DATA]) && (buffers[BufferType.DATA] = typeId === 6 ? arr : arr.subarray(stride * offset, stride * (offset + length2)));
+    return buffers;
+  }
+  _sliceChildren(children, offset, length2) {
+    return children.map((child) => child.slice(offset, length2));
+  }
+}
+Data.prototype.children = Object.freeze([]);
+class MakeDataVisitor extends Visitor {
+  visit(props) {
+    return this.getVisitFn(props["type"]).call(this, props);
+  }
+  visitNull(props) {
+    const { ["type"]: type, ["offset"]: offset = 0, ["length"]: length2 = 0 } = props;
+    return new Data(type, offset, length2, length2);
+  }
+  visitBool(props) {
+    const { ["type"]: type, ["offset"]: offset = 0 } = props;
+    const nullBitmap = toUint8Array(props["nullBitmap"]);
+    const data = toArrayBufferView(type.ArrayType, props["data"]);
+    const { ["length"]: length2 = data.length >> 3, ["nullCount"]: nullCount = props["nullBitmap"] ? -1 : 0 } = props;
+    return new Data(type, offset, length2, nullCount, [void 0, data, nullBitmap]);
+  }
+  visitInt(props) {
+    const { ["type"]: type, ["offset"]: offset = 0 } = props;
+    const nullBitmap = toUint8Array(props["nullBitmap"]);
+    const data = toArrayBufferView(type.ArrayType, props["data"]);
+    const { ["length"]: length2 = data.length, ["nullCount"]: nullCount = props["nullBitmap"] ? -1 : 0 } = props;
+    return new Data(type, offset, length2, nullCount, [void 0, data, nullBitmap]);
+  }
+  visitFloat(props) {
+    const { ["type"]: type, ["offset"]: offset = 0 } = props;
+    const nullBitmap = toUint8Array(props["nullBitmap"]);
+    const data = toArrayBufferView(type.ArrayType, props["data"]);
+    const { ["length"]: length2 = data.length, ["nullCount"]: nullCount = props["nullBitmap"] ? -1 : 0 } = props;
+    return new Data(type, offset, length2, nullCount, [void 0, data, nullBitmap]);
+  }
+  visitUtf8(props) {
+    const { ["type"]: type, ["offset"]: offset = 0 } = props;
+    const data = toUint8Array(props["data"]);
+    const nullBitmap = toUint8Array(props["nullBitmap"]);
+    const valueOffsets = toInt32Array(props["valueOffsets"]);
+    const { ["length"]: length2 = valueOffsets.length - 1, ["nullCount"]: nullCount = props["nullBitmap"] ? -1 : 0 } = props;
+    return new Data(type, offset, length2, nullCount, [valueOffsets, data, nullBitmap]);
+  }
+  visitLargeUtf8(props) {
+    const { ["type"]: type, ["offset"]: offset = 0 } = props;
+    const data = toUint8Array(props["data"]);
+    const nullBitmap = toUint8Array(props["nullBitmap"]);
+    const valueOffsets = toBigInt64Array(props["valueOffsets"]);
+    const { ["length"]: length2 = valueOffsets.length - 1, ["nullCount"]: nullCount = props["nullBitmap"] ? -1 : 0 } = props;
+    return new Data(type, offset, length2, nullCount, [valueOffsets, data, nullBitmap]);
+  }
+  visitBinary(props) {
+    const { ["type"]: type, ["offset"]: offset = 0 } = props;
+    const data = toUint8Array(props["data"]);
+    const nullBitmap = toUint8Array(props["nullBitmap"]);
+    const valueOffsets = toInt32Array(props["valueOffsets"]);
+    const { ["length"]: length2 = valueOffsets.length - 1, ["nullCount"]: nullCount = props["nullBitmap"] ? -1 : 0 } = props;
+    return new Data(type, offset, length2, nullCount, [valueOffsets, data, nullBitmap]);
+  }
+  visitLargeBinary(props) {
+    const { ["type"]: type, ["offset"]: offset = 0 } = props;
+    const data = toUint8Array(props["data"]);
+    const nullBitmap = toUint8Array(props["nullBitmap"]);
+    const valueOffsets = toBigInt64Array(props["valueOffsets"]);
+    const { ["length"]: length2 = valueOffsets.length - 1, ["nullCount"]: nullCount = props["nullBitmap"] ? -1 : 0 } = props;
+    return new Data(type, offset, length2, nullCount, [valueOffsets, data, nullBitmap]);
+  }
+  visitFixedSizeBinary(props) {
+    const { ["type"]: type, ["offset"]: offset = 0 } = props;
+    const nullBitmap = toUint8Array(props["nullBitmap"]);
+    const data = toArrayBufferView(type.ArrayType, props["data"]);
+    const { ["length"]: length2 = data.length / strideForType(type), ["nullCount"]: nullCount = props["nullBitmap"] ? -1 : 0 } = props;
+    return new Data(type, offset, length2, nullCount, [void 0, data, nullBitmap]);
+  }
+  visitDate(props) {
+    const { ["type"]: type, ["offset"]: offset = 0 } = props;
+    const nullBitmap = toUint8Array(props["nullBitmap"]);
+    const data = toArrayBufferView(type.ArrayType, props["data"]);
+    const { ["length"]: length2 = data.length / strideForType(type), ["nullCount"]: nullCount = props["nullBitmap"] ? -1 : 0 } = props;
+    return new Data(type, offset, length2, nullCount, [void 0, data, nullBitmap]);
+  }
+  visitTimestamp(props) {
+    const { ["type"]: type, ["offset"]: offset = 0 } = props;
+    const nullBitmap = toUint8Array(props["nullBitmap"]);
+    const data = toArrayBufferView(type.ArrayType, props["data"]);
+    const { ["length"]: length2 = data.length / strideForType(type), ["nullCount"]: nullCount = props["nullBitmap"] ? -1 : 0 } = props;
+    return new Data(type, offset, length2, nullCount, [void 0, data, nullBitmap]);
+  }
+  visitTime(props) {
+    const { ["type"]: type, ["offset"]: offset = 0 } = props;
+    const nullBitmap = toUint8Array(props["nullBitmap"]);
+    const data = toArrayBufferView(type.ArrayType, props["data"]);
+    const { ["length"]: length2 = data.length / strideForType(type), ["nullCount"]: nullCount = props["nullBitmap"] ? -1 : 0 } = props;
+    return new Data(type, offset, length2, nullCount, [void 0, data, nullBitmap]);
+  }
+  visitDecimal(props) {
+    const { ["type"]: type, ["offset"]: offset = 0 } = props;
+    const nullBitmap = toUint8Array(props["nullBitmap"]);
+    const data = toArrayBufferView(type.ArrayType, props["data"]);
+    const { ["length"]: length2 = data.length / strideForType(type), ["nullCount"]: nullCount = props["nullBitmap"] ? -1 : 0 } = props;
+    return new Data(type, offset, length2, nullCount, [void 0, data, nullBitmap]);
+  }
+  visitList(props) {
+    const { ["type"]: type, ["offset"]: offset = 0, ["child"]: child } = props;
+    const nullBitmap = toUint8Array(props["nullBitmap"]);
+    const valueOffsets = toInt32Array(props["valueOffsets"]);
+    const { ["length"]: length2 = valueOffsets.length - 1, ["nullCount"]: nullCount = props["nullBitmap"] ? -1 : 0 } = props;
+    return new Data(type, offset, length2, nullCount, [valueOffsets, void 0, nullBitmap], [child]);
+  }
+  visitStruct(props) {
+    const { ["type"]: type, ["offset"]: offset = 0, ["children"]: children = [] } = props;
+    const nullBitmap = toUint8Array(props["nullBitmap"]);
+    const { length: length2 = children.reduce((len2, { length: length3 }) => Math.max(len2, length3), 0), nullCount = props["nullBitmap"] ? -1 : 0 } = props;
+    return new Data(type, offset, length2, nullCount, [void 0, void 0, nullBitmap], children);
+  }
+  visitUnion(props) {
+    const { ["type"]: type, ["offset"]: offset = 0, ["children"]: children = [] } = props;
+    const typeIds = toArrayBufferView(type.ArrayType, props["typeIds"]);
+    const { ["length"]: length2 = typeIds.length, ["nullCount"]: nullCount = -1 } = props;
+    if (DataType.isSparseUnion(type)) {
+      return new Data(type, offset, length2, nullCount, [void 0, void 0, void 0, typeIds], children);
+    }
+    const valueOffsets = toInt32Array(props["valueOffsets"]);
+    return new Data(type, offset, length2, nullCount, [valueOffsets, void 0, void 0, typeIds], children);
+  }
+  visitDictionary(props) {
+    const { ["type"]: type, ["offset"]: offset = 0 } = props;
+    const nullBitmap = toUint8Array(props["nullBitmap"]);
+    const data = toArrayBufferView(type.indices.ArrayType, props["data"]);
+    const { ["dictionary"]: dictionary = new Vector$1([new MakeDataVisitor().visit({ type: type.dictionary })]) } = props;
+    const { ["length"]: length2 = data.length, ["nullCount"]: nullCount = props["nullBitmap"] ? -1 : 0 } = props;
+    return new Data(type, offset, length2, nullCount, [void 0, data, nullBitmap], [], dictionary);
+  }
+  visitInterval(props) {
+    const { ["type"]: type, ["offset"]: offset = 0 } = props;
+    const nullBitmap = toUint8Array(props["nullBitmap"]);
+    const data = toArrayBufferView(type.ArrayType, props["data"]);
+    const { ["length"]: length2 = data.length / strideForType(type), ["nullCount"]: nullCount = props["nullBitmap"] ? -1 : 0 } = props;
+    return new Data(type, offset, length2, nullCount, [void 0, data, nullBitmap]);
+  }
+  visitDuration(props) {
+    const { ["type"]: type, ["offset"]: offset = 0 } = props;
+    const nullBitmap = toUint8Array(props["nullBitmap"]);
+    const data = toArrayBufferView(type.ArrayType, props["data"]);
+    const { ["length"]: length2 = data.length, ["nullCount"]: nullCount = props["nullBitmap"] ? -1 : 0 } = props;
+    return new Data(type, offset, length2, nullCount, [void 0, data, nullBitmap]);
+  }
+  visitFixedSizeList(props) {
+    const { ["type"]: type, ["offset"]: offset = 0, ["child"]: child = new MakeDataVisitor().visit({ type: type.valueType }) } = props;
+    const nullBitmap = toUint8Array(props["nullBitmap"]);
+    const { ["length"]: length2 = child.length / strideForType(type), ["nullCount"]: nullCount = props["nullBitmap"] ? -1 : 0 } = props;
+    return new Data(type, offset, length2, nullCount, [void 0, void 0, nullBitmap], [child]);
+  }
+  visitMap(props) {
+    const { ["type"]: type, ["offset"]: offset = 0, ["child"]: child = new MakeDataVisitor().visit({ type: type.childType }) } = props;
+    const nullBitmap = toUint8Array(props["nullBitmap"]);
+    const valueOffsets = toInt32Array(props["valueOffsets"]);
+    const { ["length"]: length2 = valueOffsets.length - 1, ["nullCount"]: nullCount = props["nullBitmap"] ? -1 : 0 } = props;
+    return new Data(type, offset, length2, nullCount, [valueOffsets, void 0, nullBitmap], [child]);
+  }
+}
+const makeDataVisitor = new MakeDataVisitor();
+function makeData(props) {
+  return makeDataVisitor.visit(props);
+}
+class ChunkedIterator {
+  constructor(numChunks = 0, getChunkIterator) {
+    this.numChunks = numChunks;
+    this.getChunkIterator = getChunkIterator;
+    this.chunkIndex = 0;
+    this.chunkIterator = this.getChunkIterator(0);
+  }
+  next() {
+    while (this.chunkIndex < this.numChunks) {
+      const next = this.chunkIterator.next();
+      if (!next.done) {
+        return next;
+      }
+      if (++this.chunkIndex < this.numChunks) {
+        this.chunkIterator = this.getChunkIterator(this.chunkIndex);
+      }
+    }
+    return { done: true, value: null };
+  }
+  [Symbol.iterator]() {
+    return this;
+  }
+}
+function computeChunkNullable(chunks) {
+  return chunks.some((chunk) => chunk.nullable);
+}
+function computeChunkNullCounts(chunks) {
+  return chunks.reduce((nullCount, chunk) => nullCount + chunk.nullCount, 0);
+}
+function computeChunkOffsets(chunks) {
+  return chunks.reduce((offsets, chunk, index) => {
+    offsets[index + 1] = offsets[index] + chunk.length;
+    return offsets;
+  }, new Uint32Array(chunks.length + 1));
+}
+function sliceChunks(chunks, offsets, begin, end) {
+  const slices = [];
+  for (let i2 = -1, n2 = chunks.length; ++i2 < n2; ) {
+    const chunk = chunks[i2];
+    const offset = offsets[i2];
+    const { length: length2 } = chunk;
+    if (offset >= end) {
+      break;
+    }
+    if (begin >= offset + length2) {
+      continue;
+    }
+    if (offset >= begin && offset + length2 <= end) {
+      slices.push(chunk);
+      continue;
+    }
+    const from = Math.max(0, begin - offset);
+    const to = Math.min(end - offset, length2);
+    slices.push(chunk.slice(from, to - from));
+  }
+  if (slices.length === 0) {
+    slices.push(chunks[0].slice(0, 0));
+  }
+  return slices;
+}
+function binarySearch(chunks, offsets, idx, fn) {
+  let lhs = 0, mid = 0, rhs = offsets.length - 1;
+  do {
+    if (lhs >= rhs - 1) {
+      return idx < offsets[rhs] ? fn(chunks, lhs, idx - offsets[lhs]) : null;
+    }
+    mid = lhs + Math.trunc((rhs - lhs) * 0.5);
+    idx < offsets[mid] ? rhs = mid : lhs = mid;
+  } while (lhs < rhs);
+}
+function isChunkedValid(data, index) {
+  return data.getValid(index);
+}
+function wrapChunkedCall1(fn) {
+  function chunkedFn(chunks, i2, j2) {
+    return fn(chunks[i2], j2);
+  }
+  return function(index) {
+    const data = this.data;
+    return binarySearch(data, this._offsets, index, chunkedFn);
+  };
+}
+function wrapChunkedCall2(fn) {
+  let _2;
+  function chunkedFn(chunks, i2, j2) {
+    return fn(chunks[i2], j2, _2);
+  }
+  return function(index, value) {
+    const data = this.data;
+    _2 = value;
+    const result = binarySearch(data, this._offsets, index, chunkedFn);
+    _2 = void 0;
+    return result;
+  };
+}
+function wrapChunkedIndexOf(indexOf) {
+  let _1;
+  function chunkedIndexOf(data, chunkIndex, fromIndex) {
+    let begin = fromIndex, index = 0, total = 0;
+    for (let i2 = chunkIndex - 1, n2 = data.length; ++i2 < n2; ) {
+      const chunk = data[i2];
+      if (~(index = indexOf(chunk, _1, begin))) {
+        return total + index;
+      }
+      begin = 0;
+      total += chunk.length;
+    }
+    return -1;
+  }
+  return function(element, offset) {
+    _1 = element;
+    const data = this.data;
+    const result = typeof offset !== "number" ? chunkedIndexOf(data, 0, 0) : binarySearch(data, this._offsets, offset, chunkedIndexOf);
+    _1 = void 0;
+    return result;
+  };
+}
+class IndexOfVisitor extends Visitor {
+}
+function nullIndexOf(data, searchElement) {
+  return searchElement === null && data.length > 0 ? 0 : -1;
+}
+function indexOfNull(data, fromIndex) {
+  const { nullBitmap } = data;
+  if (!nullBitmap || data.nullCount <= 0) {
+    return -1;
+  }
+  let i2 = 0;
+  for (const isValid of new BitIterator(nullBitmap, data.offset + (fromIndex || 0), data.length, nullBitmap, getBool)) {
+    if (!isValid) {
+      return i2;
+    }
+    ++i2;
+  }
+  return -1;
+}
+function indexOfValue(data, searchElement, fromIndex) {
+  if (searchElement === void 0) {
+    return -1;
+  }
+  if (searchElement === null) {
+    switch (data.typeId) {
+      case Type.Union:
+        break;
+      case Type.Dictionary:
+        break;
+      default:
+        return indexOfNull(data, fromIndex);
+    }
+  }
+  const get = instance$4.getVisitFn(data);
+  const compare = createElementComparator(searchElement);
+  for (let i2 = (fromIndex || 0) - 1, n2 = data.length; ++i2 < n2; ) {
+    if (compare(get(data, i2))) {
+      return i2;
+    }
+  }
+  return -1;
+}
+function indexOfUnion(data, searchElement, fromIndex) {
+  const get = instance$4.getVisitFn(data);
+  const compare = createElementComparator(searchElement);
+  for (let i2 = (fromIndex || 0) - 1, n2 = data.length; ++i2 < n2; ) {
+    if (compare(get(data, i2))) {
+      return i2;
+    }
+  }
+  return -1;
+}
+IndexOfVisitor.prototype.visitNull = nullIndexOf;
+IndexOfVisitor.prototype.visitBool = indexOfValue;
+IndexOfVisitor.prototype.visitInt = indexOfValue;
+IndexOfVisitor.prototype.visitInt8 = indexOfValue;
+IndexOfVisitor.prototype.visitInt16 = indexOfValue;
+IndexOfVisitor.prototype.visitInt32 = indexOfValue;
+IndexOfVisitor.prototype.visitInt64 = indexOfValue;
+IndexOfVisitor.prototype.visitUint8 = indexOfValue;
+IndexOfVisitor.prototype.visitUint16 = indexOfValue;
+IndexOfVisitor.prototype.visitUint32 = indexOfValue;
+IndexOfVisitor.prototype.visitUint64 = indexOfValue;
+IndexOfVisitor.prototype.visitFloat = indexOfValue;
+IndexOfVisitor.prototype.visitFloat16 = indexOfValue;
+IndexOfVisitor.prototype.visitFloat32 = indexOfValue;
+IndexOfVisitor.prototype.visitFloat64 = indexOfValue;
+IndexOfVisitor.prototype.visitUtf8 = indexOfValue;
+IndexOfVisitor.prototype.visitLargeUtf8 = indexOfValue;
+IndexOfVisitor.prototype.visitBinary = indexOfValue;
+IndexOfVisitor.prototype.visitLargeBinary = indexOfValue;
+IndexOfVisitor.prototype.visitFixedSizeBinary = indexOfValue;
+IndexOfVisitor.prototype.visitDate = indexOfValue;
+IndexOfVisitor.prototype.visitDateDay = indexOfValue;
+IndexOfVisitor.prototype.visitDateMillisecond = indexOfValue;
+IndexOfVisitor.prototype.visitTimestamp = indexOfValue;
+IndexOfVisitor.prototype.visitTimestampSecond = indexOfValue;
+IndexOfVisitor.prototype.visitTimestampMillisecond = indexOfValue;
+IndexOfVisitor.prototype.visitTimestampMicrosecond = indexOfValue;
+IndexOfVisitor.prototype.visitTimestampNanosecond = indexOfValue;
+IndexOfVisitor.prototype.visitTime = indexOfValue;
+IndexOfVisitor.prototype.visitTimeSecond = indexOfValue;
+IndexOfVisitor.prototype.visitTimeMillisecond = indexOfValue;
+IndexOfVisitor.prototype.visitTimeMicrosecond = indexOfValue;
+IndexOfVisitor.prototype.visitTimeNanosecond = indexOfValue;
+IndexOfVisitor.prototype.visitDecimal = indexOfValue;
+IndexOfVisitor.prototype.visitList = indexOfValue;
+IndexOfVisitor.prototype.visitStruct = indexOfValue;
+IndexOfVisitor.prototype.visitUnion = indexOfValue;
+IndexOfVisitor.prototype.visitDenseUnion = indexOfUnion;
+IndexOfVisitor.prototype.visitSparseUnion = indexOfUnion;
+IndexOfVisitor.prototype.visitDictionary = indexOfValue;
+IndexOfVisitor.prototype.visitInterval = indexOfValue;
+IndexOfVisitor.prototype.visitIntervalDayTime = indexOfValue;
+IndexOfVisitor.prototype.visitIntervalYearMonth = indexOfValue;
+IndexOfVisitor.prototype.visitIntervalMonthDayNano = indexOfValue;
+IndexOfVisitor.prototype.visitDuration = indexOfValue;
+IndexOfVisitor.prototype.visitDurationSecond = indexOfValue;
+IndexOfVisitor.prototype.visitDurationMillisecond = indexOfValue;
+IndexOfVisitor.prototype.visitDurationMicrosecond = indexOfValue;
+IndexOfVisitor.prototype.visitDurationNanosecond = indexOfValue;
+IndexOfVisitor.prototype.visitFixedSizeList = indexOfValue;
+IndexOfVisitor.prototype.visitMap = indexOfValue;
+const instance$3 = new IndexOfVisitor();
+class IteratorVisitor extends Visitor {
+}
+function vectorIterator(vector) {
+  const { type } = vector;
+  if (vector.nullCount === 0 && vector.stride === 1 && // Don't defer to native iterator for timestamps since Numbers are expected
+  // (DataType.isTimestamp(type)) && type.unit === TimeUnit.MILLISECOND ||
+  (DataType.isInt(type) && type.bitWidth !== 64 || DataType.isTime(type) && type.bitWidth !== 64 || DataType.isFloat(type) && type.precision !== Precision.HALF)) {
+    return new ChunkedIterator(vector.data.length, (chunkIndex) => {
+      const data = vector.data[chunkIndex];
+      return data.values.subarray(0, data.length)[Symbol.iterator]();
+    });
+  }
+  let offset = 0;
+  return new ChunkedIterator(vector.data.length, (chunkIndex) => {
+    const data = vector.data[chunkIndex];
+    const length2 = data.length;
+    const inner = vector.slice(offset, offset + length2);
+    offset += length2;
+    return new VectorIterator(inner);
+  });
+}
+class VectorIterator {
+  constructor(vector) {
+    this.vector = vector;
+    this.index = 0;
+  }
+  next() {
+    if (this.index < this.vector.length) {
+      return {
+        value: this.vector.get(this.index++)
+      };
+    }
+    return { done: true, value: null };
+  }
+  [Symbol.iterator]() {
+    return this;
+  }
+}
+IteratorVisitor.prototype.visitNull = vectorIterator;
+IteratorVisitor.prototype.visitBool = vectorIterator;
+IteratorVisitor.prototype.visitInt = vectorIterator;
+IteratorVisitor.prototype.visitInt8 = vectorIterator;
+IteratorVisitor.prototype.visitInt16 = vectorIterator;
+IteratorVisitor.prototype.visitInt32 = vectorIterator;
+IteratorVisitor.prototype.visitInt64 = vectorIterator;
+IteratorVisitor.prototype.visitUint8 = vectorIterator;
+IteratorVisitor.prototype.visitUint16 = vectorIterator;
+IteratorVisitor.prototype.visitUint32 = vectorIterator;
+IteratorVisitor.prototype.visitUint64 = vectorIterator;
+IteratorVisitor.prototype.visitFloat = vectorIterator;
+IteratorVisitor.prototype.visitFloat16 = vectorIterator;
+IteratorVisitor.prototype.visitFloat32 = vectorIterator;
+IteratorVisitor.prototype.visitFloat64 = vectorIterator;
+IteratorVisitor.prototype.visitUtf8 = vectorIterator;
+IteratorVisitor.prototype.visitLargeUtf8 = vectorIterator;
+IteratorVisitor.prototype.visitBinary = vectorIterator;
+IteratorVisitor.prototype.visitLargeBinary = vectorIterator;
+IteratorVisitor.prototype.visitFixedSizeBinary = vectorIterator;
+IteratorVisitor.prototype.visitDate = vectorIterator;
+IteratorVisitor.prototype.visitDateDay = vectorIterator;
+IteratorVisitor.prototype.visitDateMillisecond = vectorIterator;
+IteratorVisitor.prototype.visitTimestamp = vectorIterator;
+IteratorVisitor.prototype.visitTimestampSecond = vectorIterator;
+IteratorVisitor.prototype.visitTimestampMillisecond = vectorIterator;
+IteratorVisitor.prototype.visitTimestampMicrosecond = vectorIterator;
+IteratorVisitor.prototype.visitTimestampNanosecond = vectorIterator;
+IteratorVisitor.prototype.visitTime = vectorIterator;
+IteratorVisitor.prototype.visitTimeSecond = vectorIterator;
+IteratorVisitor.prototype.visitTimeMillisecond = vectorIterator;
+IteratorVisitor.prototype.visitTimeMicrosecond = vectorIterator;
+IteratorVisitor.prototype.visitTimeNanosecond = vectorIterator;
+IteratorVisitor.prototype.visitDecimal = vectorIterator;
+IteratorVisitor.prototype.visitList = vectorIterator;
+IteratorVisitor.prototype.visitStruct = vectorIterator;
+IteratorVisitor.prototype.visitUnion = vectorIterator;
+IteratorVisitor.prototype.visitDenseUnion = vectorIterator;
+IteratorVisitor.prototype.visitSparseUnion = vectorIterator;
+IteratorVisitor.prototype.visitDictionary = vectorIterator;
+IteratorVisitor.prototype.visitInterval = vectorIterator;
+IteratorVisitor.prototype.visitIntervalDayTime = vectorIterator;
+IteratorVisitor.prototype.visitIntervalYearMonth = vectorIterator;
+IteratorVisitor.prototype.visitIntervalMonthDayNano = vectorIterator;
+IteratorVisitor.prototype.visitDuration = vectorIterator;
+IteratorVisitor.prototype.visitDurationSecond = vectorIterator;
+IteratorVisitor.prototype.visitDurationMillisecond = vectorIterator;
+IteratorVisitor.prototype.visitDurationMicrosecond = vectorIterator;
+IteratorVisitor.prototype.visitDurationNanosecond = vectorIterator;
+IteratorVisitor.prototype.visitFixedSizeList = vectorIterator;
+IteratorVisitor.prototype.visitMap = vectorIterator;
+const instance$2 = new IteratorVisitor();
+var _a$2;
+const visitorsByTypeId = {};
+const vectorPrototypesByTypeId = {};
+let Vector$1 = class Vector {
+  constructor(input) {
+    var _b3, _c3, _d2;
+    const data = input[0] instanceof Vector ? input.flatMap((x2) => x2.data) : input;
+    if (data.length === 0 || data.some((x2) => !(x2 instanceof Data))) {
+      throw new TypeError("Vector constructor expects an Array of Data instances.");
+    }
+    const type = (_b3 = data[0]) === null || _b3 === void 0 ? void 0 : _b3.type;
+    switch (data.length) {
+      case 0:
+        this._offsets = [0];
+        break;
+      case 1: {
+        const { get, set, indexOf } = visitorsByTypeId[type.typeId];
+        const unchunkedData = data[0];
+        this.isValid = (index) => isChunkedValid(unchunkedData, index);
+        this.get = (index) => get(unchunkedData, index);
+        this.set = (index, value) => set(unchunkedData, index, value);
+        this.indexOf = (index) => indexOf(unchunkedData, index);
+        this._offsets = [0, unchunkedData.length];
+        break;
+      }
+      default:
+        Object.setPrototypeOf(this, vectorPrototypesByTypeId[type.typeId]);
+        this._offsets = computeChunkOffsets(data);
+        break;
+    }
+    this.data = data;
+    this.type = type;
+    this.stride = strideForType(type);
+    this.numChildren = (_d2 = (_c3 = type.children) === null || _c3 === void 0 ? void 0 : _c3.length) !== null && _d2 !== void 0 ? _d2 : 0;
+    this.length = this._offsets.at(-1);
+  }
+  /**
+   * The aggregate size (in bytes) of this Vector's buffers and/or child Vectors.
+   */
+  get byteLength() {
+    return this.data.reduce((byteLength, data) => byteLength + data.byteLength, 0);
+  }
+  /**
+   * Whether this Vector's elements can contain null values.
+   */
+  get nullable() {
+    return computeChunkNullable(this.data);
+  }
+  /**
+   * The number of null elements in this Vector.
+   */
+  get nullCount() {
+    return computeChunkNullCounts(this.data);
+  }
+  /**
+   * The Array or TypedArray constructor used for the JS representation
+   *  of the element's values in {@link Vector.prototype.toArray `toArray()`}.
+   */
+  get ArrayType() {
+    return this.type.ArrayType;
+  }
+  /**
+   * The name that should be printed when the Vector is logged in a message.
+   */
+  get [Symbol.toStringTag]() {
+    return `${this.VectorName}<${this.type[Symbol.toStringTag]}>`;
+  }
+  /**
+   * The name of this Vector.
+   */
+  get VectorName() {
+    return `${Type[this.type.typeId]}Vector`;
+  }
+  /**
+   * Check whether an element is null.
+   * @param index The index at which to read the validity bitmap.
+   */
+  // @ts-ignore
+  isValid(index) {
+    return false;
+  }
+  /**
+   * Get an element value by position.
+   * @param index The index of the element to read.
+   */
+  // @ts-ignore
+  get(index) {
+    return null;
+  }
+  /**
+   * Get an element value by position.
+   * @param index The index of the element to read. A negative index will count back from the last element.
+   */
+  at(index) {
+    return this.get(wrapIndex(index, this.length));
+  }
+  /**
+   * Set an element value by position.
+   * @param index The index of the element to write.
+   * @param value The value to set.
+   */
+  // @ts-ignore
+  set(index, value) {
+    return;
+  }
+  /**
+   * Retrieve the index of the first occurrence of a value in an Vector.
+   * @param element The value to locate in the Vector.
+   * @param offset The index at which to begin the search. If offset is omitted, the search starts at index 0.
+   */
+  // @ts-ignore
+  indexOf(element, offset) {
+    return -1;
+  }
+  includes(element, offset) {
+    return this.indexOf(element, offset) > -1;
+  }
+  /**
+   * Iterator for the Vector's elements.
+   */
+  [Symbol.iterator]() {
+    return instance$2.visit(this);
+  }
+  /**
+   * Combines two or more Vectors of the same type.
+   * @param others Additional Vectors to add to the end of this Vector.
+   */
+  concat(...others) {
+    return new Vector(this.data.concat(others.flatMap((x2) => x2.data).flat(Number.POSITIVE_INFINITY)));
+  }
+  /**
+   * Return a zero-copy sub-section of this Vector.
+   * @param start The beginning of the specified portion of the Vector.
+   * @param end The end of the specified portion of the Vector. This is exclusive of the element at the index 'end'.
+   */
+  slice(begin, end) {
+    return new Vector(clampRange(this, begin, end, ({ data, _offsets }, begin2, end2) => sliceChunks(data, _offsets, begin2, end2)));
+  }
+  toJSON() {
+    return [...this];
+  }
+  /**
+   * Return a JavaScript Array or TypedArray of the Vector's elements.
+   *
+   * @note If this Vector contains a single Data chunk and the Vector's type is a
+   *  primitive numeric type corresponding to one of the JavaScript TypedArrays, this
+   *  method returns a zero-copy slice of the underlying TypedArray values. If there's
+   *  more than one chunk, the resulting TypedArray will be a copy of the data from each
+   *  chunk's underlying TypedArray values.
+   *
+   * @returns An Array or TypedArray of the Vector's elements, based on the Vector's DataType.
+   */
+  toArray() {
+    const { type, data, length: length2, stride, ArrayType } = this;
+    switch (type.typeId) {
+      case Type.Int:
+      case Type.Float:
+      case Type.Decimal:
+      case Type.Time:
+      case Type.Timestamp:
+        switch (data.length) {
+          case 0:
+            return new ArrayType();
+          case 1:
+            return data[0].values.subarray(0, length2 * stride);
+          default:
+            return data.reduce((memo, { values, length: chunk_length }) => {
+              memo.array.set(values.subarray(0, chunk_length * stride), memo.offset);
+              memo.offset += chunk_length * stride;
+              return memo;
+            }, { array: new ArrayType(length2 * stride), offset: 0 }).array;
+        }
+    }
+    return [...this];
+  }
+  /**
+   * Returns a string representation of the Vector.
+   *
+   * @returns A string representation of the Vector.
+   */
+  toString() {
+    return `[${[...this].join(",")}]`;
+  }
+  /**
+   * Returns a child Vector by name, or null if this Vector has no child with the given name.
+   * @param name The name of the child to retrieve.
+   */
+  getChild(name2) {
+    var _b3;
+    return this.getChildAt((_b3 = this.type.children) === null || _b3 === void 0 ? void 0 : _b3.findIndex((f2) => f2.name === name2));
+  }
+  /**
+   * Returns a child Vector by index, or null if this Vector has no child at the supplied index.
+   * @param index The index of the child to retrieve.
+   */
+  getChildAt(index) {
+    if (index > -1 && index < this.numChildren) {
+      return new Vector(this.data.map(({ children }) => children[index]));
+    }
+    return null;
+  }
+  get isMemoized() {
+    if (DataType.isDictionary(this.type)) {
+      return this.data[0].dictionary.isMemoized;
+    }
+    return false;
+  }
+  /**
+   * Adds memoization to the Vector's {@link get} method. For dictionary
+   * vectors, this method return a vector that memoizes only the dictionary
+   * values.
+   *
+   * Memoization is very useful when decoding a value is expensive such as
+   * Utf8. The memoization creates a cache of the size of the Vector and
+   * therefore increases memory usage.
+   *
+   * @returns A new vector that memoizes calls to {@link get}.
+   */
+  memoize() {
+    if (DataType.isDictionary(this.type)) {
+      const dictionary = new MemoizedVector(this.data[0].dictionary);
+      const newData = this.data.map((data) => {
+        const cloned = data.clone();
+        cloned.dictionary = dictionary;
+        return cloned;
+      });
+      return new Vector(newData);
+    }
+    return new MemoizedVector(this);
+  }
+  /**
+   * Returns a vector without memoization of the {@link get} method. If this
+   * vector is not memoized, this method returns this vector.
+   *
+   * @returns A new vector without memoization.
+   */
+  unmemoize() {
+    if (DataType.isDictionary(this.type) && this.isMemoized) {
+      const dictionary = this.data[0].dictionary.unmemoize();
+      const newData = this.data.map((data) => {
+        const newData2 = data.clone();
+        newData2.dictionary = dictionary;
+        return newData2;
+      });
+      return new Vector(newData);
+    }
+    return this;
+  }
+};
+_a$2 = Symbol.toStringTag;
+Vector$1[_a$2] = ((proto) => {
+  proto.type = DataType.prototype;
+  proto.data = [];
+  proto.length = 0;
+  proto.stride = 1;
+  proto.numChildren = 0;
+  proto._offsets = new Uint32Array([0]);
+  proto[Symbol.isConcatSpreadable] = true;
+  const typeIds = Object.keys(Type).map((T2) => Type[T2]).filter((T2) => typeof T2 === "number" && T2 !== Type.NONE);
+  for (const typeId of typeIds) {
+    const get = instance$4.getVisitFnByTypeId(typeId);
+    const set = instance$5.getVisitFnByTypeId(typeId);
+    const indexOf = instance$3.getVisitFnByTypeId(typeId);
+    visitorsByTypeId[typeId] = { get, set, indexOf };
+    vectorPrototypesByTypeId[typeId] = Object.create(proto, {
+      ["isValid"]: { value: wrapChunkedCall1(isChunkedValid) },
+      ["get"]: { value: wrapChunkedCall1(instance$4.getVisitFnByTypeId(typeId)) },
+      ["set"]: { value: wrapChunkedCall2(instance$5.getVisitFnByTypeId(typeId)) },
+      ["indexOf"]: { value: wrapChunkedIndexOf(instance$3.getVisitFnByTypeId(typeId)) }
+    });
+  }
+  return "Vector";
+})(Vector$1.prototype);
+class MemoizedVector extends Vector$1 {
+  constructor(vector) {
+    super(vector.data);
+    const get = this.get;
+    const set = this.set;
+    const slice = this.slice;
+    const cache = new Array(this.length);
+    Object.defineProperty(this, "get", {
+      value(index) {
+        const cachedValue = cache[index];
+        if (cachedValue !== void 0) {
+          return cachedValue;
+        }
+        const value = get.call(this, index);
+        cache[index] = value;
+        return value;
+      }
+    });
+    Object.defineProperty(this, "set", {
+      value(index, value) {
+        set.call(this, index, value);
+        cache[index] = value;
+      }
+    });
+    Object.defineProperty(this, "slice", {
+      value: (begin, end) => new MemoizedVector(slice.call(this, begin, end))
+    });
+    Object.defineProperty(this, "isMemoized", { value: true });
+    Object.defineProperty(this, "unmemoize", {
+      value: () => new Vector$1(this.data)
+    });
+    Object.defineProperty(this, "memoize", {
+      value: () => this
+    });
+  }
+}
+class Block {
+  constructor() {
+    this.bb = null;
+    this.bb_pos = 0;
+  }
+  __init(i2, bb2) {
+    this.bb_pos = i2;
+    this.bb = bb2;
+    return this;
+  }
+  /**
+   * Index to the start of the RecordBlock (note this is past the Message header)
+   */
+  offset() {
+    return this.bb.readInt64(this.bb_pos);
+  }
+  /**
+   * Length of the metadata
+   */
+  metaDataLength() {
+    return this.bb.readInt32(this.bb_pos + 8);
+  }
+  /**
+   * Length of the data (this is aligned so there can be a gap between this and
+   * the metadata).
+   */
+  bodyLength() {
+    return this.bb.readInt64(this.bb_pos + 16);
+  }
+  static sizeOf() {
+    return 24;
+  }
+  static createBlock(builder, offset, metaDataLength, bodyLength) {
+    builder.prep(8, 24);
+    builder.writeInt64(BigInt(bodyLength !== null && bodyLength !== void 0 ? bodyLength : 0));
+    builder.pad(4);
+    builder.writeInt32(metaDataLength);
+    builder.writeInt64(BigInt(offset !== null && offset !== void 0 ? offset : 0));
+    return builder.offset();
+  }
+}
+class Footer {
+  constructor() {
+    this.bb = null;
+    this.bb_pos = 0;
+  }
+  __init(i2, bb2) {
+    this.bb_pos = i2;
+    this.bb = bb2;
+    return this;
+  }
+  static getRootAsFooter(bb2, obj) {
+    return (obj || new Footer()).__init(bb2.readInt32(bb2.position()) + bb2.position(), bb2);
+  }
+  static getSizePrefixedRootAsFooter(bb2, obj) {
+    bb2.setPosition(bb2.position() + SIZE_PREFIX_LENGTH);
+    return (obj || new Footer()).__init(bb2.readInt32(bb2.position()) + bb2.position(), bb2);
+  }
+  version() {
+    const offset = this.bb.__offset(this.bb_pos, 4);
+    return offset ? this.bb.readInt16(this.bb_pos + offset) : MetadataVersion.V1;
+  }
+  schema(obj) {
+    const offset = this.bb.__offset(this.bb_pos, 6);
+    return offset ? (obj || new Schema$1()).__init(this.bb.__indirect(this.bb_pos + offset), this.bb) : null;
+  }
+  dictionaries(index, obj) {
+    const offset = this.bb.__offset(this.bb_pos, 8);
+    return offset ? (obj || new Block()).__init(this.bb.__vector(this.bb_pos + offset) + index * 24, this.bb) : null;
+  }
+  dictionariesLength() {
+    const offset = this.bb.__offset(this.bb_pos, 8);
+    return offset ? this.bb.__vector_len(this.bb_pos + offset) : 0;
+  }
+  recordBatches(index, obj) {
+    const offset = this.bb.__offset(this.bb_pos, 10);
+    return offset ? (obj || new Block()).__init(this.bb.__vector(this.bb_pos + offset) + index * 24, this.bb) : null;
+  }
+  recordBatchesLength() {
+    const offset = this.bb.__offset(this.bb_pos, 10);
+    return offset ? this.bb.__vector_len(this.bb_pos + offset) : 0;
+  }
+  /**
+   * User-defined metadata
+   */
+  customMetadata(index, obj) {
+    const offset = this.bb.__offset(this.bb_pos, 12);
+    return offset ? (obj || new KeyValue()).__init(this.bb.__indirect(this.bb.__vector(this.bb_pos + offset) + index * 4), this.bb) : null;
+  }
+  customMetadataLength() {
+    const offset = this.bb.__offset(this.bb_pos, 12);
+    return offset ? this.bb.__vector_len(this.bb_pos + offset) : 0;
+  }
+  static startFooter(builder) {
+    builder.startObject(5);
+  }
+  static addVersion(builder, version2) {
+    builder.addFieldInt16(0, version2, MetadataVersion.V1);
+  }
+  static addSchema(builder, schemaOffset) {
+    builder.addFieldOffset(1, schemaOffset, 0);
+  }
+  static addDictionaries(builder, dictionariesOffset) {
+    builder.addFieldOffset(2, dictionariesOffset, 0);
+  }
+  static startDictionariesVector(builder, numElems) {
+    builder.startVector(24, numElems, 8);
+  }
+  static addRecordBatches(builder, recordBatchesOffset) {
+    builder.addFieldOffset(3, recordBatchesOffset, 0);
+  }
+  static startRecordBatchesVector(builder, numElems) {
+    builder.startVector(24, numElems, 8);
+  }
+  static addCustomMetadata(builder, customMetadataOffset) {
+    builder.addFieldOffset(4, customMetadataOffset, 0);
+  }
+  static createCustomMetadataVector(builder, data) {
+    builder.startVector(4, data.length, 4);
+    for (let i2 = data.length - 1; i2 >= 0; i2--) {
+      builder.addOffset(data[i2]);
+    }
+    return builder.endVector();
+  }
+  static startCustomMetadataVector(builder, numElems) {
+    builder.startVector(4, numElems, 4);
+  }
+  static endFooter(builder) {
+    const offset = builder.endObject();
+    return offset;
+  }
+  static finishFooterBuffer(builder, offset) {
+    builder.finish(offset);
+  }
+  static finishSizePrefixedFooterBuffer(builder, offset) {
+    builder.finish(offset, void 0, true);
+  }
+}
+class Schema2 {
+  constructor(fields = [], metadata, dictionaries, metadataVersion = MetadataVersion.V5) {
+    this.fields = fields || [];
+    this.metadata = metadata || /* @__PURE__ */ new Map();
+    if (!dictionaries) {
+      dictionaries = generateDictionaryMap(this.fields);
+    }
+    this.dictionaries = dictionaries;
+    this.metadataVersion = metadataVersion;
+  }
+  get [Symbol.toStringTag]() {
+    return "Schema";
+  }
+  get names() {
+    return this.fields.map((f2) => f2.name);
+  }
+  toString() {
+    return `Schema<{ ${this.fields.map((f2, i2) => `${i2}: ${f2}`).join(", ")} }>`;
+  }
+  /**
+   * Construct a new Schema containing only specified fields.
+   *
+   * @param fieldNames Names of fields to keep.
+   * @returns A new Schema of fields matching the specified names.
+   */
+  select(fieldNames) {
+    const names = new Set(fieldNames);
+    const fields = this.fields.filter((f2) => names.has(f2.name));
+    return new Schema2(fields, this.metadata);
+  }
+  /**
+   * Construct a new Schema containing only fields at the specified indices.
+   *
+   * @param fieldIndices Indices of fields to keep.
+   * @returns A new Schema of fields at the specified indices.
+   */
+  selectAt(fieldIndices) {
+    const fields = fieldIndices.map((i2) => this.fields[i2]).filter(Boolean);
+    return new Schema2(fields, this.metadata);
+  }
+  assign(...args) {
+    const other = args[0] instanceof Schema2 ? args[0] : Array.isArray(args[0]) ? new Schema2(args[0]) : new Schema2(args);
+    const curFields = [...this.fields];
+    const metadata = mergeMaps(mergeMaps(/* @__PURE__ */ new Map(), this.metadata), other.metadata);
+    const newFields = other.fields.filter((f2) => {
+      const i2 = curFields.findIndex((f3) => f3.name === f2.name);
+      return ~i2 ? (curFields[i2] = f2.clone({
+        metadata: mergeMaps(mergeMaps(/* @__PURE__ */ new Map(), curFields[i2].metadata), f2.metadata)
+      })) && false : true;
+    });
+    const newDictionaries = generateDictionaryMap(newFields, /* @__PURE__ */ new Map());
+    return new Schema2([...curFields, ...newFields], metadata, new Map([...this.dictionaries, ...newDictionaries]));
+  }
+}
+Schema2.prototype.fields = null;
+Schema2.prototype.metadata = null;
+Schema2.prototype.dictionaries = null;
+class Field2 {
+  /** @nocollapse */
+  static new(...args) {
+    let [name2, type, nullable, metadata] = args;
+    if (args[0] && typeof args[0] === "object") {
+      ({ name: name2 } = args[0]);
+      type === void 0 && (type = args[0].type);
+      nullable === void 0 && (nullable = args[0].nullable);
+      metadata === void 0 && (metadata = args[0].metadata);
+    }
+    return new Field2(`${name2}`, type, nullable, metadata);
+  }
+  constructor(name2, type, nullable = false, metadata) {
+    this.name = name2;
+    this.type = type;
+    this.nullable = nullable;
+    this.metadata = metadata || /* @__PURE__ */ new Map();
+  }
+  get typeId() {
+    return this.type.typeId;
+  }
+  get [Symbol.toStringTag]() {
+    return "Field";
+  }
+  toString() {
+    return `${this.name}: ${this.type}`;
+  }
+  clone(...args) {
+    let [name2, type, nullable, metadata] = args;
+    !args[0] || typeof args[0] !== "object" ? [name2 = this.name, type = this.type, nullable = this.nullable, metadata = this.metadata] = args : { name: name2 = this.name, type = this.type, nullable = this.nullable, metadata = this.metadata } = args[0];
+    return Field2.new(name2, type, nullable, metadata);
+  }
+}
+Field2.prototype.type = null;
+Field2.prototype.name = null;
+Field2.prototype.nullable = null;
+Field2.prototype.metadata = null;
+function mergeMaps(m1, m2) {
+  return new Map([...m1 || /* @__PURE__ */ new Map(), ...m2 || /* @__PURE__ */ new Map()]);
+}
+function generateDictionaryMap(fields, dictionaries = /* @__PURE__ */ new Map()) {
+  for (let i2 = -1, n2 = fields.length; ++i2 < n2; ) {
+    const field = fields[i2];
+    const type = field.type;
+    if (DataType.isDictionary(type)) {
+      if (!dictionaries.has(type.id)) {
+        dictionaries.set(type.id, type.dictionary);
+      } else if (dictionaries.get(type.id) !== type.dictionary) {
+        throw new Error(`Cannot create Schema containing two different dictionaries with the same Id`);
+      }
+    }
+    if (type.children && type.children.length > 0) {
+      generateDictionaryMap(type.children, dictionaries);
+    }
+  }
+  return dictionaries;
+}
+var Builder$1 = Builder$2;
+var ByteBuffer$1 = ByteBuffer$2;
+class Footer_ {
+  /** @nocollapse */
+  static decode(buf) {
+    buf = new ByteBuffer$1(toUint8Array(buf));
+    const footer = Footer.getRootAsFooter(buf);
+    const schema = Schema2.decode(footer.schema(), /* @__PURE__ */ new Map(), footer.version());
+    return new OffHeapFooter(schema, footer);
+  }
+  /** @nocollapse */
+  static encode(footer) {
+    const b2 = new Builder$1();
+    const schemaOffset = Schema2.encode(b2, footer.schema);
+    Footer.startRecordBatchesVector(b2, footer.numRecordBatches);
+    for (const rb2 of [...footer.recordBatches()].slice().reverse()) {
+      FileBlock.encode(b2, rb2);
+    }
+    const recordBatchesOffset = b2.endVector();
+    Footer.startDictionariesVector(b2, footer.numDictionaries);
+    for (const db2 of [...footer.dictionaryBatches()].slice().reverse()) {
+      FileBlock.encode(b2, db2);
+    }
+    const dictionaryBatchesOffset = b2.endVector();
+    Footer.startFooter(b2);
+    Footer.addSchema(b2, schemaOffset);
+    Footer.addVersion(b2, MetadataVersion.V5);
+    Footer.addRecordBatches(b2, recordBatchesOffset);
+    Footer.addDictionaries(b2, dictionaryBatchesOffset);
+    Footer.finishFooterBuffer(b2, Footer.endFooter(b2));
+    return b2.asUint8Array();
+  }
+  get numRecordBatches() {
+    return this._recordBatches.length;
+  }
+  get numDictionaries() {
+    return this._dictionaryBatches.length;
+  }
+  constructor(schema, version2 = MetadataVersion.V5, recordBatches, dictionaryBatches) {
+    this.schema = schema;
+    this.version = version2;
+    recordBatches && (this._recordBatches = recordBatches);
+    dictionaryBatches && (this._dictionaryBatches = dictionaryBatches);
+  }
+  *recordBatches() {
+    for (let block, i2 = -1, n2 = this.numRecordBatches; ++i2 < n2; ) {
+      if (block = this.getRecordBatch(i2)) {
+        yield block;
+      }
+    }
+  }
+  *dictionaryBatches() {
+    for (let block, i2 = -1, n2 = this.numDictionaries; ++i2 < n2; ) {
+      if (block = this.getDictionaryBatch(i2)) {
+        yield block;
+      }
+    }
+  }
+  getRecordBatch(index) {
+    return index >= 0 && index < this.numRecordBatches && this._recordBatches[index] || null;
+  }
+  getDictionaryBatch(index) {
+    return index >= 0 && index < this.numDictionaries && this._dictionaryBatches[index] || null;
+  }
+}
+class OffHeapFooter extends Footer_ {
+  get numRecordBatches() {
+    return this._footer.recordBatchesLength();
+  }
+  get numDictionaries() {
+    return this._footer.dictionariesLength();
+  }
+  constructor(schema, _footer) {
+    super(schema, _footer.version());
+    this._footer = _footer;
+  }
+  getRecordBatch(index) {
+    if (index >= 0 && index < this.numRecordBatches) {
+      const fileBlock = this._footer.recordBatches(index);
+      if (fileBlock) {
+        return FileBlock.decode(fileBlock);
+      }
+    }
+    return null;
+  }
+  getDictionaryBatch(index) {
+    if (index >= 0 && index < this.numDictionaries) {
+      const fileBlock = this._footer.dictionaries(index);
+      if (fileBlock) {
+        return FileBlock.decode(fileBlock);
+      }
+    }
+    return null;
+  }
+}
+class FileBlock {
+  /** @nocollapse */
+  static decode(block) {
+    return new FileBlock(block.metaDataLength(), block.bodyLength(), block.offset());
+  }
+  /** @nocollapse */
+  static encode(b2, fileBlock) {
+    const { metaDataLength } = fileBlock;
+    const offset = BigInt(fileBlock.offset);
+    const bodyLength = BigInt(fileBlock.bodyLength);
+    return Block.createBlock(b2, offset, metaDataLength, bodyLength);
+  }
+  constructor(metaDataLength, bodyLength, offset) {
+    this.metaDataLength = metaDataLength;
+    this.offset = bigIntToNumber(offset);
+    this.bodyLength = bigIntToNumber(bodyLength);
+  }
+}
+let Message$1 = class Message {
+  constructor() {
+    this.bb = null;
+    this.bb_pos = 0;
+  }
+  __init(i2, bb2) {
+    this.bb_pos = i2;
+    this.bb = bb2;
+    return this;
+  }
+  static getRootAsMessage(bb2, obj) {
+    return (obj || new Message()).__init(bb2.readInt32(bb2.position()) + bb2.position(), bb2);
+  }
+  static getSizePrefixedRootAsMessage(bb2, obj) {
+    bb2.setPosition(bb2.position() + SIZE_PREFIX_LENGTH);
+    return (obj || new Message()).__init(bb2.readInt32(bb2.position()) + bb2.position(), bb2);
+  }
+  version() {
+    const offset = this.bb.__offset(this.bb_pos, 4);
+    return offset ? this.bb.readInt16(this.bb_pos + offset) : MetadataVersion.V1;
+  }
+  headerType() {
+    const offset = this.bb.__offset(this.bb_pos, 6);
+    return offset ? this.bb.readUint8(this.bb_pos + offset) : MessageHeader.NONE;
+  }
+  header(obj) {
+    const offset = this.bb.__offset(this.bb_pos, 8);
+    return offset ? this.bb.__union(obj, this.bb_pos + offset) : null;
+  }
+  bodyLength() {
+    const offset = this.bb.__offset(this.bb_pos, 10);
+    return offset ? this.bb.readInt64(this.bb_pos + offset) : BigInt("0");
+  }
+  customMetadata(index, obj) {
+    const offset = this.bb.__offset(this.bb_pos, 12);
+    return offset ? (obj || new KeyValue()).__init(this.bb.__indirect(this.bb.__vector(this.bb_pos + offset) + index * 4), this.bb) : null;
+  }
+  customMetadataLength() {
+    const offset = this.bb.__offset(this.bb_pos, 12);
+    return offset ? this.bb.__vector_len(this.bb_pos + offset) : 0;
+  }
+  static startMessage(builder) {
+    builder.startObject(5);
+  }
+  static addVersion(builder, version2) {
+    builder.addFieldInt16(0, version2, MetadataVersion.V1);
+  }
+  static addHeaderType(builder, headerType) {
+    builder.addFieldInt8(1, headerType, MessageHeader.NONE);
+  }
+  static addHeader(builder, headerOffset) {
+    builder.addFieldOffset(2, headerOffset, 0);
+  }
+  static addBodyLength(builder, bodyLength) {
+    builder.addFieldInt64(3, bodyLength, BigInt("0"));
+  }
+  static addCustomMetadata(builder, customMetadataOffset) {
+    builder.addFieldOffset(4, customMetadataOffset, 0);
+  }
+  static createCustomMetadataVector(builder, data) {
+    builder.startVector(4, data.length, 4);
+    for (let i2 = data.length - 1; i2 >= 0; i2--) {
+      builder.addOffset(data[i2]);
+    }
+    return builder.endVector();
+  }
+  static startCustomMetadataVector(builder, numElems) {
+    builder.startVector(4, numElems, 4);
+  }
+  static endMessage(builder) {
+    const offset = builder.endObject();
+    return offset;
+  }
+  static finishMessageBuffer(builder, offset) {
+    builder.finish(offset);
+  }
+  static finishSizePrefixedMessageBuffer(builder, offset) {
+    builder.finish(offset, void 0, true);
+  }
+  static createMessage(builder, version2, headerType, headerOffset, bodyLength, customMetadataOffset) {
+    Message.startMessage(builder);
+    Message.addVersion(builder, version2);
+    Message.addHeaderType(builder, headerType);
+    Message.addHeader(builder, headerOffset);
+    Message.addBodyLength(builder, bodyLength);
+    Message.addCustomMetadata(builder, customMetadataOffset);
+    return Message.endMessage(builder);
+  }
+};
+class TypeAssembler extends Visitor {
+  visit(node, builder) {
+    return node == null || builder == null ? void 0 : super.visit(node, builder);
+  }
+  visitNull(_node, b2) {
+    Null$1.startNull(b2);
+    return Null$1.endNull(b2);
+  }
+  visitInt(node, b2) {
+    Int.startInt(b2);
+    Int.addBitWidth(b2, node.bitWidth);
+    Int.addIsSigned(b2, node.isSigned);
+    return Int.endInt(b2);
+  }
+  visitFloat(node, b2) {
+    FloatingPoint.startFloatingPoint(b2);
+    FloatingPoint.addPrecision(b2, node.precision);
+    return FloatingPoint.endFloatingPoint(b2);
+  }
+  visitBinary(_node, b2) {
+    Binary$1.startBinary(b2);
+    return Binary$1.endBinary(b2);
+  }
+  visitLargeBinary(_node, b2) {
+    LargeBinary$1.startLargeBinary(b2);
+    return LargeBinary$1.endLargeBinary(b2);
+  }
+  visitBool(_node, b2) {
+    Bool$1.startBool(b2);
+    return Bool$1.endBool(b2);
+  }
+  visitUtf8(_node, b2) {
+    Utf8$1.startUtf8(b2);
+    return Utf8$1.endUtf8(b2);
+  }
+  visitLargeUtf8(_node, b2) {
+    LargeUtf8$1.startLargeUtf8(b2);
+    return LargeUtf8$1.endLargeUtf8(b2);
+  }
+  visitDecimal(node, b2) {
+    Decimal$1.startDecimal(b2);
+    Decimal$1.addScale(b2, node.scale);
+    Decimal$1.addPrecision(b2, node.precision);
+    Decimal$1.addBitWidth(b2, node.bitWidth);
+    return Decimal$1.endDecimal(b2);
+  }
+  visitDate(node, b2) {
+    Date$1.startDate(b2);
+    Date$1.addUnit(b2, node.unit);
+    return Date$1.endDate(b2);
+  }
+  visitTime(node, b2) {
+    Time.startTime(b2);
+    Time.addUnit(b2, node.unit);
+    Time.addBitWidth(b2, node.bitWidth);
+    return Time.endTime(b2);
+  }
+  visitTimestamp(node, b2) {
+    const timezone = node.timezone && b2.createString(node.timezone) || void 0;
+    Timestamp.startTimestamp(b2);
+    Timestamp.addUnit(b2, node.unit);
+    if (timezone !== void 0) {
+      Timestamp.addTimezone(b2, timezone);
+    }
+    return Timestamp.endTimestamp(b2);
+  }
+  visitInterval(node, b2) {
+    Interval.startInterval(b2);
+    Interval.addUnit(b2, node.unit);
+    return Interval.endInterval(b2);
+  }
+  visitDuration(node, b2) {
+    Duration$1.startDuration(b2);
+    Duration$1.addUnit(b2, node.unit);
+    return Duration$1.endDuration(b2);
+  }
+  visitList(_node, b2) {
+    List$1.startList(b2);
+    return List$1.endList(b2);
+  }
+  visitStruct(_node, b2) {
+    Struct_.startStruct_(b2);
+    return Struct_.endStruct_(b2);
+  }
+  visitUnion(node, b2) {
+    Union.startTypeIdsVector(b2, node.typeIds.length);
+    const typeIds = Union.createTypeIdsVector(b2, node.typeIds);
+    Union.startUnion(b2);
+    Union.addMode(b2, node.mode);
+    Union.addTypeIds(b2, typeIds);
+    return Union.endUnion(b2);
+  }
+  visitDictionary(node, b2) {
+    const indexType = this.visit(node.indices, b2);
+    DictionaryEncoding.startDictionaryEncoding(b2);
+    DictionaryEncoding.addId(b2, BigInt(node.id));
+    DictionaryEncoding.addIsOrdered(b2, node.isOrdered);
+    if (indexType !== void 0) {
+      DictionaryEncoding.addIndexType(b2, indexType);
+    }
+    return DictionaryEncoding.endDictionaryEncoding(b2);
+  }
+  visitFixedSizeBinary(node, b2) {
+    FixedSizeBinary$1.startFixedSizeBinary(b2);
+    FixedSizeBinary$1.addByteWidth(b2, node.byteWidth);
+    return FixedSizeBinary$1.endFixedSizeBinary(b2);
+  }
+  visitFixedSizeList(node, b2) {
+    FixedSizeList$1.startFixedSizeList(b2);
+    FixedSizeList$1.addListSize(b2, node.listSize);
+    return FixedSizeList$1.endFixedSizeList(b2);
+  }
+  visitMap(node, b2) {
+    Map$1.startMap(b2);
+    Map$1.addKeysSorted(b2, node.keysSorted);
+    return Map$1.endMap(b2);
+  }
+}
+const instance$1 = new TypeAssembler();
+function schemaFromJSON(_schema, dictionaries = /* @__PURE__ */ new Map()) {
+  return new Schema2(schemaFieldsFromJSON(_schema, dictionaries), customMetadataFromJSON(_schema["metadata"]), dictionaries);
+}
+function recordBatchFromJSON(b2) {
+  return new RecordBatch$1(b2["count"], fieldNodesFromJSON(b2["columns"]), buffersFromJSON(b2["columns"]), null);
+}
+function dictionaryBatchFromJSON(b2) {
+  return new DictionaryBatch2(recordBatchFromJSON(b2["data"]), b2["id"], b2["isDelta"]);
+}
+function schemaFieldsFromJSON(_schema, dictionaries) {
+  return (_schema["fields"] || []).filter(Boolean).map((f2) => Field2.fromJSON(f2, dictionaries));
+}
+function fieldChildrenFromJSON(_field, dictionaries) {
+  return (_field["children"] || []).filter(Boolean).map((f2) => Field2.fromJSON(f2, dictionaries));
+}
+function fieldNodesFromJSON(xs) {
+  return (xs || []).reduce((fieldNodes, column) => [
+    ...fieldNodes,
+    new FieldNode2(column["count"], nullCountFromJSON(column["VALIDITY"])),
+    ...fieldNodesFromJSON(column["children"])
+  ], []);
+}
+function buffersFromJSON(xs, buffers = []) {
+  for (let i2 = -1, n2 = (xs || []).length; ++i2 < n2; ) {
+    const column = xs[i2];
+    column["VALIDITY"] && buffers.push(new BufferRegion(buffers.length, column["VALIDITY"].length));
+    column["TYPE_ID"] && buffers.push(new BufferRegion(buffers.length, column["TYPE_ID"].length));
+    column["OFFSET"] && buffers.push(new BufferRegion(buffers.length, column["OFFSET"].length));
+    column["DATA"] && buffers.push(new BufferRegion(buffers.length, column["DATA"].length));
+    buffers = buffersFromJSON(column["children"], buffers);
+  }
+  return buffers;
+}
+function nullCountFromJSON(validity) {
+  return (validity || []).reduce((sum, val) => sum + +(val === 0), 0);
+}
+function fieldFromJSON(_field, dictionaries) {
+  let id2;
+  let keys;
+  let field;
+  let dictMeta;
+  let type;
+  let dictType;
+  if (!dictionaries || !(dictMeta = _field["dictionary"])) {
+    type = typeFromJSON(_field, fieldChildrenFromJSON(_field, dictionaries));
+    field = new Field2(_field["name"], type, _field["nullable"], customMetadataFromJSON(_field["metadata"]));
+  } else if (!dictionaries.has(id2 = dictMeta["id"])) {
+    keys = (keys = dictMeta["indexType"]) ? indexTypeFromJSON(keys) : new Int32();
+    dictionaries.set(id2, type = typeFromJSON(_field, fieldChildrenFromJSON(_field, dictionaries)));
+    dictType = new Dictionary(type, keys, id2, dictMeta["isOrdered"]);
+    field = new Field2(_field["name"], dictType, _field["nullable"], customMetadataFromJSON(_field["metadata"]));
+  } else {
+    keys = (keys = dictMeta["indexType"]) ? indexTypeFromJSON(keys) : new Int32();
+    dictType = new Dictionary(dictionaries.get(id2), keys, id2, dictMeta["isOrdered"]);
+    field = new Field2(_field["name"], dictType, _field["nullable"], customMetadataFromJSON(_field["metadata"]));
+  }
+  return field || null;
+}
+function customMetadataFromJSON(metadata = []) {
+  return new Map(metadata.map(({ key, value }) => [key, value]));
+}
+function indexTypeFromJSON(_type) {
+  return new Int_(_type["isSigned"], _type["bitWidth"]);
+}
+function typeFromJSON(f2, children) {
+  const typeId = f2["type"]["name"];
+  switch (typeId) {
+    case "NONE":
+      return new Null2();
+    case "null":
+      return new Null2();
+    case "binary":
+      return new Binary2();
+    case "largebinary":
+      return new LargeBinary2();
+    case "utf8":
+      return new Utf82();
+    case "largeutf8":
+      return new LargeUtf82();
+    case "bool":
+      return new Bool2();
+    case "list":
+      return new List2((children || [])[0]);
+    case "struct":
+      return new Struct(children || []);
+    case "struct_":
+      return new Struct(children || []);
+  }
+  switch (typeId) {
+    case "int": {
+      const t2 = f2["type"];
+      return new Int_(t2["isSigned"], t2["bitWidth"]);
+    }
+    case "floatingpoint": {
+      const t2 = f2["type"];
+      return new Float(Precision[t2["precision"]]);
+    }
+    case "decimal": {
+      const t2 = f2["type"];
+      return new Decimal2(t2["scale"], t2["precision"], t2["bitWidth"]);
+    }
+    case "date": {
+      const t2 = f2["type"];
+      return new Date_(DateUnit[t2["unit"]]);
+    }
+    case "time": {
+      const t2 = f2["type"];
+      return new Time_(TimeUnit[t2["unit"]], t2["bitWidth"]);
+    }
+    case "timestamp": {
+      const t2 = f2["type"];
+      return new Timestamp_(TimeUnit[t2["unit"]], t2["timezone"]);
+    }
+    case "interval": {
+      const t2 = f2["type"];
+      return new Interval_(IntervalUnit[t2["unit"]]);
+    }
+    case "duration": {
+      const t2 = f2["type"];
+      return new Duration2(TimeUnit[t2["unit"]]);
+    }
+    case "union": {
+      const t2 = f2["type"];
+      const [m2, ...ms] = (t2["mode"] + "").toLowerCase();
+      const mode = m2.toUpperCase() + ms.join("");
+      return new Union_(UnionMode[mode], t2["typeIds"] || [], children || []);
+    }
+    case "fixedsizebinary": {
+      const t2 = f2["type"];
+      return new FixedSizeBinary2(t2["byteWidth"]);
+    }
+    case "fixedsizelist": {
+      const t2 = f2["type"];
+      return new FixedSizeList2(t2["listSize"], (children || [])[0]);
+    }
+    case "map": {
+      const t2 = f2["type"];
+      return new Map_((children || [])[0], t2["keysSorted"]);
+    }
+  }
+  throw new Error(`Unrecognized type: "${typeId}"`);
+}
+var Builder2 = Builder$2;
+var ByteBuffer2 = ByteBuffer$2;
+class Message2 {
+  /** @nocollapse */
+  static fromJSON(msg, headerType) {
+    const message2 = new Message2(0, MetadataVersion.V5, headerType);
+    message2._createHeader = messageHeaderFromJSON(msg, headerType);
+    return message2;
+  }
+  /** @nocollapse */
+  static decode(buf) {
+    buf = new ByteBuffer2(toUint8Array(buf));
+    const _message = Message$1.getRootAsMessage(buf);
+    const bodyLength = _message.bodyLength();
+    const version2 = _message.version();
+    const headerType = _message.headerType();
+    const message2 = new Message2(bodyLength, version2, headerType);
+    message2._createHeader = decodeMessageHeader(_message, headerType);
+    return message2;
+  }
+  /** @nocollapse */
+  static encode(message2) {
+    const b2 = new Builder2();
+    let headerOffset = -1;
+    if (message2.isSchema()) {
+      headerOffset = Schema2.encode(b2, message2.header());
+    } else if (message2.isRecordBatch()) {
+      headerOffset = RecordBatch$1.encode(b2, message2.header());
+    } else if (message2.isDictionaryBatch()) {
+      headerOffset = DictionaryBatch2.encode(b2, message2.header());
+    }
+    Message$1.startMessage(b2);
+    Message$1.addVersion(b2, MetadataVersion.V5);
+    Message$1.addHeader(b2, headerOffset);
+    Message$1.addHeaderType(b2, message2.headerType);
+    Message$1.addBodyLength(b2, BigInt(message2.bodyLength));
+    Message$1.finishMessageBuffer(b2, Message$1.endMessage(b2));
+    return b2.asUint8Array();
+  }
+  /** @nocollapse */
+  static from(header, bodyLength = 0) {
+    if (header instanceof Schema2) {
+      return new Message2(0, MetadataVersion.V5, MessageHeader.Schema, header);
+    }
+    if (header instanceof RecordBatch$1) {
+      return new Message2(bodyLength, MetadataVersion.V5, MessageHeader.RecordBatch, header);
+    }
+    if (header instanceof DictionaryBatch2) {
+      return new Message2(bodyLength, MetadataVersion.V5, MessageHeader.DictionaryBatch, header);
+    }
+    throw new Error(`Unrecognized Message header: ${header}`);
+  }
+  get type() {
+    return this.headerType;
+  }
+  get version() {
+    return this._version;
+  }
+  get headerType() {
+    return this._headerType;
+  }
+  get compression() {
+    return this._compression;
+  }
+  get bodyLength() {
+    return this._bodyLength;
+  }
+  header() {
+    return this._createHeader();
+  }
+  isSchema() {
+    return this.headerType === MessageHeader.Schema;
+  }
+  isRecordBatch() {
+    return this.headerType === MessageHeader.RecordBatch;
+  }
+  isDictionaryBatch() {
+    return this.headerType === MessageHeader.DictionaryBatch;
+  }
+  constructor(bodyLength, version2, headerType, header) {
+    this._version = version2;
+    this._headerType = headerType;
+    this.body = new Uint8Array(0);
+    this._compression = header === null || header === void 0 ? void 0 : header.compression;
+    header && (this._createHeader = () => header);
+    this._bodyLength = bigIntToNumber(bodyLength);
+  }
+}
+let RecordBatch$1 = class RecordBatch2 {
+  get nodes() {
+    return this._nodes;
+  }
+  get length() {
+    return this._length;
+  }
+  get buffers() {
+    return this._buffers;
+  }
+  get compression() {
+    return this._compression;
+  }
+  constructor(length2, nodes, buffers, compression) {
+    this._nodes = nodes;
+    this._buffers = buffers;
+    this._length = bigIntToNumber(length2);
+    this._compression = compression;
+  }
+};
+class DictionaryBatch2 {
+  get id() {
+    return this._id;
+  }
+  get data() {
+    return this._data;
+  }
+  get isDelta() {
+    return this._isDelta;
+  }
+  get length() {
+    return this.data.length;
+  }
+  get nodes() {
+    return this.data.nodes;
+  }
+  get buffers() {
+    return this.data.buffers;
+  }
+  constructor(data, id2, isDelta = false) {
+    this._data = data;
+    this._isDelta = isDelta;
+    this._id = bigIntToNumber(id2);
+  }
+}
+class BufferRegion {
+  constructor(offset, length2) {
+    this.offset = bigIntToNumber(offset);
+    this.length = bigIntToNumber(length2);
+  }
+}
+class FieldNode2 {
+  constructor(length2, nullCount) {
+    this.length = bigIntToNumber(length2);
+    this.nullCount = bigIntToNumber(nullCount);
+  }
+}
+class BodyCompression2 {
+  constructor(type, method = BodyCompressionMethod.BUFFER) {
+    this.type = type;
+    this.method = method;
+  }
+}
+function messageHeaderFromJSON(message2, type) {
+  return () => {
+    switch (type) {
+      case MessageHeader.Schema:
+        return Schema2.fromJSON(message2);
+      case MessageHeader.RecordBatch:
+        return RecordBatch$1.fromJSON(message2);
+      case MessageHeader.DictionaryBatch:
+        return DictionaryBatch2.fromJSON(message2);
+    }
+    throw new Error(`Unrecognized Message type: { name: ${MessageHeader[type]}, type: ${type} }`);
+  };
+}
+function decodeMessageHeader(message2, type) {
+  return () => {
+    switch (type) {
+      case MessageHeader.Schema:
+        return Schema2.decode(message2.header(new Schema$1()), /* @__PURE__ */ new Map(), message2.version());
+      case MessageHeader.RecordBatch:
+        return RecordBatch$1.decode(message2.header(new RecordBatch$2()), message2.version());
+      case MessageHeader.DictionaryBatch:
+        return DictionaryBatch2.decode(message2.header(new DictionaryBatch$1()), message2.version());
+    }
+    throw new Error(`Unrecognized Message type: { name: ${MessageHeader[type]}, type: ${type} }`);
+  };
+}
+Field2["encode"] = encodeField;
+Field2["decode"] = decodeField;
+Field2["fromJSON"] = fieldFromJSON;
+Schema2["encode"] = encodeSchema;
+Schema2["decode"] = decodeSchema;
+Schema2["fromJSON"] = schemaFromJSON;
+RecordBatch$1["encode"] = encodeRecordBatch;
+RecordBatch$1["decode"] = decodeRecordBatch;
+RecordBatch$1["fromJSON"] = recordBatchFromJSON;
+DictionaryBatch2["encode"] = encodeDictionaryBatch;
+DictionaryBatch2["decode"] = decodeDictionaryBatch;
+DictionaryBatch2["fromJSON"] = dictionaryBatchFromJSON;
+FieldNode2["encode"] = encodeFieldNode;
+FieldNode2["decode"] = decodeFieldNode;
+BufferRegion["encode"] = encodeBufferRegion;
+BufferRegion["decode"] = decodeBufferRegion;
+BodyCompression2["encode"] = encodeBodyCompression;
+BodyCompression2["decode"] = decodeBodyCompression;
+function decodeSchema(_schema, dictionaries = /* @__PURE__ */ new Map(), version2 = MetadataVersion.V5) {
+  const fields = decodeSchemaFields(_schema, dictionaries);
+  return new Schema2(fields, decodeCustomMetadata(_schema), dictionaries, version2);
+}
+function decodeRecordBatch(batch, version2 = MetadataVersion.V5) {
+  const recordBatch = new RecordBatch$1(batch.length(), decodeFieldNodes(batch), decodeBuffers(batch, version2), decodeBodyCompression(batch.compression()));
+  return recordBatch;
+}
+function decodeDictionaryBatch(batch, version2 = MetadataVersion.V5) {
+  return new DictionaryBatch2(RecordBatch$1.decode(batch.data(), version2), batch.id(), batch.isDelta());
+}
+function decodeBufferRegion(b2) {
+  return new BufferRegion(b2.offset(), b2.length());
+}
+function decodeFieldNode(f2) {
+  return new FieldNode2(f2.length(), f2.nullCount());
+}
+function decodeFieldNodes(batch) {
+  const nodes = [];
+  for (let f2, i2 = -1, j2 = -1, n2 = batch.nodesLength(); ++i2 < n2; ) {
+    if (f2 = batch.nodes(i2)) {
+      nodes[++j2] = FieldNode2.decode(f2);
+    }
+  }
+  return nodes;
+}
+function decodeBuffers(batch, version2) {
+  const bufferRegions = [];
+  for (let b2, i2 = -1, j2 = -1, n2 = batch.buffersLength(); ++i2 < n2; ) {
+    if (b2 = batch.buffers(i2)) {
+      if (version2 < MetadataVersion.V4) {
+        b2.bb_pos += 8 * (i2 + 1);
+      }
+      bufferRegions[++j2] = BufferRegion.decode(b2);
+    }
+  }
+  return bufferRegions;
+}
+function decodeSchemaFields(schema, dictionaries) {
+  const fields = [];
+  for (let f2, i2 = -1, j2 = -1, n2 = schema.fieldsLength(); ++i2 < n2; ) {
+    if (f2 = schema.fields(i2)) {
+      fields[++j2] = Field2.decode(f2, dictionaries);
+    }
+  }
+  return fields;
+}
+function decodeFieldChildren(field, dictionaries) {
+  const children = [];
+  for (let f2, i2 = -1, j2 = -1, n2 = field.childrenLength(); ++i2 < n2; ) {
+    if (f2 = field.children(i2)) {
+      children[++j2] = Field2.decode(f2, dictionaries);
+    }
+  }
+  return children;
+}
+function decodeField(f2, dictionaries) {
+  let id2;
+  let field;
+  let type;
+  let keys;
+  let dictType;
+  let dictMeta;
+  if (!dictionaries || !(dictMeta = f2.dictionary())) {
+    type = decodeFieldType(f2, decodeFieldChildren(f2, dictionaries));
+    field = new Field2(f2.name(), type, f2.nullable(), decodeCustomMetadata(f2));
+  } else if (!dictionaries.has(id2 = bigIntToNumber(dictMeta.id()))) {
+    keys = (keys = dictMeta.indexType()) ? decodeIndexType(keys) : new Int32();
+    dictionaries.set(id2, type = decodeFieldType(f2, decodeFieldChildren(f2, dictionaries)));
+    dictType = new Dictionary(type, keys, id2, dictMeta.isOrdered());
+    field = new Field2(f2.name(), dictType, f2.nullable(), decodeCustomMetadata(f2));
+  } else {
+    keys = (keys = dictMeta.indexType()) ? decodeIndexType(keys) : new Int32();
+    dictType = new Dictionary(dictionaries.get(id2), keys, id2, dictMeta.isOrdered());
+    field = new Field2(f2.name(), dictType, f2.nullable(), decodeCustomMetadata(f2));
+  }
+  return field || null;
+}
+function decodeCustomMetadata(parent) {
+  const data = /* @__PURE__ */ new Map();
+  if (parent) {
+    for (let entry, key, i2 = -1, n2 = Math.trunc(parent.customMetadataLength()); ++i2 < n2; ) {
+      if ((entry = parent.customMetadata(i2)) && (key = entry.key()) != null) {
+        data.set(key, entry.value());
+      }
+    }
+  }
+  return data;
+}
+function decodeIndexType(_type) {
+  return new Int_(_type.isSigned(), _type.bitWidth());
+}
+function decodeFieldType(f2, children) {
+  const typeId = f2.typeType();
+  switch (typeId) {
+    case Type$1["NONE"]:
+      return new Null2();
+    case Type$1["Null"]:
+      return new Null2();
+    case Type$1["Binary"]:
+      return new Binary2();
+    case Type$1["LargeBinary"]:
+      return new LargeBinary2();
+    case Type$1["Utf8"]:
+      return new Utf82();
+    case Type$1["LargeUtf8"]:
+      return new LargeUtf82();
+    case Type$1["Bool"]:
+      return new Bool2();
+    case Type$1["List"]:
+      return new List2((children || [])[0]);
+    case Type$1["Struct_"]:
+      return new Struct(children || []);
+  }
+  switch (typeId) {
+    case Type$1["Int"]: {
+      const t2 = f2.type(new Int());
+      return new Int_(t2.isSigned(), t2.bitWidth());
+    }
+    case Type$1["FloatingPoint"]: {
+      const t2 = f2.type(new FloatingPoint());
+      return new Float(t2.precision());
+    }
+    case Type$1["Decimal"]: {
+      const t2 = f2.type(new Decimal$1());
+      return new Decimal2(t2.scale(), t2.precision(), t2.bitWidth());
+    }
+    case Type$1["Date"]: {
+      const t2 = f2.type(new Date$1());
+      return new Date_(t2.unit());
+    }
+    case Type$1["Time"]: {
+      const t2 = f2.type(new Time());
+      return new Time_(t2.unit(), t2.bitWidth());
+    }
+    case Type$1["Timestamp"]: {
+      const t2 = f2.type(new Timestamp());
+      return new Timestamp_(t2.unit(), t2.timezone());
+    }
+    case Type$1["Interval"]: {
+      const t2 = f2.type(new Interval());
+      return new Interval_(t2.unit());
+    }
+    case Type$1["Duration"]: {
+      const t2 = f2.type(new Duration$1());
+      return new Duration2(t2.unit());
+    }
+    case Type$1["Union"]: {
+      const t2 = f2.type(new Union());
+      return new Union_(t2.mode(), t2.typeIdsArray() || [], children || []);
+    }
+    case Type$1["FixedSizeBinary"]: {
+      const t2 = f2.type(new FixedSizeBinary$1());
+      return new FixedSizeBinary2(t2.byteWidth());
+    }
+    case Type$1["FixedSizeList"]: {
+      const t2 = f2.type(new FixedSizeList$1());
+      return new FixedSizeList2(t2.listSize(), (children || [])[0]);
+    }
+    case Type$1["Map"]: {
+      const t2 = f2.type(new Map$1());
+      return new Map_((children || [])[0], t2.keysSorted());
+    }
+  }
+  throw new Error(`Unrecognized type: "${Type$1[typeId]}" (${typeId})`);
+}
+function decodeBodyCompression(b2) {
+  return b2 ? new BodyCompression2(b2.codec(), b2.method()) : null;
+}
+function encodeSchema(b2, schema) {
+  const fieldOffsets = schema.fields.map((f2) => Field2.encode(b2, f2));
+  Schema$1.startFieldsVector(b2, fieldOffsets.length);
+  const fieldsVectorOffset = Schema$1.createFieldsVector(b2, fieldOffsets);
+  const metadataOffset = !(schema.metadata && schema.metadata.size > 0) ? -1 : Schema$1.createCustomMetadataVector(b2, [...schema.metadata].map(([k2, v2]) => {
+    const key = b2.createString(`${k2}`);
+    const val = b2.createString(`${v2}`);
+    KeyValue.startKeyValue(b2);
+    KeyValue.addKey(b2, key);
+    KeyValue.addValue(b2, val);
+    return KeyValue.endKeyValue(b2);
+  }));
+  Schema$1.startSchema(b2);
+  Schema$1.addFields(b2, fieldsVectorOffset);
+  Schema$1.addEndianness(b2, platformIsLittleEndian ? Endianness.Little : Endianness.Big);
+  if (metadataOffset !== -1) {
+    Schema$1.addCustomMetadata(b2, metadataOffset);
+  }
+  return Schema$1.endSchema(b2);
+}
+function encodeField(b2, field) {
+  let nameOffset = -1;
+  let typeOffset = -1;
+  let dictionaryOffset = -1;
+  const type = field.type;
+  let typeId = field.typeId;
+  if (!DataType.isDictionary(type)) {
+    typeOffset = instance$1.visit(type, b2);
+  } else {
+    typeId = type.dictionary.typeId;
+    dictionaryOffset = instance$1.visit(type, b2);
+    typeOffset = instance$1.visit(type.dictionary, b2);
+  }
+  const childOffsets = (type.children || []).map((f2) => Field2.encode(b2, f2));
+  const childrenVectorOffset = Field$1.createChildrenVector(b2, childOffsets);
+  const metadataOffset = !(field.metadata && field.metadata.size > 0) ? -1 : Field$1.createCustomMetadataVector(b2, [...field.metadata].map(([k2, v2]) => {
+    const key = b2.createString(`${k2}`);
+    const val = b2.createString(`${v2}`);
+    KeyValue.startKeyValue(b2);
+    KeyValue.addKey(b2, key);
+    KeyValue.addValue(b2, val);
+    return KeyValue.endKeyValue(b2);
+  }));
+  if (field.name) {
+    nameOffset = b2.createString(field.name);
+  }
+  Field$1.startField(b2);
+  Field$1.addType(b2, typeOffset);
+  Field$1.addTypeType(b2, typeId);
+  Field$1.addChildren(b2, childrenVectorOffset);
+  Field$1.addNullable(b2, !!field.nullable);
+  if (nameOffset !== -1) {
+    Field$1.addName(b2, nameOffset);
+  }
+  if (dictionaryOffset !== -1) {
+    Field$1.addDictionary(b2, dictionaryOffset);
+  }
+  if (metadataOffset !== -1) {
+    Field$1.addCustomMetadata(b2, metadataOffset);
+  }
+  return Field$1.endField(b2);
+}
+function encodeRecordBatch(b2, recordBatch) {
+  const nodes = recordBatch.nodes || [];
+  const buffers = recordBatch.buffers || [];
+  RecordBatch$2.startNodesVector(b2, nodes.length);
+  for (const n2 of nodes.slice().reverse())
+    FieldNode2.encode(b2, n2);
+  const nodesVectorOffset = b2.endVector();
+  RecordBatch$2.startBuffersVector(b2, buffers.length);
+  for (const b_ of buffers.slice().reverse())
+    BufferRegion.encode(b2, b_);
+  const buffersVectorOffset = b2.endVector();
+  let bodyCompressionOffset = null;
+  if (recordBatch.compression !== null) {
+    bodyCompressionOffset = encodeBodyCompression(b2, recordBatch.compression);
+  }
+  RecordBatch$2.startRecordBatch(b2);
+  RecordBatch$2.addLength(b2, BigInt(recordBatch.length));
+  RecordBatch$2.addNodes(b2, nodesVectorOffset);
+  RecordBatch$2.addBuffers(b2, buffersVectorOffset);
+  if (recordBatch.compression !== null && bodyCompressionOffset) {
+    RecordBatch$2.addCompression(b2, bodyCompressionOffset);
+  }
+  return RecordBatch$2.endRecordBatch(b2);
+}
+function encodeBodyCompression(b2, node) {
+  BodyCompression$1.startBodyCompression(b2);
+  BodyCompression$1.addCodec(b2, node.type);
+  BodyCompression$1.addMethod(b2, node.method);
+  return BodyCompression$1.endBodyCompression(b2);
+}
+function encodeDictionaryBatch(b2, dictionaryBatch) {
+  const dataOffset = RecordBatch$1.encode(b2, dictionaryBatch.data);
+  DictionaryBatch$1.startDictionaryBatch(b2);
+  DictionaryBatch$1.addId(b2, BigInt(dictionaryBatch.id));
+  DictionaryBatch$1.addIsDelta(b2, dictionaryBatch.isDelta);
+  DictionaryBatch$1.addData(b2, dataOffset);
+  return DictionaryBatch$1.endDictionaryBatch(b2);
+}
+function encodeFieldNode(b2, node) {
+  return FieldNode$1.createFieldNode(b2, BigInt(node.length), BigInt(node.nullCount));
+}
+function encodeBufferRegion(b2, node) {
+  return Buffer$2.createBuffer(b2, BigInt(node.offset), BigInt(node.length));
+}
+const platformIsLittleEndian = (() => {
+  const buffer = new ArrayBuffer(2);
+  new DataView(buffer).setInt16(
+    0,
+    256,
+    true
+    /* littleEndian */
+  );
+  return new Int16Array(buffer)[0] === 256;
+})();
+const ITERATOR_DONE = Object.freeze({ done: true, value: void 0 });
+class ArrowJSON {
+  constructor(_json) {
+    this._json = _json;
+  }
+  get schema() {
+    return this._json["schema"];
+  }
+  get batches() {
+    return this._json["batches"] || [];
+  }
+  get dictionaries() {
+    return this._json["dictionaries"] || [];
+  }
+}
+class ReadableInterop {
+  tee() {
+    return this._getDOMStream().tee();
+  }
+  pipe(writable, options) {
+    return this._getNodeStream().pipe(writable, options);
+  }
+  pipeTo(writable, options) {
+    return this._getDOMStream().pipeTo(writable, options);
+  }
+  pipeThrough(duplex, options) {
+    return this._getDOMStream().pipeThrough(duplex, options);
+  }
+  _getDOMStream() {
+    return this._DOMStream || (this._DOMStream = this.toDOMStream());
+  }
+  _getNodeStream() {
+    return this._nodeStream || (this._nodeStream = this.toNodeStream());
+  }
+}
+class AsyncQueue extends ReadableInterop {
+  constructor() {
+    super();
+    this._values = [];
+    this.resolvers = [];
+    this._closedPromise = new Promise((r2) => this._closedPromiseResolve = r2);
+  }
+  get closed() {
+    return this._closedPromise;
+  }
+  cancel(reason) {
+    return __awaiter(this, void 0, void 0, function* () {
+      yield this.return(reason);
+    });
+  }
+  write(value) {
+    if (this._ensureOpen()) {
+      this.resolvers.length <= 0 ? this._values.push(value) : this.resolvers.shift().resolve({ done: false, value });
+    }
+  }
+  abort(value) {
+    if (this._closedPromiseResolve) {
+      this.resolvers.length <= 0 ? this._error = { error: value } : this.resolvers.shift().reject({ done: true, value });
+    }
+  }
+  close() {
+    if (this._closedPromiseResolve) {
+      const { resolvers } = this;
+      while (resolvers.length > 0) {
+        resolvers.shift().resolve(ITERATOR_DONE);
+      }
+      this._closedPromiseResolve();
+      this._closedPromiseResolve = void 0;
+    }
+  }
+  [Symbol.asyncIterator]() {
+    return this;
+  }
+  toDOMStream(options) {
+    return streamAdapters.toDOMStream(this._closedPromiseResolve || this._error ? this : this._values, options);
+  }
+  toNodeStream(options) {
+    return streamAdapters.toNodeStream(this._closedPromiseResolve || this._error ? this : this._values, options);
+  }
+  throw(_2) {
+    return __awaiter(this, void 0, void 0, function* () {
+      yield this.abort(_2);
+      return ITERATOR_DONE;
+    });
+  }
+  return(_2) {
+    return __awaiter(this, void 0, void 0, function* () {
+      yield this.close();
+      return ITERATOR_DONE;
+    });
+  }
+  read(size) {
+    return __awaiter(this, void 0, void 0, function* () {
+      return (yield this.next(size, "read")).value;
+    });
+  }
+  peek(size) {
+    return __awaiter(this, void 0, void 0, function* () {
+      return (yield this.next(size, "peek")).value;
+    });
+  }
+  next(..._args) {
+    if (this._values.length > 0) {
+      return Promise.resolve({ done: false, value: this._values.shift() });
+    } else if (this._error) {
+      return Promise.reject({ done: true, value: this._error.error });
+    } else if (!this._closedPromiseResolve) {
+      return Promise.resolve(ITERATOR_DONE);
+    } else {
+      return new Promise((resolve, reject) => {
+        this.resolvers.push({ resolve, reject });
+      });
+    }
+  }
+  _ensureOpen() {
+    if (this._closedPromiseResolve) {
+      return true;
+    }
+    throw new Error(`AsyncQueue is closed`);
+  }
+}
+class AsyncByteQueue extends AsyncQueue {
+  write(value) {
+    if ((value = toUint8Array(value)).byteLength > 0) {
+      return super.write(value);
+    }
+  }
+  toString(sync = false) {
+    return sync ? decodeUtf8(this.toUint8Array(true)) : this.toUint8Array(false).then(decodeUtf8);
+  }
+  toUint8Array(sync = false) {
+    return sync ? joinUint8Arrays(this._values)[0] : (() => __awaiter(this, void 0, void 0, function* () {
+      var _a3, e_1, _b3, _c3;
+      const buffers = [];
+      let byteLength = 0;
+      try {
+        for (var _d2 = true, _e2 = __asyncValues(this), _f2; _f2 = yield _e2.next(), _a3 = _f2.done, !_a3; _d2 = true) {
+          _c3 = _f2.value;
+          _d2 = false;
+          const chunk = _c3;
+          buffers.push(chunk);
+          byteLength += chunk.byteLength;
+        }
+      } catch (e_1_1) {
+        e_1 = { error: e_1_1 };
+      } finally {
+        try {
+          if (!_d2 && !_a3 && (_b3 = _e2.return)) yield _b3.call(_e2);
+        } finally {
+          if (e_1) throw e_1.error;
+        }
+      }
+      return joinUint8Arrays(buffers, byteLength)[0];
+    }))();
+  }
+}
+class ByteStream {
+  constructor(source2) {
+    if (source2) {
+      this.source = new ByteStreamSource(streamAdapters.fromIterable(source2));
+    }
+  }
+  [Symbol.iterator]() {
+    return this;
+  }
+  next(value) {
+    return this.source.next(value);
+  }
+  throw(value) {
+    return this.source.throw(value);
+  }
+  return(value) {
+    return this.source.return(value);
+  }
+  peek(size) {
+    return this.source.peek(size);
+  }
+  read(size) {
+    return this.source.read(size);
+  }
+}
+class AsyncByteStream {
+  constructor(source2) {
+    if (source2 instanceof AsyncByteStream) {
+      this.source = source2.source;
+    } else if (source2 instanceof AsyncByteQueue) {
+      this.source = new AsyncByteStreamSource(streamAdapters.fromAsyncIterable(source2));
+    } else if (isReadableNodeStream$1(source2)) {
+      this.source = new AsyncByteStreamSource(streamAdapters.fromNodeStream(source2));
+    } else if (isReadableDOMStream$1(source2)) {
+      this.source = new AsyncByteStreamSource(streamAdapters.fromDOMStream(source2));
+    } else if (isFetchResponse(source2)) {
+      this.source = new AsyncByteStreamSource(streamAdapters.fromDOMStream(source2.body));
+    } else if (isIterable$1(source2)) {
+      this.source = new AsyncByteStreamSource(streamAdapters.fromIterable(source2));
+    } else if (isPromise(source2)) {
+      this.source = new AsyncByteStreamSource(streamAdapters.fromAsyncIterable(source2));
+    } else if (isAsyncIterable$2(source2)) {
+      this.source = new AsyncByteStreamSource(streamAdapters.fromAsyncIterable(source2));
+    }
+  }
+  [Symbol.asyncIterator]() {
+    return this;
+  }
+  next(value) {
+    return this.source.next(value);
+  }
+  throw(value) {
+    return this.source.throw(value);
+  }
+  return(value) {
+    return this.source.return(value);
+  }
+  get closed() {
+    return this.source.closed;
+  }
+  cancel(reason) {
+    return this.source.cancel(reason);
+  }
+  peek(size) {
+    return this.source.peek(size);
+  }
+  read(size) {
+    return this.source.read(size);
+  }
+}
+class ByteStreamSource {
+  constructor(source2) {
+    this.source = source2;
+  }
+  cancel(reason) {
+    this.return(reason);
+  }
+  peek(size) {
+    return this.next(size, "peek").value;
+  }
+  read(size) {
+    return this.next(size, "read").value;
+  }
+  next(size, cmd = "read") {
+    return this.source.next({ cmd, size });
+  }
+  throw(value) {
+    return Object.create(this.source.throw && this.source.throw(value) || ITERATOR_DONE);
+  }
+  return(value) {
+    return Object.create(this.source.return && this.source.return(value) || ITERATOR_DONE);
+  }
+}
+class AsyncByteStreamSource {
+  constructor(source2) {
+    this.source = source2;
+    this._closedPromise = new Promise((r2) => this._closedPromiseResolve = r2);
+  }
+  cancel(reason) {
+    return __awaiter(this, void 0, void 0, function* () {
+      yield this.return(reason);
+    });
+  }
+  get closed() {
+    return this._closedPromise;
+  }
+  read(size) {
+    return __awaiter(this, void 0, void 0, function* () {
+      return (yield this.next(size, "read")).value;
+    });
+  }
+  peek(size) {
+    return __awaiter(this, void 0, void 0, function* () {
+      return (yield this.next(size, "peek")).value;
+    });
+  }
+  next(size_1) {
+    return __awaiter(this, arguments, void 0, function* (size, cmd = "read") {
+      return yield this.source.next({ cmd, size });
+    });
+  }
+  throw(value) {
+    return __awaiter(this, void 0, void 0, function* () {
+      const result = this.source.throw && (yield this.source.throw(value)) || ITERATOR_DONE;
+      this._closedPromiseResolve && this._closedPromiseResolve();
+      this._closedPromiseResolve = void 0;
+      return Object.create(result);
+    });
+  }
+  return(value) {
+    return __awaiter(this, void 0, void 0, function* () {
+      const result = this.source.return && (yield this.source.return(value)) || ITERATOR_DONE;
+      this._closedPromiseResolve && this._closedPromiseResolve();
+      this._closedPromiseResolve = void 0;
+      return Object.create(result);
+    });
+  }
+}
+class RandomAccessFile extends ByteStream {
+  constructor(buffer, byteLength) {
+    super();
+    this.position = 0;
+    this.buffer = toUint8Array(buffer);
+    this.size = byteLength === void 0 ? this.buffer.byteLength : byteLength;
+  }
+  readInt32(position) {
+    const { buffer, byteOffset } = this.readAt(position, 4);
+    return new DataView(buffer, byteOffset).getInt32(0, true);
+  }
+  seek(position) {
+    this.position = Math.min(position, this.size);
+    return position < this.size;
+  }
+  read(nBytes) {
+    const { buffer, size, position } = this;
+    if (buffer && position < size) {
+      if (typeof nBytes !== "number") {
+        nBytes = Number.POSITIVE_INFINITY;
+      }
+      this.position = Math.min(size, position + Math.min(size - position, nBytes));
+      return buffer.subarray(position, this.position);
+    }
+    return null;
+  }
+  readAt(position, nBytes) {
+    const buf = this.buffer;
+    const end = Math.min(this.size, position + nBytes);
+    return buf ? buf.subarray(position, end) : new Uint8Array(nBytes);
+  }
+  close() {
+    this.buffer && (this.buffer = null);
+  }
+  throw(value) {
+    this.close();
+    return { done: true, value };
+  }
+  return(value) {
+    this.close();
+    return { done: true, value };
+  }
+}
+class AsyncRandomAccessFile extends AsyncByteStream {
+  constructor(file, byteLength) {
+    super();
+    this.position = 0;
+    this._handle = file;
+    if (typeof byteLength === "number") {
+      this.size = byteLength;
+    } else {
+      this._pending = (() => __awaiter(this, void 0, void 0, function* () {
+        this.size = (yield file.stat()).size;
+        delete this._pending;
+      }))();
+    }
+  }
+  readInt32(position) {
+    return __awaiter(this, void 0, void 0, function* () {
+      const { buffer, byteOffset } = yield this.readAt(position, 4);
+      return new DataView(buffer, byteOffset).getInt32(0, true);
+    });
+  }
+  seek(position) {
+    return __awaiter(this, void 0, void 0, function* () {
+      this._pending && (yield this._pending);
+      this.position = Math.min(position, this.size);
+      return position < this.size;
+    });
+  }
+  read(nBytes) {
+    return __awaiter(this, void 0, void 0, function* () {
+      this._pending && (yield this._pending);
+      const { _handle: file, size, position } = this;
+      if (file && position < size) {
+        if (typeof nBytes !== "number") {
+          nBytes = Number.POSITIVE_INFINITY;
+        }
+        let pos = position, offset = 0, bytesRead = 0;
+        const end = Math.min(size, pos + Math.min(size - pos, nBytes));
+        const buffer = new Uint8Array(Math.max(0, (this.position = end) - pos));
+        while ((pos += bytesRead) < end && (offset += bytesRead) < buffer.byteLength) {
+          ({ bytesRead } = yield file.read(buffer, offset, buffer.byteLength - offset, pos));
+        }
+        return buffer;
+      }
+      return null;
+    });
+  }
+  readAt(position, nBytes) {
+    return __awaiter(this, void 0, void 0, function* () {
+      this._pending && (yield this._pending);
+      const { _handle: file, size } = this;
+      if (file && position + nBytes < size) {
+        const end = Math.min(size, position + nBytes);
+        const buffer = new Uint8Array(end - position);
+        return (yield file.read(buffer, 0, nBytes, position)).buffer;
+      }
+      return new Uint8Array(nBytes);
+    });
+  }
+  close() {
+    return __awaiter(this, void 0, void 0, function* () {
+      const f2 = this._handle;
+      this._handle = null;
+      f2 && (yield f2.close());
+    });
+  }
+  throw(value) {
+    return __awaiter(this, void 0, void 0, function* () {
+      yield this.close();
+      return { done: true, value };
+    });
+  }
+  return(value) {
+    return __awaiter(this, void 0, void 0, function* () {
+      yield this.close();
+      return { done: true, value };
+    });
+  }
+}
+const carryBit16 = 1 << 16;
+function intAsHex(value) {
+  if (value < 0) {
+    value = 4294967295 + value + 1;
+  }
+  return `0x${value.toString(16)}`;
+}
+const kInt32DecimalDigits = 8;
+const kPowersOfTen = [
+  1,
+  10,
+  100,
+  1e3,
+  1e4,
+  1e5,
+  1e6,
+  1e7,
+  1e8
+];
+class BaseInt64 {
+  constructor(buffer) {
+    this.buffer = buffer;
+  }
+  high() {
+    return this.buffer[1];
+  }
+  low() {
+    return this.buffer[0];
+  }
+  _times(other) {
+    const L2 = new Uint32Array([
+      this.buffer[1] >>> 16,
+      this.buffer[1] & 65535,
+      this.buffer[0] >>> 16,
+      this.buffer[0] & 65535
+    ]);
+    const R2 = new Uint32Array([
+      other.buffer[1] >>> 16,
+      other.buffer[1] & 65535,
+      other.buffer[0] >>> 16,
+      other.buffer[0] & 65535
+    ]);
+    let product = L2[3] * R2[3];
+    this.buffer[0] = product & 65535;
+    let sum = product >>> 16;
+    product = L2[2] * R2[3];
+    sum += product;
+    product = L2[3] * R2[2] >>> 0;
+    sum += product;
+    this.buffer[0] += sum << 16;
+    this.buffer[1] = sum >>> 0 < product ? carryBit16 : 0;
+    this.buffer[1] += sum >>> 16;
+    this.buffer[1] += L2[1] * R2[3] + L2[2] * R2[2] + L2[3] * R2[1];
+    this.buffer[1] += L2[0] * R2[3] + L2[1] * R2[2] + L2[2] * R2[1] + L2[3] * R2[0] << 16;
+    return this;
+  }
+  _plus(other) {
+    const sum = this.buffer[0] + other.buffer[0] >>> 0;
+    this.buffer[1] += other.buffer[1];
+    if (sum < this.buffer[0] >>> 0) {
+      ++this.buffer[1];
+    }
+    this.buffer[0] = sum;
+  }
+  lessThan(other) {
+    return this.buffer[1] < other.buffer[1] || this.buffer[1] === other.buffer[1] && this.buffer[0] < other.buffer[0];
+  }
+  equals(other) {
+    return this.buffer[1] === other.buffer[1] && this.buffer[0] == other.buffer[0];
+  }
+  greaterThan(other) {
+    return other.lessThan(this);
+  }
+  hex() {
+    return `${intAsHex(this.buffer[1])} ${intAsHex(this.buffer[0])}`;
+  }
+}
+class Uint64 extends BaseInt64 {
+  times(other) {
+    this._times(other);
+    return this;
+  }
+  plus(other) {
+    this._plus(other);
+    return this;
+  }
+  /** @nocollapse */
+  static from(val, out_buffer = new Uint32Array(2)) {
+    return Uint64.fromString(typeof val === "string" ? val : val.toString(), out_buffer);
+  }
+  /** @nocollapse */
+  static fromNumber(num, out_buffer = new Uint32Array(2)) {
+    return Uint64.fromString(num.toString(), out_buffer);
+  }
+  /** @nocollapse */
+  static fromString(str, out_buffer = new Uint32Array(2)) {
+    const length2 = str.length;
+    const out = new Uint64(out_buffer);
+    for (let posn = 0; posn < length2; ) {
+      const group = kInt32DecimalDigits < length2 - posn ? kInt32DecimalDigits : length2 - posn;
+      const chunk = new Uint64(new Uint32Array([Number.parseInt(str.slice(posn, posn + group), 10), 0]));
+      const multiple = new Uint64(new Uint32Array([kPowersOfTen[group], 0]));
+      out.times(multiple);
+      out.plus(chunk);
+      posn += group;
+    }
+    return out;
+  }
+  /** @nocollapse */
+  static convertArray(values) {
+    const data = new Uint32Array(values.length * 2);
+    for (let i2 = -1, n2 = values.length; ++i2 < n2; ) {
+      Uint64.from(values[i2], new Uint32Array(data.buffer, data.byteOffset + 2 * i2 * 4, 2));
+    }
+    return data;
+  }
+  /** @nocollapse */
+  static multiply(left, right) {
+    const rtrn = new Uint64(new Uint32Array(left.buffer));
+    return rtrn.times(right);
+  }
+  /** @nocollapse */
+  static add(left, right) {
+    const rtrn = new Uint64(new Uint32Array(left.buffer));
+    return rtrn.plus(right);
+  }
+}
+class Int64 extends BaseInt64 {
+  negate() {
+    this.buffer[0] = ~this.buffer[0] + 1;
+    this.buffer[1] = ~this.buffer[1];
+    if (this.buffer[0] == 0) {
+      ++this.buffer[1];
+    }
+    return this;
+  }
+  times(other) {
+    this._times(other);
+    return this;
+  }
+  plus(other) {
+    this._plus(other);
+    return this;
+  }
+  lessThan(other) {
+    const this_high = this.buffer[1] << 0;
+    const other_high = other.buffer[1] << 0;
+    return this_high < other_high || this_high === other_high && this.buffer[0] < other.buffer[0];
+  }
+  /** @nocollapse */
+  static from(val, out_buffer = new Uint32Array(2)) {
+    return Int64.fromString(typeof val === "string" ? val : val.toString(), out_buffer);
+  }
+  /** @nocollapse */
+  static fromNumber(num, out_buffer = new Uint32Array(2)) {
+    return Int64.fromString(num.toString(), out_buffer);
+  }
+  /** @nocollapse */
+  static fromString(str, out_buffer = new Uint32Array(2)) {
+    const negate2 = str.startsWith("-");
+    const length2 = str.length;
+    const out = new Int64(out_buffer);
+    for (let posn = negate2 ? 1 : 0; posn < length2; ) {
+      const group = kInt32DecimalDigits < length2 - posn ? kInt32DecimalDigits : length2 - posn;
+      const chunk = new Int64(new Uint32Array([Number.parseInt(str.slice(posn, posn + group), 10), 0]));
+      const multiple = new Int64(new Uint32Array([kPowersOfTen[group], 0]));
+      out.times(multiple);
+      out.plus(chunk);
+      posn += group;
+    }
+    return negate2 ? out.negate() : out;
+  }
+  /** @nocollapse */
+  static convertArray(values) {
+    const data = new Uint32Array(values.length * 2);
+    for (let i2 = -1, n2 = values.length; ++i2 < n2; ) {
+      Int64.from(values[i2], new Uint32Array(data.buffer, data.byteOffset + 2 * i2 * 4, 2));
+    }
+    return data;
+  }
+  /** @nocollapse */
+  static multiply(left, right) {
+    const rtrn = new Int64(new Uint32Array(left.buffer));
+    return rtrn.times(right);
+  }
+  /** @nocollapse */
+  static add(left, right) {
+    const rtrn = new Int64(new Uint32Array(left.buffer));
+    return rtrn.plus(right);
+  }
+}
+class Int128 {
+  constructor(buffer) {
+    this.buffer = buffer;
+  }
+  high() {
+    return new Int64(new Uint32Array(this.buffer.buffer, this.buffer.byteOffset + 8, 2));
+  }
+  low() {
+    return new Int64(new Uint32Array(this.buffer.buffer, this.buffer.byteOffset, 2));
+  }
+  negate() {
+    this.buffer[0] = ~this.buffer[0] + 1;
+    this.buffer[1] = ~this.buffer[1];
+    this.buffer[2] = ~this.buffer[2];
+    this.buffer[3] = ~this.buffer[3];
+    if (this.buffer[0] == 0) {
+      ++this.buffer[1];
+    }
+    if (this.buffer[1] == 0) {
+      ++this.buffer[2];
+    }
+    if (this.buffer[2] == 0) {
+      ++this.buffer[3];
+    }
+    return this;
+  }
+  times(other) {
+    const L0 = new Uint64(new Uint32Array([this.buffer[3], 0]));
+    const L1 = new Uint64(new Uint32Array([this.buffer[2], 0]));
+    const L2 = new Uint64(new Uint32Array([this.buffer[1], 0]));
+    const L3 = new Uint64(new Uint32Array([this.buffer[0], 0]));
+    const R0 = new Uint64(new Uint32Array([other.buffer[3], 0]));
+    const R1 = new Uint64(new Uint32Array([other.buffer[2], 0]));
+    const R2 = new Uint64(new Uint32Array([other.buffer[1], 0]));
+    const R3 = new Uint64(new Uint32Array([other.buffer[0], 0]));
+    let product = Uint64.multiply(L3, R3);
+    this.buffer[0] = product.low();
+    const sum = new Uint64(new Uint32Array([product.high(), 0]));
+    product = Uint64.multiply(L2, R3);
+    sum.plus(product);
+    product = Uint64.multiply(L3, R2);
+    sum.plus(product);
+    this.buffer[1] = sum.low();
+    this.buffer[3] = sum.lessThan(product) ? 1 : 0;
+    this.buffer[2] = sum.high();
+    const high = new Uint64(new Uint32Array(this.buffer.buffer, this.buffer.byteOffset + 8, 2));
+    high.plus(Uint64.multiply(L1, R3)).plus(Uint64.multiply(L2, R2)).plus(Uint64.multiply(L3, R1));
+    this.buffer[3] += Uint64.multiply(L0, R3).plus(Uint64.multiply(L1, R2)).plus(Uint64.multiply(L2, R1)).plus(Uint64.multiply(L3, R0)).low();
+    return this;
+  }
+  plus(other) {
+    const sums = new Uint32Array(4);
+    sums[3] = this.buffer[3] + other.buffer[3] >>> 0;
+    sums[2] = this.buffer[2] + other.buffer[2] >>> 0;
+    sums[1] = this.buffer[1] + other.buffer[1] >>> 0;
+    sums[0] = this.buffer[0] + other.buffer[0] >>> 0;
+    if (sums[0] < this.buffer[0] >>> 0) {
+      ++sums[1];
+    }
+    if (sums[1] < this.buffer[1] >>> 0) {
+      ++sums[2];
+    }
+    if (sums[2] < this.buffer[2] >>> 0) {
+      ++sums[3];
+    }
+    this.buffer[3] = sums[3];
+    this.buffer[2] = sums[2];
+    this.buffer[1] = sums[1];
+    this.buffer[0] = sums[0];
+    return this;
+  }
+  hex() {
+    return `${intAsHex(this.buffer[3])} ${intAsHex(this.buffer[2])} ${intAsHex(this.buffer[1])} ${intAsHex(this.buffer[0])}`;
+  }
+  /** @nocollapse */
+  static multiply(left, right) {
+    const rtrn = new Int128(new Uint32Array(left.buffer));
+    return rtrn.times(right);
+  }
+  /** @nocollapse */
+  static add(left, right) {
+    const rtrn = new Int128(new Uint32Array(left.buffer));
+    return rtrn.plus(right);
+  }
+  /** @nocollapse */
+  static from(val, out_buffer = new Uint32Array(4)) {
+    return Int128.fromString(typeof val === "string" ? val : val.toString(), out_buffer);
+  }
+  /** @nocollapse */
+  static fromNumber(num, out_buffer = new Uint32Array(4)) {
+    return Int128.fromString(num.toString(), out_buffer);
+  }
+  /** @nocollapse */
+  static fromString(str, out_buffer = new Uint32Array(4)) {
+    const negate2 = str.startsWith("-");
+    const length2 = str.length;
+    const out = new Int128(out_buffer);
+    for (let posn = negate2 ? 1 : 0; posn < length2; ) {
+      const group = kInt32DecimalDigits < length2 - posn ? kInt32DecimalDigits : length2 - posn;
+      const chunk = new Int128(new Uint32Array([Number.parseInt(str.slice(posn, posn + group), 10), 0, 0, 0]));
+      const multiple = new Int128(new Uint32Array([kPowersOfTen[group], 0, 0, 0]));
+      out.times(multiple);
+      out.plus(chunk);
+      posn += group;
+    }
+    return negate2 ? out.negate() : out;
+  }
+  /** @nocollapse */
+  static convertArray(values) {
+    const data = new Uint32Array(values.length * 4);
+    for (let i2 = -1, n2 = values.length; ++i2 < n2; ) {
+      Int128.from(values[i2], new Uint32Array(data.buffer, data.byteOffset + 4 * 4 * i2, 4));
+    }
+    return data;
+  }
+}
+function toIntervalDayTimeInt32Array(objects) {
+  var _a3, _b3;
+  const length2 = objects.length;
+  const array = new Int32Array(length2 * 2);
+  for (let oi2 = 0, ai2 = 0; oi2 < length2; oi2++) {
+    const interval = objects[oi2];
+    array[ai2++] = (_a3 = interval["days"]) !== null && _a3 !== void 0 ? _a3 : 0;
+    array[ai2++] = (_b3 = interval["milliseconds"]) !== null && _b3 !== void 0 ? _b3 : 0;
+  }
+  return array;
+}
+function toIntervalMonthDayNanoInt32Array(objects) {
+  var _a3, _b3;
+  const length2 = objects.length;
+  const data = new Int32Array(length2 * 4);
+  for (let oi2 = 0, ai2 = 0; oi2 < length2; oi2++) {
+    const interval = objects[oi2];
+    data[ai2++] = (_a3 = interval["months"]) !== null && _a3 !== void 0 ? _a3 : 0;
+    data[ai2++] = (_b3 = interval["days"]) !== null && _b3 !== void 0 ? _b3 : 0;
+    const nanoseconds = interval["nanoseconds"];
+    if (nanoseconds) {
+      data[ai2++] = Number(BigInt(nanoseconds) & BigInt(4294967295));
+      data[ai2++] = Number(BigInt(nanoseconds) >> BigInt(32));
+    } else {
+      ai2 += 2;
+    }
+  }
+  return data;
+}
+class VectorLoader extends Visitor {
+  constructor(bytes, nodes, buffers, dictionaries, metadataVersion = MetadataVersion.V5) {
+    super();
+    this.nodesIndex = -1;
+    this.buffersIndex = -1;
+    this.bytes = bytes;
+    this.nodes = nodes;
+    this.buffers = buffers;
+    this.dictionaries = dictionaries;
+    this.metadataVersion = metadataVersion;
+  }
+  visit(node) {
+    return super.visit(node instanceof Field2 ? node.type : node);
+  }
+  visitNull(type, { length: length2 } = this.nextFieldNode()) {
+    return makeData({ type, length: length2 });
+  }
+  visitBool(type, { length: length2, nullCount } = this.nextFieldNode()) {
+    return makeData({ type, length: length2, nullCount, nullBitmap: this.readNullBitmap(type, nullCount), data: this.readData(type) });
+  }
+  visitInt(type, { length: length2, nullCount } = this.nextFieldNode()) {
+    return makeData({ type, length: length2, nullCount, nullBitmap: this.readNullBitmap(type, nullCount), data: this.readData(type) });
+  }
+  visitFloat(type, { length: length2, nullCount } = this.nextFieldNode()) {
+    return makeData({ type, length: length2, nullCount, nullBitmap: this.readNullBitmap(type, nullCount), data: this.readData(type) });
+  }
+  visitUtf8(type, { length: length2, nullCount } = this.nextFieldNode()) {
+    return makeData({ type, length: length2, nullCount, nullBitmap: this.readNullBitmap(type, nullCount), valueOffsets: this.readOffsets(type), data: this.readData(type) });
+  }
+  visitLargeUtf8(type, { length: length2, nullCount } = this.nextFieldNode()) {
+    return makeData({ type, length: length2, nullCount, nullBitmap: this.readNullBitmap(type, nullCount), valueOffsets: this.readOffsets(type), data: this.readData(type) });
+  }
+  visitBinary(type, { length: length2, nullCount } = this.nextFieldNode()) {
+    return makeData({ type, length: length2, nullCount, nullBitmap: this.readNullBitmap(type, nullCount), valueOffsets: this.readOffsets(type), data: this.readData(type) });
+  }
+  visitLargeBinary(type, { length: length2, nullCount } = this.nextFieldNode()) {
+    return makeData({ type, length: length2, nullCount, nullBitmap: this.readNullBitmap(type, nullCount), valueOffsets: this.readOffsets(type), data: this.readData(type) });
+  }
+  visitFixedSizeBinary(type, { length: length2, nullCount } = this.nextFieldNode()) {
+    return makeData({ type, length: length2, nullCount, nullBitmap: this.readNullBitmap(type, nullCount), data: this.readData(type) });
+  }
+  visitDate(type, { length: length2, nullCount } = this.nextFieldNode()) {
+    return makeData({ type, length: length2, nullCount, nullBitmap: this.readNullBitmap(type, nullCount), data: this.readData(type) });
+  }
+  visitTimestamp(type, { length: length2, nullCount } = this.nextFieldNode()) {
+    return makeData({ type, length: length2, nullCount, nullBitmap: this.readNullBitmap(type, nullCount), data: this.readData(type) });
+  }
+  visitTime(type, { length: length2, nullCount } = this.nextFieldNode()) {
+    return makeData({ type, length: length2, nullCount, nullBitmap: this.readNullBitmap(type, nullCount), data: this.readData(type) });
+  }
+  visitDecimal(type, { length: length2, nullCount } = this.nextFieldNode()) {
+    return makeData({ type, length: length2, nullCount, nullBitmap: this.readNullBitmap(type, nullCount), data: this.readData(type) });
+  }
+  visitList(type, { length: length2, nullCount } = this.nextFieldNode()) {
+    return makeData({ type, length: length2, nullCount, nullBitmap: this.readNullBitmap(type, nullCount), valueOffsets: this.readOffsets(type), "child": this.visit(type.children[0]) });
+  }
+  visitStruct(type, { length: length2, nullCount } = this.nextFieldNode()) {
+    return makeData({ type, length: length2, nullCount, nullBitmap: this.readNullBitmap(type, nullCount), children: this.visitMany(type.children) });
+  }
+  visitUnion(type, { length: length2, nullCount } = this.nextFieldNode()) {
+    if (this.metadataVersion < MetadataVersion.V5) {
+      this.readNullBitmap(type, nullCount);
+    }
+    return type.mode === UnionMode.Sparse ? this.visitSparseUnion(type, { length: length2, nullCount }) : this.visitDenseUnion(type, { length: length2, nullCount });
+  }
+  visitDenseUnion(type, { length: length2, nullCount } = this.nextFieldNode()) {
+    return makeData({ type, length: length2, nullCount, typeIds: this.readTypeIds(type), valueOffsets: this.readOffsets(type), children: this.visitMany(type.children) });
+  }
+  visitSparseUnion(type, { length: length2, nullCount } = this.nextFieldNode()) {
+    return makeData({ type, length: length2, nullCount, typeIds: this.readTypeIds(type), children: this.visitMany(type.children) });
+  }
+  visitDictionary(type, { length: length2, nullCount } = this.nextFieldNode()) {
+    return makeData({ type, length: length2, nullCount, nullBitmap: this.readNullBitmap(type, nullCount), data: this.readData(type.indices), dictionary: this.readDictionary(type) });
+  }
+  visitInterval(type, { length: length2, nullCount } = this.nextFieldNode()) {
+    return makeData({ type, length: length2, nullCount, nullBitmap: this.readNullBitmap(type, nullCount), data: this.readData(type) });
+  }
+  visitDuration(type, { length: length2, nullCount } = this.nextFieldNode()) {
+    return makeData({ type, length: length2, nullCount, nullBitmap: this.readNullBitmap(type, nullCount), data: this.readData(type) });
+  }
+  visitFixedSizeList(type, { length: length2, nullCount } = this.nextFieldNode()) {
+    return makeData({ type, length: length2, nullCount, nullBitmap: this.readNullBitmap(type, nullCount), "child": this.visit(type.children[0]) });
+  }
+  visitMap(type, { length: length2, nullCount } = this.nextFieldNode()) {
+    return makeData({ type, length: length2, nullCount, nullBitmap: this.readNullBitmap(type, nullCount), valueOffsets: this.readOffsets(type), "child": this.visit(type.children[0]) });
+  }
+  nextFieldNode() {
+    return this.nodes[++this.nodesIndex];
+  }
+  nextBufferRange() {
+    return this.buffers[++this.buffersIndex];
+  }
+  readNullBitmap(type, nullCount, buffer = this.nextBufferRange()) {
+    return nullCount > 0 && this.readData(type, buffer) || new Uint8Array(0);
+  }
+  readOffsets(type, buffer) {
+    return this.readData(type, buffer);
+  }
+  readTypeIds(type, buffer) {
+    return this.readData(type, buffer);
+  }
+  readData(_type, { length: length2, offset } = this.nextBufferRange()) {
+    return this.bytes.subarray(offset, offset + length2);
+  }
+  readDictionary(type) {
+    return this.dictionaries.get(type.id);
+  }
+}
+class JSONVectorLoader extends VectorLoader {
+  constructor(sources, nodes, buffers, dictionaries, metadataVersion) {
+    super(new Uint8Array(0), nodes, buffers, dictionaries, metadataVersion);
+    this.sources = sources;
+  }
+  readNullBitmap(_type, nullCount, { offset } = this.nextBufferRange()) {
+    return nullCount <= 0 ? new Uint8Array(0) : packBools(this.sources[offset]);
+  }
+  readOffsets(_type, { offset } = this.nextBufferRange()) {
+    return toArrayBufferView(Uint8Array, toArrayBufferView(_type.OffsetArrayType, this.sources[offset]));
+  }
+  readTypeIds(type, { offset } = this.nextBufferRange()) {
+    return toArrayBufferView(Uint8Array, toArrayBufferView(type.ArrayType, this.sources[offset]));
+  }
+  readData(type, { offset } = this.nextBufferRange()) {
+    const { sources } = this;
+    if (DataType.isTimestamp(type)) {
+      return toArrayBufferView(Uint8Array, Int64.convertArray(sources[offset]));
+    } else if ((DataType.isInt(type) || DataType.isTime(type)) && type.bitWidth === 64 || DataType.isDuration(type)) {
+      return toArrayBufferView(Uint8Array, Int64.convertArray(sources[offset]));
+    } else if (DataType.isDate(type) && type.unit === DateUnit.MILLISECOND) {
+      return toArrayBufferView(Uint8Array, Int64.convertArray(sources[offset]));
+    } else if (DataType.isDecimal(type)) {
+      return toArrayBufferView(Uint8Array, Int128.convertArray(sources[offset]));
+    } else if (DataType.isBinary(type) || DataType.isLargeBinary(type) || DataType.isFixedSizeBinary(type)) {
+      return binaryDataFromJSON(sources[offset]);
+    } else if (DataType.isBool(type)) {
+      return packBools(sources[offset]);
+    } else if (DataType.isUtf8(type) || DataType.isLargeUtf8(type)) {
+      return encodeUtf8(sources[offset].join(""));
+    } else if (DataType.isInterval(type)) {
+      switch (type.unit) {
+        case IntervalUnit.DAY_TIME:
+          return toIntervalDayTimeInt32Array(sources[offset]);
+        case IntervalUnit.MONTH_DAY_NANO:
+          return toIntervalMonthDayNanoInt32Array(sources[offset]);
+      }
+    }
+    return toArrayBufferView(Uint8Array, toArrayBufferView(type.ArrayType, sources[offset].map((x2) => +x2)));
+  }
+}
+function binaryDataFromJSON(values) {
+  const joined = values.join("");
+  const data = new Uint8Array(joined.length / 2);
+  for (let i2 = 0; i2 < joined.length; i2 += 2) {
+    data[i2 >> 1] = Number.parseInt(joined.slice(i2, i2 + 2), 16);
+  }
+  return data;
+}
+class CompressedVectorLoader extends VectorLoader {
+  constructor(bodyChunks, nodes, buffers, dictionaries, metadataVersion) {
+    super(new Uint8Array(0), nodes, buffers, dictionaries, metadataVersion);
+    this.bodyChunks = bodyChunks;
+  }
+  readData(_type, _buffer = this.nextBufferRange()) {
+    return this.bodyChunks[this.buffersIndex];
+  }
+}
+class TypeComparator extends Visitor {
+  compareSchemas(schema, other) {
+    return schema === other || other instanceof schema.constructor && this.compareManyFields(schema.fields, other.fields);
+  }
+  compareManyFields(fields, others) {
+    return fields === others || Array.isArray(fields) && Array.isArray(others) && fields.length === others.length && fields.every((f2, i2) => this.compareFields(f2, others[i2]));
+  }
+  compareFields(field, other) {
+    return field === other || other instanceof field.constructor && field.name === other.name && field.nullable === other.nullable && this.visit(field.type, other.type);
+  }
+}
+function compareConstructor(type, other) {
+  return other instanceof type.constructor;
+}
+function compareAny(type, other) {
+  return type === other || compareConstructor(type, other);
+}
+function compareInt(type, other) {
+  return type === other || compareConstructor(type, other) && type.bitWidth === other.bitWidth && type.isSigned === other.isSigned;
+}
+function compareFloat(type, other) {
+  return type === other || compareConstructor(type, other) && type.precision === other.precision;
+}
+function compareFixedSizeBinary(type, other) {
+  return type === other || compareConstructor(type, other) && type.byteWidth === other.byteWidth;
+}
+function compareDate(type, other) {
+  return type === other || compareConstructor(type, other) && type.unit === other.unit;
+}
+function compareTimestamp(type, other) {
+  return type === other || compareConstructor(type, other) && type.unit === other.unit && type.timezone === other.timezone;
+}
+function compareTime(type, other) {
+  return type === other || compareConstructor(type, other) && type.unit === other.unit && type.bitWidth === other.bitWidth;
+}
+function compareList(type, other) {
+  return type === other || compareConstructor(type, other) && type.children.length === other.children.length && instance.compareManyFields(type.children, other.children);
+}
+function compareStruct(type, other) {
+  return type === other || compareConstructor(type, other) && type.children.length === other.children.length && instance.compareManyFields(type.children, other.children);
+}
+function compareUnion(type, other) {
+  return type === other || compareConstructor(type, other) && type.mode === other.mode && type.typeIds.every((x2, i2) => x2 === other.typeIds[i2]) && instance.compareManyFields(type.children, other.children);
+}
+function compareDictionary(type, other) {
+  return type === other || compareConstructor(type, other) && type.id === other.id && type.isOrdered === other.isOrdered && instance.visit(type.indices, other.indices) && instance.visit(type.dictionary, other.dictionary);
+}
+function compareInterval(type, other) {
+  return type === other || compareConstructor(type, other) && type.unit === other.unit;
+}
+function compareDuration(type, other) {
+  return type === other || compareConstructor(type, other) && type.unit === other.unit;
+}
+function compareFixedSizeList(type, other) {
+  return type === other || compareConstructor(type, other) && type.listSize === other.listSize && type.children.length === other.children.length && instance.compareManyFields(type.children, other.children);
+}
+function compareMap(type, other) {
+  return type === other || compareConstructor(type, other) && type.keysSorted === other.keysSorted && type.children.length === other.children.length && instance.compareManyFields(type.children, other.children);
+}
+TypeComparator.prototype.visitNull = compareAny;
+TypeComparator.prototype.visitBool = compareAny;
+TypeComparator.prototype.visitInt = compareInt;
+TypeComparator.prototype.visitInt8 = compareInt;
+TypeComparator.prototype.visitInt16 = compareInt;
+TypeComparator.prototype.visitInt32 = compareInt;
+TypeComparator.prototype.visitInt64 = compareInt;
+TypeComparator.prototype.visitUint8 = compareInt;
+TypeComparator.prototype.visitUint16 = compareInt;
+TypeComparator.prototype.visitUint32 = compareInt;
+TypeComparator.prototype.visitUint64 = compareInt;
+TypeComparator.prototype.visitFloat = compareFloat;
+TypeComparator.prototype.visitFloat16 = compareFloat;
+TypeComparator.prototype.visitFloat32 = compareFloat;
+TypeComparator.prototype.visitFloat64 = compareFloat;
+TypeComparator.prototype.visitUtf8 = compareAny;
+TypeComparator.prototype.visitLargeUtf8 = compareAny;
+TypeComparator.prototype.visitBinary = compareAny;
+TypeComparator.prototype.visitLargeBinary = compareAny;
+TypeComparator.prototype.visitFixedSizeBinary = compareFixedSizeBinary;
+TypeComparator.prototype.visitDate = compareDate;
+TypeComparator.prototype.visitDateDay = compareDate;
+TypeComparator.prototype.visitDateMillisecond = compareDate;
+TypeComparator.prototype.visitTimestamp = compareTimestamp;
+TypeComparator.prototype.visitTimestampSecond = compareTimestamp;
+TypeComparator.prototype.visitTimestampMillisecond = compareTimestamp;
+TypeComparator.prototype.visitTimestampMicrosecond = compareTimestamp;
+TypeComparator.prototype.visitTimestampNanosecond = compareTimestamp;
+TypeComparator.prototype.visitTime = compareTime;
+TypeComparator.prototype.visitTimeSecond = compareTime;
+TypeComparator.prototype.visitTimeMillisecond = compareTime;
+TypeComparator.prototype.visitTimeMicrosecond = compareTime;
+TypeComparator.prototype.visitTimeNanosecond = compareTime;
+TypeComparator.prototype.visitDecimal = compareAny;
+TypeComparator.prototype.visitList = compareList;
+TypeComparator.prototype.visitStruct = compareStruct;
+TypeComparator.prototype.visitUnion = compareUnion;
+TypeComparator.prototype.visitDenseUnion = compareUnion;
+TypeComparator.prototype.visitSparseUnion = compareUnion;
+TypeComparator.prototype.visitDictionary = compareDictionary;
+TypeComparator.prototype.visitInterval = compareInterval;
+TypeComparator.prototype.visitIntervalDayTime = compareInterval;
+TypeComparator.prototype.visitIntervalYearMonth = compareInterval;
+TypeComparator.prototype.visitIntervalMonthDayNano = compareInterval;
+TypeComparator.prototype.visitDuration = compareDuration;
+TypeComparator.prototype.visitDurationSecond = compareDuration;
+TypeComparator.prototype.visitDurationMillisecond = compareDuration;
+TypeComparator.prototype.visitDurationMicrosecond = compareDuration;
+TypeComparator.prototype.visitDurationNanosecond = compareDuration;
+TypeComparator.prototype.visitFixedSizeList = compareFixedSizeList;
+TypeComparator.prototype.visitMap = compareMap;
+const instance = new TypeComparator();
+function compareSchemas(schema, other) {
+  return instance.compareSchemas(schema, other);
+}
+function distributeVectorsIntoRecordBatches(schema, vecs) {
+  return uniformlyDistributeChunksAcrossRecordBatches(schema, vecs.map((v2) => v2.data.concat()));
+}
+function uniformlyDistributeChunksAcrossRecordBatches(schema, cols) {
+  const fields = [...schema.fields];
+  const batches = [];
+  const memo = { numBatches: cols.reduce((n2, c2) => Math.max(n2, c2.length), 0) };
+  let numBatches = 0, batchLength = 0;
+  let i2 = -1;
+  const numColumns = cols.length;
+  let child, children = [];
+  while (memo.numBatches-- > 0) {
+    for (batchLength = Number.POSITIVE_INFINITY, i2 = -1; ++i2 < numColumns; ) {
+      children[i2] = child = cols[i2].shift();
+      batchLength = Math.min(batchLength, child ? child.length : batchLength);
+    }
+    if (Number.isFinite(batchLength)) {
+      children = distributeChildren(fields, batchLength, children, cols, memo);
+      if (batchLength > 0) {
+        batches[numBatches++] = makeData({
+          type: new Struct(fields),
+          length: batchLength,
+          nullCount: 0,
+          children: children.slice()
+        });
+      }
+    }
+  }
+  return [
+    schema = schema.assign(fields),
+    batches.map((data) => new RecordBatch3(schema, data))
+  ];
+}
+function distributeChildren(fields, batchLength, children, columns, memo) {
+  var _a3;
+  const nullBitmapSize = (batchLength + 63 & -64) >> 3;
+  for (let i2 = -1, n2 = columns.length; ++i2 < n2; ) {
+    const child = children[i2];
+    const length2 = child === null || child === void 0 ? void 0 : child.length;
+    if (length2 >= batchLength) {
+      if (length2 === batchLength) {
+        children[i2] = child;
+      } else {
+        children[i2] = child.slice(0, batchLength);
+        memo.numBatches = Math.max(memo.numBatches, columns[i2].unshift(child.slice(batchLength, length2 - batchLength)));
+      }
+    } else {
+      const field = fields[i2];
+      fields[i2] = field.clone({ nullable: true });
+      children[i2] = (_a3 = child === null || child === void 0 ? void 0 : child._changeLengthAndBackfillNullBitmap(batchLength)) !== null && _a3 !== void 0 ? _a3 : makeData({
+        type: field.type,
+        length: batchLength,
+        nullCount: batchLength,
+        nullBitmap: new Uint8Array(nullBitmapSize)
+      });
+    }
+  }
+  return children;
+}
+var _a$1;
+class Table {
+  constructor(...args) {
+    var _b3, _c3;
+    if (args.length === 0) {
+      this.batches = [];
+      this.schema = new Schema2([]);
+      this._offsets = [0];
+      return this;
+    }
+    let schema;
+    let offsets;
+    if (args[0] instanceof Schema2) {
+      schema = args.shift();
+    }
+    if (args.at(-1) instanceof Uint32Array) {
+      offsets = args.pop();
+    }
+    const unwrap = (x2) => {
+      if (x2) {
+        if (x2 instanceof RecordBatch3) {
+          return [x2];
+        } else if (x2 instanceof Table) {
+          return x2.batches;
+        } else if (x2 instanceof Data) {
+          if (x2.type instanceof Struct) {
+            return [new RecordBatch3(new Schema2(x2.type.children), x2)];
+          }
+        } else if (Array.isArray(x2)) {
+          return x2.flatMap((v2) => unwrap(v2));
+        } else if (typeof x2[Symbol.iterator] === "function") {
+          return [...x2].flatMap((v2) => unwrap(v2));
+        } else if (typeof x2 === "object") {
+          const keys = Object.keys(x2);
+          const vecs = keys.map((k2) => new Vector$1([x2[k2]]));
+          const batchSchema = schema !== null && schema !== void 0 ? schema : new Schema2(keys.map((k2, i2) => new Field2(String(k2), vecs[i2].type, vecs[i2].nullable)));
+          const [, batches2] = distributeVectorsIntoRecordBatches(batchSchema, vecs);
+          return batches2.length === 0 ? [new RecordBatch3(x2)] : batches2;
+        }
+      }
+      return [];
+    };
+    const batches = args.flatMap((v2) => unwrap(v2));
+    schema = (_c3 = schema !== null && schema !== void 0 ? schema : (_b3 = batches[0]) === null || _b3 === void 0 ? void 0 : _b3.schema) !== null && _c3 !== void 0 ? _c3 : new Schema2([]);
+    if (!(schema instanceof Schema2)) {
+      throw new TypeError("Table constructor expects a [Schema, RecordBatch[]] pair.");
+    }
+    for (const batch of batches) {
+      if (!(batch instanceof RecordBatch3)) {
+        throw new TypeError("Table constructor expects a [Schema, RecordBatch[]] pair.");
+      }
+      if (!compareSchemas(schema, batch.schema)) {
+        throw new TypeError("Table and inner RecordBatch schemas must be equivalent.");
+      }
+    }
+    this.schema = schema;
+    this.batches = batches;
+    this._offsets = offsets !== null && offsets !== void 0 ? offsets : computeChunkOffsets(this.data);
+  }
+  /**
+   * The contiguous {@link RecordBatch `RecordBatch`} chunks of the Table rows.
+   */
+  get data() {
+    return this.batches.map(({ data }) => data);
+  }
+  /**
+   * The number of columns in this Table.
+   */
+  get numCols() {
+    return this.schema.fields.length;
+  }
+  /**
+   * The number of rows in this Table.
+   */
+  get numRows() {
+    return this.data.reduce((numRows, data) => numRows + data.length, 0);
+  }
+  /**
+   * The number of null rows in this Table.
+   */
+  get nullCount() {
+    if (this._nullCount === -1) {
+      this._nullCount = computeChunkNullCounts(this.data);
+    }
+    return this._nullCount;
+  }
+  /**
+   * Check whether an element is null.
+   *
+   * @param index The index at which to read the validity bitmap.
+   */
+  // @ts-ignore
+  isValid(index) {
+    return false;
+  }
+  /**
+   * Get an element value by position.
+   *
+   * @param index The index of the element to read.
+   */
+  // @ts-ignore
+  get(index) {
+    return null;
+  }
+  /**
+    * Get an element value by position.
+    * @param index The index of the element to read. A negative index will count back from the last element.
+    */
+  // @ts-ignore
+  at(index) {
+    return this.get(wrapIndex(index, this.numRows));
+  }
+  /**
+   * Set an element value by position.
+   *
+   * @param index The index of the element to write.
+   * @param value The value to set.
+   */
+  // @ts-ignore
+  set(index, value) {
+    return;
+  }
+  /**
+   * Retrieve the index of the first occurrence of a value in an Vector.
+   *
+   * @param element The value to locate in the Vector.
+   * @param offset The index at which to begin the search. If offset is omitted, the search starts at index 0.
+   */
+  // @ts-ignore
+  indexOf(element, offset) {
+    return -1;
+  }
+  /**
+   * Iterator for rows in this Table.
+   */
+  [Symbol.iterator]() {
+    if (this.batches.length > 0) {
+      return instance$2.visit(new Vector$1(this.data));
+    }
+    return new Array(0)[Symbol.iterator]();
+  }
+  /**
+   * Return a JavaScript Array of the Table rows.
+   *
+   * @returns An Array of Table rows.
+   */
+  toArray() {
+    return [...this];
+  }
+  /**
+   * Returns a string representation of the Table rows.
+   *
+   * @returns A string representation of the Table rows.
+   */
+  toString() {
+    return `[
+  ${this.toArray().join(",\n  ")}
+]`;
+  }
+  /**
+   * Combines two or more Tables of the same schema.
+   *
+   * @param others Additional Tables to add to the end of this Tables.
+   */
+  concat(...others) {
+    const schema = this.schema;
+    const data = this.data.concat(others.flatMap(({ data: data2 }) => data2));
+    return new Table(schema, data.map((data2) => new RecordBatch3(schema, data2)));
+  }
+  /**
+   * Return a zero-copy sub-section of this Table.
+   *
+   * @param begin The beginning of the specified portion of the Table.
+   * @param end The end of the specified portion of the Table. This is exclusive of the element at the index 'end'.
+   */
+  slice(begin, end) {
+    const schema = this.schema;
+    [begin, end] = clampRange({ length: this.numRows }, begin, end);
+    const data = sliceChunks(this.data, this._offsets, begin, end);
+    return new Table(schema, data.map((chunk) => new RecordBatch3(schema, chunk)));
+  }
+  /**
+   * Returns a child Vector by name, or null if this Vector has no child with the given name.
+   *
+   * @param name The name of the child to retrieve.
+   */
+  getChild(name2) {
+    return this.getChildAt(this.schema.fields.findIndex((f2) => f2.name === name2));
+  }
+  /**
+   * Returns a child Vector by index, or null if this Vector has no child at the supplied index.
+   *
+   * @param index The index of the child to retrieve.
+   */
+  getChildAt(index) {
+    if (index > -1 && index < this.schema.fields.length) {
+      const data = this.data.map((data2) => data2.children[index]);
+      if (data.length === 0) {
+        const { type } = this.schema.fields[index];
+        const empty = makeData({ type, length: 0, nullCount: 0 });
+        data.push(empty._changeLengthAndBackfillNullBitmap(this.numRows));
+      }
+      return new Vector$1(data);
+    }
+    return null;
+  }
+  /**
+   * Sets a child Vector by name.
+   *
+   * @param name The name of the child to overwrite.
+   * @returns A new Table with the supplied child for the specified name.
+   */
+  setChild(name2, child) {
+    var _b3;
+    return this.setChildAt((_b3 = this.schema.fields) === null || _b3 === void 0 ? void 0 : _b3.findIndex((f2) => f2.name === name2), child);
+  }
+  setChildAt(index, child) {
+    let schema = this.schema;
+    let batches = [...this.batches];
+    if (index > -1 && index < this.numCols) {
+      if (!child) {
+        child = new Vector$1([makeData({ type: new Null2(), length: this.numRows })]);
+      }
+      const fields = schema.fields.slice();
+      const field = fields[index].clone({ type: child.type });
+      const children = this.schema.fields.map((_2, i2) => this.getChildAt(i2));
+      [fields[index], children[index]] = [field, child];
+      [schema, batches] = distributeVectorsIntoRecordBatches(schema, children);
+    }
+    return new Table(schema, batches);
+  }
+  /**
+   * Construct a new Table containing only specified columns.
+   *
+   * @param columnNames Names of columns to keep.
+   * @returns A new Table of columns matching the specified names.
+   */
+  select(columnNames) {
+    const nameToIndex = this.schema.fields.reduce((m2, f2, i2) => m2.set(f2.name, i2), /* @__PURE__ */ new Map());
+    return this.selectAt(columnNames.map((columnName) => nameToIndex.get(columnName)).filter((x2) => x2 > -1));
+  }
+  /**
+   * Construct a new Table containing only columns at the specified indices.
+   *
+   * @param columnIndices Indices of columns to keep.
+   * @returns A new Table of columns at the specified indices.
+   */
+  selectAt(columnIndices) {
+    const schema = this.schema.selectAt(columnIndices);
+    const data = this.batches.map((batch) => batch.selectAt(columnIndices));
+    return new Table(schema, data);
+  }
+  assign(other) {
+    const fields = this.schema.fields;
+    const [indices, oldToNew] = other.schema.fields.reduce((memo, f2, newIdx) => {
+      const [indices2, oldToNew2] = memo;
+      const i2 = fields.findIndex((f3) => f3.name === f2.name);
+      ~i2 ? oldToNew2[i2] = newIdx : indices2.push(newIdx);
+      return memo;
+    }, [[], []]);
+    const schema = this.schema.assign(other.schema);
+    const columns = [
+      ...fields.map((_2, i2) => [i2, oldToNew[i2]]).map(([i2, j2]) => j2 === void 0 ? this.getChildAt(i2) : other.getChildAt(j2)),
+      ...indices.map((i2) => other.getChildAt(i2))
+    ].filter(Boolean);
+    return new Table(...distributeVectorsIntoRecordBatches(schema, columns));
+  }
+}
+_a$1 = Symbol.toStringTag;
+Table[_a$1] = ((proto) => {
+  proto.schema = null;
+  proto.batches = [];
+  proto._offsets = new Uint32Array([0]);
+  proto._nullCount = -1;
+  proto[Symbol.isConcatSpreadable] = true;
+  proto["isValid"] = wrapChunkedCall1(isChunkedValid);
+  proto["get"] = wrapChunkedCall1(instance$4.getVisitFn(Type.Struct));
+  proto["set"] = wrapChunkedCall2(instance$5.getVisitFn(Type.Struct));
+  proto["indexOf"] = wrapChunkedIndexOf(instance$3.getVisitFn(Type.Struct));
+  return "Table";
+})(Table.prototype);
+var _a;
+class RecordBatch3 {
+  constructor(...args) {
+    switch (args.length) {
+      case 2: {
+        [this.schema] = args;
+        if (!(this.schema instanceof Schema2)) {
+          throw new TypeError("RecordBatch constructor expects a [Schema, Data] pair.");
+        }
+        [
+          ,
+          this.data = makeData({
+            nullCount: 0,
+            type: new Struct(this.schema.fields),
+            children: this.schema.fields.map((f2) => makeData({ type: f2.type, nullCount: 0 }))
+          })
+        ] = args;
+        if (!(this.data instanceof Data)) {
+          throw new TypeError("RecordBatch constructor expects a [Schema, Data] pair.");
+        }
+        [this.schema, this.data] = ensureSameLengthData(this.schema, this.data.children);
+        break;
+      }
+      case 1: {
+        const [obj] = args;
+        const { fields, children, length: length2 } = Object.keys(obj).reduce((memo, name2, i2) => {
+          memo.children[i2] = obj[name2];
+          memo.length = Math.max(memo.length, obj[name2].length);
+          memo.fields[i2] = Field2.new({ name: name2, type: obj[name2].type, nullable: true });
+          return memo;
+        }, {
+          length: 0,
+          fields: new Array(),
+          children: new Array()
+        });
+        const schema = new Schema2(fields);
+        const data = makeData({ type: new Struct(fields), length: length2, children, nullCount: 0 });
+        [this.schema, this.data] = ensureSameLengthData(schema, data.children, length2);
+        break;
+      }
+      default:
+        throw new TypeError("RecordBatch constructor expects an Object mapping names to child Data, or a [Schema, Data] pair.");
+    }
+  }
+  get dictionaries() {
+    return this._dictionaries || (this._dictionaries = collectDictionaries(this.schema.fields, this.data.children));
+  }
+  /**
+   * The number of columns in this RecordBatch.
+   */
+  get numCols() {
+    return this.schema.fields.length;
+  }
+  /**
+   * The number of rows in this RecordBatch.
+   */
+  get numRows() {
+    return this.data.length;
+  }
+  /**
+   * The number of null rows in this RecordBatch.
+   */
+  get nullCount() {
+    return this.data.nullCount;
+  }
+  /**
+   * Check whether an row is null.
+   * @param index The index at which to read the validity bitmap.
+   */
+  isValid(index) {
+    return this.data.getValid(index);
+  }
+  /**
+   * Get a row by position.
+   * @param index The index of the row to read.
+   */
+  get(index) {
+    return instance$4.visit(this.data, index);
+  }
+  /**
+    * Get a row value by position.
+    * @param index The index of the row to read. A negative index will count back from the last row.
+    */
+  at(index) {
+    return this.get(wrapIndex(index, this.numRows));
+  }
+  /**
+   * Set a row by position.
+   * @param index The index of the row to write.
+   * @param value The value to set.
+   */
+  set(index, value) {
+    return instance$5.visit(this.data, index, value);
+  }
+  /**
+   * Retrieve the index of the first occurrence of a row in an RecordBatch.
+   * @param element The row to locate in the RecordBatch.
+   * @param offset The index at which to begin the search. If offset is omitted, the search starts at index 0.
+   */
+  indexOf(element, offset) {
+    return instance$3.visit(this.data, element, offset);
+  }
+  /**
+   * Iterator for rows in this RecordBatch.
+   */
+  [Symbol.iterator]() {
+    return instance$2.visit(new Vector$1([this.data]));
+  }
+  /**
+   * Return a JavaScript Array of the RecordBatch rows.
+   * @returns An Array of RecordBatch rows.
+   */
+  toArray() {
+    return [...this];
+  }
+  /**
+   * Combines two or more RecordBatch of the same schema.
+   * @param others Additional RecordBatch to add to the end of this RecordBatch.
+   */
+  concat(...others) {
+    return new Table(this.schema, [this, ...others]);
+  }
+  /**
+   * Return a zero-copy sub-section of this RecordBatch.
+   * @param start The beginning of the specified portion of the RecordBatch.
+   * @param end The end of the specified portion of the RecordBatch. This is exclusive of the row at the index 'end'.
+   */
+  slice(begin, end) {
+    const [slice] = new Vector$1([this.data]).slice(begin, end).data;
+    return new RecordBatch3(this.schema, slice);
+  }
+  /**
+   * Returns a child Vector by name, or null if this Vector has no child with the given name.
+   * @param name The name of the child to retrieve.
+   */
+  getChild(name2) {
+    var _b3;
+    return this.getChildAt((_b3 = this.schema.fields) === null || _b3 === void 0 ? void 0 : _b3.findIndex((f2) => f2.name === name2));
+  }
+  /**
+   * Returns a child Vector by index, or null if this Vector has no child at the supplied index.
+   * @param index The index of the child to retrieve.
+   */
+  getChildAt(index) {
+    if (index > -1 && index < this.schema.fields.length) {
+      return new Vector$1([this.data.children[index]]);
+    }
+    return null;
+  }
+  /**
+   * Sets a child Vector by name.
+   * @param name The name of the child to overwrite.
+   * @returns A new RecordBatch with the new child for the specified name.
+   */
+  setChild(name2, child) {
+    var _b3;
+    return this.setChildAt((_b3 = this.schema.fields) === null || _b3 === void 0 ? void 0 : _b3.findIndex((f2) => f2.name === name2), child);
+  }
+  setChildAt(index, child) {
+    let schema = this.schema;
+    let data = this.data;
+    if (index > -1 && index < this.numCols) {
+      if (!child) {
+        child = new Vector$1([makeData({ type: new Null2(), length: this.numRows })]);
+      }
+      const fields = schema.fields.slice();
+      const children = data.children.slice();
+      const field = fields[index].clone({ type: child.type });
+      [fields[index], children[index]] = [field, child.data[0]];
+      schema = new Schema2(fields, new Map(this.schema.metadata));
+      data = makeData({ type: new Struct(fields), children });
+    }
+    return new RecordBatch3(schema, data);
+  }
+  /**
+   * Construct a new RecordBatch containing only specified columns.
+   *
+   * @param columnNames Names of columns to keep.
+   * @returns A new RecordBatch of columns matching the specified names.
+   */
+  select(columnNames) {
+    const schema = this.schema.select(columnNames);
+    const type = new Struct(schema.fields);
+    const children = [];
+    for (const name2 of columnNames) {
+      const index = this.schema.fields.findIndex((f2) => f2.name === name2);
+      if (~index) {
+        children[index] = this.data.children[index];
+      }
+    }
+    return new RecordBatch3(schema, makeData({ type, length: this.numRows, children }));
+  }
+  /**
+   * Construct a new RecordBatch containing only columns at the specified indices.
+   *
+   * @param columnIndices Indices of columns to keep.
+   * @returns A new RecordBatch of columns matching at the specified indices.
+   */
+  selectAt(columnIndices) {
+    const schema = this.schema.selectAt(columnIndices);
+    const children = columnIndices.map((i2) => this.data.children[i2]).filter(Boolean);
+    const subset = makeData({ type: new Struct(schema.fields), length: this.numRows, children });
+    return new RecordBatch3(schema, subset);
+  }
+}
+_a = Symbol.toStringTag;
+RecordBatch3[_a] = ((proto) => {
+  proto._nullCount = -1;
+  proto[Symbol.isConcatSpreadable] = true;
+  return "RecordBatch";
+})(RecordBatch3.prototype);
+function ensureSameLengthData(schema, chunks, maxLength = chunks.reduce((max, col) => Math.max(max, col.length), 0)) {
+  var _b3;
+  const fields = [...schema.fields];
+  const children = [...chunks];
+  const nullBitmapSize = (maxLength + 63 & -64) >> 3;
+  for (const [idx, field] of schema.fields.entries()) {
+    const chunk = chunks[idx];
+    if (!chunk || chunk.length !== maxLength) {
+      fields[idx] = field.clone({ nullable: true });
+      children[idx] = (_b3 = chunk === null || chunk === void 0 ? void 0 : chunk._changeLengthAndBackfillNullBitmap(maxLength)) !== null && _b3 !== void 0 ? _b3 : makeData({
+        type: field.type,
+        length: maxLength,
+        nullCount: maxLength,
+        nullBitmap: new Uint8Array(nullBitmapSize)
+      });
+    }
+  }
+  return [
+    schema.assign(fields),
+    makeData({ type: new Struct(fields), length: maxLength, children })
+  ];
+}
+function collectDictionaries(fields, children, dictionaries = /* @__PURE__ */ new Map()) {
+  var _b3, _c3;
+  if (((_b3 = fields === null || fields === void 0 ? void 0 : fields.length) !== null && _b3 !== void 0 ? _b3 : 0) > 0 && (fields === null || fields === void 0 ? void 0 : fields.length) === (children === null || children === void 0 ? void 0 : children.length)) {
+    for (let i2 = -1, n2 = fields.length; ++i2 < n2; ) {
+      const { type } = fields[i2];
+      const data = children[i2];
+      for (const next of [data, ...((_c3 = data === null || data === void 0 ? void 0 : data.dictionary) === null || _c3 === void 0 ? void 0 : _c3.data) || []]) {
+        collectDictionaries(type.children, next === null || next === void 0 ? void 0 : next.children, dictionaries);
+      }
+      if (DataType.isDictionary(type)) {
+        const { id: id2 } = type;
+        if (!dictionaries.has(id2)) {
+          if (data === null || data === void 0 ? void 0 : data.dictionary) {
+            dictionaries.set(id2, data.dictionary);
+          }
+        } else if (dictionaries.get(id2) !== data.dictionary) {
+          throw new Error(`Cannot create Schema containing two different dictionaries with the same Id`);
+        }
+      }
+    }
+  }
+  return dictionaries;
+}
+class _InternalEmptyPlaceholderRecordBatch extends RecordBatch3 {
+  constructor(schema) {
+    const children = schema.fields.map((f2) => makeData({ type: f2.type }));
+    const data = makeData({ type: new Struct(schema.fields), nullCount: 0, children });
+    super(schema, data);
+  }
+}
+const invalidMessageType = (type) => `Expected ${MessageHeader[type]} Message in stream, but was null or length 0.`;
+const nullMessage = (type) => `Header pointer of flatbuffer-encoded ${MessageHeader[type]} Message is null or length 0.`;
+const invalidMessageMetadata = (expected, actual) => `Expected to read ${expected} metadata bytes, but only read ${actual}.`;
+const invalidMessageBodyLength = (expected, actual) => `Expected to read ${expected} bytes for message body, but only read ${actual}.`;
+class MessageReader {
+  constructor(source2) {
+    this.source = source2 instanceof ByteStream ? source2 : new ByteStream(source2);
+  }
+  [Symbol.iterator]() {
+    return this;
+  }
+  next() {
+    let r2;
+    if ((r2 = this.readMetadataLength()).done) {
+      return ITERATOR_DONE;
+    }
+    if (r2.value === -1 && (r2 = this.readMetadataLength()).done) {
+      return ITERATOR_DONE;
+    }
+    if ((r2 = this.readMetadata(r2.value)).done) {
+      return ITERATOR_DONE;
+    }
+    return r2;
+  }
+  throw(value) {
+    return this.source.throw(value);
+  }
+  return(value) {
+    return this.source.return(value);
+  }
+  readMessage(type) {
+    let r2;
+    if ((r2 = this.next()).done) {
+      return null;
+    }
+    if (type != null && r2.value.headerType !== type) {
+      throw new Error(invalidMessageType(type));
+    }
+    return r2.value;
+  }
+  readMessageBody(bodyLength) {
+    if (bodyLength <= 0) {
+      return new Uint8Array(0);
+    }
+    const buf = toUint8Array(this.source.read(bodyLength));
+    if (buf.byteLength < bodyLength) {
+      throw new Error(invalidMessageBodyLength(bodyLength, buf.byteLength));
+    }
+    return (
+      /* 1. */
+      buf.byteOffset % 8 === 0 && /* 2. */
+      buf.byteOffset + buf.byteLength <= buf.buffer.byteLength ? buf : buf.slice()
+    );
+  }
+  readSchema(throwIfNull = false) {
+    const type = MessageHeader.Schema;
+    const message2 = this.readMessage(type);
+    const schema = message2 === null || message2 === void 0 ? void 0 : message2.header();
+    if (throwIfNull && !schema) {
+      throw new Error(nullMessage(type));
+    }
+    return schema;
+  }
+  readMetadataLength() {
+    const buf = this.source.read(PADDING);
+    const bb2 = buf && new ByteBuffer$2(buf);
+    const len2 = (bb2 === null || bb2 === void 0 ? void 0 : bb2.readInt32(0)) || 0;
+    return { done: len2 === 0, value: len2 };
+  }
+  readMetadata(metadataLength) {
+    const buf = this.source.read(metadataLength);
+    if (!buf) {
+      return ITERATOR_DONE;
+    }
+    if (buf.byteLength < metadataLength) {
+      throw new Error(invalidMessageMetadata(metadataLength, buf.byteLength));
+    }
+    return { done: false, value: Message2.decode(buf) };
+  }
+}
+class AsyncMessageReader {
+  constructor(source2, byteLength) {
+    this.source = source2 instanceof AsyncByteStream ? source2 : isFileHandle(source2) ? new AsyncRandomAccessFile(source2, byteLength) : new AsyncByteStream(source2);
+  }
+  [Symbol.asyncIterator]() {
+    return this;
+  }
+  next() {
+    return __awaiter(this, void 0, void 0, function* () {
+      let r2;
+      if ((r2 = yield this.readMetadataLength()).done) {
+        return ITERATOR_DONE;
+      }
+      if (r2.value === -1 && (r2 = yield this.readMetadataLength()).done) {
+        return ITERATOR_DONE;
+      }
+      if ((r2 = yield this.readMetadata(r2.value)).done) {
+        return ITERATOR_DONE;
+      }
+      return r2;
+    });
+  }
+  throw(value) {
+    return __awaiter(this, void 0, void 0, function* () {
+      return yield this.source.throw(value);
+    });
+  }
+  return(value) {
+    return __awaiter(this, void 0, void 0, function* () {
+      return yield this.source.return(value);
+    });
+  }
+  readMessage(type) {
+    return __awaiter(this, void 0, void 0, function* () {
+      let r2;
+      if ((r2 = yield this.next()).done) {
+        return null;
+      }
+      if (type != null && r2.value.headerType !== type) {
+        throw new Error(invalidMessageType(type));
+      }
+      return r2.value;
+    });
+  }
+  readMessageBody(bodyLength) {
+    return __awaiter(this, void 0, void 0, function* () {
+      if (bodyLength <= 0) {
+        return new Uint8Array(0);
+      }
+      const buf = toUint8Array(yield this.source.read(bodyLength));
+      if (buf.byteLength < bodyLength) {
+        throw new Error(invalidMessageBodyLength(bodyLength, buf.byteLength));
+      }
+      return (
+        /* 1. */
+        buf.byteOffset % 8 === 0 && /* 2. */
+        buf.byteOffset + buf.byteLength <= buf.buffer.byteLength ? buf : buf.slice()
+      );
+    });
+  }
+  readSchema() {
+    return __awaiter(this, arguments, void 0, function* (throwIfNull = false) {
+      const type = MessageHeader.Schema;
+      const message2 = yield this.readMessage(type);
+      const schema = message2 === null || message2 === void 0 ? void 0 : message2.header();
+      if (throwIfNull && !schema) {
+        throw new Error(nullMessage(type));
+      }
+      return schema;
+    });
+  }
+  readMetadataLength() {
+    return __awaiter(this, void 0, void 0, function* () {
+      const buf = yield this.source.read(PADDING);
+      const bb2 = buf && new ByteBuffer$2(buf);
+      const len2 = (bb2 === null || bb2 === void 0 ? void 0 : bb2.readInt32(0)) || 0;
+      return { done: len2 === 0, value: len2 };
+    });
+  }
+  readMetadata(metadataLength) {
+    return __awaiter(this, void 0, void 0, function* () {
+      const buf = yield this.source.read(metadataLength);
+      if (!buf) {
+        return ITERATOR_DONE;
+      }
+      if (buf.byteLength < metadataLength) {
+        throw new Error(invalidMessageMetadata(metadataLength, buf.byteLength));
+      }
+      return { done: false, value: Message2.decode(buf) };
+    });
+  }
+}
+class JSONMessageReader extends MessageReader {
+  constructor(source2) {
+    super(new Uint8Array(0));
+    this._schema = false;
+    this._body = [];
+    this._batchIndex = 0;
+    this._dictionaryIndex = 0;
+    this._json = source2 instanceof ArrowJSON ? source2 : new ArrowJSON(source2);
+  }
+  next() {
+    const { _json } = this;
+    if (!this._schema) {
+      this._schema = true;
+      const message2 = Message2.fromJSON(_json.schema, MessageHeader.Schema);
+      return { done: false, value: message2 };
+    }
+    if (this._dictionaryIndex < _json.dictionaries.length) {
+      const batch = _json.dictionaries[this._dictionaryIndex++];
+      this._body = batch["data"]["columns"];
+      const message2 = Message2.fromJSON(batch, MessageHeader.DictionaryBatch);
+      return { done: false, value: message2 };
+    }
+    if (this._batchIndex < _json.batches.length) {
+      const batch = _json.batches[this._batchIndex++];
+      this._body = batch["columns"];
+      const message2 = Message2.fromJSON(batch, MessageHeader.RecordBatch);
+      return { done: false, value: message2 };
+    }
+    this._body = [];
+    return ITERATOR_DONE;
+  }
+  readMessageBody(_bodyLength) {
+    return flattenDataSources(this._body);
+    function flattenDataSources(xs) {
+      return (xs || []).reduce((buffers, column) => [
+        ...buffers,
+        ...column["VALIDITY"] && [column["VALIDITY"]] || [],
+        ...column["TYPE_ID"] && [column["TYPE_ID"]] || [],
+        ...column["OFFSET"] && [column["OFFSET"]] || [],
+        ...column["DATA"] && [column["DATA"]] || [],
+        ...flattenDataSources(column["children"])
+      ], []);
+    }
+  }
+  readMessage(type) {
+    let r2;
+    if ((r2 = this.next()).done) {
+      return null;
+    }
+    if (type != null && r2.value.headerType !== type) {
+      throw new Error(invalidMessageType(type));
+    }
+    return r2.value;
+  }
+  readSchema() {
+    const type = MessageHeader.Schema;
+    const message2 = this.readMessage(type);
+    const schema = message2 === null || message2 === void 0 ? void 0 : message2.header();
+    if (!message2 || !schema) {
+      throw new Error(nullMessage(type));
+    }
+    return schema;
+  }
+}
+const PADDING = 4;
+const MAGIC_STR = "ARROW1";
+const MAGIC = new Uint8Array(MAGIC_STR.length);
+for (let i2 = 0; i2 < MAGIC_STR.length; i2 += 1) {
+  MAGIC[i2] = MAGIC_STR.codePointAt(i2);
+}
+function checkForMagicArrowString(buffer, index = 0) {
+  for (let i2 = -1, n2 = MAGIC.length; ++i2 < n2; ) {
+    if (MAGIC[i2] !== buffer[index + i2]) {
+      return false;
+    }
+  }
+  return true;
+}
+const magicLength = MAGIC.length;
+const magicAndPadding = magicLength + PADDING;
+const magicX2AndPadding = magicLength * 2 + PADDING;
+class Lz4FrameValidator {
+  constructor() {
+    this.LZ4_FRAME_MAGIC = new Uint8Array([4, 34, 77, 24]);
+    this.MIN_HEADER_LENGTH = 7;
+  }
+  isValidCodecEncode(codec) {
+    const testData = new Uint8Array([1, 2, 3, 4, 5, 6, 7, 8]);
+    const compressed = codec.encode(testData);
+    return this._isValidCompressed(compressed);
+  }
+  _isValidCompressed(buffer) {
+    return this._hasMinimumLength(buffer) && this._hasValidMagicNumber(buffer) && this._hasValidVersion(buffer);
+  }
+  _hasMinimumLength(buffer) {
+    return buffer.length >= this.MIN_HEADER_LENGTH;
+  }
+  _hasValidMagicNumber(buffer) {
+    return this.LZ4_FRAME_MAGIC.every((byte, i2) => buffer[i2] === byte);
+  }
+  _hasValidVersion(buffer) {
+    const flg = buffer[4];
+    const versionBits = (flg & 192) >> 6;
+    return versionBits === 1;
+  }
+}
+class ZstdValidator {
+  constructor() {
+    this.ZSTD_MAGIC = new Uint8Array([40, 181, 47, 253]);
+    this.MIN_HEADER_LENGTH = 6;
+  }
+  isValidCodecEncode(codec) {
+    const testData = new Uint8Array([1, 2, 3, 4, 5, 6, 7, 8]);
+    const compressed = codec.encode(testData);
+    return this._isValidCompressed(compressed);
+  }
+  _isValidCompressed(buffer) {
+    return this._hasMinimumLength(buffer) && this._hasValidMagicNumber(buffer);
+  }
+  _hasMinimumLength(buffer) {
+    return buffer.length >= this.MIN_HEADER_LENGTH;
+  }
+  _hasValidMagicNumber(buffer) {
+    return this.ZSTD_MAGIC.every((byte, i2) => buffer[i2] === byte);
+  }
+}
+const compressionValidators = {
+  [CompressionType.LZ4_FRAME]: new Lz4FrameValidator(),
+  [CompressionType.ZSTD]: new ZstdValidator()
+};
+class _CompressionRegistry {
+  constructor() {
+    this.registry = {};
+  }
+  set(compression, codec) {
+    if ((codec === null || codec === void 0 ? void 0 : codec.encode) && typeof codec.encode === "function" && !compressionValidators[compression].isValidCodecEncode(codec)) {
+      throw new Error(`Encoder for ${CompressionType[compression]} is not valid.`);
+    }
+    this.registry[compression] = codec;
+  }
+  get(compression) {
+    var _a3;
+    return ((_a3 = this.registry) === null || _a3 === void 0 ? void 0 : _a3[compression]) || null;
+  }
+}
+const compressionRegistry = new _CompressionRegistry();
+const LENGTH_NO_COMPRESSED_DATA = -1;
+const COMPRESS_LENGTH_PREFIX = 8;
+class RecordBatchReader extends ReadableInterop {
+  constructor(impl) {
+    super();
+    this._impl = impl;
+  }
+  get closed() {
+    return this._impl.closed;
+  }
+  get schema() {
+    return this._impl.schema;
+  }
+  get autoDestroy() {
+    return this._impl.autoDestroy;
+  }
+  get dictionaries() {
+    return this._impl.dictionaries;
+  }
+  get numDictionaries() {
+    return this._impl.numDictionaries;
+  }
+  get numRecordBatches() {
+    return this._impl.numRecordBatches;
+  }
+  get footer() {
+    return this._impl.isFile() ? this._impl.footer : null;
+  }
+  isSync() {
+    return this._impl.isSync();
+  }
+  isAsync() {
+    return this._impl.isAsync();
+  }
+  isFile() {
+    return this._impl.isFile();
+  }
+  isStream() {
+    return this._impl.isStream();
+  }
+  next() {
+    return this._impl.next();
+  }
+  throw(value) {
+    return this._impl.throw(value);
+  }
+  return(value) {
+    return this._impl.return(value);
+  }
+  cancel() {
+    return this._impl.cancel();
+  }
+  reset(schema) {
+    this._impl.reset(schema);
+    this._DOMStream = void 0;
+    this._nodeStream = void 0;
+    return this;
+  }
+  open(options) {
+    const opening = this._impl.open(options);
+    return isPromise(opening) ? opening.then(() => this) : this;
+  }
+  readRecordBatch(index) {
+    return this._impl.isFile() ? this._impl.readRecordBatch(index) : null;
+  }
+  [Symbol.iterator]() {
+    return this._impl[Symbol.iterator]();
+  }
+  [Symbol.asyncIterator]() {
+    return this._impl[Symbol.asyncIterator]();
+  }
+  toDOMStream() {
+    return streamAdapters.toDOMStream(this.isSync() ? { [Symbol.iterator]: () => this } : { [Symbol.asyncIterator]: () => this });
+  }
+  toNodeStream() {
+    return streamAdapters.toNodeStream(this.isSync() ? { [Symbol.iterator]: () => this } : { [Symbol.asyncIterator]: () => this }, { objectMode: true });
+  }
+  /** @nocollapse */
+  // @ts-ignore
+  static throughNode(options) {
+    throw new Error(`"throughNode" not available in this environment`);
+  }
+  /** @nocollapse */
+  static throughDOM(writableStrategy, readableStrategy) {
+    throw new Error(`"throughDOM" not available in this environment`);
+  }
+  /** @nocollapse */
+  static from(source2) {
+    if (source2 instanceof RecordBatchReader) {
+      return source2;
+    } else if (isArrowJSON(source2)) {
+      return fromArrowJSON(source2);
+    } else if (isFileHandle(source2)) {
+      return fromFileHandle(source2);
+    } else if (isPromise(source2)) {
+      return (() => __awaiter(this, void 0, void 0, function* () {
+        return yield RecordBatchReader.from(yield source2);
+      }))();
+    } else if (isFetchResponse(source2) || isReadableDOMStream$1(source2) || isReadableNodeStream$1(source2) || isAsyncIterable$2(source2)) {
+      return fromAsyncByteStream(new AsyncByteStream(source2));
+    }
+    return fromByteStream(new ByteStream(source2));
+  }
+  /** @nocollapse */
+  static readAll(source2) {
+    if (source2 instanceof RecordBatchReader) {
+      return source2.isSync() ? readAllSync(source2) : readAllAsync(source2);
+    } else if (isArrowJSON(source2) || ArrayBuffer.isView(source2) || isIterable$1(source2) || isIteratorResult(source2)) {
+      return readAllSync(source2);
+    }
+    return readAllAsync(source2);
+  }
+}
+class RecordBatchStreamReader extends RecordBatchReader {
+  constructor(_impl) {
+    super(_impl);
+    this._impl = _impl;
+  }
+  readAll() {
+    return [...this];
+  }
+  [Symbol.iterator]() {
+    return this._impl[Symbol.iterator]();
+  }
+  [Symbol.asyncIterator]() {
+    return __asyncGenerator(this, arguments, function* _a3() {
+      yield __await(yield* __asyncDelegator(__asyncValues(this[Symbol.iterator]())));
+    });
+  }
+}
+class AsyncRecordBatchStreamReader extends RecordBatchReader {
+  constructor(_impl) {
+    super(_impl);
+    this._impl = _impl;
+  }
+  readAll() {
+    return __awaiter(this, void 0, void 0, function* () {
+      var _a3, e_1, _b3, _c3;
+      const batches = new Array();
+      try {
+        for (var _d2 = true, _e2 = __asyncValues(this), _f2; _f2 = yield _e2.next(), _a3 = _f2.done, !_a3; _d2 = true) {
+          _c3 = _f2.value;
+          _d2 = false;
+          const batch = _c3;
+          batches.push(batch);
+        }
+      } catch (e_1_1) {
+        e_1 = { error: e_1_1 };
+      } finally {
+        try {
+          if (!_d2 && !_a3 && (_b3 = _e2.return)) yield _b3.call(_e2);
+        } finally {
+          if (e_1) throw e_1.error;
+        }
+      }
+      return batches;
+    });
+  }
+  [Symbol.iterator]() {
+    throw new Error(`AsyncRecordBatchStreamReader is not Iterable`);
+  }
+  [Symbol.asyncIterator]() {
+    return this._impl[Symbol.asyncIterator]();
+  }
+}
+class RecordBatchFileReader extends RecordBatchStreamReader {
+  constructor(_impl) {
+    super(_impl);
+    this._impl = _impl;
+  }
+}
+class AsyncRecordBatchFileReader extends AsyncRecordBatchStreamReader {
+  constructor(_impl) {
+    super(_impl);
+    this._impl = _impl;
+  }
+}
+class RecordBatchReaderImpl {
+  get numDictionaries() {
+    return this._dictionaryIndex;
+  }
+  get numRecordBatches() {
+    return this._recordBatchIndex;
+  }
+  constructor(dictionaries = /* @__PURE__ */ new Map()) {
+    this.closed = false;
+    this.autoDestroy = true;
+    this._dictionaryIndex = 0;
+    this._recordBatchIndex = 0;
+    this.dictionaries = dictionaries;
+  }
+  isSync() {
+    return false;
+  }
+  isAsync() {
+    return false;
+  }
+  isFile() {
+    return false;
+  }
+  isStream() {
+    return false;
+  }
+  reset(schema) {
+    this._dictionaryIndex = 0;
+    this._recordBatchIndex = 0;
+    this.schema = schema;
+    this.dictionaries = /* @__PURE__ */ new Map();
+    return this;
+  }
+  _loadRecordBatch(header, body) {
+    let children;
+    if (header.compression != null) {
+      const codec = compressionRegistry.get(header.compression.type);
+      if ((codec === null || codec === void 0 ? void 0 : codec.decode) && typeof codec.decode === "function") {
+        const { decommpressedBody, buffers } = this._decompressBuffers(header, body, codec);
+        children = this._loadCompressedVectors(header, decommpressedBody, this.schema.fields);
+        header = new RecordBatch$1(header.length, header.nodes, buffers, null);
+      } else {
+        throw new Error("Record batch is compressed but codec not found");
+      }
+    } else {
+      children = this._loadVectors(header, body, this.schema.fields);
+    }
+    const data = makeData({ type: new Struct(this.schema.fields), length: header.length, children });
+    return new RecordBatch3(this.schema, data);
+  }
+  _loadDictionaryBatch(header, body) {
+    const { id: id2, isDelta } = header;
+    const { dictionaries, schema } = this;
+    const dictionary = dictionaries.get(id2);
+    const type = schema.dictionaries.get(id2);
+    let data;
+    if (header.data.compression != null) {
+      const codec = compressionRegistry.get(header.data.compression.type);
+      if ((codec === null || codec === void 0 ? void 0 : codec.decode) && typeof codec.decode === "function") {
+        const { decommpressedBody, buffers } = this._decompressBuffers(header.data, body, codec);
+        data = this._loadCompressedVectors(header.data, decommpressedBody, [type]);
+        header = new DictionaryBatch2(new RecordBatch$1(header.data.length, header.data.nodes, buffers, null), id2, isDelta);
+      } else {
+        throw new Error("Dictionary batch is compressed but codec not found");
+      }
+    } else {
+      data = this._loadVectors(header.data, body, [type]);
+    }
+    return (dictionary && isDelta ? dictionary.concat(new Vector$1(data)) : new Vector$1(data)).memoize();
+  }
+  _loadVectors(header, body, types) {
+    return new VectorLoader(body, header.nodes, header.buffers, this.dictionaries, this.schema.metadataVersion).visitMany(types);
+  }
+  _loadCompressedVectors(header, body, types) {
+    return new CompressedVectorLoader(body, header.nodes, header.buffers, this.dictionaries, this.schema.metadataVersion).visitMany(types);
+  }
+  _decompressBuffers(header, body, codec) {
+    const decompressedBuffers = [];
+    const newBufferRegions = [];
+    let currentOffset = 0;
+    for (const { offset, length: length2 } of header.buffers) {
+      if (length2 === 0) {
+        decompressedBuffers.push(new Uint8Array(0));
+        newBufferRegions.push(new BufferRegion(currentOffset, 0));
+        continue;
+      }
+      const byteBuf = new ByteBuffer$2(body.subarray(offset, offset + length2));
+      const uncompressedLenth = bigIntToNumber(byteBuf.readInt64(0));
+      const bytes = byteBuf.bytes().subarray(COMPRESS_LENGTH_PREFIX);
+      const decompressed = uncompressedLenth === LENGTH_NO_COMPRESSED_DATA ? bytes : codec.decode(bytes);
+      decompressedBuffers.push(decompressed);
+      const padding = (currentOffset + 7 & -8) - currentOffset;
+      currentOffset += padding;
+      newBufferRegions.push(new BufferRegion(currentOffset, decompressed.length));
+      currentOffset += decompressed.length;
+    }
+    return {
+      decommpressedBody: decompressedBuffers,
+      buffers: newBufferRegions
+    };
+  }
+}
+class RecordBatchStreamReaderImpl extends RecordBatchReaderImpl {
+  constructor(source2, dictionaries) {
+    super(dictionaries);
+    this._reader = !isArrowJSON(source2) ? new MessageReader(this._handle = source2) : new JSONMessageReader(this._handle = source2);
+  }
+  isSync() {
+    return true;
+  }
+  isStream() {
+    return true;
+  }
+  [Symbol.iterator]() {
+    return this;
+  }
+  cancel() {
+    if (!this.closed && (this.closed = true)) {
+      this.reset()._reader.return();
+      this._reader = null;
+      this.dictionaries = null;
+    }
+  }
+  open(options) {
+    if (!this.closed) {
+      this.autoDestroy = shouldAutoDestroy(this, options);
+      if (!(this.schema || (this.schema = this._reader.readSchema()))) {
+        this.cancel();
+      }
+    }
+    return this;
+  }
+  throw(value) {
+    if (!this.closed && this.autoDestroy && (this.closed = true)) {
+      return this.reset()._reader.throw(value);
+    }
+    return ITERATOR_DONE;
+  }
+  return(value) {
+    if (!this.closed && this.autoDestroy && (this.closed = true)) {
+      return this.reset()._reader.return(value);
+    }
+    return ITERATOR_DONE;
+  }
+  next() {
+    if (this.closed) {
+      return ITERATOR_DONE;
+    }
+    let message2;
+    const { _reader: reader } = this;
+    while (message2 = this._readNextMessageAndValidate()) {
+      if (message2.isSchema()) {
+        this.reset(message2.header());
+      } else if (message2.isRecordBatch()) {
+        this._recordBatchIndex++;
+        const header = message2.header();
+        const buffer = reader.readMessageBody(message2.bodyLength);
+        const recordBatch = this._loadRecordBatch(header, buffer);
+        return { done: false, value: recordBatch };
+      } else if (message2.isDictionaryBatch()) {
+        this._dictionaryIndex++;
+        const header = message2.header();
+        const buffer = reader.readMessageBody(message2.bodyLength);
+        const vector = this._loadDictionaryBatch(header, buffer);
+        this.dictionaries.set(header.id, vector);
+      }
+    }
+    if (this.schema && this._recordBatchIndex === 0) {
+      this._recordBatchIndex++;
+      return { done: false, value: new _InternalEmptyPlaceholderRecordBatch(this.schema) };
+    }
+    return this.return();
+  }
+  _readNextMessageAndValidate(type) {
+    return this._reader.readMessage(type);
+  }
+}
+class AsyncRecordBatchStreamReaderImpl extends RecordBatchReaderImpl {
+  constructor(source2, dictionaries) {
+    super(dictionaries);
+    this._reader = new AsyncMessageReader(this._handle = source2);
+  }
+  isAsync() {
+    return true;
+  }
+  isStream() {
+    return true;
+  }
+  [Symbol.asyncIterator]() {
+    return this;
+  }
+  cancel() {
+    return __awaiter(this, void 0, void 0, function* () {
+      if (!this.closed && (this.closed = true)) {
+        yield this.reset()._reader.return();
+        this._reader = null;
+        this.dictionaries = null;
+      }
+    });
+  }
+  open(options) {
+    return __awaiter(this, void 0, void 0, function* () {
+      if (!this.closed) {
+        this.autoDestroy = shouldAutoDestroy(this, options);
+        if (!(this.schema || (this.schema = yield this._reader.readSchema()))) {
+          yield this.cancel();
+        }
+      }
+      return this;
+    });
+  }
+  throw(value) {
+    return __awaiter(this, void 0, void 0, function* () {
+      if (!this.closed && this.autoDestroy && (this.closed = true)) {
+        return yield this.reset()._reader.throw(value);
+      }
+      return ITERATOR_DONE;
+    });
+  }
+  return(value) {
+    return __awaiter(this, void 0, void 0, function* () {
+      if (!this.closed && this.autoDestroy && (this.closed = true)) {
+        return yield this.reset()._reader.return(value);
+      }
+      return ITERATOR_DONE;
+    });
+  }
+  next() {
+    return __awaiter(this, void 0, void 0, function* () {
+      if (this.closed) {
+        return ITERATOR_DONE;
+      }
+      let message2;
+      const { _reader: reader } = this;
+      while (message2 = yield this._readNextMessageAndValidate()) {
+        if (message2.isSchema()) {
+          yield this.reset(message2.header());
+        } else if (message2.isRecordBatch()) {
+          this._recordBatchIndex++;
+          const header = message2.header();
+          const buffer = yield reader.readMessageBody(message2.bodyLength);
+          const recordBatch = this._loadRecordBatch(header, buffer);
+          return { done: false, value: recordBatch };
+        } else if (message2.isDictionaryBatch()) {
+          this._dictionaryIndex++;
+          const header = message2.header();
+          const buffer = yield reader.readMessageBody(message2.bodyLength);
+          const vector = this._loadDictionaryBatch(header, buffer);
+          this.dictionaries.set(header.id, vector);
+        }
+      }
+      if (this.schema && this._recordBatchIndex === 0) {
+        this._recordBatchIndex++;
+        return { done: false, value: new _InternalEmptyPlaceholderRecordBatch(this.schema) };
+      }
+      return yield this.return();
+    });
+  }
+  _readNextMessageAndValidate(type) {
+    return __awaiter(this, void 0, void 0, function* () {
+      return yield this._reader.readMessage(type);
+    });
+  }
+}
+class RecordBatchFileReaderImpl extends RecordBatchStreamReaderImpl {
+  get footer() {
+    return this._footer;
+  }
+  get numDictionaries() {
+    return this._footer ? this._footer.numDictionaries : 0;
+  }
+  get numRecordBatches() {
+    return this._footer ? this._footer.numRecordBatches : 0;
+  }
+  constructor(source2, dictionaries) {
+    super(source2 instanceof RandomAccessFile ? source2 : new RandomAccessFile(source2), dictionaries);
+  }
+  isSync() {
+    return true;
+  }
+  isFile() {
+    return true;
+  }
+  open(options) {
+    if (!this.closed && !this._footer) {
+      this.schema = (this._footer = this._readFooter()).schema;
+      for (const block of this._footer.dictionaryBatches()) {
+        block && this._readDictionaryBatch(this._dictionaryIndex++);
+      }
+    }
+    return super.open(options);
+  }
+  readRecordBatch(index) {
+    var _a3;
+    if (this.closed) {
+      return null;
+    }
+    if (!this._footer) {
+      this.open();
+    }
+    const block = (_a3 = this._footer) === null || _a3 === void 0 ? void 0 : _a3.getRecordBatch(index);
+    if (block && this._handle.seek(block.offset)) {
+      const message2 = this._reader.readMessage(MessageHeader.RecordBatch);
+      if (message2 === null || message2 === void 0 ? void 0 : message2.isRecordBatch()) {
+        const header = message2.header();
+        const buffer = this._reader.readMessageBody(message2.bodyLength);
+        const recordBatch = this._loadRecordBatch(header, buffer);
+        return recordBatch;
+      }
+    }
+    return null;
+  }
+  _readDictionaryBatch(index) {
+    var _a3;
+    const block = (_a3 = this._footer) === null || _a3 === void 0 ? void 0 : _a3.getDictionaryBatch(index);
+    if (block && this._handle.seek(block.offset)) {
+      const message2 = this._reader.readMessage(MessageHeader.DictionaryBatch);
+      if (message2 === null || message2 === void 0 ? void 0 : message2.isDictionaryBatch()) {
+        const header = message2.header();
+        const buffer = this._reader.readMessageBody(message2.bodyLength);
+        const vector = this._loadDictionaryBatch(header, buffer);
+        this.dictionaries.set(header.id, vector);
+      }
+    }
+  }
+  _readFooter() {
+    const { _handle } = this;
+    const offset = _handle.size - magicAndPadding;
+    const length2 = _handle.readInt32(offset);
+    const buffer = _handle.readAt(offset - length2, length2);
+    return Footer_.decode(buffer);
+  }
+  _readNextMessageAndValidate(type) {
+    var _a3;
+    if (!this._footer) {
+      this.open();
+    }
+    if (this._footer && this._recordBatchIndex < this.numRecordBatches) {
+      const block = (_a3 = this._footer) === null || _a3 === void 0 ? void 0 : _a3.getRecordBatch(this._recordBatchIndex);
+      if (block && this._handle.seek(block.offset)) {
+        return this._reader.readMessage(type);
+      }
+    }
+    return null;
+  }
+}
+class AsyncRecordBatchFileReaderImpl extends AsyncRecordBatchStreamReaderImpl {
+  get footer() {
+    return this._footer;
+  }
+  get numDictionaries() {
+    return this._footer ? this._footer.numDictionaries : 0;
+  }
+  get numRecordBatches() {
+    return this._footer ? this._footer.numRecordBatches : 0;
+  }
+  constructor(source2, ...rest) {
+    const byteLength = typeof rest[0] !== "number" ? rest.shift() : void 0;
+    const dictionaries = rest[0] instanceof Map ? rest.shift() : void 0;
+    super(source2 instanceof AsyncRandomAccessFile ? source2 : new AsyncRandomAccessFile(source2, byteLength), dictionaries);
+  }
+  isFile() {
+    return true;
+  }
+  isAsync() {
+    return true;
+  }
+  open(options) {
+    const _super = Object.create(null, {
+      open: { get: () => super.open }
+    });
+    return __awaiter(this, void 0, void 0, function* () {
+      if (!this.closed && !this._footer) {
+        this.schema = (this._footer = yield this._readFooter()).schema;
+        for (const block of this._footer.dictionaryBatches()) {
+          block && (yield this._readDictionaryBatch(this._dictionaryIndex++));
+        }
+      }
+      return yield _super.open.call(this, options);
+    });
+  }
+  readRecordBatch(index) {
+    return __awaiter(this, void 0, void 0, function* () {
+      var _a3;
+      if (this.closed) {
+        return null;
+      }
+      if (!this._footer) {
+        yield this.open();
+      }
+      const block = (_a3 = this._footer) === null || _a3 === void 0 ? void 0 : _a3.getRecordBatch(index);
+      if (block && (yield this._handle.seek(block.offset))) {
+        const message2 = yield this._reader.readMessage(MessageHeader.RecordBatch);
+        if (message2 === null || message2 === void 0 ? void 0 : message2.isRecordBatch()) {
+          const header = message2.header();
+          const buffer = yield this._reader.readMessageBody(message2.bodyLength);
+          const recordBatch = this._loadRecordBatch(header, buffer);
+          return recordBatch;
+        }
+      }
+      return null;
+    });
+  }
+  _readDictionaryBatch(index) {
+    return __awaiter(this, void 0, void 0, function* () {
+      var _a3;
+      const block = (_a3 = this._footer) === null || _a3 === void 0 ? void 0 : _a3.getDictionaryBatch(index);
+      if (block && (yield this._handle.seek(block.offset))) {
+        const message2 = yield this._reader.readMessage(MessageHeader.DictionaryBatch);
+        if (message2 === null || message2 === void 0 ? void 0 : message2.isDictionaryBatch()) {
+          const header = message2.header();
+          const buffer = yield this._reader.readMessageBody(message2.bodyLength);
+          const vector = this._loadDictionaryBatch(header, buffer);
+          this.dictionaries.set(header.id, vector);
+        }
+      }
+    });
+  }
+  _readFooter() {
+    return __awaiter(this, void 0, void 0, function* () {
+      const { _handle } = this;
+      _handle._pending && (yield _handle._pending);
+      const offset = _handle.size - magicAndPadding;
+      const length2 = yield _handle.readInt32(offset);
+      const buffer = yield _handle.readAt(offset - length2, length2);
+      return Footer_.decode(buffer);
+    });
+  }
+  _readNextMessageAndValidate(type) {
+    return __awaiter(this, void 0, void 0, function* () {
+      if (!this._footer) {
+        yield this.open();
+      }
+      if (this._footer && this._recordBatchIndex < this.numRecordBatches) {
+        const block = this._footer.getRecordBatch(this._recordBatchIndex);
+        if (block && (yield this._handle.seek(block.offset))) {
+          return yield this._reader.readMessage(type);
+        }
+      }
+      return null;
+    });
+  }
+}
+class RecordBatchJSONReaderImpl extends RecordBatchStreamReaderImpl {
+  constructor(source2, dictionaries) {
+    super(source2, dictionaries);
+  }
+  _loadVectors(header, body, types) {
+    return new JSONVectorLoader(body, header.nodes, header.buffers, this.dictionaries, this.schema.metadataVersion).visitMany(types);
+  }
+}
+function shouldAutoDestroy(self2, options) {
+  return options && typeof options["autoDestroy"] === "boolean" ? options["autoDestroy"] : self2["autoDestroy"];
+}
+function* readAllSync(source2) {
+  const reader = RecordBatchReader.from(source2);
+  try {
+    if (!reader.open({ autoDestroy: false }).closed) {
+      do {
+        yield reader;
+      } while (!reader.reset().open().closed);
+    }
+  } finally {
+    reader.cancel();
+  }
+}
+function readAllAsync(source2) {
+  return __asyncGenerator(this, arguments, function* readAllAsync_1() {
+    const reader = yield __await(RecordBatchReader.from(source2));
+    try {
+      if (!(yield __await(reader.open({ autoDestroy: false }))).closed) {
+        do {
+          yield yield __await(reader);
+        } while (!(yield __await(reader.reset().open())).closed);
+      }
+    } finally {
+      yield __await(reader.cancel());
+    }
+  });
+}
+function fromArrowJSON(source2) {
+  return new RecordBatchStreamReader(new RecordBatchJSONReaderImpl(source2));
+}
+function fromByteStream(source2) {
+  const bytes = source2.peek(magicLength + 7 & -8);
+  return bytes && bytes.byteLength >= 4 ? !checkForMagicArrowString(bytes) ? new RecordBatchStreamReader(new RecordBatchStreamReaderImpl(source2)) : new RecordBatchFileReader(new RecordBatchFileReaderImpl(source2.read())) : new RecordBatchStreamReader(new RecordBatchStreamReaderImpl(function* () {
+  }()));
+}
+function fromAsyncByteStream(source2) {
+  return __awaiter(this, void 0, void 0, function* () {
+    const bytes = yield source2.peek(magicLength + 7 & -8);
+    return bytes && bytes.byteLength >= 4 ? !checkForMagicArrowString(bytes) ? new AsyncRecordBatchStreamReader(new AsyncRecordBatchStreamReaderImpl(source2)) : new RecordBatchFileReader(new RecordBatchFileReaderImpl(yield source2.read())) : new AsyncRecordBatchStreamReader(new AsyncRecordBatchStreamReaderImpl(function() {
+      return __asyncGenerator(this, arguments, function* () {
+      });
+    }()));
+  });
+}
+function fromFileHandle(source2) {
+  return __awaiter(this, void 0, void 0, function* () {
+    const { size } = yield source2.stat();
+    const file = new AsyncRandomAccessFile(source2, size);
+    if (size >= magicX2AndPadding && checkForMagicArrowString(yield file.readAt(0, magicLength + 7 & -8))) {
+      return new AsyncRecordBatchFileReader(new AsyncRecordBatchFileReaderImpl(file));
+    }
+    return new AsyncRecordBatchStreamReader(new AsyncRecordBatchStreamReaderImpl(file));
+  });
+}
+function tableFromIPC(input) {
+  const reader = RecordBatchReader.from(input);
+  if (isPromise(reader)) {
+    return reader.then((reader2) => tableFromIPC(reader2));
+  }
+  if (reader.isAsync()) {
+    return reader.readAll().then((xs) => new Table(xs));
+  }
+  return new Table(reader.readAll());
+}
+function usePointsApi() {
+  const fetchPointLayers = reactExports.useCallback(async () => {
+    const response = await fetch("/points/layers");
+    if (!response.ok) throw new Error(`${response.status}`);
+    return await response.json();
+  }, []);
+  const fetchPointAttributes = reactExports.useCallback(async (layerName) => {
+    const response = await fetch(`/points/${layerName}/attributes`);
+    if (!response.ok) throw new Error(`${response.status}`);
+    return await response.json();
+  }, []);
+  const fetchPoints = reactExports.useCallback(async (layerName, opts = {}) => {
+    const params = new URLSearchParams();
+    if (opts.bbox) {
+      params.set("bbox", opts.bbox.join(","));
+    }
+    if (opts.colorBy) {
+      params.set("color_by", opts.colorBy);
+    }
+    if (opts.filter) {
+      params.set("filter", opts.filter);
+    }
+    if (opts.maxPoints) {
+      params.set("max_points", opts.maxPoints.toString());
+    }
+    const response = await fetch(`/points/${layerName}?${params}`);
+    if (!response.ok) throw new Error(`${response.status}`);
+    const buffer = await response.arrayBuffer();
+    const table = tableFromIPC(new Uint8Array(buffer));
+    const pointIds = table.getChild("point_id");
+    const lons = table.getChild("lon");
+    const lats = table.getChild("lat");
+    const colorCol = table.schema.fields[3];
+    const colorValues = table.getChild(colorCol.name);
+    return {
+      point_id: Array.from(pointIds),
+      lon: Array.from(lons),
+      lat: Array.from(lats),
+      colorValues: Array.from(colorValues),
+      count: table.numRows
+    };
+  }, []);
+  const fetchPointTimeseries = reactExports.useCallback(async (layerName, pointId) => {
+    const response = await fetch(`/points/${layerName}/${pointId}/timeseries`);
+    return await response.json();
+  }, []);
+  const fetchMultiPointTimeseries = reactExports.useCallback(async (layerName, pointIds) => {
+    const response = await fetch(`/points/${layerName}/timeseries`, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({ point_ids: pointIds })
+    });
+    const data = await response.json();
+    return data.series;
+  }, []);
+  const fetchPointStats = reactExports.useCallback(async (layerName, bbox) => {
+    const params = new URLSearchParams();
+    if (bbox) {
+      params.set("bbox", bbox.join(","));
+    }
+    const response = await fetch(`/points/${layerName}/stats?${params}`);
+    return await response.json();
+  }, []);
+  return {
+    fetchPointLayers,
+    fetchPointAttributes,
+    fetchPoints,
+    fetchPointTimeseries,
+    fetchMultiPointTimeseries,
+    fetchPointStats
+  };
+}
+function useGpsApi() {
+  const fetchLosInfo = reactExports.useCallback(async () => {
+    const response = await fetch("/gps/los_info");
+    if (!response.ok) return null;
+    return await response.json();
+  }, []);
+  const fetchGpsStations = reactExports.useCallback(async (bbox) => {
+    const [west, south, east, north] = bbox;
+    const response = await fetch(`/gps/stations?bbox=${west},${south},${east},${north}`);
+    if (!response.ok) return [];
+    return await response.json();
+  }, []);
+  const fetchGpsTimeseries = reactExports.useCallback(async (stationId) => {
+    const response = await fetch(`/gps/stations/${stationId}/timeseries`);
+    if (!response.ok) return null;
+    return await response.json();
+  }, []);
+  return { fetchLosInfo, fetchGpsStations, fetchGpsTimeseries };
+}
+const URL_KEYS = [
+  "colorBy",
+  "vmin",
+  "vmax",
+  "colormap",
+  "basemap",
+  "filter",
+  "lat",
+  "lon",
+  "zoom",
+  "theme"
+];
+function parseUrlState() {
+  const params = new URLSearchParams(window.location.search);
+  const result = {};
+  for (const key of URL_KEYS) {
+    const val = params.get(key);
+    if (val !== null) result[key] = val;
+  }
+  return result;
+}
+function useUrlStateSync() {
+  const { state } = useAppContext();
+  const isFirstRender = reactExports.useRef(true);
+  reactExports.useEffect(() => {
+    if (isFirstRender.current) {
+      isFirstRender.current = false;
+      return;
+    }
+    const params = new URLSearchParams(window.location.search);
+    const setOrDelete = (key, value, isDefault) => {
+      if (isDefault) {
+        params.delete(key);
+      } else {
+        params.set(key, value);
+      }
+    };
+    setOrDelete("colorBy", state.pointColorBy, !state.pointColorBy || state.pointColorBy === "velocity");
+    setOrDelete("vmin", state.pointVmin.toFixed(2), state.pointVmin === -10);
+    setOrDelete("vmax", state.pointVmax.toFixed(2), state.pointVmax === 10);
+    setOrDelete("colormap", state.pointColormap, state.pointColormap === "rdbu_r");
+    setOrDelete("basemap", state.pointBasemap, state.pointBasemap === "satellite");
+    setOrDelete("filter", state.pointFilter, !state.pointFilter);
+    setOrDelete("theme", state.chartTheme, state.chartTheme === "dark");
+    const search = params.toString();
+    const url = search ? `?${search}` : window.location.pathname;
+    window.history.replaceState(null, "", url);
+  }, [
+    state.pointColorBy,
+    state.pointVmin,
+    state.pointVmax,
+    state.pointColormap,
+    state.pointBasemap,
+    state.pointFilter,
+    state.chartTheme
+  ]);
+}
+function applyUrlState(dispatch, urlState) {
+  if (urlState.colorBy) {
+    dispatch({ type: "SET_POINT_COLOR_BY", payload: urlState.colorBy });
+  }
+  if (urlState.vmin) {
+    dispatch({ type: "SET_POINT_VMIN", payload: parseFloat(urlState.vmin) });
+  }
+  if (urlState.vmax) {
+    dispatch({ type: "SET_POINT_VMAX", payload: parseFloat(urlState.vmax) });
+  }
+  if (urlState.colormap) {
+    dispatch({ type: "SET_POINT_COLORMAP", payload: urlState.colormap });
+  }
+  if (urlState.basemap) {
+    dispatch({ type: "SET_POINT_BASEMAP", payload: urlState.basemap });
+  }
+  if (urlState.filter) {
+    dispatch({ type: "SET_POINT_FILTER", payload: urlState.filter });
+  }
+  if (urlState.theme === "light") {
+    dispatch({ type: "SET_CHART_THEME", payload: "light" });
+  }
+}
+var maplibreGl = { exports: {} };
+/**
+ * MapLibre GL JS
+ * @license 3-Clause BSD. Full text of license: https://github.com/maplibre/maplibre-gl-js/blob/v5.21.0/LICENSE.txt
+ */
+(function(module, exports) {
+  (function(global2, factory2) {
+    module.exports = factory2();
+  })(commonjsGlobal, function() {
+    var maplibregl2 = {};
+    var modules = {};
+    function define(moduleName, _dependencies, moduleFactory) {
+      modules[moduleName] = moduleFactory;
+      if (moduleName !== "index") {
+        return;
+      }
+      var workerBundleString = "var sharedModule = {}; (" + modules.shared + ")(sharedModule); (" + modules.worker + ")(sharedModule);";
+      var sharedModule = {};
+      modules.shared(sharedModule);
+      modules.index(maplibregl2, sharedModule);
+      if (typeof window !== "undefined") {
+        maplibregl2.setWorkerUrl(window.URL.createObjectURL(new Blob([workerBundleString], { type: "text/javascript" })));
+      }
+      return maplibregl2;
+    }
+    define("shared", ["exports"], function(t2) {
+      function e2(t3, e3, n3, r3) {
+        return new (n3 || (n3 = Promise))(function(i3, s3) {
+          function o3(t4) {
+            try {
+              l3(r3.next(t4));
+            } catch (t5) {
+              s3(t5);
+            }
+          }
+          function a3(t4) {
+            try {
+              l3(r3.throw(t4));
+            } catch (t5) {
+              s3(t5);
+            }
+          }
+          function l3(t4) {
+            var e4;
+            t4.done ? i3(t4.value) : (e4 = t4.value, e4 instanceof n3 ? e4 : new n3(function(t5) {
+              t5(e4);
+            })).then(o3, a3);
+          }
+          l3((r3 = r3.apply(t3, e3 || [])).next());
+        });
+      }
+      function n2(t3, e3) {
+        this.x = t3, this.y = e3;
+      }
+      function r2(t3) {
+        return t3 && t3.__esModule && Object.prototype.hasOwnProperty.call(t3, "default") ? t3.default : t3;
+      }
+      var i2, s2;
+      "function" == typeof SuppressedError && SuppressedError, n2.prototype = { clone() {
+        return new n2(this.x, this.y);
+      }, add(t3) {
+        return this.clone()._add(t3);
+      }, sub(t3) {
+        return this.clone()._sub(t3);
+      }, multByPoint(t3) {
+        return this.clone()._multByPoint(t3);
+      }, divByPoint(t3) {
+        return this.clone()._divByPoint(t3);
+      }, mult(t3) {
+        return this.clone()._mult(t3);
+      }, div(t3) {
+        return this.clone()._div(t3);
+      }, rotate(t3) {
+        return this.clone()._rotate(t3);
+      }, rotateAround(t3, e3) {
+        return this.clone()._rotateAround(t3, e3);
+      }, matMult(t3) {
+        return this.clone()._matMult(t3);
+      }, unit() {
+        return this.clone()._unit();
+      }, perp() {
+        return this.clone()._perp();
+      }, round() {
+        return this.clone()._round();
+      }, mag() {
+        return Math.sqrt(this.x * this.x + this.y * this.y);
+      }, equals(t3) {
+        return this.x === t3.x && this.y === t3.y;
+      }, dist(t3) {
+        return Math.sqrt(this.distSqr(t3));
+      }, distSqr(t3) {
+        const e3 = t3.x - this.x, n3 = t3.y - this.y;
+        return e3 * e3 + n3 * n3;
+      }, angle() {
+        return Math.atan2(this.y, this.x);
+      }, angleTo(t3) {
+        return Math.atan2(this.y - t3.y, this.x - t3.x);
+      }, angleWith(t3) {
+        return this.angleWithSep(t3.x, t3.y);
+      }, angleWithSep(t3, e3) {
+        return Math.atan2(this.x * e3 - this.y * t3, this.x * t3 + this.y * e3);
+      }, _matMult(t3) {
+        const e3 = t3[2] * this.x + t3[3] * this.y;
+        return this.x = t3[0] * this.x + t3[1] * this.y, this.y = e3, this;
+      }, _add(t3) {
+        return this.x += t3.x, this.y += t3.y, this;
+      }, _sub(t3) {
+        return this.x -= t3.x, this.y -= t3.y, this;
+      }, _mult(t3) {
+        return this.x *= t3, this.y *= t3, this;
+      }, _div(t3) {
+        return this.x /= t3, this.y /= t3, this;
+      }, _multByPoint(t3) {
+        return this.x *= t3.x, this.y *= t3.y, this;
+      }, _divByPoint(t3) {
+        return this.x /= t3.x, this.y /= t3.y, this;
+      }, _unit() {
+        return this._div(this.mag()), this;
+      }, _perp() {
+        const t3 = this.y;
+        return this.y = this.x, this.x = -t3, this;
+      }, _rotate(t3) {
+        const e3 = Math.cos(t3), n3 = Math.sin(t3), r3 = n3 * this.x + e3 * this.y;
+        return this.x = e3 * this.x - n3 * this.y, this.y = r3, this;
+      }, _rotateAround(t3, e3) {
+        const n3 = Math.cos(t3), r3 = Math.sin(t3), i3 = e3.y + r3 * (this.x - e3.x) + n3 * (this.y - e3.y);
+        return this.x = e3.x + n3 * (this.x - e3.x) - r3 * (this.y - e3.y), this.y = i3, this;
+      }, _round() {
+        return this.x = Math.round(this.x), this.y = Math.round(this.y), this;
+      }, constructor: n2 }, n2.convert = function(t3) {
+        if (t3 instanceof n2) return t3;
+        if (Array.isArray(t3)) return new n2(+t3[0], +t3[1]);
+        if (void 0 !== t3.x && void 0 !== t3.y) return new n2(+t3.x, +t3.y);
+        throw new Error("Expected [x, y] or {x, y} point format");
+      };
+      var o2 = function() {
+        if (s2) return i2;
+        function t3(t4, e3, n3, r3) {
+          this.cx = 3 * t4, this.bx = 3 * (n3 - t4) - this.cx, this.ax = 1 - this.cx - this.bx, this.cy = 3 * e3, this.by = 3 * (r3 - e3) - this.cy, this.ay = 1 - this.cy - this.by, this.p1x = t4, this.p1y = e3, this.p2x = n3, this.p2y = r3;
+        }
+        return s2 = 1, i2 = t3, t3.prototype = { sampleCurveX: function(t4) {
+          return ((this.ax * t4 + this.bx) * t4 + this.cx) * t4;
+        }, sampleCurveY: function(t4) {
+          return ((this.ay * t4 + this.by) * t4 + this.cy) * t4;
+        }, sampleCurveDerivativeX: function(t4) {
+          return (3 * this.ax * t4 + 2 * this.bx) * t4 + this.cx;
+        }, solveCurveX: function(t4, e3) {
+          if (void 0 === e3 && (e3 = 1e-6), t4 < 0) return 0;
+          if (t4 > 1) return 1;
+          for (var n3 = t4, r3 = 0; r3 < 8; r3++) {
+            var i3 = this.sampleCurveX(n3) - t4;
+            if (Math.abs(i3) < e3) return n3;
+            var s3 = this.sampleCurveDerivativeX(n3);
+            if (Math.abs(s3) < 1e-6) break;
+            n3 -= i3 / s3;
+          }
+          var o3 = 0, a3 = 1;
+          for (n3 = t4, r3 = 0; r3 < 20 && (i3 = this.sampleCurveX(n3), !(Math.abs(i3 - t4) < e3)); r3++) t4 > i3 ? o3 = n3 : a3 = n3, n3 = 0.5 * (a3 - o3) + o3;
+          return n3;
+        }, solve: function(t4, e3) {
+          return this.sampleCurveY(this.solveCurveX(t4, e3));
+        } }, i2;
+      }(), a2 = r2(o2);
+      let l2, u2;
+      function c2() {
+        return null == l2 && (l2 = "undefined" != typeof OffscreenCanvas && new OffscreenCanvas(1, 1).getContext("2d") && "function" == typeof createImageBitmap), l2;
+      }
+      function h2() {
+        if (null == u2 && (u2 = false, c2())) {
+          const t3 = 5, e3 = new OffscreenCanvas(t3, t3).getContext("2d", { willReadFrequently: true });
+          if (e3) {
+            for (let n4 = 0; n4 < t3 * t3; n4++) {
+              const r3 = 4 * n4;
+              e3.fillStyle = `rgb(${r3},${r3 + 1},${r3 + 2})`, e3.fillRect(n4 % t3, Math.floor(n4 / t3), 1, 1);
+            }
+            const n3 = e3.getImageData(0, 0, t3, t3).data;
+            for (let e4 = 0; e4 < t3 * t3 * 4; e4++) if (e4 % 4 != 3 && n3[e4] !== e4) {
+              u2 = true;
+              break;
+            }
+          }
+        }
+        return u2 || false;
+      }
+      var p2 = 1e-6, f2 = "undefined" != typeof Float32Array ? Float32Array : Array;
+      function d2() {
+        var t3 = new f2(9);
+        return f2 != Float32Array && (t3[1] = 0, t3[2] = 0, t3[3] = 0, t3[5] = 0, t3[6] = 0, t3[7] = 0), t3[0] = 1, t3[4] = 1, t3[8] = 1, t3;
+      }
+      function y2(t3) {
+        return t3[0] = 1, t3[1] = 0, t3[2] = 0, t3[3] = 0, t3[4] = 0, t3[5] = 1, t3[6] = 0, t3[7] = 0, t3[8] = 0, t3[9] = 0, t3[10] = 1, t3[11] = 0, t3[12] = 0, t3[13] = 0, t3[14] = 0, t3[15] = 1, t3;
+      }
+      function m2() {
+        var t3 = new f2(3);
+        return f2 != Float32Array && (t3[0] = 0, t3[1] = 0, t3[2] = 0), t3;
+      }
+      function g2(t3) {
+        var e3 = t3[0], n3 = t3[1], r3 = t3[2];
+        return Math.sqrt(e3 * e3 + n3 * n3 + r3 * r3);
+      }
+      function x2(t3, e3, n3) {
+        var r3 = new f2(3);
+        return r3[0] = t3, r3[1] = e3, r3[2] = n3, r3;
+      }
+      function v2(t3, e3, n3) {
+        return t3[0] = e3[0] + n3[0], t3[1] = e3[1] + n3[1], t3[2] = e3[2] + n3[2], t3;
+      }
+      function b2(t3, e3, n3) {
+        return t3[0] = e3[0] * n3, t3[1] = e3[1] * n3, t3[2] = e3[2] * n3, t3;
+      }
+      function w2(t3, e3, n3) {
+        var r3 = e3[0], i3 = e3[1], s3 = e3[2], o3 = n3[0], a3 = n3[1], l3 = n3[2];
+        return t3[0] = i3 * l3 - s3 * a3, t3[1] = s3 * o3 - r3 * l3, t3[2] = r3 * a3 - i3 * o3, t3;
+      }
+      var _2, S2 = g2;
+      function A2(t3, e3, n3) {
+        var r3 = e3[0], i3 = e3[1], s3 = e3[2], o3 = e3[3];
+        return t3[0] = n3[0] * r3 + n3[4] * i3 + n3[8] * s3 + n3[12] * o3, t3[1] = n3[1] * r3 + n3[5] * i3 + n3[9] * s3 + n3[13] * o3, t3[2] = n3[2] * r3 + n3[6] * i3 + n3[10] * s3 + n3[14] * o3, t3[3] = n3[3] * r3 + n3[7] * i3 + n3[11] * s3 + n3[15] * o3, t3;
+      }
+      function M2() {
+        var t3 = new f2(4);
+        return f2 != Float32Array && (t3[0] = 0, t3[1] = 0, t3[2] = 0), t3[3] = 1, t3;
+      }
+      function k2(t3, e3, n3, r3) {
+        var i3 = arguments.length > 4 && void 0 !== arguments[4] ? arguments[4] : "zyx", s3 = Math.PI / 360;
+        e3 *= s3, r3 *= s3, n3 *= s3;
+        var o3 = Math.sin(e3), a3 = Math.cos(e3), l3 = Math.sin(n3), u3 = Math.cos(n3), c3 = Math.sin(r3), h3 = Math.cos(r3);
+        switch (i3) {
+          case "xyz":
+            t3[0] = o3 * u3 * h3 + a3 * l3 * c3, t3[1] = a3 * l3 * h3 - o3 * u3 * c3, t3[2] = a3 * u3 * c3 + o3 * l3 * h3, t3[3] = a3 * u3 * h3 - o3 * l3 * c3;
+            break;
+          case "xzy":
+            t3[0] = o3 * u3 * h3 - a3 * l3 * c3, t3[1] = a3 * l3 * h3 - o3 * u3 * c3, t3[2] = a3 * u3 * c3 + o3 * l3 * h3, t3[3] = a3 * u3 * h3 + o3 * l3 * c3;
+            break;
+          case "yxz":
+            t3[0] = o3 * u3 * h3 + a3 * l3 * c3, t3[1] = a3 * l3 * h3 - o3 * u3 * c3, t3[2] = a3 * u3 * c3 - o3 * l3 * h3, t3[3] = a3 * u3 * h3 + o3 * l3 * c3;
+            break;
+          case "yzx":
+            t3[0] = o3 * u3 * h3 + a3 * l3 * c3, t3[1] = a3 * l3 * h3 + o3 * u3 * c3, t3[2] = a3 * u3 * c3 - o3 * l3 * h3, t3[3] = a3 * u3 * h3 - o3 * l3 * c3;
+            break;
+          case "zxy":
+            t3[0] = o3 * u3 * h3 - a3 * l3 * c3, t3[1] = a3 * l3 * h3 + o3 * u3 * c3, t3[2] = a3 * u3 * c3 + o3 * l3 * h3, t3[3] = a3 * u3 * h3 - o3 * l3 * c3;
+            break;
+          case "zyx":
+            t3[0] = o3 * u3 * h3 - a3 * l3 * c3, t3[1] = a3 * l3 * h3 + o3 * u3 * c3, t3[2] = a3 * u3 * c3 - o3 * l3 * h3, t3[3] = a3 * u3 * h3 + o3 * l3 * c3;
+            break;
+          default:
+            throw new Error("Unknown angle order " + i3);
+        }
+        return t3;
+      }
+      function I2() {
+        var t3 = new f2(2);
+        return f2 != Float32Array && (t3[0] = 0, t3[1] = 0), t3;
+      }
+      function E2(t3, e3) {
+        var n3 = new f2(2);
+        return n3[0] = t3, n3[1] = e3, n3;
+      }
+      m2(), _2 = new f2(4), f2 != Float32Array && (_2[0] = 0, _2[1] = 0, _2[2] = 0, _2[3] = 0), m2(), x2(1, 0, 0), x2(0, 1, 0), M2(), M2(), d2(), I2();
+      const T2 = 8192;
+      function F2(t3, e3, n3) {
+        return e3 * (T2 / (t3.tileSize * Math.pow(2, n3 - t3.tileID.overscaledZ)));
+      }
+      function D2(t3, e3) {
+        return (t3 % e3 + e3) % e3;
+      }
+      function P2(t3, e3, n3) {
+        return t3 * (1 - n3) + e3 * n3;
+      }
+      function z2(t3) {
+        if (t3 <= 0) return 0;
+        if (t3 >= 1) return 1;
+        const e3 = t3 * t3, n3 = e3 * t3;
+        return 4 * (t3 < 0.5 ? n3 : 3 * (t3 - e3) + n3 - 0.75);
+      }
+      function B2(t3, e3, n3, r3) {
+        const i3 = new a2(t3, e3, n3, r3);
+        return (t4) => i3.solve(t4);
+      }
+      const C2 = B2(0.25, 0.1, 0.25, 1);
+      function V2(t3, e3, n3) {
+        return Math.min(n3, Math.max(e3, t3));
+      }
+      function L2(t3, e3, n3) {
+        const r3 = n3 - e3, i3 = ((t3 - e3) % r3 + r3) % r3 + e3;
+        return i3 === e3 ? n3 : i3;
+      }
+      function O2(t3, ...e3) {
+        for (const n3 of e3) for (const e4 in n3) t3[e4] = n3[e4];
+        return t3;
+      }
+      let $2 = 1;
+      function R2(t3, e3, n3) {
+        const r3 = {};
+        for (const n4 in t3) r3[n4] = e3.call(this, t3[n4], n4, t3);
+        return r3;
+      }
+      function N2(t3, e3, n3) {
+        const r3 = {};
+        for (const n4 in t3) e3.call(this, t3[n4], n4, t3) && (r3[n4] = t3[n4]);
+        return r3;
+      }
+      function U2(t3) {
+        return Array.isArray(t3) ? t3.map(U2) : "object" == typeof t3 && t3 ? R2(t3, U2) : t3;
+      }
+      const j2 = {};
+      function q2(t3) {
+        j2[t3] || ("undefined" != typeof console && console.warn(t3), j2[t3] = true);
+      }
+      function G2(t3, e3, n3) {
+        return (n3.y - t3.y) * (e3.x - t3.x) > (e3.y - t3.y) * (n3.x - t3.x);
+      }
+      function X2(t3) {
+        return "undefined" != typeof WorkerGlobalScope && void 0 !== t3 && t3 instanceof WorkerGlobalScope;
+      }
+      let Y2 = null;
+      function Z2(t3) {
+        return "undefined" != typeof ImageBitmap && t3 instanceof ImageBitmap;
+      }
+      const H2 = "data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAYAAAAfFcSJAAAAC0lEQVQYV2NgAAIAAAUAAarVyFEAAAAASUVORK5CYII=";
+      function W2(t3, n3, r3, i3, s3) {
+        return e2(this, void 0, void 0, function* () {
+          if ("undefined" == typeof VideoFrame) throw new Error("VideoFrame not supported");
+          const e3 = new VideoFrame(t3, { timestamp: 0 });
+          try {
+            const o3 = null == e3 ? void 0 : e3.format;
+            if (!o3 || !o3.startsWith("BGR") && !o3.startsWith("RGB")) throw new Error(`Unrecognized format ${o3}`);
+            const a3 = o3.startsWith("BGR"), l3 = new Uint8ClampedArray(i3 * s3 * 4);
+            if (yield e3.copyTo(l3, function(t4, e4, n4, r4, i4) {
+              const s4 = 4 * Math.max(-e4, 0), o4 = (Math.max(0, n4) - n4) * r4 * 4 + s4, a4 = 4 * r4, l4 = Math.max(0, e4), u3 = Math.max(0, n4);
+              return { rect: { x: l4, y: u3, width: Math.min(t4.width, e4 + r4) - l4, height: Math.min(t4.height, n4 + i4) - u3 }, layout: [{ offset: o4, stride: a4 }] };
+            }(t3, n3, r3, i3, s3)), a3) for (let t4 = 0; t4 < l3.length; t4 += 4) {
+              const e4 = l3[t4];
+              l3[t4] = l3[t4 + 2], l3[t4 + 2] = e4;
+            }
+            return l3;
+          } finally {
+            e3.close();
+          }
+        });
+      }
+      let K2, J2;
+      function Q2(t3, e3, n3, r3) {
+        return t3.addEventListener(e3, n3, r3), { unsubscribe: () => {
+          t3.removeEventListener(e3, n3, r3);
+        } };
+      }
+      function tt2(t3) {
+        return t3 * Math.PI / 180;
+      }
+      function et2(t3) {
+        return t3 / Math.PI * 180;
+      }
+      const nt2 = { touchstart: true, touchmove: true, touchmoveWindow: true, touchend: true, touchcancel: true }, rt2 = { dblclick: true, click: true, mouseover: true, mouseout: true, mousedown: true, mousemove: true, mousemoveWindow: true, mouseup: true, mouseupWindow: true, contextmenu: true, wheel: true }, it2 = "AbortError";
+      class st2 extends Error {
+        constructor(t3 = it2) {
+          super(t3 instanceof Error ? t3.message : t3), this.name = it2, t3 instanceof Error && t3.stack && (this.stack = t3.stack);
+        }
+      }
+      function ot2(t3) {
+        return t3.name === it2;
+      }
+      const at2 = { MAX_PARALLEL_IMAGE_REQUESTS: 16, MAX_PARALLEL_IMAGE_REQUESTS_PER_FRAME: 8, MAX_TILE_CACHE_ZOOM_LEVELS: 5, REGISTERED_PROTOCOLS: {}, WORKER_URL: "" };
+      function lt2(t3) {
+        return at2.REGISTERED_PROTOCOLS[t3.substring(0, t3.indexOf("://"))];
+      }
+      const ut2 = "global-dispatcher";
+      class ct2 extends Error {
+        constructor(t3, e3, n3, r3) {
+          super(`AJAXError: ${e3} (${t3}): ${n3}`), this.status = t3, this.statusText = e3, this.url = n3, this.body = r3;
+        }
+      }
+      const ht2 = () => X2(self) ? self.worker && self.worker.referrer : ("blob:" === window.location.protocol ? window.parent : window).location.href, pt2 = function(t3, n3) {
+        if (/:\/\//.test(t3.url) && !/^https?:|^file:/.test(t3.url)) {
+          const e3 = lt2(t3.url);
+          if (e3) return e3(t3, n3);
+          if (X2(self) && self.worker && self.worker.actor) return self.worker.actor.sendAsync({ type: "GR", data: t3, targetMapId: ut2 }, n3);
+        }
+        if (!(/^file:/.test(r3 = t3.url) || /^file:/.test(ht2()) && !/^\w+:/.test(r3))) {
+          if (fetch && Request && AbortController && Object.prototype.hasOwnProperty.call(Request.prototype, "signal")) return function(t4, n4) {
+            return e2(this, void 0, void 0, function* () {
+              const e3 = new Request(t4.url, { method: t4.method || "GET", body: t4.body, credentials: t4.credentials, headers: t4.headers, cache: t4.cache, referrer: ht2(), referrerPolicy: t4.referrerPolicy, signal: n4.signal });
+              let r4, i3;
+              "json" !== t4.type || e3.headers.has("Accept") || e3.headers.set("Accept", "application/json");
+              try {
+                r4 = yield fetch(e3);
+              } catch (e4) {
+                if (ot2(e4)) throw e4;
+                throw new ct2(0, e4.message, t4.url, new Blob());
+              }
+              if (!r4.ok) {
+                const e4 = yield r4.blob();
+                throw new ct2(r4.status, r4.statusText, t4.url, e4);
+              }
+              i3 = "arrayBuffer" === t4.type || "image" === t4.type ? r4.arrayBuffer() : "json" === t4.type ? r4.json() : r4.text();
+              const s3 = yield i3;
+              return n4.signal.throwIfAborted(), { data: s3, cacheControl: r4.headers.get("Cache-Control"), expires: r4.headers.get("Expires"), etag: r4.headers.get("ETag") };
+            });
+          }(t3, n3);
+          if (X2(self) && self.worker && self.worker.actor) return self.worker.actor.sendAsync({ type: "GR", data: t3, mustQueue: true, targetMapId: ut2 }, n3);
+        }
+        var r3;
+        return function(t4, e3) {
+          return new Promise((n4, r4) => {
+            var i3;
+            const s3 = new XMLHttpRequest();
+            s3.open(t4.method || "GET", t4.url, true), "arrayBuffer" !== t4.type && "image" !== t4.type || (s3.responseType = "arraybuffer");
+            for (const e4 in t4.headers) s3.setRequestHeader(e4, t4.headers[e4]);
+            "json" === t4.type && (s3.responseType = "text", (null === (i3 = t4.headers) || void 0 === i3 ? void 0 : i3.Accept) || s3.setRequestHeader("Accept", "application/json")), s3.withCredentials = "include" === t4.credentials, s3.onerror = () => {
+              r4(new Error(s3.statusText));
+            }, s3.onload = () => {
+              if (!e3.signal.aborted) if ((s3.status >= 200 && s3.status < 300 || 0 === s3.status) && null !== s3.response) {
+                let e4 = s3.response;
+                if ("json" === t4.type) try {
+                  e4 = JSON.parse(s3.response);
+                } catch (t5) {
+                  return void r4(t5);
+                }
+                n4({ data: e4, cacheControl: s3.getResponseHeader("Cache-Control"), expires: s3.getResponseHeader("Expires"), etag: s3.getResponseHeader("ETag") });
+              } else {
+                const e4 = new Blob([s3.response], { type: s3.getResponseHeader("Content-Type") });
+                r4(new ct2(s3.status, s3.statusText, t4.url, e4));
+              }
+            }, e3.signal.addEventListener("abort", () => {
+              s3.abort(), r4(new st2(e3.signal.reason));
+            }), s3.send(t4.body);
+          });
+        }(t3, n3);
+      };
+      function ft2(t3) {
+        if (!t3 || t3.indexOf("://") <= 0 || 0 === t3.indexOf("data:image/") || 0 === t3.indexOf("blob:")) return true;
+        const e3 = new URL(t3), n3 = window.location;
+        return e3.protocol === n3.protocol && e3.host === n3.host;
+      }
+      function dt2(t3, e3, n3) {
+        n3[t3] && -1 !== n3[t3].indexOf(e3) || (n3[t3] = n3[t3] || [], n3[t3].push(e3));
+      }
+      function yt(t3, e3, n3) {
+        if (n3 && n3[t3]) {
+          const r3 = n3[t3].indexOf(e3);
+          -1 !== r3 && n3[t3].splice(r3, 1);
+        }
+      }
+      class mt2 {
+        constructor(t3, e3 = {}) {
+          O2(this, e3), this.type = t3;
+        }
+      }
+      class gt2 extends mt2 {
+        constructor(t3, e3 = {}) {
+          super("error", O2({ error: t3 }, e3));
+        }
+      }
+      class xt {
+        on(t3, e3) {
+          return this._listeners = this._listeners || {}, dt2(t3, e3, this._listeners), { unsubscribe: () => {
+            this.off(t3, e3);
+          } };
+        }
+        off(t3, e3) {
+          return yt(t3, e3, this._listeners), yt(t3, e3, this._oneTimeListeners), this;
+        }
+        once(t3, e3) {
+          return e3 ? (this._oneTimeListeners = this._oneTimeListeners || {}, dt2(t3, e3, this._oneTimeListeners), this) : new Promise((e4) => this.once(t3, e4));
+        }
+        fire(t3, e3) {
+          "string" == typeof t3 && (t3 = new mt2(t3, e3 || {}));
+          const n3 = t3.type;
+          if (this.listens(n3)) {
+            t3.target = this;
+            const e4 = this._listeners && this._listeners[n3] ? this._listeners[n3].slice() : [];
+            for (const n4 of e4) n4.call(this, t3);
+            const r3 = this._oneTimeListeners && this._oneTimeListeners[n3] ? this._oneTimeListeners[n3].slice() : [];
+            for (const e5 of r3) yt(n3, e5, this._oneTimeListeners), e5.call(this, t3);
+            const i3 = this._eventedParent;
+            i3 && (O2(t3, "function" == typeof this._eventedParentData ? this._eventedParentData() : this._eventedParentData), i3.fire(t3));
+          } else t3 instanceof gt2 && console.error(t3.error);
+          return this;
+        }
+        listens(t3) {
+          return this._listeners && this._listeners[t3] && this._listeners[t3].length > 0 || this._oneTimeListeners && this._oneTimeListeners[t3] && this._oneTimeListeners[t3].length > 0 || this._eventedParent && this._eventedParent.listens(t3);
+        }
+        setEventedParent(t3, e3) {
+          return this._eventedParent = t3, this._eventedParentData = e3, this;
+        }
+      }
+      var vt = { $version: 8, $root: { version: { required: true, type: "enum", values: [8] }, name: { type: "string" }, metadata: { type: "*" }, center: { type: "array", value: "number", length: 2 }, centerAltitude: { type: "number" }, zoom: { type: "number" }, bearing: { type: "number", default: 0, period: 360, units: "degrees" }, pitch: { type: "number", default: 0, units: "degrees" }, roll: { type: "number", default: 0, units: "degrees" }, state: { type: "state", default: {} }, light: { type: "light" }, sky: { type: "sky" }, projection: { type: "projection" }, terrain: { type: "terrain" }, sources: { required: true, type: "sources" }, sprite: { type: "sprite" }, glyphs: { type: "string" }, "font-faces": { type: "fontFaces" }, transition: { type: "transition" }, layers: { required: true, type: "array", value: "layer" } }, sources: { "*": { type: "source" } }, source: ["source_vector", "source_raster", "source_raster_dem", "source_geojson", "source_video", "source_image"], source_vector: { type: { required: true, type: "enum", values: { vector: {} } }, url: { type: "string" }, tiles: { type: "array", value: "string" }, bounds: { type: "array", value: "number", length: 4, default: [-180, -85.051129, 180, 85.051129] }, scheme: { type: "enum", values: { xyz: {}, tms: {} }, default: "xyz" }, minzoom: { type: "number", default: 0 }, maxzoom: { type: "number", default: 22 }, attribution: { type: "string" }, promoteId: { type: "promoteId" }, volatile: { type: "boolean", default: false }, encoding: { type: "enum", values: { mvt: {}, mlt: {} }, default: "mvt" }, "*": { type: "*" } }, source_raster: { type: { required: true, type: "enum", values: { raster: {} } }, url: { type: "string" }, tiles: { type: "array", value: "string" }, bounds: { type: "array", value: "number", length: 4, default: [-180, -85.051129, 180, 85.051129] }, minzoom: { type: "number", default: 0 }, maxzoom: { type: "number", default: 22 }, tileSize: { type: "number", default: 512, units: "pixels" }, scheme: { type: "enum", values: { xyz: {}, tms: {} }, default: "xyz" }, attribution: { type: "string" }, volatile: { type: "boolean", default: false }, "*": { type: "*" } }, source_raster_dem: { type: { required: true, type: "enum", values: { "raster-dem": {} } }, url: { type: "string" }, tiles: { type: "array", value: "string" }, bounds: { type: "array", value: "number", length: 4, default: [-180, -85.051129, 180, 85.051129] }, minzoom: { type: "number", default: 0 }, maxzoom: { type: "number", default: 22 }, tileSize: { type: "number", default: 512, units: "pixels" }, attribution: { type: "string" }, encoding: { type: "enum", values: { terrarium: {}, mapbox: {}, custom: {} }, default: "mapbox" }, redFactor: { type: "number", default: 1 }, blueFactor: { type: "number", default: 1 }, greenFactor: { type: "number", default: 1 }, baseShift: { type: "number", default: 0 }, volatile: { type: "boolean", default: false }, "*": { type: "*" } }, source_geojson: { type: { required: true, type: "enum", values: { geojson: {} } }, data: { required: true, type: "*" }, maxzoom: { type: "number", default: 18 }, attribution: { type: "string" }, buffer: { type: "number", default: 128, maximum: 512, minimum: 0 }, filter: { type: "filter" }, tolerance: { type: "number", default: 0.375 }, cluster: { type: "boolean", default: false }, clusterRadius: { type: "number", default: 50, minimum: 0 }, clusterMaxZoom: { type: "number" }, clusterMinPoints: { type: "number" }, clusterProperties: { type: "*" }, lineMetrics: { type: "boolean", default: false }, generateId: { type: "boolean", default: false }, promoteId: { type: "promoteId" } }, source_video: { type: { required: true, type: "enum", values: { video: {} } }, urls: { required: true, type: "array", value: "string" }, coordinates: { required: true, type: "array", length: 4, value: { type: "array", length: 2, value: "number" } } }, source_image: { type: { required: true, type: "enum", values: { image: {} } }, url: { required: true, type: "string" }, coordinates: { required: true, type: "array", length: 4, value: { type: "array", length: 2, value: "number" } } }, layer: { id: { type: "string", required: true }, type: { type: "enum", values: { fill: {}, line: {}, symbol: {}, circle: {}, heatmap: {}, "fill-extrusion": {}, raster: {}, hillshade: {}, "color-relief": {}, background: {} }, required: true }, metadata: { type: "*" }, source: { type: "string" }, "source-layer": { type: "string" }, minzoom: { type: "number", minimum: 0, maximum: 24 }, maxzoom: { type: "number", minimum: 0, maximum: 24 }, filter: { type: "filter" }, layout: { type: "layout" }, paint: { type: "paint" } }, layout: ["layout_fill", "layout_line", "layout_circle", "layout_heatmap", "layout_fill-extrusion", "layout_symbol", "layout_raster", "layout_hillshade", "layout_color-relief", "layout_background"], layout_background: { visibility: { type: "enum", values: { visible: {}, none: {} }, default: "visible", expression: { interpolated: false, parameters: ["global-state"] }, "property-type": "data-constant" } }, layout_fill: { "fill-sort-key": { type: "number", expression: { interpolated: false, parameters: ["zoom", "feature"] }, "property-type": "data-driven" }, visibility: { type: "enum", values: { visible: {}, none: {} }, default: "visible", expression: { interpolated: false, parameters: ["global-state"] }, "property-type": "data-constant" } }, layout_circle: { "circle-sort-key": { type: "number", expression: { interpolated: false, parameters: ["zoom", "feature"] }, "property-type": "data-driven" }, visibility: { type: "enum", values: { visible: {}, none: {} }, default: "visible", expression: { interpolated: false, parameters: ["global-state"] }, "property-type": "data-constant" } }, layout_heatmap: { visibility: { type: "enum", values: { visible: {}, none: {} }, default: "visible", expression: { interpolated: false, parameters: ["global-state"] }, "property-type": "data-constant" } }, "layout_fill-extrusion": { visibility: { type: "enum", values: { visible: {}, none: {} }, default: "visible", expression: { interpolated: false, parameters: ["global-state"] }, "property-type": "data-constant" } }, layout_line: { "line-cap": { type: "enum", values: { butt: {}, round: {}, square: {} }, default: "butt", expression: { interpolated: false, parameters: ["zoom"] }, "property-type": "data-constant" }, "line-join": { type: "enum", values: { bevel: {}, round: {}, miter: {} }, default: "miter", expression: { interpolated: false, parameters: ["zoom", "feature"] }, "property-type": "data-driven" }, "line-miter-limit": { type: "number", default: 2, requires: [{ "line-join": "miter" }], expression: { interpolated: true, parameters: ["zoom"] }, "property-type": "data-constant" }, "line-round-limit": { type: "number", default: 1.05, requires: [{ "line-join": "round" }], expression: { interpolated: true, parameters: ["zoom"] }, "property-type": "data-constant" }, "line-sort-key": { type: "number", expression: { interpolated: false, parameters: ["zoom", "feature"] }, "property-type": "data-driven" }, visibility: { type: "enum", values: { visible: {}, none: {} }, default: "visible", expression: { interpolated: false, parameters: ["global-state"] }, "property-type": "data-constant" } }, layout_symbol: { "symbol-placement": { type: "enum", values: { point: {}, line: {}, "line-center": {} }, default: "point", expression: { interpolated: false, parameters: ["zoom"] }, "property-type": "data-constant" }, "symbol-spacing": { type: "number", default: 250, minimum: 1, units: "pixels", requires: [{ "symbol-placement": "line" }], expression: { interpolated: true, parameters: ["zoom"] }, "property-type": "data-constant" }, "symbol-avoid-edges": { type: "boolean", default: false, expression: { interpolated: false, parameters: ["zoom"] }, "property-type": "data-constant" }, "symbol-sort-key": { type: "number", expression: { interpolated: false, parameters: ["zoom", "feature"] }, "property-type": "data-driven" }, "symbol-z-order": { type: "enum", values: { auto: {}, "viewport-y": {}, source: {} }, default: "auto", expression: { interpolated: false, parameters: ["zoom"] }, "property-type": "data-constant" }, "icon-allow-overlap": { type: "boolean", default: false, requires: ["icon-image", { "!": "icon-overlap" }], expression: { interpolated: false, parameters: ["zoom"] }, "property-type": "data-constant" }, "icon-overlap": { type: "enum", values: { never: {}, always: {}, cooperative: {} }, requires: ["icon-image"], expression: { interpolated: false, parameters: ["zoom"] }, "property-type": "data-constant" }, "icon-ignore-placement": { type: "boolean", default: false, requires: ["icon-image"], expression: { interpolated: false, parameters: ["zoom"] }, "property-type": "data-constant" }, "icon-optional": { type: "boolean", default: false, requires: ["icon-image", "text-field"], expression: { interpolated: false, parameters: ["zoom"] }, "property-type": "data-constant" }, "icon-rotation-alignment": { type: "enum", values: { map: {}, viewport: {}, auto: {} }, default: "auto", requires: ["icon-image"], expression: { interpolated: false, parameters: ["zoom"] }, "property-type": "data-constant" }, "icon-size": { type: "number", default: 1, minimum: 0, units: "factor of the original icon size", requires: ["icon-image"], expression: { interpolated: true, parameters: ["zoom", "feature"] }, "property-type": "data-driven" }, "icon-text-fit": { type: "enum", values: { none: {}, width: {}, height: {}, both: {} }, default: "none", requires: ["icon-image", "text-field"], expression: { interpolated: false, parameters: ["zoom"] }, "property-type": "data-constant" }, "icon-text-fit-padding": { type: "array", value: "number", length: 4, default: [0, 0, 0, 0], units: "pixels", requires: ["icon-image", "text-field", { "icon-text-fit": ["both", "width", "height"] }], expression: { interpolated: true, parameters: ["zoom"] }, "property-type": "data-constant" }, "icon-image": { type: "resolvedImage", tokens: true, expression: { interpolated: false, parameters: ["zoom", "feature"] }, "property-type": "data-driven" }, "icon-rotate": { type: "number", default: 0, period: 360, units: "degrees", requires: ["icon-image"], expression: { interpolated: true, parameters: ["zoom", "feature"] }, "property-type": "data-driven" }, "icon-padding": { type: "padding", default: [2], units: "pixels", requires: ["icon-image"], expression: { interpolated: true, parameters: ["zoom", "feature"] }, "property-type": "data-driven" }, "icon-keep-upright": { type: "boolean", default: false, requires: ["icon-image", { "icon-rotation-alignment": "map" }, { "symbol-placement": ["line", "line-center"] }], expression: { interpolated: false, parameters: ["zoom"] }, "property-type": "data-constant" }, "icon-offset": { type: "array", value: "number", length: 2, default: [0, 0], requires: ["icon-image"], expression: { interpolated: true, parameters: ["zoom", "feature"] }, "property-type": "data-driven" }, "icon-anchor": { type: "enum", values: { center: {}, left: {}, right: {}, top: {}, bottom: {}, "top-left": {}, "top-right": {}, "bottom-left": {}, "bottom-right": {} }, default: "center", requires: ["icon-image"], expression: { interpolated: false, parameters: ["zoom", "feature"] }, "property-type": "data-driven" }, "icon-pitch-alignment": { type: "enum", values: { map: {}, viewport: {}, auto: {} }, default: "auto", requires: ["icon-image"], expression: { interpolated: false, parameters: ["zoom"] }, "property-type": "data-constant" }, "text-pitch-alignment": { type: "enum", values: { map: {}, viewport: {}, auto: {} }, default: "auto", requires: ["text-field"], expression: { interpolated: false, parameters: ["zoom"] }, "property-type": "data-constant" }, "text-rotation-alignment": { type: "enum", values: { map: {}, viewport: {}, "viewport-glyph": {}, auto: {} }, default: "auto", requires: ["text-field"], expression: { interpolated: false, parameters: ["zoom"] }, "property-type": "data-constant" }, "text-field": { type: "formatted", default: "", tokens: true, expression: { interpolated: false, parameters: ["zoom", "feature"] }, "property-type": "data-driven" }, "text-font": { type: "array", value: "string", default: ["Open Sans Regular", "Arial Unicode MS Regular"], requires: ["text-field"], expression: { interpolated: false, parameters: ["zoom", "feature"] }, "property-type": "data-driven" }, "text-size": { type: "number", default: 16, minimum: 0, units: "pixels", requires: ["text-field"], expression: { interpolated: true, parameters: ["zoom", "feature"] }, "property-type": "data-driven" }, "text-max-width": { type: "number", default: 10, minimum: 0, units: "ems", requires: ["text-field"], expression: { interpolated: true, parameters: ["zoom", "feature"] }, "property-type": "data-driven" }, "text-line-height": { type: "number", default: 1.2, units: "ems", requires: ["text-field"], expression: { interpolated: true, parameters: ["zoom"] }, "property-type": "data-constant" }, "text-letter-spacing": { type: "number", default: 0, units: "ems", requires: ["text-field"], expression: { interpolated: true, parameters: ["zoom", "feature"] }, "property-type": "data-driven" }, "text-justify": { type: "enum", values: { auto: {}, left: {}, center: {}, right: {} }, default: "center", requires: ["text-field"], expression: { interpolated: false, parameters: ["zoom", "feature"] }, "property-type": "data-driven" }, "text-radial-offset": { type: "number", units: "ems", default: 0, requires: ["text-field"], "property-type": "data-driven", expression: { interpolated: true, parameters: ["zoom", "feature"] } }, "text-variable-anchor": { type: "array", value: "enum", values: { center: {}, left: {}, right: {}, top: {}, bottom: {}, "top-left": {}, "top-right": {}, "bottom-left": {}, "bottom-right": {} }, requires: ["text-field", { "symbol-placement": ["point"] }], expression: { interpolated: false, parameters: ["zoom"] }, "property-type": "data-constant" }, "text-variable-anchor-offset": { type: "variableAnchorOffsetCollection", requires: ["text-field", { "symbol-placement": ["point"] }], expression: { interpolated: true, parameters: ["zoom", "feature"] }, "property-type": "data-driven" }, "text-anchor": { type: "enum", values: { center: {}, left: {}, right: {}, top: {}, bottom: {}, "top-left": {}, "top-right": {}, "bottom-left": {}, "bottom-right": {} }, default: "center", requires: ["text-field", { "!": "text-variable-anchor" }], expression: { interpolated: false, parameters: ["zoom", "feature"] }, "property-type": "data-driven" }, "text-max-angle": { type: "number", default: 45, units: "degrees", requires: ["text-field", { "symbol-placement": ["line", "line-center"] }], expression: { interpolated: true, parameters: ["zoom"] }, "property-type": "data-constant" }, "text-writing-mode": { type: "array", value: "enum", values: { horizontal: {}, vertical: {} }, requires: ["text-field", { "symbol-placement": ["point"] }], expression: { interpolated: false, parameters: ["zoom"] }, "property-type": "data-constant" }, "text-rotate": { type: "number", default: 0, period: 360, units: "degrees", requires: ["text-field"], expression: { interpolated: true, parameters: ["zoom", "feature"] }, "property-type": "data-driven" }, "text-padding": { type: "number", default: 2, minimum: 0, units: "pixels", requires: ["text-field"], expression: { interpolated: true, parameters: ["zoom"] }, "property-type": "data-constant" }, "text-keep-upright": { type: "boolean", default: true, requires: ["text-field", { "text-rotation-alignment": "map" }, { "symbol-placement": ["line", "line-center"] }], expression: { interpolated: false, parameters: ["zoom"] }, "property-type": "data-constant" }, "text-transform": { type: "enum", values: { none: {}, uppercase: {}, lowercase: {} }, default: "none", requires: ["text-field"], expression: { interpolated: false, parameters: ["zoom", "feature"] }, "property-type": "data-driven" }, "text-offset": { type: "array", value: "number", units: "ems", length: 2, default: [0, 0], requires: ["text-field", { "!": "text-radial-offset" }], expression: { interpolated: true, parameters: ["zoom", "feature"] }, "property-type": "data-driven" }, "text-allow-overlap": { type: "boolean", default: false, requires: ["text-field", { "!": "text-overlap" }], expression: { interpolated: false, parameters: ["zoom"] }, "property-type": "data-constant" }, "text-overlap": { type: "enum", values: { never: {}, always: {}, cooperative: {} }, requires: ["text-field"], expression: { interpolated: false, parameters: ["zoom"] }, "property-type": "data-constant" }, "text-ignore-placement": { type: "boolean", default: false, requires: ["text-field"], expression: { interpolated: false, parameters: ["zoom"] }, "property-type": "data-constant" }, "text-optional": { type: "boolean", default: false, requires: ["text-field", "icon-image"], expression: { interpolated: false, parameters: ["zoom"] }, "property-type": "data-constant" }, visibility: { type: "enum", values: { visible: {}, none: {} }, default: "visible", expression: { interpolated: false, parameters: ["global-state"] }, "property-type": "data-constant" } }, layout_raster: { visibility: { type: "enum", values: { visible: {}, none: {} }, default: "visible", expression: { interpolated: false, parameters: ["global-state"] }, "property-type": "data-constant" } }, layout_hillshade: { visibility: { type: "enum", values: { visible: {}, none: {} }, default: "visible", expression: { interpolated: false, parameters: ["global-state"] }, "property-type": "data-constant" } }, "layout_color-relief": { visibility: { type: "enum", values: { visible: {}, none: {} }, default: "visible", expression: { interpolated: false, parameters: ["global-state"] }, "property-type": "data-constant" } }, filter: { type: "boolean", expression: { interpolated: false, parameters: ["zoom", "feature"] }, "property-type": "data-driven" }, filter_operator: { type: "enum", values: { "==": {}, "!=": {}, ">": {}, ">=": {}, "<": {}, "<=": {}, in: {}, "!in": {}, all: {}, any: {}, none: {}, has: {}, "!has": {} } }, geometry_type: { type: "enum", values: { Point: {}, LineString: {}, Polygon: {} } }, function: { expression: { type: "expression" }, stops: { type: "array", value: "function_stop" }, base: { type: "number", default: 1, minimum: 0 }, property: { type: "string", default: "$zoom" }, type: { type: "enum", values: { identity: {}, exponential: {}, interval: {}, categorical: {} }, default: "exponential" }, colorSpace: { type: "enum", values: { rgb: {}, lab: {}, hcl: {} }, default: "rgb" }, default: { type: "*", required: false } }, function_stop: { type: "array", minimum: 0, maximum: 24, value: ["number", "color"], length: 2 }, expression: { type: "array", value: "expression_name", minimum: 1 }, light: { anchor: { type: "enum", default: "viewport", values: { map: {}, viewport: {} }, "property-type": "data-constant", transition: false, expression: { interpolated: false, parameters: ["zoom"] } }, position: { type: "array", default: [1.15, 210, 30], length: 3, value: "number", "property-type": "data-constant", transition: true, expression: { interpolated: true, parameters: ["zoom"] } }, color: { type: "color", "property-type": "data-constant", default: "#ffffff", expression: { interpolated: true, parameters: ["zoom"] }, transition: true }, intensity: { type: "number", "property-type": "data-constant", default: 0.5, minimum: 0, maximum: 1, expression: { interpolated: true, parameters: ["zoom"] }, transition: true } }, sky: { "sky-color": { type: "color", "property-type": "data-constant", default: "#88C6FC", expression: { interpolated: true, parameters: ["zoom"] }, transition: true }, "horizon-color": { type: "color", "property-type": "data-constant", default: "#ffffff", expression: { interpolated: true, parameters: ["zoom"] }, transition: true }, "fog-color": { type: "color", "property-type": "data-constant", default: "#ffffff", expression: { interpolated: true, parameters: ["zoom"] }, transition: true }, "fog-ground-blend": { type: "number", "property-type": "data-constant", default: 0.5, minimum: 0, maximum: 1, expression: { interpolated: true, parameters: ["zoom"] }, transition: true }, "horizon-fog-blend": { type: "number", "property-type": "data-constant", default: 0.8, minimum: 0, maximum: 1, expression: { interpolated: true, parameters: ["zoom"] }, transition: true }, "sky-horizon-blend": { type: "number", "property-type": "data-constant", default: 0.8, minimum: 0, maximum: 1, expression: { interpolated: true, parameters: ["zoom"] }, transition: true }, "atmosphere-blend": { type: "number", "property-type": "data-constant", default: 0.8, minimum: 0, maximum: 1, expression: { interpolated: true, parameters: ["zoom"] }, transition: true } }, terrain: { source: { type: "string", required: true }, exaggeration: { type: "number", minimum: 0, default: 1 } }, projection: { type: { type: "projectionDefinition", default: "mercator", "property-type": "data-constant", transition: false, expression: { interpolated: true, parameters: ["zoom"] } } }, paint: ["paint_fill", "paint_line", "paint_circle", "paint_heatmap", "paint_fill-extrusion", "paint_symbol", "paint_raster", "paint_hillshade", "paint_color-relief", "paint_background"], paint_fill: { "fill-antialias": { type: "boolean", default: true, expression: { interpolated: false, parameters: ["zoom"] }, "property-type": "data-constant" }, "fill-opacity": { type: "number", default: 1, minimum: 0, maximum: 1, transition: true, expression: { interpolated: true, parameters: ["zoom", "feature", "feature-state"] }, "property-type": "data-driven" }, "fill-color": { type: "color", default: "#000000", transition: true, requires: [{ "!": "fill-pattern" }], expression: { interpolated: true, parameters: ["zoom", "feature", "feature-state"] }, "property-type": "data-driven" }, "fill-outline-color": { type: "color", transition: true, requires: [{ "!": "fill-pattern" }, { "fill-antialias": true }], expression: { interpolated: true, parameters: ["zoom", "feature", "feature-state"] }, "property-type": "data-driven" }, "fill-translate": { type: "array", value: "number", length: 2, default: [0, 0], transition: true, units: "pixels", expression: { interpolated: true, parameters: ["zoom"] }, "property-type": "data-constant" }, "fill-translate-anchor": { type: "enum", values: { map: {}, viewport: {} }, default: "map", requires: ["fill-translate"], expression: { interpolated: false, parameters: ["zoom"] }, "property-type": "data-constant" }, "fill-pattern": { type: "resolvedImage", transition: true, expression: { interpolated: false, parameters: ["zoom", "feature"] }, "property-type": "cross-faded-data-driven" } }, "paint_fill-extrusion": { "fill-extrusion-opacity": { type: "number", default: 1, minimum: 0, maximum: 1, transition: true, expression: { interpolated: true, parameters: ["zoom"] }, "property-type": "data-constant" }, "fill-extrusion-color": { type: "color", default: "#000000", transition: true, requires: [{ "!": "fill-extrusion-pattern" }], expression: { interpolated: true, parameters: ["zoom", "feature", "feature-state"] }, "property-type": "data-driven" }, "fill-extrusion-translate": { type: "array", value: "number", length: 2, default: [0, 0], transition: true, units: "pixels", expression: { interpolated: true, parameters: ["zoom"] }, "property-type": "data-constant" }, "fill-extrusion-translate-anchor": { type: "enum", values: { map: {}, viewport: {} }, default: "map", requires: ["fill-extrusion-translate"], expression: { interpolated: false, parameters: ["zoom"] }, "property-type": "data-constant" }, "fill-extrusion-pattern": { type: "resolvedImage", transition: true, expression: { interpolated: false, parameters: ["zoom", "feature"] }, "property-type": "cross-faded-data-driven" }, "fill-extrusion-height": { type: "number", default: 0, minimum: 0, units: "meters", transition: true, expression: { interpolated: true, parameters: ["zoom", "feature", "feature-state"] }, "property-type": "data-driven" }, "fill-extrusion-base": { type: "number", default: 0, minimum: 0, units: "meters", transition: true, requires: ["fill-extrusion-height"], expression: { interpolated: true, parameters: ["zoom", "feature", "feature-state"] }, "property-type": "data-driven" }, "fill-extrusion-vertical-gradient": { type: "boolean", default: true, transition: false, expression: { interpolated: false, parameters: ["zoom"] }, "property-type": "data-constant" } }, paint_line: { "line-opacity": { type: "number", default: 1, minimum: 0, maximum: 1, transition: true, expression: { interpolated: true, parameters: ["zoom", "feature", "feature-state"] }, "property-type": "data-driven" }, "line-color": { type: "color", default: "#000000", transition: true, requires: [{ "!": "line-pattern" }], expression: { interpolated: true, parameters: ["zoom", "feature", "feature-state"] }, "property-type": "data-driven" }, "line-translate": { type: "array", value: "number", length: 2, default: [0, 0], transition: true, units: "pixels", expression: { interpolated: true, parameters: ["zoom"] }, "property-type": "data-constant" }, "line-translate-anchor": { type: "enum", values: { map: {}, viewport: {} }, default: "map", requires: ["line-translate"], expression: { interpolated: false, parameters: ["zoom"] }, "property-type": "data-constant" }, "line-width": { type: "number", default: 1, minimum: 0, transition: true, units: "pixels", expression: { interpolated: true, parameters: ["zoom", "feature", "feature-state"] }, "property-type": "data-driven" }, "line-gap-width": { type: "number", default: 0, minimum: 0, transition: true, units: "pixels", expression: { interpolated: true, parameters: ["zoom", "feature", "feature-state"] }, "property-type": "data-driven" }, "line-offset": { type: "number", default: 0, transition: true, units: "pixels", expression: { interpolated: true, parameters: ["zoom", "feature", "feature-state"] }, "property-type": "data-driven" }, "line-blur": { type: "number", default: 0, minimum: 0, transition: true, units: "pixels", expression: { interpolated: true, parameters: ["zoom", "feature", "feature-state"] }, "property-type": "data-driven" }, "line-dasharray": { type: "array", value: "number", minimum: 0, transition: true, units: "line widths", requires: [{ "!": "line-pattern" }], expression: { interpolated: false, parameters: ["zoom", "feature"] }, "property-type": "cross-faded-data-driven" }, "line-pattern": { type: "resolvedImage", transition: true, expression: { interpolated: false, parameters: ["zoom", "feature"] }, "property-type": "cross-faded-data-driven" }, "line-gradient": { type: "color", transition: false, requires: [{ "!": "line-dasharray" }, { "!": "line-pattern" }, { source: "geojson", has: { lineMetrics: true } }], expression: { interpolated: true, parameters: ["line-progress"] }, "property-type": "color-ramp" } }, paint_circle: { "circle-radius": { type: "number", default: 5, minimum: 0, transition: true, units: "pixels", expression: { interpolated: true, parameters: ["zoom", "feature", "feature-state"] }, "property-type": "data-driven" }, "circle-color": { type: "color", default: "#000000", transition: true, expression: { interpolated: true, parameters: ["zoom", "feature", "feature-state"] }, "property-type": "data-driven" }, "circle-blur": { type: "number", default: 0, transition: true, expression: { interpolated: true, parameters: ["zoom", "feature", "feature-state"] }, "property-type": "data-driven" }, "circle-opacity": { type: "number", default: 1, minimum: 0, maximum: 1, transition: true, expression: { interpolated: true, parameters: ["zoom", "feature", "feature-state"] }, "property-type": "data-driven" }, "circle-translate": { type: "array", value: "number", length: 2, default: [0, 0], transition: true, units: "pixels", expression: { interpolated: true, parameters: ["zoom"] }, "property-type": "data-constant" }, "circle-translate-anchor": { type: "enum", values: { map: {}, viewport: {} }, default: "map", requires: ["circle-translate"], expression: { interpolated: false, parameters: ["zoom"] }, "property-type": "data-constant" }, "circle-pitch-scale": { type: "enum", values: { map: {}, viewport: {} }, default: "map", expression: { interpolated: false, parameters: ["zoom"] }, "property-type": "data-constant" }, "circle-pitch-alignment": { type: "enum", values: { map: {}, viewport: {} }, default: "viewport", expression: { interpolated: false, parameters: ["zoom"] }, "property-type": "data-constant" }, "circle-stroke-width": { type: "number", default: 0, minimum: 0, transition: true, units: "pixels", expression: { interpolated: true, parameters: ["zoom", "feature", "feature-state"] }, "property-type": "data-driven" }, "circle-stroke-color": { type: "color", default: "#000000", transition: true, expression: { interpolated: true, parameters: ["zoom", "feature", "feature-state"] }, "property-type": "data-driven" }, "circle-stroke-opacity": { type: "number", default: 1, minimum: 0, maximum: 1, transition: true, expression: { interpolated: true, parameters: ["zoom", "feature", "feature-state"] }, "property-type": "data-driven" } }, paint_heatmap: { "heatmap-radius": { type: "number", default: 30, minimum: 1, transition: true, units: "pixels", expression: { interpolated: true, parameters: ["zoom", "feature", "feature-state"] }, "property-type": "data-driven" }, "heatmap-weight": { type: "number", default: 1, minimum: 0, transition: false, expression: { interpolated: true, parameters: ["zoom", "feature", "feature-state"] }, "property-type": "data-driven" }, "heatmap-intensity": { type: "number", default: 1, minimum: 0, transition: true, expression: { interpolated: true, parameters: ["zoom"] }, "property-type": "data-constant" }, "heatmap-color": { type: "color", default: ["interpolate", ["linear"], ["heatmap-density"], 0, "rgba(0, 0, 255, 0)", 0.1, "royalblue", 0.3, "cyan", 0.5, "lime", 0.7, "yellow", 1, "red"], transition: false, expression: { interpolated: true, parameters: ["heatmap-density"] }, "property-type": "color-ramp" }, "heatmap-opacity": { type: "number", default: 1, minimum: 0, maximum: 1, transition: true, expression: { interpolated: true, parameters: ["zoom"] }, "property-type": "data-constant" } }, paint_symbol: { "icon-opacity": { type: "number", default: 1, minimum: 0, maximum: 1, transition: true, requires: ["icon-image"], expression: { interpolated: true, parameters: ["zoom", "feature", "feature-state"] }, "property-type": "data-driven" }, "icon-color": { type: "color", default: "#000000", transition: true, requires: ["icon-image"], expression: { interpolated: true, parameters: ["zoom", "feature", "feature-state"] }, "property-type": "data-driven" }, "icon-halo-color": { type: "color", default: "rgba(0, 0, 0, 0)", transition: true, requires: ["icon-image"], expression: { interpolated: true, parameters: ["zoom", "feature", "feature-state"] }, "property-type": "data-driven" }, "icon-halo-width": { type: "number", default: 0, minimum: 0, transition: true, units: "pixels", requires: ["icon-image"], expression: { interpolated: true, parameters: ["zoom", "feature", "feature-state"] }, "property-type": "data-driven" }, "icon-halo-blur": { type: "number", default: 0, minimum: 0, transition: true, units: "pixels", requires: ["icon-image"], expression: { interpolated: true, parameters: ["zoom", "feature", "feature-state"] }, "property-type": "data-driven" }, "icon-translate": { type: "array", value: "number", length: 2, default: [0, 0], transition: true, units: "pixels", requires: ["icon-image"], expression: { interpolated: true, parameters: ["zoom"] }, "property-type": "data-constant" }, "icon-translate-anchor": { type: "enum", values: { map: {}, viewport: {} }, default: "map", requires: ["icon-image", "icon-translate"], expression: { interpolated: false, parameters: ["zoom"] }, "property-type": "data-constant" }, "text-opacity": { type: "number", default: 1, minimum: 0, maximum: 1, transition: true, requires: ["text-field"], expression: { interpolated: true, parameters: ["zoom", "feature", "feature-state"] }, "property-type": "data-driven" }, "text-color": { type: "color", default: "#000000", transition: true, overridable: true, requires: ["text-field"], expression: { interpolated: true, parameters: ["zoom", "feature", "feature-state"] }, "property-type": "data-driven" }, "text-halo-color": { type: "color", default: "rgba(0, 0, 0, 0)", transition: true, requires: ["text-field"], expression: { interpolated: true, parameters: ["zoom", "feature", "feature-state"] }, "property-type": "data-driven" }, "text-halo-width": { type: "number", default: 0, minimum: 0, transition: true, units: "pixels", requires: ["text-field"], expression: { interpolated: true, parameters: ["zoom", "feature", "feature-state"] }, "property-type": "data-driven" }, "text-halo-blur": { type: "number", default: 0, minimum: 0, transition: true, units: "pixels", requires: ["text-field"], expression: { interpolated: true, parameters: ["zoom", "feature", "feature-state"] }, "property-type": "data-driven" }, "text-translate": { type: "array", value: "number", length: 2, default: [0, 0], transition: true, units: "pixels", requires: ["text-field"], expression: { interpolated: true, parameters: ["zoom"] }, "property-type": "data-constant" }, "text-translate-anchor": { type: "enum", values: { map: {}, viewport: {} }, default: "map", requires: ["text-field", "text-translate"], expression: { interpolated: false, parameters: ["zoom"] }, "property-type": "data-constant" } }, paint_raster: { "raster-opacity": { type: "number", default: 1, minimum: 0, maximum: 1, transition: true, expression: { interpolated: true, parameters: ["zoom"] }, "property-type": "data-constant" }, "raster-hue-rotate": { type: "number", default: 0, period: 360, transition: true, units: "degrees", expression: { interpolated: true, parameters: ["zoom"] }, "property-type": "data-constant" }, "raster-brightness-min": { type: "number", default: 0, minimum: 0, maximum: 1, transition: true, expression: { interpolated: true, parameters: ["zoom"] }, "property-type": "data-constant" }, "raster-brightness-max": { type: "number", default: 1, minimum: 0, maximum: 1, transition: true, expression: { interpolated: true, parameters: ["zoom"] }, "property-type": "data-constant" }, "raster-saturation": { type: "number", default: 0, minimum: -1, maximum: 1, transition: true, expression: { interpolated: true, parameters: ["zoom"] }, "property-type": "data-constant" }, "raster-contrast": { type: "number", default: 0, minimum: -1, maximum: 1, transition: true, expression: { interpolated: true, parameters: ["zoom"] }, "property-type": "data-constant" }, resampling: { type: "enum", values: { linear: {}, nearest: {} }, default: "linear", expression: { interpolated: false, parameters: ["zoom"] }, "property-type": "data-constant" }, "raster-resampling": { type: "enum", values: { linear: {}, nearest: {} }, default: "linear", expression: { interpolated: false, parameters: ["zoom"] }, "property-type": "data-constant" }, "raster-fade-duration": { type: "number", default: 300, minimum: 0, transition: false, units: "milliseconds", expression: { interpolated: true, parameters: ["zoom"] }, "property-type": "data-constant" } }, paint_hillshade: { "hillshade-illumination-direction": { type: "numberArray", default: 335, minimum: 0, maximum: 359, transition: false, expression: { interpolated: true, parameters: ["zoom"] }, "property-type": "data-constant" }, "hillshade-illumination-altitude": { type: "numberArray", default: 45, minimum: 0, maximum: 90, transition: false, expression: { interpolated: true, parameters: ["zoom"] }, "property-type": "data-constant" }, "hillshade-illumination-anchor": { type: "enum", values: { map: {}, viewport: {} }, default: "viewport", expression: { interpolated: false, parameters: ["zoom"] }, "property-type": "data-constant" }, "hillshade-exaggeration": { type: "number", default: 0.5, minimum: 0, maximum: 1, transition: true, expression: { interpolated: true, parameters: ["zoom"] }, "property-type": "data-constant" }, "hillshade-shadow-color": { type: "colorArray", default: "#000000", transition: true, expression: { interpolated: true, parameters: ["zoom"] }, "property-type": "data-constant" }, "hillshade-highlight-color": { type: "colorArray", default: "#FFFFFF", transition: true, expression: { interpolated: true, parameters: ["zoom"] }, "property-type": "data-constant" }, "hillshade-accent-color": { type: "color", default: "#000000", transition: true, expression: { interpolated: true, parameters: ["zoom"] }, "property-type": "data-constant" }, "hillshade-method": { type: "enum", values: { standard: {}, basic: {}, combined: {}, igor: {}, multidirectional: {} }, default: "standard", expression: { interpolated: false, parameters: ["zoom"] }, "property-type": "data-constant" }, resampling: { type: "enum", values: { linear: {}, nearest: {} }, default: "linear", expression: { interpolated: false, parameters: ["zoom"] }, "property-type": "data-constant" } }, "paint_color-relief": { "color-relief-opacity": { type: "number", default: 1, minimum: 0, maximum: 1, transition: true, expression: { interpolated: true, parameters: ["zoom"] }, "property-type": "data-constant" }, "color-relief-color": { type: "color", transition: false, expression: { interpolated: true, parameters: ["elevation"] }, "property-type": "color-ramp" }, resampling: { type: "enum", values: { linear: {}, nearest: {} }, default: "linear", expression: { interpolated: false, parameters: ["zoom"] }, "property-type": "data-constant" } }, paint_background: { "background-color": { type: "color", default: "#000000", transition: true, requires: [{ "!": "background-pattern" }], expression: { interpolated: true, parameters: ["zoom"] }, "property-type": "data-constant" }, "background-pattern": { type: "resolvedImage", transition: true, expression: { interpolated: false, parameters: ["zoom"] }, "property-type": "cross-faded" }, "background-opacity": { type: "number", default: 1, minimum: 0, maximum: 1, transition: true, expression: { interpolated: true, parameters: ["zoom"] }, "property-type": "data-constant" } }, transition: { duration: { type: "number", default: 300, minimum: 0, units: "milliseconds" }, delay: { type: "number", default: 0, minimum: 0, units: "milliseconds" } }, "property-type": { "data-driven": { type: "property-type" }, "cross-faded": { type: "property-type" }, "cross-faded-data-driven": { type: "property-type" }, "color-ramp": { type: "property-type" }, "data-constant": { type: "property-type" }, constant: { type: "property-type" } }, promoteId: { "*": { type: "string" } }, interpolation: { type: "array", value: "interpolation_name", minimum: 1 }, interpolation_name: { type: "enum", values: { linear: { syntax: { overloads: [{ parameters: [], "output-type": "interpolation" }], parameters: [] } }, exponential: { syntax: { overloads: [{ parameters: ["base"], "output-type": "interpolation" }], parameters: [{ name: "base", type: "number literal" }] } }, "cubic-bezier": { syntax: { overloads: [{ parameters: ["x1", "y1", "x2", "y2"], "output-type": "interpolation" }], parameters: [{ name: "x1", type: "number literal" }, { name: "y1", type: "number literal" }, { name: "x2", type: "number literal" }, { name: "y2", type: "number literal" }] } } } } };
+      const bt = ["type", "source", "source-layer", "minzoom", "maxzoom", "filter", "layout"];
+      function wt(t3, e3) {
+        const n3 = {};
+        for (const e4 in t3) "ref" !== e4 && (n3[e4] = t3[e4]);
+        return bt.forEach((t4) => {
+          t4 in e3 && (n3[t4] = e3[t4]);
+        }), n3;
+      }
+      function _t2(t3, e3) {
+        if (Array.isArray(t3)) {
+          if (!Array.isArray(e3) || t3.length !== e3.length) return false;
+          for (let n3 = 0; n3 < t3.length; n3++) if (!_t2(t3[n3], e3[n3])) return false;
+          return true;
+        }
+        if ("object" == typeof t3 && null !== t3 && null !== e3) {
+          if ("object" != typeof e3) return false;
+          if (Object.keys(t3).length !== Object.keys(e3).length) return false;
+          for (const n3 in t3) if (!_t2(t3[n3], e3[n3])) return false;
+          return true;
+        }
+        return t3 === e3;
+      }
+      function St(t3, e3) {
+        t3.push(e3);
+      }
+      function At(t3, e3, n3) {
+        St(n3, { command: "addSource", args: [t3, e3[t3]] });
+      }
+      function Mt(t3, e3, n3) {
+        St(e3, { command: "removeSource", args: [t3] }), n3[t3] = true;
+      }
+      function kt(t3, e3, n3, r3) {
+        Mt(t3, n3, r3), At(t3, e3, n3);
+      }
+      function It(t3, e3, n3) {
+        let r3;
+        for (r3 in t3[n3]) if (Object.prototype.hasOwnProperty.call(t3[n3], r3) && "data" !== r3 && !_t2(t3[n3][r3], e3[n3][r3])) return false;
+        for (r3 in e3[n3]) if (Object.prototype.hasOwnProperty.call(e3[n3], r3) && "data" !== r3 && !_t2(t3[n3][r3], e3[n3][r3])) return false;
+        return true;
+      }
+      function Et(t3, e3, n3, r3, i3, s3) {
+        t3 = t3 || {}, e3 = e3 || {};
+        for (const o3 in t3) Object.prototype.hasOwnProperty.call(t3, o3) && (_t2(t3[o3], e3[o3]) || n3.push({ command: s3, args: [r3, o3, e3[o3], i3] }));
+        for (const o3 in e3) Object.prototype.hasOwnProperty.call(e3, o3) && !Object.prototype.hasOwnProperty.call(t3, o3) && (_t2(t3[o3], e3[o3]) || n3.push({ command: s3, args: [r3, o3, e3[o3], i3] }));
+      }
+      function Tt(t3) {
+        return t3.id;
+      }
+      function Ft(t3, e3) {
+        return t3[e3.id] = e3, t3;
+      }
+      class Dt {
+        constructor(t3, e3, n3, r3) {
+          this.message = (t3 ? `${t3}: ` : "") + n3, r3 && (this.identifier = r3), null != e3 && e3.__line__ && (this.line = e3.__line__);
+        }
+      }
+      function Pt(t3, ...e3) {
+        for (const n3 of e3) for (const e4 in n3) t3[e4] = n3[e4];
+        return t3;
+      }
+      class zt extends Error {
+        constructor(t3, e3) {
+          super(e3), this.message = e3, this.key = t3;
+        }
+      }
+      class Bt {
+        constructor(t3, e3 = []) {
+          this.parent = t3, this.bindings = {};
+          for (const [t4, n3] of e3) this.bindings[t4] = n3;
+        }
+        concat(t3) {
+          return new Bt(this, t3);
+        }
+        get(t3) {
+          if (this.bindings[t3]) return this.bindings[t3];
+          if (this.parent) return this.parent.get(t3);
+          throw new Error(`${t3} not found in scope.`);
+        }
+        has(t3) {
+          return !!this.bindings[t3] || !!this.parent && this.parent.has(t3);
+        }
+      }
+      const Ct = { kind: "null" }, Vt = { kind: "number" }, Lt = { kind: "string" }, Ot = { kind: "boolean" }, $t = { kind: "color" }, Rt = { kind: "projectionDefinition" }, Nt = { kind: "object" }, Ut = { kind: "value" }, jt = { kind: "collator" }, qt = { kind: "formatted" }, Gt = { kind: "padding" }, Xt = { kind: "colorArray" }, Yt = { kind: "numberArray" }, Zt = { kind: "resolvedImage" }, Ht = { kind: "variableAnchorOffsetCollection" };
+      function Wt(t3, e3) {
+        return { kind: "array", itemType: t3, N: e3 };
+      }
+      function Kt(t3) {
+        if ("array" === t3.kind) {
+          const e3 = Kt(t3.itemType);
+          return "number" == typeof t3.N ? `array<${e3}, ${t3.N}>` : "value" === t3.itemType.kind ? "array" : `array<${e3}>`;
+        }
+        return t3.kind;
+      }
+      const Jt = [Ct, Vt, Lt, Ot, $t, Rt, qt, Nt, Wt(Ut), Gt, Yt, Xt, Zt, Ht];
+      function Qt(t3, e3) {
+        if ("error" === e3.kind) return null;
+        if ("array" === t3.kind) {
+          if ("array" === e3.kind && (0 === e3.N && "value" === e3.itemType.kind || !Qt(t3.itemType, e3.itemType)) && ("number" != typeof t3.N || t3.N === e3.N)) return null;
+        } else {
+          if (t3.kind === e3.kind) return null;
+          if ("value" === t3.kind) {
+            for (const t4 of Jt) if (!Qt(t4, e3)) return null;
+          }
+        }
+        return `Expected ${Kt(t3)} but found ${Kt(e3)} instead.`;
+      }
+      function te2(t3, e3) {
+        return e3.some((e4) => e4.kind === t3.kind);
+      }
+      function ee2(t3, e3) {
+        return e3.some((e4) => "null" === e4 ? null === t3 : "array" === e4 ? Array.isArray(t3) : "object" === e4 ? t3 && !Array.isArray(t3) && "object" == typeof t3 : e4 === typeof t3);
+      }
+      function ne2(t3, e3) {
+        return "array" === t3.kind && "array" === e3.kind ? t3.itemType.kind === e3.itemType.kind && "number" == typeof t3.N : t3.kind === e3.kind;
+      }
+      const re2 = 0.96422, ie2 = 0.82521, se2 = 4 / 29, oe2 = 6 / 29, ae2 = 3 * oe2 * oe2, le2 = oe2 * oe2 * oe2, ue2 = Math.PI / 180, ce2 = 180 / Math.PI;
+      function he2(t3) {
+        return (t3 %= 360) < 0 && (t3 += 360), t3;
+      }
+      function pe2([t3, e3, n3, r3]) {
+        let i3, s3;
+        const o3 = de2((0.2225045 * (t3 = fe2(t3)) + 0.7168786 * (e3 = fe2(e3)) + 0.0606169 * (n3 = fe2(n3))) / 1);
+        t3 === e3 && e3 === n3 ? i3 = s3 = o3 : (i3 = de2((0.4360747 * t3 + 0.3850649 * e3 + 0.1430804 * n3) / re2), s3 = de2((0.0139322 * t3 + 0.0971045 * e3 + 0.7141733 * n3) / ie2));
+        const a3 = 116 * o3 - 16;
+        return [a3 < 0 ? 0 : a3, 500 * (i3 - o3), 200 * (o3 - s3), r3];
+      }
+      function fe2(t3) {
+        return t3 <= 0.04045 ? t3 / 12.92 : Math.pow((t3 + 0.055) / 1.055, 2.4);
+      }
+      function de2(t3) {
+        return t3 > le2 ? Math.pow(t3, 1 / 3) : t3 / ae2 + se2;
+      }
+      function ye2([t3, e3, n3, r3]) {
+        let i3 = (t3 + 16) / 116, s3 = isNaN(e3) ? i3 : i3 + e3 / 500, o3 = isNaN(n3) ? i3 : i3 - n3 / 200;
+        return i3 = 1 * ge2(i3), s3 = re2 * ge2(s3), o3 = ie2 * ge2(o3), [me2(3.1338561 * s3 - 1.6168667 * i3 - 0.4906146 * o3), me2(-0.9787684 * s3 + 1.9161415 * i3 + 0.033454 * o3), me2(0.0719453 * s3 - 0.2289914 * i3 + 1.4052427 * o3), r3];
+      }
+      function me2(t3) {
+        return (t3 = t3 <= 304e-5 ? 12.92 * t3 : 1.055 * Math.pow(t3, 1 / 2.4) - 0.055) < 0 ? 0 : t3 > 1 ? 1 : t3;
+      }
+      function ge2(t3) {
+        return t3 > oe2 ? t3 * t3 * t3 : ae2 * (t3 - se2);
+      }
+      const xe2 = Object.hasOwn || function(t3, e3) {
+        return Object.prototype.hasOwnProperty.call(t3, e3);
+      };
+      function ve2(t3, e3) {
+        return xe2(t3, e3) ? t3[e3] : void 0;
+      }
+      function be2(t3) {
+        return parseInt(t3.padEnd(2, t3), 16) / 255;
+      }
+      function we2(t3, e3) {
+        return _e2(e3 ? t3 / 100 : t3, 0, 1);
+      }
+      function _e2(t3, e3, n3) {
+        return Math.min(Math.max(e3, t3), n3);
+      }
+      function Se2(t3) {
+        return !t3.some(Number.isNaN);
+      }
+      const Ae2 = { aliceblue: [240, 248, 255], antiquewhite: [250, 235, 215], aqua: [0, 255, 255], aquamarine: [127, 255, 212], azure: [240, 255, 255], beige: [245, 245, 220], bisque: [255, 228, 196], black: [0, 0, 0], blanchedalmond: [255, 235, 205], blue: [0, 0, 255], blueviolet: [138, 43, 226], brown: [165, 42, 42], burlywood: [222, 184, 135], cadetblue: [95, 158, 160], chartreuse: [127, 255, 0], chocolate: [210, 105, 30], coral: [255, 127, 80], cornflowerblue: [100, 149, 237], cornsilk: [255, 248, 220], crimson: [220, 20, 60], cyan: [0, 255, 255], darkblue: [0, 0, 139], darkcyan: [0, 139, 139], darkgoldenrod: [184, 134, 11], darkgray: [169, 169, 169], darkgreen: [0, 100, 0], darkgrey: [169, 169, 169], darkkhaki: [189, 183, 107], darkmagenta: [139, 0, 139], darkolivegreen: [85, 107, 47], darkorange: [255, 140, 0], darkorchid: [153, 50, 204], darkred: [139, 0, 0], darksalmon: [233, 150, 122], darkseagreen: [143, 188, 143], darkslateblue: [72, 61, 139], darkslategray: [47, 79, 79], darkslategrey: [47, 79, 79], darkturquoise: [0, 206, 209], darkviolet: [148, 0, 211], deeppink: [255, 20, 147], deepskyblue: [0, 191, 255], dimgray: [105, 105, 105], dimgrey: [105, 105, 105], dodgerblue: [30, 144, 255], firebrick: [178, 34, 34], floralwhite: [255, 250, 240], forestgreen: [34, 139, 34], fuchsia: [255, 0, 255], gainsboro: [220, 220, 220], ghostwhite: [248, 248, 255], gold: [255, 215, 0], goldenrod: [218, 165, 32], gray: [128, 128, 128], green: [0, 128, 0], greenyellow: [173, 255, 47], grey: [128, 128, 128], honeydew: [240, 255, 240], hotpink: [255, 105, 180], indianred: [205, 92, 92], indigo: [75, 0, 130], ivory: [255, 255, 240], khaki: [240, 230, 140], lavender: [230, 230, 250], lavenderblush: [255, 240, 245], lawngreen: [124, 252, 0], lemonchiffon: [255, 250, 205], lightblue: [173, 216, 230], lightcoral: [240, 128, 128], lightcyan: [224, 255, 255], lightgoldenrodyellow: [250, 250, 210], lightgray: [211, 211, 211], lightgreen: [144, 238, 144], lightgrey: [211, 211, 211], lightpink: [255, 182, 193], lightsalmon: [255, 160, 122], lightseagreen: [32, 178, 170], lightskyblue: [135, 206, 250], lightslategray: [119, 136, 153], lightslategrey: [119, 136, 153], lightsteelblue: [176, 196, 222], lightyellow: [255, 255, 224], lime: [0, 255, 0], limegreen: [50, 205, 50], linen: [250, 240, 230], magenta: [255, 0, 255], maroon: [128, 0, 0], mediumaquamarine: [102, 205, 170], mediumblue: [0, 0, 205], mediumorchid: [186, 85, 211], mediumpurple: [147, 112, 219], mediumseagreen: [60, 179, 113], mediumslateblue: [123, 104, 238], mediumspringgreen: [0, 250, 154], mediumturquoise: [72, 209, 204], mediumvioletred: [199, 21, 133], midnightblue: [25, 25, 112], mintcream: [245, 255, 250], mistyrose: [255, 228, 225], moccasin: [255, 228, 181], navajowhite: [255, 222, 173], navy: [0, 0, 128], oldlace: [253, 245, 230], olive: [128, 128, 0], olivedrab: [107, 142, 35], orange: [255, 165, 0], orangered: [255, 69, 0], orchid: [218, 112, 214], palegoldenrod: [238, 232, 170], palegreen: [152, 251, 152], paleturquoise: [175, 238, 238], palevioletred: [219, 112, 147], papayawhip: [255, 239, 213], peachpuff: [255, 218, 185], peru: [205, 133, 63], pink: [255, 192, 203], plum: [221, 160, 221], powderblue: [176, 224, 230], purple: [128, 0, 128], rebeccapurple: [102, 51, 153], red: [255, 0, 0], rosybrown: [188, 143, 143], royalblue: [65, 105, 225], saddlebrown: [139, 69, 19], salmon: [250, 128, 114], sandybrown: [244, 164, 96], seagreen: [46, 139, 87], seashell: [255, 245, 238], sienna: [160, 82, 45], silver: [192, 192, 192], skyblue: [135, 206, 235], slateblue: [106, 90, 205], slategray: [112, 128, 144], slategrey: [112, 128, 144], snow: [255, 250, 250], springgreen: [0, 255, 127], steelblue: [70, 130, 180], tan: [210, 180, 140], teal: [0, 128, 128], thistle: [216, 191, 216], tomato: [255, 99, 71], turquoise: [64, 224, 208], violet: [238, 130, 238], wheat: [245, 222, 179], white: [255, 255, 255], whitesmoke: [245, 245, 245], yellow: [255, 255, 0], yellowgreen: [154, 205, 50] };
+      function Me2(t3, e3, n3) {
+        return t3 + n3 * (e3 - t3);
+      }
+      function ke2(t3, e3, n3) {
+        return t3.map((t4, r3) => Me2(t4, e3[r3], n3));
+      }
+      class Ie2 {
+        constructor(t3, e3, n3, r3 = 1, i3 = true) {
+          this.r = t3, this.g = e3, this.b = n3, this.a = r3, i3 || (this.r *= r3, this.g *= r3, this.b *= r3, r3 || this.overwriteGetter("rgb", [t3, e3, n3, r3]));
+        }
+        static parse(t3) {
+          if (t3 instanceof Ie2) return t3;
+          if ("string" != typeof t3) return;
+          const e3 = function(t4) {
+            if ("transparent" === (t4 = t4.toLowerCase().trim())) return [0, 0, 0, 0];
+            const e4 = ve2(Ae2, t4);
+            if (e4) {
+              const [t5, n4, r3] = e4;
+              return [t5 / 255, n4 / 255, r3 / 255, 1];
+            }
+            if (t4.startsWith("#") && /^#(?:[0-9a-f]{3,4}|[0-9a-f]{6}|[0-9a-f]{8})$/.test(t4)) {
+              const e5 = t4.length < 6 ? 1 : 2;
+              let n4 = 1;
+              return [be2(t4.slice(n4, n4 += e5)), be2(t4.slice(n4, n4 += e5)), be2(t4.slice(n4, n4 += e5)), be2(t4.slice(n4, n4 + e5) || "ff")];
+            }
+            if (t4.startsWith("rgb")) {
+              const e5 = t4.match(/^rgba?\(\s*([\de.+-]+)(%)?(?:\s+|\s*(,)\s*)([\de.+-]+)(%)?(?:\s+|\s*(,)\s*)([\de.+-]+)(%)?(?:\s*([,\/])\s*([\de.+-]+)(%)?)?\s*\)$/);
+              if (e5) {
+                const [t5, n4, r3, i3, s3, o3, a3, l3, u3, c3, h3, p3] = e5, f3 = [i3 || " ", a3 || " ", c3].join("");
+                if ("  " === f3 || "  /" === f3 || ",," === f3 || ",,," === f3) {
+                  const t6 = [r3, o3, u3].join(""), e6 = "%%%" === t6 ? 100 : "" === t6 ? 255 : 0;
+                  if (e6) {
+                    const t7 = [_e2(+n4 / e6, 0, 1), _e2(+s3 / e6, 0, 1), _e2(+l3 / e6, 0, 1), h3 ? we2(+h3, p3) : 1];
+                    if (Se2(t7)) return t7;
+                  }
+                }
+                return;
+              }
+            }
+            const n3 = t4.match(/^hsla?\(\s*([\de.+-]+)(?:deg)?(?:\s+|\s*(,)\s*)([\de.+-]+)%(?:\s+|\s*(,)\s*)([\de.+-]+)%(?:\s*([,\/])\s*([\de.+-]+)(%)?)?\s*\)$/);
+            if (n3) {
+              const [t5, e5, r3, i3, s3, o3, a3, l3, u3] = n3, c3 = [r3 || " ", s3 || " ", a3].join("");
+              if ("  " === c3 || "  /" === c3 || ",," === c3 || ",,," === c3) {
+                const t6 = [+e5, _e2(+i3, 0, 100), _e2(+o3, 0, 100), l3 ? we2(+l3, u3) : 1];
+                if (Se2(t6)) return function([t7, e6, n4, r4]) {
+                  function i4(r5) {
+                    const i5 = (r5 + t7 / 30) % 12, s4 = e6 * Math.min(n4, 1 - n4);
+                    return n4 - s4 * Math.max(-1, Math.min(i5 - 3, 9 - i5, 1));
+                  }
+                  return t7 = he2(t7), e6 /= 100, n4 /= 100, [i4(0), i4(8), i4(4), r4];
+                }(t6);
+              }
+            }
+          }(t3);
+          return e3 ? new Ie2(...e3, false) : void 0;
+        }
+        get rgb() {
+          const { r: t3, g: e3, b: n3, a: r3 } = this, i3 = r3 || 1 / 0;
+          return this.overwriteGetter("rgb", [t3 / i3, e3 / i3, n3 / i3, r3]);
+        }
+        get hcl() {
+          return this.overwriteGetter("hcl", function(t3) {
+            const [e3, n3, r3, i3] = pe2(t3), s3 = Math.sqrt(n3 * n3 + r3 * r3);
+            return [Math.round(1e4 * s3) ? he2(Math.atan2(r3, n3) * ce2) : NaN, s3, e3, i3];
+          }(this.rgb));
+        }
+        get lab() {
+          return this.overwriteGetter("lab", pe2(this.rgb));
+        }
+        overwriteGetter(t3, e3) {
+          return Object.defineProperty(this, t3, { value: e3 }), e3;
+        }
+        toString() {
+          const [t3, e3, n3, r3] = this.rgb;
+          return `rgba(${[t3, e3, n3].map((t4) => Math.round(255 * t4)).join(",")},${r3})`;
+        }
+        static interpolate(t3, e3, n3, r3 = "rgb") {
+          switch (r3) {
+            case "rgb": {
+              const [r4, i3, s3, o3] = ke2(t3.rgb, e3.rgb, n3);
+              return new Ie2(r4, i3, s3, o3, false);
+            }
+            case "hcl": {
+              const [r4, i3, s3, o3] = t3.hcl, [a3, l3, u3, c3] = e3.hcl;
+              let h3, p3;
+              if (isNaN(r4) || isNaN(a3)) isNaN(r4) ? isNaN(a3) ? h3 = NaN : (h3 = a3, 1 !== s3 && 0 !== s3 || (p3 = l3)) : (h3 = r4, 1 !== u3 && 0 !== u3 || (p3 = i3));
+              else {
+                let t4 = a3 - r4;
+                a3 > r4 && t4 > 180 ? t4 -= 360 : a3 < r4 && r4 - a3 > 180 && (t4 += 360), h3 = r4 + n3 * t4;
+              }
+              const [f3, d3, y3, m3] = function([t4, e4, n4, r5]) {
+                return t4 = isNaN(t4) ? 0 : t4 * ue2, ye2([n4, Math.cos(t4) * e4, Math.sin(t4) * e4, r5]);
+              }([h3, null != p3 ? p3 : Me2(i3, l3, n3), Me2(s3, u3, n3), Me2(o3, c3, n3)]);
+              return new Ie2(f3, d3, y3, m3, false);
+            }
+            case "lab": {
+              const [r4, i3, s3, o3] = ye2(ke2(t3.lab, e3.lab, n3));
+              return new Ie2(r4, i3, s3, o3, false);
+            }
+          }
+        }
+      }
+      Ie2.black = new Ie2(0, 0, 0, 1), Ie2.white = new Ie2(1, 1, 1, 1), Ie2.transparent = new Ie2(0, 0, 0, 0), Ie2.red = new Ie2(1, 0, 0, 1);
+      class Ee2 {
+        constructor(t3, e3, n3) {
+          this.sensitivity = t3 ? e3 ? "variant" : "case" : e3 ? "accent" : "base", this.locale = n3, this.collator = new Intl.Collator(this.locale ? this.locale : [], { sensitivity: this.sensitivity, usage: "search" });
+        }
+        compare(t3, e3) {
+          return this.collator.compare(t3, e3);
+        }
+        resolvedLocale() {
+          return new Intl.Collator(this.locale ? this.locale : []).resolvedOptions().locale;
+        }
+      }
+      const Te2 = ["bottom", "center", "top"];
+      class Fe2 {
+        constructor(t3, e3, n3, r3, i3, s3) {
+          this.text = t3, this.image = e3, this.scale = n3, this.fontStack = r3, this.textColor = i3, this.verticalAlign = s3;
+        }
+      }
+      class De2 {
+        constructor(t3) {
+          this.sections = t3;
+        }
+        static fromString(t3) {
+          return new De2([new Fe2(t3, null, null, null, null, null)]);
+        }
+        isEmpty() {
+          return 0 === this.sections.length || !this.sections.some((t3) => 0 !== t3.text.length || t3.image && 0 !== t3.image.name.length);
+        }
+        static factory(t3) {
+          return t3 instanceof De2 ? t3 : De2.fromString(t3);
+        }
+        toString() {
+          return 0 === this.sections.length ? "" : this.sections.map((t3) => t3.text).join("");
+        }
+      }
+      class Pe2 {
+        constructor(t3) {
+          this.values = t3.slice();
+        }
+        static parse(t3) {
+          if (t3 instanceof Pe2) return t3;
+          if ("number" == typeof t3) return new Pe2([t3, t3, t3, t3]);
+          if (Array.isArray(t3) && !(t3.length < 1 || t3.length > 4)) {
+            for (const e3 of t3) if ("number" != typeof e3) return;
+            switch (t3.length) {
+              case 1:
+                t3 = [t3[0], t3[0], t3[0], t3[0]];
+                break;
+              case 2:
+                t3 = [t3[0], t3[1], t3[0], t3[1]];
+                break;
+              case 3:
+                t3 = [t3[0], t3[1], t3[2], t3[1]];
+            }
+            return new Pe2(t3);
+          }
+        }
+        toString() {
+          return JSON.stringify(this.values);
+        }
+        static interpolate(t3, e3, n3) {
+          return new Pe2(ke2(t3.values, e3.values, n3));
+        }
+      }
+      class ze2 {
+        constructor(t3) {
+          this.values = t3.slice();
+        }
+        static parse(t3) {
+          if (t3 instanceof ze2) return t3;
+          if ("number" == typeof t3) return new ze2([t3]);
+          if (Array.isArray(t3)) {
+            for (const e3 of t3) if ("number" != typeof e3) return;
+            return new ze2(t3);
+          }
+        }
+        toString() {
+          return JSON.stringify(this.values);
+        }
+        static interpolate(t3, e3, n3) {
+          return new ze2(ke2(t3.values, e3.values, n3));
+        }
+      }
+      class Be2 {
+        constructor(t3) {
+          this.values = t3.slice();
+        }
+        static parse(t3) {
+          if (t3 instanceof Be2) return t3;
+          if ("string" == typeof t3) {
+            const e4 = Ie2.parse(t3);
+            if (!e4) return;
+            return new Be2([e4]);
+          }
+          if (!Array.isArray(t3)) return;
+          const e3 = [];
+          for (const n3 of t3) {
+            if ("string" != typeof n3) return;
+            const t4 = Ie2.parse(n3);
+            if (!t4) return;
+            e3.push(t4);
+          }
+          return new Be2(e3);
+        }
+        toString() {
+          return JSON.stringify(this.values);
+        }
+        static interpolate(t3, e3, n3, r3 = "rgb") {
+          const i3 = [];
+          if (t3.values.length != e3.values.length) throw new Error(`colorArray: Arrays have mismatched length (${t3.values.length} vs. ${e3.values.length}), cannot interpolate.`);
+          for (let s3 = 0; s3 < t3.values.length; s3++) i3.push(Ie2.interpolate(t3.values[s3], e3.values[s3], n3, r3));
+          return new Be2(i3);
+        }
+      }
+      class Ce2 extends Error {
+        constructor(t3) {
+          super(t3), this.name = "RuntimeError";
+        }
+        toJSON() {
+          return this.message;
+        }
+      }
+      const Ve2 = /* @__PURE__ */ new Set(["center", "left", "right", "top", "bottom", "top-left", "top-right", "bottom-left", "bottom-right"]);
+      class Le2 {
+        constructor(t3) {
+          this.values = t3.slice();
+        }
+        static parse(t3) {
+          if (t3 instanceof Le2) return t3;
+          if (Array.isArray(t3) && !(t3.length < 1) && t3.length % 2 == 0) {
+            for (let e3 = 0; e3 < t3.length; e3 += 2) {
+              const n3 = t3[e3], r3 = t3[e3 + 1];
+              if ("string" != typeof n3 || !Ve2.has(n3)) return;
+              if (!Array.isArray(r3) || 2 !== r3.length || "number" != typeof r3[0] || "number" != typeof r3[1]) return;
+            }
+            return new Le2(t3);
+          }
+        }
+        toString() {
+          return JSON.stringify(this.values);
+        }
+        static interpolate(t3, e3, n3) {
+          const r3 = t3.values, i3 = e3.values;
+          if (r3.length !== i3.length) throw new Ce2(`Cannot interpolate values of different length. from: ${t3.toString()}, to: ${e3.toString()}`);
+          const s3 = [];
+          for (let t4 = 0; t4 < r3.length; t4 += 2) {
+            if (r3[t4] !== i3[t4]) throw new Ce2(`Cannot interpolate values containing mismatched anchors. from[${t4}]: ${r3[t4]}, to[${t4}]: ${i3[t4]}`);
+            s3.push(r3[t4]);
+            const [e4, o3] = r3[t4 + 1], [a3, l3] = i3[t4 + 1];
+            s3.push([Me2(e4, a3, n3), Me2(o3, l3, n3)]);
+          }
+          return new Le2(s3);
+        }
+      }
+      class Oe2 {
+        constructor(t3) {
+          this.name = t3.name, this.available = t3.available;
+        }
+        toString() {
+          return this.name;
+        }
+        static fromString(t3) {
+          return t3 ? new Oe2({ name: t3, available: false }) : null;
+        }
+      }
+      class $e2 {
+        constructor(t3, e3, n3) {
+          this.from = t3, this.to = e3, this.transition = n3;
+        }
+        static interpolate(t3, e3, n3) {
+          return new $e2(t3, e3, n3);
+        }
+        static parse(t3) {
+          return t3 instanceof $e2 ? t3 : Array.isArray(t3) && 3 === t3.length && "string" == typeof t3[0] && "string" == typeof t3[1] && "number" == typeof t3[2] ? new $e2(t3[0], t3[1], t3[2]) : "object" == typeof t3 && "string" == typeof t3.from && "string" == typeof t3.to && "number" == typeof t3.transition ? new $e2(t3.from, t3.to, t3.transition) : "string" == typeof t3 ? new $e2(t3, t3, 1) : void 0;
+        }
+      }
+      function Re2(t3, e3, n3, r3) {
+        return "number" == typeof t3 && t3 >= 0 && t3 <= 255 && "number" == typeof e3 && e3 >= 0 && e3 <= 255 && "number" == typeof n3 && n3 >= 0 && n3 <= 255 ? void 0 === r3 || "number" == typeof r3 && r3 >= 0 && r3 <= 1 ? null : `Invalid rgba value [${[t3, e3, n3, r3].join(", ")}]: 'a' must be between 0 and 1.` : `Invalid rgba value [${("number" == typeof r3 ? [t3, e3, n3, r3] : [t3, e3, n3]).join(", ")}]: 'r', 'g', and 'b' must be between 0 and 255.`;
+      }
+      function Ne2(t3) {
+        if (null === t3 || "string" == typeof t3 || "boolean" == typeof t3 || "number" == typeof t3 || t3 instanceof $e2 || t3 instanceof Ie2 || t3 instanceof Ee2 || t3 instanceof De2 || t3 instanceof Pe2 || t3 instanceof ze2 || t3 instanceof Be2 || t3 instanceof Le2 || t3 instanceof Oe2) return true;
+        if (Array.isArray(t3)) {
+          for (const e3 of t3) if (!Ne2(e3)) return false;
+          return true;
+        }
+        if ("object" == typeof t3) {
+          for (const e3 in t3) if (!Ne2(t3[e3])) return false;
+          return true;
+        }
+        return false;
+      }
+      function Ue2(t3) {
+        if (null === t3) return Ct;
+        if ("string" == typeof t3) return Lt;
+        if ("boolean" == typeof t3) return Ot;
+        if ("number" == typeof t3) return Vt;
+        if (t3 instanceof Ie2) return $t;
+        if (t3 instanceof $e2) return Rt;
+        if (t3 instanceof Ee2) return jt;
+        if (t3 instanceof De2) return qt;
+        if (t3 instanceof Pe2) return Gt;
+        if (t3 instanceof ze2) return Yt;
+        if (t3 instanceof Be2) return Xt;
+        if (t3 instanceof Le2) return Ht;
+        if (t3 instanceof Oe2) return Zt;
+        if (Array.isArray(t3)) {
+          const e3 = t3.length;
+          let n3;
+          for (const e4 of t3) {
+            const t4 = Ue2(e4);
+            if (n3) {
+              if (n3 === t4) continue;
+              n3 = Ut;
+              break;
+            }
+            n3 = t4;
+          }
+          return Wt(n3 || Ut, e3);
+        }
+        return Nt;
+      }
+      function je2(t3) {
+        const e3 = typeof t3;
+        return null === t3 ? "" : "string" === e3 || "number" === e3 || "boolean" === e3 ? String(t3) : t3 instanceof Ie2 || t3 instanceof $e2 || t3 instanceof De2 || t3 instanceof Pe2 || t3 instanceof ze2 || t3 instanceof Be2 || t3 instanceof Le2 || t3 instanceof Oe2 ? t3.toString() : JSON.stringify(t3);
+      }
+      class qe2 {
+        constructor(t3, e3) {
+          this.type = t3, this.value = e3;
+        }
+        static parse(t3, e3) {
+          if (2 !== t3.length) return e3.error(`'literal' expression requires exactly one argument, but found ${t3.length - 1} instead.`);
+          if (!Ne2(t3[1])) return e3.error("invalid value");
+          const n3 = t3[1];
+          let r3 = Ue2(n3);
+          const i3 = e3.expectedType;
+          return "array" !== r3.kind || 0 !== r3.N || !i3 || "array" !== i3.kind || "number" == typeof i3.N && 0 !== i3.N || (r3 = i3), new qe2(r3, n3);
+        }
+        evaluate() {
+          return this.value;
+        }
+        eachChild() {
+        }
+        outputDefined() {
+          return true;
+        }
+      }
+      const Ge2 = { string: Lt, number: Vt, boolean: Ot, object: Nt };
+      class Xe2 {
+        constructor(t3, e3) {
+          this.type = t3, this.args = e3;
+        }
+        static parse(t3, e3) {
+          if (t3.length < 2) return e3.error("Expected at least one argument.");
+          let n3, r3 = 1;
+          const i3 = t3[0];
+          if ("array" === i3) {
+            let i4, s4;
+            if (t3.length > 2) {
+              const n4 = t3[1];
+              if ("string" != typeof n4 || !(n4 in Ge2) || "object" === n4) return e3.error('The item type argument of "array" must be one of string, number, boolean', 1);
+              i4 = Ge2[n4], r3++;
+            } else i4 = Ut;
+            if (t3.length > 3) {
+              if (null !== t3[2] && ("number" != typeof t3[2] || t3[2] < 0 || t3[2] !== Math.floor(t3[2]))) return e3.error('The length argument to "array" must be a positive integer literal', 2);
+              s4 = t3[2], r3++;
+            }
+            n3 = Wt(i4, s4);
+          } else {
+            if (!Ge2[i3]) throw new Error(`Types doesn't contain name = ${i3}`);
+            n3 = Ge2[i3];
+          }
+          const s3 = [];
+          for (; r3 < t3.length; r3++) {
+            const n4 = e3.parse(t3[r3], r3, Ut);
+            if (!n4) return null;
+            s3.push(n4);
+          }
+          return new Xe2(n3, s3);
+        }
+        evaluate(t3) {
+          for (let e3 = 0; e3 < this.args.length; e3++) {
+            const n3 = this.args[e3].evaluate(t3);
+            if (!Qt(this.type, Ue2(n3))) return n3;
+            if (e3 === this.args.length - 1) throw new Ce2(`Expected value to be of type ${Kt(this.type)}, but found ${Kt(Ue2(n3))} instead.`);
+          }
+          throw new Error();
+        }
+        eachChild(t3) {
+          this.args.forEach(t3);
+        }
+        outputDefined() {
+          return this.args.every((t3) => t3.outputDefined());
+        }
+      }
+      const Ye2 = { "to-boolean": Ot, "to-color": $t, "to-number": Vt, "to-string": Lt };
+      class Ze2 {
+        constructor(t3, e3) {
+          this.type = t3, this.args = e3;
+        }
+        static parse(t3, e3) {
+          if (t3.length < 2) return e3.error("Expected at least one argument.");
+          const n3 = t3[0];
+          if (!Ye2[n3]) throw new Error(`Can't parse ${n3} as it is not part of the known types`);
+          if (("to-boolean" === n3 || "to-string" === n3) && 2 !== t3.length) return e3.error("Expected one argument.");
+          const r3 = Ye2[n3], i3 = [];
+          for (let n4 = 1; n4 < t3.length; n4++) {
+            const r4 = e3.parse(t3[n4], n4, Ut);
+            if (!r4) return null;
+            i3.push(r4);
+          }
+          return new Ze2(r3, i3);
+        }
+        evaluate(t3) {
+          switch (this.type.kind) {
+            case "boolean":
+              return Boolean(this.args[0].evaluate(t3));
+            case "color": {
+              let e3, n3;
+              for (const r3 of this.args) {
+                if (e3 = r3.evaluate(t3), n3 = null, e3 instanceof Ie2) return e3;
+                if ("string" == typeof e3) {
+                  const n4 = t3.parseColor(e3);
+                  if (n4) return n4;
+                } else if (Array.isArray(e3) && (n3 = e3.length < 3 || e3.length > 4 ? `Invalid rgba value ${JSON.stringify(e3)}: expected an array containing either three or four numeric values.` : Re2(e3[0], e3[1], e3[2], e3[3]), !n3)) return new Ie2(e3[0] / 255, e3[1] / 255, e3[2] / 255, e3[3]);
+              }
+              throw new Ce2(n3 || `Could not parse color from value '${"string" == typeof e3 ? e3 : JSON.stringify(e3)}'`);
+            }
+            case "padding": {
+              let e3;
+              for (const n3 of this.args) {
+                e3 = n3.evaluate(t3);
+                const r3 = Pe2.parse(e3);
+                if (r3) return r3;
+              }
+              throw new Ce2(`Could not parse padding from value '${"string" == typeof e3 ? e3 : JSON.stringify(e3)}'`);
+            }
+            case "numberArray": {
+              let e3;
+              for (const n3 of this.args) {
+                e3 = n3.evaluate(t3);
+                const r3 = ze2.parse(e3);
+                if (r3) return r3;
+              }
+              throw new Ce2(`Could not parse numberArray from value '${"string" == typeof e3 ? e3 : JSON.stringify(e3)}'`);
+            }
+            case "colorArray": {
+              let e3;
+              for (const n3 of this.args) {
+                e3 = n3.evaluate(t3);
+                const r3 = Be2.parse(e3);
+                if (r3) return r3;
+              }
+              throw new Ce2(`Could not parse colorArray from value '${"string" == typeof e3 ? e3 : JSON.stringify(e3)}'`);
+            }
+            case "variableAnchorOffsetCollection": {
+              let e3;
+              for (const n3 of this.args) {
+                e3 = n3.evaluate(t3);
+                const r3 = Le2.parse(e3);
+                if (r3) return r3;
+              }
+              throw new Ce2(`Could not parse variableAnchorOffsetCollection from value '${"string" == typeof e3 ? e3 : JSON.stringify(e3)}'`);
+            }
+            case "number": {
+              let e3 = null;
+              for (const n3 of this.args) {
+                if (e3 = n3.evaluate(t3), null === e3) return 0;
+                const r3 = Number(e3);
+                if (!isNaN(r3)) return r3;
+              }
+              throw new Ce2(`Could not convert ${JSON.stringify(e3)} to number.`);
+            }
+            case "formatted":
+              return De2.fromString(je2(this.args[0].evaluate(t3)));
+            case "resolvedImage":
+              return Oe2.fromString(je2(this.args[0].evaluate(t3)));
+            case "projectionDefinition":
+              return this.args[0].evaluate(t3);
+            default:
+              return je2(this.args[0].evaluate(t3));
+          }
+        }
+        eachChild(t3) {
+          this.args.forEach(t3);
+        }
+        outputDefined() {
+          return this.args.every((t3) => t3.outputDefined());
+        }
+      }
+      const He2 = ["Unknown", "Point", "LineString", "Polygon"];
+      class We2 {
+        constructor() {
+          this.globals = null, this.feature = null, this.featureState = null, this.formattedSection = null, this._parseColorCache = /* @__PURE__ */ new Map(), this.availableImages = null, this.canonical = null;
+        }
+        id() {
+          return this.feature && "id" in this.feature ? this.feature.id : null;
+        }
+        geometryType() {
+          return this.feature ? "number" == typeof this.feature.type ? He2[this.feature.type] : this.feature.type : null;
+        }
+        geometry() {
+          return this.feature && "geometry" in this.feature ? this.feature.geometry : null;
+        }
+        canonicalID() {
+          return this.canonical;
+        }
+        properties() {
+          return this.feature && this.feature.properties || {};
+        }
+        parseColor(t3) {
+          let e3 = this._parseColorCache.get(t3);
+          return e3 || (e3 = Ie2.parse(t3), this._parseColorCache.set(t3, e3)), e3;
+        }
+      }
+      class Ke2 {
+        constructor(t3, e3, n3 = [], r3, i3 = new Bt(), s3 = []) {
+          this.registry = t3, this.path = n3, this.key = n3.map((t4) => `[${t4}]`).join(""), this.scope = i3, this.errors = s3, this.expectedType = r3, this._isConstant = e3;
+        }
+        parse(t3, e3, n3, r3, i3 = {}) {
+          return e3 ? this.concat(e3, n3, r3)._parse(t3, i3) : this._parse(t3, i3);
+        }
+        _parse(t3, e3) {
+          function n3(t4, e4, n4) {
+            return "assert" === n4 ? new Xe2(e4, [t4]) : "coerce" === n4 ? new Ze2(e4, [t4]) : t4;
+          }
+          if (null !== t3 && "string" != typeof t3 && "boolean" != typeof t3 && "number" != typeof t3 || (t3 = ["literal", t3]), Array.isArray(t3)) {
+            if (0 === t3.length) return this.error('Expected an array with at least one element. If you wanted a literal array, use ["literal", []].');
+            const r3 = t3[0];
+            if ("string" != typeof r3) return this.error(`Expression name must be a string, but found ${typeof r3} instead. If you wanted a literal array, use ["literal", [...]].`, 0), null;
+            const i3 = this.registry[r3];
+            if (i3) {
+              let r4 = i3.parse(t3, this);
+              if (!r4) return null;
+              if (this.expectedType) {
+                const t4 = this.expectedType, i4 = r4.type;
+                if ("string" !== t4.kind && "number" !== t4.kind && "boolean" !== t4.kind && "object" !== t4.kind && "array" !== t4.kind || "value" !== i4.kind) {
+                  if ("projectionDefinition" === t4.kind && ["string", "array"].includes(i4.kind) || ["color", "formatted", "resolvedImage"].includes(t4.kind) && ["value", "string"].includes(i4.kind) || ["padding", "numberArray"].includes(t4.kind) && ["value", "number", "array"].includes(i4.kind) || "colorArray" === t4.kind && ["value", "string", "array"].includes(i4.kind) || "variableAnchorOffsetCollection" === t4.kind && ["value", "array"].includes(i4.kind)) r4 = n3(r4, t4, e3.typeAnnotation || "coerce");
+                  else if (this.checkSubtype(t4, i4)) return null;
+                } else r4 = n3(r4, t4, e3.typeAnnotation || "assert");
+              }
+              if (!(r4 instanceof qe2) && "resolvedImage" !== r4.type.kind && this._isConstant(r4)) {
+                const t4 = new We2();
+                try {
+                  r4 = new qe2(r4.type, r4.evaluate(t4));
+                } catch (t5) {
+                  return this.error(t5.message), null;
+                }
+              }
+              return r4;
+            }
+            return this.error(`Unknown expression "${r3}". If you wanted a literal array, use ["literal", [...]].`, 0);
+          }
+          return this.error(void 0 === t3 ? "'undefined' value invalid. Use null instead." : "object" == typeof t3 ? 'Bare objects invalid. Use ["literal", {...}] instead.' : `Expected an array, but found ${typeof t3} instead.`);
+        }
+        concat(t3, e3, n3) {
+          const r3 = "number" == typeof t3 ? this.path.concat(t3) : this.path, i3 = n3 ? this.scope.concat(n3) : this.scope;
+          return new Ke2(this.registry, this._isConstant, r3, e3 || null, i3, this.errors);
+        }
+        error(t3, ...e3) {
+          const n3 = `${this.key}${e3.map((t4) => `[${t4}]`).join("")}`;
+          this.errors.push(new zt(n3, t3));
+        }
+        checkSubtype(t3, e3) {
+          const n3 = Qt(t3, e3);
+          return n3 && this.error(n3), n3;
+        }
+      }
+      class Je2 {
+        constructor(t3, e3) {
+          this.type = e3.type, this.bindings = [].concat(t3), this.result = e3;
+        }
+        evaluate(t3) {
+          return this.result.evaluate(t3);
+        }
+        eachChild(t3) {
+          for (const e3 of this.bindings) t3(e3[1]);
+          t3(this.result);
+        }
+        static parse(t3, e3) {
+          if (t3.length < 4) return e3.error(`Expected at least 3 arguments, but found ${t3.length - 1} instead.`);
+          const n3 = [];
+          for (let r4 = 1; r4 < t3.length - 1; r4 += 2) {
+            const i3 = t3[r4];
+            if ("string" != typeof i3) return e3.error(`Expected string, but found ${typeof i3} instead.`, r4);
+            if (/[^a-zA-Z0-9_]/.test(i3)) return e3.error("Variable names must contain only alphanumeric characters or '_'.", r4);
+            const s3 = e3.parse(t3[r4 + 1], r4 + 1);
+            if (!s3) return null;
+            n3.push([i3, s3]);
+          }
+          const r3 = e3.parse(t3[t3.length - 1], t3.length - 1, e3.expectedType, n3);
+          return r3 ? new Je2(n3, r3) : null;
+        }
+        outputDefined() {
+          return this.result.outputDefined();
+        }
+      }
+      class Qe2 {
+        constructor(t3, e3) {
+          this.type = e3.type, this.name = t3, this.boundExpression = e3;
+        }
+        static parse(t3, e3) {
+          if (2 !== t3.length || "string" != typeof t3[1]) return e3.error("'var' expression requires exactly one string literal argument.");
+          const n3 = t3[1];
+          return e3.scope.has(n3) ? new Qe2(n3, e3.scope.get(n3)) : e3.error(`Unknown variable "${n3}". Make sure "${n3}" has been bound in an enclosing "let" expression before using it.`, 1);
+        }
+        evaluate(t3) {
+          return this.boundExpression.evaluate(t3);
+        }
+        eachChild() {
+        }
+        outputDefined() {
+          return false;
+        }
+      }
+      class tn {
+        constructor(t3, e3, n3) {
+          this.type = t3, this.index = e3, this.input = n3;
+        }
+        static parse(t3, e3) {
+          if (3 !== t3.length) return e3.error(`Expected 2 arguments, but found ${t3.length - 1} instead.`);
+          const n3 = e3.parse(t3[1], 1, Vt), r3 = e3.parse(t3[2], 2, Wt(e3.expectedType || Ut));
+          return n3 && r3 ? new tn(r3.type.itemType, n3, r3) : null;
+        }
+        evaluate(t3) {
+          const e3 = this.index.evaluate(t3), n3 = this.input.evaluate(t3);
+          if (e3 < 0) throw new Ce2(`Array index out of bounds: ${e3} < 0.`);
+          if (e3 >= n3.length) throw new Ce2(`Array index out of bounds: ${e3} > ${n3.length - 1}.`);
+          if (e3 !== Math.floor(e3)) throw new Ce2(`Array index must be an integer, but found ${e3} instead.`);
+          return n3[e3];
+        }
+        eachChild(t3) {
+          t3(this.index), t3(this.input);
+        }
+        outputDefined() {
+          return false;
+        }
+      }
+      class en {
+        constructor(t3, e3) {
+          this.type = Ot, this.needle = t3, this.haystack = e3;
+        }
+        static parse(t3, e3) {
+          if (3 !== t3.length) return e3.error(`Expected 2 arguments, but found ${t3.length - 1} instead.`);
+          const n3 = e3.parse(t3[1], 1, Ut), r3 = e3.parse(t3[2], 2, Ut);
+          return n3 && r3 ? te2(n3.type, [Ot, Lt, Vt, Ct, Ut]) ? new en(n3, r3) : e3.error(`Expected first argument to be of type boolean, string, number or null, but found ${Kt(n3.type)} instead`) : null;
+        }
+        evaluate(t3) {
+          const e3 = this.needle.evaluate(t3), n3 = this.haystack.evaluate(t3);
+          if (!n3) return false;
+          if (!ee2(e3, ["boolean", "string", "number", "null"])) throw new Ce2(`Expected first argument to be of type boolean, string, number or null, but found ${Kt(Ue2(e3))} instead.`);
+          if (!ee2(n3, ["string", "array"])) throw new Ce2(`Expected second argument to be of type array or string, but found ${Kt(Ue2(n3))} instead.`);
+          return n3.indexOf(e3) >= 0;
+        }
+        eachChild(t3) {
+          t3(this.needle), t3(this.haystack);
+        }
+        outputDefined() {
+          return true;
+        }
+      }
+      class nn {
+        constructor(t3, e3, n3) {
+          this.type = Vt, this.needle = t3, this.haystack = e3, this.fromIndex = n3;
+        }
+        static parse(t3, e3) {
+          if (t3.length <= 2 || t3.length >= 5) return e3.error(`Expected 2 or 3 arguments, but found ${t3.length - 1} instead.`);
+          const n3 = e3.parse(t3[1], 1, Ut), r3 = e3.parse(t3[2], 2, Ut);
+          if (!n3 || !r3) return null;
+          if (!te2(n3.type, [Ot, Lt, Vt, Ct, Ut])) return e3.error(`Expected first argument to be of type boolean, string, number or null, but found ${Kt(n3.type)} instead`);
+          if (4 === t3.length) {
+            const i3 = e3.parse(t3[3], 3, Vt);
+            return i3 ? new nn(n3, r3, i3) : null;
+          }
+          return new nn(n3, r3);
+        }
+        evaluate(t3) {
+          const e3 = this.needle.evaluate(t3), n3 = this.haystack.evaluate(t3);
+          if (!ee2(e3, ["boolean", "string", "number", "null"])) throw new Ce2(`Expected first argument to be of type boolean, string, number or null, but found ${Kt(Ue2(e3))} instead.`);
+          let r3;
+          if (this.fromIndex && (r3 = this.fromIndex.evaluate(t3)), ee2(n3, ["string"])) {
+            const t4 = n3.indexOf(e3, r3);
+            return -1 === t4 ? -1 : [...n3.slice(0, t4)].length;
+          }
+          if (ee2(n3, ["array"])) return n3.indexOf(e3, r3);
+          throw new Ce2(`Expected second argument to be of type array or string, but found ${Kt(Ue2(n3))} instead.`);
+        }
+        eachChild(t3) {
+          t3(this.needle), t3(this.haystack), this.fromIndex && t3(this.fromIndex);
+        }
+        outputDefined() {
+          return false;
+        }
+      }
+      class rn {
+        constructor(t3, e3, n3, r3, i3, s3) {
+          this.inputType = t3, this.type = e3, this.input = n3, this.cases = r3, this.outputs = i3, this.otherwise = s3;
+        }
+        static parse(t3, e3) {
+          if (t3.length < 5) return e3.error(`Expected at least 4 arguments, but found only ${t3.length - 1}.`);
+          if (t3.length % 2 != 1) return e3.error("Expected an even number of arguments.");
+          let n3, r3;
+          e3.expectedType && "value" !== e3.expectedType.kind && (r3 = e3.expectedType);
+          const i3 = {}, s3 = [];
+          for (let o4 = 2; o4 < t3.length - 1; o4 += 2) {
+            let a4 = t3[o4];
+            const l3 = t3[o4 + 1];
+            Array.isArray(a4) || (a4 = [a4]);
+            const u3 = e3.concat(o4);
+            if (0 === a4.length) return u3.error("Expected at least one branch label.");
+            for (const t4 of a4) {
+              if ("number" != typeof t4 && "string" != typeof t4) return u3.error("Branch labels must be numbers or strings.");
+              if ("number" == typeof t4 && Math.abs(t4) > Number.MAX_SAFE_INTEGER) return u3.error(`Branch labels must be integers no larger than ${Number.MAX_SAFE_INTEGER}.`);
+              if ("number" == typeof t4 && Math.floor(t4) !== t4) return u3.error("Numeric branch labels must be integer values.");
+              if (n3) {
+                if (u3.checkSubtype(n3, Ue2(t4))) return null;
+              } else n3 = Ue2(t4);
+              if (void 0 !== i3[String(t4)]) return u3.error("Branch labels must be unique.");
+              i3[String(t4)] = s3.length;
+            }
+            const c3 = e3.parse(l3, o4, r3);
+            if (!c3) return null;
+            r3 = r3 || c3.type, s3.push(c3);
+          }
+          const o3 = e3.parse(t3[1], 1, Ut);
+          if (!o3) return null;
+          const a3 = e3.parse(t3[t3.length - 1], t3.length - 1, r3);
+          return a3 ? "value" !== o3.type.kind && e3.concat(1).checkSubtype(n3, o3.type) ? null : new rn(n3, r3, o3, i3, s3, a3) : null;
+        }
+        evaluate(t3) {
+          const e3 = this.input.evaluate(t3);
+          return (Ue2(e3) === this.inputType && this.outputs[this.cases[e3]] || this.otherwise).evaluate(t3);
+        }
+        eachChild(t3) {
+          t3(this.input), this.outputs.forEach(t3), t3(this.otherwise);
+        }
+        outputDefined() {
+          return this.outputs.every((t3) => t3.outputDefined()) && this.otherwise.outputDefined();
+        }
+      }
+      class sn {
+        constructor(t3, e3, n3) {
+          this.type = t3, this.branches = e3, this.otherwise = n3;
+        }
+        static parse(t3, e3) {
+          if (t3.length < 4) return e3.error(`Expected at least 3 arguments, but found only ${t3.length - 1}.`);
+          if (t3.length % 2 != 0) return e3.error("Expected an odd number of arguments.");
+          let n3;
+          e3.expectedType && "value" !== e3.expectedType.kind && (n3 = e3.expectedType);
+          const r3 = [];
+          for (let i4 = 1; i4 < t3.length - 1; i4 += 2) {
+            const s3 = e3.parse(t3[i4], i4, Ot);
+            if (!s3) return null;
+            const o3 = e3.parse(t3[i4 + 1], i4 + 1, n3);
+            if (!o3) return null;
+            r3.push([s3, o3]), n3 = n3 || o3.type;
+          }
+          const i3 = e3.parse(t3[t3.length - 1], t3.length - 1, n3);
+          if (!i3) return null;
+          if (!n3) throw new Error("Can't infer output type");
+          return new sn(n3, r3, i3);
+        }
+        evaluate(t3) {
+          for (const [e3, n3] of this.branches) if (e3.evaluate(t3)) return n3.evaluate(t3);
+          return this.otherwise.evaluate(t3);
+        }
+        eachChild(t3) {
+          for (const [e3, n3] of this.branches) t3(e3), t3(n3);
+          t3(this.otherwise);
+        }
+        outputDefined() {
+          return this.branches.every(([t3, e3]) => e3.outputDefined()) && this.otherwise.outputDefined();
+        }
+      }
+      class on {
+        constructor(t3, e3, n3, r3) {
+          this.type = t3, this.input = e3, this.beginIndex = n3, this.endIndex = r3;
+        }
+        static parse(t3, e3) {
+          if (t3.length <= 2 || t3.length >= 5) return e3.error(`Expected 2 or 3 arguments, but found ${t3.length - 1} instead.`);
+          const n3 = e3.parse(t3[1], 1, Ut), r3 = e3.parse(t3[2], 2, Vt);
+          if (!n3 || !r3) return null;
+          if (!te2(n3.type, [Wt(Ut), Lt, Ut])) return e3.error(`Expected first argument to be of type array or string, but found ${Kt(n3.type)} instead`);
+          if (4 === t3.length) {
+            const i3 = e3.parse(t3[3], 3, Vt);
+            return i3 ? new on(n3.type, n3, r3, i3) : null;
+          }
+          return new on(n3.type, n3, r3);
+        }
+        evaluate(t3) {
+          const e3 = this.input.evaluate(t3), n3 = this.beginIndex.evaluate(t3);
+          let r3;
+          if (this.endIndex && (r3 = this.endIndex.evaluate(t3)), ee2(e3, ["string"])) return [...e3].slice(n3, r3).join("");
+          if (ee2(e3, ["array"])) return e3.slice(n3, r3);
+          throw new Ce2(`Expected first argument to be of type array or string, but found ${Kt(Ue2(e3))} instead.`);
+        }
+        eachChild(t3) {
+          t3(this.input), t3(this.beginIndex), this.endIndex && t3(this.endIndex);
+        }
+        outputDefined() {
+          return false;
+        }
+      }
+      function an(t3, e3) {
+        const n3 = t3.length - 1;
+        let r3, i3, s3 = 0, o3 = n3, a3 = 0;
+        for (; s3 <= o3; ) if (a3 = Math.floor((s3 + o3) / 2), r3 = t3[a3], i3 = t3[a3 + 1], r3 <= e3) {
+          if (a3 === n3 || e3 < i3) return a3;
+          s3 = a3 + 1;
+        } else {
+          if (!(r3 > e3)) throw new Ce2("Input is not a number.");
+          o3 = a3 - 1;
+        }
+        return 0;
+      }
+      class ln {
+        constructor(t3, e3, n3) {
+          this.type = t3, this.input = e3, this.labels = [], this.outputs = [];
+          for (const [t4, e4] of n3) this.labels.push(t4), this.outputs.push(e4);
+        }
+        static parse(t3, e3) {
+          if (t3.length - 1 < 4) return e3.error(`Expected at least 4 arguments, but found only ${t3.length - 1}.`);
+          if ((t3.length - 1) % 2 != 0) return e3.error("Expected an even number of arguments.");
+          const n3 = e3.parse(t3[1], 1, Vt);
+          if (!n3) return null;
+          const r3 = [];
+          let i3 = null;
+          e3.expectedType && "value" !== e3.expectedType.kind && (i3 = e3.expectedType);
+          for (let n4 = 1; n4 < t3.length; n4 += 2) {
+            const s3 = 1 === n4 ? -1 / 0 : t3[n4], o3 = t3[n4 + 1], a3 = n4, l3 = n4 + 1;
+            if ("number" != typeof s3) return e3.error('Input/output pairs for "step" expressions must be defined using literal numeric values (not computed expressions) for the input values.', a3);
+            if (r3.length && r3[r3.length - 1][0] >= s3) return e3.error('Input/output pairs for "step" expressions must be arranged with input values in strictly ascending order.', a3);
+            const u3 = e3.parse(o3, l3, i3);
+            if (!u3) return null;
+            i3 = i3 || u3.type, r3.push([s3, u3]);
+          }
+          return new ln(i3, n3, r3);
+        }
+        evaluate(t3) {
+          const e3 = this.labels, n3 = this.outputs;
+          if (1 === e3.length) return n3[0].evaluate(t3);
+          const r3 = this.input.evaluate(t3);
+          if (r3 <= e3[0]) return n3[0].evaluate(t3);
+          const i3 = e3.length;
+          return r3 >= e3[i3 - 1] ? n3[i3 - 1].evaluate(t3) : n3[an(e3, r3)].evaluate(t3);
+        }
+        eachChild(t3) {
+          t3(this.input);
+          for (const e3 of this.outputs) t3(e3);
+        }
+        outputDefined() {
+          return this.outputs.every((t3) => t3.outputDefined());
+        }
+      }
+      function un(t3) {
+        return t3 && t3.__esModule && Object.prototype.hasOwnProperty.call(t3, "default") ? t3.default : t3;
+      }
+      var cn, hn, pn = function() {
+        if (hn) return cn;
+        function t3(t4, e3, n3, r3) {
+          this.cx = 3 * t4, this.bx = 3 * (n3 - t4) - this.cx, this.ax = 1 - this.cx - this.bx, this.cy = 3 * e3, this.by = 3 * (r3 - e3) - this.cy, this.ay = 1 - this.cy - this.by, this.p1x = t4, this.p1y = e3, this.p2x = n3, this.p2y = r3;
+        }
+        return hn = 1, cn = t3, t3.prototype = { sampleCurveX: function(t4) {
+          return ((this.ax * t4 + this.bx) * t4 + this.cx) * t4;
+        }, sampleCurveY: function(t4) {
+          return ((this.ay * t4 + this.by) * t4 + this.cy) * t4;
+        }, sampleCurveDerivativeX: function(t4) {
+          return (3 * this.ax * t4 + 2 * this.bx) * t4 + this.cx;
+        }, solveCurveX: function(t4, e3) {
+          if (void 0 === e3 && (e3 = 1e-6), t4 < 0) return 0;
+          if (t4 > 1) return 1;
+          for (var n3 = t4, r3 = 0; r3 < 8; r3++) {
+            var i3 = this.sampleCurveX(n3) - t4;
+            if (Math.abs(i3) < e3) return n3;
+            var s3 = this.sampleCurveDerivativeX(n3);
+            if (Math.abs(s3) < 1e-6) break;
+            n3 -= i3 / s3;
+          }
+          var o3 = 0, a3 = 1;
+          for (n3 = t4, r3 = 0; r3 < 20 && (i3 = this.sampleCurveX(n3), !(Math.abs(i3 - t4) < e3)); r3++) t4 > i3 ? o3 = n3 : a3 = n3, n3 = 0.5 * (a3 - o3) + o3;
+          return n3;
+        }, solve: function(t4, e3) {
+          return this.sampleCurveY(this.solveCurveX(t4, e3));
+        } }, cn;
+      }(), fn = un(pn);
+      class dn {
+        constructor(t3, e3, n3, r3, i3) {
+          this.type = t3, this.operator = e3, this.interpolation = n3, this.input = r3, this.labels = [], this.outputs = [];
+          for (const [t4, e4] of i3) this.labels.push(t4), this.outputs.push(e4);
+        }
+        static interpolationFactor(t3, e3, n3, r3) {
+          let i3 = 0;
+          if ("exponential" === t3.name) i3 = yn(e3, t3.base, n3, r3);
+          else if ("linear" === t3.name) i3 = yn(e3, 1, n3, r3);
+          else if ("cubic-bezier" === t3.name) {
+            const s3 = t3.controlPoints;
+            i3 = new fn(s3[0], s3[1], s3[2], s3[3]).solve(yn(e3, 1, n3, r3));
+          }
+          return i3;
+        }
+        static parse(t3, e3) {
+          let [n3, r3, i3, ...s3] = t3;
+          if (!Array.isArray(r3) || 0 === r3.length) return e3.error("Expected an interpolation type expression.", 1);
+          if ("linear" === r3[0]) r3 = { name: "linear" };
+          else if ("exponential" === r3[0]) {
+            const t4 = r3[1];
+            if ("number" != typeof t4) return e3.error("Exponential interpolation requires a numeric base.", 1, 1);
+            r3 = { name: "exponential", base: t4 };
+          } else {
+            if ("cubic-bezier" !== r3[0]) return e3.error(`Unknown interpolation type ${String(r3[0])}`, 1, 0);
+            {
+              const t4 = r3.slice(1);
+              if (4 !== t4.length || t4.some((t5) => "number" != typeof t5 || t5 < 0 || t5 > 1)) return e3.error("Cubic bezier interpolation requires four numeric arguments with values between 0 and 1.", 1);
+              r3 = { name: "cubic-bezier", controlPoints: t4 };
+            }
+          }
+          if (t3.length - 1 < 4) return e3.error(`Expected at least 4 arguments, but found only ${t3.length - 1}.`);
+          if ((t3.length - 1) % 2 != 0) return e3.error("Expected an even number of arguments.");
+          if (i3 = e3.parse(i3, 2, Vt), !i3) return null;
+          const o3 = [];
+          let a3 = null;
+          "interpolate-hcl" !== n3 && "interpolate-lab" !== n3 || e3.expectedType == Xt ? e3.expectedType && "value" !== e3.expectedType.kind && (a3 = e3.expectedType) : a3 = $t;
+          for (let t4 = 0; t4 < s3.length; t4 += 2) {
+            const n4 = s3[t4], r4 = s3[t4 + 1], i4 = t4 + 3, l3 = t4 + 4;
+            if ("number" != typeof n4) return e3.error('Input/output pairs for "interpolate" expressions must be defined using literal numeric values (not computed expressions) for the input values.', i4);
+            if (o3.length && o3[o3.length - 1][0] >= n4) return e3.error('Input/output pairs for "interpolate" expressions must be arranged with input values in strictly ascending order.', i4);
+            const u3 = e3.parse(r4, l3, a3);
+            if (!u3) return null;
+            a3 = a3 || u3.type, o3.push([n4, u3]);
+          }
+          return ne2(a3, Vt) || ne2(a3, Rt) || ne2(a3, $t) || ne2(a3, Gt) || ne2(a3, Yt) || ne2(a3, Xt) || ne2(a3, Ht) || ne2(a3, Wt(Vt)) ? new dn(a3, n3, r3, i3, o3) : e3.error(`Type ${Kt(a3)} is not interpolatable.`);
+        }
+        evaluate(t3) {
+          const e3 = this.labels, n3 = this.outputs;
+          if (1 === e3.length) return n3[0].evaluate(t3);
+          const r3 = this.input.evaluate(t3);
+          if (r3 <= e3[0]) return n3[0].evaluate(t3);
+          const i3 = e3.length;
+          if (r3 >= e3[i3 - 1]) return n3[i3 - 1].evaluate(t3);
+          const s3 = an(e3, r3), o3 = dn.interpolationFactor(this.interpolation, r3, e3[s3], e3[s3 + 1]), a3 = n3[s3].evaluate(t3), l3 = n3[s3 + 1].evaluate(t3);
+          switch (this.operator) {
+            case "interpolate":
+              switch (this.type.kind) {
+                case "number":
+                  return Me2(a3, l3, o3);
+                case "color":
+                  return Ie2.interpolate(a3, l3, o3);
+                case "padding":
+                  return Pe2.interpolate(a3, l3, o3);
+                case "colorArray":
+                  return Be2.interpolate(a3, l3, o3);
+                case "numberArray":
+                  return ze2.interpolate(a3, l3, o3);
+                case "variableAnchorOffsetCollection":
+                  return Le2.interpolate(a3, l3, o3);
+                case "array":
+                  return ke2(a3, l3, o3);
+                case "projectionDefinition":
+                  return $e2.interpolate(a3, l3, o3);
+              }
+            case "interpolate-hcl":
+              switch (this.type.kind) {
+                case "color":
+                  return Ie2.interpolate(a3, l3, o3, "hcl");
+                case "colorArray":
+                  return Be2.interpolate(a3, l3, o3, "hcl");
+              }
+            case "interpolate-lab":
+              switch (this.type.kind) {
+                case "color":
+                  return Ie2.interpolate(a3, l3, o3, "lab");
+                case "colorArray":
+                  return Be2.interpolate(a3, l3, o3, "lab");
+              }
+          }
+        }
+        eachChild(t3) {
+          t3(this.input);
+          for (const e3 of this.outputs) t3(e3);
+        }
+        outputDefined() {
+          return this.outputs.every((t3) => t3.outputDefined());
+        }
+      }
+      function yn(t3, e3, n3, r3) {
+        const i3 = r3 - n3, s3 = t3 - n3;
+        return 0 === i3 ? 0 : 1 === e3 ? s3 / i3 : (Math.pow(e3, s3) - 1) / (Math.pow(e3, i3) - 1);
+      }
+      const mn = { color: Ie2.interpolate, number: Me2, padding: Pe2.interpolate, numberArray: ze2.interpolate, colorArray: Be2.interpolate, variableAnchorOffsetCollection: Le2.interpolate, array: ke2 };
+      class gn {
+        constructor(t3, e3) {
+          this.type = t3, this.args = e3;
+        }
+        static parse(t3, e3) {
+          if (t3.length < 2) return e3.error("Expected at least one argument.");
+          let n3 = null;
+          const r3 = e3.expectedType;
+          r3 && "value" !== r3.kind && (n3 = r3);
+          const i3 = [];
+          for (const r4 of t3.slice(1)) {
+            const t4 = e3.parse(r4, 1 + i3.length, n3, void 0, { typeAnnotation: "omit" });
+            if (!t4) return null;
+            n3 = n3 || t4.type, i3.push(t4);
+          }
+          if (!n3) throw new Error("No output type");
+          const s3 = r3 && i3.some((t4) => Qt(r3, t4.type));
+          return new gn(s3 ? Ut : n3, i3);
+        }
+        evaluate(t3) {
+          let e3, n3 = null, r3 = 0;
+          for (const i3 of this.args) if (r3++, n3 = i3.evaluate(t3), n3 && n3 instanceof Oe2 && !n3.available && (e3 || (e3 = n3.name), n3 = null, r3 === this.args.length && (n3 = e3)), null !== n3) break;
+          return n3;
+        }
+        eachChild(t3) {
+          this.args.forEach(t3);
+        }
+        outputDefined() {
+          return this.args.every((t3) => t3.outputDefined());
+        }
+      }
+      function xn(t3, e3) {
+        return "==" === t3 || "!=" === t3 ? "boolean" === e3.kind || "string" === e3.kind || "number" === e3.kind || "null" === e3.kind || "value" === e3.kind : "string" === e3.kind || "number" === e3.kind || "value" === e3.kind;
+      }
+      function vn(t3, e3, n3, r3) {
+        return 0 === r3.compare(e3, n3);
+      }
+      function bn(t3, e3, n3) {
+        const r3 = "==" !== t3 && "!=" !== t3;
+        return class i3 {
+          constructor(t4, e4, n4) {
+            this.type = Ot, this.lhs = t4, this.rhs = e4, this.collator = n4, this.hasUntypedArgument = "value" === t4.type.kind || "value" === e4.type.kind;
+          }
+          static parse(t4, e4) {
+            if (3 !== t4.length && 4 !== t4.length) return e4.error("Expected two or three arguments.");
+            const n4 = t4[0];
+            let s3 = e4.parse(t4[1], 1, Ut);
+            if (!s3) return null;
+            if (!xn(n4, s3.type)) return e4.concat(1).error(`"${n4}" comparisons are not supported for type '${Kt(s3.type)}'.`);
+            let o3 = e4.parse(t4[2], 2, Ut);
+            if (!o3) return null;
+            if (!xn(n4, o3.type)) return e4.concat(2).error(`"${n4}" comparisons are not supported for type '${Kt(o3.type)}'.`);
+            if (s3.type.kind !== o3.type.kind && "value" !== s3.type.kind && "value" !== o3.type.kind) return e4.error(`Cannot compare types '${Kt(s3.type)}' and '${Kt(o3.type)}'.`);
+            r3 && ("value" === s3.type.kind && "value" !== o3.type.kind ? s3 = new Xe2(o3.type, [s3]) : "value" !== s3.type.kind && "value" === o3.type.kind && (o3 = new Xe2(s3.type, [o3])));
+            let a3 = null;
+            if (4 === t4.length) {
+              if ("string" !== s3.type.kind && "string" !== o3.type.kind && "value" !== s3.type.kind && "value" !== o3.type.kind) return e4.error("Cannot use collator to compare non-string types.");
+              if (a3 = e4.parse(t4[3], 3, jt), !a3) return null;
+            }
+            return new i3(s3, o3, a3);
+          }
+          evaluate(i4) {
+            const s3 = this.lhs.evaluate(i4), o3 = this.rhs.evaluate(i4);
+            if (r3 && this.hasUntypedArgument) {
+              const e4 = Ue2(s3), n4 = Ue2(o3);
+              if (e4.kind !== n4.kind || "string" !== e4.kind && "number" !== e4.kind) throw new Ce2(`Expected arguments for "${t3}" to be (string, string) or (number, number), but found (${e4.kind}, ${n4.kind}) instead.`);
+            }
+            if (this.collator && !r3 && this.hasUntypedArgument) {
+              const t4 = Ue2(s3), n4 = Ue2(o3);
+              if ("string" !== t4.kind || "string" !== n4.kind) return e3(i4, s3, o3);
+            }
+            return this.collator ? n3(i4, s3, o3, this.collator.evaluate(i4)) : e3(i4, s3, o3);
+          }
+          eachChild(t4) {
+            t4(this.lhs), t4(this.rhs), this.collator && t4(this.collator);
+          }
+          outputDefined() {
+            return true;
+          }
+        };
+      }
+      const wn = bn("==", function(t3, e3, n3) {
+        return e3 === n3;
+      }, vn), _n = bn("!=", function(t3, e3, n3) {
+        return e3 !== n3;
+      }, function(t3, e3, n3, r3) {
+        return !vn(0, e3, n3, r3);
+      }), Sn = bn("<", function(t3, e3, n3) {
+        return e3 < n3;
+      }, function(t3, e3, n3, r3) {
+        return r3.compare(e3, n3) < 0;
+      }), An = bn(">", function(t3, e3, n3) {
+        return e3 > n3;
+      }, function(t3, e3, n3, r3) {
+        return r3.compare(e3, n3) > 0;
+      }), Mn = bn("<=", function(t3, e3, n3) {
+        return e3 <= n3;
+      }, function(t3, e3, n3, r3) {
+        return r3.compare(e3, n3) <= 0;
+      }), kn = bn(">=", function(t3, e3, n3) {
+        return e3 >= n3;
+      }, function(t3, e3, n3, r3) {
+        return r3.compare(e3, n3) >= 0;
+      });
+      class In {
+        constructor(t3, e3, n3) {
+          this.type = jt, this.locale = n3, this.caseSensitive = t3, this.diacriticSensitive = e3;
+        }
+        static parse(t3, e3) {
+          if (2 !== t3.length) return e3.error("Expected one argument.");
+          const n3 = t3[1];
+          if ("object" != typeof n3 || Array.isArray(n3)) return e3.error("Collator options argument must be an object.");
+          const r3 = e3.parse(void 0 !== n3["case-sensitive"] && n3["case-sensitive"], 1, Ot);
+          if (!r3) return null;
+          const i3 = e3.parse(void 0 !== n3["diacritic-sensitive"] && n3["diacritic-sensitive"], 1, Ot);
+          if (!i3) return null;
+          let s3 = null;
+          return n3.locale && (s3 = e3.parse(n3.locale, 1, Lt), !s3) ? null : new In(r3, i3, s3);
+        }
+        evaluate(t3) {
+          return new Ee2(this.caseSensitive.evaluate(t3), this.diacriticSensitive.evaluate(t3), this.locale ? this.locale.evaluate(t3) : null);
+        }
+        eachChild(t3) {
+          t3(this.caseSensitive), t3(this.diacriticSensitive), this.locale && t3(this.locale);
+        }
+        outputDefined() {
+          return false;
+        }
+      }
+      class En {
+        constructor(t3, e3, n3, r3, i3, s3) {
+          this.type = Lt, this.number = t3, this.locale = e3, this.currency = n3, this.unit = r3, this.minFractionDigits = i3, this.maxFractionDigits = s3;
+        }
+        static parse(t3, e3) {
+          if (3 !== t3.length) return e3.error("Expected two arguments.");
+          const n3 = e3.parse(t3[1], 1, Vt);
+          if (!n3) return null;
+          const r3 = t3[2];
+          if ("object" != typeof r3 || Array.isArray(r3)) return e3.error("NumberFormat options argument must be an object.");
+          let i3 = null;
+          if (r3.locale && (i3 = e3.parse(r3.locale, 1, Lt), !i3)) return null;
+          let s3 = null;
+          if (r3.currency && (s3 = e3.parse(r3.currency, 1, Lt), !s3)) return null;
+          let o3 = null;
+          if (r3.unit && (o3 = e3.parse(r3.unit, 1, Lt), !o3)) return null;
+          if (s3 && o3) return e3.error("NumberFormat options `currency` and `unit` are mutually exclusive");
+          let a3 = null;
+          if (r3["min-fraction-digits"] && (a3 = e3.parse(r3["min-fraction-digits"], 1, Vt), !a3)) return null;
+          let l3 = null;
+          return r3["max-fraction-digits"] && (l3 = e3.parse(r3["max-fraction-digits"], 1, Vt), !l3) ? null : new En(n3, i3, s3, o3, a3, l3);
+        }
+        evaluate(t3) {
+          return new Intl.NumberFormat(this.locale ? this.locale.evaluate(t3) : [], { style: this.currency ? "currency" : this.unit ? "unit" : "decimal", currency: this.currency ? this.currency.evaluate(t3) : void 0, unit: this.unit ? this.unit.evaluate(t3) : void 0, minimumFractionDigits: this.minFractionDigits ? this.minFractionDigits.evaluate(t3) : void 0, maximumFractionDigits: this.maxFractionDigits ? this.maxFractionDigits.evaluate(t3) : void 0 }).format(this.number.evaluate(t3));
+        }
+        eachChild(t3) {
+          t3(this.number), this.locale && t3(this.locale), this.currency && t3(this.currency), this.unit && t3(this.unit), this.minFractionDigits && t3(this.minFractionDigits), this.maxFractionDigits && t3(this.maxFractionDigits);
+        }
+        outputDefined() {
+          return false;
+        }
+      }
+      class Tn {
+        constructor(t3) {
+          this.type = qt, this.sections = t3;
+        }
+        static parse(t3, e3) {
+          if (t3.length < 2) return e3.error("Expected at least one argument.");
+          const n3 = t3[1];
+          if (!Array.isArray(n3) && "object" == typeof n3) return e3.error("First argument must be an image or text section.");
+          const r3 = [];
+          let i3 = false;
+          for (let n4 = 1; n4 <= t3.length - 1; ++n4) {
+            const s3 = t3[n4];
+            if (i3 && "object" == typeof s3 && !Array.isArray(s3)) {
+              i3 = false;
+              let t4 = null;
+              if (s3["font-scale"] && (t4 = e3.parse(s3["font-scale"], 1, Vt), !t4)) return null;
+              let n5 = null;
+              if (s3["text-font"] && (n5 = e3.parse(s3["text-font"], 1, Wt(Lt)), !n5)) return null;
+              let o3 = null;
+              if (s3["text-color"] && (o3 = e3.parse(s3["text-color"], 1, $t), !o3)) return null;
+              let a3 = null;
+              if (s3["vertical-align"]) {
+                if ("string" == typeof s3["vertical-align"] && !Te2.includes(s3["vertical-align"])) return e3.error(`'vertical-align' must be one of: 'bottom', 'center', 'top' but found '${s3["vertical-align"]}' instead.`);
+                if (a3 = e3.parse(s3["vertical-align"], 1, Lt), !a3) return null;
+              }
+              const l3 = r3[r3.length - 1];
+              l3.scale = t4, l3.font = n5, l3.textColor = o3, l3.verticalAlign = a3;
+            } else {
+              const s4 = e3.parse(t3[n4], 1, Ut);
+              if (!s4) return null;
+              const o3 = s4.type.kind;
+              if ("string" !== o3 && "value" !== o3 && "null" !== o3 && "resolvedImage" !== o3) return e3.error("Formatted text type must be 'string', 'value', 'image' or 'null'.");
+              i3 = true, r3.push({ content: s4, scale: null, font: null, textColor: null, verticalAlign: null });
+            }
+          }
+          return new Tn(r3);
+        }
+        evaluate(t3) {
+          return new De2(this.sections.map((e3) => {
+            const n3 = e3.content.evaluate(t3);
+            return Ue2(n3) === Zt ? new Fe2("", n3, null, null, null, e3.verticalAlign ? e3.verticalAlign.evaluate(t3) : null) : new Fe2(je2(n3), null, e3.scale ? e3.scale.evaluate(t3) : null, e3.font ? e3.font.evaluate(t3).join(",") : null, e3.textColor ? e3.textColor.evaluate(t3) : null, e3.verticalAlign ? e3.verticalAlign.evaluate(t3) : null);
+          }));
+        }
+        eachChild(t3) {
+          for (const e3 of this.sections) t3(e3.content), e3.scale && t3(e3.scale), e3.font && t3(e3.font), e3.textColor && t3(e3.textColor), e3.verticalAlign && t3(e3.verticalAlign);
+        }
+        outputDefined() {
+          return false;
+        }
+      }
+      class Fn {
+        constructor(t3) {
+          this.type = Zt, this.input = t3;
+        }
+        static parse(t3, e3) {
+          if (2 !== t3.length) return e3.error("Expected two arguments.");
+          const n3 = e3.parse(t3[1], 1, Lt);
+          return n3 ? new Fn(n3) : e3.error("No image name provided.");
+        }
+        evaluate(t3) {
+          const e3 = this.input.evaluate(t3), n3 = Oe2.fromString(e3);
+          return n3 && t3.availableImages && (n3.available = t3.availableImages.indexOf(e3) > -1), n3;
+        }
+        eachChild(t3) {
+          t3(this.input);
+        }
+        outputDefined() {
+          return false;
+        }
+      }
+      class Dn {
+        constructor(t3) {
+          this.type = Vt, this.input = t3;
+        }
+        static parse(t3, e3) {
+          if (2 !== t3.length) return e3.error(`Expected 1 argument, but found ${t3.length - 1} instead.`);
+          const n3 = e3.parse(t3[1], 1);
+          return n3 ? "array" !== n3.type.kind && "string" !== n3.type.kind && "value" !== n3.type.kind ? e3.error(`Expected argument of type string or array, but found ${Kt(n3.type)} instead.`) : new Dn(n3) : null;
+        }
+        evaluate(t3) {
+          const e3 = this.input.evaluate(t3);
+          if ("string" == typeof e3) return [...e3].length;
+          if (Array.isArray(e3)) return e3.length;
+          throw new Ce2(`Expected value to be of type string or array, but found ${Kt(Ue2(e3))} instead.`);
+        }
+        eachChild(t3) {
+          t3(this.input);
+        }
+        outputDefined() {
+          return false;
+        }
+      }
+      const Pn = 8192;
+      function zn(t3, e3) {
+        const n3 = (180 + t3[0]) / 360, r3 = (180 - 180 / Math.PI * Math.log(Math.tan(Math.PI / 4 + t3[1] * Math.PI / 360))) / 360, i3 = Math.pow(2, e3.z);
+        return [Math.round(n3 * i3 * Pn), Math.round(r3 * i3 * Pn)];
+      }
+      function Bn(t3, e3) {
+        const n3 = Math.pow(2, e3.z);
+        return [(i3 = (t3[0] / Pn + e3.x) / n3, 360 * i3 - 180), (r3 = (t3[1] / Pn + e3.y) / n3, 360 / Math.PI * Math.atan(Math.exp((180 - 360 * r3) * Math.PI / 180)) - 90)];
+        var r3, i3;
+      }
+      function Cn(t3, e3) {
+        t3[0] = Math.min(t3[0], e3[0]), t3[1] = Math.min(t3[1], e3[1]), t3[2] = Math.max(t3[2], e3[0]), t3[3] = Math.max(t3[3], e3[1]);
+      }
+      function Vn(t3, e3) {
+        return !(t3[0] <= e3[0] || t3[2] >= e3[2] || t3[1] <= e3[1] || t3[3] >= e3[3]);
+      }
+      function Ln(t3, e3, n3) {
+        const r3 = t3[0] - e3[0], i3 = t3[1] - e3[1], s3 = t3[0] - n3[0], o3 = t3[1] - n3[1];
+        return r3 * o3 - s3 * i3 == 0 && r3 * s3 <= 0 && i3 * o3 <= 0;
+      }
+      function On(t3, e3, n3, r3) {
+        return 0 != (i3 = [r3[0] - n3[0], r3[1] - n3[1]])[0] * (s3 = [e3[0] - t3[0], e3[1] - t3[1]])[1] - i3[1] * s3[0] && !(!qn(t3, e3, n3, r3) || !qn(n3, r3, t3, e3));
+        var i3, s3;
+      }
+      function $n(t3, e3, n3) {
+        for (const r3 of n3) for (let n4 = 0; n4 < r3.length - 1; ++n4) if (On(t3, e3, r3[n4], r3[n4 + 1])) return true;
+        return false;
+      }
+      function Rn(t3, e3, n3 = false) {
+        let r3 = false;
+        for (const a3 of e3) for (let e4 = 0; e4 < a3.length - 1; e4++) {
+          if (Ln(t3, a3[e4], a3[e4 + 1])) return n3;
+          (s3 = a3[e4])[1] > (i3 = t3)[1] != (o3 = a3[e4 + 1])[1] > i3[1] && i3[0] < (o3[0] - s3[0]) * (i3[1] - s3[1]) / (o3[1] - s3[1]) + s3[0] && (r3 = !r3);
+        }
+        var i3, s3, o3;
+        return r3;
+      }
+      function Nn(t3, e3) {
+        for (const n3 of e3) if (Rn(t3, n3)) return true;
+        return false;
+      }
+      function Un(t3, e3) {
+        for (const n3 of t3) if (!Rn(n3, e3)) return false;
+        for (let n3 = 0; n3 < t3.length - 1; ++n3) if ($n(t3[n3], t3[n3 + 1], e3)) return false;
+        return true;
+      }
+      function jn(t3, e3) {
+        for (const n3 of e3) if (Un(t3, n3)) return true;
+        return false;
+      }
+      function qn(t3, e3, n3, r3) {
+        const i3 = r3[0] - n3[0], s3 = r3[1] - n3[1], o3 = (t3[0] - n3[0]) * s3 - i3 * (t3[1] - n3[1]), a3 = (e3[0] - n3[0]) * s3 - i3 * (e3[1] - n3[1]);
+        return o3 > 0 && a3 < 0 || o3 < 0 && a3 > 0;
+      }
+      function Gn(t3, e3, n3) {
+        const r3 = [];
+        for (let i3 = 0; i3 < t3.length; i3++) {
+          const s3 = [];
+          for (let r4 = 0; r4 < t3[i3].length; r4++) {
+            const o3 = zn(t3[i3][r4], n3);
+            Cn(e3, o3), s3.push(o3);
+          }
+          r3.push(s3);
+        }
+        return r3;
+      }
+      function Xn(t3, e3, n3) {
+        const r3 = [];
+        for (let i3 = 0; i3 < t3.length; i3++) {
+          const s3 = Gn(t3[i3], e3, n3);
+          r3.push(s3);
+        }
+        return r3;
+      }
+      function Yn(t3, e3, n3, r3) {
+        if (t3[0] < n3[0] || t3[0] > n3[2]) {
+          const e4 = 0.5 * r3;
+          let i3 = t3[0] - n3[0] > e4 ? -r3 : n3[0] - t3[0] > e4 ? r3 : 0;
+          0 === i3 && (i3 = t3[0] - n3[2] > e4 ? -r3 : n3[2] - t3[0] > e4 ? r3 : 0), t3[0] += i3;
+        }
+        Cn(e3, t3);
+      }
+      function Zn(t3, e3, n3, r3) {
+        const i3 = Math.pow(2, r3.z) * Pn, s3 = [r3.x * Pn, r3.y * Pn], o3 = [];
+        for (const r4 of t3) for (const t4 of r4) {
+          const r5 = [t4.x + s3[0], t4.y + s3[1]];
+          Yn(r5, e3, n3, i3), o3.push(r5);
+        }
+        return o3;
+      }
+      function Hn(t3, e3, n3, r3) {
+        const i3 = Math.pow(2, r3.z) * Pn, s3 = [r3.x * Pn, r3.y * Pn], o3 = [];
+        for (const n4 of t3) {
+          const t4 = [];
+          for (const r4 of n4) {
+            const n5 = [r4.x + s3[0], r4.y + s3[1]];
+            Cn(e3, n5), t4.push(n5);
+          }
+          o3.push(t4);
+        }
+        if (e3[2] - e3[0] <= i3 / 2) {
+          (a3 = e3)[0] = a3[1] = 1 / 0, a3[2] = a3[3] = -1 / 0;
+          for (const t4 of o3) for (const r4 of t4) Yn(r4, e3, n3, i3);
+        }
+        var a3;
+        return o3;
+      }
+      class Wn {
+        constructor(t3, e3) {
+          this.type = Ot, this.geojson = t3, this.geometries = e3;
+        }
+        static parse(t3, e3) {
+          if (2 !== t3.length) return e3.error(`'within' expression requires exactly one argument, but found ${t3.length - 1} instead.`);
+          if (Ne2(t3[1])) {
+            const e4 = t3[1];
+            if ("FeatureCollection" === e4.type) {
+              const t4 = [];
+              for (const n3 of e4.features) {
+                const { type: e5, coordinates: r3 } = n3.geometry;
+                "Polygon" === e5 && t4.push(r3), "MultiPolygon" === e5 && t4.push(...r3);
+              }
+              if (t4.length) return new Wn(e4, { type: "MultiPolygon", coordinates: t4 });
+            } else if ("Feature" === e4.type) {
+              const t4 = e4.geometry.type;
+              if ("Polygon" === t4 || "MultiPolygon" === t4) return new Wn(e4, e4.geometry);
+            } else if ("Polygon" === e4.type || "MultiPolygon" === e4.type) return new Wn(e4, e4);
+          }
+          return e3.error("'within' expression requires valid geojson object that contains polygon geometry type.");
+        }
+        evaluate(t3) {
+          if (null != t3.geometry() && null != t3.canonicalID()) {
+            if ("Point" === t3.geometryType()) return function(t4, e3) {
+              const n3 = [1 / 0, 1 / 0, -1 / 0, -1 / 0], r3 = [1 / 0, 1 / 0, -1 / 0, -1 / 0], i3 = t4.canonicalID();
+              if ("Polygon" === e3.type) {
+                const s3 = Gn(e3.coordinates, r3, i3), o3 = Zn(t4.geometry(), n3, r3, i3);
+                if (!Vn(n3, r3)) return false;
+                for (const t5 of o3) if (!Rn(t5, s3)) return false;
+              }
+              if ("MultiPolygon" === e3.type) {
+                const s3 = Xn(e3.coordinates, r3, i3), o3 = Zn(t4.geometry(), n3, r3, i3);
+                if (!Vn(n3, r3)) return false;
+                for (const t5 of o3) if (!Nn(t5, s3)) return false;
+              }
+              return true;
+            }(t3, this.geometries);
+            if ("LineString" === t3.geometryType()) return function(t4, e3) {
+              const n3 = [1 / 0, 1 / 0, -1 / 0, -1 / 0], r3 = [1 / 0, 1 / 0, -1 / 0, -1 / 0], i3 = t4.canonicalID();
+              if ("Polygon" === e3.type) {
+                const s3 = Gn(e3.coordinates, r3, i3), o3 = Hn(t4.geometry(), n3, r3, i3);
+                if (!Vn(n3, r3)) return false;
+                for (const t5 of o3) if (!Un(t5, s3)) return false;
+              }
+              if ("MultiPolygon" === e3.type) {
+                const s3 = Xn(e3.coordinates, r3, i3), o3 = Hn(t4.geometry(), n3, r3, i3);
+                if (!Vn(n3, r3)) return false;
+                for (const t5 of o3) if (!jn(t5, s3)) return false;
+              }
+              return true;
+            }(t3, this.geometries);
+          }
+          return false;
+        }
+        eachChild() {
+        }
+        outputDefined() {
+          return true;
+        }
+      }
+      let Kn = class {
+        constructor(t3 = [], e3 = (t4, e4) => t4 < e4 ? -1 : t4 > e4 ? 1 : 0) {
+          if (this.data = t3, this.length = this.data.length, this.compare = e3, this.length > 0) for (let t4 = (this.length >> 1) - 1; t4 >= 0; t4--) this._down(t4);
+        }
+        push(t3) {
+          this.data.push(t3), this._up(this.length++);
+        }
+        pop() {
+          if (0 === this.length) return;
+          const t3 = this.data[0], e3 = this.data.pop();
+          return --this.length > 0 && (this.data[0] = e3, this._down(0)), t3;
+        }
+        peek() {
+          return this.data[0];
+        }
+        _up(t3) {
+          const { data: e3, compare: n3 } = this, r3 = e3[t3];
+          for (; t3 > 0; ) {
+            const i3 = t3 - 1 >> 1, s3 = e3[i3];
+            if (n3(r3, s3) >= 0) break;
+            e3[t3] = s3, t3 = i3;
+          }
+          e3[t3] = r3;
+        }
+        _down(t3) {
+          const { data: e3, compare: n3 } = this, r3 = this.length >> 1, i3 = e3[t3];
+          for (; t3 < r3; ) {
+            let r4 = 1 + (t3 << 1);
+            const s3 = r4 + 1;
+            if (s3 < this.length && n3(e3[s3], e3[r4]) < 0 && (r4 = s3), n3(e3[r4], i3) >= 0) break;
+            e3[t3] = e3[r4], t3 = r4;
+          }
+          e3[t3] = i3;
+        }
+      };
+      function Jn(t3, e3, n3 = 0, r3 = t3.length - 1, i3 = tr) {
+        for (; r3 > n3; ) {
+          if (r3 - n3 > 600) {
+            const s4 = r3 - n3 + 1, o4 = e3 - n3 + 1, a4 = Math.log(s4), l3 = 0.5 * Math.exp(2 * a4 / 3), u3 = 0.5 * Math.sqrt(a4 * l3 * (s4 - l3) / s4) * (o4 - s4 / 2 < 0 ? -1 : 1);
+            Jn(t3, e3, Math.max(n3, Math.floor(e3 - o4 * l3 / s4 + u3)), Math.min(r3, Math.floor(e3 + (s4 - o4) * l3 / s4 + u3)), i3);
+          }
+          const s3 = t3[e3];
+          let o3 = n3, a3 = r3;
+          for (Qn(t3, n3, e3), i3(t3[r3], s3) > 0 && Qn(t3, n3, r3); o3 < a3; ) {
+            for (Qn(t3, o3, a3), o3++, a3--; i3(t3[o3], s3) < 0; ) o3++;
+            for (; i3(t3[a3], s3) > 0; ) a3--;
+          }
+          0 === i3(t3[n3], s3) ? Qn(t3, n3, a3) : (a3++, Qn(t3, a3, r3)), a3 <= e3 && (n3 = a3 + 1), e3 <= a3 && (r3 = a3 - 1);
+        }
+      }
+      function Qn(t3, e3, n3) {
+        const r3 = t3[e3];
+        t3[e3] = t3[n3], t3[n3] = r3;
+      }
+      function tr(t3, e3) {
+        return t3 < e3 ? -1 : t3 > e3 ? 1 : 0;
+      }
+      function er(t3, e3) {
+        if (t3.length <= 1) return [t3];
+        const n3 = [];
+        let r3, i3;
+        for (const e4 of t3) {
+          const t4 = rr(e4);
+          0 !== t4 && (e4.area = Math.abs(t4), void 0 === i3 && (i3 = t4 < 0), i3 === t4 < 0 ? (r3 && n3.push(r3), r3 = [e4]) : r3.push(e4));
+        }
+        if (r3 && n3.push(r3), e3 > 1) for (let t4 = 0; t4 < n3.length; t4++) n3[t4].length <= e3 || (Jn(n3[t4], e3, 1, n3[t4].length - 1, nr), n3[t4] = n3[t4].slice(0, e3));
+        return n3;
+      }
+      function nr(t3, e3) {
+        return e3.area - t3.area;
+      }
+      function rr(t3) {
+        let e3 = 0;
+        for (let n3, r3, i3 = 0, s3 = t3.length, o3 = s3 - 1; i3 < s3; o3 = i3++) n3 = t3[i3], r3 = t3[o3], e3 += (r3.x - n3.x) * (n3.y + r3.y);
+        return e3;
+      }
+      const ir = 1 / 298.257223563, sr = ir * (2 - ir), or = Math.PI / 180;
+      class ar {
+        constructor(t3) {
+          const e3 = 6378.137 * or * 1e3, n3 = Math.cos(t3 * or), r3 = 1 / (1 - sr * (1 - n3 * n3)), i3 = Math.sqrt(r3);
+          this.kx = e3 * i3 * n3, this.ky = e3 * i3 * r3 * (1 - sr);
+        }
+        distance(t3, e3) {
+          const n3 = this.wrap(t3[0] - e3[0]) * this.kx, r3 = (t3[1] - e3[1]) * this.ky;
+          return Math.sqrt(n3 * n3 + r3 * r3);
+        }
+        pointOnLine(t3, e3) {
+          let n3, r3, i3, s3, o3 = 1 / 0;
+          for (let a3 = 0; a3 < t3.length - 1; a3++) {
+            let l3 = t3[a3][0], u3 = t3[a3][1], c3 = this.wrap(t3[a3 + 1][0] - l3) * this.kx, h3 = (t3[a3 + 1][1] - u3) * this.ky, p3 = 0;
+            0 === c3 && 0 === h3 || (p3 = (this.wrap(e3[0] - l3) * this.kx * c3 + (e3[1] - u3) * this.ky * h3) / (c3 * c3 + h3 * h3), p3 > 1 ? (l3 = t3[a3 + 1][0], u3 = t3[a3 + 1][1]) : p3 > 0 && (l3 += c3 / this.kx * p3, u3 += h3 / this.ky * p3)), c3 = this.wrap(e3[0] - l3) * this.kx, h3 = (e3[1] - u3) * this.ky;
+            const f3 = c3 * c3 + h3 * h3;
+            f3 < o3 && (o3 = f3, n3 = l3, r3 = u3, i3 = a3, s3 = p3);
+          }
+          return { point: [n3, r3], index: i3, t: Math.max(0, Math.min(1, s3)) };
+        }
+        wrap(t3) {
+          for (; t3 < -180; ) t3 += 360;
+          for (; t3 > 180; ) t3 -= 360;
+          return t3;
+        }
+      }
+      function lr(t3, e3) {
+        return e3[0] - t3[0];
+      }
+      function ur(t3) {
+        return t3[1] - t3[0] + 1;
+      }
+      function cr(t3, e3) {
+        return t3[1] >= t3[0] && t3[1] < e3;
+      }
+      function hr(t3, e3) {
+        if (t3[0] > t3[1]) return [null, null];
+        const n3 = ur(t3);
+        if (e3) {
+          if (2 === n3) return [t3, null];
+          const e4 = Math.floor(n3 / 2);
+          return [[t3[0], t3[0] + e4], [t3[0] + e4, t3[1]]];
+        }
+        if (1 === n3) return [t3, null];
+        const r3 = Math.floor(n3 / 2) - 1;
+        return [[t3[0], t3[0] + r3], [t3[0] + r3 + 1, t3[1]]];
+      }
+      function pr(t3, e3) {
+        if (!cr(e3, t3.length)) return [1 / 0, 1 / 0, -1 / 0, -1 / 0];
+        const n3 = [1 / 0, 1 / 0, -1 / 0, -1 / 0];
+        for (let r3 = e3[0]; r3 <= e3[1]; ++r3) Cn(n3, t3[r3]);
+        return n3;
+      }
+      function fr(t3) {
+        const e3 = [1 / 0, 1 / 0, -1 / 0, -1 / 0];
+        for (const n3 of t3) for (const t4 of n3) Cn(e3, t4);
+        return e3;
+      }
+      function dr(t3) {
+        return t3[0] !== -1 / 0 && t3[1] !== -1 / 0 && t3[2] !== 1 / 0 && t3[3] !== 1 / 0;
+      }
+      function yr(t3, e3, n3) {
+        if (!dr(t3) || !dr(e3)) return NaN;
+        let r3 = 0, i3 = 0;
+        return t3[2] < e3[0] && (r3 = e3[0] - t3[2]), t3[0] > e3[2] && (r3 = t3[0] - e3[2]), t3[1] > e3[3] && (i3 = t3[1] - e3[3]), t3[3] < e3[1] && (i3 = e3[1] - t3[3]), n3.distance([0, 0], [r3, i3]);
+      }
+      function mr(t3, e3, n3) {
+        const r3 = n3.pointOnLine(e3, t3);
+        return n3.distance(t3, r3.point);
+      }
+      function gr(t3, e3, n3, r3, i3) {
+        const s3 = Math.min(mr(t3, [n3, r3], i3), mr(e3, [n3, r3], i3)), o3 = Math.min(mr(n3, [t3, e3], i3), mr(r3, [t3, e3], i3));
+        return Math.min(s3, o3);
+      }
+      function xr(t3, e3, n3, r3, i3) {
+        if (!cr(e3, t3.length) || !cr(r3, n3.length)) return 1 / 0;
+        let s3 = 1 / 0;
+        for (let o3 = e3[0]; o3 < e3[1]; ++o3) {
+          const e4 = t3[o3], a3 = t3[o3 + 1];
+          for (let t4 = r3[0]; t4 < r3[1]; ++t4) {
+            const r4 = n3[t4], o4 = n3[t4 + 1];
+            if (On(e4, a3, r4, o4)) return 0;
+            s3 = Math.min(s3, gr(e4, a3, r4, o4, i3));
+          }
+        }
+        return s3;
+      }
+      function vr(t3, e3, n3, r3, i3) {
+        if (!cr(e3, t3.length) || !cr(r3, n3.length)) return NaN;
+        let s3 = 1 / 0;
+        for (let o3 = e3[0]; o3 <= e3[1]; ++o3) for (let e4 = r3[0]; e4 <= r3[1]; ++e4) if (s3 = Math.min(s3, i3.distance(t3[o3], n3[e4])), 0 === s3) return s3;
+        return s3;
+      }
+      function br(t3, e3, n3) {
+        if (Rn(t3, e3, true)) return 0;
+        let r3 = 1 / 0;
+        for (const i3 of e3) {
+          const e4 = i3[0], s3 = i3[i3.length - 1];
+          if (e4 !== s3 && (r3 = Math.min(r3, mr(t3, [s3, e4], n3)), 0 === r3)) return r3;
+          const o3 = n3.pointOnLine(i3, t3);
+          if (r3 = Math.min(r3, n3.distance(t3, o3.point)), 0 === r3) return r3;
+        }
+        return r3;
+      }
+      function wr(t3, e3, n3, r3) {
+        if (!cr(e3, t3.length)) return NaN;
+        for (let r4 = e3[0]; r4 <= e3[1]; ++r4) if (Rn(t3[r4], n3, true)) return 0;
+        let i3 = 1 / 0;
+        for (let s3 = e3[0]; s3 < e3[1]; ++s3) {
+          const e4 = t3[s3], o3 = t3[s3 + 1];
+          for (const t4 of n3) for (let n4 = 0, s4 = t4.length, a3 = s4 - 1; n4 < s4; a3 = n4++) {
+            const s5 = t4[a3], l3 = t4[n4];
+            if (On(e4, o3, s5, l3)) return 0;
+            i3 = Math.min(i3, gr(e4, o3, s5, l3, r3));
+          }
+        }
+        return i3;
+      }
+      function _r2(t3, e3) {
+        for (const n3 of t3) for (const t4 of n3) if (Rn(t4, e3, true)) return true;
+        return false;
+      }
+      function Sr(t3, e3, n3, r3 = 1 / 0) {
+        const i3 = fr(t3), s3 = fr(e3);
+        if (r3 !== 1 / 0 && yr(i3, s3, n3) >= r3) return r3;
+        if (Vn(i3, s3)) {
+          if (_r2(t3, e3)) return 0;
+        } else if (_r2(e3, t3)) return 0;
+        let o3 = 1 / 0;
+        for (const r4 of t3) for (let t4 = 0, i4 = r4.length, s4 = i4 - 1; t4 < i4; s4 = t4++) {
+          const i5 = r4[s4], a3 = r4[t4];
+          for (const t5 of e3) for (let e4 = 0, r5 = t5.length, s5 = r5 - 1; e4 < r5; s5 = e4++) {
+            const r6 = t5[s5], l3 = t5[e4];
+            if (On(i5, a3, r6, l3)) return 0;
+            o3 = Math.min(o3, gr(i5, a3, r6, l3, n3));
+          }
+        }
+        return o3;
+      }
+      function Ar(t3, e3, n3, r3, i3, s3) {
+        if (!s3) return;
+        const o3 = yr(pr(r3, s3), i3, n3);
+        o3 < e3 && t3.push([o3, s3, [0, 0]]);
+      }
+      function Mr(t3, e3, n3, r3, i3, s3, o3) {
+        if (!s3 || !o3) return;
+        const a3 = yr(pr(r3, s3), pr(i3, o3), n3);
+        a3 < e3 && t3.push([a3, s3, o3]);
+      }
+      function kr(t3, e3, n3, r3, i3 = 1 / 0) {
+        let s3 = Math.min(r3.distance(t3[0], n3[0][0]), i3);
+        if (0 === s3) return s3;
+        const o3 = new Kn([[0, [0, t3.length - 1], [0, 0]]], lr), a3 = fr(n3);
+        for (; o3.length > 0; ) {
+          const i4 = o3.pop();
+          if (i4[0] >= s3) continue;
+          const l3 = i4[1], u3 = e3 ? 50 : 100;
+          if (ur(l3) <= u3) {
+            if (!cr(l3, t3.length)) return NaN;
+            if (e3) {
+              const e4 = wr(t3, l3, n3, r3);
+              if (isNaN(e4) || 0 === e4) return e4;
+              s3 = Math.min(s3, e4);
+            } else for (let e4 = l3[0]; e4 <= l3[1]; ++e4) {
+              const i5 = br(t3[e4], n3, r3);
+              if (s3 = Math.min(s3, i5), 0 === s3) return 0;
+            }
+          } else {
+            const n4 = hr(l3, e3);
+            Ar(o3, s3, r3, t3, a3, n4[0]), Ar(o3, s3, r3, t3, a3, n4[1]);
+          }
+        }
+        return s3;
+      }
+      function Ir(t3, e3, n3, r3, i3, s3 = 1 / 0) {
+        let o3 = Math.min(s3, i3.distance(t3[0], n3[0]));
+        if (0 === o3) return o3;
+        const a3 = new Kn([[0, [0, t3.length - 1], [0, n3.length - 1]]], lr);
+        for (; a3.length > 0; ) {
+          const s4 = a3.pop();
+          if (s4[0] >= o3) continue;
+          const l3 = s4[1], u3 = s4[2], c3 = e3 ? 50 : 100, h3 = r3 ? 50 : 100;
+          if (ur(l3) <= c3 && ur(u3) <= h3) {
+            if (!cr(l3, t3.length) && cr(u3, n3.length)) return NaN;
+            let s5;
+            if (e3 && r3) s5 = xr(t3, l3, n3, u3, i3), o3 = Math.min(o3, s5);
+            else if (e3 && !r3) {
+              const e4 = t3.slice(l3[0], l3[1] + 1);
+              for (let t4 = u3[0]; t4 <= u3[1]; ++t4) if (s5 = mr(n3[t4], e4, i3), o3 = Math.min(o3, s5), 0 === o3) return o3;
+            } else if (!e3 && r3) {
+              const e4 = n3.slice(u3[0], u3[1] + 1);
+              for (let n4 = l3[0]; n4 <= l3[1]; ++n4) if (s5 = mr(t3[n4], e4, i3), o3 = Math.min(o3, s5), 0 === o3) return o3;
+            } else s5 = vr(t3, l3, n3, u3, i3), o3 = Math.min(o3, s5);
+          } else {
+            const s5 = hr(l3, e3), c4 = hr(u3, r3);
+            Mr(a3, o3, i3, t3, n3, s5[0], c4[0]), Mr(a3, o3, i3, t3, n3, s5[0], c4[1]), Mr(a3, o3, i3, t3, n3, s5[1], c4[0]), Mr(a3, o3, i3, t3, n3, s5[1], c4[1]);
+          }
+        }
+        return o3;
+      }
+      function Er(t3) {
+        return "MultiPolygon" === t3.type ? t3.coordinates.map((t4) => ({ type: "Polygon", coordinates: t4 })) : "MultiLineString" === t3.type ? t3.coordinates.map((t4) => ({ type: "LineString", coordinates: t4 })) : "MultiPoint" === t3.type ? t3.coordinates.map((t4) => ({ type: "Point", coordinates: t4 })) : [t3];
+      }
+      class Tr {
+        constructor(t3, e3) {
+          this.type = Vt, this.geojson = t3, this.geometries = e3;
+        }
+        static parse(t3, e3) {
+          if (2 !== t3.length) return e3.error(`'distance' expression requires exactly one argument, but found ${t3.length - 1} instead.`);
+          if (Ne2(t3[1])) {
+            const e4 = t3[1];
+            if ("FeatureCollection" === e4.type) return new Tr(e4, e4.features.map((t4) => Er(t4.geometry)).flat());
+            if ("Feature" === e4.type) return new Tr(e4, Er(e4.geometry));
+            if ("type" in e4 && "coordinates" in e4) return new Tr(e4, Er(e4));
+          }
+          return e3.error("'distance' expression requires valid geojson object that contains polygon geometry type.");
+        }
+        evaluate(t3) {
+          if (null != t3.geometry() && null != t3.canonicalID()) {
+            if ("Point" === t3.geometryType()) return function(t4, e3) {
+              const n3 = t4.geometry(), r3 = n3.flat().map((e4) => Bn([e4.x, e4.y], t4.canonical));
+              if (0 === n3.length) return NaN;
+              const i3 = new ar(r3[0][1]);
+              let s3 = 1 / 0;
+              for (const t5 of e3) {
+                switch (t5.type) {
+                  case "Point":
+                    s3 = Math.min(s3, Ir(r3, false, [t5.coordinates], false, i3, s3));
+                    break;
+                  case "LineString":
+                    s3 = Math.min(s3, Ir(r3, false, t5.coordinates, true, i3, s3));
+                    break;
+                  case "Polygon":
+                    s3 = Math.min(s3, kr(r3, false, t5.coordinates, i3, s3));
+                }
+                if (0 === s3) return s3;
+              }
+              return s3;
+            }(t3, this.geometries);
+            if ("LineString" === t3.geometryType()) return function(t4, e3) {
+              const n3 = t4.geometry(), r3 = n3.flat().map((e4) => Bn([e4.x, e4.y], t4.canonical));
+              if (0 === n3.length) return NaN;
+              const i3 = new ar(r3[0][1]);
+              let s3 = 1 / 0;
+              for (const t5 of e3) {
+                switch (t5.type) {
+                  case "Point":
+                    s3 = Math.min(s3, Ir(r3, true, [t5.coordinates], false, i3, s3));
+                    break;
+                  case "LineString":
+                    s3 = Math.min(s3, Ir(r3, true, t5.coordinates, true, i3, s3));
+                    break;
+                  case "Polygon":
+                    s3 = Math.min(s3, kr(r3, true, t5.coordinates, i3, s3));
+                }
+                if (0 === s3) return s3;
+              }
+              return s3;
+            }(t3, this.geometries);
+            if ("Polygon" === t3.geometryType()) return function(t4, e3) {
+              const n3 = t4.geometry();
+              if (0 === n3.length || 0 === n3[0].length) return NaN;
+              const r3 = er(n3, 0).map((e4) => e4.map((e5) => e5.map((e6) => Bn([e6.x, e6.y], t4.canonical)))), i3 = new ar(r3[0][0][0][1]);
+              let s3 = 1 / 0;
+              for (const t5 of e3) for (const e4 of r3) {
+                switch (t5.type) {
+                  case "Point":
+                    s3 = Math.min(s3, kr([t5.coordinates], false, e4, i3, s3));
+                    break;
+                  case "LineString":
+                    s3 = Math.min(s3, kr(t5.coordinates, true, e4, i3, s3));
+                    break;
+                  case "Polygon":
+                    s3 = Math.min(s3, Sr(e4, t5.coordinates, i3, s3));
+                }
+                if (0 === s3) return s3;
+              }
+              return s3;
+            }(t3, this.geometries);
+          }
+          return NaN;
+        }
+        eachChild() {
+        }
+        outputDefined() {
+          return true;
+        }
+      }
+      class Fr {
+        constructor(t3) {
+          this.type = Ut, this.key = t3;
+        }
+        static parse(t3, e3) {
+          if (2 !== t3.length) return e3.error(`Expected 1 argument, but found ${t3.length - 1} instead.`);
+          const n3 = t3[1];
+          return null == n3 ? e3.error("Global state property must be defined.") : "string" != typeof n3 ? e3.error(`Global state property must be string, but found ${typeof t3[1]} instead.`) : new Fr(n3);
+        }
+        evaluate(t3) {
+          var e3;
+          const n3 = null === (e3 = t3.globals) || void 0 === e3 ? void 0 : e3.globalState;
+          return n3 && 0 !== Object.keys(n3).length ? ve2(n3, this.key) : null;
+        }
+        eachChild() {
+        }
+        outputDefined() {
+          return false;
+        }
+      }
+      const Dr = { "==": wn, "!=": _n, ">": An, "<": Sn, ">=": kn, "<=": Mn, array: Xe2, at: tn, boolean: Xe2, case: sn, coalesce: gn, collator: In, format: Tn, image: Fn, in: en, "index-of": nn, interpolate: dn, "interpolate-hcl": dn, "interpolate-lab": dn, length: Dn, let: Je2, literal: qe2, match: rn, number: Xe2, "number-format": En, object: Xe2, slice: on, step: ln, string: Xe2, "to-boolean": Ze2, "to-color": Ze2, "to-number": Ze2, "to-string": Ze2, var: Qe2, within: Wn, distance: Tr, "global-state": Fr };
+      class Pr {
+        constructor(t3, e3, n3, r3) {
+          this.name = t3, this.type = e3, this._evaluate = n3, this.args = r3;
+        }
+        evaluate(t3) {
+          return this._evaluate(t3, this.args);
+        }
+        eachChild(t3) {
+          this.args.forEach(t3);
+        }
+        outputDefined() {
+          return false;
+        }
+        static parse(t3, e3) {
+          const n3 = t3[0], r3 = Pr.definitions[n3];
+          if (!r3) return e3.error(`Unknown expression "${n3}". If you wanted a literal array, use ["literal", [...]].`, 0);
+          const i3 = Array.isArray(r3) ? r3[0] : r3.type, s3 = Array.isArray(r3) ? [[r3[1], r3[2]]] : r3.overloads, o3 = s3.filter(([e4]) => !Array.isArray(e4) || e4.length === t3.length - 1);
+          let a3 = null;
+          for (const [r4, s4] of o3) {
+            a3 = new Ke2(e3.registry, Lr, e3.path, null, e3.scope);
+            const o4 = [];
+            let l3 = false;
+            for (let e4 = 1; e4 < t3.length; e4++) {
+              const n4 = t3[e4], i4 = Array.isArray(r4) ? r4[e4 - 1] : r4.type, s5 = a3.parse(n4, 1 + o4.length, i4);
+              if (!s5) {
+                l3 = true;
+                break;
+              }
+              o4.push(s5);
+            }
+            if (!l3) if (Array.isArray(r4) && r4.length !== o4.length) a3.error(`Expected ${r4.length} arguments, but found ${o4.length} instead.`);
+            else {
+              for (let t4 = 0; t4 < o4.length; t4++) {
+                const e4 = Array.isArray(r4) ? r4[t4] : r4.type, n4 = o4[t4];
+                a3.concat(t4 + 1).checkSubtype(e4, n4.type);
+              }
+              if (0 === a3.errors.length) return new Pr(n3, i3, s4, o4);
+            }
+          }
+          if (1 === o3.length) e3.errors.push(...a3.errors);
+          else {
+            const n4 = (o3.length ? o3 : s3).map(([t4]) => {
+              return e4 = t4, Array.isArray(e4) ? `(${e4.map(Kt).join(", ")})` : `(${Kt(e4.type)}...)`;
+              var e4;
+            }).join(" | "), r4 = [];
+            for (let n5 = 1; n5 < t3.length; n5++) {
+              const i4 = e3.parse(t3[n5], 1 + r4.length);
+              if (!i4) return null;
+              r4.push(Kt(i4.type));
+            }
+            e3.error(`Expected arguments of type ${n4}, but found (${r4.join(", ")}) instead.`);
+          }
+          return null;
+        }
+        static register(t3, e3) {
+          Pr.definitions = e3;
+          for (const n3 in e3) t3[n3] = Pr;
+        }
+      }
+      function zr(t3, [e3, n3, r3, i3]) {
+        e3 = e3.evaluate(t3), n3 = n3.evaluate(t3), r3 = r3.evaluate(t3);
+        const s3 = i3 ? i3.evaluate(t3) : 1, o3 = Re2(e3, n3, r3, s3);
+        if (o3) throw new Ce2(o3);
+        return new Ie2(e3 / 255, n3 / 255, r3 / 255, s3, false);
+      }
+      function Br(t3, e3) {
+        return t3 in e3;
+      }
+      function Cr(t3, e3) {
+        const n3 = e3[t3];
+        return void 0 === n3 ? null : n3;
+      }
+      function Vr(t3) {
+        return { type: t3 };
+      }
+      function Lr(t3) {
+        if (t3 instanceof Qe2) return Lr(t3.boundExpression);
+        if (t3 instanceof Pr && "error" === t3.name) return false;
+        if (t3 instanceof In) return false;
+        if (t3 instanceof Wn) return false;
+        if (t3 instanceof Tr) return false;
+        if (t3 instanceof Fr) return false;
+        const e3 = t3 instanceof Ze2 || t3 instanceof Xe2;
+        let n3 = true;
+        return t3.eachChild((t4) => {
+          n3 = e3 ? n3 && Lr(t4) : n3 && t4 instanceof qe2;
+        }), !!n3 && Or(t3) && Rr(t3, ["zoom", "heatmap-density", "elevation", "line-progress", "accumulated", "is-supported-script"]);
+      }
+      function Or(t3) {
+        if (t3 instanceof Pr) {
+          if ("get" === t3.name && 1 === t3.args.length) return false;
+          if ("feature-state" === t3.name) return false;
+          if ("has" === t3.name && 1 === t3.args.length) return false;
+          if ("properties" === t3.name || "geometry-type" === t3.name || "id" === t3.name) return false;
+          if (/^filter-/.test(t3.name)) return false;
+        }
+        if (t3 instanceof Wn) return false;
+        if (t3 instanceof Tr) return false;
+        let e3 = true;
+        return t3.eachChild((t4) => {
+          e3 && !Or(t4) && (e3 = false);
+        }), e3;
+      }
+      function $r(t3) {
+        if (t3 instanceof Pr && "feature-state" === t3.name) return false;
+        let e3 = true;
+        return t3.eachChild((t4) => {
+          e3 && !$r(t4) && (e3 = false);
+        }), e3;
+      }
+      function Rr(t3, e3) {
+        if (t3 instanceof Pr && e3.indexOf(t3.name) >= 0) return false;
+        let n3 = true;
+        return t3.eachChild((t4) => {
+          n3 && !Rr(t4, e3) && (n3 = false);
+        }), n3;
+      }
+      function Nr(t3) {
+        return { result: "success", value: t3 };
+      }
+      function Ur(t3) {
+        return { result: "error", value: t3 };
+      }
+      function jr(t3) {
+        return "data-driven" === t3["property-type"] || "cross-faded-data-driven" === t3["property-type"];
+      }
+      function qr(t3) {
+        return !!t3.expression && t3.expression.parameters.indexOf("zoom") > -1;
+      }
+      function Gr(t3) {
+        return !!t3.expression && t3.expression.interpolated;
+      }
+      function Xr(t3) {
+        return t3 instanceof Number ? "number" : t3 instanceof String ? "string" : t3 instanceof Boolean ? "boolean" : Array.isArray(t3) ? "array" : null === t3 ? "null" : typeof t3;
+      }
+      function Yr(t3) {
+        return "object" == typeof t3 && null !== t3 && !Array.isArray(t3) && Ue2(t3) === Nt;
+      }
+      function Zr(t3) {
+        return t3;
+      }
+      function Hr(t3, e3) {
+        const n3 = t3.stops && "object" == typeof t3.stops[0][0], r3 = n3 || !(n3 || void 0 !== t3.property), i3 = t3.type || (Gr(e3) ? "exponential" : "interval"), s3 = function(t4) {
+          switch (t4.type) {
+            case "color":
+              return Ie2.parse;
+            case "padding":
+              return Pe2.parse;
+            case "numberArray":
+              return ze2.parse;
+            case "colorArray":
+              return Be2.parse;
+            default:
+              return null;
+          }
+        }(e3);
+        if (s3 && ((t3 = Pt({}, t3)).stops && (t3.stops = t3.stops.map((t4) => [t4[0], s3(t4[1])])), t3.default = s3(t3.default ? t3.default : e3.default)), t3.colorSpace && "rgb" !== (o3 = t3.colorSpace) && "hcl" !== o3 && "lab" !== o3) throw new Error(`Unknown color space: "${t3.colorSpace}"`);
+        var o3;
+        const a3 = function(t4) {
+          switch (t4) {
+            case "exponential":
+              return Qr;
+            case "interval":
+              return Jr;
+            case "categorical":
+              return Kr;
+            case "identity":
+              return ti2;
+            default:
+              throw new Error(`Unknown function type "${t4}"`);
+          }
+        }(i3);
+        let l3, u3;
+        if ("categorical" === i3) {
+          l3 = /* @__PURE__ */ Object.create(null);
+          for (const e4 of t3.stops) l3[e4[0]] = e4[1];
+          u3 = typeof t3.stops[0][0];
+        }
+        if (n3) {
+          const n4 = {}, r4 = [];
+          for (let e4 = 0; e4 < t3.stops.length; e4++) {
+            const i5 = t3.stops[e4], s5 = i5[0].zoom;
+            void 0 === n4[s5] && (n4[s5] = { zoom: s5, type: t3.type, property: t3.property, default: t3.default, stops: [] }, r4.push(s5)), n4[s5].stops.push([i5[0].value, i5[1]]);
+          }
+          const i4 = [];
+          for (const t4 of r4) i4.push([n4[t4].zoom, Hr(n4[t4], e3)]);
+          const s4 = { name: "linear" };
+          return { kind: "composite", interpolationType: s4, interpolationFactor: dn.interpolationFactor.bind(void 0, s4), zoomStops: i4.map((t4) => t4[0]), evaluate: ({ zoom: n5 }, r5) => Qr({ stops: i4, base: t3.base }, e3, n5).evaluate(n5, r5) };
+        }
+        if (r3) {
+          const n4 = "exponential" === i3 ? { name: "exponential", base: void 0 !== t3.base ? t3.base : 1 } : null;
+          return { kind: "camera", interpolationType: n4, interpolationFactor: dn.interpolationFactor.bind(void 0, n4), zoomStops: t3.stops.map((t4) => t4[0]), evaluate: ({ zoom: n5 }) => a3(t3, e3, n5, l3, u3) };
+        }
+        return { kind: "source", evaluate(n4, r4) {
+          const i4 = r4 && r4.properties ? r4.properties[t3.property] : void 0;
+          return void 0 === i4 ? Wr(t3.default, e3.default) : a3(t3, e3, i4, l3, u3);
+        } };
+      }
+      function Wr(t3, e3, n3) {
+        return void 0 !== t3 ? t3 : void 0 !== e3 ? e3 : void 0 !== n3 ? n3 : void 0;
+      }
+      function Kr(t3, e3, n3, r3, i3) {
+        return Wr(typeof n3 === i3 ? r3[n3] : void 0, t3.default, e3.default);
+      }
+      function Jr(t3, e3, n3) {
+        if ("number" !== Xr(n3)) return Wr(t3.default, e3.default);
+        const r3 = t3.stops.length;
+        if (1 === r3) return t3.stops[0][1];
+        if (n3 <= t3.stops[0][0]) return t3.stops[0][1];
+        if (n3 >= t3.stops[r3 - 1][0]) return t3.stops[r3 - 1][1];
+        const i3 = an(t3.stops.map((t4) => t4[0]), n3);
+        return t3.stops[i3][1];
+      }
+      function Qr(t3, e3, n3) {
+        const r3 = void 0 !== t3.base ? t3.base : 1;
+        if ("number" !== Xr(n3)) return Wr(t3.default, e3.default);
+        const i3 = t3.stops.length;
+        if (1 === i3) return t3.stops[0][1];
+        if (n3 <= t3.stops[0][0]) return t3.stops[0][1];
+        if (n3 >= t3.stops[i3 - 1][0]) return t3.stops[i3 - 1][1];
+        const s3 = an(t3.stops.map((t4) => t4[0]), n3), o3 = function(t4, e4, n4, r4) {
+          const i4 = r4 - n4, s4 = t4 - n4;
+          return 0 === i4 ? 0 : 1 === e4 ? s4 / i4 : (Math.pow(e4, s4) - 1) / (Math.pow(e4, i4) - 1);
+        }(n3, r3, t3.stops[s3][0], t3.stops[s3 + 1][0]), a3 = t3.stops[s3][1], l3 = t3.stops[s3 + 1][1], u3 = mn[e3.type] || Zr;
+        return "function" == typeof a3.evaluate ? { evaluate(...e4) {
+          const n4 = a3.evaluate.apply(void 0, e4), r4 = l3.evaluate.apply(void 0, e4);
+          if (void 0 !== n4 && void 0 !== r4) return u3(n4, r4, o3, t3.colorSpace);
+        } } : u3(a3, l3, o3, t3.colorSpace);
+      }
+      function ti2(t3, e3, n3) {
+        switch (e3.type) {
+          case "color":
+            n3 = Ie2.parse(n3);
+            break;
+          case "formatted":
+            n3 = De2.fromString(n3.toString());
+            break;
+          case "resolvedImage":
+            n3 = Oe2.fromString(n3.toString());
+            break;
+          case "padding":
+            n3 = Pe2.parse(n3);
+            break;
+          case "colorArray":
+            n3 = Be2.parse(n3);
+            break;
+          case "numberArray":
+            n3 = ze2.parse(n3);
+            break;
+          default:
+            Xr(n3) === e3.type || "enum" === e3.type && e3.values[n3] || (n3 = void 0);
+        }
+        return Wr(n3, t3.default, e3.default);
+      }
+      Pr.register(Dr, { error: [{ kind: "error" }, [Lt], (t3, [e3]) => {
+        throw new Ce2(e3.evaluate(t3));
+      }], typeof: [Lt, [Ut], (t3, [e3]) => Kt(Ue2(e3.evaluate(t3)))], "to-rgba": [Wt(Vt, 4), [$t], (t3, [e3]) => {
+        const [n3, r3, i3, s3] = e3.evaluate(t3).rgb;
+        return [255 * n3, 255 * r3, 255 * i3, s3];
+      }], rgb: [$t, [Vt, Vt, Vt], zr], rgba: [$t, [Vt, Vt, Vt, Vt], zr], has: { type: Ot, overloads: [[[Lt], (t3, [e3]) => Br(e3.evaluate(t3), t3.properties())], [[Lt, Nt], (t3, [e3, n3]) => Br(e3.evaluate(t3), n3.evaluate(t3))]] }, get: { type: Ut, overloads: [[[Lt], (t3, [e3]) => Cr(e3.evaluate(t3), t3.properties())], [[Lt, Nt], (t3, [e3, n3]) => Cr(e3.evaluate(t3), n3.evaluate(t3))]] }, "feature-state": [Ut, [Lt], (t3, [e3]) => Cr(e3.evaluate(t3), t3.featureState || {})], properties: [Nt, [], (t3) => t3.properties()], "geometry-type": [Lt, [], (t3) => t3.geometryType()], id: [Ut, [], (t3) => t3.id()], zoom: [Vt, [], (t3) => t3.globals.zoom], "heatmap-density": [Vt, [], (t3) => t3.globals.heatmapDensity || 0], elevation: [Vt, [], (t3) => t3.globals.elevation || 0], "line-progress": [Vt, [], (t3) => t3.globals.lineProgress || 0], accumulated: [Ut, [], (t3) => void 0 === t3.globals.accumulated ? null : t3.globals.accumulated], "+": [Vt, Vr(Vt), (t3, e3) => {
+        let n3 = 0;
+        for (const r3 of e3) n3 += r3.evaluate(t3);
+        return n3;
+      }], "*": [Vt, Vr(Vt), (t3, e3) => {
+        let n3 = 1;
+        for (const r3 of e3) n3 *= r3.evaluate(t3);
+        return n3;
+      }], "-": { type: Vt, overloads: [[[Vt, Vt], (t3, [e3, n3]) => e3.evaluate(t3) - n3.evaluate(t3)], [[Vt], (t3, [e3]) => -e3.evaluate(t3)]] }, "/": [Vt, [Vt, Vt], (t3, [e3, n3]) => e3.evaluate(t3) / n3.evaluate(t3)], "%": [Vt, [Vt, Vt], (t3, [e3, n3]) => e3.evaluate(t3) % n3.evaluate(t3)], ln2: [Vt, [], () => Math.LN2], pi: [Vt, [], () => Math.PI], e: [Vt, [], () => Math.E], "^": [Vt, [Vt, Vt], (t3, [e3, n3]) => Math.pow(e3.evaluate(t3), n3.evaluate(t3))], sqrt: [Vt, [Vt], (t3, [e3]) => Math.sqrt(e3.evaluate(t3))], log10: [Vt, [Vt], (t3, [e3]) => Math.log(e3.evaluate(t3)) / Math.LN10], ln: [Vt, [Vt], (t3, [e3]) => Math.log(e3.evaluate(t3))], log2: [Vt, [Vt], (t3, [e3]) => Math.log(e3.evaluate(t3)) / Math.LN2], sin: [Vt, [Vt], (t3, [e3]) => Math.sin(e3.evaluate(t3))], cos: [Vt, [Vt], (t3, [e3]) => Math.cos(e3.evaluate(t3))], tan: [Vt, [Vt], (t3, [e3]) => Math.tan(e3.evaluate(t3))], asin: [Vt, [Vt], (t3, [e3]) => Math.asin(e3.evaluate(t3))], acos: [Vt, [Vt], (t3, [e3]) => Math.acos(e3.evaluate(t3))], atan: [Vt, [Vt], (t3, [e3]) => Math.atan(e3.evaluate(t3))], min: [Vt, Vr(Vt), (t3, e3) => Math.min(...e3.map((e4) => e4.evaluate(t3)))], max: [Vt, Vr(Vt), (t3, e3) => Math.max(...e3.map((e4) => e4.evaluate(t3)))], abs: [Vt, [Vt], (t3, [e3]) => Math.abs(e3.evaluate(t3))], round: [Vt, [Vt], (t3, [e3]) => {
+        const n3 = e3.evaluate(t3);
+        return n3 < 0 ? -Math.round(-n3) : Math.round(n3);
+      }], floor: [Vt, [Vt], (t3, [e3]) => Math.floor(e3.evaluate(t3))], ceil: [Vt, [Vt], (t3, [e3]) => Math.ceil(e3.evaluate(t3))], "filter-==": [Ot, [Lt, Ut], (t3, [e3, n3]) => t3.properties()[e3.value] === n3.value], "filter-id-==": [Ot, [Ut], (t3, [e3]) => t3.id() === e3.value], "filter-type-==": [Ot, [Lt], (t3, [e3]) => t3.geometryType() === e3.value], "filter-<": [Ot, [Lt, Ut], (t3, [e3, n3]) => {
+        const r3 = t3.properties()[e3.value], i3 = n3.value;
+        return typeof r3 == typeof i3 && r3 < i3;
+      }], "filter-id-<": [Ot, [Ut], (t3, [e3]) => {
+        const n3 = t3.id(), r3 = e3.value;
+        return typeof n3 == typeof r3 && n3 < r3;
+      }], "filter->": [Ot, [Lt, Ut], (t3, [e3, n3]) => {
+        const r3 = t3.properties()[e3.value], i3 = n3.value;
+        return typeof r3 == typeof i3 && r3 > i3;
+      }], "filter-id->": [Ot, [Ut], (t3, [e3]) => {
+        const n3 = t3.id(), r3 = e3.value;
+        return typeof n3 == typeof r3 && n3 > r3;
+      }], "filter-<=": [Ot, [Lt, Ut], (t3, [e3, n3]) => {
+        const r3 = t3.properties()[e3.value], i3 = n3.value;
+        return typeof r3 == typeof i3 && r3 <= i3;
+      }], "filter-id-<=": [Ot, [Ut], (t3, [e3]) => {
+        const n3 = t3.id(), r3 = e3.value;
+        return typeof n3 == typeof r3 && n3 <= r3;
+      }], "filter->=": [Ot, [Lt, Ut], (t3, [e3, n3]) => {
+        const r3 = t3.properties()[e3.value], i3 = n3.value;
+        return typeof r3 == typeof i3 && r3 >= i3;
+      }], "filter-id->=": [Ot, [Ut], (t3, [e3]) => {
+        const n3 = t3.id(), r3 = e3.value;
+        return typeof n3 == typeof r3 && n3 >= r3;
+      }], "filter-has": [Ot, [Ut], (t3, [e3]) => e3.value in t3.properties()], "filter-has-id": [Ot, [], (t3) => null !== t3.id() && void 0 !== t3.id()], "filter-type-in": [Ot, [Wt(Lt)], (t3, [e3]) => e3.value.indexOf(t3.geometryType()) >= 0], "filter-id-in": [Ot, [Wt(Ut)], (t3, [e3]) => e3.value.indexOf(t3.id()) >= 0], "filter-in-small": [Ot, [Lt, Wt(Ut)], (t3, [e3, n3]) => n3.value.indexOf(t3.properties()[e3.value]) >= 0], "filter-in-large": [Ot, [Lt, Wt(Ut)], (t3, [e3, n3]) => function(t4, e4, n4, r3) {
+        for (; n4 <= r3; ) {
+          const i3 = n4 + r3 >> 1;
+          if (e4[i3] === t4) return true;
+          e4[i3] > t4 ? r3 = i3 - 1 : n4 = i3 + 1;
+        }
+        return false;
+      }(t3.properties()[e3.value], n3.value, 0, n3.value.length - 1)], all: { type: Ot, overloads: [[[Ot, Ot], (t3, [e3, n3]) => e3.evaluate(t3) && n3.evaluate(t3)], [Vr(Ot), (t3, e3) => {
+        for (const n3 of e3) if (!n3.evaluate(t3)) return false;
+        return true;
+      }]] }, any: { type: Ot, overloads: [[[Ot, Ot], (t3, [e3, n3]) => e3.evaluate(t3) || n3.evaluate(t3)], [Vr(Ot), (t3, e3) => {
+        for (const n3 of e3) if (n3.evaluate(t3)) return true;
+        return false;
+      }]] }, "!": [Ot, [Ot], (t3, [e3]) => !e3.evaluate(t3)], "is-supported-script": [Ot, [Lt], (t3, [e3]) => {
+        const n3 = t3.globals && t3.globals.isSupportedScript;
+        return !n3 || n3(e3.evaluate(t3));
+      }], upcase: [Lt, [Lt], (t3, [e3]) => e3.evaluate(t3).toUpperCase()], downcase: [Lt, [Lt], (t3, [e3]) => e3.evaluate(t3).toLowerCase()], concat: [Lt, Vr(Ut), (t3, e3) => e3.map((e4) => je2(e4.evaluate(t3))).join("")], split: [Wt(Lt), [Lt, Lt], (t3, [e3, n3]) => e3.evaluate(t3).split(n3.evaluate(t3))], join: [Lt, [Wt(Lt), Lt], (t3, [e3, n3]) => e3.value.join(n3.evaluate(t3))], "resolved-locale": [Lt, [jt], (t3, [e3]) => e3.evaluate(t3).resolvedLocale()] });
+      class ei2 {
+        constructor(t3, e3, n3) {
+          this.expression = t3, this._warningHistory = {}, this._evaluator = new We2(), this._defaultValue = e3 ? function(t4) {
+            if ("color" === t4.type && Yr(t4.default)) return new Ie2(0, 0, 0, 0);
+            switch (t4.type) {
+              case "color":
+                return Ie2.parse(t4.default) || null;
+              case "padding":
+                return Pe2.parse(t4.default) || null;
+              case "numberArray":
+                return ze2.parse(t4.default) || null;
+              case "colorArray":
+                return Be2.parse(t4.default) || null;
+              case "variableAnchorOffsetCollection":
+                return Le2.parse(t4.default) || null;
+              case "projectionDefinition":
+                return $e2.parse(t4.default) || null;
+              default:
+                return void 0 === t4.default ? null : t4.default;
+            }
+          }(e3) : null, this._enumValues = e3 && "enum" === e3.type ? e3.values : null, this._globalState = n3;
+        }
+        evaluateWithoutErrorHandling(t3, e3, n3, r3, i3, s3) {
+          return this._globalState && (t3 = ci2(t3, this._globalState)), this._evaluator.globals = t3, this._evaluator.feature = e3, this._evaluator.featureState = n3, this._evaluator.canonical = r3, this._evaluator.availableImages = i3 || null, this._evaluator.formattedSection = s3, this.expression.evaluate(this._evaluator);
+        }
+        evaluate(t3, e3, n3, r3, i3, s3) {
+          this._globalState && (t3 = ci2(t3, this._globalState)), this._evaluator.globals = t3, this._evaluator.feature = e3 || null, this._evaluator.featureState = n3 || null, this._evaluator.canonical = r3, this._evaluator.availableImages = i3 || null, this._evaluator.formattedSection = s3 || null;
+          try {
+            const t4 = this.expression.evaluate(this._evaluator);
+            if (null == t4 || "number" == typeof t4 && t4 != t4) return this._defaultValue;
+            if (this._enumValues && !(t4 in this._enumValues)) throw new Ce2(`Expected value to be one of ${Object.keys(this._enumValues).map((t5) => JSON.stringify(t5)).join(", ")}, but found ${JSON.stringify(t4)} instead.`);
+            return t4;
+          } catch (t4) {
+            return this._warningHistory[t4.message] || (this._warningHistory[t4.message] = true, "undefined" != typeof console && console.warn(t4.message)), this._defaultValue;
+          }
+        }
+      }
+      function ni2(t3) {
+        return Array.isArray(t3) && t3.length > 0 && "string" == typeof t3[0] && t3[0] in Dr;
+      }
+      function ri2(t3, e3, n3) {
+        const r3 = new Ke2(Dr, Lr, [], e3 ? function(t4) {
+          const e4 = { color: $t, string: Lt, number: Vt, enum: Lt, boolean: Ot, formatted: qt, padding: Gt, numberArray: Yt, colorArray: Xt, projectionDefinition: Rt, resolvedImage: Zt, variableAnchorOffsetCollection: Ht };
+          return "array" === t4.type ? Wt(e4[t4.value] || Ut, t4.length) : e4[t4.type];
+        }(e3) : void 0), i3 = r3.parse(t3, void 0, void 0, void 0, e3 && "string" === e3.type ? { typeAnnotation: "coerce" } : void 0);
+        return i3 ? Nr(new ei2(i3, e3, n3)) : Ur(r3.errors);
+      }
+      class ii2 {
+        constructor(t3, e3, n3) {
+          this.kind = t3, this._styleExpression = e3, this.isStateDependent = "constant" !== t3 && !$r(e3.expression), this.globalStateRefs = ui2(e3.expression), this._globalState = n3;
+        }
+        evaluateWithoutErrorHandling(t3, e3, n3, r3, i3, s3) {
+          return this._globalState && (t3 = ci2(t3, this._globalState)), this._styleExpression.evaluateWithoutErrorHandling(t3, e3, n3, r3, i3, s3);
+        }
+        evaluate(t3, e3, n3, r3, i3, s3) {
+          return this._globalState && (t3 = ci2(t3, this._globalState)), this._styleExpression.evaluate(t3, e3, n3, r3, i3, s3);
+        }
+      }
+      class si2 {
+        constructor(t3, e3, n3, r3, i3) {
+          this.kind = t3, this.zoomStops = n3, this._styleExpression = e3, this.isStateDependent = "camera" !== t3 && !$r(e3.expression), this.globalStateRefs = ui2(e3.expression), this.interpolationType = r3, this._globalState = i3;
+        }
+        evaluateWithoutErrorHandling(t3, e3, n3, r3, i3, s3) {
+          return this._globalState && (t3 = ci2(t3, this._globalState)), this._styleExpression.evaluateWithoutErrorHandling(t3, e3, n3, r3, i3, s3);
+        }
+        evaluate(t3, e3, n3, r3, i3, s3) {
+          return this._globalState && (t3 = ci2(t3, this._globalState)), this._styleExpression.evaluate(t3, e3, n3, r3, i3, s3);
+        }
+        interpolationFactor(t3, e3, n3) {
+          return this.interpolationType ? dn.interpolationFactor(this.interpolationType, t3, e3, n3) : 0;
+        }
+      }
+      function oi2(t3, e3, n3) {
+        const r3 = ri2(t3, e3, n3);
+        if ("error" === r3.result) return r3;
+        const i3 = r3.value.expression, s3 = Or(i3);
+        if (!s3 && !jr(e3)) return Ur([new zt("", "data expressions not supported")]);
+        const o3 = Rr(i3, ["zoom"]);
+        if (!o3 && !qr(e3)) return Ur([new zt("", "zoom expressions not supported")]);
+        const a3 = li2(i3);
+        return a3 || o3 ? a3 instanceof zt ? Ur([a3]) : a3 instanceof dn && !Gr(e3) ? Ur([new zt("", '"interpolate" expressions cannot be used with this property')]) : Nr(a3 ? new si2(s3 ? "camera" : "composite", r3.value, a3.labels, a3 instanceof dn ? a3.interpolation : void 0, n3) : new ii2(s3 ? "constant" : "source", r3.value, n3)) : Ur([new zt("", '"zoom" expression may only be used as input to a top-level "step" or "interpolate" expression.')]);
+      }
+      class ai2 {
+        constructor(t3, e3) {
+          this._parameters = t3, this._specification = e3, Pt(this, Hr(this._parameters, this._specification));
+        }
+        static deserialize(t3) {
+          return new ai2(t3._parameters, t3._specification);
+        }
+        static serialize(t3) {
+          return { _parameters: t3._parameters, _specification: t3._specification };
+        }
+      }
+      function li2(t3) {
+        let e3 = null;
+        if (t3 instanceof Je2) e3 = li2(t3.result);
+        else if (t3 instanceof gn) {
+          for (const n3 of t3.args) if (e3 = li2(n3), e3) break;
+        } else (t3 instanceof ln || t3 instanceof dn) && t3.input instanceof Pr && "zoom" === t3.input.name && (e3 = t3);
+        return e3 instanceof zt || t3.eachChild((t4) => {
+          const n3 = li2(t4);
+          n3 instanceof zt ? e3 = n3 : !e3 && n3 ? e3 = new zt("", '"zoom" expression may only be used as input to a top-level "step" or "interpolate" expression.') : e3 && n3 && e3 !== n3 && (e3 = new zt("", 'Only one zoom-based "step" or "interpolate" subexpression may be used in an expression.'));
+        }), e3;
+      }
+      function ui2(t3, e3 = /* @__PURE__ */ new Set()) {
+        return t3 instanceof Fr && e3.add(t3.key), t3.eachChild((t4) => {
+          ui2(t4, e3);
+        }), e3;
+      }
+      function ci2(t3, e3) {
+        const { zoom: n3, heatmapDensity: r3, elevation: i3, lineProgress: s3, isSupportedScript: o3, accumulated: a3 } = null != t3 ? t3 : {};
+        return { zoom: n3, heatmapDensity: r3, elevation: i3, lineProgress: s3, isSupportedScript: o3, accumulated: a3, globalState: e3 };
+      }
+      function hi2(t3) {
+        if (true === t3 || false === t3) return true;
+        if (!Array.isArray(t3) || 0 === t3.length) return false;
+        switch (t3[0]) {
+          case "has":
+            return t3.length >= 2 && "$id" !== t3[1] && "$type" !== t3[1];
+          case "in":
+            return t3.length >= 3 && ("string" != typeof t3[1] || Array.isArray(t3[2]));
+          case "!in":
+          case "!has":
+          case "none":
+            return false;
+          case "==":
+          case "!=":
+          case ">":
+          case ">=":
+          case "<":
+          case "<=":
+            return 3 !== t3.length || Array.isArray(t3[1]) || Array.isArray(t3[2]);
+          case "any":
+          case "all":
+            for (const e3 of t3.slice(1)) if (!hi2(e3) && "boolean" != typeof e3) return false;
+            return true;
+          default:
+            return true;
+        }
+      }
+      const pi2 = { type: "boolean", default: false, transition: false, "property-type": "data-driven", expression: { interpolated: false, parameters: ["zoom", "feature"] } };
+      function fi2(t3, e3) {
+        if (null == t3) return { filter: () => true, needGeometry: false, getGlobalStateRefs: () => /* @__PURE__ */ new Set() };
+        hi2(t3) || (t3 = mi2(t3));
+        const n3 = ri2(t3, pi2, e3);
+        if ("error" === n3.result) throw new Error(n3.value.map((t4) => `${t4.key}: ${t4.message}`).join(", "));
+        return { filter: (t4, e4, r3) => n3.value.evaluate(t4, e4, {}, r3), needGeometry: yi2(t3), getGlobalStateRefs: () => ui2(n3.value.expression) };
+      }
+      function di2(t3, e3) {
+        return t3 < e3 ? -1 : t3 > e3 ? 1 : 0;
+      }
+      function yi2(t3) {
+        if (!Array.isArray(t3)) return false;
+        if ("within" === t3[0] || "distance" === t3[0]) return true;
+        for (let e3 = 1; e3 < t3.length; e3++) if (yi2(t3[e3])) return true;
+        return false;
+      }
+      function mi2(t3) {
+        if (!t3) return true;
+        const e3 = t3[0];
+        return t3.length <= 1 ? "any" !== e3 : "==" === e3 ? gi2(t3[1], t3[2], "==") : "!=" === e3 ? bi2(gi2(t3[1], t3[2], "==")) : "<" === e3 || ">" === e3 || "<=" === e3 || ">=" === e3 ? gi2(t3[1], t3[2], e3) : "any" === e3 ? (n3 = t3.slice(1), ["any"].concat(n3.map(mi2))) : "all" === e3 ? ["all"].concat(t3.slice(1).map(mi2)) : "none" === e3 ? ["all"].concat(t3.slice(1).map(mi2).map(bi2)) : "in" === e3 ? xi2(t3[1], t3.slice(2)) : "!in" === e3 ? bi2(xi2(t3[1], t3.slice(2))) : "has" === e3 ? vi2(t3[1]) : "!has" !== e3 || bi2(vi2(t3[1]));
+        var n3;
+      }
+      function gi2(t3, e3, n3) {
+        switch (t3) {
+          case "$type":
+            return [`filter-type-${n3}`, e3];
+          case "$id":
+            return [`filter-id-${n3}`, e3];
+          default:
+            return [`filter-${n3}`, t3, e3];
+        }
+      }
+      function xi2(t3, e3) {
+        if (0 === e3.length) return false;
+        switch (t3) {
+          case "$type":
+            return ["filter-type-in", ["literal", e3]];
+          case "$id":
+            return ["filter-id-in", ["literal", e3]];
+          default:
+            return e3.length > 200 && !e3.some((t4) => typeof t4 != typeof e3[0]) ? ["filter-in-large", t3, ["literal", e3.sort(di2)]] : ["filter-in-small", t3, ["literal", e3]];
+        }
+      }
+      function vi2(t3) {
+        switch (t3) {
+          case "$type":
+            return true;
+          case "$id":
+            return ["filter-has-id"];
+          default:
+            return ["filter-has", t3];
+        }
+      }
+      function bi2(t3) {
+        return ["!", t3];
+      }
+      function wi2(t3) {
+        const e3 = typeof t3;
+        if ("number" === e3 || "boolean" === e3 || "string" === e3 || null == t3) return JSON.stringify(t3);
+        if (Array.isArray(t3)) {
+          let e4 = "[";
+          for (const n4 of t3) e4 += `${wi2(n4)},`;
+          return `${e4}]`;
+        }
+        const n3 = Object.keys(t3).sort();
+        let r3 = "{";
+        for (let e4 = 0; e4 < n3.length; e4++) r3 += `${JSON.stringify(n3[e4])}:${wi2(t3[n3[e4]])},`;
+        return `${r3}}`;
+      }
+      function _i(t3) {
+        let e3 = "";
+        for (const n3 of bt) e3 += `/${wi2(t3[n3])}`;
+        return e3;
+      }
+      function Si2(t3) {
+        const e3 = t3.value;
+        return e3 ? [new Dt(t3.key, e3, "constants have been deprecated as of v8")] : [];
+      }
+      function Ai2(t3) {
+        return t3 instanceof Number || t3 instanceof String || t3 instanceof Boolean ? t3.valueOf() : t3;
+      }
+      function Mi2(t3) {
+        if (Array.isArray(t3)) return t3.map(Mi2);
+        if (t3 instanceof Object && !(t3 instanceof Number || t3 instanceof String || t3 instanceof Boolean)) {
+          const e3 = {};
+          for (const n3 in t3) e3[n3] = Mi2(t3[n3]);
+          return e3;
+        }
+        return Ai2(t3);
+      }
+      function ki2(t3) {
+        const e3 = t3.key, n3 = t3.value, r3 = t3.valueSpec || {}, i3 = t3.objectElementValidators || {}, s3 = t3.style, o3 = t3.styleSpec, a3 = t3.validateSpec;
+        let l3 = [];
+        const u3 = Xr(n3);
+        if ("object" !== u3) return [new Dt(e3, n3, `object expected, ${u3} found`)];
+        for (const t4 in n3) {
+          const u4 = t4.split(".")[0], c3 = ve2(r3, u4) || r3["*"];
+          let h3;
+          if (ve2(i3, u4)) h3 = i3[u4];
+          else if (ve2(r3, u4)) {
+            if (void 0 === n3[t4]) continue;
+            h3 = a3;
+          } else if (i3["*"]) h3 = i3["*"];
+          else {
+            if (!r3["*"]) {
+              l3.push(new Dt(e3, n3[t4], `unknown property "${t4}"`));
+              continue;
+            }
+            h3 = a3;
+          }
+          l3 = l3.concat(h3({ key: (e3 ? `${e3}.` : e3) + t4, value: n3[t4], valueSpec: c3, style: s3, styleSpec: o3, object: n3, objectKey: t4, validateSpec: a3 }, n3));
+        }
+        for (const t4 in r3) i3[t4] || r3[t4].required && void 0 === r3[t4].default && void 0 === n3[t4] && l3.push(new Dt(e3, n3, `missing required property "${t4}"`));
+        return l3;
+      }
+      function Ii2(t3) {
+        const e3 = t3.value, n3 = t3.valueSpec, r3 = t3.style, i3 = t3.styleSpec, s3 = t3.key, o3 = t3.arrayElementValidator || t3.validateSpec;
+        if ("array" !== Xr(e3)) return [new Dt(s3, e3, `array expected, ${Xr(e3)} found`)];
+        if (n3.length && e3.length !== n3.length) return [new Dt(s3, e3, `array length ${n3.length} expected, length ${e3.length} found`)];
+        let a3 = { type: n3.value, values: n3.values };
+        i3.$version < 7 && (a3.function = n3.function), "object" === Xr(n3.value) && (a3 = n3.value);
+        let l3 = [];
+        for (let n4 = 0; n4 < e3.length; n4++) l3 = l3.concat(o3({ array: e3, arrayIndex: n4, value: e3[n4], valueSpec: a3, validateSpec: t3.validateSpec, style: r3, styleSpec: i3, key: `${s3}[${n4}]` }));
+        return l3;
+      }
+      function Ei2(t3) {
+        const e3 = t3.key, n3 = t3.value, r3 = t3.valueSpec;
+        let i3 = Xr(n3);
+        return "number" === i3 && n3 != n3 && (i3 = "NaN"), "number" !== i3 ? [new Dt(e3, n3, `number expected, ${i3} found`)] : "minimum" in r3 && n3 < r3.minimum ? [new Dt(e3, n3, `${n3} is less than the minimum value ${r3.minimum}`)] : "maximum" in r3 && n3 > r3.maximum ? [new Dt(e3, n3, `${n3} is greater than the maximum value ${r3.maximum}`)] : [];
+      }
+      function Ti2(t3) {
+        const e3 = t3.valueSpec, n3 = Ai2(t3.value.type);
+        let r3, i3, s3, o3 = {};
+        const a3 = "categorical" !== n3 && void 0 === t3.value.property, l3 = !a3, u3 = "array" === Xr(t3.value.stops) && "array" === Xr(t3.value.stops[0]) && "object" === Xr(t3.value.stops[0][0]), c3 = ki2({ key: t3.key, value: t3.value, valueSpec: t3.styleSpec.function, validateSpec: t3.validateSpec, style: t3.style, styleSpec: t3.styleSpec, objectElementValidators: { stops: function(t4) {
+          if ("identity" === n3) return [new Dt(t4.key, t4.value, 'identity function may not have a "stops" property')];
+          let e4 = [];
+          const r4 = t4.value;
+          return e4 = e4.concat(Ii2({ key: t4.key, value: r4, valueSpec: t4.valueSpec, validateSpec: t4.validateSpec, style: t4.style, styleSpec: t4.styleSpec, arrayElementValidator: h3 })), "array" === Xr(r4) && 0 === r4.length && e4.push(new Dt(t4.key, r4, "array must have at least one stop")), e4;
+        }, default: function(t4) {
+          return t4.validateSpec({ key: t4.key, value: t4.value, valueSpec: e3, validateSpec: t4.validateSpec, style: t4.style, styleSpec: t4.styleSpec });
+        } } });
+        return "identity" === n3 && a3 && c3.push(new Dt(t3.key, t3.value, 'missing required property "property"')), "identity" === n3 || t3.value.stops || c3.push(new Dt(t3.key, t3.value, 'missing required property "stops"')), "exponential" === n3 && t3.valueSpec.expression && !Gr(t3.valueSpec) && c3.push(new Dt(t3.key, t3.value, "exponential functions not supported")), t3.styleSpec.$version >= 8 && (l3 && !jr(t3.valueSpec) ? c3.push(new Dt(t3.key, t3.value, "property functions not supported")) : a3 && !qr(t3.valueSpec) && c3.push(new Dt(t3.key, t3.value, "zoom functions not supported"))), "categorical" !== n3 && !u3 || void 0 !== t3.value.property || c3.push(new Dt(t3.key, t3.value, '"property" property is required')), c3;
+        function h3(t4) {
+          let n4 = [];
+          const r4 = t4.value, a4 = t4.key;
+          if ("array" !== Xr(r4)) return [new Dt(a4, r4, `array expected, ${Xr(r4)} found`)];
+          if (2 !== r4.length) return [new Dt(a4, r4, `array length 2 expected, length ${r4.length} found`)];
+          if (u3) {
+            if ("object" !== Xr(r4[0])) return [new Dt(a4, r4, `object expected, ${Xr(r4[0])} found`)];
+            if (void 0 === r4[0].zoom) return [new Dt(a4, r4, "object stop key must have zoom")];
+            if (void 0 === r4[0].value) return [new Dt(a4, r4, "object stop key must have value")];
+            if (s3 && s3 > Ai2(r4[0].zoom)) return [new Dt(a4, r4[0].zoom, "stop zoom values must appear in ascending order")];
+            Ai2(r4[0].zoom) !== s3 && (s3 = Ai2(r4[0].zoom), i3 = void 0, o3 = {}), n4 = n4.concat(ki2({ key: `${a4}[0]`, value: r4[0], valueSpec: { zoom: {} }, validateSpec: t4.validateSpec, style: t4.style, styleSpec: t4.styleSpec, objectElementValidators: { zoom: Ei2, value: p3 } }));
+          } else n4 = n4.concat(p3({ key: `${a4}[0]`, value: r4[0], validateSpec: t4.validateSpec, style: t4.style, styleSpec: t4.styleSpec }, r4));
+          return ni2(Mi2(r4[1])) ? n4.concat([new Dt(`${a4}[1]`, r4[1], "expressions are not allowed in function stops.")]) : n4.concat(t4.validateSpec({ key: `${a4}[1]`, value: r4[1], valueSpec: e3, validateSpec: t4.validateSpec, style: t4.style, styleSpec: t4.styleSpec }));
+        }
+        function p3(t4, s4) {
+          const a4 = Xr(t4.value), l4 = Ai2(t4.value), u4 = null !== t4.value ? t4.value : s4;
+          if (r3) {
+            if (a4 !== r3) return [new Dt(t4.key, u4, `${a4} stop domain type must match previous stop domain type ${r3}`)];
+          } else r3 = a4;
+          if ("number" !== a4 && "string" !== a4 && "boolean" !== a4) return [new Dt(t4.key, u4, "stop domain value must be a number, string, or boolean")];
+          if ("number" !== a4 && "categorical" !== n3) {
+            let r4 = `number expected, ${a4} found`;
+            return jr(e3) && void 0 === n3 && (r4 += '\nIf you intended to use a categorical function, specify `"type": "categorical"`.'), [new Dt(t4.key, u4, r4)];
+          }
+          return "categorical" !== n3 || "number" !== a4 || isFinite(l4) && Math.floor(l4) === l4 ? "categorical" !== n3 && "number" === a4 && void 0 !== i3 && l4 < i3 ? [new Dt(t4.key, u4, "stop domain values must appear in ascending order")] : (i3 = l4, "categorical" === n3 && l4 in o3 ? [new Dt(t4.key, u4, "stop domain values must be unique")] : (o3[l4] = true, [])) : [new Dt(t4.key, u4, `integer expected, found ${l4}`)];
+        }
+      }
+      function Fi2(t3) {
+        const e3 = ("property" === t3.expressionContext ? oi2 : ri2)(Mi2(t3.value), t3.valueSpec);
+        if ("error" === e3.result) return e3.value.map((e4) => new Dt(`${t3.key}${e4.key}`, t3.value, e4.message));
+        const n3 = e3.value.expression || e3.value._styleExpression.expression;
+        if ("property" === t3.expressionContext && "text-font" === t3.propertyKey && !n3.outputDefined()) return [new Dt(t3.key, t3.value, `Invalid data expression for "${t3.propertyKey}". Output values must be contained as literals within the expression.`)];
+        if ("property" === t3.expressionContext && "layout" === t3.propertyType && !$r(n3)) return [new Dt(t3.key, t3.value, '"feature-state" data expressions are not supported with layout properties.')];
+        if ("filter" === t3.expressionContext && !$r(n3)) return [new Dt(t3.key, t3.value, '"feature-state" data expressions are not supported with filters.')];
+        if (t3.expressionContext && 0 === t3.expressionContext.indexOf("cluster")) {
+          if (!Rr(n3, ["zoom", "feature-state"])) return [new Dt(t3.key, t3.value, '"zoom" and "feature-state" expressions are not supported with cluster properties.')];
+          if ("cluster-initial" === t3.expressionContext && !Or(n3)) return [new Dt(t3.key, t3.value, "Feature data expressions are not supported with initial expression part of cluster properties.")];
+        }
+        return [];
+      }
+      function Di2(t3) {
+        const e3 = t3.key, n3 = t3.value, r3 = Xr(n3);
+        return "string" !== r3 ? [new Dt(e3, n3, `color expected, ${r3} found`)] : Ie2.parse(String(n3)) ? [] : [new Dt(e3, n3, `color expected, "${n3}" found`)];
+      }
+      function Pi2(t3) {
+        const e3 = t3.key, n3 = t3.value, r3 = t3.valueSpec, i3 = [];
+        return Array.isArray(r3.values) ? -1 === r3.values.indexOf(Ai2(n3)) && i3.push(new Dt(e3, n3, `expected one of [${r3.values.join(", ")}], ${JSON.stringify(n3)} found`)) : -1 === Object.keys(r3.values).indexOf(Ai2(n3)) && i3.push(new Dt(e3, n3, `expected one of [${Object.keys(r3.values).join(", ")}], ${JSON.stringify(n3)} found`)), i3;
+      }
+      function zi2(t3) {
+        return hi2(Mi2(t3.value)) ? Fi2(Pt({}, t3, { expressionContext: "filter", valueSpec: { value: "boolean" } })) : Bi2(t3);
+      }
+      function Bi2(t3) {
+        const e3 = t3.value, n3 = t3.key;
+        if ("array" !== Xr(e3)) return [new Dt(n3, e3, `array expected, ${Xr(e3)} found`)];
+        const r3 = t3.styleSpec;
+        let i3, s3 = [];
+        if (e3.length < 1) return [new Dt(n3, e3, "filter array must have at least 1 element")];
+        switch (s3 = s3.concat(Pi2({ key: `${n3}[0]`, value: e3[0], valueSpec: r3.filter_operator, style: t3.style, styleSpec: t3.styleSpec })), Ai2(e3[0])) {
+          case "<":
+          case "<=":
+          case ">":
+          case ">=":
+            e3.length >= 2 && "$type" === Ai2(e3[1]) && s3.push(new Dt(n3, e3, `"$type" cannot be use with operator "${e3[0]}"`));
+          case "==":
+          case "!=":
+            3 !== e3.length && s3.push(new Dt(n3, e3, `filter array for operator "${e3[0]}" must have 3 elements`));
+          case "in":
+          case "!in":
+            e3.length >= 2 && (i3 = Xr(e3[1]), "string" !== i3 && s3.push(new Dt(`${n3}[1]`, e3[1], `string expected, ${i3} found`)));
+            for (let o3 = 2; o3 < e3.length; o3++) i3 = Xr(e3[o3]), "$type" === Ai2(e3[1]) ? s3 = s3.concat(Pi2({ key: `${n3}[${o3}]`, value: e3[o3], valueSpec: r3.geometry_type, style: t3.style, styleSpec: t3.styleSpec })) : "string" !== i3 && "number" !== i3 && "boolean" !== i3 && s3.push(new Dt(`${n3}[${o3}]`, e3[o3], `string, number, or boolean expected, ${i3} found`));
+            break;
+          case "any":
+          case "all":
+          case "none":
+            for (let r4 = 1; r4 < e3.length; r4++) s3 = s3.concat(Bi2({ key: `${n3}[${r4}]`, value: e3[r4], style: t3.style, styleSpec: t3.styleSpec }));
+            break;
+          case "has":
+          case "!has":
+            i3 = Xr(e3[1]), 2 !== e3.length ? s3.push(new Dt(n3, e3, `filter array for "${e3[0]}" operator must have 2 elements`)) : "string" !== i3 && s3.push(new Dt(`${n3}[1]`, e3[1], `string expected, ${i3} found`));
+        }
+        return s3;
+      }
+      function Ci2(t3, e3) {
+        const n3 = t3.key, r3 = t3.validateSpec, i3 = t3.style, s3 = t3.styleSpec, o3 = t3.value, a3 = t3.objectKey, l3 = s3[`${e3}_${t3.layerType}`];
+        if (!l3) return [];
+        const u3 = a3.match(/^(.*)-transition$/);
+        if ("paint" === e3 && u3 && l3[u3[1]] && l3[u3[1]].transition) return r3({ key: n3, value: o3, valueSpec: s3.transition, style: i3, styleSpec: s3 });
+        const c3 = t3.valueSpec || l3[a3];
+        if (!c3) return [new Dt(n3, o3, `unknown property "${a3}"`)];
+        let h3;
+        if ("string" === Xr(o3) && jr(c3) && !c3.tokens && (h3 = /^{([^}]+)}$/.exec(o3))) return [new Dt(n3, o3, `"${a3}" does not support interpolation syntax
+Use an identity property function instead: \`{ "type": "identity", "property": ${JSON.stringify(h3[1])} }\`.`)];
+        const p3 = [];
+        return "symbol" === t3.layerType && "text-font" === a3 && Yr(Mi2(o3)) && "identity" === Ai2(o3.type) && p3.push(new Dt(n3, o3, '"text-font" does not support identity functions')), p3.concat(r3({ key: t3.key, value: o3, valueSpec: c3, style: i3, styleSpec: s3, expressionContext: "property", propertyType: e3, propertyKey: a3 }));
+      }
+      function Vi2(t3) {
+        return Ci2(t3, "paint");
+      }
+      function Li2(t3) {
+        return Ci2(t3, "layout");
+      }
+      function Oi2(t3) {
+        var e3, n3;
+        let r3 = [];
+        const i3 = t3.value, s3 = t3.key, o3 = t3.style, a3 = t3.styleSpec;
+        if ("object" !== Xr(i3)) return [new Dt(s3, i3, `object expected, ${Xr(i3)} found`)];
+        i3.type || i3.ref || r3.push(new Dt(s3, i3, 'either "type" or "ref" is required'));
+        let l3 = Ai2(i3.type);
+        const u3 = Ai2(i3.ref);
+        if (i3.id) {
+          const e4 = Ai2(i3.id);
+          for (let n4 = 0; n4 < t3.arrayIndex; n4++) {
+            const t4 = o3.layers[n4];
+            Ai2(t4.id) === e4 && r3.push(new Dt(s3, i3.id, `duplicate layer id "${i3.id}", previously used at line ${t4.id.__line__}`));
+          }
+        }
+        if ("ref" in i3) {
+          let t4;
+          ["type", "source", "source-layer", "filter", "layout"].forEach((t5) => {
+            t5 in i3 && r3.push(new Dt(s3, i3[t5], `"${t5}" is prohibited for ref layers`));
+          }), o3.layers.forEach((e4) => {
+            Ai2(e4.id) === u3 && (t4 = e4);
+          }), t4 ? t4.ref ? r3.push(new Dt(s3, i3.ref, "ref cannot reference another ref layer")) : l3 = Ai2(t4.type) : r3.push(new Dt(s3, i3.ref, `ref layer "${u3}" not found`));
+        } else if ("background" !== l3) if (i3.source) {
+          const t4 = o3.sources && o3.sources[i3.source], e4 = t4 && Ai2(t4.type);
+          t4 ? "vector" === e4 && "raster" === l3 ? r3.push(new Dt(s3, i3.source, `layer "${i3.id}" requires a raster source`)) : "raster-dem" !== e4 && "hillshade" === l3 || "raster-dem" !== e4 && "color-relief" === l3 ? r3.push(new Dt(s3, i3.source, `layer "${i3.id}" requires a raster-dem source`)) : "raster" === e4 && "raster" !== l3 ? r3.push(new Dt(s3, i3.source, `layer "${i3.id}" requires a vector source`)) : "vector" !== e4 || i3["source-layer"] ? "raster-dem" === e4 && "hillshade" !== l3 && "color-relief" !== l3 ? r3.push(new Dt(s3, i3.source, "raster-dem source can only be used with layer type 'hillshade' or 'color-relief'.")) : "line" !== l3 || !i3.paint || !i3.paint["line-gradient"] || "geojson" === e4 && t4.lineMetrics || r3.push(new Dt(s3, i3, `layer "${i3.id}" specifies a line-gradient, which requires a GeoJSON source with \`lineMetrics\` enabled.`)) : r3.push(new Dt(s3, i3, `layer "${i3.id}" must specify a "source-layer"`)) : r3.push(new Dt(s3, i3.source, `source "${i3.source}" not found`));
+        } else r3.push(new Dt(s3, i3, 'missing required property "source"'));
+        return "raster" === l3 && (null === (e3 = i3.paint) || void 0 === e3 ? void 0 : e3.resampling) && (null === (n3 = i3.paint) || void 0 === n3 ? void 0 : n3["raster-resampling"]) && r3.push(new Dt(s3, i3.paint, `layer "${i3.id}" redundantly specifies "resampling" and "raster-resampling" paint properties, but only one is allowed. It is advised to use "resampling".`)), r3 = r3.concat(ki2({ key: s3, value: i3, valueSpec: a3.layer, style: t3.style, styleSpec: t3.styleSpec, validateSpec: t3.validateSpec, objectElementValidators: { "*": () => [], type: () => t3.validateSpec({ key: `${s3}.type`, value: i3.type, valueSpec: a3.layer.type, style: t3.style, styleSpec: t3.styleSpec, validateSpec: t3.validateSpec, object: i3, objectKey: "type" }), filter: zi2, layout: (t4) => ki2({ layer: i3, key: t4.key, value: t4.value, style: t4.style, styleSpec: t4.styleSpec, validateSpec: t4.validateSpec, objectElementValidators: { "*": (t5) => Li2(Pt({ layerType: l3 }, t5)) } }), paint: (t4) => ki2({ layer: i3, key: t4.key, value: t4.value, style: t4.style, styleSpec: t4.styleSpec, validateSpec: t4.validateSpec, objectElementValidators: { "*": (t5) => Vi2(Pt({ layerType: l3 }, t5)) } }) } })), r3;
+      }
+      function $i2(t3) {
+        const e3 = t3.value, n3 = t3.key, r3 = Xr(e3);
+        return "string" !== r3 ? [new Dt(n3, e3, `string expected, ${r3} found`)] : [];
+      }
+      const Ri2 = { promoteId: function({ key: t3, value: e3 }) {
+        if ("string" === Xr(e3)) return $i2({ key: t3, value: e3 });
+        {
+          const n3 = [];
+          for (const r3 in e3) n3.push(...$i2({ key: `${t3}.${r3}`, value: e3[r3] }));
+          return n3;
+        }
+      } };
+      function Ni2(t3) {
+        const e3 = t3.value, n3 = t3.key, r3 = t3.styleSpec, i3 = t3.style, s3 = t3.validateSpec;
+        if (!e3.type) return [new Dt(n3, e3, '"type" is required')];
+        const o3 = Ai2(e3.type);
+        let a3;
+        switch (o3) {
+          case "vector":
+          case "raster":
+            return a3 = ki2({ key: n3, value: e3, valueSpec: r3[`source_${o3.replace("-", "_")}`], style: t3.style, styleSpec: r3, objectElementValidators: Ri2, validateSpec: s3 }), a3;
+          case "raster-dem":
+            return a3 = function(t4) {
+              var e4;
+              const n4 = null !== (e4 = t4.sourceName) && void 0 !== e4 ? e4 : "", r4 = t4.value, i4 = t4.styleSpec, s4 = i4.source_raster_dem, o4 = t4.style;
+              let a4 = [];
+              const l3 = Xr(r4);
+              if (void 0 === r4) return a4;
+              if ("object" !== l3) return a4.push(new Dt("source_raster_dem", r4, `object expected, ${l3} found`)), a4;
+              const u3 = "custom" === Ai2(r4.encoding), c3 = ["redFactor", "greenFactor", "blueFactor", "baseShift"], h3 = t4.value.encoding ? `"${t4.value.encoding}"` : "Default";
+              for (const e5 in r4) !u3 && c3.includes(e5) ? a4.push(new Dt(e5, r4[e5], `In "${n4}": "${e5}" is only valid when "encoding" is set to "custom". ${h3} encoding found`)) : s4[e5] ? a4 = a4.concat(t4.validateSpec({ key: e5, value: r4[e5], valueSpec: s4[e5], validateSpec: t4.validateSpec, style: o4, styleSpec: i4 })) : a4.push(new Dt(e5, r4[e5], `unknown property "${e5}"`));
+              return a4;
+            }({ sourceName: n3, value: e3, style: t3.style, styleSpec: r3, validateSpec: s3 }), a3;
+          case "geojson":
+            if (a3 = ki2({ key: n3, value: e3, valueSpec: r3.source_geojson, style: i3, styleSpec: r3, validateSpec: s3, objectElementValidators: Ri2 }), e3.cluster) for (const t4 in e3.clusterProperties) {
+              const [r4, i4] = e3.clusterProperties[t4], s4 = "string" == typeof r4 ? [r4, ["accumulated"], ["get", t4]] : r4;
+              a3.push(...Fi2({ key: `${n3}.${t4}.map`, value: i4, expressionContext: "cluster-map" })), a3.push(...Fi2({ key: `${n3}.${t4}.reduce`, value: s4, expressionContext: "cluster-reduce" }));
+            }
+            return a3;
+          case "video":
+            return ki2({ key: n3, value: e3, valueSpec: r3.source_video, style: i3, validateSpec: s3, styleSpec: r3 });
+          case "image":
+            return ki2({ key: n3, value: e3, valueSpec: r3.source_image, style: i3, validateSpec: s3, styleSpec: r3 });
+          case "canvas":
+            return [new Dt(n3, null, "Please use runtime APIs to add canvas sources, rather than including them in stylesheets.", "source.canvas")];
+          default:
+            return Pi2({ key: `${n3}.type`, value: e3.type, valueSpec: { values: ["vector", "raster", "raster-dem", "geojson", "video", "image"] } });
+        }
+      }
+      function Ui2(t3) {
+        const e3 = t3.value, n3 = t3.styleSpec, r3 = n3.light, i3 = t3.style;
+        let s3 = [];
+        const o3 = Xr(e3);
+        if (void 0 === e3) return s3;
+        if ("object" !== o3) return s3 = s3.concat([new Dt("light", e3, `object expected, ${o3} found`)]), s3;
+        for (const o4 in e3) {
+          const a3 = o4.match(/^(.*)-transition$/);
+          s3 = s3.concat(a3 && r3[a3[1]] && r3[a3[1]].transition ? t3.validateSpec({ key: o4, value: e3[o4], valueSpec: n3.transition, validateSpec: t3.validateSpec, style: i3, styleSpec: n3 }) : r3[o4] ? t3.validateSpec({ key: o4, value: e3[o4], valueSpec: r3[o4], validateSpec: t3.validateSpec, style: i3, styleSpec: n3 }) : [new Dt(o4, e3[o4], `unknown property "${o4}"`)]);
+        }
+        return s3;
+      }
+      function ji2(t3) {
+        const e3 = t3.value, n3 = t3.styleSpec, r3 = n3.sky, i3 = t3.style, s3 = Xr(e3);
+        if (void 0 === e3) return [];
+        if ("object" !== s3) return [new Dt("sky", e3, `object expected, ${s3} found`)];
+        let o3 = [];
+        for (const s4 in e3) o3 = o3.concat(r3[s4] ? t3.validateSpec({ key: s4, value: e3[s4], valueSpec: r3[s4], style: i3, styleSpec: n3 }) : [new Dt(s4, e3[s4], `unknown property "${s4}"`)]);
+        return o3;
+      }
+      function qi2(t3) {
+        const e3 = t3.value, n3 = t3.styleSpec, r3 = n3.terrain, i3 = t3.style;
+        let s3 = [];
+        const o3 = Xr(e3);
+        if (void 0 === e3) return s3;
+        if ("object" !== o3) return s3 = s3.concat([new Dt("terrain", e3, `object expected, ${o3} found`)]), s3;
+        for (const o4 in e3) s3 = s3.concat(r3[o4] ? t3.validateSpec({ key: o4, value: e3[o4], valueSpec: r3[o4], validateSpec: t3.validateSpec, style: i3, styleSpec: n3 }) : [new Dt(o4, e3[o4], `unknown property "${o4}"`)]);
+        return s3;
+      }
+      function Gi2(t3) {
+        let e3 = [];
+        const n3 = t3.value, r3 = t3.key;
+        if (Array.isArray(n3)) {
+          const i3 = [], s3 = [];
+          for (const o3 in n3) n3[o3].id && i3.includes(n3[o3].id) && e3.push(new Dt(r3, n3, `all the sprites' ids must be unique, but ${n3[o3].id} is duplicated`)), i3.push(n3[o3].id), n3[o3].url && s3.includes(n3[o3].url) && e3.push(new Dt(r3, n3, `all the sprites' URLs must be unique, but ${n3[o3].url} is duplicated`)), s3.push(n3[o3].url), e3 = e3.concat(ki2({ key: `${r3}[${o3}]`, value: n3[o3], valueSpec: { id: { type: "string", required: true }, url: { type: "string", required: true } }, validateSpec: t3.validateSpec }));
+          return e3;
+        }
+        return $i2({ key: r3, value: n3 });
+      }
+      function Xi2(t3) {
+        return Boolean(t3) && t3.constructor === Object;
+      }
+      function Yi2(t3) {
+        return Xi2(t3.value) ? [] : [new Dt(t3.key, t3.value, `object expected, ${Xr(t3.value)} found`)];
+      }
+      const Zi2 = { "*": () => [], array: Ii2, boolean: function(t3) {
+        const e3 = t3.value, n3 = t3.key, r3 = Xr(e3);
+        return "boolean" !== r3 ? [new Dt(n3, e3, `boolean expected, ${r3} found`)] : [];
+      }, number: Ei2, color: Di2, constants: Si2, enum: Pi2, filter: zi2, function: Ti2, layer: Oi2, object: ki2, source: Ni2, light: Ui2, sky: ji2, terrain: qi2, projection: function(t3) {
+        const e3 = t3.value, n3 = t3.styleSpec, r3 = n3.projection, i3 = t3.style, s3 = Xr(e3);
+        if (void 0 === e3) return [];
+        if ("object" !== s3) return [new Dt("projection", e3, `object expected, ${s3} found`)];
+        let o3 = [];
+        for (const s4 in e3) o3 = o3.concat(r3[s4] ? t3.validateSpec({ key: s4, value: e3[s4], valueSpec: r3[s4], style: i3, styleSpec: n3 }) : [new Dt(s4, e3[s4], `unknown property "${s4}"`)]);
+        return o3;
+      }, projectionDefinition: function(t3) {
+        const e3 = t3.key;
+        let n3 = t3.value;
+        n3 = n3 instanceof String ? n3.valueOf() : n3;
+        const r3 = Xr(n3);
+        return "array" !== r3 || function(t4) {
+          return Array.isArray(t4) && 3 === t4.length && "string" == typeof t4[0] && "string" == typeof t4[1] && "number" == typeof t4[2];
+        }(n3) || function(t4) {
+          return !!["interpolate", "step", "literal"].includes(t4[0]);
+        }(n3) ? ["array", "string"].includes(r3) ? [] : [new Dt(e3, n3, `projection expected, invalid type "${r3}" found`)] : [new Dt(e3, n3, `projection expected, invalid array ${JSON.stringify(n3)} found`)];
+      }, string: $i2, formatted: function(t3) {
+        return 0 === $i2(t3).length ? [] : Fi2(t3);
+      }, resolvedImage: function(t3) {
+        return 0 === $i2(t3).length ? [] : Fi2(t3);
+      }, padding: function(t3) {
+        const e3 = t3.key, n3 = t3.value;
+        if ("array" === Xr(n3)) {
+          if (n3.length < 1 || n3.length > 4) return [new Dt(e3, n3, `padding requires 1 to 4 values; ${n3.length} values found`)];
+          const r3 = { type: "number" };
+          let i3 = [];
+          for (let s3 = 0; s3 < n3.length; s3++) i3 = i3.concat(t3.validateSpec({ key: `${e3}[${s3}]`, value: n3[s3], validateSpec: t3.validateSpec, valueSpec: r3 }));
+          return i3;
+        }
+        return Ei2({ key: e3, value: n3, valueSpec: {} });
+      }, numberArray: function(t3) {
+        const e3 = t3.key, n3 = t3.value;
+        if ("array" === Xr(n3)) {
+          const r3 = { type: "number" };
+          if (n3.length < 1) return [new Dt(e3, n3, "array length at least 1 expected, length 0 found")];
+          let i3 = [];
+          for (let s3 = 0; s3 < n3.length; s3++) i3 = i3.concat(t3.validateSpec({ key: `${e3}[${s3}]`, value: n3[s3], validateSpec: t3.validateSpec, valueSpec: r3 }));
+          return i3;
+        }
+        return Ei2({ key: e3, value: n3, valueSpec: {} });
+      }, colorArray: function(t3) {
+        const e3 = t3.key, n3 = t3.value;
+        if ("array" === Xr(n3)) {
+          if (n3.length < 1) return [new Dt(e3, n3, "array length at least 1 expected, length 0 found")];
+          let t4 = [];
+          for (let r3 = 0; r3 < n3.length; r3++) t4 = t4.concat(Di2({ key: `${e3}[${r3}]`, value: n3[r3] }));
+          return t4;
+        }
+        return Di2({ key: e3, value: n3 });
+      }, variableAnchorOffsetCollection: function(t3) {
+        const e3 = t3.key, n3 = t3.value, r3 = Xr(n3), i3 = t3.styleSpec;
+        if ("array" !== r3 || n3.length < 1 || n3.length % 2 != 0) return [new Dt(e3, n3, "variableAnchorOffsetCollection requires a non-empty array of even length")];
+        let s3 = [];
+        for (let r4 = 0; r4 < n3.length; r4 += 2) s3 = s3.concat(Pi2({ key: `${e3}[${r4}]`, value: n3[r4], valueSpec: i3.layout_symbol["text-anchor"] })), s3 = s3.concat(Ii2({ key: `${e3}[${r4 + 1}]`, value: n3[r4 + 1], valueSpec: { length: 2, value: "number" }, validateSpec: t3.validateSpec, style: t3.style, styleSpec: i3 }));
+        return s3;
+      }, sprite: Gi2, state: Yi2, fontFaces: function(t3) {
+        const e3 = t3.key, n3 = t3.value, r3 = t3.validateSpec, i3 = t3.styleSpec, s3 = t3.style;
+        if (!Xi2(n3)) return [new Dt(e3, n3, `object expected, ${Xr(n3)} found`)];
+        const o3 = [];
+        for (const t4 in n3) {
+          const a3 = n3[t4], l3 = Xr(a3);
+          if ("string" === l3) o3.push(...$i2({ key: `${e3}.${t4}`, value: a3 }));
+          else if ("array" === l3) {
+            const n4 = { url: { type: "string", required: true }, "unicode-range": { type: "array", value: "string" } };
+            for (const [l4, u3] of a3.entries()) o3.push(...ki2({ key: `${e3}.${t4}[${l4}]`, value: u3, valueSpec: n4, styleSpec: i3, style: s3, validateSpec: r3 }));
+          } else o3.push(new Dt(`${e3}.${t4}`, a3, `string or array expected, ${l3} found`));
+        }
+        return o3;
+      } };
+      function Hi2(t3) {
+        const e3 = t3.value, n3 = t3.valueSpec, r3 = t3.styleSpec;
+        return t3.validateSpec = Hi2, n3.expression && Yr(Ai2(e3)) ? Ti2(t3) : n3.expression && ni2(Mi2(e3)) ? Fi2(t3) : n3.type && Zi2[n3.type] ? Zi2[n3.type](t3) : ki2(Pt({}, t3, { valueSpec: n3.type ? r3[n3.type] : n3 }));
+      }
+      function Wi2(t3) {
+        const e3 = t3.value, n3 = t3.key, r3 = $i2(t3);
+        return r3.length || (-1 === e3.indexOf("{fontstack}") && r3.push(new Dt(n3, e3, '"glyphs" url must include a "{fontstack}" token')), -1 === e3.indexOf("{range}") && r3.push(new Dt(n3, e3, '"glyphs" url must include a "{range}" token'))), r3;
+      }
+      function Ki2(t3, e3 = vt) {
+        let n3 = [];
+        return n3 = n3.concat(Hi2({ key: "", value: t3, valueSpec: e3.$root, styleSpec: e3, style: t3, validateSpec: Hi2, objectElementValidators: { glyphs: Wi2, "*": () => [] } })), t3.constants && (n3 = n3.concat(Si2({ key: "constants", value: t3.constants }))), Qi2(n3);
+      }
+      function Ji2(t3) {
+        return function(e3) {
+          return t3(Object.assign({}, e3, { validateSpec: Hi2 }));
+        };
+      }
+      function Qi2(t3) {
+        return [].concat(t3).sort((t4, e3) => t4.line - e3.line);
+      }
+      function ts(t3) {
+        return function(...e3) {
+          return Qi2(t3.apply(this, e3));
+        };
+      }
+      Ki2.source = ts(Ji2(Ni2)), Ki2.sprite = ts(Ji2(Gi2)), Ki2.glyphs = ts(Ji2(Wi2)), Ki2.light = ts(Ji2(Ui2)), Ki2.sky = ts(Ji2(ji2)), Ki2.terrain = ts(Ji2(qi2)), Ki2.state = ts(Ji2(Yi2)), Ki2.layer = ts(Ji2(Oi2)), Ki2.filter = ts(Ji2(zi2)), Ki2.paintProperty = ts(Ji2(Vi2)), Ki2.layoutProperty = ts(Ji2(Li2));
+      const es = { type: "enum", "property-type": "data-constant", expression: { interpolated: false, parameters: ["global-state"] }, values: { visible: {}, none: {} }, transition: false, default: "visible" };
+      class ns {
+        constructor(t3, e3) {
+          this._globalState = e3, this.setValue(t3);
+        }
+        evaluate() {
+          var t3;
+          return null !== (t3 = this._literalValue) && void 0 !== t3 ? t3 : this._compiledValue.evaluate({});
+        }
+        setValue(t3) {
+          if (null == t3 || "visible" === t3 || "none" === t3) return this._literalValue = "none" === t3 ? "none" : "visible", this._compiledValue = void 0, void (this._globalStateRefs = /* @__PURE__ */ new Set());
+          const e3 = ri2(t3, es, this._globalState);
+          if ("error" === e3.result) throw this._literalValue = "visible", this._compiledValue = void 0, new Error(e3.value.map((t4) => `${t4.key}: ${t4.message}`).join(", "));
+          this._literalValue = void 0, this._compiledValue = e3.value, this._globalStateRefs = ui2(e3.value.expression);
+        }
+        getGlobalStateRefs() {
+          return this._globalStateRefs;
+        }
+      }
+      const rs = vt, is = Ki2, ss = is.light, os = is.sky, as = is.paintProperty, ls = is.layoutProperty;
+      function us(t3, e3) {
+        let n3 = false;
+        if (e3 && e3.length) for (const r3 of e3) t3.fire(new gt2(new Error(r3.message))), n3 = true;
+        return n3;
+      }
+      class cs {
+        constructor(t3, e3, n3) {
+          const r3 = this.cells = [];
+          if (t3 instanceof ArrayBuffer) {
+            this.arrayBuffer = t3;
+            const i4 = new Int32Array(this.arrayBuffer);
+            t3 = i4[0], this.d = (e3 = i4[1]) + 2 * (n3 = i4[2]);
+            for (let t4 = 0; t4 < this.d * this.d; t4++) {
+              const e4 = i4[3 + t4], n4 = i4[3 + t4 + 1];
+              r3.push(e4 === n4 ? null : i4.subarray(e4, n4));
+            }
+            const s3 = i4[3 + r3.length + 1];
+            this.keys = i4.subarray(i4[3 + r3.length], s3), this.bboxes = i4.subarray(s3), this.insert = this._insertReadonly;
+          } else {
+            this.d = e3 + 2 * n3;
+            for (let t4 = 0; t4 < this.d * this.d; t4++) r3.push([]);
+            this.keys = [], this.bboxes = [];
+          }
+          this.n = e3, this.extent = t3, this.padding = n3, this.scale = e3 / t3, this.uid = 0;
+          const i3 = n3 / e3 * t3;
+          this.min = -i3, this.max = t3 + i3;
+        }
+        insert(t3, e3, n3, r3, i3) {
+          this._forEachCell(e3, n3, r3, i3, this._insertCell, this.uid++, void 0, void 0), this.keys.push(t3), this.bboxes.push(e3), this.bboxes.push(n3), this.bboxes.push(r3), this.bboxes.push(i3);
+        }
+        _insertReadonly() {
+          throw new Error("Cannot insert into a GridIndex created from an ArrayBuffer.");
+        }
+        _insertCell(t3, e3, n3, r3, i3, s3) {
+          this.cells[i3].push(s3);
+        }
+        query(t3, e3, n3, r3, i3) {
+          const s3 = this.min, o3 = this.max;
+          if (t3 <= s3 && e3 <= s3 && o3 <= n3 && o3 <= r3 && !i3) return [...this.keys];
+          {
+            const s4 = [];
+            return this._forEachCell(t3, e3, n3, r3, this._queryCell, s4, {}, i3), s4;
+          }
+        }
+        _queryCell(t3, e3, n3, r3, i3, s3, o3, a3) {
+          const l3 = this.cells[i3];
+          if (null !== l3) {
+            const i4 = this.keys, u3 = this.bboxes;
+            for (let c3 = 0; c3 < l3.length; c3++) {
+              const h3 = l3[c3];
+              if (void 0 === o3[h3]) {
+                const l4 = 4 * h3;
+                (a3 ? a3(u3[l4 + 0], u3[l4 + 1], u3[l4 + 2], u3[l4 + 3]) : t3 <= u3[l4 + 2] && e3 <= u3[l4 + 3] && n3 >= u3[l4 + 0] && r3 >= u3[l4 + 1]) ? (o3[h3] = true, s3.push(i4[h3])) : o3[h3] = false;
+              }
+            }
+          }
+        }
+        _forEachCell(t3, e3, n3, r3, i3, s3, o3, a3) {
+          const l3 = this._convertToCellCoord(t3), u3 = this._convertToCellCoord(e3), c3 = this._convertToCellCoord(n3), h3 = this._convertToCellCoord(r3);
+          for (let p3 = l3; p3 <= c3; p3++) for (let l4 = u3; l4 <= h3; l4++) {
+            const u4 = this.d * l4 + p3;
+            if ((!a3 || a3(this._convertFromCellCoord(p3), this._convertFromCellCoord(l4), this._convertFromCellCoord(p3 + 1), this._convertFromCellCoord(l4 + 1))) && i3.call(this, t3, e3, n3, r3, u4, s3, o3, a3)) return;
+          }
+        }
+        _convertFromCellCoord(t3) {
+          return (t3 - this.padding) / this.scale;
+        }
+        _convertToCellCoord(t3) {
+          return Math.max(0, Math.min(this.d - 1, Math.floor(t3 * this.scale) + this.padding));
+        }
+        toArrayBuffer() {
+          if (this.arrayBuffer) return this.arrayBuffer;
+          const t3 = this.cells, e3 = 3 + this.cells.length + 1 + 1;
+          let n3 = 0;
+          for (let t4 = 0; t4 < this.cells.length; t4++) n3 += this.cells[t4].length;
+          const r3 = new Int32Array(e3 + n3 + this.keys.length + this.bboxes.length);
+          r3[0] = this.extent, r3[1] = this.n, r3[2] = this.padding;
+          let i3 = e3;
+          for (let e4 = 0; e4 < t3.length; e4++) {
+            const n4 = t3[e4];
+            r3[3 + e4] = i3, r3.set(n4, i3), i3 += n4.length;
+          }
+          return r3[3 + t3.length] = i3, r3.set(this.keys, i3), i3 += this.keys.length, r3[3 + t3.length + 1] = i3, r3.set(this.bboxes, i3), i3 += this.bboxes.length, r3.buffer;
+        }
+        static serialize(t3, e3) {
+          const n3 = t3.toArrayBuffer();
+          return e3 && e3.push(n3), { buffer: n3 };
+        }
+        static deserialize(t3) {
+          return new cs(t3.buffer);
+        }
+      }
+      const hs = {};
+      function ps(t3, e3, n3 = {}) {
+        if (hs[t3]) throw new Error(`${t3} is already registered.`);
+        Object.defineProperty(e3, "_classRegistryKey", { value: t3, writeable: false }), hs[t3] = { klass: e3, omit: n3.omit || [], shallow: n3.shallow || [] };
+      }
+      ps("Object", Object), ps("Set", Set), ps("TransferableGridIndex", cs), ps("Color", Ie2), ps("Error", Error), ps("AJAXError", ct2), ps("ResolvedImage", Oe2), ps("StylePropertyFunction", ai2), ps("StyleExpression", ei2, { omit: ["_evaluator"] }), ps("ZoomDependentExpression", si2), ps("ZoomConstantExpression", ii2), ps("CompoundExpression", Pr, { omit: ["_evaluate"] });
+      for (const t3 in Dr) Dr[t3]._classRegistryKey || ps(`Expression_${t3}`, Dr[t3]);
+      function fs2(t3) {
+        return t3 && "undefined" != typeof ArrayBuffer && (t3 instanceof ArrayBuffer || t3.constructor && "ArrayBuffer" === t3.constructor.name);
+      }
+      function ds(t3) {
+        return t3.$name || t3.constructor._classRegistryKey;
+      }
+      function ys(t3) {
+        return !function(t4) {
+          if (null === t4 || "object" != typeof t4) return false;
+          const e3 = ds(t4);
+          return !(!e3 || "Object" === e3);
+        }(t3) && (null == t3 || "boolean" == typeof t3 || "number" == typeof t3 || "string" == typeof t3 || t3 instanceof Boolean || t3 instanceof Number || t3 instanceof String || t3 instanceof Date || t3 instanceof RegExp || t3 instanceof Blob || t3 instanceof Error || fs2(t3) || Z2(t3) || ArrayBuffer.isView(t3) || t3 instanceof ImageData);
+      }
+      function ms(t3, e3) {
+        if (ys(t3)) return (fs2(t3) || Z2(t3)) && e3 && e3.push(t3), ArrayBuffer.isView(t3) && e3 && e3.push(t3.buffer), t3 instanceof ImageData && e3 && e3.push(t3.data.buffer), t3;
+        if (Array.isArray(t3)) {
+          const n4 = [];
+          for (const r4 of t3) n4.push(ms(r4, e3));
+          return n4;
+        }
+        if ("object" != typeof t3) throw new Error("can't serialize object of type " + typeof t3);
+        const n3 = ds(t3);
+        if (!n3) throw new Error(`can't serialize object of unregistered class ${t3.constructor.name}`);
+        if (!hs[n3]) throw new Error(`${n3} is not registered.`);
+        const { klass: r3 } = hs[n3], i3 = r3.serialize ? r3.serialize(t3, e3) : {};
+        if (r3.serialize) {
+          if (e3 && i3 === e3[e3.length - 1]) throw new Error("statically serialized object won't survive transfer of $name property");
+        } else {
+          for (const r4 in t3) {
+            if (!t3.hasOwnProperty(r4)) continue;
+            if (hs[n3].omit.indexOf(r4) >= 0) continue;
+            const s3 = t3[r4];
+            i3[r4] = hs[n3].shallow.indexOf(r4) >= 0 ? s3 : ms(s3, e3);
+          }
+          t3 instanceof Error && (i3.message = t3.message);
+        }
+        if (i3.$name) throw new Error("$name property is reserved for worker serialization logic.");
+        return "Object" !== n3 && (i3.$name = n3), i3;
+      }
+      function gs(t3) {
+        if (ys(t3)) return t3;
+        if (Array.isArray(t3)) return t3.map(gs);
+        if ("object" != typeof t3) throw new Error("can't deserialize object of type " + typeof t3);
+        const e3 = ds(t3) || "Object";
+        if (!hs[e3]) throw new Error(`can't deserialize unregistered class ${e3}`);
+        const { klass: n3 } = hs[e3];
+        if (!n3) throw new Error(`can't deserialize unregistered class ${e3}`);
+        if (n3.deserialize) return n3.deserialize(t3);
+        const r3 = Object.create(n3.prototype);
+        for (const n4 of Object.keys(t3)) {
+          if ("$name" === n4) continue;
+          const i3 = t3[n4];
+          r3[n4] = hs[e3].shallow.indexOf(n4) >= 0 ? i3 : gs(i3);
+        }
+        return r3;
+      }
+      class xs {
+        constructor() {
+          this.first = true;
+        }
+        update(t3, e3) {
+          const n3 = Math.floor(t3);
+          return this.first ? (this.first = false, this.lastIntegerZoom = n3, this.lastIntegerZoomTime = 0, this.lastZoom = t3, this.lastFloorZoom = n3, true) : (this.lastFloorZoom > n3 ? (this.lastIntegerZoom = n3 + 1, this.lastIntegerZoomTime = e3) : this.lastFloorZoom < n3 && (this.lastIntegerZoom = n3, this.lastIntegerZoomTime = e3), t3 !== this.lastZoom && (this.lastZoom = t3, this.lastFloorZoom = n3, true));
+        }
+      }
+      function vs2(t3) {
+        return /[\u02EA\u02EB\u2E80-\u2FDF\u2FF0-\u303F\u3041-\u3096\u309D-\u309F\u30A1-\u30FA\u30FD-\u30FF\u3105-\u312F\u31A0-\u4DBF\u4E00-\uA48C\uA490-\uA4C6\uF900-\uFA6D\uFA70-\uFAD9\uFE10-\uFE1F\uFE30-\uFE4F\uFF00-\uFFEF]|\uD81B[\uDFE0-\uDFFF]|[\uD81C-\uD822\uD840-\uD868\uD86A-\uD86D\uD86F-\uD872\uD874-\uD879\uD880-\uD883\uD885-\uD88C][\uDC00-\uDFFF]|\uD823[\uDC00-\uDCD5\uDCFF-\uDD1E\uDD80-\uDDF2]|\uD82B[\uDFF0-\uDFFF]|\uD82C[\uDC00-\uDEFB]|\uD83C[\uDE00-\uDEFF]|\uD869[\uDC00-\uDEDF\uDF00-\uDFFF]|\uD86E[\uDC00-\uDC1D\uDC20-\uDFFF]|\uD873[\uDC00-\uDEAD\uDEB0-\uDFFF]|\uD87A[\uDC00-\uDFE0\uDFF0-\uDFFF]|\uD87B[\uDC00-\uDE5D]|\uD87E[\uDC00-\uDE1D]|\uD884[\uDC00-\uDF4A\uDF50-\uDFFF]|\uD88D[\uDC00-\uDC79]/gim.test(String.fromCodePoint(t3));
+      }
+      function bs(t3) {
+        return /[\u02EA\u02EB\u1100-\u11FF\u1400-\u167F\u18B0-\u18F5\u2E80-\u2E99\u2E9B-\u2EF3\u2F00-\u2FD5\u2FF0-\u3007\u3012\u3013\u3020-\u302F\u3031-\u303F\u3041-\u3096\u309D-\u30FB\u30FD-\u30FF\u3105-\u312F\u3131-\u318E\u3190-\uA48C\uA490-\uA4C6\uA960-\uA97C\uAC00-\uD7A3\uD7B0-\uD7C6\uD7CB-\uD7FB\uF900-\uFA6D\uFA70-\uFAD9\uFE10-\uFE1F\uFE30-\uFE48\uFE50-\uFE57\uFE5F-\uFE62\uFE67-\uFE6F\uFF00-\uFF07\uFF0A-\uFF0C\uFF0E-\uFF19\uFF1F-\uFF3A\uFF3C\uFF3E\uFF40-\uFF5A\uFFE0-\uFFE2\uFFE4-\uFFE7]|\uD802[\uDD80-\uDD9F]|\uD805[\uDD80-\uDDFF]|\uD806[\uDE00-\uDEBF]|\uD811[\uDC00-\uDE7F]|\uD81B[\uDFE0-\uDFE4\uDFF0-\uDFF6]|[\uD81C-\uD822\uD83D\uD840-\uD868\uD86A-\uD86D\uD86F-\uD872\uD874-\uD879\uD880-\uD883\uD885-\uD88C][\uDC00-\uDFFF]|\uD823[\uDC00-\uDCD5\uDCFF-\uDD1E\uDD80-\uDDF2]|\uD82B[\uDFF0-\uDFF3\uDFF5-\uDFFB\uDFFD\uDFFE]|\uD82C[\uDC00-\uDD22\uDD30-\uDEFB]|\uD833[\uDEC0-\uDFCF]|\uD834[\uDC00-\uDDFF\uDEE0-\uDF7F]|\uD836[\uDC00-\uDEAF]|\uD83C[\uDC00-\uDE00\uDF00-\uDFFF]|\uD83E[\uDD00-\uDEFF]|\uD869[\uDC00-\uDEDF\uDF00-\uDFFF]|\uD86E[\uDC00-\uDC1D\uDC20-\uDFFF]|\uD873[\uDC00-\uDEAD\uDEB0-\uDFFF]|\uD87A[\uDC00-\uDFE0\uDFF0-\uDFFF]|\uD87B[\uDC00-\uDE5D]|\uD87E[\uDC00-\uDE1D]|\uD884[\uDC00-\uDF4A\uDF50-\uDFFF]|\uD88D[\uDC00-\uDC79]/gim.test(String.fromCodePoint(t3));
+      }
+      function ws(t3) {
+        return /\s/u.test(String.fromCodePoint(t3));
+      }
+      function _s2(t3) {
+        for (const e3 of t3) if (bs(e3.codePointAt(0))) return true;
+        return false;
+      }
+      function Ss(t3) {
+        for (const e3 of t3) if (!ks(e3.codePointAt(0))) return false;
+        return true;
+      }
+      function As(t3) {
+        const e3 = t3.map((t4) => {
+          try {
+            return new RegExp(`\\p{sc=${t4}}`, "u").source;
+          } catch (t5) {
+            return null;
+          }
+        }).filter((t4) => t4);
+        return new RegExp(e3.join("|"), "u");
+      }
+      const Ms = As(["Arab", "Dupl", "Mong", "Ougr", "Syrc"]);
+      function ks(t3) {
+        return !Ms.test(String.fromCodePoint(t3));
+      }
+      function Is(t3) {
+        return !(bs(t3) || (e3 = t3, /[\xA7\xA9\xAE\xB1\xBC-\xBE\xD7\xF7\u2016\u2020\u2021\u2030\u2031\u203B\u203C\u2042\u2047-\u2049\u2051\u2100-\u218F\u221E\u2234\u2235\u2300-\u2307\u230C-\u231F\u2324-\u2328\u232B\u237D-\u239A\u23BE-\u23CD\u23CF\u23D1-\u23DB\u23E2-\u2422\u2424-\u24FF\u25A0-\u2619\u2620-\u2767\u2776-\u2793\u2B12-\u2B2F\u2B50-\u2B59\u2BB8-\u2BEB\u3000-\u303F\u30A0-\u30FF\uE000-\uF8FF\uFE30-\uFE6F\uFF00-\uFFEF\uFFFC\uFFFD]|[\uDB80-\uDBFF][\uDC00-\uDFFF]/gim.test(String.fromCodePoint(e3))));
+        var e3;
+      }
+      const Es = As(["Adlm", "Arab", "Armi", "Avst", "Chrs", "Cprt", "Egyp", "Elym", "Gara", "Hatr", "Hebr", "Hung", "Khar", "Lydi", "Mand", "Mani", "Mend", "Merc", "Mero", "Narb", "Nbat", "Nkoo", "Orkh", "Palm", "Phli", "Phlp", "Phnx", "Prti", "Rohg", "Samr", "Sarb", "Sogo", "Syrc", "Thaa", "Todr", "Yezi"]);
+      function Ts(t3) {
+        return Es.test(String.fromCodePoint(t3));
+      }
+      function Fs(t3, e3) {
+        return !(!e3 && Ts(t3) || /[\u0900-\u0DFF\u0F00-\u109F\u1780-\u17FF]/gim.test(String.fromCodePoint(t3)));
+      }
+      function Ds(t3) {
+        for (const e3 of t3) if (Ts(e3.codePointAt(0))) return true;
+        return false;
+      }
+      const Ps = new class {
+        constructor() {
+          this.TIMEOUT = 5e3, this.applyArabicShaping = null, this.processBidirectionalText = null, this.processStyledBidirectionalText = null, this.pluginStatus = "unavailable", this.pluginURL = null, this.loadScriptResolve = () => {
+          };
+        }
+        setState(t3) {
+          this.pluginStatus = t3.pluginStatus, this.pluginURL = t3.pluginURL;
+        }
+        getState() {
+          return { pluginStatus: this.pluginStatus, pluginURL: this.pluginURL };
+        }
+        setMethods(t3) {
+          if (Ps.isParsed()) throw new Error("RTL text plugin already registered.");
+          this.applyArabicShaping = t3.applyArabicShaping, this.processBidirectionalText = t3.processBidirectionalText, this.processStyledBidirectionalText = t3.processStyledBidirectionalText, this.loadScriptResolve();
+        }
+        isParsed() {
+          return null != this.applyArabicShaping && null != this.processBidirectionalText && null != this.processStyledBidirectionalText;
+        }
+        getRTLTextPluginStatus() {
+          return this.pluginStatus;
+        }
+        syncState(t3, n3) {
+          return e2(this, void 0, void 0, function* () {
+            if (this.isParsed()) return this.getState();
+            if ("loading" !== t3.pluginStatus) return this.setState(t3), t3;
+            const e3 = t3.pluginURL, r3 = new Promise((t4) => {
+              this.loadScriptResolve = t4;
+            });
+            n3(e3);
+            const i3 = new Promise((t4) => setTimeout(() => t4(), this.TIMEOUT));
+            if (yield Promise.race([r3, i3]), this.isParsed()) {
+              const t4 = { pluginStatus: "loaded", pluginURL: e3 };
+              return this.setState(t4), t4;
+            }
+            throw this.setState({ pluginStatus: "error", pluginURL: "" }), new Error(`RTL Text Plugin failed to import scripts from ${e3}`);
+          });
+        }
+      }();
+      class zs {
+        constructor(t3, e3) {
+          this.isSupportedScript = Bs, this.zoom = t3, e3 ? (this.now = e3.now || 0, this.fadeDuration = e3.fadeDuration || 0, this.zoomHistory = e3.zoomHistory || new xs(), this.transition = e3.transition || {}) : (this.now = 0, this.fadeDuration = 0, this.zoomHistory = new xs(), this.transition = {});
+        }
+        crossFadingFactor() {
+          return 0 === this.fadeDuration ? 1 : Math.min((this.now - this.zoomHistory.lastIntegerZoomTime) / this.fadeDuration, 1);
+        }
+        getCrossfadeParameters() {
+          const t3 = this.zoom, e3 = t3 - Math.floor(t3), n3 = this.crossFadingFactor();
+          return t3 > this.zoomHistory.lastIntegerZoom ? { fromScale: 2, toScale: 1, t: e3 + (1 - e3) * n3 } : { fromScale: 0.5, toScale: 1, t: 1 - (1 - n3) * e3 };
+        }
+      }
+      function Bs(t3) {
+        return function(t4, e3) {
+          for (const n3 of t4) if (!Fs(n3.codePointAt(0), e3)) return false;
+          return true;
+        }(t3, "loaded" === Ps.getRTLTextPluginStatus());
+      }
+      const Cs = "-transition";
+      class Vs {
+        constructor(t3, e3, n3) {
+          this.property = t3, this.value = e3, this.expression = function(t4, e4, n4) {
+            if (Yr(t4)) return new ai2(t4, e4);
+            if (ni2(t4)) {
+              const r3 = oi2(t4, e4, n4);
+              if ("error" === r3.result) throw new Error(r3.value.map((t5) => `${t5.key}: ${t5.message}`).join(", "));
+              return r3.value;
+            }
+            {
+              let n5 = t4;
+              return "color" === e4.type && "string" == typeof t4 ? n5 = Ie2.parse(t4) : "padding" !== e4.type || "number" != typeof t4 && !Array.isArray(t4) ? "numberArray" !== e4.type || "number" != typeof t4 && !Array.isArray(t4) ? "colorArray" !== e4.type || "string" != typeof t4 && !Array.isArray(t4) ? "variableAnchorOffsetCollection" === e4.type && Array.isArray(t4) ? n5 = Le2.parse(t4) : "projectionDefinition" === e4.type && "string" == typeof t4 && (n5 = $e2.parse(t4)) : n5 = Be2.parse(t4) : n5 = ze2.parse(t4) : n5 = Pe2.parse(t4), { globalStateRefs: /* @__PURE__ */ new Set(), _globalState: null, kind: "constant", evaluate: () => n5 };
+            }
+          }(void 0 === e3 ? t3.specification.default : e3, t3.specification, n3);
+        }
+        isDataDriven() {
+          return "source" === this.expression.kind || "composite" === this.expression.kind;
+        }
+        getGlobalStateRefs() {
+          return this.expression.globalStateRefs || /* @__PURE__ */ new Set();
+        }
+        possiblyEvaluate(t3, e3, n3) {
+          return this.property.possiblyEvaluate(this, t3, e3, n3);
+        }
+      }
+      class Ls {
+        constructor(t3, e3) {
+          this.property = t3, this.value = new Vs(t3, void 0, e3);
+        }
+        transitioned(t3, e3) {
+          return new $s(this.property, this.value, e3, O2({}, t3.transition, this.transition), t3.now);
+        }
+        untransitioned() {
+          return new $s(this.property, this.value, null, {}, 0);
+        }
+      }
+      class Os {
+        constructor(t3, e3) {
+          this._properties = t3, this._values = Object.create(t3.defaultTransitionablePropertyValues), this._globalState = e3;
+        }
+        getValue(t3) {
+          return U2(this._values[t3].value.value);
+        }
+        setValue(t3, e3) {
+          Object.prototype.hasOwnProperty.call(this._values, t3) || (this._values[t3] = new Ls(this._values[t3].property, this._globalState)), this._values[t3].value = new Vs(this._values[t3].property, null === e3 ? void 0 : U2(e3), this._globalState);
+        }
+        getTransition(t3) {
+          return U2(this._values[t3].transition);
+        }
+        setTransition(t3, e3) {
+          Object.prototype.hasOwnProperty.call(this._values, t3) || (this._values[t3] = new Ls(this._values[t3].property, this._globalState)), this._values[t3].transition = U2(e3) || void 0;
+        }
+        serialize() {
+          const t3 = {};
+          for (const e3 of Object.keys(this._values)) {
+            const n3 = this.getValue(e3);
+            void 0 !== n3 && (t3[e3] = n3);
+            const r3 = this.getTransition(e3);
+            void 0 !== r3 && (t3[`${e3}${Cs}`] = r3);
+          }
+          return t3;
+        }
+        transitioned(t3, e3) {
+          const n3 = new Rs(this._properties);
+          for (const r3 of Object.keys(this._values)) n3._values[r3] = this._values[r3].transitioned(t3, e3._values[r3]);
+          return n3;
+        }
+        untransitioned() {
+          const t3 = new Rs(this._properties);
+          for (const e3 of Object.keys(this._values)) t3._values[e3] = this._values[e3].untransitioned();
+          return t3;
+        }
+      }
+      class $s {
+        constructor(t3, e3, n3, r3, i3) {
+          this.property = t3, this.value = e3, this.begin = i3 + r3.delay || 0, this.end = this.begin + r3.duration || 0, t3.specification.transition && (r3.delay || r3.duration) && (this.prior = n3);
+        }
+        possiblyEvaluate(t3, e3, n3) {
+          const r3 = t3.now || 0, i3 = this.value.possiblyEvaluate(t3, e3, n3), s3 = this.prior;
+          if (s3) {
+            if (r3 > this.end) return this.prior = null, i3;
+            if (this.value.isDataDriven()) return this.prior = null, i3;
+            if (r3 < this.begin) return s3.possiblyEvaluate(t3, e3, n3);
+            {
+              const o3 = (r3 - this.begin) / (this.end - this.begin);
+              return this.property.interpolate(s3.possiblyEvaluate(t3, e3, n3), i3, z2(o3));
+            }
+          }
+          return i3;
+        }
+      }
+      class Rs {
+        constructor(t3) {
+          this._properties = t3, this._values = Object.create(t3.defaultTransitioningPropertyValues);
+        }
+        possiblyEvaluate(t3, e3, n3) {
+          const r3 = new js(this._properties);
+          for (const i3 of Object.keys(this._values)) r3._values[i3] = this._values[i3].possiblyEvaluate(t3, e3, n3);
+          return r3;
+        }
+        hasTransition() {
+          for (const t3 of Object.keys(this._values)) if (this._values[t3].prior) return true;
+          return false;
+        }
+      }
+      class Ns {
+        constructor(t3, e3) {
+          this._properties = t3, this._values = Object.create(t3.defaultPropertyValues), this._globalState = e3;
+        }
+        hasValue(t3) {
+          return void 0 !== this._values[t3].value;
+        }
+        getValue(t3) {
+          return U2(this._values[t3].value);
+        }
+        setValue(t3, e3) {
+          this._values[t3] = new Vs(this._values[t3].property, null === e3 ? void 0 : U2(e3), this._globalState);
+        }
+        serialize() {
+          const t3 = {};
+          for (const e3 of Object.keys(this._values)) {
+            const n3 = this.getValue(e3);
+            void 0 !== n3 && (t3[e3] = n3);
+          }
+          return t3;
+        }
+        possiblyEvaluate(t3, e3, n3) {
+          const r3 = new js(this._properties);
+          for (const i3 of Object.keys(this._values)) r3._values[i3] = this._values[i3].possiblyEvaluate(t3, e3, n3);
+          return r3;
+        }
+      }
+      class Us {
+        constructor(t3, e3, n3) {
+          this.property = t3, this.value = e3, this.parameters = n3;
+        }
+        isConstant() {
+          return "constant" === this.value.kind;
+        }
+        constantOr(t3) {
+          return "constant" === this.value.kind ? this.value.value : t3;
+        }
+        evaluate(t3, e3, n3, r3) {
+          return this.property.evaluate(this.value, this.parameters, t3, e3, n3, r3);
+        }
+      }
+      class js {
+        constructor(t3) {
+          this._properties = t3, this._values = Object.create(t3.defaultPossiblyEvaluatedValues);
+        }
+        get(t3) {
+          return this._values[t3];
+        }
+      }
+      class qs {
+        constructor(t3) {
+          this.specification = t3;
+        }
+        possiblyEvaluate(t3, e3) {
+          if (t3.isDataDriven()) throw new Error("Value should not be data driven");
+          return t3.expression.evaluate(e3);
+        }
+        interpolate(t3, e3, n3) {
+          const r3 = mn[this.specification.type];
+          return r3 ? r3(t3, e3, n3) : t3;
+        }
+      }
+      class Gs {
+        constructor(t3, e3) {
+          this.specification = t3, this.overrides = e3;
+        }
+        possiblyEvaluate(t3, e3, n3, r3) {
+          return new Us(this, "constant" === t3.expression.kind || "camera" === t3.expression.kind ? { kind: "constant", value: t3.expression.evaluate(e3, null, {}, n3, r3) } : t3.expression, e3);
+        }
+        interpolate(t3, e3, n3) {
+          if ("constant" !== t3.value.kind || "constant" !== e3.value.kind) return t3;
+          if (void 0 === t3.value.value || void 0 === e3.value.value) return new Us(this, { kind: "constant", value: void 0 }, t3.parameters);
+          const r3 = mn[this.specification.type];
+          if (r3) {
+            const i3 = r3(t3.value.value, e3.value.value, n3);
+            return new Us(this, { kind: "constant", value: i3 }, t3.parameters);
+          }
+          return t3;
+        }
+        evaluate(t3, e3, n3, r3, i3, s3) {
+          return "constant" === t3.kind ? t3.value : t3.evaluate(e3, n3, r3, i3, s3);
+        }
+      }
+      class Xs extends Gs {
+        possiblyEvaluate(t3, e3, n3, r3) {
+          if (void 0 === t3.value) return new Us(this, { kind: "constant", value: void 0 }, e3);
+          if ("constant" === t3.expression.kind) {
+            const i3 = t3.expression.evaluate(e3, null, {}, n3, r3), s3 = "resolvedImage" === t3.property.specification.type && "string" != typeof i3 ? i3.name : i3, o3 = this._calculate(s3, s3, s3, e3);
+            return new Us(this, { kind: "constant", value: o3 }, e3);
+          }
+          if ("camera" === t3.expression.kind) {
+            const n4 = this._calculate(t3.expression.evaluate({ zoom: e3.zoom - 1 }), t3.expression.evaluate({ zoom: e3.zoom }), t3.expression.evaluate({ zoom: e3.zoom + 1 }), e3);
+            return new Us(this, { kind: "constant", value: n4 }, e3);
+          }
+          return new Us(this, t3.expression, e3);
+        }
+        evaluate(t3, e3, n3, r3, i3, s3) {
+          if ("source" === t3.kind) {
+            const o3 = t3.evaluate(e3, n3, r3, i3, s3);
+            return this._calculate(o3, o3, o3, e3);
+          }
+          return "composite" === t3.kind ? this._calculate(t3.evaluate({ zoom: Math.floor(e3.zoom) - 1 }, n3, r3), t3.evaluate({ zoom: Math.floor(e3.zoom) }, n3, r3), t3.evaluate({ zoom: Math.floor(e3.zoom) + 1 }, n3, r3), e3) : t3.value;
+        }
+        _calculate(t3, e3, n3, r3) {
+          return r3.zoom > r3.zoomHistory.lastIntegerZoom ? { from: t3, to: e3 } : { from: n3, to: e3 };
+        }
+        interpolate(t3) {
+          return t3;
+        }
+      }
+      class Ys {
+        constructor(t3) {
+          this.specification = t3;
+        }
+        possiblyEvaluate(t3, e3, n3, r3) {
+          if (void 0 !== t3.value) {
+            if ("constant" === t3.expression.kind) {
+              const i3 = t3.expression.evaluate(e3, null, {}, n3, r3);
+              return this._calculate(i3, i3, i3, e3);
+            }
+            return this._calculate(t3.expression.evaluate(new zs(Math.floor(e3.zoom - 1), e3)), t3.expression.evaluate(new zs(Math.floor(e3.zoom), e3)), t3.expression.evaluate(new zs(Math.floor(e3.zoom + 1), e3)), e3);
+          }
+        }
+        _calculate(t3, e3, n3, r3) {
+          return r3.zoom > r3.zoomHistory.lastIntegerZoom ? { from: t3, to: e3 } : { from: n3, to: e3 };
+        }
+        interpolate(t3) {
+          return t3;
+        }
+      }
+      class Zs {
+        constructor(t3) {
+          this.specification = t3;
+        }
+        possiblyEvaluate(t3, e3, n3, r3) {
+          return !!t3.expression.evaluate(e3, null, {}, n3, r3);
+        }
+        interpolate() {
+          return false;
+        }
+      }
+      class Hs {
+        constructor(t3) {
+          this.properties = t3, this.defaultPropertyValues = {}, this.defaultTransitionablePropertyValues = {}, this.defaultTransitioningPropertyValues = {}, this.defaultPossiblyEvaluatedValues = {}, this.overridableProperties = [];
+          for (const e3 in t3) {
+            const n3 = t3[e3];
+            n3.specification.overridable && this.overridableProperties.push(e3);
+            const r3 = this.defaultPropertyValues[e3] = new Vs(n3, void 0, void 0), i3 = this.defaultTransitionablePropertyValues[e3] = new Ls(n3, void 0);
+            this.defaultTransitioningPropertyValues[e3] = i3.untransitioned(), this.defaultPossiblyEvaluatedValues[e3] = r3.possiblyEvaluate({});
+          }
+        }
+      }
+      ps("DataDrivenProperty", Gs), ps("DataConstantProperty", qs), ps("CrossFadedDataDrivenProperty", Xs), ps("CrossFadedProperty", Ys), ps("ColorRampProperty", Zs);
+      class Ws extends xt {
+        constructor(t3, e3, n3) {
+          if (super(), this.id = t3.id, this.type = t3.type, this._globalState = n3, this._featureFilter = { filter: () => true, needGeometry: false, getGlobalStateRefs: () => /* @__PURE__ */ new Set() }, this._visibilityExpression = function(t4, e4) {
+            return new ns(t4, e4);
+          }(this.visibility, n3), "custom" !== t3.type && (this.metadata = t3.metadata, this.minzoom = t3.minzoom, this.maxzoom = t3.maxzoom, "background" !== t3.type && (this.source = t3.source, this.sourceLayer = t3["source-layer"], this.filter = t3.filter, this._featureFilter = fi2(t3.filter, n3)), e3.layout && (this._unevaluatedLayout = new Ns(e3.layout, n3)), e3.paint)) {
+            this._transitionablePaint = new Os(e3.paint, n3);
+            for (const e4 in t3.paint) this.setPaintProperty(e4, t3.paint[e4], { validate: false });
+            for (const e4 in t3.layout) this.setLayoutProperty(e4, t3.layout[e4], { validate: false });
+            this._transitioningPaint = this._transitionablePaint.untransitioned(), this.paint = new js(e3.paint);
+          }
+        }
+        setFilter(t3) {
+          this.filter = t3, this._featureFilter = fi2(t3, this._globalState);
+        }
+        getCrossfadeParameters() {
+          return this._crossfadeParameters;
+        }
+        getLayoutProperty(t3) {
+          return "visibility" === t3 ? this.visibility : this._unevaluatedLayout.getValue(t3);
+        }
+        getLayoutAffectingGlobalStateRefs() {
+          const t3 = /* @__PURE__ */ new Set();
+          for (const e3 of this._visibilityExpression.getGlobalStateRefs()) t3.add(e3);
+          if (this._unevaluatedLayout) for (const e3 in this._unevaluatedLayout._values) {
+            const n3 = this._unevaluatedLayout._values[e3];
+            for (const e4 of n3.getGlobalStateRefs()) t3.add(e4);
+          }
+          for (const e3 of this._featureFilter.getGlobalStateRefs()) t3.add(e3);
+          return t3;
+        }
+        getPaintAffectingGlobalStateRefs() {
+          var t3;
+          const e3 = new globalThis.Map();
+          if (this._transitionablePaint) for (const n3 in this._transitionablePaint._values) {
+            const r3 = this._transitionablePaint._values[n3].value;
+            for (const i3 of r3.getGlobalStateRefs()) {
+              const s3 = null !== (t3 = e3.get(i3)) && void 0 !== t3 ? t3 : [];
+              s3.push({ name: n3, value: r3.value }), e3.set(i3, s3);
+            }
+          }
+          return e3;
+        }
+        getVisibilityAffectingGlobalStateRefs() {
+          return this._visibilityExpression.getGlobalStateRefs();
+        }
+        setLayoutProperty(t3, e3, n3 = {}) {
+          if (null == e3 || !this._validate(ls, `layers.${this.id}.layout.${t3}`, t3, e3, n3)) return "visibility" === t3 ? (this.visibility = e3, this._visibilityExpression.setValue(e3), void this.recalculateVisibility()) : void this._unevaluatedLayout.setValue(t3, e3);
+        }
+        getPaintProperty(t3) {
+          return t3.endsWith(Cs) ? this._transitionablePaint.getTransition(t3.slice(0, -11)) : this._transitionablePaint.getValue(t3);
+        }
+        setPaintProperty(t3, e3, n3 = {}) {
+          if (null != e3 && this._validate(as, `layers.${this.id}.paint.${t3}`, t3, e3, n3)) return false;
+          if (t3.endsWith(Cs)) return this._transitionablePaint.setTransition(t3.slice(0, -11), e3 || void 0), false;
+          {
+            const n4 = this._transitionablePaint._values[t3], r3 = "cross-faded-data-driven" === n4.property.specification["property-type"], i3 = n4.value.isDataDriven(), s3 = n4.value;
+            this._transitionablePaint.setValue(t3, e3), this._handleSpecialPaintPropertyUpdate(t3);
+            const o3 = this._transitionablePaint._values[t3].value;
+            return o3.isDataDriven() || i3 || r3 || this._handleOverridablePaintPropertyUpdate(t3, s3, o3);
+          }
+        }
+        _handleSpecialPaintPropertyUpdate(t3) {
+        }
+        _handleOverridablePaintPropertyUpdate(t3, e3, n3) {
+          return false;
+        }
+        isHidden(t3 = this.minzoom, e3 = false) {
+          return !!(this.minzoom && t3 < (e3 ? Math.floor(this.minzoom) : this.minzoom)) || !!(this.maxzoom && t3 >= this.maxzoom) || "none" === this._evaluatedVisibility;
+        }
+        updateTransitions(t3) {
+          this._transitioningPaint = this._transitionablePaint.transitioned(t3, this._transitioningPaint);
+        }
+        hasTransition() {
+          return this._transitioningPaint.hasTransition();
+        }
+        recalculateVisibility() {
+          this._evaluatedVisibility = this._visibilityExpression.evaluate();
+        }
+        recalculate(t3, e3) {
+          t3.getCrossfadeParameters && (this._crossfadeParameters = t3.getCrossfadeParameters()), this._unevaluatedLayout && (this.layout = this._unevaluatedLayout.possiblyEvaluate(t3, void 0, e3)), this.paint = this._transitioningPaint.possiblyEvaluate(t3, void 0, e3);
+        }
+        serialize() {
+          const t3 = { id: this.id, type: this.type, source: this.source, "source-layer": this.sourceLayer, metadata: this.metadata, minzoom: this.minzoom, maxzoom: this.maxzoom, filter: this.filter, layout: this._unevaluatedLayout && this._unevaluatedLayout.serialize(), paint: this._transitionablePaint && this._transitionablePaint.serialize() };
+          return this.visibility && (t3.layout = t3.layout || {}, t3.layout.visibility = this.visibility), N2(t3, (t4, e3) => !(void 0 === t4 || "layout" === e3 && !Object.keys(t4).length || "paint" === e3 && !Object.keys(t4).length));
+        }
+        _validate(t3, e3, n3, r3, i3 = {}) {
+          return (!i3 || false !== i3.validate) && us(this, t3.call(is, { key: e3, layerType: this.type, objectKey: n3, value: r3, styleSpec: vt, style: { glyphs: true, sprite: true } }));
+        }
+        is3D() {
+          return false;
+        }
+        isTileClipped() {
+          return false;
+        }
+        hasOffscreenPass() {
+          return false;
+        }
+        resize() {
+        }
+        isStateDependent() {
+          for (const t3 in this.paint._values) {
+            const e3 = this.paint.get(t3);
+            if (e3 instanceof Us && jr(e3.property.specification) && ("source" === e3.value.kind || "composite" === e3.value.kind) && e3.value.isStateDependent) return true;
+          }
+          return false;
+        }
+      }
+      let Ks;
+      var Js = { get paint() {
+        return Ks = Ks || new Hs({ "raster-opacity": new qs(vt.paint_raster["raster-opacity"]), "raster-hue-rotate": new qs(vt.paint_raster["raster-hue-rotate"]), "raster-brightness-min": new qs(vt.paint_raster["raster-brightness-min"]), "raster-brightness-max": new qs(vt.paint_raster["raster-brightness-max"]), "raster-saturation": new qs(vt.paint_raster["raster-saturation"]), "raster-contrast": new qs(vt.paint_raster["raster-contrast"]), resampling: new qs(vt.paint_raster.resampling), "raster-resampling": new qs(vt.paint_raster["raster-resampling"]), "raster-fade-duration": new qs(vt.paint_raster["raster-fade-duration"]) });
+      } };
+      class Qs extends Ws {
+        constructor(t3, e3) {
+          super(t3, Js, e3);
+        }
+      }
+      const to = { Int8: Int8Array, Uint8: Uint8Array, Int16: Int16Array, Uint16: Uint16Array, Int32: Int32Array, Uint32: Uint32Array, Float32: Float32Array };
+      class eo {
+        constructor(t3, e3) {
+          this._structArray = t3, this._pos1 = e3 * this.size, this._pos2 = this._pos1 / 2, this._pos4 = this._pos1 / 4, this._pos8 = this._pos1 / 8;
+        }
+      }
+      class no {
+        constructor() {
+          this.isTransferred = false, this.capacity = -1, this.resize(0);
+        }
+        static serialize(t3, e3) {
+          return t3._trim(), e3 && (t3.isTransferred = true, e3.push(t3.arrayBuffer)), { length: t3.length, arrayBuffer: t3.arrayBuffer };
+        }
+        static deserialize(t3) {
+          const e3 = Object.create(this.prototype);
+          return e3.arrayBuffer = t3.arrayBuffer, e3.length = t3.length, e3.capacity = t3.arrayBuffer.byteLength / e3.bytesPerElement, e3._refreshViews(), e3;
+        }
+        _trim() {
+          this.length !== this.capacity && (this.capacity = this.length, this.arrayBuffer = this.arrayBuffer.slice(0, this.length * this.bytesPerElement), this._refreshViews());
+        }
+        clear() {
+          this.length = 0;
+        }
+        resize(t3) {
+          this.reserve(t3), this.length = t3;
+        }
+        reserve(t3) {
+          if (t3 > this.capacity) {
+            this.capacity = Math.max(t3, Math.floor(5 * this.capacity), 128), this.arrayBuffer = new ArrayBuffer(this.capacity * this.bytesPerElement);
+            const e3 = this.uint8;
+            this._refreshViews(), e3 && this.uint8.set(e3);
+          }
+        }
+        _refreshViews() {
+          throw new Error("_refreshViews() must be implemented by each concrete StructArray layout");
+        }
+        freeBufferAfterUpload() {
+          this.arrayBuffer = new ArrayBuffer(0), this._refreshViews();
+        }
+      }
+      function ro(t3, e3 = 1) {
+        let n3 = 0, r3 = 0;
+        return { members: t3.map((t4) => {
+          const i3 = to[t4.type].BYTES_PER_ELEMENT, s3 = n3 = io(n3, Math.max(e3, i3)), o3 = t4.components || 1;
+          return r3 = Math.max(r3, i3), n3 += i3 * o3, { name: t4.name, type: t4.type, components: o3, offset: s3 };
+        }), size: io(n3, Math.max(r3, e3)), alignment: e3 };
+      }
+      function io(t3, e3) {
+        return Math.ceil(t3 / e3) * e3;
+      }
+      class so extends no {
+        _refreshViews() {
+          this.uint8 = new Uint8Array(this.arrayBuffer), this.int16 = new Int16Array(this.arrayBuffer);
+        }
+        emplaceBack(t3, e3) {
+          const n3 = this.length;
+          return this.resize(n3 + 1), this.emplace(n3, t3, e3);
+        }
+        emplace(t3, e3, n3) {
+          const r3 = 2 * t3;
+          return this.int16[r3 + 0] = e3, this.int16[r3 + 1] = n3, t3;
+        }
+      }
+      so.prototype.bytesPerElement = 4, ps("StructArrayLayout2i4", so);
+      class oo extends no {
+        _refreshViews() {
+          this.uint8 = new Uint8Array(this.arrayBuffer), this.int16 = new Int16Array(this.arrayBuffer);
+        }
+        emplaceBack(t3, e3, n3) {
+          const r3 = this.length;
+          return this.resize(r3 + 1), this.emplace(r3, t3, e3, n3);
+        }
+        emplace(t3, e3, n3, r3) {
+          const i3 = 3 * t3;
+          return this.int16[i3 + 0] = e3, this.int16[i3 + 1] = n3, this.int16[i3 + 2] = r3, t3;
+        }
+      }
+      oo.prototype.bytesPerElement = 6, ps("StructArrayLayout3i6", oo);
+      class ao extends no {
+        _refreshViews() {
+          this.uint8 = new Uint8Array(this.arrayBuffer), this.int16 = new Int16Array(this.arrayBuffer);
+        }
+        emplaceBack(t3, e3, n3, r3) {
+          const i3 = this.length;
+          return this.resize(i3 + 1), this.emplace(i3, t3, e3, n3, r3);
+        }
+        emplace(t3, e3, n3, r3, i3) {
+          const s3 = 4 * t3;
+          return this.int16[s3 + 0] = e3, this.int16[s3 + 1] = n3, this.int16[s3 + 2] = r3, this.int16[s3 + 3] = i3, t3;
+        }
+      }
+      ao.prototype.bytesPerElement = 8, ps("StructArrayLayout4i8", ao);
+      class lo extends no {
+        _refreshViews() {
+          this.uint8 = new Uint8Array(this.arrayBuffer), this.int16 = new Int16Array(this.arrayBuffer);
+        }
+        emplaceBack(t3, e3, n3, r3, i3, s3) {
+          const o3 = this.length;
+          return this.resize(o3 + 1), this.emplace(o3, t3, e3, n3, r3, i3, s3);
+        }
+        emplace(t3, e3, n3, r3, i3, s3, o3) {
+          const a3 = 6 * t3;
+          return this.int16[a3 + 0] = e3, this.int16[a3 + 1] = n3, this.int16[a3 + 2] = r3, this.int16[a3 + 3] = i3, this.int16[a3 + 4] = s3, this.int16[a3 + 5] = o3, t3;
+        }
+      }
+      lo.prototype.bytesPerElement = 12, ps("StructArrayLayout2i4i12", lo);
+      class uo extends no {
+        _refreshViews() {
+          this.uint8 = new Uint8Array(this.arrayBuffer), this.int16 = new Int16Array(this.arrayBuffer);
+        }
+        emplaceBack(t3, e3, n3, r3, i3, s3) {
+          const o3 = this.length;
+          return this.resize(o3 + 1), this.emplace(o3, t3, e3, n3, r3, i3, s3);
+        }
+        emplace(t3, e3, n3, r3, i3, s3, o3) {
+          const a3 = 4 * t3, l3 = 8 * t3;
+          return this.int16[a3 + 0] = e3, this.int16[a3 + 1] = n3, this.uint8[l3 + 4] = r3, this.uint8[l3 + 5] = i3, this.uint8[l3 + 6] = s3, this.uint8[l3 + 7] = o3, t3;
+        }
+      }
+      uo.prototype.bytesPerElement = 8, ps("StructArrayLayout2i4ub8", uo);
+      class co extends no {
+        _refreshViews() {
+          this.uint8 = new Uint8Array(this.arrayBuffer), this.float32 = new Float32Array(this.arrayBuffer);
+        }
+        emplaceBack(t3, e3) {
+          const n3 = this.length;
+          return this.resize(n3 + 1), this.emplace(n3, t3, e3);
+        }
+        emplace(t3, e3, n3) {
+          const r3 = 2 * t3;
+          return this.float32[r3 + 0] = e3, this.float32[r3 + 1] = n3, t3;
+        }
+      }
+      co.prototype.bytesPerElement = 8, ps("StructArrayLayout2f8", co);
+      class ho extends no {
+        _refreshViews() {
+          this.uint8 = new Uint8Array(this.arrayBuffer), this.uint16 = new Uint16Array(this.arrayBuffer);
+        }
+        emplaceBack(t3, e3, n3, r3, i3, s3, o3, a3, l3, u3) {
+          const c3 = this.length;
+          return this.resize(c3 + 1), this.emplace(c3, t3, e3, n3, r3, i3, s3, o3, a3, l3, u3);
+        }
+        emplace(t3, e3, n3, r3, i3, s3, o3, a3, l3, u3, c3) {
+          const h3 = 10 * t3;
+          return this.uint16[h3 + 0] = e3, this.uint16[h3 + 1] = n3, this.uint16[h3 + 2] = r3, this.uint16[h3 + 3] = i3, this.uint16[h3 + 4] = s3, this.uint16[h3 + 5] = o3, this.uint16[h3 + 6] = a3, this.uint16[h3 + 7] = l3, this.uint16[h3 + 8] = u3, this.uint16[h3 + 9] = c3, t3;
+        }
+      }
+      ho.prototype.bytesPerElement = 20, ps("StructArrayLayout10ui20", ho);
+      class po extends no {
+        _refreshViews() {
+          this.uint8 = new Uint8Array(this.arrayBuffer), this.uint16 = new Uint16Array(this.arrayBuffer);
+        }
+        emplaceBack(t3, e3, n3, r3, i3, s3, o3, a3) {
+          const l3 = this.length;
+          return this.resize(l3 + 1), this.emplace(l3, t3, e3, n3, r3, i3, s3, o3, a3);
+        }
+        emplace(t3, e3, n3, r3, i3, s3, o3, a3, l3) {
+          const u3 = 8 * t3;
+          return this.uint16[u3 + 0] = e3, this.uint16[u3 + 1] = n3, this.uint16[u3 + 2] = r3, this.uint16[u3 + 3] = i3, this.uint16[u3 + 4] = s3, this.uint16[u3 + 5] = o3, this.uint16[u3 + 6] = a3, this.uint16[u3 + 7] = l3, t3;
+        }
+      }
+      po.prototype.bytesPerElement = 16, ps("StructArrayLayout8ui16", po);
+      class fo extends no {
+        _refreshViews() {
+          this.uint8 = new Uint8Array(this.arrayBuffer), this.int16 = new Int16Array(this.arrayBuffer), this.uint16 = new Uint16Array(this.arrayBuffer);
+        }
+        emplaceBack(t3, e3, n3, r3, i3, s3, o3, a3, l3, u3, c3, h3) {
+          const p3 = this.length;
+          return this.resize(p3 + 1), this.emplace(p3, t3, e3, n3, r3, i3, s3, o3, a3, l3, u3, c3, h3);
+        }
+        emplace(t3, e3, n3, r3, i3, s3, o3, a3, l3, u3, c3, h3, p3) {
+          const f3 = 12 * t3;
+          return this.int16[f3 + 0] = e3, this.int16[f3 + 1] = n3, this.int16[f3 + 2] = r3, this.int16[f3 + 3] = i3, this.uint16[f3 + 4] = s3, this.uint16[f3 + 5] = o3, this.uint16[f3 + 6] = a3, this.uint16[f3 + 7] = l3, this.int16[f3 + 8] = u3, this.int16[f3 + 9] = c3, this.int16[f3 + 10] = h3, this.int16[f3 + 11] = p3, t3;
+        }
+      }
+      fo.prototype.bytesPerElement = 24, ps("StructArrayLayout4i4ui4i24", fo);
+      class yo extends no {
+        _refreshViews() {
+          this.uint8 = new Uint8Array(this.arrayBuffer), this.float32 = new Float32Array(this.arrayBuffer);
+        }
+        emplaceBack(t3, e3, n3) {
+          const r3 = this.length;
+          return this.resize(r3 + 1), this.emplace(r3, t3, e3, n3);
+        }
+        emplace(t3, e3, n3, r3) {
+          const i3 = 3 * t3;
+          return this.float32[i3 + 0] = e3, this.float32[i3 + 1] = n3, this.float32[i3 + 2] = r3, t3;
+        }
+      }
+      yo.prototype.bytesPerElement = 12, ps("StructArrayLayout3f12", yo);
+      class mo extends no {
+        _refreshViews() {
+          this.uint8 = new Uint8Array(this.arrayBuffer), this.uint32 = new Uint32Array(this.arrayBuffer);
+        }
+        emplaceBack(t3) {
+          const e3 = this.length;
+          return this.resize(e3 + 1), this.emplace(e3, t3);
+        }
+        emplace(t3, e3) {
+          return this.uint32[1 * t3 + 0] = e3, t3;
+        }
+      }
+      mo.prototype.bytesPerElement = 4, ps("StructArrayLayout1ul4", mo);
+      class go extends no {
+        _refreshViews() {
+          this.uint8 = new Uint8Array(this.arrayBuffer), this.int16 = new Int16Array(this.arrayBuffer), this.uint32 = new Uint32Array(this.arrayBuffer), this.uint16 = new Uint16Array(this.arrayBuffer);
+        }
+        emplaceBack(t3, e3, n3, r3, i3, s3, o3, a3, l3) {
+          const u3 = this.length;
+          return this.resize(u3 + 1), this.emplace(u3, t3, e3, n3, r3, i3, s3, o3, a3, l3);
+        }
+        emplace(t3, e3, n3, r3, i3, s3, o3, a3, l3, u3) {
+          const c3 = 10 * t3, h3 = 5 * t3;
+          return this.int16[c3 + 0] = e3, this.int16[c3 + 1] = n3, this.int16[c3 + 2] = r3, this.int16[c3 + 3] = i3, this.int16[c3 + 4] = s3, this.int16[c3 + 5] = o3, this.uint32[h3 + 3] = a3, this.uint16[c3 + 8] = l3, this.uint16[c3 + 9] = u3, t3;
+        }
+      }
+      go.prototype.bytesPerElement = 20, ps("StructArrayLayout6i1ul2ui20", go);
+      class xo extends no {
+        _refreshViews() {
+          this.uint8 = new Uint8Array(this.arrayBuffer), this.int16 = new Int16Array(this.arrayBuffer);
+        }
+        emplaceBack(t3, e3, n3, r3, i3, s3) {
+          const o3 = this.length;
+          return this.resize(o3 + 1), this.emplace(o3, t3, e3, n3, r3, i3, s3);
+        }
+        emplace(t3, e3, n3, r3, i3, s3, o3) {
+          const a3 = 6 * t3;
+          return this.int16[a3 + 0] = e3, this.int16[a3 + 1] = n3, this.int16[a3 + 2] = r3, this.int16[a3 + 3] = i3, this.int16[a3 + 4] = s3, this.int16[a3 + 5] = o3, t3;
+        }
+      }
+      xo.prototype.bytesPerElement = 12, ps("StructArrayLayout2i2i2i12", xo);
+      class vo extends no {
+        _refreshViews() {
+          this.uint8 = new Uint8Array(this.arrayBuffer), this.float32 = new Float32Array(this.arrayBuffer), this.int16 = new Int16Array(this.arrayBuffer);
+        }
+        emplaceBack(t3, e3, n3, r3, i3) {
+          const s3 = this.length;
+          return this.resize(s3 + 1), this.emplace(s3, t3, e3, n3, r3, i3);
+        }
+        emplace(t3, e3, n3, r3, i3, s3) {
+          const o3 = 4 * t3, a3 = 8 * t3;
+          return this.float32[o3 + 0] = e3, this.float32[o3 + 1] = n3, this.float32[o3 + 2] = r3, this.int16[a3 + 6] = i3, this.int16[a3 + 7] = s3, t3;
+        }
+      }
+      vo.prototype.bytesPerElement = 16, ps("StructArrayLayout2f1f2i16", vo);
+      class bo extends no {
+        _refreshViews() {
+          this.uint8 = new Uint8Array(this.arrayBuffer), this.float32 = new Float32Array(this.arrayBuffer), this.int16 = new Int16Array(this.arrayBuffer);
+        }
+        emplaceBack(t3, e3, n3, r3, i3, s3) {
+          const o3 = this.length;
+          return this.resize(o3 + 1), this.emplace(o3, t3, e3, n3, r3, i3, s3);
+        }
+        emplace(t3, e3, n3, r3, i3, s3, o3) {
+          const a3 = 16 * t3, l3 = 4 * t3, u3 = 8 * t3;
+          return this.uint8[a3 + 0] = e3, this.uint8[a3 + 1] = n3, this.float32[l3 + 1] = r3, this.float32[l3 + 2] = i3, this.int16[u3 + 6] = s3, this.int16[u3 + 7] = o3, t3;
+        }
+      }
+      bo.prototype.bytesPerElement = 16, ps("StructArrayLayout2ub2f2i16", bo);
+      class wo extends no {
+        _refreshViews() {
+          this.uint8 = new Uint8Array(this.arrayBuffer), this.uint16 = new Uint16Array(this.arrayBuffer);
+        }
+        emplaceBack(t3, e3, n3) {
+          const r3 = this.length;
+          return this.resize(r3 + 1), this.emplace(r3, t3, e3, n3);
+        }
+        emplace(t3, e3, n3, r3) {
+          const i3 = 3 * t3;
+          return this.uint16[i3 + 0] = e3, this.uint16[i3 + 1] = n3, this.uint16[i3 + 2] = r3, t3;
+        }
+      }
+      wo.prototype.bytesPerElement = 6, ps("StructArrayLayout3ui6", wo);
+      class _o2 extends no {
+        _refreshViews() {
+          this.uint8 = new Uint8Array(this.arrayBuffer), this.int16 = new Int16Array(this.arrayBuffer), this.uint16 = new Uint16Array(this.arrayBuffer), this.uint32 = new Uint32Array(this.arrayBuffer), this.float32 = new Float32Array(this.arrayBuffer);
+        }
+        emplaceBack(t3, e3, n3, r3, i3, s3, o3, a3, l3, u3, c3, h3, p3, f3, d3, y3, m3) {
+          const g3 = this.length;
+          return this.resize(g3 + 1), this.emplace(g3, t3, e3, n3, r3, i3, s3, o3, a3, l3, u3, c3, h3, p3, f3, d3, y3, m3);
+        }
+        emplace(t3, e3, n3, r3, i3, s3, o3, a3, l3, u3, c3, h3, p3, f3, d3, y3, m3, g3) {
+          const x3 = 24 * t3, v3 = 12 * t3, b3 = 48 * t3;
+          return this.int16[x3 + 0] = e3, this.int16[x3 + 1] = n3, this.uint16[x3 + 2] = r3, this.uint16[x3 + 3] = i3, this.uint32[v3 + 2] = s3, this.uint32[v3 + 3] = o3, this.uint32[v3 + 4] = a3, this.uint16[x3 + 10] = l3, this.uint16[x3 + 11] = u3, this.uint16[x3 + 12] = c3, this.float32[v3 + 7] = h3, this.float32[v3 + 8] = p3, this.uint8[b3 + 36] = f3, this.uint8[b3 + 37] = d3, this.uint8[b3 + 38] = y3, this.uint32[v3 + 10] = m3, this.int16[x3 + 22] = g3, t3;
+        }
+      }
+      _o2.prototype.bytesPerElement = 48, ps("StructArrayLayout2i2ui3ul3ui2f3ub1ul1i48", _o2);
+      class So extends no {
+        _refreshViews() {
+          this.uint8 = new Uint8Array(this.arrayBuffer), this.int16 = new Int16Array(this.arrayBuffer), this.uint16 = new Uint16Array(this.arrayBuffer), this.uint32 = new Uint32Array(this.arrayBuffer), this.float32 = new Float32Array(this.arrayBuffer);
+        }
+        emplaceBack(t3, e3, n3, r3, i3, s3, o3, a3, l3, u3, c3, h3, p3, f3, d3, y3, m3, g3, x3, v3, b3, w3, _3, S3, A3, M3, k3, I3) {
+          const E3 = this.length;
+          return this.resize(E3 + 1), this.emplace(E3, t3, e3, n3, r3, i3, s3, o3, a3, l3, u3, c3, h3, p3, f3, d3, y3, m3, g3, x3, v3, b3, w3, _3, S3, A3, M3, k3, I3);
+        }
+        emplace(t3, e3, n3, r3, i3, s3, o3, a3, l3, u3, c3, h3, p3, f3, d3, y3, m3, g3, x3, v3, b3, w3, _3, S3, A3, M3, k3, I3, E3) {
+          const T3 = 32 * t3, F3 = 16 * t3;
+          return this.int16[T3 + 0] = e3, this.int16[T3 + 1] = n3, this.int16[T3 + 2] = r3, this.int16[T3 + 3] = i3, this.int16[T3 + 4] = s3, this.int16[T3 + 5] = o3, this.int16[T3 + 6] = a3, this.int16[T3 + 7] = l3, this.uint16[T3 + 8] = u3, this.uint16[T3 + 9] = c3, this.uint16[T3 + 10] = h3, this.uint16[T3 + 11] = p3, this.uint16[T3 + 12] = f3, this.uint16[T3 + 13] = d3, this.uint16[T3 + 14] = y3, this.uint16[T3 + 15] = m3, this.uint16[T3 + 16] = g3, this.uint16[T3 + 17] = x3, this.uint16[T3 + 18] = v3, this.uint16[T3 + 19] = b3, this.uint16[T3 + 20] = w3, this.uint16[T3 + 21] = _3, this.uint16[T3 + 22] = S3, this.uint32[F3 + 12] = A3, this.float32[F3 + 13] = M3, this.float32[F3 + 14] = k3, this.uint16[T3 + 30] = I3, this.uint16[T3 + 31] = E3, t3;
+        }
+      }
+      So.prototype.bytesPerElement = 64, ps("StructArrayLayout8i15ui1ul2f2ui64", So);
+      class Ao extends no {
+        _refreshViews() {
+          this.uint8 = new Uint8Array(this.arrayBuffer), this.float32 = new Float32Array(this.arrayBuffer);
+        }
+        emplaceBack(t3) {
+          const e3 = this.length;
+          return this.resize(e3 + 1), this.emplace(e3, t3);
+        }
+        emplace(t3, e3) {
+          return this.float32[1 * t3 + 0] = e3, t3;
+        }
+      }
+      Ao.prototype.bytesPerElement = 4, ps("StructArrayLayout1f4", Ao);
+      class Mo extends no {
+        _refreshViews() {
+          this.uint8 = new Uint8Array(this.arrayBuffer), this.uint16 = new Uint16Array(this.arrayBuffer), this.float32 = new Float32Array(this.arrayBuffer);
+        }
+        emplaceBack(t3, e3, n3) {
+          const r3 = this.length;
+          return this.resize(r3 + 1), this.emplace(r3, t3, e3, n3);
+        }
+        emplace(t3, e3, n3, r3) {
+          const i3 = 3 * t3;
+          return this.uint16[6 * t3 + 0] = e3, this.float32[i3 + 1] = n3, this.float32[i3 + 2] = r3, t3;
+        }
+      }
+      Mo.prototype.bytesPerElement = 12, ps("StructArrayLayout1ui2f12", Mo);
+      class ko extends no {
+        _refreshViews() {
+          this.uint8 = new Uint8Array(this.arrayBuffer), this.uint32 = new Uint32Array(this.arrayBuffer), this.uint16 = new Uint16Array(this.arrayBuffer);
+        }
+        emplaceBack(t3, e3, n3) {
+          const r3 = this.length;
+          return this.resize(r3 + 1), this.emplace(r3, t3, e3, n3);
+        }
+        emplace(t3, e3, n3, r3) {
+          const i3 = 4 * t3;
+          return this.uint32[2 * t3 + 0] = e3, this.uint16[i3 + 2] = n3, this.uint16[i3 + 3] = r3, t3;
+        }
+      }
+      ko.prototype.bytesPerElement = 8, ps("StructArrayLayout1ul2ui8", ko);
+      class Io extends no {
+        _refreshViews() {
+          this.uint8 = new Uint8Array(this.arrayBuffer), this.uint16 = new Uint16Array(this.arrayBuffer);
+        }
+        emplaceBack(t3, e3) {
+          const n3 = this.length;
+          return this.resize(n3 + 1), this.emplace(n3, t3, e3);
+        }
+        emplace(t3, e3, n3) {
+          const r3 = 2 * t3;
+          return this.uint16[r3 + 0] = e3, this.uint16[r3 + 1] = n3, t3;
+        }
+      }
+      Io.prototype.bytesPerElement = 4, ps("StructArrayLayout2ui4", Io);
+      class Eo extends no {
+        _refreshViews() {
+          this.uint8 = new Uint8Array(this.arrayBuffer), this.uint16 = new Uint16Array(this.arrayBuffer);
+        }
+        emplaceBack(t3) {
+          const e3 = this.length;
+          return this.resize(e3 + 1), this.emplace(e3, t3);
+        }
+        emplace(t3, e3) {
+          return this.uint16[1 * t3 + 0] = e3, t3;
+        }
+      }
+      Eo.prototype.bytesPerElement = 2, ps("StructArrayLayout1ui2", Eo);
+      class To extends no {
+        _refreshViews() {
+          this.uint8 = new Uint8Array(this.arrayBuffer), this.float32 = new Float32Array(this.arrayBuffer);
+        }
+        emplaceBack(t3, e3, n3, r3) {
+          const i3 = this.length;
+          return this.resize(i3 + 1), this.emplace(i3, t3, e3, n3, r3);
+        }
+        emplace(t3, e3, n3, r3, i3) {
+          const s3 = 4 * t3;
+          return this.float32[s3 + 0] = e3, this.float32[s3 + 1] = n3, this.float32[s3 + 2] = r3, this.float32[s3 + 3] = i3, t3;
+        }
+      }
+      To.prototype.bytesPerElement = 16, ps("StructArrayLayout4f16", To);
+      class Fo extends eo {
+        get anchorPointX() {
+          return this._structArray.int16[this._pos2 + 0];
+        }
+        get anchorPointY() {
+          return this._structArray.int16[this._pos2 + 1];
+        }
+        get x1() {
+          return this._structArray.int16[this._pos2 + 2];
+        }
+        get y1() {
+          return this._structArray.int16[this._pos2 + 3];
+        }
+        get x2() {
+          return this._structArray.int16[this._pos2 + 4];
+        }
+        get y2() {
+          return this._structArray.int16[this._pos2 + 5];
+        }
+        get featureIndex() {
+          return this._structArray.uint32[this._pos4 + 3];
+        }
+        get sourceLayerIndex() {
+          return this._structArray.uint16[this._pos2 + 8];
+        }
+        get bucketIndex() {
+          return this._structArray.uint16[this._pos2 + 9];
+        }
+        get anchorPoint() {
+          return new n2(this.anchorPointX, this.anchorPointY);
+        }
+      }
+      Fo.prototype.size = 20;
+      class Do extends go {
+        get(t3) {
+          return new Fo(this, t3);
+        }
+      }
+      ps("CollisionBoxArray", Do);
+      class Po extends eo {
+        get anchorX() {
+          return this._structArray.int16[this._pos2 + 0];
+        }
+        get anchorY() {
+          return this._structArray.int16[this._pos2 + 1];
+        }
+        get glyphStartIndex() {
+          return this._structArray.uint16[this._pos2 + 2];
+        }
+        get numGlyphs() {
+          return this._structArray.uint16[this._pos2 + 3];
+        }
+        get vertexStartIndex() {
+          return this._structArray.uint32[this._pos4 + 2];
+        }
+        get lineStartIndex() {
+          return this._structArray.uint32[this._pos4 + 3];
+        }
+        get lineLength() {
+          return this._structArray.uint32[this._pos4 + 4];
+        }
+        get segment() {
+          return this._structArray.uint16[this._pos2 + 10];
+        }
+        get lowerSize() {
+          return this._structArray.uint16[this._pos2 + 11];
+        }
+        get upperSize() {
+          return this._structArray.uint16[this._pos2 + 12];
+        }
+        get lineOffsetX() {
+          return this._structArray.float32[this._pos4 + 7];
+        }
+        get lineOffsetY() {
+          return this._structArray.float32[this._pos4 + 8];
+        }
+        get writingMode() {
+          return this._structArray.uint8[this._pos1 + 36];
+        }
+        get placedOrientation() {
+          return this._structArray.uint8[this._pos1 + 37];
+        }
+        set placedOrientation(t3) {
+          this._structArray.uint8[this._pos1 + 37] = t3;
+        }
+        get hidden() {
+          return this._structArray.uint8[this._pos1 + 38];
+        }
+        set hidden(t3) {
+          this._structArray.uint8[this._pos1 + 38] = t3;
+        }
+        get crossTileID() {
+          return this._structArray.uint32[this._pos4 + 10];
+        }
+        set crossTileID(t3) {
+          this._structArray.uint32[this._pos4 + 10] = t3;
+        }
+        get associatedIconIndex() {
+          return this._structArray.int16[this._pos2 + 22];
+        }
+      }
+      Po.prototype.size = 48;
+      class zo extends _o2 {
+        get(t3) {
+          return new Po(this, t3);
+        }
+      }
+      ps("PlacedSymbolArray", zo);
+      class Bo extends eo {
+        get anchorX() {
+          return this._structArray.int16[this._pos2 + 0];
+        }
+        get anchorY() {
+          return this._structArray.int16[this._pos2 + 1];
+        }
+        get rightJustifiedTextSymbolIndex() {
+          return this._structArray.int16[this._pos2 + 2];
+        }
+        get centerJustifiedTextSymbolIndex() {
+          return this._structArray.int16[this._pos2 + 3];
+        }
+        get leftJustifiedTextSymbolIndex() {
+          return this._structArray.int16[this._pos2 + 4];
+        }
+        get verticalPlacedTextSymbolIndex() {
+          return this._structArray.int16[this._pos2 + 5];
+        }
+        get placedIconSymbolIndex() {
+          return this._structArray.int16[this._pos2 + 6];
+        }
+        get verticalPlacedIconSymbolIndex() {
+          return this._structArray.int16[this._pos2 + 7];
+        }
+        get key() {
+          return this._structArray.uint16[this._pos2 + 8];
+        }
+        get textBoxStartIndex() {
+          return this._structArray.uint16[this._pos2 + 9];
+        }
+        get textBoxEndIndex() {
+          return this._structArray.uint16[this._pos2 + 10];
+        }
+        get verticalTextBoxStartIndex() {
+          return this._structArray.uint16[this._pos2 + 11];
+        }
+        get verticalTextBoxEndIndex() {
+          return this._structArray.uint16[this._pos2 + 12];
+        }
+        get iconBoxStartIndex() {
+          return this._structArray.uint16[this._pos2 + 13];
+        }
+        get iconBoxEndIndex() {
+          return this._structArray.uint16[this._pos2 + 14];
+        }
+        get verticalIconBoxStartIndex() {
+          return this._structArray.uint16[this._pos2 + 15];
+        }
+        get verticalIconBoxEndIndex() {
+          return this._structArray.uint16[this._pos2 + 16];
+        }
+        get featureIndex() {
+          return this._structArray.uint16[this._pos2 + 17];
+        }
+        get numHorizontalGlyphVertices() {
+          return this._structArray.uint16[this._pos2 + 18];
+        }
+        get numVerticalGlyphVertices() {
+          return this._structArray.uint16[this._pos2 + 19];
+        }
+        get numIconVertices() {
+          return this._structArray.uint16[this._pos2 + 20];
+        }
+        get numVerticalIconVertices() {
+          return this._structArray.uint16[this._pos2 + 21];
+        }
+        get useRuntimeCollisionCircles() {
+          return this._structArray.uint16[this._pos2 + 22];
+        }
+        get crossTileID() {
+          return this._structArray.uint32[this._pos4 + 12];
+        }
+        set crossTileID(t3) {
+          this._structArray.uint32[this._pos4 + 12] = t3;
+        }
+        get textBoxScale() {
+          return this._structArray.float32[this._pos4 + 13];
+        }
+        get collisionCircleDiameter() {
+          return this._structArray.float32[this._pos4 + 14];
+        }
+        get textAnchorOffsetStartIndex() {
+          return this._structArray.uint16[this._pos2 + 30];
+        }
+        get textAnchorOffsetEndIndex() {
+          return this._structArray.uint16[this._pos2 + 31];
+        }
+      }
+      Bo.prototype.size = 64;
+      class Co extends So {
+        get(t3) {
+          return new Bo(this, t3);
+        }
+      }
+      ps("SymbolInstanceArray", Co);
+      class Vo extends Ao {
+        getoffsetX(t3) {
+          return this.float32[1 * t3 + 0];
+        }
+      }
+      ps("GlyphOffsetArray", Vo);
+      class Lo extends oo {
+        getx(t3) {
+          return this.int16[3 * t3 + 0];
+        }
+        gety(t3) {
+          return this.int16[3 * t3 + 1];
+        }
+        gettileUnitDistanceFromAnchor(t3) {
+          return this.int16[3 * t3 + 2];
+        }
+      }
+      ps("SymbolLineVertexArray", Lo);
+      class Oo extends eo {
+        get textAnchor() {
+          return this._structArray.uint16[this._pos2 + 0];
+        }
+        get textOffset0() {
+          return this._structArray.float32[this._pos4 + 1];
+        }
+        get textOffset1() {
+          return this._structArray.float32[this._pos4 + 2];
+        }
+      }
+      Oo.prototype.size = 12;
+      class $o extends Mo {
+        get(t3) {
+          return new Oo(this, t3);
+        }
+      }
+      ps("TextAnchorOffsetArray", $o);
+      class Ro extends eo {
+        get featureIndex() {
+          return this._structArray.uint32[this._pos4 + 0];
+        }
+        get sourceLayerIndex() {
+          return this._structArray.uint16[this._pos2 + 2];
+        }
+        get bucketIndex() {
+          return this._structArray.uint16[this._pos2 + 3];
+        }
+      }
+      Ro.prototype.size = 8;
+      class No extends ko {
+        get(t3) {
+          return new Ro(this, t3);
+        }
+      }
+      ps("FeatureIndexArray", No);
+      class Uo extends so {
+      }
+      class jo extends so {
+      }
+      class qo extends so {
+      }
+      class Go extends lo {
+      }
+      class Xo extends uo {
+      }
+      class Yo extends co {
+      }
+      class Zo extends ho {
+      }
+      class Ho extends po {
+      }
+      class Wo extends fo {
+      }
+      class Ko extends yo {
+      }
+      class Jo extends mo {
+      }
+      class Qo extends xo {
+      }
+      class ta2 extends bo {
+      }
+      class ea2 extends wo {
+      }
+      class na extends Io {
+      }
+      const ra2 = ro([{ name: "a_pos", components: 2, type: "Int16" }], 4), { members: ia2 } = ra2;
+      class sa2 {
+        constructor(t3 = []) {
+          this._forceNewSegmentOnNextPrepare = false, this.segments = t3;
+        }
+        prepareSegment(t3, e3, n3, r3) {
+          const i3 = this.segments[this.segments.length - 1];
+          return t3 > sa2.MAX_VERTEX_ARRAY_LENGTH && q2(`Max vertices per segment is ${sa2.MAX_VERTEX_ARRAY_LENGTH}: bucket requested ${t3}. Consider using the \`fillLargeMeshArrays\` function if you require meshes with more than ${sa2.MAX_VERTEX_ARRAY_LENGTH} vertices.`), this._forceNewSegmentOnNextPrepare || !i3 || i3.vertexLength + t3 > sa2.MAX_VERTEX_ARRAY_LENGTH || i3.sortKey !== r3 ? this.createNewSegment(e3, n3, r3) : i3;
+        }
+        createNewSegment(t3, e3, n3) {
+          const r3 = { vertexOffset: t3.length, primitiveOffset: e3.length, vertexLength: 0, primitiveLength: 0, vaos: {} };
+          return void 0 !== n3 && (r3.sortKey = n3), this._forceNewSegmentOnNextPrepare = false, this.segments.push(r3), r3;
+        }
+        getOrCreateLatestSegment(t3, e3, n3) {
+          return this.prepareSegment(0, t3, e3, n3);
+        }
+        forceNewSegmentOnNextPrepare() {
+          this._forceNewSegmentOnNextPrepare = true;
+        }
+        get() {
+          return this.segments;
+        }
+        destroy() {
+          for (const t3 of this.segments) for (const e3 in t3.vaos) t3.vaos[e3].destroy();
+        }
+        static simpleSegment(t3, e3, n3, r3) {
+          return new sa2([{ vertexOffset: t3, primitiveOffset: e3, vertexLength: n3, primitiveLength: r3, vaos: {}, sortKey: 0 }]);
+        }
+      }
+      function oa2(t3, e3) {
+        return 256 * (t3 = V2(Math.floor(t3), 0, 255)) + V2(Math.floor(e3), 0, 255);
+      }
+      sa2.MAX_VERTEX_ARRAY_LENGTH = Math.pow(2, 16) - 1, ps("SegmentVector", sa2);
+      const aa2 = ro([{ name: "a_pattern_from", components: 4, type: "Uint16" }, { name: "a_pattern_to", components: 4, type: "Uint16" }, { name: "a_pixel_ratio_from", components: 1, type: "Uint16" }, { name: "a_pixel_ratio_to", components: 1, type: "Uint16" }]), la2 = ro([{ name: "a_dasharray_from", components: 4, type: "Uint16" }, { name: "a_dasharray_to", components: 4, type: "Uint16" }]);
+      var ua2, ca2, ha2, pa2 = { exports: {} }, fa2 = { exports: {} }, da2 = { exports: {} }, ya2 = function() {
+        if (ha2) return pa2.exports;
+        ha2 = 1;
+        var t3 = (ua2 || (ua2 = 1, fa2.exports = function(t4, e4) {
+          var n3, r3, i3, s3, o3, a3, l3, u3;
+          for (r3 = t4.length - (n3 = 3 & t4.length), i3 = e4, o3 = 3432918353, a3 = 461845907, u3 = 0; u3 < r3; ) l3 = 255 & t4.charCodeAt(u3) | (255 & t4.charCodeAt(++u3)) << 8 | (255 & t4.charCodeAt(++u3)) << 16 | (255 & t4.charCodeAt(++u3)) << 24, ++u3, i3 = 27492 + (65535 & (s3 = 5 * (65535 & (i3 = (i3 ^= l3 = (65535 & (l3 = (l3 = (65535 & l3) * o3 + (((l3 >>> 16) * o3 & 65535) << 16) & 4294967295) << 15 | l3 >>> 17)) * a3 + (((l3 >>> 16) * a3 & 65535) << 16) & 4294967295) << 13 | i3 >>> 19)) + ((5 * (i3 >>> 16) & 65535) << 16) & 4294967295)) + ((58964 + (s3 >>> 16) & 65535) << 16);
+          switch (l3 = 0, n3) {
+            case 3:
+              l3 ^= (255 & t4.charCodeAt(u3 + 2)) << 16;
+            case 2:
+              l3 ^= (255 & t4.charCodeAt(u3 + 1)) << 8;
+            case 1:
+              i3 ^= l3 = (65535 & (l3 = (l3 = (65535 & (l3 ^= 255 & t4.charCodeAt(u3))) * o3 + (((l3 >>> 16) * o3 & 65535) << 16) & 4294967295) << 15 | l3 >>> 17)) * a3 + (((l3 >>> 16) * a3 & 65535) << 16) & 4294967295;
+          }
+          return i3 ^= t4.length, i3 = 2246822507 * (65535 & (i3 ^= i3 >>> 16)) + ((2246822507 * (i3 >>> 16) & 65535) << 16) & 4294967295, i3 = 3266489909 * (65535 & (i3 ^= i3 >>> 13)) + ((3266489909 * (i3 >>> 16) & 65535) << 16) & 4294967295, (i3 ^= i3 >>> 16) >>> 0;
+        }), fa2.exports), e3 = (ca2 || (ca2 = 1, da2.exports = function(t4, e4) {
+          for (var n3, r3 = t4.length, i3 = e4 ^ r3, s3 = 0; r3 >= 4; ) n3 = 1540483477 * (65535 & (n3 = 255 & t4.charCodeAt(s3) | (255 & t4.charCodeAt(++s3)) << 8 | (255 & t4.charCodeAt(++s3)) << 16 | (255 & t4.charCodeAt(++s3)) << 24)) + ((1540483477 * (n3 >>> 16) & 65535) << 16), i3 = 1540483477 * (65535 & i3) + ((1540483477 * (i3 >>> 16) & 65535) << 16) ^ (n3 = 1540483477 * (65535 & (n3 ^= n3 >>> 24)) + ((1540483477 * (n3 >>> 16) & 65535) << 16)), r3 -= 4, ++s3;
+          switch (r3) {
+            case 3:
+              i3 ^= (255 & t4.charCodeAt(s3 + 2)) << 16;
+            case 2:
+              i3 ^= (255 & t4.charCodeAt(s3 + 1)) << 8;
+            case 1:
+              i3 = 1540483477 * (65535 & (i3 ^= 255 & t4.charCodeAt(s3))) + ((1540483477 * (i3 >>> 16) & 65535) << 16);
+          }
+          return i3 = 1540483477 * (65535 & (i3 ^= i3 >>> 13)) + ((1540483477 * (i3 >>> 16) & 65535) << 16), (i3 ^= i3 >>> 15) >>> 0;
+        }), da2.exports);
+        return pa2.exports = t3, pa2.exports.murmur3 = t3, pa2.exports.murmur2 = e3, pa2.exports;
+      }(), ma2 = r2(ya2);
+      class ga {
+        constructor() {
+          this.ids = [], this.positions = [], this.indexed = false;
+        }
+        add(t3, e3, n3, r3) {
+          this.ids.push(xa(t3)), this.positions.push(e3, n3, r3);
+        }
+        getPositions(t3) {
+          if (!this.indexed) throw new Error("Trying to get index, but feature positions are not indexed");
+          const e3 = xa(t3);
+          let n3 = 0, r3 = this.ids.length - 1;
+          for (; n3 < r3; ) {
+            const t4 = n3 + r3 >> 1;
+            this.ids[t4] >= e3 ? r3 = t4 : n3 = t4 + 1;
+          }
+          const i3 = [];
+          for (; this.ids[n3] === e3; ) i3.push({ index: this.positions[3 * n3], start: this.positions[3 * n3 + 1], end: this.positions[3 * n3 + 2] }), n3++;
+          return i3;
+        }
+        static serialize(t3, e3) {
+          const n3 = new Float64Array(t3.ids), r3 = new Uint32Array(t3.positions);
+          return va2(n3, r3, 0, n3.length - 1), e3 && e3.push(n3.buffer, r3.buffer), { ids: n3, positions: r3 };
+        }
+        static deserialize(t3) {
+          const e3 = new ga();
+          return e3.ids = t3.ids, e3.positions = t3.positions, e3.indexed = true, e3;
+        }
+      }
+      function xa(t3) {
+        const e3 = +t3;
+        return !isNaN(e3) && e3 <= Number.MAX_SAFE_INTEGER ? e3 : ma2(String(t3));
+      }
+      function va2(t3, e3, n3, r3) {
+        for (; n3 < r3; ) {
+          const i3 = t3[n3 + r3 >> 1];
+          let s3 = n3 - 1, o3 = r3 + 1;
+          for (; ; ) {
+            do {
+              s3++;
+            } while (t3[s3] < i3);
+            do {
+              o3--;
+            } while (t3[o3] > i3);
+            if (s3 >= o3) break;
+            ba(t3, s3, o3), ba(e3, 3 * s3, 3 * o3), ba(e3, 3 * s3 + 1, 3 * o3 + 1), ba(e3, 3 * s3 + 2, 3 * o3 + 2);
+          }
+          o3 - n3 < r3 - o3 ? (va2(t3, e3, n3, o3), n3 = o3 + 1) : (va2(t3, e3, o3 + 1, r3), r3 = o3);
+        }
+      }
+      function ba(t3, e3, n3) {
+        const r3 = t3[e3];
+        t3[e3] = t3[n3], t3[n3] = r3;
+      }
+      ps("FeaturePositionMap", ga);
+      class wa2 {
+        constructor(t3, e3) {
+          this.gl = t3.gl, this.location = e3;
+        }
+      }
+      class _a3 extends wa2 {
+        constructor(t3, e3) {
+          super(t3, e3), this.current = 0;
+        }
+        set(t3) {
+          this.current !== t3 && (this.current = t3, this.gl.uniform1f(this.location, t3));
+        }
+      }
+      class Sa2 extends wa2 {
+        constructor(t3, e3) {
+          super(t3, e3), this.current = [0, 0, 0, 0];
+        }
+        set(t3) {
+          t3[0] === this.current[0] && t3[1] === this.current[1] && t3[2] === this.current[2] && t3[3] === this.current[3] || (this.current = t3, this.gl.uniform4f(this.location, t3[0], t3[1], t3[2], t3[3]));
+        }
+      }
+      class Aa2 extends wa2 {
+        constructor(t3, e3) {
+          super(t3, e3), this.current = Ie2.transparent;
+        }
+        set(t3) {
+          t3.r === this.current.r && t3.g === this.current.g && t3.b === this.current.b && t3.a === this.current.a || (this.current = t3, this.gl.uniform4f(this.location, t3.r, t3.g, t3.b, t3.a));
+        }
+      }
+      const Ma2 = new Float32Array(16);
+      function ka2(t3) {
+        return [oa2(255 * t3.r, 255 * t3.g), oa2(255 * t3.b, 255 * t3.a)];
+      }
+      class Ia2 {
+        constructor(t3, e3, n3) {
+          this.value = t3, this.uniformNames = e3.map((t4) => `u_${t4}`), this.type = n3;
+        }
+        setUniform(t3, e3, n3) {
+          t3.set(n3.constantOr(this.value));
+        }
+        getBinding(t3, e3, n3) {
+          return "color" === this.type ? new Aa2(t3, e3) : new _a3(t3, e3);
+        }
+      }
+      class Ea2 {
+        constructor(t3, e3) {
+          this.uniformNames = e3.map((t4) => `u_${t4}`), this.patternFrom = null, this.patternTo = null, this.pixelRatioFrom = 1, this.pixelRatioTo = 1;
+        }
+        setConstantPatternPositions(t3, e3) {
+          this.pixelRatioFrom = e3.pixelRatio, this.pixelRatioTo = t3.pixelRatio, this.patternFrom = e3.tlbr, this.patternTo = t3.tlbr;
+        }
+        setConstantDashPositions(t3, e3) {
+          this.dashTo = [0, t3.y, t3.height, t3.width], this.dashFrom = [0, e3.y, e3.height, e3.width];
+        }
+        setUniform(t3, e3, n3, r3) {
+          let i3 = null;
+          "u_pattern_to" === r3 ? i3 = this.patternTo : "u_pattern_from" === r3 ? i3 = this.patternFrom : "u_dasharray_to" === r3 ? i3 = this.dashTo : "u_dasharray_from" === r3 ? i3 = this.dashFrom : "u_pixel_ratio_to" === r3 ? i3 = this.pixelRatioTo : "u_pixel_ratio_from" === r3 && (i3 = this.pixelRatioFrom), null !== i3 && t3.set(i3);
+        }
+        getBinding(t3, e3, n3) {
+          return n3.startsWith("u_pattern") || n3.startsWith("u_dasharray_") ? new Sa2(t3, e3) : new _a3(t3, e3);
+        }
+      }
+      class Ta2 {
+        constructor(t3, e3, n3, r3) {
+          this.expression = t3, this.type = n3, this.maxValue = 0, this.paintVertexAttributes = e3.map((t4) => ({ name: `a_${t4}`, type: "Float32", components: "color" === n3 ? 2 : 1, offset: 0 })), this.paintVertexArray = new r3();
+        }
+        populatePaintArray(t3, e3, n3) {
+          const r3 = this.paintVertexArray.length, i3 = this.expression.evaluate(new zs(0, n3), e3, {}, n3.canonical, [], n3.formattedSection);
+          this.paintVertexArray.resize(t3), this._setPaintValue(r3, t3, i3);
+        }
+        updatePaintArray(t3, e3, n3, r3, i3) {
+          const s3 = this.expression.evaluate(new zs(0, i3), n3, r3);
+          this._setPaintValue(t3, e3, s3);
+        }
+        _setPaintValue(t3, e3, n3) {
+          if ("color" === this.type) {
+            const r3 = ka2(n3);
+            for (let n4 = t3; n4 < e3; n4++) this.paintVertexArray.emplace(n4, r3[0], r3[1]);
+          } else {
+            for (let r3 = t3; r3 < e3; r3++) this.paintVertexArray.emplace(r3, n3);
+            this.maxValue = Math.max(this.maxValue, Math.abs(n3));
+          }
+        }
+        upload(t3) {
+          var e3;
+          (null === (e3 = this.paintVertexArray) || void 0 === e3 ? void 0 : e3.arrayBuffer.byteLength) && (this.paintVertexBuffer && this.paintVertexBuffer.buffer ? this.paintVertexBuffer.updateData(this.paintVertexArray) : this.paintVertexBuffer = t3.createVertexBuffer(this.paintVertexArray, this.paintVertexAttributes, this.expression.isStateDependent));
+        }
+        destroy() {
+          this.paintVertexBuffer && this.paintVertexBuffer.destroy();
+        }
+      }
+      class Fa2 {
+        constructor(t3, e3, n3, r3, i3, s3) {
+          this.expression = t3, this.uniformNames = e3.map((t4) => `u_${t4}_t`), this.type = n3, this.useIntegerZoom = r3, this.zoom = i3, this.maxValue = 0, this.paintVertexAttributes = e3.map((t4) => ({ name: `a_${t4}`, type: "Float32", components: "color" === n3 ? 4 : 2, offset: 0 })), this.paintVertexArray = new s3();
+        }
+        populatePaintArray(t3, e3, n3) {
+          const r3 = this.expression.evaluate(new zs(this.zoom, n3), e3, {}, n3.canonical, [], n3.formattedSection), i3 = this.expression.evaluate(new zs(this.zoom + 1, n3), e3, {}, n3.canonical, [], n3.formattedSection), s3 = this.paintVertexArray.length;
+          this.paintVertexArray.resize(t3), this._setPaintValue(s3, t3, r3, i3);
+        }
+        updatePaintArray(t3, e3, n3, r3, i3) {
+          const s3 = this.expression.evaluate(new zs(this.zoom, i3), n3, r3), o3 = this.expression.evaluate(new zs(this.zoom + 1, i3), n3, r3);
+          this._setPaintValue(t3, e3, s3, o3);
+        }
+        _setPaintValue(t3, e3, n3, r3) {
+          if ("color" === this.type) {
+            const i3 = ka2(n3), s3 = ka2(r3);
+            for (let n4 = t3; n4 < e3; n4++) this.paintVertexArray.emplace(n4, i3[0], i3[1], s3[0], s3[1]);
+          } else {
+            for (let i3 = t3; i3 < e3; i3++) this.paintVertexArray.emplace(i3, n3, r3);
+            this.maxValue = Math.max(this.maxValue, Math.abs(n3), Math.abs(r3));
+          }
+        }
+        upload(t3) {
+          var e3;
+          (null === (e3 = this.paintVertexArray) || void 0 === e3 ? void 0 : e3.arrayBuffer.byteLength) && (this.paintVertexBuffer && this.paintVertexBuffer.buffer ? this.paintVertexBuffer.updateData(this.paintVertexArray) : this.paintVertexBuffer = t3.createVertexBuffer(this.paintVertexArray, this.paintVertexAttributes, this.expression.isStateDependent));
+        }
+        destroy() {
+          this.paintVertexBuffer && this.paintVertexBuffer.destroy();
+        }
+        setUniform(t3, e3) {
+          const n3 = this.useIntegerZoom ? Math.floor(e3.zoom) : e3.zoom, r3 = V2(this.expression.interpolationFactor(n3, this.zoom, this.zoom + 1), 0, 1);
+          t3.set(r3);
+        }
+        getBinding(t3, e3, n3) {
+          return new _a3(t3, e3);
+        }
+      }
+      class Da2 {
+        constructor(t3, e3, n3, r3, i3, s3) {
+          this.expression = t3, this.type = e3, this.useIntegerZoom = n3, this.zoom = r3, this.layerId = s3, this.zoomInPaintVertexArray = new i3(), this.zoomOutPaintVertexArray = new i3();
+        }
+        populatePaintArray(t3, e3, n3) {
+          const r3 = this.zoomInPaintVertexArray.length;
+          this.zoomInPaintVertexArray.resize(t3), this.zoomOutPaintVertexArray.resize(t3), this._setPaintValues(r3, t3, this.getPositionIds(e3), n3);
+        }
+        updatePaintArray(t3, e3, n3, r3, i3) {
+          this._setPaintValues(t3, e3, this.getPositionIds(n3), i3);
+        }
+        _setPaintValues(t3, e3, n3, r3) {
+          const i3 = this.getPositions(r3);
+          if (!i3 || !n3) return;
+          const s3 = i3[n3.min], o3 = i3[n3.mid], a3 = i3[n3.max];
+          if (s3 && o3 && a3) for (let n4 = t3; n4 < e3; n4++) this.emplace(this.zoomInPaintVertexArray, n4, o3, s3), this.emplace(this.zoomOutPaintVertexArray, n4, o3, a3);
+        }
+        upload(t3) {
+          var e3, n3;
+          if ((null === (e3 = this.zoomInPaintVertexArray) || void 0 === e3 ? void 0 : e3.arrayBuffer.byteLength) && (null === (n3 = this.zoomOutPaintVertexArray) || void 0 === n3 ? void 0 : n3.arrayBuffer.byteLength)) {
+            const e4 = this.getVertexAttributes();
+            this.zoomInPaintVertexBuffer = t3.createVertexBuffer(this.zoomInPaintVertexArray, e4, this.expression.isStateDependent), this.zoomOutPaintVertexBuffer = t3.createVertexBuffer(this.zoomOutPaintVertexArray, e4, this.expression.isStateDependent);
+          }
+        }
+        destroy() {
+          this.zoomOutPaintVertexBuffer && this.zoomOutPaintVertexBuffer.destroy(), this.zoomInPaintVertexBuffer && this.zoomInPaintVertexBuffer.destroy();
+        }
+      }
+      class Pa2 extends Da2 {
+        getPositions(t3) {
+          return t3.imagePositions;
+        }
+        getPositionIds(t3) {
+          return t3.patterns && t3.patterns[this.layerId];
+        }
+        getVertexAttributes() {
+          return aa2.members;
+        }
+        emplace(t3, e3, n3, r3) {
+          t3.emplace(e3, n3.tlbr[0], n3.tlbr[1], n3.tlbr[2], n3.tlbr[3], r3.tlbr[0], r3.tlbr[1], r3.tlbr[2], r3.tlbr[3], n3.pixelRatio, r3.pixelRatio);
+        }
+      }
+      class za2 extends Da2 {
+        getPositions(t3) {
+          return t3.dashPositions;
+        }
+        getPositionIds(t3) {
+          return t3.dashes && t3.dashes[this.layerId];
+        }
+        getVertexAttributes() {
+          return la2.members;
+        }
+        emplace(t3, e3, n3, r3) {
+          t3.emplace(e3, 0, n3.y, n3.height, n3.width, 0, r3.y, r3.height, r3.width);
+        }
+      }
+      class Ba2 {
+        constructor(t3, e3, n3) {
+          this.binders = {}, this._buffers = [];
+          const r3 = [];
+          for (const i3 in t3.paint._values) {
+            if (!n3(i3)) continue;
+            const s3 = t3.paint.get(i3);
+            if (!(s3 instanceof Us && jr(s3.property.specification))) continue;
+            const o3 = Va2(i3, t3.type), a3 = s3.value, l3 = s3.property.specification.type, u3 = s3.property.useIntegerZoom, c3 = s3.property.specification["property-type"], h3 = "cross-faded" === c3 || "cross-faded-data-driven" === c3;
+            if ("constant" === a3.kind) this.binders[i3] = h3 ? new Ea2(a3.value, o3) : new Ia2(a3.value, o3, l3), r3.push(`/u_${i3}`);
+            else if ("source" === a3.kind || h3) {
+              const n4 = La2(i3, l3, "source");
+              this.binders[i3] = h3 ? "line-dasharray" === i3 ? new za2(a3, l3, u3, e3, n4, t3.id) : new Pa2(a3, l3, u3, e3, n4, t3.id) : new Ta2(a3, o3, l3, n4), r3.push(`/a_${i3}`);
+            } else {
+              const t4 = La2(i3, l3, "composite");
+              this.binders[i3] = new Fa2(a3, o3, l3, u3, e3, t4), r3.push(`/z_${i3}`);
+            }
+          }
+          this.cacheKey = r3.sort().join("");
+        }
+        getMaxValue(t3) {
+          const e3 = this.binders[t3];
+          return e3 instanceof Ta2 || e3 instanceof Fa2 ? e3.maxValue : 0;
+        }
+        populatePaintArrays(t3, e3, n3) {
+          for (const r3 in this.binders) {
+            const i3 = this.binders[r3];
+            (i3 instanceof Ta2 || i3 instanceof Fa2 || i3 instanceof Da2) && i3.populatePaintArray(t3, e3, n3);
+          }
+        }
+        setConstantPatternPositions(t3, e3) {
+          for (const n3 in this.binders) {
+            const r3 = this.binders[n3];
+            r3 instanceof Ea2 && r3.setConstantPatternPositions(t3, e3);
+          }
+        }
+        setConstantDashPositions(t3, e3) {
+          for (const n3 in this.binders) {
+            const r3 = this.binders[n3];
+            r3 instanceof Ea2 && r3.setConstantDashPositions(t3, e3);
+          }
+        }
+        updatePaintArrays(t3, e3, n3, r3, i3) {
+          let s3 = false;
+          for (const o3 in t3) {
+            const a3 = e3.getPositions(o3);
+            for (const e4 of a3) {
+              const a4 = n3.feature(e4.index);
+              for (const n4 in this.binders) {
+                const l3 = this.binders[n4];
+                if ((l3 instanceof Ta2 || l3 instanceof Fa2 || l3 instanceof Da2) && true === l3.expression.isStateDependent) {
+                  const u3 = r3.paint.get(n4);
+                  l3.expression = u3.value, l3.updatePaintArray(e4.start, e4.end, a4, t3[o3], i3), s3 = true;
+                }
+              }
+            }
+          }
+          return s3;
+        }
+        defines() {
+          const t3 = [];
+          for (const e3 in this.binders) {
+            const n3 = this.binders[e3];
+            (n3 instanceof Ia2 || n3 instanceof Ea2) && t3.push(...n3.uniformNames.map((t4) => `#define HAS_UNIFORM_${t4}`));
+          }
+          return t3;
+        }
+        getBinderAttributes() {
+          const t3 = [];
+          for (const e3 in this.binders) {
+            const n3 = this.binders[e3];
+            if (n3 instanceof Ta2 || n3 instanceof Fa2) for (let e4 = 0; e4 < n3.paintVertexAttributes.length; e4++) t3.push(n3.paintVertexAttributes[e4].name);
+            else if (n3 instanceof Da2) {
+              const e4 = n3.getVertexAttributes();
+              for (const n4 of e4) t3.push(n4.name);
+            }
+          }
+          return t3;
+        }
+        getBinderUniforms() {
+          const t3 = [];
+          for (const e3 in this.binders) {
+            const n3 = this.binders[e3];
+            if (n3 instanceof Ia2 || n3 instanceof Ea2 || n3 instanceof Fa2) for (const e4 of n3.uniformNames) t3.push(e4);
+          }
+          return t3;
+        }
+        getPaintVertexBuffers() {
+          return this._buffers;
+        }
+        getUniforms(t3, e3) {
+          const n3 = [];
+          for (const r3 in this.binders) {
+            const i3 = this.binders[r3];
+            if (i3 instanceof Ia2 || i3 instanceof Ea2 || i3 instanceof Fa2) {
+              for (const s3 of i3.uniformNames) if (e3[s3]) {
+                const o3 = i3.getBinding(t3, e3[s3], s3);
+                n3.push({ name: s3, property: r3, binding: o3 });
+              }
+            }
+          }
+          return n3;
+        }
+        setUniforms(t3, e3, n3, r3) {
+          for (const { name: t4, property: i3, binding: s3 } of e3) this.binders[i3].setUniform(s3, r3, n3.get(i3), t4);
+        }
+        updatePaintBuffers(t3) {
+          this._buffers = [];
+          for (const e3 in this.binders) {
+            const n3 = this.binders[e3];
+            if (t3 && n3 instanceof Da2) {
+              const e4 = 2 === t3.fromScale ? n3.zoomInPaintVertexBuffer : n3.zoomOutPaintVertexBuffer;
+              e4 && this._buffers.push(e4);
+            } else (n3 instanceof Ta2 || n3 instanceof Fa2) && n3.paintVertexBuffer && this._buffers.push(n3.paintVertexBuffer);
+          }
+        }
+        upload(t3) {
+          for (const e3 in this.binders) {
+            const n3 = this.binders[e3];
+            (n3 instanceof Ta2 || n3 instanceof Fa2 || n3 instanceof Da2) && n3.upload(t3);
+          }
+          this.updatePaintBuffers();
+        }
+        destroy() {
+          for (const t3 in this.binders) {
+            const e3 = this.binders[t3];
+            (e3 instanceof Ta2 || e3 instanceof Fa2 || e3 instanceof Da2) && e3.destroy();
+          }
+        }
+      }
+      class Ca2 {
+        constructor(t3, e3, n3 = () => true) {
+          this.programConfigurations = {};
+          for (const r3 of t3) this.programConfigurations[r3.id] = new Ba2(r3, e3, n3);
+          this.needsUpload = false, this._featureMap = new ga(), this._bufferOffset = 0;
+        }
+        populatePaintArrays(t3, e3, n3, r3) {
+          for (const n4 in this.programConfigurations) this.programConfigurations[n4].populatePaintArrays(t3, e3, r3);
+          void 0 !== e3.id && this._featureMap.add(e3.id, n3, this._bufferOffset, t3), this._bufferOffset = t3, this.needsUpload = true;
+        }
+        updatePaintArrays(t3, e3, n3, r3) {
+          for (const i3 of n3) this.needsUpload = this.programConfigurations[i3.id].updatePaintArrays(t3, this._featureMap, e3, i3, r3) || this.needsUpload;
+        }
+        get(t3) {
+          return this.programConfigurations[t3];
+        }
+        upload(t3) {
+          if (this.needsUpload) {
+            for (const e3 in this.programConfigurations) this.programConfigurations[e3].upload(t3);
+            this.needsUpload = false;
+          }
+        }
+        destroy() {
+          for (const t3 in this.programConfigurations) this.programConfigurations[t3].destroy();
+        }
+      }
+      function Va2(t3, e3) {
+        return { "text-opacity": ["opacity"], "icon-opacity": ["opacity"], "text-color": ["fill_color"], "icon-color": ["fill_color"], "text-halo-color": ["halo_color"], "icon-halo-color": ["halo_color"], "text-halo-blur": ["halo_blur"], "icon-halo-blur": ["halo_blur"], "text-halo-width": ["halo_width"], "icon-halo-width": ["halo_width"], "line-gap-width": ["gapwidth"], "line-dasharray": ["dasharray_to", "dasharray_from"], "line-pattern": ["pattern_to", "pattern_from", "pixel_ratio_to", "pixel_ratio_from"], "fill-pattern": ["pattern_to", "pattern_from", "pixel_ratio_to", "pixel_ratio_from"], "fill-extrusion-pattern": ["pattern_to", "pattern_from", "pixel_ratio_to", "pixel_ratio_from"] }[t3] || [t3.replace(`${e3}-`, "").replace(/-/g, "_")];
+      }
+      function La2(t3, e3, n3) {
+        const r3 = { color: { source: co, composite: To }, number: { source: Ao, composite: co } }, i3 = function(t4) {
+          return { "line-pattern": { source: Zo, composite: Zo }, "fill-pattern": { source: Zo, composite: Zo }, "fill-extrusion-pattern": { source: Zo, composite: Zo }, "line-dasharray": { source: Ho, composite: Ho } }[t4];
+        }(t3);
+        return i3 && i3[n3] || r3[e3][n3];
+      }
+      ps("ConstantBinder", Ia2), ps("CrossFadedConstantBinder", Ea2), ps("SourceExpressionBinder", Ta2), ps("CrossFadedPatternBinder", Pa2), ps("CrossFadedDasharrayBinder", za2), ps("CompositeExpressionBinder", Fa2), ps("ProgramConfiguration", Ba2, { omit: ["_buffers"] }), ps("ProgramConfigurationSet", Ca2);
+      const Oa2 = Math.pow(2, 14) - 1, $a = -Oa2 - 1;
+      function Ra2(t3) {
+        const e3 = T2 / t3.extent, n3 = t3.loadGeometry();
+        for (let t4 = 0; t4 < n3.length; t4++) {
+          const r3 = n3[t4];
+          for (let t5 = 0; t5 < r3.length; t5++) {
+            const n4 = r3[t5], i3 = Math.round(n4.x * e3), s3 = Math.round(n4.y * e3);
+            n4.x = V2(i3, $a, Oa2), n4.y = V2(s3, $a, Oa2), (i3 < n4.x || i3 > n4.x + 1 || s3 < n4.y || s3 > n4.y + 1) && q2("Geometry exceeds allowed extent, reduce your vector tile buffer size");
+          }
+        }
+        return n3;
+      }
+      function Na2(t3, e3) {
+        return { type: t3.type, id: t3.id, properties: t3.properties, geometry: e3 ? Ra2(t3) : [] };
+      }
+      const Ua2 = -32768;
+      function ja2(t3, e3, n3, r3, i3) {
+        t3.emplaceBack(Ua2 + 8 * e3 + r3, Ua2 + 8 * n3 + i3);
+      }
+      class qa2 {
+        constructor(t3) {
+          this.zoom = t3.zoom, this.overscaling = t3.overscaling, this.layers = t3.layers, this.layerIds = this.layers.map((t4) => t4.id), this.index = t3.index, this.hasDependencies = false, this.layoutVertexArray = new jo(), this.indexArray = new ea2(), this.segments = new sa2(), this.programConfigurations = new Ca2(t3.layers, t3.zoom), this.stateDependentLayerIds = this.layers.filter((t4) => t4.isStateDependent()).map((t4) => t4.id);
+        }
+        populate(t3, e3, n3) {
+          const r3 = this.layers[0], i3 = [];
+          let s3 = null, o3 = false, a3 = "heatmap" === r3.type;
+          if ("circle" === r3.type) {
+            const t4 = r3;
+            s3 = t4.layout.get("circle-sort-key"), o3 = !s3.isConstant(), a3 = a3 || "map" === t4.paint.get("circle-pitch-alignment");
+          }
+          const l3 = a3 ? e3.subdivisionGranularity.circle : 1;
+          for (const { feature: e4, id: r4, index: a4, sourceLayerIndex: l4 } of t3) {
+            const t4 = this.layers[0]._featureFilter.needGeometry, u3 = Na2(e4, t4);
+            if (!this.layers[0]._featureFilter.filter(new zs(this.zoom), u3, n3)) continue;
+            const c3 = o3 ? s3.evaluate(u3, {}, n3) : void 0, h3 = { id: r4, properties: e4.properties, type: e4.type, sourceLayerIndex: l4, index: a4, geometry: t4 ? u3.geometry : Ra2(e4), patterns: {}, sortKey: c3 };
+            i3.push(h3);
+          }
+          o3 && i3.sort((t4, e4) => t4.sortKey - e4.sortKey);
+          for (const r4 of i3) {
+            const { geometry: i4, index: s4, sourceLayerIndex: o4 } = r4, a4 = t3[s4].feature;
+            this.addFeature(r4, i4, s4, n3, l3), e3.featureIndex.insert(a4, i4, s4, o4, this.index);
+          }
+        }
+        update(t3, e3, n3) {
+          this.stateDependentLayers.length && this.programConfigurations.updatePaintArrays(t3, e3, this.stateDependentLayers, { imagePositions: n3 });
+        }
+        isEmpty() {
+          return 0 === this.layoutVertexArray.length;
+        }
+        uploadPending() {
+          return !this.uploaded || this.programConfigurations.needsUpload;
+        }
+        upload(t3) {
+          this.uploaded || (this.layoutVertexBuffer = t3.createVertexBuffer(this.layoutVertexArray, ia2), this.indexBuffer = t3.createIndexBuffer(this.indexArray)), this.programConfigurations.upload(t3), this.uploaded = true;
+        }
+        destroy() {
+          this.layoutVertexBuffer && (this.layoutVertexBuffer.destroy(), this.indexBuffer.destroy(), this.programConfigurations.destroy(), this.segments.destroy());
+        }
+        addFeature(t3, e3, n3, r3, i3 = 1) {
+          let s3;
+          switch (i3) {
+            case 1:
+              s3 = [0, 7];
+              break;
+            case 3:
+              s3 = [0, 2, 5, 7];
+              break;
+            case 5:
+              s3 = [0, 1, 3, 4, 6, 7];
+              break;
+            case 7:
+              s3 = [0, 1, 2, 3, 4, 5, 6, 7];
+              break;
+            default:
+              throw new Error(`Invalid circle bucket granularity: ${i3}; valid values are 1, 3, 5, 7.`);
+          }
+          const o3 = s3.length;
+          for (const n4 of e3) for (const e4 of n4) {
+            const n5 = e4.x, r4 = e4.y;
+            if (n5 < 0 || n5 >= T2 || r4 < 0 || r4 >= T2) continue;
+            const i4 = this.segments.prepareSegment(o3 * o3, this.layoutVertexArray, this.indexArray, t3.sortKey), a3 = i4.vertexLength;
+            for (let t4 = 0; t4 < o3; t4++) for (let e5 = 0; e5 < o3; e5++) ja2(this.layoutVertexArray, n5, r4, s3[e5], s3[t4]);
+            for (let t4 = 0; t4 < o3 - 1; t4++) for (let e5 = 0; e5 < o3 - 1; e5++) {
+              const n6 = a3 + t4 * o3 + e5, r5 = a3 + (t4 + 1) * o3 + e5;
+              this.indexArray.emplaceBack(n6, r5 + 1, n6 + 1), this.indexArray.emplaceBack(n6, r5, r5 + 1);
+            }
+            i4.vertexLength += o3 * o3, i4.primitiveLength += (o3 - 1) * (o3 - 1) * 2;
+          }
+          this.programConfigurations.populatePaintArrays(this.layoutVertexArray.length, t3, n3, { imagePositions: {}, canonical: r3 });
+        }
+      }
+      function Ga2(t3, e3) {
+        for (let n3 = 0; n3 < t3.length; n3++) if (tl2(e3, t3[n3])) return true;
+        for (let n3 = 0; n3 < e3.length; n3++) if (tl2(t3, e3[n3])) return true;
+        return !!Ha2(t3, e3);
+      }
+      function Xa2(t3, e3, n3) {
+        return !!tl2(t3, e3) || !!Ka2(e3, t3, n3);
+      }
+      function Ya2(t3, e3) {
+        if (1 === t3.length) return Qa2(e3, t3[0]);
+        for (let n3 = 0; n3 < e3.length; n3++) {
+          const r3 = e3[n3];
+          for (let e4 = 0; e4 < r3.length; e4++) if (tl2(t3, r3[e4])) return true;
+        }
+        for (let n3 = 0; n3 < t3.length; n3++) if (Qa2(e3, t3[n3])) return true;
+        for (let n3 = 0; n3 < e3.length; n3++) if (Ha2(t3, e3[n3])) return true;
+        return false;
+      }
+      function Za2(t3, e3, n3) {
+        if (t3.length > 1) {
+          if (Ha2(t3, e3)) return true;
+          for (let r3 = 0; r3 < e3.length; r3++) if (Ka2(e3[r3], t3, n3)) return true;
+        }
+        for (let r3 = 0; r3 < t3.length; r3++) if (Ka2(t3[r3], e3, n3)) return true;
+        return false;
+      }
+      function Ha2(t3, e3) {
+        if (0 === t3.length || 0 === e3.length) return false;
+        for (let n3 = 0; n3 < t3.length - 1; n3++) {
+          const r3 = t3[n3], i3 = t3[n3 + 1];
+          for (let t4 = 0; t4 < e3.length - 1; t4++) if (Wa2(r3, i3, e3[t4], e3[t4 + 1])) return true;
+        }
+        return false;
+      }
+      function Wa2(t3, e3, n3, r3) {
+        return G2(t3, n3, r3) !== G2(e3, n3, r3) && G2(t3, e3, n3) !== G2(t3, e3, r3);
+      }
+      function Ka2(t3, e3, n3) {
+        const r3 = n3 * n3;
+        if (1 === e3.length) return t3.distSqr(e3[0]) < r3;
+        for (let n4 = 1; n4 < e3.length; n4++) if (Ja2(t3, e3[n4 - 1], e3[n4]) < r3) return true;
+        return false;
+      }
+      function Ja2(t3, e3, n3) {
+        const r3 = e3.distSqr(n3);
+        if (0 === r3) return t3.distSqr(e3);
+        const i3 = ((t3.x - e3.x) * (n3.x - e3.x) + (t3.y - e3.y) * (n3.y - e3.y)) / r3;
+        return t3.distSqr(i3 < 0 ? e3 : i3 > 1 ? n3 : n3.sub(e3)._mult(i3)._add(e3));
+      }
+      function Qa2(t3, e3) {
+        let n3, r3, i3, s3 = false;
+        for (let o3 = 0; o3 < t3.length; o3++) {
+          n3 = t3[o3];
+          for (let t4 = 0, o4 = n3.length - 1; t4 < n3.length; o4 = t4++) r3 = n3[t4], i3 = n3[o4], r3.y > e3.y != i3.y > e3.y && e3.x < (i3.x - r3.x) * (e3.y - r3.y) / (i3.y - r3.y) + r3.x && (s3 = !s3);
+        }
+        return s3;
+      }
+      function tl2(t3, e3) {
+        let n3 = false;
+        for (let r3 = 0, i3 = t3.length - 1; r3 < t3.length; i3 = r3++) {
+          const s3 = t3[r3], o3 = t3[i3];
+          s3.y > e3.y != o3.y > e3.y && e3.x < (o3.x - s3.x) * (e3.y - s3.y) / (o3.y - s3.y) + s3.x && (n3 = !n3);
+        }
+        return n3;
+      }
+      function el2(t3, e3, n3) {
+        const r3 = n3[0], i3 = n3[2];
+        if (t3.x < r3.x && e3.x < r3.x || t3.x > i3.x && e3.x > i3.x || t3.y < r3.y && e3.y < r3.y || t3.y > i3.y && e3.y > i3.y) return false;
+        const s3 = G2(t3, e3, n3[0]);
+        return s3 !== G2(t3, e3, n3[1]) || s3 !== G2(t3, e3, n3[2]) || s3 !== G2(t3, e3, n3[3]);
+      }
+      function nl2(t3, e3, n3) {
+        const r3 = e3.paint.get(t3).value;
+        return "constant" === r3.kind ? r3.value : n3.programConfigurations.get(e3.id).getMaxValue(t3);
+      }
+      function rl2(t3) {
+        return Math.sqrt(t3[0] * t3[0] + t3[1] * t3[1]);
+      }
+      function il2(t3, e3, r3, i3, s3) {
+        if (!e3[0] && !e3[1]) return t3;
+        const o3 = n2.convert(e3)._mult(s3);
+        "viewport" === r3 && o3._rotate(-i3);
+        const a3 = [];
+        for (let e4 = 0; e4 < t3.length; e4++) a3.push(t3[e4].sub(o3));
+        return a3;
+      }
+      function sl2(t3) {
+        const e3 = [];
+        for (let n3 = 0; n3 < t3.length; n3++) {
+          const r3 = t3[n3], i3 = e3.at(-1);
+          (0 === n3 || i3 && !r3.equals(i3)) && e3.push(r3);
+        }
+        return e3;
+      }
+      function ol2({ queryGeometry: t3, size: e3 }, n3) {
+        return Xa2(t3, n3, e3);
+      }
+      function al2({ queryGeometry: t3, size: e3, transform: n3, unwrappedTileID: r3, getElevation: i3 }, s3) {
+        return Xa2(t3, s3, e3 * (n3.projectTileCoordinates(s3.x, s3.y, r3, i3).signedDistanceFromCamera / n3.cameraToCenterDistance));
+      }
+      function ll2({ queryGeometry: t3, size: e3, transform: n3, unwrappedTileID: r3, getElevation: i3 }, s3) {
+        const o3 = n3.projectTileCoordinates(s3.x, s3.y, r3, i3).signedDistanceFromCamera, a3 = e3 * (n3.cameraToCenterDistance / o3);
+        return Xa2(t3, hl2(s3, n3, r3, i3), a3);
+      }
+      function ul2({ queryGeometry: t3, size: e3, transform: n3, unwrappedTileID: r3, getElevation: i3 }, s3) {
+        return Xa2(t3, hl2(s3, n3, r3, i3), e3);
+      }
+      function cl2({ queryGeometry: t3, size: e3, transform: n3, unwrappedTileID: r3, getElevation: i3, pitchAlignment: s3 = "map", pitchScale: o3 = "map" }, a3) {
+        const l3 = "map" === s3 ? "map" === o3 ? ol2 : al2 : "map" === o3 ? ll2 : ul2, u3 = { queryGeometry: t3, size: e3, transform: n3, unwrappedTileID: r3, getElevation: i3 };
+        for (const t4 of a3) for (const e4 of t4) if (l3(u3, e4)) return true;
+        return false;
+      }
+      function hl2(t3, e3, r3, i3) {
+        const s3 = e3.projectTileCoordinates(t3.x, t3.y, r3, i3).point;
+        return new n2((0.5 * s3.x + 0.5) * e3.width, (0.5 * -s3.y + 0.5) * e3.height);
+      }
+      let pl2, fl2;
+      ps("CircleBucket", qa2, { omit: ["layers"] });
+      var dl2 = { get paint() {
+        return fl2 = fl2 || new Hs({ "circle-radius": new Gs(vt.paint_circle["circle-radius"]), "circle-color": new Gs(vt.paint_circle["circle-color"]), "circle-blur": new Gs(vt.paint_circle["circle-blur"]), "circle-opacity": new Gs(vt.paint_circle["circle-opacity"]), "circle-translate": new qs(vt.paint_circle["circle-translate"]), "circle-translate-anchor": new qs(vt.paint_circle["circle-translate-anchor"]), "circle-pitch-scale": new qs(vt.paint_circle["circle-pitch-scale"]), "circle-pitch-alignment": new qs(vt.paint_circle["circle-pitch-alignment"]), "circle-stroke-width": new Gs(vt.paint_circle["circle-stroke-width"]), "circle-stroke-color": new Gs(vt.paint_circle["circle-stroke-color"]), "circle-stroke-opacity": new Gs(vt.paint_circle["circle-stroke-opacity"]) });
+      }, get layout() {
+        return pl2 = pl2 || new Hs({ "circle-sort-key": new Gs(vt.layout_circle["circle-sort-key"]) });
+      } };
+      class yl extends Ws {
+        constructor(t3, e3) {
+          super(t3, dl2, e3);
+        }
+        createBucket(t3) {
+          return new qa2(t3);
+        }
+        queryRadius(t3) {
+          const e3 = t3;
+          return nl2("circle-radius", this, e3) + nl2("circle-stroke-width", this, e3) + rl2(this.paint.get("circle-translate"));
+        }
+        queryIntersectsFeature({ queryGeometry: t3, feature: e3, featureState: n3, geometry: r3, transform: i3, pixelsToTileUnits: s3, unwrappedTileID: o3, getElevation: a3 }) {
+          const l3 = il2(t3, this.paint.get("circle-translate"), this.paint.get("circle-translate-anchor"), -i3.bearingInRadians, s3), u3 = this.paint.get("circle-radius").evaluate(e3, n3) + this.paint.get("circle-stroke-width").evaluate(e3, n3), c3 = this.paint.get("circle-pitch-scale"), h3 = this.paint.get("circle-pitch-alignment");
+          let p3, f3;
+          return "map" === h3 ? (p3 = l3, f3 = u3 * s3) : (p3 = function(t4, e4, n4, r4) {
+            return t4.map((t5) => hl2(t5, e4, n4, r4));
+          }(l3, i3, o3, a3), f3 = u3), cl2({ queryGeometry: p3, size: f3, transform: i3, unwrappedTileID: o3, getElevation: a3, pitchAlignment: h3, pitchScale: c3 }, r3);
+        }
+      }
+      class ml2 extends qa2 {
+      }
+      let gl2;
+      ps("HeatmapBucket", ml2, { omit: ["layers"] });
+      var xl = { get paint() {
+        return gl2 = gl2 || new Hs({ "heatmap-radius": new Gs(vt.paint_heatmap["heatmap-radius"]), "heatmap-weight": new Gs(vt.paint_heatmap["heatmap-weight"]), "heatmap-intensity": new qs(vt.paint_heatmap["heatmap-intensity"]), "heatmap-color": new Zs(vt.paint_heatmap["heatmap-color"]), "heatmap-opacity": new qs(vt.paint_heatmap["heatmap-opacity"]) });
+      } };
+      function vl(t3, { width: e3, height: n3 }, r3, i3) {
+        if (i3) {
+          if (i3 instanceof Uint8ClampedArray) i3 = new Uint8Array(i3.buffer);
+          else if (i3.length !== e3 * n3 * r3) throw new RangeError(`mismatched image size. expected: ${i3.length} but got: ${e3 * n3 * r3}`);
+        } else i3 = new Uint8Array(e3 * n3 * r3);
+        return t3.width = e3, t3.height = n3, t3.data = i3, t3;
+      }
+      function bl2(t3, { width: e3, height: n3 }, r3) {
+        if (e3 === t3.width && n3 === t3.height) return;
+        const i3 = vl({}, { width: e3, height: n3 }, r3);
+        wl(t3, i3, { x: 0, y: 0 }, { x: 0, y: 0 }, { width: Math.min(t3.width, e3), height: Math.min(t3.height, n3) }, r3), t3.width = e3, t3.height = n3, t3.data = i3.data;
+      }
+      function wl(t3, e3, n3, r3, i3, s3) {
+        if (0 === i3.width || 0 === i3.height) return e3;
+        if (i3.width > t3.width || i3.height > t3.height || n3.x > t3.width - i3.width || n3.y > t3.height - i3.height) throw new RangeError("out of range source coordinates for image copy");
+        if (i3.width > e3.width || i3.height > e3.height || r3.x > e3.width - i3.width || r3.y > e3.height - i3.height) throw new RangeError("out of range destination coordinates for image copy");
+        const o3 = t3.data, a3 = e3.data;
+        if (o3 === a3) throw new Error("srcData equals dstData, so image is already copied");
+        for (let l3 = 0; l3 < i3.height; l3++) {
+          const u3 = ((n3.y + l3) * t3.width + n3.x) * s3, c3 = ((r3.y + l3) * e3.width + r3.x) * s3;
+          for (let t4 = 0; t4 < i3.width * s3; t4++) a3[c3 + t4] = o3[u3 + t4];
+        }
+        return e3;
+      }
+      class _l2 {
+        constructor(t3, e3) {
+          vl(this, t3, 1, e3);
+        }
+        resize(t3) {
+          bl2(this, t3, 1);
+        }
+        clone() {
+          return new _l2({ width: this.width, height: this.height }, new Uint8Array(this.data));
+        }
+        static copy(t3, e3, n3, r3, i3) {
+          wl(t3, e3, n3, r3, i3, 1);
+        }
+      }
+      class Sl {
+        constructor(t3, e3) {
+          vl(this, t3, 4, e3);
+        }
+        resize(t3) {
+          bl2(this, t3, 4);
+        }
+        replace(t3, e3) {
+          e3 ? this.data.set(t3) : this.data = t3 instanceof Uint8ClampedArray ? new Uint8Array(t3.buffer) : t3;
+        }
+        clone() {
+          return new Sl({ width: this.width, height: this.height }, new Uint8Array(this.data));
+        }
+        static copy(t3, e3, n3, r3, i3) {
+          wl(t3, e3, n3, r3, i3, 4);
+        }
+        setPixel(t3, e3, n3) {
+          const r3 = 4 * (t3 * this.width + e3);
+          this.data[r3 + 0] = Math.round(255 * n3.r / n3.a), this.data[r3 + 1] = Math.round(255 * n3.g / n3.a), this.data[r3 + 2] = Math.round(255 * n3.b / n3.a), this.data[r3 + 3] = Math.round(255 * n3.a);
+        }
+      }
+      function Al(t3) {
+        const e3 = new Uint8Array(t3.length);
+        for (let n3 = 0; n3 < t3.length; n3 += 4) {
+          const r3 = t3[n3 + 3];
+          e3[n3 + 0] = Math.round(t3[n3 + 0] * r3 / 255), e3[n3 + 1] = Math.round(t3[n3 + 1] * r3 / 255), e3[n3 + 2] = Math.round(t3[n3 + 2] * r3 / 255), e3[n3 + 3] = r3;
+        }
+        return e3;
+      }
+      function Ml(t3) {
+        const e3 = {}, n3 = t3.resolution || 256, r3 = t3.clips ? t3.clips.length : 1, i3 = t3.image || new Sl({ width: n3, height: r3 });
+        if (Math.log(n3) / Math.LN2 % 1 != 0) throw new Error(`width is not a power of 2 - ${n3}`);
+        const s3 = (r4, s4, o3) => {
+          e3[t3.evaluationKey] = o3;
+          const a3 = t3.expression.evaluate(e3);
+          i3.setPixel(r4 / 4 / n3, s4 / 4, a3);
+        };
+        if (t3.clips) for (let e4 = 0, i4 = 0; e4 < r3; ++e4, i4 += 4 * n3) for (let r4 = 0, o3 = 0; r4 < n3; r4++, o3 += 4) {
+          const a3 = r4 / (n3 - 1), { start: l3, end: u3 } = t3.clips[e4];
+          s3(i4, o3, l3 * (1 - a3) + u3 * a3);
+        }
+        else for (let t4 = 0, e4 = 0; t4 < n3; t4++, e4 += 4) s3(0, e4, t4 / (n3 - 1));
+        return i3;
+      }
+      ps("AlphaImage", _l2), ps("RGBAImage", Sl);
+      const kl2 = "big-fb";
+      class Il extends Ws {
+        createBucket(t3) {
+          return new ml2(t3);
+        }
+        constructor(t3, e3) {
+          super(t3, xl, e3), this.heatmapFbos = /* @__PURE__ */ new Map(), this._updateColorRamp();
+        }
+        _handleSpecialPaintPropertyUpdate(t3) {
+          "heatmap-color" === t3 && this._updateColorRamp();
+        }
+        _updateColorRamp() {
+          this.colorRamp = Ml({ expression: this._transitionablePaint._values["heatmap-color"].value.expression, evaluationKey: "heatmapDensity", image: this.colorRamp }), this.colorRampTexture = null;
+        }
+        resize() {
+          this.heatmapFbos.has(kl2) && this.heatmapFbos.delete(kl2);
+        }
+        queryRadius(t3) {
+          return nl2("heatmap-radius", this, t3);
+        }
+        queryIntersectsFeature({ queryGeometry: t3, feature: e3, featureState: n3, geometry: r3, transform: i3, pixelsToTileUnits: s3, unwrappedTileID: o3, getElevation: a3 }) {
+          return cl2({ queryGeometry: t3, size: this.paint.get("heatmap-radius").evaluate(e3, n3) * s3, transform: i3, unwrappedTileID: o3, getElevation: a3 }, r3);
+        }
+        hasOffscreenPass() {
+          return 0 !== this.paint.get("heatmap-opacity") && !this.isHidden();
+        }
+      }
+      let El;
+      var Tl = { get paint() {
+        return El = El || new Hs({ "hillshade-illumination-direction": new qs(vt.paint_hillshade["hillshade-illumination-direction"]), "hillshade-illumination-altitude": new qs(vt.paint_hillshade["hillshade-illumination-altitude"]), "hillshade-illumination-anchor": new qs(vt.paint_hillshade["hillshade-illumination-anchor"]), "hillshade-exaggeration": new qs(vt.paint_hillshade["hillshade-exaggeration"]), "hillshade-shadow-color": new qs(vt.paint_hillshade["hillshade-shadow-color"]), "hillshade-highlight-color": new qs(vt.paint_hillshade["hillshade-highlight-color"]), "hillshade-accent-color": new qs(vt.paint_hillshade["hillshade-accent-color"]), "hillshade-method": new qs(vt.paint_hillshade["hillshade-method"]), resampling: new qs(vt.paint_hillshade.resampling) });
+      } };
+      class Fl extends Ws {
+        constructor(t3, e3) {
+          super(t3, Tl, e3), this.recalculate({ zoom: 0, zoomHistory: {} }, void 0);
+        }
+        getIlluminationProperties() {
+          let t3 = this.paint.get("hillshade-illumination-direction").values, e3 = this.paint.get("hillshade-illumination-altitude").values, n3 = this.paint.get("hillshade-highlight-color").values, r3 = this.paint.get("hillshade-shadow-color").values;
+          const i3 = Math.max(t3.length, e3.length, n3.length, r3.length);
+          t3 = t3.concat(Array(i3 - t3.length).fill(t3.at(-1))), e3 = e3.concat(Array(i3 - e3.length).fill(e3.at(-1))), n3 = n3.concat(Array(i3 - n3.length).fill(n3.at(-1))), r3 = r3.concat(Array(i3 - r3.length).fill(r3.at(-1)));
+          const s3 = e3.map(tt2);
+          return { directionRadians: t3.map(tt2), altitudeRadians: s3, shadowColor: r3, highlightColor: n3 };
+        }
+        hasOffscreenPass() {
+          return 0 !== this.paint.get("hillshade-exaggeration") && !this.isHidden();
+        }
+      }
+      let Dl;
+      var Pl = { get paint() {
+        return Dl = Dl || new Hs({ "color-relief-opacity": new qs(vt["paint_color-relief"]["color-relief-opacity"]), "color-relief-color": new Zs(vt["paint_color-relief"]["color-relief-color"]), resampling: new qs(vt["paint_color-relief"].resampling) });
+      } };
+      function zl(t3) {
+        return "data" in t3;
+      }
+      class Bl {
+        constructor(t3, e3, n3, r3) {
+          this.context = t3, this.format = n3, this.texture = t3.gl.createTexture(), this._ownedHandle = this.texture, this.update(e3, r3);
+        }
+        update(t3, e3, n3) {
+          const { width: r3, height: i3 } = t3, s3 = !(this.size && this.size[0] === r3 && this.size[1] === i3 || n3), { context: o3 } = this, { gl: a3 } = o3;
+          this.useMipmap = Boolean(e3 && e3.useMipmap), a3.bindTexture(a3.TEXTURE_2D, this.texture), o3.pixelStoreUnpackFlipY.set(false), o3.pixelStoreUnpack.set(1);
+          const l3 = this.format === a3.RGBA && (!e3 || false !== e3.premultiply);
+          if (s3) this.size = [r3, i3], zl(t3) ? (o3.pixelStoreUnpackPremultiplyAlpha.set(false), this._uploadRawData(t3, l3, r3, i3, a3)) : (o3.pixelStoreUnpackPremultiplyAlpha.set(l3), this._uploadDomImage(t3, a3));
+          else {
+            const { x: e4, y: s4 } = n3 || { x: 0, y: 0 };
+            zl(t3) ? (o3.pixelStoreUnpackPremultiplyAlpha.set(false), this._updateRawData(t3, l3, e4, s4, r3, i3, a3)) : (o3.pixelStoreUnpackPremultiplyAlpha.set(l3), this._updateDomImage(t3, e4, s4, a3));
+          }
+          this.useMipmap && this.isSizePowerOfTwo() && a3.generateMipmap(a3.TEXTURE_2D), o3.pixelStoreUnpackFlipY.setDefault(), o3.pixelStoreUnpack.setDefault(), o3.pixelStoreUnpackPremultiplyAlpha.setDefault();
+        }
+        _uploadDomImage(t3, e3) {
+          e3.texImage2D(e3.TEXTURE_2D, 0, this.format, this.format, e3.UNSIGNED_BYTE, t3);
+        }
+        _uploadRawData(t3, e3, n3, r3, i3) {
+          let { data: s3 } = t3;
+          e3 && s3 && (s3 = Al(s3)), i3.texImage2D(i3.TEXTURE_2D, 0, this.format, n3, r3, 0, this.format, i3.UNSIGNED_BYTE, s3);
+        }
+        _updateDomImage(t3, e3, n3, r3) {
+          r3.texSubImage2D(r3.TEXTURE_2D, 0, e3, n3, r3.RGBA, r3.UNSIGNED_BYTE, t3);
+        }
+        _updateRawData(t3, e3, n3, r3, i3, s3, o3) {
+          let { data: a3 } = t3;
+          e3 && a3 && (a3 = Al(a3)), o3.texSubImage2D(o3.TEXTURE_2D, 0, n3, r3, i3, s3, o3.RGBA, o3.UNSIGNED_BYTE, a3);
+        }
+        bind(t3, e3, n3) {
+          const { context: r3 } = this, { gl: i3 } = r3;
+          this.texture !== this._ownedHandle && (this.texture = this._ownedHandle), i3.bindTexture(i3.TEXTURE_2D, this.texture), n3 !== i3.LINEAR_MIPMAP_NEAREST || this.isSizePowerOfTwo() || (n3 = i3.LINEAR), t3 !== this.filter && (i3.texParameteri(i3.TEXTURE_2D, i3.TEXTURE_MAG_FILTER, t3), i3.texParameteri(i3.TEXTURE_2D, i3.TEXTURE_MIN_FILTER, n3 || t3), this.filter = t3), e3 !== this.wrap && (i3.texParameteri(i3.TEXTURE_2D, i3.TEXTURE_WRAP_S, e3), i3.texParameteri(i3.TEXTURE_2D, i3.TEXTURE_WRAP_T, e3), this.wrap = e3);
+        }
+        isSizePowerOfTwo() {
+          return this.size[0] === this.size[1] && Math.log(this.size[0]) / Math.LN2 % 1 == 0;
+        }
+        destroy() {
+          const { gl: t3 } = this.context;
+          t3.deleteTexture(this.texture), this.texture = null, this._ownedHandle = null;
+        }
+      }
+      class Cl {
+        constructor(t3, e3, n3, r3 = 1, i3 = 1, s3 = 1, o3 = 0) {
+          if (this.uid = t3, e3.height !== e3.width) throw new RangeError("DEM tiles must be square");
+          if (n3 && !["mapbox", "terrarium", "custom"].includes(n3)) return void q2(`"${n3}" is not a valid encoding type. Valid types include "mapbox", "terrarium" and "custom".`);
+          this.stride = e3.height;
+          const a3 = this.dim = e3.height - 2;
+          switch (this.data = new Uint32Array(e3.data.buffer), n3) {
+            case "terrarium":
+              this.redFactor = 256, this.greenFactor = 1, this.blueFactor = 1 / 256, this.baseShift = 32768;
+              break;
+            case "custom":
+              this.redFactor = r3, this.greenFactor = i3, this.blueFactor = s3, this.baseShift = o3;
+              break;
+            default:
+              this.redFactor = 6553.6, this.greenFactor = 25.6, this.blueFactor = 0.1, this.baseShift = 1e4;
+          }
+          for (let t4 = 0; t4 < a3; t4++) this.data[this._idx(-1, t4)] = this.data[this._idx(0, t4)], this.data[this._idx(a3, t4)] = this.data[this._idx(a3 - 1, t4)], this.data[this._idx(t4, -1)] = this.data[this._idx(t4, 0)], this.data[this._idx(t4, a3)] = this.data[this._idx(t4, a3 - 1)];
+          this.data[this._idx(-1, -1)] = this.data[this._idx(0, 0)], this.data[this._idx(a3, -1)] = this.data[this._idx(a3 - 1, 0)], this.data[this._idx(-1, a3)] = this.data[this._idx(0, a3 - 1)], this.data[this._idx(a3, a3)] = this.data[this._idx(a3 - 1, a3 - 1)], this.min = Number.MAX_SAFE_INTEGER, this.max = Number.MIN_SAFE_INTEGER;
+          for (let t4 = 0; t4 < a3; t4++) for (let e4 = 0; e4 < a3; e4++) {
+            const n4 = this.get(t4, e4);
+            n4 > this.max && (this.max = n4), n4 < this.min && (this.min = n4);
+          }
+        }
+        get(t3, e3) {
+          const n3 = new Uint8Array(this.data.buffer), r3 = 4 * this._idx(t3, e3);
+          return this.unpack(n3[r3], n3[r3 + 1], n3[r3 + 2]);
+        }
+        getUnpackVector() {
+          return [this.redFactor, this.greenFactor, this.blueFactor, this.baseShift];
+        }
+        _idx(t3, e3) {
+          if (t3 < -1 || t3 >= this.dim + 1 || e3 < -1 || e3 >= this.dim + 1) throw new RangeError(`Out of range source coordinates for DEM data. x: ${t3}, y: ${e3}, dim: ${this.dim}`);
+          return (e3 + 1) * this.stride + (t3 + 1);
+        }
+        unpack(t3, e3, n3) {
+          return t3 * this.redFactor + e3 * this.greenFactor + n3 * this.blueFactor - this.baseShift;
+        }
+        pack(t3) {
+          return Vl(t3, this.getUnpackVector());
+        }
+        getPixels() {
+          return new Sl({ width: this.stride, height: this.stride }, new Uint8Array(this.data.buffer));
+        }
+        backfillBorder(t3, e3, n3) {
+          if (this.dim !== t3.dim) throw new Error("dem dimension mismatch");
+          let r3 = e3 * this.dim, i3 = e3 * this.dim + this.dim, s3 = n3 * this.dim, o3 = n3 * this.dim + this.dim;
+          switch (e3) {
+            case -1:
+              r3 = i3 - 1;
+              break;
+            case 1:
+              i3 = r3 + 1;
+          }
+          switch (n3) {
+            case -1:
+              s3 = o3 - 1;
+              break;
+            case 1:
+              o3 = s3 + 1;
+          }
+          const a3 = -e3 * this.dim, l3 = -n3 * this.dim;
+          for (let e4 = s3; e4 < o3; e4++) for (let n4 = r3; n4 < i3; n4++) this.data[this._idx(n4, e4)] = t3.data[this._idx(n4 + a3, e4 + l3)];
+        }
+      }
+      function Vl(t3, e3) {
+        const n3 = e3[0], r3 = e3[1], i3 = e3[2], s3 = e3[3], o3 = Math.min(n3, r3, i3), a3 = Math.round((t3 + s3) / o3);
+        return { r: Math.floor(a3 * o3 / n3) % 256, g: Math.floor(a3 * o3 / r3) % 256, b: Math.floor(a3 * o3 / i3) % 256 };
+      }
+      ps("DEMData", Cl);
+      class Ll extends Ws {
+        constructor(t3, e3) {
+          super(t3, Pl, e3);
+        }
+        _createColorRamp(t3) {
+          const e3 = { elevationStops: [], colorStops: [] }, n3 = this._transitionablePaint._values["color-relief-color"].value.expression;
+          if (n3 instanceof ii2 && n3._styleExpression.expression instanceof dn) {
+            this.colorRampExpression = n3;
+            const t4 = n3._styleExpression.expression;
+            e3.elevationStops = t4.labels, e3.colorStops = [];
+            for (const n4 of e3.elevationStops) e3.colorStops.push(t4.evaluate({ globals: { elevation: n4 } }));
+          }
+          if (e3.elevationStops.length < 1 && (e3.elevationStops = [0], e3.colorStops = [Ie2.transparent]), e3.elevationStops.length < 2 && (e3.elevationStops.push(e3.elevationStops[0] + 1), e3.colorStops.push(e3.colorStops[0])), e3.elevationStops.length <= t3) return e3;
+          const r3 = { elevationStops: [], colorStops: [] }, i3 = (e3.elevationStops.length - 1) / (t3 - 1);
+          for (let t4 = 0; t4 < e3.elevationStops.length - 0.5; t4 += i3) r3.elevationStops.push(e3.elevationStops[Math.round(t4)]), r3.colorStops.push(e3.colorStops[Math.round(t4)]);
+          return q2(`Too many colors in specification of ${this.id} color-relief layer, may not render properly. Max possible colors: ${t3}, provided: ${e3.elevationStops.length}`), r3;
+        }
+        _colorRampChanged() {
+          return this.colorRampExpression != this._transitionablePaint._values["color-relief-color"].value.expression;
+        }
+        getColorRampTextures(t3, e3, n3) {
+          if (this.colorRampTextures && !this._colorRampChanged()) return this.colorRampTextures;
+          const r3 = this._createColorRamp(e3), i3 = new Sl({ width: r3.colorStops.length, height: 1 }), s3 = new Sl({ width: r3.colorStops.length, height: 1 });
+          for (let t4 = 0; t4 < r3.elevationStops.length; t4++) {
+            const e4 = Vl(r3.elevationStops[t4], n3);
+            s3.setPixel(0, t4, new Ie2(e4.r / 255, e4.g / 255, e4.b / 255, 1)), i3.setPixel(0, t4, r3.colorStops[t4]);
+          }
+          return this.colorRampTextures = { elevationTexture: new Bl(t3, s3, t3.gl.RGBA), colorTexture: new Bl(t3, i3, t3.gl.RGBA) }, this.colorRampTextures;
+        }
+        hasOffscreenPass() {
+          return !this.isHidden() && !!this.colorRampTextures;
+        }
+      }
+      const Ol = ro([{ name: "a_pos", components: 2, type: "Int16" }], 4), { members: $l } = Ol;
+      function Rl(t3, e3, n3) {
+        const r3 = n3.patternDependencies;
+        let i3 = false;
+        for (const n4 of e3) {
+          const e4 = n4.paint.get(`${t3}-pattern`);
+          e4.isConstant() || (i3 = true);
+          const s3 = e4.constantOr(null);
+          s3 && (i3 = true, r3[s3.to] = true, r3[s3.from] = true);
+        }
+        return i3;
+      }
+      function Nl(t3, e3, n3, r3, i3) {
+        const { zoom: s3 } = r3, o3 = i3.patternDependencies;
+        for (const r4 of e3) {
+          const e4 = r4.paint.get(`${t3}-pattern`).value;
+          if ("constant" !== e4.kind) {
+            let t4 = e4.evaluate({ zoom: s3 - 1 }, n3, {}, i3.availableImages), a3 = e4.evaluate({ zoom: s3 }, n3, {}, i3.availableImages), l3 = e4.evaluate({ zoom: s3 + 1 }, n3, {}, i3.availableImages);
+            t4 = t4 && t4.name ? t4.name : t4, a3 = a3 && a3.name ? a3.name : a3, l3 = l3 && l3.name ? l3.name : l3, o3[t4] = true, o3[a3] = true, o3[l3] = true, n3.patterns[r4.id] = { min: t4, mid: a3, max: l3 };
+          }
+        }
+        return n3;
+      }
+      function Ul(t3, e3, n3, r3, i3) {
+        let s3;
+        if (i3 === function(t4, e4, n4, r4) {
+          let i4 = 0;
+          for (let s4 = e4, o3 = n4 - r4; s4 < n4; s4 += r4) i4 += (t4[o3] - t4[s4]) * (t4[s4 + 1] + t4[o3 + 1]), o3 = s4;
+          return i4;
+        }(t3, e3, n3, r3) > 0) for (let i4 = e3; i4 < n3; i4 += r3) s3 = cu(i4 / r3 | 0, t3[i4], t3[i4 + 1], s3);
+        else for (let i4 = n3 - r3; i4 >= e3; i4 -= r3) s3 = cu(i4 / r3 | 0, t3[i4], t3[i4 + 1], s3);
+        return s3 && iu(s3, s3.next) && (hu(s3), s3 = s3.next), s3;
+      }
+      function jl2(t3, e3) {
+        if (!t3) return t3;
+        e3 || (e3 = t3);
+        let n3, r3 = t3;
+        do {
+          if (n3 = false, r3.steiner || !iu(r3, r3.next) && 0 !== ru(r3.prev, r3, r3.next)) r3 = r3.next;
+          else {
+            if (hu(r3), r3 = e3 = r3.prev, r3 === r3.next) break;
+            n3 = true;
+          }
+        } while (n3 || r3 !== e3);
+        return e3;
+      }
+      function ql2(t3, e3, n3, r3, i3, s3, o3) {
+        if (!t3) return;
+        !o3 && s3 && function(t4, e4, n4, r4) {
+          let i4 = t4;
+          do {
+            0 === i4.z && (i4.z = Jl(i4.x, i4.y, e4, n4, r4)), i4.prevZ = i4.prev, i4.nextZ = i4.next, i4 = i4.next;
+          } while (i4 !== t4);
+          i4.prevZ.nextZ = null, i4.prevZ = null, function(t5) {
+            let e5, n5 = 1;
+            do {
+              let r5, i5 = t5;
+              t5 = null;
+              let s4 = null;
+              for (e5 = 0; i5; ) {
+                e5++;
+                let o4 = i5, a4 = 0;
+                for (let t6 = 0; t6 < n5 && (a4++, o4 = o4.nextZ, o4); t6++) ;
+                let l3 = n5;
+                for (; a4 > 0 || l3 > 0 && o4; ) 0 !== a4 && (0 === l3 || !o4 || i5.z <= o4.z) ? (r5 = i5, i5 = i5.nextZ, a4--) : (r5 = o4, o4 = o4.nextZ, l3--), s4 ? s4.nextZ = r5 : t5 = r5, r5.prevZ = s4, s4 = r5;
+                i5 = o4;
+              }
+              s4.nextZ = null, n5 *= 2;
+            } while (e5 > 1);
+          }(i4);
+        }(t3, r3, i3, s3);
+        let a3 = t3;
+        for (; t3.prev !== t3.next; ) {
+          const l3 = t3.prev, u3 = t3.next;
+          if (s3 ? Xl(t3, r3, i3, s3) : Gl(t3)) e3.push(l3.i, t3.i, u3.i), hu(t3), t3 = u3.next, a3 = u3.next;
+          else if ((t3 = u3) === a3) {
+            o3 ? 1 === o3 ? ql2(t3 = Yl(jl2(t3), e3), e3, n3, r3, i3, s3, 2) : 2 === o3 && Zl(t3, e3, n3, r3, i3, s3) : ql2(jl2(t3), e3, n3, r3, i3, s3, 1);
+            break;
+          }
+        }
+      }
+      function Gl(t3) {
+        const e3 = t3.prev, n3 = t3, r3 = t3.next;
+        if (ru(e3, n3, r3) >= 0) return false;
+        const i3 = e3.x, s3 = n3.x, o3 = r3.x, a3 = e3.y, l3 = n3.y, u3 = r3.y, c3 = Math.min(i3, s3, o3), h3 = Math.min(a3, l3, u3), p3 = Math.max(i3, s3, o3), f3 = Math.max(a3, l3, u3);
+        let d3 = r3.next;
+        for (; d3 !== e3; ) {
+          if (d3.x >= c3 && d3.x <= p3 && d3.y >= h3 && d3.y <= f3 && eu(i3, a3, s3, l3, o3, u3, d3.x, d3.y) && ru(d3.prev, d3, d3.next) >= 0) return false;
+          d3 = d3.next;
+        }
+        return true;
+      }
+      function Xl(t3, e3, n3, r3) {
+        const i3 = t3.prev, s3 = t3, o3 = t3.next;
+        if (ru(i3, s3, o3) >= 0) return false;
+        const a3 = i3.x, l3 = s3.x, u3 = o3.x, c3 = i3.y, h3 = s3.y, p3 = o3.y, f3 = Math.min(a3, l3, u3), d3 = Math.min(c3, h3, p3), y3 = Math.max(a3, l3, u3), m3 = Math.max(c3, h3, p3), g3 = Jl(f3, d3, e3, n3, r3), x3 = Jl(y3, m3, e3, n3, r3);
+        let v3 = t3.prevZ, b3 = t3.nextZ;
+        for (; v3 && v3.z >= g3 && b3 && b3.z <= x3; ) {
+          if (v3.x >= f3 && v3.x <= y3 && v3.y >= d3 && v3.y <= m3 && v3 !== i3 && v3 !== o3 && eu(a3, c3, l3, h3, u3, p3, v3.x, v3.y) && ru(v3.prev, v3, v3.next) >= 0) return false;
+          if (v3 = v3.prevZ, b3.x >= f3 && b3.x <= y3 && b3.y >= d3 && b3.y <= m3 && b3 !== i3 && b3 !== o3 && eu(a3, c3, l3, h3, u3, p3, b3.x, b3.y) && ru(b3.prev, b3, b3.next) >= 0) return false;
+          b3 = b3.nextZ;
+        }
+        for (; v3 && v3.z >= g3; ) {
+          if (v3.x >= f3 && v3.x <= y3 && v3.y >= d3 && v3.y <= m3 && v3 !== i3 && v3 !== o3 && eu(a3, c3, l3, h3, u3, p3, v3.x, v3.y) && ru(v3.prev, v3, v3.next) >= 0) return false;
+          v3 = v3.prevZ;
+        }
+        for (; b3 && b3.z <= x3; ) {
+          if (b3.x >= f3 && b3.x <= y3 && b3.y >= d3 && b3.y <= m3 && b3 !== i3 && b3 !== o3 && eu(a3, c3, l3, h3, u3, p3, b3.x, b3.y) && ru(b3.prev, b3, b3.next) >= 0) return false;
+          b3 = b3.nextZ;
+        }
+        return true;
+      }
+      function Yl(t3, e3) {
+        let n3 = t3;
+        do {
+          const r3 = n3.prev, i3 = n3.next.next;
+          !iu(r3, i3) && su(r3, n3, n3.next, i3) && lu(r3, i3) && lu(i3, r3) && (e3.push(r3.i, n3.i, i3.i), hu(n3), hu(n3.next), n3 = t3 = i3), n3 = n3.next;
+        } while (n3 !== t3);
+        return jl2(n3);
+      }
+      function Zl(t3, e3, n3, r3, i3, s3) {
+        let o3 = t3;
+        do {
+          let t4 = o3.next.next;
+          for (; t4 !== o3.prev; ) {
+            if (o3.i !== t4.i && nu(o3, t4)) {
+              let a3 = uu(o3, t4);
+              return o3 = jl2(o3, o3.next), a3 = jl2(a3, a3.next), ql2(o3, e3, n3, r3, i3, s3, 0), void ql2(a3, e3, n3, r3, i3, s3, 0);
+            }
+            t4 = t4.next;
+          }
+          o3 = o3.next;
+        } while (o3 !== t3);
+      }
+      function Hl(t3, e3) {
+        let n3 = t3.x - e3.x;
+        return 0 === n3 && (n3 = t3.y - e3.y, 0 === n3) && (n3 = (t3.next.y - t3.y) / (t3.next.x - t3.x) - (e3.next.y - e3.y) / (e3.next.x - e3.x)), n3;
+      }
+      function Wl(t3, e3) {
+        const n3 = function(t4, e4) {
+          let n4 = e4;
+          const r4 = t4.x, i3 = t4.y;
+          let s3, o3 = -1 / 0;
+          if (iu(t4, n4)) return n4;
+          do {
+            if (iu(t4, n4.next)) return n4.next;
+            if (i3 <= n4.y && i3 >= n4.next.y && n4.next.y !== n4.y) {
+              const t5 = n4.x + (i3 - n4.y) * (n4.next.x - n4.x) / (n4.next.y - n4.y);
+              if (t5 <= r4 && t5 > o3 && (o3 = t5, s3 = n4.x < n4.next.x ? n4 : n4.next, t5 === r4)) return s3;
+            }
+            n4 = n4.next;
+          } while (n4 !== e4);
+          if (!s3) return null;
+          const a3 = s3, l3 = s3.x, u3 = s3.y;
+          let c3 = 1 / 0;
+          n4 = s3;
+          do {
+            if (r4 >= n4.x && n4.x >= l3 && r4 !== n4.x && tu(i3 < u3 ? r4 : o3, i3, l3, u3, i3 < u3 ? o3 : r4, i3, n4.x, n4.y)) {
+              const e5 = Math.abs(i3 - n4.y) / (r4 - n4.x);
+              lu(n4, t4) && (e5 < c3 || e5 === c3 && (n4.x > s3.x || n4.x === s3.x && Kl(s3, n4))) && (s3 = n4, c3 = e5);
+            }
+            n4 = n4.next;
+          } while (n4 !== a3);
+          return s3;
+        }(t3, e3);
+        if (!n3) return e3;
+        const r3 = uu(n3, t3);
+        return jl2(r3, r3.next), jl2(n3, n3.next);
+      }
+      function Kl(t3, e3) {
+        return ru(t3.prev, t3, e3.prev) < 0 && ru(e3.next, t3, t3.next) < 0;
+      }
+      function Jl(t3, e3, n3, r3, i3) {
+        return (t3 = 1431655765 & ((t3 = 858993459 & ((t3 = 252645135 & ((t3 = 16711935 & ((t3 = (t3 - n3) * i3 | 0) | t3 << 8)) | t3 << 4)) | t3 << 2)) | t3 << 1)) | (e3 = 1431655765 & ((e3 = 858993459 & ((e3 = 252645135 & ((e3 = 16711935 & ((e3 = (e3 - r3) * i3 | 0) | e3 << 8)) | e3 << 4)) | e3 << 2)) | e3 << 1)) << 1;
+      }
+      function Ql(t3) {
+        let e3 = t3, n3 = t3;
+        do {
+          (e3.x < n3.x || e3.x === n3.x && e3.y < n3.y) && (n3 = e3), e3 = e3.next;
+        } while (e3 !== t3);
+        return n3;
+      }
+      function tu(t3, e3, n3, r3, i3, s3, o3, a3) {
+        return (i3 - o3) * (e3 - a3) >= (t3 - o3) * (s3 - a3) && (t3 - o3) * (r3 - a3) >= (n3 - o3) * (e3 - a3) && (n3 - o3) * (s3 - a3) >= (i3 - o3) * (r3 - a3);
+      }
+      function eu(t3, e3, n3, r3, i3, s3, o3, a3) {
+        return !(t3 === o3 && e3 === a3) && tu(t3, e3, n3, r3, i3, s3, o3, a3);
+      }
+      function nu(t3, e3) {
+        return t3.next.i !== e3.i && t3.prev.i !== e3.i && !function(t4, e4) {
+          let n3 = t4;
+          do {
+            if (n3.i !== t4.i && n3.next.i !== t4.i && n3.i !== e4.i && n3.next.i !== e4.i && su(n3, n3.next, t4, e4)) return true;
+            n3 = n3.next;
+          } while (n3 !== t4);
+          return false;
+        }(t3, e3) && (lu(t3, e3) && lu(e3, t3) && function(t4, e4) {
+          let n3 = t4, r3 = false;
+          const i3 = (t4.x + e4.x) / 2, s3 = (t4.y + e4.y) / 2;
+          do {
+            n3.y > s3 != n3.next.y > s3 && n3.next.y !== n3.y && i3 < (n3.next.x - n3.x) * (s3 - n3.y) / (n3.next.y - n3.y) + n3.x && (r3 = !r3), n3 = n3.next;
+          } while (n3 !== t4);
+          return r3;
+        }(t3, e3) && (ru(t3.prev, t3, e3.prev) || ru(t3, e3.prev, e3)) || iu(t3, e3) && ru(t3.prev, t3, t3.next) > 0 && ru(e3.prev, e3, e3.next) > 0);
+      }
+      function ru(t3, e3, n3) {
+        return (e3.y - t3.y) * (n3.x - e3.x) - (e3.x - t3.x) * (n3.y - e3.y);
+      }
+      function iu(t3, e3) {
+        return t3.x === e3.x && t3.y === e3.y;
+      }
+      function su(t3, e3, n3, r3) {
+        const i3 = au(ru(t3, e3, n3)), s3 = au(ru(t3, e3, r3)), o3 = au(ru(n3, r3, t3)), a3 = au(ru(n3, r3, e3));
+        return i3 !== s3 && o3 !== a3 || !(0 !== i3 || !ou(t3, n3, e3)) || !(0 !== s3 || !ou(t3, r3, e3)) || !(0 !== o3 || !ou(n3, t3, r3)) || !(0 !== a3 || !ou(n3, e3, r3));
+      }
+      function ou(t3, e3, n3) {
+        return e3.x <= Math.max(t3.x, n3.x) && e3.x >= Math.min(t3.x, n3.x) && e3.y <= Math.max(t3.y, n3.y) && e3.y >= Math.min(t3.y, n3.y);
+      }
+      function au(t3) {
+        return t3 > 0 ? 1 : t3 < 0 ? -1 : 0;
+      }
+      function lu(t3, e3) {
+        return ru(t3.prev, t3, t3.next) < 0 ? ru(t3, e3, t3.next) >= 0 && ru(t3, t3.prev, e3) >= 0 : ru(t3, e3, t3.prev) < 0 || ru(t3, t3.next, e3) < 0;
+      }
+      function uu(t3, e3) {
+        const n3 = pu(t3.i, t3.x, t3.y), r3 = pu(e3.i, e3.x, e3.y), i3 = t3.next, s3 = e3.prev;
+        return t3.next = e3, e3.prev = t3, n3.next = i3, i3.prev = n3, r3.next = n3, n3.prev = r3, s3.next = r3, r3.prev = s3, r3;
+      }
+      function cu(t3, e3, n3, r3) {
+        const i3 = pu(t3, e3, n3);
+        return r3 ? (i3.next = r3.next, i3.prev = r3, r3.next.prev = i3, r3.next = i3) : (i3.prev = i3, i3.next = i3), i3;
+      }
+      function hu(t3) {
+        t3.next.prev = t3.prev, t3.prev.next = t3.next, t3.prevZ && (t3.prevZ.nextZ = t3.nextZ), t3.nextZ && (t3.nextZ.prevZ = t3.prevZ);
+      }
+      function pu(t3, e3, n3) {
+        return { i: t3, x: e3, y: n3, prev: null, next: null, z: 0, prevZ: null, nextZ: null, steiner: false };
+      }
+      class fu {
+        constructor(t3, e3) {
+          if (e3 > t3) throw new Error("Min granularity must not be greater than base granularity.");
+          this._baseZoomGranularity = t3, this._minGranularity = e3;
+        }
+        getGranularityForZoomLevel(t3) {
+          return Math.max(Math.floor(this._baseZoomGranularity / (1 << t3)), this._minGranularity, 1);
+        }
+      }
+      class du {
+        constructor(t3) {
+          this.fill = t3.fill, this.line = t3.line, this.tile = t3.tile, this.stencil = t3.stencil, this.circle = t3.circle;
+        }
+      }
+      du.noSubdivision = new du({ fill: new fu(0, 0), line: new fu(0, 0), tile: new fu(0, 0), stencil: new fu(0, 0), circle: 1 }), ps("SubdivisionGranularityExpression", fu), ps("SubdivisionGranularitySetting", du);
+      const yu = -32768, mu = 32767;
+      class gu {
+        constructor(t3, e3) {
+          this._vertexBuffer = [], this._vertexDictionary = /* @__PURE__ */ new Map(), this._used = false, this._granularity = t3, this._granularityCellSize = T2 / t3, this._canonical = e3;
+        }
+        _getKey(t3, e3) {
+          return (t3 += 32768) << 16 | e3 + 32768;
+        }
+        _vertexToIndex(t3, e3) {
+          if (t3 < -32768 || e3 < -32768 || t3 > 32767 || e3 > 32767) throw new Error("Vertex coordinates are out of signed 16 bit integer range.");
+          const n3 = 0 | Math.round(t3), r3 = 0 | Math.round(e3), i3 = this._getKey(n3, r3);
+          if (this._vertexDictionary.has(i3)) return this._vertexDictionary.get(i3);
+          const s3 = this._vertexBuffer.length / 2;
+          return this._vertexDictionary.set(i3, s3), this._vertexBuffer.push(n3, r3), s3;
+        }
+        _subdivideTrianglesScanline(t3) {
+          if (this._granularity < 2) return function(t4, e4) {
+            const n4 = [];
+            for (let r3 = 0; r3 < e4.length; r3 += 3) {
+              const i3 = e4[r3], s3 = e4[r3 + 1], o3 = e4[r3 + 2], a3 = t4[2 * i3], l3 = t4[2 * i3 + 1];
+              (t4[2 * s3] - a3) * (t4[2 * o3 + 1] - l3) - (t4[2 * s3 + 1] - l3) * (t4[2 * o3] - a3) > 0 ? (n4.push(i3), n4.push(o3), n4.push(s3)) : (n4.push(i3), n4.push(s3), n4.push(o3));
+            }
+            return n4;
+          }(this._vertexBuffer, t3);
+          const e3 = [], n3 = t3.length;
+          for (let r3 = 0; r3 < n3; r3 += 3) {
+            const n4 = [t3[r3 + 0], t3[r3 + 1], t3[r3 + 2]], i3 = [this._vertexBuffer[2 * t3[r3 + 0] + 0], this._vertexBuffer[2 * t3[r3 + 0] + 1], this._vertexBuffer[2 * t3[r3 + 1] + 0], this._vertexBuffer[2 * t3[r3 + 1] + 1], this._vertexBuffer[2 * t3[r3 + 2] + 0], this._vertexBuffer[2 * t3[r3 + 2] + 1]];
+            let s3 = 1 / 0, o3 = 1 / 0, a3 = -1 / 0, l3 = -1 / 0;
+            for (let t4 = 0; t4 < 3; t4++) {
+              const e4 = i3[2 * t4], n5 = i3[2 * t4 + 1];
+              s3 = Math.min(s3, e4), a3 = Math.max(a3, e4), o3 = Math.min(o3, n5), l3 = Math.max(l3, n5);
+            }
+            if (s3 === a3 || o3 === l3) continue;
+            const u3 = Math.floor(s3 / this._granularityCellSize), c3 = Math.ceil(a3 / this._granularityCellSize), h3 = Math.floor(o3 / this._granularityCellSize), p3 = Math.ceil(l3 / this._granularityCellSize);
+            if (u3 !== c3 || h3 !== p3) for (let t4 = h3; t4 < p3; t4++) {
+              const r4 = this._scanlineGenerateVertexRingForCellRow(t4, i3, n4);
+              bu(this._vertexBuffer, r4, e3);
+            }
+            else e3.push(...n4);
+          }
+          return e3;
+        }
+        _scanlineGenerateVertexRingForCellRow(t3, e3, n3) {
+          const r3 = t3 * this._granularityCellSize, i3 = r3 + this._granularityCellSize, s3 = [];
+          for (let t4 = 0; t4 < 3; t4++) {
+            const o3 = e3[2 * t4], a3 = e3[2 * t4 + 1], l3 = e3[2 * (t4 + 1) % 6], u3 = e3[(2 * (t4 + 1) + 1) % 6], c3 = e3[2 * (t4 + 2) % 6], h3 = e3[(2 * (t4 + 2) + 1) % 6], p3 = l3 - o3, f3 = u3 - a3, d3 = 0 === p3, y3 = 0 === f3, m3 = (r3 - a3) / f3, g3 = (i3 - a3) / f3, x3 = Math.min(m3, g3), v3 = Math.max(m3, g3);
+            if (!y3 && (x3 >= 1 || v3 <= 0) || y3 && (a3 < r3 || a3 > i3)) {
+              u3 >= r3 && u3 <= i3 && s3.push(n3[(t4 + 1) % 3]);
+              continue;
+            }
+            !y3 && x3 > 0 && s3.push(this._vertexToIndex(o3 + p3 * x3, a3 + f3 * x3));
+            const b3 = o3 + p3 * Math.max(x3, 0), w3 = o3 + p3 * Math.min(v3, 1);
+            d3 || this._generateIntraEdgeVertices(s3, o3, a3, l3, u3, b3, w3), !y3 && v3 < 1 && s3.push(this._vertexToIndex(o3 + p3 * v3, a3 + f3 * v3)), (y3 || u3 >= r3 && u3 <= i3) && s3.push(n3[(t4 + 1) % 3]), !y3 && (u3 <= r3 || u3 >= i3) && this._generateInterEdgeVertices(s3, o3, a3, l3, u3, c3, h3, w3, r3, i3);
+          }
+          return s3;
+        }
+        _generateIntraEdgeVertices(t3, e3, n3, r3, i3, s3, o3) {
+          const a3 = r3 - e3, l3 = i3 - n3, u3 = 0 === l3, c3 = u3 ? Math.min(e3, r3) : Math.min(s3, o3), h3 = u3 ? Math.max(e3, r3) : Math.max(s3, o3), p3 = Math.floor(c3 / this._granularityCellSize) + 1, f3 = Math.ceil(h3 / this._granularityCellSize) - 1;
+          if (u3 ? e3 < r3 : s3 < o3) for (let r4 = p3; r4 <= f3; r4++) {
+            const i4 = r4 * this._granularityCellSize;
+            t3.push(this._vertexToIndex(i4, n3 + l3 * (i4 - e3) / a3));
+          }
+          else for (let r4 = f3; r4 >= p3; r4--) {
+            const i4 = r4 * this._granularityCellSize;
+            t3.push(this._vertexToIndex(i4, n3 + l3 * (i4 - e3) / a3));
+          }
+        }
+        _generateInterEdgeVertices(t3, e3, n3, r3, i3, s3, o3, a3, l3, u3) {
+          const c3 = i3 - n3, h3 = s3 - r3, p3 = o3 - i3, f3 = (l3 - i3) / p3, d3 = (u3 - i3) / p3, y3 = Math.min(f3, d3), m3 = Math.max(f3, d3), g3 = r3 + h3 * y3;
+          let x3 = Math.floor(Math.min(g3, a3) / this._granularityCellSize) + 1, v3 = Math.ceil(Math.max(g3, a3) / this._granularityCellSize) - 1, b3 = a3 < g3;
+          const w3 = 0 === p3;
+          if (w3 && (o3 === l3 || o3 === u3)) return;
+          if (w3 || y3 >= 1 || m3 <= 0) {
+            const t4 = n3 - o3, r4 = s3 + (e3 - s3) * Math.min((l3 - o3) / t4, (u3 - o3) / t4);
+            x3 = Math.floor(Math.min(r4, a3) / this._granularityCellSize) + 1, v3 = Math.ceil(Math.max(r4, a3) / this._granularityCellSize) - 1, b3 = a3 < r4;
+          }
+          const _3 = c3 > 0 ? u3 : l3;
+          if (b3) for (let e4 = x3; e4 <= v3; e4++) t3.push(this._vertexToIndex(e4 * this._granularityCellSize, _3));
+          else for (let e4 = v3; e4 >= x3; e4--) t3.push(this._vertexToIndex(e4 * this._granularityCellSize, _3));
+        }
+        _generateOutline(t3) {
+          const e3 = [];
+          for (const n3 of t3) {
+            const t4 = vu(n3, this._granularity, true), r3 = this._pointArrayToIndices(t4), i3 = [];
+            for (let t5 = 1; t5 < r3.length; t5++) i3.push(r3[t5 - 1]), i3.push(r3[t5]);
+            e3.push(i3);
+          }
+          return e3;
+        }
+        _handlePoles(t3) {
+          let e3 = false, n3 = false;
+          this._canonical && (0 === this._canonical.y && (e3 = true), this._canonical.y === (1 << this._canonical.z) - 1 && (n3 = true)), (e3 || n3) && this._fillPoles(t3, e3, n3);
+        }
+        _ensureNoPoleVertices() {
+          const t3 = this._vertexBuffer;
+          for (let e3 = 0; e3 < t3.length; e3 += 2) {
+            const n3 = t3[e3 + 1];
+            n3 === yu && (t3[e3 + 1] = -32767), n3 === mu && (t3[e3 + 1] = 32766);
+          }
+        }
+        _generatePoleQuad(t3, e3, n3, r3, i3, s3) {
+          r3 > i3 != (s3 === yu) ? (t3.push(e3), t3.push(n3), t3.push(this._vertexToIndex(r3, s3)), t3.push(n3), t3.push(this._vertexToIndex(i3, s3)), t3.push(this._vertexToIndex(r3, s3))) : (t3.push(n3), t3.push(e3), t3.push(this._vertexToIndex(r3, s3)), t3.push(this._vertexToIndex(i3, s3)), t3.push(n3), t3.push(this._vertexToIndex(r3, s3)));
+        }
+        _fillPoles(t3, e3, n3) {
+          const r3 = this._vertexBuffer, i3 = T2, s3 = t3.length;
+          for (let o3 = 2; o3 < s3; o3 += 3) {
+            const s4 = t3[o3 - 2], a3 = t3[o3 - 1], l3 = t3[o3], u3 = r3[2 * s4], c3 = r3[2 * s4 + 1], h3 = r3[2 * a3], p3 = r3[2 * a3 + 1], f3 = r3[2 * l3], d3 = r3[2 * l3 + 1];
+            e3 && (0 === c3 && 0 === p3 && this._generatePoleQuad(t3, s4, a3, u3, h3, yu), 0 === p3 && 0 === d3 && this._generatePoleQuad(t3, a3, l3, h3, f3, yu), 0 === d3 && 0 === c3 && this._generatePoleQuad(t3, l3, s4, f3, u3, yu)), n3 && (c3 === i3 && p3 === i3 && this._generatePoleQuad(t3, s4, a3, u3, h3, mu), p3 === i3 && d3 === i3 && this._generatePoleQuad(t3, a3, l3, h3, f3, mu), d3 === i3 && c3 === i3 && this._generatePoleQuad(t3, l3, s4, f3, u3, mu));
+          }
+        }
+        _initializeVertices(t3) {
+          for (let e3 = 0; e3 < t3.length; e3 += 2) this._vertexToIndex(t3[e3], t3[e3 + 1]);
+        }
+        subdividePolygonInternal(t3, e3) {
+          if (this._used) throw new Error("Subdivision: multiple use not allowed.");
+          this._used = true;
+          const { flattened: n3, holeIndices: r3 } = function(t4) {
+            const e4 = [], n4 = [];
+            for (const r4 of t4) if (0 !== r4.length) {
+              r4 !== t4[0] && e4.push(n4.length / 2);
+              for (let t5 = 0; t5 < r4.length; t5++) n4.push(r4[t5].x), n4.push(r4[t5].y);
+            }
+            return { flattened: n4, holeIndices: e4 };
+          }(t3);
+          let i3;
+          this._initializeVertices(n3);
+          try {
+            const t4 = function(t5, e5, n4 = 2) {
+              const r4 = e5 && e5.length, i4 = r4 ? e5[0] * n4 : t5.length;
+              let s4 = Ul(t5, 0, i4, n4, true);
+              const o3 = [];
+              if (!s4 || s4.next === s4.prev) return o3;
+              let a3, l3, u3;
+              if (r4 && (s4 = function(t6, e6, n5, r5) {
+                const i5 = [];
+                for (let n6 = 0, s5 = e6.length; n6 < s5; n6++) {
+                  const o4 = Ul(t6, e6[n6] * r5, n6 < s5 - 1 ? e6[n6 + 1] * r5 : t6.length, r5, false);
+                  o4 === o4.next && (o4.steiner = true), i5.push(Ql(o4));
+                }
+                i5.sort(Hl);
+                for (let t7 = 0; t7 < i5.length; t7++) n5 = Wl(i5[t7], n5);
+                return n5;
+              }(t5, e5, s4, n4)), t5.length > 80 * n4) {
+                a3 = t5[0], l3 = t5[1];
+                let e6 = a3, r5 = l3;
+                for (let s5 = n4; s5 < i4; s5 += n4) {
+                  const n5 = t5[s5], i5 = t5[s5 + 1];
+                  n5 < a3 && (a3 = n5), i5 < l3 && (l3 = i5), n5 > e6 && (e6 = n5), i5 > r5 && (r5 = i5);
+                }
+                u3 = Math.max(e6 - a3, r5 - l3), u3 = 0 !== u3 ? 32767 / u3 : 0;
+              }
+              return ql2(s4, o3, n4, a3, l3, u3, 0), o3;
+            }(n3, r3), e4 = this._convertIndices(n3, t4);
+            i3 = this._subdivideTrianglesScanline(e4);
+          } catch (t4) {
+            console.error(t4);
+          }
+          let s3 = [];
+          return e3 && (s3 = this._generateOutline(t3)), this._ensureNoPoleVertices(), this._handlePoles(i3), { verticesFlattened: this._vertexBuffer, indicesTriangles: i3, indicesLineList: s3 };
+        }
+        _convertIndices(t3, e3) {
+          const n3 = [];
+          for (let r3 = 0; r3 < e3.length; r3++) n3.push(this._vertexToIndex(t3[2 * e3[r3]], t3[2 * e3[r3] + 1]));
+          return n3;
+        }
+        _pointArrayToIndices(t3) {
+          const e3 = [];
+          for (let n3 = 0; n3 < t3.length; n3++) {
+            const r3 = t3[n3];
+            e3.push(this._vertexToIndex(r3.x, r3.y));
+          }
+          return e3;
+        }
+      }
+      function xu(t3, e3, n3, r3 = true) {
+        return new gu(n3, e3).subdividePolygonInternal(t3, r3);
+      }
+      function vu(t3, e3, r3 = false) {
+        if (!t3 || t3.length < 1) return [];
+        if (t3.length < 2) return [];
+        const i3 = t3[0], s3 = t3[t3.length - 1], o3 = r3 && (i3.x !== s3.x || i3.y !== s3.y);
+        if (e3 < 2) return o3 ? [...t3, t3[0]] : [...t3];
+        const a3 = Math.floor(T2 / e3), l3 = [];
+        l3.push(new n2(t3[0].x, t3[0].y));
+        const u3 = t3.length, c3 = o3 ? u3 : u3 - 1;
+        for (let e4 = 0; e4 < c3; e4++) {
+          const r4 = t3[e4], i4 = e4 < u3 - 1 ? t3[e4 + 1] : t3[0], s4 = r4.x, o4 = r4.y, c4 = i4.x, h3 = i4.y, p3 = s4 !== c4, f3 = o4 !== h3;
+          if (!p3 && !f3) continue;
+          const d3 = c4 - s4, y3 = h3 - o4, m3 = Math.abs(d3), g3 = Math.abs(y3);
+          let x3 = s4, v3 = o4;
+          for (; ; ) {
+            const t4 = d3 > 0 ? (Math.floor(x3 / a3) + 1) * a3 : (Math.ceil(x3 / a3) - 1) * a3, e5 = y3 > 0 ? (Math.floor(v3 / a3) + 1) * a3 : (Math.ceil(v3 / a3) - 1) * a3, r5 = Math.abs(x3 - t4), i5 = Math.abs(v3 - e5), s5 = Math.abs(x3 - c4), o5 = Math.abs(v3 - h3), u4 = p3 ? r5 / m3 : Number.POSITIVE_INFINITY, b4 = f3 ? i5 / g3 : Number.POSITIVE_INFINITY;
+            if ((s5 <= r5 || !p3) && (o5 <= i5 || !f3)) break;
+            if (u4 < b4 && p3 || !f3) {
+              x3 = t4, v3 += y3 * u4;
+              const e6 = new n2(x3, Math.round(v3));
+              l3[l3.length - 1].x === e6.x && l3[l3.length - 1].y === e6.y || l3.push(e6);
+            } else {
+              x3 += d3 * b4, v3 = e5;
+              const t5 = new n2(Math.round(x3), v3);
+              l3[l3.length - 1].x === t5.x && l3[l3.length - 1].y === t5.y || l3.push(t5);
+            }
+          }
+          const b3 = new n2(c4, h3);
+          l3[l3.length - 1].x === b3.x && l3[l3.length - 1].y === b3.y || l3.push(b3);
+        }
+        return l3;
+      }
+      function bu(t3, e3, n3) {
+        if (0 === e3.length) throw new Error("Subdivision vertex ring is empty.");
+        let r3 = 0, i3 = t3[2 * e3[0]];
+        for (let n4 = 1; n4 < e3.length; n4++) {
+          const s4 = t3[2 * e3[n4]];
+          s4 < i3 && (i3 = s4, r3 = n4);
+        }
+        const s3 = e3.length;
+        let o3 = r3, a3 = (o3 + 1) % s3;
+        for (; ; ) {
+          const r4 = o3 - 1 >= 0 ? o3 - 1 : s3 - 1, i4 = (a3 + 1) % s3, l3 = t3[2 * e3[r4]], u3 = t3[2 * e3[i4]], c3 = t3[2 * e3[o3]], h3 = t3[2 * e3[o3] + 1], p3 = t3[2 * e3[a3] + 1];
+          let f3 = false;
+          if (l3 < u3) f3 = true;
+          else if (l3 > u3) f3 = false;
+          else {
+            const n4 = p3 - h3, s4 = -(t3[2 * e3[a3]] - c3), o4 = h3 < p3 ? 1 : -1;
+            ((l3 - c3) * n4 + (t3[2 * e3[r4] + 1] - h3) * s4) * o4 > ((u3 - c3) * n4 + (t3[2 * e3[i4] + 1] - h3) * s4) * o4 && (f3 = true);
+          }
+          if (f3) {
+            const t4 = e3[r4], i5 = e3[o3], l4 = e3[a3];
+            t4 !== i5 && t4 !== l4 && i5 !== l4 && n3.push(l4, i5, t4), o3--, o3 < 0 && (o3 = s3 - 1);
+          } else {
+            const t4 = e3[i4], r5 = e3[o3], l4 = e3[a3];
+            t4 !== r5 && t4 !== l4 && r5 !== l4 && n3.push(l4, r5, t4), a3++, a3 >= s3 && (a3 = 0);
+          }
+          if (r4 === i4) break;
+        }
+      }
+      function wu(t3, e3, n3, r3, i3, s3, o3, a3, l3) {
+        const u3 = i3.length / 2, c3 = o3 && a3 && l3;
+        if (u3 < sa2.MAX_VERTEX_ARRAY_LENGTH) {
+          const h3 = e3.prepareSegment(u3, n3, r3), p3 = h3.vertexLength;
+          for (let t4 = 0; t4 < s3.length; t4 += 3) r3.emplaceBack(p3 + s3[t4], p3 + s3[t4 + 1], p3 + s3[t4 + 2]);
+          let f3, d3;
+          h3.vertexLength += u3, h3.primitiveLength += s3.length / 3, c3 && (d3 = o3.prepareSegment(u3, n3, a3), f3 = d3.vertexLength, d3.vertexLength += u3);
+          for (let e4 = 0; e4 < i3.length; e4 += 2) t3(i3[e4], i3[e4 + 1]);
+          if (c3) for (let t4 = 0; t4 < l3.length; t4++) {
+            const e4 = l3[t4];
+            for (let t5 = 1; t5 < e4.length; t5 += 2) a3.emplaceBack(f3 + e4[t5 - 1], f3 + e4[t5]);
+            d3.primitiveLength += e4.length / 2;
+          }
+        } else !function(t4, e4, n4, r4, i4, s4) {
+          const o4 = [];
+          for (let t5 = 0; t5 < r4.length / 2; t5++) o4.push(-1);
+          const a4 = { count: 0 };
+          let l4 = 0, u4 = t4.getOrCreateLatestSegment(e4, n4), c4 = u4.vertexLength;
+          for (let h3 = 2; h3 < i4.length; h3 += 3) {
+            const p3 = i4[h3 - 2], f3 = i4[h3 - 1], d3 = i4[h3];
+            let y3 = o4[p3] < l4, m3 = o4[f3] < l4, g3 = o4[d3] < l4;
+            u4.vertexLength + ((y3 ? 1 : 0) + (m3 ? 1 : 0) + (g3 ? 1 : 0)) > sa2.MAX_VERTEX_ARRAY_LENGTH && (u4 = t4.createNewSegment(e4, n4), l4 = a4.count, y3 = true, m3 = true, g3 = true, c4 = 0);
+            const x3 = _u2(o4, r4, s4, a4, p3, y3, u4), v3 = _u2(o4, r4, s4, a4, f3, m3, u4), b3 = _u2(o4, r4, s4, a4, d3, g3, u4);
+            n4.emplaceBack(c4 + x3 - l4, c4 + v3 - l4, c4 + b3 - l4), u4.primitiveLength++;
+          }
+        }(e3, n3, r3, i3, s3, t3), c3 && function(t4, e4, n4, r4, i4, s4) {
+          const o4 = [];
+          for (let t5 = 0; t5 < r4.length / 2; t5++) o4.push(-1);
+          const a4 = { count: 0 };
+          let l4 = 0, u4 = t4.getOrCreateLatestSegment(e4, n4), c4 = u4.vertexLength;
+          for (let h3 = 0; h3 < i4.length; h3++) {
+            const p3 = i4[h3];
+            for (let f3 = 1; f3 < i4[h3].length; f3 += 2) {
+              const i5 = p3[f3 - 1], h4 = p3[f3];
+              let d3 = o4[i5] < l4, y3 = o4[h4] < l4;
+              u4.vertexLength + ((d3 ? 1 : 0) + (y3 ? 1 : 0)) > sa2.MAX_VERTEX_ARRAY_LENGTH && (u4 = t4.createNewSegment(e4, n4), l4 = a4.count, d3 = true, y3 = true, c4 = 0);
+              const m3 = _u2(o4, r4, s4, a4, i5, d3, u4), g3 = _u2(o4, r4, s4, a4, h4, y3, u4);
+              n4.emplaceBack(c4 + m3 - l4, c4 + g3 - l4), u4.primitiveLength++;
+            }
+          }
+        }(o3, n3, a3, i3, l3, t3), e3.forceNewSegmentOnNextPrepare(), null == o3 || o3.forceNewSegmentOnNextPrepare();
+      }
+      function _u2(t3, e3, n3, r3, i3, s3, o3) {
+        if (s3) {
+          const s4 = r3.count;
+          return n3(e3[2 * i3], e3[2 * i3 + 1]), t3[i3] = r3.count, r3.count++, o3.vertexLength++, s4;
+        }
+        return t3[i3];
+      }
+      class Su {
+        constructor(t3) {
+          this.zoom = t3.zoom, this.overscaling = t3.overscaling, this.layers = t3.layers, this.layerIds = this.layers.map((t4) => t4.id), this.index = t3.index, this.hasDependencies = false, this.patternFeatures = [], this.layoutVertexArray = new qo(), this.indexArray = new ea2(), this.indexArray2 = new na(), this.programConfigurations = new Ca2(t3.layers, t3.zoom), this.segments = new sa2(), this.segments2 = new sa2(), this.stateDependentLayerIds = this.layers.filter((t4) => t4.isStateDependent()).map((t4) => t4.id);
+        }
+        populate(t3, e3, n3) {
+          this.hasDependencies = Rl("fill", this.layers, e3);
+          const r3 = this.layers[0].layout.get("fill-sort-key"), i3 = !r3.isConstant(), s3 = [];
+          for (const { feature: o3, id: a3, index: l3, sourceLayerIndex: u3 } of t3) {
+            const t4 = this.layers[0]._featureFilter.needGeometry, c3 = Na2(o3, t4);
+            if (!this.layers[0]._featureFilter.filter(new zs(this.zoom), c3, n3)) continue;
+            const h3 = i3 ? r3.evaluate(c3, {}, n3, e3.availableImages) : void 0, p3 = { id: a3, properties: o3.properties, type: o3.type, sourceLayerIndex: u3, index: l3, geometry: t4 ? c3.geometry : Ra2(o3), patterns: {}, sortKey: h3 };
+            s3.push(p3);
+          }
+          i3 && s3.sort((t4, e4) => t4.sortKey - e4.sortKey);
+          for (const r4 of s3) {
+            const { geometry: i4, index: s4, sourceLayerIndex: o3 } = r4;
+            if (this.hasDependencies) {
+              const t4 = Nl("fill", this.layers, r4, { zoom: this.zoom }, e3);
+              this.patternFeatures.push(t4);
+            } else this.addFeature(r4, i4, s4, n3, {}, e3.subdivisionGranularity);
+            e3.featureIndex.insert(t3[s4].feature, i4, s4, o3, this.index);
+          }
+        }
+        update(t3, e3, n3) {
+          this.stateDependentLayers.length && this.programConfigurations.updatePaintArrays(t3, e3, this.stateDependentLayers, { imagePositions: n3 });
+        }
+        addFeatures(t3, e3, n3) {
+          for (const r3 of this.patternFeatures) this.addFeature(r3, r3.geometry, r3.index, e3, n3, t3.subdivisionGranularity);
+        }
+        isEmpty() {
+          return 0 === this.layoutVertexArray.length;
+        }
+        uploadPending() {
+          return !this.uploaded || this.programConfigurations.needsUpload;
+        }
+        upload(t3) {
+          this.uploaded || (this.layoutVertexBuffer = t3.createVertexBuffer(this.layoutVertexArray, $l), this.indexBuffer = t3.createIndexBuffer(this.indexArray), this.indexBuffer2 = t3.createIndexBuffer(this.indexArray2)), this.programConfigurations.upload(t3), this.uploaded = true;
+        }
+        destroy() {
+          this.layoutVertexBuffer && (this.layoutVertexBuffer.destroy(), this.indexBuffer.destroy(), this.indexBuffer2.destroy(), this.programConfigurations.destroy(), this.segments.destroy(), this.segments2.destroy());
+        }
+        addFeature(t3, e3, n3, r3, i3, s3) {
+          for (const t4 of er(e3, 500)) {
+            const e4 = xu(t4, r3, s3.fill.getGranularityForZoomLevel(r3.z)), n4 = this.layoutVertexArray;
+            wu((t5, e5) => {
+              n4.emplaceBack(t5, e5);
+            }, this.segments, this.layoutVertexArray, this.indexArray, e4.verticesFlattened, e4.indicesTriangles, this.segments2, this.indexArray2, e4.indicesLineList);
+          }
+          this.programConfigurations.populatePaintArrays(this.layoutVertexArray.length, t3, n3, { imagePositions: i3, canonical: r3 });
+        }
+      }
+      let Au, Mu;
+      ps("FillBucket", Su, { omit: ["layers", "patternFeatures"] });
+      var ku = { get paint() {
+        return Mu = Mu || new Hs({ "fill-antialias": new qs(vt.paint_fill["fill-antialias"]), "fill-opacity": new Gs(vt.paint_fill["fill-opacity"]), "fill-color": new Gs(vt.paint_fill["fill-color"]), "fill-outline-color": new Gs(vt.paint_fill["fill-outline-color"]), "fill-translate": new qs(vt.paint_fill["fill-translate"]), "fill-translate-anchor": new qs(vt.paint_fill["fill-translate-anchor"]), "fill-pattern": new Xs(vt.paint_fill["fill-pattern"]) });
+      }, get layout() {
+        return Au = Au || new Hs({ "fill-sort-key": new Gs(vt.layout_fill["fill-sort-key"]) });
+      } };
+      class Iu extends Ws {
+        constructor(t3, e3) {
+          super(t3, ku, e3);
+        }
+        recalculate(t3, e3) {
+          super.recalculate(t3, e3);
+          const n3 = this.paint._values["fill-outline-color"];
+          "constant" === n3.value.kind && void 0 === n3.value.value && (this.paint._values["fill-outline-color"] = this.paint._values["fill-color"]);
+        }
+        createBucket(t3) {
+          return new Su(t3);
+        }
+        queryRadius() {
+          return rl2(this.paint.get("fill-translate"));
+        }
+        queryIntersectsFeature({ queryGeometry: t3, geometry: e3, transform: n3, pixelsToTileUnits: r3 }) {
+          return Ya2(il2(t3, this.paint.get("fill-translate"), this.paint.get("fill-translate-anchor"), -n3.bearingInRadians, r3), e3);
+        }
+        isTileClipped() {
+          return true;
+        }
+      }
+      const Eu = ro([{ name: "a_pos", components: 2, type: "Int16" }, { name: "a_normal_ed", components: 4, type: "Int16" }], 4), Tu = ro([{ name: "a_centroid", components: 2, type: "Int16" }], 4), { members: Fu } = Eu;
+      class Du {
+        constructor(t3, e3, n3, r3, i3) {
+          this.properties = {}, this.extent = n3, this.type = 0, this.id = void 0, this._pbf = t3, this._geometry = -1, this._keys = r3, this._values = i3, t3.readFields(Pu, this, e3);
+        }
+        loadGeometry() {
+          const t3 = this._pbf;
+          t3.pos = this._geometry;
+          const e3 = t3.readVarint() + t3.pos, r3 = [];
+          let i3, s3 = 1, o3 = 0, a3 = 0, l3 = 0;
+          for (; t3.pos < e3; ) {
+            if (o3 <= 0) {
+              const e4 = t3.readVarint();
+              s3 = 7 & e4, o3 = e4 >> 3;
+            }
+            if (o3--, 1 === s3 || 2 === s3) a3 += t3.readSVarint(), l3 += t3.readSVarint(), 1 === s3 && (i3 && r3.push(i3), i3 = []), i3 && i3.push(new n2(a3, l3));
+            else {
+              if (7 !== s3) throw new Error(`unknown command ${s3}`);
+              i3 && i3.push(i3[0].clone());
+            }
+          }
+          return i3 && r3.push(i3), r3;
+        }
+        bbox() {
+          const t3 = this._pbf;
+          t3.pos = this._geometry;
+          const e3 = t3.readVarint() + t3.pos;
+          let n3 = 1, r3 = 0, i3 = 0, s3 = 0, o3 = 1 / 0, a3 = -1 / 0, l3 = 1 / 0, u3 = -1 / 0;
+          for (; t3.pos < e3; ) {
+            if (r3 <= 0) {
+              const e4 = t3.readVarint();
+              n3 = 7 & e4, r3 = e4 >> 3;
+            }
+            if (r3--, 1 === n3 || 2 === n3) i3 += t3.readSVarint(), s3 += t3.readSVarint(), i3 < o3 && (o3 = i3), i3 > a3 && (a3 = i3), s3 < l3 && (l3 = s3), s3 > u3 && (u3 = s3);
+            else if (7 !== n3) throw new Error(`unknown command ${n3}`);
+          }
+          return [o3, l3, a3, u3];
+        }
+        toGeoJSON(t3, e3, n3) {
+          const r3 = this.extent * Math.pow(2, n3), i3 = this.extent * t3, s3 = this.extent * e3, o3 = this.loadGeometry();
+          function a3(t4) {
+            return [360 * (t4.x + i3) / r3 - 180, 360 / Math.PI * Math.atan(Math.exp((1 - 2 * (t4.y + s3) / r3) * Math.PI)) - 90];
+          }
+          function l3(t4) {
+            return t4.map(a3);
+          }
+          let u3;
+          if (1 === this.type) {
+            const t4 = [];
+            for (const e5 of o3) t4.push(e5[0]);
+            const e4 = l3(t4);
+            u3 = 1 === t4.length ? { type: "Point", coordinates: e4[0] } : { type: "MultiPoint", coordinates: e4 };
+          } else if (2 === this.type) {
+            const t4 = o3.map(l3);
+            u3 = 1 === t4.length ? { type: "LineString", coordinates: t4[0] } : { type: "MultiLineString", coordinates: t4 };
+          } else {
+            if (3 !== this.type) throw new Error("unknown feature type");
+            {
+              const t4 = zu(o3), e4 = [];
+              for (const n4 of t4) e4.push(n4.map(l3));
+              u3 = 1 === e4.length ? { type: "Polygon", coordinates: e4[0] } : { type: "MultiPolygon", coordinates: e4 };
+            }
+          }
+          const c3 = { type: "Feature", geometry: u3, properties: this.properties };
+          return null != this.id && (c3.id = this.id), c3;
+        }
+      }
+      function Pu(t3, e3, n3) {
+        1 === t3 ? e3.id = n3.readVarint() : 2 === t3 ? function(t4, e4) {
+          const n4 = t4.readVarint() + t4.pos;
+          for (; t4.pos < n4; ) {
+            const n5 = e4._keys[t4.readVarint()], r3 = e4._values[t4.readVarint()];
+            e4.properties[n5] = r3;
+          }
+        }(n3, e3) : 3 === t3 ? e3.type = n3.readVarint() : 4 === t3 && (e3._geometry = n3.pos);
+      }
+      function zu(t3) {
+        const e3 = t3.length;
+        if (e3 <= 1) return [t3];
+        const n3 = [];
+        let r3, i3;
+        for (let s3 = 0; s3 < e3; s3++) {
+          const e4 = Bu(t3[s3]);
+          0 !== e4 && (void 0 === i3 && (i3 = e4 < 0), i3 === e4 < 0 ? (r3 && n3.push(r3), r3 = [t3[s3]]) : r3 && r3.push(t3[s3]));
+        }
+        return r3 && n3.push(r3), n3;
+      }
+      function Bu(t3) {
+        let e3 = 0;
+        for (let n3, r3, i3 = 0, s3 = t3.length, o3 = s3 - 1; i3 < s3; o3 = i3++) n3 = t3[i3], r3 = t3[o3], e3 += (r3.x - n3.x) * (n3.y + r3.y);
+        return e3;
+      }
+      Du.types = ["Unknown", "Point", "LineString", "Polygon"];
+      class Cu {
+        constructor(t3, e3) {
+          this.version = 1, this.name = "", this.extent = 4096, this.length = 0, this._pbf = t3, this._keys = [], this._values = [], this._features = [], t3.readFields(Vu, this, e3), this.length = this._features.length;
+        }
+        feature(t3) {
+          if (t3 < 0 || t3 >= this._features.length) throw new Error("feature index out of bounds");
+          this._pbf.pos = this._features[t3];
+          const e3 = this._pbf.readVarint() + this._pbf.pos;
+          return new Du(this._pbf, e3, this.extent, this._keys, this._values);
+        }
+      }
+      function Vu(t3, e3, n3) {
+        15 === t3 ? e3.version = n3.readVarint() : 1 === t3 ? e3.name = n3.readString() : 5 === t3 ? e3.extent = n3.readVarint() : 2 === t3 ? e3._features.push(n3.pos) : 3 === t3 ? e3._keys.push(n3.readString()) : 4 === t3 && e3._values.push(function(t4) {
+          let e4 = null;
+          const n4 = t4.readVarint() + t4.pos;
+          for (; t4.pos < n4; ) {
+            const n5 = t4.readVarint() >> 3;
+            e4 = 1 === n5 ? t4.readString() : 2 === n5 ? t4.readFloat() : 3 === n5 ? t4.readDouble() : 4 === n5 ? t4.readVarint64() : 5 === n5 ? t4.readVarint() : 6 === n5 ? t4.readSVarint() : 7 === n5 ? t4.readBoolean() : null;
+          }
+          if (null == e4) throw new Error("unknown feature value");
+          return e4;
+        }(n3));
+      }
+      class Lu {
+        constructor(t3, e3) {
+          this.layers = t3.readFields(Ou, {}, e3);
+        }
+      }
+      function Ou(t3, e3, n3) {
+        if (3 === t3) {
+          const t4 = new Cu(n3, n3.readVarint() + n3.pos);
+          t4.length && (e3[t4.name] = t4);
+        }
+      }
+      const $u = Math.pow(2, 13);
+      function Ru(t3, e3, n3, r3, i3, s3, o3, a3) {
+        t3.emplaceBack(e3, n3, 2 * Math.floor(r3 * $u) + o3, i3 * $u * 2, s3 * $u * 2, Math.round(a3));
+      }
+      class Nu {
+        constructor(t3) {
+          this.zoom = t3.zoom, this.overscaling = t3.overscaling, this.layers = t3.layers, this.layerIds = this.layers.map((t4) => t4.id), this.index = t3.index, this.hasDependencies = false, this.layoutVertexArray = new Go(), this.centroidVertexArray = new Uo(), this.indexArray = new ea2(), this.programConfigurations = new Ca2(t3.layers, t3.zoom), this.segments = new sa2(), this.stateDependentLayerIds = this.layers.filter((t4) => t4.isStateDependent()).map((t4) => t4.id);
+        }
+        populate(t3, e3, n3) {
+          this.features = [], this.hasDependencies = Rl("fill-extrusion", this.layers, e3);
+          for (const { feature: r3, id: i3, index: s3, sourceLayerIndex: o3 } of t3) {
+            const t4 = this.layers[0]._featureFilter.needGeometry, a3 = Na2(r3, t4);
+            if (!this.layers[0]._featureFilter.filter(new zs(this.zoom), a3, n3)) continue;
+            const l3 = { id: i3, sourceLayerIndex: o3, index: s3, geometry: t4 ? a3.geometry : Ra2(r3), properties: r3.properties, type: r3.type, patterns: {} };
+            this.hasDependencies ? this.features.push(Nl("fill-extrusion", this.layers, l3, { zoom: this.zoom }, e3)) : this.addFeature(l3, l3.geometry, s3, n3, {}, e3.subdivisionGranularity), e3.featureIndex.insert(r3, l3.geometry, s3, o3, this.index, true);
+          }
+        }
+        addFeatures(t3, e3, n3) {
+          for (const r3 of this.features) {
+            const { geometry: i3 } = r3;
+            this.addFeature(r3, i3, r3.index, e3, n3, t3.subdivisionGranularity);
+          }
+        }
+        update(t3, e3, n3) {
+          this.stateDependentLayers.length && this.programConfigurations.updatePaintArrays(t3, e3, this.stateDependentLayers, { imagePositions: n3 });
+        }
+        isEmpty() {
+          return 0 === this.layoutVertexArray.length && 0 === this.centroidVertexArray.length;
+        }
+        uploadPending() {
+          return !this.uploaded || this.programConfigurations.needsUpload;
+        }
+        upload(t3) {
+          this.uploaded || (this.layoutVertexBuffer = t3.createVertexBuffer(this.layoutVertexArray, Fu), this.centroidVertexBuffer = t3.createVertexBuffer(this.centroidVertexArray, Tu.members, true), this.indexBuffer = t3.createIndexBuffer(this.indexArray)), this.programConfigurations.upload(t3), this.uploaded = true;
+        }
+        destroy() {
+          this.layoutVertexBuffer && (this.layoutVertexBuffer.destroy(), this.indexBuffer.destroy(), this.programConfigurations.destroy(), this.segments.destroy(), this.centroidVertexBuffer.destroy());
+        }
+        addFeature(t3, e3, n3, r3, i3, s3) {
+          for (const n4 of er(e3, 500)) {
+            const e4 = { x: 0, y: 0, sampleCount: 0 }, i4 = this.layoutVertexArray.length;
+            this.processPolygon(e4, r3, t3, n4, s3);
+            const o3 = this.layoutVertexArray.length - i4, a3 = Math.floor(e4.x / e4.sampleCount), l3 = Math.floor(e4.y / e4.sampleCount);
+            for (let t4 = 0; t4 < o3; t4++) this.centroidVertexArray.emplaceBack(a3, l3);
+          }
+          this.programConfigurations.populatePaintArrays(this.layoutVertexArray.length, t3, n3, { imagePositions: i3, canonical: r3 });
+        }
+        processPolygon(t3, e3, n3, r3, i3) {
+          if (r3.length < 1) return;
+          if (qu(r3[0])) return;
+          for (const e4 of r3) 0 !== e4.length && Uu(t3, e4);
+          const s3 = { segment: this.segments.prepareSegment(4, this.layoutVertexArray, this.indexArray) }, o3 = i3.fill.getGranularityForZoomLevel(e3.z), a3 = "Polygon" === Du.types[n3.type];
+          for (const t4 of r3) {
+            if (0 === t4.length) continue;
+            if (qu(t4)) continue;
+            const e4 = vu(t4, o3, a3);
+            this._generateSideFaces(e4, s3);
+          }
+          if (!a3) return;
+          const l3 = xu(r3, e3, o3, false), u3 = this.layoutVertexArray;
+          wu((t4, e4) => {
+            Ru(u3, t4, e4, 0, 0, 1, 1, 0);
+          }, this.segments, this.layoutVertexArray, this.indexArray, l3.verticesFlattened, l3.indicesTriangles);
+        }
+        _generateSideFaces(t3, e3) {
+          let n3 = 0;
+          for (let r3 = 1; r3 < t3.length; r3++) {
+            const i3 = t3[r3], s3 = t3[r3 - 1];
+            if (ju(i3, s3)) continue;
+            e3.segment.vertexLength + 4 > sa2.MAX_VERTEX_ARRAY_LENGTH && (e3.segment = this.segments.prepareSegment(4, this.layoutVertexArray, this.indexArray));
+            const o3 = i3.sub(s3)._perp()._unit(), a3 = s3.dist(i3);
+            n3 + a3 > 32768 && (n3 = 0), Ru(this.layoutVertexArray, i3.x, i3.y, o3.x, o3.y, 0, 0, n3), Ru(this.layoutVertexArray, i3.x, i3.y, o3.x, o3.y, 0, 1, n3), n3 += a3, Ru(this.layoutVertexArray, s3.x, s3.y, o3.x, o3.y, 0, 0, n3), Ru(this.layoutVertexArray, s3.x, s3.y, o3.x, o3.y, 0, 1, n3);
+            const l3 = e3.segment.vertexLength;
+            this.indexArray.emplaceBack(l3, l3 + 2, l3 + 1), this.indexArray.emplaceBack(l3 + 1, l3 + 2, l3 + 3), e3.segment.vertexLength += 4, e3.segment.primitiveLength += 2;
+          }
+        }
+      }
+      function Uu(t3, e3) {
+        for (let n3 = 0; n3 < e3.length; n3++) {
+          const r3 = e3[n3];
+          n3 === e3.length - 1 && e3[0].x === r3.x && e3[0].y === r3.y || (t3.x += r3.x, t3.y += r3.y, t3.sampleCount++);
+        }
+      }
+      function ju(t3, e3) {
+        return t3.x === e3.x && (t3.x < 0 || t3.x > T2) || t3.y === e3.y && (t3.y < 0 || t3.y > T2);
+      }
+      function qu(t3) {
+        return t3.every((t4) => t4.x < 0) || t3.every((t4) => t4.x > T2) || t3.every((t4) => t4.y < 0) || t3.every((t4) => t4.y > T2);
+      }
+      let Gu;
+      ps("FillExtrusionBucket", Nu, { omit: ["layers", "features"] });
+      var Xu = { get paint() {
+        return Gu = Gu || new Hs({ "fill-extrusion-opacity": new qs(vt["paint_fill-extrusion"]["fill-extrusion-opacity"]), "fill-extrusion-color": new Gs(vt["paint_fill-extrusion"]["fill-extrusion-color"]), "fill-extrusion-translate": new qs(vt["paint_fill-extrusion"]["fill-extrusion-translate"]), "fill-extrusion-translate-anchor": new qs(vt["paint_fill-extrusion"]["fill-extrusion-translate-anchor"]), "fill-extrusion-pattern": new Xs(vt["paint_fill-extrusion"]["fill-extrusion-pattern"]), "fill-extrusion-height": new Gs(vt["paint_fill-extrusion"]["fill-extrusion-height"]), "fill-extrusion-base": new Gs(vt["paint_fill-extrusion"]["fill-extrusion-base"]), "fill-extrusion-vertical-gradient": new qs(vt["paint_fill-extrusion"]["fill-extrusion-vertical-gradient"]) });
+      } };
+      class Yu extends Ws {
+        constructor(t3, e3) {
+          super(t3, Xu, e3);
+        }
+        createBucket(t3) {
+          return new Nu(t3);
+        }
+        queryRadius() {
+          return rl2(this.paint.get("fill-extrusion-translate"));
+        }
+        is3D() {
+          return true;
+        }
+        queryIntersectsFeature({ queryGeometry: t3, feature: e3, featureState: r3, geometry: i3, transform: s3, pixelsToTileUnits: o3, pixelPosMatrix: a3 }) {
+          const l3 = il2(t3, this.paint.get("fill-extrusion-translate"), this.paint.get("fill-extrusion-translate-anchor"), -s3.bearingInRadians, o3), u3 = this.paint.get("fill-extrusion-height").evaluate(e3, r3), c3 = this.paint.get("fill-extrusion-base").evaluate(e3, r3), h3 = function(t4, e4) {
+            const r4 = [];
+            for (const i4 of t4) {
+              const t5 = [i4.x, i4.y, 0, 1];
+              A2(t5, t5, e4), r4.push(new n2(t5[0] / t5[3], t5[1] / t5[3]));
+            }
+            return r4;
+          }(l3, a3), p3 = function(t4, e4, r4, i4) {
+            const s4 = [], o4 = [], a4 = i4[8] * e4, l4 = i4[9] * e4, u4 = i4[10] * e4, c4 = i4[11] * e4, h4 = i4[8] * r4, p4 = i4[9] * r4, f3 = i4[10] * r4, d3 = i4[11] * r4;
+            for (const e5 of t4) {
+              const t5 = [], r5 = [];
+              for (const s5 of e5) {
+                const e6 = s5.x, o5 = s5.y, y3 = i4[0] * e6 + i4[4] * o5 + i4[12], m3 = i4[1] * e6 + i4[5] * o5 + i4[13], g3 = i4[2] * e6 + i4[6] * o5 + i4[14], x3 = i4[3] * e6 + i4[7] * o5 + i4[15], v3 = g3 + u4, b3 = x3 + c4, w3 = y3 + h4, _3 = m3 + p4, S3 = g3 + f3, A3 = x3 + d3, M3 = new n2((y3 + a4) / b3, (m3 + l4) / b3);
+                M3.z = v3 / b3, t5.push(M3);
+                const k3 = new n2(w3 / A3, _3 / A3);
+                k3.z = S3 / A3, r5.push(k3);
+              }
+              s4.push(t5), o4.push(r5);
+            }
+            return [s4, o4];
+          }(i3, c3, u3, a3);
+          return function(t4, e4, n3) {
+            let r4 = 1 / 0;
+            Ya2(n3, e4) && (r4 = Hu(n3, e4[0]));
+            for (let i4 = 0; i4 < e4.length; i4++) {
+              const s4 = e4[i4], o4 = t4[i4];
+              for (let t5 = 0; t5 < s4.length - 1; t5++) {
+                const e5 = s4[t5], i5 = [e5, s4[t5 + 1], o4[t5 + 1], o4[t5], e5];
+                Ga2(n3, i5) && (r4 = Math.min(r4, Hu(n3, i5)));
+              }
+            }
+            return r4 !== 1 / 0 && r4;
+          }(p3[0], p3[1], h3);
+        }
+      }
+      function Zu(t3, e3) {
+        return t3.x * e3.x + t3.y * e3.y;
+      }
+      function Hu(t3, e3) {
+        if (1 === t3.length) {
+          let n3 = 0;
+          const r3 = e3[n3++];
+          let i3;
+          for (; !i3 || r3.equals(i3); ) if (i3 = e3[n3++], !i3) return 1 / 0;
+          for (; n3 < e3.length; n3++) {
+            const s3 = e3[n3], o3 = t3[0], a3 = i3.sub(r3), l3 = s3.sub(r3), u3 = o3.sub(r3), c3 = Zu(a3, a3), h3 = Zu(a3, l3), p3 = Zu(l3, l3), f3 = Zu(u3, a3), d3 = Zu(u3, l3), y3 = c3 * p3 - h3 * h3, m3 = (p3 * f3 - h3 * d3) / y3, g3 = (c3 * d3 - h3 * f3) / y3, x3 = r3.z * (1 - m3 - g3) + i3.z * m3 + s3.z * g3;
+            if (isFinite(x3)) return x3;
+          }
+          return 1 / 0;
+        }
+        {
+          let t4 = 1 / 0;
+          for (const n3 of e3) t4 = Math.min(t4, n3.z);
+          return t4;
+        }
+      }
+      const Wu = [Int8Array, Uint8Array, Uint8ClampedArray, Int16Array, Uint16Array, Int32Array, Uint32Array, Float32Array, Float64Array];
+      class Ku {
+        static from(t3) {
+          if (!(t3 instanceof ArrayBuffer)) throw new Error("Data must be an instance of ArrayBuffer.");
+          const [e3, n3] = new Uint8Array(t3, 0, 2);
+          if (219 !== e3) throw new Error("Data does not appear to be in a KDBush format.");
+          const r3 = n3 >> 4;
+          if (1 !== r3) throw new Error(`Got v${r3} data when expected v1.`);
+          const i3 = Wu[15 & n3];
+          if (!i3) throw new Error("Unrecognized array type.");
+          const [s3] = new Uint16Array(t3, 2, 1), [o3] = new Uint32Array(t3, 4, 1);
+          return new Ku(o3, s3, i3, t3);
+        }
+        constructor(t3, e3 = 64, n3 = Float64Array, r3) {
+          if (isNaN(t3) || t3 < 0) throw new Error(`Unpexpected numItems value: ${t3}.`);
+          this.numItems = +t3, this.nodeSize = Math.min(Math.max(+e3, 2), 65535), this.ArrayType = n3, this.IndexArrayType = t3 < 65536 ? Uint16Array : Uint32Array;
+          const i3 = Wu.indexOf(this.ArrayType), s3 = 2 * t3 * this.ArrayType.BYTES_PER_ELEMENT, o3 = t3 * this.IndexArrayType.BYTES_PER_ELEMENT, a3 = (8 - o3 % 8) % 8;
+          if (i3 < 0) throw new Error(`Unexpected typed array class: ${n3}.`);
+          r3 && r3 instanceof ArrayBuffer ? (this.data = r3, this.ids = new this.IndexArrayType(this.data, 8, t3), this.coords = new this.ArrayType(this.data, 8 + o3 + a3, 2 * t3), this._pos = 2 * t3, this._finished = true) : (this.data = new ArrayBuffer(8 + s3 + o3 + a3), this.ids = new this.IndexArrayType(this.data, 8, t3), this.coords = new this.ArrayType(this.data, 8 + o3 + a3, 2 * t3), this._pos = 0, this._finished = false, new Uint8Array(this.data, 0, 2).set([219, 16 + i3]), new Uint16Array(this.data, 2, 1)[0] = e3, new Uint32Array(this.data, 4, 1)[0] = t3);
+        }
+        add(t3, e3) {
+          const n3 = this._pos >> 1;
+          return this.ids[n3] = n3, this.coords[this._pos++] = t3, this.coords[this._pos++] = e3, n3;
+        }
+        finish() {
+          const t3 = this._pos >> 1;
+          if (t3 !== this.numItems) throw new Error(`Added ${t3} items when expected ${this.numItems}.`);
+          return Ju(this.ids, this.coords, this.nodeSize, 0, this.numItems - 1, 0), this._finished = true, this;
+        }
+        range(t3, e3, n3, r3) {
+          if (!this._finished) throw new Error("Data not yet indexed - call index.finish().");
+          const { ids: i3, coords: s3, nodeSize: o3 } = this, a3 = [0, i3.length - 1, 0], l3 = [];
+          for (; a3.length; ) {
+            const u3 = a3.pop() || 0, c3 = a3.pop() || 0, h3 = a3.pop() || 0;
+            if (c3 - h3 <= o3) {
+              for (let o4 = h3; o4 <= c3; o4++) {
+                const a4 = s3[2 * o4], u4 = s3[2 * o4 + 1];
+                a4 >= t3 && a4 <= n3 && u4 >= e3 && u4 <= r3 && l3.push(i3[o4]);
+              }
+              continue;
+            }
+            const p3 = h3 + c3 >> 1, f3 = s3[2 * p3], d3 = s3[2 * p3 + 1];
+            f3 >= t3 && f3 <= n3 && d3 >= e3 && d3 <= r3 && l3.push(i3[p3]), (0 === u3 ? t3 <= f3 : e3 <= d3) && (a3.push(h3), a3.push(p3 - 1), a3.push(1 - u3)), (0 === u3 ? n3 >= f3 : r3 >= d3) && (a3.push(p3 + 1), a3.push(c3), a3.push(1 - u3));
+          }
+          return l3;
+        }
+        within(t3, e3, n3) {
+          if (!this._finished) throw new Error("Data not yet indexed - call index.finish().");
+          const { ids: r3, coords: i3, nodeSize: s3 } = this, o3 = [0, r3.length - 1, 0], a3 = [], l3 = n3 * n3;
+          for (; o3.length; ) {
+            const u3 = o3.pop() || 0, c3 = o3.pop() || 0, h3 = o3.pop() || 0;
+            if (c3 - h3 <= s3) {
+              for (let n4 = h3; n4 <= c3; n4++) nc2(i3[2 * n4], i3[2 * n4 + 1], t3, e3) <= l3 && a3.push(r3[n4]);
+              continue;
+            }
+            const p3 = h3 + c3 >> 1, f3 = i3[2 * p3], d3 = i3[2 * p3 + 1];
+            nc2(f3, d3, t3, e3) <= l3 && a3.push(r3[p3]), (0 === u3 ? t3 - n3 <= f3 : e3 - n3 <= d3) && (o3.push(h3), o3.push(p3 - 1), o3.push(1 - u3)), (0 === u3 ? t3 + n3 >= f3 : e3 + n3 >= d3) && (o3.push(p3 + 1), o3.push(c3), o3.push(1 - u3));
+          }
+          return a3;
+        }
+      }
+      function Ju(t3, e3, n3, r3, i3, s3) {
+        if (i3 - r3 <= n3) return;
+        const o3 = r3 + i3 >> 1;
+        Qu(t3, e3, o3, r3, i3, s3), Ju(t3, e3, n3, r3, o3 - 1, 1 - s3), Ju(t3, e3, n3, o3 + 1, i3, 1 - s3);
+      }
+      function Qu(t3, e3, n3, r3, i3, s3) {
+        for (; i3 > r3; ) {
+          if (i3 - r3 > 600) {
+            const o4 = i3 - r3 + 1, a4 = n3 - r3 + 1, l4 = Math.log(o4), u3 = 0.5 * Math.exp(2 * l4 / 3), c3 = 0.5 * Math.sqrt(l4 * u3 * (o4 - u3) / o4) * (a4 - o4 / 2 < 0 ? -1 : 1);
+            Qu(t3, e3, n3, Math.max(r3, Math.floor(n3 - a4 * u3 / o4 + c3)), Math.min(i3, Math.floor(n3 + (o4 - a4) * u3 / o4 + c3)), s3);
+          }
+          const o3 = e3[2 * n3 + s3];
+          let a3 = r3, l3 = i3;
+          for (tc2(t3, e3, r3, n3), e3[2 * i3 + s3] > o3 && tc2(t3, e3, r3, i3); a3 < l3; ) {
+            for (tc2(t3, e3, a3, l3), a3++, l3--; e3[2 * a3 + s3] < o3; ) a3++;
+            for (; e3[2 * l3 + s3] > o3; ) l3--;
+          }
+          e3[2 * r3 + s3] === o3 ? tc2(t3, e3, r3, l3) : (l3++, tc2(t3, e3, l3, i3)), l3 <= n3 && (r3 = l3 + 1), n3 <= l3 && (i3 = l3 - 1);
+        }
+      }
+      function tc2(t3, e3, n3, r3) {
+        ec2(t3, n3, r3), ec2(e3, 2 * n3, 2 * r3), ec2(e3, 2 * n3 + 1, 2 * r3 + 1);
+      }
+      function ec2(t3, e3, n3) {
+        const r3 = t3[e3];
+        t3[e3] = t3[n3], t3[n3] = r3;
+      }
+      function nc2(t3, e3, n3, r3) {
+        const i3 = t3 - n3, s3 = e3 - r3;
+        return i3 * i3 + s3 * s3;
+      }
+      function rc2(t3, e3, n3, r3) {
+        let i3 = r3;
+        const s3 = e3 + (n3 - e3 >> 1);
+        let o3, a3 = n3 - e3;
+        const l3 = t3[e3], u3 = t3[e3 + 1], c3 = t3[n3], h3 = t3[n3 + 1];
+        for (let r4 = e3 + 3; r4 < n3; r4 += 3) {
+          const e4 = ic2(t3[r4], t3[r4 + 1], l3, u3, c3, h3);
+          if (e4 > i3) o3 = r4, i3 = e4;
+          else if (e4 === i3) {
+            const t4 = Math.abs(r4 - s3);
+            t4 < a3 && (o3 = r4, a3 = t4);
+          }
+        }
+        i3 > r3 && (o3 - e3 > 3 && rc2(t3, e3, o3, r3), t3[o3 + 2] = i3, n3 - o3 > 3 && rc2(t3, o3, n3, r3));
+      }
+      function ic2(t3, e3, n3, r3, i3, s3) {
+        let o3 = i3 - n3, a3 = s3 - r3;
+        if (0 !== o3 || 0 !== a3) {
+          const l3 = ((t3 - n3) * o3 + (e3 - r3) * a3) / (o3 * o3 + a3 * a3);
+          l3 > 1 ? (n3 = i3, r3 = s3) : l3 > 0 && (n3 += o3 * l3, r3 += a3 * l3);
+        }
+        return o3 = t3 - n3, a3 = e3 - r3, o3 * o3 + a3 * a3;
+      }
+      function sc2(t3, e3, n3, r3) {
+        const i3 = { type: e3, geom: n3 }, s3 = { id: null == t3 ? null : t3, type: i3.type, geometry: i3.geom, tags: r3, minX: 1 / 0, minY: 1 / 0, maxX: -1 / 0, maxY: -1 / 0 };
+        switch (i3.type) {
+          case "Point":
+          case "MultiPoint":
+          case "LineString":
+            oc2(s3, i3.geom);
+            break;
+          case "Polygon":
+            oc2(s3, i3.geom[0]);
+            break;
+          case "MultiLineString":
+            for (const t4 of i3.geom) oc2(s3, t4);
+            break;
+          case "MultiPolygon":
+            for (const t4 of i3.geom) oc2(s3, t4[0]);
+        }
+        return s3;
+      }
+      function oc2(t3, e3) {
+        for (let n3 = 0; n3 < e3.length; n3 += 3) t3.minX = Math.min(t3.minX, e3[n3]), t3.minY = Math.min(t3.minY, e3[n3 + 1]), t3.maxX = Math.max(t3.maxX, e3[n3]), t3.maxY = Math.max(t3.maxY, e3[n3 + 1]);
+      }
+      function ac2(t3, e3) {
+        const n3 = [];
+        switch (t3.type) {
+          case "FeatureCollection":
+            for (let r3 = 0; r3 < t3.features.length; r3++) lc2(n3, t3.features[r3], e3, r3);
+            break;
+          case "Feature":
+            lc2(n3, t3, e3);
+            break;
+          default:
+            lc2(n3, { geometry: t3, properties: void 0 }, e3);
+        }
+        return n3;
+      }
+      function lc2(t3, e3, n3, r3) {
+        if (!e3.geometry) return;
+        if ("GeometryCollection" === e3.geometry.type) return void function(t4, e4, n4, r4, i4) {
+          for (const s4 of n4.geometries) lc2(t4, { id: e4.id, geometry: s4, properties: e4.properties }, r4, i4);
+        }(t3, e3, e3.geometry, n3, r3);
+        const i3 = e3.geometry.coordinates;
+        if (!(i3 == null ? void 0 : i3.length)) return;
+        const s3 = function(t4, e4, n4) {
+          var _a4;
+          return e4.promoteId ? (_a4 = t4.properties) == null ? void 0 : _a4[e4.promoteId] : e4.generateId ? n4 || 0 : t4.id;
+        }(e3, n3, r3), o3 = Math.pow(n3.tolerance / ((1 << n3.maxZoom) * n3.extent), 2);
+        switch (e3.geometry.type) {
+          case "Point":
+            return void function(t4, e4, n4, r4) {
+              const i4 = [];
+              i4.push(hc2(n4.coordinates[0]), pc2(n4.coordinates[1]), 0), t4.push(sc2(e4, "Point", i4, r4));
+            }(t3, s3, e3.geometry, e3.properties);
+          case "MultiPoint":
+            return void function(t4, e4, n4, r4) {
+              const i4 = [];
+              for (const t5 of n4.coordinates) i4.push(hc2(t5[0]), pc2(t5[1]), 0);
+              t4.push(sc2(e4, "MultiPoint", i4, r4));
+            }(t3, s3, e3.geometry, e3.properties);
+          case "LineString":
+            return void function(t4, e4, n4, r4, i4) {
+              const s4 = [];
+              uc2(n4.coordinates, s4, r4, false), t4.push(sc2(e4, "LineString", s4, i4));
+            }(t3, s3, e3.geometry, o3, e3.properties);
+          case "MultiLineString":
+            return void function(t4, e4, n4, r4, i4, s4) {
+              if (i4.lineMetrics) for (const i5 of n4.coordinates) {
+                const n5 = [];
+                uc2(i5, n5, r4, false), t4.push(sc2(e4, "LineString", n5, s4));
+              }
+              else {
+                const i5 = [];
+                cc2(n4.coordinates, i5, r4, false), t4.push(sc2(e4, "MultiLineString", i5, s4));
+              }
+            }(t3, s3, e3.geometry, o3, n3, e3.properties);
+          case "Polygon":
+            return void function(t4, e4, n4, r4, i4) {
+              const s4 = [];
+              cc2(n4.coordinates, s4, r4, true), t4.push(sc2(e4, "Polygon", s4, i4));
+            }(t3, s3, e3.geometry, o3, e3.properties);
+          case "MultiPolygon":
+            return void function(t4, e4, n4, r4, i4) {
+              const s4 = [];
+              for (const t5 of n4.coordinates) {
+                const e5 = [];
+                cc2(t5, e5, r4, true), s4.push(e5);
+              }
+              t4.push(sc2(e4, "MultiPolygon", s4, i4));
+            }(t3, s3, e3.geometry, o3, e3.properties);
+          default:
+            throw new Error("Input data is not a valid GeoJSON object.");
+        }
+      }
+      function uc2(t3, e3, n3, r3) {
+        let i3, s3, o3 = 0;
+        for (let n4 = 0; n4 < t3.length; n4++) {
+          const a4 = hc2(t3[n4][0]), l3 = pc2(t3[n4][1]);
+          e3.push(a4, l3, 0), n4 > 0 && (o3 += r3 ? (i3 * l3 - a4 * s3) / 2 : Math.sqrt(Math.pow(a4 - i3, 2) + Math.pow(l3 - s3, 2))), i3 = a4, s3 = l3;
+        }
+        const a3 = e3.length - 3;
+        e3[2] = 1, n3 > 0 && rc2(e3, 0, a3, n3), e3[a3 + 2] = 1, e3.size = Math.abs(o3), e3.start = 0, e3.end = e3.size;
+      }
+      function cc2(t3, e3, n3, r3) {
+        for (let i3 = 0; i3 < t3.length; i3++) {
+          const s3 = [];
+          uc2(t3[i3], s3, n3, r3), e3.push(s3);
+        }
+      }
+      function hc2(t3) {
+        return t3 / 360 + 0.5;
+      }
+      function pc2(t3) {
+        const e3 = Math.sin(t3 * Math.PI / 180), n3 = 0.5 - 0.25 * Math.log((1 + e3) / (1 - e3)) / Math.PI;
+        return n3 < 0 ? 0 : n3 > 1 ? 1 : n3;
+      }
+      function fc2(t3) {
+        const e3 = { type: "Feature", geometry: dc2(t3), properties: t3.tags };
+        return null != t3.id && (e3.id = t3.id), e3;
+      }
+      function dc2(t3) {
+        const { type: e3, geometry: n3 } = t3;
+        switch (e3) {
+          case "Point":
+            return { type: e3, coordinates: mc2(n3[0], n3[1]) };
+          case "MultiPoint":
+          case "LineString":
+            return { type: e3, coordinates: yc2(n3) };
+          case "MultiLineString":
+          case "Polygon":
+            return { type: e3, coordinates: n3.map((t4) => yc2(t4)) };
+          case "MultiPolygon":
+            return { type: e3, coordinates: n3.map((t4) => t4.map((t5) => yc2(t5))) };
+        }
+      }
+      function yc2(t3) {
+        const e3 = [];
+        for (let n3 = 0; n3 < t3.length; n3 += 3) e3.push(mc2(t3[n3], t3[n3 + 1]));
+        return e3;
+      }
+      function mc2(t3, e3) {
+        return [gc2(t3), xc2(e3)];
+      }
+      function gc2(t3) {
+        return 360 * (t3 - 0.5);
+      }
+      function xc2(t3) {
+        const e3 = (180 - 360 * t3) * Math.PI / 180;
+        return 360 * Math.atan(Math.exp(e3)) / Math.PI - 90;
+      }
+      var vc2;
+      function bc2(t3, e3, n3, r3, i3, s3, o3, a3) {
+        if (r3 /= e3, s3 >= (n3 /= e3) && o3 < r3) return t3;
+        if (o3 < n3 || s3 >= r3) return null;
+        const l3 = [];
+        for (const e4 of t3) {
+          const t4 = i3 === vc2.X ? e4.minX : e4.minY, s4 = i3 === vc2.X ? e4.maxX : e4.maxY;
+          if (t4 >= n3 && s4 < r3) l3.push(e4);
+          else if (!(s4 < n3 || t4 >= r3)) switch (e4.type) {
+            case "Point":
+            case "MultiPoint":
+              wc2(e4, l3, n3, r3, i3);
+              continue;
+            case "LineString":
+              _c3(e4, l3, n3, r3, i3, a3);
+              continue;
+            case "MultiLineString":
+              Sc2(e4, l3, n3, r3, i3);
+              continue;
+            case "Polygon":
+              Ac2(e4, l3, n3, r3, i3);
+              continue;
+            case "MultiPolygon":
+              Mc2(e4, l3, n3, r3, i3);
+              continue;
+          }
+        }
+        return l3.length ? l3 : null;
+      }
+      function wc2(t3, e3, n3, r3, i3) {
+        const s3 = [];
+        (function(t4, e4, n4, r4, i4) {
+          for (let s4 = 0; s4 < t4.length; s4 += 3) {
+            const o3 = t4[s4 + i4];
+            o3 >= n4 && o3 <= r4 && Tc2(e4, t4[s4], t4[s4 + 1], t4[s4 + 2]);
+          }
+        })(t3.geometry, s3, n3, r3, i3), s3.length && e3.push(sc2(t3.id, 3 === s3.length ? "Point" : "MultiPoint", s3, t3.tags));
+      }
+      function _c3(t3, e3, n3, r3, i3, s3) {
+        const o3 = [];
+        if (kc2(t3.geometry, o3, n3, r3, i3, false, s3.lineMetrics), o3.length) if (s3.lineMetrics) for (const n4 of o3) e3.push(sc2(t3.id, "LineString", n4, t3.tags));
+        else e3.push(o3.length > 1 ? sc2(t3.id, "MultiLineString", o3, t3.tags) : sc2(t3.id, "LineString", o3[0], t3.tags));
+      }
+      function Sc2(t3, e3, n3, r3, i3) {
+        const s3 = [];
+        Ec2(t3.geometry, s3, n3, r3, i3, false), s3.length && e3.push(1 !== s3.length ? sc2(t3.id, "MultiLineString", s3, t3.tags) : sc2(t3.id, "LineString", s3[0], t3.tags));
+      }
+      function Ac2(t3, e3, n3, r3, i3) {
+        const s3 = [];
+        Ec2(t3.geometry, s3, n3, r3, i3, true), s3.length && e3.push(sc2(t3.id, "Polygon", s3, t3.tags));
+      }
+      function Mc2(t3, e3, n3, r3, i3) {
+        const s3 = [];
+        for (const e4 of t3.geometry) {
+          const t4 = [];
+          Ec2(e4, t4, n3, r3, i3, true), t4.length && s3.push(t4);
+        }
+        s3.length && e3.push(sc2(t3.id, "MultiPolygon", s3, t3.tags));
+      }
+      function kc2(t3, e3, n3, r3, i3, s3, o3) {
+        let a3 = Ic2(t3);
+        const l3 = i3 === vc2.X ? Fc2 : Dc2;
+        let u3, c3, h3 = t3.start;
+        for (let p4 = 0; p4 < t3.length - 3; p4 += 3) {
+          const f4 = t3[p4], d4 = t3[p4 + 1], y4 = t3[p4 + 2], m3 = t3[p4 + 3], g3 = t3[p4 + 4], x3 = i3 === vc2.X ? f4 : d4, v3 = i3 === vc2.X ? m3 : g3;
+          let b3 = false;
+          o3 && (u3 = Math.sqrt(Math.pow(f4 - m3, 2) + Math.pow(d4 - g3, 2))), x3 < n3 ? v3 > n3 && (c3 = l3(a3, f4, d4, m3, g3, n3), o3 && (a3.start = h3 + u3 * c3)) : x3 > r3 ? v3 < r3 && (c3 = l3(a3, f4, d4, m3, g3, r3), o3 && (a3.start = h3 + u3 * c3)) : Tc2(a3, f4, d4, y4), v3 < n3 && x3 >= n3 && (c3 = l3(a3, f4, d4, m3, g3, n3), b3 = true), v3 > r3 && x3 <= r3 && (c3 = l3(a3, f4, d4, m3, g3, r3), b3 = true), !s3 && b3 && (o3 && (a3.end = h3 + u3 * c3), e3.push(a3), a3 = Ic2(t3)), o3 && (h3 += u3);
+        }
+        let p3 = t3.length - 3;
+        const f3 = t3[p3], d3 = t3[p3 + 1], y3 = i3 === vc2.X ? f3 : d3;
+        y3 >= n3 && y3 <= r3 && Tc2(a3, f3, d3, t3[p3 + 2]), p3 = a3.length - 3, s3 && p3 >= 3 && (a3[p3] !== a3[0] || a3[p3 + 1] !== a3[1]) && Tc2(a3, a3[0], a3[1], a3[2]), a3.length && e3.push(a3);
+      }
+      function Ic2(t3) {
+        const e3 = [];
+        return e3.size = t3.size, e3.start = t3.start, e3.end = t3.end, e3;
+      }
+      function Ec2(t3, e3, n3, r3, i3, s3) {
+        for (const o3 of t3) kc2(o3, e3, n3, r3, i3, s3, false);
+      }
+      function Tc2(t3, e3, n3, r3) {
+        t3.push(e3, n3, r3);
+      }
+      function Fc2(t3, e3, n3, r3, i3, s3) {
+        const o3 = (s3 - e3) / (r3 - e3);
+        return Tc2(t3, s3, n3 + (i3 - n3) * o3, 1), o3;
+      }
+      function Dc2(t3, e3, n3, r3, i3, s3) {
+        const o3 = (s3 - n3) / (i3 - n3);
+        return Tc2(t3, e3 + (r3 - e3) * o3, s3, 1), o3;
+      }
+      function Pc2(t3, e3) {
+        const n3 = e3.buffer / e3.extent;
+        let r3 = t3;
+        const i3 = bc2(t3, 1, -1 - n3, n3, vc2.X, -1, 2, e3), s3 = bc2(t3, 1, 1 - n3, 2 + n3, vc2.X, -1, 2, e3);
+        return i3 || s3 ? (r3 = bc2(t3, 1, -n3, 1 + n3, vc2.X, -1, 2, e3) || [], i3 && (r3 = zc2(i3, 1).concat(r3)), s3 && (r3 = r3.concat(zc2(s3, -1))), r3) : r3;
+      }
+      function zc2(t3, e3) {
+        const n3 = [];
+        for (const r3 of t3) switch (r3.type) {
+          case "Point":
+          case "MultiPoint":
+          case "LineString": {
+            const t4 = Bc2(r3.geometry, e3);
+            n3.push(sc2(r3.id, r3.type, t4, r3.tags));
+            continue;
+          }
+          case "MultiLineString":
+          case "Polygon": {
+            const t4 = [];
+            for (const n4 of r3.geometry) t4.push(Bc2(n4, e3));
+            n3.push(sc2(r3.id, r3.type, t4, r3.tags));
+            continue;
+          }
+          case "MultiPolygon": {
+            const t4 = [];
+            for (const n4 of r3.geometry) {
+              const r4 = [];
+              for (const t5 of n4) r4.push(Bc2(t5, e3));
+              t4.push(r4);
+            }
+            n3.push(sc2(r3.id, r3.type, t4, r3.tags));
+            continue;
+          }
+        }
+        return n3;
+      }
+      function Bc2(t3, e3) {
+        const n3 = [];
+        n3.size = t3.size, void 0 !== t3.start && (n3.start = t3.start, n3.end = t3.end);
+        for (let r3 = 0; r3 < t3.length; r3 += 3) n3.push(t3[r3] + e3, t3[r3 + 1], t3[r3 + 2]);
+        return n3;
+      }
+      function Cc2(t3, e3, n3) {
+        var _a4, _b3;
+        const r3 = !!e3.newGeometry, i3 = e3.removeAllProperties || ((_a4 = e3.removeProperties) == null ? void 0 : _a4.length) > 0 || ((_b3 = e3.addOrUpdateProperties) == null ? void 0 : _b3.length) > 0;
+        if (r3) {
+          const r4 = t3[0];
+          let s3 = ac2({ type: "FeatureCollection", features: [{ type: "Feature", id: r4.id, geometry: e3.newGeometry, properties: i3 ? Vc2(r4.tags, e3) : r4.tags }] }, n3);
+          return s3 = Pc2(s3, n3), s3;
+        }
+        if (i3) {
+          const n4 = [];
+          for (const r4 of t3) {
+            const t4 = { ...r4 };
+            t4.tags = Vc2(t4.tags, e3), n4.push(t4);
+          }
+          return n4;
+        }
+        return [];
+      }
+      function Vc2(t3, e3) {
+        if (e3.removeAllProperties) return {};
+        const n3 = { ...t3 || {} };
+        if (e3.removeProperties) for (const t4 of e3.removeProperties) delete n3[t4];
+        if (e3.addOrUpdateProperties) for (const { key: t4, value: r3 } of e3.addOrUpdateProperties) n3[t4] = r3;
+        return n3;
+      }
+      !function(t3) {
+        t3[t3.X = 0] = "X", t3[t3.Y = 1] = "Y";
+      }(vc2 || (vc2 = {}));
+      const Lc2 = { minZoom: 0, maxZoom: 16, minPoints: 2, radius: 40, extent: 512, nodeSize: 64, log: false, generateId: false, reduce: null, map: (t3) => t3 };
+      class Oc2 {
+        constructor(t3) {
+          this.options = Object.assign(Object.create(Lc2), t3), this.trees = new Array(this.options.maxZoom + 1), this.stride = this.options.reduce ? 7 : 6, this.clusterProps = [], this.points = [];
+        }
+        load(t3) {
+          const e3 = [];
+          for (const n3 of t3) {
+            if (!n3.geometry) continue;
+            const [t4, r3] = n3.geometry.coordinates, [i3, s3] = [hc2(t4), pc2(r3)];
+            e3.push({ id: n3.id, type: "Point", geometry: [i3, s3], tags: n3.properties });
+          }
+          this.createIndex(e3);
+        }
+        initialize(t3) {
+          const e3 = [];
+          for (const n3 of t3) "Point" === n3.type && e3.push(n3);
+          this.createIndex(e3);
+        }
+        updateIndex(t3, e3, n3) {
+          this.options = Object.assign(Object.create(Lc2), n3.clusterOptions), this.initialize(t3);
+        }
+        createIndex(t3) {
+          const { log: e3, minZoom: n3, maxZoom: r3 } = this.options;
+          e3 && console.time("total time");
+          const i3 = `prepare ${t3.length} points`;
+          e3 && console.time(i3), this.points = t3;
+          const s3 = [];
+          for (let e4 = 0; e4 < t3.length; e4++) {
+            const n4 = t3[e4];
+            if (!(n4 == null ? void 0 : n4.geometry)) continue;
+            let [r4, i4] = n4.geometry;
+            r4 = Math.fround(r4), i4 = Math.fround(i4), s3.push(r4, i4, 1 / 0, e4, -1, 1), this.options.reduce && s3.push(0);
+          }
+          let o3 = this.trees[r3 + 1] = this.createTree(s3);
+          e3 && console.timeEnd(i3);
+          for (let t4 = r3; t4 >= n3; t4--) {
+            const n4 = Date.now();
+            o3 = this.trees[t4] = this.createTree(this.cluster(o3, t4)), e3 && console.log("z%d: %d clusters in %dms", t4, o3.numItems, Date.now() - n4);
+          }
+          e3 && console.timeEnd("total time");
+        }
+        getClusters(t3, e3) {
+          return this.getClustersInternal(t3, e3).map((t4) => fc2(t4));
+        }
+        getClustersInternal(t3, e3) {
+          let n3 = ((t3[0] + 180) % 360 + 360) % 360 - 180;
+          const r3 = Math.max(-90, Math.min(90, t3[1]));
+          let i3 = 180 === t3[2] ? 180 : ((t3[2] + 180) % 360 + 360) % 360 - 180;
+          const s3 = Math.max(-90, Math.min(90, t3[3]));
+          if (t3[2] - t3[0] >= 360) n3 = -180, i3 = 180;
+          else if (n3 > i3) {
+            const t4 = this.getClustersInternal([n3, r3, 180, s3], e3), o4 = this.getClustersInternal([-180, r3, i3, s3], e3);
+            return t4.concat(o4);
+          }
+          const o3 = this.trees[this.limitZoom(e3)], a3 = o3.range(hc2(n3), pc2(s3), hc2(i3), pc2(r3)), l3 = o3.flatData, u3 = [];
+          for (const t4 of a3) {
+            const e4 = this.stride * t4;
+            u3.push(l3[e4 + 5] > 1 ? $c2(l3, e4, this.clusterProps) : this.points[l3[e4 + 3]]);
+          }
+          return u3;
+        }
+        getChildren(t3) {
+          const e3 = this.getOriginId(t3), n3 = this.getOriginZoom(t3), r3 = new Error("No cluster with the specified id: " + t3), i3 = this.trees[n3];
+          if (!i3) throw r3;
+          const s3 = i3.flatData;
+          if (e3 * this.stride >= s3.length) throw r3;
+          const o3 = this.options.radius / (this.options.extent * Math.pow(2, n3 - 1)), a3 = i3.within(s3[e3 * this.stride], s3[e3 * this.stride + 1], o3), l3 = [];
+          for (const e4 of a3) {
+            const n4 = e4 * this.stride;
+            s3[n4 + 4] === t3 && l3.push(s3[n4 + 5] > 1 ? Rc2(s3, n4, this.clusterProps) : fc2(this.points[s3[n4 + 3]]));
+          }
+          if (0 === l3.length) throw r3;
+          return l3;
+        }
+        getLeaves(t3, e3, n3) {
+          const r3 = [];
+          return this.appendLeaves(r3, t3, e3 = e3 || 10, n3 = n3 || 0, 0), r3;
+        }
+        getTile(t3, e3, n3) {
+          const r3 = this.trees[this.limitZoom(t3)];
+          if (!r3) return null;
+          const i3 = Math.pow(2, t3), { extent: s3, radius: o3 } = this.options, a3 = o3 / s3, l3 = (n3 - a3) / i3, u3 = (n3 + 1 + a3) / i3, c3 = { transformed: true, features: [], source: null, x: e3, y: n3, z: t3 };
+          return this.addTileFeatures(r3.range((e3 - a3) / i3, l3, (e3 + 1 + a3) / i3, u3), r3.flatData, e3, n3, i3, c3), 0 === e3 && this.addTileFeatures(r3.range(1 - a3 / i3, l3, 1, u3), r3.flatData, i3, n3, i3, c3), e3 === i3 - 1 && this.addTileFeatures(r3.range(0, l3, a3 / i3, u3), r3.flatData, -1, n3, i3, c3), c3;
+        }
+        getClusterExpansionZoom(t3) {
+          return this.getOriginZoom(t3);
+        }
+        appendLeaves(t3, e3, n3, r3, i3) {
+          const s3 = this.getChildren(e3);
+          for (const e4 of s3) {
+            const s4 = e4.properties;
+            if ((s4 == null ? void 0 : s4.cluster) ? i3 + s4.point_count <= r3 ? i3 += s4.point_count : i3 = this.appendLeaves(t3, s4.cluster_id, n3, r3, i3) : i3 < r3 ? i3++ : t3.push(e4), t3.length === n3) break;
+          }
+          return i3;
+        }
+        createTree(t3) {
+          const e3 = new Ku(t3.length / this.stride | 0, this.options.nodeSize, Float32Array);
+          for (let n3 = 0; n3 < t3.length; n3 += this.stride) e3.add(t3[n3], t3[n3 + 1]);
+          return e3.finish(), e3.flatData = t3, e3.data = null, e3;
+        }
+        addTileFeatures(t3, e3, n3, r3, i3, s3) {
+          for (const o3 of t3) {
+            const t4 = o3 * this.stride, a3 = e3[t4 + 5] > 1;
+            let l3, u3, c3;
+            if (a3) l3 = Nc2(e3, t4, this.clusterProps), u3 = e3[t4], c3 = e3[t4 + 1];
+            else {
+              const n4 = this.points[e3[t4 + 3]];
+              l3 = n4.tags, [u3, c3] = n4.geometry;
+            }
+            const h3 = { type: 1, geometry: [[Math.round(this.options.extent * (u3 * i3 - n3)), Math.round(this.options.extent * (c3 * i3 - r3))]], tags: l3 };
+            let p3;
+            p3 = a3 || this.options.generateId ? e3[t4 + 3] : this.points[e3[t4 + 3]].id, void 0 !== p3 && (h3.id = p3), s3.features.push(h3);
+          }
+        }
+        limitZoom(t3) {
+          return Math.max(this.options.minZoom, Math.min(Math.floor(+t3), this.options.maxZoom + 1));
+        }
+        cluster(t3, e3) {
+          const { radius: n3, extent: r3, reduce: i3, minPoints: s3 } = this.options, o3 = n3 / (r3 * Math.pow(2, e3)), a3 = t3.flatData, l3 = [], u3 = this.stride;
+          for (let n4 = 0; n4 < a3.length; n4 += u3) {
+            if (a3[n4 + 2] <= e3) continue;
+            a3[n4 + 2] = e3;
+            const r4 = a3[n4], c3 = a3[n4 + 1], h3 = t3.within(a3[n4], a3[n4 + 1], o3), p3 = a3[n4 + 5];
+            let f3 = p3;
+            for (const t4 of h3) {
+              const n5 = t4 * u3;
+              a3[n5 + 2] > e3 && (f3 += a3[n5 + 5]);
+            }
+            if (f3 > p3 && f3 >= s3) {
+              let t4, s4 = r4 * p3, o4 = c3 * p3, d3 = -1;
+              const y3 = (n4 / u3 << 5) + (e3 + 1) + this.points.length;
+              for (const r5 of h3) {
+                const l4 = r5 * u3;
+                if (a3[l4 + 2] <= e3) continue;
+                a3[l4 + 2] = e3;
+                const c4 = a3[l4 + 5];
+                s4 += a3[l4] * c4, o4 += a3[l4 + 1] * c4, a3[l4 + 4] = y3, i3 && (t4 || (t4 = this.map(a3, n4, true), d3 = this.clusterProps.length, this.clusterProps.push(t4)), i3(t4, this.map(a3, l4)));
+              }
+              a3[n4 + 4] = y3, l3.push(s4 / f3, o4 / f3, 1 / 0, y3, -1, f3), i3 && l3.push(d3);
+            } else {
+              for (let t4 = 0; t4 < u3; t4++) l3.push(a3[n4 + t4]);
+              if (f3 > 1) for (const t4 of h3) {
+                const n5 = t4 * u3;
+                if (!(a3[n5 + 2] <= e3)) {
+                  a3[n5 + 2] = e3;
+                  for (let t5 = 0; t5 < u3; t5++) l3.push(a3[n5 + t5]);
+                }
+              }
+            }
+          }
+          return l3;
+        }
+        getOriginId(t3) {
+          return t3 - this.points.length >> 5;
+        }
+        getOriginZoom(t3) {
+          return (t3 - this.points.length) % 32;
+        }
+        map(t3, e3, n3) {
+          if (t3[e3 + 5] > 1) {
+            const r4 = this.clusterProps[t3[e3 + 6]];
+            return n3 ? Object.assign({}, r4) : r4;
+          }
+          const r3 = this.points[t3[e3 + 3]].tags, i3 = this.options.map(r3);
+          return n3 && i3 === r3 ? Object.assign({}, i3) : i3;
+        }
+      }
+      function $c2(t3, e3, n3) {
+        return { id: t3[e3 + 3], type: "Point", tags: Nc2(t3, e3, n3), geometry: [t3[e3], t3[e3 + 1]] };
+      }
+      function Rc2(t3, e3, n3) {
+        return { type: "Feature", id: t3[e3 + 3], properties: Nc2(t3, e3, n3), geometry: { type: "Point", coordinates: [gc2(t3[e3]), xc2(t3[e3 + 1])] } };
+      }
+      function Nc2(t3, e3, n3) {
+        const r3 = t3[e3 + 5], i3 = r3 >= 1e4 ? `${Math.round(r3 / 1e3)}k` : r3 >= 1e3 ? Math.round(r3 / 100) / 10 + "k" : r3, s3 = t3[e3 + 6], o3 = -1 === s3 ? {} : Object.assign({}, n3[s3]);
+        return Object.assign(o3, { cluster: true, cluster_id: t3[e3 + 3], point_count: r3, point_count_abbreviated: i3 });
+      }
+      const Uc2 = "geojsonvt_clip_start", jc2 = "geojsonvt_clip_end";
+      function qc2(t3, e3, n3, r3, i3) {
+        const s3 = e3 === i3.maxZoom ? 0 : i3.tolerance / ((1 << e3) * i3.extent), o3 = { transformed: false, features: [], source: null, x: n3, y: r3, z: e3, minX: 2, minY: 1, maxX: -1, maxY: 0, numPoints: 0, numSimplified: 0, numFeatures: t3.length };
+        for (const e4 of t3) Gc2(o3, e4, s3, i3);
+        return o3;
+      }
+      function Gc2(t3, e3, n3, r3) {
+        switch (t3.minX = Math.min(t3.minX, e3.minX), t3.minY = Math.min(t3.minY, e3.minY), t3.maxX = Math.max(t3.maxX, e3.maxX), t3.maxY = Math.max(t3.maxY, e3.maxY), e3.type) {
+          case "Point":
+          case "MultiPoint":
+            return void function(t4, e4) {
+              const n4 = [];
+              for (let r5 = 0; r5 < e4.geometry.length; r5 += 3) n4.push(e4.geometry[r5], e4.geometry[r5 + 1]), t4.numPoints++, t4.numSimplified++;
+              if (!n4.length) return;
+              const r4 = { type: 1, tags: e4.tags || null, geometry: n4 };
+              null !== e4.id && (r4.id = e4.id), t4.features.push(r4);
+            }(t3, e3);
+          case "LineString":
+            return void function(t4, e4, n4, r4) {
+              const i3 = [];
+              if (Xc2(i3, e4.geometry, t4, n4, false, false), !i3.length) return;
+              let s3 = e4.tags || null;
+              if (r4.lineMetrics) {
+                s3 = {};
+                for (const t5 in e4.tags) s3[t5] = e4.tags[t5];
+                s3[Uc2] = e4.geometry.start / e4.geometry.size, s3[jc2] = e4.geometry.end / e4.geometry.size;
+              }
+              const o3 = { type: 2, tags: s3, geometry: i3 };
+              null !== e4.id && (o3.id = e4.id), t4.features.push(o3);
+            }(t3, e3, n3, r3);
+          case "MultiLineString":
+          case "Polygon":
+            return void function(t4, e4, n4) {
+              const r4 = [];
+              for (let i4 = 0; i4 < e4.geometry.length; i4++) Xc2(r4, e4.geometry[i4], t4, n4, "Polygon" === e4.type, 0 === i4);
+              if (!r4.length) return;
+              const i3 = { type: "Polygon" === e4.type ? 3 : 2, tags: e4.tags || null, geometry: r4 };
+              null !== e4.id && (i3.id = e4.id), t4.features.push(i3);
+            }(t3, e3, n3);
+          case "MultiPolygon":
+            return void function(t4, e4, n4) {
+              const r4 = [];
+              for (let i4 = 0; i4 < e4.geometry.length; i4++) {
+                const s3 = e4.geometry[i4];
+                for (let e5 = 0; e5 < s3.length; e5++) Xc2(r4, s3[e5], t4, n4, true, 0 === e5);
+              }
+              if (!r4.length) return;
+              const i3 = { type: 3, tags: e4.tags || null, geometry: r4 };
+              null !== e4.id && (i3.id = e4.id), t4.features.push(i3);
+            }(t3, e3, n3);
+        }
+      }
+      function Xc2(t3, e3, n3, r3, i3, s3) {
+        const o3 = r3 * r3;
+        if (r3 > 0 && e3.size < (i3 ? o3 : r3)) return void (n3.numPoints += e3.length / 3);
+        const a3 = [];
+        for (let t4 = 0; t4 < e3.length; t4 += 3) (0 === r3 || e3[t4 + 2] > o3) && (n3.numSimplified++, a3.push(e3[t4], e3[t4 + 1])), n3.numPoints++;
+        i3 && function(t4, e4) {
+          let n4 = 0;
+          for (let e5 = 0, r4 = t4.length, i4 = r4 - 2; e5 < r4; i4 = e5, e5 += 2) n4 += (t4[e5] - t4[i4]) * (t4[e5 + 1] + t4[i4 + 1]);
+          if (n4 > 0 === e4) for (let e5 = 0, n5 = t4.length; e5 < n5 / 2; e5 += 2) {
+            const r4 = t4[e5], i4 = t4[e5 + 1];
+            t4[e5] = t4[n5 - 2 - e5], t4[e5 + 1] = t4[n5 - 1 - e5], t4[n5 - 2 - e5] = r4, t4[n5 - 1 - e5] = i4;
+          }
+        }(a3, s3), t3.push(a3);
+      }
+      function Yc2(t3, e3) {
+        if (t3.transformed) return t3;
+        const n3 = 1 << t3.z, r3 = t3.x, i3 = t3.y;
+        for (const s3 of t3.features) 1 === s3.type ? Zc2(s3, e3, n3, r3, i3) : Hc2(s3, e3, n3, r3, i3);
+        return t3.transformed = true, t3;
+      }
+      function Zc2(t3, e3, n3, r3, i3) {
+        const s3 = t3, o3 = t3.geometry, a3 = [];
+        for (let t4 = 0; t4 < o3.length; t4 += 2) a3.push(Wc2(o3[t4], o3[t4 + 1], e3, n3, r3, i3));
+        return s3.geometry = a3, s3;
+      }
+      function Hc2(t3, e3, n3, r3, i3) {
+        const s3 = t3, o3 = t3.geometry, a3 = [];
+        for (const t4 of o3) {
+          const s4 = [];
+          for (let o4 = 0; o4 < t4.length; o4 += 2) s4.push(Wc2(t4[o4], t4[o4 + 1], e3, n3, r3, i3));
+          a3.push(s4);
+        }
+        return s3.geometry = a3, s3;
+      }
+      function Wc2(t3, e3, n3, r3, i3, s3) {
+        return [Math.round(n3 * (t3 * r3 - i3)), Math.round(n3 * (e3 * r3 - s3))];
+      }
+      class Kc2 {
+        constructor(t3) {
+          this.options = t3, this.stats = {}, this.total = 0, this.tiles = {}, this.tileCoords = [], this.stats = {}, this.total = 0;
+        }
+        initialize(t3) {
+          this.splitTile(t3, 0, 0, 0), this.options.debug && (t3.length && console.log("features: %d, points: %d", this.tiles[0].numFeatures, this.tiles[0].numPoints), console.timeEnd("generate tiles"), console.log("tiles generated:", this.total, JSON.stringify(this.stats)));
+        }
+        updateIndex(t3, e3, n3) {
+          n3.debug > 1 && (console.log("invalidating tiles"), console.time("invalidating")), this.invalidateTiles(e3), n3.debug > 1 && console.timeEnd("invalidating");
+          const [r3, i3, s3] = [0, 0, 0], o3 = qc2(t3, r3, i3, s3, n3);
+          o3.source = t3;
+          const a3 = Jc2(r3, i3, s3);
+          if (this.tiles[a3] = o3, this.tileCoords.push({ z: r3, x: i3, y: s3, id: a3 }), n3.debug) {
+            const t4 = `z${r3}`;
+            this.stats[t4] = (this.stats[t4] || 0) + 1, this.total++;
+          }
+        }
+        getClusterExpansionZoom(t3) {
+          return null;
+        }
+        getChildren(t3) {
+          return null;
+        }
+        getLeaves(t3, e3, n3) {
+          return null;
+        }
+        getTile(t3, e3, n3) {
+          const { extent: r3, debug: i3 } = this.options, s3 = 1 << t3, o3 = Jc2(t3, e3 = e3 + s3 & s3 - 1, n3);
+          if (this.tiles[o3]) return Yc2(this.tiles[o3], r3);
+          i3 > 1 && console.log("drilling down to z%d-%d-%d", t3, e3, n3);
+          let a3, l3 = t3, u3 = e3, c3 = n3;
+          for (; !a3 && l3 > 0; ) l3--, u3 >>= 1, c3 >>= 1, a3 = this.tiles[Jc2(l3, u3, c3)];
+          return (a3 == null ? void 0 : a3.source) ? (i3 > 1 && (console.log("found parent tile z%d-%d-%d", l3, u3, c3), console.time("drilling down")), this.splitTile(a3.source, l3, u3, c3, t3, e3, n3), i3 > 1 && console.timeEnd("drilling down"), this.tiles[o3] ? Yc2(this.tiles[o3], r3) : null) : null;
+        }
+        splitTile(t3, e3, n3, r3, i3, s3, o3) {
+          const a3 = [t3, e3, n3, r3], l3 = this.options, u3 = l3.debug;
+          for (; a3.length; ) {
+            r3 = a3.pop(), n3 = a3.pop(), e3 = a3.pop(), t3 = a3.pop();
+            const c3 = 1 << e3, h3 = Jc2(e3, n3, r3);
+            let p3 = this.tiles[h3];
+            if (!p3 && (u3 > 1 && console.time("creation"), p3 = this.tiles[h3] = qc2(t3, e3, n3, r3, l3), this.tileCoords.push({ z: e3, x: n3, y: r3, id: h3 }), u3)) {
+              u3 > 1 && (console.log("tile z%d-%d-%d (features: %d, points: %d, simplified: %d)", e3, n3, r3, p3.numFeatures, p3.numPoints, p3.numSimplified), console.timeEnd("creation"));
+              const t4 = `z${e3}`;
+              this.stats[t4] = (this.stats[t4] || 0) + 1, this.total++;
+            }
+            if (p3.source = t3, null == i3) {
+              if (e3 === l3.indexMaxZoom || p3.numPoints <= l3.indexMaxPoints) continue;
+            } else {
+              if (e3 === l3.maxZoom || e3 === i3) continue;
+              if (null != i3) {
+                const t4 = i3 - e3;
+                if (n3 !== s3 >> t4 || r3 !== o3 >> t4) continue;
+              }
+            }
+            if (p3.source = null, !t3.length) continue;
+            u3 > 1 && console.time("clipping");
+            const f3 = 0.5 * l3.buffer / l3.extent, d3 = 0.5 - f3, y3 = 0.5 + f3, m3 = 1 + f3;
+            let g3 = null, x3 = null, v3 = null, b3 = null;
+            const w3 = bc2(t3, c3, n3 - f3, n3 + y3, vc2.X, p3.minX, p3.maxX, l3), _3 = bc2(t3, c3, n3 + d3, n3 + m3, vc2.X, p3.minX, p3.maxX, l3);
+            w3 && (g3 = bc2(w3, c3, r3 - f3, r3 + y3, vc2.Y, p3.minY, p3.maxY, l3), x3 = bc2(w3, c3, r3 + d3, r3 + m3, vc2.Y, p3.minY, p3.maxY, l3)), _3 && (v3 = bc2(_3, c3, r3 - f3, r3 + y3, vc2.Y, p3.minY, p3.maxY, l3), b3 = bc2(_3, c3, r3 + d3, r3 + m3, vc2.Y, p3.minY, p3.maxY, l3)), u3 > 1 && console.timeEnd("clipping"), a3.push(g3 || [], e3 + 1, 2 * n3, 2 * r3), a3.push(x3 || [], e3 + 1, 2 * n3, 2 * r3 + 1), a3.push(v3 || [], e3 + 1, 2 * n3 + 1, 2 * r3), a3.push(b3 || [], e3 + 1, 2 * n3 + 1, 2 * r3 + 1);
+          }
+        }
+        invalidateTiles(t3) {
+          if (!t3.length) return;
+          const e3 = this.options, { debug: n3 } = e3;
+          let r3 = 1 / 0, i3 = -1 / 0, s3 = 1 / 0, o3 = -1 / 0;
+          for (const e4 of t3) r3 = Math.min(r3, e4.minX), i3 = Math.max(i3, e4.maxX), s3 = Math.min(s3, e4.minY), o3 = Math.max(o3, e4.maxY);
+          const a3 = e3.buffer / e3.extent, l3 = /* @__PURE__ */ new Set();
+          for (const e4 in this.tiles) {
+            const u3 = this.tiles[e4], c3 = 1 << u3.z, h3 = (u3.x - a3) / c3, p3 = (u3.x + 1 + a3) / c3, f3 = (u3.y - a3) / c3, d3 = (u3.y + 1 + a3) / c3;
+            if (i3 < h3 || r3 >= p3 || o3 < f3 || s3 >= d3) continue;
+            let y3 = false;
+            for (const e5 of t3) if (e5.maxX >= h3 && e5.minX < p3 && e5.maxY >= f3 && e5.minY < d3) {
+              y3 = true;
+              break;
+            }
+            if (y3) {
+              if (n3) {
+                n3 > 1 && console.log("invalidate tile z%d-%d-%d (features: %d, points: %d, simplified: %d)", u3.z, u3.x, u3.y, u3.numFeatures, u3.numPoints, u3.numSimplified);
+                const t4 = `z${u3.z}`;
+                this.stats[t4] = (this.stats[t4] || 0) - 1, this.total--;
+              }
+              delete this.tiles[e4], l3.add(e4);
+            }
+          }
+          l3.size && (this.tileCoords = this.tileCoords.filter((t4) => !l3.has(t4.id)));
+        }
+      }
+      function Jc2(t3, e3, n3) {
+        return 32 * ((1 << t3) * n3 + e3) + t3;
+      }
+      const Qc2 = { maxZoom: 14, indexMaxZoom: 5, indexMaxPoints: 1e5, tolerance: 3, extent: 4096, buffer: 64, lineMetrics: false, promoteId: null, generateId: false, updateable: false, cluster: false, clusterOptions: Lc2, debug: 0 }, th2 = ro([{ name: "a_pos_normal", components: 2, type: "Int16" }, { name: "a_data", components: 4, type: "Uint8" }], 4), { members: eh2 } = th2, nh2 = ro([{ name: "a_uv_x", components: 1, type: "Float32" }, { name: "a_split_index", components: 1, type: "Float32" }]), { members: rh2 } = nh2, ih2 = Math.cos(Math.PI / 180 * 37.5), sh2 = Math.pow(2, 14) / 0.5;
+      class oh2 {
+        constructor(t3) {
+          this.zoom = t3.zoom, this.overscaling = t3.overscaling, this.layers = t3.layers, this.layerIds = this.layers.map((t4) => t4.id), this.index = t3.index, this.hasDependencies = false, this.patternFeatures = [], this.lineClipsArray = [], this.gradients = {}, this.layers.forEach((t4) => {
+            this.gradients[t4.id] = {};
+          }), this.layoutVertexArray = new Xo(), this.layoutVertexArray2 = new Yo(), this.indexArray = new ea2(), this.programConfigurations = new Ca2(t3.layers, t3.zoom), this.segments = new sa2(), this.maxLineLength = 0, this.stateDependentLayerIds = this.layers.filter((t4) => t4.isStateDependent()).map((t4) => t4.id);
+        }
+        populate(t3, e3, n3) {
+          this.hasDependencies = Rl("line", this.layers, e3) || this.hasLineDasharray(this.layers);
+          const r3 = this.layers[0].layout.get("line-sort-key"), i3 = !r3.isConstant(), s3 = [];
+          for (const { feature: e4, id: o3, index: a3, sourceLayerIndex: l3 } of t3) {
+            const t4 = this.layers[0]._featureFilter.needGeometry, u3 = Na2(e4, t4);
+            if (!this.layers[0]._featureFilter.filter(new zs(this.zoom), u3, n3)) continue;
+            const c3 = i3 ? r3.evaluate(u3, {}, n3) : void 0, h3 = { id: o3, properties: e4.properties, type: e4.type, sourceLayerIndex: l3, index: a3, geometry: t4 ? u3.geometry : Ra2(e4), patterns: {}, dashes: {}, sortKey: c3 };
+            s3.push(h3);
+          }
+          i3 && s3.sort((t4, e4) => t4.sortKey - e4.sortKey);
+          for (const r4 of s3) {
+            const { geometry: i4, index: s4, sourceLayerIndex: o3 } = r4;
+            this.hasDependencies ? (Rl("line", this.layers, e3) ? Nl("line", this.layers, r4, { zoom: this.zoom }, e3) : this.hasLineDasharray(this.layers) && this.addLineDashDependencies(this.layers, r4, this.zoom, e3), this.patternFeatures.push(r4)) : this.addFeature(r4, i4, s4, n3, {}, {}, e3.subdivisionGranularity), e3.featureIndex.insert(t3[s4].feature, i4, s4, o3, this.index);
+          }
+        }
+        update(t3, e3, n3, r3) {
+          this.stateDependentLayers.length && this.programConfigurations.updatePaintArrays(t3, e3, this.stateDependentLayers, { imagePositions: n3, dashPositions: r3 });
+        }
+        addFeatures(t3, e3, n3, r3) {
+          for (const i3 of this.patternFeatures) this.addFeature(i3, i3.geometry, i3.index, e3, n3, r3, t3.subdivisionGranularity);
+        }
+        isEmpty() {
+          return 0 === this.layoutVertexArray.length;
+        }
+        uploadPending() {
+          return !this.uploaded || this.programConfigurations.needsUpload;
+        }
+        upload(t3) {
+          this.uploaded || (0 !== this.layoutVertexArray2.length && (this.layoutVertexBuffer2 = t3.createVertexBuffer(this.layoutVertexArray2, rh2)), this.layoutVertexBuffer = t3.createVertexBuffer(this.layoutVertexArray, eh2), this.indexBuffer = t3.createIndexBuffer(this.indexArray)), this.programConfigurations.upload(t3), this.uploaded = true;
+        }
+        destroy() {
+          this.layoutVertexBuffer && (this.layoutVertexBuffer.destroy(), this.indexBuffer.destroy(), this.programConfigurations.destroy(), this.segments.destroy());
+        }
+        lineFeatureClips(t3) {
+          if (t3.properties && Object.prototype.hasOwnProperty.call(t3.properties, Uc2) && Object.prototype.hasOwnProperty.call(t3.properties, jc2)) return { start: +t3.properties[Uc2], end: +t3.properties[jc2] };
+        }
+        addFeature(t3, e3, n3, r3, i3, s3, o3) {
+          const a3 = this.layers[0].layout, l3 = a3.get("line-join").evaluate(t3, {}), u3 = a3.get("line-cap"), c3 = a3.get("line-miter-limit"), h3 = a3.get("line-round-limit");
+          this.lineClips = this.lineFeatureClips(t3);
+          for (const n4 of e3) this.addLine(n4, t3, l3, u3, c3, h3, r3, o3);
+          this.programConfigurations.populatePaintArrays(this.layoutVertexArray.length, t3, n3, { imagePositions: i3, dashPositions: s3, canonical: r3 });
+        }
+        addLine(t3, e3, n3, r3, i3, s3, o3, a3) {
+          if (this.distance = 0, this.scaledDistance = 0, this.totalDistance = 0, t3 = vu(t3, o3 ? a3.line.getGranularityForZoomLevel(o3.z) : 1), this.lineClips) {
+            this.lineClipsArray.push(this.lineClips);
+            for (let e4 = 0; e4 < t3.length - 1; e4++) this.totalDistance += t3[e4].dist(t3[e4 + 1]);
+            this.updateScaledDistance(), this.maxLineLength = Math.max(this.maxLineLength, this.totalDistance);
+          }
+          const l3 = "Polygon" === Du.types[e3.type];
+          let u3 = t3.length;
+          for (; u3 >= 2 && t3[u3 - 1].equals(t3[u3 - 2]); ) u3--;
+          let c3 = 0;
+          for (; c3 < u3 - 1 && t3[c3].equals(t3[c3 + 1]); ) c3++;
+          if (u3 < (l3 ? 3 : 2)) return;
+          "bevel" === n3 && (i3 = 1.05);
+          const h3 = this.overscaling <= 16 ? 122880 / (512 * this.overscaling) : 0, p3 = this.segments.prepareSegment(10 * u3, this.layoutVertexArray, this.indexArray);
+          let f3, d3, y3, m3, g3;
+          this.e1 = this.e2 = -1, l3 && (f3 = t3[u3 - 2], g3 = t3[c3].sub(f3)._unit()._perp());
+          for (let e4 = c3; e4 < u3; e4++) {
+            if (y3 = e4 === u3 - 1 ? l3 ? t3[c3 + 1] : void 0 : t3[e4 + 1], y3 && t3[e4].equals(y3)) continue;
+            g3 && (m3 = g3), f3 && (d3 = f3), f3 = t3[e4], g3 = y3 ? y3.sub(f3)._unit()._perp() : m3, m3 = m3 || g3;
+            let o4 = m3.add(g3);
+            0 === o4.x && 0 === o4.y || o4._unit();
+            const a4 = m3.x * g3.x + m3.y * g3.y, x3 = o4.x * g3.x + o4.y * g3.y, v3 = 0 !== x3 ? 1 / x3 : 1 / 0, b3 = 2 * Math.sqrt(2 - 2 * x3), w3 = x3 < ih2 && d3 && y3, _3 = m3.x * g3.y - m3.y * g3.x > 0;
+            if (w3 && e4 > c3) {
+              const t4 = f3.dist(d3);
+              if (t4 > 2 * h3) {
+                const e5 = f3.sub(f3.sub(d3)._mult(h3 / t4)._round());
+                this.updateDistance(d3, e5), this.addCurrentVertex(e5, m3, 0, 0, p3), d3 = e5;
+              }
+            }
+            const S3 = d3 && y3;
+            let A3 = S3 ? n3 : l3 ? "butt" : r3;
+            if (S3 && "round" === A3 && (v3 < s3 ? A3 = "miter" : v3 <= 2 && (A3 = "fakeround")), "miter" === A3 && v3 > i3 && (A3 = "bevel"), "bevel" === A3 && (v3 > 2 && (A3 = "flipbevel"), v3 < i3 && (A3 = "miter")), d3 && this.updateDistance(d3, f3), "miter" === A3) o4._mult(v3), this.addCurrentVertex(f3, o4, 0, 0, p3);
+            else if ("flipbevel" === A3) {
+              if (v3 > 100) o4 = g3.mult(-1);
+              else {
+                const t4 = v3 * m3.add(g3).mag() / m3.sub(g3).mag();
+                o4._perp()._mult(t4 * (_3 ? -1 : 1));
+              }
+              this.addCurrentVertex(f3, o4, 0, 0, p3), this.addCurrentVertex(f3, o4.mult(-1), 0, 0, p3);
+            } else if ("bevel" === A3 || "fakeround" === A3) {
+              const t4 = -Math.sqrt(v3 * v3 - 1), e5 = _3 ? t4 : 0, n4 = _3 ? 0 : t4;
+              if (d3 && this.addCurrentVertex(f3, m3, e5, n4, p3), "fakeround" === A3) {
+                const t5 = Math.round(180 * b3 / Math.PI / 20);
+                for (let e6 = 1; e6 < t5; e6++) {
+                  let n5 = e6 / t5;
+                  if (0.5 !== n5) {
+                    const t6 = n5 - 0.5;
+                    n5 += n5 * t6 * (n5 - 1) * ((1.0904 + a4 * (a4 * (3.55645 - 1.43519 * a4) - 3.2452)) * t6 * t6 + (0.848013 + a4 * (0.215638 * a4 - 1.06021)));
+                  }
+                  const r4 = g3.sub(m3)._mult(n5)._add(m3)._unit()._mult(_3 ? -1 : 1);
+                  this.addHalfVertex(f3, r4.x, r4.y, false, _3, 0, p3);
+                }
+              }
+              y3 && this.addCurrentVertex(f3, g3, -e5, -n4, p3);
+            } else if ("butt" === A3) this.addCurrentVertex(f3, o4, 0, 0, p3);
+            else if ("square" === A3) {
+              const t4 = d3 ? 1 : -1;
+              this.addCurrentVertex(f3, o4, t4, t4, p3);
+            } else "round" === A3 && (d3 && (this.addCurrentVertex(f3, m3, 0, 0, p3), this.addCurrentVertex(f3, m3, 1, 1, p3, true)), y3 && (this.addCurrentVertex(f3, g3, -1, -1, p3, true), this.addCurrentVertex(f3, g3, 0, 0, p3)));
+            if (w3 && e4 < u3 - 1) {
+              const t4 = f3.dist(y3);
+              if (t4 > 2 * h3) {
+                const e5 = f3.add(y3.sub(f3)._mult(h3 / t4)._round());
+                this.updateDistance(f3, e5), this.addCurrentVertex(e5, g3, 0, 0, p3), f3 = e5;
+              }
+            }
+          }
+        }
+        addCurrentVertex(t3, e3, n3, r3, i3, s3 = false) {
+          const o3 = e3.y * r3 - e3.x, a3 = -e3.y - e3.x * r3;
+          this.addHalfVertex(t3, e3.x + e3.y * n3, e3.y - e3.x * n3, s3, false, n3, i3), this.addHalfVertex(t3, o3, a3, s3, true, -r3, i3), this.distance > sh2 / 2 && 0 === this.totalDistance && (this.distance = 0, this.updateScaledDistance(), this.addCurrentVertex(t3, e3, n3, r3, i3, s3));
+        }
+        addHalfVertex({ x: t3, y: e3 }, n3, r3, i3, s3, o3, a3) {
+          const l3 = 0.5 * (this.lineClips ? this.scaledDistance * (sh2 - 1) : this.scaledDistance);
+          this.layoutVertexArray.emplaceBack((t3 << 1) + (i3 ? 1 : 0), (e3 << 1) + (s3 ? 1 : 0), Math.round(63 * n3) + 128, Math.round(63 * r3) + 128, 1 + (0 === o3 ? 0 : o3 < 0 ? -1 : 1) | (63 & l3) << 2, l3 >> 6), this.lineClips && this.layoutVertexArray2.emplaceBack((this.scaledDistance - this.lineClips.start) / (this.lineClips.end - this.lineClips.start), this.lineClipsArray.length);
+          const u3 = a3.vertexLength++;
+          this.e1 >= 0 && this.e2 >= 0 && (this.indexArray.emplaceBack(this.e1, u3, this.e2), a3.primitiveLength++), s3 ? this.e2 = u3 : this.e1 = u3;
+        }
+        updateScaledDistance() {
+          this.scaledDistance = this.lineClips ? this.lineClips.start + (this.lineClips.end - this.lineClips.start) * this.distance / this.totalDistance : this.distance;
+        }
+        updateDistance(t3, e3) {
+          this.distance += t3.dist(e3), this.updateScaledDistance();
+        }
+        hasLineDasharray(t3) {
+          for (const e3 of t3) {
+            const t4 = e3.paint.get("line-dasharray");
+            if (t4 && !t4.isConstant()) return true;
+          }
+          return false;
+        }
+        addLineDashDependencies(t3, e3, n3, r3) {
+          for (const i3 of t3) {
+            const t4 = i3.paint.get("line-dasharray");
+            if (!t4 || "constant" === t4.value.kind) continue;
+            const s3 = "round" === i3.layout.get("line-cap"), o3 = { dasharray: t4.value.evaluate({ zoom: n3 - 1 }, e3, {}), round: s3 }, a3 = { dasharray: t4.value.evaluate({ zoom: n3 }, e3, {}), round: s3 }, l3 = { dasharray: t4.value.evaluate({ zoom: n3 + 1 }, e3, {}), round: s3 }, u3 = `${o3.dasharray.join(",")},${o3.round}`, c3 = `${a3.dasharray.join(",")},${a3.round}`, h3 = `${l3.dasharray.join(",")},${l3.round}`;
+            r3.dashDependencies[u3] = o3, r3.dashDependencies[c3] = a3, r3.dashDependencies[h3] = l3, e3.dashes[i3.id] = { min: u3, mid: c3, max: h3 };
+          }
+        }
+      }
+      let ah2, lh2;
+      ps("LineBucket", oh2, { omit: ["layers", "patternFeatures"] });
+      var uh2 = { get paint() {
+        return lh2 = lh2 || new Hs({ "line-opacity": new Gs(vt.paint_line["line-opacity"]), "line-color": new Gs(vt.paint_line["line-color"]), "line-translate": new qs(vt.paint_line["line-translate"]), "line-translate-anchor": new qs(vt.paint_line["line-translate-anchor"]), "line-width": new Gs(vt.paint_line["line-width"]), "line-gap-width": new Gs(vt.paint_line["line-gap-width"]), "line-offset": new Gs(vt.paint_line["line-offset"]), "line-blur": new Gs(vt.paint_line["line-blur"]), "line-dasharray": new Xs(vt.paint_line["line-dasharray"]), "line-pattern": new Xs(vt.paint_line["line-pattern"]), "line-gradient": new Zs(vt.paint_line["line-gradient"]) });
+      }, get layout() {
+        return ah2 = ah2 || new Hs({ "line-cap": new qs(vt.layout_line["line-cap"]), "line-join": new Gs(vt.layout_line["line-join"]), "line-miter-limit": new qs(vt.layout_line["line-miter-limit"]), "line-round-limit": new qs(vt.layout_line["line-round-limit"]), "line-sort-key": new Gs(vt.layout_line["line-sort-key"]) });
+      } };
+      class ch2 extends Gs {
+        possiblyEvaluate(t3, e3) {
+          return e3 = new zs(Math.floor(e3.zoom), { now: e3.now, fadeDuration: e3.fadeDuration, zoomHistory: e3.zoomHistory, transition: e3.transition }), super.possiblyEvaluate(t3, e3);
+        }
+        evaluate(t3, e3, n3, r3) {
+          return e3 = O2({}, e3, { zoom: Math.floor(e3.zoom) }), super.evaluate(t3, e3, n3, r3);
+        }
+      }
+      let hh2;
+      class ph2 extends Ws {
+        constructor(t3, e3) {
+          super(t3, uh2, e3), this.gradientVersion = 0, hh2 || (hh2 = new ch2(uh2.paint.properties["line-width"].specification), hh2.useIntegerZoom = true);
+        }
+        _handleSpecialPaintPropertyUpdate(t3) {
+          if ("line-gradient" === t3) {
+            const t4 = this.gradientExpression();
+            this.stepInterpolant = !!function(t5) {
+              return void 0 !== t5._styleExpression;
+            }(t4) && t4._styleExpression.expression instanceof ln, this.gradientVersion = (this.gradientVersion + 1) % Number.MAX_SAFE_INTEGER;
+          }
+        }
+        gradientExpression() {
+          return this._transitionablePaint._values["line-gradient"].value.expression;
+        }
+        recalculate(t3, e3) {
+          super.recalculate(t3, e3), this.paint._values["line-floorwidth"] = hh2.possiblyEvaluate(this._transitioningPaint._values["line-width"].value, t3);
+        }
+        createBucket(t3) {
+          return new oh2(t3);
+        }
+        queryRadius(t3) {
+          const e3 = t3, n3 = fh2(nl2("line-width", this, e3), nl2("line-gap-width", this, e3)), r3 = nl2("line-offset", this, e3);
+          return n3 / 2 + Math.abs(r3) + rl2(this.paint.get("line-translate"));
+        }
+        queryIntersectsFeature({ queryGeometry: t3, feature: e3, featureState: r3, geometry: i3, transform: s3, pixelsToTileUnits: o3 }) {
+          const a3 = il2(t3, this.paint.get("line-translate"), this.paint.get("line-translate-anchor"), -s3.bearingInRadians, o3), l3 = o3 / 2 * fh2(this.paint.get("line-width").evaluate(e3, r3), this.paint.get("line-gap-width").evaluate(e3, r3)), u3 = this.paint.get("line-offset").evaluate(e3, r3);
+          return u3 && (i3 = function(t4, e4) {
+            const r4 = [];
+            for (let i4 = 0; i4 < t4.length; i4++) {
+              const s4 = sl2(t4[i4]), o4 = [];
+              for (let t5 = 0; t5 < s4.length; t5++) {
+                const r5 = s4[t5], i5 = s4[t5 - 1], a4 = s4[t5 + 1], l4 = 0 === t5 ? new n2(0, 0) : r5.sub(i5)._unit()._perp(), u4 = t5 === s4.length - 1 ? new n2(0, 0) : a4.sub(r5)._unit()._perp(), c3 = l4._add(u4)._unit(), h3 = c3.x * u4.x + c3.y * u4.y;
+                0 !== h3 && c3._mult(1 / h3), o4.push(c3._mult(e4)._add(r5));
+              }
+              r4.push(o4);
+            }
+            return r4;
+          }(i3, u3 * o3)), function(t4, e4, n3) {
+            for (let r4 = 0; r4 < e4.length; r4++) {
+              const i4 = e4[r4];
+              if (t4.length >= 3) {
+                for (let e5 = 0; e5 < i4.length; e5++) if (tl2(t4, i4[e5])) return true;
+              }
+              if (Za2(t4, i4, n3)) return true;
+            }
+            return false;
+          }(a3, i3, l3);
+        }
+        isTileClipped() {
+          return true;
+        }
+      }
+      function fh2(t3, e3) {
+        return e3 > 0 ? e3 + 2 * t3 : t3;
+      }
+      const dh2 = ro([{ name: "a_pos_offset", components: 4, type: "Int16" }, { name: "a_data", components: 4, type: "Uint16" }, { name: "a_pixeloffset", components: 4, type: "Int16" }], 4), yh2 = ro([{ name: "a_projected_pos", components: 3, type: "Float32" }], 4);
+      ro([{ name: "a_fade_opacity", components: 1, type: "Uint32" }], 4);
+      const mh2 = ro([{ name: "a_placed", components: 2, type: "Uint8" }, { name: "a_shift", components: 2, type: "Float32" }, { name: "a_box_real", components: 2, type: "Int16" }]);
+      ro([{ type: "Int16", name: "anchorPointX" }, { type: "Int16", name: "anchorPointY" }, { type: "Int16", name: "x1" }, { type: "Int16", name: "y1" }, { type: "Int16", name: "x2" }, { type: "Int16", name: "y2" }, { type: "Uint32", name: "featureIndex" }, { type: "Uint16", name: "sourceLayerIndex" }, { type: "Uint16", name: "bucketIndex" }]);
+      const gh2 = ro([{ name: "a_pos", components: 2, type: "Int16" }, { name: "a_anchor_pos", components: 2, type: "Int16" }, { name: "a_extrude", components: 2, type: "Int16" }], 4), xh2 = ro([{ name: "a_pos", components: 2, type: "Float32" }, { name: "a_radius", components: 1, type: "Float32" }, { name: "a_flags", components: 2, type: "Int16" }], 4);
+      function vh2(t3, e3, n3) {
+        return t3.sections.forEach((t4) => {
+          t4.text = function(t5, e4, n4) {
+            const r3 = e4.layout.get("text-transform").evaluate(n4, {});
+            return "uppercase" === r3 ? t5 = t5.toLocaleUpperCase() : "lowercase" === r3 && (t5 = t5.toLocaleLowerCase()), Ps.applyArabicShaping && (t5 = Ps.applyArabicShaping(t5)), t5;
+          }(t4.text, e3, n3);
+        }), t3;
+      }
+      ro([{ name: "triangle", components: 3, type: "Uint16" }]), ro([{ type: "Int16", name: "anchorX" }, { type: "Int16", name: "anchorY" }, { type: "Uint16", name: "glyphStartIndex" }, { type: "Uint16", name: "numGlyphs" }, { type: "Uint32", name: "vertexStartIndex" }, { type: "Uint32", name: "lineStartIndex" }, { type: "Uint32", name: "lineLength" }, { type: "Uint16", name: "segment" }, { type: "Uint16", name: "lowerSize" }, { type: "Uint16", name: "upperSize" }, { type: "Float32", name: "lineOffsetX" }, { type: "Float32", name: "lineOffsetY" }, { type: "Uint8", name: "writingMode" }, { type: "Uint8", name: "placedOrientation" }, { type: "Uint8", name: "hidden" }, { type: "Uint32", name: "crossTileID" }, { type: "Int16", name: "associatedIconIndex" }]), ro([{ type: "Int16", name: "anchorX" }, { type: "Int16", name: "anchorY" }, { type: "Int16", name: "rightJustifiedTextSymbolIndex" }, { type: "Int16", name: "centerJustifiedTextSymbolIndex" }, { type: "Int16", name: "leftJustifiedTextSymbolIndex" }, { type: "Int16", name: "verticalPlacedTextSymbolIndex" }, { type: "Int16", name: "placedIconSymbolIndex" }, { type: "Int16", name: "verticalPlacedIconSymbolIndex" }, { type: "Uint16", name: "key" }, { type: "Uint16", name: "textBoxStartIndex" }, { type: "Uint16", name: "textBoxEndIndex" }, { type: "Uint16", name: "verticalTextBoxStartIndex" }, { type: "Uint16", name: "verticalTextBoxEndIndex" }, { type: "Uint16", name: "iconBoxStartIndex" }, { type: "Uint16", name: "iconBoxEndIndex" }, { type: "Uint16", name: "verticalIconBoxStartIndex" }, { type: "Uint16", name: "verticalIconBoxEndIndex" }, { type: "Uint16", name: "featureIndex" }, { type: "Uint16", name: "numHorizontalGlyphVertices" }, { type: "Uint16", name: "numVerticalGlyphVertices" }, { type: "Uint16", name: "numIconVertices" }, { type: "Uint16", name: "numVerticalIconVertices" }, { type: "Uint16", name: "useRuntimeCollisionCircles" }, { type: "Uint32", name: "crossTileID" }, { type: "Float32", name: "textBoxScale" }, { type: "Float32", name: "collisionCircleDiameter" }, { type: "Uint16", name: "textAnchorOffsetStartIndex" }, { type: "Uint16", name: "textAnchorOffsetEndIndex" }]), ro([{ type: "Float32", name: "offsetX" }]), ro([{ type: "Int16", name: "x" }, { type: "Int16", name: "y" }, { type: "Int16", name: "tileUnitDistanceFromAnchor" }]), ro([{ type: "Uint16", name: "textAnchor" }, { type: "Float32", components: 2, name: "textOffset" }]);
+      var bh2 = 24;
+      const wh2 = { "!": "︕", "#": "＃", $: "＄", "%": "％", "&": "＆", "(": "︵", ")": "︶", "*": "＊", "+": "＋", ",": "︐", "-": "︲", ".": "・", "/": "／", ":": "︓", ";": "︔", "<": "︿", "=": "＝", ">": "﹀", "?": "︖", "@": "＠", "[": "﹇", "\\": "＼", "]": "﹈", "^": "＾", _: "︳", "`": "｀", "{": "︷", "|": "―", "}": "︸", "~": "～", "¢": "￠", "£": "￡", "¥": "￥", "¦": "￤", "¬": "￢", "¯": "￣", "–": "︲", "—": "︱", "‘": "﹃", "’": "﹄", "“": "﹁", "”": "﹂", "…": "︙", "⋯": "︙", "‧": "・", "₩": "￦", "、": "︑", "。": "︒", "〈": "︿", "〉": "﹀", "《": "︽", "》": "︾", "「": "﹁", "」": "﹂", "『": "﹃", "』": "﹄", "【": "︻", "】": "︼", "〔": "︹", "〕": "︺", "〖": "︗", "〗": "︘", "！": "︕", "（": "︵", "）": "︶", "，": "︐", "－": "︲", "．": "・", "：": "︓", "；": "︔", "＜": "︿", "＞": "﹀", "？": "︖", "［": "﹇", "］": "﹈", "＿": "︳", "｛": "︷", "｜": "―", "｝": "︸", "｟": "︵", "｠": "︶", "｡": "︒", "｢": "﹁", "｣": "﹂" }, _h2 = { 10: true, 32: true, 38: true, 41: true, 43: true, 45: true, 47: true, 173: true, 183: true, 8203: true, 8208: true, 8211: true, 8231: true }, Sh2 = { 40: true };
+      function Ah2(t3, e3, n3, r3, i3, s3) {
+        if ("fontStack" in e3) {
+          const r4 = n3[e3.fontStack], s4 = r4 && r4[t3];
+          return s4 ? s4.metrics.advance * e3.scale + i3 : 0;
+        }
+        {
+          const t4 = r3[e3.imageName];
+          return t4 ? t4.displaySize[0] * e3.scale * bh2 / s3 + i3 : 0;
+        }
+      }
+      function Mh2(t3, e3, n3, r3) {
+        const i3 = Math.pow(t3 - e3, 2);
+        return r3 ? t3 < e3 ? i3 / 2 : 2 * i3 : i3 + Math.abs(n3) * n3;
+      }
+      function kh2(t3, e3, n3) {
+        let r3 = 0;
+        return 10 === t3 && (r3 -= 1e4), n3 && (r3 += 150), 40 !== t3 && 65288 !== t3 || (r3 += 50), 41 !== e3 && 65289 !== e3 || (r3 += 50), r3;
+      }
+      function Ih2(t3, e3, n3, r3, i3, s3) {
+        let o3 = null, a3 = Mh2(e3, n3, i3, s3);
+        for (const t4 of r3) {
+          const r4 = Mh2(e3 - t4.x, n3, i3, s3) + t4.badness;
+          r4 <= a3 && (o3 = t4, a3 = r4);
+        }
+        return { index: t3, x: e3, priorBreak: o3, badness: a3 };
+      }
+      function Eh2(t3) {
+        return t3 ? Eh2(t3.priorBreak).concat(t3.index) : [];
+      }
+      class Th2 {
+        constructor(t3 = "", e3 = [], n3 = []) {
+          this.text = t3, this.sections = e3, this.sectionIndex = n3, this.imageSectionID = null;
+        }
+        static fromFeature(t3, e3) {
+          const n3 = new Th2();
+          for (let r3 = 0; r3 < t3.sections.length; r3++) {
+            const i3 = t3.sections[r3];
+            i3.image ? n3.addImageSection(i3) : n3.addTextSection(i3, e3);
+          }
+          return n3;
+        }
+        length() {
+          return [...this.text].length;
+        }
+        getSection(t3) {
+          return this.sections[this.sectionIndex[t3]];
+        }
+        getSectionIndex(t3) {
+          return this.sectionIndex[t3];
+        }
+        verticalizePunctuation() {
+          this.text = function(t3) {
+            let e3 = "", n3 = { premature: true, value: void 0 };
+            const r3 = t3[Symbol.iterator]();
+            let i3 = r3.next();
+            const s3 = t3[Symbol.iterator]();
+            s3.next();
+            let o3 = s3.next();
+            for (; !i3.done; ) e3 += !o3.done && Is(o3.value.codePointAt(0)) && !wh2[o3.value] || !n3.premature && Is(n3.value.codePointAt(0)) && !wh2[n3.value] || !wh2[i3.value] ? i3.value : wh2[i3.value], n3 = { value: i3.value, premature: false }, i3 = r3.next(), o3 = s3.next();
+            return e3;
+          }(this.text);
+        }
+        hasZeroWidthSpaces() {
+          return this.text.includes("​");
+        }
+        trim() {
+          const t3 = this.text.match(/^\s*/), e3 = t3 ? t3[0].length : 0, n3 = this.text.match(/\S\s*$/), r3 = n3 ? n3[0].length - 1 : 0;
+          this.text = this.text.substring(e3, this.text.length - r3), this.sectionIndex = this.sectionIndex.slice(e3, this.sectionIndex.length - r3);
+        }
+        substring(t3, e3) {
+          const n3 = [...this.text].slice(t3, e3).join(""), r3 = this.sectionIndex.slice(t3, e3);
+          return new Th2(n3, this.sections, r3);
+        }
+        toCodeUnitIndex(t3) {
+          return [...this.text].slice(0, t3).join("").length;
+        }
+        toString() {
+          return this.text;
+        }
+        getMaxScale() {
+          return this.sectionIndex.reduce((t3, e3) => Math.max(t3, this.sections[e3].scale), 0);
+        }
+        getMaxImageSize(t3) {
+          let e3 = 0, n3 = 0;
+          for (let r3 = 0; r3 < this.length(); r3++) {
+            const i3 = this.getSection(r3);
+            if ("imageName" in i3) {
+              const r4 = t3[i3.imageName];
+              if (!r4) continue;
+              const s3 = r4.displaySize;
+              e3 = Math.max(e3, s3[0]), n3 = Math.max(n3, s3[1]);
+            }
+          }
+          return { maxImageWidth: e3, maxImageHeight: n3 };
+        }
+        addTextSection(t3, e3) {
+          this.text += t3.text, this.sections.push({ scale: t3.scale || 1, verticalAlign: t3.verticalAlign || "bottom", fontStack: t3.fontStack || e3 });
+          const n3 = this.sections.length - 1;
+          this.sectionIndex.push(...[...t3.text].map(() => n3));
+        }
+        addImageSection(t3) {
+          const e3 = t3.image ? t3.image.name : "";
+          if (0 === e3.length) return void q2("Can't add FormattedSection with an empty image.");
+          const n3 = this.getNextImageSectionCharCode();
+          n3 ? (this.text += String.fromCharCode(n3), this.sections.push({ scale: 1, verticalAlign: t3.verticalAlign || "bottom", imageName: e3 }), this.sectionIndex.push(this.sections.length - 1)) : q2("Reached maximum number of images 6401");
+        }
+        getNextImageSectionCharCode() {
+          return this.imageSectionID ? this.imageSectionID >= 63743 ? null : ++this.imageSectionID : (this.imageSectionID = 57344, this.imageSectionID);
+        }
+        determineLineBreaks(t3, e3, n3, r3, i3) {
+          const s3 = [], o3 = this.determineAverageLineWidth(t3, e3, n3, r3, i3), a3 = this.hasZeroWidthSpaces();
+          let l3 = 0, u3 = 0;
+          const c3 = this.text[Symbol.iterator]();
+          let h3 = c3.next();
+          const p3 = this.text[Symbol.iterator]();
+          p3.next();
+          let f3 = p3.next();
+          const d3 = this.text[Symbol.iterator]();
+          d3.next(), d3.next();
+          let y3 = d3.next();
+          for (; !h3.done; ) {
+            const e4 = this.getSection(u3), m3 = h3.value.codePointAt(0);
+            if (ws(m3) || (l3 += Ah2(m3, e4, n3, r3, t3, i3)), !f3.done) {
+              const t4 = vs2(m3), n4 = f3.value.codePointAt(0);
+              (_h2[m3] || t4 || "imageName" in e4 || !y3.done && Sh2[n4]) && s3.push(Ih2(u3 + 1, l3, o3, s3, kh2(m3, n4, t4 && a3), false));
+            }
+            u3++, h3 = c3.next(), f3 = p3.next(), y3 = d3.next();
+          }
+          return Eh2(Ih2(this.length(), l3, o3, s3, 0, true));
+        }
+        determineAverageLineWidth(t3, e3, n3, r3, i3) {
+          let s3 = 0, o3 = 0;
+          for (const e4 of this.text) {
+            const a3 = this.getSection(o3);
+            s3 += Ah2(e4.codePointAt(0), a3, n3, r3, t3, i3), o3++;
+          }
+          return s3 / Math.max(1, Math.ceil(s3 / e3));
+        }
+      }
+      const Fh2 = 4294967296, Dh2 = 1 / Fh2, Ph2 = "undefined" == typeof TextDecoder ? null : new TextDecoder("utf-8");
+      class zh2 {
+        constructor(t3 = new Uint8Array(16)) {
+          this.buf = ArrayBuffer.isView(t3) ? t3 : new Uint8Array(t3), this.dataView = new DataView(this.buf.buffer), this.pos = 0, this.type = 0, this.length = this.buf.length;
+        }
+        readFields(t3, e3, n3 = this.length) {
+          for (; this.pos < n3; ) {
+            const n4 = this.readVarint(), r3 = n4 >> 3, i3 = this.pos;
+            this.type = 7 & n4, t3(r3, e3, this), this.pos === i3 && this.skip(n4);
+          }
+          return e3;
+        }
+        readMessage(t3, e3) {
+          return this.readFields(t3, e3, this.readVarint() + this.pos);
+        }
+        readFixed32() {
+          const t3 = this.dataView.getUint32(this.pos, true);
+          return this.pos += 4, t3;
+        }
+        readSFixed32() {
+          const t3 = this.dataView.getInt32(this.pos, true);
+          return this.pos += 4, t3;
+        }
+        readFixed64() {
+          const t3 = this.dataView.getUint32(this.pos, true) + this.dataView.getUint32(this.pos + 4, true) * Fh2;
+          return this.pos += 8, t3;
+        }
+        readSFixed64() {
+          const t3 = this.dataView.getUint32(this.pos, true) + this.dataView.getInt32(this.pos + 4, true) * Fh2;
+          return this.pos += 8, t3;
+        }
+        readFloat() {
+          const t3 = this.dataView.getFloat32(this.pos, true);
+          return this.pos += 4, t3;
+        }
+        readDouble() {
+          const t3 = this.dataView.getFloat64(this.pos, true);
+          return this.pos += 8, t3;
+        }
+        readVarint(t3) {
+          const e3 = this.buf;
+          let n3, r3;
+          return r3 = e3[this.pos++], n3 = 127 & r3, r3 < 128 ? n3 : (r3 = e3[this.pos++], n3 |= (127 & r3) << 7, r3 < 128 ? n3 : (r3 = e3[this.pos++], n3 |= (127 & r3) << 14, r3 < 128 ? n3 : (r3 = e3[this.pos++], n3 |= (127 & r3) << 21, r3 < 128 ? n3 : (r3 = e3[this.pos], n3 |= (15 & r3) << 28, function(t4, e4, n4) {
+            const r4 = n4.buf;
+            let i3, s3;
+            if (s3 = r4[n4.pos++], i3 = (112 & s3) >> 4, s3 < 128) return Bh2(t4, i3, e4);
+            if (s3 = r4[n4.pos++], i3 |= (127 & s3) << 3, s3 < 128) return Bh2(t4, i3, e4);
+            if (s3 = r4[n4.pos++], i3 |= (127 & s3) << 10, s3 < 128) return Bh2(t4, i3, e4);
+            if (s3 = r4[n4.pos++], i3 |= (127 & s3) << 17, s3 < 128) return Bh2(t4, i3, e4);
+            if (s3 = r4[n4.pos++], i3 |= (127 & s3) << 24, s3 < 128) return Bh2(t4, i3, e4);
+            if (s3 = r4[n4.pos++], i3 |= (1 & s3) << 31, s3 < 128) return Bh2(t4, i3, e4);
+            throw new Error("Expected varint not more than 10 bytes");
+          }(n3, t3, this)))));
+        }
+        readVarint64() {
+          return this.readVarint(true);
+        }
+        readSVarint() {
+          const t3 = this.readVarint();
+          return t3 % 2 == 1 ? (t3 + 1) / -2 : t3 / 2;
+        }
+        readBoolean() {
+          return Boolean(this.readVarint());
+        }
+        readString() {
+          const t3 = this.readVarint() + this.pos, e3 = this.pos;
+          return this.pos = t3, t3 - e3 >= 12 && Ph2 ? Ph2.decode(this.buf.subarray(e3, t3)) : function(t4, e4, n3) {
+            let r3 = "", i3 = e4;
+            for (; i3 < n3; ) {
+              const e5 = t4[i3];
+              let s3, o3, a3, l3 = null, u3 = e5 > 239 ? 4 : e5 > 223 ? 3 : e5 > 191 ? 2 : 1;
+              if (i3 + u3 > n3) break;
+              1 === u3 ? e5 < 128 && (l3 = e5) : 2 === u3 ? (s3 = t4[i3 + 1], 128 == (192 & s3) && (l3 = (31 & e5) << 6 | 63 & s3, l3 <= 127 && (l3 = null))) : 3 === u3 ? (s3 = t4[i3 + 1], o3 = t4[i3 + 2], 128 == (192 & s3) && 128 == (192 & o3) && (l3 = (15 & e5) << 12 | (63 & s3) << 6 | 63 & o3, (l3 <= 2047 || l3 >= 55296 && l3 <= 57343) && (l3 = null))) : 4 === u3 && (s3 = t4[i3 + 1], o3 = t4[i3 + 2], a3 = t4[i3 + 3], 128 == (192 & s3) && 128 == (192 & o3) && 128 == (192 & a3) && (l3 = (15 & e5) << 18 | (63 & s3) << 12 | (63 & o3) << 6 | 63 & a3, (l3 <= 65535 || l3 >= 1114112) && (l3 = null))), null === l3 ? (l3 = 65533, u3 = 1) : l3 > 65535 && (l3 -= 65536, r3 += String.fromCharCode(l3 >>> 10 & 1023 | 55296), l3 = 56320 | 1023 & l3), r3 += String.fromCharCode(l3), i3 += u3;
+            }
+            return r3;
+          }(this.buf, e3, t3);
+        }
+        readBytes() {
+          const t3 = this.readVarint() + this.pos, e3 = this.buf.subarray(this.pos, t3);
+          return this.pos = t3, e3;
+        }
+        readPackedVarint(t3 = [], e3) {
+          const n3 = this.readPackedEnd();
+          for (; this.pos < n3; ) t3.push(this.readVarint(e3));
+          return t3;
+        }
+        readPackedSVarint(t3 = []) {
+          const e3 = this.readPackedEnd();
+          for (; this.pos < e3; ) t3.push(this.readSVarint());
+          return t3;
+        }
+        readPackedBoolean(t3 = []) {
+          const e3 = this.readPackedEnd();
+          for (; this.pos < e3; ) t3.push(this.readBoolean());
+          return t3;
+        }
+        readPackedFloat(t3 = []) {
+          const e3 = this.readPackedEnd();
+          for (; this.pos < e3; ) t3.push(this.readFloat());
+          return t3;
+        }
+        readPackedDouble(t3 = []) {
+          const e3 = this.readPackedEnd();
+          for (; this.pos < e3; ) t3.push(this.readDouble());
+          return t3;
+        }
+        readPackedFixed32(t3 = []) {
+          const e3 = this.readPackedEnd();
+          for (; this.pos < e3; ) t3.push(this.readFixed32());
+          return t3;
+        }
+        readPackedSFixed32(t3 = []) {
+          const e3 = this.readPackedEnd();
+          for (; this.pos < e3; ) t3.push(this.readSFixed32());
+          return t3;
+        }
+        readPackedFixed64(t3 = []) {
+          const e3 = this.readPackedEnd();
+          for (; this.pos < e3; ) t3.push(this.readFixed64());
+          return t3;
+        }
+        readPackedSFixed64(t3 = []) {
+          const e3 = this.readPackedEnd();
+          for (; this.pos < e3; ) t3.push(this.readSFixed64());
+          return t3;
+        }
+        readPackedEnd() {
+          return 2 === this.type ? this.readVarint() + this.pos : this.pos + 1;
+        }
+        skip(t3) {
+          const e3 = 7 & t3;
+          if (0 === e3) for (; this.buf[this.pos++] > 127; ) ;
+          else if (2 === e3) this.pos = this.readVarint() + this.pos;
+          else if (5 === e3) this.pos += 4;
+          else {
+            if (1 !== e3) throw new Error(`Unimplemented type: ${e3}`);
+            this.pos += 8;
+          }
+        }
+        writeTag(t3, e3) {
+          this.writeVarint(t3 << 3 | e3);
+        }
+        realloc(t3) {
+          let e3 = this.length || 16;
+          for (; e3 < this.pos + t3; ) e3 *= 2;
+          if (e3 !== this.length) {
+            const t4 = new Uint8Array(e3);
+            t4.set(this.buf), this.buf = t4, this.dataView = new DataView(t4.buffer), this.length = e3;
+          }
+        }
+        finish() {
+          return this.length = this.pos, this.pos = 0, this.buf.subarray(0, this.length);
+        }
+        writeFixed32(t3) {
+          this.realloc(4), this.dataView.setInt32(this.pos, t3, true), this.pos += 4;
+        }
+        writeSFixed32(t3) {
+          this.realloc(4), this.dataView.setInt32(this.pos, t3, true), this.pos += 4;
+        }
+        writeFixed64(t3) {
+          this.realloc(8), this.dataView.setInt32(this.pos, -1 & t3, true), this.dataView.setInt32(this.pos + 4, Math.floor(t3 * Dh2), true), this.pos += 8;
+        }
+        writeSFixed64(t3) {
+          this.realloc(8), this.dataView.setInt32(this.pos, -1 & t3, true), this.dataView.setInt32(this.pos + 4, Math.floor(t3 * Dh2), true), this.pos += 8;
+        }
+        writeVarint(t3) {
+          (t3 = +t3 || 0) > 268435455 || t3 < 0 ? function(t4, e3) {
+            let n3, r3;
+            if (t4 >= 0 ? (n3 = t4 % 4294967296 | 0, r3 = t4 / 4294967296 | 0) : (n3 = ~(-t4 % 4294967296), r3 = ~(-t4 / 4294967296), 4294967295 ^ n3 ? n3 = n3 + 1 | 0 : (n3 = 0, r3 = r3 + 1 | 0)), t4 >= 18446744073709552e3 || t4 < -18446744073709552e3) throw new Error("Given varint doesn't fit into 10 bytes");
+            e3.realloc(10), function(t5, e4, n4) {
+              n4.buf[n4.pos++] = 127 & t5 | 128, t5 >>>= 7, n4.buf[n4.pos++] = 127 & t5 | 128, t5 >>>= 7, n4.buf[n4.pos++] = 127 & t5 | 128, t5 >>>= 7, n4.buf[n4.pos++] = 127 & t5 | 128, n4.buf[n4.pos] = 127 & (t5 >>>= 7);
+            }(n3, 0, e3), function(t5, e4) {
+              const n4 = (7 & t5) << 4;
+              e4.buf[e4.pos++] |= n4 | ((t5 >>>= 3) ? 128 : 0), t5 && (e4.buf[e4.pos++] = 127 & t5 | ((t5 >>>= 7) ? 128 : 0), t5 && (e4.buf[e4.pos++] = 127 & t5 | ((t5 >>>= 7) ? 128 : 0), t5 && (e4.buf[e4.pos++] = 127 & t5 | ((t5 >>>= 7) ? 128 : 0), t5 && (e4.buf[e4.pos++] = 127 & t5 | ((t5 >>>= 7) ? 128 : 0), t5 && (e4.buf[e4.pos++] = 127 & t5)))));
+            }(r3, e3);
+          }(t3, this) : (this.realloc(4), this.buf[this.pos++] = 127 & t3 | (t3 > 127 ? 128 : 0), t3 <= 127 || (this.buf[this.pos++] = 127 & (t3 >>>= 7) | (t3 > 127 ? 128 : 0), t3 <= 127 || (this.buf[this.pos++] = 127 & (t3 >>>= 7) | (t3 > 127 ? 128 : 0), t3 <= 127 || (this.buf[this.pos++] = t3 >>> 7 & 127))));
+        }
+        writeSVarint(t3) {
+          this.writeVarint(t3 < 0 ? 2 * -t3 - 1 : 2 * t3);
+        }
+        writeBoolean(t3) {
+          this.writeVarint(+t3);
+        }
+        writeString(t3) {
+          t3 = String(t3), this.realloc(4 * t3.length), this.pos++;
+          const e3 = this.pos;
+          this.pos = function(t4, e4, n4) {
+            for (let r3, i3, s3 = 0; s3 < e4.length; s3++) {
+              if (r3 = e4.charCodeAt(s3), r3 > 55295 && r3 < 57344) {
+                if (!i3) {
+                  r3 > 56319 || s3 + 1 === e4.length ? (t4[n4++] = 239, t4[n4++] = 191, t4[n4++] = 189) : i3 = r3;
+                  continue;
+                }
+                if (r3 < 56320) {
+                  t4[n4++] = 239, t4[n4++] = 191, t4[n4++] = 189, i3 = r3;
+                  continue;
+                }
+                r3 = i3 - 55296 << 10 | r3 - 56320 | 65536, i3 = null;
+              } else i3 && (t4[n4++] = 239, t4[n4++] = 191, t4[n4++] = 189, i3 = null);
+              r3 < 128 ? t4[n4++] = r3 : (r3 < 2048 ? t4[n4++] = r3 >> 6 | 192 : (r3 < 65536 ? t4[n4++] = r3 >> 12 | 224 : (t4[n4++] = r3 >> 18 | 240, t4[n4++] = r3 >> 12 & 63 | 128), t4[n4++] = r3 >> 6 & 63 | 128), t4[n4++] = 63 & r3 | 128);
+            }
+            return n4;
+          }(this.buf, t3, this.pos);
+          const n3 = this.pos - e3;
+          n3 >= 128 && Ch2(e3, n3, this), this.pos = e3 - 1, this.writeVarint(n3), this.pos += n3;
+        }
+        writeFloat(t3) {
+          this.realloc(4), this.dataView.setFloat32(this.pos, t3, true), this.pos += 4;
+        }
+        writeDouble(t3) {
+          this.realloc(8), this.dataView.setFloat64(this.pos, t3, true), this.pos += 8;
+        }
+        writeBytes(t3) {
+          const e3 = t3.length;
+          this.writeVarint(e3), this.realloc(e3);
+          for (let n3 = 0; n3 < e3; n3++) this.buf[this.pos++] = t3[n3];
+        }
+        writeRawMessage(t3, e3) {
+          this.pos++;
+          const n3 = this.pos;
+          t3(e3, this);
+          const r3 = this.pos - n3;
+          r3 >= 128 && Ch2(n3, r3, this), this.pos = n3 - 1, this.writeVarint(r3), this.pos += r3;
+        }
+        writeMessage(t3, e3, n3) {
+          this.writeTag(t3, 2), this.writeRawMessage(e3, n3);
+        }
+        writePackedVarint(t3, e3) {
+          e3.length && this.writeMessage(t3, Vh2, e3);
+        }
+        writePackedSVarint(t3, e3) {
+          e3.length && this.writeMessage(t3, Lh2, e3);
+        }
+        writePackedBoolean(t3, e3) {
+          e3.length && this.writeMessage(t3, Rh2, e3);
+        }
+        writePackedFloat(t3, e3) {
+          e3.length && this.writeMessage(t3, Oh2, e3);
+        }
+        writePackedDouble(t3, e3) {
+          e3.length && this.writeMessage(t3, $h2, e3);
+        }
+        writePackedFixed32(t3, e3) {
+          e3.length && this.writeMessage(t3, Nh2, e3);
+        }
+        writePackedSFixed32(t3, e3) {
+          e3.length && this.writeMessage(t3, Uh2, e3);
+        }
+        writePackedFixed64(t3, e3) {
+          e3.length && this.writeMessage(t3, jh2, e3);
+        }
+        writePackedSFixed64(t3, e3) {
+          e3.length && this.writeMessage(t3, qh2, e3);
+        }
+        writeBytesField(t3, e3) {
+          this.writeTag(t3, 2), this.writeBytes(e3);
+        }
+        writeFixed32Field(t3, e3) {
+          this.writeTag(t3, 5), this.writeFixed32(e3);
+        }
+        writeSFixed32Field(t3, e3) {
+          this.writeTag(t3, 5), this.writeSFixed32(e3);
+        }
+        writeFixed64Field(t3, e3) {
+          this.writeTag(t3, 1), this.writeFixed64(e3);
+        }
+        writeSFixed64Field(t3, e3) {
+          this.writeTag(t3, 1), this.writeSFixed64(e3);
+        }
+        writeVarintField(t3, e3) {
+          this.writeTag(t3, 0), this.writeVarint(e3);
+        }
+        writeSVarintField(t3, e3) {
+          this.writeTag(t3, 0), this.writeSVarint(e3);
+        }
+        writeStringField(t3, e3) {
+          this.writeTag(t3, 2), this.writeString(e3);
+        }
+        writeFloatField(t3, e3) {
+          this.writeTag(t3, 5), this.writeFloat(e3);
+        }
+        writeDoubleField(t3, e3) {
+          this.writeTag(t3, 1), this.writeDouble(e3);
+        }
+        writeBooleanField(t3, e3) {
+          this.writeVarintField(t3, +e3);
+        }
+      }
+      function Bh2(t3, e3, n3) {
+        return n3 ? 4294967296 * e3 + (t3 >>> 0) : 4294967296 * (e3 >>> 0) + (t3 >>> 0);
+      }
+      function Ch2(t3, e3, n3) {
+        const r3 = e3 <= 16383 ? 1 : e3 <= 2097151 ? 2 : e3 <= 268435455 ? 3 : Math.floor(Math.log(e3) / (7 * Math.LN2));
+        n3.realloc(r3);
+        for (let e4 = n3.pos - 1; e4 >= t3; e4--) n3.buf[e4 + r3] = n3.buf[e4];
+      }
+      function Vh2(t3, e3) {
+        for (let n3 = 0; n3 < t3.length; n3++) e3.writeVarint(t3[n3]);
+      }
+      function Lh2(t3, e3) {
+        for (let n3 = 0; n3 < t3.length; n3++) e3.writeSVarint(t3[n3]);
+      }
+      function Oh2(t3, e3) {
+        for (let n3 = 0; n3 < t3.length; n3++) e3.writeFloat(t3[n3]);
+      }
+      function $h2(t3, e3) {
+        for (let n3 = 0; n3 < t3.length; n3++) e3.writeDouble(t3[n3]);
+      }
+      function Rh2(t3, e3) {
+        for (let n3 = 0; n3 < t3.length; n3++) e3.writeBoolean(t3[n3]);
+      }
+      function Nh2(t3, e3) {
+        for (let n3 = 0; n3 < t3.length; n3++) e3.writeFixed32(t3[n3]);
+      }
+      function Uh2(t3, e3) {
+        for (let n3 = 0; n3 < t3.length; n3++) e3.writeSFixed32(t3[n3]);
+      }
+      function jh2(t3, e3) {
+        for (let n3 = 0; n3 < t3.length; n3++) e3.writeFixed64(t3[n3]);
+      }
+      function qh2(t3, e3) {
+        for (let n3 = 0; n3 < t3.length; n3++) e3.writeSFixed64(t3[n3]);
+      }
+      function Gh2(t3, e3, n3) {
+        1 === t3 && n3.readMessage(Xh2, e3);
+      }
+      function Xh2(t3, e3, n3) {
+        if (3 === t3) {
+          const { id: t4, bitmap: r3, width: i3, height: s3, left: o3, top: a3, advance: l3 } = n3.readMessage(Yh2, {});
+          e3.push({ id: t4, bitmap: new _l2({ width: i3 + 6, height: s3 + 6 }, r3), metrics: { width: i3, height: s3, left: o3, top: a3, advance: l3 } });
+        }
+      }
+      function Yh2(t3, e3, n3) {
+        1 === t3 ? e3.id = n3.readVarint() : 2 === t3 ? e3.bitmap = n3.readBytes() : 3 === t3 ? e3.width = n3.readVarint() : 4 === t3 ? e3.height = n3.readVarint() : 5 === t3 ? e3.left = n3.readSVarint() : 6 === t3 ? e3.top = n3.readSVarint() : 7 === t3 && (e3.advance = n3.readVarint());
+      }
+      function Zh2(t3) {
+        let e3 = 0, n3 = 0;
+        for (const r4 of t3) e3 += r4.w * r4.h, n3 = Math.max(n3, r4.w);
+        t3.sort((t4, e4) => e4.h - t4.h);
+        const r3 = [{ x: 0, y: 0, w: Math.max(Math.ceil(Math.sqrt(e3 / 0.95)), n3), h: 1 / 0 }];
+        let i3 = 0, s3 = 0;
+        for (const e4 of t3) for (let t4 = r3.length - 1; t4 >= 0; t4--) {
+          const n4 = r3[t4];
+          if (!(e4.w > n4.w || e4.h > n4.h)) {
+            if (e4.x = n4.x, e4.y = n4.y, s3 = Math.max(s3, e4.y + e4.h), i3 = Math.max(i3, e4.x + e4.w), e4.w === n4.w && e4.h === n4.h) {
+              const e5 = r3.pop();
+              e5 && t4 < r3.length && (r3[t4] = e5);
+            } else e4.h === n4.h ? (n4.x += e4.w, n4.w -= e4.w) : e4.w === n4.w ? (n4.y += e4.h, n4.h -= e4.h) : (r3.push({ x: n4.x + e4.w, y: n4.y, w: n4.w - e4.w, h: e4.h }), n4.y += e4.h, n4.h -= e4.h);
+            break;
+          }
+        }
+        return { w: i3, h: s3, fill: e3 / (i3 * s3) || 0 };
+      }
+      class Hh2 {
+        constructor(t3, { pixelRatio: e3, version: n3, stretchX: r3, stretchY: i3, content: s3, textFitWidth: o3, textFitHeight: a3 }) {
+          this.paddedRect = t3, this.pixelRatio = e3, this.stretchX = r3, this.stretchY = i3, this.content = s3, this.version = n3, this.textFitWidth = o3, this.textFitHeight = a3;
+        }
+        get tl() {
+          return [this.paddedRect.x + 1, this.paddedRect.y + 1];
+        }
+        get br() {
+          return [this.paddedRect.x + this.paddedRect.w - 1, this.paddedRect.y + this.paddedRect.h - 1];
+        }
+        get tlbr() {
+          return this.tl.concat(this.br);
+        }
+        get displaySize() {
+          return [(this.paddedRect.w - 2) / this.pixelRatio, (this.paddedRect.h - 2) / this.pixelRatio];
+        }
+      }
+      class Wh2 {
+        constructor(t3, e3) {
+          const n3 = {}, r3 = {};
+          this.haveRenderCallbacks = [];
+          const i3 = [];
+          this.addImages(t3, n3, i3), this.addImages(e3, r3, i3);
+          const { w: s3, h: o3 } = Zh2(i3), a3 = new Sl({ width: s3 || 1, height: o3 || 1 });
+          for (const e4 in t3) {
+            const r4 = t3[e4], i4 = n3[e4].paddedRect;
+            Sl.copy(r4.data, a3, { x: 0, y: 0 }, { x: i4.x + 1, y: i4.y + 1 }, r4.data);
+          }
+          for (const t4 in e3) {
+            const n4 = e3[t4], i4 = r3[t4].paddedRect, s4 = i4.x + 1, o4 = i4.y + 1, l3 = n4.data.width, u3 = n4.data.height;
+            Sl.copy(n4.data, a3, { x: 0, y: 0 }, { x: s4, y: o4 }, n4.data), Sl.copy(n4.data, a3, { x: 0, y: u3 - 1 }, { x: s4, y: o4 - 1 }, { width: l3, height: 1 }), Sl.copy(n4.data, a3, { x: 0, y: 0 }, { x: s4, y: o4 + u3 }, { width: l3, height: 1 }), Sl.copy(n4.data, a3, { x: l3 - 1, y: 0 }, { x: s4 - 1, y: o4 }, { width: 1, height: u3 }), Sl.copy(n4.data, a3, { x: 0, y: 0 }, { x: s4 + l3, y: o4 }, { width: 1, height: u3 });
+          }
+          this.image = a3, this.iconPositions = n3, this.patternPositions = r3;
+        }
+        addImages(t3, e3, n3) {
+          for (const r3 in t3) {
+            const i3 = t3[r3], s3 = { x: 0, y: 0, w: i3.data.width + 2, h: i3.data.height + 2 };
+            n3.push(s3), e3[r3] = new Hh2(s3, i3), i3.hasRenderCallback && this.haveRenderCallbacks.push(r3);
+          }
+        }
+        patchUpdatedImages(t3, e3) {
+          t3.dispatchRenderCallbacks(this.haveRenderCallbacks);
+          for (const n3 in t3.updatedImages) this.patchUpdatedImage(this.iconPositions[n3], t3.getImage(n3), e3), this.patchUpdatedImage(this.patternPositions[n3], t3.getImage(n3), e3);
+        }
+        patchUpdatedImage(t3, e3, n3) {
+          if (!t3 || !e3) return;
+          if (t3.version === e3.version) return;
+          t3.version = e3.version;
+          const [r3, i3] = t3.tl;
+          n3.update(e3.data, void 0, { x: r3, y: i3 });
+        }
+      }
+      var Kh2;
+      function Jh2(e3, n3, r3, i3, s3, o3, a3, l3, u3, c3, h3, p3, f3, d3, y3) {
+        const m3 = Th2.fromFeature(e3, s3);
+        let g3;
+        p3 === t2.aw.vertical && m3.verticalizePunctuation();
+        let x3 = m3.determineLineBreaks(c3, o3, n3, i3, d3);
+        const { processBidirectionalText: v3, processStyledBidirectionalText: b3 } = Ps;
+        if (v3 && 1 === m3.sections.length) {
+          g3 = [], x3 = x3.map((t4) => m3.toCodeUnitIndex(t4));
+          const t3 = v3(m3.toString(), x3);
+          for (const e4 of t3) {
+            const t4 = [...e4].map(() => 0);
+            g3.push(new Th2(e4, m3.sections, t4));
+          }
+        } else if (b3) {
+          g3 = [], x3 = x3.map((t4) => m3.toCodeUnitIndex(t4));
+          let t3 = 0;
+          const e4 = [];
+          for (const n5 of m3.text) e4.push(...Array(n5.length).fill(m3.sectionIndex[t3])), t3++;
+          const n4 = b3(m3.text, e4, x3);
+          for (const t4 of n4) {
+            const e5 = [];
+            let n5 = "";
+            for (const r4 of t4[0]) e5.push(t4[1][n5.length]), n5 += r4;
+            g3.push(new Th2(t4[0], m3.sections, e5));
+          }
+        } else g3 = function(t3, e4) {
+          const n4 = [];
+          let r4 = 0;
+          for (const i4 of e4) n4.push(t3.substring(r4, i4)), r4 = i4;
+          return r4 < t3.length() && n4.push(t3.substring(r4, t3.length())), n4;
+        }(m3, x3);
+        const w3 = [], _3 = { positionedLines: w3, text: m3.toString(), top: h3[1], bottom: h3[1], left: h3[0], right: h3[0], writingMode: p3, iconsInText: false, verticalizable: false };
+        return function(t3, e4, n4, r4, i4, s4, o4, a4, l4, u4, c4, h4) {
+          let p4 = 0, f4 = 0, d4 = 0, y4 = 0;
+          const m4 = "right" === a4 ? 1 : "left" === a4 ? 0 : 0.5, g4 = bh2 / h4;
+          let x4 = 0;
+          for (const o5 of i4) {
+            o5.trim();
+            const i5 = o5.getMaxScale(), a5 = { positionedGlyphs: [], lineOffset: 0 };
+            t3.positionedLines[x4] = a5;
+            const h5 = a5.positionedGlyphs;
+            let v5 = 0;
+            if (!o5.length()) {
+              f4 += s4, ++x4;
+              continue;
+            }
+            const b5 = tp(r4, o5, g4);
+            let w4 = 0;
+            for (const s5 of o5.text) {
+              const a6 = o5.getSection(w4), d5 = s5.codePointAt(0), y5 = np(l4, c4, d5), m5 = { glyph: d5, imageName: null, x: p4, y: f4 + -17, vertical: y5, scale: 1, fontStack: "", sectionIndex: o5.getSectionIndex(w4), metrics: null, rect: null };
+              let x5;
+              if ("fontStack" in a6) {
+                if (x5 = rp(a6, d5, y5, b5, e4, n4), !x5) continue;
+                m5.fontStack = a6.fontStack;
+              } else {
+                if (t3.iconsInText = true, a6.scale *= g4, x5 = ip(a6, y5, i5, b5, r4), !x5) continue;
+                v5 = Math.max(v5, x5.imageOffset), m5.imageName = a6.imageName;
+              }
+              const { rect: _5, metrics: S3, baselineOffset: A3 } = x5;
+              m5.y += A3, m5.scale = a6.scale, m5.metrics = S3, m5.rect = _5, h5.push(m5), y5 ? (t3.verticalizable = true, p4 += ("imageName" in a6 ? S3.advance : bh2) * a6.scale + u4) : p4 += S3.advance * a6.scale + u4, w4++;
+            }
+            0 !== h5.length && (d4 = Math.max(p4 - u4, d4), sp(h5, 0, h5.length - 1, m4)), p4 = 0, a5.lineOffset = Math.max(v5, (i5 - 1) * bh2);
+            const _4 = s4 * i5 + v5;
+            f4 += _4, y4 = Math.max(_4, y4), ++x4;
+          }
+          const { horizontalAlign: v4, verticalAlign: b4 } = Qh2(o4);
+          (function(t4, e5, n5, r5, i5, s5, o5, a5, l5) {
+            const u5 = (e5 - n5) * i5;
+            let c5 = 0;
+            c5 = s5 !== o5 ? -a5 * r5 - -17 : -r5 * l5 * o5 + 0.5 * o5;
+            for (const e6 of t4) for (const t5 of e6.positionedGlyphs) t5.x += u5, t5.y += c5;
+          })(t3.positionedLines, m4, v4, b4, d4, y4, s4, f4, i4.length), t3.top += -b4 * f4, t3.bottom = t3.top + f4, t3.left += -v4 * d4, t3.right = t3.left + d4;
+        }(_3, n3, r3, i3, g3, a3, l3, u3, p3, c3, f3, y3), !function(t3) {
+          for (const e4 of t3) if (0 !== e4.positionedGlyphs.length) return false;
+          return true;
+        }(w3) && _3;
+      }
+      function Qh2(t3) {
+        let e3 = 0.5, n3 = 0.5;
+        switch (t3) {
+          case "right":
+          case "top-right":
+          case "bottom-right":
+            e3 = 1;
+            break;
+          case "left":
+          case "top-left":
+          case "bottom-left":
+            e3 = 0;
+        }
+        switch (t3) {
+          case "bottom":
+          case "bottom-right":
+          case "bottom-left":
+            n3 = 1;
+            break;
+          case "top":
+          case "top-right":
+          case "top-left":
+            n3 = 0;
+        }
+        return { horizontalAlign: e3, verticalAlign: n3 };
+      }
+      function tp(t3, e3, n3) {
+        const r3 = e3.getMaxScale() * bh2, { maxImageWidth: i3, maxImageHeight: s3 } = e3.getMaxImageSize(t3), o3 = Math.max(r3, s3 * n3);
+        return { verticalLineContentWidth: Math.max(r3, i3 * n3), horizontalLineContentHeight: o3 };
+      }
+      function ep(t3) {
+        switch (t3) {
+          case "top":
+            return 0;
+          case "center":
+            return 0.5;
+          default:
+            return 1;
+        }
+      }
+      function np(e3, n3, r3) {
+        return !(e3 === t2.aw.horizontal || !n3 && !bs(r3) || n3 && (ws(r3) || (i3 = r3, new RegExp("\\p{sc=Arab}", "u").test(String.fromCodePoint(i3)))));
+        var i3;
+      }
+      function rp(t3, e3, n3, r3, i3, s3) {
+        const o3 = s3[t3.fontStack], a3 = function(t4, e4, n4, r4) {
+          if (t4 && t4.rect) return t4;
+          const i4 = e4[n4.fontStack], s4 = i4 && i4[r4];
+          return s4 ? { rect: null, metrics: s4.metrics } : null;
+        }(o3 && o3[e3], i3, t3, e3);
+        if (null === a3) return null;
+        let l3;
+        if (n3) l3 = r3.verticalLineContentWidth - t3.scale * bh2;
+        else {
+          const e4 = ep(t3.verticalAlign);
+          l3 = (r3.horizontalLineContentHeight - t3.scale * bh2) * e4;
+        }
+        return { rect: a3.rect, metrics: a3.metrics, baselineOffset: l3 };
+      }
+      function ip(t3, e3, n3, r3, i3) {
+        const s3 = i3[t3.imageName];
+        if (!s3) return null;
+        const o3 = s3.paddedRect, a3 = s3.displaySize, l3 = { width: a3[0], height: a3[1], left: 1, top: -3, advance: e3 ? a3[1] : a3[0] };
+        let u3;
+        if (e3) u3 = r3.verticalLineContentWidth - a3[1] * t3.scale;
+        else {
+          const e4 = ep(t3.verticalAlign);
+          u3 = (r3.horizontalLineContentHeight - a3[1] * t3.scale) * e4;
+        }
+        return { rect: o3, metrics: l3, baselineOffset: u3, imageOffset: (e3 ? a3[0] : a3[1]) * t3.scale - bh2 * n3 };
+      }
+      function sp(t3, e3, n3, r3) {
+        if (0 === r3) return;
+        const i3 = t3[n3], s3 = (t3[n3].x + i3.metrics.advance * i3.scale) * r3;
+        for (let r4 = e3; r4 <= n3; r4++) t3[r4].x -= s3;
+      }
+      function op(t3, e3, n3) {
+        const { horizontalAlign: r3, verticalAlign: i3 } = Qh2(n3), s3 = e3[0] - t3.displaySize[0] * r3, o3 = e3[1] - t3.displaySize[1] * i3;
+        return { image: t3, top: o3, bottom: o3 + t3.displaySize[1], left: s3, right: s3 + t3.displaySize[0] };
+      }
+      function ap(t3) {
+        var e3, n3;
+        let r3 = t3.left, i3 = t3.top, s3 = t3.right - r3, o3 = t3.bottom - i3;
+        const a3 = null !== (e3 = t3.image.textFitWidth) && void 0 !== e3 ? e3 : "stretchOrShrink", l3 = null !== (n3 = t3.image.textFitHeight) && void 0 !== n3 ? n3 : "stretchOrShrink", u3 = (t3.image.content[2] - t3.image.content[0]) / (t3.image.content[3] - t3.image.content[1]);
+        if ("proportional" === l3) {
+          if ("stretchOnly" === a3 && s3 / o3 < u3 || "proportional" === a3) {
+            const t4 = Math.ceil(o3 * u3);
+            r3 *= t4 / s3, s3 = t4;
+          }
+        } else if ("proportional" === a3 && "stretchOnly" === l3 && 0 !== u3 && s3 / o3 > u3) {
+          const t4 = Math.ceil(s3 / u3);
+          i3 *= t4 / o3, o3 = t4;
+        }
+        return { x1: r3, y1: i3, x2: r3 + s3, y2: i3 + o3 };
+      }
+      function lp(t3, e3, n3, r3, i3, s3) {
+        const o3 = t3.image;
+        let a3;
+        if (o3.content) {
+          const t4 = o3.content, e4 = o3.pixelRatio || 1;
+          a3 = [t4[0] / e4, t4[1] / e4, o3.displaySize[0] - t4[2] / e4, o3.displaySize[1] - t4[3] / e4];
+        }
+        const l3 = e3.left * s3, u3 = e3.right * s3;
+        let c3, h3, p3, f3;
+        "width" === n3 || "both" === n3 ? (f3 = i3[0] + l3 - r3[3], h3 = i3[0] + u3 + r3[1]) : (f3 = i3[0] + (l3 + u3 - o3.displaySize[0]) / 2, h3 = f3 + o3.displaySize[0]);
+        const d3 = e3.top * s3, y3 = e3.bottom * s3;
+        return "height" === n3 || "both" === n3 ? (c3 = i3[1] + d3 - r3[0], p3 = i3[1] + y3 + r3[2]) : (c3 = i3[1] + (d3 + y3 - o3.displaySize[1]) / 2, p3 = c3 + o3.displaySize[1]), { image: o3, top: c3, right: h3, bottom: p3, left: f3, collisionPadding: a3 };
+      }
+      ps("ImagePosition", Hh2), ps("ImageAtlas", Wh2), t2.aw = void 0, (Kh2 = t2.aw || (t2.aw = {}))[Kh2.none = 0] = "none", Kh2[Kh2.horizontal = 1] = "horizontal", Kh2[Kh2.vertical = 2] = "vertical", Kh2[Kh2.horizontalOnly = 3] = "horizontalOnly";
+      const up = 128, cp = 32640;
+      function hp(t3, e3) {
+        const { expression: n3 } = e3;
+        if ("constant" === n3.kind) return { kind: "constant", layoutSize: n3.evaluate(new zs(t3 + 1)) };
+        if ("source" === n3.kind) return { kind: "source" };
+        {
+          const { zoomStops: e4, interpolationType: r3 } = n3;
+          let i3 = 0;
+          for (; i3 < e4.length && e4[i3] <= t3; ) i3++;
+          i3 = Math.max(0, i3 - 1);
+          let s3 = i3;
+          for (; s3 < e4.length && e4[s3] < t3 + 1; ) s3++;
+          s3 = Math.min(e4.length - 1, s3);
+          const o3 = e4[i3], a3 = e4[s3];
+          return "composite" === n3.kind ? { kind: "composite", minZoom: o3, maxZoom: a3, interpolationType: r3 } : { kind: "camera", minZoom: o3, maxZoom: a3, minSize: n3.evaluate(new zs(o3)), maxSize: n3.evaluate(new zs(a3)), interpolationType: r3 };
+        }
+      }
+      function pp(t3, e3, n3) {
+        let r3 = "never";
+        const i3 = t3.get(e3);
+        return i3 ? r3 = i3 : t3.get(n3) && (r3 = "always"), r3;
+      }
+      const fp = [{ name: "a_fade_opacity", components: 1, type: "Uint8", offset: 0 }];
+      function dp(t3, e3, n3, r3, i3, s3, o3, a3, l3, u3, c3, h3, p3) {
+        const f3 = a3 ? Math.min(cp, Math.round(a3[0])) : 0, d3 = a3 ? Math.min(cp, Math.round(a3[1])) : 0;
+        t3.emplaceBack(e3, n3, Math.round(32 * r3), Math.round(32 * i3), s3, o3, (f3 << 1) + (l3 ? 1 : 0), d3, 16 * u3, 16 * c3, 256 * h3, 256 * p3);
+      }
+      function yp(t3, e3, n3) {
+        t3.emplaceBack(e3.x, e3.y, n3), t3.emplaceBack(e3.x, e3.y, n3), t3.emplaceBack(e3.x, e3.y, n3), t3.emplaceBack(e3.x, e3.y, n3);
+      }
+      function mp(t3) {
+        for (const e3 of t3.sections) if (Ds(e3.text)) return true;
+        return false;
+      }
+      class gp {
+        constructor(t3) {
+          this.layoutVertexArray = new Wo(), this.indexArray = new ea2(), this.programConfigurations = t3, this.segments = new sa2(), this.dynamicLayoutVertexArray = new Ko(), this.opacityVertexArray = new Jo(), this.hasVisibleVertices = false, this.placedSymbolArray = new zo();
+        }
+        isEmpty() {
+          return 0 === this.layoutVertexArray.length && 0 === this.indexArray.length && 0 === this.dynamicLayoutVertexArray.length && 0 === this.opacityVertexArray.length;
+        }
+        upload(t3, e3, n3, r3) {
+          this.isEmpty() || (n3 && (this.layoutVertexBuffer = t3.createVertexBuffer(this.layoutVertexArray, dh2.members), this.indexBuffer = t3.createIndexBuffer(this.indexArray, e3), this.dynamicLayoutVertexBuffer = t3.createVertexBuffer(this.dynamicLayoutVertexArray, yh2.members, true), this.opacityVertexBuffer = t3.createVertexBuffer(this.opacityVertexArray, fp, true), this.opacityVertexBuffer.itemSize = 1), (n3 || r3) && this.programConfigurations.upload(t3));
+        }
+        destroy() {
+          this.layoutVertexBuffer && (this.layoutVertexBuffer.destroy(), this.indexBuffer.destroy(), this.programConfigurations.destroy(), this.segments.destroy(), this.dynamicLayoutVertexBuffer.destroy(), this.opacityVertexBuffer.destroy());
+        }
+      }
+      ps("SymbolBuffers", gp);
+      class xp {
+        constructor(t3, e3, n3) {
+          this.layoutVertexArray = new t3(), this.layoutAttributes = e3, this.indexArray = new n3(), this.segments = new sa2(), this.collisionVertexArray = new ta2();
+        }
+        upload(t3) {
+          this.layoutVertexBuffer = t3.createVertexBuffer(this.layoutVertexArray, this.layoutAttributes), this.indexBuffer = t3.createIndexBuffer(this.indexArray), this.collisionVertexBuffer = t3.createVertexBuffer(this.collisionVertexArray, mh2.members, true);
+        }
+        destroy() {
+          this.layoutVertexBuffer && (this.layoutVertexBuffer.destroy(), this.indexBuffer.destroy(), this.segments.destroy(), this.collisionVertexBuffer.destroy());
+        }
+      }
+      ps("CollisionBuffers", xp);
+      class vp {
+        constructor(e3) {
+          this.collisionBoxArray = e3.collisionBoxArray, this.zoom = e3.zoom, this.overscaling = e3.overscaling, this.layers = e3.layers, this.layerIds = this.layers.map((t3) => t3.id), this.index = e3.index, this.pixelRatio = e3.pixelRatio, this.sourceLayerIndex = e3.sourceLayerIndex, this.hasDependencies = false, this.hasRTLText = false, this.sortKeyRanges = [], this.collisionCircleArray = [];
+          const n3 = this.layers[0]._unevaluatedLayout._values;
+          this.textSizeData = hp(this.zoom, n3["text-size"]), this.iconSizeData = hp(this.zoom, n3["icon-size"]);
+          const r3 = this.layers[0].layout, i3 = r3.get("symbol-sort-key"), s3 = r3.get("symbol-z-order");
+          this.canOverlap = "never" !== pp(r3, "text-overlap", "text-allow-overlap") || "never" !== pp(r3, "icon-overlap", "icon-allow-overlap") || r3.get("text-ignore-placement") || r3.get("icon-ignore-placement"), this.sortFeaturesByKey = "viewport-y" !== s3 && !i3.isConstant(), this.sortFeaturesByY = ("viewport-y" === s3 || "auto" === s3 && !this.sortFeaturesByKey) && this.canOverlap, "point" === r3.get("symbol-placement") && (this.writingModes = r3.get("text-writing-mode").map((e4) => t2.aw[e4])), this.stateDependentLayerIds = this.layers.filter((t3) => t3.isStateDependent()).map((t3) => t3.id), this.sourceID = e3.sourceID;
+        }
+        createArrays() {
+          this.text = new gp(new Ca2(this.layers, this.zoom, (t3) => /^text/.test(t3))), this.icon = new gp(new Ca2(this.layers, this.zoom, (t3) => /^icon/.test(t3))), this.glyphOffsetArray = new Vo(), this.lineVertexArray = new Lo(), this.symbolInstances = new Co(), this.textAnchorOffsets = new $o();
+        }
+        calculateGlyphDependencies(t3, e3, n3, r3, i3) {
+          for (const s3 of t3) if (e3[s3.codePointAt(0)] = true, (n3 || r3) && i3) {
+            const t4 = wh2[s3];
+            t4 && (e3[t4.codePointAt(0)] = true);
+          }
+        }
+        populate(e3, n3, r3) {
+          const i3 = this.layers[0], s3 = i3.layout, o3 = s3.get("text-font"), a3 = s3.get("text-field"), l3 = s3.get("icon-image"), u3 = ("constant" !== a3.value.kind || a3.value.value instanceof De2 && !a3.value.value.isEmpty() || a3.value.value.toString().length > 0) && ("constant" !== o3.value.kind || o3.value.value.length > 0), c3 = "constant" !== l3.value.kind || !!l3.value.value || Object.keys(l3.parameters).length > 0, h3 = s3.get("symbol-sort-key");
+          if (this.features = [], !u3 && !c3) return;
+          const p3 = n3.iconDependencies, f3 = n3.glyphDependencies, d3 = n3.availableImages, y3 = new zs(this.zoom);
+          for (const { feature: n4, id: a4, index: l4, sourceLayerIndex: m3 } of e3) {
+            const e4 = i3._featureFilter.needGeometry, g3 = Na2(n4, e4);
+            if (!i3._featureFilter.filter(y3, g3, r3)) continue;
+            let x3, v3;
+            if (e4 || (g3.geometry = Ra2(n4)), u3) {
+              const t3 = i3.getValueAndResolveTokens("text-field", g3, r3, d3), e5 = De2.factory(t3), n5 = this.hasRTLText = this.hasRTLText || mp(e5);
+              (!n5 || "unavailable" === Ps.getRTLTextPluginStatus() || n5 && Ps.isParsed()) && (x3 = vh2(e5, i3, g3));
+            }
+            if (c3) {
+              const t3 = i3.getValueAndResolveTokens("icon-image", g3, r3, d3);
+              v3 = t3 instanceof Oe2 ? t3 : Oe2.fromString(t3);
+            }
+            if (!x3 && !v3) continue;
+            const b3 = this.sortFeaturesByKey ? h3.evaluate(g3, {}, r3) : void 0;
+            if (this.features.push({ id: a4, text: x3, icon: v3, index: l4, sourceLayerIndex: m3, geometry: g3.geometry, properties: n4.properties, type: Du.types[n4.type], sortKey: b3 }), v3 && (p3[v3.name] = true), x3) {
+              const e5 = o3.evaluate(g3, {}, r3).join(","), n5 = "viewport" !== s3.get("text-rotation-alignment") && "point" !== s3.get("symbol-placement");
+              this.allowVerticalPlacement = this.writingModes && this.writingModes.indexOf(t2.aw.vertical) >= 0;
+              for (const t3 of x3.sections) if (t3.image) p3[t3.image.name] = true;
+              else {
+                const r4 = _s2(x3.toString()), i4 = t3.fontStack || e5, s4 = f3[i4] = f3[i4] || {};
+                this.calculateGlyphDependencies(t3.text, s4, n5, this.allowVerticalPlacement, r4);
+              }
+            }
+          }
+          "line" === s3.get("symbol-placement") && (this.features = function(t3) {
+            const e4 = {}, n4 = {}, r4 = [];
+            let i4 = 0;
+            function s4(e5) {
+              r4.push(t3[e5]), i4++;
+            }
+            function o4(t4, e5, i5) {
+              const s5 = n4[t4];
+              return delete n4[t4], n4[e5] = s5, r4[s5].geometry[0].pop(), r4[s5].geometry[0] = r4[s5].geometry[0].concat(i5[0]), s5;
+            }
+            function a4(t4, n5, i5) {
+              const s5 = e4[n5];
+              return delete e4[n5], e4[t4] = s5, r4[s5].geometry[0].shift(), r4[s5].geometry[0] = i5[0].concat(r4[s5].geometry[0]), s5;
+            }
+            function l4(t4, e5, n5) {
+              const r5 = n5 ? e5[0][e5[0].length - 1] : e5[0][0];
+              return `${t4}:${r5.x}:${r5.y}`;
+            }
+            for (let u4 = 0; u4 < t3.length; u4++) {
+              const c4 = t3[u4], h4 = c4.geometry, p4 = c4.text ? c4.text.toString() : null;
+              if (!p4) {
+                s4(u4);
+                continue;
+              }
+              const f4 = l4(p4, h4), d4 = l4(p4, h4, true);
+              if (f4 in n4 && d4 in e4 && n4[f4] !== e4[d4]) {
+                const t4 = a4(f4, d4, h4), i5 = o4(f4, d4, r4[t4].geometry);
+                delete e4[f4], delete n4[d4], n4[l4(p4, r4[i5].geometry, true)] = i5, r4[t4].geometry = null;
+              } else f4 in n4 ? o4(f4, d4, h4) : d4 in e4 ? a4(f4, d4, h4) : (s4(u4), e4[f4] = i4 - 1, n4[d4] = i4 - 1);
+            }
+            return r4.filter((t4) => t4.geometry);
+          }(this.features)), this.sortFeaturesByKey && this.features.sort((t3, e4) => t3.sortKey - e4.sortKey);
+        }
+        update(t3, e3, n3) {
+          this.stateDependentLayers.length && (this.text.programConfigurations.updatePaintArrays(t3, e3, this.layers, { imagePositions: n3 }), this.icon.programConfigurations.updatePaintArrays(t3, e3, this.layers, { imagePositions: n3 }));
+        }
+        isEmpty() {
+          return 0 === this.symbolInstances.length && !this.hasRTLText;
+        }
+        uploadPending() {
+          return !this.uploaded || this.text.programConfigurations.needsUpload || this.icon.programConfigurations.needsUpload;
+        }
+        upload(t3) {
+          !this.uploaded && this.hasDebugData() && (this.textCollisionBox.upload(t3), this.iconCollisionBox.upload(t3)), this.text.upload(t3, this.sortFeaturesByY, !this.uploaded, this.text.programConfigurations.needsUpload), this.icon.upload(t3, this.sortFeaturesByY, !this.uploaded, this.icon.programConfigurations.needsUpload), this.uploaded = true;
+        }
+        destroyDebugData() {
+          this.textCollisionBox.destroy(), this.iconCollisionBox.destroy();
+        }
+        destroy() {
+          this.text.destroy(), this.icon.destroy(), this.hasDebugData() && this.destroyDebugData();
+        }
+        addToLineVertexArray(t3, e3) {
+          const n3 = this.lineVertexArray.length;
+          if (void 0 !== t3.segment) {
+            let n4 = t3.dist(e3[t3.segment + 1]), r3 = t3.dist(e3[t3.segment]);
+            const i3 = {};
+            for (let r4 = t3.segment + 1; r4 < e3.length; r4++) i3[r4] = { x: e3[r4].x, y: e3[r4].y, tileUnitDistanceFromAnchor: n4 }, r4 < e3.length - 1 && (n4 += e3[r4 + 1].dist(e3[r4]));
+            for (let n5 = t3.segment || 0; n5 >= 0; n5--) i3[n5] = { x: e3[n5].x, y: e3[n5].y, tileUnitDistanceFromAnchor: r3 }, n5 > 0 && (r3 += e3[n5 - 1].dist(e3[n5]));
+            for (let t4 = 0; t4 < e3.length; t4++) {
+              const e4 = i3[t4];
+              this.lineVertexArray.emplaceBack(e4.x, e4.y, e4.tileUnitDistanceFromAnchor);
+            }
+          }
+          return { lineStartIndex: n3, lineLength: this.lineVertexArray.length - n3 };
+        }
+        addSymbols(e3, n3, r3, i3, s3, o3, a3, l3, u3, c3, h3, p3) {
+          const f3 = e3.indexArray, d3 = e3.layoutVertexArray, y3 = e3.segments.prepareSegment(4 * n3.length, d3, f3, this.canOverlap ? o3.sortKey : void 0), m3 = this.glyphOffsetArray.length, g3 = y3.vertexLength, x3 = this.allowVerticalPlacement && a3 === t2.aw.vertical ? Math.PI / 2 : 0, v3 = o3.text && o3.text.sections;
+          for (let t3 = 0; t3 < n3.length; t3++) {
+            const { tl: i4, tr: s4, bl: a4, br: u4, tex: c4, pixelOffsetTL: h4, pixelOffsetBR: m4, minFontScaleX: g4, minFontScaleY: b3, glyphOffset: w3, isSDF: _3, sectionIndex: S3 } = n3[t3], A3 = y3.vertexLength, M3 = w3[1];
+            dp(d3, l3.x, l3.y, i4.x, M3 + i4.y, c4.x, c4.y, r3, _3, h4.x, h4.y, g4, b3), dp(d3, l3.x, l3.y, s4.x, M3 + s4.y, c4.x + c4.w, c4.y, r3, _3, m4.x, h4.y, g4, b3), dp(d3, l3.x, l3.y, a4.x, M3 + a4.y, c4.x, c4.y + c4.h, r3, _3, h4.x, m4.y, g4, b3), dp(d3, l3.x, l3.y, u4.x, M3 + u4.y, c4.x + c4.w, c4.y + c4.h, r3, _3, m4.x, m4.y, g4, b3), yp(e3.dynamicLayoutVertexArray, l3, x3), f3.emplaceBack(A3, A3 + 2, A3 + 1), f3.emplaceBack(A3 + 1, A3 + 2, A3 + 3), y3.vertexLength += 4, y3.primitiveLength += 2, this.glyphOffsetArray.emplaceBack(w3[0]), t3 !== n3.length - 1 && S3 === n3[t3 + 1].sectionIndex || e3.programConfigurations.populatePaintArrays(d3.length, o3, o3.index, { imagePositions: {}, canonical: p3, formattedSection: v3 && v3[S3] });
+          }
+          e3.placedSymbolArray.emplaceBack(l3.x, l3.y, m3, this.glyphOffsetArray.length - m3, g3, u3, c3, l3.segment, r3 ? r3[0] : 0, r3 ? r3[1] : 0, i3[0], i3[1], a3, 0, false, 0, h3);
+        }
+        _addCollisionDebugVertex(t3, e3, n3, r3, i3, s3) {
+          return e3.emplaceBack(0, 0), t3.emplaceBack(n3.x, n3.y, r3, i3, Math.round(s3.x), Math.round(s3.y));
+        }
+        addCollisionDebugVertices(t3, e3, r3, i3, s3, o3, a3) {
+          const l3 = s3.segments.prepareSegment(4, s3.layoutVertexArray, s3.indexArray), u3 = l3.vertexLength, c3 = s3.layoutVertexArray, h3 = s3.collisionVertexArray, p3 = a3.anchorX, f3 = a3.anchorY;
+          this._addCollisionDebugVertex(c3, h3, o3, p3, f3, new n2(t3, e3)), this._addCollisionDebugVertex(c3, h3, o3, p3, f3, new n2(r3, e3)), this._addCollisionDebugVertex(c3, h3, o3, p3, f3, new n2(r3, i3)), this._addCollisionDebugVertex(c3, h3, o3, p3, f3, new n2(t3, i3)), l3.vertexLength += 4;
+          const d3 = s3.indexArray;
+          d3.emplaceBack(u3, u3 + 1), d3.emplaceBack(u3 + 1, u3 + 2), d3.emplaceBack(u3 + 2, u3 + 3), d3.emplaceBack(u3 + 3, u3), l3.primitiveLength += 4;
+        }
+        addDebugCollisionBoxes(t3, e3, n3, r3) {
+          for (let i3 = t3; i3 < e3; i3++) {
+            const t4 = this.collisionBoxArray.get(i3);
+            this.addCollisionDebugVertices(t4.x1, t4.y1, t4.x2, t4.y2, r3 ? this.textCollisionBox : this.iconCollisionBox, t4.anchorPoint, n3);
+          }
+        }
+        generateCollisionDebugBuffers() {
+          this.hasDebugData() && this.destroyDebugData(), this.textCollisionBox = new xp(Qo, gh2.members, na), this.iconCollisionBox = new xp(Qo, gh2.members, na);
+          for (let t3 = 0; t3 < this.symbolInstances.length; t3++) {
+            const e3 = this.symbolInstances.get(t3);
+            this.addDebugCollisionBoxes(e3.textBoxStartIndex, e3.textBoxEndIndex, e3, true), this.addDebugCollisionBoxes(e3.verticalTextBoxStartIndex, e3.verticalTextBoxEndIndex, e3, true), this.addDebugCollisionBoxes(e3.iconBoxStartIndex, e3.iconBoxEndIndex, e3, false), this.addDebugCollisionBoxes(e3.verticalIconBoxStartIndex, e3.verticalIconBoxEndIndex, e3, false);
+          }
+        }
+        _deserializeCollisionBoxesForSymbol(t3, e3, n3, r3, i3, s3, o3, a3, l3) {
+          const u3 = {};
+          for (let r4 = e3; r4 < n3; r4++) {
+            const e4 = t3.get(r4);
+            u3.textBox = { x1: e4.x1, y1: e4.y1, x2: e4.x2, y2: e4.y2, anchorPointX: e4.anchorPointX, anchorPointY: e4.anchorPointY }, u3.textFeatureIndex = e4.featureIndex;
+            break;
+          }
+          for (let e4 = r3; e4 < i3; e4++) {
+            const n4 = t3.get(e4);
+            u3.verticalTextBox = { x1: n4.x1, y1: n4.y1, x2: n4.x2, y2: n4.y2, anchorPointX: n4.anchorPointX, anchorPointY: n4.anchorPointY }, u3.verticalTextFeatureIndex = n4.featureIndex;
+            break;
+          }
+          for (let e4 = s3; e4 < o3; e4++) {
+            const n4 = t3.get(e4);
+            u3.iconBox = { x1: n4.x1, y1: n4.y1, x2: n4.x2, y2: n4.y2, anchorPointX: n4.anchorPointX, anchorPointY: n4.anchorPointY }, u3.iconFeatureIndex = n4.featureIndex;
+            break;
+          }
+          for (let e4 = a3; e4 < l3; e4++) {
+            const n4 = t3.get(e4);
+            u3.verticalIconBox = { x1: n4.x1, y1: n4.y1, x2: n4.x2, y2: n4.y2, anchorPointX: n4.anchorPointX, anchorPointY: n4.anchorPointY }, u3.verticalIconFeatureIndex = n4.featureIndex;
+            break;
+          }
+          return u3;
+        }
+        deserializeCollisionBoxes(t3) {
+          this.collisionArrays = [];
+          for (let e3 = 0; e3 < this.symbolInstances.length; e3++) {
+            const n3 = this.symbolInstances.get(e3);
+            this.collisionArrays.push(this._deserializeCollisionBoxesForSymbol(t3, n3.textBoxStartIndex, n3.textBoxEndIndex, n3.verticalTextBoxStartIndex, n3.verticalTextBoxEndIndex, n3.iconBoxStartIndex, n3.iconBoxEndIndex, n3.verticalIconBoxStartIndex, n3.verticalIconBoxEndIndex));
+          }
+        }
+        hasTextData() {
+          return this.text.segments.get().length > 0;
+        }
+        hasIconData() {
+          return this.icon.segments.get().length > 0;
+        }
+        hasDebugData() {
+          return this.textCollisionBox && this.iconCollisionBox;
+        }
+        hasTextCollisionBoxData() {
+          return this.hasDebugData() && this.textCollisionBox.segments.get().length > 0;
+        }
+        hasIconCollisionBoxData() {
+          return this.hasDebugData() && this.iconCollisionBox.segments.get().length > 0;
+        }
+        addIndicesForPlacedSymbol(t3, e3) {
+          const n3 = t3.placedSymbolArray.get(e3), r3 = n3.vertexStartIndex + 4 * n3.numGlyphs;
+          for (let e4 = n3.vertexStartIndex; e4 < r3; e4 += 4) t3.indexArray.emplaceBack(e4, e4 + 2, e4 + 1), t3.indexArray.emplaceBack(e4 + 1, e4 + 2, e4 + 3);
+        }
+        getSortedSymbolIndexes(t3) {
+          if (this.sortedAngle === t3 && void 0 !== this.symbolInstanceIndexes) return this.symbolInstanceIndexes;
+          const e3 = Math.sin(t3), n3 = Math.cos(t3), r3 = [], i3 = [], s3 = [];
+          for (let t4 = 0; t4 < this.symbolInstances.length; ++t4) {
+            s3.push(t4);
+            const o3 = this.symbolInstances.get(t4);
+            r3.push(0 | Math.round(e3 * o3.anchorX + n3 * o3.anchorY)), i3.push(o3.featureIndex);
+          }
+          return s3.sort((t4, e4) => r3[t4] - r3[e4] || i3[e4] - i3[t4]), s3;
+        }
+        addToSortKeyRanges(t3, e3) {
+          const n3 = this.sortKeyRanges[this.sortKeyRanges.length - 1];
+          n3 && n3.sortKey === e3 ? n3.symbolInstanceEnd = t3 + 1 : this.sortKeyRanges.push({ sortKey: e3, symbolInstanceStart: t3, symbolInstanceEnd: t3 + 1 });
+        }
+        sortFeatures(t3) {
+          if (this.sortFeaturesByY && this.sortedAngle !== t3 && !(this.text.segments.get().length > 1 || this.icon.segments.get().length > 1)) {
+            this.symbolInstanceIndexes = this.getSortedSymbolIndexes(t3), this.sortedAngle = t3, this.text.indexArray.clear(), this.icon.indexArray.clear(), this.featureSortOrder = [];
+            for (const t4 of this.symbolInstanceIndexes) {
+              const e3 = this.symbolInstances.get(t4);
+              this.featureSortOrder.push(e3.featureIndex), [e3.rightJustifiedTextSymbolIndex, e3.centerJustifiedTextSymbolIndex, e3.leftJustifiedTextSymbolIndex].forEach((t5, e4, n3) => {
+                t5 >= 0 && n3.indexOf(t5) === e4 && this.addIndicesForPlacedSymbol(this.text, t5);
+              }), e3.verticalPlacedTextSymbolIndex >= 0 && this.addIndicesForPlacedSymbol(this.text, e3.verticalPlacedTextSymbolIndex), e3.placedIconSymbolIndex >= 0 && this.addIndicesForPlacedSymbol(this.icon, e3.placedIconSymbolIndex), e3.verticalPlacedIconSymbolIndex >= 0 && this.addIndicesForPlacedSymbol(this.icon, e3.verticalPlacedIconSymbolIndex);
+            }
+            this.text.indexBuffer && this.text.indexBuffer.updateData(this.text.indexArray), this.icon.indexBuffer && this.icon.indexBuffer.updateData(this.icon.indexArray);
+          }
+        }
+      }
+      let bp, wp;
+      ps("SymbolBucket", vp, { omit: ["layers", "collisionBoxArray", "features", "compareText"] }), vp.MAX_GLYPHS = 65535, vp.addDynamicAttributes = yp;
+      var _p2 = { get paint() {
+        return wp = wp || new Hs({ "icon-opacity": new Gs(vt.paint_symbol["icon-opacity"]), "icon-color": new Gs(vt.paint_symbol["icon-color"]), "icon-halo-color": new Gs(vt.paint_symbol["icon-halo-color"]), "icon-halo-width": new Gs(vt.paint_symbol["icon-halo-width"]), "icon-halo-blur": new Gs(vt.paint_symbol["icon-halo-blur"]), "icon-translate": new qs(vt.paint_symbol["icon-translate"]), "icon-translate-anchor": new qs(vt.paint_symbol["icon-translate-anchor"]), "text-opacity": new Gs(vt.paint_symbol["text-opacity"]), "text-color": new Gs(vt.paint_symbol["text-color"], { runtimeType: $t, getOverride: (t3) => t3.textColor, hasOverride: (t3) => !!t3.textColor }), "text-halo-color": new Gs(vt.paint_symbol["text-halo-color"]), "text-halo-width": new Gs(vt.paint_symbol["text-halo-width"]), "text-halo-blur": new Gs(vt.paint_symbol["text-halo-blur"]), "text-translate": new qs(vt.paint_symbol["text-translate"]), "text-translate-anchor": new qs(vt.paint_symbol["text-translate-anchor"]) });
+      }, get layout() {
+        return bp = bp || new Hs({ "symbol-placement": new qs(vt.layout_symbol["symbol-placement"]), "symbol-spacing": new qs(vt.layout_symbol["symbol-spacing"]), "symbol-avoid-edges": new qs(vt.layout_symbol["symbol-avoid-edges"]), "symbol-sort-key": new Gs(vt.layout_symbol["symbol-sort-key"]), "symbol-z-order": new qs(vt.layout_symbol["symbol-z-order"]), "icon-allow-overlap": new qs(vt.layout_symbol["icon-allow-overlap"]), "icon-overlap": new qs(vt.layout_symbol["icon-overlap"]), "icon-ignore-placement": new qs(vt.layout_symbol["icon-ignore-placement"]), "icon-optional": new qs(vt.layout_symbol["icon-optional"]), "icon-rotation-alignment": new qs(vt.layout_symbol["icon-rotation-alignment"]), "icon-size": new Gs(vt.layout_symbol["icon-size"]), "icon-text-fit": new qs(vt.layout_symbol["icon-text-fit"]), "icon-text-fit-padding": new qs(vt.layout_symbol["icon-text-fit-padding"]), "icon-image": new Gs(vt.layout_symbol["icon-image"]), "icon-rotate": new Gs(vt.layout_symbol["icon-rotate"]), "icon-padding": new Gs(vt.layout_symbol["icon-padding"]), "icon-keep-upright": new qs(vt.layout_symbol["icon-keep-upright"]), "icon-offset": new Gs(vt.layout_symbol["icon-offset"]), "icon-anchor": new Gs(vt.layout_symbol["icon-anchor"]), "icon-pitch-alignment": new qs(vt.layout_symbol["icon-pitch-alignment"]), "text-pitch-alignment": new qs(vt.layout_symbol["text-pitch-alignment"]), "text-rotation-alignment": new qs(vt.layout_symbol["text-rotation-alignment"]), "text-field": new Gs(vt.layout_symbol["text-field"]), "text-font": new Gs(vt.layout_symbol["text-font"]), "text-size": new Gs(vt.layout_symbol["text-size"]), "text-max-width": new Gs(vt.layout_symbol["text-max-width"]), "text-line-height": new qs(vt.layout_symbol["text-line-height"]), "text-letter-spacing": new Gs(vt.layout_symbol["text-letter-spacing"]), "text-justify": new Gs(vt.layout_symbol["text-justify"]), "text-radial-offset": new Gs(vt.layout_symbol["text-radial-offset"]), "text-variable-anchor": new qs(vt.layout_symbol["text-variable-anchor"]), "text-variable-anchor-offset": new Gs(vt.layout_symbol["text-variable-anchor-offset"]), "text-anchor": new Gs(vt.layout_symbol["text-anchor"]), "text-max-angle": new qs(vt.layout_symbol["text-max-angle"]), "text-writing-mode": new qs(vt.layout_symbol["text-writing-mode"]), "text-rotate": new Gs(vt.layout_symbol["text-rotate"]), "text-padding": new qs(vt.layout_symbol["text-padding"]), "text-keep-upright": new qs(vt.layout_symbol["text-keep-upright"]), "text-transform": new Gs(vt.layout_symbol["text-transform"]), "text-offset": new Gs(vt.layout_symbol["text-offset"]), "text-allow-overlap": new qs(vt.layout_symbol["text-allow-overlap"]), "text-overlap": new qs(vt.layout_symbol["text-overlap"]), "text-ignore-placement": new qs(vt.layout_symbol["text-ignore-placement"]), "text-optional": new qs(vt.layout_symbol["text-optional"]) });
+      } };
+      class Sp {
+        constructor(t3) {
+          if (void 0 === t3.property.overrides) throw new Error("overrides must be provided to instantiate FormatSectionOverride class");
+          this.type = t3.property.overrides ? t3.property.overrides.runtimeType : Ct, this.defaultValue = t3;
+        }
+        evaluate(t3) {
+          if (t3.formattedSection) {
+            const e3 = this.defaultValue.property.overrides;
+            if (e3 && e3.hasOverride(t3.formattedSection)) return e3.getOverride(t3.formattedSection);
+          }
+          return t3.feature && t3.featureState ? this.defaultValue.evaluate(t3.feature, t3.featureState) : this.defaultValue.property.specification.default;
+        }
+        eachChild(t3) {
+          this.defaultValue.isConstant() || t3(this.defaultValue.value._styleExpression.expression);
+        }
+        outputDefined() {
+          return false;
+        }
+        serialize() {
+          return null;
+        }
+      }
+      ps("FormatSectionOverride", Sp, { omit: ["defaultValue"] });
+      class Ap extends Ws {
+        constructor(t3, e3) {
+          super(t3, _p2, e3);
+        }
+        recalculate(t3, e3) {
+          if (super.recalculate(t3, e3), "auto" === this.layout.get("icon-rotation-alignment") && (this.layout._values["icon-rotation-alignment"] = "point" !== this.layout.get("symbol-placement") ? "map" : "viewport"), "auto" === this.layout.get("text-rotation-alignment") && (this.layout._values["text-rotation-alignment"] = "point" !== this.layout.get("symbol-placement") ? "map" : "viewport"), "auto" === this.layout.get("text-pitch-alignment") && (this.layout._values["text-pitch-alignment"] = "map" === this.layout.get("text-rotation-alignment") ? "map" : "viewport"), "auto" === this.layout.get("icon-pitch-alignment") && (this.layout._values["icon-pitch-alignment"] = this.layout.get("icon-rotation-alignment")), "point" === this.layout.get("symbol-placement")) {
+            const t4 = this.layout.get("text-writing-mode");
+            if (t4) {
+              const e4 = [];
+              for (const n3 of t4) e4.indexOf(n3) < 0 && e4.push(n3);
+              this.layout._values["text-writing-mode"] = e4;
+            } else this.layout._values["text-writing-mode"] = ["horizontal"];
+          }
+          this._setPaintOverrides();
+        }
+        getValueAndResolveTokens(t3, e3, n3, r3) {
+          const i3 = this.layout.get(t3).evaluate(e3, {}, n3, r3), s3 = this._unevaluatedLayout._values[t3];
+          return s3.isDataDriven() || ni2(s3.value) || !i3 ? i3 : function(t4, e4) {
+            return e4.replace(/{([^{}]+)}/g, (e5, n4) => t4 && n4 in t4 ? String(t4[n4]) : "");
+          }(e3.properties, i3);
+        }
+        createBucket(t3) {
+          return new vp(t3);
+        }
+        queryRadius() {
+          return 0;
+        }
+        queryIntersectsFeature() {
+          throw new Error("Should take a different path in FeatureIndex");
+        }
+        _setPaintOverrides() {
+          for (const t3 of _p2.paint.overridableProperties) {
+            if (!Ap.hasPaintOverride(this.layout, t3)) continue;
+            const e3 = this.paint.get(t3), n3 = new Sp(e3), r3 = new ei2(n3, e3.property.specification);
+            let i3 = null;
+            i3 = "constant" === e3.value.kind || "source" === e3.value.kind ? new ii2("source", r3) : new si2("composite", r3, e3.value.zoomStops), this.paint._values[t3] = new Us(e3.property, i3, e3.parameters);
+          }
+        }
+        _handleOverridablePaintPropertyUpdate(t3, e3, n3) {
+          return !(!this.layout || e3.isDataDriven() || n3.isDataDriven()) && Ap.hasPaintOverride(this.layout, t3);
+        }
+        static hasPaintOverride(t3, e3) {
+          const n3 = t3.get("text-field"), r3 = _p2.paint.properties[e3];
+          let i3 = false;
+          const s3 = (t4) => {
+            for (const e4 of t4) if (r3.overrides && r3.overrides.hasOverride(e4)) return void (i3 = true);
+          };
+          if ("constant" === n3.value.kind && n3.value.value instanceof De2) s3(n3.value.value.sections);
+          else if ("source" === n3.value.kind || "composite" === n3.value.kind) {
+            const t4 = (e5) => {
+              i3 || (e5 instanceof qe2 && Ue2(e5.value) === qt ? s3(e5.value.sections) : e5 instanceof Tn ? s3(e5.sections) : e5.eachChild(t4));
+            }, e4 = n3.value;
+            e4._styleExpression && t4(e4._styleExpression.expression);
+          }
+          return i3;
+        }
+      }
+      let Mp;
+      var kp = { get paint() {
+        return Mp = Mp || new Hs({ "background-color": new qs(vt.paint_background["background-color"]), "background-pattern": new Ys(vt.paint_background["background-pattern"]), "background-opacity": new qs(vt.paint_background["background-opacity"]) });
+      } };
+      class Ip extends Ws {
+        constructor(t3, e3) {
+          super(t3, kp, e3);
+        }
+      }
+      class Ep extends Ws {
+        constructor(t3, e3) {
+          super(t3, {}, e3), this.onAdd = (t4) => {
+            this.implementation.onAdd && this.implementation.onAdd(t4, t4.painter.context.gl);
+          }, this.onRemove = (t4) => {
+            this.implementation.onRemove && this.implementation.onRemove(t4, t4.painter.context.gl);
+          }, this.implementation = t3;
+        }
+        is3D() {
+          return "3d" === this.implementation.renderingMode;
+        }
+        hasOffscreenPass() {
+          return void 0 !== this.implementation.prerender;
+        }
+        recalculate() {
+        }
+        updateTransitions() {
+        }
+        hasTransition() {
+          return false;
+        }
+        serialize() {
+          throw new Error("Custom layers cannot be serialized");
+        }
+      }
+      class Tp {
+        constructor(t3) {
+          this._methodToThrottle = t3, this._triggered = false, this._channel = new MessageChannel(), this._channel.port2.onmessage = () => {
+            this._triggered = false, this._methodToThrottle();
+          };
+        }
+        trigger() {
+          var t3;
+          this._triggered || (this._triggered = true, null === (t3 = this._channel) || void 0 === t3 || t3.port1.postMessage(true));
+        }
+        remove() {
+          delete this._channel, this._methodToThrottle = () => {
+          };
+        }
+      }
+      const Fp = { once: true }, Dp = 63710088e-1;
+      class Pp {
+        constructor(t3, e3) {
+          if (isNaN(t3) || isNaN(e3)) throw new Error(`Invalid LngLat object: (${t3}, ${e3})`);
+          if (this.lng = +t3, this.lat = +e3, this.lat > 90 || this.lat < -90) throw new Error("Invalid LngLat latitude value: must be between -90 and 90");
+        }
+        wrap() {
+          return new Pp(L2(this.lng, -180, 180), this.lat);
+        }
+        toArray() {
+          return [this.lng, this.lat];
+        }
+        toString() {
+          return `LngLat(${this.lng}, ${this.lat})`;
+        }
+        distanceTo(t3) {
+          const e3 = Math.PI / 180, n3 = this.lat * e3, r3 = t3.lat * e3, i3 = Math.sin(n3) * Math.sin(r3) + Math.cos(n3) * Math.cos(r3) * Math.cos((t3.lng - this.lng) * e3);
+          return Dp * Math.acos(Math.min(i3, 1));
+        }
+        static convert(t3) {
+          if (t3 instanceof Pp) return t3;
+          if (Array.isArray(t3) && (2 === t3.length || 3 === t3.length)) return new Pp(Number(t3[0]), Number(t3[1]));
+          if (!Array.isArray(t3) && "object" == typeof t3 && null !== t3) return new Pp(Number("lng" in t3 ? t3.lng : t3.lon), Number(t3.lat));
+          throw new Error("`LngLatLike` argument must be specified as a LngLat instance, an object {lng: <lng>, lat: <lat>}, an object {lon: <lng>, lat: <lat>}, or an array of [<lng>, <lat>]");
+        }
+      }
+      const zp = 2 * Math.PI * Dp;
+      function Bp(t3) {
+        return zp * Math.cos(t3 * Math.PI / 180);
+      }
+      function Cp(t3) {
+        return (180 + t3) / 360;
+      }
+      function Vp(t3) {
+        return (180 - 180 / Math.PI * Math.log(Math.tan(Math.PI / 4 + t3 * Math.PI / 360))) / 360;
+      }
+      function Lp(t3, e3) {
+        return t3 / Bp(e3);
+      }
+      function Op(t3) {
+        return 360 * t3 - 180;
+      }
+      function $p(t3) {
+        return 360 / Math.PI * Math.atan(Math.exp((180 - 360 * t3) * Math.PI / 180)) - 90;
+      }
+      function Rp(t3, e3) {
+        return t3 * Bp($p(e3));
+      }
+      class Np {
+        constructor(t3, e3, n3 = 0) {
+          this.x = +t3, this.y = +e3, this.z = +n3;
+        }
+        static fromLngLat(t3, e3 = 0) {
+          const n3 = Pp.convert(t3);
+          return new Np(Cp(n3.lng), Vp(n3.lat), Lp(e3, n3.lat));
+        }
+        toLngLat() {
+          return new Pp(Op(this.x), $p(this.y));
+        }
+        toAltitude() {
+          return Rp(this.z, this.y);
+        }
+        meterInMercatorCoordinateUnits() {
+          return 1 / zp * (t3 = $p(this.y), 1 / Math.cos(t3 * Math.PI / 180));
+          var t3;
+        }
+      }
+      function Up(t3, e3, n3) {
+        var r3 = 2 * Math.PI * 6378137 / 256 / Math.pow(2, n3);
+        return [t3 * r3 - 2 * Math.PI * 6378137 / 2, e3 * r3 - 2 * Math.PI * 6378137 / 2];
+      }
+      class jp {
+        constructor(t3, e3, n3) {
+          if (!function(t4, e4, n4) {
+            return !(t4 < 0 || t4 > 25 || n4 < 0 || n4 >= Math.pow(2, t4) || e4 < 0 || e4 >= Math.pow(2, t4));
+          }(t3, e3, n3)) throw new Error(`x=${e3}, y=${n3}, z=${t3} outside of bounds. 0<=x<${Math.pow(2, t3)}, 0<=y<${Math.pow(2, t3)} 0<=z<=25 `);
+          this.z = t3, this.x = e3, this.y = n3, this.key = Xp(0, t3, t3, e3, n3);
+        }
+        equals(t3) {
+          return this.z === t3.z && this.x === t3.x && this.y === t3.y;
+        }
+        url(t3, e3, n3) {
+          const r3 = (s3 = this.y, o3 = this.z, a3 = Up(256 * (i3 = this.x), 256 * (s3 = Math.pow(2, o3) - s3 - 1), o3), l3 = Up(256 * (i3 + 1), 256 * (s3 + 1), o3), a3[0] + "," + a3[1] + "," + l3[0] + "," + l3[1]);
+          var i3, s3, o3, a3, l3;
+          const u3 = function(t4, e4, n4) {
+            let r4, i4 = "";
+            for (let s4 = t4; s4 > 0; s4--) r4 = 1 << s4 - 1, i4 += (e4 & r4 ? 1 : 0) + (n4 & r4 ? 2 : 0);
+            return i4;
+          }(this.z, this.x, this.y);
+          return t3[(this.x + this.y) % t3.length].replace(/{prefix}/g, (this.x % 16).toString(16) + (this.y % 16).toString(16)).replace(/{z}/g, String(this.z)).replace(/{x}/g, String(this.x)).replace(/{y}/g, String("tms" === n3 ? Math.pow(2, this.z) - this.y - 1 : this.y)).replace(/{ratio}/g, e3 > 1 ? "@2x" : "").replace(/{quadkey}/g, u3).replace(/{bbox-epsg-3857}/g, r3);
+        }
+        isChildOf(t3) {
+          const e3 = this.z - t3.z;
+          return e3 > 0 && t3.x === this.x >> e3 && t3.y === this.y >> e3;
+        }
+        getTilePoint(t3) {
+          const e3 = Math.pow(2, this.z);
+          return new n2((t3.x * e3 - this.x) * T2, (t3.y * e3 - this.y) * T2);
+        }
+        toString() {
+          return `${this.z}/${this.x}/${this.y}`;
+        }
+      }
+      class qp {
+        constructor(t3, e3) {
+          this.wrap = t3, this.canonical = e3, this.key = Xp(t3, e3.z, e3.z, e3.x, e3.y);
+        }
+      }
+      class Gp {
+        constructor(t3, e3, n3, r3, i3) {
+          if (this.terrainRttPosMatrix32f = null, t3 < n3) throw new Error(`overscaledZ should be >= z; overscaledZ = ${t3}; z = ${n3}`);
+          this.overscaledZ = t3, this.wrap = e3, this.canonical = new jp(n3, +r3, +i3), this.key = Xp(e3, t3, n3, r3, i3);
+        }
+        clone() {
+          return new Gp(this.overscaledZ, this.wrap, this.canonical.z, this.canonical.x, this.canonical.y);
+        }
+        equals(t3) {
+          return this.overscaledZ === t3.overscaledZ && this.wrap === t3.wrap && this.canonical.equals(t3.canonical);
+        }
+        scaledTo(t3) {
+          if (t3 > this.overscaledZ) throw new Error(`targetZ > this.overscaledZ; targetZ = ${t3}; overscaledZ = ${this.overscaledZ}`);
+          const e3 = this.canonical.z - t3;
+          return t3 > this.canonical.z ? new Gp(t3, this.wrap, this.canonical.z, this.canonical.x, this.canonical.y) : new Gp(t3, this.wrap, t3, this.canonical.x >> e3, this.canonical.y >> e3);
+        }
+        isOverscaled() {
+          return this.overscaledZ > this.canonical.z;
+        }
+        calculateScaledKey(t3, e3) {
+          if (t3 > this.overscaledZ) throw new Error(`targetZ > this.overscaledZ; targetZ = ${t3}; overscaledZ = ${this.overscaledZ}`);
+          const n3 = this.canonical.z - t3;
+          return t3 > this.canonical.z ? Xp(this.wrap * +e3, t3, this.canonical.z, this.canonical.x, this.canonical.y) : Xp(this.wrap * +e3, t3, t3, this.canonical.x >> n3, this.canonical.y >> n3);
+        }
+        isChildOf(t3) {
+          if (t3.wrap !== this.wrap) return false;
+          if (this.overscaledZ - t3.overscaledZ <= 0) return false;
+          if (0 === t3.overscaledZ) return this.overscaledZ > 0;
+          const e3 = this.canonical.z - t3.canonical.z;
+          return !(e3 < 0) && t3.canonical.x === this.canonical.x >> e3 && t3.canonical.y === this.canonical.y >> e3;
+        }
+        children(t3) {
+          if (this.overscaledZ >= t3) return [new Gp(this.overscaledZ + 1, this.wrap, this.canonical.z, this.canonical.x, this.canonical.y)];
+          const e3 = this.canonical.z + 1, n3 = 2 * this.canonical.x, r3 = 2 * this.canonical.y;
+          return [new Gp(e3, this.wrap, e3, n3, r3), new Gp(e3, this.wrap, e3, n3 + 1, r3), new Gp(e3, this.wrap, e3, n3, r3 + 1), new Gp(e3, this.wrap, e3, n3 + 1, r3 + 1)];
+        }
+        isLessThan(t3) {
+          return this.wrap < t3.wrap || !(this.wrap > t3.wrap) && (this.overscaledZ < t3.overscaledZ || !(this.overscaledZ > t3.overscaledZ) && (this.canonical.x < t3.canonical.x || !(this.canonical.x > t3.canonical.x) && this.canonical.y < t3.canonical.y));
+        }
+        wrapped() {
+          return new Gp(this.overscaledZ, 0, this.canonical.z, this.canonical.x, this.canonical.y);
+        }
+        unwrapTo(t3) {
+          return new Gp(this.overscaledZ, t3, this.canonical.z, this.canonical.x, this.canonical.y);
+        }
+        overscaleFactor() {
+          return Math.pow(2, this.overscaledZ - this.canonical.z);
+        }
+        toUnwrapped() {
+          return new qp(this.wrap, this.canonical);
+        }
+        toString() {
+          return `${this.overscaledZ}/${this.canonical.x}/${this.canonical.y}`;
+        }
+        getTilePoint(t3) {
+          return this.canonical.getTilePoint(new Np(t3.x - this.wrap, t3.y));
+        }
+        normalizeCoordinates(t3, e3, n3 = 8192) {
+          if (t3 >= 0 && t3 < n3 && e3 >= 0 && e3 < n3) return { tileID: this, x: t3, y: e3 };
+          const r3 = Math.floor(t3 / n3), i3 = Math.floor(e3 / n3), s3 = t3 - r3 * n3, o3 = e3 - i3 * n3, a3 = this.canonical.z, l3 = 1 << a3, u3 = this.canonical.y + i3;
+          if (u3 < 0 || u3 >= l3) return null;
+          let c3 = this.canonical.x + r3, h3 = this.wrap;
+          return c3 < 0 ? (h3 -= Math.ceil(-c3 / l3), c3 = (c3 % l3 + l3) % l3) : c3 >= l3 && (h3 += Math.floor(c3 / l3), c3 %= l3), { tileID: new Gp(this.overscaledZ, h3, a3, c3, u3), x: s3, y: o3 };
+        }
+      }
+      function Xp(t3, e3, n3, r3, i3) {
+        (t3 *= 2) < 0 && (t3 = -1 * t3 - 1);
+        const s3 = 1 << n3;
+        return (s3 * s3 * t3 + s3 * i3 + r3).toString(36) + n3.toString(36) + e3.toString(36);
+      }
+      ps("CanonicalTileID", jp), ps("OverscaledTileID", Gp, { omit: ["terrainRttPosMatrix32f"] });
+      class Yp {
+        constructor() {
+          this.minX = 1 / 0, this.maxX = -1 / 0, this.minY = 1 / 0, this.maxY = -1 / 0;
+        }
+        extend(t3) {
+          return this.minX = Math.min(this.minX, t3.x), this.minY = Math.min(this.minY, t3.y), this.maxX = Math.max(this.maxX, t3.x), this.maxY = Math.max(this.maxY, t3.y), this;
+        }
+        expandBy(t3) {
+          return this.minX -= t3, this.minY -= t3, this.maxX += t3, this.maxY += t3, (this.minX > this.maxX || this.minY > this.maxY) && (this.minX = 1 / 0, this.maxX = -1 / 0, this.minY = 1 / 0, this.maxY = -1 / 0), this;
+        }
+        shrinkBy(t3) {
+          return this.expandBy(-t3);
+        }
+        map(t3) {
+          const e3 = new Yp();
+          return e3.extend(t3(new n2(this.minX, this.minY))), e3.extend(t3(new n2(this.maxX, this.minY))), e3.extend(t3(new n2(this.minX, this.maxY))), e3.extend(t3(new n2(this.maxX, this.maxY))), e3;
+        }
+        static fromPoints(t3) {
+          const e3 = new Yp();
+          for (const n3 of t3) e3.extend(n3);
+          return e3;
+        }
+        contains(t3) {
+          return t3.x >= this.minX && t3.x <= this.maxX && t3.y >= this.minY && t3.y <= this.maxY;
+        }
+        empty() {
+          return this.minX > this.maxX;
+        }
+        width() {
+          return this.maxX - this.minX;
+        }
+        height() {
+          return this.maxY - this.minY;
+        }
+        covers(t3) {
+          return !this.empty() && !t3.empty() && t3.minX >= this.minX && t3.maxX <= this.maxX && t3.minY >= this.minY && t3.maxY <= this.maxY;
+        }
+        intersects(t3) {
+          return !this.empty() && !t3.empty() && t3.minX <= this.maxX && t3.maxX >= this.minX && t3.minY <= this.maxY && t3.maxY >= this.minY;
+        }
+      }
+      class Zp {
+        constructor(t3) {
+          this._stringToNumber = {}, this._numberToString = [];
+          for (let e3 = 0; e3 < t3.length; e3++) {
+            const n3 = t3[e3];
+            this._stringToNumber[n3] = e3, this._numberToString[e3] = n3;
+          }
+        }
+        encode(t3) {
+          return this._stringToNumber[t3];
+        }
+        decode(t3) {
+          if (t3 >= this._numberToString.length) throw new Error(`Out of bounds. Index requested n=${t3} can't be >= this._numberToString.length ${this._numberToString.length}`);
+          return this._numberToString[t3];
+        }
+      }
+      class Hp {
+        constructor(t3, e3, n3, r3, i3) {
+          this.type = "Feature", this._vectorTileFeature = t3, this._x = n3, this._y = r3, this._z = e3, this.properties = t3.properties, this.id = i3;
+        }
+        projectPoint(t3, e3, n3, r3) {
+          return [360 * (t3.x + e3) / r3 - 180, 360 / Math.PI * Math.atan(Math.exp((1 - 2 * (t3.y + n3) / r3) * Math.PI)) - 90];
+        }
+        projectLine(t3, e3, n3, r3) {
+          return t3.map((t4) => this.projectPoint(t4, e3, n3, r3));
+        }
+        get geometry() {
+          if (this._geometry) return this._geometry;
+          const t3 = this._vectorTileFeature, e3 = t3.extent * Math.pow(2, this._z), n3 = t3.extent * this._x, r3 = t3.extent * this._y, i3 = t3.loadGeometry();
+          switch (t3.type) {
+            case 1: {
+              const t4 = [];
+              for (const e4 of i3) t4.push(e4[0]);
+              const s3 = this.projectLine(t4, n3, r3, e3);
+              this._geometry = 1 === t4.length ? { type: "Point", coordinates: s3[0] } : { type: "MultiPoint", coordinates: s3 };
+              break;
+            }
+            case 2: {
+              const t4 = i3.map((t5) => this.projectLine(t5, n3, r3, e3));
+              this._geometry = 1 === t4.length ? { type: "LineString", coordinates: t4[0] } : { type: "MultiLineString", coordinates: t4 };
+              break;
+            }
+            case 3: {
+              const t4 = zu(i3), s3 = [];
+              for (const i4 of t4) s3.push(i4.map((t5) => this.projectLine(t5, n3, r3, e3)));
+              this._geometry = 1 === s3.length ? { type: "Polygon", coordinates: s3[0] } : { type: "MultiPolygon", coordinates: s3 };
+              break;
+            }
+            default:
+              throw new Error(`unknown feature type: ${t3.type}`);
+          }
+          return this._geometry;
+        }
+        set geometry(t3) {
+          this._geometry = t3;
+        }
+        toJSON() {
+          const t3 = { geometry: this.geometry };
+          for (const e3 in this) "_geometry" !== e3 && "_vectorTileFeature" !== e3 && "_x" !== e3 && "_y" !== e3 && "_z" !== e3 && (t3[e3] = this[e3]);
+          return t3;
+        }
+      }
+      class Wp {
+        constructor(t3, e3, n3) {
+          this._name = t3, this.dataBuffer = e3, "number" == typeof n3 ? this._size = n3 : (this.nullabilityBuffer = n3, this._size = n3.size());
+        }
+        getValue(t3) {
+          return this.nullabilityBuffer && !this.nullabilityBuffer.get(t3) ? null : this.getValueFromBuffer(t3);
+        }
+        has(t3) {
+          var _a4;
+          return ((_a4 = this.nullabilityBuffer) == null ? void 0 : _a4.get(t3)) || !this.nullabilityBuffer;
+        }
+        get name() {
+          return this._name;
+        }
+        get size() {
+          return this._size;
+        }
+      }
+      class Kp extends Wp {
+      }
+      class Jp extends Kp {
+        getValueFromBuffer(t3) {
+          return this.dataBuffer[t3];
+        }
+      }
+      class Qp extends Kp {
+        getValueFromBuffer(t3) {
+          return this.dataBuffer[t3];
+        }
+      }
+      class tf2 extends Wp {
+        constructor(t3, e3, n3, r3) {
+          super(t3, e3, r3), this.delta = n3;
+        }
+      }
+      class ef2 extends tf2 {
+        constructor(t3, e3, n3, r3) {
+          super(t3, Int32Array.of(e3), n3, r3);
+        }
+        getValueFromBuffer(t3) {
+          return this.dataBuffer[0] + t3 * this.delta;
+        }
+      }
+      class nf2 extends Wp {
+        constructor(t3, e3, n3, r3) {
+          super(t3, r3 ? Int32Array.of(e3) : Uint32Array.of(e3), n3);
+        }
+        getValueFromBuffer(t3) {
+          return this.dataBuffer[0];
+        }
+      }
+      class rf2 {
+        constructor(t3, e3, n3, r3, i3 = 4096) {
+          this._name = t3, this._geometryVector = e3, this._idVector = n3, this._propertyVectors = r3, this._extent = i3;
+        }
+        get name() {
+          return this._name;
+        }
+        get idVector() {
+          return this._idVector;
+        }
+        get geometryVector() {
+          return this._geometryVector;
+        }
+        get propertyVectors() {
+          return this._propertyVectors;
+        }
+        getPropertyVector(t3) {
+          return this.propertyVectorsMap || (this.propertyVectorsMap = new Map(this._propertyVectors.map((t4) => [t4.name, t4]))), this.propertyVectorsMap.get(t3);
+        }
+        get numFeatures() {
+          return this.geometryVector.numGeometries;
+        }
+        get extent() {
+          return this._extent;
+        }
+        getFeatures() {
+          const t3 = [], e3 = this.geometryVector.getGeometries();
+          for (let n3 = 0; n3 < this.numFeatures; n3++) {
+            let r3;
+            if (this.idVector) {
+              const t4 = this.idVector.getValue(n3);
+              r3 = this.containsMaxSafeIntegerValues(this.idVector) && null !== t4 ? Number(t4) : t4;
+            }
+            const i3 = { coordinates: e3[n3], type: this.geometryVector.geometryType(n3) }, s3 = {};
+            for (const t4 of this.propertyVectors) {
+              if (!t4) continue;
+              const e4 = t4.name, r4 = t4.getValue(n3);
+              null !== r4 && (s3[e4] = r4);
+            }
+            t3.push({ id: r3, geometry: i3, properties: s3 });
+          }
+          return t3;
+        }
+        containsMaxSafeIntegerValues(t3) {
+          return t3 instanceof Jp || t3 instanceof nf2 || t3 instanceof ef2 || t3 instanceof Qp;
+        }
+      }
+      class sf2 {
+        constructor(t3) {
+          this.value = t3;
+        }
+        get() {
+          return this.value;
+        }
+        set(t3) {
+          this.value = t3;
+        }
+        increment() {
+          return this.value++;
+        }
+        add(t3) {
+          this.value += t3;
+        }
+      }
+      var of2, af2;
+      !function(t3) {
+        t3.NONE = "NONE", t3.DELTA = "DELTA", t3.COMPONENTWISE_DELTA = "COMPONENTWISE_DELTA", t3.RLE = "RLE", t3.MORTON = "MORTON", t3.PDE = "PDE";
+      }(of2 || (of2 = {})), function(t3) {
+        t3.NONE = "NONE", t3.FAST_PFOR = "FAST_PFOR", t3.VARINT = "VARINT", t3.ALP = "ALP";
+      }(af2 || (af2 = {}));
+      const lf2 = new Uint32Array(33);
+      lf2[0] = 0;
+      for (let t3 = 1; t3 <= 32; t3++) lf2[t3] = 32 === t3 ? 4294967295 : 4294967295 >>> 32 - t3;
+      const uf2 = lf2, cf2 = 256;
+      function hf(t3, e3) {
+        return t3 - t3 % e3;
+      }
+      function pf2(t3) {
+        const e3 = t3 >>> 0;
+        return ((255 & e3) << 24 | (65280 & e3) << 8 | e3 >>> 8 & 65280 | e3 >>> 24 & 255) >>> 0;
+      }
+      const ff2 = function() {
+        if (!Number.isFinite(65536)) return 65536;
+        const t3 = hf(Math.floor(65536), cf2);
+        return 0 === t3 ? cf2 : t3;
+      }(), df2 = 3 * ff2 / cf2 + ff2 | 0;
+      function yf2() {
+        const t3 = new Uint8Array(df2);
+        return { dataToBePacked: new Array(33), dataPointers: new Int32Array(33), byteContainer: t3, byteContainerI32: new Int32Array(t3.buffer, t3.byteOffset, t3.byteLength >>> 2), exceptionSizes: new Int32Array(33) };
+      }
+      function mf2(t3, e3, n3, r3, i3) {
+        switch (i3) {
+          case 1:
+            !function(t4, e4, n4, r4) {
+              let i4 = r4, s3 = e4;
+              for (let e5 = 0; e5 < 8; e5++) {
+                const e6 = t4[s3++] >>> 0;
+                n4[i4++] = e6 >>> 0 & 1, n4[i4++] = e6 >>> 1 & 1, n4[i4++] = e6 >>> 2 & 1, n4[i4++] = e6 >>> 3 & 1, n4[i4++] = e6 >>> 4 & 1, n4[i4++] = e6 >>> 5 & 1, n4[i4++] = e6 >>> 6 & 1, n4[i4++] = e6 >>> 7 & 1, n4[i4++] = e6 >>> 8 & 1, n4[i4++] = e6 >>> 9 & 1, n4[i4++] = e6 >>> 10 & 1, n4[i4++] = e6 >>> 11 & 1, n4[i4++] = e6 >>> 12 & 1, n4[i4++] = e6 >>> 13 & 1, n4[i4++] = e6 >>> 14 & 1, n4[i4++] = e6 >>> 15 & 1, n4[i4++] = e6 >>> 16 & 1, n4[i4++] = e6 >>> 17 & 1, n4[i4++] = e6 >>> 18 & 1, n4[i4++] = e6 >>> 19 & 1, n4[i4++] = e6 >>> 20 & 1, n4[i4++] = e6 >>> 21 & 1, n4[i4++] = e6 >>> 22 & 1, n4[i4++] = e6 >>> 23 & 1, n4[i4++] = e6 >>> 24 & 1, n4[i4++] = e6 >>> 25 & 1, n4[i4++] = e6 >>> 26 & 1, n4[i4++] = e6 >>> 27 & 1, n4[i4++] = e6 >>> 28 & 1, n4[i4++] = e6 >>> 29 & 1, n4[i4++] = e6 >>> 30 & 1, n4[i4++] = e6 >>> 31 & 1;
+              }
+            }(t3, e3, n3, r3);
+            break;
+          case 2:
+            !function(t4, e4, n4, r4) {
+              let i4 = r4, s3 = e4;
+              for (let e5 = 0; e5 < 8; e5++) {
+                const e6 = t4[s3++] >>> 0, r5 = t4[s3++] >>> 0;
+                n4[i4++] = e6 >>> 0 & 3, n4[i4++] = e6 >>> 2 & 3, n4[i4++] = e6 >>> 4 & 3, n4[i4++] = e6 >>> 6 & 3, n4[i4++] = e6 >>> 8 & 3, n4[i4++] = e6 >>> 10 & 3, n4[i4++] = e6 >>> 12 & 3, n4[i4++] = e6 >>> 14 & 3, n4[i4++] = e6 >>> 16 & 3, n4[i4++] = e6 >>> 18 & 3, n4[i4++] = e6 >>> 20 & 3, n4[i4++] = e6 >>> 22 & 3, n4[i4++] = e6 >>> 24 & 3, n4[i4++] = e6 >>> 26 & 3, n4[i4++] = e6 >>> 28 & 3, n4[i4++] = e6 >>> 30 & 3, n4[i4++] = r5 >>> 0 & 3, n4[i4++] = r5 >>> 2 & 3, n4[i4++] = r5 >>> 4 & 3, n4[i4++] = r5 >>> 6 & 3, n4[i4++] = r5 >>> 8 & 3, n4[i4++] = r5 >>> 10 & 3, n4[i4++] = r5 >>> 12 & 3, n4[i4++] = r5 >>> 14 & 3, n4[i4++] = r5 >>> 16 & 3, n4[i4++] = r5 >>> 18 & 3, n4[i4++] = r5 >>> 20 & 3, n4[i4++] = r5 >>> 22 & 3, n4[i4++] = r5 >>> 24 & 3, n4[i4++] = r5 >>> 26 & 3, n4[i4++] = r5 >>> 28 & 3, n4[i4++] = r5 >>> 30 & 3;
+              }
+            }(t3, e3, n3, r3);
+            break;
+          case 3:
+            !function(t4, e4, n4, r4) {
+              let i4 = r4, s3 = e4;
+              for (let e5 = 0; e5 < 8; e5++) {
+                const e6 = t4[s3++] >>> 0, r5 = t4[s3++] >>> 0, o3 = t4[s3++] >>> 0;
+                n4[i4++] = e6 >>> 0 & 7, n4[i4++] = e6 >>> 3 & 7, n4[i4++] = e6 >>> 6 & 7, n4[i4++] = e6 >>> 9 & 7, n4[i4++] = e6 >>> 12 & 7, n4[i4++] = e6 >>> 15 & 7, n4[i4++] = e6 >>> 18 & 7, n4[i4++] = e6 >>> 21 & 7, n4[i4++] = e6 >>> 24 & 7, n4[i4++] = e6 >>> 27 & 7, n4[i4++] = 7 & (e6 >>> 30 | (1 & r5) << 2), n4[i4++] = r5 >>> 1 & 7, n4[i4++] = r5 >>> 4 & 7, n4[i4++] = r5 >>> 7 & 7, n4[i4++] = r5 >>> 10 & 7, n4[i4++] = r5 >>> 13 & 7, n4[i4++] = r5 >>> 16 & 7, n4[i4++] = r5 >>> 19 & 7, n4[i4++] = r5 >>> 22 & 7, n4[i4++] = r5 >>> 25 & 7, n4[i4++] = r5 >>> 28 & 7, n4[i4++] = 7 & (r5 >>> 31 | (3 & o3) << 1), n4[i4++] = o3 >>> 2 & 7, n4[i4++] = o3 >>> 5 & 7, n4[i4++] = o3 >>> 8 & 7, n4[i4++] = o3 >>> 11 & 7, n4[i4++] = o3 >>> 14 & 7, n4[i4++] = o3 >>> 17 & 7, n4[i4++] = o3 >>> 20 & 7, n4[i4++] = o3 >>> 23 & 7, n4[i4++] = o3 >>> 26 & 7, n4[i4++] = o3 >>> 29 & 7;
+              }
+            }(t3, e3, n3, r3);
+            break;
+          case 4:
+            !function(t4, e4, n4, r4) {
+              let i4 = r4, s3 = e4;
+              for (let e5 = 0; e5 < 8; e5++) {
+                const e6 = t4[s3++] >>> 0, r5 = t4[s3++] >>> 0, o3 = t4[s3++] >>> 0, a3 = t4[s3++] >>> 0;
+                n4[i4++] = e6 >>> 0 & 15, n4[i4++] = e6 >>> 4 & 15, n4[i4++] = e6 >>> 8 & 15, n4[i4++] = e6 >>> 12 & 15, n4[i4++] = e6 >>> 16 & 15, n4[i4++] = e6 >>> 20 & 15, n4[i4++] = e6 >>> 24 & 15, n4[i4++] = e6 >>> 28 & 15, n4[i4++] = r5 >>> 0 & 15, n4[i4++] = r5 >>> 4 & 15, n4[i4++] = r5 >>> 8 & 15, n4[i4++] = r5 >>> 12 & 15, n4[i4++] = r5 >>> 16 & 15, n4[i4++] = r5 >>> 20 & 15, n4[i4++] = r5 >>> 24 & 15, n4[i4++] = r5 >>> 28 & 15, n4[i4++] = o3 >>> 0 & 15, n4[i4++] = o3 >>> 4 & 15, n4[i4++] = o3 >>> 8 & 15, n4[i4++] = o3 >>> 12 & 15, n4[i4++] = o3 >>> 16 & 15, n4[i4++] = o3 >>> 20 & 15, n4[i4++] = o3 >>> 24 & 15, n4[i4++] = o3 >>> 28 & 15, n4[i4++] = a3 >>> 0 & 15, n4[i4++] = a3 >>> 4 & 15, n4[i4++] = a3 >>> 8 & 15, n4[i4++] = a3 >>> 12 & 15, n4[i4++] = a3 >>> 16 & 15, n4[i4++] = a3 >>> 20 & 15, n4[i4++] = a3 >>> 24 & 15, n4[i4++] = a3 >>> 28 & 15;
+              }
+            }(t3, e3, n3, r3);
+            break;
+          case 5:
+            !function(t4, e4, n4, r4) {
+              let i4 = r4, s3 = e4;
+              for (let e5 = 0; e5 < 8; e5++) {
+                const e6 = t4[s3++] >>> 0, r5 = t4[s3++] >>> 0, o3 = t4[s3++] >>> 0, a3 = t4[s3++] >>> 0, l3 = t4[s3++] >>> 0;
+                n4[i4++] = e6 >>> 0 & 31, n4[i4++] = e6 >>> 5 & 31, n4[i4++] = e6 >>> 10 & 31, n4[i4++] = e6 >>> 15 & 31, n4[i4++] = e6 >>> 20 & 31, n4[i4++] = e6 >>> 25 & 31, n4[i4++] = 31 & (e6 >>> 30 | (7 & r5) << 2), n4[i4++] = r5 >>> 3 & 31, n4[i4++] = r5 >>> 8 & 31, n4[i4++] = r5 >>> 13 & 31, n4[i4++] = r5 >>> 18 & 31, n4[i4++] = r5 >>> 23 & 31, n4[i4++] = 31 & (r5 >>> 28 | (1 & o3) << 4), n4[i4++] = o3 >>> 1 & 31, n4[i4++] = o3 >>> 6 & 31, n4[i4++] = o3 >>> 11 & 31, n4[i4++] = o3 >>> 16 & 31, n4[i4++] = o3 >>> 21 & 31, n4[i4++] = o3 >>> 26 & 31, n4[i4++] = 31 & (o3 >>> 31 | (15 & a3) << 1), n4[i4++] = a3 >>> 4 & 31, n4[i4++] = a3 >>> 9 & 31, n4[i4++] = a3 >>> 14 & 31, n4[i4++] = a3 >>> 19 & 31, n4[i4++] = a3 >>> 24 & 31, n4[i4++] = 31 & (a3 >>> 29 | (3 & l3) << 3), n4[i4++] = l3 >>> 2 & 31, n4[i4++] = l3 >>> 7 & 31, n4[i4++] = l3 >>> 12 & 31, n4[i4++] = l3 >>> 17 & 31, n4[i4++] = l3 >>> 22 & 31, n4[i4++] = l3 >>> 27 & 31;
+              }
+            }(t3, e3, n3, r3);
+            break;
+          case 6:
+            !function(t4, e4, n4, r4) {
+              let i4 = r4, s3 = e4;
+              for (let e5 = 0; e5 < 8; e5++) {
+                const e6 = t4[s3++] >>> 0, r5 = t4[s3++] >>> 0, o3 = t4[s3++] >>> 0, a3 = t4[s3++] >>> 0, l3 = t4[s3++] >>> 0, u3 = t4[s3++] >>> 0;
+                n4[i4++] = e6 >>> 0 & 63, n4[i4++] = e6 >>> 6 & 63, n4[i4++] = e6 >>> 12 & 63, n4[i4++] = e6 >>> 18 & 63, n4[i4++] = e6 >>> 24 & 63, n4[i4++] = 63 & (e6 >>> 30 | (15 & r5) << 2), n4[i4++] = r5 >>> 4 & 63, n4[i4++] = r5 >>> 10 & 63, n4[i4++] = r5 >>> 16 & 63, n4[i4++] = r5 >>> 22 & 63, n4[i4++] = 63 & (r5 >>> 28 | (3 & o3) << 4), n4[i4++] = o3 >>> 2 & 63, n4[i4++] = o3 >>> 8 & 63, n4[i4++] = o3 >>> 14 & 63, n4[i4++] = o3 >>> 20 & 63, n4[i4++] = o3 >>> 26 & 63, n4[i4++] = a3 >>> 0 & 63, n4[i4++] = a3 >>> 6 & 63, n4[i4++] = a3 >>> 12 & 63, n4[i4++] = a3 >>> 18 & 63, n4[i4++] = a3 >>> 24 & 63, n4[i4++] = 63 & (a3 >>> 30 | (15 & l3) << 2), n4[i4++] = l3 >>> 4 & 63, n4[i4++] = l3 >>> 10 & 63, n4[i4++] = l3 >>> 16 & 63, n4[i4++] = l3 >>> 22 & 63, n4[i4++] = 63 & (l3 >>> 28 | (3 & u3) << 4), n4[i4++] = u3 >>> 2 & 63, n4[i4++] = u3 >>> 8 & 63, n4[i4++] = u3 >>> 14 & 63, n4[i4++] = u3 >>> 20 & 63, n4[i4++] = u3 >>> 26 & 63;
+              }
+            }(t3, e3, n3, r3);
+            break;
+          case 7:
+            !function(t4, e4, n4, r4) {
+              let i4 = r4, s3 = e4;
+              for (let e5 = 0; e5 < 8; e5++) {
+                const e6 = t4[s3++] >>> 0, r5 = t4[s3++] >>> 0, o3 = t4[s3++] >>> 0, a3 = t4[s3++] >>> 0, l3 = t4[s3++] >>> 0, u3 = t4[s3++] >>> 0, c3 = t4[s3++] >>> 0;
+                n4[i4++] = e6 >>> 0 & 127, n4[i4++] = e6 >>> 7 & 127, n4[i4++] = e6 >>> 14 & 127, n4[i4++] = e6 >>> 21 & 127, n4[i4++] = 127 & (e6 >>> 28 | (7 & r5) << 4), n4[i4++] = r5 >>> 3 & 127, n4[i4++] = r5 >>> 10 & 127, n4[i4++] = r5 >>> 17 & 127, n4[i4++] = r5 >>> 24 & 127, n4[i4++] = 127 & (r5 >>> 31 | (63 & o3) << 1), n4[i4++] = o3 >>> 6 & 127, n4[i4++] = o3 >>> 13 & 127, n4[i4++] = o3 >>> 20 & 127, n4[i4++] = 127 & (o3 >>> 27 | (3 & a3) << 5), n4[i4++] = a3 >>> 2 & 127, n4[i4++] = a3 >>> 9 & 127, n4[i4++] = a3 >>> 16 & 127, n4[i4++] = a3 >>> 23 & 127, n4[i4++] = 127 & (a3 >>> 30 | (31 & l3) << 2), n4[i4++] = l3 >>> 5 & 127, n4[i4++] = l3 >>> 12 & 127, n4[i4++] = l3 >>> 19 & 127, n4[i4++] = 127 & (l3 >>> 26 | (1 & u3) << 6), n4[i4++] = u3 >>> 1 & 127, n4[i4++] = u3 >>> 8 & 127, n4[i4++] = u3 >>> 15 & 127, n4[i4++] = u3 >>> 22 & 127, n4[i4++] = 127 & (u3 >>> 29 | (15 & c3) << 3), n4[i4++] = c3 >>> 4 & 127, n4[i4++] = c3 >>> 11 & 127, n4[i4++] = c3 >>> 18 & 127, n4[i4++] = c3 >>> 25 & 127;
+              }
+            }(t3, e3, n3, r3);
+            break;
+          case 8:
+            !function(t4, e4, n4, r4) {
+              let i4 = r4, s3 = e4;
+              for (let e5 = 0; e5 < 8; e5++) {
+                const e6 = t4[s3++] >>> 0, r5 = t4[s3++] >>> 0, o3 = t4[s3++] >>> 0, a3 = t4[s3++] >>> 0, l3 = t4[s3++] >>> 0, u3 = t4[s3++] >>> 0, c3 = t4[s3++] >>> 0, h3 = t4[s3++] >>> 0;
+                n4[i4++] = e6 >>> 0 & 255, n4[i4++] = e6 >>> 8 & 255, n4[i4++] = e6 >>> 16 & 255, n4[i4++] = e6 >>> 24 & 255, n4[i4++] = r5 >>> 0 & 255, n4[i4++] = r5 >>> 8 & 255, n4[i4++] = r5 >>> 16 & 255, n4[i4++] = r5 >>> 24 & 255, n4[i4++] = o3 >>> 0 & 255, n4[i4++] = o3 >>> 8 & 255, n4[i4++] = o3 >>> 16 & 255, n4[i4++] = o3 >>> 24 & 255, n4[i4++] = a3 >>> 0 & 255, n4[i4++] = a3 >>> 8 & 255, n4[i4++] = a3 >>> 16 & 255, n4[i4++] = a3 >>> 24 & 255, n4[i4++] = l3 >>> 0 & 255, n4[i4++] = l3 >>> 8 & 255, n4[i4++] = l3 >>> 16 & 255, n4[i4++] = l3 >>> 24 & 255, n4[i4++] = u3 >>> 0 & 255, n4[i4++] = u3 >>> 8 & 255, n4[i4++] = u3 >>> 16 & 255, n4[i4++] = u3 >>> 24 & 255, n4[i4++] = c3 >>> 0 & 255, n4[i4++] = c3 >>> 8 & 255, n4[i4++] = c3 >>> 16 & 255, n4[i4++] = c3 >>> 24 & 255, n4[i4++] = h3 >>> 0 & 255, n4[i4++] = h3 >>> 8 & 255, n4[i4++] = h3 >>> 16 & 255, n4[i4++] = h3 >>> 24 & 255;
+              }
+            }(t3, e3, n3, r3);
+            break;
+          case 16:
+            !function(t4, e4, n4, r4) {
+              let i4 = r4, s3 = e4;
+              for (let e5 = 0; e5 < 128; e5++) {
+                const e6 = t4[s3++] >>> 0;
+                n4[i4++] = 65535 & e6, n4[i4++] = e6 >>> 16 & 65535;
+              }
+            }(t3, e3, n3, r3);
+            break;
+          default:
+            !function(t4, e4, n4, r4, i4) {
+              const s3 = uf2[i4] >>> 0;
+              let o3 = e4, a3 = 0, l3 = t4[o3] >>> 0, u3 = r4;
+              for (let e5 = 0; e5 < 8; e5++) {
+                for (let e6 = 0; e6 < 32; e6++) if (a3 + i4 <= 32) n4[u3 + e6] = l3 >>> a3 & s3, a3 += i4, 32 === a3 && (a3 = 0, o3++, 31 !== e6 && (l3 = t4[o3] >>> 0));
+                else {
+                  const r5 = 32 - a3, c3 = l3 >>> a3;
+                  o3++, l3 = t4[o3] >>> 0;
+                  const h3 = i4 - r5;
+                  n4[u3 + e6] = (c3 | (l3 & -1 >>> 32 - h3 >>> 0) << r5) & s3, a3 = h3;
+                }
+                u3 += 32, a3 = 0, e5 < 7 && (l3 = t4[o3] >>> 0);
+              }
+            }(t3, e3, n3, r3, i3);
+        }
+        return e3 + (i3 << 3) | 0;
+      }
+      function gf(t3, e3, n3, r3) {
+        if (n3 + 2 > e3) throw new Error(`FastPFOR decode: byteContainer underflow at block=${r3} (need 2 bytes for [bitWidth, exceptionCount], bytePos=${n3}, byteSize=${e3})`);
+        const i3 = t3[n3++], s3 = t3[n3++];
+        if (i3 > 32) throw new Error(`FastPFOR decode: invalid bitWidth=${i3} at block=${r3} (expected 0..32). This likely indicates corrupted or truncated input.`);
+        return { bitWidth: i3, exceptionCount: s3, bytePosIn: n3 };
+      }
+      function xf2(t3, e3, n3, r3, i3, s3, o3, a3, l3) {
+        const { maxBits: u3, exceptionBitWidth: c3, bytePosIn: h3 } = function(t4, e4, n4, r4, i4, s4) {
+          if (n4 + 1 > e4) throw new Error(`FastPFOR decode: exception header underflow at block=${s4} (need 1 byte for maxBits, bytePos=${n4}, byteSize=${e4})`);
+          const o4 = t4[n4++];
+          if (o4 < r4 || o4 > 32) throw new Error(`FastPFOR decode: invalid maxBits=${o4} at block=${s4} (bitWidth=${r4}, expected ${r4}..32)`);
+          const a4 = o4 - r4 | 0;
+          if (a4 < 1 || a4 > 32) throw new Error(`FastPFOR decode: invalid exceptionBitWidth=${a4} at block=${s4} (bitWidth=${r4}, maxBits=${o4})`);
+          if (n4 + i4 > e4) throw new Error(`FastPFOR decode: exception positions underflow at block=${s4} (need=${i4}, have=${e4 - n4})`);
+          return { maxBits: o4, exceptionBitWidth: a4, bytePosIn: n4 };
+        }(i3, s3, o3, n3, r3, l3);
+        if (o3 = h3, 1 === c3) {
+          const s4 = 1 << n3;
+          for (let n4 = 0; n4 < r3; n4 = n4 + 1 | 0) t3[i3[o3++] + e3 | 0] |= s4;
+          return o3;
+        }
+        const p3 = a3.dataToBePacked[c3];
+        if (!p3) throw new Error(`FastPFOR decode: missing exception stream for exceptionBitWidth=${c3} (bitWidth=${n3}, maxBits=${u3}) at block ${l3}`);
+        const f3 = a3.dataPointers;
+        let d3 = 0 | f3[c3];
+        const y3 = 0 | a3.exceptionSizes[c3];
+        if (d3 + r3 > y3) throw new Error(`FastPFOR decode: exception stream overflow for exceptionBitWidth=${c3} (ptr=${d3}, need ${r3}, size=${y3}) at block ${l3}`);
+        for (let s4 = 0; s4 < r3; s4 = s4 + 1 | 0) {
+          const r4 = i3[o3++], s5 = 0 | p3[d3++];
+          t3[r4 + e3 | 0] |= s5 << n3;
+        }
+        return f3[c3] = d3, o3;
+      }
+      function vf2(t3, e3, n3, r3, i3, s3) {
+        const o3 = 0 | n3, a3 = 0 | t3[o3];
+        if (a3 <= 0 || o3 + a3 > t3.length - 1) throw new Error(`FastPFOR decode: invalid whereMeta=${a3} at pageStart=${o3} (expected > 0 and pageStart+whereMeta < encoded.length=${t3.length})`);
+        const l3 = o3 + 1 | 0, u3 = o3 + a3 | 0, c3 = t3[u3] >>> 0, h3 = c3 + 3 >>> 2, p3 = u3 + 1, f3 = p3 + h3;
+        if (f3 >= t3.length) throw new Error(`FastPFOR decode: invalid byteSize=${c3} (metaInts=${h3}, pageStart=${o3}, packedEnd=${u3}, byteContainerStart=${p3}) causes bitmapPos=${f3} out of bounds (encoded.length=${t3.length})`);
+        const d3 = function(t4, e4, n4, r4) {
+          r4.byteContainer.length < n4 && (r4.byteContainer = new Uint8Array(2 * n4), r4.byteContainerI32 = void 0);
+          const i4 = r4.byteContainer, s4 = n4 >>> 2;
+          if (3 & i4.byteOffset) for (let n5 = 0; n5 < s4; n5 = n5 + 1 | 0) {
+            const r5 = 0 | t4[e4 + n5 | 0], s5 = n5 << 2;
+            i4[s5] = 255 & r5, i4[s5 + 1 | 0] = r5 >>> 8 & 255, i4[s5 + 2 | 0] = r5 >>> 16 & 255, i4[s5 + 3 | 0] = r5 >>> 24 & 255;
+          }
+          else {
+            let n5 = r4.byteContainerI32;
+            (!n5 || n5.buffer !== i4.buffer || n5.byteOffset !== i4.byteOffset || n5.length < s4) && (n5 = r4.byteContainerI32 = new Int32Array(i4.buffer, i4.byteOffset, i4.byteLength >>> 2)), n5.set(t4.subarray(e4, e4 + s4));
+          }
+          const o4 = 3 & n4;
+          if (o4 > 0) {
+            const n5 = 0 | t4[e4 + s4 | 0], r5 = s4 << 2;
+            for (let t5 = 0; t5 < o4; t5 = t5 + 1 | 0) i4[r5 + t5 | 0] = n5 >>> (t5 << 3) & 255;
+          }
+          return i4;
+        }(t3, p3, c3, s3), y3 = c3, m3 = function(t4, e4, n4) {
+          const r4 = 0 | t4[e4++], i4 = n4.dataToBePacked;
+          for (let s4 = 2; s4 <= 32; s4 = s4 + 1 | 0) {
+            if (!(r4 >>> s4 - 1 & 1)) continue;
+            if (e4 >= t4.length) throw new Error(`FastPFOR decode: truncated exception stream header (bitWidth=${s4}, streamWordIndex=${e4}, needWords=1, availableWords=${t4.length - e4}, encodedWords=${t4.length})`);
+            const o4 = t4[e4++] >>> 0, a4 = hf(o4 + 31, 32), l4 = o4 * s4 + 31 >>> 5;
+            if (e4 + l4 > t4.length) throw new Error(`FastPFOR decode: truncated exception stream (bitWidth=${s4}, size=${o4}, streamWordIndex=${e4}, needWords=${l4}, availableWords=${t4.length - e4}, encodedWords=${t4.length})`);
+            let u4 = i4[s4];
+            (!u4 || u4.length < a4) && (u4 = i4[s4] = new Uint32Array(a4));
+            let c4 = 0;
+            for (; c4 < o4; c4 = c4 + 32 | 0) bf2(t4, e4, u4, c4, s4), e4 = e4 + s4 | 0;
+            e4 = e4 - ((c4 - o4 | 0) * s4 >>> 5) | 0, n4.exceptionSizes[s4] = o4;
+          }
+          return e4;
+        }(t3, f3, s3);
+        return s3.dataPointers.fill(0), function(t4, e4, n4, r4, i4, s4, o4, a4, l4, u4) {
+          let c4 = 0 | n4, h4 = 0;
+          for (let e5 = 0; e5 < o4; e5 = e5 + 1 | 0) {
+            const n5 = gf(a4, l4, h4, e5);
+            h4 = n5.bytePosIn;
+            const r5 = n5.bitWidth, o5 = n5.exceptionCount, p4 = s4 + e5 * cf2 | 0;
+            switch (r5) {
+              case 0:
+                i4.fill(0, p4, p4 + cf2);
+                break;
+              case 32:
+                for (let e6 = 0; e6 < cf2; e6 = e6 + 1 | 0) i4[p4 + e6 | 0] = 0 | t4[c4 + e6 | 0];
+                c4 = c4 + cf2 | 0;
+                break;
+              default:
+                c4 = mf2(t4, c4, i4, p4, r5);
+            }
+            o5 > 0 && (h4 = xf2(i4, p4, r5, o5, a4, l4, h4, u4, e5));
+          }
+          if (c4 !== r4) throw new Error(`FastPFOR decode: packed region mismatch (pageStart=${e4}, packedStart=${n4}, consumedPackedEnd=${c4}, expectedPackedEnd=${r4}, packedWords=${r4 - n4}, encoded.length=${t4.length})`);
+        }(t3, o3, l3, u3, e3, 0 | r3, i3 / cf2 | 0, d3, y3, s3), m3;
+      }
+      function bf2(t3, e3, n3, r3, i3) {
+        switch (i3) {
+          case 2:
+            return void function(t4, e4, n4, r4) {
+              let i4 = r4;
+              const s4 = t4[e4] >>> 0, o4 = t4[e4 + 1] >>> 0;
+              n4[i4++] = s4 >>> 0 & 3, n4[i4++] = s4 >>> 2 & 3, n4[i4++] = s4 >>> 4 & 3, n4[i4++] = s4 >>> 6 & 3, n4[i4++] = s4 >>> 8 & 3, n4[i4++] = s4 >>> 10 & 3, n4[i4++] = s4 >>> 12 & 3, n4[i4++] = s4 >>> 14 & 3, n4[i4++] = s4 >>> 16 & 3, n4[i4++] = s4 >>> 18 & 3, n4[i4++] = s4 >>> 20 & 3, n4[i4++] = s4 >>> 22 & 3, n4[i4++] = s4 >>> 24 & 3, n4[i4++] = s4 >>> 26 & 3, n4[i4++] = s4 >>> 28 & 3, n4[i4++] = s4 >>> 30 & 3, n4[i4++] = o4 >>> 0 & 3, n4[i4++] = o4 >>> 2 & 3, n4[i4++] = o4 >>> 4 & 3, n4[i4++] = o4 >>> 6 & 3, n4[i4++] = o4 >>> 8 & 3, n4[i4++] = o4 >>> 10 & 3, n4[i4++] = o4 >>> 12 & 3, n4[i4++] = o4 >>> 14 & 3, n4[i4++] = o4 >>> 16 & 3, n4[i4++] = o4 >>> 18 & 3, n4[i4++] = o4 >>> 20 & 3, n4[i4++] = o4 >>> 22 & 3, n4[i4++] = o4 >>> 24 & 3, n4[i4++] = o4 >>> 26 & 3, n4[i4++] = o4 >>> 28 & 3, n4[i4] = o4 >>> 30 & 3;
+            }(t3, e3, n3, r3);
+          case 3:
+            return void function(t4, e4, n4, r4) {
+              let i4 = r4;
+              const s4 = t4[e4] >>> 0, o4 = t4[e4 + 1] >>> 0, a4 = t4[e4 + 2] >>> 0;
+              n4[i4++] = s4 >>> 0 & 7, n4[i4++] = s4 >>> 3 & 7, n4[i4++] = s4 >>> 6 & 7, n4[i4++] = s4 >>> 9 & 7, n4[i4++] = s4 >>> 12 & 7, n4[i4++] = s4 >>> 15 & 7, n4[i4++] = s4 >>> 18 & 7, n4[i4++] = s4 >>> 21 & 7, n4[i4++] = s4 >>> 24 & 7, n4[i4++] = s4 >>> 27 & 7, n4[i4++] = 7 & (s4 >>> 30 | (1 & o4) << 2), n4[i4++] = o4 >>> 1 & 7, n4[i4++] = o4 >>> 4 & 7, n4[i4++] = o4 >>> 7 & 7, n4[i4++] = o4 >>> 10 & 7, n4[i4++] = o4 >>> 13 & 7, n4[i4++] = o4 >>> 16 & 7, n4[i4++] = o4 >>> 19 & 7, n4[i4++] = o4 >>> 22 & 7, n4[i4++] = o4 >>> 25 & 7, n4[i4++] = o4 >>> 28 & 7, n4[i4++] = 7 & (o4 >>> 31 | (3 & a4) << 1), n4[i4++] = a4 >>> 2 & 7, n4[i4++] = a4 >>> 5 & 7, n4[i4++] = a4 >>> 8 & 7, n4[i4++] = a4 >>> 11 & 7, n4[i4++] = a4 >>> 14 & 7, n4[i4++] = a4 >>> 17 & 7, n4[i4++] = a4 >>> 20 & 7, n4[i4++] = a4 >>> 23 & 7, n4[i4++] = a4 >>> 26 & 7, n4[i4] = a4 >>> 29 & 7;
+            }(t3, e3, n3, r3);
+          case 4:
+            return void function(t4, e4, n4, r4) {
+              let i4 = r4;
+              const s4 = t4[e4] >>> 0, o4 = t4[e4 + 1] >>> 0, a4 = t4[e4 + 2] >>> 0, l4 = t4[e4 + 3] >>> 0;
+              n4[i4++] = s4 >>> 0 & 15, n4[i4++] = s4 >>> 4 & 15, n4[i4++] = s4 >>> 8 & 15, n4[i4++] = s4 >>> 12 & 15, n4[i4++] = s4 >>> 16 & 15, n4[i4++] = s4 >>> 20 & 15, n4[i4++] = s4 >>> 24 & 15, n4[i4++] = s4 >>> 28 & 15, n4[i4++] = o4 >>> 0 & 15, n4[i4++] = o4 >>> 4 & 15, n4[i4++] = o4 >>> 8 & 15, n4[i4++] = o4 >>> 12 & 15, n4[i4++] = o4 >>> 16 & 15, n4[i4++] = o4 >>> 20 & 15, n4[i4++] = o4 >>> 24 & 15, n4[i4++] = o4 >>> 28 & 15, n4[i4++] = a4 >>> 0 & 15, n4[i4++] = a4 >>> 4 & 15, n4[i4++] = a4 >>> 8 & 15, n4[i4++] = a4 >>> 12 & 15, n4[i4++] = a4 >>> 16 & 15, n4[i4++] = a4 >>> 20 & 15, n4[i4++] = a4 >>> 24 & 15, n4[i4++] = a4 >>> 28 & 15, n4[i4++] = l4 >>> 0 & 15, n4[i4++] = l4 >>> 4 & 15, n4[i4++] = l4 >>> 8 & 15, n4[i4++] = l4 >>> 12 & 15, n4[i4++] = l4 >>> 16 & 15, n4[i4++] = l4 >>> 20 & 15, n4[i4++] = l4 >>> 24 & 15, n4[i4] = l4 >>> 28 & 15;
+            }(t3, e3, n3, r3);
+          case 5:
+            return void function(t4, e4, n4, r4) {
+              let i4 = r4;
+              const s4 = t4[e4] >>> 0, o4 = t4[e4 + 1] >>> 0, a4 = t4[e4 + 2] >>> 0, l4 = t4[e4 + 3] >>> 0, u3 = t4[e4 + 4] >>> 0;
+              n4[i4++] = s4 >>> 0 & 31, n4[i4++] = s4 >>> 5 & 31, n4[i4++] = s4 >>> 10 & 31, n4[i4++] = s4 >>> 15 & 31, n4[i4++] = s4 >>> 20 & 31, n4[i4++] = s4 >>> 25 & 31, n4[i4++] = 31 & (s4 >>> 30 | (7 & o4) << 2), n4[i4++] = o4 >>> 3 & 31, n4[i4++] = o4 >>> 8 & 31, n4[i4++] = o4 >>> 13 & 31, n4[i4++] = o4 >>> 18 & 31, n4[i4++] = o4 >>> 23 & 31, n4[i4++] = 31 & (o4 >>> 28 | (1 & a4) << 4), n4[i4++] = a4 >>> 1 & 31, n4[i4++] = a4 >>> 6 & 31, n4[i4++] = a4 >>> 11 & 31, n4[i4++] = a4 >>> 16 & 31, n4[i4++] = a4 >>> 21 & 31, n4[i4++] = a4 >>> 26 & 31, n4[i4++] = 31 & (a4 >>> 31 | (15 & l4) << 1), n4[i4++] = l4 >>> 4 & 31, n4[i4++] = l4 >>> 9 & 31, n4[i4++] = l4 >>> 14 & 31, n4[i4++] = l4 >>> 19 & 31, n4[i4++] = l4 >>> 24 & 31, n4[i4++] = 31 & (l4 >>> 29 | (3 & u3) << 3), n4[i4++] = u3 >>> 2 & 31, n4[i4++] = u3 >>> 7 & 31, n4[i4++] = u3 >>> 12 & 31, n4[i4++] = u3 >>> 17 & 31, n4[i4++] = u3 >>> 22 & 31, n4[i4] = u3 >>> 27 & 31;
+            }(t3, e3, n3, r3);
+          case 6:
+            return void function(t4, e4, n4, r4) {
+              let i4 = r4;
+              const s4 = t4[e4] >>> 0, o4 = t4[e4 + 1] >>> 0, a4 = t4[e4 + 2] >>> 0, l4 = t4[e4 + 3] >>> 0, u3 = t4[e4 + 4] >>> 0, c3 = t4[e4 + 5] >>> 0;
+              n4[i4++] = s4 >>> 0 & 63, n4[i4++] = s4 >>> 6 & 63, n4[i4++] = s4 >>> 12 & 63, n4[i4++] = s4 >>> 18 & 63, n4[i4++] = s4 >>> 24 & 63, n4[i4++] = 63 & (s4 >>> 30 | (15 & o4) << 2), n4[i4++] = o4 >>> 4 & 63, n4[i4++] = o4 >>> 10 & 63, n4[i4++] = o4 >>> 16 & 63, n4[i4++] = o4 >>> 22 & 63, n4[i4++] = 63 & (o4 >>> 28 | (3 & a4) << 4), n4[i4++] = a4 >>> 2 & 63, n4[i4++] = a4 >>> 8 & 63, n4[i4++] = a4 >>> 14 & 63, n4[i4++] = a4 >>> 20 & 63, n4[i4++] = a4 >>> 26 & 63, n4[i4++] = l4 >>> 0 & 63, n4[i4++] = l4 >>> 6 & 63, n4[i4++] = l4 >>> 12 & 63, n4[i4++] = l4 >>> 18 & 63, n4[i4++] = l4 >>> 24 & 63, n4[i4++] = 63 & (l4 >>> 30 | (15 & u3) << 2), n4[i4++] = u3 >>> 4 & 63, n4[i4++] = u3 >>> 10 & 63, n4[i4++] = u3 >>> 16 & 63, n4[i4++] = u3 >>> 22 & 63, n4[i4++] = 63 & (u3 >>> 28 | (3 & c3) << 4), n4[i4++] = c3 >>> 2 & 63, n4[i4++] = c3 >>> 8 & 63, n4[i4++] = c3 >>> 14 & 63, n4[i4++] = c3 >>> 20 & 63, n4[i4] = c3 >>> 26 & 63;
+            }(t3, e3, n3, r3);
+          case 7:
+            return void function(t4, e4, n4, r4) {
+              let i4 = r4;
+              const s4 = t4[e4] >>> 0, o4 = t4[e4 + 1] >>> 0, a4 = t4[e4 + 2] >>> 0, l4 = t4[e4 + 3] >>> 0, u3 = t4[e4 + 4] >>> 0, c3 = t4[e4 + 5] >>> 0, h3 = t4[e4 + 6] >>> 0;
+              n4[i4++] = s4 >>> 0 & 127, n4[i4++] = s4 >>> 7 & 127, n4[i4++] = s4 >>> 14 & 127, n4[i4++] = s4 >>> 21 & 127, n4[i4++] = 127 & (s4 >>> 28 | (7 & o4) << 4), n4[i4++] = o4 >>> 3 & 127, n4[i4++] = o4 >>> 10 & 127, n4[i4++] = o4 >>> 17 & 127, n4[i4++] = o4 >>> 24 & 127, n4[i4++] = 127 & (o4 >>> 31 | (63 & a4) << 1), n4[i4++] = a4 >>> 6 & 127, n4[i4++] = a4 >>> 13 & 127, n4[i4++] = a4 >>> 20 & 127, n4[i4++] = 127 & (a4 >>> 27 | (3 & l4) << 5), n4[i4++] = l4 >>> 2 & 127, n4[i4++] = l4 >>> 9 & 127, n4[i4++] = l4 >>> 16 & 127, n4[i4++] = l4 >>> 23 & 127, n4[i4++] = 127 & (l4 >>> 30 | (31 & u3) << 2), n4[i4++] = u3 >>> 5 & 127, n4[i4++] = u3 >>> 12 & 127, n4[i4++] = u3 >>> 19 & 127, n4[i4++] = 127 & (u3 >>> 26 | (1 & c3) << 6), n4[i4++] = c3 >>> 1 & 127, n4[i4++] = c3 >>> 8 & 127, n4[i4++] = c3 >>> 15 & 127, n4[i4++] = c3 >>> 22 & 127, n4[i4++] = 127 & (c3 >>> 29 | (15 & h3) << 3), n4[i4++] = h3 >>> 4 & 127, n4[i4++] = h3 >>> 11 & 127, n4[i4++] = h3 >>> 18 & 127, n4[i4] = h3 >>> 25 & 127;
+            }(t3, e3, n3, r3);
+          case 8:
+            return void function(t4, e4, n4, r4) {
+              let i4 = r4;
+              const s4 = t4[e4] >>> 0, o4 = t4[e4 + 1] >>> 0, a4 = t4[e4 + 2] >>> 0, l4 = t4[e4 + 3] >>> 0, u3 = t4[e4 + 4] >>> 0, c3 = t4[e4 + 5] >>> 0, h3 = t4[e4 + 6] >>> 0, p3 = t4[e4 + 7] >>> 0;
+              n4[i4++] = s4 >>> 0 & 255, n4[i4++] = s4 >>> 8 & 255, n4[i4++] = s4 >>> 16 & 255, n4[i4++] = s4 >>> 24 & 255, n4[i4++] = o4 >>> 0 & 255, n4[i4++] = o4 >>> 8 & 255, n4[i4++] = o4 >>> 16 & 255, n4[i4++] = o4 >>> 24 & 255, n4[i4++] = a4 >>> 0 & 255, n4[i4++] = a4 >>> 8 & 255, n4[i4++] = a4 >>> 16 & 255, n4[i4++] = a4 >>> 24 & 255, n4[i4++] = l4 >>> 0 & 255, n4[i4++] = l4 >>> 8 & 255, n4[i4++] = l4 >>> 16 & 255, n4[i4++] = l4 >>> 24 & 255, n4[i4++] = u3 >>> 0 & 255, n4[i4++] = u3 >>> 8 & 255, n4[i4++] = u3 >>> 16 & 255, n4[i4++] = u3 >>> 24 & 255, n4[i4++] = c3 >>> 0 & 255, n4[i4++] = c3 >>> 8 & 255, n4[i4++] = c3 >>> 16 & 255, n4[i4++] = c3 >>> 24 & 255, n4[i4++] = h3 >>> 0 & 255, n4[i4++] = h3 >>> 8 & 255, n4[i4++] = h3 >>> 16 & 255, n4[i4++] = h3 >>> 24 & 255, n4[i4++] = p3 >>> 0 & 255, n4[i4++] = p3 >>> 8 & 255, n4[i4++] = p3 >>> 16 & 255, n4[i4] = p3 >>> 24 & 255;
+            }(t3, e3, n3, r3);
+          case 9:
+            return void function(t4, e4, n4, r4) {
+              let i4 = r4;
+              const s4 = t4[e4] >>> 0, o4 = t4[e4 + 1] >>> 0, a4 = t4[e4 + 2] >>> 0, l4 = t4[e4 + 3] >>> 0, u3 = t4[e4 + 4] >>> 0, c3 = t4[e4 + 5] >>> 0, h3 = t4[e4 + 6] >>> 0, p3 = t4[e4 + 7] >>> 0, f3 = t4[e4 + 8] >>> 0;
+              n4[i4++] = s4 >>> 0 & 511, n4[i4++] = s4 >>> 9 & 511, n4[i4++] = s4 >>> 18 & 511, n4[i4++] = 511 & (s4 >>> 27 | (15 & o4) << 5), n4[i4++] = o4 >>> 4 & 511, n4[i4++] = o4 >>> 13 & 511, n4[i4++] = o4 >>> 22 & 511, n4[i4++] = 511 & (o4 >>> 31 | (255 & a4) << 1), n4[i4++] = a4 >>> 8 & 511, n4[i4++] = a4 >>> 17 & 511, n4[i4++] = 511 & (a4 >>> 26 | (7 & l4) << 6), n4[i4++] = l4 >>> 3 & 511, n4[i4++] = l4 >>> 12 & 511, n4[i4++] = l4 >>> 21 & 511, n4[i4++] = 511 & (l4 >>> 30 | (127 & u3) << 2), n4[i4++] = u3 >>> 7 & 511, n4[i4++] = u3 >>> 16 & 511, n4[i4++] = 511 & (u3 >>> 25 | (3 & c3) << 7), n4[i4++] = c3 >>> 2 & 511, n4[i4++] = c3 >>> 11 & 511, n4[i4++] = c3 >>> 20 & 511, n4[i4++] = 511 & (c3 >>> 29 | (63 & h3) << 3), n4[i4++] = h3 >>> 6 & 511, n4[i4++] = h3 >>> 15 & 511, n4[i4++] = 511 & (h3 >>> 24 | (1 & p3) << 8), n4[i4++] = p3 >>> 1 & 511, n4[i4++] = p3 >>> 10 & 511, n4[i4++] = p3 >>> 19 & 511, n4[i4++] = 511 & (p3 >>> 28 | (31 & f3) << 4), n4[i4++] = f3 >>> 5 & 511, n4[i4++] = f3 >>> 14 & 511, n4[i4] = f3 >>> 23 & 511;
+            }(t3, e3, n3, r3);
+          case 10:
+            return void function(t4, e4, n4, r4) {
+              let i4 = r4;
+              const s4 = t4[e4] >>> 0, o4 = t4[e4 + 1] >>> 0, a4 = t4[e4 + 2] >>> 0, l4 = t4[e4 + 3] >>> 0, u3 = t4[e4 + 4] >>> 0, c3 = t4[e4 + 5] >>> 0, h3 = t4[e4 + 6] >>> 0, p3 = t4[e4 + 7] >>> 0, f3 = t4[e4 + 8] >>> 0, d3 = t4[e4 + 9] >>> 0;
+              n4[i4++] = s4 >>> 0 & 1023, n4[i4++] = s4 >>> 10 & 1023, n4[i4++] = s4 >>> 20 & 1023, n4[i4++] = 1023 & (s4 >>> 30 | (255 & o4) << 2), n4[i4++] = o4 >>> 8 & 1023, n4[i4++] = o4 >>> 18 & 1023, n4[i4++] = 1023 & (o4 >>> 28 | (63 & a4) << 4), n4[i4++] = a4 >>> 6 & 1023, n4[i4++] = a4 >>> 16 & 1023, n4[i4++] = 1023 & (a4 >>> 26 | (15 & l4) << 6), n4[i4++] = l4 >>> 4 & 1023, n4[i4++] = l4 >>> 14 & 1023, n4[i4++] = 1023 & (l4 >>> 24 | (3 & u3) << 8), n4[i4++] = u3 >>> 2 & 1023, n4[i4++] = u3 >>> 12 & 1023, n4[i4++] = u3 >>> 22 & 1023, n4[i4++] = c3 >>> 0 & 1023, n4[i4++] = c3 >>> 10 & 1023, n4[i4++] = c3 >>> 20 & 1023, n4[i4++] = 1023 & (c3 >>> 30 | (255 & h3) << 2), n4[i4++] = h3 >>> 8 & 1023, n4[i4++] = h3 >>> 18 & 1023, n4[i4++] = 1023 & (h3 >>> 28 | (63 & p3) << 4), n4[i4++] = p3 >>> 6 & 1023, n4[i4++] = p3 >>> 16 & 1023, n4[i4++] = 1023 & (p3 >>> 26 | (15 & f3) << 6), n4[i4++] = f3 >>> 4 & 1023, n4[i4++] = f3 >>> 14 & 1023, n4[i4++] = 1023 & (f3 >>> 24 | (3 & d3) << 8), n4[i4++] = d3 >>> 2 & 1023, n4[i4++] = d3 >>> 12 & 1023, n4[i4] = d3 >>> 22 & 1023;
+            }(t3, e3, n3, r3);
+          case 11:
+            return void function(t4, e4, n4, r4) {
+              let i4 = r4;
+              const s4 = t4[e4] >>> 0, o4 = t4[e4 + 1] >>> 0, a4 = t4[e4 + 2] >>> 0, l4 = t4[e4 + 3] >>> 0, u3 = t4[e4 + 4] >>> 0, c3 = t4[e4 + 5] >>> 0, h3 = t4[e4 + 6] >>> 0, p3 = t4[e4 + 7] >>> 0, f3 = t4[e4 + 8] >>> 0, d3 = t4[e4 + 9] >>> 0, y3 = t4[e4 + 10] >>> 0;
+              n4[i4++] = s4 >>> 0 & 2047, n4[i4++] = s4 >>> 11 & 2047, n4[i4++] = 2047 & (s4 >>> 22 | (1 & o4) << 10), n4[i4++] = o4 >>> 1 & 2047, n4[i4++] = o4 >>> 12 & 2047, n4[i4++] = 2047 & (o4 >>> 23 | (3 & a4) << 9), n4[i4++] = a4 >>> 2 & 2047, n4[i4++] = a4 >>> 13 & 2047, n4[i4++] = 2047 & (a4 >>> 24 | (7 & l4) << 8), n4[i4++] = l4 >>> 3 & 2047, n4[i4++] = l4 >>> 14 & 2047, n4[i4++] = 2047 & (l4 >>> 25 | (15 & u3) << 7), n4[i4++] = u3 >>> 4 & 2047, n4[i4++] = u3 >>> 15 & 2047, n4[i4++] = 2047 & (u3 >>> 26 | (31 & c3) << 6), n4[i4++] = c3 >>> 5 & 2047, n4[i4++] = c3 >>> 16 & 2047, n4[i4++] = 2047 & (c3 >>> 27 | (63 & h3) << 5), n4[i4++] = h3 >>> 6 & 2047, n4[i4++] = h3 >>> 17 & 2047, n4[i4++] = 2047 & (h3 >>> 28 | (127 & p3) << 4), n4[i4++] = p3 >>> 7 & 2047, n4[i4++] = p3 >>> 18 & 2047, n4[i4++] = 2047 & (p3 >>> 29 | (255 & f3) << 3), n4[i4++] = f3 >>> 8 & 2047, n4[i4++] = f3 >>> 19 & 2047, n4[i4++] = 2047 & (f3 >>> 30 | (511 & d3) << 2), n4[i4++] = d3 >>> 9 & 2047, n4[i4++] = d3 >>> 20 & 2047, n4[i4++] = 2047 & (d3 >>> 31 | (1023 & y3) << 1), n4[i4++] = y3 >>> 10 & 2047, n4[i4] = y3 >>> 21 & 2047;
+            }(t3, e3, n3, r3);
+          case 12:
+            return void function(t4, e4, n4, r4) {
+              let i4 = r4;
+              const s4 = t4[e4] >>> 0, o4 = t4[e4 + 1] >>> 0, a4 = t4[e4 + 2] >>> 0, l4 = t4[e4 + 3] >>> 0, u3 = t4[e4 + 4] >>> 0, c3 = t4[e4 + 5] >>> 0, h3 = t4[e4 + 6] >>> 0, p3 = t4[e4 + 7] >>> 0, f3 = t4[e4 + 8] >>> 0, d3 = t4[e4 + 9] >>> 0, y3 = t4[e4 + 10] >>> 0, m3 = t4[e4 + 11] >>> 0;
+              n4[i4++] = s4 >>> 0 & 4095, n4[i4++] = s4 >>> 12 & 4095, n4[i4++] = 4095 & (s4 >>> 24 | (15 & o4) << 8), n4[i4++] = o4 >>> 4 & 4095, n4[i4++] = o4 >>> 16 & 4095, n4[i4++] = 4095 & (o4 >>> 28 | (255 & a4) << 4), n4[i4++] = a4 >>> 8 & 4095, n4[i4++] = a4 >>> 20 & 4095, n4[i4++] = l4 >>> 0 & 4095, n4[i4++] = l4 >>> 12 & 4095, n4[i4++] = 4095 & (l4 >>> 24 | (15 & u3) << 8), n4[i4++] = u3 >>> 4 & 4095, n4[i4++] = u3 >>> 16 & 4095, n4[i4++] = 4095 & (u3 >>> 28 | (255 & c3) << 4), n4[i4++] = c3 >>> 8 & 4095, n4[i4++] = c3 >>> 20 & 4095, n4[i4++] = h3 >>> 0 & 4095, n4[i4++] = h3 >>> 12 & 4095, n4[i4++] = 4095 & (h3 >>> 24 | (15 & p3) << 8), n4[i4++] = p3 >>> 4 & 4095, n4[i4++] = p3 >>> 16 & 4095, n4[i4++] = 4095 & (p3 >>> 28 | (255 & f3) << 4), n4[i4++] = f3 >>> 8 & 4095, n4[i4++] = f3 >>> 20 & 4095, n4[i4++] = d3 >>> 0 & 4095, n4[i4++] = d3 >>> 12 & 4095, n4[i4++] = 4095 & (d3 >>> 24 | (15 & y3) << 8), n4[i4++] = y3 >>> 4 & 4095, n4[i4++] = y3 >>> 16 & 4095, n4[i4++] = 4095 & (y3 >>> 28 | (255 & m3) << 4), n4[i4++] = m3 >>> 8 & 4095, n4[i4] = m3 >>> 20 & 4095;
+            }(t3, e3, n3, r3);
+          case 16:
+            return void function(t4, e4, n4, r4) {
+              let i4 = r4;
+              const s4 = t4[e4] >>> 0, o4 = t4[e4 + 1] >>> 0, a4 = t4[e4 + 2] >>> 0, l4 = t4[e4 + 3] >>> 0, u3 = t4[e4 + 4] >>> 0, c3 = t4[e4 + 5] >>> 0, h3 = t4[e4 + 6] >>> 0, p3 = t4[e4 + 7] >>> 0, f3 = t4[e4 + 8] >>> 0, d3 = t4[e4 + 9] >>> 0, y3 = t4[e4 + 10] >>> 0, m3 = t4[e4 + 11] >>> 0, g3 = t4[e4 + 12] >>> 0, x3 = t4[e4 + 13] >>> 0, v3 = t4[e4 + 14] >>> 0, b3 = t4[e4 + 15] >>> 0;
+              n4[i4++] = s4 >>> 0 & 65535, n4[i4++] = s4 >>> 16 & 65535, n4[i4++] = o4 >>> 0 & 65535, n4[i4++] = o4 >>> 16 & 65535, n4[i4++] = a4 >>> 0 & 65535, n4[i4++] = a4 >>> 16 & 65535, n4[i4++] = l4 >>> 0 & 65535, n4[i4++] = l4 >>> 16 & 65535, n4[i4++] = u3 >>> 0 & 65535, n4[i4++] = u3 >>> 16 & 65535, n4[i4++] = c3 >>> 0 & 65535, n4[i4++] = c3 >>> 16 & 65535, n4[i4++] = h3 >>> 0 & 65535, n4[i4++] = h3 >>> 16 & 65535, n4[i4++] = p3 >>> 0 & 65535, n4[i4++] = p3 >>> 16 & 65535, n4[i4++] = f3 >>> 0 & 65535, n4[i4++] = f3 >>> 16 & 65535, n4[i4++] = d3 >>> 0 & 65535, n4[i4++] = d3 >>> 16 & 65535, n4[i4++] = y3 >>> 0 & 65535, n4[i4++] = y3 >>> 16 & 65535, n4[i4++] = m3 >>> 0 & 65535, n4[i4++] = m3 >>> 16 & 65535, n4[i4++] = g3 >>> 0 & 65535, n4[i4++] = g3 >>> 16 & 65535, n4[i4++] = x3 >>> 0 & 65535, n4[i4++] = x3 >>> 16 & 65535, n4[i4++] = v3 >>> 0 & 65535, n4[i4++] = v3 >>> 16 & 65535, n4[i4++] = b3 >>> 0 & 65535, n4[i4] = b3 >>> 16 & 65535;
+            }(t3, e3, n3, r3);
+          case 32:
+            for (let i4 = 0; i4 < 32; i4 = i4 + 1 | 0) n3[r3 + i4 | 0] = 0 | t3[e3 + i4 | 0];
+            return;
+        }
+        const s3 = uf2[i3] >>> 0;
+        let o3 = e3, a3 = 0, l3 = t3[o3] >>> 0;
+        for (let e4 = 0; e4 < 32; e4++) if (a3 + i3 <= 32) n3[r3 + e4] = l3 >>> a3 & s3, a3 += i3, 32 === a3 && (a3 = 0, o3++, 31 !== e4 && (l3 = t3[o3] >>> 0));
+        else {
+          const u3 = 32 - a3, c3 = l3 >>> a3;
+          o3++, l3 = t3[o3] >>> 0, n3[r3 + e4] = (c3 | (l3 & uf2[i3 - u3] >>> 0) << u3) & s3, a3 = i3 - u3;
+        }
+      }
+      function wf2(t3, e3, n3) {
+        const r3 = new Uint32Array(n3);
+        let i3 = 0, s3 = e3.get();
+        for (let e4 = 0; e4 < r3.length; e4++) {
+          let e5 = t3[s3++], n4 = 127 & e5;
+          e5 < 128 || (e5 = t3[s3++], n4 |= (127 & e5) << 7, e5 < 128 || (e5 = t3[s3++], n4 |= (127 & e5) << 14, e5 < 128 || (e5 = t3[s3++], n4 |= (127 & e5) << 21, e5 < 128 || (e5 = t3[s3++], n4 |= (15 & e5) << 28)))), r3[i3++] = n4;
+        }
+        return e3.set(s3), r3;
+      }
+      function _f2(t3, e3, n3) {
+        const r3 = new BigUint64Array(n3);
+        for (let n4 = 0; n4 < r3.length; n4++) r3[n4] = Sf2(t3, e3);
+        return r3;
+      }
+      function Sf2(t3, e3) {
+        let n3 = 0n, r3 = 0, i3 = e3.get();
+        for (; i3 < t3.length; ) {
+          const e4 = t3[i3++];
+          if (n3 |= BigInt(127 & e4) << BigInt(r3), !(128 & e4)) break;
+          if (r3 += 7, r3 >= 64) throw new Error("Varint too long");
+        }
+        return e3.set(i3), n3;
+      }
+      function Af2(t3, e3) {
+        let n3, r3;
+        return r3 = t3[e3.get()], e3.increment(), n3 = 127 & r3, r3 < 128 ? n3 : (r3 = t3[e3.get()], e3.increment(), n3 |= (127 & r3) << 7, r3 < 128 ? n3 : (r3 = t3[e3.get()], e3.increment(), n3 |= (127 & r3) << 14, r3 < 128 ? n3 : (r3 = t3[e3.get()], e3.increment(), n3 |= (127 & r3) << 21, r3 < 128 ? n3 : (r3 = t3[e3.get()], n3 |= (15 & r3) << 28, function(t4, e4, n4) {
+          let r4, i3;
+          if (i3 = e4[n4.get()], n4.increment(), r4 = (112 & i3) >> 4, i3 < 128) return 4294967296 * r4 + (t4 >>> 0);
+          if (i3 = e4[n4.get()], n4.increment(), r4 |= (127 & i3) << 3, i3 < 128) return 4294967296 * r4 + (t4 >>> 0);
+          if (i3 = e4[n4.get()], n4.increment(), r4 |= (127 & i3) << 10, i3 < 128) return 4294967296 * r4 + (t4 >>> 0);
+          if (i3 = e4[n4.get()], n4.increment(), r4 |= (127 & i3) << 17, i3 < 128) return 4294967296 * r4 + (t4 >>> 0);
+          if (i3 = e4[n4.get()], n4.increment(), r4 |= (127 & i3) << 24, i3 < 128) return 4294967296 * r4 + (t4 >>> 0);
+          if (i3 = e4[n4.get()], n4.increment(), r4 |= (1 & i3) << 31, i3 < 128) return 4294967296 * r4 + (t4 >>> 0);
+          throw new Error("Expected varint not more than 10 bytes");
+        }(n3, t3, e3)))));
+      }
+      function Mf2(t3) {
+        return t3 >>> 1 ^ -(1 & t3);
+      }
+      function kf(t3) {
+        return t3 >> 1n ^ -(1n & t3);
+      }
+      function If2(t3) {
+        return t3 % 2 == 1 ? (t3 + 1) / -2 : t3 / 2;
+      }
+      function Ef2(t3, e3, n3) {
+        if (void 0 === n3) {
+          n3 = 0;
+          for (let r4 = 0; r4 < e3; r4++) n3 += t3[r4];
+        }
+        const r3 = new Uint32Array(n3);
+        let i3 = 0;
+        for (let n4 = 0; n4 < e3; n4++) {
+          const s3 = t3[n4];
+          r3.fill(t3[n4 + e3], i3, i3 + s3), i3 += s3;
+        }
+        return r3;
+      }
+      function Tf2(t3, e3, n3) {
+        if (void 0 === n3) {
+          n3 = 0;
+          for (let r4 = 0; r4 < e3; r4++) n3 += Number(t3[r4]);
+        }
+        const r3 = new BigUint64Array(n3);
+        let i3 = 0;
+        for (let n4 = 0; n4 < e3; n4++) {
+          const s3 = Number(t3[n4]);
+          r3.fill(t3[n4 + e3], i3, i3 + s3), i3 += s3;
+        }
+        return r3;
+      }
+      function Ff2(t3, e3, n3) {
+        const r3 = new Float64Array(n3);
+        let i3 = 0;
+        for (let n4 = 0; n4 < e3; n4++) {
+          const s3 = t3[n4];
+          r3.fill(t3[n4 + e3], i3, i3 + s3), i3 += s3;
+        }
+        return r3;
+      }
+      function Df2(t3) {
+        const e3 = new Int32Array(t3.length);
+        e3[0] = Mf2(t3[0]);
+        const n3 = t3.length / 4 * 4;
+        let r3 = 1;
+        if (n3 >= 4) for (; r3 < n3 - 4; r3 += 4) {
+          const n4 = t3[r3 + 1], i3 = t3[r3 + 2], s3 = t3[r3 + 3];
+          e3[r3] = Mf2(t3[r3]) + e3[r3 - 1], e3[r3 + 1] = Mf2(n4) + e3[r3], e3[r3 + 2] = Mf2(i3) + e3[r3 + 1], e3[r3 + 3] = Mf2(s3) + e3[r3 + 2];
+        }
+        for (; r3 !== t3.length; ++r3) e3[r3] = Mf2(t3[r3]) + e3[r3 - 1];
+        return e3;
+      }
+      function Pf2(t3) {
+        const e3 = new BigInt64Array(t3.length);
+        e3[0] = kf(t3[0]);
+        const n3 = t3.length / 4 * 4;
+        let r3 = 1;
+        if (n3 >= 4) for (; r3 < n3 - 4; r3 += 4) {
+          const n4 = t3[r3 + 1], i3 = t3[r3 + 2], s3 = t3[r3 + 3];
+          e3[r3] = kf(t3[r3]) + e3[r3 - 1], e3[r3 + 1] = kf(n4) + e3[r3], e3[r3 + 2] = kf(i3) + e3[r3 + 1], e3[r3 + 3] = kf(s3) + e3[r3 + 2];
+        }
+        for (; r3 !== e3.length; ++r3) e3[r3] = kf(t3[r3]) + e3[r3 - 1];
+        return e3;
+      }
+      function zf2(t3) {
+        const e3 = t3.length / 4 * 4;
+        let n3 = 1;
+        if (e3 >= 4) for (let r3 = t3[0]; n3 < e3 - 4; n3 += 4) r3 = t3[n3] += r3, r3 = t3[n3 + 1] += r3, r3 = t3[n3 + 2] += r3, r3 = t3[n3 + 3] += r3;
+        for (; n3 !== t3.length; ) t3[n3] += t3[n3 - 1], ++n3;
+      }
+      var Bf2, Cf2, Vf2, Lf2, Of2, $f2, Rf2, Nf2;
+      function Uf2(t3, e3) {
+        const n3 = function(t4, e4) {
+          const n4 = t4[e4.get()], r3 = Object.values(Bf2)[n4 >> 4];
+          let i3 = null;
+          switch (r3) {
+            case Bf2.DATA:
+              i3 = { dictionaryType: Object.values(Cf2)[15 & n4] };
+              break;
+            case Bf2.OFFSET:
+              i3 = { offsetType: Object.values(Vf2)[15 & n4] };
+              break;
+            case Bf2.LENGTH:
+              i3 = { lengthType: Object.values(Lf2)[15 & n4] };
+          }
+          e4.increment();
+          const s3 = t4[e4.get()], o3 = Object.values(of2)[s3 >> 5], a3 = Object.values(of2)[s3 >> 2 & 7], l3 = Object.values(af2)[3 & s3];
+          e4.increment();
+          const u3 = wf2(t4, e4, 2), c3 = u3[0];
+          return { physicalStreamType: r3, logicalStreamType: i3, logicalLevelTechnique1: o3, logicalLevelTechnique2: a3, physicalLevelTechnique: l3, numValues: c3, byteLength: u3[1], decompressedCount: c3 };
+        }(t3, e3);
+        return n3.logicalLevelTechnique1 === of2.MORTON ? function(t4, e4, n4) {
+          const r3 = wf2(e4, n4, 2);
+          return { physicalStreamType: t4.physicalStreamType, logicalStreamType: t4.logicalStreamType, logicalLevelTechnique1: t4.logicalLevelTechnique1, logicalLevelTechnique2: t4.logicalLevelTechnique2, physicalLevelTechnique: t4.physicalLevelTechnique, numValues: t4.numValues, byteLength: t4.byteLength, decompressedCount: t4.decompressedCount, numBits: r3[0], coordinateShift: r3[1] };
+        }(n3, t3, e3) : of2.RLE !== n3.logicalLevelTechnique1 && of2.RLE !== n3.logicalLevelTechnique2 || af2.NONE === n3.physicalLevelTechnique ? n3 : function(t4, e4, n4) {
+          const r3 = wf2(e4, n4, 2);
+          return { physicalStreamType: t4.physicalStreamType, logicalStreamType: t4.logicalStreamType, logicalLevelTechnique1: t4.logicalLevelTechnique1, logicalLevelTechnique2: t4.logicalLevelTechnique2, physicalLevelTechnique: t4.physicalLevelTechnique, numValues: t4.numValues, byteLength: t4.byteLength, decompressedCount: r3[1], runs: r3[0], numRleValues: r3[1] };
+        }(n3, t3, e3);
+      }
+      !function(t3) {
+        t3.PRESENT = "PRESENT", t3.DATA = "DATA", t3.OFFSET = "OFFSET", t3.LENGTH = "LENGTH";
+      }(Bf2 || (Bf2 = {})), function(t3) {
+        t3.NONE = "NONE", t3.SINGLE = "SINGLE", t3.SHARED = "SHARED", t3.VERTEX = "VERTEX", t3.MORTON = "MORTON", t3.FSST = "FSST";
+      }(Cf2 || (Cf2 = {})), function(t3) {
+        t3.VERTEX = "VERTEX", t3.INDEX = "INDEX", t3.STRING = "STRING", t3.KEY = "KEY";
+      }(Vf2 || (Vf2 = {})), function(t3) {
+        t3.VAR_BINARY = "VAR_BINARY", t3.GEOMETRIES = "GEOMETRIES", t3.PARTS = "PARTS", t3.RINGS = "RINGS", t3.TRIANGLES = "TRIANGLES", t3.SYMBOL = "SYMBOL", t3.DICTIONARY = "DICTIONARY";
+      }(Lf2 || (Lf2 = {})), function(t3) {
+        t3[t3.FLAT = 0] = "FLAT", t3[t3.CONST = 1] = "CONST", t3[t3.SEQUENCE = 2] = "SEQUENCE", t3[t3.DICTIONARY = 3] = "DICTIONARY", t3[t3.FSST_DICTIONARY = 4] = "FSST_DICTIONARY";
+      }(Of2 || (Of2 = {}));
+      class jf {
+        constructor(t3, e3) {
+          this.values = t3, this._size = e3;
+        }
+        get(t3) {
+          const e3 = Math.floor(t3 / 8);
+          return 1 == (this.values[e3] >> t3 % 8 & 1);
+        }
+        set(t3, e3) {
+          const n3 = Math.floor(t3 / 8);
+          this.values[n3] = this.values[n3] | (e3 ? 1 : 0) << t3 % 8;
+        }
+        getInt(t3) {
+          const e3 = Math.floor(t3 / 8);
+          return this.values[e3] >> t3 % 8 & 1;
+        }
+        size() {
+          return this._size;
+        }
+        getBuffer() {
+          return this.values;
+        }
+      }
+      function qf2(t3, e3, n3) {
+        if (!e3) return t3;
+        const r3 = e3.size(), i3 = new t3.constructor(r3);
+        let s3 = 0;
+        for (let o3 = 0; o3 < r3; o3++) i3[o3] = e3.get(o3) ? t3[s3++] : n3;
+        return i3;
+      }
+      function Gf2(t3, e3, n3, r3, i3) {
+        return function(t4, e4, n4, r4) {
+          let i4;
+          switch (e4.logicalLevelTechnique1) {
+            case of2.DELTA:
+              if (e4.logicalLevelTechnique2 === of2.RLE) {
+                const n5 = e4;
+                if (!r4) return function(t5, e5, n6) {
+                  const r5 = new Int32Array(n6);
+                  let i5 = 0, s3 = 0;
+                  for (let n7 = 0; n7 < e5; n7++) {
+                    const o3 = t5[n7], a3 = Mf2(t5[n7 + e5]);
+                    for (let t6 = 0; t6 < o3; t6++) s3 += a3, r5[i5++] = s3;
+                  }
+                  return r5;
+                }(t4, n5.runs, n5.numRleValues);
+                i4 = Df2(t4 = Ef2(t4, n5.runs, n5.numRleValues));
+              } else i4 = Df2(t4);
+              break;
+            case of2.RLE:
+              i4 = function(t5, e5, n5) {
+                if (void 0 === n5) {
+                  n5 = 0;
+                  for (let r6 = 0; r6 < e5; r6++) n5 += t5[r6];
+                }
+                const r5 = new Int32Array(n5);
+                let i5 = 0;
+                for (let n6 = 0; n6 < e5; n6++) {
+                  const s3 = t5[n6];
+                  let o3 = t5[n6 + e5];
+                  o3 = Mf2(o3), r5.fill(o3, i5, i5 + s3), i5 += s3;
+                }
+                return r5;
+              }(t4, e4.runs, e4.numRleValues);
+              break;
+            case of2.MORTON:
+              zf2(t4), i4 = new Int32Array(t4);
+              break;
+            case of2.COMPONENTWISE_DELTA:
+              i4 = function(t5) {
+                if (t5.length < 2) return new Int32Array(t5);
+                const e5 = new Int32Array(t5.length);
+                e5[0] = Mf2(t5[0]), e5[1] = Mf2(t5[1]);
+                const n5 = t5.length / 4 * 4;
+                let r5 = 2;
+                if (n5 >= 4) for (; r5 < n5 - 4; r5 += 4) {
+                  const n6 = t5[r5 + 1], i5 = t5[r5 + 2], s3 = t5[r5 + 3];
+                  e5[r5] = Mf2(t5[r5]) + e5[r5 - 2], e5[r5 + 1] = Mf2(n6) + e5[r5 - 1], e5[r5 + 2] = Mf2(i5) + e5[r5], e5[r5 + 3] = Mf2(s3) + e5[r5 + 1];
+                }
+                for (; r5 !== t5.length; r5 += 2) e5[r5] = Mf2(t5[r5]) + e5[r5 - 2], e5[r5 + 1] = Mf2(t5[r5 + 1]) + e5[r5 - 1];
+                return e5;
+              }(t4);
+              break;
+            case of2.NONE:
+              i4 = function(t5) {
+                const e5 = new Int32Array(t5.length);
+                for (let n5 = 0; n5 < t5.length; n5++) e5[n5] = Mf2(t5[n5]);
+                return e5;
+              }(t4);
+              break;
+            default:
+              throw new Error(`The specified Logical level technique is not supported: ${e4.logicalLevelTechnique1}`);
+          }
+          return r4 ? qf2(i4, r4, 0) : i4;
+        }(Zf2(t3, e3, n3), n3, 0, i3);
+      }
+      function Xf2(t3, e3, n3, r3, i3) {
+        return function(t4, e4, n4, r4) {
+          let i4;
+          switch (e4.logicalLevelTechnique1) {
+            case of2.DELTA:
+              i4 = function(t5) {
+                const e5 = new Uint32Array(t5.length);
+                e5[0] = Mf2(t5[0]) >>> 0;
+                for (let n5 = 1; n5 < t5.length; n5++) e5[n5] = e5[n5 - 1] + Mf2(t5[n5]) >>> 0;
+                return e5;
+              }(e4.logicalLevelTechnique2 === of2.RLE ? Ef2(t4, e4.runs, e4.numRleValues) : t4);
+              break;
+            case of2.RLE:
+              i4 = Ef2(t4, e4.runs, e4.numRleValues);
+              break;
+            case of2.MORTON:
+              zf2(t4), i4 = t4;
+              break;
+            case of2.COMPONENTWISE_DELTA:
+              i4 = function(t5) {
+                if (t5.length < 2) return new Uint32Array(t5);
+                const e5 = new Uint32Array(t5.length);
+                e5[0] = Mf2(t5[0]) >>> 0, e5[1] = Mf2(t5[1]) >>> 0;
+                for (let n5 = 2; n5 < t5.length; n5 += 2) e5[n5] = e5[n5 - 2] + Mf2(t5[n5]) >>> 0, e5[n5 + 1] = e5[n5 - 1] + Mf2(t5[n5 + 1]) >>> 0;
+                return e5;
+              }(t4);
+              break;
+            case of2.NONE:
+              i4 = t4;
+              break;
+            default:
+              throw new Error(`The specified Logical level technique is not supported: ${e4.logicalLevelTechnique1}`);
+          }
+          return r4 ? qf2(i4, r4, 0) : i4;
+        }(Zf2(t3, e3, n3), n3, 0, i3);
+      }
+      function Yf2(t3, e3, n3) {
+        return function(t4, e4) {
+          if (e4.logicalLevelTechnique1 === of2.DELTA && e4.logicalLevelTechnique2 === of2.NONE) return function(t5) {
+            const e5 = new Int32Array(t5.length + 1);
+            e5[0] = 0, e5[1] = Mf2(t5[0]);
+            let n4 = e5[1];
+            for (let r3 = 2; r3 !== e5.length; ++r3) n4 += Mf2(t5[r3 - 1]), e5[r3] = e5[r3 - 1] + n4;
+            return new Uint32Array(e5);
+          }(t4);
+          if (e4.logicalLevelTechnique1 === of2.RLE && e4.logicalLevelTechnique2 === of2.NONE) return function(t5, e5, n4) {
+            const r3 = new Uint32Array(n4 + 1);
+            r3[0] = 0;
+            let i3 = 1, s3 = r3[0];
+            for (let n5 = 0; n5 < e5; n5++) {
+              const o3 = t5[n5], a3 = t5[n5 + e5];
+              for (let t6 = i3; t6 < i3 + o3; t6++) r3[t6] = a3 + s3, s3 = r3[t6];
+              i3 += o3;
+            }
+            return r3;
+          }(t4, e4.runs, e4.numRleValues);
+          if (e4.logicalLevelTechnique1 === of2.NONE && e4.logicalLevelTechnique2 === of2.NONE) {
+            !function(t5) {
+              let e5 = 0;
+              for (let n5 = 0; n5 < t5.length; n5++) t5[n5] += e5, e5 = t5[n5];
+            }(t4);
+            const n4 = new Uint32Array(e4.numValues + 1);
+            return n4[0] = 0, n4.set(t4, 1), n4;
+          }
+          if (e4.logicalLevelTechnique1 === of2.DELTA && e4.logicalLevelTechnique2 === of2.RLE) {
+            const n4 = function(t5, e5, n5) {
+              const r3 = new Int32Array(n5 + 1);
+              r3[0] = 0;
+              let i3 = 1, s3 = r3[0];
+              for (let n6 = 0; n6 < e5; n6++) {
+                const o3 = t5[n6];
+                let a3 = t5[n6 + e5];
+                a3 = Mf2(a3);
+                for (let t6 = i3; t6 < i3 + o3; t6++) r3[t6] = a3 + s3, s3 = r3[t6];
+                i3 += o3;
+              }
+              return r3;
+            }(t4, e4.runs, e4.numRleValues);
+            return zf2(n4), new Uint32Array(n4);
+          }
+          throw new Error("Only delta encoding is supported for transforming length to offset streams yet.");
+        }(Zf2(t3, e3, n3), n3);
+      }
+      function Zf2(t3, e3, n3) {
+        const r3 = n3.physicalLevelTechnique;
+        switch (r3) {
+          case af2.FAST_PFOR:
+            return function(t4, e4, n4, r4) {
+              return function(t5, e5, n5, r5, i3) {
+                const s3 = r5.get();
+                if (3 & n5) throw new Error(`FastPFOR: invalid encodedByteLength=${n5} at offset=${s3} (encodedBytes.length=${t5.length}; expected a multiple of 4 bytes for an int32 big-endian word stream)`);
+                const o3 = n5 >>> 2, a3 = function(t6, e6) {
+                  if (e6 <= t6.encodedWords.length) return t6.encodedWords;
+                  const n6 = new Uint32Array(Math.max(16, 2 * e6));
+                  return t6.encodedWords = n6, n6;
+                }(i3, o3);
+                !function(t6, e6, n6, r6) {
+                  if (e6 < 0 || n6 < 0 || e6 + n6 > t6.length) throw new RangeError(`decodeBigEndianInt32sInto: out of bounds (offset=${e6}, byteLength=${n6}, bytes.length=${t6.length})`);
+                  const i4 = Math.floor(n6 / 4), s4 = n6 % 4 != 0, o4 = s4 ? i4 + 1 : i4;
+                  if (r6.length < o4) throw new RangeError(`decodeBigEndianInt32sInto: out.length=${r6.length} < ${o4}`);
+                  if (i4 > 0) {
+                    const n7 = t6.byteOffset + e6;
+                    if (3 & n7) for (let n8 = 0; n8 < i4; n8++) {
+                      const i5 = e6 + 4 * n8;
+                      r6[n8] = t6[i5] << 24 | t6[i5 + 1] << 16 | t6[i5 + 2] << 8 | t6[i5 + 3];
+                    }
+                    else {
+                      const e7 = new Uint32Array(t6.buffer, n7, i4);
+                      for (let t7 = 0; t7 < i4; t7++) r6[t7] = 0 | pf2(e7[t7]);
+                    }
+                  }
+                  if (s4) {
+                    const s5 = e6 + 4 * i4, o5 = n6 - 4 * i4;
+                    let a4 = 0;
+                    for (let e7 = 0; e7 < o5; e7++) a4 |= t6[s5 + e7] << 24 - 8 * e7;
+                    r6[i4] = 0 | a4;
+                  }
+                }(t5, s3, n5, a3);
+                const l3 = function(t6, e6, n6) {
+                  let r6 = 0, i4 = 0;
+                  const s4 = new Uint32Array(e6), o4 = n6 ?? yf2();
+                  if (t6.length > 0) {
+                    const e7 = 0 | t6[r6];
+                    if (r6 = r6 + 1 | 0, 255 & e7) throw new Error(`FastPFOR decode: invalid alignedLength=${e7} (expected multiple of 256)`);
+                    if (i4 + e7 > s4.length) throw new Error(`FastPFOR decode: output buffer too small (outPos=${i4}, alignedLength=${e7}, out.length=${s4.length})`);
+                    r6 = function(t7, e8, n7, r7, i5, s5) {
+                      const o5 = r7 + hf(i5, cf2);
+                      let a4 = r7, l4 = n7;
+                      for (; a4 !== o5; ) {
+                        const n8 = Math.min(ff2, o5 - a4);
+                        l4 = vf2(t7, e8, l4, a4, n8, s5), a4 = a4 + n8 | 0;
+                      }
+                      return l4;
+                    }(t6, s4, r6, i4, e7, o4), i4 = i4 + e7 | 0;
+                  }
+                  return function(t7, e7, n7, r7, i5, s5) {
+                    if (0 === s5) return e7;
+                    let o5 = 0, a4 = e7;
+                    const l4 = e7 + n7, u3 = i5;
+                    let c3 = i5;
+                    const h3 = i5 + s5;
+                    let p3 = 0, f3 = 0;
+                    for (; a4 < l4 && c3 < h3; ) {
+                      const e8 = t7[a4] >>> o5 & 255;
+                      if (o5 += 8, a4 += o5 >>> 5, o5 &= 31, p3 |= (127 & e8) << f3, 128 & e8) r7[c3++] = 0 | p3, p3 = 0, f3 = 0;
+                      else if (f3 += 7, f3 > 28) throw new Error(`FastPFOR VByte: unterminated value (expected MSB=1 terminator within 5 bytes; shift=${f3}, partial=${p3}, decoded=${c3 - u3}/${s5}, inPos=${a4}, inEnd=${l4})`);
+                    }
+                    if (c3 !== h3) throw new Error(`FastPFOR VByte: truncated stream (decoded=${c3 - u3}, expected=${s5}, consumedWords=${a4 - e7}/${n7}, vbyteStart=${e7}, vbyteEnd=${l4})`);
+                  }(t6, r6, t6.length - r6 | 0, s4, i4, e6 - i4 | 0), s4;
+                }(a3.subarray(0, o3), e5, i3.decoderWorkspace);
+                return r5.add(n5), l3;
+              }(t4, e4, n4, r4, function(t5 = 16) {
+                if (t5 < 0) throw new RangeError(`initialEncodedWordCapacity must be >= 0, got ${t5}`);
+                const e5 = Math.max(16, 0 | t5);
+                return { encodedWords: new Uint32Array(e5), decoderWorkspace: yf2() };
+              }(n4 >>> 2));
+            }(t3, n3.numValues, n3.byteLength, e3);
+          case af2.VARINT:
+            return wf2(t3, e3, n3.numValues);
+          case af2.NONE: {
+            const r4 = e3.get();
+            e3.add(n3.byteLength);
+            const i3 = t3.subarray(r4, e3.get());
+            return new Uint32Array(i3);
+          }
+          default:
+            throw new Error(`Specified physicalLevelTechnique ${r3} is not supported (yet).`);
+        }
+      }
+      function Hf2(t3, e3, n3) {
+        const r3 = Zf2(t3, e3, n3);
+        return 1 === r3.length ? r3[0] : function(t4) {
+          return t4[1];
+        }(r3);
+      }
+      function Wf2(t3, e3, n3) {
+        return function(t4) {
+          if (2 === t4.length) {
+            const e4 = Mf2(t4[1]);
+            return [e4, e4];
+          }
+          return [Mf2(t4[2]), Mf2(t4[3])];
+        }(Zf2(t3, e3, n3));
+      }
+      function Kf2(t3, e3, n3) {
+        return function(t4) {
+          if (2 === t4.length) {
+            const e4 = kf(t4[1]);
+            return [e4, e4];
+          }
+          return [kf(t4[2]), kf(t4[3])];
+        }(_f2(t3, e3, n3.numValues));
+      }
+      function Jf2(t3, e3, n3, r3) {
+        return function(t4, e4, n4) {
+          let r4;
+          switch (e4.logicalLevelTechnique1) {
+            case of2.DELTA:
+              r4 = function(t5) {
+                const e5 = new BigUint64Array(t5.length);
+                e5[0] = BigInt.asUintN(64, kf(t5[0]));
+                for (let n5 = 1; n5 < t5.length; n5++) e5[n5] = BigInt.asUintN(64, e5[n5 - 1] + kf(t5[n5]));
+                return e5;
+              }(e4.logicalLevelTechnique2 === of2.RLE ? Tf2(t4, e4.runs, e4.numRleValues) : t4);
+              break;
+            case of2.RLE:
+              r4 = Tf2(t4, e4.runs, e4.numRleValues);
+              break;
+            case of2.NONE:
+              r4 = t4;
+              break;
+            default:
+              throw new Error(`The specified Logical level technique is not supported: ${e4.logicalLevelTechnique1}`);
+          }
+          return n4 ? qf2(r4, n4, 0n) : r4;
+        }(_f2(t3, e3, n3.numValues), n3, r3);
+      }
+      function Qf2(t3, e3, n3) {
+        const r3 = _f2(t3, e3, n3.numValues);
+        return 1 === r3.length ? r3[0] : function(t4) {
+          return t4[1];
+        }(r3);
+      }
+      function td2(t3, e3, n3, r3, i3 = "int32") {
+        const s3 = t3.logicalLevelTechnique1;
+        if (s3 === of2.RLE) return 1 === t3.runs ? Of2.CONST : Of2.FLAT;
+        if (s3 !== of2.DELTA || t3.logicalLevelTechnique2 !== of2.RLE) return 1 === t3.numValues ? Of2.CONST : Of2.FLAT;
+        const o3 = e3 instanceof jf ? e3.size() : e3;
+        if (t3.numRleValues !== o3) return Of2.FLAT;
+        if (1 === t3.runs) return Of2.SEQUENCE;
+        if (2 !== t3.runs) return 1 === t3.numValues ? Of2.CONST : Of2.FLAT;
+        const a3 = r3.get();
+        if (t3.physicalLevelTechnique === af2.VARINT) return function(t4, e4, n4) {
+          const r4 = new sf2(e4.get());
+          if ("int64" === n4) {
+            const e5 = _f2(t4, r4, 4);
+            return 2n === e5[2] && 2n === e5[3];
+          }
+          const i4 = wf2(t4, r4, 4);
+          return 2 === i4[2] && 2 === i4[3];
+        }(n3, r3, i3) ? Of2.SEQUENCE : 1 === t3.numValues ? Of2.CONST : Of2.FLAT;
+        const l3 = r3.get(), u3 = new Int32Array(n3.buffer, n3.byteOffset + l3, 4);
+        return r3.set(a3), 2 === u3[2] && 2 === u3[3] ? Of2.SEQUENCE : 1 === t3.numValues ? Of2.CONST : Of2.FLAT;
+      }
+      class ed2 extends Kp {
+        getValueFromBuffer(t3) {
+          return this.dataBuffer[t3];
+        }
+      }
+      class nd2 extends tf2 {
+        constructor(t3, e3, n3, r3) {
+          super(t3, BigInt64Array.of(e3), n3, r3);
+        }
+        getValueFromBuffer(t3) {
+          return this.dataBuffer[0] + BigInt(t3) * this.delta;
+        }
+      }
+      function rd2(t3, e3, n3) {
+        return { x: id2(t3, e3) - n3, y: id2(t3 >> 1, e3) - n3 };
+      }
+      function id2(t3, e3) {
+        let n3 = 0;
+        for (let r3 = 0; r3 < e3; r3++) n3 |= (t3 & 1 << 2 * r3) >> r3;
+        return n3;
+      }
+      function sd2(t3, e3, r3, i3, s3, o3, a3) {
+        return t3 === Nf2.MORTON ? function(t4, e4, r4, i4, s4, o4) {
+          const a4 = new Array(s4 ? i4 + 1 : i4);
+          for (let s5 = 0; s5 < i4; s5++) {
+            const i5 = rd2(t4[e4[r4 + s5]], o4.numBits, o4.coordinateShift);
+            a4[s5] = new n2(i5.x, i5.y);
+          }
+          return s4 && (a4[a4.length - 1] = a4[0]), a4;
+        }(e3, r3, i3, s3, o3, a3) : function(t4, e4, r4, i4, s4) {
+          const o4 = new Array(s4 ? i4 + 1 : i4);
+          for (let s5 = 0; s5 < 2 * i4; s5 += 2) {
+            const i5 = 2 * e4[r4 + s5 / 2];
+            o4[s5 / 2] = new n2(t4[i5], t4[i5 + 1]);
+          }
+          return s4 && (o4[o4.length - 1] = o4[0]), o4;
+        }(e3, r3, i3, s3, o3);
+      }
+      function od2(t3, e3, r3, i3) {
+        const s3 = new Array(i3 ? r3 + 1 : r3);
+        for (let i4 = 0; i4 < 2 * r3; i4 += 2) s3[i4 / 2] = new n2(t3[e3 + i4], t3[e3 + i4 + 1]);
+        return i3 && (s3[s3.length - 1] = s3[0]), s3;
+      }
+      !function(t3) {
+        t3[t3.POINT = 0] = "POINT", t3[t3.LINESTRING = 1] = "LINESTRING", t3[t3.POLYGON = 2] = "POLYGON", t3[t3.MULTIPOINT = 3] = "MULTIPOINT", t3[t3.MULTILINESTRING = 4] = "MULTILINESTRING", t3[t3.MULTIPOLYGON = 5] = "MULTIPOLYGON";
+      }($f2 || ($f2 = {})), function(t3) {
+        t3[t3.POINT = 0] = "POINT", t3[t3.LINESTRING = 1] = "LINESTRING", t3[t3.POLYGON = 2] = "POLYGON";
+      }(Rf2 || (Rf2 = {})), function(t3) {
+        t3[t3.MORTON = 0] = "MORTON", t3[t3.VEC_2 = 1] = "VEC_2", t3[t3.VEC_3 = 2] = "VEC_3";
+      }(Nf2 || (Nf2 = {}));
+      class ad2 {
+        constructor(t3, e3, n3, r3, i3) {
+          this._vertexBufferType = t3, this._topologyVector = e3, this._vertexOffsets = n3, this._vertexBuffer = r3, this._mortonSettings = i3;
+        }
+        get vertexBufferType() {
+          return this._vertexBufferType;
+        }
+        get topologyVector() {
+          return this._topologyVector;
+        }
+        get vertexOffsets() {
+          return this._vertexOffsets;
+        }
+        get vertexBuffer() {
+          return this._vertexBuffer;
+        }
+        getSimpleEncodedVertex(t3) {
+          const e3 = this.vertexOffsets ? 2 * this.vertexOffsets[t3] : 2 * t3;
+          return [this.vertexBuffer[e3], this.vertexBuffer[e3 + 1]];
+        }
+        getVertex(t3) {
+          if (this.vertexOffsets && this.mortonSettings) {
+            const e4 = rd2(this.vertexBuffer[this.vertexOffsets[t3]], this.mortonSettings.numBits, this.mortonSettings.coordinateShift);
+            return [e4.x, e4.y];
+          }
+          const e3 = this.vertexOffsets ? 2 * this.vertexOffsets[t3] : 2 * t3;
+          return [this.vertexBuffer[e3], this.vertexBuffer[e3 + 1]];
+        }
+        getGeometries() {
+          return function(t3) {
+            const e3 = new Array(t3.numGeometries);
+            let r3 = 1, i3 = 1, s3 = 1, o3 = 0, a3 = 0, l3 = 0;
+            const u3 = t3.mortonSettings, c3 = t3.topologyVector, h3 = c3.geometryOffsets, p3 = c3.partOffsets, f3 = c3.ringOffsets, d3 = t3.vertexOffsets, y3 = !d3 || 0 === d3.length, m3 = t3.containsPolygonGeometry(), g3 = t3.vertexBuffer;
+            for (let c4 = 0; c4 < t3.numGeometries; c4++) switch (t3.geometryType(c4)) {
+              case $f2.POINT:
+                {
+                  let c5, m4;
+                  if (y3) c5 = g3[a3++], m4 = g3[a3++];
+                  else if (t3.vertexBufferType === Nf2.MORTON) {
+                    const t4 = rd2(g3[d3[l3++]], u3.numBits, u3.coordinateShift);
+                    c5 = t4.x, m4 = t4.y;
+                  } else {
+                    const t4 = 2 * d3[l3++];
+                    c5 = g3[t4], m4 = g3[t4 + 1];
+                  }
+                  e3[o3++] = [[new n2(c5, m4)]], h3 && s3++, p3 && r3++, f3 && i3++;
+                }
+                break;
+              case $f2.MULTIPOINT:
+                {
+                  const t4 = h3[s3] - h3[s3 - 1];
+                  s3++;
+                  const u4 = new Array(t4);
+                  if (y3) for (let e4 = 0; e4 < t4; e4++) {
+                    const t5 = g3[a3++], r4 = g3[a3++];
+                    u4[e4] = new n2(t5, r4);
+                  }
+                  else for (let e4 = 0; e4 < t4; e4++) {
+                    const t5 = 2 * d3[l3++];
+                    u4[e4] = new n2(g3[t5], g3[t5 + 1]);
+                  }
+                  e3[o3++] = u4.map((t5) => [t5]), r3 += t4, i3 += t4;
+                }
+                break;
+              case $f2.LINESTRING:
+                {
+                  let n3, c5;
+                  m3 ? (n3 = f3[i3] - f3[i3 - 1], i3++) : n3 = p3[r3] - p3[r3 - 1], r3++, y3 ? (c5 = od2(g3, a3, n3, false), a3 += 2 * n3) : (c5 = sd2(t3.vertexBufferType, g3, d3, l3, n3, false, u3), l3 += n3), e3[o3++] = [c5], h3 && s3++;
+                }
+                break;
+              case $f2.POLYGON:
+                {
+                  const n3 = p3[r3] - p3[r3 - 1];
+                  r3++;
+                  const c5 = new Array(n3 - 1);
+                  let m4, x3 = f3[i3] - f3[i3 - 1];
+                  if (i3++, y3) {
+                    m4 = od2(g3, a3, x3, true), a3 += 2 * x3;
+                    for (let t4 = 0; t4 < c5.length; t4++) x3 = f3[i3] - f3[i3 - 1], i3++, c5[t4] = od2(g3, a3, x3, true), a3 += 2 * x3;
+                  } else {
+                    m4 = sd2(t3.vertexBufferType, g3, d3, l3, x3, true, u3), l3 += x3;
+                    for (let e4 = 0; e4 < c5.length; e4++) x3 = f3[i3] - f3[i3 - 1], i3++, c5[e4] = sd2(t3.vertexBufferType, g3, d3, l3, x3, true, u3), l3 += x3;
+                  }
+                  e3[o3++] = [m4].concat(c5), h3 && s3++;
+                }
+                break;
+              case $f2.MULTILINESTRING:
+                {
+                  const n3 = h3[s3] - h3[s3 - 1];
+                  s3++;
+                  const c5 = new Array(n3);
+                  for (let e4 = 0; e4 < n3; e4++) {
+                    let n4;
+                    if (m3 ? (n4 = f3[i3] - f3[i3 - 1], i3++) : n4 = p3[r3] - p3[r3 - 1], r3++, y3) c5[e4] = od2(g3, a3, n4, false), a3 += 2 * n4;
+                    else {
+                      const r4 = sd2(t3.vertexBufferType, g3, d3, l3, n4, false, u3);
+                      c5[e4] = r4, l3 += n4;
+                    }
+                  }
+                  e3[o3++] = c5;
+                }
+                break;
+              case $f2.MULTIPOLYGON:
+                {
+                  const n3 = h3[s3] - h3[s3 - 1];
+                  s3++;
+                  const c5 = new Array(n3);
+                  for (let e4 = 0; e4 < n3; e4++) {
+                    const n4 = p3[r3] - p3[r3 - 1];
+                    let s4;
+                    r3++;
+                    const o4 = new Array(n4 - 1), h4 = f3[i3] - f3[i3 - 1];
+                    i3++, y3 ? (s4 = od2(g3, a3, h4, true), a3 += 2 * h4) : (s4 = sd2(t3.vertexBufferType, g3, d3, l3, h4, true, u3), l3 += h4);
+                    for (let e5 = 0; e5 < o4.length; e5++) {
+                      const n5 = f3[i3] - f3[i3 - 1];
+                      i3++, y3 ? (o4[e5] = od2(g3, a3, n5, true), a3 += 2 * n5) : (o4[e5] = sd2(t3.vertexBufferType, g3, d3, l3, n5, true, u3), l3 += n5);
+                    }
+                    c5[e4] = [s4].concat(o4);
+                  }
+                  e3[o3++] = c5.flat();
+                }
+                break;
+              default:
+                throw new Error("The specified geometry type is currently not supported.");
+            }
+            return e3;
+          }(this);
+        }
+        get mortonSettings() {
+          return this._mortonSettings;
+        }
+      }
+      class ld2 extends ad2 {
+        constructor(t3, e3, n3, r3, i3, s3, o3) {
+          super(n3, r3, i3, s3, o3), this._numGeometries = t3, this._geometryType = e3;
+        }
+        geometryType(t3) {
+          return this._geometryType;
+        }
+        get numGeometries() {
+          return this._numGeometries;
+        }
+        containsPolygonGeometry() {
+          return this._geometryType === $f2.POLYGON || this._geometryType === $f2.MULTIPOLYGON;
+        }
+        containsSingleGeometryType() {
+          return true;
+        }
+      }
+      class ud2 extends ad2 {
+        constructor(t3, e3, n3, r3, i3, s3) {
+          super(t3, n3, r3, i3, s3), this._geometryTypes = e3;
+        }
+        geometryType(t3) {
+          return this._geometryTypes[t3];
+        }
+        get numGeometries() {
+          return this._geometryTypes.length;
+        }
+        containsPolygonGeometry() {
+          for (let t3 = 0; t3 < this.numGeometries; t3++) if (this.geometryType(t3) === $f2.POLYGON || this.geometryType(t3) === $f2.MULTIPOLYGON) return true;
+          return false;
+        }
+        containsSingleGeometryType() {
+          return false;
+        }
+      }
+      class cd2 {
+        constructor(t3, e3, n3, r3) {
+          this._triangleOffsets = t3, this._indexBuffer = e3, this._vertexBuffer = n3, this._topologyVector = r3;
+        }
+        get triangleOffsets() {
+          return this._triangleOffsets;
+        }
+        get indexBuffer() {
+          return this._indexBuffer;
+        }
+        get vertexBuffer() {
+          return this._vertexBuffer;
+        }
+        get topologyVector() {
+          return this._topologyVector;
+        }
+        getGeometries() {
+          if (!this._topologyVector) throw new Error("Cannot convert GpuVector to coordinates without topology information");
+          const t3 = new Array(this.numGeometries), e3 = this._topologyVector, r3 = e3.partOffsets, i3 = e3.ringOffsets, s3 = e3.geometryOffsets;
+          let o3 = 0, a3 = 1, l3 = 1, u3 = 1;
+          for (let e4 = 0; e4 < this.numGeometries; e4++) switch (this.geometryType(e4)) {
+            case $f2.POLYGON:
+              {
+                const c3 = r3[a3] - r3[a3 - 1];
+                a3++;
+                const h3 = [];
+                for (let t4 = 0; t4 < c3; t4++) {
+                  const t5 = i3[l3] - i3[l3 - 1];
+                  l3++;
+                  const e5 = [];
+                  for (let r4 = 0; r4 < t5; r4++) {
+                    const t6 = this._vertexBuffer[o3++], r5 = this._vertexBuffer[o3++];
+                    e5.push(new n2(t6, r5));
+                  }
+                  e5.length > 0 && e5.push(e5[0]), h3.push(e5);
+                }
+                t3[e4] = h3, s3 && u3++;
+              }
+              break;
+            case $f2.MULTIPOLYGON: {
+              const c3 = s3[u3] - s3[u3 - 1];
+              u3++;
+              const h3 = [];
+              for (let t4 = 0; t4 < c3; t4++) {
+                const t5 = r3[a3] - r3[a3 - 1];
+                a3++;
+                for (let e5 = 0; e5 < t5; e5++) {
+                  const t6 = i3[l3] - i3[l3 - 1];
+                  l3++;
+                  const e6 = [];
+                  for (let r4 = 0; r4 < t6; r4++) {
+                    const t7 = this._vertexBuffer[o3++], r5 = this._vertexBuffer[o3++];
+                    e6.push(new n2(t7, r5));
+                  }
+                  e6.length > 0 && e6.push(e6[0]), h3.push(e6);
+                }
+              }
+              t3[e4] = h3;
+            }
+          }
+          return t3;
+        }
+        [Symbol.iterator]() {
+          return null;
+        }
+      }
+      function hd2(t3, e3, n3, r3, i3, s3) {
+        return new pd2(t3, e3, n3, r3, i3, s3);
+      }
+      class pd2 extends cd2 {
+        constructor(t3, e3, n3, r3, i3, s3) {
+          super(n3, r3, i3, s3), this._numGeometries = t3, this._geometryType = e3;
+        }
+        geometryType(t3) {
+          return this._geometryType;
+        }
+        get numGeometries() {
+          return this._numGeometries;
+        }
+        containsSingleGeometryType() {
+          return true;
+        }
+      }
+      function fd2(t3, e3, n3, r3, i3) {
+        return new dd2(t3, e3, n3, r3, i3);
+      }
+      class dd2 extends cd2 {
+        constructor(t3, e3, n3, r3, i3) {
+          super(e3, n3, r3, i3), this._geometryTypes = t3;
+        }
+        geometryType(t3) {
+          return this._geometryTypes[t3];
+        }
+        get numGeometries() {
+          return this._geometryTypes.length;
+        }
+        containsSingleGeometryType() {
+          return false;
+        }
+      }
+      function yd2(t3, e3, n3, r3, i3) {
+        const s3 = Uf2(t3, n3);
+        let o3, a3, l3, u3;
+        if (td2(s3, r3, t3, n3) === Of2.CONST) {
+          const i4 = Hf2(t3, n3, s3);
+          let c4, h4, p4, f4;
+          for (let r4 = 0; r4 < e3 - 1; r4++) {
+            const e4 = Uf2(t3, n3);
+            switch (e4.physicalStreamType) {
+              case Bf2.LENGTH:
+                switch (e4.logicalStreamType.lengthType) {
+                  case Lf2.GEOMETRIES:
+                    c4 = Yf2(t3, n3, e4);
+                    break;
+                  case Lf2.PARTS:
+                    h4 = Yf2(t3, n3, e4);
+                    break;
+                  case Lf2.RINGS:
+                    p4 = Yf2(t3, n3, e4);
+                    break;
+                  case Lf2.TRIANGLES:
+                    f4 = Yf2(t3, n3, e4);
+                }
+                break;
+              case Bf2.OFFSET:
+                switch (e4.logicalStreamType.offsetType) {
+                  case Vf2.VERTEX:
+                    o3 = Xf2(t3, n3, e4);
+                    break;
+                  case Vf2.INDEX:
+                    u3 = Xf2(t3, n3, e4);
+                }
+                break;
+              case Bf2.DATA:
+                Cf2.VERTEX === e4.logicalStreamType.dictionaryType ? a3 = Gf2(t3, n3, e4) : (l3 = { numBits: e4.numBits, coordinateShift: e4.coordinateShift }, a3 = Xf2(t3, n3, e4));
+            }
+          }
+          return u3 ? void 0 !== c4 || void 0 !== h4 ? hd2(r3, i4, f4, u3, a3, { geometryOffsets: c4, partOffsets: h4, ringOffsets: p4 }) : hd2(r3, i4, f4, u3, a3) : void 0 === l3 ? function(t4, e4, n4, r4, i5) {
+            return new ld2(t4, e4, Nf2.VEC_2, n4, r4, i5);
+          }(r3, i4, { geometryOffsets: c4, partOffsets: h4, ringOffsets: p4 }, o3, a3) : function(t4, e4, n4, r4, i5, s4) {
+            return new ld2(t4, e4, Nf2.MORTON, n4, r4, i5, s4);
+          }(r3, i4, { geometryOffsets: c4, partOffsets: h4, ringOffsets: p4 }, o3, a3, l3);
+        }
+        const c3 = Xf2(t3, n3, s3);
+        let h3, p3, f3, d3, y3, m3, g3;
+        for (let r4 = 0; r4 < e3 - 1; r4++) {
+          const e4 = Uf2(t3, n3);
+          switch (e4.physicalStreamType) {
+            case Bf2.LENGTH:
+              switch (e4.logicalStreamType.lengthType) {
+                case Lf2.GEOMETRIES:
+                  h3 = Xf2(t3, n3, e4);
+                  break;
+                case Lf2.PARTS:
+                  p3 = Xf2(t3, n3, e4);
+                  break;
+                case Lf2.RINGS:
+                  f3 = Xf2(t3, n3, e4);
+                  break;
+                case Lf2.TRIANGLES:
+                  d3 = Yf2(t3, n3, e4);
+              }
+              break;
+            case Bf2.OFFSET:
+              switch (e4.logicalStreamType.offsetType) {
+                case Vf2.VERTEX:
+                  o3 = Xf2(t3, n3, e4);
+                  break;
+                case Vf2.INDEX:
+                  u3 = Xf2(t3, n3, e4);
+              }
+              break;
+            case Bf2.DATA:
+              Cf2.VERTEX === e4.logicalStreamType.dictionaryType ? a3 = Gf2(t3, n3, e4) : (l3 = { numBits: e4.numBits, coordinateShift: e4.coordinateShift }, a3 = Xf2(t3, n3, e4));
+          }
+        }
+        return h3 ? (y3 = md2(c3, h3, 2), p3 && f3 ? (m3 = gd2(c3, y3, p3, false), g3 = function(t4, e4, n4, r4) {
+          const i4 = new Uint32Array(n4[n4.length - 1] + 1);
+          let s4 = 0;
+          i4[0] = s4;
+          let o4 = 1, a4 = 1, l4 = 0;
+          for (let u4 = 0; u4 < t4.length; u4++) {
+            const c4 = t4[u4], h4 = e4[u4 + 1] - e4[u4];
+            if (0 !== c4 && 3 !== c4) for (let t5 = 0; t5 < h4; t5++) {
+              const t6 = n4[o4] - n4[o4 - 1];
+              o4++;
+              for (let e5 = 0; e5 < t6; e5++) s4 = i4[a4++] = s4 + r4[l4++];
+            }
+            else for (let t5 = 0; t5 < h4; t5++) i4[a4++] = ++s4, o4++;
+          }
+          return i4;
+        }(c3, y3, m3, f3)) : p3 && (m3 = function(t4, e4, n4) {
+          const r4 = new Uint32Array(e4[e4.length - 1] + 1);
+          let i4 = 0;
+          r4[0] = i4;
+          let s4 = 1, o4 = 0;
+          for (let a4 = 0; a4 < t4.length; a4++) {
+            const l4 = t4[a4], u4 = e4[a4 + 1] - e4[a4];
+            if (4 === l4 || 1 === l4) for (let t5 = 0; t5 < u4; t5++) i4 = r4[s4++] = i4 + n4[o4++];
+            else for (let t5 = 0; t5 < u4; t5++) r4[s4++] = ++i4;
+          }
+          return r4;
+        }(c3, y3, p3))) : p3 && f3 ? (m3 = md2(c3, p3, 1), g3 = gd2(c3, m3, f3, true)) : p3 && (m3 = md2(c3, p3, 0)), u3 && !m3 ? fd2(c3, d3, u3, a3) : u3 ? fd2(c3, d3, u3, a3, { geometryOffsets: y3, partOffsets: m3, ringOffsets: g3 }) : void 0 === l3 ? function(t4, e4, n4, r4) {
+          return new ud2(Nf2.VEC_2, t4, e4, n4, r4);
+        }(c3, { geometryOffsets: y3, partOffsets: m3, ringOffsets: g3 }, o3, a3) : function(t4, e4, n4, r4, i4) {
+          return new ud2(Nf2.MORTON, t4, e4, n4, r4, i4);
+        }(c3, { geometryOffsets: y3, partOffsets: m3, ringOffsets: g3 }, o3, a3, l3);
+      }
+      function md2(t3, e3, n3) {
+        const r3 = new Uint32Array(t3.length + 1);
+        let i3 = 0;
+        r3[0] = i3;
+        let s3 = 0;
+        for (let o3 = 0; o3 < t3.length; o3++) i3 = r3[o3 + 1] = i3 + (t3[o3] > n3 ? e3[s3++] : 1);
+        return r3;
+      }
+      function gd2(t3, e3, n3, r3) {
+        const i3 = new Uint32Array(e3[e3.length - 1] + 1);
+        let s3 = 0;
+        i3[0] = s3;
+        let o3 = 1, a3 = 0;
+        for (let l3 = 0; l3 < t3.length; l3++) {
+          const u3 = t3[l3], c3 = e3[l3 + 1] - e3[l3];
+          if (5 === u3 || 2 === u3 || r3 && (4 === u3 || 1 === u3)) for (let t4 = 0; t4 < c3; t4++) s3 = i3[o3++] = s3 + n3[a3++];
+          else for (let t4 = 0; t4 < c3; t4++) i3[o3++] = ++s3;
+        }
+        return i3;
+      }
+      class xd2 extends Wp {
+        constructor(t3, e3, n3) {
+          super(t3, e3.getBuffer(), n3), this.dataVector = e3;
+        }
+        getValueFromBuffer(t3) {
+          return this.dataVector.get(t3);
+        }
+      }
+      class vd2 extends Kp {
+        getValueFromBuffer(t3) {
+          return this.dataBuffer[t3];
+        }
+      }
+      class bd2 extends Wp {
+        constructor(t3, e3, n3, r3) {
+          super(t3, r3 ? BigInt64Array.of(e3) : BigUint64Array.of(e3), n3);
+        }
+        getValueFromBuffer(t3) {
+          return this.dataBuffer[0];
+        }
+      }
+      function wd2(t3, e3, n3, r3, i3) {
+        const s3 = function(t4, e4, n4, r4) {
+          const i4 = new Uint8Array(e4);
+          let s4 = 0;
+          const o3 = r4.get() + n4;
+          for (; s4 < e4 && !(r4.get() >= o3); ) {
+            const n5 = t4[r4.increment()];
+            if (n5 <= 127) {
+              const o4 = n5 + 3, a3 = t4[r4.increment()], l3 = Math.min(s4 + o4, e4);
+              i4.fill(a3, s4, l3), s4 = l3;
+            } else {
+              const o4 = 256 - n5;
+              for (let n6 = 0; n6 < o4 && s4 < e4; n6++) i4[s4++] = t4[r4.increment()];
+            }
+          }
+          return r4.set(o3), i4;
+        }(t3, Math.ceil(e3 / 8), n3, r3);
+        return i3 ? function(t4, e4, n4) {
+          if (!n4) return t4;
+          const r4 = n4.size(), i4 = new jf(t4, e4), s4 = new jf(new Uint8Array(Math.ceil(r4 / 8)), r4);
+          let o3 = 0;
+          for (let t5 = 0; t5 < r4; t5++) {
+            const e5 = !!n4.get(t5) && i4.get(o3++);
+            s4.set(t5, e5);
+          }
+          return s4.getBuffer();
+        }(s3, e3, i3) : s3;
+      }
+      const _d2 = new TextDecoder();
+      function Sd2(t3, e3, n3) {
+        return n3 - e3 >= 12 ? _d2.decode(t3.subarray(e3, n3)) : function(t4, e4, n4) {
+          let r3 = "", i3 = e4;
+          for (; i3 < n4; ) {
+            const e5 = t4[i3];
+            let s3, o3, a3, l3 = null, u3 = e5 > 239 ? 4 : e5 > 223 ? 3 : e5 > 191 ? 2 : 1;
+            if (i3 + u3 > n4) break;
+            1 === u3 ? e5 < 128 && (l3 = e5) : 2 === u3 ? (s3 = t4[i3 + 1], 128 == (192 & s3) && (l3 = (31 & e5) << 6 | 63 & s3, l3 <= 127 && (l3 = null))) : 3 === u3 ? (s3 = t4[i3 + 1], o3 = t4[i3 + 2], 128 == (192 & s3) && 128 == (192 & o3) && (l3 = (15 & e5) << 12 | (63 & s3) << 6 | 63 & o3, (l3 <= 2047 || l3 >= 55296 && l3 <= 57343) && (l3 = null))) : 4 === u3 && (s3 = t4[i3 + 1], o3 = t4[i3 + 2], a3 = t4[i3 + 3], 128 == (192 & s3) && 128 == (192 & o3) && 128 == (192 & a3) && (l3 = (15 & e5) << 18 | (63 & s3) << 12 | (63 & o3) << 6 | 63 & a3, (l3 <= 65535 || l3 >= 1114112) && (l3 = null))), null === l3 ? (l3 = 65533, u3 = 1) : l3 > 65535 && (l3 -= 65536, r3 += String.fromCharCode(l3 >>> 10 & 1023 | 55296), l3 = 56320 | 1023 & l3), r3 += String.fromCharCode(l3), i3 += u3;
+          }
+          return r3;
+        }(t3, e3, n3);
+      }
+      class Ad2 extends Wp {
+        constructor(t3, e3, n3, r3) {
+          super(t3, n3, r3), this.offsetBuffer = e3;
+        }
+      }
+      class Md2 extends Ad2 {
+        constructor(t3, e3, n3, r3) {
+          super(t3, e3, n3, r3 ?? e3.length - 1);
+        }
+        getValueFromBuffer(t3) {
+          return Sd2(this.dataBuffer, this.offsetBuffer[t3], this.offsetBuffer[t3 + 1]);
+        }
+      }
+      class kd2 extends Ad2 {
+        constructor(t3, e3, n3, r3, i3) {
+          super(t3, n3, r3, i3 ?? e3.length), this.indexBuffer = e3, this.indexBuffer = e3;
+        }
+        getValueFromBuffer(t3) {
+          const e3 = this.indexBuffer[t3];
+          return Sd2(this.dataBuffer, this.offsetBuffer[e3], this.offsetBuffer[e3 + 1]);
+        }
+      }
+      class Id2 extends Ad2 {
+        constructor(t3, e3, n3, r3, i3, s3, o3) {
+          super(t3, n3, r3, o3), this.indexBuffer = e3, this.symbolOffsetBuffer = i3, this.symbolTableBuffer = s3;
+        }
+        getValueFromBuffer(t3) {
+          null == this.decodedDictionary && (null == this.symbolLengthBuffer && (this.symbolLengthBuffer = this.offsetToLengthBuffer(this.symbolOffsetBuffer)), this.decodedDictionary = function(t4, e4, n3) {
+            const r3 = [], i3 = new Array(e4.length).fill(0);
+            for (let t5 = 1; t5 < e4.length; t5++) i3[t5] = i3[t5 - 1] + e4[t5 - 1];
+            for (let s3 = 0; s3 < n3.length; s3++) if (255 === n3[s3]) r3.push(n3[++s3]);
+            else {
+              const o3 = e4[n3[s3]], a3 = i3[n3[s3]];
+              for (let e5 = 0; e5 < o3; e5++) r3.push(t4[a3 + e5]);
+            }
+            return new Uint8Array(r3);
+          }(this.symbolTableBuffer, this.symbolLengthBuffer, this.dataBuffer));
+          const e3 = this.indexBuffer[t3];
+          return Sd2(this.decodedDictionary, this.offsetBuffer[e3], this.offsetBuffer[e3 + 1]);
+        }
+        offsetToLengthBuffer(t3) {
+          const e3 = new Uint32Array(t3.length - 1);
+          let n3 = t3[0];
+          for (let r3 = 1; r3 < t3.length; r3++) {
+            const i3 = t3[r3];
+            e3[r3 - 1] = i3 - n3, n3 = i3;
+          }
+          return e3;
+        }
+      }
+      function Ed2(t3, e3, n3, r3, i3, s3) {
+        return "scalarType" === n3.type ? function(t4, e4, n4, r4, i4, s4) {
+          let o3 = null;
+          if (0 === t4) return null;
+          if (s4.nullable) {
+            const t5 = Uf2(e4, n4), r5 = t5.numValues, i5 = n4.get(), s5 = wd2(e4, r5, t5.byteLength, n4);
+            n4.set(i5 + t5.byteLength), o3 = new jf(s5, t5.numValues);
+          }
+          const a3 = o3 ?? r4;
+          switch (i4.physicalType) {
+            case 4:
+            case 3:
+              return function(t5, e5, n5, r5, i5) {
+                const s5 = Uf2(t5, e5), o4 = td2(s5, i5, t5, e5), a4 = 3 === r5.physicalType;
+                if (o4 === Of2.FLAT) {
+                  const r6 = Td2(i5) ? i5 : void 0, o5 = a4 ? Gf2(t5, e5, s5, 0, r6) : Xf2(t5, e5, s5, 0, r6);
+                  return new Jp(n5.name, o5, i5);
+                }
+                if (o4 === Of2.SEQUENCE) {
+                  const r6 = Wf2(t5, e5, s5);
+                  return new ef2(n5.name, r6[0], r6[1], s5.numRleValues);
+                }
+                const l3 = a4 ? function(t6, e6, n6) {
+                  const r6 = Zf2(t6, e6, n6);
+                  return 1 === r6.length ? Mf2(r6[0]) : function(t7) {
+                    return Mf2(t7[1]);
+                  }(r6);
+                }(t5, e5, s5) : Hf2(t5, e5, s5);
+                return new nf2(n5.name, l3, i5, a4);
+              }(e4, n4, s4, i4, a3);
+            case 9:
+              return function(t5, e5, n5, r5, i5) {
+                let s5 = null, o4 = null, a4 = null, l3 = null, u3 = null, c3 = i5 ?? null, h3 = null, p3 = null;
+                for (let t6 = 0; t6 < r5; t6++) {
+                  const t7 = Uf2(e5, n5);
+                  switch (t7.physicalStreamType) {
+                    case Bf2.PRESENT: {
+                      const r6 = wd2(e5, t7.numValues, t7.byteLength, n5), s6 = new jf(r6, t7.numValues);
+                      c3 = i5 ?? s6;
+                      break;
+                    }
+                    case Bf2.OFFSET:
+                      o4 = Xf2(e5, n5, t7, 0, c3);
+                      break;
+                    case Bf2.LENGTH: {
+                      const r6 = Yf2(e5, n5, t7);
+                      Lf2.DICTIONARY === t7.logicalStreamType.lengthType ? s5 = r6 : Lf2.SYMBOL === t7.logicalStreamType.lengthType ? l3 = r6 : h3 = r6;
+                      break;
+                    }
+                    case Bf2.DATA: {
+                      const r6 = e5.subarray(n5.get(), n5.get() + t7.byteLength);
+                      n5.add(t7.byteLength);
+                      const i6 = t7.logicalStreamType.dictionaryType;
+                      Cf2.FSST === i6 ? u3 = r6 : Cf2.SINGLE === i6 || Cf2.SHARED === i6 ? a4 = r6 : Cf2.NONE === i6 && (p3 = r6);
+                      break;
+                    }
+                  }
+                }
+                return function(t6, e6, n6, r6, i6, s6, o5) {
+                  return e6 ? new Id2(t6, n6, r6, i6, s6, e6, o5) : null;
+                }(t5, u3, o4, s5, a4, l3, c3) ?? function(t6, e6, n6, r6, i6) {
+                  return e6 ? i6 ? new kd2(t6, n6, r6, e6, i6) : new kd2(t6, n6, r6, e6) : null;
+                }(t5, a4, o4, s5, c3) ?? function(t6, e6, n6, r6, i6) {
+                  if (!e6 || !n6) return null;
+                  if (r6) return i6 ? new kd2(t6, r6, e6, n6, i6) : new kd2(t6, r6, e6, n6);
+                  if (i6 && i6.size() !== e6.length - 1) {
+                    const r7 = new Uint32Array(i6.size());
+                    let s6 = 0;
+                    for (let t7 = 0; t7 < i6.size(); t7++) r7[t7] = i6.get(t7) ? s6++ : 0;
+                    return new kd2(t6, r7, e6, n6, i6);
+                  }
+                  return i6 ? new Md2(t6, e6, n6, i6) : new Md2(t6, e6, n6);
+                }(t5, h3, p3, o4, c3);
+              }(s4.name, e4, n4, s4.nullable ? t4 - 1 : t4, o3);
+            case 0:
+              return function(t5, e5, n5, r5, i5) {
+                const s5 = Uf2(t5, e5), o4 = s5.numValues, a4 = e5.get(), l3 = Td2(i5) ? i5 : void 0, u3 = wd2(t5, o4, s5.byteLength, e5, l3);
+                e5.set(a4 + s5.byteLength);
+                const c3 = new jf(u3, o4);
+                return new xd2(n5.name, c3, i5);
+              }(e4, n4, s4, 0, a3);
+            case 6:
+            case 5:
+              return function(t5, e5, n5, r5, i5) {
+                const s5 = Uf2(t5, e5), o4 = td2(s5, r5, t5, e5, "int64"), a4 = 5 === i5.physicalType;
+                if (o4 === Of2.FLAT) {
+                  const i6 = Td2(r5) ? r5 : void 0, o5 = a4 ? function(t6, e6, n6, r6) {
+                    return function(t7, e7, n7) {
+                      let r7;
+                      switch (e7.logicalLevelTechnique1) {
+                        case of2.DELTA:
+                          if (e7.logicalLevelTechnique2 === of2.RLE) {
+                            const i7 = e7;
+                            if (!n7) return function(t8, e8, n8) {
+                              const r8 = new BigInt64Array(n8);
+                              let i8 = 0, s6 = 0n;
+                              for (let n9 = 0; n9 < e8; n9++) {
+                                const o6 = Number(t8[n9]), a5 = kf(t8[n9 + e8]);
+                                for (let t9 = 0; t9 < o6; t9++) s6 += a5, r8[i8++] = s6;
+                              }
+                              return r8;
+                            }(t7, i7.runs, i7.numRleValues);
+                            r7 = Pf2(t7 = Tf2(t7, i7.runs, i7.numRleValues));
+                          } else r7 = Pf2(t7);
+                          break;
+                        case of2.RLE:
+                          r7 = function(t8, e8, n8) {
+                            if (void 0 === n8) {
+                              n8 = 0;
+                              for (let r9 = 0; r9 < e8; r9++) n8 += Number(t8[r9]);
+                            }
+                            const r8 = new BigInt64Array(n8);
+                            let i7 = 0;
+                            for (let n9 = 0; n9 < e8; n9++) {
+                              const s6 = Number(t8[n9]);
+                              let o6 = t8[n9 + e8];
+                              o6 = kf(o6), r8.fill(o6, i7, i7 + s6), i7 += s6;
+                            }
+                            return r8;
+                          }(t7, e7.runs, e7.numRleValues);
+                          break;
+                        case of2.NONE:
+                          r7 = function(t8) {
+                            const e8 = new BigInt64Array(t8.length);
+                            for (let n8 = 0; n8 < t8.length; n8++) e8[n8] = kf(t8[n8]);
+                            return e8;
+                          }(t7);
+                          break;
+                        default:
+                          throw new Error(`The specified Logical level technique is not supported: ${e7.logicalLevelTechnique1}`);
+                      }
+                      return n7 ? qf2(r7, n7, 0n) : r7;
+                    }(_f2(t6, e6, n6.numValues), n6, r6);
+                  }(t5, e5, s5, i6) : Jf2(t5, e5, s5, i6);
+                  return new ed2(n5.name, o5, r5);
+                }
+                if (o4 === Of2.SEQUENCE) {
+                  const r6 = Kf2(t5, e5, s5);
+                  return new nd2(n5.name, r6[0], r6[1], s5.numRleValues);
+                }
+                const l3 = a4 ? function(t6, e6, n6) {
+                  const r6 = _f2(t6, e6, n6.numValues);
+                  return 1 === r6.length ? kf(r6[0]) : function(t7) {
+                    return kf(t7[1]);
+                  }(r6);
+                }(t5, e5, s5) : Qf2(t5, e5, s5);
+                return new bd2(n5.name, l3, r5, a4);
+              }(e4, n4, s4, a3, i4);
+            case 7:
+              return function(t5, e5, n5, r5) {
+                const i5 = Uf2(t5, e5), s5 = Td2(r5) ? r5 : void 0, o4 = function(t6, e6, n6, r6) {
+                  const i6 = e6.get(), s6 = i6 + n6 * Float32Array.BYTES_PER_ELEMENT, o5 = new Uint8Array(t6.subarray(i6, s6)).buffer, a4 = new Float32Array(o5);
+                  return e6.set(s6), r6 ? qf2(a4, r6, 0) : a4;
+                }(t5, e5, i5.numValues, s5);
+                return new vd2(n5.name, o4, r5);
+              }(e4, n4, s4, a3);
+            case 8:
+              return function(t5, e5, n5, r5) {
+                const i5 = Uf2(t5, e5), s5 = Td2(r5) ? r5 : void 0, o4 = function(t6, e6, n6, r6) {
+                  const i6 = e6.get(), s6 = i6 + n6 * Float64Array.BYTES_PER_ELEMENT, o5 = new Uint8Array(t6.subarray(i6, s6)).buffer, a4 = new Float64Array(o5);
+                  return e6.set(s6), r6 ? qf2(a4, r6, 0) : a4;
+                }(t5, e5, i5.numValues, s5);
+                return new Qp(n5.name, o4, r5);
+              }(e4, n4, s4, a3);
+            default:
+              throw new Error(`The specified data type for the field is currently not supported: ${i4}`);
+          }
+        }(r3, t3, e3, i3, n3.scalarType, n3) : 0 === r3 ? null : function(t4, e4, n4, r4) {
+          let i4 = null, s4 = null, o3 = null, a3 = null, l3 = false;
+          for (; !l3; ) {
+            const n5 = Uf2(t4, e4);
+            switch (n5.physicalStreamType) {
+              case Bf2.LENGTH:
+                Lf2.DICTIONARY === n5.logicalStreamType.lengthType ? i4 = Yf2(t4, e4, n5) : o3 = Yf2(t4, e4, n5);
+                break;
+              case Bf2.DATA:
+                Cf2.SINGLE === n5.logicalStreamType.dictionaryType || Cf2.SHARED === n5.logicalStreamType.dictionaryType ? (s4 = t4.subarray(e4.get(), e4.get() + n5.byteLength), l3 = true) : a3 = t4.subarray(e4.get(), e4.get() + n5.byteLength), e4.add(n5.byteLength);
+            }
+          }
+          const u3 = n4.complexType.children, c3 = [];
+          let h3 = 0;
+          for (const l4 of u3) {
+            const u4 = wf2(t4, e4, 1)[0];
+            if (0 === u4) continue;
+            const p3 = l4.name ? `${n4.name}${l4.name}` : n4.name;
+            if (2 !== u4 || "scalarField" !== l4.type || 9 !== l4.scalarField.physicalType) throw new Error("Currently only optional string fields are implemented for a struct.");
+            const f3 = Uf2(t4, e4), d3 = wd2(t4, f3.numValues, f3.byteLength, e4), y3 = Uf2(t4, e4), m3 = Xf2(t4, e4, y3, 0, y3.decompressedCount !== r4 ? new jf(d3, f3.numValues) : void 0);
+            c3[h3++] = a3 ? new Id2(p3, m3, i4, s4, o3, a3, new jf(d3, f3.numValues)) : new kd2(p3, m3, i4, s4, new jf(d3, f3.numValues));
+          }
+          return c3;
+        }(t3, e3, n3, i3);
+      }
+      function Td2(t3) {
+        return t3 instanceof jf;
+      }
+      function Fd2(t3) {
+        switch (t3) {
+          case 0:
+          case 1:
+          case 2:
+          case 3: {
+            const e3 = {};
+            e3.nullable = !!(1 & t3), e3.columnScope = 0;
+            const n3 = { type: "logicalType", logicalType: 0 };
+            return n3.longID = !!(2 & t3), e3.scalarType = n3, e3.type = "scalarType", e3;
+          }
+          case 4: {
+            const t4 = { nullable: false, columnScope: 0 }, e3 = { type: "physicalType", physicalType: 0 };
+            return t4.type = "complexType", t4.complexType = e3, t4;
+          }
+          case 30: {
+            const t4 = { nullable: false, columnScope: 0 }, e3 = { type: "physicalType", physicalType: 1 };
+            return t4.type = "complexType", t4.complexType = e3, t4;
+          }
+          default:
+            return function(t4) {
+              let e3;
+              switch (t4) {
+                case 10:
+                case 11:
+                  e3 = 0;
+                  break;
+                case 12:
+                case 13:
+                  e3 = 1;
+                  break;
+                case 14:
+                case 15:
+                  e3 = 2;
+                  break;
+                case 16:
+                case 17:
+                  e3 = 3;
+                  break;
+                case 18:
+                case 19:
+                  e3 = 4;
+                  break;
+                case 20:
+                case 21:
+                  e3 = 5;
+                  break;
+                case 22:
+                case 23:
+                  e3 = 6;
+                  break;
+                case 24:
+                case 25:
+                  e3 = 7;
+                  break;
+                case 26:
+                case 27:
+                  e3 = 8;
+                  break;
+                case 28:
+                case 29:
+                  e3 = 9;
+                  break;
+                default:
+                  return null;
+              }
+              const n3 = {};
+              n3.nullable = !!(1 & t4), n3.columnScope = 0;
+              const r3 = { type: "physicalType" };
+              return r3.physicalType = e3, n3.type = "scalarType", n3.scalarType = r3, n3;
+            }(t3);
+        }
+      }
+      function Dd2(t3) {
+        return t3 >= 10;
+      }
+      function Pd2(t3) {
+        return 30 === t3;
+      }
+      function zd2(t3) {
+        if ("scalarType" === t3.type) {
+          const e3 = t3.scalarType;
+          if ("physicalType" === e3.type) switch (e3.physicalType) {
+            case 0:
+            case 1:
+            case 2:
+            case 3:
+            case 4:
+            case 5:
+            case 6:
+            case 7:
+            case 8:
+            default:
+              return false;
+            case 9:
+              return true;
+          }
+          if ("logicalType" === e3.type) return false;
+        } else if ("complexType" === t3.type) {
+          const e3 = t3.complexType;
+          if ("physicalType" === e3.type) switch (e3.physicalType) {
+            case 0:
+            case 1:
+              return true;
+            default:
+              return false;
+          }
+        }
+        return console.warn("Unexpected column type in hasStreamCount", t3), false;
+      }
+      function Bd2(t3) {
+        var _a4;
+        return "complexType" === t3.type && "physicalType" === ((_a4 = t3.complexType) == null ? void 0 : _a4.type) && 0 === t3.complexType.physicalType;
+      }
+      const Cd2 = new TextDecoder();
+      function Vd2(t3, e3) {
+        const n3 = wf2(t3, e3, 1)[0];
+        if (0 === n3) return "";
+        const r3 = e3.get(), i3 = t3.subarray(r3, r3 + n3);
+        return e3.add(n3), Cd2.decode(i3);
+      }
+      function Ld2(t3, e3) {
+        const n3 = wf2(t3, e3, 1)[0] >>> 0;
+        if (n3 < 10 || n3 > 30) throw new Error(`Unsupported field type code ${n3}. Supported: 10-29(scalars), 30(STRUCT)`);
+        const r3 = Fd2(n3);
+        if (Dd2(n3) && (r3.name = Vd2(t3, e3)), Pd2(n3)) {
+          const n4 = wf2(t3, e3, 1)[0] >>> 0;
+          r3.complexType.children = new Array(n4);
+          for (let i3 = 0; i3 < n4; i3++) r3.complexType.children[i3] = Ld2(t3, e3);
+        }
+        return function(t4) {
+          return { name: t4.name, nullable: t4.nullable, scalarField: t4.scalarType, complexField: t4.complexType, type: "scalarType" === t4.type ? "scalarField" : "complexField" };
+        }(r3);
+      }
+      function Od2(t3, e3) {
+        const n3 = wf2(t3, e3, 1)[0] >>> 0, r3 = Fd2(n3);
+        if (!r3) throw new Error(`Unsupported column type code ${n3}. Supported: 0-3(ID), 4(GEOMETRY), 10-29(scalars), 30(STRUCT)`);
+        if (Dd2(n3) ? r3.name = Vd2(t3, e3) : n3 >= 0 && n3 <= 3 ? r3.name = "id" : 4 === n3 && (r3.name = "geometry"), Pd2(n3)) {
+          const n4 = wf2(t3, e3, 1)[0] >>> 0, i3 = r3.complexType;
+          i3.children = new Array(n4);
+          for (let r4 = 0; r4 < n4; r4++) i3.children[r4] = Ld2(t3, e3);
+        }
+        return r3;
+      }
+      function $d2(t3, e3) {
+        const n3 = { featureTables: [] }, r3 = {};
+        r3.name = Vd2(t3, e3);
+        const i3 = wf2(t3, e3, 1)[0] >>> 0, s3 = wf2(t3, e3, 1)[0] >>> 0;
+        r3.columns = new Array(s3);
+        for (let n4 = 0; n4 < s3; n4++) r3.columns[n4] = Od2(t3, e3);
+        return n3.featureTables.push(r3), [n3, i3];
+      }
+      function Rd2(t3, e3, n3, r3, i3, s3, o3 = false) {
+        const a3 = e3.scalarType;
+        if (!a3 || "logicalType" !== a3.type || 0 !== a3.logicalType) throw new Error(`ID column must be a logical ID scalar type: ${r3}`);
+        const l3 = a3.longID ? 6 : 4, u3 = "number" == typeof s3 ? void 0 : s3, c3 = td2(i3, s3, t3, n3, 6 === l3 ? "int64" : "int32");
+        if (4 === l3) switch (c3) {
+          case Of2.FLAT: {
+            const e4 = Xf2(t3, n3, i3, 0, u3);
+            return new Jp(r3, e4, s3);
+          }
+          case Of2.SEQUENCE: {
+            const e4 = Wf2(t3, n3, i3);
+            return new ef2(r3, e4[0], e4[1], i3.numRleValues);
+          }
+          case Of2.CONST: {
+            const e4 = Hf2(t3, n3, i3);
+            return new nf2(r3, e4, s3, false);
+          }
+        }
+        switch (c3) {
+          case Of2.FLAT: {
+            if (o3) {
+              const e5 = function(t4, e6, n4) {
+                const r4 = function(t5, e7, n5) {
+                  const r5 = new Float64Array(n5);
+                  for (let i4 = 0; i4 < n5; i4++) r5[i4] = Af2(t5, e7);
+                  return r5;
+                }(t4, e6, n4.numValues);
+                return function(t5, e7) {
+                  switch (e7.logicalLevelTechnique1) {
+                    case of2.DELTA:
+                      return e7.logicalLevelTechnique2 === of2.RLE && (t5 = Ff2(t5, e7.runs, e7.numRleValues)), function(t6) {
+                        t6[0] = If2(t6[0]);
+                        const e8 = t6.length / 4 * 4;
+                        let n5 = 1;
+                        if (e8 >= 4) for (; n5 < e8 - 4; n5 += 4) {
+                          const e9 = t6[n5 + 1], r5 = t6[n5 + 2], i4 = t6[n5 + 3];
+                          t6[n5] = If2(t6[n5]) + t6[n5 - 1], t6[n5 + 1] = If2(e9) + t6[n5], t6[n5 + 2] = If2(r5) + t6[n5 + 1], t6[n5 + 3] = If2(i4) + t6[n5 + 2];
+                        }
+                        for (; n5 !== t6.length; ++n5) t6[n5] = If2(t6[n5]) + t6[n5 - 1];
+                      }(t5), t5;
+                    case of2.RLE:
+                      return function(t6, e8) {
+                        return Ff2(t6, e8.runs, e8.numRleValues);
+                      }(t5, e7);
+                    case of2.NONE:
+                      return t5;
+                    default:
+                      throw new Error(`The specified Logical level technique is not supported: ${e7.logicalLevelTechnique1}`);
+                  }
+                }(r4, n4);
+              }(t3, n3, i3);
+              return new Qp(r3, e5, s3);
+            }
+            const e4 = Jf2(t3, n3, i3, u3);
+            return new ed2(r3, e4, s3);
+          }
+          case Of2.SEQUENCE: {
+            const e4 = Kf2(t3, n3, i3);
+            return new nd2(r3, e4[0], e4[1], i3.numRleValues);
+          }
+          case Of2.CONST: {
+            const e4 = Qf2(t3, n3, i3);
+            return new bd2(r3, e4, s3, false);
+          }
+        }
+        throw new Error("Vector type not supported for id column.");
+      }
+      class Nd2 {
+        constructor(t3, e3) {
+          var n3;
+          switch (this._featureData = t3, this.properties = this._featureData.properties || {}, null === (n3 = this._featureData.geometry) || void 0 === n3 ? void 0 : n3.type) {
+            case $f2.POINT:
+            case $f2.MULTIPOINT:
+              this.type = 1;
+              break;
+            case $f2.LINESTRING:
+            case $f2.MULTILINESTRING:
+              this.type = 2;
+              break;
+            case $f2.POLYGON:
+            case $f2.MULTIPOLYGON:
+              this.type = 3;
+              break;
+            default:
+              this.type = 0;
+          }
+          this.extent = e3, this.id = Number(this._featureData.id);
+        }
+        loadGeometry() {
+          const t3 = [];
+          for (const e3 of this._featureData.geometry.coordinates) {
+            const r3 = [];
+            for (const t4 of e3) r3.push(new n2(t4.x, t4.y));
+            t3.push(r3);
+          }
+          return t3;
+        }
+      }
+      class Ud2 {
+        constructor(t3) {
+          this.features = [], this.featureTable = t3, this.name = t3.name, this.extent = t3.extent, this.version = 2, this.features = t3.getFeatures(), this.length = this.features.length;
+        }
+        feature(t3) {
+          return new Nd2(this.features[t3], this.extent);
+        }
+      }
+      class jd2 {
+        constructor(t3) {
+          this.layers = {};
+          const e3 = function(t4, e4, n3 = true) {
+            var _a4;
+            const r3 = new sf2(0), i3 = [];
+            for (; r3.get() < t4.length; ) {
+              const e5 = wf2(t4, r3, 1)[0] >>> 0, o3 = r3.get() + e5;
+              if (o3 > t4.length) throw new Error(`Block overruns tile: ${o3} > ${t4.length}`);
+              if (1 != wf2(t4, r3, 1)[0] >>> 0) {
+                r3.set(o3);
+                continue;
+              }
+              const [a3, l3] = $d2(t4, r3), u3 = a3.featureTables[0];
+              let c3 = null, h3 = null;
+              const p3 = [];
+              let f3 = 0;
+              for (const e6 of u3.columns) {
+                const i4 = e6.name;
+                if ("scalarType" === (s3 = e6).type && "logicalType" === ((_a4 = s3.scalarType) == null ? void 0 : _a4.type) && 0 === s3.scalarType.logicalType) {
+                  let s4 = null;
+                  if (e6.nullable) {
+                    const e7 = Uf2(t4, r3), n4 = r3.get(), i5 = wd2(t4, e7.numValues, e7.byteLength, r3);
+                    r3.set(n4 + e7.byteLength), s4 = new jf(i5, e7.numValues);
+                  }
+                  const o4 = Uf2(t4, r3);
+                  f3 = s4 ? s4.size() : o4.decompressedCount, c3 = Rd2(t4, e6, r3, i4, o4, s4 ?? f3, n3);
+                } else if (Bd2(e6)) {
+                  const e7 = wf2(t4, r3, 1)[0];
+                  if (0 === f3) {
+                    const e8 = r3.get();
+                    f3 = Uf2(t4, r3).decompressedCount, r3.set(e8);
+                  }
+                  h3 = yd2(t4, e7, r3, f3);
+                } else {
+                  const n4 = zd2(e6) ? wf2(t4, r3, 1)[0] : 1;
+                  if (0 === n4) continue;
+                  const i5 = Ed2(t4, r3, e6, n4, f3);
+                  if (i5) if (Array.isArray(i5)) for (const t5 of i5) p3.push(t5);
+                  else p3.push(i5);
+                }
+              }
+              const d3 = new rf2(u3.name, h3, c3, p3, l3);
+              i3.push(d3), r3.set(o3);
+            }
+            var s3;
+            return i3;
+          }(new Uint8Array(t3));
+          this.layers = e3.reduce((t4, e4) => Object.assign(Object.assign({}, t4), { [e4.name]: new Ud2(e4) }), {});
+        }
+      }
+      class qd2 {
+        constructor(t3, e3) {
+          this.feature = t3, this.type = t3.type, this.properties = t3.tags ? t3.tags : {}, this.extent = e3, "id" in t3 && ("string" == typeof t3.id ? this.id = parseInt(t3.id, 10) : "number" != typeof t3.id || isNaN(t3.id) || (this.id = t3.id));
+        }
+        loadGeometry() {
+          const t3 = [], e3 = 1 === this.feature.type ? [this.feature.geometry] : this.feature.geometry;
+          for (const r3 of e3) {
+            const e4 = [];
+            for (const t4 of r3) e4.push(new n2(t4[0], t4[1]));
+            t3.push(e4);
+          }
+          return t3;
+        }
+      }
+      const Gd2 = "_geojsonTileLayer";
+      function Xd2(t3, e3, n3 = "") {
+        e3.writeVarintField(15, t3.version || 1), e3.writeStringField(1, t3.name || ""), e3.writeVarintField(5, t3.extent || 4096);
+        const r3 = { jsonPrefix: n3, keys: [], values: [], keycache: {}, valuecache: {} };
+        for (let n4 = 0; n4 < t3.length; n4++) r3.feature = t3.feature(n4), e3.writeMessage(2, Yd2, r3);
+        const i3 = r3.keys;
+        for (const t4 of i3) e3.writeStringField(3, t4);
+        const s3 = r3.values;
+        for (const t4 of s3) e3.writeMessage(4, Jd2, t4);
+      }
+      function Yd2(t3, e3) {
+        if (!t3.feature) return;
+        const n3 = t3.feature;
+        void 0 !== n3.id && e3.writeVarintField(1, n3.id), e3.writeMessage(2, Zd2, t3), e3.writeVarintField(3, n3.type), e3.writeMessage(4, Kd2, n3);
+      }
+      function Zd2(t3, e3) {
+        var _a4;
+        for (const n3 in (_a4 = t3.feature) == null ? void 0 : _a4.properties) {
+          let r3 = t3.feature.properties[n3], i3 = t3.keycache[n3];
+          if (null == r3) continue;
+          void 0 === i3 && (t3.keys.push(n3), i3 = t3.keys.length - 1, t3.keycache[n3] = i3), e3.writeVarint(i3), "string" != typeof r3 && "boolean" != typeof r3 && "number" != typeof r3 && (r3 = t3.jsonPrefix + JSON.stringify(r3));
+          const s3 = typeof r3 + ":" + r3;
+          let o3 = t3.valuecache[s3];
+          void 0 === o3 && (t3.values.push(r3), o3 = t3.values.length - 1, t3.valuecache[s3] = o3), e3.writeVarint(o3);
+        }
+      }
+      function Hd2(t3, e3) {
+        return (e3 << 3) + (7 & t3);
+      }
+      function Wd2(t3) {
+        return t3 << 1 ^ t3 >> 31;
+      }
+      function Kd2(t3, e3) {
+        const n3 = t3.loadGeometry(), r3 = t3.type;
+        let i3 = 0, s3 = 0;
+        for (const o3 of n3) {
+          let n4 = 1;
+          1 === r3 && (n4 = o3.length), e3.writeVarint(Hd2(1, n4));
+          const a3 = 3 === r3 ? o3.length - 1 : o3.length;
+          for (let t4 = 0; t4 < a3; t4++) {
+            1 === t4 && 1 !== r3 && e3.writeVarint(Hd2(2, a3 - 1));
+            const n5 = o3[t4].x - i3, l3 = o3[t4].y - s3;
+            e3.writeVarint(Wd2(n5)), e3.writeVarint(Wd2(l3)), i3 += n5, s3 += l3;
+          }
+          3 === t3.type && e3.writeVarint(Hd2(7, 1));
+        }
+      }
+      function Jd2(t3, e3) {
+        const n3 = typeof t3;
+        "string" === n3 ? e3.writeStringField(1, t3) : "boolean" === n3 ? e3.writeBooleanField(7, t3) : "number" === n3 && (t3 % 1 != 0 ? e3.writeDoubleField(3, t3) : t3 < 0 ? e3.writeSVarintField(6, t3) : e3.writeVarintField(5, t3));
+      }
+      class Qd2 {
+        constructor(t3, e3) {
+          this.tileID = t3, this.x = t3.canonical.x, this.y = t3.canonical.y, this.z = t3.canonical.z, this.grid = new cs(T2, 16, 0), this.grid3D = new cs(T2, 16, 0), this.featureIndexArray = new No(), this.promoteId = e3;
+        }
+        insert(t3, e3, n3, r3, i3, s3) {
+          const o3 = this.featureIndexArray.length;
+          this.featureIndexArray.emplaceBack(n3, r3, i3);
+          const a3 = s3 ? this.grid3D : this.grid;
+          for (let t4 = 0; t4 < e3.length; t4++) {
+            const n4 = e3[t4], r4 = [1 / 0, 1 / 0, -1 / 0, -1 / 0];
+            for (let t5 = 0; t5 < n4.length; t5++) {
+              const e4 = n4[t5];
+              r4[0] = Math.min(r4[0], e4.x), r4[1] = Math.min(r4[1], e4.y), r4[2] = Math.max(r4[2], e4.x), r4[3] = Math.max(r4[3], e4.y);
+            }
+            r4[0] < T2 && r4[1] < T2 && r4[2] >= 0 && r4[3] >= 0 && a3.insert(o3, r4[0], r4[1], r4[2], r4[3]);
+          }
+        }
+        loadVTLayers() {
+          return this.vtLayers || (this.vtLayers = "mlt" !== this.encoding ? new Lu(new zh2(this.rawTileData)).layers : new jd2(this.rawTileData).layers, this.sourceLayerCoder = new Zp(this.vtLayers ? Object.keys(this.vtLayers).sort() : [Gd2])), this.vtLayers;
+        }
+        query(t3, e3, r3, i3) {
+          this.loadVTLayers();
+          const s3 = t3.params, o3 = T2 / t3.tileSize / t3.scale, a3 = fi2(s3.filter, s3.globalState), l3 = t3.queryGeometry, u3 = t3.queryPadding * o3, c3 = Yp.fromPoints(l3), h3 = this.grid.query(c3.minX - u3, c3.minY - u3, c3.maxX + u3, c3.maxY + u3), p3 = Yp.fromPoints(t3.cameraQueryGeometry).expandBy(u3), f3 = this.grid3D.query(p3.minX, p3.minY, p3.maxX, p3.maxY, (e4, r4, i4, s4) => function(t4, e5, r5, i5, s5) {
+            for (const n3 of t4) if (e5 <= n3.x && r5 <= n3.y && i5 >= n3.x && s5 >= n3.y) return true;
+            const o4 = [new n2(e5, r5), new n2(e5, s5), new n2(i5, s5), new n2(i5, r5)];
+            if (t4.length > 2) {
+              for (const e6 of o4) if (tl2(t4, e6)) return true;
+            }
+            for (let e6 = 0; e6 < t4.length - 1; e6++) if (el2(t4[e6], t4[e6 + 1], o4)) return true;
+            return false;
+          }(t3.cameraQueryGeometry, e4 - u3, r4 - u3, i4 + u3, s4 + u3));
+          for (const t4 of f3) h3.push(t4);
+          h3.sort(ey);
+          const d3 = {};
+          let y3;
+          for (let n3 = 0; n3 < h3.length; n3++) {
+            const u4 = h3[n3];
+            if (u4 === y3) continue;
+            y3 = u4;
+            const c4 = this.featureIndexArray.get(u4);
+            let p4 = null;
+            this.loadMatchingFeature(d3, c4.bucketIndex, c4.sourceLayerIndex, c4.featureIndex, a3, s3.layers, s3.availableImages, e3, r3, i3, (e4, n4, r4) => (p4 || (p4 = Ra2(e4)), n4.queryIntersectsFeature({ queryGeometry: l3, feature: e4, featureState: r4, geometry: p4, zoom: this.z, transform: t3.transform, pixelsToTileUnits: o3, pixelPosMatrix: t3.pixelPosMatrix, unwrappedTileID: this.tileID.toUnwrapped(), getElevation: t3.getElevation })));
+          }
+          return d3;
+        }
+        loadMatchingFeature(t3, e3, n3, r3, i3, s3, o3, a3, l3, u3, c3) {
+          const h3 = this.bucketLayerIDs[e3];
+          if (s3 && !h3.some((t4) => s3.has(t4))) return;
+          const p3 = this.sourceLayerCoder.decode(n3), f3 = this.vtLayers[p3].feature(r3);
+          if (i3.needGeometry) {
+            const t4 = Na2(f3, true);
+            if (!i3.filter(new zs(this.tileID.overscaledZ), t4, this.tileID.canonical)) return;
+          } else if (!i3.filter(new zs(this.tileID.overscaledZ), f3)) return;
+          const d3 = this.getId(f3, p3);
+          for (let e4 = 0; e4 < h3.length; e4++) {
+            const n4 = h3[e4];
+            if (s3 && !s3.has(n4)) continue;
+            const i4 = a3[n4];
+            if (!i4) continue;
+            let p4 = {};
+            d3 && u3 && (p4 = u3.getState(i4.sourceLayer || Gd2, d3));
+            const y3 = O2({}, l3[n4]);
+            y3.paint = ty(y3.paint, i4.paint, f3, p4, o3), y3.layout = ty(y3.layout, i4.layout, f3, p4, o3);
+            const m3 = !c3 || c3(f3, i4, p4);
+            if (!m3) continue;
+            const g3 = new Hp(f3, this.z, this.x, this.y, d3);
+            g3.layer = y3;
+            let x3 = t3[n4];
+            void 0 === x3 && (x3 = t3[n4] = []), x3.push({ featureIndex: r3, feature: g3, intersectionZ: m3 });
+          }
+        }
+        lookupSymbolFeatures(t3, e3, n3, r3, i3, s3, o3, a3) {
+          const l3 = {};
+          this.loadVTLayers();
+          const u3 = fi2(i3.filterSpec, i3.globalState);
+          for (const i4 of t3) this.loadMatchingFeature(l3, n3, r3, i4, u3, s3, o3, a3, e3);
+          return l3;
+        }
+        hasLayer(t3) {
+          for (const e3 of this.bucketLayerIDs) for (const n3 of e3) if (t3 === n3) return true;
+          return false;
+        }
+        getId(t3, e3) {
+          var n3;
+          let r3 = t3.id;
+          return this.promoteId && (r3 = t3.properties["string" == typeof this.promoteId ? this.promoteId : this.promoteId[e3]], "boolean" == typeof r3 && (r3 = Number(r3)), void 0 === r3 && (null === (n3 = t3.properties) || void 0 === n3 ? void 0 : n3.cluster) && this.promoteId && (r3 = Number(t3.properties.cluster_id))), r3;
+        }
+      }
+      function ty(t3, e3, n3, r3, i3) {
+        return R2(t3, (t4, s3) => {
+          const o3 = e3 instanceof js ? e3.get(s3) : null;
+          return o3 && o3.evaluate ? o3.evaluate(n3, r3, i3) : o3;
+        });
+      }
+      function ey(t3, e3) {
+        return e3 - t3;
+      }
+      function ny(t3, e3, r3, i3, s3) {
+        const o3 = [];
+        for (let a3 = 0; a3 < t3.length; a3++) {
+          const l3 = t3[a3];
+          let u3;
+          for (let t4 = 0; t4 < l3.length - 1; t4++) {
+            let a4 = l3[t4], c3 = l3[t4 + 1];
+            a4.x < e3 && c3.x < e3 || (a4.x < e3 ? a4 = new n2(e3, a4.y + (e3 - a4.x) / (c3.x - a4.x) * (c3.y - a4.y))._round() : c3.x < e3 && (c3 = new n2(e3, a4.y + (e3 - a4.x) / (c3.x - a4.x) * (c3.y - a4.y))._round()), a4.y < r3 && c3.y < r3 || (a4.y < r3 ? a4 = new n2(a4.x + (r3 - a4.y) / (c3.y - a4.y) * (c3.x - a4.x), r3)._round() : c3.y < r3 && (c3 = new n2(a4.x + (r3 - a4.y) / (c3.y - a4.y) * (c3.x - a4.x), r3)._round()), a4.x >= i3 && c3.x >= i3 || (a4.x >= i3 ? a4 = new n2(i3, a4.y + (i3 - a4.x) / (c3.x - a4.x) * (c3.y - a4.y))._round() : c3.x >= i3 && (c3 = new n2(i3, a4.y + (i3 - a4.x) / (c3.x - a4.x) * (c3.y - a4.y))._round()), a4.y >= s3 && c3.y >= s3 || (a4.y >= s3 ? a4 = new n2(a4.x + (s3 - a4.y) / (c3.y - a4.y) * (c3.x - a4.x), s3)._round() : c3.y >= s3 && (c3 = new n2(a4.x + (s3 - a4.y) / (c3.y - a4.y) * (c3.x - a4.x), s3)._round()), u3 && a4.equals(u3[u3.length - 1]) || (u3 = [a4], o3.push(u3)), u3.push(c3)))));
+          }
+        }
+        return o3;
+      }
+      function ry(t3, e3, n3, r3, i3) {
+        switch (e3) {
+          case 1:
+            return function(t4, e4, n4, r4) {
+              const i4 = [];
+              for (const s3 of t4) for (const t5 of s3) {
+                const s4 = 0 === r4 ? t5.x : t5.y;
+                s4 >= e4 && s4 <= n4 && i4.push([t5]);
+              }
+              return i4;
+            }(t3, n3, r3, i3);
+          case 2:
+            return sy(t3, n3, r3, i3, false);
+          case 3:
+            return sy(t3, n3, r3, i3, true);
+        }
+        return [];
+      }
+      function iy(t3, e3, r3, i3, s3) {
+        const o3 = 0 === i3 ? oy : ay;
+        let a3 = [];
+        const l3 = [];
+        for (let n3 = 0; n3 < t3.length - 1; n3++) {
+          const u4 = t3[n3], c4 = t3[n3 + 1], h3 = 0 === i3 ? u4.x : u4.y, p3 = 0 === i3 ? c4.x : c4.y;
+          let f3 = false;
+          h3 < e3 ? p3 > e3 && a3.push(o3(u4, c4, e3)) : h3 > r3 ? p3 < r3 && a3.push(o3(u4, c4, r3)) : a3.push(u4), p3 < e3 && h3 >= e3 && (a3.push(o3(u4, c4, e3)), f3 = true), p3 > r3 && h3 <= r3 && (a3.push(o3(u4, c4, r3)), f3 = true), !s3 && f3 && (l3.push(a3), a3 = []);
+        }
+        const u3 = t3.length - 1, c3 = 0 === i3 ? t3[u3].x : t3[u3].y;
+        return c3 >= e3 && c3 <= r3 && a3.push(t3[u3]), s3 && a3.length > 0 && !a3[0].equals(a3[a3.length - 1]) && a3.push(new n2(a3[0].x, a3[0].y)), a3.length > 0 && l3.push(a3), l3;
+      }
+      function sy(t3, e3, n3, r3, i3) {
+        const s3 = [];
+        for (const o3 of t3) {
+          const t4 = iy(o3, e3, n3, r3, i3);
+          t4.length > 0 && s3.push(...t4);
+        }
+        return s3;
+      }
+      function oy(t3, e3, r3) {
+        return new n2(r3, t3.y + (r3 - t3.x) / (e3.x - t3.x) * (e3.y - t3.y));
+      }
+      function ay(t3, e3, r3) {
+        return new n2(t3.x + (r3 - t3.y) / (e3.y - t3.y) * (e3.x - t3.x), r3);
+      }
+      ps("FeatureIndex", Qd2, { omit: ["rawTileData", "sourceLayerCoder"] });
+      class ly extends n2 {
+        constructor(t3, e3, n3, r3) {
+          super(t3, e3), this.angle = n3, void 0 !== r3 && (this.segment = r3);
+        }
+        clone() {
+          return new ly(this.x, this.y, this.angle, this.segment);
+        }
+      }
+      function uy(t3, e3, n3, r3, i3) {
+        if (void 0 === e3.segment || 0 === n3) return true;
+        let s3 = e3, o3 = e3.segment + 1, a3 = 0;
+        for (; a3 > -n3 / 2; ) {
+          if (o3--, o3 < 0) return false;
+          a3 -= t3[o3].dist(s3), s3 = t3[o3];
+        }
+        a3 += t3[o3].dist(t3[o3 + 1]), o3++;
+        const l3 = [];
+        let u3 = 0;
+        for (; a3 < n3 / 2; ) {
+          const e4 = t3[o3], n4 = t3[o3 + 1];
+          if (!n4) return false;
+          let s4 = t3[o3 - 1].angleTo(e4) - e4.angleTo(n4);
+          for (s4 = Math.abs((s4 + 3 * Math.PI) % (2 * Math.PI) - Math.PI), l3.push({ distance: a3, angleDelta: s4 }), u3 += s4; a3 - l3[0].distance > r3; ) u3 -= l3.shift().angleDelta;
+          if (u3 > i3) return false;
+          o3++, a3 += e4.dist(n4);
+        }
+        return true;
+      }
+      function cy(t3) {
+        let e3 = 0;
+        for (let n3 = 0; n3 < t3.length - 1; n3++) e3 += t3[n3].dist(t3[n3 + 1]);
+        return e3;
+      }
+      function hy(t3, e3, n3) {
+        return t3 ? 0.6 * e3 * n3 : 0;
+      }
+      function py(t3, e3) {
+        return Math.max(t3 ? t3.right - t3.left : 0, e3 ? e3.right - e3.left : 0);
+      }
+      function fy(t3, e3, n3, r3, i3, s3) {
+        const o3 = hy(n3, i3, s3), a3 = py(n3, r3) * s3;
+        let l3 = 0;
+        const u3 = cy(t3) / 2;
+        for (let n4 = 0; n4 < t3.length - 1; n4++) {
+          const r4 = t3[n4], i4 = t3[n4 + 1], s4 = r4.dist(i4);
+          if (l3 + s4 > u3) {
+            const c3 = (u3 - l3) / s4, h3 = mn.number(r4.x, i4.x, c3), p3 = mn.number(r4.y, i4.y, c3), f3 = new ly(h3, p3, i4.angleTo(r4), n4);
+            return f3._round(), !o3 || uy(t3, f3, a3, o3, e3) ? f3 : void 0;
+          }
+          l3 += s4;
+        }
+      }
+      function dy(t3, e3, n3, r3, i3, s3, o3, a3, l3) {
+        const u3 = hy(r3, s3, o3), c3 = py(r3, i3), h3 = c3 * o3, p3 = 0 === t3[0].x || t3[0].x === l3 || 0 === t3[0].y || t3[0].y === l3;
+        return e3 - h3 < e3 / 4 && (e3 = h3 + e3 / 4), yy(t3, p3 ? e3 / 2 * a3 % e3 : (c3 / 2 + 2 * s3) * o3 * a3 % e3, e3, u3, n3, h3, p3, false, l3);
+      }
+      function yy(t3, e3, n3, r3, i3, s3, o3, a3, l3) {
+        const u3 = s3 / 2, c3 = cy(t3);
+        let h3 = 0, p3 = e3 - n3, f3 = [];
+        for (let e4 = 0; e4 < t3.length - 1; e4++) {
+          const o4 = t3[e4], a4 = t3[e4 + 1], d3 = o4.dist(a4), y3 = a4.angleTo(o4);
+          for (; p3 + n3 < h3 + d3; ) {
+            p3 += n3;
+            const m3 = (p3 - h3) / d3, g3 = mn.number(o4.x, a4.x, m3), x3 = mn.number(o4.y, a4.y, m3);
+            if (g3 >= 0 && g3 < l3 && x3 >= 0 && x3 < l3 && p3 - u3 >= 0 && p3 + u3 <= c3) {
+              const n4 = new ly(g3, x3, y3, e4);
+              n4._round(), r3 && !uy(t3, n4, s3, r3, i3) || f3.push(n4);
+            }
+          }
+          h3 += d3;
+        }
+        return a3 || f3.length || o3 || (f3 = yy(t3, h3 / 2, n3, r3, i3, s3, o3, true, l3)), f3;
+      }
+      function my(t3, e3, r3, i3) {
+        const s3 = [], o3 = t3.image, a3 = o3.pixelRatio, l3 = o3.paddedRect.w - 2, u3 = o3.paddedRect.h - 2;
+        let c3 = { x1: t3.left, y1: t3.top, x2: t3.right, y2: t3.bottom };
+        const h3 = o3.stretchX || [[0, l3]], p3 = o3.stretchY || [[0, u3]], f3 = (t4, e4) => t4 + e4[1] - e4[0], d3 = h3.reduce(f3, 0), y3 = p3.reduce(f3, 0), m3 = l3 - d3, g3 = u3 - y3;
+        let x3 = 0, v3 = d3, b3 = 0, w3 = y3, _3 = 0, S3 = m3, A3 = 0, M3 = g3;
+        if (o3.content && i3) {
+          const e4 = o3.content, n3 = e4[2] - e4[0], r4 = e4[3] - e4[1];
+          (o3.textFitWidth || o3.textFitHeight) && (c3 = ap(t3)), x3 = gy(h3, 0, e4[0]), b3 = gy(p3, 0, e4[1]), v3 = gy(h3, e4[0], e4[2]), w3 = gy(p3, e4[1], e4[3]), _3 = e4[0] - x3, A3 = e4[1] - b3, S3 = n3 - v3, M3 = r4 - w3;
+        }
+        const k3 = c3.x1, I3 = c3.y1, E3 = c3.x2 - k3, T3 = c3.y2 - I3, F3 = (t4, i4, s4, l4) => {
+          const u4 = vy(t4.stretch - x3, v3, E3, k3), c4 = by(t4.fixed - _3, S3, t4.stretch, d3), h4 = vy(i4.stretch - b3, w3, T3, I3), p4 = by(i4.fixed - A3, M3, i4.stretch, y3), f4 = vy(s4.stretch - x3, v3, E3, k3), m4 = by(s4.fixed - _3, S3, s4.stretch, d3), g4 = vy(l4.stretch - b3, w3, T3, I3), F4 = by(l4.fixed - A3, M3, l4.stretch, y3), D3 = new n2(u4, h4), P3 = new n2(f4, h4), z3 = new n2(f4, g4), B3 = new n2(u4, g4), C3 = new n2(c4 / a3, p4 / a3), V3 = new n2(m4 / a3, F4 / a3), L3 = e3 * Math.PI / 180;
+          if (L3) {
+            const t5 = Math.sin(L3), e4 = Math.cos(L3), n3 = [e4, -t5, t5, e4];
+            D3._matMult(n3), P3._matMult(n3), B3._matMult(n3), z3._matMult(n3);
+          }
+          const O3 = t4.stretch + t4.fixed, $3 = i4.stretch + i4.fixed;
+          return { tl: D3, tr: P3, bl: B3, br: z3, tex: { x: o3.paddedRect.x + 1 + O3, y: o3.paddedRect.y + 1 + $3, w: s4.stretch + s4.fixed - O3, h: l4.stretch + l4.fixed - $3 }, writingMode: void 0, glyphOffset: [0, 0], sectionIndex: 0, pixelOffsetTL: C3, pixelOffsetBR: V3, minFontScaleX: S3 / a3 / E3, minFontScaleY: M3 / a3 / T3, isSDF: r3 };
+        };
+        if (i3 && (o3.stretchX || o3.stretchY)) {
+          const t4 = xy(h3, m3, d3), e4 = xy(p3, g3, y3);
+          for (let n3 = 0; n3 < t4.length - 1; n3++) {
+            const r4 = t4[n3], i4 = t4[n3 + 1];
+            for (let t5 = 0; t5 < e4.length - 1; t5++) s3.push(F3(r4, e4[t5], i4, e4[t5 + 1]));
+          }
+        } else s3.push(F3({ fixed: 0, stretch: -1 }, { fixed: 0, stretch: -1 }, { fixed: 0, stretch: l3 + 1 }, { fixed: 0, stretch: u3 + 1 }));
+        return s3;
+      }
+      function gy(t3, e3, n3) {
+        let r3 = 0;
+        for (const i3 of t3) r3 += Math.max(e3, Math.min(n3, i3[1])) - Math.max(e3, Math.min(n3, i3[0]));
+        return r3;
+      }
+      function xy(t3, e3, n3) {
+        const r3 = [{ fixed: -1, stretch: 0 }];
+        for (const [e4, n4] of t3) {
+          const t4 = r3[r3.length - 1];
+          r3.push({ fixed: e4 - t4.stretch, stretch: t4.stretch }), r3.push({ fixed: e4 - t4.stretch, stretch: t4.stretch + (n4 - e4) });
+        }
+        return r3.push({ fixed: e3 + 1, stretch: n3 }), r3;
+      }
+      function vy(t3, e3, n3, r3) {
+        return t3 / e3 * n3 + r3;
+      }
+      function by(t3, e3, n3, r3) {
+        return t3 - e3 * n3 / r3;
+      }
+      ps("Anchor", ly);
+      class wy {
+        constructor(t3, e3, r3, i3, s3, o3, a3, l3, u3, c3) {
+          var h3;
+          if (this.boxStartIndex = t3.length, u3) {
+            let t4 = o3.top, e4 = o3.bottom;
+            const n3 = o3.collisionPadding;
+            n3 && (t4 -= n3[1], e4 += n3[3]);
+            let r4 = e4 - t4;
+            r4 > 0 && (r4 = Math.max(10, r4), this.circleDiameter = r4);
+          } else {
+            const u4 = (null === (h3 = o3.image) || void 0 === h3 ? void 0 : h3.content) && (o3.image.textFitWidth || o3.image.textFitHeight) ? ap(o3) : { x1: o3.left, y1: o3.top, x2: o3.right, y2: o3.bottom };
+            u4.y1 = u4.y1 * a3 - l3[0], u4.y2 = u4.y2 * a3 + l3[2], u4.x1 = u4.x1 * a3 - l3[3], u4.x2 = u4.x2 * a3 + l3[1];
+            const p3 = o3.collisionPadding;
+            if (p3 && (u4.x1 -= p3[0] * a3, u4.y1 -= p3[1] * a3, u4.x2 += p3[2] * a3, u4.y2 += p3[3] * a3), c3) {
+              const t4 = new n2(u4.x1, u4.y1), e4 = new n2(u4.x2, u4.y1), r4 = new n2(u4.x1, u4.y2), i4 = new n2(u4.x2, u4.y2), s4 = c3 * Math.PI / 180;
+              t4._rotate(s4), e4._rotate(s4), r4._rotate(s4), i4._rotate(s4), u4.x1 = Math.min(t4.x, e4.x, r4.x, i4.x), u4.x2 = Math.max(t4.x, e4.x, r4.x, i4.x), u4.y1 = Math.min(t4.y, e4.y, r4.y, i4.y), u4.y2 = Math.max(t4.y, e4.y, r4.y, i4.y);
+            }
+            t3.emplaceBack(e3.x, e3.y, u4.x1, u4.y1, u4.x2, u4.y2, r3, i3, s3);
+          }
+          this.boxEndIndex = t3.length;
+        }
+      }
+      class _y {
+        constructor(t3 = [], e3 = (t4, e4) => t4 < e4 ? -1 : t4 > e4 ? 1 : 0) {
+          if (this.data = t3, this.length = this.data.length, this.compare = e3, this.length > 0) for (let t4 = (this.length >> 1) - 1; t4 >= 0; t4--) this._down(t4);
+        }
+        push(t3) {
+          this.data.push(t3), this._up(this.length++);
+        }
+        pop() {
+          if (0 === this.length) return;
+          const t3 = this.data[0], e3 = this.data.pop();
+          return --this.length > 0 && (this.data[0] = e3, this._down(0)), t3;
+        }
+        peek() {
+          return this.data[0];
+        }
+        _up(t3) {
+          const { data: e3, compare: n3 } = this, r3 = e3[t3];
+          for (; t3 > 0; ) {
+            const i3 = t3 - 1 >> 1, s3 = e3[i3];
+            if (n3(r3, s3) >= 0) break;
+            e3[t3] = s3, t3 = i3;
+          }
+          e3[t3] = r3;
+        }
+        _down(t3) {
+          const { data: e3, compare: n3 } = this, r3 = this.length >> 1, i3 = e3[t3];
+          for (; t3 < r3; ) {
+            let r4 = 1 + (t3 << 1);
+            const s3 = r4 + 1;
+            if (s3 < this.length && n3(e3[s3], e3[r4]) < 0 && (r4 = s3), n3(e3[r4], i3) >= 0) break;
+            e3[t3] = e3[r4], t3 = r4;
+          }
+          e3[t3] = i3;
+        }
+      }
+      function Sy(t3, e3 = 1, r3 = false) {
+        const i3 = Yp.fromPoints(t3[0]), s3 = Math.min(i3.width(), i3.height());
+        let o3 = s3 / 2;
+        const a3 = new _y([], Ay), { minX: l3, minY: u3, maxX: c3, maxY: h3 } = i3;
+        if (0 === s3) return new n2(l3, u3);
+        for (let e4 = l3; e4 < c3; e4 += s3) for (let n3 = u3; n3 < h3; n3 += s3) a3.push(new My(e4 + o3, n3 + o3, o3, t3));
+        let p3 = function(t4) {
+          let e4 = 0, n3 = 0, r4 = 0;
+          const i4 = t4[0];
+          for (let t5 = 0, s4 = i4.length, o4 = s4 - 1; t5 < s4; o4 = t5++) {
+            const s5 = i4[t5], a4 = i4[o4], l4 = s5.x * a4.y - a4.x * s5.y;
+            n3 += (s5.x + a4.x) * l4, r4 += (s5.y + a4.y) * l4, e4 += 3 * l4;
+          }
+          return new My(n3 / e4, r4 / e4, 0, t4);
+        }(t3), f3 = a3.length;
+        for (; a3.length; ) {
+          const n3 = a3.pop();
+          (n3.d > p3.d || !p3.d) && (p3 = n3, r3 && console.log("found best %d after %d probes", Math.round(1e4 * n3.d) / 1e4, f3)), n3.max - p3.d <= e3 || (o3 = n3.h / 2, a3.push(new My(n3.p.x - o3, n3.p.y - o3, o3, t3)), a3.push(new My(n3.p.x + o3, n3.p.y - o3, o3, t3)), a3.push(new My(n3.p.x - o3, n3.p.y + o3, o3, t3)), a3.push(new My(n3.p.x + o3, n3.p.y + o3, o3, t3)), f3 += 4);
+        }
+        return r3 && (console.log(`num probes: ${f3}`), console.log(`best distance: ${p3.d}`)), p3.p;
+      }
+      function Ay(t3, e3) {
+        return e3.max - t3.max;
+      }
+      function My(t3, e3, r3, i3) {
+        this.p = new n2(t3, e3), this.h = r3, this.d = function(t4, e4) {
+          let n3 = false, r4 = 1 / 0;
+          for (let i4 = 0; i4 < e4.length; i4++) {
+            const s3 = e4[i4];
+            for (let e5 = 0, i5 = s3.length, o3 = i5 - 1; e5 < i5; o3 = e5++) {
+              const i6 = s3[e5], a3 = s3[o3];
+              i6.y > t4.y != a3.y > t4.y && t4.x < (a3.x - i6.x) * (t4.y - i6.y) / (a3.y - i6.y) + i6.x && (n3 = !n3), r4 = Math.min(r4, Ja2(t4, i6, a3));
+            }
+          }
+          return (n3 ? 1 : -1) * Math.sqrt(r4);
+        }(this.p, i3), this.max = this.d + this.h * Math.SQRT2;
+      }
+      var ky;
+      t2.aM = void 0, (ky = t2.aM || (t2.aM = {}))[ky.center = 1] = "center", ky[ky.left = 2] = "left", ky[ky.right = 3] = "right", ky[ky.top = 4] = "top", ky[ky.bottom = 5] = "bottom", ky[ky["top-left"] = 6] = "top-left", ky[ky["top-right"] = 7] = "top-right", ky[ky["bottom-left"] = 8] = "bottom-left", ky[ky["bottom-right"] = 9] = "bottom-right";
+      const Iy = Number.POSITIVE_INFINITY;
+      function Ey(t3, e3) {
+        return e3[1] !== Iy ? function(t4, e4, n3) {
+          let r3 = 0, i3 = 0;
+          switch (e4 = Math.abs(e4), n3 = Math.abs(n3), t4) {
+            case "top-right":
+            case "top-left":
+            case "top":
+              i3 = n3 - 7;
+              break;
+            case "bottom-right":
+            case "bottom-left":
+            case "bottom":
+              i3 = 7 - n3;
+          }
+          switch (t4) {
+            case "top-right":
+            case "bottom-right":
+            case "right":
+              r3 = -e4;
+              break;
+            case "top-left":
+            case "bottom-left":
+            case "left":
+              r3 = e4;
+          }
+          return [r3, i3];
+        }(t3, e3[0], e3[1]) : function(t4, e4) {
+          let n3 = 0, r3 = 0;
+          e4 < 0 && (e4 = 0);
+          const i3 = e4 / Math.SQRT2;
+          switch (t4) {
+            case "top-right":
+            case "top-left":
+              r3 = i3 - 7;
+              break;
+            case "bottom-right":
+            case "bottom-left":
+              r3 = 7 - i3;
+              break;
+            case "bottom":
+              r3 = 7 - e4;
+              break;
+            case "top":
+              r3 = e4 - 7;
+          }
+          switch (t4) {
+            case "top-right":
+            case "bottom-right":
+              n3 = -i3;
+              break;
+            case "top-left":
+            case "bottom-left":
+              n3 = i3;
+              break;
+            case "left":
+              n3 = e4;
+              break;
+            case "right":
+              n3 = -e4;
+          }
+          return [n3, r3];
+        }(t3, e3[0]);
+      }
+      function Ty(t3, e3, n3) {
+        var r3;
+        const i3 = t3.layout, s3 = null === (r3 = i3.get("text-variable-anchor-offset")) || void 0 === r3 ? void 0 : r3.evaluate(e3, {}, n3);
+        if (s3) {
+          const t4 = s3.values, e4 = [];
+          for (let n4 = 0; n4 < t4.length; n4 += 2) {
+            const r4 = e4[n4] = t4[n4], i4 = t4[n4 + 1].map((t5) => t5 * bh2);
+            r4.startsWith("top") ? i4[1] -= 7 : r4.startsWith("bottom") && (i4[1] += 7), e4[n4 + 1] = i4;
+          }
+          return new Le2(e4);
+        }
+        const o3 = i3.get("text-variable-anchor");
+        if (o3) {
+          let r4;
+          r4 = void 0 !== t3._unevaluatedLayout.getValue("text-radial-offset") ? [i3.get("text-radial-offset").evaluate(e3, {}, n3) * bh2, Iy] : i3.get("text-offset").evaluate(e3, {}, n3).map((t4) => t4 * bh2);
+          const s4 = [];
+          for (const t4 of o3) s4.push(t4, Ey(t4, r4));
+          return new Le2(s4);
+        }
+        return null;
+      }
+      function Fy(t3) {
+        switch (t3) {
+          case "right":
+          case "top-right":
+          case "bottom-right":
+            return "right";
+          case "left":
+          case "top-left":
+          case "bottom-left":
+            return "left";
+        }
+        return "center";
+      }
+      function Dy(e3, n3, r3, i3, s3, o3, a3, l3, u3, c3, h3, p3) {
+        let f3 = o3.textMaxSize.evaluate(n3, {});
+        void 0 === f3 && (f3 = a3);
+        const d3 = e3.layers[0].layout, y3 = d3.get("icon-offset").evaluate(n3, {}, h3), m3 = zy(r3.horizontal), g3 = a3 / 24, x3 = e3.tilePixelRatio * g3, v3 = e3.tilePixelRatio * f3 / 24, b3 = e3.tilePixelRatio * l3, w3 = e3.tilePixelRatio * d3.get("symbol-spacing"), _3 = d3.get("text-padding") * e3.tilePixelRatio, S3 = function(t3, e4, n4, r4 = 1) {
+          const i4 = t3.get("icon-padding").evaluate(e4, {}, n4), s4 = i4 && i4.values;
+          return [s4[0] * r4, s4[1] * r4, s4[2] * r4, s4[3] * r4];
+        }(d3, n3, h3, e3.tilePixelRatio), A3 = d3.get("text-max-angle") / 180 * Math.PI, M3 = "viewport" !== d3.get("text-rotation-alignment") && "point" !== d3.get("symbol-placement"), k3 = "map" === d3.get("icon-rotation-alignment") && "point" !== d3.get("symbol-placement"), I3 = d3.get("symbol-placement"), E3 = w3 / 2, F3 = d3.get("icon-text-fit");
+        let D3;
+        i3 && "none" !== F3 && (e3.allowVerticalPlacement && r3.vertical && (D3 = lp(i3, r3.vertical, F3, d3.get("icon-text-fit-padding"), y3, g3)), m3 && (i3 = lp(i3, m3, F3, d3.get("icon-text-fit-padding"), y3, g3)));
+        const P3 = h3 ? p3.line.getGranularityForZoomLevel(h3.z) : 1, z3 = (l4, p4) => {
+          p4.x < 0 || p4.x >= T2 || p4.y < 0 || p4.y >= T2 || function(e4, n4, r4, i4, s4, o4, a4, l5, u4, c4, h4, p5, f4, d4, y4, m4, g4, x4, v4, b4, w4, _4, S4, A4, M4) {
+            const k4 = e4.addToLineVertexArray(n4, r4);
+            let I4, E4, T3, F4, D4 = 0, P4 = 0, z4 = 0, B3 = 0, C3 = -1, V3 = -1;
+            const L3 = {};
+            let O3 = ma2("");
+            if (e4.allowVerticalPlacement && i4.vertical) {
+              const t3 = l5.layout.get("text-rotate").evaluate(w4, {}, A4) + 90;
+              T3 = new wy(u4, n4, c4, h4, p5, i4.vertical, f4, d4, y4, t3), a4 && (F4 = new wy(u4, n4, c4, h4, p5, a4, g4, x4, y4, t3));
+            }
+            if (s4) {
+              const r5 = l5.layout.get("icon-rotate").evaluate(w4, {}), i5 = "none" !== l5.layout.get("icon-text-fit"), o5 = my(s4, r5, S4, i5), f5 = a4 ? my(a4, r5, S4, i5) : void 0;
+              E4 = new wy(u4, n4, c4, h4, p5, s4, g4, x4, false, r5), D4 = 4 * o5.length;
+              const d5 = e4.iconSizeData;
+              let y5 = null;
+              "source" === d5.kind ? (y5 = [up * l5.layout.get("icon-size").evaluate(w4, {})], y5[0] > cp && q2(`${e4.layerIds[0]}: Value for "icon-size" is >= 255. Reduce your "icon-size".`)) : "composite" === d5.kind && (y5 = [up * _4.compositeIconSizes[0].evaluate(w4, {}, A4), up * _4.compositeIconSizes[1].evaluate(w4, {}, A4)], (y5[0] > cp || y5[1] > cp) && q2(`${e4.layerIds[0]}: Value for "icon-size" is >= 255. Reduce your "icon-size".`)), e4.addSymbols(e4.icon, o5, y5, b4, v4, w4, t2.aw.none, n4, k4.lineStartIndex, k4.lineLength, -1, A4), C3 = e4.icon.placedSymbolArray.length - 1, f5 && (P4 = 4 * f5.length, e4.addSymbols(e4.icon, f5, y5, b4, v4, w4, t2.aw.vertical, n4, k4.lineStartIndex, k4.lineLength, -1, A4), V3 = e4.icon.placedSymbolArray.length - 1);
+            }
+            const $3 = Object.keys(i4.horizontal);
+            for (const r5 of $3) {
+              const s5 = i4.horizontal[r5];
+              if (!I4) {
+                O3 = ma2(s5.text);
+                const t3 = l5.layout.get("text-rotate").evaluate(w4, {}, A4);
+                I4 = new wy(u4, n4, c4, h4, p5, s5, f4, d4, y4, t3);
+              }
+              const a5 = 1 === s5.positionedLines.length;
+              if (z4 += Py(e4, n4, s5, o4, l5, y4, w4, m4, k4, i4.vertical ? t2.aw.horizontal : t2.aw.horizontalOnly, a5 ? $3 : [r5], L3, C3, _4, A4), a5) break;
+            }
+            i4.vertical && (B3 += Py(e4, n4, i4.vertical, o4, l5, y4, w4, m4, k4, t2.aw.vertical, ["vertical"], L3, V3, _4, A4));
+            const R3 = I4 ? I4.boxStartIndex : e4.collisionBoxArray.length, N3 = I4 ? I4.boxEndIndex : e4.collisionBoxArray.length, U3 = T3 ? T3.boxStartIndex : e4.collisionBoxArray.length, j3 = T3 ? T3.boxEndIndex : e4.collisionBoxArray.length, G3 = E4 ? E4.boxStartIndex : e4.collisionBoxArray.length, X3 = E4 ? E4.boxEndIndex : e4.collisionBoxArray.length, Y3 = F4 ? F4.boxStartIndex : e4.collisionBoxArray.length, Z3 = F4 ? F4.boxEndIndex : e4.collisionBoxArray.length;
+            let H3 = -1;
+            const W3 = (t3, e5) => t3 && t3.circleDiameter ? Math.max(t3.circleDiameter, e5) : e5;
+            H3 = W3(I4, H3), H3 = W3(T3, H3), H3 = W3(E4, H3), H3 = W3(F4, H3);
+            const K3 = H3 > -1 ? 1 : 0;
+            K3 && (H3 *= M4 / bh2), e4.glyphOffsetArray.length >= vp.MAX_GLYPHS && q2("Too many glyphs being rendered in a tile. See https://github.com/mapbox/mapbox-gl-js/issues/2907"), void 0 !== w4.sortKey && e4.addToSortKeyRanges(e4.symbolInstances.length, w4.sortKey);
+            const J3 = Ty(l5, w4, A4), [Q3, tt3] = function(e5, n5) {
+              const r5 = e5.length, i5 = null == n5 ? void 0 : n5.values;
+              if ((null == i5 ? void 0 : i5.length) > 0) for (let n6 = 0; n6 < i5.length; n6 += 2) {
+                const r6 = i5[n6 + 1];
+                e5.emplaceBack(t2.aM[i5[n6]], r6[0], r6[1]);
+              }
+              return [r5, e5.length];
+            }(e4.textAnchorOffsets, J3);
+            e4.symbolInstances.emplaceBack(n4.x, n4.y, L3.right >= 0 ? L3.right : -1, L3.center >= 0 ? L3.center : -1, L3.left >= 0 ? L3.left : -1, L3.vertical || -1, C3, V3, O3, R3, N3, U3, j3, G3, X3, Y3, Z3, c4, z4, B3, D4, P4, K3, 0, f4, H3, Q3, tt3);
+          }(e3, p4, l4, r3, i3, s3, D3, e3.layers[0], e3.collisionBoxArray, n3.index, n3.sourceLayerIndex, e3.index, x3, [_3, _3, _3, _3], M3, u3, b3, S3, k3, y3, n3, o3, c3, h3, a3);
+        };
+        if ("line" === I3) for (const t3 of ny(n3.geometry, 0, 0, T2, T2)) {
+          const n4 = vu(t3, P3), s4 = dy(n4, w3, A3, r3.vertical || m3, i3, 24, v3, e3.overscaling, T2);
+          for (const t4 of s4) m3 && By(e3, m3.text, E3, t4) || z3(n4, t4);
+        }
+        else if ("line-center" === I3) {
+          for (const t3 of n3.geometry) if (t3.length > 1) {
+            const e4 = vu(t3, P3), n4 = fy(e4, A3, r3.vertical || m3, i3, 24, v3);
+            n4 && z3(e4, n4);
+          }
+        } else if ("Polygon" === n3.type) for (const t3 of er(n3.geometry, 0)) {
+          const e4 = Sy(t3, 16);
+          z3(vu(t3[0], P3, true), new ly(e4.x, e4.y, 0));
+        }
+        else if ("LineString" === n3.type) for (const t3 of n3.geometry) {
+          const e4 = vu(t3, P3);
+          z3(e4, new ly(e4[0].x, e4[0].y, 0));
+        }
+        else if ("Point" === n3.type) for (const t3 of n3.geometry) for (const e4 of t3) z3([e4], new ly(e4.x, e4.y, 0));
+      }
+      function Py(t3, e3, r3, i3, s3, o3, a3, l3, u3, c3, h3, p3, f3, d3, y3) {
+        const m3 = function(t4, e4, r4, i4, s4, o4, a4, l4) {
+          const u4 = i4.layout.get("text-rotate").evaluate(o4, {}) * Math.PI / 180, c4 = [];
+          for (const t5 of e4.positionedLines) for (const i5 of t5.positionedGlyphs) {
+            if (!i5.rect) continue;
+            const o5 = i5.rect || {};
+            let h4 = 4, p4 = true, f4 = 1, d4 = 0;
+            const y4 = (s4 || l4) && i5.vertical, m4 = i5.metrics.advance * i5.scale / 2;
+            if (l4 && e4.verticalizable && (d4 = t5.lineOffset / 2 - (i5.imageName ? -(bh2 - i5.metrics.width * i5.scale) / 2 : (i5.scale - 1) * bh2)), i5.imageName) {
+              const t6 = a4[i5.imageName];
+              p4 = t6.sdf, f4 = t6.pixelRatio, h4 = 1 / f4;
+            }
+            const g4 = s4 ? [i5.x + m4, i5.y] : [0, 0];
+            let x4 = s4 ? [0, 0] : [i5.x + m4 + r4[0], i5.y + r4[1] - d4], v3 = [0, 0];
+            y4 && (v3 = x4, x4 = [0, 0]);
+            const b3 = i5.metrics.isDoubleResolution ? 2 : 1, w3 = (i5.metrics.left - h4) * i5.scale - m4 + x4[0], _3 = (-i5.metrics.top - h4) * i5.scale + x4[1], S3 = w3 + o5.w / b3 * i5.scale / f4, A3 = _3 + o5.h / b3 * i5.scale / f4, M3 = new n2(w3, _3), k3 = new n2(S3, _3), I3 = new n2(w3, A3), E3 = new n2(S3, A3);
+            if (y4) {
+              const t6 = new n2(-m4, m4 - -17), e5 = -Math.PI / 2, r5 = 12 - m4, s5 = new n2(22 - r5, -(i5.imageName ? r5 : 0)), o6 = new n2(...v3);
+              M3._rotateAround(e5, t6)._add(s5)._add(o6), k3._rotateAround(e5, t6)._add(s5)._add(o6), I3._rotateAround(e5, t6)._add(s5)._add(o6), E3._rotateAround(e5, t6)._add(s5)._add(o6);
+            }
+            if (u4) {
+              const t6 = Math.sin(u4), e5 = Math.cos(u4), n3 = [e5, -t6, t6, e5];
+              M3._matMult(n3), k3._matMult(n3), I3._matMult(n3), E3._matMult(n3);
+            }
+            const T3 = new n2(0, 0), F3 = new n2(0, 0);
+            c4.push({ tl: M3, tr: k3, bl: I3, br: E3, tex: o5, writingMode: e4.writingMode, glyphOffset: g4, sectionIndex: i5.sectionIndex, isSDF: p4, pixelOffsetTL: T3, pixelOffsetBR: F3, minFontScaleX: 0, minFontScaleY: 0 });
+          }
+          return c4;
+        }(0, r3, l3, s3, o3, a3, i3, t3.allowVerticalPlacement), g3 = t3.textSizeData;
+        let x3 = null;
+        "source" === g3.kind ? (x3 = [up * s3.layout.get("text-size").evaluate(a3, {})], x3[0] > cp && q2(`${t3.layerIds[0]}: Value for "text-size" is >= 255. Reduce your "text-size".`)) : "composite" === g3.kind && (x3 = [up * d3.compositeTextSizes[0].evaluate(a3, {}, y3), up * d3.compositeTextSizes[1].evaluate(a3, {}, y3)], (x3[0] > cp || x3[1] > cp) && q2(`${t3.layerIds[0]}: Value for "text-size" is >= 255. Reduce your "text-size".`)), t3.addSymbols(t3.text, m3, x3, l3, o3, a3, c3, e3, u3.lineStartIndex, u3.lineLength, f3, y3);
+        for (const e4 of h3) p3[e4] = t3.text.placedSymbolArray.length - 1;
+        return 4 * m3.length;
+      }
+      function zy(t3) {
+        for (const e3 in t3) return t3[e3];
+        return null;
+      }
+      function By(t3, e3, n3, r3) {
+        const i3 = t3.compareText;
+        if (e3 in i3) {
+          const t4 = i3[e3];
+          for (let e4 = t4.length - 1; e4 >= 0; e4--) if (r3.dist(t4[e4]) < n3) return true;
+        } else i3[e3] = [];
+        return i3[e3].push(r3), false;
+      }
+      var Cy;
+      t2.cF = void 0, (Cy = t2.cF || (t2.cF = {})).create = "create", Cy.load = "load", Cy.fullLoad = "fullLoad";
+      let Vy = null, Ly = [];
+      const Oy = 1e3 / 60, $y = "loadTime", Ry = "fullLoadTime", Ny = { mark(t3) {
+        performance.mark(t3);
+      }, recordStartOfFrameAt(t3) {
+        null != Vy && Ly.push(t3 - Vy), Vy = t3;
+      }, resetRuntimeMetrics() {
+        Vy = null, Ly = [];
+      }, clearInitializationMetrics() {
+        performance.clearMeasures($y), performance.clearMeasures(Ry);
+        for (const e3 in t2.cF) performance.clearMarks(t2.cF[e3]);
+      }, remove() {
+        this.resetRuntimeMetrics(), this.clearInitializationMetrics();
+      }, getPerformanceMetrics() {
+        performance.measure($y, t2.cF.create, t2.cF.load), performance.measure(Ry, t2.cF.create, t2.cF.fullLoad);
+        const e3 = performance.getEntriesByName($y)[0].duration, n3 = performance.getEntriesByName(Ry)[0].duration, r3 = Ly.length;
+        return { loadTimeMs: e3, fullLoadTimeMs: n3, averageFramesPerSecond: 1 / (Ly.reduce((t3, e4) => t3 + e4, 0) / r3 / 1e3), virtualDroppedFramesCount: Ly.filter((t3) => t3 > Oy).reduce((t3, e4) => t3 + (e4 - Oy) / Oy, 0), totalFramesCount: r3 };
+      } };
+      t2.$ = c2, t2.A = f2, t2.B = us, t2.C = is, t2.D = qs, t2.E = xt, t2.F = function([t3, e3, n3]) {
+        return e3 += 90, e3 *= Math.PI / 180, n3 *= Math.PI / 180, { x: t3 * Math.cos(e3) * Math.sin(n3), y: t3 * Math.sin(e3) * Math.sin(n3), z: t3 * Math.cos(n3) };
+      }, t2.G = mn, t2.H = zs, t2.I = Hh2, t2.J = os, t2.K = function(t3) {
+        if (null == Y2) {
+          const e3 = t3.navigator ? t3.navigator.userAgent : null;
+          Y2 = !!t3.safari || !(!e3 || !(/\b(iPad|iPhone|iPod)\b/.test(e3) || e3.match("Safari") && !e3.match("Chrome")));
+        }
+        return Y2;
+      }, t2.L = class {
+        constructor(t3, e3) {
+          this.target = t3, this.mapId = e3, this.resolveRejects = {}, this.tasks = {}, this.taskQueue = [], this.abortControllers = {}, this.messageHandlers = {}, this.invoker = new Tp(() => this.process()), this.subscription = Q2(this.target, "message", (t4) => this.receive(t4), false), this.globalScope = X2(self) ? t3 : window;
+        }
+        registerMessageHandler(t3, e3) {
+          this.messageHandlers[t3] = e3;
+        }
+        unregisterMessageHandler(t3) {
+          delete this.messageHandlers[t3];
+        }
+        sendAsync(t3, e3) {
+          return new Promise((n3, r3) => {
+            const i3 = Math.round(1e18 * Math.random()).toString(36).substring(0, 10), s3 = e3 ? Q2(e3.signal, "abort", () => {
+              null == s3 || s3.unsubscribe(), delete this.resolveRejects[i3];
+              const e4 = { id: i3, type: "<cancel>", origin: location.origin, targetMapId: t3.targetMapId, sourceMapId: this.mapId };
+              this.target.postMessage(e4);
+            }, Fp) : null;
+            this.resolveRejects[i3] = { resolve: (t4) => {
+              null == s3 || s3.unsubscribe(), n3(t4);
+            }, reject: (t4) => {
+              null == s3 || s3.unsubscribe(), r3(t4);
+            } };
+            const o3 = [], a3 = Object.assign(Object.assign({}, t3), { id: i3, sourceMapId: this.mapId, origin: location.origin, data: ms(t3.data, o3) });
+            this.target.postMessage(a3, { transfer: o3 });
+          });
+        }
+        receive(t3) {
+          const e3 = t3.data, n3 = e3.id, r3 = ["file://", "resource://android", "null"], i3 = [e3.origin, location.origin], s3 = e3.origin === location.origin, o3 = i3.some((t4) => r3.includes(t4));
+          if ((s3 || o3) && (!e3.targetMapId || this.mapId === e3.targetMapId)) {
+            if ("<cancel>" === e3.type) {
+              delete this.tasks[n3];
+              const t4 = this.abortControllers[n3];
+              return delete this.abortControllers[n3], void (t4 && t4.abort());
+            }
+            if (X2(self) || e3.mustQueue) return this.tasks[n3] = e3, this.taskQueue.push(n3), void this.invoker.trigger();
+            this.processTask(n3, e3);
+          }
+        }
+        process() {
+          if (0 === this.taskQueue.length) return;
+          const t3 = this.taskQueue.shift(), e3 = this.tasks[t3];
+          delete this.tasks[t3], this.taskQueue.length > 0 && this.invoker.trigger(), e3 && this.processTask(t3, e3);
+        }
+        processTask(t3, n3) {
+          return e2(this, void 0, void 0, function* () {
+            if ("<response>" === n3.type) {
+              const e4 = this.resolveRejects[t3];
+              if (delete this.resolveRejects[t3], !e4) return;
+              return void (n3.error ? e4.reject(gs(n3.error)) : e4.resolve(gs(n3.data)));
+            }
+            if (!this.messageHandlers[n3.type]) return void this.completeTask(t3, new Error(`Could not find a registered handler for ${n3.type}, map ID: ${this.mapId}, available handlers: ${Object.keys(this.messageHandlers).join(", ")}`));
+            const e3 = gs(n3.data), r3 = new AbortController();
+            this.abortControllers[t3] = r3;
+            try {
+              const i3 = yield this.messageHandlers[n3.type](n3.sourceMapId, e3, r3);
+              this.completeTask(t3, null, i3);
+            } catch (e4) {
+              this.completeTask(t3, e4);
+            }
+          });
+        }
+        completeTask(t3, e3, n3) {
+          const r3 = [];
+          delete this.abortControllers[t3];
+          const i3 = { id: t3, type: "<response>", sourceMapId: this.mapId, origin: location.origin, error: e3 ? ms(e3) : null, data: ms(n3, r3) };
+          this.target.postMessage(i3, { transfer: r3 });
+        }
+        remove() {
+          this.invoker.remove(), this.subscription.unsubscribe();
+        }
+      }, t2.M = ut2, t2.N = function() {
+        var t3 = new f2(16);
+        return f2 != Float32Array && (t3[1] = 0, t3[2] = 0, t3[3] = 0, t3[4] = 0, t3[6] = 0, t3[7] = 0, t3[8] = 0, t3[9] = 0, t3[11] = 0, t3[12] = 0, t3[13] = 0, t3[14] = 0), t3[0] = 1, t3[5] = 1, t3[10] = 1, t3[15] = 1, t3;
+      }, t2.O = function(t3, e3, n3) {
+        var r3, i3, s3, o3, a3, l3, u3, c3, h3, p3, f3, d3, y3 = n3[0], m3 = n3[1], g3 = n3[2];
+        return e3 === t3 ? (t3[12] = e3[0] * y3 + e3[4] * m3 + e3[8] * g3 + e3[12], t3[13] = e3[1] * y3 + e3[5] * m3 + e3[9] * g3 + e3[13], t3[14] = e3[2] * y3 + e3[6] * m3 + e3[10] * g3 + e3[14], t3[15] = e3[3] * y3 + e3[7] * m3 + e3[11] * g3 + e3[15]) : (i3 = e3[1], s3 = e3[2], o3 = e3[3], a3 = e3[4], l3 = e3[5], u3 = e3[6], c3 = e3[7], h3 = e3[8], p3 = e3[9], f3 = e3[10], d3 = e3[11], t3[0] = r3 = e3[0], t3[1] = i3, t3[2] = s3, t3[3] = o3, t3[4] = a3, t3[5] = l3, t3[6] = u3, t3[7] = c3, t3[8] = h3, t3[9] = p3, t3[10] = f3, t3[11] = d3, t3[12] = r3 * y3 + a3 * m3 + h3 * g3 + e3[12], t3[13] = i3 * y3 + l3 * m3 + p3 * g3 + e3[13], t3[14] = s3 * y3 + u3 * m3 + f3 * g3 + e3[14], t3[15] = o3 * y3 + c3 * m3 + d3 * g3 + e3[15]), t3;
+      }, t2.P = n2, t2.Q = function(t3, e3, n3) {
+        var r3 = n3[0], i3 = n3[1], s3 = n3[2];
+        return t3[0] = e3[0] * r3, t3[1] = e3[1] * r3, t3[2] = e3[2] * r3, t3[3] = e3[3] * r3, t3[4] = e3[4] * i3, t3[5] = e3[5] * i3, t3[6] = e3[6] * i3, t3[7] = e3[7] * i3, t3[8] = e3[8] * s3, t3[9] = e3[9] * s3, t3[10] = e3[10] * s3, t3[11] = e3[11] * s3, t3[12] = e3[12], t3[13] = e3[13], t3[14] = e3[14], t3[15] = e3[15], t3;
+      }, t2.R = Sl, t2.S = function(t3, e3, n3) {
+        var r3 = e3[0], i3 = e3[1], s3 = e3[2], o3 = e3[3], a3 = e3[4], l3 = e3[5], u3 = e3[6], c3 = e3[7], h3 = e3[8], p3 = e3[9], f3 = e3[10], d3 = e3[11], y3 = e3[12], m3 = e3[13], g3 = e3[14], x3 = e3[15], v3 = n3[0], b3 = n3[1], w3 = n3[2], _3 = n3[3];
+        return t3[0] = v3 * r3 + b3 * a3 + w3 * h3 + _3 * y3, t3[1] = v3 * i3 + b3 * l3 + w3 * p3 + _3 * m3, t3[2] = v3 * s3 + b3 * u3 + w3 * f3 + _3 * g3, t3[3] = v3 * o3 + b3 * c3 + w3 * d3 + _3 * x3, t3[4] = (v3 = n3[4]) * r3 + (b3 = n3[5]) * a3 + (w3 = n3[6]) * h3 + (_3 = n3[7]) * y3, t3[5] = v3 * i3 + b3 * l3 + w3 * p3 + _3 * m3, t3[6] = v3 * s3 + b3 * u3 + w3 * f3 + _3 * g3, t3[7] = v3 * o3 + b3 * c3 + w3 * d3 + _3 * x3, t3[8] = (v3 = n3[8]) * r3 + (b3 = n3[9]) * a3 + (w3 = n3[10]) * h3 + (_3 = n3[11]) * y3, t3[9] = v3 * i3 + b3 * l3 + w3 * p3 + _3 * m3, t3[10] = v3 * s3 + b3 * u3 + w3 * f3 + _3 * g3, t3[11] = v3 * o3 + b3 * c3 + w3 * d3 + _3 * x3, t3[12] = (v3 = n3[12]) * r3 + (b3 = n3[13]) * a3 + (w3 = n3[14]) * h3 + (_3 = n3[15]) * y3, t3[13] = v3 * i3 + b3 * l3 + w3 * p3 + _3 * m3, t3[14] = v3 * s3 + b3 * u3 + w3 * f3 + _3 * g3, t3[15] = v3 * o3 + b3 * c3 + w3 * d3 + _3 * x3, t3;
+      }, t2.T = Bl, t2.U = function(t3, e3) {
+        const n3 = {};
+        for (let r3 = 0; r3 < e3.length; r3++) {
+          const i3 = e3[r3];
+          i3 in t3 && (n3[i3] = t3[i3]);
+        }
+        return n3;
+      }, t2.V = Pp, t2.W = L2, t2.X = Vp, t2.Y = Cp, t2.Z = ot2, t2._ = e2, t2.a = st2, t2.a$ = function(t3) {
+        var e3 = new f2(3);
+        return e3[0] = t3[0], e3[1] = t3[1], e3[2] = t3[2], e3;
+      }, t2.a0 = h2, t2.a1 = W2, t2.a2 = Gp, t2.a3 = Op, t2.a4 = $p, t2.a5 = T2, t2.a6 = Np, t2.a7 = Yp, t2.a8 = 25, t2.a9 = jp, t2.aA = function(t3) {
+        var e3 = t3[0], n3 = t3[1];
+        return Math.sqrt(e3 * e3 + n3 * n3);
+      }, t2.aB = function(t3) {
+        return t3[0] = 0, t3[1] = 0, t3;
+      }, t2.aC = function(t3, e3, n3) {
+        return t3[0] = e3[0] * n3, t3[1] = e3[1] * n3, t3;
+      }, t2.aD = yp, t2.aE = A2, t2.aF = function(t3, e3, r3, i3) {
+        const s3 = e3.y - t3.y, o3 = e3.x - t3.x, a3 = i3.y - r3.y, l3 = i3.x - r3.x, u3 = a3 * o3 - l3 * s3;
+        if (0 === u3) return null;
+        const c3 = (l3 * (t3.y - r3.y) - a3 * (t3.x - r3.x)) / u3;
+        return new n2(t3.x + c3 * o3, t3.y + c3 * s3);
+      }, t2.aG = ny, t2.aH = Ga2, t2.aI = function(t3) {
+        let e3 = 1 / 0, n3 = 1 / 0, r3 = -1 / 0, i3 = -1 / 0;
+        for (const s3 of t3) e3 = Math.min(e3, s3.x), n3 = Math.min(n3, s3.y), r3 = Math.max(r3, s3.x), i3 = Math.max(i3, s3.y);
+        return [e3, n3, r3, i3];
+      }, t2.aJ = bh2, t2.aK = F2, t2.aL = function(t3, e3, n3, r3, i3 = false) {
+        if (!n3[0] && !n3[1]) return [0, 0];
+        const s3 = i3 ? "map" === r3 ? -t3.bearingInRadians : 0 : "viewport" === r3 ? t3.bearingInRadians : 0;
+        if (s3) {
+          const t4 = Math.sin(s3), e4 = Math.cos(s3);
+          n3 = [n3[0] * e4 - n3[1] * t4, n3[0] * t4 + n3[1] * e4];
+        }
+        return [i3 ? n3[0] : F2(e3, n3[0], t3.zoom), i3 ? n3[1] : F2(e3, n3[1], t3.zoom)];
+      }, t2.aN = pp, t2.aO = Fy, t2.aP = Qh2, t2.aQ = (t3) => "symbol" === t3.type, t2.aR = Ku, t2.aS = ro, t2.aT = du, t2.aU = Uo, t2.aV = sa2, t2.aW = ea2, t2.aX = et2, t2.aY = Rp, t2.aZ = b2, t2.a_ = v2, t2.aa = (t3) => {
+        const e3 = window.document.createElement("video");
+        return e3.muted = true, new Promise((n3) => {
+          e3.onloadstart = () => {
+            n3(e3);
+          };
+          for (const n4 of t3) {
+            const t4 = window.document.createElement("source");
+            ft2(n4) || (e3.crossOrigin = "Anonymous"), t4.src = n4, e3.appendChild(t4);
+          }
+        });
+      }, t2.ab = Dt, t2.ac = function() {
+        return $2++;
+      }, t2.ad = Do, t2.ae = vp, t2.af = Gd2, t2.ag = fi2, t2.ah = Na2, t2.ai = Hp, t2.aj = function(t3) {
+        const e3 = {};
+        if (t3.replace(/(?:^|(?:\s*\,\s*))([^\x00-\x20\(\)<>@\,;\:\\"\/\[\]\?\=\{\}\x7F]+)(?:\=(?:([^\x00-\x20\(\)<>@\,;\:\\"\/\[\]\?\=\{\}\x7F]+)|(?:\"((?:[^"\\]|\\.)*)\")))?/g, (t4, n3, r3, i3) => {
+          const s3 = r3 || i3;
+          return e3[n3] = !s3 || s3.toLowerCase(), "";
+        }), e3["max-age"]) {
+          const t4 = parseInt(e3["max-age"], 10);
+          isNaN(t4) ? delete e3["max-age"] : e3["max-age"] = t4;
+        }
+        return e3;
+      }, t2.ak = V2, t2.al = 85.051129, t2.am = tt2, t2.an = function(t3) {
+        return Math.pow(2, t3);
+      }, t2.ao = y2, t2.ap = Lp, t2.aq = function(t3) {
+        return Math.log(t3) / Math.LN2;
+      }, t2.ar = function(t3) {
+        var e3 = t3[0], n3 = t3[1];
+        return e3 * e3 + n3 * n3;
+      }, t2.as = function(t3) {
+        if (!t3.length) return /* @__PURE__ */ new Set();
+        const e3 = Math.max(...t3.map((t4) => t4.canonical.z));
+        let n3 = 1 / 0, r3 = -1 / 0, i3 = 1 / 0, s3 = -1 / 0;
+        const o3 = [];
+        for (const a4 of t3) {
+          const { x: t4, y: l3, z: u3 } = a4.canonical, c3 = Math.pow(2, e3 - u3), h3 = t4 * c3, p3 = l3 * c3;
+          o3.push({ id: a4, x: h3, y: p3 }), h3 < n3 && (n3 = h3), h3 > r3 && (r3 = h3), p3 < i3 && (i3 = p3), p3 > s3 && (s3 = p3);
+        }
+        const a3 = /* @__PURE__ */ new Set();
+        for (const t4 of o3) t4.x !== n3 && t4.x !== r3 && t4.y !== i3 && t4.y !== s3 || a3.add(t4.id);
+        return a3;
+      }, t2.at = function(t3, e3) {
+        const n3 = Math.abs(2 * t3.wrap) - +(t3.wrap < 0), r3 = Math.abs(2 * e3.wrap) - +(e3.wrap < 0);
+        return t3.overscaledZ - e3.overscaledZ || r3 - n3 || e3.canonical.y - t3.canonical.y || e3.canonical.x - t3.canonical.x;
+      }, t2.au = class {
+        constructor(t3, e3) {
+          this.max = t3, this.onRemove = e3, this.reset();
+        }
+        reset() {
+          for (const t3 in this.data) for (const e3 of this.data[t3]) e3.timeout && clearTimeout(e3.timeout), this.onRemove(e3.value);
+          return this.data = {}, this.order = [], this;
+        }
+        add(t3, e3, n3) {
+          const r3 = t3.wrapped().key;
+          void 0 === this.data[r3] && (this.data[r3] = []);
+          const i3 = { value: e3, timeout: void 0 };
+          if (void 0 !== n3 && (i3.timeout = setTimeout(() => {
+            this.remove(t3, i3);
+          }, n3)), this.data[r3].push(i3), this.order.push(r3), this.order.length > this.max) {
+            const t4 = this._getAndRemoveByKey(this.order[0]);
+            t4 && this.onRemove(t4);
+          }
+          return this;
+        }
+        has(t3) {
+          return t3.wrapped().key in this.data;
+        }
+        getAndRemove(t3) {
+          return this.has(t3) ? this._getAndRemoveByKey(t3.wrapped().key) : null;
+        }
+        _getAndRemoveByKey(t3) {
+          const e3 = this.data[t3].shift();
+          return e3.timeout && clearTimeout(e3.timeout), 0 === this.data[t3].length && delete this.data[t3], this.order.splice(this.order.indexOf(t3), 1), e3.value;
+        }
+        getByKey(t3) {
+          const e3 = this.data[t3];
+          return e3 ? e3[0].value : null;
+        }
+        get(t3) {
+          return this.has(t3) ? this.data[t3.wrapped().key][0].value : null;
+        }
+        remove(t3, e3) {
+          if (!this.has(t3)) return this;
+          const n3 = t3.wrapped().key, r3 = void 0 === e3 ? 0 : this.data[n3].indexOf(e3), i3 = this.data[n3][r3];
+          return this.data[n3].splice(r3, 1), i3.timeout && clearTimeout(i3.timeout), 0 === this.data[n3].length && delete this.data[n3], this.onRemove(i3.value), this.order.splice(this.order.indexOf(n3), 1), this;
+        }
+        setMaxSize(t3) {
+          for (this.max = t3; this.order.length > this.max; ) {
+            const t4 = this._getAndRemoveByKey(this.order[0]);
+            t4 && this.onRemove(t4);
+          }
+          return this;
+        }
+        filter(t3) {
+          const e3 = [];
+          for (const n3 in this.data) for (const r3 of this.data[n3]) t3(r3.value) || e3.push(r3);
+          for (const t4 of e3) this.remove(t4.value.tileID, t4);
+        }
+      }, t2.av = function(t3, e3) {
+        let n3 = 0, r3 = 0;
+        if ("constant" === t3.kind) r3 = t3.layoutSize;
+        else if ("source" !== t3.kind) {
+          const { interpolationType: i3, minZoom: s3, maxZoom: o3 } = t3, a3 = i3 ? V2(dn.interpolationFactor(i3, e3, s3, o3), 0, 1) : 0;
+          "camera" === t3.kind ? r3 = mn.number(t3.minSize, t3.maxSize, a3) : n3 = a3;
+        }
+        return { uSizeT: n3, uSize: r3 };
+      }, t2.ax = function(t3, { uSize: e3, uSizeT: n3 }, { lowerSize: r3, upperSize: i3 }) {
+        return "source" === t3.kind ? r3 / up : "composite" === t3.kind ? mn.number(r3 / up, i3 / up, n3) : e3;
+      }, t2.ay = function(t3, e3) {
+        var n3 = e3[0], r3 = e3[1], i3 = e3[2], s3 = e3[3], o3 = e3[4], a3 = e3[5], l3 = e3[6], u3 = e3[7], c3 = e3[8], h3 = e3[9], p3 = e3[10], f3 = e3[11], d3 = e3[12], y3 = e3[13], m3 = e3[14], g3 = e3[15], x3 = n3 * a3 - r3 * o3, v3 = n3 * l3 - i3 * o3, b3 = n3 * u3 - s3 * o3, w3 = r3 * l3 - i3 * a3, _3 = r3 * u3 - s3 * a3, S3 = i3 * u3 - s3 * l3, A3 = c3 * y3 - h3 * d3, M3 = c3 * m3 - p3 * d3, k3 = c3 * g3 - f3 * d3, I3 = h3 * m3 - p3 * y3, E3 = h3 * g3 - f3 * y3, T3 = p3 * g3 - f3 * m3, F3 = x3 * T3 - v3 * E3 + b3 * I3 + w3 * k3 - _3 * M3 + S3 * A3;
+        return F3 ? (t3[0] = (a3 * T3 - l3 * E3 + u3 * I3) * (F3 = 1 / F3), t3[1] = (i3 * E3 - r3 * T3 - s3 * I3) * F3, t3[2] = (y3 * S3 - m3 * _3 + g3 * w3) * F3, t3[3] = (p3 * _3 - h3 * S3 - f3 * w3) * F3, t3[4] = (l3 * k3 - o3 * T3 - u3 * M3) * F3, t3[5] = (n3 * T3 - i3 * k3 + s3 * M3) * F3, t3[6] = (m3 * b3 - d3 * S3 - g3 * v3) * F3, t3[7] = (c3 * S3 - p3 * b3 + f3 * v3) * F3, t3[8] = (o3 * E3 - a3 * k3 + u3 * A3) * F3, t3[9] = (r3 * k3 - n3 * E3 - s3 * A3) * F3, t3[10] = (d3 * _3 - y3 * b3 + g3 * x3) * F3, t3[11] = (h3 * b3 - c3 * _3 - f3 * x3) * F3, t3[12] = (a3 * M3 - o3 * I3 - l3 * A3) * F3, t3[13] = (n3 * I3 - r3 * M3 + i3 * A3) * F3, t3[14] = (y3 * v3 - d3 * w3 - m3 * x3) * F3, t3[15] = (c3 * w3 - h3 * v3 + p3 * x3) * F3, t3) : null;
+      }, t2.az = I2, t2.b = Z2, t2.b$ = Sa2, t2.b0 = function(t3, e3, n3) {
+        return t3[0] = e3[0] - n3[0], t3[1] = e3[1] - n3[1], t3[2] = e3[2] - n3[2], t3;
+      }, t2.b1 = function(t3, e3) {
+        var n3 = e3[0], r3 = e3[1], i3 = e3[2], s3 = n3 * n3 + r3 * r3 + i3 * i3;
+        return s3 > 0 && (s3 = 1 / Math.sqrt(s3)), t3[0] = e3[0] * s3, t3[1] = e3[1] * s3, t3[2] = e3[2] * s3, t3;
+      }, t2.b2 = w2, t2.b3 = function(t3, e3) {
+        return t3[0] * e3[0] + t3[1] * e3[1] + t3[2] * e3[2];
+      }, t2.b4 = function(t3, e3, n3) {
+        return t3[0] = e3[0] * n3[0], t3[1] = e3[1] * n3[1], t3[2] = e3[2] * n3[2], t3[3] = e3[3] * n3[3], t3;
+      }, t2.b5 = g2, t2.b6 = function(t3, e3, n3) {
+        const r3 = e3[0] * n3[0] + e3[1] * n3[1] + e3[2] * n3[2];
+        return 0 === r3 ? null : (-(t3[0] * n3[0] + t3[1] * n3[1] + t3[2] * n3[2]) - n3[3]) / r3;
+      }, t2.b7 = S2, t2.b8 = function(t3, e3, n3) {
+        return t3[0] = e3[0] * n3, t3[1] = e3[1] * n3, t3[2] = e3[2] * n3, t3[3] = e3[3] * n3, t3;
+      }, t2.b9 = function(t3, e3) {
+        return t3[0] * e3[0] + t3[1] * e3[1] + t3[2] * e3[2] + t3[3];
+      }, t2.bA = function(t3, e3, n3) {
+        var r3 = n3[0], i3 = n3[1], s3 = n3[2], o3 = n3[3], a3 = e3[0], l3 = e3[1], u3 = e3[2], c3 = i3 * u3 - s3 * l3, h3 = s3 * a3 - r3 * u3, p3 = r3 * l3 - i3 * a3;
+        return t3[0] = a3 + o3 * (c3 += c3) + i3 * (p3 += p3) - s3 * (h3 += h3), t3[1] = l3 + o3 * h3 + s3 * c3 - r3 * p3, t3[2] = u3 + o3 * p3 + r3 * h3 - i3 * c3, t3;
+      }, t2.bB = function(t3, e3, n3) {
+        const r3 = (i3 = [t3[0], t3[1], t3[2], e3[0], e3[1], e3[2], n3[0], n3[1], n3[2]])[0] * ((c3 = i3[8]) * (o3 = i3[4]) - (a3 = i3[5]) * (u3 = i3[7])) + i3[1] * (-c3 * (s3 = i3[3]) + a3 * (l3 = i3[6])) + i3[2] * (u3 * s3 - o3 * l3);
+        var i3, s3, o3, a3, l3, u3, c3;
+        if (0 === r3) return null;
+        const h3 = w2([], [e3[0], e3[1], e3[2]], [n3[0], n3[1], n3[2]]), p3 = w2([], [n3[0], n3[1], n3[2]], [t3[0], t3[1], t3[2]]), f3 = w2([], [t3[0], t3[1], t3[2]], [e3[0], e3[1], e3[2]]), d3 = b2([], h3, -t3[3]);
+        return v2(d3, d3, b2([], p3, -e3[3])), v2(d3, d3, b2([], f3, -n3[3])), b2(d3, d3, 1 / r3), d3;
+      }, t2.bC = Dp, t2.bD = function() {
+        return new Float64Array(4);
+      }, t2.bE = function(t3, e3, n3, r3) {
+        var i3 = [], s3 = [];
+        return i3[0] = e3[0] - n3[0], i3[1] = e3[1] - n3[1], i3[2] = e3[2] - n3[2], s3[0] = i3[0] * Math.cos(r3) - i3[1] * Math.sin(r3), s3[1] = i3[0] * Math.sin(r3) + i3[1] * Math.cos(r3), s3[2] = i3[2], t3[0] = s3[0] + n3[0], t3[1] = s3[1] + n3[1], t3[2] = s3[2] + n3[2], t3;
+      }, t2.bF = function(t3, e3, n3, r3) {
+        var i3 = [], s3 = [];
+        return i3[0] = e3[0] - n3[0], i3[1] = e3[1] - n3[1], i3[2] = e3[2] - n3[2], s3[0] = i3[0], s3[1] = i3[1] * Math.cos(r3) - i3[2] * Math.sin(r3), s3[2] = i3[1] * Math.sin(r3) + i3[2] * Math.cos(r3), t3[0] = s3[0] + n3[0], t3[1] = s3[1] + n3[1], t3[2] = s3[2] + n3[2], t3;
+      }, t2.bG = function(t3, e3, n3, r3) {
+        var i3 = [], s3 = [];
+        return i3[0] = e3[0] - n3[0], i3[1] = e3[1] - n3[1], i3[2] = e3[2] - n3[2], s3[0] = i3[2] * Math.sin(r3) + i3[0] * Math.cos(r3), s3[1] = i3[1], s3[2] = i3[2] * Math.cos(r3) - i3[0] * Math.sin(r3), t3[0] = s3[0] + n3[0], t3[1] = s3[1] + n3[1], t3[2] = s3[2] + n3[2], t3;
+      }, t2.bH = function(t3, e3, n3) {
+        var r3 = Math.sin(n3), i3 = Math.cos(n3), s3 = e3[0], o3 = e3[1], a3 = e3[2], l3 = e3[3], u3 = e3[8], c3 = e3[9], h3 = e3[10], p3 = e3[11];
+        return e3 !== t3 && (t3[4] = e3[4], t3[5] = e3[5], t3[6] = e3[6], t3[7] = e3[7], t3[12] = e3[12], t3[13] = e3[13], t3[14] = e3[14], t3[15] = e3[15]), t3[0] = s3 * i3 - u3 * r3, t3[1] = o3 * i3 - c3 * r3, t3[2] = a3 * i3 - h3 * r3, t3[3] = l3 * i3 - p3 * r3, t3[8] = s3 * r3 + u3 * i3, t3[9] = o3 * r3 + c3 * i3, t3[10] = a3 * r3 + h3 * i3, t3[11] = l3 * r3 + p3 * i3, t3;
+      }, t2.bI = function(t3, e3) {
+        const n3 = D2(t3, 360), r3 = D2(e3, 360), i3 = r3 - n3, s3 = r3 > n3 ? i3 - 360 : i3 + 360;
+        return Math.abs(i3) < Math.abs(s3) ? i3 : s3;
+      }, t2.bJ = function(t3) {
+        return t3[0] = 0, t3[1] = 0, t3[2] = 0, t3;
+      }, t2.bK = function(t3, e3, n3, r3) {
+        const i3 = Math.sqrt(t3 * t3 + e3 * e3), s3 = Math.sqrt(n3 * n3 + r3 * r3);
+        t3 /= i3, e3 /= i3, n3 /= s3, r3 /= s3;
+        const o3 = Math.acos(t3 * n3 + e3 * r3);
+        return -e3 * n3 + t3 * r3 > 0 ? o3 : -o3;
+      }, t2.bL = function(t3, e3) {
+        const n3 = D2(t3, 2 * Math.PI), r3 = D2(e3, 2 * Math.PI);
+        return Math.min(Math.abs(n3 - r3), Math.abs(n3 - r3 + 2 * Math.PI), Math.abs(n3 - r3 - 2 * Math.PI));
+      }, t2.bM = function() {
+        const t3 = {}, e3 = vt.$version;
+        for (const n3 in vt.$root) {
+          const r3 = vt.$root[n3];
+          if (r3.required) {
+            let i3 = null;
+            i3 = "version" === n3 ? e3 : "array" === r3.type ? [] : {}, null != i3 && (t3[n3] = i3);
+          }
+        }
+        return t3;
+      }, t2.bN = ht2, t2.bO = xs, t2.bP = function t3(e3, n3) {
+        if (Array.isArray(e3)) {
+          if (!Array.isArray(n3) || e3.length !== n3.length) return false;
+          for (let r3 = 0; r3 < e3.length; r3++) if (!t3(e3[r3], n3[r3])) return false;
+          return true;
+        }
+        if ("object" == typeof e3 && null !== e3 && null !== n3) {
+          if ("object" != typeof n3) return false;
+          if (Object.keys(e3).length !== Object.keys(n3).length) return false;
+          for (const r3 in e3) if (!t3(e3[r3], n3[r3])) return false;
+          return true;
+        }
+        return e3 === n3;
+      }, t2.bQ = function(t3) {
+        t3 = t3.slice();
+        const e3 = /* @__PURE__ */ Object.create(null);
+        for (let n3 = 0; n3 < t3.length; n3++) e3[t3[n3].id] = t3[n3];
+        for (let n3 = 0; n3 < t3.length; n3++) "ref" in t3[n3] && (t3[n3] = wt(t3[n3], e3[t3[n3].ref]));
+        return t3;
+      }, t2.bR = function(t3, e3) {
+        if ("custom" === t3.type) return new Ep(t3, e3);
+        switch (t3.type) {
+          case "background":
+            return new Ip(t3, e3);
+          case "circle":
+            return new yl(t3, e3);
+          case "color-relief":
+            return new Ll(t3, e3);
+          case "fill":
+            return new Iu(t3, e3);
+          case "fill-extrusion":
+            return new Yu(t3, e3);
+          case "heatmap":
+            return new Il(t3, e3);
+          case "hillshade":
+            return new Fl(t3, e3);
+          case "line":
+            return new ph2(t3, e3);
+          case "raster":
+            return new Qs(t3, e3);
+          case "symbol":
+            return new Ap(t3, e3);
+        }
+      }, t2.bS = (t3) => "raster" === t3.type, t2.bT = U2, t2.bU = function(t3, e3) {
+        if (!t3) return [{ command: "setStyle", args: [e3] }];
+        let n3 = [];
+        try {
+          if (!_t2(t3.version, e3.version)) return [{ command: "setStyle", args: [e3] }];
+          _t2(t3.center, e3.center) || n3.push({ command: "setCenter", args: [e3.center] }), _t2(t3.state, e3.state) || n3.push({ command: "setGlobalState", args: [e3.state] }), _t2(t3.centerAltitude, e3.centerAltitude) || n3.push({ command: "setCenterAltitude", args: [e3.centerAltitude] }), _t2(t3.zoom, e3.zoom) || n3.push({ command: "setZoom", args: [e3.zoom] }), _t2(t3.bearing, e3.bearing) || n3.push({ command: "setBearing", args: [e3.bearing] }), _t2(t3.pitch, e3.pitch) || n3.push({ command: "setPitch", args: [e3.pitch] }), _t2(t3.roll, e3.roll) || n3.push({ command: "setRoll", args: [e3.roll] }), _t2(t3.sprite, e3.sprite) || n3.push({ command: "setSprite", args: [e3.sprite] }), _t2(t3.glyphs, e3.glyphs) || n3.push({ command: "setGlyphs", args: [e3.glyphs] }), _t2(t3.transition, e3.transition) || n3.push({ command: "setTransition", args: [e3.transition] }), _t2(t3.light, e3.light) || n3.push({ command: "setLight", args: [e3.light] }), _t2(t3.terrain, e3.terrain) || n3.push({ command: "setTerrain", args: [e3.terrain] }), _t2(t3.sky, e3.sky) || n3.push({ command: "setSky", args: [e3.sky] }), _t2(t3.projection, e3.projection) || n3.push({ command: "setProjection", args: [e3.projection] });
+          const r3 = {}, i3 = [];
+          !function(t4, e4, n4, r4) {
+            let i4;
+            for (i4 in e4 = e4 || {}, t4 = t4 || {}) Object.prototype.hasOwnProperty.call(t4, i4) && (Object.prototype.hasOwnProperty.call(e4, i4) || Mt(i4, n4, r4));
+            for (i4 in e4) Object.prototype.hasOwnProperty.call(e4, i4) && (Object.prototype.hasOwnProperty.call(t4, i4) ? _t2(t4[i4], e4[i4]) || ("geojson" === t4[i4].type && "geojson" === e4[i4].type && It(t4, e4, i4) ? St(n4, { command: "setGeoJSONSourceData", args: [i4, e4[i4].data] }) : kt(i4, e4, n4, r4)) : At(i4, e4, n4));
+          }(t3.sources, e3.sources, i3, r3);
+          const s3 = [];
+          t3.layers && t3.layers.forEach((t4) => {
+            "source" in t4 && r3[t4.source] ? n3.push({ command: "removeLayer", args: [t4.id] }) : s3.push(t4);
+          }), n3 = n3.concat(i3), function(t4, e4, n4) {
+            e4 = e4 || [];
+            const r4 = (t4 = t4 || []).map(Tt), i4 = e4.map(Tt), s4 = t4.reduce(Ft, {}), o3 = e4.reduce(Ft, {}), a3 = r4.slice(), l3 = /* @__PURE__ */ Object.create(null);
+            let u3, c3, h3, p3, f3;
+            for (let t5 = 0, e5 = 0; t5 < r4.length; t5++) u3 = r4[t5], Object.prototype.hasOwnProperty.call(o3, u3) ? e5++ : (St(n4, { command: "removeLayer", args: [u3] }), a3.splice(a3.indexOf(u3, e5), 1));
+            for (let t5 = 0, e5 = 0; t5 < i4.length; t5++) u3 = i4[i4.length - 1 - t5], a3[a3.length - 1 - t5] !== u3 && (Object.prototype.hasOwnProperty.call(s4, u3) ? (St(n4, { command: "removeLayer", args: [u3] }), a3.splice(a3.lastIndexOf(u3, a3.length - e5), 1)) : e5++, p3 = a3[a3.length - t5], St(n4, { command: "addLayer", args: [o3[u3], p3] }), a3.splice(a3.length - t5, 0, u3), l3[u3] = true);
+            for (let t5 = 0; t5 < i4.length; t5++) if (u3 = i4[t5], c3 = s4[u3], h3 = o3[u3], !l3[u3] && !_t2(c3, h3)) if (_t2(c3.source, h3.source) && _t2(c3["source-layer"], h3["source-layer"]) && _t2(c3.type, h3.type)) {
+              for (f3 in Et(c3.layout, h3.layout, n4, u3, null, "setLayoutProperty"), Et(c3.paint, h3.paint, n4, u3, null, "setPaintProperty"), _t2(c3.filter, h3.filter) || St(n4, { command: "setFilter", args: [u3, h3.filter] }), _t2(c3.minzoom, h3.minzoom) && _t2(c3.maxzoom, h3.maxzoom) || St(n4, { command: "setLayerZoomRange", args: [u3, h3.minzoom, h3.maxzoom] }), c3) Object.prototype.hasOwnProperty.call(c3, f3) && "layout" !== f3 && "paint" !== f3 && "filter" !== f3 && "metadata" !== f3 && "minzoom" !== f3 && "maxzoom" !== f3 && (0 === f3.indexOf("paint.") ? Et(c3[f3], h3[f3], n4, u3, f3.slice(6), "setPaintProperty") : _t2(c3[f3], h3[f3]) || St(n4, { command: "setLayerProperty", args: [u3, f3, h3[f3]] }));
+              for (f3 in h3) Object.prototype.hasOwnProperty.call(h3, f3) && !Object.prototype.hasOwnProperty.call(c3, f3) && "layout" !== f3 && "paint" !== f3 && "filter" !== f3 && "metadata" !== f3 && "minzoom" !== f3 && "maxzoom" !== f3 && (0 === f3.indexOf("paint.") ? Et(c3[f3], h3[f3], n4, u3, f3.slice(6), "setPaintProperty") : _t2(c3[f3], h3[f3]) || St(n4, { command: "setLayerProperty", args: [u3, f3, h3[f3]] }));
+            } else St(n4, { command: "removeLayer", args: [u3] }), p3 = a3[a3.lastIndexOf(u3) + 1], St(n4, { command: "addLayer", args: [h3, p3] });
+          }(s3, e3.layers, n3);
+        } catch (t4) {
+          console.warn("Unable to compute style diff:", t4), n3 = [{ command: "setStyle", args: [e3] }];
+        }
+        return n3;
+      }, t2.bV = function(t3) {
+        const e3 = [], n3 = t3.id;
+        return void 0 === n3 && e3.push({ message: `layers.${n3}: missing required property "id"` }), void 0 === t3.render && e3.push({ message: `layers.${n3}: missing required method "render"` }), t3.renderingMode && "2d" !== t3.renderingMode && "3d" !== t3.renderingMode && e3.push({ message: `layers.${n3}: property "renderingMode" must be either "2d" or "3d"` }), e3;
+      }, t2.bW = R2, t2.bX = N2, t2.bY = class extends wa2 {
+        constructor(t3, e3) {
+          super(t3, e3), this.current = 0;
+        }
+        set(t3) {
+          this.current !== t3 && (this.current = t3, this.gl.uniform1i(this.location, t3));
+        }
+      }, t2.bZ = Aa2, t2.b_ = class extends wa2 {
+        constructor(t3, e3) {
+          super(t3, e3), this.current = Ma2;
+        }
+        set(t3) {
+          if (t3[12] !== this.current[12] || t3[0] !== this.current[0]) return this.current = t3, void this.gl.uniformMatrix4fv(this.location, false, t3);
+          for (let e3 = 1; e3 < 16; e3++) if (t3[e3] !== this.current[e3]) {
+            this.current = t3, this.gl.uniformMatrix4fv(this.location, false, t3);
+            break;
+          }
+        }
+      }, t2.ba = qp, t2.bb = Xp, t2.bc = function(t3, e3, n3, r3, i3) {
+        var s3 = 1 / Math.tan(e3 / 2);
+        if (t3[0] = s3 / n3, t3[1] = 0, t3[2] = 0, t3[3] = 0, t3[4] = 0, t3[5] = s3, t3[6] = 0, t3[7] = 0, t3[8] = 0, t3[9] = 0, t3[11] = -1, t3[12] = 0, t3[13] = 0, t3[15] = 0, null != i3 && i3 !== 1 / 0) {
+          var o3 = 1 / (r3 - i3);
+          t3[10] = (i3 + r3) * o3, t3[14] = 2 * i3 * r3 * o3;
+        } else t3[10] = -1, t3[14] = -2 * r3;
+        return t3;
+      }, t2.bd = function(t3) {
+        var e3 = new f2(16);
+        return e3[0] = t3[0], e3[1] = t3[1], e3[2] = t3[2], e3[3] = t3[3], e3[4] = t3[4], e3[5] = t3[5], e3[6] = t3[6], e3[7] = t3[7], e3[8] = t3[8], e3[9] = t3[9], e3[10] = t3[10], e3[11] = t3[11], e3[12] = t3[12], e3[13] = t3[13], e3[14] = t3[14], e3[15] = t3[15], e3;
+      }, t2.be = function(t3, e3, n3) {
+        var r3 = Math.sin(n3), i3 = Math.cos(n3), s3 = e3[0], o3 = e3[1], a3 = e3[2], l3 = e3[3], u3 = e3[4], c3 = e3[5], h3 = e3[6], p3 = e3[7];
+        return e3 !== t3 && (t3[8] = e3[8], t3[9] = e3[9], t3[10] = e3[10], t3[11] = e3[11], t3[12] = e3[12], t3[13] = e3[13], t3[14] = e3[14], t3[15] = e3[15]), t3[0] = s3 * i3 + u3 * r3, t3[1] = o3 * i3 + c3 * r3, t3[2] = a3 * i3 + h3 * r3, t3[3] = l3 * i3 + p3 * r3, t3[4] = u3 * i3 - s3 * r3, t3[5] = c3 * i3 - o3 * r3, t3[6] = h3 * i3 - a3 * r3, t3[7] = p3 * i3 - l3 * r3, t3;
+      }, t2.bf = function(t3, e3, n3) {
+        var r3 = Math.sin(n3), i3 = Math.cos(n3), s3 = e3[4], o3 = e3[5], a3 = e3[6], l3 = e3[7], u3 = e3[8], c3 = e3[9], h3 = e3[10], p3 = e3[11];
+        return e3 !== t3 && (t3[0] = e3[0], t3[1] = e3[1], t3[2] = e3[2], t3[3] = e3[3], t3[12] = e3[12], t3[13] = e3[13], t3[14] = e3[14], t3[15] = e3[15]), t3[4] = s3 * i3 + u3 * r3, t3[5] = o3 * i3 + c3 * r3, t3[6] = a3 * i3 + h3 * r3, t3[7] = l3 * i3 + p3 * r3, t3[8] = u3 * i3 - s3 * r3, t3[9] = c3 * i3 - o3 * r3, t3[10] = h3 * i3 - a3 * r3, t3[11] = p3 * i3 - l3 * r3, t3;
+      }, t2.bg = function() {
+        const t3 = new Float32Array(16);
+        return y2(t3), t3;
+      }, t2.bh = function() {
+        const t3 = new Float64Array(16);
+        return y2(t3), t3;
+      }, t2.bi = function() {
+        return new Float64Array(16);
+      }, t2.bj = function(t3, e3, n3) {
+        const r3 = new Float64Array(4);
+        return k2(r3, t3, e3 - 90, n3), r3;
+      }, t2.bk = function(t3, e3, n3, r3) {
+        var i3, s3, o3, a3, l3, u3 = e3[0], c3 = e3[1], h3 = e3[2], f3 = e3[3], d3 = n3[0], y3 = n3[1], m3 = n3[2], g3 = n3[3];
+        return (s3 = u3 * d3 + c3 * y3 + h3 * m3 + f3 * g3) < 0 && (s3 = -s3, d3 = -d3, y3 = -y3, m3 = -m3, g3 = -g3), 1 - s3 > p2 ? (i3 = Math.acos(s3), o3 = Math.sin(i3), a3 = Math.sin((1 - r3) * i3) / o3, l3 = Math.sin(r3 * i3) / o3) : (a3 = 1 - r3, l3 = r3), t3[0] = a3 * u3 + l3 * d3, t3[1] = a3 * c3 + l3 * y3, t3[2] = a3 * h3 + l3 * m3, t3[3] = a3 * f3 + l3 * g3, t3;
+      }, t2.bl = function(t3) {
+        const e3 = new Float64Array(9);
+        var n3, r3, i3, s3, o3, a3, l3, u3, c3, h3, p3, f3, d3, y3, m3, g3, x3, v3;
+        h3 = (i3 = (r3 = t3)[0]) * (l3 = i3 + i3), p3 = (s3 = r3[1]) * l3, d3 = (o3 = r3[2]) * l3, y3 = o3 * (u3 = s3 + s3), g3 = (a3 = r3[3]) * l3, x3 = a3 * u3, v3 = a3 * (c3 = o3 + o3), (n3 = e3)[0] = 1 - (f3 = s3 * u3) - (m3 = o3 * c3), n3[3] = p3 - v3, n3[6] = d3 + x3, n3[1] = p3 + v3, n3[4] = 1 - h3 - m3, n3[7] = y3 - g3, n3[2] = d3 - x3, n3[5] = y3 + g3, n3[8] = 1 - h3 - f3;
+        const b3 = et2(-Math.asin(V2(e3[2], -1, 1)));
+        let w3, _3;
+        return Math.hypot(e3[5], e3[8]) < 1e-3 ? (w3 = 0, _3 = -et2(Math.atan2(e3[3], e3[4]))) : (w3 = et2(0 === e3[5] && 0 === e3[8] ? 0 : Math.atan2(e3[5], e3[8])), _3 = et2(0 === e3[1] && 0 === e3[0] ? 0 : Math.atan2(e3[1], e3[0]))), { roll: w3, pitch: b3 + 90, bearing: _3 };
+      }, t2.bm = function(t3, e3) {
+        return t3.roll == e3.roll && t3.pitch == e3.pitch && t3.bearing == e3.bearing;
+      }, t2.bn = Ie2, t2.bo = _a3, t2.bp = yu, t2.bq = mu, t2.br = fu, t2.bs = P2, t2.bt = z2, t2.bu = $e2, t2.bv = function(t3, e3, n3, r3, i3) {
+        return P2(r3, i3, V2((t3 - e3) / (n3 - e3), 0, 1));
+      }, t2.bw = function(t3, e3, n3, r3) {
+        return t3[0] = e3[0] + n3[0] * r3, t3[1] = e3[1] + n3[1] * r3, t3[2] = e3[2] + n3[2] * r3, t3;
+      }, t2.bx = D2, t2.by = function() {
+        return new Float64Array(3);
+      }, t2.bz = k2, t2.c = at2, t2.c$ = class {
+        constructor(t3, e3) {
+          this.layers = { [Gd2]: this }, this.name = Gd2, this.version = e3 ? e3.version : 1, this.extent = e3 ? e3.extent : 4096, this.length = t3.length, this.features = t3;
+        }
+        feature(t3) {
+          return new qd2(this.features[t3], this.extent);
+        }
+      }, t2.c0 = class extends wa2 {
+        constructor(t3, e3) {
+          super(t3, e3), this.current = [0, 0, 0];
+        }
+        set(t3) {
+          t3[0] === this.current[0] && t3[1] === this.current[1] && t3[2] === this.current[2] || (this.current = t3, this.gl.uniform3f(this.location, t3[0], t3[1], t3[2]));
+        }
+      }, t2.c1 = class extends wa2 {
+        constructor(t3, e3) {
+          super(t3, e3), this.current = [0, 0];
+        }
+        set(t3) {
+          t3[0] === this.current[0] && t3[1] === this.current[1] || (this.current = t3, this.gl.uniform2f(this.location, t3[0], t3[1]));
+        }
+      }, t2.c2 = d2, t2.c3 = function(t3, e3) {
+        var n3 = Math.sin(e3), r3 = Math.cos(e3);
+        return t3[0] = r3, t3[1] = n3, t3[2] = 0, t3[3] = -n3, t3[4] = r3, t3[5] = 0, t3[6] = 0, t3[7] = 0, t3[8] = 1, t3;
+      }, t2.c4 = function(t3, e3, n3) {
+        var r3 = e3[0], i3 = e3[1], s3 = e3[2];
+        return t3[0] = r3 * n3[0] + i3 * n3[3] + s3 * n3[6], t3[1] = r3 * n3[1] + i3 * n3[4] + s3 * n3[7], t3[2] = r3 * n3[2] + i3 * n3[5] + s3 * n3[8], t3;
+      }, t2.c5 = function(t3, e3, n3, r3, i3, s3, o3) {
+        var a3 = 1 / (e3 - n3), l3 = 1 / (r3 - i3), u3 = 1 / (s3 - o3);
+        return t3[0] = -2 * a3, t3[1] = 0, t3[2] = 0, t3[3] = 0, t3[4] = 0, t3[5] = -2 * l3, t3[6] = 0, t3[7] = 0, t3[8] = 0, t3[9] = 0, t3[10] = 2 * u3, t3[11] = 0, t3[12] = (e3 + n3) * a3, t3[13] = (i3 + r3) * l3, t3[14] = (o3 + s3) * u3, t3[15] = 1, t3;
+      }, t2.c6 = class extends wa2 {
+        constructor(t3, e3) {
+          super(t3, e3), this.current = new Array();
+        }
+        set(t3) {
+          if (t3 != this.current) {
+            this.current = t3;
+            const e3 = new Float32Array(4 * t3.length);
+            for (let n3 = 0; n3 < t3.length; n3++) e3[4 * n3] = t3[n3].r, e3[4 * n3 + 1] = t3[n3].g, e3[4 * n3 + 2] = t3[n3].b, e3[4 * n3 + 3] = t3[n3].a;
+            this.gl.uniform4fv(this.location, e3);
+          }
+        }
+      }, t2.c7 = class extends wa2 {
+        constructor(t3, e3) {
+          super(t3, e3), this.current = new Array();
+        }
+        set(t3) {
+          if (t3 != this.current) {
+            this.current = t3;
+            const e3 = new Float32Array(t3);
+            this.gl.uniform1fv(this.location, e3);
+          }
+        }
+      }, t2.c8 = class extends vo {
+      }, t2.c9 = xh2, t2.cA = function(t3, e3, n3) {
+        var r3 = e3[0], i3 = e3[1];
+        return t3[0] = n3[0] * r3 + n3[4] * i3 + n3[12], t3[1] = n3[1] * r3 + n3[5] * i3 + n3[13], t3;
+      }, t2.cB = function(t3, e3) {
+        const { x: n3, y: r3 } = Np.fromLngLat(e3);
+        return !(t3 < 0 || t3 > 25 || r3 < 0 || r3 >= 1 || n3 < 0 || n3 >= 1);
+      }, t2.cC = function(t3, e3) {
+        return t3[0] = e3[0], t3[1] = 0, t3[2] = 0, t3[3] = 0, t3[4] = 0, t3[5] = e3[1], t3[6] = 0, t3[7] = 0, t3[8] = 0, t3[9] = 0, t3[10] = e3[2], t3[11] = 0, t3[12] = 0, t3[13] = 0, t3[14] = 0, t3[15] = 1, t3;
+      }, t2.cD = class extends oo {
+      }, t2.cE = Ny, t2.cG = ct2, t2.cH = function(t3, e3) {
+        at2.REGISTERED_PROTOCOLS[t3] = e3;
+      }, t2.cI = function(t3) {
+        delete at2.REGISTERED_PROTOCOLS[t3];
+      }, t2.cJ = function(t3, e3) {
+        const n3 = {};
+        for (let r4 = 0; r4 < t3.length; r4++) {
+          const i3 = e3 && e3[t3[r4].id] || _i(t3[r4]);
+          e3 && (e3[t3[r4].id] = i3);
+          let s3 = n3[i3];
+          s3 || (s3 = n3[i3] = []), s3.push(t3[r4]);
+        }
+        const r3 = [];
+        for (const t4 in n3) r3.push(n3[t4]);
+        return r3;
+      }, t2.cK = ps, t2.cL = Zp, t2.cM = Qd2, t2.cN = Wh2, t2.cO = function(e3) {
+        var n3;
+        e3.bucket.createArrays(), e3.bucket.tilePixelRatio = T2 / (512 * e3.bucket.overscaling), e3.bucket.compareText = {}, e3.bucket.iconsNeedLinear = false;
+        const r3 = e3.bucket.layers[0], i3 = r3.layout, s3 = r3._unevaluatedLayout._values, o3 = { layoutIconSize: s3["icon-size"].possiblyEvaluate(new zs(e3.bucket.zoom + 1), e3.canonical), layoutTextSize: s3["text-size"].possiblyEvaluate(new zs(e3.bucket.zoom + 1), e3.canonical), textMaxSize: s3["text-size"].possiblyEvaluate(new zs(18)) };
+        if ("composite" === e3.bucket.textSizeData.kind) {
+          const { minZoom: t3, maxZoom: n4 } = e3.bucket.textSizeData;
+          o3.compositeTextSizes = [s3["text-size"].possiblyEvaluate(new zs(t3), e3.canonical), s3["text-size"].possiblyEvaluate(new zs(n4), e3.canonical)];
+        }
+        if ("composite" === e3.bucket.iconSizeData.kind) {
+          const { minZoom: t3, maxZoom: n4 } = e3.bucket.iconSizeData;
+          o3.compositeIconSizes = [s3["icon-size"].possiblyEvaluate(new zs(t3), e3.canonical), s3["icon-size"].possiblyEvaluate(new zs(n4), e3.canonical)];
+        }
+        const a3 = i3.get("text-line-height") * bh2, l3 = "viewport" !== i3.get("text-rotation-alignment") && "point" !== i3.get("symbol-placement"), u3 = i3.get("text-keep-upright"), c3 = i3.get("text-size");
+        for (const s4 of e3.bucket.features) {
+          const h3 = i3.get("text-font").evaluate(s4, {}, e3.canonical).join(","), p3 = c3.evaluate(s4, {}, e3.canonical), f3 = o3.layoutTextSize.evaluate(s4, {}, e3.canonical), d3 = o3.layoutIconSize.evaluate(s4, {}, e3.canonical), y3 = { horizontal: {}, vertical: void 0 }, m3 = s4.text;
+          let g3, x3 = [0, 0];
+          if (m3) {
+            const n4 = m3.toString(), o4 = i3.get("text-letter-spacing").evaluate(s4, {}, e3.canonical) * bh2, c4 = Ss(n4) ? o4 : 0, d4 = i3.get("text-anchor").evaluate(s4, {}, e3.canonical), g4 = Ty(r3, s4, e3.canonical);
+            if (!g4) {
+              const t3 = i3.get("text-radial-offset").evaluate(s4, {}, e3.canonical);
+              x3 = t3 ? Ey(d4, [t3 * bh2, Iy]) : i3.get("text-offset").evaluate(s4, {}, e3.canonical).map((t4) => t4 * bh2);
+            }
+            let v4 = l3 ? "center" : i3.get("text-justify").evaluate(s4, {}, e3.canonical);
+            const b4 = "point" === i3.get("symbol-placement") ? i3.get("text-max-width").evaluate(s4, {}, e3.canonical) * bh2 : 1 / 0, w3 = () => {
+              e3.bucket.allowVerticalPlacement && _s2(n4) && (y3.vertical = Jh2(m3, e3.glyphMap, e3.glyphPositions, e3.imagePositions, h3, b4, a3, d4, "left", c4, x3, t2.aw.vertical, true, f3, p3));
+            };
+            if (!l3 && g4) {
+              const n5 = /* @__PURE__ */ new Set();
+              if ("auto" === v4) for (let t3 = 0; t3 < g4.values.length; t3 += 2) n5.add(Fy(g4.values[t3]));
+              else n5.add(v4);
+              let r4 = false;
+              for (const i4 of n5) if (!y3.horizontal[i4]) if (r4) y3.horizontal[i4] = y3.horizontal[0];
+              else {
+                const n6 = Jh2(m3, e3.glyphMap, e3.glyphPositions, e3.imagePositions, h3, b4, a3, "center", i4, c4, x3, t2.aw.horizontal, false, f3, p3);
+                n6 && (y3.horizontal[i4] = n6, r4 = 1 === n6.positionedLines.length);
+              }
+              w3();
+            } else {
+              "auto" === v4 && (v4 = Fy(d4));
+              const r4 = Jh2(m3, e3.glyphMap, e3.glyphPositions, e3.imagePositions, h3, b4, a3, d4, v4, c4, x3, t2.aw.horizontal, false, f3, p3);
+              r4 && (y3.horizontal[v4] = r4), w3(), _s2(n4) && l3 && u3 && (y3.vertical = Jh2(m3, e3.glyphMap, e3.glyphPositions, e3.imagePositions, h3, b4, a3, d4, v4, c4, x3, t2.aw.vertical, false, f3, p3));
+            }
+          }
+          let v3 = false;
+          if (s4.icon && s4.icon.name) {
+            const t3 = e3.imageMap[s4.icon.name];
+            t3 && (g3 = op(e3.imagePositions[s4.icon.name], i3.get("icon-offset").evaluate(s4, {}, e3.canonical), i3.get("icon-anchor").evaluate(s4, {}, e3.canonical)), v3 = !!t3.sdf, void 0 === e3.bucket.sdfIcons ? e3.bucket.sdfIcons = v3 : e3.bucket.sdfIcons !== v3 && q2("Style sheet warning: Cannot mix SDF and non-SDF icons in one buffer"), (t3.pixelRatio !== e3.bucket.pixelRatio || 0 !== i3.get("icon-rotate").constantOr(1)) && (e3.bucket.iconsNeedLinear = true));
+          }
+          const b3 = zy(y3.horizontal) || y3.vertical;
+          (n3 = e3.bucket).iconsInText || (n3.iconsInText = !!b3 && b3.iconsInText), (b3 || g3) && Dy(e3.bucket, s4, y3, g3, e3.imageMap, o3, f3, d3, x3, v3, e3.canonical, e3.subdivisionGranularity);
+        }
+        e3.showCollisionBoxes && e3.bucket.generateCollisionDebugBuffers();
+      }, t2.cP = Su, t2.cQ = Nu, t2.cR = oh2, t2.cS = function(t3, e3 = "") {
+        const n3 = new zh2();
+        return function(t4, e4, n4 = "") {
+          for (const r3 in t4.layers) e4.writeMessage(3, (t5, e5) => Xd2(t5, e5, n4), t4.layers[r3]);
+        }(t3, n3, e3), n3.finish();
+      }, t2.cT = function(t3, e3, n3, r3, i3, s3) {
+        let o3 = ry(t3, e3, n3, i3, 0);
+        return o3 = ry(o3, e3, r3, s3, 1), o3;
+      }, t2.cU = class {
+        constructor(t3) {
+          this.maxEntries = t3, this.map = /* @__PURE__ */ new Map();
+        }
+        get(t3) {
+          const e3 = this.map.get(t3);
+          return void 0 !== e3 && (this.map.delete(t3), this.map.set(t3, e3)), e3;
+        }
+        set(t3, e3) {
+          if (this.map.has(t3)) this.map.delete(t3);
+          else if (this.map.size >= this.maxEntries) {
+            const t4 = this.map.keys().next().value;
+            this.map.delete(t4);
+          }
+          this.map.set(t3, e3);
+        }
+        clear() {
+          this.map.clear();
+        }
+      }, t2.cV = Lu, t2.cW = zh2, t2.cX = jd2, t2.cY = class {
+        constructor(t3) {
+          this.start = `${t3}#start`, this.end = `${t3}#end`, this.measure = t3, performance.mark(this.start);
+        }
+        finish() {
+          performance.mark(this.end);
+          let t3 = performance.getEntriesByName(this.measure);
+          return 0 === t3.length && (performance.measure(this.measure, this.start, this.end), t3 = performance.getEntriesByName(this.measure), performance.clearMarks(this.start), performance.clearMarks(this.end), performance.clearMeasures(this.measure)), t3;
+        }
+      }, t2.cZ = function(t3, n3, r3, i3, s3) {
+        return e2(this, void 0, void 0, function* () {
+          if (h2()) try {
+            return yield W2(t3, n3, r3, i3, s3);
+          } catch (t4) {
+          }
+          return function(t4, e3, n4, r4, i4) {
+            const s4 = t4.width, o3 = t4.height;
+            K2 && J2 || (K2 = new OffscreenCanvas(s4, o3), J2 = K2.getContext("2d", { willReadFrequently: true })), K2.width = s4, K2.height = o3, J2.drawImage(t4, 0, 0, s4, o3);
+            const a3 = J2.getImageData(e3, n4, r4, i4);
+            return J2.clearRect(0, 0, s4, o3), a3.data;
+          }(t3, n3, r3, i3, s3);
+        });
+      }, t2.c_ = Cl, t2.ca = class extends wo {
+      }, t2.cb = kl2, t2.cc = function(t3) {
+        return t3 <= 1 ? 1 : Math.pow(2, Math.ceil(Math.log(t3) / Math.LN2));
+      }, t2.cd = Ml, t2.ce = function(t3, e3, n3) {
+        var r3 = e3[0], i3 = e3[1], s3 = e3[2], o3 = n3[3] * r3 + n3[7] * i3 + n3[11] * s3 + n3[15];
+        return t3[0] = (n3[0] * r3 + n3[4] * i3 + n3[8] * s3 + n3[12]) / (o3 = o3 || 1), t3[1] = (n3[1] * r3 + n3[5] * i3 + n3[9] * s3 + n3[13]) / o3, t3[2] = (n3[2] * r3 + n3[6] * i3 + n3[10] * s3 + n3[14]) / o3, t3;
+      }, t2.cf = class extends ao {
+      }, t2.cg = class extends Eo {
+      }, t2.ch = function(t3, e3) {
+        return t3[0] === e3[0] && t3[1] === e3[1] && t3[2] === e3[2] && t3[3] === e3[3] && t3[4] === e3[4] && t3[5] === e3[5] && t3[6] === e3[6] && t3[7] === e3[7] && t3[8] === e3[8] && t3[9] === e3[9] && t3[10] === e3[10] && t3[11] === e3[11] && t3[12] === e3[12] && t3[13] === e3[13] && t3[14] === e3[14] && t3[15] === e3[15];
+      }, t2.ci = function(t3, e3) {
+        var n3 = t3[0], r3 = t3[1], i3 = t3[2], s3 = t3[3], o3 = t3[4], a3 = t3[5], l3 = t3[6], u3 = t3[7], c3 = t3[8], h3 = t3[9], f3 = t3[10], d3 = t3[11], y3 = t3[12], m3 = t3[13], g3 = t3[14], x3 = t3[15], v3 = e3[0], b3 = e3[1], w3 = e3[2], _3 = e3[3], S3 = e3[4], A3 = e3[5], M3 = e3[6], k3 = e3[7], I3 = e3[8], E3 = e3[9], T3 = e3[10], F3 = e3[11], D3 = e3[12], P3 = e3[13], z3 = e3[14], B3 = e3[15];
+        return Math.abs(n3 - v3) <= p2 * Math.max(1, Math.abs(n3), Math.abs(v3)) && Math.abs(r3 - b3) <= p2 * Math.max(1, Math.abs(r3), Math.abs(b3)) && Math.abs(i3 - w3) <= p2 * Math.max(1, Math.abs(i3), Math.abs(w3)) && Math.abs(s3 - _3) <= p2 * Math.max(1, Math.abs(s3), Math.abs(_3)) && Math.abs(o3 - S3) <= p2 * Math.max(1, Math.abs(o3), Math.abs(S3)) && Math.abs(a3 - A3) <= p2 * Math.max(1, Math.abs(a3), Math.abs(A3)) && Math.abs(l3 - M3) <= p2 * Math.max(1, Math.abs(l3), Math.abs(M3)) && Math.abs(u3 - k3) <= p2 * Math.max(1, Math.abs(u3), Math.abs(k3)) && Math.abs(c3 - I3) <= p2 * Math.max(1, Math.abs(c3), Math.abs(I3)) && Math.abs(h3 - E3) <= p2 * Math.max(1, Math.abs(h3), Math.abs(E3)) && Math.abs(f3 - T3) <= p2 * Math.max(1, Math.abs(f3), Math.abs(T3)) && Math.abs(d3 - F3) <= p2 * Math.max(1, Math.abs(d3), Math.abs(F3)) && Math.abs(y3 - D3) <= p2 * Math.max(1, Math.abs(y3), Math.abs(D3)) && Math.abs(m3 - P3) <= p2 * Math.max(1, Math.abs(m3), Math.abs(P3)) && Math.abs(g3 - z3) <= p2 * Math.max(1, Math.abs(g3), Math.abs(z3)) && Math.abs(x3 - B3) <= p2 * Math.max(1, Math.abs(x3), Math.abs(B3));
+      }, t2.cj = function(t3, e3) {
+        return t3[0] = e3[0], t3[1] = e3[1], t3[2] = e3[2], t3[3] = e3[3], t3[4] = e3[4], t3[5] = e3[5], t3[6] = e3[6], t3[7] = e3[7], t3[8] = e3[8], t3[9] = e3[9], t3[10] = e3[10], t3[11] = e3[11], t3[12] = e3[12], t3[13] = e3[13], t3[14] = e3[14], t3[15] = e3[15], t3;
+      }, t2.ck = (t3) => "circle" === t3.type, t2.cl = (t3) => "heatmap" === t3.type, t2.cm = (t3) => "line" === t3.type, t2.cn = (t3) => "fill" === t3.type, t2.co = (t3) => "fill-extrusion" === t3.type, t2.cp = (t3) => "hillshade" === t3.type, t2.cq = (t3) => "color-relief" === t3.type, t2.cr = (t3) => "background" === t3.type, t2.cs = (t3) => "custom" === t3.type, t2.ct = B2, t2.cu = function(t3, e3, n3) {
+        if (e3 <= 0) return t3;
+        const r3 = 1 / e3;
+        return void 0 === n3 || Math.abs(n3) < 1e-10 ? Math.round(t3 * r3) / r3 : (n3 > 0 ? Math.ceil(t3 * r3 - 1e-9) : Math.floor(t3 * r3 + 1e-10)) / r3;
+      }, t2.cv = function(t3, e3, n3) {
+        const r3 = E2(e3.x - n3.x, e3.y - n3.y), i3 = E2(t3.x - n3.x, t3.y - n3.y);
+        var s3, o3;
+        return et2(Math.atan2(r3[0] * i3[1] - r3[1] * i3[0], (s3 = r3)[0] * (o3 = i3)[0] + s3[1] * o3[1]));
+      }, t2.cw = C2, t2.cx = function(t3, e3) {
+        var n3;
+        if (!rt2[e3]) return false;
+        const r3 = null == t3 ? void 0 : t3.target, i3 = (null === (n3 = null == r3 ? void 0 : r3.ownerDocument) || void 0 === n3 ? void 0 : n3.defaultView) || window;
+        return t3 instanceof i3.MouseEvent || t3 instanceof i3.WheelEvent;
+      }, t2.cy = function(t3, e3) {
+        return nt2[e3] && "touches" in t3;
+      }, t2.cz = function(t3) {
+        return nt2[t3] || rt2[t3];
+      }, t2.d = ft2, t2.d0 = ri2, t2.d1 = class {
+        get tiles() {
+          var _a4;
+          return ((_a4 = this.tileIndex) == null ? void 0 : _a4.tiles) ?? {};
+        }
+        get stats() {
+          return this.tileIndex.stats;
+        }
+        get total() {
+          return this.tileIndex.total;
+        }
+        constructor(t3, e3) {
+          const n3 = (e3 = this.options = Object.assign({}, Qc2, e3)).debug;
+          if (n3 && console.time("preprocess data"), e3.maxZoom < 0 || e3.maxZoom > 24) throw new Error("maxZoom should be in the 0-24 range");
+          if (e3.promoteId && e3.generateId) throw new Error("promoteId and generateId cannot be used together.");
+          let r3 = ac2(t3, e3);
+          n3 && (console.timeEnd("preprocess data"), console.log("index: maxZoom: %d, maxPoints: %d", e3.indexMaxZoom, e3.indexMaxPoints), console.time("generate tiles")), r3 = Pc2(r3, e3), e3.updateable && (this.source = r3), this.initializeIndex(r3, e3);
+        }
+        initializeIndex(t3, e3) {
+          this.tileIndex = e3.cluster ? new Oc2(e3.clusterOptions) : new Kc2(e3), t3.length && this.tileIndex.initialize(t3);
+        }
+        getTile(t3, e3, n3) {
+          return e3 = +e3, n3 = +n3, (t3 = +t3) < 0 || t3 > 24 ? null : this.tileIndex.getTile(t3, e3, n3);
+        }
+        updateData(t3, e3) {
+          const n3 = this.options;
+          if (!n3.updateable) throw new Error("to update tile geojson `updateable` option must be set to true");
+          let { affected: r3, source: i3 } = function(t4, e4, n4) {
+            const r4 = function(t5) {
+              var _a4, _b3;
+              return t5 ? { removeAll: t5.removeAll, remove: new Set(t5.remove || []), add: new Map((_a4 = t5.add) == null ? void 0 : _a4.map((t6) => [t6.id, t6])), update: new Map((_b3 = t5.update) == null ? void 0 : _b3.map((t6) => [t6.id, t6])) } : { remove: /* @__PURE__ */ new Set(), add: /* @__PURE__ */ new Map(), update: /* @__PURE__ */ new Map() };
+            }(e4);
+            let i4 = [];
+            if (r4.removeAll && (i4 = t4, t4 = []), r4.remove.size || r4.add.size) {
+              const e5 = [];
+              for (const n5 of t4) (r4.remove.has(n5.id) || r4.add.has(n5.id)) && e5.push(n5);
+              if (e5.length) {
+                i4.push(...e5);
+                const n5 = new Set(e5.map((t5) => t5.id));
+                t4 = t4.filter((t5) => !n5.has(t5.id));
+              }
+              if (r4.add.size) {
+                let e6 = ac2({ type: "FeatureCollection", features: Array.from(r4.add.values()) }, n4);
+                e6 = Pc2(e6, n4), i4.push(...e6), t4.push(...e6);
+              }
+            }
+            if (r4.update.size) for (const [e5, s3] of r4.update) {
+              const r5 = [], o3 = [];
+              for (const n5 of t4) n5.id === e5 ? r5.push(n5) : o3.push(n5);
+              if (!r5.length) continue;
+              const a3 = Cc2(r5, s3, n4);
+              a3.length && (i4.push(...r5, ...a3), o3.push(...a3), t4 = o3);
+            }
+            return { affected: i4, source: t4 };
+          }(this.source, t3, n3);
+          e3 && ({ affected: r3, source: i3 } = this.filterUpdate(i3, r3, e3)), r3.length && (this.source = i3, this.tileIndex.updateIndex(i3, r3, n3));
+        }
+        filterUpdate(t3, e3, n3) {
+          const r3 = /* @__PURE__ */ new Set();
+          for (const i3 of t3) null != i3.id && (n3(fc2(i3)) || (e3.push(i3), r3.add(i3.id)));
+          return { affected: e3, source: t3 = t3.filter((t4) => !r3.has(t4.id)) };
+        }
+        getData() {
+          if (!this.options.updateable) throw new Error("to retrieve data the `updateable` option must be set to true");
+          return { type: "FeatureCollection", features: this.source.map((t3) => fc2(t3)) };
+        }
+        updateClusterOptions(t3, e3) {
+          const n3 = this.options.cluster;
+          this.options.cluster = t3, this.options.clusterOptions = e3, n3 != t3 ? this.initializeIndex(this.source, this.options) : this.tileIndex.updateIndex(this.source, [], this.options);
+        }
+        getClusterExpansionZoom(t3) {
+          return this.tileIndex.getClusterExpansionZoom(t3);
+        }
+        getClusterChildren(t3) {
+          return this.tileIndex.getChildren(t3);
+        }
+        getClusterLeaves(t3, e3, n3) {
+          return this.tileIndex.getLeaves(t3, e3, n3);
+        }
+      }, t2.d2 = Ps, t2.e = O2, t2.f = (t3) => e2(void 0, void 0, void 0, function* () {
+        if (0 === t3.byteLength) return createImageBitmap(new ImageData(1, 1));
+        const e3 = new Blob([new Uint8Array(t3)], { type: "image/png" });
+        try {
+          return createImageBitmap(e3);
+        } catch (t4) {
+          throw new Error(`Could not load image because of ${t4.message}. Please make sure to use a supported image type such as PNG or JPEG. Note that SVGs are not supported.`);
+        }
+      }), t2.g = lt2, t2.h = (t3) => new Promise((e3, n3) => {
+        const r3 = new Image();
+        r3.onload = () => {
+          e3(r3), URL.revokeObjectURL(r3.src), r3.onload = null, window.requestAnimationFrame(() => {
+            r3.src = H2;
+          });
+        }, r3.onerror = () => n3(new Error("Could not load image. Please make sure to use a supported image type such as PNG or JPEG. Note that SVGs are not supported."));
+        const i3 = new Blob([new Uint8Array(t3)], { type: "image/png" });
+        r3.src = t3.byteLength ? URL.createObjectURL(i3) : H2;
+      }), t2.i = X2, t2.j = (t3, e3) => pt2(O2(t3, { type: "json" }), e3), t2.k = gt2, t2.l = mt2, t2.m = pt2, t2.n = (t3, e3) => pt2(O2(t3, { type: "arrayBuffer" }), e3), t2.o = function(t3) {
+        return new zh2(t3).readFields(Gh2, []);
+      }, t2.p = Zh2, t2.q = function(t3) {
+        return /[\u02EA\u02EB\u1100-\u11FF\u2E80-\u2FDF\u3000-\u30FF\u3105-\u312F\u3131-\u318E\u31A0-\u4DBF\u4E00-\uA48C\uA490-\uA4C6\uA960-\uA97C\uAC00-\uD7C6\uD7CB-\uD7FB\uF900-\uFA6D\uFA70-\uFAD9\uFE10-\uFE1F\uFE30-\uFE4F\uFF00-\uFFEF]|\uD81B[\uDFE0-\uDFFF]|[\uD81C-\uD822\uD840-\uD868\uD86A-\uD86D\uD86F-\uD872\uD874-\uD879\uD880-\uD883\uD885-\uD88C][\uDC00-\uDFFF]|\uD823[\uDC00-\uDCD5\uDCFF-\uDD1E\uDD80-\uDDF2]|\uD82B[\uDFF0-\uDFFF]|\uD82C[\uDC00-\uDEFB]|\uD83C[\uDE00-\uDEFF]|\uD869[\uDC00-\uDEDF\uDF00-\uDFFF]|\uD86E[\uDC00-\uDC1D\uDC20-\uDFFF]|\uD873[\uDC00-\uDEAD\uDEB0-\uDFFF]|\uD87A[\uDC00-\uDFE0\uDFF0-\uDFFF]|\uD87B[\uDC00-\uDE5D]|\uD87E[\uDC00-\uDE1D]|\uD884[\uDC00-\uDF4A\uDF50-\uDFFF]|\uD88D[\uDC00-\uDC79]/gim.test(String.fromCodePoint(t3));
+      }, t2.r = _l2, t2.s = Q2, t2.t = Hs, t2.u = vt, t2.v = rs, t2.w = q2, t2.x = Os, t2.y = ss, t2.z = Cs;
+    });
+    define("worker", ["./shared"], function(e2) {
+      class t2 {
+        constructor(e3, t3) {
+          this.keyCache = {}, e3 && this.replace(e3, t3);
+        }
+        replace(e3, t3) {
+          this._layerConfigs = {}, this._layers = {}, this.update(e3, [], t3);
+        }
+        update(t3, i3, s3) {
+          for (const i4 of t3) {
+            this._layerConfigs[i4.id] = i4;
+            const t4 = this._layers[i4.id] = e2.bR(i4, s3);
+            t4._featureFilter = e2.ag(t4.filter, s3), this.keyCache[i4.id] && delete this.keyCache[i4.id];
+          }
+          for (const e3 of i3) delete this.keyCache[e3], delete this._layerConfigs[e3], delete this._layers[e3];
+          this.familiesBySource = {};
+          const r3 = e2.cJ(Object.values(this._layerConfigs), this.keyCache);
+          for (const t4 of r3) {
+            const i4 = t4.map((e3) => this._layers[e3.id]), s4 = i4[0];
+            if (s4.isHidden()) continue;
+            const r4 = s4.source || "";
+            let o3 = this.familiesBySource[r4];
+            o3 || (o3 = this.familiesBySource[r4] = {});
+            const n3 = s4.sourceLayer || e2.af;
+            let a3 = o3[n3];
+            a3 || (a3 = o3[n3] = []), a3.push(i4);
+          }
+        }
+      }
+      class i2 {
+        constructor(t3) {
+          const i3 = {}, s3 = [];
+          for (const e3 in t3) {
+            const r4 = t3[e3], o4 = i3[e3] = {};
+            for (const e4 in r4) {
+              const t4 = r4[+e4];
+              if (!t4 || 0 === t4.bitmap.width || 0 === t4.bitmap.height) continue;
+              const i4 = { x: 0, y: 0, w: t4.bitmap.width + 2, h: t4.bitmap.height + 2 };
+              s3.push(i4), o4[e4] = { rect: i4, metrics: t4.metrics };
+            }
+          }
+          const { w: r3, h: o3 } = e2.p(s3), n3 = new e2.r({ width: r3 || 1, height: o3 || 1 });
+          for (const s4 in t3) {
+            const r4 = t3[s4];
+            for (const t4 in r4) {
+              const o4 = r4[+t4];
+              if (!o4 || 0 === o4.bitmap.width || 0 === o4.bitmap.height) continue;
+              const a3 = i3[s4][t4].rect;
+              e2.r.copy(o4.bitmap, n3, { x: 0, y: 0 }, { x: a3.x + 1, y: a3.y + 1 }, o4.bitmap);
+            }
+          }
+          this.image = n3, this.positions = i3;
+        }
+      }
+      e2.cK("GlyphAtlas", i2);
+      class s2 {
+        constructor(t3) {
+          this.tileID = new e2.a2(t3.tileID.overscaledZ, t3.tileID.wrap, t3.tileID.canonical.z, t3.tileID.canonical.x, t3.tileID.canonical.y), this.uid = t3.uid, this.zoom = t3.zoom, this.pixelRatio = t3.pixelRatio, this.tileSize = t3.tileSize, this.source = t3.source, this.overscaling = this.tileID.overscaleFactor(), this.showCollisionBoxes = t3.showCollisionBoxes, this.collectResourceTiming = !!t3.collectResourceTiming, this.returnDependencies = !!t3.returnDependencies, this.promoteId = t3.promoteId, this.inFlightDependencies = [];
+        }
+        parse(t3, s3, o3, n3, a3) {
+          return e2._(this, void 0, void 0, function* () {
+            this.status = "parsing", this.data = t3, this.collisionBoxArray = new e2.ad();
+            const l3 = new e2.cL(Object.keys(t3.layers).sort()), c3 = new e2.cM(this.tileID, this.promoteId);
+            c3.bucketLayerIDs = [];
+            const h3 = {}, d3 = { featureIndex: c3, iconDependencies: {}, patternDependencies: {}, glyphDependencies: {}, dashDependencies: {}, availableImages: o3, subdivisionGranularity: a3 }, u3 = s3.familiesBySource[this.source];
+            for (const i3 in u3) {
+              const s4 = t3.layers[i3];
+              if (!s4) continue;
+              1 === s4.version && e2.w(`Vector tile source "${this.source}" layer "${i3}" does not use vector tile spec v2 and therefore may have some rendering errors.`);
+              const n4 = l3.encode(i3), a4 = [];
+              for (let e3 = 0; e3 < s4.length; e3++) {
+                const t4 = s4.feature(e3), r3 = c3.getId(t4, i3);
+                a4.push({ feature: t4, id: r3, index: e3, sourceLayerIndex: n4 });
+              }
+              for (const t4 of u3[i3]) {
+                const i4 = t4[0];
+                i4.source !== this.source && e2.w(`layer.source = ${i4.source} does not equal this.source = ${this.source}`), i4.isHidden(this.zoom, true) || (r2(t4, this.zoom, o3), (h3[i4.id] = i4.createBucket({ index: c3.bucketLayerIDs.length, layers: t4, zoom: this.zoom, pixelRatio: this.pixelRatio, overscaling: this.overscaling, collisionBoxArray: this.collisionBoxArray, sourceLayerIndex: n4, sourceID: this.source })).populate(a4, d3, this.tileID.canonical), c3.bucketLayerIDs.push(t4.map((e3) => e3.id)));
+              }
+            }
+            const g3 = e2.bW(d3.glyphDependencies, (e3) => Object.keys(e3).map(Number));
+            this.inFlightDependencies.forEach((e3) => null == e3 ? void 0 : e3.abort()), this.inFlightDependencies = [];
+            let p3 = Promise.resolve({});
+            if (Object.keys(g3).length) {
+              const e3 = new AbortController();
+              this.inFlightDependencies.push(e3), p3 = n3.sendAsync({ type: "GG", data: { stacks: g3, source: this.source, tileID: this.tileID, type: "glyphs" } }, e3);
+            }
+            const f3 = Object.keys(d3.iconDependencies);
+            let y3 = Promise.resolve({});
+            if (f3.length) {
+              const e3 = new AbortController();
+              this.inFlightDependencies.push(e3), y3 = n3.sendAsync({ type: "GI", data: { icons: f3, source: this.source, tileID: this.tileID, type: "icons" } }, e3);
+            }
+            const v2 = Object.keys(d3.patternDependencies);
+            let m2 = Promise.resolve({});
+            if (v2.length) {
+              const e3 = new AbortController();
+              this.inFlightDependencies.push(e3), m2 = n3.sendAsync({ type: "GI", data: { icons: v2, source: this.source, tileID: this.tileID, type: "patterns" } }, e3);
+            }
+            const S2 = d3.dashDependencies;
+            let _2 = Promise.resolve({});
+            if (Object.keys(S2).length) {
+              const e3 = new AbortController();
+              this.inFlightDependencies.push(e3), _2 = n3.sendAsync({ type: "GDA", data: { dashes: S2 } }, e3);
+            }
+            const [w2, b2, I2, k2] = yield Promise.all([p3, y3, m2, _2]), T2 = new i2(w2), x2 = new e2.cN(b2, I2);
+            for (const t4 in h3) {
+              const i3 = h3[t4];
+              i3 instanceof e2.ae ? (r2(i3.layers, this.zoom, o3), e2.cO({ bucket: i3, glyphMap: w2, glyphPositions: T2.positions, imageMap: b2, imagePositions: x2.iconPositions, showCollisionBoxes: this.showCollisionBoxes, canonical: this.tileID.canonical, subdivisionGranularity: d3.subdivisionGranularity })) : i3.hasDependencies && (i3 instanceof e2.cP || i3 instanceof e2.cQ || i3 instanceof e2.cR) && (r2(i3.layers, this.zoom, o3), i3.addFeatures(d3, this.tileID.canonical, x2.patternPositions, k2));
+            }
+            return this.status = "done", { buckets: Object.values(h3).filter((e3) => !e3.isEmpty()), featureIndex: c3, collisionBoxArray: this.collisionBoxArray, glyphAtlasImage: T2.image, imageAtlas: x2, dashPositions: k2, glyphMap: this.returnDependencies ? w2 : null, iconMap: this.returnDependencies ? b2 : null, glyphPositions: this.returnDependencies ? T2.positions : null };
+          });
+        }
+      }
+      function r2(t3, i3, s3) {
+        const r3 = new e2.H(i3);
+        for (const e3 of t3) e3.recalculate(r3, s3);
+      }
+      class o2 {
+        constructor() {
+          this.loading = {}, this.loaded = {}, this.parsing = {};
+        }
+        startLoading(e3, t3) {
+          this.loading[e3] = t3;
+        }
+        finishLoading(e3) {
+          delete this.loading[e3];
+        }
+        abort(e3) {
+          const t3 = this.loading[e3];
+          (null == t3 ? void 0 : t3.abort) && (t3.abort.abort(), delete this.loading[e3]);
+        }
+        setParsing(e3, t3) {
+          this.parsing[e3] = t3;
+        }
+        consumeParsing(e3) {
+          const t3 = this.parsing[e3];
+          if (t3) return delete this.parsing[e3], t3;
+        }
+        clearParsing(e3) {
+          delete this.parsing[e3];
+        }
+        markLoaded(e3, t3) {
+          this.loaded[e3] = t3;
+        }
+        getLoaded(e3) {
+          const t3 = this.loaded[e3];
+          if (t3) return t3;
+        }
+        removeLoaded(e3) {
+          delete this.loaded[e3];
+        }
+        clearLoaded() {
+          this.loaded = {};
+        }
+      }
+      class n2 {
+        constructor(e3, t3, i3, s3, r3) {
+          this.type = e3, this.properties = i3 || {}, this.extent = r3, this.pointsArray = t3, this.id = s3;
+        }
+        loadGeometry() {
+          return this.pointsArray.map((t3) => t3.map((t4) => new e2.P(t4.x, t4.y)));
+        }
+      }
+      class a2 {
+        constructor(e3, t3, i3) {
+          this.version = 2, this._myFeatures = e3, this.name = t3, this.length = e3.length, this.extent = i3;
+        }
+        feature(e3) {
+          return this._myFeatures[e3];
+        }
+      }
+      class l2 {
+        constructor() {
+          this.layers = {};
+        }
+        addLayer(e3) {
+          this.layers[e3.name] = e3;
+        }
+      }
+      function c2(t3) {
+        let i3 = e2.cS(t3);
+        return 0 === i3.byteOffset && i3.byteLength === i3.buffer.byteLength || (i3 = new Uint8Array(i3)), { vectorTile: t3, rawData: i3.buffer };
+      }
+      function h2(t3, i3, s3) {
+        const { extent: r3 } = t3, o3 = Math.pow(2, s3.z - i3.z), l3 = (s3.x - i3.x * o3) * r3, c3 = (s3.y - i3.y * o3) * r3, h3 = [];
+        for (let i4 = 0; i4 < t3.length; i4++) {
+          const s4 = t3.feature(i4);
+          let a3 = s4.loadGeometry();
+          for (const e3 of a3) for (const t4 of e3) t4.x = t4.x * o3 - l3, t4.y = t4.y * o3 - c3;
+          const d3 = 128;
+          a3 = e2.cT(a3, s4.type, -128, -128, r3 + d3, r3 + d3), 0 !== a3.length && h3.push(new n2(s4.type, a3, s4.properties, s4.id, r3));
+        }
+        return new a2(h3, t3.name, r3);
+      }
+      class d2 {
+        constructor(t3, i3, s3) {
+          this.actor = t3, this.layerIndex = i3, this.availableImages = s3, this.tileState = new o2(), this.overzoomedTileResultCache = new e2.cU(1e3);
+        }
+        loadVectorTile(t3, i3) {
+          try {
+            return { vectorTile: "mlt" !== t3.encoding ? new e2.cV(new e2.cW(i3)) : new e2.cX(i3), rawData: i3 };
+          } catch (e3) {
+            const s3 = new Uint8Array(i3);
+            let r3 = `Unable to parse the tile at ${t3.request.url}, `;
+            throw r3 += 31 === s3[0] && 139 === s3[1] ? "please make sure the data is not gzipped and that you have configured the relevant header in the server" : `got error: ${e3.message}`, new Error(r3);
+          }
+        }
+        loadTile(t3) {
+          return e2._(this, void 0, void 0, function* () {
+            const { uid: i3, overzoomParameters: r3 } = t3;
+            r3 && (t3.request = r3.overzoomRequest);
+            const o3 = this._startRequestTiming(t3), n3 = new s2(t3);
+            this.tileState.startLoading(i3, n3);
+            const a3 = new AbortController();
+            n3.abort = a3;
+            try {
+              const s3 = yield e2.n(t3.request, a3);
+              if (t3.etag && t3.etag === s3.etag) return this.tileState.finishLoading(i3), this._getEtagUnmodifiedResult(s3, o3);
+              const l3 = this.loadVectorTile(t3, s3.data);
+              if (this.tileState.finishLoading(i3), !l3) return null;
+              let { vectorTile: c3, rawData: h3 } = l3;
+              r3 && ({ vectorTile: c3, rawData: h3 } = this._getOverzoomTile(t3, c3));
+              const d3 = this._getExpiryData(s3), u3 = this._finishRequestTiming(o3);
+              n3.vectorTile = c3, this.tileState.markLoaded(i3, n3);
+              const g3 = { rawData: h3, cacheControl: d3, resourceTiming: u3 };
+              this.tileState.setParsing(i3, g3);
+              try {
+                return yield this._parseWorkerTile(n3, t3, g3);
+              } finally {
+                this.tileState.clearParsing(i3);
+              }
+            } catch (e3) {
+              throw this.tileState.finishLoading(i3), n3.status = "done", this.tileState.markLoaded(i3, n3), e3;
+            }
+          });
+        }
+        _getEtagUnmodifiedResult(t3, i3) {
+          const s3 = this._getExpiryData(t3), r3 = this._finishRequestTiming(i3);
+          return e2.e({ etagUnmodified: true }, s3, r3);
+        }
+        _parseWorkerTile(t3, i3, s3) {
+          return e2._(this, void 0, void 0, function* () {
+            let r3 = yield t3.parse(t3.vectorTile, this.layerIndex, this.availableImages, this.actor, i3.subdivisionGranularity);
+            if (s3) {
+              const { rawData: t4, cacheControl: o3, resourceTiming: n3 } = s3;
+              r3 = e2.e({ rawTileData: t4.slice(0), encoding: i3.encoding }, r3, o3, n3);
+            }
+            return r3;
+          });
+        }
+        _getExpiryData({ expires: e3, cacheControl: t3, etag: i3 }) {
+          const s3 = {};
+          return e3 && (s3.expires = e3), t3 && (s3.cacheControl = t3), i3 && (s3.etag = i3), s3;
+        }
+        _startRequestTiming(t3) {
+          var i3;
+          if (null === (i3 = t3.request) || void 0 === i3 ? void 0 : i3.collectResourceTiming) return new e2.cY(t3.request.url);
+        }
+        _finishRequestTiming(e3) {
+          const t3 = null == e3 ? void 0 : e3.finish();
+          return t3 ? { resourceTiming: JSON.parse(JSON.stringify(t3)) } : {};
+        }
+        _getOverzoomTile(e3, t3) {
+          const { tileID: i3, source: s3, overzoomParameters: r3 } = e3, { maxZoomTileID: o3 } = r3, n3 = `${o3.key}_${i3.key}`, a3 = this.overzoomedTileResultCache.get(n3);
+          if (a3) return a3;
+          const d3 = new l2(), u3 = this.layerIndex.familiesBySource[s3];
+          for (const e4 in u3) {
+            const s4 = t3.layers[e4];
+            if (!s4) continue;
+            const r4 = h2(s4, o3, i3.canonical);
+            r4.length > 0 && d3.addLayer(r4);
+          }
+          const g3 = c2(d3);
+          return this.overzoomedTileResultCache.set(n3, g3), g3;
+        }
+        reloadTile(t3) {
+          return e2._(this, void 0, void 0, function* () {
+            const e3 = t3.uid, i3 = this.tileState.getLoaded(e3);
+            if (!i3) throw new Error("Should not be trying to reload a tile that was never loaded or has been removed");
+            if (i3.showCollisionBoxes = t3.showCollisionBoxes, "parsing" === i3.status) {
+              const s3 = this.tileState.consumeParsing(e3);
+              return yield this._parseWorkerTile(i3, t3, s3);
+            }
+            if ("done" === i3.status && i3.vectorTile) return yield this._parseWorkerTile(i3, t3);
+          });
+        }
+        abortTile(t3) {
+          return e2._(this, void 0, void 0, function* () {
+            this.tileState.abort(t3.uid);
+          });
+        }
+        removeTile(t3) {
+          return e2._(this, void 0, void 0, function* () {
+            this.tileState.removeLoaded(t3.uid);
+          });
+        }
+      }
+      class u2 {
+        constructor() {
+          this.loaded = {};
+        }
+        loadTile(t3) {
+          return e2._(this, void 0, void 0, function* () {
+            const { uid: i3, encoding: s3, rawImageData: r3, redFactor: o3, greenFactor: n3, blueFactor: a3, baseShift: l3 } = t3, c3 = r3.width + 2, h3 = r3.height + 2, d3 = e2.b(r3) ? new e2.R({ width: c3, height: h3 }, yield e2.cZ(r3, -1, -1, c3, h3)) : r3, u3 = new e2.c_(i3, d3, s3, o3, n3, a3, l3);
+            return this.loaded = this.loaded || {}, this.loaded[i3] = u3, u3;
+          });
+        }
+        removeTile(e3) {
+          const t3 = this.loaded, i3 = e3.uid;
+          t3 && t3[i3] && delete t3[i3];
+        }
+      }
+      class g2 {
+        constructor(e3, t3, i3, s3 = p2) {
+          this.actor = e3, this.layerIndex = t3, this.availableImages = i3, this.tileState = new o2(), this._createGeoJSONIndex = s3;
+        }
+        loadVectorTile(t3) {
+          if (!this._geoJSONIndex) throw new Error("Unable to parse the data into a cluster or geojson");
+          const { z: i3, x: s3, y: r3 } = t3.tileID.canonical, o3 = this._geoJSONIndex.getTile(i3, s3, r3);
+          return o3 ? c2(new e2.c$(o3.features, { version: 2, extent: e2.a5 })) : null;
+        }
+        loadTile(t3) {
+          return e2._(this, void 0, void 0, function* () {
+            const { uid: e3 } = t3, i3 = new s2(t3);
+            i3.abort = new AbortController();
+            try {
+              const s3 = this.loadVectorTile(t3);
+              if (!s3) return null;
+              const { vectorTile: r3, rawData: o3 } = s3;
+              i3.vectorTile = r3, this.tileState.markLoaded(e3, i3);
+              const n3 = { rawData: o3 };
+              this.tileState.setParsing(e3, n3);
+              try {
+                return yield this._parseWorkerTile(i3, t3, n3);
+              } finally {
+                this.tileState.clearParsing(e3);
+              }
+            } catch (t4) {
+              throw i3.status = "done", this.tileState.markLoaded(e3, i3), t4;
+            }
+          });
+        }
+        _reloadLoadedTile(t3) {
+          return e2._(this, void 0, void 0, function* () {
+            const e3 = t3.uid, i3 = this.tileState.getLoaded(e3);
+            if (!i3) throw new Error("Should not be trying to reload a tile that was never loaded or has been removed");
+            if (i3.showCollisionBoxes = t3.showCollisionBoxes, "parsing" === i3.status) {
+              const s3 = this.tileState.consumeParsing(e3);
+              return yield this._parseWorkerTile(i3, t3, s3);
+            }
+            if ("done" === i3.status && i3.vectorTile) return yield this._parseWorkerTile(i3, t3);
+          });
+        }
+        _parseWorkerTile(t3, i3, s3) {
+          return e2._(this, void 0, void 0, function* () {
+            let r3 = yield t3.parse(t3.vectorTile, this.layerIndex, this.availableImages, this.actor, i3.subdivisionGranularity);
+            if (s3) {
+              const { rawData: t4 } = s3;
+              r3 = e2.e({ rawTileData: t4.slice(0), encoding: "mvt" }, r3);
+            }
+            return r3;
+          });
+        }
+        abortTile(t3) {
+          return e2._(this, void 0, void 0, function* () {
+            this.tileState.abort(t3.uid);
+          });
+        }
+        removeTile(t3) {
+          return e2._(this, void 0, void 0, function* () {
+            this.tileState.removeLoaded(t3.uid);
+          });
+        }
+        loadData(t3) {
+          return e2._(this, void 0, void 0, function* () {
+            var i3;
+            null === (i3 = this._pendingRequest) || void 0 === i3 || i3.abort();
+            const s3 = this._startRequestTiming(t3);
+            this._pendingRequest = new AbortController();
+            try {
+              yield this.loadAndProcessGeoJSON(t3, this._pendingRequest), delete this._pendingRequest, this.tileState.clearLoaded();
+              const e3 = {};
+              return t3.request && (e3.data = t3.data), this._finishRequestTiming(s3, t3, e3), e3;
+            } catch (t4) {
+              if (delete this._pendingRequest, !e2.Z(t4)) throw t4;
+              return { abandoned: true };
+            }
+          });
+        }
+        _startRequestTiming(t3) {
+          var i3;
+          if (null === (i3 = t3.request) || void 0 === i3 ? void 0 : i3.collectResourceTiming) return new e2.cY(t3.request.url);
+        }
+        _finishRequestTiming(e3, t3, i3) {
+          const s3 = null == e3 ? void 0 : e3.finish();
+          s3 && (i3.resourceTiming = { [t3.source]: JSON.parse(JSON.stringify(s3)) });
+        }
+        reloadTile(e3) {
+          return this.tileState.getLoaded(e3.uid) ? this._reloadLoadedTile(e3) : this.loadTile(e3);
+        }
+        loadAndProcessGeoJSON(t3, i3) {
+          return e2._(this, void 0, void 0, function* () {
+            var s3;
+            if (t3.request && (t3.data = (yield e2.j(t3.request, i3)).data), t3.data) return t3.data = this._filterGeoJSON(t3.data, t3.filter), void (this._geoJSONIndex = this._createGeoJSONIndex(t3.data, t3));
+            if (t3.dataDiff) return null !== (s3 = this._geoJSONIndex) && void 0 !== s3 || (this._geoJSONIndex = this._createGeoJSONIndex({ type: "FeatureCollection", features: [] }, t3)), void this._geoJSONIndex.updateData(t3.dataDiff, this._getFilterPredicate(t3.filter));
+            if (t3.updateCluster && this._geoJSONIndex.updateClusterOptions(t3.cluster, f2(t3)), null == this._geoJSONIndex) throw new Error(`Input data given to '${t3.source}' is not a valid GeoJSON object.`);
+          });
+        }
+        _filterGeoJSON(e3, t3) {
+          if ("FeatureCollection" !== e3.type) return e3;
+          const i3 = this._getFilterPredicate(t3);
+          return i3 ? { type: "FeatureCollection", features: e3.features.filter((e4) => i3(e4)) } : e3;
+        }
+        _getFilterPredicate(t3) {
+          if ("boolean" != typeof t3 && !(null == t3 ? void 0 : t3.length)) return;
+          const i3 = e2.d0(t3, { type: "boolean", "property-type": "data-driven", overridable: false, transition: false });
+          if ("error" === i3.result) throw new Error(i3.value.map((e3) => `${e3.key}: ${e3.message}`).join(", "));
+          return (e3) => i3.value.evaluate({ zoom: 0 }, e3);
+        }
+        removeSource(t3) {
+          return e2._(this, void 0, void 0, function* () {
+            var e3;
+            null === (e3 = this._pendingRequest) || void 0 === e3 || e3.abort();
+          });
+        }
+        getClusterExpansionZoom(e3) {
+          return this._geoJSONIndex.getClusterExpansionZoom(e3.clusterId);
+        }
+        getClusterChildren(e3) {
+          return this._geoJSONIndex.getClusterChildren(e3.clusterId);
+        }
+        getClusterLeaves(e3) {
+          return this._geoJSONIndex.getClusterLeaves(e3.clusterId, e3.limit, e3.offset);
+        }
+      }
+      function p2(t3, i3) {
+        const s3 = e2.e(i3.geojsonVtOptions || {}, { updateable: true, cluster: i3.cluster, clusterOptions: f2(i3) });
+        return new e2.d1(t3, s3);
+      }
+      function f2({ superclusterOptions: t3, clusterProperties: i3 }) {
+        if (!i3 || !t3) return t3;
+        const s3 = {}, r3 = {}, o3 = { accumulated: null, zoom: 0 }, n3 = { properties: null }, a3 = Object.keys(i3);
+        for (const t4 of a3) {
+          const [o4, n4] = i3[t4], a4 = e2.d0(n4), l3 = e2.d0("string" == typeof o4 ? [o4, ["accumulated"], ["get", t4]] : o4);
+          s3[t4] = a4.value, r3[t4] = l3.value;
+        }
+        return t3.map = (e3) => {
+          n3.properties = e3;
+          const t4 = {};
+          for (const e4 of a3) t4[e4] = s3[e4].evaluate(o3, n3);
+          return t4;
+        }, t3.reduce = (e3, t4) => {
+          n3.properties = t4;
+          for (const t5 of a3) o3.accumulated = e3[t5], e3[t5] = r3[t5].evaluate(o3, n3);
+        }, t3;
+      }
+      class y2 {
+        constructor(t3) {
+          this.self = t3, this.actor = new e2.L(t3), this.layerIndexes = {}, this.availableImages = {}, this.workerSources = {}, this.demWorkerSources = {}, this.externalWorkerSourceTypes = {}, this.globalStates = /* @__PURE__ */ new Map(), this.self.registerWorkerSource = (e3, t4) => {
+            if (this.externalWorkerSourceTypes[e3]) throw new Error(`Worker source with name "${e3}" already registered.`);
+            this.externalWorkerSourceTypes[e3] = t4;
+          }, this.self.addProtocol = e2.cH, this.self.removeProtocol = e2.cI, this.self.registerRTLTextPlugin = (t4) => {
+            e2.d2.setMethods(t4);
+          }, this.actor.registerMessageHandler("LDT", (e3, t4) => this._getDEMWorkerSource(e3, t4.source).loadTile(t4)), this.actor.registerMessageHandler("RDT", (t4, i3) => e2._(this, void 0, void 0, function* () {
+            this._getDEMWorkerSource(t4, i3.source).removeTile(i3);
+          })), this.actor.registerMessageHandler("GCEZ", (t4, i3) => e2._(this, void 0, void 0, function* () {
+            return this._getWorkerSource(t4, i3.type, i3.source).getClusterExpansionZoom(i3);
+          })), this.actor.registerMessageHandler("GCC", (t4, i3) => e2._(this, void 0, void 0, function* () {
+            return this._getWorkerSource(t4, i3.type, i3.source).getClusterChildren(i3);
+          })), this.actor.registerMessageHandler("GCL", (t4, i3) => e2._(this, void 0, void 0, function* () {
+            return this._getWorkerSource(t4, i3.type, i3.source).getClusterLeaves(i3);
+          })), this.actor.registerMessageHandler("LD", (e3, t4) => this._getWorkerSource(e3, t4.type, t4.source).loadData(t4)), this.actor.registerMessageHandler("LT", (e3, t4) => this._getWorkerSource(e3, t4.type, t4.source).loadTile(t4)), this.actor.registerMessageHandler("RT", (e3, t4) => this._getWorkerSource(e3, t4.type, t4.source).reloadTile(t4)), this.actor.registerMessageHandler("AT", (e3, t4) => this._getWorkerSource(e3, t4.type, t4.source).abortTile(t4)), this.actor.registerMessageHandler("RMT", (e3, t4) => this._getWorkerSource(e3, t4.type, t4.source).removeTile(t4)), this.actor.registerMessageHandler("RS", (t4, i3) => e2._(this, void 0, void 0, function* () {
+            if (!this.workerSources[t4] || !this.workerSources[t4][i3.type] || !this.workerSources[t4][i3.type][i3.source]) return;
+            const e3 = this.workerSources[t4][i3.type][i3.source];
+            delete this.workerSources[t4][i3.type][i3.source], void 0 !== e3.removeSource && e3.removeSource(i3);
+          })), this.actor.registerMessageHandler("RM", (t4) => e2._(this, void 0, void 0, function* () {
+            delete this.layerIndexes[t4], delete this.availableImages[t4], delete this.workerSources[t4], delete this.demWorkerSources[t4], this.globalStates.delete(t4);
+          })), this.actor.registerMessageHandler("SR", (t4, i3) => e2._(this, void 0, void 0, function* () {
+            this.referrer = i3;
+          })), this.actor.registerMessageHandler("SRPS", (e3, t4) => this._syncRTLPluginState(e3, t4)), this.actor.registerMessageHandler("IS", (t4, i3) => e2._(this, void 0, void 0, function* () {
+            this.self.importScripts(i3);
+          })), this.actor.registerMessageHandler("SI", (e3, t4) => this._setImages(e3, t4)), this.actor.registerMessageHandler("UL", (t4, i3) => e2._(this, void 0, void 0, function* () {
+            this._getLayerIndex(t4).update(i3.layers, i3.removedIds, this._getGlobalState(t4));
+          })), this.actor.registerMessageHandler("UGS", (t4, i3) => e2._(this, void 0, void 0, function* () {
+            const e3 = this._getGlobalState(t4);
+            for (const t5 in i3) e3[t5] = i3[t5];
+          })), this.actor.registerMessageHandler("SL", (t4, i3) => e2._(this, void 0, void 0, function* () {
+            this._getLayerIndex(t4).replace(i3, this._getGlobalState(t4));
+          }));
+        }
+        _getGlobalState(e3) {
+          let t3 = this.globalStates.get(e3);
+          return t3 || (t3 = {}, this.globalStates.set(e3, t3)), t3;
+        }
+        _setImages(t3, i3) {
+          return e2._(this, void 0, void 0, function* () {
+            this.availableImages[t3] = i3;
+            for (const e3 in this.workerSources[t3]) {
+              const s3 = this.workerSources[t3][e3];
+              for (const e4 in s3) s3[e4].availableImages = i3;
+            }
+          });
+        }
+        _syncRTLPluginState(t3, i3) {
+          return e2._(this, void 0, void 0, function* () {
+            return yield e2.d2.syncState(i3, this.self.importScripts);
+          });
+        }
+        _getAvailableImages(e3) {
+          let t3 = this.availableImages[e3];
+          return t3 || (t3 = []), t3;
+        }
+        _getLayerIndex(e3) {
+          let i3 = this.layerIndexes[e3];
+          return i3 || (i3 = this.layerIndexes[e3] = new t2()), i3;
+        }
+        _getWorkerSource(e3, t3, i3) {
+          if (this.workerSources[e3] || (this.workerSources[e3] = {}), this.workerSources[e3][t3] || (this.workerSources[e3][t3] = {}), !this.workerSources[e3][t3][i3]) {
+            const s3 = { sendAsync: (t4, i4) => (t4.targetMapId = e3, this.actor.sendAsync(t4, i4)) };
+            switch (t3) {
+              case "vector":
+                this.workerSources[e3][t3][i3] = new d2(s3, this._getLayerIndex(e3), this._getAvailableImages(e3));
+                break;
+              case "geojson":
+                this.workerSources[e3][t3][i3] = new g2(s3, this._getLayerIndex(e3), this._getAvailableImages(e3));
+                break;
+              default:
+                this.workerSources[e3][t3][i3] = new this.externalWorkerSourceTypes[t3](s3, this._getLayerIndex(e3), this._getAvailableImages(e3));
+            }
+          }
+          return this.workerSources[e3][t3][i3];
+        }
+        _getDEMWorkerSource(e3, t3) {
+          return this.demWorkerSources[e3] || (this.demWorkerSources[e3] = {}), this.demWorkerSources[e3][t3] || (this.demWorkerSources[e3][t3] = new u2()), this.demWorkerSources[e3][t3];
+        }
+      }
+      return e2.i(self) && (self.worker = new y2(self)), y2;
+    });
+    define("index", ["exports", "./shared"], function(e2, t2) {
+      var i2 = "5.21.0";
+      function o2() {
+        var e3 = new t2.A(4);
+        return t2.A != Float32Array && (e3[1] = 0, e3[2] = 0), e3[0] = 1, e3[3] = 1, e3;
+      }
+      let a2, r2, s2;
+      const n2 = { frame(e3, i3, o3, a3) {
+        const r3 = a3 || window, s3 = r3.requestAnimationFrame((e4) => {
+          n3(), i3(e4);
+        }), { unsubscribe: n3 } = t2.s(e3.signal, "abort", () => {
+          n3(), r3.cancelAnimationFrame(s3), o3(new t2.a(e3.signal.reason));
+        }, false);
+      }, frameAsync(e3, t3) {
+        return new Promise((i3, o3) => {
+          this.frame(e3, i3, o3, t3);
+        });
+      }, getImageData(e3, t3 = 0) {
+        return this.getImageCanvasContext(e3).getImageData(-t3, -t3, e3.width + 2 * t3, e3.height + 2 * t3);
+      }, getImageCanvasContext(e3) {
+        const t3 = window.document.createElement("canvas"), i3 = t3.getContext("2d", { willReadFrequently: true });
+        if (!i3) throw new Error("failed to create canvas 2d context");
+        return t3.width = e3.width, t3.height = e3.height, i3.drawImage(e3, 0, 0, e3.width, e3.height), i3;
+      }, resolveURL: (e3) => (a2 || (a2 = document.createElement("a")), a2.href = e3, a2.href), hardwareConcurrency: "undefined" != typeof navigator && navigator.hardwareConcurrency || 4, get prefersReducedMotion() {
+        return void 0 !== s2 ? s2 : !!matchMedia && (null == r2 && (r2 = matchMedia("(prefers-reduced-motion: reduce)")), r2.matches);
+      }, set prefersReducedMotion(e3) {
+        s2 = e3;
+      } }, l2 = new class {
+        constructor() {
+          this._frozenAt = null;
+        }
+        getCurrentTime() {
+          return null !== this._frozenAt ? this._frozenAt : performance.now();
+        }
+        setNow(e3) {
+          this._frozenAt = e3;
+        }
+        restoreNow() {
+          this._frozenAt = null;
+        }
+        isFrozen() {
+          return null !== this._frozenAt;
+        }
+      }();
+      function c2() {
+        return l2.getCurrentTime();
+      }
+      class h2 {
+        static create(e3, t3, i3) {
+          const o3 = window.document.createElement(e3);
+          return void 0 !== t3 && (o3.className = t3), i3 && i3.appendChild(o3), o3;
+        }
+        static createNS(e3, t3) {
+          return window.document.createElementNS(e3, t3);
+        }
+        static disableDrag() {
+          h2.docStyle && h2.selectProp && (h2.userSelect = h2.docStyle[h2.selectProp], h2.docStyle[h2.selectProp] = "none");
+        }
+        static enableDrag() {
+          h2.docStyle && h2.selectProp && (h2.docStyle[h2.selectProp] = h2.userSelect);
+        }
+        static suppressClickInternal(e3) {
+          e3.preventDefault(), e3.stopPropagation(), window.removeEventListener("click", h2.suppressClickInternal, true);
+        }
+        static suppressClick() {
+          window.addEventListener("click", h2.suppressClickInternal, true), window.setTimeout(() => {
+            window.removeEventListener("click", h2.suppressClickInternal, true);
+          }, 0);
+        }
+        static getScale(e3) {
+          const t3 = e3.getBoundingClientRect();
+          return { x: t3.width / e3.offsetWidth || 1, y: t3.height / e3.offsetHeight || 1, boundingClientRect: t3 };
+        }
+        static getPoint(e3, i3, o3) {
+          const a3 = i3.boundingClientRect;
+          return new t2.P((o3.clientX - a3.left) / i3.x - e3.clientLeft, (o3.clientY - a3.top) / i3.y - e3.clientTop);
+        }
+        static mousePos(e3, t3) {
+          const i3 = h2.getScale(e3);
+          return h2.getPoint(e3, i3, t3);
+        }
+        static touchPos(e3, t3) {
+          const i3 = [], o3 = h2.getScale(e3);
+          for (let a3 = 0; a3 < t3.length; a3++) i3.push(h2.getPoint(e3, o3, t3[a3]));
+          return i3;
+        }
+        static sanitize(e3) {
+          const t3 = new DOMParser().parseFromString(e3, "text/html").body || document.createElement("body"), i3 = t3.querySelectorAll("script");
+          for (const e4 of i3) e4.remove();
+          return h2.clean(t3), t3.innerHTML;
+        }
+        static isPossiblyDangerous(e3, t3) {
+          const i3 = t3.replace(/\s+/g, "").toLowerCase();
+          return !(!["src", "href", "xlink:href"].includes(e3) || !i3.includes("javascript:") && !i3.includes("data:")) || !!e3.startsWith("on") || void 0;
+        }
+        static clean(e3) {
+          const t3 = e3.children;
+          for (const e4 of t3) h2.removeAttributes(e4), h2.clean(e4);
+        }
+        static removeAttributes(e3) {
+          for (const { name: t3, value: i3 } of e3.attributes) h2.isPossiblyDangerous(t3, i3) && e3.removeAttribute(t3);
+        }
+      }
+      var u2;
+      h2.docStyle = "undefined" != typeof window && window.document && window.document.documentElement.style, h2.selectProp = !h2.docStyle || "userSelect" in h2.docStyle ? "userSelect" : "webkitUserSelect", function(e3) {
+        let i3, o3, a3, r3;
+        e3.resetRequestQueue = () => {
+          i3 = [], o3 = 0, a3 = 0, r3 = {};
+        }, e3.addThrottleControl = (e4) => {
+          const t3 = a3++;
+          return r3[t3] = e4, t3;
+        }, e3.removeThrottleControl = (e4) => {
+          delete r3[e4], n3();
+        }, e3.getImage = (e4, o4, a4 = true) => new Promise((r4, s4) => {
+          e4.headers || (e4.headers = {}), e4.headers.accept = "image/webp,*/*", t2.e(e4, { type: "image" }), i3.push({ abortController: o4, requestParameters: e4, supportImageRefresh: a4, state: "queued", onError: (e5) => {
+            s4(e5);
+          }, onSuccess: (e5) => {
+            r4(e5);
+          } }), n3();
+        });
+        const s3 = (e4) => t2._(this, void 0, void 0, function* () {
+          e4.state = "running";
+          const { requestParameters: i4, supportImageRefresh: a4, onError: r4, onSuccess: s4, abortController: c3 } = e4, h3 = false === a4 && !t2.i(self) && !t2.g(i4.url) && (!i4.headers || Object.keys(i4.headers).reduce((e5, t3) => e5 && "accept" === t3, true));
+          o3++;
+          const u3 = h3 ? l3(i4, c3) : t2.m(i4, c3);
+          try {
+            const i5 = yield u3;
+            delete e4.abortController, e4.state = "completed", i5.data instanceof HTMLImageElement || t2.b(i5.data) ? s4(i5) : i5.data && s4({ data: yield (d3 = i5.data, "function" == typeof createImageBitmap ? t2.f(d3) : t2.h(d3)), cacheControl: i5.cacheControl, expires: i5.expires });
+          } catch (t3) {
+            delete e4.abortController, r4(t3);
+          } finally {
+            o3--, n3();
+          }
+          var d3;
+        }), n3 = () => {
+          const e4 = (() => {
+            for (const e5 of Object.keys(r3)) if (r3[e5]()) return true;
+            return false;
+          })() ? t2.c.MAX_PARALLEL_IMAGE_REQUESTS_PER_FRAME : t2.c.MAX_PARALLEL_IMAGE_REQUESTS;
+          for (let t3 = o3; t3 < e4 && i3.length > 0; t3++) {
+            const e5 = i3.shift();
+            e5.abortController.signal.aborted ? t3-- : s3(e5);
+          }
+        }, l3 = (e4, i4) => new Promise((o4, a4) => {
+          const r4 = new Image(), s4 = e4.url, n4 = e4.credentials;
+          n4 && "include" === n4 ? r4.crossOrigin = "use-credentials" : (n4 && "same-origin" === n4 || !t2.d(s4)) && (r4.crossOrigin = "anonymous"), i4.signal.addEventListener("abort", () => {
+            r4.src = "", a4(new t2.a(i4.signal.reason));
+          }), r4.fetchPriority = "high", r4.onload = () => {
+            r4.onerror = r4.onload = null, o4({ data: r4 });
+          }, r4.onerror = () => {
+            r4.onerror = r4.onload = null, i4.signal.aborted || a4(new Error("Could not load image. Please make sure to use a supported image type such as PNG or JPEG. Note that SVGs are not supported."));
+          }, r4.src = s4;
+        });
+      }(u2 || (u2 = {})), u2.resetRequestQueue();
+      class d2 {
+        constructor(e3) {
+          this._transformRequestFn = null != e3 ? e3 : null;
+        }
+        transformRequest(e3, t3) {
+          return this._transformRequestFn && this._transformRequestFn(e3, t3) || { url: e3 };
+        }
+        setTransformRequest(e3) {
+          this._transformRequestFn = e3;
+        }
+      }
+      function _2(e3) {
+        const t3 = [];
+        if ("string" == typeof e3) t3.push({ id: "default", url: e3 });
+        else if (e3 && e3.length > 0) {
+          const i3 = [];
+          for (const { id: o3, url: a3 } of e3) {
+            const e4 = `${o3}${a3}`;
+            -1 === i3.indexOf(e4) && (i3.push(e4), t3.push({ id: o3, url: a3 }));
+          }
+        }
+        return t3;
+      }
+      function p2(e3, t3, i3) {
+        try {
+          const o3 = new URL(e3);
+          return o3.pathname += `${t3}${i3}`, o3.toString();
+        } catch (t4) {
+          throw new Error(`Invalid sprite URL "${e3}", must be absolute. Modify style specification directly or use TransformStyleFunction to correct the issue dynamically`);
+        }
+      }
+      function m2(e3) {
+        const { userImage: t3 } = e3;
+        return !!(t3 && t3.render && t3.render()) && (e3.data.replace(new Uint8Array(t3.data.buffer)), true);
+      }
+      class f2 extends t2.E {
+        constructor() {
+          super(), this.images = {}, this.updatedImages = {}, this.callbackDispatchedThisFrame = {}, this.loaded = false, this.requestors = [], this.patterns = {}, this.atlasImage = new t2.R({ width: 1, height: 1 }), this.dirty = true;
+        }
+        destroy() {
+          this.atlasTexture && (this.atlasTexture.destroy(), this.atlasTexture = null);
+          for (const e3 of Object.keys(this.images)) this.removeImage(e3);
+          this.patterns = {}, this.atlasImage = new t2.R({ width: 1, height: 1 }), this.dirty = true;
+        }
+        isLoaded() {
+          return this.loaded;
+        }
+        setLoaded(e3) {
+          if (this.loaded !== e3 && (this.loaded = e3, e3)) {
+            for (const { ids: e4, promiseResolve: t3 } of this.requestors) t3(this._getImagesForIds(e4));
+            this.requestors = [];
+          }
+        }
+        getImage(e3) {
+          const i3 = this.images[e3];
+          if (i3 && !i3.data && i3.spriteData) {
+            const e4 = i3.spriteData;
+            i3.data = new t2.R({ width: e4.width, height: e4.height }, e4.context.getImageData(e4.x, e4.y, e4.width, e4.height).data), i3.spriteData = null;
+          }
+          return i3;
+        }
+        addImage(e3, t3) {
+          if (this.images[e3]) throw new Error(`Image id ${e3} already exist, use updateImage instead`);
+          this._validate(e3, t3) && (this.images[e3] = t3);
+        }
+        _validate(e3, i3) {
+          let o3 = true;
+          const a3 = i3.data || i3.spriteData;
+          return this._validateStretch(i3.stretchX, a3 && a3.width) || (this.fire(new t2.k(new Error(`Image "${e3}" has invalid "stretchX" value`))), o3 = false), this._validateStretch(i3.stretchY, a3 && a3.height) || (this.fire(new t2.k(new Error(`Image "${e3}" has invalid "stretchY" value`))), o3 = false), this._validateContent(i3.content, i3) || (this.fire(new t2.k(new Error(`Image "${e3}" has invalid "content" value`))), o3 = false), o3;
+        }
+        _validateStretch(e3, t3) {
+          if (!e3) return true;
+          let i3 = 0;
+          for (const o3 of e3) {
+            if (o3[0] < i3 || o3[1] < o3[0] || t3 < o3[1]) return false;
+            i3 = o3[1];
+          }
+          return true;
+        }
+        _validateContent(e3, t3) {
+          if (!e3) return true;
+          if (4 !== e3.length) return false;
+          const i3 = t3.spriteData, o3 = i3 && i3.width || t3.data.width, a3 = i3 && i3.height || t3.data.height;
+          return !(e3[0] < 0 || o3 < e3[0] || e3[1] < 0 || a3 < e3[1] || e3[2] < 0 || o3 < e3[2] || e3[3] < 0 || a3 < e3[3] || e3[2] < e3[0] || e3[3] < e3[1]);
+        }
+        updateImage(e3, t3, i3 = true) {
+          const o3 = this.getImage(e3);
+          if (i3 && (o3.data.width !== t3.data.width || o3.data.height !== t3.data.height)) throw new Error(`size mismatch between old image (${o3.data.width}x${o3.data.height}) and new image (${t3.data.width}x${t3.data.height}).`);
+          t3.version = o3.version + 1, this.images[e3] = t3, this.updatedImages[e3] = true;
+        }
+        removeImage(e3) {
+          const t3 = this.images[e3];
+          delete this.images[e3], delete this.patterns[e3], t3.userImage && t3.userImage.onRemove && t3.userImage.onRemove();
+        }
+        listImages() {
+          return Object.keys(this.images);
+        }
+        getImages(e3) {
+          return new Promise((t3, i3) => {
+            let o3 = true;
+            if (!this.isLoaded()) for (const t4 of e3) this.images[t4] || (o3 = false);
+            this.isLoaded() || o3 ? t3(this._getImagesForIds(e3)) : this.requestors.push({ ids: e3, promiseResolve: t3 });
+          });
+        }
+        _getImagesForIds(e3) {
+          const i3 = {};
+          for (const o3 of e3) {
+            let e4 = this.getImage(o3);
+            e4 || (this.fire(new t2.l("styleimagemissing", { id: o3 })), e4 = this.getImage(o3)), e4 ? i3[o3] = { data: e4.data.clone(), pixelRatio: e4.pixelRatio, sdf: e4.sdf, version: e4.version, stretchX: e4.stretchX, stretchY: e4.stretchY, content: e4.content, textFitWidth: e4.textFitWidth, textFitHeight: e4.textFitHeight, hasRenderCallback: Boolean(e4.userImage && e4.userImage.render) } : t2.w(`Image "${o3}" could not be loaded. Please make sure you have added the image with map.addImage() or a "sprite" property in your style. You can provide missing images by listening for the "styleimagemissing" map event.`);
+          }
+          return i3;
+        }
+        getPixelSize() {
+          const { width: e3, height: t3 } = this.atlasImage;
+          return { width: e3, height: t3 };
+        }
+        getPattern(e3) {
+          const i3 = this.patterns[e3], o3 = this.getImage(e3);
+          if (!o3) return null;
+          if (i3 && i3.position.version === o3.version) return i3.position;
+          if (i3) i3.position.version = o3.version;
+          else {
+            const i4 = { w: o3.data.width + 2, h: o3.data.height + 2, x: 0, y: 0 }, a3 = new t2.I(i4, o3);
+            this.patterns[e3] = { bin: i4, position: a3 };
+          }
+          return this._updatePatternAtlas(), this.patterns[e3].position;
+        }
+        bind(e3) {
+          const i3 = e3.gl;
+          this.atlasTexture ? this.dirty && (this.atlasTexture.update(this.atlasImage), this.dirty = false) : this.atlasTexture = new t2.T(e3, this.atlasImage, i3.RGBA), this.atlasTexture.bind(i3.LINEAR, i3.CLAMP_TO_EDGE);
+        }
+        _updatePatternAtlas() {
+          const e3 = [];
+          for (const t3 in this.patterns) e3.push(this.patterns[t3].bin);
+          const { w: i3, h: o3 } = t2.p(e3), a3 = this.atlasImage;
+          a3.resize({ width: i3 || 1, height: o3 || 1 });
+          for (const e4 in this.patterns) {
+            const { bin: i4 } = this.patterns[e4], o4 = i4.x + 1, r3 = i4.y + 1, s3 = this.getImage(e4).data, n3 = s3.width, l3 = s3.height;
+            t2.R.copy(s3, a3, { x: 0, y: 0 }, { x: o4, y: r3 }, { width: n3, height: l3 }), t2.R.copy(s3, a3, { x: 0, y: l3 - 1 }, { x: o4, y: r3 - 1 }, { width: n3, height: 1 }), t2.R.copy(s3, a3, { x: 0, y: 0 }, { x: o4, y: r3 + l3 }, { width: n3, height: 1 }), t2.R.copy(s3, a3, { x: n3 - 1, y: 0 }, { x: o4 - 1, y: r3 }, { width: 1, height: l3 }), t2.R.copy(s3, a3, { x: 0, y: 0 }, { x: o4 + n3, y: r3 }, { width: 1, height: l3 });
+          }
+          this.dirty = true;
+        }
+        beginFrame() {
+          this.callbackDispatchedThisFrame = {};
+        }
+        dispatchRenderCallbacks(e3) {
+          for (const i3 of e3) {
+            if (this.callbackDispatchedThisFrame[i3]) continue;
+            this.callbackDispatchedThisFrame[i3] = true;
+            const e4 = this.getImage(i3);
+            e4 || t2.w(`Image with ID: "${i3}" was not found`), m2(e4) && this.updateImage(i3, e4);
+          }
+        }
+        cloneImages() {
+          const e3 = {};
+          for (const t3 in this.images) {
+            const i3 = this.images[t3];
+            e3[t3] = Object.assign(Object.assign({}, i3), { data: i3.data ? i3.data.clone() : null });
+          }
+          return e3;
+        }
+      }
+      const g2 = 1e20;
+      function v2(e3, t3, i3, o3, a3, r3, s3, n3, l3) {
+        for (let c3 = t3; c3 < t3 + o3; c3++) x2(e3, i3 * r3 + c3, r3, a3, s3, n3, l3);
+        for (let c3 = i3; c3 < i3 + a3; c3++) x2(e3, c3 * r3 + t3, 1, o3, s3, n3, l3);
+      }
+      function x2(e3, t3, i3, o3, a3, r3, s3) {
+        r3[0] = 0, s3[0] = -1e20, s3[1] = g2, a3[0] = e3[t3];
+        for (let n3 = 1, l3 = 0, c3 = 0; n3 < o3; n3++) {
+          a3[n3] = e3[t3 + n3 * i3];
+          const o4 = n3 * n3;
+          do {
+            const e4 = r3[l3];
+            c3 = (a3[n3] - a3[e4] + o4 - e4 * e4) / (n3 - e4) / 2;
+          } while (c3 <= s3[l3] && --l3 > -1);
+          l3++, r3[l3] = n3, s3[l3] = c3, s3[l3 + 1] = g2;
+        }
+        for (let n3 = 0, l3 = 0; n3 < o3; n3++) {
+          for (; s3[l3 + 1] < n3; ) l3++;
+          const o4 = r3[l3], c3 = n3 - o4;
+          e3[t3 + n3 * i3] = a3[o4] + c3 * c3;
+        }
+      }
+      const b2 = t2.v.layout_symbol["text-font"].default.join(",");
+      class y2 {
+        constructor(e3, t3, i3) {
+          this.requestManager = e3, this.localIdeographFontFamily = t3, this.entries = {}, this.lang = i3;
+        }
+        setURL(e3) {
+          this.url = e3;
+        }
+        getGlyphs(e3) {
+          return t2._(this, void 0, void 0, function* () {
+            const t3 = [];
+            for (const i4 in e3) for (const o4 of e3[i4]) t3.push(this._getAndCacheGlyphsPromise(i4, o4));
+            const i3 = yield Promise.all(t3), o3 = {};
+            for (const { stack: e4, id: t4, glyph: a3 } of i3) o3[e4] || (o3[e4] = {}), o3[e4][t4] = a3 && { id: a3.id, bitmap: a3.bitmap.clone(), metrics: a3.metrics };
+            return o3;
+          });
+        }
+        _getAndCacheGlyphsPromise(e3, i3) {
+          return t2._(this, void 0, void 0, function* () {
+            let t3 = this.entries[e3];
+            t3 || (t3 = this.entries[e3] = { glyphs: {}, requests: {}, ranges: {} });
+            let o3 = t3.glyphs[i3];
+            return void 0 !== o3 ? { stack: e3, id: i3, glyph: o3 } : !this.url || this._charUsesLocalIdeographFontFamily(i3) ? (o3 = t3.glyphs[i3] = this._drawGlyph(t3, e3, i3), { stack: e3, id: i3, glyph: o3 }) : yield this._downloadAndCacheRangePromise(e3, i3);
+          });
+        }
+        _downloadAndCacheRangePromise(e3, i3) {
+          return t2._(this, void 0, void 0, function* () {
+            const t3 = this.entries[e3], o3 = Math.floor(i3 / 256);
+            if (t3.ranges[o3]) return { stack: e3, id: i3, glyph: null };
+            if (!t3.requests[o3]) {
+              const i4 = y2.loadGlyphRange(e3, o3, this.url, this.requestManager);
+              t3.requests[o3] = i4;
+            }
+            try {
+              const a3 = yield t3.requests[o3];
+              for (const e4 in a3) t3.glyphs[+e4] = a3[+e4];
+              return t3.ranges[o3] = true, { stack: e3, id: i3, glyph: a3[i3] || null };
+            } catch (a3) {
+              const r3 = t3.glyphs[i3] = this._drawGlyph(t3, e3, i3);
+              return this._warnOnMissingGlyphRange(r3, o3, i3, a3), { stack: e3, id: i3, glyph: r3 };
+            }
+          });
+        }
+        _warnOnMissingGlyphRange(e3, i3, o3, a3) {
+          const r3 = 256 * i3, s3 = r3 + 255, n3 = o3.toString(16).padStart(4, "0").toUpperCase();
+          t2.w(`Unable to load glyph range ${i3}, ${r3}-${s3}. Rendering codepoint U+${n3} locally instead. ${a3}`);
+        }
+        _charUsesLocalIdeographFontFamily(e3) {
+          return !!this.localIdeographFontFamily && t2.q(e3);
+        }
+        _drawGlyph(e3, i3, o3) {
+          const a3 = i3 === b2 && "" !== this.localIdeographFontFamily && this._charUsesLocalIdeographFontFamily(o3), r3 = a3 ? "ideographTinySDF" : "tinySDF";
+          e3[r3] || (e3[r3] = this._createTinySDF(a3 ? this.localIdeographFontFamily : i3));
+          const s3 = e3[r3].draw(String.fromCodePoint(o3)), n3 = new RegExp("^\\p{gc=Cf}+$", "u").test(String.fromCodePoint(o3));
+          return { id: o3, bitmap: new t2.r({ width: s3.width || 60, height: s3.height || 60 }, s3.data), metrics: { width: n3 ? 0 : s3.glyphWidth / 2 || 24, height: s3.glyphHeight / 2 || 24, left: s3.glyphLeft / 2 + 0.5 || 0, top: s3.glyphTop / 2 - 27.5 || -8, advance: n3 ? 0 : s3.glyphAdvance / 2 || 24, isDoubleResolution: true } };
+        }
+        _createTinySDF(e3) {
+          const t3 = e3 ? e3.split(",") : [];
+          t3.push("sans-serif");
+          const i3 = t3.map((e4) => /[-\w]+/.test(e4) ? e4 : `'${CSS.escape(e4)}'`).join(",");
+          return new y2.TinySDF({ fontSize: 48, buffer: 6, radius: 16, cutoff: 0.25, fontFamily: i3, fontWeight: this._fontWeight(t3[0]), fontStyle: this._fontStyle(t3[0]), lang: this.lang });
+        }
+        _fontStyle(e3) {
+          return /italic/i.test(e3) ? "italic" : /oblique/i.test(e3) ? "oblique" : "normal";
+        }
+        _fontWeight(e3) {
+          const t3 = { thin: 100, hairline: 100, "extra light": 200, "ultra light": 200, light: 300, normal: 400, regular: 400, medium: 500, semibold: 600, demibold: 600, bold: 700, "extra bold": 800, "ultra bold": 800, black: 900, heavy: 900, "extra black": 950, "ultra black": 950 };
+          let i3;
+          for (const [o3, a3] of Object.entries(t3)) new RegExp(`\\b${o3}\\b`, "i").test(e3) && (i3 = `${a3}`);
+          return i3;
+        }
+        destroy() {
+          for (const e3 in this.entries) {
+            const t3 = this.entries[e3];
+            t3.tinySDF && (t3.tinySDF = null), t3.ideographTinySDF && (t3.ideographTinySDF = null), t3.glyphs = {}, t3.requests = {}, t3.ranges = {};
+          }
+          this.entries = {};
+        }
+      }
+      y2.loadGlyphRange = function(e3, i3, o3, a3) {
+        return t2._(this, void 0, void 0, function* () {
+          const r3 = 256 * i3, s3 = r3 + 255, n3 = yield a3.transformRequest(o3.replace("{fontstack}", e3).replace("{range}", `${r3}-${s3}`), "Glyphs"), l3 = yield t2.n(n3, new AbortController());
+          if (!l3 || !l3.data) throw new Error(`Could not load glyph range. range: ${i3}, ${r3}-${s3}`);
+          const c3 = {};
+          for (const e4 of t2.o(l3.data)) c3[e4.id] = e4;
+          return c3;
+        });
+      }, y2.TinySDF = class {
+        constructor({ fontSize: e3 = 24, buffer: t3 = 3, radius: i3 = 8, cutoff: o3 = 0.25, fontFamily: a3 = "sans-serif", fontWeight: r3 = "normal", fontStyle: s3 = "normal", lang: n3 = null } = {}) {
+          this.buffer = t3, this.cutoff = o3, this.radius = i3, this.lang = n3;
+          const l3 = this.size = e3 + 4 * t3, c3 = this._createCanvas(l3), h3 = this.ctx = c3.getContext("2d", { willReadFrequently: true });
+          h3.font = `${s3} ${r3} ${e3}px ${a3}`, h3.textBaseline = "alphabetic", h3.textAlign = "left", h3.fillStyle = "black", this.gridOuter = new Float64Array(l3 * l3), this.gridInner = new Float64Array(l3 * l3), this.f = new Float64Array(l3), this.z = new Float64Array(l3 + 1), this.v = new Uint16Array(l3);
+        }
+        _createCanvas(e3) {
+          const t3 = document.createElement("canvas");
+          return t3.width = t3.height = e3, t3;
+        }
+        draw(e3) {
+          const { width: t3, actualBoundingBoxAscent: i3, actualBoundingBoxDescent: o3, actualBoundingBoxLeft: a3, actualBoundingBoxRight: r3 } = this.ctx.measureText(e3), s3 = Math.ceil(i3), n3 = Math.max(0, Math.min(this.size - this.buffer, Math.ceil(r3 - a3))), l3 = Math.min(this.size - this.buffer, s3 + Math.ceil(o3)), c3 = n3 + 2 * this.buffer, h3 = l3 + 2 * this.buffer, u3 = Math.max(c3 * h3, 0), d3 = new Uint8ClampedArray(u3), _3 = { data: d3, width: c3, height: h3, glyphWidth: n3, glyphHeight: l3, glyphTop: s3, glyphLeft: 0, glyphAdvance: t3 };
+          if (0 === n3 || 0 === l3) return _3;
+          const { ctx: p3, buffer: m3, gridInner: f3, gridOuter: x3 } = this;
+          this.lang && (p3.lang = this.lang), p3.clearRect(m3, m3, n3, l3), p3.fillText(e3, m3, m3 + s3);
+          const b3 = p3.getImageData(m3, m3, n3, l3);
+          x3.fill(g2, 0, u3), f3.fill(0, 0, u3);
+          for (let e4 = 0; e4 < l3; e4++) for (let t4 = 0; t4 < n3; t4++) {
+            const i4 = b3.data[4 * (e4 * n3 + t4) + 3] / 255;
+            if (0 === i4) continue;
+            const o4 = (e4 + m3) * c3 + t4 + m3;
+            if (1 === i4) x3[o4] = 0, f3[o4] = g2;
+            else {
+              const e5 = 0.5 - i4;
+              x3[o4] = e5 > 0 ? e5 * e5 : 0, f3[o4] = e5 < 0 ? e5 * e5 : 0;
+            }
+          }
+          v2(x3, 0, 0, c3, h3, c3, this.f, this.v, this.z), v2(f3, m3, m3, n3, l3, c3, this.f, this.v, this.z);
+          for (let e4 = 0; e4 < u3; e4++) {
+            const t4 = Math.sqrt(x3[e4]) - Math.sqrt(f3[e4]);
+            d3[e4] = Math.round(255 - 255 * (t4 / this.radius + this.cutoff));
+          }
+          return _3;
+        }
+      };
+      class w2 {
+        constructor() {
+          this.specification = t2.u.light.position;
+        }
+        possiblyEvaluate(e3, i3) {
+          return t2.F(e3.expression.evaluate(i3));
+        }
+        interpolate(e3, i3, o3) {
+          return { x: t2.G.number(e3.x, i3.x, o3), y: t2.G.number(e3.y, i3.y, o3), z: t2.G.number(e3.z, i3.z, o3) };
+        }
+      }
+      let T2;
+      class P2 extends t2.E {
+        constructor(e3) {
+          super(), T2 = T2 || new t2.t({ anchor: new t2.D(t2.u.light.anchor), position: new w2(), color: new t2.D(t2.u.light.color), intensity: new t2.D(t2.u.light.intensity) }), this._transitionable = new t2.x(T2, void 0), this.setLight(e3), this._transitioning = this._transitionable.untransitioned();
+        }
+        getLight() {
+          return this._transitionable.serialize();
+        }
+        setLight(e3, i3 = {}) {
+          if (!this._validate(t2.y, e3, i3)) for (const i4 in e3) {
+            const o3 = e3[i4];
+            i4.endsWith(t2.z) ? this._transitionable.setTransition(i4.slice(0, -t2.z.length), o3) : this._transitionable.setValue(i4, o3);
+          }
+        }
+        updateTransitions(e3) {
+          this._transitioning = this._transitionable.transitioned(e3, this._transitioning);
+        }
+        hasTransition() {
+          return this._transitioning.hasTransition();
+        }
+        recalculate(e3) {
+          this.properties = this._transitioning.possiblyEvaluate(e3);
+        }
+        _validate(e3, i3, o3) {
+          return (!o3 || false !== o3.validate) && t2.B(this, e3.call(t2.C, { value: i3, style: { glyphs: true, sprite: true }, styleSpec: t2.u }));
+        }
+      }
+      const C2 = new t2.t({ "sky-color": new t2.D(t2.u.sky["sky-color"]), "horizon-color": new t2.D(t2.u.sky["horizon-color"]), "fog-color": new t2.D(t2.u.sky["fog-color"]), "fog-ground-blend": new t2.D(t2.u.sky["fog-ground-blend"]), "horizon-fog-blend": new t2.D(t2.u.sky["horizon-fog-blend"]), "sky-horizon-blend": new t2.D(t2.u.sky["sky-horizon-blend"]), "atmosphere-blend": new t2.D(t2.u.sky["atmosphere-blend"]) });
+      class I2 extends t2.E {
+        constructor(e3) {
+          super(), this._transitionable = new t2.x(C2, void 0), this.setSky(e3), this._transitioning = this._transitionable.untransitioned(), this.recalculate(new t2.H(0));
+        }
+        setSky(e3, i3 = {}) {
+          if (!this._validate(t2.J, e3, i3)) {
+            e3 || (e3 = { "sky-color": "transparent", "horizon-color": "transparent", "fog-color": "transparent", "fog-ground-blend": 1, "atmosphere-blend": 0 });
+            for (const i4 in e3) {
+              const o3 = e3[i4];
+              i4.endsWith(t2.z) ? this._transitionable.setTransition(i4.slice(0, -t2.z.length), o3) : this._transitionable.setValue(i4, o3);
+            }
+          }
+        }
+        getSky() {
+          return this._transitionable.serialize();
+        }
+        updateTransitions(e3) {
+          this._transitioning = this._transitionable.transitioned(e3, this._transitioning);
+        }
+        hasTransition() {
+          return this._transitioning.hasTransition();
+        }
+        recalculate(e3) {
+          this.properties = this._transitioning.possiblyEvaluate(e3);
+        }
+        _validate(e3, i3, o3 = {}) {
+          return false !== (null == o3 ? void 0 : o3.validate) && t2.B(this, e3.call(t2.C, t2.e({ value: i3, style: { glyphs: true, sprite: true }, styleSpec: t2.u })));
+        }
+        calculateFogBlendOpacity(e3) {
+          return e3 < 60 ? 0 : e3 < 70 ? (e3 - 60) / 10 : 1;
+        }
+      }
+      class M2 {
+        constructor(e3, t3) {
+          this.width = e3, this.height = t3, this.nextRow = 0, this.data = new Uint8Array(this.width * this.height), this.dashEntry = {};
+        }
+        getDash(e3, t3) {
+          const i3 = e3.join(",") + String(t3);
+          return this.dashEntry[i3] || (this.dashEntry[i3] = this.addDash(e3, t3)), this.dashEntry[i3];
+        }
+        getDashRanges(e3, t3, i3) {
+          const o3 = [];
+          let a3 = e3.length % 2 == 1 ? -e3[e3.length - 1] * i3 : 0, r3 = e3[0] * i3, s3 = true;
+          o3.push({ left: a3, right: r3, isDash: s3, zeroLength: 0 === e3[0] });
+          let n3 = e3[0];
+          for (let t4 = 1; t4 < e3.length; t4++) {
+            s3 = !s3;
+            const l3 = e3[t4];
+            a3 = n3 * i3, n3 += l3, r3 = n3 * i3, o3.push({ left: a3, right: r3, isDash: s3, zeroLength: 0 === l3 });
+          }
+          return o3;
+        }
+        addRoundDash(e3, t3, i3) {
+          const o3 = t3 / 2;
+          for (let t4 = -i3; t4 <= i3; t4++) {
+            const a3 = this.width * (this.nextRow + i3 + t4);
+            let r3 = 0, s3 = e3[r3];
+            for (let n3 = 0; n3 < this.width; n3++) {
+              n3 / s3.right > 1 && (s3 = e3[++r3]);
+              const l3 = Math.abs(n3 - s3.left), c3 = Math.abs(n3 - s3.right), h3 = Math.min(l3, c3);
+              let u3;
+              const d3 = t4 / i3 * (o3 + 1);
+              if (s3.isDash) {
+                const e4 = o3 - Math.abs(d3);
+                u3 = Math.sqrt(h3 * h3 + e4 * e4);
+              } else u3 = o3 - Math.sqrt(h3 * h3 + d3 * d3);
+              this.data[a3 + n3] = Math.max(0, Math.min(255, u3 + 128));
+            }
+          }
+        }
+        addRegularDash(e3) {
+          for (let t4 = e3.length - 1; t4 >= 0; --t4) {
+            const i4 = e3[t4], o4 = e3[t4 + 1];
+            i4.zeroLength ? e3.splice(t4, 1) : o4 && o4.isDash === i4.isDash && (o4.left = i4.left, e3.splice(t4, 1));
+          }
+          const t3 = e3[0], i3 = e3[e3.length - 1];
+          t3.isDash === i3.isDash && (t3.left = i3.left - this.width, i3.right = t3.right + this.width);
+          const o3 = this.width * this.nextRow;
+          let a3 = 0, r3 = e3[a3];
+          for (let t4 = 0; t4 < this.width; t4++) {
+            t4 / r3.right > 1 && (r3 = e3[++a3]);
+            const i4 = Math.abs(t4 - r3.left), s3 = Math.abs(t4 - r3.right), n3 = Math.min(i4, s3);
+            this.data[o3 + t4] = Math.max(0, Math.min(255, (r3.isDash ? n3 : -n3) + 128));
+          }
+        }
+        addDash(e3, i3) {
+          const o3 = i3 ? 7 : 0, a3 = 2 * o3 + 1;
+          if (this.nextRow + a3 > this.height) return t2.w("LineAtlas out of space"), null;
+          let r3 = 0;
+          for (let t3 = 0; t3 < e3.length; t3++) r3 += e3[t3];
+          if (0 !== r3) {
+            const t3 = this.width / r3, a4 = this.getDashRanges(e3, this.width, t3);
+            i3 ? this.addRoundDash(a4, t3, o3) : this.addRegularDash(a4);
+          }
+          const s3 = { y: this.nextRow + o3, height: 2 * o3, width: r3 };
+          return this.nextRow += a3, this.dirty = true, s3;
+        }
+        bind(e3) {
+          const t3 = e3.gl;
+          this.texture ? (t3.bindTexture(t3.TEXTURE_2D, this.texture), this.dirty && (this.dirty = false, t3.texSubImage2D(t3.TEXTURE_2D, 0, 0, 0, this.width, this.height, t3.ALPHA, t3.UNSIGNED_BYTE, this.data))) : (this.texture = t3.createTexture(), t3.bindTexture(t3.TEXTURE_2D, this.texture), t3.texParameteri(t3.TEXTURE_2D, t3.TEXTURE_WRAP_S, t3.REPEAT), t3.texParameteri(t3.TEXTURE_2D, t3.TEXTURE_WRAP_T, t3.REPEAT), t3.texParameteri(t3.TEXTURE_2D, t3.TEXTURE_MIN_FILTER, t3.LINEAR), t3.texParameteri(t3.TEXTURE_2D, t3.TEXTURE_MAG_FILTER, t3.LINEAR), t3.texImage2D(t3.TEXTURE_2D, 0, t3.ALPHA, this.width, this.height, 0, t3.ALPHA, t3.UNSIGNED_BYTE, this.data));
+        }
+      }
+      const E2 = "maplibre_preloaded_worker_pool";
+      class S2 {
+        constructor() {
+          this.active = {};
+        }
+        acquire(e3) {
+          if (!this.workers) for (this.workers = []; this.workers.length < S2.workerCount; ) this.workers.push(new Worker(t2.c.WORKER_URL));
+          return this.active[e3] = true, this.workers.slice();
+        }
+        release(e3) {
+          delete this.active[e3], 0 === this.numActive() && (this.workers.forEach((e4) => {
+            e4.terminate();
+          }), this.workers = null);
+        }
+        isPreloaded() {
+          return !!this.active[E2];
+        }
+        numActive() {
+          return Object.keys(this.active).length;
+        }
+      }
+      const R2 = Math.floor(n2.hardwareConcurrency / 2);
+      let z2, D2;
+      function A2() {
+        return z2 || (z2 = new S2()), z2;
+      }
+      S2.workerCount = t2.K(globalThis) ? Math.max(Math.min(R2, 3), 1) : 1;
+      class L2 {
+        constructor(e3, i3) {
+          this.workerPool = e3, this.actors = [], this.currentActor = 0, this.id = i3;
+          const o3 = this.workerPool.acquire(i3);
+          for (let e4 = 0; e4 < o3.length; e4++) {
+            const a3 = new t2.L(o3[e4], i3);
+            a3.name = `Worker ${e4}`, this.actors.push(a3);
+          }
+          if (!this.actors.length) throw new Error("No actors found");
+        }
+        broadcast(e3, t3) {
+          const i3 = [];
+          for (const o3 of this.actors) i3.push(o3.sendAsync({ type: e3, data: t3 }));
+          return Promise.all(i3);
+        }
+        getActor() {
+          return this.currentActor = (this.currentActor + 1) % this.actors.length, this.actors[this.currentActor];
+        }
+        remove(e3 = true) {
+          this.actors.forEach((e4) => {
+            e4.remove();
+          }), this.actors = [], e3 && this.workerPool.release(this.id);
+        }
+        registerMessageHandler(e3, t3) {
+          for (const i3 of this.actors) i3.registerMessageHandler(e3, t3);
+        }
+        unregisterMessageHandler(e3) {
+          for (const t3 of this.actors) t3.unregisterMessageHandler(e3);
+        }
+      }
+      function k2() {
+        return D2 || (D2 = new L2(A2(), t2.M), D2.registerMessageHandler("GR", (e3, i3, o3) => t2.m(i3, o3))), D2;
+      }
+      function F2(e3, i3) {
+        const o3 = t2.N();
+        return t2.O(o3, o3, [1, 1, 0]), t2.Q(o3, o3, [0.5 * e3.width, 0.5 * e3.height, 1]), e3.calculatePosMatrix ? t2.S(o3, o3, e3.calculatePosMatrix(i3.toUnwrapped())) : o3;
+      }
+      function B2(e3, t3, i3, o3, a3, r3, s3) {
+        var n3;
+        const l3 = function(e4, t4, i4) {
+          if (e4) for (const o4 of e4) {
+            const e5 = t4[o4];
+            if (e5 && e5.source === i4 && "fill-extrusion" === e5.type) return true;
+          }
+          else for (const e5 in t4) {
+            const o4 = t4[e5];
+            if (o4.source === i4 && "fill-extrusion" === o4.type) return true;
+          }
+          return false;
+        }(null !== (n3 = null == a3 ? void 0 : a3.layers) && void 0 !== n3 ? n3 : null, t3, e3.id), c3 = r3.maxPitchScaleFactor(), h3 = e3.tilesIn(o3, c3, l3);
+        h3.sort(O2);
+        const u3 = [];
+        for (const o4 of h3) u3.push({ wrappedTileID: o4.tileID.wrapped().key, queryResults: o4.tile.queryRenderedFeatures(t3, i3, e3.getState(), o4.queryGeometry, o4.cameraQueryGeometry, o4.scale, a3, r3, c3, F2(r3, o4.tileID), s3 ? (e4, t4) => s3(o4.tileID, e4, t4) : void 0) });
+        return function(e4, t4) {
+          for (const i4 in e4) for (const o4 of e4[i4]) j2(o4, t4);
+          return e4;
+        }(function(e4) {
+          const t4 = {}, i4 = {};
+          for (const o4 of e4) {
+            const e5 = o4.queryResults, a4 = o4.wrappedTileID, r4 = i4[a4] = i4[a4] || {};
+            for (const i5 in e5) {
+              const o5 = e5[i5], a5 = r4[i5] = r4[i5] || {}, s4 = t4[i5] = t4[i5] || [];
+              for (const e6 of o5) a5[e6.featureIndex] || (a5[e6.featureIndex] = true, s4.push(e6));
+            }
+          }
+          return t4;
+        }(u3), e3);
+      }
+      function O2(e3, t3) {
+        const i3 = e3.tileID, o3 = t3.tileID;
+        return i3.overscaledZ - o3.overscaledZ || i3.canonical.y - o3.canonical.y || i3.wrap - o3.wrap || i3.canonical.x - o3.canonical.x;
+      }
+      function j2(e3, t3) {
+        const i3 = e3.feature, o3 = t3.getFeatureState(i3.layer["source-layer"], i3.id);
+        i3.source = i3.layer.source, i3.layer["source-layer"] && (i3.sourceLayer = i3.layer["source-layer"]), i3.state = o3;
+      }
+      function N2(e3, i3, o3, a3) {
+        return t2._(this, void 0, void 0, function* () {
+          let r3 = e3;
+          if (e3.url ? r3 = (yield t2.j(yield i3.transformRequest(e3.url, "Source"), o3)).data : yield n2.frameAsync(o3, a3), !r3) return null;
+          const s3 = t2.U(t2.e(r3, e3), ["tiles", "minzoom", "maxzoom", "attribution", "bounds", "scheme", "tileSize", "encoding"]);
+          return "vector_layers" in r3 && r3.vector_layers && (s3.vectorLayerIds = r3.vector_layers.map((e4) => e4.id)), s3;
+        });
+      }
+      class Z2 {
+        constructor(e3, t3) {
+          e3 && (t3 ? this.setSouthWest(e3).setNorthEast(t3) : Array.isArray(e3) && (4 === e3.length ? this.setSouthWest([e3[0], e3[1]]).setNorthEast([e3[2], e3[3]]) : this.setSouthWest(e3[0]).setNorthEast(e3[1])));
+        }
+        setNorthEast(e3) {
+          return this._ne = e3 instanceof t2.V ? new t2.V(e3.lng, e3.lat) : t2.V.convert(e3), this;
+        }
+        setSouthWest(e3) {
+          return this._sw = e3 instanceof t2.V ? new t2.V(e3.lng, e3.lat) : t2.V.convert(e3), this;
+        }
+        extend(e3) {
+          const i3 = this._sw, o3 = this._ne;
+          let a3, r3;
+          if (e3 instanceof t2.V) a3 = e3, r3 = e3;
+          else {
+            if (!(e3 instanceof Z2)) return Array.isArray(e3) ? 4 === e3.length || e3.every(Array.isArray) ? this.extend(Z2.convert(e3)) : this.extend(t2.V.convert(e3)) : e3 && ("lng" in e3 || "lon" in e3) && "lat" in e3 ? this.extend(t2.V.convert(e3)) : this;
+            if (a3 = e3._sw, r3 = e3._ne, !a3 || !r3) return this;
+          }
+          return i3 || o3 ? (i3.lng = Math.min(a3.lng, i3.lng), i3.lat = Math.min(a3.lat, i3.lat), o3.lng = Math.max(r3.lng, o3.lng), o3.lat = Math.max(r3.lat, o3.lat)) : (this._sw = new t2.V(a3.lng, a3.lat), this._ne = new t2.V(r3.lng, r3.lat)), this;
+        }
+        getCenter() {
+          return new t2.V((this._sw.lng + this._ne.lng) / 2, (this._sw.lat + this._ne.lat) / 2);
+        }
+        getSouthWest() {
+          return this._sw;
+        }
+        getNorthEast() {
+          return this._ne;
+        }
+        getNorthWest() {
+          return new t2.V(this.getWest(), this.getNorth());
+        }
+        getSouthEast() {
+          return new t2.V(this.getEast(), this.getSouth());
+        }
+        getWest() {
+          return this._sw.lng;
+        }
+        getSouth() {
+          return this._sw.lat;
+        }
+        getEast() {
+          return this._ne.lng;
+        }
+        getNorth() {
+          return this._ne.lat;
+        }
+        toArray() {
+          return [this._sw.toArray(), this._ne.toArray()];
+        }
+        toString() {
+          return `LngLatBounds(${this._sw.toString()}, ${this._ne.toString()})`;
+        }
+        isEmpty() {
+          return !(this._sw && this._ne);
+        }
+        contains(e3) {
+          const { lng: i3, lat: o3 } = t2.V.convert(e3);
+          let a3 = this._sw.lng <= i3 && i3 <= this._ne.lng;
+          return this._sw.lng > this._ne.lng && (a3 = this._sw.lng >= i3 && i3 >= this._ne.lng), this._sw.lat <= o3 && o3 <= this._ne.lat && a3;
+        }
+        intersects(e3) {
+          if (!((e3 = Z2.convert(e3)).getNorth() >= this.getSouth() && e3.getSouth() <= this.getNorth())) return false;
+          const i3 = Math.abs(this.getEast() - this.getWest()), o3 = Math.abs(e3.getEast() - e3.getWest());
+          if (i3 >= 360 || o3 >= 360) return true;
+          const a3 = t2.W(this.getWest(), -180, 180), r3 = t2.W(this.getEast(), -180, 180), s3 = t2.W(e3.getWest(), -180, 180), n3 = t2.W(e3.getEast(), -180, 180), l3 = a3 > r3, c3 = s3 > n3;
+          return !(!l3 || !c3) || (l3 ? n3 >= a3 || s3 <= r3 : c3 ? r3 >= s3 || a3 <= n3 : s3 <= r3 && n3 >= a3);
+        }
+        static convert(e3) {
+          return e3 instanceof Z2 ? e3 : e3 ? new Z2(e3) : e3;
+        }
+        static fromLngLat(e3, i3 = 0) {
+          const o3 = 360 * i3 / 40075017, a3 = o3 / Math.cos(Math.PI / 180 * e3.lat);
+          return new Z2(new t2.V(e3.lng - a3, e3.lat - o3), new t2.V(e3.lng + a3, e3.lat + o3));
+        }
+        adjustAntiMeridian() {
+          const e3 = new t2.V(this._sw.lng, this._sw.lat), i3 = new t2.V(this._ne.lng, this._ne.lat);
+          return new Z2(e3, e3.lng > i3.lng ? new t2.V(i3.lng + 360, i3.lat) : i3);
+        }
+      }
+      class U2 {
+        constructor(e3, t3, i3) {
+          this.bounds = Z2.convert(this.validateBounds(e3)), this.minzoom = t3 || 0, this.maxzoom = i3 || 24;
+        }
+        validateBounds(e3) {
+          return Array.isArray(e3) && 4 === e3.length ? [Math.max(-180, e3[0]), Math.max(-90, e3[1]), Math.min(180, e3[2]), Math.min(90, e3[3])] : [-180, -90, 180, 90];
+        }
+        contains(e3) {
+          const i3 = Math.pow(2, e3.z), o3 = Math.floor(t2.Y(this.bounds.getWest()) * i3), a3 = Math.floor(t2.X(this.bounds.getNorth()) * i3), r3 = Math.ceil(t2.Y(this.bounds.getEast()) * i3), s3 = Math.ceil(t2.X(this.bounds.getSouth()) * i3);
+          return e3.x >= o3 && e3.x < r3 && e3.y >= a3 && e3.y < s3;
+        }
+      }
+      class G2 extends t2.E {
+        constructor(e3, i3, o3, a3) {
+          if (super(), this.id = e3, this.dispatcher = o3, this.type = "vector", this.minzoom = 0, this.maxzoom = 22, this.scheme = "xyz", this.tileSize = 512, this.reparseOverscaled = true, this.isTileClipped = true, this._loaded = false, t2.e(this, t2.U(i3, ["url", "scheme", "tileSize", "promoteId", "encoding"])), this._options = t2.e({ type: "vector" }, i3), this._collectResourceTiming = i3.collectResourceTiming, 512 !== this.tileSize) throw new Error("vector tile sources must have a tileSize of 512");
+          this.setEventedParent(a3);
+        }
+        load() {
+          return t2._(this, arguments, void 0, function* (e3 = false) {
+            this._loaded = false, this.fire(new t2.l("dataloading", { dataType: "source" })), this._tileJSONRequest = new AbortController();
+            try {
+              const i3 = yield N2(this._options, this.map._requestManager, this._tileJSONRequest, this.map._ownerWindow);
+              this._tileJSONRequest = null, this._loaded = true, i3 && (t2.e(this, i3), i3.bounds && (this.tileBounds = new U2(i3.bounds, this.minzoom, this.maxzoom)), this.fire(new t2.l("data", { dataType: "source", sourceDataType: "metadata" })), this.fire(new t2.l("data", { dataType: "source", sourceDataType: "content", sourceDataChanged: e3 })));
+            } catch (e4) {
+              this._tileJSONRequest = null, this._loaded = true, t2.Z(e4) || this.fire(new t2.k(e4));
+            }
+          });
+        }
+        loaded() {
+          return this._loaded;
+        }
+        hasTile(e3) {
+          return !this.tileBounds || this.tileBounds.contains(e3.canonical);
+        }
+        onAdd(e3) {
+          this.map = e3, this.load();
+        }
+        setSourceProperty(e3) {
+          this._tileJSONRequest && this._tileJSONRequest.abort(), e3(), this.load(true);
+        }
+        setTiles(e3) {
+          return this.setSourceProperty(() => {
+            this._options.tiles = e3;
+          }), this;
+        }
+        setUrl(e3) {
+          return this.setSourceProperty(() => {
+            this.url = e3, this._options.url = e3;
+          }), this;
+        }
+        onRemove() {
+          this._tileJSONRequest && (this._tileJSONRequest.abort(), this._tileJSONRequest = null);
+        }
+        serialize() {
+          return t2.e({}, this._options);
+        }
+        loadTile(e3) {
+          return t2._(this, void 0, void 0, function* () {
+            const t3 = e3.tileID.canonical.url(this.tiles, this.map.getPixelRatio(), this.scheme), i3 = { request: yield this.map._requestManager.transformRequest(t3, "Tile"), uid: e3.uid, tileID: e3.tileID, zoom: e3.tileID.overscaledZ, tileSize: this.tileSize * e3.tileID.overscaleFactor(), type: this.type, source: this.id, pixelRatio: this.map.getPixelRatio(), showCollisionBoxes: this.map.showCollisionBoxes, promoteId: this.promoteId, subdivisionGranularity: this.map.style.projection.subdivisionGranularity, encoding: this.encoding, overzoomParameters: yield this._getOverzoomParameters(e3), etag: e3.etag };
+            i3.request.collectResourceTiming = this._collectResourceTiming;
+            let o3 = "RT";
+            if (e3.actor && "expired" !== e3.state) {
+              if ("loading" === e3.state) return new Promise((t4, i4) => {
+                e3.reloadPromise = { resolve: t4, reject: i4 };
+              });
+            } else e3.actor = this.dispatcher.getActor(), o3 = "LT";
+            e3.abortController = new AbortController();
+            try {
+              const t4 = yield e3.actor.sendAsync({ type: o3, data: i3 }, e3.abortController);
+              if (delete e3.abortController, e3.aborted) return;
+              this._afterTileLoadWorkerResponse(e3, t4);
+              const a3 = {};
+              return (null == t4 ? void 0 : t4.etagUnmodified) && (a3.unmodified = true), a3;
+            } catch (t4) {
+              if (delete e3.abortController, e3.aborted) return;
+              if (t4 && 404 !== t4.status) throw t4;
+              this._afterTileLoadWorkerResponse(e3, null);
+            }
+          });
+        }
+        _getOverzoomParameters(e3) {
+          return t2._(this, void 0, void 0, function* () {
+            if (e3.tileID.canonical.z <= this.maxzoom) return;
+            if (void 0 === this.map._zoomLevelsToOverscale) return;
+            const t3 = e3.tileID.scaledTo(this.maxzoom).canonical, i3 = t3.url(this.tiles, this.map.getPixelRatio(), this.scheme);
+            return { maxZoomTileID: t3, overzoomRequest: yield this.map._requestManager.transformRequest(i3, "Tile") };
+          });
+        }
+        _afterTileLoadWorkerResponse(e3, t3) {
+          if ((null == t3 ? void 0 : t3.resourceTiming) && (e3.resourceTiming = t3.resourceTiming), t3 && this.map._refreshExpiredTiles && e3.setExpiryData(t3), e3.etag = null == t3 ? void 0 : t3.etag, e3.loadVectorData(t3, this.map.painter), e3.reloadPromise) {
+            const t4 = e3.reloadPromise;
+            e3.reloadPromise = null, this.loadTile(e3).then(t4.resolve).catch(t4.reject);
+          }
+        }
+        abortTile(e3) {
+          return t2._(this, void 0, void 0, function* () {
+            e3.abortController && (e3.abortController.abort(), delete e3.abortController), e3.actor && (yield e3.actor.sendAsync({ type: "AT", data: { uid: e3.uid, type: this.type, source: this.id } }));
+          });
+        }
+        unloadTile(e3) {
+          return t2._(this, void 0, void 0, function* () {
+            e3.unloadVectorData(), e3.actor && (yield e3.actor.sendAsync({ type: "RMT", data: { uid: e3.uid, type: this.type, source: this.id } }));
+          });
+        }
+        hasTransition() {
+          return false;
+        }
+      }
+      class V2 extends t2.E {
+        constructor(e3, i3, o3, a3) {
+          super(), this.id = e3, this.dispatcher = o3, this.setEventedParent(a3), this.type = "raster", this.minzoom = 0, this.maxzoom = 22, this.roundZoom = true, this.scheme = "xyz", this.tileSize = 512, this._loaded = false, this._options = t2.e({ type: "raster" }, i3), t2.e(this, t2.U(i3, ["url", "scheme", "tileSize"]));
+        }
+        load() {
+          return t2._(this, arguments, void 0, function* (e3 = false) {
+            this._loaded = false, this.fire(new t2.l("dataloading", { dataType: "source" })), this._tileJSONRequest = new AbortController();
+            try {
+              const i3 = yield N2(this._options, this.map._requestManager, this._tileJSONRequest, this.map._ownerWindow);
+              this._tileJSONRequest = null, this._loaded = true, i3 && (t2.e(this, i3), i3.bounds && (this.tileBounds = new U2(i3.bounds, this.minzoom, this.maxzoom)), this.fire(new t2.l("data", { dataType: "source", sourceDataType: "metadata" })), this.fire(new t2.l("data", { dataType: "source", sourceDataType: "content", sourceDataChanged: e3 })));
+            } catch (e4) {
+              this._tileJSONRequest = null, this._loaded = true, t2.Z(e4) || this.fire(new t2.k(e4));
+            }
+          });
+        }
+        loaded() {
+          return this._loaded;
+        }
+        onAdd(e3) {
+          this.map = e3, this.load();
+        }
+        onRemove() {
+          this._tileJSONRequest && (this._tileJSONRequest.abort(), this._tileJSONRequest = null);
+        }
+        setSourceProperty(e3) {
+          this._tileJSONRequest && (this._tileJSONRequest.abort(), this._tileJSONRequest = null), e3(), this.load(true);
+        }
+        setTiles(e3) {
+          return this.setSourceProperty(() => {
+            this._options.tiles = e3;
+          }), this;
+        }
+        setUrl(e3) {
+          return this.setSourceProperty(() => {
+            this.url = e3, this._options.url = e3;
+          }), this;
+        }
+        serialize() {
+          return t2.e({}, this._options);
+        }
+        hasTile(e3) {
+          return !this.tileBounds || this.tileBounds.contains(e3.canonical);
+        }
+        loadTile(e3) {
+          return t2._(this, void 0, void 0, function* () {
+            const i3 = e3.tileID.canonical.url(this.tiles, this.map.getPixelRatio(), this.scheme);
+            e3.abortController = new AbortController();
+            try {
+              const o3 = yield u2.getImage(yield this.map._requestManager.transformRequest(i3, "Tile"), e3.abortController, this.map._refreshExpiredTiles);
+              if (delete e3.abortController, e3.aborted) return void (e3.state = "unloaded");
+              if (o3 && o3.data) {
+                this.map._refreshExpiredTiles && (o3.cacheControl || o3.expires) && e3.setExpiryData({ cacheControl: o3.cacheControl, expires: o3.expires });
+                const i4 = this.map.painter.context, a3 = i4.gl, r3 = o3.data;
+                e3.texture = this.map.painter.getTileTexture(r3.width), e3.texture ? e3.texture.update(r3, { useMipmap: true }) : (e3.texture = new t2.T(i4, r3, a3.RGBA, { useMipmap: true }), e3.texture.bind(a3.LINEAR, a3.CLAMP_TO_EDGE, a3.LINEAR_MIPMAP_NEAREST)), e3.state = "loaded";
+              }
+            } catch (t3) {
+              if (delete e3.abortController, e3.aborted) e3.state = "unloaded";
+              else if (t3) throw e3.state = "errored", t3;
+            }
+          });
+        }
+        abortTile(e3) {
+          return t2._(this, void 0, void 0, function* () {
+            e3.abortController && (e3.abortController.abort(), delete e3.abortController);
+          });
+        }
+        unloadTile(e3) {
+          return t2._(this, void 0, void 0, function* () {
+            e3.texture && this.map.painter.saveTileTexture(e3.texture);
+          });
+        }
+        hasTransition() {
+          return false;
+        }
+      }
+      class W2 extends V2 {
+        constructor(e3, i3, o3, a3) {
+          super(e3, i3, o3, a3), this.type = "raster-dem", this.maxzoom = 22, this._options = t2.e({ type: "raster-dem" }, i3), this.encoding = i3.encoding || "mapbox", this.redFactor = i3.redFactor, this.greenFactor = i3.greenFactor, this.blueFactor = i3.blueFactor, this.baseShift = i3.baseShift;
+        }
+        loadTile(e3) {
+          return t2._(this, void 0, void 0, function* () {
+            const i3 = e3.tileID.canonical.url(this.tiles, this.map.getPixelRatio(), this.scheme), o3 = yield this.map._requestManager.transformRequest(i3, "Tile");
+            e3.neighboringTiles = this._getNeighboringTiles(e3.tileID), e3.abortController = new AbortController();
+            try {
+              const i4 = yield u2.getImage(o3, e3.abortController, this.map._refreshExpiredTiles);
+              if (delete e3.abortController, e3.aborted) return void (e3.state = "unloaded");
+              if (i4 && i4.data) {
+                const o4 = i4.data;
+                this.map._refreshExpiredTiles && (i4.cacheControl || i4.expires) && e3.setExpiryData({ cacheControl: i4.cacheControl, expires: i4.expires });
+                const a3 = t2.b(o4) && t2.$() ? o4 : yield this.readImageNow(o4), r3 = { type: this.type, uid: e3.uid, source: this.id, rawImageData: a3, encoding: this.encoding, redFactor: this.redFactor, greenFactor: this.greenFactor, blueFactor: this.blueFactor, baseShift: this.baseShift };
+                if (e3.actor && "expired" !== e3.state && "reloading" !== e3.state) return;
+                e3.actor && "expired" !== e3.state || (e3.actor = this.dispatcher.getActor());
+                const s3 = yield e3.actor.sendAsync({ type: "LDT", data: r3 });
+                e3.dem = s3, e3.needsHillshadePrepare = true, e3.needsTerrainPrepare = true, e3.state = "loaded";
+              }
+            } catch (t3) {
+              if (delete e3.abortController, e3.aborted) e3.state = "unloaded";
+              else if (t3) throw e3.state = "errored", t3;
+            }
+          });
+        }
+        readImageNow(e3) {
+          return t2._(this, void 0, void 0, function* () {
+            if ("undefined" != typeof VideoFrame && t2.a0()) {
+              const i3 = e3.width + 2, o3 = e3.height + 2;
+              try {
+                return new t2.R({ width: i3, height: o3 }, yield t2.a1(e3, -1, -1, i3, o3));
+              } catch (e4) {
+              }
+            }
+            return n2.getImageData(e3, 1);
+          });
+        }
+        _getNeighboringTiles(e3) {
+          const i3 = e3.canonical, o3 = Math.pow(2, i3.z), a3 = (i3.x - 1 + o3) % o3, r3 = 0 === i3.x ? e3.wrap - 1 : e3.wrap, s3 = (i3.x + 1 + o3) % o3, n3 = i3.x + 1 === o3 ? e3.wrap + 1 : e3.wrap, l3 = {};
+          return l3[new t2.a2(e3.overscaledZ, r3, i3.z, a3, i3.y).key] = { backfilled: false }, l3[new t2.a2(e3.overscaledZ, n3, i3.z, s3, i3.y).key] = { backfilled: false }, i3.y > 0 && (l3[new t2.a2(e3.overscaledZ, r3, i3.z, a3, i3.y - 1).key] = { backfilled: false }, l3[new t2.a2(e3.overscaledZ, e3.wrap, i3.z, i3.x, i3.y - 1).key] = { backfilled: false }, l3[new t2.a2(e3.overscaledZ, n3, i3.z, s3, i3.y - 1).key] = { backfilled: false }), i3.y + 1 < o3 && (l3[new t2.a2(e3.overscaledZ, r3, i3.z, a3, i3.y + 1).key] = { backfilled: false }, l3[new t2.a2(e3.overscaledZ, e3.wrap, i3.z, i3.x, i3.y + 1).key] = { backfilled: false }, l3[new t2.a2(e3.overscaledZ, n3, i3.z, s3, i3.y + 1).key] = { backfilled: false }), l3;
+        }
+        unloadTile(e3) {
+          return t2._(this, void 0, void 0, function* () {
+            e3.demTexture && this.map.painter.saveTileTexture(e3.demTexture), e3.fbo && (e3.fbo.destroy(), delete e3.fbo), e3.dem && delete e3.dem, delete e3.neighboringTiles, e3.state = "unloaded", e3.actor && (yield e3.actor.sendAsync({ type: "RDT", data: { type: this.type, uid: e3.uid, source: this.id } }));
+          });
+        }
+      }
+      function q2(e3, t3) {
+        return t3 ? e3.properties[t3] : e3.id;
+      }
+      function $2(e3, t3) {
+        const i3 = { id: e3.id };
+        if (t3.removeAllProperties && (delete e3.removeProperties, delete e3.addOrUpdateProperties, delete t3.removeProperties), t3.removeProperties) for (const i4 of t3.removeProperties) {
+          const t4 = e3.addOrUpdateProperties.findIndex((e4) => e4.key === i4);
+          t4 > -1 && e3.addOrUpdateProperties.splice(t4, 1);
+        }
+        return (e3.removeAllProperties || t3.removeAllProperties) && (i3.removeAllProperties = true), (e3.removeProperties || t3.removeProperties) && (i3.removeProperties = [...e3.removeProperties || [], ...t3.removeProperties || []]), (e3.addOrUpdateProperties || t3.addOrUpdateProperties) && (i3.addOrUpdateProperties = [...e3.addOrUpdateProperties || [], ...t3.addOrUpdateProperties || []]), (e3.newGeometry || t3.newGeometry) && (i3.newGeometry = t3.newGeometry || e3.newGeometry), i3;
+      }
+      function H2(e3) {
+        var t3, i3;
+        if (!e3) return {};
+        const o3 = {};
+        return o3.removeAll = e3.removeAll, o3.remove = new Set(e3.remove || []), o3.add = new Map(null === (t3 = e3.add) || void 0 === t3 ? void 0 : t3.map((e4) => [e4.id, e4])), o3.update = new Map(null === (i3 = e3.update) || void 0 === i3 ? void 0 : i3.map((e4) => [e4.id, e4])), o3;
+      }
+      function X2(e3) {
+        return e3 && 0 !== e3.length ? "number" == typeof e3[0] ? [e3] : e3.flatMap((e4) => X2(e4)) : [];
+      }
+      function Y2(e3) {
+        return "GeometryCollection" === e3.type ? e3.geometries.flatMap((e4) => Y2(e4)) : X2(e3.coordinates);
+      }
+      function K2(e3) {
+        const t3 = new Z2();
+        let i3;
+        switch (e3.type) {
+          case "FeatureCollection":
+            i3 = e3.features.flatMap((e4) => Y2(e4.geometry));
+            break;
+          case "Feature":
+            i3 = Y2(e3.geometry);
+            break;
+          default:
+            i3 = Y2(e3);
+        }
+        if (0 === i3.length) return t3;
+        for (let e4 = 0; e4 < i3.length; e4++) {
+          const [o3, a3] = i3[e4];
+          t3.extend([o3, a3]);
+        }
+        return t3;
+      }
+      class Q2 extends t2.E {
+        constructor(e3, i3, o3, a3) {
+          super(), this.id = e3, this.type = "geojson", this.minzoom = 0, this.maxzoom = 18, this.tileSize = 512, this.isTileClipped = true, this.reparseOverscaled = true, this._removed = false, this._isUpdatingWorker = false, this._pendingWorkerUpdate = { data: i3.data }, this.actor = o3.getActor(), this.setEventedParent(a3), this._data = "string" == typeof i3.data ? { url: i3.data } : { geojson: i3.data }, this._options = t2.e({}, i3), this._collectResourceTiming = i3.collectResourceTiming, void 0 !== i3.maxzoom && (this.maxzoom = i3.maxzoom), i3.type && (this.type = i3.type), i3.attribution && (this.attribution = i3.attribution), this.promoteId = i3.promoteId, void 0 !== i3.clusterMaxZoom && this.maxzoom <= i3.clusterMaxZoom && t2.w(`The maxzoom value "${this.maxzoom}" is expected to be greater than the clusterMaxZoom value "${i3.clusterMaxZoom}".`), this.workerOptions = t2.e({ source: this.id, cluster: i3.cluster || false, geojsonVtOptions: { buffer: this._pixelsToTileUnits(void 0 !== i3.buffer ? i3.buffer : 128), tolerance: this._pixelsToTileUnits(void 0 !== i3.tolerance ? i3.tolerance : 0.375), extent: t2.a5, maxZoom: this.maxzoom, lineMetrics: i3.lineMetrics || false, generateId: i3.generateId || false }, superclusterOptions: { maxZoom: this._getClusterMaxZoom(i3.clusterMaxZoom), minPoints: Math.max(2, i3.clusterMinPoints || 2), extent: t2.a5, radius: this._pixelsToTileUnits(i3.clusterRadius || 50), log: false, generateId: i3.generateId || false }, clusterProperties: i3.clusterProperties, filter: i3.filter }, i3.workerOptions), "string" == typeof this.promoteId && (this.workerOptions.promoteId = this.promoteId);
+        }
+        _hasPendingWorkerUpdate() {
+          return void 0 !== this._pendingWorkerUpdate.data || void 0 !== this._pendingWorkerUpdate.diff || this._pendingWorkerUpdate.updateCluster;
+        }
+        _pixelsToTileUnits(e3) {
+          return e3 * (t2.a5 / this.tileSize);
+        }
+        _getClusterMaxZoom(e3) {
+          const i3 = e3 ? Math.round(e3) : this.maxzoom - 1;
+          return Number.isInteger(e3) || void 0 === e3 || t2.w(`Integer expected for option 'clusterMaxZoom': provided value "${e3}" rounded to "${i3}"`), i3;
+        }
+        load() {
+          return t2._(this, void 0, void 0, function* () {
+            yield this._updateWorkerData();
+          });
+        }
+        onAdd(e3) {
+          this.map = e3, this.load();
+        }
+        setData(e3, t3) {
+          this._data = "string" == typeof e3 ? { url: e3 } : { geojson: e3 }, this._pendingWorkerUpdate = { data: e3 };
+          const i3 = this._updateWorkerData();
+          return t3 ? i3 : this;
+        }
+        updateData(e3, t3) {
+          this._pendingWorkerUpdate.diff = function(e4, t4) {
+            if (!e4) return t4 || {};
+            if (!t4) return e4 || {};
+            const i4 = H2(e4), o3 = H2(t4);
+            !function(e5, t5) {
+              t5.removeAll && (e5.add.clear(), e5.update.clear(), e5.remove.clear(), t5.remove.clear());
+              for (const i5 of t5.remove) e5.add.delete(i5), e5.update.delete(i5);
+              for (const [i5, o4] of t5.update) {
+                const a4 = e5.update.get(i5);
+                a4 && (t5.update.set(i5, $2(a4, o4)), e5.update.delete(i5));
+              }
+            }(i4, o3);
+            const a3 = {};
+            if ((i4.removeAll || o3.removeAll) && (a3.removeAll = true), a3.remove = /* @__PURE__ */ new Set([...i4.remove, ...o3.remove]), a3.add = new Map([...i4.add, ...o3.add]), a3.update = new Map([...i4.update, ...o3.update]), a3.remove.size && a3.add.size) for (const e5 of a3.add.keys()) a3.remove.delete(e5);
+            return function(e5) {
+              const t5 = {};
+              return e5.removeAll && (t5.removeAll = e5.removeAll), e5.remove && (t5.remove = Array.from(e5.remove)), e5.add && (t5.add = Array.from(e5.add.values())), e5.update && (t5.update = Array.from(e5.update.values())), t5;
+            }(a3);
+          }(this._pendingWorkerUpdate.diff, e3);
+          const i3 = this._updateWorkerData();
+          return t3 ? i3 : this;
+        }
+        getData() {
+          return t2._(this, void 0, void 0, function* () {
+            return this._data.url && (yield this.once("data")), this._data.geojson ? this._data.geojson : { type: "FeatureCollection", features: Array.from(this._data.updateable.values()) };
+          });
+        }
+        getBounds() {
+          return t2._(this, void 0, void 0, function* () {
+            return K2(yield this.getData());
+          });
+        }
+        setClusterOptions(e3) {
+          return this.workerOptions.cluster = e3.cluster, void 0 !== e3.clusterRadius && (this.workerOptions.superclusterOptions.radius = this._pixelsToTileUnits(e3.clusterRadius)), void 0 !== e3.clusterMaxZoom && (this.workerOptions.superclusterOptions.maxZoom = this._getClusterMaxZoom(e3.clusterMaxZoom)), this._pendingWorkerUpdate.updateCluster = true, this._updateWorkerData(), this;
+        }
+        getClusterExpansionZoom(e3) {
+          return this.actor.sendAsync({ type: "GCEZ", data: { type: this.type, clusterId: e3, source: this.id } });
+        }
+        getClusterChildren(e3) {
+          return this.actor.sendAsync({ type: "GCC", data: { type: this.type, clusterId: e3, source: this.id } });
+        }
+        getClusterLeaves(e3, t3, i3) {
+          return this.actor.sendAsync({ type: "GCL", data: { type: this.type, source: this.id, clusterId: e3, limit: t3, offset: i3 } });
+        }
+        _updateWorkerData() {
+          return t2._(this, void 0, void 0, function* () {
+            if (this._isUpdatingWorker) return;
+            if (!this._hasPendingWorkerUpdate()) return void t2.w(`No pending worker updates for GeoJSONSource ${this.id}.`);
+            const { data: e3, diff: i3, updateCluster: o3 } = this._pendingWorkerUpdate, a3 = this._getLoadGeoJSONParameters(e3, i3, o3);
+            void 0 !== e3 ? this._pendingWorkerUpdate.data = void 0 : i3 ? this._pendingWorkerUpdate.diff = void 0 : o3 && (this._pendingWorkerUpdate.updateCluster = void 0), yield this._dispatchWorkerUpdate(a3);
+          });
+        }
+        _getLoadGeoJSONParameters(e3, i3, o3) {
+          return t2._(this, void 0, void 0, function* () {
+            const a3 = t2.e({ type: this.type }, this.workerOptions);
+            return "string" == typeof e3 ? (a3.request = yield this.map._requestManager.transformRequest(n2.resolveURL(e3), "Source"), a3.request.collectResourceTiming = this._collectResourceTiming, a3) : void 0 !== e3 ? (a3.data = e3, a3) : i3 ? (a3.dataDiff = i3, a3) : o3 ? (a3.updateCluster = true, a3) : void 0;
+          });
+        }
+        _dispatchWorkerUpdate(e3) {
+          return t2._(this, void 0, void 0, function* () {
+            this._isUpdatingWorker = true, this.fire(new t2.l("dataloading", { dataType: "source" }));
+            try {
+              const i3 = yield e3, o3 = yield this.actor.sendAsync({ type: "LD", data: i3 });
+              if (this._isUpdatingWorker = false, this._removed || o3.abandoned) return void this.fire(new t2.l("dataabort", { dataType: "source" }));
+              o3.data && (this._data = { geojson: o3.data });
+              const a3 = this._applyDiffToSource(i3.dataDiff), r3 = this._getShouldReloadTileOptions(a3), s3 = { dataType: "source" };
+              this._applyResourceTiming(s3, o3), this.fire(new t2.l("data", Object.assign(Object.assign({}, s3), { sourceDataType: "metadata" }))), this.fire(new t2.l("data", Object.assign(Object.assign({}, s3), { sourceDataType: "content", shouldReloadTileOptions: r3 })));
+            } catch (e4) {
+              if (this._isUpdatingWorker = false, this._removed) return void this.fire(new t2.l("dataabort", { dataType: "source" }));
+              this.fire(new t2.k(e4));
+            } finally {
+              this._hasPendingWorkerUpdate() && this._updateWorkerData();
+            }
+          });
+        }
+        _applyResourceTiming(e3, i3) {
+          var o3;
+          if (!this._collectResourceTiming) return;
+          const a3 = null === (o3 = i3.resourceTiming) || void 0 === o3 ? void 0 : o3[this.id];
+          if (!a3) return;
+          const r3 = a3.slice(0);
+          (null == r3 ? void 0 : r3.length) && t2.e(e3, { resourceTiming: r3 });
+        }
+        _applyDiffToSource(e3) {
+          if (!e3) return;
+          const t3 = "string" == typeof this.promoteId ? this.promoteId : void 0;
+          if (!this._data.url && !this._data.updateable) {
+            const e4 = function(e5, t4) {
+              const i4 = /* @__PURE__ */ new Map();
+              if (null == e5) return i4;
+              if (null == e5.type) return i4;
+              if ("Feature" === e5.type) {
+                const o3 = q2(e5, t4);
+                if (null == o3) return;
+                return i4.set(o3, e5), i4;
+              }
+              if ("FeatureCollection" === e5.type) {
+                const o3 = /* @__PURE__ */ new Set();
+                for (const a3 of e5.features) {
+                  const e6 = q2(a3, t4);
+                  if (null == e6) return;
+                  if (o3.has(e6)) return;
+                  o3.add(e6), i4.set(e6, a3);
+                }
+                return i4;
+              }
+            }(this._data.geojson, t3);
+            if (!e4) throw new Error(`GeoJSONSource "${this.id}": GeoJSON data is not compatible with updateData`);
+            this._data = { updateable: e4 };
+          }
+          if (!this._data.updateable) return;
+          const i3 = function(e4, t4, i4) {
+            var o3, a3;
+            const r3 = [];
+            if (t4.removeAll) e4.clear();
+            else if (t4.remove) for (const i5 of t4.remove) {
+              const t5 = e4.get(i5);
+              t5 && (r3.push(t5.geometry), e4.delete(i5));
+            }
+            if (t4.add) for (const o4 of t4.add) {
+              const t5 = q2(o4, i4);
+              if (null == t5) continue;
+              const a4 = e4.get(t5);
+              a4 && r3.push(a4.geometry), r3.push(o4.geometry), e4.set(t5, o4);
+            }
+            if (t4.update) for (const i5 of t4.update) {
+              const t5 = e4.get(i5.id);
+              if (!t5) continue;
+              const s3 = !!i5.newGeometry, n3 = i5.removeAllProperties || (null === (o3 = i5.removeProperties) || void 0 === o3 ? void 0 : o3.length) > 0 || (null === (a3 = i5.addOrUpdateProperties) || void 0 === a3 ? void 0 : a3.length) > 0;
+              if (!s3 && !n3) continue;
+              r3.push(t5.geometry);
+              const l3 = Object.assign({}, t5);
+              if (e4.set(i5.id, l3), s3 && (r3.push(i5.newGeometry), l3.geometry = i5.newGeometry), n3) {
+                if (l3.properties = i5.removeAllProperties ? {} : Object.assign({}, l3.properties || {}), i5.removeProperties) for (const e5 of i5.removeProperties) delete l3.properties[e5];
+                if (i5.addOrUpdateProperties) for (const { key: e5, value: t6 } of i5.addOrUpdateProperties) l3.properties[e5] = t6;
+              }
+            }
+            return r3;
+          }(this._data.updateable, e3, t3);
+          return e3.removeAll || this._options.cluster ? void 0 : i3;
+        }
+        _getShouldReloadTileOptions(e3) {
+          if (e3) return { affectedBounds: e3.filter(Boolean).map((e4) => K2(e4)) };
+        }
+        shouldReloadTile(e3, { affectedBounds: i3 }) {
+          if ("loading" === e3.state) return true;
+          if ("unloaded" === e3.state) return false;
+          const { buffer: o3, extent: a3 } = this.workerOptions.geojsonVtOptions, r3 = function({ x: e4, y: i4, z: o4 }, a4 = 0) {
+            const r4 = t2.a3((e4 - a4) / Math.pow(2, o4)), s3 = t2.a4((i4 + 1 + a4) / Math.pow(2, o4)), n3 = t2.a3((e4 + 1 + a4) / Math.pow(2, o4)), l3 = t2.a4((i4 - a4) / Math.pow(2, o4));
+            return new Z2([r4, s3], [n3, l3]);
+          }(e3.tileID.canonical, o3 / a3);
+          for (const e4 of i3) if (r3.intersects(e4)) return true;
+          return false;
+        }
+        loaded() {
+          return !this._isUpdatingWorker && !this._hasPendingWorkerUpdate();
+        }
+        loadTile(e3) {
+          return t2._(this, void 0, void 0, function* () {
+            const t3 = e3.actor ? "RT" : "LT";
+            e3.actor = this.actor;
+            const i3 = { type: this.type, uid: e3.uid, tileID: e3.tileID, zoom: e3.tileID.overscaledZ, maxZoom: this.maxzoom, tileSize: this.tileSize, source: this.id, pixelRatio: this.map.getPixelRatio(), showCollisionBoxes: this.map.showCollisionBoxes, promoteId: this.promoteId, subdivisionGranularity: this.map.style.projection.subdivisionGranularity };
+            e3.abortController = new AbortController();
+            const o3 = yield this.actor.sendAsync({ type: t3, data: i3 }, e3.abortController);
+            delete e3.abortController, e3.unloadVectorData(), e3.aborted || e3.loadVectorData(o3, this.map.painter, "RT" === t3);
+          });
+        }
+        abortTile(e3) {
+          return t2._(this, void 0, void 0, function* () {
+            e3.abortController && (e3.abortController.abort(), delete e3.abortController), e3.aborted = true;
+          });
+        }
+        unloadTile(e3) {
+          return t2._(this, void 0, void 0, function* () {
+            e3.unloadVectorData(), yield this.actor.sendAsync({ type: "RMT", data: { uid: e3.uid, type: this.type, source: this.id } });
+          });
+        }
+        onRemove() {
+          this._removed = true, this.actor.sendAsync({ type: "RS", data: { type: this.type, source: this.id } });
+        }
+        serialize() {
+          return t2.e({}, this._options, { type: this.type, data: this._data.updateable ? { type: "FeatureCollection", features: Array.from(this._data.updateable.values()) } : this._data.url || this._data.geojson });
+        }
+        hasTransition() {
+          return false;
+        }
+      }
+      class J2 extends t2.E {
+        constructor(e3, t3, i3, o3) {
+          super(), this.flippedWindingOrder = false, this.id = e3, this.dispatcher = i3, this.coordinates = t3.coordinates, this.type = "image", this.minzoom = 0, this.maxzoom = 22, this.tileSize = 512, this.tiles = {}, this._loaded = false, this.setEventedParent(o3), this.options = t3;
+        }
+        load(e3) {
+          return t2._(this, void 0, void 0, function* () {
+            this._loaded = false, this.fire(new t2.l("dataloading", { dataType: "source" })), this.url = this.options.url, this._request = new AbortController();
+            try {
+              const t3 = yield u2.getImage(yield this.map._requestManager.transformRequest(this.url, "Image"), this._request);
+              this._request = null, this._loaded = true, t3 && t3.data && (this.image = t3.data, e3 && (this.coordinates = e3), this._finishLoading());
+            } catch (e4) {
+              this._request = null, this._loaded = true, t2.Z(e4) || this.fire(new t2.k(e4));
+            }
+          });
+        }
+        loaded() {
+          return this._loaded;
+        }
+        updateImage(e3) {
+          return e3.url ? (this._request && (this._request.abort(), this._request = null), this.options.url = e3.url, this.load(e3.coordinates).finally(() => {
+            this.texture = null;
+          }), this) : this;
+        }
+        _finishLoading() {
+          this.map && (this.setCoordinates(this.coordinates), this.fire(new t2.l("data", { dataType: "source", sourceDataType: "metadata" })));
+        }
+        onAdd(e3) {
+          this.map = e3, this.load();
+        }
+        onRemove() {
+          this._request && (this._request.abort(), this._request = null);
+        }
+        setCoordinates(e3) {
+          this.coordinates = e3;
+          const i3 = e3.map(t2.a6.fromLngLat);
+          var o3;
+          return this.tileID = function(e4) {
+            const i4 = t2.a7.fromPoints(e4), o4 = i4.width(), a3 = i4.height(), r3 = Math.max(o4, a3), s3 = Math.max(0, Math.floor(-Math.log(r3) / Math.LN2)), n3 = Math.pow(2, s3);
+            return new t2.a9(s3, Math.floor((i4.minX + i4.maxX) / 2 * n3), Math.floor((i4.minY + i4.maxY) / 2 * n3));
+          }(i3), this.terrainTileRanges = this._getOverlappingTileRanges(i3), this.minzoom = this.maxzoom = this.tileID.z, this.tileCoords = i3.map((e4) => this.tileID.getTilePoint(e4)._round()), this.flippedWindingOrder = ((o3 = this.tileCoords)[1].x - o3[0].x) * (o3[2].y - o3[0].y) - (o3[1].y - o3[0].y) * (o3[2].x - o3[0].x) < 0, this.fire(new t2.l("data", { dataType: "source", sourceDataType: "content" })), this;
+        }
+        prepare() {
+          if (0 === Object.keys(this.tiles).length || !this.image) return;
+          const e3 = this.map.painter.context, i3 = e3.gl;
+          this.texture || (this.texture = new t2.T(e3, this.image, i3.RGBA), this.texture.bind(i3.LINEAR, i3.CLAMP_TO_EDGE));
+          let o3 = false;
+          for (const e4 in this.tiles) {
+            const t3 = this.tiles[e4];
+            "loaded" !== t3.state && (t3.state = "loaded", t3.texture = this.texture, o3 = true);
+          }
+          o3 && this.fire(new t2.l("data", { dataType: "source", sourceDataType: "idle", sourceId: this.id }));
+        }
+        loadTile(e3) {
+          return t2._(this, void 0, void 0, function* () {
+            this.tileID && this.tileID.equals(e3.tileID.canonical) ? (this.tiles[String(e3.tileID.wrap)] = e3, e3.buckets = {}) : e3.state = "errored";
+          });
+        }
+        serialize() {
+          return { type: "image", url: this.options.url, coordinates: this.coordinates };
+        }
+        hasTransition() {
+          return false;
+        }
+        _getOverlappingTileRanges(e3) {
+          const { minX: i3, minY: o3, maxX: a3, maxY: r3 } = t2.a7.fromPoints(e3), s3 = {};
+          for (let e4 = 0; e4 <= t2.a8; e4++) {
+            const t3 = Math.pow(2, e4), n3 = Math.floor(i3 * t3), l3 = Math.floor(o3 * t3), c3 = Math.floor(a3 * t3), h3 = Math.floor(r3 * t3), u3 = (n3 % t3 + t3) % t3, d3 = c3 % t3, _3 = Math.floor(n3 / t3), p3 = Math.floor(c3 / t3);
+            s3[e4] = { minWrap: _3, maxWrap: p3, minTileXWrapped: u3, maxTileXWrapped: d3, minTileY: l3, maxTileY: h3 };
+          }
+          return s3;
+        }
+      }
+      class ee2 extends J2 {
+        constructor(e3, t3, i3, o3) {
+          super(e3, t3, i3, o3), this._onPlayingHandler = () => {
+            var e4;
+            null === (e4 = this.map) || void 0 === e4 || e4.triggerRepaint();
+          }, this.roundZoom = true, this.type = "video", this.options = t3;
+        }
+        load() {
+          return t2._(this, void 0, void 0, function* () {
+            this._loaded = false;
+            const e3 = this.options;
+            this.urls = [];
+            for (const t3 of e3.urls) this.urls.push((yield this.map._requestManager.transformRequest(t3, "Source")).url);
+            try {
+              const e4 = yield t2.aa(this.urls);
+              if (this._loaded = true, !e4) return;
+              this.video = e4, this.video.loop = true, this.video.addEventListener("playing", this._onPlayingHandler), this.map && this.video.play(), this._finishLoading();
+            } catch (e4) {
+              this.fire(new t2.k(e4));
+            }
+          });
+        }
+        pause() {
+          this.video && this.video.pause();
+        }
+        play() {
+          this.video && this.video.play();
+        }
+        seek(e3) {
+          if (this.video) {
+            const i3 = this.video.seekable;
+            e3 < i3.start(0) || e3 > i3.end(0) ? this.fire(new t2.k(new t2.ab(`sources.${this.id}`, null, `Playback for this video can be set only between the ${i3.start(0)} and ${i3.end(0)}-second mark.`))) : this.video.currentTime = e3;
+          }
+        }
+        getVideo() {
+          return this.video;
+        }
+        onAdd(e3) {
+          this.map || (this.map = e3, this.load(), this.video && (this.video.play(), this.setCoordinates(this.coordinates)));
+        }
+        onRemove() {
+          super.onRemove(), this.video && (this.video.removeEventListener("playing", this._onPlayingHandler), this.video.pause());
+        }
+        prepare() {
+          if (0 === Object.keys(this.tiles).length || this.video.readyState < 2) return;
+          const e3 = this.map.painter.context, i3 = e3.gl;
+          this.texture ? this.video.paused || (this.texture.bind(i3.LINEAR, i3.CLAMP_TO_EDGE), i3.texSubImage2D(i3.TEXTURE_2D, 0, 0, 0, i3.RGBA, i3.UNSIGNED_BYTE, this.video)) : (this.texture = new t2.T(e3, this.video, i3.RGBA), this.texture.bind(i3.LINEAR, i3.CLAMP_TO_EDGE));
+          let o3 = false;
+          for (const e4 in this.tiles) {
+            const t3 = this.tiles[e4];
+            "loaded" !== t3.state && (t3.state = "loaded", t3.texture = this.texture, o3 = true);
+          }
+          o3 && this.fire(new t2.l("data", { dataType: "source", sourceDataType: "idle", sourceId: this.id }));
+        }
+        serialize() {
+          return { type: "video", urls: this.urls, coordinates: this.coordinates };
+        }
+        hasTransition() {
+          return this.video && !this.video.paused;
+        }
+      }
+      class te2 extends J2 {
+        constructor(e3, i3, o3, a3) {
+          super(e3, i3, o3, a3), i3.coordinates ? Array.isArray(i3.coordinates) && 4 === i3.coordinates.length && !i3.coordinates.some((e4) => !Array.isArray(e4) || 2 !== e4.length || e4.some((e5) => "number" != typeof e5)) || this.fire(new t2.k(new t2.ab(`sources.${e3}`, null, '"coordinates" property must be an array of 4 longitude/latitude array pairs'))) : this.fire(new t2.k(new t2.ab(`sources.${e3}`, null, 'missing required property "coordinates"'))), i3.animate && "boolean" != typeof i3.animate && this.fire(new t2.k(new t2.ab(`sources.${e3}`, null, 'optional "animate" property must be a boolean value'))), i3.canvas ? "string" == typeof i3.canvas || i3.canvas instanceof HTMLCanvasElement || this.fire(new t2.k(new t2.ab(`sources.${e3}`, null, '"canvas" must be either a string representing the ID of the canvas element from which to read, or an HTMLCanvasElement instance'))) : this.fire(new t2.k(new t2.ab(`sources.${e3}`, null, 'missing required property "canvas"'))), this.options = i3, this.animate = void 0 === i3.animate || i3.animate;
+        }
+        load() {
+          return t2._(this, void 0, void 0, function* () {
+            this._loaded = true, this.canvas || (this.canvas = this.options.canvas instanceof HTMLCanvasElement ? this.options.canvas : document.getElementById(this.options.canvas)), this.width = this.canvas.width, this.height = this.canvas.height, this._hasInvalidDimensions() ? this.fire(new t2.k(new Error("Canvas dimensions cannot be less than or equal to zero."))) : (this.play = function() {
+              this._playing = true, this.map.triggerRepaint();
+            }, this.pause = function() {
+              this._playing && (this.prepare(), this._playing = false);
+            }, this._finishLoading());
+          });
+        }
+        getCanvas() {
+          return this.canvas;
+        }
+        onAdd(e3) {
+          this.map = e3, this.load(), this.canvas && this.animate && this.play();
+        }
+        onRemove() {
+          this.pause();
+        }
+        prepare() {
+          let e3 = false;
+          if (this.canvas.width !== this.width && (this.width = this.canvas.width, e3 = true), this.canvas.height !== this.height && (this.height = this.canvas.height, e3 = true), this._hasInvalidDimensions()) return;
+          if (0 === Object.keys(this.tiles).length) return;
+          const i3 = this.map.painter.context, o3 = i3.gl;
+          this.texture ? (e3 || this._playing) && this.texture.update(this.canvas, { premultiply: true }) : (this.texture = new t2.T(i3, this.canvas, o3.RGBA, { premultiply: true }), this.texture.bind(o3.LINEAR, o3.CLAMP_TO_EDGE));
+          let a3 = false;
+          for (const e4 in this.tiles) {
+            const t3 = this.tiles[e4];
+            "loaded" !== t3.state && (t3.state = "loaded", t3.texture = this.texture, a3 = true);
+          }
+          a3 && this.fire(new t2.l("data", { dataType: "source", sourceDataType: "idle", sourceId: this.id }));
+        }
+        serialize() {
+          return { type: "canvas", animate: this.animate, canvas: this.options.canvas, coordinates: this.coordinates };
+        }
+        hasTransition() {
+          return this._playing;
+        }
+        _hasInvalidDimensions() {
+          for (const e3 of [this.canvas.width, this.canvas.height]) if (isNaN(e3) || e3 <= 0) return true;
+          return false;
+        }
+      }
+      const ie2 = {}, oe2 = (e3) => {
+        switch (e3) {
+          case "geojson":
+            return Q2;
+          case "image":
+            return J2;
+          case "raster":
+            return V2;
+          case "raster-dem":
+            return W2;
+          case "vector":
+            return G2;
+          case "video":
+            return ee2;
+          case "canvas":
+            return te2;
+        }
+        return ie2[e3];
+      }, ae2 = "RTLPluginLoaded";
+      class re2 extends t2.E {
+        constructor() {
+          super(...arguments), this.status = "unavailable", this.url = null, this.dispatcher = k2();
+        }
+        _syncState(e3) {
+          return this.status = e3, this.dispatcher.broadcast("SRPS", { pluginStatus: e3, pluginURL: this.url }).catch((e4) => {
+            throw this.status = "error", e4;
+          });
+        }
+        getRTLTextPluginStatus() {
+          return this.status;
+        }
+        clearRTLTextPlugin() {
+          this.status = "unavailable", this.url = null;
+        }
+        setRTLTextPlugin(e3) {
+          return t2._(this, arguments, void 0, function* (e4, t3 = false) {
+            if (this.url) throw new Error("setRTLTextPlugin cannot be called multiple times.");
+            if (this.url = n2.resolveURL(e4), !this.url) throw new Error(`requested url ${e4} is invalid`);
+            if ("unavailable" === this.status) {
+              if (!t3) return this._requestImport();
+              this.status = "deferred", this._syncState(this.status);
+            } else if ("requested" === this.status) return this._requestImport();
+          });
+        }
+        _requestImport() {
+          return t2._(this, void 0, void 0, function* () {
+            yield this._syncState("loading"), this.status = "loaded", this.fire(new t2.l(ae2));
+          });
+        }
+        lazyLoad() {
+          "unavailable" === this.status ? this.status = "requested" : "deferred" === this.status && this._requestImport();
+        }
+      }
+      let se2 = null;
+      function ne2() {
+        return se2 || (se2 = new re2()), se2;
+      }
+      var le2, ce2;
+      !function(e3) {
+        e3[e3.Base = 0] = "Base", e3[e3.Parent = 1] = "Parent";
+      }(le2 || (le2 = {})), function(e3) {
+        e3[e3.Departing = 0] = "Departing", e3[e3.Incoming = 1] = "Incoming";
+      }(ce2 || (ce2 = {}));
+      class he2 {
+        constructor(e3, i3) {
+          this.timeAdded = 0, this.fadeEndTime = 0, this.fadeOpacity = 1, this.tileID = e3, this.uid = t2.ac(), this.uses = 0, this.tileSize = i3, this.buckets = {}, this.expirationTime = null, this.queryPadding = 0, this.hasSymbolBuckets = false, this.hasRTLText = false, this.dependencies = {}, this.rtt = [], this.rttFingerprint = {}, this.expiredRequestCount = 0, this.state = "loading";
+        }
+        isRenderable(e3) {
+          return this.hasData() && (!this.fadeEndTime || this.fadeOpacity > 0) && (e3 || !this.holdingForSymbolFade());
+        }
+        setCrossFadeLogic({ fadingRole: e3, fadingDirection: t3, fadingParentID: i3, fadeEndTime: o3 }) {
+          this.resetFadeLogic(), this.fadingRole = e3, this.fadingDirection = t3, this.fadingParentID = i3, this.fadeEndTime = o3;
+        }
+        setSelfFadeLogic(e3) {
+          this.resetFadeLogic(), this.selfFading = true, this.fadeEndTime = e3;
+        }
+        resetFadeLogic() {
+          this.fadingRole = null, this.fadingDirection = null, this.fadingParentID = null, this.selfFading = false, this.timeAdded = c2(), this.fadeEndTime = 0, this.fadeOpacity = 1;
+        }
+        wasRequested() {
+          return "errored" === this.state || "loaded" === this.state || "reloading" === this.state;
+        }
+        clearTextures(e3) {
+          this.demTexture && e3.saveTileTexture(this.demTexture), this.demTexture = null;
+        }
+        loadVectorData(e3, i3, o3) {
+          if (true !== (null == e3 ? void 0 : e3.etagUnmodified)) if (this.hasData() && this.unloadVectorData(), this.state = "loaded", e3) {
+            e3.featureIndex && (this.latestFeatureIndex = e3.featureIndex, e3.rawTileData ? (this.latestRawTileData = e3.rawTileData, this.latestEncoding = e3.encoding, this.latestFeatureIndex.rawTileData = e3.rawTileData, this.latestFeatureIndex.encoding = e3.encoding) : this.latestRawTileData && (this.latestFeatureIndex.rawTileData = this.latestRawTileData, this.latestFeatureIndex.encoding = this.latestEncoding)), this.collisionBoxArray = e3.collisionBoxArray, this.buckets = function(e4, t3) {
+              const i4 = {};
+              if (!t3) return i4;
+              for (const o4 of e4) {
+                const e5 = o4.layerIds.map((e6) => t3.getLayer(e6)).filter(Boolean);
+                if (0 !== e5.length) {
+                  o4.layers = e5, o4.stateDependentLayerIds && (o4.stateDependentLayers = o4.stateDependentLayerIds.map((t4) => e5.filter((e6) => e6.id === t4)[0]));
+                  for (const t4 of e5) i4[t4.id] = o4;
+                }
+              }
+              return i4;
+            }(e3.buckets, null == i3 ? void 0 : i3.style), this.hasSymbolBuckets = false;
+            for (const e4 in this.buckets) {
+              const i4 = this.buckets[e4];
+              if (i4 instanceof t2.ae) {
+                if (this.hasSymbolBuckets = true, !o3) break;
+                i4.justReloaded = true;
+              }
+            }
+            if (this.hasRTLText = false, this.hasSymbolBuckets) for (const e4 in this.buckets) {
+              const i4 = this.buckets[e4];
+              if (i4 instanceof t2.ae && i4.hasRTLText) {
+                this.hasRTLText = true, ne2().lazyLoad();
+                break;
+              }
+            }
+            this.queryPadding = 0;
+            for (const e4 in this.buckets) {
+              const t3 = this.buckets[e4];
+              this.queryPadding = Math.max(this.queryPadding, i3.style.getLayer(e4).queryRadius(t3));
+            }
+            e3.imageAtlas && (this.imageAtlas = e3.imageAtlas), e3.glyphAtlasImage && (this.glyphAtlasImage = e3.glyphAtlasImage), this.dashPositions = e3.dashPositions;
+          } else this.collisionBoxArray = new t2.ad();
+          else this.state = "loaded";
+        }
+        unloadVectorData() {
+          for (const e3 in this.buckets) this.buckets[e3].destroy();
+          this.buckets = {}, this.imageAtlasTexture && this.imageAtlasTexture.destroy(), this.imageAtlas && (this.imageAtlas = null), this.glyphAtlasTexture && this.glyphAtlasTexture.destroy(), this.dashPositions && (this.dashPositions = null), this.latestFeatureIndex = null, this.state = "unloaded";
+        }
+        getBucket(e3) {
+          return this.buckets[e3.id];
+        }
+        upload(e3) {
+          for (const t3 in this.buckets) {
+            const i4 = this.buckets[t3];
+            i4.uploadPending() && i4.upload(e3);
+          }
+          const i3 = e3.gl;
+          this.imageAtlas && !this.imageAtlas.uploaded && (this.imageAtlasTexture = new t2.T(e3, this.imageAtlas.image, i3.RGBA), this.imageAtlas.uploaded = true), this.glyphAtlasImage && (this.glyphAtlasTexture = new t2.T(e3, this.glyphAtlasImage, i3.ALPHA), this.glyphAtlasImage = null);
+        }
+        prepare(e3) {
+          this.imageAtlas && this.imageAtlas.patchUpdatedImages(e3, this.imageAtlasTexture);
+        }
+        queryRenderedFeatures(e3, t3, i3, o3, a3, r3, s3, n3, l3, c3, h3) {
+          return this.latestFeatureIndex && this.latestFeatureIndex.rawTileData ? this.latestFeatureIndex.query({ queryGeometry: o3, cameraQueryGeometry: a3, scale: r3, tileSize: this.tileSize, pixelPosMatrix: c3, transform: n3, params: s3, queryPadding: this.queryPadding * l3, getElevation: h3 }, e3, t3, i3) : {};
+        }
+        querySourceFeatures(e3, i3) {
+          const o3 = this.latestFeatureIndex;
+          if (!o3 || !o3.rawTileData) return;
+          const a3 = o3.loadVTLayers(), r3 = i3 && i3.sourceLayer ? i3.sourceLayer : "", s3 = a3[t2.af] || a3[r3];
+          if (!s3) return;
+          const n3 = t2.ag(null == i3 ? void 0 : i3.filter, null == i3 ? void 0 : i3.globalState), { z: l3, x: c3, y: h3 } = this.tileID.canonical, u3 = { z: l3, x: c3, y: h3 };
+          for (let i4 = 0; i4 < s3.length; i4++) {
+            const a4 = s3.feature(i4);
+            if (n3.needGeometry) {
+              const e4 = t2.ah(a4, true);
+              if (!n3.filter(new t2.H(this.tileID.overscaledZ), e4, this.tileID.canonical)) continue;
+            } else if (!n3.filter(new t2.H(this.tileID.overscaledZ), a4)) continue;
+            const d3 = o3.getId(a4, r3), _3 = new t2.ai(a4, l3, c3, h3, d3);
+            _3.tile = u3, e3.push(_3);
+          }
+        }
+        hasData() {
+          return "loaded" === this.state || "reloading" === this.state || "expired" === this.state;
+        }
+        patternsLoaded() {
+          return this.imageAtlas && !!Object.keys(this.imageAtlas.patternPositions).length;
+        }
+        setExpiryData(e3) {
+          const i3 = this.expirationTime;
+          if (e3.cacheControl) {
+            const i4 = t2.aj(e3.cacheControl);
+            i4["max-age"] && (this.expirationTime = Date.now() + 1e3 * i4["max-age"]);
+          } else e3.expires && (this.expirationTime = new Date(e3.expires).getTime());
+          if (this.expirationTime) {
+            const e4 = Date.now();
+            let t3 = false;
+            if (this.expirationTime > e4) t3 = false;
+            else if (i3) if (this.expirationTime < i3) t3 = true;
+            else {
+              const o3 = this.expirationTime - i3;
+              o3 ? this.expirationTime = e4 + Math.max(o3, 3e4) : t3 = true;
+            }
+            else t3 = true;
+            t3 ? (this.expiredRequestCount++, this.state = "expired") : this.expiredRequestCount = 0;
+          }
+        }
+        getExpiryTimeout() {
+          if (this.expirationTime) return this.expiredRequestCount ? 1e3 * (1 << Math.min(this.expiredRequestCount - 1, 31)) : Math.min(this.expirationTime - (/* @__PURE__ */ new Date()).getTime(), Math.pow(2, 31) - 1);
+        }
+        setFeatureState(e3, i3) {
+          if (!this.latestFeatureIndex || !this.latestFeatureIndex.rawTileData || 0 === Object.keys(e3).length) return;
+          const o3 = this.latestFeatureIndex.loadVTLayers();
+          for (const a3 in this.buckets) {
+            if (!i3.style.hasLayer(a3)) continue;
+            const r3 = this.buckets[a3], s3 = r3.layers[0].sourceLayer || t2.af, n3 = o3[s3], l3 = e3[s3];
+            if (!n3 || !l3 || 0 === Object.keys(l3).length) continue;
+            r3.update(l3, n3, this.imageAtlas && this.imageAtlas.patternPositions || {}, this.dashPositions || {});
+            const c3 = i3 && i3.style && i3.style.getLayer(a3);
+            c3 && (this.queryPadding = Math.max(this.queryPadding, c3.queryRadius(r3)));
+          }
+        }
+        holdingForSymbolFade() {
+          return void 0 !== this.symbolFadeHoldUntil;
+        }
+        symbolFadeFinished() {
+          return !this.symbolFadeHoldUntil || this.symbolFadeHoldUntil < c2();
+        }
+        clearSymbolFadeHold() {
+          this.symbolFadeHoldUntil = void 0;
+        }
+        setSymbolHoldDuration(e3) {
+          this.symbolFadeHoldUntil = c2() + e3;
+        }
+        setDependencies(e3, t3) {
+          const i3 = {};
+          for (const e4 of t3) i3[e4] = true;
+          this.dependencies[e3] = i3;
+        }
+        hasDependency(e3, t3) {
+          for (const i3 of e3) {
+            const e4 = this.dependencies[i3];
+            if (e4) {
+              for (const i4 of t3) if (e4[i4]) return true;
+            }
+          }
+          return false;
+        }
+      }
+      class ue2 {
+        constructor() {
+          this.state = {}, this.stateChanges = {}, this.deletedStates = {}, this.revision = 0;
+        }
+        updateState(e3, i3, o3) {
+          const a3 = String(i3);
+          if (this.stateChanges[e3] = this.stateChanges[e3] || {}, this.stateChanges[e3][a3] = this.stateChanges[e3][a3] || {}, t2.e(this.stateChanges[e3][a3], o3), null === this.deletedStates[e3]) {
+            this.deletedStates[e3] = {};
+            for (const t3 in this.state[e3]) t3 !== a3 && (this.deletedStates[e3][t3] = null);
+          } else if (this.deletedStates[e3] && null === this.deletedStates[e3][a3]) {
+            this.deletedStates[e3][a3] = {};
+            for (const t3 in this.state[e3][a3]) o3[t3] || (this.deletedStates[e3][a3][t3] = null);
+          } else for (const t3 in o3) this.deletedStates[e3] && this.deletedStates[e3][a3] && null === this.deletedStates[e3][a3][t3] && delete this.deletedStates[e3][a3][t3];
+        }
+        removeFeatureState(e3, t3, i3) {
+          if (null === this.deletedStates[e3]) return;
+          const o3 = String(t3);
+          if (this.deletedStates[e3] = this.deletedStates[e3] || {}, i3 && void 0 !== t3) null !== this.deletedStates[e3][o3] && (this.deletedStates[e3][o3] = this.deletedStates[e3][o3] || {}, this.deletedStates[e3][o3][i3] = null);
+          else if (void 0 !== t3) if (this.stateChanges[e3] && this.stateChanges[e3][o3]) for (i3 in this.deletedStates[e3][o3] = {}, this.stateChanges[e3][o3]) this.deletedStates[e3][o3][i3] = null;
+          else this.deletedStates[e3][o3] = null;
+          else this.deletedStates[e3] = null;
+        }
+        getState(e3, i3) {
+          const o3 = String(i3), a3 = t2.e({}, (this.state[e3] || {})[o3], (this.stateChanges[e3] || {})[o3]);
+          if (null === this.deletedStates[e3]) return {};
+          if (this.deletedStates[e3]) {
+            const t3 = this.deletedStates[e3][i3];
+            if (null === t3) return {};
+            for (const e4 in t3) delete a3[e4];
+          }
+          return a3;
+        }
+        initializeTileState(e3, t3) {
+          e3.setFeatureState(this.state, t3);
+        }
+        coalesceChanges(e3, i3) {
+          const o3 = {};
+          for (const e4 in this.stateChanges) {
+            this.state[e4] = this.state[e4] || {};
+            const i4 = {};
+            for (const o4 in this.stateChanges[e4]) this.state[e4][o4] || (this.state[e4][o4] = {}), t2.e(this.state[e4][o4], this.stateChanges[e4][o4]), i4[o4] = this.state[e4][o4];
+            o3[e4] = i4;
+          }
+          for (const e4 in this.deletedStates) {
+            this.state[e4] = this.state[e4] || {};
+            const i4 = {};
+            if (null === this.deletedStates[e4]) for (const t3 in this.state[e4]) i4[t3] = {}, this.state[e4][t3] = {};
+            else for (const t3 in this.deletedStates[e4]) {
+              if (null === this.deletedStates[e4][t3]) this.state[e4][t3] = {};
+              else for (const i5 of Object.keys(this.deletedStates[e4][t3])) delete this.state[e4][t3][i5];
+              i4[t3] = this.state[e4][t3];
+            }
+            o3[e4] = o3[e4] || {}, t2.e(o3[e4], i4);
+          }
+          this.stateChanges = {}, this.deletedStates = {}, 0 !== Object.keys(o3).length && (this.revision++, e3.setFeatureState(o3, i3));
+        }
+      }
+      const de2 = 89.25;
+      function _e2(e3, i3) {
+        const o3 = t2.ak(i3.lat, -t2.al, t2.al);
+        return new t2.P(t2.Y(i3.lng) * e3, t2.X(o3) * e3);
+      }
+      function pe2(e3, i3) {
+        return new t2.a6(i3.x / e3, i3.y / e3).toLngLat();
+      }
+      function me2(e3) {
+        return e3.cameraToCenterDistance * Math.min(0.85 * Math.tan(t2.am(90 - e3.pitch)), Math.tan(t2.am(de2 - e3.pitch)));
+      }
+      function fe2(e3, i3) {
+        const o3 = e3.canonical, a3 = i3 / t2.an(o3.z), r3 = o3.x + Math.pow(2, o3.z) * e3.wrap, s3 = t2.ao(new Float64Array(16));
+        return t2.O(s3, s3, [r3 * a3, o3.y * a3, 0]), t2.Q(s3, s3, [a3 / t2.a5, a3 / t2.a5, 1]), s3;
+      }
+      function ge2(e3, i3, o3, a3, r3) {
+        const s3 = t2.a6.fromLngLat(e3, i3), n3 = r3 * t2.ap(1, e3.lat), { x: l3, y: c3, z: h3 } = ve2(o3, a3);
+        return new t2.a6(s3.x + n3 * -l3, s3.y + n3 * -c3, s3.z + n3 * -h3);
+      }
+      function ve2(e3, i3) {
+        const o3 = t2.am(e3), a3 = t2.am(i3), r3 = Math.cos(-o3), s3 = Math.sin(o3);
+        return { x: s3 * Math.sin(a3), y: -s3 * Math.cos(a3), z: r3 };
+      }
+      function xe2(e3, t3, i3) {
+        const o3 = t3.intersectsFrustum(e3);
+        if (!i3 || 0 === o3) return o3;
+        const a3 = t3.intersectsPlane(i3);
+        return 0 === a3 ? 0 : 2 === o3 && 2 === a3 ? 2 : 1;
+      }
+      function be2(e3, t3, i3) {
+        let o3 = 0;
+        const a3 = (i3 - t3) / 10;
+        for (let r3 = 0; r3 < 10; r3++) o3 += a3 * Math.pow(Math.cos(t3 + (r3 + 0.5) / 10 * (i3 - t3)), e3);
+        return o3;
+      }
+      function ye2(e3, i3) {
+        return function(o3, a3, r3, s3, n3) {
+          const l3 = 2 * ((e3 - 1) / t2.aq(Math.cos(t2.am(de2 - n3)) / Math.cos(t2.am(de2))) - 1), c3 = Math.acos(r3 / s3), h3 = 2 * be2(l3 - 1, 0, t2.am(n3 / 2)), u3 = Math.min(t2.am(de2), c3 + t2.am(n3 / 2)), d3 = be2(l3 - 1, Math.min(u3, c3 - t2.am(n3 / 2)), u3), _3 = Math.atan(a3 / r3), p3 = Math.hypot(a3, r3);
+          let m3 = o3;
+          return m3 += t2.aq(s3 / p3 / Math.max(0.5, Math.cos(t2.am(n3 / 2)))), m3 += l3 * t2.aq(Math.cos(_3)) / 2, m3 -= t2.aq(Math.max(1, d3 / h3 / i3)) / 2, m3;
+        };
+      }
+      const we2 = ye2(9.314, 3);
+      function Te2(e3, i3) {
+        const o3 = (i3.roundZoom ? Math.round : Math.floor)(e3.zoom + t2.aq(e3.tileSize / i3.tileSize));
+        return Math.max(0, o3);
+      }
+      function Pe2(e3, i3) {
+        const o3 = e3.getCameraFrustum(), a3 = e3.getClippingPlane(), r3 = e3.screenPointToMercatorCoordinate(e3.getCameraPoint()), s3 = t2.a6.fromLngLat(e3.center, e3.elevation);
+        r3.z = s3.z + Math.cos(e3.pitchInRadians) * e3.cameraToCenterDistance / e3.worldSize;
+        const n3 = e3.getCoveringTilesDetailsProvider(), l3 = n3.allowVariableZoom(e3, i3), c3 = Te2(e3, i3), h3 = i3.minzoom || 0, u3 = void 0 !== i3.maxzoom ? i3.maxzoom : e3.maxZoom, d3 = Math.min(Math.max(0, c3), u3), _3 = Math.pow(2, d3), p3 = [_3 * r3.x, _3 * r3.y, 0], m3 = [_3 * s3.x, _3 * s3.y, 0], f3 = Math.hypot(s3.x - r3.x, s3.y - r3.y), g3 = Math.abs(s3.z - r3.z), v3 = Math.hypot(f3, g3), x3 = (e4) => ({ zoom: 0, x: 0, y: 0, wrap: e4, fullyVisible: false }), b3 = [], y3 = [];
+        if (e3.renderWorldCopies && n3.allowWorldCopies()) for (let e4 = 1; e4 <= 3; e4++) b3.push(x3(-e4)), b3.push(x3(e4));
+        for (b3.push(x3(0)); b3.length > 0; ) {
+          const _4 = b3.pop(), f4 = _4.x, x4 = _4.y;
+          let w3 = _4.fullyVisible;
+          const T3 = { x: f4, y: x4, z: _4.zoom }, P3 = n3.getTileBoundingVolume(T3, _4.wrap, e3.elevation, i3);
+          if (!w3) {
+            const e4 = xe2(o3, P3, a3);
+            if (0 === e4) continue;
+            w3 = 2 === e4;
+          }
+          const C3 = n3.distanceToTile2d(r3.x, r3.y, T3, P3);
+          let I3 = c3;
+          l3 && (I3 = (i3.calculateTileZoom || we2)(e3.zoom + t2.aq(e3.tileSize / i3.tileSize), C3, g3, v3, e3.fov)), I3 = (i3.roundZoom ? Math.round : Math.floor)(I3), I3 = Math.max(0, I3);
+          const M3 = Math.min(I3, u3);
+          if (_4.wrap = n3.getWrap(s3, T3, _4.wrap), _4.zoom >= M3) {
+            if (_4.zoom < h3) continue;
+            const e4 = d3 - _4.zoom, o4 = p3[0] - 0.5 - (f4 << e4), a4 = p3[1] - 0.5 - (x4 << e4), r4 = i3.reparseOverscaled ? Math.max(_4.zoom, I3) : _4.zoom;
+            y3.push({ tileID: new t2.a2(_4.zoom === u3 ? r4 : _4.zoom, _4.wrap, _4.zoom, f4, x4), distanceSq: t2.ar([m3[0] - 0.5 - f4, m3[1] - 0.5 - x4]), tileDistanceToCamera: Math.sqrt(o4 * o4 + a4 * a4) });
+          } else for (let e4 = 0; e4 < 4; e4++) b3.push({ zoom: _4.zoom + 1, x: (f4 << 1) + e4 % 2, y: (x4 << 1) + (e4 >> 1), wrap: _4.wrap, fullyVisible: w3 });
+        }
+        return y3.sort((e4, t3) => e4.distanceSq - t3.distanceSq).map((e4) => e4.tileID);
+      }
+      const Ce2 = t2.a7.fromPoints([new t2.P(0, 0), new t2.P(t2.a5, t2.a5)]);
+      function Ie2(e3) {
+        return "raster" === e3 || "image" === e3 || "video" === e3;
+      }
+      function Me2(e3, t3, i3, o3, a3, r3, s3) {
+        if (!t3.hasData()) return false;
+        const { tileID: n3, fadingRole: l3, fadingDirection: c3, fadingParentID: h3 } = t3;
+        if (l3 === le2.Base && c3 === ce2.Incoming && h3) return i3[h3.key] = h3, true;
+        const u3 = Math.max(n3.overscaledZ - a3, r3);
+        for (let a4 = n3.overscaledZ - 1; a4 >= u3; a4--) {
+          const r4 = n3.scaledTo(a4), l4 = e3.getLoadedTile(r4);
+          if (l4) return t3.setCrossFadeLogic({ fadingRole: le2.Base, fadingDirection: ce2.Incoming, fadingParentID: l4.tileID, fadeEndTime: o3 + s3 }), l4.setCrossFadeLogic({ fadingRole: le2.Parent, fadingDirection: ce2.Departing, fadeEndTime: o3 + s3 }), i3[r4.key] = r4, true;
+        }
+        return false;
+      }
+      function Ee2(e3, t3, i3, o3, a3, r3) {
+        if (!t3.hasData()) return false;
+        const s3 = t3.tileID.children(a3);
+        let n3 = Se2(e3, t3, s3, i3, o3, a3, r3);
+        if (n3) return true;
+        for (const l3 of s3) Se2(e3, t3, l3.children(a3), i3, o3, a3, r3) && (n3 = true);
+        return n3;
+      }
+      function Se2(e3, t3, i3, o3, a3, r3, s3) {
+        if (i3[0].overscaledZ >= r3) return false;
+        let n3 = false;
+        for (const r4 of i3) {
+          const i4 = e3.getLoadedTile(r4);
+          if (!i4) continue;
+          const { fadingRole: l3, fadingDirection: c3, fadingParentID: h3 } = i4;
+          l3 === le2.Base && c3 === ce2.Departing && h3 || (i4.setCrossFadeLogic({ fadingRole: le2.Base, fadingDirection: ce2.Departing, fadingParentID: t3.tileID, fadeEndTime: a3 + s3 }), t3.setCrossFadeLogic({ fadingRole: le2.Parent, fadingDirection: ce2.Incoming, fadeEndTime: a3 + s3 })), o3[r4.key] = r4, n3 = true;
+        }
+        return n3;
+      }
+      function Re2(e3, t3, i3, o3) {
+        const a3 = e3.tileID;
+        return !!e3.selfFading || !e3.hasData() && !!t3.has(a3) && (e3.setSelfFadeLogic(i3 + o3), true);
+      }
+      function ze2(e3, t3) {
+        var i3;
+        e3.needsHillshadePrepare = true, e3.needsTerrainPrepare = true;
+        let o3 = t3.tileID.canonical.x - e3.tileID.canonical.x;
+        const a3 = t3.tileID.canonical.y - e3.tileID.canonical.y, r3 = Math.pow(2, e3.tileID.canonical.z), s3 = t3.tileID.key;
+        0 === o3 && 0 === a3 || Math.abs(a3) > 1 || (Math.abs(o3) > 1 && (1 === Math.abs(o3 + r3) ? o3 += r3 : 1 === Math.abs(o3 - r3) && (o3 -= r3)), t3.dem && e3.dem && (e3.dem.backfillBorder(t3.dem, o3, a3), (null === (i3 = e3.neighboringTiles) || void 0 === i3 ? void 0 : i3[s3]) && (e3.neighboringTiles[s3].backfilled = true)));
+      }
+      class De2 {
+        constructor() {
+          this._tiles = {};
+        }
+        handleWrapJump(e3) {
+          const t3 = {};
+          for (const i3 in this._tiles) {
+            const o3 = this._tiles[i3];
+            o3.tileID = o3.tileID.unwrapTo(o3.tileID.wrap + e3), t3[o3.tileID.key] = o3;
+          }
+          this._tiles = t3;
+        }
+        setFeatureState(e3, t3) {
+          for (const i3 in this._tiles) this._tiles[i3].setFeatureState(e3, t3);
+        }
+        getAllTiles() {
+          return Object.values(this._tiles);
+        }
+        getAllIds(e3 = false) {
+          return e3 ? Object.values(this._tiles).map((e4) => e4.tileID).sort(t2.at).map((e4) => e4.key) : Object.keys(this._tiles);
+        }
+        getTileById(e3) {
+          return this._tiles[e3];
+        }
+        setTile(e3, t3) {
+          this._tiles[e3] = t3;
+        }
+        deleteTileById(e3) {
+          delete this._tiles[e3];
+        }
+        getLoadedTile(e3) {
+          const t3 = this.getTileById(e3.key);
+          return (null == t3 ? void 0 : t3.hasData()) ? t3 : null;
+        }
+        isIdRenderable(e3, t3 = false) {
+          var i3;
+          return null === (i3 = this.getTileById(e3)) || void 0 === i3 ? void 0 : i3.isRenderable(t3);
+        }
+        getRenderableIds(e3 = 0, i3) {
+          const o3 = [];
+          for (const e4 of this.getAllIds()) this.isIdRenderable(e4, i3) && o3.push(this.getTileById(e4));
+          return i3 ? o3.sort((i4, o4) => {
+            const a3 = i4.tileID, r3 = o4.tileID, s3 = new t2.P(a3.canonical.x, a3.canonical.y)._rotate(-e3), n3 = new t2.P(r3.canonical.x, r3.canonical.y)._rotate(-e3);
+            return a3.overscaledZ - r3.overscaledZ || n3.y - s3.y || n3.x - s3.x;
+          }).map((e4) => e4.tileID.key) : o3.map((e4) => e4.tileID).sort(t2.at).map((e4) => e4.key);
+        }
+      }
+      class Ae2 extends t2.E {
+        constructor(e3, i3, o3) {
+          super(), this.id = e3, this.dispatcher = o3, this.on("data", (e4) => this._dataHandler(e4)), this.on("dataloading", () => {
+            this._sourceErrored = false;
+          }), this.on("error", () => {
+            this._sourceErrored = this._source.loaded();
+          }), this._source = ((e4, t3, i4, o4) => {
+            const a3 = new (oe2(t3.type))(e4, t3, i4, o4);
+            if (a3.id !== e4) throw new Error(`Expected Source id to be ${e4} instead of ${a3.id}`);
+            return a3;
+          })(e3, i3, o3, this), this._inViewTiles = new De2(), this._outOfViewCache = new t2.au(0, (e4) => this._unloadTile(e4)), this._timers = {}, this._maxTileCacheSize = null, this._maxTileCacheZoomLevels = null, this._rasterFadeDuration = 0, this._maxFadingAncestorLevels = 5, this._state = new ue2(), this._didEmitContent = false, this._updated = false;
+        }
+        onAdd(e3) {
+          this.map = e3, this._maxTileCacheSize = e3 ? e3._maxTileCacheSize : null, this._maxTileCacheZoomLevels = e3 ? e3._maxTileCacheZoomLevels : null, this._source && this._source.onAdd && this._source.onAdd(e3);
+        }
+        onRemove(e3) {
+          for (const e4 of this._inViewTiles.getAllTiles()) e4.unloadVectorData();
+          this.clearTiles(), this._source && this._source.onRemove && this._source.onRemove(e3), this._inViewTiles = new De2();
+        }
+        loaded() {
+          if (this._sourceErrored) return true;
+          if (!this._sourceLoaded) return false;
+          if (!this._source.loaded()) return false;
+          if (!(void 0 === this.used && void 0 === this.usedForTerrain || this.used || this.usedForTerrain)) return true;
+          if (!this._updated) return false;
+          for (const e3 of this._inViewTiles.getAllTiles()) if ("loaded" !== e3.state && "errored" !== e3.state) return false;
+          return true;
+        }
+        getSource() {
+          return this._source;
+        }
+        getState() {
+          return this._state;
+        }
+        pause() {
+          this._paused = true;
+        }
+        resume() {
+          if (!this._paused) return;
+          const e3 = this._shouldReloadOnResume;
+          this._paused = false, this._shouldReloadOnResume = false, e3 && this.reload(), this.transform && this.update(this.transform, this.terrain);
+        }
+        _loadTile(e3, i3, o3) {
+          return t2._(this, void 0, void 0, function* () {
+            try {
+              const t3 = yield this._source.loadTile(e3);
+              this._tileLoaded(e3, i3, o3, t3);
+            } catch (i4) {
+              e3.state = "errored", 404 !== i4.status ? this._source.fire(new t2.k(i4, { tile: e3 })) : this.update(this.transform, this.terrain);
+            }
+          });
+        }
+        _unloadTile(e3) {
+          this._source.unloadTile && this._source.unloadTile(e3);
+        }
+        _abortTile(e3) {
+          this._source.abortTile && this._source.abortTile(e3), this._source.fire(new t2.l("dataabort", { tile: e3, coord: e3.tileID, dataType: "source" }));
+        }
+        serialize() {
+          return this._source.serialize();
+        }
+        prepare(e3) {
+          this._source.prepare && this._source.prepare(), this._state.coalesceChanges(this._inViewTiles, this.map ? this.map.painter : null);
+          for (const t3 of this._inViewTiles.getAllTiles()) t3.upload(e3), t3.prepare(this.map.style.imageManager);
+        }
+        getIds() {
+          return this._inViewTiles.getAllIds(true);
+        }
+        getRenderableIds(e3) {
+          var t3;
+          return this._inViewTiles.getRenderableIds(null === (t3 = this.transform) || void 0 === t3 ? void 0 : t3.bearingInRadians, e3);
+        }
+        hasRenderableParent(e3) {
+          const t3 = e3.overscaledZ - 1;
+          if (t3 >= this._source.minzoom) {
+            const i3 = this.getLoadedTile(e3.scaledTo(t3));
+            if (i3) return this._inViewTiles.isIdRenderable(i3.tileID.key);
+          }
+          return false;
+        }
+        reload(e3, t3 = void 0) {
+          if (this._paused) this._shouldReloadOnResume = true;
+          else {
+            this._outOfViewCache.reset();
+            for (const i3 of this._inViewTiles.getAllIds()) {
+              const o3 = this._inViewTiles.getTileById(i3);
+              t3 && !this._source.shouldReloadTile(o3, t3) || (e3 ? this._reloadTile(i3, "expired") : "errored" !== o3.state && this._reloadTile(i3, "reloading"));
+            }
+          }
+        }
+        _reloadTile(e3, i3) {
+          return t2._(this, void 0, void 0, function* () {
+            const t3 = this._inViewTiles.getTileById(e3);
+            t3 && ("loading" !== t3.state && (t3.state = i3), yield this._loadTile(t3, e3, i3));
+          });
+        }
+        _tileLoaded(e3, i3, o3, a3) {
+          e3.timeAdded = c2(), e3.selfFading && (e3.fadeEndTime = e3.timeAdded + this._rasterFadeDuration), "expired" === o3 && (e3.refreshedUponExpiration = true), this._setTileReloadTimer(i3, e3), (null == a3 ? void 0 : a3.unmodified) || ("raster-dem" === this.getSource().type && e3.dem && function(e4, t3) {
+            var i4, o4;
+            const a4 = t3.getRenderableIds();
+            for (const r3 of a4) {
+              if (!e4.neighboringTiles || !e4.neighboringTiles[r3]) continue;
+              const a5 = t3.getTileById(r3);
+              e4.neighboringTiles[r3].backfilled || ze2(e4, a5), (null === (o4 = null === (i4 = a5.neighboringTiles) || void 0 === i4 ? void 0 : i4[e4.tileID.key]) || void 0 === o4 ? void 0 : o4.backfilled) || ze2(a5, e4);
+            }
+          }(e3, this._inViewTiles), this._state.initializeTileState(e3, this.map ? this.map.painter : null), e3.aborted || this._source.fire(new t2.l("data", { dataType: "source", tile: e3, coord: e3.tileID })));
+        }
+        getTile(e3) {
+          return this.getTileByID(e3.key);
+        }
+        getTileByID(e3) {
+          return this._inViewTiles.getTileById(e3);
+        }
+        _retainLoadedChildren(e3, t3) {
+          const i3 = this._getLoadedDescendents(t3), o3 = /* @__PURE__ */ new Set();
+          for (const a3 of t3) {
+            const t4 = i3[a3.key];
+            if (!(null == t4 ? void 0 : t4.length)) {
+              o3.add(a3);
+              continue;
+            }
+            const r3 = a3.overscaledZ + Ae2.maxOverzooming, s3 = t4.filter((e4) => e4.tileID.overscaledZ <= r3);
+            if (!s3.length) {
+              o3.add(a3);
+              continue;
+            }
+            const n3 = Math.min(...s3.map((e4) => e4.tileID.overscaledZ)), l3 = s3.filter((e4) => e4.tileID.overscaledZ === n3).map((e4) => e4.tileID);
+            for (const t5 of l3) e3[t5.key] = t5;
+            this._areDescendentsComplete(l3, n3, a3.overscaledZ) || o3.add(a3);
+          }
+          return o3;
+        }
+        _getLoadedDescendents(e3) {
+          var t3;
+          const i3 = {};
+          for (const o3 of this._inViewTiles.getAllTiles().filter((e4) => e4.hasData())) for (const a3 of e3) o3.tileID.isChildOf(a3) && (i3[t3 = a3.key] || (i3[t3] = [])).push(o3);
+          return i3;
+        }
+        _areDescendentsComplete(e3, t3, i3) {
+          return 1 === e3.length && e3[0].isOverscaled() ? e3[0].overscaledZ === t3 : Math.pow(4, t3 - i3) === e3.length;
+        }
+        getLoadedTile(e3) {
+          return this._inViewTiles.getLoadedTile(e3);
+        }
+        updateCacheSize(e3) {
+          const i3 = Math.ceil(e3.width / this._source.tileSize) + 1, o3 = Math.ceil(e3.height / this._source.tileSize) + 1, a3 = Math.floor(i3 * o3 * (null === this._maxTileCacheZoomLevels ? t2.c.MAX_TILE_CACHE_ZOOM_LEVELS : this._maxTileCacheZoomLevels)), r3 = "number" == typeof this._maxTileCacheSize ? Math.min(this._maxTileCacheSize, a3) : a3;
+          this._outOfViewCache.setMaxSize(r3);
+        }
+        handleWrapJump(e3) {
+          const t3 = Math.round((e3 - (void 0 === this._prevLng ? e3 : this._prevLng)) / 360);
+          this._prevLng = e3, t3 && (this._inViewTiles.handleWrapJump(t3), this._resetTileReloadTimers());
+        }
+        update(e3, i3) {
+          if (!this._sourceLoaded || this._paused) return;
+          let o3;
+          this.transform = e3, this.terrain = i3, this.updateCacheSize(e3), this.handleWrapJump(this.transform.center.lng), this.used || this.usedForTerrain ? this._source.tileID ? o3 = e3.getVisibleUnwrappedCoordinates(this._source.tileID).map((e4) => new t2.a2(e4.canonical.z, e4.wrap, e4.canonical.z, e4.canonical.x, e4.canonical.y)) : (o3 = Pe2(e3, { tileSize: this.usedForTerrain ? this.tileSize : this._source.tileSize, minzoom: this._source.minzoom, maxzoom: "vector" === this._source.type && void 0 !== this.map._zoomLevelsToOverscale ? e3.maxZoom - this.map._zoomLevelsToOverscale : this._source.maxzoom, roundZoom: !this.usedForTerrain && this._source.roundZoom, reparseOverscaled: this._source.reparseOverscaled, terrain: i3, calculateTileZoom: this._source.calculateTileZoom }), this._source.hasTile && (o3 = o3.filter((e4) => this._source.hasTile(e4)))) : o3 = [], this.usedForTerrain && (o3 = this._addTerrainIdealTiles(o3));
+          const a3 = 0 === o3.length && !this._updated && this._didEmitContent;
+          this._updated = true, a3 && this.fire(new t2.l("data", { sourceDataType: "idle", dataType: "source", sourceId: this.id }));
+          const r3 = Te2(e3, this._source), s3 = this._updateRetainedTiles(o3, r3), n3 = Ie2(this._source.type);
+          n3 && this._rasterFadeDuration > 0 && !i3 && function(e4, i4, o4, a4, r4, s4, n4) {
+            const l3 = c2(), h3 = t2.as(i4);
+            for (const t3 of i4) {
+              const i5 = e4.getTileById(t3.key);
+              i5.fadingDirection !== ce2.Departing && 0 !== i5.fadeOpacity || i5.resetFadeLogic(), Me2(e4, i5, o4, l3, a4, r4, n4) || Ee2(e4, i5, o4, l3, s4, n4) || Re2(i5, h3, l3, n4) || i5.resetFadeLogic();
+            }
+          }(this._inViewTiles, o3, s3, this._maxFadingAncestorLevels, this._source.minzoom, this._source.maxzoom, this._rasterFadeDuration), n3 ? this._cleanUpRasterTiles(s3) : this._cleanUpVectorTiles(s3);
+        }
+        _cleanUpRasterTiles(e3) {
+          for (const t3 of this._inViewTiles.getAllIds()) e3[t3] || this._removeTile(t3);
+        }
+        _cleanUpVectorTiles(e3) {
+          for (const t3 of this._inViewTiles.getAllIds()) {
+            const i3 = this._inViewTiles.getTileById(t3);
+            e3[t3] ? i3.clearSymbolFadeHold() : i3.hasSymbolBuckets ? i3.holdingForSymbolFade() ? i3.symbolFadeFinished() && this._removeTile(t3) : i3.setSymbolHoldDuration(this.map._fadeDuration) : this._removeTile(t3);
+          }
+        }
+        _addTerrainIdealTiles(e3) {
+          const t3 = [];
+          for (const i3 of e3) if (i3.canonical.z > this._source.minzoom) {
+            const e4 = i3.scaledTo(i3.canonical.z - 1);
+            t3.push(e4);
+            const o3 = i3.scaledTo(Math.max(this._source.minzoom, Math.min(i3.canonical.z, 5)));
+            t3.push(o3);
+          }
+          return e3.concat(t3);
+        }
+        releaseSymbolFadeTiles() {
+          for (const e3 of this._inViewTiles.getAllIds()) this._inViewTiles.getTileById(e3).holdingForSymbolFade() && this._removeTile(e3);
+        }
+        _updateRetainedTiles(e3, t3) {
+          var i3;
+          const o3 = /* @__PURE__ */ new Set();
+          for (const t4 of e3) this._addTile(t4).hasData() || o3.add(t4);
+          const a3 = e3.reduce((e4, t4) => (e4[t4.key] = t4, e4), {}), r3 = this._retainLoadedChildren(a3, o3), s3 = {}, n3 = Math.max(t3 - Ae2.maxUnderzooming, this._source.minzoom);
+          for (const e4 of r3) {
+            let t4 = this._inViewTiles.getTileById(e4.key), o4 = null == t4 ? void 0 : t4.wasRequested();
+            for (let r4 = e4.overscaledZ - 1; r4 >= n3; --r4) {
+              const n4 = e4.scaledTo(r4);
+              if (s3[n4.key]) break;
+              if (s3[n4.key] = true, t4 = this.getTile(n4), !t4 && o4 && (t4 = this._addTile(n4)), t4) {
+                const e5 = t4.hasData();
+                if ((e5 || !(null === (i3 = this.map) || void 0 === i3 ? void 0 : i3.cancelPendingTileRequestsWhileZooming) || o4) && (a3[n4.key] = n4), o4 = t4.wasRequested(), e5) break;
+              }
+            }
+          }
+          return a3;
+        }
+        _addTile(e3) {
+          let i3 = this._inViewTiles.getTileById(e3.key);
+          if (i3) return i3;
+          i3 = this._outOfViewCache.getAndRemove(e3), i3 && (i3.resetFadeLogic(), this._setTileReloadTimer(e3.key, i3), i3.tileID = e3, this._state.initializeTileState(i3, this.map ? this.map.painter : null));
+          const o3 = i3;
+          return i3 || (i3 = new he2(e3, this._source.tileSize * e3.overscaleFactor()), this._loadTile(i3, e3.key, i3.state)), i3.uses++, this._inViewTiles.setTile(e3.key, i3), o3 || this._source.fire(new t2.l("dataloading", { tile: i3, coord: i3.tileID, dataType: "source" })), i3;
+        }
+        _setTileReloadTimer(e3, t3) {
+          this._clearTileReloadTimer(e3);
+          const i3 = t3.getExpiryTimeout();
+          i3 && (this._timers[e3] = setTimeout(() => {
+            this._reloadTile(e3, "expired"), delete this._timers[e3];
+          }, i3));
+        }
+        _clearTileReloadTimer(e3) {
+          const t3 = this._timers[e3];
+          t3 && (clearTimeout(t3), delete this._timers[e3]);
+        }
+        _resetTileReloadTimers() {
+          for (const e3 in this._timers) clearTimeout(this._timers[e3]), delete this._timers[e3];
+          for (const e3 of this._inViewTiles.getAllIds()) {
+            const t3 = this._inViewTiles.getTileById(e3);
+            this._setTileReloadTimer(e3, t3);
+          }
+        }
+        refreshTiles(e3) {
+          for (const t3 of this._inViewTiles.getAllIds()) {
+            const i3 = this._inViewTiles.getTileById(t3);
+            (this._inViewTiles.isIdRenderable(t3) || "errored" == i3.state) && e3.some((e4) => e4.equals(i3.tileID.canonical)) && this._reloadTile(t3, "expired");
+          }
+        }
+        _removeTile(e3) {
+          const t3 = this._inViewTiles.getTileById(e3);
+          t3 && (t3.uses--, this._inViewTiles.deleteTileById(e3), this._clearTileReloadTimer(e3), t3.uses > 0 || (t3.hasData() && "reloading" !== t3.state ? this._outOfViewCache.add(t3.tileID, t3, t3.getExpiryTimeout()) : (t3.aborted = true, this._abortTile(t3), this._unloadTile(t3))));
+        }
+        _dataHandler(e3) {
+          "source" === e3.dataType && ("metadata" !== e3.sourceDataType ? "content" === e3.sourceDataType && this._sourceLoaded && !this._paused && (this.reload(e3.sourceDataChanged, e3.shouldReloadTileOptions), this.transform && this.update(this.transform, this.terrain), this._didEmitContent = true) : this._sourceLoaded = true);
+        }
+        clearTiles() {
+          this._shouldReloadOnResume = false, this._paused = false;
+          for (const e3 of this._inViewTiles.getAllIds()) this._removeTile(e3);
+          this._outOfViewCache.reset();
+        }
+        tilesIn(e3, i3, o3) {
+          const a3 = [], r3 = this.transform;
+          if (!r3) return a3;
+          const s3 = r3.getCoveringTilesDetailsProvider().allowWorldCopies(), n3 = o3 ? r3.getCameraQueryGeometry(e3) : e3, l3 = (e4) => r3.screenPointToMercatorCoordinate(e4, this.terrain), c3 = this.transformBbox(e3, l3, !s3), h3 = this.transformBbox(n3, l3, !s3), u3 = this.getIds(), d3 = t2.a7.fromPoints(h3);
+          for (let e4 = 0; e4 < u3.length; e4++) {
+            const o4 = this._inViewTiles.getTileById(u3[e4]);
+            if (o4.holdingForSymbolFade()) continue;
+            const n4 = s3 ? [o4.tileID] : [o4.tileID.unwrapTo(-1), o4.tileID.unwrapTo(0)], l4 = Math.pow(2, r3.zoom - o4.tileID.overscaledZ), _3 = i3 * o4.queryPadding * t2.a5 / o4.tileSize / l4;
+            for (const e5 of n4) {
+              const i4 = d3.map((i5) => e5.getTilePoint(new t2.a6(i5.x, i5.y)));
+              if (i4.expandBy(_3), i4.intersects(Ce2)) {
+                const t3 = c3.map((t4) => e5.getTilePoint(t4)), i5 = h3.map((t4) => e5.getTilePoint(t4));
+                a3.push({ tile: o4, tileID: s3 ? e5 : e5.unwrapTo(0), queryGeometry: t3, cameraQueryGeometry: i5, scale: l4 });
+              }
+            }
+          }
+          return a3;
+        }
+        transformBbox(e3, i3, o3) {
+          let a3 = e3.map(i3);
+          if (o3) {
+            const o4 = t2.a7.fromPoints(e3);
+            o4.shrinkBy(1e-3 * Math.min(o4.width(), o4.height()));
+            const r3 = o4.map(i3);
+            t2.a7.fromPoints(a3).covers(r3) || (a3 = a3.map((e4) => e4.x > 0.5 ? new t2.a6(e4.x - 1, e4.y, e4.z) : e4));
+          }
+          return a3;
+        }
+        getVisibleCoordinates(e3) {
+          const t3 = this.getRenderableIds(e3).map((e4) => this._inViewTiles.getTileById(e4).tileID);
+          return this.transform && this.transform.populateCache(t3), t3;
+        }
+        hasTransition() {
+          return !!this._source.hasTransition() || !(!Ie2(this._source.type) || !function(e3, t3) {
+            if (t3 <= 0) return false;
+            const i3 = c2();
+            for (const t4 of e3.getAllTiles()) if (t4.fadeEndTime >= i3) return true;
+            return false;
+          }(this._inViewTiles, this._rasterFadeDuration));
+        }
+        setRasterFadeDuration(e3) {
+          this._rasterFadeDuration = e3;
+        }
+        setFeatureState(e3, i3, o3) {
+          this._state.updateState(e3 = e3 || t2.af, i3, o3);
+        }
+        removeFeatureState(e3, i3, o3) {
+          this._state.removeFeatureState(e3 = e3 || t2.af, i3, o3);
+        }
+        getFeatureState(e3, i3) {
+          return this._state.getState(e3 = e3 || t2.af, i3);
+        }
+        setDependencies(e3, t3, i3) {
+          const o3 = this._inViewTiles.getTileById(e3);
+          o3 && o3.setDependencies(t3, i3);
+        }
+        reloadTilesForDependencies(e3, t3) {
+          for (const i3 of this._inViewTiles.getAllIds()) this._inViewTiles.getTileById(i3).hasDependency(e3, t3) && this._reloadTile(i3, "reloading");
+          this._outOfViewCache.filter((i3) => !i3.hasDependency(e3, t3));
+        }
+        areTilesLoaded() {
+          for (const e3 of this._inViewTiles.getAllTiles()) if ("loaded" !== e3.state && "errored" !== e3.state) return false;
+          return true;
+        }
+      }
+      Ae2.maxUnderzooming = 10, Ae2.maxOverzooming = 3;
+      class Le2 {
+        constructor(e3, t3) {
+          this.reset(e3, t3);
+        }
+        reset(e3, t3) {
+          this.points = e3 || [], this._distances = [0];
+          for (let e4 = 1; e4 < this.points.length; e4++) this._distances[e4] = this._distances[e4 - 1] + this.points[e4].dist(this.points[e4 - 1]);
+          this.length = this._distances[this._distances.length - 1], this.padding = Math.min(t3 || 0, 0.5 * this.length), this.paddedLength = this.length - 2 * this.padding;
+        }
+        lerp(e3) {
+          if (1 === this.points.length) return this.points[0];
+          e3 = t2.ak(e3, 0, 1);
+          let i3 = 1, o3 = this._distances[i3];
+          const a3 = e3 * this.paddedLength + this.padding;
+          for (; o3 < a3 && i3 < this._distances.length; ) o3 = this._distances[++i3];
+          const r3 = i3 - 1, s3 = this._distances[r3], n3 = o3 - s3, l3 = n3 > 0 ? (a3 - s3) / n3 : 0;
+          return this.points[r3].mult(1 - l3).add(this.points[i3].mult(l3));
+        }
+      }
+      function ke2(e3, t3) {
+        let i3 = true;
+        return "always" === e3 || "never" !== e3 && "never" !== t3 || (i3 = false), i3;
+      }
+      class Fe2 {
+        constructor(e3, t3, i3) {
+          const o3 = this.boxCells = [], a3 = this.circleCells = [];
+          this.xCellCount = Math.ceil(e3 / i3), this.yCellCount = Math.ceil(t3 / i3);
+          for (let e4 = 0; e4 < this.xCellCount * this.yCellCount; e4++) o3.push([]), a3.push([]);
+          this.circleKeys = [], this.boxKeys = [], this.bboxes = [], this.circles = [], this.width = e3, this.height = t3, this.xScale = this.xCellCount / e3, this.yScale = this.yCellCount / t3, this.boxUid = 0, this.circleUid = 0;
+        }
+        keysLength() {
+          return this.boxKeys.length + this.circleKeys.length;
+        }
+        insert(e3, t3, i3, o3, a3) {
+          this._forEachCell(t3, i3, o3, a3, this._insertBoxCell, this.boxUid++), this.boxKeys.push(e3), this.bboxes.push(t3), this.bboxes.push(i3), this.bboxes.push(o3), this.bboxes.push(a3);
+        }
+        insertCircle(e3, t3, i3, o3) {
+          this._forEachCell(t3 - o3, i3 - o3, t3 + o3, i3 + o3, this._insertCircleCell, this.circleUid++), this.circleKeys.push(e3), this.circles.push(t3), this.circles.push(i3), this.circles.push(o3);
+        }
+        _insertBoxCell(e3, t3, i3, o3, a3, r3) {
+          this.boxCells[a3].push(r3);
+        }
+        _insertCircleCell(e3, t3, i3, o3, a3, r3) {
+          this.circleCells[a3].push(r3);
+        }
+        _query(e3, t3, i3, o3, a3, r3, s3) {
+          if (i3 < 0 || e3 > this.width || o3 < 0 || t3 > this.height) return [];
+          const n3 = [];
+          if (e3 <= 0 && t3 <= 0 && this.width <= i3 && this.height <= o3) {
+            if (a3) return [{ key: null, x1: e3, y1: t3, x2: i3, y2: o3 }];
+            for (let e4 = 0; e4 < this.boxKeys.length; e4++) n3.push({ key: this.boxKeys[e4], x1: this.bboxes[4 * e4], y1: this.bboxes[4 * e4 + 1], x2: this.bboxes[4 * e4 + 2], y2: this.bboxes[4 * e4 + 3] });
+            for (let e4 = 0; e4 < this.circleKeys.length; e4++) {
+              const t4 = this.circles[3 * e4], i4 = this.circles[3 * e4 + 1], o4 = this.circles[3 * e4 + 2];
+              n3.push({ key: this.circleKeys[e4], x1: t4 - o4, y1: i4 - o4, x2: t4 + o4, y2: i4 + o4 });
+            }
+          } else this._forEachCell(e3, t3, i3, o3, this._queryCell, n3, { hitTest: a3, overlapMode: r3, seenUids: { box: {}, circle: {} } }, s3);
+          return n3;
+        }
+        query(e3, t3, i3, o3) {
+          return this._query(e3, t3, i3, o3, false, null);
+        }
+        hitTest(e3, t3, i3, o3, a3, r3) {
+          return this._query(e3, t3, i3, o3, true, a3, r3).length > 0;
+        }
+        hitTestCircle(e3, t3, i3, o3, a3) {
+          const r3 = e3 - i3, s3 = e3 + i3, n3 = t3 - i3, l3 = t3 + i3;
+          if (s3 < 0 || r3 > this.width || l3 < 0 || n3 > this.height) return false;
+          const c3 = [];
+          return this._forEachCell(r3, n3, s3, l3, this._queryCellCircle, c3, { hitTest: true, overlapMode: o3, circle: { x: e3, y: t3, radius: i3 }, seenUids: { box: {}, circle: {} } }, a3), c3.length > 0;
+        }
+        _queryCell(e3, t3, i3, o3, a3, r3, s3, n3) {
+          const { seenUids: l3, hitTest: c3, overlapMode: h3 } = s3, u3 = this.boxCells[a3];
+          if (null !== u3) {
+            const a4 = this.bboxes;
+            for (const s4 of u3) if (!l3.box[s4]) {
+              l3.box[s4] = true;
+              const u4 = 4 * s4, d4 = this.boxKeys[s4];
+              if (e3 <= a4[u4 + 2] && t3 <= a4[u4 + 3] && i3 >= a4[u4 + 0] && o3 >= a4[u4 + 1] && (!n3 || n3(d4)) && (!c3 || !ke2(h3, d4.overlapMode)) && (r3.push({ key: d4, x1: a4[u4], y1: a4[u4 + 1], x2: a4[u4 + 2], y2: a4[u4 + 3] }), c3)) return true;
+            }
+          }
+          const d3 = this.circleCells[a3];
+          if (null !== d3) {
+            const a4 = this.circles;
+            for (const s4 of d3) if (!l3.circle[s4]) {
+              l3.circle[s4] = true;
+              const u4 = 3 * s4, d4 = this.circleKeys[s4];
+              if (this._circleAndRectCollide(a4[u4], a4[u4 + 1], a4[u4 + 2], e3, t3, i3, o3) && (!n3 || n3(d4)) && (!c3 || !ke2(h3, d4.overlapMode))) {
+                const e4 = a4[u4], t4 = a4[u4 + 1], i4 = a4[u4 + 2];
+                if (r3.push({ key: d4, x1: e4 - i4, y1: t4 - i4, x2: e4 + i4, y2: t4 + i4 }), c3) return true;
+              }
+            }
+          }
+          return false;
+        }
+        _queryCellCircle(e3, t3, i3, o3, a3, r3, s3, n3) {
+          const { circle: l3, seenUids: c3, overlapMode: h3 } = s3, u3 = this.boxCells[a3];
+          if (null !== u3) {
+            const e4 = this.bboxes;
+            for (const t4 of u3) if (!c3.box[t4]) {
+              c3.box[t4] = true;
+              const i4 = 4 * t4, o4 = this.boxKeys[t4];
+              if (this._circleAndRectCollide(l3.x, l3.y, l3.radius, e4[i4 + 0], e4[i4 + 1], e4[i4 + 2], e4[i4 + 3]) && (!n3 || n3(o4)) && !ke2(h3, o4.overlapMode)) return r3.push(true), true;
+            }
+          }
+          const d3 = this.circleCells[a3];
+          if (null !== d3) {
+            const e4 = this.circles;
+            for (const t4 of d3) if (!c3.circle[t4]) {
+              c3.circle[t4] = true;
+              const i4 = 3 * t4, o4 = this.circleKeys[t4];
+              if (this._circlesCollide(e4[i4], e4[i4 + 1], e4[i4 + 2], l3.x, l3.y, l3.radius) && (!n3 || n3(o4)) && !ke2(h3, o4.overlapMode)) return r3.push(true), true;
+            }
+          }
+        }
+        _forEachCell(e3, t3, i3, o3, a3, r3, s3, n3) {
+          const l3 = this._convertToXCellCoord(e3), c3 = this._convertToYCellCoord(t3), h3 = this._convertToXCellCoord(i3), u3 = this._convertToYCellCoord(o3);
+          for (let d3 = l3; d3 <= h3; d3++) for (let l4 = c3; l4 <= u3; l4++) if (a3.call(this, e3, t3, i3, o3, this.xCellCount * l4 + d3, r3, s3, n3)) return;
+        }
+        _convertToXCellCoord(e3) {
+          return Math.max(0, Math.min(this.xCellCount - 1, Math.floor(e3 * this.xScale)));
+        }
+        _convertToYCellCoord(e3) {
+          return Math.max(0, Math.min(this.yCellCount - 1, Math.floor(e3 * this.yScale)));
+        }
+        _circlesCollide(e3, t3, i3, o3, a3, r3) {
+          const s3 = o3 - e3, n3 = a3 - t3, l3 = i3 + r3;
+          return l3 * l3 > s3 * s3 + n3 * n3;
+        }
+        _circleAndRectCollide(e3, t3, i3, o3, a3, r3, s3) {
+          const n3 = (r3 - o3) / 2, l3 = Math.abs(e3 - (o3 + n3));
+          if (l3 > n3 + i3) return false;
+          const c3 = (s3 - a3) / 2, h3 = Math.abs(t3 - (a3 + c3));
+          if (h3 > c3 + i3) return false;
+          if (l3 <= n3 || h3 <= c3) return true;
+          const u3 = l3 - n3, d3 = h3 - c3;
+          return u3 * u3 + d3 * d3 <= i3 * i3;
+        }
+      }
+      function Be2(e3, i3, a3) {
+        const r3 = t2.N();
+        if (!e3) {
+          const { vecSouth: e4, vecEast: t3 } = je2(i3), a4 = o2();
+          a4[0] = t3[0], a4[1] = t3[1], a4[2] = e4[0], a4[3] = e4[1], s3 = a4, (d3 = (l3 = (n3 = a4)[0]) * (u3 = n3[3]) - (h3 = n3[2]) * (c3 = n3[1])) && (s3[0] = u3 * (d3 = 1 / d3), s3[1] = -c3 * d3, s3[2] = -h3 * d3, s3[3] = l3 * d3), r3[0] = a4[0], r3[1] = a4[1], r3[4] = a4[2], r3[5] = a4[3];
+        }
+        var s3, n3, l3, c3, h3, u3, d3;
+        return t2.Q(r3, r3, [1 / a3, 1 / a3, 1]), r3;
+      }
+      function Oe2(e3, i3, o3, a3) {
+        if (e3) {
+          const e4 = t2.N();
+          if (!i3) {
+            const { vecSouth: t3, vecEast: i4 } = je2(o3);
+            e4[0] = i4[0], e4[1] = i4[1], e4[4] = t3[0], e4[5] = t3[1];
+          }
+          return t2.Q(e4, e4, [a3, a3, 1]), e4;
+        }
+        return o3.pixelsToClipSpaceMatrix;
+      }
+      function je2(e3) {
+        const i3 = Math.cos(e3.rollInRadians), o3 = Math.sin(e3.rollInRadians), a3 = Math.cos(e3.pitchInRadians), r3 = Math.cos(e3.bearingInRadians), s3 = Math.sin(e3.bearingInRadians), n3 = t2.az();
+        n3[0] = -r3 * a3 * o3 - s3 * i3, n3[1] = -s3 * a3 * o3 + r3 * i3;
+        const l3 = t2.aA(n3);
+        l3 < 1e-9 ? t2.aB(n3) : t2.aC(n3, n3, 1 / l3);
+        const c3 = t2.az();
+        c3[0] = r3 * a3 * i3 - s3 * o3, c3[1] = s3 * a3 * i3 + r3 * o3;
+        const h3 = t2.aA(c3);
+        return h3 < 1e-9 ? t2.aB(c3) : t2.aC(c3, c3, 1 / h3), { vecEast: c3, vecSouth: n3 };
+      }
+      function Ne2(e3, i3, o3, a3) {
+        let r3;
+        a3 ? (r3 = [e3, i3, a3(e3, i3), 1], t2.aE(r3, r3, o3)) : (r3 = [e3, i3, 0, 1], ot2(r3, r3, o3));
+        const s3 = r3[3];
+        return { point: new t2.P(r3[0] / s3, r3[1] / s3), signedDistanceFromCamera: s3, isOccluded: false };
+      }
+      function Ze2(e3, t3) {
+        return 0.5 + e3 / t3 * 0.5;
+      }
+      function Ue2(e3, t3) {
+        return e3.x >= -t3[0] && e3.x <= t3[0] && e3.y >= -t3[1] && e3.y <= t3[1];
+      }
+      function Ge2(e3, i3, o3, a3, r3, s3, n3, l3, c3, h3, u3, d3, _3) {
+        const p3 = o3 ? e3.textSizeData : e3.iconSizeData, m3 = t2.av(p3, i3.transform.zoom), f3 = [256 / i3.width * 2 + 1, 256 / i3.height * 2 + 1], g3 = o3 ? e3.text.dynamicLayoutVertexArray : e3.icon.dynamicLayoutVertexArray;
+        g3.clear();
+        const v3 = e3.lineVertexArray, x3 = o3 ? e3.text.placedSymbolArray : e3.icon.placedSymbolArray, b3 = i3.transform.width / i3.transform.height;
+        let y3 = false;
+        for (let o4 = 0; o4 < x3.length; o4++) {
+          const w3 = x3.get(o4);
+          if (w3.hidden || w3.writingMode === t2.aw.vertical && !y3) {
+            it2(w3.numGlyphs, g3);
+            continue;
+          }
+          y3 = false;
+          const T3 = new t2.P(w3.anchorX, w3.anchorY), P3 = { getElevation: _3, pitchedLabelPlaneMatrix: a3, lineVertexArray: v3, pitchWithMap: s3, projectionCache: { projections: {}, offsets: {}, cachedAnchorPoint: void 0, anyProjectionOccluded: false }, transform: i3.transform, tileAnchorPoint: T3, unwrappedTileID: c3, width: h3, height: u3, translation: d3 }, C3 = Ke2(w3.anchorX, w3.anchorY, P3);
+          if (!Ue2(C3.point, f3)) {
+            it2(w3.numGlyphs, g3);
+            continue;
+          }
+          const I3 = Ze2(i3.transform.cameraToCenterDistance, C3.signedDistanceFromCamera), M3 = t2.ax(p3, m3, w3), E3 = s3 ? M3 * i3.transform.getPitchedTextCorrection(w3.anchorX, w3.anchorY, c3) / I3 : M3 * I3, S3 = qe2({ projectionContext: P3, pitchedLabelPlaneMatrixInverse: r3, symbol: w3, fontSize: E3, flip: false, keepUpright: n3, glyphOffsetArray: e3.glyphOffsetArray, dynamicLayoutVertexArray: g3, aspectRatio: b3, rotateToLine: l3 });
+          y3 = S3.useVertical, (S3.notEnoughRoom || y3 || S3.needsFlipping && qe2({ projectionContext: P3, pitchedLabelPlaneMatrixInverse: r3, symbol: w3, fontSize: E3, flip: true, keepUpright: n3, glyphOffsetArray: e3.glyphOffsetArray, dynamicLayoutVertexArray: g3, aspectRatio: b3, rotateToLine: l3 }).notEnoughRoom) && it2(w3.numGlyphs, g3);
+        }
+        o3 ? e3.text.dynamicLayoutVertexBuffer.updateData(g3) : e3.icon.dynamicLayoutVertexBuffer.updateData(g3);
+      }
+      function Ve2(e3, t3, i3, o3, a3, r3, s3, n3) {
+        const l3 = r3.glyphStartIndex + r3.numGlyphs, c3 = r3.lineStartIndex, h3 = r3.lineStartIndex + r3.lineLength, u3 = t3.getoffsetX(r3.glyphStartIndex), d3 = t3.getoffsetX(l3 - 1), _3 = et2(e3 * u3, i3, o3, a3, r3.segment, c3, h3, n3, s3);
+        if (!_3) return null;
+        const p3 = et2(e3 * d3, i3, o3, a3, r3.segment, c3, h3, n3, s3);
+        return p3 ? n3.projectionCache.anyProjectionOccluded ? null : { first: _3, last: p3 } : null;
+      }
+      function We2(e3, i3, o3, a3) {
+        return e3 === t2.aw.horizontal && Math.abs(o3.y - i3.y) > Math.abs(o3.x - i3.x) * a3 ? { useVertical: true } : (e3 === t2.aw.vertical ? i3.y < o3.y : i3.x > o3.x) ? { needsFlipping: true } : null;
+      }
+      function qe2(e3) {
+        const { projectionContext: i3, pitchedLabelPlaneMatrixInverse: o3, symbol: a3, fontSize: r3, flip: s3, keepUpright: n3, glyphOffsetArray: l3, dynamicLayoutVertexArray: c3, aspectRatio: h3, rotateToLine: u3 } = e3, d3 = r3 / 24, _3 = a3.lineOffsetX * d3, p3 = a3.lineOffsetY * d3;
+        let m3;
+        if (a3.numGlyphs > 1) {
+          const e4 = a3.glyphStartIndex + a3.numGlyphs, t3 = a3.lineStartIndex, r4 = a3.lineStartIndex + a3.lineLength, c4 = Ve2(d3, l3, _3, p3, s3, a3, u3, i3);
+          if (!c4) return { notEnoughRoom: true };
+          const f3 = Ye2(c4.first.point.x, c4.first.point.y, i3, o3), g3 = Ye2(c4.last.point.x, c4.last.point.y, i3, o3);
+          if (n3 && !s3) {
+            const e5 = We2(a3.writingMode, f3, g3, h3);
+            if (e5) return e5;
+          }
+          m3 = [c4.first];
+          for (let o4 = a3.glyphStartIndex + 1; o4 < e4 - 1; o4++) {
+            const e5 = et2(d3 * l3.getoffsetX(o4), _3, p3, s3, a3.segment, t3, r4, i3, u3);
+            if (!e5) return { notEnoughRoom: true };
+            m3.push(e5);
+          }
+          m3.push(c4.last);
+        } else {
+          if (n3 && !s3) {
+            const e5 = Xe2(i3.tileAnchorPoint.x, i3.tileAnchorPoint.y, i3).point, r4 = a3.lineStartIndex + a3.segment + 1, s4 = new t2.P(i3.lineVertexArray.getx(r4), i3.lineVertexArray.gety(r4)), n4 = Xe2(s4.x, s4.y, i3), l4 = n4.signedDistanceFromCamera > 0 ? n4.point : $e2(i3.tileAnchorPoint, s4, e5, 1, i3), c4 = Ye2(e5.x, e5.y, i3, o3), u4 = Ye2(l4.x, l4.y, i3, o3), d4 = We2(a3.writingMode, c4, u4, h3);
+            if (d4) return d4;
+          }
+          const e4 = et2(d3 * l3.getoffsetX(a3.glyphStartIndex), _3, p3, s3, a3.segment, a3.lineStartIndex, a3.lineStartIndex + a3.lineLength, i3, u3);
+          if (!e4 || i3.projectionCache.anyProjectionOccluded) return { notEnoughRoom: true };
+          m3 = [e4];
+        }
+        for (const e4 of m3) t2.aD(c3, e4.point, e4.angle);
+        return {};
+      }
+      function $e2(e3, t3, i3, o3, a3) {
+        const r3 = e3.add(e3.sub(t3)._unit()), s3 = Xe2(r3.x, r3.y, a3).point, n3 = i3.sub(s3);
+        return i3.add(n3._mult(o3 / n3.mag()));
+      }
+      function He2(e3, i3, o3) {
+        const a3 = i3.projectionCache;
+        if (a3.projections[e3]) return a3.projections[e3];
+        const r3 = new t2.P(i3.lineVertexArray.getx(e3), i3.lineVertexArray.gety(e3)), s3 = Xe2(r3.x, r3.y, i3);
+        if (s3.signedDistanceFromCamera > 0) return a3.projections[e3] = s3.point, a3.anyProjectionOccluded = a3.anyProjectionOccluded || s3.isOccluded, s3.point;
+        const n3 = e3 - o3.direction;
+        return $e2(0 === o3.distanceFromAnchor ? i3.tileAnchorPoint : new t2.P(i3.lineVertexArray.getx(n3), i3.lineVertexArray.gety(n3)), r3, o3.previousVertex, o3.absOffsetX - o3.distanceFromAnchor + 1, i3);
+      }
+      function Xe2(e3, t3, i3) {
+        const o3 = e3 + i3.translation[0], a3 = t3 + i3.translation[1];
+        let r3;
+        return i3.pitchWithMap ? (r3 = Ne2(o3, a3, i3.pitchedLabelPlaneMatrix, i3.getElevation), r3.isOccluded = false) : (r3 = i3.transform.projectTileCoordinates(o3, a3, i3.unwrappedTileID, i3.getElevation), r3.point.x = (0.5 * r3.point.x + 0.5) * i3.width, r3.point.y = (0.5 * -r3.point.y + 0.5) * i3.height), r3;
+      }
+      function Ye2(e3, i3, o3, a3) {
+        if (o3.pitchWithMap) {
+          const r3 = [e3, i3, 0, 1];
+          return t2.aE(r3, r3, a3), o3.transform.projectTileCoordinates(r3[0] / r3[3], r3[1] / r3[3], o3.unwrappedTileID, o3.getElevation).point;
+        }
+        return { x: e3 / o3.width * 2 - 1, y: 1 - i3 / o3.height * 2 };
+      }
+      function Ke2(e3, t3, i3) {
+        return i3.transform.projectTileCoordinates(e3, t3, i3.unwrappedTileID, i3.getElevation);
+      }
+      function Qe2(e3, t3, i3) {
+        return e3._unit()._perp()._mult(t3 * i3);
+      }
+      function Je2(e3, i3, o3, a3, r3, s3, n3, l3, c3) {
+        if (l3.projectionCache.offsets[e3]) return l3.projectionCache.offsets[e3];
+        const h3 = o3.add(i3);
+        if (e3 + c3.direction < a3 || e3 + c3.direction >= r3) return l3.projectionCache.offsets[e3] = h3, h3;
+        const u3 = He2(e3 + c3.direction, l3, c3), d3 = Qe2(u3.sub(o3), n3, c3.direction), _3 = o3.add(d3), p3 = u3.add(d3);
+        return l3.projectionCache.offsets[e3] = t2.aF(s3, h3, _3, p3) || h3, l3.projectionCache.offsets[e3];
+      }
+      function et2(e3, t3, i3, o3, a3, r3, s3, n3, l3) {
+        const c3 = o3 ? e3 - t3 : e3 + t3;
+        let h3 = c3 > 0 ? 1 : -1, u3 = 0;
+        o3 && (h3 *= -1, u3 = Math.PI), h3 < 0 && (u3 += Math.PI);
+        let d3, _3 = h3 > 0 ? r3 + a3 : r3 + a3 + 1;
+        n3.projectionCache.cachedAnchorPoint ? d3 = n3.projectionCache.cachedAnchorPoint : (d3 = Xe2(n3.tileAnchorPoint.x, n3.tileAnchorPoint.y, n3).point, n3.projectionCache.cachedAnchorPoint = d3);
+        let p3, m3, f3 = d3, g3 = d3, v3 = 0, x3 = 0;
+        const b3 = Math.abs(c3), y3 = [];
+        let w3;
+        for (; v3 + x3 <= b3; ) {
+          if (_3 += h3, _3 < r3 || _3 >= s3) return null;
+          v3 += x3, g3 = f3, m3 = p3;
+          const e4 = { absOffsetX: b3, direction: h3, distanceFromAnchor: v3, previousVertex: g3 };
+          if (f3 = He2(_3, n3, e4), 0 === i3) y3.push(g3), w3 = f3.sub(g3);
+          else {
+            let t4;
+            const o4 = f3.sub(g3);
+            t4 = 0 === o4.mag() ? Qe2(He2(_3 + h3, n3, e4).sub(f3), i3, h3) : Qe2(o4, i3, h3), m3 || (m3 = g3.add(t4)), p3 = Je2(_3, t4, f3, r3, s3, m3, i3, n3, e4), y3.push(m3), w3 = p3.sub(m3);
+          }
+          x3 = w3.mag();
+        }
+        const T3 = w3._mult((b3 - v3) / x3)._add(m3 || g3), P3 = u3 + Math.atan2(f3.y - g3.y, f3.x - g3.x);
+        return y3.push(T3), { point: T3, angle: l3 ? P3 : 0, path: y3 };
+      }
+      const tt2 = new Float32Array([-1 / 0, -1 / 0, 0, -1 / 0, -1 / 0, 0, -1 / 0, -1 / 0, 0, -1 / 0, -1 / 0, 0]);
+      function it2(e3, t3) {
+        for (let i3 = 0; i3 < e3; i3++) {
+          const e4 = t3.length;
+          t3.resize(e4 + 4), t3.float32.set(tt2, 3 * e4);
+        }
+      }
+      function ot2(e3, t3, i3) {
+        const o3 = t3[0], a3 = t3[1];
+        return e3[0] = i3[0] * o3 + i3[4] * a3 + i3[12], e3[1] = i3[1] * o3 + i3[5] * a3 + i3[13], e3[3] = i3[3] * o3 + i3[7] * a3 + i3[15], e3;
+      }
+      const at2 = 100;
+      class rt2 {
+        constructor(e3, t3 = new Fe2(e3.width + 200, e3.height + 200, 25), i3 = new Fe2(e3.width + 200, e3.height + 200, 25)) {
+          this.transform = e3, this.grid = t3, this.ignoredGrid = i3, this.pitchFactor = Math.cos(e3.pitch * Math.PI / 180) * e3.cameraToCenterDistance, this.screenRightBoundary = e3.width + at2, this.screenBottomBoundary = e3.height + at2, this.gridRightBoundary = e3.width + 200, this.gridBottomBoundary = e3.height + 200, this.perspectiveRatioCutoff = 0.6;
+        }
+        placeCollisionBox(e3, t3, i3, o3, a3, r3, s3, n3, l3, c3, h3, u3) {
+          const d3 = this.projectAndGetPerspectiveRatio(e3.anchorPointX + n3[0], e3.anchorPointY + n3[1], a3, c3, u3), _3 = i3 * d3.perspectiveRatio;
+          let p3;
+          if (r3 || s3) p3 = this._projectCollisionBox(e3, _3, o3, a3, r3, s3, n3, d3, c3, h3, u3);
+          else {
+            const t4 = d3.x + (h3 ? h3.x * _3 : 0), i4 = d3.y + (h3 ? h3.y * _3 : 0);
+            p3 = { allPointsOccluded: false, box: [t4 + e3.x1 * _3, i4 + e3.y1 * _3, t4 + e3.x2 * _3, i4 + e3.y2 * _3] };
+          }
+          const [m3, f3, g3, v3] = p3.box, x3 = r3 ? p3.allPointsOccluded : d3.isOccluded;
+          let b3 = x3;
+          return b3 || (b3 = d3.perspectiveRatio < this.perspectiveRatioCutoff), b3 || (b3 = !this.isInsideGrid(m3, f3, g3, v3)), b3 || "always" !== t3 && this.grid.hitTest(m3, f3, g3, v3, t3, l3) ? { box: [m3, f3, g3, v3], placeable: false, offscreen: false, occluded: x3 } : { box: [m3, f3, g3, v3], placeable: true, offscreen: this.isOffscreen(m3, f3, g3, v3), occluded: x3 };
+        }
+        placeCollisionCircles(e3, i3, o3, a3, r3, s3, n3, l3, c3, h3, u3, d3, _3, p3) {
+          const m3 = [], f3 = new t2.P(i3.anchorX, i3.anchorY), g3 = this.getPerspectiveRatio(f3.x, f3.y, s3, p3), v3 = (c3 ? r3 * this.transform.getPitchedTextCorrection(i3.anchorX, i3.anchorY, s3) / g3 : r3 * g3) / t2.aJ, x3 = { getElevation: p3, pitchedLabelPlaneMatrix: n3, lineVertexArray: o3, pitchWithMap: c3, projectionCache: { projections: {}, offsets: {}, cachedAnchorPoint: void 0, anyProjectionOccluded: false }, transform: this.transform, tileAnchorPoint: f3, unwrappedTileID: s3, width: this.transform.width, height: this.transform.height, translation: _3 }, b3 = Ve2(v3, a3, i3.lineOffsetX * v3, i3.lineOffsetY * v3, false, i3, false, x3);
+          let y3 = false, w3 = false, T3 = true;
+          if (b3) {
+            const i4 = 0.5 * u3 * g3 + d3, o4 = new t2.P(-100, -100), a4 = new t2.P(this.screenRightBoundary, this.screenBottomBoundary), r4 = new Le2(), s4 = b3.first, n4 = b3.last;
+            let _4 = [];
+            for (let e4 = s4.path.length - 1; e4 >= 1; e4--) _4.push(s4.path[e4]);
+            for (let e4 = 1; e4 < n4.path.length; e4++) _4.push(n4.path[e4]);
+            const p4 = 2.5 * i4;
+            if (c3) {
+              const e4 = this.projectPathToScreenSpace(_4, x3);
+              _4 = e4.some((e5) => e5.signedDistanceFromCamera <= 0) ? [] : e4.map((e5) => e5.point);
+            }
+            let f4 = [];
+            if (_4.length > 0) {
+              const e4 = _4[0].clone(), i5 = _4[0].clone();
+              for (let t3 = 1; t3 < _4.length; t3++) e4.x = Math.min(e4.x, _4[t3].x), e4.y = Math.min(e4.y, _4[t3].y), i5.x = Math.max(i5.x, _4[t3].x), i5.y = Math.max(i5.y, _4[t3].y);
+              f4 = e4.x >= o4.x && i5.x <= a4.x && e4.y >= o4.y && i5.y <= a4.y ? [_4] : i5.x < o4.x || e4.x > a4.x || i5.y < o4.y || e4.y > a4.y ? [] : t2.aG([_4], o4.x, o4.y, a4.x, a4.y);
+            }
+            for (const t3 of f4) {
+              r4.reset(t3, 0.25 * i4);
+              let o5 = 0;
+              o5 = r4.length <= 0.5 * i4 ? 1 : Math.ceil(r4.paddedLength / p4) + 1;
+              for (let t4 = 0; t4 < o5; t4++) {
+                const a5 = t4 / Math.max(o5 - 1, 1), s5 = r4.lerp(a5), n5 = s5.x + at2, c4 = s5.y + at2;
+                m3.push(n5, c4, i4, 0);
+                const u4 = n5 - i4, d4 = c4 - i4, _5 = n5 + i4, p5 = c4 + i4;
+                if (T3 = T3 && this.isOffscreen(u4, d4, _5, p5), w3 = w3 || this.isInsideGrid(u4, d4, _5, p5), "always" !== e3 && this.grid.hitTestCircle(n5, c4, i4, e3, h3) && (y3 = true, !l3)) return { circles: [], offscreen: false, collisionDetected: y3 };
+              }
+            }
+          }
+          return { circles: !l3 && y3 || !w3 || g3 < this.perspectiveRatioCutoff ? [] : m3, offscreen: T3, collisionDetected: y3 };
+        }
+        projectPathToScreenSpace(e3, i3) {
+          const o3 = function(e4, i4) {
+            const o4 = t2.N();
+            return t2.ay(o4, i4.pitchedLabelPlaneMatrix), e4.map((e5) => {
+              const t3 = Ne2(e5.x, e5.y, o4, i4.getElevation), a3 = i4.transform.projectTileCoordinates(t3.point.x, t3.point.y, i4.unwrappedTileID, i4.getElevation);
+              return a3.point.x = (0.5 * a3.point.x + 0.5) * i4.width, a3.point.y = (0.5 * -a3.point.y + 0.5) * i4.height, a3;
+            });
+          }(e3, i3);
+          return function(e4) {
+            let t3 = 0, i4 = 0, o4 = 0, a3 = 0;
+            for (let r3 = 0; r3 < e4.length; r3++) e4[r3].isOccluded ? (o4 = r3 + 1, a3 = 0) : (a3++, a3 > i4 && (i4 = a3, t3 = o4));
+            return e4.slice(t3, t3 + i4);
+          }(o3);
+        }
+        queryRenderedSymbols(e3) {
+          if (0 === e3.length || 0 === this.grid.keysLength() && 0 === this.ignoredGrid.keysLength()) return {};
+          const i3 = [], o3 = new t2.a7();
+          for (const a4 of e3) {
+            const e4 = new t2.P(a4.x + at2, a4.y + at2);
+            o3.extend(e4), i3.push(e4);
+          }
+          const { minX: a3, minY: r3, maxX: s3, maxY: n3 } = o3, l3 = this.grid.query(a3, r3, s3, n3).concat(this.ignoredGrid.query(a3, r3, s3, n3)), c3 = {}, h3 = {};
+          for (const e4 of l3) {
+            const o4 = e4.key;
+            if (void 0 === c3[o4.bucketInstanceId] && (c3[o4.bucketInstanceId] = {}), c3[o4.bucketInstanceId][o4.featureIndex]) continue;
+            const a4 = [new t2.P(e4.x1, e4.y1), new t2.P(e4.x2, e4.y1), new t2.P(e4.x2, e4.y2), new t2.P(e4.x1, e4.y2)];
+            t2.aH(i3, a4) && (c3[o4.bucketInstanceId][o4.featureIndex] = true, void 0 === h3[o4.bucketInstanceId] && (h3[o4.bucketInstanceId] = []), h3[o4.bucketInstanceId].push(o4.featureIndex));
+          }
+          return h3;
+        }
+        insertCollisionBox(e3, t3, i3, o3, a3, r3) {
+          (i3 ? this.ignoredGrid : this.grid).insert({ bucketInstanceId: o3, featureIndex: a3, collisionGroupID: r3, overlapMode: t3 }, e3[0], e3[1], e3[2], e3[3]);
+        }
+        insertCollisionCircles(e3, t3, i3, o3, a3, r3) {
+          const s3 = i3 ? this.ignoredGrid : this.grid, n3 = { bucketInstanceId: o3, featureIndex: a3, collisionGroupID: r3, overlapMode: t3 };
+          for (let t4 = 0; t4 < e3.length; t4 += 4) s3.insertCircle(n3, e3[t4], e3[t4 + 1], e3[t4 + 2]);
+        }
+        projectAndGetPerspectiveRatio(e3, i3, o3, a3, r3) {
+          if (r3) {
+            let o4;
+            a3 ? (o4 = [e3, i3, a3(e3, i3), 1], t2.aE(o4, o4, r3)) : (o4 = [e3, i3, 0, 1], ot2(o4, o4, r3));
+            const s3 = o4[3];
+            return { x: (o4[0] / s3 + 1) / 2 * this.transform.width + at2, y: (-o4[1] / s3 + 1) / 2 * this.transform.height + at2, perspectiveRatio: 0.5 + this.transform.cameraToCenterDistance / s3 * 0.5, isOccluded: false, signedDistanceFromCamera: s3 };
+          }
+          {
+            const t3 = this.transform.projectTileCoordinates(e3, i3, o3, a3);
+            return { x: (t3.point.x + 1) / 2 * this.transform.width + at2, y: (1 - t3.point.y) / 2 * this.transform.height + at2, perspectiveRatio: 0.5 + this.transform.cameraToCenterDistance / t3.signedDistanceFromCamera * 0.5, isOccluded: t3.isOccluded, signedDistanceFromCamera: t3.signedDistanceFromCamera };
+          }
+        }
+        getPerspectiveRatio(e3, t3, i3, o3) {
+          const a3 = this.transform.projectTileCoordinates(e3, t3, i3, o3);
+          return 0.5 + this.transform.cameraToCenterDistance / a3.signedDistanceFromCamera * 0.5;
+        }
+        isOffscreen(e3, t3, i3, o3) {
+          return i3 < at2 || e3 >= this.screenRightBoundary || o3 < at2 || t3 > this.screenBottomBoundary;
+        }
+        isInsideGrid(e3, t3, i3, o3) {
+          return i3 >= 0 && e3 < this.gridRightBoundary && o3 >= 0 && t3 < this.gridBottomBoundary;
+        }
+        getViewportMatrix() {
+          const e3 = t2.ao([]);
+          return t2.O(e3, e3, [-100, -100, 0]), e3;
+        }
+        _projectCollisionBox(e3, i3, o3, a3, r3, s3, n3, l3, c3, h3, u3) {
+          let d3 = 1, _3 = 0, p3 = 0, m3 = 1;
+          const f3 = e3.anchorPointX + n3[0], g3 = e3.anchorPointY + n3[1];
+          if (s3 && !r3) {
+            const e4 = this.projectAndGetPerspectiveRatio(f3 + 1, g3, a3, c3, u3), t3 = e4.x - l3.x, i4 = Math.atan((e4.y - l3.y) / t3) + (t3 < 0 ? Math.PI : 0), o4 = Math.sin(i4), r4 = Math.cos(i4);
+            d3 = r4, _3 = o4, p3 = -o4, m3 = r4;
+          } else if (!s3 && r3) {
+            const e4 = je2(this.transform);
+            d3 = e4.vecEast[0], _3 = e4.vecEast[1], p3 = e4.vecSouth[0], m3 = e4.vecSouth[1];
+          }
+          let v3 = l3.x, x3 = l3.y, b3 = i3;
+          r3 && (v3 = f3, x3 = g3, b3 = Math.pow(2, -(this.transform.zoom - o3.overscaledZ)), b3 *= this.transform.getPitchedTextCorrection(f3, g3, a3), h3 || (b3 *= t2.ak(0.5 + l3.signedDistanceFromCamera / this.transform.cameraToCenterDistance * 0.5, 0, 4))), h3 && (v3 += d3 * h3.x * b3 + p3 * h3.y * b3, x3 += _3 * h3.x * b3 + m3 * h3.y * b3);
+          const y3 = e3.x1 * b3, w3 = e3.x2 * b3, T3 = (y3 + w3) / 2, P3 = e3.y1 * b3, C3 = e3.y2 * b3, I3 = (P3 + C3) / 2, M3 = [{ offsetX: y3, offsetY: P3 }, { offsetX: T3, offsetY: P3 }, { offsetX: w3, offsetY: P3 }, { offsetX: w3, offsetY: I3 }, { offsetX: w3, offsetY: C3 }, { offsetX: T3, offsetY: C3 }, { offsetX: y3, offsetY: C3 }, { offsetX: y3, offsetY: I3 }];
+          let E3 = [];
+          for (const { offsetX: e4, offsetY: i4 } of M3) E3.push(new t2.P(v3 + d3 * e4 + p3 * i4, x3 + _3 * e4 + m3 * i4));
+          let S3 = false;
+          if (r3) {
+            const e4 = E3.map((e5) => this.projectAndGetPerspectiveRatio(e5.x, e5.y, a3, c3, u3));
+            S3 = e4.some((e5) => !e5.isOccluded), E3 = e4.map((e5) => new t2.P(e5.x, e5.y));
+          } else S3 = true;
+          return { box: t2.aI(E3), allPointsOccluded: !S3 };
+        }
+      }
+      class st2 {
+        constructor(e3, t3, i3, o3) {
+          this.opacity = e3 ? Math.max(0, Math.min(1, e3.opacity + (e3.placed ? t3 : -t3))) : o3 && i3 ? 1 : 0, this.placed = i3;
+        }
+        isHidden() {
+          return 0 === this.opacity && !this.placed;
+        }
+      }
+      class nt2 {
+        constructor(e3, t3, i3, o3, a3) {
+          this.text = new st2(e3 ? e3.text : null, t3, i3, a3), this.icon = new st2(e3 ? e3.icon : null, t3, o3, a3);
+        }
+        isHidden() {
+          return this.text.isHidden() && this.icon.isHidden();
+        }
+      }
+      class lt2 {
+        constructor(e3, t3, i3) {
+          this.text = e3, this.icon = t3, this.skipFade = i3;
+        }
+      }
+      class ct2 {
+        constructor(e3, t3, i3, o3, a3) {
+          this.bucketInstanceId = e3, this.featureIndex = t3, this.sourceLayerIndex = i3, this.bucketIndex = o3, this.tileID = a3;
+        }
+      }
+      class ht2 {
+        constructor(e3) {
+          this.crossSourceCollisions = e3, this.maxGroupID = 0, this.collisionGroups = {};
+        }
+        get(e3) {
+          if (this.crossSourceCollisions) return { ID: 0, predicate: null };
+          if (!this.collisionGroups[e3]) {
+            const t3 = ++this.maxGroupID;
+            this.collisionGroups[e3] = { ID: t3, predicate: (e4) => e4.collisionGroupID === t3 };
+          }
+          return this.collisionGroups[e3];
+        }
+      }
+      function ut2(e3, i3, o3, a3, r3) {
+        const { horizontalAlign: s3, verticalAlign: n3 } = t2.aP(e3);
+        return new t2.P(-(s3 - 0.5) * i3 + a3[0] * r3, -(n3 - 0.5) * o3 + a3[1] * r3);
+      }
+      class dt2 {
+        constructor(e3, t3, i3, o3, a3) {
+          this.transform = e3.clone(), this.terrain = t3, this.collisionIndex = new rt2(this.transform), this.placements = {}, this.opacities = {}, this.variableOffsets = {}, this.stale = false, this.commitTime = 0, this.fadeDuration = i3, this.retainedQueryData = {}, this.collisionGroups = new ht2(o3), this.collisionCircleArrays = {}, this.collisionBoxArrays = /* @__PURE__ */ new Map(), this.prevPlacement = a3, a3 && (a3.prevPlacement = void 0), this.placedOrientations = {};
+        }
+        _getTerrainElevationFunc(e3) {
+          const t3 = this.terrain;
+          return t3 ? (i3, o3) => t3.getElevation(e3, i3, o3) : null;
+        }
+        getBucketParts(e3, i3, o3, a3) {
+          const r3 = o3.getBucket(i3), s3 = o3.latestFeatureIndex;
+          if (!r3 || !s3 || i3.id !== r3.layerIds[0]) return;
+          const n3 = o3.collisionBoxArray, l3 = r3.layers[0].layout, c3 = r3.layers[0].paint, h3 = Math.pow(2, this.transform.zoom - o3.tileID.overscaledZ), u3 = o3.tileSize / t2.a5, d3 = o3.tileID.toUnwrapped(), _3 = "map" === l3.get("text-rotation-alignment"), p3 = t2.aK(o3, 1, this.transform.zoom), m3 = t2.aL(this.collisionIndex.transform, o3, c3.get("text-translate"), c3.get("text-translate-anchor")), f3 = t2.aL(this.collisionIndex.transform, o3, c3.get("icon-translate"), c3.get("icon-translate-anchor")), g3 = Be2(_3, this.transform, p3);
+          this.retainedQueryData[r3.bucketInstanceId] = new ct2(r3.bucketInstanceId, s3, r3.sourceLayerIndex, r3.index, o3.tileID);
+          const v3 = { bucket: r3, layout: l3, translationText: m3, translationIcon: f3, unwrappedTileID: d3, pitchedLabelPlaneMatrix: g3, scale: h3, textPixelRatio: u3, holdingForFade: o3.holdingForSymbolFade(), collisionBoxArray: n3, partiallyEvaluatedTextSize: t2.av(r3.textSizeData, this.transform.zoom), collisionGroup: this.collisionGroups.get(r3.sourceID) };
+          if (a3) for (const t3 of r3.sortKeyRanges) {
+            const { sortKey: i4, symbolInstanceStart: o4, symbolInstanceEnd: a4 } = t3;
+            e3.push({ sortKey: i4, symbolInstanceStart: o4, symbolInstanceEnd: a4, parameters: v3 });
+          }
+          else e3.push({ symbolInstanceStart: 0, symbolInstanceEnd: r3.symbolInstances.length, parameters: v3 });
+        }
+        attemptAnchorPlacement(e3, i3, o3, a3, r3, s3, n3, l3, c3, h3, u3, d3, _3, p3, m3, f3, g3, v3, x3, b3) {
+          const y3 = t2.aM[e3.textAnchor], w3 = [e3.textOffset0, e3.textOffset1], T3 = ut2(y3, o3, a3, w3, r3), P3 = this.collisionIndex.placeCollisionBox(i3, d3, l3, c3, h3, n3, s3, f3, u3.predicate, x3, T3, b3);
+          if ((!v3 || this.collisionIndex.placeCollisionBox(v3, d3, l3, c3, h3, n3, s3, g3, u3.predicate, x3, T3, b3).placeable) && P3.placeable) {
+            let e4;
+            if (this.prevPlacement && this.prevPlacement.variableOffsets[_3.crossTileID] && this.prevPlacement.placements[_3.crossTileID] && this.prevPlacement.placements[_3.crossTileID].text && (e4 = this.prevPlacement.variableOffsets[_3.crossTileID].anchor), 0 === _3.crossTileID) throw new Error("symbolInstance.crossTileID can't be 0");
+            return this.variableOffsets[_3.crossTileID] = { textOffset: w3, width: o3, height: a3, anchor: y3, textBoxScale: r3, prevAnchor: e4 }, this.markUsedJustification(p3, y3, _3, m3), p3.allowVerticalPlacement && (this.markUsedOrientation(p3, m3, _3), this.placedOrientations[_3.crossTileID] = m3), { shift: T3, placedGlyphBoxes: P3 };
+          }
+        }
+        placeLayerBucketPart(e3, i3, o3) {
+          const { bucket: a3, layout: r3, translationText: s3, translationIcon: n3, unwrappedTileID: l3, pitchedLabelPlaneMatrix: c3, textPixelRatio: h3, holdingForFade: u3, collisionBoxArray: d3, partiallyEvaluatedTextSize: _3, collisionGroup: p3 } = e3.parameters, m3 = r3.get("text-optional"), f3 = r3.get("icon-optional"), g3 = t2.aN(r3, "text-overlap", "text-allow-overlap"), v3 = "always" === g3, x3 = t2.aN(r3, "icon-overlap", "icon-allow-overlap"), b3 = "always" === x3, y3 = "map" === r3.get("text-rotation-alignment"), w3 = "map" === r3.get("text-pitch-alignment"), T3 = "none" !== r3.get("icon-text-fit"), P3 = "viewport-y" === r3.get("symbol-z-order"), C3 = v3 && (b3 || !a3.hasIconData() || f3), I3 = b3 && (v3 || !a3.hasTextData() || m3);
+          !a3.collisionArrays && d3 && a3.deserializeCollisionBoxes(d3);
+          const M3 = this.retainedQueryData[a3.bucketInstanceId].tileID, E3 = this._getTerrainElevationFunc(M3), S3 = this.transform.getFastPathSimpleProjectionMatrix(M3), R3 = (e4, d4, b4) => {
+            var P4, R4;
+            if (i3[e4.crossTileID]) return;
+            if (u3) return void (this.placements[e4.crossTileID] = new lt2(false, false, false));
+            let z3 = false, D3 = false, A3 = true, L3 = null, k3 = { box: null, placeable: false, offscreen: null, occluded: false }, F3 = { placeable: false }, B3 = null, O3 = null, j3 = null, N3 = 0, Z3 = 0, U3 = 0;
+            d4.textFeatureIndex ? N3 = d4.textFeatureIndex : e4.useRuntimeCollisionCircles && (N3 = e4.featureIndex), d4.verticalTextFeatureIndex && (Z3 = d4.verticalTextFeatureIndex);
+            const G3 = d4.textBox;
+            if (G3) {
+              const i4 = (i5) => {
+                let o4 = t2.aw.horizontal;
+                if (a3.allowVerticalPlacement && !i5 && this.prevPlacement) {
+                  const t3 = this.prevPlacement.placedOrientations[e4.crossTileID];
+                  t3 && (this.placedOrientations[e4.crossTileID] = t3, o4 = t3, this.markUsedOrientation(a3, o4, e4));
+                }
+                return o4;
+              }, r4 = (i5, o4) => {
+                if (a3.allowVerticalPlacement && e4.numVerticalGlyphVertices > 0 && d4.verticalTextBox) {
+                  for (const e5 of a3.writingModes) if (e5 === t2.aw.vertical ? (k3 = o4(), F3 = k3) : k3 = i5(), k3 && k3.placeable) break;
+                } else k3 = i5();
+              }, c4 = e4.textAnchorOffsetStartIndex, u4 = e4.textAnchorOffsetEndIndex;
+              if (u4 === c4) {
+                const o4 = (t3, i5) => {
+                  const o5 = this.collisionIndex.placeCollisionBox(t3, g3, h3, M3, l3, w3, y3, s3, p3.predicate, E3, void 0, S3);
+                  return o5 && o5.placeable && (this.markUsedOrientation(a3, i5, e4), this.placedOrientations[e4.crossTileID] = i5), o5;
+                };
+                r4(() => o4(G3, t2.aw.horizontal), () => {
+                  const i5 = d4.verticalTextBox;
+                  return a3.allowVerticalPlacement && e4.numVerticalGlyphVertices > 0 && i5 ? o4(i5, t2.aw.vertical) : { box: null, offscreen: null };
+                }), i4(k3 && k3.placeable);
+              } else {
+                let _4 = t2.aM[null === (R4 = null === (P4 = this.prevPlacement) || void 0 === P4 ? void 0 : P4.variableOffsets[e4.crossTileID]) || void 0 === R4 ? void 0 : R4.anchor];
+                const m4 = (t3, i5, r5) => {
+                  const d5 = t3.x2 - t3.x1, m5 = t3.y2 - t3.y1, f5 = e4.textBoxScale, v4 = T3 && "never" === x3 ? i5 : null;
+                  let b5 = null, P5 = "never" === g3 ? 1 : 2, C4 = "never";
+                  _4 && P5++;
+                  for (let i6 = 0; i6 < P5; i6++) {
+                    for (let i7 = c4; i7 < u4; i7++) {
+                      const o4 = a3.textAnchorOffsets.get(i7);
+                      if (_4 && o4.textAnchor !== _4) continue;
+                      const c5 = this.attemptAnchorPlacement(o4, t3, d5, m5, f5, y3, w3, h3, M3, l3, p3, C4, e4, a3, r5, s3, n3, v4, E3);
+                      if (c5 && (b5 = c5.placedGlyphBoxes, b5 && b5.placeable)) return z3 = true, L3 = c5.shift, b5;
+                    }
+                    _4 ? _4 = null : C4 = g3;
+                  }
+                  return o3 && !b5 && (b5 = { box: this.collisionIndex.placeCollisionBox(G3, "always", h3, M3, l3, w3, y3, s3, p3.predicate, E3, void 0, S3).box, offscreen: false, placeable: false, occluded: false }), b5;
+                };
+                r4(() => m4(G3, d4.iconBox, t2.aw.horizontal), () => {
+                  const i5 = d4.verticalTextBox;
+                  return a3.allowVerticalPlacement && (!k3 || !k3.placeable) && e4.numVerticalGlyphVertices > 0 && i5 ? m4(i5, d4.verticalIconBox, t2.aw.vertical) : { box: null, occluded: true, offscreen: null };
+                }), k3 && (z3 = k3.placeable, A3 = k3.offscreen);
+                const f4 = i4(k3 && k3.placeable);
+                if (!z3 && this.prevPlacement) {
+                  const t3 = this.prevPlacement.variableOffsets[e4.crossTileID];
+                  t3 && (this.variableOffsets[e4.crossTileID] = t3, this.markUsedJustification(a3, t3.anchor, e4, f4));
+                }
+              }
+            }
+            if (B3 = k3, z3 = B3 && B3.placeable, A3 = B3 && B3.offscreen, e4.useRuntimeCollisionCircles && e4.centerJustifiedTextSymbolIndex >= 0) {
+              const i4 = a3.text.placedSymbolArray.get(e4.centerJustifiedTextSymbolIndex), n4 = t2.ax(a3.textSizeData, _3, i4), h4 = r3.get("text-padding");
+              O3 = this.collisionIndex.placeCollisionCircles(g3, i4, a3.lineVertexArray, a3.glyphOffsetArray, n4, l3, c3, o3, w3, p3.predicate, e4.collisionCircleDiameter, h4, s3, E3), O3.circles.length && O3.collisionDetected && !o3 && t2.w("Collisions detected, but collision boxes are not shown"), z3 = v3 || O3.circles.length > 0 && !O3.collisionDetected, A3 = A3 && O3.offscreen;
+            }
+            if (d4.iconFeatureIndex && (U3 = d4.iconFeatureIndex), d4.iconBox) {
+              const e5 = (e6) => this.collisionIndex.placeCollisionBox(e6, x3, h3, M3, l3, w3, y3, n3, p3.predicate, E3, T3 && L3 ? L3 : void 0, S3);
+              F3 && F3.placeable && d4.verticalIconBox ? (j3 = e5(d4.verticalIconBox), D3 = j3.placeable) : (j3 = e5(d4.iconBox), D3 = j3.placeable), A3 = A3 && j3.offscreen;
+            }
+            const V3 = m3 || 0 === e4.numHorizontalGlyphVertices && 0 === e4.numVerticalGlyphVertices, W3 = f3 || 0 === e4.numIconVertices;
+            V3 || W3 ? W3 ? V3 || (D3 = D3 && z3) : z3 = D3 && z3 : D3 = z3 = D3 && z3;
+            const q3 = D3 && j3.placeable;
+            if (z3 && B3.placeable && this.collisionIndex.insertCollisionBox(B3.box, g3, r3.get("text-ignore-placement"), a3.bucketInstanceId, F3 && F3.placeable && Z3 ? Z3 : N3, p3.ID), q3 && this.collisionIndex.insertCollisionBox(j3.box, x3, r3.get("icon-ignore-placement"), a3.bucketInstanceId, U3, p3.ID), O3 && z3 && this.collisionIndex.insertCollisionCircles(O3.circles, g3, r3.get("text-ignore-placement"), a3.bucketInstanceId, N3, p3.ID), o3 && this.storeCollisionData(a3.bucketInstanceId, b4, d4, B3, j3, O3), 0 === e4.crossTileID) throw new Error("symbolInstance.crossTileID can't be 0");
+            if (0 === a3.bucketInstanceId) throw new Error("bucket.bucketInstanceId can't be 0");
+            this.placements[e4.crossTileID] = new lt2((z3 || C3) && !(null == B3 ? void 0 : B3.occluded), (D3 || I3) && !(null == j3 ? void 0 : j3.occluded), A3 || a3.justReloaded), i3[e4.crossTileID] = true;
+          };
+          if (P3) {
+            if (0 !== e3.symbolInstanceStart) throw new Error("bucket.bucketInstanceId should be 0");
+            const t3 = a3.getSortedSymbolIndexes(-this.transform.bearingInRadians);
+            for (let e4 = t3.length - 1; e4 >= 0; --e4) {
+              const i4 = t3[e4];
+              R3(a3.symbolInstances.get(i4), a3.collisionArrays[i4], i4);
+            }
+          } else for (let t3 = e3.symbolInstanceStart; t3 < e3.symbolInstanceEnd; t3++) R3(a3.symbolInstances.get(t3), a3.collisionArrays[t3], t3);
+          a3.justReloaded = false;
+        }
+        storeCollisionData(e3, t3, i3, o3, a3, r3) {
+          if (i3.textBox || i3.iconBox) {
+            let r4, s3;
+            this.collisionBoxArrays.has(e3) ? r4 = this.collisionBoxArrays.get(e3) : (r4 = /* @__PURE__ */ new Map(), this.collisionBoxArrays.set(e3, r4)), r4.has(t3) ? s3 = r4.get(t3) : (s3 = { text: null, icon: null }, r4.set(t3, s3)), i3.textBox && (s3.text = o3.box), i3.iconBox && (s3.icon = a3.box);
+          }
+          if (r3) {
+            let t4 = this.collisionCircleArrays[e3];
+            void 0 === t4 && (t4 = this.collisionCircleArrays[e3] = []);
+            for (let e4 = 0; e4 < r3.circles.length; e4 += 4) t4.push(r3.circles[e4 + 0] - at2), t4.push(r3.circles[e4 + 1] - at2), t4.push(r3.circles[e4 + 2]), t4.push(r3.collisionDetected ? 1 : 0);
+          }
+        }
+        markUsedJustification(e3, i3, o3, a3) {
+          let r3;
+          r3 = a3 === t2.aw.vertical ? o3.verticalPlacedTextSymbolIndex : { left: o3.leftJustifiedTextSymbolIndex, center: o3.centerJustifiedTextSymbolIndex, right: o3.rightJustifiedTextSymbolIndex }[t2.aO(i3)];
+          const s3 = [o3.leftJustifiedTextSymbolIndex, o3.centerJustifiedTextSymbolIndex, o3.rightJustifiedTextSymbolIndex, o3.verticalPlacedTextSymbolIndex];
+          for (const t3 of s3) t3 >= 0 && (e3.text.placedSymbolArray.get(t3).crossTileID = r3 >= 0 && t3 !== r3 ? 0 : o3.crossTileID);
+        }
+        markUsedOrientation(e3, i3, o3) {
+          const a3 = i3 === t2.aw.horizontal || i3 === t2.aw.horizontalOnly ? i3 : 0, r3 = i3 === t2.aw.vertical ? i3 : 0, s3 = [o3.leftJustifiedTextSymbolIndex, o3.centerJustifiedTextSymbolIndex, o3.rightJustifiedTextSymbolIndex];
+          for (const t3 of s3) e3.text.placedSymbolArray.get(t3).placedOrientation = a3;
+          o3.verticalPlacedTextSymbolIndex && (e3.text.placedSymbolArray.get(o3.verticalPlacedTextSymbolIndex).placedOrientation = r3);
+        }
+        commit(e3) {
+          this.commitTime = e3, this.zoomAtLastRecencyCheck = this.transform.zoom;
+          const t3 = this.prevPlacement;
+          let i3 = false;
+          this.prevZoomAdjustment = t3 ? t3.zoomAdjustment(this.transform.zoom) : 0;
+          const o3 = t3 ? t3.symbolFadeChange(e3) : 1, a3 = t3 ? t3.opacities : {}, r3 = t3 ? t3.variableOffsets : {}, s3 = t3 ? t3.placedOrientations : {};
+          for (const e4 in this.placements) {
+            const t4 = this.placements[e4], r4 = a3[e4];
+            r4 ? (this.opacities[e4] = new nt2(r4, o3, t4.text, t4.icon), i3 = i3 || t4.text !== r4.text.placed || t4.icon !== r4.icon.placed) : (this.opacities[e4] = new nt2(null, o3, t4.text, t4.icon, t4.skipFade), i3 = i3 || t4.text || t4.icon);
+          }
+          for (const e4 in a3) {
+            const t4 = a3[e4];
+            if (!this.opacities[e4]) {
+              const a4 = new nt2(t4, o3, false, false);
+              a4.isHidden() || (this.opacities[e4] = a4, i3 = i3 || t4.text.placed || t4.icon.placed);
+            }
+          }
+          for (const e4 in r3) this.variableOffsets[e4] || !this.opacities[e4] || this.opacities[e4].isHidden() || (this.variableOffsets[e4] = r3[e4]);
+          for (const e4 in s3) this.placedOrientations[e4] || !this.opacities[e4] || this.opacities[e4].isHidden() || (this.placedOrientations[e4] = s3[e4]);
+          if (t3 && void 0 === t3.lastPlacementChangeTime) throw new Error("Last placement time for previous placement is not defined");
+          i3 ? this.lastPlacementChangeTime = e3 : "number" != typeof this.lastPlacementChangeTime && (this.lastPlacementChangeTime = t3 ? t3.lastPlacementChangeTime : e3);
+        }
+        updateLayerOpacities(e3, t3) {
+          const i3 = {};
+          for (const o3 of t3) {
+            const t4 = o3.getBucket(e3);
+            t4 && o3.latestFeatureIndex && e3.id === t4.layerIds[0] && this.updateBucketOpacities(t4, o3.tileID, i3, o3.collisionBoxArray);
+          }
+        }
+        updateBucketOpacities(e3, i3, o3, a3) {
+          e3.hasTextData() && (e3.text.opacityVertexArray.clear(), e3.text.hasVisibleVertices = false), e3.hasIconData() && (e3.icon.opacityVertexArray.clear(), e3.icon.hasVisibleVertices = false), e3.hasIconCollisionBoxData() && e3.iconCollisionBox.collisionVertexArray.clear(), e3.hasTextCollisionBoxData() && e3.textCollisionBox.collisionVertexArray.clear();
+          const r3 = e3.layers[0], s3 = r3.layout, n3 = new nt2(null, 0, false, false, true), l3 = s3.get("text-allow-overlap"), c3 = s3.get("icon-allow-overlap"), h3 = r3._unevaluatedLayout.hasValue("text-variable-anchor") || r3._unevaluatedLayout.hasValue("text-variable-anchor-offset"), u3 = "map" === s3.get("text-rotation-alignment"), d3 = "map" === s3.get("text-pitch-alignment"), _3 = "none" !== s3.get("icon-text-fit"), p3 = new nt2(null, 0, l3 && (c3 || !e3.hasIconData() || s3.get("icon-optional")), c3 && (l3 || !e3.hasTextData() || s3.get("text-optional")), true);
+          !e3.collisionArrays && a3 && (e3.hasIconCollisionBoxData() || e3.hasTextCollisionBoxData()) && e3.deserializeCollisionBoxes(a3);
+          const m3 = (e4, t3, i4) => {
+            for (let o4 = 0; o4 < t3 / 4; o4++) e4.opacityVertexArray.emplaceBack(i4);
+            e4.hasVisibleVertices = e4.hasVisibleVertices || i4 !== wt;
+          }, f3 = this.collisionBoxArrays.get(e3.bucketInstanceId);
+          for (let i4 = 0; i4 < e3.symbolInstances.length; i4++) {
+            const a4 = e3.symbolInstances.get(i4), { numHorizontalGlyphVertices: r4, numVerticalGlyphVertices: s4, crossTileID: l4 } = a4;
+            let c4 = this.opacities[l4];
+            o3[l4] ? c4 = n3 : c4 || (c4 = p3, this.opacities[l4] = c4), o3[l4] = true;
+            const g3 = a4.numIconVertices > 0, v3 = this.placedOrientations[a4.crossTileID], x3 = v3 === t2.aw.vertical, b3 = v3 === t2.aw.horizontal || v3 === t2.aw.horizontalOnly;
+            if (r4 > 0 || s4 > 0) {
+              const t3 = yt(c4.text);
+              m3(e3.text, r4, x3 ? wt : t3), m3(e3.text, s4, b3 ? wt : t3);
+              const i5 = c4.text.isHidden();
+              [a4.rightJustifiedTextSymbolIndex, a4.centerJustifiedTextSymbolIndex, a4.leftJustifiedTextSymbolIndex].forEach((t4) => {
+                t4 >= 0 && (e3.text.placedSymbolArray.get(t4).hidden = i5 || x3 ? 1 : 0);
+              }), a4.verticalPlacedTextSymbolIndex >= 0 && (e3.text.placedSymbolArray.get(a4.verticalPlacedTextSymbolIndex).hidden = i5 || b3 ? 1 : 0);
+              const o4 = this.variableOffsets[a4.crossTileID];
+              o4 && this.markUsedJustification(e3, o4.anchor, a4, v3);
+              const n4 = this.placedOrientations[a4.crossTileID];
+              n4 && (this.markUsedJustification(e3, "left", a4, n4), this.markUsedOrientation(e3, n4, a4));
+            }
+            if (g3) {
+              const t3 = yt(c4.icon), i5 = !(_3 && a4.verticalPlacedIconSymbolIndex && x3);
+              a4.placedIconSymbolIndex >= 0 && (m3(e3.icon, a4.numIconVertices, i5 ? t3 : wt), e3.icon.placedSymbolArray.get(a4.placedIconSymbolIndex).hidden = c4.icon.isHidden()), a4.verticalPlacedIconSymbolIndex >= 0 && (m3(e3.icon, a4.numVerticalIconVertices, i5 ? wt : t3), e3.icon.placedSymbolArray.get(a4.verticalPlacedIconSymbolIndex).hidden = c4.icon.isHidden());
+            }
+            const y3 = f3 && f3.has(i4) ? f3.get(i4) : { text: null, icon: null };
+            if (e3.hasIconCollisionBoxData() || e3.hasTextCollisionBoxData()) {
+              const o4 = e3.collisionArrays[i4];
+              if (o4) {
+                let i5 = new t2.P(0, 0);
+                if (o4.textBox || o4.verticalTextBox) {
+                  let t3 = true;
+                  if (h3) {
+                    const e4 = this.variableOffsets[l4];
+                    e4 ? (i5 = ut2(e4.anchor, e4.width, e4.height, e4.textOffset, e4.textBoxScale), u3 && i5._rotate(d3 ? -this.transform.bearingInRadians : this.transform.bearingInRadians)) : t3 = false;
+                  }
+                  if (o4.textBox || o4.verticalTextBox) {
+                    let a5;
+                    o4.textBox && (a5 = x3), o4.verticalTextBox && (a5 = b3), _t2(e3.textCollisionBox.collisionVertexArray, c4.text.placed, !t3 || a5, y3.text, i5.x, i5.y);
+                  }
+                }
+                if (o4.iconBox || o4.verticalIconBox) {
+                  const t3 = Boolean(!b3 && o4.verticalIconBox);
+                  let a5;
+                  o4.iconBox && (a5 = t3), o4.verticalIconBox && (a5 = !t3), _t2(e3.iconCollisionBox.collisionVertexArray, c4.icon.placed, a5, y3.icon, _3 ? i5.x : 0, _3 ? i5.y : 0);
+                }
+              }
+            }
+          }
+          if (e3.sortFeatures(-this.transform.bearingInRadians), this.retainedQueryData[e3.bucketInstanceId] && (this.retainedQueryData[e3.bucketInstanceId].featureSortOrder = e3.featureSortOrder), e3.hasTextData() && e3.text.opacityVertexBuffer && e3.text.opacityVertexBuffer.updateData(e3.text.opacityVertexArray), e3.hasIconData() && e3.icon.opacityVertexBuffer && e3.icon.opacityVertexBuffer.updateData(e3.icon.opacityVertexArray), e3.hasIconCollisionBoxData() && e3.iconCollisionBox.collisionVertexBuffer && e3.iconCollisionBox.collisionVertexBuffer.updateData(e3.iconCollisionBox.collisionVertexArray), e3.hasTextCollisionBoxData() && e3.textCollisionBox.collisionVertexBuffer && e3.textCollisionBox.collisionVertexBuffer.updateData(e3.textCollisionBox.collisionVertexArray), e3.text.opacityVertexArray.length !== e3.text.layoutVertexArray.length / 4) throw new Error(`bucket.text.opacityVertexArray.length (= ${e3.text.opacityVertexArray.length}) !== bucket.text.layoutVertexArray.length (= ${e3.text.layoutVertexArray.length}) / 4`);
+          if (e3.icon.opacityVertexArray.length !== e3.icon.layoutVertexArray.length / 4) throw new Error(`bucket.icon.opacityVertexArray.length (= ${e3.icon.opacityVertexArray.length}) !== bucket.icon.layoutVertexArray.length (= ${e3.icon.layoutVertexArray.length}) / 4`);
+          e3.bucketInstanceId in this.collisionCircleArrays && (e3.collisionCircleArray = this.collisionCircleArrays[e3.bucketInstanceId], delete this.collisionCircleArrays[e3.bucketInstanceId]);
+        }
+        symbolFadeChange(e3) {
+          return 0 === this.fadeDuration ? 1 : (e3 - this.commitTime) / this.fadeDuration + this.prevZoomAdjustment;
+        }
+        zoomAdjustment(e3) {
+          return Math.max(0, (this.transform.zoom - e3) / 1.5);
+        }
+        hasTransitions(e3) {
+          return this.stale || e3 - this.lastPlacementChangeTime < this.fadeDuration;
+        }
+        stillRecent(e3, t3) {
+          const i3 = this.zoomAtLastRecencyCheck === t3 ? 1 - this.zoomAdjustment(t3) : 1;
+          return this.zoomAtLastRecencyCheck = t3, this.commitTime + this.fadeDuration * i3 > e3;
+        }
+        setStale() {
+          this.stale = true;
+        }
+      }
+      function _t2(e3, t3, i3, o3, a3, r3) {
+        o3 && 0 !== o3.length || (o3 = [0, 0, 0, 0]);
+        const s3 = o3[0] - at2, n3 = o3[1] - at2, l3 = o3[2] - at2, c3 = o3[3] - at2;
+        e3.emplaceBack(t3 ? 1 : 0, i3 ? 1 : 0, a3 || 0, r3 || 0, s3, n3), e3.emplaceBack(t3 ? 1 : 0, i3 ? 1 : 0, a3 || 0, r3 || 0, l3, n3), e3.emplaceBack(t3 ? 1 : 0, i3 ? 1 : 0, a3 || 0, r3 || 0, l3, c3), e3.emplaceBack(t3 ? 1 : 0, i3 ? 1 : 0, a3 || 0, r3 || 0, s3, c3);
+      }
+      const pt2 = Math.pow(2, 25), mt2 = Math.pow(2, 24), ft2 = Math.pow(2, 17), gt2 = Math.pow(2, 16), vt = Math.pow(2, 9), xt = Math.pow(2, 8), bt = Math.pow(2, 1);
+      function yt(e3) {
+        if (0 === e3.opacity && !e3.placed) return 0;
+        if (1 === e3.opacity && e3.placed) return 4294967295;
+        const t3 = e3.placed ? 1 : 0, i3 = Math.floor(127 * e3.opacity);
+        return i3 * pt2 + t3 * mt2 + i3 * ft2 + t3 * gt2 + i3 * vt + t3 * xt + i3 * bt + t3;
+      }
+      const wt = 0;
+      class Tt {
+        constructor(e3) {
+          this._sortAcrossTiles = "viewport-y" !== e3.layout.get("symbol-z-order") && !e3.layout.get("symbol-sort-key").isConstant(), this._currentTileIndex = 0, this._currentPartIndex = 0, this._seenCrossTileIDs = {}, this._bucketParts = [];
+        }
+        continuePlacement(e3, t3, i3, o3, a3) {
+          const r3 = this._bucketParts;
+          for (; this._currentTileIndex < e3.length; ) if (t3.getBucketParts(r3, o3, e3[this._currentTileIndex], this._sortAcrossTiles), this._currentTileIndex++, a3()) return true;
+          for (this._sortAcrossTiles && (this._sortAcrossTiles = false, r3.sort((e4, t4) => e4.sortKey - t4.sortKey)); this._currentPartIndex < r3.length; ) if (t3.placeLayerBucketPart(r3[this._currentPartIndex], this._seenCrossTileIDs, i3), this._currentPartIndex++, a3()) return true;
+          return false;
+        }
+      }
+      class Pt {
+        constructor(e3, t3, i3, o3, a3, r3, s3, n3) {
+          this.placement = new dt2(e3, t3, r3, s3, n3), this._currentPlacementIndex = i3.length - 1, this._forceFullPlacement = o3, this._showCollisionBoxes = a3, this._done = false;
+        }
+        isDone() {
+          return this._done;
+        }
+        continuePlacement(e3, i3, o3) {
+          const a3 = c2(), r3 = () => !this._forceFullPlacement && c2() - a3 > 2;
+          for (; this._currentPlacementIndex >= 0; ) {
+            const a4 = i3[e3[this._currentPlacementIndex]], s3 = this.placement.collisionIndex.transform.zoom;
+            if (t2.aQ(a4) && a4.layout && (!a4.minzoom || a4.minzoom <= s3) && (!a4.maxzoom || a4.maxzoom > s3)) {
+              if (this._inProgressLayer || (this._inProgressLayer = new Tt(a4)), this._inProgressLayer.continuePlacement(o3[a4.source], this.placement, this._showCollisionBoxes, a4, r3)) return;
+              delete this._inProgressLayer;
+            }
+            this._currentPlacementIndex--;
+          }
+          this._done = true;
+        }
+        commit(e3) {
+          return this.placement.commit(e3), this.placement;
+        }
+      }
+      const Ct = 512 / t2.a5 / 2;
+      class It {
+        constructor(e3, i3, o3) {
+          this.tileID = e3, this.bucketInstanceId = o3, this._symbolsByKey = {};
+          const a3 = /* @__PURE__ */ new Map();
+          for (let e4 = 0; e4 < i3.length; e4++) {
+            const t3 = i3.get(e4), o4 = t3.key, r3 = a3.get(o4);
+            r3 ? r3.push(t3) : a3.set(o4, [t3]);
+          }
+          for (const [e4, i4] of a3) {
+            const o4 = { positions: i4.map((e5) => ({ x: Math.floor(e5.anchorX * Ct), y: Math.floor(e5.anchorY * Ct) })), crossTileIDs: i4.map((e5) => e5.crossTileID) };
+            if (o4.positions.length > 128) {
+              const e5 = new t2.aR(o4.positions.length, 16, Uint16Array);
+              for (const { x: t3, y: i5 } of o4.positions) e5.add(t3, i5);
+              e5.finish(), delete o4.positions, o4.index = e5;
+            }
+            this._symbolsByKey[e4] = o4;
+          }
+        }
+        getScaledCoordinates(e3, i3) {
+          const { x: o3, y: a3, z: r3 } = this.tileID.canonical, { x: s3, y: n3, z: l3 } = i3.canonical, c3 = Ct / Math.pow(2, l3 - r3), h3 = (n3 * t2.a5 + e3.anchorY) * c3, u3 = a3 * t2.a5 * Ct;
+          return { x: Math.floor((s3 * t2.a5 + e3.anchorX) * c3 - o3 * t2.a5 * Ct), y: Math.floor(h3 - u3) };
+        }
+        findMatches(e3, t3, i3) {
+          const o3 = this.tileID.canonical.z < t3.canonical.z ? 1 : Math.pow(2, this.tileID.canonical.z - t3.canonical.z);
+          for (let a3 = 0; a3 < e3.length; a3++) {
+            const r3 = e3.get(a3);
+            if (r3.crossTileID) continue;
+            const s3 = this._symbolsByKey[r3.key];
+            if (!s3) continue;
+            const n3 = this.getScaledCoordinates(r3, t3);
+            if (s3.index) {
+              const e4 = s3.index.range(n3.x - o3, n3.y - o3, n3.x + o3, n3.y + o3).sort();
+              for (const t4 of e4) {
+                const e5 = s3.crossTileIDs[t4];
+                if (!i3[e5]) {
+                  i3[e5] = true, r3.crossTileID = e5;
+                  break;
+                }
+              }
+            } else if (s3.positions) for (let e4 = 0; e4 < s3.positions.length; e4++) {
+              const t4 = s3.positions[e4], a4 = s3.crossTileIDs[e4];
+              if (Math.abs(t4.x - n3.x) <= o3 && Math.abs(t4.y - n3.y) <= o3 && !i3[a4]) {
+                i3[a4] = true, r3.crossTileID = a4;
+                break;
+              }
+            }
+          }
+        }
+        getCrossTileIDsLists() {
+          return Object.values(this._symbolsByKey).map(({ crossTileIDs: e3 }) => e3);
+        }
+      }
+      class Mt {
+        constructor() {
+          this.maxCrossTileID = 0;
+        }
+        generate() {
+          return ++this.maxCrossTileID;
+        }
+      }
+      class Et {
+        constructor() {
+          this.indexes = {}, this.usedCrossTileIDs = {}, this.lng = 0;
+        }
+        handleWrapJump(e3) {
+          const t3 = Math.round((e3 - this.lng) / 360);
+          if (0 !== t3) for (const e4 in this.indexes) {
+            const i3 = this.indexes[e4], o3 = {};
+            for (const e5 in i3) {
+              const a3 = i3[e5];
+              a3.tileID = a3.tileID.unwrapTo(a3.tileID.wrap + t3), o3[a3.tileID.key] = a3;
+            }
+            this.indexes[e4] = o3;
+          }
+          this.lng = e3;
+        }
+        addBucket(e3, t3, i3) {
+          if (this.indexes[e3.overscaledZ] && this.indexes[e3.overscaledZ][e3.key]) {
+            if (this.indexes[e3.overscaledZ][e3.key].bucketInstanceId === t3.bucketInstanceId) return false;
+            this.removeBucketCrossTileIDs(e3.overscaledZ, this.indexes[e3.overscaledZ][e3.key]);
+          }
+          for (let e4 = 0; e4 < t3.symbolInstances.length; e4++) t3.symbolInstances.get(e4).crossTileID = 0;
+          this.usedCrossTileIDs[e3.overscaledZ] || (this.usedCrossTileIDs[e3.overscaledZ] = {});
+          const o3 = this.usedCrossTileIDs[e3.overscaledZ];
+          for (const i4 in this.indexes) {
+            const a3 = this.indexes[i4];
+            if (Number(i4) > e3.overscaledZ) for (const i5 in a3) {
+              const r3 = a3[i5];
+              r3.tileID.isChildOf(e3) && r3.findMatches(t3.symbolInstances, e3, o3);
+            }
+            else {
+              const r3 = a3[e3.scaledTo(Number(i4)).key];
+              r3 && r3.findMatches(t3.symbolInstances, e3, o3);
+            }
+          }
+          for (let e4 = 0; e4 < t3.symbolInstances.length; e4++) {
+            const a3 = t3.symbolInstances.get(e4);
+            a3.crossTileID || (a3.crossTileID = i3.generate(), o3[a3.crossTileID] = true);
+          }
+          return void 0 === this.indexes[e3.overscaledZ] && (this.indexes[e3.overscaledZ] = {}), this.indexes[e3.overscaledZ][e3.key] = new It(e3, t3.symbolInstances, t3.bucketInstanceId), true;
+        }
+        removeBucketCrossTileIDs(e3, t3) {
+          for (const i3 of t3.getCrossTileIDsLists()) for (const t4 of i3) delete this.usedCrossTileIDs[e3][t4];
+        }
+        removeStaleBuckets(e3) {
+          let t3 = false;
+          for (const i3 in this.indexes) {
+            const o3 = this.indexes[i3];
+            for (const a3 in o3) e3[o3[a3].bucketInstanceId] || (this.removeBucketCrossTileIDs(i3, o3[a3]), delete o3[a3], t3 = true);
+          }
+          return t3;
+        }
+      }
+      class St {
+        constructor() {
+          this.layerIndexes = {}, this.crossTileIDs = new Mt(), this.maxBucketInstanceId = 0, this.bucketsInCurrentPlacement = {};
+        }
+        addLayer(e3, t3, i3) {
+          let o3 = this.layerIndexes[e3.id];
+          void 0 === o3 && (o3 = this.layerIndexes[e3.id] = new Et());
+          let a3 = false;
+          const r3 = {};
+          o3.handleWrapJump(i3);
+          for (const i4 of t3) {
+            const t4 = i4.getBucket(e3);
+            t4 && e3.id === t4.layerIds[0] && (t4.bucketInstanceId || (t4.bucketInstanceId = ++this.maxBucketInstanceId), o3.addBucket(i4.tileID, t4, this.crossTileIDs) && (a3 = true), r3[t4.bucketInstanceId] = true);
+          }
+          return o3.removeStaleBuckets(r3) && (a3 = true), a3;
+        }
+        pruneUnusedLayers(e3) {
+          const t3 = {};
+          e3.forEach((e4) => {
+            t3[e4] = true;
+          });
+          for (const e4 in this.layerIndexes) t3[e4] || delete this.layerIndexes[e4];
+        }
+      }
+      var Rt = "void main() {fragColor=vec4(1.0);}";
+      const zt = { prelude: Dt("#ifdef GL_ES\nprecision mediump float;\n#else\n#if !defined(lowp)\n#define lowp\n#endif\n#if !defined(mediump)\n#define mediump\n#endif\n#if !defined(highp)\n#define highp\n#endif\n#endif\nout highp vec4 fragColor;", "#ifdef GL_ES\nprecision highp float;\n#else\n#if !defined(lowp)\n#define lowp\n#endif\n#if !defined(mediump)\n#define mediump\n#endif\n#if !defined(highp)\n#define highp\n#endif\n#endif\nvec2 unpack_float(const float packedValue) {int packedIntValue=int(packedValue);int v0=packedIntValue/256;return vec2(v0,packedIntValue-v0*256);}vec2 unpack_opacity(const float packedOpacity) {int intOpacity=int(packedOpacity)/2;return vec2(float(intOpacity)/127.0,mod(packedOpacity,2.0));}vec4 decode_color(const vec2 encodedColor) {return vec4(unpack_float(encodedColor[0])/255.0,unpack_float(encodedColor[1])/255.0\n);}float unpack_mix_vec2(const vec2 packedValue,const float t) {return mix(packedValue[0],packedValue[1],t);}vec4 unpack_mix_color(const vec4 packedColors,const float t) {vec4 minColor=decode_color(vec2(packedColors[0],packedColors[1]));vec4 maxColor=decode_color(vec2(packedColors[2],packedColors[3]));return mix(minColor,maxColor,t);}vec2 get_pattern_pos(const vec2 pixel_coord_upper,const vec2 pixel_coord_lower,const vec2 pattern_size,const float tile_units_to_pixels,const vec2 pos) {vec2 offset=mod(mod(mod(pixel_coord_upper,pattern_size)*256.0,pattern_size)*256.0+pixel_coord_lower,pattern_size);return (tile_units_to_pixels*pos+offset)/pattern_size;}mat3 rotationMatrixFromAxisAngle(vec3 u,float angle) {float c=cos(angle);float s=sin(angle);float c2=1.0-c;return mat3(u.x*u.x*c2+      c,u.x*u.y*c2-u.z*s,u.x*u.z*c2+u.y*s,u.y*u.x*c2+u.z*s,u.y*u.y*c2+    c,u.y*u.z*c2-u.x*s,u.z*u.x*c2-u.y*s,u.z*u.y*c2+u.x*s,u.z*u.z*c2+    c\n);}\n#ifdef TERRAIN3D\nuniform sampler2D u_terrain;uniform float u_terrain_dim;uniform mat4 u_terrain_matrix;uniform vec4 u_terrain_unpack;uniform float u_terrain_exaggeration;uniform highp sampler2D u_depth;\n#endif\nconst highp vec4 bitSh=vec4(256.*256.*256.,256.*256.,256.,1.);const highp vec4 bitShifts=vec4(1.)/bitSh;highp float unpack(highp vec4 color) {return dot(color,bitShifts);}highp float depthOpacity(vec3 frag) {\n#ifdef TERRAIN3D\nhighp float d=unpack(texture(u_depth,frag.xy*0.5+0.5))+0.0001-frag.z;return 1.0-max(0.0,min(1.0,-d*500.0));\n#else\nreturn 1.0;\n#endif\n}float calculate_visibility(vec4 pos) {\n#ifdef TERRAIN3D\nvec3 frag=pos.xyz/pos.w;highp float d=depthOpacity(frag);if (d > 0.95) return 1.0;return (d+depthOpacity(frag+vec3(0.0,0.01,0.0)))/2.0;\n#else\nreturn 1.0;\n#endif\n}float ele(vec2 pos) {\n#ifdef TERRAIN3D\nvec4 rgb=(texture(u_terrain,pos)*255.0)*u_terrain_unpack;return rgb.r+rgb.g+rgb.b-u_terrain_unpack.a;\n#else\nreturn 0.0;\n#endif\n}float get_elevation(vec2 pos) {\n#ifdef TERRAIN3D\n#ifdef GLOBE\nif ((pos.y <-32767.5) || (pos.y > 32766.5)) {return 0.0;}\n#endif\nvec2 coord=(u_terrain_matrix*vec4(pos,0.0,1.0)).xy*u_terrain_dim+1.0;vec2 f=fract(coord);vec2 c=(floor(coord)+0.5)/(u_terrain_dim+2.0);float d=1.0/(u_terrain_dim+2.0);float tl=ele(c);float tr=ele(c+vec2(d,0.0));float bl=ele(c+vec2(0.0,d));float br=ele(c+vec2(d,d));float elevation=mix(mix(tl,tr,f.x),mix(bl,br,f.x),f.y);return elevation*u_terrain_exaggeration;\n#else\nreturn 0.0;\n#endif\n}const float PI=3.141592653589793;uniform mat4 u_projection_matrix;"), projectionMercator: Dt("", "float projectLineThickness(float tileY) {return 1.0;}float projectCircleRadius(float tileY) {return 1.0;}vec4 projectTile(vec2 p) {vec4 result=u_projection_matrix*vec4(p,0.0,1.0);return result;}vec4 projectTile(vec2 p,vec2 rawPos) {vec4 result=u_projection_matrix*vec4(p,0.0,1.0);if (rawPos.y <-32767.5 || rawPos.y > 32766.5) {result.z=-10000000.0;}return result;}vec4 projectTileWithElevation(vec2 posInTile,float elevation) {return u_projection_matrix*vec4(posInTile,elevation,1.0);}vec4 projectTileFor3D(vec2 posInTile,float elevation) {return projectTileWithElevation(posInTile,elevation);}"), projectionGlobe: Dt("", "#define GLOBE_RADIUS 6371008.8\nuniform highp vec4 u_projection_tile_mercator_coords;uniform highp vec4 u_projection_clipping_plane;uniform highp float u_projection_transition;uniform mat4 u_projection_fallback_matrix;vec3 globeRotateVector(vec3 vec,vec2 angles) {vec3 axisRight=vec3(vec.z,0.0,-vec.x);vec3 axisUp=cross(axisRight,vec);axisRight=normalize(axisRight);axisUp=normalize(axisUp);vec2 t=tan(angles);return normalize(vec+axisRight*t.x+axisUp*t.y);}mat3 globeGetRotationMatrix(vec3 spherePos) {vec3 axisRight=vec3(spherePos.z,0.0,-spherePos.x);vec3 axisDown=cross(axisRight,spherePos);axisRight=normalize(axisRight);axisDown=normalize(axisDown);return mat3(axisRight,axisDown,spherePos\n);}float circumferenceRatioAtTileY(float tileY) {float mercator_pos_y=u_projection_tile_mercator_coords.y+u_projection_tile_mercator_coords.w*tileY;float spherical_y=2.0*atan(exp(PI-(mercator_pos_y*PI*2.0)))-PI*0.5;return cos(spherical_y);}float projectLineThickness(float tileY) {float thickness=1.0/circumferenceRatioAtTileY(tileY); \nif (u_projection_transition < 0.999) {return mix(1.0,thickness,u_projection_transition);} else {return thickness;}}vec3 projectToSphere(vec2 translatedPos,vec2 rawPos) {vec2 mercator_pos=u_projection_tile_mercator_coords.xy+u_projection_tile_mercator_coords.zw*translatedPos;vec2 spherical;spherical.x=mercator_pos.x*PI*2.0+PI;spherical.y=2.0*atan(exp(PI-(mercator_pos.y*PI*2.0)))-PI*0.5;float len=cos(spherical.y);vec3 pos=vec3(sin(spherical.x)*len,sin(spherical.y),cos(spherical.x)*len\n);if (rawPos.y <-32767.5) {pos=vec3(0.0,1.0,0.0);}if (rawPos.y > 32766.5) {pos=vec3(0.0,-1.0,0.0);}return pos;}vec3 projectToSphere(vec2 posInTile) {return projectToSphere(posInTile,vec2(0.0,0.0));}float globeComputeClippingZ(vec3 spherePos) {return (1.0-(dot(spherePos,u_projection_clipping_plane.xyz)+u_projection_clipping_plane.w));}vec4 interpolateProjection(vec2 posInTile,vec3 spherePos,float elevation) {vec3 elevatedPos=spherePos*(1.0+elevation/GLOBE_RADIUS);vec4 globePosition=u_projection_matrix*vec4(elevatedPos,1.0);globePosition.z=globeComputeClippingZ(elevatedPos)*globePosition.w;if (u_projection_transition > 0.999) {return globePosition;}vec4 flatPosition=u_projection_fallback_matrix*vec4(posInTile,elevation,1.0);const float z_globeness_threshold=0.2;vec4 result=globePosition;result.z=mix(0.0,globePosition.z,clamp((u_projection_transition-z_globeness_threshold)/(1.0-z_globeness_threshold),0.0,1.0));result.xyw=mix(flatPosition.xyw,globePosition.xyw,u_projection_transition);if ((posInTile.y <-32767.5) || (posInTile.y > 32766.5)) {result=globePosition;const float poles_hidden_anim_percentage=0.02;result.z=mix(globePosition.z,100.0,pow(max((1.0-u_projection_transition)/poles_hidden_anim_percentage,0.0),8.0));}return result;}vec4 interpolateProjectionFor3D(vec2 posInTile,vec3 spherePos,float elevation) {vec3 elevatedPos=spherePos*(1.0+elevation/GLOBE_RADIUS);vec4 globePosition=u_projection_matrix*vec4(elevatedPos,1.0);if (u_projection_transition > 0.999) {return globePosition;}vec4 fallbackPosition=u_projection_fallback_matrix*vec4(posInTile,elevation,1.0);return mix(fallbackPosition,globePosition,u_projection_transition);}vec4 projectTile(vec2 posInTile) {return interpolateProjection(posInTile,projectToSphere(posInTile),0.0);}vec4 projectTile(vec2 posInTile,vec2 rawPos) {return interpolateProjection(posInTile,projectToSphere(posInTile,rawPos),0.0);}vec4 projectTileWithElevation(vec2 posInTile,float elevation) {return interpolateProjection(posInTile,projectToSphere(posInTile),elevation);}vec4 projectTileFor3D(vec2 posInTile,float elevation) {vec3 spherePos=projectToSphere(posInTile,posInTile);return interpolateProjectionFor3D(posInTile,spherePos,elevation);}"), background: Dt("uniform vec4 u_color;uniform float u_opacity;void main() {fragColor=u_color*u_opacity;\n#ifdef OVERDRAW_INSPECTOR\nfragColor=vec4(1.0);\n#endif\n}", "in vec2 a_pos;void main() {gl_Position=projectTile(a_pos);}"), backgroundPattern: Dt("uniform vec2 u_pattern_tl_a;uniform vec2 u_pattern_br_a;uniform vec2 u_pattern_tl_b;uniform vec2 u_pattern_br_b;uniform vec2 u_texsize;uniform float u_mix;uniform float u_opacity;uniform sampler2D u_image;in vec2 v_pos_a;in vec2 v_pos_b;void main() {vec2 imagecoord=mod(v_pos_a,1.0);vec2 pos=mix(u_pattern_tl_a/u_texsize,u_pattern_br_a/u_texsize,imagecoord);vec4 color1=texture(u_image,pos);vec2 imagecoord_b=mod(v_pos_b,1.0);vec2 pos2=mix(u_pattern_tl_b/u_texsize,u_pattern_br_b/u_texsize,imagecoord_b);vec4 color2=texture(u_image,pos2);fragColor=mix(color1,color2,u_mix)*u_opacity;\n#ifdef OVERDRAW_INSPECTOR\nfragColor=vec4(1.0);\n#endif\n}", "uniform vec2 u_pattern_size_a;uniform vec2 u_pattern_size_b;uniform vec2 u_pixel_coord_upper;uniform vec2 u_pixel_coord_lower;uniform float u_scale_a;uniform float u_scale_b;uniform float u_tile_units_to_pixels;in vec2 a_pos;out vec2 v_pos_a;out vec2 v_pos_b;void main() {gl_Position=projectTile(a_pos);v_pos_a=get_pattern_pos(u_pixel_coord_upper,u_pixel_coord_lower,u_scale_a*u_pattern_size_a,u_tile_units_to_pixels,a_pos);v_pos_b=get_pattern_pos(u_pixel_coord_upper,u_pixel_coord_lower,u_scale_b*u_pattern_size_b,u_tile_units_to_pixels,a_pos);}"), circle: Dt("in vec3 v_data;in float v_visibility;\n#pragma mapbox: define highp vec4 color\n#pragma mapbox: define mediump float radius\n#pragma mapbox: define lowp float blur\n#pragma mapbox: define lowp float opacity\n#pragma mapbox: define highp vec4 stroke_color\n#pragma mapbox: define mediump float stroke_width\n#pragma mapbox: define lowp float stroke_opacity\nvoid main() {\n#pragma mapbox: initialize highp vec4 color\n#pragma mapbox: initialize mediump float radius\n#pragma mapbox: initialize lowp float blur\n#pragma mapbox: initialize lowp float opacity\n#pragma mapbox: initialize highp vec4 stroke_color\n#pragma mapbox: initialize mediump float stroke_width\n#pragma mapbox: initialize lowp float stroke_opacity\nvec2 extrude=v_data.xy;float extrude_length=length(extrude);float antialiased_blur=v_data.z;float opacity_t=smoothstep(0.0,antialiased_blur,extrude_length-1.0);float color_t=stroke_width < 0.01 ? 0.0 : smoothstep(antialiased_blur,0.0,extrude_length-radius/(radius+stroke_width));fragColor=v_visibility*opacity_t*mix(color*opacity,stroke_color*stroke_opacity,color_t);const float epsilon=0.5/255.0;if (fragColor.r < epsilon && fragColor.g < epsilon && fragColor.b < epsilon && fragColor.a < epsilon) {discard;}\n#ifdef OVERDRAW_INSPECTOR\nfragColor=vec4(1.0);\n#endif\n}", "uniform bool u_scale_with_map;uniform bool u_pitch_with_map;uniform vec2 u_extrude_scale;uniform highp float u_globe_extrude_scale;uniform lowp float u_device_pixel_ratio;uniform highp float u_camera_to_center_distance;uniform vec2 u_translate;in vec2 a_pos;out vec3 v_data;out float v_visibility;\n#pragma mapbox: define highp vec4 color\n#pragma mapbox: define mediump float radius\n#pragma mapbox: define lowp float blur\n#pragma mapbox: define lowp float opacity\n#pragma mapbox: define highp vec4 stroke_color\n#pragma mapbox: define mediump float stroke_width\n#pragma mapbox: define lowp float stroke_opacity\nvoid main(void) {\n#pragma mapbox: initialize highp vec4 color\n#pragma mapbox: initialize mediump float radius\n#pragma mapbox: initialize lowp float blur\n#pragma mapbox: initialize lowp float opacity\n#pragma mapbox: initialize highp vec4 stroke_color\n#pragma mapbox: initialize mediump float stroke_width\n#pragma mapbox: initialize lowp float stroke_opacity\nvec2 pos_raw=a_pos+32768.0;vec2 extrude=vec2(mod(pos_raw,8.0)/7.0*2.0-1.0);vec2 circle_center=floor(pos_raw/8.0)+u_translate;float ele=get_elevation(circle_center);v_visibility=calculate_visibility(projectTileWithElevation(circle_center,ele));if (u_pitch_with_map) {\n#ifdef GLOBE\nvec3 center_vector=projectToSphere(circle_center);\n#endif\nfloat angle_scale=u_globe_extrude_scale;vec2 corner_position=circle_center;if (u_scale_with_map) {angle_scale*=(radius+stroke_width);corner_position+=extrude*u_extrude_scale*(radius+stroke_width);} else {\n#ifdef GLOBE\nvec4 projected_center=interpolateProjection(circle_center,center_vector,ele);\n#else\nvec4 projected_center=projectTileWithElevation(circle_center,ele);\n#endif\ncorner_position+=extrude*u_extrude_scale*(radius+stroke_width)*(projected_center.w/u_camera_to_center_distance);angle_scale*=(radius+stroke_width)*(projected_center.w/u_camera_to_center_distance);}\n#ifdef GLOBE\nvec2 angles=extrude*angle_scale;vec3 corner_vector=globeRotateVector(center_vector,angles);gl_Position=interpolateProjection(corner_position,corner_vector,ele);\n#else\ngl_Position=projectTileWithElevation(corner_position,ele);\n#endif\n} else {gl_Position=projectTileWithElevation(circle_center,ele);if (gl_Position.z/gl_Position.w > 1.0) {gl_Position.xy=vec2(10000.0);}if (u_scale_with_map) {gl_Position.xy+=extrude*(radius+stroke_width)*u_extrude_scale*u_camera_to_center_distance;} else {gl_Position.xy+=extrude*(radius+stroke_width)*u_extrude_scale*gl_Position.w;}}float antialiasblur=-max(1.0/u_device_pixel_ratio/(radius+stroke_width),blur);v_data=vec3(extrude.x,extrude.y,antialiasblur);}"), clippingMask: Dt(Rt, "in vec2 a_pos;void main() {gl_Position=projectTile(a_pos);}"), heatmap: Dt("uniform highp float u_intensity;in vec2 v_extrude;\n#pragma mapbox: define highp float weight\n#define GAUSS_COEF 0.3989422804014327\nvoid main() {\n#pragma mapbox: initialize highp float weight\nfloat d=-0.5*3.0*3.0*dot(v_extrude,v_extrude);float val=weight*u_intensity*GAUSS_COEF*exp(d);fragColor=vec4(val,1.0,1.0,1.0);\n#ifdef OVERDRAW_INSPECTOR\nfragColor=vec4(1.0);\n#endif\n}", "uniform float u_extrude_scale;uniform float u_opacity;uniform float u_intensity;uniform highp float u_globe_extrude_scale;in vec2 a_pos;out vec2 v_extrude;\n#pragma mapbox: define highp float weight\n#pragma mapbox: define mediump float radius\nconst highp float ZERO=1.0/255.0/16.0;\n#define GAUSS_COEF 0.3989422804014327\nvoid main(void) {\n#pragma mapbox: initialize highp float weight\n#pragma mapbox: initialize mediump float radius\nvec2 pos_raw=a_pos+32768.0;vec2 unscaled_extrude=vec2(mod(pos_raw,8.0)/7.0*2.0-1.0);float S=sqrt(-2.0*log(ZERO/weight/u_intensity/GAUSS_COEF))/3.0;v_extrude=S*unscaled_extrude;vec2 extrude=v_extrude*radius*u_extrude_scale;vec2 circle_center=floor(pos_raw/8.0);\n#ifdef GLOBE\nvec2 angles=v_extrude*radius*u_globe_extrude_scale;vec3 center_vector=projectToSphere(circle_center);vec3 corner_vector=globeRotateVector(center_vector,angles);gl_Position=interpolateProjection(circle_center+extrude,corner_vector,0.0);\n#else\ngl_Position=projectTileFor3D(circle_center+extrude,get_elevation(circle_center));\n#endif\n}"), heatmapTexture: Dt("uniform sampler2D u_image;uniform sampler2D u_color_ramp;uniform float u_opacity;in vec2 v_pos;void main() {float t=texture(u_image,v_pos).r;vec4 color=texture(u_color_ramp,vec2(t,0.5));fragColor=color*u_opacity;\n#ifdef OVERDRAW_INSPECTOR\nfragColor=vec4(0.0);\n#endif\n}", "uniform mat4 u_matrix;uniform vec2 u_world;in vec2 a_pos;out vec2 v_pos;void main() {gl_Position=u_matrix*vec4(a_pos*u_world,0,1);v_pos.x=a_pos.x;v_pos.y=1.0-a_pos.y;}"), collisionBox: Dt("in float v_placed;in float v_notUsed;void main() {float alpha=0.5;fragColor=vec4(1.0,0.0,0.0,1.0)*alpha;if (v_placed > 0.5) {fragColor=vec4(0.0,0.0,1.0,0.5)*alpha;}if (v_notUsed > 0.5) {fragColor*=.1;}}", "in vec2 a_anchor_pos;in vec2 a_placed;in vec2 a_box_real;uniform vec2 u_pixel_extrude_scale;out float v_placed;out float v_notUsed;void main() {gl_Position=projectTileWithElevation(a_anchor_pos,get_elevation(a_anchor_pos));gl_Position.xy=((a_box_real+0.5)*u_pixel_extrude_scale*2.0-1.0)*vec2(1.0,-1.0)*gl_Position.w;if (gl_Position.z/gl_Position.w < 1.1) {gl_Position.z=0.5;}v_placed=a_placed.x;v_notUsed=a_placed.y;}"), collisionCircle: Dt("in float v_radius;in vec2 v_extrude;in float v_collision;void main() {float alpha=0.5;float stroke_radius=0.9;float distance_to_center=length(v_extrude);float distance_to_edge=abs(distance_to_center-v_radius);float opacity_t=smoothstep(-stroke_radius,0.0,-distance_to_edge);vec4 color=mix(vec4(0.0,0.0,1.0,0.5),vec4(1.0,0.0,0.0,1.0),v_collision);fragColor=color*alpha*opacity_t;}", "in vec2 a_pos;in float a_radius;in vec2 a_flags;uniform vec2 u_viewport_size;out float v_radius;out vec2 v_extrude;out float v_collision;void main() {float radius=a_radius;float collision=a_flags.x;float vertexIdx=a_flags.y;vec2 quadVertexOffset=vec2(mix(-1.0,1.0,float(vertexIdx >=2.0)),mix(-1.0,1.0,float(vertexIdx >=1.0 && vertexIdx <=2.0)));vec2 quadVertexExtent=quadVertexOffset*radius;float padding_factor=1.2;v_radius=radius;v_extrude=quadVertexExtent*padding_factor;v_collision=collision;gl_Position=vec4((a_pos/u_viewport_size*2.0-1.0)*vec2(1.0,-1.0),0.0,1.0)+vec4(quadVertexExtent*padding_factor/u_viewport_size*2.0,0.0,0.0);}"), colorRelief: Dt("#ifdef GL_ES\nprecision highp float;\n#endif\nuniform sampler2D u_image;uniform vec4 u_unpack;uniform sampler2D u_elevation_stops;uniform sampler2D u_color_stops;uniform int u_color_ramp_size;uniform float u_opacity;in vec2 v_pos;float getElevation(vec2 coord) {vec4 data=texture(u_image,coord)*255.0;data.a=-1.0;return dot(data,u_unpack);}float getElevationStop(int stop) {float x=(float(stop)+0.5)/float(u_color_ramp_size);vec4 data=texture(u_elevation_stops,vec2(x,0))*255.0;data.a=-1.0;return dot(data,u_unpack);}void main() {float el=getElevation(v_pos);int r=(u_color_ramp_size-1);int l=0;float el_l=getElevationStop(l);float el_r=getElevationStop(r);while(r-l > 1){int m=(r+l)/2;float el_m=getElevationStop(m);if(el < el_m){r=m;el_r=el_m;}else\n{l=m;el_l=el_m;}}float x=(float(l)+(el-el_l)/(el_r-el_l)+0.5)/float(u_color_ramp_size);fragColor=u_opacity*texture(u_color_stops,vec2(x,0));\n#ifdef OVERDRAW_INSPECTOR\nfragColor=vec4(1.0);\n#endif\n}", "uniform vec2 u_dimension;in vec2 a_pos;out vec2 v_pos;void main() {gl_Position=projectTile(a_pos,a_pos);highp vec2 epsilon=1.0/u_dimension;float scale=(u_dimension.x-2.0)/u_dimension.x;v_pos=(a_pos/8192.0)*scale+epsilon;if (a_pos.y <-32767.5) {v_pos.y=0.0;}if (a_pos.y > 32766.5) {v_pos.y=1.0;}}"), debug: Dt("uniform highp vec4 u_color;uniform sampler2D u_overlay;in vec2 v_uv;void main() {vec4 overlay_color=texture(u_overlay,v_uv);fragColor=mix(u_color,overlay_color,overlay_color.a);}", "in vec2 a_pos;out vec2 v_uv;uniform float u_overlay_scale;void main() {v_uv=a_pos/8192.0;gl_Position=projectTileWithElevation(a_pos*u_overlay_scale,get_elevation(a_pos));}"), depth: Dt(Rt, "in vec2 a_pos;void main() {\n#ifdef GLOBE\ngl_Position=projectTileFor3D(a_pos,0.0);\n#else\ngl_Position=u_projection_matrix*vec4(a_pos,0.0,1.0);\n#endif\n}"), fill: Dt("#pragma mapbox: define highp vec4 color\n#pragma mapbox: define lowp float opacity\nvoid main() {\n#pragma mapbox: initialize highp vec4 color\n#pragma mapbox: initialize lowp float opacity\nfragColor=color*opacity;\n#ifdef OVERDRAW_INSPECTOR\nfragColor=vec4(1.0);\n#endif\n}", "uniform vec2 u_fill_translate;in vec2 a_pos;\n#pragma mapbox: define highp vec4 color\n#pragma mapbox: define lowp float opacity\nvoid main() {\n#pragma mapbox: initialize highp vec4 color\n#pragma mapbox: initialize lowp float opacity\ngl_Position=projectTile(a_pos+u_fill_translate,a_pos);}"), fillOutline: Dt("in vec2 v_pos;\n#ifdef GLOBE\nin float v_depth;\n#endif\n#pragma mapbox: define highp vec4 outline_color\n#pragma mapbox: define lowp float opacity\nvoid main() {\n#pragma mapbox: initialize highp vec4 outline_color\n#pragma mapbox: initialize lowp float opacity\nfloat dist=length(v_pos-gl_FragCoord.xy);float alpha=1.0-smoothstep(0.0,1.0,dist);fragColor=outline_color*(alpha*opacity);\n#ifdef GLOBE\nif (v_depth > 1.0) {discard;}\n#endif\n#ifdef OVERDRAW_INSPECTOR\nfragColor=vec4(1.0);\n#endif\n}", "uniform vec2 u_world;uniform vec2 u_fill_translate;in vec2 a_pos;out vec2 v_pos;\n#ifdef GLOBE\nout float v_depth;\n#endif\n#pragma mapbox: define highp vec4 outline_color\n#pragma mapbox: define lowp float opacity\nvoid main() {\n#pragma mapbox: initialize highp vec4 outline_color\n#pragma mapbox: initialize lowp float opacity\ngl_Position=projectTile(a_pos+u_fill_translate,a_pos);v_pos=(gl_Position.xy/gl_Position.w+1.0)/2.0*u_world;\n#ifdef GLOBE\nv_depth=gl_Position.z/gl_Position.w;\n#endif\n}"), fillOutlinePattern: Dt("uniform vec2 u_texsize;uniform sampler2D u_image;uniform float u_fade;in vec2 v_pos_a;in vec2 v_pos_b;in vec2 v_pos;\n#ifdef GLOBE\nin float v_depth;\n#endif\n#pragma mapbox: define lowp float opacity\n#pragma mapbox: define lowp vec4 pattern_from\n#pragma mapbox: define lowp vec4 pattern_to\nvoid main() {\n#pragma mapbox: initialize lowp float opacity\n#pragma mapbox: initialize mediump vec4 pattern_from\n#pragma mapbox: initialize mediump vec4 pattern_to\nvec2 pattern_tl_a=pattern_from.xy;vec2 pattern_br_a=pattern_from.zw;vec2 pattern_tl_b=pattern_to.xy;vec2 pattern_br_b=pattern_to.zw;vec2 imagecoord=mod(v_pos_a,1.0);vec2 pos=mix(pattern_tl_a/u_texsize,pattern_br_a/u_texsize,imagecoord);vec4 color1=texture(u_image,pos);vec2 imagecoord_b=mod(v_pos_b,1.0);vec2 pos2=mix(pattern_tl_b/u_texsize,pattern_br_b/u_texsize,imagecoord_b);vec4 color2=texture(u_image,pos2);float dist=length(v_pos-gl_FragCoord.xy);float alpha=1.0-smoothstep(0.0,1.0,dist);fragColor=mix(color1,color2,u_fade)*alpha*opacity;\n#ifdef GLOBE\nif (v_depth > 1.0) {discard;}\n#endif\n#ifdef OVERDRAW_INSPECTOR\nfragColor=vec4(1.0);\n#endif\n}", "uniform vec2 u_world;uniform vec2 u_pixel_coord_upper;uniform vec2 u_pixel_coord_lower;uniform vec3 u_scale;uniform vec2 u_fill_translate;in vec2 a_pos;out vec2 v_pos_a;out vec2 v_pos_b;out vec2 v_pos;\n#ifdef GLOBE\nout float v_depth;\n#endif\n#pragma mapbox: define lowp float opacity\n#pragma mapbox: define lowp vec4 pattern_from\n#pragma mapbox: define lowp vec4 pattern_to\n#pragma mapbox: define lowp float pixel_ratio_from\n#pragma mapbox: define lowp float pixel_ratio_to\nvoid main() {\n#pragma mapbox: initialize lowp float opacity\n#pragma mapbox: initialize mediump vec4 pattern_from\n#pragma mapbox: initialize mediump vec4 pattern_to\n#pragma mapbox: initialize lowp float pixel_ratio_from\n#pragma mapbox: initialize lowp float pixel_ratio_to\nvec2 pattern_tl_a=pattern_from.xy;vec2 pattern_br_a=pattern_from.zw;vec2 pattern_tl_b=pattern_to.xy;vec2 pattern_br_b=pattern_to.zw;float tileRatio=u_scale.x;float fromScale=u_scale.y;float toScale=u_scale.z;gl_Position=projectTile(a_pos+u_fill_translate,a_pos);vec2 display_size_a=(pattern_br_a-pattern_tl_a)/pixel_ratio_from;vec2 display_size_b=(pattern_br_b-pattern_tl_b)/pixel_ratio_to;v_pos_a=get_pattern_pos(u_pixel_coord_upper,u_pixel_coord_lower,fromScale*display_size_a,tileRatio,a_pos);v_pos_b=get_pattern_pos(u_pixel_coord_upper,u_pixel_coord_lower,toScale*display_size_b,tileRatio,a_pos);v_pos=(gl_Position.xy/gl_Position.w+1.0)/2.0*u_world;\n#ifdef GLOBE\nv_depth=gl_Position.z/gl_Position.w;\n#endif\n}"), fillPattern: Dt("#ifdef GL_ES\nprecision highp float;\n#endif\nuniform vec2 u_texsize;uniform float u_fade;uniform sampler2D u_image;in vec2 v_pos_a;in vec2 v_pos_b;\n#pragma mapbox: define lowp float opacity\n#pragma mapbox: define lowp vec4 pattern_from\n#pragma mapbox: define lowp vec4 pattern_to\nvoid main() {\n#pragma mapbox: initialize lowp float opacity\n#pragma mapbox: initialize mediump vec4 pattern_from\n#pragma mapbox: initialize mediump vec4 pattern_to\nvec2 pattern_tl_a=pattern_from.xy;vec2 pattern_br_a=pattern_from.zw;vec2 pattern_tl_b=pattern_to.xy;vec2 pattern_br_b=pattern_to.zw;vec2 imagecoord=mod(v_pos_a,1.0);vec2 pos=mix(pattern_tl_a/u_texsize,pattern_br_a/u_texsize,imagecoord);vec4 color1=texture(u_image,pos);vec2 imagecoord_b=mod(v_pos_b,1.0);vec2 pos2=mix(pattern_tl_b/u_texsize,pattern_br_b/u_texsize,imagecoord_b);vec4 color2=texture(u_image,pos2);fragColor=mix(color1,color2,u_fade)*opacity;\n#ifdef OVERDRAW_INSPECTOR\nfragColor=vec4(1.0);\n#endif\n}", "uniform vec2 u_pixel_coord_upper;uniform vec2 u_pixel_coord_lower;uniform vec3 u_scale;uniform vec2 u_fill_translate;in vec2 a_pos;out vec2 v_pos_a;out vec2 v_pos_b;\n#pragma mapbox: define lowp float opacity\n#pragma mapbox: define lowp vec4 pattern_from\n#pragma mapbox: define lowp vec4 pattern_to\n#pragma mapbox: define lowp float pixel_ratio_from\n#pragma mapbox: define lowp float pixel_ratio_to\nvoid main() {\n#pragma mapbox: initialize lowp float opacity\n#pragma mapbox: initialize mediump vec4 pattern_from\n#pragma mapbox: initialize mediump vec4 pattern_to\n#pragma mapbox: initialize lowp float pixel_ratio_from\n#pragma mapbox: initialize lowp float pixel_ratio_to\nvec2 pattern_tl_a=pattern_from.xy;vec2 pattern_br_a=pattern_from.zw;vec2 pattern_tl_b=pattern_to.xy;vec2 pattern_br_b=pattern_to.zw;float tileZoomRatio=u_scale.x;float fromScale=u_scale.y;float toScale=u_scale.z;vec2 display_size_a=(pattern_br_a-pattern_tl_a)/pixel_ratio_from;vec2 display_size_b=(pattern_br_b-pattern_tl_b)/pixel_ratio_to;gl_Position=projectTile(a_pos+u_fill_translate,a_pos);v_pos_a=get_pattern_pos(u_pixel_coord_upper,u_pixel_coord_lower,fromScale*display_size_a,tileZoomRatio,a_pos);v_pos_b=get_pattern_pos(u_pixel_coord_upper,u_pixel_coord_lower,toScale*display_size_b,tileZoomRatio,a_pos);}"), fillExtrusion: Dt("in vec4 v_color;void main() {fragColor=v_color;\n#ifdef OVERDRAW_INSPECTOR\nfragColor=vec4(1.0);\n#endif\n}", "uniform vec3 u_lightcolor;uniform lowp vec3 u_lightpos;uniform lowp vec3 u_lightpos_globe;uniform lowp float u_lightintensity;uniform float u_vertical_gradient;uniform lowp float u_opacity;uniform vec2 u_fill_translate;in vec2 a_pos;in vec4 a_normal_ed;\n#ifdef TERRAIN3D\nin vec2 a_centroid;\n#endif\nout vec4 v_color;\n#pragma mapbox: define highp float base\n#pragma mapbox: define highp float height\n#pragma mapbox: define highp vec4 color\nvoid main() {\n#pragma mapbox: initialize highp float base\n#pragma mapbox: initialize highp float height\n#pragma mapbox: initialize highp vec4 color\nvec3 normal=a_normal_ed.xyz;\n#ifdef TERRAIN3D\nfloat height_terrain3d_offset=get_elevation(a_centroid);float base_terrain3d_offset=height_terrain3d_offset-(base > 0.0 ? 0.0 : 10.0);\n#else\nfloat height_terrain3d_offset=0.0;float base_terrain3d_offset=0.0;\n#endif\nbase=max(0.0,base)+base_terrain3d_offset;height=max(0.0,height)+height_terrain3d_offset;float t=mod(normal.x,2.0);float elevation=t > 0.0 ? height : base;vec2 posInTile=a_pos+u_fill_translate;\n#ifdef GLOBE\nvec3 spherePos=projectToSphere(posInTile,a_pos);gl_Position=interpolateProjectionFor3D(posInTile,spherePos,elevation);\n#else\ngl_Position=u_projection_matrix*vec4(posInTile,elevation,1.0);\n#endif\nfloat colorvalue=color.r*0.2126+color.g*0.7152+color.b*0.0722;v_color=vec4(0.0,0.0,0.0,1.0);vec4 ambientlight=vec4(0.03,0.03,0.03,1.0);color+=ambientlight;vec3 normalForLighting=normal/16384.0;float directional=clamp(dot(normalForLighting,u_lightpos),0.0,1.0);\n#ifdef GLOBE\nmat3 rotMatrix=globeGetRotationMatrix(spherePos);normalForLighting=rotMatrix*normalForLighting;directional=mix(directional,clamp(dot(normalForLighting,u_lightpos_globe),0.0,1.0),u_projection_transition);\n#endif\ndirectional=mix((1.0-u_lightintensity),max((1.0-colorvalue+u_lightintensity),1.0),directional);if (normal.y !=0.0) {directional*=((1.0-u_vertical_gradient)+(u_vertical_gradient*clamp((t+base)*pow(height/150.0,0.5),mix(0.7,0.98,1.0-u_lightintensity),1.0)));}v_color.r+=clamp(color.r*directional*u_lightcolor.r,mix(0.0,0.3,1.0-u_lightcolor.r),1.0);v_color.g+=clamp(color.g*directional*u_lightcolor.g,mix(0.0,0.3,1.0-u_lightcolor.g),1.0);v_color.b+=clamp(color.b*directional*u_lightcolor.b,mix(0.0,0.3,1.0-u_lightcolor.b),1.0);v_color*=u_opacity;}"), fillExtrusionPattern: Dt("uniform vec2 u_texsize;uniform float u_fade;uniform sampler2D u_image;in vec2 v_pos_a;in vec2 v_pos_b;in vec4 v_lighting;\n#pragma mapbox: define lowp float base\n#pragma mapbox: define lowp float height\n#pragma mapbox: define lowp vec4 pattern_from\n#pragma mapbox: define lowp vec4 pattern_to\n#pragma mapbox: define lowp float pixel_ratio_from\n#pragma mapbox: define lowp float pixel_ratio_to\nvoid main() {\n#pragma mapbox: initialize lowp float base\n#pragma mapbox: initialize lowp float height\n#pragma mapbox: initialize mediump vec4 pattern_from\n#pragma mapbox: initialize mediump vec4 pattern_to\n#pragma mapbox: initialize lowp float pixel_ratio_from\n#pragma mapbox: initialize lowp float pixel_ratio_to\nvec2 pattern_tl_a=pattern_from.xy;vec2 pattern_br_a=pattern_from.zw;vec2 pattern_tl_b=pattern_to.xy;vec2 pattern_br_b=pattern_to.zw;vec2 imagecoord=mod(v_pos_a,1.0);vec2 pos=mix(pattern_tl_a/u_texsize,pattern_br_a/u_texsize,imagecoord);vec4 color1=texture(u_image,pos);vec2 imagecoord_b=mod(v_pos_b,1.0);vec2 pos2=mix(pattern_tl_b/u_texsize,pattern_br_b/u_texsize,imagecoord_b);vec4 color2=texture(u_image,pos2);vec4 mixedColor=mix(color1,color2,u_fade);fragColor=mixedColor*v_lighting;\n#ifdef OVERDRAW_INSPECTOR\nfragColor=vec4(1.0);\n#endif\n}", "uniform vec2 u_pixel_coord_upper;uniform vec2 u_pixel_coord_lower;uniform float u_height_factor;uniform vec3 u_scale;uniform float u_vertical_gradient;uniform lowp float u_opacity;uniform vec2 u_fill_translate;uniform vec3 u_lightcolor;uniform lowp vec3 u_lightpos;uniform lowp vec3 u_lightpos_globe;uniform lowp float u_lightintensity;in vec2 a_pos;in vec4 a_normal_ed;\n#ifdef TERRAIN3D\nin vec2 a_centroid;\n#endif\n#ifdef GLOBE\nout vec3 v_sphere_pos;\n#endif\nout vec2 v_pos_a;out vec2 v_pos_b;out vec4 v_lighting;\n#pragma mapbox: define lowp float base\n#pragma mapbox: define lowp float height\n#pragma mapbox: define lowp vec4 pattern_from\n#pragma mapbox: define lowp vec4 pattern_to\n#pragma mapbox: define lowp float pixel_ratio_from\n#pragma mapbox: define lowp float pixel_ratio_to\nvoid main() {\n#pragma mapbox: initialize lowp float base\n#pragma mapbox: initialize lowp float height\n#pragma mapbox: initialize mediump vec4 pattern_from\n#pragma mapbox: initialize mediump vec4 pattern_to\n#pragma mapbox: initialize lowp float pixel_ratio_from\n#pragma mapbox: initialize lowp float pixel_ratio_to\nvec2 pattern_tl_a=pattern_from.xy;vec2 pattern_br_a=pattern_from.zw;vec2 pattern_tl_b=pattern_to.xy;vec2 pattern_br_b=pattern_to.zw;float tileRatio=u_scale.x;float fromScale=u_scale.y;float toScale=u_scale.z;vec3 normal=a_normal_ed.xyz;float edgedistance=a_normal_ed.w;vec2 display_size_a=(pattern_br_a-pattern_tl_a)/pixel_ratio_from;vec2 display_size_b=(pattern_br_b-pattern_tl_b)/pixel_ratio_to;\n#ifdef TERRAIN3D\nfloat height_terrain3d_offset=get_elevation(a_centroid);float base_terrain3d_offset=height_terrain3d_offset-(base > 0.0 ? 0.0 : 10.0);\n#else\nfloat height_terrain3d_offset=0.0;float base_terrain3d_offset=0.0;\n#endif\nbase=max(0.0,base)+base_terrain3d_offset;height=max(0.0,height)+height_terrain3d_offset;float t=mod(normal.x,2.0);float elevation=t > 0.0 ? height : base;vec2 posInTile=a_pos+u_fill_translate;\n#ifdef GLOBE\nvec3 spherePos=projectToSphere(posInTile,a_pos);vec3 elevatedPos=spherePos*(1.0+elevation/GLOBE_RADIUS);v_sphere_pos=elevatedPos;gl_Position=interpolateProjectionFor3D(posInTile,spherePos,elevation);\n#else\ngl_Position=u_projection_matrix*vec4(posInTile,elevation,1.0);\n#endif\nvec2 pos=normal.x==1.0 && normal.y==0.0 && normal.z==16384.0\n? a_pos\n: vec2(edgedistance,elevation*u_height_factor);v_pos_a=get_pattern_pos(u_pixel_coord_upper,u_pixel_coord_lower,fromScale*display_size_a,tileRatio,pos);v_pos_b=get_pattern_pos(u_pixel_coord_upper,u_pixel_coord_lower,toScale*display_size_b,tileRatio,pos);v_lighting=vec4(0.0,0.0,0.0,1.0);float directional=clamp(dot(normal/16383.0,u_lightpos),0.0,1.0);directional=mix((1.0-u_lightintensity),max((0.5+u_lightintensity),1.0),directional);if (normal.y !=0.0) {directional*=((1.0-u_vertical_gradient)+(u_vertical_gradient*clamp((t+base)*pow(height/150.0,0.5),mix(0.7,0.98,1.0-u_lightintensity),1.0)));}v_lighting.rgb+=clamp(directional*u_lightcolor,mix(vec3(0.0),vec3(0.3),1.0-u_lightcolor),vec3(1.0));v_lighting*=u_opacity;}"), hillshadePrepare: Dt("#ifdef GL_ES\nprecision highp float;\n#endif\nuniform sampler2D u_image;in vec2 v_pos;uniform vec2 u_dimension;uniform float u_zoom;uniform vec4 u_unpack;float getElevation(vec2 coord,float bias) {vec4 data=texture(u_image,coord)*255.0;data.a=-1.0;return dot(data,u_unpack);}void main() {vec2 epsilon=1.0/u_dimension;float tileSize=u_dimension.x-2.0;float a=getElevation(v_pos+vec2(-epsilon.x,-epsilon.y),0.0);float b=getElevation(v_pos+vec2(0,-epsilon.y),0.0);float c=getElevation(v_pos+vec2(epsilon.x,-epsilon.y),0.0);float d=getElevation(v_pos+vec2(-epsilon.x,0),0.0);float e=getElevation(v_pos,0.0);float f=getElevation(v_pos+vec2(epsilon.x,0),0.0);float g=getElevation(v_pos+vec2(-epsilon.x,epsilon.y),0.0);float h=getElevation(v_pos+vec2(0,epsilon.y),0.0);float i=getElevation(v_pos+vec2(epsilon.x,epsilon.y),0.0);float exaggerationFactor=u_zoom < 2.0 ? 0.4 : u_zoom < 4.5 ? 0.35 : 0.3;float exaggeration=u_zoom < 15.0 ? (u_zoom-15.0)*exaggerationFactor : 0.0;vec2 deriv=vec2((c+f+f+i)-(a+d+d+g),(g+h+h+i)-(a+b+b+c))*tileSize/pow(2.0,exaggeration+(28.2562-u_zoom));fragColor=clamp(vec4(deriv.x/8.0+0.5,deriv.y/8.0+0.5,1.0,1.0),0.0,1.0);\n#ifdef OVERDRAW_INSPECTOR\nfragColor=vec4(1.0);\n#endif\n}", "uniform mat4 u_matrix;uniform vec2 u_dimension;in vec2 a_pos;in vec2 a_texture_pos;out vec2 v_pos;void main() {gl_Position=u_matrix*vec4(a_pos,0,1);highp vec2 epsilon=1.0/u_dimension;float scale=(u_dimension.x-2.0)/u_dimension.x;v_pos=(a_texture_pos/8192.0)*scale+epsilon;}"), hillshade: Dt("uniform sampler2D u_image;in vec2 v_pos;uniform vec2 u_latrange;uniform float u_exaggeration;uniform vec4 u_accent;uniform int u_method;uniform float u_altitudes[NUM_ILLUMINATION_SOURCES];uniform float u_azimuths[NUM_ILLUMINATION_SOURCES];uniform vec4 u_shadows[NUM_ILLUMINATION_SOURCES];uniform vec4 u_highlights[NUM_ILLUMINATION_SOURCES];\n#define PI 3.141592653589793\n#define STANDARD 0\n#define COMBINED 1\n#define IGOR 2\n#define MULTIDIRECTIONAL 3\n#define BASIC 4\nfloat get_aspect(vec2 deriv){return deriv.x !=0.0 ? atan(deriv.y,-deriv.x) : PI/2.0*(deriv.y > 0.0 ? 1.0 :-1.0);}void igor_hillshade(vec2 deriv){deriv=deriv*u_exaggeration*2.0;float aspect=get_aspect(deriv);float azimuth=u_azimuths[0]+PI;float slope_stength=atan(length(deriv))*2.0/PI;float aspect_strength=1.0-abs(mod((aspect+azimuth)/PI+0.5,2.0)-1.0);float shadow_strength=slope_stength*aspect_strength;float highlight_strength=slope_stength*(1.0-aspect_strength);fragColor=u_shadows[0]*shadow_strength+u_highlights[0]*highlight_strength;}void standard_hillshade(vec2 deriv){float azimuth=u_azimuths[0]+PI;float slope=atan(0.625*length(deriv));float aspect=get_aspect(deriv);float intensity=u_exaggeration;float base=1.875-intensity*1.75;float maxValue=0.5*PI;float scaledSlope=intensity !=0.5 ? ((pow(base,slope)-1.0)/(pow(base,maxValue)-1.0))*maxValue : slope;float accent=cos(scaledSlope);vec4 accent_color=(1.0-accent)*u_accent*clamp(intensity*2.0,0.0,1.0);float shade=abs(mod((aspect+azimuth)/PI+0.5,2.0)-1.0);vec4 shade_color=mix(u_shadows[0],u_highlights[0],shade)*sin(scaledSlope)*clamp(intensity*2.0,0.0,1.0);fragColor=accent_color*(1.0-shade_color.a)+shade_color;}void basic_hillshade(vec2 deriv){deriv=deriv*u_exaggeration*2.0;float azimuth=u_azimuths[0]+PI;float cos_az=cos(azimuth);float sin_az=sin(azimuth);float cos_alt=cos(u_altitudes[0]);float sin_alt=sin(u_altitudes[0]);float cang=(sin_alt-(deriv.y*cos_az*cos_alt-deriv.x*sin_az*cos_alt))/sqrt(1.0+dot(deriv,deriv));float shade=clamp(cang,0.0,1.0);if(shade > 0.5){fragColor=u_highlights[0]*(2.0*shade-1.0);}else\n{fragColor=u_shadows[0]*(1.0-2.0*shade);}}void multidirectional_hillshade(vec2 deriv){deriv=deriv*u_exaggeration*2.0;fragColor=vec4(0,0,0,0);for(int i=0; i < NUM_ILLUMINATION_SOURCES; i++){float cos_alt=cos(u_altitudes[i]);float sin_alt=sin(u_altitudes[i]);float cos_az=-cos(u_azimuths[i]);float sin_az=-sin(u_azimuths[i]);float cang=(sin_alt-(deriv.y*cos_az*cos_alt-deriv.x*sin_az*cos_alt))/sqrt(1.0+dot(deriv,deriv));float shade=clamp(cang,0.0,1.0);if(shade > 0.5){fragColor+=u_highlights[i]*(2.0*shade-1.0)/float(NUM_ILLUMINATION_SOURCES);}else\n{fragColor+=u_shadows[i]*(1.0-2.0*shade)/float(NUM_ILLUMINATION_SOURCES);}}}void combined_hillshade(vec2 deriv){deriv=deriv*u_exaggeration*2.0;float azimuth=u_azimuths[0]+PI;float cos_az=cos(azimuth);float sin_az=sin(azimuth);float cos_alt=cos(u_altitudes[0]);float sin_alt=sin(u_altitudes[0]);float cang=acos((sin_alt-(deriv.y*cos_az*cos_alt-deriv.x*sin_az*cos_alt))/sqrt(1.0+dot(deriv,deriv)));cang=clamp(cang,0.0,PI/2.0);float shade=cang*atan(length(deriv))*4.0/PI/PI;float highlight=(PI/2.0-cang)*atan(length(deriv))*4.0/PI/PI;fragColor=u_shadows[0]*shade+u_highlights[0]*highlight;}void main() {vec4 pixel=texture(u_image,v_pos);float scaleFactor=cos(radians((u_latrange[0]-u_latrange[1])*(1.0-v_pos.y)+u_latrange[1]));vec2 deriv=((pixel.rg*8.0)-4.0)/scaleFactor;if (u_method==BASIC) {basic_hillshade(deriv);} else if (u_method==COMBINED) {combined_hillshade(deriv);} else if (u_method==IGOR) {igor_hillshade(deriv);} else if (u_method==MULTIDIRECTIONAL) {multidirectional_hillshade(deriv);} else if (u_method==STANDARD) {standard_hillshade(deriv);} else {standard_hillshade(deriv);}\n#ifdef OVERDRAW_INSPECTOR\nfragColor=vec4(1.0);\n#endif\n}", "uniform mat4 u_matrix;in vec2 a_pos;out vec2 v_pos;void main() {gl_Position=projectTile(a_pos,a_pos);v_pos=a_pos/8192.0;if (a_pos.y <-32767.5) {v_pos.y=0.0;}if (a_pos.y > 32766.5) {v_pos.y=1.0;}}"), line: Dt("uniform lowp float u_device_pixel_ratio;in vec2 v_width2;in vec2 v_normal;in float v_gamma_scale;\n#ifdef GLOBE\nin float v_depth;\n#endif\n#pragma mapbox: define highp vec4 color\n#pragma mapbox: define lowp float blur\n#pragma mapbox: define lowp float opacity\nvoid main() {\n#pragma mapbox: initialize highp vec4 color\n#pragma mapbox: initialize lowp float blur\n#pragma mapbox: initialize lowp float opacity\nfloat dist=length(v_normal)*v_width2.s;float blur2=(blur+1.0/u_device_pixel_ratio)*v_gamma_scale;float alpha=clamp(min(dist-(v_width2.t-blur2),v_width2.s-dist)/blur2,0.0,1.0);fragColor=color*(alpha*opacity);\n#ifdef GLOBE\nif (v_depth > 1.0) {discard;}\n#endif\n#ifdef OVERDRAW_INSPECTOR\nfragColor=vec4(1.0);\n#endif\n}", "\n#define scale 0.015873016\nin vec2 a_pos_normal;in vec4 a_data;uniform vec2 u_translation;uniform mediump float u_ratio;uniform vec2 u_units_to_pixels;uniform lowp float u_device_pixel_ratio;out vec2 v_normal;out vec2 v_width2;out float v_gamma_scale;out highp float v_linesofar;\n#ifdef GLOBE\nout float v_depth;\n#endif\n#pragma mapbox: define highp vec4 color\n#pragma mapbox: define lowp float blur\n#pragma mapbox: define lowp float opacity\n#pragma mapbox: define mediump float gapwidth\n#pragma mapbox: define lowp float offset\n#pragma mapbox: define mediump float width\nvoid main() {\n#pragma mapbox: initialize highp vec4 color\n#pragma mapbox: initialize lowp float blur\n#pragma mapbox: initialize lowp float opacity\n#pragma mapbox: initialize mediump float gapwidth\n#pragma mapbox: initialize lowp float offset\n#pragma mapbox: initialize mediump float width\nfloat ANTIALIASING=1.0/u_device_pixel_ratio/2.0;vec2 a_extrude=a_data.xy-128.0;float a_direction=mod(a_data.z,4.0)-1.0;v_linesofar=(floor(a_data.z/4.0)+a_data.w*64.0)*2.0;vec2 pos=floor(a_pos_normal*0.5);mediump vec2 normal=a_pos_normal-2.0*pos;normal.y=normal.y*2.0-1.0;v_normal=normal;gapwidth=gapwidth/2.0;float halfwidth=width/2.0;offset=-1.0*offset;float inset=gapwidth+(gapwidth > 0.0 ? ANTIALIASING : 0.0);float outset=gapwidth+halfwidth*(gapwidth > 0.0 ? 2.0 : 1.0)+(halfwidth==0.0 ? 0.0 : ANTIALIASING);mediump vec2 dist=outset*a_extrude*scale;mediump float u=0.5*a_direction;mediump float t=1.0-abs(u);mediump vec2 offset2=offset*a_extrude*scale*normal.y*mat2(t,-u,u,t);float adjustedThickness=projectLineThickness(pos.y);vec4 projected_no_extrude=projectTile(pos+offset2/u_ratio*adjustedThickness+u_translation);vec4 projected_with_extrude=projectTile(pos+offset2/u_ratio*adjustedThickness+u_translation+dist/u_ratio*adjustedThickness);gl_Position=projected_with_extrude;\n#ifdef GLOBE\nv_depth=gl_Position.z/gl_Position.w;\n#endif\n#ifdef TERRAIN3D\nv_gamma_scale=1.0;\n#else\nfloat extrude_length_without_perspective=length(dist);float extrude_length_with_perspective=length((projected_with_extrude.xy-projected_no_extrude.xy)/projected_with_extrude.w*u_units_to_pixels);v_gamma_scale=extrude_length_without_perspective/extrude_length_with_perspective;\n#endif\nv_width2=vec2(outset,inset);}"), lineGradient: Dt("uniform lowp float u_device_pixel_ratio;uniform sampler2D u_image;in vec2 v_width2;in vec2 v_normal;in float v_gamma_scale;in highp vec2 v_uv;\n#ifdef GLOBE\nin float v_depth;\n#endif\n#pragma mapbox: define lowp float blur\n#pragma mapbox: define lowp float opacity\nvoid main() {\n#pragma mapbox: initialize lowp float blur\n#pragma mapbox: initialize lowp float opacity\nfloat dist=length(v_normal)*v_width2.s;float blur2=(blur+1.0/u_device_pixel_ratio)*v_gamma_scale;float alpha=clamp(min(dist-(v_width2.t-blur2),v_width2.s-dist)/blur2,0.0,1.0);vec4 color=texture(u_image,v_uv);fragColor=color*(alpha*opacity);\n#ifdef GLOBE\nif (v_depth > 1.0) {discard;}\n#endif\n#ifdef OVERDRAW_INSPECTOR\nfragColor=vec4(1.0);\n#endif\n}", "\n#define scale 0.015873016\nin vec2 a_pos_normal;in vec4 a_data;in float a_uv_x;in float a_split_index;uniform vec2 u_translation;uniform mediump float u_ratio;uniform lowp float u_device_pixel_ratio;uniform vec2 u_units_to_pixels;uniform float u_image_height;out vec2 v_normal;out vec2 v_width2;out float v_gamma_scale;out highp vec2 v_uv;\n#ifdef GLOBE\nout float v_depth;\n#endif\n#pragma mapbox: define lowp float blur\n#pragma mapbox: define lowp float opacity\n#pragma mapbox: define mediump float gapwidth\n#pragma mapbox: define lowp float offset\n#pragma mapbox: define mediump float width\nvoid main() {\n#pragma mapbox: initialize lowp float blur\n#pragma mapbox: initialize lowp float opacity\n#pragma mapbox: initialize mediump float gapwidth\n#pragma mapbox: initialize lowp float offset\n#pragma mapbox: initialize mediump float width\nfloat ANTIALIASING=1.0/u_device_pixel_ratio/2.0;vec2 a_extrude=a_data.xy-128.0;float a_direction=mod(a_data.z,4.0)-1.0;highp float texel_height=1.0/u_image_height;highp float half_texel_height=0.5*texel_height;v_uv=vec2(a_uv_x,a_split_index*texel_height-half_texel_height);vec2 pos=floor(a_pos_normal*0.5);mediump vec2 normal=a_pos_normal-2.0*pos;normal.y=normal.y*2.0-1.0;v_normal=normal;gapwidth=gapwidth/2.0;float halfwidth=width/2.0;offset=-1.0*offset;float inset=gapwidth+(gapwidth > 0.0 ? ANTIALIASING : 0.0);float outset=gapwidth+halfwidth*(gapwidth > 0.0 ? 2.0 : 1.0)+(halfwidth==0.0 ? 0.0 : ANTIALIASING);mediump vec2 dist=outset*a_extrude*scale;mediump float u=0.5*a_direction;mediump float t=1.0-abs(u);mediump vec2 offset2=offset*a_extrude*scale*normal.y*mat2(t,-u,u,t);float adjustedThickness=projectLineThickness(pos.y);vec4 projected_no_extrude=projectTile(pos+offset2/u_ratio*adjustedThickness+u_translation);vec4 projected_with_extrude=projectTile(pos+offset2/u_ratio*adjustedThickness+u_translation+dist/u_ratio*adjustedThickness);gl_Position=projected_with_extrude;\n#ifdef GLOBE\nv_depth=gl_Position.z/gl_Position.w;\n#endif\n#ifdef TERRAIN3D\nv_gamma_scale=1.0;\n#else\nfloat extrude_length_without_perspective=length(dist);float extrude_length_with_perspective=length((projected_with_extrude.xy-projected_no_extrude.xy)/projected_with_extrude.w*u_units_to_pixels);v_gamma_scale=extrude_length_without_perspective/extrude_length_with_perspective;\n#endif\nv_width2=vec2(outset,inset);}"), linePattern: Dt("#ifdef GL_ES\nprecision highp float;\n#endif\nuniform lowp float u_device_pixel_ratio;uniform vec2 u_texsize;uniform float u_fade;uniform mediump vec3 u_scale;uniform sampler2D u_image;in vec2 v_normal;in vec2 v_width2;in float v_linesofar;in float v_gamma_scale;in float v_width;\n#ifdef GLOBE\nin float v_depth;\n#endif\n#pragma mapbox: define lowp vec4 pattern_from\n#pragma mapbox: define lowp vec4 pattern_to\n#pragma mapbox: define lowp float pixel_ratio_from\n#pragma mapbox: define lowp float pixel_ratio_to\n#pragma mapbox: define lowp float blur\n#pragma mapbox: define lowp float opacity\nvoid main() {\n#pragma mapbox: initialize mediump vec4 pattern_from\n#pragma mapbox: initialize mediump vec4 pattern_to\n#pragma mapbox: initialize lowp float pixel_ratio_from\n#pragma mapbox: initialize lowp float pixel_ratio_to\n#pragma mapbox: initialize lowp float blur\n#pragma mapbox: initialize lowp float opacity\nvec2 pattern_tl_a=pattern_from.xy;vec2 pattern_br_a=pattern_from.zw;vec2 pattern_tl_b=pattern_to.xy;vec2 pattern_br_b=pattern_to.zw;float tileZoomRatio=u_scale.x;float fromScale=u_scale.y;float toScale=u_scale.z;vec2 display_size_a=(pattern_br_a-pattern_tl_a)/pixel_ratio_from;vec2 display_size_b=(pattern_br_b-pattern_tl_b)/pixel_ratio_to;vec2 pattern_size_a=vec2(display_size_a.x*fromScale/tileZoomRatio,display_size_a.y);vec2 pattern_size_b=vec2(display_size_b.x*toScale/tileZoomRatio,display_size_b.y);float aspect_a=display_size_a.y/v_width;float aspect_b=display_size_b.y/v_width;float dist=length(v_normal)*v_width2.s;float blur2=(blur+1.0/u_device_pixel_ratio)*v_gamma_scale;float alpha=clamp(min(dist-(v_width2.t-blur2),v_width2.s-dist)/blur2,0.0,1.0);float x_a=mod(v_linesofar/pattern_size_a.x*aspect_a,1.0);float x_b=mod(v_linesofar/pattern_size_b.x*aspect_b,1.0);float y=0.5*v_normal.y+0.5;vec2 texel_size=1.0/u_texsize;vec2 pos_a=mix(pattern_tl_a*texel_size-texel_size,pattern_br_a*texel_size+texel_size,vec2(x_a,y));vec2 pos_b=mix(pattern_tl_b*texel_size-texel_size,pattern_br_b*texel_size+texel_size,vec2(x_b,y));vec4 color=mix(texture(u_image,pos_a),texture(u_image,pos_b),u_fade);fragColor=color*alpha*opacity;\n#ifdef GLOBE\nif (v_depth > 1.0) {discard;}\n#endif\n#ifdef OVERDRAW_INSPECTOR\nfragColor=vec4(1.0);\n#endif\n}", "\n#define scale 0.015873016\n#define LINE_DISTANCE_SCALE 2.0\nin vec2 a_pos_normal;in vec4 a_data;uniform vec2 u_translation;uniform vec2 u_units_to_pixels;uniform mediump float u_ratio;uniform lowp float u_device_pixel_ratio;out vec2 v_normal;out vec2 v_width2;out float v_linesofar;out float v_gamma_scale;out float v_width;\n#ifdef GLOBE\nout float v_depth;\n#endif\n#pragma mapbox: define lowp float blur\n#pragma mapbox: define lowp float opacity\n#pragma mapbox: define lowp float offset\n#pragma mapbox: define mediump float gapwidth\n#pragma mapbox: define mediump float width\n#pragma mapbox: define lowp float floorwidth\n#pragma mapbox: define lowp vec4 pattern_from\n#pragma mapbox: define lowp vec4 pattern_to\n#pragma mapbox: define lowp float pixel_ratio_from\n#pragma mapbox: define lowp float pixel_ratio_to\nvoid main() {\n#pragma mapbox: initialize lowp float blur\n#pragma mapbox: initialize lowp float opacity\n#pragma mapbox: initialize lowp float offset\n#pragma mapbox: initialize mediump float gapwidth\n#pragma mapbox: initialize mediump float width\n#pragma mapbox: initialize lowp float floorwidth\n#pragma mapbox: initialize mediump vec4 pattern_from\n#pragma mapbox: initialize mediump vec4 pattern_to\n#pragma mapbox: initialize lowp float pixel_ratio_from\n#pragma mapbox: initialize lowp float pixel_ratio_to\nfloat ANTIALIASING=1.0/u_device_pixel_ratio/2.0;vec2 a_extrude=a_data.xy-128.0;float a_direction=mod(a_data.z,4.0)-1.0;float a_linesofar=(floor(a_data.z/4.0)+a_data.w*64.0)*LINE_DISTANCE_SCALE;vec2 pos=floor(a_pos_normal*0.5);mediump vec2 normal=a_pos_normal-2.0*pos;normal.y=normal.y*2.0-1.0;v_normal=normal;gapwidth=gapwidth/2.0;float halfwidth=width/2.0;offset=-1.0*offset;float inset=gapwidth+(gapwidth > 0.0 ? ANTIALIASING : 0.0);float outset=gapwidth+halfwidth*(gapwidth > 0.0 ? 2.0 : 1.0)+(halfwidth==0.0 ? 0.0 : ANTIALIASING);mediump vec2 dist=outset*a_extrude*scale;mediump float u=0.5*a_direction;mediump float t=1.0-abs(u);mediump vec2 offset2=offset*a_extrude*scale*normal.y*mat2(t,-u,u,t);float adjustedThickness=projectLineThickness(pos.y);vec4 projected_no_extrude=projectTile(pos+offset2/u_ratio*adjustedThickness+u_translation);vec4 projected_with_extrude=projectTile(pos+offset2/u_ratio*adjustedThickness+u_translation+dist/u_ratio*adjustedThickness);gl_Position=projected_with_extrude;\n#ifdef GLOBE\nv_depth=gl_Position.z/gl_Position.w;\n#endif\n#ifdef TERRAIN3D\nv_gamma_scale=1.0;\n#else\nfloat extrude_length_without_perspective=length(dist);float extrude_length_with_perspective=length((projected_with_extrude.xy-projected_no_extrude.xy)/projected_with_extrude.w*u_units_to_pixels);v_gamma_scale=extrude_length_without_perspective/extrude_length_with_perspective;\n#endif\nv_linesofar=a_linesofar;v_width2=vec2(outset,inset);v_width=floorwidth;}"), lineSDF: Dt("uniform lowp float u_device_pixel_ratio;uniform lowp float u_lineatlas_width;uniform sampler2D u_image;uniform float u_mix;in vec2 v_normal;in vec2 v_width2;in vec2 v_tex_a;in vec2 v_tex_b;in float v_gamma_scale;\n#ifdef GLOBE\nin float v_depth;\n#endif\n#pragma mapbox: define highp vec4 color\n#pragma mapbox: define lowp float blur\n#pragma mapbox: define lowp float opacity\n#pragma mapbox: define mediump float width\n#pragma mapbox: define lowp float floorwidth\n#pragma mapbox: define mediump vec4 dasharray_from\n#pragma mapbox: define mediump vec4 dasharray_to\nvoid main() {\n#pragma mapbox: initialize highp vec4 color\n#pragma mapbox: initialize lowp float blur\n#pragma mapbox: initialize lowp float opacity\n#pragma mapbox: initialize mediump float width\n#pragma mapbox: initialize lowp float floorwidth\n#pragma mapbox: initialize mediump vec4 dasharray_from\n#pragma mapbox: initialize mediump vec4 dasharray_to\nfloat dist=length(v_normal)*v_width2.s;float blur2=(blur+1.0/u_device_pixel_ratio)*v_gamma_scale;float alpha=clamp(min(dist-(v_width2.t-blur2),v_width2.s-dist)/blur2,0.0,1.0);float sdfdist_a=texture(u_image,v_tex_a).a;float sdfdist_b=texture(u_image,v_tex_b).a;float sdfdist=mix(sdfdist_a,sdfdist_b,u_mix);float sdfgamma=(u_lineatlas_width/256.0/u_device_pixel_ratio)/min(dasharray_from.w,dasharray_to.w);alpha*=smoothstep(0.5-sdfgamma/floorwidth,0.5+sdfgamma/floorwidth,sdfdist);fragColor=color*(alpha*opacity);\n#ifdef GLOBE\nif (v_depth > 1.0) {discard;}\n#endif\n#ifdef OVERDRAW_INSPECTOR\nfragColor=vec4(1.0);\n#endif\n}", "\n#define scale 0.015873016\n#define LINE_DISTANCE_SCALE 2.0\nin vec2 a_pos_normal;in vec4 a_data;uniform vec2 u_translation;uniform mediump float u_ratio;uniform lowp float u_device_pixel_ratio;uniform vec2 u_units_to_pixels;uniform float u_tileratio;uniform float u_crossfade_from;uniform float u_crossfade_to;uniform float u_lineatlas_height;out vec2 v_normal;out vec2 v_width2;out vec2 v_tex_a;out vec2 v_tex_b;out float v_gamma_scale;\n#ifdef GLOBE\nout float v_depth;\n#endif\n#pragma mapbox: define highp vec4 color\n#pragma mapbox: define lowp float blur\n#pragma mapbox: define lowp float opacity\n#pragma mapbox: define mediump float gapwidth\n#pragma mapbox: define lowp float offset\n#pragma mapbox: define mediump float width\n#pragma mapbox: define lowp float floorwidth\n#pragma mapbox: define mediump vec4 dasharray_from\n#pragma mapbox: define mediump vec4 dasharray_to\nvoid main() {\n#pragma mapbox: initialize highp vec4 color\n#pragma mapbox: initialize lowp float blur\n#pragma mapbox: initialize lowp float opacity\n#pragma mapbox: initialize mediump float gapwidth\n#pragma mapbox: initialize lowp float offset\n#pragma mapbox: initialize mediump float width\n#pragma mapbox: initialize lowp float floorwidth\n#pragma mapbox: initialize mediump vec4 dasharray_from\n#pragma mapbox: initialize mediump vec4 dasharray_to\nfloat ANTIALIASING=1.0/u_device_pixel_ratio/2.0;vec2 a_extrude=a_data.xy-128.0;float a_direction=mod(a_data.z,4.0)-1.0;float a_linesofar=(floor(a_data.z/4.0)+a_data.w*64.0)*LINE_DISTANCE_SCALE;vec2 pos=floor(a_pos_normal*0.5);mediump vec2 normal=a_pos_normal-2.0*pos;normal.y=normal.y*2.0-1.0;v_normal=normal;gapwidth=gapwidth/2.0;float halfwidth=width/2.0;offset=-1.0*offset;float inset=gapwidth+(gapwidth > 0.0 ? ANTIALIASING : 0.0);float outset=gapwidth+halfwidth*(gapwidth > 0.0 ? 2.0 : 1.0)+(halfwidth==0.0 ? 0.0 : ANTIALIASING);mediump vec2 dist=outset*a_extrude*scale;mediump float u=0.5*a_direction;mediump float t=1.0-abs(u);mediump vec2 offset2=offset*a_extrude*scale*normal.y*mat2(t,-u,u,t);float adjustedThickness=projectLineThickness(pos.y);vec4 projected_no_extrude=projectTile(pos+offset2/u_ratio*adjustedThickness+u_translation);vec4 projected_with_extrude=projectTile(pos+offset2/u_ratio*adjustedThickness+u_translation+dist/u_ratio*adjustedThickness);gl_Position=projected_with_extrude;\n#ifdef GLOBE\nv_depth=gl_Position.z/gl_Position.w;\n#endif\n#ifdef TERRAIN3D\nv_gamma_scale=1.0;\n#else\nfloat extrude_length_without_perspective=length(dist);float extrude_length_with_perspective=length((projected_with_extrude.xy-projected_no_extrude.xy)/projected_with_extrude.w*u_units_to_pixels);v_gamma_scale=extrude_length_without_perspective/extrude_length_with_perspective;\n#endif\nfloat u_patternscale_a_x=u_tileratio/dasharray_from.w/u_crossfade_from;float u_patternscale_a_y=-dasharray_from.z/2.0/u_lineatlas_height;float u_patternscale_b_x=u_tileratio/dasharray_to.w/u_crossfade_to;float u_patternscale_b_y=-dasharray_to.z/2.0/u_lineatlas_height;v_tex_a=vec2(a_linesofar*u_patternscale_a_x/floorwidth,normal.y*u_patternscale_a_y+(float(dasharray_from.y)+0.5)/u_lineatlas_height);v_tex_b=vec2(a_linesofar*u_patternscale_b_x/floorwidth,normal.y*u_patternscale_b_y+(float(dasharray_to.y)+0.5)/u_lineatlas_height);v_width2=vec2(outset,inset);}"), lineGradientSDF: Dt("uniform lowp float u_device_pixel_ratio;uniform sampler2D u_image;uniform sampler2D u_image_dash;uniform float u_mix;uniform lowp float u_lineatlas_width;in vec2 v_normal;in vec2 v_width2;in vec2 v_tex_a;in vec2 v_tex_b;in float v_gamma_scale;in highp vec2 v_uv;\n#ifdef GLOBE\nin float v_depth;\n#endif\n#pragma mapbox: define lowp float blur\n#pragma mapbox: define lowp float opacity\n#pragma mapbox: define mediump float width\n#pragma mapbox: define lowp float floorwidth\n#pragma mapbox: define mediump vec4 dasharray_from\n#pragma mapbox: define mediump vec4 dasharray_to\nvoid main() {\n#pragma mapbox: initialize lowp float blur\n#pragma mapbox: initialize lowp float opacity\n#pragma mapbox: initialize mediump float width\n#pragma mapbox: initialize lowp float floorwidth\n#pragma mapbox: initialize mediump vec4 dasharray_from\n#pragma mapbox: initialize mediump vec4 dasharray_to\nfloat dist=length(v_normal)*v_width2.s;float blur2=(blur+1.0/u_device_pixel_ratio)*v_gamma_scale;float alpha=clamp(min(dist-(v_width2.t-blur2),v_width2.s-dist)/blur2,0.0,1.0);vec4 color=texture(u_image,v_uv);float sdfdist_a=texture(u_image_dash,v_tex_a).a;float sdfdist_b=texture(u_image_dash,v_tex_b).a;float sdfdist=mix(sdfdist_a,sdfdist_b,u_mix);float sdfgamma=(u_lineatlas_width/256.0)/min(dasharray_from.w,dasharray_to.w);float dash_alpha=smoothstep(0.5-sdfgamma/floorwidth,0.5+sdfgamma/floorwidth,sdfdist);fragColor=color*(alpha*dash_alpha*opacity);\n#ifdef GLOBE\nif (v_depth > 1.0) {discard;}\n#endif\n#ifdef OVERDRAW_INSPECTOR\nfragColor=vec4(1.0);\n#endif\n}", "\n#define scale 0.015873016\n#define LINE_DISTANCE_SCALE 2.0\nin vec2 a_pos_normal;in vec4 a_data;in float a_uv_x;in float a_split_index;uniform vec2 u_translation;uniform mediump float u_ratio;uniform lowp float u_device_pixel_ratio;uniform vec2 u_units_to_pixels;uniform float u_image_height;uniform float u_tileratio;uniform float u_crossfade_from;uniform float u_crossfade_to;uniform float u_lineatlas_height;out vec2 v_normal;out vec2 v_width2;out float v_gamma_scale;out highp vec2 v_uv;out vec2 v_tex_a;out vec2 v_tex_b;\n#ifdef GLOBE\nout float v_depth;\n#endif\n#pragma mapbox: define lowp float blur\n#pragma mapbox: define lowp float opacity\n#pragma mapbox: define mediump float gapwidth\n#pragma mapbox: define lowp float offset\n#pragma mapbox: define mediump float width\n#pragma mapbox: define lowp float floorwidth\n#pragma mapbox: define mediump vec4 dasharray_from\n#pragma mapbox: define mediump vec4 dasharray_to\nvoid main() {\n#pragma mapbox: initialize lowp float blur\n#pragma mapbox: initialize lowp float opacity\n#pragma mapbox: initialize mediump float gapwidth\n#pragma mapbox: initialize lowp float offset\n#pragma mapbox: initialize mediump float width\n#pragma mapbox: initialize lowp float floorwidth\n#pragma mapbox: initialize mediump vec4 dasharray_from\n#pragma mapbox: initialize mediump vec4 dasharray_to\nfloat ANTIALIASING=1.0/u_device_pixel_ratio/2.0;vec2 a_extrude=a_data.xy-128.0;float a_direction=mod(a_data.z,4.0)-1.0;float a_linesofar=(floor(a_data.z/4.0)+a_data.w*64.0)*LINE_DISTANCE_SCALE;float texel_height=1.0/u_image_height;float half_texel_height=0.5*texel_height;v_uv=vec2(a_uv_x,a_split_index*texel_height-half_texel_height);vec2 pos=floor(a_pos_normal*0.5);mediump vec2 normal=a_pos_normal-2.0*pos;normal.y=normal.y*2.0-1.0;v_normal=normal;gapwidth=gapwidth/2.0;float halfwidth=width/2.0;offset=-1.0*offset;float inset=gapwidth+(gapwidth > 0.0 ? ANTIALIASING : 0.0);float outset=gapwidth+halfwidth*(gapwidth > 0.0 ? 2.0 : 1.0)+(halfwidth==0.0 ? 0.0 : ANTIALIASING);mediump vec2 dist=outset*a_extrude*scale;mediump float u=0.5*a_direction;mediump float t=1.0-abs(u);mediump vec2 offset2=offset*a_extrude*scale*normal.y*mat2(t,-u,u,t);float adjustedThickness=projectLineThickness(pos.y);vec4 projected_no_extrude=projectTile(pos+offset2/u_ratio*adjustedThickness+u_translation);vec4 projected_with_extrude=projectTile(pos+offset2/u_ratio*adjustedThickness+u_translation+dist/u_ratio*adjustedThickness);gl_Position=projected_with_extrude;\n#ifdef GLOBE\nv_depth=gl_Position.z/gl_Position.w;\n#endif\n#ifdef TERRAIN3D\nv_gamma_scale=1.0;\n#else\nfloat extrude_length_without_perspective=length(dist);float extrude_length_with_perspective=length((projected_with_extrude.xy-projected_no_extrude.xy)/projected_with_extrude.w*u_units_to_pixels);v_gamma_scale=extrude_length_without_perspective/extrude_length_with_perspective;\n#endif\nfloat u_patternscale_a_x=u_tileratio/dasharray_from.w/u_crossfade_from;float u_patternscale_a_y=-dasharray_from.z/2.0/u_lineatlas_height;float u_patternscale_b_x=u_tileratio/dasharray_to.w/u_crossfade_to;float u_patternscale_b_y=-dasharray_to.z/2.0/u_lineatlas_height;v_tex_a=vec2(a_linesofar*u_patternscale_a_x/floorwidth,normal.y*u_patternscale_a_y+(float(dasharray_from.y)+0.5)/u_lineatlas_height);v_tex_b=vec2(a_linesofar*u_patternscale_b_x/floorwidth,normal.y*u_patternscale_b_y+(float(dasharray_to.y)+0.5)/u_lineatlas_height);v_width2=vec2(outset,inset);}"), raster: Dt("uniform float u_fade_t;uniform float u_opacity;uniform sampler2D u_image0;uniform sampler2D u_image1;in vec2 v_pos0;in vec2 v_pos1;uniform float u_brightness_low;uniform float u_brightness_high;uniform float u_saturation_factor;uniform float u_contrast_factor;uniform vec3 u_spin_weights;void main() {vec4 color0=texture(u_image0,v_pos0);vec4 color1=texture(u_image1,v_pos1);if (color0.a > 0.0) {color0.rgb=color0.rgb/color0.a;}if (color1.a > 0.0) {color1.rgb=color1.rgb/color1.a;}vec4 color=mix(color0,color1,u_fade_t);color.a*=u_opacity;vec3 rgb=color.rgb;rgb=vec3(dot(rgb,u_spin_weights.xyz),dot(rgb,u_spin_weights.zxy),dot(rgb,u_spin_weights.yzx));float average=(color.r+color.g+color.b)/3.0;rgb+=(average-rgb)*u_saturation_factor;rgb=(rgb-0.5)*u_contrast_factor+0.5;vec3 u_high_vec=vec3(u_brightness_low,u_brightness_low,u_brightness_low);vec3 u_low_vec=vec3(u_brightness_high,u_brightness_high,u_brightness_high);fragColor=vec4(mix(u_high_vec,u_low_vec,rgb)*color.a,color.a);\n#ifdef OVERDRAW_INSPECTOR\nfragColor=vec4(1.0);\n#endif\n}", "uniform vec2 u_tl_parent;uniform float u_scale_parent;uniform float u_buffer_scale;uniform vec4 u_coords_top;uniform vec4 u_coords_bottom;in vec2 a_pos;out vec2 v_pos0;out vec2 v_pos1;void main() {vec2 fractionalPos=a_pos/8192.0;vec2 position=mix(mix(u_coords_top.xy,u_coords_top.zw,fractionalPos.x),mix(u_coords_bottom.xy,u_coords_bottom.zw,fractionalPos.x),fractionalPos.y);gl_Position=projectTile(position,position);v_pos0=((fractionalPos-0.5)/u_buffer_scale)+0.5;\n#ifdef GLOBE\nif (a_pos.y <-32767.5) {v_pos0.y=0.0;}if (a_pos.y > 32766.5) {v_pos0.y=1.0;}\n#endif\nv_pos1=(v_pos0*u_scale_parent)+u_tl_parent;}"), symbolIcon: Dt("uniform sampler2D u_texture;in vec2 v_tex;in float v_fade_opacity;\n#pragma mapbox: define lowp float opacity\nvoid main() {\n#pragma mapbox: initialize lowp float opacity\nlowp float alpha=opacity*v_fade_opacity;fragColor=texture(u_texture,v_tex)*alpha;\n#ifdef OVERDRAW_INSPECTOR\nfragColor=vec4(1.0);\n#endif\n}", "in vec4 a_pos_offset;in vec4 a_data;in vec4 a_pixeloffset;in vec3 a_projected_pos;in float a_fade_opacity;uniform bool u_is_size_zoom_constant;uniform bool u_is_size_feature_constant;uniform highp float u_size_t;uniform highp float u_size;uniform highp float u_camera_to_center_distance;uniform highp float u_pitch;uniform bool u_rotate_symbol;uniform highp float u_aspect_ratio;uniform float u_fade_change;uniform mat4 u_label_plane_matrix;uniform mat4 u_coord_matrix;uniform bool u_is_text;uniform bool u_pitch_with_map;uniform vec2 u_texsize;uniform bool u_is_along_line;uniform bool u_is_variable_anchor;uniform vec2 u_translation;uniform float u_pitched_scale;out vec2 v_tex;out float v_fade_opacity;\n#pragma mapbox: define lowp float opacity\nvoid main() {\n#pragma mapbox: initialize lowp float opacity\nvec2 a_pos=a_pos_offset.xy;vec2 a_offset=a_pos_offset.zw;vec2 a_tex=a_data.xy;vec2 a_size=a_data.zw;float a_size_min=floor(a_size[0]*0.5);vec2 a_pxoffset=a_pixeloffset.xy;vec2 a_minFontScale=a_pixeloffset.zw/256.0;float ele=get_elevation(a_pos);highp float segment_angle=-a_projected_pos[2];float size;if (!u_is_size_zoom_constant && !u_is_size_feature_constant) {size=mix(a_size_min,a_size[1],u_size_t)/128.0;} else if (u_is_size_zoom_constant && !u_is_size_feature_constant) {size=a_size_min/128.0;} else {size=u_size;}vec2 translated_a_pos=a_pos+u_translation;vec4 projectedPoint=projectTileWithElevation(translated_a_pos,ele);highp float camera_to_anchor_distance=projectedPoint.w;highp float distance_ratio=u_pitch_with_map ?\ncamera_to_anchor_distance/u_camera_to_center_distance :\nu_camera_to_center_distance/camera_to_anchor_distance;highp float perspective_ratio=clamp(0.5+0.5*distance_ratio,0.0,4.0);size*=perspective_ratio;float fontScale=u_is_text ? size/24.0 : size;highp float symbol_rotation=0.0;if (u_rotate_symbol) {vec4 offsetProjectedPoint=projectTileWithElevation(translated_a_pos+vec2(1,0),ele);vec2 a=projectedPoint.xy/projectedPoint.w;vec2 b=offsetProjectedPoint.xy/offsetProjectedPoint.w;symbol_rotation=atan((b.y-a.y)/u_aspect_ratio,b.x-a.x);}highp float angle_sin=sin(segment_angle+symbol_rotation);highp float angle_cos=cos(segment_angle+symbol_rotation);mat2 rotation_matrix=mat2(angle_cos,-1.0*angle_sin,angle_sin,angle_cos);vec4 projected_pos;if (u_is_along_line || u_is_variable_anchor) {projected_pos=vec4(a_projected_pos.xy,ele,1.0);} else if (u_pitch_with_map) {projected_pos=u_label_plane_matrix*vec4(a_projected_pos.xy+u_translation,ele,1.0);} else {projected_pos=u_label_plane_matrix*projectTileWithElevation(a_projected_pos.xy+u_translation,ele);}float z=float(u_pitch_with_map)*projected_pos.z/projected_pos.w;float projectionScaling=1.0;\n#ifdef GLOBE\nif(u_pitch_with_map) {float anchor_pos_tile_y=(u_coord_matrix*vec4(projected_pos.xy/projected_pos.w,z,1.0)).y;projectionScaling=mix(projectionScaling,1.0/circumferenceRatioAtTileY(anchor_pos_tile_y)*u_pitched_scale,u_projection_transition);}\n#endif\nvec4 finalPos=u_coord_matrix*vec4(projected_pos.xy/projected_pos.w+rotation_matrix*(a_offset/32.0*max(a_minFontScale,fontScale)+a_pxoffset/16.0)*projectionScaling,z,1.0);if(u_pitch_with_map) {finalPos=projectTileWithElevation(finalPos.xy,finalPos.z);}gl_Position=finalPos;v_tex=a_tex/u_texsize;vec2 fade_opacity=unpack_opacity(a_fade_opacity);float fade_change=fade_opacity[1] > 0.5 ? u_fade_change :-u_fade_change;float visibility=calculate_visibility(projectedPoint);v_fade_opacity=max(0.0,min(visibility,fade_opacity[0]+fade_change));}"), symbolSDF: Dt("#define SDF_PX 8.0\nuniform bool u_is_halo;uniform sampler2D u_texture;uniform highp float u_gamma_scale;uniform lowp float u_device_pixel_ratio;uniform bool u_is_text;in vec2 v_data0;in vec3 v_data1;\n#pragma mapbox: define highp vec4 fill_color\n#pragma mapbox: define highp vec4 halo_color\n#pragma mapbox: define lowp float opacity\n#pragma mapbox: define lowp float halo_width\n#pragma mapbox: define lowp float halo_blur\nvoid main() {\n#pragma mapbox: initialize highp vec4 fill_color\n#pragma mapbox: initialize highp vec4 halo_color\n#pragma mapbox: initialize lowp float opacity\n#pragma mapbox: initialize lowp float halo_width\n#pragma mapbox: initialize lowp float halo_blur\nfloat EDGE_GAMMA=0.105/u_device_pixel_ratio;vec2 tex=v_data0.xy;float gamma_scale=v_data1.x;float size=v_data1.y;float fade_opacity=v_data1[2];float fontScale=u_is_text ? size/24.0 : size;lowp vec4 color=fill_color;highp float gamma=EDGE_GAMMA/(fontScale*u_gamma_scale);lowp float inner_edge=(256.0-64.0)/256.0;if (u_is_halo) {color=halo_color;gamma=(halo_blur*1.19/SDF_PX+EDGE_GAMMA)/(fontScale*u_gamma_scale);inner_edge=inner_edge+gamma*gamma_scale;}lowp float dist=texture(u_texture,tex).a;highp float gamma_scaled=gamma*gamma_scale;highp float alpha=smoothstep(inner_edge-gamma_scaled,inner_edge+gamma_scaled,dist);if (u_is_halo) {lowp float halo_edge=(6.0-halo_width/fontScale)/SDF_PX;alpha=min(smoothstep(halo_edge-gamma_scaled,halo_edge+gamma_scaled,dist),1.0-alpha);}fragColor=color*(alpha*opacity*fade_opacity);\n#ifdef OVERDRAW_INSPECTOR\nfragColor=vec4(1.0);\n#endif\n}", "in vec4 a_pos_offset;in vec4 a_data;in vec4 a_pixeloffset;in vec3 a_projected_pos;in float a_fade_opacity;uniform bool u_is_size_zoom_constant;uniform bool u_is_size_feature_constant;uniform highp float u_size_t;uniform highp float u_size;uniform mat4 u_label_plane_matrix;uniform mat4 u_coord_matrix;uniform bool u_is_text;uniform bool u_pitch_with_map;uniform bool u_is_along_line;uniform bool u_is_variable_anchor;uniform highp float u_pitch;uniform bool u_rotate_symbol;uniform highp float u_aspect_ratio;uniform highp float u_camera_to_center_distance;uniform float u_fade_change;uniform vec2 u_texsize;uniform vec2 u_translation;uniform float u_pitched_scale;out vec2 v_data0;out vec3 v_data1;\n#pragma mapbox: define highp vec4 fill_color\n#pragma mapbox: define highp vec4 halo_color\n#pragma mapbox: define lowp float opacity\n#pragma mapbox: define lowp float halo_width\n#pragma mapbox: define lowp float halo_blur\nvoid main() {\n#pragma mapbox: initialize highp vec4 fill_color\n#pragma mapbox: initialize highp vec4 halo_color\n#pragma mapbox: initialize lowp float opacity\n#pragma mapbox: initialize lowp float halo_width\n#pragma mapbox: initialize lowp float halo_blur\nvec2 a_pos=a_pos_offset.xy;vec2 a_offset=a_pos_offset.zw;vec2 a_tex=a_data.xy;vec2 a_size=a_data.zw;float a_size_min=floor(a_size[0]*0.5);vec2 a_pxoffset=a_pixeloffset.xy/16.0;vec2 a_minFontScale=a_pixeloffset.zw/256.0;float ele=get_elevation(a_pos);highp float segment_angle=-a_projected_pos[2];float size;if (!u_is_size_zoom_constant && !u_is_size_feature_constant) {size=mix(a_size_min,a_size[1],u_size_t)/128.0;} else if (u_is_size_zoom_constant && !u_is_size_feature_constant) {size=a_size_min/128.0;} else {size=u_size;}vec2 translated_a_pos=a_pos+u_translation;vec4 projectedPoint=projectTileWithElevation(translated_a_pos,ele);highp float camera_to_anchor_distance=projectedPoint.w;highp float distance_ratio=u_pitch_with_map ?\ncamera_to_anchor_distance/u_camera_to_center_distance :\nu_camera_to_center_distance/camera_to_anchor_distance;highp float perspective_ratio=clamp(0.5+0.5*distance_ratio,0.0,4.0);size*=perspective_ratio;float fontScale=u_is_text ? size/24.0 : size;highp float symbol_rotation=0.0;if (u_rotate_symbol) {vec4 offsetProjectedPoint=projectTileWithElevation(translated_a_pos+vec2(1,0),ele);vec2 a=projectedPoint.xy/projectedPoint.w;vec2 b=offsetProjectedPoint.xy/offsetProjectedPoint.w;symbol_rotation=atan((b.y-a.y)/u_aspect_ratio,b.x-a.x);}highp float angle_sin=sin(segment_angle+symbol_rotation);highp float angle_cos=cos(segment_angle+symbol_rotation);mat2 rotation_matrix=mat2(angle_cos,-1.0*angle_sin,angle_sin,angle_cos);vec4 projected_pos;if (u_is_along_line || u_is_variable_anchor) {projected_pos=vec4(a_projected_pos.xy,ele,1.0);} else if (u_pitch_with_map) {projected_pos=u_label_plane_matrix*vec4(a_projected_pos.xy+u_translation,ele,1.0);} else {projected_pos=u_label_plane_matrix*projectTileWithElevation(a_projected_pos.xy+u_translation,ele);}float z=float(u_pitch_with_map)*projected_pos.z/projected_pos.w;float projectionScaling=1.0;\n#ifdef GLOBE\nif(u_pitch_with_map) {float anchor_pos_tile_y=(u_coord_matrix*vec4(projected_pos.xy/projected_pos.w,z,1.0)).y;projectionScaling=mix(projectionScaling,1.0/circumferenceRatioAtTileY(anchor_pos_tile_y)*u_pitched_scale,u_projection_transition);}\n#endif\nvec4 finalPos=u_coord_matrix*vec4(projected_pos.xy/projected_pos.w+rotation_matrix*(a_offset/32.0*max(a_minFontScale,fontScale)+a_pxoffset)*projectionScaling,z,1.0);if(u_pitch_with_map) {finalPos=projectTileWithElevation(finalPos.xy,finalPos.z);}float gamma_scale=finalPos.w;gl_Position=finalPos;vec2 fade_opacity=unpack_opacity(a_fade_opacity);float visibility=calculate_visibility(projectedPoint);float fade_change=fade_opacity[1] > 0.5 ? u_fade_change :-u_fade_change;float interpolated_fade_opacity=max(0.0,min(visibility,fade_opacity[0]+fade_change));v_data0=a_tex/u_texsize;v_data1=vec3(gamma_scale,size,interpolated_fade_opacity);}"), symbolTextAndIcon: Dt("#define SDF_PX 8.0\n#define SDF 1.0\n#define ICON 0.0\nuniform bool u_is_halo;uniform sampler2D u_texture;uniform sampler2D u_texture_icon;uniform highp float u_gamma_scale;uniform lowp float u_device_pixel_ratio;in vec4 v_data0;in vec4 v_data1;\n#pragma mapbox: define highp vec4 fill_color\n#pragma mapbox: define highp vec4 halo_color\n#pragma mapbox: define lowp float opacity\n#pragma mapbox: define lowp float halo_width\n#pragma mapbox: define lowp float halo_blur\nvoid main() {\n#pragma mapbox: initialize highp vec4 fill_color\n#pragma mapbox: initialize highp vec4 halo_color\n#pragma mapbox: initialize lowp float opacity\n#pragma mapbox: initialize lowp float halo_width\n#pragma mapbox: initialize lowp float halo_blur\nfloat fade_opacity=v_data1[2];if (v_data1.w==ICON) {vec2 tex_icon=v_data0.zw;lowp float alpha=opacity*fade_opacity;fragColor=texture(u_texture_icon,tex_icon)*alpha;\n#ifdef OVERDRAW_INSPECTOR\nfragColor=vec4(1.0);\n#endif\nreturn;}vec2 tex=v_data0.xy;float EDGE_GAMMA=0.105/u_device_pixel_ratio;float gamma_scale=v_data1.x;float size=v_data1.y;float fontScale=size/24.0;lowp vec4 color=fill_color;highp float gamma=EDGE_GAMMA/(fontScale*u_gamma_scale);lowp float buff=(256.0-64.0)/256.0;if (u_is_halo) {color=halo_color;gamma=(halo_blur*1.19/SDF_PX+EDGE_GAMMA)/(fontScale*u_gamma_scale);buff=(6.0-halo_width/fontScale)/SDF_PX;}lowp float dist=texture(u_texture,tex).a;highp float gamma_scaled=gamma*gamma_scale;highp float alpha=smoothstep(buff-gamma_scaled,buff+gamma_scaled,dist);fragColor=color*(alpha*opacity*fade_opacity);\n#ifdef OVERDRAW_INSPECTOR\nfragColor=vec4(1.0);\n#endif\n}", "in vec4 a_pos_offset;in vec4 a_data;in vec3 a_projected_pos;in float a_fade_opacity;uniform bool u_is_size_zoom_constant;uniform bool u_is_size_feature_constant;uniform highp float u_size_t;uniform highp float u_size;uniform mat4 u_label_plane_matrix;uniform mat4 u_coord_matrix;uniform bool u_is_text;uniform bool u_pitch_with_map;uniform highp float u_pitch;uniform bool u_rotate_symbol;uniform highp float u_aspect_ratio;uniform highp float u_camera_to_center_distance;uniform float u_fade_change;uniform vec2 u_texsize;uniform vec2 u_texsize_icon;uniform bool u_is_along_line;uniform bool u_is_variable_anchor;uniform vec2 u_translation;uniform float u_pitched_scale;out vec4 v_data0;out vec4 v_data1;\n#pragma mapbox: define highp vec4 fill_color\n#pragma mapbox: define highp vec4 halo_color\n#pragma mapbox: define lowp float opacity\n#pragma mapbox: define lowp float halo_width\n#pragma mapbox: define lowp float halo_blur\nvoid main() {\n#pragma mapbox: initialize highp vec4 fill_color\n#pragma mapbox: initialize highp vec4 halo_color\n#pragma mapbox: initialize lowp float opacity\n#pragma mapbox: initialize lowp float halo_width\n#pragma mapbox: initialize lowp float halo_blur\nvec2 a_pos=a_pos_offset.xy;vec2 a_offset=a_pos_offset.zw;vec2 a_tex=a_data.xy;vec2 a_size=a_data.zw;float a_size_min=floor(a_size[0]*0.5);float is_sdf=a_size[0]-2.0*a_size_min;float ele=get_elevation(a_pos);highp float segment_angle=-a_projected_pos[2];float size;if (!u_is_size_zoom_constant && !u_is_size_feature_constant) {size=mix(a_size_min,a_size[1],u_size_t)/128.0;} else if (u_is_size_zoom_constant && !u_is_size_feature_constant) {size=a_size_min/128.0;} else {size=u_size;}vec2 translated_a_pos=a_pos+u_translation;vec4 projectedPoint=projectTileWithElevation(translated_a_pos,ele);highp float camera_to_anchor_distance=projectedPoint.w;highp float distance_ratio=u_pitch_with_map ?\ncamera_to_anchor_distance/u_camera_to_center_distance :\nu_camera_to_center_distance/camera_to_anchor_distance;highp float perspective_ratio=clamp(0.5+0.5*distance_ratio,0.0,4.0);size*=perspective_ratio;float fontScale=size/24.0;highp float symbol_rotation=0.0;if (u_rotate_symbol) {vec4 offsetProjectedPoint=projectTileWithElevation(translated_a_pos+vec2(1,0),ele);vec2 a=projectedPoint.xy/projectedPoint.w;vec2 b=offsetProjectedPoint.xy/offsetProjectedPoint.w;symbol_rotation=atan((b.y-a.y)/u_aspect_ratio,b.x-a.x);}highp float angle_sin=sin(segment_angle+symbol_rotation);highp float angle_cos=cos(segment_angle+symbol_rotation);mat2 rotation_matrix=mat2(angle_cos,-1.0*angle_sin,angle_sin,angle_cos);vec4 projected_pos;if (u_is_along_line || u_is_variable_anchor) {projected_pos=vec4(a_projected_pos.xy,ele,1.0);} else if (u_pitch_with_map) {projected_pos=u_label_plane_matrix*vec4(a_projected_pos.xy+u_translation,ele,1.0);} else {projected_pos=u_label_plane_matrix*projectTileWithElevation(a_projected_pos.xy+u_translation,ele);}float z=float(u_pitch_with_map)*projected_pos.z/projected_pos.w;float projectionScaling=1.0;\n#ifdef GLOBE\nif(u_pitch_with_map && !u_is_along_line) {float anchor_pos_tile_y=(u_coord_matrix*vec4(projected_pos.xy/projected_pos.w,z,1.0)).y;projectionScaling=mix(projectionScaling,1.0/circumferenceRatioAtTileY(anchor_pos_tile_y)*u_pitched_scale,u_projection_transition);}\n#endif\nvec4 finalPos=u_coord_matrix*vec4(projected_pos.xy/projected_pos.w+rotation_matrix*(a_offset/32.0*fontScale)*projectionScaling,z,1.0);if(u_pitch_with_map) {finalPos=projectTileWithElevation(finalPos.xy,finalPos.z);}float gamma_scale=finalPos.w;gl_Position=finalPos;vec2 fade_opacity=unpack_opacity(a_fade_opacity);float visibility=calculate_visibility(projectedPoint);float fade_change=fade_opacity[1] > 0.5 ? u_fade_change :-u_fade_change;float interpolated_fade_opacity=max(0.0,min(visibility,fade_opacity[0]+fade_change));v_data0.xy=a_tex/u_texsize;v_data0.zw=a_tex/u_texsize_icon;v_data1=vec4(gamma_scale,size,interpolated_fade_opacity,is_sdf);}"), terrain: Dt("uniform sampler2D u_texture;uniform vec4 u_fog_color;uniform vec4 u_horizon_color;uniform float u_fog_ground_blend;uniform float u_fog_ground_blend_opacity;uniform float u_horizon_fog_blend;uniform bool u_is_globe_mode;in vec2 v_texture_pos;in float v_fog_depth;const float gamma=2.2;vec4 gammaToLinear(vec4 color) {return pow(color,vec4(gamma));}vec4 linearToGamma(vec4 color) {return pow(color,vec4(1.0/gamma));}void main() {vec4 surface_color=texture(u_texture,vec2(v_texture_pos.x,1.0-v_texture_pos.y));if (!u_is_globe_mode && v_fog_depth > u_fog_ground_blend) {vec4 surface_color_linear=gammaToLinear(surface_color);float blend_color=smoothstep(0.0,1.0,max((v_fog_depth-u_horizon_fog_blend)/(1.0-u_horizon_fog_blend),0.0));vec4 fog_horizon_color_linear=mix(gammaToLinear(u_fog_color),gammaToLinear(u_horizon_color),blend_color);float factor_fog=max(v_fog_depth-u_fog_ground_blend,0.0)/(1.0-u_fog_ground_blend);fragColor=linearToGamma(mix(surface_color_linear,fog_horizon_color_linear,pow(factor_fog,2.0)*u_fog_ground_blend_opacity));} else {fragColor=surface_color;}}", "in vec3 a_pos3d;uniform mat4 u_fog_matrix;uniform float u_ele_delta;out vec2 v_texture_pos;out float v_fog_depth;void main() {float ele=get_elevation(a_pos3d.xy);float ele_delta=a_pos3d.z==1.0 ? u_ele_delta : 0.0;v_texture_pos=a_pos3d.xy/8192.0;gl_Position=projectTileFor3D(a_pos3d.xy,get_elevation(a_pos3d.xy)-ele_delta);vec4 pos=u_fog_matrix*vec4(a_pos3d.xy,ele,1.0);v_fog_depth=pos.z/pos.w*0.5+0.5;}"), terrainDepth: Dt("in float v_depth;const highp vec4 bitSh=vec4(256.*256.*256.,256.*256.,256.,1.);const highp vec4 bitMsk=vec4(0.,vec3(1./256.0));highp vec4 pack(highp float value) {highp vec4 comp=fract(value*bitSh);comp-=comp.xxyz*bitMsk;return comp;}void main() {fragColor=pack(v_depth);}", "in vec3 a_pos3d;uniform float u_ele_delta;out float v_depth;void main() {float ele=get_elevation(a_pos3d.xy);float ele_delta=a_pos3d.z==1.0 ? u_ele_delta : 0.0;gl_Position=projectTileFor3D(a_pos3d.xy,ele-ele_delta);v_depth=gl_Position.z/gl_Position.w;}"), terrainCoords: Dt("precision mediump float;uniform sampler2D u_texture;uniform float u_terrain_coords_id;in vec2 v_texture_pos;void main() {vec4 rgba=texture(u_texture,v_texture_pos);fragColor=vec4(rgba.r,rgba.g,rgba.b,u_terrain_coords_id);}", "in vec3 a_pos3d;uniform float u_ele_delta;out vec2 v_texture_pos;void main() {float ele=get_elevation(a_pos3d.xy);float ele_delta=a_pos3d.z==1.0 ? u_ele_delta : 0.0;v_texture_pos=a_pos3d.xy/8192.0;gl_Position=projectTileFor3D(a_pos3d.xy,ele-ele_delta);}"), projectionErrorMeasurement: Dt("in vec4 v_output_error_encoded;void main() {fragColor=v_output_error_encoded;}", "in vec2 a_pos;uniform highp float u_input;uniform highp float u_output_expected;out vec4 v_output_error_encoded;void main() {float real_output=2.0*atan(exp(PI-(u_input*PI*2.0)))-PI*0.5;float error=real_output-u_output_expected;float abs_error=abs(error)*128.0;v_output_error_encoded.x=min(floor(abs_error*256.0),255.0)/255.0;abs_error-=v_output_error_encoded.x;v_output_error_encoded.y=min(floor(abs_error*65536.0),255.0)/255.0;abs_error-=v_output_error_encoded.x/255.0;v_output_error_encoded.z=min(floor(abs_error*16777216.0),255.0)/255.0;v_output_error_encoded.w=error >=0.0 ? 1.0 : 0.0;gl_Position=vec4(a_pos,0.0,1.0);}"), atmosphere: Dt("#ifdef GL_ES\nprecision highp float;\n#endif\nin vec3 view_direction;uniform vec3 u_sun_pos;uniform vec3 u_globe_position;uniform float u_globe_radius;uniform float u_atmosphere_blend;/**Shader use from https:*Made some change to adapt to MapLibre Globe geometry*/const float PI=3.141592653589793;const int iSteps=5;const int jSteps=3;/*radius of the planet*/const float EARTH_RADIUS=6371e3;/*radius of the atmosphere*/const float ATMOS_RADIUS=6471e3;vec2 rsi(vec3 r0,vec3 rd,float sr) {float a=dot(rd,rd);float b=2.0*dot(rd,r0);float c=dot(r0,r0)-(sr*sr);float d=(b*b)-4.0*a*c;if (d < 0.0) return vec2(1e5,-1e5);return vec2((-b-sqrt(d))/(2.0*a),(-b+sqrt(d))/(2.0*a));}vec4 atmosphere(vec3 r,vec3 r0,vec3 pSun,float iSun,float rPlanet,float rAtmos,vec3 kRlh,float kMie,float shRlh,float shMie,float g) {pSun=normalize(pSun);r=normalize(r);vec2 p=rsi(r0,r,rAtmos);if (p.x > p.y) {return vec4(0.0,0.0,0.0,1.0);}if (p.x < 0.0) {p.x=0.0;}vec3 pos=r0+r*p.x;vec2 p2=rsi(r0,r,rPlanet);if (p2.x <=p2.y && p2.x > 0.0) {p.y=min(p.y,p2.x);}float iStepSize=(p.y-p.x)/float(iSteps);float iTime=p.x+iStepSize*0.5;vec3 totalRlh=vec3(0,0,0);vec3 totalMie=vec3(0,0,0);float iOdRlh=0.0;float iOdMie=0.0;float mu=dot(r,pSun);float mumu=mu*mu;float gg=g*g;float pRlh=3.0/(16.0*PI)*(1.0+mumu);float pMie=3.0/(8.0*PI)*((1.0-gg)*(mumu+1.0))/(pow(1.0+gg-2.0*mu*g,1.5)*(2.0+gg));for (int i=0; i < iSteps; i++) {vec3 iPos=r0+r*iTime;float iHeight=length(iPos)-rPlanet;float odStepRlh=exp(-iHeight/shRlh)*iStepSize;float odStepMie=exp(-iHeight/shMie)*iStepSize;iOdRlh+=odStepRlh;iOdMie+=odStepMie;float jStepSize=rsi(iPos,pSun,rAtmos).y/float(jSteps);float jTime=jStepSize*0.5;float jOdRlh=0.0;float jOdMie=0.0;for (int j=0; j < jSteps; j++) {vec3 jPos=iPos+pSun*jTime;float jHeight=length(jPos)-rPlanet;jOdRlh+=exp(-jHeight/shRlh)*jStepSize;jOdMie+=exp(-jHeight/shMie)*jStepSize;jTime+=jStepSize;}vec3 attn=exp(-(kMie*(iOdMie+jOdMie)+kRlh*(iOdRlh+jOdRlh)));totalRlh+=odStepRlh*attn;totalMie+=odStepMie*attn;iTime+=iStepSize;}float opacity=exp(-(length(kRlh)*length(totalRlh)+kMie*length(totalMie)));vec3 color=iSun*(pRlh*kRlh*totalRlh+pMie*kMie*totalMie);return vec4(color,opacity);}void main() {vec3 scale_camera_pos=-u_globe_position*EARTH_RADIUS/u_globe_radius;vec4 color=atmosphere(normalize(view_direction),scale_camera_pos,u_sun_pos,22.0,EARTH_RADIUS,ATMOS_RADIUS,vec3(5.5e-6,13.0e-6,22.4e-6),21e-6,8e3,1.2e3,0.758\n);color.rgb=1.0-exp(-1.0*color.rgb);color=pow(color,vec4(1.0/2.2));fragColor=vec4(color.rgb,1.0-color.a)*u_atmosphere_blend;}", "in vec2 a_pos;uniform mat4 u_inv_proj_matrix;out vec3 view_direction;void main() {view_direction=(u_inv_proj_matrix*vec4(a_pos,0.0,1.0)).xyz;gl_Position=vec4(a_pos,0.0,1.0);}"), sky: Dt("uniform vec4 u_sky_color;uniform vec4 u_horizon_color;uniform vec2 u_horizon;uniform vec2 u_horizon_normal;uniform float u_sky_horizon_blend;uniform float u_sky_blend;void main() {float x=gl_FragCoord.x;float y=gl_FragCoord.y;float blend=(y-u_horizon.y)*u_horizon_normal.y+(x-u_horizon.x)*u_horizon_normal.x;if (blend > 0.0) {if (blend < u_sky_horizon_blend) {fragColor=mix(u_sky_color,u_horizon_color,pow(1.0-blend/u_sky_horizon_blend,2.0));} else {fragColor=u_sky_color;}}fragColor=mix(fragColor,vec4(vec3(0.0),0.0),u_sky_blend);}", "in vec2 a_pos;void main() {gl_Position=vec4(a_pos,1.0,1.0);}") };
+      function Dt(e3, t3) {
+        const i3 = /#pragma mapbox: ([\w]+) ([\w]+) ([\w]+) ([\w]+)/g, o3 = t3.match(/in ([\w]+) ([\w]+)/g), a3 = e3.match(/uniform ([\w]+) ([\w]+)([\s]*)([\w]*)/g), r3 = t3.match(/uniform ([\w]+) ([\w]+)([\s]*)([\w]*)/g), s3 = r3 ? r3.concat(a3) : a3, n3 = {};
+        return { fragmentSource: e3 = e3.replace(i3, (e4, t4, i4, o4, a4) => (n3[a4] = true, "define" === t4 ? `
+#ifndef HAS_UNIFORM_u_${a4}
+in ${i4} ${o4} ${a4};
+#else
+uniform ${i4} ${o4} u_${a4};
+#endif
+` : `
+#ifdef HAS_UNIFORM_u_${a4}
+    ${i4} ${o4} ${a4} = u_${a4};
+#endif
+`)), vertexSource: t3 = t3.replace(i3, (e4, t4, i4, o4, a4) => {
+          const r4 = "float" === o4 ? "vec2" : "vec4", s4 = a4.match(/color/) ? "color" : r4;
+          return n3[a4] ? "define" === t4 ? `
+#ifndef HAS_UNIFORM_u_${a4}
+uniform lowp float u_${a4}_t;
+in ${i4} ${r4} a_${a4};
+out ${i4} ${o4} ${a4};
+#else
+uniform ${i4} ${o4} u_${a4};
+#endif
+` : "vec4" === s4 ? `
+#ifndef HAS_UNIFORM_u_${a4}
+    ${a4} = a_${a4};
+#else
+    ${i4} ${o4} ${a4} = u_${a4};
+#endif
+` : `
+#ifndef HAS_UNIFORM_u_${a4}
+    ${a4} = unpack_mix_${s4}(a_${a4}, u_${a4}_t);
+#else
+    ${i4} ${o4} ${a4} = u_${a4};
+#endif
+` : "define" === t4 ? `
+#ifndef HAS_UNIFORM_u_${a4}
+uniform lowp float u_${a4}_t;
+in ${i4} ${r4} a_${a4};
+#else
+uniform ${i4} ${o4} u_${a4};
+#endif
+` : "vec4" === s4 ? `
+#ifndef HAS_UNIFORM_u_${a4}
+    ${i4} ${o4} ${a4} = a_${a4};
+#else
+    ${i4} ${o4} ${a4} = u_${a4};
+#endif
+` : `
+#ifndef HAS_UNIFORM_u_${a4}
+    ${i4} ${o4} ${a4} = unpack_mix_${s4}(a_${a4}, u_${a4}_t);
+#else
+    ${i4} ${o4} ${a4} = u_${a4};
+#endif
+`;
+        }), staticAttributes: o3, staticUniforms: s3 };
+      }
+      class At {
+        constructor(e3, t3, i3) {
+          this.vertexBuffer = e3, this.indexBuffer = t3, this.segments = i3;
+        }
+        destroy() {
+          this.vertexBuffer.destroy(), this.indexBuffer.destroy(), this.segments.destroy(), this.vertexBuffer = null, this.indexBuffer = null, this.segments = null;
+        }
+      }
+      var Lt = t2.aS([{ name: "a_pos", type: "Int16", components: 2 }]);
+      const kt = "#define PROJECTION_MERCATOR", Ft = "mercator";
+      class Bt {
+        constructor() {
+          this._cachedMesh = null;
+        }
+        get name() {
+          return "mercator";
+        }
+        get useSubdivision() {
+          return false;
+        }
+        get shaderVariantName() {
+          return Ft;
+        }
+        get shaderDefine() {
+          return kt;
+        }
+        get shaderPreludeCode() {
+          return zt.projectionMercator;
+        }
+        get vertexShaderPreludeCode() {
+          return zt.projectionMercator.vertexSource;
+        }
+        get subdivisionGranularity() {
+          return t2.aT.noSubdivision;
+        }
+        get useGlobeControls() {
+          return false;
+        }
+        get transitionState() {
+          return 0;
+        }
+        get latitudeErrorCorrectionRadians() {
+          return 0;
+        }
+        destroy() {
+        }
+        updateGPUdependent(e3) {
+        }
+        getMeshFromTileID(e3, i3, o3, a3, r3) {
+          if (this._cachedMesh) return this._cachedMesh;
+          const s3 = new t2.aU();
+          s3.emplaceBack(0, 0), s3.emplaceBack(t2.a5, 0), s3.emplaceBack(0, t2.a5), s3.emplaceBack(t2.a5, t2.a5);
+          const n3 = e3.createVertexBuffer(s3, Lt.members), l3 = t2.aV.simpleSegment(0, 0, 4, 2), c3 = new t2.aW();
+          c3.emplaceBack(1, 0, 2), c3.emplaceBack(1, 2, 3);
+          const h3 = e3.createIndexBuffer(c3);
+          return this._cachedMesh = new At(n3, h3, l3), this._cachedMesh;
+        }
+        recalculate() {
+        }
+        hasTransition() {
+          return false;
+        }
+        setErrorQueryLatitudeDegrees(e3) {
+        }
+      }
+      class Ot {
+        constructor(e3 = 0, t3 = 0, i3 = 0, o3 = 0) {
+          if (isNaN(e3) || e3 < 0 || isNaN(t3) || t3 < 0 || isNaN(i3) || i3 < 0 || isNaN(o3) || o3 < 0) throw new Error("Invalid value for edge-insets, top, bottom, left and right must all be numbers");
+          this.top = e3, this.bottom = t3, this.left = i3, this.right = o3;
+        }
+        interpolate(e3, i3, o3) {
+          return null != i3.top && null != e3.top && (this.top = t2.G.number(e3.top, i3.top, o3)), null != i3.bottom && null != e3.bottom && (this.bottom = t2.G.number(e3.bottom, i3.bottom, o3)), null != i3.left && null != e3.left && (this.left = t2.G.number(e3.left, i3.left, o3)), null != i3.right && null != e3.right && (this.right = t2.G.number(e3.right, i3.right, o3)), this;
+        }
+        getCenter(e3, i3) {
+          const o3 = t2.ak((this.left + e3 - this.right) / 2, 0, e3), a3 = t2.ak((this.top + i3 - this.bottom) / 2, 0, i3);
+          return new t2.P(o3, a3);
+        }
+        equals(e3) {
+          return this.top === e3.top && this.bottom === e3.bottom && this.left === e3.left && this.right === e3.right;
+        }
+        clone() {
+          return new Ot(this.top, this.bottom, this.left, this.right);
+        }
+        toJSON() {
+          return { top: this.top, bottom: this.bottom, left: this.left, right: this.right };
+        }
+      }
+      function jt(e3, t3) {
+        if (!e3.renderWorldCopies || e3.lngRange) return;
+        const i3 = t3.lng - e3.center.lng;
+        t3.lng += i3 > 180 ? -360 : i3 < -180 ? 360 : 0;
+      }
+      function Nt(e3) {
+        return Math.max(0, Math.floor(e3));
+      }
+      class Zt {
+        constructor(e3, i3) {
+          var o3;
+          this.applyConstrain = (e4, t3) => null !== this._constrainOverride ? this._constrainOverride(e4, t3) : this._callbacks.defaultConstrain(e4, t3), this._callbacks = e3, this._tileSize = 512, this._renderWorldCopies = void 0 === (null == i3 ? void 0 : i3.renderWorldCopies) || !!(null == i3 ? void 0 : i3.renderWorldCopies), this._minZoom = (null == i3 ? void 0 : i3.minZoom) || 0, this._maxZoom = (null == i3 ? void 0 : i3.maxZoom) || 22, this._minPitch = null == (null == i3 ? void 0 : i3.minPitch) ? 0 : null == i3 ? void 0 : i3.minPitch, this._maxPitch = null == (null == i3 ? void 0 : i3.maxPitch) ? 60 : null == i3 ? void 0 : i3.maxPitch, this._constrainOverride = null !== (o3 = null == i3 ? void 0 : i3.constrainOverride) && void 0 !== o3 ? o3 : null, this.setMaxBounds(), this._width = 0, this._height = 0, this._center = new t2.V(0, 0), this._elevation = 0, this._zoom = 0, this._tileZoom = Nt(this._zoom), this._scale = t2.an(this._zoom), this._bearingInRadians = 0, this._fovInRadians = 0.6435011087932844, this._pitchInRadians = 0, this._rollInRadians = 0, this._unmodified = true, this._edgeInsets = new Ot(), this._minElevationForCurrentTile = 0, this._autoCalculateNearFarZ = true;
+        }
+        apply(e3, i3, o3) {
+          this._constrainOverride = e3.constrainOverride, this._latRange = e3.latRange, this._lngRange = e3.lngRange, this._width = e3.width, this._height = e3.height, this._center = e3.center, this._elevation = e3.elevation, this._minElevationForCurrentTile = e3.minElevationForCurrentTile, this._zoom = e3.zoom, this._tileZoom = Nt(this._zoom), this._scale = t2.an(this._zoom), this._bearingInRadians = e3.bearingInRadians, this._fovInRadians = e3.fovInRadians, this._pitchInRadians = e3.pitchInRadians, this._rollInRadians = e3.rollInRadians, this._unmodified = e3.unmodified, this._edgeInsets = new Ot(e3.padding.top, e3.padding.bottom, e3.padding.left, e3.padding.right), this._minZoom = e3.minZoom, this._maxZoom = e3.maxZoom, this._minPitch = e3.minPitch, this._maxPitch = e3.maxPitch, this._renderWorldCopies = e3.renderWorldCopies, this._cameraToCenterDistance = e3.cameraToCenterDistance, this._nearZ = e3.nearZ, this._farZ = e3.farZ, this._autoCalculateNearFarZ = !o3 && e3.autoCalculateNearFarZ, i3 && this.constrainInternal(), this._calcMatrices();
+        }
+        get pixelsToClipSpaceMatrix() {
+          return this._pixelsToClipSpaceMatrix;
+        }
+        get clipSpaceToPixelsMatrix() {
+          return this._clipSpaceToPixelsMatrix;
+        }
+        get minElevationForCurrentTile() {
+          return this._minElevationForCurrentTile;
+        }
+        setMinElevationForCurrentTile(e3) {
+          this._minElevationForCurrentTile = e3;
+        }
+        get tileSize() {
+          return this._tileSize;
+        }
+        get tileZoom() {
+          return this._tileZoom;
+        }
+        get scale() {
+          return this._scale;
+        }
+        get width() {
+          return this._width;
+        }
+        get height() {
+          return this._height;
+        }
+        get bearingInRadians() {
+          return this._bearingInRadians;
+        }
+        get lngRange() {
+          return this._lngRange;
+        }
+        get latRange() {
+          return this._latRange;
+        }
+        get pixelsToGLUnits() {
+          return this._pixelsToGLUnits;
+        }
+        get minZoom() {
+          return this._minZoom;
+        }
+        setMinZoom(e3) {
+          this._minZoom !== e3 && (this._minZoom = e3, this.setZoom(this.applyConstrain(this._center, this.zoom).zoom));
+        }
+        get maxZoom() {
+          return this._maxZoom;
+        }
+        setMaxZoom(e3) {
+          this._maxZoom !== e3 && (this._maxZoom = e3, this.setZoom(this.applyConstrain(this._center, this.zoom).zoom));
+        }
+        get minPitch() {
+          return this._minPitch;
+        }
+        setMinPitch(e3) {
+          this._minPitch !== e3 && (this._minPitch = e3, this.setPitch(Math.max(this.pitch, e3)));
+        }
+        get maxPitch() {
+          return this._maxPitch;
+        }
+        setMaxPitch(e3) {
+          this._maxPitch !== e3 && (this._maxPitch = e3, this.setPitch(Math.min(this.pitch, e3)));
+        }
+        get renderWorldCopies() {
+          return this._renderWorldCopies;
+        }
+        setRenderWorldCopies(e3) {
+          void 0 === e3 ? e3 = true : null === e3 && (e3 = false), this._renderWorldCopies = e3;
+        }
+        get constrainOverride() {
+          return this._constrainOverride;
+        }
+        setConstrainOverride(e3) {
+          void 0 === e3 && (e3 = null), this._constrainOverride !== e3 && (this._constrainOverride = e3, this.constrainInternal(), this._calcMatrices());
+        }
+        get worldSize() {
+          return this._tileSize * this._scale;
+        }
+        get centerOffset() {
+          return this.centerPoint._sub(this.size._div(2));
+        }
+        get size() {
+          return new t2.P(this._width, this._height);
+        }
+        get bearing() {
+          return this._bearingInRadians / Math.PI * 180;
+        }
+        setBearing(e3) {
+          const i3 = t2.W(e3, -180, 180) * Math.PI / 180;
+          var a3, r3, s3, n3, l3, c3, h3, u3, d3;
+          this._bearingInRadians !== i3 && (this._unmodified = false, this._bearingInRadians = i3, this._calcMatrices(), this._rotationMatrix = o2(), a3 = this._rotationMatrix, s3 = -this._bearingInRadians, n3 = (r3 = this._rotationMatrix)[0], l3 = r3[1], c3 = r3[2], h3 = r3[3], u3 = Math.sin(s3), d3 = Math.cos(s3), a3[0] = n3 * d3 + c3 * u3, a3[1] = l3 * d3 + h3 * u3, a3[2] = n3 * -u3 + c3 * d3, a3[3] = l3 * -u3 + h3 * d3);
+        }
+        get rotationMatrix() {
+          return this._rotationMatrix;
+        }
+        get pitchInRadians() {
+          return this._pitchInRadians;
+        }
+        get pitch() {
+          return this._pitchInRadians / Math.PI * 180;
+        }
+        setPitch(e3) {
+          const i3 = t2.ak(e3, this.minPitch, this.maxPitch) / 180 * Math.PI;
+          this._pitchInRadians !== i3 && (this._unmodified = false, this._pitchInRadians = i3, this._calcMatrices());
+        }
+        get rollInRadians() {
+          return this._rollInRadians;
+        }
+        get roll() {
+          return this._rollInRadians / Math.PI * 180;
+        }
+        setRoll(e3) {
+          const t3 = e3 / 180 * Math.PI;
+          this._rollInRadians !== t3 && (this._unmodified = false, this._rollInRadians = t3, this._calcMatrices());
+        }
+        get fovInRadians() {
+          return this._fovInRadians;
+        }
+        get fov() {
+          return t2.aX(this._fovInRadians);
+        }
+        setFov(e3) {
+          e3 = t2.ak(e3, 0.1, 150), this.fov !== e3 && (this._unmodified = false, this._fovInRadians = t2.am(e3), this._calcMatrices());
+        }
+        get zoom() {
+          return this._zoom;
+        }
+        setZoom(e3) {
+          const i3 = this.applyConstrain(this._center, e3).zoom;
+          this._zoom !== i3 && (this._unmodified = false, this._zoom = i3, this._tileZoom = Math.max(0, Math.floor(i3)), this._scale = t2.an(i3), this.constrainInternal(), this._calcMatrices());
+        }
+        get center() {
+          return this._center;
+        }
+        setCenter(e3) {
+          e3.lat === this._center.lat && e3.lng === this._center.lng || (this._unmodified = false, this._center = e3, this.constrainInternal(), this._calcMatrices());
+        }
+        get elevation() {
+          return this._elevation;
+        }
+        setElevation(e3) {
+          e3 !== this._elevation && (this._elevation = e3, this.constrainInternal(), this._calcMatrices());
+        }
+        get padding() {
+          return this._edgeInsets.toJSON();
+        }
+        setPadding(e3) {
+          this._edgeInsets.equals(e3) || (this._unmodified = false, this._edgeInsets.interpolate(this._edgeInsets, e3, 1), this._calcMatrices());
+        }
+        get centerPoint() {
+          return this._edgeInsets.getCenter(this._width, this._height);
+        }
+        get pixelsPerMeter() {
+          return this._pixelPerMeter;
+        }
+        get unmodified() {
+          return this._unmodified;
+        }
+        get cameraToCenterDistance() {
+          return this._cameraToCenterDistance;
+        }
+        get nearZ() {
+          return this._nearZ;
+        }
+        get farZ() {
+          return this._farZ;
+        }
+        get autoCalculateNearFarZ() {
+          return this._autoCalculateNearFarZ;
+        }
+        overrideNearFarZ(e3, t3) {
+          this._autoCalculateNearFarZ = false, this._nearZ = e3, this._farZ = t3, this._calcMatrices();
+        }
+        clearNearFarZOverride() {
+          this._autoCalculateNearFarZ = true, this._calcMatrices();
+        }
+        isPaddingEqual(e3) {
+          return this._edgeInsets.equals(e3);
+        }
+        interpolatePadding(e3, t3, i3) {
+          this._unmodified = false, this._edgeInsets.interpolate(e3, t3, i3), this.constrainInternal(), this._calcMatrices();
+        }
+        resize(e3, t3, i3 = true) {
+          this._width = e3, this._height = t3, i3 && this.constrainInternal(), this._calcMatrices();
+        }
+        getMaxBounds() {
+          return this._latRange && 2 === this._latRange.length && this._lngRange && 2 === this._lngRange.length ? new Z2([this._lngRange[0], this._latRange[0]], [this._lngRange[1], this._latRange[1]]) : null;
+        }
+        setMaxBounds(e3) {
+          e3 ? (this._lngRange = [e3.getWest(), e3.getEast()], this._latRange = [e3.getSouth(), e3.getNorth()], this.constrainInternal()) : (this._lngRange = null, this._latRange = [-t2.al, t2.al]);
+        }
+        getCameraQueryGeometry(e3, i3) {
+          if (1 === i3.length) return [i3[0], e3];
+          {
+            const { minX: o3, minY: a3, maxX: r3, maxY: s3 } = t2.a7.fromPoints(i3).extend(e3);
+            return [new t2.P(o3, a3), new t2.P(r3, a3), new t2.P(r3, s3), new t2.P(o3, s3), new t2.P(o3, a3)];
+          }
+        }
+        constrainInternal() {
+          if (!this.center || !this._width || !this._height || this._constraining) return;
+          this._constraining = true;
+          const e3 = this._unmodified, { center: t3, zoom: i3 } = this.applyConstrain(this.center, this.zoom);
+          this.setCenter(t3), this.setZoom(i3), this._unmodified = e3, this._constraining = false;
+        }
+        _calcMatrices() {
+          if (this._width && this._height) {
+            this._pixelsToGLUnits = [2 / this._width, -2 / this._height];
+            let e3 = t2.ao(new Float64Array(16));
+            t2.Q(e3, e3, [this._width / 2, -this._height / 2, 1]), t2.O(e3, e3, [1, -1, 0]), this._clipSpaceToPixelsMatrix = e3, e3 = t2.ao(new Float64Array(16)), t2.Q(e3, e3, [1, -1, 1]), t2.O(e3, e3, [-1, -1, 0]), t2.Q(e3, e3, [2 / this._width, 2 / this._height, 1]), this._pixelsToClipSpaceMatrix = e3, this._cameraToCenterDistance = 0.5 / Math.tan(this.fovInRadians / 2) * this._height;
+          }
+          this._callbacks.calcMatrices();
+        }
+        calculateCenterFromCameraLngLatAlt(e3, i3, o3, a3) {
+          const r3 = void 0 !== o3 ? o3 : this.bearing, s3 = a3 = void 0 !== a3 ? a3 : this.pitch, { distanceToCenter: n3, clampedElevation: l3 } = this._distanceToCenterFromAltElevationPitch(i3, this.elevation, s3), { x: c3, y: h3 } = ve2(s3, r3), u3 = t2.a6.fromLngLat(e3, i3);
+          let d3, _3, p3 = t2.aY(1, u3.y), m3 = 0;
+          do {
+            if (m3 += 1, m3 > 10) break;
+            _3 = n3 / p3, d3 = new t2.a6(u3.x + c3 * _3, u3.y + h3 * _3), p3 = 1 / d3.meterInMercatorCoordinateUnits();
+          } while (Math.abs(n3 - _3 * p3) > 1e-12);
+          return { center: d3.toLngLat(), elevation: l3, zoom: t2.aq(this.height / 2 / Math.tan(this.fovInRadians / 2) / _3 / this.tileSize) };
+        }
+        recalculateZoomAndCenter(e3) {
+          if (this.elevation - e3 == 0) return;
+          const i3 = 1 / this.worldSize, o3 = t2.ap(1, this.center.lat) * this.worldSize, a3 = t2.a6.fromLngLat(this.center, this.elevation), r3 = a3.x / i3, s3 = a3.y / i3, n3 = a3.z / i3, l3 = this.pitch, c3 = this.bearing, { x: h3, y: u3, z: d3 } = ve2(l3, c3), _3 = this.cameraToCenterDistance, p3 = r3 + _3 * -h3, m3 = s3 + _3 * -u3, f3 = n3 + _3 * d3, { distanceToCenter: g3, clampedElevation: v3 } = this._distanceToCenterFromAltElevationPitch(f3 / o3, e3, l3), x3 = g3 * o3, b3 = new t2.a6((p3 + h3 * x3) * i3, (m3 + u3 * x3) * i3, 0).toLngLat(), y3 = t2.ap(1, b3.lat), w3 = t2.aq(this.height / 2 / Math.tan(this.fovInRadians / 2) / g3 / y3 / this.tileSize);
+          this._elevation = v3, this._center = b3, this.setZoom(w3);
+        }
+        _distanceToCenterFromAltElevationPitch(e3, i3, o3) {
+          const a3 = -Math.cos(t2.am(o3)), r3 = e3 - i3;
+          let s3, n3 = i3;
+          return a3 * r3 >= 0 || Math.abs(a3) < 0.1 ? (s3 = 1e4, n3 = e3 + s3 * a3) : s3 = -r3 / a3, { distanceToCenter: s3, clampedElevation: n3 };
+        }
+        getCameraPoint() {
+          const e3 = Math.tan(this.pitchInRadians) * (this.cameraToCenterDistance || 1);
+          return this.centerPoint.add(new t2.P(e3 * Math.sin(this.rollInRadians), e3 * Math.cos(this.rollInRadians)));
+        }
+        getCameraAltitude() {
+          return Math.cos(this.pitchInRadians) * this._cameraToCenterDistance / this._pixelPerMeter + this.elevation;
+        }
+        getCameraLngLat() {
+          const e3 = t2.ap(1, this.center.lat) * this.worldSize;
+          return ge2(this.center, this.elevation, this.pitch, this.bearing, this.cameraToCenterDistance / e3).toLngLat();
+        }
+        getMercatorTileCoordinates(e3) {
+          if (!e3) return [0, 0, 1, 1];
+          const i3 = e3.canonical.z >= 0 ? 1 << e3.canonical.z : Math.pow(2, e3.canonical.z);
+          return [e3.canonical.x / i3, e3.canonical.y / i3, 1 / i3 / t2.a5, 1 / i3 / t2.a5];
+        }
+      }
+      class Ut {
+        constructor(e3, i3) {
+          this.min = e3, this.max = i3, this.center = t2.aZ([], t2.a_([], this.min, this.max), 0.5);
+        }
+        quadrant(e3) {
+          const i3 = [e3 % 2 == 0, e3 < 2], o3 = t2.a$(this.min), a3 = t2.a$(this.max);
+          for (let e4 = 0; e4 < i3.length; e4++) o3[e4] = i3[e4] ? this.min[e4] : this.center[e4], a3[e4] = i3[e4] ? this.center[e4] : this.max[e4];
+          return a3[2] = this.max[2], new Ut(o3, a3);
+        }
+        distanceX(e3) {
+          return Math.max(Math.min(this.max[0], e3[0]), this.min[0]) - e3[0];
+        }
+        distanceY(e3) {
+          return Math.max(Math.min(this.max[1], e3[1]), this.min[1]) - e3[1];
+        }
+        intersectsFrustum(e3) {
+          let t3 = true;
+          for (let i3 = 0; i3 < e3.planes.length; i3++) {
+            const o3 = this.intersectsPlane(e3.planes[i3]);
+            if (0 === o3) return 0;
+            1 === o3 && (t3 = false);
+          }
+          return t3 ? 2 : e3.aabb.min[0] > this.max[0] || e3.aabb.min[1] > this.max[1] || e3.aabb.min[2] > this.max[2] || e3.aabb.max[0] < this.min[0] || e3.aabb.max[1] < this.min[1] || e3.aabb.max[2] < this.min[2] ? 0 : 1;
+        }
+        intersectsPlane(e3) {
+          let t3 = e3[3], i3 = e3[3];
+          for (let o3 = 0; o3 < 3; o3++) e3[o3] > 0 ? (t3 += e3[o3] * this.min[o3], i3 += e3[o3] * this.max[o3]) : (i3 += e3[o3] * this.min[o3], t3 += e3[o3] * this.max[o3]);
+          return t3 >= 0 ? 2 : i3 < 0 ? 0 : 1;
+        }
+      }
+      class Gt {
+        distanceToTile2d(e3, t3, i3, o3) {
+          const a3 = o3.distanceX([e3, t3]), r3 = o3.distanceY([e3, t3]);
+          return Math.hypot(a3, r3);
+        }
+        getWrap(e3, t3, i3) {
+          return i3;
+        }
+        getTileBoundingVolume(e3, i3, o3, a3) {
+          var r3, s3;
+          let n3 = 0, l3 = 0;
+          if (null == a3 ? void 0 : a3.terrain) {
+            const c4 = new t2.a2(e3.z, i3, e3.z, e3.x, e3.y), h3 = a3.terrain.getMinMaxElevation(c4);
+            n3 = null !== (r3 = h3.minElevation) && void 0 !== r3 ? r3 : Math.min(0, o3), l3 = null !== (s3 = h3.maxElevation) && void 0 !== s3 ? s3 : Math.max(0, o3);
+          }
+          const c3 = 1 << e3.z;
+          return new Ut([i3 + e3.x / c3, e3.y / c3, n3], [i3 + (e3.x + 1) / c3, (e3.y + 1) / c3, l3]);
+        }
+        allowVariableZoom(e3, i3) {
+          const o3 = e3.fov * (Math.abs(Math.cos(e3.rollInRadians)) * e3.height + Math.abs(Math.sin(e3.rollInRadians)) * e3.width) / e3.height, a3 = t2.ak(78.5 - o3 / 2, 0, 60);
+          return !!i3.terrain || e3.pitch > a3;
+        }
+        allowWorldCopies() {
+          return true;
+        }
+        prepareNextFrame() {
+        }
+      }
+      class Vt {
+        constructor(e3, t3, i3) {
+          this.points = e3, this.planes = t3, this.aabb = i3;
+        }
+        static fromInvProjectionMatrix(e3, i3 = 1, o3 = 0, a3, r3) {
+          const s3 = r3 ? [[6, 5, 4], [0, 1, 2], [0, 3, 7], [2, 1, 5], [3, 2, 6], [0, 4, 5]] : [[0, 1, 2], [6, 5, 4], [0, 3, 7], [2, 1, 5], [3, 2, 6], [0, 4, 5]], n3 = Math.pow(2, o3), l3 = [[-1, 1, -1, 1], [1, 1, -1, 1], [1, -1, -1, 1], [-1, -1, -1, 1], [-1, 1, 1, 1], [1, 1, 1, 1], [1, -1, 1, 1], [-1, -1, 1, 1]].map((o4) => function(e4, i4, o5, a4) {
+            const r4 = t2.aE([], e4, i4), s4 = 1 / r4[3] / o5 * a4;
+            return t2.b4(r4, r4, [s4, s4, 1 / r4[3], s4]);
+          }(o4, e3, i3, n3));
+          a3 && function(e4, i4, o4, a4) {
+            const r4 = a4 ? 4 : 0, s4 = a4 ? 0 : 4;
+            let n4 = 0;
+            const l4 = [], c4 = [];
+            for (let i5 = 0; i5 < 4; i5++) {
+              const o5 = t2.b0([], e4[i5 + s4], e4[i5 + r4]), a5 = t2.b5(o5);
+              t2.aZ(o5, o5, 1 / a5), l4.push(a5), c4.push(o5);
+            }
+            for (let i5 = 0; i5 < 4; i5++) {
+              const a5 = t2.b6(e4[i5 + r4], c4[i5], o4);
+              n4 = null !== a5 && a5 >= 0 ? Math.max(n4, a5) : Math.max(n4, l4[i5]);
+            }
+            const h4 = function(e5, i5) {
+              const o5 = t2.b0([], e5[i5[0]], e5[i5[1]]), a5 = t2.b0([], e5[i5[2]], e5[i5[1]]), r5 = [0, 0, 0, 0];
+              return t2.b1(r5, t2.b2([], o5, a5)), r5[3] = -t2.b3(r5, e5[i5[0]]), r5;
+            }(e4, i4), u4 = function(e5, i5) {
+              const o5 = t2.b7(e5), a5 = t2.b8([], e5, 1 / o5), r5 = t2.b0([], i5, t2.aZ([], a5, t2.b3(i5, a5))), s5 = t2.b7(r5);
+              if (s5 > 0) {
+                const e6 = Math.sqrt(1 - a5[3] * a5[3]), o6 = t2.aZ([], a5, -a5[3]), n5 = t2.a_([], o6, t2.aZ([], r5, e6 / s5));
+                return t2.b9(i5, n5);
+              }
+              return null;
+            }(o4, h4);
+            if (null !== u4) {
+              const e5 = u4 / t2.b3(c4[0], h4);
+              n4 = Math.min(n4, e5);
+            }
+            for (let t3 = 0; t3 < 4; t3++) {
+              const i5 = Math.min(n4, l4[t3]);
+              e4[t3 + s4] = [e4[t3 + r4][0] + c4[t3][0] * i5, e4[t3 + r4][1] + c4[t3][1] * i5, e4[t3 + r4][2] + c4[t3][2] * i5, 1];
+            }
+          }(l3, s3[0], a3, r3);
+          const c3 = s3.map((e4) => {
+            const i4 = t2.b0([], l3[e4[0]], l3[e4[1]]), o4 = t2.b0([], l3[e4[2]], l3[e4[1]]), a4 = t2.b1([], t2.b2([], i4, o4)), r4 = -t2.b3(a4, l3[e4[1]]);
+            return a4.concat(r4);
+          }), h3 = [Number.POSITIVE_INFINITY, Number.POSITIVE_INFINITY, Number.POSITIVE_INFINITY], u3 = [Number.NEGATIVE_INFINITY, Number.NEGATIVE_INFINITY, Number.NEGATIVE_INFINITY];
+          for (const e4 of l3) for (let t3 = 0; t3 < 3; t3++) h3[t3] = Math.min(h3[t3], e4[t3]), u3[t3] = Math.max(u3[t3], e4[t3]);
+          return new Vt(l3, c3, new Ut(h3, u3));
+        }
+      }
+      class Wt {
+        get pixelsToClipSpaceMatrix() {
+          return this._helper.pixelsToClipSpaceMatrix;
+        }
+        get clipSpaceToPixelsMatrix() {
+          return this._helper.clipSpaceToPixelsMatrix;
+        }
+        get pixelsToGLUnits() {
+          return this._helper.pixelsToGLUnits;
+        }
+        get centerOffset() {
+          return this._helper.centerOffset;
+        }
+        get size() {
+          return this._helper.size;
+        }
+        get rotationMatrix() {
+          return this._helper.rotationMatrix;
+        }
+        get centerPoint() {
+          return this._helper.centerPoint;
+        }
+        get pixelsPerMeter() {
+          return this._helper.pixelsPerMeter;
+        }
+        setMinZoom(e3) {
+          this._helper.setMinZoom(e3);
+        }
+        setMaxZoom(e3) {
+          this._helper.setMaxZoom(e3);
+        }
+        setMinPitch(e3) {
+          this._helper.setMinPitch(e3);
+        }
+        setMaxPitch(e3) {
+          this._helper.setMaxPitch(e3);
+        }
+        setRenderWorldCopies(e3) {
+          this._helper.setRenderWorldCopies(e3);
+        }
+        setBearing(e3) {
+          this._helper.setBearing(e3);
+        }
+        setPitch(e3) {
+          this._helper.setPitch(e3);
+        }
+        setRoll(e3) {
+          this._helper.setRoll(e3);
+        }
+        setFov(e3) {
+          this._helper.setFov(e3);
+        }
+        setZoom(e3) {
+          this._helper.setZoom(e3);
+        }
+        setCenter(e3) {
+          this._helper.setCenter(e3);
+        }
+        setElevation(e3) {
+          this._helper.setElevation(e3);
+        }
+        setMinElevationForCurrentTile(e3) {
+          this._helper.setMinElevationForCurrentTile(e3);
+        }
+        setPadding(e3) {
+          this._helper.setPadding(e3);
+        }
+        interpolatePadding(e3, t3, i3) {
+          return this._helper.interpolatePadding(e3, t3, i3);
+        }
+        isPaddingEqual(e3) {
+          return this._helper.isPaddingEqual(e3);
+        }
+        resize(e3, t3, i3 = true) {
+          this._helper.resize(e3, t3, i3);
+        }
+        getMaxBounds() {
+          return this._helper.getMaxBounds();
+        }
+        setMaxBounds(e3) {
+          this._helper.setMaxBounds(e3);
+        }
+        setConstrainOverride(e3) {
+          this._helper.setConstrainOverride(e3);
+        }
+        overrideNearFarZ(e3, t3) {
+          this._helper.overrideNearFarZ(e3, t3);
+        }
+        clearNearFarZOverride() {
+          this._helper.clearNearFarZOverride();
+        }
+        getCameraQueryGeometry(e3) {
+          return this._helper.getCameraQueryGeometry(this.getCameraPoint(), e3);
+        }
+        get tileSize() {
+          return this._helper.tileSize;
+        }
+        get tileZoom() {
+          return this._helper.tileZoom;
+        }
+        get scale() {
+          return this._helper.scale;
+        }
+        get worldSize() {
+          return this._helper.worldSize;
+        }
+        get width() {
+          return this._helper.width;
+        }
+        get height() {
+          return this._helper.height;
+        }
+        get lngRange() {
+          return this._helper.lngRange;
+        }
+        get latRange() {
+          return this._helper.latRange;
+        }
+        get minZoom() {
+          return this._helper.minZoom;
+        }
+        get maxZoom() {
+          return this._helper.maxZoom;
+        }
+        get zoom() {
+          return this._helper.zoom;
+        }
+        get center() {
+          return this._helper.center;
+        }
+        get minPitch() {
+          return this._helper.minPitch;
+        }
+        get maxPitch() {
+          return this._helper.maxPitch;
+        }
+        get pitch() {
+          return this._helper.pitch;
+        }
+        get pitchInRadians() {
+          return this._helper.pitchInRadians;
+        }
+        get roll() {
+          return this._helper.roll;
+        }
+        get rollInRadians() {
+          return this._helper.rollInRadians;
+        }
+        get bearing() {
+          return this._helper.bearing;
+        }
+        get bearingInRadians() {
+          return this._helper.bearingInRadians;
+        }
+        get fov() {
+          return this._helper.fov;
+        }
+        get fovInRadians() {
+          return this._helper.fovInRadians;
+        }
+        get elevation() {
+          return this._helper.elevation;
+        }
+        get minElevationForCurrentTile() {
+          return this._helper.minElevationForCurrentTile;
+        }
+        get padding() {
+          return this._helper.padding;
+        }
+        get unmodified() {
+          return this._helper.unmodified;
+        }
+        get renderWorldCopies() {
+          return this._helper.renderWorldCopies;
+        }
+        get cameraToCenterDistance() {
+          return this._helper.cameraToCenterDistance;
+        }
+        get constrainOverride() {
+          return this._helper.constrainOverride;
+        }
+        get nearZ() {
+          return this._helper.nearZ;
+        }
+        get farZ() {
+          return this._helper.farZ;
+        }
+        get autoCalculateNearFarZ() {
+          return this._helper.autoCalculateNearFarZ;
+        }
+        setTransitionState(e3, t3) {
+        }
+        constructor(e3) {
+          this._posMatrixCache = /* @__PURE__ */ new Map(), this._alignedPosMatrixCache = /* @__PURE__ */ new Map(), this._fogMatrixCacheF32 = /* @__PURE__ */ new Map(), this.defaultConstrain = (e4, i3) => {
+            i3 = t2.ak(+i3, this.minZoom, this.maxZoom);
+            const o3 = { center: new t2.V(e4.lng, e4.lat), zoom: i3 };
+            let a3 = this._helper._lngRange;
+            if (!this._helper._renderWorldCopies && null === a3) {
+              const e5 = 180 - 1e-10;
+              a3 = [-179.9999999999, e5];
+            }
+            const r3 = this.tileSize * t2.an(o3.zoom);
+            let s3 = 0, n3 = r3, l3 = 0, c3 = r3, h3 = 0, u3 = 0;
+            const { x: d3, y: _3 } = this.size;
+            if (this._helper._latRange) {
+              const e5 = this._helper._latRange;
+              s3 = t2.X(e5[1]) * r3, n3 = t2.X(e5[0]) * r3, n3 - s3 < _3 && (h3 = _3 / (n3 - s3));
+            }
+            a3 && (l3 = t2.W(t2.Y(a3[0]) * r3, 0, r3), c3 = t2.W(t2.Y(a3[1]) * r3, 0, r3), c3 < l3 && (c3 += r3), c3 - l3 < d3 && (u3 = d3 / (c3 - l3)));
+            const { x: p3, y: m3 } = _e2(r3, e4);
+            let f3, g3;
+            const v3 = Math.max(u3 || 0, h3 || 0);
+            if (v3) {
+              const e5 = new t2.P(u3 ? (c3 + l3) / 2 : p3, h3 ? (n3 + s3) / 2 : m3);
+              return o3.center = pe2(r3, e5).wrap(), o3.zoom += t2.aq(v3), o3;
+            }
+            if (this._helper._latRange) {
+              const e5 = _3 / 2;
+              m3 - e5 < s3 && (g3 = s3 + e5), m3 + e5 > n3 && (g3 = n3 - e5);
+            }
+            if (a3) {
+              const e5 = (l3 + c3) / 2;
+              let i4 = p3;
+              this._helper._renderWorldCopies && (i4 = t2.W(p3, e5 - r3 / 2, e5 + r3 / 2));
+              const o4 = d3 / 2;
+              i4 - o4 < l3 && (f3 = l3 + o4), i4 + o4 > c3 && (f3 = c3 - o4);
+            }
+            if (void 0 !== f3 || void 0 !== g3) {
+              const e5 = new t2.P(null != f3 ? f3 : p3, null != g3 ? g3 : m3);
+              o3.center = pe2(r3, e5).wrap();
+            }
+            return o3;
+          }, this.applyConstrain = (e4, t3) => this._helper.applyConstrain(e4, t3), this._helper = new Zt({ calcMatrices: () => {
+            this._calcMatrices();
+          }, defaultConstrain: (e4, t3) => this.defaultConstrain(e4, t3) }, e3), this._coveringTilesDetailsProvider = new Gt();
+        }
+        clone() {
+          const e3 = new Wt();
+          return e3.apply(this, false), e3;
+        }
+        apply(e3, t3, i3) {
+          this._helper.apply(e3, t3, i3);
+        }
+        get cameraPosition() {
+          return this._cameraPosition;
+        }
+        get projectionMatrix() {
+          return this._projectionMatrix;
+        }
+        get modelViewProjectionMatrix() {
+          return this._viewProjMatrix;
+        }
+        get inverseProjectionMatrix() {
+          return this._invProjMatrix;
+        }
+        get mercatorMatrix() {
+          return this._mercatorMatrix;
+        }
+        getVisibleUnwrappedCoordinates(e3) {
+          const i3 = [new t2.ba(0, e3)];
+          if (this._helper._renderWorldCopies) {
+            const o3 = this.screenPointToMercatorCoordinate(new t2.P(0, 0)), a3 = this.screenPointToMercatorCoordinate(new t2.P(this._helper._width, 0)), r3 = this.screenPointToMercatorCoordinate(new t2.P(this._helper._width, this._helper._height)), s3 = this.screenPointToMercatorCoordinate(new t2.P(0, this._helper._height)), n3 = Math.floor(Math.min(o3.x, a3.x, r3.x, s3.x)), l3 = Math.floor(Math.max(o3.x, a3.x, r3.x, s3.x)), c3 = 1;
+            for (let o4 = n3 - c3; o4 <= l3 + c3; o4++) 0 !== o4 && i3.push(new t2.ba(o4, e3));
+          }
+          return i3;
+        }
+        getCameraFrustum() {
+          return Vt.fromInvProjectionMatrix(this._invViewProjMatrix, this.worldSize);
+        }
+        getClippingPlane() {
+          return null;
+        }
+        getCoveringTilesDetailsProvider() {
+          return this._coveringTilesDetailsProvider;
+        }
+        recalculateZoomAndCenter(e3) {
+          const t3 = this.screenPointToLocation(this.centerPoint, e3), i3 = e3 ? e3.getElevationForLngLatZoom(t3, this._helper._tileZoom) : 0;
+          this._helper.recalculateZoomAndCenter(i3);
+        }
+        setLocationAtPoint(e3, i3) {
+          const o3 = t2.ap(this.elevation, this.center.lat), a3 = this.screenPointToMercatorCoordinateAtZ(i3, o3), r3 = this.screenPointToMercatorCoordinateAtZ(this.centerPoint, o3), s3 = t2.a6.fromLngLat(e3), n3 = new t2.a6(s3.x - (a3.x - r3.x), s3.y - (a3.y - r3.y));
+          this.setCenter(null == n3 ? void 0 : n3.toLngLat()), this._helper._renderWorldCopies && this.setCenter(this.center.wrap());
+        }
+        locationToScreenPoint(e3, i3) {
+          return i3 ? this.coordinatePoint(t2.a6.fromLngLat(e3), i3.getElevationForLngLat(e3, this), this._pixelMatrix3D) : this.coordinatePoint(t2.a6.fromLngLat(e3));
+        }
+        screenPointToLocation(e3, t3) {
+          var i3;
+          return null === (i3 = this.screenPointToMercatorCoordinate(e3, t3)) || void 0 === i3 ? void 0 : i3.toLngLat();
+        }
+        screenPointToMercatorCoordinate(e3, t3) {
+          if (t3) {
+            const i3 = t3.pointCoordinate(e3);
+            if (null != i3) return i3;
+          }
+          return this.screenPointToMercatorCoordinateAtZ(e3);
+        }
+        screenPointToMercatorCoordinateAtZ(e3, i3) {
+          const o3 = i3 || 0, a3 = [e3.x, e3.y, 0, 1], r3 = [e3.x, e3.y, 1, 1];
+          t2.aE(a3, a3, this._pixelMatrixInverse), t2.aE(r3, r3, this._pixelMatrixInverse);
+          const s3 = a3[3], n3 = r3[3], l3 = a3[1] / s3, c3 = r3[1] / n3, h3 = a3[2] / s3, u3 = r3[2] / n3, d3 = h3 === u3 ? 0 : (o3 - h3) / (u3 - h3);
+          return new t2.a6(t2.G.number(a3[0] / s3, r3[0] / n3, d3) / this.worldSize, t2.G.number(l3, c3, d3) / this.worldSize, o3);
+        }
+        coordinatePoint(e3, i3 = 0, o3 = this._pixelMatrix) {
+          const a3 = [e3.x * this.worldSize, e3.y * this.worldSize, i3, 1];
+          return t2.aE(a3, a3, o3), new t2.P(a3[0] / a3[3], a3[1] / a3[3]);
+        }
+        getBounds() {
+          const e3 = Math.max(0, this._helper._height / 2 - me2(this));
+          return new Z2().extend(this.screenPointToLocation(new t2.P(0, e3))).extend(this.screenPointToLocation(new t2.P(this._helper._width, e3))).extend(this.screenPointToLocation(new t2.P(this._helper._width, this._helper._height))).extend(this.screenPointToLocation(new t2.P(0, this._helper._height)));
+        }
+        isPointOnMapSurface(e3, t3) {
+          return t3 ? null != t3.pointCoordinate(e3) : e3.y > this.height / 2 - me2(this);
+        }
+        calculatePosMatrix(e3, i3 = false, o3) {
+          var a3;
+          const r3 = null !== (a3 = e3.key) && void 0 !== a3 ? a3 : t2.bb(e3.wrap, e3.canonical.z, e3.canonical.z, e3.canonical.x, e3.canonical.y), s3 = i3 ? this._alignedPosMatrixCache : this._posMatrixCache;
+          if (s3.has(r3)) {
+            const e4 = s3.get(r3);
+            return o3 ? e4.f32 : e4.f64;
+          }
+          const n3 = fe2(e3, this.worldSize);
+          t2.S(n3, i3 ? this._alignedProjMatrix : this._viewProjMatrix, n3);
+          const l3 = { f64: n3, f32: new Float32Array(n3) };
+          return s3.set(r3, l3), o3 ? l3.f32 : l3.f64;
+        }
+        calculateFogMatrix(e3) {
+          const i3 = e3.key, o3 = this._fogMatrixCacheF32;
+          if (o3.has(i3)) return o3.get(i3);
+          const a3 = fe2(e3, this.worldSize);
+          return t2.S(a3, this._fogMatrix, a3), o3.set(i3, new Float32Array(a3)), o3.get(i3);
+        }
+        calculateCenterFromCameraLngLatAlt(e3, t3, i3, o3) {
+          return this._helper.calculateCenterFromCameraLngLatAlt(e3, t3, i3, o3);
+        }
+        _calculateNearFarZIfNeeded(e3, i3, o3) {
+          if (!this._helper.autoCalculateNearFarZ) return;
+          const a3 = Math.min(this.elevation, this.minElevationForCurrentTile, this.getCameraAltitude() - 100), r3 = e3 - a3 * this._helper._pixelPerMeter / Math.cos(i3), s3 = a3 < 0 ? r3 : e3, n3 = Math.PI / 2 + this.pitchInRadians, l3 = t2.am(this.fov) * (Math.abs(Math.cos(t2.am(this.roll))) * this.height + Math.abs(Math.sin(t2.am(this.roll))) * this.width) / this.height * (0.5 + o3.y / this.height), c3 = Math.sin(l3) * s3 / Math.sin(t2.ak(Math.PI - n3 - l3, 0.01, Math.PI - 0.01)), h3 = me2(this), u3 = Math.atan(h3 / this._helper.cameraToCenterDistance), d3 = t2.am(0.75), _3 = u3 > d3 ? 2 * u3 * (0.5 + o3.y / (2 * h3)) : d3, p3 = Math.sin(_3) * s3 / Math.sin(t2.ak(Math.PI - n3 - _3, 0.01, Math.PI - 0.01)), m3 = Math.min(c3, p3);
+          this._helper._farZ = 1.01 * (Math.cos(Math.PI / 2 - i3) * m3 + s3), this._helper._nearZ = this._helper._height / 50;
+        }
+        _calcMatrices() {
+          if (!this._helper._height) return;
+          const e3 = this.centerOffset, i3 = _e2(this.worldSize, this.center), o3 = i3.x, a3 = i3.y;
+          this._helper._pixelPerMeter = t2.ap(1, this.center.lat) * this.worldSize;
+          const r3 = t2.am(Math.min(this.pitch, de2)), s3 = Math.max(this._helper.cameraToCenterDistance / 2, this._helper.cameraToCenterDistance + this._helper._elevation * this._helper._pixelPerMeter / Math.cos(r3));
+          let n3;
+          this._calculateNearFarZIfNeeded(s3, r3, e3), n3 = new Float64Array(16), t2.bc(n3, this.fovInRadians, this._helper._width / this._helper._height, this._helper._nearZ, this._helper._farZ), this._invProjMatrix = new Float64Array(16), t2.ay(this._invProjMatrix, n3), n3[8] = 2 * -e3.x / this._helper._width, n3[9] = 2 * e3.y / this._helper._height, this._projectionMatrix = t2.bd(n3), t2.Q(n3, n3, [1, -1, 1]), t2.O(n3, n3, [0, 0, -this._helper.cameraToCenterDistance]), t2.be(n3, n3, -this.rollInRadians), t2.bf(n3, n3, this.pitchInRadians), t2.be(n3, n3, -this.bearingInRadians), t2.O(n3, n3, [-o3, -a3, 0]), this._mercatorMatrix = t2.Q([], n3, [this.worldSize, this.worldSize, this.worldSize]), t2.Q(n3, n3, [1, 1, this._helper._pixelPerMeter]), this._pixelMatrix = t2.S(new Float64Array(16), this.clipSpaceToPixelsMatrix, n3), t2.O(n3, n3, [0, 0, -this.elevation]), this._viewProjMatrix = n3, this._invViewProjMatrix = t2.ay([], n3);
+          const l3 = [0, 0, -1, 1];
+          t2.aE(l3, l3, this._invViewProjMatrix), this._cameraPosition = [l3[0] / l3[3], l3[1] / l3[3], l3[2] / l3[3]], this._fogMatrix = new Float64Array(16), t2.bc(this._fogMatrix, this.fovInRadians, this.width / this.height, s3, this._helper._farZ), this._fogMatrix[8] = 2 * -e3.x / this.width, this._fogMatrix[9] = 2 * e3.y / this.height, t2.Q(this._fogMatrix, this._fogMatrix, [1, -1, 1]), t2.O(this._fogMatrix, this._fogMatrix, [0, 0, -this.cameraToCenterDistance]), t2.be(this._fogMatrix, this._fogMatrix, -this.rollInRadians), t2.bf(this._fogMatrix, this._fogMatrix, this.pitchInRadians), t2.be(this._fogMatrix, this._fogMatrix, -this.bearingInRadians), t2.O(this._fogMatrix, this._fogMatrix, [-o3, -a3, 0]), t2.Q(this._fogMatrix, this._fogMatrix, [1, 1, this._helper._pixelPerMeter]), t2.O(this._fogMatrix, this._fogMatrix, [0, 0, -this.elevation]), this._pixelMatrix3D = t2.S(new Float64Array(16), this.clipSpaceToPixelsMatrix, n3);
+          const c3 = this._helper._width % 2 / 2, h3 = this._helper._height % 2 / 2, u3 = Math.cos(this.bearingInRadians), d3 = Math.sin(-this.bearingInRadians), _3 = o3 - Math.round(o3) + u3 * c3 + d3 * h3, p3 = a3 - Math.round(a3) + u3 * h3 + d3 * c3, m3 = new Float64Array(n3);
+          if (t2.O(m3, m3, [_3 > 0.5 ? _3 - 1 : _3, p3 > 0.5 ? p3 - 1 : p3, 0]), this._alignedProjMatrix = m3, n3 = t2.ay(new Float64Array(16), this._pixelMatrix), !n3) throw new Error("failed to invert matrix");
+          this._pixelMatrixInverse = n3, this._clearMatrixCaches();
+        }
+        _clearMatrixCaches() {
+          this._posMatrixCache.clear(), this._alignedPosMatrixCache.clear(), this._fogMatrixCacheF32.clear();
+        }
+        maxPitchScaleFactor() {
+          if (!this._pixelMatrixInverse) return 1;
+          const e3 = this.screenPointToMercatorCoordinate(new t2.P(0, 0)), i3 = [e3.x * this.worldSize, e3.y * this.worldSize, 0, 1];
+          return t2.aE(i3, i3, this._pixelMatrix)[3] / this._helper.cameraToCenterDistance;
+        }
+        getCameraPoint() {
+          return this._helper.getCameraPoint();
+        }
+        getCameraAltitude() {
+          return this._helper.getCameraAltitude();
+        }
+        getCameraLngLat() {
+          const e3 = t2.ap(1, this.center.lat) * this.worldSize;
+          return ge2(this.center, this.elevation, this.pitch, this.bearing, this._helper.cameraToCenterDistance / e3).toLngLat();
+        }
+        lngLatToCameraDepth(e3, i3) {
+          const o3 = t2.a6.fromLngLat(e3), a3 = [o3.x * this.worldSize, o3.y * this.worldSize, i3, 1];
+          return t2.aE(a3, a3, this._viewProjMatrix), a3[2] / a3[3];
+        }
+        getProjectionData(e3) {
+          const { overscaledTileID: i3, aligned: o3, applyTerrainMatrix: a3 } = e3, r3 = this._helper.getMercatorTileCoordinates(i3), s3 = i3 ? this.calculatePosMatrix(i3, o3, true) : null;
+          let n3;
+          return n3 = i3 && i3.terrainRttPosMatrix32f && a3 ? i3.terrainRttPosMatrix32f : s3 || t2.bg(), { mainMatrix: n3, tileMercatorCoords: r3, clippingPlane: [0, 0, 0, 0], projectionTransition: 0, fallbackMatrix: n3 };
+        }
+        isLocationOccluded(e3) {
+          return false;
+        }
+        getPixelScale() {
+          return 1;
+        }
+        getCircleRadiusCorrection() {
+          return 1;
+        }
+        getPitchedTextCorrection(e3, t3, i3) {
+          return 1;
+        }
+        transformLightDirection(e3) {
+          return t2.a$(e3);
+        }
+        getRayDirectionFromPixel(e3) {
+          throw new Error("Not implemented.");
+        }
+        projectTileCoordinates(e3, i3, o3, a3) {
+          const r3 = this.calculatePosMatrix(o3);
+          let s3;
+          a3 ? (s3 = [e3, i3, a3(e3, i3), 1], t2.aE(s3, s3, r3)) : (s3 = [e3, i3, 0, 1], ot2(s3, s3, r3));
+          const n3 = s3[3];
+          return { point: new t2.P(s3[0] / n3, s3[1] / n3), signedDistanceFromCamera: n3, isOccluded: false };
+        }
+        populateCache(e3) {
+          for (const t3 of e3) this.calculatePosMatrix(t3);
+        }
+        getMatrixForModel(e3, i3) {
+          const o3 = t2.a6.fromLngLat(e3, i3), a3 = o3.meterInMercatorCoordinateUnits(), r3 = t2.bh();
+          return t2.O(r3, r3, [o3.x, o3.y, o3.z]), t2.be(r3, r3, Math.PI), t2.bf(r3, r3, Math.PI / 2), t2.Q(r3, r3, [-a3, a3, a3]), r3;
+        }
+        getProjectionDataForCustomLayer(e3 = true) {
+          const i3 = new t2.a2(0, 0, 0, 0, 0), o3 = this.getProjectionData({ overscaledTileID: i3, applyGlobeMatrix: e3 }), a3 = fe2(i3, this.worldSize);
+          t2.S(a3, this._viewProjMatrix, a3), o3.tileMercatorCoords = [0, 0, 1, 1];
+          const r3 = [t2.a5, t2.a5, this.worldSize / this._helper.pixelsPerMeter], s3 = t2.bi();
+          return t2.Q(s3, a3, r3), o3.fallbackMatrix = s3, o3.mainMatrix = s3, o3;
+        }
+        getFastPathSimpleProjectionMatrix(e3) {
+          return this.calculatePosMatrix(e3);
+        }
+      }
+      function qt() {
+        t2.w("Map cannot fit within canvas with the given bounds, padding, and/or offset.");
+      }
+      function $t(e3) {
+        if (e3.useSlerp) if (e3.k < 1) {
+          const i3 = t2.bj(e3.startEulerAngles.roll, e3.startEulerAngles.pitch, e3.startEulerAngles.bearing), o3 = t2.bj(e3.endEulerAngles.roll, e3.endEulerAngles.pitch, e3.endEulerAngles.bearing), a3 = new Float64Array(4);
+          t2.bk(a3, i3, o3, e3.k);
+          const r3 = t2.bl(a3);
+          e3.tr.setRoll(r3.roll), e3.tr.setPitch(r3.pitch), e3.tr.setBearing(r3.bearing);
+        } else e3.tr.setRoll(e3.endEulerAngles.roll), e3.tr.setPitch(e3.endEulerAngles.pitch), e3.tr.setBearing(e3.endEulerAngles.bearing);
+        else e3.tr.setRoll(t2.G.number(e3.startEulerAngles.roll, e3.endEulerAngles.roll, e3.k)), e3.tr.setPitch(t2.G.number(e3.startEulerAngles.pitch, e3.endEulerAngles.pitch, e3.k)), e3.tr.setBearing(t2.G.number(e3.startEulerAngles.bearing, e3.endEulerAngles.bearing, e3.k));
+      }
+      function Ht(e3, i3, o3, a3, r3) {
+        const s3 = r3.padding, n3 = _e2(r3.worldSize, o3.getNorthWest()), l3 = _e2(r3.worldSize, o3.getNorthEast()), c3 = _e2(r3.worldSize, o3.getSouthEast()), h3 = _e2(r3.worldSize, o3.getSouthWest()), u3 = t2.am(-a3), d3 = n3.rotate(u3), _3 = l3.rotate(u3), p3 = c3.rotate(u3), m3 = h3.rotate(u3), f3 = new t2.P(Math.max(d3.x, _3.x, m3.x, p3.x), Math.max(d3.y, _3.y, m3.y, p3.y)), g3 = new t2.P(Math.min(d3.x, _3.x, m3.x, p3.x), Math.min(d3.y, _3.y, m3.y, p3.y)), v3 = f3.sub(g3), x3 = (r3.width - (s3.left + s3.right + i3.left + i3.right)) / v3.x, b3 = (r3.height - (s3.top + s3.bottom + i3.top + i3.bottom)) / v3.y;
+        if (b3 < 0 || x3 < 0) return void qt();
+        const y3 = Math.min(t2.aq(r3.scale * Math.min(x3, b3)), e3.maxZoom), w3 = t2.P.convert(e3.offset), T3 = new t2.P((i3.left - i3.right) / 2, (i3.top - i3.bottom) / 2).rotate(t2.am(a3)), P3 = w3.add(T3).mult(r3.scale / t2.an(y3));
+        return { center: pe2(r3.worldSize, n3.add(c3).div(2).sub(P3)), zoom: y3, bearing: a3 };
+      }
+      class Xt {
+        get useGlobeControls() {
+          return false;
+        }
+        handlePanInertia(e3, t3) {
+          const i3 = e3.mag(), o3 = Math.abs(me2(t3));
+          return { easingOffset: e3.mult(Math.min(0.75 * o3 / i3, 1)), easingCenter: t3.center };
+        }
+        handleMapControlsRollPitchBearingZoom(e3, t3) {
+          e3.bearingDelta && t3.setBearing(t3.bearing + e3.bearingDelta), e3.pitchDelta && t3.setPitch(t3.pitch + e3.pitchDelta), e3.rollDelta && t3.setRoll(t3.roll + e3.rollDelta), e3.zoomDelta && t3.setZoom(t3.zoom + e3.zoomDelta);
+        }
+        handleMapControlsPan(e3, t3, i3) {
+          e3.around.distSqr(t3.centerPoint) < 0.01 || t3.setLocationAtPoint(i3, e3.around);
+        }
+        cameraForBoxAndBearing(e3, t3, i3, o3, a3) {
+          return Ht(e3, t3, i3, o3, a3);
+        }
+        handleJumpToCenterZoom(e3, i3) {
+          e3.zoom !== (void 0 !== i3.zoom ? +i3.zoom : e3.zoom) && e3.setZoom(+i3.zoom), void 0 !== i3.center && e3.setCenter(t2.V.convert(i3.center));
+        }
+        handleEaseTo(e3, i3) {
+          const o3 = e3.zoom, a3 = e3.padding, r3 = { roll: e3.roll, pitch: e3.pitch, bearing: e3.bearing }, s3 = { roll: void 0 === i3.roll ? e3.roll : i3.roll, pitch: void 0 === i3.pitch ? e3.pitch : i3.pitch, bearing: void 0 === i3.bearing ? e3.bearing : i3.bearing }, n3 = void 0 !== i3.zoom, l3 = !e3.isPaddingEqual(i3.padding);
+          let c3 = false;
+          const h3 = n3 ? +i3.zoom : e3.zoom;
+          let u3 = e3.centerPoint.add(i3.offsetAsPoint);
+          const d3 = e3.screenPointToLocation(u3), { center: _3, zoom: p3 } = e3.applyConstrain(t2.V.convert(i3.center || d3), null != h3 ? h3 : o3);
+          jt(e3, _3);
+          const m3 = _e2(e3.worldSize, d3), f3 = _e2(e3.worldSize, _3).sub(m3), g3 = t2.an(p3 - o3);
+          return c3 = p3 !== o3, { easeFunc: (n4) => {
+            if (c3 && e3.setZoom(t2.G.number(o3, p3, n4)), t2.bm(r3, s3) || $t({ startEulerAngles: r3, endEulerAngles: s3, tr: e3, k: n4, useSlerp: r3.roll != s3.roll }), l3 && (e3.interpolatePadding(a3, i3.padding, n4), u3 = e3.centerPoint.add(i3.offsetAsPoint)), i3.around) e3.setLocationAtPoint(i3.around, i3.aroundPoint);
+            else {
+              const i4 = t2.an(e3.zoom - o3), a4 = p3 > o3 ? Math.min(2, g3) : Math.max(0.5, g3), r4 = Math.pow(a4, 1 - n4), s4 = pe2(e3.worldSize, m3.add(f3.mult(n4 * r4)).mult(i4));
+              e3.setLocationAtPoint(e3.renderWorldCopies ? s4.wrap() : s4, u3);
+            }
+          }, isZooming: c3, elevationCenter: _3 };
+        }
+        handleFlyTo(e3, i3) {
+          const o3 = void 0 !== i3.zoom, a3 = e3.zoom, r3 = e3.applyConstrain(t2.V.convert(i3.center || i3.locationAtOffset), o3 ? +i3.zoom : a3), s3 = r3.center, n3 = r3.zoom;
+          jt(e3, s3);
+          const l3 = _e2(e3.worldSize, i3.locationAtOffset), c3 = _e2(e3.worldSize, s3).sub(l3), h3 = c3.mag(), u3 = t2.an(n3 - a3);
+          let d3;
+          if (void 0 !== i3.minZoom) {
+            const o4 = Math.min(+i3.minZoom, a3, n3), r4 = e3.applyConstrain(s3, o4).zoom;
+            d3 = t2.an(r4 - a3);
+          }
+          return { easeFunc: (i4, o4, r4, h4) => {
+            e3.setZoom(1 === i4 ? n3 : a3 + t2.aq(o4));
+            const u4 = 1 === i4 ? s3 : pe2(e3.worldSize, l3.add(c3.mult(r4)).mult(o4));
+            e3.setLocationAtPoint(e3.renderWorldCopies ? u4.wrap() : u4, h4);
+          }, scaleOfZoom: u3, targetCenter: s3, scaleOfMinZoom: d3, pixelPathLength: h3 };
+        }
+      }
+      class Yt {
+        constructor(e3, t3, i3) {
+          this.blendFunction = e3, this.blendColor = t3, this.mask = i3;
+        }
+      }
+      Yt.Replace = [1, 0], Yt.disabled = new Yt(Yt.Replace, t2.bn.transparent, [false, false, false, false]), Yt.unblended = new Yt(Yt.Replace, t2.bn.transparent, [true, true, true, true]), Yt.alphaBlended = new Yt([1, 771], t2.bn.transparent, [true, true, true, true]);
+      const Kt = 2305;
+      class Qt {
+        constructor(e3, t3, i3) {
+          this.enable = e3, this.mode = t3, this.frontFace = i3;
+        }
+      }
+      Qt.disabled = new Qt(false, 1029, Kt), Qt.backCCW = new Qt(true, 1029, Kt), Qt.frontCCW = new Qt(true, 1028, Kt);
+      class Jt {
+        constructor(e3, t3, i3) {
+          this.func = e3, this.mask = t3, this.range = i3;
+        }
+      }
+      Jt.ReadOnly = false, Jt.ReadWrite = true, Jt.disabled = new Jt(519, Jt.ReadOnly, [0, 1]);
+      const ei2 = 7680;
+      class ti2 {
+        constructor(e3, t3, i3, o3, a3, r3) {
+          this.test = e3, this.ref = t3, this.mask = i3, this.fail = o3, this.depthFail = a3, this.pass = r3;
+        }
+      }
+      ti2.disabled = new ti2({ func: 519, mask: 0 }, 0, 0, ei2, ei2, ei2);
+      const ii2 = /* @__PURE__ */ new WeakMap();
+      function oi2(e3) {
+        var t3;
+        if (ii2.has(e3)) return ii2.get(e3);
+        {
+          const i3 = null === (t3 = e3.getParameter(e3.VERSION)) || void 0 === t3 ? void 0 : t3.startsWith("WebGL 2.0");
+          return ii2.set(e3, i3), i3;
+        }
+      }
+      class ai2 {
+        get awaitingQuery() {
+          return !!this._readbackQueue;
+        }
+        constructor(e3) {
+          this._readbackWaitFrames = 4, this._measureWaitFrames = 6, this._texWidth = 1, this._texHeight = 1, this._measuredError = 0, this._updateCount = 0, this._lastReadbackFrame = -1e3, this._readbackQueue = null, this._cachedRenderContext = e3;
+          const i3 = e3.context, o3 = i3.gl;
+          this._texFormat = o3.RGBA, this._texType = o3.UNSIGNED_BYTE;
+          const a3 = new t2.aU();
+          a3.emplaceBack(-1, -1), a3.emplaceBack(2, -1), a3.emplaceBack(-1, 2);
+          const r3 = new t2.aW();
+          r3.emplaceBack(0, 1, 2), this._fullscreenTriangle = new At(i3.createVertexBuffer(a3, Lt.members), i3.createIndexBuffer(r3), t2.aV.simpleSegment(0, 0, a3.length, r3.length)), this._resultBuffer = new Uint8Array(4), i3.activeTexture.set(o3.TEXTURE1);
+          const s3 = o3.createTexture();
+          o3.bindTexture(o3.TEXTURE_2D, s3), o3.texParameteri(o3.TEXTURE_2D, o3.TEXTURE_WRAP_S, o3.CLAMP_TO_EDGE), o3.texParameteri(o3.TEXTURE_2D, o3.TEXTURE_WRAP_T, o3.CLAMP_TO_EDGE), o3.texParameteri(o3.TEXTURE_2D, o3.TEXTURE_MIN_FILTER, o3.NEAREST), o3.texParameteri(o3.TEXTURE_2D, o3.TEXTURE_MAG_FILTER, o3.NEAREST), o3.texImage2D(o3.TEXTURE_2D, 0, this._texFormat, this._texWidth, this._texHeight, 0, this._texFormat, this._texType, null), this._fbo = i3.createFramebuffer(this._texWidth, this._texHeight, false, false), this._fbo.colorAttachment.set(s3), oi2(o3) && (this._pbo = o3.createBuffer(), o3.bindBuffer(o3.PIXEL_PACK_BUFFER, this._pbo), o3.bufferData(o3.PIXEL_PACK_BUFFER, 4, o3.STREAM_READ), o3.bindBuffer(o3.PIXEL_PACK_BUFFER, null));
+        }
+        destroy() {
+          const e3 = this._cachedRenderContext.context.gl;
+          this._fullscreenTriangle.destroy(), this._fbo.destroy(), e3.deleteBuffer(this._pbo), this._fullscreenTriangle = null, this._fbo = null, this._pbo = null, this._resultBuffer = null;
+        }
+        updateErrorLoop(e3, t3) {
+          const i3 = this._updateCount;
+          return this._readbackQueue ? i3 >= this._readbackQueue.frameNumberIssued + this._readbackWaitFrames && this._tryReadback() : i3 >= this._lastReadbackFrame + this._measureWaitFrames && this._renderErrorTexture(e3, t3), this._updateCount++, this._measuredError;
+        }
+        _bindFramebuffer() {
+          const e3 = this._cachedRenderContext.context, t3 = e3.gl;
+          e3.activeTexture.set(t3.TEXTURE1), t3.bindTexture(t3.TEXTURE_2D, this._fbo.colorAttachment.get()), e3.bindFramebuffer.set(this._fbo.framebuffer);
+        }
+        _renderErrorTexture(e3, i3) {
+          const o3 = this._cachedRenderContext.context, a3 = o3.gl;
+          if (this._bindFramebuffer(), o3.viewport.set([0, 0, this._texWidth, this._texHeight]), o3.clear({ color: t2.bn.transparent }), this._cachedRenderContext.useProgram("projectionErrorMeasurement").draw(o3, a3.TRIANGLES, Jt.disabled, ti2.disabled, Yt.unblended, Qt.disabled, /* @__PURE__ */ ((e4, t3) => ({ u_input: e4, u_output_expected: t3 }))(e3, i3), null, null, "$clipping", this._fullscreenTriangle.vertexBuffer, this._fullscreenTriangle.indexBuffer, this._fullscreenTriangle.segments), this._pbo && oi2(a3)) {
+            a3.bindBuffer(a3.PIXEL_PACK_BUFFER, this._pbo), a3.readBuffer(a3.COLOR_ATTACHMENT0), a3.readPixels(0, 0, this._texWidth, this._texHeight, this._texFormat, this._texType, 0), a3.bindBuffer(a3.PIXEL_PACK_BUFFER, null);
+            const e4 = a3.fenceSync(a3.SYNC_GPU_COMMANDS_COMPLETE, 0);
+            a3.flush(), this._readbackQueue = { frameNumberIssued: this._updateCount, sync: e4 };
+          } else this._readbackQueue = { frameNumberIssued: this._updateCount, sync: null };
+        }
+        _tryReadback() {
+          const e3 = this._cachedRenderContext.context.gl;
+          if (this._pbo && this._readbackQueue && oi2(e3)) {
+            const i3 = e3.clientWaitSync(this._readbackQueue.sync, 0, 0);
+            if (i3 === e3.WAIT_FAILED) return t2.w("WebGL2 clientWaitSync failed."), this._readbackQueue = null, void (this._lastReadbackFrame = this._updateCount);
+            if (i3 === e3.TIMEOUT_EXPIRED) return;
+            e3.bindBuffer(e3.PIXEL_PACK_BUFFER, this._pbo), e3.getBufferSubData(e3.PIXEL_PACK_BUFFER, 0, this._resultBuffer, 0, 4), e3.bindBuffer(e3.PIXEL_PACK_BUFFER, null);
+          } else this._bindFramebuffer(), e3.readPixels(0, 0, this._texWidth, this._texHeight, this._texFormat, this._texType, this._resultBuffer);
+          this._readbackQueue = null, this._measuredError = ai2._parseRGBA8float(this._resultBuffer), this._lastReadbackFrame = this._updateCount;
+        }
+        static _parseRGBA8float(e3) {
+          let t3 = 0;
+          return t3 += e3[0] / 256, t3 += e3[1] / 65536, t3 += e3[2] / 16777216, e3[3] < 127 && (t3 = -t3), t3 / 128;
+        }
+      }
+      const ri2 = t2.a5 / 128;
+      function si2(e3, i3) {
+        const o3 = void 0 !== e3.granularity ? Math.max(e3.granularity, 1) : 1, a3 = o3 + (e3.generateBorders ? 2 : 0), r3 = o3 + (e3.extendToNorthPole || e3.generateBorders ? 1 : 0) + (e3.extendToSouthPole || e3.generateBorders ? 1 : 0), s3 = a3 + 1, n3 = r3 + 1, l3 = e3.generateBorders ? -1 : 0, c3 = e3.generateBorders || e3.extendToNorthPole ? -1 : 0, h3 = o3 + (e3.generateBorders ? 1 : 0), u3 = o3 + (e3.generateBorders || e3.extendToSouthPole ? 1 : 0), d3 = s3 * n3, _3 = a3 * r3 * 6, p3 = s3 * n3 > 65536;
+        if (p3 && "16bit" === i3) throw new Error("Granularity is too large and meshes would not fit inside 16 bit vertex indices.");
+        const m3 = p3 || "32bit" === i3, f3 = new Int16Array(2 * d3);
+        let g3 = 0;
+        for (let i4 = c3; i4 <= u3; i4++) for (let a4 = l3; a4 <= h3; a4++) {
+          let r4 = a4 / o3 * t2.a5;
+          -1 === a4 && (r4 = -ri2), a4 === o3 + 1 && (r4 = t2.a5 + ri2);
+          let s4 = i4 / o3 * t2.a5;
+          -1 === i4 && (s4 = e3.extendToNorthPole ? t2.bp : -ri2), i4 === o3 + 1 && (s4 = e3.extendToSouthPole ? t2.bq : t2.a5 + ri2), f3[g3++] = r4, f3[g3++] = s4;
+        }
+        const v3 = m3 ? new Uint32Array(_3) : new Uint16Array(_3);
+        let x3 = 0;
+        for (let e4 = 0; e4 < r3; e4++) for (let t3 = 0; t3 < a3; t3++) {
+          const i4 = t3 + 1 + e4 * s3, o4 = t3 + (e4 + 1) * s3, a4 = t3 + 1 + (e4 + 1) * s3;
+          v3[x3++] = t3 + e4 * s3, v3[x3++] = o4, v3[x3++] = i4, v3[x3++] = i4, v3[x3++] = o4, v3[x3++] = a4;
+        }
+        return { vertices: f3.buffer.slice(0), indices: v3.buffer.slice(0), uses32bitIndices: m3 };
+      }
+      const ni2 = new t2.aT({ fill: new t2.br(128, 2), line: new t2.br(512, 0), tile: new t2.br(128, 32), stencil: new t2.br(128, 1), circle: 3 });
+      class li2 {
+        constructor() {
+          this._tileMeshCache = {}, this._errorCorrectionUsable = 0, this._errorMeasurementLastValue = 0, this._errorCorrectionPreviousValue = 0, this._errorMeasurementLastChangeTime = -1e3;
+        }
+        get name() {
+          return "vertical-perspective";
+        }
+        get transitionState() {
+          return 1;
+        }
+        get useSubdivision() {
+          return true;
+        }
+        get shaderVariantName() {
+          return "globe";
+        }
+        get shaderDefine() {
+          return "#define GLOBE";
+        }
+        get shaderPreludeCode() {
+          return zt.projectionGlobe;
+        }
+        get vertexShaderPreludeCode() {
+          return zt.projectionMercator.vertexSource;
+        }
+        get subdivisionGranularity() {
+          return ni2;
+        }
+        get useGlobeControls() {
+          return true;
+        }
+        get latitudeErrorCorrectionRadians() {
+          return this._errorCorrectionUsable;
+        }
+        destroy() {
+          this._errorMeasurement && this._errorMeasurement.destroy();
+        }
+        updateGPUdependent(e3) {
+          this._errorMeasurement || (this._errorMeasurement = new ai2(e3));
+          const i3 = t2.X(this._errorQueryLatitudeDegrees), o3 = 2 * Math.atan(Math.exp(Math.PI - i3 * Math.PI * 2)) - 0.5 * Math.PI, a3 = this._errorMeasurement.updateErrorLoop(i3, o3), r3 = c2();
+          a3 !== this._errorMeasurementLastValue && (this._errorCorrectionPreviousValue = this._errorCorrectionUsable, this._errorMeasurementLastValue = a3, this._errorMeasurementLastChangeTime = r3);
+          const s3 = Math.min(Math.max((r3 - this._errorMeasurementLastChangeTime) / 1e3 / 0.5, 0), 1);
+          this._errorCorrectionUsable = t2.bs(this._errorCorrectionPreviousValue, -this._errorMeasurementLastValue, t2.bt(s3));
+        }
+        _getMeshKey(e3) {
+          return `${e3.granularity.toString(36)}_${e3.generateBorders ? "b" : ""}${e3.extendToNorthPole ? "n" : ""}${e3.extendToSouthPole ? "s" : ""}`;
+        }
+        getMeshFromTileID(e3, t3, i3, o3, a3) {
+          const r3 = ("stencil" === a3 ? ni2.stencil : ni2.tile).getGranularityForZoomLevel(t3.z);
+          return this._getMesh(e3, { granularity: r3, generateBorders: i3, extendToNorthPole: 0 === t3.y && o3, extendToSouthPole: t3.y === (1 << t3.z) - 1 && o3 });
+        }
+        _getMesh(e3, i3) {
+          const o3 = this._getMeshKey(i3);
+          if (o3 in this._tileMeshCache) return this._tileMeshCache[o3];
+          const a3 = function(e4, i4) {
+            const o4 = si2(i4, "16bit"), a4 = t2.aU.deserialize({ arrayBuffer: o4.vertices, length: o4.vertices.byteLength / 2 / 2 }), r3 = t2.aW.deserialize({ arrayBuffer: o4.indices, length: o4.indices.byteLength / 2 / 3 });
+            return new At(e4.createVertexBuffer(a4, Lt.members), e4.createIndexBuffer(r3), t2.aV.simpleSegment(0, 0, a4.length, r3.length));
+          }(e3, i3);
+          return this._tileMeshCache[o3] = a3, a3;
+        }
+        recalculate(e3) {
+        }
+        hasTransition() {
+          const e3 = c2();
+          let t3 = false;
+          return t3 = t3 || (e3 - this._errorMeasurementLastChangeTime) / 1e3 < 0.7, t3 = t3 || this._errorMeasurement && this._errorMeasurement.awaitingQuery, t3;
+        }
+        setErrorQueryLatitudeDegrees(e3) {
+          this._errorQueryLatitudeDegrees = e3;
+        }
+      }
+      const ci2 = new t2.t({ type: new t2.D(t2.u.projection.type) });
+      class hi2 extends t2.E {
+        constructor(e3) {
+          super(), this._transitionable = new t2.x(ci2, void 0), this.setProjection(e3), this._transitioning = this._transitionable.untransitioned(), this.recalculate(new t2.H(0)), this._mercatorProjection = new Bt(), this._verticalPerspectiveProjection = new li2();
+        }
+        get transitionState() {
+          const e3 = this.properties.get("type");
+          if ("string" == typeof e3 && "mercator" === e3) return 0;
+          if ("string" == typeof e3 && "vertical-perspective" === e3) return 1;
+          if (e3 instanceof t2.bu) {
+            if ("vertical-perspective" === e3.from && "mercator" === e3.to) return 1 - e3.transition;
+            if ("mercator" === e3.from && "vertical-perspective" === e3.to) return e3.transition;
+          }
+          return 1;
+        }
+        get useGlobeRendering() {
+          return this.transitionState > 0;
+        }
+        get latitudeErrorCorrectionRadians() {
+          return this._verticalPerspectiveProjection.latitudeErrorCorrectionRadians;
+        }
+        get currentProjection() {
+          return this.useGlobeRendering ? this._verticalPerspectiveProjection : this._mercatorProjection;
+        }
+        get name() {
+          return "globe";
+        }
+        get useSubdivision() {
+          return this.currentProjection.useSubdivision;
+        }
+        get shaderVariantName() {
+          return this.currentProjection.shaderVariantName;
+        }
+        get shaderDefine() {
+          return this.currentProjection.shaderDefine;
+        }
+        get shaderPreludeCode() {
+          return this.currentProjection.shaderPreludeCode;
+        }
+        get vertexShaderPreludeCode() {
+          return this.currentProjection.vertexShaderPreludeCode;
+        }
+        get subdivisionGranularity() {
+          return this.currentProjection.subdivisionGranularity;
+        }
+        get useGlobeControls() {
+          return this.transitionState > 0;
+        }
+        destroy() {
+          this._mercatorProjection.destroy(), this._verticalPerspectiveProjection.destroy();
+        }
+        updateGPUdependent(e3) {
+          this._mercatorProjection.updateGPUdependent(e3), this._verticalPerspectiveProjection.updateGPUdependent(e3);
+        }
+        getMeshFromTileID(e3, t3, i3, o3, a3) {
+          return this.currentProjection.getMeshFromTileID(e3, t3, i3, o3, a3);
+        }
+        setProjection(e3) {
+          this._transitionable.setValue("type", (null == e3 ? void 0 : e3.type) || "mercator");
+        }
+        updateTransitions(e3) {
+          this._transitioning = this._transitionable.transitioned(e3, this._transitioning);
+        }
+        hasTransition() {
+          return this._transitioning.hasTransition() || this.currentProjection.hasTransition();
+        }
+        recalculate(e3) {
+          this.properties = this._transitioning.possiblyEvaluate(e3);
+        }
+        setErrorQueryLatitudeDegrees(e3) {
+          this._verticalPerspectiveProjection.setErrorQueryLatitudeDegrees(e3), this._mercatorProjection.setErrorQueryLatitudeDegrees(e3);
+        }
+      }
+      function ui2(e3) {
+        const t3 = pi2(e3.worldSize, e3.center.lat);
+        return 2 * Math.PI * t3;
+      }
+      function di2(e3, i3, o3, a3, r3) {
+        const s3 = 1 / (1 << r3), n3 = i3 / t2.a5 * s3 + a3 * s3, l3 = t2.bx((e3 / t2.a5 * s3 + o3 * s3) * Math.PI * 2 + Math.PI, 2 * Math.PI), c3 = 2 * Math.atan(Math.exp(Math.PI - n3 * Math.PI * 2)) - 0.5 * Math.PI, h3 = Math.cos(c3), u3 = new Float64Array(3);
+        return u3[0] = Math.sin(l3) * h3, u3[1] = Math.sin(c3), u3[2] = Math.cos(l3) * h3, u3;
+      }
+      function _i(e3) {
+        return function(e4, t3) {
+          const i3 = Math.cos(t3), o3 = new Float64Array(3);
+          return o3[0] = Math.sin(e4) * i3, o3[1] = Math.sin(t3), o3[2] = Math.cos(e4) * i3, o3;
+        }(e3.lng * Math.PI / 180, e3.lat * Math.PI / 180);
+      }
+      function pi2(e3, t3) {
+        return e3 / (2 * Math.PI) / Math.cos(t3 * Math.PI / 180);
+      }
+      function mi2(e3) {
+        const i3 = Math.asin(e3[1]) / Math.PI * 180, o3 = Math.sqrt(e3[0] * e3[0] + e3[2] * e3[2]);
+        if (o3 > 1e-6) {
+          const a3 = e3[0] / o3, r3 = Math.acos(e3[2] / o3), s3 = (a3 > 0 ? r3 : -r3) / Math.PI * 180;
+          return new t2.V(t2.W(s3, -180, 180), i3);
+        }
+        return new t2.V(0, i3);
+      }
+      function fi2(e3) {
+        return Math.cos(e3 * Math.PI / 180);
+      }
+      function gi2(e3, i3) {
+        const o3 = fi2(e3), a3 = fi2(i3);
+        return t2.aq(a3 / o3);
+      }
+      function vi2(e3, i3) {
+        const o3 = e3.rotate(i3.bearingInRadians), a3 = i3.zoom + gi2(i3.center.lat, 0), r3 = t2.bs(1 / fi2(i3.center.lat), 1 / fi2(Math.min(Math.abs(i3.center.lat), 60)), t2.bv(a3, 7, 3, 0, 1)), s3 = 360 / ui2({ worldSize: i3.worldSize, center: { lat: i3.center.lat } });
+        return new t2.V(i3.center.lng - o3.x * s3 * r3, t2.ak(i3.center.lat + o3.y * s3, -t2.al, t2.al));
+      }
+      function xi2(e3) {
+        const t3 = 0.5 * e3, i3 = Math.sin(t3), o3 = Math.cos(t3);
+        return Math.log(i3 + o3) - Math.log(o3 - i3);
+      }
+      function bi2(e3, i3, o3, a3) {
+        const r3 = e3.lat + o3 * a3;
+        if (Math.abs(o3) > 1) {
+          const s3 = (Math.sign(e3.lat + o3) !== Math.sign(e3.lat) ? -Math.abs(e3.lat) : Math.abs(e3.lat)) * Math.PI / 180, n3 = Math.abs(e3.lat + o3) * Math.PI / 180, l3 = xi2(s3 + a3 * (n3 - s3)), c3 = xi2(s3), h3 = xi2(n3);
+          return new t2.V(e3.lng + i3 * ((l3 - c3) / (h3 - c3)), r3);
+        }
+        return new t2.V(e3.lng + i3 * a3, r3);
+      }
+      class yi2 {
+        constructor(e3) {
+          this._cachePrevious = /* @__PURE__ */ new Map(), this._cache = /* @__PURE__ */ new Map(), this._hadAnyChanges = false, this._boundingVolumeFactory = e3;
+        }
+        swapBuffers() {
+          if (!this._hadAnyChanges) return;
+          const e3 = this._cachePrevious;
+          this._cachePrevious = this._cache, this._cache = e3, this._cache.clear(), this._hadAnyChanges = false;
+        }
+        getTileBoundingVolume(e3, t3, i3, o3) {
+          const a3 = `${e3.z}_${e3.x}_${e3.y}_${(null == o3 ? void 0 : o3.terrain) ? "t" : ""}`, r3 = this._cache.get(a3);
+          if (r3) return r3;
+          const s3 = this._cachePrevious.get(a3);
+          if (s3) return this._cache.set(a3, s3), s3;
+          const n3 = this._boundingVolumeFactory(e3, t3, i3, o3);
+          return this._cache.set(a3, n3), this._hadAnyChanges = true, n3;
+        }
+      }
+      class wi2 {
+        constructor(e3, t3, i3, o3) {
+          this.min = i3, this.max = o3, this.points = e3, this.planes = t3;
+        }
+        static fromAabb(e3, t3) {
+          const i3 = [];
+          for (let o3 = 0; o3 < 8; o3++) i3.push([1 & ~o3 ? e3[0] : t3[0], 1 == (o3 >> 1 & 1) ? t3[1] : e3[1], 1 == (o3 >> 2 & 1) ? t3[2] : e3[2]]);
+          return new wi2(i3, [[-1, 0, 0, t3[0]], [1, 0, 0, -e3[0]], [0, -1, 0, t3[1]], [0, 1, 0, -e3[1]], [0, 0, -1, t3[2]], [0, 0, 1, -e3[2]]], e3, t3);
+        }
+        static fromCenterSizeAngles(e3, i3, o3) {
+          const a3 = t2.bz([], o3[0], o3[1], o3[2]), r3 = t2.bA([], [i3[0], 0, 0], a3), s3 = t2.bA([], [0, i3[1], 0], a3), n3 = t2.bA([], [0, 0, i3[2]], a3), l3 = [...e3], c3 = [...e3];
+          for (let t3 = 0; t3 < 8; t3++) for (let i4 = 0; i4 < 3; i4++) {
+            const o4 = e3[i4] + r3[i4] * (1 & ~t3 ? -1 : 1) + s3[i4] * (1 == (t3 >> 1 & 1) ? 1 : -1) + n3[i4] * (1 == (t3 >> 2 & 1) ? 1 : -1);
+            l3[i4] = Math.min(l3[i4], o4), c3[i4] = Math.max(c3[i4], o4);
+          }
+          const h3 = [];
+          for (let i4 = 0; i4 < 8; i4++) {
+            const o4 = [...e3];
+            t2.a_(o4, o4, t2.aZ([], r3, 1 & ~i4 ? -1 : 1)), t2.a_(o4, o4, t2.aZ([], s3, 1 == (i4 >> 1 & 1) ? 1 : -1)), t2.a_(o4, o4, t2.aZ([], n3, 1 == (i4 >> 2 & 1) ? 1 : -1)), h3.push(o4);
+          }
+          return new wi2(h3, [[...r3, -t2.b3(r3, h3[0])], [...s3, -t2.b3(s3, h3[0])], [...n3, -t2.b3(n3, h3[0])], [-r3[0], -r3[1], -r3[2], -t2.b3(r3, h3[7])], [-s3[0], -s3[1], -s3[2], -t2.b3(s3, h3[7])], [-n3[0], -n3[1], -n3[2], -t2.b3(n3, h3[7])]], l3, c3);
+        }
+        intersectsFrustum(e3) {
+          let t3 = true;
+          const i3 = this.points.length, o3 = this.planes.length, a3 = e3.planes.length, r3 = e3.points.length;
+          for (let o4 = 0; o4 < a3; o4++) {
+            const a4 = e3.planes[o4];
+            let r4 = 0;
+            for (let e4 = 0; e4 < i3; e4++) {
+              const t4 = this.points[e4];
+              a4[0] * t4[0] + a4[1] * t4[1] + a4[2] * t4[2] + a4[3] >= 0 && r4++;
+            }
+            if (0 === r4) return 0;
+            r4 < i3 && (t3 = false);
+          }
+          if (t3) return 2;
+          for (let t4 = 0; t4 < o3; t4++) {
+            const i4 = this.planes[t4];
+            let o4 = 0;
+            for (let t5 = 0; t5 < r3; t5++) {
+              const a4 = e3.points[t5];
+              i4[0] * a4[0] + i4[1] * a4[1] + i4[2] * a4[2] + i4[3] >= 0 && o4++;
+            }
+            if (0 === o4) return 0;
+          }
+          return 1;
+        }
+        intersectsPlane(e3) {
+          const t3 = this.points.length;
+          let i3 = 0;
+          for (let o3 = 0; o3 < t3; o3++) {
+            const t4 = this.points[o3];
+            e3[0] * t4[0] + e3[1] * t4[1] + e3[2] * t4[2] + e3[3] >= 0 && i3++;
+          }
+          return i3 === t3 ? 2 : 0 === i3 ? 0 : 1;
+        }
+      }
+      function Ti2(e3, t3, i3) {
+        const o3 = e3 - t3;
+        return o3 < 0 ? -o3 : Math.max(0, o3 - i3);
+      }
+      function Pi2(e3, t3, i3, o3, a3) {
+        const r3 = e3 - i3;
+        let s3;
+        return s3 = r3 < 0 ? Math.min(-r3, 1 + r3 - a3) : r3 > a3 ? Math.min(Math.max(r3 - a3, 0), 1 - r3) : 0, Math.max(s3, Ti2(t3, o3, a3));
+      }
+      class Ci2 {
+        constructor() {
+          this._boundingVolumeCache = new yi2(this._computeTileBoundingVolume);
+        }
+        prepareNextFrame() {
+          this._boundingVolumeCache.swapBuffers();
+        }
+        distanceToTile2d(e3, t3, i3, o3) {
+          const a3 = 1 << i3.z, r3 = 1 / a3, s3 = i3.x / a3, n3 = i3.y / a3;
+          let l3 = 2;
+          return l3 = Math.min(l3, Pi2(e3, t3, s3, n3, r3)), l3 = Math.min(l3, Pi2(e3, t3, s3 + 0.5, -n3 - r3, r3)), l3 = Math.min(l3, Pi2(e3, t3, s3 + 0.5, 2 - n3 - r3, r3)), l3;
+        }
+        getWrap(e3, t3, i3) {
+          const o3 = 1 << t3.z, a3 = 1 / o3, r3 = t3.x / o3, s3 = Ti2(e3.x, r3, a3), n3 = Ti2(e3.x, r3 - 1, a3), l3 = Ti2(e3.x, r3 + 1, a3), c3 = Math.min(s3, n3, l3);
+          return c3 === l3 ? 1 : c3 === n3 ? -1 : 0;
+        }
+        allowVariableZoom(e3, t3) {
+          return Te2(e3, t3) > 4;
+        }
+        allowWorldCopies() {
+          return false;
+        }
+        getTileBoundingVolume(e3, t3, i3, o3) {
+          return this._boundingVolumeCache.getTileBoundingVolume(e3, t3, i3, o3);
+        }
+        _computeTileBoundingVolume(e3, i3, o3, a3) {
+          var r3, s3;
+          let n3 = 0, l3 = 0;
+          if (null == a3 ? void 0 : a3.terrain) {
+            const c3 = new t2.a2(e3.z, i3, e3.z, e3.x, e3.y), h3 = a3.terrain.getMinMaxElevation(c3);
+            n3 = null !== (r3 = h3.minElevation) && void 0 !== r3 ? r3 : Math.min(0, o3), l3 = null !== (s3 = h3.maxElevation) && void 0 !== s3 ? s3 : Math.max(0, o3);
+          }
+          if (n3 /= t2.bC, l3 /= t2.bC, n3 += 1, l3 += 1, e3.z <= 0) return wi2.fromAabb([-l3, -l3, -l3], [l3, l3, l3]);
+          if (1 === e3.z) return wi2.fromAabb([0 === e3.x ? -l3 : 0, 0 === e3.y ? 0 : -l3, -l3], [0 === e3.x ? 0 : l3, 0 === e3.y ? l3 : 0, l3]);
+          {
+            const i4 = [di2(0, 0, e3.x, e3.y, e3.z), di2(t2.a5, 0, e3.x, e3.y, e3.z), di2(t2.a5, t2.a5, e3.x, e3.y, e3.z), di2(0, t2.a5, e3.x, e3.y, e3.z)], o4 = [];
+            for (const e4 of i4) o4.push(t2.aZ([], e4, l3));
+            if (l3 !== n3) for (const e4 of i4) o4.push(t2.aZ([], e4, n3));
+            0 === e3.y && o4.push([0, 1, 0]), e3.y === (1 << e3.z) - 1 && o4.push([0, -1, 0]);
+            const a4 = [1, 1, 1], r4 = [-1, -1, -1];
+            for (const e4 of o4) for (let t3 = 0; t3 < 3; t3++) a4[t3] = Math.min(a4[t3], e4[t3]), r4[t3] = Math.max(r4[t3], e4[t3]);
+            const s4 = di2(t2.a5 / 2, t2.a5 / 2, e3.x, e3.y, e3.z), c3 = t2.b2([], [0, 1, 0], s4);
+            t2.b1(c3, c3);
+            const h3 = t2.b2([], s4, c3);
+            t2.b1(h3, h3);
+            const u3 = t2.b2([], i4[2], i4[1]);
+            t2.b1(u3, u3);
+            const d3 = t2.b2([], i4[0], i4[3]);
+            t2.b1(d3, d3), o4.push(t2.aZ([], s4, l3)), e3.y >= (1 << e3.z) / 2 && o4.push(t2.aZ([], di2(t2.a5 / 2, 0, e3.x, e3.y, e3.z), l3)), e3.y < (1 << e3.z) / 2 && o4.push(t2.aZ([], di2(t2.a5 / 2, t2.a5, e3.x, e3.y, e3.z), l3));
+            const _3 = Ii2(s4, o4), p3 = Ii2(h3, o4), m3 = [-s4[0], -s4[1], -s4[2], _3.max], f3 = [s4[0], s4[1], s4[2], -_3.min], g3 = [-h3[0], -h3[1], -h3[2], p3.max], v3 = [h3[0], h3[1], h3[2], -p3.min], x3 = [...u3, 0], b3 = [...d3, 0], y3 = [];
+            return 0 === e3.y ? y3.push(t2.bB(b3, x3, m3), t2.bB(b3, x3, f3)) : y3.push(t2.bB(g3, x3, m3), t2.bB(g3, x3, f3), t2.bB(g3, b3, m3), t2.bB(g3, b3, f3)), e3.y === (1 << e3.z) - 1 ? y3.push(t2.bB(b3, x3, m3), t2.bB(b3, x3, f3)) : y3.push(t2.bB(v3, x3, m3), t2.bB(v3, x3, f3), t2.bB(v3, b3, m3), t2.bB(v3, b3, f3)), new wi2(y3, [m3, f3, g3, v3, x3, b3], a4, r4);
+          }
+        }
+      }
+      function Ii2(e3, i3) {
+        let o3 = 1 / 0, a3 = -1 / 0;
+        for (const r3 of i3) {
+          const i4 = t2.b3(e3, r3);
+          o3 = Math.min(o3, i4), a3 = Math.max(a3, i4);
+        }
+        return { min: o3, max: a3 };
+      }
+      class Mi2 {
+        get pixelsToClipSpaceMatrix() {
+          return this._helper.pixelsToClipSpaceMatrix;
+        }
+        get clipSpaceToPixelsMatrix() {
+          return this._helper.clipSpaceToPixelsMatrix;
+        }
+        get pixelsToGLUnits() {
+          return this._helper.pixelsToGLUnits;
+        }
+        get centerOffset() {
+          return this._helper.centerOffset;
+        }
+        get size() {
+          return this._helper.size;
+        }
+        get rotationMatrix() {
+          return this._helper.rotationMatrix;
+        }
+        get centerPoint() {
+          return this._helper.centerPoint;
+        }
+        get pixelsPerMeter() {
+          return this._helper.pixelsPerMeter;
+        }
+        setMinZoom(e3) {
+          this._helper.setMinZoom(e3);
+        }
+        setMaxZoom(e3) {
+          this._helper.setMaxZoom(e3);
+        }
+        setMinPitch(e3) {
+          this._helper.setMinPitch(e3);
+        }
+        setMaxPitch(e3) {
+          this._helper.setMaxPitch(e3);
+        }
+        setRenderWorldCopies(e3) {
+          this._helper.setRenderWorldCopies(e3);
+        }
+        setBearing(e3) {
+          this._helper.setBearing(e3);
+        }
+        setPitch(e3) {
+          this._helper.setPitch(e3);
+        }
+        setRoll(e3) {
+          this._helper.setRoll(e3);
+        }
+        setFov(e3) {
+          this._helper.setFov(e3);
+        }
+        setZoom(e3) {
+          this._helper.setZoom(e3);
+        }
+        setCenter(e3) {
+          this._helper.setCenter(e3);
+        }
+        setElevation(e3) {
+          this._helper.setElevation(e3);
+        }
+        setMinElevationForCurrentTile(e3) {
+          this._helper.setMinElevationForCurrentTile(e3);
+        }
+        setPadding(e3) {
+          this._helper.setPadding(e3);
+        }
+        interpolatePadding(e3, t3, i3) {
+          return this._helper.interpolatePadding(e3, t3, i3);
+        }
+        isPaddingEqual(e3) {
+          return this._helper.isPaddingEqual(e3);
+        }
+        resize(e3, t3) {
+          this._helper.resize(e3, t3);
+        }
+        getMaxBounds() {
+          return this._helper.getMaxBounds();
+        }
+        setMaxBounds(e3) {
+          this._helper.setMaxBounds(e3);
+        }
+        setConstrainOverride(e3) {
+          this._helper.setConstrainOverride(e3);
+        }
+        overrideNearFarZ(e3, t3) {
+          this._helper.overrideNearFarZ(e3, t3);
+        }
+        clearNearFarZOverride() {
+          this._helper.clearNearFarZOverride();
+        }
+        getCameraQueryGeometry(e3) {
+          return this._helper.getCameraQueryGeometry(this.getCameraPoint(), e3);
+        }
+        get tileSize() {
+          return this._helper.tileSize;
+        }
+        get tileZoom() {
+          return this._helper.tileZoom;
+        }
+        get scale() {
+          return this._helper.scale;
+        }
+        get worldSize() {
+          return this._helper.worldSize;
+        }
+        get width() {
+          return this._helper.width;
+        }
+        get height() {
+          return this._helper.height;
+        }
+        get lngRange() {
+          return this._helper.lngRange;
+        }
+        get latRange() {
+          return this._helper.latRange;
+        }
+        get minZoom() {
+          return this._helper.minZoom;
+        }
+        get maxZoom() {
+          return this._helper.maxZoom;
+        }
+        get zoom() {
+          return this._helper.zoom;
+        }
+        get center() {
+          return this._helper.center;
+        }
+        get minPitch() {
+          return this._helper.minPitch;
+        }
+        get maxPitch() {
+          return this._helper.maxPitch;
+        }
+        get pitch() {
+          return this._helper.pitch;
+        }
+        get pitchInRadians() {
+          return this._helper.pitchInRadians;
+        }
+        get roll() {
+          return this._helper.roll;
+        }
+        get rollInRadians() {
+          return this._helper.rollInRadians;
+        }
+        get bearing() {
+          return this._helper.bearing;
+        }
+        get bearingInRadians() {
+          return this._helper.bearingInRadians;
+        }
+        get fov() {
+          return this._helper.fov;
+        }
+        get fovInRadians() {
+          return this._helper.fovInRadians;
+        }
+        get elevation() {
+          return this._helper.elevation;
+        }
+        get minElevationForCurrentTile() {
+          return this._helper.minElevationForCurrentTile;
+        }
+        get padding() {
+          return this._helper.padding;
+        }
+        get unmodified() {
+          return this._helper.unmodified;
+        }
+        get renderWorldCopies() {
+          return this._helper.renderWorldCopies;
+        }
+        get constrainOverride() {
+          return this._helper.constrainOverride;
+        }
+        get nearZ() {
+          return this._helper.nearZ;
+        }
+        get farZ() {
+          return this._helper.farZ;
+        }
+        get autoCalculateNearFarZ() {
+          return this._helper.autoCalculateNearFarZ;
+        }
+        setTransitionState(e3) {
+        }
+        constructor(e3) {
+          this._cachedClippingPlane = t2.bD(), this._projectionMatrix = t2.bh(), this._globeViewProjMatrix32f = t2.bg(), this._globeViewProjMatrixNoCorrection = t2.bh(), this._globeViewProjMatrixNoCorrectionInverted = t2.bh(), this._globeProjMatrixInverted = t2.bh(), this._cameraPosition = t2.by(), this._globeLatitudeErrorCorrectionRadians = 0, this.defaultConstrain = (e4, i3) => {
+            const o3 = t2.ak(e4.lat, -t2.al, t2.al), a3 = t2.ak(+i3, this.minZoom + gi2(0, o3), this.maxZoom);
+            return { center: new t2.V(e4.lng, o3), zoom: a3 };
+          }, this.applyConstrain = (e4, t3) => this._helper.applyConstrain(e4, t3), this._helper = new Zt({ calcMatrices: () => {
+            this._calcMatrices();
+          }, defaultConstrain: (e4, t3) => this.defaultConstrain(e4, t3) }, e3), this._coveringTilesDetailsProvider = new Ci2();
+        }
+        clone() {
+          const e3 = new Mi2();
+          return e3.apply(this, false), e3;
+        }
+        apply(e3, t3, i3) {
+          this._globeLatitudeErrorCorrectionRadians = i3 || 0, this._helper.apply(e3, t3);
+        }
+        get projectionMatrix() {
+          return this._projectionMatrix;
+        }
+        get modelViewProjectionMatrix() {
+          return this._globeViewProjMatrixNoCorrection;
+        }
+        get inverseProjectionMatrix() {
+          return this._globeProjMatrixInverted;
+        }
+        get cameraPosition() {
+          const e3 = t2.by();
+          return e3[0] = this._cameraPosition[0], e3[1] = this._cameraPosition[1], e3[2] = this._cameraPosition[2], e3;
+        }
+        get cameraToCenterDistance() {
+          return this._helper.cameraToCenterDistance;
+        }
+        getProjectionData(e3) {
+          const { overscaledTileID: t3, applyGlobeMatrix: i3 } = e3, o3 = this._helper.getMercatorTileCoordinates(t3);
+          return { mainMatrix: this._globeViewProjMatrix32f, tileMercatorCoords: o3, clippingPlane: this._cachedClippingPlane, projectionTransition: i3 ? 1 : 0, fallbackMatrix: this._globeViewProjMatrix32f };
+        }
+        _computeClippingPlane(e3) {
+          const i3 = this.pitchInRadians, o3 = this.cameraToCenterDistance / e3, a3 = Math.sin(i3) * o3, r3 = Math.cos(i3) * o3 + 1, s3 = 1 / Math.sqrt(a3 * a3 + r3 * r3) * 1;
+          let n3 = -a3, l3 = r3;
+          const c3 = Math.sqrt(n3 * n3 + l3 * l3);
+          n3 /= c3, l3 /= c3;
+          const h3 = [0, n3, l3];
+          t2.bE(h3, h3, [0, 0, 0], -this.bearingInRadians), t2.bF(h3, h3, [0, 0, 0], -1 * this.center.lat * Math.PI / 180), t2.bG(h3, h3, [0, 0, 0], this.center.lng * Math.PI / 180);
+          const u3 = 1 / t2.b5(h3);
+          return t2.aZ(h3, h3, u3), [...h3, -s3 * u3];
+        }
+        isLocationOccluded(e3) {
+          return !this.isSurfacePointVisible(_i(e3));
+        }
+        transformLightDirection(e3) {
+          const i3 = this._helper._center.lng * Math.PI / 180, o3 = this._helper._center.lat * Math.PI / 180, a3 = Math.cos(o3), r3 = [Math.sin(i3) * a3, Math.sin(o3), Math.cos(i3) * a3], s3 = [r3[2], 0, -r3[0]], n3 = [0, 0, 0];
+          t2.b2(n3, s3, r3), t2.b1(s3, s3), t2.b1(n3, n3);
+          const l3 = [0, 0, 0];
+          return t2.b1(l3, [s3[0] * e3[0] + n3[0] * e3[1] + r3[0] * e3[2], s3[1] * e3[0] + n3[1] * e3[1] + r3[1] * e3[2], s3[2] * e3[0] + n3[2] * e3[1] + r3[2] * e3[2]]), l3;
+        }
+        getPixelScale() {
+          return 1 / Math.cos(this._helper._center.lat * Math.PI / 180);
+        }
+        getCircleRadiusCorrection() {
+          return Math.cos(this._helper._center.lat * Math.PI / 180);
+        }
+        getPitchedTextCorrection(e3, i3, o3) {
+          const a3 = function(e4, i4, o4) {
+            const a4 = 1 / (1 << o4.z);
+            return new t2.a6(e4 / t2.a5 * a4 + o4.x * a4, i4 / t2.a5 * a4 + o4.y * a4);
+          }(e3, i3, o3.canonical), r3 = (s3 = a3.y, [t2.bx(a3.x * Math.PI * 2 + Math.PI, 2 * Math.PI), 2 * Math.atan(Math.exp(Math.PI - s3 * Math.PI * 2)) - 0.5 * Math.PI]);
+          var s3;
+          return this.getCircleRadiusCorrection() / Math.cos(r3[1]);
+        }
+        projectTileCoordinates(e3, i3, o3, a3) {
+          const r3 = o3.canonical, s3 = di2(e3, i3, r3.x, r3.y, r3.z), n3 = 1 + (a3 ? a3(e3, i3) : 0) / t2.bC, l3 = [s3[0] * n3, s3[1] * n3, s3[2] * n3, 1];
+          t2.aE(l3, l3, this._globeViewProjMatrixNoCorrection);
+          const c3 = this._cachedClippingPlane, h3 = c3[0] * s3[0] + c3[1] * s3[1] + c3[2] * s3[2] + c3[3] < 0;
+          return { point: new t2.P(l3[0] / l3[3], l3[1] / l3[3]), signedDistanceFromCamera: l3[3], isOccluded: h3 };
+        }
+        _calcMatrices() {
+          if (!this._helper._width || !this._helper._height) return;
+          const e3 = pi2(this.worldSize, this.center.lat), i3 = t2.bi(), o3 = t2.bi();
+          this._helper.autoCalculateNearFarZ && (this._helper._nearZ = 0.5, this._helper._farZ = this.cameraToCenterDistance + 2 * e3), t2.bc(i3, this.fovInRadians, this.width / this.height, this._helper._nearZ, this._helper._farZ);
+          const a3 = this.centerOffset;
+          i3[8] = 2 * -a3.x / this._helper._width, i3[9] = 2 * a3.y / this._helper._height, this._projectionMatrix = t2.bd(i3), this._globeProjMatrixInverted = t2.bi(), t2.ay(this._globeProjMatrixInverted, i3), t2.O(i3, i3, [0, 0, -this.cameraToCenterDistance]), t2.be(i3, i3, this.rollInRadians), t2.bf(i3, i3, -this.pitchInRadians), t2.be(i3, i3, this.bearingInRadians), t2.O(i3, i3, [0, 0, -e3]);
+          const r3 = t2.by();
+          r3[0] = e3, r3[1] = e3, r3[2] = e3, t2.bf(o3, i3, this.center.lat * Math.PI / 180), t2.bH(o3, o3, -this.center.lng * Math.PI / 180), t2.Q(o3, o3, r3), this._globeViewProjMatrixNoCorrection = o3, t2.bf(i3, i3, this.center.lat * Math.PI / 180 - this._globeLatitudeErrorCorrectionRadians), t2.bH(i3, i3, -this.center.lng * Math.PI / 180), t2.Q(i3, i3, r3), this._globeViewProjMatrix32f = new Float32Array(i3), this._globeViewProjMatrixNoCorrectionInverted = t2.bi(), t2.ay(this._globeViewProjMatrixNoCorrectionInverted, o3);
+          const s3 = t2.by();
+          this._cameraPosition = t2.by(), this._cameraPosition[2] = this.cameraToCenterDistance / e3, t2.bE(this._cameraPosition, this._cameraPosition, s3, -this.rollInRadians), t2.bF(this._cameraPosition, this._cameraPosition, s3, this.pitchInRadians), t2.bE(this._cameraPosition, this._cameraPosition, s3, -this.bearingInRadians), t2.a_(this._cameraPosition, this._cameraPosition, [0, 0, 1]), t2.bF(this._cameraPosition, this._cameraPosition, s3, -this.center.lat * Math.PI / 180), t2.bG(this._cameraPosition, this._cameraPosition, s3, this.center.lng * Math.PI / 180), this._cachedClippingPlane = this._computeClippingPlane(e3);
+          const n3 = t2.bd(this._globeViewProjMatrixNoCorrectionInverted);
+          t2.Q(n3, n3, [1, 1, -1]), this._cachedFrustum = Vt.fromInvProjectionMatrix(n3, 1, 0, this._cachedClippingPlane, true);
+        }
+        calculateFogMatrix(e3) {
+          t2.w("calculateFogMatrix is not supported on globe projection.");
+          const i3 = t2.bi();
+          return t2.ao(i3), i3;
+        }
+        getVisibleUnwrappedCoordinates(e3) {
+          return [new t2.ba(0, e3)];
+        }
+        getCameraFrustum() {
+          return this._cachedFrustum;
+        }
+        getClippingPlane() {
+          return this._cachedClippingPlane;
+        }
+        getCoveringTilesDetailsProvider() {
+          return this._coveringTilesDetailsProvider;
+        }
+        recalculateZoomAndCenter(e3) {
+          e3 && t2.w("terrain is not fully supported on vertical perspective projection."), this._helper.recalculateZoomAndCenter(0);
+        }
+        maxPitchScaleFactor() {
+          return 1;
+        }
+        getCameraPoint() {
+          return this._helper.getCameraPoint();
+        }
+        getCameraAltitude() {
+          return this._helper.getCameraAltitude();
+        }
+        getCameraLngLat() {
+          return this._helper.getCameraLngLat();
+        }
+        lngLatToCameraDepth(e3, i3) {
+          if (!this._globeViewProjMatrixNoCorrection) return 1;
+          const o3 = _i(e3);
+          t2.aZ(o3, o3, 1 + i3 / t2.bC);
+          const a3 = t2.bD();
+          return t2.aE(a3, [o3[0], o3[1], o3[2], 1], this._globeViewProjMatrixNoCorrection), a3[2] / a3[3];
+        }
+        populateCache(e3) {
+        }
+        getBounds() {
+          const e3 = 0.5 * this.width, i3 = 0.5 * this.height, o3 = [new t2.P(0, 0), new t2.P(e3, 0), new t2.P(this.width, 0), new t2.P(this.width, i3), new t2.P(this.width, this.height), new t2.P(e3, this.height), new t2.P(0, this.height), new t2.P(0, i3)], a3 = [];
+          for (const e4 of o3) a3.push(this.unprojectScreenPoint(e4));
+          let r3 = 0, s3 = 0, n3 = 0, l3 = 0;
+          const c3 = this.center;
+          for (const e4 of a3) {
+            const i4 = t2.bI(c3.lng, e4.lng), o4 = t2.bI(c3.lat, e4.lat);
+            i4 < s3 && (s3 = i4), i4 > r3 && (r3 = i4), o4 < l3 && (l3 = o4), o4 > n3 && (n3 = o4);
+          }
+          const h3 = [c3.lng + s3, c3.lat + l3, c3.lng + r3, c3.lat + n3];
+          return this.isSurfacePointOnScreen([0, 1, 0]) && (h3[3] = 90, h3[0] = -180, h3[2] = 180), this.isSurfacePointOnScreen([0, -1, 0]) && (h3[1] = -90, h3[0] = -180, h3[2] = 180), new Z2(h3);
+        }
+        calculateCenterFromCameraLngLatAlt(e3, t3, i3, o3) {
+          return this._helper.calculateCenterFromCameraLngLatAlt(e3, t3, i3, o3);
+        }
+        setLocationAtPoint(e3, i3) {
+          const o3 = _i(this.unprojectScreenPoint(i3)), a3 = _i(e3), r3 = t2.by();
+          t2.bJ(r3);
+          const s3 = t2.by();
+          t2.bG(s3, o3, r3, -this.center.lng * Math.PI / 180), t2.bF(s3, s3, r3, this.center.lat * Math.PI / 180);
+          const n3 = a3[0] * a3[0] + a3[2] * a3[2], l3 = s3[0] * s3[0];
+          if (n3 < l3) return;
+          const c3 = Math.sqrt(n3 - l3), h3 = -c3, u3 = t2.bK(a3[0], a3[2], s3[0], c3), d3 = t2.bK(a3[0], a3[2], s3[0], h3), _3 = t2.by();
+          t2.bG(_3, a3, r3, -u3);
+          const p3 = t2.bK(_3[1], _3[2], s3[1], s3[2]), m3 = t2.by();
+          t2.bG(m3, a3, r3, -d3);
+          const f3 = t2.bK(m3[1], m3[2], s3[1], s3[2]), g3 = 0.5 * Math.PI, v3 = p3 >= -g3 && p3 <= g3, x3 = f3 >= -g3 && f3 <= g3;
+          let b3, y3;
+          if (v3 && x3) {
+            const e4 = this.center.lng * Math.PI / 180, i4 = this.center.lat * Math.PI / 180;
+            t2.bL(u3, e4) + t2.bL(p3, i4) < t2.bL(d3, e4) + t2.bL(f3, i4) ? (b3 = u3, y3 = p3) : (b3 = d3, y3 = f3);
+          } else if (v3) b3 = u3, y3 = p3;
+          else {
+            if (!x3) return;
+            b3 = d3, y3 = f3;
+          }
+          const w3 = b3 / Math.PI * 180, T3 = y3 / Math.PI * 180, P3 = this.center.lat;
+          this.setCenter(new t2.V(w3, t2.ak(T3, -90, 90))), this.setZoom(this.zoom + gi2(P3, this.center.lat));
+        }
+        locationToScreenPoint(e3, i3) {
+          const o3 = _i(e3);
+          if (i3) {
+            const a3 = i3.getElevationForLngLatZoom(e3, this._helper._tileZoom);
+            t2.aZ(o3, o3, 1 + a3 / t2.bC);
+          }
+          return this._projectSurfacePointToScreen(o3);
+        }
+        _projectSurfacePointToScreen(e3) {
+          const i3 = t2.bD();
+          return t2.aE(i3, [...e3, 1], this._globeViewProjMatrixNoCorrection), i3[0] /= i3[3], i3[1] /= i3[3], new t2.P((0.5 * i3[0] + 0.5) * this.width, (0.5 * -i3[1] + 0.5) * this.height);
+        }
+        screenPointToMercatorCoordinate(e3, i3) {
+          if (i3) {
+            const t3 = i3.pointCoordinate(e3);
+            if (t3) return t3;
+          }
+          return t2.a6.fromLngLat(this.unprojectScreenPoint(e3));
+        }
+        screenPointToLocation(e3, t3) {
+          var i3;
+          return null === (i3 = this.screenPointToMercatorCoordinate(e3, t3)) || void 0 === i3 ? void 0 : i3.toLngLat();
+        }
+        isPointOnMapSurface(e3, t3) {
+          const i3 = this._cameraPosition, o3 = this.getRayDirectionFromPixel(e3);
+          return !!this.rayPlanetIntersection(i3, o3);
+        }
+        getRayDirectionFromPixel(e3) {
+          const i3 = t2.bD();
+          i3[0] = e3.x / this.width * 2 - 1, i3[1] = -1 * (e3.y / this.height * 2 - 1), i3[2] = 1, i3[3] = 1, t2.aE(i3, i3, this._globeViewProjMatrixNoCorrectionInverted), i3[0] /= i3[3], i3[1] /= i3[3], i3[2] /= i3[3];
+          const o3 = t2.by();
+          o3[0] = i3[0] - this._cameraPosition[0], o3[1] = i3[1] - this._cameraPosition[1], o3[2] = i3[2] - this._cameraPosition[2];
+          const a3 = t2.by();
+          return t2.b1(a3, o3), a3;
+        }
+        isSurfacePointVisible(e3) {
+          const t3 = this._cachedClippingPlane;
+          return t3[0] * e3[0] + t3[1] * e3[1] + t3[2] * e3[2] + t3[3] >= 0;
+        }
+        isSurfacePointOnScreen(e3) {
+          if (!this.isSurfacePointVisible(e3)) return false;
+          const i3 = t2.bD();
+          return t2.aE(i3, [...e3, 1], this._globeViewProjMatrixNoCorrection), i3[0] /= i3[3], i3[1] /= i3[3], i3[2] /= i3[3], i3[0] > -1 && i3[0] < 1 && i3[1] > -1 && i3[1] < 1 && i3[2] > -1 && i3[2] < 1;
+        }
+        rayPlanetIntersection(e3, i3) {
+          const o3 = t2.b3(e3, i3), a3 = t2.by(), r3 = t2.by();
+          t2.aZ(r3, i3, o3), t2.b0(a3, e3, r3);
+          const s3 = 1 - t2.b3(a3, a3);
+          if (s3 < 0) return null;
+          const n3 = t2.b3(e3, e3) - 1, l3 = -o3 + (o3 < 0 ? 1 : -1) * Math.sqrt(s3), c3 = n3 / l3, h3 = l3;
+          return { tMin: Math.min(c3, h3), tMax: Math.max(c3, h3) };
+        }
+        unprojectScreenPoint(e3) {
+          const i3 = this._cameraPosition, o3 = this.getRayDirectionFromPixel(e3), a3 = this.rayPlanetIntersection(i3, o3);
+          if (a3) {
+            const e4 = t2.by();
+            t2.a_(e4, i3, [o3[0] * a3.tMin, o3[1] * a3.tMin, o3[2] * a3.tMin]);
+            const r4 = t2.by();
+            return t2.b1(r4, e4), mi2(r4);
+          }
+          const r3 = this._cachedClippingPlane, s3 = r3[0] * o3[0] + r3[1] * o3[1] + r3[2] * o3[2], n3 = -t2.b9(r3, i3) / s3, l3 = t2.by();
+          if (n3 > 0) t2.a_(l3, i3, [o3[0] * n3, o3[1] * n3, o3[2] * n3]);
+          else {
+            const e4 = t2.by();
+            t2.a_(e4, i3, [2 * o3[0], 2 * o3[1], 2 * o3[2]]);
+            const a4 = t2.b9(this._cachedClippingPlane, e4);
+            t2.b0(l3, e4, [this._cachedClippingPlane[0] * a4, this._cachedClippingPlane[1] * a4, this._cachedClippingPlane[2] * a4]);
+          }
+          const c3 = function(e4) {
+            const i4 = t2.by();
+            return i4[0] = e4[0] * -e4[3], i4[1] = e4[1] * -e4[3], i4[2] = e4[2] * -e4[3], { center: i4, radius: Math.sqrt(1 - e4[3] * e4[3]) };
+          }(r3);
+          return mi2(function(e4, i4, o4) {
+            const a4 = t2.by();
+            t2.b0(a4, o4, e4);
+            const r4 = t2.by();
+            return t2.bw(r4, e4, a4, i4 / t2.b7(a4)), r4;
+          }(c3.center, c3.radius, l3));
+        }
+        getMatrixForModel(e3, i3) {
+          const o3 = t2.V.convert(e3), a3 = 1 / t2.bC, r3 = t2.bh();
+          return t2.bH(r3, r3, o3.lng / 180 * Math.PI), t2.bf(r3, r3, -o3.lat / 180 * Math.PI), t2.O(r3, r3, [0, 0, 1 + i3 / t2.bC]), t2.bf(r3, r3, 0.5 * Math.PI), t2.Q(r3, r3, [a3, a3, a3]), r3;
+        }
+        getProjectionDataForCustomLayer(e3 = true) {
+          const i3 = this.getProjectionData({ overscaledTileID: new t2.a2(0, 0, 0, 0, 0), applyGlobeMatrix: e3 });
+          return i3.tileMercatorCoords = [0, 0, 1, 1], i3;
+        }
+        getFastPathSimpleProjectionMatrix(e3) {
+        }
+      }
+      class Ei2 {
+        get pixelsToClipSpaceMatrix() {
+          return this._helper.pixelsToClipSpaceMatrix;
+        }
+        get clipSpaceToPixelsMatrix() {
+          return this._helper.clipSpaceToPixelsMatrix;
+        }
+        get pixelsToGLUnits() {
+          return this._helper.pixelsToGLUnits;
+        }
+        get centerOffset() {
+          return this._helper.centerOffset;
+        }
+        get size() {
+          return this._helper.size;
+        }
+        get rotationMatrix() {
+          return this._helper.rotationMatrix;
+        }
+        get centerPoint() {
+          return this._helper.centerPoint;
+        }
+        get pixelsPerMeter() {
+          return this._helper.pixelsPerMeter;
+        }
+        setMinZoom(e3) {
+          this._helper.setMinZoom(e3);
+        }
+        setMaxZoom(e3) {
+          this._helper.setMaxZoom(e3);
+        }
+        setMinPitch(e3) {
+          this._helper.setMinPitch(e3);
+        }
+        setMaxPitch(e3) {
+          this._helper.setMaxPitch(e3);
+        }
+        setRenderWorldCopies(e3) {
+          this._helper.setRenderWorldCopies(e3);
+        }
+        setBearing(e3) {
+          this._helper.setBearing(e3);
+        }
+        setPitch(e3) {
+          this._helper.setPitch(e3);
+        }
+        setRoll(e3) {
+          this._helper.setRoll(e3);
+        }
+        setFov(e3) {
+          this._helper.setFov(e3);
+        }
+        setZoom(e3) {
+          this._helper.setZoom(e3);
+        }
+        setCenter(e3) {
+          this._helper.setCenter(e3);
+        }
+        setElevation(e3) {
+          this._helper.setElevation(e3);
+        }
+        setMinElevationForCurrentTile(e3) {
+          this._helper.setMinElevationForCurrentTile(e3);
+        }
+        setPadding(e3) {
+          this._helper.setPadding(e3);
+        }
+        interpolatePadding(e3, t3, i3) {
+          return this._helper.interpolatePadding(e3, t3, i3);
+        }
+        isPaddingEqual(e3) {
+          return this._helper.isPaddingEqual(e3);
+        }
+        resize(e3, t3, i3 = true) {
+          this._helper.resize(e3, t3, i3);
+        }
+        getMaxBounds() {
+          return this._helper.getMaxBounds();
+        }
+        setMaxBounds(e3) {
+          this._helper.setMaxBounds(e3);
+        }
+        setConstrainOverride(e3) {
+          this._helper.setConstrainOverride(e3);
+        }
+        overrideNearFarZ(e3, t3) {
+          this._helper.overrideNearFarZ(e3, t3);
+        }
+        clearNearFarZOverride() {
+          this._helper.clearNearFarZOverride();
+        }
+        getCameraQueryGeometry(e3) {
+          return this._helper.getCameraQueryGeometry(this.getCameraPoint(), e3);
+        }
+        get tileSize() {
+          return this._helper.tileSize;
+        }
+        get tileZoom() {
+          return this._helper.tileZoom;
+        }
+        get scale() {
+          return this._helper.scale;
+        }
+        get worldSize() {
+          return this._helper.worldSize;
+        }
+        get width() {
+          return this._helper.width;
+        }
+        get height() {
+          return this._helper.height;
+        }
+        get lngRange() {
+          return this._helper.lngRange;
+        }
+        get latRange() {
+          return this._helper.latRange;
+        }
+        get minZoom() {
+          return this._helper.minZoom;
+        }
+        get maxZoom() {
+          return this._helper.maxZoom;
+        }
+        get zoom() {
+          return this._helper.zoom;
+        }
+        get center() {
+          return this._helper.center;
+        }
+        get minPitch() {
+          return this._helper.minPitch;
+        }
+        get maxPitch() {
+          return this._helper.maxPitch;
+        }
+        get pitch() {
+          return this._helper.pitch;
+        }
+        get pitchInRadians() {
+          return this._helper.pitchInRadians;
+        }
+        get roll() {
+          return this._helper.roll;
+        }
+        get rollInRadians() {
+          return this._helper.rollInRadians;
+        }
+        get bearing() {
+          return this._helper.bearing;
+        }
+        get bearingInRadians() {
+          return this._helper.bearingInRadians;
+        }
+        get fov() {
+          return this._helper.fov;
+        }
+        get fovInRadians() {
+          return this._helper.fovInRadians;
+        }
+        get elevation() {
+          return this._helper.elevation;
+        }
+        get minElevationForCurrentTile() {
+          return this._helper.minElevationForCurrentTile;
+        }
+        get padding() {
+          return this._helper.padding;
+        }
+        get unmodified() {
+          return this._helper.unmodified;
+        }
+        get renderWorldCopies() {
+          return this._helper.renderWorldCopies;
+        }
+        get cameraToCenterDistance() {
+          return this._helper.cameraToCenterDistance;
+        }
+        get constrainOverride() {
+          return this._helper.constrainOverride;
+        }
+        get nearZ() {
+          return this._helper.nearZ;
+        }
+        get farZ() {
+          return this._helper.farZ;
+        }
+        get autoCalculateNearFarZ() {
+          return this._helper.autoCalculateNearFarZ;
+        }
+        get isGlobeRendering() {
+          return this._globeness > 0;
+        }
+        setTransitionState(e3, t3) {
+          this._globeness = e3, this._globeLatitudeErrorCorrectionRadians = t3, this._calcMatrices(), this._verticalPerspectiveTransform.getCoveringTilesDetailsProvider().prepareNextFrame(), this._mercatorTransform.getCoveringTilesDetailsProvider().prepareNextFrame();
+        }
+        get currentTransform() {
+          return this.isGlobeRendering ? this._verticalPerspectiveTransform : this._mercatorTransform;
+        }
+        constructor(e3) {
+          this._globeLatitudeErrorCorrectionRadians = 0, this._globeness = 1, this.defaultConstrain = (e4, t3) => this.currentTransform.defaultConstrain(e4, t3), this.applyConstrain = (e4, t3) => this._helper.applyConstrain(e4, t3), this._helper = new Zt({ calcMatrices: () => {
+            this._calcMatrices();
+          }, defaultConstrain: (e4, t3) => this.defaultConstrain(e4, t3) }, e3), this._globeness = 1, this._mercatorTransform = new Wt(), this._verticalPerspectiveTransform = new Mi2();
+        }
+        clone() {
+          const e3 = new Ei2();
+          return e3._globeness = this._globeness, e3._globeLatitudeErrorCorrectionRadians = this._globeLatitudeErrorCorrectionRadians, e3.apply(this, false), e3;
+        }
+        apply(e3, t3) {
+          this._helper.apply(e3, t3), this._mercatorTransform.apply(this, false), this._verticalPerspectiveTransform.apply(this, false, this._globeLatitudeErrorCorrectionRadians);
+        }
+        get projectionMatrix() {
+          return this.currentTransform.projectionMatrix;
+        }
+        get modelViewProjectionMatrix() {
+          return this.currentTransform.modelViewProjectionMatrix;
+        }
+        get inverseProjectionMatrix() {
+          return this.currentTransform.inverseProjectionMatrix;
+        }
+        get cameraPosition() {
+          return this.currentTransform.cameraPosition;
+        }
+        getProjectionData(e3) {
+          const t3 = this._mercatorTransform.getProjectionData(e3), i3 = this._verticalPerspectiveTransform.getProjectionData(e3);
+          return { mainMatrix: this.isGlobeRendering ? i3.mainMatrix : t3.mainMatrix, clippingPlane: i3.clippingPlane, tileMercatorCoords: i3.tileMercatorCoords, projectionTransition: e3.applyGlobeMatrix ? this._globeness : 0, fallbackMatrix: t3.fallbackMatrix };
+        }
+        isLocationOccluded(e3) {
+          return this.currentTransform.isLocationOccluded(e3);
+        }
+        transformLightDirection(e3) {
+          return this.currentTransform.transformLightDirection(e3);
+        }
+        getPixelScale() {
+          return t2.bs(this._mercatorTransform.getPixelScale(), this._verticalPerspectiveTransform.getPixelScale(), this._globeness);
+        }
+        getCircleRadiusCorrection() {
+          return t2.bs(this._mercatorTransform.getCircleRadiusCorrection(), this._verticalPerspectiveTransform.getCircleRadiusCorrection(), this._globeness);
+        }
+        getPitchedTextCorrection(e3, i3, o3) {
+          const a3 = this._mercatorTransform.getPitchedTextCorrection(e3, i3, o3), r3 = this._verticalPerspectiveTransform.getPitchedTextCorrection(e3, i3, o3);
+          return t2.bs(a3, r3, this._globeness);
+        }
+        projectTileCoordinates(e3, t3, i3, o3) {
+          return this.currentTransform.projectTileCoordinates(e3, t3, i3, o3);
+        }
+        _calcMatrices() {
+          this._helper._width && this._helper._height && (this._verticalPerspectiveTransform.apply(this, false, this._globeLatitudeErrorCorrectionRadians), this._helper._nearZ = this._verticalPerspectiveTransform.nearZ, this._helper._farZ = this._verticalPerspectiveTransform.farZ, this._mercatorTransform.apply(this, true, this.isGlobeRendering), this._helper._nearZ = this._mercatorTransform.nearZ, this._helper._farZ = this._mercatorTransform.farZ);
+        }
+        calculateFogMatrix(e3) {
+          return this.currentTransform.calculateFogMatrix(e3);
+        }
+        getVisibleUnwrappedCoordinates(e3) {
+          return this.currentTransform.getVisibleUnwrappedCoordinates(e3);
+        }
+        getCameraFrustum() {
+          return this.currentTransform.getCameraFrustum();
+        }
+        getClippingPlane() {
+          return this.currentTransform.getClippingPlane();
+        }
+        getCoveringTilesDetailsProvider() {
+          return this.currentTransform.getCoveringTilesDetailsProvider();
+        }
+        recalculateZoomAndCenter(e3) {
+          this._mercatorTransform.recalculateZoomAndCenter(e3), this._verticalPerspectiveTransform.recalculateZoomAndCenter(e3);
+        }
+        maxPitchScaleFactor() {
+          return this._mercatorTransform.maxPitchScaleFactor();
+        }
+        getCameraPoint() {
+          return this._helper.getCameraPoint();
+        }
+        getCameraAltitude() {
+          return this._helper.getCameraAltitude();
+        }
+        getCameraLngLat() {
+          return this._helper.getCameraLngLat();
+        }
+        lngLatToCameraDepth(e3, t3) {
+          return this.currentTransform.lngLatToCameraDepth(e3, t3);
+        }
+        populateCache(e3) {
+          this._mercatorTransform.populateCache(e3), this._verticalPerspectiveTransform.populateCache(e3);
+        }
+        getBounds() {
+          return this.currentTransform.getBounds();
+        }
+        calculateCenterFromCameraLngLatAlt(e3, t3, i3, o3) {
+          return this._helper.calculateCenterFromCameraLngLatAlt(e3, t3, i3, o3);
+        }
+        setLocationAtPoint(e3, t3) {
+          if (!this.isGlobeRendering) return this._mercatorTransform.setLocationAtPoint(e3, t3), void this.apply(this._mercatorTransform, false);
+          this._verticalPerspectiveTransform.setLocationAtPoint(e3, t3), this.apply(this._verticalPerspectiveTransform, false);
+        }
+        locationToScreenPoint(e3, t3) {
+          return this.currentTransform.locationToScreenPoint(e3, t3);
+        }
+        screenPointToMercatorCoordinate(e3, t3) {
+          return this.currentTransform.screenPointToMercatorCoordinate(e3, t3);
+        }
+        screenPointToLocation(e3, t3) {
+          return this.currentTransform.screenPointToLocation(e3, t3);
+        }
+        isPointOnMapSurface(e3, t3) {
+          return this.currentTransform.isPointOnMapSurface(e3, t3);
+        }
+        getRayDirectionFromPixel(e3) {
+          return this._verticalPerspectiveTransform.getRayDirectionFromPixel(e3);
+        }
+        getMatrixForModel(e3, t3) {
+          return this.currentTransform.getMatrixForModel(e3, t3);
+        }
+        getProjectionDataForCustomLayer(e3 = true) {
+          const t3 = this._mercatorTransform.getProjectionDataForCustomLayer(e3);
+          if (!this.isGlobeRendering) return t3;
+          const i3 = this._verticalPerspectiveTransform.getProjectionDataForCustomLayer(e3);
+          return i3.fallbackMatrix = t3.mainMatrix, i3;
+        }
+        getFastPathSimpleProjectionMatrix(e3) {
+          return this.currentTransform.getFastPathSimpleProjectionMatrix(e3);
+        }
+      }
+      class Si2 {
+        get useGlobeControls() {
+          return true;
+        }
+        handlePanInertia(e3, i3) {
+          const o3 = vi2(e3, i3);
+          return Math.abs(o3.lng - i3.center.lng) > 180 && (o3.lng = i3.center.lng + 179.5 * Math.sign(o3.lng - i3.center.lng)), { easingCenter: o3, easingOffset: new t2.P(0, 0) };
+        }
+        handleMapControlsRollPitchBearingZoom(e3, i3) {
+          const o3 = e3.around, a3 = i3.screenPointToLocation(o3);
+          e3.bearingDelta && i3.setBearing(i3.bearing + e3.bearingDelta), e3.pitchDelta && i3.setPitch(i3.pitch + e3.pitchDelta), e3.rollDelta && i3.setRoll(i3.roll + e3.rollDelta);
+          const r3 = i3.zoom;
+          e3.zoomDelta && i3.setZoom(i3.zoom + e3.zoomDelta);
+          const s3 = i3.zoom - r3;
+          if (0 === s3) return;
+          const n3 = t2.bI(i3.center.lng, a3.lng), l3 = n3 / (Math.abs(n3 / 180) + 1), c3 = t2.bI(i3.center.lat, a3.lat), h3 = i3.getRayDirectionFromPixel(o3), u3 = i3.cameraPosition, d3 = -1 * t2.b3(u3, h3), _3 = t2.by();
+          t2.a_(_3, u3, [h3[0] * d3, h3[1] * d3, h3[2] * d3]);
+          const p3 = t2.b5(_3) - 1, m3 = Math.exp(0.5 * -Math.max(p3 - 0.3, 0)), f3 = pi2(i3.worldSize, i3.center.lat) / Math.min(i3.width, i3.height), g3 = t2.bv(f3, 0.9, 0.5, 1, 0.25), v3 = (1 - t2.an(-s3)) * Math.min(m3, g3), x3 = i3.center.lat, b3 = i3.zoom, y3 = new t2.V(i3.center.lng + l3 * v3, t2.ak(i3.center.lat + c3 * v3, -t2.al, t2.al));
+          i3.setLocationAtPoint(a3, o3);
+          const w3 = i3.center, T3 = t2.bv(Math.abs(n3), 45, 85, 0, 1), P3 = t2.bv(f3, 0.75, 0.35, 0, 1), C3 = Math.pow(Math.max(T3, P3), 0.25), I3 = t2.bI(w3.lng, y3.lng), M3 = t2.bI(w3.lat, y3.lat);
+          i3.setCenter(new t2.V(w3.lng + I3 * C3, w3.lat + M3 * C3).wrap()), i3.setZoom(b3 + gi2(x3, i3.center.lat));
+        }
+        handleMapControlsPan(e3, t3, i3) {
+          if (!e3.panDelta) return;
+          const o3 = t3.center.lat, a3 = t3.zoom;
+          t3.setCenter(vi2(e3.panDelta, t3).wrap()), t3.setZoom(a3 + gi2(o3, t3.center.lat));
+        }
+        cameraForBoxAndBearing(e3, i3, o3, a3, r3) {
+          const s3 = Ht(e3, i3, o3, a3, r3), n3 = i3.left / r3.width * 2 - 1, l3 = (r3.width - i3.right) / r3.width * 2 - 1, c3 = i3.top / r3.height * -2 + 1, h3 = (r3.height - i3.bottom) / r3.height * -2 + 1, u3 = t2.bI(o3.getWest(), o3.getEast()) < 0, d3 = u3 ? o3.getEast() : o3.getWest(), _3 = u3 ? o3.getWest() : o3.getEast(), p3 = Math.max(o3.getNorth(), o3.getSouth()), m3 = Math.min(o3.getNorth(), o3.getSouth()), f3 = d3 + 0.5 * t2.bI(d3, _3), g3 = p3 + 0.5 * t2.bI(p3, m3), v3 = r3.clone();
+          v3.setCenter(s3.center), v3.setBearing(s3.bearing), v3.setPitch(0), v3.setRoll(0), v3.setZoom(s3.zoom);
+          const x3 = v3.modelViewProjectionMatrix, b3 = [_i(o3.getNorthWest()), _i(o3.getNorthEast()), _i(o3.getSouthWest()), _i(o3.getSouthEast()), _i(new t2.V(_3, g3)), _i(new t2.V(d3, g3)), _i(new t2.V(f3, p3)), _i(new t2.V(f3, m3))], y3 = _i(s3.center);
+          let w3 = Number.POSITIVE_INFINITY;
+          for (const e4 of b3) n3 < 0 && (w3 = Si2.getLesserNonNegativeNonNull(w3, Si2.solveVectorScale(e4, y3, x3, "x", n3))), l3 > 0 && (w3 = Si2.getLesserNonNegativeNonNull(w3, Si2.solveVectorScale(e4, y3, x3, "x", l3))), c3 > 0 && (w3 = Si2.getLesserNonNegativeNonNull(w3, Si2.solveVectorScale(e4, y3, x3, "y", c3))), h3 < 0 && (w3 = Si2.getLesserNonNegativeNonNull(w3, Si2.solveVectorScale(e4, y3, x3, "y", h3)));
+          if (Number.isFinite(w3) && 0 !== w3) return s3.zoom = v3.zoom + t2.aq(w3), s3;
+          qt();
+        }
+        handleJumpToCenterZoom(e3, i3) {
+          const o3 = e3.center.lat, a3 = e3.applyConstrain(i3.center ? t2.V.convert(i3.center) : e3.center, e3.zoom).center;
+          e3.setCenter(a3.wrap());
+          const r3 = void 0 !== i3.zoom ? +i3.zoom : e3.zoom + gi2(o3, a3.lat);
+          e3.zoom !== r3 && e3.setZoom(r3);
+        }
+        handleEaseTo(e3, i3) {
+          const o3 = e3.zoom, a3 = e3.center, r3 = e3.padding, s3 = { roll: e3.roll, pitch: e3.pitch, bearing: e3.bearing }, n3 = { roll: void 0 === i3.roll ? e3.roll : i3.roll, pitch: void 0 === i3.pitch ? e3.pitch : i3.pitch, bearing: void 0 === i3.bearing ? e3.bearing : i3.bearing }, l3 = void 0 !== i3.zoom, c3 = !e3.isPaddingEqual(i3.padding);
+          let h3 = false;
+          const u3 = i3.center ? t2.V.convert(i3.center) : a3, d3 = e3.applyConstrain(u3, o3).center;
+          jt(e3, d3);
+          const _3 = e3.clone();
+          _3.setCenter(d3), _3.setZoom(l3 ? +i3.zoom : o3 + gi2(a3.lat, u3.lat)), _3.setBearing(i3.bearing);
+          const p3 = new t2.P(t2.ak(e3.centerPoint.x + i3.offsetAsPoint.x, 0, e3.width), t2.ak(e3.centerPoint.y + i3.offsetAsPoint.y, 0, e3.height));
+          _3.setLocationAtPoint(d3, p3);
+          const m3 = (i3.offset && i3.offsetAsPoint.mag()) > 0 ? _3.center : d3, f3 = l3 ? +i3.zoom : o3 + gi2(a3.lat, m3.lat), g3 = o3 + gi2(a3.lat, 0), v3 = f3 + gi2(m3.lat, 0), x3 = t2.bI(a3.lng, m3.lng), b3 = t2.bI(a3.lat, m3.lat), y3 = t2.an(v3 - g3);
+          return h3 = f3 !== o3, { easeFunc: (o4) => {
+            if (t2.bm(s3, n3) || $t({ startEulerAngles: s3, endEulerAngles: n3, tr: e3, k: o4, useSlerp: s3.roll != n3.roll }), c3 && e3.interpolatePadding(r3, i3.padding, o4), i3.around) t2.w("Easing around a point is not supported under globe projection."), e3.setLocationAtPoint(i3.around, i3.aroundPoint);
+            else {
+              const t3 = v3 > g3 ? Math.min(2, y3) : Math.max(0.5, y3), i4 = Math.pow(t3, 1 - o4), r4 = bi2(a3, x3, b3, o4 * i4);
+              e3.setCenter(r4.wrap());
+            }
+            if (h3) {
+              const i4 = t2.G.number(g3, v3, o4) + gi2(0, e3.center.lat);
+              e3.setZoom(i4);
+            }
+          }, isZooming: h3, elevationCenter: m3 };
+        }
+        handleFlyTo(e3, i3) {
+          const o3 = void 0 !== i3.zoom, a3 = e3.center, r3 = e3.zoom, s3 = e3.padding, n3 = !e3.isPaddingEqual(i3.padding), l3 = e3.applyConstrain(t2.V.convert(i3.center || i3.locationAtOffset), r3).center, c3 = o3 ? +i3.zoom : e3.zoom + gi2(e3.center.lat, l3.lat), h3 = e3.clone();
+          h3.setCenter(l3), h3.setZoom(c3), h3.setBearing(i3.bearing);
+          const u3 = new t2.P(t2.ak(e3.centerPoint.x + i3.offsetAsPoint.x, 0, e3.width), t2.ak(e3.centerPoint.y + i3.offsetAsPoint.y, 0, e3.height));
+          h3.setLocationAtPoint(l3, u3);
+          const d3 = h3.center;
+          jt(e3, d3);
+          const _3 = function(e4, i4, o4) {
+            const a4 = _i(i4), r4 = _i(o4), s4 = t2.b3(a4, r4), n4 = Math.acos(s4), l4 = ui2(e4);
+            return n4 / (2 * Math.PI) * l4;
+          }(e3, a3, d3), p3 = r3 + gi2(a3.lat, 0), m3 = c3 + gi2(d3.lat, 0), f3 = t2.an(m3 - p3);
+          let g3;
+          if ("number" == typeof i3.minZoom) {
+            const o4 = +i3.minZoom + gi2(d3.lat, 0), a4 = Math.min(o4, p3, m3) + gi2(0, d3.lat), r4 = e3.applyConstrain(d3, a4).zoom + gi2(d3.lat, 0);
+            g3 = t2.an(r4 - p3);
+          }
+          const v3 = t2.bI(a3.lng, d3.lng), x3 = t2.bI(a3.lat, d3.lat);
+          return { easeFunc: (o4, r4, l4, h4) => {
+            const u4 = bi2(a3, v3, x3, l4);
+            n3 && e3.interpolatePadding(s3, i3.padding, o4);
+            const _4 = 1 === o4 ? d3 : u4;
+            e3.setCenter(_4.wrap());
+            const m4 = p3 + t2.aq(r4);
+            e3.setZoom(1 === o4 ? c3 : m4 + gi2(0, _4.lat));
+          }, scaleOfZoom: f3, targetCenter: d3, scaleOfMinZoom: g3, pixelPathLength: _3 };
+        }
+        static solveVectorScale(e3, t3, i3, o3, a3) {
+          const r3 = "x" === o3 ? [i3[0], i3[4], i3[8], i3[12]] : [i3[1], i3[5], i3[9], i3[13]], s3 = [i3[3], i3[7], i3[11], i3[15]], n3 = e3[0] * r3[0] + e3[1] * r3[1] + e3[2] * r3[2], l3 = e3[0] * s3[0] + e3[1] * s3[1] + e3[2] * s3[2], c3 = t3[0] * r3[0] + t3[1] * r3[1] + t3[2] * r3[2], h3 = t3[0] * s3[0] + t3[1] * s3[1] + t3[2] * s3[2];
+          return c3 + a3 * l3 === n3 + a3 * h3 || s3[3] * (n3 - c3) + r3[3] * (h3 - l3) + n3 * h3 == c3 * l3 ? null : (c3 + r3[3] - a3 * h3 - a3 * s3[3]) / (c3 - n3 - a3 * h3 + a3 * l3);
+        }
+        static getLesserNonNegativeNonNull(e3, t3) {
+          return null !== t3 && t3 >= 0 && t3 < e3 ? t3 : e3;
+        }
+      }
+      class Ri2 {
+        constructor(e3) {
+          this._globe = e3, this._mercatorCameraHelper = new Xt(), this._verticalPerspectiveCameraHelper = new Si2();
+        }
+        get useGlobeControls() {
+          return this._globe.useGlobeRendering;
+        }
+        get currentHelper() {
+          return this.useGlobeControls ? this._verticalPerspectiveCameraHelper : this._mercatorCameraHelper;
+        }
+        handlePanInertia(e3, t3) {
+          return this.currentHelper.handlePanInertia(e3, t3);
+        }
+        handleMapControlsRollPitchBearingZoom(e3, t3) {
+          return this.currentHelper.handleMapControlsRollPitchBearingZoom(e3, t3);
+        }
+        handleMapControlsPan(e3, t3, i3) {
+          this.currentHelper.handleMapControlsPan(e3, t3, i3);
+        }
+        cameraForBoxAndBearing(e3, t3, i3, o3, a3) {
+          return this.currentHelper.cameraForBoxAndBearing(e3, t3, i3, o3, a3);
+        }
+        handleJumpToCenterZoom(e3, t3) {
+          this.currentHelper.handleJumpToCenterZoom(e3, t3);
+        }
+        handleEaseTo(e3, t3) {
+          return this.currentHelper.handleEaseTo(e3, t3);
+        }
+        handleFlyTo(e3, t3) {
+          return this.currentHelper.handleFlyTo(e3, t3);
+        }
+      }
+      const zi2 = (e3, i3) => t2.B(e3, i3 && i3.filter((e4) => "source.canvas" !== e4.identifier)), Di2 = t2.bM();
+      class Ai2 extends t2.E {
+        constructor(e3, i3 = {}) {
+          var o3, a3;
+          super(), this._rtlPluginLoaded = () => {
+            for (const e4 in this.tileManagers) {
+              const t3 = this.tileManagers[e4].getSource().type;
+              "vector" !== t3 && "geojson" !== t3 || this.tileManagers[e4].reload();
+            }
+          }, this.map = e3, this.dispatcher = new L2(A2(), e3._getMapId()), this.dispatcher.registerMessageHandler("GG", (e4, t3) => this.getGlyphs(e4, t3)), this.dispatcher.registerMessageHandler("GI", (e4, t3) => this.getImages(e4, t3)), this.dispatcher.registerMessageHandler("GDA", (e4, t3) => this.getDashes(e4, t3)), this.imageManager = new f2(), this.imageManager.setEventedParent(this);
+          const r3 = (null === (o3 = e3._container) || void 0 === o3 ? void 0 : o3.lang) || "undefined" != typeof document && (null === (a3 = document.documentElement) || void 0 === a3 ? void 0 : a3.lang) || void 0;
+          this.glyphManager = new y2(e3._requestManager, i3.localIdeographFontFamily, r3), this.lineAtlas = new M2(256, 512), this.crossTileSymbolIndex = new St(), this._setInitialValues(), this._resetUpdates(), this.dispatcher.broadcast("SR", t2.bN()), ne2().on(ae2, this._rtlPluginLoaded), this.on("data", (e4) => {
+            if ("source" !== e4.dataType || "metadata" !== e4.sourceDataType) return;
+            const t3 = this.tileManagers[e4.sourceId];
+            if (!t3) return;
+            const i4 = t3.getSource();
+            if (i4 && i4.vectorLayerIds) for (const e5 in this._layers) {
+              const t4 = this._layers[e5];
+              t4.source === i4.id && this._validateLayer(t4);
+            }
+          });
+        }
+        _setInitialValues() {
+          var e3;
+          this._spritesImagesIds = {}, this._layers = {}, this._order = [], this.tileManagers = {}, this.zoomHistory = new t2.bO(), this._availableImages = [], this._globalState = {}, this._serializedLayers = {}, this.stylesheet = null, this.light = null, this.sky = null, this.projection && (this.projection.destroy(), delete this.projection), this._loaded = false, this._changed = false, this._updatedLayers = {}, this._updatedSources = {}, this._changedImages = {}, this._glyphsDidChange = false, this._updatedPaintProps = {}, this._layerOrderChanged = false, this.crossTileSymbolIndex = new ((null === (e3 = this.crossTileSymbolIndex) || void 0 === e3 ? void 0 : e3.constructor) || Object)(), this.pauseablePlacement = void 0, this.placement = void 0, this.z = 0;
+        }
+        setGlobalStateProperty(e3, i3) {
+          var o3, a3, r3;
+          this._checkLoaded();
+          const s3 = null === i3 ? null !== (r3 = null === (a3 = null === (o3 = this.stylesheet.state) || void 0 === o3 ? void 0 : o3[e3]) || void 0 === a3 ? void 0 : a3.default) && void 0 !== r3 ? r3 : null : i3;
+          if (t2.bP(s3, this._globalState[e3])) return this;
+          this._globalState[e3] = s3, this._applyGlobalStateChanges([e3]);
+        }
+        getGlobalState() {
+          return this._globalState;
+        }
+        setGlobalState(e3) {
+          this._checkLoaded();
+          const i3 = [];
+          for (const o3 in e3) !t2.bP(this._globalState[o3], e3[o3].default) && (i3.push(o3), this._globalState[o3] = e3[o3].default);
+          this._applyGlobalStateChanges(i3);
+        }
+        _applyGlobalStateChanges(e3) {
+          if (0 === e3.length) return;
+          const t3 = /* @__PURE__ */ new Set(), i3 = {};
+          for (const o3 of e3) {
+            i3[o3] = this._globalState[o3];
+            for (const e4 in this._layers) {
+              const i4 = this._layers[e4], a3 = i4.getLayoutAffectingGlobalStateRefs(), r3 = i4.getPaintAffectingGlobalStateRefs(), s3 = i4.getVisibilityAffectingGlobalStateRefs();
+              if (a3.has(o3) && t3.add(i4.source), r3.has(o3)) for (const { name: e5, value: t4 } of r3.get(o3)) this._updatePaintProperty(i4, e5, t4);
+              (null == s3 ? void 0 : s3.has(o3)) && (i4.recalculateVisibility(), this._updateLayer(i4));
+            }
+          }
+          this.dispatcher.broadcast("UGS", i3);
+          for (const e4 in this.tileManagers) t3.has(e4) && (this._reloadSource(e4), this._changed = true);
+        }
+        loadURL(e3) {
+          return t2._(this, arguments, void 0, function* (e4, i3 = {}, o3) {
+            this.fire(new t2.l("dataloading", { dataType: "style" })), i3.validate = "boolean" != typeof i3.validate || i3.validate;
+            const a3 = yield this.map._requestManager.transformRequest(e4, "Style");
+            this._loadStyleRequest = new AbortController();
+            const r3 = this._loadStyleRequest;
+            try {
+              const e5 = yield t2.j(a3, this._loadStyleRequest);
+              this._loadStyleRequest = null, this._load(e5.data, i3, o3);
+            } catch (e5) {
+              this._loadStyleRequest = null, e5 && !r3.signal.aborted && this.fire(new t2.k(e5));
+            }
+          });
+        }
+        loadJSON(e3, i3 = {}, o3) {
+          this.fire(new t2.l("dataloading", { dataType: "style" })), this._frameRequest = new AbortController(), n2.frameAsync(this._frameRequest, this.map._ownerWindow).then(() => {
+            this._frameRequest = null, i3.validate = false !== i3.validate, this._load(e3, i3, o3);
+          }).catch(() => {
+          });
+        }
+        loadEmpty() {
+          this.fire(new t2.l("dataloading", { dataType: "style" })), this._load(Di2, { validate: false });
+        }
+        _load(e3, i3, o3) {
+          var a3, r3;
+          let s3 = i3.transformStyle ? i3.transformStyle(o3, e3) : e3;
+          if (!i3.validate || !zi2(this, t2.C(s3))) {
+            s3 = Object.assign({}, s3), this._loaded = true, this.stylesheet = s3;
+            for (const e4 in s3.sources) this.addSource(e4, s3.sources[e4], { validate: false });
+            s3.sprite ? this._loadSprite(s3.sprite) : this.imageManager.setLoaded(true), this.glyphManager.setURL(s3.glyphs), this._createLayers(), this.light = new P2(this.stylesheet.light), this._setProjectionInternal((null === (a3 = this.stylesheet.projection) || void 0 === a3 ? void 0 : a3.type) || "mercator"), this.sky = new I2(this.stylesheet.sky), this.map.setTerrain(null !== (r3 = this.stylesheet.terrain) && void 0 !== r3 ? r3 : null), this.fire(new t2.l("data", { dataType: "style" })), this.fire(new t2.l("style.load"));
+          }
+        }
+        _createLayers() {
+          var e3, i3, o3;
+          const a3 = t2.bQ(this.stylesheet.layers);
+          this.setGlobalState(null !== (e3 = this.stylesheet.state) && void 0 !== e3 ? e3 : null), this.dispatcher.broadcast("SL", a3), this._order = a3.map((e4) => e4.id), this._layers = {}, this._serializedLayers = null;
+          for (const e4 of a3) {
+            const a4 = t2.bR(e4, this._globalState);
+            if (a4.setEventedParent(this, { layer: { id: e4.id } }), this._layers[e4.id] = a4, t2.bS(a4) && this.tileManagers[a4.source]) {
+              const t3 = null !== (o3 = null === (i3 = e4.paint) || void 0 === i3 ? void 0 : i3["raster-fade-duration"]) && void 0 !== o3 ? o3 : a4.paint.get("raster-fade-duration");
+              this.tileManagers[a4.source].setRasterFadeDuration(t3);
+            }
+          }
+        }
+        _loadSprite(e3, i3 = false, o3 = void 0) {
+          this.imageManager.setLoaded(false);
+          const a3 = new AbortController();
+          let r3;
+          this._spriteRequest = a3, function(e4, i4, o4, a4) {
+            return t2._(this, void 0, void 0, function* () {
+              const r4 = _2(e4), s3 = o4 > 1 ? "@2x" : "", l3 = {}, c3 = {};
+              for (const { id: e5, url: o5 } of r4) {
+                const r5 = yield i4.transformRequest(p2(o5, s3, ".json"), "SpriteJSON");
+                l3[e5] = t2.j(r5, a4);
+                const n3 = yield i4.transformRequest(p2(o5, s3, ".png"), "SpriteImage");
+                c3[e5] = u2.getImage(n3, a4);
+              }
+              return yield Promise.all([...Object.values(l3), ...Object.values(c3)]), function(e5, i5) {
+                return t2._(this, void 0, void 0, function* () {
+                  const t3 = {};
+                  for (const o5 in e5) {
+                    t3[o5] = {};
+                    const a5 = n2.getImageCanvasContext((yield i5[o5]).data), r5 = (yield e5[o5]).data;
+                    for (const e6 in r5) {
+                      const { width: i6, height: s4, x: n3, y: l4, sdf: c4, pixelRatio: h3, stretchX: u3, stretchY: d3, content: _3, textFitWidth: p3, textFitHeight: m3 } = r5[e6];
+                      t3[o5][e6] = { data: null, pixelRatio: h3, sdf: c4, stretchX: u3, stretchY: d3, content: _3, textFitWidth: p3, textFitHeight: m3, spriteData: { width: i6, height: s4, x: n3, y: l4, context: a5 } };
+                    }
+                  }
+                  return t3;
+                });
+              }(l3, c3);
+            });
+          }(e3, this.map._requestManager, this.map.getPixelRatio(), this._spriteRequest).then((e4) => {
+            if (this._spriteRequest = null, e4) for (const t3 in e4) {
+              this._spritesImagesIds[t3] = [];
+              const o4 = this._spritesImagesIds[t3] ? this._spritesImagesIds[t3].filter((t4) => !(t4 in e4)) : [];
+              for (const e5 of o4) this.imageManager.removeImage(e5), this._changedImages[e5] = true;
+              for (const o5 in e4[t3]) {
+                const a4 = "default" === t3 ? o5 : `${t3}:${o5}`;
+                this._spritesImagesIds[t3].push(a4), a4 in this.imageManager.images ? this.imageManager.updateImage(a4, e4[t3][o5], false) : this.imageManager.addImage(a4, e4[t3][o5]), i3 && (this._changedImages[a4] = true);
+              }
+            }
+          }).catch((e4) => {
+            this._spriteRequest = null, r3 = e4, a3.signal.aborted || this.fire(new t2.k(r3));
+          }).finally(() => {
+            this.imageManager.setLoaded(true), this._availableImages = this.imageManager.listImages(), i3 && (this._changed = true), this.dispatcher.broadcast("SI", this._availableImages), this.fire(new t2.l("data", { dataType: "style" })), o3 && o3(r3);
+          });
+        }
+        _unloadSprite() {
+          for (const e3 of Object.values(this._spritesImagesIds).flat()) this.imageManager.removeImage(e3), this._changedImages[e3] = true;
+          this._spritesImagesIds = {}, this._availableImages = this.imageManager.listImages(), this._changed = true, this.dispatcher.broadcast("SI", this._availableImages), this.fire(new t2.l("data", { dataType: "style" }));
+        }
+        _validateLayer(e3) {
+          const i3 = this.tileManagers[e3.source];
+          if (!i3) return;
+          const o3 = e3.sourceLayer;
+          if (!o3) return;
+          const a3 = i3.getSource();
+          ("geojson" === a3.type || a3.vectorLayerIds && -1 === a3.vectorLayerIds.indexOf(o3)) && this.fire(new t2.k(new Error(`Source layer "${o3}" does not exist on source "${a3.id}" as specified by style layer "${e3.id}".`)));
+        }
+        loaded() {
+          if (!this._loaded) return false;
+          if (Object.keys(this._updatedSources).length) return false;
+          for (const e3 in this.tileManagers) if (!this.tileManagers[e3].loaded()) return false;
+          return !!this.imageManager.isLoaded();
+        }
+        _serializeByIds(e3, i3 = false) {
+          const o3 = this._serializedAllLayers();
+          if (!e3 || 0 === e3.length) return Object.values(i3 ? t2.bT(o3) : o3);
+          const a3 = [];
+          for (const r3 of e3) if (o3[r3]) {
+            const e4 = i3 ? t2.bT(o3[r3]) : o3[r3];
+            a3.push(e4);
+          }
+          return a3;
+        }
+        _serializedAllLayers() {
+          let e3 = this._serializedLayers;
+          if (e3) return e3;
+          e3 = this._serializedLayers = {};
+          const t3 = Object.keys(this._layers);
+          for (const i3 of t3) {
+            const t4 = this._layers[i3];
+            "custom" !== t4.type && (e3[i3] = t4.serialize());
+          }
+          return e3;
+        }
+        hasTransitions() {
+          var e3, t3, i3;
+          if (null === (e3 = this.light) || void 0 === e3 ? void 0 : e3.hasTransition()) return true;
+          if (null === (t3 = this.sky) || void 0 === t3 ? void 0 : t3.hasTransition()) return true;
+          if (null === (i3 = this.projection) || void 0 === i3 ? void 0 : i3.hasTransition()) return true;
+          for (const e4 in this.tileManagers) if (this.tileManagers[e4].hasTransition()) return true;
+          for (const e4 in this._layers) if (this._layers[e4].hasTransition()) return true;
+          return false;
+        }
+        _checkLoaded() {
+          if (!this._loaded) throw new Error("Style is not done loading.");
+        }
+        update(e3) {
+          if (!this._loaded) return;
+          const i3 = this._changed;
+          if (i3) {
+            const t3 = Object.keys(this._updatedLayers), i4 = Object.keys(this._removedLayers);
+            (t3.length || i4.length) && this._updateWorkerLayers(t3, i4);
+            for (const e4 in this._updatedSources) {
+              const t4 = this._updatedSources[e4];
+              if ("reload" === t4) this._reloadSource(e4);
+              else {
+                if ("clear" !== t4) throw new Error(`Invalid action ${t4}`);
+                this._clearSource(e4);
+              }
+            }
+            this._updateTilesForChangedImages(), this._updateTilesForChangedGlyphs();
+            for (const t4 in this._updatedPaintProps) this._layers[t4].updateTransitions(e3);
+            this.light.updateTransitions(e3), this.sky.updateTransitions(e3), this._resetUpdates();
+          }
+          const o3 = {};
+          for (const e4 in this.tileManagers) {
+            const t3 = this.tileManagers[e4];
+            o3[e4] = t3.used, t3.used = false;
+          }
+          for (const t3 of this._order) {
+            const i4 = this._layers[t3];
+            i4.recalculate(e3, this._availableImages), !i4.isHidden(e3.zoom) && i4.source && (this.tileManagers[i4.source].used = true);
+          }
+          for (const e4 in o3) {
+            const i4 = this.tileManagers[e4];
+            !!o3[e4] != !!i4.used && i4.fire(new t2.l("data", { sourceDataType: "visibility", dataType: "source", sourceId: e4 }));
+          }
+          this.light.recalculate(e3), this.sky.recalculate(e3), this.projection.recalculate(e3), this.z = e3.zoom, i3 && this.fire(new t2.l("data", { dataType: "style" }));
+        }
+        _updateTilesForChangedImages() {
+          const e3 = Object.keys(this._changedImages);
+          if (e3.length) {
+            for (const t3 in this.tileManagers) this.tileManagers[t3].reloadTilesForDependencies(["icons", "patterns"], e3);
+            this._changedImages = {};
+          }
+        }
+        _updateTilesForChangedGlyphs() {
+          if (this._glyphsDidChange) {
+            for (const e3 in this.tileManagers) this.tileManagers[e3].reloadTilesForDependencies(["glyphs"], [""]);
+            this._glyphsDidChange = false;
+          }
+        }
+        _updateWorkerLayers(e3, t3) {
+          this.dispatcher.broadcast("UL", { layers: this._serializeByIds(e3, false), removedIds: t3 });
+        }
+        _resetUpdates() {
+          this._changed = false, this._updatedLayers = {}, this._removedLayers = {}, this._updatedSources = {}, this._updatedPaintProps = {}, this._changedImages = {}, this._glyphsDidChange = false;
+        }
+        setState(e3, i3 = {}) {
+          var o3;
+          this._checkLoaded();
+          const a3 = this.serialize();
+          if (e3 = i3.transformStyle ? i3.transformStyle(a3, e3) : e3, (null === (o3 = i3.validate) || void 0 === o3 || o3) && zi2(this, t2.C(e3))) return false;
+          (e3 = t2.bT(e3)).layers = t2.bQ(e3.layers);
+          const r3 = t2.bU(a3, e3), s3 = this._getOperationsToPerform(r3);
+          if (s3.unimplemented.length > 0) throw new Error(`Unimplemented: ${s3.unimplemented.join(", ")}.`);
+          if (0 === s3.operations.length) return false;
+          for (const e4 of s3.operations) e4();
+          return this.stylesheet = e3, this._serializedLayers = null, this.fire(new t2.l("style.load", { style: this })), true;
+        }
+        _getOperationsToPerform(e3) {
+          const t3 = [], i3 = [];
+          for (const o3 of e3) switch (o3.command) {
+            case "setCenter":
+            case "setZoom":
+            case "setBearing":
+            case "setPitch":
+            case "setRoll":
+              continue;
+            case "addLayer":
+              t3.push(() => this.addLayer.apply(this, o3.args));
+              break;
+            case "removeLayer":
+              t3.push(() => this.removeLayer.apply(this, o3.args));
+              break;
+            case "setPaintProperty":
+              t3.push(() => this.setPaintProperty.apply(this, o3.args));
+              break;
+            case "setLayoutProperty":
+              t3.push(() => this.setLayoutProperty.apply(this, o3.args));
+              break;
+            case "setFilter":
+              t3.push(() => this.setFilter.apply(this, o3.args));
+              break;
+            case "addSource":
+              t3.push(() => this.addSource.apply(this, o3.args));
+              break;
+            case "removeSource":
+              t3.push(() => this.removeSource.apply(this, o3.args));
+              break;
+            case "setLayerZoomRange":
+              t3.push(() => this.setLayerZoomRange.apply(this, o3.args));
+              break;
+            case "setLight":
+              t3.push(() => this.setLight.apply(this, o3.args));
+              break;
+            case "setGeoJSONSourceData":
+              t3.push(() => this.setGeoJSONSourceData.apply(this, o3.args));
+              break;
+            case "setGlyphs":
+              t3.push(() => this.setGlyphs.apply(this, o3.args));
+              break;
+            case "setSprite":
+              t3.push(() => this.setSprite.apply(this, o3.args));
+              break;
+            case "setTerrain":
+              t3.push(() => this.map.setTerrain.apply(this, o3.args));
+              break;
+            case "setSky":
+              t3.push(() => this.setSky.apply(this, o3.args));
+              break;
+            case "setProjection":
+              this.setProjection.apply(this, o3.args);
+              break;
+            case "setGlobalState":
+              t3.push(() => this.setGlobalState.apply(this, o3.args));
+              break;
+            case "setTransition":
+              t3.push(() => {
+              });
+              break;
+            default:
+              i3.push(o3.command);
+          }
+          return { operations: t3, unimplemented: i3 };
+        }
+        addImage(e3, i3) {
+          if (this.getImage(e3)) return this.fire(new t2.k(new Error(`An image named "${e3}" already exists.`)));
+          this.imageManager.addImage(e3, i3), this._afterImageUpdated(e3);
+        }
+        updateImage(e3, t3) {
+          this.imageManager.updateImage(e3, t3);
+        }
+        getImage(e3) {
+          return this.imageManager.getImage(e3);
+        }
+        removeImage(e3) {
+          if (!this.getImage(e3)) return this.fire(new t2.k(new Error(`An image named "${e3}" does not exist.`)));
+          this.imageManager.removeImage(e3), this._afterImageUpdated(e3);
+        }
+        _afterImageUpdated(e3) {
+          this._availableImages = this.imageManager.listImages(), this._changedImages[e3] = true, this._changed = true, this.dispatcher.broadcast("SI", this._availableImages), this.fire(new t2.l("data", { dataType: "style" }));
+        }
+        listImages() {
+          return this._checkLoaded(), this.imageManager.listImages();
+        }
+        addSource(e3, i3, o3 = {}) {
+          if (this._checkLoaded(), void 0 !== this.tileManagers[e3]) throw new Error(`Source "${e3}" already exists.`);
+          if (!i3.type) throw new Error(`The type property must be defined, but only the following properties were given: ${Object.keys(i3).join(", ")}.`);
+          if (["vector", "raster", "geojson", "video", "image"].indexOf(i3.type) >= 0 && this._validate(t2.C.source, `sources.${e3}`, i3, null, o3)) return;
+          this.map && this.map._collectResourceTiming && (i3.collectResourceTiming = true);
+          const a3 = this.tileManagers[e3] = new Ae2(e3, i3, this.dispatcher);
+          a3.style = this, a3.setEventedParent(this, () => ({ isSourceLoaded: a3.loaded(), source: a3.serialize(), sourceId: e3 })), a3.onAdd(this.map), this._changed = true;
+        }
+        removeSource(e3) {
+          if (this._checkLoaded(), void 0 === this.tileManagers[e3]) throw new Error(`There is no source with this ID=${e3}`);
+          for (const i4 in this._layers) if (this._layers[i4].source === e3) return this.fire(new t2.k(new Error(`Source "${e3}" cannot be removed while layer "${i4}" is using it.`)));
+          const i3 = this.tileManagers[e3];
+          delete this.tileManagers[e3], delete this._updatedSources[e3], i3.fire(new t2.l("data", { sourceDataType: "metadata", dataType: "source", sourceId: e3 })), i3.setEventedParent(null), i3.onRemove(this.map), this._changed = true;
+        }
+        setGeoJSONSourceData(e3, t3) {
+          if (this._checkLoaded(), void 0 === this.tileManagers[e3]) throw new Error(`There is no source with this ID=${e3}`);
+          const i3 = this.tileManagers[e3].getSource();
+          if ("geojson" !== i3.type) throw new Error(`geojsonSource.type is ${i3.type}, which is !== 'geojson`);
+          i3.setData(t3), this._changed = true;
+        }
+        getSource(e3) {
+          return this.tileManagers[e3] && this.tileManagers[e3].getSource();
+        }
+        addLayer(e3, i3, o3 = {}) {
+          this._checkLoaded();
+          const a3 = e3.id;
+          if (this.getLayer(a3)) return void this.fire(new t2.k(new Error(`Layer "${a3}" already exists on this map.`)));
+          let r3;
+          if ("custom" === e3.type) {
+            if (zi2(this, t2.bV(e3))) return;
+            r3 = t2.bR(e3, this._globalState);
+          } else {
+            if ("source" in e3 && "object" == typeof e3.source && (this.addSource(a3, e3.source), e3 = t2.bT(e3), e3 = t2.e(e3, { source: a3 })), this._validate(t2.C.layer, `layers.${a3}`, e3, { arrayIndex: -1 }, o3)) return;
+            r3 = t2.bR(e3, this._globalState), this._validateLayer(r3), r3.setEventedParent(this, { layer: { id: a3 } });
+          }
+          const s3 = i3 ? this._order.indexOf(i3) : this._order.length;
+          if (i3 && -1 === s3) this.fire(new t2.k(new Error(`Cannot add layer "${a3}" before non-existing layer "${i3}".`)));
+          else {
+            if (this._order.splice(s3, 0, a3), this._layerOrderChanged = true, this._layers[a3] = r3, this._removedLayers[a3] && r3.source && "custom" !== r3.type) {
+              const e4 = this._removedLayers[a3];
+              delete this._removedLayers[a3], e4.type !== r3.type ? this._updatedSources[r3.source] = "clear" : (this._updatedSources[r3.source] = "reload", this.tileManagers[r3.source].pause());
+            }
+            this._updateLayer(r3), r3.onAdd && r3.onAdd(this.map);
+          }
+        }
+        moveLayer(e3, i3) {
+          if (this._checkLoaded(), this._changed = true, !this._layers[e3]) return void this.fire(new t2.k(new Error(`The layer '${e3}' does not exist in the map's style and cannot be moved.`)));
+          if (e3 === i3) return;
+          const o3 = this._order.indexOf(e3);
+          this._order.splice(o3, 1);
+          const a3 = i3 ? this._order.indexOf(i3) : this._order.length;
+          i3 && -1 === a3 ? this.fire(new t2.k(new Error(`Cannot move layer "${e3}" before non-existing layer "${i3}".`))) : (this._order.splice(a3, 0, e3), this._layerOrderChanged = true);
+        }
+        removeLayer(e3) {
+          this._checkLoaded();
+          const i3 = this._layers[e3];
+          if (!i3) return void this.fire(new t2.k(new Error(`Cannot remove non-existing layer "${e3}".`)));
+          i3.setEventedParent(null);
+          const o3 = this._order.indexOf(e3);
+          this._order.splice(o3, 1), this._layerOrderChanged = true, this._changed = true, this._removedLayers[e3] = i3, delete this._layers[e3], this._serializedLayers && delete this._serializedLayers[e3], delete this._updatedLayers[e3], delete this._updatedPaintProps[e3], i3.onRemove && i3.onRemove(this.map);
+        }
+        getLayer(e3) {
+          return this._layers[e3];
+        }
+        getLayersOrder() {
+          return [...this._order];
+        }
+        hasLayer(e3) {
+          return e3 in this._layers;
+        }
+        setLayerZoomRange(e3, i3, o3) {
+          this._checkLoaded();
+          const a3 = this.getLayer(e3);
+          a3 ? a3.minzoom === i3 && a3.maxzoom === o3 || (null != i3 && (a3.minzoom = i3), null != o3 && (a3.maxzoom = o3), this._updateLayer(a3)) : this.fire(new t2.k(new Error(`Cannot set the zoom range of non-existing layer "${e3}".`)));
+        }
+        setFilter(e3, i3, o3 = {}) {
+          this._checkLoaded();
+          const a3 = this.getLayer(e3);
+          if (a3) {
+            if (!t2.bP(a3.filter, i3)) return null == i3 ? (a3.setFilter(void 0), void this._updateLayer(a3)) : void (this._validate(t2.C.filter, `layers.${a3.id}.filter`, i3, null, o3) || (a3.setFilter(t2.bT(i3)), this._updateLayer(a3)));
+          } else this.fire(new t2.k(new Error(`Cannot filter non-existing layer "${e3}".`)));
+        }
+        getFilter(e3) {
+          return t2.bT(this.getLayer(e3).filter);
+        }
+        setLayoutProperty(e3, i3, o3, a3 = {}) {
+          this._checkLoaded();
+          const r3 = this.getLayer(e3);
+          r3 ? t2.bP(r3.getLayoutProperty(i3), o3) || (r3.setLayoutProperty(i3, o3, a3), this._updateLayer(r3)) : this.fire(new t2.k(new Error(`Cannot style non-existing layer "${e3}".`)));
+        }
+        getLayoutProperty(e3, i3) {
+          const o3 = this.getLayer(e3);
+          if (o3) return o3.getLayoutProperty(i3);
+          this.fire(new t2.k(new Error(`Cannot get style of non-existing layer "${e3}".`)));
+        }
+        setPaintProperty(e3, i3, o3, a3 = {}) {
+          this._checkLoaded();
+          const r3 = this.getLayer(e3);
+          r3 ? t2.bP(r3.getPaintProperty(i3), o3) || this._updatePaintProperty(r3, i3, o3, a3) : this.fire(new t2.k(new Error(`Cannot style non-existing layer "${e3}".`)));
+        }
+        _updatePaintProperty(e3, i3, o3, a3 = {}) {
+          e3.setPaintProperty(i3, o3, a3) && this._updateLayer(e3), t2.bS(e3) && "raster-fade-duration" === i3 && this.tileManagers[e3.source].setRasterFadeDuration(o3), this._changed = true, this._updatedPaintProps[e3.id] = true, this._serializedLayers = null;
+        }
+        getPaintProperty(e3, t3) {
+          return this.getLayer(e3).getPaintProperty(t3);
+        }
+        setFeatureState(e3, i3) {
+          this._checkLoaded();
+          const o3 = e3.source, a3 = e3.sourceLayer, r3 = this.tileManagers[o3];
+          if (void 0 === r3) return void this.fire(new t2.k(new Error(`The source '${o3}' does not exist in the map's style.`)));
+          const s3 = r3.getSource().type;
+          "geojson" === s3 && a3 ? this.fire(new t2.k(new Error("GeoJSON sources cannot have a sourceLayer parameter."))) : "vector" !== s3 || a3 ? (void 0 === e3.id && this.fire(new t2.k(new Error("The feature id parameter must be provided."))), r3.setFeatureState(a3, e3.id, i3)) : this.fire(new t2.k(new Error("The sourceLayer parameter must be provided for vector source types.")));
+        }
+        removeFeatureState(e3, i3) {
+          this._checkLoaded();
+          const o3 = e3.source, a3 = this.tileManagers[o3];
+          if (void 0 === a3) return void this.fire(new t2.k(new Error(`The source '${o3}' does not exist in the map's style.`)));
+          const r3 = a3.getSource().type, s3 = "vector" === r3 ? e3.sourceLayer : void 0;
+          "vector" !== r3 || s3 ? i3 && "string" != typeof e3.id && "number" != typeof e3.id ? this.fire(new t2.k(new Error("A feature id is required to remove its specific state property."))) : a3.removeFeatureState(s3, e3.id, i3) : this.fire(new t2.k(new Error("The sourceLayer parameter must be provided for vector source types.")));
+        }
+        getFeatureState(e3) {
+          this._checkLoaded();
+          const i3 = e3.source, o3 = e3.sourceLayer, a3 = this.tileManagers[i3];
+          if (void 0 !== a3) return "vector" !== a3.getSource().type || o3 ? (void 0 === e3.id && this.fire(new t2.k(new Error("The feature id parameter must be provided."))), a3.getFeatureState(o3, e3.id)) : void this.fire(new t2.k(new Error("The sourceLayer parameter must be provided for vector source types.")));
+          this.fire(new t2.k(new Error(`The source '${i3}' does not exist in the map's style.`)));
+        }
+        getTransition() {
+          return t2.e({ duration: 300, delay: 0 }, this.stylesheet && this.stylesheet.transition);
+        }
+        serialize() {
+          if (!this._loaded) return;
+          const e3 = t2.bW(this.tileManagers, (e4) => e4.serialize()), i3 = this._serializeByIds(this._order, true), o3 = this.map.getTerrain() || void 0, a3 = this.stylesheet;
+          return t2.bX({ version: a3.version, name: a3.name, metadata: a3.metadata, light: a3.light, sky: a3.sky, center: a3.center, zoom: a3.zoom, bearing: a3.bearing, pitch: a3.pitch, sprite: a3.sprite, glyphs: a3.glyphs, transition: a3.transition, projection: a3.projection, sources: e3, layers: i3, terrain: o3 }, (e4) => void 0 !== e4);
+        }
+        _updateLayer(e3) {
+          this._updatedLayers[e3.id] = true, e3.source && !this._updatedSources[e3.source] && "raster" !== this.tileManagers[e3.source].getSource().type && (this._updatedSources[e3.source] = "reload", this.tileManagers[e3.source].pause()), this._serializedLayers = null, this._changed = true;
+        }
+        _flattenAndSortRenderedFeatures(e3) {
+          const t3 = (e4) => "fill-extrusion" === this._layers[e4].type, i3 = {}, o3 = [];
+          for (let a4 = this._order.length - 1; a4 >= 0; a4--) {
+            const r3 = this._order[a4];
+            if (t3(r3)) {
+              i3[r3] = a4;
+              for (const t4 of e3) {
+                const e4 = t4[r3];
+                if (e4) for (const t5 of e4) o3.push(t5);
+              }
+            }
+          }
+          o3.sort((e4, t4) => t4.intersectionZ - e4.intersectionZ);
+          const a3 = [];
+          for (let r3 = this._order.length - 1; r3 >= 0; r3--) {
+            const s3 = this._order[r3];
+            if (t3(s3)) for (let e4 = o3.length - 1; e4 >= 0; e4--) {
+              const t4 = o3[e4].feature;
+              if (i3[t4.layer.id] < r3) break;
+              a3.push(t4), o3.pop();
+            }
+            else for (const t4 of e3) {
+              const e4 = t4[s3];
+              if (e4) for (const t5 of e4) a3.push(t5.feature);
+            }
+          }
+          return a3;
+        }
+        queryRenderedFeatures(e3, i3, o3) {
+          i3 && i3.filter && this._validate(t2.C.filter, "queryRenderedFeatures.filter", i3.filter, null, i3);
+          const a3 = {};
+          if (i3 && i3.layers) {
+            if (!(Array.isArray(i3.layers) || i3.layers instanceof Set)) return this.fire(new t2.k(new Error("parameters.layers must be an Array or a Set of strings"))), [];
+            for (const e4 of i3.layers) {
+              const i4 = this._layers[e4];
+              if (!i4) return this.fire(new t2.k(new Error(`The layer '${e4}' does not exist in the map's style and cannot be queried for features.`))), [];
+              a3[i4.source] = true;
+            }
+          }
+          const r3 = [];
+          i3.availableImages = this._availableImages;
+          const s3 = this._serializedAllLayers(), n3 = i3.layers instanceof Set ? i3.layers : Array.isArray(i3.layers) ? new Set(i3.layers) : null, l3 = Object.assign(Object.assign({}, i3), { layers: n3, globalState: this._globalState });
+          for (const t3 in this.tileManagers) i3.layers && !a3[t3] || r3.push(B2(this.tileManagers[t3], this._layers, s3, e3, l3, o3, this.map.terrain ? (e4, t4, i4) => this.map.terrain.getElevation(e4, t4, i4) : void 0));
+          return this.placement && r3.push(function(e4, t3, i4, o4, a4, r4, s4) {
+            const n4 = {}, l4 = r4.queryRenderedSymbols(o4), c3 = [];
+            for (const e5 of Object.keys(l4).map(Number)) c3.push(s4[e5]);
+            c3.sort(O2);
+            for (const i5 of c3) {
+              const o5 = i5.featureIndex.lookupSymbolFeatures(l4[i5.bucketInstanceId], t3, i5.bucketIndex, i5.sourceLayerIndex, { filterSpec: a4.filter, globalState: a4.globalState }, a4.layers, a4.availableImages, e4);
+              for (const e5 in o5) {
+                const t4 = n4[e5] = n4[e5] || [], a5 = o5[e5];
+                a5.sort((e6, t5) => {
+                  const o6 = i5.featureSortOrder;
+                  if (o6) {
+                    const i6 = o6.indexOf(e6.featureIndex);
+                    return o6.indexOf(t5.featureIndex) - i6;
+                  }
+                  return t5.featureIndex - e6.featureIndex;
+                });
+                for (const e6 of a5) t4.push(e6);
+              }
+            }
+            return function(e5, t4, i5) {
+              for (const o5 in e5) for (const a5 of e5[o5]) j2(a5, i5[t4[o5].source]);
+              return e5;
+            }(n4, e4, i4);
+          }(this._layers, s3, this.tileManagers, e3, l3, this.placement.collisionIndex, this.placement.retainedQueryData)), this._flattenAndSortRenderedFeatures(r3);
+        }
+        querySourceFeatures(e3, i3) {
+          (null == i3 ? void 0 : i3.filter) && this._validate(t2.C.filter, "querySourceFeatures.filter", i3.filter, null, i3);
+          const o3 = this.tileManagers[e3];
+          return o3 ? function(e4, t3) {
+            const i4 = e4.getRenderableIds().map((t4) => e4.getTileByID(t4)), o4 = [], a3 = {};
+            for (let e5 = 0; e5 < i4.length; e5++) {
+              const r3 = i4[e5], s3 = r3.tileID.canonical.key;
+              a3[s3] || (a3[s3] = true, r3.querySourceFeatures(o4, t3));
+            }
+            return o4;
+          }(o3, i3 ? Object.assign(Object.assign({}, i3), { globalState: this._globalState }) : { globalState: this._globalState }) : [];
+        }
+        getLight() {
+          return this.light.getLight();
+        }
+        setLight(e3, i3 = {}) {
+          this._checkLoaded();
+          const o3 = this.light.getLight();
+          let a3 = false;
+          for (const i4 in e3) if (!t2.bP(e3[i4], o3[i4])) {
+            a3 = true;
+            break;
+          }
+          if (!a3) return;
+          const r3 = { now: c2(), transition: t2.e({ duration: 300, delay: 0 }, this.stylesheet.transition) };
+          this.light.setLight(e3, i3), this.light.updateTransitions(r3);
+        }
+        getProjection() {
+          var e3;
+          return null === (e3 = this.stylesheet) || void 0 === e3 ? void 0 : e3.projection;
+        }
+        setProjection(e3) {
+          if (this._checkLoaded(), this.stylesheet.projection = e3, this.projection) {
+            if (this.projection.name === e3.type) return;
+            this.projection.destroy(), delete this.projection;
+          }
+          this._setProjectionInternal(e3.type);
+        }
+        getSky() {
+          var e3;
+          return null === (e3 = this.stylesheet) || void 0 === e3 ? void 0 : e3.sky;
+        }
+        setSky(e3, i3 = {}) {
+          this._checkLoaded();
+          const o3 = this.getSky();
+          let a3 = false;
+          if (!e3 && !o3) return;
+          if (e3 && !o3) a3 = true;
+          else if (!e3 && o3) a3 = true;
+          else for (const i4 in e3) if (!t2.bP(e3[i4], o3[i4])) {
+            a3 = true;
+            break;
+          }
+          if (!a3) return;
+          const r3 = { now: c2(), transition: t2.e({ duration: 300, delay: 0 }, this.stylesheet.transition) };
+          this.stylesheet.sky = e3, this.sky.setSky(e3, i3), this.sky.updateTransitions(r3);
+        }
+        _setProjectionInternal(e3) {
+          const i3 = function(e4, i4) {
+            const o3 = { constrainOverride: i4 };
+            if (Array.isArray(e4)) {
+              const t3 = new hi2({ type: e4 });
+              return { projection: t3, transform: new Ei2(o3), cameraHelper: new Ri2(t3) };
+            }
+            switch (e4) {
+              case "mercator":
+                return { projection: new Bt(), transform: new Wt(o3), cameraHelper: new Xt() };
+              case "globe": {
+                const e5 = new hi2({ type: ["interpolate", ["linear"], ["zoom"], 11, "vertical-perspective", 12, "mercator"] });
+                return { projection: e5, transform: new Ei2(o3), cameraHelper: new Ri2(e5) };
+              }
+              case "vertical-perspective":
+                return { projection: new li2(), transform: new Mi2(o3), cameraHelper: new Si2() };
+              default:
+                return t2.w(`Unknown projection name: ${e4}. Falling back to mercator projection.`), { projection: new Bt(), transform: new Wt(o3), cameraHelper: new Xt() };
+            }
+          }(e3, this.map.transformConstrain);
+          this.projection = i3.projection, this.map.migrateProjection(i3.transform, i3.cameraHelper);
+          for (const e4 in this.tileManagers) this.tileManagers[e4].reload();
+        }
+        _validate(e3, i3, o3, a3, r3 = {}) {
+          return (!r3 || false !== r3.validate) && zi2(this, e3.call(t2.C, t2.e({ key: i3, style: this.serialize(), value: o3, styleSpec: t2.u }, a3)));
+        }
+        _remove(e3 = true) {
+          this._frameRequest && (this._frameRequest.abort(), this._frameRequest = null), this._loadStyleRequest && (this._loadStyleRequest.abort(), this._loadStyleRequest = null), this._spriteRequest && (this._spriteRequest.abort(), this._spriteRequest = null), ne2().off(ae2, this._rtlPluginLoaded);
+          for (const e4 in this._layers) this._layers[e4].setEventedParent(null);
+          for (const e4 in this.tileManagers) {
+            const t3 = this.tileManagers[e4];
+            t3.setEventedParent(null), t3.onRemove(this.map);
+          }
+          this.imageManager.setEventedParent(null), this.setEventedParent(null), e3 && this.dispatcher.broadcast("RM", void 0), this.dispatcher.remove(e3);
+        }
+        _clearSource(e3) {
+          this.tileManagers[e3].clearTiles();
+        }
+        _reloadSource(e3) {
+          this.tileManagers[e3].resume(), this.tileManagers[e3].reload();
+        }
+        _updateSources(e3) {
+          for (const t3 in this.tileManagers) this.tileManagers[t3].update(e3, this.map.terrain);
+        }
+        _generateCollisionBoxes() {
+          for (const e3 in this.tileManagers) this._reloadSource(e3);
+        }
+        _updatePlacement(e3, t3, i3, o3, a3 = false) {
+          let r3 = false, s3 = false;
+          const n3 = {};
+          for (const t4 of this._order) {
+            const i4 = this._layers[t4];
+            if ("symbol" !== i4.type) continue;
+            if (!n3[i4.source]) {
+              const e4 = this.tileManagers[i4.source];
+              n3[i4.source] = e4.getRenderableIds(true).map((t5) => e4.getTileByID(t5)).sort((e5, t5) => t5.tileID.overscaledZ - e5.tileID.overscaledZ || (e5.tileID.isLessThan(t5.tileID) ? -1 : 1));
+            }
+            const o4 = this.crossTileSymbolIndex.addLayer(i4, n3[i4.source], e3.center.lng);
+            r3 = r3 || o4;
+          }
+          if (this.crossTileSymbolIndex.pruneUnusedLayers(this._order), ((a3 = a3 || this._layerOrderChanged || 0 === i3) || !this.pauseablePlacement || this.pauseablePlacement.isDone() && !this.placement.stillRecent(c2(), e3.zoom)) && (this.pauseablePlacement = new Pt(e3, this.map.terrain, this._order, a3, t3, i3, o3, this.placement), this._layerOrderChanged = false), this.pauseablePlacement.isDone() ? this.placement.setStale() : (this.pauseablePlacement.continuePlacement(this._order, this._layers, n3), this.pauseablePlacement.isDone() && (this.placement = this.pauseablePlacement.commit(c2()), s3 = true), r3 && this.pauseablePlacement.placement.setStale()), s3 || r3) for (const e4 of this._order) {
+            const t4 = this._layers[e4];
+            "symbol" === t4.type && this.placement.updateLayerOpacities(t4, n3[t4.source]);
+          }
+          return !this.pauseablePlacement.isDone() || this.placement.hasTransitions(c2());
+        }
+        _releaseSymbolFadeTiles() {
+          for (const e3 in this.tileManagers) this.tileManagers[e3].releaseSymbolFadeTiles();
+        }
+        getImages(e3, i3) {
+          return t2._(this, void 0, void 0, function* () {
+            const e4 = yield this.imageManager.getImages(i3.icons);
+            this._updateTilesForChangedImages();
+            const t3 = this.tileManagers[i3.source];
+            return t3 && t3.setDependencies(i3.tileID.key, i3.type, i3.icons), e4;
+          });
+        }
+        getGlyphs(e3, i3) {
+          return t2._(this, void 0, void 0, function* () {
+            const e4 = yield this.glyphManager.getGlyphs(i3.stacks), t3 = this.tileManagers[i3.source];
+            return t3 && t3.setDependencies(i3.tileID.key, i3.type, [""]), e4;
+          });
+        }
+        getGlyphsUrl() {
+          return this.stylesheet.glyphs || null;
+        }
+        setGlyphs(e3, i3 = {}) {
+          this._checkLoaded(), e3 && this._validate(t2.C.glyphs, "glyphs", e3, null, i3) || (this._glyphsDidChange = true, this.stylesheet.glyphs = e3, this.glyphManager.entries = {}, this.glyphManager.setURL(e3));
+        }
+        getDashes(e3, i3) {
+          return t2._(this, void 0, void 0, function* () {
+            const e4 = {};
+            for (const [t3, o3] of Object.entries(i3.dashes)) e4[t3] = this.lineAtlas.getDash(o3.dasharray, o3.round);
+            return e4;
+          });
+        }
+        addSprite(e3, i3, o3 = {}, a3) {
+          this._checkLoaded();
+          const r3 = [{ id: e3, url: i3 }], s3 = [..._2(this.stylesheet.sprite), ...r3];
+          this._validate(t2.C.sprite, "sprite", s3, null, o3) || (this.stylesheet.sprite = s3, this._loadSprite(r3, true, a3));
+        }
+        removeSprite(e3) {
+          this._checkLoaded();
+          const i3 = _2(this.stylesheet.sprite);
+          if (i3.find((t3) => t3.id === e3)) {
+            if (this._spritesImagesIds[e3]) for (const t3 of this._spritesImagesIds[e3]) this.imageManager.removeImage(t3), this._changedImages[t3] = true;
+            i3.splice(i3.findIndex((t3) => t3.id === e3), 1), this.stylesheet.sprite = i3.length > 0 ? i3 : void 0, delete this._spritesImagesIds[e3], this._availableImages = this.imageManager.listImages(), this._changed = true, this.dispatcher.broadcast("SI", this._availableImages), this.fire(new t2.l("data", { dataType: "style" }));
+          } else this.fire(new t2.k(new Error(`Sprite "${e3}" doesn't exists on this map.`)));
+        }
+        getSprite() {
+          return _2(this.stylesheet.sprite);
+        }
+        setSprite(e3, i3 = {}, o3) {
+          this._checkLoaded(), e3 && this._validate(t2.C.sprite, "sprite", e3, null, i3) || (this.stylesheet.sprite = e3, e3 ? this._loadSprite(e3, true, o3) : (this._unloadSprite(), o3 && o3(null)));
+        }
+        destroy() {
+          this._frameRequest && (this._frameRequest.abort(), this._frameRequest = null), this._loadStyleRequest && (this._loadStyleRequest.abort(), this._loadStyleRequest = null), this._spriteRequest && (this._spriteRequest.abort(), this._spriteRequest = null);
+          for (const e3 in this.tileManagers) {
+            const t3 = this.tileManagers[e3];
+            t3.setEventedParent(null), t3.onRemove(this.map);
+          }
+          this.tileManagers = {}, this.imageManager && (this.imageManager.setEventedParent(null), this.imageManager.destroy(), this._availableImages = [], this._spritesImagesIds = {}), this.glyphManager && this.glyphManager.destroy();
+          for (const e3 in this._layers) {
+            const t3 = this._layers[e3];
+            t3.setEventedParent(null), t3.onRemove && t3.onRemove(this.map);
+          }
+          this._setInitialValues(), this.setEventedParent(null), this.dispatcher.unregisterMessageHandler("GG"), this.dispatcher.unregisterMessageHandler("GI"), this.dispatcher.unregisterMessageHandler("GDA"), this.dispatcher.remove(true), this._listeners = {}, this._oneTimeListeners = {};
+        }
+      }
+      var Li2 = t2.aS([{ name: "a_pos", type: "Int16", components: 2 }, { name: "a_texture_pos", type: "Int16", components: 2 }]);
+      class ki2 {
+        constructor() {
+          this.boundProgram = null, this.boundLayoutVertexBuffer = null, this.boundPaintVertexBuffers = [], this.boundIndexBuffer = null, this.boundVertexOffset = null, this.boundDynamicVertexBuffer = null, this.vao = null;
+        }
+        bind(e3, t3, i3, o3, a3, r3, s3, n3, l3) {
+          this.context = e3;
+          let c3 = this.boundPaintVertexBuffers.length !== o3.length;
+          for (let e4 = 0; !c3 && e4 < o3.length; e4++) this.boundPaintVertexBuffers[e4] !== o3[e4] && (c3 = true);
+          !this.vao || this.boundProgram !== t3 || this.boundLayoutVertexBuffer !== i3 || c3 || this.boundIndexBuffer !== a3 || this.boundVertexOffset !== r3 || this.boundDynamicVertexBuffer !== s3 || this.boundDynamicVertexBuffer2 !== n3 || this.boundDynamicVertexBuffer3 !== l3 ? this.freshBind(t3, i3, o3, a3, r3, s3, n3, l3) : (e3.bindVertexArray.set(this.vao), s3 && s3.bind(), a3 && a3.dynamicDraw && a3.bind(), n3 && n3.bind(), l3 && l3.bind());
+        }
+        freshBind(e3, t3, i3, o3, a3, r3, s3, n3) {
+          const l3 = e3.numAttributes, c3 = this.context, h3 = c3.gl;
+          this.vao && this.destroy(), this.vao = c3.createVertexArray(), c3.bindVertexArray.set(this.vao), this.boundProgram = e3, this.boundLayoutVertexBuffer = t3, this.boundPaintVertexBuffers = i3, this.boundIndexBuffer = o3, this.boundVertexOffset = a3, this.boundDynamicVertexBuffer = r3, this.boundDynamicVertexBuffer2 = s3, this.boundDynamicVertexBuffer3 = n3, t3.enableAttributes(h3, e3);
+          for (const t4 of i3) t4.enableAttributes(h3, e3);
+          r3 && r3.enableAttributes(h3, e3), s3 && s3.enableAttributes(h3, e3), n3 && n3.enableAttributes(h3, e3), t3.bind(), t3.setVertexAttribPointers(h3, e3, a3);
+          for (const t4 of i3) t4.bind(), t4.setVertexAttribPointers(h3, e3, a3);
+          r3 && (r3.bind(), r3.setVertexAttribPointers(h3, e3, a3)), o3 && o3.bind(), s3 && (s3.bind(), s3.setVertexAttribPointers(h3, e3, a3)), n3 && (n3.bind(), n3.setVertexAttribPointers(h3, e3, a3)), c3.currentNumAttributes = l3;
+        }
+        destroy() {
+          this.vao && (this.context.deleteVertexArray(this.vao), this.vao = null);
+        }
+      }
+      const Fi2 = (e3, i3, o3, a3, r3) => ({ u_texture: 0, u_ele_delta: e3, u_fog_matrix: i3, u_fog_color: o3 ? o3.properties.get("fog-color") : t2.bn.white, u_fog_ground_blend: o3 ? o3.properties.get("fog-ground-blend") : 1, u_fog_ground_blend_opacity: r3 ? 0 : o3 ? o3.calculateFogBlendOpacity(a3) : 0, u_horizon_color: o3 ? o3.properties.get("horizon-color") : t2.bn.white, u_horizon_fog_blend: o3 ? o3.properties.get("horizon-fog-blend") : 1, u_is_globe_mode: r3 ? 1 : 0 }), Bi2 = { mainMatrix: "u_projection_matrix", tileMercatorCoords: "u_projection_tile_mercator_coords", clippingPlane: "u_projection_clipping_plane", projectionTransition: "u_projection_transition", fallbackMatrix: "u_projection_fallback_matrix" };
+      function Oi2(e3) {
+        const t3 = [];
+        for (let i3 = 0; i3 < e3.length; i3++) {
+          if (null === e3[i3]) continue;
+          const o3 = e3[i3].split(" ");
+          t3.push(o3.pop());
+        }
+        return t3;
+      }
+      class ji2 {
+        constructor(e3, i3, o3, a3, r3, s3, n3, l3, c3 = []) {
+          const h3 = e3.gl;
+          this.program = h3.createProgram();
+          const u3 = Oi2(i3.staticAttributes), d3 = o3 ? o3.getBinderAttributes() : [], _3 = u3.concat(d3), p3 = zt.prelude.staticUniforms ? Oi2(zt.prelude.staticUniforms) : [], m3 = n3.staticUniforms ? Oi2(n3.staticUniforms) : [], f3 = i3.staticUniforms ? Oi2(i3.staticUniforms) : [], g3 = o3 ? o3.getBinderUniforms() : [], v3 = p3.concat(m3).concat(f3).concat(g3), x3 = [];
+          for (const e4 of v3) x3.indexOf(e4) < 0 && x3.push(e4);
+          const b3 = o3 ? o3.defines() : [];
+          oi2(h3) && b3.unshift("#version 300 es"), r3 && b3.push("#define OVERDRAW_INSPECTOR;"), s3 && b3.push("#define TERRAIN3D;"), l3 && b3.push(l3), c3 && b3.push(...c3);
+          let y3 = b3.concat(zt.prelude.fragmentSource, n3.fragmentSource, i3.fragmentSource).join("\n"), w3 = b3.concat(zt.prelude.vertexSource, n3.vertexSource, i3.vertexSource).join("\n");
+          oi2(h3) || (y3 = function(e4) {
+            return e4.replace(/\bin\s/g, "varying ").replace("out highp vec4 fragColor;", "").replace(/fragColor/g, "gl_FragColor").replace(/texture\(/g, "texture2D(");
+          }(y3), w3 = function(e4) {
+            return e4.replace(/\bin\s/g, "attribute ").replace(/\bout\s/g, "varying ").replace(/texture\(/g, "texture2D(");
+          }(w3));
+          const T3 = h3.createShader(h3.FRAGMENT_SHADER);
+          if (h3.isContextLost()) return void (this.failedToCreate = true);
+          if (h3.shaderSource(T3, y3), h3.compileShader(T3), !h3.getShaderParameter(T3, h3.COMPILE_STATUS)) throw new Error(`Could not compile fragment shader: ${h3.getShaderInfoLog(T3)}`);
+          h3.attachShader(this.program, T3);
+          const P3 = h3.createShader(h3.VERTEX_SHADER);
+          if (h3.isContextLost()) return void (this.failedToCreate = true);
+          if (h3.shaderSource(P3, w3), h3.compileShader(P3), !h3.getShaderParameter(P3, h3.COMPILE_STATUS)) throw new Error(`Could not compile vertex shader: ${h3.getShaderInfoLog(P3)}`);
+          h3.attachShader(this.program, P3), this.attributes = {};
+          const C3 = {};
+          this.numAttributes = _3.length;
+          for (let e4 = 0; e4 < this.numAttributes; e4++) _3[e4] && (h3.bindAttribLocation(this.program, e4, _3[e4]), this.attributes[_3[e4]] = e4);
+          if (h3.linkProgram(this.program), !h3.getProgramParameter(this.program, h3.LINK_STATUS)) throw new Error(`Program failed to link: ${h3.getProgramInfoLog(this.program)}`);
+          h3.deleteShader(P3), h3.deleteShader(T3);
+          for (let e4 = 0; e4 < x3.length; e4++) {
+            const t3 = x3[e4];
+            if (t3 && !C3[t3]) {
+              const e5 = h3.getUniformLocation(this.program, t3);
+              e5 && (C3[t3] = e5);
+            }
+          }
+          this.fixedUniforms = a3(e3, C3), this.terrainUniforms = ((e4, i4) => ({ u_depth: new t2.bY(e4, i4.u_depth), u_terrain: new t2.bY(e4, i4.u_terrain), u_terrain_dim: new t2.bo(e4, i4.u_terrain_dim), u_terrain_matrix: new t2.b_(e4, i4.u_terrain_matrix), u_terrain_unpack: new t2.b$(e4, i4.u_terrain_unpack), u_terrain_exaggeration: new t2.bo(e4, i4.u_terrain_exaggeration) }))(e3, C3), this.projectionUniforms = ((e4, i4) => ({ u_projection_matrix: new t2.b_(e4, i4.u_projection_matrix), u_projection_tile_mercator_coords: new t2.b$(e4, i4.u_projection_tile_mercator_coords), u_projection_clipping_plane: new t2.b$(e4, i4.u_projection_clipping_plane), u_projection_transition: new t2.bo(e4, i4.u_projection_transition), u_projection_fallback_matrix: new t2.b_(e4, i4.u_projection_fallback_matrix) }))(e3, C3), this.binderUniforms = o3 ? o3.getUniforms(e3, C3) : [];
+        }
+        draw(e3, t3, i3, o3, a3, r3, s3, n3, l3, c3, h3, u3, d3, _3, p3, m3, f3, g3, v3) {
+          const x3 = e3.gl;
+          if (this.failedToCreate) return;
+          if (e3.program.set(this.program), e3.setDepthMode(i3), e3.setStencilMode(o3), e3.setColorMode(a3), e3.setCullFace(r3), n3) {
+            e3.activeTexture.set(x3.TEXTURE2), x3.bindTexture(x3.TEXTURE_2D, n3.depthTexture), e3.activeTexture.set(x3.TEXTURE3), x3.bindTexture(x3.TEXTURE_2D, n3.texture);
+            for (const e4 in this.terrainUniforms) this.terrainUniforms[e4].set(n3[e4]);
+          }
+          if (l3) for (const e4 in l3) this.projectionUniforms[Bi2[e4]].set(l3[e4]);
+          if (s3) for (const e4 in this.fixedUniforms) this.fixedUniforms[e4].set(s3[e4]);
+          m3 && m3.setUniforms(e3, this.binderUniforms, _3, { zoom: p3 });
+          let b3 = 0;
+          switch (t3) {
+            case x3.LINES:
+              b3 = 2;
+              break;
+            case x3.TRIANGLES:
+              b3 = 3;
+              break;
+            case x3.LINE_STRIP:
+              b3 = 1;
+          }
+          for (const i4 of d3.get()) {
+            const o4 = i4.vaos || (i4.vaos = {});
+            (o4[c3] || (o4[c3] = new ki2())).bind(e3, this, h3, m3 ? m3.getPaintVertexBuffers() : [], u3, i4.vertexOffset, f3, g3, v3), x3.drawElements(t3, i4.primitiveLength * b3, x3.UNSIGNED_SHORT, i4.primitiveOffset * b3 * 2);
+          }
+        }
+      }
+      function Ni2(e3, i3, o3) {
+        const a3 = 1 / t2.aK(o3, 1, i3.transform.tileZoom), r3 = Math.pow(2, o3.tileID.overscaledZ), s3 = o3.tileSize * Math.pow(2, i3.transform.tileZoom) / r3, n3 = s3 * (o3.tileID.canonical.x + o3.tileID.wrap * r3), l3 = s3 * o3.tileID.canonical.y;
+        return { u_image: 0, u_texsize: o3.imageAtlasTexture.size, u_scale: [a3, e3.fromScale, e3.toScale], u_fade: e3.t, u_pixel_coord_upper: [n3 >> 16, l3 >> 16], u_pixel_coord_lower: [65535 & n3, 65535 & l3] };
+      }
+      const Zi2 = (e3, i3, o3, a3) => {
+        const r3 = e3.style.light, s3 = r3.properties.get("position"), n3 = [s3.x, s3.y, s3.z], l3 = t2.c2();
+        "viewport" === r3.properties.get("anchor") && t2.c3(l3, e3.transform.bearingInRadians), t2.c4(n3, n3, l3);
+        const c3 = e3.transform.transformLightDirection(n3), h3 = r3.properties.get("color");
+        return { u_lightpos: n3, u_lightpos_globe: c3, u_lightintensity: r3.properties.get("intensity"), u_lightcolor: [h3.r, h3.g, h3.b], u_vertical_gradient: +i3, u_opacity: o3, u_fill_translate: a3 };
+      }, Ui2 = (e3, i3, o3, a3, r3, s3, n3) => t2.e(Zi2(e3, i3, o3, a3), Ni2(s3, e3, n3), { u_height_factor: -Math.pow(2, r3.overscaledZ) / n3.tileSize / 8 }), Gi2 = (e3, i3, o3, a3) => t2.e(Ni2(i3, e3, o3), { u_fill_translate: a3 }), Vi2 = (e3, t3) => ({ u_world: e3, u_fill_translate: t3 }), Wi2 = (e3, i3, o3, a3, r3) => t2.e(Gi2(e3, i3, o3, r3), { u_world: a3 }), qi2 = (e3, i3, o3, a3, r3) => {
+        const s3 = e3.transform;
+        let n3, l3, c3 = 0;
+        if ("map" === o3.paint.get("circle-pitch-alignment")) {
+          const e4 = t2.aK(i3, 1, s3.zoom);
+          n3 = true, l3 = [e4, e4], c3 = e4 / (t2.a5 * Math.pow(2, i3.tileID.overscaledZ)) * 2 * Math.PI * r3;
+        } else n3 = false, l3 = s3.pixelsToGLUnits;
+        return { u_camera_to_center_distance: s3.cameraToCenterDistance, u_scale_with_map: +("map" === o3.paint.get("circle-pitch-scale")), u_pitch_with_map: +n3, u_device_pixel_ratio: e3.pixelRatio, u_extrude_scale: l3, u_globe_extrude_scale: c3, u_translate: a3 };
+      }, $i2 = (e3) => ({ u_pixel_extrude_scale: [1 / e3.width, 1 / e3.height] }), Hi2 = (e3) => ({ u_viewport_size: [e3.width, e3.height] }), Xi2 = (e3, t3 = 1) => ({ u_color: e3, u_overlay: 0, u_overlay_scale: t3 }), Yi2 = (e3, i3, o3, a3) => {
+        const r3 = t2.aK(e3, 1, i3) / (t2.a5 * Math.pow(2, e3.tileID.overscaledZ)) * 2 * Math.PI * a3;
+        return { u_extrude_scale: t2.aK(e3, 1, i3), u_intensity: o3, u_globe_extrude_scale: r3 };
+      }, Ki2 = (e3, i3, o3, a3) => {
+        const r3 = t2.N();
+        t2.c5(r3, 0, e3.width, e3.height, 0, 0, 1);
+        const s3 = e3.context.gl;
+        return { u_matrix: r3, u_world: [s3.drawingBufferWidth, s3.drawingBufferHeight], u_image: o3, u_color_ramp: a3, u_opacity: i3.paint.get("heatmap-opacity") };
+      }, Qi2 = (e3, t3, i3) => {
+        const o3 = i3.paint.get("hillshade-accent-color");
+        let a3;
+        switch (i3.paint.get("hillshade-method")) {
+          case "basic":
+            a3 = 4;
+            break;
+          case "combined":
+            a3 = 1;
+            break;
+          case "igor":
+            a3 = 2;
+            break;
+          case "multidirectional":
+            a3 = 3;
+            break;
+          default:
+            a3 = 0;
+        }
+        const r3 = i3.getIlluminationProperties();
+        for (let t4 = 0; t4 < r3.directionRadians.length; t4++) "viewport" === i3.paint.get("hillshade-illumination-anchor") && (r3.directionRadians[t4] += e3.transform.bearingInRadians);
+        return { u_image: 0, u_latrange: eo(0, t3.tileID), u_exaggeration: i3.paint.get("hillshade-exaggeration"), u_altitudes: r3.altitudeRadians, u_azimuths: r3.directionRadians, u_accent: o3, u_method: a3, u_highlights: r3.highlightColor, u_shadows: r3.shadowColor };
+      }, Ji2 = (e3, i3) => {
+        const o3 = i3.stride, a3 = t2.N();
+        return t2.c5(a3, 0, t2.a5, -t2.a5, 0, 0, 1), t2.O(a3, a3, [0, -t2.a5, 0]), { u_matrix: a3, u_image: 1, u_dimension: [o3, o3], u_zoom: e3.overscaledZ, u_unpack: i3.getUnpackVector() };
+      };
+      function eo(e3, i3) {
+        const o3 = Math.pow(2, i3.canonical.z), a3 = i3.canonical.y;
+        return [new t2.a6(0, a3 / o3).toLngLat().lat, new t2.a6(0, (a3 + 1) / o3).toLngLat().lat];
+      }
+      const to = (e3, t3, i3 = 0) => ({ u_image: 0, u_unpack: t3.getUnpackVector(), u_dimension: [t3.stride, t3.stride], u_elevation_stops: 1, u_color_stops: 4, u_color_ramp_size: i3, u_opacity: e3.paint.get("color-relief-opacity") }), io = (e3, i3, o3, a3) => {
+        const r3 = e3.transform;
+        return { u_translation: lo(e3, i3, o3), u_ratio: a3 / t2.aK(i3, 1, r3.zoom), u_device_pixel_ratio: e3.pixelRatio, u_units_to_pixels: [1 / r3.pixelsToGLUnits[0], 1 / r3.pixelsToGLUnits[1]] };
+      }, oo = (e3, i3, o3, a3, r3) => t2.e(io(e3, i3, o3, a3), { u_image: 0, u_image_height: r3 }), ao = (e3, i3, o3, a3, r3) => {
+        const s3 = e3.transform, n3 = no(i3, s3);
+        return { u_translation: lo(e3, i3, o3), u_texsize: i3.imageAtlasTexture.size, u_ratio: a3 / t2.aK(i3, 1, s3.zoom), u_device_pixel_ratio: e3.pixelRatio, u_image: 0, u_scale: [n3, r3.fromScale, r3.toScale], u_fade: r3.t, u_units_to_pixels: [1 / s3.pixelsToGLUnits[0], 1 / s3.pixelsToGLUnits[1]] };
+      }, ro = (e3, i3, o3, a3, r3) => {
+        const s3 = no(i3, e3.transform);
+        return t2.e(io(e3, i3, o3, a3), { u_tileratio: s3, u_crossfade_from: r3.fromScale, u_crossfade_to: r3.toScale, u_image: 0, u_mix: r3.t, u_lineatlas_width: e3.lineAtlas.width, u_lineatlas_height: e3.lineAtlas.height });
+      }, so = (e3, i3, o3, a3, r3, s3) => {
+        const n3 = no(i3, e3.transform);
+        return t2.e(io(e3, i3, o3, a3), { u_image: 0, u_image_height: s3, u_tileratio: n3, u_crossfade_from: r3.fromScale, u_crossfade_to: r3.toScale, u_image_dash: 1, u_mix: r3.t, u_lineatlas_width: e3.lineAtlas.width, u_lineatlas_height: e3.lineAtlas.height });
+      };
+      function no(e3, i3) {
+        return 1 / t2.aK(e3, 1, i3.tileZoom);
+      }
+      function lo(e3, i3, o3) {
+        return t2.aL(e3.transform, i3, o3.paint.get("line-translate"), o3.paint.get("line-translate-anchor"));
+      }
+      const co = (e3, t3, i3, o3, a3) => {
+        return { u_tl_parent: e3, u_scale_parent: t3, u_buffer_scale: 1, u_fade_t: i3.mix, u_opacity: i3.opacity * o3.paint.get("raster-opacity"), u_image0: 0, u_image1: 1, u_brightness_low: o3.paint.get("raster-brightness-min"), u_brightness_high: o3.paint.get("raster-brightness-max"), u_saturation_factor: (s3 = o3.paint.get("raster-saturation"), s3 > 0 ? 1 - 1 / (1.001 - s3) : -s3), u_contrast_factor: (r3 = o3.paint.get("raster-contrast"), r3 > 0 ? 1 / (1 - r3) : 1 + r3), u_spin_weights: ho(o3.paint.get("raster-hue-rotate")), u_coords_top: [a3[0].x, a3[0].y, a3[1].x, a3[1].y], u_coords_bottom: [a3[3].x, a3[3].y, a3[2].x, a3[2].y] };
+        var r3, s3;
+      };
+      function ho(e3) {
+        e3 *= Math.PI / 180;
+        const t3 = Math.sin(e3), i3 = Math.cos(e3);
+        return [(2 * i3 + 1) / 3, (-Math.sqrt(3) * t3 - i3 + 1) / 3, (Math.sqrt(3) * t3 - i3 + 1) / 3];
+      }
+      const uo = (e3, t3, i3, o3, a3, r3, s3, n3, l3, c3, h3, u3, d3) => {
+        const _3 = s3.transform;
+        return { u_is_size_zoom_constant: +("constant" === e3 || "source" === e3), u_is_size_feature_constant: +("constant" === e3 || "camera" === e3), u_size_t: t3 ? t3.uSizeT : 0, u_size: t3 ? t3.uSize : 0, u_camera_to_center_distance: _3.cameraToCenterDistance, u_pitch: _3.pitch / 360 * 2 * Math.PI, u_rotate_symbol: +i3, u_aspect_ratio: _3.width / _3.height, u_fade_change: s3.options.fadeDuration ? s3.symbolFadeChange : 1, u_label_plane_matrix: n3, u_coord_matrix: l3, u_is_text: +h3, u_pitch_with_map: +o3, u_is_along_line: a3, u_is_variable_anchor: r3, u_texsize: u3, u_texture: 0, u_translation: c3, u_pitched_scale: d3 };
+      }, _o2 = (e3, i3, o3, a3, r3, s3, n3, l3, c3, h3, u3, d3, _3, p3) => {
+        const m3 = n3.transform;
+        return t2.e(uo(e3, i3, o3, a3, r3, s3, n3, l3, c3, h3, u3, d3, p3), { u_gamma_scale: a3 ? Math.cos(m3.pitch * Math.PI / 180) * m3.cameraToCenterDistance : 1, u_device_pixel_ratio: n3.pixelRatio, u_is_halo: 1 });
+      }, po = (e3, i3, o3, a3, r3, s3, n3, l3, c3, h3, u3, d3, _3) => t2.e(_o2(e3, i3, o3, a3, r3, s3, n3, l3, c3, h3, true, u3, 0, _3), { u_texsize_icon: d3, u_texture_icon: 1 }), mo = (e3, t3) => ({ u_opacity: e3, u_color: t3 }), fo = (e3, i3, o3, a3, r3) => t2.e(function(e4, i4, o4, a4) {
+        const r4 = o4.imageManager.getPattern(e4.from.toString()), s3 = o4.imageManager.getPattern(e4.to.toString()), { width: n3, height: l3 } = o4.imageManager.getPixelSize(), c3 = Math.pow(2, a4.tileID.overscaledZ), h3 = a4.tileSize * Math.pow(2, o4.transform.tileZoom) / c3, u3 = h3 * (a4.tileID.canonical.x + a4.tileID.wrap * c3), d3 = h3 * a4.tileID.canonical.y;
+        return { u_image: 0, u_pattern_tl_a: r4.tl, u_pattern_br_a: r4.br, u_pattern_tl_b: s3.tl, u_pattern_br_b: s3.br, u_texsize: [n3, l3], u_mix: i4.t, u_pattern_size_a: r4.displaySize, u_pattern_size_b: s3.displaySize, u_scale_a: i4.fromScale, u_scale_b: i4.toScale, u_tile_units_to_pixels: 1 / t2.aK(a4, 1, o4.transform.tileZoom), u_pixel_coord_upper: [u3 >> 16, d3 >> 16], u_pixel_coord_lower: [65535 & u3, 65535 & d3] };
+      }(o3, r3, i3, a3), { u_opacity: e3 }), go = (e3, t3) => {
+      }, vo = { fillExtrusion: (e3, i3) => ({ u_lightpos: new t2.c0(e3, i3.u_lightpos), u_lightpos_globe: new t2.c0(e3, i3.u_lightpos_globe), u_lightintensity: new t2.bo(e3, i3.u_lightintensity), u_lightcolor: new t2.c0(e3, i3.u_lightcolor), u_vertical_gradient: new t2.bo(e3, i3.u_vertical_gradient), u_opacity: new t2.bo(e3, i3.u_opacity), u_fill_translate: new t2.c1(e3, i3.u_fill_translate) }), fillExtrusionPattern: (e3, i3) => ({ u_lightpos: new t2.c0(e3, i3.u_lightpos), u_lightpos_globe: new t2.c0(e3, i3.u_lightpos_globe), u_lightintensity: new t2.bo(e3, i3.u_lightintensity), u_lightcolor: new t2.c0(e3, i3.u_lightcolor), u_vertical_gradient: new t2.bo(e3, i3.u_vertical_gradient), u_height_factor: new t2.bo(e3, i3.u_height_factor), u_opacity: new t2.bo(e3, i3.u_opacity), u_fill_translate: new t2.c1(e3, i3.u_fill_translate), u_image: new t2.bY(e3, i3.u_image), u_texsize: new t2.c1(e3, i3.u_texsize), u_pixel_coord_upper: new t2.c1(e3, i3.u_pixel_coord_upper), u_pixel_coord_lower: new t2.c1(e3, i3.u_pixel_coord_lower), u_scale: new t2.c0(e3, i3.u_scale), u_fade: new t2.bo(e3, i3.u_fade) }), fill: (e3, i3) => ({ u_fill_translate: new t2.c1(e3, i3.u_fill_translate) }), fillPattern: (e3, i3) => ({ u_image: new t2.bY(e3, i3.u_image), u_texsize: new t2.c1(e3, i3.u_texsize), u_pixel_coord_upper: new t2.c1(e3, i3.u_pixel_coord_upper), u_pixel_coord_lower: new t2.c1(e3, i3.u_pixel_coord_lower), u_scale: new t2.c0(e3, i3.u_scale), u_fade: new t2.bo(e3, i3.u_fade), u_fill_translate: new t2.c1(e3, i3.u_fill_translate) }), fillOutline: (e3, i3) => ({ u_world: new t2.c1(e3, i3.u_world), u_fill_translate: new t2.c1(e3, i3.u_fill_translate) }), fillOutlinePattern: (e3, i3) => ({ u_world: new t2.c1(e3, i3.u_world), u_image: new t2.bY(e3, i3.u_image), u_texsize: new t2.c1(e3, i3.u_texsize), u_pixel_coord_upper: new t2.c1(e3, i3.u_pixel_coord_upper), u_pixel_coord_lower: new t2.c1(e3, i3.u_pixel_coord_lower), u_scale: new t2.c0(e3, i3.u_scale), u_fade: new t2.bo(e3, i3.u_fade), u_fill_translate: new t2.c1(e3, i3.u_fill_translate) }), circle: (e3, i3) => ({ u_camera_to_center_distance: new t2.bo(e3, i3.u_camera_to_center_distance), u_scale_with_map: new t2.bY(e3, i3.u_scale_with_map), u_pitch_with_map: new t2.bY(e3, i3.u_pitch_with_map), u_extrude_scale: new t2.c1(e3, i3.u_extrude_scale), u_device_pixel_ratio: new t2.bo(e3, i3.u_device_pixel_ratio), u_globe_extrude_scale: new t2.bo(e3, i3.u_globe_extrude_scale), u_translate: new t2.c1(e3, i3.u_translate) }), collisionBox: (e3, i3) => ({ u_pixel_extrude_scale: new t2.c1(e3, i3.u_pixel_extrude_scale) }), collisionCircle: (e3, i3) => ({ u_viewport_size: new t2.c1(e3, i3.u_viewport_size) }), debug: (e3, i3) => ({ u_color: new t2.bZ(e3, i3.u_color), u_overlay: new t2.bY(e3, i3.u_overlay), u_overlay_scale: new t2.bo(e3, i3.u_overlay_scale) }), depth: go, clippingMask: go, heatmap: (e3, i3) => ({ u_extrude_scale: new t2.bo(e3, i3.u_extrude_scale), u_intensity: new t2.bo(e3, i3.u_intensity), u_globe_extrude_scale: new t2.bo(e3, i3.u_globe_extrude_scale) }), heatmapTexture: (e3, i3) => ({ u_matrix: new t2.b_(e3, i3.u_matrix), u_world: new t2.c1(e3, i3.u_world), u_image: new t2.bY(e3, i3.u_image), u_color_ramp: new t2.bY(e3, i3.u_color_ramp), u_opacity: new t2.bo(e3, i3.u_opacity) }), hillshade: (e3, i3) => ({ u_image: new t2.bY(e3, i3.u_image), u_latrange: new t2.c1(e3, i3.u_latrange), u_exaggeration: new t2.bo(e3, i3.u_exaggeration), u_altitudes: new t2.c7(e3, i3.u_altitudes), u_azimuths: new t2.c7(e3, i3.u_azimuths), u_accent: new t2.bZ(e3, i3.u_accent), u_method: new t2.bY(e3, i3.u_method), u_shadows: new t2.c6(e3, i3.u_shadows), u_highlights: new t2.c6(e3, i3.u_highlights) }), hillshadePrepare: (e3, i3) => ({ u_matrix: new t2.b_(e3, i3.u_matrix), u_image: new t2.bY(e3, i3.u_image), u_dimension: new t2.c1(e3, i3.u_dimension), u_zoom: new t2.bo(e3, i3.u_zoom), u_unpack: new t2.b$(e3, i3.u_unpack) }), colorRelief: (e3, i3) => ({ u_image: new t2.bY(e3, i3.u_image), u_unpack: new t2.b$(e3, i3.u_unpack), u_dimension: new t2.c1(e3, i3.u_dimension), u_elevation_stops: new t2.bY(e3, i3.u_elevation_stops), u_color_stops: new t2.bY(e3, i3.u_color_stops), u_color_ramp_size: new t2.bY(e3, i3.u_color_ramp_size), u_opacity: new t2.bo(e3, i3.u_opacity) }), line: (e3, i3) => ({ u_translation: new t2.c1(e3, i3.u_translation), u_ratio: new t2.bo(e3, i3.u_ratio), u_device_pixel_ratio: new t2.bo(e3, i3.u_device_pixel_ratio), u_units_to_pixels: new t2.c1(e3, i3.u_units_to_pixels) }), lineGradient: (e3, i3) => ({ u_translation: new t2.c1(e3, i3.u_translation), u_ratio: new t2.bo(e3, i3.u_ratio), u_device_pixel_ratio: new t2.bo(e3, i3.u_device_pixel_ratio), u_units_to_pixels: new t2.c1(e3, i3.u_units_to_pixels), u_image: new t2.bY(e3, i3.u_image), u_image_height: new t2.bo(e3, i3.u_image_height) }), linePattern: (e3, i3) => ({ u_translation: new t2.c1(e3, i3.u_translation), u_texsize: new t2.c1(e3, i3.u_texsize), u_ratio: new t2.bo(e3, i3.u_ratio), u_device_pixel_ratio: new t2.bo(e3, i3.u_device_pixel_ratio), u_image: new t2.bY(e3, i3.u_image), u_units_to_pixels: new t2.c1(e3, i3.u_units_to_pixels), u_scale: new t2.c0(e3, i3.u_scale), u_fade: new t2.bo(e3, i3.u_fade) }), lineSDF: (e3, i3) => ({ u_translation: new t2.c1(e3, i3.u_translation), u_ratio: new t2.bo(e3, i3.u_ratio), u_device_pixel_ratio: new t2.bo(e3, i3.u_device_pixel_ratio), u_units_to_pixels: new t2.c1(e3, i3.u_units_to_pixels), u_image: new t2.bY(e3, i3.u_image), u_mix: new t2.bo(e3, i3.u_mix), u_tileratio: new t2.bo(e3, i3.u_tileratio), u_crossfade_from: new t2.bo(e3, i3.u_crossfade_from), u_crossfade_to: new t2.bo(e3, i3.u_crossfade_to), u_lineatlas_width: new t2.bo(e3, i3.u_lineatlas_width), u_lineatlas_height: new t2.bo(e3, i3.u_lineatlas_height) }), lineGradientSDF: (e3, i3) => ({ u_translation: new t2.c1(e3, i3.u_translation), u_ratio: new t2.bo(e3, i3.u_ratio), u_device_pixel_ratio: new t2.bo(e3, i3.u_device_pixel_ratio), u_units_to_pixels: new t2.c1(e3, i3.u_units_to_pixels), u_image: new t2.bY(e3, i3.u_image), u_image_height: new t2.bo(e3, i3.u_image_height), u_tileratio: new t2.bo(e3, i3.u_tileratio), u_crossfade_from: new t2.bo(e3, i3.u_crossfade_from), u_crossfade_to: new t2.bo(e3, i3.u_crossfade_to), u_image_dash: new t2.bY(e3, i3.u_image_dash), u_mix: new t2.bo(e3, i3.u_mix), u_lineatlas_width: new t2.bo(e3, i3.u_lineatlas_width), u_lineatlas_height: new t2.bo(e3, i3.u_lineatlas_height) }), raster: (e3, i3) => ({ u_tl_parent: new t2.c1(e3, i3.u_tl_parent), u_scale_parent: new t2.bo(e3, i3.u_scale_parent), u_buffer_scale: new t2.bo(e3, i3.u_buffer_scale), u_fade_t: new t2.bo(e3, i3.u_fade_t), u_opacity: new t2.bo(e3, i3.u_opacity), u_image0: new t2.bY(e3, i3.u_image0), u_image1: new t2.bY(e3, i3.u_image1), u_brightness_low: new t2.bo(e3, i3.u_brightness_low), u_brightness_high: new t2.bo(e3, i3.u_brightness_high), u_saturation_factor: new t2.bo(e3, i3.u_saturation_factor), u_contrast_factor: new t2.bo(e3, i3.u_contrast_factor), u_spin_weights: new t2.c0(e3, i3.u_spin_weights), u_coords_top: new t2.b$(e3, i3.u_coords_top), u_coords_bottom: new t2.b$(e3, i3.u_coords_bottom) }), symbolIcon: (e3, i3) => ({ u_is_size_zoom_constant: new t2.bY(e3, i3.u_is_size_zoom_constant), u_is_size_feature_constant: new t2.bY(e3, i3.u_is_size_feature_constant), u_size_t: new t2.bo(e3, i3.u_size_t), u_size: new t2.bo(e3, i3.u_size), u_camera_to_center_distance: new t2.bo(e3, i3.u_camera_to_center_distance), u_pitch: new t2.bo(e3, i3.u_pitch), u_rotate_symbol: new t2.bY(e3, i3.u_rotate_symbol), u_aspect_ratio: new t2.bo(e3, i3.u_aspect_ratio), u_fade_change: new t2.bo(e3, i3.u_fade_change), u_label_plane_matrix: new t2.b_(e3, i3.u_label_plane_matrix), u_coord_matrix: new t2.b_(e3, i3.u_coord_matrix), u_is_text: new t2.bY(e3, i3.u_is_text), u_pitch_with_map: new t2.bY(e3, i3.u_pitch_with_map), u_is_along_line: new t2.bY(e3, i3.u_is_along_line), u_is_variable_anchor: new t2.bY(e3, i3.u_is_variable_anchor), u_texsize: new t2.c1(e3, i3.u_texsize), u_texture: new t2.bY(e3, i3.u_texture), u_translation: new t2.c1(e3, i3.u_translation), u_pitched_scale: new t2.bo(e3, i3.u_pitched_scale) }), symbolSDF: (e3, i3) => ({ u_is_size_zoom_constant: new t2.bY(e3, i3.u_is_size_zoom_constant), u_is_size_feature_constant: new t2.bY(e3, i3.u_is_size_feature_constant), u_size_t: new t2.bo(e3, i3.u_size_t), u_size: new t2.bo(e3, i3.u_size), u_camera_to_center_distance: new t2.bo(e3, i3.u_camera_to_center_distance), u_pitch: new t2.bo(e3, i3.u_pitch), u_rotate_symbol: new t2.bY(e3, i3.u_rotate_symbol), u_aspect_ratio: new t2.bo(e3, i3.u_aspect_ratio), u_fade_change: new t2.bo(e3, i3.u_fade_change), u_label_plane_matrix: new t2.b_(e3, i3.u_label_plane_matrix), u_coord_matrix: new t2.b_(e3, i3.u_coord_matrix), u_is_text: new t2.bY(e3, i3.u_is_text), u_pitch_with_map: new t2.bY(e3, i3.u_pitch_with_map), u_is_along_line: new t2.bY(e3, i3.u_is_along_line), u_is_variable_anchor: new t2.bY(e3, i3.u_is_variable_anchor), u_texsize: new t2.c1(e3, i3.u_texsize), u_texture: new t2.bY(e3, i3.u_texture), u_gamma_scale: new t2.bo(e3, i3.u_gamma_scale), u_device_pixel_ratio: new t2.bo(e3, i3.u_device_pixel_ratio), u_is_halo: new t2.bY(e3, i3.u_is_halo), u_translation: new t2.c1(e3, i3.u_translation), u_pitched_scale: new t2.bo(e3, i3.u_pitched_scale) }), symbolTextAndIcon: (e3, i3) => ({ u_is_size_zoom_constant: new t2.bY(e3, i3.u_is_size_zoom_constant), u_is_size_feature_constant: new t2.bY(e3, i3.u_is_size_feature_constant), u_size_t: new t2.bo(e3, i3.u_size_t), u_size: new t2.bo(e3, i3.u_size), u_camera_to_center_distance: new t2.bo(e3, i3.u_camera_to_center_distance), u_pitch: new t2.bo(e3, i3.u_pitch), u_rotate_symbol: new t2.bY(e3, i3.u_rotate_symbol), u_aspect_ratio: new t2.bo(e3, i3.u_aspect_ratio), u_fade_change: new t2.bo(e3, i3.u_fade_change), u_label_plane_matrix: new t2.b_(e3, i3.u_label_plane_matrix), u_coord_matrix: new t2.b_(e3, i3.u_coord_matrix), u_is_text: new t2.bY(e3, i3.u_is_text), u_pitch_with_map: new t2.bY(e3, i3.u_pitch_with_map), u_is_along_line: new t2.bY(e3, i3.u_is_along_line), u_is_variable_anchor: new t2.bY(e3, i3.u_is_variable_anchor), u_texsize: new t2.c1(e3, i3.u_texsize), u_texsize_icon: new t2.c1(e3, i3.u_texsize_icon), u_texture: new t2.bY(e3, i3.u_texture), u_texture_icon: new t2.bY(e3, i3.u_texture_icon), u_gamma_scale: new t2.bo(e3, i3.u_gamma_scale), u_device_pixel_ratio: new t2.bo(e3, i3.u_device_pixel_ratio), u_is_halo: new t2.bY(e3, i3.u_is_halo), u_translation: new t2.c1(e3, i3.u_translation), u_pitched_scale: new t2.bo(e3, i3.u_pitched_scale) }), background: (e3, i3) => ({ u_opacity: new t2.bo(e3, i3.u_opacity), u_color: new t2.bZ(e3, i3.u_color) }), backgroundPattern: (e3, i3) => ({ u_opacity: new t2.bo(e3, i3.u_opacity), u_image: new t2.bY(e3, i3.u_image), u_pattern_tl_a: new t2.c1(e3, i3.u_pattern_tl_a), u_pattern_br_a: new t2.c1(e3, i3.u_pattern_br_a), u_pattern_tl_b: new t2.c1(e3, i3.u_pattern_tl_b), u_pattern_br_b: new t2.c1(e3, i3.u_pattern_br_b), u_texsize: new t2.c1(e3, i3.u_texsize), u_mix: new t2.bo(e3, i3.u_mix), u_pattern_size_a: new t2.c1(e3, i3.u_pattern_size_a), u_pattern_size_b: new t2.c1(e3, i3.u_pattern_size_b), u_scale_a: new t2.bo(e3, i3.u_scale_a), u_scale_b: new t2.bo(e3, i3.u_scale_b), u_pixel_coord_upper: new t2.c1(e3, i3.u_pixel_coord_upper), u_pixel_coord_lower: new t2.c1(e3, i3.u_pixel_coord_lower), u_tile_units_to_pixels: new t2.bo(e3, i3.u_tile_units_to_pixels) }), terrain: (e3, i3) => ({ u_texture: new t2.bY(e3, i3.u_texture), u_ele_delta: new t2.bo(e3, i3.u_ele_delta), u_fog_matrix: new t2.b_(e3, i3.u_fog_matrix), u_fog_color: new t2.bZ(e3, i3.u_fog_color), u_fog_ground_blend: new t2.bo(e3, i3.u_fog_ground_blend), u_fog_ground_blend_opacity: new t2.bo(e3, i3.u_fog_ground_blend_opacity), u_horizon_color: new t2.bZ(e3, i3.u_horizon_color), u_horizon_fog_blend: new t2.bo(e3, i3.u_horizon_fog_blend), u_is_globe_mode: new t2.bo(e3, i3.u_is_globe_mode) }), terrainDepth: (e3, i3) => ({ u_ele_delta: new t2.bo(e3, i3.u_ele_delta) }), terrainCoords: (e3, i3) => ({ u_texture: new t2.bY(e3, i3.u_texture), u_terrain_coords_id: new t2.bo(e3, i3.u_terrain_coords_id), u_ele_delta: new t2.bo(e3, i3.u_ele_delta) }), projectionErrorMeasurement: (e3, i3) => ({ u_input: new t2.bo(e3, i3.u_input), u_output_expected: new t2.bo(e3, i3.u_output_expected) }), atmosphere: (e3, i3) => ({ u_sun_pos: new t2.c0(e3, i3.u_sun_pos), u_atmosphere_blend: new t2.bo(e3, i3.u_atmosphere_blend), u_globe_position: new t2.c0(e3, i3.u_globe_position), u_globe_radius: new t2.bo(e3, i3.u_globe_radius), u_inv_proj_matrix: new t2.b_(e3, i3.u_inv_proj_matrix) }), sky: (e3, i3) => ({ u_sky_color: new t2.bZ(e3, i3.u_sky_color), u_horizon_color: new t2.bZ(e3, i3.u_horizon_color), u_horizon: new t2.c1(e3, i3.u_horizon), u_horizon_normal: new t2.c1(e3, i3.u_horizon_normal), u_sky_horizon_blend: new t2.bo(e3, i3.u_sky_horizon_blend), u_sky_blend: new t2.bo(e3, i3.u_sky_blend) }) };
+      class xo {
+        constructor(e3, t3, i3) {
+          this.context = e3;
+          const o3 = e3.gl;
+          this.buffer = o3.createBuffer(), this.dynamicDraw = Boolean(i3), this.context.unbindVAO(), e3.bindElementBuffer.set(this.buffer), o3.bufferData(o3.ELEMENT_ARRAY_BUFFER, t3.arrayBuffer, this.dynamicDraw ? o3.DYNAMIC_DRAW : o3.STATIC_DRAW), this.dynamicDraw || t3.freeBufferAfterUpload();
+        }
+        bind() {
+          this.context.bindElementBuffer.set(this.buffer);
+        }
+        updateData(e3) {
+          const t3 = this.context.gl;
+          if (!this.dynamicDraw) throw new Error("Attempted to update data while not in dynamic mode.");
+          this.context.unbindVAO(), this.bind(), t3.bufferSubData(t3.ELEMENT_ARRAY_BUFFER, 0, e3.arrayBuffer);
+        }
+        destroy() {
+          this.buffer && (this.context.gl.deleteBuffer(this.buffer), delete this.buffer);
+        }
+      }
+      const bo = { Int8: "BYTE", Uint8: "UNSIGNED_BYTE", Int16: "SHORT", Uint16: "UNSIGNED_SHORT", Int32: "INT", Uint32: "UNSIGNED_INT", Float32: "FLOAT" };
+      class yo {
+        constructor(e3, t3, i3, o3) {
+          this.length = t3.length, this.attributes = i3, this.itemSize = t3.bytesPerElement, this.dynamicDraw = o3, this.context = e3;
+          const a3 = e3.gl;
+          this.buffer = a3.createBuffer(), e3.bindVertexBuffer.set(this.buffer), a3.bufferData(a3.ARRAY_BUFFER, t3.arrayBuffer, this.dynamicDraw ? a3.DYNAMIC_DRAW : a3.STATIC_DRAW), this.dynamicDraw || t3.freeBufferAfterUpload();
+        }
+        bind() {
+          this.context.bindVertexBuffer.set(this.buffer);
+        }
+        updateData(e3) {
+          if (e3.length !== this.length) throw new Error(`Length of new data is ${e3.length}, which doesn't match current length of ${this.length}`);
+          const t3 = this.context.gl;
+          this.bind(), t3.bufferSubData(t3.ARRAY_BUFFER, 0, e3.arrayBuffer);
+        }
+        enableAttributes(e3, t3) {
+          for (let i3 = 0; i3 < this.attributes.length; i3++) {
+            const o3 = t3.attributes[this.attributes[i3].name];
+            void 0 !== o3 && e3.enableVertexAttribArray(o3);
+          }
+        }
+        setVertexAttribPointers(e3, t3, i3) {
+          for (let o3 = 0; o3 < this.attributes.length; o3++) {
+            const a3 = this.attributes[o3], r3 = t3.attributes[a3.name];
+            void 0 !== r3 && e3.vertexAttribPointer(r3, a3.components, e3[bo[a3.type]], false, this.itemSize, a3.offset + this.itemSize * (i3 || 0));
+          }
+        }
+        destroy() {
+          this.buffer && (this.context.gl.deleteBuffer(this.buffer), delete this.buffer);
+        }
+      }
+      class wo {
+        constructor(e3) {
+          this.gl = e3.gl, this.default = this.getDefault(), this.current = this.default, this.dirty = false;
+        }
+        get() {
+          return this.current;
+        }
+        set(e3) {
+        }
+        getDefault() {
+          return this.default;
+        }
+        setDefault() {
+          this.set(this.default);
+        }
+      }
+      class To extends wo {
+        getDefault() {
+          return t2.bn.transparent;
+        }
+        set(e3) {
+          const t3 = this.current;
+          (e3.r !== t3.r || e3.g !== t3.g || e3.b !== t3.b || e3.a !== t3.a || this.dirty) && (this.gl.clearColor(e3.r, e3.g, e3.b, e3.a), this.current = e3, this.dirty = false);
+        }
+      }
+      class Po extends wo {
+        getDefault() {
+          return 1;
+        }
+        set(e3) {
+          (e3 !== this.current || this.dirty) && (this.gl.clearDepth(e3), this.current = e3, this.dirty = false);
+        }
+      }
+      class Co extends wo {
+        getDefault() {
+          return 0;
+        }
+        set(e3) {
+          (e3 !== this.current || this.dirty) && (this.gl.clearStencil(e3), this.current = e3, this.dirty = false);
+        }
+      }
+      class Io extends wo {
+        getDefault() {
+          return [true, true, true, true];
+        }
+        set(e3) {
+          const t3 = this.current;
+          (e3[0] !== t3[0] || e3[1] !== t3[1] || e3[2] !== t3[2] || e3[3] !== t3[3] || this.dirty) && (this.gl.colorMask(e3[0], e3[1], e3[2], e3[3]), this.current = e3, this.dirty = false);
+        }
+      }
+      class Mo extends wo {
+        getDefault() {
+          return true;
+        }
+        set(e3) {
+          (e3 !== this.current || this.dirty) && (this.gl.depthMask(e3), this.current = e3, this.dirty = false);
+        }
+      }
+      class Eo extends wo {
+        getDefault() {
+          return 255;
+        }
+        set(e3) {
+          (e3 !== this.current || this.dirty) && (this.gl.stencilMask(e3), this.current = e3, this.dirty = false);
+        }
+      }
+      class So extends wo {
+        getDefault() {
+          return { func: this.gl.ALWAYS, ref: 0, mask: 255 };
+        }
+        set(e3) {
+          const t3 = this.current;
+          (e3.func !== t3.func || e3.ref !== t3.ref || e3.mask !== t3.mask || this.dirty) && (this.gl.stencilFunc(e3.func, e3.ref, e3.mask), this.current = e3, this.dirty = false);
+        }
+      }
+      class Ro extends wo {
+        getDefault() {
+          const e3 = this.gl;
+          return [e3.KEEP, e3.KEEP, e3.KEEP];
+        }
+        set(e3) {
+          const t3 = this.current;
+          (e3[0] !== t3[0] || e3[1] !== t3[1] || e3[2] !== t3[2] || this.dirty) && (this.gl.stencilOp(e3[0], e3[1], e3[2]), this.current = e3, this.dirty = false);
+        }
+      }
+      class zo extends wo {
+        getDefault() {
+          return false;
+        }
+        set(e3) {
+          if (e3 === this.current && !this.dirty) return;
+          const t3 = this.gl;
+          e3 ? t3.enable(t3.STENCIL_TEST) : t3.disable(t3.STENCIL_TEST), this.current = e3, this.dirty = false;
+        }
+      }
+      class Do extends wo {
+        getDefault() {
+          return [0, 1];
+        }
+        set(e3) {
+          const t3 = this.current;
+          (e3[0] !== t3[0] || e3[1] !== t3[1] || this.dirty) && (this.gl.depthRange(e3[0], e3[1]), this.current = e3, this.dirty = false);
+        }
+      }
+      class Ao extends wo {
+        getDefault() {
+          return false;
+        }
+        set(e3) {
+          if (e3 === this.current && !this.dirty) return;
+          const t3 = this.gl;
+          e3 ? t3.enable(t3.DEPTH_TEST) : t3.disable(t3.DEPTH_TEST), this.current = e3, this.dirty = false;
+        }
+      }
+      class Lo extends wo {
+        getDefault() {
+          return this.gl.LESS;
+        }
+        set(e3) {
+          (e3 !== this.current || this.dirty) && (this.gl.depthFunc(e3), this.current = e3, this.dirty = false);
+        }
+      }
+      class ko extends wo {
+        getDefault() {
+          return false;
+        }
+        set(e3) {
+          if (e3 === this.current && !this.dirty) return;
+          const t3 = this.gl;
+          e3 ? t3.enable(t3.BLEND) : t3.disable(t3.BLEND), this.current = e3, this.dirty = false;
+        }
+      }
+      class Fo extends wo {
+        getDefault() {
+          const e3 = this.gl;
+          return [e3.ONE, e3.ZERO];
+        }
+        set(e3) {
+          const t3 = this.current;
+          (e3[0] !== t3[0] || e3[1] !== t3[1] || this.dirty) && (this.gl.blendFunc(e3[0], e3[1]), this.current = e3, this.dirty = false);
+        }
+      }
+      class Bo extends wo {
+        getDefault() {
+          return t2.bn.transparent;
+        }
+        set(e3) {
+          const t3 = this.current;
+          (e3.r !== t3.r || e3.g !== t3.g || e3.b !== t3.b || e3.a !== t3.a || this.dirty) && (this.gl.blendColor(e3.r, e3.g, e3.b, e3.a), this.current = e3, this.dirty = false);
+        }
+      }
+      class Oo extends wo {
+        getDefault() {
+          return this.gl.FUNC_ADD;
+        }
+        set(e3) {
+          (e3 !== this.current || this.dirty) && (this.gl.blendEquation(e3), this.current = e3, this.dirty = false);
+        }
+      }
+      class jo extends wo {
+        getDefault() {
+          return false;
+        }
+        set(e3) {
+          if (e3 === this.current && !this.dirty) return;
+          const t3 = this.gl;
+          e3 ? t3.enable(t3.CULL_FACE) : t3.disable(t3.CULL_FACE), this.current = e3, this.dirty = false;
+        }
+      }
+      class No extends wo {
+        getDefault() {
+          return this.gl.BACK;
+        }
+        set(e3) {
+          (e3 !== this.current || this.dirty) && (this.gl.cullFace(e3), this.current = e3, this.dirty = false);
+        }
+      }
+      class Zo extends wo {
+        getDefault() {
+          return this.gl.CCW;
+        }
+        set(e3) {
+          (e3 !== this.current || this.dirty) && (this.gl.frontFace(e3), this.current = e3, this.dirty = false);
+        }
+      }
+      class Uo extends wo {
+        getDefault() {
+          return null;
+        }
+        set(e3) {
+          (e3 !== this.current || this.dirty) && (this.gl.useProgram(e3), this.current = e3, this.dirty = false);
+        }
+      }
+      class Go extends wo {
+        getDefault() {
+          return this.gl.TEXTURE0;
+        }
+        set(e3) {
+          (e3 !== this.current || this.dirty) && (this.gl.activeTexture(e3), this.current = e3, this.dirty = false);
+        }
+      }
+      class Vo extends wo {
+        getDefault() {
+          const e3 = this.gl;
+          return [0, 0, e3.drawingBufferWidth, e3.drawingBufferHeight];
+        }
+        set(e3) {
+          const t3 = this.current;
+          (e3[0] !== t3[0] || e3[1] !== t3[1] || e3[2] !== t3[2] || e3[3] !== t3[3] || this.dirty) && (this.gl.viewport(e3[0], e3[1], e3[2], e3[3]), this.current = e3, this.dirty = false);
+        }
+      }
+      class Wo extends wo {
+        getDefault() {
+          return null;
+        }
+        set(e3) {
+          if (e3 === this.current && !this.dirty) return;
+          const t3 = this.gl;
+          t3.bindFramebuffer(t3.FRAMEBUFFER, e3), this.current = e3, this.dirty = false;
+        }
+      }
+      class qo extends wo {
+        getDefault() {
+          return null;
+        }
+        set(e3) {
+          if (e3 === this.current && !this.dirty) return;
+          const t3 = this.gl;
+          t3.bindRenderbuffer(t3.RENDERBUFFER, e3), this.current = e3, this.dirty = false;
+        }
+      }
+      class $o extends wo {
+        getDefault() {
+          return null;
+        }
+        set(e3) {
+          if (e3 === this.current && !this.dirty) return;
+          const t3 = this.gl;
+          t3.bindTexture(t3.TEXTURE_2D, e3), this.current = e3, this.dirty = false;
+        }
+      }
+      class Ho extends wo {
+        getDefault() {
+          return null;
+        }
+        set(e3) {
+          if (e3 === this.current && !this.dirty) return;
+          const t3 = this.gl;
+          t3.bindBuffer(t3.ARRAY_BUFFER, e3), this.current = e3, this.dirty = false;
+        }
+      }
+      class Xo extends wo {
+        getDefault() {
+          return null;
+        }
+        set(e3) {
+          const t3 = this.gl;
+          t3.bindBuffer(t3.ELEMENT_ARRAY_BUFFER, e3), this.current = e3, this.dirty = false;
+        }
+      }
+      class Yo extends wo {
+        getDefault() {
+          return null;
+        }
+        set(e3) {
+          var t3;
+          if (e3 === this.current && !this.dirty) return;
+          const i3 = this.gl;
+          oi2(i3) ? i3.bindVertexArray(e3) : null === (t3 = i3.getExtension("OES_vertex_array_object")) || void 0 === t3 || t3.bindVertexArrayOES(e3), this.current = e3, this.dirty = false;
+        }
+      }
+      class Ko extends wo {
+        getDefault() {
+          return 4;
+        }
+        set(e3) {
+          if (e3 === this.current && !this.dirty) return;
+          const t3 = this.gl;
+          t3.pixelStorei(t3.UNPACK_ALIGNMENT, e3), this.current = e3, this.dirty = false;
+        }
+      }
+      class Qo extends wo {
+        getDefault() {
+          return false;
+        }
+        set(e3) {
+          if (e3 === this.current && !this.dirty) return;
+          const t3 = this.gl;
+          t3.pixelStorei(t3.UNPACK_PREMULTIPLY_ALPHA_WEBGL, e3), this.current = e3, this.dirty = false;
+        }
+      }
+      class Jo extends wo {
+        getDefault() {
+          return false;
+        }
+        set(e3) {
+          if (e3 === this.current && !this.dirty) return;
+          const t3 = this.gl;
+          t3.pixelStorei(t3.UNPACK_FLIP_Y_WEBGL, e3), this.current = e3, this.dirty = false;
+        }
+      }
+      class ea2 extends wo {
+        constructor(e3, t3) {
+          super(e3), this.context = e3, this.parent = t3;
+        }
+        getDefault() {
+          return null;
+        }
+      }
+      class ta2 extends ea2 {
+        setDirty() {
+          this.dirty = true;
+        }
+        set(e3) {
+          if (e3 === this.current && !this.dirty) return;
+          this.context.bindFramebuffer.set(this.parent);
+          const t3 = this.gl;
+          t3.framebufferTexture2D(t3.FRAMEBUFFER, t3.COLOR_ATTACHMENT0, t3.TEXTURE_2D, e3, 0), this.current = e3, this.dirty = false;
+        }
+      }
+      class ia2 extends ea2 {
+        set(e3) {
+          if (e3 === this.current && !this.dirty) return;
+          this.context.bindFramebuffer.set(this.parent);
+          const t3 = this.gl;
+          t3.framebufferRenderbuffer(t3.FRAMEBUFFER, t3.DEPTH_ATTACHMENT, t3.RENDERBUFFER, e3), this.current = e3, this.dirty = false;
+        }
+      }
+      class oa2 extends ea2 {
+        set(e3) {
+          if (e3 === this.current && !this.dirty) return;
+          this.context.bindFramebuffer.set(this.parent);
+          const t3 = this.gl;
+          t3.framebufferRenderbuffer(t3.FRAMEBUFFER, t3.DEPTH_STENCIL_ATTACHMENT, t3.RENDERBUFFER, e3), this.current = e3, this.dirty = false;
+        }
+      }
+      const aa2 = "Framebuffer is not complete";
+      class ra2 {
+        constructor(e3, t3, i3, o3, a3) {
+          this.context = e3, this.width = t3, this.height = i3;
+          const r3 = e3.gl, s3 = this.framebuffer = r3.createFramebuffer();
+          if (this.colorAttachment = new ta2(e3, s3), o3) this.depthAttachment = a3 ? new oa2(e3, s3) : new ia2(e3, s3);
+          else if (a3) throw new Error("Stencil cannot be set without depth");
+          if (r3.checkFramebufferStatus(r3.FRAMEBUFFER) !== r3.FRAMEBUFFER_COMPLETE) throw new Error(aa2);
+        }
+        destroy() {
+          const e3 = this.context.gl, t3 = this.colorAttachment.get();
+          if (t3 && e3.deleteTexture(t3), this.depthAttachment) {
+            const t4 = this.depthAttachment.get();
+            t4 && e3.deleteRenderbuffer(t4);
+          }
+          e3.deleteFramebuffer(this.framebuffer);
+        }
+      }
+      class sa2 {
+        constructor(e3) {
+          var t3, i3;
+          if (this.gl = e3, this.clearColor = new To(this), this.clearDepth = new Po(this), this.clearStencil = new Co(this), this.colorMask = new Io(this), this.depthMask = new Mo(this), this.stencilMask = new Eo(this), this.stencilFunc = new So(this), this.stencilOp = new Ro(this), this.stencilTest = new zo(this), this.depthRange = new Do(this), this.depthTest = new Ao(this), this.depthFunc = new Lo(this), this.blend = new ko(this), this.blendFunc = new Fo(this), this.blendColor = new Bo(this), this.blendEquation = new Oo(this), this.cullFace = new jo(this), this.cullFaceSide = new No(this), this.frontFace = new Zo(this), this.program = new Uo(this), this.activeTexture = new Go(this), this.viewport = new Vo(this), this.bindFramebuffer = new Wo(this), this.bindRenderbuffer = new qo(this), this.bindTexture = new $o(this), this.bindVertexBuffer = new Ho(this), this.bindElementBuffer = new Xo(this), this.bindVertexArray = new Yo(this), this.pixelStoreUnpack = new Ko(this), this.pixelStoreUnpackPremultiplyAlpha = new Qo(this), this.pixelStoreUnpackFlipY = new Jo(this), this.extTextureFilterAnisotropic = e3.getExtension("EXT_texture_filter_anisotropic"), this.extTextureFilterAnisotropic && (this.extTextureFilterAnisotropicMax = e3.getParameter(this.extTextureFilterAnisotropic.MAX_TEXTURE_MAX_ANISOTROPY_EXT)), this.maxTextureSize = e3.getParameter(e3.MAX_TEXTURE_SIZE), oi2(e3)) {
+            this.HALF_FLOAT = e3.HALF_FLOAT;
+            const o3 = e3.getExtension("EXT_color_buffer_half_float");
+            this.RGBA16F = null !== (t3 = e3.RGBA16F) && void 0 !== t3 ? t3 : null == o3 ? void 0 : o3.RGBA16F_EXT, this.RGB16F = null !== (i3 = e3.RGB16F) && void 0 !== i3 ? i3 : null == o3 ? void 0 : o3.RGB16F_EXT, e3.getExtension("EXT_color_buffer_float");
+          } else {
+            e3.getExtension("EXT_color_buffer_half_float"), e3.getExtension("OES_texture_half_float_linear");
+            const t4 = e3.getExtension("OES_texture_half_float");
+            this.HALF_FLOAT = null == t4 ? void 0 : t4.HALF_FLOAT_OES;
+          }
+        }
+        setDefault() {
+          this.unbindVAO(), this.clearColor.setDefault(), this.clearDepth.setDefault(), this.clearStencil.setDefault(), this.colorMask.setDefault(), this.depthMask.setDefault(), this.stencilMask.setDefault(), this.stencilFunc.setDefault(), this.stencilOp.setDefault(), this.stencilTest.setDefault(), this.depthRange.setDefault(), this.depthTest.setDefault(), this.depthFunc.setDefault(), this.blend.setDefault(), this.blendFunc.setDefault(), this.blendColor.setDefault(), this.blendEquation.setDefault(), this.cullFace.setDefault(), this.cullFaceSide.setDefault(), this.frontFace.setDefault(), this.program.setDefault(), this.activeTexture.setDefault(), this.bindFramebuffer.setDefault(), this.pixelStoreUnpack.setDefault(), this.pixelStoreUnpackPremultiplyAlpha.setDefault(), this.pixelStoreUnpackFlipY.setDefault();
+        }
+        setDirty() {
+          this.clearColor.dirty = true, this.clearDepth.dirty = true, this.clearStencil.dirty = true, this.colorMask.dirty = true, this.depthMask.dirty = true, this.stencilMask.dirty = true, this.stencilFunc.dirty = true, this.stencilOp.dirty = true, this.stencilTest.dirty = true, this.depthRange.dirty = true, this.depthTest.dirty = true, this.depthFunc.dirty = true, this.blend.dirty = true, this.blendFunc.dirty = true, this.blendColor.dirty = true, this.blendEquation.dirty = true, this.cullFace.dirty = true, this.cullFaceSide.dirty = true, this.frontFace.dirty = true, this.program.dirty = true, this.activeTexture.dirty = true, this.viewport.dirty = true, this.bindFramebuffer.dirty = true, this.bindRenderbuffer.dirty = true, this.bindTexture.dirty = true, this.bindVertexBuffer.dirty = true, this.bindElementBuffer.dirty = true, this.bindVertexArray.dirty = true, this.pixelStoreUnpack.dirty = true, this.pixelStoreUnpackPremultiplyAlpha.dirty = true, this.pixelStoreUnpackFlipY.dirty = true;
+        }
+        createIndexBuffer(e3, t3) {
+          return new xo(this, e3, t3);
+        }
+        createVertexBuffer(e3, t3, i3) {
+          return new yo(this, e3, t3, i3);
+        }
+        createRenderbuffer(e3, t3, i3) {
+          const o3 = this.gl, a3 = o3.createRenderbuffer();
+          return this.bindRenderbuffer.set(a3), o3.renderbufferStorage(o3.RENDERBUFFER, e3, t3, i3), this.bindRenderbuffer.set(null), a3;
+        }
+        createFramebuffer(e3, t3, i3, o3) {
+          return new ra2(this, e3, t3, i3, o3);
+        }
+        clear({ color: e3, depth: t3, stencil: i3 }) {
+          const o3 = this.gl;
+          let a3 = 0;
+          e3 && (a3 |= o3.COLOR_BUFFER_BIT, this.clearColor.set(e3), this.colorMask.set([true, true, true, true])), void 0 !== t3 && (a3 |= o3.DEPTH_BUFFER_BIT, this.depthRange.set([0, 1]), this.clearDepth.set(t3), this.depthMask.set(true)), void 0 !== i3 && (a3 |= o3.STENCIL_BUFFER_BIT, this.clearStencil.set(i3), this.stencilMask.set(255)), o3.clear(a3);
+        }
+        setCullFace(e3) {
+          false === e3.enable ? this.cullFace.set(false) : (this.cullFace.set(true), this.cullFaceSide.set(e3.mode), this.frontFace.set(e3.frontFace));
+        }
+        setDepthMode(e3) {
+          e3.func !== this.gl.ALWAYS || e3.mask ? (this.depthTest.set(true), this.depthFunc.set(e3.func), this.depthMask.set(e3.mask), this.depthRange.set(e3.range)) : this.depthTest.set(false);
+        }
+        setStencilMode(e3) {
+          e3.test.func !== this.gl.ALWAYS || e3.mask ? (this.stencilTest.set(true), this.stencilMask.set(e3.mask), this.stencilOp.set([e3.fail, e3.depthFail, e3.pass]), this.stencilFunc.set({ func: e3.test.func, ref: e3.ref, mask: e3.test.mask })) : this.stencilTest.set(false);
+        }
+        setColorMode(e3) {
+          t2.bP(e3.blendFunction, Yt.Replace) ? this.blend.set(false) : (this.blend.set(true), this.blendFunc.set(e3.blendFunction), this.blendColor.set(e3.blendColor)), this.colorMask.set(e3.mask);
+        }
+        createVertexArray() {
+          var e3;
+          return oi2(this.gl) ? this.gl.createVertexArray() : null === (e3 = this.gl.getExtension("OES_vertex_array_object")) || void 0 === e3 ? void 0 : e3.createVertexArrayOES();
+        }
+        deleteVertexArray(e3) {
+          var t3;
+          return oi2(this.gl) ? this.gl.deleteVertexArray(e3) : null === (t3 = this.gl.getExtension("OES_vertex_array_object")) || void 0 === t3 ? void 0 : t3.deleteVertexArrayOES(e3);
+        }
+        unbindVAO() {
+          this.bindVertexArray.set(null);
+        }
+      }
+      let na;
+      function la2(e3, i3, o3, a3, r3) {
+        const s3 = e3.context, n3 = e3.transform, l3 = s3.gl, c3 = e3.useProgram("collisionBox"), h3 = [];
+        let u3 = 0, d3 = 0;
+        for (let t3 = 0; t3 < a3.length; t3++) {
+          const _4 = a3[t3], p4 = i3.getTile(_4).getBucket(o3);
+          if (!p4) continue;
+          const m4 = r3 ? p4.textCollisionBox : p4.iconCollisionBox, f4 = p4.collisionCircleArray;
+          f4.length > 0 && (h3.push({ circleArray: f4, circleOffset: d3, coord: _4 }), u3 += f4.length / 4, d3 = u3), m4 && c3.draw(s3, l3.LINES, Jt.disabled, ti2.disabled, e3.colorModeForRenderPass(), Qt.disabled, $i2(e3.transform), e3.style.map.terrain && e3.style.map.terrain.getTerrainData(_4), n3.getProjectionData({ overscaledTileID: _4, applyGlobeMatrix: true, applyTerrainMatrix: true }), o3.id, m4.layoutVertexBuffer, m4.indexBuffer, m4.segments, null, e3.transform.zoom, null, null, m4.collisionVertexBuffer);
+        }
+        if (!r3 || !h3.length) return;
+        const _3 = e3.useProgram("collisionCircle"), p3 = new t2.c8();
+        p3.resize(4 * u3), p3._trim();
+        let m3 = 0;
+        for (const e4 of h3) for (let t3 = 0; t3 < e4.circleArray.length / 4; t3++) {
+          const i4 = 4 * t3, o4 = e4.circleArray[i4 + 0], a4 = e4.circleArray[i4 + 1], r4 = e4.circleArray[i4 + 2], s4 = e4.circleArray[i4 + 3];
+          p3.emplace(m3++, o4, a4, r4, s4, 0), p3.emplace(m3++, o4, a4, r4, s4, 1), p3.emplace(m3++, o4, a4, r4, s4, 2), p3.emplace(m3++, o4, a4, r4, s4, 3);
+        }
+        (!na || na.length < 2 * u3) && (na = function(e4) {
+          const i4 = 2 * e4, o4 = new t2.ca();
+          o4.resize(i4), o4._trim();
+          for (let e5 = 0; e5 < i4; e5++) {
+            const t3 = 6 * e5;
+            o4.uint16[t3 + 0] = 4 * e5 + 0, o4.uint16[t3 + 1] = 4 * e5 + 1, o4.uint16[t3 + 2] = 4 * e5 + 2, o4.uint16[t3 + 3] = 4 * e5 + 2, o4.uint16[t3 + 4] = 4 * e5 + 3, o4.uint16[t3 + 5] = 4 * e5 + 0;
+          }
+          return o4;
+        }(u3));
+        const f3 = s3.createIndexBuffer(na, true), g3 = s3.createVertexBuffer(p3, t2.c9.members, true);
+        for (const i4 of h3) {
+          const a4 = Hi2(e3.transform);
+          _3.draw(s3, l3.TRIANGLES, Jt.disabled, ti2.disabled, e3.colorModeForRenderPass(), Qt.disabled, a4, e3.style.map.terrain && e3.style.map.terrain.getTerrainData(i4.coord), null, o3.id, g3, f3, t2.aV.simpleSegment(0, 2 * i4.circleOffset, i4.circleArray.length, i4.circleArray.length / 2), null, e3.transform.zoom, null, null, null);
+        }
+        g3.destroy(), f3.destroy();
+      }
+      const ca2 = t2.ao(new Float32Array(16));
+      function ha2(e3, i3, o3, a3, r3, s3) {
+        const { horizontalAlign: n3, verticalAlign: l3 } = t2.aP(e3);
+        return new t2.P((-(n3 - 0.5) * i3 / r3 + a3[0]) * s3, (-(l3 - 0.5) * o3 / r3 + a3[1]) * s3);
+      }
+      function ua2(e3, i3, o3, a3, r3, s3) {
+        const n3 = i3.tileAnchorPoint.add(new t2.P(i3.translation[0], i3.translation[1]));
+        if (i3.pitchWithMap) {
+          let e4 = a3.mult(s3);
+          o3 || (e4 = e4.rotate(-r3));
+          const t3 = n3.add(e4);
+          return Ne2(t3.x, t3.y, i3.pitchedLabelPlaneMatrix, i3.getElevation).point;
+        }
+        if (o3) {
+          const t3 = Xe2(i3.tileAnchorPoint.x + 1, i3.tileAnchorPoint.y, i3).point.sub(e3), o4 = Math.atan(t3.y / t3.x) + (t3.x < 0 ? Math.PI : 0);
+          return e3.add(a3.rotate(o4));
+        }
+        return e3.add(a3);
+      }
+      function da2(e3, i3, o3, a3, r3, s3, n3, l3, c3, h3, u3, d3) {
+        const _3 = e3.text.placedSymbolArray, p3 = e3.text.dynamicLayoutVertexArray, m3 = e3.icon.dynamicLayoutVertexArray, f3 = {};
+        p3.clear();
+        for (let m4 = 0; m4 < _3.length; m4++) {
+          const g3 = _3.get(m4), v3 = g3.hidden || !g3.crossTileID || e3.allowVerticalPlacement && !g3.placedOrientation ? null : a3[g3.crossTileID];
+          if (v3) {
+            const a4 = new t2.P(g3.anchorX, g3.anchorY), _4 = { getElevation: d3, width: r3.width, height: r3.height, pitchedLabelPlaneMatrix: s3, pitchWithMap: o3, transform: r3, tileAnchorPoint: a4, translation: h3, unwrappedTileID: u3 }, m5 = o3 ? Ke2(a4.x, a4.y, _4) : Xe2(a4.x, a4.y, _4), x3 = Ze2(r3.cameraToCenterDistance, m5.signedDistanceFromCamera);
+            let b3 = t2.ax(e3.textSizeData, l3, g3) * x3 / t2.aJ;
+            o3 && (b3 *= e3.tilePixelRatio / n3);
+            const { width: y3, height: w3, anchor: T3, textOffset: P3, textBoxScale: C3 } = v3, I3 = ha2(T3, y3, w3, P3, C3, b3), M3 = r3.getPitchedTextCorrection(a4.x + h3[0], a4.y + h3[1], u3), E3 = ua2(m5.point, _4, i3, I3, -r3.bearingInRadians, M3), S3 = e3.allowVerticalPlacement && g3.placedOrientation === t2.aw.vertical ? Math.PI / 2 : 0;
+            for (let e4 = 0; e4 < g3.numGlyphs; e4++) t2.aD(p3, E3, S3);
+            c3 && g3.associatedIconIndex >= 0 && (f3[g3.associatedIconIndex] = { shiftedAnchor: E3, angle: S3 });
+          } else it2(g3.numGlyphs, p3);
+        }
+        if (c3) {
+          m3.clear();
+          const i4 = e3.icon.placedSymbolArray;
+          for (let e4 = 0; e4 < i4.length; e4++) {
+            const o4 = i4.get(e4);
+            if (o4.hidden) it2(o4.numGlyphs, m3);
+            else {
+              const i5 = f3[e4];
+              if (i5) for (let e5 = 0; e5 < o4.numGlyphs; e5++) t2.aD(m3, i5.shiftedAnchor, i5.angle);
+              else it2(o4.numGlyphs, m3);
+            }
+          }
+          e3.icon.dynamicLayoutVertexBuffer.updateData(m3);
+        }
+        e3.text.dynamicLayoutVertexBuffer.updateData(p3);
+      }
+      function _a3(e3, t3, i3) {
+        return i3.iconsInText && t3 ? "symbolTextAndIcon" : e3 ? "symbolSDF" : "symbolIcon";
+      }
+      function pa2(e3, i3, o3, a3, r3, s3, n3, l3, c3, h3, u3, d3, _3) {
+        const p3 = e3.context, m3 = p3.gl, f3 = e3.transform, g3 = "map" === l3, v3 = "map" === c3, x3 = "viewport" !== l3 && "point" !== o3.layout.get("symbol-placement"), b3 = g3 && !v3 && !x3, y3 = !o3.layout.get("symbol-sort-key").isConstant();
+        let w3 = false;
+        const T3 = e3.getDepthModeForSublayer(0, Jt.ReadOnly), P3 = o3._unevaluatedLayout.hasValue("text-variable-anchor") || o3._unevaluatedLayout.hasValue("text-variable-anchor-offset"), C3 = [], I3 = f3.getCircleRadiusCorrection();
+        for (const l4 of a3) {
+          const a4 = i3.getTile(l4), c4 = a4.getBucket(o3);
+          if (!c4) continue;
+          const u4 = r3 ? c4.text : c4.icon;
+          if (!u4 || !u4.segments.get().length || !u4.hasVisibleVertices) continue;
+          const d4 = u4.programConfigurations.get(o3.id), p4 = r3 || c4.sdfIcons, T4 = r3 ? c4.textSizeData : c4.iconSizeData, M3 = v3 || 0 !== f3.pitch, E3 = e3.useProgram(_a3(p4, r3, c4), d4), S3 = t2.av(T4, f3.zoom), R3 = e3.style.map.terrain && e3.style.map.terrain.getTerrainData(l4);
+          let z3, D3, A3, L3, k3 = [0, 0], F3 = null;
+          if (r3) D3 = a4.glyphAtlasTexture, A3 = m3.LINEAR, z3 = a4.glyphAtlasTexture.size, c4.iconsInText && (k3 = a4.imageAtlasTexture.size, F3 = a4.imageAtlasTexture, L3 = M3 || e3.options.rotating || e3.options.zooming || "composite" === T4.kind || "camera" === T4.kind ? m3.LINEAR : m3.NEAREST);
+          else {
+            const t3 = 1 !== o3.layout.get("icon-size").constantOr(0) || c4.iconsNeedLinear;
+            D3 = a4.imageAtlasTexture, A3 = p4 || e3.options.rotating || e3.options.zooming || t3 || M3 ? m3.LINEAR : m3.NEAREST, z3 = a4.imageAtlasTexture.size;
+          }
+          const B3 = t2.aK(a4, 1, e3.transform.zoom), O3 = Be2(g3, e3.transform, B3), j3 = t2.N();
+          t2.ay(j3, O3);
+          const N3 = Oe2(v3, g3, e3.transform, B3), Z3 = t2.aL(f3, a4, s3, n3), U3 = f3.getProjectionData({ overscaledTileID: l4, applyGlobeMatrix: !_3, applyTerrainMatrix: true }), G3 = P3 && c4.hasTextData(), V3 = "none" !== o3.layout.get("icon-text-fit") && G3 && c4.hasIconData();
+          if (x3) {
+            const t3 = e3.style.map.terrain ? (t4, i5) => e3.style.map.terrain.getElevation(l4, t4, i5) : null, i4 = "map" === o3.layout.get("text-rotation-alignment");
+            Ge2(c4, e3, r3, O3, j3, v3, h3, i4, l4.toUnwrapped(), f3.width, f3.height, Z3, t3);
+          }
+          const W3 = r3 && P3 || V3, q3 = x3 || W3 ? ca2 : v3 ? O3 : e3.transform.clipSpaceToPixelsMatrix, $3 = p4 && 0 !== o3.paint.get(r3 ? "text-halo-width" : "icon-halo-width").constantOr(1);
+          let H3;
+          H3 = p4 ? c4.iconsInText ? po(T4.kind, S3, b3, v3, x3, W3, e3, q3, N3, Z3, z3, k3, I3) : _o2(T4.kind, S3, b3, v3, x3, W3, e3, q3, N3, Z3, r3, z3, 0, I3) : uo(T4.kind, S3, b3, v3, x3, W3, e3, q3, N3, Z3, r3, z3, I3);
+          const X3 = { program: E3, buffers: u4, uniformValues: H3, projectionData: U3, atlasTexture: D3, atlasTextureIcon: F3, atlasInterpolation: A3, atlasInterpolationIcon: L3, isSDF: p4, hasHalo: $3 };
+          if (y3 && c4.canOverlap) {
+            w3 = true;
+            const e4 = u4.segments.get();
+            for (const i4 of e4) C3.push({ segments: new t2.aV([i4]), sortKey: i4.sortKey, state: X3, terrainData: R3 });
+          } else C3.push({ segments: u4.segments, sortKey: 0, state: X3, terrainData: R3 });
+        }
+        w3 && C3.sort((e4, t3) => e4.sortKey - t3.sortKey);
+        for (const t3 of C3) {
+          const i4 = t3.state;
+          if (p3.activeTexture.set(m3.TEXTURE0), i4.atlasTexture.bind(i4.atlasInterpolation, m3.CLAMP_TO_EDGE), i4.atlasTextureIcon && (p3.activeTexture.set(m3.TEXTURE1), i4.atlasTextureIcon && i4.atlasTextureIcon.bind(i4.atlasInterpolationIcon, m3.CLAMP_TO_EDGE)), i4.isSDF) {
+            const a4 = i4.uniformValues;
+            i4.hasHalo && (a4.u_is_halo = 1, ma2(i4.buffers, t3.segments, o3, e3, i4.program, T3, u3, d3, a4, i4.projectionData, t3.terrainData)), a4.u_is_halo = 0;
+          }
+          ma2(i4.buffers, t3.segments, o3, e3, i4.program, T3, u3, d3, i4.uniformValues, i4.projectionData, t3.terrainData);
+        }
+      }
+      function ma2(e3, t3, i3, o3, a3, r3, s3, n3, l3, c3, h3) {
+        const u3 = o3.context;
+        a3.draw(u3, u3.gl.TRIANGLES, r3, s3, n3, Qt.backCCW, l3, h3, c3, i3.id, e3.layoutVertexBuffer, e3.indexBuffer, t3, i3.paint, o3.transform.zoom, e3.programConfigurations.get(i3.id), e3.dynamicLayoutVertexBuffer, e3.opacityVertexBuffer);
+      }
+      function fa2(e3, i3, o3, a3, r3) {
+        const s3 = e3.context, n3 = s3.gl, l3 = ti2.disabled, c3 = new Yt([n3.ONE, n3.ONE], t2.bn.transparent, [true, true, true, true]), h3 = i3.getBucket(o3);
+        if (!h3) return;
+        const u3 = a3.key;
+        let d3 = o3.heatmapFbos.get(u3);
+        d3 || (d3 = va2(s3, i3.tileSize, i3.tileSize), o3.heatmapFbos.set(u3, d3)), s3.bindFramebuffer.set(d3.framebuffer), s3.viewport.set([0, 0, i3.tileSize, i3.tileSize]), s3.clear({ color: t2.bn.transparent });
+        const _3 = h3.programConfigurations.get(o3.id), p3 = e3.useProgram("heatmap", _3, !r3), m3 = e3.transform.getProjectionData({ overscaledTileID: i3.tileID, applyGlobeMatrix: true, applyTerrainMatrix: true }), f3 = e3.style.map.terrain.getTerrainData(a3);
+        p3.draw(s3, n3.TRIANGLES, Jt.disabled, l3, c3, Qt.disabled, Yi2(i3, e3.transform.zoom, o3.paint.get("heatmap-intensity"), 1), f3, m3, o3.id, h3.layoutVertexBuffer, h3.indexBuffer, h3.segments, o3.paint, e3.transform.zoom, _3);
+      }
+      function ga(e3, t3, i3, o3, a3) {
+        const r3 = e3.context, s3 = r3.gl, n3 = e3.transform;
+        r3.setColorMode(e3.colorModeForRenderPass());
+        const l3 = xa(r3, t3), c3 = i3.key, h3 = t3.heatmapFbos.get(c3);
+        if (!h3) return;
+        r3.activeTexture.set(s3.TEXTURE0), s3.bindTexture(s3.TEXTURE_2D, h3.colorAttachment.get()), r3.activeTexture.set(s3.TEXTURE1), l3.bind(s3.LINEAR, s3.CLAMP_TO_EDGE);
+        const u3 = n3.getProjectionData({ overscaledTileID: i3, applyTerrainMatrix: a3, applyGlobeMatrix: !o3 });
+        e3.useProgram("heatmapTexture").draw(r3, s3.TRIANGLES, Jt.disabled, ti2.disabled, e3.colorModeForRenderPass(), Qt.disabled, Ki2(e3, t3, 0, 1), null, u3, t3.id, e3.rasterBoundsBuffer, e3.quadTriangleIndexBuffer, e3.rasterBoundsSegments, t3.paint, n3.zoom), h3.destroy(), t3.heatmapFbos.delete(c3);
+      }
+      function va2(e3, t3, i3) {
+        var o3, a3;
+        const r3 = e3.gl, s3 = r3.createTexture();
+        r3.bindTexture(r3.TEXTURE_2D, s3), r3.texParameteri(r3.TEXTURE_2D, r3.TEXTURE_WRAP_S, r3.CLAMP_TO_EDGE), r3.texParameteri(r3.TEXTURE_2D, r3.TEXTURE_WRAP_T, r3.CLAMP_TO_EDGE), r3.texParameteri(r3.TEXTURE_2D, r3.TEXTURE_MIN_FILTER, r3.LINEAR), r3.texParameteri(r3.TEXTURE_2D, r3.TEXTURE_MAG_FILTER, r3.LINEAR);
+        const n3 = null !== (o3 = e3.HALF_FLOAT) && void 0 !== o3 ? o3 : r3.UNSIGNED_BYTE, l3 = null !== (a3 = e3.RGBA16F) && void 0 !== a3 ? a3 : r3.RGBA;
+        r3.texImage2D(r3.TEXTURE_2D, 0, l3, t3, i3, 0, r3.RGBA, n3, null);
+        const c3 = e3.createFramebuffer(t3, i3, false, false);
+        return c3.colorAttachment.set(s3), c3;
+      }
+      function xa(e3, i3) {
+        return i3.colorRampTexture || (i3.colorRampTexture = new t2.T(e3, i3.colorRamp, e3.gl.RGBA)), i3.colorRampTexture;
+      }
+      function ba(e3, i3, o3, a3, r3, s3, n3, l3) {
+        let c3 = 256;
+        if (r3.stepInterpolant) {
+          const a4 = i3.getSource().maxzoom, r4 = n3.canonical.z === a4 ? Math.ceil(1 << e3.transform.maxZoom - n3.canonical.z) : 1;
+          c3 = t2.ak(t2.cc(s3.maxLineLength / t2.a5 * 1024 * r4), 256, o3.maxTextureSize);
+        }
+        return l3.gradient = t2.cd({ expression: r3.gradientExpression(), evaluationKey: "lineProgress", resolution: c3, image: l3.gradient || void 0, clips: s3.lineClipsArray }), l3.texture ? l3.texture.update(l3.gradient) : l3.texture = new t2.T(o3, l3.gradient, a3.RGBA), l3.version = r3.gradientVersion, l3.texture;
+      }
+      function ya2(e3, t3, i3, o3, a3) {
+        e3.activeTexture.set(t3.TEXTURE0), i3.imageAtlasTexture.bind(t3.LINEAR, t3.CLAMP_TO_EDGE), o3.updatePaintBuffers(a3);
+      }
+      function wa2(e3, t3, i3, o3, a3, r3) {
+        (a3 || e3.lineAtlas.dirty) && (t3.activeTexture.set(i3.TEXTURE0), e3.lineAtlas.bind(t3)), o3.updatePaintBuffers(r3);
+      }
+      function Ta2(e3, t3, i3, o3, a3, r3, s3) {
+        const n3 = r3.gradients[a3.id];
+        let l3 = n3.texture;
+        a3.gradientVersion !== n3.version && (l3 = ba(e3, t3, i3, o3, a3, r3, s3, n3)), i3.activeTexture.set(o3.TEXTURE0), l3.bind(a3.stepInterpolant ? o3.NEAREST : o3.LINEAR, o3.CLAMP_TO_EDGE);
+      }
+      function Pa2(e3, t3, i3, o3, a3, r3, s3, n3, l3) {
+        const c3 = r3.gradients[a3.id];
+        let h3 = c3.texture;
+        a3.gradientVersion !== c3.version && (h3 = ba(e3, t3, i3, o3, a3, r3, s3, c3)), i3.activeTexture.set(o3.TEXTURE0), h3.bind(a3.stepInterpolant ? o3.NEAREST : o3.LINEAR, o3.CLAMP_TO_EDGE), i3.activeTexture.set(o3.TEXTURE1), e3.lineAtlas.bind(i3), n3.updatePaintBuffers(l3);
+      }
+      function Ca2(e3, t3, i3, o3, a3) {
+        if (!i3 || !o3 || !o3.imageAtlas) return;
+        const r3 = o3.imageAtlas.patternPositions;
+        let s3 = r3[i3.to.toString()], n3 = r3[i3.from.toString()];
+        if (!s3 && n3 && (s3 = n3), !n3 && s3 && (n3 = s3), !s3 || !n3) {
+          const e4 = a3.getPaintProperty(t3);
+          s3 = r3[e4], n3 = r3[e4];
+        }
+        s3 && n3 && e3.setConstantPatternPositions(s3, n3);
+      }
+      function Ia2(e3, i3, o3, a3, r3, s3, n3, l3) {
+        const c3 = e3.context.gl, h3 = "fill-pattern", u3 = o3.paint.get(h3), d3 = u3 && u3.constantOr(1), _3 = o3.getCrossfadeParameters();
+        let p3, m3, f3, g3, v3;
+        const x3 = e3.transform, b3 = o3.paint.get("fill-translate"), y3 = o3.paint.get("fill-translate-anchor");
+        n3 ? (m3 = d3 && !o3.getPaintProperty("fill-outline-color") ? "fillOutlinePattern" : "fillOutline", p3 = c3.LINES) : (m3 = d3 ? "fillPattern" : "fill", p3 = c3.TRIANGLES);
+        const w3 = u3.constantOr(null);
+        for (const u4 of a3) {
+          const a4 = i3.getTile(u4);
+          if (d3 && !a4.patternsLoaded()) continue;
+          const T3 = a4.getBucket(o3);
+          if (!T3) continue;
+          const P3 = T3.programConfigurations.get(o3.id), C3 = e3.useProgram(m3, P3), I3 = e3.style.map.terrain && e3.style.map.terrain.getTerrainData(u4);
+          d3 && (e3.context.activeTexture.set(c3.TEXTURE0), a4.imageAtlasTexture.bind(c3.LINEAR, c3.CLAMP_TO_EDGE), P3.updatePaintBuffers(_3)), Ca2(P3, h3, w3, a4, o3);
+          const M3 = x3.getProjectionData({ overscaledTileID: u4, applyGlobeMatrix: !l3, applyTerrainMatrix: true }), E3 = t2.aL(x3, a4, b3, y3);
+          if (n3) {
+            g3 = T3.indexBuffer2, v3 = T3.segments2;
+            const t3 = [c3.drawingBufferWidth, c3.drawingBufferHeight];
+            f3 = "fillOutlinePattern" === m3 && d3 ? Wi2(e3, _3, a4, t3, E3) : Vi2(t3, E3);
+          } else g3 = T3.indexBuffer, v3 = T3.segments, f3 = d3 ? Gi2(e3, _3, a4, E3) : { u_fill_translate: E3 };
+          const S3 = e3.stencilModeForClipping(u4);
+          C3.draw(e3.context, p3, r3, S3, s3, Qt.backCCW, f3, I3, M3, o3.id, T3.layoutVertexBuffer, g3, v3, o3.paint, e3.transform.zoom, P3);
+        }
+      }
+      function Ma2(e3, i3, o3, a3, r3, s3, n3, l3) {
+        const c3 = e3.context, h3 = c3.gl, u3 = "fill-extrusion-pattern", d3 = o3.paint.get(u3), _3 = d3.constantOr(1), p3 = o3.getCrossfadeParameters(), m3 = o3.paint.get("fill-extrusion-opacity"), f3 = d3.constantOr(null), g3 = e3.transform;
+        for (const d4 of a3) {
+          const a4 = i3.getTile(d4), v3 = a4.getBucket(o3);
+          if (!v3) continue;
+          const x3 = e3.style.map.terrain && e3.style.map.terrain.getTerrainData(d4), b3 = v3.programConfigurations.get(o3.id), y3 = e3.useProgram(_3 ? "fillExtrusionPattern" : "fillExtrusion", b3);
+          _3 && (e3.context.activeTexture.set(h3.TEXTURE0), a4.imageAtlasTexture.bind(h3.LINEAR, h3.CLAMP_TO_EDGE), b3.updatePaintBuffers(p3));
+          const w3 = g3.getProjectionData({ overscaledTileID: d4, applyGlobeMatrix: !l3, applyTerrainMatrix: true });
+          Ca2(b3, u3, f3, a4, o3);
+          const T3 = t2.aL(g3, a4, o3.paint.get("fill-extrusion-translate"), o3.paint.get("fill-extrusion-translate-anchor")), P3 = o3.paint.get("fill-extrusion-vertical-gradient"), C3 = _3 ? Ui2(e3, P3, m3, T3, d4, p3, a4) : Zi2(e3, P3, m3, T3);
+          y3.draw(c3, c3.gl.TRIANGLES, r3, s3, n3, Qt.backCCW, C3, x3, w3, o3.id, v3.layoutVertexBuffer, v3.indexBuffer, v3.segments, o3.paint, e3.transform.zoom, b3, e3.style.map.terrain && v3.centroidVertexBuffer);
+        }
+      }
+      function Ea2(e3, t3, i3, o3, a3, r3, s3, n3, l3) {
+        var c3;
+        const h3 = e3.style.projection, u3 = e3.context, d3 = e3.transform, _3 = u3.gl, p3 = [`#define NUM_ILLUMINATION_SOURCES ${i3.paint.get("hillshade-highlight-color").values.length}`], m3 = e3.useProgram("hillshade", null, false, p3), f3 = !e3.options.moving;
+        for (const p4 of o3) {
+          const o4 = t3.getTile(p4), g3 = o4.fbo;
+          if (!g3) continue;
+          const v3 = h3.getMeshFromTileID(u3, p4.canonical, n3, true, "raster"), x3 = null === (c3 = e3.style.map.terrain) || void 0 === c3 ? void 0 : c3.getTerrainData(p4);
+          u3.activeTexture.set(_3.TEXTURE0), _3.bindTexture(_3.TEXTURE_2D, g3.colorAttachment.get());
+          const b3 = d3.getProjectionData({ overscaledTileID: p4, aligned: f3, applyGlobeMatrix: !l3, applyTerrainMatrix: true });
+          m3.draw(u3, _3.TRIANGLES, r3, a3[p4.overscaledZ], s3, Qt.backCCW, Qi2(e3, o4, i3), x3, b3, i3.id, v3.vertexBuffer, v3.indexBuffer, v3.segments);
+        }
+      }
+      function Sa2(e3, i3, o3, a3, r3, s3, n3, l3, c3) {
+        var h3;
+        const u3 = e3.style.projection, d3 = e3.context, _3 = e3.transform, p3 = d3.gl, m3 = e3.useProgram("colorRelief"), f3 = !e3.options.moving, g3 = "nearest" === o3.paint.get("resampling") ? p3.NEAREST : p3.LINEAR;
+        let v3 = true, x3 = 0;
+        for (const b3 of a3) {
+          const a4 = i3.getTile(b3), y3 = a4.dem;
+          if (v3) {
+            const e4 = p3.getParameter(p3.MAX_TEXTURE_SIZE), { elevationTexture: t3, colorTexture: i4 } = o3.getColorRampTextures(d3, e4, y3.getUnpackVector());
+            d3.activeTexture.set(p3.TEXTURE1), t3.bind(p3.NEAREST, p3.CLAMP_TO_EDGE), d3.activeTexture.set(p3.TEXTURE4), i4.bind(p3.LINEAR, p3.CLAMP_TO_EDGE), v3 = false, x3 = t3.size[0];
+          }
+          if (!y3 || !y3.data) continue;
+          const w3 = y3.stride, T3 = y3.getPixels();
+          if (d3.activeTexture.set(p3.TEXTURE0), d3.pixelStoreUnpackPremultiplyAlpha.set(false), a4.demTexture = a4.demTexture || e3.getTileTexture(w3), a4.demTexture) {
+            const e4 = a4.demTexture;
+            e4.update(T3, { premultiply: false }), e4.bind(g3, p3.CLAMP_TO_EDGE);
+          } else a4.demTexture = new t2.T(d3, T3, p3.RGBA, { premultiply: false }), a4.demTexture.bind(g3, p3.CLAMP_TO_EDGE);
+          const P3 = u3.getMeshFromTileID(d3, b3.canonical, l3, true, "raster"), C3 = null === (h3 = e3.style.map.terrain) || void 0 === h3 ? void 0 : h3.getTerrainData(b3), I3 = _3.getProjectionData({ overscaledTileID: b3, aligned: f3, applyGlobeMatrix: !c3, applyTerrainMatrix: true });
+          m3.draw(d3, p3.TRIANGLES, s3, r3[b3.overscaledZ], n3, Qt.backCCW, to(o3, a4.dem, x3), C3, I3, o3.id, P3.vertexBuffer, P3.indexBuffer, P3.segments);
+        }
+      }
+      const Ra2 = [new t2.P(0, 0), new t2.P(t2.a5, 0), new t2.P(t2.a5, t2.a5), new t2.P(0, t2.a5)];
+      function za2(e3, t3, i3, o3, a3, r3, s3, n3, l3 = false, c3 = false) {
+        const h3 = o3[o3.length - 1].overscaledZ, u3 = e3.context, d3 = u3.gl, _3 = e3.useProgram("raster"), p3 = e3.transform, m3 = e3.style.projection, f3 = e3.colorModeForRenderPass(), g3 = !e3.options.moving, v3 = i3.paint.get("raster-opacity"), x3 = "nearest" === i3.paint.get("resampling") || "nearest" === i3.paint.get("raster-resampling") ? d3.NEAREST : d3.LINEAR, b3 = i3.paint.get("raster-fade-duration"), y3 = !!e3.style.map.terrain;
+        for (const w3 of o3) {
+          const o4 = e3.getDepthModeForSublayer(w3.overscaledZ - h3, 1 === v3 ? Jt.ReadWrite : Jt.ReadOnly, d3.LESS), T3 = t3.getTile(w3);
+          u3.activeTexture.set(d3.TEXTURE0), T3.texture.bind(x3, d3.CLAMP_TO_EDGE, d3.LINEAR_MIPMAP_NEAREST), u3.activeTexture.set(d3.TEXTURE1);
+          const { parentTile: P3, parentScaleBy: C3, parentTopLeft: I3, fadeValues: M3 } = Da2(T3, t3, b3, y3);
+          T3.fadeOpacity = M3.tileOpacity, P3 ? (P3.fadeOpacity = M3.parentTileOpacity, P3.texture.bind(x3, d3.CLAMP_TO_EDGE, d3.LINEAR_MIPMAP_NEAREST)) : T3.texture.bind(x3, d3.CLAMP_TO_EDGE, d3.LINEAR_MIPMAP_NEAREST), T3.texture.useMipmap && u3.extTextureFilterAnisotropic && e3.transform.pitch > e3.options.anisotropicFilterPitch && d3.texParameterf(d3.TEXTURE_2D, u3.extTextureFilterAnisotropic.TEXTURE_MAX_ANISOTROPY_EXT, u3.extTextureFilterAnisotropicMax);
+          const E3 = e3.style.map.terrain && e3.style.map.terrain.getTerrainData(w3), S3 = p3.getProjectionData({ overscaledTileID: w3, aligned: g3, applyGlobeMatrix: !c3, applyTerrainMatrix: true }), R3 = co(I3, C3, M3.fadeMix, i3, n3), z3 = m3.getMeshFromTileID(u3, w3.canonical, r3, s3, "raster");
+          _3.draw(u3, d3.TRIANGLES, o4, a3 ? a3[w3.overscaledZ] : ti2.disabled, f3, l3 ? Qt.frontCCW : Qt.backCCW, R3, E3, S3, i3.id, z3.vertexBuffer, z3.indexBuffer, z3.segments);
+        }
+      }
+      function Da2(e3, i3, o3, a3) {
+        const r3 = { parentTile: null, parentScaleBy: 1, parentTopLeft: [0, 0], fadeValues: { tileOpacity: 1, parentTileOpacity: 1, fadeMix: { opacity: 1, mix: 0 } } };
+        if (0 === o3 || a3) return r3;
+        if (e3.fadingParentID) {
+          const a4 = i3.getLoadedTile(e3.fadingParentID);
+          if (!a4) return r3;
+          const s3 = Math.pow(2, a4.tileID.overscaledZ - e3.tileID.overscaledZ), n3 = [e3.tileID.canonical.x * s3 % 1, e3.tileID.canonical.y * s3 % 1], l3 = function(e4, i4, o4) {
+            const a5 = c2(), r4 = (a5 - i4.timeAdded) / o4, s4 = e4.fadingDirection === ce2.Incoming, n4 = t2.ak((a5 - e4.timeAdded) / o4, 0, 1), l4 = t2.ak(1 - r4, 0, 1), h3 = s4 ? n4 : l4;
+            return { tileOpacity: h3, parentTileOpacity: s4 ? l4 : n4, fadeMix: { opacity: 1, mix: 1 - h3 } };
+          }(e3, a4, o3);
+          return { parentTile: a4, parentScaleBy: s3, parentTopLeft: n3, fadeValues: l3 };
+        }
+        if (e3.selfFading) {
+          const i4 = function(e4, i5) {
+            const o4 = (c2() - e4.timeAdded) / i5, a4 = t2.ak(o4, 0, 1);
+            return { tileOpacity: a4, fadeMix: { opacity: a4, mix: 0 } };
+          }(e3, o3);
+          return { parentTile: null, parentScaleBy: 1, parentTopLeft: [0, 0], fadeValues: i4 };
+        }
+        return r3;
+      }
+      const Aa2 = new t2.bn(1, 0, 0, 1), La2 = new t2.bn(0, 1, 0, 1), ka2 = new t2.bn(0, 0, 1, 1), Fa2 = new t2.bn(1, 0, 1, 1), Ba2 = new t2.bn(0, 1, 1, 1);
+      function Oa2(e3, t3, i3, o3) {
+        Na2(e3, 0, t3 + i3 / 2, e3.transform.width, i3, o3);
+      }
+      function ja2(e3, t3, i3, o3) {
+        Na2(e3, t3 - i3 / 2, 0, i3, e3.transform.height, o3);
+      }
+      function Na2(e3, t3, i3, o3, a3, r3) {
+        const s3 = e3.context, n3 = s3.gl;
+        n3.enable(n3.SCISSOR_TEST), n3.scissor(t3 * e3.pixelRatio, i3 * e3.pixelRatio, o3 * e3.pixelRatio, a3 * e3.pixelRatio), s3.clear({ color: r3 }), n3.disable(n3.SCISSOR_TEST);
+      }
+      function Za2(e3, i3, o3) {
+        const a3 = e3.context, r3 = a3.gl, s3 = e3.useProgram("debug"), n3 = Jt.disabled, l3 = ti2.disabled, c3 = e3.colorModeForRenderPass(), h3 = "$debug", u3 = e3.style.map.terrain && e3.style.map.terrain.getTerrainData(o3);
+        a3.activeTexture.set(r3.TEXTURE0);
+        const d3 = i3.getTileByID(o3.key).latestRawTileData, _3 = Math.floor((d3 && d3.byteLength || 0) / 1024), p3 = i3.getTile(o3).tileSize, m3 = 512 / Math.min(p3, 512) * (o3.overscaledZ / e3.transform.zoom) * 0.5;
+        let f3 = o3.canonical.toString();
+        o3.overscaledZ !== o3.canonical.z && (f3 += ` => ${o3.overscaledZ}`), function(e4, t3) {
+          e4.initDebugOverlayCanvas();
+          const i4 = e4.debugOverlayCanvas, o4 = e4.context.gl, a4 = e4.debugOverlayCanvas.getContext("2d");
+          a4.clearRect(0, 0, i4.width, i4.height), a4.shadowColor = "white", a4.shadowBlur = 2, a4.lineWidth = 1.5, a4.strokeStyle = "white", a4.textBaseline = "top", a4.font = "bold 36px Open Sans, sans-serif", a4.fillText(t3, 5, 5), a4.strokeText(t3, 5, 5), e4.debugOverlayTexture.update(i4), e4.debugOverlayTexture.bind(o4.LINEAR, o4.CLAMP_TO_EDGE);
+        }(e3, `${f3} ${_3}kB`);
+        const g3 = e3.transform.getProjectionData({ overscaledTileID: o3, applyGlobeMatrix: true, applyTerrainMatrix: true });
+        s3.draw(a3, r3.TRIANGLES, n3, l3, Yt.alphaBlended, Qt.disabled, Xi2(t2.bn.transparent, m3), null, g3, h3, e3.debugBuffer, e3.quadTriangleIndexBuffer, e3.debugSegments), s3.draw(a3, r3.LINE_STRIP, n3, l3, c3, Qt.disabled, Xi2(t2.bn.red), u3, g3, h3, e3.debugBuffer, e3.tileBorderIndexBuffer, e3.debugSegments);
+      }
+      function Ua2(e3, t3, i3, o3) {
+        const { isRenderingGlobe: a3 } = o3, r3 = e3.context, s3 = r3.gl, n3 = e3.transform, l3 = e3.colorModeForRenderPass(), c3 = e3.getDepthModeFor3D(), h3 = e3.useProgram("terrain");
+        r3.bindFramebuffer.set(null), r3.viewport.set([0, 0, e3.width, e3.height]);
+        for (const o4 of i3) {
+          const i4 = t3.getTerrainMesh(o4.tileID), u3 = e3.renderToTexture.getTexture(o4), d3 = t3.getTerrainData(o4.tileID);
+          r3.activeTexture.set(s3.TEXTURE0), s3.bindTexture(s3.TEXTURE_2D, u3.texture);
+          const _3 = t3.getMeshFrameDelta(n3.zoom), p3 = n3.calculateFogMatrix(o4.tileID.toUnwrapped()), m3 = Fi2(_3, p3, e3.style.sky, n3.pitch, a3), f3 = n3.getProjectionData({ overscaledTileID: o4.tileID, applyTerrainMatrix: false, applyGlobeMatrix: true });
+          h3.draw(r3, s3.TRIANGLES, c3, ti2.disabled, l3, Qt.backCCW, m3, d3, f3, "terrain", i4.vertexBuffer, i4.indexBuffer, i4.segments);
+        }
+      }
+      function Ga2(e3, i3) {
+        if (!i3.mesh) {
+          const o3 = new t2.aU();
+          o3.emplaceBack(-1, -1), o3.emplaceBack(1, -1), o3.emplaceBack(1, 1), o3.emplaceBack(-1, 1);
+          const a3 = new t2.aW();
+          a3.emplaceBack(0, 1, 2), a3.emplaceBack(0, 2, 3), i3.mesh = new At(e3.createVertexBuffer(o3, Lt.members), e3.createIndexBuffer(a3), t2.aV.simpleSegment(0, 0, o3.length, a3.length));
+        }
+        return i3.mesh;
+      }
+      class Va2 {
+        constructor(e3, i3) {
+          this.context = new sa2(e3), this.transform = i3, this._tileTextures = {}, this.terrainFacilitator = { dirty: true, matrix: t2.ao(new Float64Array(16)), renderTime: 0 }, this.setup(), this.numSublayers = Ae2.maxOverzooming + Ae2.maxUnderzooming + 1, this.depthEpsilon = 1 / Math.pow(2, 16), this.crossTileSymbolIndex = new St();
+        }
+        resize(e3, t3, i3) {
+          if (this.width = Math.floor(e3 * i3), this.height = Math.floor(t3 * i3), this.pixelRatio = i3, this.context.viewport.set([0, 0, this.width, this.height]), this.style) for (const e4 of this.style._order) this.style._layers[e4].resize();
+        }
+        setup() {
+          const e3 = this.context, i3 = new t2.aU();
+          i3.emplaceBack(0, 0), i3.emplaceBack(t2.a5, 0), i3.emplaceBack(0, t2.a5), i3.emplaceBack(t2.a5, t2.a5), this.tileExtentBuffer = e3.createVertexBuffer(i3, Lt.members), this.tileExtentSegments = t2.aV.simpleSegment(0, 0, 4, 2);
+          const o3 = new t2.aU();
+          o3.emplaceBack(0, 0), o3.emplaceBack(t2.a5, 0), o3.emplaceBack(0, t2.a5), o3.emplaceBack(t2.a5, t2.a5), this.debugBuffer = e3.createVertexBuffer(o3, Lt.members), this.debugSegments = t2.aV.simpleSegment(0, 0, 4, 5);
+          const a3 = new t2.cf();
+          a3.emplaceBack(0, 0, 0, 0), a3.emplaceBack(t2.a5, 0, t2.a5, 0), a3.emplaceBack(0, t2.a5, 0, t2.a5), a3.emplaceBack(t2.a5, t2.a5, t2.a5, t2.a5), this.rasterBoundsBuffer = e3.createVertexBuffer(a3, Li2.members), this.rasterBoundsSegments = t2.aV.simpleSegment(0, 0, 4, 2);
+          const r3 = new t2.aU();
+          r3.emplaceBack(0, 0), r3.emplaceBack(t2.a5, 0), r3.emplaceBack(0, t2.a5), r3.emplaceBack(t2.a5, t2.a5), this.rasterBoundsBufferPosOnly = e3.createVertexBuffer(r3, Lt.members), this.rasterBoundsSegmentsPosOnly = t2.aV.simpleSegment(0, 0, 4, 5);
+          const s3 = new t2.aU();
+          s3.emplaceBack(0, 0), s3.emplaceBack(1, 0), s3.emplaceBack(0, 1), s3.emplaceBack(1, 1), this.viewportBuffer = e3.createVertexBuffer(s3, Lt.members), this.viewportSegments = t2.aV.simpleSegment(0, 0, 4, 2);
+          const n3 = new t2.cg();
+          n3.emplaceBack(0), n3.emplaceBack(1), n3.emplaceBack(3), n3.emplaceBack(2), n3.emplaceBack(0), this.tileBorderIndexBuffer = e3.createIndexBuffer(n3);
+          const l3 = new t2.aW();
+          l3.emplaceBack(1, 0, 2), l3.emplaceBack(1, 2, 3), this.quadTriangleIndexBuffer = e3.createIndexBuffer(l3);
+          const c3 = this.context.gl;
+          this.stencilClearMode = new ti2({ func: c3.ALWAYS, mask: 0 }, 0, 255, c3.ZERO, c3.ZERO, c3.ZERO), this.tileExtentMesh = new At(this.tileExtentBuffer, this.quadTriangleIndexBuffer, this.tileExtentSegments);
+        }
+        clearStencil() {
+          const e3 = this.context, i3 = e3.gl;
+          this.nextStencilID = 1, this.currentStencilSource = void 0;
+          const o3 = t2.N();
+          t2.c5(o3, 0, this.width, this.height, 0, 0, 1), t2.Q(o3, o3, [i3.drawingBufferWidth, i3.drawingBufferHeight, 0]);
+          const a3 = { mainMatrix: o3, tileMercatorCoords: [0, 0, 1, 1], clippingPlane: [0, 0, 0, 0], projectionTransition: 0, fallbackMatrix: o3 };
+          this.useProgram("clippingMask", null, true).draw(e3, i3.TRIANGLES, Jt.disabled, this.stencilClearMode, Yt.disabled, Qt.disabled, null, null, a3, "$clipping", this.viewportBuffer, this.quadTriangleIndexBuffer, this.viewportSegments);
+        }
+        _renderTileClippingMasks(e3, t3, i3) {
+          if (this.currentStencilSource === e3.source || !e3.isTileClipped() || !t3 || !t3.length) return;
+          this.currentStencilSource = e3.source, this.nextStencilID + t3.length > 256 && this.clearStencil();
+          const o3 = this.context;
+          o3.setColorMode(Yt.disabled), o3.setDepthMode(Jt.disabled);
+          const a3 = {};
+          for (const e4 of t3) a3[e4.key] = this.nextStencilID++;
+          this._renderTileMasks(a3, t3, i3, true), this._renderTileMasks(a3, t3, i3, false), this._tileClippingMaskIDs = a3;
+        }
+        _renderTileMasks(e3, t3, i3, o3) {
+          const a3 = this.context, r3 = a3.gl, s3 = this.style.projection, n3 = this.transform, l3 = this.useProgram("clippingMask");
+          for (const c3 of t3) {
+            const t4 = e3[c3.key], h3 = this.style.map.terrain && this.style.map.terrain.getTerrainData(c3), u3 = s3.getMeshFromTileID(this.context, c3.canonical, o3, true, "stencil"), d3 = n3.getProjectionData({ overscaledTileID: c3, applyGlobeMatrix: !i3, applyTerrainMatrix: true });
+            l3.draw(a3, r3.TRIANGLES, Jt.disabled, new ti2({ func: r3.ALWAYS, mask: 0 }, t4, 255, r3.KEEP, r3.KEEP, r3.REPLACE), Yt.disabled, i3 ? Qt.disabled : Qt.backCCW, null, h3, d3, "$clipping", u3.vertexBuffer, u3.indexBuffer, u3.segments);
+          }
+        }
+        _renderTilesDepthBuffer() {
+          const e3 = this.context, t3 = e3.gl, i3 = this.style.projection, o3 = this.transform, a3 = this.useProgram("depth"), r3 = this.getDepthModeFor3D(), s3 = Pe2(o3, { tileSize: o3.tileSize });
+          for (const n3 of s3) {
+            const s4 = this.style.map.terrain && this.style.map.terrain.getTerrainData(n3), l3 = i3.getMeshFromTileID(this.context, n3.canonical, true, true, "raster"), c3 = o3.getProjectionData({ overscaledTileID: n3, applyGlobeMatrix: true, applyTerrainMatrix: true });
+            a3.draw(e3, t3.TRIANGLES, r3, ti2.disabled, Yt.disabled, Qt.backCCW, null, s4, c3, "$clipping", l3.vertexBuffer, l3.indexBuffer, l3.segments);
+          }
+        }
+        stencilModeFor3D() {
+          this.currentStencilSource = void 0, this.nextStencilID + 1 > 256 && this.clearStencil();
+          const e3 = this.nextStencilID++, t3 = this.context.gl;
+          return new ti2({ func: t3.NOTEQUAL, mask: 255 }, e3, 255, t3.KEEP, t3.KEEP, t3.REPLACE);
+        }
+        stencilModeForClipping(e3) {
+          const t3 = this.context.gl;
+          return new ti2({ func: t3.EQUAL, mask: 255 }, this._tileClippingMaskIDs[e3.key], 0, t3.KEEP, t3.KEEP, t3.REPLACE);
+        }
+        getStencilConfigForOverlapAndUpdateStencilID(e3) {
+          const t3 = this.context.gl, i3 = e3.sort((e4, t4) => t4.overscaledZ - e4.overscaledZ), o3 = i3[i3.length - 1].overscaledZ, a3 = i3[0].overscaledZ - o3 + 1;
+          if (a3 > 1) {
+            this.currentStencilSource = void 0, this.nextStencilID + a3 > 256 && this.clearStencil();
+            const e4 = {};
+            for (let i4 = 0; i4 < a3; i4++) e4[i4 + o3] = new ti2({ func: t3.GEQUAL, mask: 255 }, i4 + this.nextStencilID, 255, t3.KEEP, t3.KEEP, t3.REPLACE);
+            return this.nextStencilID += a3, [e4, i3];
+          }
+          return [{ [o3]: ti2.disabled }, i3];
+        }
+        stencilConfigForOverlapTwoPass(e3) {
+          const t3 = this.context.gl, i3 = e3.sort((e4, t4) => t4.overscaledZ - e4.overscaledZ), o3 = i3[i3.length - 1].overscaledZ, a3 = i3[0].overscaledZ - o3 + 1;
+          if (this.clearStencil(), a3 > 1) {
+            const e4 = {}, r3 = {};
+            for (let i4 = 0; i4 < a3; i4++) e4[i4 + o3] = new ti2({ func: t3.GREATER, mask: 255 }, a3 + 1 + i4, 255, t3.KEEP, t3.KEEP, t3.REPLACE), r3[i4 + o3] = new ti2({ func: t3.GREATER, mask: 255 }, 1 + i4, 255, t3.KEEP, t3.KEEP, t3.REPLACE);
+            return this.nextStencilID = 2 * a3 + 1, [e4, r3, i3];
+          }
+          return this.nextStencilID = 3, [{ [o3]: new ti2({ func: t3.GREATER, mask: 255 }, 2, 255, t3.KEEP, t3.KEEP, t3.REPLACE) }, { [o3]: new ti2({ func: t3.GREATER, mask: 255 }, 1, 255, t3.KEEP, t3.KEEP, t3.REPLACE) }, i3];
+        }
+        colorModeForRenderPass() {
+          const e3 = this.context.gl;
+          if (this._showOverdrawInspector) {
+            const i3 = 1 / 8;
+            return new Yt([e3.CONSTANT_COLOR, e3.ONE], new t2.bn(i3, i3, i3, 0), [true, true, true, true]);
+          }
+          return "opaque" === this.renderPass ? Yt.unblended : Yt.alphaBlended;
+        }
+        getDepthModeForSublayer(e3, t3, i3) {
+          if (!this.opaquePassEnabledForLayer()) return Jt.disabled;
+          const o3 = 1 - ((1 + this.currentLayer) * this.numSublayers + e3) * this.depthEpsilon;
+          return new Jt(i3 || this.context.gl.LEQUAL, t3, [o3, o3]);
+        }
+        getDepthModeFor3D() {
+          return new Jt(this.context.gl.LEQUAL, Jt.ReadWrite, this.depthRangeFor3D);
+        }
+        opaquePassEnabledForLayer() {
+          return this.currentLayer < this.opaquePassCutoff;
+        }
+        render(e3, i3) {
+          var o3, a3;
+          this.style = e3, this.options = i3, this.lineAtlas = e3.lineAtlas, this.imageManager = e3.imageManager, this.glyphManager = e3.glyphManager, this.symbolFadeChange = e3.placement.symbolFadeChange(c2()), this.imageManager.beginFrame();
+          const r3 = this.style._order, s3 = this.style.tileManagers, n3 = {}, l3 = {}, h3 = {}, u3 = { isRenderingToTexture: false, isRenderingGlobe: (null === (o3 = e3.projection) || void 0 === o3 ? void 0 : o3.transitionState) > 0 };
+          for (const e4 in s3) {
+            const t3 = s3[e4];
+            t3.used && t3.prepare(this.context), n3[e4] = t3.getVisibleCoordinates(false), l3[e4] = n3[e4].slice().reverse(), h3[e4] = t3.getVisibleCoordinates(true).reverse();
+          }
+          this.opaquePassCutoff = 1 / 0;
+          for (let e4 = 0; e4 < r3.length; e4++) if (this.style._layers[r3[e4]].is3D()) {
+            this.opaquePassCutoff = e4;
+            break;
+          }
+          this.maybeDrawDepthAndCoords(false), this.renderToTexture && (this.renderToTexture.prepareForRender(this.style, this.transform.zoom), this.opaquePassCutoff = 0), this.renderPass = "offscreen";
+          for (const e4 of r3) {
+            const t3 = this.style._layers[e4];
+            if (!t3.hasOffscreenPass() || t3.isHidden(this.transform.zoom)) continue;
+            const i4 = l3[t3.source];
+            ("custom" === t3.type || i4.length) && this.renderLayer(this, s3[t3.source], t3, i4, u3);
+          }
+          if (null === (a3 = this.style.projection) || void 0 === a3 || a3.updateGPUdependent({ context: this.context, useProgram: (e4) => this.useProgram(e4) }), this.context.viewport.set([0, 0, this.width, this.height]), this.context.bindFramebuffer.set(null), this.context.clear({ color: i3.showOverdrawInspector ? t2.bn.black : t2.bn.transparent, depth: 1 }), this.clearStencil(), this.style.sky && function(e4, t3) {
+            const i4 = e4.context, o4 = i4.gl, a4 = ((e5, t4, i5) => {
+              const o5 = Math.cos(t4.rollInRadians), a5 = Math.sin(t4.rollInRadians), r5 = me2(t4), s5 = t4.getProjectionData({ overscaledTileID: null, applyGlobeMatrix: true, applyTerrainMatrix: true }).projectionTransition;
+              return { u_sky_color: e5.properties.get("sky-color"), u_horizon_color: e5.properties.get("horizon-color"), u_horizon: [(t4.width / 2 - r5 * a5) * i5, (t4.height / 2 + r5 * o5) * i5], u_horizon_normal: [-a5, o5], u_sky_horizon_blend: e5.properties.get("sky-horizon-blend") * t4.height / 2 * i5, u_sky_blend: s5 };
+            })(t3, e4.style.map.transform, e4.pixelRatio), r4 = new Jt(o4.LEQUAL, Jt.ReadWrite, [0, 1]), s4 = ti2.disabled, n4 = e4.colorModeForRenderPass(), l4 = e4.useProgram("sky"), c3 = Ga2(i4, t3);
+            l4.draw(i4, o4.TRIANGLES, r4, s4, n4, Qt.disabled, a4, null, void 0, "sky", c3.vertexBuffer, c3.indexBuffer, c3.segments);
+          }(this, this.style.sky), this._showOverdrawInspector = i3.showOverdrawInspector, this.depthRangeFor3D = [0, 1 - (e3._order.length + 2) * this.numSublayers * this.depthEpsilon], !this.renderToTexture) for (this.renderPass = "opaque", this.currentLayer = r3.length - 1; this.currentLayer >= 0; this.currentLayer--) {
+            const e4 = this.style._layers[r3[this.currentLayer]], t3 = s3[e4.source], i4 = n3[e4.source];
+            this._renderTileClippingMasks(e4, i4, false), this.renderLayer(this, t3, e4, i4, u3);
+          }
+          this.renderPass = "translucent";
+          let d3 = false;
+          for (this.currentLayer = 0; this.currentLayer < r3.length; this.currentLayer++) {
+            const e4 = this.style._layers[r3[this.currentLayer]], t3 = s3[e4.source];
+            if (this.renderToTexture && this.renderToTexture.renderLayer(e4, u3)) continue;
+            this.opaquePassEnabledForLayer() || d3 || (d3 = true, u3.isRenderingGlobe && !this.style.map.terrain && this._renderTilesDepthBuffer());
+            const i4 = ("symbol" === e4.type ? h3 : l3)[e4.source];
+            this._renderTileClippingMasks(e4, n3[e4.source], !!this.renderToTexture), this.renderLayer(this, t3, e4, i4, u3);
+          }
+          if (u3.isRenderingGlobe && function(e4, i4, o4) {
+            const a4 = e4.context, r4 = a4.gl, s4 = e4.useProgram("atmosphere"), n4 = new Jt(r4.LEQUAL, Jt.ReadOnly, [0, 1]), l4 = e4.transform, c3 = function(e5, i5) {
+              const o5 = e5.properties.get("position"), a5 = [-o5.x, -o5.y, -o5.z], r5 = t2.ao(new Float64Array(16));
+              return "map" === e5.properties.get("anchor") && (t2.be(r5, r5, i5.rollInRadians), t2.bf(r5, r5, -i5.pitchInRadians), t2.be(r5, r5, i5.bearingInRadians), t2.bf(r5, r5, i5.center.lat * Math.PI / 180), t2.bH(r5, r5, -i5.center.lng * Math.PI / 180)), t2.ce(a5, a5, r5), a5;
+            }(o4, e4.transform), h4 = l4.getProjectionData({ overscaledTileID: null, applyGlobeMatrix: true, applyTerrainMatrix: true }), u4 = i4.properties.get("atmosphere-blend") * h4.projectionTransition;
+            if (0 === u4) return;
+            const d4 = pi2(l4.worldSize, l4.center.lat), _3 = l4.inverseProjectionMatrix, p3 = new Float64Array(4);
+            p3[3] = 1, t2.aE(p3, p3, l4.modelViewProjectionMatrix), p3[0] /= p3[3], p3[1] /= p3[3], p3[2] /= p3[3], p3[3] = 1, t2.aE(p3, p3, _3), p3[0] /= p3[3], p3[1] /= p3[3], p3[2] /= p3[3], p3[3] = 1;
+            const m3 = /* @__PURE__ */ ((e5, t3, i5, o5, a5) => ({ u_sun_pos: e5, u_atmosphere_blend: t3, u_globe_position: i5, u_globe_radius: o5, u_inv_proj_matrix: a5 }))(c3, u4, [p3[0], p3[1], p3[2]], d4, _3), f3 = Ga2(a4, i4);
+            s4.draw(a4, r4.TRIANGLES, n4, ti2.disabled, Yt.alphaBlended, Qt.disabled, m3, null, null, "atmosphere", f3.vertexBuffer, f3.indexBuffer, f3.segments);
+          }(this, this.style.sky, this.style.light), this.options.showTileBoundaries) {
+            const e4 = function(e5, t3) {
+              let i4 = null;
+              const o4 = Object.values(e5._layers).flatMap((i5) => i5.source && !i5.isHidden(t3) ? [e5.tileManagers[i5.source]] : []), a4 = o4.filter((e6) => "vector" === e6.getSource().type), r4 = o4.filter((e6) => "vector" !== e6.getSource().type), s4 = (e6) => {
+                (!i4 || i4.getSource().maxzoom < e6.getSource().maxzoom) && (i4 = e6);
+              };
+              return a4.forEach((e6) => s4(e6)), i4 || r4.forEach((e6) => s4(e6)), i4;
+            }(this.style, this.transform.zoom);
+            e4 && function(e5, t3, i4) {
+              for (let o4 = 0; o4 < i4.length; o4++) Za2(e5, t3, i4[o4]);
+            }(this, e4, e4.getVisibleCoordinates());
+          }
+          this.options.showPadding && function(e4) {
+            const t3 = e4.transform.padding;
+            Oa2(e4, e4.transform.height - (t3.top || 0), 3, Aa2), Oa2(e4, t3.bottom || 0, 3, La2), ja2(e4, t3.left || 0, 3, ka2), ja2(e4, e4.transform.width - (t3.right || 0), 3, Fa2);
+            const i4 = e4.transform.centerPoint;
+            !function(e5, t4, i5, o4) {
+              Na2(e5, t4 - 1, i5 - 10, 2, 20, o4), Na2(e5, t4 - 10, i5 - 1, 20, 2, o4);
+            }(e4, i4.x, e4.transform.height - i4.y, Ba2);
+          }(this), this.context.setDefault();
+        }
+        maybeDrawDepthAndCoords(e3) {
+          if (!this.style || !this.style.map || !this.style.map.terrain) return;
+          const i3 = this.terrainFacilitator.matrix, o3 = this.transform.modelViewProjectionMatrix;
+          let a3 = this.terrainFacilitator.dirty;
+          a3 || (a3 = e3 ? !t2.ch(i3, o3) : !t2.ci(i3, o3)), a3 || (a3 = this.style.map.terrain.tileManager.anyTilesAfterTime(this.terrainFacilitator.renderTime)), a3 && (t2.cj(i3, o3), this.terrainFacilitator.renderTime = Date.now(), this.terrainFacilitator.dirty = false, function(e4, i4) {
+            const o4 = e4.context, a4 = o4.gl, r3 = e4.transform, s3 = Yt.unblended, n3 = new Jt(a4.LEQUAL, Jt.ReadWrite, [0, 1]), l3 = i4.tileManager.getRenderableTiles(), c3 = e4.useProgram("terrainDepth");
+            o4.bindFramebuffer.set(i4.getFramebuffer("depth").framebuffer), o4.viewport.set([0, 0, e4.width / devicePixelRatio, e4.height / devicePixelRatio]), o4.clear({ color: t2.bn.transparent, depth: 1 });
+            for (const e5 of l3) {
+              const t3 = i4.getTerrainMesh(e5.tileID), l4 = i4.getTerrainData(e5.tileID), h3 = r3.getProjectionData({ overscaledTileID: e5.tileID, applyTerrainMatrix: false, applyGlobeMatrix: true }), u3 = { u_ele_delta: i4.getMeshFrameDelta(r3.zoom) };
+              c3.draw(o4, a4.TRIANGLES, n3, ti2.disabled, s3, Qt.backCCW, u3, l4, h3, "terrain", t3.vertexBuffer, t3.indexBuffer, t3.segments);
+            }
+            o4.bindFramebuffer.set(null), o4.viewport.set([0, 0, e4.width, e4.height]);
+          }(this, this.style.map.terrain), function(e4, i4) {
+            const o4 = e4.context, a4 = o4.gl, r3 = e4.transform, s3 = Yt.unblended, n3 = new Jt(a4.LEQUAL, Jt.ReadWrite, [0, 1]), l3 = i4.getCoordsTexture(), c3 = i4.tileManager.getRenderableTiles(), h3 = e4.useProgram("terrainCoords");
+            o4.bindFramebuffer.set(i4.getFramebuffer("coords").framebuffer), o4.viewport.set([0, 0, e4.width / devicePixelRatio, e4.height / devicePixelRatio]), o4.clear({ color: t2.bn.transparent, depth: 1 }), i4.coordsIndex = [];
+            for (const e5 of c3) {
+              const t3 = i4.getTerrainMesh(e5.tileID), c4 = i4.getTerrainData(e5.tileID);
+              o4.activeTexture.set(a4.TEXTURE0), a4.bindTexture(a4.TEXTURE_2D, l3.texture);
+              const u3 = { u_terrain_coords_id: (255 - i4.coordsIndex.length) / 255, u_texture: 0, u_ele_delta: i4.getMeshFrameDelta(r3.zoom) }, d3 = r3.getProjectionData({ overscaledTileID: e5.tileID, applyTerrainMatrix: false, applyGlobeMatrix: true });
+              h3.draw(o4, a4.TRIANGLES, n3, ti2.disabled, s3, Qt.backCCW, u3, c4, d3, "terrain", t3.vertexBuffer, t3.indexBuffer, t3.segments), i4.coordsIndex.push(e5.tileID.key);
+            }
+            o4.bindFramebuffer.set(null), o4.viewport.set([0, 0, e4.width, e4.height]);
+          }(this, this.style.map.terrain));
+        }
+        renderLayer(e3, i3, o3, a3, r3) {
+          o3.isHidden(this.transform.zoom) || ("background" === o3.type || "custom" === o3.type || (a3 || []).length) && (this.id = o3.id, t2.aQ(o3) ? function(e4, i4, o4, a4, r4, s3) {
+            if ("translucent" !== e4.renderPass) return;
+            const { isRenderingToTexture: n3 } = s3, l3 = ti2.disabled, c3 = e4.colorModeForRenderPass();
+            (o4._unevaluatedLayout.hasValue("text-variable-anchor") || o4._unevaluatedLayout.hasValue("text-variable-anchor-offset")) && function(e5, i5, o5, a5, r5, s4, n4, l4, c4) {
+              const h3 = i5.transform, u3 = i5.style.map.terrain, d3 = "map" === r5, _3 = "map" === s4;
+              for (const r6 of e5) {
+                const e6 = a5.getTile(r6), s5 = e6.getBucket(o5);
+                if (!s5 || !s5.text || !s5.text.segments.get().length) continue;
+                const p3 = t2.av(s5.textSizeData, h3.zoom), m3 = t2.aK(e6, 1, i5.transform.zoom), f3 = Be2(d3, i5.transform, m3), g3 = "none" !== o5.layout.get("icon-text-fit") && s5.hasIconData();
+                if (p3) {
+                  const i6 = Math.pow(2, h3.zoom - e6.tileID.overscaledZ), o6 = u3 ? (e7, t3) => u3.getElevation(r6, e7, t3) : null;
+                  da2(s5, d3, _3, c4, h3, f3, i6, p3, g3, t2.aL(h3, e6, n4, l4), r6.toUnwrapped(), o6);
+                }
+              }
+            }(a4, e4, o4, i4, o4.layout.get("text-rotation-alignment"), o4.layout.get("text-pitch-alignment"), o4.paint.get("text-translate"), o4.paint.get("text-translate-anchor"), r4), 0 !== o4.paint.get("icon-opacity").constantOr(1) && pa2(e4, i4, o4, a4, false, o4.paint.get("icon-translate"), o4.paint.get("icon-translate-anchor"), o4.layout.get("icon-rotation-alignment"), o4.layout.get("icon-pitch-alignment"), o4.layout.get("icon-keep-upright"), l3, c3, n3), 0 !== o4.paint.get("text-opacity").constantOr(1) && pa2(e4, i4, o4, a4, true, o4.paint.get("text-translate"), o4.paint.get("text-translate-anchor"), o4.layout.get("text-rotation-alignment"), o4.layout.get("text-pitch-alignment"), o4.layout.get("text-keep-upright"), l3, c3, n3), i4.map.showCollisionBoxes && (la2(e4, i4, o4, a4, true), la2(e4, i4, o4, a4, false));
+          }(e3, i3, o3, a3, this.style.placement.variableOffsets, r3) : t2.ck(o3) ? function(e4, i4, o4, a4, r4) {
+            if ("translucent" !== e4.renderPass) return;
+            const { isRenderingToTexture: s3 } = r4, n3 = o4.paint.get("circle-opacity"), l3 = o4.paint.get("circle-stroke-width"), c3 = o4.paint.get("circle-stroke-opacity"), h3 = !o4.layout.get("circle-sort-key").isConstant();
+            if (0 === n3.constantOr(1) && (0 === l3.constantOr(1) || 0 === c3.constantOr(1))) return;
+            const u3 = e4.context, d3 = u3.gl, _3 = e4.transform, p3 = e4.getDepthModeForSublayer(0, Jt.ReadOnly), m3 = ti2.disabled, f3 = e4.colorModeForRenderPass(), g3 = [], v3 = _3.getCircleRadiusCorrection();
+            for (let r5 = 0; r5 < a4.length; r5++) {
+              const n4 = a4[r5], l4 = i4.getTile(n4), c4 = l4.getBucket(o4);
+              if (!c4) continue;
+              const u4 = o4.paint.get("circle-translate"), d4 = o4.paint.get("circle-translate-anchor"), p4 = t2.aL(_3, l4, u4, d4), m4 = c4.programConfigurations.get(o4.id), f4 = e4.useProgram("circle", m4), x3 = c4.layoutVertexBuffer, b3 = c4.indexBuffer, y3 = e4.style.map.terrain && e4.style.map.terrain.getTerrainData(n4), w3 = { programConfiguration: m4, program: f4, layoutVertexBuffer: x3, indexBuffer: b3, uniformValues: qi2(e4, l4, o4, p4, v3), terrainData: y3, projectionData: _3.getProjectionData({ overscaledTileID: n4, applyGlobeMatrix: !s3, applyTerrainMatrix: true }) };
+              if (h3) {
+                const e5 = c4.segments.get();
+                for (const i5 of e5) g3.push({ segments: new t2.aV([i5]), sortKey: i5.sortKey, state: w3 });
+              } else g3.push({ segments: c4.segments, sortKey: 0, state: w3 });
+            }
+            h3 && g3.sort((e5, t3) => e5.sortKey - t3.sortKey);
+            for (const t3 of g3) {
+              const { programConfiguration: i5, program: a5, layoutVertexBuffer: r5, indexBuffer: s4, uniformValues: n4, terrainData: l4, projectionData: c4 } = t3.state;
+              a5.draw(u3, d3.TRIANGLES, p3, m3, f3, Qt.backCCW, n4, l4, c4, o4.id, r5, s4, t3.segments, o4.paint, e4.transform.zoom, i5);
+            }
+          }(e3, i3, o3, a3, r3) : t2.cl(o3) ? function(e4, i4, o4, a4, r4) {
+            if (0 === o4.paint.get("heatmap-opacity")) return;
+            const s3 = e4.context, { isRenderingToTexture: n3, isRenderingGlobe: l3 } = r4;
+            if (e4.style.map.terrain) {
+              for (const t3 of a4) {
+                const a5 = i4.getTile(t3);
+                i4.hasRenderableParent(t3) || ("offscreen" === e4.renderPass ? fa2(e4, a5, o4, t3, l3) : "translucent" === e4.renderPass && ga(e4, o4, t3, n3, l3));
+              }
+              s3.viewport.set([0, 0, e4.width, e4.height]);
+            } else "offscreen" === e4.renderPass ? function(e5, i5, o5, a5) {
+              const r5 = e5.context, s4 = r5.gl, n4 = e5.transform, l4 = ti2.disabled, c3 = new Yt([s4.ONE, s4.ONE], t2.bn.transparent, [true, true, true, true]);
+              (function(e6, i6, o6) {
+                const a6 = e6.gl;
+                e6.activeTexture.set(a6.TEXTURE1), e6.viewport.set([0, 0, i6.width / 4, i6.height / 4]);
+                let r6 = o6.heatmapFbos.get(t2.cb);
+                r6 ? (a6.bindTexture(a6.TEXTURE_2D, r6.colorAttachment.get()), e6.bindFramebuffer.set(r6.framebuffer)) : (r6 = va2(e6, i6.width / 4, i6.height / 4), o6.heatmapFbos.set(t2.cb, r6));
+              })(r5, e5, o5), r5.clear({ color: t2.bn.transparent });
+              for (let t3 = 0; t3 < a5.length; t3++) {
+                const h3 = a5[t3];
+                if (i5.hasRenderableParent(h3)) continue;
+                const u3 = i5.getTile(h3), d3 = u3.getBucket(o5);
+                if (!d3) continue;
+                const _3 = d3.programConfigurations.get(o5.id), p3 = e5.useProgram("heatmap", _3), m3 = n4.getProjectionData({ overscaledTileID: h3, applyGlobeMatrix: true, applyTerrainMatrix: false }), f3 = n4.getCircleRadiusCorrection();
+                p3.draw(r5, s4.TRIANGLES, Jt.disabled, l4, c3, Qt.backCCW, Yi2(u3, n4.zoom, o5.paint.get("heatmap-intensity"), f3), null, m3, o5.id, d3.layoutVertexBuffer, d3.indexBuffer, d3.segments, o5.paint, n4.zoom, _3);
+              }
+              r5.viewport.set([0, 0, e5.width, e5.height]);
+            }(e4, i4, o4, a4) : "translucent" === e4.renderPass && function(e5, i5) {
+              const o5 = e5.context, a5 = o5.gl;
+              o5.setColorMode(e5.colorModeForRenderPass());
+              const r5 = i5.heatmapFbos.get(t2.cb);
+              r5 && (o5.activeTexture.set(a5.TEXTURE0), a5.bindTexture(a5.TEXTURE_2D, r5.colorAttachment.get()), o5.activeTexture.set(a5.TEXTURE1), xa(o5, i5).bind(a5.LINEAR, a5.CLAMP_TO_EDGE), e5.useProgram("heatmapTexture").draw(o5, a5.TRIANGLES, Jt.disabled, ti2.disabled, e5.colorModeForRenderPass(), Qt.disabled, Ki2(e5, i5, 0, 1), null, null, i5.id, e5.viewportBuffer, e5.quadTriangleIndexBuffer, e5.viewportSegments, i5.paint, e5.transform.zoom));
+            }(e4, o4);
+          }(e3, i3, o3, a3, r3) : t2.cm(o3) ? function(e4, t3, i4, o4, a4) {
+            if ("translucent" !== e4.renderPass) return;
+            const { isRenderingToTexture: r4 } = a4, s3 = i4.paint.get("line-opacity"), n3 = i4.paint.get("line-width");
+            if (0 === s3.constantOr(1) || 0 === n3.constantOr(1)) return;
+            const l3 = e4.getDepthModeForSublayer(0, Jt.ReadOnly), c3 = e4.colorModeForRenderPass(), h3 = i4.paint.get("line-dasharray"), u3 = h3.constantOr(1), d3 = i4.paint.get("line-pattern"), _3 = d3.constantOr(1), p3 = i4.paint.get("line-gradient"), m3 = i4.getCrossfadeParameters();
+            let f3;
+            f3 = _3 ? "linePattern" : u3 && p3 ? "lineGradientSDF" : u3 ? "lineSDF" : p3 ? "lineGradient" : "line";
+            const g3 = e4.context, v3 = g3.gl, x3 = e4.transform;
+            let b3 = true;
+            for (const a5 of o4) {
+              const o5 = t3.getTile(a5);
+              if (_3 && !o5.patternsLoaded()) continue;
+              const s4 = o5.getBucket(i4);
+              if (!s4) continue;
+              const n4 = s4.programConfigurations.get(i4.id), y3 = e4.context.program.get(), w3 = e4.useProgram(f3, n4), T3 = b3 || w3.program !== y3, P3 = e4.style.map.terrain && e4.style.map.terrain.getTerrainData(a5), C3 = d3.constantOr(null), I3 = h3 && h3.constantOr(null);
+              if (C3 && o5.imageAtlas) {
+                const e5 = o5.imageAtlas, t4 = e5.patternPositions[C3.to.toString()], i5 = e5.patternPositions[C3.from.toString()];
+                t4 && i5 && n4.setConstantPatternPositions(t4, i5);
+              } else if (I3) {
+                const t4 = "round" === i4.layout.get("line-cap"), o6 = e4.lineAtlas.getDash(I3.to, t4), a6 = e4.lineAtlas.getDash(I3.from, t4);
+                n4.setConstantDashPositions(o6, a6);
+              }
+              const M3 = x3.getProjectionData({ overscaledTileID: a5, applyGlobeMatrix: !r4, applyTerrainMatrix: true }), E3 = x3.getPixelScale();
+              let S3;
+              _3 ? (S3 = ao(e4, o5, i4, E3, m3), ya2(g3, v3, o5, n4, m3)) : u3 && p3 ? (S3 = so(e4, o5, i4, E3, m3, s4.lineClipsArray.length), Pa2(e4, t3, g3, v3, i4, s4, a5, n4, m3)) : u3 ? (S3 = ro(e4, o5, i4, E3, m3), wa2(e4, g3, v3, n4, T3, m3)) : p3 ? (S3 = oo(e4, o5, i4, E3, s4.lineClipsArray.length), Ta2(e4, t3, g3, v3, i4, s4, a5)) : S3 = io(e4, o5, i4, E3);
+              const R3 = e4.stencilModeForClipping(a5);
+              w3.draw(g3, v3.TRIANGLES, l3, R3, c3, Qt.disabled, S3, P3, M3, i4.id, s4.layoutVertexBuffer, s4.indexBuffer, s4.segments, i4.paint, e4.transform.zoom, n4, s4.layoutVertexBuffer2), b3 = false;
+            }
+          }(e3, i3, o3, a3, r3) : t2.cn(o3) ? function(e4, i4, o4, a4, r4) {
+            const s3 = o4.paint.get("fill-color"), n3 = o4.paint.get("fill-opacity");
+            if (0 === n3.constantOr(1)) return;
+            const { isRenderingToTexture: l3 } = r4, c3 = e4.colorModeForRenderPass(), h3 = o4.paint.get("fill-pattern"), u3 = e4.opaquePassEnabledForLayer() && !h3.constantOr(1) && 1 === s3.constantOr(t2.bn.transparent).a && 1 === n3.constantOr(0) ? "opaque" : "translucent";
+            if (e4.renderPass === u3) {
+              const t3 = e4.getDepthModeForSublayer(1, "opaque" === e4.renderPass ? Jt.ReadWrite : Jt.ReadOnly);
+              Ia2(e4, i4, o4, a4, t3, c3, false, l3);
+            }
+            if ("translucent" === e4.renderPass && o4.paint.get("fill-antialias")) {
+              const t3 = e4.getDepthModeForSublayer(o4.getPaintProperty("fill-outline-color") ? 2 : 0, Jt.ReadOnly);
+              Ia2(e4, i4, o4, a4, t3, c3, true, l3);
+            }
+          }(e3, i3, o3, a3, r3) : t2.co(o3) ? function(e4, t3, i4, o4, a4) {
+            const r4 = i4.paint.get("fill-extrusion-opacity");
+            if (0 === r4) return;
+            const { isRenderingToTexture: s3 } = a4;
+            if ("translucent" === e4.renderPass) {
+              const a5 = new Jt(e4.context.gl.LEQUAL, Jt.ReadWrite, e4.depthRangeFor3D);
+              if (1 !== r4 || i4.paint.get("fill-extrusion-pattern").constantOr(1)) Ma2(e4, t3, i4, o4, a5, ti2.disabled, Yt.disabled, s3), Ma2(e4, t3, i4, o4, a5, e4.stencilModeFor3D(), e4.colorModeForRenderPass(), s3);
+              else {
+                const r5 = e4.colorModeForRenderPass();
+                Ma2(e4, t3, i4, o4, a5, ti2.disabled, r5, s3);
+              }
+            }
+          }(e3, i3, o3, a3, r3) : t2.cp(o3) ? function(e4, i4, o4, a4, r4) {
+            if ("offscreen" !== e4.renderPass && "translucent" !== e4.renderPass) return;
+            const { isRenderingToTexture: s3 } = r4, n3 = e4.context, l3 = e4.style.projection.useSubdivision, c3 = e4.getDepthModeForSublayer(0, Jt.ReadOnly), h3 = e4.colorModeForRenderPass();
+            if ("offscreen" === e4.renderPass) !function(e5, i5, o5, a5, r5, s4, n4) {
+              const l4 = e5.context, c4 = l4.gl, h4 = "nearest" === a5.paint.get("resampling") ? c4.NEAREST : c4.LINEAR;
+              for (const u3 of o5) {
+                const o6 = i5.getTile(u3), d3 = o6.dem;
+                if (!d3 || !d3.data) continue;
+                if (!o6.needsHillshadePrepare) continue;
+                const _3 = d3.dim, p3 = d3.stride, m3 = d3.getPixels();
+                if (l4.activeTexture.set(c4.TEXTURE1), l4.pixelStoreUnpackPremultiplyAlpha.set(false), o6.demTexture = o6.demTexture || e5.getTileTexture(p3), o6.demTexture) {
+                  const e6 = o6.demTexture;
+                  e6.update(m3, { premultiply: false }), e6.bind(c4.NEAREST, c4.CLAMP_TO_EDGE);
+                } else o6.demTexture = new t2.T(l4, m3, c4.RGBA, { premultiply: false }), o6.demTexture.bind(c4.NEAREST, c4.CLAMP_TO_EDGE);
+                l4.activeTexture.set(c4.TEXTURE0);
+                let f3 = o6.fbo;
+                if (!f3) {
+                  const e6 = new t2.T(l4, { width: _3, height: _3, data: null }, c4.RGBA);
+                  e6.bind(h4, c4.CLAMP_TO_EDGE), f3 = o6.fbo = l4.createFramebuffer(_3, _3, true, false), f3.colorAttachment.set(e6.texture);
+                }
+                l4.bindFramebuffer.set(f3.framebuffer), l4.viewport.set([0, 0, _3, _3]), e5.useProgram("hillshadePrepare").draw(l4, c4.TRIANGLES, r5, s4, n4, Qt.disabled, Ji2(o6.tileID, d3), null, null, a5.id, e5.rasterBoundsBuffer, e5.quadTriangleIndexBuffer, e5.rasterBoundsSegments), o6.needsHillshadePrepare = false;
+              }
+            }(e4, i4, a4, o4, c3, ti2.disabled, h3), n3.viewport.set([0, 0, e4.width, e4.height]);
+            else if ("translucent" === e4.renderPass) if (l3) {
+              const [t3, r5, n4] = e4.stencilConfigForOverlapTwoPass(a4);
+              Ea2(e4, i4, o4, n4, t3, c3, h3, false, s3), Ea2(e4, i4, o4, n4, r5, c3, h3, true, s3);
+            } else {
+              const [t3, r5] = e4.getStencilConfigForOverlapAndUpdateStencilID(a4);
+              Ea2(e4, i4, o4, r5, t3, c3, h3, false, s3);
+            }
+          }(e3, i3, o3, a3, r3) : t2.cq(o3) ? function(e4, t3, i4, o4, a4) {
+            if ("translucent" !== e4.renderPass) return;
+            if (!o4.length) return;
+            const { isRenderingToTexture: r4 } = a4, s3 = e4.style.projection.useSubdivision, n3 = e4.getDepthModeForSublayer(0, Jt.ReadOnly), l3 = e4.colorModeForRenderPass();
+            if (s3) {
+              const [a5, s4, c3] = e4.stencilConfigForOverlapTwoPass(o4);
+              Sa2(e4, t3, i4, c3, a5, n3, l3, false, r4), Sa2(e4, t3, i4, c3, s4, n3, l3, true, r4);
+            } else {
+              const [a5, s4] = e4.getStencilConfigForOverlapAndUpdateStencilID(o4);
+              Sa2(e4, t3, i4, s4, a5, n3, l3, false, r4);
+            }
+          }(e3, i3, o3, a3, r3) : t2.bS(o3) ? function(e4, t3, i4, o4, a4) {
+            if ("translucent" !== e4.renderPass) return;
+            if (0 === i4.paint.get("raster-opacity")) return;
+            if (!o4.length) return;
+            const { isRenderingToTexture: r4 } = a4, s3 = t3.getSource(), n3 = e4.style.projection.useSubdivision;
+            if (s3 instanceof J2) za2(e4, t3, i4, o4, null, false, false, s3.tileCoords, s3.flippedWindingOrder, r4);
+            else if (n3) {
+              const [a5, s4, n4] = e4.stencilConfigForOverlapTwoPass(o4);
+              za2(e4, t3, i4, n4, a5, false, true, Ra2, false, r4), za2(e4, t3, i4, n4, s4, true, true, Ra2, false, r4);
+            } else {
+              const [a5, s4] = e4.getStencilConfigForOverlapAndUpdateStencilID(o4);
+              za2(e4, t3, i4, s4, a5, false, true, Ra2, false, r4);
+            }
+          }(e3, i3, o3, a3, r3) : t2.cr(o3) ? function(e4, t3, i4, o4, a4) {
+            const r4 = i4.paint.get("background-color"), s3 = i4.paint.get("background-opacity");
+            if (0 === s3) return;
+            const { isRenderingToTexture: n3 } = a4, l3 = e4.context, c3 = l3.gl, h3 = e4.style.projection, u3 = e4.transform, d3 = u3.tileSize, _3 = i4.paint.get("background-pattern");
+            if (e4.isPatternMissing(_3)) return;
+            const p3 = !_3 && 1 === r4.a && 1 === s3 && e4.opaquePassEnabledForLayer() ? "opaque" : "translucent";
+            if (e4.renderPass !== p3) return;
+            const m3 = ti2.disabled, f3 = e4.getDepthModeForSublayer(0, "opaque" === p3 ? Jt.ReadWrite : Jt.ReadOnly), g3 = e4.colorModeForRenderPass(), v3 = e4.useProgram(_3 ? "backgroundPattern" : "background"), x3 = o4 || Pe2(u3, { tileSize: d3, terrain: e4.style.map.terrain });
+            _3 && (l3.activeTexture.set(c3.TEXTURE0), e4.imageManager.bind(e4.context));
+            const b3 = i4.getCrossfadeParameters();
+            for (const t4 of x3) {
+              const o5 = u3.getProjectionData({ overscaledTileID: t4, applyGlobeMatrix: !n3, applyTerrainMatrix: true }), a5 = _3 ? fo(s3, e4, _3, { tileID: t4, tileSize: d3 }, b3) : mo(s3, r4), p4 = e4.style.map.terrain && e4.style.map.terrain.getTerrainData(t4), x4 = h3.getMeshFromTileID(l3, t4.canonical, false, true, "raster");
+              v3.draw(l3, c3.TRIANGLES, f3, m3, g3, Qt.backCCW, a5, p4, o5, i4.id, x4.vertexBuffer, x4.indexBuffer, x4.segments);
+            }
+          }(e3, 0, o3, a3, r3) : t2.cs(o3) && function(e4, t3, i4, o4) {
+            const { isRenderingGlobe: a4 } = o4, r4 = e4.context, s3 = i4.implementation, n3 = e4.style.projection, l3 = e4.transform, c3 = l3.getProjectionDataForCustomLayer(a4), h3 = { farZ: l3.farZ, nearZ: l3.nearZ, fov: l3.fov * Math.PI / 180, modelViewProjectionMatrix: l3.modelViewProjectionMatrix, projectionMatrix: l3.projectionMatrix, shaderData: { variantName: n3.shaderVariantName, vertexShaderPrelude: `const float PI = 3.141592653589793;
+uniform mat4 u_projection_matrix;
+${n3.shaderPreludeCode.vertexSource}`, define: n3.shaderDefine }, defaultProjectionData: c3 }, u3 = s3.renderingMode ? s3.renderingMode : "2d";
+            if ("offscreen" === e4.renderPass) {
+              const t4 = s3.prerender;
+              t4 && (e4.setCustomLayerDefaults(), r4.setColorMode(e4.colorModeForRenderPass()), t4.call(s3, r4.gl, h3), r4.setDirty(), e4.setBaseState());
+            } else if ("translucent" === e4.renderPass) {
+              e4.setCustomLayerDefaults(), r4.setColorMode(e4.colorModeForRenderPass()), r4.setStencilMode(ti2.disabled);
+              const t4 = "3d" === u3 ? e4.getDepthModeFor3D() : e4.getDepthModeForSublayer(0, Jt.ReadOnly);
+              r4.setDepthMode(t4), s3.render(r4.gl, h3), r4.setDirty(), e4.setBaseState(), r4.bindFramebuffer.set(null);
+            }
+          }(e3, 0, o3, r3));
+        }
+        saveTileTexture(e3) {
+          const t3 = this._tileTextures[e3.size[0]];
+          t3 ? t3.length < Va2.MAX_TEXTURE_POOL_SIZE_PER_BUCKET ? t3.push(e3) : e3.destroy() : this._tileTextures[e3.size[0]] = [e3];
+        }
+        getTileTexture(e3) {
+          const t3 = this._tileTextures[e3];
+          return t3 && t3.length > 0 ? t3.pop() : null;
+        }
+        isPatternMissing(e3) {
+          if (!e3) return false;
+          if (!e3.from || !e3.to) return true;
+          const t3 = this.imageManager.getPattern(e3.from.toString()), i3 = this.imageManager.getPattern(e3.to.toString());
+          return !t3 || !i3;
+        }
+        useProgram(e3, t3, i3 = false, o3 = []) {
+          this.cache = this.cache || {};
+          const a3 = !!this.style.map.terrain, r3 = this.style.projection, s3 = i3 ? zt.projectionMercator : r3.shaderPreludeCode, n3 = i3 ? kt : r3.shaderDefine, l3 = e3 + (t3 ? t3.cacheKey : "") + `/${i3 ? Ft : r3.shaderVariantName}` + (this._showOverdrawInspector ? "/overdraw" : "") + (a3 ? "/terrain" : "") + (o3 ? `/${o3.join("/")}` : "");
+          return this.cache[l3] || (this.cache[l3] = new ji2(this.context, zt[e3], t3, vo[e3], this._showOverdrawInspector, a3, s3, n3, o3)), this.cache[l3];
+        }
+        setCustomLayerDefaults() {
+          this.context.unbindVAO(), this.context.cullFace.setDefault(), this.context.activeTexture.setDefault(), this.context.pixelStoreUnpack.setDefault(), this.context.pixelStoreUnpackPremultiplyAlpha.setDefault(), this.context.pixelStoreUnpackFlipY.setDefault();
+        }
+        setBaseState() {
+          const e3 = this.context.gl;
+          this.context.cullFace.set(false), this.context.viewport.set([0, 0, this.width, this.height]), this.context.blendEquation.set(e3.FUNC_ADD);
+        }
+        initDebugOverlayCanvas() {
+          null == this.debugOverlayCanvas && (this.debugOverlayCanvas = document.createElement("canvas"), this.debugOverlayCanvas.width = 512, this.debugOverlayCanvas.height = 512, this.debugOverlayTexture = new t2.T(this.context, this.debugOverlayCanvas, this.context.gl.RGBA));
+        }
+        destroy() {
+          var e3, t3;
+          if (this._tileTextures) {
+            for (const e4 in this._tileTextures) {
+              const t4 = this._tileTextures[e4];
+              if (t4) for (const e5 of t4) e5.destroy();
+            }
+            this._tileTextures = {};
+          }
+          if (this.tileExtentBuffer && this.tileExtentBuffer.destroy(), this.debugBuffer && this.debugBuffer.destroy(), this.rasterBoundsBuffer && this.rasterBoundsBuffer.destroy(), this.rasterBoundsBufferPosOnly && this.rasterBoundsBufferPosOnly.destroy(), this.viewportBuffer && this.viewportBuffer.destroy(), this.tileBorderIndexBuffer && this.tileBorderIndexBuffer.destroy(), this.quadTriangleIndexBuffer && this.quadTriangleIndexBuffer.destroy(), this.tileExtentMesh && (null === (e3 = this.tileExtentMesh.vertexBuffer) || void 0 === e3 || e3.destroy()), this.tileExtentMesh && (null === (t3 = this.tileExtentMesh.indexBuffer) || void 0 === t3 || t3.destroy()), this.debugOverlayTexture && this.debugOverlayTexture.destroy(), this.cache) {
+            for (const e4 in this.cache) {
+              const t4 = this.cache[e4];
+              t4 && t4.program && this.context.gl.deleteProgram(t4.program);
+            }
+            this.cache = {};
+          }
+          this.context && this.context.setDefault();
+        }
+        overLimit() {
+          const { drawingBufferWidth: e3, drawingBufferHeight: t3 } = this.context.gl;
+          return this.width !== e3 || this.height !== t3;
+        }
+      }
+      function Wa2(e3, t3) {
+        let i3, o3 = false, a3 = null, r3 = null;
+        const s3 = () => {
+          a3 = null, o3 && (e3.apply(r3, i3), a3 = setTimeout(s3, t3), o3 = false);
+        };
+        return (...e4) => (o3 = true, r3 = this, i3 = e4, a3 || s3(), a3);
+      }
+      Va2.MAX_TEXTURE_POOL_SIZE_PER_BUCKET = 50;
+      class qa2 {
+        constructor(e3) {
+          this._getCurrentHash = () => {
+            const e4 = window.location.hash.replace("#", "");
+            if (this._hashName) {
+              let t3;
+              return e4.split("&").map((e5) => e5.split("=")).forEach((e5) => {
+                e5[0] === this._hashName && (t3 = e5);
+              }), (t3 && t3[1] || "").split("/");
+            }
+            return e4.split("/");
+          }, this._onHashChange = () => {
+            const e4 = this._getCurrentHash();
+            if (!this._isValidHash(e4)) return false;
+            const t3 = this._map.dragRotate.isEnabled() && this._map.touchZoomRotate.isEnabled() ? +(e4[3] || 0) : this._map.getBearing();
+            return this._map.jumpTo({ center: [+e4[2], +e4[1]], zoom: +e4[0], bearing: t3, pitch: +(e4[4] || 0) }), true;
+          }, this._updateHashUnthrottled = () => {
+            const e4 = window.location.href.replace(/(#.*)?$/, this.getHashString());
+            window.history.replaceState(window.history.state, null, e4);
+          }, this._removeHash = () => {
+            const e4 = this._getCurrentHash();
+            if (0 === e4.length) return;
+            const t3 = e4.join("/");
+            let i3 = t3;
+            i3.split("&").length > 0 && (i3 = i3.split("&")[0]), this._hashName && (i3 = `${this._hashName}=${t3}`);
+            let o3 = window.location.hash.replace(i3, "");
+            o3.startsWith("#&") ? o3 = o3.slice(0, 1) + o3.slice(2) : "#" === o3 && (o3 = "");
+            let a3 = window.location.href.replace(/(#.+)?$/, o3);
+            a3 = a3.replace("&&", "&"), window.history.replaceState(window.history.state, null, a3);
+          }, this._updateHash = Wa2(this._updateHashUnthrottled, 300), this._hashName = e3 && encodeURIComponent(e3);
+        }
+        addTo(e3) {
+          return this._map = e3, addEventListener("hashchange", this._onHashChange, false), this._map.on("moveend", this._updateHash), this;
+        }
+        remove() {
+          return removeEventListener("hashchange", this._onHashChange, false), this._map.off("moveend", this._updateHash), clearTimeout(this._updateHash()), this._removeHash(), delete this._map, this;
+        }
+        getHashString(e3) {
+          const t3 = this._map.getCenter(), i3 = Math.round(100 * this._map.getZoom()) / 100, o3 = Math.ceil((i3 * Math.LN2 + Math.log(512 / 360 / 0.5)) / Math.LN10), a3 = Math.pow(10, o3), r3 = Math.round(t3.lng * a3) / a3, s3 = Math.round(t3.lat * a3) / a3, n3 = this._map.getBearing(), l3 = this._map.getPitch();
+          let c3 = "";
+          if (c3 += e3 ? `/${r3}/${s3}/${i3}` : `${i3}/${s3}/${r3}`, (n3 || l3) && (c3 += "/" + Math.round(10 * n3) / 10), l3 && (c3 += `/${Math.round(l3)}`), this._hashName) {
+            const e4 = this._hashName;
+            let t4 = false;
+            const i4 = window.location.hash.slice(1).split("&").map((i5) => {
+              const o4 = i5.split("=")[0];
+              return o4 === e4 ? (t4 = true, `${o4}=${c3}`) : i5;
+            }).filter((e5) => e5);
+            return t4 || i4.push(`${e4}=${c3}`), `#${i4.join("&")}`;
+          }
+          return `#${c3}`;
+        }
+        _isValidHash(e3) {
+          if (e3.length < 3 || e3.some(isNaN)) return false;
+          try {
+            new t2.V(+e3[2], +e3[1]);
+          } catch (e4) {
+            return false;
+          }
+          const i3 = +e3[0], o3 = +(e3[3] || 0), a3 = +(e3[4] || 0);
+          return i3 >= this._map.getMinZoom() && i3 <= this._map.getMaxZoom() && o3 >= -180 && o3 <= 180 && a3 >= this._map.getMinPitch() && a3 <= this._map.getMaxPitch();
+        }
+      }
+      const $a = { linearity: 0.3, easing: t2.ct(0, 0, 0.3, 1) }, Ha2 = t2.e({ deceleration: 2500, maxSpeed: 1400 }, $a), Xa2 = t2.e({ deceleration: 20, maxSpeed: 1400 }, $a), Ya2 = t2.e({ deceleration: 1e3, maxSpeed: 360 }, $a), Ka2 = t2.e({ deceleration: 1e3, maxSpeed: 90 }, $a), Qa2 = t2.e({ deceleration: 1e3, maxSpeed: 360 }, $a);
+      class Ja2 {
+        constructor(e3) {
+          this._map = e3, this.clear();
+        }
+        clear() {
+          this._inertiaBuffer = [];
+        }
+        record(e3) {
+          this._drainInertiaBuffer(), this._inertiaBuffer.push({ time: c2(), settings: e3 });
+        }
+        _drainInertiaBuffer() {
+          const e3 = this._inertiaBuffer, t3 = c2();
+          for (; e3.length > 0 && t3 - e3[0].time > 160; ) e3.shift();
+        }
+        _onMoveEnd(e3) {
+          if (this._drainInertiaBuffer(), this._inertiaBuffer.length < 2) return;
+          const i3 = { zoom: 0, bearing: 0, pitch: 0, roll: 0, pan: new t2.P(0, 0), pinchAround: void 0, around: void 0 };
+          for (const { settings: e4 } of this._inertiaBuffer) i3.zoom += e4.zoomDelta || 0, i3.bearing += e4.bearingDelta || 0, i3.pitch += e4.pitchDelta || 0, i3.roll += e4.rollDelta || 0, e4.panDelta && i3.pan._add(e4.panDelta), e4.around && (i3.around = e4.around), e4.pinchAround && (i3.pinchAround = e4.pinchAround);
+          const o3 = this._inertiaBuffer[this._inertiaBuffer.length - 1].time - this._inertiaBuffer[0].time, a3 = {};
+          if (i3.pan.mag()) {
+            const r3 = tr(i3.pan.mag(), o3, t2.e({}, Ha2, e3 || {})), s3 = i3.pan.mult(r3.amount / i3.pan.mag()), n3 = this._map.cameraHelper.handlePanInertia(s3, this._map.transform);
+            a3.center = n3.easingCenter, a3.offset = n3.easingOffset, er(a3, r3);
+          }
+          if (i3.zoom) {
+            const e4 = tr(i3.zoom, o3, Xa2), r3 = t2.cu(this._map.transform.zoom + e4.amount, this._map.getZoomSnap(), e4.amount);
+            a3.zoom = r3, er(a3, e4);
+          }
+          if (i3.bearing) {
+            const e4 = tr(i3.bearing, o3, Ya2);
+            a3.bearing = this._map.transform.bearing + t2.ak(e4.amount, -179, 179), er(a3, e4);
+          }
+          if (i3.pitch) {
+            const e4 = tr(i3.pitch, o3, Ka2);
+            a3.pitch = this._map.transform.pitch + e4.amount, er(a3, e4);
+          }
+          if (i3.roll) {
+            const e4 = tr(i3.roll, o3, Qa2);
+            a3.roll = this._map.transform.roll + t2.ak(e4.amount, -179, 179), er(a3, e4);
+          }
+          if (a3.zoom || a3.bearing) {
+            const e4 = void 0 === i3.pinchAround ? i3.around : i3.pinchAround;
+            a3.around = e4 ? this._map.unproject(e4) : this._map.getCenter();
+          }
+          return this.clear(), t2.e(a3, { noMoveStart: true });
+        }
+      }
+      function er(e3, t3) {
+        (!e3.duration || e3.duration < t3.duration) && (e3.duration = t3.duration, e3.easing = t3.easing);
+      }
+      function tr(e3, i3, o3) {
+        const { maxSpeed: a3, linearity: r3, deceleration: s3 } = o3, n3 = t2.ak(e3 * r3 / (i3 / 1e3), -a3, a3), l3 = Math.abs(n3) / (s3 * r3);
+        return { easing: o3.easing, duration: 1e3 * l3, amount: n3 * (l3 / 2) };
+      }
+      class ir extends t2.l {
+        preventDefault() {
+          this._defaultPrevented = true;
+        }
+        get defaultPrevented() {
+          return this._defaultPrevented;
+        }
+        constructor(e3, i3, o3, a3 = {}) {
+          o3 = o3 instanceof MouseEvent ? o3 : new MouseEvent(e3, o3);
+          const r3 = h2.mousePos(i3.getCanvas(), o3), s3 = i3.unproject(r3);
+          super(e3, t2.e({ point: r3, lngLat: s3, originalEvent: o3 }, a3)), this._defaultPrevented = false, this.target = i3;
+        }
+      }
+      class or extends t2.l {
+        preventDefault() {
+          this._defaultPrevented = true;
+        }
+        get defaultPrevented() {
+          return this._defaultPrevented;
+        }
+        constructor(e3, i3, o3) {
+          const a3 = "touchend" === e3 ? o3.changedTouches : o3.touches, r3 = h2.touchPos(i3.getCanvasContainer(), a3), s3 = r3.map((e4) => i3.unproject(e4)), n3 = r3.reduce((e4, t3, i4, o4) => e4.add(t3.div(o4.length)), new t2.P(0, 0));
+          super(e3, { points: r3, point: n3, lngLats: s3, lngLat: i3.unproject(n3), originalEvent: o3 }), this._defaultPrevented = false;
+        }
+      }
+      class ar extends t2.l {
+        preventDefault() {
+          this._defaultPrevented = true;
+        }
+        get defaultPrevented() {
+          return this._defaultPrevented;
+        }
+        constructor(e3, t3, i3) {
+          super(e3, { originalEvent: i3 }), this._defaultPrevented = false;
+        }
+      }
+      class rr {
+        constructor(e3, t3) {
+          this._map = e3, this._clickTolerance = t3.clickTolerance;
+        }
+        reset() {
+          delete this._mousedownPos;
+        }
+        wheel(e3) {
+          return this._firePreventable(new ar(e3.type, this._map, e3));
+        }
+        mousedown(e3, t3) {
+          return this._mousedownPos = t3, this._firePreventable(new ir(e3.type, this._map, e3));
+        }
+        mouseup(e3) {
+          this._map.fire(new ir(e3.type, this._map, e3));
+        }
+        click(e3, t3) {
+          this._mousedownPos && this._mousedownPos.dist(t3) >= this._clickTolerance || this._map.fire(new ir(e3.type, this._map, e3));
+        }
+        dblclick(e3) {
+          return this._firePreventable(new ir(e3.type, this._map, e3));
+        }
+        mouseover(e3) {
+          this._map.fire(new ir(e3.type, this._map, e3));
+        }
+        mouseout(e3) {
+          this._map.fire(new ir(e3.type, this._map, e3));
+        }
+        touchstart(e3) {
+          return this._firePreventable(new or(e3.type, this._map, e3));
+        }
+        touchmove(e3) {
+          this._map.fire(new or(e3.type, this._map, e3));
+        }
+        touchend(e3) {
+          this._map.fire(new or(e3.type, this._map, e3));
+        }
+        touchcancel(e3) {
+          this._map.fire(new or(e3.type, this._map, e3));
+        }
+        _firePreventable(e3) {
+          if (this._map.fire(e3), e3.defaultPrevented) return {};
+        }
+        isEnabled() {
+          return true;
+        }
+        isActive() {
+          return false;
+        }
+        enable() {
+        }
+        disable() {
+        }
+      }
+      class sr {
+        constructor(e3) {
+          this._map = e3;
+        }
+        reset() {
+          this._delayContextMenu = false, this._ignoreContextMenu = true, delete this._contextMenuEvent;
+        }
+        mousemove(e3) {
+          this._map.fire(new ir(e3.type, this._map, e3));
+        }
+        mousedown() {
+          this._delayContextMenu = true, this._ignoreContextMenu = false;
+        }
+        mouseup() {
+          this._delayContextMenu = false, this._contextMenuEvent && (this._map.fire(new ir("contextmenu", this._map, this._contextMenuEvent)), delete this._contextMenuEvent);
+        }
+        contextmenu(e3) {
+          this._delayContextMenu ? this._contextMenuEvent = e3 : this._ignoreContextMenu || this._map.fire(new ir(e3.type, this._map, e3)), this._map.listens("contextmenu") && e3.preventDefault();
+        }
+        isEnabled() {
+          return true;
+        }
+        isActive() {
+          return false;
+        }
+        enable() {
+        }
+        disable() {
+        }
+      }
+      class nr {
+        constructor(e3) {
+          this._map = e3;
+        }
+        get transform() {
+          return this._map._requestedCameraState || this._map.transform;
+        }
+        get center() {
+          return { lng: this.transform.center.lng, lat: this.transform.center.lat };
+        }
+        get zoom() {
+          return this.transform.zoom;
+        }
+        get pitch() {
+          return this.transform.pitch;
+        }
+        get bearing() {
+          return this.transform.bearing;
+        }
+        unproject(e3) {
+          return this.transform.screenPointToLocation(t2.P.convert(e3), this._map.terrain);
+        }
+      }
+      class lr {
+        constructor(e3, t3) {
+          this._map = e3, this._tr = new nr(e3), this._el = e3.getCanvasContainer(), this._container = e3.getContainer(), this._clickTolerance = t3.clickTolerance || 1, t3.boxZoom && "object" == typeof t3.boxZoom && (this._boxZoomEnd = t3.boxZoom.boxZoomEnd);
+        }
+        isEnabled() {
+          return !!this._enabled;
+        }
+        isActive() {
+          return !!this._active;
+        }
+        enable() {
+          this.isEnabled() || (this._enabled = true);
+        }
+        disable() {
+          this.isEnabled() && (this._enabled = false);
+        }
+        mousedown(e3, t3) {
+          this.isEnabled() && e3.shiftKey && 0 === e3.button && (h2.disableDrag(), this._startPos = this._lastPos = t3, this._active = true);
+        }
+        mousemoveWindow(e3, t3) {
+          if (!this._active) return;
+          const i3 = t3;
+          if (this._lastPos.equals(i3) || !this._box && i3.dist(this._startPos) < this._clickTolerance) return;
+          const o3 = this._startPos;
+          this._lastPos = i3, this._box || (this._box = h2.create("div", "maplibregl-boxzoom", this._container), this._container.classList.add("maplibregl-crosshair"), this._fireEvent("boxzoomstart", e3));
+          const a3 = Math.min(o3.x, i3.x), r3 = Math.max(o3.x, i3.x), s3 = Math.min(o3.y, i3.y), n3 = Math.max(o3.y, i3.y);
+          this._box.style.transform = `translate(${a3}px,${s3}px)`, this._box.style.width = r3 - a3 + "px", this._box.style.height = n3 - s3 + "px";
+        }
+        mouseupWindow(e3, i3) {
+          if (!this._active) return;
+          if (0 !== e3.button) return;
+          const o3 = this._startPos, a3 = i3;
+          if (this.reset(), h2.suppressClick(), o3.x !== a3.x || o3.y !== a3.y) return this._map.fire(new t2.l("boxzoomend", { originalEvent: e3 })), this._boxZoomEnd ? void this._boxZoomEnd(this._map, o3, a3, e3) : { cameraAnimation: (e4) => e4.fitScreenCoordinates(o3, a3, this._tr.bearing, { linear: true }) };
+          this._fireEvent("boxzoomcancel", e3);
+        }
+        keydown(e3) {
+          this._active && 27 === e3.keyCode && (this.reset(), this._fireEvent("boxzoomcancel", e3));
+        }
+        reset() {
+          this._active = false, this._container.classList.remove("maplibregl-crosshair"), this._box && (this._box.remove(), this._box = null), h2.enableDrag(), delete this._startPos, delete this._lastPos;
+        }
+        _fireEvent(e3, i3) {
+          return this._map.fire(new t2.l(e3, { originalEvent: i3 }));
+        }
+      }
+      function cr(e3, t3) {
+        if (e3.length !== t3.length) throw new Error(`The number of touches and points are not equal - touches ${e3.length}, points ${t3.length}`);
+        const i3 = {};
+        for (let o3 = 0; o3 < e3.length; o3++) i3[e3[o3].identifier] = t3[o3];
+        return i3;
+      }
+      class hr {
+        constructor(e3) {
+          this.reset(), this.numTouches = e3.numTouches;
+        }
+        reset() {
+          delete this.centroid, delete this.startTime, delete this.touches, this.aborted = false;
+        }
+        touchstart(e3, i3, o3) {
+          (this.centroid || o3.length > this.numTouches) && (this.aborted = true), this.aborted || (void 0 === this.startTime && (this.startTime = e3.timeStamp), o3.length === this.numTouches && (this.centroid = function(e4) {
+            const i4 = new t2.P(0, 0);
+            for (const t3 of e4) i4._add(t3);
+            return i4.div(e4.length);
+          }(i3), this.touches = cr(o3, i3)));
+        }
+        touchmove(e3, t3, i3) {
+          if (this.aborted || !this.centroid) return;
+          const o3 = cr(i3, t3);
+          for (const e4 in this.touches) {
+            const t4 = o3[e4];
+            (!t4 || t4.dist(this.touches[e4]) > 30) && (this.aborted = true);
+          }
+        }
+        touchend(e3, t3, i3) {
+          if ((!this.centroid || e3.timeStamp - this.startTime > 500) && (this.aborted = true), 0 === i3.length) {
+            const e4 = !this.aborted && this.centroid;
+            if (this.reset(), e4) return e4;
+          }
+        }
+      }
+      class ur {
+        constructor(e3) {
+          this.singleTap = new hr(e3), this.numTaps = e3.numTaps, this.reset();
+        }
+        reset() {
+          this.lastTime = 1 / 0, delete this.lastTap, this.count = 0, this.singleTap.reset();
+        }
+        touchstart(e3, t3, i3) {
+          this.singleTap.touchstart(e3, t3, i3);
+        }
+        touchmove(e3, t3, i3) {
+          this.singleTap.touchmove(e3, t3, i3);
+        }
+        touchend(e3, t3, i3) {
+          const o3 = this.singleTap.touchend(e3, t3, i3);
+          if (o3) {
+            const t4 = e3.timeStamp - this.lastTime < 500, i4 = !this.lastTap || this.lastTap.dist(o3) < 30;
+            if (t4 && i4 || this.reset(), this.count++, this.lastTime = e3.timeStamp, this.lastTap = o3, this.count === this.numTaps) return this.reset(), o3;
+          }
+        }
+      }
+      class dr {
+        constructor(e3) {
+          this._tr = new nr(e3), this._zoomIn = new ur({ numTouches: 1, numTaps: 2 }), this._zoomOut = new ur({ numTouches: 2, numTaps: 1 }), this.reset();
+        }
+        reset() {
+          this._active = false, this._zoomIn.reset(), this._zoomOut.reset();
+        }
+        touchstart(e3, t3, i3) {
+          this._zoomIn.touchstart(e3, t3, i3), this._zoomOut.touchstart(e3, t3, i3);
+        }
+        touchmove(e3, t3, i3) {
+          this._zoomIn.touchmove(e3, t3, i3), this._zoomOut.touchmove(e3, t3, i3);
+        }
+        touchend(e3, i3, o3) {
+          const a3 = this._zoomIn.touchend(e3, i3, o3), r3 = this._zoomOut.touchend(e3, i3, o3), s3 = this._tr;
+          return a3 ? (this._active = true, e3.preventDefault(), setTimeout(() => this.reset(), 0), { cameraAnimation: (i4) => i4.easeTo({ duration: 300, zoom: t2.cu(s3.zoom + 1, i4.getZoomSnap()), around: s3.unproject(a3) }, { originalEvent: e3 }) }) : r3 ? (this._active = true, e3.preventDefault(), setTimeout(() => this.reset(), 0), { cameraAnimation: (i4) => i4.easeTo({ duration: 300, zoom: t2.cu(s3.zoom - 1, i4.getZoomSnap()), around: s3.unproject(r3) }, { originalEvent: e3 }) }) : void 0;
+        }
+        touchcancel() {
+          this.reset();
+        }
+        enable() {
+          this._enabled = true;
+        }
+        disable() {
+          this._enabled = false, this.reset();
+        }
+        isEnabled() {
+          return this._enabled;
+        }
+        isActive() {
+          return this._active;
+        }
+      }
+      class _r2 {
+        constructor(e3) {
+          this._enabled = !!e3.enable, this._moveStateManager = e3.moveStateManager, this._clickTolerance = e3.clickTolerance || 1, this._moveFunction = e3.move, this._activateOnStart = !!e3.activateOnStart, e3.assignEvents(this), this.reset();
+        }
+        reset(e3) {
+          this._active = false, this._moved = false, delete this._lastPoint, this._moveStateManager.endMove(e3);
+        }
+        _move(...e3) {
+          const t3 = this._moveFunction(...e3);
+          if (t3.bearingDelta || t3.pitchDelta || t3.rollDelta || t3.around || t3.panDelta) return this._active = true, t3;
+        }
+        dragStart(e3, t3) {
+          this.isEnabled() && !this._lastPoint && this._moveStateManager.isValidStartEvent(e3) && (this._moveStateManager.startMove(e3), this._lastPoint = Array.isArray(t3) ? t3[0] : t3, this._activateOnStart && this._lastPoint && (this._active = true));
+        }
+        dragMove(e3, t3) {
+          if (!this.isEnabled()) return;
+          const i3 = this._lastPoint;
+          if (!i3) return;
+          if (e3.preventDefault(), !this._moveStateManager.isValidMoveEvent(e3)) return void this.reset(e3);
+          const o3 = Array.isArray(t3) ? t3[0] : t3;
+          return !this._moved && o3.dist(i3) < this._clickTolerance ? void 0 : (this._moved = true, this._lastPoint = o3, this._move(i3, o3));
+        }
+        dragEnd(e3) {
+          this.isEnabled() && this._lastPoint && this._moveStateManager.isValidEndEvent(e3) && (this._moved && h2.suppressClick(), this.reset(e3));
+        }
+        enable() {
+          this._enabled = true;
+        }
+        disable() {
+          this._enabled = false, this.reset();
+        }
+        isEnabled() {
+          return this._enabled;
+        }
+        isActive() {
+          return this._active;
+        }
+        getClickTolerance() {
+          return this._clickTolerance;
+        }
+      }
+      const pr = 0, mr = 2, fr = { [pr]: 1, [mr]: 2 };
+      class gr {
+        constructor(e3) {
+          this._correctEvent = e3.checkCorrectEvent;
+        }
+        startMove(e3) {
+          this._eventButton = e3.button;
+        }
+        endMove(e3) {
+          delete this._eventButton;
+        }
+        isValidStartEvent(e3) {
+          return this._correctEvent(e3);
+        }
+        isValidMoveEvent(e3) {
+          return !function(e4, t3) {
+            const i3 = fr[t3];
+            return void 0 === e4.buttons || (e4.buttons & i3) !== i3;
+          }(e3, this._eventButton);
+        }
+        isValidEndEvent(e3) {
+          return e3.button === this._eventButton;
+        }
+      }
+      class vr {
+        constructor() {
+          this._firstTouch = void 0;
+        }
+        _isOneFingerTouch(e3) {
+          return 1 === e3.targetTouches.length;
+        }
+        _isSameTouchEvent(e3) {
+          return e3.targetTouches[0].identifier === this._firstTouch;
+        }
+        startMove(e3) {
+          this._firstTouch = e3.targetTouches[0].identifier;
+        }
+        endMove(e3) {
+          delete this._firstTouch;
+        }
+        isValidStartEvent(e3) {
+          return this._isOneFingerTouch(e3);
+        }
+        isValidMoveEvent(e3) {
+          return this._isOneFingerTouch(e3) && this._isSameTouchEvent(e3);
+        }
+        isValidEndEvent(e3) {
+          return this._isOneFingerTouch(e3) && this._isSameTouchEvent(e3);
+        }
+      }
+      class xr {
+        constructor(e3 = new gr({ checkCorrectEvent: () => true }), t3 = new vr()) {
+          this.mouseMoveStateManager = e3, this.oneFingerTouchMoveStateManager = t3;
+        }
+        _executeRelevantHandler(e3, t3, i3) {
+          return e3 instanceof MouseEvent ? t3(e3) : "undefined" != typeof TouchEvent && e3 instanceof TouchEvent ? i3(e3) : void 0;
+        }
+        startMove(e3) {
+          this._executeRelevantHandler(e3, (e4) => this.mouseMoveStateManager.startMove(e4), (e4) => this.oneFingerTouchMoveStateManager.startMove(e4));
+        }
+        endMove(e3) {
+          this._executeRelevantHandler(e3, (e4) => this.mouseMoveStateManager.endMove(e4), (e4) => this.oneFingerTouchMoveStateManager.endMove(e4));
+        }
+        isValidStartEvent(e3) {
+          return this._executeRelevantHandler(e3, (e4) => this.mouseMoveStateManager.isValidStartEvent(e4), (e4) => this.oneFingerTouchMoveStateManager.isValidStartEvent(e4));
+        }
+        isValidMoveEvent(e3) {
+          return this._executeRelevantHandler(e3, (e4) => this.mouseMoveStateManager.isValidMoveEvent(e4), (e4) => this.oneFingerTouchMoveStateManager.isValidMoveEvent(e4));
+        }
+        isValidEndEvent(e3) {
+          return this._executeRelevantHandler(e3, (e4) => this.mouseMoveStateManager.isValidEndEvent(e4), (e4) => this.oneFingerTouchMoveStateManager.isValidEndEvent(e4));
+        }
+      }
+      const br = (e3) => {
+        e3.mousedown = e3.dragStart, e3.mousemoveWindow = e3.dragMove, e3.mouseup = e3.dragEnd, e3.contextmenu = (e4) => {
+          e4.preventDefault();
+        };
+      };
+      class yr {
+        constructor(e3, t3) {
+          this._clickTolerance = e3.clickTolerance || 1, this._map = t3, this.reset();
+        }
+        reset() {
+          this._active = false, this._touches = {}, this._sum = new t2.P(0, 0);
+        }
+        _shouldBePrevented(e3) {
+          return e3 < (this._map.cooperativeGestures.isEnabled() ? 2 : 1);
+        }
+        touchstart(e3, t3, i3) {
+          return this._calculateTransform(e3, t3, i3);
+        }
+        touchmove(e3, t3, i3) {
+          if (this._active) {
+            if (!this._shouldBePrevented(i3.length)) return e3.preventDefault(), this._calculateTransform(e3, t3, i3);
+            this._map.cooperativeGestures.notifyGestureBlocked("touch_pan", e3);
+          }
+        }
+        touchend(e3, t3, i3) {
+          this._calculateTransform(e3, t3, i3), this._active && this._shouldBePrevented(i3.length) && this.reset();
+        }
+        touchcancel() {
+          this.reset();
+        }
+        _calculateTransform(e3, i3, o3) {
+          o3.length > 0 && (this._active = true);
+          const a3 = cr(o3, i3), r3 = new t2.P(0, 0), s3 = new t2.P(0, 0);
+          let n3 = 0;
+          for (const e4 in a3) {
+            const t3 = a3[e4], i4 = this._touches[e4];
+            i4 && (r3._add(t3), s3._add(t3.sub(i4)), n3++, a3[e4] = t3);
+          }
+          if (this._touches = a3, this._shouldBePrevented(n3) || !s3.mag()) return;
+          const l3 = s3.div(n3);
+          return this._sum._add(l3), this._sum.mag() < this._clickTolerance ? void 0 : { around: r3.div(n3), panDelta: l3 };
+        }
+        enable() {
+          this._enabled = true;
+        }
+        disable() {
+          this._enabled = false, this.reset();
+        }
+        isEnabled() {
+          return this._enabled;
+        }
+        isActive() {
+          return this._active;
+        }
+      }
+      class wr {
+        constructor() {
+          this.reset();
+        }
+        reset() {
+          this._active = false, delete this._firstTwoTouches;
+        }
+        touchstart(e3, t3, i3) {
+          this._firstTwoTouches || i3.length < 2 || (this._firstTwoTouches = [i3[0].identifier, i3[1].identifier], this._start([t3[0], t3[1]]));
+        }
+        touchmove(e3, t3, i3) {
+          if (!this._firstTwoTouches) return;
+          e3.preventDefault();
+          const [o3, a3] = this._firstTwoTouches, r3 = Tr(i3, t3, o3), s3 = Tr(i3, t3, a3);
+          if (!r3 || !s3) return;
+          const n3 = this._aroundCenter ? null : r3.add(s3).div(2);
+          return this._move([r3, s3], n3, e3);
+        }
+        touchend(e3, t3, i3) {
+          if (!this._firstTwoTouches) return;
+          const [o3, a3] = this._firstTwoTouches, r3 = Tr(i3, t3, o3), s3 = Tr(i3, t3, a3);
+          r3 && s3 || (this._active && h2.suppressClick(), this.reset());
+        }
+        touchcancel() {
+          this.reset();
+        }
+        enable(e3) {
+          this._enabled = true, this._aroundCenter = !!e3 && "center" === e3.around;
+        }
+        disable() {
+          this._enabled = false, this.reset();
+        }
+        isEnabled() {
+          return !!this._enabled;
+        }
+        isActive() {
+          return !!this._active;
+        }
+      }
+      function Tr(e3, t3, i3) {
+        for (let o3 = 0; o3 < e3.length; o3++) if (e3[o3].identifier === i3) return t3[o3];
+      }
+      function Pr(e3, t3) {
+        return Math.log(e3 / t3) / Math.LN2;
+      }
+      class Cr extends wr {
+        reset() {
+          super.reset(), delete this._distance, delete this._startDistance;
+        }
+        _start(e3) {
+          this._startDistance = this._distance = e3[0].dist(e3[1]);
+        }
+        _move(e3, t3) {
+          const i3 = this._distance;
+          if (this._distance = e3[0].dist(e3[1]), this._active || !(Math.abs(Pr(this._distance, this._startDistance)) < 0.1)) return this._active = true, { zoomDelta: Pr(this._distance, i3), pinchAround: t3 };
+        }
+      }
+      function Ir(e3, t3) {
+        return 180 * e3.angleWith(t3) / Math.PI;
+      }
+      class Mr extends wr {
+        reset() {
+          super.reset(), delete this._minDiameter, delete this._startVector, delete this._vector;
+        }
+        _start(e3) {
+          this._startVector = this._vector = e3[0].sub(e3[1]), this._minDiameter = e3[0].dist(e3[1]);
+        }
+        _move(e3, t3, i3) {
+          const o3 = this._vector;
+          if (this._vector = e3[0].sub(e3[1]), this._active || !this._isBelowThreshold(this._vector)) return this._active = true, { bearingDelta: Ir(this._vector, o3), pinchAround: t3 };
+        }
+        _isBelowThreshold(e3) {
+          this._minDiameter = Math.min(this._minDiameter, e3.mag());
+          const t3 = 25 / (Math.PI * this._minDiameter) * 360, i3 = Ir(e3, this._startVector);
+          return Math.abs(i3) < t3;
+        }
+      }
+      function Er(e3) {
+        return Math.abs(e3.y) > Math.abs(e3.x);
+      }
+      class Sr extends wr {
+        constructor(e3) {
+          super(), this._currentTouchCount = 0, this._map = e3;
+        }
+        reset() {
+          super.reset(), this._valid = void 0, delete this._firstMove, delete this._lastPoints;
+        }
+        touchstart(e3, t3, i3) {
+          super.touchstart(e3, t3, i3), this._currentTouchCount = i3.length;
+        }
+        _start(e3) {
+          this._lastPoints = e3, Er(e3[0].sub(e3[1])) && (this._valid = false);
+        }
+        _move(e3, t3, i3) {
+          if (this._map.cooperativeGestures.isEnabled() && this._currentTouchCount < 3) return;
+          const o3 = e3[0].sub(this._lastPoints[0]), a3 = e3[1].sub(this._lastPoints[1]);
+          return this._valid = this.gestureBeginsVertically(o3, a3, i3.timeStamp), this._valid ? (this._lastPoints = e3, this._active = true, { pitchDelta: (o3.y + a3.y) / 2 * -0.5 }) : void 0;
+        }
+        gestureBeginsVertically(e3, t3, i3) {
+          if (void 0 !== this._valid) return this._valid;
+          const o3 = e3.mag() >= 2, a3 = t3.mag() >= 2;
+          if (!o3 && !a3) return;
+          if (!o3 || !a3) return void 0 === this._firstMove && (this._firstMove = i3), i3 - this._firstMove < 100 && void 0;
+          const r3 = e3.y > 0 == t3.y > 0;
+          return Er(e3) && Er(t3) && r3;
+        }
+      }
+      const Rr = { panStep: 100, bearingStep: 15, pitchStep: 10 };
+      class zr {
+        constructor(e3) {
+          this._tr = new nr(e3);
+          const t3 = Rr;
+          this._panStep = t3.panStep, this._bearingStep = t3.bearingStep, this._pitchStep = t3.pitchStep, this._rotationDisabled = false;
+        }
+        reset() {
+          this._active = false;
+        }
+        keydown(e3) {
+          if (e3.altKey || e3.ctrlKey || e3.metaKey) return;
+          let i3 = 0, o3 = 0, a3 = 0, r3 = 0, s3 = 0;
+          switch (e3.keyCode) {
+            case 61:
+            case 107:
+            case 171:
+            case 187:
+              i3 = 1;
+              break;
+            case 189:
+            case 109:
+            case 173:
+              i3 = -1;
+              break;
+            case 37:
+              e3.shiftKey ? o3 = -1 : (e3.preventDefault(), r3 = -1);
+              break;
+            case 39:
+              e3.shiftKey ? o3 = 1 : (e3.preventDefault(), r3 = 1);
+              break;
+            case 38:
+              e3.shiftKey ? a3 = 1 : (e3.preventDefault(), s3 = -1);
+              break;
+            case 40:
+              e3.shiftKey ? a3 = -1 : (e3.preventDefault(), s3 = 1);
+              break;
+            default:
+              return;
+          }
+          return this._rotationDisabled && (o3 = 0, a3 = 0), { cameraAnimation: (n3) => {
+            const l3 = this._tr;
+            n3.easeTo({ duration: 300, easeId: "keyboardHandler", easing: Dr, zoom: i3 ? t2.cu(l3.zoom + i3 * (e3.shiftKey ? 2 : 1), n3.getZoomSnap()) : l3.zoom, bearing: l3.bearing + o3 * this._bearingStep, pitch: l3.pitch + a3 * this._pitchStep, offset: [-r3 * this._panStep, -s3 * this._panStep], center: l3.center }, { originalEvent: e3 });
+          } };
+        }
+        enable() {
+          this._enabled = true;
+        }
+        disable() {
+          this._enabled = false, this.reset();
+        }
+        isEnabled() {
+          return this._enabled;
+        }
+        isActive() {
+          return this._active;
+        }
+        disableRotation() {
+          this._rotationDisabled = true;
+        }
+        enableRotation() {
+          this._rotationDisabled = false;
+        }
+      }
+      function Dr(e3) {
+        return e3 * (2 - e3);
+      }
+      const Ar = 4.000244140625, Lr = 1 / 450;
+      class kr {
+        constructor(e3, t3) {
+          this._onTimeout = (e4) => {
+            this._type = "wheel", this._delta -= this._lastValue, this._active || this._start(e4);
+          }, this._map = e3, this._tr = new nr(e3), this._triggerRenderFrame = t3, this._delta = 0, this._defaultZoomRate = 0.01, this._wheelZoomRate = Lr;
+        }
+        setZoomRate(e3) {
+          this._defaultZoomRate = e3;
+        }
+        setWheelZoomRate(e3) {
+          this._wheelZoomRate = e3;
+        }
+        isEnabled() {
+          return !!this._enabled;
+        }
+        isActive() {
+          return !!this._active || void 0 !== this._finishTimeout;
+        }
+        isZooming() {
+          return !!this._zooming;
+        }
+        enable(e3) {
+          this.isEnabled() || (this._enabled = true, this._aroundCenter = !!e3 && "center" === e3.around);
+        }
+        disable() {
+          this.isEnabled() && (this._enabled = false);
+        }
+        _shouldBePrevented(e3) {
+          return !!this._map.cooperativeGestures.isEnabled() && !(e3.ctrlKey || this._map.cooperativeGestures.isBypassed(e3));
+        }
+        wheel(e3) {
+          if (!this.isEnabled()) return;
+          if (this._shouldBePrevented(e3)) return void this._map.cooperativeGestures.notifyGestureBlocked("wheel_zoom", e3);
+          let t3 = e3.deltaMode === WheelEvent.DOM_DELTA_LINE ? 40 * e3.deltaY : e3.deltaY;
+          const i3 = c2(), o3 = i3 - (this._lastWheelEventTime || 0);
+          this._lastWheelEventTime = i3, 0 !== t3 && t3 % Ar == 0 ? this._type = "wheel" : 0 !== t3 && Math.abs(t3) < 4 ? this._type = "trackpad" : o3 > 400 ? (this._type = null, this._lastValue = t3, this._timeout = setTimeout(this._onTimeout, 40, e3)) : this._type || (this._type = Math.abs(o3 * t3) < 200 ? "trackpad" : "wheel", this._timeout && (clearTimeout(this._timeout), this._timeout = null, t3 += this._lastValue)), e3.shiftKey && t3 && (t3 /= 4), this._type && (this._lastWheelEvent = e3, this._delta -= t3, this._active || this._start(e3)), e3.preventDefault();
+        }
+        _start(e3) {
+          if (!this._delta) return;
+          this._frameId && (this._frameId = null), this._active = true, this.isZooming() || (this._zooming = true), this._finishTimeout && (clearTimeout(this._finishTimeout), delete this._finishTimeout);
+          const i3 = h2.mousePos(this._map.getCanvas(), e3), o3 = this._tr;
+          this._aroundPoint = this._aroundCenter ? o3.transform.locationToScreenPoint(t2.V.convert(o3.center)) : i3, this._frameId || (this._frameId = true, this._triggerRenderFrame());
+        }
+        renderFrame() {
+          if (!this._frameId) return;
+          if (this._frameId = null, !this.isActive()) return;
+          const e3 = this._tr.transform;
+          if ("number" == typeof this._lastExpectedZoom) {
+            const t3 = e3.zoom - this._lastExpectedZoom;
+            "number" == typeof this._startZoom && (this._startZoom += t3), "number" == typeof this._targetZoom && (this._targetZoom += t3);
+          }
+          if (0 !== this._delta) {
+            const i4 = "wheel" === this._type && Math.abs(this._delta) > Ar ? this._wheelZoomRate : this._defaultZoomRate;
+            let o4 = 2 / (1 + Math.exp(-Math.abs(this._delta * i4)));
+            this._delta < 0 && 0 !== o4 && (o4 = 1 / o4);
+            const a4 = "number" != typeof this._targetZoom ? e3.scale : t2.an(this._targetZoom), r4 = e3.applyConstrain(e3.getCameraLngLat(), t2.aq(a4 * o4)).zoom, s4 = this._map.getZoomSnap();
+            if ("wheel" === this._type && s4 > 0) {
+              const i5 = t2.cu(e3.zoom, s4);
+              this._targetZoom = t2.cu(r4, s4, r4 - i5);
+            } else this._targetZoom = r4;
+            "wheel" === this._type && (this._startZoom = e3.zoom, this._easing = this._smoothOutEasing(200)), this._delta = 0;
+          }
+          const i3 = "number" != typeof this._targetZoom ? e3.zoom : this._targetZoom, o3 = this._startZoom, a3 = this._easing;
+          let r3, s3 = false;
+          if ("wheel" === this._type && o3 && a3) {
+            const e4 = c2() - this._lastWheelEventTime, n3 = Math.min((e4 + 5) / 200, 1), l3 = a3(n3);
+            r3 = t2.G.number(o3, i3, l3), n3 < 1 ? this._frameId || (this._frameId = true) : s3 = true;
+          } else r3 = i3, s3 = true;
+          return this._active = true, s3 && (this._active = false, this._finishTimeout = setTimeout(() => {
+            this._zooming = false, this._triggerRenderFrame(), delete this._targetZoom, delete this._lastExpectedZoom, delete this._finishTimeout;
+          }, 200)), this._lastExpectedZoom = r3, { noInertia: true, needsRenderFrame: !s3, zoomDelta: r3 - e3.zoom, around: this._aroundPoint, originalEvent: this._lastWheelEvent };
+        }
+        _smoothOutEasing(e3) {
+          let i3 = t2.cw;
+          if (this._prevEase) {
+            const e4 = this._prevEase, o3 = (c2() - e4.start) / e4.duration, a3 = e4.easing(o3 + 0.01) - e4.easing(o3), r3 = 0.27 / Math.sqrt(a3 * a3 + 1e-4) * 0.01, s3 = Math.sqrt(0.0729 - r3 * r3);
+            i3 = t2.ct(r3, s3, 0.25, 1);
+          }
+          return this._prevEase = { start: c2(), duration: e3, easing: i3 }, i3;
+        }
+        reset() {
+          this._active = false, this._zooming = false, delete this._targetZoom, delete this._lastExpectedZoom, this._finishTimeout && (clearTimeout(this._finishTimeout), delete this._finishTimeout);
+        }
+      }
+      class Fr {
+        constructor(e3, t3) {
+          this._clickZoom = e3, this._tapZoom = t3;
+        }
+        enable() {
+          this._clickZoom.enable(), this._tapZoom.enable();
+        }
+        disable() {
+          this._clickZoom.disable(), this._tapZoom.disable();
+        }
+        isEnabled() {
+          return this._clickZoom.isEnabled() && this._tapZoom.isEnabled();
+        }
+        isActive() {
+          return this._clickZoom.isActive() || this._tapZoom.isActive();
+        }
+      }
+      class Br {
+        constructor(e3) {
+          this._tr = new nr(e3), this.reset();
+        }
+        reset() {
+          this._active = false;
+        }
+        dblclick(e3, i3) {
+          return e3.preventDefault(), { cameraAnimation: (o3) => {
+            o3.easeTo({ duration: 300, zoom: t2.cu(this._tr.zoom + (e3.shiftKey ? -1 : 1), o3.getZoomSnap()), around: this._tr.unproject(i3) }, { originalEvent: e3 });
+          } };
+        }
+        enable() {
+          this._enabled = true;
+        }
+        disable() {
+          this._enabled = false, this.reset();
+        }
+        isEnabled() {
+          return this._enabled;
+        }
+        isActive() {
+          return this._active;
+        }
+      }
+      class Or {
+        constructor() {
+          this._tap = new ur({ numTouches: 1, numTaps: 1 }), this.reset();
+        }
+        reset() {
+          this._active = false, delete this._swipePoint, delete this._swipeTouch, delete this._tapTime, delete this._tapPoint, this._tap.reset();
+        }
+        touchstart(e3, t3, i3) {
+          if (!this._swipePoint) if (this._tapTime) {
+            const o3 = t3[0], a3 = e3.timeStamp - this._tapTime < 500, r3 = this._tapPoint.dist(o3) < 30;
+            a3 && r3 ? i3.length > 0 && (this._swipePoint = o3, this._swipeTouch = i3[0].identifier) : this.reset();
+          } else this._tap.touchstart(e3, t3, i3);
+        }
+        touchmove(e3, t3, i3) {
+          if (this._tapTime) {
+            if (this._swipePoint) {
+              if (i3[0].identifier !== this._swipeTouch) return;
+              const o3 = t3[0], a3 = o3.y - this._swipePoint.y;
+              return this._swipePoint = o3, e3.preventDefault(), this._active = true, { zoomDelta: a3 / 128 };
+            }
+          } else this._tap.touchmove(e3, t3, i3);
+        }
+        touchend(e3, t3, i3) {
+          if (this._tapTime) this._swipePoint && 0 === i3.length && this.reset();
+          else {
+            const o3 = this._tap.touchend(e3, t3, i3);
+            o3 && (this._tapTime = e3.timeStamp, this._tapPoint = o3);
+          }
+        }
+        touchcancel() {
+          this.reset();
+        }
+        enable() {
+          this._enabled = true;
+        }
+        disable() {
+          this._enabled = false, this.reset();
+        }
+        isEnabled() {
+          return this._enabled;
+        }
+        isActive() {
+          return this._active;
+        }
+      }
+      class jr {
+        constructor(e3, t3, i3) {
+          this._el = e3, this._mousePan = t3, this._touchPan = i3;
+        }
+        enable(e3) {
+          this._inertiaOptions = e3 || {}, this._mousePan.enable(), this._touchPan.enable(), this._el.classList.add("maplibregl-touch-drag-pan");
+        }
+        disable() {
+          this._mousePan.disable(), this._touchPan.disable(), this._el.classList.remove("maplibregl-touch-drag-pan");
+        }
+        isEnabled() {
+          return this._mousePan.isEnabled() && this._touchPan.isEnabled();
+        }
+        isActive() {
+          return this._mousePan.isActive() || this._touchPan.isActive();
+        }
+      }
+      class Nr {
+        constructor(e3, t3, i3, o3) {
+          this._pitchWithRotate = e3.pitchWithRotate, this._rollEnabled = e3.rollEnabled, this._mouseRotate = t3, this._mousePitch = i3, this._mouseRoll = o3;
+        }
+        enable() {
+          this._mouseRotate.enable(), this._pitchWithRotate && this._mousePitch.enable(), this._rollEnabled && this._mouseRoll.enable();
+        }
+        disable() {
+          this._mouseRotate.disable(), this._mousePitch.disable(), this._mouseRoll.disable();
+        }
+        isEnabled() {
+          return this._mouseRotate.isEnabled() && (!this._pitchWithRotate || this._mousePitch.isEnabled()) && (!this._rollEnabled || this._mouseRoll.isEnabled());
+        }
+        isActive() {
+          return this._mouseRotate.isActive() || this._mousePitch.isActive() || this._mouseRoll.isActive();
+        }
+      }
+      class Zr {
+        constructor(e3, t3, i3, o3) {
+          this._el = e3, this._touchZoom = t3, this._touchRotate = i3, this._tapDragZoom = o3, this._rotationDisabled = false, this._enabled = true;
+        }
+        enable(e3) {
+          this._touchZoom.enable(e3), this._rotationDisabled || this._touchRotate.enable(e3), this._tapDragZoom.enable(), this._el.classList.add("maplibregl-touch-zoom-rotate");
+        }
+        disable() {
+          this._touchZoom.disable(), this._touchRotate.disable(), this._tapDragZoom.disable(), this._el.classList.remove("maplibregl-touch-zoom-rotate");
+        }
+        isEnabled() {
+          return this._touchZoom.isEnabled() && (this._rotationDisabled || this._touchRotate.isEnabled()) && this._tapDragZoom.isEnabled();
+        }
+        isActive() {
+          return this._touchZoom.isActive() || this._touchRotate.isActive() || this._tapDragZoom.isActive();
+        }
+        disableRotation() {
+          this._rotationDisabled = true, this._touchRotate.disable();
+        }
+        enableRotation() {
+          this._rotationDisabled = false, this._touchZoom.isEnabled() && this._touchRotate.enable();
+        }
+      }
+      class Ur {
+        constructor(e3, t3) {
+          this._bypassKey = -1 !== navigator.userAgent.indexOf("Mac") ? "metaKey" : "ctrlKey", this._map = e3, this._options = t3, this._enabled = false;
+        }
+        isActive() {
+          return false;
+        }
+        reset() {
+        }
+        _setupUI() {
+          if (this._container) return;
+          const e3 = this._map.getCanvasContainer();
+          e3.classList.add("maplibregl-cooperative-gestures"), this._container = h2.create("div", "maplibregl-cooperative-gesture-screen", e3);
+          let t3 = this._map._getUIString("CooperativeGesturesHandler.WindowsHelpText");
+          "metaKey" === this._bypassKey && (t3 = this._map._getUIString("CooperativeGesturesHandler.MacHelpText"));
+          const i3 = this._map._getUIString("CooperativeGesturesHandler.MobileHelpText"), o3 = document.createElement("div");
+          o3.className = "maplibregl-desktop-message", o3.textContent = t3, this._container.appendChild(o3);
+          const a3 = document.createElement("div");
+          a3.className = "maplibregl-mobile-message", a3.textContent = i3, this._container.appendChild(a3), this._container.setAttribute("aria-hidden", "true");
+        }
+        _destroyUI() {
+          this._container && (this._container.remove(), this._map.getCanvasContainer().classList.remove("maplibregl-cooperative-gestures")), delete this._container;
+        }
+        enable() {
+          this._setupUI(), this._enabled = true;
+        }
+        disable() {
+          this._enabled = false, this._destroyUI();
+        }
+        isEnabled() {
+          return this._enabled;
+        }
+        isBypassed(e3) {
+          return e3[this._bypassKey];
+        }
+        notifyGestureBlocked(e3, i3) {
+          this._enabled && (this._map.fire(new t2.l("cooperativegestureprevented", { gestureType: e3, originalEvent: i3 })), this._container.classList.add("maplibregl-show"), setTimeout(() => {
+            this._container.classList.remove("maplibregl-show");
+          }, 100));
+        }
+      }
+      const Gr = (e3) => e3.zoom || e3.drag || e3.roll || e3.pitch || e3.rotate;
+      class Vr extends t2.l {
+      }
+      function Wr(e3) {
+        return e3.panDelta && e3.panDelta.mag() || e3.zoomDelta || e3.bearingDelta || e3.pitchDelta || e3.rollDelta;
+      }
+      class qr {
+        get _ownerDocument() {
+          var e3;
+          return (null === (e3 = this._el) || void 0 === e3 ? void 0 : e3.ownerDocument) || document;
+        }
+        get _ownerWindow() {
+          var e3, t3;
+          return (null === (t3 = null === (e3 = this._el) || void 0 === e3 ? void 0 : e3.ownerDocument) || void 0 === t3 ? void 0 : t3.defaultView) || window;
+        }
+        constructor(e3, i3) {
+          this.handleWindowEvent = (e4) => {
+            this.handleEvent(e4, `${e4.type}Window`);
+          }, this.handleEvent = (e4, i4) => {
+            if ("blur" === e4.type) return void this.stop(true);
+            this._updatingCamera = true;
+            const o4 = "renderFrame" === e4.type ? void 0 : e4, a3 = { needsRenderFrame: false }, r3 = {}, s3 = {};
+            for (const { handlerName: n4, handler: l4, allowed: c3 } of this._handlers) {
+              if (!l4.isEnabled()) continue;
+              let u3;
+              if (this._blockedByActive(s3, c3, n4)) l4.reset();
+              else if (l4[i4 || e4.type]) {
+                if (t2.cx(e4, i4 || e4.type)) {
+                  const t3 = h2.mousePos(this._map.getCanvas(), e4);
+                  u3 = l4[i4 || e4.type](e4, t3);
+                } else if (t2.cy(e4, i4 || e4.type)) {
+                  const t3 = this._getMapTouches(e4.touches), o5 = h2.touchPos(this._map.getCanvas(), t3);
+                  u3 = l4[i4 || e4.type](e4, o5, t3);
+                } else t2.cz(i4 || e4.type) || (u3 = l4[i4 || e4.type](e4));
+                this.mergeHandlerResult(a3, r3, u3, n4, o4), u3 && u3.needsRenderFrame && this._triggerRenderFrame();
+              }
+              (u3 || l4.isActive()) && (s3[n4] = l4);
+            }
+            const n3 = {};
+            for (const e5 in this._previousActiveHandlers) s3[e5] || (n3[e5] = o4);
+            this._previousActiveHandlers = s3, (Object.keys(n3).length || Wr(a3)) && (this._changes.push([a3, r3, n3]), this._triggerRenderFrame()), (Object.keys(s3).length || Wr(a3)) && this._map._stop(true), this._updatingCamera = false;
+            const { cameraAnimation: l3 } = a3;
+            l3 && (this._inertia.clear(), this._fireEvents({}, {}, true), this._changes = [], l3(this._map));
+          }, this._map = e3, this._el = this._map.getCanvasContainer(), this._handlers = [], this._handlersById = {}, this._changes = [], this._inertia = new Ja2(e3), this._bearingSnap = i3.bearingSnap, this._previousActiveHandlers = {}, this._eventsInProgress = {}, this._addDefaultHandlers(i3);
+          const o3 = this._el;
+          this._listeners = [[o3, "touchstart", { passive: true }], [o3, "touchmove", { passive: false }], [o3, "touchend", void 0], [o3, "touchcancel", void 0], [o3, "mousedown", void 0], [o3, "mousemove", void 0], [o3, "mouseup", void 0], [this._ownerDocument, "mousemove", { capture: true }], [this._ownerDocument, "mouseup", void 0], [o3, "mouseover", void 0], [o3, "mouseout", void 0], [o3, "dblclick", void 0], [o3, "click", void 0], [o3, "keydown", { capture: false }], [o3, "keyup", void 0], [o3, "wheel", { passive: false }], [o3, "contextmenu", void 0], [this._ownerWindow, "blur", void 0]];
+          for (const [e4, t3, i4] of this._listeners) e4.addEventListener(t3, e4 === this._ownerDocument ? this.handleWindowEvent : this.handleEvent, i4);
+        }
+        destroy() {
+          for (const [e3, t3, i3] of this._listeners) e3.removeEventListener(t3, e3 === this._ownerDocument ? this.handleWindowEvent : this.handleEvent, i3);
+        }
+        _addDefaultHandlers(e3) {
+          const i3 = this._map, o3 = i3.getCanvasContainer();
+          this._add("mapEvent", new rr(i3, e3));
+          const a3 = i3.boxZoom = new lr(i3, e3);
+          this._add("boxZoom", a3), e3.interactive && e3.boxZoom && a3.enable();
+          const r3 = i3.cooperativeGestures = new Ur(i3, e3.cooperativeGestures);
+          this._add("cooperativeGestures", r3), e3.cooperativeGestures && r3.enable();
+          const s3 = new dr(i3), n3 = new Br(i3);
+          i3.doubleClickZoom = new Fr(n3, s3), this._add("tapZoom", s3), this._add("clickZoom", n3), e3.interactive && e3.doubleClickZoom && i3.doubleClickZoom.enable();
+          const l3 = new Or();
+          this._add("tapDragZoom", l3);
+          const c3 = i3.touchPitch = new Sr(i3);
+          this._add("touchPitch", c3), e3.interactive && e3.touchPitch && i3.touchPitch.enable(e3.touchPitch);
+          const h3 = () => i3.project(i3.getCenter()), u3 = function({ enable: e4, clickTolerance: i4, aroundCenter: o4 = true, minPixelCenterThreshold: a4 = 100, rotateDegreesPerPixelMoved: r4 = 0.8 }, s4) {
+            const n4 = new gr({ checkCorrectEvent: (e5) => 0 === e5.button && e5.ctrlKey || 2 === e5.button && !e5.ctrlKey });
+            return new _r2({ clickTolerance: i4, move: (e5, i5) => {
+              const n5 = s4();
+              if (o4 && Math.abs(n5.y - e5.y) > a4) return { bearingDelta: t2.cv(new t2.P(e5.x, i5.y), i5, n5) };
+              let l4 = (i5.x - e5.x) * r4;
+              return o4 && i5.y < n5.y && (l4 = -l4), { bearingDelta: l4 };
+            }, moveStateManager: n4, enable: e4, assignEvents: br });
+          }(e3, h3), d3 = function({ enable: e4, clickTolerance: t3, pitchDegreesPerPixelMoved: i4 = -0.5 }) {
+            const o4 = new gr({ checkCorrectEvent: (e5) => 0 === e5.button && e5.ctrlKey || 2 === e5.button });
+            return new _r2({ clickTolerance: t3, move: (e5, t4) => ({ pitchDelta: (t4.y - e5.y) * i4 }), moveStateManager: o4, enable: e4, assignEvents: br });
+          }(e3), _3 = function({ enable: e4, clickTolerance: t3, rollDegreesPerPixelMoved: i4 = 0.3 }, o4) {
+            const a4 = new gr({ checkCorrectEvent: (e5) => 2 === e5.button && e5.ctrlKey });
+            return new _r2({ clickTolerance: t3, move: (e5, t4) => {
+              const a5 = o4();
+              let r4 = (t4.x - e5.x) * i4;
+              return t4.y < a5.y && (r4 = -r4), { rollDelta: r4 };
+            }, moveStateManager: a4, enable: e4, assignEvents: br });
+          }(e3, h3);
+          i3.dragRotate = new Nr(e3, u3, d3, _3), this._add("mouseRotate", u3, ["mousePitch"]), this._add("mousePitch", d3, ["mouseRotate", "mouseRoll"]), this._add("mouseRoll", _3, ["mousePitch"]), e3.interactive && e3.dragRotate && i3.dragRotate.enable();
+          const p3 = function({ enable: e4, clickTolerance: t3 }) {
+            const i4 = new gr({ checkCorrectEvent: (e5) => 0 === e5.button && !e5.ctrlKey });
+            return new _r2({ clickTolerance: t3, move: (e5, t4) => ({ around: t4, panDelta: t4.sub(e5) }), activateOnStart: true, moveStateManager: i4, enable: e4, assignEvents: br });
+          }(e3), m3 = new yr(e3, i3);
+          i3.dragPan = new jr(o3, p3, m3), this._add("mousePan", p3), this._add("touchPan", m3, ["touchZoom", "touchRotate"]), e3.interactive && e3.dragPan && i3.dragPan.enable(e3.dragPan);
+          const f3 = new Mr(), g3 = new Cr();
+          i3.touchZoomRotate = new Zr(o3, g3, f3, l3), this._add("touchRotate", f3, ["touchPan", "touchZoom"]), this._add("touchZoom", g3, ["touchPan", "touchRotate"]), e3.interactive && e3.touchZoomRotate && i3.touchZoomRotate.enable(e3.touchZoomRotate), this._add("blockableMapEvent", new sr(i3));
+          const v3 = i3.scrollZoom = new kr(i3, () => this._triggerRenderFrame());
+          this._add("scrollZoom", v3, ["mousePan"]), e3.interactive && e3.scrollZoom && i3.scrollZoom.enable(e3.scrollZoom);
+          const x3 = i3.keyboard = new zr(i3);
+          this._add("keyboard", x3), e3.interactive && e3.keyboard && i3.keyboard.enable();
+        }
+        _add(e3, t3, i3) {
+          this._handlers.push({ handlerName: e3, handler: t3, allowed: i3 }), this._handlersById[e3] = t3;
+        }
+        stop(e3) {
+          if (!this._updatingCamera) {
+            for (const { handler: e4 } of this._handlers) e4.reset();
+            this._inertia.clear(), this._fireEvents({}, {}, e3), this._changes = [];
+          }
+        }
+        isActive() {
+          for (const { handler: e3 } of this._handlers) if (e3.isActive()) return true;
+          return false;
+        }
+        isZooming() {
+          return !!this._eventsInProgress.zoom || this._map.scrollZoom.isZooming();
+        }
+        isRotating() {
+          return !!this._eventsInProgress.rotate;
+        }
+        isMoving() {
+          return Boolean(Gr(this._eventsInProgress)) || this.isZooming();
+        }
+        _blockedByActive(e3, t3, i3) {
+          for (const o3 in e3) if (o3 !== i3 && (!t3 || t3.indexOf(o3) < 0)) return true;
+          return false;
+        }
+        _getMapTouches(e3) {
+          const t3 = [];
+          for (const i3 of e3) this._el.contains(i3.target) && t3.push(i3);
+          return t3;
+        }
+        mergeHandlerResult(e3, i3, o3, a3, r3) {
+          if (!o3) return;
+          t2.e(e3, o3);
+          const s3 = { handlerName: a3, originalEvent: o3.originalEvent || r3 };
+          void 0 !== o3.zoomDelta && (i3.zoom = s3), void 0 !== o3.panDelta && (i3.drag = s3), void 0 !== o3.rollDelta && (i3.roll = s3), void 0 !== o3.pitchDelta && (i3.pitch = s3), void 0 !== o3.bearingDelta && (i3.rotate = s3);
+        }
+        _applyChanges() {
+          const e3 = {}, i3 = {}, o3 = {};
+          for (const [a3, r3, s3] of this._changes) a3.panDelta && (e3.panDelta = (e3.panDelta || new t2.P(0, 0))._add(a3.panDelta)), a3.zoomDelta && (e3.zoomDelta = (e3.zoomDelta || 0) + a3.zoomDelta), a3.bearingDelta && (e3.bearingDelta = (e3.bearingDelta || 0) + a3.bearingDelta), a3.pitchDelta && (e3.pitchDelta = (e3.pitchDelta || 0) + a3.pitchDelta), a3.rollDelta && (e3.rollDelta = (e3.rollDelta || 0) + a3.rollDelta), void 0 !== a3.around && (e3.around = a3.around), void 0 !== a3.pinchAround && (e3.pinchAround = a3.pinchAround), a3.noInertia && (e3.noInertia = a3.noInertia), t2.e(i3, r3), t2.e(o3, s3);
+          this._updateMapTransform(e3, i3, o3), this._changes = [];
+        }
+        _updateMapTransform(e3, t3, i3) {
+          const o3 = this._map, a3 = o3._getTransformForUpdate(), r3 = o3.terrain;
+          if (!(Wr(e3) || r3 && this._terrainMovement)) return this._fireEvents(t3, i3, true);
+          o3._stop(true);
+          let { panDelta: s3, zoomDelta: n3, bearingDelta: l3, pitchDelta: c3, rollDelta: h3, around: u3, pinchAround: d3 } = e3;
+          void 0 !== d3 && (u3 = d3), u3 = u3 || o3.transform.centerPoint, r3 && !a3.isPointOnMapSurface(u3) && (u3 = a3.centerPoint);
+          const _3 = { panDelta: s3, zoomDelta: n3, rollDelta: h3, pitchDelta: c3, bearingDelta: l3, around: u3 };
+          this._map.cameraHelper.useGlobeControls && !a3.isPointOnMapSurface(u3) && (u3 = a3.centerPoint);
+          const p3 = u3.distSqr(a3.centerPoint) < 0.01 ? a3.center : a3.screenPointToLocation(s3 ? u3.sub(s3) : u3);
+          this._handleMapControls({ terrain: r3, tr: a3, deltasForHelper: _3, preZoomAroundLoc: p3, combinedEventsInProgress: t3, panDelta: s3 }), o3._applyUpdatedTransform(a3), this._map._update(), e3.noInertia || this._inertia.record(e3), this._fireEvents(t3, i3, true);
+        }
+        _handleMapControls({ terrain: e3, tr: t3, deltasForHelper: i3, preZoomAroundLoc: o3, combinedEventsInProgress: a3, panDelta: r3 }) {
+          const s3 = this._map.cameraHelper;
+          if (s3.handleMapControlsRollPitchBearingZoom(i3, t3), e3) return s3.useGlobeControls ? (this._terrainMovement || !a3.drag && !a3.zoom || (this._terrainMovement = true, this._map._elevationFreeze = true), void s3.handleMapControlsPan(i3, t3, o3)) : this._terrainMovement || !a3.drag && !a3.zoom ? void (a3.drag && this._terrainMovement && r3 ? t3.setCenter(t3.screenPointToLocation(t3.centerPoint.sub(r3))) : s3.handleMapControlsPan(i3, t3, o3)) : (this._terrainMovement = true, this._map._elevationFreeze = true, void s3.handleMapControlsPan(i3, t3, o3));
+          s3.handleMapControlsPan(i3, t3, o3);
+        }
+        _fireEvents(e3, i3, o3) {
+          const a3 = Gr(this._eventsInProgress), r3 = Gr(e3), s3 = {};
+          for (const t3 in e3) {
+            const { originalEvent: i4 } = e3[t3];
+            this._eventsInProgress[t3] || (s3[`${t3}start`] = i4), this._eventsInProgress[t3] = e3[t3];
+          }
+          !a3 && r3 && this._fireEvent("movestart", r3.originalEvent);
+          for (const e4 in s3) this._fireEvent(e4, s3[e4]);
+          r3 && this._fireEvent("move", r3.originalEvent);
+          for (const t3 in e3) {
+            const { originalEvent: i4 } = e3[t3];
+            this._fireEvent(t3, i4);
+          }
+          const l3 = {};
+          let c3;
+          for (const e4 in this._eventsInProgress) {
+            const { handlerName: t3, originalEvent: o4 } = this._eventsInProgress[e4];
+            this._handlersById[t3].isActive() || (delete this._eventsInProgress[e4], c3 = i3[t3] || o4, l3[`${e4}end`] = c3);
+          }
+          for (const e4 in l3) this._fireEvent(e4, l3[e4]);
+          const h3 = Gr(this._eventsInProgress), u3 = (a3 || r3) && !h3;
+          if (u3 && this._terrainMovement) {
+            this._map._elevationFreeze = false, this._terrainMovement = false;
+            const e4 = this._map._getTransformForUpdate();
+            this._map.getCenterClampedToGround() && e4.recalculateZoomAndCenter(this._map.terrain), this._map._applyUpdatedTransform(e4);
+          }
+          if (o3 && u3) {
+            this._updatingCamera = true;
+            const e4 = this._inertia._onMoveEnd(this._map.dragPan._inertiaOptions), i4 = (e5) => 0 !== e5 && -this._bearingSnap < e5 && e5 < this._bearingSnap;
+            !e4 || !e4.essential && n2.prefersReducedMotion ? (this._map.fire(new t2.l("moveend", { originalEvent: c3 })), i4(this._map.getBearing()) && this._map.resetNorth()) : (i4(e4.bearing || this._map.getBearing()) && (e4.bearing = 0), e4.freezeElevation = true, this._map.easeTo(e4, { originalEvent: c3 })), this._updatingCamera = false;
+          }
+        }
+        _fireEvent(e3, i3) {
+          this._map.fire(new t2.l(e3, i3 ? { originalEvent: i3 } : {}));
+        }
+        _requestFrame() {
+          return this._map.triggerRepaint(), this._map._renderTaskQueue.add((e3) => {
+            delete this._frameId, this.handleEvent(new Vr("renderFrame", { timeStamp: e3 })), this._applyChanges();
+          });
+        }
+        _triggerRenderFrame() {
+          void 0 === this._frameId && (this._frameId = this._requestFrame());
+        }
+      }
+      class $r extends t2.E {
+        constructor(e3, t3, i3) {
+          super(), this._renderFrameCallback = () => {
+            const e4 = Math.min((c2() - this._easeStart) / this._easeOptions.duration, 1);
+            this._onEaseFrame(this._easeOptions.easing(e4)), e4 < 1 && this._easeFrameId ? this._easeFrameId = this._requestRenderFrame(this._renderFrameCallback) : this.stop();
+          }, this._moving = false, this._zooming = false, this.transform = e3, this._bearingSnap = i3.bearingSnap, this._zoomSnap = i3.zoomSnap, this.cameraHelper = t3, this.on("moveend", () => {
+            delete this._requestedCameraState;
+          });
+        }
+        migrateProjection(e3, t3) {
+          e3.apply(this.transform, true), this.transform = e3, this.cameraHelper = t3;
+        }
+        getCenter() {
+          return new t2.V(this.transform.center.lng, this.transform.center.lat);
+        }
+        setCenter(e3, t3) {
+          return this.jumpTo({ center: e3 }, t3);
+        }
+        getCenterElevation() {
+          return this.transform.elevation;
+        }
+        setCenterElevation(e3, t3) {
+          return this.jumpTo({ elevation: e3 }, t3), this;
+        }
+        getCenterClampedToGround() {
+          return this._centerClampedToGround;
+        }
+        setCenterClampedToGround(e3) {
+          this._centerClampedToGround = e3;
+        }
+        panBy(e3, i3, o3) {
+          return e3 = t2.P.convert(e3).mult(-1), this.panTo(this.transform.center, t2.e({ offset: e3 }, i3), o3);
+        }
+        panTo(e3, i3, o3) {
+          return this.easeTo(t2.e({ center: e3 }, i3), o3);
+        }
+        getZoom() {
+          return this.transform.zoom;
+        }
+        setZoom(e3, t3) {
+          return this.jumpTo({ zoom: e3 }, t3), this;
+        }
+        zoomTo(e3, i3, o3) {
+          return this.easeTo(t2.e({ zoom: e3 }, i3), o3);
+        }
+        zoomIn(e3, i3) {
+          return this.zoomTo(t2.cu(this.getZoom() + 1, this._zoomSnap), e3, i3), this;
+        }
+        zoomOut(e3, i3) {
+          return this.zoomTo(t2.cu(this.getZoom() - 1, this._zoomSnap), e3, i3), this;
+        }
+        getVerticalFieldOfView() {
+          return this.transform.fov;
+        }
+        setVerticalFieldOfView(e3, i3) {
+          return e3 != this.transform.fov && (this.transform.setFov(e3), this.fire(new t2.l("movestart", i3)).fire(new t2.l("move", i3)).fire(new t2.l("moveend", i3))), this;
+        }
+        getBearing() {
+          return this.transform.bearing;
+        }
+        setZoomSnap(e3) {
+          return this._zoomSnap = e3, this;
+        }
+        getZoomSnap() {
+          return this._zoomSnap;
+        }
+        setBearing(e3, t3) {
+          return this.jumpTo({ bearing: e3 }, t3), this;
+        }
+        getPadding() {
+          return this.transform.padding;
+        }
+        setPadding(e3, t3) {
+          return this.jumpTo({ padding: e3 }, t3), this;
+        }
+        rotateTo(e3, i3, o3) {
+          return this.easeTo(t2.e({ bearing: e3 }, i3), o3);
+        }
+        resetNorth(e3, i3) {
+          return this.rotateTo(0, t2.e({ duration: 1e3 }, e3), i3), this;
+        }
+        resetNorthPitch(e3, i3) {
+          return this.easeTo(t2.e({ bearing: 0, pitch: 0, roll: 0, duration: 1e3 }, e3), i3), this;
+        }
+        snapToNorth(e3, t3) {
+          return Math.abs(this.getBearing()) < this._bearingSnap ? this.resetNorth(e3, t3) : this;
+        }
+        getPitch() {
+          return this.transform.pitch;
+        }
+        setPitch(e3, t3) {
+          return this.jumpTo({ pitch: e3 }, t3), this;
+        }
+        getRoll() {
+          return this.transform.roll;
+        }
+        setRoll(e3, t3) {
+          return this.jumpTo({ roll: e3 }, t3), this;
+        }
+        cameraForBounds(e3, t3) {
+          e3 = Z2.convert(e3).adjustAntiMeridian();
+          const i3 = t3 && t3.bearing || 0;
+          return this._cameraForBoxAndBearing(e3.getNorthWest(), e3.getSouthEast(), i3, t3);
+        }
+        _cameraForBoxAndBearing(e3, i3, o3, a3) {
+          const r3 = { top: 0, bottom: 0, right: 0, left: 0 };
+          if ("number" == typeof (a3 = t2.e({ padding: r3, offset: [0, 0], maxZoom: this.transform.maxZoom }, a3)).padding) {
+            const e4 = a3.padding;
+            a3.padding = { top: e4, bottom: e4, right: e4, left: e4 };
+          }
+          const s3 = t2.e(r3, a3.padding);
+          a3.padding = s3;
+          const n3 = this.transform, l3 = new Z2(e3, i3);
+          return this.cameraHelper.cameraForBoxAndBearing(a3, s3, l3, o3, n3);
+        }
+        fitBounds(e3, t3, i3) {
+          return this._fitInternal(this.cameraForBounds(e3, t3), t3, i3);
+        }
+        fitScreenCoordinates(e3, i3, o3, a3, r3) {
+          return this._fitInternal(this._cameraForBoxAndBearing(this.transform.screenPointToLocation(t2.P.convert(e3)), this.transform.screenPointToLocation(t2.P.convert(i3)), o3, a3), a3, r3);
+        }
+        _fitInternal(e3, i3, o3) {
+          return e3 ? (delete (i3 = t2.e(e3, i3)).padding, i3.linear ? this.easeTo(i3, o3) : this.flyTo(i3, o3)) : this;
+        }
+        jumpTo(e3, i3) {
+          this.stop();
+          const o3 = this._getTransformForUpdate();
+          let a3 = false, r3 = false, s3 = false;
+          const n3 = o3.zoom;
+          this.terrain && o3.setElevation(this.terrain.getElevationForLngLatZoom(e3.center ? t2.V.convert(e3.center) : o3.center, e3.zoom || o3.tileZoom)), this.cameraHelper.handleJumpToCenterZoom(o3, e3);
+          const l3 = o3.zoom !== n3;
+          return "elevation" in e3 && o3.elevation !== +e3.elevation && o3.setElevation(+e3.elevation), "bearing" in e3 && o3.bearing !== +e3.bearing && (a3 = true, o3.setBearing(+e3.bearing)), "pitch" in e3 && o3.pitch !== +e3.pitch && (r3 = true, o3.setPitch(+e3.pitch)), "roll" in e3 && o3.roll !== +e3.roll && (s3 = true, o3.setRoll(+e3.roll)), null == e3.padding || o3.isPaddingEqual(e3.padding) || o3.setPadding(e3.padding), this._applyUpdatedTransform(o3), this.fire(new t2.l("movestart", i3)).fire(new t2.l("move", i3)), l3 && this.fire(new t2.l("zoomstart", i3)).fire(new t2.l("zoom", i3)).fire(new t2.l("zoomend", i3)), a3 && this.fire(new t2.l("rotatestart", i3)).fire(new t2.l("rotate", i3)).fire(new t2.l("rotateend", i3)), r3 && this.fire(new t2.l("pitchstart", i3)).fire(new t2.l("pitch", i3)).fire(new t2.l("pitchend", i3)), s3 && this.fire(new t2.l("rollstart", i3)).fire(new t2.l("roll", i3)).fire(new t2.l("rollend", i3)), this.fire(new t2.l("moveend", i3));
+        }
+        calculateCameraOptionsFromTo(e3, i3, o3, a3 = 0) {
+          const r3 = t2.a6.fromLngLat(e3, i3), s3 = t2.a6.fromLngLat(o3, a3), n3 = s3.x - r3.x, l3 = s3.y - r3.y, c3 = s3.z - r3.z, h3 = Math.hypot(n3, l3, c3);
+          if (0 === h3) throw new Error("Can't calculate camera options with same From and To");
+          const u3 = Math.hypot(n3, l3), d3 = t2.aq(this.transform.cameraToCenterDistance / h3 / this.transform.tileSize), _3 = 180 * Math.atan2(n3, -l3) / Math.PI;
+          let p3 = 180 * Math.acos(u3 / h3) / Math.PI;
+          return p3 = c3 < 0 ? 90 - p3 : 90 + p3, { center: s3.toLngLat(), elevation: a3, zoom: d3, pitch: p3, bearing: _3 };
+        }
+        calculateCameraOptionsFromCameraLngLatAltRotation(e3, t3, i3, o3, a3) {
+          const r3 = this.transform.calculateCenterFromCameraLngLatAlt(e3, t3, i3, o3);
+          return { center: r3.center, elevation: r3.elevation, zoom: r3.zoom, bearing: i3, pitch: o3, roll: a3 };
+        }
+        easeTo(e3, i3) {
+          this._stop(false, e3.easeId), (false === (e3 = t2.e({ offset: [0, 0], duration: 500, easing: t2.cw }, e3)).animate || !e3.essential && n2.prefersReducedMotion) && (e3.duration = 0);
+          const o3 = this._getTransformForUpdate(), a3 = this.getBearing(), r3 = o3.pitch, s3 = o3.roll, l3 = "bearing" in e3 ? this._normalizeBearing(e3.bearing, a3) : a3, c3 = "pitch" in e3 ? +e3.pitch : r3, h3 = "roll" in e3 ? this._normalizeBearing(e3.roll, s3) : s3, u3 = "padding" in e3 ? e3.padding : o3.padding, d3 = t2.P.convert(e3.offset);
+          let _3, p3;
+          e3.around && (_3 = t2.V.convert(e3.around), p3 = o3.locationToScreenPoint(_3));
+          const m3 = { moving: this._moving, zooming: this._zooming, rotating: this._rotating, pitching: this._pitching, rolling: this._rolling }, f3 = this.cameraHelper.handleEaseTo(o3, { bearing: l3, pitch: c3, roll: h3, padding: u3, around: _3, aroundPoint: p3, offsetAsPoint: d3, offset: e3.offset, zoom: e3.zoom, center: e3.center });
+          return this._rotating = this._rotating || a3 !== l3, this._pitching = this._pitching || c3 !== r3, this._rolling = this._rolling || h3 !== s3, this._padding = !o3.isPaddingEqual(u3), this._zooming = this._zooming || f3.isZooming, this._easeId = e3.easeId, this._prepareEase(i3, e3.noMoveStart, m3), this.terrain && this._prepareElevation(f3.elevationCenter), this._ease((t3) => {
+            f3.easeFunc(t3), this.terrain && !e3.freezeElevation && this._updateElevation(t3), this._applyUpdatedTransform(o3), this._fireMoveEvents(i3);
+          }, (t3) => {
+            this.terrain && e3.freezeElevation && this._finalizeElevation(), this._afterEase(i3, t3);
+          }, e3), this;
+        }
+        _prepareEase(e3, i3, o3 = {}) {
+          this._moving = true, i3 || o3.moving || this.fire(new t2.l("movestart", e3)), this._zooming && !o3.zooming && this.fire(new t2.l("zoomstart", e3)), this._rotating && !o3.rotating && this.fire(new t2.l("rotatestart", e3)), this._pitching && !o3.pitching && this.fire(new t2.l("pitchstart", e3)), this._rolling && !o3.rolling && this.fire(new t2.l("rollstart", e3));
+        }
+        _prepareElevation(e3) {
+          this._elevationCenter = e3, this._elevationStart = this.transform.elevation, this._elevationTarget = this.terrain.getElevationForLngLatZoom(e3, this.transform.tileZoom), this._elevationFreeze = true;
+        }
+        _updateElevation(e3) {
+          void 0 !== this._elevationStart && void 0 !== this._elevationCenter || this._prepareElevation(this.transform.center), this.transform.setMinElevationForCurrentTile(this.terrain.getMinTileElevationForLngLatZoom(this._elevationCenter, this.transform.tileZoom));
+          const i3 = this.terrain.getElevationForLngLatZoom(this._elevationCenter, this.transform.tileZoom);
+          if (e3 < 1 && i3 !== this._elevationTarget) {
+            const t3 = this._elevationTarget - this._elevationStart;
+            this._elevationStart += e3 * (t3 - (i3 - (t3 * e3 + this._elevationStart)) / (1 - e3)), this._elevationTarget = i3;
+          }
+          this.transform.setElevation(t2.G.number(this._elevationStart, this._elevationTarget, e3));
+        }
+        _finalizeElevation() {
+          this._elevationFreeze = false, this.getCenterClampedToGround() && this.transform.recalculateZoomAndCenter(this.terrain);
+        }
+        _getTransformForUpdate() {
+          return this.transformCameraUpdate || this.terrain ? (this._requestedCameraState || (this._requestedCameraState = this.transform.clone()), this._requestedCameraState) : this.transform;
+        }
+        _elevateCameraIfInsideTerrain(e3) {
+          if (!this.terrain && e3.elevation >= 0 && e3.pitch <= 90) return {};
+          const t3 = e3.getCameraLngLat(), i3 = e3.getCameraAltitude(), o3 = this.terrain ? this.terrain.getElevationForLngLatZoom(t3, e3.zoom) : 0;
+          if (i3 < o3) {
+            const i4 = this.calculateCameraOptionsFromTo(t3, o3, e3.center, e3.elevation);
+            return { pitch: i4.pitch, zoom: i4.zoom };
+          }
+          return {};
+        }
+        _applyUpdatedTransform(e3) {
+          const t3 = [];
+          if (t3.push((e4) => this._elevateCameraIfInsideTerrain(e4)), this.transformCameraUpdate && t3.push((e4) => this.transformCameraUpdate(e4)), !t3.length) return;
+          const i3 = e3.clone();
+          for (const e4 of t3) {
+            const t4 = i3.clone(), { center: o3, zoom: a3, roll: r3, pitch: s3, bearing: n3, elevation: l3 } = e4(t4);
+            o3 && t4.setCenter(o3), void 0 !== l3 && t4.setElevation(l3), void 0 !== a3 && t4.setZoom(a3), void 0 !== r3 && t4.setRoll(r3), void 0 !== s3 && t4.setPitch(s3), void 0 !== n3 && t4.setBearing(n3), i3.apply(t4, false);
+          }
+          this.transform.apply(i3, false);
+        }
+        _fireMoveEvents(e3) {
+          this.fire(new t2.l("move", e3)), this._zooming && this.fire(new t2.l("zoom", e3)), this._rotating && this.fire(new t2.l("rotate", e3)), this._pitching && this.fire(new t2.l("pitch", e3)), this._rolling && this.fire(new t2.l("roll", e3));
+        }
+        _afterEase(e3, i3) {
+          if (this._easeId && i3 && this._easeId === i3) return;
+          delete this._easeId;
+          const o3 = this._zooming, a3 = this._rotating, r3 = this._pitching, s3 = this._rolling;
+          this._moving = false, this._zooming = false, this._rotating = false, this._pitching = false, this._rolling = false, this._padding = false, o3 && this.fire(new t2.l("zoomend", e3)), a3 && this.fire(new t2.l("rotateend", e3)), r3 && this.fire(new t2.l("pitchend", e3)), s3 && this.fire(new t2.l("rollend", e3)), this.fire(new t2.l("moveend", e3));
+        }
+        flyTo(e3, i3) {
+          if (!e3.essential && n2.prefersReducedMotion) {
+            const o4 = t2.U(e3, ["center", "zoom", "bearing", "pitch", "roll", "elevation", "padding"]);
+            return this.jumpTo(o4, i3);
+          }
+          this.stop(), e3 = t2.e({ offset: [0, 0], speed: 1.2, curve: 1.42, easing: t2.cw }, e3);
+          const o3 = this._getTransformForUpdate(), a3 = o3.bearing, r3 = o3.pitch, s3 = o3.roll, l3 = o3.padding, c3 = "bearing" in e3 ? this._normalizeBearing(e3.bearing, a3) : a3, h3 = "pitch" in e3 ? +e3.pitch : r3, u3 = "roll" in e3 ? this._normalizeBearing(e3.roll, s3) : s3, d3 = "padding" in e3 ? e3.padding : o3.padding, _3 = t2.P.convert(e3.offset);
+          let p3 = o3.centerPoint.add(_3);
+          const m3 = o3.screenPointToLocation(p3), f3 = this.cameraHelper.handleFlyTo(o3, { bearing: c3, pitch: h3, roll: u3, padding: d3, locationAtOffset: m3, offsetAsPoint: _3, center: e3.center, minZoom: e3.minZoom, zoom: e3.zoom });
+          let g3 = e3.curve;
+          const v3 = Math.max(o3.width, o3.height), x3 = v3 / f3.scaleOfZoom, b3 = f3.pixelPathLength;
+          "number" == typeof f3.scaleOfMinZoom && (g3 = Math.sqrt(v3 / f3.scaleOfMinZoom / b3 * 2));
+          const y3 = g3 * g3;
+          function w3(e4) {
+            const t3 = (x3 * x3 - v3 * v3 + (e4 ? -1 : 1) * y3 * y3 * b3 * b3) / (2 * (e4 ? x3 : v3) * y3 * b3);
+            return Math.log(Math.sqrt(t3 * t3 + 1) - t3);
+          }
+          function T3(e4) {
+            return (Math.exp(e4) - Math.exp(-e4)) / 2;
+          }
+          function P3(e4) {
+            return (Math.exp(e4) + Math.exp(-e4)) / 2;
+          }
+          const C3 = w3(false);
+          let I3 = function(e4) {
+            return P3(C3) / P3(C3 + g3 * e4);
+          }, M3 = function(e4) {
+            return v3 * ((P3(C3) * (T3(t3 = C3 + g3 * e4) / P3(t3)) - T3(C3)) / y3) / b3;
+            var t3;
+          }, E3 = (w3(true) - C3) / g3;
+          if (Math.abs(b3) < 2e-6 || !isFinite(E3)) {
+            if (Math.abs(v3 - x3) < 1e-6) return this.easeTo(e3, i3);
+            const t3 = x3 < v3 ? -1 : 1;
+            E3 = Math.abs(Math.log(x3 / v3)) / g3, M3 = () => 0, I3 = (e4) => Math.exp(t3 * g3 * e4);
+          }
+          return e3.duration = "duration" in e3 ? +e3.duration : 1e3 * E3 / ("screenSpeed" in e3 ? +e3.screenSpeed / g3 : +e3.speed), e3.maxDuration && e3.duration > e3.maxDuration && (e3.duration = 0), this._zooming = true, this._rotating = a3 !== c3, this._pitching = h3 !== r3, this._rolling = u3 !== s3, this._padding = !o3.isPaddingEqual(d3), this._prepareEase(i3, false), this.terrain && this._prepareElevation(f3.targetCenter), this._ease((n3) => {
+            const m4 = n3 * E3, g4 = 1 / I3(m4), v4 = M3(m4);
+            this._rotating && o3.setBearing(t2.G.number(a3, c3, n3)), this._pitching && o3.setPitch(t2.G.number(r3, h3, n3)), this._rolling && o3.setRoll(t2.G.number(s3, u3, n3)), this._padding && (o3.interpolatePadding(l3, d3, n3), p3 = o3.centerPoint.add(_3)), f3.easeFunc(n3, g4, v4, p3), this.terrain && !e3.freezeElevation && this._updateElevation(n3), this._applyUpdatedTransform(o3), this._fireMoveEvents(i3);
+          }, () => {
+            this.terrain && e3.freezeElevation && this._finalizeElevation(), this._afterEase(i3);
+          }, e3), this;
+        }
+        isEasing() {
+          return !!this._easeFrameId;
+        }
+        stop() {
+          return this._stop();
+        }
+        _stop(e3, t3) {
+          var i3;
+          if (this._easeFrameId && (this._cancelRenderFrame(this._easeFrameId), delete this._easeFrameId, delete this._onEaseFrame), this._onEaseEnd) {
+            const e4 = this._onEaseEnd;
+            delete this._onEaseEnd, e4.call(this, t3);
+          }
+          return e3 || null === (i3 = this.handlers) || void 0 === i3 || i3.stop(false), this;
+        }
+        _ease(e3, t3, i3) {
+          false === i3.animate || 0 === i3.duration ? (e3(1), t3()) : (this._easeStart = c2(), this._easeOptions = i3, this._onEaseFrame = e3, this._onEaseEnd = t3, this._easeFrameId = this._requestRenderFrame(this._renderFrameCallback));
+        }
+        _normalizeBearing(e3, i3) {
+          e3 = t2.W(e3, -180, 180);
+          const o3 = Math.abs(e3 - i3);
+          return Math.abs(e3 - 360 - i3) < o3 && (e3 -= 360), Math.abs(e3 + 360 - i3) < o3 && (e3 += 360), e3;
+        }
+        queryTerrainElevation(e3) {
+          return this.terrain ? this.terrain.getElevationForLngLat(t2.V.convert(e3), this.transform) : null;
+        }
+      }
+      const Hr = { compact: true, customAttribution: '<a href="https://maplibre.org/" target="_blank">MapLibre</a>' };
+      class Xr {
+        constructor(e3 = Hr) {
+          this._toggleAttribution = () => {
+            this._container.classList.contains("maplibregl-compact") && (this._container.classList.contains("maplibregl-compact-show") ? (this._container.setAttribute("open", ""), this._container.classList.remove("maplibregl-compact-show")) : (this._container.classList.add("maplibregl-compact-show"), this._container.removeAttribute("open")));
+          }, this._updateData = (e4) => {
+            !e4 || "metadata" !== e4.sourceDataType && "visibility" !== e4.sourceDataType && "style" !== e4.dataType && "terrain" !== e4.type || this._updateAttributions();
+          }, this._updateCompact = () => {
+            this._map.getCanvasContainer().offsetWidth <= 640 || this._compact ? false === this._compact ? this._container.setAttribute("open", "") : this._container.classList.contains("maplibregl-compact") || this._container.classList.contains("maplibregl-attrib-empty") || (this._container.setAttribute("open", ""), this._container.classList.add("maplibregl-compact", "maplibregl-compact-show")) : (this._container.setAttribute("open", ""), this._container.classList.contains("maplibregl-compact") && this._container.classList.remove("maplibregl-compact", "maplibregl-compact-show"));
+          }, this._updateCompactMinimize = () => {
+            this._container.classList.contains("maplibregl-compact") && this._container.classList.contains("maplibregl-compact-show") && this._container.classList.remove("maplibregl-compact-show");
+          }, this.options = e3;
+        }
+        getDefaultPosition() {
+          return "bottom-right";
+        }
+        onAdd(e3) {
+          return this._map = e3, this._compact = this.options.compact, this._container = h2.create("details", "maplibregl-ctrl maplibregl-ctrl-attrib"), this._compactButton = h2.create("summary", "maplibregl-ctrl-attrib-button", this._container), this._compactButton.addEventListener("click", this._toggleAttribution), this._setElementTitle(this._compactButton, "ToggleAttribution"), this._innerContainer = h2.create("div", "maplibregl-ctrl-attrib-inner", this._container), this._updateAttributions(), this._updateCompact(), this._map.on("styledata", this._updateData), this._map.on("sourcedata", this._updateData), this._map.on("terrain", this._updateData), this._map.on("resize", this._updateCompact), this._map.on("drag", this._updateCompactMinimize), this._container;
+        }
+        onRemove() {
+          this._container.remove(), this._map.off("styledata", this._updateData), this._map.off("sourcedata", this._updateData), this._map.off("terrain", this._updateData), this._map.off("resize", this._updateCompact), this._map.off("drag", this._updateCompactMinimize), this._map = void 0, this._compact = void 0, this._attribHTML = void 0;
+        }
+        _setElementTitle(e3, t3) {
+          const i3 = this._map._getUIString(`AttributionControl.${t3}`);
+          e3.title = i3, e3.setAttribute("aria-label", i3);
+        }
+        _updateAttributions() {
+          if (!this._map.style) return;
+          let e3 = [];
+          if (this.options.customAttribution && (Array.isArray(this.options.customAttribution) ? e3 = e3.concat(this.options.customAttribution.map((e4) => "string" != typeof e4 ? "" : e4)) : "string" == typeof this.options.customAttribution && e3.push(this.options.customAttribution)), this._map.style.stylesheet) {
+            const e4 = this._map.style.stylesheet;
+            this.styleOwner = e4.owner, this.styleId = e4.id;
+          }
+          const t3 = this._map.style.tileManagers;
+          for (const i4 in t3) {
+            const o3 = t3[i4];
+            if (o3.used || o3.usedForTerrain) {
+              const t4 = o3.getSource();
+              t4.attribution && e3.indexOf(t4.attribution) < 0 && e3.push(t4.attribution);
+            }
+          }
+          e3 = e3.filter((e4) => String(e4).trim()), e3.sort((e4, t4) => e4.length - t4.length), e3 = e3.filter((t4, i4) => {
+            for (let o3 = i4 + 1; o3 < e3.length; o3++) if (e3[o3].indexOf(t4) >= 0) return false;
+            return true;
+          });
+          const i3 = e3.join(" | ");
+          i3 !== this._attribHTML && (this._attribHTML = i3, e3.length ? (this._innerContainer.innerHTML = h2.sanitize(i3), this._container.classList.remove("maplibregl-attrib-empty")) : this._container.classList.add("maplibregl-attrib-empty"), this._updateCompact(), this._editLink = null);
+        }
+      }
+      class Yr {
+        constructor(e3 = {}) {
+          this._updateCompact = () => {
+            const e4 = this._container.children;
+            if (e4.length) {
+              const t3 = e4[0];
+              this._map.getCanvasContainer().offsetWidth <= 640 || this._compact ? false !== this._compact && t3.classList.add("maplibregl-compact") : t3.classList.remove("maplibregl-compact");
+            }
+          }, this.options = e3;
+        }
+        getDefaultPosition() {
+          return "bottom-left";
+        }
+        onAdd(e3) {
+          this._map = e3, this._compact = this.options && this.options.compact, this._container = h2.create("div", "maplibregl-ctrl");
+          const t3 = h2.create("a", "maplibregl-ctrl-logo");
+          return t3.target = "_blank", t3.rel = "noopener nofollow", t3.href = "https://maplibre.org/", t3.setAttribute("aria-label", this._map._getUIString("LogoControl.Title")), t3.setAttribute("rel", "noopener nofollow"), this._container.appendChild(t3), this._container.style.display = "block", this._map.on("resize", this._updateCompact), this._updateCompact(), this._container;
+        }
+        onRemove() {
+          this._container.remove(), this._map.off("resize", this._updateCompact), this._map = void 0, this._compact = void 0;
+        }
+      }
+      class Kr {
+        constructor() {
+          this._queue = [], this._id = 0, this._cleared = false, this._currentlyRunning = false;
+        }
+        add(e3) {
+          const t3 = ++this._id;
+          return this._queue.push({ callback: e3, id: t3, cancelled: false }), t3;
+        }
+        remove(e3) {
+          const t3 = this._currentlyRunning, i3 = t3 ? this._queue.concat(t3) : this._queue;
+          for (const t4 of i3) if (t4.id === e3) return void (t4.cancelled = true);
+        }
+        run(e3 = 0) {
+          if (this._currentlyRunning) throw new Error("Attempting to run(), but is already running.");
+          const t3 = this._currentlyRunning = this._queue;
+          this._queue = [];
+          for (const i3 of t3) if (!i3.cancelled && (i3.callback(e3), this._cleared)) break;
+          this._cleared = false, this._currentlyRunning = false;
+        }
+        clear() {
+          this._currentlyRunning && (this._cleared = true), this._queue = [];
+        }
+      }
+      var Qr = t2.aS([{ name: "a_pos3d", type: "Int16", components: 3 }]);
+      class Jr extends t2.E {
+        constructor(e3) {
+          super(), this._lastTilesetChange = c2(), this.tileManager = e3, this._tiles = {}, this._renderableTilesKeys = [], this._sourceTileCache = {}, this.minzoom = 0, this.maxzoom = 22, this.deltaZoom = 1, this.tileSize = e3._source.tileSize * 2 ** this.deltaZoom, e3.usedForTerrain = true, e3.tileSize = this.tileSize;
+        }
+        destruct() {
+          this.tileManager.usedForTerrain = false, this.tileManager.tileSize = null;
+        }
+        getSource() {
+          return this.tileManager._source;
+        }
+        update(e3, i3) {
+          this.tileManager.update(e3, i3), this._renderableTilesKeys = [];
+          const o3 = {};
+          for (const a3 of Pe2(e3, { tileSize: this.tileSize, minzoom: this.minzoom, maxzoom: this.maxzoom, reparseOverscaled: false, terrain: i3, calculateTileZoom: this.tileManager._source.calculateTileZoom })) o3[a3.key] = true, this._renderableTilesKeys.push(a3.key), this._tiles[a3.key] || (a3.terrainRttPosMatrix32f = new Float64Array(16), t2.c5(a3.terrainRttPosMatrix32f, 0, t2.a5, t2.a5, 0, 0, 1), this._tiles[a3.key] = new he2(a3, this.tileSize), this._lastTilesetChange = c2());
+          for (const e4 in this._tiles) o3[e4] || delete this._tiles[e4];
+        }
+        freeRtt(e3) {
+          for (const t3 in this._tiles) {
+            const i3 = this._tiles[t3];
+            (!e3 || i3.tileID.equals(e3) || i3.tileID.isChildOf(e3) || e3.isChildOf(i3.tileID)) && (i3.rtt = []);
+          }
+        }
+        getRenderableTiles() {
+          return this._renderableTilesKeys.map((e3) => this.getTileByID(e3));
+        }
+        getTileByID(e3) {
+          return this._tiles[e3];
+        }
+        getTerrainCoords(e3, t3) {
+          return t3 ? this._getTerrainCoordsForTileRanges(e3, t3) : this._getTerrainCoordsForRegularTile(e3);
+        }
+        _getTerrainCoordsForRegularTile(e3) {
+          const i3 = {};
+          for (const o3 of this._renderableTilesKeys) {
+            const a3 = this._tiles[o3].tileID, r3 = e3.clone(), s3 = t2.bi();
+            if (a3.canonical.equals(e3.canonical)) t2.c5(s3, 0, t2.a5, t2.a5, 0, 0, 1);
+            else if (a3.canonical.isChildOf(e3.canonical)) {
+              const i4 = a3.canonical.z - e3.canonical.z, o4 = a3.canonical.x - (a3.canonical.x >> i4 << i4), r4 = a3.canonical.y - (a3.canonical.y >> i4 << i4), n3 = t2.a5 >> i4;
+              t2.c5(s3, 0, n3, n3, 0, 0, 1), t2.O(s3, s3, [-o4 * n3, -r4 * n3, 0]);
+            } else {
+              if (!e3.canonical.isChildOf(a3.canonical)) continue;
+              {
+                const i4 = e3.canonical.z - a3.canonical.z, o4 = e3.canonical.x - (e3.canonical.x >> i4 << i4), r4 = e3.canonical.y - (e3.canonical.y >> i4 << i4), n3 = t2.a5 >> i4;
+                t2.c5(s3, 0, t2.a5, t2.a5, 0, 0, 1), t2.O(s3, s3, [o4 * n3, r4 * n3, 0]), t2.Q(s3, s3, [1 / 2 ** i4, 1 / 2 ** i4, 0]);
+              }
+            }
+            r3.terrainRttPosMatrix32f = new Float32Array(s3), i3[o3] = r3;
+          }
+          return i3;
+        }
+        _getTerrainCoordsForTileRanges(e3, i3) {
+          const o3 = {};
+          for (const a3 of this._renderableTilesKeys) {
+            const r3 = this._tiles[a3].tileID;
+            if (!this._isWithinTileRanges(r3, i3)) continue;
+            const s3 = e3.clone(), n3 = t2.bi();
+            if (r3.canonical.z === e3.canonical.z) {
+              const i4 = e3.canonical.x - r3.canonical.x + e3.wrap * (1 << e3.canonical.z), o4 = e3.canonical.y - r3.canonical.y;
+              t2.c5(n3, 0, t2.a5, t2.a5, 0, 0, 1), t2.O(n3, n3, [i4 * t2.a5, o4 * t2.a5, 0]);
+            } else if (r3.canonical.z > e3.canonical.z) {
+              const i4 = r3.canonical.z - e3.canonical.z, o4 = r3.canonical.x - (r3.canonical.x >> i4 << i4) + e3.wrap * (1 << r3.canonical.z), a4 = r3.canonical.y - (r3.canonical.y >> i4 << i4), s4 = e3.canonical.x - (r3.canonical.x >> i4), l3 = e3.canonical.y - (r3.canonical.y >> i4), c3 = t2.a5 >> i4;
+              t2.c5(n3, 0, c3, c3, 0, 0, 1), t2.O(n3, n3, [-o4 * c3 + s4 * t2.a5, -a4 * c3 + l3 * t2.a5, 0]);
+            } else {
+              const i4 = e3.canonical.z - r3.canonical.z, o4 = e3.canonical.x - (e3.canonical.x >> i4 << i4) + e3.wrap * (1 << e3.canonical.z), a4 = e3.canonical.y - (e3.canonical.y >> i4 << i4), s4 = (e3.canonical.x >> i4) - r3.canonical.x, l3 = (e3.canonical.y >> i4) - r3.canonical.y, c3 = t2.a5 << i4;
+              t2.c5(n3, 0, c3, c3, 0, 0, 1), t2.O(n3, n3, [o4 * t2.a5 + s4 * c3, a4 * t2.a5 + l3 * c3, 0]);
+            }
+            s3.terrainRttPosMatrix32f = new Float32Array(n3), o3[a3] = s3;
+          }
+          return o3;
+        }
+        getSourceTile(e3, t3) {
+          const i3 = this.tileManager._source;
+          let o3 = e3.overscaledZ - this.deltaZoom;
+          if (o3 > i3.maxzoom && (o3 = i3.maxzoom), o3 < i3.minzoom) return;
+          this._sourceTileCache[e3.key] || (this._sourceTileCache[e3.key] = e3.scaledTo(o3).key);
+          let a3 = this.findTileInCaches(this._sourceTileCache[e3.key]);
+          if (!(null == a3 ? void 0 : a3.dem) && t3) for (; o3 >= i3.minzoom && !(null == a3 ? void 0 : a3.dem); ) a3 = this.findTileInCaches(e3.scaledTo(o3--).key);
+          return a3;
+        }
+        findTileInCaches(e3) {
+          let t3 = this.tileManager.getTileByID(e3);
+          return t3 || (t3 = this.tileManager._outOfViewCache.getByKey(e3), t3);
+        }
+        anyTilesAfterTime(e3 = Date.now()) {
+          return this._lastTilesetChange >= e3;
+        }
+        _isWithinTileRanges(e3, t3) {
+          const i3 = t3[e3.canonical.z];
+          return !!i3 && (e3.wrap > i3.minWrap || e3.wrap < i3.maxWrap || e3.canonical.x >= i3.minTileXWrapped && e3.canonical.x <= i3.maxTileXWrapped && e3.canonical.y >= i3.minTileY && e3.canonical.y <= i3.maxTileY);
+        }
+      }
+      class es {
+        constructor(e3, t3, i3) {
+          this._meshCache = {}, this.painter = e3, this.tileManager = new Jr(t3), this.options = i3, this.exaggeration = "number" == typeof i3.exaggeration ? i3.exaggeration : 1, this.qualityFactor = 2, this.meshSize = 128, this._demMatrixCache = {}, this.coordsIndex = [], this._coordsTextureSize = 1024;
+        }
+        destroy() {
+          this._fbo && (this._fbo.destroy(), this._fbo = null), this._fboCoordsTexture && (this._fboCoordsTexture.destroy(), this._fboCoordsTexture = null), this._fboDepthTexture && (this._fboDepthTexture.destroy(), this._fboDepthTexture = null), this._emptyDemTexture && (this._emptyDemTexture.destroy(), this._emptyDemTexture = null), this._emptyDepthTexture && (this._emptyDepthTexture.destroy(), this._emptyDepthTexture = null), this._coordsTexture && (this._coordsTexture.destroy(), this._coordsTexture = null);
+          for (const e3 in this._meshCache) this._meshCache[e3].destroy();
+          this._meshCache = {}, this.tileManager.destruct();
+        }
+        getDEMElevation(e3, i3, o3, a3 = t2.a5) {
+          var r3;
+          const s3 = e3.normalizeCoordinates(i3, o3, a3);
+          if (!s3) return 0;
+          const n3 = this.getTerrainData(s3.tileID), l3 = null === (r3 = n3.tile) || void 0 === r3 ? void 0 : r3.dem;
+          if (!l3) return 0;
+          const c3 = t2.cA([], [s3.x / a3 * t2.a5, s3.y / a3 * t2.a5], n3.u_terrain_matrix), h3 = [c3[0] * l3.dim, c3[1] * l3.dim], u3 = Math.floor(h3[0]), d3 = Math.floor(h3[1]), _3 = h3[0] - u3, p3 = h3[1] - d3;
+          return l3.get(u3, d3) * (1 - _3) * (1 - p3) + l3.get(u3 + 1, d3) * _3 * (1 - p3) + l3.get(u3, d3 + 1) * (1 - _3) * p3 + l3.get(u3 + 1, d3 + 1) * _3 * p3;
+        }
+        getElevationForLngLatZoom(e3, i3) {
+          if (!t2.cB(i3, e3.wrap())) return 0;
+          const { tileID: o3, mercatorX: a3, mercatorY: r3 } = this._getOverscaledTileIDFromLngLatZoom(e3, i3);
+          return this.getElevation(o3, a3 % t2.a5, r3 % t2.a5, t2.a5);
+        }
+        getElevationForLngLat(e3, t3) {
+          const i3 = Pe2(t3, { maxzoom: this.tileManager.maxzoom, minzoom: this.tileManager.minzoom, tileSize: 512, terrain: this });
+          let o3 = 0;
+          for (const e4 of i3) e4.canonical.z > o3 && (o3 = Math.min(e4.canonical.z, this.tileManager.maxzoom));
+          return this.getElevationForLngLatZoom(e3, o3);
+        }
+        getElevation(e3, i3, o3, a3 = t2.a5) {
+          return this.getDEMElevation(e3, i3, o3, a3) * this.exaggeration;
+        }
+        getTerrainData(e3) {
+          if (!this._emptyDemTexture) {
+            const e4 = this.painter.context, i4 = new t2.R({ width: 1, height: 1 }, new Uint8Array(4));
+            this._emptyDepthTexture = new t2.T(e4, i4, e4.gl.RGBA, { premultiply: false }), this._emptyDemUnpack = [0, 0, 0, 0], this._emptyDemTexture = new t2.T(e4, new t2.R({ width: 1, height: 1 }), e4.gl.RGBA, { premultiply: false }), this._emptyDemTexture.bind(e4.gl.NEAREST, e4.gl.CLAMP_TO_EDGE), this._emptyDemMatrix = t2.ao([]);
+          }
+          const i3 = this.tileManager.getSourceTile(e3, true);
+          if (i3 && i3.dem && (!i3.demTexture || i3.needsTerrainPrepare)) {
+            const e4 = this.painter.context;
+            i3.demTexture = this.painter.getTileTexture(i3.dem.stride), i3.demTexture ? i3.demTexture.update(i3.dem.getPixels(), { premultiply: false }) : i3.demTexture = new t2.T(e4, i3.dem.getPixels(), e4.gl.RGBA, { premultiply: false }), i3.demTexture.bind(e4.gl.NEAREST, e4.gl.CLAMP_TO_EDGE), i3.needsTerrainPrepare = false;
+          }
+          const o3 = i3 && i3.toString() + i3.tileID.key + e3.key;
+          if (o3 && !this._demMatrixCache[o3]) {
+            const o4 = this.tileManager.getSource().maxzoom;
+            let a3 = e3.canonical.z - i3.tileID.canonical.z;
+            e3.overscaledZ > e3.canonical.z && (e3.canonical.z >= o4 ? a3 = e3.canonical.z - o4 : t2.w("cannot calculate elevation if elevation maxzoom > source.maxzoom"));
+            const r3 = e3.canonical.x - (e3.canonical.x >> a3 << a3), s3 = e3.canonical.y - (e3.canonical.y >> a3 << a3), n3 = t2.cC(new Float64Array(16), [1 / (t2.a5 << a3), 1 / (t2.a5 << a3), 0]);
+            t2.O(n3, n3, [r3 * t2.a5, s3 * t2.a5, 0]), this._demMatrixCache[e3.key] = { matrix: n3, coord: e3 };
+          }
+          return { u_depth: 2, u_terrain: 3, u_terrain_dim: i3 && i3.dem && i3.dem.dim || 1, u_terrain_matrix: o3 ? this._demMatrixCache[e3.key].matrix : this._emptyDemMatrix, u_terrain_unpack: i3 && i3.dem && i3.dem.getUnpackVector() || this._emptyDemUnpack, u_terrain_exaggeration: this.exaggeration, texture: (i3 && i3.demTexture || this._emptyDemTexture).texture, depthTexture: (this._fboDepthTexture || this._emptyDepthTexture).texture, tile: i3 };
+        }
+        getFramebuffer(e3) {
+          const i3 = this.painter, o3 = i3.width / devicePixelRatio, a3 = i3.height / devicePixelRatio;
+          return !this._fbo || this._fbo.width === o3 && this._fbo.height === a3 || (this._fbo.destroy(), this._fboCoordsTexture.destroy(), this._fboDepthTexture.destroy(), delete this._fbo, delete this._fboDepthTexture, delete this._fboCoordsTexture), this._fboCoordsTexture || (this._fboCoordsTexture = new t2.T(i3.context, { width: o3, height: a3, data: null }, i3.context.gl.RGBA, { premultiply: false }), this._fboCoordsTexture.bind(i3.context.gl.NEAREST, i3.context.gl.CLAMP_TO_EDGE)), this._fboDepthTexture || (this._fboDepthTexture = new t2.T(i3.context, { width: o3, height: a3, data: null }, i3.context.gl.RGBA, { premultiply: false }), this._fboDepthTexture.bind(i3.context.gl.NEAREST, i3.context.gl.CLAMP_TO_EDGE)), this._fbo || (this._fbo = i3.context.createFramebuffer(o3, a3, true, false), this._fbo.depthAttachment.set(i3.context.createRenderbuffer(i3.context.gl.DEPTH_COMPONENT16, o3, a3))), this._fbo.colorAttachment.set("coords" === e3 ? this._fboCoordsTexture.texture : this._fboDepthTexture.texture), this._fbo;
+        }
+        getCoordsTexture() {
+          const e3 = this.painter.context;
+          if (this._coordsTexture) return this._coordsTexture;
+          const i3 = new Uint8Array(this._coordsTextureSize * this._coordsTextureSize * 4);
+          for (let e4 = 0, t3 = 0; e4 < this._coordsTextureSize; e4++) for (let o4 = 0; o4 < this._coordsTextureSize; o4++, t3 += 4) i3[t3 + 0] = 255 & o4, i3[t3 + 1] = 255 & e4, i3[t3 + 2] = o4 >> 8 << 4 | e4 >> 8, i3[t3 + 3] = 0;
+          const o3 = new t2.R({ width: this._coordsTextureSize, height: this._coordsTextureSize }, new Uint8Array(i3.buffer)), a3 = new t2.T(e3, o3, e3.gl.RGBA, { premultiply: false });
+          return a3.bind(e3.gl.NEAREST, e3.gl.CLAMP_TO_EDGE), this._coordsTexture = a3, a3;
+        }
+        pointCoordinate(e3) {
+          this.painter.maybeDrawDepthAndCoords(true);
+          const i3 = new Uint8Array(4), o3 = this.painter.context, a3 = o3.gl, r3 = Math.round(e3.x * this.painter.pixelRatio / devicePixelRatio), s3 = Math.round(e3.y * this.painter.pixelRatio / devicePixelRatio), n3 = Math.round(this.painter.height / devicePixelRatio);
+          o3.bindFramebuffer.set(this.getFramebuffer("coords").framebuffer), a3.readPixels(r3, n3 - s3 - 1, 1, 1, a3.RGBA, a3.UNSIGNED_BYTE, i3), o3.bindFramebuffer.set(null);
+          const l3 = i3[0] + (i3[2] >> 4 << 8), c3 = i3[1] + ((15 & i3[2]) << 8), h3 = this.coordsIndex[255 - i3[3]], u3 = h3 && this.tileManager.getTileByID(h3);
+          if (!u3) return null;
+          const d3 = this._coordsTextureSize, _3 = (1 << u3.tileID.canonical.z) * d3;
+          return new t2.a6((u3.tileID.canonical.x * d3 + l3) / _3 + u3.tileID.wrap, (u3.tileID.canonical.y * d3 + c3) / _3, this.getElevation(u3.tileID, l3, c3, d3));
+        }
+        depthAtPoint(e3) {
+          const t3 = new Uint8Array(4), i3 = this.painter.context, o3 = i3.gl;
+          return i3.bindFramebuffer.set(this.getFramebuffer("depth").framebuffer), o3.readPixels(e3.x, this.painter.height / devicePixelRatio - e3.y - 1, 1, 1, o3.RGBA, o3.UNSIGNED_BYTE, t3), i3.bindFramebuffer.set(null), (t3[0] / 16777216 + t3[1] / 65536 + t3[2] / 256 + t3[3]) / 256;
+        }
+        getTerrainMesh(e3) {
+          var i3;
+          const o3 = (null === (i3 = this.painter.style.projection) || void 0 === i3 ? void 0 : i3.transitionState) > 0, a3 = o3 && 0 === e3.canonical.y, r3 = o3 && e3.canonical.y === (1 << e3.canonical.z) - 1, s3 = `m_${a3 ? "n" : ""}_${r3 ? "s" : ""}`;
+          if (this._meshCache[s3]) return this._meshCache[s3];
+          const n3 = this.painter.context, l3 = new t2.cD(), c3 = new t2.aW(), h3 = this.meshSize, u3 = t2.a5 / h3, d3 = h3 * h3;
+          for (let e4 = 0; e4 <= h3; e4++) for (let t3 = 0; t3 <= h3; t3++) l3.emplaceBack(t3 * u3, e4 * u3, 0);
+          for (let e4 = 0; e4 < d3; e4 += h3 + 1) for (let t3 = 0; t3 < h3; t3++) c3.emplaceBack(t3 + e4, h3 + t3 + e4 + 1, h3 + t3 + e4 + 2), c3.emplaceBack(t3 + e4, h3 + t3 + e4 + 2, t3 + e4 + 1);
+          const _3 = l3.length, p3 = _3 + (h3 + 1), m3 = (h3 + 1) * h3, f3 = a3 ? t2.bp : 0, g3 = a3 ? 0 : 1, v3 = r3 ? t2.bq : t2.a5, x3 = r3 ? 0 : 1;
+          for (let e4 = 0; e4 <= h3; e4++) l3.emplaceBack(e4 * u3, f3, g3);
+          for (let e4 = 0; e4 <= h3; e4++) l3.emplaceBack(e4 * u3, v3, x3);
+          for (let e4 = 0; e4 < h3; e4++) c3.emplaceBack(m3 + e4, p3 + e4, p3 + e4 + 1), c3.emplaceBack(m3 + e4, p3 + e4 + 1, m3 + e4 + 1), c3.emplaceBack(0 + e4, _3 + e4 + 1, _3 + e4), c3.emplaceBack(0 + e4, 0 + e4 + 1, _3 + e4 + 1);
+          const b3 = l3.length, y3 = b3 + 2 * (h3 + 1);
+          for (const e4 of [0, 1]) for (let i4 = 0; i4 <= h3; i4++) for (const o4 of [0, 1]) l3.emplaceBack(e4 * t2.a5, i4 * u3, o4);
+          for (let e4 = 0; e4 < 2 * h3; e4 += 2) c3.emplaceBack(b3 + e4, b3 + e4 + 1, b3 + e4 + 3), c3.emplaceBack(b3 + e4, b3 + e4 + 3, b3 + e4 + 2), c3.emplaceBack(y3 + e4, y3 + e4 + 3, y3 + e4 + 1), c3.emplaceBack(y3 + e4, y3 + e4 + 2, y3 + e4 + 3);
+          const w3 = new At(n3.createVertexBuffer(l3, Qr.members), n3.createIndexBuffer(c3), t2.aV.simpleSegment(0, 0, l3.length, c3.length));
+          return this._meshCache[s3] = w3, w3;
+        }
+        getMeshFrameDelta(e3) {
+          return 2 * Math.PI * t2.bC / Math.pow(2, Math.max(e3, 0)) / 5;
+        }
+        getMinTileElevationForLngLatZoom(e3, i3) {
+          var o3;
+          if (!t2.cB(i3, e3.wrap())) return 0;
+          const { tileID: a3 } = this._getOverscaledTileIDFromLngLatZoom(e3, i3);
+          return null !== (o3 = this.getMinMaxElevation(a3).minElevation) && void 0 !== o3 ? o3 : 0;
+        }
+        getMinMaxElevation(e3) {
+          const t3 = this.getTerrainData(e3).tile, i3 = { minElevation: null, maxElevation: null };
+          return t3 && t3.dem && (i3.minElevation = t3.dem.min * this.exaggeration, i3.maxElevation = t3.dem.max * this.exaggeration), i3;
+        }
+        _getOverscaledTileIDFromLngLatZoom(e3, i3) {
+          const o3 = t2.a6.fromLngLat(e3.wrap()), a3 = (1 << i3) * t2.a5, r3 = o3.x * a3, s3 = o3.y * a3, n3 = Math.floor(r3 / t2.a5), l3 = Math.floor(s3 / t2.a5);
+          return { tileID: new t2.a2(i3, 0, i3, n3, l3), mercatorX: r3, mercatorY: s3 };
+        }
+      }
+      class ts {
+        constructor(e3, t3, i3) {
+          this._context = e3, this._size = t3, this._tileSize = i3, this._objects = [], this._recentlyUsed = [], this._stamp = 0;
+        }
+        destruct() {
+          for (const e3 of this._objects) e3.texture.destroy(), e3.fbo.destroy();
+        }
+        _createObject(e3) {
+          const i3 = this._context.createFramebuffer(this._tileSize, this._tileSize, true, true), o3 = new t2.T(this._context, { width: this._tileSize, height: this._tileSize, data: null }, this._context.gl.RGBA);
+          return o3.bind(this._context.gl.LINEAR, this._context.gl.CLAMP_TO_EDGE), this._context.extTextureFilterAnisotropic && this._context.gl.texParameterf(this._context.gl.TEXTURE_2D, this._context.extTextureFilterAnisotropic.TEXTURE_MAX_ANISOTROPY_EXT, this._context.extTextureFilterAnisotropicMax), i3.depthAttachment.set(this._context.createRenderbuffer(this._context.gl.DEPTH_STENCIL, this._tileSize, this._tileSize)), i3.colorAttachment.set(o3.texture), { id: e3, fbo: i3, texture: o3, stamp: -1, inUse: false };
+        }
+        getObjectForId(e3) {
+          return this._objects[e3];
+        }
+        useObject(e3) {
+          e3.inUse = true, this._recentlyUsed = this._recentlyUsed.filter((t3) => e3.id !== t3), this._recentlyUsed.push(e3.id);
+        }
+        stampObject(e3) {
+          e3.stamp = ++this._stamp;
+        }
+        getOrCreateFreeObject() {
+          for (const e4 of this._recentlyUsed) if (!this._objects[e4].inUse) return this._objects[e4];
+          if (this._objects.length >= this._size) throw new Error("No free RenderPool available, call freeAllObjects() required!");
+          const e3 = this._createObject(this._objects.length);
+          return this._objects.push(e3), e3;
+        }
+        freeObject(e3) {
+          e3.inUse = false;
+        }
+        freeAllObjects() {
+          for (const e3 of this._objects) this.freeObject(e3);
+        }
+        isFull() {
+          return !(this._objects.length < this._size) && false === this._objects.some((e3) => !e3.inUse);
+        }
+      }
+      const is = { background: true, fill: true, line: true, raster: true, hillshade: true, "color-relief": true };
+      class os {
+        constructor(e3, t3) {
+          this.painter = e3, this.terrain = t3, this.pool = new ts(e3.context, 30, t3.tileManager.tileSize * t3.qualityFactor);
+        }
+        destruct() {
+          this.pool.destruct();
+        }
+        getTexture(e3) {
+          return this.pool.getObjectForId(e3.rtt[this._stacks.length - 1].id).texture;
+        }
+        prepareForRender(e3, t3) {
+          var i3, o3;
+          this._stacks = [], this._prevType = null, this._rttTiles = [], this._renderableTiles = this.terrain.tileManager.getRenderableTiles(), this._renderableLayerIds = e3._order.filter((i4) => !e3._layers[i4].isHidden(t3)), this._coordsAscending = {};
+          for (const t4 in e3.tileManagers) {
+            this._coordsAscending[t4] = {};
+            const i4 = e3.tileManagers[t4].getVisibleCoordinates(), o4 = e3.tileManagers[t4].getSource(), a3 = o4 instanceof J2 ? o4.terrainTileRanges : null;
+            for (const e4 of i4) {
+              const i5 = this.terrain.tileManager.getTerrainCoords(e4, a3);
+              for (const e5 in i5) this._coordsAscending[t4][e5] || (this._coordsAscending[t4][e5] = []), this._coordsAscending[t4][e5].push(i5[e5]);
+            }
+          }
+          this._rttFingerprints = {};
+          for (const t4 of e3._order) {
+            const a3 = e3._layers[t4], r3 = a3.source;
+            if (is[a3.type] && !this._rttFingerprints[r3]) {
+              this._rttFingerprints[r3] = {};
+              const t5 = null !== (o3 = null === (i3 = e3.tileManagers[r3]) || void 0 === i3 ? void 0 : i3.getState().revision) && void 0 !== o3 ? o3 : 0;
+              for (const e4 in this._coordsAscending[r3]) this._rttFingerprints[r3][e4] = `${this._coordsAscending[r3][e4].map((e5) => e5.key).sort().join()}#${t5}`;
+            }
+          }
+          for (const e4 of this._renderableTiles) for (const t4 in this._rttFingerprints) {
+            const i4 = this._rttFingerprints[t4][e4.tileID.key];
+            i4 && i4 !== e4.rttFingerprint[t4] && (e4.rtt = []);
+          }
+        }
+        renderLayer(e3, i3) {
+          if (e3.isHidden(this.painter.transform.zoom)) return false;
+          const o3 = Object.assign(Object.assign({}, i3), { isRenderingToTexture: true }), a3 = e3.type, r3 = this.painter, s3 = this._renderableLayerIds[this._renderableLayerIds.length - 1] === e3.id;
+          if (is[a3] && (this._prevType && is[this._prevType] || this._stacks.push([]), this._prevType = a3, this._stacks[this._stacks.length - 1].push(e3.id), !s3)) return true;
+          if (is[this._prevType] || is[a3] && s3) {
+            this._prevType = a3;
+            const e4 = this._stacks.length - 1, i4 = this._stacks[e4] || [];
+            for (const a4 of this._renderableTiles) {
+              if (this.pool.isFull() && (Ua2(this.painter, this.terrain, this._rttTiles, o3), this._rttTiles = [], this.pool.freeAllObjects()), this._rttTiles.push(a4), a4.rtt[e4]) {
+                const t3 = this.pool.getObjectForId(a4.rtt[e4].id);
+                if (t3.stamp === a4.rtt[e4].stamp) {
+                  this.pool.useObject(t3);
+                  continue;
+                }
+              }
+              const s4 = this.pool.getOrCreateFreeObject();
+              this.pool.useObject(s4), this.pool.stampObject(s4), a4.rtt[e4] = { id: s4.id, stamp: s4.stamp }, r3.context.bindFramebuffer.set(s4.fbo.framebuffer), r3.context.clear({ color: t2.bn.transparent, stencil: 0 }), r3.currentStencilSource = void 0;
+              for (let e5 = 0; e5 < i4.length; e5++) {
+                const t3 = r3.style._layers[i4[e5]], n3 = t3.source ? this._coordsAscending[t3.source][a4.tileID.key] : [a4.tileID];
+                r3.context.viewport.set([0, 0, s4.fbo.width, s4.fbo.height]), r3._renderTileClippingMasks(t3, n3, true), r3.renderLayer(r3, r3.style.tileManagers[t3.source], t3, n3, o3), t3.source && (a4.rttFingerprint[t3.source] = this._rttFingerprints[t3.source][a4.tileID.key]);
+              }
+            }
+            return Ua2(this.painter, this.terrain, this._rttTiles, o3), this._rttTiles = [], this.pool.freeAllObjects(), is[a3];
+          }
+          return false;
+        }
+      }
+      const as = { "AttributionControl.ToggleAttribution": "Toggle attribution", "AttributionControl.MapFeedback": "Map feedback", "FullscreenControl.Enter": "Enter fullscreen", "FullscreenControl.Exit": "Exit fullscreen", "GeolocateControl.FindMyLocation": "Find my location", "GeolocateControl.LocationNotAvailable": "Location not available", "LogoControl.Title": "MapLibre logo", "Map.Title": "Map", "Marker.Title": "Map marker", "NavigationControl.ResetBearing": "Drag to rotate map, click to reset north", "NavigationControl.ZoomIn": "Zoom in", "NavigationControl.ZoomOut": "Zoom out", "Popup.Close": "Close popup", "ScaleControl.Feet": "ft", "ScaleControl.Meters": "m", "ScaleControl.Kilometers": "km", "ScaleControl.Miles": "mi", "ScaleControl.NauticalMiles": "nm", "GlobeControl.Enable": "Enable globe", "GlobeControl.Disable": "Disable globe", "TerrainControl.Enable": "Enable terrain", "TerrainControl.Disable": "Disable terrain", "CooperativeGesturesHandler.WindowsHelpText": "Use Ctrl + scroll to zoom the map", "CooperativeGesturesHandler.MacHelpText": "Use ⌘ + scroll to zoom the map", "CooperativeGesturesHandler.MobileHelpText": "Use two fingers to move the map" }, rs = i2, ss = { hash: false, interactive: true, bearingSnap: 7, zoomSnap: 0, attributionControl: Hr, maplibreLogo: false, refreshExpiredTiles: true, canvasContextAttributes: { antialias: false, preserveDrawingBuffer: false, powerPreference: "high-performance", failIfMajorPerformanceCaveat: false, desynchronized: false, contextType: void 0 }, scrollZoom: true, minZoom: -2, maxZoom: 22, minPitch: 0, maxPitch: 60, boxZoom: true, dragRotate: true, dragPan: true, keyboard: true, doubleClickZoom: true, touchZoomRotate: true, touchPitch: true, cooperativeGestures: false, trackResize: true, center: [0, 0], elevation: 0, zoom: 0, bearing: 0, pitch: 0, roll: 0, renderWorldCopies: true, maxTileCacheSize: null, maxTileCacheZoomLevels: t2.c.MAX_TILE_CACHE_ZOOM_LEVELS, transformRequest: null, transformCameraUpdate: null, transformConstrain: null, fadeDuration: 300, crossSourceCollisions: true, clickTolerance: 3, localIdeographFontFamily: "sans-serif", pitchWithRotate: true, rollEnabled: false, reduceMotion: void 0, validateStyle: true, maxCanvasSize: [4096, 4096], cancelPendingTileRequestsWhileZooming: true, centerClampedToGround: true, experimentalZoomLevelsToOverscale: void 0, anisotropicFilterPitch: 20 };
+      let ns = class extends $r {
+        get _ownerWindow() {
+          var e3, t3;
+          return (null === (t3 = null === (e3 = this._container) || void 0 === e3 ? void 0 : e3.ownerDocument) || void 0 === t3 ? void 0 : t3.defaultView) || window;
+        }
+        constructor(e3) {
+          var i3, o3;
+          t2.cE.mark(t2.cF.create);
+          const a3 = Object.assign(Object.assign(Object.assign({}, ss), e3), { canvasContextAttributes: Object.assign(Object.assign({}, ss.canvasContextAttributes), e3.canvasContextAttributes) });
+          if (null != a3.minZoom && null != a3.maxZoom && a3.minZoom > a3.maxZoom) throw new Error("maxZoom must be greater than or equal to minZoom");
+          if (null != a3.minPitch && null != a3.maxPitch && a3.minPitch > a3.maxPitch) throw new Error("maxPitch must be greater than or equal to minPitch");
+          if (null != a3.minPitch && a3.minPitch < 0) throw new Error("minPitch must be greater than or equal to 0");
+          if (null != a3.maxPitch && a3.maxPitch > 180) throw new Error("maxPitch must be less than or equal to 180");
+          const r3 = new Wt(), s3 = new Xt();
+          void 0 !== a3.minZoom && r3.setMinZoom(a3.minZoom), void 0 !== a3.maxZoom && r3.setMaxZoom(a3.maxZoom), void 0 !== a3.minPitch && r3.setMinPitch(a3.minPitch), void 0 !== a3.maxPitch && r3.setMaxPitch(a3.maxPitch), void 0 !== a3.renderWorldCopies && r3.setRenderWorldCopies(a3.renderWorldCopies), null !== a3.transformConstrain && r3.setConstrainOverride(a3.transformConstrain), super(r3, s3, { bearingSnap: a3.bearingSnap, zoomSnap: a3.zoomSnap }), this._idleTriggered = false, this._crossFadingFactor = 1, this._renderTaskQueue = new Kr(), this._controls = [], this._mapId = t2.ac(), this._lostContextStyle = { style: null, images: null }, this._contextLost = (e4) => {
+            if (e4.preventDefault(), this._frameRequest && (this._frameRequest.abort(), this._frameRequest = null), this.painter.destroy(), this._lostContextStyle = this._getStyleAndImages(), this.style) {
+              for (const e5 of Object.values(this.style._layers)) if ("custom" === e5.type && console.warn(`Custom layer with id '${e5.id}' cannot be restored after WebGL context loss. You will need to re-add it manually after context restoration.`), e5._listeners) for (const [t3] of Object.entries(e5._listeners)) console.warn(`Custom layer with id '${e5.id}' had event listeners for event '${t3}' which cannot be restored after WebGL context loss. You will need to re-add them manually after context restoration.`);
+              this.style.destroy(), this.style = null, this.fire(new t2.l("webglcontextlost", { originalEvent: e4 }));
+            } else this.fire(new t2.l("webglcontextlost", { originalEvent: e4 }));
+          }, this._contextRestored = (e4) => {
+            this._lostContextStyle.style && this.setStyle(this._lostContextStyle.style, { diff: false }), this._lostContextStyle.images && (this.style.imageManager.images = this._lostContextStyle.images), this._lostContextStyle = { style: null, images: null }, this._setupPainter(), this.resize(), this._update(), this._resizeInternal(), this.fire(new t2.l("webglcontextrestored", { originalEvent: e4 }));
+          }, this._onMapScroll = (e4) => {
+            if (e4.target === this._container) return this._container.scrollTop = 0, this._container.scrollLeft = 0, false;
+          }, this._onWindowOnline = () => {
+            this._update();
+          }, this._interactive = a3.interactive, this._maxTileCacheSize = a3.maxTileCacheSize, this._maxTileCacheZoomLevels = a3.maxTileCacheZoomLevels, this._canvasContextAttributes = Object.assign({}, a3.canvasContextAttributes), this._trackResize = true === a3.trackResize, this._bearingSnap = a3.bearingSnap, this._zoomSnap = a3.zoomSnap, this._centerClampedToGround = a3.centerClampedToGround, this._refreshExpiredTiles = true === a3.refreshExpiredTiles, this._fadeDuration = a3.fadeDuration, this._crossSourceCollisions = true === a3.crossSourceCollisions, this._collectResourceTiming = true === a3.collectResourceTiming, this._locale = Object.assign(Object.assign({}, as), a3.locale), this._clickTolerance = a3.clickTolerance, this._overridePixelRatio = a3.pixelRatio, this._maxCanvasSize = a3.maxCanvasSize, this._zoomLevelsToOverscale = a3.experimentalZoomLevelsToOverscale, this.transformCameraUpdate = a3.transformCameraUpdate, this.transformConstrain = a3.transformConstrain, this.cancelPendingTileRequestsWhileZooming = true === a3.cancelPendingTileRequestsWhileZooming, this.setAnisotropicFilterPitch(a3.anisotropicFilterPitch), void 0 !== a3.reduceMotion && (n2.prefersReducedMotion = a3.reduceMotion), this._imageQueueHandle = u2.addThrottleControl(() => this.isMoving()), this._requestManager = new d2(a3.transformRequest), this._container = this._resolveContainer(a3.container), a3.maxBounds && this.setMaxBounds(a3.maxBounds), this._setupContainer(), this._setupPainter(), this.on("move", () => this._update(false)), this.on("moveend", () => this._update(false)), this.on("zoom", () => this._update(true)), this.on("terrain", () => {
+            this.painter.terrainFacilitator.dirty = true, this._update(true);
+          }), this.once("idle", () => {
+            this._idleTriggered = true;
+          }), "undefined" != typeof window && (this._ownerWindow.addEventListener("online", this._onWindowOnline, false), this._setupResizeObserver()), this.handlers = new qr(this, a3), this._hash = a3.hash && new qa2("string" == typeof a3.hash && a3.hash || void 0).addTo(this), this._hash && this._hash._onHashChange() || (this.jumpTo({ center: a3.center, elevation: a3.elevation, zoom: a3.zoom, bearing: a3.bearing, pitch: a3.pitch, roll: a3.roll }), a3.bounds && (this.resize(), this.fitBounds(a3.bounds, t2.e({}, a3.fitBoundsOptions, { duration: 0 }))));
+          const l3 = "string" == typeof a3.style || !("globe" === (null === (o3 = null === (i3 = a3.style) || void 0 === i3 ? void 0 : i3.projection) || void 0 === o3 ? void 0 : o3.type));
+          this.resize(null, l3), this._localIdeographFontFamily = a3.localIdeographFontFamily, this._validateStyle = a3.validateStyle, a3.style && this.setStyle(a3.style, { localIdeographFontFamily: a3.localIdeographFontFamily }), a3.attributionControl && this.addControl(new Xr("boolean" == typeof a3.attributionControl ? void 0 : a3.attributionControl)), a3.maplibreLogo && this.addControl(new Yr(), a3.logoPosition), this.on("style.load", () => {
+            if (l3 || this._resizeTransform(), this.transform.unmodified) {
+              const e4 = t2.U(this.style.stylesheet, ["center", "zoom", "bearing", "pitch", "roll"]);
+              this.jumpTo(e4);
+            }
+          }), this.on("data", (e4) => {
+            this._update("style" === e4.dataType), this.fire(new t2.l(`${e4.dataType}data`, e4));
+          }), this.on("dataloading", (e4) => {
+            this.fire(new t2.l(`${e4.dataType}dataloading`, e4));
+          }), this.on("dataabort", (e4) => {
+            this.fire(new t2.l("sourcedataabort", e4));
+          });
+        }
+        _getMapId() {
+          return this._mapId;
+        }
+        setGlobalStateProperty(e3, t3) {
+          return this.style.setGlobalStateProperty(e3, t3), this._update(true);
+        }
+        getGlobalState() {
+          return this.style.getGlobalState();
+        }
+        addControl(e3, i3) {
+          if (void 0 === i3 && (i3 = e3.getDefaultPosition ? e3.getDefaultPosition() : "top-right"), !e3 || !e3.onAdd) return this.fire(new t2.k(new Error("Invalid argument to map.addControl(). Argument must be a control with onAdd and onRemove methods.")));
+          const o3 = e3.onAdd(this);
+          this._controls.push(e3);
+          const a3 = this._controlPositions[i3];
+          return -1 !== i3.indexOf("bottom") ? a3.insertBefore(o3, a3.firstChild) : a3.appendChild(o3), this;
+        }
+        removeControl(e3) {
+          if (!e3 || !e3.onRemove) return this.fire(new t2.k(new Error("Invalid argument to map.removeControl(). Argument must be a control with onAdd and onRemove methods.")));
+          const i3 = this._controls.indexOf(e3);
+          return i3 > -1 && this._controls.splice(i3, 1), e3.onRemove(this), this;
+        }
+        hasControl(e3) {
+          return this._controls.indexOf(e3) > -1;
+        }
+        coveringTiles(e3) {
+          return Pe2(this.transform, e3);
+        }
+        calculateCameraOptionsFromTo(e3, t3, i3, o3) {
+          return null == o3 && this.terrain && (o3 = this.terrain.getElevationForLngLat(i3, this.transform)), super.calculateCameraOptionsFromTo(e3, t3, i3, o3);
+        }
+        resize(e3, i3 = true) {
+          if (null !== this._lostContextStyle.style) return this;
+          this._resizeInternal(i3);
+          const o3 = !this._moving;
+          return o3 && (this.stop(), this.fire(new t2.l("movestart", e3)).fire(new t2.l("move", e3))), this.fire(new t2.l("resize", e3)), o3 && this.fire(new t2.l("moveend", e3)), this;
+        }
+        _resizeInternal(e3 = true) {
+          const [t3, i3] = this._containerDimensions(), o3 = this._getClampedPixelRatio(t3, i3);
+          if (this._resizeCanvas(t3, i3, o3), this.painter.resize(t3, i3, o3), this.painter.overLimit()) {
+            const e4 = this.painter.context.gl;
+            this._maxCanvasSize = [e4.drawingBufferWidth, e4.drawingBufferHeight];
+            const o4 = this._getClampedPixelRatio(t3, i3);
+            this._resizeCanvas(t3, i3, o4), this.painter.resize(t3, i3, o4);
+          }
+          this._resizeTransform(e3);
+        }
+        _resizeTransform(e3 = true) {
+          var t3;
+          const [i3, o3] = this._containerDimensions();
+          this.transform.resize(i3, o3, e3), null === (t3 = this._requestedCameraState) || void 0 === t3 || t3.resize(i3, o3, e3);
+        }
+        _getClampedPixelRatio(e3, t3) {
+          const { 0: i3, 1: o3 } = this._maxCanvasSize, a3 = this.getPixelRatio(), r3 = e3 * a3, s3 = t3 * a3;
+          return Math.min(r3 > i3 ? i3 / r3 : 1, s3 > o3 ? o3 / s3 : 1) * a3;
+        }
+        getPixelRatio() {
+          var e3;
+          return null !== (e3 = this._overridePixelRatio) && void 0 !== e3 ? e3 : devicePixelRatio;
+        }
+        setPixelRatio(e3) {
+          this._overridePixelRatio = e3, this.resize();
+        }
+        getBounds() {
+          return this.transform.getBounds();
+        }
+        getMaxBounds() {
+          return this.transform.getMaxBounds();
+        }
+        setMaxBounds(e3) {
+          return this.transform.setMaxBounds(Z2.convert(e3)), this._update();
+        }
+        setMinZoom(e3) {
+          if ((e3 = null == e3 ? -2 : e3) >= -2 && e3 <= this.transform.maxZoom) {
+            const i3 = this.transform.zoom, o3 = this._getTransformForUpdate();
+            return o3.setMinZoom(e3), this._applyUpdatedTransform(o3), this._update(), i3 !== this.transform.zoom && this.fire(new t2.l("zoomstart")).fire(new t2.l("zoom")).fire(new t2.l("zoomend")).fire(new t2.l("movestart")).fire(new t2.l("move")).fire(new t2.l("moveend")), this;
+          }
+          throw new Error("minZoom must be between -2 and the current maxZoom, inclusive");
+        }
+        getMinZoom() {
+          return this.transform.minZoom;
+        }
+        setMaxZoom(e3) {
+          if ((e3 = null == e3 ? 22 : e3) >= this.transform.minZoom) {
+            const i3 = this.transform.zoom, o3 = this._getTransformForUpdate();
+            return o3.setMaxZoom(e3), this._applyUpdatedTransform(o3), this._update(), i3 !== this.transform.zoom && this.fire(new t2.l("zoomstart")).fire(new t2.l("zoom")).fire(new t2.l("zoomend")).fire(new t2.l("movestart")).fire(new t2.l("move")).fire(new t2.l("moveend")), this;
+          }
+          throw new Error("maxZoom must be greater than the current minZoom");
+        }
+        getMaxZoom() {
+          return this.transform.maxZoom;
+        }
+        setMinPitch(e3) {
+          if ((e3 = null == e3 ? 0 : e3) < 0) throw new Error("minPitch must be greater than or equal to 0");
+          if (e3 >= 0 && e3 <= this.transform.maxPitch) {
+            const i3 = this.transform.pitch, o3 = this._getTransformForUpdate();
+            return o3.setMinPitch(e3), this._applyUpdatedTransform(o3), this._update(), i3 !== this.transform.pitch && this.fire(new t2.l("pitchstart")).fire(new t2.l("pitch")).fire(new t2.l("pitchend")).fire(new t2.l("movestart")).fire(new t2.l("move")).fire(new t2.l("moveend")), this;
+          }
+          throw new Error("minPitch must be between 0 and the current maxPitch, inclusive");
+        }
+        getMinPitch() {
+          return this.transform.minPitch;
+        }
+        setMaxPitch(e3) {
+          if ((e3 = null == e3 ? 60 : e3) > 180) throw new Error("maxPitch must be less than or equal to 180");
+          if (e3 >= this.transform.minPitch) {
+            const i3 = this.transform.pitch, o3 = this._getTransformForUpdate();
+            return o3.setMaxPitch(e3), this._applyUpdatedTransform(o3), this._update(), i3 !== this.transform.pitch && this.fire(new t2.l("pitchstart")).fire(new t2.l("pitch")).fire(new t2.l("pitchend")).fire(new t2.l("movestart")).fire(new t2.l("move")).fire(new t2.l("moveend")), this;
+          }
+          throw new Error("maxPitch must be greater than the current minPitch");
+        }
+        getMaxPitch() {
+          return this.transform.maxPitch;
+        }
+        getAnisotropicFilterPitch() {
+          return this._anisotropicFilterPitch;
+        }
+        setAnisotropicFilterPitch(e3) {
+          if ((e3 = null == e3 ? 20 : e3) > 180) throw new Error("anisotropicFilterPitch must be less than or equal to 180");
+          if (e3 < 0) throw new Error("anisotropicFilterPitch must be greater than or equal to 0");
+          return this._anisotropicFilterPitch = e3, this._update();
+        }
+        getRenderWorldCopies() {
+          return this.transform.renderWorldCopies;
+        }
+        setRenderWorldCopies(e3) {
+          return this.transform.setRenderWorldCopies(e3), this._update();
+        }
+        setTransformConstrain(e3) {
+          return this.transform.setConstrainOverride(e3), this._update();
+        }
+        project(e3) {
+          return this.transform.locationToScreenPoint(t2.V.convert(e3), this.style && this.terrain);
+        }
+        unproject(e3) {
+          return this.transform.screenPointToLocation(t2.P.convert(e3), this.terrain);
+        }
+        isMoving() {
+          var e3;
+          return this._moving || (null === (e3 = this.handlers) || void 0 === e3 ? void 0 : e3.isMoving());
+        }
+        isZooming() {
+          var e3;
+          return this._zooming || (null === (e3 = this.handlers) || void 0 === e3 ? void 0 : e3.isZooming());
+        }
+        isRotating() {
+          var e3;
+          return this._rotating || (null === (e3 = this.handlers) || void 0 === e3 ? void 0 : e3.isRotating());
+        }
+        _createDelegatedListener(e3, t3, i3) {
+          if ("mouseenter" === e3 || "mouseover" === e3) {
+            let o3 = false;
+            const a3 = (a4) => {
+              const r3 = t3.filter((e4) => this.getLayer(e4)), s3 = 0 !== r3.length ? this.queryRenderedFeatures(a4.point, { layers: r3 }) : [];
+              s3.length ? o3 || (o3 = true, i3.call(this, new ir(e3, this, a4.originalEvent, { features: s3 }))) : o3 = false;
+            };
+            return { layers: t3, listener: i3, delegates: { mousemove: a3, mouseout: () => {
+              o3 = false;
+            } } };
+          }
+          if ("mouseleave" === e3 || "mouseout" === e3) {
+            let o3 = false;
+            const a3 = (a4) => {
+              const r4 = t3.filter((e4) => this.getLayer(e4));
+              (0 !== r4.length ? this.queryRenderedFeatures(a4.point, { layers: r4 }) : []).length ? o3 = true : o3 && (o3 = false, i3.call(this, new ir(e3, this, a4.originalEvent)));
+            }, r3 = (t4) => {
+              o3 && (o3 = false, i3.call(this, new ir(e3, this, t4.originalEvent)));
+            };
+            return { layers: t3, listener: i3, delegates: { mousemove: a3, mouseout: r3 } };
+          }
+          {
+            const o3 = (e4) => {
+              const o4 = t3.filter((e5) => this.getLayer(e5)), a3 = 0 !== o4.length ? this.queryRenderedFeatures(e4.point, { layers: o4 }) : [];
+              a3.length && (e4.features = a3, i3.call(this, e4), delete e4.features);
+            };
+            return { layers: t3, listener: i3, delegates: { [e3]: o3 } };
+          }
+        }
+        _saveDelegatedListener(e3, t3) {
+          this._delegatedListeners = this._delegatedListeners || {}, this._delegatedListeners[e3] = this._delegatedListeners[e3] || [], this._delegatedListeners[e3].push(t3);
+        }
+        _removeDelegatedListener(e3, t3, i3) {
+          if (!this._delegatedListeners || !this._delegatedListeners[e3]) return;
+          const o3 = this._delegatedListeners[e3];
+          for (let e4 = 0; e4 < o3.length; e4++) {
+            const a3 = o3[e4];
+            if (a3.listener === i3 && a3.layers.length === t3.length && a3.layers.every((e5) => t3.includes(e5))) {
+              for (const e5 in a3.delegates) this.off(e5, a3.delegates[e5]);
+              return void o3.splice(e4, 1);
+            }
+          }
+        }
+        on(e3, t3, i3) {
+          if (void 0 === i3) return super.on(e3, t3);
+          const o3 = "string" == typeof t3 ? [t3] : t3, a3 = this._createDelegatedListener(e3, o3, i3);
+          this._saveDelegatedListener(e3, a3);
+          for (const e4 in a3.delegates) this.on(e4, a3.delegates[e4]);
+          return { unsubscribe: () => {
+            this._removeDelegatedListener(e3, o3, i3);
+          } };
+        }
+        once(e3, t3, i3) {
+          if (void 0 === i3) return super.once(e3, t3);
+          const o3 = "string" == typeof t3 ? [t3] : t3, a3 = this._createDelegatedListener(e3, o3, i3);
+          for (const t4 in a3.delegates) {
+            const r3 = a3.delegates[t4];
+            a3.delegates[t4] = (...t5) => {
+              this._removeDelegatedListener(e3, o3, i3), r3(...t5);
+            };
+          }
+          this._saveDelegatedListener(e3, a3);
+          for (const e4 in a3.delegates) this.once(e4, a3.delegates[e4]);
+          return this;
+        }
+        off(e3, t3, i3) {
+          return void 0 === i3 ? super.off(e3, t3) : (this._removeDelegatedListener(e3, "string" == typeof t3 ? [t3] : t3, i3), this);
+        }
+        queryRenderedFeatures(e3, i3) {
+          if (!this.style) return [];
+          let o3;
+          const a3 = e3 instanceof t2.P || Array.isArray(e3), r3 = a3 ? e3 : [[0, 0], [this.transform.width, this.transform.height]];
+          if (i3 = i3 || (a3 ? {} : e3) || {}, r3 instanceof t2.P || "number" == typeof r3[0]) o3 = [t2.P.convert(r3)];
+          else {
+            const e4 = t2.P.convert(r3[0]), i4 = t2.P.convert(r3[1]);
+            o3 = [e4, new t2.P(i4.x, e4.y), i4, new t2.P(e4.x, i4.y), e4];
+          }
+          return this.style.queryRenderedFeatures(o3, i3, this.transform);
+        }
+        querySourceFeatures(e3, t3) {
+          return this.style.querySourceFeatures(e3, t3);
+        }
+        setStyle(e3, i3) {
+          return false !== (i3 = t2.e({}, { localIdeographFontFamily: this._localIdeographFontFamily, validate: this._validateStyle }, i3)).diff && i3.localIdeographFontFamily === this._localIdeographFontFamily && this.style && e3 ? (this._diffStyle(e3, i3), this) : (this._localIdeographFontFamily = i3.localIdeographFontFamily, this._updateStyle(e3, i3));
+        }
+        setTransformRequest(e3) {
+          return this._requestManager.setTransformRequest(e3), this;
+        }
+        _getUIString(e3) {
+          const t3 = this._locale[e3];
+          if (null == t3) throw new Error(`Missing UI string '${e3}'`);
+          return t3;
+        }
+        _updateStyle(e3, t3) {
+          var i3, o3;
+          if (t3.transformStyle && this.style && !this.style._loaded) return void this.style.once("style.load", () => this._updateStyle(e3, t3));
+          const a3 = this.style && t3.transformStyle ? this.style.serialize() : void 0;
+          return this.style && (this.style.setEventedParent(null), this.style._remove(!e3)), e3 ? (this.style = new Ai2(this, t3 || {}), this.style.setEventedParent(this, { style: this.style }), "string" == typeof e3 ? this.style.loadURL(e3, t3, a3) : this.style.loadJSON(e3, t3, a3), this) : (null === (o3 = null === (i3 = this.style) || void 0 === i3 ? void 0 : i3.projection) || void 0 === o3 || o3.destroy(), delete this.style, this);
+        }
+        _lazyInitEmptyStyle() {
+          this.style || (this.style = new Ai2(this, {}), this.style.setEventedParent(this, { style: this.style }), this.style.loadEmpty());
+        }
+        _diffStyle(e3, i3) {
+          return t2._(this, void 0, void 0, function* () {
+            if ("string" == typeof e3) {
+              const o3 = e3, a3 = yield this._requestManager.transformRequest(o3, "Style");
+              try {
+                const e4 = yield t2.j(a3, new AbortController());
+                this._updateDiff(e4.data, i3);
+              } catch (e4) {
+                e4 && this.fire(new t2.k(e4));
+              }
+            } else "object" == typeof e3 && this._updateDiff(e3, i3);
+          });
+        }
+        _updateDiff(e3, i3) {
+          try {
+            this.style.setState(e3, i3) && this._update(true);
+          } catch (o3) {
+            t2.w(`Unable to perform style diff: ${o3.message || o3.error || o3}.  Rebuilding the style from scratch.`), this._updateStyle(e3, i3);
+          }
+        }
+        getStyle() {
+          if (this.style) return this.style.serialize();
+        }
+        _getStyleAndImages() {
+          return this.style ? { style: this.style.serialize(), images: this.style.imageManager.cloneImages() } : { style: null, images: {} };
+        }
+        isStyleLoaded() {
+          return this.style ? this.style.loaded() : t2.w("There is no style added to the map.");
+        }
+        addSource(e3, t3) {
+          return this._lazyInitEmptyStyle(), this.style.addSource(e3, t3), this._update(true);
+        }
+        isSourceLoaded(e3) {
+          const i3 = this.style && this.style.tileManagers[e3];
+          if (void 0 !== i3) return i3.loaded();
+          this.fire(new t2.k(new Error(`There is no tile manager with ID '${e3}'`)));
+        }
+        setTerrain(e3) {
+          if (this.style._checkLoaded(), this._terrainDataCallback && this.style.off("data", this._terrainDataCallback), e3) {
+            const i3 = this.style.tileManagers[e3.source];
+            if (!i3) throw new Error(`cannot load terrain, because there exists no source with ID: ${e3.source}`);
+            null === this.terrain && i3.reload();
+            for (const i4 in this.style._layers) {
+              const o3 = this.style._layers[i4];
+              "hillshade" === o3.type && o3.source === e3.source && t2.w("You are using the same source for a hillshade layer and for 3D terrain. Please consider using two separate sources to improve rendering quality."), "color-relief" === o3.type && o3.source === e3.source && t2.w("You are using the same source for a color-relief layer and for 3D terrain. Please consider using two separate sources to improve rendering quality.");
+            }
+            this.terrain = new es(this.painter, i3, e3), this.painter.renderToTexture = new os(this.painter, this.terrain), this.transform.setMinElevationForCurrentTile(this.terrain.getMinTileElevationForLngLatZoom(this.transform.center, this.transform.tileZoom)), this.transform.setElevation(this.terrain.getElevationForLngLatZoom(this.transform.center, this.transform.tileZoom)), this._terrainDataCallback = (t3) => {
+              var i4;
+              "style" === t3.dataType ? this.terrain.tileManager.freeRtt() : "source" === t3.dataType && t3.tile && (t3.sourceId !== e3.source || this._elevationFreeze || (this.transform.setMinElevationForCurrentTile(this.terrain.getMinTileElevationForLngLatZoom(this.transform.center, this.transform.tileZoom)), this._centerClampedToGround && this.transform.setElevation(this.terrain.getElevationForLngLatZoom(this.transform.center, this.transform.tileZoom))), "image" === (null === (i4 = t3.source) || void 0 === i4 ? void 0 : i4.type) ? this.terrain.tileManager.freeRtt() : this.terrain.tileManager.freeRtt(t3.tile.tileID));
+            }, this.style.on("data", this._terrainDataCallback);
+          } else this.terrain && this.terrain.destroy(), this.terrain = null, this.painter.renderToTexture && this.painter.renderToTexture.destruct(), this.painter.renderToTexture = null, this.transform.setMinElevationForCurrentTile(0), this._centerClampedToGround && this.transform.setElevation(0);
+          return this.fire(new t2.l("terrain", { terrain: e3 })), this;
+        }
+        getTerrain() {
+          var e3, t3;
+          return null !== (t3 = null === (e3 = this.terrain) || void 0 === e3 ? void 0 : e3.options) && void 0 !== t3 ? t3 : null;
+        }
+        areTilesLoaded() {
+          const e3 = this.style && this.style.tileManagers;
+          for (const t3 of Object.values(e3)) if (!t3.areTilesLoaded()) return false;
+          return true;
+        }
+        removeSource(e3) {
+          return this.style.removeSource(e3), this._update(true);
+        }
+        getSource(e3) {
+          return this.style.getSource(e3);
+        }
+        setSourceTileLodParams(e3, t3, i3) {
+          if (i3) {
+            const o3 = this.getSource(i3);
+            if (!o3) throw new Error(`There is no source with ID "${i3}", cannot set LOD parameters`);
+            o3.calculateTileZoom = ye2(Math.max(1, e3), Math.max(1, t3));
+          } else for (const i4 in this.style.tileManagers) this.style.tileManagers[i4].getSource().calculateTileZoom = ye2(Math.max(1, e3), Math.max(1, t3));
+          return this._update(true), this;
+        }
+        refreshTiles(e3, i3) {
+          const o3 = this.style.tileManagers[e3];
+          if (!o3) throw new Error(`There is no tile manager with ID "${e3}", cannot refresh tile`);
+          void 0 === i3 ? o3.reload(true) : o3.refreshTiles(i3.map((e4) => new t2.a9(e4.z, e4.x, e4.y)));
+        }
+        addImage(e3, i3, o3 = {}) {
+          const { pixelRatio: a3 = 1, sdf: r3 = false, stretchX: s3, stretchY: l3, content: c3, textFitWidth: h3, textFitHeight: u3 } = o3;
+          if (this._lazyInitEmptyStyle(), !(i3 instanceof HTMLImageElement || t2.b(i3))) {
+            if (void 0 === i3.width || void 0 === i3.height) return this.fire(new t2.k(new Error("Invalid arguments to map.addImage(). The second argument must be an `HTMLImageElement`, `ImageData`, `ImageBitmap`, or object with `width`, `height`, and `data` properties with the same format as `ImageData`")));
+            {
+              const { width: o4, height: n3, data: d3 } = i3, _3 = i3;
+              return this.style.addImage(e3, { data: new t2.R({ width: o4, height: n3 }, new Uint8Array(d3)), pixelRatio: a3, stretchX: s3, stretchY: l3, content: c3, textFitWidth: h3, textFitHeight: u3, sdf: r3, version: 0, userImage: _3 }), _3.onAdd && _3.onAdd(this, e3), this;
+            }
+          }
+          {
+            const { width: o4, height: d3, data: _3 } = n2.getImageData(i3);
+            this.style.addImage(e3, { data: new t2.R({ width: o4, height: d3 }, _3), pixelRatio: a3, stretchX: s3, stretchY: l3, content: c3, textFitWidth: h3, textFitHeight: u3, sdf: r3, version: 0 });
+          }
+        }
+        updateImage(e3, i3) {
+          const o3 = this.style.getImage(e3);
+          if (!o3) return this.fire(new t2.k(new Error("The map has no image with that id. If you are adding a new image use `map.addImage(...)` instead.")));
+          const a3 = i3 instanceof HTMLImageElement || t2.b(i3) ? n2.getImageData(i3) : i3, { width: r3, height: s3, data: l3 } = a3;
+          if (void 0 === r3 || void 0 === s3) return this.fire(new t2.k(new Error("Invalid arguments to map.updateImage(). The second argument must be an `HTMLImageElement`, `ImageData`, `ImageBitmap`, or object with `width`, `height`, and `data` properties with the same format as `ImageData`")));
+          if (r3 !== o3.data.width || s3 !== o3.data.height) return this.fire(new t2.k(new Error("The width and height of the updated image must be that same as the previous version of the image")));
+          const c3 = !(i3 instanceof HTMLImageElement || t2.b(i3));
+          return o3.data.replace(l3, c3), this.style.updateImage(e3, o3), this;
+        }
+        getImage(e3) {
+          return this.style.getImage(e3);
+        }
+        hasImage(e3) {
+          return e3 ? !!this.style.getImage(e3) : (this.fire(new t2.k(new Error("Missing required image id"))), false);
+        }
+        removeImage(e3) {
+          this.style.removeImage(e3);
+        }
+        loadImage(e3) {
+          return t2._(this, void 0, void 0, function* () {
+            return u2.getImage(yield this._requestManager.transformRequest(e3, "Image"), new AbortController());
+          });
+        }
+        listImages() {
+          return this.style.listImages();
+        }
+        addLayer(e3, t3) {
+          return this._lazyInitEmptyStyle(), this.style.addLayer(e3, t3), this._update(true);
+        }
+        moveLayer(e3, t3) {
+          return this.style.moveLayer(e3, t3), this._update(true);
+        }
+        removeLayer(e3) {
+          return this.style.removeLayer(e3), this._update(true);
+        }
+        getLayer(e3) {
+          return this.style.getLayer(e3);
+        }
+        getLayersOrder() {
+          return this.style.getLayersOrder();
+        }
+        setLayerZoomRange(e3, t3, i3) {
+          return this.style.setLayerZoomRange(e3, t3, i3), this._update(true);
+        }
+        setFilter(e3, t3, i3 = {}) {
+          return this.style.setFilter(e3, t3, i3), this._update(true);
+        }
+        getFilter(e3) {
+          return this.style.getFilter(e3);
+        }
+        setPaintProperty(e3, t3, i3, o3 = {}) {
+          return this.style.setPaintProperty(e3, t3, i3, o3), this._update(true);
+        }
+        getPaintProperty(e3, t3) {
+          return this.style.getPaintProperty(e3, t3);
+        }
+        setLayoutProperty(e3, t3, i3, o3 = {}) {
+          return this.style.setLayoutProperty(e3, t3, i3, o3), this._update(true);
+        }
+        getLayoutProperty(e3, t3) {
+          return this.style.getLayoutProperty(e3, t3);
+        }
+        setGlyphs(e3, t3 = {}) {
+          return this._lazyInitEmptyStyle(), this.style.setGlyphs(e3, t3), this._update(true);
+        }
+        getGlyphs() {
+          return this.style.getGlyphsUrl();
+        }
+        addSprite(e3, t3, i3 = {}) {
+          return this._lazyInitEmptyStyle(), this.style.addSprite(e3, t3, i3, (e4) => {
+            e4 || this._update(true);
+          }), this;
+        }
+        removeSprite(e3) {
+          return this._lazyInitEmptyStyle(), this.style.removeSprite(e3), this._update(true);
+        }
+        getSprite() {
+          return this.style.getSprite();
+        }
+        setSprite(e3, t3 = {}) {
+          return this._lazyInitEmptyStyle(), this.style.setSprite(e3, t3, (e4) => {
+            e4 || this._update(true);
+          }), this;
+        }
+        setLight(e3, t3 = {}) {
+          return this._lazyInitEmptyStyle(), this.style.setLight(e3, t3), this._update(true);
+        }
+        getLight() {
+          return this.style.getLight();
+        }
+        setSky(e3, t3 = {}) {
+          return this._lazyInitEmptyStyle(), this.style.setSky(e3, t3), this._update(true);
+        }
+        getSky() {
+          return this.style.getSky();
+        }
+        setFeatureState(e3, t3) {
+          return this.style.setFeatureState(e3, t3), this._update();
+        }
+        removeFeatureState(e3, t3) {
+          return this.style.removeFeatureState(e3, t3), this._update();
+        }
+        getFeatureState(e3) {
+          return this.style.getFeatureState(e3);
+        }
+        getContainer() {
+          return this._container;
+        }
+        getCanvasContainer() {
+          return this._canvasContainer;
+        }
+        getCanvas() {
+          return this._canvas;
+        }
+        _containerDimensions() {
+          let e3 = 0, t3 = 0;
+          return this._container && (e3 = this._container.clientWidth || 400, t3 = this._container.clientHeight || 300), [e3, t3];
+        }
+        _setupResizeObserver() {
+          var e3;
+          let t3 = false;
+          const i3 = Wa2((e4) => {
+            this._trackResize && !this._removed && (this.resize(e4), this.redraw());
+          }, 50), o3 = null !== (e3 = this._ownerWindow.ResizeObserver) && void 0 !== e3 ? e3 : ResizeObserver;
+          this._resizeObserver = new o3((e4) => {
+            t3 ? i3(e4) : t3 = true;
+          }), this._resizeObserver.observe(this._container);
+        }
+        _resolveContainer(e3) {
+          if ("string" == typeof e3) {
+            const t3 = document.getElementById(e3);
+            if (!t3) throw new Error(`Container '${e3}' not found.`);
+            return t3;
+          }
+          if (e3 instanceof HTMLElement) return e3;
+          if (e3 && "object" == typeof e3 && 1 === e3.nodeType) return e3;
+          throw new Error("Invalid type: 'container' must be a String or HTMLElement.");
+        }
+        _setupContainer() {
+          const e3 = this._container;
+          e3.classList.add("maplibregl-map");
+          const t3 = this._canvasContainer = h2.create("div", "maplibregl-canvas-container", e3);
+          this._interactive && t3.classList.add("maplibregl-interactive"), this._canvas = h2.create("canvas", "maplibregl-canvas", t3), this._canvas.addEventListener("webglcontextlost", this._contextLost, false), this._canvas.addEventListener("webglcontextrestored", this._contextRestored, false), this._canvas.setAttribute("tabindex", this._interactive ? "0" : "-1"), this._canvas.setAttribute("aria-label", this._getUIString("Map.Title")), this._canvas.setAttribute("role", "region");
+          const i3 = this._containerDimensions(), o3 = this._getClampedPixelRatio(i3[0], i3[1]);
+          this._resizeCanvas(i3[0], i3[1], o3);
+          const a3 = this._controlContainer = h2.create("div", "maplibregl-control-container", e3), r3 = this._controlPositions = {};
+          ["top-left", "top-right", "bottom-left", "bottom-right"].forEach((e4) => {
+            r3[e4] = h2.create("div", `maplibregl-ctrl-${e4} `, a3);
+          }), this._container.addEventListener("scroll", this._onMapScroll, false);
+        }
+        _resizeCanvas(e3, t3, i3) {
+          this._canvas.width = Math.floor(i3 * e3), this._canvas.height = Math.floor(i3 * t3), this._canvas.style.width = `${e3}px`, this._canvas.style.height = `${t3}px`;
+        }
+        _setupPainter() {
+          const e3 = Object.assign(Object.assign({}, this._canvasContextAttributes), { alpha: true, depth: true, stencil: true, premultipliedAlpha: true });
+          let t3 = null;
+          this._canvas.addEventListener("webglcontextcreationerror", (i4) => {
+            t3 = { requestedAttributes: e3 }, i4 && (t3.statusMessage = i4.statusMessage, t3.type = i4.type);
+          }, { once: true });
+          let i3 = null;
+          if (i3 = this._canvasContextAttributes.contextType ? this._canvas.getContext(this._canvasContextAttributes.contextType, e3) : this._canvas.getContext("webgl2", e3) || this._canvas.getContext("webgl", e3), !i3) {
+            const e4 = "Failed to initialize WebGL";
+            throw t3 ? (t3.message = e4, new Error(JSON.stringify(t3))) : new Error(e4);
+          }
+          this.painter = new Va2(i3, this.transform);
+        }
+        migrateProjection(e3, i3) {
+          super.migrateProjection(e3, i3), this.painter.transform = e3, this.fire(new t2.l("projectiontransition", { newProjection: this.style.projection.name }));
+        }
+        loaded() {
+          return !this._styleDirty && !this._sourcesDirty && !!this.style && this.style.loaded();
+        }
+        _update(e3) {
+          return this.style && this.style._loaded ? (this._styleDirty = this._styleDirty || e3, this._sourcesDirty = true, this.triggerRepaint(), this) : this;
+        }
+        _requestRenderFrame(e3) {
+          return this._update(), this._renderTaskQueue.add(e3);
+        }
+        _cancelRenderFrame(e3) {
+          this._renderTaskQueue.remove(e3);
+        }
+        _render(e3) {
+          var i3, o3, a3, r3, s3;
+          const n3 = this._idleTriggered ? this._fadeDuration : 0, l3 = (null === (i3 = this.style.projection) || void 0 === i3 ? void 0 : i3.transitionState) > 0;
+          if (this.painter.context.setDirty(), this.painter.setBaseState(), this._renderTaskQueue.run(e3), this._removed) return;
+          let h3 = false;
+          if (this.style && this._styleDirty) {
+            this._styleDirty = false;
+            const e4 = this.transform.zoom, i4 = c2();
+            this.style.zoomHistory.update(e4, i4);
+            const o4 = new t2.H(e4, { now: i4, fadeDuration: n3, zoomHistory: this.style.zoomHistory, transition: this.style.getTransition() }), a4 = o4.crossFadingFactor();
+            1 === a4 && a4 === this._crossFadingFactor || (h3 = true, this._crossFadingFactor = a4), this.style.update(o4);
+          }
+          const u3 = (null === (o3 = this.style.projection) || void 0 === o3 ? void 0 : o3.transitionState) > 0 !== l3;
+          null === (a3 = this.style.projection) || void 0 === a3 || a3.setErrorQueryLatitudeDegrees(this.transform.center.lat), this.transform.setTransitionState(null === (r3 = this.style.projection) || void 0 === r3 ? void 0 : r3.transitionState, null === (s3 = this.style.projection) || void 0 === s3 ? void 0 : s3.latitudeErrorCorrectionRadians), this.style && (this._sourcesDirty || u3) && (this._sourcesDirty = false, this.style._updateSources(this.transform)), this.terrain ? (this.terrain.tileManager.update(this.transform, this.terrain), this.transform.setMinElevationForCurrentTile(this.terrain.getMinTileElevationForLngLatZoom(this.transform.center, this.transform.tileZoom)), !this._elevationFreeze && this._centerClampedToGround && this.transform.setElevation(this.terrain.getElevationForLngLatZoom(this.transform.center, this.transform.tileZoom))) : (this.transform.setMinElevationForCurrentTile(0), this._centerClampedToGround && this.transform.setElevation(0)), this._placementDirty = this.style && this.style._updatePlacement(this.transform, this.showCollisionBoxes, n3, this._crossSourceCollisions, u3), this.painter.render(this.style, { showTileBoundaries: this.showTileBoundaries, showOverdrawInspector: this._showOverdrawInspector, rotating: this.isRotating(), zooming: this.isZooming(), moving: this.isMoving(), fadeDuration: n3, showPadding: this.showPadding, anisotropicFilterPitch: this.getAnisotropicFilterPitch() }), this.fire(new t2.l("render")), this.loaded() && !this._loaded && (this._loaded = true, t2.cE.mark(t2.cF.load), this.fire(new t2.l("load"))), this.style && (this.style.hasTransitions() || h3) && (this._styleDirty = true), this.style && !this._placementDirty && this.style._releaseSymbolFadeTiles();
+          const d3 = this._sourcesDirty || this._styleDirty || this._placementDirty;
+          return d3 || this._repaint ? this.triggerRepaint() : !this.isMoving() && this.loaded() && this.fire(new t2.l("idle")), !this._loaded || this._fullyLoaded || d3 || (this._fullyLoaded = true, t2.cE.mark(t2.cF.fullLoad)), this;
+        }
+        redraw() {
+          return this.style && (this._frameRequest && (this._frameRequest.abort(), this._frameRequest = null), this._render(0)), this;
+        }
+        remove() {
+          var e3;
+          this._hash && this._hash.remove();
+          for (const e4 of this._controls) e4.onRemove(this);
+          this._controls = [], this._frameRequest && (this._frameRequest.abort(), this._frameRequest = null), this._renderTaskQueue.clear(), this.painter.destroy(), this.handlers.destroy(), delete this.handlers, this.setStyle(null), "undefined" != typeof window && this._ownerWindow.removeEventListener("online", this._onWindowOnline, false), u2.removeThrottleControl(this._imageQueueHandle), null === (e3 = this._resizeObserver) || void 0 === e3 || e3.disconnect();
+          const i3 = this.painter.context.gl.getExtension("WEBGL_lose_context");
+          (null == i3 ? void 0 : i3.loseContext) && i3.loseContext(), this._canvas.removeEventListener("webglcontextrestored", this._contextRestored, false), this._canvas.removeEventListener("webglcontextlost", this._contextLost, false), this._canvasContainer.remove(), this._controlContainer.remove(), this._container.removeEventListener("scroll", this._onMapScroll, false), this._container.classList.remove("maplibregl-map"), t2.cE.remove(), this._removed = true, this.fire(new t2.l("remove"));
+        }
+        triggerRepaint() {
+          this.style && !this._frameRequest && (this._frameRequest = new AbortController(), n2.frame(this._frameRequest, (e3) => {
+            t2.cE.recordStartOfFrameAt(e3), this._frameRequest = null;
+            try {
+              this._render(e3);
+            } catch (e4) {
+              if (!t2.Z(e4) && !function(e5) {
+                return e5.message === aa2;
+              }(e4)) throw e4;
+            }
+          }, () => {
+          }, this._ownerWindow));
+        }
+        get showTileBoundaries() {
+          return !!this._showTileBoundaries;
+        }
+        set showTileBoundaries(e3) {
+          this._showTileBoundaries !== e3 && (this._showTileBoundaries = e3, this._update());
+        }
+        get showPadding() {
+          return !!this._showPadding;
+        }
+        set showPadding(e3) {
+          this._showPadding !== e3 && (this._showPadding = e3, this._update());
+        }
+        get showCollisionBoxes() {
+          return !!this._showCollisionBoxes;
+        }
+        set showCollisionBoxes(e3) {
+          this._showCollisionBoxes !== e3 && (this._showCollisionBoxes = e3, e3 ? this.style._generateCollisionBoxes() : this._update());
+        }
+        get showOverdrawInspector() {
+          return !!this._showOverdrawInspector;
+        }
+        set showOverdrawInspector(e3) {
+          this._showOverdrawInspector !== e3 && (this._showOverdrawInspector = e3, this._update());
+        }
+        get repaint() {
+          return !!this._repaint;
+        }
+        set repaint(e3) {
+          this._repaint !== e3 && (this._repaint = e3, this.triggerRepaint());
+        }
+        get vertices() {
+          return !!this._vertices;
+        }
+        set vertices(e3) {
+          this._vertices = e3, this._update();
+        }
+        get version() {
+          return rs;
+        }
+        getCameraTargetElevation() {
+          return this.transform.elevation;
+        }
+        getProjection() {
+          return this.style.getProjection();
+        }
+        setProjection(e3) {
+          return this._lazyInitEmptyStyle(), this.style.setProjection(e3), this._update(true);
+        }
+      };
+      const ls = { showCompass: true, showZoom: true, visualizePitch: false, visualizeRoll: true };
+      class cs {
+        constructor(e3, i3, o3 = false) {
+          this.mousedown = (e4) => {
+            this.startMove(e4, h2.mousePos(this.element, e4)), window.addEventListener("mousemove", this.mousemove), window.addEventListener("mouseup", this.mouseup);
+          }, this.mousemove = (e4) => {
+            this.move(e4, h2.mousePos(this.element, e4));
+          }, this.mouseup = (e4) => {
+            this._rotatePitchHandler.dragEnd(e4), this.offTemp();
+          }, this.touchstart = (e4) => {
+            1 !== e4.targetTouches.length ? this.reset() : (this._startPos = this._lastPos = h2.touchPos(this.element, e4.targetTouches)[0], this.startMove(e4, this._startPos), window.addEventListener("touchmove", this.touchmove, { passive: false }), window.addEventListener("touchend", this.touchend));
+          }, this.touchmove = (e4) => {
+            1 !== e4.targetTouches.length ? this.reset() : (this._lastPos = h2.touchPos(this.element, e4.targetTouches)[0], this.move(e4, this._lastPos));
+          }, this.touchend = (e4) => {
+            0 === e4.targetTouches.length && this._startPos && this._lastPos && this._startPos.dist(this._lastPos) < this._clickTolerance && this.element.click(), delete this._startPos, delete this._lastPos, this.offTemp();
+          }, this.reset = () => {
+            this._rotatePitchHandler.reset(), delete this._startPos, delete this._lastPos, this.offTemp();
+          }, this._clickTolerance = 10, this.element = i3;
+          const a3 = new xr();
+          this._rotatePitchHandler = new _r2({ clickTolerance: 3, move: (e4, a4) => {
+            const r3 = i3.getBoundingClientRect(), s3 = new t2.P((r3.bottom - r3.top) / 2, (r3.right - r3.left) / 2);
+            return { bearingDelta: t2.cv(new t2.P(e4.x, a4.y), a4, s3), pitchDelta: o3 ? -0.5 * (a4.y - e4.y) : void 0 };
+          }, moveStateManager: a3, enable: true, assignEvents: () => {
+          } }), this.map = e3, i3.addEventListener("mousedown", this.mousedown), i3.addEventListener("touchstart", this.touchstart, { passive: false }), i3.addEventListener("touchcancel", this.reset);
+        }
+        startMove(e3, t3) {
+          this._rotatePitchHandler.dragStart(e3, t3), h2.disableDrag();
+        }
+        move(e3, t3) {
+          const i3 = this.map, { bearingDelta: o3, pitchDelta: a3 } = this._rotatePitchHandler.dragMove(e3, t3) || {};
+          o3 && i3.setBearing(i3.getBearing() + o3), a3 && i3.setPitch(i3.getPitch() + a3);
+        }
+        off() {
+          const e3 = this.element;
+          e3.removeEventListener("mousedown", this.mousedown), e3.removeEventListener("touchstart", this.touchstart), window.removeEventListener("touchmove", this.touchmove), window.removeEventListener("touchend", this.touchend), e3.removeEventListener("touchcancel", this.reset), this.offTemp();
+        }
+        offTemp() {
+          h2.enableDrag(), window.removeEventListener("mousemove", this.mousemove), window.removeEventListener("mouseup", this.mouseup), window.removeEventListener("touchmove", this.touchmove), window.removeEventListener("touchend", this.touchend);
+        }
+      }
+      let hs;
+      function us(e3, i3, o3, a3 = false) {
+        if (a3 || !o3.getCoveringTilesDetailsProvider().allowWorldCopies()) return null == e3 ? void 0 : e3.wrap();
+        const r3 = new t2.V(e3.lng, e3.lat);
+        if (e3 = new t2.V(e3.lng, e3.lat), i3) {
+          const a4 = new t2.V(e3.lng - 360, e3.lat), r4 = new t2.V(e3.lng + 360, e3.lat), s3 = o3.locationToScreenPoint(e3).distSqr(i3);
+          o3.locationToScreenPoint(a4).distSqr(i3) < s3 ? e3 = a4 : o3.locationToScreenPoint(r4).distSqr(i3) < s3 && (e3 = r4);
+        }
+        for (; Math.abs(e3.lng - o3.center.lng) > 180; ) {
+          const t3 = o3.locationToScreenPoint(e3);
+          if (t3.x >= 0 && t3.y >= 0 && t3.x <= o3.width && t3.y <= o3.height) break;
+          e3.lng > o3.center.lng ? e3.lng -= 360 : e3.lng += 360;
+        }
+        return e3.lng !== r3.lng && o3.isPointOnMapSurface(o3.locationToScreenPoint(e3)) ? e3 : r3;
+      }
+      const ds = { center: "translate(-50%,-50%)", top: "translate(-50%,0)", "top-left": "translate(0,0)", "top-right": "translate(-100%,0)", bottom: "translate(-50%,-100%)", "bottom-left": "translate(0,-100%)", "bottom-right": "translate(-100%,-100%)", left: "translate(0,-50%)", right: "translate(-100%,-50%)" };
+      function _s2(e3, t3, i3) {
+        const o3 = e3.classList;
+        for (const e4 in ds) o3.remove(`maplibregl-${i3}-anchor-${e4}`);
+        o3.add(`maplibregl-${i3}-anchor-${t3}`);
+      }
+      class ps extends t2.E {
+        constructor(e3) {
+          if (super(), this._onClick = (e4) => {
+            this.fire(new t2.l("click", { originalEvent: e4 }));
+          }, this._onKeyPress = (e4) => {
+            "Space" !== e4.code && "Enter" !== e4.code || this.togglePopup();
+          }, this._onMapClick = (e4) => {
+            const t3 = e4.originalEvent.target, i3 = this._element;
+            this._popup && (t3 === i3 || i3.contains(t3)) && this.togglePopup();
+          }, this._update = (e4) => {
+            if (!this._map) return;
+            const t3 = this._map.loaded() && !this._map.isMoving();
+            ("terrain" === (null == e4 ? void 0 : e4.type) || "render" === (null == e4 ? void 0 : e4.type) && !t3) && this._map.once("render", this._update), this._lngLat = us(this._lngLat, this._flatPos, this._map.transform), this._flatPos = this._pos = this._map.project(this._lngLat)._add(this._offset), this._map.terrain && (this._flatPos = this._map.transform.locationToScreenPoint(this._lngLat)._add(this._offset));
+            let i3 = "";
+            "viewport" === this._rotationAlignment || "auto" === this._rotationAlignment ? i3 = `rotateZ(${this._rotation}deg)` : "map" === this._rotationAlignment && (i3 = `rotateZ(${this._rotation - this._map.getBearing()}deg)`);
+            let o3 = "";
+            "viewport" === this._pitchAlignment || "auto" === this._pitchAlignment ? o3 = "rotateX(0deg)" : "map" === this._pitchAlignment && (o3 = `rotateX(${this._map.getPitch()}deg)`), this._subpixelPositioning || e4 && "moveend" !== e4.type || (this._pos = this._pos.round()), this._element.style.transform = `${ds[this._anchor]} translate(${this._pos.x}px, ${this._pos.y}px) ${o3} ${i3}`, n2.frameAsync(new AbortController(), this._map._ownerWindow).then(() => {
+              this._updateOpacity(e4 && "moveend" === e4.type);
+            }).catch(() => {
+            });
+          }, this._onMove = (e4) => {
+            if (!this._isDragging) {
+              const t3 = this._clickTolerance || this._map._clickTolerance;
+              this._isDragging = e4.point.dist(this._pointerdownPos) >= t3;
+            }
+            this._isDragging && (this._pos = e4.point.sub(this._positionDelta), this._lngLat = this._map.unproject(this._pos), this.setLngLat(this._lngLat), this._element.style.pointerEvents = "none", "pending" === this._state && (this._state = "active", this.fire(new t2.l("dragstart"))), this.fire(new t2.l("drag")));
+          }, this._onUp = () => {
+            this._element.style.pointerEvents = "auto", this._positionDelta = null, this._pointerdownPos = null, this._isDragging = false, this._map.off("mousemove", this._onMove), this._map.off("touchmove", this._onMove), "active" === this._state && this.fire(new t2.l("dragend")), this._state = "inactive";
+          }, this._addDragHandler = (e4) => {
+            this._element.contains(e4.originalEvent.target) && (e4.preventDefault(), this._positionDelta = e4.point.sub(this._pos).add(this._offset), this._pointerdownPos = e4.point, this._state = "pending", this._map.on("mousemove", this._onMove), this._map.on("touchmove", this._onMove), this._map.once("mouseup", this._onUp), this._map.once("touchend", this._onUp));
+          }, this._anchor = e3 && e3.anchor || "center", this._color = e3 && e3.color || "#3FB1CE", this._scale = e3 && e3.scale || 1, this._draggable = e3 && e3.draggable || false, this._clickTolerance = e3 && e3.clickTolerance || 0, this._subpixelPositioning = e3 && e3.subpixelPositioning || false, this._isDragging = false, this._state = "inactive", this._rotation = e3 && e3.rotation || 0, this._rotationAlignment = e3 && e3.rotationAlignment || "auto", this._pitchAlignment = e3 && e3.pitchAlignment && "auto" !== e3.pitchAlignment ? e3.pitchAlignment : this._rotationAlignment, this.setOpacity(null == e3 ? void 0 : e3.opacity, null == e3 ? void 0 : e3.opacityWhenCovered), e3 && e3.element) this._element = e3.element, this._offset = t2.P.convert(e3 && e3.offset || [0, 0]);
+          else {
+            this._defaultMarker = true, this._element = h2.create("div");
+            const i3 = h2.createNS("http://www.w3.org/2000/svg", "svg"), o3 = 41, a3 = 27;
+            i3.setAttributeNS(null, "display", "block"), i3.setAttributeNS(null, "height", `${o3}px`), i3.setAttributeNS(null, "width", `${a3}px`), i3.setAttributeNS(null, "viewBox", `0 0 ${a3} ${o3}`);
+            const r3 = h2.createNS("http://www.w3.org/2000/svg", "g");
+            r3.setAttributeNS(null, "stroke", "none"), r3.setAttributeNS(null, "stroke-width", "1"), r3.setAttributeNS(null, "fill", "none"), r3.setAttributeNS(null, "fill-rule", "evenodd");
+            const s3 = h2.createNS("http://www.w3.org/2000/svg", "g");
+            s3.setAttributeNS(null, "fill-rule", "nonzero");
+            const n3 = h2.createNS("http://www.w3.org/2000/svg", "g");
+            n3.setAttributeNS(null, "transform", "translate(3.0, 29.0)"), n3.setAttributeNS(null, "fill", "#000000");
+            const l3 = [{ rx: "10.5", ry: "5.25002273" }, { rx: "10.5", ry: "5.25002273" }, { rx: "9.5", ry: "4.77275007" }, { rx: "8.5", ry: "4.29549936" }, { rx: "7.5", ry: "3.81822308" }, { rx: "6.5", ry: "3.34094679" }, { rx: "5.5", ry: "2.86367051" }, { rx: "4.5", ry: "2.38636864" }];
+            for (const e4 of l3) {
+              const t3 = h2.createNS("http://www.w3.org/2000/svg", "ellipse");
+              t3.setAttributeNS(null, "opacity", "0.04"), t3.setAttributeNS(null, "cx", "10.5"), t3.setAttributeNS(null, "cy", "5.80029008"), t3.setAttributeNS(null, "rx", e4.rx), t3.setAttributeNS(null, "ry", e4.ry), n3.appendChild(t3);
+            }
+            const c3 = h2.createNS("http://www.w3.org/2000/svg", "g");
+            c3.setAttributeNS(null, "fill", this._color);
+            const u3 = h2.createNS("http://www.w3.org/2000/svg", "path");
+            u3.setAttributeNS(null, "d", "M27,13.5 C27,19.074644 20.250001,27.000002 14.75,34.500002 C14.016665,35.500004 12.983335,35.500004 12.25,34.500002 C6.7499993,27.000002 0,19.222562 0,13.5 C0,6.0441559 6.0441559,0 13.5,0 C20.955844,0 27,6.0441559 27,13.5 Z"), c3.appendChild(u3);
+            const d3 = h2.createNS("http://www.w3.org/2000/svg", "g");
+            d3.setAttributeNS(null, "opacity", "0.25"), d3.setAttributeNS(null, "fill", "#000000");
+            const _3 = h2.createNS("http://www.w3.org/2000/svg", "path");
+            _3.setAttributeNS(null, "d", "M13.5,0 C6.0441559,0 0,6.0441559 0,13.5 C0,19.222562 6.7499993,27 12.25,34.5 C13,35.522727 14.016664,35.500004 14.75,34.5 C20.250001,27 27,19.074644 27,13.5 C27,6.0441559 20.955844,0 13.5,0 Z M13.5,1 C20.415404,1 26,6.584596 26,13.5 C26,15.898657 24.495584,19.181431 22.220703,22.738281 C19.945823,26.295132 16.705119,30.142167 13.943359,33.908203 C13.743445,34.180814 13.612715,34.322738 13.5,34.441406 C13.387285,34.322738 13.256555,34.180814 13.056641,33.908203 C10.284481,30.127985 7.4148684,26.314159 5.015625,22.773438 C2.6163816,19.232715 1,15.953538 1,13.5 C1,6.584596 6.584596,1 13.5,1 Z"), d3.appendChild(_3);
+            const p3 = h2.createNS("http://www.w3.org/2000/svg", "g");
+            p3.setAttributeNS(null, "transform", "translate(6.0, 7.0)"), p3.setAttributeNS(null, "fill", "#FFFFFF");
+            const m3 = h2.createNS("http://www.w3.org/2000/svg", "g");
+            m3.setAttributeNS(null, "transform", "translate(8.0, 8.0)");
+            const f3 = h2.createNS("http://www.w3.org/2000/svg", "circle");
+            f3.setAttributeNS(null, "fill", "#000000"), f3.setAttributeNS(null, "opacity", "0.25"), f3.setAttributeNS(null, "cx", "5.5"), f3.setAttributeNS(null, "cy", "5.5"), f3.setAttributeNS(null, "r", "5.4999962");
+            const g3 = h2.createNS("http://www.w3.org/2000/svg", "circle");
+            g3.setAttributeNS(null, "fill", "#FFFFFF"), g3.setAttributeNS(null, "cx", "5.5"), g3.setAttributeNS(null, "cy", "5.5"), g3.setAttributeNS(null, "r", "5.4999962"), m3.appendChild(f3), m3.appendChild(g3), s3.appendChild(n3), s3.appendChild(c3), s3.appendChild(d3), s3.appendChild(p3), s3.appendChild(m3), i3.appendChild(s3), i3.setAttributeNS(null, "height", o3 * this._scale + "px"), i3.setAttributeNS(null, "width", a3 * this._scale + "px"), this._element.appendChild(i3), this._offset = t2.P.convert(e3 && e3.offset || [0, -14]);
+          }
+          if (this._element.classList.add("maplibregl-marker"), this._element.addEventListener("dragstart", (e4) => {
+            e4.preventDefault();
+          }), this._element.addEventListener("mousedown", (e4) => {
+            e4.preventDefault();
+          }), _s2(this._element, this._anchor, "marker"), e3 && e3.className) for (const t3 of e3.className.split(" ")) this._element.classList.add(t3);
+          this._popup = null;
+        }
+        addTo(e3) {
+          return this.remove(), this._map = e3, this._element.hasAttribute("aria-label") || this._element.setAttribute("aria-label", e3._getUIString("Marker.Title")), this._element.hasAttribute("role") || this._element.setAttribute("role", "button"), e3.getCanvasContainer().appendChild(this._element), e3.on("move", this._update), e3.on("moveend", this._update), e3.on("terrain", this._update), e3.on("projectiontransition", this._update), this._element.addEventListener("click", this._onClick), this.setDraggable(this._draggable), this._update(), this._map.on("click", this._onMapClick), this;
+        }
+        remove() {
+          return this._opacityTimeout && (clearTimeout(this._opacityTimeout), delete this._opacityTimeout), this._map && (this._map.off("click", this._onMapClick), this._map.off("move", this._update), this._map.off("moveend", this._update), this._map.off("terrain", this._update), this._map.off("projectiontransition", this._update), this._map.off("mousedown", this._addDragHandler), this._map.off("touchstart", this._addDragHandler), this._map.off("mouseup", this._onUp), this._map.off("touchend", this._onUp), this._map.off("mousemove", this._onMove), this._map.off("touchmove", this._onMove), delete this._map), this._element.removeEventListener("click", this._onClick), this._element.remove(), this._popup && this._popup.remove(), this;
+        }
+        getLngLat() {
+          return this._lngLat;
+        }
+        setLngLat(e3) {
+          return this._lngLat = t2.V.convert(e3), this._pos = null, this._popup && this._popup.setLngLat(this._lngLat), this._update(), this;
+        }
+        getElement() {
+          return this._element;
+        }
+        setPopup(e3) {
+          if (this._popup && (this._popup.remove(), this._popup = null, this._element.removeEventListener("keypress", this._onKeyPress), this._originalTabIndex || this._element.removeAttribute("tabindex")), e3) {
+            if (!("offset" in e3.options)) {
+              const t3 = 38.1, i3 = 13.5, o3 = Math.abs(i3) / Math.SQRT2;
+              e3.options.offset = this._defaultMarker ? { top: [0, 0], "top-left": [0, 0], "top-right": [0, 0], bottom: [0, -38.1], "bottom-left": [o3, -1 * (t3 - i3 + o3)], "bottom-right": [-o3, -1 * (t3 - i3 + o3)], left: [i3, -1 * (t3 - i3)], right: [-13.5, -1 * (t3 - i3)] } : this._offset;
+            }
+            this._popup = e3, this._originalTabIndex = this._element.getAttribute("tabindex"), this._originalTabIndex || this._element.setAttribute("tabindex", "0"), this._element.addEventListener("keypress", this._onKeyPress);
+          }
+          return this;
+        }
+        setSubpixelPositioning(e3) {
+          return this._subpixelPositioning = e3, this;
+        }
+        getPopup() {
+          return this._popup;
+        }
+        togglePopup() {
+          const e3 = this._popup;
+          return this._element.style.opacity === this._opacityWhenCovered ? this : e3 ? (e3.isOpen() ? e3.remove() : (e3.setLngLat(this._lngLat), e3.addTo(this._map)), this) : this;
+        }
+        _updateOpacity(e3 = false) {
+          var i3, o3;
+          const a3 = null === (i3 = this._map) || void 0 === i3 ? void 0 : i3.terrain, r3 = this._map.transform.isLocationOccluded(this._lngLat);
+          if (!a3 || r3) {
+            const e4 = r3 ? this._opacityWhenCovered : this._opacity;
+            return void (this._element.style.opacity !== e4 && (this._element.style.opacity = e4));
+          }
+          if (e3) this._opacityTimeout = null;
+          else {
+            if (this._opacityTimeout) return;
+            this._opacityTimeout = setTimeout(() => {
+              this._opacityTimeout = null;
+            }, 100);
+          }
+          const s3 = this._map, n3 = s3.terrain.depthAtPoint(this._pos), l3 = s3.terrain.getElevationForLngLat(this._lngLat, s3.transform);
+          if (s3.transform.lngLatToCameraDepth(this._lngLat, l3) - n3 < 6e-3) return void (this._element.style.opacity = this._opacity);
+          const c3 = -this._offset.y / s3.transform.pixelsPerMeter, h3 = Math.sin(s3.getPitch() * Math.PI / 180) * c3, u3 = s3.terrain.depthAtPoint(new t2.P(this._pos.x, this._pos.y - this._offset.y)), d3 = s3.transform.lngLatToCameraDepth(this._lngLat, l3 + h3) - u3 > 6e-3;
+          (null === (o3 = this._popup) || void 0 === o3 ? void 0 : o3.isOpen()) && d3 && this._popup.remove(), this._element.style.opacity = d3 ? this._opacityWhenCovered : this._opacity;
+        }
+        getOffset() {
+          return this._offset;
+        }
+        setOffset(e3) {
+          return this._offset = t2.P.convert(e3), this._update(), this;
+        }
+        addClassName(e3) {
+          this._element.classList.add(e3);
+        }
+        removeClassName(e3) {
+          this._element.classList.remove(e3);
+        }
+        toggleClassName(e3) {
+          return this._element.classList.toggle(e3);
+        }
+        setDraggable(e3) {
+          return this._draggable = !!e3, this._map && (e3 ? (this._map.on("mousedown", this._addDragHandler), this._map.on("touchstart", this._addDragHandler)) : (this._map.off("mousedown", this._addDragHandler), this._map.off("touchstart", this._addDragHandler))), this;
+        }
+        isDraggable() {
+          return this._draggable;
+        }
+        setRotation(e3) {
+          return this._rotation = e3 || 0, this._update(), this;
+        }
+        getRotation() {
+          return this._rotation;
+        }
+        setRotationAlignment(e3) {
+          return this._rotationAlignment = e3 || "auto", this._update(), this;
+        }
+        getRotationAlignment() {
+          return this._rotationAlignment;
+        }
+        setPitchAlignment(e3) {
+          return this._pitchAlignment = e3 && "auto" !== e3 ? e3 : this._rotationAlignment, this._update(), this;
+        }
+        getPitchAlignment() {
+          return this._pitchAlignment;
+        }
+        setOpacity(e3, t3) {
+          return (void 0 === this._opacity || void 0 === e3 && void 0 === t3) && (this._opacity = "1", this._opacityWhenCovered = "0.2"), void 0 !== e3 && (this._opacity = e3), void 0 !== t3 && (this._opacityWhenCovered = t3), this._map && this._updateOpacity(true), this;
+        }
+      }
+      const ms = { positionOptions: { enableHighAccuracy: false, maximumAge: 0, timeout: 6e3 }, fitBoundsOptions: { maxZoom: 15 }, trackUserLocation: false, showAccuracyCircle: true, showUserLocation: true };
+      let fs2 = 0, gs = false;
+      const vs2 = { maxWidth: 100, unit: "metric" };
+      function xs(e3, t3, i3) {
+        const o3 = i3 && i3.maxWidth || 100, a3 = e3._container.clientHeight / 2, r3 = e3._container.clientWidth / 2, s3 = e3.unproject([r3 - o3 / 2, a3]), n3 = e3.unproject([r3 + o3 / 2, a3]), l3 = Math.round(e3.project(n3).x - e3.project(s3).x), c3 = Math.min(o3, l3, e3._container.clientWidth), h3 = s3.distanceTo(n3);
+        if (i3 && "imperial" === i3.unit) {
+          const i4 = 3.2808 * h3;
+          i4 > 5280 ? bs(t3, c3, i4 / 5280, e3._getUIString("ScaleControl.Miles")) : bs(t3, c3, i4, e3._getUIString("ScaleControl.Feet"));
+        } else i3 && "nautical" === i3.unit ? bs(t3, c3, h3 / 1852, e3._getUIString("ScaleControl.NauticalMiles")) : h3 >= 1e3 ? bs(t3, c3, h3 / 1e3, e3._getUIString("ScaleControl.Kilometers")) : bs(t3, c3, h3, e3._getUIString("ScaleControl.Meters"));
+      }
+      function bs(e3, t3, i3, o3) {
+        const a3 = function(e4) {
+          const t4 = Math.pow(10, `${Math.floor(e4)}`.length - 1);
+          let i4 = e4 / t4;
+          return i4 = i4 >= 10 ? 10 : i4 >= 5 ? 5 : i4 >= 3 ? 3 : i4 >= 2 ? 2 : i4 >= 1 ? 1 : function(e5) {
+            const t5 = Math.pow(10, Math.ceil(-Math.log(e5) / Math.LN10));
+            return Math.round(e5 * t5) / t5;
+          }(i4), t4 * i4;
+        }(i3);
+        e3.style.width = t3 * (a3 / i3) + "px", e3.innerHTML = `${a3}&nbsp;${o3}`;
+      }
+      const ys = { closeButton: true, closeOnClick: true, focusAfterOpen: true, className: "", maxWidth: "240px", subpixelPositioning: false, locationOccludedOpacity: void 0, padding: void 0 }, ws = ["a[href]", "[tabindex]:not([tabindex='-1'])", "[contenteditable]:not([contenteditable='false'])", "button:not([disabled])", "input:not([disabled])", "select:not([disabled])", "textarea:not([disabled])"].join(", ");
+      function Ts(e3) {
+        if (e3) {
+          if ("number" == typeof e3) {
+            const i3 = Math.round(Math.abs(e3) / Math.SQRT2);
+            return { center: new t2.P(0, 0), top: new t2.P(0, e3), "top-left": new t2.P(i3, i3), "top-right": new t2.P(-i3, i3), bottom: new t2.P(0, -e3), "bottom-left": new t2.P(i3, -i3), "bottom-right": new t2.P(-i3, -i3), left: new t2.P(e3, 0), right: new t2.P(-e3, 0) };
+          }
+          if (e3 instanceof t2.P || Array.isArray(e3)) {
+            const i3 = t2.P.convert(e3);
+            return { center: i3, top: i3, "top-left": i3, "top-right": i3, bottom: i3, "bottom-left": i3, "bottom-right": i3, left: i3, right: i3 };
+          }
+          return { center: t2.P.convert(e3.center || [0, 0]), top: t2.P.convert(e3.top || [0, 0]), "top-left": t2.P.convert(e3["top-left"] || [0, 0]), "top-right": t2.P.convert(e3["top-right"] || [0, 0]), bottom: t2.P.convert(e3.bottom || [0, 0]), "bottom-left": t2.P.convert(e3["bottom-left"] || [0, 0]), "bottom-right": t2.P.convert(e3["bottom-right"] || [0, 0]), left: t2.P.convert(e3.left || [0, 0]), right: t2.P.convert(e3.right || [0, 0]) };
+        }
+        return Ts(new t2.P(0, 0));
+      }
+      const Ps = i2;
+      e2.AJAXError = t2.cG, e2.EXTENT = t2.a5, e2.Event = t2.l, e2.Evented = t2.E, e2.LngLat = t2.V, e2.MercatorCoordinate = t2.a6, e2.Point = t2.P, e2.addProtocol = t2.cH, e2.config = t2.c, e2.removeProtocol = t2.cI, e2.AttributionControl = Xr, e2.BoxZoomHandler = lr, e2.CanvasSource = te2, e2.CooperativeGesturesHandler = Ur, e2.DoubleClickZoomHandler = Fr, e2.DragPanHandler = jr, e2.DragRotateHandler = Nr, e2.EdgeInsets = Ot, e2.FullscreenControl = class extends t2.E {
+        constructor(e3 = {}) {
+          var i3;
+          super(), this._onFullscreenChange = () => {
+            var e4;
+            let t3 = window.document.fullscreenElement || window.document.webkitFullscreenElement;
+            for (; null === (e4 = null == t3 ? void 0 : t3.shadowRoot) || void 0 === e4 ? void 0 : e4.fullscreenElement; ) t3 = t3.shadowRoot.fullscreenElement;
+            t3 === this._container !== this._fullscreen && this._handleFullscreenChange();
+          }, this._onClickFullscreen = () => {
+            this._isFullscreen() ? this._exitFullscreen() : this._requestFullscreen();
+          }, this._fullscreen = false, this._pseudo = null !== (i3 = e3.pseudo) && void 0 !== i3 && i3, e3 && e3.container && (e3.container instanceof HTMLElement ? this._container = e3.container : t2.w("Full screen control 'container' must be a DOM element.")), "onfullscreenchange" in document ? this._fullscreenchange = "fullscreenchange" : "onmozfullscreenchange" in document ? this._fullscreenchange = "mozfullscreenchange" : "onwebkitfullscreenchange" in document ? this._fullscreenchange = "webkitfullscreenchange" : "onmsfullscreenchange" in document && (this._fullscreenchange = "MSFullscreenChange");
+        }
+        onAdd(e3) {
+          return this._map = e3, this._container || (this._container = this._map.getContainer()), this._controlContainer = h2.create("div", "maplibregl-ctrl maplibregl-ctrl-group"), this._setupUI(), this._controlContainer;
+        }
+        onRemove() {
+          this._controlContainer.remove(), this._map = null, window.document.removeEventListener(this._fullscreenchange, this._onFullscreenChange);
+        }
+        _setupUI() {
+          const e3 = this._fullscreenButton = h2.create("button", "maplibregl-ctrl-fullscreen", this._controlContainer);
+          h2.create("span", "maplibregl-ctrl-icon", e3).setAttribute("aria-hidden", "true"), e3.type = "button", this._updateTitle(), this._fullscreenButton.addEventListener("click", this._onClickFullscreen), window.document.addEventListener(this._fullscreenchange, this._onFullscreenChange);
+        }
+        _updateTitle() {
+          const e3 = this._getTitle();
+          this._fullscreenButton.setAttribute("aria-label", e3), this._fullscreenButton.title = e3;
+        }
+        _getTitle() {
+          return this._map._getUIString(this._isFullscreen() ? "FullscreenControl.Exit" : "FullscreenControl.Enter");
+        }
+        _isFullscreen() {
+          return this._fullscreen;
+        }
+        _handleFullscreenChange() {
+          this._fullscreen = !this._fullscreen, this._fullscreenButton.classList.toggle("maplibregl-ctrl-shrink"), this._fullscreenButton.classList.toggle("maplibregl-ctrl-fullscreen"), this._updateTitle(), this._fullscreen ? (this.fire(new t2.l("fullscreenstart")), this._prevCooperativeGesturesEnabled = this._map.cooperativeGestures.isEnabled(), this._map.cooperativeGestures.disable()) : (this.fire(new t2.l("fullscreenend")), this._prevCooperativeGesturesEnabled && this._map.cooperativeGestures.enable());
+        }
+        _exitFullscreen() {
+          this._pseudo ? this._togglePseudoFullScreen() : window.document.exitFullscreen ? window.document.exitFullscreen() : window.document.webkitCancelFullScreen ? window.document.webkitCancelFullScreen() : this._togglePseudoFullScreen();
+        }
+        _requestFullscreen() {
+          this._pseudo ? this._togglePseudoFullScreen() : this._container.requestFullscreen ? this._container.requestFullscreen() : this._container.webkitRequestFullscreen ? this._container.webkitRequestFullscreen() : this._togglePseudoFullScreen();
+        }
+        _togglePseudoFullScreen() {
+          this._container.classList.toggle("maplibregl-pseudo-fullscreen"), this._handleFullscreenChange(), this._map.resize();
+        }
+      }, e2.GeoJSONSource = Q2, e2.GeolocateControl = class extends t2.E {
+        constructor(e3) {
+          super(), this._onSuccess = (e4) => {
+            if (this._map) {
+              if (this._isOutOfMapMaxBounds(e4)) return this._setErrorState(), this.fire(new t2.l("outofmaxbounds", e4)), this._updateMarker(), void this._finish();
+              if (this.options.trackUserLocation) switch (this._lastKnownPosition = e4, this._watchState) {
+                case "WAITING_ACTIVE":
+                case "ACTIVE_LOCK":
+                case "ACTIVE_ERROR":
+                  this._watchState = "ACTIVE_LOCK", this._geolocateButton.classList.remove("maplibregl-ctrl-geolocate-waiting"), this._geolocateButton.classList.remove("maplibregl-ctrl-geolocate-active-error"), this._geolocateButton.classList.add("maplibregl-ctrl-geolocate-active");
+                  break;
+                case "BACKGROUND":
+                case "BACKGROUND_ERROR":
+                  this._watchState = "BACKGROUND", this._geolocateButton.classList.remove("maplibregl-ctrl-geolocate-waiting"), this._geolocateButton.classList.remove("maplibregl-ctrl-geolocate-background-error"), this._geolocateButton.classList.add("maplibregl-ctrl-geolocate-background");
+                  break;
+                default:
+                  throw new Error(`Unexpected watchState ${this._watchState}`);
+              }
+              this.options.showUserLocation && "OFF" !== this._watchState && this._updateMarker(e4), this.options.trackUserLocation && "ACTIVE_LOCK" !== this._watchState || this._updateCamera(e4), this.options.showUserLocation && this._dotElement.classList.remove("maplibregl-user-location-dot-stale"), this.fire(new t2.l("geolocate", e4)), this._finish();
+            }
+          }, this._updateCamera = (e4) => {
+            const i3 = new t2.V(e4.coords.longitude, e4.coords.latitude), o3 = e4.coords.accuracy, a3 = this._map.getBearing(), r3 = t2.e({ bearing: a3 }, this.options.fitBoundsOptions), s3 = Z2.fromLngLat(i3, o3);
+            this._map.fitBounds(s3, r3, { geolocateSource: true });
+          }, this._updateMarker = (e4) => {
+            if (e4) {
+              const i3 = new t2.V(e4.coords.longitude, e4.coords.latitude);
+              this._accuracyCircleMarker.setLngLat(i3).addTo(this._map), this._userLocationDotMarker.setLngLat(i3).addTo(this._map), this._accuracy = e4.coords.accuracy, this._updateCircleRadiusIfNeeded();
+            } else this._userLocationDotMarker.remove(), this._accuracyCircleMarker.remove();
+          }, this._onUpdate = () => {
+            this._updateCircleRadiusIfNeeded();
+          }, this._onError = (e4) => {
+            if (this._map) {
+              if (1 === e4.code) {
+                this._watchState = "OFF", this._geolocateButton.classList.remove("maplibregl-ctrl-geolocate-waiting"), this._geolocateButton.classList.remove("maplibregl-ctrl-geolocate-active"), this._geolocateButton.classList.remove("maplibregl-ctrl-geolocate-active-error"), this._geolocateButton.classList.remove("maplibregl-ctrl-geolocate-background"), this._geolocateButton.classList.remove("maplibregl-ctrl-geolocate-background-error"), this._geolocateButton.disabled = true;
+                const e5 = this._map._getUIString("GeolocateControl.LocationNotAvailable");
+                this._geolocateButton.title = e5, this._geolocateButton.setAttribute("aria-label", e5), void 0 !== this._geolocationWatchID && this._clearWatch();
+              } else {
+                if (3 === e4.code && gs) return;
+                this._setErrorState();
+              }
+              "OFF" !== this._watchState && this.options.showUserLocation && this._dotElement.classList.add("maplibregl-user-location-dot-stale"), this.fire(new t2.l("error", e4)), this._finish();
+            }
+          }, this._finish = () => {
+            this._timeoutId && clearTimeout(this._timeoutId), this._timeoutId = void 0;
+          }, this._onMoveStart = (e4) => {
+            if (!this._map) return;
+            const i3 = (null == e4 ? void 0 : e4[0]) instanceof ResizeObserverEntry;
+            e4.geolocateSource || "ACTIVE_LOCK" !== this._watchState || i3 || this._map.isZooming() || (this._watchState = "BACKGROUND", this._geolocateButton.classList.add("maplibregl-ctrl-geolocate-background"), this._geolocateButton.classList.remove("maplibregl-ctrl-geolocate-active"), this.fire(new t2.l("trackuserlocationend")), this.fire(new t2.l("userlocationlostfocus")));
+          }, this._setupUI = () => {
+            this._map && (this._container.addEventListener("contextmenu", (e4) => e4.preventDefault()), this._geolocateButton = h2.create("button", "maplibregl-ctrl-geolocate", this._container), h2.create("span", "maplibregl-ctrl-icon", this._geolocateButton).setAttribute("aria-hidden", "true"), this._geolocateButton.type = "button", this._geolocateButton.disabled = true);
+          }, this._finishSetupUI = (e4) => {
+            if (this._map) {
+              if (false === e4) {
+                t2.w("Geolocation support is not available so the GeolocateControl will be disabled.");
+                const e5 = this._map._getUIString("GeolocateControl.LocationNotAvailable");
+                this._geolocateButton.disabled = true, this._geolocateButton.title = e5, this._geolocateButton.setAttribute("aria-label", e5);
+              } else {
+                const e5 = this._map._getUIString("GeolocateControl.FindMyLocation");
+                this._geolocateButton.disabled = false, this._geolocateButton.title = e5, this._geolocateButton.setAttribute("aria-label", e5);
+              }
+              this.options.trackUserLocation && (this._geolocateButton.setAttribute("aria-pressed", "false"), this._watchState = "OFF"), this.options.showUserLocation && (this._dotElement = h2.create("div", "maplibregl-user-location-dot"), this._userLocationDotMarker = new ps({ element: this._dotElement }), this._circleElement = h2.create("div", "maplibregl-user-location-accuracy-circle"), this._accuracyCircleMarker = new ps({ element: this._circleElement, pitchAlignment: "map" }), this.options.trackUserLocation && (this._watchState = "OFF"), this._map.on("zoom", this._onUpdate), this._map.on("move", this._onUpdate), this._map.on("rotate", this._onUpdate), this._map.on("pitch", this._onUpdate)), this._geolocateButton.addEventListener("click", () => this.trigger()), this._setup = true, this.options.trackUserLocation && this._map.on("movestart", this._onMoveStart);
+            }
+          }, this.options = t2.e({}, ms, e3);
+        }
+        onAdd(e3) {
+          return this._map = e3, this._container = h2.create("div", "maplibregl-ctrl maplibregl-ctrl-group"), this._setupUI(), function() {
+            return t2._(this, arguments, void 0, function* (e4 = false) {
+              if (void 0 !== hs && !e4) return hs;
+              if (void 0 === window.navigator.permissions) return hs = !!window.navigator.geolocation, hs;
+              try {
+                const e5 = yield window.navigator.permissions.query({ name: "geolocation" });
+                hs = "denied" !== e5.state;
+              } catch (e5) {
+                hs = !!window.navigator.geolocation;
+              }
+              return hs;
+            });
+          }().then((e4) => this._finishSetupUI(e4)), this._container;
+        }
+        onRemove() {
+          void 0 !== this._geolocationWatchID && (window.navigator.geolocation.clearWatch(this._geolocationWatchID), this._geolocationWatchID = void 0), this.options.showUserLocation && this._userLocationDotMarker && this._userLocationDotMarker.remove(), this.options.showAccuracyCircle && this._accuracyCircleMarker && this._accuracyCircleMarker.remove(), this._container.remove(), this._map.off("movestart", this._onMoveStart), this._map.off("zoom", this._onUpdate), this._map.off("move", this._onUpdate), this._map.off("rotate", this._onUpdate), this._map.off("pitch", this._onUpdate), this._map = void 0, fs2 = 0, gs = false;
+        }
+        _isOutOfMapMaxBounds(e3) {
+          const t3 = this._map.getMaxBounds(), i3 = e3.coords;
+          return t3 && (i3.longitude < t3.getWest() || i3.longitude > t3.getEast() || i3.latitude < t3.getSouth() || i3.latitude > t3.getNorth());
+        }
+        _setErrorState() {
+          switch (this._watchState) {
+            case "WAITING_ACTIVE":
+              this._watchState = "ACTIVE_ERROR", this._geolocateButton.classList.remove("maplibregl-ctrl-geolocate-active"), this._geolocateButton.classList.add("maplibregl-ctrl-geolocate-active-error");
+              break;
+            case "ACTIVE_LOCK":
+              this._watchState = "ACTIVE_ERROR", this._geolocateButton.classList.remove("maplibregl-ctrl-geolocate-active"), this._geolocateButton.classList.add("maplibregl-ctrl-geolocate-active-error"), this._geolocateButton.classList.add("maplibregl-ctrl-geolocate-waiting");
+              break;
+            case "BACKGROUND":
+              this._watchState = "BACKGROUND_ERROR", this._geolocateButton.classList.remove("maplibregl-ctrl-geolocate-background"), this._geolocateButton.classList.add("maplibregl-ctrl-geolocate-background-error"), this._geolocateButton.classList.add("maplibregl-ctrl-geolocate-waiting");
+              break;
+            case "ACTIVE_ERROR":
+            case "BACKGROUND_ERROR":
+            case "OFF":
+            case void 0:
+              break;
+            default:
+              throw new Error(`Unexpected watchState ${this._watchState}`);
+          }
+        }
+        _updateCircleRadiusIfNeeded() {
+          const e3 = this._userLocationDotMarker.getLngLat();
+          if (!(this.options.showUserLocation && this.options.showAccuracyCircle && this._accuracy && e3)) return;
+          const t3 = this._map.project(e3), i3 = this._map.unproject([t3.x + 100, t3.y]), o3 = e3.distanceTo(i3) / 100, a3 = 2 * this._accuracy / o3;
+          this._circleElement.style.width = `${a3.toFixed(2)}px`, this._circleElement.style.height = `${a3.toFixed(2)}px`;
+        }
+        trigger() {
+          if (!this._setup) return t2.w("Geolocate control triggered before added to a map"), false;
+          if (this.options.trackUserLocation) {
+            switch (this._watchState) {
+              case "OFF":
+                this._watchState = "WAITING_ACTIVE", this.fire(new t2.l("trackuserlocationstart"));
+                break;
+              case "WAITING_ACTIVE":
+              case "ACTIVE_LOCK":
+              case "ACTIVE_ERROR":
+              case "BACKGROUND_ERROR":
+                fs2--, gs = false, this._watchState = "OFF", this._geolocateButton.classList.remove("maplibregl-ctrl-geolocate-waiting"), this._geolocateButton.classList.remove("maplibregl-ctrl-geolocate-active"), this._geolocateButton.classList.remove("maplibregl-ctrl-geolocate-active-error"), this._geolocateButton.classList.remove("maplibregl-ctrl-geolocate-background"), this._geolocateButton.classList.remove("maplibregl-ctrl-geolocate-background-error"), this.fire(new t2.l("trackuserlocationend"));
+                break;
+              case "BACKGROUND":
+                this._watchState = "ACTIVE_LOCK", this._geolocateButton.classList.remove("maplibregl-ctrl-geolocate-background"), this._lastKnownPosition && this._updateCamera(this._lastKnownPosition), this.fire(new t2.l("trackuserlocationstart")), this.fire(new t2.l("userlocationfocus"));
+                break;
+              default:
+                throw new Error(`Unexpected watchState ${this._watchState}`);
+            }
+            switch (this._watchState) {
+              case "WAITING_ACTIVE":
+                this._geolocateButton.classList.add("maplibregl-ctrl-geolocate-waiting"), this._geolocateButton.classList.add("maplibregl-ctrl-geolocate-active");
+                break;
+              case "ACTIVE_LOCK":
+                this._geolocateButton.classList.add("maplibregl-ctrl-geolocate-active");
+                break;
+              case "OFF":
+                break;
+              default:
+                throw new Error(`Unexpected watchState ${this._watchState}`);
+            }
+            if ("OFF" === this._watchState && void 0 !== this._geolocationWatchID) this._clearWatch();
+            else if (void 0 === this._geolocationWatchID) {
+              let e3;
+              this._geolocateButton.classList.add("maplibregl-ctrl-geolocate-waiting"), this._geolocateButton.setAttribute("aria-pressed", "true"), fs2++, fs2 > 1 ? (e3 = { maximumAge: 6e5, timeout: 0 }, gs = true) : (e3 = this.options.positionOptions, gs = false), this._geolocationWatchID = window.navigator.geolocation.watchPosition(this._onSuccess, this._onError, e3);
+            }
+          } else window.navigator.geolocation.getCurrentPosition(this._onSuccess, this._onError, this.options.positionOptions), this._timeoutId = setTimeout(this._finish, 1e4);
+          return true;
+        }
+        _clearWatch() {
+          window.navigator.geolocation.clearWatch(this._geolocationWatchID), this._geolocationWatchID = void 0, this._geolocateButton.classList.remove("maplibregl-ctrl-geolocate-waiting"), this._geolocateButton.setAttribute("aria-pressed", "false"), this.options.showUserLocation && this._updateMarker(null);
+        }
+      }, e2.GlobeControl = class {
+        constructor() {
+          this._toggleProjection = () => {
+            var e3;
+            const t3 = null === (e3 = this._map.getProjection()) || void 0 === e3 ? void 0 : e3.type;
+            this._map.setProjection("mercator" !== t3 && t3 ? { type: "mercator" } : { type: "globe" }), this._updateGlobeIcon();
+          }, this._updateGlobeIcon = () => {
+            var e3;
+            this._globeButton.classList.remove("maplibregl-ctrl-globe"), this._globeButton.classList.remove("maplibregl-ctrl-globe-enabled"), "globe" === (null === (e3 = this._map.getProjection()) || void 0 === e3 ? void 0 : e3.type) ? (this._globeButton.classList.add("maplibregl-ctrl-globe-enabled"), this._globeButton.title = this._map._getUIString("GlobeControl.Disable")) : (this._globeButton.classList.add("maplibregl-ctrl-globe"), this._globeButton.title = this._map._getUIString("GlobeControl.Enable"));
+          };
+        }
+        onAdd(e3) {
+          return this._map = e3, this._container = h2.create("div", "maplibregl-ctrl maplibregl-ctrl-group"), this._globeButton = h2.create("button", "maplibregl-ctrl-globe", this._container), h2.create("span", "maplibregl-ctrl-icon", this._globeButton).setAttribute("aria-hidden", "true"), this._globeButton.type = "button", this._globeButton.addEventListener("click", this._toggleProjection), this._updateGlobeIcon(), this._map.on("styledata", this._updateGlobeIcon), this._map.on("projectiontransition", this._updateGlobeIcon), this._container;
+        }
+        onRemove() {
+          this._container.remove(), this._map.off("styledata", this._updateGlobeIcon), this._map.off("projectiontransition", this._updateGlobeIcon), this._globeButton.removeEventListener("click", this._toggleProjection), this._map = void 0;
+        }
+      }, e2.Hash = qa2, e2.ImageSource = J2, e2.KeyboardHandler = zr, e2.LngLatBounds = Z2, e2.LogoControl = Yr, e2.Map = ns, e2.MapLibreMap = ns, e2.MapMouseEvent = ir, e2.MapTouchEvent = or, e2.MapWheelEvent = ar, e2.Marker = ps, e2.NavigationControl = class {
+        constructor(e3) {
+          this._updateZoomButtons = () => {
+            const e4 = this._map.getZoom(), t3 = e4 === this._map.getMaxZoom(), i3 = e4 === this._map.getMinZoom();
+            this._zoomInButton.disabled = t3, this._zoomOutButton.disabled = i3, this._zoomInButton.setAttribute("aria-disabled", t3.toString()), this._zoomOutButton.setAttribute("aria-disabled", i3.toString());
+          }, this._rotateCompassArrow = () => {
+            this._compassIcon.style.transform = this.options.visualizePitch && this.options.visualizeRoll ? `scale(${1 / Math.pow(Math.cos(this._map.transform.pitchInRadians), 0.5)}) rotateZ(${-this._map.transform.roll}deg) rotateX(${this._map.transform.pitch}deg) rotateZ(${-this._map.transform.bearing}deg)` : this.options.visualizePitch ? `scale(${1 / Math.pow(Math.cos(this._map.transform.pitchInRadians), 0.5)}) rotateX(${this._map.transform.pitch}deg) rotateZ(${-this._map.transform.bearing}deg)` : this.options.visualizeRoll ? `rotate(${-this._map.transform.bearing - this._map.transform.roll}deg)` : `rotate(${-this._map.transform.bearing}deg)`;
+          }, this._setButtonTitle = (e4, t3) => {
+            const i3 = this._map._getUIString(`NavigationControl.${t3}`);
+            e4.title = i3, e4.setAttribute("aria-label", i3);
+          }, this.options = t2.e({}, ls, e3), this._container = h2.create("div", "maplibregl-ctrl maplibregl-ctrl-group"), this._container.addEventListener("contextmenu", (e4) => e4.preventDefault()), this.options.showZoom && (this._zoomInButton = this._createButton("maplibregl-ctrl-zoom-in", (e4) => this._map.zoomIn({}, { originalEvent: e4 })), h2.create("span", "maplibregl-ctrl-icon", this._zoomInButton).setAttribute("aria-hidden", "true"), this._zoomOutButton = this._createButton("maplibregl-ctrl-zoom-out", (e4) => this._map.zoomOut({}, { originalEvent: e4 })), h2.create("span", "maplibregl-ctrl-icon", this._zoomOutButton).setAttribute("aria-hidden", "true")), this.options.showCompass && (this._compass = this._createButton("maplibregl-ctrl-compass", (e4) => {
+            this.options.visualizePitch ? this._map.resetNorthPitch({}, { originalEvent: e4 }) : this._map.resetNorth({}, { originalEvent: e4 });
+          }), this._compassIcon = h2.create("span", "maplibregl-ctrl-icon", this._compass), this._compassIcon.setAttribute("aria-hidden", "true"));
+        }
+        onAdd(e3) {
+          return this._map = e3, this.options.showZoom && (this._setButtonTitle(this._zoomInButton, "ZoomIn"), this._setButtonTitle(this._zoomOutButton, "ZoomOut"), this._map.on("zoom", this._updateZoomButtons), this._updateZoomButtons()), this.options.showCompass && (this._setButtonTitle(this._compass, "ResetBearing"), this.options.visualizePitch && this._map.on("pitch", this._rotateCompassArrow), this.options.visualizeRoll && this._map.on("roll", this._rotateCompassArrow), this._map.on("rotate", this._rotateCompassArrow), this._rotateCompassArrow(), this._handler = new cs(this._map, this._compass, this.options.visualizePitch)), this._container;
+        }
+        onRemove() {
+          this._container.remove(), this.options.showZoom && this._map.off("zoom", this._updateZoomButtons), this.options.showCompass && (this.options.visualizePitch && this._map.off("pitch", this._rotateCompassArrow), this.options.visualizeRoll && this._map.off("roll", this._rotateCompassArrow), this._map.off("rotate", this._rotateCompassArrow), this._handler.off(), delete this._handler), delete this._map;
+        }
+        _createButton(e3, t3) {
+          const i3 = h2.create("button", e3, this._container);
+          return i3.type = "button", i3.addEventListener("click", t3), i3;
+        }
+      }, e2.Popup = class extends t2.E {
+        constructor(e3) {
+          super(), this._updateOpacity = () => {
+            void 0 !== this.options.locationOccludedOpacity && (this._container.style.opacity = this._map.transform.isLocationOccluded(this.getLngLat()) ? `${this.options.locationOccludedOpacity}` : "");
+          }, this.remove = () => (this._content && this._content.remove(), this._container && (this._container.remove(), delete this._container), this._map && (this._map.off("move", this._update), this._map.off("move", this._onClose), this._map.off("click", this._onClose), this._map.off("remove", this.remove), this._map.off("mousemove", this._update), this._map.off("mouseup", this._update), this._map.off("drag", this._update), this._map._canvasContainer.classList.remove("maplibregl-track-pointer"), delete this._map, this.fire(new t2.l("close"))), this), this._update = (e4) => {
+            if (!this._map || !this._lngLat && !this._trackPointer || !this._content) return;
+            if (!this._container) {
+              if (this._container = h2.create("div", "maplibregl-popup", this._map.getContainer()), this._tip = h2.create("div", "maplibregl-popup-tip", this._container), this._container.appendChild(this._content), this.options.className) for (const e5 of this.options.className.split(" ")) this._container.classList.add(e5);
+              this._closeButton && this._closeButton.setAttribute("aria-label", this._map._getUIString("Popup.Close")), this._trackPointer && this._container.classList.add("maplibregl-popup-track-pointer");
+            }
+            let t3;
+            if (this.options.maxWidth && this._container.style.maxWidth !== this.options.maxWidth && (this._container.style.maxWidth = this.options.maxWidth), this._lngLat = us(this._lngLat, this._flatPos, this._map.transform, this._trackPointer), e4 && "point" in e4 && e4.point && (t3 = e4.point), this._trackPointer && !t3) return;
+            const i3 = this._flatPos = this._pos = this._trackPointer && t3 ? t3 : this._map.project(this._lngLat);
+            this._map.terrain && (this._flatPos = this._trackPointer && t3 ? t3 : this._map.transform.locationToScreenPoint(this._lngLat));
+            let o3 = this.options.anchor;
+            const a3 = Ts(this.options.offset);
+            if (!o3) {
+              const e5 = this._container.offsetWidth, t4 = this._container.offsetHeight, r4 = function(e6) {
+                var t5, i4, o4, a4;
+                return e6 ? { top: null !== (t5 = e6.top) && void 0 !== t5 ? t5 : 0, right: null !== (i4 = e6.right) && void 0 !== i4 ? i4 : 0, bottom: null !== (o4 = e6.bottom) && void 0 !== o4 ? o4 : 0, left: null !== (a4 = e6.left) && void 0 !== a4 ? a4 : 0 } : { top: 0, right: 0, bottom: 0, left: 0 };
+              }(this.options.padding);
+              let s3;
+              s3 = i3.y + a3.bottom.y < t4 + r4.top ? ["top"] : i3.y > this._map.transform.height - t4 - r4.bottom ? ["bottom"] : [], i3.x < e5 / 2 + r4.left ? s3.push("left") : i3.x > this._map.transform.width - e5 / 2 - r4.right && s3.push("right"), o3 = 0 === s3.length ? "bottom" : s3.join("-");
+            }
+            let r3 = i3.add(a3[o3]);
+            this.options.subpixelPositioning || (r3 = r3.round()), this._container.style.transform = `${ds[o3]} translate(${r3.x}px,${r3.y}px)`, _s2(this._container, o3, "popup"), this._updateOpacity();
+          }, this._onClose = () => {
+            this.remove();
+          }, this.options = t2.e(Object.create(ys), e3);
+        }
+        addTo(e3) {
+          return this._map && this.remove(), this._map = e3, this.options.closeOnClick && this._map.on("click", this._onClose), this.options.closeOnMove && this._map.on("move", this._onClose), this._map.on("remove", this.remove), this._update(), this._focusFirstElement(), this._trackPointer ? (this._map.on("mousemove", this._update), this._map.on("mouseup", this._update), this._container && this._container.classList.add("maplibregl-popup-track-pointer"), this._map._canvasContainer.classList.add("maplibregl-track-pointer")) : this._map.on("move", this._update), this.fire(new t2.l("open")), this;
+        }
+        isOpen() {
+          return !!this._map;
+        }
+        getLngLat() {
+          return this._lngLat;
+        }
+        setLngLat(e3) {
+          return this._lngLat = t2.V.convert(e3), this._pos = null, this._flatPos = null, this._trackPointer = false, this._update(), this._map && (this._map.on("move", this._update), this._map.off("mousemove", this._update), this._container && this._container.classList.remove("maplibregl-popup-track-pointer"), this._map._canvasContainer.classList.remove("maplibregl-track-pointer")), this;
+        }
+        trackPointer() {
+          return this._trackPointer = true, this._pos = null, this._flatPos = null, this._update(), this._map && (this._map.off("move", this._update), this._map.on("mousemove", this._update), this._map.on("drag", this._update), this._container && this._container.classList.add("maplibregl-popup-track-pointer"), this._map._canvasContainer.classList.add("maplibregl-track-pointer")), this;
+        }
+        getElement() {
+          return this._container;
+        }
+        setText(e3) {
+          return this.setDOMContent(document.createTextNode(e3));
+        }
+        setHTML(e3) {
+          const t3 = document.createDocumentFragment(), i3 = document.createElement("body");
+          let o3;
+          for (i3.innerHTML = e3; o3 = i3.firstChild, o3; ) t3.appendChild(o3);
+          return this.setDOMContent(t3);
+        }
+        getMaxWidth() {
+          var e3;
+          return null === (e3 = this._container) || void 0 === e3 ? void 0 : e3.style.maxWidth;
+        }
+        setMaxWidth(e3) {
+          return this.options.maxWidth = e3, this._update(), this;
+        }
+        setDOMContent(e3) {
+          if (this._content) for (; this._content.hasChildNodes(); ) this._content.firstChild && this._content.removeChild(this._content.firstChild);
+          else this._content = h2.create("div", "maplibregl-popup-content", this._container);
+          return this._content.appendChild(e3), this._createCloseButton(), this._update(), this._focusFirstElement(), this;
+        }
+        addClassName(e3) {
+          return this._container && this._container.classList.add(e3), this;
+        }
+        removeClassName(e3) {
+          return this._container && this._container.classList.remove(e3), this;
+        }
+        setOffset(e3) {
+          return this.options.offset = e3, this._update(), this;
+        }
+        toggleClassName(e3) {
+          if (this._container) return this._container.classList.toggle(e3);
+        }
+        setSubpixelPositioning(e3) {
+          this.options.subpixelPositioning = e3;
+        }
+        setPadding(e3) {
+          this.options.padding = e3, this._update();
+        }
+        _createCloseButton() {
+          this.options.closeButton && (this._closeButton = h2.create("button", "maplibregl-popup-close-button", this._content), this._closeButton.type = "button", this._closeButton.innerHTML = "&#215;", this._closeButton.addEventListener("click", this._onClose));
+        }
+        _focusFirstElement() {
+          if (!this.options.focusAfterOpen || !this._container) return;
+          const e3 = this._container.querySelector(ws);
+          e3 && e3.focus();
+        }
+      }, e2.RasterDEMTileSource = W2, e2.RasterTileSource = V2, e2.ScaleControl = class {
+        constructor(e3) {
+          this._onMove = () => {
+            xs(this._map, this._container, this.options);
+          }, this.setUnit = (e4) => {
+            this.options.unit = e4, xs(this._map, this._container, this.options);
+          }, this.options = Object.assign(Object.assign({}, vs2), e3);
+        }
+        getDefaultPosition() {
+          return "bottom-left";
+        }
+        onAdd(e3) {
+          return this._map = e3, this._container = h2.create("div", "maplibregl-ctrl maplibregl-ctrl-scale", e3.getContainer()), this._map.on("move", this._onMove), this._onMove(), this._container;
+        }
+        onRemove() {
+          this._container.remove(), this._map.off("move", this._onMove), this._map = void 0;
+        }
+      }, e2.ScrollZoomHandler = kr, e2.Style = Ai2, e2.TerrainControl = class {
+        constructor(e3) {
+          this._toggleTerrain = () => {
+            this._map.getTerrain() ? this._map.setTerrain(null) : this._map.setTerrain(this.options), this._updateTerrainIcon();
+          }, this._updateTerrainIcon = () => {
+            this._terrainButton.classList.remove("maplibregl-ctrl-terrain"), this._terrainButton.classList.remove("maplibregl-ctrl-terrain-enabled"), this._map.terrain ? (this._terrainButton.classList.add("maplibregl-ctrl-terrain-enabled"), this._terrainButton.title = this._map._getUIString("TerrainControl.Disable")) : (this._terrainButton.classList.add("maplibregl-ctrl-terrain"), this._terrainButton.title = this._map._getUIString("TerrainControl.Enable"));
+          }, this.options = e3;
+        }
+        onAdd(e3) {
+          return this._map = e3, this._container = h2.create("div", "maplibregl-ctrl maplibregl-ctrl-group"), this._terrainButton = h2.create("button", "maplibregl-ctrl-terrain", this._container), h2.create("span", "maplibregl-ctrl-icon", this._terrainButton).setAttribute("aria-hidden", "true"), this._terrainButton.type = "button", this._terrainButton.addEventListener("click", this._toggleTerrain), this._updateTerrainIcon(), this._map.on("terrain", this._updateTerrainIcon), this._container;
+        }
+        onRemove() {
+          this._container.remove(), this._map.off("terrain", this._updateTerrainIcon), this._map = void 0;
+        }
+      }, e2.TwoFingersTouchPitchHandler = Sr, e2.TwoFingersTouchRotateHandler = Mr, e2.TwoFingersTouchZoomHandler = Cr, e2.TwoFingersTouchZoomRotateHandler = Zr, e2.VectorTileSource = G2, e2.VideoSource = ee2, e2.addSourceType = (e3, i3) => t2._(void 0, void 0, void 0, function* () {
+        if (oe2(e3)) throw new Error(`A source type called "${e3}" already exists.`);
+        ((e4, t3) => {
+          ie2[e4] = t3;
+        })(e3, i3);
+      }), e2.clearPrewarmedResources = function() {
+        const e3 = z2;
+        e3 && (e3.isPreloaded() && 1 === e3.numActive() ? (e3.release(E2), z2 = null) : console.warn("Could not clear WebWorkers since there are active Map instances that still reference it. The pre-warmed WebWorker pool can only be cleared when all map instances have been removed with map.remove()"));
+      }, e2.createTileMesh = si2, e2.getMaxParallelImageRequests = function() {
+        return t2.c.MAX_PARALLEL_IMAGE_REQUESTS;
+      }, e2.getRTLTextPluginStatus = function() {
+        return ne2().getRTLTextPluginStatus();
+      }, e2.getVersion = function() {
+        return Ps;
+      }, e2.getWorkerCount = function() {
+        return S2.workerCount;
+      }, e2.getWorkerUrl = function() {
+        return t2.c.WORKER_URL;
+      }, e2.importScriptInWorkers = function(e3) {
+        return k2().broadcast("IS", e3);
+      }, e2.isTimeFrozen = function() {
+        return l2.isFrozen();
+      }, e2.now = c2, e2.prewarm = function() {
+        A2().acquire(E2);
+      }, e2.restoreNow = function() {
+        l2.restoreNow();
+      }, e2.setMaxParallelImageRequests = function(e3) {
+        t2.c.MAX_PARALLEL_IMAGE_REQUESTS = e3;
+      }, e2.setNow = function(e3) {
+        l2.setNow(e3);
+      }, e2.setRTLTextPlugin = function(e3, t3) {
+        return ne2().setRTLTextPlugin(e3, t3);
+      }, e2.setWorkerCount = function(e3) {
+        S2.workerCount = e3;
+      }, e2.setWorkerUrl = function(e3) {
+        t2.c.WORKER_URL = e3;
+      };
+    });
+    var maplibregl$1 = maplibregl2;
+    return maplibregl$1;
+  });
+})(maplibreGl);
+var maplibreGlExports = maplibreGl.exports;
+const maplibregl = /* @__PURE__ */ getDefaultExportFromCjs(maplibreGlExports);
+function assert$6(condition, message2) {
+  if (!condition) {
+    throw new Error(message2 || "loader assertion failed.");
+  }
+}
+const isBrowser$2 = (
+  // @ts-ignore process does not exist on browser
+  Boolean(typeof process !== "object" || String(process) !== "[object process]" || process.browser)
+);
+const matches$1 = typeof process !== "undefined" && process.version && /v([0-9]*)/.exec(process.version);
+matches$1 && parseFloat(matches$1[1]) || 0;
+const window_ = globalThis;
+const process_ = globalThis.process || {};
+const navigator_ = globalThis.navigator || {};
+function isElectron(mockUserAgent) {
+  var _a3, _b3;
+  if (typeof window !== "undefined" && ((_a3 = window.process) == null ? void 0 : _a3.type) === "renderer") {
+    return true;
+  }
+  if (typeof process !== "undefined" && Boolean((_b3 = process.versions) == null ? void 0 : _b3["electron"])) {
+    return true;
+  }
+  const realUserAgent = typeof navigator !== "undefined" && navigator.userAgent;
+  const userAgent2 = realUserAgent;
+  return Boolean(userAgent2 && userAgent2.indexOf("Electron") >= 0);
+}
+function isBrowser$1() {
+  const isNode = (
+    // @ts-expect-error
+    typeof process === "object" && String(process) === "[object process]" && !(process == null ? void 0 : process.browser)
+  );
+  return !isNode || isElectron();
+}
+function getBrowser(mockUserAgent) {
+  if (!isBrowser$1()) {
+    return "Node";
+  }
+  if (isElectron()) {
+    return "Electron";
+  }
+  const userAgent2 = navigator_.userAgent || "";
+  if (userAgent2.indexOf("Edge") > -1) {
+    return "Edge";
+  }
+  if (globalThis.chrome) {
+    return "Chrome";
+  }
+  if (globalThis.safari) {
+    return "Safari";
+  }
+  if (globalThis.mozInnerScreenX) {
+    return "Firefox";
+  }
+  return "Unknown";
+}
+const VERSION$4 = "4.1.1";
+function assert$5(condition, message2) {
+  if (!condition) {
+    throw new Error("Assertion failed");
+  }
+}
+function normalizeLogLevel(logLevel) {
+  if (!logLevel) {
+    return 0;
+  }
+  let resolvedLevel;
+  switch (typeof logLevel) {
+    case "number":
+      resolvedLevel = logLevel;
+      break;
+    case "object":
+      resolvedLevel = logLevel.logLevel || logLevel.priority || 0;
+      break;
+    default:
+      return 0;
+  }
+  assert$5(Number.isFinite(resolvedLevel) && resolvedLevel >= 0);
+  return resolvedLevel;
+}
+function normalizeArguments(opts) {
+  const { logLevel, message: message2 } = opts;
+  opts.logLevel = normalizeLogLevel(logLevel);
+  const args = opts.args ? Array.from(opts.args) : [];
+  while (args.length && args.shift() !== message2) {
+  }
+  switch (typeof logLevel) {
+    case "string":
+    case "function":
+      if (message2 !== void 0) {
+        args.unshift(message2);
+      }
+      opts.message = logLevel;
+      break;
+    case "object":
+      Object.assign(opts, logLevel);
+      break;
+  }
+  if (typeof opts.message === "function") {
+    opts.message = opts.message();
+  }
+  const messageType = typeof opts.message;
+  assert$5(messageType === "string" || messageType === "object");
+  return Object.assign(opts, { args }, opts.opts);
+}
+const noop$2 = () => {
+};
+class BaseLog {
+  constructor({ level = 0 } = {}) {
+    this.userData = {};
+    this._onceCache = /* @__PURE__ */ new Set();
+    this._level = level;
+  }
+  set level(newLevel) {
+    this.setLevel(newLevel);
+  }
+  get level() {
+    return this.getLevel();
+  }
+  setLevel(level) {
+    this._level = level;
+    return this;
+  }
+  getLevel() {
+    return this._level;
+  }
+  // Unconditional logging
+  warn(message2, ...args) {
+    return this._log("warn", 0, message2, args, { once: true });
+  }
+  error(message2, ...args) {
+    return this._log("error", 0, message2, args);
+  }
+  // Conditional logging
+  log(logLevel, message2, ...args) {
+    return this._log("log", logLevel, message2, args);
+  }
+  info(logLevel, message2, ...args) {
+    return this._log("info", logLevel, message2, args);
+  }
+  once(logLevel, message2, ...args) {
+    return this._log("once", logLevel, message2, args, { once: true });
+  }
+  _log(type, logLevel, message2, args, options = {}) {
+    const normalized = normalizeArguments({
+      logLevel,
+      message: message2,
+      args: this._buildArgs(logLevel, message2, args),
+      opts: options
+    });
+    return this._createLogFunction(type, normalized, options);
+  }
+  _buildArgs(logLevel, message2, args) {
+    return [logLevel, message2, ...args];
+  }
+  _createLogFunction(type, normalized, options) {
+    if (!this._shouldLog(normalized.logLevel)) {
+      return noop$2;
+    }
+    const tag = this._getOnceTag(options.tag ?? normalized.tag ?? normalized.message);
+    if ((options.once || normalized.once) && tag !== void 0) {
+      if (this._onceCache.has(tag)) {
+        return noop$2;
+      }
+      this._onceCache.add(tag);
+    }
+    return this._emit(type, normalized);
+  }
+  _shouldLog(logLevel) {
+    return this.getLevel() >= normalizeLogLevel(logLevel);
+  }
+  _getOnceTag(tag) {
+    if (tag === void 0) {
+      return void 0;
+    }
+    try {
+      return typeof tag === "string" ? tag : String(tag);
+    } catch {
+      return void 0;
+    }
+  }
+}
+function getStorage(type) {
+  try {
+    const storage = window[type];
+    const x2 = "__storage_test__";
+    storage.setItem(x2, x2);
+    storage.removeItem(x2);
+    return storage;
+  } catch (e2) {
+    return null;
+  }
+}
+class LocalStorage {
+  constructor(id2, defaultConfig, type = "sessionStorage") {
+    this.storage = getStorage(type);
+    this.id = id2;
+    this.config = defaultConfig;
+    this._loadConfiguration();
+  }
+  getConfiguration() {
+    return this.config;
+  }
+  setConfiguration(configuration) {
+    Object.assign(this.config, configuration);
+    if (this.storage) {
+      const serialized = JSON.stringify(this.config);
+      this.storage.setItem(this.id, serialized);
+    }
+  }
+  // Get config from persistent store, if available
+  _loadConfiguration() {
+    let configuration = {};
+    if (this.storage) {
+      const serializedConfiguration = this.storage.getItem(this.id);
+      configuration = serializedConfiguration ? JSON.parse(serializedConfiguration) : {};
+    }
+    Object.assign(this.config, configuration);
+    return this;
+  }
+}
+function formatTime(ms) {
+  let formatted;
+  if (ms < 10) {
+    formatted = `${ms.toFixed(2)}ms`;
+  } else if (ms < 100) {
+    formatted = `${ms.toFixed(1)}ms`;
+  } else if (ms < 1e3) {
+    formatted = `${ms.toFixed(0)}ms`;
+  } else {
+    formatted = `${(ms / 1e3).toFixed(2)}s`;
+  }
+  return formatted;
+}
+function leftPad(string, length2 = 8) {
+  const padLength = Math.max(length2 - string.length, 0);
+  return `${" ".repeat(padLength)}${string}`;
+}
+var COLOR;
+(function(COLOR2) {
+  COLOR2[COLOR2["BLACK"] = 30] = "BLACK";
+  COLOR2[COLOR2["RED"] = 31] = "RED";
+  COLOR2[COLOR2["GREEN"] = 32] = "GREEN";
+  COLOR2[COLOR2["YELLOW"] = 33] = "YELLOW";
+  COLOR2[COLOR2["BLUE"] = 34] = "BLUE";
+  COLOR2[COLOR2["MAGENTA"] = 35] = "MAGENTA";
+  COLOR2[COLOR2["CYAN"] = 36] = "CYAN";
+  COLOR2[COLOR2["WHITE"] = 37] = "WHITE";
+  COLOR2[COLOR2["BRIGHT_BLACK"] = 90] = "BRIGHT_BLACK";
+  COLOR2[COLOR2["BRIGHT_RED"] = 91] = "BRIGHT_RED";
+  COLOR2[COLOR2["BRIGHT_GREEN"] = 92] = "BRIGHT_GREEN";
+  COLOR2[COLOR2["BRIGHT_YELLOW"] = 93] = "BRIGHT_YELLOW";
+  COLOR2[COLOR2["BRIGHT_BLUE"] = 94] = "BRIGHT_BLUE";
+  COLOR2[COLOR2["BRIGHT_MAGENTA"] = 95] = "BRIGHT_MAGENTA";
+  COLOR2[COLOR2["BRIGHT_CYAN"] = 96] = "BRIGHT_CYAN";
+  COLOR2[COLOR2["BRIGHT_WHITE"] = 97] = "BRIGHT_WHITE";
+})(COLOR || (COLOR = {}));
+const BACKGROUND_INCREMENT = 10;
+function getColor(color2) {
+  if (typeof color2 !== "string") {
+    return color2;
+  }
+  color2 = color2.toUpperCase();
+  return COLOR[color2] || COLOR.WHITE;
+}
+function addColor(string, color2, background) {
+  if (!isBrowser$1 && typeof string === "string") {
+    if (color2) {
+      const colorCode = getColor(color2);
+      string = `\x1B[${colorCode}m${string}\x1B[39m`;
+    }
+    if (background) {
+      const colorCode = getColor(background);
+      string = `\x1B[${colorCode + BACKGROUND_INCREMENT}m${string}\x1B[49m`;
+    }
+  }
+  return string;
+}
+function autobind(obj, predefined = ["constructor"]) {
+  const proto = Object.getPrototypeOf(obj);
+  const propNames = Object.getOwnPropertyNames(proto);
+  const object = obj;
+  for (const key of propNames) {
+    const value = object[key];
+    if (typeof value === "function") {
+      if (!predefined.find((name2) => key === name2)) {
+        object[key] = value.bind(obj);
+      }
+    }
+  }
+}
+function getHiResTimestamp$1() {
+  var _a3, _b3, _c3;
+  let timestamp;
+  if (isBrowser$1() && window_.performance) {
+    timestamp = (_b3 = (_a3 = window_ == null ? void 0 : window_.performance) == null ? void 0 : _a3.now) == null ? void 0 : _b3.call(_a3);
+  } else if ("hrtime" in process_) {
+    const timeParts = (_c3 = process_ == null ? void 0 : process_.hrtime) == null ? void 0 : _c3.call(process_);
+    timestamp = timeParts[0] * 1e3 + timeParts[1] / 1e6;
+  } else {
+    timestamp = Date.now();
+  }
+  return timestamp;
+}
+const originalConsole = {
+  debug: isBrowser$1() ? console.debug || console.log : console.log,
+  log: console.log,
+  info: console.info,
+  warn: console.warn,
+  error: console.error
+};
+const DEFAULT_LOG_CONFIGURATION = {
+  enabled: true,
+  level: 0
+};
+class ProbeLog extends BaseLog {
+  constructor({ id: id2 } = { id: "" }) {
+    super({ level: 0 });
+    this.VERSION = VERSION$4;
+    this._startTs = getHiResTimestamp$1();
+    this._deltaTs = getHiResTimestamp$1();
+    this.userData = {};
+    this.LOG_THROTTLE_TIMEOUT = 0;
+    this.id = id2;
+    this.userData = {};
+    this._storage = new LocalStorage(`__probe-${this.id}__`, { [this.id]: DEFAULT_LOG_CONFIGURATION });
+    this.timeStamp(`${this.id} started`);
+    autobind(this);
+    Object.seal(this);
+  }
+  isEnabled() {
+    return this._getConfiguration().enabled;
+  }
+  getLevel() {
+    return this._getConfiguration().level;
+  }
+  /** @return milliseconds, with fractions */
+  getTotal() {
+    return Number((getHiResTimestamp$1() - this._startTs).toPrecision(10));
+  }
+  /** @return milliseconds, with fractions */
+  getDelta() {
+    return Number((getHiResTimestamp$1() - this._deltaTs).toPrecision(10));
+  }
+  /** @deprecated use logLevel */
+  set priority(newPriority) {
+    this.level = newPriority;
+  }
+  /** @deprecated use logLevel */
+  get priority() {
+    return this.level;
+  }
+  /** @deprecated use logLevel */
+  getPriority() {
+    return this.level;
+  }
+  // Configure
+  enable(enabled = true) {
+    this._updateConfiguration({ enabled });
+    return this;
+  }
+  setLevel(level) {
+    this._updateConfiguration({ level });
+    return this;
+  }
+  /** return the current status of the setting */
+  get(setting) {
+    return this._getConfiguration()[setting];
+  }
+  // update the status of the setting
+  set(setting, value) {
+    this._updateConfiguration({ [setting]: value });
+  }
+  /** Logs the current settings as a table */
+  settings() {
+    if (console.table) {
+      console.table(this._storage.config);
+    } else {
+      console.log(this._storage.config);
+    }
+  }
+  // Unconditional logging
+  assert(condition, message2) {
+    if (!condition) {
+      throw new Error(message2 || "Assertion failed");
+    }
+  }
+  warn(message2, ...args) {
+    return this._log("warn", 0, message2, args, {
+      method: originalConsole.warn,
+      once: true
+    });
+  }
+  error(message2, ...args) {
+    return this._log("error", 0, message2, args, {
+      method: originalConsole.error
+    });
+  }
+  /** Print a deprecation warning */
+  deprecated(oldUsage, newUsage) {
+    return this.warn(`\`${oldUsage}\` is deprecated and will be removed in a later version. Use \`${newUsage}\` instead`);
+  }
+  /** Print a removal warning */
+  removed(oldUsage, newUsage) {
+    return this.error(`\`${oldUsage}\` has been removed. Use \`${newUsage}\` instead`);
+  }
+  probe(logLevel, message2, ...args) {
+    return this._log("log", logLevel, message2, args, {
+      method: originalConsole.log,
+      time: true,
+      once: true
+    });
+  }
+  log(logLevel, message2, ...args) {
+    return this._log("log", logLevel, message2, args, {
+      method: originalConsole.debug
+    });
+  }
+  info(logLevel, message2, ...args) {
+    return this._log("info", logLevel, message2, args, { method: console.info });
+  }
+  once(logLevel, message2, ...args) {
+    return this._log("once", logLevel, message2, args, {
+      method: originalConsole.debug || originalConsole.info,
+      once: true
+    });
+  }
+  /** Logs an object as a table */
+  table(logLevel, table, columns) {
+    if (table) {
+      return this._log("table", logLevel, table, columns && [columns] || [], {
+        method: console.table || noop$2,
+        tag: getTableHeader(table)
+      });
+    }
+    return noop$2;
+  }
+  time(logLevel, message2) {
+    return this._log("time", logLevel, message2, [], {
+      method: console.time ? console.time : console.info
+    });
+  }
+  timeEnd(logLevel, message2) {
+    return this._log("time", logLevel, message2, [], {
+      method: console.timeEnd ? console.timeEnd : console.info
+    });
+  }
+  timeStamp(logLevel, message2) {
+    return this._log("time", logLevel, message2, [], {
+      method: console.timeStamp || noop$2
+    });
+  }
+  group(logLevel, message2, opts = { collapsed: false }) {
+    const method = (opts.collapsed ? console.groupCollapsed : console.group) || console.info;
+    return this._log("group", logLevel, message2, [], { method });
+  }
+  groupCollapsed(logLevel, message2, opts = {}) {
+    return this.group(logLevel, message2, Object.assign({}, opts, { collapsed: true }));
+  }
+  groupEnd(logLevel) {
+    return this._log("groupEnd", logLevel, "", [], {
+      method: console.groupEnd || noop$2
+    });
+  }
+  // EXPERIMENTAL
+  withGroup(logLevel, message2, func) {
+    this.group(logLevel, message2)();
+    try {
+      func();
+    } finally {
+      this.groupEnd(logLevel)();
+    }
+  }
+  trace() {
+    if (console.trace) {
+      console.trace();
+    }
+  }
+  _shouldLog(logLevel) {
+    return this.isEnabled() && super._shouldLog(logLevel);
+  }
+  _emit(_type, normalized) {
+    const method = normalized.method;
+    assert$5(method);
+    normalized.total = this.getTotal();
+    normalized.delta = this.getDelta();
+    this._deltaTs = getHiResTimestamp$1();
+    const message2 = decorateMessage(this.id, normalized.message, normalized);
+    return method.bind(console, message2, ...normalized.args);
+  }
+  _getConfiguration() {
+    if (!this._storage.config[this.id]) {
+      this._updateConfiguration(DEFAULT_LOG_CONFIGURATION);
+    }
+    return this._storage.config[this.id];
+  }
+  _updateConfiguration(configuration) {
+    const currentConfiguration = this._storage.config[this.id] || {
+      ...DEFAULT_LOG_CONFIGURATION
+    };
+    this._storage.setConfiguration({
+      [this.id]: { ...currentConfiguration, ...configuration }
+    });
+  }
+}
+ProbeLog.VERSION = VERSION$4;
+function decorateMessage(id2, message2, opts) {
+  if (typeof message2 === "string") {
+    const time = opts.time ? leftPad(formatTime(opts.total)) : "";
+    message2 = opts.time ? `${id2}: ${time}  ${message2}` : `${id2}: ${message2}`;
+    message2 = addColor(message2, opts.color, opts.background);
+  }
+  return message2;
+}
+function getTableHeader(table) {
+  for (const key in table) {
+    for (const title in table[key]) {
+      return title || "untitled";
+    }
+  }
+  return "empty";
+}
+const VERSION$3 = "4.3.3";
+const version = VERSION$3[0] >= "0" && VERSION$3[0] <= "9" ? `v${VERSION$3}` : "";
+function createLog() {
+  const log3 = new ProbeLog({ id: "loaders.gl" });
+  globalThis.loaders = globalThis.loaders || {};
+  globalThis.loaders.log = log3;
+  globalThis.loaders.version = version;
+  globalThis.probe = globalThis.probe || {};
+  globalThis.probe.loaders = log3;
+  return log3;
+}
+const log$1 = createLog();
+function mergeLoaderOptions(baseOptions, newOptions) {
+  return mergeOptionsRecursively(baseOptions || {}, newOptions);
+}
+function mergeOptionsRecursively(baseOptions, newOptions, level = 0) {
+  if (level > 3) {
+    return newOptions;
+  }
+  const options = { ...baseOptions };
+  for (const [key, newValue] of Object.entries(newOptions)) {
+    if (newValue && typeof newValue === "object" && !Array.isArray(newValue)) {
+      options[key] = mergeOptionsRecursively(options[key] || {}, newOptions[key], level + 1);
+    } else {
+      options[key] = newOptions[key];
+    }
+  }
+  return options;
+}
+const NPM_TAG = "latest";
+function getVersion() {
+  var _a3;
+  if (!((_a3 = globalThis._loadersgl_) == null ? void 0 : _a3.version)) {
+    globalThis._loadersgl_ = globalThis._loadersgl_ || {};
+    {
+      globalThis._loadersgl_.version = "4.3.3";
+    }
+  }
+  return globalThis._loadersgl_.version;
+}
+const VERSION$2 = getVersion();
+function assert$4(condition, message2) {
+  if (!condition) {
+    throw new Error(message2 || "loaders.gl assertion failed.");
+  }
+}
+const isBrowser = (
+  // @ts-ignore process.browser
+  typeof process !== "object" || String(process) !== "[object process]" || process.browser
+);
+const isMobile = typeof window !== "undefined" && typeof window.orientation !== "undefined";
+const matches = typeof process !== "undefined" && process.version && /v([0-9]*)/.exec(process.version);
+matches && parseFloat(matches[1]) || 0;
+class WorkerJob {
+  constructor(jobName, workerThread) {
+    __publicField(this, "name");
+    __publicField(this, "workerThread");
+    __publicField(this, "isRunning", true);
+    /** Promise that resolves when Job is done */
+    __publicField(this, "result");
+    __publicField(this, "_resolve", () => {
+    });
+    __publicField(this, "_reject", () => {
+    });
+    this.name = jobName;
+    this.workerThread = workerThread;
+    this.result = new Promise((resolve, reject) => {
+      this._resolve = resolve;
+      this._reject = reject;
+    });
+  }
+  /**
+   * Send a message to the job's worker thread
+   * @param data any data structure, ideally consisting mostly of transferrable objects
+   */
+  postMessage(type, payload) {
+    this.workerThread.postMessage({
+      source: "loaders.gl",
+      // Lets worker ignore unrelated messages
+      type,
+      payload
+    });
+  }
+  /**
+   * Call to resolve the `result` Promise with the supplied value
+   */
+  done(value) {
+    assert$4(this.isRunning);
+    this.isRunning = false;
+    this._resolve(value);
+  }
+  /**
+   * Call to reject the `result` Promise with the supplied error
+   */
+  error(error) {
+    assert$4(this.isRunning);
+    this.isRunning = false;
+    this._reject(error);
+  }
+}
+class NodeWorker {
+  terminate() {
+  }
+}
+const workerURLCache = /* @__PURE__ */ new Map();
+function getLoadableWorkerURL(props) {
+  assert$4(props.source && !props.url || !props.source && props.url);
+  let workerURL = workerURLCache.get(props.source || props.url);
+  if (!workerURL) {
+    if (props.url) {
+      workerURL = getLoadableWorkerURLFromURL(props.url);
+      workerURLCache.set(props.url, workerURL);
+    }
+    if (props.source) {
+      workerURL = getLoadableWorkerURLFromSource(props.source);
+      workerURLCache.set(props.source, workerURL);
+    }
+  }
+  assert$4(workerURL);
+  return workerURL;
+}
+function getLoadableWorkerURLFromURL(url) {
+  if (!url.startsWith("http")) {
+    return url;
+  }
+  const workerSource = buildScriptSource(url);
+  return getLoadableWorkerURLFromSource(workerSource);
+}
+function getLoadableWorkerURLFromSource(workerSource) {
+  const blob = new Blob([workerSource], { type: "application/javascript" });
+  return URL.createObjectURL(blob);
+}
+function buildScriptSource(workerUrl) {
+  return `try {
+  importScripts('${workerUrl}');
+} catch (error) {
+  console.error(error);
+  throw error;
+}`;
+}
+function getTransferList(object, recursive = true, transfers) {
+  const transfersSet = transfers || /* @__PURE__ */ new Set();
+  if (!object) ;
+  else if (isTransferable(object)) {
+    transfersSet.add(object);
+  } else if (isTransferable(object.buffer)) {
+    transfersSet.add(object.buffer);
+  } else if (ArrayBuffer.isView(object)) ;
+  else if (recursive && typeof object === "object") {
+    for (const key in object) {
+      getTransferList(object[key], recursive, transfersSet);
+    }
+  }
+  return transfers === void 0 ? Array.from(transfersSet) : [];
+}
+function isTransferable(object) {
+  if (!object) {
+    return false;
+  }
+  if (object instanceof ArrayBuffer) {
+    return true;
+  }
+  if (typeof MessagePort !== "undefined" && object instanceof MessagePort) {
+    return true;
+  }
+  if (typeof ImageBitmap !== "undefined" && object instanceof ImageBitmap) {
+    return true;
+  }
+  if (typeof OffscreenCanvas !== "undefined" && object instanceof OffscreenCanvas) {
+    return true;
+  }
+  return false;
+}
+const NOOP = () => {
+};
+class WorkerThread {
+  constructor(props) {
+    __publicField(this, "name");
+    __publicField(this, "source");
+    __publicField(this, "url");
+    __publicField(this, "terminated", false);
+    __publicField(this, "worker");
+    __publicField(this, "onMessage");
+    __publicField(this, "onError");
+    __publicField(this, "_loadableURL", "");
+    const { name: name2, source: source2, url } = props;
+    assert$4(source2 || url);
+    this.name = name2;
+    this.source = source2;
+    this.url = url;
+    this.onMessage = NOOP;
+    this.onError = (error) => console.log(error);
+    this.worker = isBrowser ? this._createBrowserWorker() : this._createNodeWorker();
+  }
+  /** Checks if workers are supported on this platform */
+  static isSupported() {
+    return typeof Worker !== "undefined" && isBrowser || typeof NodeWorker !== "undefined" && !isBrowser;
+  }
+  /**
+   * Terminate this worker thread
+   * @note Can free up significant memory
+   */
+  destroy() {
+    this.onMessage = NOOP;
+    this.onError = NOOP;
+    this.worker.terminate();
+    this.terminated = true;
+  }
+  get isRunning() {
+    return Boolean(this.onMessage);
+  }
+  /**
+   * Send a message to this worker thread
+   * @param data any data structure, ideally consisting mostly of transferrable objects
+   * @param transferList If not supplied, calculated automatically by traversing data
+   */
+  postMessage(data, transferList) {
+    transferList = transferList || getTransferList(data);
+    this.worker.postMessage(data, transferList);
+  }
+  // PRIVATE
+  /**
+   * Generate a standard Error from an ErrorEvent
+   * @param event
+   */
+  _getErrorFromErrorEvent(event) {
+    let message2 = "Failed to load ";
+    message2 += `worker ${this.name} from ${this.url}. `;
+    if (event.message) {
+      message2 += `${event.message} in `;
+    }
+    if (event.lineno) {
+      message2 += `:${event.lineno}:${event.colno}`;
+    }
+    return new Error(message2);
+  }
+  /**
+   * Creates a worker thread on the browser
+   */
+  _createBrowserWorker() {
+    this._loadableURL = getLoadableWorkerURL({ source: this.source, url: this.url });
+    const worker = new Worker(this._loadableURL, { name: this.name });
+    worker.onmessage = (event) => {
+      if (!event.data) {
+        this.onError(new Error("No data received"));
+      } else {
+        this.onMessage(event.data);
+      }
+    };
+    worker.onerror = (error) => {
+      this.onError(this._getErrorFromErrorEvent(error));
+      this.terminated = true;
+    };
+    worker.onmessageerror = (event) => console.error(event);
+    return worker;
+  }
+  /**
+   * Creates a worker thread in node.js
+   * @todo https://nodejs.org/api/async_hooks.html#async-resource-worker-pool
+   */
+  _createNodeWorker() {
+    let worker;
+    if (this.url) {
+      const absolute = this.url.includes(":/") || this.url.startsWith("/");
+      const url = absolute ? this.url : `./${this.url}`;
+      worker = new NodeWorker(url, { eval: false });
+    } else if (this.source) {
+      worker = new NodeWorker(this.source, { eval: true });
+    } else {
+      throw new Error("no worker");
+    }
+    worker.on("message", (data) => {
+      this.onMessage(data);
+    });
+    worker.on("error", (error) => {
+      this.onError(error);
+    });
+    worker.on("exit", (code) => {
+    });
+    return worker;
+  }
+}
+class WorkerPool {
+  /**
+   * @param processor - worker function
+   * @param maxConcurrency - max count of workers
+   */
+  constructor(props) {
+    __publicField(this, "name", "unnamed");
+    __publicField(this, "source");
+    // | Function;
+    __publicField(this, "url");
+    __publicField(this, "maxConcurrency", 1);
+    __publicField(this, "maxMobileConcurrency", 1);
+    __publicField(this, "onDebug", () => {
+    });
+    __publicField(this, "reuseWorkers", true);
+    __publicField(this, "props", {});
+    __publicField(this, "jobQueue", []);
+    __publicField(this, "idleQueue", []);
+    __publicField(this, "count", 0);
+    __publicField(this, "isDestroyed", false);
+    this.source = props.source;
+    this.url = props.url;
+    this.setProps(props);
+  }
+  /** Checks if workers are supported on this platform */
+  static isSupported() {
+    return WorkerThread.isSupported();
+  }
+  /**
+   * Terminates all workers in the pool
+   * @note Can free up significant memory
+   */
+  destroy() {
+    this.idleQueue.forEach((worker) => worker.destroy());
+    this.isDestroyed = true;
+  }
+  setProps(props) {
+    this.props = { ...this.props, ...props };
+    if (props.name !== void 0) {
+      this.name = props.name;
+    }
+    if (props.maxConcurrency !== void 0) {
+      this.maxConcurrency = props.maxConcurrency;
+    }
+    if (props.maxMobileConcurrency !== void 0) {
+      this.maxMobileConcurrency = props.maxMobileConcurrency;
+    }
+    if (props.reuseWorkers !== void 0) {
+      this.reuseWorkers = props.reuseWorkers;
+    }
+    if (props.onDebug !== void 0) {
+      this.onDebug = props.onDebug;
+    }
+  }
+  async startJob(name2, onMessage2 = (job, type, data) => job.done(data), onError = (job, error) => job.error(error)) {
+    const startPromise = new Promise((onStart) => {
+      this.jobQueue.push({ name: name2, onMessage: onMessage2, onError, onStart });
+      return this;
+    });
+    this._startQueuedJob();
+    return await startPromise;
+  }
+  // PRIVATE
+  /**
+   * Starts first queued job if worker is available or can be created
+   * Called when job is started and whenever a worker returns to the idleQueue
+   */
+  async _startQueuedJob() {
+    if (!this.jobQueue.length) {
+      return;
+    }
+    const workerThread = this._getAvailableWorker();
+    if (!workerThread) {
+      return;
+    }
+    const queuedJob = this.jobQueue.shift();
+    if (queuedJob) {
+      this.onDebug({
+        message: "Starting job",
+        name: queuedJob.name,
+        workerThread,
+        backlog: this.jobQueue.length
+      });
+      const job = new WorkerJob(queuedJob.name, workerThread);
+      workerThread.onMessage = (data) => queuedJob.onMessage(job, data.type, data.payload);
+      workerThread.onError = (error) => queuedJob.onError(job, error);
+      queuedJob.onStart(job);
+      try {
+        await job.result;
+      } catch (error) {
+        console.error(`Worker exception: ${error}`);
+      } finally {
+        this.returnWorkerToQueue(workerThread);
+      }
+    }
+  }
+  /**
+   * Returns a worker to the idle queue
+   * Destroys the worker if
+   *  - pool is destroyed
+   *  - if this pool doesn't reuse workers
+   *  - if maxConcurrency has been lowered
+   * @param worker
+   */
+  returnWorkerToQueue(worker) {
+    const shouldDestroyWorker = (
+      // Workers on Node.js prevent the process from exiting.
+      // Until we figure out how to close them before exit, we always destroy them
+      !isBrowser || // If the pool is destroyed, there is no reason to keep the worker around
+      this.isDestroyed || // If the app has disabled worker reuse, any completed workers should be destroyed
+      !this.reuseWorkers || // If concurrency has been lowered, this worker might be surplus to requirements
+      this.count > this._getMaxConcurrency()
+    );
+    if (shouldDestroyWorker) {
+      worker.destroy();
+      this.count--;
+    } else {
+      this.idleQueue.push(worker);
+    }
+    if (!this.isDestroyed) {
+      this._startQueuedJob();
+    }
+  }
+  /**
+   * Returns idle worker or creates new worker if maxConcurrency has not been reached
+   */
+  _getAvailableWorker() {
+    if (this.idleQueue.length > 0) {
+      return this.idleQueue.shift() || null;
+    }
+    if (this.count < this._getMaxConcurrency()) {
+      this.count++;
+      const name2 = `${this.name.toLowerCase()} (#${this.count} of ${this.maxConcurrency})`;
+      return new WorkerThread({ name: name2, source: this.source, url: this.url });
+    }
+    return null;
+  }
+  _getMaxConcurrency() {
+    return isMobile ? this.maxMobileConcurrency : this.maxConcurrency;
+  }
+}
+const DEFAULT_PROPS$1 = {
+  maxConcurrency: 3,
+  maxMobileConcurrency: 1,
+  reuseWorkers: true,
+  onDebug: () => {
+  }
+};
+const _WorkerFarm = class _WorkerFarm {
+  /** get global instance with WorkerFarm.getWorkerFarm() */
+  constructor(props) {
+    __publicField(this, "props");
+    __publicField(this, "workerPools", /* @__PURE__ */ new Map());
+    this.props = { ...DEFAULT_PROPS$1 };
+    this.setProps(props);
+    this.workerPools = /* @__PURE__ */ new Map();
+  }
+  /** Checks if workers are supported on this platform */
+  static isSupported() {
+    return WorkerThread.isSupported();
+  }
+  /** Get the singleton instance of the global worker farm */
+  static getWorkerFarm(props = {}) {
+    _WorkerFarm._workerFarm = _WorkerFarm._workerFarm || new _WorkerFarm({});
+    _WorkerFarm._workerFarm.setProps(props);
+    return _WorkerFarm._workerFarm;
+  }
+  /**
+   * Terminate all workers in the farm
+   * @note Can free up significant memory
+   */
+  destroy() {
+    for (const workerPool of this.workerPools.values()) {
+      workerPool.destroy();
+    }
+    this.workerPools = /* @__PURE__ */ new Map();
+  }
+  /**
+   * Set props used when initializing worker pools
+   * @param props
+   */
+  setProps(props) {
+    this.props = { ...this.props, ...props };
+    for (const workerPool of this.workerPools.values()) {
+      workerPool.setProps(this._getWorkerPoolProps());
+    }
+  }
+  /**
+   * Returns a worker pool for the specified worker
+   * @param options - only used first time for a specific worker name
+   * @param options.name - the name of the worker - used to identify worker pool
+   * @param options.url -
+   * @param options.source -
+   * @example
+   *   const job = WorkerFarm.getWorkerFarm().getWorkerPool({name, url}).startJob(...);
+   */
+  getWorkerPool(options) {
+    const { name: name2, source: source2, url } = options;
+    let workerPool = this.workerPools.get(name2);
+    if (!workerPool) {
+      workerPool = new WorkerPool({
+        name: name2,
+        source: source2,
+        url
+      });
+      workerPool.setProps(this._getWorkerPoolProps());
+      this.workerPools.set(name2, workerPool);
+    }
+    return workerPool;
+  }
+  _getWorkerPoolProps() {
+    return {
+      maxConcurrency: this.props.maxConcurrency,
+      maxMobileConcurrency: this.props.maxMobileConcurrency,
+      reuseWorkers: this.props.reuseWorkers,
+      onDebug: this.props.onDebug
+    };
+  }
+};
+// singleton
+__publicField(_WorkerFarm, "_workerFarm");
+let WorkerFarm = _WorkerFarm;
+function getWorkerURL(worker, options = {}) {
+  const workerOptions = options[worker.id] || {};
+  const workerFile = isBrowser ? `${worker.id}-worker.js` : `${worker.id}-worker-node.js`;
+  let url = workerOptions.workerUrl;
+  if (!url && worker.id === "compression") {
+    url = options.workerUrl;
+  }
+  if (options._workerType === "test") {
+    if (isBrowser) {
+      url = `modules/${worker.module}/dist/${workerFile}`;
+    } else {
+      url = `modules/${worker.module}/src/workers/${worker.id}-worker-node.ts`;
+    }
+  }
+  if (!url) {
+    let version2 = worker.version;
+    if (version2 === "latest") {
+      version2 = NPM_TAG;
+    }
+    const versionTag = version2 ? `@${version2}` : "";
+    url = `https://unpkg.com/@loaders.gl/${worker.module}${versionTag}/dist/${workerFile}`;
+  }
+  assert$4(url);
+  return url;
+}
+function validateWorkerVersion(worker, coreVersion = VERSION$2) {
+  assert$4(worker, "no worker provided");
+  const workerVersion = worker.version;
+  if (!coreVersion || !workerVersion) {
+    return false;
+  }
+  return true;
+}
+function canParseWithWorker(loader, options) {
+  if (!WorkerFarm.isSupported()) {
+    return false;
+  }
+  if (!isBrowser && !(options == null ? void 0 : options._nodeWorkers)) {
+    return false;
+  }
+  return loader.worker && (options == null ? void 0 : options.worker);
+}
+async function parseWithWorker(loader, data, options, context, parseOnMainThread) {
+  const name2 = loader.id;
+  const url = getWorkerURL(loader, options);
+  const workerFarm = WorkerFarm.getWorkerFarm(options);
+  const workerPool = workerFarm.getWorkerPool({ name: name2, url });
+  options = JSON.parse(JSON.stringify(options));
+  context = JSON.parse(JSON.stringify(context || {}));
+  const job = await workerPool.startJob(
+    "process-on-worker",
+    // @ts-expect-error
+    onMessage.bind(null, parseOnMainThread)
+    // eslint-disable-line @typescript-eslint/no-misused-promises
+  );
+  job.postMessage("process", {
+    // @ts-ignore
+    input: data,
+    options,
+    context
+  });
+  const result = await job.result;
+  return await result.result;
+}
+async function onMessage(parseOnMainThread, job, type, payload) {
+  switch (type) {
+    case "done":
+      job.done(payload);
+      break;
+    case "error":
+      job.error(new Error(payload.error));
+      break;
+    case "process":
+      const { id: id2, input, options } = payload;
+      try {
+        const result = await parseOnMainThread(input, options);
+        job.postMessage("done", { id: id2, result });
+      } catch (error) {
+        const message2 = error instanceof Error ? error.message : "unknown error";
+        job.postMessage("error", { id: id2, error: message2 });
+      }
+      break;
+    default:
+      console.warn(`parse-with-worker unknown message ${type}`);
+  }
+}
+function compareArrayBuffers(arrayBuffer1, arrayBuffer2, byteLength) {
+  byteLength = byteLength || arrayBuffer1.byteLength;
+  if (arrayBuffer1.byteLength < byteLength || arrayBuffer2.byteLength < byteLength) {
+    return false;
+  }
+  const array1 = new Uint8Array(arrayBuffer1);
+  const array2 = new Uint8Array(arrayBuffer2);
+  for (let i2 = 0; i2 < array1.length; ++i2) {
+    if (array1[i2] !== array2[i2]) {
+      return false;
+    }
+  }
+  return true;
+}
+function concatenateArrayBuffers(...sources) {
+  return concatenateArrayBuffersFromArray(sources);
+}
+function concatenateArrayBuffersFromArray(sources) {
+  const sourceArrays = sources.map((source2) => source2 instanceof ArrayBuffer ? new Uint8Array(source2) : source2);
+  const byteLength = sourceArrays.reduce((length2, typedArray) => length2 + typedArray.byteLength, 0);
+  const result = new Uint8Array(byteLength);
+  let offset = 0;
+  for (const sourceArray of sourceArrays) {
+    result.set(sourceArray, offset);
+    offset += sourceArray.byteLength;
+  }
+  return result.buffer;
+}
+async function concatenateArrayBuffersAsync(asyncIterator) {
+  const arrayBuffers = [];
+  for await (const chunk of asyncIterator) {
+    arrayBuffers.push(chunk);
+  }
+  return concatenateArrayBuffers(...arrayBuffers);
+}
+function getHiResTimestamp() {
+  let timestamp;
+  if (typeof window !== "undefined" && window.performance) {
+    timestamp = window.performance.now();
+  } else if (typeof process !== "undefined" && process.hrtime) {
+    const timeParts = process.hrtime();
+    timestamp = timeParts[0] * 1e3 + timeParts[1] / 1e6;
+  } else {
+    timestamp = Date.now();
+  }
+  return timestamp;
+}
+class Stat {
+  constructor(name2, type) {
+    this.sampleSize = 1;
+    this.time = 0;
+    this.count = 0;
+    this.samples = 0;
+    this.lastTiming = 0;
+    this.lastSampleTime = 0;
+    this.lastSampleCount = 0;
+    this._count = 0;
+    this._time = 0;
+    this._samples = 0;
+    this._startTime = 0;
+    this._timerPending = false;
+    this.name = name2;
+    this.type = type;
+    this.reset();
+  }
+  reset() {
+    this.time = 0;
+    this.count = 0;
+    this.samples = 0;
+    this.lastTiming = 0;
+    this.lastSampleTime = 0;
+    this.lastSampleCount = 0;
+    this._count = 0;
+    this._time = 0;
+    this._samples = 0;
+    this._startTime = 0;
+    this._timerPending = false;
+    return this;
+  }
+  setSampleSize(samples) {
+    this.sampleSize = samples;
+    return this;
+  }
+  /** Call to increment count (+1) */
+  incrementCount() {
+    this.addCount(1);
+    return this;
+  }
+  /** Call to decrement count (-1) */
+  decrementCount() {
+    this.subtractCount(1);
+    return this;
+  }
+  /** Increase count */
+  addCount(value) {
+    this._count += value;
+    this._samples++;
+    this._checkSampling();
+    return this;
+  }
+  /** Decrease count */
+  subtractCount(value) {
+    this._count -= value;
+    this._samples++;
+    this._checkSampling();
+    return this;
+  }
+  /** Add an arbitrary timing and bump the count */
+  addTime(time) {
+    this._time += time;
+    this.lastTiming = time;
+    this._samples++;
+    this._checkSampling();
+    return this;
+  }
+  /** Start a timer */
+  timeStart() {
+    this._startTime = getHiResTimestamp();
+    this._timerPending = true;
+    return this;
+  }
+  /** End a timer. Adds to time and bumps the timing count. */
+  timeEnd() {
+    if (!this._timerPending) {
+      return this;
+    }
+    this.addTime(getHiResTimestamp() - this._startTime);
+    this._timerPending = false;
+    this._checkSampling();
+    return this;
+  }
+  getSampleAverageCount() {
+    return this.sampleSize > 0 ? this.lastSampleCount / this.sampleSize : 0;
+  }
+  /** Calculate average time / count for the previous window */
+  getSampleAverageTime() {
+    return this.sampleSize > 0 ? this.lastSampleTime / this.sampleSize : 0;
+  }
+  /** Calculate counts per second for the previous window */
+  getSampleHz() {
+    return this.lastSampleTime > 0 ? this.sampleSize / (this.lastSampleTime / 1e3) : 0;
+  }
+  getAverageCount() {
+    return this.samples > 0 ? this.count / this.samples : 0;
+  }
+  /** Calculate average time / count */
+  getAverageTime() {
+    return this.samples > 0 ? this.time / this.samples : 0;
+  }
+  /** Calculate counts per second */
+  getHz() {
+    return this.time > 0 ? this.samples / (this.time / 1e3) : 0;
+  }
+  _checkSampling() {
+    if (this._samples === this.sampleSize) {
+      this.lastSampleTime = this._time;
+      this.lastSampleCount = this._count;
+      this.count += this._count;
+      this.time += this._time;
+      this.samples += this._samples;
+      this._time = 0;
+      this._count = 0;
+      this._samples = 0;
+    }
+  }
+}
+class Stats {
+  constructor(options) {
+    this.stats = {};
+    this.id = options.id;
+    this.stats = {};
+    this._initializeStats(options.stats);
+    Object.seal(this);
+  }
+  /** Acquire a stat. Create if it doesn't exist. */
+  get(name2, type = "count") {
+    return this._getOrCreate({ name: name2, type });
+  }
+  get size() {
+    return Object.keys(this.stats).length;
+  }
+  /** Reset all stats */
+  reset() {
+    for (const stat of Object.values(this.stats)) {
+      stat.reset();
+    }
+    return this;
+  }
+  forEach(fn) {
+    for (const stat of Object.values(this.stats)) {
+      fn(stat);
+    }
+  }
+  getTable() {
+    const table = {};
+    this.forEach((stat) => {
+      table[stat.name] = {
+        time: stat.time || 0,
+        count: stat.count || 0,
+        average: stat.getAverageTime() || 0,
+        hz: stat.getHz() || 0
+      };
+    });
+    return table;
+  }
+  _initializeStats(stats = []) {
+    stats.forEach((stat) => this._getOrCreate(stat));
+  }
+  _getOrCreate(stat) {
+    const { name: name2, type } = stat;
+    let result = this.stats[name2];
+    if (!result) {
+      if (stat instanceof Stat) {
+        result = stat;
+      } else {
+        result = new Stat(name2, type);
+      }
+      this.stats[name2] = result;
+    }
+    return result;
+  }
+}
+let pathPrefix$1 = "";
+const fileAliases = {};
+function resolvePath(filename2) {
+  for (const alias in fileAliases) {
+    if (filename2.startsWith(alias)) {
+      const replacement = fileAliases[alias];
+      filename2 = filename2.replace(alias, replacement);
+    }
+  }
+  if (!filename2.startsWith("http://") && !filename2.startsWith("https://")) {
+    filename2 = `${pathPrefix$1}${filename2}`;
+  }
+  return filename2;
+}
+function toArrayBuffer$1(buffer) {
+  return buffer;
+}
+function isBuffer$1(value) {
+  return value && typeof value === "object" && value.isBuffer;
+}
+function toArrayBuffer(data) {
+  if (isBuffer$1(data)) {
+    return toArrayBuffer$1(data);
+  }
+  if (data instanceof ArrayBuffer) {
+    return data;
+  }
+  if (ArrayBuffer.isView(data)) {
+    if (data.byteOffset === 0 && data.byteLength === data.buffer.byteLength) {
+      return data.buffer;
+    }
+    return data.buffer.slice(data.byteOffset, data.byteOffset + data.byteLength);
+  }
+  if (typeof data === "string") {
+    const text = data;
+    const uint8Array = new TextEncoder().encode(text);
+    return uint8Array.buffer;
+  }
+  if (data && typeof data === "object" && data._toArrayBuffer) {
+    return data._toArrayBuffer();
+  }
+  throw new Error("toArrayBuffer");
+}
+function filename(url) {
+  const slashIndex = url ? url.lastIndexOf("/") : -1;
+  return slashIndex >= 0 ? url.substr(slashIndex + 1) : "";
+}
+function dirname(url) {
+  const slashIndex = url ? url.lastIndexOf("/") : -1;
+  return slashIndex >= 0 ? url.substr(0, slashIndex) : "";
+}
+const isBoolean = (x2) => typeof x2 === "boolean";
+const isFunction = (x2) => typeof x2 === "function";
+const isObject$1 = (x2) => x2 !== null && typeof x2 === "object";
+const isPureObject = (x2) => isObject$1(x2) && x2.constructor === {}.constructor;
+const isIterable = (x2) => Boolean(x2) && typeof x2[Symbol.iterator] === "function";
+const isAsyncIterable$1 = (x2) => x2 && typeof x2[Symbol.asyncIterator] === "function";
+const isResponse = (x2) => typeof Response !== "undefined" && x2 instanceof Response || x2 && x2.arrayBuffer && x2.text && x2.json;
+const isBlob = (x2) => typeof Blob !== "undefined" && x2 instanceof Blob;
+const isBuffer = (x2) => x2 && typeof x2 === "object" && x2.isBuffer;
+const isReadableDOMStream = (x2) => typeof ReadableStream !== "undefined" && x2 instanceof ReadableStream || isObject$1(x2) && isFunction(x2.tee) && isFunction(x2.cancel) && isFunction(x2.getReader);
+const isReadableNodeStream = (x2) => isObject$1(x2) && isFunction(x2.read) && isFunction(x2.pipe) && isBoolean(x2.readable);
+const isReadableStream = (x2) => isReadableDOMStream(x2) || isReadableNodeStream(x2);
+class FetchError extends Error {
+  constructor(message2, info) {
+    super(message2);
+    /** A best effort reason for why the fetch failed */
+    __publicField(this, "reason");
+    /** The URL that failed to load. Empty string if not available. */
+    __publicField(this, "url");
+    /** The Response object, if any. */
+    __publicField(this, "response");
+    this.reason = info.reason;
+    this.url = info.url;
+    this.response = info.response;
+  }
+}
+const DATA_URL_PATTERN = /^data:([-\w.]+\/[-\w.+]+)(;|,)/;
+const MIME_TYPE_PATTERN = /^([-\w.]+\/[-\w.+]+)/;
+function compareMIMETypes(mimeType1, mimeType2) {
+  if (mimeType1.toLowerCase() === mimeType2.toLowerCase()) {
+    return true;
+  }
+  return false;
+}
+function parseMIMEType(mimeString) {
+  const matches2 = MIME_TYPE_PATTERN.exec(mimeString);
+  if (matches2) {
+    return matches2[1];
+  }
+  return mimeString;
+}
+function parseMIMETypeFromURL(url) {
+  const matches2 = DATA_URL_PATTERN.exec(url);
+  if (matches2) {
+    return matches2[1];
+  }
+  return "";
+}
+const QUERY_STRING_PATTERN = /\?.*/;
+function extractQueryString(url) {
+  const matches2 = url.match(QUERY_STRING_PATTERN);
+  return matches2 && matches2[0];
+}
+function stripQueryString(url) {
+  return url.replace(QUERY_STRING_PATTERN, "");
+}
+function shortenUrlForDisplay(url) {
+  if (url.length < 50) {
+    return url;
+  }
+  const urlEnd = url.slice(url.length - 15);
+  const urlStart = url.substr(0, 32);
+  return `${urlStart}...${urlEnd}`;
+}
+function getResourceUrl(resource) {
+  if (isResponse(resource)) {
+    const response = resource;
+    return response.url;
+  }
+  if (isBlob(resource)) {
+    const blob = resource;
+    return blob.name || "";
+  }
+  if (typeof resource === "string") {
+    return resource;
+  }
+  return "";
+}
+function getResourceMIMEType(resource) {
+  if (isResponse(resource)) {
+    const response = resource;
+    const contentTypeHeader = response.headers.get("content-type") || "";
+    const noQueryUrl = stripQueryString(response.url);
+    return parseMIMEType(contentTypeHeader) || parseMIMETypeFromURL(noQueryUrl);
+  }
+  if (isBlob(resource)) {
+    const blob = resource;
+    return blob.type || "";
+  }
+  if (typeof resource === "string") {
+    return parseMIMETypeFromURL(resource);
+  }
+  return "";
+}
+function getResourceContentLength(resource) {
+  if (isResponse(resource)) {
+    const response = resource;
+    return response.headers["content-length"] || -1;
+  }
+  if (isBlob(resource)) {
+    const blob = resource;
+    return blob.size;
+  }
+  if (typeof resource === "string") {
+    return resource.length;
+  }
+  if (resource instanceof ArrayBuffer) {
+    return resource.byteLength;
+  }
+  if (ArrayBuffer.isView(resource)) {
+    return resource.byteLength;
+  }
+  return -1;
+}
+async function makeResponse(resource) {
+  if (isResponse(resource)) {
+    return resource;
+  }
+  const headers = {};
+  const contentLength = getResourceContentLength(resource);
+  if (contentLength >= 0) {
+    headers["content-length"] = String(contentLength);
+  }
+  const url = getResourceUrl(resource);
+  const type = getResourceMIMEType(resource);
+  if (type) {
+    headers["content-type"] = type;
+  }
+  const initialDataUrl = await getInitialDataUrl(resource);
+  if (initialDataUrl) {
+    headers["x-first-bytes"] = initialDataUrl;
+  }
+  if (typeof resource === "string") {
+    resource = new TextEncoder().encode(resource);
+  }
+  const response = new Response(resource, { headers });
+  Object.defineProperty(response, "url", { value: url });
+  return response;
+}
+async function checkResponse(response) {
+  if (!response.ok) {
+    const error = await getResponseError(response);
+    throw error;
+  }
+}
+async function getResponseError(response) {
+  const shortUrl = shortenUrlForDisplay(response.url);
+  let message2 = `Failed to fetch resource (${response.status}) ${response.statusText}: ${shortUrl}`;
+  message2 = message2.length > 100 ? `${message2.slice(0, 100)}...` : message2;
+  const info = {
+    reason: response.statusText,
+    url: response.url,
+    response
+  };
+  try {
+    const contentType = response.headers.get("Content-Type");
+    info.reason = !response.bodyUsed && (contentType == null ? void 0 : contentType.includes("application/json")) ? await response.json() : await response.text();
+  } catch (error) {
+  }
+  return new FetchError(message2, info);
+}
+async function getInitialDataUrl(resource) {
+  const INITIAL_DATA_LENGTH = 5;
+  if (typeof resource === "string") {
+    return `data:,${resource.slice(0, INITIAL_DATA_LENGTH)}`;
+  }
+  if (resource instanceof Blob) {
+    const blobSlice = resource.slice(0, 5);
+    return await new Promise((resolve) => {
+      const reader = new FileReader();
+      reader.onload = (event) => {
+        var _a3;
+        return resolve((_a3 = event == null ? void 0 : event.target) == null ? void 0 : _a3.result);
+      };
+      reader.readAsDataURL(blobSlice);
+    });
+  }
+  if (resource instanceof ArrayBuffer) {
+    const slice = resource.slice(0, INITIAL_DATA_LENGTH);
+    const base64 = arrayBufferToBase64(slice);
+    return `data:base64,${base64}`;
+  }
+  return null;
+}
+function arrayBufferToBase64(buffer) {
+  let binary = "";
+  const bytes = new Uint8Array(buffer);
+  for (let i2 = 0; i2 < bytes.byteLength; i2++) {
+    binary += String.fromCharCode(bytes[i2]);
+  }
+  return btoa(binary);
+}
+function isNodePath(url) {
+  return !isRequestURL(url) && !isDataURL(url);
+}
+function isRequestURL(url) {
+  return url.startsWith("http:") || url.startsWith("https:");
+}
+function isDataURL(url) {
+  return url.startsWith("data:");
+}
+async function fetchFile(urlOrData, fetchOptions) {
+  var _a3, _b3;
+  if (typeof urlOrData === "string") {
+    const url = resolvePath(urlOrData);
+    if (isNodePath(url)) {
+      if ((_a3 = globalThis.loaders) == null ? void 0 : _a3.fetchNode) {
+        return (_b3 = globalThis.loaders) == null ? void 0 : _b3.fetchNode(url, fetchOptions);
+      }
+    }
+    return await fetch(url, fetchOptions);
+  }
+  return await makeResponse(urlOrData);
+}
+const probeLog = new ProbeLog({ id: "loaders.gl" });
+class NullLog {
+  log() {
+    return () => {
+    };
+  }
+  info() {
+    return () => {
+    };
+  }
+  warn() {
+    return () => {
+    };
+  }
+  error() {
+    return () => {
+    };
+  }
+}
+class ConsoleLog {
+  constructor() {
+    __publicField(this, "console");
+    this.console = console;
+  }
+  log(...args) {
+    return this.console.log.bind(this.console, ...args);
+  }
+  info(...args) {
+    return this.console.info.bind(this.console, ...args);
+  }
+  warn(...args) {
+    return this.console.warn.bind(this.console, ...args);
+  }
+  error(...args) {
+    return this.console.error.bind(this.console, ...args);
+  }
+}
+const DEFAULT_LOADER_OPTIONS = {
+  // baseUri
+  fetch: null,
+  mimeType: void 0,
+  nothrow: false,
+  log: new ConsoleLog(),
+  // A probe.gl compatible (`log.log()()` syntax) that just logs to console
+  useLocalLibraries: false,
+  CDN: "https://unpkg.com/@loaders.gl",
+  worker: true,
+  // By default, use worker if provided by loader.
+  maxConcurrency: 3,
+  // How many worker instances should be created for each loader.
+  maxMobileConcurrency: 1,
+  // How many worker instances should be created for each loader on mobile devices.
+  reuseWorkers: isBrowser$2,
+  // By default reuse workers in browser (Node.js refuses to terminate if browsers are running)
+  _nodeWorkers: false,
+  // By default do not support node workers
+  _workerType: "",
+  // 'test' to use locally generated workers
+  limit: 0,
+  _limitMB: 0,
+  batchSize: "auto",
+  batchDebounceMs: 0,
+  metadata: false,
+  // TODO - currently only implemented for parseInBatches, adds initial metadata batch,
+  transforms: []
+};
+const REMOVED_LOADER_OPTIONS = {
+  throws: "nothrow",
+  dataType: "(no longer used)",
+  uri: "baseUri",
+  // Warn if fetch options are used on top-level
+  method: "fetch.method",
+  headers: "fetch.headers",
+  body: "fetch.body",
+  mode: "fetch.mode",
+  credentials: "fetch.credentials",
+  cache: "fetch.cache",
+  redirect: "fetch.redirect",
+  referrer: "fetch.referrer",
+  referrerPolicy: "fetch.referrerPolicy",
+  integrity: "fetch.integrity",
+  keepalive: "fetch.keepalive",
+  signal: "fetch.signal"
+};
+function getGlobalLoaderState() {
+  globalThis.loaders = globalThis.loaders || {};
+  const { loaders } = globalThis;
+  if (!loaders._state) {
+    loaders._state = {};
+  }
+  return loaders._state;
+}
+function getGlobalLoaderOptions() {
+  const state = getGlobalLoaderState();
+  state.globalOptions = state.globalOptions || { ...DEFAULT_LOADER_OPTIONS };
+  return state.globalOptions;
+}
+function normalizeOptions(options, loader, loaders, url) {
+  loaders = loaders || [];
+  loaders = Array.isArray(loaders) ? loaders : [loaders];
+  validateOptions(options, loaders);
+  return normalizeOptionsInternal(loader, options, url);
+}
+function validateOptions(options, loaders) {
+  validateOptionsObject(options, null, DEFAULT_LOADER_OPTIONS, REMOVED_LOADER_OPTIONS, loaders);
+  for (const loader of loaders) {
+    const idOptions = options && options[loader.id] || {};
+    const loaderOptions = loader.options && loader.options[loader.id] || {};
+    const deprecatedOptions = loader.deprecatedOptions && loader.deprecatedOptions[loader.id] || {};
+    validateOptionsObject(idOptions, loader.id, loaderOptions, deprecatedOptions, loaders);
+  }
+}
+function validateOptionsObject(options, id2, defaultOptions2, deprecatedOptions, loaders) {
+  const loaderName = id2 || "Top level";
+  const prefix = id2 ? `${id2}.` : "";
+  for (const key in options) {
+    const isSubOptions = !id2 && isObject$1(options[key]);
+    const isBaseUriOption = key === "baseUri" && !id2;
+    const isWorkerUrlOption = key === "workerUrl" && id2;
+    if (!(key in defaultOptions2) && !isBaseUriOption && !isWorkerUrlOption) {
+      if (key in deprecatedOptions) {
+        probeLog.warn(`${loaderName} loader option '${prefix}${key}' no longer supported, use '${deprecatedOptions[key]}'`)();
+      } else if (!isSubOptions) {
+        const suggestion = findSimilarOption(key, loaders);
+        probeLog.warn(`${loaderName} loader option '${prefix}${key}' not recognized. ${suggestion}`)();
+      }
+    }
+  }
+}
+function findSimilarOption(optionKey, loaders) {
+  const lowerCaseOptionKey = optionKey.toLowerCase();
+  let bestSuggestion = "";
+  for (const loader of loaders) {
+    for (const key in loader.options) {
+      if (optionKey === key) {
+        return `Did you mean '${loader.id}.${key}'?`;
+      }
+      const lowerCaseKey = key.toLowerCase();
+      const isPartialMatch = lowerCaseOptionKey.startsWith(lowerCaseKey) || lowerCaseKey.startsWith(lowerCaseOptionKey);
+      if (isPartialMatch) {
+        bestSuggestion = bestSuggestion || `Did you mean '${loader.id}.${key}'?`;
+      }
+    }
+  }
+  return bestSuggestion;
+}
+function normalizeOptionsInternal(loader, options, url) {
+  const loaderDefaultOptions = loader.options || {};
+  const mergedOptions = { ...loaderDefaultOptions };
+  addUrlOptions(mergedOptions, url);
+  if (mergedOptions.log === null) {
+    mergedOptions.log = new NullLog();
+  }
+  mergeNestedFields(mergedOptions, getGlobalLoaderOptions());
+  mergeNestedFields(mergedOptions, options);
+  return mergedOptions;
+}
+function mergeNestedFields(mergedOptions, options) {
+  for (const key in options) {
+    if (key in options) {
+      const value = options[key];
+      if (isPureObject(value) && isPureObject(mergedOptions[key])) {
+        mergedOptions[key] = {
+          ...mergedOptions[key],
+          ...options[key]
+        };
+      } else {
+        mergedOptions[key] = options[key];
+      }
+    }
+  }
+}
+function addUrlOptions(options, url) {
+  if (url && !("baseUri" in options)) {
+    options.baseUri = url;
+  }
+}
+function isLoaderObject(loader) {
+  if (!loader) {
+    return false;
+  }
+  if (Array.isArray(loader)) {
+    loader = loader[0];
+  }
+  const hasExtensions = Array.isArray(loader == null ? void 0 : loader.extensions);
+  return hasExtensions;
+}
+function normalizeLoader(loader) {
+  assert$6(loader, "null loader");
+  assert$6(isLoaderObject(loader), "invalid loader");
+  let options;
+  if (Array.isArray(loader)) {
+    options = loader[1];
+    loader = loader[0];
+    loader = {
+      ...loader,
+      options: { ...loader.options, ...options }
+    };
+  }
+  if ((loader == null ? void 0 : loader.parseTextSync) || (loader == null ? void 0 : loader.parseText)) {
+    loader.text = true;
+  }
+  if (!loader.text) {
+    loader.binary = true;
+  }
+  return loader;
+}
+const getGlobalLoaderRegistry = () => {
+  const state = getGlobalLoaderState();
+  state.loaderRegistry = state.loaderRegistry || [];
+  return state.loaderRegistry;
+};
+function registerLoaders(loaders) {
+  const loaderRegistry = getGlobalLoaderRegistry();
+  loaders = Array.isArray(loaders) ? loaders : [loaders];
+  for (const loader of loaders) {
+    const normalizedLoader = normalizeLoader(loader);
+    if (!loaderRegistry.find((registeredLoader) => normalizedLoader === registeredLoader)) {
+      loaderRegistry.unshift(normalizedLoader);
+    }
+  }
+}
+function getRegisteredLoaders() {
+  return getGlobalLoaderRegistry();
+}
+const EXT_PATTERN = /\.([^.]+)$/;
+async function selectLoader(data, loaders = [], options, context) {
+  if (!validHTTPResponse(data)) {
+    return null;
+  }
+  let loader = selectLoaderSync(data, loaders, { ...options, nothrow: true }, context);
+  if (loader) {
+    return loader;
+  }
+  if (isBlob(data)) {
+    data = await data.slice(0, 10).arrayBuffer();
+    loader = selectLoaderSync(data, loaders, options, context);
+  }
+  if (!loader && !(options == null ? void 0 : options.nothrow)) {
+    throw new Error(getNoValidLoaderMessage(data));
+  }
+  return loader;
+}
+function selectLoaderSync(data, loaders = [], options, context) {
+  if (!validHTTPResponse(data)) {
+    return null;
+  }
+  if (loaders && !Array.isArray(loaders)) {
+    return normalizeLoader(loaders);
+  }
+  let candidateLoaders = [];
+  if (loaders) {
+    candidateLoaders = candidateLoaders.concat(loaders);
+  }
+  if (!(options == null ? void 0 : options.ignoreRegisteredLoaders)) {
+    candidateLoaders.push(...getRegisteredLoaders());
+  }
+  normalizeLoaders(candidateLoaders);
+  const loader = selectLoaderInternal(data, candidateLoaders, options, context);
+  if (!loader && !(options == null ? void 0 : options.nothrow)) {
+    throw new Error(getNoValidLoaderMessage(data));
+  }
+  return loader;
+}
+function selectLoaderInternal(data, loaders, options, context) {
+  const url = getResourceUrl(data);
+  const type = getResourceMIMEType(data);
+  const testUrl = stripQueryString(url) || (context == null ? void 0 : context.url);
+  let loader = null;
+  let reason = "";
+  if (options == null ? void 0 : options.mimeType) {
+    loader = findLoaderByMIMEType(loaders, options == null ? void 0 : options.mimeType);
+    reason = `match forced by supplied MIME type ${options == null ? void 0 : options.mimeType}`;
+  }
+  loader = loader || findLoaderByUrl(loaders, testUrl);
+  reason = reason || (loader ? `matched url ${testUrl}` : "");
+  loader = loader || findLoaderByMIMEType(loaders, type);
+  reason = reason || (loader ? `matched MIME type ${type}` : "");
+  loader = loader || findLoaderByInitialBytes(loaders, data);
+  reason = reason || (loader ? `matched initial data ${getFirstCharacters(data)}` : "");
+  if (options == null ? void 0 : options.fallbackMimeType) {
+    loader = loader || findLoaderByMIMEType(loaders, options == null ? void 0 : options.fallbackMimeType);
+    reason = reason || (loader ? `matched fallback MIME type ${type}` : "");
+  }
+  if (reason) {
+    log$1.log(1, `selectLoader selected ${loader == null ? void 0 : loader.name}: ${reason}.`);
+  }
+  return loader;
+}
+function validHTTPResponse(data) {
+  if (data instanceof Response) {
+    if (data.status === 204) {
+      return false;
+    }
+  }
+  return true;
+}
+function getNoValidLoaderMessage(data) {
+  const url = getResourceUrl(data);
+  const type = getResourceMIMEType(data);
+  let message2 = "No valid loader found (";
+  message2 += url ? `${filename(url)}, ` : "no url provided, ";
+  message2 += `MIME type: ${type ? `"${type}"` : "not provided"}, `;
+  const firstCharacters = data ? getFirstCharacters(data) : "";
+  message2 += firstCharacters ? ` first bytes: "${firstCharacters}"` : "first bytes: not available";
+  message2 += ")";
+  return message2;
+}
+function normalizeLoaders(loaders) {
+  for (const loader of loaders) {
+    normalizeLoader(loader);
+  }
+}
+function findLoaderByUrl(loaders, url) {
+  const match = url && EXT_PATTERN.exec(url);
+  const extension = match && match[1];
+  return extension ? findLoaderByExtension(loaders, extension) : null;
+}
+function findLoaderByExtension(loaders, extension) {
+  extension = extension.toLowerCase();
+  for (const loader of loaders) {
+    for (const loaderExtension of loader.extensions) {
+      if (loaderExtension.toLowerCase() === extension) {
+        return loader;
+      }
+    }
+  }
+  return null;
+}
+function findLoaderByMIMEType(loaders, mimeType) {
+  var _a3;
+  for (const loader of loaders) {
+    if ((_a3 = loader.mimeTypes) == null ? void 0 : _a3.some((mimeType1) => compareMIMETypes(mimeType, mimeType1))) {
+      return loader;
+    }
+    if (compareMIMETypes(mimeType, `application/x.${loader.id}`)) {
+      return loader;
+    }
+  }
+  return null;
+}
+function findLoaderByInitialBytes(loaders, data) {
+  if (!data) {
+    return null;
+  }
+  for (const loader of loaders) {
+    if (typeof data === "string") {
+      if (testDataAgainstText(data, loader)) {
+        return loader;
+      }
+    } else if (ArrayBuffer.isView(data)) {
+      if (testDataAgainstBinary(data.buffer, data.byteOffset, loader)) {
+        return loader;
+      }
+    } else if (data instanceof ArrayBuffer) {
+      const byteOffset = 0;
+      if (testDataAgainstBinary(data, byteOffset, loader)) {
+        return loader;
+      }
+    }
+  }
+  return null;
+}
+function testDataAgainstText(data, loader) {
+  if (loader.testText) {
+    return loader.testText(data);
+  }
+  const tests = Array.isArray(loader.tests) ? loader.tests : [loader.tests];
+  return tests.some((test) => data.startsWith(test));
+}
+function testDataAgainstBinary(data, byteOffset, loader) {
+  const tests = Array.isArray(loader.tests) ? loader.tests : [loader.tests];
+  return tests.some((test) => testBinary(data, byteOffset, loader, test));
+}
+function testBinary(data, byteOffset, loader, test) {
+  if (test instanceof ArrayBuffer) {
+    return compareArrayBuffers(test, data, test.byteLength);
+  }
+  switch (typeof test) {
+    case "function":
+      return test(data);
+    case "string":
+      const magic = getMagicString(data, byteOffset, test.length);
+      return test === magic;
+    default:
+      return false;
+  }
+}
+function getFirstCharacters(data, length2 = 5) {
+  if (typeof data === "string") {
+    return data.slice(0, length2);
+  } else if (ArrayBuffer.isView(data)) {
+    return getMagicString(data.buffer, data.byteOffset, length2);
+  } else if (data instanceof ArrayBuffer) {
+    const byteOffset = 0;
+    return getMagicString(data, byteOffset, length2);
+  }
+  return "";
+}
+function getMagicString(arrayBuffer2, byteOffset, length2) {
+  if (arrayBuffer2.byteLength < byteOffset + length2) {
+    return "";
+  }
+  const dataView = new DataView(arrayBuffer2);
+  let magic = "";
+  for (let i2 = 0; i2 < length2; i2++) {
+    magic += String.fromCharCode(dataView.getUint8(byteOffset + i2));
+  }
+  return magic;
+}
+const DEFAULT_CHUNK_SIZE$2 = 256 * 1024;
+function* makeStringIterator(string, options) {
+  const chunkSize = (options == null ? void 0 : options.chunkSize) || DEFAULT_CHUNK_SIZE$2;
+  let offset = 0;
+  const textEncoder = new TextEncoder();
+  while (offset < string.length) {
+    const chunkLength = Math.min(string.length - offset, chunkSize);
+    const chunk = string.slice(offset, offset + chunkLength);
+    offset += chunkLength;
+    yield textEncoder.encode(chunk);
+  }
+}
+const DEFAULT_CHUNK_SIZE$1 = 256 * 1024;
+function* makeArrayBufferIterator(arrayBuffer2, options = {}) {
+  const { chunkSize = DEFAULT_CHUNK_SIZE$1 } = options;
+  let byteOffset = 0;
+  while (byteOffset < arrayBuffer2.byteLength) {
+    const chunkByteLength = Math.min(arrayBuffer2.byteLength - byteOffset, chunkSize);
+    const chunk = new ArrayBuffer(chunkByteLength);
+    const sourceArray = new Uint8Array(arrayBuffer2, byteOffset, chunkByteLength);
+    const chunkArray = new Uint8Array(chunk);
+    chunkArray.set(sourceArray);
+    byteOffset += chunkByteLength;
+    yield chunk;
+  }
+}
+const DEFAULT_CHUNK_SIZE = 1024 * 1024;
+async function* makeBlobIterator(blob, options) {
+  const chunkSize = (options == null ? void 0 : options.chunkSize) || DEFAULT_CHUNK_SIZE;
+  let offset = 0;
+  while (offset < blob.size) {
+    const end = offset + chunkSize;
+    const chunk = await blob.slice(offset, end).arrayBuffer();
+    offset = end;
+    yield chunk;
+  }
+}
+function makeStreamIterator(stream, options) {
+  return isBrowser$2 ? makeBrowserStreamIterator(stream, options) : makeNodeStreamIterator(stream);
+}
+async function* makeBrowserStreamIterator(stream, options) {
+  const reader = stream.getReader();
+  let nextBatchPromise;
+  try {
+    while (true) {
+      const currentBatchPromise = nextBatchPromise || reader.read();
+      if (options == null ? void 0 : options._streamReadAhead) {
+        nextBatchPromise = reader.read();
+      }
+      const { done, value } = await currentBatchPromise;
+      if (done) {
+        return;
+      }
+      yield toArrayBuffer(value);
+    }
+  } catch (error) {
+    reader.releaseLock();
+  }
+}
+async function* makeNodeStreamIterator(stream, options) {
+  for await (const chunk of stream) {
+    yield toArrayBuffer(chunk);
+  }
+}
+function makeIterator(data, options) {
+  if (typeof data === "string") {
+    return makeStringIterator(data, options);
+  }
+  if (data instanceof ArrayBuffer) {
+    return makeArrayBufferIterator(data, options);
+  }
+  if (isBlob(data)) {
+    return makeBlobIterator(data, options);
+  }
+  if (isReadableStream(data)) {
+    return makeStreamIterator(data, options);
+  }
+  if (isResponse(data)) {
+    const response = data;
+    return makeStreamIterator(response.body, options);
+  }
+  throw new Error("makeIterator");
+}
+const ERR_DATA = "Cannot convert supplied data type";
+function getArrayBufferOrStringFromDataSync(data, loader, options) {
+  if (loader.text && typeof data === "string") {
+    return data;
+  }
+  if (isBuffer(data)) {
+    data = data.buffer;
+  }
+  if (data instanceof ArrayBuffer) {
+    const arrayBuffer2 = data;
+    if (loader.text && !loader.binary) {
+      const textDecoder = new TextDecoder("utf8");
+      return textDecoder.decode(arrayBuffer2);
+    }
+    return arrayBuffer2;
+  }
+  if (ArrayBuffer.isView(data)) {
+    if (loader.text && !loader.binary) {
+      const textDecoder = new TextDecoder("utf8");
+      return textDecoder.decode(data);
+    }
+    let arrayBuffer2 = data.buffer;
+    const byteLength = data.byteLength || data.length;
+    if (data.byteOffset !== 0 || byteLength !== arrayBuffer2.byteLength) {
+      arrayBuffer2 = arrayBuffer2.slice(data.byteOffset, data.byteOffset + byteLength);
+    }
+    return arrayBuffer2;
+  }
+  throw new Error(ERR_DATA);
+}
+async function getArrayBufferOrStringFromData(data, loader, options) {
+  const isArrayBuffer = data instanceof ArrayBuffer || ArrayBuffer.isView(data);
+  if (typeof data === "string" || isArrayBuffer) {
+    return getArrayBufferOrStringFromDataSync(data, loader);
+  }
+  if (isBlob(data)) {
+    data = await makeResponse(data);
+  }
+  if (isResponse(data)) {
+    const response = data;
+    await checkResponse(response);
+    return loader.binary ? await response.arrayBuffer() : await response.text();
+  }
+  if (isReadableStream(data)) {
+    data = makeIterator(data, options);
+  }
+  if (isIterable(data) || isAsyncIterable$1(data)) {
+    return concatenateArrayBuffersAsync(data);
+  }
+  throw new Error(ERR_DATA);
+}
+function getFetchFunction(options, context) {
+  const globalOptions = getGlobalLoaderOptions();
+  const loaderOptions = options || globalOptions;
+  if (typeof loaderOptions.fetch === "function") {
+    return loaderOptions.fetch;
+  }
+  if (isObject$1(loaderOptions.fetch)) {
+    return (url) => fetchFile(url, loaderOptions.fetch);
+  }
+  if (context == null ? void 0 : context.fetch) {
+    return context == null ? void 0 : context.fetch;
+  }
+  return fetchFile;
+}
+function getLoaderContext(context, options, parentContext) {
+  if (parentContext) {
+    return parentContext;
+  }
+  const newContext = {
+    fetch: getFetchFunction(options, context),
+    ...context
+  };
+  if (newContext.url) {
+    const baseUrl = stripQueryString(newContext.url);
+    newContext.baseUrl = baseUrl;
+    newContext.queryString = extractQueryString(newContext.url);
+    newContext.filename = filename(baseUrl);
+    newContext.baseUrl = dirname(baseUrl);
+  }
+  if (!Array.isArray(newContext.loaders)) {
+    newContext.loaders = null;
+  }
+  return newContext;
+}
+function getLoadersFromContext(loaders, context) {
+  if (loaders && !Array.isArray(loaders)) {
+    return loaders;
+  }
+  let candidateLoaders;
+  if (loaders) {
+    candidateLoaders = Array.isArray(loaders) ? loaders : [loaders];
+  }
+  if (context && context.loaders) {
+    const contextLoaders = Array.isArray(context.loaders) ? context.loaders : [context.loaders];
+    candidateLoaders = candidateLoaders ? [...candidateLoaders, ...contextLoaders] : contextLoaders;
+  }
+  return candidateLoaders && candidateLoaders.length ? candidateLoaders : void 0;
+}
+async function parse(data, loaders, options, context) {
+  if (loaders && !Array.isArray(loaders) && !isLoaderObject(loaders)) {
+    context = void 0;
+    options = loaders;
+    loaders = void 0;
+  }
+  data = await data;
+  options = options || {};
+  const url = getResourceUrl(data);
+  const typedLoaders = loaders;
+  const candidateLoaders = getLoadersFromContext(typedLoaders, context);
+  const loader = await selectLoader(data, candidateLoaders, options);
+  if (!loader) {
+    return null;
+  }
+  options = normalizeOptions(options, loader, candidateLoaders, url);
+  context = getLoaderContext(
+    // @ts-expect-error
+    { url, _parse: parse, loaders: candidateLoaders },
+    options,
+    context || null
+  );
+  return await parseWithLoader(loader, data, options, context);
+}
+async function parseWithLoader(loader, data, options, context) {
+  validateWorkerVersion(loader);
+  options = mergeLoaderOptions(loader.options, options);
+  if (isResponse(data)) {
+    const response = data;
+    const { ok: ok2, redirected, status, statusText, type, url } = response;
+    const headers = Object.fromEntries(response.headers.entries());
+    context.response = { headers, ok: ok2, redirected, status, statusText, type, url };
+  }
+  data = await getArrayBufferOrStringFromData(data, loader, options);
+  const loaderWithParser = loader;
+  if (loaderWithParser.parseTextSync && typeof data === "string") {
+    return loaderWithParser.parseTextSync(data, options, context);
+  }
+  if (canParseWithWorker(loader, options)) {
+    return await parseWithWorker(loader, data, options, context, parse);
+  }
+  if (loaderWithParser.parseText && typeof data === "string") {
+    return await loaderWithParser.parseText(data, options, context);
+  }
+  if (loaderWithParser.parse) {
+    return await loaderWithParser.parse(data, options, context);
+  }
+  assert$4(!loaderWithParser.parseSync);
+  throw new Error(`${loader.id} loader - no parser found and worker is disabled`);
+}
+async function load(url, loaders, options, context) {
+  let resolvedLoaders;
+  let resolvedOptions;
+  if (!Array.isArray(loaders) && !isLoaderObject(loaders)) {
+    resolvedLoaders = [];
+    resolvedOptions = loaders;
+  } else {
+    resolvedLoaders = loaders;
+    resolvedOptions = options;
+  }
+  const fetch2 = getFetchFunction(resolvedOptions);
+  let data = url;
+  if (typeof url === "string") {
+    data = await fetch2(url);
+  }
+  if (isBlob(url)) {
+    data = await fetch2(url);
+  }
+  return Array.isArray(resolvedLoaders) ? await parse(data, resolvedLoaders, resolvedOptions) : await parse(data, resolvedLoaders, resolvedOptions);
+}
+const VERSION$1 = "4.3.3";
+const parseImageNode = (_a2 = globalThis.loaders) == null ? void 0 : _a2.parseImageNode;
+const IMAGE_SUPPORTED = typeof Image !== "undefined";
+const IMAGE_BITMAP_SUPPORTED = typeof ImageBitmap !== "undefined";
+const NODE_IMAGE_SUPPORTED = Boolean(parseImageNode);
+const DATA_SUPPORTED = isBrowser$2 ? true : NODE_IMAGE_SUPPORTED;
+function isImageTypeSupported(type) {
+  switch (type) {
+    case "auto":
+      return IMAGE_BITMAP_SUPPORTED || IMAGE_SUPPORTED || DATA_SUPPORTED;
+    case "imagebitmap":
+      return IMAGE_BITMAP_SUPPORTED;
+    case "image":
+      return IMAGE_SUPPORTED;
+    case "data":
+      return DATA_SUPPORTED;
+    default:
+      throw new Error(`@loaders.gl/images: image ${type} not supported in this environment`);
+  }
+}
+function getDefaultImageType() {
+  if (IMAGE_BITMAP_SUPPORTED) {
+    return "imagebitmap";
+  }
+  if (IMAGE_SUPPORTED) {
+    return "image";
+  }
+  if (DATA_SUPPORTED) {
+    return "data";
+  }
+  throw new Error("Install '@loaders.gl/polyfills' to parse images under Node.js");
+}
+function getImageType(image) {
+  const format = getImageTypeOrNull(image);
+  if (!format) {
+    throw new Error("Not an image");
+  }
+  return format;
+}
+function getImageData(image) {
+  switch (getImageType(image)) {
+    case "data":
+      return image;
+    case "image":
+    case "imagebitmap":
+      const canvas2 = document.createElement("canvas");
+      const context = canvas2.getContext("2d");
+      if (!context) {
+        throw new Error("getImageData");
+      }
+      canvas2.width = image.width;
+      canvas2.height = image.height;
+      context.drawImage(image, 0, 0);
+      return context.getImageData(0, 0, image.width, image.height);
+    default:
+      throw new Error("getImageData");
+  }
+}
+function getImageTypeOrNull(image) {
+  if (typeof ImageBitmap !== "undefined" && image instanceof ImageBitmap) {
+    return "imagebitmap";
+  }
+  if (typeof Image !== "undefined" && image instanceof Image) {
+    return "image";
+  }
+  if (image && typeof image === "object" && image.data && image.width && image.height) {
+    return "data";
+  }
+  return null;
+}
+const SVG_DATA_URL_PATTERN = /^data:image\/svg\+xml/;
+const SVG_URL_PATTERN = /\.svg((\?|#).*)?$/;
+function isSVG(url) {
+  return url && (SVG_DATA_URL_PATTERN.test(url) || SVG_URL_PATTERN.test(url));
+}
+function getBlobOrSVGDataUrl(arrayBuffer2, url) {
+  if (isSVG(url)) {
+    const textDecoder = new TextDecoder();
+    let xmlText = textDecoder.decode(arrayBuffer2);
+    try {
+      if (typeof unescape === "function" && typeof encodeURIComponent === "function") {
+        xmlText = unescape(encodeURIComponent(xmlText));
+      }
+    } catch (error) {
+      throw new Error(error.message);
+    }
+    const src = `data:image/svg+xml;base64,${btoa(xmlText)}`;
+    return src;
+  }
+  return getBlob(arrayBuffer2, url);
+}
+function getBlob(arrayBuffer2, url) {
+  if (isSVG(url)) {
+    throw new Error("SVG cannot be parsed directly to imagebitmap");
+  }
+  return new Blob([new Uint8Array(arrayBuffer2)]);
+}
+async function parseToImage(arrayBuffer2, options, url) {
+  const blobOrDataUrl = getBlobOrSVGDataUrl(arrayBuffer2, url);
+  const URL2 = self.URL || self.webkitURL;
+  const objectUrl = typeof blobOrDataUrl !== "string" && URL2.createObjectURL(blobOrDataUrl);
+  try {
+    return await loadToImage(objectUrl || blobOrDataUrl, options);
+  } finally {
+    if (objectUrl) {
+      URL2.revokeObjectURL(objectUrl);
+    }
+  }
+}
+async function loadToImage(url, options) {
+  const image = new Image();
+  image.src = url;
+  if (options.image && options.image.decode && image.decode) {
+    await image.decode();
+    return image;
+  }
+  return await new Promise((resolve, reject) => {
+    try {
+      image.onload = () => resolve(image);
+      image.onerror = (error) => {
+        const message2 = error instanceof Error ? error.message : "error";
+        reject(new Error(message2));
+      };
+    } catch (error) {
+      reject(error);
+    }
+  });
+}
+const EMPTY_OBJECT = {};
+let imagebitmapOptionsSupported = true;
+async function parseToImageBitmap(arrayBuffer2, options, url) {
+  let blob;
+  if (isSVG(url)) {
+    const image = await parseToImage(arrayBuffer2, options, url);
+    blob = image;
+  } else {
+    blob = getBlob(arrayBuffer2, url);
+  }
+  const imagebitmapOptions = options && options.imagebitmap;
+  return await safeCreateImageBitmap(blob, imagebitmapOptions);
+}
+async function safeCreateImageBitmap(blob, imagebitmapOptions = null) {
+  if (isEmptyObject(imagebitmapOptions) || !imagebitmapOptionsSupported) {
+    imagebitmapOptions = null;
+  }
+  if (imagebitmapOptions) {
+    try {
+      return await createImageBitmap(blob, imagebitmapOptions);
+    } catch (error) {
+      console.warn(error);
+      imagebitmapOptionsSupported = false;
+    }
+  }
+  return await createImageBitmap(blob);
+}
+function isEmptyObject(object) {
+  for (const key in object || EMPTY_OBJECT) {
+    return false;
+  }
+  return true;
+}
+function getISOBMFFMediaType(buffer) {
+  if (!checkString(buffer, "ftyp", 4)) {
+    return null;
+  }
+  if ((buffer[8] & 96) === 0) {
+    return null;
+  }
+  return decodeMajorBrand(buffer);
+}
+function decodeMajorBrand(buffer) {
+  const brandMajor = getUTF8String(buffer, 8, 12).replace("\0", " ").trim();
+  switch (brandMajor) {
+    case "avif":
+    case "avis":
+      return { extension: "avif", mimeType: "image/avif" };
+    default:
+      return null;
+  }
+}
+function getUTF8String(array, start, end) {
+  return String.fromCharCode(...array.slice(start, end));
+}
+function stringToBytes(string) {
+  return [...string].map((character) => character.charCodeAt(0));
+}
+function checkString(buffer, header, offset = 0) {
+  const headerBytes = stringToBytes(header);
+  for (let i2 = 0; i2 < headerBytes.length; ++i2) {
+    if (headerBytes[i2] !== buffer[i2 + offset]) {
+      return false;
+    }
+  }
+  return true;
+}
+const BIG_ENDIAN = false;
+const LITTLE_ENDIAN = true;
+function getBinaryImageMetadata(binaryData) {
+  const dataView = toDataView(binaryData);
+  return getPngMetadata(dataView) || getJpegMetadata(dataView) || getGifMetadata(dataView) || getBmpMetadata(dataView) || getISOBMFFMetadata(dataView);
+}
+function getISOBMFFMetadata(binaryData) {
+  const buffer = new Uint8Array(binaryData instanceof DataView ? binaryData.buffer : binaryData);
+  const mediaType = getISOBMFFMediaType(buffer);
+  if (!mediaType) {
+    return null;
+  }
+  return {
+    mimeType: mediaType.mimeType,
+    // TODO - decode width and height
+    width: 0,
+    height: 0
+  };
+}
+function getPngMetadata(binaryData) {
+  const dataView = toDataView(binaryData);
+  const isPng = dataView.byteLength >= 24 && dataView.getUint32(0, BIG_ENDIAN) === 2303741511;
+  if (!isPng) {
+    return null;
+  }
+  return {
+    mimeType: "image/png",
+    width: dataView.getUint32(16, BIG_ENDIAN),
+    height: dataView.getUint32(20, BIG_ENDIAN)
+  };
+}
+function getGifMetadata(binaryData) {
+  const dataView = toDataView(binaryData);
+  const isGif = dataView.byteLength >= 10 && dataView.getUint32(0, BIG_ENDIAN) === 1195984440;
+  if (!isGif) {
+    return null;
+  }
+  return {
+    mimeType: "image/gif",
+    width: dataView.getUint16(6, LITTLE_ENDIAN),
+    height: dataView.getUint16(8, LITTLE_ENDIAN)
+  };
+}
+function getBmpMetadata(binaryData) {
+  const dataView = toDataView(binaryData);
+  const isBmp = dataView.byteLength >= 14 && dataView.getUint16(0, BIG_ENDIAN) === 16973 && dataView.getUint32(2, LITTLE_ENDIAN) === dataView.byteLength;
+  if (!isBmp) {
+    return null;
+  }
+  return {
+    mimeType: "image/bmp",
+    width: dataView.getUint32(18, LITTLE_ENDIAN),
+    height: dataView.getUint32(22, LITTLE_ENDIAN)
+  };
+}
+function getJpegMetadata(binaryData) {
+  const dataView = toDataView(binaryData);
+  const isJpeg = dataView.byteLength >= 3 && dataView.getUint16(0, BIG_ENDIAN) === 65496 && dataView.getUint8(2) === 255;
+  if (!isJpeg) {
+    return null;
+  }
+  const { tableMarkers, sofMarkers } = getJpegMarkers();
+  let i2 = 2;
+  while (i2 + 9 < dataView.byteLength) {
+    const marker = dataView.getUint16(i2, BIG_ENDIAN);
+    if (sofMarkers.has(marker)) {
+      return {
+        mimeType: "image/jpeg",
+        height: dataView.getUint16(i2 + 5, BIG_ENDIAN),
+        // Number of lines
+        width: dataView.getUint16(i2 + 7, BIG_ENDIAN)
+        // Number of pixels per line
+      };
+    }
+    if (!tableMarkers.has(marker)) {
+      return null;
+    }
+    i2 += 2;
+    i2 += dataView.getUint16(i2, BIG_ENDIAN);
+  }
+  return null;
+}
+function getJpegMarkers() {
+  const tableMarkers = /* @__PURE__ */ new Set([65499, 65476, 65484, 65501, 65534]);
+  for (let i2 = 65504; i2 < 65520; ++i2) {
+    tableMarkers.add(i2);
+  }
+  const sofMarkers = /* @__PURE__ */ new Set([
+    65472,
+    65473,
+    65474,
+    65475,
+    65477,
+    65478,
+    65479,
+    65481,
+    65482,
+    65483,
+    65485,
+    65486,
+    65487,
+    65502
+  ]);
+  return { tableMarkers, sofMarkers };
+}
+function toDataView(data) {
+  if (data instanceof DataView) {
+    return data;
+  }
+  if (ArrayBuffer.isView(data)) {
+    return new DataView(data.buffer);
+  }
+  if (data instanceof ArrayBuffer) {
+    return new DataView(data);
+  }
+  throw new Error("toDataView");
+}
+async function parseToNodeImage(arrayBuffer2, options) {
+  var _a3;
+  const { mimeType } = getBinaryImageMetadata(arrayBuffer2) || {};
+  const parseImageNode2 = (_a3 = globalThis.loaders) == null ? void 0 : _a3.parseImageNode;
+  assert$6(parseImageNode2);
+  return await parseImageNode2(arrayBuffer2, mimeType);
+}
+async function parseImage(arrayBuffer2, options, context) {
+  options = options || {};
+  const imageOptions = options.image || {};
+  const imageType = imageOptions.type || "auto";
+  const { url } = context || {};
+  const loadType = getLoadableImageType(imageType);
+  let image;
+  switch (loadType) {
+    case "imagebitmap":
+      image = await parseToImageBitmap(arrayBuffer2, options, url);
+      break;
+    case "image":
+      image = await parseToImage(arrayBuffer2, options, url);
+      break;
+    case "data":
+      image = await parseToNodeImage(arrayBuffer2);
+      break;
+    default:
+      assert$6(false);
+  }
+  if (imageType === "data") {
+    image = getImageData(image);
+  }
+  return image;
+}
+function getLoadableImageType(type) {
+  switch (type) {
+    case "auto":
+    case "data":
+      return getDefaultImageType();
+    default:
+      isImageTypeSupported(type);
+      return type;
+  }
+}
+const EXTENSIONS = ["png", "jpg", "jpeg", "gif", "webp", "bmp", "ico", "svg", "avif"];
+const MIME_TYPES = [
+  "image/png",
+  "image/jpeg",
+  "image/gif",
+  "image/webp",
+  "image/avif",
+  "image/bmp",
+  "image/vnd.microsoft.icon",
+  "image/svg+xml"
+];
+const DEFAULT_IMAGE_LOADER_OPTIONS = {
+  image: {
+    type: "auto",
+    decode: true
+    // if format is HTML
+  }
+  // imagebitmap: {} - passes (platform dependent) parameters to ImageBitmap constructor
+};
+const ImageLoader = {
+  dataType: null,
+  batchType: null,
+  id: "image",
+  module: "images",
+  name: "Images",
+  version: VERSION$1,
+  mimeTypes: MIME_TYPES,
+  extensions: EXTENSIONS,
+  parse: parseImage,
+  // TODO: byteOffset, byteLength;
+  tests: [(arrayBuffer2) => Boolean(getBinaryImageMetadata(new DataView(arrayBuffer2)))],
+  options: DEFAULT_IMAGE_LOADER_OPTIONS
+};
+const defaultLogger = new ProbeLog({ id: "deck" });
+let loggers = {};
+function register(handlers) {
+  loggers = handlers;
+}
+function debug(eventType, arg1, arg2, arg3) {
+  if (defaultLogger.level > 0 && loggers[eventType]) {
+    loggers[eventType].call(null, arg1, arg2, arg3);
+  }
+}
+function isJSON(text) {
+  const firstChar = text[0];
+  const lastChar = text[text.length - 1];
+  return firstChar === "{" && lastChar === "}" || firstChar === "[" && lastChar === "]";
+}
+const jsonLoader = {
+  dataType: null,
+  batchType: null,
+  id: "JSON",
+  name: "JSON",
+  module: "",
+  version: "",
+  options: {},
+  extensions: ["json", "geojson"],
+  mimeTypes: ["application/json", "application/geo+json"],
+  testText: isJSON,
+  parseTextSync: JSON.parse
+};
+function checkVersion() {
+  const version2 = "9.2.11";
+  const existingVersion = globalThis.deck && globalThis.deck.VERSION;
+  if (existingVersion && existingVersion !== version2) {
+    throw new Error(`deck.gl - multiple versions detected: ${existingVersion} vs ${version2}`);
+  }
+  if (!existingVersion) {
+    defaultLogger.log(1, `deck.gl ${version2}`)();
+    globalThis.deck = {
+      ...globalThis.deck,
+      VERSION: version2,
+      version: version2,
+      log: defaultLogger,
+      // experimental
+      _registerLoggers: register
+    };
+    registerLoaders([
+      jsonLoader,
+      // @ts-expect-error non-standard Loader format
+      [ImageLoader, { imagebitmap: { premultiplyAlpha: "none" } }]
+    ]);
+  }
+  return version2;
+}
+const VERSION = checkVersion();
+function assert$3(condition, message2) {
+  if (!condition) {
+    throw new Error(message2 || "shadertools: assertion failed.");
+  }
+}
+const DEFAULT_PROP_VALIDATORS = {
+  number: {
+    type: "number",
+    validate(value, propType) {
+      return Number.isFinite(value) && typeof propType === "object" && (propType.max === void 0 || value <= propType.max) && (propType.min === void 0 || value >= propType.min);
+    }
+  },
+  array: {
+    type: "array",
+    validate(value, propType) {
+      return Array.isArray(value) || ArrayBuffer.isView(value);
+    }
+  }
+};
+function makePropValidators(propTypes2) {
+  const propValidators = {};
+  for (const [name2, propType] of Object.entries(propTypes2)) {
+    propValidators[name2] = makePropValidator(propType);
+  }
+  return propValidators;
+}
+function makePropValidator(propType) {
+  let type = getTypeOf$1(propType);
+  if (type !== "object") {
+    return { value: propType, ...DEFAULT_PROP_VALIDATORS[type], type };
+  }
+  if (typeof propType === "object") {
+    if (!propType) {
+      return { type: "object", value: null };
+    }
+    if (propType.type !== void 0) {
+      return { ...propType, ...DEFAULT_PROP_VALIDATORS[propType.type], type: propType.type };
+    }
+    if (propType.value === void 0) {
+      return { type: "object", value: propType };
+    }
+    type = getTypeOf$1(propType.value);
+    return { ...propType, ...DEFAULT_PROP_VALIDATORS[type], type };
+  }
+  throw new Error("props");
+}
+function getTypeOf$1(value) {
+  if (Array.isArray(value) || ArrayBuffer.isView(value)) {
+    return "array";
+  }
+  return typeof value;
+}
+const MODULE_INJECTORS_VS = (
+  /* glsl */
+  `#ifdef MODULE_LOGDEPTH
+  logdepth_adjustPosition(gl_Position);
+#endif
+`
+);
+const MODULE_INJECTORS_FS = (
+  /* glsl */
+  `#ifdef MODULE_MATERIAL
+  fragColor = material_filterColor(fragColor);
+#endif
+
+#ifdef MODULE_LIGHTING
+  fragColor = lighting_filterColor(fragColor);
+#endif
+
+#ifdef MODULE_FOG
+  fragColor = fog_filterColor(fragColor);
+#endif
+
+#ifdef MODULE_PICKING
+  fragColor = picking_filterHighlightColor(fragColor);
+  fragColor = picking_filterPickingColor(fragColor);
+#endif
+
+#ifdef MODULE_LOGDEPTH
+  logdepth_setFragDepth();
+#endif
+`
+);
+const MODULE_INJECTORS = {
+  vertex: MODULE_INJECTORS_VS,
+  fragment: MODULE_INJECTORS_FS
+};
+const REGEX_START_OF_MAIN = /void\s+main\s*\([^)]*\)\s*\{\n?/;
+const REGEX_END_OF_MAIN = /}\n?[^{}]*$/;
+const fragments = [];
+const DECLARATION_INJECT_MARKER = "__LUMA_INJECT_DECLARATIONS__";
+function normalizeInjections(injections) {
+  const result = { vertex: {}, fragment: {} };
+  for (const hook in injections) {
+    let injection = injections[hook];
+    const stage = getHookStage(hook);
+    if (typeof injection === "string") {
+      injection = {
+        order: 0,
+        injection
+      };
+    }
+    result[stage][hook] = injection;
+  }
+  return result;
+}
+function getHookStage(hook) {
+  const type = hook.slice(0, 2);
+  switch (type) {
+    case "vs":
+      return "vertex";
+    case "fs":
+      return "fragment";
+    default:
+      throw new Error(type);
+  }
+}
+function injectShader(source2, stage, inject, injectStandardStubs = false) {
+  const isVertex = stage === "vertex";
+  for (const key in inject) {
+    const fragmentData = inject[key];
+    fragmentData.sort((a2, b2) => a2.order - b2.order);
+    fragments.length = fragmentData.length;
+    for (let i2 = 0, len2 = fragmentData.length; i2 < len2; ++i2) {
+      fragments[i2] = fragmentData[i2].injection;
+    }
+    const fragmentString = `${fragments.join("\n")}
+`;
+    switch (key) {
+      case "vs:#decl":
+        if (isVertex) {
+          source2 = source2.replace(DECLARATION_INJECT_MARKER, fragmentString);
+        }
+        break;
+      case "vs:#main-start":
+        if (isVertex) {
+          source2 = source2.replace(REGEX_START_OF_MAIN, (match) => match + fragmentString);
+        }
+        break;
+      case "vs:#main-end":
+        if (isVertex) {
+          source2 = source2.replace(REGEX_END_OF_MAIN, (match) => fragmentString + match);
+        }
+        break;
+      case "fs:#decl":
+        if (!isVertex) {
+          source2 = source2.replace(DECLARATION_INJECT_MARKER, fragmentString);
+        }
+        break;
+      case "fs:#main-start":
+        if (!isVertex) {
+          source2 = source2.replace(REGEX_START_OF_MAIN, (match) => match + fragmentString);
+        }
+        break;
+      case "fs:#main-end":
+        if (!isVertex) {
+          source2 = source2.replace(REGEX_END_OF_MAIN, (match) => fragmentString + match);
+        }
+        break;
+      default:
+        source2 = source2.replace(key, (match) => match + fragmentString);
+    }
+  }
+  source2 = source2.replace(DECLARATION_INJECT_MARKER, "");
+  if (injectStandardStubs) {
+    source2 = source2.replace(/\}\s*$/, (match) => match + MODULE_INJECTORS[stage]);
+  }
+  return source2;
+}
+function initializeShaderModules(modules) {
+  modules.map((module) => initializeShaderModule(module));
+}
+function initializeShaderModule(module) {
+  if (module.instance) {
+    return;
+  }
+  initializeShaderModules(module.dependencies || []);
+  const {
+    propTypes: propTypes2 = {},
+    deprecations = [],
+    // defines = {},
+    inject = {}
+  } = module;
+  const instance2 = {
+    normalizedInjections: normalizeInjections(inject),
+    parsedDeprecations: parseDeprecationDefinitions(deprecations)
+  };
+  if (propTypes2) {
+    instance2.propValidators = makePropValidators(propTypes2);
+  }
+  module.instance = instance2;
+  let defaultProps2 = {};
+  if (propTypes2) {
+    defaultProps2 = Object.entries(propTypes2).reduce((obj, [key, propType]) => {
+      const value = propType == null ? void 0 : propType.value;
+      if (value) {
+        obj[key] = value;
+      }
+      return obj;
+    }, {});
+  }
+  module.defaultUniforms = { ...module.defaultUniforms, ...defaultProps2 };
+}
+function checkShaderModuleDeprecations(shaderModule, shaderSource, log3) {
+  var _a3;
+  (_a3 = shaderModule.deprecations) == null ? void 0 : _a3.forEach((def) => {
+    var _a4;
+    if ((_a4 = def.regex) == null ? void 0 : _a4.test(shaderSource)) {
+      if (def.deprecated) {
+        log3.deprecated(def.old, def.new)();
+      } else {
+        log3.removed(def.old, def.new)();
+      }
+    }
+  });
+}
+function parseDeprecationDefinitions(deprecations) {
+  deprecations.forEach((def) => {
+    switch (def.type) {
+      case "function":
+        def.regex = new RegExp(`\\b${def.old}\\(`);
+        break;
+      default:
+        def.regex = new RegExp(`${def.type} ${def.old};`);
+    }
+  });
+  return deprecations;
+}
+function getShaderModuleDependencies(modules) {
+  initializeShaderModules(modules);
+  const moduleMap = {};
+  const moduleDepth = {};
+  getDependencyGraph({ modules, level: 0, moduleMap, moduleDepth });
+  const dependencies = Object.keys(moduleDepth).sort((a2, b2) => moduleDepth[b2] - moduleDepth[a2]).map((name2) => moduleMap[name2]);
+  initializeShaderModules(dependencies);
+  return dependencies;
+}
+function getDependencyGraph(options) {
+  const { modules, level, moduleMap, moduleDepth } = options;
+  if (level >= 5) {
+    throw new Error("Possible loop in shader dependency graph");
+  }
+  for (const module of modules) {
+    moduleMap[module.name] = module;
+    if (moduleDepth[module.name] === void 0 || moduleDepth[module.name] < level) {
+      moduleDepth[module.name] = level;
+    }
+  }
+  for (const module of modules) {
+    if (module.dependencies) {
+      getDependencyGraph({ modules: module.dependencies, level: level + 1, moduleMap, moduleDepth });
+    }
+  }
+}
+function getPlatformShaderDefines(platformInfo) {
+  switch (platformInfo == null ? void 0 : platformInfo.gpu.toLowerCase()) {
+    case "apple":
+      return (
+        /* glsl */
+        `#define APPLE_GPU
+// Apple optimizes away the calculation necessary for emulated fp64
+#define LUMA_FP64_CODE_ELIMINATION_WORKAROUND 1
+#define LUMA_FP32_TAN_PRECISION_WORKAROUND 1
+// Intel GPU doesn't have full 32 bits precision in same cases, causes overflow
+#define LUMA_FP64_HIGH_BITS_OVERFLOW_WORKAROUND 1
+`
+      );
+    case "nvidia":
+      return (
+        /* glsl */
+        `#define NVIDIA_GPU
+// Nvidia optimizes away the calculation necessary for emulated fp64
+#define LUMA_FP64_CODE_ELIMINATION_WORKAROUND 1
+`
+      );
+    case "intel":
+      return (
+        /* glsl */
+        `#define INTEL_GPU
+// Intel optimizes away the calculation necessary for emulated fp64
+#define LUMA_FP64_CODE_ELIMINATION_WORKAROUND 1
+// Intel's built-in 'tan' function doesn't have acceptable precision
+#define LUMA_FP32_TAN_PRECISION_WORKAROUND 1
+// Intel GPU doesn't have full 32 bits precision in same cases, causes overflow
+#define LUMA_FP64_HIGH_BITS_OVERFLOW_WORKAROUND 1
+`
+      );
+    case "amd":
+      return (
+        /* glsl */
+        `#define AMD_GPU
+`
+      );
+    default:
+      return (
+        /* glsl */
+        `#define DEFAULT_GPU
+// Prevent driver from optimizing away the calculation necessary for emulated fp64
+#define LUMA_FP64_CODE_ELIMINATION_WORKAROUND 1
+// Headless Chrome's software shader 'tan' function doesn't have acceptable precision
+#define LUMA_FP32_TAN_PRECISION_WORKAROUND 1
+// If the GPU doesn't have full 32 bits precision, will causes overflow
+#define LUMA_FP64_HIGH_BITS_OVERFLOW_WORKAROUND 1
+`
+      );
+  }
+}
+function transpileGLSLShader(source2, stage) {
+  var _a3;
+  const sourceGLSLVersion = Number(((_a3 = source2.match(/^#version[ \t]+(\d+)/m)) == null ? void 0 : _a3[1]) || 100);
+  if (sourceGLSLVersion !== 300) {
+    throw new Error("luma.gl v9 only supports GLSL 3.00 shader sources");
+  }
+  switch (stage) {
+    case "vertex":
+      source2 = convertShader(source2, ES300_VERTEX_REPLACEMENTS);
+      return source2;
+    case "fragment":
+      source2 = convertShader(source2, ES300_FRAGMENT_REPLACEMENTS);
+      return source2;
+    default:
+      throw new Error(stage);
+  }
+}
+const ES300_REPLACEMENTS = [
+  // Fix poorly formatted version directive
+  [/^(#version[ \t]+(100|300[ \t]+es))?[ \t]*\n/, "#version 300 es\n"],
+  // The individual `texture...()` functions were replaced with `texture()` overloads
+  [/\btexture(2D|2DProj|Cube)Lod(EXT)?\(/g, "textureLod("],
+  [/\btexture(2D|2DProj|Cube)(EXT)?\(/g, "texture("]
+];
+const ES300_VERTEX_REPLACEMENTS = [
+  ...ES300_REPLACEMENTS,
+  // `attribute` keyword replaced with `in`
+  [makeVariableTextRegExp("attribute"), "in $1"],
+  // `varying` keyword replaced with `out`
+  [makeVariableTextRegExp("varying"), "out $1"]
+];
+const ES300_FRAGMENT_REPLACEMENTS = [
+  ...ES300_REPLACEMENTS,
+  // `varying` keyword replaced with `in`
+  [makeVariableTextRegExp("varying"), "in $1"]
+];
+function convertShader(source2, replacements) {
+  for (const [pattern, replacement] of replacements) {
+    source2 = source2.replace(pattern, replacement);
+  }
+  return source2;
+}
+function makeVariableTextRegExp(qualifier) {
+  return new RegExp(`\\b${qualifier}[ \\t]+(\\w+[ \\t]+\\w+(\\[\\w+\\])?;)`, "g");
+}
+function getShaderHooks(hookFunctions, hookInjections) {
+  let result = "";
+  for (const hookName in hookFunctions) {
+    const hookFunction = hookFunctions[hookName];
+    result += `void ${hookFunction.signature} {
+`;
+    if (hookFunction.header) {
+      result += `  ${hookFunction.header}`;
+    }
+    if (hookInjections[hookName]) {
+      const injections = hookInjections[hookName];
+      injections.sort((a2, b2) => a2.order - b2.order);
+      for (const injection of injections) {
+        result += `  ${injection.injection}
+`;
+      }
+    }
+    if (hookFunction.footer) {
+      result += `  ${hookFunction.footer}`;
+    }
+    result += "}\n";
+  }
+  return result;
+}
+function normalizeShaderHooks(hookFunctions) {
+  const result = { vertex: {}, fragment: {} };
+  for (const hookFunction of hookFunctions) {
+    let opts;
+    let hook;
+    if (typeof hookFunction !== "string") {
+      opts = hookFunction;
+      hook = opts.hook;
+    } else {
+      opts = {};
+      hook = hookFunction;
+    }
+    hook = hook.trim();
+    const [shaderStage, signature] = hook.split(":");
+    const name2 = hook.replace(/\(.+/, "");
+    const normalizedHook = Object.assign(opts, { signature });
+    switch (shaderStage) {
+      case "vs":
+        result.vertex[name2] = normalizedHook;
+        break;
+      case "fs":
+        result.fragment[name2] = normalizedHook;
+        break;
+      default:
+        throw new Error(shaderStage);
+    }
+  }
+  return result;
+}
+function getShaderInfo(source2, defaultName) {
+  return {
+    name: getShaderName$1(source2, defaultName),
+    language: "glsl",
+    version: getShaderVersion(source2)
+  };
+}
+function getShaderName$1(shader, defaultName = "unnamed") {
+  const SHADER_NAME_REGEXP = /#define[^\S\r\n]*SHADER_NAME[^\S\r\n]*([A-Za-z0-9_-]+)\s*/;
+  const match = SHADER_NAME_REGEXP.exec(shader);
+  return match ? match[1] : defaultName;
+}
+function getShaderVersion(source2) {
+  let version2 = 100;
+  const words = source2.match(/[^\s]+/g);
+  if (words && words.length >= 2 && words[0] === "#version") {
+    const parsedVersion = parseInt(words[1], 10);
+    if (Number.isFinite(parsedVersion)) {
+      version2 = parsedVersion;
+    }
+  }
+  if (version2 !== 100 && version2 !== 300) {
+    throw new Error(`Invalid GLSL version ${version2}`);
+  }
+  return version2;
+}
+const INJECT_SHADER_DECLARATIONS = `
+
+${DECLARATION_INJECT_MARKER}
+`;
+const FRAGMENT_SHADER_PROLOGUE = (
+  /* glsl */
+  `precision highp float;
+`
+);
+function assembleWGSLShader(options) {
+  const modules = getShaderModuleDependencies(options.modules || []);
+  return {
+    source: assembleShaderWGSL(options.platformInfo, {
+      ...options,
+      source: options.source,
+      stage: "vertex",
+      modules
+    }),
+    getUniforms: assembleGetUniforms(modules)
+  };
+}
+function assembleGLSLShaderPair(options) {
+  const { vs: vs2, fs: fs2 } = options;
+  const modules = getShaderModuleDependencies(options.modules || []);
+  return {
+    vs: assembleShaderGLSL(options.platformInfo, {
+      ...options,
+      source: vs2,
+      stage: "vertex",
+      modules
+    }),
+    fs: assembleShaderGLSL(options.platformInfo, {
+      ...options,
+      // @ts-expect-error
+      source: fs2,
+      stage: "fragment",
+      modules
+    }),
+    getUniforms: assembleGetUniforms(modules)
+  };
+}
+function assembleShaderWGSL(platformInfo, options) {
+  var _a3;
+  const {
+    // id,
+    source: source2,
+    stage,
+    modules,
+    // defines = {},
+    hookFunctions = [],
+    inject = {},
+    log: log3
+  } = options;
+  assert$3(typeof source2 === "string", "shader source must be a string");
+  const coreSource = source2;
+  let assembledSource = "";
+  const hookFunctionMap = normalizeShaderHooks(hookFunctions);
+  const hookInjections = {};
+  const declInjections = {};
+  const mainInjections = {};
+  for (const key in inject) {
+    const injection = typeof inject[key] === "string" ? { injection: inject[key], order: 0 } : inject[key];
+    const match = /^(v|f)s:(#)?([\w-]+)$/.exec(key);
+    if (match) {
+      const hash = match[2];
+      const name2 = match[3];
+      if (hash) {
+        if (name2 === "decl") {
+          declInjections[key] = [injection];
+        } else {
+          mainInjections[key] = [injection];
+        }
+      } else {
+        hookInjections[key] = [injection];
+      }
+    } else {
+      mainInjections[key] = [injection];
+    }
+  }
+  const modulesToInject = modules;
+  for (const module of modulesToInject) {
+    if (log3) {
+      checkShaderModuleDeprecations(module, coreSource, log3);
+    }
+    const moduleSource = getShaderModuleSource(module, "wgsl");
+    assembledSource += moduleSource;
+    const injections = ((_a3 = module.injections) == null ? void 0 : _a3[stage]) || {};
+    for (const key in injections) {
+      const match = /^(v|f)s:#([\w-]+)$/.exec(key);
+      if (match) {
+        const name2 = match[2];
+        const injectionType = name2 === "decl" ? declInjections : mainInjections;
+        injectionType[key] = injectionType[key] || [];
+        injectionType[key].push(injections[key]);
+      } else {
+        hookInjections[key] = hookInjections[key] || [];
+        hookInjections[key].push(injections[key]);
+      }
+    }
+  }
+  assembledSource += INJECT_SHADER_DECLARATIONS;
+  assembledSource = injectShader(assembledSource, stage, declInjections);
+  assembledSource += getShaderHooks(hookFunctionMap[stage], hookInjections);
+  assembledSource += coreSource;
+  assembledSource = injectShader(assembledSource, stage, mainInjections);
+  return assembledSource;
+}
+function assembleShaderGLSL(platformInfo, options) {
+  var _a3;
+  const { source: source2, stage, language = "glsl", modules, defines: defines2 = {}, hookFunctions = [], inject = {}, prologue = true, log: log3 } = options;
+  assert$3(typeof source2 === "string", "shader source must be a string");
+  const sourceVersion = language === "glsl" ? getShaderInfo(source2).version : -1;
+  const targetVersion = platformInfo.shaderLanguageVersion;
+  const sourceVersionDirective = sourceVersion === 100 ? "#version 100" : "#version 300 es";
+  const sourceLines = source2.split("\n");
+  const coreSource = sourceLines.slice(1).join("\n");
+  const allDefines = {};
+  modules.forEach((module) => {
+    Object.assign(allDefines, module.defines);
+  });
+  Object.assign(allDefines, defines2);
+  let assembledSource = "";
+  switch (language) {
+    case "wgsl":
+      break;
+    case "glsl":
+      assembledSource = prologue ? `${sourceVersionDirective}
+
+// ----- PROLOGUE -------------------------
+${`#define SHADER_TYPE_${stage.toUpperCase()}`}
+
+${getPlatformShaderDefines(platformInfo)}
+${stage === "fragment" ? FRAGMENT_SHADER_PROLOGUE : ""}
+
+// ----- APPLICATION DEFINES -------------------------
+
+${getApplicationDefines(allDefines)}
+
+` : `${sourceVersionDirective}
+`;
+      break;
+  }
+  const hookFunctionMap = normalizeShaderHooks(hookFunctions);
+  const hookInjections = {};
+  const declInjections = {};
+  const mainInjections = {};
+  for (const key in inject) {
+    const injection = typeof inject[key] === "string" ? { injection: inject[key], order: 0 } : inject[key];
+    const match = /^(v|f)s:(#)?([\w-]+)$/.exec(key);
+    if (match) {
+      const hash = match[2];
+      const name2 = match[3];
+      if (hash) {
+        if (name2 === "decl") {
+          declInjections[key] = [injection];
+        } else {
+          mainInjections[key] = [injection];
+        }
+      } else {
+        hookInjections[key] = [injection];
+      }
+    } else {
+      mainInjections[key] = [injection];
+    }
+  }
+  for (const module of modules) {
+    if (log3) {
+      checkShaderModuleDeprecations(module, coreSource, log3);
+    }
+    const moduleSource = getShaderModuleSource(module, stage);
+    assembledSource += moduleSource;
+    const injections = ((_a3 = module.instance) == null ? void 0 : _a3.normalizedInjections[stage]) || {};
+    for (const key in injections) {
+      const match = /^(v|f)s:#([\w-]+)$/.exec(key);
+      if (match) {
+        const name2 = match[2];
+        const injectionType = name2 === "decl" ? declInjections : mainInjections;
+        injectionType[key] = injectionType[key] || [];
+        injectionType[key].push(injections[key]);
+      } else {
+        hookInjections[key] = hookInjections[key] || [];
+        hookInjections[key].push(injections[key]);
+      }
+    }
+  }
+  assembledSource += "// ----- MAIN SHADER SOURCE -------------------------";
+  assembledSource += INJECT_SHADER_DECLARATIONS;
+  assembledSource = injectShader(assembledSource, stage, declInjections);
+  assembledSource += getShaderHooks(hookFunctionMap[stage], hookInjections);
+  assembledSource += coreSource;
+  assembledSource = injectShader(assembledSource, stage, mainInjections);
+  if (language === "glsl" && sourceVersion !== targetVersion) {
+    assembledSource = transpileGLSLShader(assembledSource, stage);
+  }
+  return assembledSource.trim();
+}
+function assembleGetUniforms(modules) {
+  return function getUniforms2(opts) {
+    var _a3;
+    const uniforms = {};
+    for (const module of modules) {
+      const moduleUniforms = (_a3 = module.getUniforms) == null ? void 0 : _a3.call(module, opts, uniforms);
+      Object.assign(uniforms, moduleUniforms);
+    }
+    return uniforms;
+  };
+}
+function getApplicationDefines(defines2 = {}) {
+  let sourceText = "";
+  for (const define in defines2) {
+    const value = defines2[define];
+    if (value || Number.isFinite(value)) {
+      sourceText += `#define ${define.toUpperCase()} ${defines2[define]}
+`;
+    }
+  }
+  return sourceText;
+}
+function getShaderModuleSource(module, stage) {
+  let moduleSource;
+  switch (stage) {
+    case "vertex":
+      moduleSource = module.vs || "";
+      break;
+    case "fragment":
+      moduleSource = module.fs || "";
+      break;
+    case "wgsl":
+      moduleSource = module.source || "";
+      break;
+    default:
+      assert$3(false);
+  }
+  if (!module.name) {
+    throw new Error("Shader module must have a name");
+  }
+  const moduleName = module.name.toUpperCase().replace(/[^0-9a-z]/gi, "_");
+  let source2 = `// ----- MODULE ${module.name} ---------------
+
+`;
+  if (stage !== "wgsl") {
+    source2 += `#define MODULE_${moduleName}
+`;
+  }
+  source2 += `${moduleSource}
+`;
+  return source2;
+}
+const IFDEF_REGEXP = /^\s*\#\s*ifdef\s*([a-zA-Z_]+)\s*$/;
+const ENDIF_REGEXP = /^\s*\#\s*endif\s*$/;
+function preprocess(source2, options) {
+  var _a3;
+  const lines = source2.split("\n");
+  const output = [];
+  let conditional = true;
+  let currentDefine = null;
+  for (const line of lines) {
+    const matchIf = line.match(IFDEF_REGEXP);
+    const matchEnd = line.match(ENDIF_REGEXP);
+    if (matchIf) {
+      currentDefine = matchIf[1];
+      conditional = Boolean((_a3 = options == null ? void 0 : options.defines) == null ? void 0 : _a3[currentDefine]);
+    } else if (matchEnd) {
+      conditional = true;
+    } else if (conditional) {
+      output.push(line);
+    }
+  }
+  return output.join("\n");
+}
+const _ShaderAssembler = class _ShaderAssembler {
+  constructor() {
+    /** Hook functions */
+    __publicField(this, "_hookFunctions", []);
+    /** Shader modules */
+    __publicField(this, "_defaultModules", []);
+  }
+  /**
+   * A default shader assembler instance - the natural place to register default modules and hooks
+   * @returns
+   */
+  static getDefaultShaderAssembler() {
+    _ShaderAssembler.defaultShaderAssembler = _ShaderAssembler.defaultShaderAssembler || new _ShaderAssembler();
+    return _ShaderAssembler.defaultShaderAssembler;
+  }
+  /**
+   * Add a default module that does not have to be provided with every call to assembleShaders()
+   */
+  addDefaultModule(module) {
+    if (!this._defaultModules.find((m2) => m2.name === (typeof module === "string" ? module : module.name))) {
+      this._defaultModules.push(module);
+    }
+  }
+  /**
+   * Remove a default module
+   */
+  removeDefaultModule(module) {
+    const moduleName = typeof module === "string" ? module : module.name;
+    this._defaultModules = this._defaultModules.filter((m2) => m2.name !== moduleName);
+  }
+  /**
+   * Register a shader hook
+   * @param hook
+   * @param opts
+   */
+  addShaderHook(hook, opts) {
+    if (opts) {
+      hook = Object.assign(opts, { hook });
+    }
+    this._hookFunctions.push(hook);
+  }
+  /**
+   * Assemble a WGSL unified shader
+   * @param platformInfo
+   * @param props
+   * @returns
+   */
+  assembleWGSLShader(props) {
+    const modules = this._getModuleList(props.modules);
+    const hookFunctions = this._hookFunctions;
+    const { source: source2, getUniforms: getUniforms2 } = assembleWGSLShader({
+      ...props,
+      // @ts-expect-error
+      source: props.source,
+      modules,
+      hookFunctions
+    });
+    const preprocessedSource = props.platformInfo.shaderLanguage === "wgsl" ? preprocess(source2) : source2;
+    return { source: preprocessedSource, getUniforms: getUniforms2, modules };
+  }
+  /**
+   * Assemble a pair of shaders into a single shader program
+   * @param platformInfo
+   * @param props
+   * @returns
+   */
+  assembleGLSLShaderPair(props) {
+    const modules = this._getModuleList(props.modules);
+    const hookFunctions = this._hookFunctions;
+    const assembled = assembleGLSLShaderPair({
+      ...props,
+      // @ts-expect-error
+      vs: props.vs,
+      // @ts-expect-error
+      fs: props.fs,
+      modules,
+      hookFunctions
+    });
+    return { ...assembled, modules };
+  }
+  /**
+   * Dedupe and combine with default modules
+   */
+  _getModuleList(appModules = []) {
+    const modules = new Array(this._defaultModules.length + appModules.length);
+    const seen2 = {};
+    let count2 = 0;
+    for (let i2 = 0, len2 = this._defaultModules.length; i2 < len2; ++i2) {
+      const module = this._defaultModules[i2];
+      const name2 = module.name;
+      modules[count2++] = module;
+      seen2[name2] = true;
+    }
+    for (let i2 = 0, len2 = appModules.length; i2 < len2; ++i2) {
+      const module = appModules[i2];
+      const name2 = module.name;
+      if (!seen2[name2]) {
+        modules[count2++] = module;
+        seen2[name2] = true;
+      }
+    }
+    modules.length = count2;
+    initializeShaderModules(modules);
+    return modules;
+  }
+};
+/** Default ShaderAssembler instance */
+__publicField(_ShaderAssembler, "defaultShaderAssembler");
+let ShaderAssembler = _ShaderAssembler;
+const FS_GLES = (
+  /* glsl */
+  `out vec4 transform_output;
+void main() {
+  transform_output = vec4(0);
+}`
+);
+const FS300 = `#version 300 es
+${FS_GLES}`;
+function getPassthroughFS(options) {
+  const { input, inputChannels, output } = {};
+  if (!input) {
+    return FS300;
+  }
+  if (!inputChannels) {
+    throw new Error("inputChannels");
+  }
+  const inputType = channelCountToType(inputChannels);
+  const outputValue = convertToVec4(input, inputChannels);
+  return `#version 300 es
+in ${inputType} ${input};
+out vec4 ${output};
+void main() {
+  ${output} = ${outputValue};
+}`;
+}
+function channelCountToType(channels) {
+  switch (channels) {
+    case 1:
+      return "float";
+    case 2:
+      return "vec2";
+    case 3:
+      return "vec3";
+    case 4:
+      return "vec4";
+    default:
+      throw new Error(`invalid channels: ${channels}`);
+  }
+}
+function convertToVec4(variable, channels) {
+  switch (channels) {
+    case 1:
+      return `vec4(${variable}, 0.0, 0.0, 1.0)`;
+    case 2:
+      return `vec4(${variable}, 0.0, 1.0)`;
+    case 3:
+      return `vec4(${variable}, 1.0)`;
+    case 4:
+      return variable;
+    default:
+      throw new Error(`invalid channels: ${channels}`);
+  }
+}
+class StatsManager {
+  constructor() {
+    __publicField(this, "stats", /* @__PURE__ */ new Map());
+  }
+  getStats(name2) {
+    return this.get(name2);
+  }
+  get(name2) {
+    if (!this.stats.has(name2)) {
+      this.stats.set(name2, new Stats({ id: name2 }));
+    }
+    return this.stats.get(name2);
+  }
+}
+const lumaStats = new StatsManager();
+const log = new ProbeLog({ id: "luma.gl" });
+const uidCounters$2 = {};
+function uid$2(id2 = "id") {
+  uidCounters$2[id2] = uidCounters$2[id2] || 1;
+  const count2 = uidCounters$2[id2]++;
+  return `${id2}-${count2}`;
+}
+let Resource$1 = (_b2 = class {
+  /**
+   * Create a new Resource. Called from Subclass
+   */
+  constructor(device, props, defaultProps2) {
+    /** props.id, for debugging. */
+    __publicField(this, "id");
+    __publicField(this, "props");
+    __publicField(this, "userData", {});
+    __publicField(this, "_device");
+    /** Whether this resource has been destroyed */
+    __publicField(this, "destroyed", false);
+    /** For resources that allocate GPU memory */
+    __publicField(this, "allocatedBytes", 0);
+    /** Attached resources will be destroyed when this resource is destroyed. Tracks auto-created "sub" resources. */
+    __publicField(this, "_attachedResources", /* @__PURE__ */ new Set());
+    if (!device) {
+      throw new Error("no device");
+    }
+    this._device = device;
+    this.props = selectivelyMerge(props, defaultProps2);
+    const id2 = this.props.id !== "undefined" ? this.props.id : uid$2(this[Symbol.toStringTag]);
+    this.props.id = id2;
+    this.id = id2;
+    this.userData = this.props.userData || {};
+    this.addStats();
+  }
+  toString() {
+    return `${this[Symbol.toStringTag] || this.constructor.name}:"${this.id}"`;
+  }
+  /**
+   * destroy can be called on any resource to release it before it is garbage collected.
+   */
+  destroy() {
+    this.destroyResource();
+  }
+  /** @deprecated Use destroy() */
+  delete() {
+    this.destroy();
+    return this;
+  }
+  /**
+   * Combines a map of user props and default props, only including props from defaultProps
+   * @returns returns a map of overridden default props
+   */
+  getProps() {
+    return this.props;
+  }
+  // ATTACHED RESOURCES
+  /**
+   * Attaches a resource. Attached resources are auto destroyed when this resource is destroyed
+   * Called automatically when sub resources are auto created but can be called by application
+   */
+  attachResource(resource) {
+    this._attachedResources.add(resource);
+  }
+  /**
+   * Detach an attached resource. The resource will no longer be auto-destroyed when this resource is destroyed.
+   */
+  detachResource(resource) {
+    this._attachedResources.delete(resource);
+  }
+  /**
+   * Destroys a resource (only if owned), and removes from the owned (auto-destroy) list for this resource.
+   */
+  destroyAttachedResource(resource) {
+    if (this._attachedResources.delete(resource)) {
+      resource.destroy();
+    }
+  }
+  /** Destroy all owned resources. Make sure the resources are no longer needed before calling. */
+  destroyAttachedResources() {
+    for (const resource of Object.values(this._attachedResources)) {
+      resource.destroy();
+    }
+    this._attachedResources = /* @__PURE__ */ new Set();
+  }
+  // PROTECTED METHODS
+  /** Perform all destroy steps. Can be called by derived resources when overriding destroy() */
+  destroyResource() {
+    this.destroyAttachedResources();
+    this.removeStats();
+    this.destroyed = true;
+  }
+  /** Called by .destroy() to track object destruction. Subclass must call if overriding destroy() */
+  removeStats() {
+    const stats = this._device.statsManager.getStats("Resource Counts");
+    const name2 = this[Symbol.toStringTag];
+    stats.get(`${name2}s Active`).decrementCount();
+  }
+  /** Called by subclass to track memory allocations */
+  trackAllocatedMemory(bytes, name2 = this[Symbol.toStringTag]) {
+    const stats = this._device.statsManager.getStats("Resource Counts");
+    stats.get("GPU Memory").addCount(bytes);
+    stats.get(`${name2} Memory`).addCount(bytes);
+    this.allocatedBytes = bytes;
+  }
+  /** Called by subclass to track memory deallocations */
+  trackDeallocatedMemory(name2 = this[Symbol.toStringTag]) {
+    const stats = this._device.statsManager.getStats("Resource Counts");
+    stats.get("GPU Memory").subtractCount(this.allocatedBytes);
+    stats.get(`${name2} Memory`).subtractCount(this.allocatedBytes);
+    this.allocatedBytes = 0;
+  }
+  /** Called by resource constructor to track object creation */
+  addStats() {
+    const stats = this._device.statsManager.getStats("Resource Counts");
+    const name2 = this[Symbol.toStringTag];
+    stats.get("Resources Created").incrementCount();
+    stats.get(`${name2}s Created`).incrementCount();
+    stats.get(`${name2}s Active`).incrementCount();
+  }
+}, /** Default properties for resource */
+__publicField(_b2, "defaultProps", {
+  id: "undefined",
+  handle: void 0,
+  userData: void 0
+}), _b2);
+function selectivelyMerge(props, defaultProps2) {
+  const mergedProps = { ...defaultProps2 };
+  for (const key in props) {
+    if (props[key] !== void 0) {
+      mergedProps[key] = props[key];
+    }
+  }
+  return mergedProps;
+}
+let Buffer$1 = (_c2 = class extends Resource$1 {
+  constructor(device, props) {
+    const deducedProps = { ...props };
+    if ((props.usage || 0) & _c2.INDEX && !props.indexType) {
+      if (props.data instanceof Uint32Array) {
+        deducedProps.indexType = "uint32";
+      } else if (props.data instanceof Uint16Array) {
+        deducedProps.indexType = "uint16";
+      } else if (props.data instanceof Uint8Array) {
+        deducedProps.indexType = "uint8";
+      }
+    }
+    delete deducedProps.data;
+    super(device, deducedProps, _c2.defaultProps);
+    /** The usage with which this buffer was created */
+    __publicField(this, "usage");
+    /** For index buffers, whether indices are 8, 16 or 32 bit. Note: uint8 indices are automatically converted to uint16 for WebGPU compatibility */
+    __publicField(this, "indexType");
+    /** "Time" of last update, can be used to check if redraw is needed */
+    __publicField(this, "updateTimestamp");
+    /** A partial CPU-side copy of the data in this buffer, for debugging purposes */
+    __publicField(this, "debugData", new ArrayBuffer(0));
+    this.usage = deducedProps.usage || 0;
+    this.indexType = deducedProps.indexType;
+    this.updateTimestamp = device.incrementTimestamp();
+  }
+  get [Symbol.toStringTag]() {
+    return "Buffer";
+  }
+  /**
+   * Create a copy of this Buffer with new byteLength, with same props but of the specified size.
+   * @note Does not copy contents of the cloned Buffer.
+   */
+  clone(props) {
+    return this.device.createBuffer({ ...this.props, ...props });
+  }
+  /** This doesn't handle partial non-zero offset updates correctly */
+  _setDebugData(data, byteOffset, byteLength) {
+    const arrayBuffer2 = ArrayBuffer.isView(data) ? data.buffer : data;
+    const debugDataLength = Math.min(data ? data.byteLength : byteLength, _c2.DEBUG_DATA_MAX_LENGTH);
+    if (arrayBuffer2 === null) {
+      this.debugData = new ArrayBuffer(debugDataLength);
+    } else if (byteOffset === 0 && byteLength === arrayBuffer2.byteLength) {
+      this.debugData = arrayBuffer2.slice(0, debugDataLength);
+    } else {
+      this.debugData = arrayBuffer2.slice(byteOffset, byteOffset + debugDataLength);
+    }
+  }
+}, /** Index buffer */
+__publicField(_c2, "INDEX", 16), /** Vertex buffer */
+__publicField(_c2, "VERTEX", 32), /** Uniform buffer */
+__publicField(_c2, "UNIFORM", 64), /** Storage buffer */
+__publicField(_c2, "STORAGE", 128), __publicField(_c2, "INDIRECT", 256), __publicField(_c2, "QUERY_RESOLVE", 512), // Usage Flags
+__publicField(_c2, "MAP_READ", 1), __publicField(_c2, "MAP_WRITE", 2), __publicField(_c2, "COPY_SRC", 4), __publicField(_c2, "COPY_DST", 8), // PROTECTED METHODS (INTENDED FOR USE BY OTHER FRAMEWORK CODE ONLY)
+/** Max amount of debug data saved. Two vec4's */
+__publicField(_c2, "DEBUG_DATA_MAX_LENGTH", 32), __publicField(_c2, "defaultProps", {
+  ...Resource$1.defaultProps,
+  usage: 0,
+  // Buffer.COPY_DST | Buffer.COPY_SRC
+  byteLength: 0,
+  byteOffset: 0,
+  data: null,
+  indexType: "uint16",
+  onMapped: void 0
+}), _c2);
+function getDataTypeInfo(type) {
+  const [signedType, primitiveType, byteLength] = NORMALIZED_TYPE_MAP[type];
+  const normalized = type.includes("norm");
+  const integer = !normalized && !type.startsWith("float");
+  const signed = type.startsWith("s");
+  return {
+    signedType,
+    primitiveType,
+    byteLength,
+    normalized,
+    integer,
+    signed
+  };
+}
+function getNormalizedDataType(signedDataType) {
+  const dataType = signedDataType;
+  switch (dataType) {
+    case "uint8":
+      return "unorm8";
+    case "sint8":
+      return "snorm8";
+    case "uint16":
+      return "unorm16";
+    case "sint16":
+      return "snorm16";
+    default:
+      return dataType;
+  }
+}
+function alignTo(size, count2) {
+  switch (count2) {
+    case 1:
+      return size;
+    case 2:
+      return size + size % 2;
+    default:
+      return size + (4 - size % 4) % 4;
+  }
+}
+function getDataType(arrayOrType) {
+  const Constructor = ArrayBuffer.isView(arrayOrType) ? arrayOrType.constructor : arrayOrType;
+  if (Constructor === Uint8ClampedArray) {
+    return "uint8";
+  }
+  const info = Object.values(NORMALIZED_TYPE_MAP).find((entry) => Constructor === entry[4]);
+  if (!info) {
+    throw new Error(Constructor.name);
+  }
+  return info[0];
+}
+function getTypedArrayConstructor(type) {
+  const [, , , , Constructor] = NORMALIZED_TYPE_MAP[type];
+  return Constructor;
+}
+const NORMALIZED_TYPE_MAP = {
+  uint8: ["uint8", "u32", 1, false, Uint8Array],
+  sint8: ["sint8", "i32", 1, false, Int8Array],
+  unorm8: ["uint8", "f32", 1, true, Uint8Array],
+  snorm8: ["sint8", "f32", 1, true, Int8Array],
+  uint16: ["uint16", "u32", 2, false, Uint16Array],
+  sint16: ["sint16", "i32", 2, false, Int16Array],
+  unorm16: ["uint16", "u32", 2, true, Uint16Array],
+  snorm16: ["sint16", "i32", 2, true, Int16Array],
+  float16: ["float16", "f16", 2, false, Uint16Array],
+  float32: ["float32", "f32", 4, false, Float32Array],
+  uint32: ["uint32", "u32", 4, false, Uint32Array],
+  sint32: ["sint32", "i32", 4, false, Int32Array]
+};
+function getVertexFormatInfo(format) {
+  let webglOnly;
+  if (format.endsWith("-webgl")) {
+    format.replace("-webgl", "");
+    webglOnly = true;
+  }
+  const [type_, count2] = format.split("x");
+  const type = type_;
+  const components = count2 ? parseInt(count2) : 1;
+  const decodedType = getDataTypeInfo(type);
+  const result = {
+    type,
+    components,
+    byteLength: decodedType.byteLength * components,
+    integer: decodedType.integer,
+    signed: decodedType.signed,
+    normalized: decodedType.normalized
+  };
+  if (webglOnly) {
+    result.webglOnly = true;
+  }
+  return result;
+}
+function makeVertexFormat(signedDataType, components, normalized) {
+  const dataType = normalized ? getNormalizedDataType(signedDataType) : signedDataType;
+  switch (dataType) {
+    case "unorm8":
+      if (components === 1) {
+        return "unorm8";
+      }
+      if (components === 3) {
+        return "unorm8x3-webgl";
+      }
+      return `${dataType}x${components}`;
+    case "snorm8":
+    case "uint8":
+    case "sint8":
+    case "uint16":
+    case "sint16":
+    case "unorm16":
+    case "snorm16":
+    case "float16":
+      if (components === 1 || components === 3) {
+        throw new Error(`size: ${components}`);
+      }
+      return `${dataType}x${components}`;
+    default:
+      return components === 1 ? dataType : `${dataType}x${components}`;
+  }
+}
+function getVertexFormatFromAttribute(typedArray, size, normalized) {
+  if (!size || size > 4) {
+    throw new Error(`size ${size}`);
+  }
+  const components = size;
+  const signedDataType = getDataType(typedArray);
+  return makeVertexFormat(signedDataType, components, normalized);
+}
+function getCompatibleVertexFormat(opts) {
+  let vertexType;
+  switch (opts.primitiveType) {
+    case "f32":
+      vertexType = "float32";
+      break;
+    case "i32":
+      vertexType = "sint32";
+      break;
+    case "u32":
+      vertexType = "uint32";
+      break;
+    case "f16":
+      return opts.components <= 2 ? "float16x2" : "float16x4";
+  }
+  if (opts.components === 1) {
+    return vertexType;
+  }
+  return `${vertexType}x${opts.components}`;
+}
+const texture_compression_bc = "texture-compression-bc";
+const texture_compression_astc = "texture-compression-astc";
+const texture_compression_etc2 = "texture-compression-etc2";
+const texture_compression_etc1_webgl = "texture-compression-etc1-webgl";
+const texture_compression_pvrtc_webgl = "texture-compression-pvrtc-webgl";
+const texture_compression_atc_webgl = "texture-compression-atc-webgl";
+const float32_renderable = "float32-renderable-webgl";
+const float16_renderable = "float16-renderable-webgl";
+const rgb9e5ufloat_renderable = "rgb9e5ufloat-renderable-webgl";
+const snorm8_renderable = "snorm8-renderable-webgl";
+const norm16_renderable = "norm16-renderable-webgl";
+const snorm16_renderable = "snorm16-renderable-webgl";
+const float32_filterable = "float32-filterable";
+const float16_filterable = "float16-filterable-webgl";
+function getTextureFormatDefinition(format) {
+  const info = TEXTURE_FORMAT_TABLE[format];
+  if (!info) {
+    throw new Error(`Unsupported texture format ${format}`);
+  }
+  return info;
+}
+const TEXTURE_FORMAT_COLOR_DEPTH_TABLE = {
+  // 8-bit formats
+  "r8unorm": {},
+  "rg8unorm": {},
+  "rgb8unorm-webgl": {},
+  "rgba8unorm": {},
+  "rgba8unorm-srgb": {},
+  "r8snorm": { render: snorm8_renderable },
+  "rg8snorm": { render: snorm8_renderable },
+  "rgb8snorm-webgl": {},
+  "rgba8snorm": { render: snorm8_renderable },
+  "r8uint": {},
+  "rg8uint": {},
+  "rgba8uint": {},
+  "r8sint": {},
+  "rg8sint": {},
+  "rgba8sint": {},
+  "bgra8unorm": {},
+  "bgra8unorm-srgb": {},
+  "r16unorm": { f: norm16_renderable },
+  "rg16unorm": { render: norm16_renderable },
+  "rgb16unorm-webgl": { f: norm16_renderable },
+  // rgb not renderable
+  "rgba16unorm": { render: norm16_renderable },
+  "r16snorm": { f: snorm16_renderable },
+  "rg16snorm": { render: snorm16_renderable },
+  "rgb16snorm-webgl": { f: norm16_renderable },
+  // rgb not renderable
+  "rgba16snorm": { render: snorm16_renderable },
+  "r16uint": {},
+  "rg16uint": {},
+  "rgba16uint": {},
+  "r16sint": {},
+  "rg16sint": {},
+  "rgba16sint": {},
+  "r16float": { render: float16_renderable, filter: "float16-filterable-webgl" },
+  "rg16float": { render: float16_renderable, filter: float16_filterable },
+  "rgba16float": { render: float16_renderable, filter: float16_filterable },
+  "r32uint": {},
+  "rg32uint": {},
+  "rgba32uint": {},
+  "r32sint": {},
+  "rg32sint": {},
+  "rgba32sint": {},
+  "r32float": { render: float32_renderable, filter: float32_filterable },
+  "rg32float": { render: false, filter: float32_filterable },
+  "rgb32float-webgl": { render: float32_renderable, filter: float32_filterable },
+  "rgba32float": { render: float32_renderable, filter: float32_filterable },
+  // Packed 16-bit formats
+  "rgba4unorm-webgl": { channels: "rgba", bitsPerChannel: [4, 4, 4, 4], packed: true },
+  "rgb565unorm-webgl": { channels: "rgb", bitsPerChannel: [5, 6, 5, 0], packed: true },
+  "rgb5a1unorm-webgl": { channels: "rgba", bitsPerChannel: [5, 5, 5, 1], packed: true },
+  // Packed 32 bit formats
+  "rgb9e5ufloat": { channels: "rgb", packed: true, render: rgb9e5ufloat_renderable },
+  // , filter: true},
+  "rg11b10ufloat": { channels: "rgb", bitsPerChannel: [11, 11, 10, 0], packed: true, p: 1, render: float32_renderable },
+  "rgb10a2unorm": { channels: "rgba", bitsPerChannel: [10, 10, 10, 2], packed: true, p: 1 },
+  "rgb10a2uint": { channels: "rgba", bitsPerChannel: [10, 10, 10, 2], packed: true, p: 1 },
+  // Depth/stencil Formats
+  // Depth and stencil formats
+  stencil8: { attachment: "stencil", bitsPerChannel: [8, 0, 0, 0], dataType: "uint8" },
+  "depth16unorm": { attachment: "depth", bitsPerChannel: [16, 0, 0, 0], dataType: "uint16" },
+  "depth24plus": { attachment: "depth", bitsPerChannel: [24, 0, 0, 0], dataType: "uint32" },
+  "depth32float": { attachment: "depth", bitsPerChannel: [32, 0, 0, 0], dataType: "float32" },
+  // The depth component of the "depth24plus" and "depth24plus-stencil8" formats may be implemented as either a 24-bit depth value or a "depth32float" value.
+  "depth24plus-stencil8": { attachment: "depth-stencil", bitsPerChannel: [24, 8, 0, 0], packed: true },
+  // "depth32float-stencil8" feature
+  "depth32float-stencil8": { attachment: "depth-stencil", bitsPerChannel: [32, 8, 0, 0], packed: true }
+};
+const TEXTURE_FORMAT_COMPRESSED_TABLE = {
+  // BC compressed formats: check device.features.has("texture-compression-bc");
+  "bc1-rgb-unorm-webgl": { f: texture_compression_bc },
+  "bc1-rgb-unorm-srgb-webgl": { f: texture_compression_bc },
+  "bc1-rgba-unorm": { f: texture_compression_bc },
+  "bc1-rgba-unorm-srgb": { f: texture_compression_bc },
+  "bc2-rgba-unorm": { f: texture_compression_bc },
+  "bc2-rgba-unorm-srgb": { f: texture_compression_bc },
+  "bc3-rgba-unorm": { f: texture_compression_bc },
+  "bc3-rgba-unorm-srgb": { f: texture_compression_bc },
+  "bc4-r-unorm": { f: texture_compression_bc },
+  "bc4-r-snorm": { f: texture_compression_bc },
+  "bc5-rg-unorm": { f: texture_compression_bc },
+  "bc5-rg-snorm": { f: texture_compression_bc },
+  "bc6h-rgb-ufloat": { f: texture_compression_bc },
+  "bc6h-rgb-float": { f: texture_compression_bc },
+  "bc7-rgba-unorm": { f: texture_compression_bc },
+  "bc7-rgba-unorm-srgb": { f: texture_compression_bc },
+  // WEBGL_compressed_texture_etc: device.features.has("texture-compression-etc2")
+  // Note: Supposedly guaranteed availability compressed formats in WebGL2, but through CPU decompression
+  "etc2-rgb8unorm": { f: texture_compression_etc2 },
+  "etc2-rgb8unorm-srgb": { f: texture_compression_etc2 },
+  "etc2-rgb8a1unorm": { f: texture_compression_etc2 },
+  "etc2-rgb8a1unorm-srgb": { f: texture_compression_etc2 },
+  "etc2-rgba8unorm": { f: texture_compression_etc2 },
+  "etc2-rgba8unorm-srgb": { f: texture_compression_etc2 },
+  "eac-r11unorm": { f: texture_compression_etc2 },
+  "eac-r11snorm": { f: texture_compression_etc2 },
+  "eac-rg11unorm": { f: texture_compression_etc2 },
+  "eac-rg11snorm": { f: texture_compression_etc2 },
+  // X_ASTC compressed formats: device.features.has("texture-compression-astc")
+  "astc-4x4-unorm": { f: texture_compression_astc },
+  "astc-4x4-unorm-srgb": { f: texture_compression_astc },
+  "astc-5x4-unorm": { f: texture_compression_astc },
+  "astc-5x4-unorm-srgb": { f: texture_compression_astc },
+  "astc-5x5-unorm": { f: texture_compression_astc },
+  "astc-5x5-unorm-srgb": { f: texture_compression_astc },
+  "astc-6x5-unorm": { f: texture_compression_astc },
+  "astc-6x5-unorm-srgb": { f: texture_compression_astc },
+  "astc-6x6-unorm": { f: texture_compression_astc },
+  "astc-6x6-unorm-srgb": { f: texture_compression_astc },
+  "astc-8x5-unorm": { f: texture_compression_astc },
+  "astc-8x5-unorm-srgb": { f: texture_compression_astc },
+  "astc-8x6-unorm": { f: texture_compression_astc },
+  "astc-8x6-unorm-srgb": { f: texture_compression_astc },
+  "astc-8x8-unorm": { f: texture_compression_astc },
+  "astc-8x8-unorm-srgb": { f: texture_compression_astc },
+  "astc-10x5-unorm": { f: texture_compression_astc },
+  "astc-10x5-unorm-srgb": { f: texture_compression_astc },
+  "astc-10x6-unorm": { f: texture_compression_astc },
+  "astc-10x6-unorm-srgb": { f: texture_compression_astc },
+  "astc-10x8-unorm": { f: texture_compression_astc },
+  "astc-10x8-unorm-srgb": { f: texture_compression_astc },
+  "astc-10x10-unorm": { f: texture_compression_astc },
+  "astc-10x10-unorm-srgb": { f: texture_compression_astc },
+  "astc-12x10-unorm": { f: texture_compression_astc },
+  "astc-12x10-unorm-srgb": { f: texture_compression_astc },
+  "astc-12x12-unorm": { f: texture_compression_astc },
+  "astc-12x12-unorm-srgb": { f: texture_compression_astc },
+  // WEBGL_compressed_texture_pvrtc
+  "pvrtc-rgb4unorm-webgl": { f: texture_compression_pvrtc_webgl },
+  "pvrtc-rgba4unorm-webgl": { f: texture_compression_pvrtc_webgl },
+  "pvrtc-rbg2unorm-webgl": { f: texture_compression_pvrtc_webgl },
+  "pvrtc-rgba2unorm-webgl": { f: texture_compression_pvrtc_webgl },
+  // WEBGL_compressed_texture_etc1
+  "etc1-rbg-unorm-webgl": { f: texture_compression_etc1_webgl },
+  // WEBGL_compressed_texture_atc
+  "atc-rgb-unorm-webgl": { f: texture_compression_atc_webgl },
+  "atc-rgba-unorm-webgl": { f: texture_compression_atc_webgl },
+  "atc-rgbai-unorm-webgl": { f: texture_compression_atc_webgl }
+};
+const TEXTURE_FORMAT_TABLE = {
+  ...TEXTURE_FORMAT_COLOR_DEPTH_TABLE,
+  ...TEXTURE_FORMAT_COMPRESSED_TABLE
+};
+const COMPRESSED_TEXTURE_FORMAT_PREFIXES = [
+  "bc1",
+  "bc2",
+  "bc3",
+  "bc4",
+  "bc5",
+  "bc6",
+  "bc7",
+  "etc1",
+  "etc2",
+  "eac",
+  "atc",
+  "astc",
+  "pvrtc"
+];
+const RGB_FORMAT_REGEX = /^(r|rg|rgb|rgba|bgra)([0-9]*)([a-z]*)(-srgb)?(-webgl)?$/;
+class TextureFormatDecoder {
+  /** Returns information about a texture format, e.g. attatchment type, components, byte length and flags (integer, signed, normalized) */
+  getInfo(format) {
+    return getTextureFormatInfo(format);
+  }
+  /** Checks if a texture format is color */
+  isColor(format) {
+    return format.startsWith("rgba") || format.startsWith("bgra") || format.startsWith("rgb");
+  }
+  /** Checks if a texture format is depth or stencil */
+  isDepthStencil(format) {
+    return format.startsWith("depth") || format.startsWith("stencil");
+  }
+  /** Checks if a texture format is compressed */
+  isCompressed(format) {
+    return COMPRESSED_TEXTURE_FORMAT_PREFIXES.some((prefix) => format.startsWith(prefix));
+  }
+  /**
+   * Returns the "static" capabilities of a texture format.
+   * @note Needs to be checked against current device
+   */
+  getCapabilities(format) {
+    const info = getTextureFormatDefinition(format);
+    const formatCapabilities = {
+      format,
+      create: info.f ?? true,
+      render: info.render ?? true,
+      filter: info.filter ?? true,
+      blend: info.blend ?? true,
+      store: info.store ?? true
+    };
+    const formatInfo = getTextureFormatInfo(format);
+    const isDepthStencil = format.startsWith("depth") || format.startsWith("stencil");
+    const isSigned = formatInfo == null ? void 0 : formatInfo.signed;
+    const isInteger = formatInfo == null ? void 0 : formatInfo.integer;
+    const isWebGLSpecific = formatInfo == null ? void 0 : formatInfo.webgl;
+    formatCapabilities.render && (formatCapabilities.render = !isSigned);
+    formatCapabilities.filter && (formatCapabilities.filter = !isDepthStencil && !isSigned && !isInteger && !isWebGLSpecific);
+    return formatCapabilities;
+  }
+}
+const textureFormatDecoder = new TextureFormatDecoder();
+function getTextureFormatInfo(format) {
+  let formatInfo = getTextureFormatInfoUsingTable(format);
+  if (textureFormatDecoder.isCompressed(format)) {
+    formatInfo.channels = "rgb";
+    formatInfo.components = 3;
+    formatInfo.bytesPerPixel = 1;
+    formatInfo.srgb = false;
+    formatInfo.compressed = true;
+    const blockSize = getCompressedTextureBlockSize(format);
+    if (blockSize) {
+      formatInfo.blockWidth = blockSize.blockWidth;
+      formatInfo.blockHeight = blockSize.blockHeight;
+    }
+  }
+  const matches2 = RGB_FORMAT_REGEX.exec(format);
+  if (matches2) {
+    const [, channels, length2, type, srgb, suffix] = matches2;
+    const dataType = `${type}${length2}`;
+    const decodedType = getDataTypeInfo(dataType);
+    const bits = decodedType.byteLength * 8;
+    const components = channels.length;
+    const bitsPerChannel = [
+      bits,
+      components >= 2 ? bits : 0,
+      components >= 3 ? bits : 0,
+      components >= 4 ? bits : 0
+    ];
+    formatInfo = {
+      format,
+      attachment: formatInfo.attachment,
+      dataType: decodedType.signedType,
+      components,
+      channels,
+      integer: decodedType.integer,
+      signed: decodedType.signed,
+      normalized: decodedType.normalized,
+      bitsPerChannel,
+      bytesPerPixel: decodedType.byteLength * channels.length,
+      packed: formatInfo.packed,
+      srgb: formatInfo.srgb
+    };
+    if (suffix === "-webgl") {
+      formatInfo.webgl = true;
+    }
+    if (srgb === "-srgb") {
+      formatInfo.srgb = true;
+    }
+  }
+  if (format.endsWith("-webgl")) {
+    formatInfo.webgl = true;
+  }
+  if (format.endsWith("-srgb")) {
+    formatInfo.srgb = true;
+  }
+  return formatInfo;
+}
+function getTextureFormatInfoUsingTable(format) {
+  var _a3;
+  const info = getTextureFormatDefinition(format);
+  const bytesPerPixel = info.bytesPerPixel || 1;
+  const bitsPerChannel = info.bitsPerChannel || [8, 8, 8, 8];
+  delete info.bitsPerChannel;
+  delete info.bytesPerPixel;
+  delete info.f;
+  delete info.render;
+  delete info.filter;
+  delete info.blend;
+  delete info.store;
+  const formatInfo = {
+    ...info,
+    format,
+    attachment: info.attachment || "color",
+    channels: info.channels || "r",
+    components: info.components || ((_a3 = info.channels) == null ? void 0 : _a3.length) || 1,
+    bytesPerPixel,
+    bitsPerChannel,
+    dataType: info.dataType || "uint8",
+    srgb: info.srgb ?? false,
+    packed: info.packed ?? false,
+    webgl: info.webgl ?? false,
+    integer: info.integer ?? false,
+    signed: info.signed ?? false,
+    normalized: info.normalized ?? false,
+    compressed: info.compressed ?? false
+  };
+  return formatInfo;
+}
+function getCompressedTextureBlockSize(format) {
+  const REGEX = /.*-(\d+)x(\d+)-.*/;
+  const matches2 = REGEX.exec(format);
+  if (matches2) {
+    const [, blockWidth, blockHeight] = matches2;
+    return { blockWidth: Number(blockWidth), blockHeight: Number(blockHeight) };
+  }
+  return null;
+}
+function isExternalImage(data) {
+  return typeof ImageData !== "undefined" && data instanceof ImageData || typeof ImageBitmap !== "undefined" && data instanceof ImageBitmap || typeof HTMLImageElement !== "undefined" && data instanceof HTMLImageElement || typeof HTMLVideoElement !== "undefined" && data instanceof HTMLVideoElement || typeof VideoFrame !== "undefined" && data instanceof VideoFrame || typeof HTMLCanvasElement !== "undefined" && data instanceof HTMLCanvasElement || typeof OffscreenCanvas !== "undefined" && data instanceof OffscreenCanvas;
+}
+function getExternalImageSize(data) {
+  if (typeof ImageData !== "undefined" && data instanceof ImageData || typeof ImageBitmap !== "undefined" && data instanceof ImageBitmap || typeof HTMLCanvasElement !== "undefined" && data instanceof HTMLCanvasElement || typeof OffscreenCanvas !== "undefined" && data instanceof OffscreenCanvas) {
+    return { width: data.width, height: data.height };
+  }
+  if (typeof HTMLImageElement !== "undefined" && data instanceof HTMLImageElement) {
+    return { width: data.naturalWidth, height: data.naturalHeight };
+  }
+  if (typeof HTMLVideoElement !== "undefined" && data instanceof HTMLVideoElement) {
+    return { width: data.videoWidth, height: data.videoHeight };
+  }
+  if (typeof VideoFrame !== "undefined" && data instanceof VideoFrame) {
+    return { width: data.displayWidth, height: data.displayHeight };
+  }
+  throw new Error("Unknown image type");
+}
+class DeviceLimits {
+}
+class DeviceFeatures {
+  constructor(features = [], disabledFeatures) {
+    __publicField(this, "features");
+    __publicField(this, "disabledFeatures");
+    this.features = new Set(features);
+    this.disabledFeatures = disabledFeatures || {};
+  }
+  *[Symbol.iterator]() {
+    yield* this.features;
+  }
+  has(feature) {
+    var _a3;
+    return !((_a3 = this.disabledFeatures) == null ? void 0 : _a3[feature]) && this.features.has(feature);
+  }
+}
+const _Device = class _Device {
+  constructor(props) {
+    /** id of this device, primarily for debugging */
+    __publicField(this, "id");
+    /** A copy of the device props  */
+    __publicField(this, "props");
+    /** Available for the application to store data on the device */
+    __publicField(this, "userData", {});
+    /** stats */
+    __publicField(this, "statsManager", lumaStats);
+    /** An abstract timestamp used for change tracking */
+    __publicField(this, "timestamp", 0);
+    /** True if this device has been reused during device creation (app has multiple references) */
+    __publicField(this, "_reused", false);
+    /** Used by other luma.gl modules to store data on the device */
+    __publicField(this, "_lumaData", {});
+    __publicField(this, "_textureCaps", {});
+    this.props = { ..._Device.defaultProps, ...props };
+    this.id = this.props.id || uid$2(this[Symbol.toStringTag].toLowerCase());
+  }
+  get [Symbol.toStringTag]() {
+    return "Device";
+  }
+  toString() {
+    return `Device(${this.id})`;
+  }
+  getVertexFormatInfo(format) {
+    return getVertexFormatInfo(format);
+  }
+  isVertexFormatSupported(format) {
+    return true;
+  }
+  /** Returns information about a texture format, such as data type, channels, bits per channel, compression etc */
+  getTextureFormatInfo(format) {
+    return textureFormatDecoder.getInfo(format);
+  }
+  /** Determines what operations are supported on a texture format on this particular device (checks against supported device features) */
+  getTextureFormatCapabilities(format) {
+    let textureCaps = this._textureCaps[format];
+    if (!textureCaps) {
+      const capabilities = this._getDeviceTextureFormatCapabilities(format);
+      textureCaps = this._getDeviceSpecificTextureFormatCapabilities(capabilities);
+      this._textureCaps[format] = textureCaps;
+    }
+    return textureCaps;
+  }
+  /** Calculates the number of mip levels for a texture of width, height and in case of 3d textures only, depth */
+  getMipLevelCount(width, height, depth3d = 1) {
+    const maxSize = Math.max(width, height, depth3d);
+    return 1 + Math.floor(Math.log2(maxSize));
+  }
+  /** Check if data is an external image */
+  isExternalImage(data) {
+    return isExternalImage(data);
+  }
+  /** Get the size of an external image */
+  getExternalImageSize(data) {
+    return getExternalImageSize(data);
+  }
+  /** Check if device supports a specific texture format (creation and `nearest` sampling) */
+  isTextureFormatSupported(format) {
+    return this.getTextureFormatCapabilities(format).create;
+  }
+  /** Check if linear filtering (sampler interpolation) is supported for a specific texture format */
+  isTextureFormatFilterable(format) {
+    return this.getTextureFormatCapabilities(format).filter;
+  }
+  /** Check if device supports rendering to a framebuffer color attachment of a specific texture format */
+  isTextureFormatRenderable(format) {
+    return this.getTextureFormatCapabilities(format).render;
+  }
+  /** Check if a specific texture format is GPU compressed */
+  isTextureFormatCompressed(format) {
+    return textureFormatDecoder.isCompressed(format);
+  }
+  // DEBUG METHODS
+  pushDebugGroup(groupLabel) {
+    this.commandEncoder.pushDebugGroup(groupLabel);
+  }
+  popDebugGroup() {
+    var _a3;
+    (_a3 = this.commandEncoder) == null ? void 0 : _a3.popDebugGroup();
+  }
+  insertDebugMarker(markerLabel) {
+    var _a3;
+    (_a3 = this.commandEncoder) == null ? void 0 : _a3.insertDebugMarker(markerLabel);
+  }
+  /**
+   * Trigger device loss.
+   * @returns `true` if context loss could actually be triggered.
+   * @note primarily intended for testing how application reacts to device loss
+   */
+  loseDevice() {
+    return false;
+  }
+  /** A monotonic counter for tracking buffer and texture updates */
+  incrementTimestamp() {
+    return this.timestamp++;
+  }
+  /**
+   * Reports Device errors in a way that optimizes for developer experience / debugging.
+   * - Logs so that the console error links directly to the source code that generated the error.
+   * - Includes the object that reported the error in the log message, even if the error is asynchronous.
+   *
+   * Conventions when calling reportError():
+   * - Always call the returned function - to ensure error is logged, at the error site
+   * - Follow with a call to device.debug() - to ensure that the debugger breaks at the error site
+   *
+   * @param error - the error to report. If needed, just create a new Error object with the appropriate message.
+   * @param context - pass `this` as context, otherwise it may not be available in the debugger for async errors.
+   * @returns the logger function returned by device.props.onError() so that it can be called from the error site.
+   *
+   * @example
+   *   device.reportError(new Error(...), this)();
+   *   device.debug();
+   */
+  reportError(error, context, ...args) {
+    const isHandled = this.props.onError(error, context);
+    if (!isHandled) {
+      return log.error(error.message, context, ...args);
+    }
+    return () => {
+    };
+  }
+  /** Break in the debugger - if device.props.debug is true */
+  debug() {
+    if (this.props.debug) {
+      debugger;
+    } else {
+      const message2 = `'Type luma.log.set({debug: true}) in console to enable debug breakpoints',
+or create a device with the 'debug: true' prop.`;
+      log.once(0, message2)();
+    }
+  }
+  /** Returns the default / primary canvas context. Throws an error if no canvas context is available (a WebGPU compute device) */
+  getDefaultCanvasContext() {
+    if (!this.canvasContext) {
+      throw new Error("Device has no default CanvasContext. See props.createCanvasContext");
+    }
+    return this.canvasContext;
+  }
+  /** Create a RenderPass using the default CommandEncoder */
+  beginRenderPass(props) {
+    return this.commandEncoder.beginRenderPass(props);
+  }
+  /** Create a ComputePass using the default CommandEncoder*/
+  beginComputePass(props) {
+    return this.commandEncoder.beginComputePass(props);
+  }
+  // DEPRECATED METHODS
+  /** @deprecated Use getDefaultCanvasContext() */
+  getCanvasContext() {
+    return this.getDefaultCanvasContext();
+  }
+  // WebGL specific HACKS - enables app to remove webgl import
+  // Use until we have a better way to handle these
+  /** @deprecated - will be removed - should use command encoder */
+  readPixelsToArrayWebGL(source2, options) {
+    throw new Error("not implemented");
+  }
+  /** @deprecated - will be removed - should use command encoder */
+  readPixelsToBufferWebGL(source2, options) {
+    throw new Error("not implemented");
+  }
+  /** @deprecated - will be removed - should use WebGPU parameters (pipeline) */
+  setParametersWebGL(parameters) {
+    throw new Error("not implemented");
+  }
+  /** @deprecated - will be removed - should use WebGPU parameters (pipeline) */
+  getParametersWebGL(parameters) {
+    throw new Error("not implemented");
+  }
+  /** @deprecated - will be removed - should use WebGPU parameters (pipeline) */
+  withParametersWebGL(parameters, func) {
+    throw new Error("not implemented");
+  }
+  /** @deprecated - will be removed - should use clear arguments in RenderPass */
+  clearWebGL(options) {
+    throw new Error("not implemented");
+  }
+  /** @deprecated - will be removed - should use for debugging only */
+  resetWebGL() {
+    throw new Error("not implemented");
+  }
+  // IMPLEMENTATION
+  /** Helper to get the canvas context props */
+  static _getCanvasContextProps(props) {
+    return props.createCanvasContext === true ? {} : props.createCanvasContext;
+  }
+  _getDeviceTextureFormatCapabilities(format) {
+    const genericCapabilities = textureFormatDecoder.getCapabilities(format);
+    const checkFeature = (feature) => (typeof feature === "string" ? this.features.has(feature) : feature) ?? true;
+    const supported = checkFeature(genericCapabilities.create);
+    return {
+      format,
+      create: supported,
+      render: supported && checkFeature(genericCapabilities.render),
+      filter: supported && checkFeature(genericCapabilities.filter),
+      blend: supported && checkFeature(genericCapabilities.blend),
+      store: supported && checkFeature(genericCapabilities.store)
+    };
+  }
+  /** Subclasses use this to support .createBuffer() overloads */
+  _normalizeBufferProps(props) {
+    if (props instanceof ArrayBuffer || ArrayBuffer.isView(props)) {
+      props = { data: props };
+    }
+    const newProps = { ...props };
+    const usage = props.usage || 0;
+    if (usage & Buffer$1.INDEX) {
+      if (!props.indexType) {
+        if (props.data instanceof Uint32Array) {
+          newProps.indexType = "uint32";
+        } else if (props.data instanceof Uint16Array) {
+          newProps.indexType = "uint16";
+        } else if (props.data instanceof Uint8Array) {
+          newProps.data = new Uint16Array(props.data);
+          newProps.indexType = "uint16";
+        }
+      }
+      if (!newProps.indexType) {
+        throw new Error("indices buffer content must be of type uint16 or uint32");
+      }
+    }
+    return newProps;
+  }
+};
+__publicField(_Device, "defaultProps", {
+  id: null,
+  powerPreference: "high-performance",
+  failIfMajorPerformanceCaveat: false,
+  createCanvasContext: void 0,
+  // WebGL specific
+  webgl: {},
+  // Callbacks
+  // eslint-disable-next-line handle-callback-err
+  onError: (error, context) => {
+  },
+  onResize: (context, info) => {
+    const [width, height] = context.getDevicePixelSize();
+    log.log(1, `${context} resized => ${width}x${height}px`)();
+  },
+  onPositionChange: (context, info) => {
+    const [left, top] = context.getPosition();
+    log.log(1, `${context} repositioned => ${left},${top}`)();
+  },
+  onVisibilityChange: (context) => log.log(1, `${context} Visibility changed ${context.isVisible}`)(),
+  onDevicePixelRatioChange: (context, info) => log.log(1, `${context} DPR changed ${info.oldRatio} => ${context.devicePixelRatio}`)(),
+  // Debug flags
+  debug: log.get("debug") || void 0,
+  debugShaders: log.get("debug-shaders") || void 0,
+  debugFramebuffers: Boolean(log.get("debug-framebuffers")),
+  debugFactories: Boolean(log.get("debug-factories")),
+  debugWebGL: Boolean(log.get("debug-webgl")),
+  debugSpectorJS: void 0,
+  // Note: log setting is queried by the spector.js code
+  debugSpectorJSUrl: void 0,
+  // Experimental
+  _reuseDevices: false,
+  _requestMaxLimits: true,
+  _cacheShaders: false,
+  _cachePipelines: false,
+  _cacheDestroyPolicy: "unused",
+  // TODO - Change these after confirming things work as expected
+  _initializeFeatures: true,
+  _disabledFeatures: {
+    "compilation-status-async-webgl": true
+  },
+  // INTERNAL
+  _handle: void 0
+});
+let Device = _Device;
+const STARTUP_MESSAGE = "set luma.log.level=1 (or higher) to trace rendering";
+const ERROR_MESSAGE = "No matching device found. Ensure `@luma.gl/webgl` and/or `@luma.gl/webgpu` modules are imported.";
+const _Luma = class _Luma {
+  constructor() {
+    /** Global stats for all devices */
+    __publicField(this, "stats", lumaStats);
+    /**
+     * Global log
+     *
+     * Assign luma.log.level in console to control logging: \
+     * 0: none, 1: minimal, 2: verbose, 3: attribute/uniforms, 4: gl logs
+     * luma.log.break[], set to gl funcs, luma.log.profile[] set to model names`;
+     */
+    __publicField(this, "log", log);
+    /** Version of luma.gl */
+    __publicField(
+      this,
+      "VERSION",
+      // Version detection using build plugin
+      // @ts-expect-error no-undef
+      "9.2.6"
+    );
+    __publicField(this, "spector");
+    __publicField(this, "preregisteredAdapters", /* @__PURE__ */ new Map());
+    if (globalThis.luma) {
+      if (globalThis.luma.VERSION !== this.VERSION) {
+        log.error(`Found luma.gl ${globalThis.luma.VERSION} while initialzing ${this.VERSION}`)();
+        log.error(`'yarn why @luma.gl/core' can help identify the source of the conflict`)();
+        throw new Error(`luma.gl - multiple versions detected: see console log`);
+      }
+      log.error("This version of luma.gl has already been initialized")();
+    }
+    log.log(1, `${this.VERSION} - ${STARTUP_MESSAGE}`)();
+    globalThis.luma = this;
+  }
+  /** Creates a device. Asynchronously. */
+  async createDevice(props_ = {}) {
+    const props = { ..._Luma.defaultProps, ...props_ };
+    const adapter = this.selectAdapter(props.type, props.adapters);
+    if (!adapter) {
+      throw new Error(ERROR_MESSAGE);
+    }
+    if (props.waitForPageLoad) {
+      await adapter.pageLoaded;
+    }
+    return await adapter.create(props);
+  }
+  /**
+   * Attach to an existing GPU API handle (WebGL2RenderingContext or GPUDevice).
+   * @param handle Externally created WebGL context or WebGPU device
+   */
+  async attachDevice(handle, props) {
+    var _a3;
+    const type = this._getTypeFromHandle(handle, props.adapters);
+    const adapter = type && this.selectAdapter(type, props.adapters);
+    if (!adapter) {
+      throw new Error(ERROR_MESSAGE);
+    }
+    return await ((_a3 = adapter == null ? void 0 : adapter.attach) == null ? void 0 : _a3.call(adapter, handle, props));
+  }
+  /**
+   * Global adapter registration.
+   * @deprecated Use props.adapters instead
+   */
+  registerAdapters(adapters) {
+    for (const deviceClass of adapters) {
+      this.preregisteredAdapters.set(deviceClass.type, deviceClass);
+    }
+  }
+  /** Get type strings for supported Devices */
+  getSupportedAdapters(adapters = []) {
+    const adapterMap = this._getAdapterMap(adapters);
+    return Array.from(adapterMap).map(([, adapter]) => adapter).filter((adapter) => {
+      var _a3;
+      return (_a3 = adapter.isSupported) == null ? void 0 : _a3.call(adapter);
+    }).map((adapter) => adapter.type);
+  }
+  /** Get type strings for best available Device */
+  getBestAvailableAdapterType(adapters = []) {
+    var _a3, _b3;
+    const KNOWN_ADAPTERS = ["webgpu", "webgl", "null"];
+    const adapterMap = this._getAdapterMap(adapters);
+    for (const type of KNOWN_ADAPTERS) {
+      if ((_b3 = (_a3 = adapterMap.get(type)) == null ? void 0 : _a3.isSupported) == null ? void 0 : _b3.call(_a3)) {
+        return type;
+      }
+    }
+    return null;
+  }
+  /** Select adapter of type from registered adapters */
+  selectAdapter(type, adapters = []) {
+    let selectedType = type;
+    if (type === "best-available") {
+      selectedType = this.getBestAvailableAdapterType(adapters);
+    }
+    const adapterMap = this._getAdapterMap(adapters);
+    return selectedType && adapterMap.get(selectedType) || null;
+  }
+  /**
+   * Override `HTMLCanvasContext.getCanvas()` to always create WebGL2 contexts with additional WebGL1 compatibility.
+   * Useful when attaching luma to a context from an external library does not support creating WebGL2 contexts.
+   */
+  enforceWebGL2(enforce = true, adapters = []) {
+    var _a3;
+    const adapterMap = this._getAdapterMap(adapters);
+    const webgl2Adapter2 = adapterMap.get("webgl");
+    if (!webgl2Adapter2) {
+      log.warn("enforceWebGL2: webgl adapter not found")();
+    }
+    (_a3 = webgl2Adapter2 == null ? void 0 : webgl2Adapter2.enforceWebGL2) == null ? void 0 : _a3.call(webgl2Adapter2, enforce);
+  }
+  // DEPRECATED
+  /** @deprecated */
+  setDefaultDeviceProps(props) {
+    Object.assign(_Luma.defaultProps, props);
+  }
+  // HELPERS
+  /** Convert a list of adapters to a map */
+  _getAdapterMap(adapters = []) {
+    const map2 = new Map(this.preregisteredAdapters);
+    for (const adapter of adapters) {
+      map2.set(adapter.type, adapter);
+    }
+    return map2;
+  }
+  /** Get type of a handle (for attachDevice) */
+  _getTypeFromHandle(handle, adapters = []) {
+    if (handle instanceof WebGL2RenderingContext) {
+      return "webgl";
+    }
+    if (typeof GPUDevice !== "undefined" && handle instanceof GPUDevice) {
+      return "webgpu";
+    }
+    if (handle == null ? void 0 : handle.queue) {
+      return "webgpu";
+    }
+    if (handle === null) {
+      return "null";
+    }
+    if (handle instanceof WebGLRenderingContext) {
+      log.warn("WebGL1 is not supported", handle)();
+    } else {
+      log.warn("Unknown handle type", handle)();
+    }
+    return null;
+  }
+};
+__publicField(_Luma, "defaultProps", {
+  ...Device.defaultProps,
+  type: "best-available",
+  adapters: void 0,
+  waitForPageLoad: true
+});
+let Luma = _Luma;
+const luma = new Luma();
+class Adapter {
+  /**
+   * Page load promise
+   * Resolves when the DOM is loaded.
+   * @note Since are be limitations on number of `load` event listeners,
+   * it is recommended avoid calling this accessor until actually needed.
+   * I.e. we don't call it unless you know that you will be looking up a string in the DOM.
+   */
+  get pageLoaded() {
+    return getPageLoadPromise();
+  }
+}
+const isPage = isBrowser$1() && typeof document !== "undefined";
+const isPageLoaded = () => isPage && document.readyState === "complete";
+let pageLoadPromise = null;
+function getPageLoadPromise() {
+  if (!pageLoadPromise) {
+    if (isPageLoaded() || typeof window === "undefined") {
+      pageLoadPromise = Promise.resolve();
+    } else {
+      pageLoadPromise = new Promise((resolve) => window.addEventListener("load", () => resolve()));
+    }
+  }
+  return pageLoadPromise;
+}
+function withResolvers() {
+  let resolve;
+  let reject;
+  const promise = new Promise((_resolve, _reject) => {
+    resolve = _resolve;
+    reject = _reject;
+  });
+  return { promise, resolve, reject };
+}
+const _CanvasContext = class _CanvasContext {
+  constructor(props) {
+    __publicField(this, "id");
+    __publicField(this, "props");
+    __publicField(this, "canvas");
+    /** Handle to HTML canvas */
+    __publicField(this, "htmlCanvas");
+    /** Handle to wrapped OffScreenCanvas */
+    __publicField(this, "offscreenCanvas");
+    __publicField(this, "type");
+    /** Promise that resolved once the resize observer has updated the pixel size */
+    __publicField(this, "initialized");
+    __publicField(this, "isInitialized", false);
+    /** Visibility is automatically updated (via an IntersectionObserver) */
+    __publicField(this, "isVisible", true);
+    /** Width of canvas in CSS units (tracked by a ResizeObserver) */
+    __publicField(this, "cssWidth");
+    /** Height of canvas in CSS units (tracked by a ResizeObserver) */
+    __publicField(this, "cssHeight");
+    /** Device pixel ratio. Automatically updated via media queries */
+    __publicField(this, "devicePixelRatio");
+    /** Exact width of canvas in physical pixels (tracked by a ResizeObserver) */
+    __publicField(this, "devicePixelWidth");
+    /** Exact height of canvas in physical pixels (tracked by a ResizeObserver) */
+    __publicField(this, "devicePixelHeight");
+    /** Width of drawing buffer: automatically tracks this.pixelWidth if props.autoResize is true */
+    __publicField(this, "drawingBufferWidth");
+    /** Height of drawing buffer: automatically tracks this.pixelHeight if props.autoResize is true */
+    __publicField(this, "drawingBufferHeight");
+    __publicField(this, "_initializedResolvers", withResolvers());
+    __publicField(this, "_resizeObserver");
+    __publicField(this, "_intersectionObserver");
+    __publicField(this, "_position");
+    __publicField(this, "destroyed", false);
+    var _a3, _b3;
+    this.props = { ..._CanvasContext.defaultProps, ...props };
+    props = this.props;
+    this.initialized = this._initializedResolvers.promise;
+    if (!isBrowser$1()) {
+      this.canvas = { width: props.width || 1, height: props.height || 1 };
+    } else if (!props.canvas) {
+      this.canvas = createCanvasElement(props);
+    } else if (typeof props.canvas === "string") {
+      this.canvas = getCanvasFromDOM(props.canvas);
+    } else {
+      this.canvas = props.canvas;
+    }
+    if (_CanvasContext.isHTMLCanvas(this.canvas)) {
+      this.id = props.id || this.canvas.id;
+      this.type = "html-canvas";
+      this.htmlCanvas = this.canvas;
+    } else if (_CanvasContext.isOffscreenCanvas(this.canvas)) {
+      this.id = props.id || "offscreen-canvas";
+      this.type = "offscreen-canvas";
+      this.offscreenCanvas = this.canvas;
+    } else {
+      this.id = props.id || "node-canvas-context";
+      this.type = "node";
+    }
+    this.cssWidth = ((_a3 = this.htmlCanvas) == null ? void 0 : _a3.clientWidth) || this.canvas.width;
+    this.cssHeight = ((_b3 = this.htmlCanvas) == null ? void 0 : _b3.clientHeight) || this.canvas.height;
+    this.devicePixelWidth = this.canvas.width;
+    this.devicePixelHeight = this.canvas.height;
+    this.drawingBufferWidth = this.canvas.width;
+    this.drawingBufferHeight = this.canvas.height;
+    this.devicePixelRatio = globalThis.devicePixelRatio || 1;
+    this._position = [0, 0];
+    if (_CanvasContext.isHTMLCanvas(this.canvas)) {
+      this._intersectionObserver = new IntersectionObserver((entries) => this._handleIntersection(entries));
+      this._intersectionObserver.observe(this.canvas);
+      this._resizeObserver = new ResizeObserver((entries) => this._handleResize(entries));
+      try {
+        this._resizeObserver.observe(this.canvas, { box: "device-pixel-content-box" });
+      } catch {
+        this._resizeObserver.observe(this.canvas, { box: "content-box" });
+      }
+      setTimeout(() => this._observeDevicePixelRatio(), 0);
+      if (this.props.trackPosition) {
+        this._trackPosition();
+      }
+    }
+  }
+  static isHTMLCanvas(canvas2) {
+    return typeof HTMLCanvasElement !== "undefined" && canvas2 instanceof HTMLCanvasElement;
+  }
+  static isOffscreenCanvas(canvas2) {
+    return typeof OffscreenCanvas !== "undefined" && canvas2 instanceof OffscreenCanvas;
+  }
+  toString() {
+    return `${this[Symbol.toStringTag]}(${this.id})`;
+  }
+  destroy() {
+    this.destroyed = true;
+  }
+  setProps(props) {
+    if ("useDevicePixels" in props) {
+      this.props.useDevicePixels = props.useDevicePixels || false;
+      this._updateDrawingBufferSize();
+    }
+    return this;
+  }
+  // SIZE METHODS
+  /**
+   * Returns the size covered by the canvas in CSS pixels
+   * @note This can be different from the actual device pixel size of a canvas due to DPR scaling, and rounding to integer pixels
+   * @note This is independent of the canvas' internal drawing buffer size (.width, .height).
+   */
+  getCSSSize() {
+    return [this.cssWidth, this.cssHeight];
+  }
+  getPosition() {
+    return this._position;
+  }
+  /**
+   * Returns the size covered by the canvas in actual device pixels.
+   * @note This can be different from the 'CSS' size of a canvas due to DPR scaling, and rounding to integer pixels
+   * @note This is independent of the canvas' internal drawing buffer size (.width, .height).
+   */
+  getDevicePixelSize() {
+    return [this.devicePixelWidth, this.devicePixelHeight];
+  }
+  /** Get the drawing buffer size (number of pixels GPU is rendering into, can be different from CSS size) */
+  getDrawingBufferSize() {
+    return [this.drawingBufferWidth, this.drawingBufferHeight];
+  }
+  /** Returns the biggest allowed framebuffer size. @todo Allow the application to limit this? */
+  getMaxDrawingBufferSize() {
+    const maxTextureDimension = this.device.limits.maxTextureDimension2D;
+    return [maxTextureDimension, maxTextureDimension];
+  }
+  /** Update the canvas drawing buffer size. Called automatically if props.autoResize is true. */
+  setDrawingBufferSize(width, height) {
+    this.canvas.width = width;
+    this.canvas.height = height;
+    this.drawingBufferWidth = width;
+    this.drawingBufferHeight = height;
+  }
+  /**
+   * Returns the current DPR (number of physical pixels per CSS pixel), if props.useDevicePixels is true
+   * @note This can be a fractional (non-integer) number, e.g. when the user zooms in the browser.
+   * @note This function handles the non-HTML canvas cases
+   */
+  getDevicePixelRatio() {
+    const dpr = typeof window !== "undefined" && window.devicePixelRatio;
+    return dpr || 1;
+  }
+  // DEPRECATED METHODS
+  /**
+   * Maps CSS pixel position to device pixel position
+   */
+  cssToDevicePixels(cssPixel, yInvert = true) {
+    const ratio = this.cssToDeviceRatio();
+    const [width, height] = this.getDrawingBufferSize();
+    return scalePixels(cssPixel, ratio, width, height, yInvert);
+  }
+  /** @deprecated - use .getDevicePixelSize() */
+  getPixelSize() {
+    return this.getDevicePixelSize();
+  }
+  /** @deprecated - TODO which values should we use for aspect */
+  getAspect() {
+    const [width, height] = this.getDevicePixelSize();
+    return width / height;
+  }
+  /** @deprecated Returns multiplier need to convert CSS size to Device size */
+  cssToDeviceRatio() {
+    try {
+      const [drawingBufferWidth] = this.getDrawingBufferSize();
+      const [cssWidth] = this.getCSSSize();
+      return cssWidth ? drawingBufferWidth / cssWidth : 1;
+    } catch {
+      return 1;
+    }
+  }
+  /** @deprecated Use canvasContext.setDrawingBufferSize() */
+  resize(size) {
+    this.setDrawingBufferSize(size.width, size.height);
+  }
+  // IMPLEMENTATION
+  /**
+   * Allows subclass constructor to override the canvas id for auto created canvases.
+   * This can really help when debugging DOM in apps that create multiple devices
+   */
+  _setAutoCreatedCanvasId(id2) {
+    var _a3;
+    if (((_a3 = this.htmlCanvas) == null ? void 0 : _a3.id) === "lumagl-auto-created-canvas") {
+      this.htmlCanvas.id = id2;
+    }
+  }
+  /** reacts to an observed intersection */
+  _handleIntersection(entries) {
+    const entry = entries.find((entry_) => entry_.target === this.canvas);
+    if (!entry) {
+      return;
+    }
+    const isVisible = entry.isIntersecting;
+    if (this.isVisible !== isVisible) {
+      this.isVisible = isVisible;
+      this.device.props.onVisibilityChange(this);
+    }
+  }
+  /**
+   * Reacts to an observed resize by using the most accurate pixel size information the browser can provide
+   * @see https://web.dev/articles/device-pixel-content-box
+   * @see https://webgpufundamentals.org/webgpu/lessons/webgpu-resizing-the-canvas.html
+   */
+  _handleResize(entries) {
+    var _a3, _b3;
+    const entry = entries.find((entry_) => entry_.target === this.canvas);
+    if (!entry) {
+      return;
+    }
+    this.cssWidth = entry.contentBoxSize[0].inlineSize;
+    this.cssHeight = entry.contentBoxSize[0].blockSize;
+    const oldPixelSize = this.getDevicePixelSize();
+    const devicePixelWidth = ((_a3 = entry.devicePixelContentBoxSize) == null ? void 0 : _a3[0].inlineSize) || entry.contentBoxSize[0].inlineSize * devicePixelRatio;
+    const devicePixelHeight = ((_b3 = entry.devicePixelContentBoxSize) == null ? void 0 : _b3[0].blockSize) || entry.contentBoxSize[0].blockSize * devicePixelRatio;
+    const [maxDevicePixelWidth, maxDevicePixelHeight] = this.getMaxDrawingBufferSize();
+    this.devicePixelWidth = Math.max(1, Math.min(devicePixelWidth, maxDevicePixelWidth));
+    this.devicePixelHeight = Math.max(1, Math.min(devicePixelHeight, maxDevicePixelHeight));
+    this._updateDrawingBufferSize();
+    this.device.props.onResize(this, { oldPixelSize });
+  }
+  _updateDrawingBufferSize() {
+    if (this.props.autoResize) {
+      if (typeof this.props.useDevicePixels === "number") {
+        const dpr = this.props.useDevicePixels;
+        this.setDrawingBufferSize(this.cssWidth * dpr, this.cssHeight * dpr);
+      } else if (this.props.useDevicePixels) {
+        this.setDrawingBufferSize(this.devicePixelWidth, this.devicePixelHeight);
+      } else {
+        this.setDrawingBufferSize(this.cssWidth, this.cssHeight);
+      }
+      this._updateDevice();
+    }
+    this._initializedResolvers.resolve();
+    this.isInitialized = true;
+    this.updatePosition();
+  }
+  /** Monitor DPR changes */
+  _observeDevicePixelRatio() {
+    const oldRatio = this.devicePixelRatio;
+    this.devicePixelRatio = window.devicePixelRatio;
+    this.updatePosition();
+    this.device.props.onDevicePixelRatioChange(this, { oldRatio });
+    matchMedia(`(resolution: ${this.devicePixelRatio}dppx)`).addEventListener("change", () => this._observeDevicePixelRatio(), { once: true });
+  }
+  /** Start tracking positions with a timer */
+  _trackPosition(intervalMs = 100) {
+    const intervalId = setInterval(() => {
+      if (this.destroyed) {
+        clearInterval(intervalId);
+      } else {
+        this.updatePosition();
+      }
+    }, intervalMs);
+  }
+  /**
+   * Calculated the absolute position of the canvas
+   * @note - getBoundingClientRect() is normally cheap but can be expensive
+   * if called before browser has finished a reflow. Should not be the case here.
+   */
+  updatePosition() {
+    var _a3, _b3, _c3;
+    const newRect = (_a3 = this.htmlCanvas) == null ? void 0 : _a3.getBoundingClientRect();
+    if (newRect) {
+      const position = [newRect.left, newRect.top];
+      this._position ?? (this._position = position);
+      const positionChanged = position[0] !== this._position[0] || position[1] !== this._position[1];
+      if (positionChanged) {
+        const oldPosition = this._position;
+        this._position = position;
+        (_c3 = (_b3 = this.device.props).onPositionChange) == null ? void 0 : _c3.call(_b3, this, { oldPosition });
+      }
+    }
+  }
+};
+__publicField(_CanvasContext, "defaultProps", {
+  id: void 0,
+  canvas: null,
+  width: 800,
+  height: 600,
+  useDevicePixels: true,
+  autoResize: true,
+  container: null,
+  visible: true,
+  alphaMode: "opaque",
+  colorSpace: "srgb",
+  trackPosition: false
+});
+let CanvasContext = _CanvasContext;
+function getContainer(container) {
+  if (typeof container === "string") {
+    const element = document.getElementById(container);
+    if (!element) {
+      throw new Error(`${container} is not an HTML element`);
+    }
+    return element;
+  }
+  if (container) {
+    return container;
+  }
+  return document.body;
+}
+function getCanvasFromDOM(canvasId) {
+  const canvas2 = document.getElementById(canvasId);
+  if (!CanvasContext.isHTMLCanvas(canvas2)) {
+    throw new Error("Object is not a canvas element");
+  }
+  return canvas2;
+}
+function createCanvasElement(props) {
+  const { width, height } = props;
+  const newCanvas = document.createElement("canvas");
+  newCanvas.id = uid$2("lumagl-auto-created-canvas");
+  newCanvas.width = width || 1;
+  newCanvas.height = height || 1;
+  newCanvas.style.width = Number.isFinite(width) ? `${width}px` : "100%";
+  newCanvas.style.height = Number.isFinite(height) ? `${height}px` : "100%";
+  if (!(props == null ? void 0 : props.visible)) {
+    newCanvas.style.visibility = "hidden";
+  }
+  const container = getContainer((props == null ? void 0 : props.container) || null);
+  container.insertBefore(newCanvas, container.firstChild);
+  return newCanvas;
+}
+function scalePixels(pixel, ratio, width, height, yInvert) {
+  const point = pixel;
+  const x2 = scaleX(point[0], ratio, width);
+  let y2 = scaleY(point[1], ratio, height, yInvert);
+  let t2 = scaleX(point[0] + 1, ratio, width);
+  const xHigh = t2 === width - 1 ? t2 : t2 - 1;
+  t2 = scaleY(point[1] + 1, ratio, height, yInvert);
+  let yHigh;
+  if (yInvert) {
+    t2 = t2 === 0 ? t2 : t2 + 1;
+    yHigh = y2;
+    y2 = t2;
+  } else {
+    yHigh = t2 === height - 1 ? t2 : t2 - 1;
+  }
+  return {
+    x: x2,
+    y: y2,
+    // when ratio < 1, current css pixel and next css pixel may point to same device pixel, set width/height to 1 in those cases.
+    width: Math.max(xHigh - x2 + 1, 1),
+    height: Math.max(yHigh - y2 + 1, 1)
+  };
+}
+function scaleX(x2, ratio, width) {
+  const r2 = Math.min(Math.round(x2 * ratio), width - 1);
+  return r2;
+}
+function scaleY(y2, ratio, height, yInvert) {
+  return yInvert ? Math.max(0, height - 1 - Math.round(y2 * ratio)) : Math.min(Math.round(y2 * ratio), height - 1);
+}
+const _Sampler = class _Sampler extends Resource$1 {
+  get [Symbol.toStringTag]() {
+    return "Sampler";
+  }
+  constructor(device, props) {
+    props = _Sampler.normalizeProps(device, props);
+    super(device, props, _Sampler.defaultProps);
+  }
+  static normalizeProps(device, props) {
+    return props;
+  }
+};
+__publicField(_Sampler, "defaultProps", {
+  ...Resource$1.defaultProps,
+  type: "color-sampler",
+  addressModeU: "clamp-to-edge",
+  addressModeV: "clamp-to-edge",
+  addressModeW: "clamp-to-edge",
+  magFilter: "nearest",
+  minFilter: "nearest",
+  mipmapFilter: "none",
+  lodMinClamp: 0,
+  lodMaxClamp: 32,
+  // Per WebGPU spec
+  compare: "less-equal",
+  maxAnisotropy: 1
+});
+let Sampler = _Sampler;
+const BASE_DIMENSIONS = {
+  "1d": "1d",
+  "2d": "2d",
+  "2d-array": "2d",
+  cube: "2d",
+  "cube-array": "2d",
+  "3d": "3d"
+};
+const _Texture = class _Texture extends Resource$1 {
+  /** Do not use directly. Create with device.createTexture() */
+  constructor(device, props) {
+    props = _Texture.normalizeProps(device, props);
+    super(device, props, _Texture.defaultProps);
+    /** dimension of this texture */
+    __publicField(this, "dimension");
+    /** base dimension of this texture */
+    __publicField(this, "baseDimension");
+    /** format of this texture */
+    __publicField(this, "format");
+    /** width in pixels of this texture */
+    __publicField(this, "width");
+    /** height in pixels of this texture */
+    __publicField(this, "height");
+    /** depth of this texture */
+    __publicField(this, "depth");
+    /** mip levels in this texture */
+    __publicField(this, "mipLevels");
+    /** "Time" of last update. Monotonically increasing timestamp. TODO move to AsyncTexture? */
+    __publicField(this, "updateTimestamp");
+    this.dimension = this.props.dimension;
+    this.baseDimension = BASE_DIMENSIONS[this.dimension];
+    this.format = this.props.format;
+    this.width = this.props.width;
+    this.height = this.props.height;
+    this.depth = this.props.depth;
+    this.mipLevels = this.props.mipLevels;
+    if (this.props.width === void 0 || this.props.height === void 0) {
+      if (device.isExternalImage(props.data)) {
+        const size = device.getExternalImageSize(props.data);
+        this.width = (size == null ? void 0 : size.width) || 1;
+        this.height = (size == null ? void 0 : size.height) || 1;
+      } else {
+        this.width = 1;
+        this.height = 1;
+        if (this.props.width === void 0 || this.props.height === void 0) {
+          log.warn(`${this} created with undefined width or height. This is deprecated. Use AsyncTexture instead.`)();
+        }
+      }
+    }
+    this.updateTimestamp = device.incrementTimestamp();
+  }
+  get [Symbol.toStringTag]() {
+    return "Texture";
+  }
+  toString() {
+    return `Texture(${this.id},${this.format},${this.width}x${this.height})`;
+  }
+  /** Set sampler props associated with this texture */
+  setSampler(sampler) {
+    this.sampler = sampler instanceof Sampler ? sampler : this.device.createSampler(sampler);
+  }
+  /**
+   * Create a new texture with the same parameters and optionally a different size
+   * @note Textures are immutable and cannot be resized after creation, but we can create a similar texture with the same parameters but a new size.
+   * @note Does not copy contents of the texture
+   */
+  clone(size) {
+    return this.device.createTexture({ ...this.props, ...size });
+  }
+  /** Ensure we have integer coordinates */
+  static normalizeProps(device, props) {
+    const newProps = { ...props };
+    const { width, height } = newProps;
+    if (typeof width === "number") {
+      newProps.width = Math.max(1, Math.ceil(width));
+    }
+    if (typeof height === "number") {
+      newProps.height = Math.max(1, Math.ceil(height));
+    }
+    return newProps;
+  }
+  // HELPERS
+  /** Initialize texture with supplied props */
+  // eslint-disable-next-line max-statements
+  _initializeData(data) {
+    if (this.device.isExternalImage(data)) {
+      this.copyExternalImage({
+        image: data,
+        width: this.width,
+        height: this.height,
+        depth: this.depth,
+        mipLevel: 0,
+        x: 0,
+        y: 0,
+        z: 0,
+        aspect: "all",
+        colorSpace: "srgb",
+        premultipliedAlpha: false,
+        flipY: false
+      });
+    } else if (data) {
+      this.copyImageData({
+        data,
+        // width: this.width,
+        // height: this.height,
+        // depth: this.depth,
+        mipLevel: 0,
+        x: 0,
+        y: 0,
+        z: 0,
+        aspect: "all"
+      });
+    }
+  }
+  _normalizeCopyImageDataOptions(options_) {
+    const { width, height, depth } = this;
+    const options = { ..._Texture.defaultCopyDataOptions, width, height, depth, ...options_ };
+    const info = this.device.getTextureFormatInfo(this.format);
+    if (!options_.bytesPerRow && !info.bytesPerPixel) {
+      throw new Error(`bytesPerRow must be provided for texture format ${this.format}`);
+    }
+    options.bytesPerRow = options_.bytesPerRow || width * (info.bytesPerPixel || 4);
+    options.rowsPerImage = options_.rowsPerImage || height;
+    return options;
+  }
+  _normalizeCopyExternalImageOptions(options_) {
+    const size = this.device.getExternalImageSize(options_.image);
+    const options = { ..._Texture.defaultCopyExternalImageOptions, ...size, ...options_ };
+    options.width = Math.min(options.width, this.width - options.x);
+    options.height = Math.min(options.height, this.height - options.y);
+    return options;
+  }
+};
+/** The texture can be bound for use as a sampled texture in a shader */
+__publicField(_Texture, "SAMPLE", 4);
+/** The texture can be bound for use as a storage texture in a shader */
+__publicField(_Texture, "STORAGE", 8);
+/** The texture can be used as a color or depth/stencil attachment in a render pass */
+__publicField(_Texture, "RENDER", 16);
+/** The texture can be used as the source of a copy operation */
+__publicField(_Texture, "COPY_SRC", 1);
+/** he texture can be used as the destination of a copy or write operation */
+__publicField(_Texture, "COPY_DST", 2);
+/** @deprecated Use Texture.SAMPLE */
+__publicField(_Texture, "TEXTURE", 4);
+/** @deprecated Use Texture.RENDER */
+__publicField(_Texture, "RENDER_ATTACHMENT", 16);
+/** Default options */
+__publicField(_Texture, "defaultProps", {
+  ...Resource$1.defaultProps,
+  data: null,
+  dimension: "2d",
+  format: "rgba8unorm",
+  usage: _Texture.TEXTURE | _Texture.RENDER_ATTACHMENT | _Texture.COPY_DST,
+  width: void 0,
+  height: void 0,
+  depth: 1,
+  mipLevels: 1,
+  samples: void 0,
+  sampler: {},
+  view: void 0
+});
+__publicField(_Texture, "defaultCopyDataOptions", {
+  data: void 0,
+  byteOffset: 0,
+  bytesPerRow: void 0,
+  rowsPerImage: void 0,
+  mipLevel: 0,
+  x: 0,
+  y: 0,
+  z: 0,
+  aspect: "all"
+});
+/** Default options */
+__publicField(_Texture, "defaultCopyExternalImageOptions", {
+  image: void 0,
+  sourceX: 0,
+  sourceY: 0,
+  width: void 0,
+  height: void 0,
+  depth: 1,
+  mipLevel: 0,
+  x: 0,
+  y: 0,
+  z: 0,
+  aspect: "all",
+  colorSpace: "srgb",
+  premultipliedAlpha: false,
+  flipY: false
+});
+let Texture = _Texture;
+const _TextureView = class _TextureView extends Resource$1 {
+  get [Symbol.toStringTag]() {
+    return "TextureView";
+  }
+  /** Should not be constructed directly. Use `texture.createView(props)` */
+  constructor(device, props) {
+    super(device, props, _TextureView.defaultProps);
+  }
+};
+__publicField(_TextureView, "defaultProps", {
+  ...Resource$1.defaultProps,
+  format: void 0,
+  dimension: void 0,
+  aspect: "all",
+  baseMipLevel: 0,
+  mipLevelCount: void 0,
+  baseArrayLayer: 0,
+  arrayLayerCount: void 0
+});
+let TextureView = _TextureView;
+function formatCompilerLog(shaderLog, source2, options) {
+  let formattedLog = "";
+  const lines = source2.split(/\r?\n/);
+  const log3 = shaderLog.slice().sort((a2, b2) => a2.lineNum - b2.lineNum);
+  switch ((options == null ? void 0 : options.showSourceCode) || "no") {
+    case "all":
+      let currentMessage = 0;
+      for (let lineNum = 1; lineNum <= lines.length; lineNum++) {
+        formattedLog += getNumberedLine(lines[lineNum - 1], lineNum, options);
+        while (log3.length > currentMessage && log3[currentMessage].lineNum === lineNum) {
+          const message2 = log3[currentMessage++];
+          formattedLog += formatCompilerMessage(message2, lines, message2.lineNum, {
+            ...options,
+            inlineSource: false
+          });
+        }
+      }
+      while (log3.length > currentMessage) {
+        const message2 = log3[currentMessage++];
+        formattedLog += formatCompilerMessage(message2, [], 0, {
+          ...options,
+          inlineSource: false
+        });
+      }
+      return formattedLog;
+    case "issues":
+    case "no":
+      for (const message2 of shaderLog) {
+        formattedLog += formatCompilerMessage(message2, lines, message2.lineNum, {
+          inlineSource: (options == null ? void 0 : options.showSourceCode) !== "no"
+        });
+      }
+      return formattedLog;
+  }
+}
+function formatCompilerMessage(message2, lines, lineNum, options) {
+  if (options == null ? void 0 : options.inlineSource) {
+    const numberedLines = getNumberedLines(lines, lineNum);
+    const positionIndicator = message2.linePos > 0 ? `${" ".repeat(message2.linePos + 5)}^^^
+` : "";
+    return `
+${numberedLines}${positionIndicator}${message2.type.toUpperCase()}: ${message2.message}
+
+`;
+  }
+  const color2 = message2.type === "error" ? "red" : "#8B4000";
+  return (options == null ? void 0 : options.html) ? `<div class='luma-compiler-log-error' style="color:${color2};"><b> ${message2.type.toUpperCase()}: ${message2.message}</b></div>` : `${message2.type.toUpperCase()}: ${message2.message}`;
+}
+function getNumberedLines(lines, lineNum, options) {
+  let numberedLines = "";
+  for (let lineIndex = lineNum - 2; lineIndex <= lineNum; lineIndex++) {
+    const sourceLine = lines[lineIndex - 1];
+    if (sourceLine !== void 0) {
+      numberedLines += getNumberedLine(sourceLine, lineNum, options);
+    }
+  }
+  return numberedLines;
+}
+function getNumberedLine(line, lineNum, options) {
+  const escapedLine = (options == null ? void 0 : options.html) ? escapeHTML(line) : line;
+  return `${padLeft(String(lineNum), 4)}: ${escapedLine}${(options == null ? void 0 : options.html) ? "<br/>" : "\n"}`;
+}
+function padLeft(string, paddedLength) {
+  let result = "";
+  for (let i2 = string.length; i2 < paddedLength; ++i2) {
+    result += " ";
+  }
+  return result + string;
+}
+function escapeHTML(unsafe) {
+  return unsafe.replaceAll("&", "&amp;").replaceAll("<", "&lt;").replaceAll(">", "&gt;").replaceAll('"', "&quot;").replaceAll("'", "&#039;");
+}
+const _Shader = class _Shader extends Resource$1 {
+  /** Create a new Shader instance */
+  constructor(device, props) {
+    props = { ...props, debugShaders: props.debugShaders || device.props.debugShaders || "errors" };
+    super(device, { id: getShaderIdFromProps(props), ...props }, _Shader.defaultProps);
+    /** The stage of this shader */
+    __publicField(this, "stage");
+    /** The source code of this shader */
+    __publicField(this, "source");
+    /** The compilation status of the shader. 'pending' if compilation is asynchronous, and on production */
+    __publicField(this, "compilationStatus", "pending");
+    this.stage = this.props.stage;
+    this.source = this.props.source;
+  }
+  get [Symbol.toStringTag]() {
+    return "Shader";
+  }
+  /** Get compiler log synchronously (WebGL only) */
+  getCompilationInfoSync() {
+    return null;
+  }
+  /** Get translated shader source in host platform's native language (HLSL, GLSL, and even GLSL ES), if available */
+  getTranslatedSource() {
+    return null;
+  }
+  // PORTABLE HELPERS
+  /** In browser logging of errors */
+  async debugShader() {
+    const trigger = this.props.debugShaders;
+    switch (trigger) {
+      case "never":
+        return;
+      case "errors":
+        if (this.compilationStatus === "success") {
+          return;
+        }
+        break;
+    }
+    const messages = await this.getCompilationInfo();
+    if (trigger === "warnings" && (messages == null ? void 0 : messages.length) === 0) {
+      return;
+    }
+    this._displayShaderLog(messages, this.id);
+  }
+  // PRIVATE
+  /**
+   * In-browser UI logging of errors
+   * TODO - this HTML formatting code should not be in Device, should be pluggable
+   */
+  _displayShaderLog(messages, shaderId) {
+    var _a3;
+    if (typeof document === "undefined" || !(document == null ? void 0 : document.createElement)) {
+      return;
+    }
+    const shaderName = shaderId;
+    const shaderTitle = `${this.stage} shader "${shaderName}"`;
+    let htmlLog = formatCompilerLog(messages, this.source, { showSourceCode: "all", html: true });
+    const translatedSource = this.getTranslatedSource();
+    if (translatedSource) {
+      htmlLog += `<br /><br /><h1>Translated Source</h1><br /><br /><code style="user-select:text;"><pre>${translatedSource}</pre></code>`;
+    }
+    const button = document.createElement("Button");
+    button.innerHTML = `
+<h1>Compilation error in ${shaderTitle}</h1><br /><br />
+<code style="user-select:text;"><pre>
+${htmlLog}
+</pre></code>`;
+    button.style.top = "10px";
+    button.style.left = "10px";
+    button.style.position = "absolute";
+    button.style.zIndex = "9999";
+    button.style.width = "100%";
+    button.style.textAlign = "left";
+    document.body.appendChild(button);
+    const errors = document.getElementsByClassName("luma-compiler-log-error");
+    (_a3 = errors[0]) == null ? void 0 : _a3.scrollIntoView();
+    button.onclick = () => {
+      const dataURI = `data:text/plain,${encodeURIComponent(this.source)}`;
+      navigator.clipboard.writeText(dataURI);
+    };
+  }
+};
+__publicField(_Shader, "defaultProps", {
+  ...Resource$1.defaultProps,
+  language: "auto",
+  stage: void 0,
+  source: "",
+  sourceMap: null,
+  entryPoint: "main",
+  debugShaders: void 0
+});
+let Shader = _Shader;
+function getShaderIdFromProps(props) {
+  return getShaderName(props.source) || props.id || uid$2(`unnamed ${props.stage}-shader`);
+}
+function getShaderName(shader, defaultName = "unnamed") {
+  const SHADER_NAME_REGEXP = /#define[\s*]SHADER_NAME[\s*]([A-Za-z0-9_-]+)[\s*]/;
+  const match = SHADER_NAME_REGEXP.exec(shader);
+  return match ? match[1] : defaultName;
+}
+const _Framebuffer = class _Framebuffer extends Resource$1 {
+  constructor(device, props = {}) {
+    super(device, props, _Framebuffer.defaultProps);
+    /** Width of all attachments in this framebuffer */
+    __publicField(this, "width");
+    /** Height of all attachments in this framebuffer */
+    __publicField(this, "height");
+    this.width = this.props.width;
+    this.height = this.props.height;
+  }
+  get [Symbol.toStringTag]() {
+    return "Framebuffer";
+  }
+  /**
+   * Create a copy of this framebuffer with new attached textures, with same props but of the specified size.
+   * @note Does not copy contents of the attached textures.
+   */
+  clone(size) {
+    const colorAttachments = this.colorAttachments.map((colorAttachment) => colorAttachment.texture.clone(size));
+    const depthStencilAttachment = this.depthStencilAttachment && this.depthStencilAttachment.texture.clone(size);
+    return this.device.createFramebuffer({ ...this.props, colorAttachments, depthStencilAttachment });
+  }
+  resize(size) {
+    let updateSize = !size;
+    if (size) {
+      const [width, height] = Array.isArray(size) ? size : [size.width, size.height];
+      updateSize = updateSize || height !== this.height || width !== this.width;
+      this.width = width;
+      this.height = height;
+    }
+    if (updateSize) {
+      log.log(2, `Resizing framebuffer ${this.id} to ${this.width}x${this.height}`)();
+      this.resizeAttachments(this.width, this.height);
+    }
+  }
+  /** Auto creates any textures */
+  autoCreateAttachmentTextures() {
+    if (this.props.colorAttachments.length === 0 && !this.props.depthStencilAttachment) {
+      throw new Error("Framebuffer has noattachments");
+    }
+    this.colorAttachments = this.props.colorAttachments.map((attachment2, index) => {
+      if (typeof attachment2 === "string") {
+        const texture = this.createColorTexture(attachment2, index);
+        this.attachResource(texture);
+        return texture.view;
+      }
+      if (attachment2 instanceof Texture) {
+        return attachment2.view;
+      }
+      return attachment2;
+    });
+    const attachment = this.props.depthStencilAttachment;
+    if (attachment) {
+      if (typeof attachment === "string") {
+        const texture = this.createDepthStencilTexture(attachment);
+        this.attachResource(texture);
+        this.depthStencilAttachment = texture.view;
+      } else if (attachment instanceof Texture) {
+        this.depthStencilAttachment = attachment.view;
+      } else {
+        this.depthStencilAttachment = attachment;
+      }
+    }
+  }
+  /** Create a color texture */
+  createColorTexture(format, index) {
+    return this.device.createTexture({
+      id: `${this.id}-color-attachment-${index}`,
+      usage: Texture.RENDER_ATTACHMENT,
+      format,
+      width: this.width,
+      height: this.height,
+      // TODO deprecated? - luma.gl v8 compatibility
+      sampler: {
+        magFilter: "linear",
+        minFilter: "linear"
+      }
+    });
+  }
+  /** Create depth stencil texture */
+  createDepthStencilTexture(format) {
+    return this.device.createTexture({
+      id: `${this.id}-depth-stencil-attachment`,
+      usage: Texture.RENDER_ATTACHMENT,
+      format,
+      width: this.width,
+      height: this.height
+    });
+  }
+  /**
+   * Default implementation of resize
+   * Creates new textures with correct size for all attachments.
+   * and destroys existing textures if owned
+   */
+  resizeAttachments(width, height) {
+    for (let i2 = 0; i2 < this.colorAttachments.length; ++i2) {
+      if (this.colorAttachments[i2]) {
+        const resizedTexture = this.colorAttachments[i2].texture.clone({
+          width,
+          height
+        });
+        this.destroyAttachedResource(this.colorAttachments[i2]);
+        this.colorAttachments[i2] = resizedTexture.view;
+        this.attachResource(resizedTexture.view);
+      }
+    }
+    if (this.depthStencilAttachment) {
+      const resizedTexture = this.depthStencilAttachment.texture.clone({
+        width,
+        height
+      });
+      this.destroyAttachedResource(this.depthStencilAttachment);
+      this.depthStencilAttachment = resizedTexture.view;
+      this.attachResource(resizedTexture);
+    }
+    this.updateAttachments();
+  }
+};
+__publicField(_Framebuffer, "defaultProps", {
+  ...Resource$1.defaultProps,
+  width: 1,
+  height: 1,
+  colorAttachments: [],
+  // ['rgba8unorm'],
+  depthStencilAttachment: null
+  // 'depth24plus-stencil8'
+});
+let Framebuffer = _Framebuffer;
+const _RenderPipeline = class _RenderPipeline extends Resource$1 {
+  constructor(device, props) {
+    super(device, props, _RenderPipeline.defaultProps);
+    /** The merged layout */
+    __publicField(this, "shaderLayout");
+    /** Buffer map describing buffer interleaving etc */
+    __publicField(this, "bufferLayout");
+    /** The linking status of the pipeline. 'pending' if linking is asynchronous, and on production */
+    __publicField(this, "linkStatus", "pending");
+    /** The hash of the pipeline */
+    __publicField(this, "hash", "");
+    this.shaderLayout = this.props.shaderLayout;
+    this.bufferLayout = this.props.bufferLayout || [];
+  }
+  get [Symbol.toStringTag]() {
+    return "RenderPipeline";
+  }
+};
+__publicField(_RenderPipeline, "defaultProps", {
+  ...Resource$1.defaultProps,
+  vs: null,
+  vertexEntryPoint: "vertexMain",
+  vsConstants: {},
+  fs: null,
+  fragmentEntryPoint: "fragmentMain",
+  fsConstants: {},
+  shaderLayout: null,
+  bufferLayout: [],
+  topology: "triangle-list",
+  colorAttachmentFormats: void 0,
+  depthStencilAttachmentFormat: void 0,
+  parameters: {},
+  bindings: {},
+  uniforms: {}
+});
+let RenderPipeline = _RenderPipeline;
+const _RenderPass = class _RenderPass extends Resource$1 {
+  get [Symbol.toStringTag]() {
+    return "RenderPass";
+  }
+  constructor(device, props) {
+    props = _RenderPass.normalizeProps(device, props);
+    super(device, props, _RenderPass.defaultProps);
+  }
+  static normalizeProps(device, props) {
+    return props;
+  }
+};
+/** TODO - should be [0, 0, 0, 0], update once deck.gl tests run clean */
+__publicField(_RenderPass, "defaultClearColor", [0, 0, 0, 1]);
+/** Depth 1.0 represents the far plance */
+__publicField(_RenderPass, "defaultClearDepth", 1);
+/** Clears all stencil bits */
+__publicField(_RenderPass, "defaultClearStencil", 0);
+/** Default properties for RenderPass */
+__publicField(_RenderPass, "defaultProps", {
+  ...Resource$1.defaultProps,
+  framebuffer: null,
+  parameters: void 0,
+  clearColor: _RenderPass.defaultClearColor,
+  clearColors: void 0,
+  clearDepth: _RenderPass.defaultClearDepth,
+  clearStencil: _RenderPass.defaultClearStencil,
+  depthReadOnly: false,
+  stencilReadOnly: false,
+  discard: false,
+  occlusionQuerySet: void 0,
+  timestampQuerySet: void 0,
+  beginTimestampIndex: void 0,
+  endTimestampIndex: void 0
+});
+let RenderPass = _RenderPass;
+const _ComputePipeline = class _ComputePipeline extends Resource$1 {
+  constructor(device, props) {
+    super(device, props, _ComputePipeline.defaultProps);
+    __publicField(this, "hash", "");
+    /** The merged shader layout */
+    __publicField(this, "shaderLayout");
+    this.shaderLayout = props.shaderLayout;
+  }
+  get [Symbol.toStringTag]() {
+    return "ComputePipeline";
+  }
+};
+__publicField(_ComputePipeline, "defaultProps", {
+  ...Resource$1.defaultProps,
+  shader: void 0,
+  entryPoint: void 0,
+  constants: {},
+  shaderLayout: void 0
+});
+let ComputePipeline = _ComputePipeline;
+const _CommandEncoder = class _CommandEncoder extends Resource$1 {
+  get [Symbol.toStringTag]() {
+    return "CommandEncoder";
+  }
+  constructor(device, props) {
+    super(device, props, _CommandEncoder.defaultProps);
+  }
+};
+// TODO - luma.gl has these on the device, should we align with WebGPU API?
+// beginRenderPass(GPURenderPassDescriptor descriptor): GPURenderPassEncoder;
+// beginComputePass(optional GPUComputePassDescriptor descriptor = {}): GPUComputePassEncoder;
+__publicField(_CommandEncoder, "defaultProps", {
+  ...Resource$1.defaultProps,
+  measureExecutionTime: void 0
+});
+let CommandEncoder = _CommandEncoder;
+const _CommandBuffer = class _CommandBuffer extends Resource$1 {
+  get [Symbol.toStringTag]() {
+    return "CommandBuffer";
+  }
+  constructor(device, props) {
+    super(device, props, _CommandBuffer.defaultProps);
+  }
+};
+__publicField(_CommandBuffer, "defaultProps", {
+  ...Resource$1.defaultProps
+});
+let CommandBuffer = _CommandBuffer;
+function getVariableShaderTypeInfo(format) {
+  const decoded = UNIFORM_FORMATS[format];
+  return decoded;
+}
+function getAttributeShaderTypeInfo(attributeType) {
+  const [primitiveType, components] = TYPE_INFO[attributeType];
+  const integer = primitiveType === "i32" || primitiveType === "u32";
+  const signed = primitiveType !== "u32";
+  const byteLength = PRIMITIVE_TYPE_SIZES[primitiveType] * components;
+  return {
+    primitiveType,
+    components,
+    byteLength,
+    integer,
+    signed
+  };
+}
+const PRIMITIVE_TYPE_SIZES = {
+  f32: 4,
+  f16: 2,
+  i32: 4,
+  u32: 4
+  // 'bool-webgl': 4,
+};
+const TYPE_INFO = {
+  f32: ["f32", 1],
+  "vec2<f32>": ["f32", 2],
+  "vec3<f32>": ["f32", 3],
+  "vec4<f32>": ["f32", 4],
+  f16: ["f16", 1],
+  "vec2<f16>": ["f16", 2],
+  "vec3<f16>": ["f16", 3],
+  "vec4<f16>": ["f16", 4],
+  i32: ["i32", 1],
+  "vec2<i32>": ["i32", 2],
+  "vec3<i32>": ["i32", 3],
+  "vec4<i32>": ["i32", 4],
+  u32: ["u32", 1],
+  "vec2<u32>": ["u32", 2],
+  "vec3<u32>": ["u32", 3],
+  "vec4<u32>": ["u32", 4]
+};
+const UNIFORM_FORMATS = {
+  f32: { type: "f32", components: 1 },
+  f16: { type: "f16", components: 1 },
+  i32: { type: "i32", components: 1 },
+  u32: { type: "u32", components: 1 },
+  // 'bool-webgl': {type: 'bool-webgl', components: 1},
+  "vec2<f32>": { type: "f32", components: 2 },
+  "vec3<f32>": { type: "f32", components: 3 },
+  "vec4<f32>": { type: "f32", components: 4 },
+  "vec2<f16>": { type: "f16", components: 2 },
+  "vec3<f16>": { type: "f16", components: 3 },
+  "vec4<f16>": { type: "f16", components: 4 },
+  "vec2<i32>": { type: "i32", components: 2 },
+  "vec3<i32>": { type: "i32", components: 3 },
+  "vec4<i32>": { type: "i32", components: 4 },
+  "vec2<u32>": { type: "u32", components: 2 },
+  "vec3<u32>": { type: "u32", components: 3 },
+  "vec4<u32>": { type: "u32", components: 4 },
+  "mat2x2<f32>": { type: "f32", components: 4 },
+  "mat2x3<f32>": { type: "f32", components: 6 },
+  "mat2x4<f32>": { type: "f32", components: 8 },
+  "mat3x2<f32>": { type: "f32", components: 6 },
+  "mat3x3<f32>": { type: "f32", components: 9 },
+  "mat3x4<f32>": { type: "f32", components: 12 },
+  "mat4x2<f32>": { type: "f32", components: 8 },
+  "mat4x3<f32>": { type: "f32", components: 12 },
+  "mat4x4<f32>": { type: "f32", components: 16 },
+  "mat2x2<f16>": { type: "f16", components: 4 },
+  "mat2x3<f16>": { type: "f16", components: 6 },
+  "mat2x4<f16>": { type: "f16", components: 8 },
+  "mat3x2<f16>": { type: "f16", components: 6 },
+  "mat3x3<f16>": { type: "f16", components: 9 },
+  "mat3x4<f16>": { type: "f16", components: 12 },
+  "mat4x2<f16>": { type: "f16", components: 8 },
+  "mat4x3<f16>": { type: "f16", components: 12 },
+  "mat4x4<f16>": { type: "f16", components: 16 },
+  "mat2x2<i32>": { type: "i32", components: 4 },
+  "mat2x3<i32>": { type: "i32", components: 6 },
+  "mat2x4<i32>": { type: "i32", components: 8 },
+  "mat3x2<i32>": { type: "i32", components: 6 },
+  "mat3x3<i32>": { type: "i32", components: 9 },
+  "mat3x4<i32>": { type: "i32", components: 12 },
+  "mat4x2<i32>": { type: "i32", components: 8 },
+  "mat4x3<i32>": { type: "i32", components: 12 },
+  "mat4x4<i32>": { type: "i32", components: 16 },
+  "mat2x2<u32>": { type: "u32", components: 4 },
+  "mat2x3<u32>": { type: "u32", components: 6 },
+  "mat2x4<u32>": { type: "u32", components: 8 },
+  "mat3x2<u32>": { type: "u32", components: 6 },
+  "mat3x3<u32>": { type: "u32", components: 9 },
+  "mat3x4<u32>": { type: "u32", components: 12 },
+  "mat4x2<u32>": { type: "u32", components: 8 },
+  "mat4x3<u32>": { type: "u32", components: 12 },
+  "mat4x4<u32>": { type: "u32", components: 16 }
+};
+function getAttributeInfosFromLayouts(shaderLayout, bufferLayout) {
+  const attributeInfos = {};
+  for (const attribute of shaderLayout.attributes) {
+    const attributeInfo = getAttributeInfoFromLayouts(shaderLayout, bufferLayout, attribute.name);
+    if (attributeInfo) {
+      attributeInfos[attribute.name] = attributeInfo;
+    }
+  }
+  return attributeInfos;
+}
+function getAttributeInfosByLocation(shaderLayout, bufferLayout, maxVertexAttributes = 16) {
+  const attributeInfos = getAttributeInfosFromLayouts(shaderLayout, bufferLayout);
+  const locationInfos = new Array(maxVertexAttributes).fill(null);
+  for (const attributeInfo of Object.values(attributeInfos)) {
+    locationInfos[attributeInfo.location] = attributeInfo;
+  }
+  return locationInfos;
+}
+function getAttributeInfoFromLayouts(shaderLayout, bufferLayout, name2) {
+  const shaderDeclaration = getAttributeFromShaderLayout(shaderLayout, name2);
+  const bufferMapping = getAttributeFromBufferLayout(bufferLayout, name2);
+  if (!shaderDeclaration) {
+    return null;
+  }
+  const attributeTypeInfo = getAttributeShaderTypeInfo(shaderDeclaration.type);
+  const defaultVertexFormat = getCompatibleVertexFormat(attributeTypeInfo);
+  const vertexFormat = (bufferMapping == null ? void 0 : bufferMapping.vertexFormat) || defaultVertexFormat;
+  const vertexFormatInfo = getVertexFormatInfo(vertexFormat);
+  return {
+    attributeName: (bufferMapping == null ? void 0 : bufferMapping.attributeName) || shaderDeclaration.name,
+    bufferName: (bufferMapping == null ? void 0 : bufferMapping.bufferName) || shaderDeclaration.name,
+    location: shaderDeclaration.location,
+    shaderType: shaderDeclaration.type,
+    primitiveType: attributeTypeInfo.primitiveType,
+    shaderComponents: attributeTypeInfo.components,
+    vertexFormat,
+    bufferDataType: vertexFormatInfo.type,
+    bufferComponents: vertexFormatInfo.components,
+    // normalized is a property of the buffer's vertex format
+    normalized: vertexFormatInfo.normalized,
+    // integer is a property of the shader declaration
+    integer: attributeTypeInfo.integer,
+    stepMode: (bufferMapping == null ? void 0 : bufferMapping.stepMode) || shaderDeclaration.stepMode || "vertex",
+    byteOffset: (bufferMapping == null ? void 0 : bufferMapping.byteOffset) || 0,
+    byteStride: (bufferMapping == null ? void 0 : bufferMapping.byteStride) || 0
+  };
+}
+function getAttributeFromShaderLayout(shaderLayout, name2) {
+  const attribute = shaderLayout.attributes.find((attr) => attr.name === name2);
+  if (!attribute) {
+    log.warn(`shader layout attribute "${name2}" not present in shader`);
+  }
+  return attribute || null;
+}
+function getAttributeFromBufferLayout(bufferLayouts, name2) {
+  checkBufferLayouts(bufferLayouts);
+  let bufferLayoutInfo = getAttributeFromShortHand(bufferLayouts, name2);
+  if (bufferLayoutInfo) {
+    return bufferLayoutInfo;
+  }
+  bufferLayoutInfo = getAttributeFromAttributesList(bufferLayouts, name2);
+  if (bufferLayoutInfo) {
+    return bufferLayoutInfo;
+  }
+  log.warn(`layout for attribute "${name2}" not present in buffer layout`);
+  return null;
+}
+function checkBufferLayouts(bufferLayouts) {
+  for (const bufferLayout of bufferLayouts) {
+    if (bufferLayout.attributes && bufferLayout.format || !bufferLayout.attributes && !bufferLayout.format) {
+      log.warn(`BufferLayout ${name} must have either 'attributes' or 'format' field`);
+    }
+  }
+}
+function getAttributeFromShortHand(bufferLayouts, name2) {
+  for (const bufferLayout of bufferLayouts) {
+    if (bufferLayout.format && bufferLayout.name === name2) {
+      return {
+        attributeName: bufferLayout.name,
+        bufferName: name2,
+        stepMode: bufferLayout.stepMode,
+        vertexFormat: bufferLayout.format,
+        // If offset is needed, use `attributes` field.
+        byteOffset: 0,
+        byteStride: bufferLayout.byteStride || 0
+      };
+    }
+  }
+  return null;
+}
+function getAttributeFromAttributesList(bufferLayouts, name2) {
+  var _a3;
+  for (const bufferLayout of bufferLayouts) {
+    let byteStride = bufferLayout.byteStride;
+    if (typeof bufferLayout.byteStride !== "number") {
+      for (const attributeMapping2 of bufferLayout.attributes || []) {
+        const info = getVertexFormatInfo(attributeMapping2.format);
+        byteStride += info.byteLength;
+      }
+    }
+    const attributeMapping = (_a3 = bufferLayout.attributes) == null ? void 0 : _a3.find((mapping) => mapping.attribute === name2);
+    if (attributeMapping) {
+      return {
+        attributeName: attributeMapping.attribute,
+        bufferName: bufferLayout.name,
+        stepMode: bufferLayout.stepMode,
+        vertexFormat: attributeMapping.format,
+        byteOffset: attributeMapping.byteOffset,
+        // @ts-ignore
+        byteStride
+      };
+    }
+  }
+  return null;
+}
+const _VertexArray = class _VertexArray extends Resource$1 {
+  constructor(device, props) {
+    super(device, props, _VertexArray.defaultProps);
+    /** Max number of vertex attributes */
+    __publicField(this, "maxVertexAttributes");
+    /** Attribute infos indexed by location - TODO only needed by webgl module? */
+    __publicField(this, "attributeInfos");
+    /** Index buffer */
+    __publicField(this, "indexBuffer", null);
+    /** Attributes indexed by buffer slot */
+    __publicField(this, "attributes");
+    this.maxVertexAttributes = device.limits.maxVertexAttributes;
+    this.attributes = new Array(this.maxVertexAttributes).fill(null);
+    this.attributeInfos = getAttributeInfosByLocation(props.shaderLayout, props.bufferLayout, this.maxVertexAttributes);
+  }
+  get [Symbol.toStringTag]() {
+    return "VertexArray";
+  }
+  // DEPRECATED METHODS
+  /** @deprecated Set constant attributes (WebGL only) */
+  setConstantWebGL(location2, value) {
+    this.device.reportError(new Error("constant attributes not supported"), this)();
+  }
+};
+__publicField(_VertexArray, "defaultProps", {
+  ...Resource$1.defaultProps,
+  shaderLayout: void 0,
+  bufferLayout: []
+});
+let VertexArray = _VertexArray;
+const _TransformFeedback = class _TransformFeedback extends Resource$1 {
+  get [Symbol.toStringTag]() {
+    return "TransformFeedback";
+  }
+  constructor(device, props) {
+    super(device, props, _TransformFeedback.defaultProps);
+  }
+};
+__publicField(_TransformFeedback, "defaultProps", {
+  ...Resource$1.defaultProps,
+  layout: void 0,
+  buffers: {}
+});
+let TransformFeedback = _TransformFeedback;
+const _QuerySet = class _QuerySet extends Resource$1 {
+  get [Symbol.toStringTag]() {
+    return "QuerySet";
+  }
+  constructor(device, props) {
+    super(device, props, _QuerySet.defaultProps);
+  }
+};
+__publicField(_QuerySet, "defaultProps", {
+  ...Resource$1.defaultProps,
+  type: void 0,
+  count: void 0
+});
+let QuerySet = _QuerySet;
+let arrayBuffer;
+function getScratchArrayBuffer(byteLength) {
+  if (!arrayBuffer || arrayBuffer.byteLength < byteLength) {
+    arrayBuffer = new ArrayBuffer(byteLength);
+  }
+  return arrayBuffer;
+}
+function getScratchArray(Type2, length2) {
+  const scratchArrayBuffer = getScratchArrayBuffer(Type2.BYTES_PER_ELEMENT * length2);
+  return new Type2(scratchArrayBuffer, 0, length2);
+}
+function isTypedArray$1(value) {
+  return ArrayBuffer.isView(value) && !(value instanceof DataView);
+}
+function isNumberArray$1(value) {
+  if (Array.isArray(value)) {
+    return value.length === 0 || typeof value[0] === "number";
+  }
+  return isTypedArray$1(value);
+}
+const minBufferSize = 1024;
+class UniformBufferLayout {
+  /** Create a new UniformBufferLayout given a map of attributes. */
+  constructor(uniformTypes, uniformSizes = {}) {
+    __publicField(this, "layout", {});
+    /** number of bytes needed for buffer allocation */
+    __publicField(this, "byteLength");
+    let size = 0;
+    for (const [key, uniformType] of Object.entries(uniformTypes)) {
+      const typeAndComponents = getVariableShaderTypeInfo(uniformType);
+      const { type, components } = typeAndComponents;
+      const count2 = components * ((uniformSizes == null ? void 0 : uniformSizes[key]) ?? 1);
+      size = alignTo(size, count2);
+      const offset = size;
+      size += count2;
+      this.layout[key] = { type, size: count2, offset };
+    }
+    size += (4 - size % 4) % 4;
+    const actualByteLength = size * 4;
+    this.byteLength = Math.max(actualByteLength, minBufferSize);
+  }
+  /** Get the data for the complete buffer */
+  getData(uniformValues) {
+    const arrayBuffer2 = getScratchArrayBuffer(this.byteLength);
+    const typedArrays = {
+      i32: new Int32Array(arrayBuffer2),
+      u32: new Uint32Array(arrayBuffer2),
+      f32: new Float32Array(arrayBuffer2),
+      // TODO not implemented
+      f16: new Uint16Array(arrayBuffer2)
+    };
+    for (const [name2, value] of Object.entries(uniformValues)) {
+      const uniformLayout = this.layout[name2];
+      if (!uniformLayout) {
+        log.warn(`Supplied uniform value ${name2} not present in uniform block layout`)();
+        continue;
+      }
+      const { type, size, offset } = uniformLayout;
+      const typedArray = typedArrays[type];
+      if (size === 1) {
+        if (typeof value !== "number" && typeof value !== "boolean") {
+          log.warn(`Supplied value for single component uniform ${name2} is not a number: ${value}`)();
+          continue;
+        }
+        typedArray[offset] = Number(value);
+      } else {
+        if (!isNumberArray$1(value)) {
+          log.warn(`Supplied value for multi component / array uniform ${name2} is not a numeric array: ${value}`)();
+          continue;
+        }
+        typedArray.set(value, offset);
+      }
+    }
+    return new Uint8Array(arrayBuffer2, 0, this.byteLength);
+  }
+  /** Does this layout have a field with specified name */
+  has(name2) {
+    return Boolean(this.layout[name2]);
+  }
+  /** Get offset and size for a field with specified name */
+  get(name2) {
+    const layout = this.layout[name2];
+    return layout;
+  }
+}
+function arrayEqual(a2, b2, limit = 16) {
+  if (a2 !== b2) {
+    return false;
+  }
+  const arrayA = a2;
+  const arrayB = b2;
+  if (!isNumberArray$1(arrayA)) {
+    return false;
+  }
+  if (isNumberArray$1(arrayB) && arrayA.length === arrayB.length) {
+    for (let i2 = 0; i2 < arrayA.length; ++i2) {
+      if (arrayB[i2] !== arrayA[i2]) {
+        return false;
+      }
+    }
+  }
+  return true;
+}
+function arrayCopy(a2) {
+  if (isNumberArray$1(a2)) {
+    return a2.slice();
+  }
+  return a2;
+}
+class UniformBlock {
+  constructor(props) {
+    __publicField(this, "name");
+    __publicField(this, "uniforms", {});
+    __publicField(this, "modifiedUniforms", {});
+    __publicField(this, "modified", true);
+    __publicField(this, "bindingLayout", {});
+    __publicField(this, "needsRedraw", "initialized");
+    var _a3;
+    this.name = (props == null ? void 0 : props.name) || "unnamed";
+    if ((props == null ? void 0 : props.name) && (props == null ? void 0 : props.shaderLayout)) {
+      const binding = (_a3 = props == null ? void 0 : props.shaderLayout.bindings) == null ? void 0 : _a3.find((binding_) => binding_.type === "uniform" && binding_.name === (props == null ? void 0 : props.name));
+      if (!binding) {
+        throw new Error(props == null ? void 0 : props.name);
+      }
+      const uniformBlock2 = binding;
+      for (const uniform of uniformBlock2.uniforms || []) {
+        this.bindingLayout[uniform.name] = uniform;
+      }
+    }
+  }
+  /** Set a map of uniforms */
+  setUniforms(uniforms) {
+    for (const [key, value] of Object.entries(uniforms)) {
+      this._setUniform(key, value);
+      if (!this.needsRedraw) {
+        this.setNeedsRedraw(`${this.name}.${key}=${value}`);
+      }
+    }
+  }
+  setNeedsRedraw(reason) {
+    this.needsRedraw = this.needsRedraw || reason;
+  }
+  /** Returns all uniforms */
+  getAllUniforms() {
+    this.modifiedUniforms = {};
+    this.needsRedraw = false;
+    return this.uniforms || {};
+  }
+  /** Set a single uniform */
+  _setUniform(key, value) {
+    if (arrayEqual(this.uniforms[key], value)) {
+      return;
+    }
+    this.uniforms[key] = arrayCopy(value);
+    this.modifiedUniforms[key] = true;
+    this.modified = true;
+  }
+}
+class UniformStore {
+  /**
+   * Create a new UniformStore instance
+   * @param blocks
+   */
+  constructor(blocks) {
+    /** Stores the uniform values for each uniform block */
+    __publicField(this, "uniformBlocks", /* @__PURE__ */ new Map());
+    /** Can generate data for a uniform buffer for each block from data */
+    __publicField(this, "uniformBufferLayouts", /* @__PURE__ */ new Map());
+    /** Actual buffer for the blocks */
+    __publicField(this, "uniformBuffers", /* @__PURE__ */ new Map());
+    for (const [bufferName, block] of Object.entries(blocks)) {
+      const uniformBufferName = bufferName;
+      const uniformBufferLayout = new UniformBufferLayout(block.uniformTypes ?? {}, block.uniformSizes ?? {});
+      this.uniformBufferLayouts.set(uniformBufferName, uniformBufferLayout);
+      const uniformBlock2 = new UniformBlock({ name: bufferName });
+      uniformBlock2.setUniforms(block.defaultUniforms || {});
+      this.uniformBlocks.set(uniformBufferName, uniformBlock2);
+    }
+  }
+  /** Destroy any managed uniform buffers */
+  destroy() {
+    for (const uniformBuffer of this.uniformBuffers.values()) {
+      uniformBuffer.destroy();
+    }
+  }
+  /**
+   * Set uniforms
+   * Makes all properties partial
+   */
+  setUniforms(uniforms) {
+    var _a3;
+    for (const [blockName, uniformValues] of Object.entries(uniforms)) {
+      (_a3 = this.uniformBlocks.get(blockName)) == null ? void 0 : _a3.setUniforms(uniformValues);
+    }
+    this.updateUniformBuffers();
+  }
+  /** Get the required minimum length of the uniform buffer */
+  getUniformBufferByteLength(uniformBufferName) {
+    var _a3;
+    return ((_a3 = this.uniformBufferLayouts.get(uniformBufferName)) == null ? void 0 : _a3.byteLength) || 0;
+  }
+  /** Get formatted binary memory that can be uploaded to a buffer */
+  getUniformBufferData(uniformBufferName) {
+    var _a3, _b3;
+    const uniformValues = ((_a3 = this.uniformBlocks.get(uniformBufferName)) == null ? void 0 : _a3.getAllUniforms()) || {};
+    return (_b3 = this.uniformBufferLayouts.get(uniformBufferName)) == null ? void 0 : _b3.getData(uniformValues);
+  }
+  /**
+   * Creates an unmanaged uniform buffer (umnanaged means that application is responsible for destroying it)
+   * The new buffer is initialized with current / supplied values
+   */
+  createUniformBuffer(device, uniformBufferName, uniforms) {
+    if (uniforms) {
+      this.setUniforms(uniforms);
+    }
+    const byteLength = this.getUniformBufferByteLength(uniformBufferName);
+    const uniformBuffer = device.createBuffer({
+      usage: Buffer$1.UNIFORM | Buffer$1.COPY_DST,
+      byteLength
+    });
+    const uniformBufferData = this.getUniformBufferData(uniformBufferName);
+    uniformBuffer.write(uniformBufferData);
+    return uniformBuffer;
+  }
+  /** Get the managed uniform buffer. "managed" resources are destroyed when the uniformStore is destroyed. */
+  getManagedUniformBuffer(device, uniformBufferName) {
+    if (!this.uniformBuffers.get(uniformBufferName)) {
+      const byteLength = this.getUniformBufferByteLength(uniformBufferName);
+      const uniformBuffer = device.createBuffer({
+        usage: Buffer$1.UNIFORM | Buffer$1.COPY_DST,
+        byteLength
+      });
+      this.uniformBuffers.set(uniformBufferName, uniformBuffer);
+    }
+    return this.uniformBuffers.get(uniformBufferName);
+  }
+  /** Updates all uniform buffers where values have changed */
+  updateUniformBuffers() {
+    let reason = false;
+    for (const uniformBufferName of this.uniformBlocks.keys()) {
+      const bufferReason = this.updateUniformBuffer(uniformBufferName);
+      reason || (reason = bufferReason);
+    }
+    if (reason) {
+      log.log(3, `UniformStore.updateUniformBuffers(): ${reason}`)();
+    }
+    return reason;
+  }
+  /** Update one uniform buffer. Only updates if values have changed */
+  updateUniformBuffer(uniformBufferName) {
+    var _a3;
+    const uniformBlock2 = this.uniformBlocks.get(uniformBufferName);
+    let uniformBuffer = this.uniformBuffers.get(uniformBufferName);
+    let reason = false;
+    if (uniformBuffer && (uniformBlock2 == null ? void 0 : uniformBlock2.needsRedraw)) {
+      reason || (reason = uniformBlock2.needsRedraw);
+      const uniformBufferData = this.getUniformBufferData(uniformBufferName);
+      uniformBuffer = this.uniformBuffers.get(uniformBufferName);
+      uniformBuffer == null ? void 0 : uniformBuffer.write(uniformBufferData);
+      const uniformValues = (_a3 = this.uniformBlocks.get(uniformBufferName)) == null ? void 0 : _a3.getAllUniforms();
+      log.log(4, `Writing to uniform buffer ${String(uniformBufferName)}`, uniformBufferData, uniformValues)();
+    }
+    return reason;
+  }
+}
+class e {
+  constructor(e2, t2) {
+    this.name = e2, this.attributes = t2, this.size = 0;
+  }
+  get isArray() {
+    return false;
+  }
+  get isStruct() {
+    return false;
+  }
+  get isTemplate() {
+    return false;
+  }
+  get isPointer() {
+    return false;
+  }
+  getTypeName() {
+    return this.name;
+  }
+}
+class t {
+  constructor(e2, t2, n2) {
+    this.name = e2, this.type = t2, this.attributes = n2, this.offset = 0, this.size = 0;
+  }
+  get isArray() {
+    return this.type.isArray;
+  }
+  get isStruct() {
+    return this.type.isStruct;
+  }
+  get isTemplate() {
+    return this.type.isTemplate;
+  }
+  get align() {
+    return this.type.isStruct ? this.type.align : 0;
+  }
+  get members() {
+    return this.type.isStruct ? this.type.members : null;
+  }
+  get format() {
+    return this.type.isArray || this.type.isTemplate ? this.type.format : null;
+  }
+  get count() {
+    return this.type.isArray ? this.type.count : 0;
+  }
+  get stride() {
+    return this.type.isArray ? this.type.stride : this.size;
+  }
+}
+class n extends e {
+  constructor(e2, t2) {
+    super(e2, t2), this.members = [], this.align = 0, this.startLine = -1, this.endLine = -1, this.inUse = false;
+  }
+  get isStruct() {
+    return true;
+  }
+}
+class s extends e {
+  constructor(e2, t2) {
+    super(e2, t2), this.count = 0, this.stride = 0;
+  }
+  get isArray() {
+    return true;
+  }
+  getTypeName() {
+    return `array<${this.format.getTypeName()}, ${this.count}>`;
+  }
+}
+class r extends e {
+  constructor(e2, t2, n2) {
+    super(e2, n2), this.format = t2;
+  }
+  get isPointer() {
+    return true;
+  }
+  getTypeName() {
+    return `&${this.format.getTypeName()}`;
+  }
+}
+class a extends e {
+  constructor(e2, t2, n2, s2) {
+    super(e2, n2), this.format = t2, this.access = s2;
+  }
+  get isTemplate() {
+    return true;
+  }
+  getTypeName() {
+    let e2 = this.name;
+    if (null !== this.format) {
+      if ("vec2" === e2 || "vec3" === e2 || "vec4" === e2 || "mat2x2" === e2 || "mat2x3" === e2 || "mat2x4" === e2 || "mat3x2" === e2 || "mat3x3" === e2 || "mat3x4" === e2 || "mat4x2" === e2 || "mat4x3" === e2 || "mat4x4" === e2) {
+        if ("f32" === this.format.name) return e2 += "f", e2;
+        if ("i32" === this.format.name) return e2 += "i", e2;
+        if ("u32" === this.format.name) return e2 += "u", e2;
+        if ("bool" === this.format.name) return e2 += "b", e2;
+        if ("f16" === this.format.name) return e2 += "h", e2;
+      }
+      e2 += `<${this.format.name}>`;
+    } else if ("vec2" === e2 || "vec3" === e2 || "vec4" === e2) return e2;
+    return e2;
+  }
+}
+var i;
+((e2) => {
+  e2[e2.Uniform = 0] = "Uniform", e2[e2.Storage = 1] = "Storage", e2[e2.Texture = 2] = "Texture", e2[e2.Sampler = 3] = "Sampler", e2[e2.StorageTexture = 4] = "StorageTexture";
+})(i || (i = {}));
+class o {
+  constructor(e2, t2, n2, s2, r2, a2, i2) {
+    this.name = e2, this.type = t2, this.group = n2, this.binding = s2, this.attributes = r2, this.resourceType = a2, this.access = i2;
+  }
+  get isArray() {
+    return this.type.isArray;
+  }
+  get isStruct() {
+    return this.type.isStruct;
+  }
+  get isTemplate() {
+    return this.type.isTemplate;
+  }
+  get size() {
+    return this.type.size;
+  }
+  get align() {
+    return this.type.isStruct ? this.type.align : 0;
+  }
+  get members() {
+    return this.type.isStruct ? this.type.members : null;
+  }
+  get format() {
+    return this.type.isArray || this.type.isTemplate ? this.type.format : null;
+  }
+  get count() {
+    return this.type.isArray ? this.type.count : 0;
+  }
+  get stride() {
+    return this.type.isArray ? this.type.stride : this.size;
+  }
+}
+class c {
+  constructor(e2, t2) {
+    this.name = e2, this.type = t2;
+  }
+}
+class l {
+  constructor(e2, t2, n2, s2) {
+    this.name = e2, this.type = t2, this.locationType = n2, this.location = s2, this.interpolation = null;
+  }
+}
+class u {
+  constructor(e2, t2, n2, s2) {
+    this.name = e2, this.type = t2, this.locationType = n2, this.location = s2;
+  }
+}
+class h {
+  constructor(e2, t2, n2, s2) {
+    this.name = e2, this.type = t2, this.attributes = n2, this.id = s2;
+  }
+}
+class f {
+  constructor(e2, t2, n2) {
+    this.name = e2, this.type = t2, this.attributes = n2;
+  }
+}
+class p {
+  constructor(e2, t2 = null, n2) {
+    this.stage = null, this.inputs = [], this.outputs = [], this.arguments = [], this.returnType = null, this.resources = [], this.overrides = [], this.startLine = -1, this.endLine = -1, this.inUse = false, this.calls = /* @__PURE__ */ new Set(), this.name = e2, this.stage = t2, this.attributes = n2;
+  }
+}
+class d {
+  constructor() {
+    this.vertex = [], this.fragment = [], this.compute = [];
+  }
+}
+function m(e2) {
+  var t2 = (32768 & e2) >> 15, n2 = (31744 & e2) >> 10, s2 = 1023 & e2;
+  return 0 == n2 ? (t2 ? -1 : 1) * Math.pow(2, -14) * (s2 / Math.pow(2, 10)) : 31 == n2 ? s2 ? NaN : 1 / 0 * (t2 ? -1 : 1) : (t2 ? -1 : 1) * Math.pow(2, n2 - 15) * (1 + s2 / Math.pow(2, 10));
+}
+const g = new Float32Array(1), _ = new Int32Array(g.buffer), x = new Uint16Array(1);
+function y(e2) {
+  g[0] = e2;
+  const t2 = _[0], n2 = t2 >> 31 & 1;
+  let s2 = t2 >> 23 & 255, r2 = 8388607 & t2;
+  if (255 === s2) return x[0] = n2 << 15 | 31744 | (0 !== r2 ? 512 : 0), x[0];
+  if (0 === s2) {
+    if (0 === r2) return x[0] = n2 << 15, x[0];
+    r2 |= 8388608;
+    let e3 = 113;
+    for (; !(8388608 & r2); ) r2 <<= 1, e3--;
+    return s2 = 127 - e3, r2 &= 8388607, s2 > 0 ? (r2 = (r2 >> 126 - s2) + (r2 >> 127 - s2 & 1), x[0] = n2 << 15 | s2 << 10 | r2 >> 13, x[0]) : (x[0] = n2 << 15, x[0]);
+  }
+  return s2 = s2 - 127 + 15, s2 >= 31 ? (x[0] = n2 << 15 | 31744, x[0]) : s2 <= 0 ? s2 < -10 ? (x[0] = n2 << 15, x[0]) : (r2 = (8388608 | r2) >> 1 - s2, x[0] = n2 << 15 | r2 >> 13, x[0]) : (r2 >>= 13, x[0] = n2 << 15 | s2 << 10 | r2, x[0]);
+}
+const b = new Uint32Array(1), v = new Float32Array(b.buffer, 0, 1);
+function w(e2) {
+  const t2 = 112 + (e2 >> 6 & 31) << 23 | (63 & e2) << 17;
+  return b[0] = t2, v[0];
+}
+function k(e2, t2, n2, s2, r2, a2, i2, o2, c2) {
+  const l2 = s2 * (i2 >>= r2) * (a2 >>= r2) + n2 * i2 + t2 * o2;
+  switch (c2) {
+    case "r8unorm":
+      return [I(e2, l2, "8unorm", 1)[0]];
+    case "r8snorm":
+      return [I(e2, l2, "8snorm", 1)[0]];
+    case "r8uint":
+      return [I(e2, l2, "8uint", 1)[0]];
+    case "r8sint":
+      return [I(e2, l2, "8sint", 1)[0]];
+    case "rg8unorm": {
+      const t3 = I(e2, l2, "8unorm", 2);
+      return [t3[0], t3[1]];
+    }
+    case "rg8snorm": {
+      const t3 = I(e2, l2, "8snorm", 2);
+      return [t3[0], t3[1]];
+    }
+    case "rg8uint": {
+      const t3 = I(e2, l2, "8uint", 2);
+      return [t3[0], t3[1]];
+    }
+    case "rg8sint": {
+      const t3 = I(e2, l2, "8sint", 2);
+      return [t3[0], t3[1]];
+    }
+    case "rgba8unorm-srgb":
+    case "rgba8unorm": {
+      const t3 = I(e2, l2, "8unorm", 4);
+      return [t3[0], t3[1], t3[2], t3[3]];
+    }
+    case "rgba8snorm": {
+      const t3 = I(e2, l2, "8snorm", 4);
+      return [t3[0], t3[1], t3[2], t3[3]];
+    }
+    case "rgba8uint": {
+      const t3 = I(e2, l2, "8uint", 4);
+      return [t3[0], t3[1], t3[2], t3[3]];
+    }
+    case "rgba8sint": {
+      const t3 = I(e2, l2, "8sint", 4);
+      return [t3[0], t3[1], t3[2], t3[3]];
+    }
+    case "bgra8unorm-srgb":
+    case "bgra8unorm": {
+      const t3 = I(e2, l2, "8unorm", 4);
+      return [t3[2], t3[1], t3[0], t3[3]];
+    }
+    case "r16uint":
+      return [I(e2, l2, "16uint", 1)[0]];
+    case "r16sint":
+      return [I(e2, l2, "16sint", 1)[0]];
+    case "r16float":
+      return [I(e2, l2, "16float", 1)[0]];
+    case "rg16uint": {
+      const t3 = I(e2, l2, "16uint", 2);
+      return [t3[0], t3[1]];
+    }
+    case "rg16sint": {
+      const t3 = I(e2, l2, "16sint", 2);
+      return [t3[0], t3[1]];
+    }
+    case "rg16float": {
+      const t3 = I(e2, l2, "16float", 2);
+      return [t3[0], t3[1]];
+    }
+    case "rgba16uint": {
+      const t3 = I(e2, l2, "16uint", 4);
+      return [t3[0], t3[1], t3[2], t3[3]];
+    }
+    case "rgba16sint": {
+      const t3 = I(e2, l2, "16sint", 4);
+      return [t3[0], t3[1], t3[2], t3[3]];
+    }
+    case "rgba16float": {
+      const t3 = I(e2, l2, "16float", 4);
+      return [t3[0], t3[1], t3[2], t3[3]];
+    }
+    case "r32uint":
+      return [I(e2, l2, "32uint", 1)[0]];
+    case "r32sint":
+      return [I(e2, l2, "32sint", 1)[0]];
+    case "depth16unorm":
+    case "depth24plus":
+    case "depth24plus-stencil8":
+    case "depth32float":
+    case "depth32float-stencil8":
+    case "r32float":
+      return [I(e2, l2, "32float", 1)[0]];
+    case "rg32uint": {
+      const t3 = I(e2, l2, "32uint", 2);
+      return [t3[0], t3[1]];
+    }
+    case "rg32sint": {
+      const t3 = I(e2, l2, "32sint", 2);
+      return [t3[0], t3[1]];
+    }
+    case "rg32float": {
+      const t3 = I(e2, l2, "32float", 2);
+      return [t3[0], t3[1]];
+    }
+    case "rgba32uint": {
+      const t3 = I(e2, l2, "32uint", 4);
+      return [t3[0], t3[1], t3[2], t3[3]];
+    }
+    case "rgba32sint": {
+      const t3 = I(e2, l2, "32sint", 4);
+      return [t3[0], t3[1], t3[2], t3[3]];
+    }
+    case "rgba32float": {
+      const t3 = I(e2, l2, "32float", 4);
+      return [t3[0], t3[1], t3[2], t3[3]];
+    }
+    case "rg11b10ufloat": {
+      const t3 = new Uint32Array(e2.buffer, l2, 1)[0], n3 = (4192256 & t3) >> 11, s3 = (4290772992 & t3) >> 22;
+      return [w(2047 & t3), w(n3), function(e3) {
+        const t4 = 112 + (e3 >> 5 & 31) << 23 | (31 & e3) << 18;
+        return b[0] = t4, v[0];
+      }(s3), 1];
+    }
+  }
+  return null;
+}
+function I(e2, t2, n2, s2) {
+  const r2 = [0, 0, 0, 0];
+  for (let a2 = 0; a2 < s2; ++a2) switch (n2) {
+    case "8unorm":
+      r2[a2] = e2[t2] / 255, t2++;
+      break;
+    case "8snorm":
+      r2[a2] = e2[t2] / 255 * 2 - 1, t2++;
+      break;
+    case "8uint":
+      r2[a2] = e2[t2], t2++;
+      break;
+    case "8sint":
+      r2[a2] = e2[t2] - 127, t2++;
+      break;
+    case "16uint":
+      r2[a2] = e2[t2] | e2[t2 + 1] << 8, t2 += 2;
+      break;
+    case "16sint":
+      r2[a2] = (e2[t2] | e2[t2 + 1] << 8) - 32768, t2 += 2;
+      break;
+    case "16float":
+      r2[a2] = m(e2[t2] | e2[t2 + 1] << 8), t2 += 2;
+      break;
+    case "32uint":
+    case "32sint":
+      r2[a2] = e2[t2] | e2[t2 + 1] << 8 | e2[t2 + 2] << 16 | e2[t2 + 3] << 24, t2 += 4;
+      break;
+    case "32float":
+      r2[a2] = new Float32Array(e2.buffer, t2, 1)[0], t2 += 4;
+  }
+  return r2;
+}
+function T(e2, t2, n2, s2, r2) {
+  for (let a2 = 0; a2 < s2; ++a2) switch (n2) {
+    case "8unorm":
+      e2[t2] = 255 * r2[a2], t2++;
+      break;
+    case "8snorm":
+      e2[t2] = 0.5 * (r2[a2] + 1) * 255, t2++;
+      break;
+    case "8uint":
+      e2[t2] = r2[a2], t2++;
+      break;
+    case "8sint":
+      e2[t2] = r2[a2] + 127, t2++;
+      break;
+    case "16uint":
+      new Uint16Array(e2.buffer, t2, 1)[0] = r2[a2], t2 += 2;
+      break;
+    case "16sint":
+      new Int16Array(e2.buffer, t2, 1)[0] = r2[a2], t2 += 2;
+      break;
+    case "16float": {
+      const n3 = y(r2[a2]);
+      new Uint16Array(e2.buffer, t2, 1)[0] = n3, t2 += 2;
+      break;
+    }
+    case "32uint":
+      new Uint32Array(e2.buffer, t2, 1)[0] = r2[a2], t2 += 4;
+      break;
+    case "32sint":
+      new Int32Array(e2.buffer, t2, 1)[0] = r2[a2], t2 += 4;
+      break;
+    case "32float":
+      new Float32Array(e2.buffer, t2, 1)[0] = r2[a2], t2 += 4;
+  }
+  return r2;
+}
+const S = { r8unorm: { bytesPerBlock: 1, blockWidth: 1, blockHeight: 1, isCompressed: false, channels: 1 }, r8snorm: { bytesPerBlock: 1, blockWidth: 1, blockHeight: 1, isCompressed: false, channels: 1 }, r8uint: { bytesPerBlock: 1, blockWidth: 1, blockHeight: 1, isCompressed: false, channels: 1 }, r8sint: { bytesPerBlock: 1, blockWidth: 1, blockHeight: 1, isCompressed: false, channels: 1 }, rg8unorm: { bytesPerBlock: 2, blockWidth: 1, blockHeight: 1, isCompressed: false, channels: 2 }, rg8snorm: { bytesPerBlock: 2, blockWidth: 1, blockHeight: 1, isCompressed: false, channels: 2 }, rg8uint: { bytesPerBlock: 2, blockWidth: 1, blockHeight: 1, isCompressed: false, channels: 2 }, rg8sint: { bytesPerBlock: 2, blockWidth: 1, blockHeight: 1, isCompressed: false, channels: 2 }, rgba8unorm: { bytesPerBlock: 4, blockWidth: 1, blockHeight: 1, isCompressed: false, channels: 4 }, "rgba8unorm-srgb": { bytesPerBlock: 4, blockWidth: 1, blockHeight: 1, isCompressed: false, channels: 4 }, rgba8snorm: { bytesPerBlock: 4, blockWidth: 1, blockHeight: 1, isCompressed: false, channels: 4 }, rgba8uint: { bytesPerBlock: 4, blockWidth: 1, blockHeight: 1, isCompressed: false, channels: 4 }, rgba8sint: { bytesPerBlock: 4, blockWidth: 1, blockHeight: 1, isCompressed: false, channels: 4 }, bgra8unorm: { bytesPerBlock: 4, blockWidth: 1, blockHeight: 1, isCompressed: false, channels: 4 }, "bgra8unorm-srgb": { bytesPerBlock: 4, blockWidth: 1, blockHeight: 1, isCompressed: false, channels: 4 }, r16uint: { bytesPerBlock: 2, blockWidth: 1, blockHeight: 1, isCompressed: false, channels: 1 }, r16sint: { bytesPerBlock: 2, blockWidth: 1, blockHeight: 1, isCompressed: false, channels: 1 }, r16float: { bytesPerBlock: 2, blockWidth: 1, blockHeight: 1, isCompressed: false, channels: 1 }, rg16uint: { bytesPerBlock: 4, blockWidth: 1, blockHeight: 1, isCompressed: false, channels: 2 }, rg16sint: { bytesPerBlock: 4, blockWidth: 1, blockHeight: 1, isCompressed: false, channels: 2 }, rg16float: { bytesPerBlock: 4, blockWidth: 1, blockHeight: 1, isCompressed: false, channels: 2 }, rgba16uint: { bytesPerBlock: 8, blockWidth: 1, blockHeight: 1, isCompressed: false, channels: 4 }, rgba16sint: { bytesPerBlock: 8, blockWidth: 1, blockHeight: 1, isCompressed: false, channels: 4 }, rgba16float: { bytesPerBlock: 8, blockWidth: 1, blockHeight: 1, isCompressed: false, channels: 4 }, r32uint: { bytesPerBlock: 4, blockWidth: 1, blockHeight: 1, isCompressed: false, channels: 1 }, r32sint: { bytesPerBlock: 4, blockWidth: 1, blockHeight: 1, isCompressed: false, channels: 1 }, r32float: { bytesPerBlock: 4, blockWidth: 1, blockHeight: 1, isCompressed: false, channels: 1 }, rg32uint: { bytesPerBlock: 8, blockWidth: 1, blockHeight: 1, isCompressed: false, channels: 2 }, rg32sint: { bytesPerBlock: 8, blockWidth: 1, blockHeight: 1, isCompressed: false, channels: 2 }, rg32float: { bytesPerBlock: 8, blockWidth: 1, blockHeight: 1, isCompressed: false, channels: 2 }, rgba32uint: { bytesPerBlock: 16, blockWidth: 1, blockHeight: 1, isCompressed: false, channels: 4 }, rgba32sint: { bytesPerBlock: 16, blockWidth: 1, blockHeight: 1, isCompressed: false, channels: 4 }, rgba32float: { bytesPerBlock: 16, blockWidth: 1, blockHeight: 1, isCompressed: false, channels: 4 }, rgb10a2uint: { bytesPerBlock: 4, blockWidth: 1, blockHeight: 1, isCompressed: false, channels: 4 }, rgb10a2unorm: { bytesPerBlock: 4, blockWidth: 1, blockHeight: 1, isCompressed: false, channels: 4 }, rg11b10ufloat: { bytesPerBlock: 4, blockWidth: 1, blockHeight: 1, isCompressed: false, channels: 4 }, stencil8: { bytesPerBlock: 1, blockWidth: 1, blockHeight: 1, isCompressed: false, isDepthStencil: true, hasDepth: false, hasStencil: true, channels: 1 }, depth16unorm: { bytesPerBlock: 2, blockWidth: 1, blockHeight: 1, isCompressed: false, isDepthStencil: true, hasDepth: true, hasStencil: false, channels: 1 }, depth24plus: { bytesPerBlock: 4, blockWidth: 1, blockHeight: 1, isCompressed: false, isDepthStencil: true, hasDepth: true, hasStencil: false, depthOnlyFormat: "depth32float", channels: 1 }, "depth24plus-stencil8": { bytesPerBlock: 8, blockWidth: 1, blockHeight: 1, isCompressed: false, isDepthStencil: true, hasDepth: true, hasStencil: true, depthOnlyFormat: "depth32float", channels: 1 }, depth32float: { bytesPerBlock: 4, blockWidth: 1, blockHeight: 1, isCompressed: false, isDepthStencil: true, hasDepth: true, hasStencil: false, channels: 1 }, "depth32float-stencil8": { bytesPerBlock: 8, blockWidth: 1, blockHeight: 1, isCompressed: false, isDepthStencil: true, hasDepth: true, hasStencil: true, stencilOnlyFormat: "depth32float", channels: 1 }, rgb9e5ufloat: { bytesPerBlock: 4, blockWidth: 1, blockHeight: 1, isCompressed: false, channels: 4 }, "bc1-rgba-unorm": { bytesPerBlock: 8, blockWidth: 4, blockHeight: 4, isCompressed: true, channels: 4 }, "bc1-rgba-unorm-srgb": { bytesPerBlock: 8, blockWidth: 4, blockHeight: 4, isCompressed: true, channels: 4 }, "bc2-rgba-unorm": { bytesPerBlock: 16, blockWidth: 4, blockHeight: 4, isCompressed: true, channels: 4 }, "bc2-rgba-unorm-srgb": { bytesPerBlock: 16, blockWidth: 4, blockHeight: 4, isCompressed: true, channels: 4 }, "bc3-rgba-unorm": { bytesPerBlock: 16, blockWidth: 4, blockHeight: 4, isCompressed: true, channels: 4 }, "bc3-rgba-unorm-srgb": { bytesPerBlock: 16, blockWidth: 4, blockHeight: 4, isCompressed: true, channels: 4 }, "bc4-r-unorm": { bytesPerBlock: 8, blockWidth: 4, blockHeight: 4, isCompressed: true, channels: 1 }, "bc4-r-snorm": { bytesPerBlock: 8, blockWidth: 4, blockHeight: 4, isCompressed: true, channels: 1 }, "bc5-rg-unorm": { bytesPerBlock: 16, blockWidth: 4, blockHeight: 4, isCompressed: true, channels: 2 }, "bc5-rg-snorm": { bytesPerBlock: 16, blockWidth: 4, blockHeight: 4, isCompressed: true, channels: 2 }, "bc6h-rgb-ufloat": { bytesPerBlock: 16, blockWidth: 4, blockHeight: 4, isCompressed: true, channels: 4 }, "bc6h-rgb-float": { bytesPerBlock: 16, blockWidth: 4, blockHeight: 4, isCompressed: true, channels: 4 }, "bc7-rgba-unorm": { bytesPerBlock: 16, blockWidth: 4, blockHeight: 4, isCompressed: true, channels: 4 }, "bc7-rgba-unorm-srgb": { bytesPerBlock: 16, blockWidth: 4, blockHeight: 4, isCompressed: true, channels: 4 }, "etc2-rgb8unorm": { bytesPerBlock: 8, blockWidth: 4, blockHeight: 4, isCompressed: true, channels: 4 }, "etc2-rgb8unorm-srgb": { bytesPerBlock: 8, blockWidth: 4, blockHeight: 4, isCompressed: true, channels: 4 }, "etc2-rgb8a1unorm": { bytesPerBlock: 8, blockWidth: 4, blockHeight: 4, isCompressed: true, channels: 4 }, "etc2-rgb8a1unorm-srgb": { bytesPerBlock: 8, blockWidth: 4, blockHeight: 4, isCompressed: true, channels: 4 }, "etc2-rgba8unorm": { bytesPerBlock: 16, blockWidth: 4, blockHeight: 4, isCompressed: true, channels: 4 }, "etc2-rgba8unorm-srgb": { bytesPerBlock: 16, blockWidth: 4, blockHeight: 4, isCompressed: true, channels: 4 }, "eac-r11unorm": { bytesPerBlock: 8, blockWidth: 1, blockHeight: 1, isCompressed: true, channels: 1 }, "eac-r11snorm": { bytesPerBlock: 8, blockWidth: 1, blockHeight: 1, isCompressed: true, channels: 1 }, "eac-rg11unorm": { bytesPerBlock: 16, blockWidth: 1, blockHeight: 1, isCompressed: true, channels: 2 }, "eac-rg11snorm": { bytesPerBlock: 16, blockWidth: 1, blockHeight: 1, isCompressed: true, channels: 2 }, "astc-4x4-unorm": { bytesPerBlock: 16, blockWidth: 4, blockHeight: 4, isCompressed: true, channels: 4 }, "astc-4x4-unorm-srgb": { bytesPerBlock: 16, blockWidth: 4, blockHeight: 4, isCompressed: true, channels: 4 }, "astc-5x4-unorm": { bytesPerBlock: 16, blockWidth: 5, blockHeight: 4, isCompressed: true, channels: 4 }, "astc-5x4-unorm-srgb": { bytesPerBlock: 16, blockWidth: 5, blockHeight: 4, isCompressed: true, channels: 4 }, "astc-5x5-unorm": { bytesPerBlock: 16, blockWidth: 5, blockHeight: 5, isCompressed: true, channels: 4 }, "astc-5x5-unorm-srgb": { bytesPerBlock: 16, blockWidth: 5, blockHeight: 5, isCompressed: true, channels: 4 }, "astc-6x5-unorm": { bytesPerBlock: 16, blockWidth: 6, blockHeight: 5, isCompressed: true, channels: 4 }, "astc-6x5-unorm-srgb": { bytesPerBlock: 16, blockWidth: 6, blockHeight: 5, isCompressed: true, channels: 4 }, "astc-6x6-unorm": { bytesPerBlock: 16, blockWidth: 6, blockHeight: 6, isCompressed: true, channels: 4 }, "astc-6x6-unorm-srgb": { bytesPerBlock: 16, blockWidth: 6, blockHeight: 6, isCompressed: true, channels: 4 }, "astc-8x5-unorm": { bytesPerBlock: 16, blockWidth: 8, blockHeight: 5, isCompressed: true, channels: 4 }, "astc-8x5-unorm-srgb": { bytesPerBlock: 16, blockWidth: 8, blockHeight: 5, isCompressed: true, channels: 4 }, "astc-8x6-unorm": { bytesPerBlock: 16, blockWidth: 8, blockHeight: 6, isCompressed: true, channels: 4 }, "astc-8x6-unorm-srgb": { bytesPerBlock: 16, blockWidth: 8, blockHeight: 6, isCompressed: true, channels: 4 }, "astc-8x8-unorm": { bytesPerBlock: 16, blockWidth: 8, blockHeight: 8, isCompressed: true, channels: 4 }, "astc-8x8-unorm-srgb": { bytesPerBlock: 16, blockWidth: 8, blockHeight: 8, isCompressed: true, channels: 4 }, "astc-10x5-unorm": { bytesPerBlock: 16, blockWidth: 10, blockHeight: 5, isCompressed: true, channels: 4 }, "astc-10x5-unorm-srgb": { bytesPerBlock: 16, blockWidth: 10, blockHeight: 5, isCompressed: true, channels: 4 }, "astc-10x6-unorm": { bytesPerBlock: 16, blockWidth: 10, blockHeight: 6, isCompressed: true, channels: 4 }, "astc-10x6-unorm-srgb": { bytesPerBlock: 16, blockWidth: 10, blockHeight: 6, isCompressed: true, channels: 4 }, "astc-10x8-unorm": { bytesPerBlock: 16, blockWidth: 10, blockHeight: 8, isCompressed: true, channels: 4 }, "astc-10x8-unorm-srgb": { bytesPerBlock: 16, blockWidth: 10, blockHeight: 8, isCompressed: true, channels: 4 }, "astc-10x10-unorm": { bytesPerBlock: 16, blockWidth: 10, blockHeight: 10, isCompressed: true, channels: 4 }, "astc-10x10-unorm-srgb": { bytesPerBlock: 16, blockWidth: 10, blockHeight: 10, isCompressed: true, channels: 4 }, "astc-12x10-unorm": { bytesPerBlock: 16, blockWidth: 12, blockHeight: 10, isCompressed: true, channels: 4 }, "astc-12x10-unorm-srgb": { bytesPerBlock: 16, blockWidth: 12, blockHeight: 10, isCompressed: true, channels: 4 }, "astc-12x12-unorm": { bytesPerBlock: 16, blockWidth: 12, blockHeight: 12, isCompressed: true, channels: 4 }, "astc-12x12-unorm-srgb": { bytesPerBlock: 16, blockWidth: 12, blockHeight: 12, isCompressed: true, channels: 4 } };
+class A {
+  constructor() {
+    this.id = A._id++, this.line = 0;
+  }
+  get isAstNode() {
+    return true;
+  }
+  get astNodeType() {
+    return "";
+  }
+  search(e2) {
+    e2(this);
+  }
+  searchBlock(e2, t2) {
+    if (e2) {
+      t2(E.instance);
+      for (const n2 of e2) n2 instanceof Array ? this.searchBlock(n2, t2) : n2.search(t2);
+      t2($.instance);
+    }
+  }
+  constEvaluate(e2, t2) {
+    throw new Error("Cannot evaluate node");
+  }
+  constEvaluateString(e2) {
+    return this.constEvaluate(e2).toString();
+  }
+}
+A._id = 0;
+class E extends A {
+}
+E.instance = new E();
+class $ extends A {
+}
+$.instance = new $();
+const L = /* @__PURE__ */ new Set(["all", "all", "any", "select", "arrayLength", "abs", "acos", "acosh", "asin", "asinh", "atan", "atanh", "atan2", "ceil", "clamp", "cos", "cosh", "countLeadingZeros", "countOneBits", "countTrailingZeros", "cross", "degrees", "determinant", "distance", "dot", "dot4U8Packed", "dot4I8Packed", "exp", "exp2", "extractBits", "faceForward", "firstLeadingBit", "firstTrailingBit", "floor", "fma", "fract", "frexp", "insertBits", "inverseSqrt", "ldexp", "length", "log", "log2", "max", "min", "mix", "modf", "normalize", "pow", "quantizeToF16", "radians", "reflect", "refract", "reverseBits", "round", "saturate", "sign", "sin", "sinh", "smoothStep", "sqrt", "step", "tan", "tanh", "transpose", "trunc", "dpdx", "dpdxCoarse", "dpdxFine", "dpdy", "dpdyCoarse", "dpdyFine", "fwidth", "fwidthCoarse", "fwidthFine", "textureDimensions", "textureGather", "textureGatherCompare", "textureLoad", "textureNumLayers", "textureNumLevels", "textureNumSamples", "textureSample", "textureSampleBias", "textureSampleCompare", "textureSampleCompareLevel", "textureSampleGrad", "textureSampleLevel", "textureSampleBaseClampToEdge", "textureStore", "atomicLoad", "atomicStore", "atomicAdd", "atomicSub", "atomicMax", "atomicMin", "atomicAnd", "atomicOr", "atomicXor", "atomicExchange", "atomicCompareExchangeWeak", "pack4x8snorm", "pack4x8unorm", "pack4xI8", "pack4xU8", "pack4x8Clamp", "pack4xU8Clamp", "pack2x16snorm", "pack2x16unorm", "pack2x16float", "unpack4x8snorm", "unpack4x8unorm", "unpack4xI8", "unpack4xU8", "unpack2x16snorm", "unpack2x16unorm", "unpack2x16float", "storageBarrier", "textureBarrier", "workgroupBarrier", "workgroupUniformLoad", "subgroupAdd", "subgroupExclusiveAdd", "subgroupInclusiveAdd", "subgroupAll", "subgroupAnd", "subgroupAny", "subgroupBallot", "subgroupBroadcast", "subgroupBroadcastFirst", "subgroupElect", "subgroupMax", "subgroupMin", "subgroupMul", "subgroupExclusiveMul", "subgroupInclusiveMul", "subgroupOr", "subgroupShuffle", "subgroupShuffleDown", "subgroupShuffleUp", "subgroupShuffleXor", "subgroupXor", "quadBroadcast", "quadSwapDiagonal", "quadSwapX", "quadSwapY"]);
+class C extends A {
+  constructor() {
+    super();
+  }
+}
+class D extends C {
+  constructor(e2, t2, n2, s2, r2, a2) {
+    super(), this.calls = /* @__PURE__ */ new Set(), this.name = e2, this.args = t2, this.returnType = n2, this.body = s2, this.startLine = r2, this.endLine = a2;
+  }
+  get astNodeType() {
+    return "function";
+  }
+  search(e2) {
+    if (this.attributes) for (const t2 of this.attributes) e2(t2);
+    e2(this);
+    for (const t2 of this.args) e2(t2);
+    this.searchBlock(this.body, e2);
+  }
+}
+class N extends C {
+  constructor(e2) {
+    super(), this.expression = e2;
+  }
+  get astNodeType() {
+    return "staticAssert";
+  }
+  search(e2) {
+    this.expression.search(e2);
+  }
+}
+class V extends C {
+  constructor(e2, t2) {
+    super(), this.condition = e2, this.body = t2;
+  }
+  get astNodeType() {
+    return "while";
+  }
+  search(e2) {
+    this.condition.search(e2), this.searchBlock(this.body, e2);
+  }
+}
+class O extends C {
+  constructor(e2, t2) {
+    super(), this.body = e2, this.loopId = t2;
+  }
+  get astNodeType() {
+    return "continuing";
+  }
+  search(e2) {
+    this.searchBlock(this.body, e2);
+  }
+}
+class B extends C {
+  constructor(e2, t2, n2, s2) {
+    super(), this.init = e2, this.condition = t2, this.increment = n2, this.body = s2;
+  }
+  get astNodeType() {
+    return "for";
+  }
+  search(e2) {
+    var t2, n2, s2;
+    null === (t2 = this.init) || void 0 === t2 || t2.search(e2), null === (n2 = this.condition) || void 0 === n2 || n2.search(e2), null === (s2 = this.increment) || void 0 === s2 || s2.search(e2), this.searchBlock(this.body, e2);
+  }
+}
+class F extends C {
+  constructor(e2, t2, n2, s2, r2) {
+    super(), this.attributes = null, this.name = e2, this.type = t2, this.storage = n2, this.access = s2, this.value = r2;
+  }
+  get astNodeType() {
+    return "var";
+  }
+  search(e2) {
+    var t2;
+    e2(this), null === (t2 = this.value) || void 0 === t2 || t2.search(e2);
+  }
+}
+class M extends C {
+  constructor(e2, t2, n2) {
+    super(), this.attributes = null, this.name = e2, this.type = t2, this.value = n2;
+  }
+  get astNodeType() {
+    return "override";
+  }
+  search(e2) {
+    var t2;
+    null === (t2 = this.value) || void 0 === t2 || t2.search(e2);
+  }
+}
+class U extends C {
+  constructor(e2, t2, n2, s2, r2) {
+    super(), this.attributes = null, this.name = e2, this.type = t2, this.storage = n2, this.access = s2, this.value = r2;
+  }
+  get astNodeType() {
+    return "let";
+  }
+  search(e2) {
+    var t2;
+    e2(this), null === (t2 = this.value) || void 0 === t2 || t2.search(e2);
+  }
+}
+class P extends C {
+  constructor(e2, t2, n2, s2, r2) {
+    super(), this.attributes = null, this.name = e2, this.type = t2, this.storage = n2, this.access = s2, this.value = r2;
+  }
+  get astNodeType() {
+    return "const";
+  }
+  constEvaluate(e2, t2) {
+    return this.value.constEvaluate(e2, t2);
+  }
+  search(e2) {
+    var t2;
+    e2(this), null === (t2 = this.value) || void 0 === t2 || t2.search(e2);
+  }
+}
+var W, q, H, z;
+((e2) => {
+  e2.increment = "++", e2.decrement = "--";
+})(W || (W = {})), ((e2) => {
+  e2.parse = function(t2) {
+    const n2 = t2;
+    if ("parse" == n2) throw new Error("Invalid value for IncrementOperator");
+    return e2[n2];
+  };
+})(W || (W = {}));
+class R extends C {
+  constructor(e2, t2) {
+    super(), this.operator = e2, this.variable = t2;
+  }
+  get astNodeType() {
+    return "increment";
+  }
+  search(e2) {
+    this.variable.search(e2);
+  }
+}
+((e2) => {
+  e2.assign = "=", e2.addAssign = "+=", e2.subtractAssin = "-=", e2.multiplyAssign = "*=", e2.divideAssign = "/=", e2.moduloAssign = "%=", e2.andAssign = "&=", e2.orAssign = "|=", e2.xorAssign = "^=", e2.shiftLeftAssign = "<<=", e2.shiftRightAssign = ">>=";
+})(q || (q = {})), ((e2) => {
+  e2.parse = function(e3) {
+    const t2 = e3;
+    if ("parse" == t2) throw new Error("Invalid value for AssignOperator");
+    return t2;
+  };
+})(q || (q = {}));
+class G extends C {
+  constructor(e2, t2, n2) {
+    super(), this.operator = e2, this.variable = t2, this.value = n2;
+  }
+  get astNodeType() {
+    return "assign";
+  }
+  search(e2) {
+    this.variable.search(e2), this.value.search(e2);
+  }
+}
+class X extends C {
+  constructor(e2, t2) {
+    super(), this.name = e2, this.args = t2;
+  }
+  get astNodeType() {
+    return "call";
+  }
+  isBuiltin() {
+    return L.has(this.name);
+  }
+  search(e2) {
+    for (const t2 of this.args) t2.search(e2);
+    e2(this);
+  }
+}
+class j extends C {
+  constructor(e2, t2) {
+    super(), this.body = e2, this.continuing = t2;
+  }
+  get astNodeType() {
+    return "loop";
+  }
+  search(e2) {
+    var t2;
+    this.searchBlock(this.body, e2), null === (t2 = this.continuing) || void 0 === t2 || t2.search(e2);
+  }
+}
+class Z extends C {
+  constructor(e2, t2) {
+    super(), this.condition = e2, this.cases = t2;
+  }
+  get astNodeType() {
+    return "switch";
+  }
+  search(e2) {
+    e2(this);
+    for (const t2 of this.cases) t2.search(e2);
+  }
+}
+class Q extends C {
+  constructor(e2, t2, n2, s2) {
+    super(), this.condition = e2, this.body = t2, this.elseif = n2, this.else = s2;
+  }
+  get astNodeType() {
+    return "if";
+  }
+  search(e2) {
+    this.condition.search(e2), this.searchBlock(this.body, e2), this.searchBlock(this.elseif, e2), this.searchBlock(this.else, e2);
+  }
+}
+class Y extends C {
+  constructor(e2) {
+    super(), this.value = e2;
+  }
+  get astNodeType() {
+    return "return";
+  }
+  search(e2) {
+    var t2;
+    null === (t2 = this.value) || void 0 === t2 || t2.search(e2);
+  }
+}
+class K extends C {
+  constructor(e2) {
+    super(), this.name = e2;
+  }
+  get astNodeType() {
+    return "enable";
+  }
+}
+class J extends C {
+  constructor(e2) {
+    super(), this.extensions = e2;
+  }
+  get astNodeType() {
+    return "requires";
+  }
+}
+class ee extends C {
+  constructor(e2, t2) {
+    super(), this.severity = e2, this.rule = t2;
+  }
+  get astNodeType() {
+    return "diagnostic";
+  }
+}
+class te extends C {
+  constructor(e2, t2) {
+    super(), this.name = e2, this.type = t2;
+  }
+  get astNodeType() {
+    return "alias";
+  }
+}
+class ne extends C {
+  constructor() {
+    super();
+  }
+  get astNodeType() {
+    return "discard";
+  }
+}
+class se extends C {
+  constructor() {
+    super(), this.condition = null, this.loopId = -1;
+  }
+  get astNodeType() {
+    return "break";
+  }
+}
+class re extends C {
+  constructor() {
+    super(), this.loopId = -1;
+  }
+  get astNodeType() {
+    return "continue";
+  }
+}
+class ae extends C {
+  constructor(e2) {
+    super(), this.attributes = null, this.name = e2;
+  }
+  get astNodeType() {
+    return "type";
+  }
+  get isStruct() {
+    return false;
+  }
+  get isArray() {
+    return false;
+  }
+  static maxFormatType(e2) {
+    let t2 = e2[0];
+    if ("f32" === t2.name) return t2;
+    for (let n2 = 1; n2 < e2.length; ++n2) {
+      const s2 = ae._priority.get(t2.name);
+      ae._priority.get(e2[n2].name) < s2 && (t2 = e2[n2]);
+    }
+    return "x32" === t2.name ? ae.i32 : t2;
+  }
+  getTypeName() {
+    return this.name;
+  }
+}
+ae.x32 = new ae("x32"), ae.f32 = new ae("f32"), ae.i32 = new ae("i32"), ae.u32 = new ae("u32"), ae.f16 = new ae("f16"), ae.bool = new ae("bool"), ae.void = new ae("void"), ae._priority = /* @__PURE__ */ new Map([["f32", 0], ["f16", 1], ["u32", 2], ["i32", 3], ["x32", 3]]);
+class ie extends ae {
+  constructor(e2) {
+    super(e2);
+  }
+}
+class oe extends ae {
+  constructor(e2, t2, n2, s2) {
+    super(e2), this.members = t2, this.startLine = n2, this.endLine = s2;
+  }
+  get astNodeType() {
+    return "struct";
+  }
+  get isStruct() {
+    return true;
+  }
+  getMemberIndex(e2) {
+    for (let t2 = 0; t2 < this.members.length; t2++) if (this.members[t2].name == e2) return t2;
+    return -1;
+  }
+  search(e2) {
+    for (const t2 of this.members) e2(t2);
+  }
+}
+class ce extends ae {
+  constructor(e2, t2, n2) {
+    super(e2), this.format = t2, this.access = n2;
+  }
+  get astNodeType() {
+    return "template";
+  }
+  getTypeName() {
+    let e2 = this.name;
+    if (null !== this.format) {
+      if ("vec2" === e2 || "vec3" === e2 || "vec4" === e2 || "mat2x2" === e2 || "mat2x3" === e2 || "mat2x4" === e2 || "mat3x2" === e2 || "mat3x3" === e2 || "mat3x4" === e2 || "mat4x2" === e2 || "mat4x3" === e2 || "mat4x4" === e2) {
+        if ("f32" === this.format.name) return e2 += "f", e2;
+        if ("i32" === this.format.name) return e2 += "i", e2;
+        if ("u32" === this.format.name) return e2 += "u", e2;
+        if ("bool" === this.format.name) return e2 += "b", e2;
+        if ("f16" === this.format.name) return e2 += "h", e2;
+      }
+      e2 += `<${this.format.name}>`;
+    } else if ("vec2" === e2 || "vec3" === e2 || "vec4" === e2) return e2;
+    return e2;
+  }
+}
+ce.vec2f = new ce("vec2", ae.f32, null), ce.vec3f = new ce("vec3", ae.f32, null), ce.vec4f = new ce("vec4", ae.f32, null), ce.vec2i = new ce("vec2", ae.i32, null), ce.vec3i = new ce("vec3", ae.i32, null), ce.vec4i = new ce("vec4", ae.i32, null), ce.vec2u = new ce("vec2", ae.u32, null), ce.vec3u = new ce("vec3", ae.u32, null), ce.vec4u = new ce("vec4", ae.u32, null), ce.vec2h = new ce("vec2", ae.f16, null), ce.vec3h = new ce("vec3", ae.f16, null), ce.vec4h = new ce("vec4", ae.f16, null), ce.vec2b = new ce("vec2", ae.bool, null), ce.vec3b = new ce("vec3", ae.bool, null), ce.vec4b = new ce("vec4", ae.bool, null), ce.mat2x2f = new ce("mat2x2", ae.f32, null), ce.mat2x3f = new ce("mat2x3", ae.f32, null), ce.mat2x4f = new ce("mat2x4", ae.f32, null), ce.mat3x2f = new ce("mat3x2", ae.f32, null), ce.mat3x3f = new ce("mat3x3", ae.f32, null), ce.mat3x4f = new ce("mat3x4", ae.f32, null), ce.mat4x2f = new ce("mat4x2", ae.f32, null), ce.mat4x3f = new ce("mat4x3", ae.f32, null), ce.mat4x4f = new ce("mat4x4", ae.f32, null), ce.mat2x2h = new ce("mat2x2", ae.f16, null), ce.mat2x3h = new ce("mat2x3", ae.f16, null), ce.mat2x4h = new ce("mat2x4", ae.f16, null), ce.mat3x2h = new ce("mat3x2", ae.f16, null), ce.mat3x3h = new ce("mat3x3", ae.f16, null), ce.mat3x4h = new ce("mat3x4", ae.f16, null), ce.mat4x2h = new ce("mat4x2", ae.f16, null), ce.mat4x3h = new ce("mat4x3", ae.f16, null), ce.mat4x4h = new ce("mat4x4", ae.f16, null), ce.mat2x2i = new ce("mat2x2", ae.i32, null), ce.mat2x3i = new ce("mat2x3", ae.i32, null), ce.mat2x4i = new ce("mat2x4", ae.i32, null), ce.mat3x2i = new ce("mat3x2", ae.i32, null), ce.mat3x3i = new ce("mat3x3", ae.i32, null), ce.mat3x4i = new ce("mat3x4", ae.i32, null), ce.mat4x2i = new ce("mat4x2", ae.i32, null), ce.mat4x3i = new ce("mat4x3", ae.i32, null), ce.mat4x4i = new ce("mat4x4", ae.i32, null), ce.mat2x2u = new ce("mat2x2", ae.u32, null), ce.mat2x3u = new ce("mat2x3", ae.u32, null), ce.mat2x4u = new ce("mat2x4", ae.u32, null), ce.mat3x2u = new ce("mat3x2", ae.u32, null), ce.mat3x3u = new ce("mat3x3", ae.u32, null), ce.mat3x4u = new ce("mat3x4", ae.u32, null), ce.mat4x2u = new ce("mat4x2", ae.u32, null), ce.mat4x3u = new ce("mat4x3", ae.u32, null), ce.mat4x4u = new ce("mat4x4", ae.u32, null);
+class le extends ae {
+  constructor(e2, t2, n2, s2) {
+    super(e2), this.storage = t2, this.type = n2, this.access = s2;
+  }
+  get astNodeType() {
+    return "pointer";
+  }
+}
+class ue extends ae {
+  constructor(e2, t2, n2, s2) {
+    super(e2), this.attributes = t2, this.format = n2, this.count = s2;
+  }
+  get astNodeType() {
+    return "array";
+  }
+  get isArray() {
+    return true;
+  }
+}
+class he extends ae {
+  constructor(e2, t2, n2) {
+    super(e2), this.format = t2, this.access = n2;
+  }
+  get astNodeType() {
+    return "sampler";
+  }
+}
+class fe extends A {
+  constructor() {
+    super(), this.postfix = null;
+  }
+}
+class pe extends fe {
+  constructor(e2) {
+    super(), this.value = e2;
+  }
+  get astNodeType() {
+    return "stringExpr";
+  }
+  toString() {
+    return this.value;
+  }
+  constEvaluateString() {
+    return this.value;
+  }
+}
+class de extends fe {
+  constructor(e2, t2) {
+    super(), this.type = e2, this.args = t2;
+  }
+  get astNodeType() {
+    return "createExpr";
+  }
+  search(e2) {
+    if (e2(this), this.args) for (const t2 of this.args) t2.search(e2);
+  }
+  constEvaluate(e2, t2) {
+    return t2 && (t2[0] = this.type), e2.evalExpression(this, e2.context);
+  }
+}
+class me extends fe {
+  constructor(e2, t2) {
+    super(), this.cachedReturnValue = null, this.name = e2, this.args = t2;
+  }
+  get astNodeType() {
+    return "callExpr";
+  }
+  setCachedReturnValue(e2) {
+    this.cachedReturnValue = e2;
+  }
+  get isBuiltin() {
+    return L.has(this.name);
+  }
+  constEvaluate(e2, t2) {
+    return e2.evalExpression(this, e2.context);
+  }
+  search(e2) {
+    for (const t2 of this.args) t2.search(e2);
+    e2(this);
+  }
+}
+class ge extends fe {
+  constructor(e2) {
+    super(), this.name = e2;
+  }
+  get astNodeType() {
+    return "varExpr";
+  }
+  search(e2) {
+    e2(this), this.postfix && this.postfix.search(e2);
+  }
+  constEvaluate(e2, t2) {
+    return e2.evalExpression(this, e2.context);
+  }
+}
+class _e extends fe {
+  constructor(e2, t2) {
+    super(), this.name = e2, this.initializer = t2;
+  }
+  get astNodeType() {
+    return "constExpr";
+  }
+  constEvaluate(e2, t2) {
+    if (this.initializer) {
+      const t3 = e2.evalExpression(this.initializer, e2.context);
+      return null !== t3 && this.postfix ? t3.getSubData(e2, this.postfix, e2.context) : t3;
+    }
+    return null;
+  }
+  search(e2) {
+    this.initializer.search(e2);
+  }
+}
+class xe extends fe {
+  constructor(e2, t2) {
+    super(), this.value = e2, this.type = t2;
+  }
+  get astNodeType() {
+    return "literalExpr";
+  }
+  constEvaluate(e2, t2) {
+    return void 0 !== t2 && (t2[0] = this.type), this.value;
+  }
+  get isScalar() {
+    return this.value instanceof Be;
+  }
+  get isVector() {
+    return this.value instanceof Me || this.value instanceof Ue;
+  }
+  get scalarValue() {
+    return this.value instanceof Be ? this.value.value : (console.error("Value is not scalar."), 0);
+  }
+  get vectorValue() {
+    return this.value instanceof Me || this.value instanceof Ue ? this.value.data : (console.error("Value is not a vector or matrix."), new Float32Array(0));
+  }
+}
+class ye extends fe {
+  constructor(e2, t2) {
+    super(), this.type = e2, this.value = t2;
+  }
+  get astNodeType() {
+    return "bitcastExpr";
+  }
+  search(e2) {
+    this.value.search(e2);
+  }
+}
+class ve extends fe {
+  constructor(e2) {
+    super(), this.index = e2;
+  }
+  search(e2) {
+    this.index.search(e2);
+  }
+}
+class we extends fe {
+  constructor() {
+    super();
+  }
+}
+class ke extends we {
+  constructor(e2, t2) {
+    super(), this.operator = e2, this.right = t2;
+  }
+  get astNodeType() {
+    return "unaryOp";
+  }
+  constEvaluate(e2, t2) {
+    return e2.evalExpression(this, e2.context);
+  }
+  search(e2) {
+    this.right.search(e2);
+  }
+}
+class Ie extends we {
+  constructor(e2, t2, n2) {
+    super(), this.operator = e2, this.left = t2, this.right = n2;
+  }
+  get astNodeType() {
+    return "binaryOp";
+  }
+  _getPromotedType(e2, t2) {
+    return e2.name === t2.name ? e2 : "f32" === e2.name || "f32" === t2.name ? ae.f32 : "u32" === e2.name || "u32" === t2.name ? ae.u32 : ae.i32;
+  }
+  constEvaluate(e2, t2) {
+    return e2.evalExpression(this, e2.context);
+  }
+  search(e2) {
+    this.left.search(e2), this.right.search(e2);
+  }
+}
+class Te extends A {
+  constructor(e2) {
+    super(), this.body = e2;
+  }
+  search(e2) {
+    e2(this), this.searchBlock(this.body, e2);
+  }
+}
+class Se extends fe {
+  constructor() {
+    super();
+  }
+  get astNodeType() {
+    return "default";
+  }
+}
+class Ae extends Te {
+  constructor(e2, t2) {
+    super(t2), this.selectors = e2;
+  }
+  get astNodeType() {
+    return "case";
+  }
+  search(e2) {
+    this.searchBlock(this.body, e2);
+  }
+}
+class Ee extends Te {
+  constructor(e2) {
+    super(e2);
+  }
+  get astNodeType() {
+    return "default";
+  }
+  search(e2) {
+    this.searchBlock(this.body, e2);
+  }
+}
+class $e extends A {
+  constructor(e2, t2, n2) {
+    super(), this.name = e2, this.type = t2, this.attributes = n2;
+  }
+  get astNodeType() {
+    return "argument";
+  }
+}
+class Le extends A {
+  constructor(e2, t2) {
+    super(), this.condition = e2, this.body = t2;
+  }
+  get astNodeType() {
+    return "elseif";
+  }
+  search(e2) {
+    this.condition.search(e2), this.searchBlock(this.body, e2);
+  }
+}
+class Ce extends A {
+  constructor(e2, t2, n2) {
+    super(), this.name = e2, this.type = t2, this.attributes = n2;
+  }
+  get astNodeType() {
+    return "member";
+  }
+}
+class De extends A {
+  constructor(e2, t2) {
+    super(), this.name = e2, this.value = t2;
+  }
+  get astNodeType() {
+    return "attribute";
+  }
+}
+class Ne {
+  constructor(e2, t2) {
+    this.parent = null, this.typeInfo = e2, this.parent = t2, this.id = Ne._id++;
+  }
+  clone() {
+    throw `Clone: Not implemented for ${this.constructor.name}`;
+  }
+  setDataValue(e2, t2, n2, s2) {
+    console.error(`SetDataValue: Not implemented for ${this.constructor.name}`);
+  }
+  getSubData(e2, t2, n2) {
+    return console.error(`GetDataValue: Not implemented for ${this.constructor.name}`), null;
+  }
+  toString() {
+    return `<${this.typeInfo.getTypeName()}>`;
+  }
+}
+Ne._id = 0;
+class Ve extends Ne {
+  constructor() {
+    super(new e("void", null), null);
+  }
+  toString() {
+    return "void";
+  }
+}
+Ve.void = new Ve();
+class Oe extends Ne {
+  constructor(e2) {
+    super(new r("pointer", e2.typeInfo, null), null), this.reference = e2;
+  }
+  clone() {
+    return this;
+  }
+  setDataValue(e2, t2, n2, s2) {
+    this.reference.setDataValue(e2, t2, n2, s2);
+  }
+  getSubData(e2, t2, n2) {
+    return t2 ? this.reference.getSubData(e2, t2, n2) : this;
+  }
+  toString() {
+    return `&${this.reference.toString()}`;
+  }
+}
+class Be extends Ne {
+  constructor(e2, t2, n2 = null) {
+    super(t2, n2), e2 instanceof Int32Array || e2 instanceof Uint32Array || e2 instanceof Float32Array ? this.data = e2 : "x32" === this.typeInfo.name ? e2 - Math.floor(e2) !== 0 ? this.data = new Float32Array([e2]) : this.data = e2 >= 0 ? new Uint32Array([e2]) : new Int32Array([e2]) : "i32" === this.typeInfo.name || "bool" === this.typeInfo.name ? this.data = new Int32Array([e2]) : "u32" === this.typeInfo.name ? this.data = new Uint32Array([e2]) : "f32" === this.typeInfo.name || "f16" === this.typeInfo.name ? this.data = new Float32Array([e2]) : console.error("ScalarData2: Invalid type", t2);
+  }
+  clone() {
+    if (this.data instanceof Float32Array) return new Be(new Float32Array(this.data), this.typeInfo, null);
+    if (this.data instanceof Int32Array) return new Be(new Int32Array(this.data), this.typeInfo, null);
+    if (this.data instanceof Uint32Array) return new Be(new Uint32Array(this.data), this.typeInfo, null);
+    throw "ScalarData: Invalid data type";
+  }
+  get value() {
+    return this.data[0];
+  }
+  set value(e2) {
+    this.data[0] = e2;
+  }
+  setDataValue(e2, t2, n2, s2) {
+    if (n2) return void console.error("SetDataValue: Scalar data does not support postfix", n2);
+    if (!(t2 instanceof Be)) return void console.error("SetDataValue: Invalid value", t2);
+    let r2 = t2.data[0];
+    "i32" === this.typeInfo.name || "u32" === this.typeInfo.name ? r2 = Math.floor(r2) : "bool" === this.typeInfo.name && (r2 = r2 ? 1 : 0), this.data[0] = r2;
+  }
+  getSubData(e2, t2, n2) {
+    return t2 ? (console.error("getSubData: Scalar data does not support postfix", t2), null) : this;
+  }
+  toString() {
+    return `${this.value}`;
+  }
+}
+function Fe(e2, t2, n2) {
+  const s2 = t2.length;
+  return 2 === s2 ? "f32" === n2 ? new Me(new Float32Array(t2), e2.getTypeInfo("vec2f")) : "i32" === n2 || "bool" === n2 ? new Me(new Int32Array(t2), e2.getTypeInfo("vec2i")) : "u32" === n2 ? new Me(new Uint32Array(t2), e2.getTypeInfo("vec2u")) : "f16" === n2 ? new Me(new Float32Array(t2), e2.getTypeInfo("vec2h")) : (console.error(`getSubData: Unknown format ${n2}`), null) : 3 === s2 ? "f32" === n2 ? new Me(new Float32Array(t2), e2.getTypeInfo("vec3f")) : "i32" === n2 || "bool" === n2 ? new Me(new Int32Array(t2), e2.getTypeInfo("vec3i")) : "u32" === n2 ? new Me(new Uint32Array(t2), e2.getTypeInfo("vec3u")) : "f16" === n2 ? new Me(new Float32Array(t2), e2.getTypeInfo("vec3h")) : (console.error(`getSubData: Unknown format ${n2}`), null) : 4 === s2 ? "f32" === n2 ? new Me(new Float32Array(t2), e2.getTypeInfo("vec4f")) : "i32" === n2 || "bool" === n2 ? new Me(new Int32Array(t2), e2.getTypeInfo("vec4i")) : "u32" === n2 ? new Me(new Uint32Array(t2), e2.getTypeInfo("vec4u")) : "f16" === n2 ? new Me(new Float32Array(t2), e2.getTypeInfo("vec4h")) : (console.error(`getSubData: Unknown format ${n2}`), null) : (console.error(`getSubData: Invalid vector size ${t2.length}`), null);
+}
+class Me extends Ne {
+  constructor(e2, t2, n2 = null) {
+    if (super(t2, n2), e2 instanceof Float32Array || e2 instanceof Uint32Array || e2 instanceof Int32Array) this.data = e2;
+    else {
+      const t3 = this.typeInfo.name;
+      "vec2f" === t3 || "vec3f" === t3 || "vec4f" === t3 ? this.data = new Float32Array(e2) : "vec2i" === t3 || "vec3i" === t3 || "vec4i" === t3 ? this.data = new Int32Array(e2) : "vec2u" === t3 || "vec3u" === t3 || "vec4u" === t3 ? this.data = new Uint32Array(e2) : "vec2h" === t3 || "vec3h" === t3 || "vec4h" === t3 ? this.data = new Float32Array(e2) : "vec2b" === t3 || "vec3b" === t3 || "vec4b" === t3 ? this.data = new Int32Array(e2) : "vec2" === t3 || "vec3" === t3 || "vec4" === t3 ? this.data = new Float32Array(e2) : console.error(`VectorData: Invalid type ${t3}`);
+    }
+  }
+  clone() {
+    if (this.data instanceof Float32Array) return new Me(new Float32Array(this.data), this.typeInfo, null);
+    if (this.data instanceof Int32Array) return new Me(new Int32Array(this.data), this.typeInfo, null);
+    if (this.data instanceof Uint32Array) return new Me(new Uint32Array(this.data), this.typeInfo, null);
+    throw "VectorData: Invalid data type";
+  }
+  setDataValue(e2, t2, n2, s2) {
+    n2 instanceof pe ? console.error("TODO: Set vector postfix") : t2 instanceof Me ? this.data = t2.data : console.error("SetDataValue: Invalid value", t2);
+  }
+  getSubData(e2, t2, n2) {
+    if (null === t2) return this;
+    let s2 = e2.getTypeInfo("f32");
+    if (this.typeInfo instanceof a) s2 = this.typeInfo.format || s2;
+    else {
+      const t3 = this.typeInfo.name;
+      "vec2f" === t3 || "vec3f" === t3 || "vec4f" === t3 ? s2 = e2.getTypeInfo("f32") : "vec2i" === t3 || "vec3i" === t3 || "vec4i" === t3 ? s2 = e2.getTypeInfo("i32") : "vec2b" === t3 || "vec3b" === t3 || "vec4b" === t3 ? s2 = e2.getTypeInfo("bool") : "vec2u" === t3 || "vec3u" === t3 || "vec4u" === t3 ? s2 = e2.getTypeInfo("u32") : "vec2h" === t3 || "vec3h" === t3 || "vec4h" === t3 ? s2 = e2.getTypeInfo("f16") : console.error(`GetSubData: Unknown type ${t3}`);
+    }
+    let r2 = this;
+    for (; null !== t2 && null !== r2; ) {
+      if (t2 instanceof ve) {
+        const a2 = t2.index;
+        let i2 = -1;
+        if (a2 instanceof xe) {
+          if (!(a2.value instanceof Be)) return console.error(`GetSubData: Invalid array index ${a2.value}`), null;
+          i2 = a2.value.value;
+        } else {
+          const t3 = e2.evalExpression(a2, n2);
+          if (!(t3 instanceof Be)) return console.error("GetSubData: Unknown index type", a2), null;
+          i2 = t3.value;
+        }
+        if (i2 < 0 || i2 >= r2.data.length) return console.error("GetSubData: Index out of range", i2), null;
+        if (r2.data instanceof Float32Array) {
+          const e3 = new Float32Array(r2.data.buffer, r2.data.byteOffset + 4 * i2, 1);
+          return new Be(e3, s2);
+        }
+        if (r2.data instanceof Int32Array) {
+          const e3 = new Int32Array(r2.data.buffer, r2.data.byteOffset + 4 * i2, 1);
+          return new Be(e3, s2);
+        }
+        if (r2.data instanceof Uint32Array) {
+          const e3 = new Uint32Array(r2.data.buffer, r2.data.byteOffset + 4 * i2, 1);
+          return new Be(e3, s2);
+        }
+        throw "GetSubData: Invalid data type";
+      }
+      if (!(t2 instanceof pe)) return console.error("GetSubData: Unknown postfix", t2), null;
+      {
+        const n3 = t2.value.toLowerCase();
+        if (1 === n3.length) {
+          let e3 = 0;
+          if ("x" === n3 || "r" === n3) e3 = 0;
+          else if ("y" === n3 || "g" === n3) e3 = 1;
+          else if ("z" === n3 || "b" === n3) e3 = 2;
+          else {
+            if ("w" !== n3 && "a" !== n3) return console.error(`GetSubData: Unknown member ${n3}`), null;
+            e3 = 3;
+          }
+          if (this.data instanceof Float32Array) {
+            let t3 = new Float32Array(this.data.buffer, this.data.byteOffset + 4 * e3, 1);
+            return new Be(t3, s2, this);
+          }
+          if (this.data instanceof Int32Array) {
+            let t3 = new Int32Array(this.data.buffer, this.data.byteOffset + 4 * e3, 1);
+            return new Be(t3, s2, this);
+          }
+          if (this.data instanceof Uint32Array) {
+            let t3 = new Uint32Array(this.data.buffer, this.data.byteOffset + 4 * e3, 1);
+            return new Be(t3, s2, this);
+          }
+        }
+        const a2 = [];
+        for (const e3 of n3) "x" === e3 || "r" === e3 ? a2.push(this.data[0]) : "y" === e3 || "g" === e3 ? a2.push(this.data[1]) : "z" === e3 || "b" === e3 ? a2.push(this.data[2]) : "w" === e3 || "a" === e3 ? a2.push(this.data[3]) : console.error(`GetDataValue: Unknown member ${e3}`);
+        r2 = Fe(e2, a2, s2.name);
+      }
+      t2 = t2.postfix;
+    }
+    return r2;
+  }
+  toString() {
+    let e2 = `${this.data[0]}`;
+    for (let t2 = 1; t2 < this.data.length; ++t2) e2 += `, ${this.data[t2]}`;
+    return e2;
+  }
+}
+class Ue extends Ne {
+  constructor(e2, t2, n2 = null) {
+    super(t2, n2), e2 instanceof Float32Array ? this.data = e2 : this.data = new Float32Array(e2);
+  }
+  clone() {
+    return new Ue(new Float32Array(this.data), this.typeInfo, null);
+  }
+  setDataValue(e2, t2, n2, s2) {
+    n2 instanceof pe ? console.error("TODO: Set matrix postfix") : t2 instanceof Ue ? this.data = t2.data : console.error("SetDataValue: Invalid value", t2);
+  }
+  getSubData(e2, t2, n2) {
+    if (null === t2) return this;
+    const s2 = this.typeInfo.name;
+    if (e2.getTypeInfo("f32"), this.typeInfo instanceof a) this.typeInfo.format;
+    else if (s2.endsWith("f")) e2.getTypeInfo("f32");
+    else if (s2.endsWith("i")) e2.getTypeInfo("i32");
+    else if (s2.endsWith("u")) e2.getTypeInfo("u32");
+    else {
+      if (!s2.endsWith("h")) return console.error(`GetDataValue: Unknown type ${s2}`), null;
+      e2.getTypeInfo("f16");
+    }
+    if (t2 instanceof ve) {
+      const r2 = t2.index;
+      let a2 = -1;
+      if (r2 instanceof xe) {
+        if (!(r2.value instanceof Be)) return console.error(`GetDataValue: Invalid array index ${r2.value}`), null;
+        a2 = r2.value.value;
+      } else {
+        const t3 = e2.evalExpression(r2, n2);
+        if (!(t3 instanceof Be)) return console.error("GetDataValue: Unknown index type", r2), null;
+        a2 = t3.value;
+      }
+      if (a2 < 0 || a2 >= this.data.length) return console.error("GetDataValue: Index out of range", a2), null;
+      const i2 = s2.endsWith("h") ? "h" : "f";
+      let o2;
+      if ("mat2x2" === s2 || "mat2x2f" === s2 || "mat2x2h" === s2 || "mat3x2" === s2 || "mat3x2f" === s2 || "mat3x2h" === s2 || "mat4x2" === s2 || "mat4x2f" === s2 || "mat4x2h" === s2) o2 = new Me(new Float32Array(this.data.buffer, this.data.byteOffset + 2 * a2 * 4, 2), e2.getTypeInfo(`vec2${i2}`));
+      else if ("mat2x3" === s2 || "mat2x3f" === s2 || "mat2x3h" === s2 || "mat3x3" === s2 || "mat3x3f" === s2 || "mat3x3h" === s2 || "mat4x3" === s2 || "mat4x3f" === s2 || "mat4x3h" === s2) o2 = new Me(new Float32Array(this.data.buffer, this.data.byteOffset + 3 * a2 * 4, 3), e2.getTypeInfo(`vec3${i2}`));
+      else {
+        if ("mat2x4" !== s2 && "mat2x4f" !== s2 && "mat2x4h" !== s2 && "mat3x4" !== s2 && "mat3x4f" !== s2 && "mat3x4h" !== s2 && "mat4x4" !== s2 && "mat4x4f" !== s2 && "mat4x4h" !== s2) return console.error(`GetDataValue: Unknown type ${s2}`), null;
+        o2 = new Me(new Float32Array(this.data.buffer, this.data.byteOffset + 4 * a2 * 4, 4), e2.getTypeInfo(`vec4${i2}`));
+      }
+      return t2.postfix ? o2.getSubData(e2, t2.postfix, n2) : o2;
+    }
+    return console.error("GetDataValue: Invalid postfix", t2), null;
+  }
+  toString() {
+    let e2 = `${this.data[0]}`;
+    for (let t2 = 1; t2 < this.data.length; ++t2) e2 += `, ${this.data[t2]}`;
+    return e2;
+  }
+}
+class Pe extends Ne {
+  constructor(e2, t2, n2 = 0, s2 = null) {
+    super(t2, s2), this.buffer = e2 instanceof ArrayBuffer ? e2 : e2.buffer, this.offset = n2;
+  }
+  clone() {
+    const e2 = new Uint8Array(new Uint8Array(this.buffer, this.offset, this.typeInfo.size));
+    return new Pe(e2.buffer, this.typeInfo, 0, null);
+  }
+  setDataValue(t2, r2, a2, i2) {
+    if (null === r2) return void console.log("setDataValue: NULL data.");
+    let o2 = this.offset, c2 = this.typeInfo;
+    for (; a2; ) {
+      if (a2 instanceof ve) if (c2 instanceof s) {
+        const e2 = a2.index;
+        if (e2 instanceof xe) {
+          if (!(e2.value instanceof Be)) return void console.error(`SetDataValue: Invalid index type ${e2.value}`);
+          o2 += e2.value.value * c2.stride;
+        } else {
+          const n2 = t2.evalExpression(e2, i2);
+          if (!(n2 instanceof Be)) return void console.error("SetDataValue: Unknown index type", e2);
+          o2 += n2.value * c2.stride;
+        }
+        c2 = c2.format;
+      } else console.error(`SetDataValue: Type ${c2.getTypeName()} is not an array`);
+      else {
+        if (!(a2 instanceof pe)) return void console.error("SetDataValue: Unknown postfix type", a2);
+        {
+          const t3 = a2.value;
+          if (c2 instanceof n) {
+            let e2 = false;
+            for (const n2 of c2.members) if (n2.name === t3) {
+              o2 += n2.offset, c2 = n2.type, e2 = true;
+              break;
+            }
+            if (!e2) return void console.error(`SetDataValue: Member ${t3} not found`);
+          } else if (c2 instanceof e) {
+            const e2 = c2.getTypeName();
+            let n2 = 0;
+            if ("x" === t3 || "r" === t3) n2 = 0;
+            else if ("y" === t3 || "g" === t3) n2 = 1;
+            else if ("z" === t3 || "b" === t3) n2 = 2;
+            else {
+              if ("w" !== t3 && "a" !== t3) return void console.error(`SetDataValue: Unknown member ${t3}`);
+              n2 = 3;
+            }
+            if (!(r2 instanceof Be)) return void console.error("SetDataValue: Invalid value", r2);
+            const s2 = r2.value;
+            return "vec2f" === e2 ? void (new Float32Array(this.buffer, o2, 2)[n2] = s2) : "vec3f" === e2 ? void (new Float32Array(this.buffer, o2, 3)[n2] = s2) : "vec4f" === e2 ? void (new Float32Array(this.buffer, o2, 4)[n2] = s2) : "vec2i" === e2 ? void (new Int32Array(this.buffer, o2, 2)[n2] = s2) : "vec3i" === e2 ? void (new Int32Array(this.buffer, o2, 3)[n2] = s2) : "vec4i" === e2 ? void (new Int32Array(this.buffer, o2, 4)[n2] = s2) : "vec2u" === e2 ? void (new Uint32Array(this.buffer, o2, 2)[n2] = s2) : "vec3u" === e2 ? void (new Uint32Array(this.buffer, o2, 3)[n2] = s2) : "vec4u" === e2 ? void (new Uint32Array(this.buffer, o2, 4)[n2] = s2) : void console.error(`SetDataValue: Type ${e2} is not a struct`);
+          }
+        }
+      }
+      a2 = a2.postfix;
+    }
+    this.setData(t2, r2, c2, o2, i2);
+  }
+  setData(e2, t2, n2, s2, r2) {
+    const a2 = n2.getTypeName();
+    if ("f32" !== a2 && "f16" !== a2) if ("i32" !== a2 && "atomic<i32>" !== a2 && "x32" !== a2) if ("u32" !== a2 && "atomic<u32>" !== a2) if ("bool" !== a2) {
+      if ("vec2f" === a2 || "vec2h" === a2) {
+        const e3 = new Float32Array(this.buffer, s2, 2);
+        return void (t2 instanceof Me ? (e3[0] = t2.data[0], e3[1] = t2.data[1]) : (e3[0] = t2[0], e3[1] = t2[1]));
+      }
+      if ("vec3f" === a2 || "vec3h" === a2) {
+        const e3 = new Float32Array(this.buffer, s2, 3);
+        return void (t2 instanceof Me ? (e3[0] = t2.data[0], e3[1] = t2.data[1], e3[2] = t2.data[2]) : (e3[0] = t2[0], e3[1] = t2[1], e3[2] = t2[2]));
+      }
+      if ("vec4f" === a2 || "vec4h" === a2) {
+        const e3 = new Float32Array(this.buffer, s2, 4);
+        return void (t2 instanceof Me ? (e3[0] = t2.data[0], e3[1] = t2.data[1], e3[2] = t2.data[2], e3[3] = t2.data[3]) : (e3[0] = t2[0], e3[1] = t2[1], e3[2] = t2[2], e3[3] = t2[3]));
+      }
+      if ("vec2i" === a2) {
+        const e3 = new Int32Array(this.buffer, s2, 2);
+        return void (t2 instanceof Me ? (e3[0] = t2.data[0], e3[1] = t2.data[1]) : (e3[0] = t2[0], e3[1] = t2[1]));
+      }
+      if ("vec3i" === a2) {
+        const e3 = new Int32Array(this.buffer, s2, 3);
+        return void (t2 instanceof Me ? (e3[0] = t2.data[0], e3[1] = t2.data[1], e3[2] = t2.data[2]) : (e3[0] = t2[0], e3[1] = t2[1], e3[2] = t2[2]));
+      }
+      if ("vec4i" === a2) {
+        const e3 = new Int32Array(this.buffer, s2, 4);
+        return void (t2 instanceof Me ? (e3[0] = t2.data[0], e3[1] = t2.data[1], e3[2] = t2.data[2], e3[3] = t2.data[3]) : (e3[0] = t2[0], e3[1] = t2[1], e3[2] = t2[2], e3[3] = t2[3]));
+      }
+      if ("vec2u" === a2) {
+        const e3 = new Uint32Array(this.buffer, s2, 2);
+        return void (t2 instanceof Me ? (e3[0] = t2.data[0], e3[1] = t2.data[1]) : (e3[0] = t2[0], e3[1] = t2[1]));
+      }
+      if ("vec3u" === a2) {
+        const e3 = new Uint32Array(this.buffer, s2, 3);
+        return void (t2 instanceof Me ? (e3[0] = t2.data[0], e3[1] = t2.data[1], e3[2] = t2.data[2]) : (e3[0] = t2[0], e3[1] = t2[1], e3[2] = t2[2]));
+      }
+      if ("vec4u" === a2) {
+        const e3 = new Uint32Array(this.buffer, s2, 4);
+        return void (t2 instanceof Me ? (e3[0] = t2.data[0], e3[1] = t2.data[1], e3[2] = t2.data[2], e3[3] = t2.data[3]) : (e3[0] = t2[0], e3[1] = t2[1], e3[2] = t2[2], e3[3] = t2[3]));
+      }
+      if ("vec2b" === a2) {
+        const e3 = new Uint32Array(this.buffer, s2, 2);
+        return void (t2 instanceof Me ? (e3[0] = t2.data[0], e3[1] = t2.data[1]) : (e3[0] = t2[0], e3[1] = t2[1]));
+      }
+      if ("vec3b" === a2) {
+        const e3 = new Uint32Array(this.buffer, s2, 3);
+        return void (t2 instanceof Me ? (e3[0] = t2.data[0], e3[1] = t2.data[1], e3[2] = t2.data[2]) : (e3[0] = t2[0], e3[1] = t2[1], e3[2] = t2[2]));
+      }
+      if ("vec4b" === a2) {
+        const e3 = new Uint32Array(this.buffer, s2, 4);
+        return void (t2 instanceof Me ? (e3[0] = t2.data[0], e3[1] = t2.data[1], e3[2] = t2.data[2], e3[3] = t2.data[3]) : (e3[0] = t2[0], e3[1] = t2[1], e3[2] = t2[2], e3[3] = t2[3]));
+      }
+      if ("mat2x2f" === a2 || "mat2x2h" === a2) {
+        const e3 = new Float32Array(this.buffer, s2, 4);
+        return void (t2 instanceof Ue ? (e3[0] = t2.data[0], e3[1] = t2.data[1], e3[2] = t2.data[2], e3[3] = t2.data[3]) : (e3[0] = t2[0], e3[1] = t2[1], e3[2] = t2[2], e3[3] = t2[3]));
+      }
+      if ("mat2x3f" === a2 || "mat2x3h" === a2) {
+        const e3 = new Float32Array(this.buffer, s2, 6);
+        return void (t2 instanceof Ue ? (e3[0] = t2.data[0], e3[1] = t2.data[1], e3[2] = t2.data[2], e3[3] = t2.data[3], e3[4] = t2.data[4], e3[5] = t2.data[5]) : (e3[0] = t2[0], e3[1] = t2[1], e3[2] = t2[2], e3[3] = t2[3], e3[4] = t2[4], e3[5] = t2[5]));
+      }
+      if ("mat2x4f" === a2 || "mat2x4h" === a2) {
+        const e3 = new Float32Array(this.buffer, s2, 8);
+        return void (t2 instanceof Ue ? (e3[0] = t2.data[0], e3[1] = t2.data[1], e3[2] = t2.data[2], e3[3] = t2.data[3], e3[4] = t2.data[4], e3[5] = t2.data[5], e3[6] = t2.data[6], e3[7] = t2.data[7]) : (e3[0] = t2[0], e3[1] = t2[1], e3[2] = t2[2], e3[3] = t2[3], e3[4] = t2[4], e3[5] = t2[5], e3[6] = t2[6], e3[7] = t2[7]));
+      }
+      if ("mat3x2f" === a2 || "mat3x2h" === a2) {
+        const e3 = new Float32Array(this.buffer, s2, 6);
+        return void (t2 instanceof Ue ? (e3[0] = t2.data[0], e3[1] = t2.data[1], e3[2] = t2.data[2], e3[3] = t2.data[3], e3[4] = t2.data[4], e3[5] = t2.data[5]) : (e3[0] = t2[0], e3[1] = t2[1], e3[2] = t2[2], e3[3] = t2[3], e3[4] = t2[4], e3[5] = t2[5]));
+      }
+      if ("mat3x3f" === a2 || "mat3x3h" === a2) {
+        const e3 = new Float32Array(this.buffer, s2, 9);
+        return void (t2 instanceof Ue ? (e3[0] = t2.data[0], e3[1] = t2.data[1], e3[2] = t2.data[2], e3[3] = t2.data[3], e3[4] = t2.data[4], e3[5] = t2.data[5], e3[6] = t2.data[6], e3[7] = t2.data[7], e3[8] = t2.data[8]) : (e3[0] = t2[0], e3[1] = t2[1], e3[2] = t2[2], e3[3] = t2[3], e3[4] = t2[4], e3[5] = t2[5], e3[6] = t2[6], e3[7] = t2[7], e3[8] = t2[8]));
+      }
+      if ("mat3x4f" === a2 || "mat3x4h" === a2) {
+        const e3 = new Float32Array(this.buffer, s2, 12);
+        return void (t2 instanceof Ue ? (e3[0] = t2.data[0], e3[1] = t2.data[1], e3[2] = t2.data[2], e3[3] = t2.data[3], e3[4] = t2.data[4], e3[5] = t2.data[5], e3[6] = t2.data[6], e3[7] = t2.data[7], e3[8] = t2.data[8], e3[9] = t2.data[9], e3[10] = t2.data[10], e3[11] = t2.data[11]) : (e3[0] = t2[0], e3[1] = t2[1], e3[2] = t2[2], e3[3] = t2[3], e3[4] = t2[4], e3[5] = t2[5], e3[6] = t2[6], e3[7] = t2[7], e3[8] = t2[8], e3[9] = t2[9], e3[10] = t2[10], e3[11] = t2[11]));
+      }
+      if ("mat4x2f" === a2 || "mat4x2h" === a2) {
+        const e3 = new Float32Array(this.buffer, s2, 8);
+        return void (t2 instanceof Ue ? (e3[0] = t2.data[0], e3[1] = t2.data[1], e3[2] = t2.data[2], e3[3] = t2.data[3], e3[4] = t2.data[4], e3[5] = t2.data[5], e3[6] = t2.data[6], e3[7] = t2.data[7]) : (e3[0] = t2[0], e3[1] = t2[1], e3[2] = t2[2], e3[3] = t2[3], e3[4] = t2[4], e3[5] = t2[5], e3[6] = t2[6], e3[7] = t2[7]));
+      }
+      if ("mat4x3f" === a2 || "mat4x3h" === a2) {
+        const e3 = new Float32Array(this.buffer, s2, 12);
+        return void (t2 instanceof Ue ? (e3[0] = t2.data[0], e3[1] = t2.data[1], e3[2] = t2.data[2], e3[3] = t2.data[3], e3[4] = t2.data[4], e3[5] = t2.data[5], e3[6] = t2.data[6], e3[7] = t2.data[7], e3[8] = t2.data[8], e3[9] = t2.data[9], e3[10] = t2.data[10], e3[11] = t2.data[11]) : (e3[0] = t2[0], e3[1] = t2[1], e3[2] = t2[2], e3[3] = t2[3], e3[4] = t2[4], e3[5] = t2[5], e3[6] = t2[6], e3[7] = t2[7], e3[8] = t2[8], e3[9] = t2[9], e3[10] = t2[10], e3[11] = t2[11]));
+      }
+      if ("mat4x4f" === a2 || "mat4x4h" === a2) {
+        const e3 = new Float32Array(this.buffer, s2, 16);
+        return void (t2 instanceof Ue ? (e3[0] = t2.data[0], e3[1] = t2.data[1], e3[2] = t2.data[2], e3[3] = t2.data[3], e3[4] = t2.data[4], e3[5] = t2.data[5], e3[6] = t2.data[6], e3[7] = t2.data[7], e3[8] = t2.data[8], e3[9] = t2.data[9], e3[10] = t2.data[10], e3[11] = t2.data[11], e3[12] = t2.data[12], e3[13] = t2.data[13], e3[14] = t2.data[14], e3[15] = t2.data[15]) : (e3[0] = t2[0], e3[1] = t2[1], e3[2] = t2[2], e3[3] = t2[3], e3[4] = t2[4], e3[5] = t2[5], e3[6] = t2[6], e3[7] = t2[7], e3[8] = t2[8], e3[9] = t2[9], e3[10] = t2[10], e3[11] = t2[11], e3[12] = t2[12], e3[13] = t2[13], e3[14] = t2[14], e3[15] = t2[15]));
+      }
+      if (t2 instanceof Pe) {
+        if (n2 === t2.typeInfo) {
+          return void new Uint8Array(this.buffer, s2, t2.buffer.byteLength).set(new Uint8Array(t2.buffer));
+        }
+        console.error("SetDataValue: Type mismatch", a2, t2.typeInfo.getTypeName());
+      } else console.error(`SetData: Unknown type ${a2}`);
+    } else t2 instanceof Be && (new Int32Array(this.buffer, s2, 1)[0] = t2.value);
+    else t2 instanceof Be && (new Uint32Array(this.buffer, s2, 1)[0] = t2.value);
+    else t2 instanceof Be && (new Int32Array(this.buffer, s2, 1)[0] = t2.value);
+    else t2 instanceof Be && (new Float32Array(this.buffer, s2, 1)[0] = t2.value);
+  }
+  getSubData(t2, r2, i2) {
+    var o2, c2, l2;
+    if (null === r2) return this;
+    let u2 = this.offset, h2 = this.typeInfo;
+    for (; r2; ) {
+      if (r2 instanceof ve) {
+        const e2 = r2.index, n2 = e2 instanceof fe ? t2.evalExpression(e2, i2) : e2;
+        let a2 = 0;
+        if (n2 instanceof Be ? a2 = n2.value : "number" == typeof n2 ? a2 = n2 : console.error("GetDataValue: Invalid index type", e2), h2 instanceof s) u2 += a2 * h2.stride, h2 = h2.format;
+        else {
+          const e3 = h2.getTypeName();
+          "mat4x4" === e3 || "mat4x4f" === e3 || "mat4x4h" === e3 ? (u2 += 16 * a2, h2 = t2.getTypeInfo("vec4f")) : console.error(`getDataValue: Type ${h2.getTypeName()} is not an array`);
+        }
+      } else {
+        if (!(r2 instanceof pe)) return console.error("GetDataValue: Unknown postfix type", r2), null;
+        {
+          const s2 = r2.value;
+          if (h2 instanceof n) {
+            let e2 = false;
+            for (const t3 of h2.members) if (t3.name === s2) {
+              u2 += t3.offset, h2 = t3.type, e2 = true;
+              break;
+            }
+            if (!e2) return console.error(`GetDataValue: Member ${s2} not found`), null;
+          } else if (h2 instanceof e) {
+            const e2 = h2.getTypeName();
+            if ("vec2f" === e2 || "vec3f" === e2 || "vec4f" === e2 || "vec2i" === e2 || "vec3i" === e2 || "vec4i" === e2 || "vec2u" === e2 || "vec3u" === e2 || "vec4u" === e2 || "vec2b" === e2 || "vec3b" === e2 || "vec4b" === e2 || "vec2h" === e2 || "vec3h" === e2 || "vec4h" === e2 || "vec2" === e2 || "vec3" === e2 || "vec4" === e2) {
+              if (s2.length > 0 && s2.length < 5) {
+                let n2 = "f";
+                const r3 = [];
+                for (let a2 = 0; a2 < s2.length; ++a2) {
+                  const i3 = s2[a2].toLowerCase();
+                  let o3 = 0;
+                  if ("x" === i3 || "r" === i3) o3 = 0;
+                  else if ("y" === i3 || "g" === i3) o3 = 1;
+                  else if ("z" === i3 || "b" === i3) o3 = 2;
+                  else {
+                    if ("w" !== i3 && "a" !== i3) return console.error(`Unknown member ${s2}`), null;
+                    o3 = 3;
+                  }
+                  if (1 === s2.length) {
+                    if (e2.endsWith("f")) return this.buffer.byteLength < u2 + 4 * o3 + 4 ? (console.log("Insufficient buffer data"), null) : new Be(new Float32Array(this.buffer, u2 + 4 * o3, 1), t2.getTypeInfo("f32"), this);
+                    if (e2.endsWith("h")) return new Be(new Float32Array(this.buffer, u2 + 4 * o3, 1), t2.getTypeInfo("f16"), this);
+                    if (e2.endsWith("i")) return new Be(new Int32Array(this.buffer, u2 + 4 * o3, 1), t2.getTypeInfo("i32"), this);
+                    if (e2.endsWith("b")) return new Be(new Int32Array(this.buffer, u2 + 4 * o3, 1), t2.getTypeInfo("bool"), this);
+                    if (e2.endsWith("u")) return new Be(new Uint32Array(this.buffer, u2 + 4 * o3, 1), t2.getTypeInfo("i32"), this);
+                  }
+                  if ("vec2f" === e2) r3.push(new Float32Array(this.buffer, u2, 2)[o3]);
+                  else if ("vec3f" === e2) {
+                    if (u2 + 12 >= this.buffer.byteLength) return console.log("Insufficient buffer data"), null;
+                    const e3 = new Float32Array(this.buffer, u2, 3);
+                    r3.push(e3[o3]);
+                  } else if ("vec4f" === e2) r3.push(new Float32Array(this.buffer, u2, 4)[o3]);
+                  else if ("vec2i" === e2) n2 = "i", r3.push(new Int32Array(this.buffer, u2, 2)[o3]);
+                  else if ("vec3i" === e2) n2 = "i", r3.push(new Int32Array(this.buffer, u2, 3)[o3]);
+                  else if ("vec4i" === e2) n2 = "i", r3.push(new Int32Array(this.buffer, u2, 4)[o3]);
+                  else if ("vec2u" === e2) {
+                    n2 = "u";
+                    const e3 = new Uint32Array(this.buffer, u2, 2);
+                    r3.push(e3[o3]);
+                  } else "vec3u" === e2 ? (n2 = "u", r3.push(new Uint32Array(this.buffer, u2, 3)[o3])) : "vec4u" === e2 && (n2 = "u", r3.push(new Uint32Array(this.buffer, u2, 4)[o3]));
+                }
+                return 2 === r3.length ? h2 = t2.getTypeInfo(`vec2${n2}`) : 3 === r3.length ? h2 = t2.getTypeInfo(`vec3${n2}`) : 4 === r3.length ? h2 = t2.getTypeInfo(`vec4${n2}`) : console.error(`GetDataValue: Invalid vector length ${r3.length}`), new Me(r3, h2, null);
+              }
+              return console.error(`GetDataValue: Unknown member ${s2}`), null;
+            }
+            return console.error(`GetDataValue: Type ${e2} is not a struct`), null;
+          }
+        }
+      }
+      r2 = r2.postfix;
+    }
+    const f2 = h2.getTypeName();
+    return "f32" === f2 ? new Be(new Float32Array(this.buffer, u2, 1), h2, this) : "i32" === f2 ? new Be(new Int32Array(this.buffer, u2, 1), h2, this) : "u32" === f2 ? new Be(new Uint32Array(this.buffer, u2, 1), h2, this) : "vec2f" === f2 ? new Me(new Float32Array(this.buffer, u2, 2), h2, this) : "vec3f" === f2 ? new Me(new Float32Array(this.buffer, u2, 3), h2, this) : "vec4f" === f2 ? new Me(new Float32Array(this.buffer, u2, 4), h2, this) : "vec2i" === f2 ? new Me(new Int32Array(this.buffer, u2, 2), h2, this) : "vec3i" === f2 ? new Me(new Int32Array(this.buffer, u2, 3), h2, this) : "vec4i" === f2 ? new Me(new Int32Array(this.buffer, u2, 4), h2, this) : "vec2u" === f2 ? new Me(new Uint32Array(this.buffer, u2, 2), h2, this) : "vec3u" === f2 ? new Me(new Uint32Array(this.buffer, u2, 3), h2, this) : "vec4u" === f2 ? new Me(new Uint32Array(this.buffer, u2, 4), h2, this) : h2 instanceof a && "atomic" === h2.name ? "u32" === (null === (o2 = h2.format) || void 0 === o2 ? void 0 : o2.name) ? new Be(new Uint32Array(this.buffer, u2, 1)[0], h2.format, this) : "i32" === (null === (c2 = h2.format) || void 0 === c2 ? void 0 : c2.name) ? new Be(new Int32Array(this.buffer, u2, 1)[0], h2.format, this) : (console.error(`GetDataValue: Invalid atomic format ${null === (l2 = h2.format) || void 0 === l2 ? void 0 : l2.name}`), null) : new Pe(this.buffer, h2, u2, this);
+  }
+  toString() {
+    let e2 = "";
+    if (this.typeInfo instanceof s) if ("f32" === this.typeInfo.format.name) {
+      const t2 = new Float32Array(this.buffer, this.offset);
+      e2 = `[${t2[0]}`;
+      for (let n2 = 1; n2 < t2.length; ++n2) e2 += `, ${t2[n2]}`;
+    } else if ("i32" === this.typeInfo.format.name) {
+      const t2 = new Int32Array(this.buffer, this.offset);
+      e2 = `[${t2[0]}`;
+      for (let n2 = 1; n2 < t2.length; ++n2) e2 += `, ${t2[n2]}`;
+    } else if ("u32" === this.typeInfo.format.name) {
+      const t2 = new Uint32Array(this.buffer, this.offset);
+      e2 = `[${t2[0]}`;
+      for (let n2 = 1; n2 < t2.length; ++n2) e2 += `, ${t2[n2]}`;
+    } else if ("vec2f" === this.typeInfo.format.name) {
+      const t2 = new Float32Array(this.buffer, this.offset);
+      e2 = `[${t2[0]}, ${t2[1]}]`;
+      for (let n2 = 1; n2 < t2.length / 2; ++n2) e2 += `, [${t2[2 * n2]}, ${t2[2 * n2 + 1]}]`;
+    } else if ("vec3f" === this.typeInfo.format.name) {
+      const t2 = new Float32Array(this.buffer, this.offset);
+      e2 = `[${t2[0]}, ${t2[1]}, ${t2[2]}]`;
+      for (let n2 = 4; n2 < t2.length; n2 += 4) e2 += `, [${t2[n2]}, ${t2[n2 + 1]}, ${t2[n2 + 2]}]`;
+    } else if ("vec4f" === this.typeInfo.format.name) {
+      const t2 = new Float32Array(this.buffer, this.offset);
+      e2 = `[${t2[0]}, ${t2[1]}, ${t2[2]}, ${t2[3]}]`;
+      for (let n2 = 4; n2 < t2.length; n2 += 4) e2 += `, [${t2[n2]}, ${t2[n2 + 1]}, ${t2[n2 + 2]}, ${t2[n2 + 3]}]`;
+    } else e2 = "[...]";
+    else this.typeInfo instanceof n ? e2 += "{...}" : e2 = "[...]";
+    return e2;
+  }
+}
+class We extends Ne {
+  constructor(e2, t2, n2, s2) {
+    super(t2, null), this.data = e2, this.descriptor = n2, this.view = s2;
+  }
+  clone() {
+    return new We(this.data, this.typeInfo, this.descriptor, this.view);
+  }
+  get width() {
+    var e2, t2;
+    const n2 = this.descriptor.size;
+    return n2 instanceof Array && n2.length > 0 ? null !== (e2 = n2[0]) && void 0 !== e2 ? e2 : 0 : n2 instanceof Object && null !== (t2 = n2.width) && void 0 !== t2 ? t2 : 0;
+  }
+  get height() {
+    var e2, t2;
+    const n2 = this.descriptor.size;
+    return n2 instanceof Array && n2.length > 1 ? null !== (e2 = n2[1]) && void 0 !== e2 ? e2 : 0 : n2 instanceof Object && null !== (t2 = n2.height) && void 0 !== t2 ? t2 : 0;
+  }
+  get depthOrArrayLayers() {
+    var e2, t2;
+    const n2 = this.descriptor.size;
+    return n2 instanceof Array && n2.length > 2 ? null !== (e2 = n2[2]) && void 0 !== e2 ? e2 : 0 : n2 instanceof Object && null !== (t2 = n2.depthOrArrayLayers) && void 0 !== t2 ? t2 : 0;
+  }
+  get format() {
+    var e2;
+    return this.descriptor && null !== (e2 = this.descriptor.format) && void 0 !== e2 ? e2 : "rgba8unorm";
+  }
+  get sampleCount() {
+    var e2;
+    return this.descriptor && null !== (e2 = this.descriptor.sampleCount) && void 0 !== e2 ? e2 : 1;
+  }
+  get mipLevelCount() {
+    var e2;
+    return this.descriptor && null !== (e2 = this.descriptor.mipLevelCount) && void 0 !== e2 ? e2 : 1;
+  }
+  get dimension() {
+    var e2;
+    return this.descriptor && null !== (e2 = this.descriptor.dimension) && void 0 !== e2 ? e2 : "2d";
+  }
+  getMipLevelSize(e2) {
+    if (e2 >= this.mipLevelCount) return [0, 0, 0];
+    const t2 = [this.width, this.height, this.depthOrArrayLayers];
+    for (let n2 = 0; n2 < t2.length; ++n2) t2[n2] = Math.max(1, t2[n2] >> e2);
+    return t2;
+  }
+  get texelByteSize() {
+    const e2 = this.format, t2 = S[e2];
+    return t2 ? t2.isDepthStencil ? 4 : t2.bytesPerBlock : 0;
+  }
+  get bytesPerRow() {
+    return this.width * this.texelByteSize;
+  }
+  get isDepthStencil() {
+    const e2 = this.format, t2 = S[e2];
+    return !!t2 && t2.isDepthStencil;
+  }
+  getGpuSize() {
+    const e2 = this.format, t2 = S[e2], n2 = this.width;
+    if (!e2 || n2 <= 0 || !t2) return -1;
+    const s2 = this.height, r2 = this.depthOrArrayLayers, a2 = this.dimension;
+    return n2 / t2.blockWidth * ("1d" === a2 ? 1 : s2 / t2.blockHeight) * t2.bytesPerBlock * r2;
+  }
+  getPixel(e2, t2, n2 = 0, s2 = 0) {
+    const r2 = this.texelByteSize, a2 = this.bytesPerRow, i2 = this.height, o2 = this.data[s2];
+    return k(new Uint8Array(o2), e2, t2, n2, s2, i2, a2, r2, this.format);
+  }
+  setPixel(e2, t2, n2, s2, r2) {
+    const a2 = this.texelByteSize, i2 = this.bytesPerRow, o2 = this.height, c2 = this.data[s2];
+    !function(e3, t3, n3, s3, r3, a3, i3, o3, c3, l2) {
+      const u2 = s3 * (i3 >>= r3) * (a3 >>= r3) + n3 * i3 + t3 * o3;
+      switch (c3) {
+        case "r8unorm":
+          return void T(e3, u2, "8unorm", 1, l2);
+        case "r8snorm":
+          return void T(e3, u2, "8snorm", 1, l2);
+        case "r8uint":
+          return void T(e3, u2, "8uint", 1, l2);
+        case "r8sint":
+          return void T(e3, u2, "8sint", 1, l2);
+        case "rg8unorm":
+          return void T(e3, u2, "8unorm", 2, l2);
+        case "rg8snorm":
+          return void T(e3, u2, "8snorm", 2, l2);
+        case "rg8uint":
+          return void T(e3, u2, "8uint", 2, l2);
+        case "rg8sint":
+          return void T(e3, u2, "8sint", 2, l2);
+        case "rgba8unorm-srgb":
+        case "rgba8unorm":
+        case "bgra8unorm-srgb":
+        case "bgra8unorm":
+          return void T(e3, u2, "8unorm", 4, l2);
+        case "rgba8snorm":
+          return void T(e3, u2, "8snorm", 4, l2);
+        case "rgba8uint":
+          return void T(e3, u2, "8uint", 4, l2);
+        case "rgba8sint":
+          return void T(e3, u2, "8sint", 4, l2);
+        case "r16uint":
+          return void T(e3, u2, "16uint", 1, l2);
+        case "r16sint":
+          return void T(e3, u2, "16sint", 1, l2);
+        case "r16float":
+          return void T(e3, u2, "16float", 1, l2);
+        case "rg16uint":
+          return void T(e3, u2, "16uint", 2, l2);
+        case "rg16sint":
+          return void T(e3, u2, "16sint", 2, l2);
+        case "rg16float":
+          return void T(e3, u2, "16float", 2, l2);
+        case "rgba16uint":
+          return void T(e3, u2, "16uint", 4, l2);
+        case "rgba16sint":
+          return void T(e3, u2, "16sint", 4, l2);
+        case "rgba16float":
+          return void T(e3, u2, "16float", 4, l2);
+        case "r32uint":
+          return void T(e3, u2, "32uint", 1, l2);
+        case "r32sint":
+          return void T(e3, u2, "32sint", 1, l2);
+        case "depth16unorm":
+        case "depth24plus":
+        case "depth24plus-stencil8":
+        case "depth32float":
+        case "depth32float-stencil8":
+        case "r32float":
+          return void T(e3, u2, "32float", 1, l2);
+        case "rg32uint":
+          return void T(e3, u2, "32uint", 2, l2);
+        case "rg32sint":
+          return void T(e3, u2, "32sint", 2, l2);
+        case "rg32float":
+          return void T(e3, u2, "32float", 2, l2);
+        case "rgba32uint":
+          return void T(e3, u2, "32uint", 4, l2);
+        case "rgba32sint":
+          return void T(e3, u2, "32sint", 4, l2);
+        case "rgba32float":
+          return void T(e3, u2, "32float", 4, l2);
+        case "rg11b10ufloat":
+          console.error("TODO: rg11b10ufloat not supported for writing");
+      }
+    }(new Uint8Array(c2), e2, t2, n2, s2, o2, i2, a2, this.format, r2);
+  }
+}
+((e2) => {
+  e2[e2.token = 0] = "token", e2[e2.keyword = 1] = "keyword", e2[e2.reserved = 2] = "reserved";
+})(z || (z = {}));
+class qe {
+  constructor(e2, t2, n2) {
+    this.name = e2, this.type = t2, this.rule = n2;
+  }
+  toString() {
+    return this.name;
+  }
+}
+class He {
+}
+H = He, He.none = new qe("", z.reserved, ""), He.eof = new qe("EOF", z.token, ""), He.reserved = { asm: new qe("asm", z.reserved, "asm"), bf16: new qe("bf16", z.reserved, "bf16"), do: new qe("do", z.reserved, "do"), enum: new qe("enum", z.reserved, "enum"), f16: new qe("f16", z.reserved, "f16"), f64: new qe("f64", z.reserved, "f64"), handle: new qe("handle", z.reserved, "handle"), i8: new qe("i8", z.reserved, "i8"), i16: new qe("i16", z.reserved, "i16"), i64: new qe("i64", z.reserved, "i64"), mat: new qe("mat", z.reserved, "mat"), premerge: new qe("premerge", z.reserved, "premerge"), regardless: new qe("regardless", z.reserved, "regardless"), typedef: new qe("typedef", z.reserved, "typedef"), u8: new qe("u8", z.reserved, "u8"), u16: new qe("u16", z.reserved, "u16"), u64: new qe("u64", z.reserved, "u64"), unless: new qe("unless", z.reserved, "unless"), using: new qe("using", z.reserved, "using"), vec: new qe("vec", z.reserved, "vec"), void: new qe("void", z.reserved, "void") }, He.keywords = { array: new qe("array", z.keyword, "array"), atomic: new qe("atomic", z.keyword, "atomic"), bool: new qe("bool", z.keyword, "bool"), f32: new qe("f32", z.keyword, "f32"), i32: new qe("i32", z.keyword, "i32"), mat2x2: new qe("mat2x2", z.keyword, "mat2x2"), mat2x3: new qe("mat2x3", z.keyword, "mat2x3"), mat2x4: new qe("mat2x4", z.keyword, "mat2x4"), mat3x2: new qe("mat3x2", z.keyword, "mat3x2"), mat3x3: new qe("mat3x3", z.keyword, "mat3x3"), mat3x4: new qe("mat3x4", z.keyword, "mat3x4"), mat4x2: new qe("mat4x2", z.keyword, "mat4x2"), mat4x3: new qe("mat4x3", z.keyword, "mat4x3"), mat4x4: new qe("mat4x4", z.keyword, "mat4x4"), ptr: new qe("ptr", z.keyword, "ptr"), sampler: new qe("sampler", z.keyword, "sampler"), sampler_comparison: new qe("sampler_comparison", z.keyword, "sampler_comparison"), struct: new qe("struct", z.keyword, "struct"), texture_1d: new qe("texture_1d", z.keyword, "texture_1d"), texture_2d: new qe("texture_2d", z.keyword, "texture_2d"), texture_2d_array: new qe("texture_2d_array", z.keyword, "texture_2d_array"), texture_3d: new qe("texture_3d", z.keyword, "texture_3d"), texture_cube: new qe("texture_cube", z.keyword, "texture_cube"), texture_cube_array: new qe("texture_cube_array", z.keyword, "texture_cube_array"), texture_multisampled_2d: new qe("texture_multisampled_2d", z.keyword, "texture_multisampled_2d"), texture_storage_1d: new qe("texture_storage_1d", z.keyword, "texture_storage_1d"), texture_storage_2d: new qe("texture_storage_2d", z.keyword, "texture_storage_2d"), texture_storage_2d_array: new qe("texture_storage_2d_array", z.keyword, "texture_storage_2d_array"), texture_storage_3d: new qe("texture_storage_3d", z.keyword, "texture_storage_3d"), texture_depth_2d: new qe("texture_depth_2d", z.keyword, "texture_depth_2d"), texture_depth_2d_array: new qe("texture_depth_2d_array", z.keyword, "texture_depth_2d_array"), texture_depth_cube: new qe("texture_depth_cube", z.keyword, "texture_depth_cube"), texture_depth_cube_array: new qe("texture_depth_cube_array", z.keyword, "texture_depth_cube_array"), texture_depth_multisampled_2d: new qe("texture_depth_multisampled_2d", z.keyword, "texture_depth_multisampled_2d"), texture_external: new qe("texture_external", z.keyword, "texture_external"), u32: new qe("u32", z.keyword, "u32"), vec2: new qe("vec2", z.keyword, "vec2"), vec3: new qe("vec3", z.keyword, "vec3"), vec4: new qe("vec4", z.keyword, "vec4"), bitcast: new qe("bitcast", z.keyword, "bitcast"), block: new qe("block", z.keyword, "block"), break: new qe("break", z.keyword, "break"), case: new qe("case", z.keyword, "case"), continue: new qe("continue", z.keyword, "continue"), continuing: new qe("continuing", z.keyword, "continuing"), default: new qe("default", z.keyword, "default"), diagnostic: new qe("diagnostic", z.keyword, "diagnostic"), discard: new qe("discard", z.keyword, "discard"), else: new qe("else", z.keyword, "else"), enable: new qe("enable", z.keyword, "enable"), fallthrough: new qe("fallthrough", z.keyword, "fallthrough"), false: new qe("false", z.keyword, "false"), fn: new qe("fn", z.keyword, "fn"), for: new qe("for", z.keyword, "for"), function: new qe("function", z.keyword, "function"), if: new qe("if", z.keyword, "if"), let: new qe("let", z.keyword, "let"), const: new qe("const", z.keyword, "const"), loop: new qe("loop", z.keyword, "loop"), while: new qe("while", z.keyword, "while"), private: new qe("private", z.keyword, "private"), read: new qe("read", z.keyword, "read"), read_write: new qe("read_write", z.keyword, "read_write"), return: new qe("return", z.keyword, "return"), requires: new qe("requires", z.keyword, "requires"), storage: new qe("storage", z.keyword, "storage"), switch: new qe("switch", z.keyword, "switch"), true: new qe("true", z.keyword, "true"), alias: new qe("alias", z.keyword, "alias"), type: new qe("type", z.keyword, "type"), uniform: new qe("uniform", z.keyword, "uniform"), var: new qe("var", z.keyword, "var"), override: new qe("override", z.keyword, "override"), workgroup: new qe("workgroup", z.keyword, "workgroup"), write: new qe("write", z.keyword, "write"), r8unorm: new qe("r8unorm", z.keyword, "r8unorm"), r8snorm: new qe("r8snorm", z.keyword, "r8snorm"), r8uint: new qe("r8uint", z.keyword, "r8uint"), r8sint: new qe("r8sint", z.keyword, "r8sint"), r16uint: new qe("r16uint", z.keyword, "r16uint"), r16sint: new qe("r16sint", z.keyword, "r16sint"), r16float: new qe("r16float", z.keyword, "r16float"), rg8unorm: new qe("rg8unorm", z.keyword, "rg8unorm"), rg8snorm: new qe("rg8snorm", z.keyword, "rg8snorm"), rg8uint: new qe("rg8uint", z.keyword, "rg8uint"), rg8sint: new qe("rg8sint", z.keyword, "rg8sint"), r32uint: new qe("r32uint", z.keyword, "r32uint"), r32sint: new qe("r32sint", z.keyword, "r32sint"), r32float: new qe("r32float", z.keyword, "r32float"), rg16uint: new qe("rg16uint", z.keyword, "rg16uint"), rg16sint: new qe("rg16sint", z.keyword, "rg16sint"), rg16float: new qe("rg16float", z.keyword, "rg16float"), rgba8unorm: new qe("rgba8unorm", z.keyword, "rgba8unorm"), rgba8unorm_srgb: new qe("rgba8unorm_srgb", z.keyword, "rgba8unorm_srgb"), rgba8snorm: new qe("rgba8snorm", z.keyword, "rgba8snorm"), rgba8uint: new qe("rgba8uint", z.keyword, "rgba8uint"), rgba8sint: new qe("rgba8sint", z.keyword, "rgba8sint"), bgra8unorm: new qe("bgra8unorm", z.keyword, "bgra8unorm"), bgra8unorm_srgb: new qe("bgra8unorm_srgb", z.keyword, "bgra8unorm_srgb"), rgb10a2unorm: new qe("rgb10a2unorm", z.keyword, "rgb10a2unorm"), rg11b10float: new qe("rg11b10float", z.keyword, "rg11b10float"), rg32uint: new qe("rg32uint", z.keyword, "rg32uint"), rg32sint: new qe("rg32sint", z.keyword, "rg32sint"), rg32float: new qe("rg32float", z.keyword, "rg32float"), rgba16uint: new qe("rgba16uint", z.keyword, "rgba16uint"), rgba16sint: new qe("rgba16sint", z.keyword, "rgba16sint"), rgba16float: new qe("rgba16float", z.keyword, "rgba16float"), rgba32uint: new qe("rgba32uint", z.keyword, "rgba32uint"), rgba32sint: new qe("rgba32sint", z.keyword, "rgba32sint"), rgba32float: new qe("rgba32float", z.keyword, "rgba32float"), static_assert: new qe("static_assert", z.keyword, "static_assert") }, He.tokens = { decimal_float_literal: new qe("decimal_float_literal", z.token, /((-?[0-9]*\.[0-9]+|-?[0-9]+\.[0-9]*)((e|E)(\+|-)?[0-9]+)?[fh]?)|(-?[0-9]+(e|E)(\+|-)?[0-9]+[fh]?)|(-?[0-9]+[fh])/), hex_float_literal: new qe("hex_float_literal", z.token, /-?0x((([0-9a-fA-F]*\.[0-9a-fA-F]+|[0-9a-fA-F]+\.[0-9a-fA-F]*)((p|P)(\+|-)?[0-9]+[fh]?)?)|([0-9a-fA-F]+(p|P)(\+|-)?[0-9]+[fh]?))/), int_literal: new qe("int_literal", z.token, /-?0x[0-9a-fA-F]+|0i?|-?[1-9][0-9]*i?/), uint_literal: new qe("uint_literal", z.token, /0x[0-9a-fA-F]+u|0u|[1-9][0-9]*u/), name: new qe("name", z.token, /([_\p{XID_Start}][\p{XID_Continue}]+)|([\p{XID_Start}])/u), ident: new qe("ident", z.token, /[_a-zA-Z][0-9a-zA-Z_]*/), and: new qe("and", z.token, "&"), and_and: new qe("and_and", z.token, "&&"), arrow: new qe("arrow ", z.token, "->"), attr: new qe("attr", z.token, "@"), forward_slash: new qe("forward_slash", z.token, "/"), bang: new qe("bang", z.token, "!"), bracket_left: new qe("bracket_left", z.token, "["), bracket_right: new qe("bracket_right", z.token, "]"), brace_left: new qe("brace_left", z.token, "{"), brace_right: new qe("brace_right", z.token, "}"), colon: new qe("colon", z.token, ":"), comma: new qe("comma", z.token, ","), equal: new qe("equal", z.token, "="), equal_equal: new qe("equal_equal", z.token, "=="), not_equal: new qe("not_equal", z.token, "!="), greater_than: new qe("greater_than", z.token, ">"), greater_than_equal: new qe("greater_than_equal", z.token, ">="), shift_right: new qe("shift_right", z.token, ">>"), less_than: new qe("less_than", z.token, "<"), less_than_equal: new qe("less_than_equal", z.token, "<="), shift_left: new qe("shift_left", z.token, "<<"), modulo: new qe("modulo", z.token, "%"), minus: new qe("minus", z.token, "-"), minus_minus: new qe("minus_minus", z.token, "--"), period: new qe("period", z.token, "."), plus: new qe("plus", z.token, "+"), plus_plus: new qe("plus_plus", z.token, "++"), or: new qe("or", z.token, "|"), or_or: new qe("or_or", z.token, "||"), paren_left: new qe("paren_left", z.token, "("), paren_right: new qe("paren_right", z.token, ")"), semicolon: new qe("semicolon", z.token, ";"), star: new qe("star", z.token, "*"), tilde: new qe("tilde", z.token, "~"), underscore: new qe("underscore", z.token, "_"), xor: new qe("xor", z.token, "^"), plus_equal: new qe("plus_equal", z.token, "+="), minus_equal: new qe("minus_equal", z.token, "-="), times_equal: new qe("times_equal", z.token, "*="), division_equal: new qe("division_equal", z.token, "/="), modulo_equal: new qe("modulo_equal", z.token, "%="), and_equal: new qe("and_equal", z.token, "&="), or_equal: new qe("or_equal", z.token, "|="), xor_equal: new qe("xor_equal", z.token, "^="), shift_right_equal: new qe("shift_right_equal", z.token, ">>="), shift_left_equal: new qe("shift_left_equal", z.token, "<<=") }, He.simpleTokens = { "@": H.tokens.attr, "{": H.tokens.brace_left, "}": H.tokens.brace_right, ":": H.tokens.colon, ",": H.tokens.comma, "(": H.tokens.paren_left, ")": H.tokens.paren_right, ";": H.tokens.semicolon }, He.literalTokens = { "&": H.tokens.and, "&&": H.tokens.and_and, "->": H.tokens.arrow, "/": H.tokens.forward_slash, "!": H.tokens.bang, "[": H.tokens.bracket_left, "]": H.tokens.bracket_right, "=": H.tokens.equal, "==": H.tokens.equal_equal, "!=": H.tokens.not_equal, ">": H.tokens.greater_than, ">=": H.tokens.greater_than_equal, ">>": H.tokens.shift_right, "<": H.tokens.less_than, "<=": H.tokens.less_than_equal, "<<": H.tokens.shift_left, "%": H.tokens.modulo, "-": H.tokens.minus, "--": H.tokens.minus_minus, ".": H.tokens.period, "+": H.tokens.plus, "++": H.tokens.plus_plus, "|": H.tokens.or, "||": H.tokens.or_or, "*": H.tokens.star, "~": H.tokens.tilde, _: H.tokens.underscore, "^": H.tokens.xor, "+=": H.tokens.plus_equal, "-=": H.tokens.minus_equal, "*=": H.tokens.times_equal, "/=": H.tokens.division_equal, "%=": H.tokens.modulo_equal, "&=": H.tokens.and_equal, "|=": H.tokens.or_equal, "^=": H.tokens.xor_equal, ">>=": H.tokens.shift_right_equal, "<<=": H.tokens.shift_left_equal }, He.regexTokens = { decimal_float_literal: H.tokens.decimal_float_literal, hex_float_literal: H.tokens.hex_float_literal, int_literal: H.tokens.int_literal, uint_literal: H.tokens.uint_literal, ident: H.tokens.ident }, He.storage_class = [H.keywords.function, H.keywords.private, H.keywords.workgroup, H.keywords.uniform, H.keywords.storage], He.access_mode = [H.keywords.read, H.keywords.write, H.keywords.read_write], He.sampler_type = [H.keywords.sampler, H.keywords.sampler_comparison], He.sampled_texture_type = [H.keywords.texture_1d, H.keywords.texture_2d, H.keywords.texture_2d_array, H.keywords.texture_3d, H.keywords.texture_cube, H.keywords.texture_cube_array], He.multisampled_texture_type = [H.keywords.texture_multisampled_2d], He.storage_texture_type = [H.keywords.texture_storage_1d, H.keywords.texture_storage_2d, H.keywords.texture_storage_2d_array, H.keywords.texture_storage_3d], He.depth_texture_type = [H.keywords.texture_depth_2d, H.keywords.texture_depth_2d_array, H.keywords.texture_depth_cube, H.keywords.texture_depth_cube_array, H.keywords.texture_depth_multisampled_2d], He.texture_external_type = [H.keywords.texture_external], He.any_texture_type = [...H.sampled_texture_type, ...H.multisampled_texture_type, ...H.storage_texture_type, ...H.depth_texture_type, ...H.texture_external_type], He.texel_format = [H.keywords.r8unorm, H.keywords.r8snorm, H.keywords.r8uint, H.keywords.r8sint, H.keywords.r16uint, H.keywords.r16sint, H.keywords.r16float, H.keywords.rg8unorm, H.keywords.rg8snorm, H.keywords.rg8uint, H.keywords.rg8sint, H.keywords.r32uint, H.keywords.r32sint, H.keywords.r32float, H.keywords.rg16uint, H.keywords.rg16sint, H.keywords.rg16float, H.keywords.rgba8unorm, H.keywords.rgba8unorm_srgb, H.keywords.rgba8snorm, H.keywords.rgba8uint, H.keywords.rgba8sint, H.keywords.bgra8unorm, H.keywords.bgra8unorm_srgb, H.keywords.rgb10a2unorm, H.keywords.rg11b10float, H.keywords.rg32uint, H.keywords.rg32sint, H.keywords.rg32float, H.keywords.rgba16uint, H.keywords.rgba16sint, H.keywords.rgba16float, H.keywords.rgba32uint, H.keywords.rgba32sint, H.keywords.rgba32float], He.const_literal = [H.tokens.int_literal, H.tokens.uint_literal, H.tokens.decimal_float_literal, H.tokens.hex_float_literal, H.keywords.true, H.keywords.false], He.literal_or_ident = [H.tokens.ident, H.tokens.int_literal, H.tokens.uint_literal, H.tokens.decimal_float_literal, H.tokens.hex_float_literal, H.tokens.name], He.element_count_expression = [H.tokens.int_literal, H.tokens.uint_literal, H.tokens.ident], He.template_types = [H.keywords.vec2, H.keywords.vec3, H.keywords.vec4, H.keywords.mat2x2, H.keywords.mat2x3, H.keywords.mat2x4, H.keywords.mat3x2, H.keywords.mat3x3, H.keywords.mat3x4, H.keywords.mat4x2, H.keywords.mat4x3, H.keywords.mat4x4, H.keywords.atomic, H.keywords.bitcast, ...H.any_texture_type], He.attribute_name = [H.tokens.ident, H.keywords.block, H.keywords.diagnostic], He.assignment_operators = [H.tokens.equal, H.tokens.plus_equal, H.tokens.minus_equal, H.tokens.times_equal, H.tokens.division_equal, H.tokens.modulo_equal, H.tokens.and_equal, H.tokens.or_equal, H.tokens.xor_equal, H.tokens.shift_right_equal, H.tokens.shift_left_equal], He.increment_operators = [H.tokens.plus_plus, H.tokens.minus_minus];
+class ze {
+  constructor(e2, t2, n2, s2, r2) {
+    this.type = e2, this.lexeme = t2, this.line = n2, this.start = s2, this.end = r2;
+  }
+  toString() {
+    return this.lexeme;
+  }
+  isTemplateType() {
+    return -1 != He.template_types.indexOf(this.type);
+  }
+  isArrayType() {
+    return this.type == He.keywords.array;
+  }
+  isArrayOrTemplateType() {
+    return this.isArrayType() || this.isTemplateType();
+  }
+}
+class Re {
+  constructor(e2) {
+    this._tokens = [], this._start = 0, this._current = 0, this._line = 1, this._source = null != e2 ? e2 : "";
+  }
+  scanTokens() {
+    for (; !this._isAtEnd(); ) if (this._start = this._current, !this.scanToken()) throw `Invalid syntax at line ${this._line}`;
+    return this._tokens.push(new ze(He.eof, "", this._line, this._current, this._current)), this._tokens;
+  }
+  scanToken() {
+    let e2 = this._advance();
+    if ("\n" == e2) return this._line++, true;
+    if (this._isWhitespace(e2)) return true;
+    if ("/" == e2) {
+      if ("/" == this._peekAhead()) {
+        for (; "\n" != e2; ) {
+          if (this._isAtEnd()) return true;
+          e2 = this._advance();
+        }
+        return this._line++, true;
+      }
+      if ("*" == this._peekAhead()) {
+        this._advance();
+        let t3 = 1;
+        for (; t3 > 0; ) {
+          if (this._isAtEnd()) return true;
+          if (e2 = this._advance(), "\n" == e2) this._line++;
+          else if ("*" == e2) {
+            if ("/" == this._peekAhead() && (this._advance(), t3--, 0 == t3)) return true;
+          } else "/" == e2 && "*" == this._peekAhead() && (this._advance(), t3++);
+        }
+        return true;
+      }
+    }
+    const t2 = He.simpleTokens[e2];
+    if (t2) return this._addToken(t2), true;
+    let n2 = He.none;
+    const s2 = this._isAlpha(e2), r2 = "_" === e2;
+    if (this._isAlphaNumeric(e2)) {
+      let t3 = this._peekAhead();
+      for (; this._isAlphaNumeric(t3); ) e2 += this._advance(), t3 = this._peekAhead();
+    }
+    if (s2) {
+      const t3 = He.keywords[e2];
+      if (t3) return this._addToken(t3), true;
+    }
+    if (s2 || r2) return this._addToken(He.tokens.ident), true;
+    for (; ; ) {
+      let t3 = this._findType(e2);
+      const s3 = this._peekAhead();
+      if ("-" == e2 && this._tokens.length > 0) {
+        if ("=" == s3) return this._current++, e2 += s3, this._addToken(He.tokens.minus_equal), true;
+        if ("-" == s3) return this._current++, e2 += s3, this._addToken(He.tokens.minus_minus), true;
+        const n3 = this._tokens.length - 1;
+        if ((-1 != He.literal_or_ident.indexOf(this._tokens[n3].type) || this._tokens[n3].type == He.tokens.paren_right) && ">" != s3) return this._addToken(t3), true;
+      }
+      if (">" == e2 && (">" == s3 || "=" == s3)) {
+        let e3 = false, n3 = this._tokens.length - 1;
+        for (let t4 = 0; t4 < 5 && n3 >= 0 && -1 === He.assignment_operators.indexOf(this._tokens[n3].type); ++t4, --n3) if (this._tokens[n3].type === He.tokens.less_than) {
+          n3 > 0 && this._tokens[n3 - 1].isArrayOrTemplateType() && (e3 = true);
+          break;
+        }
+        if (e3) return this._addToken(t3), true;
+      }
+      if (t3 === He.none) {
+        let s4 = e2, r3 = 0;
+        const a2 = 2;
+        for (let e3 = 0; e3 < a2; ++e3) if (s4 += this._peekAhead(e3), t3 = this._findType(s4), t3 !== He.none) {
+          r3 = e3;
+          break;
+        }
+        if (t3 === He.none) return n2 !== He.none && (this._current--, this._addToken(n2), true);
+        e2 = s4, this._current += r3 + 1;
+      }
+      if (n2 = t3, this._isAtEnd()) break;
+      e2 += this._advance();
+    }
+    return n2 !== He.none && (this._addToken(n2), true);
+  }
+  _findType(e2) {
+    for (const t3 in He.regexTokens) {
+      const n2 = He.regexTokens[t3];
+      if (this._match(e2, n2.rule)) return n2;
+    }
+    const t2 = He.literalTokens[e2];
+    return t2 || He.none;
+  }
+  _match(e2, t2) {
+    const n2 = t2.exec(e2);
+    return n2 && 0 == n2.index && n2[0] == e2;
+  }
+  _isAtEnd() {
+    return this._current >= this._source.length;
+  }
+  _isAlpha(e2) {
+    return !this._isNumeric(e2) && !this._isWhitespace(e2) && "_" !== e2 && "." !== e2 && "(" !== e2 && ")" !== e2 && "[" !== e2 && "]" !== e2 && "{" !== e2 && "}" !== e2 && "," !== e2 && ";" !== e2 && ":" !== e2 && "=" !== e2 && "!" !== e2 && "<" !== e2 && ">" !== e2 && "+" !== e2 && "-" !== e2 && "*" !== e2 && "/" !== e2 && "%" !== e2 && "&" !== e2 && "|" !== e2 && "^" !== e2 && "~" !== e2 && "@" !== e2 && "#" !== e2 && "?" !== e2 && "'" !== e2 && "`" !== e2 && '"' !== e2 && "\\" !== e2 && "\n" !== e2 && "\r" !== e2 && "	" !== e2 && "\0" !== e2;
+  }
+  _isNumeric(e2) {
+    return e2 >= "0" && e2 <= "9";
+  }
+  _isAlphaNumeric(e2) {
+    return this._isAlpha(e2) || this._isNumeric(e2) || "_" === e2;
+  }
+  _isWhitespace(e2) {
+    return " " == e2 || "	" == e2 || "\r" == e2;
+  }
+  _advance(e2 = 0) {
+    let t2 = this._source[this._current];
+    return e2 = e2 || 0, e2++, this._current += e2, t2;
+  }
+  _peekAhead(e2 = 0) {
+    return e2 = e2 || 0, this._current + e2 >= this._source.length ? "\0" : this._source[this._current + e2];
+  }
+  _addToken(e2) {
+    const t2 = this._source.substring(this._start, this._current);
+    this._tokens.push(new ze(e2, t2, this._line, this._start, this._current));
+  }
+}
+function Ge(e2) {
+  return Array.isArray(e2) || (null == e2 ? void 0 : e2.buffer) instanceof ArrayBuffer;
+}
+const Xe = new Float32Array(1), je = new Uint32Array(Xe.buffer), Ze = new Uint32Array(Xe.buffer), Qe = new Int32Array(1), Ye = new Float32Array(Qe.buffer), Ke = new Uint32Array(Qe.buffer), Je = new Uint32Array(1), et = new Float32Array(Je.buffer), tt = new Int32Array(Je.buffer);
+function nt(e2, t2, n2) {
+  if (t2 === n2) return e2;
+  if ("f32" === t2) {
+    if ("i32" === n2 || "x32" === n2) return Xe[0] = e2, je[0];
+    if ("u32" === n2) return Xe[0] = e2, Ze[0];
+  } else if ("i32" === t2 || "x32" === t2) {
+    if ("f32" === n2) return Qe[0] = e2, Ye[0];
+    if ("u32" === n2) return Qe[0] = e2, Ke[0];
+  } else if ("u32" === t2) {
+    if ("f32" === n2) return Je[0] = e2, et[0];
+    if ("i32" === n2 || "x32" === n2) return Je[0] = e2, tt[0];
+  }
+  return console.error(`Unsupported cast from ${t2} to ${n2}`), e2;
+}
+class st {
+  constructor(e2) {
+    this.resources = null, this.inUse = false, this.info = null, this.node = e2;
+  }
+}
+class rt {
+  constructor(e2, t2) {
+    this.align = e2, this.size = t2;
+  }
+}
+class at {
+  constructor() {
+    this.uniforms = [], this.storage = [], this.textures = [], this.samplers = [], this.aliases = [], this.overrides = [], this.structs = [], this.entry = new d(), this.functions = [], this._types = /* @__PURE__ */ new Map(), this._functions = /* @__PURE__ */ new Map();
+  }
+  _isStorageTexture(e2) {
+    return "texture_storage_1d" == e2.name || "texture_storage_2d" == e2.name || "texture_storage_2d_array" == e2.name || "texture_storage_3d" == e2.name;
+  }
+  updateAST(e2) {
+    for (const t2 of e2) t2 instanceof D && this._functions.set(t2.name, new st(t2));
+    for (const t2 of e2) if (t2 instanceof oe) {
+      const e3 = this.getTypeInfo(t2, null);
+      e3 instanceof n && this.structs.push(e3);
+    }
+    for (const t2 of e2) if (t2 instanceof te) this.aliases.push(this._getAliasInfo(t2));
+    else {
+      if (t2 instanceof M) {
+        const e3 = t2, n2 = this._getAttributeNum(e3.attributes, "id", 0), s2 = null != e3.type ? this.getTypeInfo(e3.type, e3.attributes) : null;
+        this.overrides.push(new h(e3.name, s2, e3.attributes, n2));
+        continue;
+      }
+      if (this._isUniformVar(t2)) {
+        const e3 = t2, n2 = this._getAttributeNum(e3.attributes, "group", 0), s2 = this._getAttributeNum(e3.attributes, "binding", 0), r2 = this.getTypeInfo(e3.type, e3.attributes), a2 = new o(e3.name, r2, n2, s2, e3.attributes, i.Uniform, e3.access);
+        a2.access || (a2.access = "read"), this.uniforms.push(a2);
+        continue;
+      }
+      if (this._isStorageVar(t2)) {
+        const e3 = t2, n2 = this._getAttributeNum(e3.attributes, "group", 0), s2 = this._getAttributeNum(e3.attributes, "binding", 0), r2 = this.getTypeInfo(e3.type, e3.attributes), a2 = this._isStorageTexture(r2), c2 = new o(e3.name, r2, n2, s2, e3.attributes, a2 ? i.StorageTexture : i.Storage, e3.access);
+        c2.access || (c2.access = "read"), this.storage.push(c2);
+        continue;
+      }
+      if (this._isTextureVar(t2)) {
+        const e3 = t2, n2 = this._getAttributeNum(e3.attributes, "group", 0), s2 = this._getAttributeNum(e3.attributes, "binding", 0), r2 = this.getTypeInfo(e3.type, e3.attributes), a2 = this._isStorageTexture(r2), c2 = new o(e3.name, r2, n2, s2, e3.attributes, a2 ? i.StorageTexture : i.Texture, e3.access);
+        c2.access || (c2.access = "read"), a2 ? this.storage.push(c2) : this.textures.push(c2);
+        continue;
+      }
+      if (this._isSamplerVar(t2)) {
+        const e3 = t2, n2 = this._getAttributeNum(e3.attributes, "group", 0), s2 = this._getAttributeNum(e3.attributes, "binding", 0), r2 = this.getTypeInfo(e3.type, e3.attributes), a2 = new o(e3.name, r2, n2, s2, e3.attributes, i.Sampler, e3.access);
+        this.samplers.push(a2);
+        continue;
+      }
+    }
+    for (const t2 of e2) if (t2 instanceof D) {
+      const e3 = this._getAttribute(t2, "vertex"), n2 = this._getAttribute(t2, "fragment"), s2 = this._getAttribute(t2, "compute"), r2 = e3 || n2 || s2, a2 = new p(t2.name, null == r2 ? void 0 : r2.name, t2.attributes);
+      a2.attributes = t2.attributes, a2.startLine = t2.startLine, a2.endLine = t2.endLine, this.functions.push(a2), this._functions.get(t2.name).info = a2, r2 && (this._functions.get(t2.name).inUse = true, a2.inUse = true, a2.resources = this._findResources(t2, !!r2), a2.inputs = this._getInputs(t2.args), a2.outputs = this._getOutputs(t2.returnType), this.entry[r2.name].push(a2)), a2.arguments = t2.args.map((e4) => new f(e4.name, this.getTypeInfo(e4.type, e4.attributes), e4.attributes)), a2.returnType = t2.returnType ? this.getTypeInfo(t2.returnType, t2.attributes) : null;
+      continue;
+    }
+    for (const e3 of this._functions.values()) e3.info && (e3.info.inUse = e3.inUse, this._addCalls(e3.node, e3.info.calls));
+    for (const e3 of this._functions.values()) e3.node.search((t2) => {
+      var n2, s2, r2;
+      if (t2 instanceof De) {
+        if (t2.value) if (Ge(t2.value)) for (const s3 of t2.value) for (const t3 of this.overrides) s3 === t3.name && (null === (n2 = e3.info) || void 0 === n2 || n2.overrides.push(t3));
+        else for (const n3 of this.overrides) t2.value === n3.name && (null === (s2 = e3.info) || void 0 === s2 || s2.overrides.push(n3));
+      } else if (t2 instanceof ge) for (const n3 of this.overrides) t2.name === n3.name && (null === (r2 = e3.info) || void 0 === r2 || r2.overrides.push(n3));
+    });
+    for (const e3 of this.uniforms) this._markStructsInUse(e3.type);
+    for (const e3 of this.storage) this._markStructsInUse(e3.type);
+  }
+  getFunctionInfo(e2) {
+    for (const t2 of this.functions) if (t2.name == e2) return t2;
+    return null;
+  }
+  getStructInfo(e2) {
+    for (const t2 of this.structs) if (t2.name == e2) return t2;
+    return null;
+  }
+  getOverrideInfo(e2) {
+    for (const t2 of this.overrides) if (t2.name == e2) return t2;
+    return null;
+  }
+  _markStructsInUse(e2) {
+    if (e2) if (e2.isStruct) {
+      if (e2.inUse = true, e2.members) for (const t2 of e2.members) this._markStructsInUse(t2.type);
+    } else if (e2.isArray) this._markStructsInUse(e2.format);
+    else if (e2.isTemplate) e2.format && this._markStructsInUse(e2.format);
+    else {
+      const t2 = this._getAlias(e2.name);
+      t2 && this._markStructsInUse(t2);
+    }
+  }
+  _addCalls(e2, t2) {
+    var n2;
+    for (const s2 of e2.calls) {
+      const e3 = null === (n2 = this._functions.get(s2.name)) || void 0 === n2 ? void 0 : n2.info;
+      e3 && t2.add(e3);
+    }
+  }
+  findResource(e2, t2, n2) {
+    if (n2) {
+      for (const s2 of this.entry.compute) if (s2.name === n2) {
+        for (const n3 of s2.resources) if (n3.group == e2 && n3.binding == t2) return n3;
+      }
+      for (const s2 of this.entry.vertex) if (s2.name === n2) {
+        for (const n3 of s2.resources) if (n3.group == e2 && n3.binding == t2) return n3;
+      }
+      for (const s2 of this.entry.fragment) if (s2.name === n2) {
+        for (const n3 of s2.resources) if (n3.group == e2 && n3.binding == t2) return n3;
+      }
+    }
+    for (const n3 of this.uniforms) if (n3.group == e2 && n3.binding == t2) return n3;
+    for (const n3 of this.storage) if (n3.group == e2 && n3.binding == t2) return n3;
+    for (const n3 of this.textures) if (n3.group == e2 && n3.binding == t2) return n3;
+    for (const n3 of this.samplers) if (n3.group == e2 && n3.binding == t2) return n3;
+    return null;
+  }
+  _findResource(e2) {
+    for (const t2 of this.uniforms) if (t2.name == e2) return t2;
+    for (const t2 of this.storage) if (t2.name == e2) return t2;
+    for (const t2 of this.textures) if (t2.name == e2) return t2;
+    for (const t2 of this.samplers) if (t2.name == e2) return t2;
+    return null;
+  }
+  _markStructsFromAST(e2) {
+    const t2 = this.getTypeInfo(e2, null);
+    this._markStructsInUse(t2);
+  }
+  _findResources(e2, t2) {
+    const n2 = [], s2 = this, r2 = [];
+    return e2.search((a2) => {
+      if (a2 instanceof E) r2.push({});
+      else if (a2 instanceof $) r2.pop();
+      else if (a2 instanceof F) {
+        const e3 = a2;
+        t2 && null !== e3.type && this._markStructsFromAST(e3.type), r2.length > 0 && (r2[r2.length - 1][e3.name] = e3);
+      } else if (a2 instanceof de) {
+        const e3 = a2;
+        t2 && null !== e3.type && this._markStructsFromAST(e3.type);
+      } else if (a2 instanceof U) {
+        const e3 = a2;
+        t2 && null !== e3.type && this._markStructsFromAST(e3.type), r2.length > 0 && (r2[r2.length - 1][e3.name] = e3);
+      } else if (a2 instanceof ge) {
+        const e3 = a2;
+        if (r2.length > 0) {
+          if (r2[r2.length - 1][e3.name]) return;
+        }
+        const t3 = s2._findResource(e3.name);
+        t3 && n2.push(t3);
+      } else if (a2 instanceof me) {
+        const r3 = a2, i2 = s2._functions.get(r3.name);
+        i2 && (t2 && (i2.inUse = true), e2.calls.add(i2.node), null === i2.resources && (i2.resources = s2._findResources(i2.node, t2)), n2.push(...i2.resources));
+      } else if (a2 instanceof X) {
+        const r3 = a2, i2 = s2._functions.get(r3.name);
+        i2 && (t2 && (i2.inUse = true), e2.calls.add(i2.node), null === i2.resources && (i2.resources = s2._findResources(i2.node, t2)), n2.push(...i2.resources));
+      }
+    }), [...new Map(n2.map((e3) => [e3.name, e3])).values()];
+  }
+  getBindGroups() {
+    const e2 = [];
+    function t2(t3, n2) {
+      t3 >= e2.length && (e2.length = t3 + 1), void 0 === e2[t3] && (e2[t3] = []), n2 >= e2[t3].length && (e2[t3].length = n2 + 1);
+    }
+    for (const n2 of this.uniforms) {
+      t2(n2.group, n2.binding);
+      e2[n2.group][n2.binding] = n2;
+    }
+    for (const n2 of this.storage) {
+      t2(n2.group, n2.binding);
+      e2[n2.group][n2.binding] = n2;
+    }
+    for (const n2 of this.textures) {
+      t2(n2.group, n2.binding);
+      e2[n2.group][n2.binding] = n2;
+    }
+    for (const n2 of this.samplers) {
+      t2(n2.group, n2.binding);
+      e2[n2.group][n2.binding] = n2;
+    }
+    return e2;
+  }
+  _getOutputs(e2, t2 = void 0) {
+    if (void 0 === t2 && (t2 = []), e2 instanceof oe) this._getStructOutputs(e2, t2);
+    else {
+      const n2 = this._getOutputInfo(e2);
+      null !== n2 && t2.push(n2);
+    }
+    return t2;
+  }
+  _getStructOutputs(e2, t2) {
+    for (const n2 of e2.members) if (n2.type instanceof oe) this._getStructOutputs(n2.type, t2);
+    else {
+      const e3 = this._getAttribute(n2, "location") || this._getAttribute(n2, "builtin");
+      if (null !== e3) {
+        const s2 = this.getTypeInfo(n2.type, n2.type.attributes), r2 = this._parseInt(e3.value), a2 = new u(n2.name, s2, e3.name, r2);
+        t2.push(a2);
+      }
+    }
+  }
+  _getOutputInfo(e2) {
+    const t2 = this._getAttribute(e2, "location") || this._getAttribute(e2, "builtin");
+    if (null !== t2) {
+      const n2 = this.getTypeInfo(e2, e2.attributes), s2 = this._parseInt(t2.value);
+      return new u("", n2, t2.name, s2);
+    }
+    return null;
+  }
+  _getInputs(e2, t2 = void 0) {
+    void 0 === t2 && (t2 = []);
+    for (const n2 of e2) if (n2.type instanceof oe) this._getStructInputs(n2.type, t2);
+    else {
+      const e3 = this._getInputInfo(n2);
+      null !== e3 && t2.push(e3);
+    }
+    return t2;
+  }
+  _getStructInputs(e2, t2) {
+    for (const n2 of e2.members) if (n2.type instanceof oe) this._getStructInputs(n2.type, t2);
+    else {
+      const e3 = this._getInputInfo(n2);
+      null !== e3 && t2.push(e3);
+    }
+  }
+  _getInputInfo(e2) {
+    const t2 = this._getAttribute(e2, "location") || this._getAttribute(e2, "builtin");
+    if (null !== t2) {
+      const n2 = this._getAttribute(e2, "interpolation"), s2 = this.getTypeInfo(e2.type, e2.attributes), r2 = this._parseInt(t2.value), a2 = new l(e2.name, s2, t2.name, r2);
+      return null !== n2 && (a2.interpolation = this._parseString(n2.value)), a2;
+    }
+    return null;
+  }
+  _parseString(e2) {
+    return e2 instanceof Array && (e2 = e2[0]), e2;
+  }
+  _parseInt(e2) {
+    e2 instanceof Array && (e2 = e2[0]);
+    const t2 = parseInt(e2);
+    return isNaN(t2) ? e2 : t2;
+  }
+  _getAlias(e2) {
+    for (const t2 of this.aliases) if (t2.name == e2) return t2.type;
+    return null;
+  }
+  _getAliasInfo(e2) {
+    return new c(e2.name, this.getTypeInfo(e2.type, null));
+  }
+  getTypeInfoByName(e2) {
+    for (const t2 of this.structs) if (t2.name == e2) return t2;
+    for (const t2 of this.aliases) if (t2.name == e2) return t2.type;
+    return null;
+  }
+  getTypeInfo(i2, o2 = null) {
+    if (this._types.has(i2)) return this._types.get(i2);
+    if (i2 instanceof le) {
+      const e2 = i2.type ? this.getTypeInfo(i2.type, i2.attributes) : null, t2 = new r(i2.name, e2, o2);
+      return this._types.set(i2, t2), this._updateTypeInfo(t2), t2;
+    }
+    if (i2 instanceof ue) {
+      const e2 = i2, t2 = e2.format ? this.getTypeInfo(e2.format, e2.attributes) : null, n2 = new s(e2.name, o2);
+      return n2.format = t2, n2.count = e2.count, this._types.set(i2, n2), this._updateTypeInfo(n2), n2;
+    }
+    if (i2 instanceof oe) {
+      const e2 = i2, s2 = new n(e2.name, o2);
+      s2.startLine = e2.startLine, s2.endLine = e2.endLine;
+      for (const n2 of e2.members) {
+        const e3 = this.getTypeInfo(n2.type, n2.attributes);
+        s2.members.push(new t(n2.name, e3, n2.attributes));
+      }
+      return this._types.set(i2, s2), this._updateTypeInfo(s2), s2;
+    }
+    if (i2 instanceof he) {
+      const t2 = i2, n2 = t2.format instanceof ae, s2 = t2.format ? n2 ? this.getTypeInfo(t2.format, null) : new e(t2.format, null) : null, r2 = new a(t2.name, s2, o2, t2.access);
+      return this._types.set(i2, r2), this._updateTypeInfo(r2), r2;
+    }
+    if (i2 instanceof ce) {
+      const e2 = i2, t2 = e2.format ? this.getTypeInfo(e2.format, null) : null, n2 = new a(e2.name, t2, o2, e2.access);
+      return this._types.set(i2, n2), this._updateTypeInfo(n2), n2;
+    }
+    const c2 = new e(i2.name, o2);
+    return this._types.set(i2, c2), this._updateTypeInfo(c2), c2;
+  }
+  _updateTypeInfo(e2) {
+    var t2, a2, i2;
+    const o2 = this._getTypeSize(e2);
+    if (e2.size = null !== (t2 = null == o2 ? void 0 : o2.size) && void 0 !== t2 ? t2 : 0, e2 instanceof s && e2.format) {
+      const t3 = this._getTypeSize(e2.format);
+      e2.stride = Math.max(null !== (a2 = null == t3 ? void 0 : t3.size) && void 0 !== a2 ? a2 : 0, null !== (i2 = null == t3 ? void 0 : t3.align) && void 0 !== i2 ? i2 : 0), this._updateTypeInfo(e2.format);
+    }
+    e2 instanceof r && this._updateTypeInfo(e2.format), e2 instanceof n && this._updateStructInfo(e2);
+  }
+  _updateStructInfo(e2) {
+    var t2;
+    let n2 = 0, s2 = 0, r2 = 0, a2 = 0;
+    for (let i2 = 0, o2 = e2.members.length; i2 < o2; ++i2) {
+      const o3 = e2.members[i2], c2 = this._getTypeSize(o3);
+      if (!c2) continue;
+      null !== (t2 = this._getAlias(o3.type.name)) && void 0 !== t2 || o3.type;
+      const l2 = c2.align, u2 = c2.size;
+      n2 = this._roundUp(l2, n2 + s2), s2 = u2, r2 = n2, a2 = Math.max(a2, l2), o3.offset = n2, o3.size = u2, this._updateTypeInfo(o3.type);
+    }
+    e2.size = this._roundUp(a2, r2 + s2), e2.align = a2;
+  }
+  _getTypeSize(r2) {
+    var a2, i2;
+    if (null == r2) return null;
+    const o2 = this._getAttributeNum(r2.attributes, "size", 0), c2 = this._getAttributeNum(r2.attributes, "align", 0);
+    if (r2 instanceof t && (r2 = r2.type), r2 instanceof e) {
+      const e2 = this._getAlias(r2.name);
+      null !== e2 && (r2 = e2);
+    }
+    {
+      const e2 = at._typeInfo[r2.name];
+      if (void 0 !== e2) {
+        const t2 = "f16" === (null === (a2 = r2.format) || void 0 === a2 ? void 0 : a2.name) ? 2 : 1;
+        return new rt(Math.max(c2, e2.align / t2), Math.max(o2, e2.size / t2));
+      }
+    }
+    {
+      const e2 = at._typeInfo[r2.name.substring(0, r2.name.length - 1)];
+      if (e2) {
+        const t2 = "h" === r2.name[r2.name.length - 1] ? 2 : 1;
+        return new rt(Math.max(c2, e2.align / t2), Math.max(o2, e2.size / t2));
+      }
+    }
+    if (r2 instanceof s) {
+      let e2 = r2, t2 = 8, n2 = 8;
+      const s2 = this._getTypeSize(e2.format);
+      null !== s2 && (n2 = s2.size, t2 = s2.align);
+      return n2 = e2.count * this._getAttributeNum(null !== (i2 = null == r2 ? void 0 : r2.attributes) && void 0 !== i2 ? i2 : null, "stride", this._roundUp(t2, n2)), o2 && (n2 = o2), new rt(Math.max(c2, t2), Math.max(o2, n2));
+    }
+    if (r2 instanceof n) {
+      let e2 = 0, t2 = 0, n2 = 0, s2 = 0, a3 = 0;
+      for (const t3 of r2.members) {
+        const r3 = this._getTypeSize(t3.type);
+        null !== r3 && (e2 = Math.max(r3.align, e2), n2 = this._roundUp(r3.align, n2 + s2), s2 = r3.size, a3 = n2);
+      }
+      return t2 = this._roundUp(e2, a3 + s2), new rt(Math.max(c2, e2), Math.max(o2, t2));
+    }
+    return null;
+  }
+  _isUniformVar(e2) {
+    return e2 instanceof F && "uniform" == e2.storage;
+  }
+  _isStorageVar(e2) {
+    return e2 instanceof F && "storage" == e2.storage;
+  }
+  _isTextureVar(e2) {
+    return e2 instanceof F && null !== e2.type && -1 != at._textureTypes.indexOf(e2.type.name);
+  }
+  _isSamplerVar(e2) {
+    return e2 instanceof F && null !== e2.type && -1 != at._samplerTypes.indexOf(e2.type.name);
+  }
+  _getAttribute(e2, t2) {
+    const n2 = e2;
+    if (!n2 || !n2.attributes) return null;
+    const s2 = n2.attributes;
+    for (let e3 of s2) if (e3.name == t2) return e3;
+    return null;
+  }
+  _getAttributeNum(e2, t2, n2) {
+    if (null === e2) return n2;
+    for (let s2 of e2) if (s2.name == t2) {
+      let e3 = null !== s2 && null !== s2.value ? s2.value : n2;
+      return e3 instanceof Array && (e3 = e3[0]), "number" == typeof e3 ? e3 : "string" == typeof e3 ? parseInt(e3) : n2;
+    }
+    return n2;
+  }
+  _roundUp(e2, t2) {
+    return Math.ceil(t2 / e2) * e2;
+  }
+}
+at._typeInfo = { f16: { align: 2, size: 2 }, i32: { align: 4, size: 4 }, u32: { align: 4, size: 4 }, f32: { align: 4, size: 4 }, atomic: { align: 4, size: 4 }, vec2: { align: 8, size: 8 }, vec3: { align: 16, size: 12 }, vec4: { align: 16, size: 16 }, mat2x2: { align: 8, size: 16 }, mat3x2: { align: 8, size: 24 }, mat4x2: { align: 8, size: 32 }, mat2x3: { align: 16, size: 32 }, mat3x3: { align: 16, size: 48 }, mat4x3: { align: 16, size: 64 }, mat2x4: { align: 16, size: 32 }, mat3x4: { align: 16, size: 48 }, mat4x4: { align: 16, size: 64 } }, at._textureTypes = He.any_texture_type.map((e2) => e2.name), at._samplerTypes = He.sampler_type.map((e2) => e2.name);
+let it = 0;
+class ot {
+  constructor(e2, t2, n2) {
+    this.id = it++, this.name = e2, this.value = t2, this.node = n2;
+  }
+  clone() {
+    return new ot(this.name, this.value, this.node);
+  }
+}
+class ct {
+  constructor(e2) {
+    this.id = it++, this.name = e2.name, this.node = e2;
+  }
+  clone() {
+    return new ct(this.node);
+  }
+}
+class lt {
+  constructor(e2) {
+    this.parent = null, this.variables = /* @__PURE__ */ new Map(), this.functions = /* @__PURE__ */ new Map(), this.currentFunctionName = "", this.id = it++, e2 && (this.parent = e2, this.currentFunctionName = e2.currentFunctionName);
+  }
+  getVariable(e2) {
+    var t2;
+    return this.variables.has(e2) ? null !== (t2 = this.variables.get(e2)) && void 0 !== t2 ? t2 : null : this.parent ? this.parent.getVariable(e2) : null;
+  }
+  getFunction(e2) {
+    var t2;
+    return this.functions.has(e2) ? null !== (t2 = this.functions.get(e2)) && void 0 !== t2 ? t2 : null : this.parent ? this.parent.getFunction(e2) : null;
+  }
+  createVariable(e2, t2, n2) {
+    this.variables.set(e2, new ot(e2, t2, null != n2 ? n2 : null));
+  }
+  setVariable(e2, t2, n2) {
+    const s2 = this.getVariable(e2);
+    null !== s2 ? s2.value = t2 : this.createVariable(e2, t2, n2);
+  }
+  getVariableValue(e2) {
+    var t2;
+    const n2 = this.getVariable(e2);
+    return null !== (t2 = null == n2 ? void 0 : n2.value) && void 0 !== t2 ? t2 : null;
+  }
+  clone() {
+    return new lt(this);
+  }
+}
+class ut {
+  evalExpression(e2, t2) {
+    return null;
+  }
+  getTypeInfo(e2) {
+    return null;
+  }
+  getVariableName(e2, t2) {
+    return "";
+  }
+}
+class ht {
+  constructor(e2) {
+    this.exec = e2;
+  }
+  getTypeInfo(e2) {
+    return this.exec.getTypeInfo(e2);
+  }
+  All(e2, t2) {
+    const n2 = this.exec.evalExpression(e2.args[0], t2);
+    let s2 = true;
+    if (n2 instanceof Me) return n2.data.forEach((e3) => {
+      e3 || (s2 = false);
+    }), new Be(s2 ? 1 : 0, this.getTypeInfo("bool"));
+    throw new Error(`All() expects a vector argument. Line ${e2.line}`);
+  }
+  Any(e2, t2) {
+    const n2 = this.exec.evalExpression(e2.args[0], t2);
+    if (n2 instanceof Me) {
+      const e3 = n2.data.some((e4) => e4);
+      return new Be(e3 ? 1 : 0, this.getTypeInfo("bool"));
+    }
+    throw new Error(`Any() expects a vector argument. Line ${e2.line}`);
+  }
+  Select(e2, t2) {
+    const n2 = this.exec.evalExpression(e2.args[2], t2);
+    if (!(n2 instanceof Be)) throw new Error(`Select() expects a bool condition. Line ${e2.line}`);
+    return n2.value ? this.exec.evalExpression(e2.args[1], t2) : this.exec.evalExpression(e2.args[0], t2);
+  }
+  ArrayLength(e2, t2) {
+    let n2 = e2.args[0];
+    n2 instanceof ke && (n2 = n2.right);
+    const s2 = this.exec.evalExpression(n2, t2);
+    if (s2 instanceof Pe && 0 === s2.typeInfo.size) {
+      const e3 = s2.typeInfo, t3 = s2.buffer.byteLength / e3.stride;
+      return new Be(t3, this.getTypeInfo("u32"));
+    }
+    return new Be(s2.typeInfo.size, this.getTypeInfo("u32"));
+  }
+  Abs(e2, t2) {
+    const n2 = this.exec.evalExpression(e2.args[0], t2);
+    if (n2 instanceof Me) return new Me(n2.data.map((e3) => Math.abs(e3)), n2.typeInfo);
+    const s2 = n2;
+    return new Be(Math.abs(s2.value), s2.typeInfo);
+  }
+  Acos(e2, t2) {
+    const n2 = this.exec.evalExpression(e2.args[0], t2);
+    if (n2 instanceof Me) return new Me(n2.data.map((e3) => Math.acos(e3)), n2.typeInfo);
+    const s2 = n2;
+    return new Be(Math.acos(s2.value), n2.typeInfo);
+  }
+  Acosh(e2, t2) {
+    const n2 = this.exec.evalExpression(e2.args[0], t2);
+    if (n2 instanceof Me) return new Me(n2.data.map((e3) => Math.acosh(e3)), n2.typeInfo);
+    const s2 = n2;
+    return new Be(Math.acosh(s2.value), n2.typeInfo);
+  }
+  Asin(e2, t2) {
+    const n2 = this.exec.evalExpression(e2.args[0], t2);
+    if (n2 instanceof Me) return new Me(n2.data.map((e3) => Math.asin(e3)), n2.typeInfo);
+    const s2 = n2;
+    return new Be(Math.asin(s2.value), n2.typeInfo);
+  }
+  Asinh(e2, t2) {
+    const n2 = this.exec.evalExpression(e2.args[0], t2);
+    if (n2 instanceof Me) return new Me(n2.data.map((e3) => Math.asinh(e3)), n2.typeInfo);
+    const s2 = n2;
+    return new Be(Math.asinh(s2.value), n2.typeInfo);
+  }
+  Atan(e2, t2) {
+    const n2 = this.exec.evalExpression(e2.args[0], t2);
+    if (n2 instanceof Me) return new Me(n2.data.map((e3) => Math.atan(e3)), n2.typeInfo);
+    const s2 = n2;
+    return new Be(Math.atan(s2.value), n2.typeInfo);
+  }
+  Atanh(e2, t2) {
+    const n2 = this.exec.evalExpression(e2.args[0], t2);
+    if (n2 instanceof Me) return new Me(n2.data.map((e3) => Math.atanh(e3)), n2.typeInfo);
+    const s2 = n2;
+    return new Be(Math.atanh(s2.value), n2.typeInfo);
+  }
+  Atan2(e2, t2) {
+    const n2 = this.exec.evalExpression(e2.args[0], t2), s2 = this.exec.evalExpression(e2.args[1], t2);
+    if (n2 instanceof Me && s2 instanceof Me) return new Me(n2.data.map((e3, t3) => Math.atan2(e3, s2.data[t3])), n2.typeInfo);
+    const r2 = n2, a2 = s2;
+    return new Be(Math.atan2(r2.value, a2.value), n2.typeInfo);
+  }
+  Ceil(e2, t2) {
+    const n2 = this.exec.evalExpression(e2.args[0], t2);
+    if (n2 instanceof Me) return new Me(n2.data.map((e3) => Math.ceil(e3)), n2.typeInfo);
+    const s2 = n2;
+    return new Be(Math.ceil(s2.value), n2.typeInfo);
+  }
+  _clamp(e2, t2, n2) {
+    return Math.min(Math.max(e2, t2), n2);
+  }
+  Clamp(e2, t2) {
+    const n2 = this.exec.evalExpression(e2.args[0], t2), s2 = this.exec.evalExpression(e2.args[1], t2), r2 = this.exec.evalExpression(e2.args[2], t2);
+    if (n2 instanceof Me && s2 instanceof Me && r2 instanceof Me) return new Me(n2.data.map((e3, t3) => this._clamp(e3, s2.data[t3], r2.data[t3])), n2.typeInfo);
+    const a2 = n2, i2 = s2, o2 = r2;
+    return new Be(this._clamp(a2.value, i2.value, o2.value), n2.typeInfo);
+  }
+  Cos(e2, t2) {
+    const n2 = this.exec.evalExpression(e2.args[0], t2);
+    if (n2 instanceof Me) return new Me(n2.data.map((e3) => Math.cos(e3)), n2.typeInfo);
+    const s2 = n2;
+    return new Be(Math.cos(s2.value), n2.typeInfo);
+  }
+  Cosh(e2, t2) {
+    const n2 = this.exec.evalExpression(e2.args[0], t2);
+    if (n2 instanceof Me) return new Me(n2.data.map((e3) => Math.cosh(e3)), n2.typeInfo);
+    const s2 = n2;
+    return new Be(Math.cos(s2.value), n2.typeInfo);
+  }
+  CountLeadingZeros(e2, t2) {
+    const n2 = this.exec.evalExpression(e2.args[0], t2);
+    if (n2 instanceof Me) return new Me(n2.data.map((e3) => Math.clz32(e3)), n2.typeInfo);
+    const s2 = n2;
+    return new Be(Math.clz32(s2.value), n2.typeInfo);
+  }
+  _countOneBits(e2) {
+    let t2 = 0;
+    for (; 0 !== e2; ) 1 & e2 && t2++, e2 >>= 1;
+    return t2;
+  }
+  CountOneBits(e2, t2) {
+    const n2 = this.exec.evalExpression(e2.args[0], t2);
+    if (n2 instanceof Me) return new Me(n2.data.map((e3) => this._countOneBits(e3)), n2.typeInfo);
+    const s2 = n2;
+    return new Be(this._countOneBits(s2.value), n2.typeInfo);
+  }
+  _countTrailingZeros(e2) {
+    if (0 === e2) return 32;
+    let t2 = 0;
+    for (; !(1 & e2); ) e2 >>= 1, t2++;
+    return t2;
+  }
+  CountTrailingZeros(e2, t2) {
+    const n2 = this.exec.evalExpression(e2.args[0], t2);
+    if (n2 instanceof Me) return new Me(n2.data.map((e3) => this._countTrailingZeros(e3)), n2.typeInfo);
+    const s2 = n2;
+    return new Be(this._countTrailingZeros(s2.value), n2.typeInfo);
+  }
+  Cross(e2, t2) {
+    const n2 = this.exec.evalExpression(e2.args[0], t2), s2 = this.exec.evalExpression(e2.args[1], t2);
+    if (n2 instanceof Me && s2 instanceof Me) {
+      if (3 !== n2.data.length || 3 !== s2.data.length) return console.error(`Cross() expects 3D vectors. Line ${e2.line}`), null;
+      const t3 = n2.data, r2 = s2.data;
+      return new Me([t3[1] * r2[2] - r2[1] * t3[2], t3[2] * r2[0] - r2[2] * t3[0], t3[0] * r2[1] - r2[0] * t3[1]], n2.typeInfo);
+    }
+    return console.error(`Cross() expects vector arguments. Line ${e2.line}`), null;
+  }
+  Degrees(e2, t2) {
+    const n2 = this.exec.evalExpression(e2.args[0], t2), s2 = 180 / Math.PI;
+    if (n2 instanceof Me) return new Me(n2.data.map((e3) => e3 * s2), n2.typeInfo);
+    return new Be(n2.value * s2, this.getTypeInfo("f32"));
+  }
+  Determinant(e2, t2) {
+    const n2 = this.exec.evalExpression(e2.args[0], t2);
+    if (n2 instanceof Ue) {
+      const e3 = n2.data, t3 = n2.typeInfo.getTypeName(), s2 = t3.endsWith("h") ? this.getTypeInfo("f16") : this.getTypeInfo("f32");
+      if ("mat2x2" === t3 || "mat2x2f" === t3 || "mat2x2h" === t3) return new Be(e3[0] * e3[3] - e3[1] * e3[2], s2);
+      if ("mat2x3" === t3 || "mat2x3f" === t3 || "mat2x3h" === t3) return new Be(e3[0] * (e3[4] * e3[8] - e3[5] * e3[7]) - e3[1] * (e3[3] * e3[8] - e3[5] * e3[6]) + e3[2] * (e3[3] * e3[7] - e3[4] * e3[6]), s2);
+      if ("mat2x4" === t3 || "mat2x4f" === t3 || "mat2x4h" === t3) console.error(`TODO: Determinant for ${t3}`);
+      else if ("mat3x2" === t3 || "mat3x2f" === t3 || "mat3x2h" === t3) console.error(`TODO: Determinant for ${t3}`);
+      else {
+        if ("mat3x3" === t3 || "mat3x3f" === t3 || "mat3x3h" === t3) return new Be(e3[0] * (e3[4] * e3[8] - e3[5] * e3[7]) - e3[1] * (e3[3] * e3[8] - e3[5] * e3[6]) + e3[2] * (e3[3] * e3[7] - e3[4] * e3[6]), s2);
+        "mat3x4" === t3 || "mat3x4f" === t3 || "mat3x4h" === t3 || "mat4x2" === t3 || "mat4x2f" === t3 || "mat4x2h" === t3 || "mat4x3" === t3 || "mat4x3f" === t3 || "mat4x3h" === t3 ? console.error(`TODO: Determinant for ${t3}`) : "mat4x4" !== t3 && "mat4x4f" !== t3 && "mat4x4h" !== t3 || console.error(`TODO: Determinant for ${t3}`);
+      }
+    }
+    return console.error(`Determinant expects a matrix argument. Line ${e2.line}`), null;
+  }
+  Distance(e2, t2) {
+    const n2 = this.exec.evalExpression(e2.args[0], t2), s2 = this.exec.evalExpression(e2.args[1], t2);
+    if (n2 instanceof Me && s2 instanceof Me) {
+      let e3 = 0;
+      for (let t3 = 0; t3 < n2.data.length; ++t3) e3 += (n2.data[t3] - s2.data[t3]) * (n2.data[t3] - s2.data[t3]);
+      return new Be(Math.sqrt(e3), this.getTypeInfo("f32"));
+    }
+    const r2 = n2, a2 = s2;
+    return new Be(Math.abs(r2.value - a2.value), n2.typeInfo);
+  }
+  _dot(e2, t2) {
+    let n2 = 0;
+    for (let s2 = 0; s2 < e2.length; ++s2) n2 += t2[s2] * e2[s2];
+    return n2;
+  }
+  Dot(e2, t2) {
+    const n2 = this.exec.evalExpression(e2.args[0], t2), s2 = this.exec.evalExpression(e2.args[1], t2);
+    return n2 instanceof Me && s2 instanceof Me ? new Be(this._dot(n2.data, s2.data), this.getTypeInfo("f32")) : (console.error(`Dot() expects vector arguments. Line ${e2.line}`), null);
+  }
+  Dot4U8Packed(e2, t2) {
+    return console.error(`TODO: dot4U8Packed. Line ${e2.line}`), null;
+  }
+  Dot4I8Packed(e2, t2) {
+    return console.error(`TODO: dot4I8Packed. Line ${e2.line}`), null;
+  }
+  Exp(e2, t2) {
+    const n2 = this.exec.evalExpression(e2.args[0], t2);
+    if (n2 instanceof Me) return new Me(n2.data.map((e3) => Math.exp(e3)), n2.typeInfo);
+    const s2 = n2;
+    return new Be(Math.exp(s2.value), n2.typeInfo);
+  }
+  Exp2(e2, t2) {
+    const n2 = this.exec.evalExpression(e2.args[0], t2);
+    if (n2 instanceof Me) return new Me(n2.data.map((e3) => Math.pow(2, e3)), n2.typeInfo);
+    const s2 = n2;
+    return new Be(Math.pow(2, s2.value), n2.typeInfo);
+  }
+  ExtractBits(e2, t2) {
+    const n2 = this.exec.evalExpression(e2.args[0], t2), s2 = this.exec.evalExpression(e2.args[1], t2), r2 = this.exec.evalExpression(e2.args[2], t2);
+    if ("u32" !== s2.typeInfo.name && "x32" !== s2.typeInfo.name) return console.error(`ExtractBits() expects an i32 offset argument. Line ${e2.line}`), null;
+    if ("u32" !== r2.typeInfo.name && "x32" !== r2.typeInfo.name) return console.error(`ExtractBits() expects an i32 count argument. Line ${e2.line}`), null;
+    const a2 = s2.value, i2 = r2.value;
+    if (n2 instanceof Me) return new Me(n2.data.map((e3) => e3 >> a2 & (1 << i2) - 1), n2.typeInfo);
+    if ("i32" !== n2.typeInfo.name && "x32" !== n2.typeInfo.name) return console.error(`ExtractBits() expects an i32 argument. Line ${e2.line}`), null;
+    const o2 = n2.value;
+    return new Be(o2 >> a2 & (1 << i2) - 1, this.getTypeInfo("i32"));
+  }
+  FaceForward(e2, t2) {
+    const n2 = this.exec.evalExpression(e2.args[0], t2), s2 = this.exec.evalExpression(e2.args[1], t2), r2 = this.exec.evalExpression(e2.args[2], t2);
+    if (n2 instanceof Me && s2 instanceof Me && r2 instanceof Me) {
+      const e3 = this._dot(s2.data, r2.data);
+      return new Me(e3 < 0 ? Array.from(n2.data) : n2.data.map((e4) => -e4), n2.typeInfo);
+    }
+    return console.error(`FaceForward() expects vector arguments. Line ${e2.line}`), null;
+  }
+  _firstLeadingBit(e2) {
+    return 0 === e2 ? -1 : 31 - Math.clz32(e2);
+  }
+  FirstLeadingBit(e2, t2) {
+    const n2 = this.exec.evalExpression(e2.args[0], t2);
+    if (n2 instanceof Me) return new Me(n2.data.map((e3) => this._firstLeadingBit(e3)), n2.typeInfo);
+    const s2 = n2;
+    return new Be(this._firstLeadingBit(s2.value), n2.typeInfo);
+  }
+  _firstTrailingBit(e2) {
+    return 0 === e2 ? -1 : Math.log2(e2 & -e2);
+  }
+  FirstTrailingBit(e2, t2) {
+    const n2 = this.exec.evalExpression(e2.args[0], t2);
+    if (n2 instanceof Me) return new Me(n2.data.map((e3) => this._firstTrailingBit(e3)), n2.typeInfo);
+    const s2 = n2;
+    return new Be(this._firstTrailingBit(s2.value), n2.typeInfo);
+  }
+  Floor(e2, t2) {
+    const n2 = this.exec.evalExpression(e2.args[0], t2);
+    if (n2 instanceof Me) return new Me(n2.data.map((e3) => Math.floor(e3)), n2.typeInfo);
+    const s2 = n2;
+    return new Be(Math.floor(s2.value), n2.typeInfo);
+  }
+  Fma(e2, t2) {
+    const n2 = this.exec.evalExpression(e2.args[0], t2), s2 = this.exec.evalExpression(e2.args[1], t2), r2 = this.exec.evalExpression(e2.args[2], t2);
+    if (n2 instanceof Me && s2 instanceof Me && r2 instanceof Me) return n2.data.length !== s2.data.length || n2.data.length !== r2.data.length ? (console.error(`Fma() expects vectors of the same length. Line ${e2.line}`), null) : new Me(n2.data.map((e3, t3) => e3 * s2.data[t3] + r2.data[t3]), n2.typeInfo);
+    const a2 = n2, i2 = s2, o2 = r2;
+    return new Be(a2.value * i2.value + o2.value, a2.typeInfo);
+  }
+  Fract(e2, t2) {
+    const n2 = this.exec.evalExpression(e2.args[0], t2);
+    if (n2 instanceof Me) return new Me(n2.data.map((e3) => e3 - Math.floor(e3)), n2.typeInfo);
+    const s2 = n2;
+    return new Be(s2.value - Math.floor(s2.value), n2.typeInfo);
+  }
+  Frexp(e2, t2) {
+    return console.error(`TODO: frexp. Line ${e2.line}`), null;
+  }
+  InsertBits(e2, t2) {
+    const n2 = this.exec.evalExpression(e2.args[0], t2), s2 = this.exec.evalExpression(e2.args[1], t2), r2 = this.exec.evalExpression(e2.args[2], t2), a2 = this.exec.evalExpression(e2.args[3], t2);
+    if ("u32" !== r2.typeInfo.name && "x32" !== r2.typeInfo.name) return console.error(`InsertBits() expects an i32 offset argument. Line ${e2.line}`), null;
+    const i2 = r2.value, o2 = (1 << a2.value) - 1 << i2, c2 = ~o2;
+    if (n2 instanceof Me && s2 instanceof Me) return new Me(n2.data.map((e3, t3) => e3 & c2 | s2.data[t3] << i2 & o2), n2.typeInfo);
+    const l2 = n2.value, u2 = s2.value;
+    return new Be(l2 & c2 | u2 << i2 & o2, n2.typeInfo);
+  }
+  InverseSqrt(e2, t2) {
+    const n2 = this.exec.evalExpression(e2.args[0], t2);
+    if (n2 instanceof Me) return new Me(n2.data.map((e3) => 1 / Math.sqrt(e3)), n2.typeInfo);
+    const s2 = n2;
+    return new Be(1 / Math.sqrt(s2.value), n2.typeInfo);
+  }
+  Ldexp(e2, t2) {
+    return console.error(`TODO: ldexp. Line ${e2.line}`), null;
+  }
+  Length(e2, t2) {
+    const n2 = this.exec.evalExpression(e2.args[0], t2);
+    if (n2 instanceof Me) {
+      let e3 = 0;
+      return n2.data.forEach((t3) => {
+        e3 += t3 * t3;
+      }), new Be(Math.sqrt(e3), this.getTypeInfo("f32"));
+    }
+    const s2 = n2;
+    return new Be(Math.abs(s2.value), n2.typeInfo);
+  }
+  Log(e2, t2) {
+    const n2 = this.exec.evalExpression(e2.args[0], t2);
+    if (n2 instanceof Me) return new Me(n2.data.map((e3) => Math.log(e3)), n2.typeInfo);
+    const s2 = n2;
+    return new Be(Math.log(s2.value), n2.typeInfo);
+  }
+  Log2(e2, t2) {
+    const n2 = this.exec.evalExpression(e2.args[0], t2);
+    if (n2 instanceof Me) return new Me(n2.data.map((e3) => Math.log2(e3)), n2.typeInfo);
+    const s2 = n2;
+    return new Be(Math.log2(s2.value), n2.typeInfo);
+  }
+  Max(e2, t2) {
+    const n2 = this.exec.evalExpression(e2.args[0], t2), s2 = this.exec.evalExpression(e2.args[1], t2);
+    if (n2 instanceof Me && s2 instanceof Me) return new Me(n2.data.map((e3, t3) => Math.max(e3, s2.data[t3])), n2.typeInfo);
+    const r2 = n2, a2 = s2;
+    return new Be(Math.max(r2.value, a2.value), n2.typeInfo);
+  }
+  Min(e2, t2) {
+    const n2 = this.exec.evalExpression(e2.args[0], t2), s2 = this.exec.evalExpression(e2.args[1], t2);
+    if (n2 instanceof Me && s2 instanceof Me) return new Me(n2.data.map((e3, t3) => Math.min(e3, s2.data[t3])), n2.typeInfo);
+    const r2 = n2, a2 = s2;
+    return new Be(Math.min(r2.value, a2.value), n2.typeInfo);
+  }
+  Mix(e2, t2) {
+    const n2 = this.exec.evalExpression(e2.args[0], t2), s2 = this.exec.evalExpression(e2.args[1], t2), r2 = this.exec.evalExpression(e2.args[2], t2);
+    if (n2 instanceof Me && s2 instanceof Me && r2 instanceof Me) return new Me(n2.data.map((e3, t3) => n2.data[t3] * (1 - r2.data[t3]) + s2.data[t3] * r2.data[t3]), n2.typeInfo);
+    const a2 = s2, i2 = r2;
+    return new Be(n2.value * (1 - i2.value) + a2.value * i2.value, n2.typeInfo);
+  }
+  Modf(e2, t2) {
+    const n2 = this.exec.evalExpression(e2.args[0], t2), s2 = this.exec.evalExpression(e2.args[1], t2);
+    if (n2 instanceof Me && s2 instanceof Me) return new Me(n2.data.map((e3, t3) => e3 % s2.data[t3]), n2.typeInfo);
+    const r2 = s2;
+    return new Be(n2.value % r2.value, n2.typeInfo);
+  }
+  Normalize(e2, t2) {
+    const n2 = this.exec.evalExpression(e2.args[0], t2);
+    if (n2 instanceof Me) {
+      const s2 = this.Length(e2, t2).value;
+      return new Me(n2.data.map((e3) => e3 / s2), n2.typeInfo);
+    }
+    return console.error(`Normalize() expects a vector argument. Line ${e2.line}`), null;
+  }
+  Pow(e2, t2) {
+    const n2 = this.exec.evalExpression(e2.args[0], t2), s2 = this.exec.evalExpression(e2.args[1], t2);
+    if (n2 instanceof Me && s2 instanceof Me) return new Me(n2.data.map((e3, t3) => Math.pow(e3, s2.data[t3])), n2.typeInfo);
+    const r2 = n2, a2 = s2;
+    return new Be(Math.pow(r2.value, a2.value), n2.typeInfo);
+  }
+  QuantizeToF16(e2, t2) {
+    const n2 = this.exec.evalExpression(e2.args[0], t2);
+    if (n2 instanceof Me) return new Me(n2.data.map((e3) => e3), n2.typeInfo);
+    return new Be(n2.value, n2.typeInfo);
+  }
+  Radians(e2, t2) {
+    const n2 = this.exec.evalExpression(e2.args[0], t2);
+    if (n2 instanceof Me) return new Me(n2.data.map((e3) => e3 * Math.PI / 180), n2.typeInfo);
+    return new Be(n2.value * Math.PI / 180, this.getTypeInfo("f32"));
+  }
+  Reflect(e2, t2) {
+    let n2 = this.exec.evalExpression(e2.args[0], t2), s2 = this.exec.evalExpression(e2.args[1], t2);
+    if (n2 instanceof Me && s2 instanceof Me) {
+      const e3 = this._dot(n2.data, s2.data);
+      return new Me(n2.data.map((t3, n3) => t3 - 2 * e3 * s2.data[n3]), n2.typeInfo);
+    }
+    return console.error(`Reflect() expects vector arguments. Line ${e2.line}`), null;
+  }
+  Refract(e2, t2) {
+    let n2 = this.exec.evalExpression(e2.args[0], t2), s2 = this.exec.evalExpression(e2.args[1], t2), r2 = this.exec.evalExpression(e2.args[2], t2);
+    if (n2 instanceof Me && s2 instanceof Me && r2 instanceof Be) {
+      const e3 = this._dot(s2.data, n2.data);
+      return new Me(n2.data.map((t3, n3) => {
+        const a2 = 1 - r2.value * r2.value * (1 - e3 * e3);
+        if (a2 < 0) return 0;
+        const i2 = Math.sqrt(a2);
+        return r2.value * t3 - (r2.value * e3 + i2) * s2.data[n3];
+      }), n2.typeInfo);
+    }
+    return console.error(`Refract() expects vector arguments and a scalar argument. Line ${e2.line}`), null;
+  }
+  ReverseBits(e2, t2) {
+    return console.error(`TODO: reverseBits. Line ${e2.line}`), null;
+  }
+  Round(e2, t2) {
+    const n2 = this.exec.evalExpression(e2.args[0], t2);
+    if (n2 instanceof Me) return new Me(n2.data.map((e3) => Math.round(e3)), n2.typeInfo);
+    const s2 = n2;
+    return new Be(Math.round(s2.value), n2.typeInfo);
+  }
+  Saturate(e2, t2) {
+    const n2 = this.exec.evalExpression(e2.args[0], t2);
+    if (n2 instanceof Me) return new Me(n2.data.map((e3) => Math.min(Math.max(e3, 0), 1)), n2.typeInfo);
+    const s2 = n2;
+    return new Be(Math.min(Math.max(s2.value, 0), 1), n2.typeInfo);
+  }
+  Sign(e2, t2) {
+    const n2 = this.exec.evalExpression(e2.args[0], t2);
+    if (n2 instanceof Me) return new Me(n2.data.map((e3) => Math.sign(e3)), n2.typeInfo);
+    const s2 = n2;
+    return new Be(Math.sign(s2.value), n2.typeInfo);
+  }
+  Sin(e2, t2) {
+    const n2 = this.exec.evalExpression(e2.args[0], t2);
+    if (n2 instanceof Me) return new Me(n2.data.map((e3) => Math.sin(e3)), n2.typeInfo);
+    const s2 = n2;
+    return new Be(Math.sin(s2.value), n2.typeInfo);
+  }
+  Sinh(e2, t2) {
+    const n2 = this.exec.evalExpression(e2.args[0], t2);
+    if (n2 instanceof Me) return new Me(n2.data.map((e3) => Math.sinh(e3)), n2.typeInfo);
+    const s2 = n2;
+    return new Be(Math.sinh(s2.value), n2.typeInfo);
+  }
+  _smoothstep(e2, t2, n2) {
+    const s2 = Math.min(Math.max((n2 - e2) / (t2 - e2), 0), 1);
+    return s2 * s2 * (3 - 2 * s2);
+  }
+  SmoothStep(e2, t2) {
+    const n2 = this.exec.evalExpression(e2.args[0], t2), s2 = this.exec.evalExpression(e2.args[1], t2), r2 = this.exec.evalExpression(e2.args[2], t2);
+    if (r2 instanceof Me && n2 instanceof Me && s2 instanceof Me) return new Me(r2.data.map((e3, t3) => this._smoothstep(n2.data[t3], s2.data[t3], e3)), r2.typeInfo);
+    const a2 = n2, i2 = s2, o2 = r2;
+    return new Be(this._smoothstep(a2.value, i2.value, o2.value), r2.typeInfo);
+  }
+  Sqrt(e2, t2) {
+    const n2 = this.exec.evalExpression(e2.args[0], t2);
+    if (n2 instanceof Me) return new Me(n2.data.map((e3) => Math.sqrt(e3)), n2.typeInfo);
+    const s2 = n2;
+    return new Be(Math.sqrt(s2.value), n2.typeInfo);
+  }
+  Step(e2, t2) {
+    const n2 = this.exec.evalExpression(e2.args[0], t2), s2 = this.exec.evalExpression(e2.args[1], t2);
+    if (s2 instanceof Me && n2 instanceof Me) return new Me(s2.data.map((e3, t3) => e3 < n2.data[t3] ? 0 : 1), s2.typeInfo);
+    const r2 = n2;
+    return new Be(s2.value < r2.value ? 0 : 1, r2.typeInfo);
+  }
+  Tan(e2, t2) {
+    const n2 = this.exec.evalExpression(e2.args[0], t2);
+    if (n2 instanceof Me) return new Me(n2.data.map((e3) => Math.tan(e3)), n2.typeInfo);
+    const s2 = n2;
+    return new Be(Math.tan(s2.value), n2.typeInfo);
+  }
+  Tanh(e2, t2) {
+    const n2 = this.exec.evalExpression(e2.args[0], t2);
+    if (n2 instanceof Me) return new Me(n2.data.map((e3) => Math.tanh(e3)), n2.typeInfo);
+    const s2 = n2;
+    return new Be(Math.tanh(s2.value), n2.typeInfo);
+  }
+  _getTransposeType(e2) {
+    const t2 = e2.getTypeName();
+    return "mat2x2f" === t2 || "mat2x2h" === t2 ? e2 : "mat2x3f" === t2 ? this.getTypeInfo("mat3x2f") : "mat2x3h" === t2 ? this.getTypeInfo("mat3x2h") : "mat2x4f" === t2 ? this.getTypeInfo("mat4x2f") : "mat2x4h" === t2 ? this.getTypeInfo("mat4x2h") : "mat3x2f" === t2 ? this.getTypeInfo("mat2x3f") : "mat3x2h" === t2 ? this.getTypeInfo("mat2x3h") : "mat3x3f" === t2 || "mat3x3h" === t2 ? e2 : "mat3x4f" === t2 ? this.getTypeInfo("mat4x3f") : "mat3x4h" === t2 ? this.getTypeInfo("mat4x3h") : "mat4x2f" === t2 ? this.getTypeInfo("mat2x4f") : "mat4x2h" === t2 ? this.getTypeInfo("mat2x4h") : "mat4x3f" === t2 ? this.getTypeInfo("mat3x4f") : "mat4x3h" === t2 ? this.getTypeInfo("mat3x4h") : ("mat4x4f" === t2 || "mat4x4h" === t2 || console.error(`Invalid matrix type ${t2}`), e2);
+  }
+  Transpose(e2, t2) {
+    const n2 = this.exec.evalExpression(e2.args[0], t2);
+    if (!(n2 instanceof Ue)) return console.error(`Transpose() expects a matrix argument. Line ${e2.line}`), null;
+    const s2 = this._getTransposeType(n2.typeInfo);
+    if ("mat2x2" === n2.typeInfo.name || "mat2x2f" === n2.typeInfo.name || "mat2x2h" === n2.typeInfo.name) {
+      const e3 = n2.data;
+      return new Ue([e3[0], e3[2], e3[1], e3[3]], s2);
+    }
+    if ("mat2x3" === n2.typeInfo.name || "mat2x3f" === n2.typeInfo.name || "mat2x3h" === n2.typeInfo.name) {
+      const e3 = n2.data;
+      return new Ue([e3[0], e3[3], e3[6], e3[1], e3[4], e3[7]], s2);
+    }
+    if ("mat2x4" === n2.typeInfo.name || "mat2x4f" === n2.typeInfo.name || "mat2x4h" === n2.typeInfo.name) {
+      const e3 = n2.data;
+      return new Ue([e3[0], e3[4], e3[8], e3[12], e3[1], e3[5], e3[9], e3[13]], s2);
+    }
+    if ("mat3x2" === n2.typeInfo.name || "mat3x2f" === n2.typeInfo.name || "mat3x2h" === n2.typeInfo.name) {
+      const e3 = n2.data;
+      return new Ue([e3[0], e3[3], e3[1], e3[4], e3[2], e3[5]], s2);
+    }
+    if ("mat3x3" === n2.typeInfo.name || "mat3x3f" === n2.typeInfo.name || "mat3x3h" === n2.typeInfo.name) {
+      const e3 = n2.data;
+      return new Ue([e3[0], e3[3], e3[6], e3[1], e3[4], e3[7], e3[2], e3[5], e3[8]], s2);
+    }
+    if ("mat3x4" === n2.typeInfo.name || "mat3x4f" === n2.typeInfo.name || "mat3x4h" === n2.typeInfo.name) {
+      const e3 = n2.data;
+      return new Ue([e3[0], e3[4], e3[8], e3[12], e3[1], e3[5], e3[9], e3[13], e3[2], e3[6], e3[10], e3[14]], s2);
+    }
+    if ("mat4x2" === n2.typeInfo.name || "mat4x2f" === n2.typeInfo.name || "mat4x2h" === n2.typeInfo.name) {
+      const e3 = n2.data;
+      return new Ue([e3[0], e3[4], e3[1], e3[5], e3[2], e3[6]], s2);
+    }
+    if ("mat4x3" === n2.typeInfo.name || "mat4x3f" === n2.typeInfo.name || "mat4x3h" === n2.typeInfo.name) {
+      const e3 = n2.data;
+      return new Ue([e3[0], e3[4], e3[8], e3[1], e3[5], e3[9], e3[2], e3[6], e3[10]], s2);
+    }
+    if ("mat4x4" === n2.typeInfo.name || "mat4x4f" === n2.typeInfo.name || "mat4x4h" === n2.typeInfo.name) {
+      const e3 = n2.data;
+      return new Ue([e3[0], e3[4], e3[8], e3[12], e3[1], e3[5], e3[9], e3[13], e3[2], e3[6], e3[10], e3[14], e3[3], e3[7], e3[11], e3[15]], s2);
+    }
+    return console.error(`Invalid matrix type ${n2.typeInfo.name}`), null;
+  }
+  Trunc(e2, t2) {
+    const n2 = this.exec.evalExpression(e2.args[0], t2);
+    if (n2 instanceof Me) return new Me(n2.data.map((e3) => Math.trunc(e3)), n2.typeInfo);
+    const s2 = n2;
+    return new Be(Math.trunc(s2.value), n2.typeInfo);
+  }
+  Dpdx(e2, t2) {
+    return console.error(`TODO: dpdx. Line ${e2.line}`), null;
+  }
+  DpdxCoarse(e2, t2) {
+    return console.error(`TODO: dpdxCoarse. Line ${e2.line}`), null;
+  }
+  DpdxFine(e2, t2) {
+    return console.error("TODO: dpdxFine"), null;
+  }
+  Dpdy(e2, t2) {
+    return console.error("TODO: dpdy"), null;
+  }
+  DpdyCoarse(e2, t2) {
+    return console.error("TODO: dpdyCoarse"), null;
+  }
+  DpdyFine(e2, t2) {
+    return console.error("TODO: dpdyFine"), null;
+  }
+  Fwidth(e2, t2) {
+    return console.error("TODO: fwidth"), null;
+  }
+  FwidthCoarse(e2, t2) {
+    return console.error("TODO: fwidthCoarse"), null;
+  }
+  FwidthFine(e2, t2) {
+    return console.error("TODO: fwidthFine"), null;
+  }
+  TextureDimensions(e2, t2) {
+    const n2 = e2.args[0], s2 = e2.args.length > 1 ? this.exec.evalExpression(e2.args[1], t2).value : 0;
+    if (n2 instanceof ge) {
+      const r2 = n2.name, a2 = t2.getVariableValue(r2);
+      if (a2 instanceof We) {
+        if (s2 < 0 || s2 >= a2.mipLevelCount) return console.error(`Invalid mip level for textureDimensions. Line ${e2.line}`), null;
+        const t3 = a2.getMipLevelSize(s2), n3 = a2.dimension;
+        return "1d" === n3 ? new Be(t3[0], this.getTypeInfo("u32")) : "3d" === n3 ? new Me(t3, this.getTypeInfo("vec3u")) : "2d" === n3 ? new Me(t3.slice(0, 2), this.getTypeInfo("vec2u")) : (console.error(`Invalid texture dimension ${n3} not found. Line ${e2.line}`), null);
+      }
+      return console.error(`Texture ${r2} not found. Line ${e2.line}`), null;
+    }
+    return console.error(`Invalid texture argument for textureDimensions. Line ${e2.line}`), null;
+  }
+  TextureGather(e2, t2) {
+    return console.error("TODO: textureGather"), null;
+  }
+  TextureGatherCompare(e2, t2) {
+    return console.error("TODO: textureGatherCompare"), null;
+  }
+  TextureLoad(e2, t2) {
+    const n2 = e2.args[0], s2 = this.exec.evalExpression(e2.args[1], t2), r2 = e2.args.length > 2 ? this.exec.evalExpression(e2.args[2], t2).value : 0;
+    if (!(s2 instanceof Me) || 2 !== s2.data.length) return console.error(`Invalid UV argument for textureLoad. Line ${e2.line}`), null;
+    if (n2 instanceof ge) {
+      const a2 = n2.name, i2 = t2.getVariableValue(a2);
+      if (i2 instanceof We) {
+        const t3 = Math.floor(s2.data[0]), n3 = Math.floor(s2.data[1]);
+        if (t3 < 0 || t3 >= i2.width || n3 < 0 || n3 >= i2.height) return console.error(`Texture ${a2} out of bounds. Line ${e2.line}`), null;
+        const o2 = i2.getPixel(t3, n3, 0, r2);
+        return null === o2 ? (console.error(`Invalid texture format for textureLoad. Line ${e2.line}`), null) : new Me(o2, this.getTypeInfo("vec4f"));
+      }
+      return console.error(`Texture ${a2} not found. Line ${e2.line}`), null;
+    }
+    return console.error(`Invalid texture argument for textureLoad. Line ${e2.line}`), null;
+  }
+  TextureNumLayers(e2, t2) {
+    const n2 = e2.args[0];
+    if (n2 instanceof ge) {
+      const s2 = n2.name, r2 = t2.getVariableValue(s2);
+      return r2 instanceof We ? new Be(r2.depthOrArrayLayers, this.getTypeInfo("u32")) : (console.error(`Texture ${s2} not found. Line ${e2.line}`), null);
+    }
+    return console.error(`Invalid texture argument for textureNumLayers. Line ${e2.line}`), null;
+  }
+  TextureNumLevels(e2, t2) {
+    const n2 = e2.args[0];
+    if (n2 instanceof ge) {
+      const s2 = n2.name, r2 = t2.getVariableValue(s2);
+      return r2 instanceof We ? new Be(r2.mipLevelCount, this.getTypeInfo("u32")) : (console.error(`Texture ${s2} not found. Line ${e2.line}`), null);
+    }
+    return console.error(`Invalid texture argument for textureNumLevels. Line ${e2.line}`), null;
+  }
+  TextureNumSamples(e2, t2) {
+    const n2 = e2.args[0];
+    if (n2 instanceof ge) {
+      const s2 = n2.name, r2 = t2.getVariableValue(s2);
+      return r2 instanceof We ? new Be(r2.sampleCount, this.getTypeInfo("u32")) : (console.error(`Texture ${s2} not found. Line ${e2.line}`), null);
+    }
+    return console.error(`Invalid texture argument for textureNumSamples. Line ${e2.line}`), null;
+  }
+  TextureSample(e2, t2) {
+    return console.error("TODO: textureSample"), null;
+  }
+  TextureSampleBias(e2, t2) {
+    return console.error("TODO: textureSampleBias"), null;
+  }
+  TextureSampleCompare(e2, t2) {
+    return console.error("TODO: textureSampleCompare"), null;
+  }
+  TextureSampleCompareLevel(e2, t2) {
+    return console.error("TODO: textureSampleCompareLevel"), null;
+  }
+  TextureSampleGrad(e2, t2) {
+    return console.error("TODO: textureSampleGrad"), null;
+  }
+  TextureSampleLevel(e2, t2) {
+    return console.error("TODO: textureSampleLevel"), null;
+  }
+  TextureSampleBaseClampToEdge(e2, t2) {
+    return console.error("TODO: textureSampleBaseClampToEdge"), null;
+  }
+  TextureStore(e2, t2) {
+    const n2 = e2.args[0], s2 = this.exec.evalExpression(e2.args[1], t2), r2 = 4 === e2.args.length ? this.exec.evalExpression(e2.args[2], t2).value : 0, a2 = 4 === e2.args.length ? this.exec.evalExpression(e2.args[3], t2).data : this.exec.evalExpression(e2.args[2], t2).data;
+    if (4 !== a2.length) return console.error(`Invalid value argument for textureStore. Line ${e2.line}`), null;
+    if (!(s2 instanceof Me) || 2 !== s2.data.length) return console.error(`Invalid UV argument for textureStore. Line ${e2.line}`), null;
+    if (n2 instanceof ge) {
+      const i2 = n2.name, o2 = t2.getVariableValue(i2);
+      if (o2 instanceof We) {
+        const t3 = o2.getMipLevelSize(0), n3 = Math.floor(s2.data[0]), c2 = Math.floor(s2.data[1]);
+        return n3 < 0 || n3 >= t3[0] || c2 < 0 || c2 >= t3[1] ? (console.error(`Texture ${i2} out of bounds. Line ${e2.line}`), null) : (o2.setPixel(n3, c2, 0, r2, Array.from(a2)), null);
+      }
+      return console.error(`Texture ${i2} not found. Line ${e2.line}`), null;
+    }
+    return console.error(`Invalid texture argument for textureStore. Line ${e2.line}`), null;
+  }
+  AtomicLoad(e2, t2) {
+    let n2 = e2.args[0];
+    n2 instanceof ke && (n2 = n2.right);
+    const s2 = this.exec.getVariableName(n2, t2);
+    return t2.getVariable(s2).value.getSubData(this.exec, n2.postfix, t2);
+  }
+  AtomicStore(e2, t2) {
+    let n2 = e2.args[0];
+    n2 instanceof ke && (n2 = n2.right);
+    const s2 = this.exec.getVariableName(n2, t2), r2 = t2.getVariable(s2);
+    let a2 = e2.args[1];
+    const i2 = this.exec.evalExpression(a2, t2), o2 = r2.value.getSubData(this.exec, n2.postfix, t2);
+    return o2 instanceof Be && i2 instanceof Be && (o2.value = i2.value), r2.value instanceof Pe && r2.value.setDataValue(this.exec, o2, n2.postfix, t2), null;
+  }
+  AtomicAdd(e2, t2) {
+    let n2 = e2.args[0];
+    n2 instanceof ke && (n2 = n2.right);
+    const s2 = this.exec.getVariableName(n2, t2), r2 = t2.getVariable(s2);
+    let a2 = e2.args[1];
+    const i2 = this.exec.evalExpression(a2, t2), o2 = r2.value.getSubData(this.exec, n2.postfix, t2), c2 = new Be(o2.value, o2.typeInfo);
+    return o2 instanceof Be && i2 instanceof Be && (o2.value += i2.value), r2.value instanceof Pe && r2.value.setDataValue(this.exec, o2, n2.postfix, t2), c2;
+  }
+  AtomicSub(e2, t2) {
+    let n2 = e2.args[0];
+    n2 instanceof ke && (n2 = n2.right);
+    const s2 = this.exec.getVariableName(n2, t2), r2 = t2.getVariable(s2);
+    let a2 = e2.args[1];
+    const i2 = this.exec.evalExpression(a2, t2), o2 = r2.value.getSubData(this.exec, n2.postfix, t2), c2 = new Be(o2.value, o2.typeInfo);
+    return o2 instanceof Be && i2 instanceof Be && (o2.value -= i2.value), r2.value instanceof Pe && r2.value.setDataValue(this.exec, o2, n2.postfix, t2), c2;
+  }
+  AtomicMax(e2, t2) {
+    let n2 = e2.args[0];
+    n2 instanceof ke && (n2 = n2.right);
+    const s2 = this.exec.getVariableName(n2, t2), r2 = t2.getVariable(s2);
+    let a2 = e2.args[1];
+    const i2 = this.exec.evalExpression(a2, t2), o2 = r2.value.getSubData(this.exec, n2.postfix, t2), c2 = new Be(o2.value, o2.typeInfo);
+    return o2 instanceof Be && i2 instanceof Be && (o2.value = Math.max(o2.value, i2.value)), r2.value instanceof Pe && r2.value.setDataValue(this.exec, o2, n2.postfix, t2), c2;
+  }
+  AtomicMin(e2, t2) {
+    let n2 = e2.args[0];
+    n2 instanceof ke && (n2 = n2.right);
+    const s2 = this.exec.getVariableName(n2, t2), r2 = t2.getVariable(s2);
+    let a2 = e2.args[1];
+    const i2 = this.exec.evalExpression(a2, t2), o2 = r2.value.getSubData(this.exec, n2.postfix, t2), c2 = new Be(o2.value, o2.typeInfo);
+    return o2 instanceof Be && i2 instanceof Be && (o2.value = Math.min(o2.value, i2.value)), r2.value instanceof Pe && r2.value.setDataValue(this.exec, o2, n2.postfix, t2), c2;
+  }
+  AtomicAnd(e2, t2) {
+    let n2 = e2.args[0];
+    n2 instanceof ke && (n2 = n2.right);
+    const s2 = this.exec.getVariableName(n2, t2), r2 = t2.getVariable(s2);
+    let a2 = e2.args[1];
+    const i2 = this.exec.evalExpression(a2, t2), o2 = r2.value.getSubData(this.exec, n2.postfix, t2), c2 = new Be(o2.value, o2.typeInfo);
+    return o2 instanceof Be && i2 instanceof Be && (o2.value = o2.value & i2.value), r2.value instanceof Pe && r2.value.setDataValue(this.exec, o2, n2.postfix, t2), c2;
+  }
+  AtomicOr(e2, t2) {
+    let n2 = e2.args[0];
+    n2 instanceof ke && (n2 = n2.right);
+    const s2 = this.exec.getVariableName(n2, t2), r2 = t2.getVariable(s2);
+    let a2 = e2.args[1];
+    const i2 = this.exec.evalExpression(a2, t2), o2 = r2.value.getSubData(this.exec, n2.postfix, t2), c2 = new Be(o2.value, o2.typeInfo);
+    return o2 instanceof Be && i2 instanceof Be && (o2.value = o2.value | i2.value), r2.value instanceof Pe && r2.value.setDataValue(this.exec, o2, n2.postfix, t2), c2;
+  }
+  AtomicXor(e2, t2) {
+    let n2 = e2.args[0];
+    n2 instanceof ke && (n2 = n2.right);
+    const s2 = this.exec.getVariableName(n2, t2), r2 = t2.getVariable(s2);
+    let a2 = e2.args[1];
+    const i2 = this.exec.evalExpression(a2, t2), o2 = r2.value.getSubData(this.exec, n2.postfix, t2), c2 = new Be(o2.value, o2.typeInfo);
+    return o2 instanceof Be && i2 instanceof Be && (o2.value = o2.value ^ i2.value), r2.value instanceof Pe && r2.value.setDataValue(this.exec, o2, n2.postfix, t2), c2;
+  }
+  AtomicExchange(e2, t2) {
+    let n2 = e2.args[0];
+    n2 instanceof ke && (n2 = n2.right);
+    const s2 = this.exec.getVariableName(n2, t2), r2 = t2.getVariable(s2);
+    let a2 = e2.args[1];
+    const i2 = this.exec.evalExpression(a2, t2), o2 = r2.value.getSubData(this.exec, n2.postfix, t2), c2 = new Be(o2.value, o2.typeInfo);
+    return o2 instanceof Be && i2 instanceof Be && (o2.value = i2.value), r2.value instanceof Pe && r2.value.setDataValue(this.exec, o2, n2.postfix, t2), c2;
+  }
+  AtomicCompareExchangeWeak(e2, t2) {
+    return console.error("TODO: atomicCompareExchangeWeak"), null;
+  }
+  Pack4x8snorm(e2, t2) {
+    return console.error("TODO: pack4x8snorm"), null;
+  }
+  Pack4x8unorm(e2, t2) {
+    return console.error("TODO: pack4x8unorm"), null;
+  }
+  Pack4xI8(e2, t2) {
+    return console.error("TODO: pack4xI8"), null;
+  }
+  Pack4xU8(e2, t2) {
+    return console.error("TODO: pack4xU8"), null;
+  }
+  Pack4x8Clamp(e2, t2) {
+    return console.error("TODO: pack4x8Clamp"), null;
+  }
+  Pack4xU8Clamp(e2, t2) {
+    return console.error("TODO: pack4xU8Clamp"), null;
+  }
+  Pack2x16snorm(e2, t2) {
+    return console.error("TODO: pack2x16snorm"), null;
+  }
+  Pack2x16unorm(e2, t2) {
+    return console.error("TODO: pack2x16unorm"), null;
+  }
+  Pack2x16float(e2, t2) {
+    return console.error("TODO: pack2x16float"), null;
+  }
+  Unpack4x8snorm(e2, t2) {
+    return console.error("TODO: unpack4x8snorm"), null;
+  }
+  Unpack4x8unorm(e2, t2) {
+    return console.error("TODO: unpack4x8unorm"), null;
+  }
+  Unpack4xI8(e2, t2) {
+    return console.error("TODO: unpack4xI8"), null;
+  }
+  Unpack4xU8(e2, t2) {
+    return console.error("TODO: unpack4xU8"), null;
+  }
+  Unpack2x16snorm(e2, t2) {
+    return console.error("TODO: unpack2x16snorm"), null;
+  }
+  Unpack2x16unorm(e2, t2) {
+    return console.error("TODO: unpack2x16unorm"), null;
+  }
+  Unpack2x16float(e2, t2) {
+    return console.error("TODO: unpack2x16float"), null;
+  }
+  StorageBarrier(e2, t2) {
+    return null;
+  }
+  TextureBarrier(e2, t2) {
+    return null;
+  }
+  WorkgroupBarrier(e2, t2) {
+    return null;
+  }
+  WorkgroupUniformLoad(e2, t2) {
+    return null;
+  }
+  SubgroupAdd(e2, t2) {
+    return console.error("TODO: subgroupAdd"), null;
+  }
+  SubgroupExclusiveAdd(e2, t2) {
+    return console.error("TODO: subgroupExclusiveAdd"), null;
+  }
+  SubgroupInclusiveAdd(e2, t2) {
+    return console.error("TODO: subgroupInclusiveAdd"), null;
+  }
+  SubgroupAll(e2, t2) {
+    return console.error("TODO: subgroupAll"), null;
+  }
+  SubgroupAnd(e2, t2) {
+    return console.error("TODO: subgroupAnd"), null;
+  }
+  SubgroupAny(e2, t2) {
+    return console.error("TODO: subgroupAny"), null;
+  }
+  SubgroupBallot(e2, t2) {
+    return console.error("TODO: subgroupBallot"), null;
+  }
+  SubgroupBroadcast(e2, t2) {
+    return console.error("TODO: subgroupBroadcast"), null;
+  }
+  SubgroupBroadcastFirst(e2, t2) {
+    return console.error("TODO: subgroupBroadcastFirst"), null;
+  }
+  SubgroupElect(e2, t2) {
+    return console.error("TODO: subgroupElect"), null;
+  }
+  SubgroupMax(e2, t2) {
+    return console.error("TODO: subgroupMax"), null;
+  }
+  SubgroupMin(e2, t2) {
+    return console.error("TODO: subgroupMin"), null;
+  }
+  SubgroupMul(e2, t2) {
+    return console.error("TODO: subgroupMul"), null;
+  }
+  SubgroupExclusiveMul(e2, t2) {
+    return console.error("TODO: subgroupExclusiveMul"), null;
+  }
+  SubgroupInclusiveMul(e2, t2) {
+    return console.error("TODO: subgroupInclusiveMul"), null;
+  }
+  SubgroupOr(e2, t2) {
+    return console.error("TODO: subgroupOr"), null;
+  }
+  SubgroupShuffle(e2, t2) {
+    return console.error("TODO: subgroupShuffle"), null;
+  }
+  SubgroupShuffleDown(e2, t2) {
+    return console.error("TODO: subgroupShuffleDown"), null;
+  }
+  SubgroupShuffleUp(e2, t2) {
+    return console.error("TODO: subgroupShuffleUp"), null;
+  }
+  SubgroupShuffleXor(e2, t2) {
+    return console.error("TODO: subgroupShuffleXor"), null;
+  }
+  SubgroupXor(e2, t2) {
+    return console.error("TODO: subgroupXor"), null;
+  }
+  QuadBroadcast(e2, t2) {
+    return console.error("TODO: quadBroadcast"), null;
+  }
+  QuadSwapDiagonal(e2, t2) {
+    return console.error("TODO: quadSwapDiagonal"), null;
+  }
+  QuadSwapX(e2, t2) {
+    return console.error("TODO: quadSwapX"), null;
+  }
+  QuadSwapY(e2, t2) {
+    return console.error("TODO: quadSwapY"), null;
+  }
+}
+const ft = { vec2: 2, vec2f: 2, vec2i: 2, vec2u: 2, vec2b: 2, vec2h: 2, vec3: 3, vec3f: 3, vec3i: 3, vec3u: 3, vec3b: 3, vec3h: 3, vec4: 4, vec4f: 4, vec4i: 4, vec4u: 4, vec4b: 4, vec4h: 4 }, pt = { mat2x2: [2, 2, 4], mat2x2f: [2, 2, 4], mat2x2h: [2, 2, 4], mat2x3: [2, 3, 6], mat2x3f: [2, 3, 6], mat2x3h: [2, 3, 6], mat2x4: [2, 4, 8], mat2x4f: [2, 4, 8], mat2x4h: [2, 4, 8], mat3x2: [3, 2, 6], mat3x2f: [3, 2, 6], mat3x2h: [3, 2, 6], mat3x3: [3, 3, 9], mat3x3f: [3, 3, 9], mat3x3h: [3, 3, 9], mat3x4: [3, 4, 12], mat3x4f: [3, 4, 12], mat3x4h: [3, 4, 12], mat4x2: [4, 2, 8], mat4x2f: [4, 2, 8], mat4x2h: [4, 2, 8], mat4x3: [4, 3, 12], mat4x3f: [4, 3, 12], mat4x3h: [4, 3, 12], mat4x4: [4, 4, 16], mat4x4f: [4, 4, 16], mat4x4h: [4, 4, 16] };
+class dt extends ut {
+  constructor(e2, t2) {
+    var n2;
+    super(), this.ast = null != e2 ? e2 : [], this.reflection = new at(), this.reflection.updateAST(this.ast), this.context = null !== (n2 = null == t2 ? void 0 : t2.clone()) && void 0 !== n2 ? n2 : new lt(), this.builtins = new ht(this), this.typeInfo = { bool: this.getTypeInfo(ae.bool), i32: this.getTypeInfo(ae.i32), u32: this.getTypeInfo(ae.u32), f32: this.getTypeInfo(ae.f32), f16: this.getTypeInfo(ae.f16), vec2f: this.getTypeInfo(ce.vec2f), vec2u: this.getTypeInfo(ce.vec2u), vec2i: this.getTypeInfo(ce.vec2i), vec2h: this.getTypeInfo(ce.vec2h), vec3f: this.getTypeInfo(ce.vec3f), vec3u: this.getTypeInfo(ce.vec3u), vec3i: this.getTypeInfo(ce.vec3i), vec3h: this.getTypeInfo(ce.vec3h), vec4f: this.getTypeInfo(ce.vec4f), vec4u: this.getTypeInfo(ce.vec4u), vec4i: this.getTypeInfo(ce.vec4i), vec4h: this.getTypeInfo(ce.vec4h), mat2x2f: this.getTypeInfo(ce.mat2x2f), mat2x3f: this.getTypeInfo(ce.mat2x3f), mat2x4f: this.getTypeInfo(ce.mat2x4f), mat3x2f: this.getTypeInfo(ce.mat3x2f), mat3x3f: this.getTypeInfo(ce.mat3x3f), mat3x4f: this.getTypeInfo(ce.mat3x4f), mat4x2f: this.getTypeInfo(ce.mat4x2f), mat4x3f: this.getTypeInfo(ce.mat4x3f), mat4x4f: this.getTypeInfo(ce.mat4x4f) };
+  }
+  getVariableValue(e2) {
+    var t2, n2;
+    const r2 = null !== (n2 = null === (t2 = this.context.getVariable(e2)) || void 0 === t2 ? void 0 : t2.value) && void 0 !== n2 ? n2 : null;
+    if (null === r2) return null;
+    if (r2 instanceof Be) return r2.value;
+    if (r2 instanceof Me) return Array.from(r2.data);
+    if (r2 instanceof Ue) return Array.from(r2.data);
+    if (r2 instanceof Pe && r2.typeInfo instanceof s) {
+      if ("u32" === r2.typeInfo.format.name) return Array.from(new Uint32Array(r2.buffer, r2.offset, r2.typeInfo.count));
+      if ("i32" === r2.typeInfo.format.name) return Array.from(new Int32Array(r2.buffer, r2.offset, r2.typeInfo.count));
+      if ("f32" === r2.typeInfo.format.name) return Array.from(new Float32Array(r2.buffer, r2.offset, r2.typeInfo.count));
+    }
+    return console.error(`Unsupported return variable type ${r2.typeInfo.name}`), null;
+  }
+  execute(e2) {
+    (e2 = null != e2 ? e2 : {}).constants && this._setOverrides(e2.constants, this.context), this._execStatements(this.ast, this.context);
+  }
+  dispatchWorkgroups(e2, t2, n2, s2) {
+    const r2 = this.context.clone();
+    (s2 = null != s2 ? s2 : {}).constants && this._setOverrides(s2.constants, r2), this._execStatements(this.ast, r2);
+    const a2 = r2.getFunction(e2);
+    if (!a2) return void console.error(`Function ${e2} not found`);
+    if ("number" == typeof t2) t2 = [t2, 1, 1];
+    else {
+      if (0 === t2.length) return void console.error("Invalid dispatch count");
+      1 === t2.length ? t2 = [t2[0], 1, 1] : 2 === t2.length ? t2 = [t2[0], t2[1], 1] : t2.length > 3 && (t2 = [t2[0], t2[1], t2[2]]);
+    }
+    const i2 = t2[0], o2 = t2[1], c2 = t2[2], l2 = this.getTypeInfo("vec3u");
+    r2.setVariable("@num_workgroups", new Me(t2, l2));
+    const u2 = this.reflection.getFunctionInfo(e2);
+    null === u2 && console.error(`Function ${e2} not found in reflection data`);
+    for (const e3 in n2) for (const t3 in n2[e3]) {
+      const s3 = n2[e3][t3];
+      r2.variables.forEach((n3) => {
+        var r3;
+        const a3 = n3.node;
+        if (null == a3 ? void 0 : a3.attributes) {
+          let i3 = null, o3 = null;
+          for (const e4 of a3.attributes) "binding" === e4.name ? i3 = e4.value : "group" === e4.name && (o3 = e4.value);
+          if (t3 == i3 && e3 == o3) {
+            let i4 = false;
+            for (const s4 of u2.resources) if (s4.name === n3.name && s4.group === parseInt(e3) && s4.binding === parseInt(t3)) {
+              i4 = true;
+              break;
+            }
+            if (i4) if (void 0 !== s3.texture && void 0 !== s3.descriptor) {
+              const e4 = new We(s3.texture, this.getTypeInfo(a3.type), s3.descriptor, null !== (r3 = s3.texture.view) && void 0 !== r3 ? r3 : null);
+              n3.value = e4;
+            } else void 0 !== s3.uniform ? n3.value = new Pe(s3.uniform, this.getTypeInfo(a3.type)) : n3.value = new Pe(s3, this.getTypeInfo(a3.type));
+          }
+        }
+      });
+    }
+    for (let e3 = 0; e3 < c2; ++e3) for (let t3 = 0; t3 < o2; ++t3) for (let n3 = 0; n3 < i2; ++n3) r2.setVariable("@workgroup_id", new Me([n3, t3, e3], this.getTypeInfo("vec3u"))), this._dispatchWorkgroup(a2, [n3, t3, e3], r2);
+  }
+  execStatement(e2, t2) {
+    if (e2 instanceof Y) return this.evalExpression(e2.value, t2);
+    if (e2 instanceof se) {
+      if (e2.condition) {
+        const n2 = this.evalExpression(e2.condition, t2);
+        if (!(n2 instanceof Be)) throw new Error("Invalid break-if condition");
+        if (!n2.value) return null;
+      }
+      return dt._breakObj;
+    }
+    if (e2 instanceof re) return dt._continueObj;
+    if (e2 instanceof U) this._let(e2, t2);
+    else if (e2 instanceof F) this._var(e2, t2);
+    else if (e2 instanceof P) this._const(e2, t2);
+    else if (e2 instanceof D) this._function(e2, t2);
+    else {
+      if (e2 instanceof Q) return this._if(e2, t2);
+      if (e2 instanceof Z) return this._switch(e2, t2);
+      if (e2 instanceof B) return this._for(e2, t2);
+      if (e2 instanceof V) return this._while(e2, t2);
+      if (e2 instanceof j) return this._loop(e2, t2);
+      if (e2 instanceof O) {
+        const n2 = t2.clone();
+        return n2.currentFunctionName = t2.currentFunctionName, this._execStatements(e2.body, n2);
+      }
+      if (e2 instanceof G) this._assign(e2, t2);
+      else if (e2 instanceof R) this._increment(e2, t2);
+      else {
+        if (e2 instanceof oe) return null;
+        if (e2 instanceof M) {
+          const n2 = e2.name;
+          null === t2.getVariable(n2) && t2.setVariable(n2, new Be(0, this.getTypeInfo("u32")));
+        } else if (e2 instanceof X) this._call(e2, t2);
+        else {
+          if (e2 instanceof ee) return null;
+          if (e2 instanceof te) return null;
+          console.error("Invalid statement type.", e2, `Line ${e2.line}`);
+        }
+      }
+    }
+    return null;
+  }
+  evalExpression(e2, t2) {
+    return e2 instanceof Ie ? this._evalBinaryOp(e2, t2) : e2 instanceof xe ? this._evalLiteral(e2, t2) : e2 instanceof ge ? this._evalVariable(e2, t2) : e2 instanceof me ? this._evalCall(e2, t2) : e2 instanceof de ? this._evalCreate(e2, t2) : e2 instanceof _e ? this._evalConst(e2, t2) : e2 instanceof ye ? this._evalBitcast(e2, t2) : e2 instanceof ke ? this._evalUnaryOp(e2, t2) : (console.error("Invalid expression type", e2, `Line ${e2.line}`), null);
+  }
+  getTypeInfo(e2) {
+    var t2;
+    if (e2 instanceof ae) {
+      const t3 = this.reflection.getTypeInfo(e2);
+      if (null !== t3) return t3;
+    }
+    let n2 = null !== (t2 = this.typeInfo[e2]) && void 0 !== t2 ? t2 : null;
+    return null !== n2 || (n2 = this.reflection.getTypeInfoByName(e2)), n2;
+  }
+  _setOverrides(e2, t2) {
+    for (const n2 in e2) {
+      const s2 = e2[n2], r2 = this.reflection.getOverrideInfo(n2);
+      null !== r2 ? (null === r2.type && (r2.type = this.getTypeInfo("u32")), "u32" === r2.type.name || "i32" === r2.type.name || "f32" === r2.type.name || "f16" === r2.type.name ? t2.setVariable(n2, new Be(s2, r2.type)) : "bool" === r2.type.name ? t2.setVariable(n2, new Be(s2 ? 1 : 0, r2.type)) : "vec2" === r2.type.name || "vec3" === r2.type.name || "vec4" === r2.type.name || "vec2f" === r2.type.name || "vec3f" === r2.type.name || "vec4f" === r2.type.name || "vec2i" === r2.type.name || "vec3i" === r2.type.name || "vec4i" === r2.type.name || "vec2u" === r2.type.name || "vec3u" === r2.type.name || "vec4u" === r2.type.name || "vec2h" === r2.type.name || "vec3h" === r2.type.name || "vec4h" === r2.type.name ? t2.setVariable(n2, new Me(s2, r2.type)) : console.error(`Invalid constant type for ${n2}`)) : console.error(`Override ${n2} does not exist in the shader.`);
+    }
+  }
+  _dispatchWorkgroup(e2, t2, n2) {
+    const s2 = [1, 1, 1];
+    for (const t3 of e2.node.attributes) if ("workgroup_size" === t3.name) {
+      if (t3.value.length > 0) {
+        const e3 = n2.getVariableValue(t3.value[0]);
+        s2[0] = e3 instanceof Be ? e3.value : parseInt(t3.value[0]);
+      }
+      if (t3.value.length > 1) {
+        const e3 = n2.getVariableValue(t3.value[1]);
+        s2[1] = e3 instanceof Be ? e3.value : parseInt(t3.value[1]);
+      }
+      if (t3.value.length > 2) {
+        const e3 = n2.getVariableValue(t3.value[2]);
+        s2[2] = e3 instanceof Be ? e3.value : parseInt(t3.value[2]);
+      }
+    }
+    const r2 = this.getTypeInfo("vec3u"), a2 = this.getTypeInfo("u32");
+    n2.setVariable("@workgroup_size", new Me(s2, r2));
+    const i2 = s2[0], o2 = s2[1], c2 = s2[2];
+    for (let l2 = 0, u2 = 0; l2 < c2; ++l2) for (let c3 = 0; c3 < o2; ++c3) for (let o3 = 0; o3 < i2; ++o3, ++u2) {
+      const i3 = [o3, c3, l2], h2 = [o3 + t2[0] * s2[0], c3 + t2[1] * s2[1], l2 + t2[2] * s2[2]];
+      n2.setVariable("@local_invocation_id", new Me(i3, r2)), n2.setVariable("@global_invocation_id", new Me(h2, r2)), n2.setVariable("@local_invocation_index", new Be(u2, a2)), this._dispatchExec(e2, n2);
+    }
+  }
+  _dispatchExec(e2, t2) {
+    for (const n2 of e2.node.args) for (const e3 of n2.attributes) if ("builtin" === e3.name) {
+      const s2 = `@${e3.value}`, r2 = t2.getVariable(s2);
+      void 0 !== r2 && t2.variables.set(n2.name, r2);
+    }
+    this._execStatements(e2.node.body, t2);
+  }
+  getVariableName(e2, t2) {
+    for (; e2 instanceof ke; ) e2 = e2.right;
+    return e2 instanceof ge ? e2.name : (console.error("Unknown variable type", e2, "Line", e2.line), null);
+  }
+  _execStatements(e2, t2) {
+    for (const n2 of e2) {
+      if (n2 instanceof Array) {
+        const e4 = t2.clone(), s2 = this._execStatements(n2, e4);
+        if (s2) return s2;
+        continue;
+      }
+      const e3 = this.execStatement(n2, t2);
+      if (e3) return e3;
+    }
+    return null;
+  }
+  _call(e2, t2) {
+    const n2 = t2.clone();
+    n2.currentFunctionName = e2.name;
+    const s2 = t2.getFunction(e2.name);
+    if (s2) {
+      for (let t3 = 0; t3 < s2.node.args.length; ++t3) {
+        const r2 = s2.node.args[t3], a2 = this.evalExpression(e2.args[t3], n2);
+        n2.setVariable(r2.name, a2, r2);
+      }
+      this._execStatements(s2.node.body, n2);
+    } else if (e2.isBuiltin) this._callBuiltinFunction(e2, n2);
+    else {
+      this.getTypeInfo(e2.name) && this._evalCreate(e2, t2);
+    }
+  }
+  _increment(e2, t2) {
+    const n2 = this.getVariableName(e2.variable, t2), s2 = t2.getVariable(n2);
+    s2 ? "++" === e2.operator ? s2.value instanceof Be ? s2.value.value++ : console.error(`Variable ${n2} is not a scalar. Line ${e2.line}`) : "--" === e2.operator ? s2.value instanceof Be ? s2.value.value-- : console.error(`Variable ${n2} is not a scalar. Line ${e2.line}`) : console.error(`Unknown increment operator ${e2.operator}. Line ${e2.line}`) : console.error(`Variable ${n2} not found. Line ${e2.line}`);
+  }
+  _getVariableData(e2, t2) {
+    if (e2 instanceof ge) {
+      const n2 = this.getVariableName(e2, t2), s2 = t2.getVariable(n2);
+      return null === s2 ? (console.error(`Variable ${n2} not found. Line ${e2.line}`), null) : s2.value.getSubData(this, e2.postfix, t2);
+    }
+    if (e2 instanceof ke) {
+      if ("*" === e2.operator) {
+        const n2 = this._getVariableData(e2.right, t2);
+        return n2 instanceof Oe ? n2.reference.getSubData(this, e2.postfix, t2) : (console.error(`Variable ${e2.right} is not a pointer. Line ${e2.line}`), null);
+      }
+      if ("&" === e2.operator) {
+        const n2 = this._getVariableData(e2.right, t2);
+        return new Oe(n2);
+      }
+    }
+    return null;
+  }
+  _assign(e2, t2) {
+    let n2 = null, s2 = "<var>", r2 = null;
+    if (e2.variable instanceof ke) {
+      const n3 = this._getVariableData(e2.variable, t2), s3 = this.evalExpression(e2.value, t2), r3 = e2.operator;
+      if ("=" === r3) {
+        if (n3 instanceof Be || n3 instanceof Me || n3 instanceof Ue) {
+          if (s3 instanceof Be || s3 instanceof Me || s3 instanceof Ue && n3.data.length === s3.data.length) return void n3.data.set(s3.data);
+          console.error(`Invalid assignment. Line ${e2.line}`);
+        } else if (n3 instanceof Pe && s3 instanceof Pe && n3.buffer.byteLength - n3.offset >= s3.buffer.byteLength - s3.offset) return void (n3.buffer.byteLength % 4 == 0 ? new Uint32Array(n3.buffer, n3.offset, n3.typeInfo.size / 4).set(new Uint32Array(s3.buffer, s3.offset, s3.typeInfo.size / 4)) : new Uint8Array(n3.buffer, n3.offset, n3.typeInfo.size).set(new Uint8Array(s3.buffer, s3.offset, s3.typeInfo.size)));
+        return console.error(`Invalid assignment. Line ${e2.line}`), null;
+      }
+      if ("+=" === r3) return n3 instanceof Be || n3 instanceof Me || n3 instanceof Ue ? s3 instanceof Be || s3 instanceof Me || s3 instanceof Ue ? void n3.data.set(s3.data.map((e3, t3) => n3.data[t3] + e3)) : void console.error(`Invalid assignment . Line ${e2.line}`) : void console.error(`Invalid assignment. Line ${e2.line}`);
+      if ("-=" === r3) return (n3 instanceof Be || n3 instanceof Me || n3 instanceof Ue) && (s3 instanceof Be || s3 instanceof Me || s3 instanceof Ue) ? void n3.data.set(s3.data.map((e3, t3) => n3.data[t3] - e3)) : void console.error(`Invalid assignment. Line ${e2.line}`);
+    }
+    if (e2.variable instanceof ke) {
+      if ("*" === e2.variable.operator) {
+        s2 = this.getVariableName(e2.variable.right, t2);
+        const r3 = t2.getVariable(s2);
+        if (!(r3 && r3.value instanceof Oe)) return void console.error(`Variable ${s2} is not a pointer. Line ${e2.line}`);
+        n2 = r3.value.reference;
+        let a3 = e2.variable.postfix;
+        if (!a3) {
+          let t3 = e2.variable.right;
+          for (; t3 instanceof ke; ) {
+            if (t3.postfix) {
+              a3 = t3.postfix;
+              break;
+            }
+            t3 = t3.right;
+          }
+        }
+        a3 && (n2 = n2.getSubData(this, a3, t2));
+      }
+    } else {
+      r2 = e2.variable.postfix, s2 = this.getVariableName(e2.variable, t2);
+      const a3 = t2.getVariable(s2);
+      if (null === a3) return void console.error(`Variable ${s2} not found. Line ${e2.line}`);
+      n2 = a3.value;
+    }
+    if (n2 instanceof Oe && (n2 = n2.reference), null === n2) return void console.error(`Variable ${s2} not found. Line ${e2.line}`);
+    const a2 = this.evalExpression(e2.value, t2), i2 = e2.operator;
+    if ("=" !== i2) {
+      const s3 = n2.getSubData(this, r2, t2);
+      if (s3 instanceof Me && a2 instanceof Be) {
+        const t3 = s3.data, n3 = a2.value;
+        if ("+=" === i2) for (let e3 = 0; e3 < t3.length; ++e3) t3[e3] += n3;
+        else if ("-=" === i2) for (let e3 = 0; e3 < t3.length; ++e3) t3[e3] -= n3;
+        else if ("*=" === i2) for (let e3 = 0; e3 < t3.length; ++e3) t3[e3] *= n3;
+        else if ("/=" === i2) for (let e3 = 0; e3 < t3.length; ++e3) t3[e3] /= n3;
+        else if ("%=" === i2) for (let e3 = 0; e3 < t3.length; ++e3) t3[e3] %= n3;
+        else if ("&=" === i2) for (let e3 = 0; e3 < t3.length; ++e3) t3[e3] &= n3;
+        else if ("|=" === i2) for (let e3 = 0; e3 < t3.length; ++e3) t3[e3] |= n3;
+        else if ("^=" === i2) for (let e3 = 0; e3 < t3.length; ++e3) t3[e3] ^= n3;
+        else if ("<<=" === i2) for (let e3 = 0; e3 < t3.length; ++e3) t3[e3] <<= n3;
+        else if (">>=" === i2) for (let e3 = 0; e3 < t3.length; ++e3) t3[e3] >>= n3;
+        else console.error(`Invalid operator ${i2}. Line ${e2.line}`);
+      } else if (s3 instanceof Me && a2 instanceof Me) {
+        const t3 = s3.data, n3 = a2.data;
+        if (t3.length !== n3.length) return void console.error(`Vector length mismatch. Line ${e2.line}`);
+        if ("+=" === i2) for (let e3 = 0; e3 < t3.length; ++e3) t3[e3] += n3[e3];
+        else if ("-=" === i2) for (let e3 = 0; e3 < t3.length; ++e3) t3[e3] -= n3[e3];
+        else if ("*=" === i2) for (let e3 = 0; e3 < t3.length; ++e3) t3[e3] *= n3[e3];
+        else if ("/=" === i2) for (let e3 = 0; e3 < t3.length; ++e3) t3[e3] /= n3[e3];
+        else if ("%=" === i2) for (let e3 = 0; e3 < t3.length; ++e3) t3[e3] %= n3[e3];
+        else if ("&=" === i2) for (let e3 = 0; e3 < t3.length; ++e3) t3[e3] &= n3[e3];
+        else if ("|=" === i2) for (let e3 = 0; e3 < t3.length; ++e3) t3[e3] |= n3[e3];
+        else if ("^=" === i2) for (let e3 = 0; e3 < t3.length; ++e3) t3[e3] ^= n3[e3];
+        else if ("<<=" === i2) for (let e3 = 0; e3 < t3.length; ++e3) t3[e3] <<= n3[e3];
+        else if (">>=" === i2) for (let e3 = 0; e3 < t3.length; ++e3) t3[e3] >>= n3[e3];
+        else console.error(`Invalid operator ${i2}. Line ${e2.line}`);
+      } else {
+        if (!(s3 instanceof Be && a2 instanceof Be)) return void console.error(`Invalid type for ${e2.operator} operator. Line ${e2.line}`);
+        "+=" === i2 ? s3.value += a2.value : "-=" === i2 ? s3.value -= a2.value : "*=" === i2 ? s3.value *= a2.value : "/=" === i2 ? s3.value /= a2.value : "%=" === i2 ? s3.value %= a2.value : "&=" === i2 ? s3.value &= a2.value : "|=" === i2 ? s3.value |= a2.value : "^=" === i2 ? s3.value ^= a2.value : "<<=" === i2 ? s3.value <<= a2.value : ">>=" === i2 ? s3.value >>= a2.value : console.error(`Invalid operator ${i2}. Line ${e2.line}`);
+      }
+      return void (n2 instanceof Pe && n2.setDataValue(this, s3, r2, t2));
+    }
+    if (n2 instanceof Pe) n2.setDataValue(this, a2, r2, t2);
+    else if (r2) {
+      if (!(n2 instanceof Me || n2 instanceof Ue)) return void console.error(`Variable ${s2} is not a vector or matrix. Line ${e2.line}`);
+      if (r2 instanceof ve) {
+        const i3 = this.evalExpression(r2.index, t2).value;
+        if (n2 instanceof Me) {
+          if (!(a2 instanceof Be)) return void console.error(`Invalid assignment to ${s2}. Line ${e2.line}`);
+          n2.data[i3] = a2.value;
+        } else {
+          if (!(n2 instanceof Ue)) return void console.error(`Invalid assignment to ${s2}. Line ${e2.line}`);
+          {
+            const i4 = this.evalExpression(r2.index, t2).value;
+            if (i4 < 0) return void console.error(`Invalid assignment to ${s2}. Line ${e2.line}`);
+            if (!(a2 instanceof Me)) return void console.error(`Invalid assignment to ${s2}. Line ${e2.line}`);
+            {
+              const t3 = n2.typeInfo.getTypeName();
+              if ("mat2x2" === t3 || "mat2x2f" === t3 || "mat2x2h" === t3) {
+                if (!(i4 < 2 && 2 === a2.data.length)) return void console.error(`Invalid assignment to ${s2}. Line ${e2.line}`);
+                n2.data[2 * i4] = a2.data[0], n2.data[2 * i4 + 1] = a2.data[1];
+              } else if ("mat2x3" === t3 || "mat2x3f" === t3 || "mat2x3h" === t3) {
+                if (!(i4 < 2 && 3 === a2.data.length)) return void console.error(`Invalid assignment to ${s2}. Line ${e2.line}`);
+                n2.data[3 * i4] = a2.data[0], n2.data[3 * i4 + 1] = a2.data[1], n2.data[3 * i4 + 2] = a2.data[2];
+              } else if ("mat2x4" === t3 || "mat2x4f" === t3 || "mat2x4h" === t3) {
+                if (!(i4 < 2 && 4 === a2.data.length)) return void console.error(`Invalid assignment to ${s2}. Line ${e2.line}`);
+                n2.data[4 * i4] = a2.data[0], n2.data[4 * i4 + 1] = a2.data[1], n2.data[4 * i4 + 2] = a2.data[2], n2.data[4 * i4 + 3] = a2.data[3];
+              } else if ("mat3x2" === t3 || "mat3x2f" === t3 || "mat3x2h" === t3) {
+                if (!(i4 < 3 && 2 === a2.data.length)) return void console.error(`Invalid assignment to ${s2}. Line ${e2.line}`);
+                n2.data[2 * i4] = a2.data[0], n2.data[2 * i4 + 1] = a2.data[1];
+              } else if ("mat3x3" === t3 || "mat3x3f" === t3 || "mat3x3h" === t3) {
+                if (!(i4 < 3 && 3 === a2.data.length)) return void console.error(`Invalid assignment to ${s2}. Line ${e2.line}`);
+                n2.data[3 * i4] = a2.data[0], n2.data[3 * i4 + 1] = a2.data[1], n2.data[3 * i4 + 2] = a2.data[2];
+              } else if ("mat3x4" === t3 || "mat3x4f" === t3 || "mat3x4h" === t3) {
+                if (!(i4 < 3 && 4 === a2.data.length)) return void console.error(`Invalid assignment to ${s2}. Line ${e2.line}`);
+                n2.data[4 * i4] = a2.data[0], n2.data[4 * i4 + 1] = a2.data[1], n2.data[4 * i4 + 2] = a2.data[2], n2.data[4 * i4 + 3] = a2.data[3];
+              } else if ("mat4x2" === t3 || "mat4x2f" === t3 || "mat4x2h" === t3) {
+                if (!(i4 < 4 && 2 === a2.data.length)) return void console.error(`Invalid assignment to ${s2}. Line ${e2.line}`);
+                n2.data[2 * i4] = a2.data[0], n2.data[2 * i4 + 1] = a2.data[1];
+              } else if ("mat4x3" === t3 || "mat4x3f" === t3 || "mat4x3h" === t3) {
+                if (!(i4 < 4 && 3 === a2.data.length)) return void console.error(`Invalid assignment to ${s2}. Line ${e2.line}`);
+                n2.data[3 * i4] = a2.data[0], n2.data[3 * i4 + 1] = a2.data[1], n2.data[3 * i4 + 2] = a2.data[2];
+              } else {
+                if ("mat4x4" !== t3 && "mat4x4f" !== t3 && "mat4x4h" !== t3) return void console.error(`Invalid assignment to ${s2}. Line ${e2.line}`);
+                if (!(i4 < 4 && 4 === a2.data.length)) return void console.error(`Invalid assignment to ${s2}. Line ${e2.line}`);
+                n2.data[4 * i4] = a2.data[0], n2.data[4 * i4 + 1] = a2.data[1], n2.data[4 * i4 + 2] = a2.data[2], n2.data[4 * i4 + 3] = a2.data[3];
+              }
+            }
+          }
+        }
+      } else if (r2 instanceof pe) {
+        const t3 = r2.value;
+        if (!(n2 instanceof Me)) return void console.error(`Invalid assignment to ${t3}. Variable ${s2} is not a vector. Line ${e2.line}`);
+        if (a2 instanceof Be) {
+          if (t3.length > 1) return void console.error(`Invalid assignment to ${t3} for variable ${s2}. Line ${e2.line}`);
+          if ("x" === t3) n2.data[0] = a2.value;
+          else if ("y" === t3) {
+            if (n2.data.length < 2) return void console.error(`Invalid assignment to ${t3} for variable ${s2}. Line ${e2.line}`);
+            n2.data[1] = a2.value;
+          } else if ("z" === t3) {
+            if (n2.data.length < 3) return void console.error(`Invalid assignment to ${t3} for variable ${s2}. Line ${e2.line}`);
+            n2.data[2] = a2.value;
+          } else if ("w" === t3) {
+            if (n2.data.length < 4) return void console.error(`Invalid assignment to ${t3} for variable ${s2}. Line ${e2.line}`);
+            n2.data[3] = a2.value;
+          }
+        } else {
+          if (!(a2 instanceof Me)) return void console.error(`Invalid assignment to ${s2}. Line ${e2.line}`);
+          if (t3.length !== a2.data.length) return void console.error(`Invalid assignment to ${t3} for variable ${s2}. Line ${e2.line}`);
+          for (let r3 = 0; r3 < t3.length; ++r3) {
+            const i3 = t3[r3];
+            if ("x" === i3 || "r" === i3) n2.data[0] = a2.data[r3];
+            else if ("y" === i3 || "g" === i3) {
+              if (a2.data.length < 2) return void console.error(`Invalid assignment to ${i3} for variable ${s2}. Line ${e2.line}`);
+              n2.data[1] = a2.data[r3];
+            } else if ("z" === i3 || "b" === i3) {
+              if (a2.data.length < 3) return void console.error(`Invalid assignment to ${i3} for variable ${s2}. Line ${e2.line}`);
+              n2.data[2] = a2.data[r3];
+            } else {
+              if ("w" !== i3 && "a" !== i3) return void console.error(`Invalid assignment to ${i3} for variable ${s2}. Line ${e2.line}`);
+              if (a2.data.length < 4) return void console.error(`Invalid assignment to ${i3} for variable ${s2}. Line ${e2.line}`);
+              n2.data[3] = a2.data[r3];
+            }
+          }
+        }
+      }
+    } else n2 instanceof Be && a2 instanceof Be ? n2.value = a2.value : n2 instanceof Me && a2 instanceof Me || n2 instanceof Ue && a2 instanceof Ue ? n2.data.set(a2.data) : console.error(`Invalid assignment to ${s2}. Line ${e2.line}`);
+  }
+  _function(e2, t2) {
+    const n2 = new ct(e2);
+    t2.functions.set(e2.name, n2);
+  }
+  _const(e2, t2) {
+    let n2 = null;
+    null !== e2.value && (n2 = this.evalExpression(e2.value, t2)), t2.createVariable(e2.name, n2, e2);
+  }
+  _let(e2, t2) {
+    let n2 = null;
+    if (null !== e2.value) {
+      if (n2 = this.evalExpression(e2.value, t2), null === n2) return void console.error(`Invalid value for variable ${e2.name}. Line ${e2.line}`);
+      e2.value instanceof ke || (n2 = n2.clone());
+    } else {
+      const s2 = e2.type.name;
+      if ("f32" === s2 || "i32" === s2 || "u32" === s2 || "bool" === s2 || "f16" === s2 || "vec2" === s2 || "vec3" === s2 || "vec4" === s2 || "vec2f" === s2 || "vec3f" === s2 || "vec4f" === s2 || "vec2i" === s2 || "vec3i" === s2 || "vec4i" === s2 || "vec2u" === s2 || "vec3u" === s2 || "vec4u" === s2 || "vec2h" === s2 || "vec3h" === s2 || "vec4h" === s2 || "vec2b" === s2 || "vec3b" === s2 || "vec4b" === s2 || "mat2x2" === s2 || "mat2x3" === s2 || "mat2x4" === s2 || "mat3x2" === s2 || "mat3x3" === s2 || "mat3x4" === s2 || "mat4x2" === s2 || "mat4x3" === s2 || "mat4x4" === s2 || "mat2x2f" === s2 || "mat2x3f" === s2 || "mat2x4f" === s2 || "mat3x2f" === s2 || "mat3x3f" === s2 || "mat3x4f" === s2 || "mat4x2f" === s2 || "mat4x3f" === s2 || "mat4x4f" === s2 || "mat2x2h" === s2 || "mat2x3h" === s2 || "mat2x4h" === s2 || "mat3x2h" === s2 || "mat3x3h" === s2 || "mat3x4h" === s2 || "mat4x2h" === s2 || "mat4x3h" === s2 || "mat4x4h" === s2 || "array" === s2) {
+        const s3 = new de(e2.type, []);
+        n2 = this._evalCreate(s3, t2);
+      }
+    }
+    t2.createVariable(e2.name, n2, e2);
+  }
+  _var(e2, t2) {
+    let n2 = null;
+    if (null !== e2.value) {
+      if (n2 = this.evalExpression(e2.value, t2), null === n2) return void console.error(`Invalid value for variable ${e2.name}. Line ${e2.line}`);
+      e2.value instanceof ke || (n2 = n2.clone());
+    } else {
+      if (null === e2.type) return void console.error(`Variable ${e2.name} has no type. Line ${e2.line}`);
+      const s2 = e2.type.name;
+      if ("f32" === s2 || "i32" === s2 || "u32" === s2 || "bool" === s2 || "f16" === s2 || "vec2" === s2 || "vec3" === s2 || "vec4" === s2 || "vec2f" === s2 || "vec3f" === s2 || "vec4f" === s2 || "vec2i" === s2 || "vec3i" === s2 || "vec4i" === s2 || "vec2u" === s2 || "vec3u" === s2 || "vec4u" === s2 || "vec2h" === s2 || "vec3h" === s2 || "vec4h" === s2 || "vec2b" === s2 || "vec3b" === s2 || "vec4b" === s2 || "mat2x2" === s2 || "mat2x3" === s2 || "mat2x4" === s2 || "mat3x2" === s2 || "mat3x3" === s2 || "mat3x4" === s2 || "mat4x2" === s2 || "mat4x3" === s2 || "mat4x4" === s2 || "mat2x2f" === s2 || "mat2x3f" === s2 || "mat2x4f" === s2 || "mat3x2f" === s2 || "mat3x3f" === s2 || "mat3x4f" === s2 || "mat4x2f" === s2 || "mat4x3f" === s2 || "mat4x4f" === s2 || "mat2x2h" === s2 || "mat2x3h" === s2 || "mat2x4h" === s2 || "mat3x2h" === s2 || "mat3x3h" === s2 || "mat3x4h" === s2 || "mat4x2h" === s2 || "mat4x3h" === s2 || "mat4x4h" === s2 || e2.type instanceof ue || e2.type instanceof oe || e2.type instanceof ce) {
+        const s3 = new de(e2.type, []);
+        n2 = this._evalCreate(s3, t2);
+      }
+    }
+    t2.createVariable(e2.name, n2, e2);
+  }
+  _switch(e2, t2) {
+    t2 = t2.clone();
+    const n2 = this.evalExpression(e2.condition, t2);
+    if (!(n2 instanceof Be)) return console.error(`Invalid if condition. Line ${e2.line}`), null;
+    let s2 = null;
+    for (const r2 of e2.cases) if (r2 instanceof Ae) for (const a2 of r2.selectors) {
+      if (a2 instanceof Se) {
+        s2 = r2;
+        continue;
+      }
+      const i2 = this.evalExpression(a2, t2);
+      if (!(i2 instanceof Be)) return console.error(`Invalid case selector. Line ${e2.line}`), null;
+      if (i2.value === n2.value) return this._execStatements(r2.body, t2);
+    }
+    else r2 instanceof Ee && (s2 = r2);
+    return s2 ? this._execStatements(s2.body, t2) : null;
+  }
+  _if(e2, t2) {
+    t2 = t2.clone();
+    const n2 = this.evalExpression(e2.condition, t2);
+    if (!(n2 instanceof Be)) return console.error(`Invalid if condition. Line ${e2.line}`), null;
+    if (n2.value) return this._execStatements(e2.body, t2);
+    for (const n3 of e2.elseif) {
+      const s2 = this.evalExpression(n3.condition, t2);
+      if (!(s2 instanceof Be)) return console.error(`Invalid if condition. Line ${e2.line}`), null;
+      if (s2.value) return this._execStatements(n3.body, t2);
+    }
+    return e2.else ? this._execStatements(e2.else, t2) : null;
+  }
+  _getScalarValue(e2) {
+    return e2 instanceof Be ? e2.value : (console.error("Expected scalar value.", e2), 0);
+  }
+  _for(e2, t2) {
+    for (t2 = t2.clone(), this.execStatement(e2.init, t2); this._getScalarValue(this.evalExpression(e2.condition, t2)); ) {
+      const n2 = this._execStatements(e2.body, t2);
+      if (n2 === dt._breakObj) break;
+      if (null !== n2 && n2 !== dt._continueObj) return n2;
+      this.execStatement(e2.increment, t2);
+    }
+    return null;
+  }
+  _loop(e2, t2) {
+    for (t2 = t2.clone(); ; ) {
+      const n2 = this._execStatements(e2.body, t2);
+      if (n2 === dt._breakObj) break;
+      if (n2 === dt._continueObj) {
+        if (e2.continuing) {
+          if (this._execStatements(e2.continuing.body, t2) === dt._breakObj) break;
+        }
+      } else if (null !== n2) return n2;
+    }
+    return null;
+  }
+  _while(e2, t2) {
+    for (t2 = t2.clone(); this._getScalarValue(this.evalExpression(e2.condition, t2)); ) {
+      const n2 = this._execStatements(e2.body, t2);
+      if (n2 === dt._breakObj) break;
+      if (n2 !== dt._continueObj && null !== n2) return n2;
+    }
+    return null;
+  }
+  _evalBitcast(e2, t2) {
+    const n2 = this.evalExpression(e2.value, t2), s2 = e2.type;
+    if (n2 instanceof Be) {
+      const e3 = nt(n2.value, n2.typeInfo.name, s2.name);
+      return new Be(e3, this.getTypeInfo(s2));
+    }
+    if (n2 instanceof Me) {
+      const t3 = n2.typeInfo.getTypeName();
+      let r2 = "";
+      if (t3.endsWith("f")) r2 = "f32";
+      else if (t3.endsWith("i")) r2 = "i32";
+      else if (t3.endsWith("u")) r2 = "u32";
+      else if (t3.endsWith("b")) r2 = "bool";
+      else {
+        if (!t3.endsWith("h")) return console.error(`Unknown vector type ${t3}. Line ${e2.line}`), null;
+        r2 = "f16";
+      }
+      const a2 = s2.getTypeName();
+      let i2 = "";
+      if (a2.endsWith("f")) i2 = "f32";
+      else if (a2.endsWith("i")) i2 = "i32";
+      else if (a2.endsWith("u")) i2 = "u32";
+      else if (a2.endsWith("b")) i2 = "bool";
+      else {
+        if (!a2.endsWith("h")) return console.error(`Unknown vector type ${i2}. Line ${e2.line}`), null;
+        i2 = "f16";
+      }
+      const o2 = function(e3, t4, n3) {
+        if (t4 === n3) return e3;
+        const s3 = new Array(e3.length);
+        for (let r3 = 0; r3 < e3.length; r3++) s3[r3] = nt(e3[r3], t4, n3);
+        return s3;
+      }(Array.from(n2.data), r2, i2);
+      return new Me(o2, this.getTypeInfo(s2));
+    }
+    return console.error(`TODO: bitcast for ${n2.typeInfo.name}. Line ${e2.line}`), null;
+  }
+  _evalConst(e2, t2) {
+    return t2.getVariableValue(e2.name).clone().getSubData(this, e2.postfix, t2);
+  }
+  _evalCreate(e2, t2) {
+    var r2;
+    if (e2 instanceof de) {
+      if (null === e2.type) return Ve.void;
+      switch (e2.type.getTypeName()) {
+        case "bool":
+        case "i32":
+        case "u32":
+        case "f32":
+        case "f16":
+          return this._callConstructorValue(e2, t2);
+        case "vec2":
+        case "vec3":
+        case "vec4":
+        case "vec2f":
+        case "vec3f":
+        case "vec4f":
+        case "vec2h":
+        case "vec3h":
+        case "vec4h":
+        case "vec2i":
+        case "vec3i":
+        case "vec4i":
+        case "vec2u":
+        case "vec3u":
+        case "vec4u":
+        case "vec2b":
+        case "vec3b":
+        case "vec4b":
+          return this._callConstructorVec(e2, t2);
+        case "mat2x2":
+        case "mat2x2f":
+        case "mat2x2h":
+        case "mat2x3":
+        case "mat2x3f":
+        case "mat2x3h":
+        case "mat2x4":
+        case "mat2x4f":
+        case "mat2x4h":
+        case "mat3x2":
+        case "mat3x2f":
+        case "mat3x2h":
+        case "mat3x3":
+        case "mat3x3f":
+        case "mat3x3h":
+        case "mat3x4":
+        case "mat3x4f":
+        case "mat3x4h":
+        case "mat4x2":
+        case "mat4x2f":
+        case "mat4x2h":
+        case "mat4x3":
+        case "mat4x3f":
+        case "mat4x3h":
+        case "mat4x4":
+        case "mat4x4f":
+        case "mat4x4h":
+          return this._callConstructorMatrix(e2, t2);
+      }
+    }
+    const a2 = e2 instanceof de ? e2.type.name : e2.name, i2 = e2 instanceof de ? this.getTypeInfo(e2.type) : this.getTypeInfo(e2.name);
+    if (null === i2) return console.error(`Unknown type ${a2}. Line ${e2.line}`), null;
+    if (0 === i2.size) return null;
+    const o2 = new Pe(new ArrayBuffer(i2.size), i2, 0);
+    if (i2 instanceof n) {
+      if (e2.args) for (let n2 = 0; n2 < e2.args.length; ++n2) {
+        const s2 = i2.members[n2], r3 = e2.args[n2], a3 = this.evalExpression(r3, t2);
+        o2.setData(this, a3, s2.type, s2.offset, t2);
+      }
+    } else if (i2 instanceof s) {
+      let n2 = 0;
+      if (e2.args) for (let s2 = 0; s2 < e2.args.length; ++s2) {
+        const a3 = e2.args[s2], c2 = this.evalExpression(a3, t2);
+        null === i2.format && ("x32" === (null === (r2 = c2.typeInfo) || void 0 === r2 ? void 0 : r2.name) ? i2.format = this.getTypeInfo("i32") : i2.format = c2.typeInfo), o2.setData(this, c2, i2.format, n2, t2), n2 += i2.stride;
+      }
+    } else console.error(`Unknown type "${a2}". Line ${e2.line}`);
+    return e2 instanceof de ? o2.getSubData(this, e2.postfix, t2) : o2;
+  }
+  _evalLiteral(e2, t2) {
+    const n2 = this.getTypeInfo(e2.type), s2 = n2.name;
+    if ("x32" === s2 || "u32" === s2 || "f32" === s2 || "f16" === s2 || "i32" === s2 || "bool" === s2) {
+      return new Be(e2.scalarValue, n2);
+    }
+    return "vec2" === s2 || "vec3" === s2 || "vec4" === s2 || "vec2f" === s2 || "vec3f" === s2 || "vec4f" === s2 || "vec2h" === s2 || "vec3h" === s2 || "vec4h" === s2 || "vec2i" === s2 || "vec3i" === s2 || "vec4i" === s2 || "vec2u" === s2 || "vec3u" === s2 || "vec4u" === s2 ? this._callConstructorVec(e2, t2) : "mat2x2" === s2 || "mat2x3" === s2 || "mat2x4" === s2 || "mat3x2" === s2 || "mat3x3" === s2 || "mat3x4" === s2 || "mat4x2" === s2 || "mat4x3" === s2 || "mat4x4" === s2 || "mat2x2f" === s2 || "mat2x3f" === s2 || "mat2x4f" === s2 || "mat3x2f" === s2 || "mat3x3f" === s2 || "mat3x4f" === s2 || "mat4x2f" === s2 || "mat4x3f" === s2 || "mat4x4f" === s2 || "mat2x2h" === s2 || "mat2x3h" === s2 || "mat2x4h" === s2 || "mat3x2h" === s2 || "mat3x3h" === s2 || "mat3x4h" === s2 || "mat4x2h" === s2 || "mat4x3h" === s2 || "mat4x4h" === s2 ? this._callConstructorMatrix(e2, t2) : e2.value;
+  }
+  _evalVariable(e2, t2) {
+    const n2 = t2.getVariableValue(e2.name);
+    return null === n2 ? n2 : n2.getSubData(this, e2.postfix, t2);
+  }
+  _maxFormatTypeInfo(e2) {
+    let t2 = e2[0];
+    if ("f32" === t2.name) return t2;
+    for (let n2 = 1; n2 < e2.length; ++n2) {
+      const s2 = dt._priority.get(t2.name);
+      dt._priority.get(e2[n2].name) < s2 && (t2 = e2[n2]);
+    }
+    return "x32" === t2.name ? this.getTypeInfo("i32") : t2;
+  }
+  _evalUnaryOp(e2, t2) {
+    const n2 = this.evalExpression(e2.right, t2);
+    if ("&" === e2.operator) return new Oe(n2);
+    if ("*" === e2.operator) return n2 instanceof Oe ? n2.reference.getSubData(this, e2.postfix, t2) : (console.error(`Invalid dereference. Line ${e2.line}`), null);
+    const s2 = n2 instanceof Be ? n2.value : n2 instanceof Me ? Array.from(n2.data) : null;
+    switch (e2.operator) {
+      case "+": {
+        if (Ge(s2)) {
+          const e4 = s2.map((e5, t4) => +e5);
+          return new Me(e4, n2.typeInfo);
+        }
+        const e3 = s2, t3 = this._maxFormatTypeInfo([n2.typeInfo, n2.typeInfo]);
+        return new Be(+e3, t3);
+      }
+      case "-": {
+        if (Ge(s2)) {
+          const e4 = s2.map((e5, t4) => -e5);
+          return new Me(e4, n2.typeInfo);
+        }
+        const e3 = s2, t3 = this._maxFormatTypeInfo([n2.typeInfo, n2.typeInfo]);
+        return new Be(-e3, t3);
+      }
+      case "!": {
+        if (Ge(s2)) {
+          const e4 = s2.map((e5, t4) => e5 ? 0 : 1);
+          return new Me(e4, n2.typeInfo);
+        }
+        const e3 = s2, t3 = this._maxFormatTypeInfo([n2.typeInfo, n2.typeInfo]);
+        return new Be(e3 ? 0 : 1, t3);
+      }
+      case "~": {
+        if (Ge(s2)) {
+          const e4 = s2.map((e5, t4) => ~e5);
+          return new Me(e4, n2.typeInfo);
+        }
+        const e3 = s2, t3 = this._maxFormatTypeInfo([n2.typeInfo, n2.typeInfo]);
+        return new Be(~e3, t3);
+      }
+    }
+    return console.error(`Invalid unary operator ${e2.operator}. Line ${e2.line}`), null;
+  }
+  _evalBinaryOp(e2, t2) {
+    const n2 = this.evalExpression(e2.left, t2), s2 = this.evalExpression(e2.right, t2), r2 = n2 instanceof Be ? n2.value : n2 instanceof Me || n2 instanceof Ue ? Array.from(n2.data) : null, a2 = s2 instanceof Be ? s2.value : s2 instanceof Me || s2 instanceof Ue ? Array.from(s2.data) : null;
+    switch (e2.operator) {
+      case "+": {
+        if (Ge(r2) && Ge(a2)) {
+          const t4 = r2, s3 = a2;
+          if (t4.length !== s3.length) return console.error(`Vector length mismatch. Line ${e2.line}.`), null;
+          const i3 = t4.map((e3, t5) => e3 + s3[t5]);
+          return new Me(i3, n2.typeInfo);
+        }
+        if (Ge(r2)) {
+          const e3 = a2, t4 = r2.map((t5, n3) => t5 + e3);
+          return new Me(t4, n2.typeInfo);
+        }
+        if (Ge(a2)) {
+          const e3 = r2, t4 = a2.map((t5, n3) => e3 + t5);
+          return new Me(t4, s2.typeInfo);
+        }
+        const t3 = r2, i2 = a2, o2 = this._maxFormatTypeInfo([n2.typeInfo, s2.typeInfo]);
+        return new Be(t3 + i2, o2);
+      }
+      case "-": {
+        if (Ge(r2) && Ge(a2)) {
+          const t4 = r2, s3 = a2;
+          if (t4.length !== s3.length) return console.error(`Vector length mismatch. Line ${e2.line}.`), null;
+          const i3 = t4.map((e3, t5) => e3 - s3[t5]);
+          return new Me(i3, n2.typeInfo);
+        }
+        if (Ge(r2)) {
+          const e3 = a2, t4 = r2.map((t5, n3) => t5 - e3);
+          return new Me(t4, n2.typeInfo);
+        }
+        if (Ge(a2)) {
+          const e3 = r2, t4 = a2.map((t5, n3) => e3 - t5);
+          return new Me(t4, s2.typeInfo);
+        }
+        const t3 = r2, i2 = a2, o2 = this._maxFormatTypeInfo([n2.typeInfo, s2.typeInfo]);
+        return new Be(t3 - i2, o2);
+      }
+      case "*": {
+        if (Ge(r2) && Ge(a2)) {
+          const t4 = r2, i3 = a2;
+          if (n2 instanceof Ue && s2 instanceof Ue) {
+            const r3 = function(e3, t5, n3, s3) {
+              if (void 0 === pt[t5.name] || void 0 === pt[s3.name]) return null;
+              const r4 = pt[t5.name][0], a4 = pt[t5.name][1], i4 = pt[s3.name][0];
+              if (r4 !== pt[s3.name][1]) return null;
+              const o4 = new Array(i4 * a4);
+              for (let t6 = 0; t6 < a4; t6++) for (let s4 = 0; s4 < i4; s4++) {
+                let c3 = 0;
+                for (let i5 = 0; i5 < r4; i5++) c3 += e3[i5 * a4 + t6] * n3[s4 * r4 + i5];
+                o4[t6 * i4 + s4] = c3;
+              }
+              return o4;
+            }(t4, n2.typeInfo, i3, s2.typeInfo);
+            if (null === r3) return console.error(`Matrix multiplication failed. Line ${e2.line}.`), null;
+            const a3 = pt[s2.typeInfo.name][0], o3 = pt[n2.typeInfo.name][1], c2 = this.getTypeInfo(`mat${a3}x${o3}f`);
+            return new Ue(r3, c2);
+          }
+          if (n2 instanceof Ue && s2 instanceof Me) {
+            const r3 = function(e3, t5, n3, s3) {
+              if (void 0 === pt[t5.name] || void 0 === ft[s3.name]) return null;
+              const r4 = pt[t5.name][0], a3 = pt[t5.name][1];
+              if (r4 !== n3.length) return null;
+              const i4 = new Array(a3);
+              for (let t6 = 0; t6 < a3; t6++) {
+                let s4 = 0;
+                for (let i5 = 0; i5 < r4; i5++) s4 += e3[i5 * a3 + t6] * n3[i5];
+                i4[t6] = s4;
+              }
+              return i4;
+            }(t4, n2.typeInfo, i3, s2.typeInfo);
+            return null === r3 ? (console.error(`Matrix vector multiplication failed. Line ${e2.line}.`), null) : new Me(r3, s2.typeInfo);
+          }
+          if (n2 instanceof Me && s2 instanceof Ue) {
+            const r3 = function(e3, t5, n3, s3) {
+              if (void 0 === ft[t5.name] || void 0 === pt[s3.name]) return null;
+              const r4 = pt[s3.name][0], a3 = pt[s3.name][1];
+              if (a3 !== e3.length) return null;
+              const i4 = [];
+              for (let t6 = 0; t6 < r4; t6++) {
+                let s4 = 0;
+                for (let i5 = 0; i5 < a3; i5++) s4 += e3[i5] * n3[i5 * r4 + t6];
+                i4[t6] = s4;
+              }
+              return i4;
+            }(t4, n2.typeInfo, i3, s2.typeInfo);
+            return null === r3 ? (console.error(`Matrix vector multiplication failed. Line ${e2.line}.`), null) : new Me(r3, n2.typeInfo);
+          }
+          {
+            if (t4.length !== i3.length) return console.error(`Vector length mismatch. Line ${e2.line}.`), null;
+            const s3 = t4.map((e3, t5) => e3 * i3[t5]);
+            return new Me(s3, n2.typeInfo);
+          }
+        }
+        if (Ge(r2)) {
+          const e3 = a2, t4 = r2.map((t5, n3) => t5 * e3);
+          return n2 instanceof Ue ? new Ue(t4, n2.typeInfo) : new Me(t4, n2.typeInfo);
+        }
+        if (Ge(a2)) {
+          const e3 = r2, t4 = a2.map((t5, n3) => e3 * t5);
+          return s2 instanceof Ue ? new Ue(t4, s2.typeInfo) : new Me(t4, s2.typeInfo);
+        }
+        const t3 = r2, i2 = a2, o2 = this._maxFormatTypeInfo([n2.typeInfo, s2.typeInfo]);
+        return new Be(t3 * i2, o2);
+      }
+      case "%": {
+        if (Ge(r2) && Ge(a2)) {
+          const t4 = r2, s3 = a2;
+          if (t4.length !== s3.length) return console.error(`Vector length mismatch. Line ${e2.line}.`), null;
+          const i3 = t4.map((e3, t5) => e3 % s3[t5]);
+          return new Me(i3, n2.typeInfo);
+        }
+        if (Ge(r2)) {
+          const e3 = a2, t4 = r2.map((t5, n3) => t5 % e3);
+          return new Me(t4, n2.typeInfo);
+        }
+        if (Ge(a2)) {
+          const e3 = r2, t4 = a2.map((t5, n3) => e3 % t5);
+          return new Me(t4, s2.typeInfo);
+        }
+        const t3 = r2, i2 = a2, o2 = this._maxFormatTypeInfo([n2.typeInfo, s2.typeInfo]);
+        return new Be(t3 % i2, o2);
+      }
+      case "/": {
+        if (Ge(r2) && Ge(a2)) {
+          const t4 = r2, s3 = a2;
+          if (t4.length !== s3.length) return console.error(`Vector length mismatch. Line ${e2.line}.`), null;
+          const i3 = t4.map((e3, t5) => e3 / s3[t5]);
+          return new Me(i3, n2.typeInfo);
+        }
+        if (Ge(r2)) {
+          const e3 = a2, t4 = r2.map((t5, n3) => t5 / e3);
+          return new Me(t4, n2.typeInfo);
+        }
+        if (Ge(a2)) {
+          const e3 = r2, t4 = a2.map((t5, n3) => e3 / t5);
+          return new Me(t4, s2.typeInfo);
+        }
+        const t3 = r2, i2 = a2, o2 = this._maxFormatTypeInfo([n2.typeInfo, s2.typeInfo]);
+        return new Be(t3 / i2, o2);
+      }
+      case "&": {
+        if (Ge(r2) && Ge(a2)) {
+          const t4 = r2, s3 = a2;
+          if (t4.length !== s3.length) return console.error(`Vector length mismatch. Line ${e2.line}.`), null;
+          const i3 = t4.map((e3, t5) => e3 & s3[t5]);
+          return new Me(i3, n2.typeInfo);
+        }
+        if (Ge(r2)) {
+          const e3 = a2, t4 = r2.map((t5, n3) => t5 & e3);
+          return new Me(t4, n2.typeInfo);
+        }
+        if (Ge(a2)) {
+          const e3 = r2, t4 = a2.map((t5, n3) => e3 & t5);
+          return new Me(t4, s2.typeInfo);
+        }
+        const t3 = r2, i2 = a2, o2 = this._maxFormatTypeInfo([n2.typeInfo, s2.typeInfo]);
+        return new Be(t3 & i2, o2);
+      }
+      case "|": {
+        if (Ge(r2) && Ge(a2)) {
+          const t4 = r2, s3 = a2;
+          if (t4.length !== s3.length) return console.error(`Vector length mismatch. Line ${e2.line}.`), null;
+          const i3 = t4.map((e3, t5) => e3 | s3[t5]);
+          return new Me(i3, n2.typeInfo);
+        }
+        if (Ge(r2)) {
+          const e3 = a2, t4 = r2.map((t5, n3) => t5 | e3);
+          return new Me(t4, n2.typeInfo);
+        }
+        if (Ge(a2)) {
+          const e3 = r2, t4 = a2.map((t5, n3) => e3 | t5);
+          return new Me(t4, s2.typeInfo);
+        }
+        const t3 = r2, i2 = a2, o2 = this._maxFormatTypeInfo([n2.typeInfo, s2.typeInfo]);
+        return new Be(t3 | i2, o2);
+      }
+      case "^": {
+        if (Ge(r2) && Ge(a2)) {
+          const t4 = r2, s3 = a2;
+          if (t4.length !== s3.length) return console.error(`Vector length mismatch. Line ${e2.line}.`), null;
+          const i3 = t4.map((e3, t5) => e3 ^ s3[t5]);
+          return new Me(i3, n2.typeInfo);
+        }
+        if (Ge(r2)) {
+          const e3 = a2, t4 = r2.map((t5, n3) => t5 ^ e3);
+          return new Me(t4, n2.typeInfo);
+        }
+        if (Ge(a2)) {
+          const e3 = r2, t4 = a2.map((t5, n3) => e3 ^ t5);
+          return new Me(t4, s2.typeInfo);
+        }
+        const t3 = r2, i2 = a2, o2 = this._maxFormatTypeInfo([n2.typeInfo, s2.typeInfo]);
+        return new Be(t3 ^ i2, o2);
+      }
+      case "<<": {
+        if (Ge(r2) && Ge(a2)) {
+          const t4 = r2, s3 = a2;
+          if (t4.length !== s3.length) return console.error(`Vector length mismatch. Line ${e2.line}.`), null;
+          const i3 = t4.map((e3, t5) => e3 << s3[t5]);
+          return new Me(i3, n2.typeInfo);
+        }
+        if (Ge(r2)) {
+          const e3 = a2, t4 = r2.map((t5, n3) => t5 << e3);
+          return new Me(t4, n2.typeInfo);
+        }
+        if (Ge(a2)) {
+          const e3 = r2, t4 = a2.map((t5, n3) => e3 << t5);
+          return new Me(t4, s2.typeInfo);
+        }
+        const t3 = r2, i2 = a2, o2 = this._maxFormatTypeInfo([n2.typeInfo, s2.typeInfo]);
+        return new Be(t3 << i2, o2);
+      }
+      case ">>": {
+        if (Ge(r2) && Ge(a2)) {
+          const t4 = r2, s3 = a2;
+          if (t4.length !== s3.length) return console.error(`Vector length mismatch. Line ${e2.line}.`), null;
+          const i3 = t4.map((e3, t5) => e3 >> s3[t5]);
+          return new Me(i3, n2.typeInfo);
+        }
+        if (Ge(r2)) {
+          const e3 = a2, t4 = r2.map((t5, n3) => t5 >> e3);
+          return new Me(t4, n2.typeInfo);
+        }
+        if (Ge(a2)) {
+          const e3 = r2, t4 = a2.map((t5, n3) => e3 >> t5);
+          return new Me(t4, s2.typeInfo);
+        }
+        const t3 = r2, i2 = a2, o2 = this._maxFormatTypeInfo([n2.typeInfo, s2.typeInfo]);
+        return new Be(t3 >> i2, o2);
+      }
+      case ">":
+        if (Ge(r2) && Ge(a2)) {
+          const t3 = r2, s3 = a2;
+          if (t3.length !== s3.length) return console.error(`Vector length mismatch. Line ${e2.line}.`), null;
+          const i2 = t3.map((e3, t4) => e3 > s3[t4] ? 1 : 0);
+          return new Me(i2, n2.typeInfo);
+        }
+        if (Ge(r2)) {
+          const e3 = a2, t3 = r2.map((t4, n3) => t4 > e3 ? 1 : 0);
+          return new Me(t3, n2.typeInfo);
+        }
+        if (Ge(a2)) {
+          const e3 = r2, t3 = a2.map((t4, n3) => e3 > t4 ? 1 : 0);
+          return new Me(t3, s2.typeInfo);
+        }
+        return new Be(r2 > a2 ? 1 : 0, this.getTypeInfo("bool"));
+      case "<":
+        if (Ge(r2) && Ge(a2)) {
+          const t3 = r2, s3 = a2;
+          if (t3.length !== s3.length) return console.error(`Vector length mismatch. Line ${e2.line}.`), null;
+          const i2 = t3.map((e3, t4) => e3 < s3[t4] ? 1 : 0);
+          return new Me(i2, n2.typeInfo);
+        }
+        if (Ge(r2)) {
+          const e3 = a2, t3 = r2.map((t4, n3) => t4 < e3 ? 1 : 0);
+          return new Me(t3, n2.typeInfo);
+        }
+        if (Ge(a2)) {
+          const e3 = r2, t3 = a2.map((t4, n3) => e3 < t4 ? 1 : 0);
+          return new Me(t3, s2.typeInfo);
+        }
+        return new Be(r2 < a2 ? 1 : 0, this.getTypeInfo("bool"));
+      case "==":
+        if (Ge(r2) && Ge(a2)) {
+          const t3 = r2, s3 = a2;
+          if (t3.length !== s3.length) return console.error(`Vector length mismatch. Line ${e2.line}.`), null;
+          const i2 = t3.map((e3, t4) => e3 === s3[t4] ? 1 : 0);
+          return new Me(i2, n2.typeInfo);
+        }
+        if (Ge(r2)) {
+          const e3 = a2, t3 = r2.map((t4, n3) => t4 == e3 ? 1 : 0);
+          return new Me(t3, n2.typeInfo);
+        }
+        if (Ge(a2)) {
+          const e3 = r2, t3 = a2.map((t4, n3) => e3 == t4 ? 1 : 0);
+          return new Me(t3, s2.typeInfo);
+        }
+        return new Be(r2 === a2 ? 1 : 0, this.getTypeInfo("bool"));
+      case "!=":
+        if (Ge(r2) && Ge(a2)) {
+          const t3 = r2, s3 = a2;
+          if (t3.length !== s3.length) return console.error(`Vector length mismatch. Line ${e2.line}.`), null;
+          const i2 = t3.map((e3, t4) => e3 !== s3[t4] ? 1 : 0);
+          return new Me(i2, n2.typeInfo);
+        }
+        if (Ge(r2)) {
+          const e3 = a2, t3 = r2.map((t4, n3) => t4 !== e3 ? 1 : 0);
+          return new Me(t3, n2.typeInfo);
+        }
+        if (Ge(a2)) {
+          const e3 = r2, t3 = a2.map((t4, n3) => e3 !== t4 ? 1 : 0);
+          return new Me(t3, s2.typeInfo);
+        }
+        return new Be(r2 !== a2 ? 1 : 0, this.getTypeInfo("bool"));
+      case ">=":
+        if (Ge(r2) && Ge(a2)) {
+          const t3 = r2, s3 = a2;
+          if (t3.length !== s3.length) return console.error(`Vector length mismatch. Line ${e2.line}.`), null;
+          const i2 = t3.map((e3, t4) => e3 >= s3[t4] ? 1 : 0);
+          return new Me(i2, n2.typeInfo);
+        }
+        if (Ge(r2)) {
+          const e3 = a2, t3 = r2.map((t4, n3) => t4 >= e3 ? 1 : 0);
+          return new Me(t3, n2.typeInfo);
+        }
+        if (Ge(a2)) {
+          const e3 = r2, t3 = a2.map((t4, n3) => e3 >= t4 ? 1 : 0);
+          return new Me(t3, s2.typeInfo);
+        }
+        return new Be(r2 >= a2 ? 1 : 0, this.getTypeInfo("bool"));
+      case "<=":
+        if (Ge(r2) && Ge(a2)) {
+          const t3 = r2, s3 = a2;
+          if (t3.length !== s3.length) return console.error(`Vector length mismatch. Line ${e2.line}.`), null;
+          const i2 = t3.map((e3, t4) => e3 <= s3[t4] ? 1 : 0);
+          return new Me(i2, n2.typeInfo);
+        }
+        if (Ge(r2)) {
+          const e3 = a2, t3 = r2.map((t4, n3) => t4 <= e3 ? 1 : 0);
+          return new Me(t3, n2.typeInfo);
+        }
+        if (Ge(a2)) {
+          const e3 = r2, t3 = a2.map((t4, n3) => e3 <= t4 ? 1 : 0);
+          return new Me(t3, s2.typeInfo);
+        }
+        return new Be(r2 <= a2 ? 1 : 0, this.getTypeInfo("bool"));
+      case "&&":
+        if (Ge(r2) && Ge(a2)) {
+          const t3 = r2, s3 = a2;
+          if (t3.length !== s3.length) return console.error(`Vector length mismatch. Line ${e2.line}.`), null;
+          const i2 = t3.map((e3, t4) => e3 && s3[t4] ? 1 : 0);
+          return new Me(i2, n2.typeInfo);
+        }
+        if (Ge(r2)) {
+          const e3 = a2, t3 = r2.map((t4, n3) => t4 && e3 ? 1 : 0);
+          return new Me(t3, n2.typeInfo);
+        }
+        if (Ge(a2)) {
+          const e3 = r2, t3 = a2.map((t4, n3) => e3 && t4 ? 1 : 0);
+          return new Me(t3, s2.typeInfo);
+        }
+        return new Be(r2 && a2 ? 1 : 0, this.getTypeInfo("bool"));
+      case "||":
+        if (Ge(r2) && Ge(a2)) {
+          const t3 = r2, s3 = a2;
+          if (t3.length !== s3.length) return console.error(`Vector length mismatch. Line ${e2.line}.`), null;
+          const i2 = t3.map((e3, t4) => e3 || s3[t4] ? 1 : 0);
+          return new Me(i2, n2.typeInfo);
+        }
+        if (Ge(r2)) {
+          const e3 = a2, t3 = r2.map((t4, n3) => t4 || e3 ? 1 : 0);
+          return new Me(t3, n2.typeInfo);
+        }
+        if (Ge(a2)) {
+          const e3 = r2, t3 = a2.map((t4, n3) => e3 || t4 ? 1 : 0);
+          return new Me(t3, s2.typeInfo);
+        }
+        return new Be(r2 || a2 ? 1 : 0, this.getTypeInfo("bool"));
+    }
+    return console.error(`Unknown operator ${e2.operator}. Line ${e2.line}`), null;
+  }
+  _evalCall(e2, t2) {
+    if (null !== e2.cachedReturnValue) return e2.cachedReturnValue;
+    const n2 = t2.clone();
+    n2.currentFunctionName = e2.name;
+    const s2 = t2.getFunction(e2.name);
+    if (!s2) {
+      if (e2.isBuiltin) return this._callBuiltinFunction(e2, n2);
+      return this.getTypeInfo(e2.name) ? this._evalCreate(e2, t2) : (console.error(`Unknown function "${e2.name}". Line ${e2.line}`), null);
+    }
+    for (let t3 = 0; t3 < s2.node.args.length; ++t3) {
+      const r2 = s2.node.args[t3], a2 = this.evalExpression(e2.args[t3], n2);
+      n2.createVariable(r2.name, a2, r2);
+    }
+    return this._execStatements(s2.node.body, n2);
+  }
+  _callBuiltinFunction(e2, t2) {
+    switch (e2.name) {
+      case "all":
+        return this.builtins.All(e2, t2);
+      case "any":
+        return this.builtins.Any(e2, t2);
+      case "select":
+        return this.builtins.Select(e2, t2);
+      case "arrayLength":
+        return this.builtins.ArrayLength(e2, t2);
+      case "abs":
+        return this.builtins.Abs(e2, t2);
+      case "acos":
+        return this.builtins.Acos(e2, t2);
+      case "acosh":
+        return this.builtins.Acosh(e2, t2);
+      case "asin":
+        return this.builtins.Asin(e2, t2);
+      case "asinh":
+        return this.builtins.Asinh(e2, t2);
+      case "atan":
+        return this.builtins.Atan(e2, t2);
+      case "atanh":
+        return this.builtins.Atanh(e2, t2);
+      case "atan2":
+        return this.builtins.Atan2(e2, t2);
+      case "ceil":
+        return this.builtins.Ceil(e2, t2);
+      case "clamp":
+        return this.builtins.Clamp(e2, t2);
+      case "cos":
+        return this.builtins.Cos(e2, t2);
+      case "cosh":
+        return this.builtins.Cosh(e2, t2);
+      case "countLeadingZeros":
+        return this.builtins.CountLeadingZeros(e2, t2);
+      case "countOneBits":
+        return this.builtins.CountOneBits(e2, t2);
+      case "countTrailingZeros":
+        return this.builtins.CountTrailingZeros(e2, t2);
+      case "cross":
+        return this.builtins.Cross(e2, t2);
+      case "degrees":
+        return this.builtins.Degrees(e2, t2);
+      case "determinant":
+        return this.builtins.Determinant(e2, t2);
+      case "distance":
+        return this.builtins.Distance(e2, t2);
+      case "dot":
+        return this.builtins.Dot(e2, t2);
+      case "dot4U8Packed":
+        return this.builtins.Dot4U8Packed(e2, t2);
+      case "dot4I8Packed":
+        return this.builtins.Dot4I8Packed(e2, t2);
+      case "exp":
+        return this.builtins.Exp(e2, t2);
+      case "exp2":
+        return this.builtins.Exp2(e2, t2);
+      case "extractBits":
+        return this.builtins.ExtractBits(e2, t2);
+      case "faceForward":
+        return this.builtins.FaceForward(e2, t2);
+      case "firstLeadingBit":
+        return this.builtins.FirstLeadingBit(e2, t2);
+      case "firstTrailingBit":
+        return this.builtins.FirstTrailingBit(e2, t2);
+      case "floor":
+        return this.builtins.Floor(e2, t2);
+      case "fma":
+        return this.builtins.Fma(e2, t2);
+      case "fract":
+        return this.builtins.Fract(e2, t2);
+      case "frexp":
+        return this.builtins.Frexp(e2, t2);
+      case "insertBits":
+        return this.builtins.InsertBits(e2, t2);
+      case "inverseSqrt":
+        return this.builtins.InverseSqrt(e2, t2);
+      case "ldexp":
+        return this.builtins.Ldexp(e2, t2);
+      case "length":
+        return this.builtins.Length(e2, t2);
+      case "log":
+        return this.builtins.Log(e2, t2);
+      case "log2":
+        return this.builtins.Log2(e2, t2);
+      case "max":
+        return this.builtins.Max(e2, t2);
+      case "min":
+        return this.builtins.Min(e2, t2);
+      case "mix":
+        return this.builtins.Mix(e2, t2);
+      case "modf":
+        return this.builtins.Modf(e2, t2);
+      case "normalize":
+        return this.builtins.Normalize(e2, t2);
+      case "pow":
+        return this.builtins.Pow(e2, t2);
+      case "quantizeToF16":
+        return this.builtins.QuantizeToF16(e2, t2);
+      case "radians":
+        return this.builtins.Radians(e2, t2);
+      case "reflect":
+        return this.builtins.Reflect(e2, t2);
+      case "refract":
+        return this.builtins.Refract(e2, t2);
+      case "reverseBits":
+        return this.builtins.ReverseBits(e2, t2);
+      case "round":
+        return this.builtins.Round(e2, t2);
+      case "saturate":
+        return this.builtins.Saturate(e2, t2);
+      case "sign":
+        return this.builtins.Sign(e2, t2);
+      case "sin":
+        return this.builtins.Sin(e2, t2);
+      case "sinh":
+        return this.builtins.Sinh(e2, t2);
+      case "smoothstep":
+        return this.builtins.SmoothStep(e2, t2);
+      case "sqrt":
+        return this.builtins.Sqrt(e2, t2);
+      case "step":
+        return this.builtins.Step(e2, t2);
+      case "tan":
+        return this.builtins.Tan(e2, t2);
+      case "tanh":
+        return this.builtins.Tanh(e2, t2);
+      case "transpose":
+        return this.builtins.Transpose(e2, t2);
+      case "trunc":
+        return this.builtins.Trunc(e2, t2);
+      case "dpdx":
+        return this.builtins.Dpdx(e2, t2);
+      case "dpdxCoarse":
+        return this.builtins.DpdxCoarse(e2, t2);
+      case "dpdxFine":
+        return this.builtins.DpdxFine(e2, t2);
+      case "dpdy":
+        return this.builtins.Dpdy(e2, t2);
+      case "dpdyCoarse":
+        return this.builtins.DpdyCoarse(e2, t2);
+      case "dpdyFine":
+        return this.builtins.DpdyFine(e2, t2);
+      case "fwidth":
+        return this.builtins.Fwidth(e2, t2);
+      case "fwidthCoarse":
+        return this.builtins.FwidthCoarse(e2, t2);
+      case "fwidthFine":
+        return this.builtins.FwidthFine(e2, t2);
+      case "textureDimensions":
+        return this.builtins.TextureDimensions(e2, t2);
+      case "textureGather":
+        return this.builtins.TextureGather(e2, t2);
+      case "textureGatherCompare":
+        return this.builtins.TextureGatherCompare(e2, t2);
+      case "textureLoad":
+        return this.builtins.TextureLoad(e2, t2);
+      case "textureNumLayers":
+        return this.builtins.TextureNumLayers(e2, t2);
+      case "textureNumLevels":
+        return this.builtins.TextureNumLevels(e2, t2);
+      case "textureNumSamples":
+        return this.builtins.TextureNumSamples(e2, t2);
+      case "textureSample":
+        return this.builtins.TextureSample(e2, t2);
+      case "textureSampleBias":
+        return this.builtins.TextureSampleBias(e2, t2);
+      case "textureSampleCompare":
+        return this.builtins.TextureSampleCompare(e2, t2);
+      case "textureSampleCompareLevel":
+        return this.builtins.TextureSampleCompareLevel(e2, t2);
+      case "textureSampleGrad":
+        return this.builtins.TextureSampleGrad(e2, t2);
+      case "textureSampleLevel":
+        return this.builtins.TextureSampleLevel(e2, t2);
+      case "textureSampleBaseClampToEdge":
+        return this.builtins.TextureSampleBaseClampToEdge(e2, t2);
+      case "textureStore":
+        return this.builtins.TextureStore(e2, t2);
+      case "atomicLoad":
+        return this.builtins.AtomicLoad(e2, t2);
+      case "atomicStore":
+        return this.builtins.AtomicStore(e2, t2);
+      case "atomicAdd":
+        return this.builtins.AtomicAdd(e2, t2);
+      case "atomicSub":
+        return this.builtins.AtomicSub(e2, t2);
+      case "atomicMax":
+        return this.builtins.AtomicMax(e2, t2);
+      case "atomicMin":
+        return this.builtins.AtomicMin(e2, t2);
+      case "atomicAnd":
+        return this.builtins.AtomicAnd(e2, t2);
+      case "atomicOr":
+        return this.builtins.AtomicOr(e2, t2);
+      case "atomicXor":
+        return this.builtins.AtomicXor(e2, t2);
+      case "atomicExchange":
+        return this.builtins.AtomicExchange(e2, t2);
+      case "atomicCompareExchangeWeak":
+        return this.builtins.AtomicCompareExchangeWeak(e2, t2);
+      case "pack4x8snorm":
+        return this.builtins.Pack4x8snorm(e2, t2);
+      case "pack4x8unorm":
+        return this.builtins.Pack4x8unorm(e2, t2);
+      case "pack4xI8":
+        return this.builtins.Pack4xI8(e2, t2);
+      case "pack4xU8":
+        return this.builtins.Pack4xU8(e2, t2);
+      case "pack4x8Clamp":
+        return this.builtins.Pack4x8Clamp(e2, t2);
+      case "pack4xU8Clamp":
+        return this.builtins.Pack4xU8Clamp(e2, t2);
+      case "pack2x16snorm":
+        return this.builtins.Pack2x16snorm(e2, t2);
+      case "pack2x16unorm":
+        return this.builtins.Pack2x16unorm(e2, t2);
+      case "pack2x16float":
+        return this.builtins.Pack2x16float(e2, t2);
+      case "unpack4x8snorm":
+        return this.builtins.Unpack4x8snorm(e2, t2);
+      case "unpack4x8unorm":
+        return this.builtins.Unpack4x8unorm(e2, t2);
+      case "unpack4xI8":
+        return this.builtins.Unpack4xI8(e2, t2);
+      case "unpack4xU8":
+        return this.builtins.Unpack4xU8(e2, t2);
+      case "unpack2x16snorm":
+        return this.builtins.Unpack2x16snorm(e2, t2);
+      case "unpack2x16unorm":
+        return this.builtins.Unpack2x16unorm(e2, t2);
+      case "unpack2x16float":
+        return this.builtins.Unpack2x16float(e2, t2);
+      case "storageBarrier":
+        return this.builtins.StorageBarrier(e2, t2);
+      case "textureBarrier":
+        return this.builtins.TextureBarrier(e2, t2);
+      case "workgroupBarrier":
+        return this.builtins.WorkgroupBarrier(e2, t2);
+      case "workgroupUniformLoad":
+        return this.builtins.WorkgroupUniformLoad(e2, t2);
+      case "subgroupAdd":
+        return this.builtins.SubgroupAdd(e2, t2);
+      case "subgroupExclusiveAdd":
+        return this.builtins.SubgroupExclusiveAdd(e2, t2);
+      case "subgroupInclusiveAdd":
+        return this.builtins.SubgroupInclusiveAdd(e2, t2);
+      case "subgroupAll":
+        return this.builtins.SubgroupAll(e2, t2);
+      case "subgroupAnd":
+        return this.builtins.SubgroupAnd(e2, t2);
+      case "subgroupAny":
+        return this.builtins.SubgroupAny(e2, t2);
+      case "subgroupBallot":
+        return this.builtins.SubgroupBallot(e2, t2);
+      case "subgroupBroadcast":
+        return this.builtins.SubgroupBroadcast(e2, t2);
+      case "subgroupBroadcastFirst":
+        return this.builtins.SubgroupBroadcastFirst(e2, t2);
+      case "subgroupElect":
+        return this.builtins.SubgroupElect(e2, t2);
+      case "subgroupMax":
+        return this.builtins.SubgroupMax(e2, t2);
+      case "subgroupMin":
+        return this.builtins.SubgroupMin(e2, t2);
+      case "subgroupMul":
+        return this.builtins.SubgroupMul(e2, t2);
+      case "subgroupExclusiveMul":
+        return this.builtins.SubgroupExclusiveMul(e2, t2);
+      case "subgroupInclusiveMul":
+        return this.builtins.SubgroupInclusiveMul(e2, t2);
+      case "subgroupOr":
+        return this.builtins.SubgroupOr(e2, t2);
+      case "subgroupShuffle":
+        return this.builtins.SubgroupShuffle(e2, t2);
+      case "subgroupShuffleDown":
+        return this.builtins.SubgroupShuffleDown(e2, t2);
+      case "subgroupShuffleUp":
+        return this.builtins.SubgroupShuffleUp(e2, t2);
+      case "subgroupShuffleXor":
+        return this.builtins.SubgroupShuffleXor(e2, t2);
+      case "subgroupXor":
+        return this.builtins.SubgroupXor(e2, t2);
+      case "quadBroadcast":
+        return this.builtins.QuadBroadcast(e2, t2);
+      case "quadSwapDiagonal":
+        return this.builtins.QuadSwapDiagonal(e2, t2);
+      case "quadSwapX":
+        return this.builtins.QuadSwapX(e2, t2);
+      case "quadSwapY":
+        return this.builtins.QuadSwapY(e2, t2);
+    }
+    const n2 = t2.getFunction(e2.name);
+    if (n2) {
+      const s2 = t2.clone();
+      for (let t3 = 0; t3 < n2.node.args.length; ++t3) {
+        const r2 = n2.node.args[t3], a2 = this.evalExpression(e2.args[t3], s2);
+        s2.setVariable(r2.name, a2, r2);
+      }
+      return this._execStatements(n2.node.body, s2);
+    }
+    return null;
+  }
+  _callConstructorValue(e2, t2) {
+    if (!e2.args || 0 === e2.args.length) return new Be(0, this.getTypeInfo(e2.type));
+    const n2 = this.evalExpression(e2.args[0], t2);
+    return n2.typeInfo = this.getTypeInfo(e2.type), n2.getSubData(this, e2.postfix, t2).clone();
+  }
+  _callConstructorVec(e2, t2) {
+    const n2 = this.getTypeInfo(e2.type), s2 = e2.type.getTypeName(), r2 = ft[s2];
+    if (void 0 === r2) return console.error(`Invalid vec constructor ${s2}. Line ${e2.line}`), null;
+    const a2 = [];
+    if (e2 instanceof xe) if (e2.isVector) {
+      const t3 = e2.vectorValue;
+      for (const e3 of t3) a2.push(e3);
+    } else a2.push(e2.scalarValue);
+    else if (e2.args) for (const n3 of e2.args) {
+      const e3 = this.evalExpression(n3, t2);
+      if (e3 instanceof Me) {
+        const t3 = e3.data;
+        for (let e4 = 0; e4 < t3.length; ++e4) {
+          let n4 = t3[e4];
+          a2.push(n4);
+        }
+      } else if (e3 instanceof Be) {
+        let t3 = e3.value;
+        a2.push(t3);
+      }
+    }
+    if (e2.type instanceof ce && null === e2.type.format && (e2.type.format = ce.f32), 0 === a2.length) {
+      const s3 = new Array(r2).fill(0);
+      return new Me(s3, n2).getSubData(this, e2.postfix, t2);
+    }
+    if (1 === a2.length) for (; a2.length < r2; ) a2.push(a2[0]);
+    if (a2.length < r2) return console.error(`Invalid vec constructor. Line ${e2.line}`), null;
+    return new Me(a2.length > r2 ? a2.slice(0, r2) : a2, n2).getSubData(this, e2.postfix, t2);
+  }
+  _callConstructorMatrix(e2, t2) {
+    const n2 = this.getTypeInfo(e2.type), s2 = e2.type.getTypeName(), r2 = pt[s2];
+    if (void 0 === r2) return console.error(`Invalid matrix constructor ${s2}. Line ${e2.line}`), null;
+    const i2 = [];
+    if (e2 instanceof xe) if (e2.isVector) {
+      const t3 = e2.vectorValue;
+      for (const e3 of t3) i2.push(e3);
+    } else i2.push(e2.scalarValue);
+    else if (e2.args) for (const n3 of e2.args) {
+      const e3 = this.evalExpression(n3, t2);
+      e3 instanceof Me ? i2.push(...e3.data) : e3 instanceof Be ? i2.push(e3.value) : e3 instanceof Ue && i2.push(...e3.data);
+    }
+    if (n2 instanceof a && null === n2.format && (n2.format = this.getTypeInfo("f32")), 0 === i2.length) {
+      const s3 = new Array(r2[2]).fill(0);
+      return new Ue(s3, n2).getSubData(this, e2.postfix, t2);
+    }
+    return i2.length !== r2[2] ? (console.error(`Invalid matrix constructor. Line ${e2.line}`), null) : new Ue(i2, n2).getSubData(this, e2.postfix, t2);
+  }
+}
+dt._breakObj = new Ne(new e("BREAK", null), null), dt._continueObj = new Ne(new e("CONTINUE", null), null), dt._priority = /* @__PURE__ */ new Map([["f32", 0], ["f16", 1], ["u32", 2], ["i32", 3], ["x32", 3]]);
+class mt {
+  constructor() {
+    this.constants = /* @__PURE__ */ new Map(), this.aliases = /* @__PURE__ */ new Map(), this.structs = /* @__PURE__ */ new Map();
+  }
+}
+class gt {
+  constructor() {
+    this._tokens = [], this._current = 0, this._currentLine = 1, this._deferArrayCountEval = [], this._currentLoop = [], this._context = new mt(), this._exec = new dt(), this._forwardTypeCount = 0;
+  }
+  parse(e2) {
+    this._initialize(e2), this._deferArrayCountEval.length = 0;
+    const t2 = [];
+    for (; !this._isAtEnd(); ) {
+      const e3 = this._global_decl_or_directive();
+      if (!e3) break;
+      t2.push(e3);
+    }
+    if (this._deferArrayCountEval.length > 0) {
+      for (const e3 of this._deferArrayCountEval) {
+        const t3 = e3.arrayType, n2 = e3.countNode;
+        if (n2 instanceof ge) {
+          const e4 = n2.name, s2 = this._context.constants.get(e4);
+          if (s2) try {
+            const e5 = s2.constEvaluate(this._exec);
+            t3.count = e5;
+          } catch (e5) {
+          }
+        }
+      }
+      this._deferArrayCountEval.length = 0;
+    }
+    if (this._forwardTypeCount > 0) for (const e3 of t2) e3.search((e4) => {
+      e4 instanceof Ce || e4 instanceof le ? e4.type = this._forwardType(e4.type) : e4 instanceof ue ? e4.format = this._forwardType(e4.format) : e4 instanceof F || e4 instanceof U || e4 instanceof P ? e4.type = this._forwardType(e4.type) : e4 instanceof D ? e4.returnType = this._forwardType(e4.returnType) : e4 instanceof $e && (e4.type = this._forwardType(e4.type));
+    });
+    return t2;
+  }
+  _forwardType(e2) {
+    if (e2 instanceof ie) {
+      const t2 = this._getType(e2.name);
+      if (t2) return t2;
+    } else e2 instanceof le ? e2.type = this._forwardType(e2.type) : e2 instanceof ue && (e2.format = this._forwardType(e2.format));
+    return e2;
+  }
+  _initialize(e2) {
+    if (e2) if ("string" == typeof e2) {
+      const t2 = new Re(e2);
+      this._tokens = t2.scanTokens();
+    } else this._tokens = e2;
+    else this._tokens = [];
+    this._current = 0;
+  }
+  _updateNode(e2, t2) {
+    return e2.line = null != t2 ? t2 : this._currentLine, e2;
+  }
+  _error(e2, t2) {
+    return { token: e2, message: t2, toString: () => `${t2}` };
+  }
+  _isAtEnd() {
+    return this._current >= this._tokens.length || this._peek().type == He.eof;
+  }
+  _match(e2) {
+    if (e2 instanceof qe) return !!this._check(e2) && (this._advance(), true);
+    for (let t2 = 0, n2 = e2.length; t2 < n2; ++t2) {
+      const n3 = e2[t2];
+      if (this._check(n3)) return this._advance(), true;
+    }
+    return false;
+  }
+  _consume(e2, t2) {
+    if (this._check(e2)) return this._advance();
+    throw this._error(this._peek(), `${t2}. Line:${this._currentLine}`);
+  }
+  _check(e2) {
+    if (this._isAtEnd()) return false;
+    const t2 = this._peek();
+    if (e2 instanceof Array) {
+      const n2 = t2.type;
+      let s2 = false;
+      for (const t3 of e2) {
+        if (n2 === t3) return true;
+        t3 === He.tokens.name && (s2 = true);
+      }
+      if (s2) {
+        const e3 = He.tokens.name.rule.exec(t2.lexeme);
+        if (e3 && 0 == e3.index && e3[0] == t2.lexeme) return true;
+      }
+      return false;
+    }
+    if (t2.type === e2) return true;
+    if (e2 === He.tokens.name) {
+      const e3 = He.tokens.name.rule.exec(t2.lexeme);
+      return e3 && 0 == e3.index && e3[0] == t2.lexeme;
+    }
+    return false;
+  }
+  _advance() {
+    var e2, t2;
+    return this._currentLine = null !== (t2 = null === (e2 = this._peek()) || void 0 === e2 ? void 0 : e2.line) && void 0 !== t2 ? t2 : -1, this._isAtEnd() || this._current++, this._previous();
+  }
+  _peek() {
+    return this._tokens[this._current];
+  }
+  _previous() {
+    return this._tokens[this._current - 1];
+  }
+  _global_decl_or_directive() {
+    for (; this._match(He.tokens.semicolon) && !this._isAtEnd(); ) ;
+    if (this._match(He.keywords.alias)) {
+      const e3 = this._type_alias();
+      return this._consume(He.tokens.semicolon, "Expected ';'"), this._exec.reflection.updateAST([e3]), e3;
+    }
+    if (this._match(He.keywords.diagnostic)) {
+      const e3 = this._diagnostic();
+      return this._consume(He.tokens.semicolon, "Expected ';'"), this._exec.reflection.updateAST([e3]), e3;
+    }
+    if (this._match(He.keywords.requires)) {
+      const e3 = this._requires_directive();
+      return this._consume(He.tokens.semicolon, "Expected ';'"), this._exec.reflection.updateAST([e3]), e3;
+    }
+    if (this._match(He.keywords.enable)) {
+      const e3 = this._enable_directive();
+      return this._consume(He.tokens.semicolon, "Expected ';'"), this._exec.reflection.updateAST([e3]), e3;
+    }
+    const e2 = this._attribute();
+    if (this._check(He.keywords.var)) {
+      const t2 = this._global_variable_decl();
+      return null != t2 && (t2.attributes = e2), this._consume(He.tokens.semicolon, "Expected ';'."), this._exec.reflection.updateAST([t2]), t2;
+    }
+    if (this._check(He.keywords.override)) {
+      const t2 = this._override_variable_decl();
+      return null != t2 && (t2.attributes = e2), this._consume(He.tokens.semicolon, "Expected ';'."), this._exec.reflection.updateAST([t2]), t2;
+    }
+    if (this._check(He.keywords.let)) {
+      const t2 = this._global_let_decl();
+      return null != t2 && (t2.attributes = e2), this._consume(He.tokens.semicolon, "Expected ';'."), this._exec.reflection.updateAST([t2]), t2;
+    }
+    if (this._check(He.keywords.const)) {
+      const t2 = this._global_const_decl();
+      return null != t2 && (t2.attributes = e2), this._consume(He.tokens.semicolon, "Expected ';'."), this._exec.reflection.updateAST([t2]), t2;
+    }
+    if (this._check(He.keywords.struct)) {
+      const t2 = this._struct_decl();
+      return null != t2 && (t2.attributes = e2), this._exec.reflection.updateAST([t2]), t2;
+    }
+    if (this._check(He.keywords.fn)) {
+      const t2 = this._function_decl();
+      return null != t2 && (t2.attributes = e2), this._exec.reflection.updateAST([t2]), t2;
+    }
+    return null;
+  }
+  _function_decl() {
+    if (!this._match(He.keywords.fn)) return null;
+    const e2 = this._currentLine, t2 = this._consume(He.tokens.ident, "Expected function name.").toString();
+    this._consume(He.tokens.paren_left, "Expected '(' for function arguments.");
+    const n2 = [];
+    if (!this._check(He.tokens.paren_right)) do {
+      if (this._check(He.tokens.paren_right)) break;
+      const e3 = this._attribute(), t3 = this._consume(He.tokens.name, "Expected argument name.").toString();
+      this._consume(He.tokens.colon, "Expected ':' for argument type.");
+      const s3 = this._attribute(), r3 = this._type_decl();
+      null != r3 && (r3.attributes = s3, n2.push(this._updateNode(new $e(t3, r3, e3))));
+    } while (this._match(He.tokens.comma));
+    this._consume(He.tokens.paren_right, "Expected ')' after function arguments.");
+    let s2 = null;
+    if (this._match(He.tokens.arrow)) {
+      const e3 = this._attribute();
+      s2 = this._type_decl(), null != s2 && (s2.attributes = e3);
+    }
+    const r2 = this._compound_statement(), a2 = this._currentLine;
+    return this._updateNode(new D(t2, n2, s2, r2, e2, a2), e2);
+  }
+  _compound_statement() {
+    const e2 = [];
+    for (this._consume(He.tokens.brace_left, "Expected '{' for block."); !this._check(He.tokens.brace_right); ) {
+      const t2 = this._statement();
+      null !== t2 && e2.push(t2);
+    }
+    return this._consume(He.tokens.brace_right, "Expected '}' for block."), e2;
+  }
+  _statement() {
+    for (; this._match(He.tokens.semicolon) && !this._isAtEnd(); ) ;
+    if (this._check(He.tokens.attr) && this._attribute(), this._check(He.keywords.if)) return this._if_statement();
+    if (this._check(He.keywords.switch)) return this._switch_statement();
+    if (this._check(He.keywords.loop)) return this._loop_statement();
+    if (this._check(He.keywords.for)) return this._for_statement();
+    if (this._check(He.keywords.while)) return this._while_statement();
+    if (this._check(He.keywords.continuing)) return this._continuing_statement();
+    if (this._check(He.keywords.static_assert)) return this._static_assert_statement();
+    if (this._check(He.tokens.brace_left)) return this._compound_statement();
+    let e2 = null;
+    if (this._check(He.keywords.return)) e2 = this._return_statement();
+    else if (this._check([He.keywords.var, He.keywords.let, He.keywords.const])) e2 = this._variable_statement();
+    else if (this._match(He.keywords.discard)) e2 = this._updateNode(new ne());
+    else if (this._match(He.keywords.break)) {
+      const t2 = this._updateNode(new se());
+      if (this._currentLoop.length > 0) {
+        const e3 = this._currentLoop[this._currentLoop.length - 1];
+        t2.loopId = e3.id;
+      }
+      e2 = t2, this._check(He.keywords.if) && (this._advance(), t2.condition = this._optional_paren_expression());
+    } else if (this._match(He.keywords.continue)) {
+      const t2 = this._updateNode(new re());
+      if (!(this._currentLoop.length > 0)) throw this._error(this._peek(), `Continue statement must be inside a loop. Line: ${t2.line}`);
+      {
+        const e3 = this._currentLoop[this._currentLoop.length - 1];
+        t2.loopId = e3.id;
+      }
+      e2 = t2;
+    } else e2 = this._increment_decrement_statement() || this._func_call_statement() || this._assignment_statement();
+    return null != e2 && this._consume(He.tokens.semicolon, "Expected ';' after statement."), e2;
+  }
+  _static_assert_statement() {
+    if (!this._match(He.keywords.static_assert)) return null;
+    const e2 = this._currentLine, t2 = this._optional_paren_expression();
+    return this._updateNode(new N(t2), e2);
+  }
+  _while_statement() {
+    if (!this._match(He.keywords.while)) return null;
+    const e2 = this._updateNode(new V(null, null));
+    return this._currentLoop.push(e2), e2.condition = this._optional_paren_expression(), this._check(He.tokens.attr) && this._attribute(), e2.body = this._compound_statement(), this._currentLoop.pop(), e2;
+  }
+  _continuing_statement() {
+    const e2 = this._currentLoop.length > 0 ? this._currentLoop[this._currentLoop.length - 1].id : -1;
+    if (!this._match(He.keywords.continuing)) return null;
+    const t2 = this._currentLine, n2 = this._compound_statement();
+    return this._updateNode(new O(n2, e2), t2);
+  }
+  _for_statement() {
+    if (!this._match(He.keywords.for)) return null;
+    this._consume(He.tokens.paren_left, "Expected '('.");
+    const e2 = this._updateNode(new B(null, null, null, null));
+    return this._currentLoop.push(e2), e2.init = this._check(He.tokens.semicolon) ? null : this._for_init(), this._consume(He.tokens.semicolon, "Expected ';'."), e2.condition = this._check(He.tokens.semicolon) ? null : this._short_circuit_or_expression(), this._consume(He.tokens.semicolon, "Expected ';'."), e2.increment = this._check(He.tokens.paren_right) ? null : this._for_increment(), this._consume(He.tokens.paren_right, "Expected ')'."), this._check(He.tokens.attr) && this._attribute(), e2.body = this._compound_statement(), this._currentLoop.pop(), e2;
+  }
+  _for_init() {
+    return this._variable_statement() || this._func_call_statement() || this._assignment_statement();
+  }
+  _for_increment() {
+    return this._func_call_statement() || this._increment_decrement_statement() || this._assignment_statement();
+  }
+  _variable_statement() {
+    if (this._check(He.keywords.var)) {
+      const e2 = this._variable_decl();
+      if (null === e2) throw this._error(this._peek(), "Variable declaration expected.");
+      let t2 = null;
+      return this._match(He.tokens.equal) && (t2 = this._short_circuit_or_expression()), this._updateNode(new F(e2.name, e2.type, e2.storage, e2.access, t2), e2.line);
+    }
+    if (this._match(He.keywords.let)) {
+      const e2 = this._currentLine, t2 = this._consume(He.tokens.name, "Expected name for let.").toString();
+      let n2 = null;
+      if (this._match(He.tokens.colon)) {
+        const e3 = this._attribute();
+        n2 = this._type_decl(), null != n2 && (n2.attributes = e3);
+      }
+      this._consume(He.tokens.equal, "Expected '=' for let.");
+      const s2 = this._short_circuit_or_expression();
+      return this._updateNode(new U(t2, n2, null, null, s2), e2);
+    }
+    if (this._match(He.keywords.const)) {
+      const e2 = this._currentLine, t2 = this._consume(He.tokens.name, "Expected name for const.").toString();
+      let n2 = null;
+      if (this._match(He.tokens.colon)) {
+        const e3 = this._attribute();
+        n2 = this._type_decl(), null != n2 && (n2.attributes = e3);
+      }
+      this._consume(He.tokens.equal, "Expected '=' for const.");
+      const s2 = this._short_circuit_or_expression();
+      return null === n2 && s2 instanceof xe && (n2 = s2.type), this._updateNode(new P(t2, n2, null, null, s2), e2);
+    }
+    return null;
+  }
+  _increment_decrement_statement() {
+    const e2 = this._current, t2 = this._unary_expression();
+    if (null == t2) return null;
+    if (!this._check(He.increment_operators)) return this._current = e2, null;
+    const n2 = this._consume(He.increment_operators, "Expected increment operator");
+    return this._updateNode(new R(n2.type === He.tokens.plus_plus ? W.increment : W.decrement, t2));
+  }
+  _assignment_statement() {
+    let e2 = null;
+    const t2 = this._currentLine;
+    if (this._check(He.tokens.brace_right)) return null;
+    let n2 = this._match(He.tokens.underscore);
+    if (n2 || (e2 = this._unary_expression()), !n2 && null == e2) return null;
+    const s2 = this._consume(He.assignment_operators, "Expected assignment operator."), r2 = this._short_circuit_or_expression();
+    return this._updateNode(new G(q.parse(s2.lexeme), e2, r2), t2);
+  }
+  _func_call_statement() {
+    if (!this._check(He.tokens.ident)) return null;
+    const e2 = this._currentLine, t2 = this._current, n2 = this._consume(He.tokens.ident, "Expected function name."), s2 = this._argument_expression_list();
+    return null === s2 ? (this._current = t2, null) : this._updateNode(new X(n2.lexeme, s2), e2);
+  }
+  _loop_statement() {
+    if (!this._match(He.keywords.loop)) return null;
+    this._check(He.tokens.attr) && this._attribute(), this._consume(He.tokens.brace_left, "Expected '{' for loop.");
+    const e2 = this._updateNode(new j([], null));
+    this._currentLoop.push(e2);
+    let t2 = this._statement();
+    for (; null !== t2; ) {
+      if (Array.isArray(t2)) for (let n2 of t2) e2.body.push(n2);
+      else e2.body.push(t2);
+      if (t2 instanceof O) {
+        e2.continuing = t2;
+        break;
+      }
+      t2 = this._statement();
+    }
+    return this._currentLoop.pop(), this._consume(He.tokens.brace_right, "Expected '}' for loop."), e2;
+  }
+  _switch_statement() {
+    if (!this._match(He.keywords.switch)) return null;
+    const e2 = this._updateNode(new Z(null, []));
+    if (this._currentLoop.push(e2), e2.condition = this._optional_paren_expression(), this._check(He.tokens.attr) && this._attribute(), this._consume(He.tokens.brace_left, "Expected '{' for switch."), e2.cases = this._switch_body(), null == e2.cases || 0 == e2.cases.length) throw this._error(this._previous(), "Expected 'case' or 'default'.");
+    return this._consume(He.tokens.brace_right, "Expected '}' for switch."), this._currentLoop.pop(), e2;
+  }
+  _switch_body() {
+    const e2 = [];
+    let t2 = false;
+    for (; this._check([He.keywords.default, He.keywords.case]); ) {
+      if (this._match(He.keywords.case)) {
+        const n2 = this._case_selectors();
+        for (const e3 of n2) if (e3 instanceof Se) {
+          if (t2) throw this._error(this._previous(), "Multiple default cases in switch statement.");
+          t2 = true;
+          break;
+        }
+        this._match(He.tokens.colon), this._check(He.tokens.attr) && this._attribute(), this._consume(He.tokens.brace_left, "Exected '{' for switch case.");
+        const s2 = this._case_body();
+        this._consume(He.tokens.brace_right, "Exected '}' for switch case."), e2.push(this._updateNode(new Ae(n2, s2)));
+      }
+      if (this._match(He.keywords.default)) {
+        if (t2) throw this._error(this._previous(), "Multiple default cases in switch statement.");
+        this._match(He.tokens.colon), this._check(He.tokens.attr) && this._attribute(), this._consume(He.tokens.brace_left, "Exected '{' for switch default.");
+        const n2 = this._case_body();
+        this._consume(He.tokens.brace_right, "Exected '}' for switch default."), e2.push(this._updateNode(new Ee(n2)));
+      }
+    }
+    return e2;
+  }
+  _case_selectors() {
+    const e2 = [];
+    for (this._match(He.keywords.default) ? e2.push(this._updateNode(new Se())) : e2.push(this._shift_expression()); this._match(He.tokens.comma); ) this._match(He.keywords.default) ? e2.push(this._updateNode(new Se())) : e2.push(this._shift_expression());
+    return e2;
+  }
+  _case_body() {
+    if (this._match(He.keywords.fallthrough)) return this._consume(He.tokens.semicolon, "Expected ';'"), [];
+    let e2 = this._statement();
+    if (null == e2) return [];
+    e2 instanceof Array || (e2 = [e2]);
+    const t2 = this._case_body();
+    return 0 == t2.length ? e2 : [...e2, t2[0]];
+  }
+  _if_statement() {
+    if (!this._match(He.keywords.if)) return null;
+    const e2 = this._currentLine, t2 = this._optional_paren_expression();
+    this._check(He.tokens.attr) && this._attribute();
+    const n2 = this._compound_statement();
+    let s2 = [];
+    this._match_elseif() && (this._check(He.tokens.attr) && this._attribute(), s2 = this._elseif_statement(s2));
+    let r2 = null;
+    return this._match(He.keywords.else) && (this._check(He.tokens.attr) && this._attribute(), r2 = this._compound_statement()), this._updateNode(new Q(t2, n2, s2, r2), e2);
+  }
+  _match_elseif() {
+    return this._tokens[this._current].type === He.keywords.else && this._tokens[this._current + 1].type === He.keywords.if && (this._advance(), this._advance(), true);
+  }
+  _elseif_statement(e2 = []) {
+    const t2 = this._optional_paren_expression(), n2 = this._compound_statement();
+    return e2.push(this._updateNode(new Le(t2, n2))), this._match_elseif() && (this._check(He.tokens.attr) && this._attribute(), this._elseif_statement(e2)), e2;
+  }
+  _return_statement() {
+    if (!this._match(He.keywords.return)) return null;
+    const e2 = this._short_circuit_or_expression();
+    return this._updateNode(new Y(e2));
+  }
+  _short_circuit_or_expression() {
+    let e2 = this._short_circuit_and_expr();
+    for (; this._match(He.tokens.or_or); ) e2 = this._updateNode(new Ie(this._previous().toString(), e2, this._short_circuit_and_expr()));
+    return e2;
+  }
+  _short_circuit_and_expr() {
+    let e2 = this._inclusive_or_expression();
+    for (; this._match(He.tokens.and_and); ) e2 = this._updateNode(new Ie(this._previous().toString(), e2, this._inclusive_or_expression()));
+    return e2;
+  }
+  _inclusive_or_expression() {
+    let e2 = this._exclusive_or_expression();
+    for (; this._match(He.tokens.or); ) e2 = this._updateNode(new Ie(this._previous().toString(), e2, this._exclusive_or_expression()));
+    return e2;
+  }
+  _exclusive_or_expression() {
+    let e2 = this._and_expression();
+    for (; this._match(He.tokens.xor); ) e2 = this._updateNode(new Ie(this._previous().toString(), e2, this._and_expression()));
+    return e2;
+  }
+  _and_expression() {
+    let e2 = this._equality_expression();
+    for (; this._match(He.tokens.and); ) e2 = this._updateNode(new Ie(this._previous().toString(), e2, this._equality_expression()));
+    return e2;
+  }
+  _equality_expression() {
+    const e2 = this._relational_expression();
+    return this._match([He.tokens.equal_equal, He.tokens.not_equal]) ? this._updateNode(new Ie(this._previous().toString(), e2, this._relational_expression())) : e2;
+  }
+  _relational_expression() {
+    let e2 = this._shift_expression();
+    for (; this._match([He.tokens.less_than, He.tokens.greater_than, He.tokens.less_than_equal, He.tokens.greater_than_equal]); ) e2 = this._updateNode(new Ie(this._previous().toString(), e2, this._shift_expression()));
+    return e2;
+  }
+  _shift_expression() {
+    let e2 = this._additive_expression();
+    for (; this._match([He.tokens.shift_left, He.tokens.shift_right]); ) e2 = this._updateNode(new Ie(this._previous().toString(), e2, this._additive_expression()));
+    return e2;
+  }
+  _additive_expression() {
+    let e2 = this._multiplicative_expression();
+    for (; this._match([He.tokens.plus, He.tokens.minus]); ) e2 = this._updateNode(new Ie(this._previous().toString(), e2, this._multiplicative_expression()));
+    return e2;
+  }
+  _multiplicative_expression() {
+    let e2 = this._unary_expression();
+    for (; this._match([He.tokens.star, He.tokens.forward_slash, He.tokens.modulo]); ) e2 = this._updateNode(new Ie(this._previous().toString(), e2, this._unary_expression()));
+    return e2;
+  }
+  _unary_expression() {
+    return this._match([He.tokens.minus, He.tokens.bang, He.tokens.tilde, He.tokens.star, He.tokens.and]) ? this._updateNode(new ke(this._previous().toString(), this._unary_expression())) : this._singular_expression();
+  }
+  _singular_expression() {
+    const e2 = this._primary_expression(), t2 = this._postfix_expression();
+    return t2 && (e2.postfix = t2), e2;
+  }
+  _postfix_expression() {
+    if (this._match(He.tokens.bracket_left)) {
+      const e2 = this._short_circuit_or_expression();
+      this._consume(He.tokens.bracket_right, "Expected ']'.");
+      const t2 = this._updateNode(new ve(e2)), n2 = this._postfix_expression();
+      return n2 && (t2.postfix = n2), t2;
+    }
+    if (this._match(He.tokens.period)) {
+      const e2 = this._consume(He.tokens.name, "Expected member name."), t2 = this._postfix_expression(), n2 = this._updateNode(new pe(e2.lexeme));
+      return t2 && (n2.postfix = t2), n2;
+    }
+    return null;
+  }
+  _getStruct(e2) {
+    if (this._context.aliases.has(e2)) {
+      return this._context.aliases.get(e2).type;
+    }
+    if (this._context.structs.has(e2)) {
+      return this._context.structs.get(e2);
+    }
+    return null;
+  }
+  _getType(e2) {
+    const t2 = this._getStruct(e2);
+    if (null !== t2) return t2;
+    switch (e2) {
+      case "void":
+        return ae.void;
+      case "bool":
+        return ae.bool;
+      case "i32":
+        return ae.i32;
+      case "u32":
+        return ae.u32;
+      case "f32":
+        return ae.f32;
+      case "f16":
+        return ae.f16;
+      case "vec2f":
+        return ce.vec2f;
+      case "vec3f":
+        return ce.vec3f;
+      case "vec4f":
+        return ce.vec4f;
+      case "vec2i":
+        return ce.vec2i;
+      case "vec3i":
+        return ce.vec3i;
+      case "vec4i":
+        return ce.vec4i;
+      case "vec2u":
+        return ce.vec2u;
+      case "vec3u":
+        return ce.vec3u;
+      case "vec4u":
+        return ce.vec4u;
+      case "vec2h":
+        return ce.vec2h;
+      case "vec3h":
+        return ce.vec3h;
+      case "vec4h":
+        return ce.vec4h;
+      case "mat2x2f":
+        return ce.mat2x2f;
+      case "mat2x3f":
+        return ce.mat2x3f;
+      case "mat2x4f":
+        return ce.mat2x4f;
+      case "mat3x2f":
+        return ce.mat3x2f;
+      case "mat3x3f":
+        return ce.mat3x3f;
+      case "mat3x4f":
+        return ce.mat3x4f;
+      case "mat4x2f":
+        return ce.mat4x2f;
+      case "mat4x3f":
+        return ce.mat4x3f;
+      case "mat4x4f":
+        return ce.mat4x4f;
+      case "mat2x2h":
+        return ce.mat2x2h;
+      case "mat2x3h":
+        return ce.mat2x3h;
+      case "mat2x4h":
+        return ce.mat2x4h;
+      case "mat3x2h":
+        return ce.mat3x2h;
+      case "mat3x3h":
+        return ce.mat3x3h;
+      case "mat3x4h":
+        return ce.mat3x4h;
+      case "mat4x2h":
+        return ce.mat4x2h;
+      case "mat4x3h":
+        return ce.mat4x3h;
+      case "mat4x4h":
+        return ce.mat4x4h;
+      case "mat2x2i":
+        return ce.mat2x2i;
+      case "mat2x3i":
+        return ce.mat2x3i;
+      case "mat2x4i":
+        return ce.mat2x4i;
+      case "mat3x2i":
+        return ce.mat3x2i;
+      case "mat3x3i":
+        return ce.mat3x3i;
+      case "mat3x4i":
+        return ce.mat3x4i;
+      case "mat4x2i":
+        return ce.mat4x2i;
+      case "mat4x3i":
+        return ce.mat4x3i;
+      case "mat4x4i":
+        return ce.mat4x4i;
+      case "mat2x2u":
+        return ce.mat2x2u;
+      case "mat2x3u":
+        return ce.mat2x3u;
+      case "mat2x4u":
+        return ce.mat2x4u;
+      case "mat3x2u":
+        return ce.mat3x2u;
+      case "mat3x3u":
+        return ce.mat3x3u;
+      case "mat3x4u":
+        return ce.mat3x4u;
+      case "mat4x2u":
+        return ce.mat4x2u;
+      case "mat4x3u":
+        return ce.mat4x3u;
+      case "mat4x4u":
+        return ce.mat4x4u;
+    }
+    return null;
+  }
+  _validateTypeRange(e2, t2) {
+    if ("i32" === t2.name) {
+      if (e2 < -2147483648 || e2 > 2147483647) throw this._error(this._previous(), `Value out of range for i32: ${e2}. Line: ${this._currentLine}.`);
+    } else if ("u32" === t2.name && (e2 < 0 || e2 > 4294967295)) throw this._error(this._previous(), `Value out of range for u32: ${e2}. Line: ${this._currentLine}.`);
+  }
+  _primary_expression() {
+    if (this._match(He.tokens.ident)) {
+      const e3 = this._previous().toString();
+      if (this._check(He.tokens.paren_left)) {
+        const t3 = this._argument_expression_list(), n2 = this._getType(e3);
+        return null !== n2 ? this._updateNode(new de(n2, t3)) : this._updateNode(new me(e3, t3));
+      }
+      if (this._context.constants.has(e3)) {
+        const t3 = this._context.constants.get(e3);
+        return this._updateNode(new _e(e3, t3.value));
+      }
+      return this._updateNode(new ge(e3));
+    }
+    if (this._match(He.tokens.int_literal)) {
+      const e3 = this._previous().toString();
+      let t3 = e3.endsWith("i") || e3.endsWith("i") ? ae.i32 : e3.endsWith("u") || e3.endsWith("U") ? ae.u32 : ae.x32;
+      const n2 = parseInt(e3);
+      return this._validateTypeRange(n2, t3), this._updateNode(new xe(new Be(n2, this._exec.getTypeInfo(t3)), t3));
+    }
+    if (this._match(He.tokens.uint_literal)) {
+      const e3 = parseInt(this._previous().toString());
+      return this._validateTypeRange(e3, ae.u32), this._updateNode(new xe(new Be(e3, this._exec.getTypeInfo(ae.u32)), ae.u32));
+    }
+    if (this._match([He.tokens.decimal_float_literal, He.tokens.hex_float_literal])) {
+      let e3 = this._previous().toString(), t3 = e3.endsWith("h");
+      t3 && (e3 = e3.substring(0, e3.length - 1));
+      const n2 = parseFloat(e3);
+      this._validateTypeRange(n2, t3 ? ae.f16 : ae.f32);
+      const s2 = t3 ? ae.f16 : ae.f32;
+      return this._updateNode(new xe(new Be(n2, this._exec.getTypeInfo(s2)), s2));
+    }
+    if (this._match([He.keywords.true, He.keywords.false])) {
+      let e3 = this._previous().toString() === He.keywords.true.rule;
+      return this._updateNode(new xe(new Be(e3 ? 1 : 0, this._exec.getTypeInfo(ae.bool)), ae.bool));
+    }
+    if (this._check(He.tokens.paren_left)) return this._paren_expression();
+    if (this._match(He.keywords.bitcast)) {
+      this._consume(He.tokens.less_than, "Expected '<'.");
+      const e3 = this._type_decl();
+      this._consume(He.tokens.greater_than, "Expected '>'.");
+      const t3 = this._paren_expression();
+      return this._updateNode(new ye(e3, t3));
+    }
+    const e2 = this._type_decl(), t2 = this._argument_expression_list();
+    return this._updateNode(new de(e2, t2));
+  }
+  _argument_expression_list() {
+    if (!this._match(He.tokens.paren_left)) return null;
+    const e2 = [];
+    do {
+      if (this._check(He.tokens.paren_right)) break;
+      const t2 = this._short_circuit_or_expression();
+      e2.push(t2);
+    } while (this._match(He.tokens.comma));
+    return this._consume(He.tokens.paren_right, "Expected ')' for agument list"), e2;
+  }
+  _optional_paren_expression() {
+    this._match(He.tokens.paren_left);
+    const e2 = this._short_circuit_or_expression();
+    return this._match(He.tokens.paren_right), e2;
+  }
+  _paren_expression() {
+    this._consume(He.tokens.paren_left, "Expected '('.");
+    const e2 = this._short_circuit_or_expression();
+    return this._consume(He.tokens.paren_right, "Expected ')'."), e2;
+  }
+  _struct_decl() {
+    if (!this._match(He.keywords.struct)) return null;
+    const e2 = this._currentLine, t2 = this._consume(He.tokens.ident, "Expected name for struct.").toString();
+    this._consume(He.tokens.brace_left, "Expected '{' for struct body.");
+    const n2 = [];
+    for (; !this._check(He.tokens.brace_right); ) {
+      const e3 = this._attribute(), t3 = this._consume(He.tokens.name, "Expected variable name.").toString();
+      this._consume(He.tokens.colon, "Expected ':' for struct member type.");
+      const s3 = this._attribute(), r3 = this._type_decl();
+      null != r3 && (r3.attributes = s3), this._check(He.tokens.brace_right) ? this._match(He.tokens.comma) : this._consume(He.tokens.comma, "Expected ',' for struct member."), n2.push(this._updateNode(new Ce(t3, r3, e3)));
+    }
+    this._consume(He.tokens.brace_right, "Expected '}' after struct body.");
+    const s2 = this._currentLine, r2 = this._updateNode(new oe(t2, n2, e2, s2), e2);
+    return this._context.structs.set(t2, r2), r2;
+  }
+  _global_variable_decl() {
+    const e2 = this._variable_decl();
+    if (!e2) return null;
+    if (this._match(He.tokens.equal)) {
+      const t2 = this._const_expression();
+      e2.value = t2;
+    }
+    if (null !== e2.type && e2.value instanceof xe) {
+      if ("x32" !== e2.value.type.name) {
+        if (e2.type.getTypeName() !== e2.value.type.getTypeName()) throw this._error(this._peek(), `Invalid cast from ${e2.value.type.name} to ${e2.type.name}. Line:${this._currentLine}`);
+      }
+      e2.value.isScalar && this._validateTypeRange(e2.value.scalarValue, e2.type), e2.value.type = e2.type;
+    } else null === e2.type && e2.value instanceof xe && (e2.type = "x32" === e2.value.type.name ? ae.i32 : e2.value.type, e2.value.isScalar && this._validateTypeRange(e2.value.scalarValue, e2.type));
+    return e2;
+  }
+  _override_variable_decl() {
+    const e2 = this._override_decl();
+    return e2 && this._match(He.tokens.equal) && (e2.value = this._const_expression()), e2;
+  }
+  _global_const_decl() {
+    var e2;
+    if (!this._match(He.keywords.const)) return null;
+    const t2 = this._consume(He.tokens.name, "Expected variable name"), n2 = this._currentLine;
+    let s2 = null;
+    if (this._match(He.tokens.colon)) {
+      const e3 = this._attribute();
+      s2 = this._type_decl(), null != s2 && (s2.attributes = e3);
+    }
+    let r2 = null;
+    this._consume(He.tokens.equal, "const declarations require an assignment");
+    const i2 = this._short_circuit_or_expression();
+    try {
+      let e3 = [ae.f32], n3 = i2.constEvaluate(this._exec, e3);
+      n3 instanceof Be && this._validateTypeRange(n3.value, e3[0]), e3[0] instanceof ce && null === e3[0].format && n3.typeInfo instanceof a && null !== n3.typeInfo.format && ("f16" === n3.typeInfo.format.name ? e3[0].format = ae.f16 : "f32" === n3.typeInfo.format.name ? e3[0].format = ae.f32 : "i32" === n3.typeInfo.format.name ? e3[0].format = ae.i32 : "u32" === n3.typeInfo.format.name ? e3[0].format = ae.u32 : "bool" === n3.typeInfo.format.name ? e3[0].format = ae.bool : console.error(`TODO: impelement template format type ${n3.typeInfo.format.name}`)), r2 = this._updateNode(new xe(n3, e3[0])), this._exec.context.setVariable(t2.toString(), n3);
+    } catch (e3) {
+      r2 = i2;
+    }
+    if (null !== s2 && r2 instanceof xe) {
+      if ("x32" !== r2.type.name) {
+        if (s2.getTypeName() !== r2.type.getTypeName()) throw this._error(this._peek(), `Invalid cast from ${r2.type.name} to ${s2.name}. Line:${this._currentLine}`);
+      }
+      r2.type = s2, r2.isScalar && this._validateTypeRange(r2.scalarValue, r2.type);
+    } else null === s2 && r2 instanceof xe && (s2 = null !== (e2 = null == r2 ? void 0 : r2.type) && void 0 !== e2 ? e2 : ae.f32, s2 === ae.x32 && (s2 = ae.i32));
+    const o2 = this._updateNode(new P(t2.toString(), s2, "", "", r2), n2);
+    return this._context.constants.set(o2.name, o2), o2;
+  }
+  _global_let_decl() {
+    if (!this._match(He.keywords.let)) return null;
+    const e2 = this._currentLine, t2 = this._consume(He.tokens.name, "Expected variable name");
+    let n2 = null;
+    if (this._match(He.tokens.colon)) {
+      const e3 = this._attribute();
+      n2 = this._type_decl(), null != n2 && (n2.attributes = e3);
+    }
+    let s2 = null;
+    if (this._match(He.tokens.equal) && (s2 = this._const_expression()), null !== n2 && s2 instanceof xe) {
+      if ("x32" !== s2.type.name) {
+        if (n2.getTypeName() !== s2.type.getTypeName()) throw this._error(this._peek(), `Invalid cast from ${s2.type.name} to ${n2.name}. Line:${this._currentLine}`);
+      }
+      s2.type = n2;
+    } else null === n2 && s2 instanceof xe && (n2 = "x32" === s2.type.name ? ae.i32 : s2.type);
+    return s2 instanceof xe && s2.isScalar && this._validateTypeRange(s2.scalarValue, n2), this._updateNode(new U(t2.toString(), n2, "", "", s2), e2);
+  }
+  _const_expression() {
+    return this._short_circuit_or_expression();
+  }
+  _variable_decl() {
+    if (!this._match(He.keywords.var)) return null;
+    const e2 = this._currentLine;
+    let t2 = "", n2 = "";
+    this._match(He.tokens.less_than) && (t2 = this._consume(He.storage_class, "Expected storage_class.").toString(), this._match(He.tokens.comma) && (n2 = this._consume(He.access_mode, "Expected access_mode.").toString()), this._consume(He.tokens.greater_than, "Expected '>'."));
+    const s2 = this._consume(He.tokens.name, "Expected variable name");
+    let r2 = null;
+    if (this._match(He.tokens.colon)) {
+      const e3 = this._attribute();
+      r2 = this._type_decl(), null != r2 && (r2.attributes = e3);
+    }
+    return this._updateNode(new F(s2.toString(), r2, t2, n2, null), e2);
+  }
+  _override_decl() {
+    if (!this._match(He.keywords.override)) return null;
+    const e2 = this._consume(He.tokens.name, "Expected variable name");
+    let t2 = null;
+    if (this._match(He.tokens.colon)) {
+      const e3 = this._attribute();
+      t2 = this._type_decl(), null != t2 && (t2.attributes = e3);
+    }
+    return this._updateNode(new M(e2.toString(), t2, null));
+  }
+  _diagnostic() {
+    this._consume(He.tokens.paren_left, "Expected '('");
+    const e2 = this._consume(He.tokens.ident, "Expected severity control name.");
+    this._consume(He.tokens.comma, "Expected ','");
+    let t2 = this._consume(He.tokens.ident, "Expected diagnostic rule name.").toString();
+    if (this._match(He.tokens.period)) {
+      t2 += `.${this._consume(He.tokens.ident, "Expected diagnostic message.").toString()}`;
+    }
+    return this._consume(He.tokens.paren_right, "Expected ')'"), this._updateNode(new ee(e2.toString(), t2));
+  }
+  _enable_directive() {
+    const e2 = this._consume(He.tokens.ident, "identity expected.");
+    return this._updateNode(new K(e2.toString()));
+  }
+  _requires_directive() {
+    const e2 = [this._consume(He.tokens.ident, "identity expected.").toString()];
+    for (; this._match(He.tokens.comma); ) {
+      const t2 = this._consume(He.tokens.ident, "identity expected.");
+      e2.push(t2.toString());
+    }
+    return this._updateNode(new J(e2));
+  }
+  _type_alias() {
+    const e2 = this._consume(He.tokens.ident, "identity expected.");
+    this._consume(He.tokens.equal, "Expected '=' for type alias.");
+    let t2 = this._type_decl();
+    if (null === t2) throw this._error(this._peek(), "Expected Type for Alias.");
+    this._context.aliases.has(t2.name) && (t2 = this._context.aliases.get(t2.name).type);
+    const n2 = this._updateNode(new te(e2.toString(), t2));
+    return this._context.aliases.set(n2.name, n2), n2;
+  }
+  _type_decl() {
+    if (this._check([He.tokens.ident, ...He.texel_format, He.keywords.bool, He.keywords.f32, He.keywords.i32, He.keywords.u32])) {
+      const e3 = this._advance().toString();
+      if (this._context.structs.has(e3)) return this._context.structs.get(e3);
+      if (this._context.aliases.has(e3)) return this._context.aliases.get(e3).type;
+      if (!this._getType(e3)) {
+        const t3 = this._updateNode(new ie(e3));
+        return this._forwardTypeCount++, t3;
+      }
+      return this._updateNode(new ae(e3));
+    }
+    let e2 = this._texture_sampler_types();
+    if (e2) return e2;
+    if (this._check(He.template_types)) {
+      let e3 = this._advance().toString(), t3 = null, n2 = null;
+      this._match(He.tokens.less_than) && (t3 = this._type_decl(), n2 = null, this._match(He.tokens.comma) && (n2 = this._consume(He.access_mode, "Expected access_mode for pointer").toString()), this._consume(He.tokens.greater_than, "Expected '>' for type."));
+      return this._updateNode(new ce(e3, t3, n2));
+    }
+    if (this._match(He.keywords.ptr)) {
+      let e3 = this._previous().toString();
+      this._consume(He.tokens.less_than, "Expected '<' for pointer.");
+      const t3 = this._consume(He.storage_class, "Expected storage_class for pointer");
+      this._consume(He.tokens.comma, "Expected ',' for pointer.");
+      const n2 = this._type_decl();
+      let s2 = null;
+      this._match(He.tokens.comma) && (s2 = this._consume(He.access_mode, "Expected access_mode for pointer").toString()), this._consume(He.tokens.greater_than, "Expected '>' for pointer.");
+      return this._updateNode(new le(e3, t3.toString(), n2, s2));
+    }
+    const t2 = this._attribute();
+    if (this._match(He.keywords.array)) {
+      let e3 = null, n2 = -1;
+      const s2 = this._previous();
+      let r2 = null;
+      if (this._match(He.tokens.less_than)) {
+        e3 = this._type_decl(), this._context.aliases.has(e3.name) && (e3 = this._context.aliases.get(e3.name).type);
+        let t3 = "";
+        if (this._match(He.tokens.comma)) {
+          r2 = this._shift_expression();
+          try {
+            t3 = r2.constEvaluate(this._exec).toString(), r2 = null;
+          } catch (e4) {
+            t3 = "1";
+          }
+        }
+        this._consume(He.tokens.greater_than, "Expected '>' for array."), n2 = t3 ? parseInt(t3) : 0;
+      }
+      const a2 = this._updateNode(new ue(s2.toString(), t2, e3, n2));
+      return r2 && this._deferArrayCountEval.push({ arrayType: a2, countNode: r2 }), a2;
+    }
+    return null;
+  }
+  _texture_sampler_types() {
+    if (this._match(He.sampler_type)) return this._updateNode(new he(this._previous().toString(), null, null));
+    if (this._match(He.depth_texture_type)) return this._updateNode(new he(this._previous().toString(), null, null));
+    if (this._match(He.sampled_texture_type) || this._match(He.multisampled_texture_type)) {
+      const e2 = this._previous();
+      this._consume(He.tokens.less_than, "Expected '<' for sampler type.");
+      const t2 = this._type_decl();
+      return this._consume(He.tokens.greater_than, "Expected '>' for sampler type."), this._updateNode(new he(e2.toString(), t2, null));
+    }
+    if (this._match(He.storage_texture_type)) {
+      const e2 = this._previous();
+      this._consume(He.tokens.less_than, "Expected '<' for sampler type.");
+      const t2 = this._consume(He.texel_format, "Invalid texel format.").toString();
+      this._consume(He.tokens.comma, "Expected ',' after texel format.");
+      const n2 = this._consume(He.access_mode, "Expected access mode for storage texture type.").toString();
+      return this._consume(He.tokens.greater_than, "Expected '>' for sampler type."), this._updateNode(new he(e2.toString(), t2, n2));
+    }
+    return null;
+  }
+  _attribute() {
+    let e2 = [];
+    for (; this._match(He.tokens.attr); ) {
+      const t2 = this._consume(He.attribute_name, "Expected attribute name"), n2 = this._updateNode(new De(t2.toString(), null));
+      if (this._match(He.tokens.paren_left)) {
+        if (n2.value = this._consume(He.literal_or_ident, "Expected attribute value").toString(), this._check(He.tokens.comma)) {
+          this._advance();
+          do {
+            const e3 = this._consume(He.literal_or_ident, "Expected attribute value").toString();
+            n2.value instanceof Array || (n2.value = [n2.value]), n2.value.push(e3);
+          } while (this._match(He.tokens.comma));
+        }
+        this._consume(He.tokens.paren_right, "Expected ')'");
+      }
+      e2.push(n2);
+    }
+    return 0 == e2.length ? null : e2;
+  }
+}
+class _t extends at {
+  constructor(e2) {
+    super(), e2 && this.update(e2);
+  }
+  update(e2) {
+    const t2 = new gt().parse(e2);
+    this.updateAST(t2);
+  }
+}
+function getShaderLayoutFromWGSL(source2) {
+  var _a3;
+  const shaderLayout = { attributes: [], bindings: [] };
+  let parsedWGSL;
+  try {
+    parsedWGSL = parseWGSL(source2);
+  } catch (error) {
+    log.error(error.message)();
+    return shaderLayout;
+  }
+  for (const uniform of parsedWGSL.uniforms) {
+    const members = [];
+    for (const attribute of ((_a3 = uniform.type) == null ? void 0 : _a3.members) || []) {
+      members.push({
+        name: attribute.name,
+        type: getType(attribute.type)
+      });
+    }
+    shaderLayout.bindings.push({
+      type: "uniform",
+      name: uniform.name,
+      group: uniform.group,
+      location: uniform.binding,
+      // @ts-expect-error TODO - unused for now but needs fixing
+      members
+    });
+  }
+  for (const texture of parsedWGSL.textures) {
+    shaderLayout.bindings.push({
+      type: "texture",
+      name: texture.name,
+      group: texture.group,
+      location: texture.binding
+    });
+  }
+  for (const sampler of parsedWGSL.samplers) {
+    shaderLayout.bindings.push({
+      type: "sampler",
+      name: sampler.name,
+      group: sampler.group,
+      location: sampler.binding
+    });
+  }
+  const vertex2 = parsedWGSL.entry.vertex[0];
+  const attributeCount = (vertex2 == null ? void 0 : vertex2.inputs.length) || 0;
+  for (let i2 = 0; i2 < attributeCount; i2++) {
+    const wgslAttribute = vertex2.inputs[i2];
+    if (wgslAttribute.locationType === "location") {
+      const type = getType(wgslAttribute.type);
+      shaderLayout.attributes.push({
+        name: wgslAttribute.name,
+        location: Number(wgslAttribute.location),
+        type
+      });
+    }
+  }
+  return shaderLayout;
+}
+function getType(type) {
+  return (type == null ? void 0 : type.format) ? `${type.name}<${type.format.name}>` : type.name;
+}
+function parseWGSL(source2) {
+  try {
+    return new _t(source2);
+  } catch (error) {
+    if (error instanceof Error) {
+      throw error;
+    }
+    let message2 = "WGSL parse error";
+    if (typeof error === "object" && (error == null ? void 0 : error.message)) {
+      message2 += `: ${error.message} `;
+    }
+    if (typeof error === "object" && (error == null ? void 0 : error.token)) {
+      message2 += error.token.line || "";
+    }
+    throw new Error(message2, { cause: error });
+  }
+}
+const DEFAULT_CONFIG = {
+  EPSILON: 1e-12,
+  debug: false,
+  precision: 4,
+  printTypes: false,
+  printDegrees: false,
+  printRowMajor: true,
+  _cartographicRadians: false
+};
+globalThis.mathgl = globalThis.mathgl || { config: { ...DEFAULT_CONFIG } };
+const config = globalThis.mathgl.config;
+function formatValue(value, { precision = config.precision } = {}) {
+  value = round(value);
+  return `${parseFloat(value.toPrecision(precision))}`;
+}
+function isArray$3(value) {
+  return Array.isArray(value) || ArrayBuffer.isView(value) && !(value instanceof DataView);
+}
+function clamp$1(value, min, max) {
+  return map$1(value, (value2) => Math.max(min, Math.min(max, value2)));
+}
+function lerp$2(a2, b2, t2) {
+  if (isArray$3(a2)) {
+    return a2.map((ai2, i2) => lerp$2(ai2, b2[i2], t2));
+  }
+  return t2 * b2 + (1 - t2) * a2;
+}
+function equals(a2, b2, epsilon) {
+  const oldEpsilon = config.EPSILON;
+  try {
+    if (a2 === b2) {
+      return true;
+    }
+    if (isArray$3(a2) && isArray$3(b2)) {
+      if (a2.length !== b2.length) {
+        return false;
+      }
+      for (let i2 = 0; i2 < a2.length; ++i2) {
+        if (!equals(a2[i2], b2[i2])) {
+          return false;
+        }
+      }
+      return true;
+    }
+    if (a2 && a2.equals) {
+      return a2.equals(b2);
+    }
+    if (b2 && b2.equals) {
+      return b2.equals(a2);
+    }
+    if (typeof a2 === "number" && typeof b2 === "number") {
+      return Math.abs(a2 - b2) <= config.EPSILON * Math.max(1, Math.abs(a2), Math.abs(b2));
+    }
+    return false;
+  } finally {
+    config.EPSILON = oldEpsilon;
+  }
+}
+function round(value) {
+  return Math.round(value / config.EPSILON) * config.EPSILON;
+}
+function duplicateArray(array) {
+  return array.clone ? array.clone() : new Array(array.length);
+}
+function map$1(value, func, result) {
+  if (isArray$3(value)) {
+    const array = value;
+    result = result || duplicateArray(array);
+    for (let i2 = 0; i2 < result.length && i2 < array.length; ++i2) {
+      const val = typeof value === "number" ? value : value[i2];
+      result[i2] = func(val, i2, result);
+    }
+    return result;
+  }
+  return func(value);
+}
+class MathArray extends Array {
+  // Common methods
+  /**
+   * Clone the current object
+   * @returns a new copy of this object
+   */
+  clone() {
+    return new this.constructor().copy(this);
+  }
+  fromArray(array, offset = 0) {
+    for (let i2 = 0; i2 < this.ELEMENTS; ++i2) {
+      this[i2] = array[i2 + offset];
+    }
+    return this.check();
+  }
+  toArray(targetArray = [], offset = 0) {
+    for (let i2 = 0; i2 < this.ELEMENTS; ++i2) {
+      targetArray[offset + i2] = this[i2];
+    }
+    return targetArray;
+  }
+  toObject(targetObject) {
+    return targetObject;
+  }
+  from(arrayOrObject) {
+    return Array.isArray(arrayOrObject) ? this.copy(arrayOrObject) : (
+      // @ts-ignore
+      this.fromObject(arrayOrObject)
+    );
+  }
+  to(arrayOrObject) {
+    if (arrayOrObject === this) {
+      return this;
+    }
+    return isArray$3(arrayOrObject) ? this.toArray(arrayOrObject) : this.toObject(arrayOrObject);
+  }
+  toTarget(target) {
+    return target ? this.to(target) : this;
+  }
+  /** @deprecated */
+  toFloat32Array() {
+    return new Float32Array(this);
+  }
+  toString() {
+    return this.formatString(config);
+  }
+  /** Formats string according to options */
+  formatString(opts) {
+    let string = "";
+    for (let i2 = 0; i2 < this.ELEMENTS; ++i2) {
+      string += (i2 > 0 ? ", " : "") + formatValue(this[i2], opts);
+    }
+    return `${opts.printTypes ? this.constructor.name : ""}[${string}]`;
+  }
+  equals(array) {
+    if (!array || this.length !== array.length) {
+      return false;
+    }
+    for (let i2 = 0; i2 < this.ELEMENTS; ++i2) {
+      if (!equals(this[i2], array[i2])) {
+        return false;
+      }
+    }
+    return true;
+  }
+  exactEquals(array) {
+    if (!array || this.length !== array.length) {
+      return false;
+    }
+    for (let i2 = 0; i2 < this.ELEMENTS; ++i2) {
+      if (this[i2] !== array[i2]) {
+        return false;
+      }
+    }
+    return true;
+  }
+  // Modifiers
+  /** Negates all values in this object */
+  negate() {
+    for (let i2 = 0; i2 < this.ELEMENTS; ++i2) {
+      this[i2] = -this[i2];
+    }
+    return this.check();
+  }
+  lerp(a2, b2, t2) {
+    if (t2 === void 0) {
+      return this.lerp(this, a2, b2);
+    }
+    for (let i2 = 0; i2 < this.ELEMENTS; ++i2) {
+      const ai2 = a2[i2];
+      const endValue = typeof b2 === "number" ? b2 : b2[i2];
+      this[i2] = ai2 + t2 * (endValue - ai2);
+    }
+    return this.check();
+  }
+  /** Minimal */
+  min(vector) {
+    for (let i2 = 0; i2 < this.ELEMENTS; ++i2) {
+      this[i2] = Math.min(vector[i2], this[i2]);
+    }
+    return this.check();
+  }
+  /** Maximal */
+  max(vector) {
+    for (let i2 = 0; i2 < this.ELEMENTS; ++i2) {
+      this[i2] = Math.max(vector[i2], this[i2]);
+    }
+    return this.check();
+  }
+  clamp(minVector, maxVector) {
+    for (let i2 = 0; i2 < this.ELEMENTS; ++i2) {
+      this[i2] = Math.min(Math.max(this[i2], minVector[i2]), maxVector[i2]);
+    }
+    return this.check();
+  }
+  add(...vectors) {
+    for (const vector of vectors) {
+      for (let i2 = 0; i2 < this.ELEMENTS; ++i2) {
+        this[i2] += vector[i2];
+      }
+    }
+    return this.check();
+  }
+  subtract(...vectors) {
+    for (const vector of vectors) {
+      for (let i2 = 0; i2 < this.ELEMENTS; ++i2) {
+        this[i2] -= vector[i2];
+      }
+    }
+    return this.check();
+  }
+  scale(scale2) {
+    if (typeof scale2 === "number") {
+      for (let i2 = 0; i2 < this.ELEMENTS; ++i2) {
+        this[i2] *= scale2;
+      }
+    } else {
+      for (let i2 = 0; i2 < this.ELEMENTS && i2 < scale2.length; ++i2) {
+        this[i2] *= scale2[i2];
+      }
+    }
+    return this.check();
+  }
+  /**
+   * Multiplies all elements by `scale`
+   * Note: `Matrix4.multiplyByScalar` only scales its 3x3 "minor"
+   */
+  multiplyByScalar(scalar) {
+    for (let i2 = 0; i2 < this.ELEMENTS; ++i2) {
+      this[i2] *= scalar;
+    }
+    return this.check();
+  }
+  // Debug checks
+  /** Throws an error if array length is incorrect or contains illegal values */
+  check() {
+    if (config.debug && !this.validate()) {
+      throw new Error(`math.gl: ${this.constructor.name} some fields set to invalid numbers'`);
+    }
+    return this;
+  }
+  /** Returns false if the array length is incorrect or contains illegal values */
+  validate() {
+    let valid = this.length === this.ELEMENTS;
+    for (let i2 = 0; i2 < this.ELEMENTS; ++i2) {
+      valid = valid && Number.isFinite(this[i2]);
+    }
+    return valid;
+  }
+  // three.js compatibility
+  /** @deprecated */
+  sub(a2) {
+    return this.subtract(a2);
+  }
+  /** @deprecated */
+  setScalar(a2) {
+    for (let i2 = 0; i2 < this.ELEMENTS; ++i2) {
+      this[i2] = a2;
+    }
+    return this.check();
+  }
+  /** @deprecated */
+  addScalar(a2) {
+    for (let i2 = 0; i2 < this.ELEMENTS; ++i2) {
+      this[i2] += a2;
+    }
+    return this.check();
+  }
+  /** @deprecated */
+  subScalar(a2) {
+    return this.addScalar(-a2);
+  }
+  /** @deprecated */
+  multiplyScalar(scalar) {
+    for (let i2 = 0; i2 < this.ELEMENTS; ++i2) {
+      this[i2] *= scalar;
+    }
+    return this.check();
+  }
+  /** @deprecated */
+  divideScalar(a2) {
+    return this.multiplyByScalar(1 / a2);
+  }
+  /** @deprecated */
+  clampScalar(min, max) {
+    for (let i2 = 0; i2 < this.ELEMENTS; ++i2) {
+      this[i2] = Math.min(Math.max(this[i2], min), max);
+    }
+    return this.check();
+  }
+  /** @deprecated */
+  get elements() {
+    return this;
+  }
+}
+function validateVector(v2, length2) {
+  if (v2.length !== length2) {
+    return false;
+  }
+  for (let i2 = 0; i2 < v2.length; ++i2) {
+    if (!Number.isFinite(v2[i2])) {
+      return false;
+    }
+  }
+  return true;
+}
+function checkNumber(value) {
+  if (!Number.isFinite(value)) {
+    throw new Error(`Invalid number ${JSON.stringify(value)}`);
+  }
+  return value;
+}
+function checkVector(v2, length2, callerName = "") {
+  if (config.debug && !validateVector(v2, length2)) {
+    throw new Error(`math.gl: ${callerName} some fields set to invalid numbers'`);
+  }
+  return v2;
+}
+function assert$2(condition, message2) {
+  if (!condition) {
+    throw new Error(`math.gl assertion ${message2}`);
+  }
+}
+class Vector2 extends MathArray {
+  // ACCESSORS
+  get x() {
+    return this[0];
+  }
+  set x(value) {
+    this[0] = checkNumber(value);
+  }
+  get y() {
+    return this[1];
+  }
+  set y(value) {
+    this[1] = checkNumber(value);
+  }
+  /**
+   * Returns the length of the vector from the origin to the point described by this vector
+   *
+   * @note `length` is a reserved word for Arrays, so `v.length()` will return number of elements
+   * Instead we provide `len` and `magnitude`
+   */
+  len() {
+    return Math.sqrt(this.lengthSquared());
+  }
+  /**
+   * Returns the length of the vector from the origin to the point described by this vector
+   */
+  magnitude() {
+    return this.len();
+  }
+  /**
+   * Returns the squared length of the vector from the origin to the point described by this vector
+   */
+  lengthSquared() {
+    let length2 = 0;
+    for (let i2 = 0; i2 < this.ELEMENTS; ++i2) {
+      length2 += this[i2] * this[i2];
+    }
+    return length2;
+  }
+  /**
+   * Returns the squared length of the vector from the origin to the point described by this vector
+   */
+  magnitudeSquared() {
+    return this.lengthSquared();
+  }
+  distance(mathArray) {
+    return Math.sqrt(this.distanceSquared(mathArray));
+  }
+  distanceSquared(mathArray) {
+    let length2 = 0;
+    for (let i2 = 0; i2 < this.ELEMENTS; ++i2) {
+      const dist = this[i2] - mathArray[i2];
+      length2 += dist * dist;
+    }
+    return checkNumber(length2);
+  }
+  dot(mathArray) {
+    let product = 0;
+    for (let i2 = 0; i2 < this.ELEMENTS; ++i2) {
+      product += this[i2] * mathArray[i2];
+    }
+    return checkNumber(product);
+  }
+  // MODIFIERS
+  normalize() {
+    const length2 = this.magnitude();
+    if (length2 !== 0) {
+      for (let i2 = 0; i2 < this.ELEMENTS; ++i2) {
+        this[i2] /= length2;
+      }
+    }
+    return this.check();
+  }
+  multiply(...vectors) {
+    for (const vector of vectors) {
+      for (let i2 = 0; i2 < this.ELEMENTS; ++i2) {
+        this[i2] *= vector[i2];
+      }
+    }
+    return this.check();
+  }
+  divide(...vectors) {
+    for (const vector of vectors) {
+      for (let i2 = 0; i2 < this.ELEMENTS; ++i2) {
+        this[i2] /= vector[i2];
+      }
+    }
+    return this.check();
+  }
+  // THREE.js compatibility
+  lengthSq() {
+    return this.lengthSquared();
+  }
+  distanceTo(vector) {
+    return this.distance(vector);
+  }
+  distanceToSquared(vector) {
+    return this.distanceSquared(vector);
+  }
+  getComponent(i2) {
+    assert$2(i2 >= 0 && i2 < this.ELEMENTS, "index is out of range");
+    return checkNumber(this[i2]);
+  }
+  setComponent(i2, value) {
+    assert$2(i2 >= 0 && i2 < this.ELEMENTS, "index is out of range");
+    this[i2] = value;
+    return this.check();
+  }
+  addVectors(a2, b2) {
+    return this.copy(a2).add(b2);
+  }
+  subVectors(a2, b2) {
+    return this.copy(a2).subtract(b2);
+  }
+  multiplyVectors(a2, b2) {
+    return this.copy(a2).multiply(b2);
+  }
+  addScaledVector(a2, b2) {
+    return this.add(new this.constructor(a2).multiplyScalar(b2));
+  }
+}
+const EPSILON$1 = 1e-6;
+let ARRAY_TYPE = typeof Float32Array !== "undefined" ? Float32Array : Array;
+function create$2() {
+  const out = new ARRAY_TYPE(2);
+  if (ARRAY_TYPE != Float32Array) {
+    out[0] = 0;
+    out[1] = 0;
+  }
+  return out;
+}
+function add$1(out, a2, b2) {
+  out[0] = a2[0] + b2[0];
+  out[1] = a2[1] + b2[1];
+  return out;
+}
+function negate$1(out, a2) {
+  out[0] = -a2[0];
+  out[1] = -a2[1];
+  return out;
+}
+function lerp$1(out, a2, b2, t2) {
+  const ax = a2[0];
+  const ay = a2[1];
+  out[0] = ax + t2 * (b2[0] - ax);
+  out[1] = ay + t2 * (b2[1] - ay);
+  return out;
+}
+function transformMat4$2(out, a2, m2) {
+  const x2 = a2[0];
+  const y2 = a2[1];
+  out[0] = m2[0] * x2 + m2[4] * y2 + m2[12];
+  out[1] = m2[1] * x2 + m2[5] * y2 + m2[13];
+  return out;
+}
+(function() {
+  const vec = create$2();
+  return function(a2, stride, offset, count2, fn, arg) {
+    let i2;
+    let l2;
+    if (!stride) {
+      stride = 2;
+    }
+    if (!offset) {
+      offset = 0;
+    }
+    if (count2) {
+      l2 = Math.min(count2 * stride + offset, a2.length);
+    } else {
+      l2 = a2.length;
+    }
+    for (i2 = offset; i2 < l2; i2 += stride) {
+      vec[0] = a2[i2];
+      vec[1] = a2[i2 + 1];
+      fn(vec, vec, arg);
+      a2[i2] = vec[0];
+      a2[i2 + 1] = vec[1];
+    }
+    return a2;
+  };
+})();
+function vec2_transformMat4AsVector(out, a2, m2) {
+  const x2 = a2[0];
+  const y2 = a2[1];
+  const w2 = m2[3] * x2 + m2[7] * y2 || 1;
+  out[0] = (m2[0] * x2 + m2[4] * y2) / w2;
+  out[1] = (m2[1] * x2 + m2[5] * y2) / w2;
+  return out;
+}
+function vec3_transformMat4AsVector(out, a2, m2) {
+  const x2 = a2[0];
+  const y2 = a2[1];
+  const z2 = a2[2];
+  const w2 = m2[3] * x2 + m2[7] * y2 + m2[11] * z2 || 1;
+  out[0] = (m2[0] * x2 + m2[4] * y2 + m2[8] * z2) / w2;
+  out[1] = (m2[1] * x2 + m2[5] * y2 + m2[9] * z2) / w2;
+  out[2] = (m2[2] * x2 + m2[6] * y2 + m2[10] * z2) / w2;
+  return out;
+}
+function vec3_transformMat2(out, a2, m2) {
+  const x2 = a2[0];
+  const y2 = a2[1];
+  out[0] = m2[0] * x2 + m2[2] * y2;
+  out[1] = m2[1] * x2 + m2[3] * y2;
+  out[2] = a2[2];
+  return out;
+}
+function create$1() {
+  const out = new ARRAY_TYPE(3);
+  if (ARRAY_TYPE != Float32Array) {
+    out[0] = 0;
+    out[1] = 0;
+    out[2] = 0;
+  }
+  return out;
+}
+function length(a2) {
+  const x2 = a2[0];
+  const y2 = a2[1];
+  const z2 = a2[2];
+  return Math.sqrt(x2 * x2 + y2 * y2 + z2 * z2);
+}
+function subtract(out, a2, b2) {
+  out[0] = a2[0] - b2[0];
+  out[1] = a2[1] - b2[1];
+  out[2] = a2[2] - b2[2];
+  return out;
+}
+function squaredLength(a2) {
+  const x2 = a2[0];
+  const y2 = a2[1];
+  const z2 = a2[2];
+  return x2 * x2 + y2 * y2 + z2 * z2;
+}
+function negate(out, a2) {
+  out[0] = -a2[0];
+  out[1] = -a2[1];
+  out[2] = -a2[2];
+  return out;
+}
+function dot(a2, b2) {
+  return a2[0] * b2[0] + a2[1] * b2[1] + a2[2] * b2[2];
+}
+function cross(out, a2, b2) {
+  const ax = a2[0];
+  const ay = a2[1];
+  const az = a2[2];
+  const bx = b2[0];
+  const by = b2[1];
+  const bz = b2[2];
+  out[0] = ay * bz - az * by;
+  out[1] = az * bx - ax * bz;
+  out[2] = ax * by - ay * bx;
+  return out;
+}
+function lerp(out, a2, b2, t2) {
+  const ax = a2[0];
+  const ay = a2[1];
+  const az = a2[2];
+  out[0] = ax + t2 * (b2[0] - ax);
+  out[1] = ay + t2 * (b2[1] - ay);
+  out[2] = az + t2 * (b2[2] - az);
+  return out;
+}
+function transformMat4$1(out, a2, m2) {
+  const x2 = a2[0];
+  const y2 = a2[1];
+  const z2 = a2[2];
+  let w2 = m2[3] * x2 + m2[7] * y2 + m2[11] * z2 + m2[15];
+  w2 = w2 || 1;
+  out[0] = (m2[0] * x2 + m2[4] * y2 + m2[8] * z2 + m2[12]) / w2;
+  out[1] = (m2[1] * x2 + m2[5] * y2 + m2[9] * z2 + m2[13]) / w2;
+  out[2] = (m2[2] * x2 + m2[6] * y2 + m2[10] * z2 + m2[14]) / w2;
+  return out;
+}
+function transformMat3(out, a2, m2) {
+  const x2 = a2[0];
+  const y2 = a2[1];
+  const z2 = a2[2];
+  out[0] = x2 * m2[0] + y2 * m2[3] + z2 * m2[6];
+  out[1] = x2 * m2[1] + y2 * m2[4] + z2 * m2[7];
+  out[2] = x2 * m2[2] + y2 * m2[5] + z2 * m2[8];
+  return out;
+}
+function transformQuat(out, a2, q2) {
+  const qx = q2[0];
+  const qy = q2[1];
+  const qz = q2[2];
+  const qw = q2[3];
+  const x2 = a2[0];
+  const y2 = a2[1];
+  const z2 = a2[2];
+  let uvx = qy * z2 - qz * y2;
+  let uvy = qz * x2 - qx * z2;
+  let uvz = qx * y2 - qy * x2;
+  let uuvx = qy * uvz - qz * uvy;
+  let uuvy = qz * uvx - qx * uvz;
+  let uuvz = qx * uvy - qy * uvx;
+  const w2 = qw * 2;
+  uvx *= w2;
+  uvy *= w2;
+  uvz *= w2;
+  uuvx *= 2;
+  uuvy *= 2;
+  uuvz *= 2;
+  out[0] = x2 + uvx + uuvx;
+  out[1] = y2 + uvy + uuvy;
+  out[2] = z2 + uvz + uuvz;
+  return out;
+}
+function rotateX$1(out, a2, b2, rad) {
+  const p2 = [];
+  const r2 = [];
+  p2[0] = a2[0] - b2[0];
+  p2[1] = a2[1] - b2[1];
+  p2[2] = a2[2] - b2[2];
+  r2[0] = p2[0];
+  r2[1] = p2[1] * Math.cos(rad) - p2[2] * Math.sin(rad);
+  r2[2] = p2[1] * Math.sin(rad) + p2[2] * Math.cos(rad);
+  out[0] = r2[0] + b2[0];
+  out[1] = r2[1] + b2[1];
+  out[2] = r2[2] + b2[2];
+  return out;
+}
+function rotateY$1(out, a2, b2, rad) {
+  const p2 = [];
+  const r2 = [];
+  p2[0] = a2[0] - b2[0];
+  p2[1] = a2[1] - b2[1];
+  p2[2] = a2[2] - b2[2];
+  r2[0] = p2[2] * Math.sin(rad) + p2[0] * Math.cos(rad);
+  r2[1] = p2[1];
+  r2[2] = p2[2] * Math.cos(rad) - p2[0] * Math.sin(rad);
+  out[0] = r2[0] + b2[0];
+  out[1] = r2[1] + b2[1];
+  out[2] = r2[2] + b2[2];
+  return out;
+}
+function rotateZ$1(out, a2, b2, rad) {
+  const p2 = [];
+  const r2 = [];
+  p2[0] = a2[0] - b2[0];
+  p2[1] = a2[1] - b2[1];
+  p2[2] = a2[2] - b2[2];
+  r2[0] = p2[0] * Math.cos(rad) - p2[1] * Math.sin(rad);
+  r2[1] = p2[0] * Math.sin(rad) + p2[1] * Math.cos(rad);
+  r2[2] = p2[2];
+  out[0] = r2[0] + b2[0];
+  out[1] = r2[1] + b2[1];
+  out[2] = r2[2] + b2[2];
+  return out;
+}
+function angle(a2, b2) {
+  const ax = a2[0];
+  const ay = a2[1];
+  const az = a2[2];
+  const bx = b2[0];
+  const by = b2[1];
+  const bz = b2[2];
+  const mag = Math.sqrt((ax * ax + ay * ay + az * az) * (bx * bx + by * by + bz * bz));
+  const cosine = mag && dot(a2, b2) / mag;
+  return Math.acos(Math.min(Math.max(cosine, -1), 1));
+}
+const sub = subtract;
+const len = length;
+const sqrLen = squaredLength;
+(function() {
+  const vec = create$1();
+  return function(a2, stride, offset, count2, fn, arg) {
+    let i2;
+    let l2;
+    if (!stride) {
+      stride = 3;
+    }
+    if (!offset) {
+      offset = 0;
+    }
+    if (count2) {
+      l2 = Math.min(count2 * stride + offset, a2.length);
+    } else {
+      l2 = a2.length;
+    }
+    for (i2 = offset; i2 < l2; i2 += stride) {
+      vec[0] = a2[i2];
+      vec[1] = a2[i2 + 1];
+      vec[2] = a2[i2 + 2];
+      fn(vec, vec, arg);
+      a2[i2] = vec[0];
+      a2[i2 + 1] = vec[1];
+      a2[i2 + 2] = vec[2];
+    }
+    return a2;
+  };
+})();
+const ORIGIN = [0, 0, 0];
+let ZERO$1;
+class Vector3 extends Vector2 {
+  static get ZERO() {
+    if (!ZERO$1) {
+      ZERO$1 = new Vector3(0, 0, 0);
+      Object.freeze(ZERO$1);
+    }
+    return ZERO$1;
+  }
+  /**
+   * @class
+   * @param x
+   * @param y
+   * @param z
+   */
+  constructor(x2 = 0, y2 = 0, z2 = 0) {
+    super(-0, -0, -0);
+    if (arguments.length === 1 && isArray$3(x2)) {
+      this.copy(x2);
+    } else {
+      if (config.debug) {
+        checkNumber(x2);
+        checkNumber(y2);
+        checkNumber(z2);
+      }
+      this[0] = x2;
+      this[1] = y2;
+      this[2] = z2;
+    }
+  }
+  set(x2, y2, z2) {
+    this[0] = x2;
+    this[1] = y2;
+    this[2] = z2;
+    return this.check();
+  }
+  copy(array) {
+    this[0] = array[0];
+    this[1] = array[1];
+    this[2] = array[2];
+    return this.check();
+  }
+  fromObject(object) {
+    if (config.debug) {
+      checkNumber(object.x);
+      checkNumber(object.y);
+      checkNumber(object.z);
+    }
+    this[0] = object.x;
+    this[1] = object.y;
+    this[2] = object.z;
+    return this.check();
+  }
+  toObject(object) {
+    object.x = this[0];
+    object.y = this[1];
+    object.z = this[2];
+    return object;
+  }
+  // Getters/setters
+  get ELEMENTS() {
+    return 3;
+  }
+  get z() {
+    return this[2];
+  }
+  set z(value) {
+    this[2] = checkNumber(value);
+  }
+  // ACCESSORS
+  angle(vector) {
+    return angle(this, vector);
+  }
+  // MODIFIERS
+  cross(vector) {
+    cross(this, this, vector);
+    return this.check();
+  }
+  rotateX({ radians, origin = ORIGIN }) {
+    rotateX$1(this, this, origin, radians);
+    return this.check();
+  }
+  rotateY({ radians, origin = ORIGIN }) {
+    rotateY$1(this, this, origin, radians);
+    return this.check();
+  }
+  rotateZ({ radians, origin = ORIGIN }) {
+    rotateZ$1(this, this, origin, radians);
+    return this.check();
+  }
+  // Transforms
+  // transforms as point (4th component is implicitly 1)
+  transform(matrix4) {
+    return this.transformAsPoint(matrix4);
+  }
+  // transforms as point (4th component is implicitly 1)
+  transformAsPoint(matrix4) {
+    transformMat4$1(this, this, matrix4);
+    return this.check();
+  }
+  // transforms as vector  (4th component is implicitly 0, ignores translation. slightly faster)
+  transformAsVector(matrix4) {
+    vec3_transformMat4AsVector(this, this, matrix4);
+    return this.check();
+  }
+  transformByMatrix3(matrix3) {
+    transformMat3(this, this, matrix3);
+    return this.check();
+  }
+  transformByMatrix2(matrix2) {
+    vec3_transformMat2(this, this, matrix2);
+    return this.check();
+  }
+  transformByQuaternion(quaternion) {
+    transformQuat(this, this, quaternion);
+    return this.check();
+  }
+}
+class Matrix extends MathArray {
+  // fromObject(object) {
+  //   const array = object.elements;
+  //   return this.fromRowMajor(array);
+  // }
+  // toObject(object) {
+  //   const array = object.elements;
+  //   this.toRowMajor(array);
+  //   return object;
+  // }
+  // TODO better override formatString?
+  toString() {
+    let string = "[";
+    if (config.printRowMajor) {
+      string += "row-major:";
+      for (let row = 0; row < this.RANK; ++row) {
+        for (let col = 0; col < this.RANK; ++col) {
+          string += ` ${this[col * this.RANK + row]}`;
+        }
+      }
+    } else {
+      string += "column-major:";
+      for (let i2 = 0; i2 < this.ELEMENTS; ++i2) {
+        string += ` ${this[i2]}`;
+      }
+    }
+    string += "]";
+    return string;
+  }
+  getElementIndex(row, col) {
+    return col * this.RANK + row;
+  }
+  // By default assumes row major indices
+  getElement(row, col) {
+    return this[col * this.RANK + row];
+  }
+  // By default assumes row major indices
+  setElement(row, col, value) {
+    this[col * this.RANK + row] = checkNumber(value);
+    return this;
+  }
+  getColumn(columnIndex, result = new Array(this.RANK).fill(-0)) {
+    const firstIndex = columnIndex * this.RANK;
+    for (let i2 = 0; i2 < this.RANK; ++i2) {
+      result[i2] = this[firstIndex + i2];
+    }
+    return result;
+  }
+  setColumn(columnIndex, columnVector) {
+    const firstIndex = columnIndex * this.RANK;
+    for (let i2 = 0; i2 < this.RANK; ++i2) {
+      this[firstIndex + i2] = columnVector[i2];
+    }
+    return this;
+  }
+}
+function identity(out) {
+  out[0] = 1;
+  out[1] = 0;
+  out[2] = 0;
+  out[3] = 0;
+  out[4] = 0;
+  out[5] = 1;
+  out[6] = 0;
+  out[7] = 0;
+  out[8] = 0;
+  out[9] = 0;
+  out[10] = 1;
+  out[11] = 0;
+  out[12] = 0;
+  out[13] = 0;
+  out[14] = 0;
+  out[15] = 1;
+  return out;
+}
+function transpose(out, a2) {
+  if (out === a2) {
+    const a01 = a2[1];
+    const a02 = a2[2];
+    const a03 = a2[3];
+    const a12 = a2[6];
+    const a13 = a2[7];
+    const a23 = a2[11];
+    out[1] = a2[4];
+    out[2] = a2[8];
+    out[3] = a2[12];
+    out[4] = a01;
+    out[6] = a2[9];
+    out[7] = a2[13];
+    out[8] = a02;
+    out[9] = a12;
+    out[11] = a2[14];
+    out[12] = a03;
+    out[13] = a13;
+    out[14] = a23;
+  } else {
+    out[0] = a2[0];
+    out[1] = a2[4];
+    out[2] = a2[8];
+    out[3] = a2[12];
+    out[4] = a2[1];
+    out[5] = a2[5];
+    out[6] = a2[9];
+    out[7] = a2[13];
+    out[8] = a2[2];
+    out[9] = a2[6];
+    out[10] = a2[10];
+    out[11] = a2[14];
+    out[12] = a2[3];
+    out[13] = a2[7];
+    out[14] = a2[11];
+    out[15] = a2[15];
+  }
+  return out;
+}
+function invert(out, a2) {
+  const a00 = a2[0];
+  const a01 = a2[1];
+  const a02 = a2[2];
+  const a03 = a2[3];
+  const a10 = a2[4];
+  const a11 = a2[5];
+  const a12 = a2[6];
+  const a13 = a2[7];
+  const a20 = a2[8];
+  const a21 = a2[9];
+  const a22 = a2[10];
+  const a23 = a2[11];
+  const a30 = a2[12];
+  const a31 = a2[13];
+  const a32 = a2[14];
+  const a33 = a2[15];
+  const b00 = a00 * a11 - a01 * a10;
+  const b01 = a00 * a12 - a02 * a10;
+  const b02 = a00 * a13 - a03 * a10;
+  const b03 = a01 * a12 - a02 * a11;
+  const b04 = a01 * a13 - a03 * a11;
+  const b05 = a02 * a13 - a03 * a12;
+  const b06 = a20 * a31 - a21 * a30;
+  const b07 = a20 * a32 - a22 * a30;
+  const b08 = a20 * a33 - a23 * a30;
+  const b09 = a21 * a32 - a22 * a31;
+  const b10 = a21 * a33 - a23 * a31;
+  const b11 = a22 * a33 - a23 * a32;
+  let det = b00 * b11 - b01 * b10 + b02 * b09 + b03 * b08 - b04 * b07 + b05 * b06;
+  if (!det) {
+    return null;
+  }
+  det = 1 / det;
+  out[0] = (a11 * b11 - a12 * b10 + a13 * b09) * det;
+  out[1] = (a02 * b10 - a01 * b11 - a03 * b09) * det;
+  out[2] = (a31 * b05 - a32 * b04 + a33 * b03) * det;
+  out[3] = (a22 * b04 - a21 * b05 - a23 * b03) * det;
+  out[4] = (a12 * b08 - a10 * b11 - a13 * b07) * det;
+  out[5] = (a00 * b11 - a02 * b08 + a03 * b07) * det;
+  out[6] = (a32 * b02 - a30 * b05 - a33 * b01) * det;
+  out[7] = (a20 * b05 - a22 * b02 + a23 * b01) * det;
+  out[8] = (a10 * b10 - a11 * b08 + a13 * b06) * det;
+  out[9] = (a01 * b08 - a00 * b10 - a03 * b06) * det;
+  out[10] = (a30 * b04 - a31 * b02 + a33 * b00) * det;
+  out[11] = (a21 * b02 - a20 * b04 - a23 * b00) * det;
+  out[12] = (a11 * b07 - a10 * b09 - a12 * b06) * det;
+  out[13] = (a00 * b09 - a01 * b07 + a02 * b06) * det;
+  out[14] = (a31 * b01 - a30 * b03 - a32 * b00) * det;
+  out[15] = (a20 * b03 - a21 * b01 + a22 * b00) * det;
+  return out;
+}
+function determinant(a2) {
+  const a00 = a2[0];
+  const a01 = a2[1];
+  const a02 = a2[2];
+  const a03 = a2[3];
+  const a10 = a2[4];
+  const a11 = a2[5];
+  const a12 = a2[6];
+  const a13 = a2[7];
+  const a20 = a2[8];
+  const a21 = a2[9];
+  const a22 = a2[10];
+  const a23 = a2[11];
+  const a30 = a2[12];
+  const a31 = a2[13];
+  const a32 = a2[14];
+  const a33 = a2[15];
+  const b0 = a00 * a11 - a01 * a10;
+  const b1 = a00 * a12 - a02 * a10;
+  const b2 = a01 * a12 - a02 * a11;
+  const b3 = a20 * a31 - a21 * a30;
+  const b4 = a20 * a32 - a22 * a30;
+  const b5 = a21 * a32 - a22 * a31;
+  const b6 = a00 * b5 - a01 * b4 + a02 * b3;
+  const b7 = a10 * b5 - a11 * b4 + a12 * b3;
+  const b8 = a20 * b2 - a21 * b1 + a22 * b0;
+  const b9 = a30 * b2 - a31 * b1 + a32 * b0;
+  return a13 * b6 - a03 * b7 + a33 * b8 - a23 * b9;
+}
+function multiply(out, a2, b2) {
+  const a00 = a2[0];
+  const a01 = a2[1];
+  const a02 = a2[2];
+  const a03 = a2[3];
+  const a10 = a2[4];
+  const a11 = a2[5];
+  const a12 = a2[6];
+  const a13 = a2[7];
+  const a20 = a2[8];
+  const a21 = a2[9];
+  const a22 = a2[10];
+  const a23 = a2[11];
+  const a30 = a2[12];
+  const a31 = a2[13];
+  const a32 = a2[14];
+  const a33 = a2[15];
+  let b0 = b2[0];
+  let b1 = b2[1];
+  let b22 = b2[2];
+  let b3 = b2[3];
+  out[0] = b0 * a00 + b1 * a10 + b22 * a20 + b3 * a30;
+  out[1] = b0 * a01 + b1 * a11 + b22 * a21 + b3 * a31;
+  out[2] = b0 * a02 + b1 * a12 + b22 * a22 + b3 * a32;
+  out[3] = b0 * a03 + b1 * a13 + b22 * a23 + b3 * a33;
+  b0 = b2[4];
+  b1 = b2[5];
+  b22 = b2[6];
+  b3 = b2[7];
+  out[4] = b0 * a00 + b1 * a10 + b22 * a20 + b3 * a30;
+  out[5] = b0 * a01 + b1 * a11 + b22 * a21 + b3 * a31;
+  out[6] = b0 * a02 + b1 * a12 + b22 * a22 + b3 * a32;
+  out[7] = b0 * a03 + b1 * a13 + b22 * a23 + b3 * a33;
+  b0 = b2[8];
+  b1 = b2[9];
+  b22 = b2[10];
+  b3 = b2[11];
+  out[8] = b0 * a00 + b1 * a10 + b22 * a20 + b3 * a30;
+  out[9] = b0 * a01 + b1 * a11 + b22 * a21 + b3 * a31;
+  out[10] = b0 * a02 + b1 * a12 + b22 * a22 + b3 * a32;
+  out[11] = b0 * a03 + b1 * a13 + b22 * a23 + b3 * a33;
+  b0 = b2[12];
+  b1 = b2[13];
+  b22 = b2[14];
+  b3 = b2[15];
+  out[12] = b0 * a00 + b1 * a10 + b22 * a20 + b3 * a30;
+  out[13] = b0 * a01 + b1 * a11 + b22 * a21 + b3 * a31;
+  out[14] = b0 * a02 + b1 * a12 + b22 * a22 + b3 * a32;
+  out[15] = b0 * a03 + b1 * a13 + b22 * a23 + b3 * a33;
+  return out;
+}
+function translate(out, a2, v2) {
+  const x2 = v2[0];
+  const y2 = v2[1];
+  const z2 = v2[2];
+  let a00;
+  let a01;
+  let a02;
+  let a03;
+  let a10;
+  let a11;
+  let a12;
+  let a13;
+  let a20;
+  let a21;
+  let a22;
+  let a23;
+  if (a2 === out) {
+    out[12] = a2[0] * x2 + a2[4] * y2 + a2[8] * z2 + a2[12];
+    out[13] = a2[1] * x2 + a2[5] * y2 + a2[9] * z2 + a2[13];
+    out[14] = a2[2] * x2 + a2[6] * y2 + a2[10] * z2 + a2[14];
+    out[15] = a2[3] * x2 + a2[7] * y2 + a2[11] * z2 + a2[15];
+  } else {
+    a00 = a2[0];
+    a01 = a2[1];
+    a02 = a2[2];
+    a03 = a2[3];
+    a10 = a2[4];
+    a11 = a2[5];
+    a12 = a2[6];
+    a13 = a2[7];
+    a20 = a2[8];
+    a21 = a2[9];
+    a22 = a2[10];
+    a23 = a2[11];
+    out[0] = a00;
+    out[1] = a01;
+    out[2] = a02;
+    out[3] = a03;
+    out[4] = a10;
+    out[5] = a11;
+    out[6] = a12;
+    out[7] = a13;
+    out[8] = a20;
+    out[9] = a21;
+    out[10] = a22;
+    out[11] = a23;
+    out[12] = a00 * x2 + a10 * y2 + a20 * z2 + a2[12];
+    out[13] = a01 * x2 + a11 * y2 + a21 * z2 + a2[13];
+    out[14] = a02 * x2 + a12 * y2 + a22 * z2 + a2[14];
+    out[15] = a03 * x2 + a13 * y2 + a23 * z2 + a2[15];
+  }
+  return out;
+}
+function scale$1(out, a2, v2) {
+  const x2 = v2[0];
+  const y2 = v2[1];
+  const z2 = v2[2];
+  out[0] = a2[0] * x2;
+  out[1] = a2[1] * x2;
+  out[2] = a2[2] * x2;
+  out[3] = a2[3] * x2;
+  out[4] = a2[4] * y2;
+  out[5] = a2[5] * y2;
+  out[6] = a2[6] * y2;
+  out[7] = a2[7] * y2;
+  out[8] = a2[8] * z2;
+  out[9] = a2[9] * z2;
+  out[10] = a2[10] * z2;
+  out[11] = a2[11] * z2;
+  out[12] = a2[12];
+  out[13] = a2[13];
+  out[14] = a2[14];
+  out[15] = a2[15];
+  return out;
+}
+function rotate(out, a2, rad, axis) {
+  let x2 = axis[0];
+  let y2 = axis[1];
+  let z2 = axis[2];
+  let len2 = Math.sqrt(x2 * x2 + y2 * y2 + z2 * z2);
+  let c2;
+  let s2;
+  let t2;
+  let a00;
+  let a01;
+  let a02;
+  let a03;
+  let a10;
+  let a11;
+  let a12;
+  let a13;
+  let a20;
+  let a21;
+  let a22;
+  let a23;
+  let b00;
+  let b01;
+  let b02;
+  let b10;
+  let b11;
+  let b12;
+  let b20;
+  let b21;
+  let b22;
+  if (len2 < EPSILON$1) {
+    return null;
+  }
+  len2 = 1 / len2;
+  x2 *= len2;
+  y2 *= len2;
+  z2 *= len2;
+  s2 = Math.sin(rad);
+  c2 = Math.cos(rad);
+  t2 = 1 - c2;
+  a00 = a2[0];
+  a01 = a2[1];
+  a02 = a2[2];
+  a03 = a2[3];
+  a10 = a2[4];
+  a11 = a2[5];
+  a12 = a2[6];
+  a13 = a2[7];
+  a20 = a2[8];
+  a21 = a2[9];
+  a22 = a2[10];
+  a23 = a2[11];
+  b00 = x2 * x2 * t2 + c2;
+  b01 = y2 * x2 * t2 + z2 * s2;
+  b02 = z2 * x2 * t2 - y2 * s2;
+  b10 = x2 * y2 * t2 - z2 * s2;
+  b11 = y2 * y2 * t2 + c2;
+  b12 = z2 * y2 * t2 + x2 * s2;
+  b20 = x2 * z2 * t2 + y2 * s2;
+  b21 = y2 * z2 * t2 - x2 * s2;
+  b22 = z2 * z2 * t2 + c2;
+  out[0] = a00 * b00 + a10 * b01 + a20 * b02;
+  out[1] = a01 * b00 + a11 * b01 + a21 * b02;
+  out[2] = a02 * b00 + a12 * b01 + a22 * b02;
+  out[3] = a03 * b00 + a13 * b01 + a23 * b02;
+  out[4] = a00 * b10 + a10 * b11 + a20 * b12;
+  out[5] = a01 * b10 + a11 * b11 + a21 * b12;
+  out[6] = a02 * b10 + a12 * b11 + a22 * b12;
+  out[7] = a03 * b10 + a13 * b11 + a23 * b12;
+  out[8] = a00 * b20 + a10 * b21 + a20 * b22;
+  out[9] = a01 * b20 + a11 * b21 + a21 * b22;
+  out[10] = a02 * b20 + a12 * b21 + a22 * b22;
+  out[11] = a03 * b20 + a13 * b21 + a23 * b22;
+  if (a2 !== out) {
+    out[12] = a2[12];
+    out[13] = a2[13];
+    out[14] = a2[14];
+    out[15] = a2[15];
+  }
+  return out;
+}
+function rotateX(out, a2, rad) {
+  const s2 = Math.sin(rad);
+  const c2 = Math.cos(rad);
+  const a10 = a2[4];
+  const a11 = a2[5];
+  const a12 = a2[6];
+  const a13 = a2[7];
+  const a20 = a2[8];
+  const a21 = a2[9];
+  const a22 = a2[10];
+  const a23 = a2[11];
+  if (a2 !== out) {
+    out[0] = a2[0];
+    out[1] = a2[1];
+    out[2] = a2[2];
+    out[3] = a2[3];
+    out[12] = a2[12];
+    out[13] = a2[13];
+    out[14] = a2[14];
+    out[15] = a2[15];
+  }
+  out[4] = a10 * c2 + a20 * s2;
+  out[5] = a11 * c2 + a21 * s2;
+  out[6] = a12 * c2 + a22 * s2;
+  out[7] = a13 * c2 + a23 * s2;
+  out[8] = a20 * c2 - a10 * s2;
+  out[9] = a21 * c2 - a11 * s2;
+  out[10] = a22 * c2 - a12 * s2;
+  out[11] = a23 * c2 - a13 * s2;
+  return out;
+}
+function rotateY(out, a2, rad) {
+  const s2 = Math.sin(rad);
+  const c2 = Math.cos(rad);
+  const a00 = a2[0];
+  const a01 = a2[1];
+  const a02 = a2[2];
+  const a03 = a2[3];
+  const a20 = a2[8];
+  const a21 = a2[9];
+  const a22 = a2[10];
+  const a23 = a2[11];
+  if (a2 !== out) {
+    out[4] = a2[4];
+    out[5] = a2[5];
+    out[6] = a2[6];
+    out[7] = a2[7];
+    out[12] = a2[12];
+    out[13] = a2[13];
+    out[14] = a2[14];
+    out[15] = a2[15];
+  }
+  out[0] = a00 * c2 - a20 * s2;
+  out[1] = a01 * c2 - a21 * s2;
+  out[2] = a02 * c2 - a22 * s2;
+  out[3] = a03 * c2 - a23 * s2;
+  out[8] = a00 * s2 + a20 * c2;
+  out[9] = a01 * s2 + a21 * c2;
+  out[10] = a02 * s2 + a22 * c2;
+  out[11] = a03 * s2 + a23 * c2;
+  return out;
+}
+function rotateZ(out, a2, rad) {
+  const s2 = Math.sin(rad);
+  const c2 = Math.cos(rad);
+  const a00 = a2[0];
+  const a01 = a2[1];
+  const a02 = a2[2];
+  const a03 = a2[3];
+  const a10 = a2[4];
+  const a11 = a2[5];
+  const a12 = a2[6];
+  const a13 = a2[7];
+  if (a2 !== out) {
+    out[8] = a2[8];
+    out[9] = a2[9];
+    out[10] = a2[10];
+    out[11] = a2[11];
+    out[12] = a2[12];
+    out[13] = a2[13];
+    out[14] = a2[14];
+    out[15] = a2[15];
+  }
+  out[0] = a00 * c2 + a10 * s2;
+  out[1] = a01 * c2 + a11 * s2;
+  out[2] = a02 * c2 + a12 * s2;
+  out[3] = a03 * c2 + a13 * s2;
+  out[4] = a10 * c2 - a00 * s2;
+  out[5] = a11 * c2 - a01 * s2;
+  out[6] = a12 * c2 - a02 * s2;
+  out[7] = a13 * c2 - a03 * s2;
+  return out;
+}
+function fromQuat(out, q2) {
+  const x2 = q2[0];
+  const y2 = q2[1];
+  const z2 = q2[2];
+  const w2 = q2[3];
+  const x22 = x2 + x2;
+  const y22 = y2 + y2;
+  const z22 = z2 + z2;
+  const xx = x2 * x22;
+  const yx = y2 * x22;
+  const yy = y2 * y22;
+  const zx = z2 * x22;
+  const zy = z2 * y22;
+  const zz = z2 * z22;
+  const wx = w2 * x22;
+  const wy = w2 * y22;
+  const wz = w2 * z22;
+  out[0] = 1 - yy - zz;
+  out[1] = yx + wz;
+  out[2] = zx - wy;
+  out[3] = 0;
+  out[4] = yx - wz;
+  out[5] = 1 - xx - zz;
+  out[6] = zy + wx;
+  out[7] = 0;
+  out[8] = zx + wy;
+  out[9] = zy - wx;
+  out[10] = 1 - xx - yy;
+  out[11] = 0;
+  out[12] = 0;
+  out[13] = 0;
+  out[14] = 0;
+  out[15] = 1;
+  return out;
+}
+function frustum(out, left, right, bottom, top, near, far) {
+  const rl2 = 1 / (right - left);
+  const tb2 = 1 / (top - bottom);
+  const nf2 = 1 / (near - far);
+  out[0] = near * 2 * rl2;
+  out[1] = 0;
+  out[2] = 0;
+  out[3] = 0;
+  out[4] = 0;
+  out[5] = near * 2 * tb2;
+  out[6] = 0;
+  out[7] = 0;
+  out[8] = (right + left) * rl2;
+  out[9] = (top + bottom) * tb2;
+  out[10] = (far + near) * nf2;
+  out[11] = -1;
+  out[12] = 0;
+  out[13] = 0;
+  out[14] = far * near * 2 * nf2;
+  out[15] = 0;
+  return out;
+}
+function perspectiveNO(out, fovy, aspect, near, far) {
+  const f2 = 1 / Math.tan(fovy / 2);
+  out[0] = f2 / aspect;
+  out[1] = 0;
+  out[2] = 0;
+  out[3] = 0;
+  out[4] = 0;
+  out[5] = f2;
+  out[6] = 0;
+  out[7] = 0;
+  out[8] = 0;
+  out[9] = 0;
+  out[11] = -1;
+  out[12] = 0;
+  out[13] = 0;
+  out[15] = 0;
+  if (far != null && far !== Infinity) {
+    const nf2 = 1 / (near - far);
+    out[10] = (far + near) * nf2;
+    out[14] = 2 * far * near * nf2;
+  } else {
+    out[10] = -1;
+    out[14] = -2 * near;
+  }
+  return out;
+}
+const perspective = perspectiveNO;
+function orthoNO(out, left, right, bottom, top, near, far) {
+  const lr = 1 / (left - right);
+  const bt = 1 / (bottom - top);
+  const nf2 = 1 / (near - far);
+  out[0] = -2 * lr;
+  out[1] = 0;
+  out[2] = 0;
+  out[3] = 0;
+  out[4] = 0;
+  out[5] = -2 * bt;
+  out[6] = 0;
+  out[7] = 0;
+  out[8] = 0;
+  out[9] = 0;
+  out[10] = 2 * nf2;
+  out[11] = 0;
+  out[12] = (left + right) * lr;
+  out[13] = (top + bottom) * bt;
+  out[14] = (far + near) * nf2;
+  out[15] = 1;
+  return out;
+}
+const ortho = orthoNO;
+function lookAt(out, eye, center, up) {
+  let len2;
+  let x0;
+  let x1;
+  let x2;
+  let y0;
+  let y1;
+  let y2;
+  let z0;
+  let z1;
+  let z2;
+  const eyex = eye[0];
+  const eyey = eye[1];
+  const eyez = eye[2];
+  const upx = up[0];
+  const upy = up[1];
+  const upz = up[2];
+  const centerx = center[0];
+  const centery = center[1];
+  const centerz = center[2];
+  if (Math.abs(eyex - centerx) < EPSILON$1 && Math.abs(eyey - centery) < EPSILON$1 && Math.abs(eyez - centerz) < EPSILON$1) {
+    return identity(out);
+  }
+  z0 = eyex - centerx;
+  z1 = eyey - centery;
+  z2 = eyez - centerz;
+  len2 = 1 / Math.sqrt(z0 * z0 + z1 * z1 + z2 * z2);
+  z0 *= len2;
+  z1 *= len2;
+  z2 *= len2;
+  x0 = upy * z2 - upz * z1;
+  x1 = upz * z0 - upx * z2;
+  x2 = upx * z1 - upy * z0;
+  len2 = Math.sqrt(x0 * x0 + x1 * x1 + x2 * x2);
+  if (!len2) {
+    x0 = 0;
+    x1 = 0;
+    x2 = 0;
+  } else {
+    len2 = 1 / len2;
+    x0 *= len2;
+    x1 *= len2;
+    x2 *= len2;
+  }
+  y0 = z1 * x2 - z2 * x1;
+  y1 = z2 * x0 - z0 * x2;
+  y2 = z0 * x1 - z1 * x0;
+  len2 = Math.sqrt(y0 * y0 + y1 * y1 + y2 * y2);
+  if (!len2) {
+    y0 = 0;
+    y1 = 0;
+    y2 = 0;
+  } else {
+    len2 = 1 / len2;
+    y0 *= len2;
+    y1 *= len2;
+    y2 *= len2;
+  }
+  out[0] = x0;
+  out[1] = y0;
+  out[2] = z0;
+  out[3] = 0;
+  out[4] = x1;
+  out[5] = y1;
+  out[6] = z1;
+  out[7] = 0;
+  out[8] = x2;
+  out[9] = y2;
+  out[10] = z2;
+  out[11] = 0;
+  out[12] = -(x0 * eyex + x1 * eyey + x2 * eyez);
+  out[13] = -(y0 * eyex + y1 * eyey + y2 * eyez);
+  out[14] = -(z0 * eyex + z1 * eyey + z2 * eyez);
+  out[15] = 1;
+  return out;
+}
+function create() {
+  const out = new ARRAY_TYPE(4);
+  if (ARRAY_TYPE != Float32Array) {
+    out[0] = 0;
+    out[1] = 0;
+    out[2] = 0;
+    out[3] = 0;
+  }
+  return out;
+}
+function scale(out, a2, b2) {
+  out[0] = a2[0] * b2;
+  out[1] = a2[1] * b2;
+  out[2] = a2[2] * b2;
+  out[3] = a2[3] * b2;
+  return out;
+}
+function transformMat4(out, a2, m2) {
+  const x2 = a2[0];
+  const y2 = a2[1];
+  const z2 = a2[2];
+  const w2 = a2[3];
+  out[0] = m2[0] * x2 + m2[4] * y2 + m2[8] * z2 + m2[12] * w2;
+  out[1] = m2[1] * x2 + m2[5] * y2 + m2[9] * z2 + m2[13] * w2;
+  out[2] = m2[2] * x2 + m2[6] * y2 + m2[10] * z2 + m2[14] * w2;
+  out[3] = m2[3] * x2 + m2[7] * y2 + m2[11] * z2 + m2[15] * w2;
+  return out;
+}
+(function() {
+  const vec = create();
+  return function(a2, stride, offset, count2, fn, arg) {
+    let i2;
+    let l2;
+    if (!stride) {
+      stride = 4;
+    }
+    if (!offset) {
+      offset = 0;
+    }
+    if (count2) {
+      l2 = Math.min(count2 * stride + offset, a2.length);
+    } else {
+      l2 = a2.length;
+    }
+    for (i2 = offset; i2 < l2; i2 += stride) {
+      vec[0] = a2[i2];
+      vec[1] = a2[i2 + 1];
+      vec[2] = a2[i2 + 2];
+      vec[3] = a2[i2 + 3];
+      fn(vec, vec, arg);
+      a2[i2] = vec[0];
+      a2[i2 + 1] = vec[1];
+      a2[i2 + 2] = vec[2];
+      a2[i2 + 3] = vec[3];
+    }
+    return a2;
+  };
+})();
+var INDICES;
+(function(INDICES2) {
+  INDICES2[INDICES2["COL0ROW0"] = 0] = "COL0ROW0";
+  INDICES2[INDICES2["COL0ROW1"] = 1] = "COL0ROW1";
+  INDICES2[INDICES2["COL0ROW2"] = 2] = "COL0ROW2";
+  INDICES2[INDICES2["COL0ROW3"] = 3] = "COL0ROW3";
+  INDICES2[INDICES2["COL1ROW0"] = 4] = "COL1ROW0";
+  INDICES2[INDICES2["COL1ROW1"] = 5] = "COL1ROW1";
+  INDICES2[INDICES2["COL1ROW2"] = 6] = "COL1ROW2";
+  INDICES2[INDICES2["COL1ROW3"] = 7] = "COL1ROW3";
+  INDICES2[INDICES2["COL2ROW0"] = 8] = "COL2ROW0";
+  INDICES2[INDICES2["COL2ROW1"] = 9] = "COL2ROW1";
+  INDICES2[INDICES2["COL2ROW2"] = 10] = "COL2ROW2";
+  INDICES2[INDICES2["COL2ROW3"] = 11] = "COL2ROW3";
+  INDICES2[INDICES2["COL3ROW0"] = 12] = "COL3ROW0";
+  INDICES2[INDICES2["COL3ROW1"] = 13] = "COL3ROW1";
+  INDICES2[INDICES2["COL3ROW2"] = 14] = "COL3ROW2";
+  INDICES2[INDICES2["COL3ROW3"] = 15] = "COL3ROW3";
+})(INDICES || (INDICES = {}));
+const DEFAULT_FOVY = 45 * Math.PI / 180;
+const DEFAULT_ASPECT = 1;
+const DEFAULT_NEAR = 0.1;
+const DEFAULT_FAR = 500;
+const IDENTITY_MATRIX$1 = Object.freeze([1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1]);
+class Matrix4 extends Matrix {
+  static get IDENTITY() {
+    return getIdentityMatrix();
+  }
+  static get ZERO() {
+    return getZeroMatrix();
+  }
+  get ELEMENTS() {
+    return 16;
+  }
+  get RANK() {
+    return 4;
+  }
+  get INDICES() {
+    return INDICES;
+  }
+  constructor(array) {
+    super(-0, -0, -0, -0, -0, -0, -0, -0, -0, -0, -0, -0, -0, -0, -0, -0);
+    if (arguments.length === 1 && Array.isArray(array)) {
+      this.copy(array);
+    } else {
+      this.identity();
+    }
+  }
+  copy(array) {
+    this[0] = array[0];
+    this[1] = array[1];
+    this[2] = array[2];
+    this[3] = array[3];
+    this[4] = array[4];
+    this[5] = array[5];
+    this[6] = array[6];
+    this[7] = array[7];
+    this[8] = array[8];
+    this[9] = array[9];
+    this[10] = array[10];
+    this[11] = array[11];
+    this[12] = array[12];
+    this[13] = array[13];
+    this[14] = array[14];
+    this[15] = array[15];
+    return this.check();
+  }
+  // eslint-disable-next-line max-params
+  set(m00, m10, m20, m30, m01, m11, m21, m31, m02, m12, m22, m32, m03, m13, m23, m33) {
+    this[0] = m00;
+    this[1] = m10;
+    this[2] = m20;
+    this[3] = m30;
+    this[4] = m01;
+    this[5] = m11;
+    this[6] = m21;
+    this[7] = m31;
+    this[8] = m02;
+    this[9] = m12;
+    this[10] = m22;
+    this[11] = m32;
+    this[12] = m03;
+    this[13] = m13;
+    this[14] = m23;
+    this[15] = m33;
+    return this.check();
+  }
+  // accepts row major order, stores as column major
+  // eslint-disable-next-line max-params
+  setRowMajor(m00, m01, m02, m03, m10, m11, m12, m13, m20, m21, m22, m23, m30, m31, m32, m33) {
+    this[0] = m00;
+    this[1] = m10;
+    this[2] = m20;
+    this[3] = m30;
+    this[4] = m01;
+    this[5] = m11;
+    this[6] = m21;
+    this[7] = m31;
+    this[8] = m02;
+    this[9] = m12;
+    this[10] = m22;
+    this[11] = m32;
+    this[12] = m03;
+    this[13] = m13;
+    this[14] = m23;
+    this[15] = m33;
+    return this.check();
+  }
+  toRowMajor(result) {
+    result[0] = this[0];
+    result[1] = this[4];
+    result[2] = this[8];
+    result[3] = this[12];
+    result[4] = this[1];
+    result[5] = this[5];
+    result[6] = this[9];
+    result[7] = this[13];
+    result[8] = this[2];
+    result[9] = this[6];
+    result[10] = this[10];
+    result[11] = this[14];
+    result[12] = this[3];
+    result[13] = this[7];
+    result[14] = this[11];
+    result[15] = this[15];
+    return result;
+  }
+  // Constructors
+  /** Set to identity matrix */
+  identity() {
+    return this.copy(IDENTITY_MATRIX$1);
+  }
+  /**
+   *
+   * @param object
+   * @returns self
+   */
+  // eslint-disable-next-line @typescript-eslint/no-unused-vars
+  fromObject(object) {
+    return this.check();
+  }
+  /**
+   * Calculates a 4x4 matrix from the given quaternion
+   * @param quaternion Quaternion to create matrix from
+   * @returns self
+   */
+  fromQuaternion(quaternion) {
+    fromQuat(this, quaternion);
+    return this.check();
+  }
+  /**
+   * Generates a frustum matrix with the given bounds
+   * @param view.left - Left bound of the frustum
+   * @param view.right - Right bound of the frustum
+   * @param view.bottom - Bottom bound of the frustum
+   * @param view.top - Top bound of the frustum
+   * @param view.near - Near bound of the frustum
+   * @param view.far - Far bound of the frustum. Can be set to Infinity.
+   * @returns self
+   */
+  frustum(view) {
+    const { left, right, bottom, top, near = DEFAULT_NEAR, far = DEFAULT_FAR } = view;
+    if (far === Infinity) {
+      computeInfinitePerspectiveOffCenter(this, left, right, bottom, top, near);
+    } else {
+      frustum(this, left, right, bottom, top, near, far);
+    }
+    return this.check();
+  }
+  /**
+   * Generates a look-at matrix with the given eye position, focal point,
+   * and up axis
+   * @param view.eye - (vector) Position of the viewer
+   * @param view.center - (vector) Point the viewer is looking at
+   * @param view.up - (vector) Up axis
+   * @returns self
+   */
+  lookAt(view) {
+    const { eye, center = [0, 0, 0], up = [0, 1, 0] } = view;
+    lookAt(this, eye, center, up);
+    return this.check();
+  }
+  /**
+   * Generates a orthogonal projection matrix with the given bounds
+   * from "traditional" view space parameters
+   * @param view.left - Left bound of the frustum
+   * @param view.right number  Right bound of the frustum
+   * @param view.bottom - Bottom bound of the frustum
+   * @param view.top number  Top bound of the frustum
+   * @param view.near - Near bound of the frustum
+   * @param view.far number  Far bound of the frustum
+   * @returns self
+   */
+  ortho(view) {
+    const { left, right, bottom, top, near = DEFAULT_NEAR, far = DEFAULT_FAR } = view;
+    ortho(this, left, right, bottom, top, near, far);
+    return this.check();
+  }
+  /**
+   * Generates an orthogonal projection matrix with the same parameters
+   * as a perspective matrix (plus focalDistance)
+   * @param view.fovy Vertical field of view in radians
+   * @param view.aspect Aspect ratio. Typically viewport width / viewport height
+   * @param view.focalDistance Distance in the view frustum used for extent calculations
+   * @param view.near Near bound of the frustum
+   * @param view.far Far bound of the frustum
+   * @returns self
+   */
+  orthographic(view) {
+    const { fovy = DEFAULT_FOVY, aspect = DEFAULT_ASPECT, focalDistance = 1, near = DEFAULT_NEAR, far = DEFAULT_FAR } = view;
+    checkRadians(fovy);
+    const halfY = fovy / 2;
+    const top = focalDistance * Math.tan(halfY);
+    const right = top * aspect;
+    return this.ortho({
+      left: -right,
+      right,
+      bottom: -top,
+      top,
+      near,
+      far
+    });
+  }
+  /**
+   * Generates a perspective projection matrix with the given bounds
+   * @param view.fovy Vertical field of view in radians
+   * @param view.aspect Aspect ratio. typically viewport width/height
+   * @param view.near Near bound of the frustum
+   * @param view.far Far bound of the frustum
+   * @returns self
+   */
+  perspective(view) {
+    const { fovy = 45 * Math.PI / 180, aspect = 1, near = 0.1, far = 500 } = view;
+    checkRadians(fovy);
+    perspective(this, fovy, aspect, near, far);
+    return this.check();
+  }
+  // Accessors
+  determinant() {
+    return determinant(this);
+  }
+  /**
+   * Extracts the non-uniform scale assuming the matrix is an affine transformation.
+   * The scales are the "lengths" of the column vectors in the upper-left 3x3 matrix.
+   * @param result
+   * @returns self
+   */
+  getScale(result = [-0, -0, -0]) {
+    result[0] = Math.sqrt(this[0] * this[0] + this[1] * this[1] + this[2] * this[2]);
+    result[1] = Math.sqrt(this[4] * this[4] + this[5] * this[5] + this[6] * this[6]);
+    result[2] = Math.sqrt(this[8] * this[8] + this[9] * this[9] + this[10] * this[10]);
+    return result;
+  }
+  /**
+   * Gets the translation portion, assuming the matrix is a affine transformation matrix.
+   * @param result
+   * @returns self
+   */
+  getTranslation(result = [-0, -0, -0]) {
+    result[0] = this[12];
+    result[1] = this[13];
+    result[2] = this[14];
+    return result;
+  }
+  /**
+   * Gets upper left 3x3 pure rotation matrix (non-scaling), assume affine transformation matrix
+   * @param result
+   * @param scaleResult
+   * @returns self
+   */
+  getRotation(result, scaleResult) {
+    result = result || [-0, -0, -0, -0, -0, -0, -0, -0, -0, -0, -0, -0, -0, -0, -0, -0];
+    scaleResult = scaleResult || [-0, -0, -0];
+    const scale2 = this.getScale(scaleResult);
+    const inverseScale0 = 1 / scale2[0];
+    const inverseScale1 = 1 / scale2[1];
+    const inverseScale2 = 1 / scale2[2];
+    result[0] = this[0] * inverseScale0;
+    result[1] = this[1] * inverseScale1;
+    result[2] = this[2] * inverseScale2;
+    result[3] = 0;
+    result[4] = this[4] * inverseScale0;
+    result[5] = this[5] * inverseScale1;
+    result[6] = this[6] * inverseScale2;
+    result[7] = 0;
+    result[8] = this[8] * inverseScale0;
+    result[9] = this[9] * inverseScale1;
+    result[10] = this[10] * inverseScale2;
+    result[11] = 0;
+    result[12] = 0;
+    result[13] = 0;
+    result[14] = 0;
+    result[15] = 1;
+    return result;
+  }
+  /**
+   *
+   * @param result
+   * @param scaleResult
+   * @returns self
+   */
+  getRotationMatrix3(result, scaleResult) {
+    result = result || [-0, -0, -0, -0, -0, -0, -0, -0, -0];
+    scaleResult = scaleResult || [-0, -0, -0];
+    const scale2 = this.getScale(scaleResult);
+    const inverseScale0 = 1 / scale2[0];
+    const inverseScale1 = 1 / scale2[1];
+    const inverseScale2 = 1 / scale2[2];
+    result[0] = this[0] * inverseScale0;
+    result[1] = this[1] * inverseScale1;
+    result[2] = this[2] * inverseScale2;
+    result[3] = this[4] * inverseScale0;
+    result[4] = this[5] * inverseScale1;
+    result[5] = this[6] * inverseScale2;
+    result[6] = this[8] * inverseScale0;
+    result[7] = this[9] * inverseScale1;
+    result[8] = this[10] * inverseScale2;
+    return result;
+  }
+  // Modifiers
+  transpose() {
+    transpose(this, this);
+    return this.check();
+  }
+  invert() {
+    invert(this, this);
+    return this.check();
+  }
+  // Operations
+  multiplyLeft(a2) {
+    multiply(this, a2, this);
+    return this.check();
+  }
+  multiplyRight(a2) {
+    multiply(this, this, a2);
+    return this.check();
+  }
+  // Rotates a matrix by the given angle around the X axis
+  rotateX(radians) {
+    rotateX(this, this, radians);
+    return this.check();
+  }
+  // Rotates a matrix by the given angle around the Y axis.
+  rotateY(radians) {
+    rotateY(this, this, radians);
+    return this.check();
+  }
+  /**
+   * Rotates a matrix by the given angle around the Z axis.
+   * @param radians
+   * @returns self
+   */
+  rotateZ(radians) {
+    rotateZ(this, this, radians);
+    return this.check();
+  }
+  /**
+   *
+   * @param param0
+   * @returns self
+   */
+  rotateXYZ(angleXYZ) {
+    return this.rotateX(angleXYZ[0]).rotateY(angleXYZ[1]).rotateZ(angleXYZ[2]);
+  }
+  /**
+   *
+   * @param radians
+   * @param axis
+   * @returns self
+   */
+  rotateAxis(radians, axis) {
+    rotate(this, this, radians, axis);
+    return this.check();
+  }
+  /**
+   *
+   * @param factor
+   * @returns self
+   */
+  scale(factor) {
+    scale$1(this, this, Array.isArray(factor) ? factor : [factor, factor, factor]);
+    return this.check();
+  }
+  /**
+   *
+   * @param vec
+   * @returns self
+   */
+  translate(vector) {
+    translate(this, this, vector);
+    return this.check();
+  }
+  // Transforms
+  /**
+   * Transforms any 2, 3 or 4 element vector. 2 and 3 elements are treated as points
+   * @param vector
+   * @param result
+   * @returns self
+   */
+  transform(vector, result) {
+    if (vector.length === 4) {
+      result = transformMat4(result || [-0, -0, -0, -0], vector, this);
+      checkVector(result, 4);
+      return result;
+    }
+    return this.transformAsPoint(vector, result);
+  }
+  /**
+   * Transforms any 2 or 3 element array as point (w implicitly 1)
+   * @param vector
+   * @param result
+   * @returns self
+   */
+  transformAsPoint(vector, result) {
+    const { length: length2 } = vector;
+    let out;
+    switch (length2) {
+      case 2:
+        out = transformMat4$2(result || [-0, -0], vector, this);
+        break;
+      case 3:
+        out = transformMat4$1(result || [-0, -0, -0], vector, this);
+        break;
+      default:
+        throw new Error("Illegal vector");
+    }
+    checkVector(out, vector.length);
+    return out;
+  }
+  /**
+   * Transforms any 2 or 3 element array as vector (w implicitly 0)
+   * @param vector
+   * @param result
+   * @returns self
+   */
+  transformAsVector(vector, result) {
+    let out;
+    switch (vector.length) {
+      case 2:
+        out = vec2_transformMat4AsVector(result || [-0, -0], vector, this);
+        break;
+      case 3:
+        out = vec3_transformMat4AsVector(result || [-0, -0, -0], vector, this);
+        break;
+      default:
+        throw new Error("Illegal vector");
+    }
+    checkVector(out, vector.length);
+    return out;
+  }
+  /** @deprecated */
+  transformPoint(vector, result) {
+    return this.transformAsPoint(vector, result);
+  }
+  /** @deprecated */
+  transformVector(vector, result) {
+    return this.transformAsPoint(vector, result);
+  }
+  /** @deprecated */
+  transformDirection(vector, result) {
+    return this.transformAsVector(vector, result);
+  }
+  // three.js math API compatibility
+  makeRotationX(radians) {
+    return this.identity().rotateX(radians);
+  }
+  makeTranslation(x2, y2, z2) {
+    return this.identity().translate([x2, y2, z2]);
+  }
+}
+let ZERO;
+let IDENTITY$1;
+function getZeroMatrix() {
+  if (!ZERO) {
+    ZERO = new Matrix4([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]);
+    Object.freeze(ZERO);
+  }
+  return ZERO;
+}
+function getIdentityMatrix() {
+  if (!IDENTITY$1) {
+    IDENTITY$1 = new Matrix4();
+    Object.freeze(IDENTITY$1);
+  }
+  return IDENTITY$1;
+}
+function checkRadians(possiblyDegrees) {
+  if (possiblyDegrees > Math.PI * 2) {
+    throw Error("expected radians");
+  }
+}
+function computeInfinitePerspectiveOffCenter(result, left, right, bottom, top, near) {
+  const column0Row0 = 2 * near / (right - left);
+  const column1Row1 = 2 * near / (top - bottom);
+  const column2Row0 = (right + left) / (right - left);
+  const column2Row1 = (top + bottom) / (top - bottom);
+  const column2Row2 = -1;
+  const column2Row3 = -1;
+  const column3Row2 = -2 * near;
+  result[0] = column0Row0;
+  result[1] = 0;
+  result[2] = 0;
+  result[3] = 0;
+  result[4] = 0;
+  result[5] = column1Row1;
+  result[6] = 0;
+  result[7] = 0;
+  result[8] = column2Row0;
+  result[9] = column2Row1;
+  result[10] = column2Row2;
+  result[11] = column2Row3;
+  result[12] = 0;
+  result[13] = 0;
+  result[14] = column3Row2;
+  result[15] = 0;
+  return result;
+}
+function fp64ify(a2, out = [], startIndex = 0) {
+  const hiPart = Math.fround(a2);
+  const loPart = a2 - hiPart;
+  out[startIndex] = hiPart;
+  out[startIndex + 1] = loPart;
+  return out;
+}
+function fp64LowPart$1(a2) {
+  return a2 - Math.fround(a2);
+}
+function fp64ifyMatrix4(matrix) {
+  const matrixFP64 = new Float32Array(32);
+  for (let i2 = 0; i2 < 4; ++i2) {
+    for (let j2 = 0; j2 < 4; ++j2) {
+      const index = i2 * 4 + j2;
+      fp64ify(matrix[j2 * 4 + i2], matrixFP64, index * 2);
+    }
+  }
+  return matrixFP64;
+}
+const fp32shader = (
+  /* glsl */
+  `#ifdef LUMA_FP32_TAN_PRECISION_WORKAROUND
+
+// All these functions are for substituting tan() function from Intel GPU only
+const float TWO_PI = 6.2831854820251465;
+const float PI_2 = 1.5707963705062866;
+const float PI_16 = 0.1963495463132858;
+
+const float SIN_TABLE_0 = 0.19509032368659973;
+const float SIN_TABLE_1 = 0.3826834261417389;
+const float SIN_TABLE_2 = 0.5555702447891235;
+const float SIN_TABLE_3 = 0.7071067690849304;
+
+const float COS_TABLE_0 = 0.9807852506637573;
+const float COS_TABLE_1 = 0.9238795042037964;
+const float COS_TABLE_2 = 0.8314695954322815;
+const float COS_TABLE_3 = 0.7071067690849304;
+
+const float INVERSE_FACTORIAL_3 = 1.666666716337204e-01; // 1/3!
+const float INVERSE_FACTORIAL_5 = 8.333333767950535e-03; // 1/5!
+const float INVERSE_FACTORIAL_7 = 1.9841270113829523e-04; // 1/7!
+const float INVERSE_FACTORIAL_9 = 2.75573188446287533e-06; // 1/9!
+
+float sin_taylor_fp32(float a) {
+  float r, s, t, x;
+
+  if (a == 0.0) {
+    return 0.0;
+  }
+
+  x = -a * a;
+  s = a;
+  r = a;
+
+  r = r * x;
+  t = r * INVERSE_FACTORIAL_3;
+  s = s + t;
+
+  r = r * x;
+  t = r * INVERSE_FACTORIAL_5;
+  s = s + t;
+
+  r = r * x;
+  t = r * INVERSE_FACTORIAL_7;
+  s = s + t;
+
+  r = r * x;
+  t = r * INVERSE_FACTORIAL_9;
+  s = s + t;
+
+  return s;
+}
+
+void sincos_taylor_fp32(float a, out float sin_t, out float cos_t) {
+  if (a == 0.0) {
+    sin_t = 0.0;
+    cos_t = 1.0;
+  }
+  sin_t = sin_taylor_fp32(a);
+  cos_t = sqrt(1.0 - sin_t * sin_t);
+}
+
+float tan_taylor_fp32(float a) {
+    float sin_a;
+    float cos_a;
+
+    if (a == 0.0) {
+        return 0.0;
+    }
+
+    // 2pi range reduction
+    float z = floor(a / TWO_PI);
+    float r = a - TWO_PI * z;
+
+    float t;
+    float q = floor(r / PI_2 + 0.5);
+    int j = int(q);
+
+    if (j < -2 || j > 2) {
+        return 1.0 / 0.0;
+    }
+
+    t = r - PI_2 * q;
+
+    q = floor(t / PI_16 + 0.5);
+    int k = int(q);
+    int abs_k = int(abs(float(k)));
+
+    if (abs_k > 4) {
+        return 1.0 / 0.0;
+    } else {
+        t = t - PI_16 * q;
+    }
+
+    float u = 0.0;
+    float v = 0.0;
+
+    float sin_t, cos_t;
+    float s, c;
+    sincos_taylor_fp32(t, sin_t, cos_t);
+
+    if (k == 0) {
+        s = sin_t;
+        c = cos_t;
+    } else {
+        if (abs(float(abs_k) - 1.0) < 0.5) {
+            u = COS_TABLE_0;
+            v = SIN_TABLE_0;
+        } else if (abs(float(abs_k) - 2.0) < 0.5) {
+            u = COS_TABLE_1;
+            v = SIN_TABLE_1;
+        } else if (abs(float(abs_k) - 3.0) < 0.5) {
+            u = COS_TABLE_2;
+            v = SIN_TABLE_2;
+        } else if (abs(float(abs_k) - 4.0) < 0.5) {
+            u = COS_TABLE_3;
+            v = SIN_TABLE_3;
+        }
+        if (k > 0) {
+            s = u * sin_t + v * cos_t;
+            c = u * cos_t - v * sin_t;
+        } else {
+            s = u * sin_t - v * cos_t;
+            c = u * cos_t + v * sin_t;
+        }
+    }
+
+    if (j == 0) {
+        sin_a = s;
+        cos_a = c;
+    } else if (j == 1) {
+        sin_a = c;
+        cos_a = -s;
+    } else if (j == -1) {
+        sin_a = -c;
+        cos_a = s;
+    } else {
+        sin_a = -s;
+        cos_a = -c;
+    }
+    return sin_a / cos_a;
+}
+#endif
+
+float tan_fp32(float a) {
+#ifdef LUMA_FP32_TAN_PRECISION_WORKAROUND
+  return tan_taylor_fp32(a);
+#else
+  return tan(a);
+#endif
+}
+`
+);
+const fp32 = {
+  name: "fp32",
+  vs: fp32shader
+};
+const fp64arithmeticShader = (
+  /* glsl */
+  `
+uniform fp64arithmeticUniforms {
+  uniform float ONE;
+} fp64;
+
+/*
+About LUMA_FP64_CODE_ELIMINATION_WORKAROUND
+
+The purpose of this workaround is to prevent shader compilers from
+optimizing away necessary arithmetic operations by swapping their sequences
+or transform the equation to some 'equivalent' form.
+
+The method is to multiply an artifical variable, ONE, which will be known to
+the compiler to be 1 only at runtime. The whole expression is then represented
+as a polynomial with respective to ONE. In the coefficients of all terms, only one a
+and one b should appear
+
+err = (a + b) * ONE^6 - a * ONE^5 - (a + b) * ONE^4 + a * ONE^3 - b - (a + b) * ONE^2 + a * ONE
+*/
+
+// Divide float number to high and low floats to extend fraction bits
+vec2 split(float a) {
+  const float SPLIT = 4097.0;
+  float t = a * SPLIT;
+#if defined(LUMA_FP64_CODE_ELIMINATION_WORKAROUND)
+  float a_hi = t * fp64.ONE - (t - a);
+  float a_lo = a * fp64.ONE - a_hi;
+#else
+  float a_hi = t - (t - a);
+  float a_lo = a - a_hi;
+#endif
+  return vec2(a_hi, a_lo);
+}
+
+// Divide float number again when high float uses too many fraction bits
+vec2 split2(vec2 a) {
+  vec2 b = split(a.x);
+  b.y += a.y;
+  return b;
+}
+
+// Special sum operation when a > b
+vec2 quickTwoSum(float a, float b) {
+#if defined(LUMA_FP64_CODE_ELIMINATION_WORKAROUND)
+  float sum = (a + b) * fp64.ONE;
+  float err = b - (sum - a) * fp64.ONE;
+#else
+  float sum = a + b;
+  float err = b - (sum - a);
+#endif
+  return vec2(sum, err);
+}
+
+// General sum operation
+vec2 twoSum(float a, float b) {
+  float s = (a + b);
+#if defined(LUMA_FP64_CODE_ELIMINATION_WORKAROUND)
+  float v = (s * fp64.ONE - a) * fp64.ONE;
+  float err = (a - (s - v) * fp64.ONE) * fp64.ONE * fp64.ONE * fp64.ONE + (b - v);
+#else
+  float v = s - a;
+  float err = (a - (s - v)) + (b - v);
+#endif
+  return vec2(s, err);
+}
+
+vec2 twoSub(float a, float b) {
+  float s = (a - b);
+#if defined(LUMA_FP64_CODE_ELIMINATION_WORKAROUND)
+  float v = (s * fp64.ONE - a) * fp64.ONE;
+  float err = (a - (s - v) * fp64.ONE) * fp64.ONE * fp64.ONE * fp64.ONE - (b + v);
+#else
+  float v = s - a;
+  float err = (a - (s - v)) - (b + v);
+#endif
+  return vec2(s, err);
+}
+
+vec2 twoSqr(float a) {
+  float prod = a * a;
+  vec2 a_fp64 = split(a);
+#if defined(LUMA_FP64_CODE_ELIMINATION_WORKAROUND)
+  float err = ((a_fp64.x * a_fp64.x - prod) * fp64.ONE + 2.0 * a_fp64.x *
+    a_fp64.y * fp64.ONE * fp64.ONE) + a_fp64.y * a_fp64.y * fp64.ONE * fp64.ONE * fp64.ONE;
+#else
+  float err = ((a_fp64.x * a_fp64.x - prod) + 2.0 * a_fp64.x * a_fp64.y) + a_fp64.y * a_fp64.y;
+#endif
+  return vec2(prod, err);
+}
+
+vec2 twoProd(float a, float b) {
+  float prod = a * b;
+  vec2 a_fp64 = split(a);
+  vec2 b_fp64 = split(b);
+  float err = ((a_fp64.x * b_fp64.x - prod) + a_fp64.x * b_fp64.y +
+    a_fp64.y * b_fp64.x) + a_fp64.y * b_fp64.y;
+  return vec2(prod, err);
+}
+
+vec2 sum_fp64(vec2 a, vec2 b) {
+  vec2 s, t;
+  s = twoSum(a.x, b.x);
+  t = twoSum(a.y, b.y);
+  s.y += t.x;
+  s = quickTwoSum(s.x, s.y);
+  s.y += t.y;
+  s = quickTwoSum(s.x, s.y);
+  return s;
+}
+
+vec2 sub_fp64(vec2 a, vec2 b) {
+  vec2 s, t;
+  s = twoSub(a.x, b.x);
+  t = twoSub(a.y, b.y);
+  s.y += t.x;
+  s = quickTwoSum(s.x, s.y);
+  s.y += t.y;
+  s = quickTwoSum(s.x, s.y);
+  return s;
+}
+
+vec2 mul_fp64(vec2 a, vec2 b) {
+  vec2 prod = twoProd(a.x, b.x);
+  // y component is for the error
+  prod.y += a.x * b.y;
+#if defined(LUMA_FP64_HIGH_BITS_OVERFLOW_WORKAROUND)
+  prod = split2(prod);
+#endif
+  prod = quickTwoSum(prod.x, prod.y);
+  prod.y += a.y * b.x;
+#if defined(LUMA_FP64_HIGH_BITS_OVERFLOW_WORKAROUND)
+  prod = split2(prod);
+#endif
+  prod = quickTwoSum(prod.x, prod.y);
+  return prod;
+}
+
+vec2 div_fp64(vec2 a, vec2 b) {
+  float xn = 1.0 / b.x;
+#if defined(LUMA_FP64_HIGH_BITS_OVERFLOW_WORKAROUND)
+  vec2 yn = mul_fp64(a, vec2(xn, 0));
+#else
+  vec2 yn = a * xn;
+#endif
+  float diff = (sub_fp64(a, mul_fp64(b, yn))).x;
+  vec2 prod = twoProd(xn, diff);
+  return sum_fp64(yn, prod);
+}
+
+vec2 sqrt_fp64(vec2 a) {
+  if (a.x == 0.0 && a.y == 0.0) return vec2(0.0, 0.0);
+  if (a.x < 0.0) return vec2(0.0 / 0.0, 0.0 / 0.0);
+
+  float x = 1.0 / sqrt(a.x);
+  float yn = a.x * x;
+#if defined(LUMA_FP64_CODE_ELIMINATION_WORKAROUND)
+  vec2 yn_sqr = twoSqr(yn) * fp64.ONE;
+#else
+  vec2 yn_sqr = twoSqr(yn);
+#endif
+  float diff = sub_fp64(a, yn_sqr).x;
+  vec2 prod = twoProd(x * 0.5, diff);
+#if defined(LUMA_FP64_HIGH_BITS_OVERFLOW_WORKAROUND)
+  return sum_fp64(split(yn), prod);
+#else
+  return sum_fp64(vec2(yn, 0.0), prod);
+#endif
+}
+`
+);
+const defaultUniforms = {
+  // Used in LUMA_FP64_CODE_ELIMINATION_WORKAROUND
+  ONE: 1
+};
+const fp64arithmetic = {
+  name: "fp64arithmetic",
+  vs: fp64arithmeticShader,
+  defaultUniforms,
+  uniformTypes: { ONE: "f32" },
+  // Additional Functions
+  fp64ify,
+  fp64LowPart: fp64LowPart$1,
+  fp64ifyMatrix4
+};
+const DEFAULT_HIGHLIGHT_COLOR = [0, 1, 1, 1];
+const vs$6 = (
+  /* glsl */
+  `uniform pickingUniforms {
+  float isActive;
+  float isAttribute;
+  float isHighlightActive;
+  float useFloatColors;
+  vec3 highlightedObjectColor;
+  vec4 highlightColor;
+} picking;
+
+out vec4 picking_vRGBcolor_Avalid;
+
+// Normalize unsigned byte color to 0-1 range
+vec3 picking_normalizeColor(vec3 color) {
+  return picking.useFloatColors > 0.5 ? color : color / 255.0;
+}
+
+// Normalize unsigned byte color to 0-1 range
+vec4 picking_normalizeColor(vec4 color) {
+  return picking.useFloatColors > 0.5 ? color : color / 255.0;
+}
+
+bool picking_isColorZero(vec3 color) {
+  return dot(color, vec3(1.0)) < 0.00001;
+}
+
+bool picking_isColorValid(vec3 color) {
+  return dot(color, vec3(1.0)) > 0.00001;
+}
+
+// Check if this vertex is highlighted
+bool isVertexHighlighted(vec3 vertexColor) {
+  vec3 highlightedObjectColor = picking_normalizeColor(picking.highlightedObjectColor);
+  return
+    bool(picking.isHighlightActive) && picking_isColorZero(abs(vertexColor - highlightedObjectColor));
+}
+
+// Set the current picking color
+void picking_setPickingColor(vec3 pickingColor) {
+  pickingColor = picking_normalizeColor(pickingColor);
+
+  if (bool(picking.isActive)) {
+    // Use alpha as the validity flag. If pickingColor is [0, 0, 0] fragment is non-pickable
+    picking_vRGBcolor_Avalid.a = float(picking_isColorValid(pickingColor));
+
+    if (!bool(picking.isAttribute)) {
+      // Stores the picking color so that the fragment shader can render it during picking
+      picking_vRGBcolor_Avalid.rgb = pickingColor;
+    }
+  } else {
+    // Do the comparison with selected item color in vertex shader as it should mean fewer compares
+    picking_vRGBcolor_Avalid.a = float(isVertexHighlighted(pickingColor));
+  }
+}
+
+void picking_setPickingAttribute(float value) {
+  if (bool(picking.isAttribute)) {
+    picking_vRGBcolor_Avalid.r = value;
+  }
+}
+
+void picking_setPickingAttribute(vec2 value) {
+  if (bool(picking.isAttribute)) {
+    picking_vRGBcolor_Avalid.rg = value;
+  }
+}
+
+void picking_setPickingAttribute(vec3 value) {
+  if (bool(picking.isAttribute)) {
+    picking_vRGBcolor_Avalid.rgb = value;
+  }
+}
+`
+);
+const fs$4 = (
+  /* glsl */
+  `uniform pickingUniforms {
+  float isActive;
+  float isAttribute;
+  float isHighlightActive;
+  float useFloatColors;
+  vec3 highlightedObjectColor;
+  vec4 highlightColor;
+} picking;
+
+in vec4 picking_vRGBcolor_Avalid;
+
+/*
+ * Returns highlight color if this item is selected.
+ */
+vec4 picking_filterHighlightColor(vec4 color) {
+  // If we are still picking, we don't highlight
+  if (picking.isActive > 0.5) {
+    return color;
+  }
+
+  bool selected = bool(picking_vRGBcolor_Avalid.a);
+
+  if (selected) {
+    // Blend in highlight color based on its alpha value
+    float highLightAlpha = picking.highlightColor.a;
+    float blendedAlpha = highLightAlpha + color.a * (1.0 - highLightAlpha);
+    float highLightRatio = highLightAlpha / blendedAlpha;
+
+    vec3 blendedRGB = mix(color.rgb, picking.highlightColor.rgb, highLightRatio);
+    return vec4(blendedRGB, blendedAlpha);
+  } else {
+    return color;
+  }
+}
+
+/*
+ * Returns picking color if picking enabled else unmodified argument.
+ */
+vec4 picking_filterPickingColor(vec4 color) {
+  if (bool(picking.isActive)) {
+    if (picking_vRGBcolor_Avalid.a == 0.0) {
+      discard;
+    }
+    return picking_vRGBcolor_Avalid;
+  }
+  return color;
+}
+
+/*
+ * Returns picking color if picking is enabled if not
+ * highlight color if this item is selected, otherwise unmodified argument.
+ */
+vec4 picking_filterColor(vec4 color) {
+  vec4 highlightColor = picking_filterHighlightColor(color);
+  return picking_filterPickingColor(highlightColor);
+}
+`
+);
+const picking$1 = {
+  props: {},
+  uniforms: {},
+  name: "picking",
+  uniformTypes: {
+    isActive: "f32",
+    isAttribute: "f32",
+    isHighlightActive: "f32",
+    useFloatColors: "f32",
+    highlightedObjectColor: "vec3<f32>",
+    highlightColor: "vec4<f32>"
+  },
+  defaultUniforms: {
+    isActive: false,
+    isAttribute: false,
+    isHighlightActive: false,
+    useFloatColors: true,
+    highlightedObjectColor: [0, 0, 0],
+    highlightColor: DEFAULT_HIGHLIGHT_COLOR
+  },
+  vs: vs$6,
+  fs: fs$4,
+  getUniforms: getUniforms$1
+};
+function getUniforms$1(opts = {}, prevUniforms) {
+  const uniforms = {};
+  if (opts.highlightedObjectColor === void 0) ;
+  else if (opts.highlightedObjectColor === null) {
+    uniforms.isHighlightActive = false;
+  } else {
+    uniforms.isHighlightActive = true;
+    const highlightedObjectColor = opts.highlightedObjectColor.slice(0, 3);
+    uniforms.highlightedObjectColor = highlightedObjectColor;
+  }
+  if (opts.highlightColor) {
+    const color2 = Array.from(opts.highlightColor, (x2) => x2 / 255);
+    if (!Number.isFinite(color2[3])) {
+      color2[3] = 1;
+    }
+    uniforms.highlightColor = color2;
+  }
+  if (opts.isActive !== void 0) {
+    uniforms.isActive = Boolean(opts.isActive);
+    uniforms.isAttribute = Boolean(opts.isAttribute);
+  }
+  if (opts.useFloatColors !== void 0) {
+    uniforms.useFloatColors = Boolean(opts.useFloatColors);
+  }
+  return uniforms;
+}
+const uniformBlock$3 = `uniform layerUniforms {
+  uniform float opacity;
+} layer;
+`;
+const layerUniforms = {
+  name: "layer",
+  vs: uniformBlock$3,
+  fs: uniformBlock$3,
+  getUniforms: (props) => {
+    return {
+      // apply gamma to opacity to make it visually "linear"
+      // TODO - v10: use raw opacity?
+      opacity: Math.pow(props.opacity, 1 / 2.2)
+    };
+  },
+  uniformTypes: {
+    opacity: "f32"
+  }
+};
+const colorWGSL = (
+  /* WGSL */
+  `
+
+struct ColorUniforms {
+  opacity: f32,
+};
+
+var<private> color: ColorUniforms = ColorUniforms(1.0);
+// TODO (kaapp) avoiding binding index collisions to handle layer opacity
+// requires some thought.
+// @group(0) @binding(0) var<uniform> color: ColorUniforms;
+
+@must_use
+fn deckgl_premultiplied_alpha(fragColor: vec4<f32>) -> vec4<f32> {
+    return vec4(fragColor.rgb * fragColor.a, fragColor.a);
+};
+`
+);
+const color = {
+  name: "color",
+  dependencies: [],
+  source: colorWGSL,
+  getUniforms: (_props) => {
+    return {};
+  },
+  uniformTypes: {
+    opacity: "f32"
+  }
+  // @ts-ignore TODO v9.1
+};
+const source$2 = (
+  /* wgsl */
+  `const SMOOTH_EDGE_RADIUS: f32 = 0.5;
+
+struct VertexGeometry {
+  position: vec4<f32>,
+  worldPosition: vec3<f32>,
+  worldPositionAlt: vec3<f32>,
+  normal: vec3<f32>,
+  uv: vec2<f32>,
+  pickingColor: vec3<f32>,
+};
+
+var<private> geometry_: VertexGeometry = VertexGeometry(
+  vec4<f32>(0.0, 0.0, 1.0, 0.0),
+  vec3<f32>(0.0, 0.0, 0.0),
+  vec3<f32>(0.0, 0.0, 0.0),
+  vec3<f32>(0.0, 0.0, 0.0),
+  vec2<f32>(0.0, 0.0),
+  vec3<f32>(0.0, 0.0, 0.0)
+);
+
+struct FragmentGeometry {
+  uv: vec2<f32>,
+};
+
+var<private> fragmentGeometry: FragmentGeometry;
+
+fn smoothedge(edge: f32, x: f32) -> f32 {
+  return smoothstep(edge - SMOOTH_EDGE_RADIUS, edge + SMOOTH_EDGE_RADIUS, x);
+}
+`
+);
+const defines = "#define SMOOTH_EDGE_RADIUS 0.5";
+const vs$5 = (
+  /* glsl */
+  `${defines}
+
+struct VertexGeometry {
+  vec4 position;
+  vec3 worldPosition;
+  vec3 worldPositionAlt;
+  vec3 normal;
+  vec2 uv;
+  vec3 pickingColor;
+} geometry = VertexGeometry(
+  vec4(0.0, 0.0, 1.0, 0.0),
+  vec3(0.0),
+  vec3(0.0),
+  vec3(0.0),
+  vec2(0.0),
+  vec3(0.0)
+);
+`
+);
+const fs$3 = (
+  /* glsl */
+  `${defines}
+
+struct FragmentGeometry {
+  vec2 uv;
+} geometry;
+
+float smoothedge(float edge, float x) {
+  return smoothstep(edge - SMOOTH_EDGE_RADIUS, edge + SMOOTH_EDGE_RADIUS, x);
+}
+`
+);
+const geometry = {
+  name: "geometry",
+  source: source$2,
+  vs: vs$5,
+  fs: fs$3
+};
+const COMPUTE_INTERVAL = 25;
+var InputEvent;
+(function(InputEvent2) {
+  InputEvent2[InputEvent2["Start"] = 1] = "Start";
+  InputEvent2[InputEvent2["Move"] = 2] = "Move";
+  InputEvent2[InputEvent2["End"] = 4] = "End";
+  InputEvent2[InputEvent2["Cancel"] = 8] = "Cancel";
+})(InputEvent || (InputEvent = {}));
+var InputDirection;
+(function(InputDirection2) {
+  InputDirection2[InputDirection2["None"] = 0] = "None";
+  InputDirection2[InputDirection2["Left"] = 1] = "Left";
+  InputDirection2[InputDirection2["Right"] = 2] = "Right";
+  InputDirection2[InputDirection2["Up"] = 4] = "Up";
+  InputDirection2[InputDirection2["Down"] = 8] = "Down";
+  InputDirection2[InputDirection2["Horizontal"] = 3] = "Horizontal";
+  InputDirection2[InputDirection2["Vertical"] = 12] = "Vertical";
+  InputDirection2[InputDirection2["All"] = 15] = "All";
+})(InputDirection || (InputDirection = {}));
+var RecognizerState;
+(function(RecognizerState2) {
+  RecognizerState2[RecognizerState2["Possible"] = 1] = "Possible";
+  RecognizerState2[RecognizerState2["Began"] = 2] = "Began";
+  RecognizerState2[RecognizerState2["Changed"] = 4] = "Changed";
+  RecognizerState2[RecognizerState2["Ended"] = 8] = "Ended";
+  RecognizerState2[RecognizerState2["Recognized"] = 8] = "Recognized";
+  RecognizerState2[RecognizerState2["Cancelled"] = 16] = "Cancelled";
+  RecognizerState2[RecognizerState2["Failed"] = 32] = "Failed";
+})(RecognizerState || (RecognizerState = {}));
+const TOUCH_ACTION_COMPUTE = "compute";
+const TOUCH_ACTION_AUTO = "auto";
+const TOUCH_ACTION_MANIPULATION = "manipulation";
+const TOUCH_ACTION_NONE = "none";
+const TOUCH_ACTION_PAN_X = "pan-x";
+const TOUCH_ACTION_PAN_Y = "pan-y";
+function cleanTouchActions(actions) {
+  if (actions.includes(TOUCH_ACTION_NONE)) {
+    return TOUCH_ACTION_NONE;
+  }
+  const hasPanX = actions.includes(TOUCH_ACTION_PAN_X);
+  const hasPanY = actions.includes(TOUCH_ACTION_PAN_Y);
+  if (hasPanX && hasPanY) {
+    return TOUCH_ACTION_NONE;
+  }
+  if (hasPanX || hasPanY) {
+    return hasPanX ? TOUCH_ACTION_PAN_X : TOUCH_ACTION_PAN_Y;
+  }
+  if (actions.includes(TOUCH_ACTION_MANIPULATION)) {
+    return TOUCH_ACTION_MANIPULATION;
+  }
+  return TOUCH_ACTION_AUTO;
+}
+class TouchAction {
+  constructor(manager, value) {
+    this.actions = "";
+    this.manager = manager;
+    this.set(value);
+  }
+  /**
+   * set the touchAction value on the element or enable the polyfill
+   */
+  set(value) {
+    if (value === TOUCH_ACTION_COMPUTE) {
+      value = this.compute();
+    }
+    if (this.manager.element) {
+      this.manager.element.style.touchAction = value;
+      this.actions = value;
+    }
+  }
+  /**
+   * just re-set the touchAction value
+   */
+  update() {
+    this.set(this.manager.options.touchAction);
+  }
+  /**
+   * compute the value for the touchAction property based on the recognizer's settings
+   */
+  compute() {
+    let actions = [];
+    for (const recognizer of this.manager.recognizers) {
+      if (recognizer.options.enable) {
+        actions = actions.concat(recognizer.getTouchAction());
+      }
+    }
+    return cleanTouchActions(actions.join(" "));
+  }
+}
+function splitStr(str) {
+  return str.trim().split(/\s+/g);
+}
+function addEventListeners(target, types, handler) {
+  if (!target) {
+    return;
+  }
+  for (const type of splitStr(types)) {
+    target.addEventListener(type, handler, false);
+  }
+}
+function removeEventListeners(target, types, handler) {
+  if (!target) {
+    return;
+  }
+  for (const type of splitStr(types)) {
+    target.removeEventListener(type, handler, false);
+  }
+}
+function getWindowForElement(element) {
+  const doc = element.ownerDocument || element;
+  return doc.defaultView;
+}
+function hasParent(node, parent) {
+  let ancestor = node;
+  while (ancestor) {
+    if (ancestor === parent) {
+      return true;
+    }
+    ancestor = ancestor.parentNode;
+  }
+  return false;
+}
+function getCenter(pointers) {
+  const pointersLength = pointers.length;
+  if (pointersLength === 1) {
+    return {
+      x: Math.round(pointers[0].clientX),
+      y: Math.round(pointers[0].clientY)
+    };
+  }
+  let x2 = 0;
+  let y2 = 0;
+  let i2 = 0;
+  while (i2 < pointersLength) {
+    x2 += pointers[i2].clientX;
+    y2 += pointers[i2].clientY;
+    i2++;
+  }
+  return {
+    x: Math.round(x2 / pointersLength),
+    y: Math.round(y2 / pointersLength)
+  };
+}
+function simpleCloneInputData(input) {
+  const pointers = [];
+  let i2 = 0;
+  while (i2 < input.pointers.length) {
+    pointers[i2] = {
+      clientX: Math.round(input.pointers[i2].clientX),
+      clientY: Math.round(input.pointers[i2].clientY)
+    };
+    i2++;
+  }
+  return {
+    timeStamp: Date.now(),
+    pointers,
+    center: getCenter(pointers),
+    deltaX: input.deltaX,
+    deltaY: input.deltaY
+  };
+}
+function getPointDistance(p1, p2) {
+  const x2 = p2.x - p1.x;
+  const y2 = p2.y - p1.y;
+  return Math.sqrt(x2 * x2 + y2 * y2);
+}
+function getEventDistance(p1, p2) {
+  const x2 = p2.clientX - p1.clientX;
+  const y2 = p2.clientY - p1.clientY;
+  return Math.sqrt(x2 * x2 + y2 * y2);
+}
+function getPointAngle(p1, p2) {
+  const x2 = p2.x - p1.x;
+  const y2 = p2.y - p1.y;
+  return Math.atan2(y2, x2) * 180 / Math.PI;
+}
+function getEventAngle(p1, p2) {
+  const x2 = p2.clientX - p1.clientX;
+  const y2 = p2.clientY - p1.clientY;
+  return Math.atan2(y2, x2) * 180 / Math.PI;
+}
+function getDirection(dx, dy) {
+  if (dx === dy) {
+    return InputDirection.None;
+  }
+  if (Math.abs(dx) >= Math.abs(dy)) {
+    return dx < 0 ? InputDirection.Left : InputDirection.Right;
+  }
+  return dy < 0 ? InputDirection.Up : InputDirection.Down;
+}
+function computeDeltaXY(session, input) {
+  const center = input.center;
+  let offset = session.offsetDelta;
+  let prevDelta = session.prevDelta;
+  const prevInput = session.prevInput;
+  if (input.eventType === InputEvent.Start || (prevInput == null ? void 0 : prevInput.eventType) === InputEvent.End) {
+    prevDelta = session.prevDelta = {
+      x: (prevInput == null ? void 0 : prevInput.deltaX) || 0,
+      y: (prevInput == null ? void 0 : prevInput.deltaY) || 0
+    };
+    offset = session.offsetDelta = {
+      x: center.x,
+      y: center.y
+    };
+  }
+  return {
+    deltaX: prevDelta.x + (center.x - offset.x),
+    deltaY: prevDelta.y + (center.y - offset.y)
+  };
+}
+function getVelocity(deltaTime, x2, y2) {
+  return {
+    x: x2 / deltaTime || 0,
+    y: y2 / deltaTime || 0
+  };
+}
+function getScale(start, end) {
+  return getEventDistance(end[0], end[1]) / getEventDistance(start[0], start[1]);
+}
+function getRotation(start, end) {
+  return getEventAngle(end[1], end[0]) - getEventAngle(start[1], start[0]);
+}
+function computeIntervalInputData(session, input) {
+  const last = session.lastInterval || input;
+  const deltaTime = input.timeStamp - last.timeStamp;
+  let velocity;
+  let velocityX;
+  let velocityY;
+  let direction;
+  if (input.eventType !== InputEvent.Cancel && (deltaTime > COMPUTE_INTERVAL || last.velocity === void 0)) {
+    const deltaX = input.deltaX - last.deltaX;
+    const deltaY = input.deltaY - last.deltaY;
+    const v2 = getVelocity(deltaTime, deltaX, deltaY);
+    velocityX = v2.x;
+    velocityY = v2.y;
+    velocity = Math.abs(v2.x) > Math.abs(v2.y) ? v2.x : v2.y;
+    direction = getDirection(deltaX, deltaY);
+    session.lastInterval = input;
+  } else {
+    velocity = last.velocity;
+    velocityX = last.velocityX;
+    velocityY = last.velocityY;
+    direction = last.direction;
+  }
+  input.velocity = velocity;
+  input.velocityX = velocityX;
+  input.velocityY = velocityY;
+  input.direction = direction;
+}
+function computeInputData(manager, input) {
+  const { session } = manager;
+  const { pointers } = input;
+  const { length: pointersLength } = pointers;
+  if (!session.firstInput) {
+    session.firstInput = simpleCloneInputData(input);
+  }
+  if (pointersLength > 1 && !session.firstMultiple) {
+    session.firstMultiple = simpleCloneInputData(input);
+  } else if (pointersLength === 1) {
+    session.firstMultiple = false;
+  }
+  const { firstInput, firstMultiple } = session;
+  const offsetCenter = firstMultiple ? firstMultiple.center : firstInput.center;
+  const center = input.center = getCenter(pointers);
+  input.timeStamp = Date.now();
+  input.deltaTime = input.timeStamp - firstInput.timeStamp;
+  input.angle = getPointAngle(offsetCenter, center);
+  input.distance = getPointDistance(offsetCenter, center);
+  const { deltaX, deltaY } = computeDeltaXY(session, input);
+  input.deltaX = deltaX;
+  input.deltaY = deltaY;
+  input.offsetDirection = getDirection(input.deltaX, input.deltaY);
+  const overallVelocity = getVelocity(input.deltaTime, input.deltaX, input.deltaY);
+  input.overallVelocityX = overallVelocity.x;
+  input.overallVelocityY = overallVelocity.y;
+  input.overallVelocity = Math.abs(overallVelocity.x) > Math.abs(overallVelocity.y) ? overallVelocity.x : overallVelocity.y;
+  input.scale = firstMultiple ? getScale(firstMultiple.pointers, pointers) : 1;
+  input.rotation = firstMultiple ? getRotation(firstMultiple.pointers, pointers) : 0;
+  input.maxPointers = !session.prevInput ? input.pointers.length : input.pointers.length > session.prevInput.maxPointers ? input.pointers.length : session.prevInput.maxPointers;
+  let target = manager.element;
+  if (hasParent(input.srcEvent.target, target)) {
+    target = input.srcEvent.target;
+  }
+  input.target = target;
+  computeIntervalInputData(session, input);
+  return input;
+}
+function inputHandler(manager, eventType, input) {
+  const pointersLen = input.pointers.length;
+  const changedPointersLen = input.changedPointers.length;
+  const isFirst = eventType & InputEvent.Start && pointersLen - changedPointersLen === 0;
+  const isFinal = eventType & (InputEvent.End | InputEvent.Cancel) && pointersLen - changedPointersLen === 0;
+  input.isFirst = Boolean(isFirst);
+  input.isFinal = Boolean(isFinal);
+  if (isFirst) {
+    manager.session = {};
+  }
+  input.eventType = eventType;
+  const processedInput = computeInputData(manager, input);
+  manager.emit("hammer.input", processedInput);
+  manager.recognize(processedInput);
+  manager.session.prevInput = processedInput;
+}
+let Input$1 = class Input {
+  constructor(manager) {
+    this.evEl = "";
+    this.evWin = "";
+    this.evTarget = "";
+    this.domHandler = (ev) => {
+      if (this.manager.options.enable) {
+        this.handler(ev);
+      }
+    };
+    this.manager = manager;
+    this.element = manager.element;
+    this.target = manager.options.inputTarget || manager.element;
+  }
+  callback(eventType, input) {
+    inputHandler(this.manager, eventType, input);
+  }
+  // eslint-disable @typescript-eslint/unbound-method
+  /**
+   * bind the events
+   */
+  init() {
+    addEventListeners(this.element, this.evEl, this.domHandler);
+    addEventListeners(this.target, this.evTarget, this.domHandler);
+    addEventListeners(getWindowForElement(this.element), this.evWin, this.domHandler);
+  }
+  /**
+   * unbind the events
+   */
+  destroy() {
+    removeEventListeners(this.element, this.evEl, this.domHandler);
+    removeEventListeners(this.target, this.evTarget, this.domHandler);
+    removeEventListeners(getWindowForElement(this.element), this.evWin, this.domHandler);
+  }
+};
+const POINTER_INPUT_MAP = {
+  pointerdown: InputEvent.Start,
+  pointermove: InputEvent.Move,
+  pointerup: InputEvent.End,
+  pointercancel: InputEvent.Cancel,
+  pointerout: InputEvent.Cancel
+};
+const POINTER_ELEMENT_EVENTS = "pointerdown";
+const POINTER_WINDOW_EVENTS = "pointermove pointerup pointercancel";
+class PointerEventInput extends Input$1 {
+  constructor(manager) {
+    super(manager);
+    this.evEl = POINTER_ELEMENT_EVENTS;
+    this.evWin = POINTER_WINDOW_EVENTS;
+    this.store = this.manager.session.pointerEvents = [];
+    this.init();
+  }
+  /**
+   * handle mouse events
+   */
+  handler(ev) {
+    const { store } = this;
+    let removePointer = false;
+    const eventType = POINTER_INPUT_MAP[ev.type];
+    const pointerType = ev.pointerType;
+    const isTouch = pointerType === "touch";
+    let storeIndex = store.findIndex((e2) => e2.pointerId === ev.pointerId);
+    if (eventType & InputEvent.Start && (ev.buttons || isTouch)) {
+      if (storeIndex < 0) {
+        store.push(ev);
+        storeIndex = store.length - 1;
+      }
+    } else if (eventType & (InputEvent.End | InputEvent.Cancel)) {
+      removePointer = true;
+    }
+    if (storeIndex < 0) {
+      return;
+    }
+    store[storeIndex] = ev;
+    this.callback(eventType, {
+      pointers: store,
+      changedPointers: [ev],
+      eventType,
+      pointerType,
+      srcEvent: ev
+    });
+    if (removePointer) {
+      store.splice(storeIndex, 1);
+    }
+  }
+}
+const VENDOR_PREFIXES = ["", "webkit", "Moz", "MS", "ms", "o"];
+function prefixed(obj, property) {
+  const camelProp = property[0].toUpperCase() + property.slice(1);
+  for (const prefix of VENDOR_PREFIXES) {
+    const prop = prefix ? prefix + camelProp : property;
+    if (prop in obj) {
+      return prop;
+    }
+  }
+  return void 0;
+}
+const STOP = 1;
+const FORCED_STOP = 2;
+const defaultOptions = {
+  touchAction: "compute",
+  enable: true,
+  inputTarget: null,
+  cssProps: {
+    /**
+     * Disables text selection to improve the dragging gesture. Mainly for desktop browsers.
+     */
+    userSelect: "none",
+    /**
+     * (Webkit) Disable default dragging behavior
+     */
+    // @ts-ignore
+    userDrag: "none",
+    /**
+     * (iOS only) Disables the default callout shown when you touch and hold a touch target.
+     * When you touch and hold a touch target such as a link, Safari displays
+     * a callout containing information about the link. This property allows you to disable that callout.
+     */
+    // @ts-ignore
+    touchCallout: "none",
+    /**
+     * (iOS only) Sets the color of the highlight that appears over a link while it's being tapped.
+     */
+    // @ts-ignore
+    tapHighlightColor: "rgba(0,0,0,0)"
+  }
+};
+class Manager {
+  constructor(element, options) {
+    this.options = {
+      ...defaultOptions,
+      ...options,
+      cssProps: { ...defaultOptions.cssProps, ...options.cssProps },
+      inputTarget: options.inputTarget || element
+    };
+    this.handlers = {};
+    this.session = {};
+    this.recognizers = [];
+    this.oldCssProps = {};
+    this.element = element;
+    this.input = new PointerEventInput(this);
+    this.touchAction = new TouchAction(this, this.options.touchAction);
+    this.toggleCssProps(true);
+  }
+  /**
+   * set options
+   */
+  set(options) {
+    Object.assign(this.options, options);
+    if (options.touchAction) {
+      this.touchAction.update();
+    }
+    if (options.inputTarget) {
+      this.input.destroy();
+      this.input.target = options.inputTarget;
+      this.input.init();
+    }
+    return this;
+  }
+  /**
+   * stop recognizing for this session.
+   * This session will be discarded, when a new [input]start event is fired.
+   * When forced, the recognizer cycle is stopped immediately.
+   */
+  stop(force) {
+    this.session.stopped = force ? FORCED_STOP : STOP;
+  }
+  /**
+   * run the recognizers!
+   * called by the inputHandler function on every movement of the pointers (touches)
+   * it walks through all the recognizers and tries to detect the gesture that is being made
+   */
+  recognize(inputData) {
+    const { session } = this;
+    if (session.stopped) {
+      return;
+    }
+    if (this.session.prevented) {
+      inputData.srcEvent.preventDefault();
+    }
+    let recognizer;
+    const { recognizers } = this;
+    let { curRecognizer } = session;
+    if (!curRecognizer || curRecognizer && curRecognizer.state & RecognizerState.Recognized) {
+      curRecognizer = session.curRecognizer = null;
+    }
+    let i2 = 0;
+    while (i2 < recognizers.length) {
+      recognizer = recognizers[i2];
+      if (session.stopped !== FORCED_STOP && // 1
+      (!curRecognizer || recognizer === curRecognizer || // 2
+      recognizer.canRecognizeWith(curRecognizer))) {
+        recognizer.recognize(inputData);
+      } else {
+        recognizer.reset();
+      }
+      if (!curRecognizer && recognizer.state & (RecognizerState.Began | RecognizerState.Changed | RecognizerState.Ended)) {
+        curRecognizer = session.curRecognizer = recognizer;
+      }
+      i2++;
+    }
+  }
+  /**
+   * get a recognizer by its event name.
+   */
+  get(recognizerName) {
+    const { recognizers } = this;
+    for (let i2 = 0; i2 < recognizers.length; i2++) {
+      if (recognizers[i2].options.event === recognizerName) {
+        return recognizers[i2];
+      }
+    }
+    return null;
+  }
+  /**
+   * add a recognizer to the manager
+   * existing recognizers with the same event name will be removed
+   */
+  add(recognizer) {
+    if (Array.isArray(recognizer)) {
+      for (const item of recognizer) {
+        this.add(item);
+      }
+      return this;
+    }
+    const existing = this.get(recognizer.options.event);
+    if (existing) {
+      this.remove(existing);
+    }
+    this.recognizers.push(recognizer);
+    recognizer.manager = this;
+    this.touchAction.update();
+    return recognizer;
+  }
+  /**
+   * remove a recognizer by name or instance
+   */
+  remove(recognizerOrName) {
+    if (Array.isArray(recognizerOrName)) {
+      for (const item of recognizerOrName) {
+        this.remove(item);
+      }
+      return this;
+    }
+    const recognizer = typeof recognizerOrName === "string" ? this.get(recognizerOrName) : recognizerOrName;
+    if (recognizer) {
+      const { recognizers } = this;
+      const index = recognizers.indexOf(recognizer);
+      if (index !== -1) {
+        recognizers.splice(index, 1);
+        this.touchAction.update();
+      }
+    }
+    return this;
+  }
+  /**
+   * bind event
+   */
+  on(events, handler) {
+    if (!events || !handler) {
+      return;
+    }
+    const { handlers } = this;
+    for (const event of splitStr(events)) {
+      handlers[event] = handlers[event] || [];
+      handlers[event].push(handler);
+    }
+  }
+  /**
+   * unbind event, leave hander blank to remove all handlers
+   */
+  off(events, handler) {
+    if (!events) {
+      return;
+    }
+    const { handlers } = this;
+    for (const event of splitStr(events)) {
+      if (!handler) {
+        delete handlers[event];
+      } else if (handlers[event]) {
+        handlers[event].splice(handlers[event].indexOf(handler), 1);
+      }
+    }
+  }
+  /**
+   * emit event to the listeners
+   */
+  emit(event, data) {
+    const handlers = this.handlers[event] && this.handlers[event].slice();
+    if (!handlers || !handlers.length) {
+      return;
+    }
+    const evt = data;
+    evt.type = event;
+    evt.preventDefault = function() {
+      data.srcEvent.preventDefault();
+    };
+    let i2 = 0;
+    while (i2 < handlers.length) {
+      handlers[i2](evt);
+      i2++;
+    }
+  }
+  /**
+   * destroy the manager and unbinds all events
+   * it doesn't unbind dom events, that is the user own responsibility
+   */
+  destroy() {
+    this.toggleCssProps(false);
+    this.handlers = {};
+    this.session = {};
+    this.input.destroy();
+    this.element = null;
+  }
+  /**
+   * add/remove the css properties as defined in manager.options.cssProps
+   */
+  toggleCssProps(add2) {
+    const { element } = this;
+    if (!element) {
+      return;
+    }
+    for (const [name2, value] of Object.entries(this.options.cssProps)) {
+      const prop = prefixed(element.style, name2);
+      if (add2) {
+        this.oldCssProps[prop] = element.style[prop];
+        element.style[prop] = value;
+      } else {
+        element.style[prop] = this.oldCssProps[prop] || "";
+      }
+    }
+    if (!add2) {
+      this.oldCssProps = {};
+    }
+  }
+}
+let _uniqueId = 1;
+function uniqueId() {
+  return _uniqueId++;
+}
+function stateStr(state) {
+  if (state & RecognizerState.Cancelled) {
+    return "cancel";
+  } else if (state & RecognizerState.Ended) {
+    return "end";
+  } else if (state & RecognizerState.Changed) {
+    return "move";
+  } else if (state & RecognizerState.Began) {
+    return "start";
+  }
+  return "";
+}
+class Recognizer {
+  constructor(options) {
+    this.options = options;
+    this.id = uniqueId();
+    this.state = RecognizerState.Possible;
+    this.simultaneous = {};
+    this.requireFail = [];
+  }
+  /**
+   * set options
+   */
+  set(options) {
+    Object.assign(this.options, options);
+    this.manager.touchAction.update();
+    return this;
+  }
+  /**
+   * recognize simultaneous with an other recognizer.
+   */
+  recognizeWith(recognizerOrName) {
+    if (Array.isArray(recognizerOrName)) {
+      for (const item of recognizerOrName) {
+        this.recognizeWith(item);
+      }
+      return this;
+    }
+    let otherRecognizer;
+    if (typeof recognizerOrName === "string") {
+      otherRecognizer = this.manager.get(recognizerOrName);
+      if (!otherRecognizer) {
+        throw new Error(`Cannot find recognizer ${recognizerOrName}`);
+      }
+    } else {
+      otherRecognizer = recognizerOrName;
+    }
+    const { simultaneous } = this;
+    if (!simultaneous[otherRecognizer.id]) {
+      simultaneous[otherRecognizer.id] = otherRecognizer;
+      otherRecognizer.recognizeWith(this);
+    }
+    return this;
+  }
+  /**
+   * drop the simultaneous link. it doesnt remove the link on the other recognizer.
+   */
+  dropRecognizeWith(recognizerOrName) {
+    if (Array.isArray(recognizerOrName)) {
+      for (const item of recognizerOrName) {
+        this.dropRecognizeWith(item);
+      }
+      return this;
+    }
+    let otherRecognizer;
+    if (typeof recognizerOrName === "string") {
+      otherRecognizer = this.manager.get(recognizerOrName);
+    } else {
+      otherRecognizer = recognizerOrName;
+    }
+    if (otherRecognizer) {
+      delete this.simultaneous[otherRecognizer.id];
+    }
+    return this;
+  }
+  /**
+   * recognizer can only run when an other is failing
+   */
+  requireFailure(recognizerOrName) {
+    if (Array.isArray(recognizerOrName)) {
+      for (const item of recognizerOrName) {
+        this.requireFailure(item);
+      }
+      return this;
+    }
+    let otherRecognizer;
+    if (typeof recognizerOrName === "string") {
+      otherRecognizer = this.manager.get(recognizerOrName);
+      if (!otherRecognizer) {
+        throw new Error(`Cannot find recognizer ${recognizerOrName}`);
+      }
+    } else {
+      otherRecognizer = recognizerOrName;
+    }
+    const { requireFail } = this;
+    if (requireFail.indexOf(otherRecognizer) === -1) {
+      requireFail.push(otherRecognizer);
+      otherRecognizer.requireFailure(this);
+    }
+    return this;
+  }
+  /**
+   * drop the requireFailure link. it does not remove the link on the other recognizer.
+   */
+  dropRequireFailure(recognizerOrName) {
+    if (Array.isArray(recognizerOrName)) {
+      for (const item of recognizerOrName) {
+        this.dropRequireFailure(item);
+      }
+      return this;
+    }
+    let otherRecognizer;
+    if (typeof recognizerOrName === "string") {
+      otherRecognizer = this.manager.get(recognizerOrName);
+    } else {
+      otherRecognizer = recognizerOrName;
+    }
+    if (otherRecognizer) {
+      const index = this.requireFail.indexOf(otherRecognizer);
+      if (index > -1) {
+        this.requireFail.splice(index, 1);
+      }
+    }
+    return this;
+  }
+  /**
+   * has require failures boolean
+   */
+  hasRequireFailures() {
+    return Boolean(this.requireFail.find((recognier) => recognier.options.enable));
+  }
+  /**
+   * if the recognizer can recognize simultaneous with an other recognizer
+   */
+  canRecognizeWith(otherRecognizer) {
+    return Boolean(this.simultaneous[otherRecognizer.id]);
+  }
+  /**
+   * You should use `tryEmit` instead of `emit` directly to check
+   * that all the needed recognizers has failed before emitting.
+   */
+  emit(input) {
+    if (!input)
+      return;
+    const { state } = this;
+    if (state < RecognizerState.Ended) {
+      this.manager.emit(this.options.event + stateStr(state), input);
+    }
+    this.manager.emit(this.options.event, input);
+    if (input.additionalEvent) {
+      this.manager.emit(input.additionalEvent, input);
+    }
+    if (state >= RecognizerState.Ended) {
+      this.manager.emit(this.options.event + stateStr(state), input);
+    }
+  }
+  /**
+   * Check that all the require failure recognizers has failed,
+   * if true, it emits a gesture event,
+   * otherwise, setup the state to FAILED.
+   */
+  tryEmit(input) {
+    if (this.canEmit()) {
+      this.emit(input);
+    } else {
+      this.state = RecognizerState.Failed;
+    }
+  }
+  /**
+   * can we emit?
+   */
+  canEmit() {
+    let i2 = 0;
+    while (i2 < this.requireFail.length) {
+      if (!(this.requireFail[i2].state & (RecognizerState.Failed | RecognizerState.Possible))) {
+        return false;
+      }
+      i2++;
+    }
+    return true;
+  }
+  /**
+   * update the recognizer
+   */
+  recognize(inputData) {
+    const inputDataClone = { ...inputData };
+    if (!this.options.enable) {
+      this.reset();
+      this.state = RecognizerState.Failed;
+      return;
+    }
+    if (this.state & (RecognizerState.Recognized | RecognizerState.Cancelled | RecognizerState.Failed)) {
+      this.state = RecognizerState.Possible;
+    }
+    this.state = this.process(inputDataClone);
+    if (this.state & (RecognizerState.Began | RecognizerState.Changed | RecognizerState.Ended | RecognizerState.Cancelled)) {
+      this.tryEmit(inputDataClone);
+    }
+  }
+  /**
+   * return the event names that are emitted by this recognizer
+   */
+  getEventNames() {
+    return [this.options.event];
+  }
+  /**
+   * called when the gesture isn't allowed to recognize
+   * like when another is being recognized or it is disabled
+   */
+  reset() {
+  }
+}
+class AttrRecognizer extends Recognizer {
+  /**
+   * Used to check if it the recognizer receives valid input, like input.distance > 10.
+   */
+  attrTest(input) {
+    const optionPointers = this.options.pointers;
+    return optionPointers === 0 || input.pointers.length === optionPointers;
+  }
+  /**
+   * Process the input and return the state for the recognizer
+   */
+  process(input) {
+    const { state } = this;
+    const { eventType } = input;
+    const isRecognized = state & (RecognizerState.Began | RecognizerState.Changed);
+    const isValid = this.attrTest(input);
+    if (isRecognized && (eventType & InputEvent.Cancel || !isValid)) {
+      return state | RecognizerState.Cancelled;
+    } else if (isRecognized || isValid) {
+      if (eventType & InputEvent.End) {
+        return state | RecognizerState.Ended;
+      } else if (!(state & RecognizerState.Began)) {
+        return RecognizerState.Began;
+      }
+      return state | RecognizerState.Changed;
+    }
+    return RecognizerState.Failed;
+  }
+}
+class TapRecognizer extends Recognizer {
+  constructor(options = {}) {
+    super({
+      enable: true,
+      event: "tap",
+      pointers: 1,
+      taps: 1,
+      interval: 300,
+      time: 250,
+      threshold: 9,
+      posThreshold: 10,
+      ...options
+    });
+    this.pTime = null;
+    this.pCenter = null;
+    this._timer = null;
+    this._input = null;
+    this.count = 0;
+  }
+  getTouchAction() {
+    return [TOUCH_ACTION_MANIPULATION];
+  }
+  process(input) {
+    const { options } = this;
+    const validPointers = input.pointers.length === options.pointers;
+    const validMovement = input.distance < options.threshold;
+    const validTouchTime = input.deltaTime < options.time;
+    this.reset();
+    if (input.eventType & InputEvent.Start && this.count === 0) {
+      return this.failTimeout();
+    }
+    if (validMovement && validTouchTime && validPointers) {
+      if (input.eventType !== InputEvent.End) {
+        return this.failTimeout();
+      }
+      const validInterval = this.pTime ? input.timeStamp - this.pTime < options.interval : true;
+      const validMultiTap = !this.pCenter || getPointDistance(this.pCenter, input.center) < options.posThreshold;
+      this.pTime = input.timeStamp;
+      this.pCenter = input.center;
+      if (!validMultiTap || !validInterval) {
+        this.count = 1;
+      } else {
+        this.count += 1;
+      }
+      this._input = input;
+      const tapCount = this.count % options.taps;
+      if (tapCount === 0) {
+        if (!this.hasRequireFailures()) {
+          return RecognizerState.Recognized;
+        }
+        this._timer = setTimeout(() => {
+          this.state = RecognizerState.Recognized;
+          this.tryEmit(this._input);
+        }, options.interval);
+        return RecognizerState.Began;
+      }
+    }
+    return RecognizerState.Failed;
+  }
+  failTimeout() {
+    this._timer = setTimeout(() => {
+      this.state = RecognizerState.Failed;
+    }, this.options.interval);
+    return RecognizerState.Failed;
+  }
+  reset() {
+    clearTimeout(this._timer);
+  }
+  emit(input) {
+    if (this.state === RecognizerState.Recognized) {
+      input.tapCount = this.count;
+      this.manager.emit(this.options.event, input);
+    }
+  }
+}
+const EVENT_NAMES$1 = ["", "start", "move", "end", "cancel", "up", "down", "left", "right"];
+class PanRecognizer extends AttrRecognizer {
+  constructor(options = {}) {
+    super({
+      enable: true,
+      pointers: 1,
+      event: "pan",
+      threshold: 10,
+      direction: InputDirection.All,
+      ...options
+    });
+    this.pX = null;
+    this.pY = null;
+  }
+  getTouchAction() {
+    const { options: { direction } } = this;
+    const actions = [];
+    if (direction & InputDirection.Horizontal) {
+      actions.push(TOUCH_ACTION_PAN_Y);
+    }
+    if (direction & InputDirection.Vertical) {
+      actions.push(TOUCH_ACTION_PAN_X);
+    }
+    return actions;
+  }
+  getEventNames() {
+    return EVENT_NAMES$1.map((suffix) => this.options.event + suffix);
+  }
+  directionTest(input) {
+    const { options } = this;
+    let hasMoved = true;
+    let { distance: distance2 } = input;
+    let { direction } = input;
+    const x2 = input.deltaX;
+    const y2 = input.deltaY;
+    if (!(direction & options.direction)) {
+      if (options.direction & InputDirection.Horizontal) {
+        direction = x2 === 0 ? InputDirection.None : x2 < 0 ? InputDirection.Left : InputDirection.Right;
+        hasMoved = x2 !== this.pX;
+        distance2 = Math.abs(input.deltaX);
+      } else {
+        direction = y2 === 0 ? InputDirection.None : y2 < 0 ? InputDirection.Up : InputDirection.Down;
+        hasMoved = y2 !== this.pY;
+        distance2 = Math.abs(input.deltaY);
+      }
+    }
+    input.direction = direction;
+    return hasMoved && distance2 > options.threshold && Boolean(direction & options.direction);
+  }
+  attrTest(input) {
+    return super.attrTest(input) && (Boolean(this.state & RecognizerState.Began) || !(this.state & RecognizerState.Began) && this.directionTest(input));
+  }
+  emit(input) {
+    this.pX = input.deltaX;
+    this.pY = input.deltaY;
+    const direction = InputDirection[input.direction].toLowerCase();
+    if (direction) {
+      input.additionalEvent = this.options.event + direction;
+    }
+    super.emit(input);
+  }
+}
+const EVENT_NAMES = ["", "start", "move", "end", "cancel", "in", "out"];
+class PinchRecognizer extends AttrRecognizer {
+  constructor(options = {}) {
+    super({
+      enable: true,
+      event: "pinch",
+      threshold: 0,
+      pointers: 2,
+      ...options
+    });
+  }
+  getTouchAction() {
+    return [TOUCH_ACTION_NONE];
+  }
+  getEventNames() {
+    return EVENT_NAMES.map((suffix) => this.options.event + suffix);
+  }
+  attrTest(input) {
+    return super.attrTest(input) && (Math.abs(input.scale - 1) > this.options.threshold || Boolean(this.state & RecognizerState.Began));
+  }
+  emit(input) {
+    if (input.scale !== 1) {
+      const inOut = input.scale < 1 ? "in" : "out";
+      input.additionalEvent = this.options.event + inOut;
+    }
+    super.emit(input);
+  }
+}
+class Input2 {
+  constructor(element, callback, options) {
+    this.element = element;
+    this.callback = callback;
+    this.options = options;
+  }
+}
+const userAgent = typeof navigator !== "undefined" && navigator.userAgent ? navigator.userAgent.toLowerCase() : "";
+const firefox = userAgent.indexOf("firefox") !== -1;
+const WHEEL_DELTA_MAGIC_SCALER = 4.000244140625;
+const WHEEL_DELTA_PER_LINE = 40;
+const SHIFT_MULTIPLIER = 0.25;
+class WheelInput extends Input2 {
+  constructor(element, callback, options) {
+    super(element, callback, { enable: true, ...options });
+    this.handleEvent = (event) => {
+      if (!this.options.enable) {
+        return;
+      }
+      let value = event.deltaY;
+      if (globalThis.WheelEvent) {
+        if (firefox && event.deltaMode === globalThis.WheelEvent.DOM_DELTA_PIXEL) {
+          value /= globalThis.devicePixelRatio;
+        }
+        if (event.deltaMode === globalThis.WheelEvent.DOM_DELTA_LINE) {
+          value *= WHEEL_DELTA_PER_LINE;
+        }
+      }
+      if (value !== 0 && value % WHEEL_DELTA_MAGIC_SCALER === 0) {
+        value = Math.floor(value / WHEEL_DELTA_MAGIC_SCALER);
+      }
+      if (event.shiftKey && value) {
+        value = value * SHIFT_MULTIPLIER;
+      }
+      this.callback({
+        type: "wheel",
+        center: {
+          x: event.clientX,
+          y: event.clientY
+        },
+        delta: -value,
+        srcEvent: event,
+        pointerType: "mouse",
+        target: event.target
+      });
+    };
+    element.addEventListener("wheel", this.handleEvent, { passive: false });
+  }
+  destroy() {
+    this.element.removeEventListener("wheel", this.handleEvent);
+  }
+  /**
+   * Enable this input (begin processing events)
+   * if the specified event type is among those handled by this input.
+   */
+  enableEventType(eventType, enabled) {
+    if (eventType === "wheel") {
+      this.options.enable = enabled;
+    }
+  }
+}
+const MOUSE_EVENTS$1 = [
+  "mousedown",
+  "mousemove",
+  "mouseup",
+  "mouseover",
+  "mouseout",
+  "mouseleave"
+];
+class MoveInput extends Input2 {
+  constructor(element, callback, options) {
+    super(element, callback, { enable: true, ...options });
+    this.handleEvent = (event) => {
+      this.handleOverEvent(event);
+      this.handleOutEvent(event);
+      this.handleEnterEvent(event);
+      this.handleLeaveEvent(event);
+      this.handleMoveEvent(event);
+    };
+    this.pressed = false;
+    const { enable: enable2 } = this.options;
+    this.enableMoveEvent = enable2;
+    this.enableLeaveEvent = enable2;
+    this.enableEnterEvent = enable2;
+    this.enableOutEvent = enable2;
+    this.enableOverEvent = enable2;
+    MOUSE_EVENTS$1.forEach((event) => element.addEventListener(event, this.handleEvent));
+  }
+  destroy() {
+    MOUSE_EVENTS$1.forEach((event) => this.element.removeEventListener(event, this.handleEvent));
+  }
+  /**
+   * Enable this input (begin processing events)
+   * if the specified event type is among those handled by this input.
+   */
+  enableEventType(eventType, enabled) {
+    switch (eventType) {
+      case "pointermove":
+        this.enableMoveEvent = enabled;
+        break;
+      case "pointerover":
+        this.enableOverEvent = enabled;
+        break;
+      case "pointerout":
+        this.enableOutEvent = enabled;
+        break;
+      case "pointerenter":
+        this.enableEnterEvent = enabled;
+        break;
+      case "pointerleave":
+        this.enableLeaveEvent = enabled;
+        break;
+    }
+  }
+  handleOverEvent(event) {
+    if (this.enableOverEvent && event.type === "mouseover") {
+      this._emit("pointerover", event);
+    }
+  }
+  handleOutEvent(event) {
+    if (this.enableOutEvent && event.type === "mouseout") {
+      this._emit("pointerout", event);
+    }
+  }
+  handleEnterEvent(event) {
+    if (this.enableEnterEvent && event.type === "mouseenter") {
+      this._emit("pointerenter", event);
+    }
+  }
+  handleLeaveEvent(event) {
+    if (this.enableLeaveEvent && event.type === "mouseleave") {
+      this._emit("pointerleave", event);
+    }
+  }
+  handleMoveEvent(event) {
+    if (this.enableMoveEvent) {
+      switch (event.type) {
+        case "mousedown":
+          if (event.button >= 0) {
+            this.pressed = true;
+          }
+          break;
+        case "mousemove":
+          if (event.buttons === 0) {
+            this.pressed = false;
+          }
+          if (!this.pressed) {
+            this._emit("pointermove", event);
+          }
+          break;
+        case "mouseup":
+          this.pressed = false;
+          break;
+      }
+    }
+  }
+  _emit(type, event) {
+    this.callback({
+      type,
+      center: {
+        x: event.clientX,
+        y: event.clientY
       },
-      // @method getScaleZoom(scale: Number, fromZoom: Number): Number
-      // Returns the zoom level that the map would end up at, if it is at `fromZoom`
-      // level and everything is scaled by a factor of `scale`. Inverse of
-      // [`getZoomScale`](#map-getZoomScale).
-      getScaleZoom: function(scale2, fromZoom) {
-        var crs = this.options.crs;
-        fromZoom = fromZoom === void 0 ? this._zoom : fromZoom;
-        var zoom2 = crs.zoom(scale2 * crs.scale(fromZoom));
-        return isNaN(zoom2) ? Infinity : zoom2;
+      srcEvent: event,
+      pointerType: "mouse",
+      target: event.target
+    });
+  }
+}
+const KEY_EVENTS = ["keydown", "keyup"];
+class KeyInput extends Input2 {
+  constructor(element, callback, options) {
+    super(element, callback, { enable: true, tabIndex: 0, ...options });
+    this.handleEvent = (event) => {
+      const targetElement = event.target || event.srcElement;
+      if (targetElement.tagName === "INPUT" && targetElement.type === "text" || targetElement.tagName === "TEXTAREA") {
+        return;
+      }
+      if (this.enableDownEvent && event.type === "keydown") {
+        this.callback({
+          type: "keydown",
+          srcEvent: event,
+          key: event.key,
+          target: event.target
+        });
+      }
+      if (this.enableUpEvent && event.type === "keyup") {
+        this.callback({
+          type: "keyup",
+          srcEvent: event,
+          key: event.key,
+          target: event.target
+        });
+      }
+    };
+    this.enableDownEvent = this.options.enable;
+    this.enableUpEvent = this.options.enable;
+    element.tabIndex = this.options.tabIndex;
+    element.style.outline = "none";
+    KEY_EVENTS.forEach((event) => element.addEventListener(event, this.handleEvent));
+  }
+  destroy() {
+    KEY_EVENTS.forEach((event) => this.element.removeEventListener(event, this.handleEvent));
+  }
+  /**
+   * Enable this input (begin processing events)
+   * if the specified event type is among those handled by this input.
+   */
+  enableEventType(eventType, enabled) {
+    if (eventType === "keydown") {
+      this.enableDownEvent = enabled;
+    }
+    if (eventType === "keyup") {
+      this.enableUpEvent = enabled;
+    }
+  }
+}
+class ContextmenuInput extends Input2 {
+  constructor(element, callback, options) {
+    super(element, callback, options);
+    this.handleEvent = (event) => {
+      if (!this.options.enable) {
+        return;
+      }
+      this.callback({
+        type: "contextmenu",
+        center: {
+          x: event.clientX,
+          y: event.clientY
+        },
+        srcEvent: event,
+        pointerType: "mouse",
+        target: event.target
+      });
+    };
+    element.addEventListener("contextmenu", this.handleEvent);
+  }
+  destroy() {
+    this.element.removeEventListener("contextmenu", this.handleEvent);
+  }
+  /**
+   * Enable this input (begin processing events)
+   * if the specified event type is among those handled by this input.
+   */
+  enableEventType(eventType, enabled) {
+    if (eventType === "contextmenu") {
+      this.options.enable = enabled;
+    }
+  }
+}
+const DOWN_EVENT = 1;
+const MOVE_EVENT = 2;
+const UP_EVENT = 4;
+const MOUSE_EVENTS = {
+  pointerdown: DOWN_EVENT,
+  pointermove: MOVE_EVENT,
+  pointerup: UP_EVENT,
+  mousedown: DOWN_EVENT,
+  mousemove: MOVE_EVENT,
+  mouseup: UP_EVENT
+};
+const MOUSE_EVENT_BUTTON_LEFT = 0;
+const MOUSE_EVENT_BUTTON_MIDDLE = 1;
+const MOUSE_EVENT_BUTTON_RIGHT = 2;
+const MOUSE_EVENT_BUTTONS_LEFT_MASK = 1;
+const MOUSE_EVENT_BUTTONS_RIGHT_MASK = 2;
+const MOUSE_EVENT_BUTTONS_MIDDLE_MASK = 4;
+function whichButtons(event) {
+  const eventType = MOUSE_EVENTS[event.srcEvent.type];
+  if (!eventType) {
+    return null;
+  }
+  const { buttons, button } = event.srcEvent;
+  let leftButton = false;
+  let middleButton = false;
+  let rightButton = false;
+  if (eventType === MOVE_EVENT) {
+    leftButton = Boolean(buttons & MOUSE_EVENT_BUTTONS_LEFT_MASK);
+    middleButton = Boolean(buttons & MOUSE_EVENT_BUTTONS_MIDDLE_MASK);
+    rightButton = Boolean(buttons & MOUSE_EVENT_BUTTONS_RIGHT_MASK);
+  } else {
+    leftButton = button === MOUSE_EVENT_BUTTON_LEFT;
+    middleButton = button === MOUSE_EVENT_BUTTON_MIDDLE;
+    rightButton = button === MOUSE_EVENT_BUTTON_RIGHT;
+  }
+  return { leftButton, middleButton, rightButton };
+}
+function getOffsetPosition(event, rootElement) {
+  const center = event.center;
+  if (!center) {
+    return null;
+  }
+  const rect = rootElement.getBoundingClientRect();
+  const scaleX2 = rect.width / rootElement.offsetWidth || 1;
+  const scaleY2 = rect.height / rootElement.offsetHeight || 1;
+  const offsetCenter = {
+    x: (center.x - rect.left - rootElement.clientLeft) / scaleX2,
+    y: (center.y - rect.top - rootElement.clientTop) / scaleY2
+  };
+  return { center, offsetCenter };
+}
+const DEFAULT_OPTIONS = {
+  srcElement: "root",
+  priority: 0
+};
+class EventRegistrar {
+  constructor(eventManager, recognizerName) {
+    this.handleEvent = (event) => {
+      if (this.isEmpty()) {
+        return;
+      }
+      const mjolnirEvent = this._normalizeEvent(event);
+      let target = event.srcEvent.target;
+      while (target && target !== mjolnirEvent.rootElement) {
+        this._emit(mjolnirEvent, target);
+        if (mjolnirEvent.handled) {
+          return;
+        }
+        target = target.parentNode;
+      }
+      this._emit(mjolnirEvent, "root");
+    };
+    this.eventManager = eventManager;
+    this.recognizerName = recognizerName;
+    this.handlers = [];
+    this.handlersByElement = /* @__PURE__ */ new Map();
+    this._active = false;
+  }
+  // Returns true if there are no non-passive handlers
+  isEmpty() {
+    return !this._active;
+  }
+  add(type, handler, options, once = false, passive = false) {
+    const { handlers, handlersByElement } = this;
+    const opts = { ...DEFAULT_OPTIONS, ...options };
+    let entries = handlersByElement.get(opts.srcElement);
+    if (!entries) {
+      entries = [];
+      handlersByElement.set(opts.srcElement, entries);
+    }
+    const entry = {
+      type,
+      handler,
+      srcElement: opts.srcElement,
+      priority: opts.priority
+    };
+    if (once) {
+      entry.once = true;
+    }
+    if (passive) {
+      entry.passive = true;
+    }
+    handlers.push(entry);
+    this._active = this._active || !entry.passive;
+    let insertPosition = entries.length - 1;
+    while (insertPosition >= 0) {
+      if (entries[insertPosition].priority >= entry.priority) {
+        break;
+      }
+      insertPosition--;
+    }
+    entries.splice(insertPosition + 1, 0, entry);
+  }
+  remove(type, handler) {
+    const { handlers, handlersByElement } = this;
+    for (let i2 = handlers.length - 1; i2 >= 0; i2--) {
+      const entry = handlers[i2];
+      if (entry.type === type && entry.handler === handler) {
+        handlers.splice(i2, 1);
+        const entries = handlersByElement.get(entry.srcElement);
+        entries.splice(entries.indexOf(entry), 1);
+        if (entries.length === 0) {
+          handlersByElement.delete(entry.srcElement);
+        }
+      }
+    }
+    this._active = handlers.some((entry) => !entry.passive);
+  }
+  /**
+   * Invoke handlers on a particular element
+   */
+  _emit(event, srcElement) {
+    const entries = this.handlersByElement.get(srcElement);
+    if (entries) {
+      let immediatePropagationStopped = false;
+      const stopPropagation = () => {
+        event.handled = true;
+      };
+      const stopImmediatePropagation = () => {
+        event.handled = true;
+        immediatePropagationStopped = true;
+      };
+      const entriesToRemove = [];
+      for (let i2 = 0; i2 < entries.length; i2++) {
+        const { type, handler, once } = entries[i2];
+        handler({
+          ...event,
+          type,
+          stopPropagation,
+          stopImmediatePropagation
+        });
+        if (once) {
+          entriesToRemove.push(entries[i2]);
+        }
+        if (immediatePropagationStopped) {
+          break;
+        }
+      }
+      for (let i2 = 0; i2 < entriesToRemove.length; i2++) {
+        const { type, handler } = entriesToRemove[i2];
+        this.remove(type, handler);
+      }
+    }
+  }
+  /**
+   * Normalizes hammerjs and custom events to have predictable fields.
+   */
+  _normalizeEvent(event) {
+    const rootElement = this.eventManager.getElement();
+    return {
+      ...event,
+      ...whichButtons(event),
+      ...getOffsetPosition(event, rootElement),
+      preventDefault: () => {
+        event.srcEvent.preventDefault();
       },
-      // @method project(latlng: LatLng, zoom: Number): Point
-      // Projects a geographical coordinate `LatLng` according to the projection
-      // of the map's CRS, then scales it according to `zoom` and the CRS's
-      // `Transformation`. The result is pixel coordinate relative to
-      // the CRS origin.
-      project: function(latlng, zoom2) {
-        zoom2 = zoom2 === void 0 ? this._zoom : zoom2;
-        return this.options.crs.latLngToPoint(toLatLng(latlng), zoom2);
+      stopImmediatePropagation: null,
+      stopPropagation: null,
+      handled: false,
+      rootElement
+    };
+  }
+}
+function normalizeRecognizer(item) {
+  if ("recognizer" in item) {
+    return item;
+  }
+  let recognizer;
+  const itemArray = Array.isArray(item) ? [...item] : [item];
+  if (typeof itemArray[0] === "function") {
+    const RecognizerType = itemArray.shift();
+    const options = itemArray.shift() || {};
+    recognizer = new RecognizerType(options);
+  } else {
+    recognizer = itemArray.shift();
+  }
+  return {
+    recognizer,
+    recognizeWith: typeof itemArray[0] === "string" ? [itemArray[0]] : itemArray[0],
+    requireFailure: typeof itemArray[1] === "string" ? [itemArray[1]] : itemArray[1]
+  };
+}
+class EventManager {
+  constructor(element = null, options = {}) {
+    this._onBasicInput = (event) => {
+      this.manager.emit(event.srcEvent.type, event);
+    };
+    this._onOtherEvent = (event) => {
+      this.manager.emit(event.type, event);
+    };
+    this.options = {
+      recognizers: [],
+      events: {},
+      touchAction: "compute",
+      tabIndex: 0,
+      cssProps: {},
+      ...options
+    };
+    this.events = /* @__PURE__ */ new Map();
+    this.element = element;
+    if (!element)
+      return;
+    this.manager = new Manager(element, this.options);
+    for (const item of this.options.recognizers) {
+      const { recognizer, recognizeWith, requireFailure } = normalizeRecognizer(item);
+      this.manager.add(recognizer);
+      if (recognizeWith) {
+        recognizer.recognizeWith(recognizeWith);
+      }
+      if (requireFailure) {
+        recognizer.requireFailure(requireFailure);
+      }
+    }
+    this.manager.on("hammer.input", this._onBasicInput);
+    this.wheelInput = new WheelInput(element, this._onOtherEvent, {
+      enable: false
+    });
+    this.moveInput = new MoveInput(element, this._onOtherEvent, {
+      enable: false
+    });
+    this.keyInput = new KeyInput(element, this._onOtherEvent, {
+      enable: false,
+      tabIndex: options.tabIndex
+    });
+    this.contextmenuInput = new ContextmenuInput(element, this._onOtherEvent, {
+      enable: false
+    });
+    this.on(this.options.events);
+  }
+  getElement() {
+    return this.element;
+  }
+  // Tear down internal event management implementations.
+  destroy() {
+    if (!this.element)
+      return;
+    this.wheelInput.destroy();
+    this.moveInput.destroy();
+    this.keyInput.destroy();
+    this.contextmenuInput.destroy();
+    this.manager.destroy();
+  }
+  /** Register an event handler function to be called on `event` */
+  on(event, handler, opts) {
+    this._addEventHandler(event, handler, opts, false);
+  }
+  once(event, handler, opts) {
+    this._addEventHandler(event, handler, opts, true);
+  }
+  watch(event, handler, opts) {
+    this._addEventHandler(event, handler, opts, false, true);
+  }
+  off(event, handler) {
+    this._removeEventHandler(event, handler);
+  }
+  /*
+   * Enable/disable recognizer for the given event
+   */
+  _toggleRecognizer(name2, enabled) {
+    var _a3, _b3, _c3, _d2;
+    const { manager } = this;
+    if (!manager) {
+      return;
+    }
+    const recognizer = manager.get(name2);
+    if (recognizer) {
+      recognizer.set({ enable: enabled });
+      manager.touchAction.update();
+    }
+    (_a3 = this.wheelInput) == null ? void 0 : _a3.enableEventType(name2, enabled);
+    (_b3 = this.moveInput) == null ? void 0 : _b3.enableEventType(name2, enabled);
+    (_c3 = this.keyInput) == null ? void 0 : _c3.enableEventType(name2, enabled);
+    (_d2 = this.contextmenuInput) == null ? void 0 : _d2.enableEventType(name2, enabled);
+  }
+  /**
+   * Process the event registration for a single event + handler.
+   */
+  _addEventHandler(event, handler, opts, once, passive) {
+    if (typeof event !== "string") {
+      opts = handler;
+      for (const [eventName, eventHandler] of Object.entries(event)) {
+        this._addEventHandler(eventName, eventHandler, opts, once, passive);
+      }
+      return;
+    }
+    const { manager, events } = this;
+    if (!manager)
+      return;
+    let eventRegistrar = events.get(event);
+    if (!eventRegistrar) {
+      const recognizerName = this._getRecognizerName(event) || event;
+      eventRegistrar = new EventRegistrar(this, recognizerName);
+      events.set(event, eventRegistrar);
+      if (manager) {
+        manager.on(event, eventRegistrar.handleEvent);
+      }
+    }
+    eventRegistrar.add(event, handler, opts, once, passive);
+    if (!eventRegistrar.isEmpty()) {
+      this._toggleRecognizer(eventRegistrar.recognizerName, true);
+    }
+  }
+  /**
+   * Process the event deregistration for a single event + handler.
+   */
+  _removeEventHandler(event, handler) {
+    if (typeof event !== "string") {
+      for (const [eventName, eventHandler] of Object.entries(event)) {
+        this._removeEventHandler(eventName, eventHandler);
+      }
+      return;
+    }
+    const { events } = this;
+    const eventRegistrar = events.get(event);
+    if (!eventRegistrar) {
+      return;
+    }
+    eventRegistrar.remove(event, handler);
+    if (eventRegistrar.isEmpty()) {
+      const { recognizerName } = eventRegistrar;
+      let isRecognizerUsed = false;
+      for (const eh2 of events.values()) {
+        if (eh2.recognizerName === recognizerName && !eh2.isEmpty()) {
+          isRecognizerUsed = true;
+          break;
+        }
+      }
+      if (!isRecognizerUsed) {
+        this._toggleRecognizer(recognizerName, false);
+      }
+    }
+  }
+  _getRecognizerName(event) {
+    var _a3;
+    return (_a3 = this.manager.recognizers.find((recognizer) => {
+      return recognizer.getEventNames().includes(event);
+    })) == null ? void 0 : _a3.options.event;
+  }
+}
+const COORDINATE_SYSTEM = {
+  /**
+   * `LNGLAT` if rendering into a geospatial viewport, `CARTESIAN` otherwise
+   */
+  DEFAULT: -1,
+  /**
+   * Positions are interpreted as [longitude, latitude, elevation]
+   * longitude/latitude are in degrees, elevation is in meters.
+   * Dimensions are in meters.
+   */
+  LNGLAT: 1,
+  /**
+   * Positions are interpreted as [x, y, z] in meter offsets from the coordinate origin.
+   * Dimensions are in meters.
+   */
+  METER_OFFSETS: 2,
+  /**
+   * Positions are interpreted as [deltaLng, deltaLat, elevation] from the coordinate origin.
+   * deltaLng/deltaLat are in degrees, elevation is in meters.
+   * Dimensions are in meters.
+   */
+  LNGLAT_OFFSETS: 3,
+  /**
+   * Positions and dimensions are in the common units of the viewport.
+   */
+  CARTESIAN: 0
+};
+Object.defineProperty(COORDINATE_SYSTEM, "IDENTITY", {
+  get: () => {
+    defaultLogger.deprecated("COORDINATE_SYSTEM.IDENTITY", "COORDINATE_SYSTEM.CARTESIAN")();
+    return 0;
+  }
+});
+const PROJECTION_MODE = {
+  /**
+   * Render geospatial data in Web Mercator projection
+   */
+  WEB_MERCATOR: 1,
+  /**
+   * Render geospatial data as a 3D globe
+   */
+  GLOBE: 2,
+  /**
+   * (Internal use only) Web Mercator projection at high zoom
+   */
+  WEB_MERCATOR_AUTO_OFFSET: 4,
+  /**
+   * No transformation
+   */
+  IDENTITY: 0
+};
+const UNIT = {
+  common: 0,
+  meters: 1,
+  pixels: 2
+};
+const EVENT_HANDLERS = {
+  click: "onClick",
+  dblclick: "onClick",
+  panstart: "onDragStart",
+  panmove: "onDrag",
+  panend: "onDragEnd"
+};
+const RECOGNIZERS = {
+  multipan: [PanRecognizer, { threshold: 10, direction: InputDirection.Vertical, pointers: 2 }],
+  pinch: [PinchRecognizer, {}, null, ["multipan"]],
+  pan: [PanRecognizer, { threshold: 1 }, ["pinch"], ["multipan"]],
+  dblclick: [TapRecognizer, { event: "dblclick", taps: 2 }],
+  click: [TapRecognizer, { event: "click" }, null, ["dblclick"]]
+};
+function isEqual(a2, b2) {
+  if (a2 === b2) {
+    return true;
+  }
+  if (Array.isArray(a2)) {
+    const len2 = a2.length;
+    if (!b2 || b2.length !== len2) {
+      return false;
+    }
+    for (let i2 = 0; i2 < len2; i2++) {
+      if (a2[i2] !== b2[i2]) {
+        return false;
+      }
+    }
+    return true;
+  }
+  return false;
+}
+function memoize(compute) {
+  let cachedArgs = {};
+  let cachedResult;
+  return (args) => {
+    for (const key in args) {
+      if (!isEqual(args[key], cachedArgs[key])) {
+        cachedResult = compute(args);
+        cachedArgs = args;
+        break;
+      }
+    }
+    return cachedResult;
+  };
+}
+const ZERO_VECTOR$1 = [0, 0, 0, 0];
+const VECTOR_TO_POINT_MATRIX$1 = [1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0];
+const IDENTITY_MATRIX = [1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1];
+const DEFAULT_PIXELS_PER_UNIT2 = [0, 0, 0];
+const DEFAULT_COORDINATE_ORIGIN$1 = [0, 0, 0];
+const getMemoizedViewportUniforms = memoize(calculateViewportUniforms);
+function getOffsetOrigin(viewport, coordinateSystem, coordinateOrigin = DEFAULT_COORDINATE_ORIGIN$1) {
+  if (coordinateOrigin.length < 3) {
+    coordinateOrigin = [coordinateOrigin[0], coordinateOrigin[1], 0];
+  }
+  let shaderCoordinateOrigin = coordinateOrigin;
+  let geospatialOrigin;
+  let offsetMode = true;
+  if (coordinateSystem === COORDINATE_SYSTEM.LNGLAT_OFFSETS || coordinateSystem === COORDINATE_SYSTEM.METER_OFFSETS) {
+    geospatialOrigin = coordinateOrigin;
+  } else {
+    geospatialOrigin = viewport.isGeospatial ? (
+      // @ts-expect-error longitude and latitude are not defined on the base Viewport, but is expected on geospatial viewports
+      [Math.fround(viewport.longitude), Math.fround(viewport.latitude), 0]
+    ) : null;
+  }
+  switch (viewport.projectionMode) {
+    case PROJECTION_MODE.WEB_MERCATOR:
+      if (coordinateSystem === COORDINATE_SYSTEM.LNGLAT || coordinateSystem === COORDINATE_SYSTEM.CARTESIAN) {
+        geospatialOrigin = [0, 0, 0];
+        offsetMode = false;
+      }
+      break;
+    case PROJECTION_MODE.WEB_MERCATOR_AUTO_OFFSET:
+      if (coordinateSystem === COORDINATE_SYSTEM.LNGLAT) {
+        shaderCoordinateOrigin = geospatialOrigin;
+      } else if (coordinateSystem === COORDINATE_SYSTEM.CARTESIAN) {
+        shaderCoordinateOrigin = [
+          Math.fround(viewport.center[0]),
+          Math.fround(viewport.center[1]),
+          0
+        ];
+        geospatialOrigin = viewport.unprojectPosition(shaderCoordinateOrigin);
+        shaderCoordinateOrigin[0] -= coordinateOrigin[0];
+        shaderCoordinateOrigin[1] -= coordinateOrigin[1];
+        shaderCoordinateOrigin[2] -= coordinateOrigin[2];
+      }
+      break;
+    case PROJECTION_MODE.IDENTITY:
+      shaderCoordinateOrigin = viewport.position.map(Math.fround);
+      shaderCoordinateOrigin[2] = shaderCoordinateOrigin[2] || 0;
+      break;
+    case PROJECTION_MODE.GLOBE:
+      offsetMode = false;
+      geospatialOrigin = null;
+      break;
+    default:
+      offsetMode = false;
+  }
+  return { geospatialOrigin, shaderCoordinateOrigin, offsetMode };
+}
+function calculateMatrixAndOffset(viewport, coordinateSystem, coordinateOrigin) {
+  const { viewMatrixUncentered, projectionMatrix } = viewport;
+  let { viewMatrix, viewProjectionMatrix } = viewport;
+  let projectionCenter = ZERO_VECTOR$1;
+  let originCommon = ZERO_VECTOR$1;
+  let cameraPosCommon = viewport.cameraPosition;
+  const { geospatialOrigin, shaderCoordinateOrigin, offsetMode } = getOffsetOrigin(viewport, coordinateSystem, coordinateOrigin);
+  if (offsetMode) {
+    originCommon = viewport.projectPosition(geospatialOrigin || shaderCoordinateOrigin);
+    cameraPosCommon = [
+      cameraPosCommon[0] - originCommon[0],
+      cameraPosCommon[1] - originCommon[1],
+      cameraPosCommon[2] - originCommon[2]
+    ];
+    originCommon[3] = 1;
+    projectionCenter = transformMat4([], originCommon, viewProjectionMatrix);
+    viewMatrix = viewMatrixUncentered || viewMatrix;
+    viewProjectionMatrix = multiply([], projectionMatrix, viewMatrix);
+    viewProjectionMatrix = multiply([], viewProjectionMatrix, VECTOR_TO_POINT_MATRIX$1);
+  }
+  return {
+    viewMatrix,
+    viewProjectionMatrix,
+    projectionCenter,
+    originCommon,
+    cameraPosCommon,
+    shaderCoordinateOrigin,
+    geospatialOrigin
+  };
+}
+function getUniformsFromViewport({
+  viewport,
+  devicePixelRatio: devicePixelRatio2 = 1,
+  modelMatrix = null,
+  // Match Layer.defaultProps
+  coordinateSystem = COORDINATE_SYSTEM.DEFAULT,
+  coordinateOrigin = DEFAULT_COORDINATE_ORIGIN$1,
+  autoWrapLongitude = false
+}) {
+  if (coordinateSystem === COORDINATE_SYSTEM.DEFAULT) {
+    coordinateSystem = viewport.isGeospatial ? COORDINATE_SYSTEM.LNGLAT : COORDINATE_SYSTEM.CARTESIAN;
+  }
+  const uniforms = getMemoizedViewportUniforms({
+    viewport,
+    devicePixelRatio: devicePixelRatio2,
+    coordinateSystem,
+    coordinateOrigin
+  });
+  uniforms.wrapLongitude = autoWrapLongitude;
+  uniforms.modelMatrix = modelMatrix || IDENTITY_MATRIX;
+  return uniforms;
+}
+function calculateViewportUniforms({ viewport, devicePixelRatio: devicePixelRatio2, coordinateSystem, coordinateOrigin }) {
+  const { projectionCenter, viewProjectionMatrix, originCommon, cameraPosCommon, shaderCoordinateOrigin, geospatialOrigin } = calculateMatrixAndOffset(viewport, coordinateSystem, coordinateOrigin);
+  const distanceScales = viewport.getDistanceScales();
+  const viewportSize = [
+    viewport.width * devicePixelRatio2,
+    viewport.height * devicePixelRatio2
+  ];
+  const focalDistance = transformMat4([], [0, 0, -viewport.focalDistance, 1], viewport.projectionMatrix)[3] || 1;
+  const uniforms = {
+    // Projection mode values
+    coordinateSystem,
+    projectionMode: viewport.projectionMode,
+    coordinateOrigin: shaderCoordinateOrigin,
+    commonOrigin: originCommon.slice(0, 3),
+    center: projectionCenter,
+    // Backward compatibility
+    // TODO: remove in v9
+    // @ts-expect-error _pseudoMeters is only defined on WebMercator viewport
+    pseudoMeters: Boolean(viewport._pseudoMeters),
+    // Screen size
+    viewportSize,
+    devicePixelRatio: devicePixelRatio2,
+    focalDistance,
+    commonUnitsPerMeter: distanceScales.unitsPerMeter,
+    commonUnitsPerWorldUnit: distanceScales.unitsPerMeter,
+    commonUnitsPerWorldUnit2: DEFAULT_PIXELS_PER_UNIT2,
+    scale: viewport.scale,
+    // This is the mercator scale (2 ** zoom)
+    wrapLongitude: false,
+    viewProjectionMatrix,
+    modelMatrix: IDENTITY_MATRIX,
+    // This is for lighting calculations
+    cameraPosition: cameraPosCommon
+  };
+  if (geospatialOrigin) {
+    const distanceScalesAtOrigin = viewport.getDistanceScales(geospatialOrigin);
+    switch (coordinateSystem) {
+      case COORDINATE_SYSTEM.METER_OFFSETS:
+        uniforms.commonUnitsPerWorldUnit = distanceScalesAtOrigin.unitsPerMeter;
+        uniforms.commonUnitsPerWorldUnit2 = distanceScalesAtOrigin.unitsPerMeter2;
+        break;
+      case COORDINATE_SYSTEM.LNGLAT:
+      case COORDINATE_SYSTEM.LNGLAT_OFFSETS:
+        if (!viewport._pseudoMeters) {
+          uniforms.commonUnitsPerMeter = distanceScalesAtOrigin.unitsPerMeter;
+        }
+        uniforms.commonUnitsPerWorldUnit = distanceScalesAtOrigin.unitsPerDegree;
+        uniforms.commonUnitsPerWorldUnit2 = distanceScalesAtOrigin.unitsPerDegree2;
+        break;
+      case COORDINATE_SYSTEM.CARTESIAN:
+        uniforms.commonUnitsPerWorldUnit = [1, 1, distanceScalesAtOrigin.unitsPerMeter[2]];
+        uniforms.commonUnitsPerWorldUnit2 = [0, 0, distanceScalesAtOrigin.unitsPerMeter2[2]];
+        break;
+    }
+  }
+  return uniforms;
+}
+const COORDINATE_SYSTEM_WGSL_CONSTANTS = Object.keys(COORDINATE_SYSTEM).map((key) => `const COORDINATE_SYSTEM_${key}: i32 = ${COORDINATE_SYSTEM[key]};`).join("");
+const PROJECTION_MODE_WGSL_CONSTANTS = Object.keys(PROJECTION_MODE).map((key) => `const PROJECTION_MODE_${key}: i32 = ${PROJECTION_MODE[key]};`).join("");
+const UNIT_WGSL_CONSTANTS = Object.keys(UNIT).map((key) => `const UNIT_${key.toUpperCase()}: i32 = ${UNIT[key]};`).join("");
+const projectWGSLHeader = (
+  /* wgsl */
+  `${COORDINATE_SYSTEM_WGSL_CONSTANTS}
+${PROJECTION_MODE_WGSL_CONSTANTS}
+${UNIT_WGSL_CONSTANTS}
+
+const TILE_SIZE: f32 = 512.0;
+const PI: f32 = 3.1415926536;
+const WORLD_SCALE: f32 = TILE_SIZE / (PI * 2.0);
+const ZERO_64_LOW: vec3<f32> = vec3<f32>(0.0, 0.0, 0.0);
+const EARTH_RADIUS: f32 = 6370972.0; // meters
+const GLOBE_RADIUS: f32 = 256.0;
+
+// -----------------------------------------------------------------------------
+// Uniform block (converted from GLSL uniform block)
+// -----------------------------------------------------------------------------
+struct ProjectUniforms {
+  wrapLongitude: i32,
+  coordinateSystem: i32,
+  commonUnitsPerMeter: vec3<f32>,
+  projectionMode: i32,
+  scale: f32,
+  commonUnitsPerWorldUnit: vec3<f32>,
+  commonUnitsPerWorldUnit2: vec3<f32>,
+  center: vec4<f32>,
+  modelMatrix: mat4x4<f32>,
+  viewProjectionMatrix: mat4x4<f32>,
+  viewportSize: vec2<f32>,
+  devicePixelRatio: f32,
+  focalDistance: f32,
+  cameraPosition: vec3<f32>,
+  coordinateOrigin: vec3<f32>,
+  commonOrigin: vec3<f32>,
+  pseudoMeters: i32,
+};
+
+@group(0) @binding(0)
+var<uniform> project: ProjectUniforms;
+
+// -----------------------------------------------------------------------------
+// Geometry data
+// (In your GLSL code, "geometry" was assumed to be available globally. In WGSL,
+// you might supply this via vertex attributes or a uniform. Here we define a
+// uniform struct for demonstration.)
+// -----------------------------------------------------------------------------
+
+// Structure to carry additional geometry data used by deck.gl filters.
+struct Geometry {
+  worldPosition: vec3<f32>,
+  worldPositionAlt: vec3<f32>,
+  position: vec4<f32>,
+  normal: vec3<f32>,
+  uv: vec2<f32>,
+  pickingColor: vec3<f32>,
+};
+
+// @group(0) @binding(1)
+var<private> geometry: Geometry;
+`
+);
+const projectWGSL = (
+  /* wgsl */
+  `${projectWGSLHeader}
+
+// -----------------------------------------------------------------------------
+// Functions
+// -----------------------------------------------------------------------------
+
+// Returns an adjustment factor for commonUnitsPerMeter
+fn _project_size_at_latitude(lat: f32) -> f32 {
+  let y = clamp(lat, -89.9, 89.9);
+  return 1.0 / cos(radians(y));
+}
+
+// Overloaded version: scales a value in meters at a given latitude.
+fn _project_size_at_latitude_m(meters: f32, lat: f32) -> f32 {
+  return meters * project.commonUnitsPerMeter.z * _project_size_at_latitude(lat);
+}
+
+// Computes a non-linear scale factor based on geometry.
+// (Note: This function relies on "geometry" being provided.)
+fn project_size() -> f32 {
+  if (project.projectionMode == PROJECTION_MODE_WEB_MERCATOR &&
+      project.coordinateSystem == COORDINATE_SYSTEM_LNGLAT &&
+      project.pseudoMeters == 0) {
+    if (geometry.position.w == 0.0) {
+      return _project_size_at_latitude(geometry.worldPosition.y);
+    }
+    let y: f32 = geometry.position.y / TILE_SIZE * 2.0 - 1.0;
+    let y2 = y * y;
+    let y4 = y2 * y2;
+    let y6 = y4 * y2;
+    return 1.0 + 4.9348 * y2 + 4.0587 * y4 + 1.5642 * y6;
+  }
+  return 1.0;
+}
+
+// Overloads to scale offsets (meters to world units)
+fn project_size_float(meters: f32) -> f32 {
+  return meters * project.commonUnitsPerMeter.z * project_size();
+}
+
+fn project_size_vec2(meters: vec2<f32>) -> vec2<f32> {
+  return meters * project.commonUnitsPerMeter.xy * project_size();
+}
+
+fn project_size_vec3(meters: vec3<f32>) -> vec3<f32> {
+  return meters * project.commonUnitsPerMeter * project_size();
+}
+
+fn project_size_vec4(meters: vec4<f32>) -> vec4<f32> {
+  return vec4<f32>(meters.xyz * project.commonUnitsPerMeter, meters.w);
+}
+
+// Returns a rotation matrix aligning the z‑axis with the given up vector.
+fn project_get_orientation_matrix(up: vec3<f32>) -> mat3x3<f32> {
+  let uz = normalize(up);
+  let ux = select(
+    vec3<f32>(1.0, 0.0, 0.0),
+    normalize(vec3<f32>(uz.y, -uz.x, 0.0)),
+    abs(uz.z) == 1.0
+  );
+  let uy = cross(uz, ux);
+  return mat3x3<f32>(ux, uy, uz);
+}
+
+// Since WGSL does not support "out" parameters, we return a struct.
+struct RotationResult {
+  needsRotation: bool,
+  transform: mat3x3<f32>,
+};
+
+fn project_needs_rotation(commonPosition: vec3<f32>) -> RotationResult {
+  if (project.projectionMode == PROJECTION_MODE_GLOBE) {
+    return RotationResult(true, project_get_orientation_matrix(commonPosition));
+  } else {
+    return RotationResult(false, mat3x3<f32>());  // identity alternative if needed
+  };
+}
+
+// Projects a normal vector from the current coordinate system to world space.
+fn project_normal(vector: vec3<f32>) -> vec3<f32> {
+  let normal_modelspace = project.modelMatrix * vec4<f32>(vector, 0.0);
+  var n = normalize(normal_modelspace.xyz * project.commonUnitsPerMeter);
+  let rotResult = project_needs_rotation(geometry.position.xyz);
+  if (rotResult.needsRotation) {
+    n = rotResult.transform * n;
+  }
+  return n;
+}
+
+// Applies a scale offset based on y-offset (dy)
+fn project_offset_(offset: vec4<f32>) -> vec4<f32> {
+  let dy: f32 = offset.y;
+  let commonUnitsPerWorldUnit = project.commonUnitsPerWorldUnit + project.commonUnitsPerWorldUnit2 * dy;
+  return vec4<f32>(offset.xyz * commonUnitsPerWorldUnit, offset.w);
+}
+
+// Projects lng/lat coordinates to a unit tile [0,1]
+fn project_mercator_(lnglat: vec2<f32>) -> vec2<f32> {
+  var x = lnglat.x;
+  if (project.wrapLongitude != 0) {
+    x = ((x + 180.0) % 360.0) - 180.0;
+  }
+  let y = clamp(lnglat.y, -89.9, 89.9);
+  return vec2<f32>(
+    radians(x) + PI,
+    PI + log(tan(PI * 0.25 + radians(y) * 0.5))
+  ) * WORLD_SCALE;
+}
+
+// Projects lng/lat/z coordinates for a globe projection.
+fn project_globe_(lnglatz: vec3<f32>) -> vec3<f32> {
+  let lambda = radians(lnglatz.x);
+  let phi = radians(lnglatz.y);
+  let cosPhi = cos(phi);
+  let D = (lnglatz.z / EARTH_RADIUS + 1.0) * GLOBE_RADIUS;
+  return vec3<f32>(
+    sin(lambda) * cosPhi,
+    -cos(lambda) * cosPhi,
+    sin(phi)
+  ) * D;
+}
+
+// Projects positions (with an optional 64-bit low part) from the input
+// coordinate system to the common space.
+fn project_position_vec4_f64(position: vec4<f32>, position64Low: vec3<f32>) -> vec4<f32> {
+  var position_world = project.modelMatrix * position;
+
+  // Work around for a Mac+NVIDIA bug:
+  if (project.projectionMode == PROJECTION_MODE_WEB_MERCATOR) {
+    if (project.coordinateSystem == COORDINATE_SYSTEM_LNGLAT) {
+      return vec4<f32>(
+        project_mercator_(position_world.xy),
+        _project_size_at_latitude_m(position_world.z, position_world.y),
+        position_world.w
+      );
+    }
+    if (project.coordinateSystem == COORDINATE_SYSTEM_CARTESIAN) {
+      position_world = vec4f(position_world.xyz + project.coordinateOrigin, position_world.w);
+    }
+  }
+  if (project.projectionMode == PROJECTION_MODE_GLOBE) {
+    if (project.coordinateSystem == COORDINATE_SYSTEM_LNGLAT) {
+      return vec4<f32>(
+        project_globe_(position_world.xyz),
+        position_world.w
+      );
+    }
+  }
+  if (project.projectionMode == PROJECTION_MODE_WEB_MERCATOR_AUTO_OFFSET) {
+    if (project.coordinateSystem == COORDINATE_SYSTEM_LNGLAT) {
+      if (abs(position_world.y - project.coordinateOrigin.y) > 0.25) {
+        return vec4<f32>(
+          project_mercator_(position_world.xy) - project.commonOrigin.xy,
+          project_size_float(position_world.z),
+          position_world.w
+        );
+      }
+    }
+  }
+  if (project.projectionMode == PROJECTION_MODE_IDENTITY ||
+      (project.projectionMode == PROJECTION_MODE_WEB_MERCATOR_AUTO_OFFSET &&
+       (project.coordinateSystem == COORDINATE_SYSTEM_LNGLAT ||
+        project.coordinateSystem == COORDINATE_SYSTEM_CARTESIAN))) {
+    position_world = vec4f(position_world.xyz - project.coordinateOrigin, position_world.w);
+  }
+
+  return project_offset_(position_world) +
+         project_offset_(project.modelMatrix * vec4<f32>(position64Low, 0.0));
+}
+
+// Overloaded versions for different input types.
+fn project_position_vec4_f32(position: vec4<f32>) -> vec4<f32> {
+  return project_position_vec4_f64(position, ZERO_64_LOW);
+}
+
+fn project_position_vec3_f64(position: vec3<f32>, position64Low: vec3<f32>) -> vec3<f32> {
+  let projected_position = project_position_vec4_f64(vec4<f32>(position, 1.0), position64Low);
+  return projected_position.xyz;
+}
+
+fn project_position_vec3_f32(position: vec3<f32>) -> vec3<f32> {
+  let projected_position = project_position_vec4_f64(vec4<f32>(position, 1.0), ZERO_64_LOW);
+  return projected_position.xyz;
+}
+
+fn project_position_vec2_f32(position: vec2<f32>) -> vec2<f32> {
+  let projected_position = project_position_vec4_f64(vec4<f32>(position, 0.0, 1.0), ZERO_64_LOW);
+  return projected_position.xy;
+}
+
+// Transforms a common space position to clip space.
+fn project_common_position_to_clipspace_with_projection(position: vec4<f32>, viewProjectionMatrix: mat4x4<f32>, center: vec4<f32>) -> vec4<f32> {
+  return viewProjectionMatrix * position + center;
+}
+
+// Uses the project viewProjectionMatrix and center.
+fn project_common_position_to_clipspace(position: vec4<f32>) -> vec4<f32> {
+  return project_common_position_to_clipspace_with_projection(position, project.viewProjectionMatrix, project.center);
+}
+
+// Returns a clip space offset corresponding to a given number of screen pixels.
+fn project_pixel_size_to_clipspace(pixels: vec2<f32>) -> vec2<f32> {
+  let offset = pixels / project.viewportSize * project.devicePixelRatio * 2.0;
+  return offset * project.focalDistance;
+}
+
+fn project_meter_size_to_pixel(meters: f32) -> f32 {
+  return project_size_float(meters) * project.scale;
+}
+
+fn project_unit_size_to_pixel(size: f32, unit: i32) -> f32 {
+  if (unit == UNIT_METERS) {
+    return project_meter_size_to_pixel(size);
+  } else if (unit == UNIT_COMMON) {
+    return size * project.scale;
+  }
+  // UNIT_PIXELS: no scaling applied.
+  return size;
+}
+
+fn project_pixel_size_float(pixels: f32) -> f32 {
+  return pixels / project.scale;
+}
+
+fn project_pixel_size_vec2(pixels: vec2<f32>) -> vec2<f32> {
+  return pixels / project.scale;
+}
+`
+);
+const COORDINATE_SYSTEM_GLSL_CONSTANTS = Object.keys(COORDINATE_SYSTEM).map((key) => `const int COORDINATE_SYSTEM_${key} = ${COORDINATE_SYSTEM[key]};`).join("");
+const PROJECTION_MODE_GLSL_CONSTANTS = Object.keys(PROJECTION_MODE).map((key) => `const int PROJECTION_MODE_${key} = ${PROJECTION_MODE[key]};`).join("");
+const UNIT_GLSL_CONSTANTS = Object.keys(UNIT).map((key) => `const int UNIT_${key.toUpperCase()} = ${UNIT[key]};`).join("");
+const projectGLSL = (
+  /* glsl */
+  `${COORDINATE_SYSTEM_GLSL_CONSTANTS}
+${PROJECTION_MODE_GLSL_CONSTANTS}
+${UNIT_GLSL_CONSTANTS}
+uniform projectUniforms {
+bool wrapLongitude;
+int coordinateSystem;
+vec3 commonUnitsPerMeter;
+int projectionMode;
+float scale;
+vec3 commonUnitsPerWorldUnit;
+vec3 commonUnitsPerWorldUnit2;
+vec4 center;
+mat4 modelMatrix;
+mat4 viewProjectionMatrix;
+vec2 viewportSize;
+float devicePixelRatio;
+float focalDistance;
+vec3 cameraPosition;
+vec3 coordinateOrigin;
+vec3 commonOrigin;
+bool pseudoMeters;
+} project;
+const float TILE_SIZE = 512.0;
+const float PI = 3.1415926536;
+const float WORLD_SCALE = TILE_SIZE / (PI * 2.0);
+const vec3 ZERO_64_LOW = vec3(0.0);
+const float EARTH_RADIUS = 6370972.0;
+const float GLOBE_RADIUS = 256.0;
+float project_size_at_latitude(float lat) {
+float y = clamp(lat, -89.9, 89.9);
+return 1.0 / cos(radians(y));
+}
+float project_size() {
+if (project.projectionMode == PROJECTION_MODE_WEB_MERCATOR &&
+project.coordinateSystem == COORDINATE_SYSTEM_LNGLAT &&
+project.pseudoMeters == false) {
+if (geometry.position.w == 0.0) {
+return project_size_at_latitude(geometry.worldPosition.y);
+}
+float y = geometry.position.y / TILE_SIZE * 2.0 - 1.0;
+float y2 = y * y;
+float y4 = y2 * y2;
+float y6 = y4 * y2;
+return 1.0 + 4.9348 * y2 + 4.0587 * y4 + 1.5642 * y6;
+}
+return 1.0;
+}
+float project_size_at_latitude(float meters, float lat) {
+return meters * project.commonUnitsPerMeter.z * project_size_at_latitude(lat);
+}
+float project_size(float meters) {
+return meters * project.commonUnitsPerMeter.z * project_size();
+}
+vec2 project_size(vec2 meters) {
+return meters * project.commonUnitsPerMeter.xy * project_size();
+}
+vec3 project_size(vec3 meters) {
+return meters * project.commonUnitsPerMeter * project_size();
+}
+vec4 project_size(vec4 meters) {
+return vec4(meters.xyz * project.commonUnitsPerMeter, meters.w);
+}
+mat3 project_get_orientation_matrix(vec3 up) {
+vec3 uz = normalize(up);
+vec3 ux = abs(uz.z) == 1.0 ? vec3(1.0, 0.0, 0.0) : normalize(vec3(uz.y, -uz.x, 0));
+vec3 uy = cross(uz, ux);
+return mat3(ux, uy, uz);
+}
+bool project_needs_rotation(vec3 commonPosition, out mat3 transform) {
+if (project.projectionMode == PROJECTION_MODE_GLOBE) {
+transform = project_get_orientation_matrix(commonPosition);
+return true;
+}
+return false;
+}
+vec3 project_normal(vec3 vector) {
+vec4 normal_modelspace = project.modelMatrix * vec4(vector, 0.0);
+vec3 n = normalize(normal_modelspace.xyz * project.commonUnitsPerMeter);
+mat3 rotation;
+if (project_needs_rotation(geometry.position.xyz, rotation)) {
+n = rotation * n;
+}
+return n;
+}
+vec4 project_offset_(vec4 offset) {
+float dy = offset.y;
+vec3 commonUnitsPerWorldUnit = project.commonUnitsPerWorldUnit + project.commonUnitsPerWorldUnit2 * dy;
+return vec4(offset.xyz * commonUnitsPerWorldUnit, offset.w);
+}
+vec2 project_mercator_(vec2 lnglat) {
+float x = lnglat.x;
+if (project.wrapLongitude) {
+x = mod(x + 180., 360.0) - 180.;
+}
+float y = clamp(lnglat.y, -89.9, 89.9);
+return vec2(
+radians(x) + PI,
+PI + log(tan_fp32(PI * 0.25 + radians(y) * 0.5))
+) * WORLD_SCALE;
+}
+vec3 project_globe_(vec3 lnglatz) {
+float lambda = radians(lnglatz.x);
+float phi = radians(lnglatz.y);
+float cosPhi = cos(phi);
+float D = (lnglatz.z / EARTH_RADIUS + 1.0) * GLOBE_RADIUS;
+return vec3(
+sin(lambda) * cosPhi,
+-cos(lambda) * cosPhi,
+sin(phi)
+) * D;
+}
+vec4 project_position(vec4 position, vec3 position64Low) {
+vec4 position_world = project.modelMatrix * position;
+if (project.projectionMode == PROJECTION_MODE_WEB_MERCATOR) {
+if (project.coordinateSystem == COORDINATE_SYSTEM_LNGLAT) {
+return vec4(
+project_mercator_(position_world.xy),
+project_size_at_latitude(position_world.z, position_world.y),
+position_world.w
+);
+}
+if (project.coordinateSystem == COORDINATE_SYSTEM_CARTESIAN) {
+position_world.xyz += project.coordinateOrigin;
+}
+}
+if (project.projectionMode == PROJECTION_MODE_GLOBE) {
+if (project.coordinateSystem == COORDINATE_SYSTEM_LNGLAT) {
+return vec4(
+project_globe_(position_world.xyz),
+position_world.w
+);
+}
+}
+if (project.projectionMode == PROJECTION_MODE_WEB_MERCATOR_AUTO_OFFSET) {
+if (project.coordinateSystem == COORDINATE_SYSTEM_LNGLAT) {
+if (abs(position_world.y - project.coordinateOrigin.y) > 0.25) {
+return vec4(
+project_mercator_(position_world.xy) - project.commonOrigin.xy,
+project_size(position_world.z),
+position_world.w
+);
+}
+}
+}
+if (project.projectionMode == PROJECTION_MODE_IDENTITY ||
+(project.projectionMode == PROJECTION_MODE_WEB_MERCATOR_AUTO_OFFSET &&
+(project.coordinateSystem == COORDINATE_SYSTEM_LNGLAT ||
+project.coordinateSystem == COORDINATE_SYSTEM_CARTESIAN))) {
+position_world.xyz -= project.coordinateOrigin;
+}
+return project_offset_(position_world) + project_offset_(project.modelMatrix * vec4(position64Low, 0.0));
+}
+vec4 project_position(vec4 position) {
+return project_position(position, ZERO_64_LOW);
+}
+vec3 project_position(vec3 position, vec3 position64Low) {
+vec4 projected_position = project_position(vec4(position, 1.0), position64Low);
+return projected_position.xyz;
+}
+vec3 project_position(vec3 position) {
+vec4 projected_position = project_position(vec4(position, 1.0), ZERO_64_LOW);
+return projected_position.xyz;
+}
+vec2 project_position(vec2 position) {
+vec4 projected_position = project_position(vec4(position, 0.0, 1.0), ZERO_64_LOW);
+return projected_position.xy;
+}
+vec4 project_common_position_to_clipspace(vec4 position, mat4 viewProjectionMatrix, vec4 center) {
+return viewProjectionMatrix * position + center;
+}
+vec4 project_common_position_to_clipspace(vec4 position) {
+return project_common_position_to_clipspace(position, project.viewProjectionMatrix, project.center);
+}
+vec2 project_pixel_size_to_clipspace(vec2 pixels) {
+vec2 offset = pixels / project.viewportSize * project.devicePixelRatio * 2.0;
+return offset * project.focalDistance;
+}
+float project_size_to_pixel(float meters) {
+return project_size(meters) * project.scale;
+}
+float project_size_to_pixel(float size, int unit) {
+if (unit == UNIT_METERS) return project_size_to_pixel(size);
+if (unit == UNIT_COMMON) return size * project.scale;
+return size;
+}
+float project_pixel_size(float pixels) {
+return pixels / project.scale;
+}
+vec2 project_pixel_size(vec2 pixels) {
+return pixels / project.scale;
+}
+`
+);
+const INITIAL_MODULE_OPTIONS = {};
+function getUniforms(opts = INITIAL_MODULE_OPTIONS) {
+  if ("viewport" in opts) {
+    return getUniformsFromViewport(opts);
+  }
+  return {};
+}
+const project = {
+  name: "project",
+  dependencies: [fp32, geometry],
+  source: projectWGSL,
+  vs: projectGLSL,
+  getUniforms,
+  uniformTypes: {
+    wrapLongitude: "f32",
+    coordinateSystem: "i32",
+    commonUnitsPerMeter: "vec3<f32>",
+    projectionMode: "i32",
+    scale: "f32",
+    commonUnitsPerWorldUnit: "vec3<f32>",
+    commonUnitsPerWorldUnit2: "vec3<f32>",
+    center: "vec4<f32>",
+    modelMatrix: "mat4x4<f32>",
+    viewProjectionMatrix: "mat4x4<f32>",
+    viewportSize: "vec2<f32>",
+    devicePixelRatio: "f32",
+    focalDistance: "f32",
+    cameraPosition: "vec3<f32>",
+    coordinateOrigin: "vec3<f32>",
+    commonOrigin: "vec3<f32>",
+    pseudoMeters: "f32"
+  }
+  // @ts-ignore TODO v9.1
+};
+const source$1 = (
+  /* wgsl */
+  `// Define a structure to hold both the clip-space position and the common position.
+struct ProjectResult {
+  clipPosition: vec4<f32>,
+  commonPosition: vec4<f32>,
+};
+
+// This function mimics the GLSL version with the 'out' parameter by returning both values.
+fn project_position_to_clipspace_and_commonspace(
+    position: vec3<f32>,
+    position64Low: vec3<f32>,
+    offset: vec3<f32>
+) -> ProjectResult {
+  // Compute the projected position.
+  let projectedPosition: vec3<f32> = project_position_vec3_f64(position, position64Low);
+
+  // Start with the provided offset.
+  var finalOffset: vec3<f32> = offset;
+
+  // Get whether a rotation is needed and the rotation matrix.
+  let rotationResult = project_needs_rotation(projectedPosition);
+
+  // If rotation is needed, update the offset.
+  if (rotationResult.needsRotation) {
+    finalOffset = rotationResult.transform * offset;
+  }
+
+  // Compute the common position.
+  let commonPosition: vec4<f32> = vec4<f32>(projectedPosition + finalOffset, 1.0);
+
+  // Convert to clip-space.
+  let clipPosition: vec4<f32> = project_common_position_to_clipspace(commonPosition);
+
+  return ProjectResult(clipPosition, commonPosition);
+}
+
+// A convenience overload that returns only the clip-space position.
+fn project_position_to_clipspace(
+    position: vec3<f32>,
+    position64Low: vec3<f32>,
+    offset: vec3<f32>
+) -> vec4<f32> {
+  return project_position_to_clipspace_and_commonspace(position, position64Low, offset).clipPosition;
+}
+`
+);
+const vs$4 = (
+  /* glsl */
+  `vec4 project_position_to_clipspace(
+  vec3 position, vec3 position64Low, vec3 offset, out vec4 commonPosition
+) {
+  vec3 projectedPosition = project_position(position, position64Low);
+  mat3 rotation;
+  if (project_needs_rotation(projectedPosition, rotation)) {
+    // offset is specified as ENU
+    // when in globe projection, rotate offset so that the ground alighs with the surface of the globe
+    offset = rotation * offset;
+  }
+  commonPosition = vec4(projectedPosition + offset, 1.0);
+  return project_common_position_to_clipspace(commonPosition);
+}
+
+vec4 project_position_to_clipspace(
+  vec3 position, vec3 position64Low, vec3 offset
+) {
+  vec4 commonPosition;
+  return project_position_to_clipspace(position, position64Low, offset, commonPosition);
+}
+`
+);
+const project32 = {
+  name: "project32",
+  dependencies: [project],
+  source: source$1,
+  vs: vs$4
+};
+function createMat4$1() {
+  return [1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1];
+}
+function transformVector$1(matrix, vector) {
+  const result = transformMat4([], vector, matrix);
+  scale(result, result, 1 / result[3]);
+  return result;
+}
+function mod$1(value, divisor) {
+  const modulus = value % divisor;
+  return modulus < 0 ? divisor + modulus : modulus;
+}
+function clamp(x2, min, max) {
+  return x2 < min ? min : x2 > max ? max : x2;
+}
+function ieLog2(x2) {
+  return Math.log(x2) * Math.LOG2E;
+}
+const log2 = Math.log2 || ieLog2;
+function assert$1(condition, message2) {
+  if (!condition) {
+    throw new Error(message2 || "@math.gl/web-mercator: assertion failed.");
+  }
+}
+const PI = Math.PI;
+const PI_4 = PI / 4;
+const DEGREES_TO_RADIANS$4 = PI / 180;
+const RADIANS_TO_DEGREES$1 = 180 / PI;
+const TILE_SIZE$2 = 512;
+const EARTH_CIRCUMFERENCE = 4003e4;
+const MAX_LATITUDE = 85.051129;
+const DEFAULT_ALTITUDE = 1.5;
+function scaleToZoom(scale2) {
+  return log2(scale2);
+}
+function lngLatToWorld(lngLat) {
+  const [lng, lat] = lngLat;
+  assert$1(Number.isFinite(lng));
+  assert$1(Number.isFinite(lat) && lat >= -90 && lat <= 90, "invalid latitude");
+  const lambda2 = lng * DEGREES_TO_RADIANS$4;
+  const phi2 = lat * DEGREES_TO_RADIANS$4;
+  const x2 = TILE_SIZE$2 * (lambda2 + PI) / (2 * PI);
+  const y2 = TILE_SIZE$2 * (PI + Math.log(Math.tan(PI_4 + phi2 * 0.5))) / (2 * PI);
+  return [x2, y2];
+}
+function worldToLngLat(xy) {
+  const [x2, y2] = xy;
+  const lambda2 = x2 / TILE_SIZE$2 * (2 * PI) - PI;
+  const phi2 = 2 * (Math.atan(Math.exp(y2 / TILE_SIZE$2 * (2 * PI) - PI)) - PI_4);
+  return [lambda2 * RADIANS_TO_DEGREES$1, phi2 * RADIANS_TO_DEGREES$1];
+}
+function getMeterZoom(options) {
+  const { latitude } = options;
+  assert$1(Number.isFinite(latitude));
+  const latCosine = Math.cos(latitude * DEGREES_TO_RADIANS$4);
+  return scaleToZoom(EARTH_CIRCUMFERENCE * latCosine) - 9;
+}
+function unitsPerMeter(latitude) {
+  const latCosine = Math.cos(latitude * DEGREES_TO_RADIANS$4);
+  return TILE_SIZE$2 / EARTH_CIRCUMFERENCE / latCosine;
+}
+function getDistanceScales$1(options) {
+  const { latitude, longitude, highPrecision = false } = options;
+  assert$1(Number.isFinite(latitude) && Number.isFinite(longitude));
+  const worldSize = TILE_SIZE$2;
+  const latCosine = Math.cos(latitude * DEGREES_TO_RADIANS$4);
+  const unitsPerDegreeX = worldSize / 360;
+  const unitsPerDegreeY = unitsPerDegreeX / latCosine;
+  const altUnitsPerMeter = worldSize / EARTH_CIRCUMFERENCE / latCosine;
+  const result = {
+    unitsPerMeter: [altUnitsPerMeter, altUnitsPerMeter, altUnitsPerMeter],
+    metersPerUnit: [1 / altUnitsPerMeter, 1 / altUnitsPerMeter, 1 / altUnitsPerMeter],
+    unitsPerDegree: [unitsPerDegreeX, unitsPerDegreeY, altUnitsPerMeter],
+    degreesPerUnit: [1 / unitsPerDegreeX, 1 / unitsPerDegreeY, 1 / altUnitsPerMeter]
+  };
+  if (highPrecision) {
+    const latCosine2 = DEGREES_TO_RADIANS$4 * Math.tan(latitude * DEGREES_TO_RADIANS$4) / latCosine;
+    const unitsPerDegreeY2 = unitsPerDegreeX * latCosine2 / 2;
+    const altUnitsPerDegree2 = worldSize / EARTH_CIRCUMFERENCE * latCosine2;
+    const altUnitsPerMeter2 = altUnitsPerDegree2 / unitsPerDegreeY * altUnitsPerMeter;
+    result.unitsPerDegree2 = [0, unitsPerDegreeY2, altUnitsPerDegree2];
+    result.unitsPerMeter2 = [altUnitsPerMeter2, 0, altUnitsPerMeter2];
+  }
+  return result;
+}
+function addMetersToLngLat(lngLatZ, xyz) {
+  const [longitude, latitude, z0] = lngLatZ;
+  const [x2, y2, z2] = xyz;
+  const { unitsPerMeter: unitsPerMeter2, unitsPerMeter2: unitsPerMeter22 } = getDistanceScales$1({
+    longitude,
+    latitude,
+    highPrecision: true
+  });
+  const worldspace = lngLatToWorld(lngLatZ);
+  worldspace[0] += x2 * (unitsPerMeter2[0] + unitsPerMeter22[0] * y2);
+  worldspace[1] += y2 * (unitsPerMeter2[1] + unitsPerMeter22[1] * y2);
+  const newLngLat = worldToLngLat(worldspace);
+  const newZ = (z0 || 0) + (z2 || 0);
+  return Number.isFinite(z0) || Number.isFinite(z2) ? [newLngLat[0], newLngLat[1], newZ] : newLngLat;
+}
+function getViewMatrix(options) {
+  const {
+    // Viewport props
+    height,
+    pitch,
+    bearing,
+    altitude,
+    // Pre-calculated parameters
+    scale: scale2,
+    center
+  } = options;
+  const vm = createMat4$1();
+  translate(vm, vm, [0, 0, -altitude]);
+  rotateX(vm, vm, -pitch * DEGREES_TO_RADIANS$4);
+  rotateZ(vm, vm, bearing * DEGREES_TO_RADIANS$4);
+  const relativeScale = scale2 / height;
+  scale$1(vm, vm, [relativeScale, relativeScale, relativeScale]);
+  if (center) {
+    translate(vm, vm, negate([], center));
+  }
+  return vm;
+}
+function getProjectionParameters(options) {
+  const { width, height, altitude, pitch = 0, offset, center, scale: scale2, nearZMultiplier = 1, farZMultiplier = 1 } = options;
+  let { fovy = altitudeToFovy(DEFAULT_ALTITUDE) } = options;
+  if (altitude !== void 0) {
+    fovy = altitudeToFovy(altitude);
+  }
+  const fovRadians = fovy * DEGREES_TO_RADIANS$4;
+  const pitchRadians = pitch * DEGREES_TO_RADIANS$4;
+  const focalDistance = fovyToAltitude(fovy);
+  let cameraToSeaLevelDistance = focalDistance;
+  if (center) {
+    cameraToSeaLevelDistance += center[2] * scale2 / Math.cos(pitchRadians) / height;
+  }
+  const fovAboveCenter = fovRadians * (0.5 + (offset ? offset[1] : 0) / height);
+  const topHalfSurfaceDistance = Math.sin(fovAboveCenter) * cameraToSeaLevelDistance / Math.sin(clamp(Math.PI / 2 - pitchRadians - fovAboveCenter, 0.01, Math.PI - 0.01));
+  const furthestDistance = Math.sin(pitchRadians) * topHalfSurfaceDistance + cameraToSeaLevelDistance;
+  const horizonDistance = cameraToSeaLevelDistance * 10;
+  const farZ = Math.min(furthestDistance * farZMultiplier, horizonDistance);
+  return {
+    fov: fovRadians,
+    aspect: width / height,
+    focalDistance,
+    near: nearZMultiplier,
+    far: farZ
+  };
+}
+function altitudeToFovy(altitude) {
+  return 2 * Math.atan(0.5 / altitude) * RADIANS_TO_DEGREES$1;
+}
+function fovyToAltitude(fovy) {
+  return 0.5 / Math.tan(0.5 * fovy * DEGREES_TO_RADIANS$4);
+}
+function worldToPixels(xyz, pixelProjectionMatrix) {
+  const [x2, y2, z2 = 0] = xyz;
+  assert$1(Number.isFinite(x2) && Number.isFinite(y2) && Number.isFinite(z2));
+  return transformVector$1(pixelProjectionMatrix, [x2, y2, z2, 1]);
+}
+function pixelsToWorld(xyz, pixelUnprojectionMatrix, targetZ = 0) {
+  const [x2, y2, z2] = xyz;
+  assert$1(Number.isFinite(x2) && Number.isFinite(y2), "invalid pixel coordinate");
+  if (Number.isFinite(z2)) {
+    const coord = transformVector$1(pixelUnprojectionMatrix, [x2, y2, z2, 1]);
+    return coord;
+  }
+  const coord0 = transformVector$1(pixelUnprojectionMatrix, [x2, y2, 0, 1]);
+  const coord1 = transformVector$1(pixelUnprojectionMatrix, [x2, y2, 1, 1]);
+  const z0 = coord0[2];
+  const z1 = coord1[2];
+  const t2 = z0 === z1 ? 0 : ((targetZ || 0) - z0) / (z1 - z0);
+  return lerp$1([], coord0, coord1, t2);
+}
+function fitBounds(options) {
+  const {
+    width,
+    height,
+    bounds,
+    minExtent = 0,
+    // 0.01 would be about 1000 meters (degree is ~110KM)
+    maxZoom = 24,
+    // ~x4,000,000 => About 10 meter extents
+    offset = [0, 0]
+  } = options;
+  const [[west, south], [east, north]] = bounds;
+  const padding = getPaddingObject(options.padding);
+  const nw = lngLatToWorld([west, clamp(north, -85.051129, MAX_LATITUDE)]);
+  const se2 = lngLatToWorld([east, clamp(south, -85.051129, MAX_LATITUDE)]);
+  const size = [
+    Math.max(Math.abs(se2[0] - nw[0]), minExtent),
+    Math.max(Math.abs(se2[1] - nw[1]), minExtent)
+  ];
+  const targetSize = [
+    width - padding.left - padding.right - Math.abs(offset[0]) * 2,
+    height - padding.top - padding.bottom - Math.abs(offset[1]) * 2
+  ];
+  assert$1(targetSize[0] > 0 && targetSize[1] > 0);
+  const scaleX2 = targetSize[0] / size[0];
+  const scaleY2 = targetSize[1] / size[1];
+  const offsetX = (padding.right - padding.left) / 2 / scaleX2;
+  const offsetY = (padding.top - padding.bottom) / 2 / scaleY2;
+  const center = [(se2[0] + nw[0]) / 2 + offsetX, (se2[1] + nw[1]) / 2 + offsetY];
+  const centerLngLat = worldToLngLat(center);
+  const zoom = Math.min(maxZoom, log2(Math.abs(Math.min(scaleX2, scaleY2))));
+  assert$1(Number.isFinite(zoom));
+  return {
+    longitude: centerLngLat[0],
+    latitude: centerLngLat[1],
+    zoom
+  };
+}
+function getPaddingObject(padding = 0) {
+  if (typeof padding === "number") {
+    return {
+      top: padding,
+      bottom: padding,
+      left: padding,
+      right: padding
+    };
+  }
+  assert$1(Number.isFinite(padding.top) && Number.isFinite(padding.bottom) && Number.isFinite(padding.left) && Number.isFinite(padding.right));
+  return padding;
+}
+const DEGREES_TO_RADIANS$3 = Math.PI / 180;
+function getBounds(viewport, z2 = 0) {
+  const { width, height, unproject } = viewport;
+  const unprojectOps = { targetZ: z2 };
+  const bottomLeft = unproject([0, height], unprojectOps);
+  const bottomRight = unproject([width, height], unprojectOps);
+  let topLeft;
+  let topRight;
+  const halfFov = viewport.fovy ? 0.5 * viewport.fovy * DEGREES_TO_RADIANS$3 : Math.atan(0.5 / viewport.altitude);
+  const angleToGround = (90 - viewport.pitch) * DEGREES_TO_RADIANS$3;
+  if (halfFov > angleToGround - 0.01) {
+    topLeft = unprojectOnFarPlane(viewport, 0, z2);
+    topRight = unprojectOnFarPlane(viewport, width, z2);
+  } else {
+    topLeft = unproject([0, 0], unprojectOps);
+    topRight = unproject([width, 0], unprojectOps);
+  }
+  return [bottomLeft, bottomRight, topRight, topLeft];
+}
+function unprojectOnFarPlane(viewport, x2, targetZ) {
+  const { pixelUnprojectionMatrix } = viewport;
+  const coord0 = transformVector$1(pixelUnprojectionMatrix, [x2, 0, 1, 1]);
+  const coord1 = transformVector$1(pixelUnprojectionMatrix, [x2, viewport.height, 1, 1]);
+  const z2 = targetZ * viewport.distanceScales.unitsPerMeter[2];
+  const t2 = (z2 - coord0[2]) / (coord1[2] - coord0[2]);
+  const coord = lerp$1([], coord0, coord1, t2);
+  const result = worldToLngLat(coord);
+  result.push(targetZ);
+  return result;
+}
+const TILE_SIZE$1 = 512;
+function normalizeViewportProps(props) {
+  const { width, height, pitch = 0 } = props;
+  let { longitude, latitude, zoom, bearing = 0 } = props;
+  if (longitude < -180 || longitude > 180) {
+    longitude = mod$1(longitude + 180, 360) - 180;
+  }
+  if (bearing < -180 || bearing > 180) {
+    bearing = mod$1(bearing + 180, 360) - 180;
+  }
+  const minZoom = log2(height / TILE_SIZE$1);
+  if (zoom <= minZoom) {
+    zoom = minZoom;
+    latitude = 0;
+  } else {
+    const halfHeightPixels = height / 2 / Math.pow(2, zoom);
+    const minLatitude = worldToLngLat([0, halfHeightPixels])[1];
+    if (latitude < minLatitude) {
+      latitude = minLatitude;
+    } else {
+      const maxLatitude = worldToLngLat([0, TILE_SIZE$1 - halfHeightPixels])[1];
+      if (latitude > maxLatitude) {
+        latitude = maxLatitude;
+      }
+    }
+  }
+  return { width, height, longitude, latitude, zoom, pitch, bearing };
+}
+const uniformBlock$2 = (
+  /* glsl */
+  `
+uniform shadowUniforms {
+  bool drawShadowMap;
+  bool useShadowMap;
+  vec4 color;
+  highp int lightId;
+  float lightCount;
+  mat4 viewProjectionMatrix0;
+  mat4 viewProjectionMatrix1;
+  vec4 projectCenter0;
+  vec4 projectCenter1;
+} shadow;
+`
+);
+const vertex = (
+  /* glsl */
+  `
+const int max_lights = 2;
+
+out vec3 shadow_vPosition[max_lights];
+
+vec4 shadow_setVertexPosition(vec4 position_commonspace) {
+  mat4 viewProjectionMatrices[max_lights];
+  viewProjectionMatrices[0] = shadow.viewProjectionMatrix0;
+  viewProjectionMatrices[1] = shadow.viewProjectionMatrix1;
+  vec4 projectCenters[max_lights];
+  projectCenters[0] = shadow.projectCenter0;
+  projectCenters[1] = shadow.projectCenter1;
+
+  if (shadow.drawShadowMap) {
+    return project_common_position_to_clipspace(position_commonspace, viewProjectionMatrices[shadow.lightId], projectCenters[shadow.lightId]);
+  }
+  if (shadow.useShadowMap) {
+    for (int i = 0; i < max_lights; i++) {
+      if(i < int(shadow.lightCount)) {
+        vec4 shadowMap_position = project_common_position_to_clipspace(position_commonspace, viewProjectionMatrices[i], projectCenters[i]);
+        shadow_vPosition[i] = (shadowMap_position.xyz / shadowMap_position.w + 1.0) / 2.0;
+      }
+    }
+  }
+  return gl_Position;
+}
+`
+);
+const vs$3 = `
+${uniformBlock$2}
+${vertex}
+`;
+const fragment = (
+  /* glsl */
+  `
+const int max_lights = 2;
+uniform sampler2D shadow_uShadowMap0;
+uniform sampler2D shadow_uShadowMap1;
+
+in vec3 shadow_vPosition[max_lights];
+
+const vec4 bitPackShift = vec4(1.0, 255.0, 65025.0, 16581375.0);
+const vec4 bitUnpackShift = 1.0 / bitPackShift;
+const vec4 bitMask = vec4(1.0 / 255.0, 1.0 / 255.0, 1.0 / 255.0,  0.0);
+
+float shadow_getShadowWeight(vec3 position, sampler2D shadowMap) {
+  vec4 rgbaDepth = texture(shadowMap, position.xy);
+
+  float z = dot(rgbaDepth, bitUnpackShift);
+  return smoothstep(0.001, 0.01, position.z - z);
+}
+
+vec4 shadow_filterShadowColor(vec4 color) {
+  if (shadow.drawShadowMap) {
+    vec4 rgbaDepth = fract(gl_FragCoord.z * bitPackShift);
+    rgbaDepth -= rgbaDepth.gbaa * bitMask;
+    return rgbaDepth;
+  }
+  if (shadow.useShadowMap) {
+    float shadowAlpha = 0.0;
+    shadowAlpha += shadow_getShadowWeight(shadow_vPosition[0], shadow_uShadowMap0);
+    if(shadow.lightCount > 1.0) {
+      shadowAlpha += shadow_getShadowWeight(shadow_vPosition[1], shadow_uShadowMap1);
+    }
+    shadowAlpha *= shadow.color.a / shadow.lightCount;
+    float blendedAlpha = shadowAlpha + color.a * (1.0 - shadowAlpha);
+
+    return vec4(
+      mix(color.rgb, shadow.color.rgb, shadowAlpha / blendedAlpha),
+      blendedAlpha
+    );
+  }
+  return color;
+}
+`
+);
+const fs$2 = `
+${uniformBlock$2}
+${fragment}
+`;
+const getMemoizedViewportCenterPosition = memoize(getViewportCenterPosition);
+const getMemoizedViewProjectionMatrices = memoize(getViewProjectionMatrices);
+const DEFAULT_SHADOW_COLOR$1 = [0, 0, 0, 1];
+const VECTOR_TO_POINT_MATRIX = [1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0];
+function screenToCommonSpace(xyz, pixelUnprojectionMatrix) {
+  const [x2, y2, z2] = xyz;
+  const coord = pixelsToWorld([x2, y2, z2], pixelUnprojectionMatrix);
+  if (Number.isFinite(z2)) {
+    return coord;
+  }
+  return [coord[0], coord[1], 0];
+}
+function getViewportCenterPosition({ viewport, center }) {
+  return new Matrix4(viewport.viewProjectionMatrix).invert().transform(center);
+}
+function getViewProjectionMatrices({ viewport, shadowMatrices }) {
+  const projectionMatrices = [];
+  const pixelUnprojectionMatrix = viewport.pixelUnprojectionMatrix;
+  const farZ = viewport.isGeospatial ? void 0 : 1;
+  const corners = [
+    [0, 0, farZ],
+    // top left ground
+    [viewport.width, 0, farZ],
+    // top right ground
+    [0, viewport.height, farZ],
+    // bottom left ground
+    [viewport.width, viewport.height, farZ],
+    // bottom right ground
+    [0, 0, -1],
+    // top left near
+    [viewport.width, 0, -1],
+    // top right near
+    [0, viewport.height, -1],
+    // bottom left near
+    [viewport.width, viewport.height, -1]
+    // bottom right near
+  ].map((pixel) => (
+    // @ts-expect-error z may be undefined
+    screenToCommonSpace(pixel, pixelUnprojectionMatrix)
+  ));
+  for (const shadowMatrix of shadowMatrices) {
+    const viewMatrix = shadowMatrix.clone().translate(new Vector3(viewport.center).negate());
+    const positions = corners.map((corner) => viewMatrix.transform(corner));
+    const projectionMatrix = new Matrix4().ortho({
+      left: Math.min(...positions.map((position) => position[0])),
+      right: Math.max(...positions.map((position) => position[0])),
+      bottom: Math.min(...positions.map((position) => position[1])),
+      top: Math.max(...positions.map((position) => position[1])),
+      near: Math.min(...positions.map((position) => -position[2])),
+      far: Math.max(...positions.map((position) => -position[2]))
+    });
+    projectionMatrices.push(projectionMatrix.multiplyRight(shadowMatrix));
+  }
+  return projectionMatrices;
+}
+function createShadowUniforms(opts) {
+  const { shadowEnabled = true, project: projectProps } = opts;
+  if (!shadowEnabled || !projectProps || !opts.shadowMatrices || !opts.shadowMatrices.length) {
+    return {
+      drawShadowMap: false,
+      useShadowMap: false,
+      shadow_uShadowMap0: opts.dummyShadowMap,
+      shadow_uShadowMap1: opts.dummyShadowMap
+    };
+  }
+  const projectUniforms = project.getUniforms(projectProps);
+  const center = getMemoizedViewportCenterPosition({
+    viewport: projectProps.viewport,
+    center: projectUniforms.center
+  });
+  const projectCenters = [];
+  const viewProjectionMatrices = getMemoizedViewProjectionMatrices({
+    shadowMatrices: opts.shadowMatrices,
+    viewport: projectProps.viewport
+  }).slice();
+  for (let i2 = 0; i2 < opts.shadowMatrices.length; i2++) {
+    const viewProjectionMatrix = viewProjectionMatrices[i2];
+    const viewProjectionMatrixCentered = viewProjectionMatrix.clone().translate(new Vector3(projectProps.viewport.center).negate());
+    if (projectUniforms.coordinateSystem === COORDINATE_SYSTEM.LNGLAT && projectUniforms.projectionMode === PROJECTION_MODE.WEB_MERCATOR) {
+      viewProjectionMatrices[i2] = viewProjectionMatrixCentered;
+      projectCenters[i2] = center;
+    } else {
+      viewProjectionMatrices[i2] = viewProjectionMatrix.clone().multiplyRight(VECTOR_TO_POINT_MATRIX);
+      projectCenters[i2] = viewProjectionMatrixCentered.transform(center);
+    }
+  }
+  const uniforms = {
+    drawShadowMap: Boolean(opts.drawToShadowMap),
+    useShadowMap: opts.shadowMaps ? opts.shadowMaps.length > 0 : false,
+    color: opts.shadowColor || DEFAULT_SHADOW_COLOR$1,
+    lightId: opts.shadowLightId || 0,
+    lightCount: opts.shadowMatrices.length,
+    shadow_uShadowMap0: opts.dummyShadowMap,
+    shadow_uShadowMap1: opts.dummyShadowMap
+  };
+  for (let i2 = 0; i2 < viewProjectionMatrices.length; i2++) {
+    uniforms[`viewProjectionMatrix${i2}`] = viewProjectionMatrices[i2];
+    uniforms[`projectCenter${i2}`] = projectCenters[i2];
+  }
+  for (let i2 = 0; i2 < 2; i2++) {
+    uniforms[`shadow_uShadowMap${i2}`] = opts.shadowMaps && opts.shadowMaps[i2] || opts.dummyShadowMap;
+  }
+  return uniforms;
+}
+const shadow = {
+  name: "shadow",
+  dependencies: [project],
+  vs: vs$3,
+  fs: fs$2,
+  inject: {
+    "vs:DECKGL_FILTER_GL_POSITION": `
+    position = shadow_setVertexPosition(geometry.position);
+    `,
+    "fs:DECKGL_FILTER_COLOR": `
+    color = shadow_filterShadowColor(color);
+    `
+  },
+  getUniforms: createShadowUniforms,
+  uniformTypes: {
+    drawShadowMap: "f32",
+    useShadowMap: "f32",
+    color: "vec4<f32>",
+    lightId: "i32",
+    lightCount: "f32",
+    viewProjectionMatrix0: "mat4x4<f32>",
+    viewProjectionMatrix1: "mat4x4<f32>",
+    projectCenter0: "vec4<f32>",
+    projectCenter1: "vec4<f32>"
+  }
+};
+const picking = {
+  ...picking$1,
+  defaultUniforms: { ...picking$1.defaultUniforms, useFloatColors: false },
+  inject: {
+    "vs:DECKGL_FILTER_GL_POSITION": `
+    // for picking depth values
+    picking_setPickingAttribute(position.z / position.w);
+  `,
+    "vs:DECKGL_FILTER_COLOR": `
+  picking_setPickingColor(geometry.pickingColor);
+  `,
+    "fs:DECKGL_FILTER_COLOR": {
+      order: 99,
+      injection: `
+  // use highlight color if this fragment belongs to the selected object.
+  color = picking_filterHighlightColor(color);
+
+  // use picking color if rendering to picking FBO.
+  color = picking_filterPickingColor(color);
+    `
+    }
+  }
+};
+const DEFAULT_MODULES = [geometry];
+const SHADER_HOOKS_GLSL = [
+  "vs:DECKGL_FILTER_SIZE(inout vec3 size, VertexGeometry geometry)",
+  "vs:DECKGL_FILTER_GL_POSITION(inout vec4 position, VertexGeometry geometry)",
+  "vs:DECKGL_FILTER_COLOR(inout vec4 color, VertexGeometry geometry)",
+  "fs:DECKGL_FILTER_COLOR(inout vec4 color, FragmentGeometry geometry)"
+];
+const SHADER_HOOKS_WGSL = [
+  // Not yet supported
+];
+function getShaderAssembler(language) {
+  const shaderAssembler = ShaderAssembler.getDefaultShaderAssembler();
+  for (const shaderModule of DEFAULT_MODULES) {
+    shaderAssembler.addDefaultModule(shaderModule);
+  }
+  shaderAssembler._hookFunctions.length = 0;
+  const shaderHooks = language === "glsl" ? SHADER_HOOKS_GLSL : SHADER_HOOKS_WGSL;
+  for (const shaderHook of shaderHooks) {
+    shaderAssembler.addShaderHook(shaderHook);
+  }
+  return shaderAssembler;
+}
+const DEFAULT_LIGHT_COLOR$1 = [255, 255, 255];
+const DEFAULT_LIGHT_INTENSITY$1 = 1;
+let idCount$1 = 0;
+class AmbientLight {
+  constructor(props = {}) {
+    this.type = "ambient";
+    const { color: color2 = DEFAULT_LIGHT_COLOR$1 } = props;
+    const { intensity = DEFAULT_LIGHT_INTENSITY$1 } = props;
+    this.id = props.id || `ambient-${idCount$1++}`;
+    this.color = color2;
+    this.intensity = intensity;
+  }
+}
+const DEFAULT_LIGHT_COLOR = [255, 255, 255];
+const DEFAULT_LIGHT_INTENSITY = 1;
+const DEFAULT_LIGHT_DIRECTION = [0, 0, -1];
+let idCount = 0;
+class DirectionalLight {
+  constructor(props = {}) {
+    this.type = "directional";
+    const { color: color2 = DEFAULT_LIGHT_COLOR } = props;
+    const { intensity = DEFAULT_LIGHT_INTENSITY } = props;
+    const { direction = DEFAULT_LIGHT_DIRECTION } = props;
+    const { _shadow = false } = props;
+    this.id = props.id || `directional-${idCount++}`;
+    this.color = color2;
+    this.intensity = intensity;
+    this.type = "directional";
+    this.direction = new Vector3(direction).normalize().toArray();
+    this.shadow = _shadow;
+  }
+  getProjectedLight(opts) {
+    return this;
+  }
+}
+class Pass {
+  /** Create a new Pass instance */
+  constructor(device, props = { id: "pass" }) {
+    const { id: id2 } = props;
+    this.id = id2;
+    this.device = device;
+    this.props = { ...props };
+  }
+  setProps(props) {
+    Object.assign(this.props, props);
+  }
+  render(params) {
+  }
+  // eslint-disable-line @typescript-eslint/no-empty-function
+  cleanup() {
+  }
+  // eslint-disable-line @typescript-eslint/no-empty-function
+}
+class LayersPass extends Pass {
+  constructor() {
+    super(...arguments);
+    this._lastRenderIndex = -1;
+  }
+  render(options) {
+    const [width, height] = this.device.canvasContext.getDrawingBufferSize();
+    const clearCanvas = options.clearCanvas ?? true;
+    const clearColor = options.clearColor ?? (clearCanvas ? [0, 0, 0, 0] : false);
+    const clearDepth = clearCanvas ? 1 : false;
+    const clearStencil = clearCanvas ? 0 : false;
+    const colorMask = options.colorMask ?? 15;
+    const parameters = { viewport: [0, 0, width, height] };
+    if (options.colorMask) {
+      parameters.colorMask = colorMask;
+    }
+    if (options.scissorRect) {
+      parameters.scissorRect = options.scissorRect;
+    }
+    const renderPass = this.device.beginRenderPass({
+      framebuffer: options.target,
+      parameters,
+      clearColor,
+      clearDepth,
+      clearStencil
+    });
+    try {
+      return this._drawLayers(renderPass, options);
+    } finally {
+      renderPass.end();
+      this.device.submit();
+    }
+  }
+  /** Draw a list of layers in a list of viewports */
+  _drawLayers(renderPass, options) {
+    const { target, shaderModuleProps, viewports, views, onViewportActive, clearStack = true } = options;
+    options.pass = options.pass || "unknown";
+    if (clearStack) {
+      this._lastRenderIndex = -1;
+    }
+    const renderStats = [];
+    for (const viewport of viewports) {
+      const view = views && views[viewport.id];
+      onViewportActive == null ? void 0 : onViewportActive(viewport);
+      const drawLayerParams = this._getDrawLayerParams(viewport, options);
+      const subViewports = viewport.subViewports || [viewport];
+      for (const subViewport of subViewports) {
+        const stats = this._drawLayersInViewport(renderPass, {
+          target,
+          shaderModuleProps,
+          viewport: subViewport,
+          view,
+          pass: options.pass,
+          layers: options.layers
+        }, drawLayerParams);
+        renderStats.push(stats);
+      }
+    }
+    return renderStats;
+  }
+  // When a viewport contains multiple subviewports (e.g. repeated web mercator map),
+  // this is only done once for the parent viewport
+  /* Resolve the parameters needed to draw each layer */
+  _getDrawLayerParams(viewport, { layers, pass, isPicking = false, layerFilter, cullRect, effects, shaderModuleProps }, evaluateShouldDrawOnly = false) {
+    var _a3;
+    const drawLayerParams = [];
+    const indexResolver = layerIndexResolver(this._lastRenderIndex + 1);
+    const drawContext = {
+      layer: layers[0],
+      viewport,
+      isPicking,
+      renderPass: pass,
+      cullRect
+    };
+    const layerFilterCache = {};
+    for (let layerIndex = 0; layerIndex < layers.length; layerIndex++) {
+      const layer = layers[layerIndex];
+      const shouldDrawLayer = this._shouldDrawLayer(layer, drawContext, layerFilter, layerFilterCache);
+      const layerParam = { shouldDrawLayer };
+      if (shouldDrawLayer && !evaluateShouldDrawOnly) {
+        layerParam.shouldDrawLayer = true;
+        layerParam.layerRenderIndex = indexResolver(layer, shouldDrawLayer);
+        layerParam.shaderModuleProps = this._getShaderModuleProps(layer, effects, pass, shaderModuleProps);
+        layerParam.layerParameters = {
+          ...(_a3 = layer.context.deck) == null ? void 0 : _a3.props.parameters,
+          ...this.getLayerParameters(layer, layerIndex, viewport)
+        };
+      }
+      drawLayerParams[layerIndex] = layerParam;
+    }
+    return drawLayerParams;
+  }
+  // Draws a list of layers in one viewport
+  // TODO - when picking we could completely skip rendering viewports that dont
+  // intersect with the picking rect
+  /* eslint-disable max-depth, max-statements, complexity */
+  _drawLayersInViewport(renderPass, { layers, shaderModuleProps: globalModuleParameters, pass, target, viewport, view }, drawLayerParams) {
+    const glViewport = getGLViewport(this.device, {
+      shaderModuleProps: globalModuleParameters,
+      target,
+      viewport
+    });
+    if (view) {
+      const { clear, clearColor, clearDepth, clearStencil } = view.props;
+      if (clear) {
+        let colorToUse = [0, 0, 0, 0];
+        let depthToUse = 1;
+        let stencilToUse = 0;
+        if (Array.isArray(clearColor)) {
+          colorToUse = [...clearColor.slice(0, 3), clearColor[3] || 255].map((c2) => c2 / 255);
+        } else if (clearColor === false) {
+          colorToUse = false;
+        }
+        if (clearDepth !== void 0) {
+          depthToUse = clearDepth;
+        }
+        if (clearStencil !== void 0) {
+          stencilToUse = clearStencil;
+        }
+        const clearRenderPass = this.device.beginRenderPass({
+          framebuffer: target,
+          parameters: {
+            viewport: glViewport,
+            scissorRect: glViewport
+          },
+          clearColor: colorToUse,
+          clearDepth: depthToUse,
+          clearStencil: stencilToUse
+        });
+        clearRenderPass.end();
+      }
+    }
+    const renderStatus = {
+      totalCount: layers.length,
+      visibleCount: 0,
+      compositeCount: 0,
+      pickableCount: 0
+    };
+    renderPass.setParameters({ viewport: glViewport });
+    for (let layerIndex = 0; layerIndex < layers.length; layerIndex++) {
+      const layer = layers[layerIndex];
+      const drawLayerParameters = drawLayerParams[layerIndex];
+      const { shouldDrawLayer } = drawLayerParameters;
+      if (shouldDrawLayer && layer.props.pickable) {
+        renderStatus.pickableCount++;
+      }
+      if (layer.isComposite) {
+        renderStatus.compositeCount++;
+      }
+      if (layer.isDrawable && drawLayerParameters.shouldDrawLayer) {
+        const { layerRenderIndex, shaderModuleProps, layerParameters } = drawLayerParameters;
+        renderStatus.visibleCount++;
+        this._lastRenderIndex = Math.max(this._lastRenderIndex, layerRenderIndex);
+        if (shaderModuleProps.project) {
+          shaderModuleProps.project.viewport = viewport;
+        }
+        layer.context.renderPass = renderPass;
+        try {
+          layer._drawLayer({
+            renderPass,
+            shaderModuleProps,
+            uniforms: { layerIndex: layerRenderIndex },
+            parameters: layerParameters
+          });
+        } catch (err) {
+          layer.raiseError(err, `drawing ${layer} to ${pass}`);
+        }
+      }
+    }
+    return renderStatus;
+  }
+  /* eslint-enable max-depth, max-statements */
+  /* Methods for subclass overrides */
+  shouldDrawLayer(layer) {
+    return true;
+  }
+  getShaderModuleProps(layer, effects, otherShaderModuleProps) {
+    return null;
+  }
+  getLayerParameters(layer, layerIndex, viewport) {
+    return layer.props.parameters;
+  }
+  /* Private */
+  _shouldDrawLayer(layer, drawContext, layerFilter, layerFilterCache) {
+    const shouldDrawLayer = layer.props.visible && this.shouldDrawLayer(layer);
+    if (!shouldDrawLayer) {
+      return false;
+    }
+    drawContext.layer = layer;
+    let parent = layer.parent;
+    while (parent) {
+      if (!parent.props.visible || !parent.filterSubLayer(drawContext)) {
+        return false;
+      }
+      drawContext.layer = parent;
+      parent = parent.parent;
+    }
+    if (layerFilter) {
+      const rootLayerId = drawContext.layer.id;
+      if (!(rootLayerId in layerFilterCache)) {
+        layerFilterCache[rootLayerId] = layerFilter(drawContext);
+      }
+      if (!layerFilterCache[rootLayerId]) {
+        return false;
+      }
+    }
+    layer.activateViewport(drawContext.viewport);
+    return true;
+  }
+  _getShaderModuleProps(layer, effects, pass, overrides) {
+    var _a3, _b3;
+    const devicePixelRatio2 = this.device.canvasContext.cssToDeviceRatio();
+    const layerProps = ((_a3 = layer.internalState) == null ? void 0 : _a3.propsInTransition) || layer.props;
+    const shaderModuleProps = {
+      layer: layerProps,
+      picking: {
+        isActive: false
       },
-      // @method unproject(point: Point, zoom: Number): LatLng
-      // Inverse of [`project`](#map-project).
-      unproject: function(point, zoom2) {
-        zoom2 = zoom2 === void 0 ? this._zoom : zoom2;
-        return this.options.crs.pointToLatLng(toPoint(point), zoom2);
+      project: {
+        viewport: layer.context.viewport,
+        devicePixelRatio: devicePixelRatio2,
+        modelMatrix: layerProps.modelMatrix,
+        coordinateSystem: layerProps.coordinateSystem,
+        coordinateOrigin: layerProps.coordinateOrigin,
+        autoWrapLongitude: layer.wrapLongitude
+      }
+    };
+    if (effects) {
+      for (const effect of effects) {
+        mergeModuleParameters(shaderModuleProps, (_b3 = effect.getShaderModuleProps) == null ? void 0 : _b3.call(effect, layer, shaderModuleProps));
+      }
+    }
+    return mergeModuleParameters(shaderModuleProps, this.getShaderModuleProps(layer, effects, shaderModuleProps), overrides);
+  }
+}
+function layerIndexResolver(startIndex = 0, layerIndices = {}) {
+  const resolvers = {};
+  const resolveLayerIndex = (layer, isDrawn) => {
+    const indexOverride = layer.props._offset;
+    const layerId = layer.id;
+    const parentId = layer.parent && layer.parent.id;
+    let index;
+    if (parentId && !(parentId in layerIndices)) {
+      resolveLayerIndex(layer.parent, false);
+    }
+    if (parentId in resolvers) {
+      const resolver = resolvers[parentId] = resolvers[parentId] || layerIndexResolver(layerIndices[parentId], layerIndices);
+      index = resolver(layer, isDrawn);
+      resolvers[layerId] = resolver;
+    } else if (Number.isFinite(indexOverride)) {
+      index = indexOverride + (layerIndices[parentId] || 0);
+      resolvers[layerId] = null;
+    } else {
+      index = startIndex;
+    }
+    if (isDrawn && index >= startIndex) {
+      startIndex = index + 1;
+    }
+    layerIndices[layerId] = index;
+    return index;
+  };
+  return resolveLayerIndex;
+}
+function getGLViewport(device, { shaderModuleProps, target, viewport }) {
+  var _a3;
+  const pixelRatio = ((_a3 = shaderModuleProps == null ? void 0 : shaderModuleProps.project) == null ? void 0 : _a3.devicePixelRatio) ?? // @ts-expect-error TODO - assuming WebGL context
+  device.canvasContext.cssToDeviceRatio();
+  const [, drawingBufferHeight] = device.canvasContext.getDrawingBufferSize();
+  const height = target ? target.height : drawingBufferHeight;
+  const dimensions = viewport;
+  return [
+    dimensions.x * pixelRatio,
+    height - (dimensions.y + dimensions.height) * pixelRatio,
+    dimensions.width * pixelRatio,
+    dimensions.height * pixelRatio
+  ];
+}
+function mergeModuleParameters(target, ...sources) {
+  for (const source2 of sources) {
+    if (source2) {
+      for (const key in source2) {
+        if (target[key]) {
+          Object.assign(target[key], source2[key]);
+        } else {
+          target[key] = source2[key];
+        }
+      }
+    }
+  }
+  return target;
+}
+class ShadowPass extends LayersPass {
+  constructor(device, props) {
+    super(device, props);
+    const shadowMap = device.createTexture({
+      format: "rgba8unorm",
+      width: 1,
+      height: 1,
+      sampler: {
+        minFilter: "linear",
+        magFilter: "linear",
+        addressModeU: "clamp-to-edge",
+        addressModeV: "clamp-to-edge"
+      }
+      // TODO - texture API change in luma.gl v9.2
+      // mipmaps: true
+    });
+    const depthBuffer = device.createTexture({ format: "depth16unorm", width: 1, height: 1 });
+    this.fbo = device.createFramebuffer({
+      id: "shadowmap",
+      width: 1,
+      height: 1,
+      colorAttachments: [shadowMap],
+      // Depth attachment has to be specified for depth test to work
+      depthStencilAttachment: depthBuffer
+    });
+  }
+  delete() {
+    if (this.fbo) {
+      this.fbo.destroy();
+      this.fbo = null;
+    }
+  }
+  getShadowMap() {
+    return this.fbo.colorAttachments[0].texture;
+  }
+  render(params) {
+    const target = this.fbo;
+    const pixelRatio = this.device.canvasContext.cssToDeviceRatio();
+    const viewport = params.viewports[0];
+    const width = viewport.width * pixelRatio;
+    const height = viewport.height * pixelRatio;
+    const clearColor = [1, 1, 1, 1];
+    if (width !== target.width || height !== target.height) {
+      target.resize({ width, height });
+    }
+    super.render({ ...params, clearColor, target, pass: "shadow" });
+  }
+  getLayerParameters(layer, layerIndex, viewport) {
+    return {
+      ...layer.props.parameters,
+      blend: false,
+      depthWriteEnabled: true,
+      depthCompare: "less-equal"
+    };
+  }
+  shouldDrawLayer(layer) {
+    return layer.props.shadowEnabled !== false;
+  }
+  getShaderModuleProps(layer, effects, otherShaderModuleProps) {
+    return {
+      shadow: {
+        project: otherShaderModuleProps.project,
+        drawToShadowMap: true
+      }
+    };
+  }
+}
+const DEFAULT_AMBIENT_LIGHT_PROPS = {
+  color: [255, 255, 255],
+  intensity: 1
+};
+const DEFAULT_DIRECTIONAL_LIGHT_PROPS = [
+  {
+    color: [255, 255, 255],
+    intensity: 1,
+    direction: [-1, 3, -1]
+  },
+  {
+    color: [255, 255, 255],
+    intensity: 0.9,
+    direction: [1, -8, -2.5]
+  }
+];
+const DEFAULT_SHADOW_COLOR = [0, 0, 0, 200 / 255];
+class LightingEffect {
+  constructor(props = {}) {
+    this.id = "lighting-effect";
+    this.shadowColor = DEFAULT_SHADOW_COLOR;
+    this.shadow = false;
+    this.directionalLights = [];
+    this.pointLights = [];
+    this.shadowPasses = [];
+    this.dummyShadowMap = null;
+    this.setProps(props);
+  }
+  setup(context) {
+    this.context = context;
+    const { device, deck } = context;
+    if (this.shadow && !this.dummyShadowMap) {
+      this._createShadowPasses(device);
+      deck._addDefaultShaderModule(shadow);
+      this.dummyShadowMap = device.createTexture({
+        width: 1,
+        height: 1
+      });
+    }
+  }
+  setProps(props) {
+    this.ambientLight = void 0;
+    this.directionalLights = [];
+    this.pointLights = [];
+    for (const key in props) {
+      const lightSource = props[key];
+      switch (lightSource.type) {
+        case "ambient":
+          this.ambientLight = lightSource;
+          break;
+        case "directional":
+          this.directionalLights.push(lightSource);
+          break;
+        case "point":
+          this.pointLights.push(lightSource);
+          break;
+      }
+    }
+    this._applyDefaultLights();
+    this.shadow = this.directionalLights.some((light) => light.shadow);
+    if (this.context) {
+      this.setup(this.context);
+    }
+    this.props = props;
+  }
+  preRender({ layers, layerFilter, viewports, onViewportActive, views }) {
+    if (!this.shadow)
+      return;
+    this.shadowMatrices = this._calculateMatrices();
+    for (let i2 = 0; i2 < this.shadowPasses.length; i2++) {
+      const shadowPass = this.shadowPasses[i2];
+      shadowPass.render({
+        layers,
+        layerFilter,
+        viewports,
+        onViewportActive,
+        views,
+        shaderModuleProps: {
+          shadow: {
+            shadowLightId: i2,
+            dummyShadowMap: this.dummyShadowMap,
+            shadowMatrices: this.shadowMatrices
+          }
+        }
+      });
+    }
+  }
+  getShaderModuleProps(layer, otherShaderModuleProps) {
+    const shadowProps = this.shadow ? {
+      project: otherShaderModuleProps.project,
+      shadowMaps: this.shadowPasses.map((shadowPass) => shadowPass.getShadowMap()),
+      dummyShadowMap: this.dummyShadowMap,
+      shadowColor: this.shadowColor,
+      shadowMatrices: this.shadowMatrices
+    } : {};
+    const lightingProps = {
+      enabled: true,
+      ambientLight: this.ambientLight,
+      directionalLights: this.directionalLights.map((directionalLight) => directionalLight.getProjectedLight({ layer })),
+      pointLights: this.pointLights.map((pointLight) => pointLight.getProjectedLight({ layer }))
+    };
+    const materialProps = layer.props.material;
+    return {
+      shadow: shadowProps,
+      lighting: lightingProps,
+      phongMaterial: materialProps,
+      gouraudMaterial: materialProps
+    };
+  }
+  cleanup(context) {
+    for (const shadowPass of this.shadowPasses) {
+      shadowPass.delete();
+    }
+    this.shadowPasses.length = 0;
+    if (this.dummyShadowMap) {
+      this.dummyShadowMap.destroy();
+      this.dummyShadowMap = null;
+      context.deck._removeDefaultShaderModule(shadow);
+    }
+  }
+  _calculateMatrices() {
+    const lightMatrices = [];
+    for (const light of this.directionalLights) {
+      const viewMatrix = new Matrix4().lookAt({
+        eye: new Vector3(light.direction).negate()
+      });
+      lightMatrices.push(viewMatrix);
+    }
+    return lightMatrices;
+  }
+  _createShadowPasses(device) {
+    for (let i2 = 0; i2 < this.directionalLights.length; i2++) {
+      const shadowPass = new ShadowPass(device);
+      this.shadowPasses[i2] = shadowPass;
+    }
+  }
+  _applyDefaultLights() {
+    const { ambientLight, pointLights, directionalLights } = this;
+    if (!ambientLight && pointLights.length === 0 && directionalLights.length === 0) {
+      this.ambientLight = new AmbientLight(DEFAULT_AMBIENT_LIGHT_PROPS);
+      this.directionalLights.push(new DirectionalLight(DEFAULT_DIRECTIONAL_LIGHT_PROPS[0]), new DirectionalLight(DEFAULT_DIRECTIONAL_LIGHT_PROPS[1]));
+    }
+  }
+}
+class TypedArrayManager {
+  constructor(options = {}) {
+    this._pool = [];
+    this.opts = { overAlloc: 2, poolSize: 100 };
+    this.setOptions(options);
+  }
+  setOptions(options) {
+    Object.assign(this.opts, options);
+  }
+  allocate(typedArray, count2, { size = 1, type, padding = 0, copy = false, initialize = false, maxCount }) {
+    const Type2 = type || typedArray && typedArray.constructor || Float32Array;
+    const newSize = count2 * size + padding;
+    if (ArrayBuffer.isView(typedArray)) {
+      if (newSize <= typedArray.length) {
+        return typedArray;
+      }
+      if (newSize * typedArray.BYTES_PER_ELEMENT <= typedArray.buffer.byteLength) {
+        return new Type2(typedArray.buffer, 0, newSize);
+      }
+    }
+    let maxSize = Infinity;
+    if (maxCount) {
+      maxSize = maxCount * size + padding;
+    }
+    const newArray = this._allocate(Type2, newSize, initialize, maxSize);
+    if (typedArray && copy) {
+      newArray.set(typedArray);
+    } else if (!initialize) {
+      newArray.fill(0, 0, 4);
+    }
+    this._release(typedArray);
+    return newArray;
+  }
+  release(typedArray) {
+    this._release(typedArray);
+  }
+  _allocate(Type2, size, initialize, maxSize) {
+    let sizeToAllocate = Math.max(Math.ceil(size * this.opts.overAlloc), 1);
+    if (sizeToAllocate > maxSize) {
+      sizeToAllocate = maxSize;
+    }
+    const pool = this._pool;
+    const byteLength = Type2.BYTES_PER_ELEMENT * sizeToAllocate;
+    const i2 = pool.findIndex((b2) => b2.byteLength >= byteLength);
+    if (i2 >= 0) {
+      const array = new Type2(pool.splice(i2, 1)[0], 0, sizeToAllocate);
+      if (initialize) {
+        array.fill(0);
+      }
+      return array;
+    }
+    return new Type2(sizeToAllocate);
+  }
+  _release(typedArray) {
+    if (!ArrayBuffer.isView(typedArray)) {
+      return;
+    }
+    const pool = this._pool;
+    const { buffer } = typedArray;
+    const { byteLength } = buffer;
+    const i2 = pool.findIndex((b2) => b2.byteLength >= byteLength);
+    if (i2 < 0) {
+      pool.push(buffer);
+    } else if (i2 > 0 || pool.length < this.opts.poolSize) {
+      pool.splice(i2, 0, buffer);
+    }
+    if (pool.length > this.opts.poolSize) {
+      pool.shift();
+    }
+  }
+}
+const defaultTypedArrayManager = new TypedArrayManager();
+function createMat4() {
+  return [1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1];
+}
+function mod(value, divisor) {
+  const modulus = value % divisor;
+  return modulus < 0 ? divisor + modulus : modulus;
+}
+function getCameraPosition(viewMatrixInverse) {
+  return [viewMatrixInverse[12], viewMatrixInverse[13], viewMatrixInverse[14]];
+}
+function getFrustumPlanes(viewProjectionMatrix) {
+  return {
+    left: getFrustumPlane(viewProjectionMatrix[3] + viewProjectionMatrix[0], viewProjectionMatrix[7] + viewProjectionMatrix[4], viewProjectionMatrix[11] + viewProjectionMatrix[8], viewProjectionMatrix[15] + viewProjectionMatrix[12]),
+    right: getFrustumPlane(viewProjectionMatrix[3] - viewProjectionMatrix[0], viewProjectionMatrix[7] - viewProjectionMatrix[4], viewProjectionMatrix[11] - viewProjectionMatrix[8], viewProjectionMatrix[15] - viewProjectionMatrix[12]),
+    bottom: getFrustumPlane(viewProjectionMatrix[3] + viewProjectionMatrix[1], viewProjectionMatrix[7] + viewProjectionMatrix[5], viewProjectionMatrix[11] + viewProjectionMatrix[9], viewProjectionMatrix[15] + viewProjectionMatrix[13]),
+    top: getFrustumPlane(viewProjectionMatrix[3] - viewProjectionMatrix[1], viewProjectionMatrix[7] - viewProjectionMatrix[5], viewProjectionMatrix[11] - viewProjectionMatrix[9], viewProjectionMatrix[15] - viewProjectionMatrix[13]),
+    near: getFrustumPlane(viewProjectionMatrix[3] + viewProjectionMatrix[2], viewProjectionMatrix[7] + viewProjectionMatrix[6], viewProjectionMatrix[11] + viewProjectionMatrix[10], viewProjectionMatrix[15] + viewProjectionMatrix[14]),
+    far: getFrustumPlane(viewProjectionMatrix[3] - viewProjectionMatrix[2], viewProjectionMatrix[7] - viewProjectionMatrix[6], viewProjectionMatrix[11] - viewProjectionMatrix[10], viewProjectionMatrix[15] - viewProjectionMatrix[14])
+  };
+}
+const scratchVector = new Vector3();
+function getFrustumPlane(a2, b2, c2, d2) {
+  scratchVector.set(a2, b2, c2);
+  const L2 = scratchVector.len();
+  return { distance: d2 / L2, normal: new Vector3(-a2 / L2, -b2 / L2, -c2 / L2) };
+}
+function fp64LowPart(x2) {
+  return x2 - Math.fround(x2);
+}
+let scratchArray;
+function toDoublePrecisionArray(typedArray, options) {
+  const { size = 1, startIndex = 0 } = options;
+  const endIndex = options.endIndex !== void 0 ? options.endIndex : typedArray.length;
+  const count2 = (endIndex - startIndex) / size;
+  scratchArray = defaultTypedArrayManager.allocate(scratchArray, count2, {
+    type: Float32Array,
+    size: size * 2
+  });
+  let sourceIndex = startIndex;
+  let targetIndex = 0;
+  while (sourceIndex < endIndex) {
+    for (let j2 = 0; j2 < size; j2++) {
+      const value = typedArray[sourceIndex++];
+      scratchArray[targetIndex + j2] = value;
+      scratchArray[targetIndex + j2 + size] = fp64LowPart(value);
+    }
+    targetIndex += size * 2;
+  }
+  return scratchArray.subarray(0, count2 * size * 2);
+}
+function mergeBounds(boundsList) {
+  let mergedBounds = null;
+  let isMerged = false;
+  for (const bounds of boundsList) {
+    if (!bounds)
+      continue;
+    if (!mergedBounds) {
+      mergedBounds = bounds;
+    } else {
+      if (!isMerged) {
+        mergedBounds = [
+          [mergedBounds[0][0], mergedBounds[0][1]],
+          [mergedBounds[1][0], mergedBounds[1][1]]
+        ];
+        isMerged = true;
+      }
+      mergedBounds[0][0] = Math.min(mergedBounds[0][0], bounds[0][0]);
+      mergedBounds[0][1] = Math.min(mergedBounds[0][1], bounds[0][1]);
+      mergedBounds[1][0] = Math.max(mergedBounds[1][0], bounds[1][0]);
+      mergedBounds[1][1] = Math.max(mergedBounds[1][1], bounds[1][1]);
+    }
+  }
+  return mergedBounds;
+}
+const DEGREES_TO_RADIANS$2 = Math.PI / 180;
+const IDENTITY = createMat4();
+const ZERO_VECTOR = [0, 0, 0];
+const DEFAULT_DISTANCE_SCALES = {
+  unitsPerMeter: [1, 1, 1],
+  metersPerUnit: [1, 1, 1]
+};
+function createProjectionMatrix({ width, height, orthographic, fovyRadians, focalDistance, padding, near, far }) {
+  const aspect = width / height;
+  const matrix = orthographic ? new Matrix4().orthographic({ fovy: fovyRadians, aspect, focalDistance, near, far }) : new Matrix4().perspective({ fovy: fovyRadians, aspect, near, far });
+  if (padding) {
+    const { left = 0, right = 0, top = 0, bottom = 0 } = padding;
+    const offsetX = clamp$1((left + width - right) / 2, 0, width) - width / 2;
+    const offsetY = clamp$1((top + height - bottom) / 2, 0, height) - height / 2;
+    matrix[8] -= offsetX * 2 / width;
+    matrix[9] += offsetY * 2 / height;
+  }
+  return matrix;
+}
+class Viewport {
+  // eslint-disable-next-line complexity
+  constructor(opts = {}) {
+    this._frustumPlanes = {};
+    this.id = opts.id || this.constructor.displayName || "viewport";
+    this.x = opts.x || 0;
+    this.y = opts.y || 0;
+    this.width = opts.width || 1;
+    this.height = opts.height || 1;
+    this.zoom = opts.zoom || 0;
+    this.padding = opts.padding;
+    this.distanceScales = opts.distanceScales || DEFAULT_DISTANCE_SCALES;
+    this.focalDistance = opts.focalDistance || 1;
+    this.position = opts.position || ZERO_VECTOR;
+    this.modelMatrix = opts.modelMatrix || null;
+    const { longitude, latitude } = opts;
+    this.isGeospatial = Number.isFinite(latitude) && Number.isFinite(longitude);
+    this._initProps(opts);
+    this._initMatrices(opts);
+    this.equals = this.equals.bind(this);
+    this.project = this.project.bind(this);
+    this.unproject = this.unproject.bind(this);
+    this.projectPosition = this.projectPosition.bind(this);
+    this.unprojectPosition = this.unprojectPosition.bind(this);
+    this.projectFlat = this.projectFlat.bind(this);
+    this.unprojectFlat = this.unprojectFlat.bind(this);
+  }
+  get subViewports() {
+    return null;
+  }
+  get metersPerPixel() {
+    return this.distanceScales.metersPerUnit[2] / this.scale;
+  }
+  get projectionMode() {
+    if (this.isGeospatial) {
+      return this.zoom < 12 ? PROJECTION_MODE.WEB_MERCATOR : PROJECTION_MODE.WEB_MERCATOR_AUTO_OFFSET;
+    }
+    return PROJECTION_MODE.IDENTITY;
+  }
+  // Two viewports are equal if width and height are identical, and if
+  // their view and projection matrices are (approximately) equal.
+  equals(viewport) {
+    if (!(viewport instanceof Viewport)) {
+      return false;
+    }
+    if (this === viewport) {
+      return true;
+    }
+    return viewport.width === this.width && viewport.height === this.height && viewport.scale === this.scale && equals(viewport.projectionMatrix, this.projectionMatrix) && equals(viewport.viewMatrix, this.viewMatrix);
+  }
+  /**
+   * Projects xyz (possibly latitude and longitude) to pixel coordinates in window
+   * using viewport projection parameters
+   * - [longitude, latitude] to [x, y]
+   * - [longitude, latitude, Z] => [x, y, z]
+   * Note: By default, returns top-left coordinates for canvas/SVG type render
+   *
+   * @param {Array} lngLatZ - [lng, lat] or [lng, lat, Z]
+   * @param {Object} opts - options
+   * @param {Object} opts.topLeft=true - Whether projected coords are top left
+   * @return {Array} - [x, y] or [x, y, z] in top left coords
+   */
+  project(xyz, { topLeft = true } = {}) {
+    const worldPosition = this.projectPosition(xyz);
+    const coord = worldToPixels(worldPosition, this.pixelProjectionMatrix);
+    const [x2, y2] = coord;
+    const y22 = topLeft ? y2 : this.height - y2;
+    return xyz.length === 2 ? [x2, y22] : [x2, y22, coord[2]];
+  }
+  /**
+   * Unproject pixel coordinates on screen onto world coordinates,
+   * (possibly [lon, lat]) on map.
+   * - [x, y] => [lng, lat]
+   * - [x, y, z] => [lng, lat, Z]
+   * @param {Array} xyz -
+   * @param {Object} opts - options
+   * @param {Object} opts.topLeft=true - Whether origin is top left
+   * @return {Array|null} - [lng, lat, Z] or [X, Y, Z]
+   */
+  unproject(xyz, { topLeft = true, targetZ } = {}) {
+    const [x2, y2, z2] = xyz;
+    const y22 = topLeft ? y2 : this.height - y2;
+    const targetZWorld = targetZ && targetZ * this.distanceScales.unitsPerMeter[2];
+    const coord = pixelsToWorld([x2, y22, z2], this.pixelUnprojectionMatrix, targetZWorld);
+    const [X2, Y2, Z2] = this.unprojectPosition(coord);
+    if (Number.isFinite(z2)) {
+      return [X2, Y2, Z2];
+    }
+    return Number.isFinite(targetZ) ? [X2, Y2, targetZ] : [X2, Y2];
+  }
+  // NON_LINEAR PROJECTION HOOKS
+  // Used for web meractor projection
+  projectPosition(xyz) {
+    const [X2, Y2] = this.projectFlat(xyz);
+    const Z2 = (xyz[2] || 0) * this.distanceScales.unitsPerMeter[2];
+    return [X2, Y2, Z2];
+  }
+  unprojectPosition(xyz) {
+    const [X2, Y2] = this.unprojectFlat(xyz);
+    const Z2 = (xyz[2] || 0) * this.distanceScales.metersPerUnit[2];
+    return [X2, Y2, Z2];
+  }
+  /**
+   * Project [lng,lat] on sphere onto [x,y] on 512*512 Mercator Zoom 0 tile.
+   * Performs the nonlinear part of the web mercator projection.
+   * Remaining projection is done with 4x4 matrices which also handles
+   * perspective.
+   * @param {Array} lngLat - [lng, lat] coordinates
+   *   Specifies a point on the sphere to project onto the map.
+   * @return {Array} [x,y] coordinates.
+   */
+  projectFlat(xyz) {
+    if (this.isGeospatial) {
+      const result = lngLatToWorld(xyz);
+      result[1] = clamp$1(result[1], -318, 830);
+      return result;
+    }
+    return xyz;
+  }
+  /**
+   * Unproject world point [x,y] on map onto {lat, lon} on sphere
+   * @param {object|Vector} xy - object with {x,y} members
+   *  representing point on projected map plane
+   * @return {GeoCoordinates} - object with {lat,lon} of point on sphere.
+   *   Has toArray method if you need a GeoJSON Array.
+   *   Per cartographic tradition, lat and lon are specified as degrees.
+   */
+  unprojectFlat(xyz) {
+    if (this.isGeospatial) {
+      return worldToLngLat(xyz);
+    }
+    return xyz;
+  }
+  /**
+   * Get bounds of the current viewport
+   * @return {Array} - [minX, minY, maxX, maxY]
+   */
+  getBounds(options = {}) {
+    const unprojectOption = { targetZ: options.z || 0 };
+    const topLeft = this.unproject([0, 0], unprojectOption);
+    const topRight = this.unproject([this.width, 0], unprojectOption);
+    const bottomLeft = this.unproject([0, this.height], unprojectOption);
+    const bottomRight = this.unproject([this.width, this.height], unprojectOption);
+    return [
+      Math.min(topLeft[0], topRight[0], bottomLeft[0], bottomRight[0]),
+      Math.min(topLeft[1], topRight[1], bottomLeft[1], bottomRight[1]),
+      Math.max(topLeft[0], topRight[0], bottomLeft[0], bottomRight[0]),
+      Math.max(topLeft[1], topRight[1], bottomLeft[1], bottomRight[1])
+    ];
+  }
+  getDistanceScales(coordinateOrigin) {
+    if (coordinateOrigin && this.isGeospatial) {
+      return getDistanceScales$1({
+        longitude: coordinateOrigin[0],
+        latitude: coordinateOrigin[1],
+        highPrecision: true
+      });
+    }
+    return this.distanceScales;
+  }
+  containsPixel({ x: x2, y: y2, width = 1, height = 1 }) {
+    return x2 < this.x + this.width && this.x < x2 + width && y2 < this.y + this.height && this.y < y2 + height;
+  }
+  // Extract frustum planes in common space
+  getFrustumPlanes() {
+    if (this._frustumPlanes.near) {
+      return this._frustumPlanes;
+    }
+    Object.assign(this._frustumPlanes, getFrustumPlanes(this.viewProjectionMatrix));
+    return this._frustumPlanes;
+  }
+  // EXPERIMENTAL METHODS
+  /**
+   * Needed by panning and linear transition
+   * Pan the viewport to place a given world coordinate at screen point [x, y]
+   *
+   * @param {Array} coords - world coordinates
+   * @param {Array} pixel - [x,y] coordinates on screen
+   * @param {Array} startPixel - [x,y] screen position where pan started (optional, for delta-based panning)
+   * @return {Object} props of the new viewport
+   */
+  panByPosition(coords, pixel, startPixel) {
+    return null;
+  }
+  // INTERNAL METHODS
+  /* eslint-disable complexity, max-statements */
+  _initProps(opts) {
+    const longitude = opts.longitude;
+    const latitude = opts.latitude;
+    if (this.isGeospatial) {
+      if (!Number.isFinite(opts.zoom)) {
+        this.zoom = getMeterZoom({ latitude }) + Math.log2(this.focalDistance);
+      }
+      this.distanceScales = opts.distanceScales || getDistanceScales$1({ latitude, longitude });
+    }
+    const scale2 = Math.pow(2, this.zoom);
+    this.scale = scale2;
+    const { position, modelMatrix } = opts;
+    let meterOffset = ZERO_VECTOR;
+    if (position) {
+      meterOffset = modelMatrix ? new Matrix4(modelMatrix).transformAsVector(position, []) : position;
+    }
+    if (this.isGeospatial) {
+      const center = this.projectPosition([longitude, latitude, 0]);
+      this.center = new Vector3(meterOffset).scale(this.distanceScales.unitsPerMeter).add(center);
+    } else {
+      this.center = this.projectPosition(meterOffset);
+    }
+  }
+  /* eslint-enable complexity, max-statements */
+  _initMatrices(opts) {
+    const {
+      // View matrix
+      viewMatrix = IDENTITY,
+      // Projection matrix
+      projectionMatrix = null,
+      // Projection matrix parameters, used if projectionMatrix not supplied
+      orthographic = false,
+      fovyRadians,
+      fovy = 75,
+      near = 0.1,
+      // Distance of near clipping plane
+      far = 1e3,
+      // Distance of far clipping plane
+      padding = null,
+      // Center offset in pixels
+      focalDistance = 1
+    } = opts;
+    this.viewMatrixUncentered = viewMatrix;
+    this.viewMatrix = new Matrix4().multiplyRight(viewMatrix).translate(new Vector3(this.center).negate());
+    this.projectionMatrix = projectionMatrix || createProjectionMatrix({
+      width: this.width,
+      height: this.height,
+      orthographic,
+      fovyRadians: fovyRadians || fovy * DEGREES_TO_RADIANS$2,
+      focalDistance,
+      padding,
+      near,
+      far
+    });
+    const vpm = createMat4();
+    multiply(vpm, vpm, this.projectionMatrix);
+    multiply(vpm, vpm, this.viewMatrix);
+    this.viewProjectionMatrix = vpm;
+    this.viewMatrixInverse = invert([], this.viewMatrix) || this.viewMatrix;
+    this.cameraPosition = getCameraPosition(this.viewMatrixInverse);
+    const viewportMatrix = createMat4();
+    const pixelProjectionMatrix = createMat4();
+    scale$1(viewportMatrix, viewportMatrix, [this.width / 2, -this.height / 2, 1]);
+    translate(viewportMatrix, viewportMatrix, [1, -1, 0]);
+    multiply(pixelProjectionMatrix, viewportMatrix, this.viewProjectionMatrix);
+    this.pixelProjectionMatrix = pixelProjectionMatrix;
+    this.pixelUnprojectionMatrix = invert(createMat4(), this.pixelProjectionMatrix);
+    if (!this.pixelUnprojectionMatrix) {
+      defaultLogger.warn("Pixel project matrix not invertible")();
+    }
+  }
+}
+Viewport.displayName = "Viewport";
+class WebMercatorViewport extends Viewport {
+  /* eslint-disable complexity, max-statements */
+  constructor(opts = {}) {
+    const {
+      latitude = 0,
+      longitude = 0,
+      zoom = 0,
+      pitch = 0,
+      bearing = 0,
+      nearZMultiplier = 0.1,
+      farZMultiplier = 1.01,
+      nearZ,
+      farZ,
+      orthographic = false,
+      projectionMatrix,
+      repeat = false,
+      worldOffset = 0,
+      position,
+      padding,
+      // backward compatibility
+      // TODO: remove in v9
+      legacyMeterSizes = false
+    } = opts;
+    let { width, height, altitude = 1.5 } = opts;
+    const scale2 = Math.pow(2, zoom);
+    width = width || 1;
+    height = height || 1;
+    let fovy;
+    let projectionParameters = null;
+    if (projectionMatrix) {
+      altitude = projectionMatrix[5] / 2;
+      fovy = altitudeToFovy(altitude);
+    } else {
+      if (opts.fovy) {
+        fovy = opts.fovy;
+        altitude = fovyToAltitude(fovy);
+      } else {
+        fovy = altitudeToFovy(altitude);
+      }
+      let offset;
+      if (padding) {
+        const { top = 0, bottom = 0 } = padding;
+        offset = [0, clamp$1((top + height - bottom) / 2, 0, height) - height / 2];
+      }
+      projectionParameters = getProjectionParameters({
+        width,
+        height,
+        scale: scale2,
+        center: position && [0, 0, position[2] * unitsPerMeter(latitude)],
+        offset,
+        pitch,
+        fovy,
+        nearZMultiplier,
+        farZMultiplier
+      });
+      if (Number.isFinite(nearZ)) {
+        projectionParameters.near = nearZ;
+      }
+      if (Number.isFinite(farZ)) {
+        projectionParameters.far = farZ;
+      }
+    }
+    let viewMatrixUncentered = getViewMatrix({
+      height,
+      pitch,
+      bearing,
+      scale: scale2,
+      altitude
+    });
+    if (worldOffset) {
+      const viewOffset = new Matrix4().translate([512 * worldOffset, 0, 0]);
+      viewMatrixUncentered = viewOffset.multiplyLeft(viewMatrixUncentered);
+    }
+    super({
+      ...opts,
+      // x, y,
+      width,
+      height,
+      // view matrix
+      viewMatrix: viewMatrixUncentered,
+      longitude,
+      latitude,
+      zoom,
+      // projection matrix parameters
+      ...projectionParameters,
+      fovy,
+      focalDistance: altitude
+    });
+    this.latitude = latitude;
+    this.longitude = longitude;
+    this.zoom = zoom;
+    this.pitch = pitch;
+    this.bearing = bearing;
+    this.altitude = altitude;
+    this.fovy = fovy;
+    this.orthographic = orthographic;
+    this._subViewports = repeat ? [] : null;
+    this._pseudoMeters = legacyMeterSizes;
+    Object.freeze(this);
+  }
+  /* eslint-enable complexity, max-statements */
+  get subViewports() {
+    if (this._subViewports && !this._subViewports.length) {
+      const bounds = this.getBounds();
+      const minOffset = Math.floor((bounds[0] + 180) / 360);
+      const maxOffset = Math.ceil((bounds[2] - 180) / 360);
+      for (let x2 = minOffset; x2 <= maxOffset; x2++) {
+        const offsetViewport = x2 ? new WebMercatorViewport({
+          ...this,
+          worldOffset: x2
+        }) : this;
+        this._subViewports.push(offsetViewport);
+      }
+    }
+    return this._subViewports;
+  }
+  projectPosition(xyz) {
+    if (this._pseudoMeters) {
+      return super.projectPosition(xyz);
+    }
+    const [X2, Y2] = this.projectFlat(xyz);
+    const Z2 = (xyz[2] || 0) * unitsPerMeter(xyz[1]);
+    return [X2, Y2, Z2];
+  }
+  unprojectPosition(xyz) {
+    if (this._pseudoMeters) {
+      return super.unprojectPosition(xyz);
+    }
+    const [X2, Y2] = this.unprojectFlat(xyz);
+    const Z2 = (xyz[2] || 0) / unitsPerMeter(Y2);
+    return [X2, Y2, Z2];
+  }
+  /**
+   * Add a meter delta to a base lnglat coordinate, returning a new lnglat array
+   *
+   * Note: Uses simple linear approximation around the viewport center
+   * Error increases with size of offset (roughly 1% per 100km)
+   *
+   * @param {[Number,Number]|[Number,Number,Number]) lngLatZ - base coordinate
+   * @param {[Number,Number]|[Number,Number,Number]) xyz - array of meter deltas
+   * @return {[Number,Number]|[Number,Number,Number]) array of [lng,lat,z] deltas
+   */
+  addMetersToLngLat(lngLatZ, xyz) {
+    return addMetersToLngLat(lngLatZ, xyz);
+  }
+  panByPosition(coords, pixel, startPixel) {
+    const fromLocation = pixelsToWorld(pixel, this.pixelUnprojectionMatrix);
+    const toLocation = this.projectFlat(coords);
+    const translate2 = add$1([], toLocation, negate$1([], fromLocation));
+    const newCenter = add$1([], this.center, translate2);
+    const [longitude, latitude] = this.unprojectFlat(newCenter);
+    return { longitude, latitude };
+  }
+  getBounds(options = {}) {
+    const corners = getBounds(this, options.z || 0);
+    return [
+      Math.min(corners[0][0], corners[1][0], corners[2][0], corners[3][0]),
+      Math.min(corners[0][1], corners[1][1], corners[2][1], corners[3][1]),
+      Math.max(corners[0][0], corners[1][0], corners[2][0], corners[3][0]),
+      Math.max(corners[0][1], corners[1][1], corners[2][1], corners[3][1])
+    ];
+  }
+  /**
+   * Returns a new viewport that fit around the given rectangle.
+   * Only supports non-perspective mode.
+   */
+  fitBounds(bounds, options = {}) {
+    const { width, height } = this;
+    const { longitude, latitude, zoom } = fitBounds({ width, height, bounds, ...options });
+    return new WebMercatorViewport({ width, height, longitude, latitude, zoom });
+  }
+}
+WebMercatorViewport.displayName = "WebMercatorViewport";
+const DEFAULT_COORDINATE_ORIGIN = [0, 0, 0];
+function lngLatZToWorldPosition(lngLatZ, viewport, offsetMode = false) {
+  const p2 = viewport.projectPosition(lngLatZ);
+  if (offsetMode && viewport instanceof WebMercatorViewport) {
+    const [longitude, latitude, z2 = 0] = lngLatZ;
+    const distanceScales = viewport.getDistanceScales([longitude, latitude]);
+    p2[2] = z2 * distanceScales.unitsPerMeter[2];
+  }
+  return p2;
+}
+function normalizeParameters(opts) {
+  const { viewport, modelMatrix, coordinateOrigin } = opts;
+  let { coordinateSystem, fromCoordinateSystem, fromCoordinateOrigin } = opts;
+  if (coordinateSystem === COORDINATE_SYSTEM.DEFAULT) {
+    coordinateSystem = viewport.isGeospatial ? COORDINATE_SYSTEM.LNGLAT : COORDINATE_SYSTEM.CARTESIAN;
+  }
+  if (fromCoordinateSystem === void 0) {
+    fromCoordinateSystem = coordinateSystem;
+  }
+  if (fromCoordinateOrigin === void 0) {
+    fromCoordinateOrigin = coordinateOrigin;
+  }
+  return {
+    viewport,
+    coordinateSystem,
+    coordinateOrigin,
+    modelMatrix,
+    fromCoordinateSystem,
+    fromCoordinateOrigin
+  };
+}
+function getWorldPosition(position, { viewport, modelMatrix, coordinateSystem, coordinateOrigin, offsetMode }) {
+  let [x2, y2, z2 = 0] = position;
+  if (modelMatrix) {
+    [x2, y2, z2] = transformMat4([], [x2, y2, z2, 1], modelMatrix);
+  }
+  switch (coordinateSystem) {
+    case COORDINATE_SYSTEM.LNGLAT:
+      return lngLatZToWorldPosition([x2, y2, z2], viewport, offsetMode);
+    case COORDINATE_SYSTEM.LNGLAT_OFFSETS:
+      return lngLatZToWorldPosition([x2 + coordinateOrigin[0], y2 + coordinateOrigin[1], z2 + (coordinateOrigin[2] || 0)], viewport, offsetMode);
+    case COORDINATE_SYSTEM.METER_OFFSETS:
+      return lngLatZToWorldPosition(addMetersToLngLat(coordinateOrigin, [x2, y2, z2]), viewport, offsetMode);
+    case COORDINATE_SYSTEM.CARTESIAN:
+    default:
+      return viewport.isGeospatial ? [x2 + coordinateOrigin[0], y2 + coordinateOrigin[1], z2 + coordinateOrigin[2]] : viewport.projectPosition([x2, y2, z2]);
+  }
+}
+function projectPosition(position, params) {
+  const { viewport, coordinateSystem, coordinateOrigin, modelMatrix, fromCoordinateSystem, fromCoordinateOrigin } = normalizeParameters(params);
+  const { autoOffset = true } = params;
+  const { geospatialOrigin = DEFAULT_COORDINATE_ORIGIN, shaderCoordinateOrigin = DEFAULT_COORDINATE_ORIGIN, offsetMode = false } = autoOffset ? getOffsetOrigin(viewport, coordinateSystem, coordinateOrigin) : {};
+  const worldPosition = getWorldPosition(position, {
+    viewport,
+    modelMatrix,
+    coordinateSystem: fromCoordinateSystem,
+    coordinateOrigin: fromCoordinateOrigin,
+    offsetMode
+  });
+  if (offsetMode) {
+    const positionCommonSpace = viewport.projectPosition(geospatialOrigin || shaderCoordinateOrigin);
+    sub(worldPosition, worldPosition, positionCommonSpace);
+  }
+  return worldPosition;
+}
+let channelHandles = 1;
+let animationHandles = 1;
+class Timeline {
+  constructor() {
+    __publicField(this, "time", 0);
+    __publicField(this, "channels", /* @__PURE__ */ new Map());
+    __publicField(this, "animations", /* @__PURE__ */ new Map());
+    __publicField(this, "playing", false);
+    __publicField(this, "lastEngineTime", -1);
+  }
+  addChannel(props) {
+    const { delay = 0, duration = Number.POSITIVE_INFINITY, rate = 1, repeat = 1 } = props;
+    const channelId = channelHandles++;
+    const channel = {
+      time: 0,
+      delay,
+      duration,
+      rate,
+      repeat
+    };
+    this._setChannelTime(channel, this.time);
+    this.channels.set(channelId, channel);
+    return channelId;
+  }
+  removeChannel(channelId) {
+    this.channels.delete(channelId);
+    for (const [animationHandle, animation] of this.animations) {
+      if (animation.channel === channelId) {
+        this.detachAnimation(animationHandle);
+      }
+    }
+  }
+  isFinished(channelId) {
+    const channel = this.channels.get(channelId);
+    if (channel === void 0) {
+      return false;
+    }
+    return this.time >= channel.delay + channel.duration * channel.repeat;
+  }
+  getTime(channelId) {
+    if (channelId === void 0) {
+      return this.time;
+    }
+    const channel = this.channels.get(channelId);
+    if (channel === void 0) {
+      return -1;
+    }
+    return channel.time;
+  }
+  setTime(time) {
+    this.time = Math.max(0, time);
+    const channels = this.channels.values();
+    for (const channel of channels) {
+      this._setChannelTime(channel, this.time);
+    }
+    const animations = this.animations.values();
+    for (const animationData of animations) {
+      const { animation, channel } = animationData;
+      animation.setTime(this.getTime(channel));
+    }
+  }
+  play() {
+    this.playing = true;
+  }
+  pause() {
+    this.playing = false;
+    this.lastEngineTime = -1;
+  }
+  reset() {
+    this.setTime(0);
+  }
+  attachAnimation(animation, channelHandle) {
+    const animationHandle = animationHandles++;
+    this.animations.set(animationHandle, {
+      animation,
+      channel: channelHandle
+    });
+    animation.setTime(this.getTime(channelHandle));
+    return animationHandle;
+  }
+  detachAnimation(channelId) {
+    this.animations.delete(channelId);
+  }
+  update(engineTime) {
+    if (this.playing) {
+      if (this.lastEngineTime === -1) {
+        this.lastEngineTime = engineTime;
+      }
+      this.setTime(this.time + (engineTime - this.lastEngineTime));
+      this.lastEngineTime = engineTime;
+    }
+  }
+  _setChannelTime(channel, time) {
+    const offsetTime = time - channel.delay;
+    const totalDuration = channel.duration * channel.repeat;
+    if (offsetTime >= totalDuration) {
+      channel.time = channel.duration * channel.rate;
+    } else {
+      channel.time = Math.max(0, offsetTime) % channel.duration;
+      channel.time *= channel.rate;
+    }
+  }
+}
+function requestAnimationFramePolyfill(callback) {
+  return typeof window !== "undefined" && window.requestAnimationFrame ? window.requestAnimationFrame(callback) : setTimeout(callback, 1e3 / 60);
+}
+function cancelAnimationFramePolyfill(timerId) {
+  return typeof window !== "undefined" && window.cancelAnimationFrame ? window.cancelAnimationFrame(timerId) : clearTimeout(timerId);
+}
+let statIdCounter = 0;
+const _AnimationLoop = class _AnimationLoop {
+  // _gpuTimeQuery: Query | null = null;
+  /*
+   * @param {HTMLCanvasElement} canvas - if provided, width and height will be passed to context
+   */
+  constructor(props) {
+    __publicField(this, "device", null);
+    __publicField(this, "canvas", null);
+    __publicField(this, "props");
+    __publicField(this, "animationProps", null);
+    __publicField(this, "timeline", null);
+    __publicField(this, "stats");
+    __publicField(this, "cpuTime");
+    __publicField(this, "gpuTime");
+    __publicField(this, "frameRate");
+    __publicField(this, "display");
+    __publicField(this, "needsRedraw", "initialized");
+    __publicField(this, "_initialized", false);
+    __publicField(this, "_running", false);
+    __publicField(this, "_animationFrameId", null);
+    __publicField(this, "_nextFramePromise", null);
+    __publicField(this, "_resolveNextFrame", null);
+    __publicField(this, "_cpuStartTime", 0);
+    __publicField(this, "_error", null);
+    this.props = { ..._AnimationLoop.defaultAnimationLoopProps, ...props };
+    props = this.props;
+    if (!props.device) {
+      throw new Error("No device provided");
+    }
+    this.stats = props.stats || new Stats({ id: "animation-loop-stats" });
+    this.cpuTime = this.stats.get("CPU Time");
+    this.gpuTime = this.stats.get("GPU Time");
+    this.frameRate = this.stats.get("Frame Rate");
+    this.setProps({ autoResizeViewport: props.autoResizeViewport });
+    this.start = this.start.bind(this);
+    this.stop = this.stop.bind(this);
+    this._onMousemove = this._onMousemove.bind(this);
+    this._onMouseleave = this._onMouseleave.bind(this);
+  }
+  destroy() {
+    this.stop();
+    this._setDisplay(null);
+  }
+  /** @deprecated Use .destroy() */
+  delete() {
+    this.destroy();
+  }
+  reportError(error) {
+    this.props.onError(error);
+    this._error = error;
+  }
+  /** Flags this animation loop as needing redraw */
+  setNeedsRedraw(reason) {
+    this.needsRedraw = this.needsRedraw || reason;
+    return this;
+  }
+  setProps(props) {
+    if ("autoResizeViewport" in props) {
+      this.props.autoResizeViewport = props.autoResizeViewport || false;
+    }
+    return this;
+  }
+  /** Starts a render loop if not already running */
+  async start() {
+    if (this._running) {
+      return this;
+    }
+    this._running = true;
+    try {
+      let appContext;
+      if (!this._initialized) {
+        this._initialized = true;
+        await this._initDevice();
+        this._initialize();
+        await this.props.onInitialize(this._getAnimationProps());
+      }
+      if (!this._running) {
+        return null;
+      }
+      if (appContext !== false) {
+        this._cancelAnimationFrame();
+        this._requestAnimationFrame();
+      }
+      return this;
+    } catch (err) {
+      const error = err instanceof Error ? err : new Error("Unknown error");
+      this.props.onError(error);
+      throw error;
+    }
+  }
+  /** Stops a render loop if already running, finalizing */
+  stop() {
+    if (this._running) {
+      if (this.animationProps && !this._error) {
+        this.props.onFinalize(this.animationProps);
+      }
+      this._cancelAnimationFrame();
+      this._nextFramePromise = null;
+      this._resolveNextFrame = null;
+      this._running = false;
+    }
+    return this;
+  }
+  /** Explicitly draw a frame */
+  redraw() {
+    var _a3;
+    if (((_a3 = this.device) == null ? void 0 : _a3.isLost) || this._error) {
+      return this;
+    }
+    this._beginFrameTimers();
+    this._setupFrame();
+    this._updateAnimationProps();
+    this._renderFrame(this._getAnimationProps());
+    this._clearNeedsRedraw();
+    if (this._resolveNextFrame) {
+      this._resolveNextFrame(this);
+      this._nextFramePromise = null;
+      this._resolveNextFrame = null;
+    }
+    this._endFrameTimers();
+    return this;
+  }
+  /** Add a timeline, it will be automatically updated by the animation loop. */
+  attachTimeline(timeline) {
+    this.timeline = timeline;
+    return this.timeline;
+  }
+  /** Remove a timeline */
+  detachTimeline() {
+    this.timeline = null;
+  }
+  /** Wait until a render completes */
+  waitForRender() {
+    this.setNeedsRedraw("waitForRender");
+    if (!this._nextFramePromise) {
+      this._nextFramePromise = new Promise((resolve) => {
+        this._resolveNextFrame = resolve;
+      });
+    }
+    return this._nextFramePromise;
+  }
+  /** TODO - should use device.deviceContext */
+  async toDataURL() {
+    this.setNeedsRedraw("toDataURL");
+    await this.waitForRender();
+    if (this.canvas instanceof HTMLCanvasElement) {
+      return this.canvas.toDataURL();
+    }
+    throw new Error("OffscreenCanvas");
+  }
+  // PRIVATE METHODS
+  _initialize() {
+    this._startEventHandling();
+    this._initializeAnimationProps();
+    this._updateAnimationProps();
+    this._resizeViewport();
+  }
+  _setDisplay(display) {
+    if (this.display) {
+      this.display.destroy();
+      this.display.animationLoop = null;
+    }
+    if (display) {
+      display.animationLoop = this;
+    }
+    this.display = display;
+  }
+  _requestAnimationFrame() {
+    if (!this._running) {
+      return;
+    }
+    this._animationFrameId = requestAnimationFramePolyfill(this._animationFrame.bind(this));
+  }
+  _cancelAnimationFrame() {
+    if (this._animationFrameId === null) {
+      return;
+    }
+    cancelAnimationFramePolyfill(this._animationFrameId);
+    this._animationFrameId = null;
+  }
+  _animationFrame() {
+    if (!this._running) {
+      return;
+    }
+    this.redraw();
+    this._requestAnimationFrame();
+  }
+  // Called on each frame, can be overridden to call onRender multiple times
+  // to support e.g. stereoscopic rendering
+  _renderFrame(animationProps) {
+    var _a3;
+    if (this.display) {
+      this.display._renderFrame(animationProps);
+      return;
+    }
+    this.props.onRender(this._getAnimationProps());
+    (_a3 = this.device) == null ? void 0 : _a3.submit();
+  }
+  _clearNeedsRedraw() {
+    this.needsRedraw = false;
+  }
+  _setupFrame() {
+    this._resizeViewport();
+  }
+  // Initialize the  object that will be passed to app callbacks
+  _initializeAnimationProps() {
+    var _a3;
+    const canvasContext = (_a3 = this.device) == null ? void 0 : _a3.getDefaultCanvasContext();
+    if (!this.device || !canvasContext) {
+      throw new Error("loop");
+    }
+    const canvas2 = canvasContext == null ? void 0 : canvasContext.canvas;
+    const useDevicePixels = canvasContext.props.useDevicePixels;
+    this.animationProps = {
+      animationLoop: this,
+      device: this.device,
+      canvasContext,
+      canvas: canvas2,
+      // @ts-expect-error Deprecated
+      useDevicePixels,
+      timeline: this.timeline,
+      needsRedraw: false,
+      // Placeholders
+      width: 1,
+      height: 1,
+      aspect: 1,
+      // Animation props
+      time: 0,
+      startTime: Date.now(),
+      engineTime: 0,
+      tick: 0,
+      tock: 0,
+      // Experimental
+      _mousePosition: null
+      // Event props
+    };
+  }
+  _getAnimationProps() {
+    if (!this.animationProps) {
+      throw new Error("animationProps");
+    }
+    return this.animationProps;
+  }
+  // Update the context object that will be passed to app callbacks
+  _updateAnimationProps() {
+    if (!this.animationProps) {
+      return;
+    }
+    const { width, height, aspect } = this._getSizeAndAspect();
+    if (width !== this.animationProps.width || height !== this.animationProps.height) {
+      this.setNeedsRedraw("drawing buffer resized");
+    }
+    if (aspect !== this.animationProps.aspect) {
+      this.setNeedsRedraw("drawing buffer aspect changed");
+    }
+    this.animationProps.width = width;
+    this.animationProps.height = height;
+    this.animationProps.aspect = aspect;
+    this.animationProps.needsRedraw = this.needsRedraw;
+    this.animationProps.engineTime = Date.now() - this.animationProps.startTime;
+    if (this.timeline) {
+      this.timeline.update(this.animationProps.engineTime);
+    }
+    this.animationProps.tick = Math.floor(this.animationProps.time / 1e3 * 60);
+    this.animationProps.tock++;
+    this.animationProps.time = this.timeline ? this.timeline.getTime() : this.animationProps.engineTime;
+  }
+  /** Wait for supplied device */
+  async _initDevice() {
+    this.device = await this.props.device;
+    if (!this.device) {
+      throw new Error("No device provided");
+    }
+    this.canvas = this.device.getDefaultCanvasContext().canvas || null;
+  }
+  _createInfoDiv() {
+    if (this.canvas && this.props.onAddHTML) {
+      const wrapperDiv = document.createElement("div");
+      document.body.appendChild(wrapperDiv);
+      wrapperDiv.style.position = "relative";
+      const div = document.createElement("div");
+      div.style.position = "absolute";
+      div.style.left = "10px";
+      div.style.bottom = "10px";
+      div.style.width = "300px";
+      div.style.background = "white";
+      if (this.canvas instanceof HTMLCanvasElement) {
+        wrapperDiv.appendChild(this.canvas);
+      }
+      wrapperDiv.appendChild(div);
+      const html = this.props.onAddHTML(div);
+      if (html) {
+        div.innerHTML = html;
+      }
+    }
+  }
+  _getSizeAndAspect() {
+    var _a3, _b3;
+    if (!this.device) {
+      return { width: 1, height: 1, aspect: 1 };
+    }
+    const [width, height] = ((_a3 = this.device) == null ? void 0 : _a3.getDefaultCanvasContext().getDevicePixelSize()) || [1, 1];
+    let aspect = 1;
+    const canvas2 = (_b3 = this.device) == null ? void 0 : _b3.getDefaultCanvasContext().canvas;
+    if (canvas2 && canvas2.clientHeight) {
+      aspect = canvas2.clientWidth / canvas2.clientHeight;
+    } else if (width > 0 && height > 0) {
+      aspect = width / height;
+    }
+    return { width, height, aspect };
+  }
+  /** @deprecated Default viewport setup */
+  _resizeViewport() {
+    if (this.props.autoResizeViewport && this.device.gl) {
+      this.device.gl.viewport(
+        0,
+        0,
+        // @ts-expect-error Expose canvasContext
+        this.device.gl.drawingBufferWidth,
+        // @ts-expect-error Expose canvasContext
+        this.device.gl.drawingBufferHeight
+      );
+    }
+  }
+  _beginFrameTimers() {
+    this.frameRate.timeEnd();
+    this.frameRate.timeStart();
+    this.cpuTime.timeStart();
+  }
+  _endFrameTimers() {
+    this.cpuTime.timeEnd();
+  }
+  // Event handling
+  _startEventHandling() {
+    if (this.canvas) {
+      this.canvas.addEventListener("mousemove", this._onMousemove.bind(this));
+      this.canvas.addEventListener("mouseleave", this._onMouseleave.bind(this));
+    }
+  }
+  _onMousemove(event) {
+    if (event instanceof MouseEvent) {
+      this._getAnimationProps()._mousePosition = [event.offsetX, event.offsetY];
+    }
+  }
+  _onMouseleave(event) {
+    this._getAnimationProps()._mousePosition = null;
+  }
+};
+__publicField(_AnimationLoop, "defaultAnimationLoopProps", {
+  device: null,
+  onAddHTML: () => "",
+  onInitialize: async () => null,
+  onRender: () => {
+  },
+  onFinalize: () => {
+  },
+  onError: (error) => console.error(error),
+  // eslint-disable-line no-console
+  stats: luma.stats.get(`animation-loop-${statIdCounter++}`),
+  // view parameters
+  autoResizeViewport: false
+});
+let AnimationLoop = _AnimationLoop;
+const uidCounters$1 = {};
+function uid$1(id2 = "id") {
+  uidCounters$1[id2] = uidCounters$1[id2] || 1;
+  const count2 = uidCounters$1[id2]++;
+  return `${id2}-${count2}`;
+}
+class GPUGeometry {
+  constructor(props) {
+    __publicField(this, "id");
+    __publicField(this, "userData", {});
+    /** Determines how vertices are read from the 'vertex' attributes */
+    __publicField(this, "topology");
+    __publicField(this, "bufferLayout", []);
+    __publicField(this, "vertexCount");
+    __publicField(this, "indices");
+    __publicField(this, "attributes");
+    this.id = props.id || uid$1("geometry");
+    this.topology = props.topology;
+    this.indices = props.indices || null;
+    this.attributes = props.attributes;
+    this.vertexCount = props.vertexCount;
+    this.bufferLayout = props.bufferLayout || [];
+    if (this.indices) {
+      if (!(this.indices.usage & Buffer$1.INDEX)) {
+        throw new Error("Index buffer must have INDEX usage");
+      }
+    }
+  }
+  destroy() {
+    var _a3;
+    (_a3 = this.indices) == null ? void 0 : _a3.destroy();
+    for (const attribute of Object.values(this.attributes)) {
+      attribute.destroy();
+    }
+  }
+  getVertexCount() {
+    return this.vertexCount;
+  }
+  getAttributes() {
+    return this.attributes;
+  }
+  getIndexes() {
+    return this.indices || null;
+  }
+  _calculateVertexCount(positions) {
+    const vertexCount = positions.byteLength / 12;
+    return vertexCount;
+  }
+}
+function makeGPUGeometry(device, geometry2) {
+  if (geometry2 instanceof GPUGeometry) {
+    return geometry2;
+  }
+  const indices = getIndexBufferFromGeometry(device, geometry2);
+  const { attributes, bufferLayout } = getAttributeBuffersFromGeometry(device, geometry2);
+  return new GPUGeometry({
+    topology: geometry2.topology || "triangle-list",
+    bufferLayout,
+    vertexCount: geometry2.vertexCount,
+    indices,
+    attributes
+  });
+}
+function getIndexBufferFromGeometry(device, geometry2) {
+  if (!geometry2.indices) {
+    return void 0;
+  }
+  const data = geometry2.indices.value;
+  return device.createBuffer({ usage: Buffer$1.INDEX, data });
+}
+function getAttributeBuffersFromGeometry(device, geometry2) {
+  const bufferLayout = [];
+  const attributes = {};
+  for (const [attributeName, attribute] of Object.entries(geometry2.attributes)) {
+    let name2 = attributeName;
+    switch (attributeName) {
+      case "POSITION":
+        name2 = "positions";
+        break;
+      case "NORMAL":
+        name2 = "normals";
+        break;
+      case "TEXCOORD_0":
+        name2 = "texCoords";
+        break;
+      case "COLOR_0":
+        name2 = "colors";
+        break;
+    }
+    if (attribute) {
+      attributes[name2] = device.createBuffer({
+        data: attribute.value,
+        id: `${attributeName}-buffer`
+      });
+      const { value, size, normalized } = attribute;
+      bufferLayout.push({ name: name2, format: getVertexFormatFromAttribute(value, size, normalized) });
+    }
+  }
+  const vertexCount = geometry2._calculateVertexCount(geometry2.attributes, geometry2.indices);
+  return { attributes, bufferLayout, vertexCount };
+}
+const _PipelineFactory = class _PipelineFactory {
+  constructor(device) {
+    __publicField(this, "device");
+    __publicField(this, "cachingEnabled");
+    __publicField(this, "destroyPolicy");
+    __publicField(this, "debug");
+    __publicField(this, "_hashCounter", 0);
+    __publicField(this, "_hashes", {});
+    __publicField(this, "_renderPipelineCache", {});
+    __publicField(this, "_computePipelineCache", {});
+    this.device = device;
+    this.cachingEnabled = device.props._cachePipelines;
+    this.destroyPolicy = device.props._cacheDestroyPolicy;
+    this.debug = device.props.debugFactories;
+  }
+  /** Get the singleton default pipeline factory for the specified device */
+  static getDefaultPipelineFactory(device) {
+    device._lumaData["defaultPipelineFactory"] = device._lumaData["defaultPipelineFactory"] || new _PipelineFactory(device);
+    return device._lumaData["defaultPipelineFactory"];
+  }
+  get [Symbol.toStringTag]() {
+    return "PipelineFactory";
+  }
+  toString() {
+    return `PipelineFactory(${this.device.id})`;
+  }
+  /** Return a RenderPipeline matching supplied props. Reuses an equivalent pipeline if already created. */
+  createRenderPipeline(props) {
+    var _a3;
+    if (!this.cachingEnabled) {
+      return this.device.createRenderPipeline(props);
+    }
+    const allProps = { ...RenderPipeline.defaultProps, ...props };
+    const cache = this._renderPipelineCache;
+    const hash = this._hashRenderPipeline(allProps);
+    let pipeline = (_a3 = cache[hash]) == null ? void 0 : _a3.pipeline;
+    if (!pipeline) {
+      pipeline = this.device.createRenderPipeline({
+        ...allProps,
+        id: allProps.id ? `${allProps.id}-cached` : uid$1("unnamed-cached")
+      });
+      pipeline.hash = hash;
+      cache[hash] = { pipeline, useCount: 1 };
+      if (this.debug) {
+        log.log(3, `${this}: ${pipeline} created, count=${cache[hash].useCount}`)();
+      }
+    } else {
+      cache[hash].useCount++;
+      if (this.debug) {
+        log.log(3, `${this}: ${cache[hash].pipeline} reused, count=${cache[hash].useCount}, (id=${props.id})`)();
+      }
+    }
+    return pipeline;
+  }
+  /** Return a ComputePipeline matching supplied props. Reuses an equivalent pipeline if already created. */
+  createComputePipeline(props) {
+    var _a3;
+    if (!this.cachingEnabled) {
+      return this.device.createComputePipeline(props);
+    }
+    const allProps = { ...ComputePipeline.defaultProps, ...props };
+    const cache = this._computePipelineCache;
+    const hash = this._hashComputePipeline(allProps);
+    let pipeline = (_a3 = cache[hash]) == null ? void 0 : _a3.pipeline;
+    if (!pipeline) {
+      pipeline = this.device.createComputePipeline({
+        ...allProps,
+        id: allProps.id ? `${allProps.id}-cached` : void 0
+      });
+      pipeline.hash = hash;
+      cache[hash] = { pipeline, useCount: 1 };
+      if (this.debug) {
+        log.log(3, `${this}: ${pipeline} created, count=${cache[hash].useCount}`)();
+      }
+    } else {
+      cache[hash].useCount++;
+      if (this.debug) {
+        log.log(3, `${this}: ${cache[hash].pipeline} reused, count=${cache[hash].useCount}, (id=${props.id})`)();
+      }
+    }
+    return pipeline;
+  }
+  release(pipeline) {
+    if (!this.cachingEnabled) {
+      pipeline.destroy();
+      return;
+    }
+    const cache = this._getCache(pipeline);
+    const hash = pipeline.hash;
+    cache[hash].useCount--;
+    if (cache[hash].useCount === 0) {
+      this._destroyPipeline(pipeline);
+      if (this.debug) {
+        log.log(3, `${this}: ${pipeline} released and destroyed`)();
+      }
+    } else if (cache[hash].useCount < 0) {
+      log.error(`${this}: ${pipeline} released, useCount < 0, resetting`)();
+      cache[hash].useCount = 0;
+    } else if (this.debug) {
+      log.log(3, `${this}: ${pipeline} released, count=${cache[hash].useCount}`)();
+    }
+  }
+  // PRIVATE
+  /** Destroy a cached pipeline, removing it from the cache (depending on destroy policy) */
+  _destroyPipeline(pipeline) {
+    const cache = this._getCache(pipeline);
+    switch (this.destroyPolicy) {
+      case "never":
+        return false;
+      case "unused":
+        delete cache[pipeline.hash];
+        pipeline.destroy();
+        return true;
+    }
+  }
+  /** Get the appropriate cache for the type of pipeline */
+  _getCache(pipeline) {
+    let cache;
+    if (pipeline instanceof ComputePipeline) {
+      cache = this._computePipelineCache;
+    }
+    if (pipeline instanceof RenderPipeline) {
+      cache = this._renderPipelineCache;
+    }
+    if (!cache) {
+      throw new Error(`${this}`);
+    }
+    if (!cache[pipeline.hash]) {
+      throw new Error(`${this}: ${pipeline} matched incorrect entry`);
+    }
+    return cache;
+  }
+  /** Calculate a hash based on all the inputs for a compute pipeline */
+  _hashComputePipeline(props) {
+    const { type } = this.device;
+    const shaderHash = this._getHash(props.shader.source);
+    return `${type}/C/${shaderHash}`;
+  }
+  /** Calculate a hash based on all the inputs for a render pipeline */
+  _hashRenderPipeline(props) {
+    const vsHash = props.vs ? this._getHash(props.vs.source) : 0;
+    const fsHash = props.fs ? this._getHash(props.fs.source) : 0;
+    const varyingHash = "-";
+    const bufferLayoutHash = this._getHash(JSON.stringify(props.bufferLayout));
+    const { type } = this.device;
+    switch (type) {
+      case "webgl":
+        return `${type}/R/${vsHash}/${fsHash}V${varyingHash}BL${bufferLayoutHash}`;
+      case "webgpu":
+      default:
+        const parameterHash = this._getHash(JSON.stringify(props.parameters));
+        return `${type}/R/${vsHash}/${fsHash}V${varyingHash}T${props.topology}P${parameterHash}BL${bufferLayoutHash}`;
+    }
+  }
+  _getHash(key) {
+    if (this._hashes[key] === void 0) {
+      this._hashes[key] = this._hashCounter++;
+    }
+    return this._hashes[key];
+  }
+};
+__publicField(_PipelineFactory, "defaultProps", { ...RenderPipeline.defaultProps });
+let PipelineFactory = _PipelineFactory;
+const _ShaderFactory = class _ShaderFactory {
+  /** @internal */
+  constructor(device) {
+    __publicField(this, "device");
+    __publicField(this, "cachingEnabled");
+    __publicField(this, "destroyPolicy");
+    __publicField(this, "debug");
+    __publicField(this, "_cache", {});
+    this.device = device;
+    this.cachingEnabled = device.props._cacheShaders;
+    this.destroyPolicy = device.props._cacheDestroyPolicy;
+    this.debug = true;
+  }
+  /** Returns the default ShaderFactory for the given {@link Device}, creating one if necessary. */
+  static getDefaultShaderFactory(device) {
+    var _a3;
+    (_a3 = device._lumaData)["defaultShaderFactory"] || (_a3["defaultShaderFactory"] = new _ShaderFactory(device));
+    return device._lumaData["defaultShaderFactory"];
+  }
+  get [Symbol.toStringTag]() {
+    return "ShaderFactory";
+  }
+  toString() {
+    return `${this[Symbol.toStringTag]}(${this.device.id})`;
+  }
+  /** Requests a {@link Shader} from the cache, creating a new Shader only if necessary. */
+  createShader(props) {
+    if (!this.cachingEnabled) {
+      return this.device.createShader(props);
+    }
+    const key = this._hashShader(props);
+    let cacheEntry = this._cache[key];
+    if (!cacheEntry) {
+      const shader = this.device.createShader({
+        ...props,
+        id: props.id ? `${props.id}-cached` : void 0
+      });
+      this._cache[key] = cacheEntry = { shader, useCount: 1 };
+      if (this.debug) {
+        log.log(3, `${this}: Created new shader ${shader.id}`)();
+      }
+    } else {
+      cacheEntry.useCount++;
+      if (this.debug) {
+        log.log(3, `${this}: Reusing shader ${cacheEntry.shader.id} count=${cacheEntry.useCount}`)();
+      }
+    }
+    return cacheEntry.shader;
+  }
+  /** Releases a previously-requested {@link Shader}, destroying it if no users remain. */
+  release(shader) {
+    if (!this.cachingEnabled) {
+      shader.destroy();
+      return;
+    }
+    const key = this._hashShader(shader);
+    const cacheEntry = this._cache[key];
+    if (cacheEntry) {
+      cacheEntry.useCount--;
+      if (cacheEntry.useCount === 0) {
+        if (this.destroyPolicy === "unused") {
+          delete this._cache[key];
+          cacheEntry.shader.destroy();
+          if (this.debug) {
+            log.log(3, `${this}: Releasing shader ${shader.id}, destroyed`)();
+          }
+        }
+      } else if (cacheEntry.useCount < 0) {
+        throw new Error(`ShaderFactory: Shader ${shader.id} released too many times`);
+      } else if (this.debug) {
+        log.log(3, `${this}: Releasing shader ${shader.id} count=${cacheEntry.useCount}`)();
+      }
+    }
+  }
+  // PRIVATE
+  _hashShader(value) {
+    return `${value.stage}:${value.source}`;
+  }
+};
+__publicField(_ShaderFactory, "defaultProps", { ...Shader.defaultProps });
+let ShaderFactory = _ShaderFactory;
+function getDebugTableForShaderLayout(layout, name2) {
+  var _a3;
+  const table = {};
+  const header = "Values";
+  if (layout.attributes.length === 0 && !((_a3 = layout.varyings) == null ? void 0 : _a3.length)) {
+    return { "No attributes or varyings": { [header]: "N/A" } };
+  }
+  for (const attributeDeclaration of layout.attributes) {
+    if (attributeDeclaration) {
+      const glslDeclaration = `${attributeDeclaration.location} ${attributeDeclaration.name}: ${attributeDeclaration.type}`;
+      table[`in ${glslDeclaration}`] = { [header]: attributeDeclaration.stepMode || "vertex" };
+    }
+  }
+  for (const varyingDeclaration of layout.varyings || []) {
+    const glslDeclaration = `${varyingDeclaration.location} ${varyingDeclaration.name}`;
+    table[`out ${glslDeclaration}`] = { [header]: JSON.stringify(varyingDeclaration) };
+  }
+  return table;
+}
+let canvas = null;
+let ctx = null;
+function debugFramebuffer(fbo, { id: id2, minimap, opaque, top = "0", left = "0", rgbaScale = 1 }) {
+  if (!canvas) {
+    canvas = document.createElement("canvas");
+    canvas.id = id2;
+    canvas.title = id2;
+    canvas.style.zIndex = "100";
+    canvas.style.position = "absolute";
+    canvas.style.top = top;
+    canvas.style.left = left;
+    canvas.style.border = "blue 5px solid";
+    canvas.style.transform = "scaleY(-1)";
+    document.body.appendChild(canvas);
+    ctx = canvas.getContext("2d");
+  }
+  if (canvas.width !== fbo.width || canvas.height !== fbo.height) {
+    canvas.width = fbo.width / 2;
+    canvas.height = fbo.height / 2;
+    canvas.style.width = "400px";
+    canvas.style.height = "400px";
+  }
+  const color2 = fbo.device.readPixelsToArrayWebGL(fbo);
+  const imageData = ctx == null ? void 0 : ctx.createImageData(fbo.width, fbo.height);
+  if (imageData) {
+    const offset = 0;
+    for (let i2 = 0; i2 < color2.length; i2 += 4) {
+      imageData.data[offset + i2 + 0] = color2[i2 + 0] * rgbaScale;
+      imageData.data[offset + i2 + 1] = color2[i2 + 1] * rgbaScale;
+      imageData.data[offset + i2 + 2] = color2[i2 + 2] * rgbaScale;
+      imageData.data[offset + i2 + 3] = opaque ? 255 : color2[i2 + 3] * rgbaScale;
+    }
+    ctx == null ? void 0 : ctx.putImageData(imageData, 0, 0);
+  }
+}
+function deepEqual$1(a2, b2, depth) {
+  if (a2 === b2) {
+    return true;
+  }
+  if (!depth || !a2 || !b2) {
+    return false;
+  }
+  if (Array.isArray(a2)) {
+    if (!Array.isArray(b2) || a2.length !== b2.length) {
+      return false;
+    }
+    for (let i2 = 0; i2 < a2.length; i2++) {
+      if (!deepEqual$1(a2[i2], b2[i2], depth - 1)) {
+        return false;
+      }
+    }
+    return true;
+  }
+  if (Array.isArray(b2)) {
+    return false;
+  }
+  if (typeof a2 === "object" && typeof b2 === "object") {
+    const aKeys = Object.keys(a2);
+    const bKeys = Object.keys(b2);
+    if (aKeys.length !== bKeys.length) {
+      return false;
+    }
+    for (const key of aKeys) {
+      if (!b2.hasOwnProperty(key)) {
+        return false;
+      }
+      if (!deepEqual$1(a2[key], b2[key], depth - 1)) {
+        return false;
+      }
+    }
+    return true;
+  }
+  return false;
+}
+class BufferLayoutHelper {
+  constructor(bufferLayouts) {
+    __publicField(this, "bufferLayouts");
+    this.bufferLayouts = bufferLayouts;
+  }
+  getBufferLayout(name2) {
+    return this.bufferLayouts.find((layout) => layout.name === name2) || null;
+  }
+  /** Get attribute names from a BufferLayout */
+  getAttributeNamesForBuffer(bufferLayout) {
+    var _a3;
+    return bufferLayout.attributes ? (_a3 = bufferLayout.attributes) == null ? void 0 : _a3.map((layout) => layout.attribute) : [bufferLayout.name];
+  }
+  mergeBufferLayouts(bufferLayouts1, bufferLayouts2) {
+    const mergedLayouts = [...bufferLayouts1];
+    for (const attribute of bufferLayouts2) {
+      const index = mergedLayouts.findIndex((attribute2) => attribute2.name === attribute.name);
+      if (index < 0) {
+        mergedLayouts.push(attribute);
+      } else {
+        mergedLayouts[index] = attribute;
+      }
+    }
+    return mergedLayouts;
+  }
+  getBufferIndex(bufferName) {
+    const bufferIndex = this.bufferLayouts.findIndex((layout) => layout.name === bufferName);
+    if (bufferIndex === -1) {
+      log.warn(`BufferLayout: Missing buffer for "${bufferName}".`)();
+    }
+    return bufferIndex;
+  }
+}
+function sortedBufferLayoutByShaderSourceLocations(shaderLayout, bufferLayout) {
+  const shaderLayoutMap = Object.fromEntries(shaderLayout.attributes.map((attr) => [attr.name, attr.location]));
+  const sortedLayout = bufferLayout.slice();
+  sortedLayout.sort((a2, b2) => {
+    const attributeNamesA = a2.attributes ? a2.attributes.map((attr) => attr.attribute) : [a2.name];
+    const attributeNamesB = b2.attributes ? b2.attributes.map((attr) => attr.attribute) : [b2.name];
+    const minLocationA = Math.min(...attributeNamesA.map((name2) => shaderLayoutMap[name2]));
+    const minLocationB = Math.min(...attributeNamesB.map((name2) => shaderLayoutMap[name2]));
+    return minLocationA - minLocationB;
+  });
+  return sortedLayout;
+}
+function isTypedArray(value) {
+  return ArrayBuffer.isView(value) && !(value instanceof DataView);
+}
+function isNumberArray(value) {
+  if (Array.isArray(value)) {
+    return value.length === 0 || typeof value[0] === "number";
+  }
+  return false;
+}
+function isNumericArray(value) {
+  return isTypedArray(value) || isNumberArray(value);
+}
+function isUniformValue(value) {
+  return isNumericArray(value) || typeof value === "number" || typeof value === "boolean";
+}
+function splitUniformsAndBindings(uniforms) {
+  const result = { bindings: {}, uniforms: {} };
+  Object.keys(uniforms).forEach((name2) => {
+    const uniform = uniforms[name2];
+    if (isUniformValue(uniform)) {
+      result.uniforms[name2] = uniform;
+    } else {
+      result.bindings[name2] = uniform;
+    }
+  });
+  return result;
+}
+class ShaderInputs {
+  /** Tracks if uniforms have changed */
+  // moduleUniformsChanged: Record<keyof ShaderPropsT, false | string>;
+  /**
+   * Create a new UniformStore instance
+   * @param modules
+   */
+  constructor(modules, options) {
+    __publicField(this, "options", {
+      disableWarnings: false
+    });
+    /**
+     * The map of modules
+     * @todo should should this include the resolved dependencies?
+     */
+    // @ts-ignore Fix typings
+    __publicField(this, "modules");
+    /** Stores the uniform values for each module */
+    __publicField(this, "moduleUniforms");
+    /** Stores the uniform bindings for each module  */
+    __publicField(this, "moduleBindings");
+    Object.assign(this.options, options);
+    const resolvedModules = getShaderModuleDependencies(Object.values(modules).filter((module) => module.dependencies));
+    for (const resolvedModule of resolvedModules) {
+      modules[resolvedModule.name] = resolvedModule;
+    }
+    log.log(1, "Creating ShaderInputs with modules", Object.keys(modules))();
+    this.modules = modules;
+    this.moduleUniforms = {};
+    this.moduleBindings = {};
+    for (const [name2, module] of Object.entries(modules)) {
+      this._addModule(module);
+      if (module.name && name2 !== module.name && !this.options.disableWarnings) {
+        log.warn(`Module name: ${name2} vs ${module.name}`)();
+      }
+    }
+  }
+  /** Destroy */
+  destroy() {
+  }
+  /**
+   * Set module props
+   */
+  setProps(props) {
+    var _a3;
+    for (const name2 of Object.keys(props)) {
+      const moduleName = name2;
+      const moduleProps = props[moduleName] || {};
+      const module = this.modules[moduleName];
+      if (!module) {
+        if (!this.options.disableWarnings) {
+          log.warn(`Module ${name2} not found`)();
+        }
+        continue;
+      }
+      const oldUniforms = this.moduleUniforms[moduleName];
+      const oldBindings = this.moduleBindings[moduleName];
+      const uniformsAndBindings = ((_a3 = module.getUniforms) == null ? void 0 : _a3.call(module, moduleProps, oldUniforms)) || moduleProps;
+      const { uniforms, bindings } = splitUniformsAndBindings(uniformsAndBindings);
+      this.moduleUniforms[moduleName] = { ...oldUniforms, ...uniforms };
+      this.moduleBindings[moduleName] = { ...oldBindings, ...bindings };
+    }
+  }
+  /**
+   * Return the map of modules
+   * @todo should should this include the resolved dependencies?
+   */
+  getModules() {
+    return Object.values(this.modules);
+  }
+  /** Get all uniform values for all modules */
+  getUniformValues() {
+    return this.moduleUniforms;
+  }
+  /** Merges all bindings for the shader (from the various modules) */
+  getBindingValues() {
+    const bindings = {};
+    for (const moduleBindings of Object.values(this.moduleBindings)) {
+      Object.assign(bindings, moduleBindings);
+    }
+    return bindings;
+  }
+  // INTERNAL
+  /** Return a debug table that can be used for console.table() or log.table() */
+  getDebugTable() {
+    var _a3;
+    const table = {};
+    for (const [moduleName, module] of Object.entries(this.moduleUniforms)) {
+      for (const [key, value] of Object.entries(module)) {
+        table[`${moduleName}.${key}`] = {
+          type: (_a3 = this.modules[moduleName].uniformTypes) == null ? void 0 : _a3[key],
+          value: String(value)
+        };
+      }
+    }
+    return table;
+  }
+  _addModule(module) {
+    const moduleName = module.name;
+    this.moduleUniforms[moduleName] = module.defaultUniforms || {};
+    this.moduleBindings[moduleName] = {};
+  }
+}
+let pathPrefix = "";
+async function loadImageBitmap(url, opts) {
+  const image = new Image();
+  image.crossOrigin = "anonymous";
+  image.src = url.startsWith("http") ? url : pathPrefix + url;
+  await image.decode();
+  return opts ? await createImageBitmap(image, opts) : await createImageBitmap(image);
+}
+const TextureCubeFaces = ["+X", "-X", "+Y", "-Y", "+Z", "-Z"];
+const CubeFaces = ["+X", "-X", "+Y", "-Y", "+Z", "-Z"];
+const _AsyncTexture = class _AsyncTexture {
+  constructor(device, props) {
+    __publicField(this, "device");
+    __publicField(this, "id");
+    __publicField(this, "props");
+    // TODO - should we type these as possibly `null`? It will make usage harder?
+    // @ts-expect-error
+    __publicField(this, "texture");
+    // @ts-expect-error
+    __publicField(this, "sampler");
+    // @ts-expect-error
+    __publicField(this, "view");
+    __publicField(this, "ready");
+    __publicField(this, "isReady", false);
+    __publicField(this, "destroyed", false);
+    __publicField(this, "resolveReady", () => {
+    });
+    __publicField(this, "rejectReady", () => {
+    });
+    this.device = device;
+    const id2 = uid$1("async-texture");
+    this.props = { ..._AsyncTexture.defaultProps, id: id2, ...props };
+    this.id = this.props.id;
+    props = { ...props };
+    if (typeof (props == null ? void 0 : props.data) === "string" && props.dimension === "2d") {
+      props.data = loadImageBitmap(props.data);
+    }
+    if (props.mipmaps) {
+      props.mipLevels = "auto";
+    }
+    this.ready = new Promise((resolve, reject) => {
+      this.resolveReady = () => {
+        this.isReady = true;
+        resolve();
+      };
+      this.rejectReady = reject;
+    });
+    this.initAsync(props);
+  }
+  get [Symbol.toStringTag]() {
+    return "AsyncTexture";
+  }
+  toString() {
+    return `AsyncTexture:"${this.id}"(${this.isReady ? "ready" : "loading"})`;
+  }
+  async initAsync(props) {
+    const asyncData = props.data;
+    const data = await awaitAllPromises(asyncData).then(void 0, this.rejectReady);
+    if (this.destroyed) {
+      return;
+    }
+    const size = this.props.width && this.props.height ? { width: this.props.width, height: this.props.height } : this.getTextureDataSize(data);
+    if (!size) {
+      throw new Error("Texture size could not be determined");
+    }
+    const syncProps = { ...size, ...props, data: void 0, mipLevels: 1 };
+    const maxMips = this.device.getMipLevelCount(syncProps.width, syncProps.height);
+    syncProps.mipLevels = this.props.mipLevels === "auto" ? maxMips : Math.min(maxMips, this.props.mipLevels);
+    this.texture = this.device.createTexture(syncProps);
+    this.sampler = this.texture.sampler;
+    this.view = this.texture.view;
+    if (props.data) {
+      switch (this.props.dimension) {
+        case "1d":
+          this._setTexture1DData(this.texture, data);
+          break;
+        case "2d":
+          this._setTexture2DData(data);
+          break;
+        case "3d":
+          this._setTexture3DData(this.texture, data);
+          break;
+        case "2d-array":
+          this._setTextureArrayData(this.texture, data);
+          break;
+        case "cube":
+          this._setTextureCubeData(this.texture, data);
+          break;
+        case "cube-array":
+          this._setTextureCubeArrayData(this.texture, data);
+          break;
+      }
+    }
+    if (this.props.mipmaps) {
+      this.generateMipmaps();
+    }
+    log.info(1, `${this} loaded`);
+    this.resolveReady();
+  }
+  destroy() {
+    if (this.texture) {
+      this.texture.destroy();
+      this.texture = null;
+    }
+    this.destroyed = true;
+  }
+  generateMipmaps() {
+    this.texture.generateMipmapsWebGL();
+  }
+  /** Set sampler or create and set new Sampler from SamplerProps */
+  setSampler(sampler = {}) {
+    this.texture.setSampler(sampler instanceof Sampler ? sampler : this.device.createSampler(sampler));
+  }
+  /**
+   * Textures are immutable and cannot be resized after creation,
+   * but we can create a similar texture with the same parameters but a new size.
+   * @note Does not copy contents of the texture
+   * @note Mipmaps may need to be regenerated after resizing / setting new data
+   * @todo Abort pending promise and create a texture with the new size?
+   */
+  resize(size) {
+    if (!this.isReady) {
+      throw new Error("Cannot resize texture before it is ready");
+    }
+    if (size.width === this.texture.width && size.height === this.texture.height) {
+      return false;
+    }
+    if (this.texture) {
+      const texture = this.texture;
+      this.texture = texture.clone(size);
+      texture.destroy();
+    }
+    return true;
+  }
+  /** Check if texture data is a typed array */
+  isTextureLevelData(data) {
+    const typedArray = data == null ? void 0 : data.data;
+    return ArrayBuffer.isView(typedArray);
+  }
+  /** Get the size of the texture described by the provided TextureData */
+  getTextureDataSize(data) {
+    if (!data) {
+      return null;
+    }
+    if (ArrayBuffer.isView(data)) {
+      return null;
+    }
+    if (Array.isArray(data)) {
+      return this.getTextureDataSize(data[0]);
+    }
+    if (this.device.isExternalImage(data)) {
+      return this.device.getExternalImageSize(data);
+    }
+    if (data && typeof data === "object" && data.constructor === Object) {
+      const textureDataArray = Object.values(data);
+      const untypedData = textureDataArray[0];
+      return { width: untypedData.width, height: untypedData.height };
+    }
+    throw new Error("texture size deduction failed");
+  }
+  /** Convert luma.gl cubemap face constants to depth index */
+  getCubeFaceDepth(face) {
+    switch (face) {
+      case "+X":
+        return 0;
+      case "-X":
+        return 1;
+      case "+Y":
+        return 2;
+      case "-Y":
+        return 3;
+      case "+Z":
+        return 4;
+      case "-Z":
+        return 5;
+      default:
+        throw new Error(face);
+    }
+  }
+  // EXPERIMENTAL
+  setTextureData(data) {
+  }
+  /** Experimental: Set multiple mip levels */
+  _setTexture1DData(texture, data) {
+    throw new Error("setTexture1DData not supported in WebGL.");
+  }
+  /** Experimental: Set multiple mip levels */
+  _setTexture2DData(lodData, depth = 0) {
+    if (!this.texture) {
+      throw new Error("Texture not initialized");
+    }
+    const lodArray = this._normalizeTextureData(lodData);
+    if (lodArray.length > 1 && this.props.mipmaps !== false) {
+      log.warn(`Texture ${this.id} mipmap and multiple LODs.`)();
+    }
+    for (let mipLevel = 0; mipLevel < lodArray.length; mipLevel++) {
+      const imageData = lodArray[mipLevel];
+      if (this.device.isExternalImage(imageData)) {
+        this.texture.copyExternalImage({ image: imageData, depth, mipLevel, flipY: true });
+      } else {
+        this.texture.copyImageData({ data: imageData.data, mipLevel });
+      }
+    }
+  }
+  /**
+   * Experimental: Sets 3D texture data: multiple depth slices, multiple mip levels
+   * @param data
+   */
+  _setTexture3DData(texture, data) {
+    var _a3;
+    if (((_a3 = this.texture) == null ? void 0 : _a3.props.dimension) !== "3d") {
+      throw new Error(this.id);
+    }
+    for (let depth = 0; depth < data.length; depth++) {
+      this._setTexture2DData(data[depth], depth);
+    }
+  }
+  /**
+   * Experimental: Set Cube texture data, multiple faces, multiple mip levels
+   * @todo - could support TextureCubeArray with depth
+   * @param data
+   * @param index
+   */
+  _setTextureCubeData(texture, data) {
+    var _a3;
+    if (((_a3 = this.texture) == null ? void 0 : _a3.props.dimension) !== "cube") {
+      throw new Error(this.id);
+    }
+    for (const [face, faceData] of Object.entries(data)) {
+      const faceDepth = CubeFaces.indexOf(face);
+      this._setTexture2DData(faceData, faceDepth);
+    }
+  }
+  /**
+   * Experimental: Sets texture array data, multiple levels, multiple depth slices
+   * @param data
+   */
+  _setTextureArrayData(texture, data) {
+    var _a3;
+    if (((_a3 = this.texture) == null ? void 0 : _a3.props.dimension) !== "2d-array") {
+      throw new Error(this.id);
+    }
+    for (let depth = 0; depth < data.length; depth++) {
+      this._setTexture2DData(data[depth], depth);
+    }
+  }
+  /**
+   * Experimental: Sets texture cube array, multiple faces, multiple levels, multiple mip levels
+   * @param data
+   */
+  _setTextureCubeArrayData(texture, data) {
+    throw new Error("setTextureCubeArrayData not supported in WebGL2.");
+  }
+  /** Experimental */
+  _setTextureCubeFaceData(texture, lodData, face, depth = 0) {
+    if (Array.isArray(lodData) && lodData.length > 1 && this.props.mipmaps !== false) {
+      log.warn(`${this.id} has mipmap and multiple LODs.`)();
+    }
+    const faceDepth = TextureCubeFaces.indexOf(face);
+    this._setTexture2DData(lodData, faceDepth);
+  }
+  /**
+   * Normalize TextureData to an array of TextureImageData / ExternalImages
+   * @param data
+   * @param options
+   * @returns array of TextureImageData / ExternalImages
+   */
+  _normalizeTextureData(data) {
+    const options = this.texture;
+    let mipLevelArray;
+    if (ArrayBuffer.isView(data)) {
+      mipLevelArray = [
+        {
+          // ts-expect-error does data really need to be Uint8ClampedArray?
+          data,
+          width: options.width,
+          height: options.height
+          // depth: options.depth
+        }
+      ];
+    } else if (!Array.isArray(data)) {
+      mipLevelArray = [data];
+    } else {
+      mipLevelArray = data;
+    }
+    return mipLevelArray;
+  }
+};
+__publicField(_AsyncTexture, "defaultProps", {
+  ...Texture.defaultProps,
+  data: null,
+  mipmaps: false
+});
+let AsyncTexture = _AsyncTexture;
+async function awaitAllPromises(x2) {
+  x2 = await x2;
+  if (Array.isArray(x2)) {
+    return await Promise.all(x2.map(awaitAllPromises));
+  }
+  if (x2 && typeof x2 === "object" && x2.constructor === Object) {
+    const object = x2;
+    const values = await Promise.all(Object.values(object));
+    const keys = Object.keys(object);
+    const resolvedObject = {};
+    for (let i2 = 0; i2 < keys.length; i2++) {
+      resolvedObject[keys[i2]] = values[i2];
+    }
+    return resolvedObject;
+  }
+  return x2;
+}
+const LOG_DRAW_PRIORITY = 2;
+const LOG_DRAW_TIMEOUT = 1e4;
+const _Model = class _Model {
+  constructor(device, props) {
+    __publicField(this, "device");
+    __publicField(this, "id");
+    // @ts-expect-error assigned in function called from constructor
+    __publicField(this, "source");
+    // @ts-expect-error assigned in function called from constructor
+    __publicField(this, "vs");
+    // @ts-expect-error assigned in function called from constructor
+    __publicField(this, "fs");
+    __publicField(this, "pipelineFactory");
+    __publicField(this, "shaderFactory");
+    __publicField(this, "userData", {});
+    // Fixed properties (change can trigger pipeline rebuild)
+    /** The render pipeline GPU parameters, depth testing etc */
+    __publicField(this, "parameters");
+    /** The primitive topology */
+    __publicField(this, "topology");
+    /** Buffer layout */
+    __publicField(this, "bufferLayout");
+    // Dynamic properties
+    /** Use instanced rendering */
+    __publicField(this, "isInstanced");
+    /** instance count. `undefined` means not instanced */
+    __publicField(this, "instanceCount", 0);
+    /** Vertex count */
+    __publicField(this, "vertexCount");
+    /** Index buffer */
+    __publicField(this, "indexBuffer", null);
+    /** Buffer-valued attributes */
+    __publicField(this, "bufferAttributes", {});
+    /** Constant-valued attributes */
+    __publicField(this, "constantAttributes", {});
+    /** Bindings (textures, samplers, uniform buffers) */
+    __publicField(this, "bindings", {});
+    /**
+     * VertexArray
+     * @note not implemented: if bufferLayout is updated, vertex array has to be rebuilt!
+     * @todo - allow application to define multiple vertex arrays?
+     * */
+    __publicField(this, "vertexArray");
+    /** TransformFeedback, WebGL 2 only. */
+    __publicField(this, "transformFeedback", null);
+    /** The underlying GPU "program". @note May be recreated if parameters change */
+    __publicField(this, "pipeline");
+    /** ShaderInputs instance */
+    // @ts-expect-error Assigned in function called by constructor
+    __publicField(this, "shaderInputs");
+    // @ts-expect-error Assigned in function called by constructor
+    __publicField(this, "_uniformStore");
+    __publicField(this, "_attributeInfos", {});
+    __publicField(this, "_gpuGeometry", null);
+    __publicField(this, "props");
+    __publicField(this, "_pipelineNeedsUpdate", "newly created");
+    __publicField(this, "_needsRedraw", "initializing");
+    __publicField(this, "_destroyed", false);
+    /** "Time" of last draw. Monotonically increasing timestamp */
+    __publicField(this, "_lastDrawTimestamp", -1);
+    /** Throttle draw call logging */
+    __publicField(this, "_lastLogTime", 0);
+    __publicField(this, "_logOpen", false);
+    __publicField(this, "_drawCount", 0);
+    var _a3, _b3, _c3, _d2;
+    this.props = { ..._Model.defaultProps, ...props };
+    props = this.props;
+    this.id = props.id || uid$1("model");
+    this.device = device;
+    Object.assign(this.userData, props.userData);
+    const moduleMap = Object.fromEntries(((_a3 = this.props.modules) == null ? void 0 : _a3.map((module) => [module.name, module])) || []);
+    const shaderInputs = props.shaderInputs || new ShaderInputs(moduleMap, { disableWarnings: this.props.disableWarnings });
+    this.setShaderInputs(shaderInputs);
+    const platformInfo = getPlatformInfo(device);
+    const modules = (
+      // @ts-ignore shaderInputs is assigned in setShaderInputs above.
+      (((_b3 = this.props.modules) == null ? void 0 : _b3.length) > 0 ? this.props.modules : (_c3 = this.shaderInputs) == null ? void 0 : _c3.getModules()) || []
+    );
+    const isWebGPU = this.device.type === "webgpu";
+    if (isWebGPU && this.props.source) {
+      const { source: source2, getUniforms: getUniforms2 } = this.props.shaderAssembler.assembleWGSLShader({
+        platformInfo,
+        ...this.props,
+        modules
+      });
+      this.source = source2;
+      this._getModuleUniforms = getUniforms2;
+      (_d2 = this.props).shaderLayout || (_d2.shaderLayout = getShaderLayoutFromWGSL(this.source));
+    } else {
+      const { vs: vs2, fs: fs2, getUniforms: getUniforms2 } = this.props.shaderAssembler.assembleGLSLShaderPair({
+        platformInfo,
+        ...this.props,
+        modules
+      });
+      this.vs = vs2;
+      this.fs = fs2;
+      this._getModuleUniforms = getUniforms2;
+    }
+    this.vertexCount = this.props.vertexCount;
+    this.instanceCount = this.props.instanceCount;
+    this.topology = this.props.topology;
+    this.bufferLayout = this.props.bufferLayout;
+    this.parameters = this.props.parameters;
+    if (props.geometry) {
+      this.setGeometry(props.geometry);
+    }
+    this.pipelineFactory = props.pipelineFactory || PipelineFactory.getDefaultPipelineFactory(this.device);
+    this.shaderFactory = props.shaderFactory || ShaderFactory.getDefaultShaderFactory(this.device);
+    this.pipeline = this._updatePipeline();
+    this.vertexArray = device.createVertexArray({
+      shaderLayout: this.pipeline.shaderLayout,
+      bufferLayout: this.pipeline.bufferLayout
+    });
+    if (this._gpuGeometry) {
+      this._setGeometryAttributes(this._gpuGeometry);
+    }
+    if ("isInstanced" in props) {
+      this.isInstanced = props.isInstanced;
+    }
+    if (props.instanceCount) {
+      this.setInstanceCount(props.instanceCount);
+    }
+    if (props.vertexCount) {
+      this.setVertexCount(props.vertexCount);
+    }
+    if (props.indexBuffer) {
+      this.setIndexBuffer(props.indexBuffer);
+    }
+    if (props.attributes) {
+      this.setAttributes(props.attributes);
+    }
+    if (props.constantAttributes) {
+      this.setConstantAttributes(props.constantAttributes);
+    }
+    if (props.bindings) {
+      this.setBindings(props.bindings);
+    }
+    if (props.transformFeedback) {
+      this.transformFeedback = props.transformFeedback;
+    }
+    Object.seal(this);
+  }
+  get [Symbol.toStringTag]() {
+    return "Model";
+  }
+  toString() {
+    return `Model(${this.id})`;
+  }
+  destroy() {
+    var _a3;
+    if (!this._destroyed) {
+      this.pipelineFactory.release(this.pipeline);
+      this.shaderFactory.release(this.pipeline.vs);
+      if (this.pipeline.fs) {
+        this.shaderFactory.release(this.pipeline.fs);
+      }
+      this._uniformStore.destroy();
+      (_a3 = this._gpuGeometry) == null ? void 0 : _a3.destroy();
+      this._destroyed = true;
+    }
+  }
+  // Draw call
+  /** Query redraw status. Clears the status. */
+  needsRedraw() {
+    if (this._getBindingsUpdateTimestamp() > this._lastDrawTimestamp) {
+      this.setNeedsRedraw("contents of bound textures or buffers updated");
+    }
+    const needsRedraw = this._needsRedraw;
+    this._needsRedraw = false;
+    return needsRedraw;
+  }
+  /** Mark the model as needing a redraw */
+  setNeedsRedraw(reason) {
+    this._needsRedraw || (this._needsRedraw = reason);
+  }
+  predraw() {
+    this.updateShaderInputs();
+    this.pipeline = this._updatePipeline();
+  }
+  draw(renderPass) {
+    const loadingBinding = this._areBindingsLoading();
+    if (loadingBinding) {
+      log.info(LOG_DRAW_PRIORITY, `>>> DRAWING ABORTED ${this.id}: ${loadingBinding} not loaded`)();
+      return false;
+    }
+    try {
+      renderPass.pushDebugGroup(`${this}.predraw(${renderPass})`);
+      this.predraw();
+    } finally {
+      renderPass.popDebugGroup();
+    }
+    let drawSuccess;
+    try {
+      renderPass.pushDebugGroup(`${this}.draw(${renderPass})`);
+      this._logDrawCallStart();
+      this.pipeline = this._updatePipeline();
+      const syncBindings = this._getBindings();
+      this.pipeline.setBindings(syncBindings, {
+        disableWarnings: this.props.disableWarnings
+      });
+      const { indexBuffer } = this.vertexArray;
+      const indexCount = indexBuffer ? indexBuffer.byteLength / (indexBuffer.indexType === "uint32" ? 4 : 2) : void 0;
+      drawSuccess = this.pipeline.draw({
+        renderPass,
+        vertexArray: this.vertexArray,
+        isInstanced: this.isInstanced,
+        vertexCount: this.vertexCount,
+        instanceCount: this.instanceCount,
+        indexCount,
+        transformFeedback: this.transformFeedback || void 0,
+        // WebGL shares underlying cached pipelines even for models that have different parameters and topology,
+        // so we must provide our unique parameters to each draw
+        // (In WebGPU most parameters are encoded in the pipeline and cannot be changed per draw call)
+        parameters: this.parameters,
+        topology: this.topology
+      });
+    } finally {
+      renderPass.popDebugGroup();
+      this._logDrawCallEnd();
+    }
+    this._logFramebuffer(renderPass);
+    if (drawSuccess) {
+      this._lastDrawTimestamp = this.device.timestamp;
+      this._needsRedraw = false;
+    } else {
+      this._needsRedraw = "waiting for resource initialization";
+    }
+    return drawSuccess;
+  }
+  // Update fixed fields (can trigger pipeline rebuild)
+  /**
+   * Updates the optional geometry
+   * Geometry, set topology and bufferLayout
+   * @note Can trigger a pipeline rebuild / pipeline cache fetch on WebGPU
+   */
+  setGeometry(geometry2) {
+    var _a3;
+    (_a3 = this._gpuGeometry) == null ? void 0 : _a3.destroy();
+    const gpuGeometry = geometry2 && makeGPUGeometry(this.device, geometry2);
+    if (gpuGeometry) {
+      this.setTopology(gpuGeometry.topology || "triangle-list");
+      const bufferLayoutHelper = new BufferLayoutHelper(this.bufferLayout);
+      this.bufferLayout = bufferLayoutHelper.mergeBufferLayouts(gpuGeometry.bufferLayout, this.bufferLayout);
+      if (this.vertexArray) {
+        this._setGeometryAttributes(gpuGeometry);
+      }
+    }
+    this._gpuGeometry = gpuGeometry;
+  }
+  /**
+   * Updates the primitive topology ('triangle-list', 'triangle-strip' etc).
+   * @note Triggers a pipeline rebuild / pipeline cache fetch on WebGPU
+   */
+  setTopology(topology) {
+    if (topology !== this.topology) {
+      this.topology = topology;
+      this._setPipelineNeedsUpdate("topology");
+    }
+  }
+  /**
+   * Updates the buffer layout.
+   * @note Triggers a pipeline rebuild / pipeline cache fetch
+   */
+  setBufferLayout(bufferLayout) {
+    const bufferLayoutHelper = new BufferLayoutHelper(this.bufferLayout);
+    this.bufferLayout = this._gpuGeometry ? bufferLayoutHelper.mergeBufferLayouts(bufferLayout, this._gpuGeometry.bufferLayout) : bufferLayout;
+    this._setPipelineNeedsUpdate("bufferLayout");
+    this.pipeline = this._updatePipeline();
+    this.vertexArray = this.device.createVertexArray({
+      shaderLayout: this.pipeline.shaderLayout,
+      bufferLayout: this.pipeline.bufferLayout
+    });
+    if (this._gpuGeometry) {
+      this._setGeometryAttributes(this._gpuGeometry);
+    }
+  }
+  /**
+   * Set GPU parameters.
+   * @note Can trigger a pipeline rebuild / pipeline cache fetch.
+   * @param parameters
+   */
+  setParameters(parameters) {
+    if (!deepEqual$1(parameters, this.parameters, 2)) {
+      this.parameters = parameters;
+      this._setPipelineNeedsUpdate("parameters");
+    }
+  }
+  // Update dynamic fields
+  /**
+   * Updates the instance count (used in draw calls)
+   * @note Any attributes with stepMode=instance need to be at least this big
+   */
+  setInstanceCount(instanceCount) {
+    this.instanceCount = instanceCount;
+    if (this.isInstanced === void 0 && instanceCount > 0) {
+      this.isInstanced = true;
+    }
+    this.setNeedsRedraw("instanceCount");
+  }
+  /**
+   * Updates the vertex count (used in draw calls)
+   * @note Any attributes with stepMode=vertex need to be at least this big
+   */
+  setVertexCount(vertexCount) {
+    this.vertexCount = vertexCount;
+    this.setNeedsRedraw("vertexCount");
+  }
+  /** Set the shader inputs */
+  setShaderInputs(shaderInputs) {
+    this.shaderInputs = shaderInputs;
+    this._uniformStore = new UniformStore(this.shaderInputs.modules);
+    for (const [moduleName, module] of Object.entries(this.shaderInputs.modules)) {
+      if (shaderModuleHasUniforms(module)) {
+        const uniformBuffer = this._uniformStore.getManagedUniformBuffer(this.device, moduleName);
+        this.bindings[`${moduleName}Uniforms`] = uniformBuffer;
+      }
+    }
+    this.setNeedsRedraw("shaderInputs");
+  }
+  /** Update uniform buffers from the model's shader inputs */
+  updateShaderInputs() {
+    this._uniformStore.setUniforms(this.shaderInputs.getUniformValues());
+    this.setBindings(this.shaderInputs.getBindingValues());
+    this.setNeedsRedraw("shaderInputs");
+  }
+  /**
+   * Sets bindings (textures, samplers, uniform buffers)
+   */
+  setBindings(bindings) {
+    Object.assign(this.bindings, bindings);
+    this.setNeedsRedraw("bindings");
+  }
+  /**
+   * Updates optional transform feedback. WebGL only.
+   */
+  setTransformFeedback(transformFeedback) {
+    this.transformFeedback = transformFeedback;
+    this.setNeedsRedraw("transformFeedback");
+  }
+  /**
+   * Sets the index buffer
+   * @todo - how to unset it if we change geometry?
+   */
+  setIndexBuffer(indexBuffer) {
+    this.vertexArray.setIndexBuffer(indexBuffer);
+    this.setNeedsRedraw("indexBuffer");
+  }
+  /**
+   * Sets attributes (buffers)
+   * @note Overrides any attributes previously set with the same name
+   */
+  setAttributes(buffers, options) {
+    const disableWarnings = (options == null ? void 0 : options.disableWarnings) ?? this.props.disableWarnings;
+    if (buffers["indices"]) {
+      log.warn(`Model:${this.id} setAttributes() - indexBuffer should be set using setIndexBuffer()`)();
+    }
+    this.bufferLayout = sortedBufferLayoutByShaderSourceLocations(this.pipeline.shaderLayout, this.bufferLayout);
+    const bufferLayoutHelper = new BufferLayoutHelper(this.bufferLayout);
+    for (const [bufferName, buffer] of Object.entries(buffers)) {
+      const bufferLayout = bufferLayoutHelper.getBufferLayout(bufferName);
+      if (!bufferLayout) {
+        if (!disableWarnings) {
+          log.warn(`Model(${this.id}): Missing layout for buffer "${bufferName}".`)();
+        }
+        continue;
+      }
+      const attributeNames = bufferLayoutHelper.getAttributeNamesForBuffer(bufferLayout);
+      let set = false;
+      for (const attributeName of attributeNames) {
+        const attributeInfo = this._attributeInfos[attributeName];
+        if (attributeInfo) {
+          const location2 = this.device.type === "webgpu" ? bufferLayoutHelper.getBufferIndex(attributeInfo.bufferName) : attributeInfo.location;
+          this.vertexArray.setBuffer(location2, buffer);
+          set = true;
+        }
+      }
+      if (!set && !disableWarnings) {
+        log.warn(`Model(${this.id}): Ignoring buffer "${buffer.id}" for unknown attribute "${bufferName}"`)();
+      }
+    }
+    this.setNeedsRedraw("attributes");
+  }
+  /**
+   * Sets constant attributes
+   * @note Overrides any attributes previously set with the same name
+   * Constant attributes are only supported in WebGL, not in WebGPU
+   * Any attribute that is disabled in the current vertex array object
+   * is read from the context's global constant value for that attribute location.
+   * @param constantAttributes
+   */
+  setConstantAttributes(attributes, options) {
+    for (const [attributeName, value] of Object.entries(attributes)) {
+      const attributeInfo = this._attributeInfos[attributeName];
+      if (attributeInfo) {
+        this.vertexArray.setConstantWebGL(attributeInfo.location, value);
+      } else if (!((options == null ? void 0 : options.disableWarnings) ?? this.props.disableWarnings)) {
+        log.warn(`Model "${this.id}: Ignoring constant supplied for unknown attribute "${attributeName}"`)();
+      }
+    }
+    this.setNeedsRedraw("constants");
+  }
+  // INTERNAL METHODS
+  /** Check that bindings are loaded. Returns id of first binding that is still loading. */
+  _areBindingsLoading() {
+    for (const binding of Object.values(this.bindings)) {
+      if (binding instanceof AsyncTexture && !binding.isReady) {
+        return binding.id;
+      }
+    }
+    return false;
+  }
+  /** Extracts texture view from loaded async textures. Returns null if any textures have not yet been loaded. */
+  _getBindings() {
+    const validBindings = {};
+    for (const [name2, binding] of Object.entries(this.bindings)) {
+      if (binding instanceof AsyncTexture) {
+        if (binding.isReady) {
+          validBindings[name2] = binding.texture;
+        }
+      } else {
+        validBindings[name2] = binding;
+      }
+    }
+    return validBindings;
+  }
+  /** Get the timestamp of the latest updated bound GPU memory resource (buffer/texture). */
+  _getBindingsUpdateTimestamp() {
+    let timestamp = 0;
+    for (const binding of Object.values(this.bindings)) {
+      if (binding instanceof TextureView) {
+        timestamp = Math.max(timestamp, binding.texture.updateTimestamp);
+      } else if (binding instanceof Buffer$1 || binding instanceof Texture) {
+        timestamp = Math.max(timestamp, binding.updateTimestamp);
+      } else if (binding instanceof AsyncTexture) {
+        timestamp = binding.texture ? Math.max(timestamp, binding.texture.updateTimestamp) : (
+          // The texture will become available in the future
+          Infinity
+        );
+      } else if (!(binding instanceof Sampler)) {
+        timestamp = Math.max(timestamp, binding.buffer.updateTimestamp);
+      }
+    }
+    return timestamp;
+  }
+  /**
+   * Updates the optional geometry attributes
+   * Geometry, sets several attributes, indexBuffer, and also vertex count
+   * @note Can trigger a pipeline rebuild / pipeline cache fetch on WebGPU
+   */
+  _setGeometryAttributes(gpuGeometry) {
+    const attributes = { ...gpuGeometry.attributes };
+    for (const [attributeName] of Object.entries(attributes)) {
+      if (!this.pipeline.shaderLayout.attributes.find((layout) => layout.name === attributeName) && attributeName !== "positions") {
+        delete attributes[attributeName];
+      }
+    }
+    this.vertexCount = gpuGeometry.vertexCount;
+    this.setIndexBuffer(gpuGeometry.indices || null);
+    this.setAttributes(gpuGeometry.attributes, { disableWarnings: true });
+    this.setAttributes(attributes, { disableWarnings: this.props.disableWarnings });
+    this.setNeedsRedraw("geometry attributes");
+  }
+  /** Mark pipeline as needing update */
+  _setPipelineNeedsUpdate(reason) {
+    this._pipelineNeedsUpdate || (this._pipelineNeedsUpdate = reason);
+    this.setNeedsRedraw(reason);
+  }
+  /** Update pipeline if needed */
+  _updatePipeline() {
+    if (this._pipelineNeedsUpdate) {
+      let prevShaderVs = null;
+      let prevShaderFs = null;
+      if (this.pipeline) {
+        log.log(1, `Model ${this.id}: Recreating pipeline because "${this._pipelineNeedsUpdate}".`)();
+        prevShaderVs = this.pipeline.vs;
+        prevShaderFs = this.pipeline.fs;
+      }
+      this._pipelineNeedsUpdate = false;
+      const vs2 = this.shaderFactory.createShader({
+        id: `${this.id}-vertex`,
+        stage: "vertex",
+        source: this.source || this.vs,
+        debugShaders: this.props.debugShaders
+      });
+      let fs2 = null;
+      if (this.source) {
+        fs2 = vs2;
+      } else if (this.fs) {
+        fs2 = this.shaderFactory.createShader({
+          id: `${this.id}-fragment`,
+          stage: "fragment",
+          source: this.source || this.fs,
+          debugShaders: this.props.debugShaders
+        });
+      }
+      this.pipeline = this.pipelineFactory.createRenderPipeline({
+        ...this.props,
+        bufferLayout: this.bufferLayout,
+        topology: this.topology,
+        parameters: this.parameters,
+        // TODO - why set bindings here when we reset them every frame?
+        // Should we expose a BindGroup abstraction?
+        bindings: this._getBindings(),
+        vs: vs2,
+        fs: fs2
+      });
+      this._attributeInfos = getAttributeInfosFromLayouts(this.pipeline.shaderLayout, this.bufferLayout);
+      if (prevShaderVs)
+        this.shaderFactory.release(prevShaderVs);
+      if (prevShaderFs)
+        this.shaderFactory.release(prevShaderFs);
+    }
+    return this.pipeline;
+  }
+  _logDrawCallStart() {
+    const logDrawTimeout = log.level > 3 ? 0 : LOG_DRAW_TIMEOUT;
+    if (log.level < 2 || Date.now() - this._lastLogTime < logDrawTimeout) {
+      return;
+    }
+    this._lastLogTime = Date.now();
+    this._logOpen = true;
+    log.group(LOG_DRAW_PRIORITY, `>>> DRAWING MODEL ${this.id}`, { collapsed: log.level <= 2 })();
+  }
+  _logDrawCallEnd() {
+    if (this._logOpen) {
+      const shaderLayoutTable = getDebugTableForShaderLayout(this.pipeline.shaderLayout, this.id);
+      log.table(LOG_DRAW_PRIORITY, shaderLayoutTable)();
+      const uniformTable = this.shaderInputs.getDebugTable();
+      log.table(LOG_DRAW_PRIORITY, uniformTable)();
+      const attributeTable = this._getAttributeDebugTable();
+      log.table(LOG_DRAW_PRIORITY, this._attributeInfos)();
+      log.table(LOG_DRAW_PRIORITY, attributeTable)();
+      log.groupEnd(LOG_DRAW_PRIORITY)();
+      this._logOpen = false;
+    }
+  }
+  _logFramebuffer(renderPass) {
+    const debugFramebuffers = this.device.props.debugFramebuffers;
+    this._drawCount++;
+    if (!debugFramebuffers) {
+      return;
+    }
+    const framebuffer = renderPass.props.framebuffer;
+    if (framebuffer) {
+      debugFramebuffer(framebuffer, { id: framebuffer.id, minimap: true });
+    }
+  }
+  _getAttributeDebugTable() {
+    const table = {};
+    for (const [name2, attributeInfo] of Object.entries(this._attributeInfos)) {
+      const values = this.vertexArray.attributes[attributeInfo.location];
+      table[attributeInfo.location] = {
+        name: name2,
+        type: attributeInfo.shaderType,
+        values: values ? this._getBufferOrConstantValues(values, attributeInfo.bufferDataType) : "null"
+      };
+    }
+    if (this.vertexArray.indexBuffer) {
+      const { indexBuffer } = this.vertexArray;
+      const values = indexBuffer.indexType === "uint32" ? new Uint32Array(indexBuffer.debugData) : new Uint16Array(indexBuffer.debugData);
+      table["indices"] = {
+        name: "indices",
+        type: indexBuffer.indexType,
+        values: values.toString()
+      };
+    }
+    return table;
+  }
+  // TODO - fix typing of luma data types
+  _getBufferOrConstantValues(attribute, dataType) {
+    const TypedArrayConstructor = getTypedArrayConstructor(dataType);
+    const typedArray = attribute instanceof Buffer$1 ? new TypedArrayConstructor(attribute.debugData) : attribute;
+    return typedArray.toString();
+  }
+};
+__publicField(_Model, "defaultProps", {
+  ...RenderPipeline.defaultProps,
+  source: void 0,
+  vs: null,
+  fs: null,
+  id: "unnamed",
+  handle: void 0,
+  userData: {},
+  defines: {},
+  modules: [],
+  geometry: null,
+  indexBuffer: null,
+  attributes: {},
+  constantAttributes: {},
+  varyings: [],
+  isInstanced: void 0,
+  instanceCount: 0,
+  vertexCount: 0,
+  shaderInputs: void 0,
+  pipelineFactory: void 0,
+  shaderFactory: void 0,
+  transformFeedback: void 0,
+  shaderAssembler: ShaderAssembler.getDefaultShaderAssembler(),
+  debugShaders: void 0,
+  disableWarnings: void 0
+});
+let Model = _Model;
+function shaderModuleHasUniforms(module) {
+  return Boolean(module.uniformTypes && !isObjectEmpty$3(module.uniformTypes));
+}
+function getPlatformInfo(device) {
+  return {
+    type: device.type,
+    shaderLanguage: device.info.shadingLanguage,
+    shaderLanguageVersion: device.info.shadingLanguageVersion,
+    gpu: device.info.gpu,
+    // HACK - we pretend that the DeviceFeatures is a Set, it has a similar API
+    features: device.features
+  };
+}
+function isObjectEmpty$3(obj) {
+  for (const key in obj) {
+    return false;
+  }
+  return true;
+}
+const _BufferTransform = class _BufferTransform {
+  constructor(device, props = _BufferTransform.defaultProps) {
+    __publicField(this, "device");
+    __publicField(this, "model");
+    __publicField(this, "transformFeedback");
+    if (!_BufferTransform.isSupported(device)) {
+      throw new Error("BufferTransform not yet implemented on WebGPU");
+    }
+    this.device = device;
+    this.model = new Model(this.device, {
+      id: props.id || "buffer-transform-model",
+      fs: props.fs || getPassthroughFS(),
+      topology: props.topology || "point-list",
+      varyings: props.outputs || props.varyings,
+      ...props
+    });
+    this.transformFeedback = this.device.createTransformFeedback({
+      layout: this.model.pipeline.shaderLayout,
+      // @ts-expect-error TODO
+      buffers: props.feedbackBuffers
+    });
+    this.model.setTransformFeedback(this.transformFeedback);
+    Object.seal(this);
+  }
+  static isSupported(device) {
+    var _a3;
+    return ((_a3 = device == null ? void 0 : device.info) == null ? void 0 : _a3.type) === "webgl";
+  }
+  /** Destroy owned resources. */
+  destroy() {
+    if (this.model) {
+      this.model.destroy();
+    }
+  }
+  /** @deprecated Use {@link destroy}. */
+  delete() {
+    this.destroy();
+  }
+  /** Run one transform loop. */
+  run(options) {
+    if (options == null ? void 0 : options.inputBuffers) {
+      this.model.setAttributes(options.inputBuffers);
+    }
+    if (options == null ? void 0 : options.outputBuffers) {
+      this.transformFeedback.setBuffers(options.outputBuffers);
+    }
+    const renderPass = this.device.beginRenderPass(options);
+    this.model.draw(renderPass);
+    renderPass.end();
+  }
+  // DEPRECATED METHODS
+  /** @deprecated App knows what buffers it is passing in - Returns the {@link Buffer} or {@link BufferRange} for given varying name. */
+  getBuffer(varyingName) {
+    return this.transformFeedback.getBuffer(varyingName);
+  }
+  /** @deprecated App knows what buffers it is passing in - Reads the {@link Buffer} or {@link BufferRange} for given varying name. */
+  readAsync(varyingName) {
+    const result = this.getBuffer(varyingName);
+    if (!result) {
+      throw new Error("BufferTransform#getBuffer");
+    }
+    if (result instanceof Buffer$1) {
+      return result.readAsync();
+    }
+    const { buffer, byteOffset = 0, byteLength = buffer.byteLength } = result;
+    return buffer.readAsync(byteOffset, byteLength);
+  }
+};
+__publicField(_BufferTransform, "defaultProps", {
+  ...Model.defaultProps,
+  outputs: void 0,
+  feedbackBuffers: void 0
+});
+let BufferTransform = _BufferTransform;
+class Geometry {
+  constructor(props) {
+    __publicField(this, "id");
+    /** Determines how vertices are read from the 'vertex' attributes */
+    __publicField(this, "topology");
+    __publicField(this, "vertexCount");
+    __publicField(this, "indices");
+    __publicField(this, "attributes");
+    __publicField(this, "userData", {});
+    const { attributes = {}, indices = null, vertexCount = null } = props;
+    this.id = props.id || uid$1("geometry");
+    this.topology = props.topology;
+    if (indices) {
+      this.indices = ArrayBuffer.isView(indices) ? { value: indices, size: 1 } : indices;
+    }
+    this.attributes = {};
+    for (const [attributeName, attributeValue] of Object.entries(attributes)) {
+      const attribute = ArrayBuffer.isView(attributeValue) ? { value: attributeValue } : attributeValue;
+      if (!ArrayBuffer.isView(attribute.value)) {
+        throw new Error(`${this._print(attributeName)}: must be typed array or object with value as typed array`);
+      }
+      if ((attributeName === "POSITION" || attributeName === "positions") && !attribute.size) {
+        attribute.size = 3;
+      }
+      if (attributeName === "indices") {
+        if (this.indices) {
+          throw new Error("Multiple indices detected");
+        }
+        this.indices = attribute;
+      } else {
+        this.attributes[attributeName] = attribute;
+      }
+    }
+    if (this.indices && this.indices["isIndexed"] !== void 0) {
+      this.indices = Object.assign({}, this.indices);
+      delete this.indices["isIndexed"];
+    }
+    this.vertexCount = vertexCount || this._calculateVertexCount(this.attributes, this.indices);
+  }
+  getVertexCount() {
+    return this.vertexCount;
+  }
+  /**
+   * Return an object with all attributes plus indices added as a field.
+   * TODO Geometry types are a mess
+   */
+  getAttributes() {
+    return this.indices ? { indices: this.indices, ...this.attributes } : this.attributes;
+  }
+  // PRIVATE
+  _print(attributeName) {
+    return `Geometry ${this.id} attribute ${attributeName}`;
+  }
+  /**
+   * GeometryAttribute
+   * value: typed array
+   * type: indices, vertices, uvs
+   * size: elements per vertex
+   * target: WebGL buffer type (string or constant)
+   *
+   * @param attributes
+   * @param indices
+   * @returns
+   */
+  _setAttributes(attributes, indices) {
+    return this;
+  }
+  _calculateVertexCount(attributes, indices) {
+    if (indices) {
+      return indices.value.length;
+    }
+    let vertexCount = Infinity;
+    for (const attribute of Object.values(attributes)) {
+      const { value, size, constant } = attribute;
+      if (!constant && value && size !== void 0 && size >= 1) {
+        vertexCount = Math.min(vertexCount, value.length / size);
+      }
+    }
+    return vertexCount;
+  }
+}
+const PICKING_BLENDING = {
+  blendColorOperation: "add",
+  blendColorSrcFactor: "one",
+  blendColorDstFactor: "zero",
+  blendAlphaOperation: "add",
+  blendAlphaSrcFactor: "constant",
+  blendAlphaDstFactor: "zero"
+};
+class PickLayersPass extends LayersPass {
+  constructor() {
+    super(...arguments);
+    this._colorEncoderState = null;
+  }
+  render(props) {
+    if ("pickingFBO" in props) {
+      return this._drawPickingBuffer(props);
+    }
+    return super.render(props);
+  }
+  // Private
+  // Draws list of layers and viewports into the picking buffer
+  // Note: does not sample the buffer, that has to be done by the caller
+  _drawPickingBuffer({ layers, layerFilter, views, viewports, onViewportActive, pickingFBO, deviceRect: { x: x2, y: y2, width, height }, cullRect, effects, pass = "picking", pickZ, shaderModuleProps }) {
+    this.pickZ = pickZ;
+    const colorEncoderState = this._resetColorEncoder(pickZ);
+    const scissorRect = [x2, y2, width, height];
+    const renderStatus = super.render({
+      target: pickingFBO,
+      layers,
+      layerFilter,
+      views,
+      viewports,
+      onViewportActive,
+      cullRect,
+      effects: effects == null ? void 0 : effects.filter((e2) => e2.useInPicking),
+      pass,
+      isPicking: true,
+      shaderModuleProps,
+      clearColor: [0, 0, 0, 0],
+      colorMask: 15,
+      scissorRect
+    });
+    this._colorEncoderState = null;
+    const decodePickingColor = colorEncoderState && decodeColor.bind(null, colorEncoderState);
+    return { decodePickingColor, stats: renderStatus };
+  }
+  shouldDrawLayer(layer) {
+    const { pickable, operation } = layer.props;
+    return pickable && operation.includes("draw") || operation.includes("terrain") || operation.includes("mask");
+  }
+  getShaderModuleProps(layer, effects, otherShaderModuleProps) {
+    return {
+      picking: {
+        isActive: 1,
+        isAttribute: this.pickZ
       },
-      // @method layerPointToLatLng(point: Point): LatLng
-      // Given a pixel coordinate relative to the [origin pixel](#map-getpixelorigin),
-      // returns the corresponding geographical coordinate (for the current zoom level).
-      layerPointToLatLng: function(point) {
-        var projectedPoint = toPoint(point).add(this.getPixelOrigin());
-        return this.unproject(projectedPoint);
+      lighting: { enabled: false }
+    };
+  }
+  getLayerParameters(layer, layerIndex, viewport) {
+    const pickParameters = {
+      ...layer.props.parameters
+    };
+    const { pickable, operation } = layer.props;
+    if (!this._colorEncoderState) {
+      pickParameters.blend = false;
+    } else if (pickable && operation.includes("draw")) {
+      Object.assign(pickParameters, PICKING_BLENDING);
+      pickParameters.blend = true;
+      pickParameters.blendColor = encodeColor(this._colorEncoderState, layer, viewport);
+    } else if (operation.includes("terrain")) {
+      pickParameters.blend = false;
+    }
+    return pickParameters;
+  }
+  _resetColorEncoder(pickZ) {
+    this._colorEncoderState = pickZ ? null : {
+      byLayer: /* @__PURE__ */ new Map(),
+      byAlpha: []
+    };
+    return this._colorEncoderState;
+  }
+}
+function encodeColor(encoded, layer, viewport) {
+  const { byLayer, byAlpha } = encoded;
+  let a2;
+  let entry = byLayer.get(layer);
+  if (entry) {
+    entry.viewports.push(viewport);
+    a2 = entry.a;
+  } else {
+    a2 = byLayer.size + 1;
+    if (a2 <= 255) {
+      entry = { a: a2, layer, viewports: [viewport] };
+      byLayer.set(layer, entry);
+      byAlpha[a2] = entry;
+    } else {
+      defaultLogger.warn("Too many pickable layers, only picking the first 255")();
+      a2 = 0;
+    }
+  }
+  return [0, 0, 0, a2 / 255];
+}
+function decodeColor(encoded, pickedColor) {
+  const entry = encoded.byAlpha[pickedColor[3]];
+  return entry && {
+    pickedLayer: entry.layer,
+    pickedViewports: entry.viewports,
+    pickedObjectIndex: entry.layer.decodePickingColor(pickedColor)
+  };
+}
+const LIFECYCLE = {
+  NO_STATE: "Awaiting state",
+  MATCHED: "Matched. State transferred from previous layer",
+  INITIALIZED: "Initialized",
+  AWAITING_GC: "Discarded. Awaiting garbage collection",
+  AWAITING_FINALIZATION: "No longer matched. Awaiting garbage collection",
+  FINALIZED: "Finalized! Awaiting garbage collection"
+};
+const COMPONENT_SYMBOL = Symbol.for("component");
+const PROP_TYPES_SYMBOL = Symbol.for("propTypes");
+const DEPRECATED_PROPS_SYMBOL = Symbol.for("deprecatedProps");
+const ASYNC_DEFAULTS_SYMBOL = Symbol.for("asyncPropDefaults");
+const ASYNC_ORIGINAL_SYMBOL = Symbol.for("asyncPropOriginal");
+const ASYNC_RESOLVED_SYMBOL = Symbol.for("asyncPropResolved");
+function flatten(array, filter = () => true) {
+  if (!Array.isArray(array)) {
+    return filter(array) ? [array] : [];
+  }
+  return flattenArray(array, filter, []);
+}
+function flattenArray(array, filter, result) {
+  let index = -1;
+  while (++index < array.length) {
+    const value = array[index];
+    if (Array.isArray(value)) {
+      flattenArray(value, filter, result);
+    } else if (filter(value)) {
+      result.push(value);
+    }
+  }
+  return result;
+}
+function fillArray$1({ target, source: source2, start = 0, count: count2 = 1 }) {
+  const length2 = source2.length;
+  const total = count2 * length2;
+  let copied = 0;
+  for (let i2 = start; copied < length2; copied++) {
+    target[i2++] = source2[copied];
+  }
+  while (copied < total) {
+    if (copied < total - copied) {
+      target.copyWithin(start + copied, start, start + copied);
+      copied *= 2;
+    } else {
+      target.copyWithin(start + copied, start, start + total - copied);
+      copied = total;
+    }
+  }
+  return target;
+}
+class Resource {
+  constructor(id2, data, context) {
+    this._loadCount = 0;
+    this._subscribers = /* @__PURE__ */ new Set();
+    this.id = id2;
+    this.context = context;
+    this.setData(data);
+  }
+  // consumer: {onChange: Function}
+  subscribe(consumer) {
+    this._subscribers.add(consumer);
+  }
+  unsubscribe(consumer) {
+    this._subscribers.delete(consumer);
+  }
+  inUse() {
+    return this._subscribers.size > 0;
+  }
+  delete() {
+  }
+  getData() {
+    return this.isLoaded ? this._error ? Promise.reject(this._error) : this._content : this._loader.then(() => this.getData());
+  }
+  setData(data, forceUpdate) {
+    if (data === this._data && !forceUpdate) {
+      return;
+    }
+    this._data = data;
+    const loadCount = ++this._loadCount;
+    let loader = data;
+    if (typeof data === "string") {
+      loader = load(data);
+    }
+    if (loader instanceof Promise) {
+      this.isLoaded = false;
+      this._loader = loader.then((result) => {
+        if (this._loadCount === loadCount) {
+          this.isLoaded = true;
+          this._error = void 0;
+          this._content = result;
+        }
+      }).catch((error) => {
+        if (this._loadCount === loadCount) {
+          this.isLoaded = true;
+          this._error = error || true;
+        }
+      });
+    } else {
+      this.isLoaded = true;
+      this._error = void 0;
+      this._content = data;
+    }
+    for (const subscriber of this._subscribers) {
+      subscriber.onChange(this.getData());
+    }
+  }
+}
+class ResourceManager {
+  constructor(props) {
+    var _a3;
+    this.protocol = props.protocol || "resource://";
+    this._context = {
+      device: props.device,
+      // @ts-expect-error
+      gl: (_a3 = props.device) == null ? void 0 : _a3.gl,
+      resourceManager: this
+    };
+    this._resources = {};
+    this._consumers = {};
+    this._pruneRequest = null;
+  }
+  contains(resourceId) {
+    if (resourceId.startsWith(this.protocol)) {
+      return true;
+    }
+    return resourceId in this._resources;
+  }
+  add({ resourceId, data, forceUpdate = false, persistent = true }) {
+    let res = this._resources[resourceId];
+    if (res) {
+      res.setData(data, forceUpdate);
+    } else {
+      res = new Resource(resourceId, data, this._context);
+      this._resources[resourceId] = res;
+    }
+    res.persistent = persistent;
+  }
+  remove(resourceId) {
+    const res = this._resources[resourceId];
+    if (res) {
+      res.delete();
+      delete this._resources[resourceId];
+    }
+  }
+  unsubscribe({ consumerId }) {
+    const consumer = this._consumers[consumerId];
+    if (consumer) {
+      for (const requestId in consumer) {
+        const request = consumer[requestId];
+        const resource = this._resources[request.resourceId];
+        if (resource) {
+          resource.unsubscribe(request);
+        }
+      }
+      delete this._consumers[consumerId];
+      this.prune();
+    }
+  }
+  subscribe({ resourceId, onChange, consumerId, requestId = "default" }) {
+    const { _resources: resources, protocol } = this;
+    if (resourceId.startsWith(protocol)) {
+      resourceId = resourceId.replace(protocol, "");
+      if (!resources[resourceId]) {
+        this.add({ resourceId, data: null, persistent: false });
+      }
+    }
+    const res = resources[resourceId];
+    this._track(consumerId, requestId, res, onChange);
+    if (res) {
+      return res.getData();
+    }
+    return void 0;
+  }
+  prune() {
+    if (!this._pruneRequest) {
+      this._pruneRequest = setTimeout(() => this._prune(), 0);
+    }
+  }
+  finalize() {
+    for (const key in this._resources) {
+      this._resources[key].delete();
+    }
+  }
+  _track(consumerId, requestId, resource, onChange) {
+    const consumers = this._consumers;
+    const consumer = consumers[consumerId] = consumers[consumerId] || {};
+    let request = consumer[requestId];
+    const oldResource = request && request.resourceId && this._resources[request.resourceId];
+    if (oldResource) {
+      oldResource.unsubscribe(request);
+      this.prune();
+    }
+    if (resource) {
+      if (request) {
+        request.onChange = onChange;
+        request.resourceId = resource.id;
+      } else {
+        request = {
+          onChange,
+          resourceId: resource.id
+        };
+      }
+      consumer[requestId] = request;
+      resource.subscribe(request);
+    }
+  }
+  _prune() {
+    this._pruneRequest = null;
+    for (const key of Object.keys(this._resources)) {
+      const res = this._resources[key];
+      if (!res.persistent && !res.inUse()) {
+        res.delete();
+        delete this._resources[key];
+      }
+    }
+  }
+}
+const TRACE_SET_LAYERS = "layerManager.setLayers";
+const TRACE_ACTIVATE_VIEWPORT = "layerManager.activateViewport";
+class LayerManager {
+  /**
+   * @param device
+   * @param param1
+   */
+  // eslint-disable-next-line
+  constructor(device, props) {
+    var _a3;
+    this._lastRenderedLayers = [];
+    this._needsRedraw = false;
+    this._needsUpdate = false;
+    this._nextLayers = null;
+    this._debug = false;
+    this._defaultShaderModulesChanged = false;
+    this.activateViewport = (viewport2) => {
+      debug(TRACE_ACTIVATE_VIEWPORT, this, viewport2);
+      if (viewport2) {
+        this.context.viewport = viewport2;
+      }
+    };
+    const { deck, stats, viewport, timeline } = props || {};
+    this.layers = [];
+    this.resourceManager = new ResourceManager({ device, protocol: "deck://" });
+    this.context = {
+      mousePosition: null,
+      userData: {},
+      layerManager: this,
+      device,
+      // @ts-expect-error
+      gl: device == null ? void 0 : device.gl,
+      deck,
+      shaderAssembler: getShaderAssembler(((_a3 = device == null ? void 0 : device.info) == null ? void 0 : _a3.shadingLanguage) || "glsl"),
+      defaultShaderModules: [layerUniforms],
+      renderPass: void 0,
+      stats: stats || new Stats({ id: "deck.gl" }),
+      // Make sure context.viewport is not empty on the first layer initialization
+      viewport: viewport || new Viewport({ id: "DEFAULT-INITIAL-VIEWPORT" }),
+      // Current viewport, exposed to layers for project* function
+      timeline: timeline || new Timeline(),
+      resourceManager: this.resourceManager,
+      onError: void 0
+    };
+    Object.seal(this);
+  }
+  /** Method to call when the layer manager is not needed anymore. */
+  finalize() {
+    this.resourceManager.finalize();
+    for (const layer of this.layers) {
+      this._finalizeLayer(layer);
+    }
+  }
+  /** Check if a redraw is needed */
+  needsRedraw(opts = { clearRedrawFlags: false }) {
+    let redraw = this._needsRedraw;
+    if (opts.clearRedrawFlags) {
+      this._needsRedraw = false;
+    }
+    for (const layer of this.layers) {
+      const layerNeedsRedraw = layer.getNeedsRedraw(opts);
+      redraw = redraw || layerNeedsRedraw;
+    }
+    return redraw;
+  }
+  /** Check if a deep update of all layers is needed */
+  needsUpdate() {
+    if (this._nextLayers && this._nextLayers !== this._lastRenderedLayers) {
+      return "layers changed";
+    }
+    if (this._defaultShaderModulesChanged) {
+      return "shader modules changed";
+    }
+    return this._needsUpdate;
+  }
+  /** Layers will be redrawn (in next animation frame) */
+  setNeedsRedraw(reason) {
+    this._needsRedraw = this._needsRedraw || reason;
+  }
+  /** Layers will be updated deeply (in next animation frame)
+    Potentially regenerating attributes and sub layers */
+  setNeedsUpdate(reason) {
+    this._needsUpdate = this._needsUpdate || reason;
+  }
+  /** Gets a list of currently rendered layers. Optionally filter by id. */
+  getLayers({ layerIds } = {}) {
+    return layerIds ? this.layers.filter((layer) => layerIds.find((layerId) => layer.id.indexOf(layerId) === 0)) : this.layers;
+  }
+  /** Set props needed for layer rendering and picking. */
+  setProps(props) {
+    if ("debug" in props) {
+      this._debug = props.debug;
+    }
+    if ("userData" in props) {
+      this.context.userData = props.userData;
+    }
+    if ("layers" in props) {
+      this._nextLayers = props.layers;
+    }
+    if ("onError" in props) {
+      this.context.onError = props.onError;
+    }
+  }
+  /** Supply a new layer list, initiating sublayer generation and layer matching */
+  setLayers(newLayers, reason) {
+    debug(TRACE_SET_LAYERS, this, reason, newLayers);
+    this._lastRenderedLayers = newLayers;
+    const flatLayers = flatten(newLayers, Boolean);
+    for (const layer of flatLayers) {
+      layer.context = this.context;
+    }
+    this._updateLayers(this.layers, flatLayers);
+  }
+  /** Update layers from last cycle if `setNeedsUpdate()` has been called */
+  updateLayers() {
+    const reason = this.needsUpdate();
+    if (reason) {
+      this.setNeedsRedraw(`updating layers: ${reason}`);
+      this.setLayers(this._nextLayers || this._lastRenderedLayers, reason);
+    }
+    this._nextLayers = null;
+  }
+  /** Register a default shader module */
+  addDefaultShaderModule(module) {
+    const { defaultShaderModules } = this.context;
+    if (!defaultShaderModules.find((m2) => m2.name === module.name)) {
+      defaultShaderModules.push(module);
+      this._defaultShaderModulesChanged = true;
+    }
+  }
+  /** Deregister a default shader module */
+  removeDefaultShaderModule(module) {
+    const { defaultShaderModules } = this.context;
+    const i2 = defaultShaderModules.findIndex((m2) => m2.name === module.name);
+    if (i2 >= 0) {
+      defaultShaderModules.splice(i2, 1);
+      this._defaultShaderModulesChanged = true;
+    }
+  }
+  _handleError(stage, error, layer) {
+    layer.raiseError(error, `${stage} of ${layer}`);
+  }
+  // TODO - mark layers with exceptions as bad and remove from rendering cycle?
+  /** Match all layers, checking for caught errors
+    to avoid having an exception in one layer disrupt other layers */
+  _updateLayers(oldLayers, newLayers) {
+    const oldLayerMap = {};
+    for (const oldLayer of oldLayers) {
+      if (oldLayerMap[oldLayer.id]) {
+        defaultLogger.warn(`Multiple old layers with same id ${oldLayer.id}`)();
+      } else {
+        oldLayerMap[oldLayer.id] = oldLayer;
+      }
+    }
+    if (this._defaultShaderModulesChanged) {
+      for (const layer of oldLayers) {
+        layer.setNeedsUpdate();
+        layer.setChangeFlags({ extensionsChanged: true });
+      }
+      this._defaultShaderModulesChanged = false;
+    }
+    const generatedLayers = [];
+    this._updateSublayersRecursively(newLayers, oldLayerMap, generatedLayers);
+    this._finalizeOldLayers(oldLayerMap);
+    let needsUpdate = false;
+    for (const layer of generatedLayers) {
+      if (layer.hasUniformTransition()) {
+        needsUpdate = `Uniform transition in ${layer}`;
+        break;
+      }
+    }
+    this._needsUpdate = needsUpdate;
+    this.layers = generatedLayers;
+  }
+  /* eslint-disable complexity,max-statements */
+  // Note: adds generated layers to `generatedLayers` array parameter
+  _updateSublayersRecursively(newLayers, oldLayerMap, generatedLayers) {
+    for (const newLayer of newLayers) {
+      newLayer.context = this.context;
+      const oldLayer = oldLayerMap[newLayer.id];
+      if (oldLayer === null) {
+        defaultLogger.warn(`Multiple new layers with same id ${newLayer.id}`)();
+      }
+      oldLayerMap[newLayer.id] = null;
+      let sublayers = null;
+      try {
+        if (this._debug && oldLayer !== newLayer) {
+          newLayer.validateProps();
+        }
+        if (!oldLayer) {
+          this._initializeLayer(newLayer);
+        } else {
+          this._transferLayerState(oldLayer, newLayer);
+          this._updateLayer(newLayer);
+        }
+        generatedLayers.push(newLayer);
+        sublayers = newLayer.isComposite ? newLayer.getSubLayers() : null;
+      } catch (err) {
+        this._handleError("matching", err, newLayer);
+      }
+      if (sublayers) {
+        this._updateSublayersRecursively(sublayers, oldLayerMap, generatedLayers);
+      }
+    }
+  }
+  /* eslint-enable complexity,max-statements */
+  // Finalize any old layers that were not matched
+  _finalizeOldLayers(oldLayerMap) {
+    for (const layerId in oldLayerMap) {
+      const layer = oldLayerMap[layerId];
+      if (layer) {
+        this._finalizeLayer(layer);
+      }
+    }
+  }
+  // / EXCEPTION SAFE LAYER ACCESS
+  /** Safely initializes a single layer, calling layer methods */
+  _initializeLayer(layer) {
+    try {
+      layer._initialize();
+      layer.lifecycle = LIFECYCLE.INITIALIZED;
+    } catch (err) {
+      this._handleError("initialization", err, layer);
+    }
+  }
+  /** Transfer state from one layer to a newer version */
+  _transferLayerState(oldLayer, newLayer) {
+    newLayer._transferState(oldLayer);
+    newLayer.lifecycle = LIFECYCLE.MATCHED;
+    if (newLayer !== oldLayer) {
+      oldLayer.lifecycle = LIFECYCLE.AWAITING_GC;
+    }
+  }
+  /** Safely updates a single layer, cleaning all flags */
+  _updateLayer(layer) {
+    try {
+      layer._update();
+    } catch (err) {
+      this._handleError("update", err, layer);
+    }
+  }
+  /** Safely finalizes a single layer, removing all resources */
+  _finalizeLayer(layer) {
+    this._needsRedraw = this._needsRedraw || `finalized ${layer}`;
+    layer.lifecycle = LIFECYCLE.AWAITING_FINALIZATION;
+    try {
+      layer._finalize();
+      layer.lifecycle = LIFECYCLE.FINALIZED;
+    } catch (err) {
+      this._handleError("finalization", err, layer);
+    }
+  }
+}
+function deepEqual(a2, b2, depth) {
+  if (a2 === b2) {
+    return true;
+  }
+  if (!depth || !a2 || !b2) {
+    return false;
+  }
+  if (Array.isArray(a2)) {
+    if (!Array.isArray(b2) || a2.length !== b2.length) {
+      return false;
+    }
+    for (let i2 = 0; i2 < a2.length; i2++) {
+      if (!deepEqual(a2[i2], b2[i2], depth - 1)) {
+        return false;
+      }
+    }
+    return true;
+  }
+  if (Array.isArray(b2)) {
+    return false;
+  }
+  if (typeof a2 === "object" && typeof b2 === "object") {
+    const aKeys = Object.keys(a2);
+    const bKeys = Object.keys(b2);
+    if (aKeys.length !== bKeys.length) {
+      return false;
+    }
+    for (const key of aKeys) {
+      if (!b2.hasOwnProperty(key)) {
+        return false;
+      }
+      if (!deepEqual(a2[key], b2[key], depth - 1)) {
+        return false;
+      }
+    }
+    return true;
+  }
+  return false;
+}
+class ViewManager {
+  constructor(props) {
+    this.views = [];
+    this.width = 100;
+    this.height = 100;
+    this.viewState = {};
+    this.controllers = {};
+    this.timeline = props.timeline;
+    this._viewports = [];
+    this._viewportMap = {};
+    this._isUpdating = false;
+    this._needsRedraw = "First render";
+    this._needsUpdate = "Initialize";
+    this._eventManager = props.eventManager;
+    this._eventCallbacks = {
+      onViewStateChange: props.onViewStateChange,
+      onInteractionStateChange: props.onInteractionStateChange
+    };
+    Object.seal(this);
+    this.setProps(props);
+  }
+  /** Remove all resources and event listeners */
+  finalize() {
+    for (const key in this.controllers) {
+      const controller = this.controllers[key];
+      if (controller) {
+        controller.finalize();
+      }
+    }
+    this.controllers = {};
+  }
+  /** Check if a redraw is needed */
+  needsRedraw(opts = { clearRedrawFlags: false }) {
+    const redraw = this._needsRedraw;
+    if (opts.clearRedrawFlags) {
+      this._needsRedraw = false;
+    }
+    return redraw;
+  }
+  /** Mark the manager as dirty. Will rebuild all viewports and update controllers. */
+  setNeedsUpdate(reason) {
+    this._needsUpdate = this._needsUpdate || reason;
+    this._needsRedraw = this._needsRedraw || reason;
+  }
+  /** Checks each viewport for transition updates */
+  updateViewStates() {
+    for (const viewId in this.controllers) {
+      const controller = this.controllers[viewId];
+      if (controller) {
+        controller.updateTransition();
+      }
+    }
+  }
+  /** Get a set of viewports for a given width and height
+   * TODO - Intention is for deck.gl to autodeduce width and height and drop the need for props
+   * @param rect (object, optional) - filter the viewports
+   *   + not provided - return all viewports
+   *   + {x, y} - only return viewports that contain this pixel
+   *   + {x, y, width, height} - only return viewports that overlap with this rectangle
+   */
+  getViewports(rect) {
+    if (rect) {
+      return this._viewports.filter((viewport) => viewport.containsPixel(rect));
+    }
+    return this._viewports;
+  }
+  /** Get a map of all views */
+  getViews() {
+    const viewMap = {};
+    this.views.forEach((view) => {
+      viewMap[view.id] = view;
+    });
+    return viewMap;
+  }
+  /** Resolves a viewId string to a View */
+  getView(viewId) {
+    return this.views.find((view) => view.id === viewId);
+  }
+  /** Returns the viewState for a specific viewId. Matches the viewState by
+    1. view.viewStateId
+    2. view.id
+    3. root viewState
+    then applies the view's filter if any */
+  getViewState(viewOrViewId) {
+    const view = typeof viewOrViewId === "string" ? this.getView(viewOrViewId) : viewOrViewId;
+    const viewState = view && this.viewState[view.getViewStateId()] || this.viewState;
+    return view ? view.filterViewState(viewState) : viewState;
+  }
+  getViewport(viewId) {
+    return this._viewportMap[viewId];
+  }
+  /**
+   * Unproject pixel coordinates on screen onto world coordinates,
+   * (possibly [lon, lat]) on map.
+   * - [x, y] => [lng, lat]
+   * - [x, y, z] => [lng, lat, Z]
+   * @param {Array} xyz -
+   * @param {Object} opts - options
+   * @param {Object} opts.topLeft=true - Whether origin is top left
+   * @return {Array|null} - [lng, lat, Z] or [X, Y, Z]
+   */
+  unproject(xyz, opts) {
+    const viewports = this.getViewports();
+    const pixel = { x: xyz[0], y: xyz[1] };
+    for (let i2 = viewports.length - 1; i2 >= 0; --i2) {
+      const viewport = viewports[i2];
+      if (viewport.containsPixel(pixel)) {
+        const p2 = xyz.slice();
+        p2[0] -= viewport.x;
+        p2[1] -= viewport.y;
+        return viewport.unproject(p2, opts);
+      }
+    }
+    return null;
+  }
+  /** Update the manager with new Deck props */
+  setProps(props) {
+    if (props.views) {
+      this._setViews(props.views);
+    }
+    if (props.viewState) {
+      this._setViewState(props.viewState);
+    }
+    if ("width" in props || "height" in props) {
+      this._setSize(props.width, props.height);
+    }
+    if (!this._isUpdating) {
+      this._update();
+    }
+  }
+  //
+  // PRIVATE METHODS
+  //
+  _update() {
+    this._isUpdating = true;
+    if (this._needsUpdate) {
+      this._needsUpdate = false;
+      this._rebuildViewports();
+    }
+    if (this._needsUpdate) {
+      this._needsUpdate = false;
+      this._rebuildViewports();
+    }
+    this._isUpdating = false;
+  }
+  _setSize(width, height) {
+    if (width !== this.width || height !== this.height) {
+      this.width = width;
+      this.height = height;
+      this.setNeedsUpdate("Size changed");
+    }
+  }
+  // Update the view descriptor list and set change flag if needed
+  // Does not actually rebuild the `Viewport`s until `getViewports` is called
+  _setViews(views) {
+    views = flatten(views, Boolean);
+    const viewsChanged = this._diffViews(views, this.views);
+    if (viewsChanged) {
+      this.setNeedsUpdate("views changed");
+    }
+    this.views = views;
+  }
+  _setViewState(viewState) {
+    if (viewState) {
+      const viewStateChanged = !deepEqual(viewState, this.viewState, 3);
+      if (viewStateChanged) {
+        this.setNeedsUpdate("viewState changed");
+      }
+      this.viewState = viewState;
+    } else {
+      defaultLogger.warn("missing `viewState` or `initialViewState`")();
+    }
+  }
+  _createController(view, props) {
+    const Controller2 = props.type;
+    const controller = new Controller2({
+      timeline: this.timeline,
+      eventManager: this._eventManager,
+      // Set an internal callback that calls the prop callback if provided
+      onViewStateChange: this._eventCallbacks.onViewStateChange,
+      onStateChange: this._eventCallbacks.onInteractionStateChange,
+      makeViewport: (viewState) => {
+        var _a3;
+        return (_a3 = this.getView(view.id)) == null ? void 0 : _a3.makeViewport({
+          viewState,
+          width: this.width,
+          height: this.height
+        });
+      }
+    });
+    return controller;
+  }
+  _updateController(view, viewState, viewport, controller) {
+    const controllerProps = view.controller;
+    if (controllerProps && viewport) {
+      const resolvedProps = {
+        ...viewState,
+        ...controllerProps,
+        id: view.id,
+        x: viewport.x,
+        y: viewport.y,
+        width: viewport.width,
+        height: viewport.height
+      };
+      if (!controller || controller.constructor !== controllerProps.type) {
+        controller = this._createController(view, resolvedProps);
+      }
+      if (controller) {
+        controller.setProps(resolvedProps);
+      }
+      return controller;
+    }
+    return null;
+  }
+  // Rebuilds viewports from descriptors towards a certain window size
+  _rebuildViewports() {
+    const { views } = this;
+    const oldControllers = this.controllers;
+    this._viewports = [];
+    this.controllers = {};
+    let invalidateControllers = false;
+    for (let i2 = views.length; i2--; ) {
+      const view = views[i2];
+      const viewState = this.getViewState(view);
+      const viewport = view.makeViewport({ viewState, width: this.width, height: this.height });
+      let oldController = oldControllers[view.id];
+      const hasController = Boolean(view.controller);
+      if (hasController && !oldController) {
+        invalidateControllers = true;
+      }
+      if ((invalidateControllers || !hasController) && oldController) {
+        oldController.finalize();
+        oldController = null;
+      }
+      this.controllers[view.id] = this._updateController(view, viewState, viewport, oldController);
+      if (viewport) {
+        this._viewports.unshift(viewport);
+      }
+    }
+    for (const id2 in oldControllers) {
+      const oldController = oldControllers[id2];
+      if (oldController && !this.controllers[id2]) {
+        oldController.finalize();
+      }
+    }
+    this._buildViewportMap();
+  }
+  _buildViewportMap() {
+    this._viewportMap = {};
+    this._viewports.forEach((viewport) => {
+      if (viewport.id) {
+        this._viewportMap[viewport.id] = this._viewportMap[viewport.id] || viewport;
+      }
+    });
+  }
+  // Check if viewport array has changed, returns true if any change
+  // Note that descriptors can be the same
+  _diffViews(newViews, oldViews) {
+    if (newViews.length !== oldViews.length) {
+      return true;
+    }
+    return newViews.some((_2, i2) => !newViews[i2].equals(oldViews[i2]));
+  }
+}
+const NUMBER_REGEX = /^(?:\d+\.?\d*|\.\d+)$/;
+function parsePosition(value) {
+  switch (typeof value) {
+    case "number":
+      if (!Number.isFinite(value)) {
+        throw new Error(`Could not parse position string ${value}`);
+      }
+      return { type: "literal", value };
+    case "string":
+      try {
+        const tokens = tokenize(value);
+        const parser = new LayoutExpressionParser(tokens);
+        return parser.parseExpression();
+      } catch (error) {
+        const reason = error instanceof Error ? error.message : String(error);
+        throw new Error(`Could not parse position string ${value}: ${reason}`);
+      }
+    default:
+      throw new Error(`Could not parse position string ${value}`);
+  }
+}
+function evaluateLayoutExpression(expression, extent) {
+  switch (expression.type) {
+    case "literal":
+      return expression.value;
+    case "percentage":
+      return Math.round(expression.value * extent);
+    case "binary":
+      const left = evaluateLayoutExpression(expression.left, extent);
+      const right = evaluateLayoutExpression(expression.right, extent);
+      return expression.operator === "+" ? left + right : left - right;
+    default:
+      throw new Error("Unknown layout expression type");
+  }
+}
+function getPosition(expression, extent) {
+  return evaluateLayoutExpression(expression, extent);
+}
+function tokenize(input) {
+  const tokens = [];
+  let index = 0;
+  while (index < input.length) {
+    const char = input[index];
+    if (/\s/.test(char)) {
+      index++;
+      continue;
+    }
+    if (char === "+" || char === "-" || char === "(" || char === ")" || char === "%") {
+      tokens.push({ type: "symbol", value: char });
+      index++;
+      continue;
+    }
+    if (isDigit(char) || char === ".") {
+      const start = index;
+      let hasDecimal = char === ".";
+      index++;
+      while (index < input.length) {
+        const next = input[index];
+        if (isDigit(next)) {
+          index++;
+          continue;
+        }
+        if (next === "." && !hasDecimal) {
+          hasDecimal = true;
+          index++;
+          continue;
+        }
+        break;
+      }
+      const numberString = input.slice(start, index);
+      if (!NUMBER_REGEX.test(numberString)) {
+        throw new Error("Invalid number token");
+      }
+      tokens.push({ type: "number", value: parseFloat(numberString) });
+      continue;
+    }
+    if (isAlpha(char)) {
+      const start = index;
+      while (index < input.length && isAlpha(input[index])) {
+        index++;
+      }
+      const word = input.slice(start, index).toLowerCase();
+      tokens.push({ type: "word", value: word });
+      continue;
+    }
+    throw new Error("Invalid token in position string");
+  }
+  return tokens;
+}
+class LayoutExpressionParser {
+  constructor(tokens) {
+    this.index = 0;
+    this.tokens = tokens;
+  }
+  parseExpression() {
+    const expression = this.parseBinaryExpression();
+    if (this.index < this.tokens.length) {
+      throw new Error("Unexpected token at end of expression");
+    }
+    return expression;
+  }
+  parseBinaryExpression() {
+    let expression = this.parseFactor();
+    let token = this.peek();
+    while (isAddSubSymbol(token)) {
+      this.index++;
+      const right = this.parseFactor();
+      expression = { type: "binary", operator: token.value, left: expression, right };
+      token = this.peek();
+    }
+    return expression;
+  }
+  parseFactor() {
+    const token = this.peek();
+    if (!token) {
+      throw new Error("Unexpected end of expression");
+    }
+    if (token.type === "symbol" && token.value === "+") {
+      this.index++;
+      return this.parseFactor();
+    }
+    if (token.type === "symbol" && token.value === "-") {
+      this.index++;
+      const factor = this.parseFactor();
+      return { type: "binary", operator: "-", left: { type: "literal", value: 0 }, right: factor };
+    }
+    if (token.type === "symbol" && token.value === "(") {
+      this.index++;
+      const expression = this.parseBinaryExpression();
+      if (!this.consumeSymbol(")")) {
+        throw new Error("Missing closing parenthesis");
+      }
+      return expression;
+    }
+    if (token.type === "word" && token.value === "calc") {
+      this.index++;
+      if (!this.consumeSymbol("(")) {
+        throw new Error("Missing opening parenthesis after calc");
+      }
+      const expression = this.parseBinaryExpression();
+      if (!this.consumeSymbol(")")) {
+        throw new Error("Missing closing parenthesis");
+      }
+      return expression;
+    }
+    if (token.type === "number") {
+      this.index++;
+      const numberValue = token.value;
+      const nextToken = this.peek();
+      if (nextToken && nextToken.type === "symbol" && nextToken.value === "%") {
+        this.index++;
+        return { type: "percentage", value: numberValue / 100 };
+      }
+      if (nextToken && nextToken.type === "word" && nextToken.value === "px") {
+        this.index++;
+        return { type: "literal", value: numberValue };
+      }
+      return { type: "literal", value: numberValue };
+    }
+    throw new Error("Unexpected token in expression");
+  }
+  consumeSymbol(value) {
+    const token = this.peek();
+    if (token && token.type === "symbol" && token.value === value) {
+      this.index++;
+      return true;
+    }
+    return false;
+  }
+  peek() {
+    return this.tokens[this.index] || null;
+  }
+}
+function isDigit(char) {
+  return char >= "0" && char <= "9";
+}
+function isAlpha(char) {
+  return char >= "a" && char <= "z" || char >= "A" && char <= "Z";
+}
+function isAddSubSymbol(token) {
+  return Boolean(token && token.type === "symbol" && (token.value === "+" || token.value === "-"));
+}
+class View {
+  constructor(props) {
+    const { id: id2, x: x2 = 0, y: y2 = 0, width = "100%", height = "100%", padding = null } = props;
+    this.id = id2 || this.constructor.displayName || "view";
+    this.props = { ...props, id: this.id };
+    this._x = parsePosition(x2);
+    this._y = parsePosition(y2);
+    this._width = parsePosition(width);
+    this._height = parsePosition(height);
+    this._padding = padding && {
+      left: parsePosition(padding.left || 0),
+      right: parsePosition(padding.right || 0),
+      top: parsePosition(padding.top || 0),
+      bottom: parsePosition(padding.bottom || 0)
+    };
+    this.equals = this.equals.bind(this);
+    Object.seal(this);
+  }
+  equals(view) {
+    if (this === view) {
+      return true;
+    }
+    return this.constructor === view.constructor && deepEqual(this.props, view.props, 2);
+  }
+  /** Clone this view with modified props */
+  clone(newProps) {
+    const ViewConstructor = this.constructor;
+    return new ViewConstructor({ ...this.props, ...newProps });
+  }
+  /** Make viewport from canvas dimensions and view state */
+  makeViewport({ width, height, viewState }) {
+    viewState = this.filterViewState(viewState);
+    const viewportDimensions = this.getDimensions({ width, height });
+    if (!viewportDimensions.height || !viewportDimensions.width) {
+      return null;
+    }
+    const ViewportType = this.getViewportType(viewState);
+    return new ViewportType({ ...viewState, ...this.props, ...viewportDimensions });
+  }
+  getViewStateId() {
+    const { viewState } = this.props;
+    if (typeof viewState === "string") {
+      return viewState;
+    }
+    return (viewState == null ? void 0 : viewState.id) || this.id;
+  }
+  // Allows view to override (or completely define) viewState
+  filterViewState(viewState) {
+    if (this.props.viewState && typeof this.props.viewState === "object") {
+      if (!this.props.viewState.id) {
+        return this.props.viewState;
+      }
+      const newViewState = { ...viewState };
+      for (const key in this.props.viewState) {
+        if (key !== "id") {
+          newViewState[key] = this.props.viewState[key];
+        }
+      }
+      return newViewState;
+    }
+    return viewState;
+  }
+  /** Resolve the dimensions of the view from overall canvas dimensions */
+  getDimensions({ width, height }) {
+    const dimensions = {
+      x: getPosition(this._x, width),
+      y: getPosition(this._y, height),
+      width: getPosition(this._width, width),
+      height: getPosition(this._height, height)
+    };
+    if (this._padding) {
+      dimensions.padding = {
+        left: getPosition(this._padding.left, width),
+        top: getPosition(this._padding.top, height),
+        right: getPosition(this._padding.right, width),
+        bottom: getPosition(this._padding.bottom, height)
+      };
+    }
+    return dimensions;
+  }
+  // Used by sub classes to resolve controller props
+  get controller() {
+    const opts = this.props.controller;
+    if (!opts) {
+      return null;
+    }
+    if (opts === true) {
+      return { type: this.ControllerType };
+    }
+    if (typeof opts === "function") {
+      return { type: opts };
+    }
+    return { type: this.ControllerType, ...opts };
+  }
+}
+class Transition {
+  /**
+   * @params timeline {Timeline}
+   */
+  constructor(timeline) {
+    this._inProgress = false;
+    this._handle = null;
+    this.time = 0;
+    this.settings = {
+      duration: 0
+    };
+    this._timeline = timeline;
+  }
+  /* Public API */
+  get inProgress() {
+    return this._inProgress;
+  }
+  /**
+   * (re)start this transition.
+   * @params props {object} - optional overriding props. see constructor
+   */
+  start(settings) {
+    var _a3, _b3;
+    this.cancel();
+    this.settings = settings;
+    this._inProgress = true;
+    (_b3 = (_a3 = this.settings).onStart) == null ? void 0 : _b3.call(_a3, this);
+  }
+  /**
+   * end this transition if it is in progress.
+   */
+  end() {
+    var _a3, _b3;
+    if (this._inProgress) {
+      this._timeline.removeChannel(this._handle);
+      this._handle = null;
+      this._inProgress = false;
+      (_b3 = (_a3 = this.settings).onEnd) == null ? void 0 : _b3.call(_a3, this);
+    }
+  }
+  /**
+   * cancel this transition if it is in progress.
+   */
+  cancel() {
+    var _a3, _b3;
+    if (this._inProgress) {
+      (_b3 = (_a3 = this.settings).onInterrupt) == null ? void 0 : _b3.call(_a3, this);
+      this._timeline.removeChannel(this._handle);
+      this._handle = null;
+      this._inProgress = false;
+    }
+  }
+  /**
+   * update this transition. Returns `true` if updated.
+   */
+  update() {
+    var _a3, _b3;
+    if (!this._inProgress) {
+      return false;
+    }
+    if (this._handle === null) {
+      const { _timeline: timeline, settings } = this;
+      this._handle = timeline.addChannel({
+        delay: timeline.getTime(),
+        duration: settings.duration
+      });
+    }
+    this.time = this._timeline.getTime(this._handle);
+    this._onUpdate();
+    (_b3 = (_a3 = this.settings).onUpdate) == null ? void 0 : _b3.call(_a3, this);
+    if (this._timeline.isFinished(this._handle)) {
+      this.end();
+    }
+    return true;
+  }
+  /* Private API */
+  _onUpdate() {
+  }
+}
+const noop$1 = () => {
+};
+const TRANSITION_EVENTS = {
+  BREAK: 1,
+  SNAP_TO_END: 2,
+  IGNORE: 3
+};
+const DEFAULT_EASING = (t2) => t2;
+const DEFAULT_INTERRUPTION = TRANSITION_EVENTS.BREAK;
+class TransitionManager {
+  constructor(opts) {
+    this._onTransitionUpdate = (transition) => {
+      const { time, settings: { interpolator, startProps, endProps, duration, easing } } = transition;
+      const t2 = easing(time / duration);
+      const viewport = interpolator.interpolateProps(startProps, endProps, t2);
+      this.propsInTransition = this.getControllerState({
+        ...this.props,
+        ...viewport
+      }).getViewportProps();
+      this.onViewStateChange({
+        viewState: this.propsInTransition,
+        oldViewState: this.props
+      });
+    };
+    this.getControllerState = opts.getControllerState;
+    this.propsInTransition = null;
+    this.transition = new Transition(opts.timeline);
+    this.onViewStateChange = opts.onViewStateChange || noop$1;
+    this.onStateChange = opts.onStateChange || noop$1;
+  }
+  finalize() {
+    this.transition.cancel();
+  }
+  // Returns current transitioned viewport.
+  getViewportInTransition() {
+    return this.propsInTransition;
+  }
+  // Process the vewiport change, either ignore or trigger a new transition.
+  // Return true if a new transition is triggered, false otherwise.
+  processViewStateChange(nextProps) {
+    let transitionTriggered = false;
+    const currentProps = this.props;
+    this.props = nextProps;
+    if (!currentProps || this._shouldIgnoreViewportChange(currentProps, nextProps)) {
+      return false;
+    }
+    if (this._isTransitionEnabled(nextProps)) {
+      let startProps = currentProps;
+      if (this.transition.inProgress) {
+        const { interruption, endProps } = this.transition.settings;
+        startProps = {
+          ...currentProps,
+          ...interruption === TRANSITION_EVENTS.SNAP_TO_END ? endProps : this.propsInTransition || currentProps
+        };
+      }
+      this._triggerTransition(startProps, nextProps);
+      transitionTriggered = true;
+    } else {
+      this.transition.cancel();
+    }
+    return transitionTriggered;
+  }
+  updateTransition() {
+    this.transition.update();
+  }
+  // Helper methods
+  _isTransitionEnabled(props) {
+    const { transitionDuration, transitionInterpolator } = props;
+    return (transitionDuration > 0 || transitionDuration === "auto") && Boolean(transitionInterpolator);
+  }
+  _isUpdateDueToCurrentTransition(props) {
+    if (this.transition.inProgress && this.propsInTransition) {
+      return this.transition.settings.interpolator.arePropsEqual(props, this.propsInTransition);
+    }
+    return false;
+  }
+  _shouldIgnoreViewportChange(currentProps, nextProps) {
+    if (this.transition.inProgress) {
+      const transitionSettings = this.transition.settings;
+      return transitionSettings.interruption === TRANSITION_EVENTS.IGNORE || // Ignore update if it is due to current active transition.
+      this._isUpdateDueToCurrentTransition(nextProps);
+    }
+    if (this._isTransitionEnabled(nextProps)) {
+      return nextProps.transitionInterpolator.arePropsEqual(currentProps, nextProps);
+    }
+    return true;
+  }
+  _triggerTransition(startProps, endProps) {
+    const startViewstate = this.getControllerState(startProps);
+    const endViewStateProps = this.getControllerState(endProps).shortestPathFrom(startViewstate);
+    const transitionInterpolator = endProps.transitionInterpolator;
+    const duration = transitionInterpolator.getDuration ? transitionInterpolator.getDuration(startProps, endProps) : endProps.transitionDuration;
+    if (duration === 0) {
+      return;
+    }
+    const initialProps = transitionInterpolator.initializeProps(startProps, endViewStateProps);
+    this.propsInTransition = {};
+    const transitionSettings = {
+      duration,
+      easing: endProps.transitionEasing || DEFAULT_EASING,
+      interpolator: transitionInterpolator,
+      interruption: endProps.transitionInterruption || DEFAULT_INTERRUPTION,
+      startProps: initialProps.start,
+      endProps: initialProps.end,
+      onStart: endProps.onTransitionStart,
+      onUpdate: this._onTransitionUpdate,
+      onInterrupt: this._onTransitionEnd(endProps.onTransitionInterrupt),
+      onEnd: this._onTransitionEnd(endProps.onTransitionEnd)
+    };
+    this.transition.start(transitionSettings);
+    this.onStateChange({ inTransition: true });
+    this.updateTransition();
+  }
+  _onTransitionEnd(callback) {
+    return (transition) => {
+      this.propsInTransition = null;
+      this.onStateChange({
+        inTransition: false,
+        isZooming: false,
+        isPanning: false,
+        isRotating: false
+      });
+      callback == null ? void 0 : callback(transition);
+    };
+  }
+}
+function assert(condition, message2) {
+  if (!condition) {
+    throw new Error(message2 || "deck.gl: assertion failed.");
+  }
+}
+class TransitionInterpolator {
+  /**
+   * @param opts {array|object}
+   * @param opts.compare {array} - prop names used in equality check
+   * @param opts.extract {array} - prop names needed for interpolation
+   * @param opts.required {array} - prop names that must be supplied
+   * alternatively, supply one list of prop names as `opts` if all of the above are the same.
+   */
+  constructor(opts) {
+    const { compare, extract, required } = opts;
+    this._propsToCompare = compare;
+    this._propsToExtract = extract || compare;
+    this._requiredProps = required;
+  }
+  /**
+   * Checks if two sets of props need transition in between
+   * @param currentProps {object} - a list of viewport props
+   * @param nextProps {object} - a list of viewport props
+   * @returns {bool} - true if two props are equivalent
+   */
+  arePropsEqual(currentProps, nextProps) {
+    for (const key of this._propsToCompare) {
+      if (!(key in currentProps) || !(key in nextProps) || !equals(currentProps[key], nextProps[key])) {
+        return false;
+      }
+    }
+    return true;
+  }
+  /**
+   * Called before transition starts to validate/pre-process start and end props
+   * @param startProps {object} - a list of starting viewport props
+   * @param endProps {object} - a list of target viewport props
+   * @returns {Object} {start, end} - start and end props to be passed
+   *   to `interpolateProps`
+   */
+  initializeProps(startProps, endProps) {
+    const startViewStateProps = {};
+    const endViewStateProps = {};
+    for (const key of this._propsToExtract) {
+      if (key in startProps || key in endProps) {
+        startViewStateProps[key] = startProps[key];
+        endViewStateProps[key] = endProps[key];
+      }
+    }
+    this._checkRequiredProps(startViewStateProps);
+    this._checkRequiredProps(endViewStateProps);
+    return { start: startViewStateProps, end: endViewStateProps };
+  }
+  /**
+   * Returns transition duration
+   * @param startProps {object} - a list of starting viewport props
+   * @param endProps {object} - a list of target viewport props
+   * @returns {Number} - transition duration in milliseconds
+   */
+  getDuration(startProps, endProps) {
+    return endProps.transitionDuration;
+  }
+  _checkRequiredProps(props) {
+    if (!this._requiredProps) {
+      return;
+    }
+    this._requiredProps.forEach((propName) => {
+      const value = props[propName];
+      assert(Number.isFinite(value) || Array.isArray(value), `${propName} is required for transition`);
+    });
+  }
+}
+const DEGREES_TO_RADIANS$1 = Math.PI / 180;
+const RADIANS_TO_DEGREES = 180 / Math.PI;
+const EARTH_RADIUS = 6370972;
+const GLOBE_RADIUS = 256;
+function getDistanceScales() {
+  const unitsPerMeter2 = GLOBE_RADIUS / EARTH_RADIUS;
+  const unitsPerDegree = Math.PI / 180 * GLOBE_RADIUS;
+  return {
+    unitsPerMeter: [unitsPerMeter2, unitsPerMeter2, unitsPerMeter2],
+    unitsPerMeter2: [0, 0, 0],
+    metersPerUnit: [1 / unitsPerMeter2, 1 / unitsPerMeter2, 1 / unitsPerMeter2],
+    unitsPerDegree: [unitsPerDegree, unitsPerDegree, unitsPerMeter2],
+    unitsPerDegree2: [0, 0, 0],
+    degreesPerUnit: [1 / unitsPerDegree, 1 / unitsPerDegree, 1 / unitsPerMeter2]
+  };
+}
+class GlobeViewport extends Viewport {
+  constructor(opts = {}) {
+    const {
+      longitude = 0,
+      zoom = 0,
+      // Matches Maplibre defaults
+      // https://github.com/maplibre/maplibre-gl-js/blob/f8ab4b48d59ab8fe7b068b102538793bbdd4c848/src/geo/projection/globe_transform.ts#L632-L633
+      nearZMultiplier = 0.5,
+      farZMultiplier = 1,
+      resolution = 10
+    } = opts;
+    let { latitude = 0, height, altitude = 1.5, fovy } = opts;
+    latitude = Math.max(Math.min(latitude, MAX_LATITUDE), -85.051129);
+    height = height || 1;
+    if (fovy) {
+      altitude = fovyToAltitude(fovy);
+    } else {
+      fovy = altitudeToFovy(altitude);
+    }
+    const scale2 = Math.pow(2, zoom - zoomAdjust(latitude));
+    const nearZ = opts.nearZ ?? nearZMultiplier;
+    const farZ = opts.farZ ?? (altitude + GLOBE_RADIUS * 2 * scale2 / height) * farZMultiplier;
+    const viewMatrix = new Matrix4().lookAt({ eye: [0, -altitude, 0], up: [0, 0, 1] });
+    viewMatrix.rotateX(latitude * DEGREES_TO_RADIANS$1);
+    viewMatrix.rotateZ(-longitude * DEGREES_TO_RADIANS$1);
+    viewMatrix.scale(scale2 / height);
+    super({
+      ...opts,
+      // x, y, width,
+      height,
+      // view matrix
+      viewMatrix,
+      longitude,
+      latitude,
+      zoom,
+      // projection matrix parameters
+      distanceScales: getDistanceScales(),
+      fovy,
+      focalDistance: altitude,
+      near: nearZ,
+      far: farZ
+    });
+    this.scale = scale2;
+    this.latitude = latitude;
+    this.longitude = longitude;
+    this.fovy = fovy;
+    this.resolution = resolution;
+  }
+  get projectionMode() {
+    return PROJECTION_MODE.GLOBE;
+  }
+  getDistanceScales() {
+    return this.distanceScales;
+  }
+  getBounds(options = {}) {
+    const unprojectOption = { targetZ: options.z || 0 };
+    const left = this.unproject([0, this.height / 2], unprojectOption);
+    const top = this.unproject([this.width / 2, 0], unprojectOption);
+    const right = this.unproject([this.width, this.height / 2], unprojectOption);
+    const bottom = this.unproject([this.width / 2, this.height], unprojectOption);
+    if (right[0] < this.longitude)
+      right[0] += 360;
+    if (left[0] > this.longitude)
+      left[0] -= 360;
+    return [
+      Math.min(left[0], right[0], top[0], bottom[0]),
+      Math.min(left[1], right[1], top[1], bottom[1]),
+      Math.max(left[0], right[0], top[0], bottom[0]),
+      Math.max(left[1], right[1], top[1], bottom[1])
+    ];
+  }
+  unproject(xyz, { topLeft = true, targetZ } = {}) {
+    const [x2, y2, z2] = xyz;
+    const y22 = topLeft ? y2 : this.height - y2;
+    const { pixelUnprojectionMatrix } = this;
+    let coord;
+    if (Number.isFinite(z2)) {
+      coord = transformVector(pixelUnprojectionMatrix, [x2, y22, z2, 1]);
+    } else {
+      const coord0 = transformVector(pixelUnprojectionMatrix, [x2, y22, -1, 1]);
+      const coord1 = transformVector(pixelUnprojectionMatrix, [x2, y22, 1, 1]);
+      const lt2 = ((targetZ || 0) / EARTH_RADIUS + 1) * GLOBE_RADIUS;
+      const lSqr = sqrLen(sub([], coord0, coord1));
+      const l0Sqr = sqrLen(coord0);
+      const l1Sqr = sqrLen(coord1);
+      const sSqr = (4 * l0Sqr * l1Sqr - (lSqr - l0Sqr - l1Sqr) ** 2) / 16;
+      const dSqr = 4 * sSqr / lSqr;
+      const r0 = Math.sqrt(l0Sqr - dSqr);
+      const dr = Math.sqrt(Math.max(0, lt2 * lt2 - dSqr));
+      const t2 = (r0 - dr) / Math.sqrt(lSqr);
+      coord = lerp([], coord0, coord1, t2);
+    }
+    const [X2, Y2, Z2] = this.unprojectPosition(coord);
+    if (Number.isFinite(z2)) {
+      return [X2, Y2, Z2];
+    }
+    return Number.isFinite(targetZ) ? [X2, Y2, targetZ] : [X2, Y2];
+  }
+  projectPosition(xyz) {
+    const [lng, lat, Z2 = 0] = xyz;
+    const lambda = lng * DEGREES_TO_RADIANS$1;
+    const phi = lat * DEGREES_TO_RADIANS$1;
+    const cosPhi = Math.cos(phi);
+    const D2 = (Z2 / EARTH_RADIUS + 1) * GLOBE_RADIUS;
+    return [Math.sin(lambda) * cosPhi * D2, -Math.cos(lambda) * cosPhi * D2, Math.sin(phi) * D2];
+  }
+  unprojectPosition(xyz) {
+    const [x2, y2, z2] = xyz;
+    const D2 = len(xyz);
+    const phi = Math.asin(z2 / D2);
+    const lambda = Math.atan2(x2, -y2);
+    const lng = lambda * RADIANS_TO_DEGREES;
+    const lat = phi * RADIANS_TO_DEGREES;
+    const Z2 = (D2 / GLOBE_RADIUS - 1) * EARTH_RADIUS;
+    return [lng, lat, Z2];
+  }
+  projectFlat(xyz) {
+    return xyz;
+  }
+  unprojectFlat(xyz) {
+    return xyz;
+  }
+  /**
+   * Pan the globe using delta-based movement
+   * @param coords - the geographic coordinates where the pan started
+   * @param pixel - the current screen position
+   * @param startPixel - the screen position where the pan started
+   * @returns updated viewport options with new longitude/latitude
+   */
+  panByPosition([startLng, startLat, startZoom], pixel, startPixel) {
+    const scale2 = Math.pow(2, this.zoom - zoomAdjust(this.latitude));
+    const rotationSpeed = 0.25 / scale2;
+    const longitude = startLng + rotationSpeed * (startPixel[0] - pixel[0]);
+    let latitude = startLat - rotationSpeed * (startPixel[1] - pixel[1]);
+    latitude = Math.max(Math.min(latitude, MAX_LATITUDE), -85.051129);
+    const out = { longitude, latitude, zoom: startZoom - zoomAdjust(startLat) };
+    out.zoom += zoomAdjust(out.latitude);
+    return out;
+  }
+}
+GlobeViewport.displayName = "GlobeViewport";
+function zoomAdjust(latitude) {
+  const scaleAdjust = Math.PI * Math.cos(latitude * Math.PI / 180);
+  return Math.log2(scaleAdjust);
+}
+function transformVector(matrix, vector) {
+  const result = transformMat4([], vector, matrix);
+  scale(result, result, 1 / result[3]);
+  return result;
+}
+const DEFAULT_PROPS = ["longitude", "latitude", "zoom", "bearing", "pitch"];
+const DEFAULT_REQUIRED_PROPS = ["longitude", "latitude", "zoom"];
+class LinearInterpolator extends TransitionInterpolator {
+  /**
+   * @param {Object} opts
+   * @param {Array} opts.transitionProps - list of props to apply linear transition to.
+   * @param {Array} opts.around - a screen point to zoom/rotate around.
+   * @param {Function} opts.makeViewport - construct a viewport instance with given props.
+   */
+  constructor(opts = {}) {
+    const transitionProps = Array.isArray(opts) ? opts : opts.transitionProps;
+    const normalizedOpts = Array.isArray(opts) ? {} : opts;
+    normalizedOpts.transitionProps = Array.isArray(transitionProps) ? {
+      compare: transitionProps,
+      required: transitionProps
+    } : transitionProps || {
+      compare: DEFAULT_PROPS,
+      required: DEFAULT_REQUIRED_PROPS
+    };
+    super(normalizedOpts.transitionProps);
+    this.opts = normalizedOpts;
+  }
+  initializeProps(startProps, endProps) {
+    const result = super.initializeProps(startProps, endProps);
+    const { makeViewport, around } = this.opts;
+    if (makeViewport && around) {
+      const TestViewport = makeViewport(startProps);
+      if (TestViewport instanceof GlobeViewport) {
+        defaultLogger.warn("around not supported in GlobeView")();
+      } else {
+        const startViewport = makeViewport(startProps);
+        const endViewport = makeViewport(endProps);
+        const aroundPosition = startViewport.unproject(around);
+        result.start.around = around;
+        Object.assign(result.end, {
+          around: endViewport.project(aroundPosition),
+          aroundPosition,
+          width: endProps.width,
+          height: endProps.height
+        });
+      }
+    }
+    return result;
+  }
+  interpolateProps(startProps, endProps, t2) {
+    const propsInTransition = {};
+    for (const key of this._propsToExtract) {
+      propsInTransition[key] = lerp$2(startProps[key] || 0, endProps[key] || 0, t2);
+    }
+    if (endProps.aroundPosition && this.opts.makeViewport) {
+      const viewport = this.opts.makeViewport({ ...endProps, ...propsInTransition });
+      Object.assign(propsInTransition, viewport.panByPosition(
+        endProps.aroundPosition,
+        // anchor point in current screen coordinates
+        lerp$2(startProps.around, endProps.around, t2)
+      ));
+    }
+    return propsInTransition;
+  }
+}
+const NO_TRANSITION_PROPS = {
+  transitionDuration: 0
+};
+const DEFAULT_INERTIA = 300;
+const INERTIA_EASING = (t2) => 1 - (1 - t2) * (1 - t2);
+const EVENT_TYPES = {
+  WHEEL: ["wheel"],
+  PAN: ["panstart", "panmove", "panend"],
+  PINCH: ["pinchstart", "pinchmove", "pinchend"],
+  MULTI_PAN: ["multipanstart", "multipanmove", "multipanend"],
+  DOUBLE_CLICK: ["dblclick"],
+  KEYBOARD: ["keydown"]
+};
+const pinchEventWorkaround = {};
+class Controller {
+  constructor(opts) {
+    this.state = {};
+    this._events = {};
+    this._interactionState = {
+      isDragging: false
+    };
+    this._customEvents = [];
+    this._eventStartBlocked = null;
+    this._panMove = false;
+    this.invertPan = false;
+    this.dragMode = "rotate";
+    this.inertia = 0;
+    this.scrollZoom = true;
+    this.dragPan = true;
+    this.dragRotate = true;
+    this.doubleClickZoom = true;
+    this.touchZoom = true;
+    this.touchRotate = false;
+    this.keyboard = true;
+    this.transitionManager = new TransitionManager({
+      ...opts,
+      getControllerState: (props) => new this.ControllerState(props),
+      onViewStateChange: this._onTransition.bind(this),
+      onStateChange: this._setInteractionState.bind(this)
+    });
+    this.handleEvent = this.handleEvent.bind(this);
+    this.eventManager = opts.eventManager;
+    this.onViewStateChange = opts.onViewStateChange || (() => {
+    });
+    this.onStateChange = opts.onStateChange || (() => {
+    });
+    this.makeViewport = opts.makeViewport;
+  }
+  set events(customEvents) {
+    this.toggleEvents(this._customEvents, false);
+    this.toggleEvents(customEvents, true);
+    this._customEvents = customEvents;
+    if (this.props) {
+      this.setProps(this.props);
+    }
+  }
+  finalize() {
+    var _a3;
+    for (const eventName in this._events) {
+      if (this._events[eventName]) {
+        (_a3 = this.eventManager) == null ? void 0 : _a3.off(eventName, this.handleEvent);
+      }
+    }
+    this.transitionManager.finalize();
+  }
+  /**
+   * Callback for events
+   */
+  handleEvent(event) {
+    this._controllerState = void 0;
+    const eventStartBlocked = this._eventStartBlocked;
+    switch (event.type) {
+      case "panstart":
+        return eventStartBlocked ? false : this._onPanStart(event);
+      case "panmove":
+        return this._onPan(event);
+      case "panend":
+        return this._onPanEnd(event);
+      case "pinchstart":
+        return eventStartBlocked ? false : this._onPinchStart(event);
+      case "pinchmove":
+        return this._onPinch(event);
+      case "pinchend":
+        return this._onPinchEnd(event);
+      case "multipanstart":
+        return eventStartBlocked ? false : this._onMultiPanStart(event);
+      case "multipanmove":
+        return this._onMultiPan(event);
+      case "multipanend":
+        return this._onMultiPanEnd(event);
+      case "dblclick":
+        return this._onDoubleClick(event);
+      case "wheel":
+        return this._onWheel(event);
+      case "keydown":
+        return this._onKeyDown(event);
+      default:
+        return false;
+    }
+  }
+  /* Event utils */
+  // Event object: http://hammerjs.github.io/api/#event-object
+  get controllerState() {
+    this._controllerState = this._controllerState || new this.ControllerState({
+      makeViewport: this.makeViewport,
+      ...this.props,
+      ...this.state
+    });
+    return this._controllerState;
+  }
+  getCenter(event) {
+    const { x: x2, y: y2 } = this.props;
+    const { offsetCenter } = event;
+    return [offsetCenter.x - x2, offsetCenter.y - y2];
+  }
+  isPointInBounds(pos, event) {
+    const { width, height } = this.props;
+    if (event && event.handled) {
+      return false;
+    }
+    const inside = pos[0] >= 0 && pos[0] <= width && pos[1] >= 0 && pos[1] <= height;
+    if (inside && event) {
+      event.stopPropagation();
+    }
+    return inside;
+  }
+  isFunctionKeyPressed(event) {
+    const { srcEvent } = event;
+    return Boolean(srcEvent.metaKey || srcEvent.altKey || srcEvent.ctrlKey || srcEvent.shiftKey);
+  }
+  isDragging() {
+    return this._interactionState.isDragging || false;
+  }
+  // When a multi-touch event ends, e.g. pinch, not all pointers are lifted at the same time.
+  // This triggers a brief `pan` event.
+  // Calling this method will temporarily disable *start events to avoid conflicting transitions.
+  blockEvents(timeout) {
+    const timer = setTimeout(() => {
+      if (this._eventStartBlocked === timer) {
+        this._eventStartBlocked = null;
+      }
+    }, timeout);
+    this._eventStartBlocked = timer;
+  }
+  /**
+   * Extract interactivity options
+   */
+  setProps(props) {
+    if (props.dragMode) {
+      this.dragMode = props.dragMode;
+    }
+    this.props = props;
+    if (!("transitionInterpolator" in props)) {
+      props.transitionInterpolator = this._getTransitionProps().transitionInterpolator;
+    }
+    this.transitionManager.processViewStateChange(props);
+    const { inertia } = props;
+    this.inertia = Number.isFinite(inertia) ? inertia : inertia === true ? DEFAULT_INERTIA : 0;
+    const { scrollZoom = true, dragPan = true, dragRotate = true, doubleClickZoom = true, touchZoom = true, touchRotate = false, keyboard = true } = props;
+    const isInteractive = Boolean(this.onViewStateChange);
+    this.toggleEvents(EVENT_TYPES.WHEEL, isInteractive && scrollZoom);
+    this.toggleEvents(EVENT_TYPES.PAN, isInteractive);
+    this.toggleEvents(EVENT_TYPES.PINCH, isInteractive && (touchZoom || touchRotate));
+    this.toggleEvents(EVENT_TYPES.MULTI_PAN, isInteractive && touchRotate);
+    this.toggleEvents(EVENT_TYPES.DOUBLE_CLICK, isInteractive && doubleClickZoom);
+    this.toggleEvents(EVENT_TYPES.KEYBOARD, isInteractive && keyboard);
+    this.scrollZoom = scrollZoom;
+    this.dragPan = dragPan;
+    this.dragRotate = dragRotate;
+    this.doubleClickZoom = doubleClickZoom;
+    this.touchZoom = touchZoom;
+    this.touchRotate = touchRotate;
+    this.keyboard = keyboard;
+  }
+  updateTransition() {
+    this.transitionManager.updateTransition();
+  }
+  toggleEvents(eventNames, enabled) {
+    if (this.eventManager) {
+      eventNames.forEach((eventName) => {
+        if (this._events[eventName] !== enabled) {
+          this._events[eventName] = enabled;
+          if (enabled) {
+            this.eventManager.on(eventName, this.handleEvent);
+          } else {
+            this.eventManager.off(eventName, this.handleEvent);
+          }
+        }
+      });
+    }
+  }
+  // Private Methods
+  /* Callback util */
+  // formats map state and invokes callback function
+  updateViewport(newControllerState, extraProps = null, interactionState = {}) {
+    const viewState = { ...newControllerState.getViewportProps(), ...extraProps };
+    const changed = this.controllerState !== newControllerState;
+    this.state = newControllerState.getState();
+    this._setInteractionState(interactionState);
+    if (changed) {
+      const oldViewState = this.controllerState && this.controllerState.getViewportProps();
+      if (this.onViewStateChange) {
+        this.onViewStateChange({ viewState, interactionState: this._interactionState, oldViewState, viewId: this.props.id });
+      }
+    }
+  }
+  _onTransition(params) {
+    this.onViewStateChange({ ...params, interactionState: this._interactionState, viewId: this.props.id });
+  }
+  _setInteractionState(newStates) {
+    Object.assign(this._interactionState, newStates);
+    this.onStateChange(this._interactionState);
+  }
+  /* Event handlers */
+  // Default handler for the `panstart` event.
+  _onPanStart(event) {
+    const pos = this.getCenter(event);
+    if (!this.isPointInBounds(pos, event)) {
+      return false;
+    }
+    let alternateMode = this.isFunctionKeyPressed(event) || event.rightButton || false;
+    if (this.invertPan || this.dragMode === "pan") {
+      alternateMode = !alternateMode;
+    }
+    const newControllerState = this.controllerState[alternateMode ? "panStart" : "rotateStart"]({
+      pos
+    });
+    this._panMove = alternateMode;
+    this.updateViewport(newControllerState, NO_TRANSITION_PROPS, { isDragging: true });
+    return true;
+  }
+  // Default handler for the `panmove` and `panend` event.
+  _onPan(event) {
+    if (!this.isDragging()) {
+      return false;
+    }
+    return this._panMove ? this._onPanMove(event) : this._onPanRotate(event);
+  }
+  _onPanEnd(event) {
+    if (!this.isDragging()) {
+      return false;
+    }
+    return this._panMove ? this._onPanMoveEnd(event) : this._onPanRotateEnd(event);
+  }
+  // Default handler for panning to move.
+  // Called by `_onPan` when panning without function key pressed.
+  _onPanMove(event) {
+    if (!this.dragPan) {
+      return false;
+    }
+    const pos = this.getCenter(event);
+    const newControllerState = this.controllerState.pan({ pos });
+    this.updateViewport(newControllerState, NO_TRANSITION_PROPS, {
+      isDragging: true,
+      isPanning: true
+    });
+    return true;
+  }
+  _onPanMoveEnd(event) {
+    const { inertia } = this;
+    if (this.dragPan && inertia && event.velocity) {
+      const pos = this.getCenter(event);
+      const endPos = [
+        pos[0] + event.velocityX * inertia / 2,
+        pos[1] + event.velocityY * inertia / 2
+      ];
+      const newControllerState = this.controllerState.pan({ pos: endPos }).panEnd();
+      this.updateViewport(newControllerState, {
+        ...this._getTransitionProps(),
+        transitionDuration: inertia,
+        transitionEasing: INERTIA_EASING
+      }, {
+        isDragging: false,
+        isPanning: true
+      });
+    } else {
+      const newControllerState = this.controllerState.panEnd();
+      this.updateViewport(newControllerState, null, {
+        isDragging: false,
+        isPanning: false
+      });
+    }
+    return true;
+  }
+  // Default handler for panning to rotate.
+  // Called by `_onPan` when panning with function key pressed.
+  _onPanRotate(event) {
+    if (!this.dragRotate) {
+      return false;
+    }
+    const pos = this.getCenter(event);
+    const newControllerState = this.controllerState.rotate({ pos });
+    this.updateViewport(newControllerState, NO_TRANSITION_PROPS, {
+      isDragging: true,
+      isRotating: true
+    });
+    return true;
+  }
+  _onPanRotateEnd(event) {
+    const { inertia } = this;
+    if (this.dragRotate && inertia && event.velocity) {
+      const pos = this.getCenter(event);
+      const endPos = [
+        pos[0] + event.velocityX * inertia / 2,
+        pos[1] + event.velocityY * inertia / 2
+      ];
+      const newControllerState = this.controllerState.rotate({ pos: endPos }).rotateEnd();
+      this.updateViewport(newControllerState, {
+        ...this._getTransitionProps(),
+        transitionDuration: inertia,
+        transitionEasing: INERTIA_EASING
+      }, {
+        isDragging: false,
+        isRotating: true
+      });
+    } else {
+      const newControllerState = this.controllerState.rotateEnd();
+      this.updateViewport(newControllerState, null, {
+        isDragging: false,
+        isRotating: false
+      });
+    }
+    return true;
+  }
+  // Default handler for the `wheel` event.
+  _onWheel(event) {
+    if (!this.scrollZoom) {
+      return false;
+    }
+    const pos = this.getCenter(event);
+    if (!this.isPointInBounds(pos, event)) {
+      return false;
+    }
+    event.srcEvent.preventDefault();
+    const { speed = 0.01, smooth = false } = this.scrollZoom === true ? {} : this.scrollZoom;
+    const { delta } = event;
+    let scale2 = 2 / (1 + Math.exp(-Math.abs(delta * speed)));
+    if (delta < 0 && scale2 !== 0) {
+      scale2 = 1 / scale2;
+    }
+    const transitionProps = smooth ? { ...this._getTransitionProps({ around: pos }), transitionDuration: 250 } : NO_TRANSITION_PROPS;
+    const newControllerState = this.controllerState.zoom({ pos, scale: scale2 });
+    this.updateViewport(newControllerState, transitionProps, {
+      isZooming: true,
+      isPanning: true
+    });
+    if (!smooth) {
+      this._setInteractionState({ isZooming: false, isPanning: false });
+    }
+    return true;
+  }
+  _onMultiPanStart(event) {
+    const pos = this.getCenter(event);
+    if (!this.isPointInBounds(pos, event)) {
+      return false;
+    }
+    const newControllerState = this.controllerState.rotateStart({ pos });
+    this.updateViewport(newControllerState, NO_TRANSITION_PROPS, { isDragging: true });
+    return true;
+  }
+  _onMultiPan(event) {
+    if (!this.touchRotate) {
+      return false;
+    }
+    if (!this.isDragging()) {
+      return false;
+    }
+    const pos = this.getCenter(event);
+    pos[0] -= event.deltaX;
+    const newControllerState = this.controllerState.rotate({ pos });
+    this.updateViewport(newControllerState, NO_TRANSITION_PROPS, {
+      isDragging: true,
+      isRotating: true
+    });
+    return true;
+  }
+  _onMultiPanEnd(event) {
+    if (!this.isDragging()) {
+      return false;
+    }
+    const { inertia } = this;
+    if (this.touchRotate && inertia && event.velocityY) {
+      const pos = this.getCenter(event);
+      const endPos = [pos[0], pos[1] += event.velocityY * inertia / 2];
+      const newControllerState = this.controllerState.rotate({ pos: endPos });
+      this.updateViewport(newControllerState, {
+        ...this._getTransitionProps(),
+        transitionDuration: inertia,
+        transitionEasing: INERTIA_EASING
+      }, {
+        isDragging: false,
+        isRotating: true
+      });
+      this.blockEvents(inertia);
+    } else {
+      const newControllerState = this.controllerState.rotateEnd();
+      this.updateViewport(newControllerState, null, {
+        isDragging: false,
+        isRotating: false
+      });
+    }
+    return true;
+  }
+  // Default handler for the `pinchstart` event.
+  _onPinchStart(event) {
+    const pos = this.getCenter(event);
+    if (!this.isPointInBounds(pos, event)) {
+      return false;
+    }
+    const newControllerState = this.controllerState.zoomStart({ pos }).rotateStart({ pos });
+    pinchEventWorkaround._startPinchRotation = event.rotation;
+    pinchEventWorkaround._lastPinchEvent = event;
+    this.updateViewport(newControllerState, NO_TRANSITION_PROPS, { isDragging: true });
+    return true;
+  }
+  // Default handler for the `pinchmove` and `pinchend` events.
+  _onPinch(event) {
+    if (!this.touchZoom && !this.touchRotate) {
+      return false;
+    }
+    if (!this.isDragging()) {
+      return false;
+    }
+    let newControllerState = this.controllerState;
+    if (this.touchZoom) {
+      const { scale: scale2 } = event;
+      const pos = this.getCenter(event);
+      newControllerState = newControllerState.zoom({ pos, scale: scale2 });
+    }
+    if (this.touchRotate) {
+      const { rotation } = event;
+      newControllerState = newControllerState.rotate({
+        deltaAngleX: pinchEventWorkaround._startPinchRotation - rotation
+      });
+    }
+    this.updateViewport(newControllerState, NO_TRANSITION_PROPS, {
+      isDragging: true,
+      isPanning: this.touchZoom,
+      isZooming: this.touchZoom,
+      isRotating: this.touchRotate
+    });
+    pinchEventWorkaround._lastPinchEvent = event;
+    return true;
+  }
+  _onPinchEnd(event) {
+    if (!this.isDragging()) {
+      return false;
+    }
+    const { inertia } = this;
+    const { _lastPinchEvent } = pinchEventWorkaround;
+    if (this.touchZoom && inertia && _lastPinchEvent && event.scale !== _lastPinchEvent.scale) {
+      const pos = this.getCenter(event);
+      let newControllerState = this.controllerState.rotateEnd();
+      const z2 = Math.log2(event.scale);
+      const velocityZ = (z2 - Math.log2(_lastPinchEvent.scale)) / (event.deltaTime - _lastPinchEvent.deltaTime);
+      const endScale = Math.pow(2, z2 + velocityZ * inertia / 2);
+      newControllerState = newControllerState.zoom({ pos, scale: endScale }).zoomEnd();
+      this.updateViewport(newControllerState, {
+        ...this._getTransitionProps({ around: pos }),
+        transitionDuration: inertia,
+        transitionEasing: INERTIA_EASING
+      }, {
+        isDragging: false,
+        isPanning: this.touchZoom,
+        isZooming: this.touchZoom,
+        isRotating: false
+      });
+      this.blockEvents(inertia);
+    } else {
+      const newControllerState = this.controllerState.zoomEnd().rotateEnd();
+      this.updateViewport(newControllerState, null, {
+        isDragging: false,
+        isPanning: false,
+        isZooming: false,
+        isRotating: false
+      });
+    }
+    pinchEventWorkaround._startPinchRotation = null;
+    pinchEventWorkaround._lastPinchEvent = null;
+    return true;
+  }
+  // Default handler for the `dblclick` event.
+  _onDoubleClick(event) {
+    if (!this.doubleClickZoom) {
+      return false;
+    }
+    const pos = this.getCenter(event);
+    if (!this.isPointInBounds(pos, event)) {
+      return false;
+    }
+    const isZoomOut = this.isFunctionKeyPressed(event);
+    const newControllerState = this.controllerState.zoom({ pos, scale: isZoomOut ? 0.5 : 2 });
+    this.updateViewport(newControllerState, this._getTransitionProps({ around: pos }), {
+      isZooming: true,
+      isPanning: true
+    });
+    this.blockEvents(100);
+    return true;
+  }
+  // Default handler for the `keydown` event
+  _onKeyDown(event) {
+    if (!this.keyboard) {
+      return false;
+    }
+    const funcKey = this.isFunctionKeyPressed(event);
+    const { zoomSpeed, moveSpeed, rotateSpeedX, rotateSpeedY } = this.keyboard === true ? {} : this.keyboard;
+    const { controllerState } = this;
+    let newControllerState;
+    const interactionState = {};
+    switch (event.srcEvent.code) {
+      case "Minus":
+        newControllerState = funcKey ? controllerState.zoomOut(zoomSpeed).zoomOut(zoomSpeed) : controllerState.zoomOut(zoomSpeed);
+        interactionState.isZooming = true;
+        break;
+      case "Equal":
+        newControllerState = funcKey ? controllerState.zoomIn(zoomSpeed).zoomIn(zoomSpeed) : controllerState.zoomIn(zoomSpeed);
+        interactionState.isZooming = true;
+        break;
+      case "ArrowLeft":
+        if (funcKey) {
+          newControllerState = controllerState.rotateLeft(rotateSpeedX);
+          interactionState.isRotating = true;
+        } else {
+          newControllerState = controllerState.moveLeft(moveSpeed);
+          interactionState.isPanning = true;
+        }
+        break;
+      case "ArrowRight":
+        if (funcKey) {
+          newControllerState = controllerState.rotateRight(rotateSpeedX);
+          interactionState.isRotating = true;
+        } else {
+          newControllerState = controllerState.moveRight(moveSpeed);
+          interactionState.isPanning = true;
+        }
+        break;
+      case "ArrowUp":
+        if (funcKey) {
+          newControllerState = controllerState.rotateUp(rotateSpeedY);
+          interactionState.isRotating = true;
+        } else {
+          newControllerState = controllerState.moveUp(moveSpeed);
+          interactionState.isPanning = true;
+        }
+        break;
+      case "ArrowDown":
+        if (funcKey) {
+          newControllerState = controllerState.rotateDown(rotateSpeedY);
+          interactionState.isRotating = true;
+        } else {
+          newControllerState = controllerState.moveDown(moveSpeed);
+          interactionState.isPanning = true;
+        }
+        break;
+      default:
+        return false;
+    }
+    this.updateViewport(newControllerState, this._getTransitionProps(), interactionState);
+    return true;
+  }
+  _getTransitionProps(opts) {
+    const { transition } = this;
+    if (!transition || !transition.transitionInterpolator) {
+      return NO_TRANSITION_PROPS;
+    }
+    return opts ? {
+      ...transition,
+      transitionInterpolator: new LinearInterpolator({
+        ...opts,
+        ...transition.transitionInterpolator.opts,
+        makeViewport: this.controllerState.makeViewport
+      })
+    } : transition;
+  }
+}
+class ViewState {
+  constructor(props, state) {
+    this._viewportProps = this.applyConstraints(props);
+    this._state = state;
+  }
+  getViewportProps() {
+    return this._viewportProps;
+  }
+  getState() {
+    return this._state;
+  }
+}
+const PITCH_MOUSE_THRESHOLD = 5;
+const PITCH_ACCEL = 1.2;
+class MapState extends ViewState {
+  constructor(options) {
+    const {
+      /** Mapbox viewport properties */
+      /** The width of the viewport */
+      width,
+      /** The height of the viewport */
+      height,
+      /** The latitude at the center of the viewport */
+      latitude,
+      /** The longitude at the center of the viewport */
+      longitude,
+      /** The tile zoom level of the map. */
+      zoom,
+      /** The bearing of the viewport in degrees */
+      bearing = 0,
+      /** The pitch of the viewport in degrees */
+      pitch = 0,
+      /**
+       * Specify the altitude of the viewport camera
+       * Unit: map heights, default 1.5
+       * Non-public API, see https://github.com/mapbox/mapbox-gl-js/issues/1137
+       */
+      altitude = 1.5,
+      /** Viewport position */
+      position = [0, 0, 0],
+      /** Viewport constraints */
+      maxZoom = 20,
+      minZoom = 0,
+      maxPitch = 60,
+      minPitch = 0,
+      /** Interaction states, required to calculate change during transform */
+      /* The point on map being grabbed when the operation first started */
+      startPanLngLat,
+      /* Center of the zoom when the operation first started */
+      startZoomLngLat,
+      /* Pointer position when rotation started */
+      startRotatePos,
+      /** Bearing when current perspective rotate operation started */
+      startBearing,
+      /** Pitch when current perspective rotate operation started */
+      startPitch,
+      /** Zoom when current zoom operation started */
+      startZoom,
+      /** Normalize viewport props to fit map height into viewport */
+      normalize = true
+    } = options;
+    assert(Number.isFinite(longitude));
+    assert(Number.isFinite(latitude));
+    assert(Number.isFinite(zoom));
+    super({
+      width,
+      height,
+      latitude,
+      longitude,
+      zoom,
+      bearing,
+      pitch,
+      altitude,
+      maxZoom,
+      minZoom,
+      maxPitch,
+      minPitch,
+      normalize,
+      position
+    }, {
+      startPanLngLat,
+      startZoomLngLat,
+      startRotatePos,
+      startBearing,
+      startPitch,
+      startZoom
+    });
+    this.makeViewport = options.makeViewport;
+  }
+  /**
+   * Start panning
+   * @param {[Number, Number]} pos - position on screen where the pointer grabs
+   */
+  panStart({ pos }) {
+    return this._getUpdatedState({
+      startPanLngLat: this._unproject(pos)
+    });
+  }
+  /**
+   * Pan
+   * @param {[Number, Number]} pos - position on screen where the pointer is
+   * @param {[Number, Number], optional} startPos - where the pointer grabbed at
+   *   the start of the operation. Must be supplied of `panStart()` was not called
+   */
+  pan({ pos, startPos }) {
+    const startPanLngLat = this.getState().startPanLngLat || this._unproject(startPos);
+    if (!startPanLngLat) {
+      return this;
+    }
+    const viewport = this.makeViewport(this.getViewportProps());
+    const newProps = viewport.panByPosition(startPanLngLat, pos);
+    return this._getUpdatedState(newProps);
+  }
+  /**
+   * End panning
+   * Must call if `panStart()` was called
+   */
+  panEnd() {
+    return this._getUpdatedState({
+      startPanLngLat: null
+    });
+  }
+  /**
+   * Start rotating
+   * @param {[Number, Number]} pos - position on screen where the center is
+   */
+  rotateStart({ pos }) {
+    return this._getUpdatedState({
+      startRotatePos: pos,
+      startBearing: this.getViewportProps().bearing,
+      startPitch: this.getViewportProps().pitch
+    });
+  }
+  /**
+   * Rotate
+   * @param {[Number, Number]} pos - position on screen where the center is
+   */
+  rotate({ pos, deltaAngleX = 0, deltaAngleY = 0 }) {
+    const { startRotatePos, startBearing, startPitch } = this.getState();
+    if (!startRotatePos || startBearing === void 0 || startPitch === void 0) {
+      return this;
+    }
+    let newRotation;
+    if (pos) {
+      newRotation = this._getNewRotation(pos, startRotatePos, startPitch, startBearing);
+    } else {
+      newRotation = {
+        bearing: startBearing + deltaAngleX,
+        pitch: startPitch + deltaAngleY
+      };
+    }
+    return this._getUpdatedState(newRotation);
+  }
+  /**
+   * End rotating
+   * Must call if `rotateStart()` was called
+   */
+  rotateEnd() {
+    return this._getUpdatedState({
+      startBearing: null,
+      startPitch: null
+    });
+  }
+  /**
+   * Start zooming
+   * @param {[Number, Number]} pos - position on screen where the center is
+   */
+  zoomStart({ pos }) {
+    return this._getUpdatedState({
+      startZoomLngLat: this._unproject(pos),
+      startZoom: this.getViewportProps().zoom
+    });
+  }
+  /**
+   * Zoom
+   * @param {[Number, Number]} pos - position on screen where the current center is
+   * @param {[Number, Number]} startPos - the center position at
+   *   the start of the operation. Must be supplied of `zoomStart()` was not called
+   * @param {Number} scale - a number between [0, 1] specifying the accumulated
+   *   relative scale.
+   */
+  zoom({ pos, startPos, scale: scale2 }) {
+    let { startZoom, startZoomLngLat } = this.getState();
+    if (!startZoomLngLat) {
+      startZoom = this.getViewportProps().zoom;
+      startZoomLngLat = this._unproject(startPos) || this._unproject(pos);
+    }
+    if (!startZoomLngLat) {
+      return this;
+    }
+    const { maxZoom, minZoom } = this.getViewportProps();
+    let zoom = startZoom + Math.log2(scale2);
+    zoom = clamp$1(zoom, minZoom, maxZoom);
+    const zoomedViewport = this.makeViewport({ ...this.getViewportProps(), zoom });
+    return this._getUpdatedState({
+      zoom,
+      ...zoomedViewport.panByPosition(startZoomLngLat, pos)
+    });
+  }
+  /**
+   * End zooming
+   * Must call if `zoomStart()` was called
+   */
+  zoomEnd() {
+    return this._getUpdatedState({
+      startZoomLngLat: null,
+      startZoom: null
+    });
+  }
+  zoomIn(speed = 2) {
+    return this._zoomFromCenter(speed);
+  }
+  zoomOut(speed = 2) {
+    return this._zoomFromCenter(1 / speed);
+  }
+  moveLeft(speed = 100) {
+    return this._panFromCenter([speed, 0]);
+  }
+  moveRight(speed = 100) {
+    return this._panFromCenter([-speed, 0]);
+  }
+  moveUp(speed = 100) {
+    return this._panFromCenter([0, speed]);
+  }
+  moveDown(speed = 100) {
+    return this._panFromCenter([0, -speed]);
+  }
+  rotateLeft(speed = 15) {
+    return this._getUpdatedState({
+      bearing: this.getViewportProps().bearing - speed
+    });
+  }
+  rotateRight(speed = 15) {
+    return this._getUpdatedState({
+      bearing: this.getViewportProps().bearing + speed
+    });
+  }
+  rotateUp(speed = 10) {
+    return this._getUpdatedState({
+      pitch: this.getViewportProps().pitch + speed
+    });
+  }
+  rotateDown(speed = 10) {
+    return this._getUpdatedState({
+      pitch: this.getViewportProps().pitch - speed
+    });
+  }
+  shortestPathFrom(viewState) {
+    const fromProps = viewState.getViewportProps();
+    const props = { ...this.getViewportProps() };
+    const { bearing, longitude } = props;
+    if (Math.abs(bearing - fromProps.bearing) > 180) {
+      props.bearing = bearing < 0 ? bearing + 360 : bearing - 360;
+    }
+    if (Math.abs(longitude - fromProps.longitude) > 180) {
+      props.longitude = longitude < 0 ? longitude + 360 : longitude - 360;
+    }
+    return props;
+  }
+  // Apply any constraints (mathematical or defined by _viewportProps) to map state
+  applyConstraints(props) {
+    const { maxZoom, minZoom, zoom } = props;
+    props.zoom = clamp$1(zoom, minZoom, maxZoom);
+    const { maxPitch, minPitch, pitch } = props;
+    props.pitch = clamp$1(pitch, minPitch, maxPitch);
+    const { normalize = true } = props;
+    if (normalize) {
+      Object.assign(props, normalizeViewportProps(props));
+    }
+    return props;
+  }
+  /* Private methods */
+  _zoomFromCenter(scale2) {
+    const { width, height } = this.getViewportProps();
+    return this.zoom({
+      pos: [width / 2, height / 2],
+      scale: scale2
+    });
+  }
+  _panFromCenter(offset) {
+    const { width, height } = this.getViewportProps();
+    return this.pan({
+      startPos: [width / 2, height / 2],
+      pos: [width / 2 + offset[0], height / 2 + offset[1]]
+    });
+  }
+  _getUpdatedState(newProps) {
+    return new this.constructor({
+      makeViewport: this.makeViewport,
+      ...this.getViewportProps(),
+      ...this.getState(),
+      ...newProps
+    });
+  }
+  _unproject(pos) {
+    const viewport = this.makeViewport(this.getViewportProps());
+    return pos && viewport.unproject(pos);
+  }
+  _getNewRotation(pos, startPos, startPitch, startBearing) {
+    const deltaX = pos[0] - startPos[0];
+    const deltaY = pos[1] - startPos[1];
+    const centerY = pos[1];
+    const startY = startPos[1];
+    const { width, height } = this.getViewportProps();
+    const deltaScaleX = deltaX / width;
+    let deltaScaleY = 0;
+    if (deltaY > 0) {
+      if (Math.abs(height - startY) > PITCH_MOUSE_THRESHOLD) {
+        deltaScaleY = deltaY / (startY - height) * PITCH_ACCEL;
+      }
+    } else if (deltaY < 0) {
+      if (startY > PITCH_MOUSE_THRESHOLD) {
+        deltaScaleY = 1 - centerY / startY;
+      }
+    }
+    deltaScaleY = clamp$1(deltaScaleY, -1, 1);
+    const { minPitch, maxPitch } = this.getViewportProps();
+    const bearing = startBearing + 180 * deltaScaleX;
+    let pitch = startPitch;
+    if (deltaScaleY > 0) {
+      pitch = startPitch + deltaScaleY * (maxPitch - startPitch);
+    } else if (deltaScaleY < 0) {
+      pitch = startPitch - deltaScaleY * (minPitch - startPitch);
+    }
+    return {
+      pitch,
+      bearing
+    };
+  }
+}
+class MapController extends Controller {
+  constructor() {
+    super(...arguments);
+    this.ControllerState = MapState;
+    this.transition = {
+      transitionDuration: 300,
+      transitionInterpolator: new LinearInterpolator({
+        transitionProps: {
+          compare: ["longitude", "latitude", "zoom", "bearing", "pitch", "position"],
+          required: ["longitude", "latitude", "zoom"]
+        }
+      })
+    };
+    this.dragMode = "pan";
+  }
+  setProps(props) {
+    props.position = props.position || [0, 0, 0];
+    const oldProps = this.props;
+    super.setProps(props);
+    const dimensionChanged = !oldProps || oldProps.height !== props.height;
+    if (dimensionChanged) {
+      this.updateViewport(new this.ControllerState({
+        makeViewport: this.makeViewport,
+        ...props,
+        ...this.state
+      }));
+    }
+  }
+}
+class MapView extends View {
+  constructor(props = {}) {
+    super(props);
+  }
+  getViewportType() {
+    return WebMercatorViewport;
+  }
+  get ControllerType() {
+    return MapController;
+  }
+}
+MapView.displayName = "MapView";
+const DEFAULT_LIGHTING_EFFECT = new LightingEffect();
+function compareEffects(e1, e2) {
+  const o1 = e1.order ?? Infinity;
+  const o2 = e2.order ?? Infinity;
+  return o1 - o2;
+}
+class EffectManager {
+  constructor(context) {
+    this._resolvedEffects = [];
+    this._defaultEffects = [];
+    this.effects = [];
+    this._context = context;
+    this._needsRedraw = "Initial render";
+    this._setEffects([]);
+  }
+  /**
+   * Register a new default effect, i.e. an effect presents regardless of user supplied props.effects
+   */
+  addDefaultEffect(effect) {
+    const defaultEffects = this._defaultEffects;
+    if (!defaultEffects.find((e2) => e2.id === effect.id)) {
+      const index = defaultEffects.findIndex((e2) => compareEffects(e2, effect) > 0);
+      if (index < 0) {
+        defaultEffects.push(effect);
+      } else {
+        defaultEffects.splice(index, 0, effect);
+      }
+      effect.setup(this._context);
+      this._setEffects(this.effects);
+    }
+  }
+  setProps(props) {
+    if ("effects" in props) {
+      if (!deepEqual(props.effects, this.effects, 1)) {
+        this._setEffects(props.effects);
+      }
+    }
+  }
+  needsRedraw(opts = { clearRedrawFlags: false }) {
+    const redraw = this._needsRedraw;
+    if (opts.clearRedrawFlags) {
+      this._needsRedraw = false;
+    }
+    return redraw;
+  }
+  getEffects() {
+    return this._resolvedEffects;
+  }
+  _setEffects(effects) {
+    const oldEffectsMap = {};
+    for (const effect of this.effects) {
+      oldEffectsMap[effect.id] = effect;
+    }
+    const nextEffects = [];
+    for (const effect of effects) {
+      const oldEffect = oldEffectsMap[effect.id];
+      let effectToAdd = effect;
+      if (oldEffect && oldEffect !== effect) {
+        if (oldEffect.setProps) {
+          oldEffect.setProps(effect.props);
+          effectToAdd = oldEffect;
+        } else {
+          oldEffect.cleanup(this._context);
+        }
+      } else if (!oldEffect) {
+        effect.setup(this._context);
+      }
+      nextEffects.push(effectToAdd);
+      delete oldEffectsMap[effect.id];
+    }
+    for (const removedEffectId in oldEffectsMap) {
+      oldEffectsMap[removedEffectId].cleanup(this._context);
+    }
+    this.effects = nextEffects;
+    this._resolvedEffects = nextEffects.concat(this._defaultEffects);
+    if (!effects.some((effect) => effect instanceof LightingEffect)) {
+      this._resolvedEffects.push(DEFAULT_LIGHTING_EFFECT);
+    }
+    this._needsRedraw = "effects changed";
+  }
+  finalize() {
+    for (const effect of this._resolvedEffects) {
+      effect.cleanup(this._context);
+    }
+    this.effects.length = 0;
+    this._resolvedEffects.length = 0;
+    this._defaultEffects.length = 0;
+  }
+}
+class DrawLayersPass extends LayersPass {
+  shouldDrawLayer(layer) {
+    const { operation } = layer.props;
+    return operation.includes("draw") || operation.includes("terrain");
+  }
+}
+const TRACE_RENDER_LAYERS = "deckRenderer.renderLayers";
+class DeckRenderer {
+  constructor(device) {
+    this.device = device;
+    this.layerFilter = null;
+    this.drawPickingColors = false;
+    this.drawLayersPass = new DrawLayersPass(device);
+    this.pickLayersPass = new PickLayersPass(device);
+    this.renderCount = 0;
+    this._needsRedraw = "Initial render";
+    this.renderBuffers = [];
+    this.lastPostProcessEffect = null;
+  }
+  setProps(props) {
+    if (this.layerFilter !== props.layerFilter) {
+      this.layerFilter = props.layerFilter;
+      this._needsRedraw = "layerFilter changed";
+    }
+    if (this.drawPickingColors !== props.drawPickingColors) {
+      this.drawPickingColors = props.drawPickingColors;
+      this._needsRedraw = "drawPickingColors changed";
+    }
+  }
+  renderLayers(opts) {
+    if (!opts.viewports.length) {
+      return;
+    }
+    const layerPass = this.drawPickingColors ? this.pickLayersPass : this.drawLayersPass;
+    const renderOpts = {
+      layerFilter: this.layerFilter,
+      isPicking: this.drawPickingColors,
+      ...opts
+    };
+    if (renderOpts.effects) {
+      this._preRender(renderOpts.effects, renderOpts);
+    }
+    const outputBuffer = this.lastPostProcessEffect ? this.renderBuffers[0] : renderOpts.target;
+    if (this.lastPostProcessEffect) {
+      renderOpts.clearColor = [0, 0, 0, 0];
+      renderOpts.clearCanvas = true;
+    }
+    const renderStats = layerPass.render({ ...renderOpts, target: outputBuffer });
+    if (renderOpts.effects) {
+      if (this.lastPostProcessEffect) {
+        renderOpts.clearCanvas = opts.clearCanvas === void 0 ? true : opts.clearCanvas;
+      }
+      this._postRender(renderOpts.effects, renderOpts);
+    }
+    this.renderCount++;
+    debug(TRACE_RENDER_LAYERS, this, renderStats, opts);
+  }
+  needsRedraw(opts = { clearRedrawFlags: false }) {
+    const redraw = this._needsRedraw;
+    if (opts.clearRedrawFlags) {
+      this._needsRedraw = false;
+    }
+    return redraw;
+  }
+  finalize() {
+    const { renderBuffers } = this;
+    for (const buffer of renderBuffers) {
+      buffer.delete();
+    }
+    renderBuffers.length = 0;
+  }
+  _preRender(effects, opts) {
+    this.lastPostProcessEffect = null;
+    opts.preRenderStats = opts.preRenderStats || {};
+    for (const effect of effects) {
+      opts.preRenderStats[effect.id] = effect.preRender(opts);
+      if (effect.postRender) {
+        this.lastPostProcessEffect = effect.id;
+      }
+    }
+    if (this.lastPostProcessEffect) {
+      this._resizeRenderBuffers();
+    }
+  }
+  _resizeRenderBuffers() {
+    const { renderBuffers } = this;
+    const size = this.device.canvasContext.getDrawingBufferSize();
+    const [width, height] = size;
+    if (renderBuffers.length === 0) {
+      [0, 1].map((i2) => {
+        const texture = this.device.createTexture({
+          sampler: { minFilter: "linear", magFilter: "linear" },
+          width,
+          height
+        });
+        renderBuffers.push(this.device.createFramebuffer({
+          id: `deck-renderbuffer-${i2}`,
+          colorAttachments: [texture]
+        }));
+      });
+    }
+    for (const buffer of renderBuffers) {
+      buffer.resize(size);
+    }
+  }
+  _postRender(effects, opts) {
+    const { renderBuffers } = this;
+    const params = {
+      ...opts,
+      inputBuffer: renderBuffers[0],
+      swapBuffer: renderBuffers[1]
+    };
+    for (const effect of effects) {
+      if (effect.postRender) {
+        params.target = effect.id === this.lastPostProcessEffect ? opts.target : void 0;
+        const buffer = effect.postRender(params);
+        params.inputBuffer = buffer;
+        params.swapBuffer = buffer === renderBuffers[0] ? renderBuffers[1] : renderBuffers[0];
+      }
+    }
+  }
+}
+const NO_PICKED_OBJECT = {
+  pickedColor: null,
+  pickedObjectIndex: -1
+};
+function getClosestObject({ pickedColors, decodePickingColor, deviceX, deviceY, deviceRadius, deviceRect }) {
+  const { x: x2, y: y2, width, height } = deviceRect;
+  let minSquareDistanceToCenter = deviceRadius * deviceRadius;
+  let closestPixelIndex = -1;
+  let i2 = 0;
+  for (let row = 0; row < height; row++) {
+    const dy = row + y2 - deviceY;
+    const dy2 = dy * dy;
+    if (dy2 > minSquareDistanceToCenter) {
+      i2 += 4 * width;
+    } else {
+      for (let col = 0; col < width; col++) {
+        const pickedLayerIndex = pickedColors[i2 + 3] - 1;
+        if (pickedLayerIndex >= 0) {
+          const dx = col + x2 - deviceX;
+          const d2 = dx * dx + dy2;
+          if (d2 <= minSquareDistanceToCenter) {
+            minSquareDistanceToCenter = d2;
+            closestPixelIndex = i2;
+          }
+        }
+        i2 += 4;
+      }
+    }
+  }
+  if (closestPixelIndex >= 0) {
+    const pickedColor = pickedColors.slice(closestPixelIndex, closestPixelIndex + 4);
+    const pickedObject = decodePickingColor(pickedColor);
+    if (pickedObject) {
+      const dy = Math.floor(closestPixelIndex / 4 / width);
+      const dx = closestPixelIndex / 4 - dy * width;
+      return {
+        ...pickedObject,
+        pickedColor,
+        pickedX: x2 + dx,
+        pickedY: y2 + dy
+      };
+    }
+    defaultLogger.error("Picked non-existent layer. Is picking buffer corrupt?")();
+  }
+  return NO_PICKED_OBJECT;
+}
+function getUniqueObjects({ pickedColors, decodePickingColor }) {
+  const uniqueColors = /* @__PURE__ */ new Map();
+  if (pickedColors) {
+    for (let i2 = 0; i2 < pickedColors.length; i2 += 4) {
+      const pickedLayerIndex = pickedColors[i2 + 3] - 1;
+      if (pickedLayerIndex >= 0) {
+        const pickedColor = pickedColors.slice(i2, i2 + 4);
+        const colorKey = pickedColor.join(",");
+        if (!uniqueColors.has(colorKey)) {
+          const pickedObject = decodePickingColor(pickedColor);
+          if (pickedObject) {
+            uniqueColors.set(colorKey, {
+              ...pickedObject,
+              color: pickedColor
+            });
+          } else {
+            defaultLogger.error("Picked non-existent layer. Is picking buffer corrupt?")();
+          }
+        }
+      }
+    }
+  }
+  return Array.from(uniqueColors.values());
+}
+function getEmptyPickingInfo({ pickInfo, viewports, pixelRatio, x: x2, y: y2, z: z2 }) {
+  let pickedViewport = viewports[0];
+  if (viewports.length > 1) {
+    pickedViewport = getViewportFromCoordinates((pickInfo == null ? void 0 : pickInfo.pickedViewports) || viewports, { x: x2, y: y2 });
+  }
+  let coordinate;
+  if (pickedViewport) {
+    const point = [x2 - pickedViewport.x, y2 - pickedViewport.y];
+    if (z2 !== void 0) {
+      point[2] = z2;
+    }
+    coordinate = pickedViewport.unproject(point);
+  }
+  return {
+    color: null,
+    layer: null,
+    viewport: pickedViewport,
+    index: -1,
+    picked: false,
+    x: x2,
+    y: y2,
+    pixel: [x2, y2],
+    coordinate,
+    devicePixel: pickInfo && "pickedX" in pickInfo ? [pickInfo.pickedX, pickInfo.pickedY] : void 0,
+    pixelRatio
+  };
+}
+function processPickInfo(opts) {
+  const { pickInfo, lastPickedInfo, mode, layers } = opts;
+  const { pickedColor, pickedLayer, pickedObjectIndex } = pickInfo;
+  const affectedLayers = pickedLayer ? [pickedLayer] : [];
+  if (mode === "hover") {
+    const lastPickedPixelIndex = lastPickedInfo.index;
+    const lastPickedLayerId = lastPickedInfo.layerId;
+    const pickedLayerId = pickedLayer ? pickedLayer.props.id : null;
+    if (pickedLayerId !== lastPickedLayerId || pickedObjectIndex !== lastPickedPixelIndex) {
+      if (pickedLayerId !== lastPickedLayerId) {
+        const lastPickedLayer = layers.find((layer) => layer.props.id === lastPickedLayerId);
+        if (lastPickedLayer) {
+          affectedLayers.unshift(lastPickedLayer);
+        }
+      }
+      lastPickedInfo.layerId = pickedLayerId;
+      lastPickedInfo.index = pickedObjectIndex;
+      lastPickedInfo.info = null;
+    }
+  }
+  const baseInfo = getEmptyPickingInfo(opts);
+  const infos = /* @__PURE__ */ new Map();
+  infos.set(null, baseInfo);
+  affectedLayers.forEach((layer) => {
+    let info = { ...baseInfo };
+    if (layer === pickedLayer) {
+      info.color = pickedColor;
+      info.index = pickedObjectIndex;
+      info.picked = true;
+    }
+    info = getLayerPickingInfo({ layer, info, mode });
+    const rootLayer = info.layer;
+    if (layer === pickedLayer && mode === "hover") {
+      lastPickedInfo.info = info;
+    }
+    infos.set(rootLayer.id, info);
+    if (mode === "hover") {
+      rootLayer.updateAutoHighlight(info);
+    }
+  });
+  return infos;
+}
+function getLayerPickingInfo({ layer, info, mode }) {
+  while (layer && info) {
+    const sourceLayer = info.layer || null;
+    info.sourceLayer = sourceLayer;
+    info.layer = layer;
+    info = layer.getPickingInfo({ info, mode, sourceLayer });
+    layer = layer.parent;
+  }
+  return info;
+}
+function getViewportFromCoordinates(viewports, pixel) {
+  for (let i2 = viewports.length - 1; i2 >= 0; i2--) {
+    const viewport = viewports[i2];
+    if (viewport.containsPixel(pixel)) {
+      return viewport;
+    }
+  }
+  return viewports[0];
+}
+class DeckPicker {
+  constructor(device) {
+    this._pickable = true;
+    this.device = device;
+    this.pickLayersPass = new PickLayersPass(device);
+    this.lastPickedInfo = {
+      index: -1,
+      layerId: null,
+      info: null
+    };
+  }
+  setProps(props) {
+    if ("layerFilter" in props) {
+      this.layerFilter = props.layerFilter;
+    }
+    if ("_pickable" in props) {
+      this._pickable = props._pickable;
+    }
+  }
+  finalize() {
+    if (this.pickingFBO) {
+      this.pickingFBO.destroy();
+    }
+    if (this.depthFBO) {
+      this.depthFBO.destroy();
+    }
+  }
+  /**
+   * Pick the closest info at given coordinate
+   * @returns Promise that resolves with picking info
+   */
+  pickObjectAsync(opts) {
+    return this._pickClosestObjectAsync(opts);
+  }
+  /**
+   * Picks a list of unique infos within a bounding box
+   * @returns Promise that resolves to all unique infos within a bounding box
+   */
+  pickObjectsAsync(opts) {
+    return this._pickVisibleObjectsAsync(opts);
+  }
+  /**
+   * Pick the closest info at given coordinate
+   * @returns picking info
+   * @deprecated WebGL only - use pickObjectAsync instead
+   */
+  pickObject(opts) {
+    return this._pickClosestObject(opts);
+  }
+  /**
+   * Get all unique infos within a bounding box
+   * @returns all unique infos within a bounding box
+   * @deprecated WebGL only - use pickObjectAsync instead
+   */
+  pickObjects(opts) {
+    return this._pickVisibleObjects(opts);
+  }
+  // Returns a new picking info object by assuming the last picked object is still picked
+  getLastPickedObject({ x: x2, y: y2, layers, viewports }, lastPickedInfo = this.lastPickedInfo.info) {
+    const lastPickedLayerId = lastPickedInfo && lastPickedInfo.layer && lastPickedInfo.layer.id;
+    const lastPickedViewportId = lastPickedInfo && lastPickedInfo.viewport && lastPickedInfo.viewport.id;
+    const layer = lastPickedLayerId ? layers.find((l2) => l2.id === lastPickedLayerId) : null;
+    const viewport = lastPickedViewportId && viewports.find((v2) => v2.id === lastPickedViewportId) || viewports[0];
+    const coordinate = viewport && viewport.unproject([x2 - viewport.x, y2 - viewport.y]);
+    const info = {
+      x: x2,
+      y: y2,
+      viewport,
+      coordinate,
+      layer
+    };
+    return { ...lastPickedInfo, ...info };
+  }
+  // Private
+  /** Ensures that picking framebuffer exists and matches the canvas size */
+  _resizeBuffer() {
+    var _a3, _b3;
+    if (!this.pickingFBO) {
+      this.pickingFBO = this.device.createFramebuffer({
+        colorAttachments: ["rgba8unorm"],
+        depthStencilAttachment: "depth16unorm"
+      });
+      if (this.device.isTextureFormatRenderable("rgba32float")) {
+        const depthFBO = this.device.createFramebuffer({
+          colorAttachments: ["rgba32float"],
+          depthStencilAttachment: "depth16unorm"
+        });
+        this.depthFBO = depthFBO;
+      }
+    }
+    const { canvas: canvas2 } = this.device.getDefaultCanvasContext();
+    (_a3 = this.pickingFBO) == null ? void 0 : _a3.resize({ width: canvas2.width, height: canvas2.height });
+    (_b3 = this.depthFBO) == null ? void 0 : _b3.resize({ width: canvas2.width, height: canvas2.height });
+  }
+  /** Preliminary filtering of the layers list. Skid picking pass if no layer is pickable. */
+  _getPickable(layers) {
+    if (this._pickable === false) {
+      return null;
+    }
+    const pickableLayers = layers.filter((layer) => this.pickLayersPass.shouldDrawLayer(layer) && !layer.isComposite);
+    return pickableLayers.length ? pickableLayers : null;
+  }
+  /**
+   * Pick the closest object at the given coordinate
+   */
+  // eslint-disable-next-line max-statements,complexity
+  async _pickClosestObjectAsync({ layers, views, viewports, x: x2, y: y2, radius = 0, depth = 1, mode = "query", unproject3D, onViewportActive, effects }) {
+    const pixelRatio = this.device.canvasContext.cssToDeviceRatio();
+    const pickableLayers = this._getPickable(layers);
+    if (!pickableLayers || viewports.length === 0) {
+      return {
+        result: [],
+        emptyInfo: getEmptyPickingInfo({ viewports, x: x2, y: y2, pixelRatio })
+      };
+    }
+    this._resizeBuffer();
+    const devicePixelRange = this.device.canvasContext.cssToDevicePixels([x2, y2], true);
+    const devicePixel = [
+      devicePixelRange.x + Math.floor(devicePixelRange.width / 2),
+      devicePixelRange.y + Math.floor(devicePixelRange.height / 2)
+    ];
+    const deviceRadius = Math.round(radius * pixelRatio);
+    const { width, height } = this.pickingFBO;
+    const deviceRect = this._getPickingRect({
+      deviceX: devicePixel[0],
+      deviceY: devicePixel[1],
+      deviceRadius,
+      deviceWidth: width,
+      deviceHeight: height
+    });
+    const cullRect = {
+      x: x2 - radius,
+      y: y2 - radius,
+      width: radius * 2 + 1,
+      height: radius * 2 + 1
+    };
+    let infos;
+    const result = [];
+    const affectedLayers = /* @__PURE__ */ new Set();
+    for (let i2 = 0; i2 < depth; i2++) {
+      let pickInfo;
+      if (deviceRect) {
+        const pickedResult = this._drawAndSample({
+          layers: pickableLayers,
+          views,
+          viewports,
+          onViewportActive,
+          deviceRect,
+          cullRect,
+          effects,
+          pass: `picking:${mode}`
+        });
+        pickInfo = getClosestObject({
+          ...pickedResult,
+          deviceX: devicePixel[0],
+          deviceY: devicePixel[1],
+          deviceRadius,
+          deviceRect
+        });
+      } else {
+        pickInfo = {
+          pickedColor: null,
+          pickedObjectIndex: -1
+        };
+      }
+      let z2;
+      if (pickInfo.pickedLayer && unproject3D && this.depthFBO) {
+        const { pickedColors: pickedColors2 } = this._drawAndSample({
+          layers: [pickInfo.pickedLayer],
+          views,
+          viewports,
+          onViewportActive,
+          deviceRect: {
+            x: pickInfo.pickedX,
+            y: pickInfo.pickedY,
+            width: 1,
+            height: 1
+          },
+          cullRect,
+          effects,
+          pass: `picking:${mode}:z`
+        }, true);
+        if (pickedColors2[3]) {
+          z2 = pickedColors2[0];
+        }
+      }
+      if (pickInfo.pickedLayer && i2 + 1 < depth) {
+        affectedLayers.add(pickInfo.pickedLayer);
+        pickInfo.pickedLayer.disablePickingIndex(pickInfo.pickedObjectIndex);
+      }
+      infos = processPickInfo({
+        pickInfo,
+        lastPickedInfo: this.lastPickedInfo,
+        mode,
+        layers: pickableLayers,
+        viewports,
+        x: x2,
+        y: y2,
+        z: z2,
+        pixelRatio
+      });
+      for (const info of infos.values()) {
+        if (info.layer) {
+          result.push(info);
+        }
+      }
+      if (!pickInfo.pickedColor) {
+        break;
+      }
+    }
+    for (const layer of affectedLayers) {
+      layer.restorePickingColors();
+    }
+    return { result, emptyInfo: infos.get(null) };
+  }
+  /**
+   * Pick the closest object at the given coordinate
+   * @deprecated WebGL only
+   */
+  // eslint-disable-next-line max-statements,complexity
+  _pickClosestObject({ layers, views, viewports, x: x2, y: y2, radius = 0, depth = 1, mode = "query", unproject3D, onViewportActive, effects }) {
+    const pixelRatio = this.device.canvasContext.cssToDeviceRatio();
+    const pickableLayers = this._getPickable(layers);
+    if (!pickableLayers || viewports.length === 0) {
+      return {
+        result: [],
+        emptyInfo: getEmptyPickingInfo({ viewports, x: x2, y: y2, pixelRatio })
+      };
+    }
+    this._resizeBuffer();
+    const devicePixelRange = this.device.canvasContext.cssToDevicePixels([x2, y2], true);
+    const devicePixel = [
+      devicePixelRange.x + Math.floor(devicePixelRange.width / 2),
+      devicePixelRange.y + Math.floor(devicePixelRange.height / 2)
+    ];
+    const deviceRadius = Math.round(radius * pixelRatio);
+    const { width, height } = this.pickingFBO;
+    const deviceRect = this._getPickingRect({
+      deviceX: devicePixel[0],
+      deviceY: devicePixel[1],
+      deviceRadius,
+      deviceWidth: width,
+      deviceHeight: height
+    });
+    const cullRect = {
+      x: x2 - radius,
+      y: y2 - radius,
+      width: radius * 2 + 1,
+      height: radius * 2 + 1
+    };
+    let infos;
+    const result = [];
+    const affectedLayers = /* @__PURE__ */ new Set();
+    for (let i2 = 0; i2 < depth; i2++) {
+      let pickInfo;
+      if (deviceRect) {
+        const pickedResult = this._drawAndSample({
+          layers: pickableLayers,
+          views,
+          viewports,
+          onViewportActive,
+          deviceRect,
+          cullRect,
+          effects,
+          pass: `picking:${mode}`
+        });
+        pickInfo = getClosestObject({
+          ...pickedResult,
+          deviceX: devicePixel[0],
+          deviceY: devicePixel[1],
+          deviceRadius,
+          deviceRect
+        });
+      } else {
+        pickInfo = {
+          pickedColor: null,
+          pickedObjectIndex: -1
+        };
+      }
+      let z2;
+      if (pickInfo.pickedLayer && unproject3D && this.depthFBO) {
+        const { pickedColors: pickedColors2 } = this._drawAndSample({
+          layers: [pickInfo.pickedLayer],
+          views,
+          viewports,
+          onViewportActive,
+          deviceRect: {
+            x: pickInfo.pickedX,
+            y: pickInfo.pickedY,
+            width: 1,
+            height: 1
+          },
+          cullRect,
+          effects,
+          pass: `picking:${mode}:z`
+        }, true);
+        if (pickedColors2[3]) {
+          z2 = pickedColors2[0];
+        }
+      }
+      if (pickInfo.pickedLayer && i2 + 1 < depth) {
+        affectedLayers.add(pickInfo.pickedLayer);
+        pickInfo.pickedLayer.disablePickingIndex(pickInfo.pickedObjectIndex);
+      }
+      infos = processPickInfo({
+        pickInfo,
+        lastPickedInfo: this.lastPickedInfo,
+        mode,
+        layers: pickableLayers,
+        viewports,
+        x: x2,
+        y: y2,
+        z: z2,
+        pixelRatio
+      });
+      for (const info of infos.values()) {
+        if (info.layer) {
+          result.push(info);
+        }
+      }
+      if (!pickInfo.pickedColor) {
+        break;
+      }
+    }
+    for (const layer of affectedLayers) {
+      layer.restorePickingColors();
+    }
+    return { result, emptyInfo: infos.get(null) };
+  }
+  /**
+   * Pick all objects within the given bounding box
+   */
+  // eslint-disable-next-line max-statements
+  async _pickVisibleObjectsAsync({ layers, views, viewports, x: x2, y: y2, width = 1, height = 1, mode = "query", maxObjects = null, onViewportActive, effects }) {
+    const pickableLayers = this._getPickable(layers);
+    if (!pickableLayers || viewports.length === 0) {
+      return [];
+    }
+    this._resizeBuffer();
+    const pixelRatio = this.device.canvasContext.cssToDeviceRatio();
+    const leftTop = this.device.canvasContext.cssToDevicePixels([x2, y2], true);
+    const deviceLeft = leftTop.x;
+    const deviceTop = leftTop.y + leftTop.height;
+    const rightBottom = this.device.canvasContext.cssToDevicePixels([x2 + width, y2 + height], true);
+    const deviceRight = rightBottom.x + rightBottom.width;
+    const deviceBottom = rightBottom.y;
+    const deviceRect = {
+      x: deviceLeft,
+      y: deviceBottom,
+      // deviceTop and deviceRight represent the first pixel outside the desired rect
+      width: deviceRight - deviceLeft,
+      height: deviceTop - deviceBottom
+    };
+    const pickedResult = this._drawAndSample({
+      layers: pickableLayers,
+      views,
+      viewports,
+      onViewportActive,
+      deviceRect,
+      cullRect: { x: x2, y: y2, width, height },
+      effects,
+      pass: `picking:${mode}`
+    });
+    const pickInfos = getUniqueObjects(pickedResult);
+    const uniquePickedObjects = /* @__PURE__ */ new Map();
+    const uniqueInfos = [];
+    const limitMaxObjects = Number.isFinite(maxObjects);
+    for (let i2 = 0; i2 < pickInfos.length; i2++) {
+      if (limitMaxObjects && uniqueInfos.length >= maxObjects) {
+        break;
+      }
+      const pickInfo = pickInfos[i2];
+      let info = {
+        color: pickInfo.pickedColor,
+        layer: null,
+        index: pickInfo.pickedObjectIndex,
+        picked: true,
+        x: x2,
+        y: y2,
+        pixelRatio
+      };
+      info = getLayerPickingInfo({ layer: pickInfo.pickedLayer, info, mode });
+      const pickedLayerId = info.layer.id;
+      if (!uniquePickedObjects.has(pickedLayerId)) {
+        uniquePickedObjects.set(pickedLayerId, /* @__PURE__ */ new Set());
+      }
+      const uniqueObjectsInLayer = uniquePickedObjects.get(pickedLayerId);
+      const pickedObjectKey = info.object ?? info.index;
+      if (!uniqueObjectsInLayer.has(pickedObjectKey)) {
+        uniqueObjectsInLayer.add(pickedObjectKey);
+        uniqueInfos.push(info);
+      }
+    }
+    return uniqueInfos;
+  }
+  /**
+   * Pick all objects within the given bounding box
+   * @deprecated WebGL only
+   */
+  // eslint-disable-next-line max-statements
+  _pickVisibleObjects({ layers, views, viewports, x: x2, y: y2, width = 1, height = 1, mode = "query", maxObjects = null, onViewportActive, effects }) {
+    const pickableLayers = this._getPickable(layers);
+    if (!pickableLayers || viewports.length === 0) {
+      return [];
+    }
+    this._resizeBuffer();
+    const pixelRatio = this.device.canvasContext.cssToDeviceRatio();
+    const leftTop = this.device.canvasContext.cssToDevicePixels([x2, y2], true);
+    const deviceLeft = leftTop.x;
+    const deviceTop = leftTop.y + leftTop.height;
+    const rightBottom = this.device.canvasContext.cssToDevicePixels([x2 + width, y2 + height], true);
+    const deviceRight = rightBottom.x + rightBottom.width;
+    const deviceBottom = rightBottom.y;
+    const deviceRect = {
+      x: deviceLeft,
+      y: deviceBottom,
+      // deviceTop and deviceRight represent the first pixel outside the desired rect
+      width: deviceRight - deviceLeft,
+      height: deviceTop - deviceBottom
+    };
+    const pickedResult = this._drawAndSample({
+      layers: pickableLayers,
+      views,
+      viewports,
+      onViewportActive,
+      deviceRect,
+      cullRect: { x: x2, y: y2, width, height },
+      effects,
+      pass: `picking:${mode}`
+    });
+    const pickInfos = getUniqueObjects(pickedResult);
+    const uniquePickedObjects = /* @__PURE__ */ new Map();
+    const uniqueInfos = [];
+    const limitMaxObjects = Number.isFinite(maxObjects);
+    for (let i2 = 0; i2 < pickInfos.length; i2++) {
+      if (limitMaxObjects && uniqueInfos.length >= maxObjects) {
+        break;
+      }
+      const pickInfo = pickInfos[i2];
+      let info = {
+        color: pickInfo.pickedColor,
+        layer: null,
+        index: pickInfo.pickedObjectIndex,
+        picked: true,
+        x: x2,
+        y: y2,
+        pixelRatio
+      };
+      info = getLayerPickingInfo({ layer: pickInfo.pickedLayer, info, mode });
+      const pickedLayerId = info.layer.id;
+      if (!uniquePickedObjects.has(pickedLayerId)) {
+        uniquePickedObjects.set(pickedLayerId, /* @__PURE__ */ new Set());
+      }
+      const uniqueObjectsInLayer = uniquePickedObjects.get(pickedLayerId);
+      const pickedObjectKey = info.object ?? info.index;
+      if (!uniqueObjectsInLayer.has(pickedObjectKey)) {
+        uniqueObjectsInLayer.add(pickedObjectKey);
+        uniqueInfos.push(info);
+      }
+    }
+    return uniqueInfos;
+  }
+  // Note: Implementation of the overloaded signatures above, TSDoc is on the signatures
+  async _drawAndSampleAsync({ layers, views, viewports, onViewportActive, deviceRect, cullRect, effects, pass }, pickZ = false) {
+    const pickingFBO = pickZ ? this.depthFBO : this.pickingFBO;
+    const opts = {
+      layers,
+      layerFilter: this.layerFilter,
+      views,
+      viewports,
+      onViewportActive,
+      pickingFBO,
+      deviceRect,
+      cullRect,
+      effects,
+      pass,
+      pickZ,
+      preRenderStats: {},
+      isPicking: true
+    };
+    for (const effect of effects) {
+      if (effect.useInPicking) {
+        opts.preRenderStats[effect.id] = effect.preRender(opts);
+      }
+    }
+    const { decodePickingColor } = this.pickLayersPass.render(opts);
+    const { x: x2, y: y2, width, height } = deviceRect;
+    const pickedColors = new (pickZ ? Float32Array : Uint8Array)(width * height * 4);
+    this.device.readPixelsToArrayWebGL(pickingFBO, {
+      sourceX: x2,
+      sourceY: y2,
+      sourceWidth: width,
+      sourceHeight: height,
+      target: pickedColors
+    });
+    return { pickedColors, decodePickingColor };
+  }
+  // Note: Implementation of the overloaded signatures above, TSDoc is on the signatures
+  _drawAndSample({ layers, views, viewports, onViewportActive, deviceRect, cullRect, effects, pass }, pickZ = false) {
+    const pickingFBO = pickZ ? this.depthFBO : this.pickingFBO;
+    const opts = {
+      layers,
+      layerFilter: this.layerFilter,
+      views,
+      viewports,
+      onViewportActive,
+      pickingFBO,
+      deviceRect,
+      cullRect,
+      effects,
+      pass,
+      pickZ,
+      preRenderStats: {},
+      isPicking: true
+    };
+    for (const effect of effects) {
+      if (effect.useInPicking) {
+        opts.preRenderStats[effect.id] = effect.preRender(opts);
+      }
+    }
+    const { decodePickingColor } = this.pickLayersPass.render(opts);
+    const { x: x2, y: y2, width, height } = deviceRect;
+    const pickedColors = new (pickZ ? Float32Array : Uint8Array)(width * height * 4);
+    this.device.readPixelsToArrayWebGL(pickingFBO, {
+      sourceX: x2,
+      sourceY: y2,
+      sourceWidth: width,
+      sourceHeight: height,
+      target: pickedColors
+    });
+    return { pickedColors, decodePickingColor };
+  }
+  /**
+   * Calculate a picking rect centered on deviceX and deviceY and clipped to device
+   * @returns null if pixel is outside of device
+   */
+  _getPickingRect({ deviceX, deviceY, deviceRadius, deviceWidth, deviceHeight }) {
+    const x2 = Math.max(0, deviceX - deviceRadius);
+    const y2 = Math.max(0, deviceY - deviceRadius);
+    const width = Math.min(deviceWidth, deviceX + deviceRadius + 1) - x2;
+    const height = Math.min(deviceHeight, deviceY + deviceRadius + 1) - y2;
+    if (width <= 0 || height <= 0) {
+      return null;
+    }
+    return { x: x2, y: y2, width, height };
+  }
+}
+const PLACEMENTS = {
+  "top-left": { top: 0, left: 0 },
+  "top-right": { top: 0, right: 0 },
+  "bottom-left": { bottom: 0, left: 0 },
+  "bottom-right": { bottom: 0, right: 0 },
+  fill: { top: 0, left: 0, bottom: 0, right: 0 }
+};
+const DEFAULT_PLACEMENT = "top-left";
+const ROOT_CONTAINER_ID = "root";
+class WidgetManager {
+  constructor({ deck, parentElement }) {
+    this.defaultWidgets = [];
+    this.widgets = [];
+    this.resolvedWidgets = [];
+    this.containers = {};
+    this.lastViewports = {};
+    this.deck = deck;
+    parentElement == null ? void 0 : parentElement.classList.add("deck-widget-container");
+    this.parentElement = parentElement;
+  }
+  getWidgets() {
+    return this.resolvedWidgets;
+  }
+  /** Declarative API to configure widgets */
+  setProps(props) {
+    if (props.widgets && !deepEqual(props.widgets, this.widgets, 1)) {
+      const nextWidgets = props.widgets.filter(Boolean);
+      this._setWidgets(nextWidgets);
+    }
+  }
+  finalize() {
+    for (const widget of this.getWidgets()) {
+      this._removeWidget(widget);
+    }
+    this.defaultWidgets.length = 0;
+    this.resolvedWidgets.length = 0;
+    for (const id2 in this.containers) {
+      this.containers[id2].remove();
+    }
+  }
+  /** Imperative API. Widgets added this way are not affected by the declarative prop. */
+  addDefault(widget) {
+    if (!this.defaultWidgets.find((w2) => w2.id === widget.id)) {
+      this._addWidget(widget);
+      this.defaultWidgets.push(widget);
+      this._setWidgets(this.widgets);
+    }
+  }
+  onRedraw({ viewports, layers }) {
+    var _a3, _b3;
+    const viewportsById = viewports.reduce((acc, v2) => {
+      acc[v2.id] = v2;
+      return acc;
+    }, {});
+    for (const widget of this.getWidgets()) {
+      const { viewId } = widget;
+      if (viewId) {
+        const viewport = viewportsById[viewId];
+        if (viewport) {
+          if (widget.onViewportChange) {
+            widget.onViewportChange(viewport);
+          }
+          (_a3 = widget.onRedraw) == null ? void 0 : _a3.call(widget, { viewports: [viewport], layers });
+        }
+      } else {
+        if (widget.onViewportChange) {
+          for (const viewport of viewports) {
+            widget.onViewportChange(viewport);
+          }
+        }
+        (_b3 = widget.onRedraw) == null ? void 0 : _b3.call(widget, { viewports, layers });
+      }
+    }
+    this.lastViewports = viewportsById;
+    this._updateContainers();
+  }
+  onHover(info, event) {
+    var _a3, _b3;
+    for (const widget of this.getWidgets()) {
+      const { viewId } = widget;
+      if (!viewId || viewId === ((_a3 = info.viewport) == null ? void 0 : _a3.id)) {
+        (_b3 = widget.onHover) == null ? void 0 : _b3.call(widget, info, event);
+      }
+    }
+  }
+  onEvent(info, event) {
+    var _a3, _b3;
+    const eventHandlerProp = EVENT_HANDLERS[event.type];
+    if (!eventHandlerProp) {
+      return;
+    }
+    for (const widget of this.getWidgets()) {
+      const { viewId } = widget;
+      if (!viewId || viewId === ((_a3 = info.viewport) == null ? void 0 : _a3.id)) {
+        (_b3 = widget[eventHandlerProp]) == null ? void 0 : _b3.call(widget, info, event);
+      }
+    }
+  }
+  // INTERNAL METHODS
+  /**
+   * Resolve widgets from the declarative prop
+   * Initialize new widgets and remove old ones
+   * Update props of existing widgets
+   */
+  _setWidgets(nextWidgets) {
+    const oldWidgetMap = {};
+    for (const widget of this.resolvedWidgets) {
+      oldWidgetMap[widget.id] = widget;
+    }
+    this.resolvedWidgets.length = 0;
+    for (const widget of this.defaultWidgets) {
+      oldWidgetMap[widget.id] = null;
+      this.resolvedWidgets.push(widget);
+    }
+    for (let widget of nextWidgets) {
+      const oldWidget = oldWidgetMap[widget.id];
+      if (!oldWidget) {
+        this._addWidget(widget);
+      } else if (
+        // Widget placement changed
+        oldWidget.viewId !== widget.viewId || oldWidget.placement !== widget.placement
+      ) {
+        this._removeWidget(oldWidget);
+        this._addWidget(widget);
+      } else if (widget !== oldWidget) {
+        oldWidget.setProps(widget.props);
+        widget = oldWidget;
+      }
+      oldWidgetMap[widget.id] = null;
+      this.resolvedWidgets.push(widget);
+    }
+    for (const id2 in oldWidgetMap) {
+      const oldWidget = oldWidgetMap[id2];
+      if (oldWidget) {
+        this._removeWidget(oldWidget);
+      }
+    }
+    this.widgets = nextWidgets;
+  }
+  /** Initialize new widget */
+  _addWidget(widget) {
+    const { viewId = null, placement = DEFAULT_PLACEMENT } = widget;
+    const container = widget.props._container ?? viewId;
+    widget.widgetManager = this;
+    widget.deck = this.deck;
+    widget.rootElement = widget._onAdd({ deck: this.deck, viewId });
+    if (widget.rootElement) {
+      this._getContainer(container, placement).append(widget.rootElement);
+    }
+    widget.updateHTML();
+  }
+  /** Destroy an old widget */
+  _removeWidget(widget) {
+    var _a3;
+    (_a3 = widget.onRemove) == null ? void 0 : _a3.call(widget);
+    if (widget.rootElement) {
+      widget.rootElement.remove();
+    }
+    widget.rootElement = void 0;
+    widget.deck = void 0;
+    widget.widgetManager = void 0;
+  }
+  /** Get a container element based on view and placement */
+  _getContainer(viewIdOrContainer, placement) {
+    var _a3;
+    if (viewIdOrContainer && typeof viewIdOrContainer !== "string") {
+      return viewIdOrContainer;
+    }
+    const containerId = viewIdOrContainer || ROOT_CONTAINER_ID;
+    let viewContainer = this.containers[containerId];
+    if (!viewContainer) {
+      viewContainer = document.createElement("div");
+      viewContainer.style.pointerEvents = "none";
+      viewContainer.style.position = "absolute";
+      viewContainer.style.overflow = "hidden";
+      (_a3 = this.parentElement) == null ? void 0 : _a3.append(viewContainer);
+      this.containers[containerId] = viewContainer;
+    }
+    let container = viewContainer.querySelector(`.${placement}`);
+    if (!container) {
+      container = globalThis.document.createElement("div");
+      container.className = placement;
+      container.style.position = "absolute";
+      container.style.zIndex = "2";
+      Object.assign(container.style, PLACEMENTS[placement]);
+      viewContainer.append(container);
+    }
+    return container;
+  }
+  _updateContainers() {
+    const canvasWidth = this.deck.width;
+    const canvasHeight = this.deck.height;
+    for (const id2 in this.containers) {
+      const viewport = this.lastViewports[id2] || null;
+      const visible = id2 === ROOT_CONTAINER_ID || viewport;
+      const container = this.containers[id2];
+      if (visible) {
+        container.style.display = "block";
+        container.style.left = `${viewport ? viewport.x : 0}px`;
+        container.style.top = `${viewport ? viewport.y : 0}px`;
+        container.style.width = `${viewport ? viewport.width : canvasWidth}px`;
+        container.style.height = `${viewport ? viewport.height : canvasHeight}px`;
+      } else {
+        container.style.display = "none";
+      }
+    }
+  }
+}
+function applyStyles(element, style) {
+  if (style) {
+    Object.entries(style).map(([key, value]) => {
+      if (key.startsWith("--")) {
+        element.style.setProperty(key, value);
+      } else {
+        element.style[key] = value;
+      }
+    });
+  }
+}
+function removeStyles(element, style) {
+  if (style) {
+    Object.keys(style).map((key) => {
+      if (key.startsWith("--")) {
+        element.style.removeProperty(key);
+      } else {
+        element.style[key] = "";
+      }
+    });
+  }
+}
+class Widget {
+  constructor(props) {
+    this.viewId = null;
+    this.props = {
+      // @ts-expect-error `defaultProps` may not exist on constructor
+      ...this.constructor.defaultProps,
+      ...props
+    };
+    this.id = this.props.id;
+  }
+  /** Called to update widget options */
+  setProps(props) {
+    const oldProps = this.props;
+    const el2 = this.rootElement;
+    if (el2 && oldProps.className !== props.className) {
+      if (oldProps.className)
+        el2.classList.remove(oldProps.className);
+      if (props.className)
+        el2.classList.add(props.className);
+    }
+    if (el2 && !deepEqual(oldProps.style, props.style, 1)) {
+      removeStyles(el2, oldProps.style);
+      applyStyles(el2, props.style);
+    }
+    Object.assign(this.props, props);
+    this.updateHTML();
+  }
+  /** Update the HTML to reflect latest props and state */
+  updateHTML() {
+    if (this.rootElement) {
+      this.onRenderHTML(this.rootElement);
+    }
+  }
+  // @note empty method calls have an overhead in V8 but it is very low, ~1ns
+  /**
+   * Common utility to create the root DOM element for this widget
+   * Configures the top-level styles and adds basic class names for theming
+   * @returns an UI element that should be appended to the Deck container
+   */
+  onCreateRootElement() {
+    const CLASS_NAMES = [
+      // Add class names for theming
+      "deck-widget",
+      this.className,
+      // plus any app-supplied class name
+      this.props.className
+    ];
+    const element = document.createElement("div");
+    CLASS_NAMES.filter((cls) => typeof cls === "string" && cls.length > 0).forEach((className) => element.classList.add(className));
+    applyStyles(element, this.props.style);
+    return element;
+  }
+  /** Internal API called by Deck when the widget is first added to a Deck instance */
+  _onAdd(params) {
+    return this.onAdd(params) ?? this.onCreateRootElement();
+  }
+  /** Overridable by subclass - called when the widget is first added to a Deck instance
+   * @returns an optional UI element that should be appended to the Deck container
+   */
+  onAdd(params) {
+  }
+  /** Called when the widget is removed */
+  onRemove() {
+  }
+  // deck integration - Event hooks
+  /** Called when the containing view is changed */
+  onViewportChange(viewport) {
+  }
+  /** Called when the containing view is redrawn */
+  onRedraw(params) {
+  }
+  /** Called when a hover event occurs */
+  onHover(info, event) {
+  }
+  /** Called when a click event occurs */
+  onClick(info, event) {
+  }
+  /** Called when a drag event occurs */
+  onDrag(info, event) {
+  }
+  /** Called when a dragstart event occurs */
+  onDragStart(info, event) {
+  }
+  /** Called when a dragend event occurs */
+  onDragEnd(info, event) {
+  }
+}
+Widget.defaultProps = {
+  id: "widget",
+  style: {},
+  _container: null,
+  className: ""
+};
+const defaultStyle = {
+  zIndex: "1",
+  position: "absolute",
+  pointerEvents: "none",
+  color: "#a0a7b4",
+  backgroundColor: "#29323c",
+  padding: "10px",
+  top: "0",
+  left: "0",
+  display: "none"
+};
+class TooltipWidget extends Widget {
+  constructor(props = {}) {
+    super(props);
+    this.id = "default-tooltip";
+    this.placement = "fill";
+    this.className = "deck-tooltip";
+    this.isVisible = false;
+    this.setProps(props);
+  }
+  // TODO(ib) - does this really need to be overridden?
+  onCreateRootElement() {
+    const el2 = document.createElement("div");
+    el2.className = this.className;
+    Object.assign(el2.style, defaultStyle);
+    return el2;
+  }
+  onRenderHTML(rootElement) {
+  }
+  onViewportChange(viewport) {
+    var _a3;
+    if (this.isVisible && viewport.id === ((_a3 = this.lastViewport) == null ? void 0 : _a3.id) && !viewport.equals(this.lastViewport)) {
+      this.setTooltip(null);
+    }
+    this.lastViewport = viewport;
+  }
+  onHover(info) {
+    const { deck } = this;
+    const getTooltip = deck && deck.props.getTooltip;
+    if (!getTooltip) {
+      return;
+    }
+    const displayInfo = getTooltip(info);
+    this.setTooltip(displayInfo, info.x, info.y);
+  }
+  setTooltip(displayInfo, x2, y2) {
+    const el2 = this.rootElement;
+    if (!el2) {
+      return;
+    }
+    if (typeof displayInfo === "string") {
+      el2.innerText = displayInfo;
+    } else if (!displayInfo) {
+      this.isVisible = false;
+      el2.style.display = "none";
+      return;
+    } else {
+      if (displayInfo.text) {
+        el2.innerText = displayInfo.text;
+      }
+      if (displayInfo.html) {
+        el2.innerHTML = displayInfo.html;
+      }
+      if (displayInfo.className) {
+        el2.className = displayInfo.className;
+      }
+    }
+    this.isVisible = true;
+    el2.style.display = "block";
+    el2.style.transform = `translate(${x2}px, ${y2}px)`;
+    if (displayInfo && typeof displayInfo === "object" && "style" in displayInfo) {
+      Object.assign(el2.style, displayInfo.style);
+    }
+  }
+}
+TooltipWidget.defaultProps = {
+  ...Widget.defaultProps
+};
+const scriptRel = "modulepreload";
+const assetsURL = function(dep, importerUrl) {
+  return new URL(dep, importerUrl).href;
+};
+const seen = {};
+const __vitePreload = function preload(baseModule, deps, importerUrl) {
+  let promise = Promise.resolve();
+  if (deps && deps.length > 0) {
+    const links = document.getElementsByTagName("link");
+    const cspNonceMeta = document.querySelector(
+      "meta[property=csp-nonce]"
+    );
+    const cspNonce = (cspNonceMeta == null ? void 0 : cspNonceMeta.nonce) || (cspNonceMeta == null ? void 0 : cspNonceMeta.getAttribute("nonce"));
+    promise = Promise.allSettled(
+      deps.map((dep) => {
+        dep = assetsURL(dep, importerUrl);
+        if (dep in seen) return;
+        seen[dep] = true;
+        const isCss = dep.endsWith(".css");
+        const cssSelector = isCss ? '[rel="stylesheet"]' : "";
+        const isBaseRelative = !!importerUrl;
+        if (isBaseRelative) {
+          for (let i2 = links.length - 1; i2 >= 0; i2--) {
+            const link2 = links[i2];
+            if (link2.href === dep && (!isCss || link2.rel === "stylesheet")) {
+              return;
+            }
+          }
+        } else if (document.querySelector(`link[href="${dep}"]${cssSelector}`)) {
+          return;
+        }
+        const link = document.createElement("link");
+        link.rel = isCss ? "stylesheet" : scriptRel;
+        if (!isCss) {
+          link.as = "script";
+        }
+        link.crossOrigin = "";
+        link.href = dep;
+        if (cspNonce) {
+          link.setAttribute("nonce", cspNonce);
+        }
+        document.head.appendChild(link);
+        if (isCss) {
+          return new Promise((res, rej) => {
+            link.addEventListener("load", res);
+            link.addEventListener(
+              "error",
+              () => rej(new Error(`Unable to preload CSS for ${dep}`))
+            );
+          });
+        }
+      })
+    );
+  }
+  function handlePreloadError(err) {
+    const e2 = new Event("vite:preloadError", {
+      cancelable: true
+    });
+    e2.payload = err;
+    window.dispatchEvent(e2);
+    if (!e2.defaultPrevented) {
+      throw err;
+    }
+  }
+  return promise.then((res) => {
+    for (const item of res || []) {
+      if (item.status !== "rejected") continue;
+      handlePreloadError(item.reason);
+    }
+    return baseModule().catch(handlePreloadError);
+  });
+};
+var GLEnum;
+(function(GLEnum2) {
+  GLEnum2[GLEnum2["DEPTH_BUFFER_BIT"] = 256] = "DEPTH_BUFFER_BIT";
+  GLEnum2[GLEnum2["STENCIL_BUFFER_BIT"] = 1024] = "STENCIL_BUFFER_BIT";
+  GLEnum2[GLEnum2["COLOR_BUFFER_BIT"] = 16384] = "COLOR_BUFFER_BIT";
+  GLEnum2[GLEnum2["POINTS"] = 0] = "POINTS";
+  GLEnum2[GLEnum2["LINES"] = 1] = "LINES";
+  GLEnum2[GLEnum2["LINE_LOOP"] = 2] = "LINE_LOOP";
+  GLEnum2[GLEnum2["LINE_STRIP"] = 3] = "LINE_STRIP";
+  GLEnum2[GLEnum2["TRIANGLES"] = 4] = "TRIANGLES";
+  GLEnum2[GLEnum2["TRIANGLE_STRIP"] = 5] = "TRIANGLE_STRIP";
+  GLEnum2[GLEnum2["TRIANGLE_FAN"] = 6] = "TRIANGLE_FAN";
+  GLEnum2[GLEnum2["ZERO"] = 0] = "ZERO";
+  GLEnum2[GLEnum2["ONE"] = 1] = "ONE";
+  GLEnum2[GLEnum2["SRC_COLOR"] = 768] = "SRC_COLOR";
+  GLEnum2[GLEnum2["ONE_MINUS_SRC_COLOR"] = 769] = "ONE_MINUS_SRC_COLOR";
+  GLEnum2[GLEnum2["SRC_ALPHA"] = 770] = "SRC_ALPHA";
+  GLEnum2[GLEnum2["ONE_MINUS_SRC_ALPHA"] = 771] = "ONE_MINUS_SRC_ALPHA";
+  GLEnum2[GLEnum2["DST_ALPHA"] = 772] = "DST_ALPHA";
+  GLEnum2[GLEnum2["ONE_MINUS_DST_ALPHA"] = 773] = "ONE_MINUS_DST_ALPHA";
+  GLEnum2[GLEnum2["DST_COLOR"] = 774] = "DST_COLOR";
+  GLEnum2[GLEnum2["ONE_MINUS_DST_COLOR"] = 775] = "ONE_MINUS_DST_COLOR";
+  GLEnum2[GLEnum2["SRC_ALPHA_SATURATE"] = 776] = "SRC_ALPHA_SATURATE";
+  GLEnum2[GLEnum2["CONSTANT_COLOR"] = 32769] = "CONSTANT_COLOR";
+  GLEnum2[GLEnum2["ONE_MINUS_CONSTANT_COLOR"] = 32770] = "ONE_MINUS_CONSTANT_COLOR";
+  GLEnum2[GLEnum2["CONSTANT_ALPHA"] = 32771] = "CONSTANT_ALPHA";
+  GLEnum2[GLEnum2["ONE_MINUS_CONSTANT_ALPHA"] = 32772] = "ONE_MINUS_CONSTANT_ALPHA";
+  GLEnum2[GLEnum2["FUNC_ADD"] = 32774] = "FUNC_ADD";
+  GLEnum2[GLEnum2["FUNC_SUBTRACT"] = 32778] = "FUNC_SUBTRACT";
+  GLEnum2[GLEnum2["FUNC_REVERSE_SUBTRACT"] = 32779] = "FUNC_REVERSE_SUBTRACT";
+  GLEnum2[GLEnum2["BLEND_EQUATION"] = 32777] = "BLEND_EQUATION";
+  GLEnum2[GLEnum2["BLEND_EQUATION_RGB"] = 32777] = "BLEND_EQUATION_RGB";
+  GLEnum2[GLEnum2["BLEND_EQUATION_ALPHA"] = 34877] = "BLEND_EQUATION_ALPHA";
+  GLEnum2[GLEnum2["BLEND_DST_RGB"] = 32968] = "BLEND_DST_RGB";
+  GLEnum2[GLEnum2["BLEND_SRC_RGB"] = 32969] = "BLEND_SRC_RGB";
+  GLEnum2[GLEnum2["BLEND_DST_ALPHA"] = 32970] = "BLEND_DST_ALPHA";
+  GLEnum2[GLEnum2["BLEND_SRC_ALPHA"] = 32971] = "BLEND_SRC_ALPHA";
+  GLEnum2[GLEnum2["BLEND_COLOR"] = 32773] = "BLEND_COLOR";
+  GLEnum2[GLEnum2["ARRAY_BUFFER_BINDING"] = 34964] = "ARRAY_BUFFER_BINDING";
+  GLEnum2[GLEnum2["ELEMENT_ARRAY_BUFFER_BINDING"] = 34965] = "ELEMENT_ARRAY_BUFFER_BINDING";
+  GLEnum2[GLEnum2["LINE_WIDTH"] = 2849] = "LINE_WIDTH";
+  GLEnum2[GLEnum2["ALIASED_POINT_SIZE_RANGE"] = 33901] = "ALIASED_POINT_SIZE_RANGE";
+  GLEnum2[GLEnum2["ALIASED_LINE_WIDTH_RANGE"] = 33902] = "ALIASED_LINE_WIDTH_RANGE";
+  GLEnum2[GLEnum2["CULL_FACE_MODE"] = 2885] = "CULL_FACE_MODE";
+  GLEnum2[GLEnum2["FRONT_FACE"] = 2886] = "FRONT_FACE";
+  GLEnum2[GLEnum2["DEPTH_RANGE"] = 2928] = "DEPTH_RANGE";
+  GLEnum2[GLEnum2["DEPTH_WRITEMASK"] = 2930] = "DEPTH_WRITEMASK";
+  GLEnum2[GLEnum2["DEPTH_CLEAR_VALUE"] = 2931] = "DEPTH_CLEAR_VALUE";
+  GLEnum2[GLEnum2["DEPTH_FUNC"] = 2932] = "DEPTH_FUNC";
+  GLEnum2[GLEnum2["STENCIL_CLEAR_VALUE"] = 2961] = "STENCIL_CLEAR_VALUE";
+  GLEnum2[GLEnum2["STENCIL_FUNC"] = 2962] = "STENCIL_FUNC";
+  GLEnum2[GLEnum2["STENCIL_FAIL"] = 2964] = "STENCIL_FAIL";
+  GLEnum2[GLEnum2["STENCIL_PASS_DEPTH_FAIL"] = 2965] = "STENCIL_PASS_DEPTH_FAIL";
+  GLEnum2[GLEnum2["STENCIL_PASS_DEPTH_PASS"] = 2966] = "STENCIL_PASS_DEPTH_PASS";
+  GLEnum2[GLEnum2["STENCIL_REF"] = 2967] = "STENCIL_REF";
+  GLEnum2[GLEnum2["STENCIL_VALUE_MASK"] = 2963] = "STENCIL_VALUE_MASK";
+  GLEnum2[GLEnum2["STENCIL_WRITEMASK"] = 2968] = "STENCIL_WRITEMASK";
+  GLEnum2[GLEnum2["STENCIL_BACK_FUNC"] = 34816] = "STENCIL_BACK_FUNC";
+  GLEnum2[GLEnum2["STENCIL_BACK_FAIL"] = 34817] = "STENCIL_BACK_FAIL";
+  GLEnum2[GLEnum2["STENCIL_BACK_PASS_DEPTH_FAIL"] = 34818] = "STENCIL_BACK_PASS_DEPTH_FAIL";
+  GLEnum2[GLEnum2["STENCIL_BACK_PASS_DEPTH_PASS"] = 34819] = "STENCIL_BACK_PASS_DEPTH_PASS";
+  GLEnum2[GLEnum2["STENCIL_BACK_REF"] = 36003] = "STENCIL_BACK_REF";
+  GLEnum2[GLEnum2["STENCIL_BACK_VALUE_MASK"] = 36004] = "STENCIL_BACK_VALUE_MASK";
+  GLEnum2[GLEnum2["STENCIL_BACK_WRITEMASK"] = 36005] = "STENCIL_BACK_WRITEMASK";
+  GLEnum2[GLEnum2["VIEWPORT"] = 2978] = "VIEWPORT";
+  GLEnum2[GLEnum2["SCISSOR_BOX"] = 3088] = "SCISSOR_BOX";
+  GLEnum2[GLEnum2["COLOR_CLEAR_VALUE"] = 3106] = "COLOR_CLEAR_VALUE";
+  GLEnum2[GLEnum2["COLOR_WRITEMASK"] = 3107] = "COLOR_WRITEMASK";
+  GLEnum2[GLEnum2["UNPACK_ALIGNMENT"] = 3317] = "UNPACK_ALIGNMENT";
+  GLEnum2[GLEnum2["PACK_ALIGNMENT"] = 3333] = "PACK_ALIGNMENT";
+  GLEnum2[GLEnum2["MAX_TEXTURE_SIZE"] = 3379] = "MAX_TEXTURE_SIZE";
+  GLEnum2[GLEnum2["MAX_VIEWPORT_DIMS"] = 3386] = "MAX_VIEWPORT_DIMS";
+  GLEnum2[GLEnum2["SUBPIXEL_BITS"] = 3408] = "SUBPIXEL_BITS";
+  GLEnum2[GLEnum2["RED_BITS"] = 3410] = "RED_BITS";
+  GLEnum2[GLEnum2["GREEN_BITS"] = 3411] = "GREEN_BITS";
+  GLEnum2[GLEnum2["BLUE_BITS"] = 3412] = "BLUE_BITS";
+  GLEnum2[GLEnum2["ALPHA_BITS"] = 3413] = "ALPHA_BITS";
+  GLEnum2[GLEnum2["DEPTH_BITS"] = 3414] = "DEPTH_BITS";
+  GLEnum2[GLEnum2["STENCIL_BITS"] = 3415] = "STENCIL_BITS";
+  GLEnum2[GLEnum2["POLYGON_OFFSET_UNITS"] = 10752] = "POLYGON_OFFSET_UNITS";
+  GLEnum2[GLEnum2["POLYGON_OFFSET_FACTOR"] = 32824] = "POLYGON_OFFSET_FACTOR";
+  GLEnum2[GLEnum2["TEXTURE_BINDING_2D"] = 32873] = "TEXTURE_BINDING_2D";
+  GLEnum2[GLEnum2["SAMPLE_BUFFERS"] = 32936] = "SAMPLE_BUFFERS";
+  GLEnum2[GLEnum2["SAMPLES"] = 32937] = "SAMPLES";
+  GLEnum2[GLEnum2["SAMPLE_COVERAGE_VALUE"] = 32938] = "SAMPLE_COVERAGE_VALUE";
+  GLEnum2[GLEnum2["SAMPLE_COVERAGE_INVERT"] = 32939] = "SAMPLE_COVERAGE_INVERT";
+  GLEnum2[GLEnum2["COMPRESSED_TEXTURE_FORMATS"] = 34467] = "COMPRESSED_TEXTURE_FORMATS";
+  GLEnum2[GLEnum2["VENDOR"] = 7936] = "VENDOR";
+  GLEnum2[GLEnum2["RENDERER"] = 7937] = "RENDERER";
+  GLEnum2[GLEnum2["VERSION"] = 7938] = "VERSION";
+  GLEnum2[GLEnum2["IMPLEMENTATION_COLOR_READ_TYPE"] = 35738] = "IMPLEMENTATION_COLOR_READ_TYPE";
+  GLEnum2[GLEnum2["IMPLEMENTATION_COLOR_READ_FORMAT"] = 35739] = "IMPLEMENTATION_COLOR_READ_FORMAT";
+  GLEnum2[GLEnum2["BROWSER_DEFAULT_WEBGL"] = 37444] = "BROWSER_DEFAULT_WEBGL";
+  GLEnum2[GLEnum2["STATIC_DRAW"] = 35044] = "STATIC_DRAW";
+  GLEnum2[GLEnum2["STREAM_DRAW"] = 35040] = "STREAM_DRAW";
+  GLEnum2[GLEnum2["DYNAMIC_DRAW"] = 35048] = "DYNAMIC_DRAW";
+  GLEnum2[GLEnum2["ARRAY_BUFFER"] = 34962] = "ARRAY_BUFFER";
+  GLEnum2[GLEnum2["ELEMENT_ARRAY_BUFFER"] = 34963] = "ELEMENT_ARRAY_BUFFER";
+  GLEnum2[GLEnum2["BUFFER_SIZE"] = 34660] = "BUFFER_SIZE";
+  GLEnum2[GLEnum2["BUFFER_USAGE"] = 34661] = "BUFFER_USAGE";
+  GLEnum2[GLEnum2["CURRENT_VERTEX_ATTRIB"] = 34342] = "CURRENT_VERTEX_ATTRIB";
+  GLEnum2[GLEnum2["VERTEX_ATTRIB_ARRAY_ENABLED"] = 34338] = "VERTEX_ATTRIB_ARRAY_ENABLED";
+  GLEnum2[GLEnum2["VERTEX_ATTRIB_ARRAY_SIZE"] = 34339] = "VERTEX_ATTRIB_ARRAY_SIZE";
+  GLEnum2[GLEnum2["VERTEX_ATTRIB_ARRAY_STRIDE"] = 34340] = "VERTEX_ATTRIB_ARRAY_STRIDE";
+  GLEnum2[GLEnum2["VERTEX_ATTRIB_ARRAY_TYPE"] = 34341] = "VERTEX_ATTRIB_ARRAY_TYPE";
+  GLEnum2[GLEnum2["VERTEX_ATTRIB_ARRAY_NORMALIZED"] = 34922] = "VERTEX_ATTRIB_ARRAY_NORMALIZED";
+  GLEnum2[GLEnum2["VERTEX_ATTRIB_ARRAY_POINTER"] = 34373] = "VERTEX_ATTRIB_ARRAY_POINTER";
+  GLEnum2[GLEnum2["VERTEX_ATTRIB_ARRAY_BUFFER_BINDING"] = 34975] = "VERTEX_ATTRIB_ARRAY_BUFFER_BINDING";
+  GLEnum2[GLEnum2["CULL_FACE"] = 2884] = "CULL_FACE";
+  GLEnum2[GLEnum2["FRONT"] = 1028] = "FRONT";
+  GLEnum2[GLEnum2["BACK"] = 1029] = "BACK";
+  GLEnum2[GLEnum2["FRONT_AND_BACK"] = 1032] = "FRONT_AND_BACK";
+  GLEnum2[GLEnum2["BLEND"] = 3042] = "BLEND";
+  GLEnum2[GLEnum2["DEPTH_TEST"] = 2929] = "DEPTH_TEST";
+  GLEnum2[GLEnum2["DITHER"] = 3024] = "DITHER";
+  GLEnum2[GLEnum2["POLYGON_OFFSET_FILL"] = 32823] = "POLYGON_OFFSET_FILL";
+  GLEnum2[GLEnum2["SAMPLE_ALPHA_TO_COVERAGE"] = 32926] = "SAMPLE_ALPHA_TO_COVERAGE";
+  GLEnum2[GLEnum2["SAMPLE_COVERAGE"] = 32928] = "SAMPLE_COVERAGE";
+  GLEnum2[GLEnum2["SCISSOR_TEST"] = 3089] = "SCISSOR_TEST";
+  GLEnum2[GLEnum2["STENCIL_TEST"] = 2960] = "STENCIL_TEST";
+  GLEnum2[GLEnum2["NO_ERROR"] = 0] = "NO_ERROR";
+  GLEnum2[GLEnum2["INVALID_ENUM"] = 1280] = "INVALID_ENUM";
+  GLEnum2[GLEnum2["INVALID_VALUE"] = 1281] = "INVALID_VALUE";
+  GLEnum2[GLEnum2["INVALID_OPERATION"] = 1282] = "INVALID_OPERATION";
+  GLEnum2[GLEnum2["OUT_OF_MEMORY"] = 1285] = "OUT_OF_MEMORY";
+  GLEnum2[GLEnum2["CONTEXT_LOST_WEBGL"] = 37442] = "CONTEXT_LOST_WEBGL";
+  GLEnum2[GLEnum2["CW"] = 2304] = "CW";
+  GLEnum2[GLEnum2["CCW"] = 2305] = "CCW";
+  GLEnum2[GLEnum2["DONT_CARE"] = 4352] = "DONT_CARE";
+  GLEnum2[GLEnum2["FASTEST"] = 4353] = "FASTEST";
+  GLEnum2[GLEnum2["NICEST"] = 4354] = "NICEST";
+  GLEnum2[GLEnum2["GENERATE_MIPMAP_HINT"] = 33170] = "GENERATE_MIPMAP_HINT";
+  GLEnum2[GLEnum2["BYTE"] = 5120] = "BYTE";
+  GLEnum2[GLEnum2["UNSIGNED_BYTE"] = 5121] = "UNSIGNED_BYTE";
+  GLEnum2[GLEnum2["SHORT"] = 5122] = "SHORT";
+  GLEnum2[GLEnum2["UNSIGNED_SHORT"] = 5123] = "UNSIGNED_SHORT";
+  GLEnum2[GLEnum2["INT"] = 5124] = "INT";
+  GLEnum2[GLEnum2["UNSIGNED_INT"] = 5125] = "UNSIGNED_INT";
+  GLEnum2[GLEnum2["FLOAT"] = 5126] = "FLOAT";
+  GLEnum2[GLEnum2["DOUBLE"] = 5130] = "DOUBLE";
+  GLEnum2[GLEnum2["DEPTH_COMPONENT"] = 6402] = "DEPTH_COMPONENT";
+  GLEnum2[GLEnum2["ALPHA"] = 6406] = "ALPHA";
+  GLEnum2[GLEnum2["RGB"] = 6407] = "RGB";
+  GLEnum2[GLEnum2["RGBA"] = 6408] = "RGBA";
+  GLEnum2[GLEnum2["LUMINANCE"] = 6409] = "LUMINANCE";
+  GLEnum2[GLEnum2["LUMINANCE_ALPHA"] = 6410] = "LUMINANCE_ALPHA";
+  GLEnum2[GLEnum2["UNSIGNED_SHORT_4_4_4_4"] = 32819] = "UNSIGNED_SHORT_4_4_4_4";
+  GLEnum2[GLEnum2["UNSIGNED_SHORT_5_5_5_1"] = 32820] = "UNSIGNED_SHORT_5_5_5_1";
+  GLEnum2[GLEnum2["UNSIGNED_SHORT_5_6_5"] = 33635] = "UNSIGNED_SHORT_5_6_5";
+  GLEnum2[GLEnum2["FRAGMENT_SHADER"] = 35632] = "FRAGMENT_SHADER";
+  GLEnum2[GLEnum2["VERTEX_SHADER"] = 35633] = "VERTEX_SHADER";
+  GLEnum2[GLEnum2["COMPILE_STATUS"] = 35713] = "COMPILE_STATUS";
+  GLEnum2[GLEnum2["DELETE_STATUS"] = 35712] = "DELETE_STATUS";
+  GLEnum2[GLEnum2["LINK_STATUS"] = 35714] = "LINK_STATUS";
+  GLEnum2[GLEnum2["VALIDATE_STATUS"] = 35715] = "VALIDATE_STATUS";
+  GLEnum2[GLEnum2["ATTACHED_SHADERS"] = 35717] = "ATTACHED_SHADERS";
+  GLEnum2[GLEnum2["ACTIVE_ATTRIBUTES"] = 35721] = "ACTIVE_ATTRIBUTES";
+  GLEnum2[GLEnum2["ACTIVE_UNIFORMS"] = 35718] = "ACTIVE_UNIFORMS";
+  GLEnum2[GLEnum2["MAX_VERTEX_ATTRIBS"] = 34921] = "MAX_VERTEX_ATTRIBS";
+  GLEnum2[GLEnum2["MAX_VERTEX_UNIFORM_VECTORS"] = 36347] = "MAX_VERTEX_UNIFORM_VECTORS";
+  GLEnum2[GLEnum2["MAX_VARYING_VECTORS"] = 36348] = "MAX_VARYING_VECTORS";
+  GLEnum2[GLEnum2["MAX_COMBINED_TEXTURE_IMAGE_UNITS"] = 35661] = "MAX_COMBINED_TEXTURE_IMAGE_UNITS";
+  GLEnum2[GLEnum2["MAX_VERTEX_TEXTURE_IMAGE_UNITS"] = 35660] = "MAX_VERTEX_TEXTURE_IMAGE_UNITS";
+  GLEnum2[GLEnum2["MAX_TEXTURE_IMAGE_UNITS"] = 34930] = "MAX_TEXTURE_IMAGE_UNITS";
+  GLEnum2[GLEnum2["MAX_FRAGMENT_UNIFORM_VECTORS"] = 36349] = "MAX_FRAGMENT_UNIFORM_VECTORS";
+  GLEnum2[GLEnum2["SHADER_TYPE"] = 35663] = "SHADER_TYPE";
+  GLEnum2[GLEnum2["SHADING_LANGUAGE_VERSION"] = 35724] = "SHADING_LANGUAGE_VERSION";
+  GLEnum2[GLEnum2["CURRENT_PROGRAM"] = 35725] = "CURRENT_PROGRAM";
+  GLEnum2[GLEnum2["NEVER"] = 512] = "NEVER";
+  GLEnum2[GLEnum2["LESS"] = 513] = "LESS";
+  GLEnum2[GLEnum2["EQUAL"] = 514] = "EQUAL";
+  GLEnum2[GLEnum2["LEQUAL"] = 515] = "LEQUAL";
+  GLEnum2[GLEnum2["GREATER"] = 516] = "GREATER";
+  GLEnum2[GLEnum2["NOTEQUAL"] = 517] = "NOTEQUAL";
+  GLEnum2[GLEnum2["GEQUAL"] = 518] = "GEQUAL";
+  GLEnum2[GLEnum2["ALWAYS"] = 519] = "ALWAYS";
+  GLEnum2[GLEnum2["KEEP"] = 7680] = "KEEP";
+  GLEnum2[GLEnum2["REPLACE"] = 7681] = "REPLACE";
+  GLEnum2[GLEnum2["INCR"] = 7682] = "INCR";
+  GLEnum2[GLEnum2["DECR"] = 7683] = "DECR";
+  GLEnum2[GLEnum2["INVERT"] = 5386] = "INVERT";
+  GLEnum2[GLEnum2["INCR_WRAP"] = 34055] = "INCR_WRAP";
+  GLEnum2[GLEnum2["DECR_WRAP"] = 34056] = "DECR_WRAP";
+  GLEnum2[GLEnum2["NEAREST"] = 9728] = "NEAREST";
+  GLEnum2[GLEnum2["LINEAR"] = 9729] = "LINEAR";
+  GLEnum2[GLEnum2["NEAREST_MIPMAP_NEAREST"] = 9984] = "NEAREST_MIPMAP_NEAREST";
+  GLEnum2[GLEnum2["LINEAR_MIPMAP_NEAREST"] = 9985] = "LINEAR_MIPMAP_NEAREST";
+  GLEnum2[GLEnum2["NEAREST_MIPMAP_LINEAR"] = 9986] = "NEAREST_MIPMAP_LINEAR";
+  GLEnum2[GLEnum2["LINEAR_MIPMAP_LINEAR"] = 9987] = "LINEAR_MIPMAP_LINEAR";
+  GLEnum2[GLEnum2["TEXTURE_MAG_FILTER"] = 10240] = "TEXTURE_MAG_FILTER";
+  GLEnum2[GLEnum2["TEXTURE_MIN_FILTER"] = 10241] = "TEXTURE_MIN_FILTER";
+  GLEnum2[GLEnum2["TEXTURE_WRAP_S"] = 10242] = "TEXTURE_WRAP_S";
+  GLEnum2[GLEnum2["TEXTURE_WRAP_T"] = 10243] = "TEXTURE_WRAP_T";
+  GLEnum2[GLEnum2["TEXTURE_2D"] = 3553] = "TEXTURE_2D";
+  GLEnum2[GLEnum2["TEXTURE"] = 5890] = "TEXTURE";
+  GLEnum2[GLEnum2["TEXTURE_CUBE_MAP"] = 34067] = "TEXTURE_CUBE_MAP";
+  GLEnum2[GLEnum2["TEXTURE_BINDING_CUBE_MAP"] = 34068] = "TEXTURE_BINDING_CUBE_MAP";
+  GLEnum2[GLEnum2["TEXTURE_CUBE_MAP_POSITIVE_X"] = 34069] = "TEXTURE_CUBE_MAP_POSITIVE_X";
+  GLEnum2[GLEnum2["TEXTURE_CUBE_MAP_NEGATIVE_X"] = 34070] = "TEXTURE_CUBE_MAP_NEGATIVE_X";
+  GLEnum2[GLEnum2["TEXTURE_CUBE_MAP_POSITIVE_Y"] = 34071] = "TEXTURE_CUBE_MAP_POSITIVE_Y";
+  GLEnum2[GLEnum2["TEXTURE_CUBE_MAP_NEGATIVE_Y"] = 34072] = "TEXTURE_CUBE_MAP_NEGATIVE_Y";
+  GLEnum2[GLEnum2["TEXTURE_CUBE_MAP_POSITIVE_Z"] = 34073] = "TEXTURE_CUBE_MAP_POSITIVE_Z";
+  GLEnum2[GLEnum2["TEXTURE_CUBE_MAP_NEGATIVE_Z"] = 34074] = "TEXTURE_CUBE_MAP_NEGATIVE_Z";
+  GLEnum2[GLEnum2["MAX_CUBE_MAP_TEXTURE_SIZE"] = 34076] = "MAX_CUBE_MAP_TEXTURE_SIZE";
+  GLEnum2[GLEnum2["TEXTURE0"] = 33984] = "TEXTURE0";
+  GLEnum2[GLEnum2["ACTIVE_TEXTURE"] = 34016] = "ACTIVE_TEXTURE";
+  GLEnum2[GLEnum2["REPEAT"] = 10497] = "REPEAT";
+  GLEnum2[GLEnum2["CLAMP_TO_EDGE"] = 33071] = "CLAMP_TO_EDGE";
+  GLEnum2[GLEnum2["MIRRORED_REPEAT"] = 33648] = "MIRRORED_REPEAT";
+  GLEnum2[GLEnum2["TEXTURE_WIDTH"] = 4096] = "TEXTURE_WIDTH";
+  GLEnum2[GLEnum2["TEXTURE_HEIGHT"] = 4097] = "TEXTURE_HEIGHT";
+  GLEnum2[GLEnum2["FLOAT_VEC2"] = 35664] = "FLOAT_VEC2";
+  GLEnum2[GLEnum2["FLOAT_VEC3"] = 35665] = "FLOAT_VEC3";
+  GLEnum2[GLEnum2["FLOAT_VEC4"] = 35666] = "FLOAT_VEC4";
+  GLEnum2[GLEnum2["INT_VEC2"] = 35667] = "INT_VEC2";
+  GLEnum2[GLEnum2["INT_VEC3"] = 35668] = "INT_VEC3";
+  GLEnum2[GLEnum2["INT_VEC4"] = 35669] = "INT_VEC4";
+  GLEnum2[GLEnum2["BOOL"] = 35670] = "BOOL";
+  GLEnum2[GLEnum2["BOOL_VEC2"] = 35671] = "BOOL_VEC2";
+  GLEnum2[GLEnum2["BOOL_VEC3"] = 35672] = "BOOL_VEC3";
+  GLEnum2[GLEnum2["BOOL_VEC4"] = 35673] = "BOOL_VEC4";
+  GLEnum2[GLEnum2["FLOAT_MAT2"] = 35674] = "FLOAT_MAT2";
+  GLEnum2[GLEnum2["FLOAT_MAT3"] = 35675] = "FLOAT_MAT3";
+  GLEnum2[GLEnum2["FLOAT_MAT4"] = 35676] = "FLOAT_MAT4";
+  GLEnum2[GLEnum2["SAMPLER_2D"] = 35678] = "SAMPLER_2D";
+  GLEnum2[GLEnum2["SAMPLER_CUBE"] = 35680] = "SAMPLER_CUBE";
+  GLEnum2[GLEnum2["LOW_FLOAT"] = 36336] = "LOW_FLOAT";
+  GLEnum2[GLEnum2["MEDIUM_FLOAT"] = 36337] = "MEDIUM_FLOAT";
+  GLEnum2[GLEnum2["HIGH_FLOAT"] = 36338] = "HIGH_FLOAT";
+  GLEnum2[GLEnum2["LOW_INT"] = 36339] = "LOW_INT";
+  GLEnum2[GLEnum2["MEDIUM_INT"] = 36340] = "MEDIUM_INT";
+  GLEnum2[GLEnum2["HIGH_INT"] = 36341] = "HIGH_INT";
+  GLEnum2[GLEnum2["FRAMEBUFFER"] = 36160] = "FRAMEBUFFER";
+  GLEnum2[GLEnum2["RENDERBUFFER"] = 36161] = "RENDERBUFFER";
+  GLEnum2[GLEnum2["RGBA4"] = 32854] = "RGBA4";
+  GLEnum2[GLEnum2["RGB5_A1"] = 32855] = "RGB5_A1";
+  GLEnum2[GLEnum2["RGB565"] = 36194] = "RGB565";
+  GLEnum2[GLEnum2["DEPTH_COMPONENT16"] = 33189] = "DEPTH_COMPONENT16";
+  GLEnum2[GLEnum2["STENCIL_INDEX"] = 6401] = "STENCIL_INDEX";
+  GLEnum2[GLEnum2["STENCIL_INDEX8"] = 36168] = "STENCIL_INDEX8";
+  GLEnum2[GLEnum2["DEPTH_STENCIL"] = 34041] = "DEPTH_STENCIL";
+  GLEnum2[GLEnum2["RENDERBUFFER_WIDTH"] = 36162] = "RENDERBUFFER_WIDTH";
+  GLEnum2[GLEnum2["RENDERBUFFER_HEIGHT"] = 36163] = "RENDERBUFFER_HEIGHT";
+  GLEnum2[GLEnum2["RENDERBUFFER_INTERNAL_FORMAT"] = 36164] = "RENDERBUFFER_INTERNAL_FORMAT";
+  GLEnum2[GLEnum2["RENDERBUFFER_RED_SIZE"] = 36176] = "RENDERBUFFER_RED_SIZE";
+  GLEnum2[GLEnum2["RENDERBUFFER_GREEN_SIZE"] = 36177] = "RENDERBUFFER_GREEN_SIZE";
+  GLEnum2[GLEnum2["RENDERBUFFER_BLUE_SIZE"] = 36178] = "RENDERBUFFER_BLUE_SIZE";
+  GLEnum2[GLEnum2["RENDERBUFFER_ALPHA_SIZE"] = 36179] = "RENDERBUFFER_ALPHA_SIZE";
+  GLEnum2[GLEnum2["RENDERBUFFER_DEPTH_SIZE"] = 36180] = "RENDERBUFFER_DEPTH_SIZE";
+  GLEnum2[GLEnum2["RENDERBUFFER_STENCIL_SIZE"] = 36181] = "RENDERBUFFER_STENCIL_SIZE";
+  GLEnum2[GLEnum2["FRAMEBUFFER_ATTACHMENT_OBJECT_TYPE"] = 36048] = "FRAMEBUFFER_ATTACHMENT_OBJECT_TYPE";
+  GLEnum2[GLEnum2["FRAMEBUFFER_ATTACHMENT_OBJECT_NAME"] = 36049] = "FRAMEBUFFER_ATTACHMENT_OBJECT_NAME";
+  GLEnum2[GLEnum2["FRAMEBUFFER_ATTACHMENT_TEXTURE_LEVEL"] = 36050] = "FRAMEBUFFER_ATTACHMENT_TEXTURE_LEVEL";
+  GLEnum2[GLEnum2["FRAMEBUFFER_ATTACHMENT_TEXTURE_CUBE_MAP_FACE"] = 36051] = "FRAMEBUFFER_ATTACHMENT_TEXTURE_CUBE_MAP_FACE";
+  GLEnum2[GLEnum2["COLOR_ATTACHMENT0"] = 36064] = "COLOR_ATTACHMENT0";
+  GLEnum2[GLEnum2["DEPTH_ATTACHMENT"] = 36096] = "DEPTH_ATTACHMENT";
+  GLEnum2[GLEnum2["STENCIL_ATTACHMENT"] = 36128] = "STENCIL_ATTACHMENT";
+  GLEnum2[GLEnum2["DEPTH_STENCIL_ATTACHMENT"] = 33306] = "DEPTH_STENCIL_ATTACHMENT";
+  GLEnum2[GLEnum2["NONE"] = 0] = "NONE";
+  GLEnum2[GLEnum2["FRAMEBUFFER_COMPLETE"] = 36053] = "FRAMEBUFFER_COMPLETE";
+  GLEnum2[GLEnum2["FRAMEBUFFER_INCOMPLETE_ATTACHMENT"] = 36054] = "FRAMEBUFFER_INCOMPLETE_ATTACHMENT";
+  GLEnum2[GLEnum2["FRAMEBUFFER_INCOMPLETE_MISSING_ATTACHMENT"] = 36055] = "FRAMEBUFFER_INCOMPLETE_MISSING_ATTACHMENT";
+  GLEnum2[GLEnum2["FRAMEBUFFER_INCOMPLETE_DIMENSIONS"] = 36057] = "FRAMEBUFFER_INCOMPLETE_DIMENSIONS";
+  GLEnum2[GLEnum2["FRAMEBUFFER_UNSUPPORTED"] = 36061] = "FRAMEBUFFER_UNSUPPORTED";
+  GLEnum2[GLEnum2["FRAMEBUFFER_BINDING"] = 36006] = "FRAMEBUFFER_BINDING";
+  GLEnum2[GLEnum2["RENDERBUFFER_BINDING"] = 36007] = "RENDERBUFFER_BINDING";
+  GLEnum2[GLEnum2["READ_FRAMEBUFFER"] = 36008] = "READ_FRAMEBUFFER";
+  GLEnum2[GLEnum2["DRAW_FRAMEBUFFER"] = 36009] = "DRAW_FRAMEBUFFER";
+  GLEnum2[GLEnum2["MAX_RENDERBUFFER_SIZE"] = 34024] = "MAX_RENDERBUFFER_SIZE";
+  GLEnum2[GLEnum2["INVALID_FRAMEBUFFER_OPERATION"] = 1286] = "INVALID_FRAMEBUFFER_OPERATION";
+  GLEnum2[GLEnum2["UNPACK_FLIP_Y_WEBGL"] = 37440] = "UNPACK_FLIP_Y_WEBGL";
+  GLEnum2[GLEnum2["UNPACK_PREMULTIPLY_ALPHA_WEBGL"] = 37441] = "UNPACK_PREMULTIPLY_ALPHA_WEBGL";
+  GLEnum2[GLEnum2["UNPACK_COLORSPACE_CONVERSION_WEBGL"] = 37443] = "UNPACK_COLORSPACE_CONVERSION_WEBGL";
+  GLEnum2[GLEnum2["READ_BUFFER"] = 3074] = "READ_BUFFER";
+  GLEnum2[GLEnum2["UNPACK_ROW_LENGTH"] = 3314] = "UNPACK_ROW_LENGTH";
+  GLEnum2[GLEnum2["UNPACK_SKIP_ROWS"] = 3315] = "UNPACK_SKIP_ROWS";
+  GLEnum2[GLEnum2["UNPACK_SKIP_PIXELS"] = 3316] = "UNPACK_SKIP_PIXELS";
+  GLEnum2[GLEnum2["PACK_ROW_LENGTH"] = 3330] = "PACK_ROW_LENGTH";
+  GLEnum2[GLEnum2["PACK_SKIP_ROWS"] = 3331] = "PACK_SKIP_ROWS";
+  GLEnum2[GLEnum2["PACK_SKIP_PIXELS"] = 3332] = "PACK_SKIP_PIXELS";
+  GLEnum2[GLEnum2["TEXTURE_BINDING_3D"] = 32874] = "TEXTURE_BINDING_3D";
+  GLEnum2[GLEnum2["UNPACK_SKIP_IMAGES"] = 32877] = "UNPACK_SKIP_IMAGES";
+  GLEnum2[GLEnum2["UNPACK_IMAGE_HEIGHT"] = 32878] = "UNPACK_IMAGE_HEIGHT";
+  GLEnum2[GLEnum2["MAX_3D_TEXTURE_SIZE"] = 32883] = "MAX_3D_TEXTURE_SIZE";
+  GLEnum2[GLEnum2["MAX_ELEMENTS_VERTICES"] = 33e3] = "MAX_ELEMENTS_VERTICES";
+  GLEnum2[GLEnum2["MAX_ELEMENTS_INDICES"] = 33001] = "MAX_ELEMENTS_INDICES";
+  GLEnum2[GLEnum2["MAX_TEXTURE_LOD_BIAS"] = 34045] = "MAX_TEXTURE_LOD_BIAS";
+  GLEnum2[GLEnum2["MAX_FRAGMENT_UNIFORM_COMPONENTS"] = 35657] = "MAX_FRAGMENT_UNIFORM_COMPONENTS";
+  GLEnum2[GLEnum2["MAX_VERTEX_UNIFORM_COMPONENTS"] = 35658] = "MAX_VERTEX_UNIFORM_COMPONENTS";
+  GLEnum2[GLEnum2["MAX_ARRAY_TEXTURE_LAYERS"] = 35071] = "MAX_ARRAY_TEXTURE_LAYERS";
+  GLEnum2[GLEnum2["MIN_PROGRAM_TEXEL_OFFSET"] = 35076] = "MIN_PROGRAM_TEXEL_OFFSET";
+  GLEnum2[GLEnum2["MAX_PROGRAM_TEXEL_OFFSET"] = 35077] = "MAX_PROGRAM_TEXEL_OFFSET";
+  GLEnum2[GLEnum2["MAX_VARYING_COMPONENTS"] = 35659] = "MAX_VARYING_COMPONENTS";
+  GLEnum2[GLEnum2["FRAGMENT_SHADER_DERIVATIVE_HINT"] = 35723] = "FRAGMENT_SHADER_DERIVATIVE_HINT";
+  GLEnum2[GLEnum2["RASTERIZER_DISCARD"] = 35977] = "RASTERIZER_DISCARD";
+  GLEnum2[GLEnum2["VERTEX_ARRAY_BINDING"] = 34229] = "VERTEX_ARRAY_BINDING";
+  GLEnum2[GLEnum2["MAX_VERTEX_OUTPUT_COMPONENTS"] = 37154] = "MAX_VERTEX_OUTPUT_COMPONENTS";
+  GLEnum2[GLEnum2["MAX_FRAGMENT_INPUT_COMPONENTS"] = 37157] = "MAX_FRAGMENT_INPUT_COMPONENTS";
+  GLEnum2[GLEnum2["MAX_SERVER_WAIT_TIMEOUT"] = 37137] = "MAX_SERVER_WAIT_TIMEOUT";
+  GLEnum2[GLEnum2["MAX_ELEMENT_INDEX"] = 36203] = "MAX_ELEMENT_INDEX";
+  GLEnum2[GLEnum2["RED"] = 6403] = "RED";
+  GLEnum2[GLEnum2["RGB8"] = 32849] = "RGB8";
+  GLEnum2[GLEnum2["RGBA8"] = 32856] = "RGBA8";
+  GLEnum2[GLEnum2["RGB10_A2"] = 32857] = "RGB10_A2";
+  GLEnum2[GLEnum2["TEXTURE_3D"] = 32879] = "TEXTURE_3D";
+  GLEnum2[GLEnum2["TEXTURE_WRAP_R"] = 32882] = "TEXTURE_WRAP_R";
+  GLEnum2[GLEnum2["TEXTURE_MIN_LOD"] = 33082] = "TEXTURE_MIN_LOD";
+  GLEnum2[GLEnum2["TEXTURE_MAX_LOD"] = 33083] = "TEXTURE_MAX_LOD";
+  GLEnum2[GLEnum2["TEXTURE_BASE_LEVEL"] = 33084] = "TEXTURE_BASE_LEVEL";
+  GLEnum2[GLEnum2["TEXTURE_MAX_LEVEL"] = 33085] = "TEXTURE_MAX_LEVEL";
+  GLEnum2[GLEnum2["TEXTURE_COMPARE_MODE"] = 34892] = "TEXTURE_COMPARE_MODE";
+  GLEnum2[GLEnum2["TEXTURE_COMPARE_FUNC"] = 34893] = "TEXTURE_COMPARE_FUNC";
+  GLEnum2[GLEnum2["SRGB"] = 35904] = "SRGB";
+  GLEnum2[GLEnum2["SRGB8"] = 35905] = "SRGB8";
+  GLEnum2[GLEnum2["SRGB8_ALPHA8"] = 35907] = "SRGB8_ALPHA8";
+  GLEnum2[GLEnum2["COMPARE_REF_TO_TEXTURE"] = 34894] = "COMPARE_REF_TO_TEXTURE";
+  GLEnum2[GLEnum2["RGBA32F"] = 34836] = "RGBA32F";
+  GLEnum2[GLEnum2["RGB32F"] = 34837] = "RGB32F";
+  GLEnum2[GLEnum2["RGBA16F"] = 34842] = "RGBA16F";
+  GLEnum2[GLEnum2["RGB16F"] = 34843] = "RGB16F";
+  GLEnum2[GLEnum2["TEXTURE_2D_ARRAY"] = 35866] = "TEXTURE_2D_ARRAY";
+  GLEnum2[GLEnum2["TEXTURE_BINDING_2D_ARRAY"] = 35869] = "TEXTURE_BINDING_2D_ARRAY";
+  GLEnum2[GLEnum2["R11F_G11F_B10F"] = 35898] = "R11F_G11F_B10F";
+  GLEnum2[GLEnum2["RGB9_E5"] = 35901] = "RGB9_E5";
+  GLEnum2[GLEnum2["RGBA32UI"] = 36208] = "RGBA32UI";
+  GLEnum2[GLEnum2["RGB32UI"] = 36209] = "RGB32UI";
+  GLEnum2[GLEnum2["RGBA16UI"] = 36214] = "RGBA16UI";
+  GLEnum2[GLEnum2["RGB16UI"] = 36215] = "RGB16UI";
+  GLEnum2[GLEnum2["RGBA8UI"] = 36220] = "RGBA8UI";
+  GLEnum2[GLEnum2["RGB8UI"] = 36221] = "RGB8UI";
+  GLEnum2[GLEnum2["RGBA32I"] = 36226] = "RGBA32I";
+  GLEnum2[GLEnum2["RGB32I"] = 36227] = "RGB32I";
+  GLEnum2[GLEnum2["RGBA16I"] = 36232] = "RGBA16I";
+  GLEnum2[GLEnum2["RGB16I"] = 36233] = "RGB16I";
+  GLEnum2[GLEnum2["RGBA8I"] = 36238] = "RGBA8I";
+  GLEnum2[GLEnum2["RGB8I"] = 36239] = "RGB8I";
+  GLEnum2[GLEnum2["RED_INTEGER"] = 36244] = "RED_INTEGER";
+  GLEnum2[GLEnum2["RGB_INTEGER"] = 36248] = "RGB_INTEGER";
+  GLEnum2[GLEnum2["RGBA_INTEGER"] = 36249] = "RGBA_INTEGER";
+  GLEnum2[GLEnum2["R8"] = 33321] = "R8";
+  GLEnum2[GLEnum2["RG8"] = 33323] = "RG8";
+  GLEnum2[GLEnum2["R16F"] = 33325] = "R16F";
+  GLEnum2[GLEnum2["R32F"] = 33326] = "R32F";
+  GLEnum2[GLEnum2["RG16F"] = 33327] = "RG16F";
+  GLEnum2[GLEnum2["RG32F"] = 33328] = "RG32F";
+  GLEnum2[GLEnum2["R8I"] = 33329] = "R8I";
+  GLEnum2[GLEnum2["R8UI"] = 33330] = "R8UI";
+  GLEnum2[GLEnum2["R16I"] = 33331] = "R16I";
+  GLEnum2[GLEnum2["R16UI"] = 33332] = "R16UI";
+  GLEnum2[GLEnum2["R32I"] = 33333] = "R32I";
+  GLEnum2[GLEnum2["R32UI"] = 33334] = "R32UI";
+  GLEnum2[GLEnum2["RG8I"] = 33335] = "RG8I";
+  GLEnum2[GLEnum2["RG8UI"] = 33336] = "RG8UI";
+  GLEnum2[GLEnum2["RG16I"] = 33337] = "RG16I";
+  GLEnum2[GLEnum2["RG16UI"] = 33338] = "RG16UI";
+  GLEnum2[GLEnum2["RG32I"] = 33339] = "RG32I";
+  GLEnum2[GLEnum2["RG32UI"] = 33340] = "RG32UI";
+  GLEnum2[GLEnum2["R8_SNORM"] = 36756] = "R8_SNORM";
+  GLEnum2[GLEnum2["RG8_SNORM"] = 36757] = "RG8_SNORM";
+  GLEnum2[GLEnum2["RGB8_SNORM"] = 36758] = "RGB8_SNORM";
+  GLEnum2[GLEnum2["RGBA8_SNORM"] = 36759] = "RGBA8_SNORM";
+  GLEnum2[GLEnum2["RGB10_A2UI"] = 36975] = "RGB10_A2UI";
+  GLEnum2[GLEnum2["TEXTURE_IMMUTABLE_FORMAT"] = 37167] = "TEXTURE_IMMUTABLE_FORMAT";
+  GLEnum2[GLEnum2["TEXTURE_IMMUTABLE_LEVELS"] = 33503] = "TEXTURE_IMMUTABLE_LEVELS";
+  GLEnum2[GLEnum2["UNSIGNED_INT_2_10_10_10_REV"] = 33640] = "UNSIGNED_INT_2_10_10_10_REV";
+  GLEnum2[GLEnum2["UNSIGNED_INT_10F_11F_11F_REV"] = 35899] = "UNSIGNED_INT_10F_11F_11F_REV";
+  GLEnum2[GLEnum2["UNSIGNED_INT_5_9_9_9_REV"] = 35902] = "UNSIGNED_INT_5_9_9_9_REV";
+  GLEnum2[GLEnum2["FLOAT_32_UNSIGNED_INT_24_8_REV"] = 36269] = "FLOAT_32_UNSIGNED_INT_24_8_REV";
+  GLEnum2[GLEnum2["UNSIGNED_INT_24_8"] = 34042] = "UNSIGNED_INT_24_8";
+  GLEnum2[GLEnum2["HALF_FLOAT"] = 5131] = "HALF_FLOAT";
+  GLEnum2[GLEnum2["RG"] = 33319] = "RG";
+  GLEnum2[GLEnum2["RG_INTEGER"] = 33320] = "RG_INTEGER";
+  GLEnum2[GLEnum2["INT_2_10_10_10_REV"] = 36255] = "INT_2_10_10_10_REV";
+  GLEnum2[GLEnum2["CURRENT_QUERY"] = 34917] = "CURRENT_QUERY";
+  GLEnum2[GLEnum2["QUERY_RESULT"] = 34918] = "QUERY_RESULT";
+  GLEnum2[GLEnum2["QUERY_RESULT_AVAILABLE"] = 34919] = "QUERY_RESULT_AVAILABLE";
+  GLEnum2[GLEnum2["ANY_SAMPLES_PASSED"] = 35887] = "ANY_SAMPLES_PASSED";
+  GLEnum2[GLEnum2["ANY_SAMPLES_PASSED_CONSERVATIVE"] = 36202] = "ANY_SAMPLES_PASSED_CONSERVATIVE";
+  GLEnum2[GLEnum2["MAX_DRAW_BUFFERS"] = 34852] = "MAX_DRAW_BUFFERS";
+  GLEnum2[GLEnum2["DRAW_BUFFER0"] = 34853] = "DRAW_BUFFER0";
+  GLEnum2[GLEnum2["DRAW_BUFFER1"] = 34854] = "DRAW_BUFFER1";
+  GLEnum2[GLEnum2["DRAW_BUFFER2"] = 34855] = "DRAW_BUFFER2";
+  GLEnum2[GLEnum2["DRAW_BUFFER3"] = 34856] = "DRAW_BUFFER3";
+  GLEnum2[GLEnum2["DRAW_BUFFER4"] = 34857] = "DRAW_BUFFER4";
+  GLEnum2[GLEnum2["DRAW_BUFFER5"] = 34858] = "DRAW_BUFFER5";
+  GLEnum2[GLEnum2["DRAW_BUFFER6"] = 34859] = "DRAW_BUFFER6";
+  GLEnum2[GLEnum2["DRAW_BUFFER7"] = 34860] = "DRAW_BUFFER7";
+  GLEnum2[GLEnum2["DRAW_BUFFER8"] = 34861] = "DRAW_BUFFER8";
+  GLEnum2[GLEnum2["DRAW_BUFFER9"] = 34862] = "DRAW_BUFFER9";
+  GLEnum2[GLEnum2["DRAW_BUFFER10"] = 34863] = "DRAW_BUFFER10";
+  GLEnum2[GLEnum2["DRAW_BUFFER11"] = 34864] = "DRAW_BUFFER11";
+  GLEnum2[GLEnum2["DRAW_BUFFER12"] = 34865] = "DRAW_BUFFER12";
+  GLEnum2[GLEnum2["DRAW_BUFFER13"] = 34866] = "DRAW_BUFFER13";
+  GLEnum2[GLEnum2["DRAW_BUFFER14"] = 34867] = "DRAW_BUFFER14";
+  GLEnum2[GLEnum2["DRAW_BUFFER15"] = 34868] = "DRAW_BUFFER15";
+  GLEnum2[GLEnum2["MAX_COLOR_ATTACHMENTS"] = 36063] = "MAX_COLOR_ATTACHMENTS";
+  GLEnum2[GLEnum2["COLOR_ATTACHMENT1"] = 36065] = "COLOR_ATTACHMENT1";
+  GLEnum2[GLEnum2["COLOR_ATTACHMENT2"] = 36066] = "COLOR_ATTACHMENT2";
+  GLEnum2[GLEnum2["COLOR_ATTACHMENT3"] = 36067] = "COLOR_ATTACHMENT3";
+  GLEnum2[GLEnum2["COLOR_ATTACHMENT4"] = 36068] = "COLOR_ATTACHMENT4";
+  GLEnum2[GLEnum2["COLOR_ATTACHMENT5"] = 36069] = "COLOR_ATTACHMENT5";
+  GLEnum2[GLEnum2["COLOR_ATTACHMENT6"] = 36070] = "COLOR_ATTACHMENT6";
+  GLEnum2[GLEnum2["COLOR_ATTACHMENT7"] = 36071] = "COLOR_ATTACHMENT7";
+  GLEnum2[GLEnum2["COLOR_ATTACHMENT8"] = 36072] = "COLOR_ATTACHMENT8";
+  GLEnum2[GLEnum2["COLOR_ATTACHMENT9"] = 36073] = "COLOR_ATTACHMENT9";
+  GLEnum2[GLEnum2["COLOR_ATTACHMENT10"] = 36074] = "COLOR_ATTACHMENT10";
+  GLEnum2[GLEnum2["COLOR_ATTACHMENT11"] = 36075] = "COLOR_ATTACHMENT11";
+  GLEnum2[GLEnum2["COLOR_ATTACHMENT12"] = 36076] = "COLOR_ATTACHMENT12";
+  GLEnum2[GLEnum2["COLOR_ATTACHMENT13"] = 36077] = "COLOR_ATTACHMENT13";
+  GLEnum2[GLEnum2["COLOR_ATTACHMENT14"] = 36078] = "COLOR_ATTACHMENT14";
+  GLEnum2[GLEnum2["COLOR_ATTACHMENT15"] = 36079] = "COLOR_ATTACHMENT15";
+  GLEnum2[GLEnum2["SAMPLER_3D"] = 35679] = "SAMPLER_3D";
+  GLEnum2[GLEnum2["SAMPLER_2D_SHADOW"] = 35682] = "SAMPLER_2D_SHADOW";
+  GLEnum2[GLEnum2["SAMPLER_2D_ARRAY"] = 36289] = "SAMPLER_2D_ARRAY";
+  GLEnum2[GLEnum2["SAMPLER_2D_ARRAY_SHADOW"] = 36292] = "SAMPLER_2D_ARRAY_SHADOW";
+  GLEnum2[GLEnum2["SAMPLER_CUBE_SHADOW"] = 36293] = "SAMPLER_CUBE_SHADOW";
+  GLEnum2[GLEnum2["INT_SAMPLER_2D"] = 36298] = "INT_SAMPLER_2D";
+  GLEnum2[GLEnum2["INT_SAMPLER_3D"] = 36299] = "INT_SAMPLER_3D";
+  GLEnum2[GLEnum2["INT_SAMPLER_CUBE"] = 36300] = "INT_SAMPLER_CUBE";
+  GLEnum2[GLEnum2["INT_SAMPLER_2D_ARRAY"] = 36303] = "INT_SAMPLER_2D_ARRAY";
+  GLEnum2[GLEnum2["UNSIGNED_INT_SAMPLER_2D"] = 36306] = "UNSIGNED_INT_SAMPLER_2D";
+  GLEnum2[GLEnum2["UNSIGNED_INT_SAMPLER_3D"] = 36307] = "UNSIGNED_INT_SAMPLER_3D";
+  GLEnum2[GLEnum2["UNSIGNED_INT_SAMPLER_CUBE"] = 36308] = "UNSIGNED_INT_SAMPLER_CUBE";
+  GLEnum2[GLEnum2["UNSIGNED_INT_SAMPLER_2D_ARRAY"] = 36311] = "UNSIGNED_INT_SAMPLER_2D_ARRAY";
+  GLEnum2[GLEnum2["MAX_SAMPLES"] = 36183] = "MAX_SAMPLES";
+  GLEnum2[GLEnum2["SAMPLER_BINDING"] = 35097] = "SAMPLER_BINDING";
+  GLEnum2[GLEnum2["PIXEL_PACK_BUFFER"] = 35051] = "PIXEL_PACK_BUFFER";
+  GLEnum2[GLEnum2["PIXEL_UNPACK_BUFFER"] = 35052] = "PIXEL_UNPACK_BUFFER";
+  GLEnum2[GLEnum2["PIXEL_PACK_BUFFER_BINDING"] = 35053] = "PIXEL_PACK_BUFFER_BINDING";
+  GLEnum2[GLEnum2["PIXEL_UNPACK_BUFFER_BINDING"] = 35055] = "PIXEL_UNPACK_BUFFER_BINDING";
+  GLEnum2[GLEnum2["COPY_READ_BUFFER"] = 36662] = "COPY_READ_BUFFER";
+  GLEnum2[GLEnum2["COPY_WRITE_BUFFER"] = 36663] = "COPY_WRITE_BUFFER";
+  GLEnum2[GLEnum2["COPY_READ_BUFFER_BINDING"] = 36662] = "COPY_READ_BUFFER_BINDING";
+  GLEnum2[GLEnum2["COPY_WRITE_BUFFER_BINDING"] = 36663] = "COPY_WRITE_BUFFER_BINDING";
+  GLEnum2[GLEnum2["FLOAT_MAT2x3"] = 35685] = "FLOAT_MAT2x3";
+  GLEnum2[GLEnum2["FLOAT_MAT2x4"] = 35686] = "FLOAT_MAT2x4";
+  GLEnum2[GLEnum2["FLOAT_MAT3x2"] = 35687] = "FLOAT_MAT3x2";
+  GLEnum2[GLEnum2["FLOAT_MAT3x4"] = 35688] = "FLOAT_MAT3x4";
+  GLEnum2[GLEnum2["FLOAT_MAT4x2"] = 35689] = "FLOAT_MAT4x2";
+  GLEnum2[GLEnum2["FLOAT_MAT4x3"] = 35690] = "FLOAT_MAT4x3";
+  GLEnum2[GLEnum2["UNSIGNED_INT_VEC2"] = 36294] = "UNSIGNED_INT_VEC2";
+  GLEnum2[GLEnum2["UNSIGNED_INT_VEC3"] = 36295] = "UNSIGNED_INT_VEC3";
+  GLEnum2[GLEnum2["UNSIGNED_INT_VEC4"] = 36296] = "UNSIGNED_INT_VEC4";
+  GLEnum2[GLEnum2["UNSIGNED_NORMALIZED"] = 35863] = "UNSIGNED_NORMALIZED";
+  GLEnum2[GLEnum2["SIGNED_NORMALIZED"] = 36764] = "SIGNED_NORMALIZED";
+  GLEnum2[GLEnum2["VERTEX_ATTRIB_ARRAY_INTEGER"] = 35069] = "VERTEX_ATTRIB_ARRAY_INTEGER";
+  GLEnum2[GLEnum2["VERTEX_ATTRIB_ARRAY_DIVISOR"] = 35070] = "VERTEX_ATTRIB_ARRAY_DIVISOR";
+  GLEnum2[GLEnum2["TRANSFORM_FEEDBACK_BUFFER_MODE"] = 35967] = "TRANSFORM_FEEDBACK_BUFFER_MODE";
+  GLEnum2[GLEnum2["MAX_TRANSFORM_FEEDBACK_SEPARATE_COMPONENTS"] = 35968] = "MAX_TRANSFORM_FEEDBACK_SEPARATE_COMPONENTS";
+  GLEnum2[GLEnum2["TRANSFORM_FEEDBACK_VARYINGS"] = 35971] = "TRANSFORM_FEEDBACK_VARYINGS";
+  GLEnum2[GLEnum2["TRANSFORM_FEEDBACK_BUFFER_START"] = 35972] = "TRANSFORM_FEEDBACK_BUFFER_START";
+  GLEnum2[GLEnum2["TRANSFORM_FEEDBACK_BUFFER_SIZE"] = 35973] = "TRANSFORM_FEEDBACK_BUFFER_SIZE";
+  GLEnum2[GLEnum2["TRANSFORM_FEEDBACK_PRIMITIVES_WRITTEN"] = 35976] = "TRANSFORM_FEEDBACK_PRIMITIVES_WRITTEN";
+  GLEnum2[GLEnum2["MAX_TRANSFORM_FEEDBACK_INTERLEAVED_COMPONENTS"] = 35978] = "MAX_TRANSFORM_FEEDBACK_INTERLEAVED_COMPONENTS";
+  GLEnum2[GLEnum2["MAX_TRANSFORM_FEEDBACK_SEPARATE_ATTRIBS"] = 35979] = "MAX_TRANSFORM_FEEDBACK_SEPARATE_ATTRIBS";
+  GLEnum2[GLEnum2["INTERLEAVED_ATTRIBS"] = 35980] = "INTERLEAVED_ATTRIBS";
+  GLEnum2[GLEnum2["SEPARATE_ATTRIBS"] = 35981] = "SEPARATE_ATTRIBS";
+  GLEnum2[GLEnum2["TRANSFORM_FEEDBACK_BUFFER"] = 35982] = "TRANSFORM_FEEDBACK_BUFFER";
+  GLEnum2[GLEnum2["TRANSFORM_FEEDBACK_BUFFER_BINDING"] = 35983] = "TRANSFORM_FEEDBACK_BUFFER_BINDING";
+  GLEnum2[GLEnum2["TRANSFORM_FEEDBACK"] = 36386] = "TRANSFORM_FEEDBACK";
+  GLEnum2[GLEnum2["TRANSFORM_FEEDBACK_PAUSED"] = 36387] = "TRANSFORM_FEEDBACK_PAUSED";
+  GLEnum2[GLEnum2["TRANSFORM_FEEDBACK_ACTIVE"] = 36388] = "TRANSFORM_FEEDBACK_ACTIVE";
+  GLEnum2[GLEnum2["TRANSFORM_FEEDBACK_BINDING"] = 36389] = "TRANSFORM_FEEDBACK_BINDING";
+  GLEnum2[GLEnum2["FRAMEBUFFER_ATTACHMENT_COLOR_ENCODING"] = 33296] = "FRAMEBUFFER_ATTACHMENT_COLOR_ENCODING";
+  GLEnum2[GLEnum2["FRAMEBUFFER_ATTACHMENT_COMPONENT_TYPE"] = 33297] = "FRAMEBUFFER_ATTACHMENT_COMPONENT_TYPE";
+  GLEnum2[GLEnum2["FRAMEBUFFER_ATTACHMENT_RED_SIZE"] = 33298] = "FRAMEBUFFER_ATTACHMENT_RED_SIZE";
+  GLEnum2[GLEnum2["FRAMEBUFFER_ATTACHMENT_GREEN_SIZE"] = 33299] = "FRAMEBUFFER_ATTACHMENT_GREEN_SIZE";
+  GLEnum2[GLEnum2["FRAMEBUFFER_ATTACHMENT_BLUE_SIZE"] = 33300] = "FRAMEBUFFER_ATTACHMENT_BLUE_SIZE";
+  GLEnum2[GLEnum2["FRAMEBUFFER_ATTACHMENT_ALPHA_SIZE"] = 33301] = "FRAMEBUFFER_ATTACHMENT_ALPHA_SIZE";
+  GLEnum2[GLEnum2["FRAMEBUFFER_ATTACHMENT_DEPTH_SIZE"] = 33302] = "FRAMEBUFFER_ATTACHMENT_DEPTH_SIZE";
+  GLEnum2[GLEnum2["FRAMEBUFFER_ATTACHMENT_STENCIL_SIZE"] = 33303] = "FRAMEBUFFER_ATTACHMENT_STENCIL_SIZE";
+  GLEnum2[GLEnum2["FRAMEBUFFER_DEFAULT"] = 33304] = "FRAMEBUFFER_DEFAULT";
+  GLEnum2[GLEnum2["DEPTH24_STENCIL8"] = 35056] = "DEPTH24_STENCIL8";
+  GLEnum2[GLEnum2["DRAW_FRAMEBUFFER_BINDING"] = 36006] = "DRAW_FRAMEBUFFER_BINDING";
+  GLEnum2[GLEnum2["READ_FRAMEBUFFER_BINDING"] = 36010] = "READ_FRAMEBUFFER_BINDING";
+  GLEnum2[GLEnum2["RENDERBUFFER_SAMPLES"] = 36011] = "RENDERBUFFER_SAMPLES";
+  GLEnum2[GLEnum2["FRAMEBUFFER_ATTACHMENT_TEXTURE_LAYER"] = 36052] = "FRAMEBUFFER_ATTACHMENT_TEXTURE_LAYER";
+  GLEnum2[GLEnum2["FRAMEBUFFER_INCOMPLETE_MULTISAMPLE"] = 36182] = "FRAMEBUFFER_INCOMPLETE_MULTISAMPLE";
+  GLEnum2[GLEnum2["UNIFORM_BUFFER"] = 35345] = "UNIFORM_BUFFER";
+  GLEnum2[GLEnum2["UNIFORM_BUFFER_BINDING"] = 35368] = "UNIFORM_BUFFER_BINDING";
+  GLEnum2[GLEnum2["UNIFORM_BUFFER_START"] = 35369] = "UNIFORM_BUFFER_START";
+  GLEnum2[GLEnum2["UNIFORM_BUFFER_SIZE"] = 35370] = "UNIFORM_BUFFER_SIZE";
+  GLEnum2[GLEnum2["MAX_VERTEX_UNIFORM_BLOCKS"] = 35371] = "MAX_VERTEX_UNIFORM_BLOCKS";
+  GLEnum2[GLEnum2["MAX_FRAGMENT_UNIFORM_BLOCKS"] = 35373] = "MAX_FRAGMENT_UNIFORM_BLOCKS";
+  GLEnum2[GLEnum2["MAX_COMBINED_UNIFORM_BLOCKS"] = 35374] = "MAX_COMBINED_UNIFORM_BLOCKS";
+  GLEnum2[GLEnum2["MAX_UNIFORM_BUFFER_BINDINGS"] = 35375] = "MAX_UNIFORM_BUFFER_BINDINGS";
+  GLEnum2[GLEnum2["MAX_UNIFORM_BLOCK_SIZE"] = 35376] = "MAX_UNIFORM_BLOCK_SIZE";
+  GLEnum2[GLEnum2["MAX_COMBINED_VERTEX_UNIFORM_COMPONENTS"] = 35377] = "MAX_COMBINED_VERTEX_UNIFORM_COMPONENTS";
+  GLEnum2[GLEnum2["MAX_COMBINED_FRAGMENT_UNIFORM_COMPONENTS"] = 35379] = "MAX_COMBINED_FRAGMENT_UNIFORM_COMPONENTS";
+  GLEnum2[GLEnum2["UNIFORM_BUFFER_OFFSET_ALIGNMENT"] = 35380] = "UNIFORM_BUFFER_OFFSET_ALIGNMENT";
+  GLEnum2[GLEnum2["ACTIVE_UNIFORM_BLOCKS"] = 35382] = "ACTIVE_UNIFORM_BLOCKS";
+  GLEnum2[GLEnum2["UNIFORM_TYPE"] = 35383] = "UNIFORM_TYPE";
+  GLEnum2[GLEnum2["UNIFORM_SIZE"] = 35384] = "UNIFORM_SIZE";
+  GLEnum2[GLEnum2["UNIFORM_BLOCK_INDEX"] = 35386] = "UNIFORM_BLOCK_INDEX";
+  GLEnum2[GLEnum2["UNIFORM_OFFSET"] = 35387] = "UNIFORM_OFFSET";
+  GLEnum2[GLEnum2["UNIFORM_ARRAY_STRIDE"] = 35388] = "UNIFORM_ARRAY_STRIDE";
+  GLEnum2[GLEnum2["UNIFORM_MATRIX_STRIDE"] = 35389] = "UNIFORM_MATRIX_STRIDE";
+  GLEnum2[GLEnum2["UNIFORM_IS_ROW_MAJOR"] = 35390] = "UNIFORM_IS_ROW_MAJOR";
+  GLEnum2[GLEnum2["UNIFORM_BLOCK_BINDING"] = 35391] = "UNIFORM_BLOCK_BINDING";
+  GLEnum2[GLEnum2["UNIFORM_BLOCK_DATA_SIZE"] = 35392] = "UNIFORM_BLOCK_DATA_SIZE";
+  GLEnum2[GLEnum2["UNIFORM_BLOCK_ACTIVE_UNIFORMS"] = 35394] = "UNIFORM_BLOCK_ACTIVE_UNIFORMS";
+  GLEnum2[GLEnum2["UNIFORM_BLOCK_ACTIVE_UNIFORM_INDICES"] = 35395] = "UNIFORM_BLOCK_ACTIVE_UNIFORM_INDICES";
+  GLEnum2[GLEnum2["UNIFORM_BLOCK_REFERENCED_BY_VERTEX_SHADER"] = 35396] = "UNIFORM_BLOCK_REFERENCED_BY_VERTEX_SHADER";
+  GLEnum2[GLEnum2["UNIFORM_BLOCK_REFERENCED_BY_FRAGMENT_SHADER"] = 35398] = "UNIFORM_BLOCK_REFERENCED_BY_FRAGMENT_SHADER";
+  GLEnum2[GLEnum2["OBJECT_TYPE"] = 37138] = "OBJECT_TYPE";
+  GLEnum2[GLEnum2["SYNC_CONDITION"] = 37139] = "SYNC_CONDITION";
+  GLEnum2[GLEnum2["SYNC_STATUS"] = 37140] = "SYNC_STATUS";
+  GLEnum2[GLEnum2["SYNC_FLAGS"] = 37141] = "SYNC_FLAGS";
+  GLEnum2[GLEnum2["SYNC_FENCE"] = 37142] = "SYNC_FENCE";
+  GLEnum2[GLEnum2["SYNC_GPU_COMMANDS_COMPLETE"] = 37143] = "SYNC_GPU_COMMANDS_COMPLETE";
+  GLEnum2[GLEnum2["UNSIGNALED"] = 37144] = "UNSIGNALED";
+  GLEnum2[GLEnum2["SIGNALED"] = 37145] = "SIGNALED";
+  GLEnum2[GLEnum2["ALREADY_SIGNALED"] = 37146] = "ALREADY_SIGNALED";
+  GLEnum2[GLEnum2["TIMEOUT_EXPIRED"] = 37147] = "TIMEOUT_EXPIRED";
+  GLEnum2[GLEnum2["CONDITION_SATISFIED"] = 37148] = "CONDITION_SATISFIED";
+  GLEnum2[GLEnum2["WAIT_FAILED"] = 37149] = "WAIT_FAILED";
+  GLEnum2[GLEnum2["SYNC_FLUSH_COMMANDS_BIT"] = 1] = "SYNC_FLUSH_COMMANDS_BIT";
+  GLEnum2[GLEnum2["COLOR"] = 6144] = "COLOR";
+  GLEnum2[GLEnum2["DEPTH"] = 6145] = "DEPTH";
+  GLEnum2[GLEnum2["STENCIL"] = 6146] = "STENCIL";
+  GLEnum2[GLEnum2["MIN"] = 32775] = "MIN";
+  GLEnum2[GLEnum2["MAX"] = 32776] = "MAX";
+  GLEnum2[GLEnum2["DEPTH_COMPONENT24"] = 33190] = "DEPTH_COMPONENT24";
+  GLEnum2[GLEnum2["STREAM_READ"] = 35041] = "STREAM_READ";
+  GLEnum2[GLEnum2["STREAM_COPY"] = 35042] = "STREAM_COPY";
+  GLEnum2[GLEnum2["STATIC_READ"] = 35045] = "STATIC_READ";
+  GLEnum2[GLEnum2["STATIC_COPY"] = 35046] = "STATIC_COPY";
+  GLEnum2[GLEnum2["DYNAMIC_READ"] = 35049] = "DYNAMIC_READ";
+  GLEnum2[GLEnum2["DYNAMIC_COPY"] = 35050] = "DYNAMIC_COPY";
+  GLEnum2[GLEnum2["DEPTH_COMPONENT32F"] = 36012] = "DEPTH_COMPONENT32F";
+  GLEnum2[GLEnum2["DEPTH32F_STENCIL8"] = 36013] = "DEPTH32F_STENCIL8";
+  GLEnum2[GLEnum2["INVALID_INDEX"] = 4294967295] = "INVALID_INDEX";
+  GLEnum2[GLEnum2["TIMEOUT_IGNORED"] = -1] = "TIMEOUT_IGNORED";
+  GLEnum2[GLEnum2["MAX_CLIENT_WAIT_TIMEOUT_WEBGL"] = 37447] = "MAX_CLIENT_WAIT_TIMEOUT_WEBGL";
+  GLEnum2[GLEnum2["UNMASKED_VENDOR_WEBGL"] = 37445] = "UNMASKED_VENDOR_WEBGL";
+  GLEnum2[GLEnum2["UNMASKED_RENDERER_WEBGL"] = 37446] = "UNMASKED_RENDERER_WEBGL";
+  GLEnum2[GLEnum2["MAX_TEXTURE_MAX_ANISOTROPY_EXT"] = 34047] = "MAX_TEXTURE_MAX_ANISOTROPY_EXT";
+  GLEnum2[GLEnum2["TEXTURE_MAX_ANISOTROPY_EXT"] = 34046] = "TEXTURE_MAX_ANISOTROPY_EXT";
+  GLEnum2[GLEnum2["R16_EXT"] = 33322] = "R16_EXT";
+  GLEnum2[GLEnum2["RG16_EXT"] = 33324] = "RG16_EXT";
+  GLEnum2[GLEnum2["RGB16_EXT"] = 32852] = "RGB16_EXT";
+  GLEnum2[GLEnum2["RGBA16_EXT"] = 32859] = "RGBA16_EXT";
+  GLEnum2[GLEnum2["R16_SNORM_EXT"] = 36760] = "R16_SNORM_EXT";
+  GLEnum2[GLEnum2["RG16_SNORM_EXT"] = 36761] = "RG16_SNORM_EXT";
+  GLEnum2[GLEnum2["RGB16_SNORM_EXT"] = 36762] = "RGB16_SNORM_EXT";
+  GLEnum2[GLEnum2["RGBA16_SNORM_EXT"] = 36763] = "RGBA16_SNORM_EXT";
+  GLEnum2[GLEnum2["COMPRESSED_RGB_S3TC_DXT1_EXT"] = 33776] = "COMPRESSED_RGB_S3TC_DXT1_EXT";
+  GLEnum2[GLEnum2["COMPRESSED_RGBA_S3TC_DXT1_EXT"] = 33777] = "COMPRESSED_RGBA_S3TC_DXT1_EXT";
+  GLEnum2[GLEnum2["COMPRESSED_RGBA_S3TC_DXT3_EXT"] = 33778] = "COMPRESSED_RGBA_S3TC_DXT3_EXT";
+  GLEnum2[GLEnum2["COMPRESSED_RGBA_S3TC_DXT5_EXT"] = 33779] = "COMPRESSED_RGBA_S3TC_DXT5_EXT";
+  GLEnum2[GLEnum2["COMPRESSED_SRGB_S3TC_DXT1_EXT"] = 35916] = "COMPRESSED_SRGB_S3TC_DXT1_EXT";
+  GLEnum2[GLEnum2["COMPRESSED_SRGB_ALPHA_S3TC_DXT1_EXT"] = 35917] = "COMPRESSED_SRGB_ALPHA_S3TC_DXT1_EXT";
+  GLEnum2[GLEnum2["COMPRESSED_SRGB_ALPHA_S3TC_DXT3_EXT"] = 35918] = "COMPRESSED_SRGB_ALPHA_S3TC_DXT3_EXT";
+  GLEnum2[GLEnum2["COMPRESSED_SRGB_ALPHA_S3TC_DXT5_EXT"] = 35919] = "COMPRESSED_SRGB_ALPHA_S3TC_DXT5_EXT";
+  GLEnum2[GLEnum2["COMPRESSED_RED_RGTC1_EXT"] = 36283] = "COMPRESSED_RED_RGTC1_EXT";
+  GLEnum2[GLEnum2["COMPRESSED_SIGNED_RED_RGTC1_EXT"] = 36284] = "COMPRESSED_SIGNED_RED_RGTC1_EXT";
+  GLEnum2[GLEnum2["COMPRESSED_RED_GREEN_RGTC2_EXT"] = 36285] = "COMPRESSED_RED_GREEN_RGTC2_EXT";
+  GLEnum2[GLEnum2["COMPRESSED_SIGNED_RED_GREEN_RGTC2_EXT"] = 36286] = "COMPRESSED_SIGNED_RED_GREEN_RGTC2_EXT";
+  GLEnum2[GLEnum2["COMPRESSED_RGBA_BPTC_UNORM_EXT"] = 36492] = "COMPRESSED_RGBA_BPTC_UNORM_EXT";
+  GLEnum2[GLEnum2["COMPRESSED_SRGB_ALPHA_BPTC_UNORM_EXT"] = 36493] = "COMPRESSED_SRGB_ALPHA_BPTC_UNORM_EXT";
+  GLEnum2[GLEnum2["COMPRESSED_RGB_BPTC_SIGNED_FLOAT_EXT"] = 36494] = "COMPRESSED_RGB_BPTC_SIGNED_FLOAT_EXT";
+  GLEnum2[GLEnum2["COMPRESSED_RGB_BPTC_UNSIGNED_FLOAT_EXT"] = 36495] = "COMPRESSED_RGB_BPTC_UNSIGNED_FLOAT_EXT";
+  GLEnum2[GLEnum2["COMPRESSED_R11_EAC"] = 37488] = "COMPRESSED_R11_EAC";
+  GLEnum2[GLEnum2["COMPRESSED_SIGNED_R11_EAC"] = 37489] = "COMPRESSED_SIGNED_R11_EAC";
+  GLEnum2[GLEnum2["COMPRESSED_RG11_EAC"] = 37490] = "COMPRESSED_RG11_EAC";
+  GLEnum2[GLEnum2["COMPRESSED_SIGNED_RG11_EAC"] = 37491] = "COMPRESSED_SIGNED_RG11_EAC";
+  GLEnum2[GLEnum2["COMPRESSED_RGB8_ETC2"] = 37492] = "COMPRESSED_RGB8_ETC2";
+  GLEnum2[GLEnum2["COMPRESSED_RGBA8_ETC2_EAC"] = 37493] = "COMPRESSED_RGBA8_ETC2_EAC";
+  GLEnum2[GLEnum2["COMPRESSED_SRGB8_ETC2"] = 37494] = "COMPRESSED_SRGB8_ETC2";
+  GLEnum2[GLEnum2["COMPRESSED_SRGB8_ALPHA8_ETC2_EAC"] = 37495] = "COMPRESSED_SRGB8_ALPHA8_ETC2_EAC";
+  GLEnum2[GLEnum2["COMPRESSED_RGB8_PUNCHTHROUGH_ALPHA1_ETC2"] = 37496] = "COMPRESSED_RGB8_PUNCHTHROUGH_ALPHA1_ETC2";
+  GLEnum2[GLEnum2["COMPRESSED_SRGB8_PUNCHTHROUGH_ALPHA1_ETC2"] = 37497] = "COMPRESSED_SRGB8_PUNCHTHROUGH_ALPHA1_ETC2";
+  GLEnum2[GLEnum2["COMPRESSED_RGB_PVRTC_4BPPV1_IMG"] = 35840] = "COMPRESSED_RGB_PVRTC_4BPPV1_IMG";
+  GLEnum2[GLEnum2["COMPRESSED_RGBA_PVRTC_4BPPV1_IMG"] = 35842] = "COMPRESSED_RGBA_PVRTC_4BPPV1_IMG";
+  GLEnum2[GLEnum2["COMPRESSED_RGB_PVRTC_2BPPV1_IMG"] = 35841] = "COMPRESSED_RGB_PVRTC_2BPPV1_IMG";
+  GLEnum2[GLEnum2["COMPRESSED_RGBA_PVRTC_2BPPV1_IMG"] = 35843] = "COMPRESSED_RGBA_PVRTC_2BPPV1_IMG";
+  GLEnum2[GLEnum2["COMPRESSED_RGB_ETC1_WEBGL"] = 36196] = "COMPRESSED_RGB_ETC1_WEBGL";
+  GLEnum2[GLEnum2["COMPRESSED_RGB_ATC_WEBGL"] = 35986] = "COMPRESSED_RGB_ATC_WEBGL";
+  GLEnum2[GLEnum2["COMPRESSED_RGBA_ATC_EXPLICIT_ALPHA_WEBGL"] = 35986] = "COMPRESSED_RGBA_ATC_EXPLICIT_ALPHA_WEBGL";
+  GLEnum2[GLEnum2["COMPRESSED_RGBA_ATC_INTERPOLATED_ALPHA_WEBGL"] = 34798] = "COMPRESSED_RGBA_ATC_INTERPOLATED_ALPHA_WEBGL";
+  GLEnum2[GLEnum2["COMPRESSED_RGBA_ASTC_4x4_KHR"] = 37808] = "COMPRESSED_RGBA_ASTC_4x4_KHR";
+  GLEnum2[GLEnum2["COMPRESSED_RGBA_ASTC_5x4_KHR"] = 37809] = "COMPRESSED_RGBA_ASTC_5x4_KHR";
+  GLEnum2[GLEnum2["COMPRESSED_RGBA_ASTC_5x5_KHR"] = 37810] = "COMPRESSED_RGBA_ASTC_5x5_KHR";
+  GLEnum2[GLEnum2["COMPRESSED_RGBA_ASTC_6x5_KHR"] = 37811] = "COMPRESSED_RGBA_ASTC_6x5_KHR";
+  GLEnum2[GLEnum2["COMPRESSED_RGBA_ASTC_6x6_KHR"] = 37812] = "COMPRESSED_RGBA_ASTC_6x6_KHR";
+  GLEnum2[GLEnum2["COMPRESSED_RGBA_ASTC_8x5_KHR"] = 37813] = "COMPRESSED_RGBA_ASTC_8x5_KHR";
+  GLEnum2[GLEnum2["COMPRESSED_RGBA_ASTC_8x6_KHR"] = 37814] = "COMPRESSED_RGBA_ASTC_8x6_KHR";
+  GLEnum2[GLEnum2["COMPRESSED_RGBA_ASTC_8x8_KHR"] = 37815] = "COMPRESSED_RGBA_ASTC_8x8_KHR";
+  GLEnum2[GLEnum2["COMPRESSED_RGBA_ASTC_10x5_KHR"] = 37816] = "COMPRESSED_RGBA_ASTC_10x5_KHR";
+  GLEnum2[GLEnum2["COMPRESSED_RGBA_ASTC_10x6_KHR"] = 37817] = "COMPRESSED_RGBA_ASTC_10x6_KHR";
+  GLEnum2[GLEnum2["COMPRESSED_RGBA_ASTC_10x8_KHR"] = 37818] = "COMPRESSED_RGBA_ASTC_10x8_KHR";
+  GLEnum2[GLEnum2["COMPRESSED_RGBA_ASTC_10x10_KHR"] = 37819] = "COMPRESSED_RGBA_ASTC_10x10_KHR";
+  GLEnum2[GLEnum2["COMPRESSED_RGBA_ASTC_12x10_KHR"] = 37820] = "COMPRESSED_RGBA_ASTC_12x10_KHR";
+  GLEnum2[GLEnum2["COMPRESSED_RGBA_ASTC_12x12_KHR"] = 37821] = "COMPRESSED_RGBA_ASTC_12x12_KHR";
+  GLEnum2[GLEnum2["COMPRESSED_SRGB8_ALPHA8_ASTC_4x4_KHR"] = 37840] = "COMPRESSED_SRGB8_ALPHA8_ASTC_4x4_KHR";
+  GLEnum2[GLEnum2["COMPRESSED_SRGB8_ALPHA8_ASTC_5x4_KHR"] = 37841] = "COMPRESSED_SRGB8_ALPHA8_ASTC_5x4_KHR";
+  GLEnum2[GLEnum2["COMPRESSED_SRGB8_ALPHA8_ASTC_5x5_KHR"] = 37842] = "COMPRESSED_SRGB8_ALPHA8_ASTC_5x5_KHR";
+  GLEnum2[GLEnum2["COMPRESSED_SRGB8_ALPHA8_ASTC_6x5_KHR"] = 37843] = "COMPRESSED_SRGB8_ALPHA8_ASTC_6x5_KHR";
+  GLEnum2[GLEnum2["COMPRESSED_SRGB8_ALPHA8_ASTC_6x6_KHR"] = 37844] = "COMPRESSED_SRGB8_ALPHA8_ASTC_6x6_KHR";
+  GLEnum2[GLEnum2["COMPRESSED_SRGB8_ALPHA8_ASTC_8x5_KHR"] = 37845] = "COMPRESSED_SRGB8_ALPHA8_ASTC_8x5_KHR";
+  GLEnum2[GLEnum2["COMPRESSED_SRGB8_ALPHA8_ASTC_8x6_KHR"] = 37846] = "COMPRESSED_SRGB8_ALPHA8_ASTC_8x6_KHR";
+  GLEnum2[GLEnum2["COMPRESSED_SRGB8_ALPHA8_ASTC_8x8_KHR"] = 37847] = "COMPRESSED_SRGB8_ALPHA8_ASTC_8x8_KHR";
+  GLEnum2[GLEnum2["COMPRESSED_SRGB8_ALPHA8_ASTC_10x5_KHR"] = 37848] = "COMPRESSED_SRGB8_ALPHA8_ASTC_10x5_KHR";
+  GLEnum2[GLEnum2["COMPRESSED_SRGB8_ALPHA8_ASTC_10x6_KHR"] = 37849] = "COMPRESSED_SRGB8_ALPHA8_ASTC_10x6_KHR";
+  GLEnum2[GLEnum2["COMPRESSED_SRGB8_ALPHA8_ASTC_10x8_KHR"] = 37850] = "COMPRESSED_SRGB8_ALPHA8_ASTC_10x8_KHR";
+  GLEnum2[GLEnum2["COMPRESSED_SRGB8_ALPHA8_ASTC_10x10_KHR"] = 37851] = "COMPRESSED_SRGB8_ALPHA8_ASTC_10x10_KHR";
+  GLEnum2[GLEnum2["COMPRESSED_SRGB8_ALPHA8_ASTC_12x10_KHR"] = 37852] = "COMPRESSED_SRGB8_ALPHA8_ASTC_12x10_KHR";
+  GLEnum2[GLEnum2["COMPRESSED_SRGB8_ALPHA8_ASTC_12x12_KHR"] = 37853] = "COMPRESSED_SRGB8_ALPHA8_ASTC_12x12_KHR";
+  GLEnum2[GLEnum2["QUERY_COUNTER_BITS_EXT"] = 34916] = "QUERY_COUNTER_BITS_EXT";
+  GLEnum2[GLEnum2["CURRENT_QUERY_EXT"] = 34917] = "CURRENT_QUERY_EXT";
+  GLEnum2[GLEnum2["QUERY_RESULT_EXT"] = 34918] = "QUERY_RESULT_EXT";
+  GLEnum2[GLEnum2["QUERY_RESULT_AVAILABLE_EXT"] = 34919] = "QUERY_RESULT_AVAILABLE_EXT";
+  GLEnum2[GLEnum2["TIME_ELAPSED_EXT"] = 35007] = "TIME_ELAPSED_EXT";
+  GLEnum2[GLEnum2["TIMESTAMP_EXT"] = 36392] = "TIMESTAMP_EXT";
+  GLEnum2[GLEnum2["GPU_DISJOINT_EXT"] = 36795] = "GPU_DISJOINT_EXT";
+  GLEnum2[GLEnum2["COMPLETION_STATUS_KHR"] = 37297] = "COMPLETION_STATUS_KHR";
+  GLEnum2[GLEnum2["DEPTH_CLAMP_EXT"] = 34383] = "DEPTH_CLAMP_EXT";
+  GLEnum2[GLEnum2["FIRST_VERTEX_CONVENTION_WEBGL"] = 36429] = "FIRST_VERTEX_CONVENTION_WEBGL";
+  GLEnum2[GLEnum2["LAST_VERTEX_CONVENTION_WEBGL"] = 36430] = "LAST_VERTEX_CONVENTION_WEBGL";
+  GLEnum2[GLEnum2["PROVOKING_VERTEX_WEBL"] = 36431] = "PROVOKING_VERTEX_WEBL";
+  GLEnum2[GLEnum2["POLYGON_MODE_WEBGL"] = 2880] = "POLYGON_MODE_WEBGL";
+  GLEnum2[GLEnum2["POLYGON_OFFSET_LINE_WEBGL"] = 10754] = "POLYGON_OFFSET_LINE_WEBGL";
+  GLEnum2[GLEnum2["LINE_WEBGL"] = 6913] = "LINE_WEBGL";
+  GLEnum2[GLEnum2["FILL_WEBGL"] = 6914] = "FILL_WEBGL";
+  GLEnum2[GLEnum2["MAX_CLIP_DISTANCES_WEBGL"] = 3378] = "MAX_CLIP_DISTANCES_WEBGL";
+  GLEnum2[GLEnum2["MAX_CULL_DISTANCES_WEBGL"] = 33529] = "MAX_CULL_DISTANCES_WEBGL";
+  GLEnum2[GLEnum2["MAX_COMBINED_CLIP_AND_CULL_DISTANCES_WEBGL"] = 33530] = "MAX_COMBINED_CLIP_AND_CULL_DISTANCES_WEBGL";
+  GLEnum2[GLEnum2["CLIP_DISTANCE0_WEBGL"] = 12288] = "CLIP_DISTANCE0_WEBGL";
+  GLEnum2[GLEnum2["CLIP_DISTANCE1_WEBGL"] = 12289] = "CLIP_DISTANCE1_WEBGL";
+  GLEnum2[GLEnum2["CLIP_DISTANCE2_WEBGL"] = 12290] = "CLIP_DISTANCE2_WEBGL";
+  GLEnum2[GLEnum2["CLIP_DISTANCE3_WEBGL"] = 12291] = "CLIP_DISTANCE3_WEBGL";
+  GLEnum2[GLEnum2["CLIP_DISTANCE4_WEBGL"] = 12292] = "CLIP_DISTANCE4_WEBGL";
+  GLEnum2[GLEnum2["CLIP_DISTANCE5_WEBGL"] = 12293] = "CLIP_DISTANCE5_WEBGL";
+  GLEnum2[GLEnum2["CLIP_DISTANCE6_WEBGL"] = 12294] = "CLIP_DISTANCE6_WEBGL";
+  GLEnum2[GLEnum2["CLIP_DISTANCE7_WEBGL"] = 12295] = "CLIP_DISTANCE7_WEBGL";
+  GLEnum2[GLEnum2["POLYGON_OFFSET_CLAMP_EXT"] = 36379] = "POLYGON_OFFSET_CLAMP_EXT";
+  GLEnum2[GLEnum2["LOWER_LEFT_EXT"] = 36001] = "LOWER_LEFT_EXT";
+  GLEnum2[GLEnum2["UPPER_LEFT_EXT"] = 36002] = "UPPER_LEFT_EXT";
+  GLEnum2[GLEnum2["NEGATIVE_ONE_TO_ONE_EXT"] = 37726] = "NEGATIVE_ONE_TO_ONE_EXT";
+  GLEnum2[GLEnum2["ZERO_TO_ONE_EXT"] = 37727] = "ZERO_TO_ONE_EXT";
+  GLEnum2[GLEnum2["CLIP_ORIGIN_EXT"] = 37724] = "CLIP_ORIGIN_EXT";
+  GLEnum2[GLEnum2["CLIP_DEPTH_MODE_EXT"] = 37725] = "CLIP_DEPTH_MODE_EXT";
+  GLEnum2[GLEnum2["SRC1_COLOR_WEBGL"] = 35065] = "SRC1_COLOR_WEBGL";
+  GLEnum2[GLEnum2["SRC1_ALPHA_WEBGL"] = 34185] = "SRC1_ALPHA_WEBGL";
+  GLEnum2[GLEnum2["ONE_MINUS_SRC1_COLOR_WEBGL"] = 35066] = "ONE_MINUS_SRC1_COLOR_WEBGL";
+  GLEnum2[GLEnum2["ONE_MINUS_SRC1_ALPHA_WEBGL"] = 35067] = "ONE_MINUS_SRC1_ALPHA_WEBGL";
+  GLEnum2[GLEnum2["MAX_DUAL_SOURCE_DRAW_BUFFERS_WEBGL"] = 35068] = "MAX_DUAL_SOURCE_DRAW_BUFFERS_WEBGL";
+  GLEnum2[GLEnum2["MIRROR_CLAMP_TO_EDGE_EXT"] = 34627] = "MIRROR_CLAMP_TO_EDGE_EXT";
+})(GLEnum || (GLEnum = {}));
+const WEBGL1_STATIC_EXTENSIONS = {
+  WEBGL_depth_texture: {
+    UNSIGNED_INT_24_8_WEBGL: 34042
+  },
+  OES_element_index_uint: {},
+  OES_texture_float: {},
+  OES_texture_half_float: {
+    // @ts-expect-error different numbers?
+    HALF_FLOAT_OES: 5131
+  },
+  EXT_color_buffer_float: {},
+  OES_standard_derivatives: {
+    FRAGMENT_SHADER_DERIVATIVE_HINT_OES: 35723
+  },
+  EXT_frag_depth: {},
+  EXT_blend_minmax: {
+    MIN_EXT: 32775,
+    MAX_EXT: 32776
+  },
+  EXT_shader_texture_lod: {}
+};
+const getWEBGL_draw_buffers = (gl2) => ({
+  drawBuffersWEBGL(buffers) {
+    return gl2.drawBuffers(buffers);
+  },
+  COLOR_ATTACHMENT0_WEBGL: 36064,
+  COLOR_ATTACHMENT1_WEBGL: 36065,
+  COLOR_ATTACHMENT2_WEBGL: 36066,
+  COLOR_ATTACHMENT3_WEBGL: 36067
+});
+const getOES_vertex_array_object = (gl2) => ({
+  VERTEX_ARRAY_BINDING_OES: 34229,
+  createVertexArrayOES() {
+    return gl2.createVertexArray();
+  },
+  deleteVertexArrayOES(vertexArray) {
+    return gl2.deleteVertexArray(vertexArray);
+  },
+  isVertexArrayOES(vertexArray) {
+    return gl2.isVertexArray(vertexArray);
+  },
+  bindVertexArrayOES(vertexArray) {
+    return gl2.bindVertexArray(vertexArray);
+  }
+});
+const getANGLE_instanced_arrays = (gl2) => ({
+  VERTEX_ATTRIB_ARRAY_DIVISOR_ANGLE: 35070,
+  drawArraysInstancedANGLE(...args) {
+    return gl2.drawArraysInstanced(...args);
+  },
+  drawElementsInstancedANGLE(...args) {
+    return gl2.drawElementsInstanced(...args);
+  },
+  vertexAttribDivisorANGLE(...args) {
+    return gl2.vertexAttribDivisor(...args);
+  }
+});
+function enforceWebGL2(enforce = true) {
+  const prototype = HTMLCanvasElement.prototype;
+  if (!enforce && prototype.originalGetContext) {
+    prototype.getContext = prototype.originalGetContext;
+    prototype.originalGetContext = void 0;
+    return;
+  }
+  prototype.originalGetContext = prototype.getContext;
+  prototype.getContext = function(contextId, options) {
+    if (contextId === "webgl" || contextId === "experimental-webgl") {
+      const context = this.originalGetContext("webgl2", options);
+      if (context instanceof HTMLElement) {
+        polyfillWebGL1Extensions(context);
+      }
+      return context;
+    }
+    return this.originalGetContext(contextId, options);
+  };
+}
+function polyfillWebGL1Extensions(gl2) {
+  gl2.getExtension("EXT_color_buffer_float");
+  const boundExtensions = {
+    ...WEBGL1_STATIC_EXTENSIONS,
+    WEBGL_disjoint_timer_query: gl2.getExtension("EXT_disjoint_timer_query_webgl2"),
+    WEBGL_draw_buffers: getWEBGL_draw_buffers(gl2),
+    OES_vertex_array_object: getOES_vertex_array_object(gl2),
+    ANGLE_instanced_arrays: getANGLE_instanced_arrays(gl2)
+  };
+  const originalGetExtension = gl2.getExtension;
+  gl2.getExtension = function(extensionName) {
+    const ext = originalGetExtension.call(gl2, extensionName);
+    if (ext) {
+      return ext;
+    }
+    if (extensionName in boundExtensions) {
+      return boundExtensions[extensionName];
+    }
+    return null;
+  };
+  const originalGetSupportedExtensions = gl2.getSupportedExtensions;
+  gl2.getSupportedExtensions = function() {
+    const extensions = originalGetSupportedExtensions.apply(gl2) || [];
+    return extensions == null ? void 0 : extensions.concat(Object.keys(boundExtensions));
+  };
+}
+async function loadScript(scriptUrl, scriptId) {
+  const head = document.getElementsByTagName("head")[0];
+  if (!head) {
+    throw new Error("loadScript");
+  }
+  const script = document.createElement("script");
+  script.setAttribute("type", "text/javascript");
+  script.setAttribute("src", scriptUrl);
+  return new Promise((resolve, reject) => {
+    script.onload = resolve;
+    script.onerror = (error) => reject(new Error(`Unable to load script '${scriptUrl}': ${error}`));
+    head.appendChild(script);
+  });
+}
+const LOG_LEVEL$1 = 1;
+let spector = null;
+let initialized = false;
+const DEFAULT_SPECTOR_PROPS = {
+  debugSpectorJS: log.get("debug-spectorjs"),
+  // https://github.com/BabylonJS/Spector.js#basic-usage
+  // https://forum.babylonjs.com/t/spectorcdn-is-temporarily-off/48241
+  // spectorUrl: 'https://spectorcdn.babylonjs.com/spector.bundle.js';
+  debugSpectorJSUrl: "https://cdn.jsdelivr.net/npm/spectorjs@0.9.30/dist/spector.bundle.js",
+  gl: void 0
+};
+async function loadSpectorJS(props) {
+  if (!globalThis.SPECTOR) {
+    try {
+      await loadScript(props.debugSpectorJSUrl || DEFAULT_SPECTOR_PROPS.debugSpectorJSUrl);
+    } catch (error) {
+      log.warn(String(error));
+    }
+  }
+}
+function initializeSpectorJS(props) {
+  var _a3;
+  props = { ...DEFAULT_SPECTOR_PROPS, ...props };
+  if (!props.debugSpectorJS) {
+    return null;
+  }
+  if (!spector && globalThis.SPECTOR && !((_a3 = globalThis.luma) == null ? void 0 : _a3.spector)) {
+    log.probe(LOG_LEVEL$1, "SPECTOR found and initialized. Start with `luma.spector.displayUI()`")();
+    const { Spector: SpectorJS } = globalThis.SPECTOR;
+    spector = new SpectorJS();
+    if (globalThis.luma) {
+      globalThis.luma.spector = spector;
+    }
+  }
+  if (!spector) {
+    return null;
+  }
+  if (!initialized) {
+    initialized = true;
+    spector.spyCanvases();
+    spector == null ? void 0 : spector.onCaptureStarted.add((capture) => log.info("Spector capture started:", capture)());
+    spector == null ? void 0 : spector.onCapture.add((capture) => {
+      log.info("Spector capture complete:", capture)();
+      spector == null ? void 0 : spector.getResultUI();
+      spector == null ? void 0 : spector.resultView.display();
+      spector == null ? void 0 : spector.resultView.addCapture(capture);
+    });
+  }
+  if (props.gl) {
+    const gl2 = props.gl;
+    const device = gl2.device;
+    spector == null ? void 0 : spector.startCapture(props.gl, 500);
+    gl2.device = device;
+    new Promise((resolve) => setTimeout(resolve, 2e3)).then((_2) => {
+      log.info("Spector capture stopped after 2 seconds")();
+      spector == null ? void 0 : spector.stopCapture();
+    });
+  }
+  return spector;
+}
+const WEBGL_DEBUG_CDN_URL = "https://unpkg.com/webgl-debug@2.0.1/index.js";
+function getWebGLContextData(gl2) {
+  gl2.luma = gl2.luma || {};
+  return gl2.luma;
+}
+async function loadWebGLDeveloperTools() {
+  if (isBrowser$1() && !globalThis.WebGLDebugUtils) {
+    globalThis.global = globalThis.global || globalThis;
+    globalThis.global.module = {};
+    await loadScript(WEBGL_DEBUG_CDN_URL);
+  }
+}
+function makeDebugContext(gl2, props = {}) {
+  return props.debugWebGL || props.traceWebGL ? getDebugContext(gl2, props) : getRealContext(gl2);
+}
+function getRealContext(gl2) {
+  const data = getWebGLContextData(gl2);
+  return data.realContext ? data.realContext : gl2;
+}
+function getDebugContext(gl2, props) {
+  if (!globalThis.WebGLDebugUtils) {
+    log.warn("webgl-debug not loaded")();
+    return gl2;
+  }
+  const data = getWebGLContextData(gl2);
+  if (data.debugContext) {
+    return data.debugContext;
+  }
+  globalThis.WebGLDebugUtils.init({ ...GLEnum, ...gl2 });
+  const glDebug = globalThis.WebGLDebugUtils.makeDebugContext(gl2, onGLError.bind(null, props), onValidateGLFunc.bind(null, props));
+  for (const key in GLEnum) {
+    if (!(key in glDebug) && typeof GLEnum[key] === "number") {
+      glDebug[key] = GLEnum[key];
+    }
+  }
+  class WebGLDebugContext {
+  }
+  Object.setPrototypeOf(glDebug, Object.getPrototypeOf(gl2));
+  Object.setPrototypeOf(WebGLDebugContext, glDebug);
+  const debugContext = Object.create(WebGLDebugContext);
+  data.realContext = gl2;
+  data.debugContext = debugContext;
+  debugContext.debug = true;
+  return debugContext;
+}
+function getFunctionString(functionName, functionArgs) {
+  functionArgs = Array.from(functionArgs).map((arg) => arg === void 0 ? "undefined" : arg);
+  let args = globalThis.WebGLDebugUtils.glFunctionArgsToString(functionName, functionArgs);
+  args = `${args.slice(0, 100)}${args.length > 100 ? "..." : ""}`;
+  return `gl.${functionName}(${args})`;
+}
+function onGLError(props, err, functionName, args) {
+  args = Array.from(args).map((arg) => arg === void 0 ? "undefined" : arg);
+  const errorMessage = globalThis.WebGLDebugUtils.glEnumToString(err);
+  const functionArgs = globalThis.WebGLDebugUtils.glFunctionArgsToString(functionName, args);
+  const message2 = `${errorMessage} in gl.${functionName}(${functionArgs})`;
+  log.error(message2)();
+  debugger;
+}
+function onValidateGLFunc(props, functionName, functionArgs) {
+  let functionString = "";
+  if (log.level >= 1) {
+    functionString = getFunctionString(functionName, functionArgs);
+    if (props.traceWebGL) {
+      log.log(1, functionString)();
+    }
+  }
+  for (const arg of functionArgs) {
+    if (arg === void 0) {
+      functionString = functionString || getFunctionString(functionName, functionArgs);
+      debugger;
+    }
+  }
+}
+const LOG_LEVEL = 1;
+class WebGLAdapter extends Adapter {
+  constructor() {
+    super();
+    /** type of device's created by this adapter */
+    __publicField(this, "type", "webgl");
+    Device.defaultProps = { ...Device.defaultProps, ...DEFAULT_SPECTOR_PROPS };
+  }
+  /** Force any created WebGL contexts to be WebGL2 contexts, polyfilled with WebGL1 extensions */
+  enforceWebGL2(enable2) {
+    enforceWebGL2(enable2);
+  }
+  /** Check if WebGL 2 is available */
+  isSupported() {
+    return typeof WebGL2RenderingContext !== "undefined";
+  }
+  isDeviceHandle(handle) {
+    if (typeof WebGL2RenderingContext !== "undefined" && handle instanceof WebGL2RenderingContext) {
+      return true;
+    }
+    if (typeof WebGLRenderingContext !== "undefined" && handle instanceof WebGLRenderingContext) {
+      log.warn("WebGL1 is not supported", handle)();
+    }
+    return false;
+  }
+  /**
+   * Get a device instance from a GL context
+   * Creates a WebGLCanvasContext against the contexts canvas
+   * @note autoResize will be disabled, assuming that whoever created the external context will be handling resizes.
+   * @param gl
+   * @returns
+   */
+  async attach(gl2, props = {}) {
+    const { WebGLDevice: WebGLDevice2 } = await __vitePreload(async () => {
+      const { WebGLDevice: WebGLDevice3 } = await Promise.resolve().then(() => webglDevice);
+      return { WebGLDevice: WebGLDevice3 };
+    }, true ? void 0 : void 0, import.meta.url);
+    if (gl2 instanceof WebGLDevice2) {
+      return gl2;
+    }
+    if ((gl2 == null ? void 0 : gl2.device) instanceof WebGLDevice2) {
+      return gl2.device;
+    }
+    if (!isWebGL(gl2)) {
+      throw new Error("Invalid WebGL2RenderingContext");
+    }
+    const createCanvasContext = props.createCanvasContext === true ? {} : props.createCanvasContext;
+    return new WebGLDevice2({
+      ...props,
+      _handle: gl2,
+      createCanvasContext: { canvas: gl2.canvas, autoResize: false, ...createCanvasContext }
+    });
+  }
+  async create(props = {}) {
+    const { WebGLDevice: WebGLDevice2 } = await __vitePreload(async () => {
+      const { WebGLDevice: WebGLDevice3 } = await Promise.resolve().then(() => webglDevice);
+      return { WebGLDevice: WebGLDevice3 };
+    }, true ? void 0 : void 0, import.meta.url);
+    log.groupCollapsed(LOG_LEVEL, "WebGLDevice created")();
+    try {
+      const promises = [];
+      if (props.debugWebGL || props.debug) {
+        promises.push(loadWebGLDeveloperTools());
+      }
+      if (props.debugSpectorJS) {
+        promises.push(loadSpectorJS(props));
+      }
+      const results = await Promise.allSettled(promises);
+      for (const result of results) {
+        if (result.status === "rejected") {
+          log.error(`Failed to initialize debug libraries ${result.reason}`)();
+        }
+      }
+      const device = new WebGLDevice2(props);
+      const message2 = `${device._reused ? "Reusing" : "Created"} device with WebGL2 ${device.props.debug ? "debug " : ""}context: ${device.info.vendor}, ${device.info.renderer} for canvas: ${device.canvasContext.id}`;
+      log.probe(LOG_LEVEL, message2)();
+      log.table(LOG_LEVEL, device.info)();
+      return device;
+    } finally {
+      log.groupEnd(LOG_LEVEL)();
+    }
+  }
+}
+function isWebGL(gl2) {
+  if (typeof WebGL2RenderingContext !== "undefined" && gl2 instanceof WebGL2RenderingContext) {
+    return true;
+  }
+  return Boolean(gl2 && Number.isFinite(gl2._version));
+}
+const webgl2Adapter = new WebGLAdapter();
+const GL_PARAMETER_DEFAULTS = {
+  [3042]: false,
+  [32773]: new Float32Array([0, 0, 0, 0]),
+  [32777]: 32774,
+  [34877]: 32774,
+  [32969]: 1,
+  [32968]: 0,
+  [32971]: 1,
+  [32970]: 0,
+  [3106]: new Float32Array([0, 0, 0, 0]),
+  // TBD
+  [3107]: [true, true, true, true],
+  [2884]: false,
+  [2885]: 1029,
+  [2929]: false,
+  [2931]: 1,
+  [2932]: 513,
+  [2928]: new Float32Array([0, 1]),
+  // TBD
+  [2930]: true,
+  [3024]: true,
+  [35725]: null,
+  // FRAMEBUFFER_BINDING and DRAW_FRAMEBUFFER_BINDING(WebGL2) refer same state.
+  [36006]: null,
+  [36007]: null,
+  [34229]: null,
+  [34964]: null,
+  [2886]: 2305,
+  [33170]: 4352,
+  [2849]: 1,
+  [32823]: false,
+  [32824]: 0,
+  [10752]: 0,
+  [32926]: false,
+  [32928]: false,
+  [32938]: 1,
+  [32939]: false,
+  [3089]: false,
+  // Note: Dynamic value. If scissor test enabled we expect users to set correct scissor box
+  [3088]: new Int32Array([0, 0, 1024, 1024]),
+  [2960]: false,
+  [2961]: 0,
+  [2968]: 4294967295,
+  [36005]: 4294967295,
+  [2962]: 519,
+  [2967]: 0,
+  [2963]: 4294967295,
+  [34816]: 519,
+  [36003]: 0,
+  [36004]: 4294967295,
+  [2964]: 7680,
+  [2965]: 7680,
+  [2966]: 7680,
+  [34817]: 7680,
+  [34818]: 7680,
+  [34819]: 7680,
+  // Dynamic value: We use [0, 0, 1024, 1024] as default, but usually this is updated in each frame.
+  [2978]: [0, 0, 1024, 1024],
+  [36389]: null,
+  [36662]: null,
+  [36663]: null,
+  [35053]: null,
+  [35055]: null,
+  [35723]: 4352,
+  [36010]: null,
+  [35977]: false,
+  [3333]: 4,
+  [3317]: 4,
+  [37440]: false,
+  [37441]: false,
+  [37443]: 37444,
+  [3330]: 0,
+  [3332]: 0,
+  [3331]: 0,
+  [3314]: 0,
+  [32878]: 0,
+  [3316]: 0,
+  [3315]: 0,
+  [32877]: 0
+};
+const enable = (gl2, value, key) => value ? gl2.enable(key) : gl2.disable(key);
+const hint = (gl2, value, key) => gl2.hint(key, value);
+const pixelStorei = (gl2, value, key) => gl2.pixelStorei(key, value);
+const bindFramebuffer = (gl2, value, key) => {
+  const target = key === 36006 ? 36009 : 36008;
+  return gl2.bindFramebuffer(target, value);
+};
+const bindBuffer = (gl2, value, key) => {
+  const bindingMap = {
+    [34964]: 34962,
+    [36662]: 36662,
+    [36663]: 36663,
+    [35053]: 35051,
+    [35055]: 35052
+  };
+  const glTarget = bindingMap[key];
+  gl2.bindBuffer(glTarget, value);
+};
+function isArray$2(array) {
+  return Array.isArray(array) || ArrayBuffer.isView(array) && !(array instanceof DataView);
+}
+const GL_PARAMETER_SETTERS = {
+  [3042]: enable,
+  [32773]: (gl2, value) => gl2.blendColor(...value),
+  [32777]: "blendEquation",
+  [34877]: "blendEquation",
+  [32969]: "blendFunc",
+  [32968]: "blendFunc",
+  [32971]: "blendFunc",
+  [32970]: "blendFunc",
+  [3106]: (gl2, value) => gl2.clearColor(...value),
+  [3107]: (gl2, value) => gl2.colorMask(...value),
+  [2884]: enable,
+  [2885]: (gl2, value) => gl2.cullFace(value),
+  [2929]: enable,
+  [2931]: (gl2, value) => gl2.clearDepth(value),
+  [2932]: (gl2, value) => gl2.depthFunc(value),
+  [2928]: (gl2, value) => gl2.depthRange(...value),
+  [2930]: (gl2, value) => gl2.depthMask(value),
+  [3024]: enable,
+  [35723]: hint,
+  [35725]: (gl2, value) => gl2.useProgram(value),
+  [36007]: (gl2, value) => gl2.bindRenderbuffer(36161, value),
+  [36389]: (gl2, value) => {
+    var _a3;
+    return (_a3 = gl2.bindTransformFeedback) == null ? void 0 : _a3.call(gl2, 36386, value);
+  },
+  [34229]: (gl2, value) => gl2.bindVertexArray(value),
+  // NOTE: FRAMEBUFFER_BINDING and DRAW_FRAMEBUFFER_BINDING(WebGL2) refer same state.
+  [36006]: bindFramebuffer,
+  [36010]: bindFramebuffer,
+  // Buffers
+  [34964]: bindBuffer,
+  [36662]: bindBuffer,
+  [36663]: bindBuffer,
+  [35053]: bindBuffer,
+  [35055]: bindBuffer,
+  [2886]: (gl2, value) => gl2.frontFace(value),
+  [33170]: hint,
+  [2849]: (gl2, value) => gl2.lineWidth(value),
+  [32823]: enable,
+  [32824]: "polygonOffset",
+  [10752]: "polygonOffset",
+  [35977]: enable,
+  [32926]: enable,
+  [32928]: enable,
+  [32938]: "sampleCoverage",
+  [32939]: "sampleCoverage",
+  [3089]: enable,
+  [3088]: (gl2, value) => gl2.scissor(...value),
+  [2960]: enable,
+  [2961]: (gl2, value) => gl2.clearStencil(value),
+  [2968]: (gl2, value) => gl2.stencilMaskSeparate(1028, value),
+  [36005]: (gl2, value) => gl2.stencilMaskSeparate(1029, value),
+  [2962]: "stencilFuncFront",
+  [2967]: "stencilFuncFront",
+  [2963]: "stencilFuncFront",
+  [34816]: "stencilFuncBack",
+  [36003]: "stencilFuncBack",
+  [36004]: "stencilFuncBack",
+  [2964]: "stencilOpFront",
+  [2965]: "stencilOpFront",
+  [2966]: "stencilOpFront",
+  [34817]: "stencilOpBack",
+  [34818]: "stencilOpBack",
+  [34819]: "stencilOpBack",
+  [2978]: (gl2, value) => gl2.viewport(...value),
+  // WEBGL2 EXTENSIONS
+  // EXT_depth_clamp https://registry.khronos.org/webgl/extensions/EXT_depth_clamp/
+  [34383]: enable,
+  // WEBGL_provoking_vertex https://registry.khronos.org/webgl/extensions/WEBGL_provoking_vertex/
+  // [GL.PROVOKING_VERTEX_WEBL]: TODO - extension function needed
+  // WEBGL_polygon_mode https://registry.khronos.org/webgl/extensions/WEBGL_polygon_mode/
+  // POLYGON_MODE_WEBGL  TODO - extension function needed
+  [10754]: enable,
+  // WEBGL_clip_cull_distance https://registry.khronos.org/webgl/extensions/WEBGL_clip_cull_distance/
+  [12288]: enable,
+  [12289]: enable,
+  [12290]: enable,
+  [12291]: enable,
+  [12292]: enable,
+  [12293]: enable,
+  [12294]: enable,
+  [12295]: enable,
+  // PIXEL PACK/UNPACK MODES
+  [3333]: pixelStorei,
+  [3317]: pixelStorei,
+  [37440]: pixelStorei,
+  [37441]: pixelStorei,
+  [37443]: pixelStorei,
+  [3330]: pixelStorei,
+  [3332]: pixelStorei,
+  [3331]: pixelStorei,
+  [3314]: pixelStorei,
+  [32878]: pixelStorei,
+  [3316]: pixelStorei,
+  [3315]: pixelStorei,
+  [32877]: pixelStorei,
+  // Function-style setters
+  framebuffer: (gl2, framebuffer) => {
+    const handle = framebuffer && "handle" in framebuffer ? framebuffer.handle : framebuffer;
+    return gl2.bindFramebuffer(36160, handle);
+  },
+  blend: (gl2, value) => value ? gl2.enable(3042) : gl2.disable(3042),
+  blendColor: (gl2, value) => gl2.blendColor(...value),
+  blendEquation: (gl2, args) => {
+    const separateModes = typeof args === "number" ? [args, args] : args;
+    gl2.blendEquationSeparate(...separateModes);
+  },
+  blendFunc: (gl2, args) => {
+    const separateFuncs = (args == null ? void 0 : args.length) === 2 ? [...args, ...args] : args;
+    gl2.blendFuncSeparate(...separateFuncs);
+  },
+  clearColor: (gl2, value) => gl2.clearColor(...value),
+  clearDepth: (gl2, value) => gl2.clearDepth(value),
+  clearStencil: (gl2, value) => gl2.clearStencil(value),
+  colorMask: (gl2, value) => gl2.colorMask(...value),
+  cull: (gl2, value) => value ? gl2.enable(2884) : gl2.disable(2884),
+  cullFace: (gl2, value) => gl2.cullFace(value),
+  depthTest: (gl2, value) => value ? gl2.enable(2929) : gl2.disable(2929),
+  depthFunc: (gl2, value) => gl2.depthFunc(value),
+  depthMask: (gl2, value) => gl2.depthMask(value),
+  depthRange: (gl2, value) => gl2.depthRange(...value),
+  dither: (gl2, value) => value ? gl2.enable(3024) : gl2.disable(3024),
+  derivativeHint: (gl2, value) => {
+    gl2.hint(35723, value);
+  },
+  frontFace: (gl2, value) => gl2.frontFace(value),
+  mipmapHint: (gl2, value) => gl2.hint(33170, value),
+  lineWidth: (gl2, value) => gl2.lineWidth(value),
+  polygonOffsetFill: (gl2, value) => value ? gl2.enable(32823) : gl2.disable(32823),
+  polygonOffset: (gl2, value) => gl2.polygonOffset(...value),
+  sampleCoverage: (gl2, value) => gl2.sampleCoverage(value[0], value[1] || false),
+  scissorTest: (gl2, value) => value ? gl2.enable(3089) : gl2.disable(3089),
+  scissor: (gl2, value) => gl2.scissor(...value),
+  stencilTest: (gl2, value) => value ? gl2.enable(2960) : gl2.disable(2960),
+  stencilMask: (gl2, value) => {
+    value = isArray$2(value) ? value : [value, value];
+    const [mask, backMask] = value;
+    gl2.stencilMaskSeparate(1028, mask);
+    gl2.stencilMaskSeparate(1029, backMask);
+  },
+  stencilFunc: (gl2, args) => {
+    args = isArray$2(args) && args.length === 3 ? [...args, ...args] : args;
+    const [func, ref, mask, backFunc, backRef, backMask] = args;
+    gl2.stencilFuncSeparate(1028, func, ref, mask);
+    gl2.stencilFuncSeparate(1029, backFunc, backRef, backMask);
+  },
+  stencilOp: (gl2, args) => {
+    args = isArray$2(args) && args.length === 3 ? [...args, ...args] : args;
+    const [sfail, dpfail, dppass, backSfail, backDpfail, backDppass] = args;
+    gl2.stencilOpSeparate(1028, sfail, dpfail, dppass);
+    gl2.stencilOpSeparate(1029, backSfail, backDpfail, backDppass);
+  },
+  viewport: (gl2, value) => gl2.viewport(...value)
+};
+function getValue(glEnum, values, cache) {
+  return values[glEnum] !== void 0 ? values[glEnum] : cache[glEnum];
+}
+const GL_COMPOSITE_PARAMETER_SETTERS = {
+  blendEquation: (gl2, values, cache) => gl2.blendEquationSeparate(getValue(32777, values, cache), getValue(34877, values, cache)),
+  blendFunc: (gl2, values, cache) => gl2.blendFuncSeparate(getValue(32969, values, cache), getValue(32968, values, cache), getValue(32971, values, cache), getValue(32970, values, cache)),
+  polygonOffset: (gl2, values, cache) => gl2.polygonOffset(getValue(32824, values, cache), getValue(10752, values, cache)),
+  sampleCoverage: (gl2, values, cache) => gl2.sampleCoverage(getValue(32938, values, cache), getValue(32939, values, cache)),
+  stencilFuncFront: (gl2, values, cache) => gl2.stencilFuncSeparate(1028, getValue(2962, values, cache), getValue(2967, values, cache), getValue(2963, values, cache)),
+  stencilFuncBack: (gl2, values, cache) => gl2.stencilFuncSeparate(1029, getValue(34816, values, cache), getValue(36003, values, cache), getValue(36004, values, cache)),
+  stencilOpFront: (gl2, values, cache) => gl2.stencilOpSeparate(1028, getValue(2964, values, cache), getValue(2965, values, cache), getValue(2966, values, cache)),
+  stencilOpBack: (gl2, values, cache) => gl2.stencilOpSeparate(1029, getValue(34817, values, cache), getValue(34818, values, cache), getValue(34819, values, cache))
+};
+const GL_HOOKED_SETTERS = {
+  // GENERIC SETTERS
+  enable: (update, capability) => update({
+    [capability]: true
+  }),
+  disable: (update, capability) => update({
+    [capability]: false
+  }),
+  pixelStorei: (update, pname, value) => update({
+    [pname]: value
+  }),
+  hint: (update, pname, value) => update({
+    [pname]: value
+  }),
+  // SPECIFIC SETTERS
+  useProgram: (update, value) => update({
+    [35725]: value
+  }),
+  bindRenderbuffer: (update, target, value) => update({
+    [36007]: value
+  }),
+  bindTransformFeedback: (update, target, value) => update({
+    [36389]: value
+  }),
+  bindVertexArray: (update, value) => update({
+    [34229]: value
+  }),
+  bindFramebuffer: (update, target, framebuffer) => {
+    switch (target) {
+      case 36160:
+        return update({
+          [36006]: framebuffer,
+          [36010]: framebuffer
+        });
+      case 36009:
+        return update({ [36006]: framebuffer });
+      case 36008:
+        return update({ [36010]: framebuffer });
+      default:
+        return null;
+    }
+  },
+  bindBuffer: (update, target, buffer) => {
+    const pname = {
+      [34962]: [34964],
+      [36662]: [36662],
+      [36663]: [36663],
+      [35051]: [35053],
+      [35052]: [35055]
+    }[target];
+    if (pname) {
+      return update({ [pname]: buffer });
+    }
+    return { valueChanged: true };
+  },
+  blendColor: (update, r2, g2, b2, a2) => update({
+    [32773]: new Float32Array([r2, g2, b2, a2])
+  }),
+  blendEquation: (update, mode) => update({
+    [32777]: mode,
+    [34877]: mode
+  }),
+  blendEquationSeparate: (update, modeRGB, modeAlpha) => update({
+    [32777]: modeRGB,
+    [34877]: modeAlpha
+  }),
+  blendFunc: (update, src, dst) => update({
+    [32969]: src,
+    [32968]: dst,
+    [32971]: src,
+    [32970]: dst
+  }),
+  blendFuncSeparate: (update, srcRGB, dstRGB, srcAlpha, dstAlpha) => update({
+    [32969]: srcRGB,
+    [32968]: dstRGB,
+    [32971]: srcAlpha,
+    [32970]: dstAlpha
+  }),
+  clearColor: (update, r2, g2, b2, a2) => update({
+    [3106]: new Float32Array([r2, g2, b2, a2])
+  }),
+  clearDepth: (update, depth) => update({
+    [2931]: depth
+  }),
+  clearStencil: (update, s2) => update({
+    [2961]: s2
+  }),
+  colorMask: (update, r2, g2, b2, a2) => update({
+    [3107]: [r2, g2, b2, a2]
+  }),
+  cullFace: (update, mode) => update({
+    [2885]: mode
+  }),
+  depthFunc: (update, func) => update({
+    [2932]: func
+  }),
+  depthRange: (update, zNear, zFar) => update({
+    [2928]: new Float32Array([zNear, zFar])
+  }),
+  depthMask: (update, mask) => update({
+    [2930]: mask
+  }),
+  frontFace: (update, face) => update({
+    [2886]: face
+  }),
+  lineWidth: (update, width) => update({
+    [2849]: width
+  }),
+  polygonOffset: (update, factor, units) => update({
+    [32824]: factor,
+    [10752]: units
+  }),
+  sampleCoverage: (update, value, invert2) => update({
+    [32938]: value,
+    [32939]: invert2
+  }),
+  scissor: (update, x2, y2, width, height) => update({
+    [3088]: new Int32Array([x2, y2, width, height])
+  }),
+  stencilMask: (update, mask) => update({
+    [2968]: mask,
+    [36005]: mask
+  }),
+  stencilMaskSeparate: (update, face, mask) => update({
+    [face === 1028 ? 2968 : 36005]: mask
+  }),
+  stencilFunc: (update, func, ref, mask) => update({
+    [2962]: func,
+    [2967]: ref,
+    [2963]: mask,
+    [34816]: func,
+    [36003]: ref,
+    [36004]: mask
+  }),
+  stencilFuncSeparate: (update, face, func, ref, mask) => update({
+    [face === 1028 ? 2962 : 34816]: func,
+    [face === 1028 ? 2967 : 36003]: ref,
+    [face === 1028 ? 2963 : 36004]: mask
+  }),
+  stencilOp: (update, fail, zfail, zpass) => update({
+    [2964]: fail,
+    [2965]: zfail,
+    [2966]: zpass,
+    [34817]: fail,
+    [34818]: zfail,
+    [34819]: zpass
+  }),
+  stencilOpSeparate: (update, face, fail, zfail, zpass) => update({
+    [face === 1028 ? 2964 : 34817]: fail,
+    [face === 1028 ? 2965 : 34818]: zfail,
+    [face === 1028 ? 2966 : 34819]: zpass
+  }),
+  viewport: (update, x2, y2, width, height) => update({
+    [2978]: [x2, y2, width, height]
+  })
+};
+const isEnabled = (gl2, key) => gl2.isEnabled(key);
+const GL_PARAMETER_GETTERS = {
+  [3042]: isEnabled,
+  [2884]: isEnabled,
+  [2929]: isEnabled,
+  [3024]: isEnabled,
+  [32823]: isEnabled,
+  [32926]: isEnabled,
+  [32928]: isEnabled,
+  [3089]: isEnabled,
+  [2960]: isEnabled,
+  [35977]: isEnabled
+};
+const NON_CACHE_PARAMETERS = /* @__PURE__ */ new Set([
+  34016,
+  36388,
+  36387,
+  35983,
+  35368,
+  34965,
+  35739,
+  35738,
+  3074,
+  34853,
+  34854,
+  34855,
+  34856,
+  34857,
+  34858,
+  34859,
+  34860,
+  34861,
+  34862,
+  34863,
+  34864,
+  34865,
+  34866,
+  34867,
+  34868,
+  35097,
+  32873,
+  35869,
+  32874,
+  34068
+]);
+function setGLParameters(gl2, parameters) {
+  if (isObjectEmpty$2(parameters)) {
+    return;
+  }
+  const compositeSetters = {};
+  for (const key in parameters) {
+    const glConstant = Number(key);
+    const setter = GL_PARAMETER_SETTERS[key];
+    if (setter) {
+      if (typeof setter === "string") {
+        compositeSetters[setter] = true;
+      } else {
+        setter(gl2, parameters[key], glConstant);
+      }
+    }
+  }
+  const cache = gl2.state && gl2.state.cache;
+  if (cache) {
+    for (const key in compositeSetters) {
+      const compositeSetter = GL_COMPOSITE_PARAMETER_SETTERS[key];
+      compositeSetter(gl2, parameters, cache);
+    }
+  }
+}
+function getGLParameters(gl2, parameters = GL_PARAMETER_DEFAULTS) {
+  if (typeof parameters === "number") {
+    const key = parameters;
+    const getter = GL_PARAMETER_GETTERS[key];
+    return getter ? getter(gl2, key) : gl2.getParameter(key);
+  }
+  const parameterKeys = Array.isArray(parameters) ? parameters : Object.keys(parameters);
+  const state = {};
+  for (const key of parameterKeys) {
+    const getter = GL_PARAMETER_GETTERS[key];
+    state[key] = getter ? getter(gl2, Number(key)) : gl2.getParameter(Number(key));
+  }
+  return state;
+}
+function resetGLParameters(gl2) {
+  setGLParameters(gl2, GL_PARAMETER_DEFAULTS);
+}
+function isObjectEmpty$2(object) {
+  for (const key in object) {
+    return false;
+  }
+  return true;
+}
+function deepArrayEqual(x2, y2) {
+  if (x2 === y2) {
+    return true;
+  }
+  if (isArray$1(x2) && isArray$1(y2) && x2.length === y2.length) {
+    for (let i2 = 0; i2 < x2.length; ++i2) {
+      if (x2[i2] !== y2[i2]) {
+        return false;
+      }
+    }
+    return true;
+  }
+  return false;
+}
+function isArray$1(x2) {
+  return Array.isArray(x2) || ArrayBuffer.isView(x2);
+}
+class WebGLStateTracker {
+  constructor(gl2, props) {
+    __publicField(this, "gl");
+    __publicField(this, "program", null);
+    __publicField(this, "stateStack", []);
+    __publicField(this, "enable", true);
+    __publicField(this, "cache", null);
+    __publicField(this, "log");
+    __publicField(this, "initialized", false);
+    this.gl = gl2;
+    this.log = (props == null ? void 0 : props.log) || (() => {
+    });
+    this._updateCache = this._updateCache.bind(this);
+    Object.seal(this);
+  }
+  static get(gl2) {
+    return gl2.state;
+  }
+  push(values = {}) {
+    this.stateStack.push({});
+  }
+  pop() {
+    const oldValues = this.stateStack[this.stateStack.length - 1];
+    setGLParameters(this.gl, oldValues);
+    this.stateStack.pop();
+  }
+  /**
+   * Initialize WebGL state caching on a context
+   * can be called multiple times to enable/disable
+   *
+   * @note After calling this function, context state will be cached
+   * .push() and .pop() will be available for saving,
+   * temporarily modifying, and then restoring state.
+   */
+  trackState(gl2, options) {
+    this.cache = (options == null ? void 0 : options.copyState) ? getGLParameters(gl2) : Object.assign({}, GL_PARAMETER_DEFAULTS);
+    if (this.initialized) {
+      throw new Error("WebGLStateTracker");
+    }
+    this.initialized = true;
+    this.gl.state = this;
+    installProgramSpy(gl2);
+    for (const key in GL_HOOKED_SETTERS) {
+      const setter = GL_HOOKED_SETTERS[key];
+      installSetterSpy(gl2, key, setter);
+    }
+    installGetterOverride(gl2, "getParameter");
+    installGetterOverride(gl2, "isEnabled");
+  }
+  /**
+  // interceptor for context set functions - update our cache and our stack
+  // values (Object) - the key values for this setter
+   * @param values
+   * @returns
+   */
+  _updateCache(values) {
+    let valueChanged = false;
+    let oldValue;
+    const oldValues = this.stateStack.length > 0 ? this.stateStack[this.stateStack.length - 1] : null;
+    for (const key in values) {
+      const value = values[key];
+      const cached = this.cache[key];
+      if (!deepArrayEqual(value, cached)) {
+        valueChanged = true;
+        oldValue = cached;
+        if (oldValues && !(key in oldValues)) {
+          oldValues[key] = cached;
+        }
+        this.cache[key] = value;
+      }
+    }
+    return { valueChanged, oldValue };
+  }
+}
+function installGetterOverride(gl2, functionName) {
+  const originalGetterFunc = gl2[functionName].bind(gl2);
+  gl2[functionName] = function get(pname) {
+    if (pname === void 0 || NON_CACHE_PARAMETERS.has(pname)) {
+      return originalGetterFunc(pname);
+    }
+    const glState = WebGLStateTracker.get(gl2);
+    if (!(pname in glState.cache)) {
+      glState.cache[pname] = originalGetterFunc(pname);
+    }
+    return glState.enable ? (
+      // Call the getter the params so that it can e.g. serve from a cache
+      glState.cache[pname]
+    ) : (
+      // Optionally call the original function to do a "hard" query from the WebGL2RenderingContext
+      originalGetterFunc(pname)
+    );
+  };
+  Object.defineProperty(gl2[functionName], "name", {
+    value: `${functionName}-from-cache`,
+    configurable: false
+  });
+}
+function installSetterSpy(gl2, functionName, setter) {
+  if (!gl2[functionName]) {
+    return;
+  }
+  const originalSetterFunc = gl2[functionName].bind(gl2);
+  gl2[functionName] = function set(...params) {
+    const glState = WebGLStateTracker.get(gl2);
+    const { valueChanged, oldValue } = setter(glState._updateCache, ...params);
+    if (valueChanged) {
+      originalSetterFunc(...params);
+    }
+    return oldValue;
+  };
+  Object.defineProperty(gl2[functionName], "name", {
+    value: `${functionName}-to-cache`,
+    configurable: false
+  });
+}
+function installProgramSpy(gl2) {
+  const originalUseProgram = gl2.useProgram.bind(gl2);
+  gl2.useProgram = function useProgramLuma(handle) {
+    const glState = WebGLStateTracker.get(gl2);
+    if (glState.program !== handle) {
+      originalUseProgram(handle);
+      glState.program = handle;
+    }
+  };
+}
+function createBrowserContext(canvas2, props, webglContextAttributes) {
+  let errorMessage = "";
+  const webglProps = {
+    preserveDrawingBuffer: true,
+    // failIfMajorPerformanceCaveat: true,
+    ...webglContextAttributes
+  };
+  let gl2 = null;
+  gl2 || (gl2 = canvas2.getContext("webgl2", webglProps));
+  if (webglProps.failIfMajorPerformanceCaveat) {
+    errorMessage || (errorMessage = "Only software GPU is available. Set `failIfMajorPerformanceCaveat: false` to allow.");
+  }
+  if (!gl2 && !webglContextAttributes.failIfMajorPerformanceCaveat) {
+    webglProps.failIfMajorPerformanceCaveat = false;
+    gl2 = canvas2.getContext("webgl2", webglProps);
+    gl2.luma || (gl2.luma = {});
+    gl2.luma.softwareRenderer = true;
+  }
+  if (!gl2) {
+    gl2 = canvas2.getContext("webgl", {});
+    if (gl2) {
+      gl2 = null;
+      errorMessage || (errorMessage = "Your browser only supports WebGL1");
+    }
+  }
+  if (!gl2) {
+    errorMessage || (errorMessage = "Your browser does not support WebGL");
+    throw new Error(`Failed to create WebGL context: ${errorMessage}`);
+  }
+  const { onContextLost, onContextRestored } = props;
+  canvas2.addEventListener("webglcontextlost", (event) => onContextLost(event), false);
+  canvas2.addEventListener("webglcontextrestored", (event) => onContextRestored(event), false);
+  gl2.luma || (gl2.luma = {});
+  return gl2;
+}
+function getWebGLExtension(gl2, name2, extensions) {
+  if (extensions[name2] === void 0) {
+    extensions[name2] = gl2.getExtension(name2) || null;
+  }
+  return extensions[name2];
+}
+function getDeviceInfo(gl2, extensions) {
+  const vendorMasked = gl2.getParameter(7936);
+  const rendererMasked = gl2.getParameter(7937);
+  getWebGLExtension(gl2, "WEBGL_debug_renderer_info", extensions);
+  const ext = extensions.WEBGL_debug_renderer_info;
+  const vendorUnmasked = gl2.getParameter(ext ? ext.UNMASKED_VENDOR_WEBGL : 7936);
+  const rendererUnmasked = gl2.getParameter(ext ? ext.UNMASKED_RENDERER_WEBGL : 7937);
+  const vendor = vendorUnmasked || vendorMasked;
+  const renderer = rendererUnmasked || rendererMasked;
+  const version2 = gl2.getParameter(7938);
+  const gpu = identifyGPUVendor(vendor, renderer);
+  const gpuBackend = identifyGPUBackend(vendor, renderer);
+  const gpuType = identifyGPUType(vendor, renderer);
+  const shadingLanguage = "glsl";
+  const shadingLanguageVersion = 300;
+  return {
+    type: "webgl",
+    gpu,
+    gpuType,
+    gpuBackend,
+    vendor,
+    renderer,
+    version: version2,
+    shadingLanguage,
+    shadingLanguageVersion
+  };
+}
+function identifyGPUVendor(vendor, renderer) {
+  if (/NVIDIA/i.exec(vendor) || /NVIDIA/i.exec(renderer)) {
+    return "nvidia";
+  }
+  if (/INTEL/i.exec(vendor) || /INTEL/i.exec(renderer)) {
+    return "intel";
+  }
+  if (/Apple/i.exec(vendor) || /Apple/i.exec(renderer)) {
+    return "apple";
+  }
+  if (/AMD/i.exec(vendor) || /AMD/i.exec(renderer) || /ATI/i.exec(vendor) || /ATI/i.exec(renderer)) {
+    return "amd";
+  }
+  if (/SwiftShader/i.exec(vendor) || /SwiftShader/i.exec(renderer)) {
+    return "software";
+  }
+  return "unknown";
+}
+function identifyGPUBackend(vendor, renderer) {
+  if (/Metal/i.exec(vendor) || /Metal/i.exec(renderer)) {
+    return "metal";
+  }
+  if (/ANGLE/i.exec(vendor) || /ANGLE/i.exec(renderer)) {
+    return "opengl";
+  }
+  return "unknown";
+}
+function identifyGPUType(vendor, renderer) {
+  if (/SwiftShader/i.exec(vendor) || /SwiftShader/i.exec(renderer)) {
+    return "cpu";
+  }
+  const gpuVendor = identifyGPUVendor(vendor, renderer);
+  switch (gpuVendor) {
+    case "intel":
+      return "integrated";
+    case "software":
+      return "cpu";
+    case "unknown":
+      return "unknown";
+    default:
+      return "discrete";
+  }
+}
+function getGLFromVertexType(dataType) {
+  switch (dataType) {
+    case "uint8":
+      return 5121;
+    case "sint8":
+      return 5120;
+    case "unorm8":
+      return 5121;
+    case "snorm8":
+      return 5120;
+    case "uint16":
+      return 5123;
+    case "sint16":
+      return 5122;
+    case "unorm16":
+      return 5123;
+    case "snorm16":
+      return 5122;
+    case "uint32":
+      return 5125;
+    case "sint32":
+      return 5124;
+    case "float16":
+      return 5131;
+    case "float32":
+      return 5126;
+  }
+  throw new Error(String(dataType));
+}
+const X_S3TC = "WEBGL_compressed_texture_s3tc";
+const X_S3TC_SRGB = "WEBGL_compressed_texture_s3tc_srgb";
+const X_RGTC = "EXT_texture_compression_rgtc";
+const X_BPTC = "EXT_texture_compression_bptc";
+const X_ETC2 = "WEBGL_compressed_texture_etc";
+const X_ASTC = "WEBGL_compressed_texture_astc";
+const X_ETC1 = "WEBGL_compressed_texture_etc1";
+const X_PVRTC = "WEBGL_compressed_texture_pvrtc";
+const X_ATC = "WEBGL_compressed_texture_atc";
+const EXT_texture_norm16 = "EXT_texture_norm16";
+const EXT_render_snorm = "EXT_render_snorm";
+const EXT_color_buffer_float = "EXT_color_buffer_float";
+const TEXTURE_FEATURES = {
+  "float32-renderable-webgl": ["EXT_color_buffer_float"],
+  "float16-renderable-webgl": ["EXT_color_buffer_half_float"],
+  "rgb9e5ufloat-renderable-webgl": ["WEBGL_render_shared_exponent"],
+  "snorm8-renderable-webgl": [EXT_render_snorm],
+  "norm16-renderable-webgl": [EXT_texture_norm16],
+  "snorm16-renderable-webgl": [EXT_texture_norm16, EXT_render_snorm],
+  "float32-filterable": ["OES_texture_float_linear"],
+  "float16-filterable-webgl": ["OES_texture_half_float_linear"],
+  "texture-filterable-anisotropic-webgl": ["EXT_texture_filter_anisotropic"],
+  "texture-blend-float-webgl": ["EXT_float_blend"],
+  "texture-compression-bc": [X_S3TC, X_S3TC_SRGB, X_RGTC, X_BPTC],
+  // 'texture-compression-bc3-srgb-webgl': [X_S3TC_SRGB],
+  // 'texture-compression-bc3-webgl': [X_S3TC],
+  "texture-compression-bc5-webgl": [X_RGTC],
+  "texture-compression-bc7-webgl": [X_BPTC],
+  "texture-compression-etc2": [X_ETC2],
+  "texture-compression-astc": [X_ASTC],
+  "texture-compression-etc1-webgl": [X_ETC1],
+  "texture-compression-pvrtc-webgl": [X_PVRTC],
+  "texture-compression-atc-webgl": [X_ATC]
+};
+function isTextureFeature(feature) {
+  return feature in TEXTURE_FEATURES;
+}
+function checkTextureFeature(gl2, feature, extensions) {
+  const textureExtensions = TEXTURE_FEATURES[feature] || [];
+  return textureExtensions.every((extension) => getWebGLExtension(gl2, extension, extensions));
+}
+const WEBGL_TEXTURE_FORMATS = {
+  // 8-bit formats
+  "r8unorm": { gl: 33321, rb: true },
+  "r8snorm": { gl: 36756 },
+  "r8uint": { gl: 33330, rb: true },
+  "r8sint": { gl: 33329, rb: true },
+  // 16-bit formats
+  "rg8unorm": { gl: 33323, rb: true },
+  "rg8snorm": { gl: 36757 },
+  "rg8uint": { gl: 33336, rb: true },
+  "rg8sint": { gl: 33335, rb: true },
+  "r16uint": { gl: 33332, rb: true },
+  "r16sint": { gl: 33331, rb: true },
+  "r16float": { gl: 33325, rb: true },
+  "r16unorm": { gl: 33322, rb: true },
+  "r16snorm": { gl: 36760 },
+  // Packed 16-bit formats
+  "rgba4unorm-webgl": { gl: 32854, rb: true },
+  "rgb565unorm-webgl": { gl: 36194, rb: true },
+  "rgb5a1unorm-webgl": { gl: 32855, rb: true },
+  // 24-bit formats
+  "rgb8unorm-webgl": { gl: 32849 },
+  "rgb8snorm-webgl": { gl: 36758 },
+  // 32-bit formats
+  "rgba8unorm": { gl: 32856 },
+  "rgba8unorm-srgb": { gl: 35907 },
+  "rgba8snorm": { gl: 36759 },
+  "rgba8uint": { gl: 36220 },
+  "rgba8sint": { gl: 36238 },
+  // reverse colors, webgpu only
+  "bgra8unorm": {},
+  "bgra8unorm-srgb": {},
+  "rg16uint": { gl: 33338 },
+  "rg16sint": { gl: 33337 },
+  "rg16float": { gl: 33327, rb: true },
+  "rg16unorm": { gl: 33324 },
+  "rg16snorm": { gl: 36761 },
+  "r32uint": { gl: 33334, rb: true },
+  "r32sint": { gl: 33333, rb: true },
+  "r32float": { gl: 33326 },
+  // Packed 32-bit formats
+  "rgb9e5ufloat": { gl: 35901 },
+  // , filter: true},
+  "rg11b10ufloat": { gl: 35898, rb: true },
+  "rgb10a2unorm": { gl: 32857, rb: true },
+  "rgb10a2uint": { gl: 36975, rb: true },
+  // 48-bit formats
+  "rgb16unorm-webgl": { gl: 32852 },
+  // rgb not renderable
+  "rgb16snorm-webgl": { gl: 36762 },
+  // rgb not renderable
+  // 64-bit formats
+  "rg32uint": { gl: 33340, rb: true },
+  "rg32sint": { gl: 33339, rb: true },
+  "rg32float": { gl: 33328, rb: true },
+  "rgba16uint": { gl: 36214, rb: true },
+  "rgba16sint": { gl: 36232, rb: true },
+  "rgba16float": { gl: 34842 },
+  "rgba16unorm": { gl: 32859, rb: true },
+  "rgba16snorm": { gl: 36763 },
+  // 96-bit formats (deprecated!)
+  "rgb32float-webgl": { gl: 34837, x: EXT_color_buffer_float, dataFormat: 6407, types: [5126] },
+  // 128-bit formats
+  "rgba32uint": { gl: 36208, rb: true },
+  "rgba32sint": { gl: 36226, rb: true },
+  "rgba32float": { gl: 34836, rb: true },
+  // Depth and stencil formats
+  "stencil8": { gl: 36168, rb: true },
+  // 8 stencil bits
+  "depth16unorm": { gl: 33189, dataFormat: 6402, types: [5123], rb: true },
+  // 16 depth bits
+  "depth24plus": { gl: 33190, dataFormat: 6402, types: [5125] },
+  "depth32float": { gl: 36012, dataFormat: 6402, types: [5126], rb: true },
+  // The depth component of the "depth24plus" and "depth24plus-stencil8" formats may be implemented as either a 24-bit depth value or a "depth32float" value.
+  "depth24plus-stencil8": { gl: 35056, rb: true, depthTexture: true, dataFormat: 34041, types: [34042] },
+  // "depth32float-stencil8" feature - TODO below is render buffer only?
+  "depth32float-stencil8": { gl: 36013, dataFormat: 34041, types: [36269], rb: true },
+  // BC compressed formats: check device.features.has("texture-compression-bc");
+  "bc1-rgb-unorm-webgl": { gl: 33776, x: X_S3TC },
+  "bc1-rgb-unorm-srgb-webgl": { gl: 35916, x: X_S3TC_SRGB },
+  "bc1-rgba-unorm": { gl: 33777, x: X_S3TC },
+  "bc1-rgba-unorm-srgb": { gl: 35916, x: X_S3TC_SRGB },
+  "bc2-rgba-unorm": { gl: 33778, x: X_S3TC },
+  "bc2-rgba-unorm-srgb": { gl: 35918, x: X_S3TC_SRGB },
+  "bc3-rgba-unorm": { gl: 33779, x: X_S3TC },
+  "bc3-rgba-unorm-srgb": { gl: 35919, x: X_S3TC_SRGB },
+  "bc4-r-unorm": { gl: 36283, x: X_RGTC },
+  "bc4-r-snorm": { gl: 36284, x: X_RGTC },
+  "bc5-rg-unorm": { gl: 36285, x: X_RGTC },
+  "bc5-rg-snorm": { gl: 36286, x: X_RGTC },
+  "bc6h-rgb-ufloat": { gl: 36495, x: X_BPTC },
+  "bc6h-rgb-float": { gl: 36494, x: X_BPTC },
+  "bc7-rgba-unorm": { gl: 36492, x: X_BPTC },
+  "bc7-rgba-unorm-srgb": { gl: 36493, x: X_BPTC },
+  // WEBGL_compressed_texture_etc: device.features.has("texture-compression-etc2")
+  // Note: Supposedly guaranteed availability compressed formats in WebGL2, but through CPU decompression
+  "etc2-rgb8unorm": { gl: 37492 },
+  "etc2-rgb8unorm-srgb": { gl: 37494 },
+  "etc2-rgb8a1unorm": { gl: 37496 },
+  "etc2-rgb8a1unorm-srgb": { gl: 37497 },
+  "etc2-rgba8unorm": { gl: 37493 },
+  "etc2-rgba8unorm-srgb": { gl: 37495 },
+  "eac-r11unorm": { gl: 37488 },
+  "eac-r11snorm": { gl: 37489 },
+  "eac-rg11unorm": { gl: 37490 },
+  "eac-rg11snorm": { gl: 37491 },
+  // X_ASTC compressed formats: device.features.has("texture-compression-astc")
+  "astc-4x4-unorm": { gl: 37808 },
+  "astc-4x4-unorm-srgb": { gl: 37840 },
+  "astc-5x4-unorm": { gl: 37809 },
+  "astc-5x4-unorm-srgb": { gl: 37841 },
+  "astc-5x5-unorm": { gl: 37810 },
+  "astc-5x5-unorm-srgb": { gl: 37842 },
+  "astc-6x5-unorm": { gl: 37811 },
+  "astc-6x5-unorm-srgb": { gl: 37843 },
+  "astc-6x6-unorm": { gl: 37812 },
+  "astc-6x6-unorm-srgb": { gl: 37844 },
+  "astc-8x5-unorm": { gl: 37813 },
+  "astc-8x5-unorm-srgb": { gl: 37845 },
+  "astc-8x6-unorm": { gl: 37814 },
+  "astc-8x6-unorm-srgb": { gl: 37846 },
+  "astc-8x8-unorm": { gl: 37815 },
+  "astc-8x8-unorm-srgb": { gl: 37847 },
+  "astc-10x5-unorm": { gl: 37819 },
+  "astc-10x5-unorm-srgb": { gl: 37851 },
+  "astc-10x6-unorm": { gl: 37817 },
+  "astc-10x6-unorm-srgb": { gl: 37849 },
+  "astc-10x8-unorm": { gl: 37818 },
+  "astc-10x8-unorm-srgb": { gl: 37850 },
+  "astc-10x10-unorm": { gl: 37819 },
+  "astc-10x10-unorm-srgb": { gl: 37851 },
+  "astc-12x10-unorm": { gl: 37820 },
+  "astc-12x10-unorm-srgb": { gl: 37852 },
+  "astc-12x12-unorm": { gl: 37821 },
+  "astc-12x12-unorm-srgb": { gl: 37853 },
+  // WEBGL_compressed_texture_pvrtc
+  "pvrtc-rgb4unorm-webgl": { gl: 35840 },
+  "pvrtc-rgba4unorm-webgl": { gl: 35842 },
+  "pvrtc-rbg2unorm-webgl": { gl: 35841 },
+  "pvrtc-rgba2unorm-webgl": { gl: 35843 },
+  // WEBGL_compressed_texture_etc1
+  "etc1-rbg-unorm-webgl": { gl: 36196 },
+  // WEBGL_compressed_texture_atc
+  "atc-rgb-unorm-webgl": { gl: 35986 },
+  "atc-rgba-unorm-webgl": { gl: 35986 },
+  "atc-rgbai-unorm-webgl": { gl: 34798 }
+};
+function getTextureFormatCapabilitiesWebGL(gl2, formatSupport, extensions) {
+  let supported = formatSupport.create;
+  const webglFormatInfo = WEBGL_TEXTURE_FORMATS[formatSupport.format];
+  if ((webglFormatInfo == null ? void 0 : webglFormatInfo.gl) === void 0) {
+    supported = false;
+  }
+  if (webglFormatInfo == null ? void 0 : webglFormatInfo.x) {
+    supported = supported && Boolean(getWebGLExtension(gl2, webglFormatInfo.x, extensions));
+  }
+  return {
+    format: formatSupport.format,
+    // @ts-ignore
+    create: supported && formatSupport.create,
+    // @ts-ignore
+    render: supported && formatSupport.render,
+    // @ts-ignore
+    filter: supported && formatSupport.filter,
+    // @ts-ignore
+    blend: supported && formatSupport.blend,
+    // @ts-ignore
+    store: supported && formatSupport.store
+  };
+}
+function getTextureFormatWebGL(format) {
+  var _a3;
+  const formatData = WEBGL_TEXTURE_FORMATS[format];
+  const webglFormat = convertTextureFormatToGL(format);
+  const decoded = textureFormatDecoder.getInfo(format);
+  if (decoded.compressed) {
+    formatData.dataFormat = webglFormat;
+  }
+  return {
+    internalFormat: webglFormat,
+    format: (formatData == null ? void 0 : formatData.dataFormat) || getWebGLPixelDataFormat(decoded.channels, decoded.integer, decoded.normalized, webglFormat),
+    // depth formats don't have a type
+    type: decoded.dataType ? getGLFromVertexType(decoded.dataType) : ((_a3 = formatData == null ? void 0 : formatData.types) == null ? void 0 : _a3[0]) || 5121,
+    compressed: decoded.compressed || false
+  };
+}
+function getDepthStencilAttachmentWebGL(format) {
+  const formatInfo = textureFormatDecoder.getInfo(format);
+  switch (formatInfo.attachment) {
+    case "depth":
+      return 36096;
+    case "stencil":
+      return 36128;
+    case "depth-stencil":
+      return 33306;
+    default:
+      throw new Error(`Not a depth stencil format: ${format}`);
+  }
+}
+function getWebGLPixelDataFormat(channels, integer, normalized, format) {
+  if (format === 6408 || format === 6407) {
+    return format;
+  }
+  switch (channels) {
+    case "r":
+      return integer && !normalized ? 36244 : 6403;
+    case "rg":
+      return integer && !normalized ? 33320 : 33319;
+    case "rgb":
+      return integer && !normalized ? 36248 : 6407;
+    case "rgba":
+      return integer && !normalized ? 36249 : 6408;
+    case "bgra":
+      throw new Error("bgra pixels not supported by WebGL");
+    default:
+      return 6408;
+  }
+}
+function convertTextureFormatToGL(format) {
+  const formatInfo = WEBGL_TEXTURE_FORMATS[format];
+  const webglFormat = formatInfo == null ? void 0 : formatInfo.gl;
+  if (webglFormat === void 0) {
+    throw new Error(`Unsupported texture format ${format}`);
+  }
+  return webglFormat;
+}
+const WEBGL_FEATURES = {
+  // optional WebGPU features
+  "depth-clip-control": "EXT_depth_clamp",
+  // TODO these seem subtly different
+  // 'timestamp-query' // GPUQueryType "timestamp-query"
+  // "indirect-first-instance"
+  // Textures are handled by getTextureFeatures()
+  // 'depth32float-stencil8' // GPUTextureFormat 'depth32float-stencil8'
+  // optional WebGL features
+  "timer-query-webgl": "EXT_disjoint_timer_query_webgl2",
+  "compilation-status-async-webgl": "KHR_parallel_shader_compile",
+  "polygon-mode-webgl": "WEBGL_polygon_mode",
+  "provoking-vertex-webgl": "WEBGL_provoking_vertex",
+  "shader-clip-cull-distance-webgl": "WEBGL_clip_cull_distance",
+  "shader-noperspective-interpolation-webgl": "NV_shader_noperspective_interpolation",
+  "shader-conservative-depth-webgl": "EXT_conservative_depth"
+  // Textures are handled by getTextureFeatures()
+};
+class WebGLDeviceFeatures extends DeviceFeatures {
+  constructor(gl2, extensions, disabledFeatures) {
+    super([], disabledFeatures);
+    __publicField(this, "gl");
+    __publicField(this, "extensions");
+    __publicField(this, "testedFeatures", /* @__PURE__ */ new Set());
+    this.gl = gl2;
+    this.extensions = extensions;
+    getWebGLExtension(gl2, "EXT_color_buffer_float", extensions);
+  }
+  *[Symbol.iterator]() {
+    const features = this.getFeatures();
+    for (const feature of features) {
+      if (this.has(feature)) {
+        yield feature;
+      }
+    }
+    return [];
+  }
+  has(feature) {
+    var _a3;
+    if ((_a3 = this.disabledFeatures) == null ? void 0 : _a3[feature]) {
+      return false;
+    }
+    if (!this.testedFeatures.has(feature)) {
+      this.testedFeatures.add(feature);
+      if (isTextureFeature(feature) && checkTextureFeature(this.gl, feature, this.extensions)) {
+        this.features.add(feature);
+      }
+      if (this.getWebGLFeature(feature)) {
+        this.features.add(feature);
+      }
+    }
+    return this.features.has(feature);
+  }
+  // FOR DEVICE
+  initializeFeatures() {
+    const features = this.getFeatures().filter((feature) => feature !== "polygon-mode-webgl");
+    for (const feature of features) {
+      this.has(feature);
+    }
+  }
+  // IMPLEMENTATION
+  getFeatures() {
+    return [...Object.keys(WEBGL_FEATURES), ...Object.keys(TEXTURE_FEATURES)];
+  }
+  /** Extract all WebGL features */
+  getWebGLFeature(feature) {
+    const featureInfo = WEBGL_FEATURES[feature];
+    const isSupported = typeof featureInfo === "string" ? Boolean(getWebGLExtension(this.gl, featureInfo, this.extensions)) : Boolean(featureInfo);
+    return isSupported;
+  }
+}
+class WebGLDeviceLimits extends DeviceLimits {
+  constructor(gl2) {
+    super();
+    // WebGL does not support compute shaders
+    // PRIVATE
+    __publicField(this, "gl");
+    __publicField(this, "limits", {});
+    this.gl = gl2;
+  }
+  get maxTextureDimension1D() {
+    return 0;
+  }
+  // WebGL does not support 1D textures
+  get maxTextureDimension2D() {
+    return this.getParameter(3379);
+  }
+  get maxTextureDimension3D() {
+    return this.getParameter(32883);
+  }
+  get maxTextureArrayLayers() {
+    return this.getParameter(35071);
+  }
+  get maxBindGroups() {
+    return 0;
+  }
+  get maxDynamicUniformBuffersPerPipelineLayout() {
+    return 0;
+  }
+  // TBD
+  get maxDynamicStorageBuffersPerPipelineLayout() {
+    return 0;
+  }
+  // TBD
+  get maxSampledTexturesPerShaderStage() {
+    return this.getParameter(35660);
+  }
+  // ) TBD
+  get maxSamplersPerShaderStage() {
+    return this.getParameter(35661);
+  }
+  get maxStorageBuffersPerShaderStage() {
+    return 0;
+  }
+  // TBD
+  get maxStorageTexturesPerShaderStage() {
+    return 0;
+  }
+  // TBD
+  get maxUniformBuffersPerShaderStage() {
+    return this.getParameter(35375);
+  }
+  get maxUniformBufferBindingSize() {
+    return this.getParameter(35376);
+  }
+  get maxStorageBufferBindingSize() {
+    return 0;
+  }
+  get minUniformBufferOffsetAlignment() {
+    return this.getParameter(35380);
+  }
+  get minStorageBufferOffsetAlignment() {
+    return 0;
+  }
+  get maxVertexBuffers() {
+    return 16;
+  }
+  // WebGL 2 supports 16 buffers, see https://github.com/gpuweb/gpuweb/issues/4284
+  get maxVertexAttributes() {
+    return this.getParameter(34921);
+  }
+  get maxVertexBufferArrayStride() {
+    return 2048;
+  }
+  // TBD, this is just the default value from WebGPU
+  get maxInterStageShaderVariables() {
+    return this.getParameter(35659);
+  }
+  get maxComputeWorkgroupStorageSize() {
+    return 0;
+  }
+  // WebGL does not support compute shaders
+  get maxComputeInvocationsPerWorkgroup() {
+    return 0;
+  }
+  // WebGL does not support compute shaders
+  get maxComputeWorkgroupSizeX() {
+    return 0;
+  }
+  // WebGL does not support compute shaders
+  get maxComputeWorkgroupSizeY() {
+    return 0;
+  }
+  // WebGL does not support compute shaders
+  get maxComputeWorkgroupSizeZ() {
+    return 0;
+  }
+  // WebGL does not support compute shaders
+  get maxComputeWorkgroupsPerDimension() {
+    return 0;
+  }
+  getParameter(parameter) {
+    if (this.limits[parameter] === void 0) {
+      this.limits[parameter] = this.gl.getParameter(parameter);
+    }
+    return this.limits[parameter] || 0;
+  }
+}
+class WEBGLFramebuffer extends Framebuffer {
+  constructor(device, props) {
+    super(device, props);
+    __publicField(this, "device");
+    __publicField(this, "gl");
+    __publicField(this, "handle");
+    __publicField(this, "colorAttachments", []);
+    __publicField(this, "depthStencilAttachment", null);
+    const isDefaultFramebuffer = props.handle === null;
+    this.device = device;
+    this.gl = device.gl;
+    this.handle = this.props.handle || isDefaultFramebuffer ? this.props.handle : this.gl.createFramebuffer();
+    if (!isDefaultFramebuffer) {
+      device._setWebGLDebugMetadata(this.handle, this, { spector: this.props });
+      this.autoCreateAttachmentTextures();
+      this.updateAttachments();
+    }
+  }
+  /** destroys any auto created resources etc. */
+  destroy() {
+    super.destroy();
+    if (!this.destroyed && this.handle !== null) {
+      this.gl.deleteFramebuffer(this.handle);
+    }
+  }
+  updateAttachments() {
+    const prevHandle = this.gl.bindFramebuffer(36160, this.handle);
+    for (let i2 = 0; i2 < this.colorAttachments.length; ++i2) {
+      const attachment = this.colorAttachments[i2];
+      if (attachment) {
+        const attachmentPoint = 36064 + i2;
+        this._attachTextureView(attachmentPoint, attachment);
+      }
+    }
+    if (this.depthStencilAttachment) {
+      const attachmentPoint = getDepthStencilAttachmentWebGL(this.depthStencilAttachment.props.format);
+      this._attachTextureView(attachmentPoint, this.depthStencilAttachment);
+    }
+    if (this.device.props.debug) {
+      const status = this.gl.checkFramebufferStatus(36160);
+      if (status !== 36053) {
+        throw new Error(`Framebuffer ${_getFrameBufferStatus(status)}`);
+      }
+    }
+    this.gl.bindFramebuffer(36160, prevHandle);
+  }
+  // PRIVATE
+  /** In WebGL we must use renderbuffers for depth/stencil attachments (unless we have extensions) */
+  // protected override createDepthStencilTexture(format: TextureFormat): Texture {
+  //   // return new WEBGLRenderbuffer(this.device, {
+  //   return new WEBGLTexture(this.device, {
+  //     id: `${this.id}-depth-stencil`,
+  //     format,
+  //     width: this.width,
+  //     height: this.height,
+  //     mipmaps: false
+  //   });
+  // }
+  /**
+   * @param attachment
+   * @param texture
+   * @param layer = 0 - index into WEBGLTextureArray and Texture3D or face for `TextureCubeMap`
+   * @param level = 0 - mipmapLevel
+   */
+  _attachTextureView(attachment, textureView) {
+    const { gl: gl2 } = this.device;
+    const { texture } = textureView;
+    const level = textureView.props.baseMipLevel;
+    const layer = textureView.props.baseArrayLayer;
+    gl2.bindTexture(texture.glTarget, texture.handle);
+    switch (texture.glTarget) {
+      case 35866:
+      case 32879:
+        gl2.framebufferTextureLayer(36160, attachment, texture.handle, level, layer);
+        break;
+      case 34067:
+        const face = mapIndexToCubeMapFace(layer);
+        gl2.framebufferTexture2D(36160, attachment, face, texture.handle, level);
+        break;
+      case 3553:
+        gl2.framebufferTexture2D(36160, attachment, 3553, texture.handle, level);
+        break;
+      default:
+        throw new Error("Illegal texture type");
+    }
+    gl2.bindTexture(texture.glTarget, null);
+  }
+}
+function mapIndexToCubeMapFace(layer) {
+  return layer < 34069 ? layer + 34069 : layer;
+}
+function _getFrameBufferStatus(status) {
+  switch (status) {
+    case 36053:
+      return "success";
+    case 36054:
+      return "Mismatched attachments";
+    case 36055:
+      return "No attachments";
+    case 36057:
+      return "Height/width mismatch";
+    case 36061:
+      return "Unsupported or split attachments";
+    case 36182:
+      return "Samples mismatch";
+    default:
+      return `${status}`;
+  }
+}
+class WebGLCanvasContext extends CanvasContext {
+  constructor(device, props) {
+    super(props);
+    __publicField(this, "device");
+    __publicField(this, "handle", null);
+    __publicField(this, "_framebuffer", null);
+    this.device = device;
+    this._setAutoCreatedCanvasId(`${this.device.id}-canvas`);
+    this._updateDevice();
+  }
+  get [Symbol.toStringTag]() {
+    return "WebGLCanvasContext";
+  }
+  getCurrentFramebuffer() {
+    this._framebuffer = this._framebuffer || new WEBGLFramebuffer(this.device, { handle: null });
+    return this._framebuffer;
+  }
+  // IMPLEMENTATION OF ABSTRACT METHODS
+  _updateDevice() {
+  }
+}
+const uidCounters = {};
+function uid(id2 = "id") {
+  uidCounters[id2] = uidCounters[id2] || 1;
+  const count2 = uidCounters[id2]++;
+  return `${id2}-${count2}`;
+}
+class WEBGLBuffer extends Buffer$1 {
+  constructor(device, props = {}) {
+    super(device, props);
+    __publicField(this, "device");
+    __publicField(this, "gl");
+    __publicField(this, "handle");
+    /** Target in OpenGL defines the type of buffer */
+    __publicField(this, "glTarget");
+    /** Usage is a hint on how frequently the buffer will be updates */
+    __publicField(this, "glUsage");
+    /** Index type is needed when issuing draw calls, so we pre-compute it */
+    __publicField(this, "glIndexType", 5123);
+    /** Number of bytes allocated on the GPU for this buffer */
+    __publicField(this, "byteLength", 0);
+    /** Number of bytes used */
+    __publicField(this, "bytesUsed", 0);
+    this.device = device;
+    this.gl = this.device.gl;
+    const handle = typeof props === "object" ? props.handle : void 0;
+    this.handle = handle || this.gl.createBuffer();
+    device._setWebGLDebugMetadata(this.handle, this, {
+      spector: { ...this.props, data: typeof this.props.data }
+    });
+    this.glTarget = getWebGLTarget(this.props.usage);
+    this.glUsage = getWebGLUsage(this.props.usage);
+    this.glIndexType = this.props.indexType === "uint32" ? 5125 : 5123;
+    if (props.data) {
+      this._initWithData(props.data, props.byteOffset, props.byteLength);
+    } else {
+      this._initWithByteLength(props.byteLength || 0);
+    }
+  }
+  destroy() {
+    if (!this.destroyed && this.handle) {
+      this.removeStats();
+      this.trackDeallocatedMemory();
+      this.gl.deleteBuffer(this.handle);
+      this.destroyed = true;
+      this.handle = null;
+    }
+  }
+  /** Allocate a new buffer and initialize to contents of typed array */
+  _initWithData(data, byteOffset = 0, byteLength = data.byteLength + byteOffset) {
+    const glTarget = this.glTarget;
+    this.gl.bindBuffer(glTarget, this.handle);
+    this.gl.bufferData(glTarget, byteLength, this.glUsage);
+    this.gl.bufferSubData(glTarget, byteOffset, data);
+    this.gl.bindBuffer(glTarget, null);
+    this.bytesUsed = byteLength;
+    this.byteLength = byteLength;
+    this._setDebugData(data, byteOffset, byteLength);
+    this.trackAllocatedMemory(byteLength);
+  }
+  // Allocate a GPU buffer of specified size.
+  _initWithByteLength(byteLength) {
+    let data = byteLength;
+    if (byteLength === 0) {
+      data = new Float32Array(0);
+    }
+    const glTarget = this.glTarget;
+    this.gl.bindBuffer(glTarget, this.handle);
+    this.gl.bufferData(glTarget, data, this.glUsage);
+    this.gl.bindBuffer(glTarget, null);
+    this.bytesUsed = byteLength;
+    this.byteLength = byteLength;
+    this._setDebugData(null, 0, byteLength);
+    this.trackAllocatedMemory(byteLength);
+    return this;
+  }
+  write(data, byteOffset = 0) {
+    const dataView = ArrayBuffer.isView(data) ? data : new Uint8Array(data);
+    const glTarget = 36663;
+    this.gl.bindBuffer(glTarget, this.handle);
+    {
+      this.gl.bufferSubData(glTarget, byteOffset, dataView);
+    }
+    this.gl.bindBuffer(glTarget, null);
+    this._setDebugData(data, byteOffset, data.byteLength);
+  }
+  async mapAndWriteAsync(callback, byteOffset = 0, byteLength = this.byteLength - byteOffset) {
+    const arrayBuffer2 = new ArrayBuffer(byteLength);
+    await callback(arrayBuffer2, "copied");
+    this.write(arrayBuffer2, byteOffset);
+  }
+  async readAsync(byteOffset = 0, byteLength) {
+    return this.readSyncWebGL(byteOffset, byteLength);
+  }
+  async mapAndReadAsync(callback, byteOffset = 0, byteLength) {
+    const data = await this.readAsync(byteOffset, byteLength);
+    return await callback(data.buffer, "copied");
+  }
+  readSyncWebGL(byteOffset = 0, byteLength) {
+    byteLength = byteLength ?? this.byteLength - byteOffset;
+    const data = new Uint8Array(byteLength);
+    const dstOffset = 0;
+    this.gl.bindBuffer(36662, this.handle);
+    this.gl.getBufferSubData(36662, byteOffset, data, dstOffset, byteLength);
+    this.gl.bindBuffer(36662, null);
+    this._setDebugData(data, byteOffset, byteLength);
+    return data;
+  }
+}
+function getWebGLTarget(usage) {
+  if (usage & Buffer$1.INDEX) {
+    return 34963;
+  }
+  if (usage & Buffer$1.VERTEX) {
+    return 34962;
+  }
+  if (usage & Buffer$1.UNIFORM) {
+    return 35345;
+  }
+  return 34962;
+}
+function getWebGLUsage(usage) {
+  if (usage & Buffer$1.INDEX) {
+    return 35044;
+  }
+  if (usage & Buffer$1.VERTEX) {
+    return 35044;
+  }
+  if (usage & Buffer$1.UNIFORM) {
+    return 35048;
+  }
+  return 35044;
+}
+function parseShaderCompilerLog(errLog) {
+  const lines = errLog.split(/\r?\n/);
+  const messages = [];
+  for (const line of lines) {
+    if (line.length <= 1) {
+      continue;
+    }
+    const segments = line.split(":");
+    if (segments.length === 2) {
+      const [messageType2, message2] = segments;
+      messages.push({
+        message: message2.trim(),
+        type: getMessageType(messageType2),
+        lineNum: 0,
+        linePos: 0
+      });
+      continue;
+    }
+    const [messageType, linePosition, lineNumber, ...rest] = segments;
+    let lineNum = parseInt(lineNumber, 10);
+    if (isNaN(lineNum)) {
+      lineNum = 0;
+    }
+    let linePos = parseInt(linePosition, 10);
+    if (isNaN(linePos)) {
+      linePos = 0;
+    }
+    messages.push({
+      message: rest.join(":").trim(),
+      type: getMessageType(messageType),
+      lineNum,
+      linePos
+      // TODO
+    });
+  }
+  return messages;
+}
+function getMessageType(messageType) {
+  const MESSAGE_TYPES = ["warning", "error", "info"];
+  const lowerCaseType = messageType.toLowerCase();
+  return MESSAGE_TYPES.includes(lowerCaseType) ? lowerCaseType : "info";
+}
+class WEBGLShader extends Shader {
+  constructor(device, props) {
+    super(device, props);
+    __publicField(this, "device");
+    __publicField(this, "handle");
+    this.device = device;
+    switch (this.props.stage) {
+      case "vertex":
+        this.handle = this.props.handle || this.device.gl.createShader(35633);
+        break;
+      case "fragment":
+        this.handle = this.props.handle || this.device.gl.createShader(35632);
+        break;
+      default:
+        throw new Error(this.props.stage);
+    }
+    device._setWebGLDebugMetadata(this.handle, this, { spector: this.props });
+    this._compile(this.source);
+  }
+  destroy() {
+    if (this.handle) {
+      this.removeStats();
+      this.device.gl.deleteShader(this.handle);
+      this.destroyed = true;
+      this.handle.destroyed = true;
+    }
+  }
+  get asyncCompilationStatus() {
+    return this._waitForCompilationComplete().then(() => {
+      this._getCompilationStatus();
+      return this.compilationStatus;
+    });
+  }
+  async getCompilationInfo() {
+    await this._waitForCompilationComplete();
+    return this.getCompilationInfoSync();
+  }
+  getCompilationInfoSync() {
+    const shaderLog = this.device.gl.getShaderInfoLog(this.handle);
+    return shaderLog ? parseShaderCompilerLog(shaderLog) : [];
+  }
+  getTranslatedSource() {
+    const extensions = this.device.getExtension("WEBGL_debug_shaders");
+    const ext = extensions.WEBGL_debug_shaders;
+    return (ext == null ? void 0 : ext.getTranslatedShaderSource(this.handle)) || null;
+  }
+  // PRIVATE METHODS
+  /** Compile a shader and get compilation status */
+  async _compile(source2) {
+    source2 = source2.startsWith("#version ") ? source2 : `#version 300 es
+${source2}`;
+    const { gl: gl2 } = this.device;
+    gl2.shaderSource(this.handle, source2);
+    gl2.compileShader(this.handle);
+    if (!this.device.props.debug) {
+      this.compilationStatus = "pending";
+      return;
+    }
+    if (!this.device.features.has("compilation-status-async-webgl")) {
+      this._getCompilationStatus();
+      this.debugShader();
+      if (this.compilationStatus === "error") {
+        throw new Error(`GLSL compilation errors in ${this.props.stage} shader ${this.props.id}`);
+      }
+      return;
+    }
+    log.once(1, "Shader compilation is asynchronous")();
+    await this._waitForCompilationComplete();
+    log.info(2, `Shader ${this.id} - async compilation complete: ${this.compilationStatus}`)();
+    this._getCompilationStatus();
+    this.debugShader();
+  }
+  /** Use KHR_parallel_shader_compile extension if available */
+  async _waitForCompilationComplete() {
+    const waitMs = async (ms) => await new Promise((resolve) => setTimeout(resolve, ms));
+    const DELAY_MS = 10;
+    if (!this.device.features.has("compilation-status-async-webgl")) {
+      await waitMs(DELAY_MS);
+      return;
+    }
+    const { gl: gl2 } = this.device;
+    for (; ; ) {
+      const complete = gl2.getShaderParameter(this.handle, 37297);
+      if (complete) {
+        return;
+      }
+      await waitMs(DELAY_MS);
+    }
+  }
+  /**
+   * Get the shader compilation status
+   * TODO - Load log even when no error reported, to catch warnings?
+   * https://gamedev.stackexchange.com/questions/30429/how-to-detect-glsl-warnings
+   */
+  _getCompilationStatus() {
+    this.compilationStatus = this.device.gl.getShaderParameter(this.handle, 35713) ? "success" : "error";
+  }
+}
+function withDeviceAndGLParameters(device, parameters, glParameters, func) {
+  if (isObjectEmpty$1(parameters)) {
+    return func(device);
+  }
+  const webglDevice2 = device;
+  webglDevice2.pushState();
+  try {
+    setDeviceParameters(device, parameters);
+    setGLParameters(webglDevice2.gl, glParameters);
+    return func(device);
+  } finally {
+    webglDevice2.popState();
+  }
+}
+function setDeviceParameters(device, parameters) {
+  const webglDevice2 = device;
+  const { gl: gl2 } = webglDevice2;
+  if (parameters.cullMode) {
+    switch (parameters.cullMode) {
+      case "none":
+        gl2.disable(2884);
+        break;
+      case "front":
+        gl2.enable(2884);
+        gl2.cullFace(1028);
+        break;
+      case "back":
+        gl2.enable(2884);
+        gl2.cullFace(1029);
+        break;
+    }
+  }
+  if (parameters.frontFace) {
+    gl2.frontFace(map("frontFace", parameters.frontFace, {
+      ccw: 2305,
+      cw: 2304
+    }));
+  }
+  if (parameters.unclippedDepth) {
+    if (device.features.has("depth-clip-control")) {
+      gl2.enable(34383);
+    }
+  }
+  if (parameters.depthBias !== void 0) {
+    gl2.enable(32823);
+    gl2.polygonOffset(parameters.depthBias, parameters.depthBiasSlopeScale || 0);
+  }
+  if (parameters.provokingVertex) {
+    if (device.features.has("provoking-vertex-webgl")) {
+      const extensions = webglDevice2.getExtension("WEBGL_provoking_vertex");
+      const ext = extensions.WEBGL_provoking_vertex;
+      const vertex2 = map("provokingVertex", parameters.provokingVertex, {
+        first: 36429,
+        last: 36430
+      });
+      ext == null ? void 0 : ext.provokingVertexWEBGL(vertex2);
+    }
+  }
+  if (parameters.polygonMode || parameters.polygonOffsetLine) {
+    if (device.features.has("polygon-mode-webgl")) {
+      if (parameters.polygonMode) {
+        const extensions = webglDevice2.getExtension("WEBGL_polygon_mode");
+        const ext = extensions.WEBGL_polygon_mode;
+        const mode = map("polygonMode", parameters.polygonMode, {
+          fill: 6914,
+          line: 6913
+        });
+        ext == null ? void 0 : ext.polygonModeWEBGL(1028, mode);
+        ext == null ? void 0 : ext.polygonModeWEBGL(1029, mode);
+      }
+      if (parameters.polygonOffsetLine) {
+        gl2.enable(10754);
+      }
+    }
+  }
+  if (device.features.has("shader-clip-cull-distance-webgl")) {
+    if (parameters.clipDistance0) {
+      gl2.enable(12288);
+    }
+    if (parameters.clipDistance1) {
+      gl2.enable(12289);
+    }
+    if (parameters.clipDistance2) {
+      gl2.enable(12290);
+    }
+    if (parameters.clipDistance3) {
+      gl2.enable(12291);
+    }
+    if (parameters.clipDistance4) {
+      gl2.enable(12292);
+    }
+    if (parameters.clipDistance5) {
+      gl2.enable(12293);
+    }
+    if (parameters.clipDistance6) {
+      gl2.enable(12294);
+    }
+    if (parameters.clipDistance7) {
+      gl2.enable(12295);
+    }
+  }
+  if (parameters.depthWriteEnabled !== void 0) {
+    gl2.depthMask(mapBoolean("depthWriteEnabled", parameters.depthWriteEnabled));
+  }
+  if (parameters.depthCompare) {
+    parameters.depthCompare !== "always" ? gl2.enable(2929) : gl2.disable(2929);
+    gl2.depthFunc(convertCompareFunction("depthCompare", parameters.depthCompare));
+  }
+  if (parameters.stencilWriteMask) {
+    const mask = parameters.stencilWriteMask;
+    gl2.stencilMaskSeparate(1028, mask);
+    gl2.stencilMaskSeparate(1029, mask);
+  }
+  if (parameters.stencilReadMask) {
+    log.warn("stencilReadMask not supported under WebGL");
+  }
+  if (parameters.stencilCompare) {
+    const mask = parameters.stencilReadMask || 4294967295;
+    const glValue = convertCompareFunction("depthCompare", parameters.stencilCompare);
+    parameters.stencilCompare !== "always" ? gl2.enable(2960) : gl2.disable(2960);
+    gl2.stencilFuncSeparate(1028, glValue, 0, mask);
+    gl2.stencilFuncSeparate(1029, glValue, 0, mask);
+  }
+  if (parameters.stencilPassOperation && parameters.stencilFailOperation && parameters.stencilDepthFailOperation) {
+    const dppass = convertStencilOperation("stencilPassOperation", parameters.stencilPassOperation);
+    const sfail = convertStencilOperation("stencilFailOperation", parameters.stencilFailOperation);
+    const dpfail = convertStencilOperation("stencilDepthFailOperation", parameters.stencilDepthFailOperation);
+    gl2.stencilOpSeparate(1028, sfail, dpfail, dppass);
+    gl2.stencilOpSeparate(1029, sfail, dpfail, dppass);
+  }
+  switch (parameters.blend) {
+    case true:
+      gl2.enable(3042);
+      break;
+    case false:
+      gl2.disable(3042);
+      break;
+  }
+  if (parameters.blendColorOperation || parameters.blendAlphaOperation) {
+    const colorEquation = convertBlendOperationToEquation("blendColorOperation", parameters.blendColorOperation || "add");
+    const alphaEquation = convertBlendOperationToEquation("blendAlphaOperation", parameters.blendAlphaOperation || "add");
+    gl2.blendEquationSeparate(colorEquation, alphaEquation);
+    const colorSrcFactor = convertBlendFactorToFunction("blendColorSrcFactor", parameters.blendColorSrcFactor || "one");
+    const colorDstFactor = convertBlendFactorToFunction("blendColorDstFactor", parameters.blendColorDstFactor || "zero");
+    const alphaSrcFactor = convertBlendFactorToFunction("blendAlphaSrcFactor", parameters.blendAlphaSrcFactor || "one");
+    const alphaDstFactor = convertBlendFactorToFunction("blendAlphaDstFactor", parameters.blendAlphaDstFactor || "zero");
+    gl2.blendFuncSeparate(colorSrcFactor, colorDstFactor, alphaSrcFactor, alphaDstFactor);
+  }
+}
+function convertCompareFunction(parameter, value) {
+  return map(parameter, value, {
+    never: 512,
+    less: 513,
+    equal: 514,
+    "less-equal": 515,
+    greater: 516,
+    "not-equal": 517,
+    "greater-equal": 518,
+    always: 519
+  });
+}
+function convertStencilOperation(parameter, value) {
+  return map(parameter, value, {
+    keep: 7680,
+    zero: 0,
+    replace: 7681,
+    invert: 5386,
+    "increment-clamp": 7682,
+    "decrement-clamp": 7683,
+    "increment-wrap": 34055,
+    "decrement-wrap": 34056
+  });
+}
+function convertBlendOperationToEquation(parameter, value) {
+  return map(parameter, value, {
+    add: 32774,
+    subtract: 32778,
+    "reverse-subtract": 32779,
+    min: 32775,
+    max: 32776
+  });
+}
+function convertBlendFactorToFunction(parameter, value, type = "color") {
+  return map(parameter, value, {
+    one: 1,
+    zero: 0,
+    src: 768,
+    "one-minus-src": 769,
+    dst: 774,
+    "one-minus-dst": 775,
+    "src-alpha": 770,
+    "one-minus-src-alpha": 771,
+    "dst-alpha": 772,
+    "one-minus-dst-alpha": 773,
+    "src-alpha-saturated": 776,
+    constant: type === "color" ? 32769 : 32771,
+    "one-minus-constant": type === "color" ? 32770 : 32772,
+    // 'constant-alpha': GL.CONSTANT_ALPHA,
+    // 'one-minus-constant-alpha': GL.ONE_MINUS_CONSTANT_ALPHA,
+    // TODO not supported in WebGL2
+    src1: 768,
+    "one-minus-src1": 769,
+    "src1-alpha": 770,
+    "one-minus-src1-alpha": 771
+  });
+}
+function message(parameter, value) {
+  return `Illegal parameter ${value} for ${parameter}`;
+}
+function map(parameter, value, valueMap) {
+  if (!(value in valueMap)) {
+    throw new Error(message(parameter, value));
+  }
+  return valueMap[value];
+}
+function mapBoolean(parameter, value) {
+  return value;
+}
+function isObjectEmpty$1(obj) {
+  let isEmpty = true;
+  for (const key in obj) {
+    isEmpty = false;
+    break;
+  }
+  return isEmpty;
+}
+function convertSamplerParametersToWebGL(props) {
+  const params = {};
+  if (props.addressModeU) {
+    params[10242] = convertAddressMode(props.addressModeU);
+  }
+  if (props.addressModeV) {
+    params[10243] = convertAddressMode(props.addressModeV);
+  }
+  if (props.addressModeW) {
+    params[32882] = convertAddressMode(props.addressModeW);
+  }
+  if (props.magFilter) {
+    params[10240] = convertMaxFilterMode(props.magFilter);
+  }
+  if (props.minFilter || props.mipmapFilter) {
+    params[10241] = convertMinFilterMode(props.minFilter || "linear", props.mipmapFilter);
+  }
+  if (props.lodMinClamp !== void 0) {
+    params[33082] = props.lodMinClamp;
+  }
+  if (props.lodMaxClamp !== void 0) {
+    params[33083] = props.lodMaxClamp;
+  }
+  if (props.type === "comparison-sampler") {
+    params[34892] = 34894;
+  }
+  if (props.compare) {
+    params[34893] = convertCompareFunction("compare", props.compare);
+  }
+  if (props.maxAnisotropy) {
+    params[34046] = props.maxAnisotropy;
+  }
+  return params;
+}
+function convertAddressMode(addressMode) {
+  switch (addressMode) {
+    case "clamp-to-edge":
+      return 33071;
+    case "repeat":
+      return 10497;
+    case "mirror-repeat":
+      return 33648;
+  }
+}
+function convertMaxFilterMode(maxFilter) {
+  switch (maxFilter) {
+    case "nearest":
+      return 9728;
+    case "linear":
+      return 9729;
+  }
+}
+function convertMinFilterMode(minFilter, mipmapFilter = "none") {
+  if (!mipmapFilter) {
+    return convertMaxFilterMode(minFilter);
+  }
+  switch (mipmapFilter) {
+    case "none":
+      return convertMaxFilterMode(minFilter);
+    case "nearest":
+      switch (minFilter) {
+        case "nearest":
+          return 9984;
+        case "linear":
+          return 9985;
+      }
+      break;
+    case "linear":
+      switch (minFilter) {
+        case "nearest":
+          return 9986;
+        case "linear":
+          return 9987;
+      }
+  }
+}
+class WEBGLSampler extends Sampler {
+  constructor(device, props) {
+    super(device, props);
+    __publicField(this, "device");
+    __publicField(this, "handle");
+    __publicField(this, "parameters");
+    this.device = device;
+    this.parameters = convertSamplerParametersToWebGL(props);
+    this.handle = props.handle || this.device.gl.createSampler();
+    this._setSamplerParameters(this.parameters);
+  }
+  destroy() {
+    if (this.handle) {
+      this.device.gl.deleteSampler(this.handle);
+      this.handle = void 0;
+    }
+  }
+  toString() {
+    return `Sampler(${this.id},${JSON.stringify(this.props)})`;
+  }
+  /** Set sampler parameters on the sampler */
+  _setSamplerParameters(parameters) {
+    for (const [pname, value] of Object.entries(parameters)) {
+      const param = Number(pname);
+      switch (param) {
+        case 33082:
+        case 33083:
+          this.device.gl.samplerParameterf(this.handle, param, value);
+          break;
+        default:
+          this.device.gl.samplerParameteri(this.handle, param, value);
+          break;
+      }
+    }
+  }
+}
+function withGLParameters(gl2, parameters, func) {
+  if (isObjectEmpty(parameters)) {
+    return func(gl2);
+  }
+  const { nocatch = true } = parameters;
+  const webglState = WebGLStateTracker.get(gl2);
+  webglState.push();
+  setGLParameters(gl2, parameters);
+  let value;
+  if (nocatch) {
+    value = func(gl2);
+    webglState.pop();
+  } else {
+    try {
+      value = func(gl2);
+    } finally {
+      webglState.pop();
+    }
+  }
+  return value;
+}
+function isObjectEmpty(object) {
+  for (const key in object) {
+    return false;
+  }
+  return true;
+}
+class WEBGLTextureView extends TextureView {
+  constructor(device, props) {
+    super(device, { ...Texture.defaultProps, ...props });
+    __publicField(this, "device");
+    __publicField(this, "gl");
+    __publicField(this, "handle");
+    // Does not have a WebGL representation
+    __publicField(this, "texture");
+    this.device = device;
+    this.gl = this.device.gl;
+    this.handle = null;
+    this.texture = props.texture;
+  }
+}
+class WEBGLTexture extends Texture {
+  constructor(device, props) {
+    super(device, props);
+    // readonly MAX_ATTRIBUTES: number;
+    __publicField(this, "device");
+    __publicField(this, "gl");
+    __publicField(this, "handle");
+    // @ts-ignore TODO - currently unused in WebGL. Create dummy sampler?
+    __publicField(this, "sampler");
+    __publicField(this, "view");
+    /**
+     * The WebGL target corresponding to the texture type
+     * @note `target` cannot be modified by bind:
+     * textures are special because when you first bind them to a target,
+     * When you first bind a texture as a GL_TEXTURE_2D, you are saying that this texture is a 2D texture.
+     * And it will always be a 2D texture; this state cannot be changed ever.
+     * A texture that was first bound as a GL_TEXTURE_2D, must always be bound as a GL_TEXTURE_2D;
+     * attempting to bind it as GL_TEXTURE_3D will give rise to a run-time error
+     */
+    __publicField(this, "glTarget");
+    /** The WebGL format - essentially channel structure */
+    __publicField(this, "glFormat");
+    /** The WebGL data format - the type of each channel */
+    __publicField(this, "glType");
+    /** The WebGL constant corresponding to the WebGPU style constant in format */
+    __publicField(this, "glInternalFormat");
+    /** Whether the internal format is compressed */
+    __publicField(this, "compressed");
+    // state
+    /** Texture binding slot - TODO - move to texture view? */
+    __publicField(this, "_textureUnit", 0);
+    this.device = device;
+    this.gl = this.device.gl;
+    const formatInfo = getTextureFormatWebGL(this.props.format);
+    this.glTarget = getWebGLTextureTarget(this.props.dimension);
+    this.glInternalFormat = formatInfo.internalFormat;
+    this.glFormat = formatInfo.format;
+    this.glType = formatInfo.type;
+    this.compressed = formatInfo.compressed;
+    this.handle = this.props.handle || this.gl.createTexture();
+    this.device._setWebGLDebugMetadata(this.handle, this, { spector: this.props });
+    this.gl.bindTexture(this.glTarget, this.handle);
+    const { dimension, width, height, depth, mipLevels, glTarget, glInternalFormat } = this;
+    switch (dimension) {
+      case "2d":
+      case "cube":
+        this.gl.texStorage2D(glTarget, mipLevels, glInternalFormat, width, height);
+        break;
+      case "2d-array":
+      case "3d":
+        this.gl.texStorage3D(glTarget, mipLevels, glInternalFormat, width, height, depth);
+        break;
+      default:
+        throw new Error(dimension);
+    }
+    this.gl.bindTexture(this.glTarget, null);
+    this._initializeData(props.data);
+    this.setSampler(this.props.sampler);
+    this.view = new WEBGLTextureView(this.device, { ...this.props, texture: this });
+    Object.seal(this);
+  }
+  destroy() {
+    if (this.handle) {
+      this.gl.deleteTexture(this.handle);
+      this.removeStats();
+      this.trackDeallocatedMemory("Texture");
+      this.destroyed = true;
+    }
+  }
+  createView(props) {
+    return new WEBGLTextureView(this.device, { ...props, texture: this });
+  }
+  setSampler(sampler = {}) {
+    super.setSampler(sampler);
+    const parameters = convertSamplerParametersToWebGL(this.sampler.props);
+    this._setSamplerParameters(parameters);
+  }
+  copyImageData(options_) {
+    const options = this._normalizeCopyImageDataOptions(options_);
+    const typedArray = options.data;
+    const { width, height, depth } = this;
+    const { mipLevel = 0, byteOffset = 0, x: x2 = 0, y: y2 = 0, z: z2 = 0 } = options;
+    const { glFormat, glType, compressed } = this;
+    const glTarget = getWebGLCubeFaceTarget(this.glTarget, this.dimension, z2);
+    let unpackRowLength;
+    if (!this.compressed) {
+      const { bytesPerPixel } = this.device.getTextureFormatInfo(this.format);
+      if (bytesPerPixel) {
+        if (options.bytesPerRow % bytesPerPixel !== 0) {
+          throw new Error(`bytesPerRow (${options.bytesPerRow}) must be a multiple of bytesPerPixel (${bytesPerPixel}) for ${this.format}`);
+        }
+        unpackRowLength = options.bytesPerRow / bytesPerPixel;
+      }
+    }
+    const glParameters = !this.compressed ? {
+      ...unpackRowLength !== void 0 ? { [3314]: unpackRowLength } : {},
+      [32878]: options.rowsPerImage
+    } : {};
+    this.gl.bindTexture(glTarget, this.handle);
+    withGLParameters(this.gl, glParameters, () => {
+      switch (this.dimension) {
+        case "2d":
+        case "cube":
+          if (compressed) {
+            this.gl.compressedTexSubImage2D(glTarget, mipLevel, x2, y2, width, height, glFormat, typedArray, byteOffset);
+          } else {
+            this.gl.texSubImage2D(glTarget, mipLevel, x2, y2, width, height, glFormat, glType, typedArray, byteOffset);
+          }
+          break;
+        case "2d-array":
+        case "3d":
+          if (compressed) {
+            this.gl.compressedTexSubImage3D(glTarget, mipLevel, x2, y2, z2, width, height, depth, glFormat, typedArray, byteOffset);
+          } else {
+            this.gl.texSubImage3D(glTarget, mipLevel, x2, y2, z2, width, height, depth, glFormat, glType, typedArray, byteOffset);
+          }
+          break;
+        default:
+      }
+    });
+    this.gl.bindTexture(glTarget, null);
+  }
+  copyExternalImage(options_) {
+    const options = this._normalizeCopyExternalImageOptions(options_);
+    if (options.sourceX || options.sourceY) {
+      throw new Error("WebGL does not support sourceX/sourceY)");
+    }
+    const { glFormat, glType } = this;
+    const { image, depth, mipLevel, x: x2, y: y2, z: z2, width, height } = options;
+    const glTarget = getWebGLCubeFaceTarget(this.glTarget, this.dimension, depth);
+    const glParameters = options.flipY ? { [37440]: true } : {};
+    this.gl.bindTexture(this.glTarget, this.handle);
+    withGLParameters(this.gl, glParameters, () => {
+      switch (this.dimension) {
+        case "2d":
+        case "cube":
+          this.gl.texSubImage2D(glTarget, mipLevel, x2, y2, width, height, glFormat, glType, image);
+          break;
+        case "2d-array":
+        case "3d":
+          this.gl.texSubImage3D(glTarget, mipLevel, x2, y2, z2, width, height, depth, glFormat, glType, image);
+          break;
+        default:
+      }
+    });
+    this.gl.bindTexture(this.glTarget, null);
+    return { width: options.width, height: options.height };
+  }
+  // WEBGL SPECIFIC
+  generateMipmapsWebGL(options) {
+    const isFilterableAndRenderable = this.device.isTextureFormatRenderable(this.props.format) && this.device.isTextureFormatFilterable(this.props.format);
+    if (!isFilterableAndRenderable) {
+      log.warn(`${this} is not renderable or filterable, may not be able to generate mipmaps`)();
+      if (!(options == null ? void 0 : options.force)) {
+        return;
+      }
+    }
+    try {
+      this.gl.bindTexture(this.glTarget, this.handle);
+      this.gl.generateMipmap(this.glTarget);
+    } catch (error) {
+      log.warn(`Error generating mipmap for ${this}: ${error.message}`)();
+    } finally {
+      this.gl.bindTexture(this.glTarget, null);
+    }
+  }
+  // INTERNAL
+  /**
+   * Sets sampler parameters on texture
+   */
+  _setSamplerParameters(parameters) {
+    log.log(2, `${this.id} sampler parameters`, this.device.getGLKeys(parameters))();
+    this.gl.bindTexture(this.glTarget, this.handle);
+    for (const [pname, pvalue] of Object.entries(parameters)) {
+      const param = Number(pname);
+      const value = pvalue;
+      switch (param) {
+        case 33082:
+        case 33083:
+          this.gl.texParameterf(this.glTarget, param, value);
+          break;
+        case 10240:
+        case 10241:
+          this.gl.texParameteri(this.glTarget, param, value);
+          break;
+        case 10242:
+        case 10243:
+        case 32882:
+          this.gl.texParameteri(this.glTarget, param, value);
+          break;
+        case 34046:
+          if (this.device.features.has("texture-filterable-anisotropic-webgl")) {
+            this.gl.texParameteri(this.glTarget, param, value);
+          }
+          break;
+        case 34892:
+        case 34893:
+          this.gl.texParameteri(this.glTarget, param, value);
+          break;
+      }
+    }
+    this.gl.bindTexture(this.glTarget, null);
+  }
+  _getActiveUnit() {
+    return this.gl.getParameter(34016) - 33984;
+  }
+  _bind(_textureUnit) {
+    const { gl: gl2 } = this;
+    if (_textureUnit !== void 0) {
+      this._textureUnit = _textureUnit;
+      gl2.activeTexture(33984 + _textureUnit);
+    }
+    gl2.bindTexture(this.glTarget, this.handle);
+    return _textureUnit;
+  }
+  _unbind(_textureUnit) {
+    const { gl: gl2 } = this;
+    if (_textureUnit !== void 0) {
+      this._textureUnit = _textureUnit;
+      gl2.activeTexture(33984 + _textureUnit);
+    }
+    gl2.bindTexture(this.glTarget, null);
+    return _textureUnit;
+  }
+}
+function getWebGLTextureTarget(dimension) {
+  switch (dimension) {
+    case "1d":
+      break;
+    case "2d":
+      return 3553;
+    case "3d":
+      return 32879;
+    case "cube":
+      return 34067;
+    case "2d-array":
+      return 35866;
+  }
+  throw new Error(dimension);
+}
+function getWebGLCubeFaceTarget(glTarget, dimension, level) {
+  return dimension === "cube" ? 34069 + level : glTarget;
+}
+function convertDataTypeToGLDataType(normalizedType) {
+  return NORMALIZED_SHADER_TYPE_TO_WEBGL[normalizedType];
+}
+function convertGLUniformTypeToShaderVariableType(glUniformType) {
+  return WEBGL_SHADER_TYPES[glUniformType];
+}
+function isGLSamplerType(type) {
+  return Boolean(WEBGL_SAMPLER_TO_TEXTURE_BINDINGS[type]);
+}
+function getTextureBindingFromGLSamplerType(glSamplerType) {
+  return WEBGL_SAMPLER_TO_TEXTURE_BINDINGS[glSamplerType];
+}
+const WEBGL_SHADER_TYPES = {
+  [5126]: "f32",
+  [35664]: "vec2<f32>",
+  [35665]: "vec3<f32>",
+  [35666]: "vec4<f32>",
+  [5124]: "i32",
+  [35667]: "vec2<i32>",
+  [35668]: "vec3<i32>",
+  [35669]: "vec4<i32>",
+  [5125]: "u32",
+  [36294]: "vec2<u32>",
+  [36295]: "vec3<u32>",
+  [36296]: "vec4<u32>",
+  [35670]: "f32",
+  [35671]: "vec2<f32>",
+  [35672]: "vec3<f32>",
+  [35673]: "vec4<f32>",
+  // TODO - are sizes/components below correct?
+  [35674]: "mat2x2<f32>",
+  [35685]: "mat2x3<f32>",
+  [35686]: "mat2x4<f32>",
+  [35687]: "mat3x2<f32>",
+  [35675]: "mat3x3<f32>",
+  [35688]: "mat3x4<f32>",
+  [35689]: "mat4x2<f32>",
+  [35690]: "mat4x3<f32>",
+  [35676]: "mat4x4<f32>"
+};
+const WEBGL_SAMPLER_TO_TEXTURE_BINDINGS = {
+  [35678]: { viewDimension: "2d", sampleType: "float" },
+  [35680]: { viewDimension: "cube", sampleType: "float" },
+  [35679]: { viewDimension: "3d", sampleType: "float" },
+  [35682]: { viewDimension: "3d", sampleType: "depth" },
+  [36289]: { viewDimension: "2d-array", sampleType: "float" },
+  [36292]: { viewDimension: "2d-array", sampleType: "depth" },
+  [36293]: { viewDimension: "cube", sampleType: "float" },
+  [36298]: { viewDimension: "2d", sampleType: "sint" },
+  [36299]: { viewDimension: "3d", sampleType: "sint" },
+  [36300]: { viewDimension: "cube", sampleType: "sint" },
+  [36303]: { viewDimension: "2d-array", sampleType: "uint" },
+  [36306]: { viewDimension: "2d", sampleType: "uint" },
+  [36307]: { viewDimension: "3d", sampleType: "uint" },
+  [36308]: { viewDimension: "cube", sampleType: "uint" },
+  [36311]: { viewDimension: "2d-array", sampleType: "uint" }
+};
+const NORMALIZED_SHADER_TYPE_TO_WEBGL = {
+  uint8: 5121,
+  sint8: 5120,
+  unorm8: 5121,
+  snorm8: 5120,
+  uint16: 5123,
+  sint16: 5122,
+  unorm16: 5123,
+  snorm16: 5122,
+  uint32: 5125,
+  sint32: 5124,
+  // WebGPU does not support normalized 32 bit integer attributes
+  //  'unorm32': GL.UNSIGNED_INT,
+  //  'snorm32': GL.INT,
+  float16: 5131,
+  float32: 5126
+};
+function getShaderLayoutFromGLSL(gl2, program) {
+  const shaderLayout = {
+    attributes: [],
+    bindings: []
+  };
+  shaderLayout.attributes = readAttributeDeclarations(gl2, program);
+  const uniformBlocks = readUniformBlocks(gl2, program);
+  for (const uniformBlock2 of uniformBlocks) {
+    const uniforms2 = uniformBlock2.uniforms.map((uniform) => ({
+      name: uniform.name,
+      format: uniform.format,
+      byteOffset: uniform.byteOffset,
+      byteStride: uniform.byteStride,
+      arrayLength: uniform.arrayLength
+    }));
+    shaderLayout.bindings.push({
+      type: "uniform",
+      name: uniformBlock2.name,
+      group: 0,
+      location: uniformBlock2.location,
+      visibility: (uniformBlock2.vertex ? 1 : 0) & (uniformBlock2.fragment ? 2 : 0),
+      minBindingSize: uniformBlock2.byteLength,
+      uniforms: uniforms2
+    });
+  }
+  const uniforms = readUniformBindings(gl2, program);
+  let textureUnit = 0;
+  for (const uniform of uniforms) {
+    if (isGLSamplerType(uniform.type)) {
+      const { viewDimension, sampleType } = getTextureBindingFromGLSamplerType(uniform.type);
+      shaderLayout.bindings.push({
+        type: "texture",
+        name: uniform.name,
+        group: 0,
+        location: textureUnit,
+        viewDimension,
+        sampleType
+      });
+      uniform.textureUnit = textureUnit;
+      textureUnit += 1;
+    }
+  }
+  if (uniforms.length) {
+    shaderLayout.uniforms = uniforms;
+  }
+  const varyings = readVaryings(gl2, program);
+  if (varyings == null ? void 0 : varyings.length) {
+    shaderLayout.varyings = varyings;
+  }
+  return shaderLayout;
+}
+function readAttributeDeclarations(gl2, program) {
+  const attributes = [];
+  const count2 = gl2.getProgramParameter(program, 35721);
+  for (let index = 0; index < count2; index++) {
+    const activeInfo = gl2.getActiveAttrib(program, index);
+    if (!activeInfo) {
+      throw new Error("activeInfo");
+    }
+    const {
+      name: name2,
+      type: compositeType
+      /* , size*/
+    } = activeInfo;
+    const location2 = gl2.getAttribLocation(program, name2);
+    if (location2 >= 0) {
+      const attributeType = convertGLUniformTypeToShaderVariableType(compositeType);
+      const stepMode = /instance/i.test(name2) ? "instance" : "vertex";
+      attributes.push({
+        name: name2,
+        location: location2,
+        stepMode,
+        type: attributeType
+        // size - for arrays, size is the number of elements in the array
+      });
+    }
+  }
+  attributes.sort((a2, b2) => a2.location - b2.location);
+  return attributes;
+}
+function readVaryings(gl2, program) {
+  const varyings = [];
+  const count2 = gl2.getProgramParameter(program, 35971);
+  for (let location2 = 0; location2 < count2; location2++) {
+    const activeInfo = gl2.getTransformFeedbackVarying(program, location2);
+    if (!activeInfo) {
+      throw new Error("activeInfo");
+    }
+    const { name: name2, type: glUniformType, size } = activeInfo;
+    const uniformType = convertGLUniformTypeToShaderVariableType(glUniformType);
+    const { type, components } = getVariableShaderTypeInfo(uniformType);
+    varyings.push({ location: location2, name: name2, type, size: size * components });
+  }
+  varyings.sort((a2, b2) => a2.location - b2.location);
+  return varyings;
+}
+function readUniformBindings(gl2, program) {
+  const uniforms = [];
+  const uniformCount = gl2.getProgramParameter(program, 35718);
+  for (let i2 = 0; i2 < uniformCount; i2++) {
+    const activeInfo = gl2.getActiveUniform(program, i2);
+    if (!activeInfo) {
+      throw new Error("activeInfo");
+    }
+    const { name: rawName, size, type } = activeInfo;
+    const { name: name2, isArray: isArray2 } = parseUniformName(rawName);
+    let webglLocation = gl2.getUniformLocation(program, name2);
+    const uniformInfo = {
+      // WebGL locations are uniquely typed but just numbers
+      location: webglLocation,
+      name: name2,
+      size,
+      type,
+      isArray: isArray2
+    };
+    uniforms.push(uniformInfo);
+    if (uniformInfo.size > 1) {
+      for (let j2 = 0; j2 < uniformInfo.size; j2++) {
+        const elementName = `${name2}[${j2}]`;
+        webglLocation = gl2.getUniformLocation(program, elementName);
+        const arrayElementUniformInfo = {
+          ...uniformInfo,
+          name: elementName,
+          location: webglLocation
+        };
+        uniforms.push(arrayElementUniformInfo);
+      }
+    }
+  }
+  return uniforms;
+}
+function readUniformBlocks(gl2, program) {
+  const getBlockParameter = (blockIndex, pname) => gl2.getActiveUniformBlockParameter(program, blockIndex, pname);
+  const uniformBlocks = [];
+  const blockCount = gl2.getProgramParameter(program, 35382);
+  for (let blockIndex = 0; blockIndex < blockCount; blockIndex++) {
+    const blockInfo = {
+      name: gl2.getActiveUniformBlockName(program, blockIndex) || "",
+      location: getBlockParameter(blockIndex, 35391),
+      byteLength: getBlockParameter(blockIndex, 35392),
+      vertex: getBlockParameter(blockIndex, 35396),
+      fragment: getBlockParameter(blockIndex, 35398),
+      uniformCount: getBlockParameter(blockIndex, 35394),
+      uniforms: []
+    };
+    const uniformIndices = getBlockParameter(blockIndex, 35395) || [];
+    const uniformType = gl2.getActiveUniforms(program, uniformIndices, 35383);
+    const uniformArrayLength = gl2.getActiveUniforms(program, uniformIndices, 35384);
+    const uniformOffset = gl2.getActiveUniforms(program, uniformIndices, 35387);
+    const uniformStride = gl2.getActiveUniforms(program, uniformIndices, 35388);
+    for (let i2 = 0; i2 < blockInfo.uniformCount; ++i2) {
+      const activeInfo = gl2.getActiveUniform(program, uniformIndices[i2]);
+      if (!activeInfo) {
+        throw new Error("activeInfo");
+      }
+      const format = convertGLUniformTypeToShaderVariableType(uniformType[i2]);
+      blockInfo.uniforms.push({
+        name: activeInfo.name,
+        format,
+        type: uniformType[i2],
+        arrayLength: uniformArrayLength[i2],
+        byteOffset: uniformOffset[i2],
+        byteStride: uniformStride[i2]
+        // matrixStride: uniformStride[i],
+        // rowMajor: uniformRowMajor[i]
+      });
+    }
+    uniformBlocks.push(blockInfo);
+  }
+  uniformBlocks.sort((a2, b2) => a2.location - b2.location);
+  return uniformBlocks;
+}
+function parseUniformName(name2) {
+  if (name2[name2.length - 1] !== "]") {
+    return {
+      name: name2,
+      length: 1,
+      isArray: false
+    };
+  }
+  const UNIFORM_NAME_REGEXP = /([^[]*)(\[[0-9]+\])?/;
+  const matches2 = UNIFORM_NAME_REGEXP.exec(name2);
+  if (!matches2 || matches2.length < 2) {
+    throw new Error(`Failed to parse GLSL uniform name ${name2}`);
+  }
+  return {
+    name: matches2[1],
+    length: matches2[2] ? 1 : 0,
+    isArray: Boolean(matches2[2])
+  };
+}
+function setUniform(gl2, location2, type, value) {
+  const gl22 = gl2;
+  let uniformValue = value;
+  if (uniformValue === true) {
+    uniformValue = 1;
+  }
+  if (uniformValue === false) {
+    uniformValue = 0;
+  }
+  const arrayValue = typeof uniformValue === "number" ? [uniformValue] : uniformValue;
+  switch (type) {
+    case 35678:
+    case 35680:
+    case 35679:
+    case 35682:
+    case 36289:
+    case 36292:
+    case 36293:
+    case 36298:
+    case 36299:
+    case 36300:
+    case 36303:
+    case 36306:
+    case 36307:
+    case 36308:
+    case 36311:
+      if (typeof value !== "number") {
+        throw new Error("samplers must be set to integers");
+      }
+      return gl2.uniform1i(location2, value);
+    case 5126:
+      return gl2.uniform1fv(location2, arrayValue);
+    case 35664:
+      return gl2.uniform2fv(location2, arrayValue);
+    case 35665:
+      return gl2.uniform3fv(location2, arrayValue);
+    case 35666:
+      return gl2.uniform4fv(location2, arrayValue);
+    case 5124:
+      return gl2.uniform1iv(location2, arrayValue);
+    case 35667:
+      return gl2.uniform2iv(location2, arrayValue);
+    case 35668:
+      return gl2.uniform3iv(location2, arrayValue);
+    case 35669:
+      return gl2.uniform4iv(location2, arrayValue);
+    case 35670:
+      return gl2.uniform1iv(location2, arrayValue);
+    case 35671:
+      return gl2.uniform2iv(location2, arrayValue);
+    case 35672:
+      return gl2.uniform3iv(location2, arrayValue);
+    case 35673:
+      return gl2.uniform4iv(location2, arrayValue);
+    case 5125:
+      return gl22.uniform1uiv(location2, arrayValue, 1);
+    case 36294:
+      return gl22.uniform2uiv(location2, arrayValue, 2);
+    case 36295:
+      return gl22.uniform3uiv(location2, arrayValue, 3);
+    case 36296:
+      return gl22.uniform4uiv(location2, arrayValue, 4);
+    case 35674:
+      return gl2.uniformMatrix2fv(location2, false, arrayValue);
+    case 35675:
+      return gl2.uniformMatrix3fv(location2, false, arrayValue);
+    case 35676:
+      return gl2.uniformMatrix4fv(location2, false, arrayValue);
+    case 35685:
+      return gl22.uniformMatrix2x3fv(location2, false, arrayValue);
+    case 35686:
+      return gl22.uniformMatrix2x4fv(location2, false, arrayValue);
+    case 35687:
+      return gl22.uniformMatrix3x2fv(location2, false, arrayValue);
+    case 35688:
+      return gl22.uniformMatrix3x4fv(location2, false, arrayValue);
+    case 35689:
+      return gl22.uniformMatrix4x2fv(location2, false, arrayValue);
+    case 35690:
+      return gl22.uniformMatrix4x3fv(location2, false, arrayValue);
+  }
+  throw new Error("Illegal uniform");
+}
+function getGLDrawMode(topology) {
+  switch (topology) {
+    case "point-list":
+      return 0;
+    case "line-list":
+      return 1;
+    case "line-strip":
+      return 3;
+    case "triangle-list":
+      return 4;
+    case "triangle-strip":
+      return 5;
+    default:
+      throw new Error(topology);
+  }
+}
+function getGLPrimitive(topology) {
+  switch (topology) {
+    case "point-list":
+      return 0;
+    case "line-list":
+      return 1;
+    case "line-strip":
+      return 1;
+    case "triangle-list":
+      return 4;
+    case "triangle-strip":
+      return 4;
+    default:
+      throw new Error(topology);
+  }
+}
+const LOG_PROGRAM_PERF_PRIORITY = 4;
+class WEBGLRenderPipeline extends RenderPipeline {
+  constructor(device, props) {
+    super(device, props);
+    /** The WebGL device that created this render pipeline */
+    __publicField(this, "device");
+    /** Handle to underlying WebGL program */
+    __publicField(this, "handle");
+    /** vertex shader */
+    __publicField(this, "vs");
+    /** fragment shader */
+    __publicField(this, "fs");
+    /** The layout extracted from shader by WebGL introspection APIs */
+    __publicField(this, "introspectedLayout");
+    /** Uniforms set on this model */
+    __publicField(this, "uniforms", {});
+    /** Bindings set on this model */
+    __publicField(this, "bindings", {});
+    /** WebGL varyings */
+    __publicField(this, "varyings", null);
+    __publicField(this, "_uniformCount", 0);
+    __publicField(this, "_uniformSetters", {});
+    this.device = device;
+    this.handle = this.props.handle || this.device.gl.createProgram();
+    this.device._setWebGLDebugMetadata(this.handle, this, { spector: { id: this.props.id } });
+    this.vs = props.vs;
+    this.fs = props.fs;
+    const { varyings, bufferMode = 35981 } = props;
+    if (varyings && varyings.length > 0) {
+      this.varyings = varyings;
+      this.device.gl.transformFeedbackVaryings(this.handle, varyings, bufferMode);
+    }
+    this._linkShaders();
+    log.time(3, `RenderPipeline ${this.id} - shaderLayout introspection`)();
+    this.introspectedLayout = getShaderLayoutFromGLSL(this.device.gl, this.handle);
+    log.timeEnd(3, `RenderPipeline ${this.id} - shaderLayout introspection`)();
+    this.shaderLayout = props.shaderLayout ? mergeShaderLayout(this.introspectedLayout, props.shaderLayout) : this.introspectedLayout;
+  }
+  // TODO are these used?
+  get [Symbol.toStringTag]() {
+    return "WEBGLRenderPipeline";
+  }
+  destroy() {
+    if (this.handle) {
+      this.device.gl.useProgram(null);
+      this.device.gl.deleteProgram(this.handle);
+      this.destroyed = true;
+      this.handle.destroyed = true;
+      this.handle = null;
+    }
+  }
+  /**
+   * Bindings include: textures, samplers and uniform buffers
+   * @todo needed for portable model
+   */
+  setBindings(bindings, options) {
+    for (const [name2, value] of Object.entries(bindings)) {
+      const binding = this.shaderLayout.bindings.find((binding_) => binding_.name === name2) || this.shaderLayout.bindings.find((binding_) => binding_.name === `${name2}Uniforms`);
+      if (!binding) {
+        const validBindings = this.shaderLayout.bindings.map((binding_) => `"${binding_.name}"`).join(", ");
+        if (!(options == null ? void 0 : options.disableWarnings)) {
+          log.warn(`No binding "${name2}" in render pipeline "${this.id}", expected one of ${validBindings}`, value)();
+        }
+        continue;
+      }
+      if (!value) {
+        log.warn(`Unsetting binding "${name2}" in render pipeline "${this.id}"`)();
+      }
+      switch (binding.type) {
+        case "uniform":
+          if (!(value instanceof WEBGLBuffer) && !(value.buffer instanceof WEBGLBuffer)) {
+            throw new Error("buffer value");
+          }
+          break;
+        case "texture":
+          if (!(value instanceof WEBGLTextureView || value instanceof WEBGLTexture || value instanceof WEBGLFramebuffer)) {
+            throw new Error(`${this} Bad texture binding for ${name2}`);
+          }
+          break;
+        case "sampler":
+          log.warn(`Ignoring sampler ${name2}`)();
+          break;
+        default:
+          throw new Error(binding.type);
+      }
+      this.bindings[name2] = value;
+    }
+  }
+  /** @todo needed for portable model
+   * @note The WebGL API is offers many ways to draw things
+   * This function unifies those ways into a single call using common parameters with sane defaults
+   */
+  draw(options) {
+    var _a3;
+    const {
+      renderPass,
+      parameters = this.props.parameters,
+      topology = this.props.topology,
+      vertexArray,
+      vertexCount,
+      // indexCount,
+      instanceCount,
+      isInstanced = false,
+      firstVertex = 0,
+      // firstIndex,
+      // firstInstance,
+      // baseVertex,
+      transformFeedback
+    } = options;
+    const glDrawMode = getGLDrawMode(topology);
+    const isIndexed = Boolean(vertexArray.indexBuffer);
+    const glIndexType = (_a3 = vertexArray.indexBuffer) == null ? void 0 : _a3.glIndexType;
+    if (this.linkStatus !== "success") {
+      log.info(2, `RenderPipeline:${this.id}.draw() aborted - waiting for shader linking`)();
+      return false;
+    }
+    if (!this._areTexturesRenderable()) {
+      log.info(2, `RenderPipeline:${this.id}.draw() aborted - textures not yet loaded`)();
+      return false;
+    }
+    this.device.gl.useProgram(this.handle);
+    vertexArray.bindBeforeRender(renderPass);
+    if (transformFeedback) {
+      transformFeedback.begin(this.props.topology);
+    }
+    this._applyBindings();
+    this._applyUniforms();
+    const webglRenderPass = renderPass;
+    withDeviceAndGLParameters(this.device, parameters, webglRenderPass.glParameters, () => {
+      if (isIndexed && isInstanced) {
+        this.device.gl.drawElementsInstanced(
+          glDrawMode,
+          vertexCount || 0,
+          // indexCount?
+          glIndexType,
+          firstVertex,
+          instanceCount || 0
+        );
+      } else if (isIndexed) {
+        this.device.gl.drawElements(glDrawMode, vertexCount || 0, glIndexType, firstVertex);
+      } else if (isInstanced) {
+        this.device.gl.drawArraysInstanced(glDrawMode, firstVertex, vertexCount || 0, instanceCount || 0);
+      } else {
+        this.device.gl.drawArrays(glDrawMode, firstVertex, vertexCount || 0);
+      }
+      if (transformFeedback) {
+        transformFeedback.end();
+      }
+    });
+    vertexArray.unbindAfterRender(renderPass);
+    return true;
+  }
+  // PRIVATE METHODS
+  // setAttributes(attributes: Record<string, Buffer>): void {}
+  // setBindings(bindings: Record<string, Binding>): void {}
+  async _linkShaders() {
+    const { gl: gl2 } = this.device;
+    gl2.attachShader(this.handle, this.vs.handle);
+    gl2.attachShader(this.handle, this.fs.handle);
+    log.time(LOG_PROGRAM_PERF_PRIORITY, `linkProgram for ${this.id}`)();
+    gl2.linkProgram(this.handle);
+    log.timeEnd(LOG_PROGRAM_PERF_PRIORITY, `linkProgram for ${this.id}`)();
+    if (log.level === 0) ;
+    if (!this.device.features.has("compilation-status-async-webgl")) {
+      const status2 = this._getLinkStatus();
+      this._reportLinkStatus(status2);
+      return;
+    }
+    log.once(1, "RenderPipeline linking is asynchronous")();
+    await this._waitForLinkComplete();
+    log.info(2, `RenderPipeline ${this.id} - async linking complete: ${this.linkStatus}`)();
+    const status = this._getLinkStatus();
+    this._reportLinkStatus(status);
+  }
+  /** Report link status. First, check for shader compilation failures if linking fails */
+  async _reportLinkStatus(status) {
+    var _a3;
+    switch (status) {
+      case "success":
+        return;
+      default:
+        const errorType = status === "link-error" ? "Link error" : "Validation error";
+        switch (this.vs.compilationStatus) {
+          case "error":
+            this.vs.debugShader();
+            throw new Error(`${this} ${errorType} during compilation of ${this.vs}`);
+          case "pending":
+            await this.vs.asyncCompilationStatus;
+            this.vs.debugShader();
+            break;
+        }
+        switch ((_a3 = this.fs) == null ? void 0 : _a3.compilationStatus) {
+          case "error":
+            this.fs.debugShader();
+            throw new Error(`${this} ${errorType} during compilation of ${this.fs}`);
+          case "pending":
+            await this.fs.asyncCompilationStatus;
+            this.fs.debugShader();
+            break;
+        }
+        const linkErrorLog = this.device.gl.getProgramInfoLog(this.handle);
+        this.device.reportError(new Error(`${errorType} during ${status}: ${linkErrorLog}`), this)();
+        this.device.debug();
+    }
+  }
+  /**
+   * Get the shader compilation status
+   * TODO - Load log even when no error reported, to catch warnings?
+   * https://gamedev.stackexchange.com/questions/30429/how-to-detect-glsl-warnings
+   */
+  _getLinkStatus() {
+    const { gl: gl2 } = this.device;
+    const linked = gl2.getProgramParameter(this.handle, 35714);
+    if (!linked) {
+      this.linkStatus = "error";
+      return "link-error";
+    }
+    gl2.validateProgram(this.handle);
+    const validated = gl2.getProgramParameter(this.handle, 35715);
+    if (!validated) {
+      this.linkStatus = "error";
+      return "validation-error";
+    }
+    this.linkStatus = "success";
+    return "success";
+  }
+  /** Use KHR_parallel_shader_compile extension if available */
+  async _waitForLinkComplete() {
+    const waitMs = async (ms) => await new Promise((resolve) => setTimeout(resolve, ms));
+    const DELAY_MS = 10;
+    if (!this.device.features.has("compilation-status-async-webgl")) {
+      await waitMs(DELAY_MS);
+      return;
+    }
+    const { gl: gl2 } = this.device;
+    for (; ; ) {
+      const complete = gl2.getProgramParameter(this.handle, 37297);
+      if (complete) {
+        return;
+      }
+      await waitMs(DELAY_MS);
+    }
+  }
+  /**
+   * Checks if all texture-values uniforms are renderable (i.e. loaded)
+   * Update a texture if needed (e.g. from video)
+   * Note: This is currently done before every draw call
+   */
+  _areTexturesRenderable() {
+    let texturesRenderable = true;
+    for (const bindingInfo of this.shaderLayout.bindings) {
+      if (!this.bindings[bindingInfo.name] && !this.bindings[bindingInfo.name.replace(/Uniforms$/, "")]) {
+        log.warn(`Binding ${bindingInfo.name} not found in ${this.id}`)();
+        texturesRenderable = false;
+      }
+    }
+    return texturesRenderable;
+  }
+  /** Apply any bindings (before each draw call) */
+  _applyBindings() {
+    if (this.linkStatus !== "success") {
+      return;
+    }
+    const { gl: gl2 } = this.device;
+    gl2.useProgram(this.handle);
+    let textureUnit = 0;
+    let uniformBufferIndex = 0;
+    for (const binding of this.shaderLayout.bindings) {
+      const value = this.bindings[binding.name] || this.bindings[binding.name.replace(/Uniforms$/, "")];
+      if (!value) {
+        throw new Error(`No value for binding ${binding.name} in ${this.id}`);
+      }
+      switch (binding.type) {
+        case "uniform":
+          const { name: name2 } = binding;
+          const location2 = gl2.getUniformBlockIndex(this.handle, name2);
+          if (location2 === 4294967295) {
+            throw new Error(`Invalid uniform block name ${name2}`);
+          }
+          gl2.uniformBlockBinding(this.handle, uniformBufferIndex, location2);
+          if (value instanceof WEBGLBuffer) {
+            gl2.bindBufferBase(35345, uniformBufferIndex, value.handle);
+          } else {
+            gl2.bindBufferRange(
+              35345,
+              uniformBufferIndex,
+              // @ts-expect-error
+              value.buffer.handle,
+              // @ts-expect-error
+              value.offset || 0,
+              // @ts-expect-error
+              value.size || value.buffer.byteLength - value.offset
+            );
+          }
+          uniformBufferIndex += 1;
+          break;
+        case "texture":
+          if (!(value instanceof WEBGLTextureView || value instanceof WEBGLTexture || value instanceof WEBGLFramebuffer)) {
+            throw new Error("texture");
+          }
+          let texture;
+          if (value instanceof WEBGLTextureView) {
+            texture = value.texture;
+          } else if (value instanceof WEBGLTexture) {
+            texture = value;
+          } else if (value instanceof WEBGLFramebuffer && value.colorAttachments[0] instanceof WEBGLTextureView) {
+            log.warn("Passing framebuffer in texture binding may be deprecated. Use fbo.colorAttachments[0] instead")();
+            texture = value.colorAttachments[0].texture;
+          } else {
+            throw new Error("No texture");
+          }
+          gl2.activeTexture(33984 + textureUnit);
+          gl2.bindTexture(texture.glTarget, texture.handle);
+          textureUnit += 1;
+          break;
+        case "sampler":
+          break;
+        case "storage":
+        case "read-only-storage":
+          throw new Error(`binding type '${binding.type}' not supported in WebGL`);
+      }
+    }
+  }
+  /**
+   * Due to program sharing, uniforms need to be reset before every draw call
+   * (though caching will avoid redundant WebGL calls)
+   */
+  _applyUniforms() {
+    for (const uniformLayout of this.shaderLayout.uniforms || []) {
+      const { name: name2, location: location2, type, textureUnit } = uniformLayout;
+      const value = this.uniforms[name2] ?? textureUnit;
+      if (value !== void 0) {
+        setUniform(this.device.gl, location2, type, value);
+      }
+    }
+  }
+}
+function mergeShaderLayout(baseLayout, overrideLayout) {
+  const mergedLayout = {
+    ...baseLayout,
+    attributes: baseLayout.attributes.map((attribute) => ({ ...attribute }))
+  };
+  for (const attribute of (overrideLayout == null ? void 0 : overrideLayout.attributes) || []) {
+    const baseAttribute = mergedLayout.attributes.find((attr) => attr.name === attribute.name);
+    if (!baseAttribute) {
+      log.warn(`shader layout attribute ${attribute.name} not present in shader`);
+    } else {
+      baseAttribute.type = attribute.type || baseAttribute.type;
+      baseAttribute.stepMode = attribute.stepMode || baseAttribute.stepMode;
+    }
+  }
+  return mergedLayout;
+}
+class WEBGLCommandBuffer extends CommandBuffer {
+  constructor(device) {
+    super(device, {});
+    __publicField(this, "device");
+    __publicField(this, "handle", null);
+    __publicField(this, "commands", []);
+    this.device = device;
+  }
+  _executeCommands(commands = this.commands) {
+    for (const command of commands) {
+      switch (command.name) {
+        case "copy-buffer-to-buffer":
+          _copyBufferToBuffer(this.device, command.options);
+          break;
+        case "copy-buffer-to-texture":
+          _copyBufferToTexture(this.device, command.options);
+          break;
+        case "copy-texture-to-buffer":
+          _copyTextureToBuffer(this.device, command.options);
+          break;
+        case "copy-texture-to-texture":
+          _copyTextureToTexture(this.device, command.options);
+          break;
+        default:
+          throw new Error(command.name);
+      }
+    }
+  }
+}
+function _copyBufferToBuffer(device, options) {
+  const source2 = options.sourceBuffer;
+  const destination = options.destinationBuffer;
+  device.gl.bindBuffer(36662, source2.handle);
+  device.gl.bindBuffer(36663, destination.handle);
+  device.gl.copyBufferSubData(36662, 36663, options.sourceOffset ?? 0, options.destinationOffset ?? 0, options.size);
+  device.gl.bindBuffer(36662, null);
+  device.gl.bindBuffer(36663, null);
+}
+function _copyBufferToTexture(device, options) {
+  throw new Error("Not implemented");
+}
+function _copyTextureToBuffer(device, options) {
+  const {
+    /** Texture to copy to/from. */
+    sourceTexture,
+    /**  Mip-map level of the texture to copy to/from. (Default 0) */
+    mipLevel = 0,
+    /** Defines which aspects of the texture to copy to/from. */
+    aspect = "all",
+    /** Width to copy */
+    width = options.sourceTexture.width,
+    /** Height to copy */
+    height = options.sourceTexture.height,
+    depthOrArrayLayers = 0,
+    /** Defines the origin of the copy - the minimum corner of the texture sub-region to copy to/from. */
+    origin = [0, 0],
+    /** Destination buffer */
+    destinationBuffer,
+    /** Offset, in bytes, from the beginning of the buffer to the start of the image data (default 0) */
+    byteOffset = 0,
+    /**
+     * The stride, in bytes, between the beginning of each block row and the subsequent block row.
+     * Required if there are multiple block rows (i.e. the copy height or depth is more than one block).
+     */
+    bytesPerRow,
+    /**
+     * Number of block rows per single image of the texture.
+     * rowsPerImage &times; bytesPerRow is the stride, in bytes, between the beginning of each image of data and the subsequent image.
+     * Required if there are multiple images (i.e. the copy depth is more than one).
+     */
+    rowsPerImage
+  } = options;
+  if (aspect !== "all") {
+    throw new Error("aspect not supported in WebGL");
+  }
+  if (mipLevel !== 0 || depthOrArrayLayers !== 0 || bytesPerRow || rowsPerImage) {
+    throw new Error("not implemented");
+  }
+  const { framebuffer, destroyFramebuffer } = getFramebuffer$2(sourceTexture);
+  let prevHandle;
+  try {
+    const webglBuffer = destinationBuffer;
+    const sourceWidth = width || framebuffer.width;
+    const sourceHeight = height || framebuffer.height;
+    const sourceParams = getTextureFormatWebGL(framebuffer.colorAttachments[0].texture.props.format);
+    const sourceFormat = sourceParams.format;
+    const sourceType = sourceParams.type;
+    device.gl.bindBuffer(35051, webglBuffer.handle);
+    prevHandle = device.gl.bindFramebuffer(36160, framebuffer.handle);
+    device.gl.readPixels(origin[0], origin[1], sourceWidth, sourceHeight, sourceFormat, sourceType, byteOffset);
+  } finally {
+    device.gl.bindBuffer(35051, null);
+    if (prevHandle !== void 0) {
+      device.gl.bindFramebuffer(36160, prevHandle);
+    }
+    if (destroyFramebuffer) {
+      framebuffer.destroy();
+    }
+  }
+}
+function _copyTextureToTexture(device, options) {
+  const {
+    /** Texture to copy to/from. */
+    sourceTexture,
+    /**  Mip-map level of the texture to copy to (Default 0) */
+    destinationMipLevel = 0,
+    /** Defines which aspects of the texture to copy to/from. */
+    // aspect = 'all',
+    /** Defines the origin of the copy - the minimum corner of the texture sub-region to copy from. */
+    origin = [0, 0],
+    /** Defines the origin of the copy - the minimum corner of the texture sub-region to copy to. */
+    destinationOrigin = [0, 0],
+    /** Texture to copy to/from. */
+    destinationTexture
+    /**  Mip-map level of the texture to copy to/from. (Default 0) */
+    // destinationMipLevel = options.mipLevel,
+    /** Defines the origin of the copy - the minimum corner of the texture sub-region to copy to/from. */
+    // destinationOrigin = [0, 0],
+    /** Defines which aspects of the texture to copy to/from. */
+    // destinationAspect = options.aspect,
+  } = options;
+  let {
+    width = options.destinationTexture.width,
+    height = options.destinationTexture.height
+    // depthOrArrayLayers = 0
+  } = options;
+  const { framebuffer, destroyFramebuffer } = getFramebuffer$2(sourceTexture);
+  const [sourceX, sourceY] = origin;
+  const [destinationX, destinationY, destinationZ] = destinationOrigin;
+  const prevHandle = device.gl.bindFramebuffer(36160, framebuffer.handle);
+  let texture;
+  let textureTarget;
+  if (destinationTexture instanceof WEBGLTexture) {
+    texture = destinationTexture;
+    width = Number.isFinite(width) ? width : texture.width;
+    height = Number.isFinite(height) ? height : texture.height;
+    texture._bind(0);
+    textureTarget = texture.glTarget;
+  } else {
+    throw new Error("invalid destination");
+  }
+  switch (textureTarget) {
+    case 3553:
+    case 34067:
+      device.gl.copyTexSubImage2D(textureTarget, destinationMipLevel, destinationX, destinationY, sourceX, sourceY, width, height);
+      break;
+    case 35866:
+    case 32879:
+      device.gl.copyTexSubImage3D(textureTarget, destinationMipLevel, destinationX, destinationY, destinationZ, sourceX, sourceY, width, height);
+      break;
+  }
+  if (texture) {
+    texture._unbind();
+  }
+  device.gl.bindFramebuffer(36160, prevHandle);
+  if (destroyFramebuffer) {
+    framebuffer.destroy();
+  }
+}
+function getFramebuffer$2(source2) {
+  if (source2 instanceof Texture) {
+    const { width, height, id: id2 } = source2;
+    const framebuffer = source2.device.createFramebuffer({
+      id: `framebuffer-for-${id2}`,
+      width,
+      height,
+      colorAttachments: [source2]
+    });
+    return { framebuffer, destroyFramebuffer: true };
+  }
+  return { framebuffer: source2, destroyFramebuffer: false };
+}
+const COLOR_CHANNELS = [1, 2, 4, 8];
+class WEBGLRenderPass extends RenderPass {
+  constructor(device, props) {
+    var _a3;
+    super(device, props);
+    __publicField(this, "device");
+    __publicField(this, "handle", null);
+    /** Parameters that should be applied before each draw call */
+    __publicField(this, "glParameters", {});
+    this.device = device;
+    let viewport;
+    if (!((_a3 = props == null ? void 0 : props.parameters) == null ? void 0 : _a3.viewport)) {
+      if (props == null ? void 0 : props.framebuffer) {
+        const { width, height } = props.framebuffer;
+        viewport = [0, 0, width, height];
+      } else {
+        const [width, height] = device.getDefaultCanvasContext().getDrawingBufferSize();
+        viewport = [0, 0, width, height];
+      }
+    }
+    this.device.pushState();
+    this.setParameters({ viewport, ...this.props.parameters });
+    const webglFramebuffer = this.props.framebuffer;
+    if (this.props.framebuffer && (webglFramebuffer == null ? void 0 : webglFramebuffer.handle)) {
+      const drawBuffers = this.props.framebuffer.colorAttachments.map((_2, i2) => 36064 + i2);
+      this.device.gl.drawBuffers(drawBuffers);
+    } else {
+      this.device.gl.drawBuffers([1029]);
+    }
+    this.clear();
+  }
+  end() {
+    this.device.popState();
+  }
+  pushDebugGroup(groupLabel) {
+  }
+  popDebugGroup() {
+  }
+  insertDebugMarker(markerLabel) {
+  }
+  // beginOcclusionQuery(queryIndex: number): void;
+  // endOcclusionQuery(): void;
+  // executeBundles(bundles: Iterable<GPURenderBundle>): void;
+  /**
+   * Maps RenderPass parameters to GL parameters
+   */
+  setParameters(parameters = {}) {
+    const glParameters = { ...this.glParameters };
+    glParameters.framebuffer = this.props.framebuffer || null;
+    if (this.props.depthReadOnly) {
+      glParameters.depthMask = !this.props.depthReadOnly;
+    }
+    glParameters.stencilMask = this.props.stencilReadOnly ? 0 : 1;
+    glParameters[35977] = this.props.discard;
+    if (parameters.viewport) {
+      if (parameters.viewport.length >= 6) {
+        glParameters.viewport = parameters.viewport.slice(0, 4);
+        glParameters.depthRange = [
+          parameters.viewport[4],
+          parameters.viewport[5]
+        ];
+      } else {
+        glParameters.viewport = parameters.viewport;
+      }
+    }
+    if (parameters.scissorRect) {
+      glParameters.scissorTest = true;
+      glParameters.scissor = parameters.scissorRect;
+    }
+    if (parameters.blendConstant) {
+      glParameters.blendColor = parameters.blendConstant;
+    }
+    if (parameters.stencilReference) {
+      console.warn("RenderPassParameters.stencilReference not yet implemented in WebGL");
+      glParameters[2967] = parameters.stencilReference;
+    }
+    if ("colorMask" in parameters) {
+      glParameters.colorMask = COLOR_CHANNELS.map((channel) => Boolean(channel & parameters.colorMask));
+    }
+    this.glParameters = glParameters;
+    setGLParameters(this.device.gl, glParameters);
+  }
+  beginOcclusionQuery(queryIndex) {
+    const webglQuerySet = this.props.occlusionQuerySet;
+    webglQuerySet == null ? void 0 : webglQuerySet.beginOcclusionQuery();
+  }
+  endOcclusionQuery() {
+    const webglQuerySet = this.props.occlusionQuerySet;
+    webglQuerySet == null ? void 0 : webglQuerySet.endOcclusionQuery();
+  }
+  // PRIVATE
+  /**
+   * Optionally clears depth, color and stencil buffers based on parameters
+   */
+  clear() {
+    const glParameters = { ...this.glParameters };
+    let clearMask = 0;
+    if (this.props.clearColors) {
+      this.props.clearColors.forEach((color2, drawBufferIndex) => {
+        if (color2) {
+          this.clearColorBuffer(drawBufferIndex, color2);
+        }
+      });
+    }
+    if (this.props.clearColor !== false && this.props.clearColors === void 0) {
+      clearMask |= 16384;
+      glParameters.clearColor = this.props.clearColor;
+    }
+    if (this.props.clearDepth !== false) {
+      clearMask |= 256;
+      glParameters.clearDepth = this.props.clearDepth;
+    }
+    if (this.props.clearStencil !== false) {
+      clearMask |= 1024;
+      glParameters.clearStencil = this.props.clearStencil;
+    }
+    if (clearMask !== 0) {
+      withGLParameters(this.device.gl, glParameters, () => {
+        this.device.gl.clear(clearMask);
+      });
+    }
+  }
+  /**
+   * WebGL2 - clear a specific color buffer
+   */
+  clearColorBuffer(drawBuffer = 0, value = [0, 0, 0, 0]) {
+    withGLParameters(this.device.gl, { framebuffer: this.props.framebuffer }, () => {
+      switch (value.constructor) {
+        case Int8Array:
+        case Int16Array:
+        case Int32Array:
+          this.device.gl.clearBufferiv(6144, drawBuffer, value);
+          break;
+        case Uint8Array:
+        case Uint8ClampedArray:
+        case Uint16Array:
+        case Uint32Array:
+          this.device.gl.clearBufferuiv(6144, drawBuffer, value);
+          break;
+        case Float32Array:
+          this.device.gl.clearBufferfv(6144, drawBuffer, value);
+          break;
+        default:
+          throw new Error("clearColorBuffer: color must be typed array");
+      }
+    });
+  }
+}
+class WEBGLCommandEncoder extends CommandEncoder {
+  constructor(device, props) {
+    super(device, props);
+    __publicField(this, "device");
+    __publicField(this, "handle", null);
+    __publicField(this, "commandBuffer");
+    this.device = device;
+    this.commandBuffer = new WEBGLCommandBuffer(device);
+  }
+  destroy() {
+  }
+  finish() {
+    return this.commandBuffer;
+  }
+  beginRenderPass(props) {
+    return new WEBGLRenderPass(this.device, props);
+  }
+  beginComputePass(props) {
+    throw new Error("ComputePass not supported in WebGL");
+  }
+  copyBufferToBuffer(options) {
+    this.commandBuffer.commands.push({ name: "copy-buffer-to-buffer", options });
+  }
+  copyBufferToTexture(options) {
+    this.commandBuffer.commands.push({ name: "copy-buffer-to-texture", options });
+  }
+  copyTextureToBuffer(options) {
+    this.commandBuffer.commands.push({ name: "copy-texture-to-buffer", options });
+  }
+  copyTextureToTexture(options) {
+    this.commandBuffer.commands.push({ name: "copy-texture-to-texture", options });
+  }
+  // clearTexture(options: ClearTextureOptions): void {
+  //   this.commandBuffer.commands.push({name: 'copy-texture-to-texture', options});
+  // }
+  pushDebugGroup(groupLabel) {
+  }
+  popDebugGroup() {
+  }
+  insertDebugMarker(markerLabel) {
+  }
+  resolveQuerySet(querySet, destination, options) {
+  }
+}
+function fillArray(options) {
+  const { target, source: source2, start = 0, count: count2 = 1 } = options;
+  const length2 = source2.length;
+  const total = count2 * length2;
+  let copied = 0;
+  for (let i2 = start; copied < length2; copied++) {
+    target[i2++] = source2[copied];
+  }
+  while (copied < total) {
+    if (copied < total - copied) {
+      target.copyWithin(start + copied, start, start + copied);
+      copied *= 2;
+    } else {
+      target.copyWithin(start + copied, start, start + total - copied);
+      copied = total;
+    }
+  }
+  return options.target;
+}
+class WEBGLVertexArray extends VertexArray {
+  // Create a VertexArray
+  constructor(device, props) {
+    super(device, props);
+    __publicField(this, "device");
+    __publicField(this, "handle");
+    /** Attribute 0 buffer constant */
+    __publicField(this, "buffer", null);
+    __publicField(this, "bufferValue", null);
+    this.device = device;
+    this.handle = this.device.gl.createVertexArray();
+  }
+  get [Symbol.toStringTag]() {
+    return "VertexArray";
+  }
+  /** * Attribute 0 can not be disable on most desktop OpenGL based browsers */
+  static isConstantAttributeZeroSupported(device) {
+    return getBrowser() === "Chrome";
+  }
+  destroy() {
+    var _a3;
+    super.destroy();
+    if (this.buffer) {
+      (_a3 = this.buffer) == null ? void 0 : _a3.destroy();
+    }
+    if (this.handle) {
+      this.device.gl.deleteVertexArray(this.handle);
+      this.handle = void 0;
+    }
+  }
+  /**
+  // Set (bind/unbind) an elements buffer, for indexed rendering.
+  // Must be a Buffer bound to GL.ELEMENT_ARRAY_BUFFER or null. Constants not supported
+   *
+   * @param elementBuffer
+   */
+  setIndexBuffer(indexBuffer) {
+    const buffer = indexBuffer;
+    if (buffer && buffer.glTarget !== 34963) {
+      throw new Error("Use .setBuffer()");
+    }
+    this.device.gl.bindVertexArray(this.handle);
+    this.device.gl.bindBuffer(34963, buffer ? buffer.handle : null);
+    this.indexBuffer = buffer;
+    this.device.gl.bindVertexArray(null);
+  }
+  /** Set a location in vertex attributes array to a buffer, enables the location, sets divisor */
+  setBuffer(location2, attributeBuffer) {
+    const buffer = attributeBuffer;
+    if (buffer.glTarget === 34963) {
+      throw new Error("Use .setIndexBuffer()");
+    }
+    const { size, type, stride, offset, normalized, integer, divisor } = this._getAccessor(location2);
+    this.device.gl.bindVertexArray(this.handle);
+    this.device.gl.bindBuffer(34962, buffer.handle);
+    if (integer) {
+      this.device.gl.vertexAttribIPointer(location2, size, type, stride, offset);
+    } else {
+      this.device.gl.vertexAttribPointer(location2, size, type, normalized, stride, offset);
+    }
+    this.device.gl.bindBuffer(34962, null);
+    this.device.gl.enableVertexAttribArray(location2);
+    this.device.gl.vertexAttribDivisor(location2, divisor || 0);
+    this.attributes[location2] = buffer;
+    this.device.gl.bindVertexArray(null);
+  }
+  /** Set a location in vertex attributes array to a constant value, disables the location */
+  setConstantWebGL(location2, value) {
+    this._enable(location2, false);
+    this.attributes[location2] = value;
+  }
+  bindBeforeRender() {
+    this.device.gl.bindVertexArray(this.handle);
+    this._applyConstantAttributes();
+  }
+  unbindAfterRender() {
+    this.device.gl.bindVertexArray(null);
+  }
+  // Internal methods
+  /**
+   * Constant attributes need to be reset before every draw call
+   * Any attribute that is disabled in the current vertex array object
+   * is read from the context's global constant value for that attribute location.
+   * @note Constant attributes are only supported in WebGL, not in WebGPU
+   */
+  _applyConstantAttributes() {
+    for (let location2 = 0; location2 < this.maxVertexAttributes; ++location2) {
+      const constant = this.attributes[location2];
+      if (ArrayBuffer.isView(constant)) {
+        this.device.setConstantAttributeWebGL(location2, constant);
+      }
+    }
+  }
+  /**
+   * Set a location in vertex attributes array to a buffer, enables the location, sets divisor
+   * @note requires vertex array to be bound
+   */
+  // protected _setAttributeLayout(location: number): void {
+  //   const {size, type, stride, offset, normalized, integer, divisor} = this._getAccessor(location);
+  //   // WebGL2 supports *integer* data formats, i.e. GPU will see integer values
+  //   if (integer) {
+  //     this.device.gl.vertexAttribIPointer(location, size, type, stride, offset);
+  //   } else {
+  //     // Attaches ARRAY_BUFFER with specified buffer format to location
+  //     this.device.gl.vertexAttribPointer(location, size, type, normalized, stride, offset);
+  //   }
+  //   this.device.gl.vertexAttribDivisor(location, divisor || 0);
+  // }
+  /** Get an accessor from the  */
+  _getAccessor(location2) {
+    const attributeInfo = this.attributeInfos[location2];
+    if (!attributeInfo) {
+      throw new Error(`Unknown attribute location ${location2}`);
+    }
+    const glType = getGLFromVertexType(attributeInfo.bufferDataType);
+    return {
+      size: attributeInfo.bufferComponents,
+      type: glType,
+      stride: attributeInfo.byteStride,
+      offset: attributeInfo.byteOffset,
+      normalized: attributeInfo.normalized,
+      // it is the shader attribute declaration, not the vertex memory format,
+      // that determines if the data in the buffer will be treated as integers.
+      //
+      // Also note that WebGL supports assigning non-normalized integer data to floating point attributes,
+      // but as far as we can tell, WebGPU does not.
+      integer: attributeInfo.integer,
+      divisor: attributeInfo.stepMode === "instance" ? 1 : 0
+    };
+  }
+  /**
+   * Enabling an attribute location makes it reference the currently bound buffer
+   * Disabling an attribute location makes it reference the global constant value
+   * TODO - handle single values for size 1 attributes?
+   * TODO - convert classic arrays based on known type?
+   */
+  _enable(location2, enable2 = true) {
+    const canDisableAttributeZero = WEBGLVertexArray.isConstantAttributeZeroSupported(this.device);
+    const canDisableAttribute = canDisableAttributeZero || location2 !== 0;
+    if (enable2 || canDisableAttribute) {
+      location2 = Number(location2);
+      this.device.gl.bindVertexArray(this.handle);
+      if (enable2) {
+        this.device.gl.enableVertexAttribArray(location2);
+      } else {
+        this.device.gl.disableVertexAttribArray(location2);
+      }
+      this.device.gl.bindVertexArray(null);
+    }
+  }
+  /**
+   * Provide a means to create a buffer that is equivalent to a constant.
+   * NOTE: Desktop OpenGL cannot disable attribute 0.
+   * https://stackoverflow.com/questions/20305231/webgl-warning-attribute-0-is-disabled-
+   * this-has-significant-performance-penalty
+   */
+  getConstantBuffer(elementCount, value) {
+    const constantValue = normalizeConstantArrayValue(value);
+    const byteLength = constantValue.byteLength * elementCount;
+    const length2 = constantValue.length * elementCount;
+    if (this.buffer && byteLength !== this.buffer.byteLength) {
+      throw new Error(`Buffer size is immutable, byte length ${byteLength} !== ${this.buffer.byteLength}.`);
+    }
+    let updateNeeded = !this.buffer;
+    this.buffer = this.buffer || this.device.createBuffer({ byteLength });
+    updateNeeded || (updateNeeded = !compareConstantArrayValues$1(constantValue, this.bufferValue));
+    if (updateNeeded) {
+      const typedArray = getScratchArray(value.constructor, length2);
+      fillArray({ target: typedArray, source: constantValue, start: 0, count: length2 });
+      this.buffer.write(typedArray);
+      this.bufferValue = value;
+    }
+    return this.buffer;
+  }
+}
+function normalizeConstantArrayValue(arrayValue) {
+  if (Array.isArray(arrayValue)) {
+    return new Float32Array(arrayValue);
+  }
+  return arrayValue;
+}
+function compareConstantArrayValues$1(v1, v2) {
+  if (!v1 || !v2 || v1.length !== v2.length || v1.constructor !== v2.constructor) {
+    return false;
+  }
+  for (let i2 = 0; i2 < v1.length; ++i2) {
+    if (v1[i2] !== v2[i2]) {
+      return false;
+    }
+  }
+  return true;
+}
+class WEBGLTransformFeedback extends TransformFeedback {
+  constructor(device, props) {
+    super(device, props);
+    __publicField(this, "device");
+    __publicField(this, "gl");
+    __publicField(this, "handle");
+    /**
+     * NOTE: The Model already has this information while drawing, but
+     * TransformFeedback currently needs it internally, to look up
+     * varying information outside of a draw() call.
+     */
+    __publicField(this, "layout");
+    __publicField(this, "buffers", {});
+    __publicField(this, "unusedBuffers", {});
+    /**
+     * Allows us to avoid a Chrome bug where a buffer that is already bound to a
+     * different target cannot be bound to 'TRANSFORM_FEEDBACK_BUFFER' target.
+     * This a major workaround, see: https://github.com/KhronosGroup/WebGL/issues/2346
+     */
+    __publicField(this, "bindOnUse", true);
+    __publicField(this, "_bound", false);
+    this.device = device;
+    this.gl = device.gl;
+    this.handle = this.props.handle || this.gl.createTransformFeedback();
+    this.layout = this.props.layout;
+    if (props.buffers) {
+      this.setBuffers(props.buffers);
+    }
+    Object.seal(this);
+  }
+  destroy() {
+    this.gl.deleteTransformFeedback(this.handle);
+    super.destroy();
+  }
+  begin(topology = "point-list") {
+    this.gl.bindTransformFeedback(36386, this.handle);
+    if (this.bindOnUse) {
+      this._bindBuffers();
+    }
+    this.gl.beginTransformFeedback(getGLPrimitive(topology));
+  }
+  end() {
+    this.gl.endTransformFeedback();
+    if (this.bindOnUse) {
+      this._unbindBuffers();
+    }
+    this.gl.bindTransformFeedback(36386, null);
+  }
+  // SUBCLASS
+  setBuffers(buffers) {
+    this.buffers = {};
+    this.unusedBuffers = {};
+    this.bind(() => {
+      for (const bufferName in buffers) {
+        this.setBuffer(bufferName, buffers[bufferName]);
+      }
+    });
+  }
+  setBuffer(locationOrName, bufferOrRange) {
+    const location2 = this._getVaryingIndex(locationOrName);
+    const { buffer, byteLength, byteOffset } = this._getBufferRange(bufferOrRange);
+    if (location2 < 0) {
+      this.unusedBuffers[locationOrName] = buffer;
+      log.warn(`${this.id} unusedBuffers varying buffer ${locationOrName}`)();
+      return;
+    }
+    this.buffers[location2] = { buffer, byteLength, byteOffset };
+    if (!this.bindOnUse) {
+      this._bindBuffer(location2, buffer, byteOffset, byteLength);
+    }
+  }
+  getBuffer(locationOrName) {
+    if (isIndex(locationOrName)) {
+      return this.buffers[locationOrName] || null;
+    }
+    const location2 = this._getVaryingIndex(locationOrName);
+    return location2 >= 0 ? this.buffers[location2] : null;
+  }
+  bind(funcOrHandle = this.handle) {
+    if (typeof funcOrHandle !== "function") {
+      this.gl.bindTransformFeedback(36386, funcOrHandle);
+      return this;
+    }
+    let value;
+    if (!this._bound) {
+      this.gl.bindTransformFeedback(36386, this.handle);
+      this._bound = true;
+      value = funcOrHandle();
+      this._bound = false;
+      this.gl.bindTransformFeedback(36386, null);
+    } else {
+      value = funcOrHandle();
+    }
+    return value;
+  }
+  unbind() {
+    this.bind(null);
+  }
+  // PRIVATE METHODS
+  /** Extract offsets for bindBufferRange */
+  _getBufferRange(bufferOrRange) {
+    if (bufferOrRange instanceof WEBGLBuffer) {
+      return { buffer: bufferOrRange, byteOffset: 0, byteLength: bufferOrRange.byteLength };
+    }
+    const { buffer, byteOffset = 0, byteLength = bufferOrRange.buffer.byteLength } = bufferOrRange;
+    return { buffer, byteOffset, byteLength };
+  }
+  _getVaryingIndex(locationOrName) {
+    if (isIndex(locationOrName)) {
+      return Number(locationOrName);
+    }
+    for (const varying of this.layout.varyings || []) {
+      if (locationOrName === varying.name) {
+        return varying.location;
+      }
+    }
+    return -1;
+  }
+  /**
+   * Need to avoid chrome bug where buffer that is already bound to a different target
+   * cannot be bound to 'TRANSFORM_FEEDBACK_BUFFER' target.
+   */
+  _bindBuffers() {
+    for (const bufferIndex in this.buffers) {
+      const { buffer, byteLength, byteOffset } = this._getBufferRange(this.buffers[bufferIndex]);
+      this._bindBuffer(Number(bufferIndex), buffer, byteOffset, byteLength);
+    }
+  }
+  _unbindBuffers() {
+    for (const bufferIndex in this.buffers) {
+      this.gl.bindBufferBase(35982, Number(bufferIndex), null);
+    }
+  }
+  _bindBuffer(index, buffer, byteOffset = 0, byteLength) {
+    const handle = buffer && buffer.handle;
+    if (!handle || byteLength === void 0) {
+      this.gl.bindBufferBase(35982, index, handle);
+    } else {
+      this.gl.bindBufferRange(35982, index, handle, byteOffset, byteLength);
+    }
+  }
+}
+function isIndex(value) {
+  if (typeof value === "number") {
+    return Number.isInteger(value);
+  }
+  return /^\d+$/.test(value);
+}
+class WEBGLQuerySet extends QuerySet {
+  // Create a query class
+  constructor(device, props) {
+    super(device, props);
+    __publicField(this, "device");
+    __publicField(this, "handle");
+    __publicField(this, "target", null);
+    __publicField(this, "_queryPending", false);
+    __publicField(this, "_pollingPromise", null);
+    this.device = device;
+    if (props.count > 1) {
+      throw new Error("WebGL QuerySet can only have one value");
+    }
+    const handle = this.device.gl.createQuery();
+    if (!handle) {
+      throw new Error("WebGL query not supported");
+    }
+    this.handle = handle;
+    Object.seal(this);
+  }
+  get [Symbol.toStringTag]() {
+    return "Query";
+  }
+  destroy() {
+    this.device.gl.deleteQuery(this.handle);
+  }
+  // FOR RENDER PASS AND COMMAND ENCODER
+  /**
+   * Shortcut for timer query (dependent on extension in both WebGL1 and 2)
+   * Measures GPU time delta between this call and a matching `end` call in the
+   * GPU instruction stream.
+   */
+  beginTimestampQuery() {
+    return this._begin(35007);
+  }
+  endTimestampQuery() {
+    this._end();
+  }
+  // Shortcut for occlusion queries
+  beginOcclusionQuery(options) {
+    return this._begin((options == null ? void 0 : options.conservative) ? 36202 : 35887);
+  }
+  endOcclusionQuery() {
+    this._end();
+  }
+  // Shortcut for transformFeedbackQuery
+  beginTransformFeedbackQuery() {
+    return this._begin(35976);
+  }
+  endTransformFeedbackQuery() {
+    this._end();
+  }
+  async resolveQuery() {
+    const value = await this.pollQuery();
+    return [value];
+  }
+  // PRIVATE METHODS
+  /**
+   * Due to OpenGL API limitations, after calling `begin()` on one Query
+   * instance, `end()` must be called on that same instance before
+   * calling `begin()` on another query. While there can be multiple
+   * outstanding queries representing disjoint `begin()`/`end()` intervals.
+   * It is not possible to interleave or overlap `begin` and `end` calls.
+   */
+  _begin(target) {
+    if (this._queryPending) {
+      return;
+    }
+    this.target = target;
+    this.device.gl.beginQuery(this.target, this.handle);
+    return;
+  }
+  // ends the current query
+  _end() {
+    if (this._queryPending) {
+      return;
+    }
+    if (this.target) {
+      this.device.gl.endQuery(this.target);
+      this.target = null;
+      this._queryPending = true;
+    }
+    return;
+  }
+  // Returns true if the query result is available
+  isResultAvailable() {
+    if (!this._queryPending) {
+      return false;
+    }
+    const resultAvailable = this.device.gl.getQueryParameter(this.handle, 34919);
+    if (resultAvailable) {
+      this._queryPending = false;
+    }
+    return resultAvailable;
+  }
+  // Timing query is disjoint, i.e. results are invalid
+  isTimerDisjoint() {
+    return this.device.gl.getParameter(36795);
+  }
+  // Returns query result.
+  getResult() {
+    return this.device.gl.getQueryParameter(this.handle, 34918);
+  }
+  // Returns the query result, converted to milliseconds to match JavaScript conventions.
+  getTimerMilliseconds() {
+    return this.getResult() / 1e6;
+  }
+  // Polls the query
+  pollQuery(limit = Number.POSITIVE_INFINITY) {
+    if (this._pollingPromise) {
+      return this._pollingPromise;
+    }
+    let counter2 = 0;
+    this._pollingPromise = new Promise((resolve, reject) => {
+      const poll = () => {
+        if (this.isResultAvailable()) {
+          resolve(this.getResult());
+          this._pollingPromise = null;
+        } else if (counter2++ > limit) {
+          reject("Timed out");
+          this._pollingPromise = null;
+        } else {
+          requestAnimationFrame(poll);
+        }
+      };
+      requestAnimationFrame(poll);
+    });
+    return this._pollingPromise;
+  }
+}
+function glFormatToComponents(format) {
+  switch (format) {
+    case 6406:
+    case 33326:
+    case 6403:
+    case 36244:
+      return 1;
+    case 33339:
+    case 33340:
+    case 33328:
+    case 33320:
+    case 33319:
+      return 2;
+    case 6407:
+    case 36248:
+    case 34837:
+      return 3;
+    case 6408:
+    case 36249:
+    case 34836:
+      return 4;
+    default:
+      return 0;
+  }
+}
+function glTypeToBytes(type) {
+  switch (type) {
+    case 5121:
+      return 1;
+    case 33635:
+    case 32819:
+    case 32820:
+      return 2;
+    case 5126:
+      return 4;
+    default:
+      return 0;
+  }
+}
+function convertGLDataTypeToDataType(type) {
+  return GL_DATA_TYPE_MAP[type];
+}
+const GL_DATA_TYPE_MAP = {
+  [5124]: "sint32",
+  [5125]: "uint32",
+  [5122]: "sint16",
+  [5123]: "uint16",
+  [5120]: "sint8",
+  [5121]: "uint8",
+  [5126]: "float32",
+  [5131]: "float16",
+  [33635]: "uint16",
+  [32819]: "uint16",
+  [32820]: "uint16",
+  [33640]: "uint32",
+  [35899]: "uint32",
+  [35902]: "uint32",
+  [34042]: "uint32",
+  [36269]: "uint32"
+};
+function readPixelsToArray(source2, options) {
+  var _a3;
+  const {
+    sourceX = 0,
+    sourceY = 0,
+    sourceAttachment = 0
+    // TODO - support gl.readBuffer
+  } = options || {};
+  let {
+    target = null,
+    // following parameters are auto deduced if not provided
+    sourceWidth,
+    sourceHeight,
+    sourceDepth,
+    sourceFormat,
+    sourceType
+  } = options || {};
+  const { framebuffer, deleteFramebuffer } = getFramebuffer$1(source2);
+  const { gl: gl2, handle } = framebuffer;
+  sourceWidth || (sourceWidth = framebuffer.width);
+  sourceHeight || (sourceHeight = framebuffer.height);
+  const texture = (_a3 = framebuffer.colorAttachments[sourceAttachment]) == null ? void 0 : _a3.texture;
+  if (!texture) {
+    throw new Error(`Invalid framebuffer attachment ${sourceAttachment}`);
+  }
+  sourceDepth = (texture == null ? void 0 : texture.depth) || 1;
+  sourceFormat || (sourceFormat = (texture == null ? void 0 : texture.glFormat) || 6408);
+  sourceType || (sourceType = (texture == null ? void 0 : texture.glType) || 5121);
+  target = getPixelArray(target, sourceType, sourceFormat, sourceWidth, sourceHeight);
+  const signedType = getDataType(target);
+  sourceType = sourceType || convertDataTypeToGLDataType(signedType);
+  const prevHandle = gl2.bindFramebuffer(36160, handle);
+  gl2.readBuffer(36064 + sourceAttachment);
+  gl2.readPixels(sourceX, sourceY, sourceWidth, sourceHeight, sourceFormat, sourceType, target);
+  gl2.readBuffer(36064);
+  gl2.bindFramebuffer(36160, prevHandle || null);
+  if (deleteFramebuffer) {
+    framebuffer.destroy();
+  }
+  return target;
+}
+function readPixelsToBuffer(source2, options) {
+  const { target, sourceX = 0, sourceY = 0, sourceFormat = 6408, targetByteOffset = 0 } = options || {};
+  let { sourceWidth, sourceHeight, sourceType } = options || {};
+  const { framebuffer, deleteFramebuffer } = getFramebuffer$1(source2);
+  sourceWidth = sourceWidth || framebuffer.width;
+  sourceHeight = sourceHeight || framebuffer.height;
+  const webglFramebuffer = framebuffer;
+  sourceType = sourceType || 5121;
+  let webglBufferTarget = target;
+  if (!webglBufferTarget) {
+    const components = glFormatToComponents(sourceFormat);
+    const byteCount = glTypeToBytes(sourceType);
+    const byteLength = targetByteOffset + sourceWidth * sourceHeight * components * byteCount;
+    webglBufferTarget = webglFramebuffer.device.createBuffer({ byteLength });
+  }
+  const commandEncoder = source2.device.createCommandEncoder();
+  commandEncoder.copyTextureToBuffer({
+    sourceTexture: source2,
+    width: sourceWidth,
+    height: sourceHeight,
+    origin: [sourceX, sourceY],
+    destinationBuffer: webglBufferTarget,
+    byteOffset: targetByteOffset
+  });
+  commandEncoder.destroy();
+  if (deleteFramebuffer) {
+    framebuffer.destroy();
+  }
+  return webglBufferTarget;
+}
+function getFramebuffer$1(source2) {
+  if (!(source2 instanceof Framebuffer)) {
+    return { framebuffer: toFramebuffer(source2), deleteFramebuffer: true };
+  }
+  return { framebuffer: source2, deleteFramebuffer: false };
+}
+function toFramebuffer(texture, props) {
+  const { device, width, height, id: id2 } = texture;
+  const framebuffer = device.createFramebuffer({
+    ...props,
+    id: `framebuffer-for-${id2}`,
+    width,
+    height,
+    colorAttachments: [texture]
+  });
+  return framebuffer;
+}
+function getPixelArray(pixelArray, glType, glFormat, width, height, depth) {
+  if (pixelArray) {
+    return pixelArray;
+  }
+  glType || (glType = 5121);
+  const shaderType = convertGLDataTypeToDataType(glType);
+  const ArrayType = getTypedArrayConstructor(shaderType);
+  const components = glFormatToComponents(glFormat);
+  return new ArrayType(width * height * components);
+}
+class WebGLDevice extends Device {
+  constructor(props) {
+    var _a3, _b3;
+    super({ ...props, id: props.id || uid("webgl-device") });
+    // Public `Device` API
+    /** type of this device */
+    __publicField(this, "type", "webgl");
+    // Use the ! assertion to handle the case where _reuseDevices causes the constructor to return early
+    /** The underlying WebGL context */
+    __publicField(this, "handle");
+    __publicField(this, "features");
+    __publicField(this, "limits");
+    __publicField(this, "info");
+    __publicField(this, "canvasContext");
+    __publicField(this, "preferredColorFormat", "rgba8unorm");
+    __publicField(this, "preferredDepthFormat", "depth24plus");
+    __publicField(this, "commandEncoder");
+    __publicField(this, "lost");
+    __publicField(this, "_resolveContextLost");
+    /** WebGL2 context. */
+    __publicField(this, "gl");
+    /** Store constants */
+    // @ts-ignore TODO fix
+    __publicField(this, "_constants");
+    /** State used by luma.gl classes - TODO - not used? */
+    __publicField(this, "_extensions", {});
+    __publicField(this, "_polyfilled", false);
+    /** Instance of Spector.js (if initialized) */
+    __publicField(this, "spectorJS");
+    const canvasContextProps = Device._getCanvasContextProps(props);
+    if (!canvasContextProps) {
+      throw new Error("WebGLDevice requires props.createCanvasContext to be set");
+    }
+    let device = (_b3 = (_a3 = canvasContextProps.canvas) == null ? void 0 : _a3.gl) == null ? void 0 : _b3.device;
+    if (device) {
+      throw new Error(`WebGL context already attached to device ${device.id}`);
+    }
+    this.canvasContext = new WebGLCanvasContext(this, canvasContextProps);
+    this.lost = new Promise((resolve) => {
+      this._resolveContextLost = resolve;
+    });
+    const webglContextAttributes = { ...props.webgl };
+    if (canvasContextProps.alphaMode === "premultiplied") {
+      webglContextAttributes.premultipliedAlpha = true;
+    }
+    if (props.powerPreference !== void 0) {
+      webglContextAttributes.powerPreference = props.powerPreference;
+    }
+    const externalGLContext = this.props._handle;
+    const gl2 = externalGLContext || createBrowserContext(this.canvasContext.canvas, {
+      onContextLost: (event) => {
+        var _a4;
+        return (_a4 = this._resolveContextLost) == null ? void 0 : _a4.call(this, {
+          reason: "destroyed",
+          message: "Entered sleep mode, or too many apps or browser tabs are using the GPU."
+        });
       },
-      // @method latLngToLayerPoint(latlng: LatLng): Point
-      // Given a geographical coordinate, returns the corresponding pixel coordinate
-      // relative to the [origin pixel](#map-getpixelorigin).
-      latLngToLayerPoint: function(latlng) {
-        var projectedPoint = this.project(toLatLng(latlng))._round();
-        return projectedPoint._subtract(this.getPixelOrigin());
+      // eslint-disable-next-line no-console
+      onContextRestored: (event) => console.log("WebGL context restored")
+    }, webglContextAttributes);
+    if (!gl2) {
+      throw new Error("WebGL context creation failed");
+    }
+    device = gl2.device;
+    if (device) {
+      if (props._reuseDevices) {
+        log.log(1, `Not creating a new Device, instead returning a reference to Device ${device.id} already attached to WebGL context`, device)();
+        device._reused = true;
+        return device;
+      }
+      throw new Error(`WebGL context already attached to device ${device.id}`);
+    }
+    this.handle = gl2;
+    this.gl = gl2;
+    this.spectorJS = initializeSpectorJS({ ...this.props, gl: this.handle });
+    this.gl.device = this;
+    this.gl._version = 2;
+    this.info = getDeviceInfo(this.gl, this._extensions);
+    this.limits = new WebGLDeviceLimits(this.gl);
+    this.features = new WebGLDeviceFeatures(this.gl, this._extensions, this.props._disabledFeatures);
+    if (this.props._initializeFeatures) {
+      this.features.initializeFeatures();
+    }
+    const glState = new WebGLStateTracker(this.gl, {
+      log: (...args) => log.log(1, ...args)()
+    });
+    glState.trackState(this.gl, { copyState: false });
+    const debugWebGL = props.debugWebGL || props.debug;
+    const traceWebGL = props.debugWebGL;
+    if (debugWebGL) {
+      this.gl = makeDebugContext(this.gl, { debugWebGL, traceWebGL });
+      log.warn("WebGL debug mode activated. Performance reduced.")();
+      if (props.debugWebGL) {
+        log.level = Math.max(log.level, 1);
+      }
+    }
+    this.commandEncoder = new WEBGLCommandEncoder(this, { id: `${this}-command-encoder` });
+  }
+  //
+  // Public API
+  //
+  get [Symbol.toStringTag]() {
+    return "WebGLDevice";
+  }
+  toString() {
+    return `${this[Symbol.toStringTag]}(${this.id})`;
+  }
+  isVertexFormatSupported(format) {
+    switch (format) {
+      case "unorm8x4-bgra":
+        return false;
+      default:
+        return true;
+    }
+  }
+  /**
+   * Destroys the device
+   *
+   * @note "Detaches" from the WebGL context unless _reuseDevices is true.
+   *
+   * @note The underlying WebGL context is not immediately destroyed,
+   * but may be destroyed later through normal JavaScript garbage collection.
+   * This is a fundamental limitation since WebGL does not offer any
+   * browser API for destroying WebGL contexts.
+   */
+  destroy() {
+    if (!this.props._reuseDevices && !this._reused) {
+      delete this.gl.device;
+    }
+  }
+  get isLost() {
+    return this.gl.isContextLost();
+  }
+  // IMPLEMENTATION OF ABSTRACT DEVICE
+  getTextureByteAlignment() {
+    return 4;
+  }
+  createCanvasContext(props) {
+    throw new Error("WebGL only supports a single canvas");
+  }
+  createBuffer(props) {
+    const newProps = this._normalizeBufferProps(props);
+    return new WEBGLBuffer(this, newProps);
+  }
+  createTexture(props) {
+    return new WEBGLTexture(this, props);
+  }
+  createExternalTexture(props) {
+    throw new Error("createExternalTexture() not implemented");
+  }
+  createSampler(props) {
+    return new WEBGLSampler(this, props);
+  }
+  createShader(props) {
+    return new WEBGLShader(this, props);
+  }
+  createFramebuffer(props) {
+    return new WEBGLFramebuffer(this, props);
+  }
+  createVertexArray(props) {
+    return new WEBGLVertexArray(this, props);
+  }
+  createTransformFeedback(props) {
+    return new WEBGLTransformFeedback(this, props);
+  }
+  createQuerySet(props) {
+    return new WEBGLQuerySet(this, props);
+  }
+  createRenderPipeline(props) {
+    return new WEBGLRenderPipeline(this, props);
+  }
+  createComputePipeline(props) {
+    throw new Error("ComputePipeline not supported in WebGL");
+  }
+  createCommandEncoder(props = {}) {
+    return new WEBGLCommandEncoder(this, props);
+  }
+  /**
+   * Offscreen Canvas Support: Commit the frame
+   * https://developer.mozilla.org/en-US/docs/Web/API/WebGL2RenderingContext/commit
+   * Chrome's offscreen canvas does not require gl.commit
+   */
+  submit(commandBuffer) {
+    if (!commandBuffer) {
+      commandBuffer = this.commandEncoder.finish();
+      this.commandEncoder.destroy();
+      this.commandEncoder = this.createCommandEncoder({ id: `${this.id}-default-encoder` });
+    }
+    commandBuffer._executeCommands();
+  }
+  //
+  // TEMPORARY HACKS - will be removed in v9.1
+  //
+  /** @deprecated - should use command encoder */
+  readPixelsToArrayWebGL(source2, options) {
+    return readPixelsToArray(source2, options);
+  }
+  /** @deprecated - should use command encoder */
+  readPixelsToBufferWebGL(source2, options) {
+    return readPixelsToBuffer(source2, options);
+  }
+  setParametersWebGL(parameters) {
+    setGLParameters(this.gl, parameters);
+  }
+  getParametersWebGL(parameters) {
+    return getGLParameters(this.gl, parameters);
+  }
+  withParametersWebGL(parameters, func) {
+    return withGLParameters(this.gl, parameters, func);
+  }
+  resetWebGL() {
+    log.warn("WebGLDevice.resetWebGL is deprecated, use only for debugging")();
+    resetGLParameters(this.gl);
+  }
+  _getDeviceSpecificTextureFormatCapabilities(capabilities) {
+    return getTextureFormatCapabilitiesWebGL(this.gl, capabilities, this._extensions);
+  }
+  //
+  // WebGL-only API (not part of `Device` API)
+  //
+  /**
+   * Triggers device (or WebGL context) loss.
+   * @note primarily intended for testing how application reacts to device loss
+   */
+  loseDevice() {
+    var _a3;
+    let deviceLossTriggered = false;
+    const extensions = this.getExtension("WEBGL_lose_context");
+    const ext = extensions.WEBGL_lose_context;
+    if (ext) {
+      deviceLossTriggered = true;
+      ext.loseContext();
+    }
+    (_a3 = this._resolveContextLost) == null ? void 0 : _a3.call(this, {
+      reason: "destroyed",
+      message: "Application triggered context loss"
+    });
+    return deviceLossTriggered;
+  }
+  /** Save current WebGL context state onto an internal stack */
+  pushState() {
+    const webglState = WebGLStateTracker.get(this.gl);
+    webglState.push();
+  }
+  /** Restores previously saved context state */
+  popState() {
+    const webglState = WebGLStateTracker.get(this.gl);
+    webglState.pop();
+  }
+  /**
+   * Returns the GL.<KEY> constant that corresponds to a numeric value of a GL constant
+   * Be aware that there are some duplicates especially for constants that are 0,
+   * so this isn't guaranteed to return the right key in all cases.
+   */
+  getGLKey(value, options) {
+    const number = Number(value);
+    for (const key in this.gl) {
+      if (this.gl[key] === number) {
+        return `GL.${key}`;
+      }
+    }
+    return (options == null ? void 0 : options.emptyIfUnknown) ? "" : String(value);
+  }
+  /**
+   * Returns a map with any GL.<KEY> constants mapped to strings, both for keys and values
+   */
+  getGLKeys(glParameters) {
+    const opts = { emptyIfUnknown: true };
+    return Object.entries(glParameters).reduce((keys, [key, value]) => {
+      keys[`${key}:${this.getGLKey(key, opts)}`] = `${value}:${this.getGLKey(value, opts)}`;
+      return keys;
+    }, {});
+  }
+  /**
+   * Set a constant value for a location. Disabled attributes at that location will read from this value
+   * @note WebGL constants are stored globally on the WebGL context, not the VertexArray
+   * so they need to be updated before every render
+   * @todo - remember/cache values to avoid setting them unnecessarily?
+   */
+  setConstantAttributeWebGL(location2, constant) {
+    const maxVertexAttributes = this.limits.maxVertexAttributes;
+    this._constants = this._constants || new Array(maxVertexAttributes).fill(null);
+    const currentConstant = this._constants[location2];
+    if (currentConstant && compareConstantArrayValues(currentConstant, constant)) {
+      log.info(1, `setConstantAttributeWebGL(${location2}) could have been skipped, value unchanged`)();
+    }
+    this._constants[location2] = constant;
+    switch (constant.constructor) {
+      case Float32Array:
+        setConstantFloatArray(this, location2, constant);
+        break;
+      case Int32Array:
+        setConstantIntArray(this, location2, constant);
+        break;
+      case Uint32Array:
+        setConstantUintArray(this, location2, constant);
+        break;
+      default:
+        throw new Error("constant");
+    }
+  }
+  /** Ensure extensions are only requested once */
+  getExtension(name2) {
+    getWebGLExtension(this.gl, name2, this._extensions);
+    return this._extensions;
+  }
+  // INTERNAL SUPPORT METHODS FOR WEBGL RESOURCES
+  /**
+   * Storing data on a special field on WebGLObjects makes that data visible in SPECTOR chrome debug extension
+   * luma.gl ids and props can be inspected
+   */
+  _setWebGLDebugMetadata(handle, resource, options) {
+    handle.luma = resource;
+    const spectorMetadata = { props: options.spector, id: options.spector["id"] };
+    handle.__SPECTOR_Metadata = spectorMetadata;
+  }
+}
+function setConstantFloatArray(device, location2, array) {
+  switch (array.length) {
+    case 1:
+      device.gl.vertexAttrib1fv(location2, array);
+      break;
+    case 2:
+      device.gl.vertexAttrib2fv(location2, array);
+      break;
+    case 3:
+      device.gl.vertexAttrib3fv(location2, array);
+      break;
+    case 4:
+      device.gl.vertexAttrib4fv(location2, array);
+      break;
+  }
+}
+function setConstantIntArray(device, location2, array) {
+  device.gl.vertexAttribI4iv(location2, array);
+}
+function setConstantUintArray(device, location2, array) {
+  device.gl.vertexAttribI4uiv(location2, array);
+}
+function compareConstantArrayValues(v1, v2) {
+  if (!v1 || !v2 || v1.length !== v2.length || v1.constructor !== v2.constructor) {
+    return false;
+  }
+  for (let i2 = 0; i2 < v1.length; ++i2) {
+    if (v1[i2] !== v2[i2]) {
+      return false;
+    }
+  }
+  return true;
+}
+const webglDevice = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
+  __proto__: null,
+  WebGLDevice
+}, Symbol.toStringTag, { value: "Module" }));
+function noop() {
+}
+const getCursor = ({ isDragging }) => isDragging ? "grabbing" : "grab";
+const defaultProps$2 = {
+  id: "",
+  width: "100%",
+  height: "100%",
+  style: null,
+  viewState: null,
+  initialViewState: null,
+  pickingRadius: 0,
+  layerFilter: null,
+  parameters: {},
+  parent: null,
+  device: null,
+  deviceProps: {},
+  gl: null,
+  canvas: null,
+  layers: [],
+  effects: [],
+  views: null,
+  controller: null,
+  // Rely on external controller, e.g. react-map-gl
+  useDevicePixels: true,
+  touchAction: "none",
+  eventRecognizerOptions: {},
+  _framebuffer: null,
+  _animate: false,
+  _pickable: true,
+  _typedArrayManagerProps: {},
+  _customRender: null,
+  widgets: [],
+  onDeviceInitialized: noop,
+  onWebGLInitialized: noop,
+  onResize: noop,
+  onViewStateChange: noop,
+  onInteractionStateChange: noop,
+  onBeforeRender: noop,
+  onAfterRender: noop,
+  onLoad: noop,
+  onError: (error) => defaultLogger.error(error.message, error.cause)(),
+  onHover: null,
+  onClick: null,
+  onDragStart: null,
+  onDrag: null,
+  onDragEnd: null,
+  _onMetrics: null,
+  getCursor,
+  getTooltip: null,
+  debug: false,
+  drawPickingColors: false
+};
+class Deck {
+  constructor(props) {
+    var _a3;
+    this.width = 0;
+    this.height = 0;
+    this.userData = {};
+    this.device = null;
+    this.canvas = null;
+    this.viewManager = null;
+    this.layerManager = null;
+    this.effectManager = null;
+    this.deckRenderer = null;
+    this.deckPicker = null;
+    this.eventManager = null;
+    this.widgetManager = null;
+    this.tooltip = null;
+    this.animationLoop = null;
+    this.cursorState = {
+      isHovering: false,
+      isDragging: false
+    };
+    this.stats = new Stats({ id: "deck.gl" });
+    this.metrics = {
+      fps: 0,
+      setPropsTime: 0,
+      updateAttributesTime: 0,
+      framesRedrawn: 0,
+      pickTime: 0,
+      pickCount: 0,
+      gpuTime: 0,
+      gpuTimePerFrame: 0,
+      cpuTime: 0,
+      cpuTimePerFrame: 0,
+      bufferMemory: 0,
+      textureMemory: 0,
+      renderbufferMemory: 0,
+      gpuMemory: 0
+    };
+    this._metricsCounter = 0;
+    this._needsRedraw = "Initial render";
+    this._pickRequest = {
+      mode: "hover",
+      x: -1,
+      y: -1,
+      radius: 0,
+      event: null,
+      unproject3D: false
+    };
+    this._lastPointerDownInfo = null;
+    this._onPointerMove = (event) => {
+      const { _pickRequest } = this;
+      if (event.type === "pointerleave") {
+        _pickRequest.x = -1;
+        _pickRequest.y = -1;
+        _pickRequest.radius = 0;
+      } else if (event.leftButton || event.rightButton) {
+        return;
+      } else {
+        const pos = event.offsetCenter;
+        if (!pos) {
+          return;
+        }
+        _pickRequest.x = pos.x;
+        _pickRequest.y = pos.y;
+        _pickRequest.radius = this.props.pickingRadius;
+      }
+      if (this.layerManager) {
+        this.layerManager.context.mousePosition = { x: _pickRequest.x, y: _pickRequest.y };
+      }
+      _pickRequest.event = event;
+    };
+    this._onEvent = (event) => {
+      const eventHandlerProp = EVENT_HANDLERS[event.type];
+      const pos = event.offsetCenter;
+      if (!eventHandlerProp || !pos || !this.layerManager) {
+        return;
+      }
+      let info;
+      const layers = this.layerManager.getLayers();
+      const has3DPickableLayers = layers.some((layer2) => layer2.props.pickable === "3d");
+      if (event.type === "click" && has3DPickableLayers) {
+        const pickResult = this._pick("pickObject", "pickObject Time", {
+          x: pos.x,
+          y: pos.y,
+          radius: this.props.pickingRadius,
+          unproject3D: true
+        });
+        info = pickResult.result[0] || pickResult.emptyInfo;
+      } else {
+        info = this.deckPicker.getLastPickedObject({
+          x: pos.x,
+          y: pos.y,
+          layers,
+          viewports: this.getViewports(pos)
+        }, this._lastPointerDownInfo);
+      }
+      const { layer } = info;
+      const layerHandler = layer && (layer[eventHandlerProp] || layer.props[eventHandlerProp]);
+      const rootHandler = this.props[eventHandlerProp];
+      let handled = false;
+      if (layerHandler) {
+        handled = layerHandler.call(layer, info, event);
+      }
+      if (!handled) {
+        rootHandler == null ? void 0 : rootHandler(info, event);
+        this.widgetManager.onEvent(info, event);
+      }
+    };
+    this._onPointerDown = (event) => {
+      var _a4;
+      if (((_a4 = this.device) == null ? void 0 : _a4.type) === "webgpu") {
+        return;
+      }
+      const pos = event.offsetCenter;
+      const pickedInfo = this._pick("pickObject", "pickObject Time", {
+        x: pos.x,
+        y: pos.y,
+        radius: this.props.pickingRadius
+      });
+      this._lastPointerDownInfo = pickedInfo.result[0] || pickedInfo.emptyInfo;
+    };
+    this.props = { ...defaultProps$2, ...props };
+    props = this.props;
+    if (props.viewState && props.initialViewState) {
+      defaultLogger.warn("View state tracking is disabled. Use either `initialViewState` for auto update or `viewState` for manual update.")();
+    }
+    this.viewState = this.props.initialViewState;
+    if (props.device) {
+      this.device = props.device;
+    }
+    let deviceOrPromise = this.device;
+    if (!deviceOrPromise && props.gl) {
+      if (props.gl instanceof WebGLRenderingContext) {
+        defaultLogger.error("WebGL1 context not supported.")();
+      }
+      const userOnResize = (_a3 = this.props.deviceProps) == null ? void 0 : _a3.onResize;
+      deviceOrPromise = webgl2Adapter.attach(props.gl, {
+        // Enable shader and pipeline caching for attached devices (matches _createDevice defaults)
+        // Without this, interleaved mode (e.g., MapboxOverlay) creates new pipelines every frame
+        _cacheShaders: true,
+        _cachePipelines: true,
+        ...this.props.deviceProps,
+        onResize: (canvasContext, info) => {
+          const { width, height } = canvasContext.canvas;
+          canvasContext.drawingBufferWidth = width;
+          canvasContext.drawingBufferHeight = height;
+          this._needsRedraw = "Canvas resized";
+          userOnResize == null ? void 0 : userOnResize(canvasContext, info);
+        }
+      });
+    }
+    if (!deviceOrPromise) {
+      deviceOrPromise = this._createDevice(props);
+    }
+    this.animationLoop = this._createAnimationLoop(deviceOrPromise, props);
+    this.setProps(props);
+    if (props._typedArrayManagerProps) {
+      defaultTypedArrayManager.setOptions(props._typedArrayManagerProps);
+    }
+    this.animationLoop.start();
+  }
+  /** Stop rendering and dispose all resources */
+  finalize() {
+    var _a3, _b3, _c3, _d2, _e2, _f2, _g2, _h2, _i, _j2;
+    (_a3 = this.animationLoop) == null ? void 0 : _a3.stop();
+    (_b3 = this.animationLoop) == null ? void 0 : _b3.destroy();
+    this.animationLoop = null;
+    this._lastPointerDownInfo = null;
+    (_c3 = this.layerManager) == null ? void 0 : _c3.finalize();
+    this.layerManager = null;
+    (_d2 = this.viewManager) == null ? void 0 : _d2.finalize();
+    this.viewManager = null;
+    (_e2 = this.effectManager) == null ? void 0 : _e2.finalize();
+    this.effectManager = null;
+    (_f2 = this.deckRenderer) == null ? void 0 : _f2.finalize();
+    this.deckRenderer = null;
+    (_g2 = this.deckPicker) == null ? void 0 : _g2.finalize();
+    this.deckPicker = null;
+    (_h2 = this.eventManager) == null ? void 0 : _h2.destroy();
+    this.eventManager = null;
+    (_i = this.widgetManager) == null ? void 0 : _i.finalize();
+    this.widgetManager = null;
+    if (!this.props.canvas && !this.props.device && !this.props.gl && this.canvas) {
+      (_j2 = this.canvas.parentElement) == null ? void 0 : _j2.removeChild(this.canvas);
+      this.canvas = null;
+    }
+  }
+  /** Partially update props */
+  setProps(props) {
+    var _a3, _b3, _c3, _d2, _e2, _f2, _g2, _h2;
+    this.stats.get("setProps Time").timeStart();
+    if ("onLayerHover" in props) {
+      defaultLogger.removed("onLayerHover", "onHover")();
+    }
+    if ("onLayerClick" in props) {
+      defaultLogger.removed("onLayerClick", "onClick")();
+    }
+    if (props.initialViewState && // depth = 3 when comparing viewStates: viewId.position.0
+    !deepEqual(this.props.initialViewState, props.initialViewState, 3)) {
+      this.viewState = props.initialViewState;
+    }
+    Object.assign(this.props, props);
+    this._setCanvasSize(this.props);
+    const resolvedProps = Object.create(this.props);
+    Object.assign(resolvedProps, {
+      views: this._getViews(),
+      width: this.width,
+      height: this.height,
+      viewState: this._getViewState()
+    });
+    if (props.device && props.device.id !== ((_a3 = this.device) == null ? void 0 : _a3.id)) {
+      (_b3 = this.animationLoop) == null ? void 0 : _b3.stop();
+      if (this.canvas !== ((_c3 = props.device.canvasContext) == null ? void 0 : _c3.canvas)) {
+        (_d2 = this.canvas) == null ? void 0 : _d2.remove();
+        (_e2 = this.eventManager) == null ? void 0 : _e2.destroy();
+        this.canvas = null;
+      }
+      defaultLogger.log(`recreating animation loop for new device! id=${props.device.id}`)();
+      this.animationLoop = this._createAnimationLoop(props.device, props);
+      this.animationLoop.start();
+    }
+    (_f2 = this.animationLoop) == null ? void 0 : _f2.setProps(resolvedProps);
+    if (props.useDevicePixels !== void 0 && ((_h2 = (_g2 = this.device) == null ? void 0 : _g2.canvasContext) == null ? void 0 : _h2.setProps)) {
+      this.device.canvasContext.setProps({ useDevicePixels: props.useDevicePixels });
+    }
+    if (this.layerManager) {
+      this.viewManager.setProps(resolvedProps);
+      this.layerManager.activateViewport(this.getViewports()[0]);
+      this.layerManager.setProps(resolvedProps);
+      this.effectManager.setProps(resolvedProps);
+      this.deckRenderer.setProps(resolvedProps);
+      this.deckPicker.setProps(resolvedProps);
+      this.widgetManager.setProps(resolvedProps);
+    }
+    this.stats.get("setProps Time").timeEnd();
+  }
+  // Public API
+  /**
+   * Check if a redraw is needed
+   * @returns `false` or a string summarizing the redraw reason
+   */
+  needsRedraw(opts = { clearRedrawFlags: false }) {
+    if (!this.layerManager) {
+      return false;
+    }
+    if (this.props._animate) {
+      return "Deck._animate";
+    }
+    let redraw = this._needsRedraw;
+    if (opts.clearRedrawFlags) {
+      this._needsRedraw = false;
+    }
+    const viewManagerNeedsRedraw = this.viewManager.needsRedraw(opts);
+    const layerManagerNeedsRedraw = this.layerManager.needsRedraw(opts);
+    const effectManagerNeedsRedraw = this.effectManager.needsRedraw(opts);
+    const deckRendererNeedsRedraw = this.deckRenderer.needsRedraw(opts);
+    redraw = redraw || viewManagerNeedsRedraw || layerManagerNeedsRedraw || effectManagerNeedsRedraw || deckRendererNeedsRedraw;
+    return redraw;
+  }
+  /**
+   * Redraw the GL context
+   * @param reason If not provided, only redraw if deemed necessary. Otherwise redraw regardless of internal states.
+   * @returns
+   */
+  redraw(reason) {
+    if (!this.layerManager) {
+      return;
+    }
+    let redrawReason = this.needsRedraw({ clearRedrawFlags: true });
+    redrawReason = reason || redrawReason;
+    if (!redrawReason) {
+      return;
+    }
+    this.stats.get("Redraw Count").incrementCount();
+    if (this.props._customRender) {
+      this.props._customRender(redrawReason);
+    } else {
+      this._drawLayers(redrawReason);
+    }
+  }
+  /** Flag indicating that the Deck instance has initialized its resources and it's safe to call public methods. */
+  get isInitialized() {
+    return this.viewManager !== null;
+  }
+  /** Get a list of views that are currently rendered */
+  getViews() {
+    assert(this.viewManager);
+    return this.viewManager.views;
+  }
+  /** Get a view by id */
+  getView(viewId) {
+    assert(this.viewManager);
+    return this.viewManager.getView(viewId);
+  }
+  /** Get a list of viewports that are currently rendered.
+   * @param rect If provided, only returns viewports within the given bounding box.
+   */
+  getViewports(rect) {
+    assert(this.viewManager);
+    return this.viewManager.getViewports(rect);
+  }
+  /** Get the current canvas element. */
+  getCanvas() {
+    return this.canvas;
+  }
+  /** Query the object rendered on top at a given point */
+  pickObject(opts) {
+    const infos = this._pick("pickObject", "pickObject Time", opts).result;
+    return infos.length ? infos[0] : null;
+  }
+  /* Query all rendered objects at a given point */
+  pickMultipleObjects(opts) {
+    opts.depth = opts.depth || 10;
+    return this._pick("pickObject", "pickMultipleObjects Time", opts).result;
+  }
+  /* Query all objects rendered on top within a bounding box */
+  pickObjects(opts) {
+    return this._pick("pickObjects", "pickObjects Time", opts);
+  }
+  /** Experimental
+   * Add a global resource for sharing among layers
+   */
+  _addResources(resources, forceUpdate = false) {
+    for (const id2 in resources) {
+      this.layerManager.resourceManager.add({ resourceId: id2, data: resources[id2], forceUpdate });
+    }
+  }
+  /** Experimental
+   * Remove a global resource
+   */
+  _removeResources(resourceIds) {
+    for (const id2 of resourceIds) {
+      this.layerManager.resourceManager.remove(id2);
+    }
+  }
+  /** Experimental
+   * Register a default effect. Effects will be sorted by order, those with a low order will be rendered first
+   */
+  _addDefaultEffect(effect) {
+    this.effectManager.addDefaultEffect(effect);
+  }
+  _addDefaultShaderModule(module) {
+    this.layerManager.addDefaultShaderModule(module);
+  }
+  _removeDefaultShaderModule(module) {
+    var _a3;
+    (_a3 = this.layerManager) == null ? void 0 : _a3.removeDefaultShaderModule(module);
+  }
+  _pick(method, statKey, opts) {
+    assert(this.deckPicker);
+    const { stats } = this;
+    stats.get("Pick Count").incrementCount();
+    stats.get(statKey).timeStart();
+    const infos = this.deckPicker[method]({
+      // layerManager, viewManager and effectManager are always defined if deckPicker is
+      layers: this.layerManager.getLayers(opts),
+      views: this.viewManager.getViews(),
+      viewports: this.getViewports(opts),
+      onViewportActive: this.layerManager.activateViewport,
+      effects: this.effectManager.getEffects(),
+      ...opts
+    });
+    stats.get(statKey).timeEnd();
+    return infos;
+  }
+  /** Resolve props.canvas to element */
+  _createCanvas(props) {
+    let canvas2 = props.canvas;
+    if (typeof canvas2 === "string") {
+      canvas2 = document.getElementById(canvas2);
+      assert(canvas2);
+    }
+    if (!canvas2) {
+      canvas2 = document.createElement("canvas");
+      canvas2.id = props.id || "deckgl-overlay";
+      if (props.width && typeof props.width === "number") {
+        canvas2.width = props.width;
+      }
+      if (props.height && typeof props.height === "number") {
+        canvas2.height = props.height;
+      }
+      const parent = props.parent || document.body;
+      parent.appendChild(canvas2);
+    }
+    Object.assign(canvas2.style, props.style);
+    return canvas2;
+  }
+  /** Updates canvas width and/or height, if provided as props */
+  _setCanvasSize(props) {
+    var _a3;
+    if (!this.canvas) {
+      return;
+    }
+    const { width, height } = props;
+    if (width || width === 0) {
+      const cssWidth = Number.isFinite(width) ? `${width}px` : width;
+      this.canvas.style.width = cssWidth;
+    }
+    if (height || height === 0) {
+      const cssHeight = Number.isFinite(height) ? `${height}px` : height;
+      this.canvas.style.position = ((_a3 = props.style) == null ? void 0 : _a3.position) || "absolute";
+      this.canvas.style.height = cssHeight;
+    }
+  }
+  /** If canvas size has changed, reads out the new size and update */
+  _updateCanvasSize() {
+    var _a3, _b3;
+    const { canvas: canvas2 } = this;
+    if (!canvas2) {
+      return;
+    }
+    const newWidth = canvas2.clientWidth ?? canvas2.width;
+    const newHeight = canvas2.clientHeight ?? canvas2.height;
+    if (newWidth !== this.width || newHeight !== this.height) {
+      this.width = newWidth;
+      this.height = newHeight;
+      (_a3 = this.viewManager) == null ? void 0 : _a3.setProps({ width: newWidth, height: newHeight });
+      (_b3 = this.layerManager) == null ? void 0 : _b3.activateViewport(this.getViewports()[0]);
+      this.props.onResize({ width: newWidth, height: newHeight });
+    }
+  }
+  _createAnimationLoop(deviceOrPromise, props) {
+    const {
+      // width,
+      // height,
+      gl: gl2,
+      // debug,
+      onError
+      // onBeforeRender,
+      // onAfterRender,
+    } = props;
+    return new AnimationLoop({
+      device: deviceOrPromise,
+      // TODO v9
+      autoResizeDrawingBuffer: !gl2,
+      // do not auto resize external context
+      autoResizeViewport: false,
+      // @ts-expect-error luma.gl needs to accept Promise<void> return value
+      onInitialize: (context) => this._setDevice(context.device),
+      onRender: this._onRenderFrame.bind(this),
+      // @ts-expect-error typing mismatch: AnimationLoop does not accept onError:null
+      onError
+      // onBeforeRender,
+      // onAfterRender,
+    });
+  }
+  // Create a device from the deviceProps, assigning required defaults
+  _createDevice(props) {
+    var _a3, _b3, _c3;
+    const canvasContextUserProps = (_a3 = this.props.deviceProps) == null ? void 0 : _a3.createCanvasContext;
+    const canvasContextProps = typeof canvasContextUserProps === "object" ? canvasContextUserProps : void 0;
+    const deviceProps = {
+      adapters: [],
+      _cacheShaders: true,
+      _cachePipelines: true,
+      ...props.deviceProps
+    };
+    if (!deviceProps.adapters.includes(webgl2Adapter)) {
+      deviceProps.adapters.push(webgl2Adapter);
+    }
+    const defaultCanvasProps = {
+      // we must use 'premultiplied' canvas for webgpu to enable transparency and match shaders
+      alphaMode: ((_b3 = this.props.deviceProps) == null ? void 0 : _b3.type) === "webgpu" ? "premultiplied" : void 0
+    };
+    const userOnResize = (_c3 = this.props.deviceProps) == null ? void 0 : _c3.onResize;
+    return luma.createDevice({
+      // luma by default throws if a device is already attached
+      // asynchronous device creation could happen after finalize() is called
+      // TODO - createDevice should support AbortController?
+      _reuseDevices: true,
+      // tests can't handle WebGPU devices yet so we force WebGL2 unless overridden
+      type: "webgl",
+      ...deviceProps,
+      // In deck.gl v10 we may emphasize multi canvas support and unwind this prop wrapping
+      createCanvasContext: {
+        ...defaultCanvasProps,
+        ...canvasContextProps,
+        canvas: this._createCanvas(props),
+        useDevicePixels: this.props.useDevicePixels,
+        autoResize: true
       },
-      // @method wrapLatLng(latlng: LatLng): LatLng
-      // Returns a `LatLng` where `lat` and `lng` has been wrapped according to the
-      // map's CRS's `wrapLat` and `wrapLng` properties, if they are outside the
-      // CRS's bounds.
-      // By default this means longitude is wrapped around the dateline so its
-      // value is between -180 and +180 degrees.
-      wrapLatLng: function(latlng) {
-        return this.options.crs.wrapLatLng(toLatLng(latlng));
+      onResize: (canvasContext, info) => {
+        this._needsRedraw = "Canvas resized";
+        userOnResize == null ? void 0 : userOnResize(canvasContext, info);
+      }
+    });
+  }
+  // Get the most relevant view state: props.viewState, if supplied, shadows internal viewState
+  // TODO: For backwards compatibility ensure numeric width and height is added to the viewState
+  _getViewState() {
+    return this.props.viewState || this.viewState;
+  }
+  // Get the view descriptor list
+  _getViews() {
+    const { views } = this.props;
+    const normalizedViews = Array.isArray(views) ? views : (
+      // If null, default to a full screen map view port
+      views ? [views] : [new MapView({ id: "default-view" })]
+    );
+    if (normalizedViews.length && this.props.controller) {
+      normalizedViews[0].props.controller = this.props.controller;
+    }
+    return normalizedViews;
+  }
+  _onContextLost() {
+    const { onError } = this.props;
+    if (this.animationLoop && onError) {
+      onError(new Error("WebGL context is lost"));
+    }
+  }
+  /** Actually run picking */
+  _pickAndCallback() {
+    var _a3, _b3, _c3, _d2, _e2;
+    if (((_a3 = this.device) == null ? void 0 : _a3.type) === "webgpu") {
+      return;
+    }
+    const { _pickRequest } = this;
+    if (_pickRequest.event) {
+      const layers = ((_b3 = this.layerManager) == null ? void 0 : _b3.getLayers()) || [];
+      const has3DPickableLayers = layers.some((layer) => layer.props.pickable === "3d");
+      _pickRequest.unproject3D = has3DPickableLayers;
+      const { result, emptyInfo } = this._pick("pickObject", "pickObject Time", _pickRequest);
+      this.cursorState.isHovering = result.length > 0;
+      let pickedInfo = emptyInfo;
+      let handled = false;
+      for (const info of result) {
+        pickedInfo = info;
+        handled = ((_c3 = info.layer) == null ? void 0 : _c3.onHover(info, _pickRequest.event)) || handled;
+      }
+      if (!handled) {
+        (_e2 = (_d2 = this.props).onHover) == null ? void 0 : _e2.call(_d2, pickedInfo, _pickRequest.event);
+        this.widgetManager.onHover(pickedInfo, _pickRequest.event);
+      }
+      _pickRequest.event = null;
+    }
+  }
+  _updateCursor() {
+    const container = this.props.parent || this.canvas;
+    if (container) {
+      container.style.cursor = this.props.getCursor(this.cursorState);
+    }
+  }
+  _setDevice(device) {
+    var _a3, _b3;
+    this.device = device;
+    if (!this.animationLoop) {
+      return;
+    }
+    if (!this.canvas) {
+      this.canvas = (_a3 = this.device.canvasContext) == null ? void 0 : _a3.canvas;
+      if (!this.canvas.isConnected && this.props.parent) {
+        this.props.parent.insertBefore(this.canvas, this.props.parent.firstChild);
+      }
+    }
+    if (this.device.type === "webgl") {
+      this.device.setParametersWebGL({
+        blend: true,
+        blendFunc: [770, 771, 1, 771],
+        polygonOffsetFill: true,
+        depthTest: true,
+        depthFunc: 515
+      });
+    }
+    this.props.onDeviceInitialized(this.device);
+    if (this.device.type === "webgl") {
+      this.props.onWebGLInitialized(this.device.gl);
+    }
+    const timeline = new Timeline();
+    timeline.play();
+    this.animationLoop.attachTimeline(timeline);
+    this.eventManager = new EventManager(this.props.parent || this.canvas, {
+      touchAction: this.props.touchAction,
+      recognizers: Object.keys(RECOGNIZERS).map((eventName) => {
+        var _a4;
+        const [RecognizerConstructor, defaultOptions2, recognizeWith, requestFailure] = RECOGNIZERS[eventName];
+        const optionsOverride = (_a4 = this.props.eventRecognizerOptions) == null ? void 0 : _a4[eventName];
+        const options = { ...defaultOptions2, ...optionsOverride, event: eventName };
+        return {
+          recognizer: new RecognizerConstructor(options),
+          recognizeWith,
+          requestFailure
+        };
+      }),
+      events: {
+        pointerdown: this._onPointerDown,
+        pointermove: this._onPointerMove,
+        pointerleave: this._onPointerMove
+      }
+    });
+    for (const eventType in EVENT_HANDLERS) {
+      this.eventManager.on(eventType, this._onEvent);
+    }
+    this.viewManager = new ViewManager({
+      timeline,
+      eventManager: this.eventManager,
+      onViewStateChange: this._onViewStateChange.bind(this),
+      onInteractionStateChange: this._onInteractionStateChange.bind(this),
+      views: this._getViews(),
+      viewState: this._getViewState(),
+      width: this.width,
+      height: this.height
+    });
+    const viewport = this.viewManager.getViewports()[0];
+    this.layerManager = new LayerManager(this.device, {
+      deck: this,
+      stats: this.stats,
+      viewport,
+      timeline
+    });
+    this.effectManager = new EffectManager({
+      deck: this,
+      device: this.device
+    });
+    this.deckRenderer = new DeckRenderer(this.device);
+    this.deckPicker = new DeckPicker(this.device);
+    this.widgetManager = new WidgetManager({
+      deck: this,
+      parentElement: (_b3 = this.canvas) == null ? void 0 : _b3.parentElement
+    });
+    this.widgetManager.addDefault(new TooltipWidget());
+    this.setProps(this.props);
+    this._updateCanvasSize();
+    this.props.onLoad();
+  }
+  /** Internal only: default render function (redraw all layers and views) */
+  _drawLayers(redrawReason, renderOptions) {
+    var _a3;
+    const { device, gl: gl2 } = this.layerManager.context;
+    this.props.onBeforeRender({ device, gl: gl2 });
+    const opts = {
+      target: this.props._framebuffer,
+      layers: this.layerManager.getLayers(),
+      viewports: this.viewManager.getViewports(),
+      onViewportActive: this.layerManager.activateViewport,
+      views: this.viewManager.getViews(),
+      pass: "screen",
+      effects: this.effectManager.getEffects(),
+      ...renderOptions
+    };
+    (_a3 = this.deckRenderer) == null ? void 0 : _a3.renderLayers(opts);
+    if (opts.pass === "screen") {
+      this.widgetManager.onRedraw({
+        viewports: opts.viewports,
+        layers: opts.layers
+      });
+    }
+    this.props.onAfterRender({ device, gl: gl2 });
+  }
+  // Callbacks
+  _onRenderFrame() {
+    var _a3;
+    this._getFrameStats();
+    if (this._metricsCounter++ % 60 === 0) {
+      this._getMetrics();
+      this.stats.reset();
+      defaultLogger.table(4, this.metrics)();
+      if (this.props._onMetrics) {
+        this.props._onMetrics(this.metrics);
+      }
+    }
+    this._updateCanvasSize();
+    this._updateCursor();
+    this.layerManager.updateLayers();
+    if (((_a3 = this.device) == null ? void 0 : _a3.type) !== "webgpu") {
+      this._pickAndCallback();
+    }
+    this.redraw();
+    if (this.viewManager) {
+      this.viewManager.updateViewStates();
+    }
+  }
+  // Callbacks
+  _onViewStateChange(params) {
+    const viewState = this.props.onViewStateChange(params) || params.viewState;
+    if (this.viewState) {
+      this.viewState = { ...this.viewState, [params.viewId]: viewState };
+      if (!this.props.viewState) {
+        if (this.viewManager) {
+          this.viewManager.setProps({ viewState: this.viewState });
+        }
+      }
+    }
+  }
+  _onInteractionStateChange(interactionState) {
+    this.cursorState.isDragging = interactionState.isDragging || false;
+    this.props.onInteractionStateChange(interactionState);
+  }
+  _getFrameStats() {
+    const { stats } = this;
+    stats.get("frameRate").timeEnd();
+    stats.get("frameRate").timeStart();
+    const animationLoopStats = this.animationLoop.stats;
+    stats.get("GPU Time").addTime(animationLoopStats.get("GPU Time").lastTiming);
+    stats.get("CPU Time").addTime(animationLoopStats.get("CPU Time").lastTiming);
+  }
+  _getMetrics() {
+    const { metrics, stats } = this;
+    metrics.fps = stats.get("frameRate").getHz();
+    metrics.setPropsTime = stats.get("setProps Time").time;
+    metrics.updateAttributesTime = stats.get("Update Attributes").time;
+    metrics.framesRedrawn = stats.get("Redraw Count").count;
+    metrics.pickTime = stats.get("pickObject Time").time + stats.get("pickMultipleObjects Time").time + stats.get("pickObjects Time").time;
+    metrics.pickCount = stats.get("Pick Count").count;
+    metrics.gpuTime = stats.get("GPU Time").time;
+    metrics.cpuTime = stats.get("CPU Time").time;
+    metrics.gpuTimePerFrame = stats.get("GPU Time").getAverageTime();
+    metrics.cpuTimePerFrame = stats.get("CPU Time").getAverageTime();
+    const memoryStats = luma.stats.get("Memory Usage");
+    metrics.bufferMemory = memoryStats.get("Buffer Memory").count;
+    metrics.textureMemory = memoryStats.get("Texture Memory").count;
+    metrics.renderbufferMemory = memoryStats.get("Renderbuffer Memory").count;
+    metrics.gpuMemory = memoryStats.get("GPU Memory").count;
+  }
+}
+Deck.defaultProps = defaultProps$2;
+Deck.VERSION = VERSION;
+function typedArrayFromDataType(type) {
+  switch (type) {
+    case "float64":
+      return Float64Array;
+    case "uint8":
+    case "unorm8":
+      return Uint8ClampedArray;
+    default:
+      return getTypedArrayConstructor(type);
+  }
+}
+const dataTypeFromTypedArray = getDataType;
+function getBufferAttributeLayout(name2, accessor, deviceType) {
+  const type = deviceType === "webgpu" && accessor.type === "uint8" ? "unorm8" : accessor.type;
+  return {
+    attribute: name2,
+    // @ts-expect-error Not all combinations are valid vertex formats; it's up to DataColumn to ensure
+    format: accessor.size > 1 ? `${type}x${accessor.size}` : accessor.type,
+    byteOffset: accessor.offset || 0
+    // Note stride is set on the top level
+  };
+}
+function getStride(accessor) {
+  return accessor.stride || accessor.size * accessor.bytesPerElement;
+}
+function bufferLayoutEqual(accessor1, accessor2) {
+  return accessor1.type === accessor2.type && accessor1.size === accessor2.size && getStride(accessor1) === getStride(accessor2) && (accessor1.offset || 0) === (accessor2.offset || 0);
+}
+function resolveShaderAttribute(baseAccessor, shaderAttributeOptions) {
+  if (shaderAttributeOptions.offset) {
+    defaultLogger.removed("shaderAttribute.offset", "vertexOffset, elementOffset")();
+  }
+  const stride = getStride(baseAccessor);
+  const vertexOffset = shaderAttributeOptions.vertexOffset !== void 0 ? shaderAttributeOptions.vertexOffset : baseAccessor.vertexOffset || 0;
+  const elementOffset = shaderAttributeOptions.elementOffset || 0;
+  const offset = (
+    // offsets defined by the attribute
+    vertexOffset * stride + elementOffset * baseAccessor.bytesPerElement + // offsets defined by external buffers if any
+    (baseAccessor.offset || 0)
+  );
+  return {
+    ...shaderAttributeOptions,
+    offset,
+    stride
+  };
+}
+function resolveDoublePrecisionShaderAttributes(baseAccessor, shaderAttributeOptions) {
+  const resolvedOptions = resolveShaderAttribute(baseAccessor, shaderAttributeOptions);
+  return {
+    high: resolvedOptions,
+    low: {
+      ...resolvedOptions,
+      offset: resolvedOptions.offset + baseAccessor.size * 4
+    }
+  };
+}
+class DataColumn {
+  /* eslint-disable max-statements */
+  constructor(device, opts, state) {
+    this._buffer = null;
+    this.device = device;
+    this.id = opts.id || "";
+    this.size = opts.size || 1;
+    const logicalType = opts.logicalType || opts.type;
+    const doublePrecision = logicalType === "float64";
+    let { defaultValue } = opts;
+    defaultValue = Number.isFinite(defaultValue) ? [defaultValue] : defaultValue || new Array(this.size).fill(0);
+    let bufferType;
+    if (doublePrecision) {
+      bufferType = "float32";
+    } else if (!logicalType && opts.isIndexed) {
+      bufferType = "uint32";
+    } else {
+      bufferType = logicalType || "float32";
+    }
+    let defaultType = typedArrayFromDataType(logicalType || bufferType);
+    this.doublePrecision = doublePrecision;
+    if (doublePrecision && opts.fp64 === false) {
+      defaultType = Float32Array;
+    }
+    this.value = null;
+    this.settings = {
+      ...opts,
+      defaultType,
+      defaultValue,
+      logicalType,
+      type: bufferType,
+      normalized: bufferType.includes("norm"),
+      size: this.size,
+      bytesPerElement: defaultType.BYTES_PER_ELEMENT
+    };
+    this.state = {
+      ...state,
+      externalBuffer: null,
+      bufferAccessor: this.settings,
+      allocatedValue: null,
+      numInstances: 0,
+      bounds: null,
+      constant: false
+    };
+  }
+  /* eslint-enable max-statements */
+  get isConstant() {
+    return this.state.constant;
+  }
+  get buffer() {
+    return this._buffer;
+  }
+  get byteOffset() {
+    const accessor = this.getAccessor();
+    if (accessor.vertexOffset) {
+      return accessor.vertexOffset * getStride(accessor);
+    }
+    return 0;
+  }
+  get numInstances() {
+    return this.state.numInstances;
+  }
+  set numInstances(n2) {
+    this.state.numInstances = n2;
+  }
+  delete() {
+    if (this._buffer) {
+      this._buffer.delete();
+      this._buffer = null;
+    }
+    defaultTypedArrayManager.release(this.state.allocatedValue);
+  }
+  getBuffer() {
+    if (this.state.constant) {
+      return null;
+    }
+    return this.state.externalBuffer || this._buffer;
+  }
+  getValue(attributeName = this.id, options = null) {
+    const result = {};
+    if (this.state.constant) {
+      const value = this.value;
+      if (options) {
+        const shaderAttributeDef = resolveShaderAttribute(this.getAccessor(), options);
+        const offset = shaderAttributeDef.offset / value.BYTES_PER_ELEMENT;
+        const size = shaderAttributeDef.size || this.size;
+        result[attributeName] = value.subarray(offset, offset + size);
+      } else {
+        result[attributeName] = value;
+      }
+    } else {
+      result[attributeName] = this.getBuffer();
+    }
+    if (this.doublePrecision) {
+      if (this.value instanceof Float64Array) {
+        result[`${attributeName}64Low`] = result[attributeName];
+      } else {
+        result[`${attributeName}64Low`] = new Float32Array(this.size);
+      }
+    }
+    return result;
+  }
+  _getBufferLayout(attributeName = this.id, options = null) {
+    const accessor = this.getAccessor();
+    const attributes = [];
+    const result = {
+      name: this.id,
+      byteStride: getStride(accessor),
+      attributes
+    };
+    if (this.doublePrecision) {
+      const doubleShaderAttributeDefs = resolveDoublePrecisionShaderAttributes(accessor, options || {});
+      attributes.push(getBufferAttributeLayout(attributeName, { ...accessor, ...doubleShaderAttributeDefs.high }, this.device.type), getBufferAttributeLayout(`${attributeName}64Low`, {
+        ...accessor,
+        ...doubleShaderAttributeDefs.low
+      }, this.device.type));
+    } else if (options) {
+      const shaderAttributeDef = resolveShaderAttribute(accessor, options);
+      attributes.push(getBufferAttributeLayout(attributeName, { ...accessor, ...shaderAttributeDef }, this.device.type));
+    } else {
+      attributes.push(getBufferAttributeLayout(attributeName, accessor, this.device.type));
+    }
+    return result;
+  }
+  setAccessor(accessor) {
+    this.state.bufferAccessor = accessor;
+  }
+  getAccessor() {
+    return this.state.bufferAccessor;
+  }
+  // Returns [min: Array(size), max: Array(size)]
+  /* eslint-disable max-depth */
+  getBounds() {
+    if (this.state.bounds) {
+      return this.state.bounds;
+    }
+    let result = null;
+    if (this.state.constant && this.value) {
+      const min = Array.from(this.value);
+      result = [min, min];
+    } else {
+      const { value, numInstances, size } = this;
+      const len2 = numInstances * size;
+      if (value && len2 && value.length >= len2) {
+        const min = new Array(size).fill(Infinity);
+        const max = new Array(size).fill(-Infinity);
+        for (let i2 = 0; i2 < len2; ) {
+          for (let j2 = 0; j2 < size; j2++) {
+            const v2 = value[i2++];
+            if (v2 < min[j2])
+              min[j2] = v2;
+            if (v2 > max[j2])
+              max[j2] = v2;
+          }
+        }
+        result = [min, max];
+      }
+    }
+    this.state.bounds = result;
+    return result;
+  }
+  // returns true if success
+  // eslint-disable-next-line max-statements
+  setData(data) {
+    const { state } = this;
+    let opts;
+    if (ArrayBuffer.isView(data)) {
+      opts = { value: data };
+    } else if (data instanceof Buffer$1) {
+      opts = { buffer: data };
+    } else {
+      opts = data;
+    }
+    const accessor = { ...this.settings, ...opts };
+    if (ArrayBuffer.isView(opts.value)) {
+      if (!opts.type) {
+        const is64Bit = this.doublePrecision && opts.value instanceof Float64Array;
+        if (is64Bit) {
+          accessor.type = "float32";
+        } else {
+          const type = dataTypeFromTypedArray(opts.value);
+          accessor.type = accessor.normalized ? type.replace("int", "norm") : type;
+        }
+      }
+      accessor.bytesPerElement = opts.value.BYTES_PER_ELEMENT;
+      accessor.stride = getStride(accessor);
+    }
+    state.bounds = null;
+    if (opts.constant) {
+      let value = opts.value;
+      value = this._normalizeValue(value, [], 0);
+      if (this.settings.normalized) {
+        value = this.normalizeConstant(value);
+      }
+      const hasChanged = !state.constant || !this._areValuesEqual(value, this.value);
+      if (!hasChanged) {
+        return false;
+      }
+      state.externalBuffer = null;
+      state.constant = true;
+      this.value = ArrayBuffer.isView(value) ? value : new Float32Array(value);
+    } else if (opts.buffer) {
+      const buffer = opts.buffer;
+      state.externalBuffer = buffer;
+      state.constant = false;
+      this.value = opts.value || null;
+    } else if (opts.value) {
+      this._checkExternalBuffer(opts);
+      let value = opts.value;
+      state.externalBuffer = null;
+      state.constant = false;
+      this.value = value;
+      let { buffer } = this;
+      const stride = getStride(accessor);
+      const byteOffset = (accessor.vertexOffset || 0) * stride;
+      if (this.doublePrecision && value instanceof Float64Array) {
+        value = toDoublePrecisionArray(value, accessor);
+      }
+      if (this.settings.isIndexed) {
+        const ArrayType = this.settings.defaultType;
+        if (value.constructor !== ArrayType) {
+          value = new ArrayType(value);
+        }
+      }
+      const requiredBufferSize = value.byteLength + byteOffset + stride * 2;
+      if (!buffer || buffer.byteLength < requiredBufferSize) {
+        buffer = this._createBuffer(requiredBufferSize);
+      }
+      buffer.write(value, byteOffset);
+    }
+    this.setAccessor(accessor);
+    return true;
+  }
+  updateSubBuffer(opts = {}) {
+    this.state.bounds = null;
+    const value = this.value;
+    const { startOffset = 0, endOffset } = opts;
+    this.buffer.write(this.doublePrecision && value instanceof Float64Array ? toDoublePrecisionArray(value, {
+      size: this.size,
+      startIndex: startOffset,
+      endIndex: endOffset
+    }) : value.subarray(startOffset, endOffset), startOffset * value.BYTES_PER_ELEMENT + this.byteOffset);
+  }
+  allocate(numInstances, copy = false) {
+    const { state } = this;
+    const oldValue = state.allocatedValue;
+    const value = defaultTypedArrayManager.allocate(oldValue, numInstances + 1, {
+      size: this.size,
+      type: this.settings.defaultType,
+      copy
+    });
+    this.value = value;
+    const { byteOffset } = this;
+    let { buffer } = this;
+    if (!buffer || buffer.byteLength < value.byteLength + byteOffset) {
+      buffer = this._createBuffer(value.byteLength + byteOffset);
+      if (copy && oldValue) {
+        buffer.write(oldValue instanceof Float64Array ? toDoublePrecisionArray(oldValue, this) : oldValue, byteOffset);
+      }
+    }
+    state.allocatedValue = value;
+    state.constant = false;
+    state.externalBuffer = null;
+    this.setAccessor(this.settings);
+    return true;
+  }
+  // PRIVATE HELPER METHODS
+  _checkExternalBuffer(opts) {
+    const { value } = opts;
+    if (!ArrayBuffer.isView(value)) {
+      throw new Error(`Attribute ${this.id} value is not TypedArray`);
+    }
+    const ArrayType = this.settings.defaultType;
+    let illegalArrayType = false;
+    if (this.doublePrecision) {
+      illegalArrayType = value.BYTES_PER_ELEMENT < 4;
+    }
+    if (illegalArrayType) {
+      throw new Error(`Attribute ${this.id} does not support ${value.constructor.name}`);
+    }
+    if (!(value instanceof ArrayType) && this.settings.normalized && !("normalized" in opts)) {
+      defaultLogger.warn(`Attribute ${this.id} is normalized`)();
+    }
+  }
+  // https://developer.mozilla.org/en-US/docs/Web/API/WebGLRenderingContext/vertexAttribPointer
+  normalizeConstant(value) {
+    switch (this.settings.type) {
+      case "snorm8":
+        return new Float32Array(value).map((x2) => (x2 + 128) / 255 * 2 - 1);
+      case "snorm16":
+        return new Float32Array(value).map((x2) => (x2 + 32768) / 65535 * 2 - 1);
+      case "unorm8":
+        return new Float32Array(value).map((x2) => x2 / 255);
+      case "unorm16":
+        return new Float32Array(value).map((x2) => x2 / 65535);
+      default:
+        return value;
+    }
+  }
+  /* check user supplied values and apply fallback */
+  _normalizeValue(value, out, start) {
+    const { defaultValue, size } = this.settings;
+    if (Number.isFinite(value)) {
+      out[start] = value;
+      return out;
+    }
+    if (!value) {
+      let i2 = size;
+      while (--i2 >= 0) {
+        out[start + i2] = defaultValue[i2];
+      }
+      return out;
+    }
+    switch (size) {
+      case 4:
+        out[start + 3] = Number.isFinite(value[3]) ? value[3] : defaultValue[3];
+      case 3:
+        out[start + 2] = Number.isFinite(value[2]) ? value[2] : defaultValue[2];
+      case 2:
+        out[start + 1] = Number.isFinite(value[1]) ? value[1] : defaultValue[1];
+      case 1:
+        out[start + 0] = Number.isFinite(value[0]) ? value[0] : defaultValue[0];
+        break;
+      default:
+        let i2 = size;
+        while (--i2 >= 0) {
+          out[start + i2] = Number.isFinite(value[i2]) ? value[i2] : defaultValue[i2];
+        }
+    }
+    return out;
+  }
+  _areValuesEqual(value1, value2) {
+    if (!value1 || !value2) {
+      return false;
+    }
+    const { size } = this;
+    for (let i2 = 0; i2 < size; i2++) {
+      if (value1[i2] !== value2[i2]) {
+        return false;
+      }
+    }
+    return true;
+  }
+  _createBuffer(byteLength) {
+    var _a3;
+    if (this._buffer) {
+      this._buffer.destroy();
+    }
+    const { isIndexed, type } = this.settings;
+    this._buffer = this.device.createBuffer({
+      ...(_a3 = this._buffer) == null ? void 0 : _a3.props,
+      id: this.id,
+      // TODO(ibgreen) - WebGPU requires COPY_DST and COPY_SRC to allow write / read
+      usage: (isIndexed ? Buffer$1.INDEX : Buffer$1.VERTEX) | Buffer$1.COPY_DST,
+      indexType: isIndexed ? type : void 0,
+      byteLength
+    });
+    return this._buffer;
+  }
+}
+const EMPTY_ARRAY$1 = [];
+const placeholderArray = [];
+function createIterable(data, startRow = 0, endRow = Infinity) {
+  let iterable = EMPTY_ARRAY$1;
+  const objectInfo = {
+    index: -1,
+    data,
+    // visitor can optionally utilize this to avoid constructing a new array for every object
+    target: []
+  };
+  if (!data) {
+    iterable = EMPTY_ARRAY$1;
+  } else if (typeof data[Symbol.iterator] === "function") {
+    iterable = data;
+  } else if (data.length > 0) {
+    placeholderArray.length = data.length;
+    iterable = placeholderArray;
+  }
+  if (startRow > 0 || Number.isFinite(endRow)) {
+    iterable = (Array.isArray(iterable) ? iterable : Array.from(iterable)).slice(startRow, endRow);
+    objectInfo.index = startRow - 1;
+  }
+  return { iterable, objectInfo };
+}
+function isAsyncIterable(data) {
+  return data && data[Symbol.asyncIterator];
+}
+function getAccessorFromBuffer(typedArray, options) {
+  const { size, stride, offset, startIndices, nested } = options;
+  const bytesPerElement = typedArray.BYTES_PER_ELEMENT;
+  const elementStride = stride ? stride / bytesPerElement : size;
+  const elementOffset = offset ? offset / bytesPerElement : 0;
+  const vertexCount = Math.floor((typedArray.length - elementOffset) / elementStride);
+  return (_2, { index, target }) => {
+    if (!startIndices) {
+      const sourceIndex = index * elementStride + elementOffset;
+      for (let j2 = 0; j2 < size; j2++) {
+        target[j2] = typedArray[sourceIndex + j2];
+      }
+      return target;
+    }
+    const startIndex = startIndices[index];
+    const endIndex = startIndices[index + 1] || vertexCount;
+    let result;
+    if (nested) {
+      result = new Array(endIndex - startIndex);
+      for (let i2 = startIndex; i2 < endIndex; i2++) {
+        const sourceIndex = i2 * elementStride + elementOffset;
+        target = new Array(size);
+        for (let j2 = 0; j2 < size; j2++) {
+          target[j2] = typedArray[sourceIndex + j2];
+        }
+        result[i2 - startIndex] = target;
+      }
+    } else if (elementStride === size) {
+      result = typedArray.subarray(startIndex * size + elementOffset, endIndex * size + elementOffset);
+    } else {
+      result = new typedArray.constructor((endIndex - startIndex) * size);
+      let targetIndex = 0;
+      for (let i2 = startIndex; i2 < endIndex; i2++) {
+        const sourceIndex = i2 * elementStride + elementOffset;
+        for (let j2 = 0; j2 < size; j2++) {
+          result[targetIndex++] = typedArray[sourceIndex + j2];
+        }
+      }
+    }
+    return result;
+  };
+}
+const EMPTY = [];
+const FULL = [[0, Infinity]];
+function add(rangeList, range) {
+  if (rangeList === FULL) {
+    return rangeList;
+  }
+  if (range[0] < 0) {
+    range[0] = 0;
+  }
+  if (range[0] >= range[1]) {
+    return rangeList;
+  }
+  const newRangeList = [];
+  const len2 = rangeList.length;
+  let insertPosition = 0;
+  for (let i2 = 0; i2 < len2; i2++) {
+    const range0 = rangeList[i2];
+    if (range0[1] < range[0]) {
+      newRangeList.push(range0);
+      insertPosition = i2 + 1;
+    } else if (range0[0] > range[1]) {
+      newRangeList.push(range0);
+    } else {
+      range = [Math.min(range0[0], range[0]), Math.max(range0[1], range[1])];
+    }
+  }
+  newRangeList.splice(insertPosition, 0, range);
+  return newRangeList;
+}
+const DEFAULT_TRANSITION_SETTINGS = {
+  interpolation: {
+    duration: 0,
+    easing: (t2) => t2
+  },
+  spring: {
+    stiffness: 0.05,
+    damping: 0.5
+  }
+};
+function normalizeTransitionSettings(userSettings, layerSettings) {
+  if (!userSettings) {
+    return null;
+  }
+  if (Number.isFinite(userSettings)) {
+    userSettings = { type: "interpolation", duration: userSettings };
+  }
+  const type = userSettings.type || "interpolation";
+  return {
+    ...DEFAULT_TRANSITION_SETTINGS[type],
+    ...layerSettings,
+    ...userSettings,
+    type
+  };
+}
+class Attribute extends DataColumn {
+  constructor(device, opts) {
+    super(device, opts, {
+      startIndices: null,
+      lastExternalBuffer: null,
+      binaryValue: null,
+      binaryAccessor: null,
+      needsUpdate: true,
+      needsRedraw: false,
+      layoutChanged: false,
+      updateRanges: FULL
+    });
+    this.constant = false;
+    this.settings.update = opts.update || (opts.accessor ? this._autoUpdater : void 0);
+    Object.seal(this.settings);
+    Object.seal(this.state);
+    this._validateAttributeUpdaters();
+  }
+  get startIndices() {
+    return this.state.startIndices;
+  }
+  set startIndices(layout) {
+    this.state.startIndices = layout;
+  }
+  needsUpdate() {
+    return this.state.needsUpdate;
+  }
+  needsRedraw({ clearChangedFlags = false } = {}) {
+    const needsRedraw = this.state.needsRedraw;
+    this.state.needsRedraw = needsRedraw && !clearChangedFlags;
+    return needsRedraw;
+  }
+  layoutChanged() {
+    return this.state.layoutChanged;
+  }
+  setAccessor(accessor) {
+    var _a3;
+    (_a3 = this.state).layoutChanged || (_a3.layoutChanged = !bufferLayoutEqual(accessor, this.getAccessor()));
+    super.setAccessor(accessor);
+  }
+  getUpdateTriggers() {
+    const { accessor } = this.settings;
+    return [this.id].concat(typeof accessor !== "function" && accessor || []);
+  }
+  supportsTransition() {
+    return Boolean(this.settings.transition);
+  }
+  // Resolve transition settings object if transition is enabled, otherwise `null`
+  getTransitionSetting(opts) {
+    if (!opts || !this.supportsTransition()) {
+      return null;
+    }
+    const { accessor } = this.settings;
+    const layerSettings = this.settings.transition;
+    const userSettings = Array.isArray(accessor) ? (
+      // @ts-ignore
+      opts[accessor.find((a2) => opts[a2])]
+    ) : (
+      // @ts-ignore
+      opts[accessor]
+    );
+    return normalizeTransitionSettings(userSettings, layerSettings);
+  }
+  setNeedsUpdate(reason = this.id, dataRange) {
+    this.state.needsUpdate = this.state.needsUpdate || reason;
+    this.setNeedsRedraw(reason);
+    if (dataRange) {
+      const { startRow = 0, endRow = Infinity } = dataRange;
+      this.state.updateRanges = add(this.state.updateRanges, [startRow, endRow]);
+    } else {
+      this.state.updateRanges = FULL;
+    }
+  }
+  clearNeedsUpdate() {
+    this.state.needsUpdate = false;
+    this.state.updateRanges = EMPTY;
+  }
+  setNeedsRedraw(reason = this.id) {
+    this.state.needsRedraw = this.state.needsRedraw || reason;
+  }
+  allocate(numInstances) {
+    const { state, settings } = this;
+    if (settings.noAlloc) {
+      return false;
+    }
+    if (settings.update) {
+      super.allocate(numInstances, state.updateRanges !== FULL);
+      return true;
+    }
+    return false;
+  }
+  updateBuffer({ numInstances, data, props, context }) {
+    if (!this.needsUpdate()) {
+      return false;
+    }
+    const { state: { updateRanges }, settings: { update, noAlloc } } = this;
+    let updated = true;
+    if (update) {
+      for (const [startRow, endRow] of updateRanges) {
+        update.call(context, this, { data, startRow, endRow, props, numInstances });
+      }
+      if (!this.value) ;
+      else if (this.constant || !this.buffer || this.buffer.byteLength < this.value.byteLength + this.byteOffset) {
+        this.setData({
+          value: this.value,
+          constant: this.constant
+        });
+        this.constant = false;
+      } else {
+        for (const [startRow, endRow] of updateRanges) {
+          const startOffset = Number.isFinite(startRow) ? this.getVertexOffset(startRow) : 0;
+          const endOffset = Number.isFinite(endRow) ? this.getVertexOffset(endRow) : noAlloc || !Number.isFinite(numInstances) ? this.value.length : numInstances * this.size;
+          super.updateSubBuffer({ startOffset, endOffset });
+        }
+      }
+      this._checkAttributeArray();
+    } else {
+      updated = false;
+    }
+    this.clearNeedsUpdate();
+    this.setNeedsRedraw();
+    return updated;
+  }
+  // Use generic value
+  // Returns true if successful
+  setConstantValue(context, value) {
+    const isWebGPU = this.device.type === "webgpu";
+    if (isWebGPU || value === void 0 || typeof value === "function") {
+      if (isWebGPU && typeof value !== "function") {
+        const normalisedValue = this._normalizeValue(value, [], 0);
+        if (!this._areValuesEqual(normalisedValue, this.value)) {
+          this.setNeedsUpdate("WebGPU constant updated");
+        }
+      }
+      return false;
+    }
+    const transformedValue = this.settings.transform && context ? this.settings.transform.call(context, value) : value;
+    const hasChanged = this.setData({ constant: true, value: transformedValue });
+    if (hasChanged) {
+      this.setNeedsRedraw();
+    }
+    this.clearNeedsUpdate();
+    return true;
+  }
+  // Use external buffer
+  // Returns true if successful
+  // eslint-disable-next-line max-statements
+  setExternalBuffer(buffer) {
+    const { state } = this;
+    if (!buffer) {
+      state.lastExternalBuffer = null;
+      return false;
+    }
+    this.clearNeedsUpdate();
+    if (state.lastExternalBuffer === buffer) {
+      return true;
+    }
+    state.lastExternalBuffer = buffer;
+    this.setNeedsRedraw();
+    this.setData(buffer);
+    return true;
+  }
+  // Binary value is a typed array packed from mapping the source data with the accessor
+  // If the returned value from the accessor is the same as the attribute value, set it directly
+  // Otherwise use the auto updater for transform/normalization
+  setBinaryValue(buffer, startIndices = null) {
+    const { state, settings } = this;
+    if (!buffer) {
+      state.binaryValue = null;
+      state.binaryAccessor = null;
+      return false;
+    }
+    if (settings.noAlloc) {
+      return false;
+    }
+    if (state.binaryValue === buffer) {
+      this.clearNeedsUpdate();
+      return true;
+    }
+    state.binaryValue = buffer;
+    this.setNeedsRedraw();
+    const needsUpdate = settings.transform || startIndices !== this.startIndices;
+    if (needsUpdate) {
+      if (ArrayBuffer.isView(buffer)) {
+        buffer = { value: buffer };
+      }
+      const binaryValue = buffer;
+      assert(ArrayBuffer.isView(binaryValue.value), `invalid ${settings.accessor}`);
+      const needsNormalize = Boolean(binaryValue.size) && binaryValue.size !== this.size;
+      state.binaryAccessor = getAccessorFromBuffer(binaryValue.value, {
+        size: binaryValue.size || this.size,
+        stride: binaryValue.stride,
+        offset: binaryValue.offset,
+        startIndices,
+        nested: needsNormalize
+      });
+      return false;
+    }
+    this.clearNeedsUpdate();
+    this.setData(buffer);
+    return true;
+  }
+  getVertexOffset(row) {
+    const { startIndices } = this;
+    const vertexIndex = startIndices ? row < startIndices.length ? startIndices[row] : this.numInstances : row;
+    return vertexIndex * this.size;
+  }
+  getValue() {
+    const shaderAttributeDefs = this.settings.shaderAttributes;
+    const result = super.getValue();
+    if (!shaderAttributeDefs) {
+      return result;
+    }
+    for (const shaderAttributeName in shaderAttributeDefs) {
+      Object.assign(result, super.getValue(shaderAttributeName, shaderAttributeDefs[shaderAttributeName]));
+    }
+    return result;
+  }
+  /** Generate WebGPU-style buffer layout descriptor from this attribute */
+  getBufferLayout(modelInfo) {
+    this.state.layoutChanged = false;
+    const shaderAttributeDefs = this.settings.shaderAttributes;
+    const result = super._getBufferLayout();
+    const { stepMode } = this.settings;
+    if (stepMode === "dynamic") {
+      result.stepMode = modelInfo ? modelInfo.isInstanced ? "instance" : "vertex" : "instance";
+    } else {
+      result.stepMode = stepMode ?? "vertex";
+    }
+    if (!shaderAttributeDefs) {
+      return result;
+    }
+    for (const shaderAttributeName in shaderAttributeDefs) {
+      const map2 = super._getBufferLayout(shaderAttributeName, shaderAttributeDefs[shaderAttributeName]);
+      result.attributes.push(...map2.attributes);
+    }
+    return result;
+  }
+  /* eslint-disable max-depth, max-statements */
+  _autoUpdater(attribute, { data, startRow, endRow, props, numInstances }) {
+    if (attribute.constant) {
+      if (this.context.device.type !== "webgpu") {
+        return;
+      }
+    }
+    const { settings, state, value, size, startIndices } = attribute;
+    const { accessor, transform } = settings;
+    let accessorFunc = state.binaryAccessor || // @ts-ignore
+    (typeof accessor === "function" ? accessor : props[accessor]);
+    if (typeof accessorFunc !== "function" && typeof accessor === "string") {
+      accessorFunc = () => props[accessor];
+    }
+    assert(typeof accessorFunc === "function", `accessor "${accessor}" is not a function`);
+    let i2 = attribute.getVertexOffset(startRow);
+    const { iterable, objectInfo } = createIterable(data, startRow, endRow);
+    for (const object of iterable) {
+      objectInfo.index++;
+      let objectValue = accessorFunc(object, objectInfo);
+      if (transform) {
+        objectValue = transform.call(this, objectValue);
+      }
+      if (startIndices) {
+        const numVertices = (objectInfo.index < startIndices.length - 1 ? startIndices[objectInfo.index + 1] : numInstances) - startIndices[objectInfo.index];
+        if (objectValue && Array.isArray(objectValue[0])) {
+          let startIndex = i2;
+          for (const item of objectValue) {
+            attribute._normalizeValue(item, value, startIndex);
+            startIndex += size;
+          }
+        } else if (objectValue && objectValue.length > size) {
+          value.set(objectValue, i2);
+        } else {
+          attribute._normalizeValue(objectValue, objectInfo.target, 0);
+          fillArray$1({
+            target: value,
+            source: objectInfo.target,
+            start: i2,
+            count: numVertices
+          });
+        }
+        i2 += numVertices * size;
+      } else {
+        attribute._normalizeValue(objectValue, value, i2);
+        i2 += size;
+      }
+    }
+  }
+  /* eslint-enable max-depth, max-statements */
+  // Validate deck.gl level fields
+  _validateAttributeUpdaters() {
+    const { settings } = this;
+    const hasUpdater = settings.noAlloc || typeof settings.update === "function";
+    if (!hasUpdater) {
+      throw new Error(`Attribute ${this.id} missing update or accessor`);
+    }
+  }
+  // check that the first few elements of the attribute are reasonable
+  /* eslint-disable no-fallthrough */
+  _checkAttributeArray() {
+    const { value } = this;
+    const limit = Math.min(4, this.size);
+    if (value && value.length >= limit) {
+      let valid = true;
+      switch (limit) {
+        case 4:
+          valid = valid && Number.isFinite(value[3]);
+        case 3:
+          valid = valid && Number.isFinite(value[2]);
+        case 2:
+          valid = valid && Number.isFinite(value[1]);
+        case 1:
+          valid = valid && Number.isFinite(value[0]);
+          break;
+        default:
+          valid = false;
+      }
+      if (!valid) {
+        throw new Error(`Illegal attribute generated for ${this.id}`);
+      }
+    }
+  }
+}
+function padArrayChunk(options) {
+  const { source: source2, target, start = 0, size, getData } = options;
+  const end = options.end || target.length;
+  const sourceLength = source2.length;
+  const targetLength = end - start;
+  if (sourceLength > targetLength) {
+    target.set(source2.subarray(0, targetLength), start);
+    return;
+  }
+  target.set(source2, start);
+  if (!getData) {
+    return;
+  }
+  let i2 = sourceLength;
+  while (i2 < targetLength) {
+    const datum = getData(i2, source2);
+    for (let j2 = 0; j2 < size; j2++) {
+      target[start + i2] = datum[j2] || 0;
+      i2++;
+    }
+  }
+}
+function padArray({ source: source2, target, size, getData, sourceStartIndices, targetStartIndices }) {
+  if (!sourceStartIndices || !targetStartIndices) {
+    padArrayChunk({
+      source: source2,
+      target,
+      size,
+      getData
+    });
+    return target;
+  }
+  let sourceIndex = 0;
+  let targetIndex = 0;
+  const getChunkData = getData && ((i2, chunk) => getData(i2 + targetIndex, chunk));
+  const n2 = Math.min(sourceStartIndices.length, targetStartIndices.length);
+  for (let i2 = 1; i2 < n2; i2++) {
+    const nextSourceIndex = sourceStartIndices[i2] * size;
+    const nextTargetIndex = targetStartIndices[i2] * size;
+    padArrayChunk({
+      source: source2.subarray(sourceIndex, nextSourceIndex),
+      target,
+      start: targetIndex,
+      end: nextTargetIndex,
+      size,
+      getData: getChunkData
+    });
+    sourceIndex = nextSourceIndex;
+    targetIndex = nextTargetIndex;
+  }
+  if (targetIndex < target.length) {
+    padArrayChunk({
+      // @ts-ignore
+      source: [],
+      target,
+      start: targetIndex,
+      size,
+      getData: getChunkData
+    });
+  }
+  return target;
+}
+function cloneAttribute(attribute) {
+  const { device, settings, value } = attribute;
+  const newAttribute = new Attribute(device, settings);
+  newAttribute.setData({
+    value: value instanceof Float64Array ? new Float64Array(0) : new Float32Array(0),
+    normalized: settings.normalized
+  });
+  return newAttribute;
+}
+function getAttributeTypeFromSize(size) {
+  switch (size) {
+    case 1:
+      return "float";
+    case 2:
+      return "vec2";
+    case 3:
+      return "vec3";
+    case 4:
+      return "vec4";
+    default:
+      throw new Error(`No defined attribute type for size "${size}"`);
+  }
+}
+function getFloat32VertexFormat(size) {
+  switch (size) {
+    case 1:
+      return "float32";
+    case 2:
+      return "float32x2";
+    case 3:
+      return "float32x3";
+    case 4:
+      return "float32x4";
+    default:
+      throw new Error("invalid type size");
+  }
+}
+function cycleBuffers(buffers) {
+  buffers.push(buffers.shift());
+}
+function getAttributeBufferLength(attribute, numInstances) {
+  const { doublePrecision, settings, value, size } = attribute;
+  const multiplier = doublePrecision && value instanceof Float64Array ? 2 : 1;
+  let maxVertexOffset = 0;
+  const { shaderAttributes } = attribute.settings;
+  if (shaderAttributes) {
+    for (const shaderAttribute of Object.values(shaderAttributes)) {
+      maxVertexOffset = Math.max(maxVertexOffset, shaderAttribute.vertexOffset ?? 0);
+    }
+  }
+  return (settings.noAlloc ? value.length : (numInstances + maxVertexOffset) * size) * multiplier;
+}
+function matchBuffer({ device, source: source2, target }) {
+  if (!target || target.byteLength < source2.byteLength) {
+    target == null ? void 0 : target.destroy();
+    target = device.createBuffer({
+      byteLength: source2.byteLength,
+      usage: source2.usage
+    });
+  }
+  return target;
+}
+function padBuffer({ device, buffer, attribute, fromLength, toLength, fromStartIndices, getData = (x2) => x2 }) {
+  const precisionMultiplier = attribute.doublePrecision && attribute.value instanceof Float64Array ? 2 : 1;
+  const size = attribute.size * precisionMultiplier;
+  const byteOffset = attribute.byteOffset;
+  const targetByteOffset = attribute.settings.bytesPerElement < 4 ? byteOffset / attribute.settings.bytesPerElement * 4 : byteOffset;
+  const toStartIndices = attribute.startIndices;
+  const hasStartIndices = fromStartIndices && toStartIndices;
+  const isConstant = attribute.isConstant;
+  if (!hasStartIndices && buffer && fromLength >= toLength) {
+    return buffer;
+  }
+  const ArrayType = attribute.value instanceof Float64Array ? Float32Array : attribute.value.constructor;
+  const toData = isConstant ? attribute.value : (
+    // TODO(v9.1): Avoid non-portable synchronous reads.
+    new ArrayType(attribute.getBuffer().readSyncWebGL(byteOffset, toLength * ArrayType.BYTES_PER_ELEMENT).buffer)
+  );
+  if (attribute.settings.normalized && !isConstant) {
+    const getter = getData;
+    getData = (value, chunk) => attribute.normalizeConstant(getter(value, chunk));
+  }
+  const getMissingData = isConstant ? (i2, chunk) => getData(toData, chunk) : (i2, chunk) => getData(toData.subarray(i2 + byteOffset, i2 + byteOffset + size), chunk);
+  const source2 = buffer ? new Float32Array(buffer.readSyncWebGL(targetByteOffset, fromLength * 4).buffer) : new Float32Array(0);
+  const target = new Float32Array(toLength);
+  padArray({
+    source: source2,
+    target,
+    sourceStartIndices: fromStartIndices,
+    targetStartIndices: toStartIndices,
+    size,
+    getData: getMissingData
+  });
+  if (!buffer || buffer.byteLength < target.byteLength + targetByteOffset) {
+    buffer == null ? void 0 : buffer.destroy();
+    buffer = device.createBuffer({
+      byteLength: target.byteLength + targetByteOffset,
+      usage: 35050
+    });
+  }
+  buffer.write(target, targetByteOffset);
+  return buffer;
+}
+class GPUTransitionBase {
+  constructor({ device, attribute, timeline }) {
+    this.buffers = [];
+    this.currentLength = 0;
+    this.device = device;
+    this.transition = new Transition(timeline);
+    this.attribute = attribute;
+    this.attributeInTransition = cloneAttribute(attribute);
+    this.currentStartIndices = attribute.startIndices;
+  }
+  get inProgress() {
+    return this.transition.inProgress;
+  }
+  start(transitionSettings, numInstances, duration = Infinity) {
+    this.settings = transitionSettings;
+    this.currentStartIndices = this.attribute.startIndices;
+    this.currentLength = getAttributeBufferLength(this.attribute, numInstances);
+    this.transition.start({ ...transitionSettings, duration });
+  }
+  update() {
+    const updated = this.transition.update();
+    if (updated) {
+      this.onUpdate();
+    }
+    return updated;
+  }
+  setBuffer(buffer) {
+    this.attributeInTransition.setData({
+      buffer,
+      normalized: this.attribute.settings.normalized,
+      // Retain placeholder value to generate correct shader layout
+      value: this.attributeInTransition.value
+    });
+  }
+  cancel() {
+    this.transition.cancel();
+  }
+  delete() {
+    this.cancel();
+    for (const buffer of this.buffers) {
+      buffer.destroy();
+    }
+    this.buffers.length = 0;
+  }
+}
+class GPUInterpolationTransition extends GPUTransitionBase {
+  constructor({ device, attribute, timeline }) {
+    super({ device, attribute, timeline });
+    this.type = "interpolation";
+    this.transform = getTransform$1(device, attribute);
+  }
+  start(transitionSettings, numInstances) {
+    const prevLength = this.currentLength;
+    const prevStartIndices = this.currentStartIndices;
+    super.start(transitionSettings, numInstances, transitionSettings.duration);
+    if (transitionSettings.duration <= 0) {
+      this.transition.cancel();
+      return;
+    }
+    const { buffers, attribute } = this;
+    cycleBuffers(buffers);
+    buffers[0] = padBuffer({
+      device: this.device,
+      buffer: buffers[0],
+      attribute,
+      fromLength: prevLength,
+      toLength: this.currentLength,
+      fromStartIndices: prevStartIndices,
+      getData: transitionSettings.enter
+    });
+    buffers[1] = matchBuffer({
+      device: this.device,
+      source: buffers[0],
+      target: buffers[1]
+    });
+    this.setBuffer(buffers[1]);
+    const { transform } = this;
+    const model = transform.model;
+    let vertexCount = Math.floor(this.currentLength / attribute.size);
+    if (useFp64(attribute)) {
+      vertexCount /= 2;
+    }
+    model.setVertexCount(vertexCount);
+    if (attribute.isConstant) {
+      model.setAttributes({ aFrom: buffers[0] });
+      model.setConstantAttributes({ aTo: attribute.value });
+    } else {
+      model.setAttributes({
+        aFrom: buffers[0],
+        aTo: attribute.getBuffer()
+      });
+    }
+    transform.transformFeedback.setBuffers({ vCurrent: buffers[1] });
+  }
+  onUpdate() {
+    const { duration, easing } = this.settings;
+    const { time } = this.transition;
+    let t2 = time / duration;
+    if (easing) {
+      t2 = easing(t2);
+    }
+    const { model } = this.transform;
+    const interpolationProps = { time: t2 };
+    model.shaderInputs.setProps({ interpolation: interpolationProps });
+    this.transform.run({ discard: true });
+  }
+  delete() {
+    super.delete();
+    this.transform.destroy();
+  }
+}
+const uniformBlock$1 = `uniform interpolationUniforms {
+  float time;
+} interpolation;
+`;
+const interpolationUniforms = {
+  name: "interpolation",
+  vs: uniformBlock$1,
+  uniformTypes: {
+    time: "f32"
+  }
+};
+const vs$2 = `#version 300 es
+#define SHADER_NAME interpolation-transition-vertex-shader
+
+in ATTRIBUTE_TYPE aFrom;
+in ATTRIBUTE_TYPE aTo;
+out ATTRIBUTE_TYPE vCurrent;
+
+void main(void) {
+  vCurrent = mix(aFrom, aTo, interpolation.time);
+  gl_Position = vec4(0.0);
+}
+`;
+const vs64 = `#version 300 es
+#define SHADER_NAME interpolation-transition-vertex-shader
+
+in ATTRIBUTE_TYPE aFrom;
+in ATTRIBUTE_TYPE aFrom64Low;
+in ATTRIBUTE_TYPE aTo;
+in ATTRIBUTE_TYPE aTo64Low;
+out ATTRIBUTE_TYPE vCurrent;
+out ATTRIBUTE_TYPE vCurrent64Low;
+
+vec2 mix_fp64(vec2 a, vec2 b, float x) {
+  vec2 range = sub_fp64(b, a);
+  return sum_fp64(a, mul_fp64(range, vec2(x, 0.0)));
+}
+
+void main(void) {
+  for (int i=0; i<ATTRIBUTE_SIZE; i++) {
+    vec2 value = mix_fp64(vec2(aFrom[i], aFrom64Low[i]), vec2(aTo[i], aTo64Low[i]), interpolation.time);
+    vCurrent[i] = value.x;
+    vCurrent64Low[i] = value.y;
+  }
+  gl_Position = vec4(0.0);
+}
+`;
+function useFp64(attribute) {
+  return attribute.doublePrecision && attribute.value instanceof Float64Array;
+}
+function getTransform$1(device, attribute) {
+  const attributeSize = attribute.size;
+  const attributeType = getAttributeTypeFromSize(attributeSize);
+  const inputFormat = getFloat32VertexFormat(attributeSize);
+  const bufferLayout = attribute.getBufferLayout();
+  if (useFp64(attribute)) {
+    return new BufferTransform(device, {
+      vs: vs64,
+      bufferLayout: [
+        {
+          name: "aFrom",
+          byteStride: 8 * attributeSize,
+          attributes: [
+            { attribute: "aFrom", format: inputFormat, byteOffset: 0 },
+            { attribute: "aFrom64Low", format: inputFormat, byteOffset: 4 * attributeSize }
+          ]
+        },
+        {
+          name: "aTo",
+          byteStride: 8 * attributeSize,
+          attributes: [
+            { attribute: "aTo", format: inputFormat, byteOffset: 0 },
+            { attribute: "aTo64Low", format: inputFormat, byteOffset: 4 * attributeSize }
+          ]
+        }
+      ],
+      // @ts-expect-error fp64 module only sets ONE uniform via defaultUniforms
+      modules: [fp64arithmetic, interpolationUniforms],
+      defines: {
+        // @ts-expect-error TODO fix luma type
+        ATTRIBUTE_TYPE: attributeType,
+        // @ts-expect-error TODO fix luma type
+        ATTRIBUTE_SIZE: attributeSize
       },
-      // @method wrapLatLngBounds(bounds: LatLngBounds): LatLngBounds
-      // Returns a `LatLngBounds` with the same size as the given one, ensuring that
-      // its center is within the CRS's bounds.
-      // By default this means the center longitude is wrapped around the dateline so its
-      // value is between -180 and +180 degrees, and the majority of the bounds
-      // overlaps the CRS's bounds.
-      wrapLatLngBounds: function(latlng) {
-        return this.options.crs.wrapLatLngBounds(toLatLngBounds(latlng));
+      // Default uniforms are not set without this
+      moduleSettings: {},
+      varyings: ["vCurrent", "vCurrent64Low"],
+      bufferMode: 35980,
+      disableWarnings: true
+    });
+  }
+  return new BufferTransform(device, {
+    vs: vs$2,
+    bufferLayout: [
+      { name: "aFrom", format: inputFormat },
+      { name: "aTo", format: bufferLayout.attributes[0].format }
+    ],
+    modules: [interpolationUniforms],
+    defines: {
+      // @ts-expect-error TODO fix luma type
+      ATTRIBUTE_TYPE: attributeType
+    },
+    varyings: ["vCurrent"],
+    // TODO investigate why this is needed
+    disableWarnings: true
+  });
+}
+class GPUSpringTransition extends GPUTransitionBase {
+  constructor({ device, attribute, timeline }) {
+    super({ device, attribute, timeline });
+    this.type = "spring";
+    this.texture = getTexture(device);
+    this.framebuffer = getFramebuffer(device, this.texture);
+    this.transform = getTransform(device, attribute);
+  }
+  start(transitionSettings, numInstances) {
+    const prevLength = this.currentLength;
+    const prevStartIndices = this.currentStartIndices;
+    super.start(transitionSettings, numInstances);
+    const { buffers, attribute } = this;
+    for (let i2 = 0; i2 < 2; i2++) {
+      buffers[i2] = padBuffer({
+        device: this.device,
+        buffer: buffers[i2],
+        attribute,
+        fromLength: prevLength,
+        toLength: this.currentLength,
+        fromStartIndices: prevStartIndices,
+        getData: transitionSettings.enter
+      });
+    }
+    buffers[2] = matchBuffer({
+      device: this.device,
+      source: buffers[0],
+      target: buffers[2]
+    });
+    this.setBuffer(buffers[1]);
+    const { model } = this.transform;
+    model.setVertexCount(Math.floor(this.currentLength / attribute.size));
+    if (attribute.isConstant) {
+      model.setConstantAttributes({ aTo: attribute.value });
+    } else {
+      model.setAttributes({ aTo: attribute.getBuffer() });
+    }
+  }
+  onUpdate() {
+    const { buffers, transform, framebuffer, transition } = this;
+    const settings = this.settings;
+    transform.model.setAttributes({
+      aPrev: buffers[0],
+      aCur: buffers[1]
+    });
+    transform.transformFeedback.setBuffers({ vNext: buffers[2] });
+    const springProps = {
+      stiffness: settings.stiffness,
+      damping: settings.damping
+    };
+    transform.model.shaderInputs.setProps({ spring: springProps });
+    transform.run({
+      framebuffer,
+      discard: false,
+      parameters: { viewport: [0, 0, 1, 1] },
+      clearColor: [0, 0, 0, 0]
+    });
+    cycleBuffers(buffers);
+    this.setBuffer(buffers[1]);
+    const isTransitioning = this.device.readPixelsToArrayWebGL(framebuffer)[0] > 0;
+    if (!isTransitioning) {
+      transition.end();
+    }
+  }
+  delete() {
+    super.delete();
+    this.transform.destroy();
+    this.texture.destroy();
+    this.framebuffer.destroy();
+  }
+}
+const uniformBlock = `uniform springUniforms {
+  float damping;
+  float stiffness;
+} spring;
+`;
+const springUniforms = {
+  name: "spring",
+  vs: uniformBlock,
+  uniformTypes: {
+    damping: "f32",
+    stiffness: "f32"
+  }
+};
+const vs$1 = `#version 300 es
+#define SHADER_NAME spring-transition-vertex-shader
+
+#define EPSILON 0.00001
+
+in ATTRIBUTE_TYPE aPrev;
+in ATTRIBUTE_TYPE aCur;
+in ATTRIBUTE_TYPE aTo;
+out ATTRIBUTE_TYPE vNext;
+out float vIsTransitioningFlag;
+
+ATTRIBUTE_TYPE getNextValue(ATTRIBUTE_TYPE cur, ATTRIBUTE_TYPE prev, ATTRIBUTE_TYPE dest) {
+  ATTRIBUTE_TYPE velocity = cur - prev;
+  ATTRIBUTE_TYPE delta = dest - cur;
+  ATTRIBUTE_TYPE force = delta * spring.stiffness;
+  ATTRIBUTE_TYPE resistance = velocity * spring.damping;
+  return force - resistance + velocity + cur;
+}
+
+void main(void) {
+  bool isTransitioning = length(aCur - aPrev) > EPSILON || length(aTo - aCur) > EPSILON;
+  vIsTransitioningFlag = isTransitioning ? 1.0 : 0.0;
+
+  vNext = getNextValue(aCur, aPrev, aTo);
+  gl_Position = vec4(0, 0, 0, 1);
+  gl_PointSize = 100.0;
+}
+`;
+const fs$1 = `#version 300 es
+#define SHADER_NAME spring-transition-is-transitioning-fragment-shader
+
+in float vIsTransitioningFlag;
+
+out vec4 fragColor;
+
+void main(void) {
+  if (vIsTransitioningFlag == 0.0) {
+    discard;
+  }
+  fragColor = vec4(1.0);
+}`;
+function getTransform(device, attribute) {
+  const attributeType = getAttributeTypeFromSize(attribute.size);
+  const format = getFloat32VertexFormat(attribute.size);
+  return new BufferTransform(device, {
+    vs: vs$1,
+    fs: fs$1,
+    bufferLayout: [
+      { name: "aPrev", format },
+      { name: "aCur", format },
+      { name: "aTo", format: attribute.getBufferLayout().attributes[0].format }
+    ],
+    varyings: ["vNext"],
+    modules: [springUniforms],
+    // @ts-expect-error TODO fix luma type
+    defines: { ATTRIBUTE_TYPE: attributeType },
+    parameters: {
+      depthCompare: "always",
+      blendColorOperation: "max",
+      blendColorSrcFactor: "one",
+      blendColorDstFactor: "one",
+      blendAlphaOperation: "max",
+      blendAlphaSrcFactor: "one",
+      blendAlphaDstFactor: "one"
+    }
+  });
+}
+function getTexture(device) {
+  return device.createTexture({
+    data: new Uint8Array(4),
+    format: "rgba8unorm",
+    width: 1,
+    height: 1
+  });
+}
+function getFramebuffer(device, texture) {
+  return device.createFramebuffer({
+    id: "spring-transition-is-transitioning-framebuffer",
+    width: 1,
+    height: 1,
+    colorAttachments: [texture]
+  });
+}
+const TRANSITION_TYPES$1 = {
+  interpolation: GPUInterpolationTransition,
+  spring: GPUSpringTransition
+};
+class AttributeTransitionManager {
+  constructor(device, { id: id2, timeline }) {
+    if (!device)
+      throw new Error("AttributeTransitionManager is constructed without device");
+    this.id = id2;
+    this.device = device;
+    this.timeline = timeline;
+    this.transitions = {};
+    this.needsRedraw = false;
+    this.numInstances = 1;
+  }
+  finalize() {
+    for (const attributeName in this.transitions) {
+      this._removeTransition(attributeName);
+    }
+  }
+  /* Public methods */
+  // Called when attribute manager updates
+  // Check the latest attributes for updates.
+  update({ attributes, transitions, numInstances }) {
+    this.numInstances = numInstances || 1;
+    for (const attributeName in attributes) {
+      const attribute = attributes[attributeName];
+      const settings = attribute.getTransitionSetting(transitions);
+      if (!settings)
+        continue;
+      this._updateAttribute(attributeName, attribute, settings);
+    }
+    for (const attributeName in this.transitions) {
+      const attribute = attributes[attributeName];
+      if (!attribute || !attribute.getTransitionSetting(transitions)) {
+        this._removeTransition(attributeName);
+      }
+    }
+  }
+  // Returns `true` if attribute is transition-enabled
+  hasAttribute(attributeName) {
+    const transition = this.transitions[attributeName];
+    return transition && transition.inProgress;
+  }
+  // Get all the animated attributes
+  getAttributes() {
+    const animatedAttributes = {};
+    for (const attributeName in this.transitions) {
+      const transition = this.transitions[attributeName];
+      if (transition.inProgress) {
+        animatedAttributes[attributeName] = transition.attributeInTransition;
+      }
+    }
+    return animatedAttributes;
+  }
+  /* eslint-disable max-statements */
+  // Called every render cycle, run transform feedback
+  // Returns `true` if anything changes
+  run() {
+    if (this.numInstances === 0) {
+      return false;
+    }
+    for (const attributeName in this.transitions) {
+      const updated = this.transitions[attributeName].update();
+      if (updated) {
+        this.needsRedraw = true;
+      }
+    }
+    const needsRedraw = this.needsRedraw;
+    this.needsRedraw = false;
+    return needsRedraw;
+  }
+  /* eslint-enable max-statements */
+  /* Private methods */
+  _removeTransition(attributeName) {
+    this.transitions[attributeName].delete();
+    delete this.transitions[attributeName];
+  }
+  // Check an attributes for updates
+  // Returns a transition object if a new transition is triggered.
+  _updateAttribute(attributeName, attribute, settings) {
+    const transition = this.transitions[attributeName];
+    let isNew = !transition || transition.type !== settings.type;
+    if (isNew) {
+      if (transition) {
+        this._removeTransition(attributeName);
+      }
+      const TransitionType = TRANSITION_TYPES$1[settings.type];
+      if (TransitionType) {
+        this.transitions[attributeName] = new TransitionType({
+          attribute,
+          timeline: this.timeline,
+          device: this.device
+        });
+      } else {
+        defaultLogger.error(`unsupported transition type '${settings.type}'`)();
+        isNew = false;
+      }
+    }
+    if (isNew || attribute.needsRedraw()) {
+      this.needsRedraw = true;
+      this.transitions[attributeName].start(settings, this.numInstances);
+    }
+  }
+}
+const TRACE_INVALIDATE = "attributeManager.invalidate";
+const TRACE_UPDATE_START = "attributeManager.updateStart";
+const TRACE_UPDATE_END = "attributeManager.updateEnd";
+const TRACE_ATTRIBUTE_UPDATE_START = "attribute.updateStart";
+const TRACE_ATTRIBUTE_ALLOCATE = "attribute.allocate";
+const TRACE_ATTRIBUTE_UPDATE_END = "attribute.updateEnd";
+class AttributeManager {
+  constructor(device, { id: id2 = "attribute-manager", stats, timeline } = {}) {
+    this.mergeBoundsMemoized = memoize(mergeBounds);
+    this.id = id2;
+    this.device = device;
+    this.attributes = {};
+    this.updateTriggers = {};
+    this.needsRedraw = true;
+    this.userData = {};
+    this.stats = stats;
+    this.attributeTransitionManager = new AttributeTransitionManager(device, {
+      id: `${id2}-transitions`,
+      timeline
+    });
+    Object.seal(this);
+  }
+  finalize() {
+    for (const attributeName in this.attributes) {
+      this.attributes[attributeName].delete();
+    }
+    this.attributeTransitionManager.finalize();
+  }
+  // Returns the redraw flag, optionally clearing it.
+  // Redraw flag will be set if any attributes attributes changed since
+  // flag was last cleared.
+  //
+  // @param {String} [clearRedrawFlags=false] - whether to clear the flag
+  // @return {false|String} - reason a redraw is needed.
+  getNeedsRedraw(opts = { clearRedrawFlags: false }) {
+    const redraw = this.needsRedraw;
+    this.needsRedraw = this.needsRedraw && !opts.clearRedrawFlags;
+    return redraw && this.id;
+  }
+  // Sets the redraw flag.
+  // @param {Boolean} redraw=true
+  setNeedsRedraw() {
+    this.needsRedraw = true;
+  }
+  // Adds attributes
+  add(attributes) {
+    this._add(attributes);
+  }
+  // Adds attributes
+  addInstanced(attributes) {
+    this._add(attributes, { stepMode: "instance" });
+  }
+  /**
+   * Removes attributes
+   * Takes an array of attribute names and delete them from
+   * the attribute map if they exists
+   *
+   * @example
+   * attributeManager.remove(['position']);
+   *
+   * @param {Object} attributeNameArray - attribute name array (see above)
+   */
+  remove(attributeNameArray) {
+    for (const name2 of attributeNameArray) {
+      if (this.attributes[name2] !== void 0) {
+        this.attributes[name2].delete();
+        delete this.attributes[name2];
+      }
+    }
+  }
+  // Marks an attribute for update
+  invalidate(triggerName, dataRange) {
+    const invalidatedAttributes = this._invalidateTrigger(triggerName, dataRange);
+    debug(TRACE_INVALIDATE, this, triggerName, invalidatedAttributes);
+  }
+  invalidateAll(dataRange) {
+    for (const attributeName in this.attributes) {
+      this.attributes[attributeName].setNeedsUpdate(attributeName, dataRange);
+    }
+    debug(TRACE_INVALIDATE, this, "all");
+  }
+  // Ensure all attribute buffers are updated from props or data.
+  // eslint-disable-next-line complexity
+  update({ data, numInstances, startIndices = null, transitions, props = {}, buffers = {}, context = {} }) {
+    let updated = false;
+    debug(TRACE_UPDATE_START, this);
+    if (this.stats) {
+      this.stats.get("Update Attributes").timeStart();
+    }
+    for (const attributeName in this.attributes) {
+      const attribute = this.attributes[attributeName];
+      const accessorName = attribute.settings.accessor;
+      attribute.startIndices = startIndices;
+      attribute.numInstances = numInstances;
+      if (props[attributeName]) {
+        defaultLogger.removed(`props.${attributeName}`, `data.attributes.${attributeName}`)();
+      }
+      if (attribute.setExternalBuffer(buffers[attributeName])) ;
+      else if (attribute.setBinaryValue(typeof accessorName === "string" ? buffers[accessorName] : void 0, data.startIndices)) ;
+      else if (typeof accessorName === "string" && !buffers[accessorName] && attribute.setConstantValue(context, props[accessorName])) ;
+      else if (attribute.needsUpdate()) {
+        updated = true;
+        this._updateAttribute({
+          attribute,
+          numInstances,
+          data,
+          props,
+          context
+        });
+      }
+      this.needsRedraw = this.needsRedraw || attribute.needsRedraw();
+    }
+    if (updated) {
+      debug(TRACE_UPDATE_END, this, numInstances);
+    }
+    if (this.stats) {
+      this.stats.get("Update Attributes").timeEnd();
+    }
+    this.attributeTransitionManager.update({
+      attributes: this.attributes,
+      numInstances,
+      transitions
+    });
+  }
+  // Update attribute transition to the current timestamp
+  // Returns `true` if any transition is in progress
+  updateTransition() {
+    const { attributeTransitionManager } = this;
+    const transitionUpdated = attributeTransitionManager.run();
+    this.needsRedraw = this.needsRedraw || transitionUpdated;
+    return transitionUpdated;
+  }
+  /**
+   * Returns all attribute descriptors
+   * Note: Format matches luma.gl Model/Program.setAttributes()
+   * @return {Object} attributes - descriptors
+   */
+  getAttributes() {
+    return { ...this.attributes, ...this.attributeTransitionManager.getAttributes() };
+  }
+  /**
+   * Computes the spatial bounds of a given set of attributes
+   */
+  getBounds(attributeNames) {
+    const bounds = attributeNames.map((attributeName) => {
+      var _a3;
+      return (_a3 = this.attributes[attributeName]) == null ? void 0 : _a3.getBounds();
+    });
+    return this.mergeBoundsMemoized(bounds);
+  }
+  /**
+   * Returns changed attribute descriptors
+   * This indicates which WebGLBuffers need to be updated
+   * @return {Object} attributes - descriptors
+   */
+  getChangedAttributes(opts = { clearChangedFlags: false }) {
+    const { attributes, attributeTransitionManager } = this;
+    const changedAttributes = { ...attributeTransitionManager.getAttributes() };
+    for (const attributeName in attributes) {
+      const attribute = attributes[attributeName];
+      if (attribute.needsRedraw(opts) && !attributeTransitionManager.hasAttribute(attributeName)) {
+        changedAttributes[attributeName] = attribute;
+      }
+    }
+    return changedAttributes;
+  }
+  /** Generate WebGPU-style buffer layout descriptors from all attributes */
+  getBufferLayouts(modelInfo) {
+    return Object.values(this.getAttributes()).map((attribute) => attribute.getBufferLayout(modelInfo));
+  }
+  // PRIVATE METHODS
+  /** Register new attributes */
+  _add(attributes, overrideOptions) {
+    for (const attributeName in attributes) {
+      const attribute = attributes[attributeName];
+      const props = {
+        ...attribute,
+        id: attributeName,
+        size: attribute.isIndexed && 1 || attribute.size || 1,
+        ...overrideOptions
+      };
+      this.attributes[attributeName] = new Attribute(this.device, props);
+    }
+    this._mapUpdateTriggersToAttributes();
+  }
+  // build updateTrigger name to attribute name mapping
+  _mapUpdateTriggersToAttributes() {
+    const triggers = {};
+    for (const attributeName in this.attributes) {
+      const attribute = this.attributes[attributeName];
+      attribute.getUpdateTriggers().forEach((triggerName) => {
+        if (!triggers[triggerName]) {
+          triggers[triggerName] = [];
+        }
+        triggers[triggerName].push(attributeName);
+      });
+    }
+    this.updateTriggers = triggers;
+  }
+  _invalidateTrigger(triggerName, dataRange) {
+    const { attributes, updateTriggers } = this;
+    const invalidatedAttributes = updateTriggers[triggerName];
+    if (invalidatedAttributes) {
+      invalidatedAttributes.forEach((name2) => {
+        const attribute = attributes[name2];
+        if (attribute) {
+          attribute.setNeedsUpdate(attribute.id, dataRange);
+        }
+      });
+    }
+    return invalidatedAttributes;
+  }
+  _updateAttribute(opts) {
+    const { attribute, numInstances } = opts;
+    debug(TRACE_ATTRIBUTE_UPDATE_START, attribute);
+    if (attribute.constant) {
+      attribute.setConstantValue(opts.context, attribute.value);
+      return;
+    }
+    if (attribute.allocate(numInstances)) {
+      debug(TRACE_ATTRIBUTE_ALLOCATE, attribute, numInstances);
+    }
+    const updated = attribute.updateBuffer(opts);
+    if (updated) {
+      this.needsRedraw = true;
+      debug(TRACE_ATTRIBUTE_UPDATE_END, attribute, numInstances);
+    }
+  }
+}
+class CPUInterpolationTransition extends Transition {
+  get value() {
+    return this._value;
+  }
+  _onUpdate() {
+    const { time, settings: { fromValue, toValue, duration, easing } } = this;
+    const t2 = easing(time / duration);
+    this._value = lerp$2(fromValue, toValue, t2);
+  }
+}
+const EPSILON = 1e-5;
+function updateSpringElement(prev, cur, dest, damping, stiffness) {
+  const velocity = cur - prev;
+  const delta = dest - cur;
+  const spring = delta * stiffness;
+  const damper = -velocity * damping;
+  return spring + damper + velocity + cur;
+}
+function updateSpring(prev, cur, dest, damping, stiffness) {
+  if (Array.isArray(dest)) {
+    const next = [];
+    for (let i2 = 0; i2 < dest.length; i2++) {
+      next[i2] = updateSpringElement(prev[i2], cur[i2], dest[i2], damping, stiffness);
+    }
+    return next;
+  }
+  return updateSpringElement(prev, cur, dest, damping, stiffness);
+}
+function distance(value1, value2) {
+  if (Array.isArray(value1)) {
+    let distanceSquare = 0;
+    for (let i2 = 0; i2 < value1.length; i2++) {
+      const d2 = value1[i2] - value2[i2];
+      distanceSquare += d2 * d2;
+    }
+    return Math.sqrt(distanceSquare);
+  }
+  return Math.abs(value1 - value2);
+}
+class CPUSpringTransition extends Transition {
+  get value() {
+    return this._currValue;
+  }
+  _onUpdate() {
+    const { fromValue, toValue, damping, stiffness } = this.settings;
+    const { _prevValue = fromValue, _currValue = fromValue } = this;
+    let nextValue = updateSpring(_prevValue, _currValue, toValue, damping, stiffness);
+    const delta = distance(nextValue, toValue);
+    const velocity = distance(nextValue, _currValue);
+    if (delta < EPSILON && velocity < EPSILON) {
+      nextValue = toValue;
+      this.end();
+    }
+    this._prevValue = _currValue;
+    this._currValue = nextValue;
+  }
+}
+const TRANSITION_TYPES = {
+  interpolation: CPUInterpolationTransition,
+  spring: CPUSpringTransition
+};
+class UniformTransitionManager {
+  constructor(timeline) {
+    this.transitions = /* @__PURE__ */ new Map();
+    this.timeline = timeline;
+  }
+  get active() {
+    return this.transitions.size > 0;
+  }
+  add(key, fromValue, toValue, settings) {
+    const { transitions } = this;
+    if (transitions.has(key)) {
+      const transition2 = transitions.get(key);
+      const { value = transition2.settings.fromValue } = transition2;
+      fromValue = value;
+      this.remove(key);
+    }
+    settings = normalizeTransitionSettings(settings);
+    if (!settings) {
+      return;
+    }
+    const TransitionType = TRANSITION_TYPES[settings.type];
+    if (!TransitionType) {
+      defaultLogger.error(`unsupported transition type '${settings.type}'`)();
+      return;
+    }
+    const transition = new TransitionType(this.timeline);
+    transition.start({
+      ...settings,
+      fromValue,
+      toValue
+    });
+    transitions.set(key, transition);
+  }
+  remove(key) {
+    const { transitions } = this;
+    if (transitions.has(key)) {
+      transitions.get(key).cancel();
+      transitions.delete(key);
+    }
+  }
+  update() {
+    const propsInTransition = {};
+    for (const [key, transition] of this.transitions) {
+      transition.update();
+      propsInTransition[key] = transition.value;
+      if (!transition.inProgress) {
+        this.remove(key);
+      }
+    }
+    return propsInTransition;
+  }
+  clear() {
+    for (const key of this.transitions.keys()) {
+      this.remove(key);
+    }
+  }
+}
+function validateProps(props) {
+  const propTypes2 = props[PROP_TYPES_SYMBOL];
+  for (const propName in propTypes2) {
+    const propType = propTypes2[propName];
+    const { validate } = propType;
+    if (validate && !validate(props[propName], propType)) {
+      throw new Error(`Invalid prop ${propName}: ${props[propName]}`);
+    }
+  }
+}
+function diffProps(props, oldProps) {
+  const propsChangedReason = compareProps({
+    newProps: props,
+    oldProps,
+    propTypes: props[PROP_TYPES_SYMBOL],
+    ignoreProps: { data: null, updateTriggers: null, extensions: null, transitions: null }
+  });
+  const dataChangedReason = diffDataProps(props, oldProps);
+  let updateTriggersChangedReason = false;
+  if (!dataChangedReason) {
+    updateTriggersChangedReason = diffUpdateTriggers(props, oldProps);
+  }
+  return {
+    dataChanged: dataChangedReason,
+    propsChanged: propsChangedReason,
+    updateTriggersChanged: updateTriggersChangedReason,
+    extensionsChanged: diffExtensions(props, oldProps),
+    transitionsChanged: diffTransitions(props, oldProps)
+  };
+}
+function diffTransitions(props, oldProps) {
+  if (!props.transitions) {
+    return false;
+  }
+  const result = {};
+  const propTypes2 = props[PROP_TYPES_SYMBOL];
+  let changed = false;
+  for (const key in props.transitions) {
+    const propType = propTypes2[key];
+    const type = propType && propType.type;
+    const isTransitionable = type === "number" || type === "color" || type === "array";
+    if (isTransitionable && comparePropValues(props[key], oldProps[key], propType)) {
+      result[key] = true;
+      changed = true;
+    }
+  }
+  return changed ? result : false;
+}
+function compareProps({ newProps, oldProps, ignoreProps = {}, propTypes: propTypes2 = {}, triggerName = "props" }) {
+  if (oldProps === newProps) {
+    return false;
+  }
+  if (typeof newProps !== "object" || newProps === null) {
+    return `${triggerName} changed shallowly`;
+  }
+  if (typeof oldProps !== "object" || oldProps === null) {
+    return `${triggerName} changed shallowly`;
+  }
+  for (const key of Object.keys(newProps)) {
+    if (!(key in ignoreProps)) {
+      if (!(key in oldProps)) {
+        return `${triggerName}.${key} added`;
+      }
+      const changed = comparePropValues(newProps[key], oldProps[key], propTypes2[key]);
+      if (changed) {
+        return `${triggerName}.${key} ${changed}`;
+      }
+    }
+  }
+  for (const key of Object.keys(oldProps)) {
+    if (!(key in ignoreProps)) {
+      if (!(key in newProps)) {
+        return `${triggerName}.${key} dropped`;
+      }
+      if (!Object.hasOwnProperty.call(newProps, key)) {
+        const changed = comparePropValues(newProps[key], oldProps[key], propTypes2[key]);
+        if (changed) {
+          return `${triggerName}.${key} ${changed}`;
+        }
+      }
+    }
+  }
+  return false;
+}
+function comparePropValues(newProp, oldProp, propType) {
+  let equal = propType && propType.equal;
+  if (equal && !equal(newProp, oldProp, propType)) {
+    return "changed deeply";
+  }
+  if (!equal) {
+    equal = newProp && oldProp && newProp.equals;
+    if (equal && !equal.call(newProp, oldProp)) {
+      return "changed deeply";
+    }
+  }
+  if (!equal && oldProp !== newProp) {
+    return "changed shallowly";
+  }
+  return null;
+}
+function diffDataProps(props, oldProps) {
+  if (oldProps === null) {
+    return "oldProps is null, initial diff";
+  }
+  let dataChanged = false;
+  const { dataComparator, _dataDiff } = props;
+  if (dataComparator) {
+    if (!dataComparator(props.data, oldProps.data)) {
+      dataChanged = "Data comparator detected a change";
+    }
+  } else if (props.data !== oldProps.data) {
+    dataChanged = "A new data container was supplied";
+  }
+  if (dataChanged && _dataDiff) {
+    dataChanged = _dataDiff(props.data, oldProps.data) || dataChanged;
+  }
+  return dataChanged;
+}
+function diffUpdateTriggers(props, oldProps) {
+  if (oldProps === null) {
+    return { all: true };
+  }
+  if ("all" in props.updateTriggers) {
+    const diffReason = diffUpdateTrigger(props, oldProps, "all");
+    if (diffReason) {
+      return { all: true };
+    }
+  }
+  const reason = {};
+  let changed = false;
+  for (const triggerName in props.updateTriggers) {
+    if (triggerName !== "all") {
+      const diffReason = diffUpdateTrigger(props, oldProps, triggerName);
+      if (diffReason) {
+        reason[triggerName] = true;
+        changed = true;
+      }
+    }
+  }
+  return changed ? reason : false;
+}
+function diffExtensions(props, oldProps) {
+  if (oldProps === null) {
+    return true;
+  }
+  const oldExtensions = oldProps.extensions;
+  const { extensions } = props;
+  if (extensions === oldExtensions) {
+    return false;
+  }
+  if (!oldExtensions || !extensions) {
+    return true;
+  }
+  if (extensions.length !== oldExtensions.length) {
+    return true;
+  }
+  for (let i2 = 0; i2 < extensions.length; i2++) {
+    if (!extensions[i2].equals(oldExtensions[i2])) {
+      return true;
+    }
+  }
+  return false;
+}
+function diffUpdateTrigger(props, oldProps, triggerName) {
+  let newTriggers = props.updateTriggers[triggerName];
+  newTriggers = newTriggers === void 0 || newTriggers === null ? {} : newTriggers;
+  let oldTriggers = oldProps.updateTriggers[triggerName];
+  oldTriggers = oldTriggers === void 0 || oldTriggers === null ? {} : oldTriggers;
+  const diffReason = compareProps({
+    oldProps: oldTriggers,
+    newProps: newTriggers,
+    triggerName
+  });
+  return diffReason;
+}
+const ERR_NOT_OBJECT = "count(): argument not an object";
+const ERR_NOT_CONTAINER = "count(): argument not a container";
+function count(container) {
+  if (!isObject(container)) {
+    throw new Error(ERR_NOT_OBJECT);
+  }
+  if (typeof container.count === "function") {
+    return container.count();
+  }
+  if (Number.isFinite(container.size)) {
+    return container.size;
+  }
+  if (Number.isFinite(container.length)) {
+    return container.length;
+  }
+  if (isPlainObject(container)) {
+    return Object.keys(container).length;
+  }
+  throw new Error(ERR_NOT_CONTAINER);
+}
+function isPlainObject(value) {
+  return value !== null && typeof value === "object" && value.constructor === Object;
+}
+function isObject(value) {
+  return value !== null && typeof value === "object";
+}
+function mergeShaders(target, source2) {
+  if (!source2) {
+    return target;
+  }
+  const result = { ...target, ...source2 };
+  if ("defines" in source2) {
+    result.defines = { ...target.defines, ...source2.defines };
+  }
+  if ("modules" in source2) {
+    result.modules = (target.modules || []).concat(source2.modules);
+    if (source2.modules.some((module) => module.name === "project64")) {
+      const index = result.modules.findIndex((module) => module.name === "project32");
+      if (index >= 0) {
+        result.modules.splice(index, 1);
+      }
+    }
+  }
+  if ("inject" in source2) {
+    if (!target.inject) {
+      result.inject = source2.inject;
+    } else {
+      const mergedInjection = { ...target.inject };
+      for (const key in source2.inject) {
+        mergedInjection[key] = (mergedInjection[key] || "") + source2.inject[key];
+      }
+      result.inject = mergedInjection;
+    }
+  }
+  return result;
+}
+const DEFAULT_TEXTURE_PARAMETERS = {
+  minFilter: "linear",
+  mipmapFilter: "linear",
+  magFilter: "linear",
+  addressModeU: "clamp-to-edge",
+  addressModeV: "clamp-to-edge"
+};
+const internalTextures = {};
+function createTexture(owner, device, image, sampler) {
+  if (image instanceof Texture) {
+    return image;
+  } else if (image.constructor && image.constructor.name !== "Object") {
+    image = { data: image };
+  }
+  let samplerParameters = null;
+  if (image.compressed) {
+    samplerParameters = {
+      minFilter: "linear",
+      mipmapFilter: image.data.length > 1 ? "nearest" : "linear"
+    };
+  }
+  const { width, height } = image.data;
+  const texture = device.createTexture({
+    ...image,
+    sampler: {
+      ...DEFAULT_TEXTURE_PARAMETERS,
+      ...samplerParameters,
+      ...sampler
+    },
+    mipLevels: device.getMipLevelCount(width, height)
+  });
+  texture.generateMipmapsWebGL();
+  internalTextures[texture.id] = owner;
+  return texture;
+}
+function destroyTexture(owner, texture) {
+  if (!texture || !(texture instanceof Texture)) {
+    return;
+  }
+  if (internalTextures[texture.id] === owner) {
+    texture.delete();
+    delete internalTextures[texture.id];
+  }
+}
+const TYPE_DEFINITIONS = {
+  boolean: {
+    validate(value, propType) {
+      return true;
+    },
+    equal(value1, value2, propType) {
+      return Boolean(value1) === Boolean(value2);
+    }
+  },
+  number: {
+    validate(value, propType) {
+      return Number.isFinite(value) && (!("max" in propType) || value <= propType.max) && (!("min" in propType) || value >= propType.min);
+    }
+  },
+  color: {
+    validate(value, propType) {
+      return propType.optional && !value || isArray(value) && (value.length === 3 || value.length === 4);
+    },
+    equal(value1, value2, propType) {
+      return deepEqual(value1, value2, 1);
+    }
+  },
+  accessor: {
+    validate(value, propType) {
+      const valueType = getTypeOf(value);
+      return valueType === "function" || valueType === getTypeOf(propType.value);
+    },
+    equal(value1, value2, propType) {
+      if (typeof value2 === "function") {
+        return true;
+      }
+      return deepEqual(value1, value2, 1);
+    }
+  },
+  array: {
+    validate(value, propType) {
+      return propType.optional && !value || isArray(value);
+    },
+    equal(value1, value2, propType) {
+      const { compare } = propType;
+      const depth = Number.isInteger(compare) ? compare : compare ? 1 : 0;
+      return compare ? deepEqual(value1, value2, depth) : value1 === value2;
+    }
+  },
+  object: {
+    equal(value1, value2, propType) {
+      if (propType.ignore) {
+        return true;
+      }
+      const { compare } = propType;
+      const depth = Number.isInteger(compare) ? compare : compare ? 1 : 0;
+      return compare ? deepEqual(value1, value2, depth) : value1 === value2;
+    }
+  },
+  function: {
+    validate(value, propType) {
+      return propType.optional && !value || typeof value === "function";
+    },
+    equal(value1, value2, propType) {
+      const shouldIgnore = !propType.compare && propType.ignore !== false;
+      return shouldIgnore || value1 === value2;
+    }
+  },
+  data: {
+    transform: (value, propType, component) => {
+      if (!value) {
+        return value;
+      }
+      const { dataTransform } = component.props;
+      if (dataTransform) {
+        return dataTransform(value);
+      }
+      if (typeof value.shape === "string" && value.shape.endsWith("-table") && Array.isArray(value.data)) {
+        return value.data;
+      }
+      return value;
+    }
+  },
+  image: {
+    transform: (value, propType, component) => {
+      const context = component.context;
+      if (!context || !context.device) {
+        return null;
+      }
+      return createTexture(component.id, context.device, value, {
+        ...propType.parameters,
+        ...component.props.textureParameters
+      });
+    },
+    release: (value, propType, component) => {
+      destroyTexture(component.id, value);
+    }
+  }
+};
+function parsePropTypes(propDefs) {
+  const propTypes2 = {};
+  const defaultProps2 = {};
+  const deprecatedProps = {};
+  for (const [propName, propDef] of Object.entries(propDefs)) {
+    const deprecated = propDef == null ? void 0 : propDef.deprecatedFor;
+    if (deprecated) {
+      deprecatedProps[propName] = Array.isArray(deprecated) ? deprecated : [deprecated];
+    } else {
+      const propType = parsePropType(propName, propDef);
+      propTypes2[propName] = propType;
+      defaultProps2[propName] = propType.value;
+    }
+  }
+  return { propTypes: propTypes2, defaultProps: defaultProps2, deprecatedProps };
+}
+function parsePropType(name2, propDef) {
+  switch (getTypeOf(propDef)) {
+    case "object":
+      return normalizePropDefinition(name2, propDef);
+    case "array":
+      return normalizePropDefinition(name2, { type: "array", value: propDef, compare: false });
+    case "boolean":
+      return normalizePropDefinition(name2, { type: "boolean", value: propDef });
+    case "number":
+      return normalizePropDefinition(name2, { type: "number", value: propDef });
+    case "function":
+      return normalizePropDefinition(name2, { type: "function", value: propDef, compare: true });
+    default:
+      return { name: name2, type: "unknown", value: propDef };
+  }
+}
+function normalizePropDefinition(name2, propDef) {
+  if (!("type" in propDef)) {
+    if (!("value" in propDef)) {
+      return { name: name2, type: "object", value: propDef };
+    }
+    return { name: name2, type: getTypeOf(propDef.value), ...propDef };
+  }
+  return { name: name2, ...TYPE_DEFINITIONS[propDef.type], ...propDef };
+}
+function isArray(value) {
+  return Array.isArray(value) || ArrayBuffer.isView(value);
+}
+function getTypeOf(value) {
+  if (isArray(value)) {
+    return "array";
+  }
+  if (value === null) {
+    return "null";
+  }
+  return typeof value;
+}
+function createProps(component, propObjects) {
+  let extensions;
+  for (let i2 = propObjects.length - 1; i2 >= 0; i2--) {
+    const props = propObjects[i2];
+    if ("extensions" in props) {
+      extensions = props.extensions;
+    }
+  }
+  const propsPrototype = getPropsPrototype(component.constructor, extensions);
+  const propsInstance = Object.create(propsPrototype);
+  propsInstance[COMPONENT_SYMBOL] = component;
+  propsInstance[ASYNC_ORIGINAL_SYMBOL] = {};
+  propsInstance[ASYNC_RESOLVED_SYMBOL] = {};
+  for (let i2 = 0; i2 < propObjects.length; ++i2) {
+    const props = propObjects[i2];
+    for (const key in props) {
+      propsInstance[key] = props[key];
+    }
+  }
+  Object.freeze(propsInstance);
+  return propsInstance;
+}
+const MergedDefaultPropsCacheKey = "_mergedDefaultProps";
+function getPropsPrototype(componentClass, extensions) {
+  if (!(componentClass instanceof Component.constructor))
+    return {};
+  let cacheKey = MergedDefaultPropsCacheKey;
+  if (extensions) {
+    for (const extension of extensions) {
+      const ExtensionClass = extension.constructor;
+      if (ExtensionClass) {
+        cacheKey += `:${ExtensionClass.extensionName || ExtensionClass.name}`;
+      }
+    }
+  }
+  const defaultProps2 = getOwnProperty(componentClass, cacheKey);
+  if (!defaultProps2) {
+    return componentClass[cacheKey] = createPropsPrototypeAndTypes(componentClass, extensions || []);
+  }
+  return defaultProps2;
+}
+function createPropsPrototypeAndTypes(componentClass, extensions) {
+  const parent = componentClass.prototype;
+  if (!parent) {
+    return null;
+  }
+  const parentClass = Object.getPrototypeOf(componentClass);
+  const parentDefaultProps = getPropsPrototype(parentClass);
+  const componentDefaultProps = getOwnProperty(componentClass, "defaultProps") || {};
+  const componentPropDefs = parsePropTypes(componentDefaultProps);
+  const defaultProps2 = Object.assign(/* @__PURE__ */ Object.create(null), parentDefaultProps, componentPropDefs.defaultProps);
+  const propTypes2 = Object.assign(/* @__PURE__ */ Object.create(null), parentDefaultProps == null ? void 0 : parentDefaultProps[PROP_TYPES_SYMBOL], componentPropDefs.propTypes);
+  const deprecatedProps = Object.assign(/* @__PURE__ */ Object.create(null), parentDefaultProps == null ? void 0 : parentDefaultProps[DEPRECATED_PROPS_SYMBOL], componentPropDefs.deprecatedProps);
+  for (const extension of extensions) {
+    const extensionDefaultProps = getPropsPrototype(extension.constructor);
+    if (extensionDefaultProps) {
+      Object.assign(defaultProps2, extensionDefaultProps);
+      Object.assign(propTypes2, extensionDefaultProps[PROP_TYPES_SYMBOL]);
+      Object.assign(deprecatedProps, extensionDefaultProps[DEPRECATED_PROPS_SYMBOL]);
+    }
+  }
+  createPropsPrototype(defaultProps2, componentClass);
+  addAsyncPropsToPropPrototype(defaultProps2, propTypes2);
+  addDeprecatedPropsToPropPrototype(defaultProps2, deprecatedProps);
+  defaultProps2[PROP_TYPES_SYMBOL] = propTypes2;
+  defaultProps2[DEPRECATED_PROPS_SYMBOL] = deprecatedProps;
+  if (extensions.length === 0 && !hasOwnProperty$1(componentClass, "_propTypes")) {
+    componentClass._propTypes = propTypes2;
+  }
+  return defaultProps2;
+}
+function createPropsPrototype(defaultProps2, componentClass) {
+  const id2 = getComponentName(componentClass);
+  Object.defineProperties(defaultProps2, {
+    // `id` is treated specially because layer might need to override it
+    id: {
+      writable: true,
+      value: id2
+    }
+  });
+}
+function addDeprecatedPropsToPropPrototype(defaultProps2, deprecatedProps) {
+  for (const propName in deprecatedProps) {
+    Object.defineProperty(defaultProps2, propName, {
+      enumerable: false,
+      set(newValue) {
+        const nameStr = `${this.id}: ${propName}`;
+        for (const newPropName of deprecatedProps[propName]) {
+          if (!hasOwnProperty$1(this, newPropName)) {
+            this[newPropName] = newValue;
+          }
+        }
+        defaultLogger.deprecated(nameStr, deprecatedProps[propName].join("/"))();
+      }
+    });
+  }
+}
+function addAsyncPropsToPropPrototype(defaultProps2, propTypes2) {
+  const defaultValues = {};
+  const descriptors = {};
+  for (const propName in propTypes2) {
+    const propType = propTypes2[propName];
+    const { name: name2, value } = propType;
+    if (propType.async) {
+      defaultValues[name2] = value;
+      descriptors[name2] = getDescriptorForAsyncProp(name2);
+    }
+  }
+  defaultProps2[ASYNC_DEFAULTS_SYMBOL] = defaultValues;
+  defaultProps2[ASYNC_ORIGINAL_SYMBOL] = {};
+  Object.defineProperties(defaultProps2, descriptors);
+}
+function getDescriptorForAsyncProp(name2) {
+  return {
+    enumerable: true,
+    // Save the provided value for async props in a special map
+    set(newValue) {
+      if (typeof newValue === "string" || newValue instanceof Promise || isAsyncIterable(newValue)) {
+        this[ASYNC_ORIGINAL_SYMBOL][name2] = newValue;
+      } else {
+        this[ASYNC_RESOLVED_SYMBOL][name2] = newValue;
+      }
+    },
+    // Only the component's state knows the true value of async prop
+    get() {
+      if (this[ASYNC_RESOLVED_SYMBOL]) {
+        if (name2 in this[ASYNC_RESOLVED_SYMBOL]) {
+          const value = this[ASYNC_RESOLVED_SYMBOL][name2];
+          return value || this[ASYNC_DEFAULTS_SYMBOL][name2];
+        }
+        if (name2 in this[ASYNC_ORIGINAL_SYMBOL]) {
+          const state = this[COMPONENT_SYMBOL] && this[COMPONENT_SYMBOL].internalState;
+          if (state && state.hasAsyncProp(name2)) {
+            return state.getAsyncProp(name2) || this[ASYNC_DEFAULTS_SYMBOL][name2];
+          }
+        }
+      }
+      return this[ASYNC_DEFAULTS_SYMBOL][name2];
+    }
+  };
+}
+function hasOwnProperty$1(object, prop) {
+  return Object.prototype.hasOwnProperty.call(object, prop);
+}
+function getOwnProperty(object, prop) {
+  return hasOwnProperty$1(object, prop) && object[prop];
+}
+function getComponentName(componentClass) {
+  const componentName = componentClass.componentName;
+  if (!componentName) {
+    defaultLogger.warn(`${componentClass.name}.componentName not specified`)();
+  }
+  return componentName || componentClass.name;
+}
+let counter = 0;
+class Component {
+  constructor(...propObjects) {
+    this.props = createProps(this, propObjects);
+    this.id = this.props.id;
+    this.count = counter++;
+  }
+  // clone this layer with modified props
+  clone(newProps) {
+    const { props } = this;
+    const asyncProps = {};
+    for (const key in props[ASYNC_DEFAULTS_SYMBOL]) {
+      if (key in props[ASYNC_RESOLVED_SYMBOL]) {
+        asyncProps[key] = props[ASYNC_RESOLVED_SYMBOL][key];
+      } else if (key in props[ASYNC_ORIGINAL_SYMBOL]) {
+        asyncProps[key] = props[ASYNC_ORIGINAL_SYMBOL][key];
+      }
+    }
+    return new this.constructor({ ...props, ...asyncProps, ...newProps });
+  }
+}
+Component.componentName = "Component";
+Component.defaultProps = {};
+const EMPTY_PROPS = Object.freeze({});
+class ComponentState {
+  constructor(component) {
+    this.component = component;
+    this.asyncProps = {};
+    this.onAsyncPropUpdated = () => {
+    };
+    this.oldProps = null;
+    this.oldAsyncProps = null;
+  }
+  finalize() {
+    for (const propName in this.asyncProps) {
+      const asyncProp = this.asyncProps[propName];
+      if (asyncProp && asyncProp.type && asyncProp.type.release) {
+        asyncProp.type.release(asyncProp.resolvedValue, asyncProp.type, this.component);
+      }
+    }
+    this.asyncProps = {};
+    this.component = null;
+    this.resetOldProps();
+  }
+  /* Layer-facing props API */
+  getOldProps() {
+    return this.oldAsyncProps || this.oldProps || EMPTY_PROPS;
+  }
+  resetOldProps() {
+    this.oldAsyncProps = null;
+    this.oldProps = this.component ? this.component.props : null;
+  }
+  // Checks if a prop is overridden
+  hasAsyncProp(propName) {
+    return propName in this.asyncProps;
+  }
+  // Returns value of an overriden prop
+  getAsyncProp(propName) {
+    const asyncProp = this.asyncProps[propName];
+    return asyncProp && asyncProp.resolvedValue;
+  }
+  isAsyncPropLoading(propName) {
+    if (propName) {
+      const asyncProp = this.asyncProps[propName];
+      return Boolean(asyncProp && asyncProp.pendingLoadCount > 0 && asyncProp.pendingLoadCount !== asyncProp.resolvedLoadCount);
+    }
+    for (const key in this.asyncProps) {
+      if (this.isAsyncPropLoading(key)) {
+        return true;
+      }
+    }
+    return false;
+  }
+  // Without changing the original prop value, swap out the data resolution under the hood
+  reloadAsyncProp(propName, value) {
+    this._watchPromise(propName, Promise.resolve(value));
+  }
+  // Updates all async/overridden props (when new props come in)
+  // Checks if urls have changed, starts loading, or removes override
+  setAsyncProps(props) {
+    this.component = props[COMPONENT_SYMBOL] || this.component;
+    const resolvedValues = props[ASYNC_RESOLVED_SYMBOL] || {};
+    const originalValues = props[ASYNC_ORIGINAL_SYMBOL] || props;
+    const defaultValues = props[ASYNC_DEFAULTS_SYMBOL] || {};
+    for (const propName in resolvedValues) {
+      const value = resolvedValues[propName];
+      this._createAsyncPropData(propName, defaultValues[propName]);
+      this._updateAsyncProp(propName, value);
+      resolvedValues[propName] = this.getAsyncProp(propName);
+    }
+    for (const propName in originalValues) {
+      const value = originalValues[propName];
+      this._createAsyncPropData(propName, defaultValues[propName]);
+      this._updateAsyncProp(propName, value);
+    }
+  }
+  /* Placeholder methods for subclassing */
+  _fetch(propName, url) {
+    return null;
+  }
+  _onResolve(propName, value) {
+  }
+  // eslint-disable-line @typescript-eslint/no-empty-function
+  _onError(propName, error) {
+  }
+  // eslint-disable-line @typescript-eslint/no-empty-function
+  // Intercept strings (URLs) and Promises and activates loading and prop rewriting
+  _updateAsyncProp(propName, value) {
+    if (!this._didAsyncInputValueChange(propName, value)) {
+      return;
+    }
+    if (typeof value === "string") {
+      value = this._fetch(propName, value);
+    }
+    if (value instanceof Promise) {
+      this._watchPromise(propName, value);
+      return;
+    }
+    if (isAsyncIterable(value)) {
+      this._resolveAsyncIterable(propName, value);
+      return;
+    }
+    this._setPropValue(propName, value);
+  }
+  // Whenever async props are changing, we need to make a copy of oldProps
+  // otherwise the prop rewriting will affect the value both in props and oldProps.
+  // While the copy is relatively expensive, this only happens on load completion.
+  _freezeAsyncOldProps() {
+    if (!this.oldAsyncProps && this.oldProps) {
+      this.oldAsyncProps = Object.create(this.oldProps);
+      for (const propName in this.asyncProps) {
+        Object.defineProperty(this.oldAsyncProps, propName, {
+          enumerable: true,
+          value: this.oldProps[propName]
+        });
+      }
+    }
+  }
+  // Checks if an input value actually changed (to avoid reloading/rewatching promises/urls)
+  _didAsyncInputValueChange(propName, value) {
+    const asyncProp = this.asyncProps[propName];
+    if (value === asyncProp.resolvedValue || value === asyncProp.lastValue) {
+      return false;
+    }
+    asyncProp.lastValue = value;
+    return true;
+  }
+  // Set normal, non-async value
+  _setPropValue(propName, value) {
+    this._freezeAsyncOldProps();
+    const asyncProp = this.asyncProps[propName];
+    if (asyncProp) {
+      value = this._postProcessValue(asyncProp, value);
+      asyncProp.resolvedValue = value;
+      asyncProp.pendingLoadCount++;
+      asyncProp.resolvedLoadCount = asyncProp.pendingLoadCount;
+    }
+  }
+  // Set a just resolved async value, calling onAsyncPropUpdates if value changes asynchronously
+  _setAsyncPropValue(propName, value, loadCount) {
+    const asyncProp = this.asyncProps[propName];
+    if (asyncProp && loadCount >= asyncProp.resolvedLoadCount && value !== void 0) {
+      this._freezeAsyncOldProps();
+      asyncProp.resolvedValue = value;
+      asyncProp.resolvedLoadCount = loadCount;
+      this.onAsyncPropUpdated(propName, value);
+    }
+  }
+  // Tracks a promise, sets the prop when loaded, handles load count
+  _watchPromise(propName, promise) {
+    const asyncProp = this.asyncProps[propName];
+    if (asyncProp) {
+      asyncProp.pendingLoadCount++;
+      const loadCount = asyncProp.pendingLoadCount;
+      promise.then((data) => {
+        if (!this.component) {
+          return;
+        }
+        data = this._postProcessValue(asyncProp, data);
+        this._setAsyncPropValue(propName, data, loadCount);
+        this._onResolve(propName, data);
+      }).catch((error) => {
+        this._onError(propName, error);
+      });
+    }
+  }
+  async _resolveAsyncIterable(propName, iterable) {
+    if (propName !== "data") {
+      this._setPropValue(propName, iterable);
+      return;
+    }
+    const asyncProp = this.asyncProps[propName];
+    if (!asyncProp) {
+      return;
+    }
+    asyncProp.pendingLoadCount++;
+    const loadCount = asyncProp.pendingLoadCount;
+    let data = [];
+    let count2 = 0;
+    for await (const chunk of iterable) {
+      if (!this.component) {
+        return;
+      }
+      const { dataTransform } = this.component.props;
+      if (dataTransform) {
+        data = dataTransform(chunk, data);
+      } else {
+        data = data.concat(chunk);
+      }
+      Object.defineProperty(data, "__diff", {
+        enumerable: false,
+        value: [{ startRow: count2, endRow: data.length }]
+      });
+      count2 = data.length;
+      this._setAsyncPropValue(propName, data, loadCount);
+    }
+    this._onResolve(propName, data);
+  }
+  // Give the app a chance to post process the loaded data
+  _postProcessValue(asyncProp, value) {
+    const propType = asyncProp.type;
+    if (propType && this.component) {
+      if (propType.release) {
+        propType.release(asyncProp.resolvedValue, propType, this.component);
+      }
+      if (propType.transform) {
+        return propType.transform(value, propType, this.component);
+      }
+    }
+    return value;
+  }
+  // Creating an asyncProp record if needed
+  _createAsyncPropData(propName, defaultValue) {
+    const asyncProp = this.asyncProps[propName];
+    if (!asyncProp) {
+      const propTypes2 = this.component && this.component.props[PROP_TYPES_SYMBOL];
+      this.asyncProps[propName] = {
+        type: propTypes2 && propTypes2[propName],
+        lastValue: null,
+        resolvedValue: defaultValue,
+        pendingLoadCount: 0,
+        resolvedLoadCount: 0
+      };
+    }
+  }
+}
+class LayerState extends ComponentState {
+  constructor({ attributeManager, layer }) {
+    super(layer);
+    this.attributeManager = attributeManager;
+    this.needsRedraw = true;
+    this.needsUpdate = true;
+    this.subLayers = null;
+    this.usesPickingColorCache = false;
+  }
+  get layer() {
+    return this.component;
+  }
+  /* Override base Component methods with Layer-specific handling */
+  _fetch(propName, url) {
+    const layer = this.layer;
+    const fetch2 = layer == null ? void 0 : layer.props.fetch;
+    if (fetch2) {
+      return fetch2(url, { propName, layer });
+    }
+    return super._fetch(propName, url);
+  }
+  _onResolve(propName, value) {
+    const layer = this.layer;
+    if (layer) {
+      const onDataLoad = layer.props.onDataLoad;
+      if (propName === "data" && onDataLoad) {
+        onDataLoad(value, { propName, layer });
+      }
+    }
+  }
+  _onError(propName, error) {
+    const layer = this.layer;
+    if (layer) {
+      layer.raiseError(error, `loading ${propName} of ${this.layer}`);
+    }
+  }
+}
+const TRACE_CHANGE_FLAG = "layer.changeFlag";
+const TRACE_INITIALIZE = "layer.initialize";
+const TRACE_UPDATE = "layer.update";
+const TRACE_FINALIZE = "layer.finalize";
+const TRACE_MATCHED = "layer.matched";
+const MAX_PICKING_COLOR_CACHE_SIZE = 2 ** 24 - 1;
+const EMPTY_ARRAY = Object.freeze([]);
+const areViewportsEqual = memoize(({ oldViewport, viewport }) => {
+  return oldViewport.equals(viewport);
+});
+let pickingColorCache = new Uint8ClampedArray(0);
+const defaultProps$1 = {
+  // data: Special handling for null, see below
+  data: { type: "data", value: EMPTY_ARRAY, async: true },
+  dataComparator: { type: "function", value: null, optional: true },
+  _dataDiff: {
+    type: "function",
+    // @ts-ignore __diff is not defined on data
+    value: (data) => data && data.__diff,
+    optional: true
+  },
+  dataTransform: { type: "function", value: null, optional: true },
+  onDataLoad: { type: "function", value: null, optional: true },
+  onError: { type: "function", value: null, optional: true },
+  fetch: {
+    type: "function",
+    value: (url, { propName, layer, loaders, loadOptions, signal }) => {
+      const { resourceManager } = layer.context;
+      loadOptions = loadOptions || layer.getLoadOptions();
+      loaders = loaders || layer.props.loaders;
+      if (signal) {
+        loadOptions = {
+          ...loadOptions,
+          fetch: {
+            ...loadOptions == null ? void 0 : loadOptions.fetch,
+            signal
+          }
+        };
+      }
+      let inResourceManager = resourceManager.contains(url);
+      if (!inResourceManager && !loadOptions) {
+        resourceManager.add({ resourceId: url, data: load(url, loaders), persistent: false });
+        inResourceManager = true;
+      }
+      if (inResourceManager) {
+        return resourceManager.subscribe({
+          resourceId: url,
+          onChange: (data) => {
+            var _a3;
+            return (_a3 = layer.internalState) == null ? void 0 : _a3.reloadAsyncProp(propName, data);
+          },
+          consumerId: layer.id,
+          requestId: propName
+        });
+      }
+      return load(url, loaders, loadOptions);
+    }
+  },
+  updateTriggers: {},
+  // Update triggers: a core change detection mechanism in deck.gl
+  visible: true,
+  pickable: false,
+  opacity: { type: "number", min: 0, max: 1, value: 1 },
+  operation: "draw",
+  onHover: { type: "function", value: null, optional: true },
+  onClick: { type: "function", value: null, optional: true },
+  onDragStart: { type: "function", value: null, optional: true },
+  onDrag: { type: "function", value: null, optional: true },
+  onDragEnd: { type: "function", value: null, optional: true },
+  coordinateSystem: COORDINATE_SYSTEM.DEFAULT,
+  coordinateOrigin: { type: "array", value: [0, 0, 0], compare: true },
+  modelMatrix: { type: "array", value: null, compare: true, optional: true },
+  wrapLongitude: false,
+  positionFormat: "XYZ",
+  colorFormat: "RGBA",
+  parameters: { type: "object", value: {}, optional: true, compare: 2 },
+  loadOptions: { type: "object", value: null, optional: true, ignore: true },
+  transitions: null,
+  extensions: [],
+  loaders: { type: "array", value: [], optional: true, ignore: true },
+  // Offset depth based on layer index to avoid z-fighting.
+  // Negative values pull layer towards the camera
+  // https://www.opengl.org/archives/resources/faq/technical/polygonoffset.htm
+  getPolygonOffset: {
+    type: "function",
+    value: ({ layerIndex }) => [0, -layerIndex * 100]
+  },
+  // Selection/Highlighting
+  highlightedObjectIndex: null,
+  autoHighlight: false,
+  highlightColor: { type: "accessor", value: [0, 0, 128, 128] }
+};
+class Layer extends Component {
+  constructor() {
+    super(...arguments);
+    this.internalState = null;
+    this.lifecycle = LIFECYCLE.NO_STATE;
+    this.parent = null;
+  }
+  static get componentName() {
+    return Object.prototype.hasOwnProperty.call(this, "layerName") ? this.layerName : "";
+  }
+  get root() {
+    let layer = this;
+    while (layer.parent) {
+      layer = layer.parent;
+    }
+    return layer;
+  }
+  toString() {
+    const className = this.constructor.layerName || this.constructor.name;
+    return `${className}({id: '${this.props.id}'})`;
+  }
+  // Public API for users
+  /** Projects a point with current view state from the current layer's coordinate system to screen */
+  project(xyz) {
+    assert(this.internalState);
+    const viewport = this.internalState.viewport || this.context.viewport;
+    const worldPosition = getWorldPosition(xyz, {
+      viewport,
+      modelMatrix: this.props.modelMatrix,
+      coordinateOrigin: this.props.coordinateOrigin,
+      coordinateSystem: this.props.coordinateSystem
+    });
+    const [x2, y2, z2] = worldToPixels(worldPosition, viewport.pixelProjectionMatrix);
+    return xyz.length === 2 ? [x2, y2] : [x2, y2, z2];
+  }
+  /** Unprojects a screen pixel to the current view's default coordinate system
+      Note: this does not reverse `project`. */
+  unproject(xy) {
+    assert(this.internalState);
+    const viewport = this.internalState.viewport || this.context.viewport;
+    return viewport.unproject(xy);
+  }
+  /** Projects a point with current view state from the current layer's coordinate system to the world space */
+  projectPosition(xyz, params) {
+    assert(this.internalState);
+    const viewport = this.internalState.viewport || this.context.viewport;
+    return projectPosition(xyz, {
+      viewport,
+      modelMatrix: this.props.modelMatrix,
+      coordinateOrigin: this.props.coordinateOrigin,
+      coordinateSystem: this.props.coordinateSystem,
+      ...params
+    });
+  }
+  // Public API for custom layer implementation
+  /** `true` if this layer renders other layers */
+  get isComposite() {
+    return false;
+  }
+  /** `true` if the layer renders to screen */
+  get isDrawable() {
+    return true;
+  }
+  /** Updates selected state members and marks the layer for redraw */
+  setState(partialState) {
+    this.setChangeFlags({ stateChanged: true });
+    Object.assign(this.state, partialState);
+    this.setNeedsRedraw();
+  }
+  /** Sets the redraw flag for this layer, will trigger a redraw next animation frame */
+  setNeedsRedraw() {
+    if (this.internalState) {
+      this.internalState.needsRedraw = true;
+    }
+  }
+  /** Mark this layer as needs a deep update */
+  setNeedsUpdate() {
+    if (this.internalState) {
+      this.context.layerManager.setNeedsUpdate(String(this));
+      this.internalState.needsUpdate = true;
+    }
+  }
+  /** Returns true if all async resources are loaded */
+  get isLoaded() {
+    return this.internalState ? !this.internalState.isAsyncPropLoading() : false;
+  }
+  /** Returns true if using shader-based WGS84 longitude wrapping */
+  get wrapLongitude() {
+    return this.props.wrapLongitude;
+  }
+  /** @deprecated Returns true if the layer is visible in the picking pass */
+  isPickable() {
+    return this.props.pickable && this.props.visible;
+  }
+  /** Returns an array of models used by this layer, can be overriden by layer subclass */
+  getModels() {
+    const state = this.state;
+    return state && (state.models || state.model && [state.model]) || [];
+  }
+  /** Update shader input parameters */
+  setShaderModuleProps(...props) {
+    for (const model of this.getModels()) {
+      model.shaderInputs.setProps(...props);
+    }
+  }
+  /** Returns the attribute manager of this layer */
+  getAttributeManager() {
+    return this.internalState && this.internalState.attributeManager;
+  }
+  /** Returns the most recent layer that matched to this state
+    (When reacting to an async event, this layer may no longer be the latest) */
+  getCurrentLayer() {
+    return this.internalState && this.internalState.layer;
+  }
+  /** Returns the default parse options for async props */
+  getLoadOptions() {
+    return this.props.loadOptions;
+  }
+  use64bitPositions() {
+    const { coordinateSystem } = this.props;
+    return coordinateSystem === COORDINATE_SYSTEM.DEFAULT || coordinateSystem === COORDINATE_SYSTEM.LNGLAT || coordinateSystem === COORDINATE_SYSTEM.CARTESIAN;
+  }
+  // Event handling
+  onHover(info, pickingEvent) {
+    if (this.props.onHover) {
+      return this.props.onHover(info, pickingEvent) || false;
+    }
+    return false;
+  }
+  onClick(info, pickingEvent) {
+    if (this.props.onClick) {
+      return this.props.onClick(info, pickingEvent) || false;
+    }
+    return false;
+  }
+  // Returns the picking color that doesn't match any subfeature
+  // Use if some graphics do not belong to any pickable subfeature
+  // @return {Array} - a black color
+  nullPickingColor() {
+    return [0, 0, 0];
+  }
+  // Returns the picking color that doesn't match any subfeature
+  // Use if some graphics do not belong to any pickable subfeature
+  encodePickingColor(i2, target = []) {
+    target[0] = i2 + 1 & 255;
+    target[1] = i2 + 1 >> 8 & 255;
+    target[2] = i2 + 1 >> 8 >> 8 & 255;
+    return target;
+  }
+  // Returns the index corresponding to a picking color that doesn't match any subfeature
+  // @param {Uint8Array} color - color array to be decoded
+  // @return {Array} - the decoded picking color
+  decodePickingColor(color2) {
+    assert(color2 instanceof Uint8Array);
+    const [i1, i2, i3] = color2;
+    const index = i1 + i2 * 256 + i3 * 65536 - 1;
+    return index;
+  }
+  /** Deduces number of instances. Intention is to support:
+    - Explicit setting of numInstances
+    - Auto-deduction for ES6 containers that define a size member
+    - Auto-deduction for Classic Arrays via the built-in length attribute
+    - Auto-deduction via arrays */
+  getNumInstances() {
+    if (Number.isFinite(this.props.numInstances)) {
+      return this.props.numInstances;
+    }
+    if (this.state && this.state.numInstances !== void 0) {
+      return this.state.numInstances;
+    }
+    return count(this.props.data);
+  }
+  /** Buffer layout describes how many attribute values are packed for each data object
+      The default (null) is one value each object.
+      Some data formats (e.g. paths, polygons) have various length. Their buffer layout
+      is in the form of [L0, L1, L2, ...] */
+  getStartIndices() {
+    if (this.props.startIndices) {
+      return this.props.startIndices;
+    }
+    if (this.state && this.state.startIndices) {
+      return this.state.startIndices;
+    }
+    return null;
+  }
+  // Default implementation
+  getBounds() {
+    var _a3;
+    return (_a3 = this.getAttributeManager()) == null ? void 0 : _a3.getBounds(["positions", "instancePositions"]);
+  }
+  getShaders(shaders) {
+    shaders = mergeShaders(shaders, {
+      disableWarnings: true,
+      modules: this.context.defaultShaderModules
+    });
+    for (const extension of this.props.extensions) {
+      shaders = mergeShaders(shaders, extension.getShaders.call(this, extension));
+    }
+    return shaders;
+  }
+  /** Controls if updateState should be called. By default returns true if any prop has changed */
+  shouldUpdateState(params) {
+    return params.changeFlags.propsOrDataChanged;
+  }
+  /** Default implementation, all attributes will be invalidated and updated when data changes */
+  // eslint-disable-next-line complexity
+  updateState(params) {
+    const attributeManager = this.getAttributeManager();
+    const { dataChanged } = params.changeFlags;
+    if (dataChanged && attributeManager) {
+      if (Array.isArray(dataChanged)) {
+        for (const dataRange of dataChanged) {
+          attributeManager.invalidateAll(dataRange);
+        }
+      } else {
+        attributeManager.invalidateAll();
+      }
+    }
+    if (attributeManager) {
+      const { props } = params;
+      const hasPickingBuffer = this.internalState.hasPickingBuffer;
+      const needsPickingBuffer = Number.isInteger(props.highlightedObjectIndex) || Boolean(props.pickable) || props.extensions.some((extension) => extension.getNeedsPickingBuffer.call(this, extension));
+      if (hasPickingBuffer !== needsPickingBuffer) {
+        this.internalState.hasPickingBuffer = needsPickingBuffer;
+        const { pickingColors, instancePickingColors } = attributeManager.attributes;
+        const pickingColorsAttribute = pickingColors || instancePickingColors;
+        if (pickingColorsAttribute) {
+          if (needsPickingBuffer && pickingColorsAttribute.constant) {
+            pickingColorsAttribute.constant = false;
+            attributeManager.invalidate(pickingColorsAttribute.id);
+          }
+          if (!pickingColorsAttribute.value && !needsPickingBuffer) {
+            pickingColorsAttribute.constant = true;
+            pickingColorsAttribute.value = [0, 0, 0];
+          }
+        }
+      }
+    }
+  }
+  /** Called once when layer is no longer matched and state will be discarded. Layers can destroy WebGL resources here. */
+  finalizeState(context) {
+    for (const model of this.getModels()) {
+      model.destroy();
+    }
+    const attributeManager = this.getAttributeManager();
+    if (attributeManager) {
+      attributeManager.finalize();
+    }
+    if (this.context) {
+      this.context.resourceManager.unsubscribe({ consumerId: this.id });
+    }
+    if (this.internalState) {
+      this.internalState.uniformTransitions.clear();
+      this.internalState.finalize();
+    }
+  }
+  // If state has a model, draw it with supplied uniforms
+  draw(opts) {
+    for (const model of this.getModels()) {
+      model.draw(opts.renderPass);
+    }
+  }
+  // called to populate the info object that is passed to the event handler
+  // @return null to cancel event
+  getPickingInfo({ info, mode, sourceLayer }) {
+    const { index } = info;
+    if (index >= 0) {
+      if (Array.isArray(this.props.data)) {
+        info.object = this.props.data[index];
+      }
+    }
+    return info;
+  }
+  // END LIFECYCLE METHODS
+  // / INTERNAL METHODS - called by LayerManager, DeckRenderer and DeckPicker
+  /** (Internal) Propagate an error event through the system */
+  raiseError(error, message2) {
+    var _a3, _b3, _c3, _d2;
+    if (message2) {
+      error = new Error(`${message2}: ${error.message}`, { cause: error });
+    }
+    if (!((_b3 = (_a3 = this.props).onError) == null ? void 0 : _b3.call(_a3, error))) {
+      (_d2 = (_c3 = this.context) == null ? void 0 : _c3.onError) == null ? void 0 : _d2.call(_c3, error, this);
+    }
+  }
+  /** (Internal) Checks if this layer needs redraw */
+  getNeedsRedraw(opts = { clearRedrawFlags: false }) {
+    return this._getNeedsRedraw(opts);
+  }
+  /** (Internal) Checks if this layer needs a deep update */
+  needsUpdate() {
+    if (!this.internalState) {
+      return false;
+    }
+    return this.internalState.needsUpdate || this.hasUniformTransition() || this.shouldUpdateState(this._getUpdateParams());
+  }
+  /** Checks if this layer has ongoing uniform transition */
+  hasUniformTransition() {
+    var _a3;
+    return ((_a3 = this.internalState) == null ? void 0 : _a3.uniformTransitions.active) || false;
+  }
+  /** Called when this layer is rendered into the given viewport */
+  activateViewport(viewport) {
+    if (!this.internalState) {
+      return;
+    }
+    const oldViewport = this.internalState.viewport;
+    this.internalState.viewport = viewport;
+    if (!oldViewport || !areViewportsEqual({ oldViewport, viewport })) {
+      this.setChangeFlags({ viewportChanged: true });
+      if (this.isComposite) {
+        if (this.needsUpdate()) {
+          this.setNeedsUpdate();
+        }
+      } else {
+        this._update();
+      }
+    }
+  }
+  /** Default implementation of attribute invalidation, can be redefined */
+  invalidateAttribute(name2 = "all") {
+    const attributeManager = this.getAttributeManager();
+    if (!attributeManager) {
+      return;
+    }
+    if (name2 === "all") {
+      attributeManager.invalidateAll();
+    } else {
+      attributeManager.invalidate(name2);
+    }
+  }
+  /** Send updated attributes to the WebGL model */
+  updateAttributes(changedAttributes) {
+    let bufferLayoutChanged = false;
+    for (const id2 in changedAttributes) {
+      if (changedAttributes[id2].layoutChanged()) {
+        bufferLayoutChanged = true;
+      }
+    }
+    for (const model of this.getModels()) {
+      this._setModelAttributes(model, changedAttributes, bufferLayoutChanged);
+    }
+  }
+  /** Recalculate any attributes if needed */
+  _updateAttributes() {
+    const attributeManager = this.getAttributeManager();
+    if (!attributeManager) {
+      return;
+    }
+    const props = this.props;
+    const numInstances = this.getNumInstances();
+    const startIndices = this.getStartIndices();
+    attributeManager.update({
+      data: props.data,
+      numInstances,
+      startIndices,
+      props,
+      transitions: props.transitions,
+      // @ts-ignore (TS2339) property attribute is not present on some acceptable data types
+      buffers: props.data.attributes,
+      context: this
+    });
+    const changedAttributes = attributeManager.getChangedAttributes({ clearChangedFlags: true });
+    this.updateAttributes(changedAttributes);
+  }
+  /** Update attribute transitions. This is called in drawLayer, no model updates required. */
+  _updateAttributeTransition() {
+    const attributeManager = this.getAttributeManager();
+    if (attributeManager) {
+      attributeManager.updateTransition();
+    }
+  }
+  /** Update uniform (prop) transitions. This is called in updateState, may result in model updates. */
+  _updateUniformTransition() {
+    const { uniformTransitions } = this.internalState;
+    if (uniformTransitions.active) {
+      const propsInTransition = uniformTransitions.update();
+      const props = Object.create(this.props);
+      for (const key in propsInTransition) {
+        Object.defineProperty(props, key, { value: propsInTransition[key] });
+      }
+      return props;
+    }
+    return this.props;
+  }
+  /** Updater for the automatically populated instancePickingColors attribute */
+  calculateInstancePickingColors(attribute, { numInstances }) {
+    if (attribute.constant) {
+      return;
+    }
+    const cacheSize = Math.floor(pickingColorCache.length / 4);
+    this.internalState.usesPickingColorCache = true;
+    if (cacheSize < numInstances) {
+      if (numInstances > MAX_PICKING_COLOR_CACHE_SIZE) {
+        defaultLogger.warn("Layer has too many data objects. Picking might not be able to distinguish all objects.")();
+      }
+      pickingColorCache = defaultTypedArrayManager.allocate(pickingColorCache, numInstances, {
+        size: 4,
+        copy: true,
+        maxCount: Math.max(numInstances, MAX_PICKING_COLOR_CACHE_SIZE)
+      });
+      const newCacheSize = Math.floor(pickingColorCache.length / 4);
+      const pickingColor = [0, 0, 0];
+      for (let i2 = cacheSize; i2 < newCacheSize; i2++) {
+        this.encodePickingColor(i2, pickingColor);
+        pickingColorCache[i2 * 4 + 0] = pickingColor[0];
+        pickingColorCache[i2 * 4 + 1] = pickingColor[1];
+        pickingColorCache[i2 * 4 + 2] = pickingColor[2];
+        pickingColorCache[i2 * 4 + 3] = 0;
+      }
+    }
+    attribute.value = pickingColorCache.subarray(0, numInstances * 4);
+  }
+  /** Apply changed attributes to model */
+  _setModelAttributes(model, changedAttributes, bufferLayoutChanged = false) {
+    var _a3;
+    if (!Object.keys(changedAttributes).length) {
+      return;
+    }
+    if (bufferLayoutChanged) {
+      const attributeManager = this.getAttributeManager();
+      model.setBufferLayout(attributeManager.getBufferLayouts(model));
+      changedAttributes = attributeManager.getAttributes();
+    }
+    const excludeAttributes = ((_a3 = model.userData) == null ? void 0 : _a3.excludeAttributes) || {};
+    const attributeBuffers = {};
+    const constantAttributes = {};
+    for (const name2 in changedAttributes) {
+      if (excludeAttributes[name2]) {
+        continue;
+      }
+      const values = changedAttributes[name2].getValue();
+      for (const attributeName in values) {
+        const value = values[attributeName];
+        if (value instanceof Buffer$1) {
+          if (changedAttributes[name2].settings.isIndexed) {
+            model.setIndexBuffer(value);
+          } else {
+            attributeBuffers[attributeName] = value;
+          }
+        } else if (value) {
+          constantAttributes[attributeName] = value;
+        }
+      }
+    }
+    model.setAttributes(attributeBuffers);
+    model.setConstantAttributes(constantAttributes);
+  }
+  /** (Internal) Sets the picking color at the specified index to null picking color. Used for multi-depth picking.
+     This method may be overriden by layer implementations */
+  disablePickingIndex(objectIndex) {
+    const data = this.props.data;
+    if (!("attributes" in data)) {
+      this._disablePickingIndex(objectIndex);
+      return;
+    }
+    const { pickingColors, instancePickingColors } = this.getAttributeManager().attributes;
+    const colors = pickingColors || instancePickingColors;
+    const externalColorAttribute = colors && data.attributes && data.attributes[colors.id];
+    if (externalColorAttribute && externalColorAttribute.value) {
+      const values = externalColorAttribute.value;
+      const objectColor = this.encodePickingColor(objectIndex);
+      for (let index = 0; index < data.length; index++) {
+        const i2 = colors.getVertexOffset(index);
+        if (values[i2] === objectColor[0] && values[i2 + 1] === objectColor[1] && values[i2 + 2] === objectColor[2]) {
+          this._disablePickingIndex(index);
+        }
+      }
+    } else {
+      this._disablePickingIndex(objectIndex);
+    }
+  }
+  // TODO - simplify subclassing interface
+  _disablePickingIndex(objectIndex) {
+    const { pickingColors, instancePickingColors } = this.getAttributeManager().attributes;
+    const colors = pickingColors || instancePickingColors;
+    if (!colors) {
+      return;
+    }
+    const start = colors.getVertexOffset(objectIndex);
+    const end = colors.getVertexOffset(objectIndex + 1);
+    colors.buffer.write(new Uint8Array(end - start), start);
+  }
+  /** (Internal) Re-enable all picking indices after multi-depth picking */
+  restorePickingColors() {
+    const { pickingColors, instancePickingColors } = this.getAttributeManager().attributes;
+    const colors = pickingColors || instancePickingColors;
+    if (!colors) {
+      return;
+    }
+    if (
+      // @ts-ignore (TS2531) this method is only called internally with internalState defined
+      this.internalState.usesPickingColorCache && colors.value.buffer !== pickingColorCache.buffer
+    ) {
+      colors.value = pickingColorCache.subarray(0, colors.value.length);
+    }
+    colors.updateSubBuffer({ startOffset: 0 });
+  }
+  /* eslint-disable max-statements */
+  /* (Internal) Called by layer manager when a new layer is found */
+  _initialize() {
+    assert(!this.internalState);
+    assert(Number.isFinite(this.props.coordinateSystem));
+    debug(TRACE_INITIALIZE, this);
+    const attributeManager = this._getAttributeManager();
+    if (attributeManager) {
+      attributeManager.addInstanced({
+        instancePickingColors: {
+          type: "uint8",
+          size: 4,
+          noAlloc: true,
+          // Updaters are always called with `this` pointing to the layer
+          // eslint-disable-next-line @typescript-eslint/unbound-method
+          update: this.calculateInstancePickingColors
+        }
+      });
+    }
+    this.internalState = new LayerState({
+      attributeManager,
+      layer: this
+    });
+    this._clearChangeFlags();
+    this.state = {};
+    Object.defineProperty(this.state, "attributeManager", {
+      get: () => {
+        defaultLogger.deprecated("layer.state.attributeManager", "layer.getAttributeManager()")();
+        return attributeManager;
+      }
+    });
+    this.internalState.uniformTransitions = new UniformTransitionManager(this.context.timeline);
+    this.internalState.onAsyncPropUpdated = this._onAsyncPropUpdated.bind(this);
+    this.internalState.setAsyncProps(this.props);
+    this.initializeState(this.context);
+    for (const extension of this.props.extensions) {
+      extension.initializeState.call(this, this.context, extension);
+    }
+    this.setChangeFlags({
+      dataChanged: "init",
+      propsChanged: "init",
+      viewportChanged: true,
+      extensionsChanged: true
+    });
+    this._update();
+  }
+  /** (Internal) Called by layer manager to transfer state from an old layer */
+  _transferState(oldLayer) {
+    debug(TRACE_MATCHED, this, this === oldLayer);
+    const { state, internalState } = oldLayer;
+    if (this === oldLayer) {
+      return;
+    }
+    this.internalState = internalState;
+    this.state = state;
+    this.internalState.setAsyncProps(this.props);
+    this._diffProps(this.props, this.internalState.getOldProps());
+  }
+  /** (Internal) Called by layer manager when a new layer is added or an existing layer is matched with a new instance */
+  _update() {
+    const stateNeedsUpdate = this.needsUpdate();
+    debug(TRACE_UPDATE, this, stateNeedsUpdate);
+    if (!stateNeedsUpdate) {
+      return;
+    }
+    const currentProps = this.props;
+    const context = this.context;
+    const internalState = this.internalState;
+    const currentViewport = context.viewport;
+    const propsInTransition = this._updateUniformTransition();
+    internalState.propsInTransition = propsInTransition;
+    context.viewport = internalState.viewport || currentViewport;
+    this.props = propsInTransition;
+    try {
+      const updateParams = this._getUpdateParams();
+      const oldModels = this.getModels();
+      if (context.device) {
+        this.updateState(updateParams);
+      } else {
+        try {
+          this.updateState(updateParams);
+        } catch (error) {
+        }
+      }
+      for (const extension of this.props.extensions) {
+        extension.updateState.call(this, updateParams, extension);
+      }
+      this.setNeedsRedraw();
+      this._updateAttributes();
+      const modelChanged = this.getModels()[0] !== oldModels[0];
+      this._postUpdate(updateParams, modelChanged);
+    } finally {
+      context.viewport = currentViewport;
+      this.props = currentProps;
+      this._clearChangeFlags();
+      internalState.needsUpdate = false;
+      internalState.resetOldProps();
+    }
+  }
+  /* eslint-enable max-statements */
+  /** (Internal) Called by manager when layer is about to be disposed
+      Note: not guaranteed to be called on application shutdown */
+  _finalize() {
+    debug(TRACE_FINALIZE, this);
+    this.finalizeState(this.context);
+    for (const extension of this.props.extensions) {
+      extension.finalizeState.call(this, this.context, extension);
+    }
+  }
+  // Calculates uniforms
+  _drawLayer({ renderPass, shaderModuleProps = null, uniforms = {}, parameters = {} }) {
+    this._updateAttributeTransition();
+    const currentProps = this.props;
+    const context = this.context;
+    this.props = this.internalState.propsInTransition || currentProps;
+    try {
+      if (shaderModuleProps) {
+        this.setShaderModuleProps(shaderModuleProps);
+      }
+      const { getPolygonOffset } = this.props;
+      const offsets = getPolygonOffset && getPolygonOffset(uniforms) || [0, 0];
+      if (context.device instanceof WebGLDevice) {
+        context.device.setParametersWebGL({ polygonOffset: offsets });
+      }
+      for (const model of this.getModels()) {
+        if (model.device.type === "webgpu") {
+          model.setParameters({ ...model.parameters, ...parameters });
+        } else {
+          model.setParameters(parameters);
+        }
+      }
+      if (context.device instanceof WebGLDevice) {
+        context.device.withParametersWebGL(parameters, () => {
+          const opts = { renderPass, shaderModuleProps, uniforms, parameters, context };
+          for (const extension of this.props.extensions) {
+            extension.draw.call(this, opts, extension);
+          }
+          this.draw(opts);
+        });
+      } else {
+        const opts = { renderPass, shaderModuleProps, uniforms, parameters, context };
+        for (const extension of this.props.extensions) {
+          extension.draw.call(this, opts, extension);
+        }
+        this.draw(opts);
+      }
+    } finally {
+      this.props = currentProps;
+    }
+  }
+  // Helper methods
+  /** Returns the current change flags */
+  getChangeFlags() {
+    var _a3;
+    return (_a3 = this.internalState) == null ? void 0 : _a3.changeFlags;
+  }
+  /* eslint-disable complexity */
+  /** Dirty some change flags, will be handled by updateLayer */
+  setChangeFlags(flags) {
+    if (!this.internalState) {
+      return;
+    }
+    const { changeFlags } = this.internalState;
+    for (const key in flags) {
+      if (flags[key]) {
+        let flagChanged = false;
+        switch (key) {
+          case "dataChanged":
+            const dataChangedReason = flags[key];
+            const prevDataChangedReason = changeFlags[key];
+            if (dataChangedReason && Array.isArray(prevDataChangedReason)) {
+              changeFlags.dataChanged = Array.isArray(dataChangedReason) ? prevDataChangedReason.concat(dataChangedReason) : dataChangedReason;
+              flagChanged = true;
+            }
+          default:
+            if (!changeFlags[key]) {
+              changeFlags[key] = flags[key];
+              flagChanged = true;
+            }
+        }
+        if (flagChanged) {
+          debug(TRACE_CHANGE_FLAG, this, key, flags);
+        }
+      }
+    }
+    const propsOrDataChanged = Boolean(changeFlags.dataChanged || changeFlags.updateTriggersChanged || changeFlags.propsChanged || changeFlags.extensionsChanged);
+    changeFlags.propsOrDataChanged = propsOrDataChanged;
+    changeFlags.somethingChanged = propsOrDataChanged || changeFlags.viewportChanged || changeFlags.stateChanged;
+  }
+  /* eslint-enable complexity */
+  /** Clear all changeFlags, typically after an update */
+  _clearChangeFlags() {
+    this.internalState.changeFlags = {
+      dataChanged: false,
+      propsChanged: false,
+      updateTriggersChanged: false,
+      viewportChanged: false,
+      stateChanged: false,
+      extensionsChanged: false,
+      propsOrDataChanged: false,
+      somethingChanged: false
+    };
+  }
+  /** Compares the layers props with old props from a matched older layer
+      and extracts change flags that describe what has change so that state
+      can be update correctly with minimal effort */
+  _diffProps(newProps, oldProps) {
+    var _a3;
+    const changeFlags = diffProps(newProps, oldProps);
+    if (changeFlags.updateTriggersChanged) {
+      for (const key in changeFlags.updateTriggersChanged) {
+        if (changeFlags.updateTriggersChanged[key]) {
+          this.invalidateAttribute(key);
+        }
+      }
+    }
+    if (changeFlags.transitionsChanged) {
+      for (const key in changeFlags.transitionsChanged) {
+        this.internalState.uniformTransitions.add(key, oldProps[key], newProps[key], (_a3 = newProps.transitions) == null ? void 0 : _a3[key]);
+      }
+    }
+    return this.setChangeFlags(changeFlags);
+  }
+  /** (Internal) called by layer manager to perform extra props validation (in development only) */
+  validateProps() {
+    validateProps(this.props);
+  }
+  /** (Internal) Called by deck picker when the hovered object changes to update the auto highlight */
+  updateAutoHighlight(info) {
+    if (this.props.autoHighlight && !Number.isInteger(this.props.highlightedObjectIndex)) {
+      this._updateAutoHighlight(info);
+    }
+  }
+  // May be overriden by subclasses
+  // TODO - simplify subclassing interface
+  /** Update picking module parameters to highlight the hovered object */
+  _updateAutoHighlight(info) {
+    const picking2 = {
+      // @ts-ignore
+      highlightedObjectColor: info.picked ? info.color : null
+    };
+    const { highlightColor } = this.props;
+    if (info.picked && typeof highlightColor === "function") {
+      picking2.highlightColor = highlightColor(info);
+    }
+    this.setShaderModuleProps({ picking: picking2 });
+    this.setNeedsRedraw();
+  }
+  /** Create new attribute manager */
+  _getAttributeManager() {
+    const context = this.context;
+    return new AttributeManager(context.device, {
+      id: this.props.id,
+      stats: context.stats,
+      timeline: context.timeline
+    });
+  }
+  // Private methods
+  /** Called after updateState to perform common tasks */
+  // eslint-disable-next-line complexity
+  _postUpdate(updateParams, forceUpdate) {
+    const { props, oldProps } = updateParams;
+    const model = this.state.model;
+    if (model == null ? void 0 : model.isInstanced) {
+      model.setInstanceCount(this.getNumInstances());
+    }
+    const { autoHighlight, highlightedObjectIndex, highlightColor } = props;
+    if (forceUpdate || oldProps.autoHighlight !== autoHighlight || oldProps.highlightedObjectIndex !== highlightedObjectIndex || oldProps.highlightColor !== highlightColor) {
+      const picking2 = {};
+      if (Array.isArray(highlightColor)) {
+        picking2.highlightColor = highlightColor;
+      }
+      if (forceUpdate || oldProps.autoHighlight !== autoHighlight || highlightedObjectIndex !== oldProps.highlightedObjectIndex) {
+        picking2.highlightedObjectColor = Number.isFinite(highlightedObjectIndex) && highlightedObjectIndex >= 0 ? this.encodePickingColor(highlightedObjectIndex) : null;
+      }
+      this.setShaderModuleProps({ picking: picking2 });
+    }
+  }
+  _getUpdateParams() {
+    return {
+      props: this.props,
+      // @ts-ignore TS2531 this method can only be called internally with internalState assigned
+      oldProps: this.internalState.getOldProps(),
+      context: this.context,
+      // @ts-ignore TS2531 this method can only be called internally with internalState assigned
+      changeFlags: this.internalState.changeFlags
+    };
+  }
+  /** Checks state of attributes and model */
+  _getNeedsRedraw(opts) {
+    if (!this.internalState) {
+      return false;
+    }
+    let redraw = false;
+    redraw = redraw || this.internalState.needsRedraw && this.id;
+    const attributeManager = this.getAttributeManager();
+    const attributeManagerNeedsRedraw = attributeManager ? attributeManager.getNeedsRedraw(opts) : false;
+    redraw = redraw || attributeManagerNeedsRedraw;
+    if (redraw) {
+      for (const extension of this.props.extensions) {
+        extension.onNeedsRedraw.call(this, extension);
+      }
+    }
+    this.internalState.needsRedraw = this.internalState.needsRedraw && !opts.clearRedrawFlags;
+    return redraw;
+  }
+  /** Callback when asyn prop is loaded */
+  _onAsyncPropUpdated() {
+    this._diffProps(this.props, this.internalState.getOldProps());
+    this.setNeedsUpdate();
+  }
+}
+Layer.defaultProps = defaultProps$1;
+Layer.layerName = "Layer";
+class GlobeState extends MapState {
+  constructor(options) {
+    const { startPanPos, ...mapStateOptions } = options;
+    super(mapStateOptions);
+    if (startPanPos !== void 0) {
+      this._state.startPanPos = startPanPos;
+    }
+  }
+  panStart({ pos }) {
+    const { latitude, longitude, zoom } = this.getViewportProps();
+    return this._getUpdatedState({
+      startPanLngLat: [longitude, latitude],
+      startPanPos: pos,
+      startZoom: zoom
+    });
+  }
+  pan({ pos, startPos }) {
+    const state = this.getState();
+    const startPanLngLat = state.startPanLngLat || this._unproject(startPos);
+    if (!startPanLngLat)
+      return this;
+    const startZoom = state.startZoom ?? this.getViewportProps().zoom;
+    const startPanPos = state.startPanPos || startPos;
+    const coords = [startPanLngLat[0], startPanLngLat[1], startZoom];
+    const viewport = this.makeViewport(this.getViewportProps());
+    const newProps = viewport.panByPosition(coords, pos, startPanPos);
+    return this._getUpdatedState(newProps);
+  }
+  panEnd() {
+    return this._getUpdatedState({
+      startPanLngLat: null,
+      startPanPos: null,
+      startZoom: null
+    });
+  }
+  zoom({ scale: scale2 }) {
+    const startZoom = this.getState().startZoom || this.getViewportProps().zoom;
+    const zoom = startZoom + Math.log2(scale2);
+    return this._getUpdatedState({ zoom });
+  }
+  applyConstraints(props) {
+    const { longitude, latitude, maxZoom, minZoom, zoom } = props;
+    const ZOOM0 = zoomAdjust(0);
+    const zoomAdjustment = zoomAdjust(latitude) - ZOOM0;
+    props.zoom = clamp$1(zoom, minZoom + zoomAdjustment, maxZoom + zoomAdjustment);
+    if (longitude < -180 || longitude > 180) {
+      props.longitude = mod(longitude + 180, 360) - 180;
+    }
+    props.latitude = clamp$1(latitude, -85.051129, MAX_LATITUDE);
+    return props;
+  }
+}
+class GlobeController extends Controller {
+  constructor() {
+    super(...arguments);
+    this.ControllerState = GlobeState;
+    this.transition = {
+      transitionDuration: 300,
+      transitionInterpolator: new LinearInterpolator(["longitude", "latitude", "zoom"])
+    };
+    this.dragMode = "pan";
+  }
+  setProps(props) {
+    super.setProps(props);
+    this.dragRotate = false;
+    this.touchRotate = false;
+  }
+}
+class GlobeView extends View {
+  constructor(props = {}) {
+    super(props);
+  }
+  getViewportType(viewState) {
+    return viewState.zoom > 12 ? WebMercatorViewport : GlobeViewport;
+  }
+  get ControllerType() {
+    return GlobeController;
+  }
+}
+GlobeView.displayName = "GlobeView";
+const MAPBOX_VIEW_ID = "mapbox";
+const TILE_SIZE = 512;
+const DEGREES_TO_RADIANS = Math.PI / 180;
+function getDeckInstance({ map: map2, deck }) {
+  if (map2.__deck) {
+    return map2.__deck;
+  }
+  const customRender = deck.props._customRender;
+  const onLoad = deck.props.onLoad;
+  const deckProps = {
+    ...deck.props,
+    _customRender: () => {
+      map2.triggerRepaint();
+      customRender == null ? void 0 : customRender("");
+    }
+  };
+  deckProps.views || (deckProps.views = getDefaultView(map2));
+  Object.assign(deckProps, {
+    width: null,
+    height: null,
+    touchAction: "unset",
+    viewState: getViewState(map2)
+  });
+  if (deck.isInitialized) {
+    watchMapMove(deck, map2);
+  } else {
+    deckProps.onLoad = () => {
+      onLoad == null ? void 0 : onLoad();
+      watchMapMove(deck, map2);
+    };
+  }
+  deck.setProps(deckProps);
+  map2.__deck = deck;
+  map2.on("render", () => {
+    if (deck.isInitialized)
+      afterRender(deck, map2);
+  });
+  return deck;
+}
+function watchMapMove(deck, map2) {
+  const _handleMapMove = () => {
+    if (deck.isInitialized) {
+      onMapMove(deck, map2);
+    } else {
+      map2.off("move", _handleMapMove);
+    }
+  };
+  map2.on("move", _handleMapMove);
+}
+function removeDeckInstance(map2) {
+  var _a3;
+  (_a3 = map2.__deck) == null ? void 0 : _a3.finalize();
+  map2.__deck = null;
+}
+function getDefaultParameters(map2, interleaved) {
+  const result = interleaved ? {
+    depthWriteEnabled: true,
+    depthCompare: "less-equal",
+    depthBias: 0,
+    blend: true,
+    blendColorSrcFactor: "src-alpha",
+    blendColorDstFactor: "one-minus-src-alpha",
+    blendAlphaSrcFactor: "one",
+    blendAlphaDstFactor: "one-minus-src-alpha",
+    blendColorOperation: "add",
+    blendAlphaOperation: "add"
+  } : {};
+  if (getProjection(map2) === "globe") {
+    result.cullMode = "back";
+  }
+  return result;
+}
+function drawLayer(deck, map2, layer, renderParameters) {
+  if (!deck.isInitialized) {
+    return;
+  }
+  let { currentViewport } = deck.userData;
+  let clearStack = false;
+  if (!currentViewport) {
+    currentViewport = getViewport(deck, map2, renderParameters);
+    deck.userData.currentViewport = currentViewport;
+    clearStack = true;
+  }
+  deck._drawLayers("mapbox-repaint", {
+    viewports: [currentViewport],
+    layerFilter: (params) => (!deck.props.layerFilter || deck.props.layerFilter(params)) && (layer.id === params.layer.id || params.layer.props.operation.includes("terrain")),
+    clearStack,
+    clearCanvas: false
+  });
+}
+function drawLayerGroup(deck, map2, group, renderParameters) {
+  if (!deck.isInitialized) {
+    return;
+  }
+  let { currentViewport } = deck.userData;
+  let clearStack = false;
+  if (!currentViewport) {
+    currentViewport = getViewport(deck, map2, renderParameters);
+    deck.userData.currentViewport = currentViewport;
+    clearStack = true;
+  }
+  deck._drawLayers("mapbox-repaint", {
+    viewports: [currentViewport],
+    layerFilter: (params) => {
+      if (deck.props.layerFilter && !deck.props.layerFilter(params)) {
+        return false;
+      }
+      const layer = params.layer;
+      if (layer.props.beforeId === group.beforeId && layer.props.slot === group.slot) {
+        return true;
+      }
+      return false;
+    },
+    clearStack,
+    clearCanvas: false
+  });
+}
+function getProjection(map2) {
+  var _a3;
+  const projection = (_a3 = map2.getProjection) == null ? void 0 : _a3.call(map2);
+  const type = (
+    // maplibre projection spec
+    (projection == null ? void 0 : projection.type) || // mapbox projection spec
+    (projection == null ? void 0 : projection.name)
+  );
+  if (type === "globe") {
+    return "globe";
+  }
+  if (type && type !== "mercator") {
+    throw new Error("Unsupported projection");
+  }
+  return "mercator";
+}
+function getDefaultView(map2) {
+  if (getProjection(map2) === "globe") {
+    return new GlobeView({ id: MAPBOX_VIEW_ID });
+  }
+  return new MapView({ id: MAPBOX_VIEW_ID });
+}
+function getViewState(map2) {
+  var _a3;
+  const { lng, lat } = map2.getCenter();
+  const viewState = {
+    // Longitude returned by getCenter can be outside of [-180, 180] when zooming near the anti meridian
+    // https://github.com/visgl/deck.gl/issues/6894
+    longitude: (lng + 540) % 360 - 180,
+    latitude: lat,
+    zoom: map2.getZoom(),
+    bearing: map2.getBearing(),
+    pitch: map2.getPitch(),
+    padding: map2.getPadding(),
+    repeat: map2.getRenderWorldCopies()
+  };
+  if ((_a3 = map2.getTerrain) == null ? void 0 : _a3.call(map2)) {
+    centerCameraOnTerrain(map2, viewState);
+  }
+  return viewState;
+}
+function centerCameraOnTerrain(map2, viewState) {
+  if (map2.getFreeCameraOptions) {
+    const { position } = map2.getFreeCameraOptions();
+    if (!position || position.z === void 0) {
+      return;
+    }
+    const height = map2.transform.height;
+    const { longitude, latitude, pitch } = viewState;
+    const cameraX = position.x * TILE_SIZE;
+    const cameraY = (1 - position.y) * TILE_SIZE;
+    const cameraZ = position.z * TILE_SIZE;
+    const center = lngLatToWorld([longitude, latitude]);
+    const dx = cameraX - center[0];
+    const dy = cameraY - center[1];
+    const cameraToCenterDistanceGround = Math.sqrt(dx * dx + dy * dy);
+    const pitchRadians = pitch * DEGREES_TO_RADIANS;
+    const altitudePixels = 1.5 * height;
+    const scale2 = pitchRadians < 1e-3 ? (
+      // Pitch angle too small to deduce the look at point, assume elevation is 0
+      altitudePixels * Math.cos(pitchRadians) / cameraZ
+    ) : altitudePixels * Math.sin(pitchRadians) / cameraToCenterDistanceGround;
+    viewState.zoom = Math.log2(scale2);
+    const cameraZFromSurface = altitudePixels * Math.cos(pitchRadians) / scale2;
+    const surfaceElevation = cameraZ - cameraZFromSurface;
+    viewState.position = [0, 0, surfaceElevation / unitsPerMeter(latitude)];
+  } else if (typeof map2.transform.elevation === "number") {
+    viewState.position = [0, 0, map2.transform.elevation];
+  }
+}
+function getViewport(deck, map2, renderParameters) {
+  const viewState = getViewState(map2);
+  const view = deck.getView(MAPBOX_VIEW_ID) || getDefaultView(map2);
+  if (renderParameters) {
+    view.props.nearZMultiplier = 0.2;
+  }
+  const nearZ = (renderParameters == null ? void 0 : renderParameters.nearZ) ?? map2.transform._nearZ;
+  const farZ = (renderParameters == null ? void 0 : renderParameters.farZ) ?? map2.transform._farZ;
+  if (Number.isFinite(nearZ)) {
+    viewState.nearZ = nearZ / map2.transform.height;
+    viewState.farZ = farZ / map2.transform.height;
+  }
+  return view.makeViewport({
+    width: deck.width,
+    height: deck.height,
+    viewState
+  });
+}
+function afterRender(deck, map2) {
+  const deckLayers = flatten(deck.props.layers, Boolean);
+  const hasNonMapboxLayers = deckLayers.some((layer) => layer && !map2.getLayer(layer.id));
+  let viewports = deck.getViewports();
+  const mapboxViewportIdx = viewports.findIndex((vp) => vp.id === MAPBOX_VIEW_ID);
+  const hasNonMapboxViews = viewports.length > 1 || mapboxViewportIdx < 0;
+  if (hasNonMapboxLayers || hasNonMapboxViews) {
+    if (mapboxViewportIdx >= 0) {
+      viewports = viewports.slice();
+      viewports[mapboxViewportIdx] = getViewport(deck, map2);
+    }
+    deck._drawLayers("mapbox-repaint", {
+      viewports,
+      layerFilter: (params) => (!deck.props.layerFilter || deck.props.layerFilter(params)) && (params.viewport.id !== MAPBOX_VIEW_ID || !map2.getLayer(params.layer.id)),
+      clearCanvas: false
+    });
+  }
+  deck.userData.currentViewport = null;
+}
+function onMapMove(deck, map2) {
+  deck.setProps({
+    viewState: getViewState(map2)
+  });
+  deck.needsRedraw({ clearRedrawFlags: true });
+}
+class MapboxLayer {
+  /* eslint-disable no-this-before-super */
+  constructor(props) {
+    if (!props.id) {
+      throw new Error("Layer must have an unique id");
+    }
+    this.id = props.id;
+    this.type = "custom";
+    this.renderingMode = props.renderingMode || "3d";
+    this.slot = props.slot;
+    this.map = null;
+    this.props = props;
+  }
+  /* Mapbox custom layer methods */
+  onAdd(map2, gl2) {
+    this.map = map2;
+  }
+  onRemove() {
+    this.map = null;
+  }
+  setProps(props) {
+    Object.assign(this.props, props, { id: this.id });
+  }
+  render(gl2, renderParameters) {
+    if (!this.map)
+      return;
+    drawLayer(this.map.__deck, this.map, this, renderParameters);
+  }
+}
+const UNDEFINED_BEFORE_ID$1 = "__UNDEFINED__";
+function resolveLayers(map2, deck, oldLayers, newLayers) {
+  if (!map2 || !deck || !map2.style || !map2.style._loaded) {
+    return;
+  }
+  const layers = flatten(newLayers, Boolean);
+  if (oldLayers !== newLayers) {
+    const prevLayers = flatten(oldLayers, Boolean);
+    const prevLayerIds = new Set(prevLayers.map((l2) => l2.id));
+    for (const layer of layers) {
+      prevLayerIds.delete(layer.id);
+    }
+    for (const id2 of prevLayerIds) {
+      if (map2.getLayer(id2)) {
+        map2.removeLayer(id2);
+      }
+    }
+  }
+  for (const layer of layers) {
+    const mapboxLayer = map2.getLayer(layer.id);
+    if (mapboxLayer) {
+      const layerInstance = mapboxLayer.implementation || mapboxLayer;
+      layerInstance.setProps(layer.props);
+    } else {
+      map2.addLayer(
+        new MapboxLayer({
+          id: layer.id,
+          // @ts-expect-error slot is not defined in LayerProps
+          slot: layer.props.slot
+        }),
+        // @ts-expect-error beforeId is not defined in LayerProps
+        layer.props.beforeId
+      );
+    }
+  }
+  const mapLayers = map2.style._order;
+  const layerGroups = {};
+  for (const layer of layers) {
+    let { beforeId } = layer.props;
+    if (!beforeId || !mapLayers.includes(beforeId)) {
+      beforeId = UNDEFINED_BEFORE_ID$1;
+    }
+    layerGroups[beforeId] = layerGroups[beforeId] || [];
+    layerGroups[beforeId].push(layer.id);
+  }
+  for (const beforeId in layerGroups) {
+    const layerGroup = layerGroups[beforeId];
+    let lastLayerIndex = beforeId === UNDEFINED_BEFORE_ID$1 ? mapLayers.length : mapLayers.indexOf(beforeId);
+    let lastLayerId = beforeId === UNDEFINED_BEFORE_ID$1 ? void 0 : beforeId;
+    for (let i2 = layerGroup.length - 1; i2 >= 0; i2--) {
+      const layerId = layerGroup[i2];
+      const layerIndex = mapLayers.indexOf(layerId);
+      if (layerIndex !== lastLayerIndex - 1) {
+        map2.moveLayer(layerId, lastLayerId);
+        if (layerIndex > lastLayerIndex) {
+          lastLayerIndex++;
+        }
+      }
+      lastLayerIndex--;
+      lastLayerId = layerId;
+    }
+  }
+}
+class MapboxLayerGroup {
+  /* eslint-disable no-this-before-super */
+  constructor(props) {
+    assert(props.id, "id is required");
+    this.id = props.id;
+    this.type = "custom";
+    this.renderingMode = props.renderingMode || "3d";
+    this.slot = props.slot;
+    this.beforeId = props.beforeId;
+    this.map = null;
+  }
+  /* Mapbox custom layer methods */
+  onAdd(map2, gl2) {
+    this.map = map2;
+  }
+  render(gl2, renderParameters) {
+    if (!this.map)
+      return;
+    drawLayerGroup(this.map.__deck, this.map, this, renderParameters);
+  }
+}
+const UNDEFINED_BEFORE_ID = "__UNDEFINED__";
+function getLayerGroupId(layer) {
+  if (layer.props.beforeId) {
+    return `deck-layer-group-before:${layer.props.beforeId}`;
+  } else if (layer.props.slot) {
+    return `deck-layer-group-slot:${layer.props.slot}`;
+  }
+  return "deck-layer-group-last";
+}
+function resolveLayerGroups(map2, oldLayers, newLayers) {
+  if (!map2 || !map2.style || !map2.style._loaded) {
+    return;
+  }
+  const layers = flatten(newLayers, Boolean);
+  if (oldLayers !== newLayers) {
+    const prevLayers = flatten(oldLayers, Boolean);
+    const prevLayerGroupIds = new Set(prevLayers.map((l2) => getLayerGroupId(l2)));
+    const newLayerGroupIds = new Set(layers.map((l2) => getLayerGroupId(l2)));
+    for (const groupId of prevLayerGroupIds) {
+      if (!newLayerGroupIds.has(groupId)) {
+        if (map2.getLayer(groupId)) {
+          map2.removeLayer(groupId);
+        }
+      }
+    }
+  }
+  const layerGroups = {};
+  for (const layer of layers) {
+    const groupId = getLayerGroupId(layer);
+    const mapboxGroup = map2.getLayer(groupId);
+    if (mapboxGroup) {
+      const groupInstance = mapboxGroup.implementation || mapboxGroup;
+      layerGroups[groupId] = groupInstance;
+    } else {
+      const newGroup = new MapboxLayerGroup({
+        id: groupId,
+        slot: layer.props.slot,
+        beforeId: layer.props.beforeId
+      });
+      layerGroups[groupId] = newGroup;
+      map2.addLayer(newGroup, layer.props.beforeId);
+    }
+  }
+  const mapLayers = map2.style._order;
+  for (const [groupId, group] of Object.entries(layerGroups)) {
+    const beforeId = group.beforeId || UNDEFINED_BEFORE_ID;
+    const expectedGroupIndex = beforeId === UNDEFINED_BEFORE_ID ? mapLayers.length : mapLayers.indexOf(beforeId);
+    const currentGropupIndex = mapLayers.indexOf(groupId);
+    if (currentGropupIndex !== expectedGroupIndex - 1) {
+      const moveBeforeId = beforeId === UNDEFINED_BEFORE_ID ? void 0 : beforeId;
+      map2.moveLayer(groupId, moveBeforeId);
+    }
+  }
+}
+class MapboxOverlay {
+  constructor(props) {
+    this._handleStyleChange = () => {
+      var _a3;
+      this._resolveLayers(this._map, this._deck, this._props.layers, this._props.layers);
+      if (!this._map)
+        return;
+      const projection = getProjection(this._map);
+      if (projection && !this._props.views) {
+        (_a3 = this._deck) == null ? void 0 : _a3.setProps({ views: getDefaultView(this._map) });
+      }
+    };
+    this._updateContainerSize = () => {
+      if (this._map && this._container) {
+        const { clientWidth, clientHeight } = this._map.getContainer();
+        Object.assign(this._container.style, {
+          width: `${clientWidth}px`,
+          height: `${clientHeight}px`
+        });
+      }
+    };
+    this._updateViewState = () => {
+      const deck = this._deck;
+      const map2 = this._map;
+      if (deck && map2) {
+        deck.setProps({
+          views: this._props.views || getDefaultView(map2),
+          viewState: getViewState(map2)
+        });
+        if (deck.isInitialized) {
+          deck.redraw();
+        }
+      }
+    };
+    this._handleMouseEvent = (event) => {
+      const deck = this._deck;
+      if (!deck || !deck.isInitialized) {
+        return;
+      }
+      const mockEvent = {
+        type: event.type,
+        offsetCenter: event.point,
+        srcEvent: event
+      };
+      const lastDown = this._lastMouseDownPoint;
+      if (!event.point && lastDown) {
+        mockEvent.deltaX = event.originalEvent.clientX - lastDown.clientX;
+        mockEvent.deltaY = event.originalEvent.clientY - lastDown.clientY;
+        mockEvent.offsetCenter = {
+          x: lastDown.x + mockEvent.deltaX,
+          y: lastDown.y + mockEvent.deltaY
+        };
+      }
+      switch (mockEvent.type) {
+        case "mousedown":
+          deck._onPointerDown(mockEvent);
+          this._lastMouseDownPoint = {
+            ...event.point,
+            clientX: event.originalEvent.clientX,
+            clientY: event.originalEvent.clientY
+          };
+          break;
+        case "dragstart":
+          mockEvent.type = "panstart";
+          deck._onEvent(mockEvent);
+          break;
+        case "drag":
+          mockEvent.type = "panmove";
+          deck._onEvent(mockEvent);
+          break;
+        case "dragend":
+          mockEvent.type = "panend";
+          deck._onEvent(mockEvent);
+          break;
+        case "click":
+          mockEvent.tapCount = 1;
+          deck._onEvent(mockEvent);
+          break;
+        case "dblclick":
+          mockEvent.type = "click";
+          mockEvent.tapCount = 2;
+          deck._onEvent(mockEvent);
+          break;
+        case "mousemove":
+          mockEvent.type = "pointermove";
+          deck._onPointerMove(mockEvent);
+          break;
+        case "mouseout":
+          mockEvent.type = "pointerleave";
+          deck._onPointerMove(mockEvent);
+          break;
+        default:
+          return;
+      }
+    };
+    const { interleaved = false } = props;
+    this._interleaved = interleaved;
+    this._renderLayersInGroups = props._renderLayersInGroups || false;
+    this._props = this.filterProps(props);
+  }
+  /** Filter out props to pass to Deck **/
+  filterProps(props) {
+    const { interleaved = false, useDevicePixels, ...deckProps } = props;
+    if (!interleaved && useDevicePixels !== void 0) {
+      deckProps.useDevicePixels = useDevicePixels;
+    }
+    return deckProps;
+  }
+  /** Update (partial) props of the underlying Deck instance. */
+  setProps(props) {
+    if (this._interleaved && props.layers) {
+      this._resolveLayers(this._map, this._deck, this._props.layers, props.layers);
+    }
+    Object.assign(this._props, this.filterProps(props));
+    if (this._deck && this._map) {
+      this._deck.setProps({
+        ...this._props,
+        parameters: {
+          ...getDefaultParameters(this._map, this._interleaved),
+          ...this._props.parameters
+        }
+      });
+    }
+  }
+  // The local Map type is for internal typecheck only. It does not necesarily satisefy mapbox/maplibre types at runtime.
+  // Do not restrict the argument type here to avoid type conflict.
+  /** Called when the control is added to a map */
+  onAdd(map2) {
+    this._map = map2;
+    return this._interleaved ? this._onAddInterleaved(map2) : this._onAddOverlaid(map2);
+  }
+  _onAddOverlaid(map2) {
+    const container = document.createElement("div");
+    Object.assign(container.style, {
+      position: "absolute",
+      left: 0,
+      top: 0,
+      textAlign: "initial",
+      pointerEvents: "none"
+    });
+    this._container = container;
+    this._deck = new Deck({
+      ...this._props,
+      parent: container,
+      parameters: { ...getDefaultParameters(map2, false), ...this._props.parameters },
+      views: this._props.views || getDefaultView(map2),
+      viewState: getViewState(map2)
+    });
+    map2.on("resize", this._updateContainerSize);
+    map2.on("render", this._updateViewState);
+    map2.on("mousedown", this._handleMouseEvent);
+    map2.on("dragstart", this._handleMouseEvent);
+    map2.on("drag", this._handleMouseEvent);
+    map2.on("dragend", this._handleMouseEvent);
+    map2.on("mousemove", this._handleMouseEvent);
+    map2.on("mouseout", this._handleMouseEvent);
+    map2.on("click", this._handleMouseEvent);
+    map2.on("dblclick", this._handleMouseEvent);
+    this._updateContainerSize();
+    return container;
+  }
+  _onAddInterleaved(map2) {
+    const gl2 = map2.painter.context.gl;
+    if (gl2 instanceof WebGLRenderingContext) {
+      defaultLogger.warn("Incompatible basemap library. See: https://deck.gl/docs/api-reference/mapbox/overview#compatibility")();
+    }
+    this._deck = getDeckInstance({
+      map: map2,
+      deck: new Deck({
+        ...this._props,
+        gl: gl2,
+        parameters: { ...getDefaultParameters(map2, true), ...this._props.parameters }
+      })
+    });
+    map2.on("styledata", this._handleStyleChange);
+    this._resolveLayers(map2, this._deck, [], this._props.layers);
+    return document.createElement("div");
+  }
+  _resolveLayers(map2, deck, prevLayers, newLayers) {
+    if (this._renderLayersInGroups) {
+      resolveLayerGroups(map2, prevLayers, newLayers);
+    } else {
+      resolveLayers(map2, deck, prevLayers, newLayers);
+    }
+  }
+  /** Called when the control is removed from a map */
+  onRemove() {
+    const map2 = this._map;
+    if (map2) {
+      if (this._interleaved) {
+        this._onRemoveInterleaved(map2);
+      } else {
+        this._onRemoveOverlaid(map2);
+      }
+    }
+    this._deck = void 0;
+    this._map = void 0;
+    this._container = void 0;
+  }
+  _onRemoveOverlaid(map2) {
+    var _a3;
+    map2.off("resize", this._updateContainerSize);
+    map2.off("render", this._updateViewState);
+    map2.off("mousedown", this._handleMouseEvent);
+    map2.off("dragstart", this._handleMouseEvent);
+    map2.off("drag", this._handleMouseEvent);
+    map2.off("dragend", this._handleMouseEvent);
+    map2.off("mousemove", this._handleMouseEvent);
+    map2.off("mouseout", this._handleMouseEvent);
+    map2.off("click", this._handleMouseEvent);
+    map2.off("dblclick", this._handleMouseEvent);
+    (_a3 = this._deck) == null ? void 0 : _a3.finalize();
+  }
+  _onRemoveInterleaved(map2) {
+    map2.off("styledata", this._handleStyleChange);
+    this._resolveLayers(map2, this._deck, this._props.layers, []);
+    removeDeckInstance(map2);
+  }
+  getDefaultPosition() {
+    return "top-left";
+  }
+  /** Forwards the Deck.pickObject method */
+  pickObject(params) {
+    assert(this._deck);
+    return this._deck.pickObject(params);
+  }
+  /** Forwards the Deck.pickMultipleObjects method */
+  pickMultipleObjects(params) {
+    assert(this._deck);
+    return this._deck.pickMultipleObjects(params);
+  }
+  /** Forwards the Deck.pickObjects method */
+  pickObjects(params) {
+    assert(this._deck);
+    return this._deck.pickObjects(params);
+  }
+  /** Remove from map and releases all resources */
+  finalize() {
+    if (this._map) {
+      this._map.removeControl(this);
+    }
+  }
+  /** If interleaved: true, returns base map's canvas, otherwise forwards the Deck.getCanvas method. */
+  getCanvas() {
+    if (!this._map) {
+      return null;
+    }
+    return this._interleaved ? this._map.getCanvas() : this._deck.getCanvas();
+  }
+}
+const glslUniformBlock = `uniform scatterplotUniforms {
+  float radiusScale;
+  float radiusMinPixels;
+  float radiusMaxPixels;
+  float lineWidthScale;
+  float lineWidthMinPixels;
+  float lineWidthMaxPixels;
+  float stroked;
+  float filled;
+  bool antialiasing;
+  bool billboard;
+  highp int radiusUnits;
+  highp int lineWidthUnits;
+} scatterplot;
+`;
+const scatterplotUniforms = {
+  name: "scatterplot",
+  vs: glslUniformBlock,
+  fs: glslUniformBlock,
+  source: "",
+  uniformTypes: {
+    radiusScale: "f32",
+    radiusMinPixels: "f32",
+    radiusMaxPixels: "f32",
+    lineWidthScale: "f32",
+    lineWidthMinPixels: "f32",
+    lineWidthMaxPixels: "f32",
+    stroked: "f32",
+    filled: "f32",
+    antialiasing: "f32",
+    billboard: "f32",
+    radiusUnits: "i32",
+    lineWidthUnits: "i32"
+  }
+};
+const vs = (
+  /* glsl */
+  `#version 300 es
+#define SHADER_NAME scatterplot-layer-vertex-shader
+in vec3 positions;
+in vec3 instancePositions;
+in vec3 instancePositions64Low;
+in float instanceRadius;
+in float instanceLineWidths;
+in vec4 instanceFillColors;
+in vec4 instanceLineColors;
+in vec3 instancePickingColors;
+out vec4 vFillColor;
+out vec4 vLineColor;
+out vec2 unitPosition;
+out float innerUnitRadius;
+out float outerRadiusPixels;
+void main(void) {
+geometry.worldPosition = instancePositions;
+outerRadiusPixels = clamp(
+project_size_to_pixel(scatterplot.radiusScale * instanceRadius, scatterplot.radiusUnits),
+scatterplot.radiusMinPixels, scatterplot.radiusMaxPixels
+);
+float lineWidthPixels = clamp(
+project_size_to_pixel(scatterplot.lineWidthScale * instanceLineWidths, scatterplot.lineWidthUnits),
+scatterplot.lineWidthMinPixels, scatterplot.lineWidthMaxPixels
+);
+outerRadiusPixels += scatterplot.stroked * lineWidthPixels / 2.0;
+float edgePadding = scatterplot.antialiasing ? (outerRadiusPixels + SMOOTH_EDGE_RADIUS) / outerRadiusPixels : 1.0;
+unitPosition = edgePadding * positions.xy;
+geometry.uv = unitPosition;
+geometry.pickingColor = instancePickingColors;
+innerUnitRadius = 1.0 - scatterplot.stroked * lineWidthPixels / outerRadiusPixels;
+if (scatterplot.billboard) {
+gl_Position = project_position_to_clipspace(instancePositions, instancePositions64Low, vec3(0.0), geometry.position);
+DECKGL_FILTER_GL_POSITION(gl_Position, geometry);
+vec3 offset = edgePadding * positions * outerRadiusPixels;
+DECKGL_FILTER_SIZE(offset, geometry);
+gl_Position.xy += project_pixel_size_to_clipspace(offset.xy);
+} else {
+vec3 offset = edgePadding * positions * project_pixel_size(outerRadiusPixels);
+DECKGL_FILTER_SIZE(offset, geometry);
+gl_Position = project_position_to_clipspace(instancePositions, instancePositions64Low, offset, geometry.position);
+DECKGL_FILTER_GL_POSITION(gl_Position, geometry);
+}
+vFillColor = vec4(instanceFillColors.rgb, instanceFillColors.a * layer.opacity);
+DECKGL_FILTER_COLOR(vFillColor, geometry);
+vLineColor = vec4(instanceLineColors.rgb, instanceLineColors.a * layer.opacity);
+DECKGL_FILTER_COLOR(vLineColor, geometry);
+}
+`
+);
+const fs = (
+  /* glsl */
+  `#version 300 es
+#define SHADER_NAME scatterplot-layer-fragment-shader
+precision highp float;
+in vec4 vFillColor;
+in vec4 vLineColor;
+in vec2 unitPosition;
+in float innerUnitRadius;
+in float outerRadiusPixels;
+out vec4 fragColor;
+void main(void) {
+geometry.uv = unitPosition;
+float distToCenter = length(unitPosition) * outerRadiusPixels;
+float inCircle = scatterplot.antialiasing ?
+smoothedge(distToCenter, outerRadiusPixels) :
+step(distToCenter, outerRadiusPixels);
+if (inCircle == 0.0) {
+discard;
+}
+if (scatterplot.stroked > 0.5) {
+float isLine = scatterplot.antialiasing ?
+smoothedge(innerUnitRadius * outerRadiusPixels, distToCenter) :
+step(innerUnitRadius * outerRadiusPixels, distToCenter);
+if (scatterplot.filled > 0.5) {
+fragColor = mix(vFillColor, vLineColor, isLine);
+} else {
+if (isLine == 0.0) {
+discard;
+}
+fragColor = vec4(vLineColor.rgb, vLineColor.a * isLine);
+}
+} else if (scatterplot.filled < 0.5) {
+discard;
+} else {
+fragColor = vFillColor;
+}
+fragColor.a *= inCircle;
+DECKGL_FILTER_COLOR(fragColor, geometry);
+}
+`
+);
+const source = (
+  /* wgsl */
+  `// Main shaders
+
+struct ScatterplotUniforms {
+  radiusScale: f32,
+  radiusMinPixels: f32,
+  radiusMaxPixels: f32,
+  lineWidthScale: f32,
+  lineWidthMinPixels: f32,
+  lineWidthMaxPixels: f32,
+  stroked: f32,
+  filled: i32,
+  antialiasing: i32,
+  billboard: i32,
+  radiusUnits: i32,
+  lineWidthUnits: i32,
+};
+
+struct ConstantAttributeUniforms {
+ instancePositions: vec3<f32>,
+ instancePositions64Low: vec3<f32>,
+ instanceRadius: f32,
+ instanceLineWidths: f32,
+ instanceFillColors: vec4<f32>,
+ instanceLineColors: vec4<f32>,
+ instancePickingColors: vec3<f32>,
+
+ instancePositionsConstant: i32,
+ instancePositions64LowConstant: i32,
+ instanceRadiusConstant: i32,
+ instanceLineWidthsConstant: i32,
+ instanceFillColorsConstant: i32,
+ instanceLineColorsConstant: i32,
+ instancePickingColorsConstant: i32
+};
+
+@group(0) @binding(2) var<uniform> scatterplot: ScatterplotUniforms;
+
+struct ConstantAttributes {
+  instancePositions: vec3<f32>,
+  instancePositions64Low: vec3<f32>,
+  instanceRadius: f32,
+  instanceLineWidths: f32,
+  instanceFillColors: vec4<f32>,
+  instanceLineColors: vec4<f32>,
+  instancePickingColors: vec3<f32>
+};
+
+const constants = ConstantAttributes(
+  vec3<f32>(0.0),
+  vec3<f32>(0.0),
+  0.0,
+  0.0,
+  vec4<f32>(0.0, 0.0, 0.0, 1.0),
+  vec4<f32>(0.0, 0.0, 0.0, 1.0),
+  vec3<f32>(0.0)
+);
+
+struct Attributes {
+  @builtin(instance_index) instanceIndex : u32,
+  @builtin(vertex_index) vertexIndex : u32,
+  @location(0) positions: vec3<f32>,
+  @location(1) instancePositions: vec3<f32>,
+  @location(2) instancePositions64Low: vec3<f32>,
+  @location(3) instanceRadius: f32,
+  @location(4) instanceLineWidths: f32,
+  @location(5) instanceFillColors: vec4<f32>,
+  @location(6) instanceLineColors: vec4<f32>,
+  @location(7) instancePickingColors: vec3<f32>
+};
+
+struct Varyings {
+  @builtin(position) position: vec4<f32>,
+  @location(0) vFillColor: vec4<f32>,
+  @location(1) vLineColor: vec4<f32>,
+  @location(2) unitPosition: vec2<f32>,
+  @location(3) innerUnitRadius: f32,
+  @location(4) outerRadiusPixels: f32,
+};
+
+@vertex
+fn vertexMain(attributes: Attributes) -> Varyings {
+  var varyings: Varyings;
+
+  // Draw an inline geometry constant array clip space triangle to verify that rendering works.
+  // var positions = array<vec2<f32>, 3>(vec2(0.0, 0.5), vec2(-0.5, -0.5), vec2(0.5, -0.5));
+  // if (attributes.instanceIndex == 0) {
+  //   varyings.position = vec4<f32>(positions[attributes.vertexIndex], 0.0, 1.0);
+  //   return varyings;
+  // }
+
+  // var geometry: Geometry;
+  // geometry.worldPosition = instancePositions;
+
+  // Multiply out radius and clamp to limits
+  varyings.outerRadiusPixels = clamp(
+    project_unit_size_to_pixel(scatterplot.radiusScale * attributes.instanceRadius, scatterplot.radiusUnits),
+    scatterplot.radiusMinPixels, scatterplot.radiusMaxPixels
+  );
+
+  // Multiply out line width and clamp to limits
+  let lineWidthPixels = clamp(
+    project_unit_size_to_pixel(scatterplot.lineWidthScale * attributes.instanceLineWidths, scatterplot.lineWidthUnits),
+    scatterplot.lineWidthMinPixels, scatterplot.lineWidthMaxPixels
+  );
+
+  // outer radius needs to offset by half stroke width
+  varyings.outerRadiusPixels += scatterplot.stroked * lineWidthPixels / 2.0;
+  // Expand geometry to accommodate edge smoothing
+  let edgePadding = select(
+    (varyings.outerRadiusPixels + SMOOTH_EDGE_RADIUS) / varyings.outerRadiusPixels,
+    1.0,
+    scatterplot.antialiasing != 0
+  );
+
+  // position on the containing square in [-1, 1] space
+  varyings.unitPosition = edgePadding * attributes.positions.xy;
+  geometry.uv = varyings.unitPosition;
+  geometry.pickingColor = attributes.instancePickingColors;
+
+  varyings.innerUnitRadius = 1.0 - scatterplot.stroked * lineWidthPixels / varyings.outerRadiusPixels;
+
+  if (scatterplot.billboard != 0) {
+    varyings.position = project_position_to_clipspace(attributes.instancePositions, attributes.instancePositions64Low, vec3<f32>(0.0)); // TODO , geometry.position);
+    // DECKGL_FILTER_GL_POSITION(varyings.position, geometry);
+    let offset = attributes.positions; // * edgePadding * varyings.outerRadiusPixels;
+    // DECKGL_FILTER_SIZE(offset, geometry);
+    let clipPixels = project_pixel_size_to_clipspace(offset.xy);
+    varyings.position.x = clipPixels.x;
+    varyings.position.y = clipPixels.y;
+  } else {
+    let offset = edgePadding * attributes.positions * project_pixel_size_float(varyings.outerRadiusPixels);
+    // DECKGL_FILTER_SIZE(offset, geometry);
+    varyings.position = project_position_to_clipspace(attributes.instancePositions, attributes.instancePositions64Low, offset); // TODO , geometry.position);
+    // DECKGL_FILTER_GL_POSITION(varyings.position, geometry);
+  }
+
+  // Apply opacity to instance color, or return instance picking color
+  varyings.vFillColor = vec4<f32>(attributes.instanceFillColors.rgb, attributes.instanceFillColors.a * color.opacity);
+  // DECKGL_FILTER_COLOR(varyings.vFillColor, geometry);
+  varyings.vLineColor = vec4<f32>(attributes.instanceLineColors.rgb, attributes.instanceLineColors.a * color.opacity);
+  // DECKGL_FILTER_COLOR(varyings.vLineColor, geometry);
+
+  return varyings;
+}
+
+@fragment
+fn fragmentMain(varyings: Varyings) -> @location(0) vec4<f32> {
+  // var geometry: Geometry;
+  // geometry.uv = unitPosition;
+
+  let distToCenter = length(varyings.unitPosition) * varyings.outerRadiusPixels;
+  let inCircle = select(
+    smoothedge(distToCenter, varyings.outerRadiusPixels),
+    step(distToCenter, varyings.outerRadiusPixels),
+    scatterplot.antialiasing != 0
+  );
+
+  if (inCircle == 0.0) {
+    discard;
+  }
+
+  var fragColor: vec4<f32>;
+
+  if (scatterplot.stroked != 0) {
+    let isLine = select(
+      smoothedge(varyings.innerUnitRadius * varyings.outerRadiusPixels, distToCenter),
+      step(varyings.innerUnitRadius * varyings.outerRadiusPixels, distToCenter),
+      scatterplot.antialiasing != 0
+    );
+
+    if (scatterplot.filled != 0) {
+      fragColor = mix(varyings.vFillColor, varyings.vLineColor, isLine);
+    } else {
+      if (isLine == 0.0) {
+        discard;
+      }
+      fragColor = vec4<f32>(varyings.vLineColor.rgb, varyings.vLineColor.a * isLine);
+    }
+  } else if (scatterplot.filled == 0) {
+    discard;
+  } else {
+    fragColor = varyings.vFillColor;
+  }
+
+  fragColor.a *= inCircle;
+  // DECKGL_FILTER_COLOR(fragColor, geometry);
+
+  // Apply premultiplied alpha as required by transparent canvas
+  fragColor = deckgl_premultiplied_alpha(fragColor);
+
+  return fragColor;
+  // return vec4<f32>(0, 0, 1, 1);
+}
+`
+);
+const DEFAULT_COLOR = [0, 0, 0, 255];
+const defaultProps = {
+  radiusUnits: "meters",
+  radiusScale: { type: "number", min: 0, value: 1 },
+  radiusMinPixels: { type: "number", min: 0, value: 0 },
+  //  min point radius in pixels
+  radiusMaxPixels: { type: "number", min: 0, value: Number.MAX_SAFE_INTEGER },
+  // max point radius in pixels
+  lineWidthUnits: "meters",
+  lineWidthScale: { type: "number", min: 0, value: 1 },
+  lineWidthMinPixels: { type: "number", min: 0, value: 0 },
+  lineWidthMaxPixels: { type: "number", min: 0, value: Number.MAX_SAFE_INTEGER },
+  stroked: false,
+  filled: true,
+  billboard: false,
+  antialiasing: true,
+  getPosition: { type: "accessor", value: (x2) => x2.position },
+  getRadius: { type: "accessor", value: 1 },
+  getFillColor: { type: "accessor", value: DEFAULT_COLOR },
+  getLineColor: { type: "accessor", value: DEFAULT_COLOR },
+  getLineWidth: { type: "accessor", value: 1 },
+  // deprecated
+  strokeWidth: { deprecatedFor: "getLineWidth" },
+  outline: { deprecatedFor: "stroked" },
+  getColor: { deprecatedFor: ["getFillColor", "getLineColor"] }
+};
+class ScatterplotLayer extends Layer {
+  getShaders() {
+    return super.getShaders({
+      vs,
+      fs,
+      source,
+      modules: [project32, color, picking, scatterplotUniforms]
+    });
+  }
+  initializeState() {
+    this.getAttributeManager().addInstanced({
+      instancePositions: {
+        size: 3,
+        type: "float64",
+        fp64: this.use64bitPositions(),
+        transition: true,
+        accessor: "getPosition"
       },
-      // @method distance(latlng1: LatLng, latlng2: LatLng): Number
-      // Returns the distance between two geographical coordinates according to
-      // the map's CRS. By default this measures distance in meters.
-      distance: function(latlng1, latlng2) {
-        return this.options.crs.distance(toLatLng(latlng1), toLatLng(latlng2));
+      instanceRadius: {
+        size: 1,
+        transition: true,
+        accessor: "getRadius",
+        defaultValue: 1
       },
-      // @method containerPointToLayerPoint(point: Point): Point
-      // Given a pixel coordinate relative to the map container, returns the corresponding
-      // pixel coordinate relative to the [origin pixel](#map-getpixelorigin).
-      containerPointToLayerPoint: function(point) {
-        return toPoint(point).subtract(this._getMapPanePos());
+      instanceFillColors: {
+        size: this.props.colorFormat.length,
+        transition: true,
+        type: "unorm8",
+        accessor: "getFillColor",
+        defaultValue: [0, 0, 0, 255]
       },
-      // @method layerPointToContainerPoint(point: Point): Point
-      // Given a pixel coordinate relative to the [origin pixel](#map-getpixelorigin),
-      // returns the corresponding pixel coordinate relative to the map container.
-      layerPointToContainerPoint: function(point) {
-        return toPoint(point).add(this._getMapPanePos());
+      instanceLineColors: {
+        size: this.props.colorFormat.length,
+        transition: true,
+        type: "unorm8",
+        accessor: "getLineColor",
+        defaultValue: [0, 0, 0, 255]
       },
-      // @method containerPointToLatLng(point: Point): LatLng
-      // Given a pixel coordinate relative to the map container, returns
-      // the corresponding geographical coordinate (for the current zoom level).
-      containerPointToLatLng: function(point) {
-        var layerPoint = this.containerPointToLayerPoint(toPoint(point));
-        return this.layerPointToLatLng(layerPoint);
+      instanceLineWidths: {
+        size: 1,
+        transition: true,
+        accessor: "getLineWidth",
+        defaultValue: 1
+      }
+    });
+  }
+  updateState(params) {
+    var _a3;
+    super.updateState(params);
+    if (params.changeFlags.extensionsChanged) {
+      (_a3 = this.state.model) == null ? void 0 : _a3.destroy();
+      this.state.model = this._getModel();
+      this.getAttributeManager().invalidateAll();
+    }
+  }
+  draw({ uniforms }) {
+    const { radiusUnits, radiusScale, radiusMinPixels, radiusMaxPixels, stroked, filled, billboard, antialiasing, lineWidthUnits, lineWidthScale, lineWidthMinPixels, lineWidthMaxPixels } = this.props;
+    const scatterplotProps = {
+      stroked,
+      filled,
+      billboard,
+      antialiasing,
+      radiusUnits: UNIT[radiusUnits],
+      radiusScale,
+      radiusMinPixels,
+      radiusMaxPixels,
+      lineWidthUnits: UNIT[lineWidthUnits],
+      lineWidthScale,
+      lineWidthMinPixels,
+      lineWidthMaxPixels
+    };
+    const model = this.state.model;
+    model.shaderInputs.setProps({ scatterplot: scatterplotProps });
+    if (this.context.device.type === "webgpu") {
+      model.instanceCount = this.props.data.length;
+    }
+    model.draw(this.context.renderPass);
+  }
+  _getModel() {
+    const parameters = this.context.device.type === "webgpu" ? {
+      depthWriteEnabled: true,
+      depthCompare: "less-equal"
+    } : void 0;
+    const positions = [-1, -1, 0, 1, -1, 0, -1, 1, 0, 1, 1, 0];
+    return new Model(this.context.device, {
+      ...this.getShaders(),
+      id: this.props.id,
+      bufferLayout: this.getAttributeManager().getBufferLayouts(),
+      geometry: new Geometry({
+        topology: "triangle-strip",
+        attributes: {
+          positions: { size: 3, value: new Float32Array(positions) }
+        }
+      }),
+      isInstanced: true,
+      parameters
+    });
+  }
+}
+ScatterplotLayer.defaultProps = defaultProps;
+ScatterplotLayer.layerName = "ScatterplotLayer";
+function interpolateStops(t2, stops) {
+  const n2 = stops.length - 1;
+  const idx = Math.min(Math.floor(t2 * n2), n2 - 1);
+  const local = t2 * n2 - idx;
+  const a2 = stops[idx];
+  const b2 = stops[idx + 1];
+  return [
+    Math.round(a2[0] + (b2[0] - a2[0]) * local),
+    Math.round(a2[1] + (b2[1] - a2[1]) * local),
+    Math.round(a2[2] + (b2[2] - a2[2]) * local),
+    220
+  ];
+}
+const COLORMAP_STOPS = {
+  rdbu_r: [
+    [33, 102, 172],
+    // blue (low)
+    [146, 197, 222],
+    [247, 247, 247],
+    // white (mid)
+    [214, 96, 77],
+    [178, 24, 43]
+    // red (high)
+  ],
+  viridis: [
+    [68, 1, 84],
+    [59, 82, 139],
+    [33, 145, 140],
+    [94, 201, 98],
+    [253, 231, 37]
+  ],
+  plasma: [
+    [13, 8, 135],
+    [126, 3, 168],
+    [204, 71, 120],
+    [248, 149, 64],
+    [240, 249, 33]
+  ],
+  inferno: [
+    [0, 0, 4],
+    [87, 16, 110],
+    [188, 55, 84],
+    [249, 142, 9],
+    [252, 255, 164]
+  ],
+  coolwarm: [
+    [59, 76, 192],
+    [141, 176, 254],
+    [221, 221, 221],
+    [245, 152, 105],
+    [180, 4, 38]
+  ]
+};
+const COLORMAP_NAMES = Object.keys(COLORMAP_STOPS);
+function valueToColor(value, vmin, vmax, colormap = "rdbu_r") {
+  const t2 = Math.max(0, Math.min(1, (value - vmin) / (vmax - vmin || 1)));
+  const stops = COLORMAP_STOPS[colormap] || COLORMAP_STOPS.rdbu_r;
+  return interpolateStops(t2, stops);
+}
+function colormapGradientCSS(colormap = "rdbu_r") {
+  const stops = COLORMAP_STOPS[colormap] || COLORMAP_STOPS.rdbu_r;
+  const cssStops = stops.map((s2, i2) => {
+    const pct = i2 / (stops.length - 1) * 100;
+    return `rgb(${s2[0]},${s2[1]},${s2[2]}) ${pct}%`;
+  });
+  return `linear-gradient(to right, ${cssStops.join(", ")})`;
+}
+const BASEMAPS = {
+  satellite: {
+    url: "https://mt1.google.com/vt/lyrs=s&x={x}&y={y}&z={z}",
+    maxZoom: 21
+  },
+  osm: {
+    url: "https://tile.openstreetmap.org/{z}/{x}/{y}.png",
+    maxZoom: 19
+  },
+  dark: {
+    url: "https://basemaps.cartocdn.com/dark_all/{z}/{x}/{y}@2x.png",
+    maxZoom: 20
+  }
+};
+function MapContainer() {
+  const { state, dispatch } = useAppContext();
+  const { fetchPoints, fetchPointTimeseries } = usePointsApi();
+  const { fetchPointTimeSeries: fetchRasterPixelTS } = useApi();
+  const { fetchGpsStations, fetchGpsTimeseries } = useGpsApi();
+  const mapContainerRef = reactExports.useRef(null);
+  const mapRef = reactExports.useRef(null);
+  const deckOverlayRef = reactExports.useRef(null);
+  const deckLayersRef = reactExports.useRef([]);
+  const setDeckLayers = reactExports.useCallback((layers) => {
+    var _a3;
+    deckLayersRef.current = layers;
+    (_a3 = deckOverlayRef.current) == null ? void 0 : _a3.setProps({ layers });
+  }, []);
+  const refMarkerRef = reactExports.useRef(null);
+  const deckClickedRef = reactExports.useRef(false);
+  const tsMarkersRef = reactExports.useRef([]);
+  const [pointData, setPointData] = reactExports.useState(null);
+  const [selectedPointId, setSelectedPointId] = reactExports.useState(null);
+  const [pointCount, setPointCount] = reactExports.useState(0);
+  const colorBy = state.pointColorBy;
+  const pointVmin = state.pointVmin;
+  const pointVmax = state.pointVmax;
+  const pointFilter = state.pointFilter;
+  const pointBasemap = state.pointBasemap;
+  const pointColormap = state.pointColormap;
+  reactExports.useEffect(() => {
+    if (!mapContainerRef.current || mapRef.current) return;
+    const map2 = new maplibregl.Map({
+      container: mapContainerRef.current,
+      style: {
+        version: 8,
+        sources: {
+          "basemap": {
+            type: "raster",
+            tiles: [BASEMAPS.satellite.url],
+            tileSize: 256,
+            maxzoom: BASEMAPS.satellite.maxZoom
+          }
+        },
+        layers: [{
+          id: "basemap",
+          type: "raster",
+          source: "basemap"
+        }]
       },
-      // @method latLngToContainerPoint(latlng: LatLng): Point
-      // Given a geographical coordinate, returns the corresponding pixel coordinate
-      // relative to the map container.
-      latLngToContainerPoint: function(latlng) {
-        return this.layerPointToContainerPoint(this.latLngToLayerPoint(toLatLng(latlng)));
+      center: (() => {
+        const url = parseUrlState();
+        if (url.lon && url.lat) return [parseFloat(url.lon), parseFloat(url.lat)];
+        return [0, 0];
+      })(),
+      zoom: (() => {
+        const url = parseUrlState();
+        return url.zoom ? parseFloat(url.zoom) : 12;
+      })(),
+      maxZoom: 22,
+      // @ts-expect-error preserveDrawingBuffer is a valid WebGL option, not in MapLibre types
+      preserveDrawingBuffer: true,
+      // Needed for map canvas export to PNG
+      attributionControl: false
+    });
+    map2.addControl(new maplibregl.NavigationControl(), "top-right");
+    map2.addControl(new maplibregl.AttributionControl({ compact: true }), "bottom-right");
+    let urlSyncEnabled = false;
+    setTimeout(() => {
+      urlSyncEnabled = true;
+    }, 2e3);
+    map2.on("moveend", () => {
+      if (!urlSyncEnabled) return;
+      const center = map2.getCenter();
+      const z2 = map2.getZoom();
+      const params = new URLSearchParams(window.location.search);
+      params.set("lat", center.lat.toFixed(4));
+      params.set("lon", center.lng.toFixed(4));
+      params.set("zoom", z2.toFixed(1));
+      window.history.replaceState(null, "", `?${params}`);
+    });
+    const deckOverlay = new MapboxOverlay({
+      interleaved: false,
+      layers: []
+    });
+    map2.addControl(deckOverlay);
+    deckOverlayRef.current = deckOverlay;
+    mapRef.current = map2;
+    return () => {
+      map2.remove();
+      mapRef.current = null;
+      deckOverlayRef.current = null;
+    };
+  }, []);
+  const hasRasters = Object.keys(state.datasetInfo).length > 0;
+  const hasPointLayer = state.activePointLayer != null;
+  reactExports.useEffect(() => {
+    const map2 = mapRef.current;
+    if (!map2 || !hasRasters) return;
+    const handleClick = (e2) => {
+      if (hasPointLayer) return;
+      if (deckClickedRef.current) {
+        deckClickedRef.current = false;
+        return;
+      }
+      const { lng, lat } = e2.lngLat;
+      dispatch({
+        type: "ADD_TIME_SERIES_POINT",
+        payload: { position: [lat, lng] }
+      });
+      if (!state.showChart) {
+        dispatch({ type: "TOGGLE_CHART" });
+      }
+    };
+    map2.on("click", handleClick);
+    return () => {
+      map2.off("click", handleClick);
+    };
+  }, [hasRasters, hasPointLayer, state.showChart, dispatch]);
+  reactExports.useEffect(() => {
+    var _a3;
+    if (!hasRasters || !state.currentDataset) return;
+    for (const point of state.timeSeriesPoints) {
+      if (!((_a3 = point.data) == null ? void 0 : _a3[state.currentDataset])) {
+        fetchRasterPixelTS(point.position[1], point.position[0], state.currentDataset).then((values) => {
+          if (values) {
+            dispatch({
+              type: "SET_POINT_DATA",
+              payload: { pointId: point.id, dataset: state.currentDataset, data: values }
+            });
+          }
+        });
+      }
+    }
+  }, [state.timeSeriesPoints, state.currentDataset, hasRasters, fetchRasterPixelTS, dispatch]);
+  reactExports.useEffect(() => {
+    const map2 = mapRef.current;
+    if (!map2 || !hasRasters) return;
+    if (!refMarkerRef.current) {
+      const el2 = document.createElement("div");
+      el2.style.width = "20px";
+      el2.style.height = "20px";
+      el2.style.borderRadius = "50%";
+      el2.style.background = "#ff4444";
+      el2.style.border = "3px solid white";
+      el2.style.cursor = "grab";
+      el2.title = "Reference point (drag to move)";
+      const marker = new maplibregl.Marker({ element: el2, draggable: true }).setLngLat([state.refMarkerPosition[1], state.refMarkerPosition[0]]).addTo(map2);
+      marker.on("dragend", async () => {
+        const lngLat = marker.getLngLat();
+        dispatch({
+          type: "SET_REF_MARKER_POSITION",
+          payload: [lngLat.lat, lngLat.lng]
+        });
+        for (const [dsName] of Object.entries(state.datasetInfo)) {
+          const values = await fetchRasterPixelTS(lngLat.lng, lngLat.lat, dsName);
+          if (values) {
+            dispatch({
+              type: "SET_REF_VALUES",
+              payload: { dataset: dsName, values }
+            });
+          }
+        }
+      });
+      refMarkerRef.current = marker;
+      for (const [dsName] of Object.entries(state.datasetInfo)) {
+        if (!state.refValues[dsName]) {
+          fetchRasterPixelTS(
+            state.refMarkerPosition[1],
+            state.refMarkerPosition[0],
+            dsName
+          ).then((values) => {
+            if (values) {
+              dispatch({ type: "SET_REF_VALUES", payload: { dataset: dsName, values } });
+            }
+          });
+        }
+      }
+    } else {
+      refMarkerRef.current.setLngLat([state.refMarkerPosition[1], state.refMarkerPosition[0]]);
+    }
+    return () => {
+    };
+  }, [hasRasters, state.refMarkerPosition, state.datasetInfo, state.refValues, dispatch, fetchRasterPixelTS]);
+  reactExports.useEffect(() => {
+    const map2 = mapRef.current;
+    if (!map2) return;
+    tsMarkersRef.current.forEach((m2) => m2.remove());
+    tsMarkersRef.current = [];
+    for (const point of state.timeSeriesPoints) {
+      if (!point.visible) continue;
+      const el2 = document.createElement("div");
+      el2.style.width = "12px";
+      el2.style.height = "12px";
+      el2.style.borderRadius = "50%";
+      el2.style.background = point.color;
+      el2.style.border = "2px solid white";
+      el2.style.cursor = "grab";
+      const pointId = point.id;
+      const marker = new maplibregl.Marker({ element: el2, draggable: true }).setLngLat([point.position[1], point.position[0]]).addTo(map2);
+      marker.on("dragend", () => {
+        const lngLat = marker.getLngLat();
+        dispatch({
+          type: "UPDATE_TIME_SERIES_POINT",
+          payload: {
+            id: pointId,
+            updates: { position: [lngLat.lat, lngLat.lng], data: {} }
+          }
+        });
+      });
+      tsMarkersRef.current.push(marker);
+    }
+  }, [state.timeSeriesPoints, dispatch]);
+  reactExports.useEffect(() => {
+    const map2 = mapRef.current;
+    if (!map2) return;
+    const basemap = BASEMAPS[pointBasemap];
+    const source2 = map2.getSource("basemap");
+    if (source2) {
+      source2.setTiles([basemap.url]);
+    }
+  }, [pointBasemap]);
+  reactExports.useEffect(() => {
+    const map2 = mapRef.current;
+    if (!map2) return;
+    const url = parseUrlState();
+    if (url.lat && url.lon && url.zoom) return;
+    if (state.pointLayerBounds) {
+      const [west, south, east, north] = state.pointLayerBounds;
+      map2.fitBounds([[west, south], [east, north]], { padding: 50 });
+      return;
+    }
+    if (state.currentDataset && state.datasetInfo[state.currentDataset]) {
+      const bounds = state.datasetInfo[state.currentDataset].latlon_bounds;
+      map2.fitBounds([[bounds[0], bounds[1]], [bounds[2], bounds[3]]], { padding: 50 });
+    }
+  }, [state.pointLayerBounds, state.currentDataset, state.datasetInfo]);
+  reactExports.useEffect(() => {
+    if (!state.activePointLayer) return;
+    const loadPoints = async () => {
+      try {
+        const data = await fetchPoints(state.activePointLayer, {
+          colorBy,
+          filter: pointFilter || void 0,
+          maxPoints: 2e5
+        });
+        setPointData(data);
+        setPointCount(data.count);
+        if (data.count > 0) {
+          const vals = data.colorValues;
+          const min = vals.reduce((a2, b2) => Math.min(a2, b2), Infinity);
+          const max = vals.reduce((a2, b2) => Math.max(a2, b2), -Infinity);
+          const nBins = 40;
+          const binWidth = (max - min) / nBins || 1;
+          const counts = new Array(nBins).fill(0);
+          const edges = Array.from({ length: nBins + 1 }, (_2, i2) => min + i2 * binWidth);
+          for (const v2 of vals) {
+            const idx = Math.min(Math.floor((v2 - min) / binWidth), nBins - 1);
+            counts[idx]++;
+          }
+          dispatch({ type: "SET_POINT_HISTOGRAM", payload: { edges, counts } });
+        }
+      } catch (err) {
+        console.error("Error loading points:", err);
+      }
+    };
+    loadPoints();
+  }, [state.activePointLayer, colorBy, pointFilter, fetchPoints]);
+  const clickedPointIds = new Set(state.clickedPoints.map((p2) => p2.pointId));
+  const onPointClick = reactExports.useCallback(async (pointId, shiftKey, ctrlKey) => {
+    if (!state.activePointLayer) return;
+    setSelectedPointId(pointId);
+    try {
+      const ts = await fetchPointTimeseries(state.activePointLayer, pointId);
+      if (ctrlKey) {
+        dispatch({ type: "SET_REFERENCE_POINT", payload: { pointId, timeseries: ts } });
+        return;
+      }
+      if (!shiftKey) {
+        dispatch({ type: "CLEAR_CLICKED_POINTS" });
+      }
+      dispatch({
+        type: "SET_CLICKED_POINT_TIMESERIES",
+        payload: { pointId, timeseries: ts }
+      });
+    } catch (err) {
+      console.error("Error fetching timeseries:", err);
+    }
+  }, [state.activePointLayer, fetchPointTimeseries, dispatch]);
+  reactExports.useEffect(() => {
+    const overlay = deckOverlayRef.current;
+    if (!overlay) return;
+    if (!pointData || !state.pointLayerVisible) {
+      const existing2 = deckLayersRef.current;
+      const otherLayers2 = existing2.filter((l2) => l2.id !== "point-cloud");
+      setDeckLayers(otherLayers2);
+      return;
+    }
+    const positions = new Float64Array(pointData.count * 2);
+    for (let i2 = 0; i2 < pointData.count; i2++) {
+      positions[i2 * 2] = pointData.lon[i2];
+      positions[i2 * 2 + 1] = pointData.lat[i2];
+    }
+    const layer = new ScatterplotLayer({
+      id: "point-cloud",
+      data: {
+        length: pointData.count,
+        attributes: {
+          getPosition: { value: positions, size: 2 }
+        }
       },
-      // @method mouseEventToContainerPoint(ev: MouseEvent): Point
-      // Given a MouseEvent object, returns the pixel coordinate relative to the
-      // map container where the event took place.
-      mouseEventToContainerPoint: function(e) {
-        return getMousePosition(e, this._container);
+      getPosition: (_2, { index }) => [pointData.lon[index], pointData.lat[index]],
+      opacity: state.pointOpacity,
+      getFillColor: (_2, { index }) => {
+        const pid = pointData.point_id[index];
+        if (pid === state.referencePointId) {
+          return [0, 255, 128, 255];
+        }
+        if (clickedPointIds.has(pid)) {
+          return [255, 255, 0, 255];
+        }
+        const v2 = pointData.colorValues[index];
+        return valueToColor(v2, pointVmin, pointVmax, pointColormap);
       },
-      // @method mouseEventToLayerPoint(ev: MouseEvent): Point
-      // Given a MouseEvent object, returns the pixel coordinate relative to
-      // the [origin pixel](#map-getpixelorigin) where the event took place.
-      mouseEventToLayerPoint: function(e) {
-        return this.containerPointToLayerPoint(this.mouseEventToContainerPoint(e));
+      getRadius: (_2, { index }) => {
+        const pid = pointData.point_id[index];
+        if (pid === state.referencePointId) return 7;
+        if (clickedPointIds.has(pid)) return 5;
+        return 3;
       },
-      // @method mouseEventToLatLng(ev: MouseEvent): LatLng
-      // Given a MouseEvent object, returns geographical coordinate where the
-      // event took place.
-      mouseEventToLatLng: function(e) {
-        return this.layerPointToLatLng(this.mouseEventToLayerPoint(e));
+      radiusMinPixels: 2,
+      radiusMaxPixels: 14,
+      pickable: true,
+      onClick: (info, event) => {
+        if (info.index >= 0) {
+          const srcEvent = event.srcEvent;
+          const shiftKey = (srcEvent == null ? void 0 : srcEvent.shiftKey) ?? false;
+          const ctrlKey = (srcEvent == null ? void 0 : srcEvent.ctrlKey) ?? (srcEvent == null ? void 0 : srcEvent.metaKey) ?? false;
+          onPointClick(pointData.point_id[info.index], shiftKey, ctrlKey);
+        }
       },
-      // map initialization methods
-      _initContainer: function(id2) {
-        var container = this._container = get(id2);
-        if (!container) {
-          throw new Error("Map container not found.");
-        } else if (container._leaflet_id) {
-          throw new Error("Map container is already initialized.");
-        }
-        on(container, "scroll", this._onScroll, this);
-        this._containerId = stamp(container);
+      updateTriggers: {
+        getFillColor: [pointVmin, pointVmax, pointColormap, state.referencePointId, ...clickedPointIds],
+        getRadius: [state.referencePointId, ...clickedPointIds]
+      }
+    });
+    const existing = deckLayersRef.current;
+    const otherLayers = existing.filter((l2) => l2.id !== "point-cloud");
+    setDeckLayers([layer, ...otherLayers]);
+  }, [
+    pointData,
+    pointVmin,
+    pointVmax,
+    pointColormap,
+    selectedPointId,
+    onPointClick,
+    state.pointLayerVisible,
+    state.pointOpacity
+  ]);
+  reactExports.useEffect(() => {
+    const map2 = mapRef.current;
+    if (!map2 || !state.gpsVisible) return;
+    let debounceTimer;
+    const fetchStations = () => {
+      clearTimeout(debounceTimer);
+      debounceTimer = setTimeout(async () => {
+        const bounds = map2.getBounds();
+        dispatch({ type: "SET_GPS_LOADING", payload: true });
+        const stations = await fetchGpsStations([
+          bounds.getWest(),
+          bounds.getSouth(),
+          bounds.getEast(),
+          bounds.getNorth()
+        ]);
+        dispatch({ type: "SET_GPS_STATIONS", payload: stations });
+      }, 500);
+    };
+    fetchStations();
+    map2.on("moveend", fetchStations);
+    return () => {
+      clearTimeout(debounceTimer);
+      map2.off("moveend", fetchStations);
+    };
+  }, [state.gpsVisible, fetchGpsStations, dispatch]);
+  const onGpsStationClick = reactExports.useCallback(async (stationId) => {
+    deckClickedRef.current = true;
+    dispatch({ type: "SET_GPS_SELECTED_STATION", payload: stationId });
+    const data = await fetchGpsTimeseries(stationId);
+    if (data) {
+      dispatch({ type: "SET_GPS_TIMESERIES", payload: data.timeseries });
+    }
+  }, [fetchGpsTimeseries, dispatch]);
+  reactExports.useEffect(() => {
+    const overlay = deckOverlayRef.current;
+    if (!overlay) return;
+    const existingLayers = deckLayersRef.current;
+    const nonGpsLayers = existingLayers.filter((l2) => l2.id !== "gps-stations");
+    if (!state.gpsVisible || state.gpsStations.length === 0) {
+      setDeckLayers(nonGpsLayers);
+      return;
+    }
+    const gpsLayer = new ScatterplotLayer({
+      id: "gps-stations",
+      data: state.gpsStations,
+      getPosition: (d2) => [d2.lon, d2.lat],
+      getFillColor: (d2) => d2.id === state.gpsSelectedStationId ? [255, 255, 0, 255] : [34, 170, 102, 230],
+      // Default: green
+      getRadius: 8,
+      radiusMinPixels: 6,
+      radiusMaxPixels: 16,
+      stroked: true,
+      getLineColor: [255, 255, 255, 200],
+      getLineWidth: 2,
+      lineWidthMinPixels: 2,
+      pickable: true,
+      onClick: (info) => {
+        if (info.object) {
+          onGpsStationClick(info.object.id);
+        }
       },
-      _initLayout: function() {
-        var container = this._container;
-        this._fadeAnimated = this.options.fadeAnimation && Browser.any3d;
-        addClass(container, "leaflet-container" + (Browser.touch ? " leaflet-touch" : "") + (Browser.retina ? " leaflet-retina" : "") + (Browser.ielt9 ? " leaflet-oldie" : "") + (Browser.safari ? " leaflet-safari" : "") + (this._fadeAnimated ? " leaflet-fade-anim" : ""));
-        var position = getStyle2(container, "position");
-        if (position !== "absolute" && position !== "relative" && position !== "fixed" && position !== "sticky") {
-          container.style.position = "relative";
-        }
-        this._initPanes();
-        if (this._initControlPos) {
-          this._initControlPos();
+      updateTriggers: {
+        getFillColor: [state.gpsSelectedStationId]
+      }
+    });
+    setDeckLayers([...nonGpsLayers, gpsLayer]);
+  }, [state.gpsVisible, state.gpsStations, state.gpsSelectedStationId, onGpsStationClick]);
+  reactExports.useEffect(() => {
+    const map2 = mapRef.current;
+    if (!map2) return;
+    const layer = map2.getLayer("raster-layer");
+    if (layer) {
+      map2.setLayoutProperty(
+        "raster-layer",
+        "visibility",
+        state.rasterLayerVisible ? "visible" : "none"
+      );
+    }
+  }, [state.rasterLayerVisible]);
+  reactExports.useEffect(() => {
+    const map2 = mapRef.current;
+    if (!map2 || !state.currentDataset || !state.datasetInfo[state.currentDataset]) return;
+    const addRasterLayer = () => {
+      const currentDatasetInfo = state.datasetInfo[state.currentDataset];
+      const maxIdx = currentDatasetInfo.x_values.length - 1;
+      const timeIdx = Math.max(0, Math.min(state.currentTimeIndex, maxIdx));
+      const params = {
+        variable: state.currentDataset,
+        time_idx: timeIdx.toString(),
+        rescale: `${state.vmin},${state.vmax}`,
+        colormap_name: state.colormap
+      };
+      if (currentDatasetInfo.algorithm) {
+        params.algorithm = currentDatasetInfo.algorithm;
+      }
+      if (state.refValues[state.currentDataset] && currentDatasetInfo.algorithm === "shift") {
+        const shift = state.refValues[state.currentDataset][timeIdx];
+        if (shift !== void 0) {
+          params.algorithm_params = JSON.stringify({ shift });
+        }
+      }
+      if (state.dataMode === "cog") {
+        params.url = currentDatasetInfo.file_list[timeIdx];
+        const maskUrl = currentDatasetInfo.mask_file_list[timeIdx];
+        if (maskUrl) params.mask = encodeURIComponent(maskUrl);
+        if (currentDatasetInfo.mask_min_value !== void 0) {
+          params.mask_min_value = currentDatasetInfo.mask_min_value.toString();
+        }
+      }
+      const urlParams = new URLSearchParams(params).toString();
+      const endpoint = state.dataMode === "md" ? "md" : "cog";
+      const tileUrl = `/${endpoint}/tiles/WebMercatorQuad/{z}/{x}/{y}.png?${urlParams}`;
+      if (map2.getSource("raster-tiles")) {
+        map2.getSource("raster-tiles").setTiles([tileUrl]);
+      } else {
+        map2.addSource("raster-tiles", {
+          type: "raster",
+          tiles: [tileUrl],
+          tileSize: 256
+        });
+        map2.addLayer({
+          id: "raster-layer",
+          type: "raster",
+          source: "raster-tiles",
+          paint: { "raster-opacity": state.opacity }
+        }, map2.getLayer("basemap") ? void 0 : void 0);
+      }
+      if (map2.getLayer("raster-layer")) {
+        map2.setPaintProperty("raster-layer", "raster-opacity", state.opacity);
+      }
+    };
+    if (map2.isStyleLoaded()) {
+      addRasterLayer();
+    } else {
+      map2.once("load", addRasterLayer);
+    }
+  }, [
+    state.currentDataset,
+    state.currentTimeIndex,
+    state.datasetInfo,
+    state.dataMode,
+    state.refValues,
+    state.colormap,
+    state.vmin,
+    state.vmax,
+    state.opacity
+  ]);
+  return /* @__PURE__ */ jsxRuntimeExports.jsxs("div", { style: { position: "relative", width: "100%", height: "100%" }, children: [
+    /* @__PURE__ */ jsxRuntimeExports.jsx("div", { ref: mapContainerRef, style: { width: "100%", height: "100%" } }),
+    pointCount > 0 && /* @__PURE__ */ jsxRuntimeExports.jsxs("div", { style: {
+      position: "absolute",
+      bottom: 30,
+      left: 10,
+      background: "rgba(0,0,0,0.7)",
+      color: "#fff",
+      padding: "6px 10px",
+      borderRadius: 4,
+      fontSize: 12,
+      zIndex: 10,
+      fontFamily: "monospace"
+    }, children: [
+      pointCount.toLocaleString(),
+      " points | color: ",
+      colorBy,
+      "| [",
+      pointVmin.toFixed(1),
+      ", ",
+      pointVmax.toFixed(1),
+      "]",
+      state.clickedPoints.length > 0 && ` | ${state.clickedPoints.length} selected`,
+      state.referencePointId != null && ` | ref: ${state.referencePointId}`,
+      state.clickedPoints.length === 0 && " | click: TS, shift: compare, ctrl: ref"
+    ] })
+  ] });
+}
+var reactPlotly = {};
+var factory = {};
+var propTypes = { exports: {} };
+var ReactPropTypesSecret$1 = "SECRET_DO_NOT_PASS_THIS_OR_YOU_WILL_BE_FIRED";
+var ReactPropTypesSecret_1 = ReactPropTypesSecret$1;
+var ReactPropTypesSecret = ReactPropTypesSecret_1;
+function emptyFunction() {
+}
+function emptyFunctionWithReset() {
+}
+emptyFunctionWithReset.resetWarningCache = emptyFunction;
+var factoryWithThrowingShims = function() {
+  function shim(props, propName, componentName, location2, propFullName, secret) {
+    if (secret === ReactPropTypesSecret) {
+      return;
+    }
+    var err = new Error(
+      "Calling PropTypes validators directly is not supported by the `prop-types` package. Use PropTypes.checkPropTypes() to call them. Read more at http://fb.me/use-check-prop-types"
+    );
+    err.name = "Invariant Violation";
+    throw err;
+  }
+  shim.isRequired = shim;
+  function getShim() {
+    return shim;
+  }
+  var ReactPropTypes = {
+    array: shim,
+    bigint: shim,
+    bool: shim,
+    func: shim,
+    number: shim,
+    object: shim,
+    string: shim,
+    symbol: shim,
+    any: shim,
+    arrayOf: getShim,
+    element: shim,
+    elementType: shim,
+    instanceOf: getShim,
+    node: shim,
+    objectOf: getShim,
+    oneOf: getShim,
+    oneOfType: getShim,
+    shape: getShim,
+    exact: getShim,
+    checkPropTypes: emptyFunctionWithReset,
+    resetWarningCache: emptyFunction
+  };
+  ReactPropTypes.PropTypes = ReactPropTypes;
+  return ReactPropTypes;
+};
+{
+  propTypes.exports = factoryWithThrowingShims();
+}
+var propTypesExports = propTypes.exports;
+(function(exports) {
+  function _typeof(obj) {
+    "@babel/helpers - typeof";
+    return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function(obj2) {
+      return typeof obj2;
+    } : function(obj2) {
+      return obj2 && "function" == typeof Symbol && obj2.constructor === Symbol && obj2 !== Symbol.prototype ? "symbol" : typeof obj2;
+    }, _typeof(obj);
+  }
+  Object.defineProperty(exports, "__esModule", {
+    value: true
+  });
+  exports["default"] = plotComponentFactory;
+  var _react = _interopRequireWildcard(reactExports);
+  var _propTypes = _interopRequireDefault(propTypesExports);
+  function _interopRequireDefault(obj) {
+    return obj && obj.__esModule ? obj : { "default": obj };
+  }
+  function _getRequireWildcardCache(nodeInterop) {
+    if (typeof WeakMap !== "function") return null;
+    var cacheBabelInterop = /* @__PURE__ */ new WeakMap();
+    var cacheNodeInterop = /* @__PURE__ */ new WeakMap();
+    return (_getRequireWildcardCache = function _getRequireWildcardCache2(nodeInterop2) {
+      return nodeInterop2 ? cacheNodeInterop : cacheBabelInterop;
+    })(nodeInterop);
+  }
+  function _interopRequireWildcard(obj, nodeInterop) {
+    if (obj && obj.__esModule) {
+      return obj;
+    }
+    if (obj === null || _typeof(obj) !== "object" && typeof obj !== "function") {
+      return { "default": obj };
+    }
+    var cache = _getRequireWildcardCache(nodeInterop);
+    if (cache && cache.has(obj)) {
+      return cache.get(obj);
+    }
+    var newObj = {};
+    var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor;
+    for (var key in obj) {
+      if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) {
+        var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null;
+        if (desc && (desc.get || desc.set)) {
+          Object.defineProperty(newObj, key, desc);
+        } else {
+          newObj[key] = obj[key];
+        }
+      }
+    }
+    newObj["default"] = obj;
+    if (cache) {
+      cache.set(obj, newObj);
+    }
+    return newObj;
+  }
+  function _classCallCheck(instance2, Constructor) {
+    if (!(instance2 instanceof Constructor)) {
+      throw new TypeError("Cannot call a class as a function");
+    }
+  }
+  function _defineProperties(target, props) {
+    for (var i2 = 0; i2 < props.length; i2++) {
+      var descriptor = props[i2];
+      descriptor.enumerable = descriptor.enumerable || false;
+      descriptor.configurable = true;
+      if ("value" in descriptor) descriptor.writable = true;
+      Object.defineProperty(target, descriptor.key, descriptor);
+    }
+  }
+  function _createClass(Constructor, protoProps, staticProps) {
+    if (protoProps) _defineProperties(Constructor.prototype, protoProps);
+    Object.defineProperty(Constructor, "prototype", { writable: false });
+    return Constructor;
+  }
+  function _inherits(subClass, superClass) {
+    if (typeof superClass !== "function" && superClass !== null) {
+      throw new TypeError("Super expression must either be null or a function");
+    }
+    subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, writable: true, configurable: true } });
+    Object.defineProperty(subClass, "prototype", { writable: false });
+    if (superClass) _setPrototypeOf(subClass, superClass);
+  }
+  function _setPrototypeOf(o2, p2) {
+    _setPrototypeOf = Object.setPrototypeOf ? Object.setPrototypeOf.bind() : function _setPrototypeOf2(o3, p3) {
+      o3.__proto__ = p3;
+      return o3;
+    };
+    return _setPrototypeOf(o2, p2);
+  }
+  function _createSuper(Derived) {
+    var hasNativeReflectConstruct = _isNativeReflectConstruct();
+    return function _createSuperInternal() {
+      var Super = _getPrototypeOf(Derived), result;
+      if (hasNativeReflectConstruct) {
+        var NewTarget = _getPrototypeOf(this).constructor;
+        result = Reflect.construct(Super, arguments, NewTarget);
+      } else {
+        result = Super.apply(this, arguments);
+      }
+      return _possibleConstructorReturn(this, result);
+    };
+  }
+  function _possibleConstructorReturn(self2, call) {
+    if (call && (_typeof(call) === "object" || typeof call === "function")) {
+      return call;
+    } else if (call !== void 0) {
+      throw new TypeError("Derived constructors may only return object or undefined");
+    }
+    return _assertThisInitialized(self2);
+  }
+  function _assertThisInitialized(self2) {
+    if (self2 === void 0) {
+      throw new ReferenceError("this hasn't been initialised - super() hasn't been called");
+    }
+    return self2;
+  }
+  function _isNativeReflectConstruct() {
+    if (typeof Reflect === "undefined" || !Reflect.construct) return false;
+    if (Reflect.construct.sham) return false;
+    if (typeof Proxy === "function") return true;
+    try {
+      Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function() {
+      }));
+      return true;
+    } catch (e2) {
+      return false;
+    }
+  }
+  function _getPrototypeOf(o2) {
+    _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf.bind() : function _getPrototypeOf2(o3) {
+      return o3.__proto__ || Object.getPrototypeOf(o3);
+    };
+    return _getPrototypeOf(o2);
+  }
+  var eventNames = ["AfterExport", "AfterPlot", "Animated", "AnimatingFrame", "AnimationInterrupted", "AutoSize", "BeforeExport", "BeforeHover", "ButtonClicked", "Click", "ClickAnnotation", "Deselect", "DoubleClick", "Framework", "Hover", "LegendClick", "LegendDoubleClick", "Relayout", "Relayouting", "Restyle", "Redraw", "Selected", "Selecting", "SliderChange", "SliderEnd", "SliderStart", "SunburstClick", "Transitioning", "TransitionInterrupted", "Unhover", "WebGlContextLost"];
+  var updateEvents = ["plotly_restyle", "plotly_redraw", "plotly_relayout", "plotly_relayouting", "plotly_doubleclick", "plotly_animated", "plotly_sunburstclick"];
+  var isBrowser2 = typeof window !== "undefined";
+  function plotComponentFactory(Plotly) {
+    var PlotlyComponent = /* @__PURE__ */ function(_Component) {
+      _inherits(PlotlyComponent2, _Component);
+      var _super = _createSuper(PlotlyComponent2);
+      function PlotlyComponent2(props) {
+        var _this;
+        _classCallCheck(this, PlotlyComponent2);
+        _this = _super.call(this, props);
+        _this.p = Promise.resolve();
+        _this.resizeHandler = null;
+        _this.handlers = {};
+        _this.syncWindowResize = _this.syncWindowResize.bind(_assertThisInitialized(_this));
+        _this.syncEventHandlers = _this.syncEventHandlers.bind(_assertThisInitialized(_this));
+        _this.attachUpdateEvents = _this.attachUpdateEvents.bind(_assertThisInitialized(_this));
+        _this.getRef = _this.getRef.bind(_assertThisInitialized(_this));
+        _this.handleUpdate = _this.handleUpdate.bind(_assertThisInitialized(_this));
+        _this.figureCallback = _this.figureCallback.bind(_assertThisInitialized(_this));
+        _this.updatePlotly = _this.updatePlotly.bind(_assertThisInitialized(_this));
+        return _this;
+      }
+      _createClass(PlotlyComponent2, [{
+        key: "updatePlotly",
+        value: function updatePlotly(shouldInvokeResizeHandler, figureCallbackFunction, shouldAttachUpdateEvents) {
+          var _this2 = this;
+          this.p = this.p.then(function() {
+            if (_this2.unmounting) {
+              return;
+            }
+            if (!_this2.el) {
+              throw new Error("Missing element reference");
+            }
+            return Plotly.react(_this2.el, {
+              data: _this2.props.data,
+              layout: _this2.props.layout,
+              config: _this2.props.config,
+              frames: _this2.props.frames
+            });
+          }).then(function() {
+            if (_this2.unmounting) {
+              return;
+            }
+            _this2.syncWindowResize(shouldInvokeResizeHandler);
+            _this2.syncEventHandlers();
+            _this2.figureCallback(figureCallbackFunction);
+            if (shouldAttachUpdateEvents) {
+              _this2.attachUpdateEvents();
+            }
+          })["catch"](function(err) {
+            if (_this2.props.onError) {
+              _this2.props.onError(err);
+            }
+          });
+        }
+      }, {
+        key: "componentDidMount",
+        value: function componentDidMount() {
+          this.unmounting = false;
+          this.updatePlotly(true, this.props.onInitialized, true);
+        }
+      }, {
+        key: "componentDidUpdate",
+        value: function componentDidUpdate(prevProps) {
+          this.unmounting = false;
+          var numPrevFrames = prevProps.frames && prevProps.frames.length ? prevProps.frames.length : 0;
+          var numNextFrames = this.props.frames && this.props.frames.length ? this.props.frames.length : 0;
+          var figureChanged = !(prevProps.layout === this.props.layout && prevProps.data === this.props.data && prevProps.config === this.props.config && numNextFrames === numPrevFrames);
+          var revisionDefined = prevProps.revision !== void 0;
+          var revisionChanged = prevProps.revision !== this.props.revision;
+          if (!figureChanged && (!revisionDefined || revisionDefined && !revisionChanged)) {
+            return;
+          }
+          this.updatePlotly(false, this.props.onUpdate, false);
+        }
+      }, {
+        key: "componentWillUnmount",
+        value: function componentWillUnmount() {
+          this.unmounting = true;
+          this.figureCallback(this.props.onPurge);
+          if (this.resizeHandler && isBrowser2) {
+            window.removeEventListener("resize", this.resizeHandler);
+            this.resizeHandler = null;
+          }
+          this.removeUpdateEvents();
+          Plotly.purge(this.el);
+        }
+      }, {
+        key: "attachUpdateEvents",
+        value: function attachUpdateEvents() {
+          var _this3 = this;
+          if (!this.el || !this.el.removeListener) {
+            return;
+          }
+          updateEvents.forEach(function(updateEvent) {
+            _this3.el.on(updateEvent, _this3.handleUpdate);
+          });
+        }
+      }, {
+        key: "removeUpdateEvents",
+        value: function removeUpdateEvents() {
+          var _this4 = this;
+          if (!this.el || !this.el.removeListener) {
+            return;
+          }
+          updateEvents.forEach(function(updateEvent) {
+            _this4.el.removeListener(updateEvent, _this4.handleUpdate);
+          });
+        }
+      }, {
+        key: "handleUpdate",
+        value: function handleUpdate() {
+          this.figureCallback(this.props.onUpdate);
+        }
+      }, {
+        key: "figureCallback",
+        value: function figureCallback(callback) {
+          if (typeof callback === "function") {
+            var _this$el = this.el, data = _this$el.data, layout = _this$el.layout;
+            var frames = this.el._transitionData ? this.el._transitionData._frames : null;
+            var figure = {
+              data,
+              layout,
+              frames
+            };
+            callback(figure, this.el);
+          }
+        }
+      }, {
+        key: "syncWindowResize",
+        value: function syncWindowResize(invoke) {
+          var _this5 = this;
+          if (!isBrowser2) {
+            return;
+          }
+          if (this.props.useResizeHandler && !this.resizeHandler) {
+            this.resizeHandler = function() {
+              return Plotly.Plots.resize(_this5.el);
+            };
+            window.addEventListener("resize", this.resizeHandler);
+            if (invoke) {
+              this.resizeHandler();
+            }
+          } else if (!this.props.useResizeHandler && this.resizeHandler) {
+            window.removeEventListener("resize", this.resizeHandler);
+            this.resizeHandler = null;
+          }
+        }
+      }, {
+        key: "getRef",
+        value: function getRef(el2) {
+          this.el = el2;
+          if (this.props.debug && isBrowser2) {
+            window.gd = this.el;
+          }
+        }
+        // Attach and remove event handlers as they're added or removed from props:
+      }, {
+        key: "syncEventHandlers",
+        value: function syncEventHandlers() {
+          var _this6 = this;
+          eventNames.forEach(function(eventName) {
+            var prop = _this6.props["on" + eventName];
+            var handler = _this6.handlers[eventName];
+            var hasHandler = Boolean(handler);
+            if (prop && !hasHandler) {
+              _this6.addEventHandler(eventName, prop);
+            } else if (!prop && hasHandler) {
+              _this6.removeEventHandler(eventName);
+            } else if (prop && hasHandler && prop !== handler) {
+              _this6.removeEventHandler(eventName);
+              _this6.addEventHandler(eventName, prop);
+            }
+          });
+        }
+      }, {
+        key: "addEventHandler",
+        value: function addEventHandler(eventName, prop) {
+          this.handlers[eventName] = prop;
+          this.el.on(this.getPlotlyEventName(eventName), this.handlers[eventName]);
+        }
+      }, {
+        key: "removeEventHandler",
+        value: function removeEventHandler(eventName) {
+          this.el.removeListener(this.getPlotlyEventName(eventName), this.handlers[eventName]);
+          delete this.handlers[eventName];
+        }
+      }, {
+        key: "getPlotlyEventName",
+        value: function getPlotlyEventName(eventName) {
+          return "plotly_" + eventName.toLowerCase();
+        }
+      }, {
+        key: "render",
+        value: function render() {
+          return /* @__PURE__ */ _react["default"].createElement("div", {
+            id: this.props.divId,
+            style: this.props.style,
+            ref: this.getRef,
+            className: this.props.className
+          });
+        }
+      }]);
+      return PlotlyComponent2;
+    }(_react.Component);
+    PlotlyComponent.propTypes = {
+      data: _propTypes["default"].arrayOf(_propTypes["default"].object),
+      config: _propTypes["default"].object,
+      layout: _propTypes["default"].object,
+      frames: _propTypes["default"].arrayOf(_propTypes["default"].object),
+      revision: _propTypes["default"].number,
+      onInitialized: _propTypes["default"].func,
+      onPurge: _propTypes["default"].func,
+      onError: _propTypes["default"].func,
+      onUpdate: _propTypes["default"].func,
+      debug: _propTypes["default"].bool,
+      style: _propTypes["default"].object,
+      className: _propTypes["default"].string,
+      useResizeHandler: _propTypes["default"].bool,
+      divId: _propTypes["default"].string
+    };
+    eventNames.forEach(function(eventName) {
+      PlotlyComponent.propTypes["on" + eventName] = _propTypes["default"].func;
+    });
+    PlotlyComponent.defaultProps = {
+      debug: false,
+      useResizeHandler: false,
+      data: [],
+      style: {
+        position: "relative",
+        display: "inline-block"
+      }
+    };
+    return PlotlyComponent;
+  }
+})(factory);
+var plotly = { exports: {} };
+(function(module) {
+  var define_process_env_default = {};
+  (function(root, factory2) {
+    if (module.exports) {
+      module.exports = factory2();
+    } else {
+      root.moduleName = factory2();
+    }
+  })(typeof self !== "undefined" ? self : commonjsGlobal, () => {
+    var Plotly = (() => {
+      var __create = Object.create;
+      var __defProp2 = Object.defineProperty;
+      var __defProps = Object.defineProperties;
+      var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+      var __getOwnPropDescs = Object.getOwnPropertyDescriptors;
+      var __getOwnPropNames = Object.getOwnPropertyNames;
+      var __getOwnPropSymbols = Object.getOwnPropertySymbols;
+      var __getProtoOf = Object.getPrototypeOf;
+      var __hasOwnProp = Object.prototype.hasOwnProperty;
+      var __propIsEnum = Object.prototype.propertyIsEnumerable;
+      var __defNormalProp2 = (obj, key, value) => key in obj ? __defProp2(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+      var __spreadValues = (a2, b2) => {
+        for (var prop in b2 || (b2 = {}))
+          if (__hasOwnProp.call(b2, prop))
+            __defNormalProp2(a2, prop, b2[prop]);
+        if (__getOwnPropSymbols)
+          for (var prop of __getOwnPropSymbols(b2)) {
+            if (__propIsEnum.call(b2, prop))
+              __defNormalProp2(a2, prop, b2[prop]);
+          }
+        return a2;
+      };
+      var __spreadProps = (a2, b2) => __defProps(a2, __getOwnPropDescs(b2));
+      var __objRest = (source2, exclude) => {
+        var target = {};
+        for (var prop in source2)
+          if (__hasOwnProp.call(source2, prop) && exclude.indexOf(prop) < 0)
+            target[prop] = source2[prop];
+        if (source2 != null && __getOwnPropSymbols)
+          for (var prop of __getOwnPropSymbols(source2)) {
+            if (exclude.indexOf(prop) < 0 && __propIsEnum.call(source2, prop))
+              target[prop] = source2[prop];
+          }
+        return target;
+      };
+      var __esm = (fn, res) => function __init() {
+        return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+      };
+      var __commonJS = (cb2, mod2) => function __require() {
+        return mod2 || (0, cb2[__getOwnPropNames(cb2)[0]])((mod2 = { exports: {} }).exports, mod2), mod2.exports;
+      };
+      var __export = (target, all) => {
+        for (var name2 in all)
+          __defProp2(target, name2, { get: all[name2], enumerable: true });
+      };
+      var __copyProps = (to, from, except, desc) => {
+        if (from && typeof from === "object" || typeof from === "function") {
+          for (let key of __getOwnPropNames(from))
+            if (!__hasOwnProp.call(to, key) && key !== except)
+              __defProp2(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+        }
+        return to;
+      };
+      var __toESM = (mod2, isNodeMode, target) => (target = mod2 != null ? __create(__getProtoOf(mod2)) : {}, __copyProps(
+        // If the importer is in node compatibility mode or this is not an ESM
+        // file that has been converted to a CommonJS file using a Babel-
+        // compatible transform (i.e. "__esModule" has not been set), then set
+        // "default" to the CommonJS "module.exports" for node compatibility.
+        __defProp2(target, "default", { value: mod2, enumerable: true }),
+        mod2
+      ));
+      var __toCommonJS = (mod2) => __copyProps(__defProp2({}, "__esModule", { value: true }), mod2);
+      var require_version = __commonJS({
+        "src/version.js"(exports) {
+          exports.version = "3.4.0";
+        }
+      });
+      var require_npo_src = __commonJS({
+        "node_modules/native-promise-only/lib/npo.src.js"(exports, module2) {
+          (function UMD(name2, context, definition) {
+            context[name2] = context[name2] || definition();
+            if (typeof module2 != "undefined" && module2.exports) {
+              module2.exports = context[name2];
+            }
+          })("Promise", typeof window != "undefined" ? window : exports, function DEF() {
+            var builtInProp, cycle, scheduling_queue, ToString = Object.prototype.toString, timer = typeof setImmediate != "undefined" ? function timer2(fn) {
+              return setImmediate(fn);
+            } : setTimeout;
+            try {
+              Object.defineProperty({}, "x", {});
+              builtInProp = function builtInProp2(obj, name2, val, config2) {
+                return Object.defineProperty(obj, name2, {
+                  value: val,
+                  writable: true,
+                  configurable: config2 !== false
+                });
+              };
+            } catch (err) {
+              builtInProp = function builtInProp2(obj, name2, val) {
+                obj[name2] = val;
+                return obj;
+              };
+            }
+            scheduling_queue = /* @__PURE__ */ function Queue() {
+              var first, last, item;
+              function Item(fn, self2) {
+                this.fn = fn;
+                this.self = self2;
+                this.next = void 0;
+              }
+              return {
+                add: function add2(fn, self2) {
+                  item = new Item(fn, self2);
+                  if (last) {
+                    last.next = item;
+                  } else {
+                    first = item;
+                  }
+                  last = item;
+                  item = void 0;
+                },
+                drain: function drain() {
+                  var f2 = first;
+                  first = last = cycle = void 0;
+                  while (f2) {
+                    f2.fn.call(f2.self);
+                    f2 = f2.next;
+                  }
+                }
+              };
+            }();
+            function schedule(fn, self2) {
+              scheduling_queue.add(fn, self2);
+              if (!cycle) {
+                cycle = timer(scheduling_queue.drain);
+              }
+            }
+            function isThenable(o2) {
+              var _then, o_type = typeof o2;
+              if (o2 != null && (o_type == "object" || o_type == "function")) {
+                _then = o2.then;
+              }
+              return typeof _then == "function" ? _then : false;
+            }
+            function notify() {
+              for (var i2 = 0; i2 < this.chain.length; i2++) {
+                notifyIsolated(
+                  this,
+                  this.state === 1 ? this.chain[i2].success : this.chain[i2].failure,
+                  this.chain[i2]
+                );
+              }
+              this.chain.length = 0;
+            }
+            function notifyIsolated(self2, cb2, chain) {
+              var ret, _then;
+              try {
+                if (cb2 === false) {
+                  chain.reject(self2.msg);
+                } else {
+                  if (cb2 === true) {
+                    ret = self2.msg;
+                  } else {
+                    ret = cb2.call(void 0, self2.msg);
+                  }
+                  if (ret === chain.promise) {
+                    chain.reject(TypeError("Promise-chain cycle"));
+                  } else if (_then = isThenable(ret)) {
+                    _then.call(ret, chain.resolve, chain.reject);
+                  } else {
+                    chain.resolve(ret);
+                  }
+                }
+              } catch (err) {
+                chain.reject(err);
+              }
+            }
+            function resolve(msg) {
+              var _then, self2 = this;
+              if (self2.triggered) {
+                return;
+              }
+              self2.triggered = true;
+              if (self2.def) {
+                self2 = self2.def;
+              }
+              try {
+                if (_then = isThenable(msg)) {
+                  schedule(function() {
+                    var def_wrapper = new MakeDefWrapper(self2);
+                    try {
+                      _then.call(
+                        msg,
+                        function $resolve$() {
+                          resolve.apply(def_wrapper, arguments);
+                        },
+                        function $reject$() {
+                          reject.apply(def_wrapper, arguments);
+                        }
+                      );
+                    } catch (err) {
+                      reject.call(def_wrapper, err);
+                    }
+                  });
+                } else {
+                  self2.msg = msg;
+                  self2.state = 1;
+                  if (self2.chain.length > 0) {
+                    schedule(notify, self2);
+                  }
+                }
+              } catch (err) {
+                reject.call(new MakeDefWrapper(self2), err);
+              }
+            }
+            function reject(msg) {
+              var self2 = this;
+              if (self2.triggered) {
+                return;
+              }
+              self2.triggered = true;
+              if (self2.def) {
+                self2 = self2.def;
+              }
+              self2.msg = msg;
+              self2.state = 2;
+              if (self2.chain.length > 0) {
+                schedule(notify, self2);
+              }
+            }
+            function iteratePromises(Constructor, arr, resolver, rejecter) {
+              for (var idx = 0; idx < arr.length; idx++) {
+                (function IIFE(idx2) {
+                  Constructor.resolve(arr[idx2]).then(
+                    function $resolver$(msg) {
+                      resolver(idx2, msg);
+                    },
+                    rejecter
+                  );
+                })(idx);
+              }
+            }
+            function MakeDefWrapper(self2) {
+              this.def = self2;
+              this.triggered = false;
+            }
+            function MakeDef(self2) {
+              this.promise = self2;
+              this.state = 0;
+              this.triggered = false;
+              this.chain = [];
+              this.msg = void 0;
+            }
+            function Promise2(executor) {
+              if (typeof executor != "function") {
+                throw TypeError("Not a function");
+              }
+              if (this.__NPO__ !== 0) {
+                throw TypeError("Not a promise");
+              }
+              this.__NPO__ = 1;
+              var def = new MakeDef(this);
+              this["then"] = function then(success, failure) {
+                var o2 = {
+                  success: typeof success == "function" ? success : true,
+                  failure: typeof failure == "function" ? failure : false
+                };
+                o2.promise = new this.constructor(function extractChain(resolve2, reject2) {
+                  if (typeof resolve2 != "function" || typeof reject2 != "function") {
+                    throw TypeError("Not a function");
+                  }
+                  o2.resolve = resolve2;
+                  o2.reject = reject2;
+                });
+                def.chain.push(o2);
+                if (def.state !== 0) {
+                  schedule(notify, def);
+                }
+                return o2.promise;
+              };
+              this["catch"] = function $catch$(failure) {
+                return this.then(void 0, failure);
+              };
+              try {
+                executor.call(
+                  void 0,
+                  function publicResolve(msg) {
+                    resolve.call(def, msg);
+                  },
+                  function publicReject(msg) {
+                    reject.call(def, msg);
+                  }
+                );
+              } catch (err) {
+                reject.call(def, err);
+              }
+            }
+            var PromisePrototype = builtInProp(
+              {},
+              "constructor",
+              Promise2,
+              /*configurable=*/
+              false
+            );
+            Promise2.prototype = PromisePrototype;
+            builtInProp(
+              PromisePrototype,
+              "__NPO__",
+              0,
+              /*configurable=*/
+              false
+            );
+            builtInProp(Promise2, "resolve", function Promise$resolve(msg) {
+              var Constructor = this;
+              if (msg && typeof msg == "object" && msg.__NPO__ === 1) {
+                return msg;
+              }
+              return new Constructor(function executor(resolve2, reject2) {
+                if (typeof resolve2 != "function" || typeof reject2 != "function") {
+                  throw TypeError("Not a function");
+                }
+                resolve2(msg);
+              });
+            });
+            builtInProp(Promise2, "reject", function Promise$reject(msg) {
+              return new this(function executor(resolve2, reject2) {
+                if (typeof resolve2 != "function" || typeof reject2 != "function") {
+                  throw TypeError("Not a function");
+                }
+                reject2(msg);
+              });
+            });
+            builtInProp(Promise2, "all", function Promise$all(arr) {
+              var Constructor = this;
+              if (ToString.call(arr) != "[object Array]") {
+                return Constructor.reject(TypeError("Not an array"));
+              }
+              if (arr.length === 0) {
+                return Constructor.resolve([]);
+              }
+              return new Constructor(function executor(resolve2, reject2) {
+                if (typeof resolve2 != "function" || typeof reject2 != "function") {
+                  throw TypeError("Not a function");
+                }
+                var len2 = arr.length, msgs = Array(len2), count2 = 0;
+                iteratePromises(Constructor, arr, function resolver(idx, msg) {
+                  msgs[idx] = msg;
+                  if (++count2 === len2) {
+                    resolve2(msgs);
+                  }
+                }, reject2);
+              });
+            });
+            builtInProp(Promise2, "race", function Promise$race(arr) {
+              var Constructor = this;
+              if (ToString.call(arr) != "[object Array]") {
+                return Constructor.reject(TypeError("Not an array"));
+              }
+              return new Constructor(function executor(resolve2, reject2) {
+                if (typeof resolve2 != "function" || typeof reject2 != "function") {
+                  throw TypeError("Not a function");
+                }
+                iteratePromises(Constructor, arr, function resolver(idx, msg) {
+                  resolve2(msg);
+                }, reject2);
+              });
+            });
+            return Promise2;
+          });
+        }
+      });
+      var require_d3 = __commonJS({
+        "node_modules/@plotly/d3/d3.js"(exports, module2) {
+          !(function() {
+            var d3 = {
+              version: "3.8.2"
+            };
+            var d3_arraySlice = [].slice, d3_array = function(list) {
+              return d3_arraySlice.call(list);
+            };
+            var d3_document = self.document;
+            function d3_documentElement(node) {
+              return node && (node.ownerDocument || node.document || node).documentElement;
+            }
+            function d3_window(node) {
+              return node && (node.ownerDocument && node.ownerDocument.defaultView || node.document && node || node.defaultView);
+            }
+            if (d3_document) {
+              try {
+                d3_array(d3_document.documentElement.childNodes)[0].nodeType;
+              } catch (e2) {
+                d3_array = function(list) {
+                  var i2 = list.length, array = new Array(i2);
+                  while (i2--) array[i2] = list[i2];
+                  return array;
+                };
+              }
+            }
+            if (!Date.now) Date.now = function() {
+              return +/* @__PURE__ */ new Date();
+            };
+            if (d3_document) {
+              try {
+                d3_document.createElement("DIV").style.setProperty("opacity", 0, "");
+              } catch (error) {
+                var d3_element_prototype = this.Element.prototype, d3_element_setAttribute = d3_element_prototype.setAttribute, d3_element_setAttributeNS = d3_element_prototype.setAttributeNS, d3_style_prototype = this.CSSStyleDeclaration.prototype, d3_style_setProperty = d3_style_prototype.setProperty;
+                d3_element_prototype.setAttribute = function(name2, value) {
+                  d3_element_setAttribute.call(this, name2, value + "");
+                };
+                d3_element_prototype.setAttributeNS = function(space, local, value) {
+                  d3_element_setAttributeNS.call(this, space, local, value + "");
+                };
+                d3_style_prototype.setProperty = function(name2, value, priority) {
+                  d3_style_setProperty.call(this, name2, value + "", priority);
+                };
+              }
+            }
+            d3.ascending = d3_ascending;
+            function d3_ascending(a2, b2) {
+              return a2 < b2 ? -1 : a2 > b2 ? 1 : a2 >= b2 ? 0 : NaN;
+            }
+            d3.descending = function(a2, b2) {
+              return b2 < a2 ? -1 : b2 > a2 ? 1 : b2 >= a2 ? 0 : NaN;
+            };
+            d3.min = function(array, f2) {
+              var i2 = -1, n2 = array.length, a2, b2;
+              if (arguments.length === 1) {
+                while (++i2 < n2) if ((b2 = array[i2]) != null && b2 >= b2) {
+                  a2 = b2;
+                  break;
+                }
+                while (++i2 < n2) if ((b2 = array[i2]) != null && a2 > b2) a2 = b2;
+              } else {
+                while (++i2 < n2) if ((b2 = f2.call(array, array[i2], i2)) != null && b2 >= b2) {
+                  a2 = b2;
+                  break;
+                }
+                while (++i2 < n2) if ((b2 = f2.call(array, array[i2], i2)) != null && a2 > b2) a2 = b2;
+              }
+              return a2;
+            };
+            d3.max = function(array, f2) {
+              var i2 = -1, n2 = array.length, a2, b2;
+              if (arguments.length === 1) {
+                while (++i2 < n2) if ((b2 = array[i2]) != null && b2 >= b2) {
+                  a2 = b2;
+                  break;
+                }
+                while (++i2 < n2) if ((b2 = array[i2]) != null && b2 > a2) a2 = b2;
+              } else {
+                while (++i2 < n2) if ((b2 = f2.call(array, array[i2], i2)) != null && b2 >= b2) {
+                  a2 = b2;
+                  break;
+                }
+                while (++i2 < n2) if ((b2 = f2.call(array, array[i2], i2)) != null && b2 > a2) a2 = b2;
+              }
+              return a2;
+            };
+            d3.extent = function(array, f2) {
+              var i2 = -1, n2 = array.length, a2, b2, c2;
+              if (arguments.length === 1) {
+                while (++i2 < n2) if ((b2 = array[i2]) != null && b2 >= b2) {
+                  a2 = c2 = b2;
+                  break;
+                }
+                while (++i2 < n2) if ((b2 = array[i2]) != null) {
+                  if (a2 > b2) a2 = b2;
+                  if (c2 < b2) c2 = b2;
+                }
+              } else {
+                while (++i2 < n2) if ((b2 = f2.call(array, array[i2], i2)) != null && b2 >= b2) {
+                  a2 = c2 = b2;
+                  break;
+                }
+                while (++i2 < n2) if ((b2 = f2.call(array, array[i2], i2)) != null) {
+                  if (a2 > b2) a2 = b2;
+                  if (c2 < b2) c2 = b2;
+                }
+              }
+              return [a2, c2];
+            };
+            function d3_number(x2) {
+              return x2 === null ? NaN : +x2;
+            }
+            function d3_numeric(x2) {
+              return !isNaN(x2);
+            }
+            d3.sum = function(array, f2) {
+              var s2 = 0, n2 = array.length, a2, i2 = -1;
+              if (arguments.length === 1) {
+                while (++i2 < n2) if (d3_numeric(a2 = +array[i2])) s2 += a2;
+              } else {
+                while (++i2 < n2) if (d3_numeric(a2 = +f2.call(array, array[i2], i2))) s2 += a2;
+              }
+              return s2;
+            };
+            d3.mean = function(array, f2) {
+              var s2 = 0, n2 = array.length, a2, i2 = -1, j2 = n2;
+              if (arguments.length === 1) {
+                while (++i2 < n2) if (d3_numeric(a2 = d3_number(array[i2]))) s2 += a2;
+                else --j2;
+              } else {
+                while (++i2 < n2) if (d3_numeric(a2 = d3_number(f2.call(array, array[i2], i2)))) s2 += a2;
+                else --j2;
+              }
+              if (j2) return s2 / j2;
+            };
+            d3.quantile = function(values, p2) {
+              var H2 = (values.length - 1) * p2 + 1, h2 = Math.floor(H2), v2 = +values[h2 - 1], e2 = H2 - h2;
+              return e2 ? v2 + e2 * (values[h2] - v2) : v2;
+            };
+            d3.median = function(array, f2) {
+              var numbers = [], n2 = array.length, a2, i2 = -1;
+              if (arguments.length === 1) {
+                while (++i2 < n2) if (d3_numeric(a2 = d3_number(array[i2]))) numbers.push(a2);
+              } else {
+                while (++i2 < n2) if (d3_numeric(a2 = d3_number(f2.call(array, array[i2], i2)))) numbers.push(a2);
+              }
+              if (numbers.length) return d3.quantile(numbers.sort(d3_ascending), 0.5);
+            };
+            d3.variance = function(array, f2) {
+              var n2 = array.length, m2 = 0, a2, d2, s2 = 0, i2 = -1, j2 = 0;
+              if (arguments.length === 1) {
+                while (++i2 < n2) {
+                  if (d3_numeric(a2 = d3_number(array[i2]))) {
+                    d2 = a2 - m2;
+                    m2 += d2 / ++j2;
+                    s2 += d2 * (a2 - m2);
+                  }
+                }
+              } else {
+                while (++i2 < n2) {
+                  if (d3_numeric(a2 = d3_number(f2.call(array, array[i2], i2)))) {
+                    d2 = a2 - m2;
+                    m2 += d2 / ++j2;
+                    s2 += d2 * (a2 - m2);
+                  }
+                }
+              }
+              if (j2 > 1) return s2 / (j2 - 1);
+            };
+            d3.deviation = function() {
+              var v2 = d3.variance.apply(this, arguments);
+              return v2 ? Math.sqrt(v2) : v2;
+            };
+            function d3_bisector(compare) {
+              return {
+                left: function(a2, x2, lo, hi2) {
+                  if (arguments.length < 3) lo = 0;
+                  if (arguments.length < 4) hi2 = a2.length;
+                  while (lo < hi2) {
+                    var mid = lo + hi2 >>> 1;
+                    if (compare(a2[mid], x2) < 0) lo = mid + 1;
+                    else hi2 = mid;
+                  }
+                  return lo;
+                },
+                right: function(a2, x2, lo, hi2) {
+                  if (arguments.length < 3) lo = 0;
+                  if (arguments.length < 4) hi2 = a2.length;
+                  while (lo < hi2) {
+                    var mid = lo + hi2 >>> 1;
+                    if (compare(a2[mid], x2) > 0) hi2 = mid;
+                    else lo = mid + 1;
+                  }
+                  return lo;
+                }
+              };
+            }
+            var d3_bisect = d3_bisector(d3_ascending);
+            d3.bisectLeft = d3_bisect.left;
+            d3.bisect = d3.bisectRight = d3_bisect.right;
+            d3.bisector = function(f2) {
+              return d3_bisector(f2.length === 1 ? function(d2, x2) {
+                return d3_ascending(f2(d2), x2);
+              } : f2);
+            };
+            d3.shuffle = function(array, i0, i1) {
+              if ((m2 = arguments.length) < 3) {
+                i1 = array.length;
+                if (m2 < 2) i0 = 0;
+              }
+              var m2 = i1 - i0, t4, i2;
+              while (m2) {
+                i2 = Math.random() * m2-- | 0;
+                t4 = array[m2 + i0], array[m2 + i0] = array[i2 + i0], array[i2 + i0] = t4;
+              }
+              return array;
+            };
+            d3.permute = function(array, indexes) {
+              var i2 = indexes.length, permutes = new Array(i2);
+              while (i2--) permutes[i2] = array[indexes[i2]];
+              return permutes;
+            };
+            d3.pairs = function(array) {
+              var i2 = 0, n2 = array.length - 1, p1 = array[0], pairs = new Array(n2 < 0 ? 0 : n2);
+              while (i2 < n2) pairs[i2] = [p1, p1 = array[++i2]];
+              return pairs;
+            };
+            d3.transpose = function(matrix) {
+              if (!(n2 = matrix.length)) return [];
+              for (var i2 = -1, m2 = d3.min(matrix, d3_transposeLength), transpose2 = new Array(m2); ++i2 < m2; ) {
+                for (var j2 = -1, n2, row = transpose2[i2] = new Array(n2); ++j2 < n2; ) {
+                  row[j2] = matrix[j2][i2];
+                }
+              }
+              return transpose2;
+            };
+            function d3_transposeLength(d2) {
+              return d2.length;
+            }
+            d3.zip = function() {
+              return d3.transpose(arguments);
+            };
+            d3.keys = function(map2) {
+              var keys = [];
+              for (var key in map2) keys.push(key);
+              return keys;
+            };
+            d3.values = function(map2) {
+              var values = [];
+              for (var key in map2) values.push(map2[key]);
+              return values;
+            };
+            d3.entries = function(map2) {
+              var entries = [];
+              for (var key in map2) entries.push({
+                key,
+                value: map2[key]
+              });
+              return entries;
+            };
+            d3.merge = function(arrays) {
+              var n2 = arrays.length, m2, i2 = -1, j2 = 0, merged, array;
+              while (++i2 < n2) j2 += arrays[i2].length;
+              merged = new Array(j2);
+              while (--n2 >= 0) {
+                array = arrays[n2];
+                m2 = array.length;
+                while (--m2 >= 0) {
+                  merged[--j2] = array[m2];
+                }
+              }
+              return merged;
+            };
+            var abs = Math.abs;
+            d3.range = function(start, stop, step) {
+              if (arguments.length < 3) {
+                step = 1;
+                if (arguments.length < 2) {
+                  stop = start;
+                  start = 0;
+                }
+              }
+              if ((stop - start) / step === Infinity) throw new Error("infinite range");
+              var range = [], k2 = d3_range_integerScale(abs(step)), i2 = -1, j2;
+              start *= k2, stop *= k2, step *= k2;
+              if (step < 0) while ((j2 = start + step * ++i2) > stop) range.push(j2 / k2);
+              else while ((j2 = start + step * ++i2) < stop) range.push(j2 / k2);
+              return range;
+            };
+            function d3_range_integerScale(x2) {
+              var k2 = 1;
+              while (x2 * k2 % 1) k2 *= 10;
+              return k2;
+            }
+            function d3_class(ctor, properties) {
+              for (var key in properties) {
+                Object.defineProperty(ctor.prototype, key, {
+                  value: properties[key],
+                  enumerable: false
+                });
+              }
+            }
+            d3.map = function(object, f2) {
+              var map2 = new d3_Map();
+              if (object instanceof d3_Map) {
+                object.forEach(function(key2, value) {
+                  map2.set(key2, value);
+                });
+              } else if (Array.isArray(object)) {
+                var i2 = -1, n2 = object.length, o2;
+                if (arguments.length === 1) while (++i2 < n2) map2.set(i2, object[i2]);
+                else while (++i2 < n2) map2.set(f2.call(object, o2 = object[i2], i2), o2);
+              } else {
+                for (var key in object) map2.set(key, object[key]);
+              }
+              return map2;
+            };
+            function d3_Map() {
+              this._ = /* @__PURE__ */ Object.create(null);
+            }
+            var d3_map_proto = "__proto__", d3_map_zero = "\0";
+            d3_class(d3_Map, {
+              has: d3_map_has,
+              get: function(key) {
+                return this._[d3_map_escape(key)];
+              },
+              set: function(key, value) {
+                return this._[d3_map_escape(key)] = value;
+              },
+              remove: d3_map_remove,
+              keys: d3_map_keys,
+              values: function() {
+                var values = [];
+                for (var key in this._) values.push(this._[key]);
+                return values;
+              },
+              entries: function() {
+                var entries = [];
+                for (var key in this._) entries.push({
+                  key: d3_map_unescape(key),
+                  value: this._[key]
+                });
+                return entries;
+              },
+              size: d3_map_size,
+              empty: d3_map_empty,
+              forEach: function(f2) {
+                for (var key in this._) f2.call(this, d3_map_unescape(key), this._[key]);
+              }
+            });
+            function d3_map_escape(key) {
+              return (key += "") === d3_map_proto || key[0] === d3_map_zero ? d3_map_zero + key : key;
+            }
+            function d3_map_unescape(key) {
+              return (key += "")[0] === d3_map_zero ? key.slice(1) : key;
+            }
+            function d3_map_has(key) {
+              return d3_map_escape(key) in this._;
+            }
+            function d3_map_remove(key) {
+              return (key = d3_map_escape(key)) in this._ && delete this._[key];
+            }
+            function d3_map_keys() {
+              var keys = [];
+              for (var key in this._) keys.push(d3_map_unescape(key));
+              return keys;
+            }
+            function d3_map_size() {
+              var size = 0;
+              for (var key in this._) ++size;
+              return size;
+            }
+            function d3_map_empty() {
+              for (var key in this._) return false;
+              return true;
+            }
+            d3.nest = function() {
+              var nest = {}, keys = [], sortKeys = [], sortValues, rollup;
+              function map2(mapType, array, depth) {
+                if (depth >= keys.length) return rollup ? rollup.call(nest, array) : sortValues ? array.sort(sortValues) : array;
+                var i2 = -1, n2 = array.length, key = keys[depth++], keyValue, object, setter, valuesByKey = new d3_Map(), values;
+                while (++i2 < n2) {
+                  if (values = valuesByKey.get(keyValue = key(object = array[i2]))) {
+                    values.push(object);
+                  } else {
+                    valuesByKey.set(keyValue, [object]);
+                  }
+                }
+                if (mapType) {
+                  object = mapType();
+                  setter = function(keyValue2, values2) {
+                    object.set(keyValue2, map2(mapType, values2, depth));
+                  };
+                } else {
+                  object = {};
+                  setter = function(keyValue2, values2) {
+                    object[keyValue2] = map2(mapType, values2, depth);
+                  };
+                }
+                valuesByKey.forEach(setter);
+                return object;
+              }
+              function entries(map22, depth) {
+                if (depth >= keys.length) return map22;
+                var array = [], sortKey = sortKeys[depth++];
+                map22.forEach(function(key, keyMap) {
+                  array.push({
+                    key,
+                    values: entries(keyMap, depth)
+                  });
+                });
+                return sortKey ? array.sort(function(a2, b2) {
+                  return sortKey(a2.key, b2.key);
+                }) : array;
+              }
+              nest.map = function(array, mapType) {
+                return map2(mapType, array, 0);
+              };
+              nest.entries = function(array) {
+                return entries(map2(d3.map, array, 0), 0);
+              };
+              nest.key = function(d2) {
+                keys.push(d2);
+                return nest;
+              };
+              nest.sortKeys = function(order) {
+                sortKeys[keys.length - 1] = order;
+                return nest;
+              };
+              nest.sortValues = function(order) {
+                sortValues = order;
+                return nest;
+              };
+              nest.rollup = function(f2) {
+                rollup = f2;
+                return nest;
+              };
+              return nest;
+            };
+            d3.set = function(array) {
+              var set = new d3_Set();
+              if (array) for (var i2 = 0, n2 = array.length; i2 < n2; ++i2) set.add(array[i2]);
+              return set;
+            };
+            function d3_Set() {
+              this._ = /* @__PURE__ */ Object.create(null);
+            }
+            d3_class(d3_Set, {
+              has: d3_map_has,
+              add: function(key) {
+                this._[d3_map_escape(key += "")] = true;
+                return key;
+              },
+              remove: d3_map_remove,
+              values: d3_map_keys,
+              size: d3_map_size,
+              empty: d3_map_empty,
+              forEach: function(f2) {
+                for (var key in this._) f2.call(this, d3_map_unescape(key));
+              }
+            });
+            d3.behavior = {};
+            function d3_identity(d2) {
+              return d2;
+            }
+            d3.rebind = function(target, source2) {
+              var i2 = 1, n2 = arguments.length, method;
+              while (++i2 < n2) target[method = arguments[i2]] = d3_rebind(target, source2, source2[method]);
+              return target;
+            };
+            function d3_rebind(target, source2, method) {
+              return function() {
+                var value = method.apply(source2, arguments);
+                return value === source2 ? target : value;
+              };
+            }
+            function d3_vendorSymbol(object, name2) {
+              if (name2 in object) return name2;
+              name2 = name2.charAt(0).toUpperCase() + name2.slice(1);
+              for (var i2 = 0, n2 = d3_vendorPrefixes.length; i2 < n2; ++i2) {
+                var prefixName = d3_vendorPrefixes[i2] + name2;
+                if (prefixName in object) return prefixName;
+              }
+            }
+            var d3_vendorPrefixes = ["webkit", "ms", "moz", "Moz", "o", "O"];
+            function d3_noop() {
+            }
+            d3.dispatch = function() {
+              var dispatch = new d3_dispatch(), i2 = -1, n2 = arguments.length;
+              while (++i2 < n2) dispatch[arguments[i2]] = d3_dispatch_event(dispatch);
+              return dispatch;
+            };
+            function d3_dispatch() {
+            }
+            d3_dispatch.prototype.on = function(type, listener) {
+              var i2 = type.indexOf("."), name2 = "";
+              if (i2 >= 0) {
+                name2 = type.slice(i2 + 1);
+                type = type.slice(0, i2);
+              }
+              if (type) return arguments.length < 2 ? this[type].on(name2) : this[type].on(name2, listener);
+              if (arguments.length === 2) {
+                if (listener == null) for (type in this) {
+                  if (this.hasOwnProperty(type)) this[type].on(name2, null);
+                }
+                return this;
+              }
+            };
+            function d3_dispatch_event(dispatch) {
+              var listeners = [], listenerByName = new d3_Map();
+              function event() {
+                var z2 = listeners, i2 = -1, n2 = z2.length, l2;
+                while (++i2 < n2) if (l2 = z2[i2].on) l2.apply(this, arguments);
+                return dispatch;
+              }
+              event.on = function(name2, listener) {
+                var l2 = listenerByName.get(name2), i2;
+                if (arguments.length < 2) return l2 && l2.on;
+                if (l2) {
+                  l2.on = null;
+                  listeners = listeners.slice(0, i2 = listeners.indexOf(l2)).concat(listeners.slice(i2 + 1));
+                  listenerByName.remove(name2);
+                }
+                if (listener) listeners.push(listenerByName.set(name2, {
+                  on: listener
+                }));
+                return dispatch;
+              };
+              return event;
+            }
+            d3.event = null;
+            function d3_eventPreventDefault() {
+              d3.event.preventDefault();
+            }
+            function d3_eventSource() {
+              var e2 = d3.event, s2;
+              while (s2 = e2.sourceEvent) e2 = s2;
+              return e2;
+            }
+            function d3_eventDispatch(target) {
+              var dispatch = new d3_dispatch(), i2 = 0, n2 = arguments.length;
+              while (++i2 < n2) dispatch[arguments[i2]] = d3_dispatch_event(dispatch);
+              dispatch.of = function(thiz, argumentz) {
+                return function(e1) {
+                  try {
+                    var e0 = e1.sourceEvent = d3.event;
+                    e1.target = target;
+                    d3.event = e1;
+                    dispatch[e1.type].apply(thiz, argumentz);
+                  } finally {
+                    d3.event = e0;
+                  }
+                };
+              };
+              return dispatch;
+            }
+            d3.requote = function(s2) {
+              return s2.replace(d3_requote_re, "\\$&");
+            };
+            var d3_requote_re = /[\\\^\$\*\+\?\|\[\]\(\)\.\{\}]/g;
+            var d3_subclass = {}.__proto__ ? function(object, prototype) {
+              object.__proto__ = prototype;
+            } : function(object, prototype) {
+              for (var property in prototype) object[property] = prototype[property];
+            };
+            function d3_selection(groups) {
+              d3_subclass(groups, d3_selectionPrototype);
+              return groups;
+            }
+            var d3_select = function(s2, n2) {
+              return n2.querySelector(s2);
+            }, d3_selectAll = function(s2, n2) {
+              return n2.querySelectorAll(s2);
+            }, d3_selectMatches = function(n2, s2) {
+              var d3_selectMatcher = n2.matches || n2[d3_vendorSymbol(n2, "matchesSelector")];
+              d3_selectMatches = function(n22, s22) {
+                return d3_selectMatcher.call(n22, s22);
+              };
+              return d3_selectMatches(n2, s2);
+            };
+            if (typeof Sizzle === "function") {
+              d3_select = function(s2, n2) {
+                return Sizzle(s2, n2)[0] || null;
+              };
+              d3_selectAll = Sizzle;
+              d3_selectMatches = Sizzle.matchesSelector;
+            }
+            d3.selection = function() {
+              return d3.select(d3_document.documentElement);
+            };
+            var d3_selectionPrototype = d3.selection.prototype = [];
+            d3_selectionPrototype.select = function(selector) {
+              var subgroups = [], subgroup, subnode, group, node;
+              selector = d3_selection_selector(selector);
+              for (var j2 = -1, m2 = this.length; ++j2 < m2; ) {
+                subgroups.push(subgroup = []);
+                subgroup.parentNode = (group = this[j2]).parentNode;
+                for (var i2 = -1, n2 = group.length; ++i2 < n2; ) {
+                  if (node = group[i2]) {
+                    subgroup.push(subnode = selector.call(node, node.__data__, i2, j2));
+                    if (subnode && "__data__" in node) subnode.__data__ = node.__data__;
+                  } else {
+                    subgroup.push(null);
+                  }
+                }
+              }
+              return d3_selection(subgroups);
+            };
+            function d3_selection_selector(selector) {
+              return typeof selector === "function" ? selector : function() {
+                return d3_select(selector, this);
+              };
+            }
+            d3_selectionPrototype.selectAll = function(selector) {
+              var subgroups = [], subgroup, node;
+              selector = d3_selection_selectorAll(selector);
+              for (var j2 = -1, m2 = this.length; ++j2 < m2; ) {
+                for (var group = this[j2], i2 = -1, n2 = group.length; ++i2 < n2; ) {
+                  if (node = group[i2]) {
+                    subgroups.push(subgroup = d3_array(selector.call(node, node.__data__, i2, j2)));
+                    subgroup.parentNode = node;
+                  }
+                }
+              }
+              return d3_selection(subgroups);
+            };
+            function d3_selection_selectorAll(selector) {
+              return typeof selector === "function" ? selector : function() {
+                return d3_selectAll(selector, this);
+              };
+            }
+            var d3_nsXhtml = "http://www.w3.org/1999/xhtml";
+            var d3_nsPrefix = {
+              svg: "http://www.w3.org/2000/svg",
+              xhtml: d3_nsXhtml,
+              xlink: "http://www.w3.org/1999/xlink",
+              xml: "http://www.w3.org/XML/1998/namespace",
+              xmlns: "http://www.w3.org/2000/xmlns/"
+            };
+            d3.ns = {
+              prefix: d3_nsPrefix,
+              qualify: function(name2) {
+                var i2 = name2.indexOf(":"), prefix = name2;
+                if (i2 >= 0 && (prefix = name2.slice(0, i2)) !== "xmlns") name2 = name2.slice(i2 + 1);
+                return d3_nsPrefix.hasOwnProperty(prefix) ? {
+                  space: d3_nsPrefix[prefix],
+                  local: name2
+                } : name2;
+              }
+            };
+            d3_selectionPrototype.attr = function(name2, value) {
+              if (arguments.length < 2) {
+                if (typeof name2 === "string") {
+                  var node = this.node();
+                  name2 = d3.ns.qualify(name2);
+                  return name2.local ? node.getAttributeNS(name2.space, name2.local) : node.getAttribute(name2);
+                }
+                for (value in name2) this.each(d3_selection_attr(value, name2[value]));
+                return this;
+              }
+              return this.each(d3_selection_attr(name2, value));
+            };
+            function d3_selection_attr(name2, value) {
+              name2 = d3.ns.qualify(name2);
+              function attrNull() {
+                this.removeAttribute(name2);
+              }
+              function attrNullNS() {
+                this.removeAttributeNS(name2.space, name2.local);
+              }
+              function attrConstant() {
+                this.setAttribute(name2, value);
+              }
+              function attrConstantNS() {
+                this.setAttributeNS(name2.space, name2.local, value);
+              }
+              function attrFunction() {
+                var x2 = value.apply(this, arguments);
+                if (x2 == null) this.removeAttribute(name2);
+                else this.setAttribute(name2, x2);
+              }
+              function attrFunctionNS() {
+                var x2 = value.apply(this, arguments);
+                if (x2 == null) this.removeAttributeNS(name2.space, name2.local);
+                else this.setAttributeNS(name2.space, name2.local, x2);
+              }
+              return value == null ? name2.local ? attrNullNS : attrNull : typeof value === "function" ? name2.local ? attrFunctionNS : attrFunction : name2.local ? attrConstantNS : attrConstant;
+            }
+            function d3_collapse(s2) {
+              return s2.trim().replace(/\s+/g, " ");
+            }
+            d3_selectionPrototype.classed = function(name2, value) {
+              if (arguments.length < 2) {
+                if (typeof name2 === "string") {
+                  var node = this.node(), n2 = (name2 = d3_selection_classes(name2)).length, i2 = -1;
+                  if (value = node.classList) {
+                    while (++i2 < n2) if (!value.contains(name2[i2])) return false;
+                  } else {
+                    value = node.getAttribute("class");
+                    while (++i2 < n2) if (!d3_selection_classedRe(name2[i2]).test(value)) return false;
+                  }
+                  return true;
+                }
+                for (value in name2) this.each(d3_selection_classed(value, name2[value]));
+                return this;
+              }
+              return this.each(d3_selection_classed(name2, value));
+            };
+            function d3_selection_classedRe(name2) {
+              return new RegExp("(?:^|\\s+)" + d3.requote(name2) + "(?:\\s+|$)", "g");
+            }
+            function d3_selection_classes(name2) {
+              return (name2 + "").trim().split(/^|\s+/);
+            }
+            function d3_selection_classed(name2, value) {
+              name2 = d3_selection_classes(name2).map(d3_selection_classedName);
+              var n2 = name2.length;
+              function classedConstant() {
+                var i2 = -1;
+                while (++i2 < n2) name2[i2](this, value);
+              }
+              function classedFunction() {
+                var i2 = -1, x2 = value.apply(this, arguments);
+                while (++i2 < n2) name2[i2](this, x2);
+              }
+              return typeof value === "function" ? classedFunction : classedConstant;
+            }
+            function d3_selection_classedName(name2) {
+              var re2 = d3_selection_classedRe(name2);
+              return function(node, value) {
+                if (c2 = node.classList) return value ? c2.add(name2) : c2.remove(name2);
+                var c2 = node.getAttribute("class") || "";
+                if (value) {
+                  re2.lastIndex = 0;
+                  if (!re2.test(c2)) node.setAttribute("class", d3_collapse(c2 + " " + name2));
+                } else {
+                  node.setAttribute("class", d3_collapse(c2.replace(re2, " ")));
+                }
+              };
+            }
+            d3_selectionPrototype.style = function(name2, value, priority) {
+              var n2 = arguments.length;
+              if (n2 < 3) {
+                if (typeof name2 !== "string") {
+                  if (n2 < 2) value = "";
+                  for (priority in name2) this.each(d3_selection_style(priority, name2[priority], value));
+                  return this;
+                }
+                if (n2 < 2) {
+                  var node = this.node();
+                  return d3_window(node).getComputedStyle(node, null).getPropertyValue(name2);
+                }
+                priority = "";
+              }
+              return this.each(d3_selection_style(name2, value, priority));
+            };
+            function d3_selection_style(name2, value, priority) {
+              function styleNull() {
+                this.style.removeProperty(name2);
+              }
+              function styleConstant() {
+                this.style.setProperty(name2, value, priority);
+              }
+              function styleFunction() {
+                var x2 = value.apply(this, arguments);
+                if (x2 == null) this.style.removeProperty(name2);
+                else this.style.setProperty(name2, x2, priority);
+              }
+              return value == null ? styleNull : typeof value === "function" ? styleFunction : styleConstant;
+            }
+            d3_selectionPrototype.property = function(name2, value) {
+              if (arguments.length < 2) {
+                if (typeof name2 === "string") return this.node()[name2];
+                for (value in name2) this.each(d3_selection_property(value, name2[value]));
+                return this;
+              }
+              return this.each(d3_selection_property(name2, value));
+            };
+            function d3_selection_property(name2, value) {
+              function propertyNull() {
+                delete this[name2];
+              }
+              function propertyConstant() {
+                this[name2] = value;
+              }
+              function propertyFunction() {
+                var x2 = value.apply(this, arguments);
+                if (x2 == null) delete this[name2];
+                else this[name2] = x2;
+              }
+              return value == null ? propertyNull : typeof value === "function" ? propertyFunction : propertyConstant;
+            }
+            d3_selectionPrototype.text = function(value) {
+              return arguments.length ? this.each(typeof value === "function" ? function() {
+                var v2 = value.apply(this, arguments);
+                this.textContent = v2 == null ? "" : v2;
+              } : value == null ? function() {
+                this.textContent = "";
+              } : function() {
+                this.textContent = value;
+              }) : this.node().textContent;
+            };
+            d3_selectionPrototype.html = function(value) {
+              return arguments.length ? this.each(typeof value === "function" ? function() {
+                var v2 = value.apply(this, arguments);
+                this.innerHTML = v2 == null ? "" : v2;
+              } : value == null ? function() {
+                this.innerHTML = "";
+              } : function() {
+                this.innerHTML = value;
+              }) : this.node().innerHTML;
+            };
+            d3_selectionPrototype.append = function(name2) {
+              name2 = d3_selection_creator(name2);
+              return this.select(function() {
+                return this.appendChild(name2.apply(this, arguments));
+              });
+            };
+            function d3_selection_creator(name2) {
+              function create2() {
+                var document2 = this.ownerDocument, namespace = this.namespaceURI;
+                return namespace === d3_nsXhtml && document2.documentElement.namespaceURI === d3_nsXhtml ? document2.createElement(name2) : document2.createElementNS(namespace, name2);
+              }
+              function createNS() {
+                return this.ownerDocument.createElementNS(name2.space, name2.local);
+              }
+              return typeof name2 === "function" ? name2 : (name2 = d3.ns.qualify(name2)).local ? createNS : create2;
+            }
+            d3_selectionPrototype.insert = function(name2, before) {
+              name2 = d3_selection_creator(name2);
+              before = d3_selection_selector(before);
+              return this.select(function() {
+                return this.insertBefore(name2.apply(this, arguments), before.apply(this, arguments) || null);
+              });
+            };
+            d3_selectionPrototype.remove = function() {
+              return this.each(d3_selectionRemove);
+            };
+            function d3_selectionRemove() {
+              var parent = this.parentNode;
+              if (parent) parent.removeChild(this);
+            }
+            d3_selectionPrototype.data = function(value, key) {
+              var i2 = -1, n2 = this.length, group, node;
+              if (!arguments.length) {
+                value = new Array(n2 = (group = this[0]).length);
+                while (++i2 < n2) {
+                  if (node = group[i2]) {
+                    value[i2] = node.__data__;
+                  }
+                }
+                return value;
+              }
+              function bind(group2, groupData) {
+                var i22, n22 = group2.length, m2 = groupData.length, n0 = Math.min(n22, m2), updateNodes = new Array(m2), enterNodes = new Array(m2), exitNodes = new Array(n22), node2, nodeData;
+                if (key) {
+                  var nodeByKeyValue = new d3_Map(), keyValues = new Array(n22), keyValue;
+                  for (i22 = -1; ++i22 < n22; ) {
+                    if (node2 = group2[i22]) {
+                      if (nodeByKeyValue.has(keyValue = key.call(node2, node2.__data__, i22))) {
+                        exitNodes[i22] = node2;
+                      } else {
+                        nodeByKeyValue.set(keyValue, node2);
+                      }
+                      keyValues[i22] = keyValue;
+                    }
+                  }
+                  for (i22 = -1; ++i22 < m2; ) {
+                    if (!(node2 = nodeByKeyValue.get(keyValue = key.call(groupData, nodeData = groupData[i22], i22)))) {
+                      enterNodes[i22] = d3_selection_dataNode(nodeData);
+                    } else if (node2 !== true) {
+                      updateNodes[i22] = node2;
+                      node2.__data__ = nodeData;
+                    }
+                    nodeByKeyValue.set(keyValue, true);
+                  }
+                  for (i22 = -1; ++i22 < n22; ) {
+                    if (i22 in keyValues && nodeByKeyValue.get(keyValues[i22]) !== true) {
+                      exitNodes[i22] = group2[i22];
+                    }
+                  }
+                } else {
+                  for (i22 = -1; ++i22 < n0; ) {
+                    node2 = group2[i22];
+                    nodeData = groupData[i22];
+                    if (node2) {
+                      node2.__data__ = nodeData;
+                      updateNodes[i22] = node2;
+                    } else {
+                      enterNodes[i22] = d3_selection_dataNode(nodeData);
+                    }
+                  }
+                  for (; i22 < m2; ++i22) {
+                    enterNodes[i22] = d3_selection_dataNode(groupData[i22]);
+                  }
+                  for (; i22 < n22; ++i22) {
+                    exitNodes[i22] = group2[i22];
+                  }
+                }
+                enterNodes.update = updateNodes;
+                enterNodes.parentNode = updateNodes.parentNode = exitNodes.parentNode = group2.parentNode;
+                enter.push(enterNodes);
+                update.push(updateNodes);
+                exit.push(exitNodes);
+              }
+              var enter = d3_selection_enter([]), update = d3_selection([]), exit = d3_selection([]);
+              if (typeof value === "function") {
+                while (++i2 < n2) {
+                  bind(group = this[i2], value.call(group, group.parentNode.__data__, i2));
+                }
+              } else {
+                while (++i2 < n2) {
+                  bind(group = this[i2], value);
+                }
+              }
+              update.enter = function() {
+                return enter;
+              };
+              update.exit = function() {
+                return exit;
+              };
+              return update;
+            };
+            function d3_selection_dataNode(data) {
+              return {
+                __data__: data
+              };
+            }
+            d3_selectionPrototype.datum = function(value) {
+              return arguments.length ? this.property("__data__", value) : this.property("__data__");
+            };
+            d3_selectionPrototype.filter = function(filter) {
+              var subgroups = [], subgroup, group, node;
+              if (typeof filter !== "function") filter = d3_selection_filter(filter);
+              for (var j2 = 0, m2 = this.length; j2 < m2; j2++) {
+                subgroups.push(subgroup = []);
+                subgroup.parentNode = (group = this[j2]).parentNode;
+                for (var i2 = 0, n2 = group.length; i2 < n2; i2++) {
+                  if ((node = group[i2]) && filter.call(node, node.__data__, i2, j2)) {
+                    subgroup.push(node);
+                  }
+                }
+              }
+              return d3_selection(subgroups);
+            };
+            function d3_selection_filter(selector) {
+              return function() {
+                return d3_selectMatches(this, selector);
+              };
+            }
+            d3_selectionPrototype.order = function() {
+              for (var j2 = -1, m2 = this.length; ++j2 < m2; ) {
+                for (var group = this[j2], i2 = group.length - 1, next = group[i2], node; --i2 >= 0; ) {
+                  if (node = group[i2]) {
+                    if (next && next !== node.nextSibling) next.parentNode.insertBefore(node, next);
+                    next = node;
+                  }
+                }
+              }
+              return this;
+            };
+            d3_selectionPrototype.sort = function(comparator) {
+              comparator = d3_selection_sortComparator.apply(this, arguments);
+              for (var j2 = -1, m2 = this.length; ++j2 < m2; ) this[j2].sort(comparator);
+              return this.order();
+            };
+            function d3_selection_sortComparator(comparator) {
+              if (!arguments.length) comparator = d3_ascending;
+              return function(a2, b2) {
+                return a2 && b2 ? comparator(a2.__data__, b2.__data__) : !a2 - !b2;
+              };
+            }
+            d3_selectionPrototype.each = function(callback) {
+              return d3_selection_each(this, function(node, i2, j2) {
+                callback.call(node, node.__data__, i2, j2);
+              });
+            };
+            function d3_selection_each(groups, callback) {
+              for (var j2 = 0, m2 = groups.length; j2 < m2; j2++) {
+                for (var group = groups[j2], i2 = 0, n2 = group.length, node; i2 < n2; i2++) {
+                  if (node = group[i2]) callback(node, i2, j2);
+                }
+              }
+              return groups;
+            }
+            d3_selectionPrototype.call = function(callback) {
+              var args = d3_array(arguments);
+              callback.apply(args[0] = this, args);
+              return this;
+            };
+            d3_selectionPrototype.empty = function() {
+              return !this.node();
+            };
+            d3_selectionPrototype.node = function() {
+              for (var j2 = 0, m2 = this.length; j2 < m2; j2++) {
+                for (var group = this[j2], i2 = 0, n2 = group.length; i2 < n2; i2++) {
+                  var node = group[i2];
+                  if (node) return node;
+                }
+              }
+              return null;
+            };
+            d3_selectionPrototype.size = function() {
+              var n2 = 0;
+              d3_selection_each(this, function() {
+                ++n2;
+              });
+              return n2;
+            };
+            function d3_selection_enter(selection) {
+              d3_subclass(selection, d3_selection_enterPrototype);
+              return selection;
+            }
+            var d3_selection_enterPrototype = [];
+            d3.selection.enter = d3_selection_enter;
+            d3.selection.enter.prototype = d3_selection_enterPrototype;
+            d3_selection_enterPrototype.append = d3_selectionPrototype.append;
+            d3_selection_enterPrototype.empty = d3_selectionPrototype.empty;
+            d3_selection_enterPrototype.node = d3_selectionPrototype.node;
+            d3_selection_enterPrototype.call = d3_selectionPrototype.call;
+            d3_selection_enterPrototype.size = d3_selectionPrototype.size;
+            d3_selection_enterPrototype.select = function(selector) {
+              var subgroups = [], subgroup, subnode, upgroup, group, node;
+              for (var j2 = -1, m2 = this.length; ++j2 < m2; ) {
+                upgroup = (group = this[j2]).update;
+                subgroups.push(subgroup = []);
+                subgroup.parentNode = group.parentNode;
+                for (var i2 = -1, n2 = group.length; ++i2 < n2; ) {
+                  if (node = group[i2]) {
+                    subgroup.push(upgroup[i2] = subnode = selector.call(group.parentNode, node.__data__, i2, j2));
+                    subnode.__data__ = node.__data__;
+                  } else {
+                    subgroup.push(null);
+                  }
+                }
+              }
+              return d3_selection(subgroups);
+            };
+            d3_selection_enterPrototype.insert = function(name2, before) {
+              if (arguments.length < 2) before = d3_selection_enterInsertBefore(this);
+              return d3_selectionPrototype.insert.call(this, name2, before);
+            };
+            function d3_selection_enterInsertBefore(enter) {
+              var i0, j0;
+              return function(d2, i2, j2) {
+                var group = enter[j2].update, n2 = group.length, node;
+                if (j2 != j0) j0 = j2, i0 = 0;
+                if (i2 >= i0) i0 = i2 + 1;
+                while (!(node = group[i0]) && ++i0 < n2) ;
+                return node;
+              };
+            }
+            d3.select = function(node) {
+              var group;
+              if (typeof node === "string") {
+                group = [d3_select(node, d3_document)];
+                group.parentNode = d3_document.documentElement;
+              } else {
+                group = [node];
+                group.parentNode = d3_documentElement(node);
+              }
+              return d3_selection([group]);
+            };
+            d3.selectAll = function(nodes) {
+              var group;
+              if (typeof nodes === "string") {
+                group = d3_array(d3_selectAll(nodes, d3_document));
+                group.parentNode = d3_document.documentElement;
+              } else {
+                group = d3_array(nodes);
+                group.parentNode = null;
+              }
+              return d3_selection([group]);
+            };
+            d3_selectionPrototype.on = function(type, listener, capture) {
+              var n2 = arguments.length;
+              if (n2 < 3) {
+                if (typeof type !== "string") {
+                  if (n2 < 2) listener = false;
+                  for (capture in type) this.each(d3_selection_on(capture, type[capture], listener));
+                  return this;
+                }
+                if (n2 < 2) return (n2 = this.node()["__on" + type]) && n2._;
+                capture = false;
+              }
+              return this.each(d3_selection_on(type, listener, capture));
+            };
+            function d3_selection_on(type, listener, capture) {
+              var name2 = "__on" + type, i2 = type.indexOf("."), wrap = d3_selection_onListener;
+              if (i2 > 0) type = type.slice(0, i2);
+              var filter = d3_selection_onFilters.get(type);
+              if (filter) type = filter, wrap = d3_selection_onFilter;
+              function onRemove() {
+                var l2 = this[name2];
+                if (l2) {
+                  this.removeEventListener(type, l2, l2.$);
+                  delete this[name2];
+                }
+              }
+              function onAdd() {
+                var l2 = wrap(listener, d3_array(arguments));
+                onRemove.call(this);
+                this.addEventListener(type, this[name2] = l2, l2.$ = capture);
+                l2._ = listener;
+              }
+              function removeAll() {
+                var re2 = new RegExp("^__on([^.]+)" + d3.requote(type) + "$"), match;
+                for (var name3 in this) {
+                  if (match = name3.match(re2)) {
+                    var l2 = this[name3];
+                    this.removeEventListener(match[1], l2, l2.$);
+                    delete this[name3];
+                  }
+                }
+              }
+              return i2 ? listener ? onAdd : onRemove : listener ? d3_noop : removeAll;
+            }
+            var d3_selection_onFilters = d3.map({
+              mouseenter: "mouseover",
+              mouseleave: "mouseout"
+            });
+            if (d3_document) {
+              d3_selection_onFilters.forEach(function(k2) {
+                if ("on" + k2 in d3_document) d3_selection_onFilters.remove(k2);
+              });
+            }
+            function d3_selection_onListener(listener, argumentz) {
+              return function(e2) {
+                var o2 = d3.event;
+                d3.event = e2;
+                argumentz[0] = this.__data__;
+                try {
+                  listener.apply(this, argumentz);
+                } finally {
+                  d3.event = o2;
+                }
+              };
+            }
+            function d3_selection_onFilter(listener, argumentz) {
+              var l2 = d3_selection_onListener(listener, argumentz);
+              return function(e2) {
+                var target = this, related = e2.relatedTarget;
+                if (!related || related !== target && !(related.compareDocumentPosition(target) & 8)) {
+                  l2.call(target, e2);
+                }
+              };
+            }
+            var d3_event_dragSelect, d3_event_dragId = 0;
+            function d3_event_dragSuppress(node) {
+              var name2 = ".dragsuppress-" + ++d3_event_dragId, click = "click" + name2, w2 = d3.select(d3_window(node)).on("touchmove" + name2, d3_eventPreventDefault).on("dragstart" + name2, d3_eventPreventDefault).on("selectstart" + name2, d3_eventPreventDefault);
+              if (d3_event_dragSelect == null) {
+                d3_event_dragSelect = "onselectstart" in node ? false : d3_vendorSymbol(node.style, "userSelect");
+              }
+              if (d3_event_dragSelect) {
+                var style = d3_documentElement(node).style, select = style[d3_event_dragSelect];
+                style[d3_event_dragSelect] = "none";
+              }
+              return function(suppressClick) {
+                w2.on(name2, null);
+                if (d3_event_dragSelect) style[d3_event_dragSelect] = select;
+                if (suppressClick) {
+                  var off = function() {
+                    w2.on(click, null);
+                  };
+                  w2.on(click, function() {
+                    d3_eventPreventDefault();
+                    off();
+                  }, true);
+                  setTimeout(off, 0);
+                }
+              };
+            }
+            d3.mouse = function(container) {
+              return d3_mousePoint(container, d3_eventSource());
+            };
+            var d3_mouse_bug44083 = this.navigator && /WebKit/.test(this.navigator.userAgent) ? -1 : 0;
+            function d3_mousePoint(container, e2) {
+              if (e2.changedTouches) e2 = e2.changedTouches[0];
+              var svg = container.ownerSVGElement || container;
+              if (svg.createSVGPoint) {
+                var point = svg.createSVGPoint();
+                if (d3_mouse_bug44083 < 0) {
+                  var window2 = d3_window(container);
+                  if (window2.scrollX || window2.scrollY) {
+                    svg = d3.select("body").append("svg").style({
+                      position: "absolute",
+                      top: 0,
+                      left: 0,
+                      margin: 0,
+                      padding: 0,
+                      border: "none"
+                    }, "important");
+                    var ctm = svg[0][0].getScreenCTM();
+                    d3_mouse_bug44083 = !(ctm.f || ctm.e);
+                    svg.remove();
+                  }
+                }
+                if (d3_mouse_bug44083) point.x = e2.pageX, point.y = e2.pageY;
+                else point.x = e2.clientX, point.y = e2.clientY;
+                point = point.matrixTransform(container.getScreenCTM().inverse());
+                return [point.x, point.y];
+              }
+              var rect = container.getBoundingClientRect();
+              return [e2.clientX - rect.left - container.clientLeft, e2.clientY - rect.top - container.clientTop];
+            }
+            d3.touch = function(container, touches, identifier) {
+              if (arguments.length < 3) identifier = touches, touches = d3_eventSource().changedTouches;
+              if (touches) for (var i2 = 0, n2 = touches.length, touch; i2 < n2; ++i2) {
+                if ((touch = touches[i2]).identifier === identifier) {
+                  return d3_mousePoint(container, touch);
+                }
+              }
+            };
+            d3.behavior.drag = function() {
+              var event = d3_eventDispatch(drag, "drag", "dragstart", "dragend"), origin = null, mousedown = dragstart(d3_noop, d3.mouse, d3_window, "mousemove", "mouseup"), touchstart = dragstart(d3_behavior_dragTouchId, d3.touch, d3_identity, "touchmove", "touchend");
+              function drag() {
+                this.on("mousedown.drag", mousedown).on("touchstart.drag", touchstart);
+              }
+              function dragstart(id2, position, subject, move, end) {
+                return function() {
+                  var that = this, target = d3.event.target.correspondingElement || d3.event.target, parent = that.parentNode, dispatch = event.of(that, arguments), dragged = 0, dragId = id2(), dragName = ".drag" + (dragId == null ? "" : "-" + dragId), dragOffset, dragSubject = d3.select(subject(target)).on(move + dragName, moved).on(end + dragName, ended), dragRestore = d3_event_dragSuppress(target), position0 = position(parent, dragId);
+                  if (origin) {
+                    dragOffset = origin.apply(that, arguments);
+                    dragOffset = [dragOffset.x - position0[0], dragOffset.y - position0[1]];
+                  } else {
+                    dragOffset = [0, 0];
+                  }
+                  dispatch({
+                    type: "dragstart"
+                  });
+                  function moved() {
+                    var position1 = position(parent, dragId), dx, dy;
+                    if (!position1) return;
+                    dx = position1[0] - position0[0];
+                    dy = position1[1] - position0[1];
+                    dragged |= dx | dy;
+                    position0 = position1;
+                    dispatch({
+                      type: "drag",
+                      x: position1[0] + dragOffset[0],
+                      y: position1[1] + dragOffset[1],
+                      dx,
+                      dy
+                    });
+                  }
+                  function ended() {
+                    if (!position(parent, dragId)) return;
+                    dragSubject.on(move + dragName, null).on(end + dragName, null);
+                    dragRestore(dragged);
+                    dispatch({
+                      type: "dragend"
+                    });
+                  }
+                };
+              }
+              drag.origin = function(x2) {
+                if (!arguments.length) return origin;
+                origin = x2;
+                return drag;
+              };
+              return d3.rebind(drag, event, "on");
+            };
+            function d3_behavior_dragTouchId() {
+              return d3.event.changedTouches[0].identifier;
+            }
+            d3.touches = function(container, touches) {
+              if (arguments.length < 2) touches = d3_eventSource().touches;
+              return touches ? d3_array(touches).map(function(touch) {
+                var point = d3_mousePoint(container, touch);
+                point.identifier = touch.identifier;
+                return point;
+              }) : [];
+            };
+            var ε = 1e-6, ε2 = ε * ε, π = Math.PI, τ = 2 * π, τε = τ - ε, halfπ = π / 2, d3_radians = π / 180, d3_degrees = 180 / π;
+            function d3_cross2d(a2, b2, c2) {
+              return (b2[0] - a2[0]) * (c2[1] - a2[1]) - (b2[1] - a2[1]) * (c2[0] - a2[0]);
+            }
+            function d3_asin(x2) {
+              return x2 > 1 ? halfπ : x2 < -1 ? -halfπ : Math.asin(x2);
+            }
+            function d3_sinh(x2) {
+              return ((x2 = Math.exp(x2)) - 1 / x2) / 2;
+            }
+            function d3_cosh(x2) {
+              return ((x2 = Math.exp(x2)) + 1 / x2) / 2;
+            }
+            function d3_tanh(x2) {
+              return ((x2 = Math.exp(2 * x2)) - 1) / (x2 + 1);
+            }
+            var ρ = Math.SQRT2, ρ2 = 2, ρ4 = 4;
+            d3.interpolateZoom = function(p0, p1) {
+              var ux0 = p0[0], uy0 = p0[1], w0 = p0[2], ux1 = p1[0], uy1 = p1[1], w1 = p1[2], dx = ux1 - ux0, dy = uy1 - uy0, d2 = dx * dx + dy * dy, i2, S2;
+              if (d2 < ε2) {
+                S2 = Math.log(w1 / w0) / ρ;
+                i2 = function(t4) {
+                  return [ux0 + t4 * dx, uy0 + t4 * dy, w0 * Math.exp(ρ * t4 * S2)];
+                };
+              } else {
+                var d1 = Math.sqrt(d2), b0 = (w1 * w1 - w0 * w0 + ρ4 * d2) / (2 * w0 * ρ2 * d1), b1 = (w1 * w1 - w0 * w0 - ρ4 * d2) / (2 * w1 * ρ2 * d1), r0 = Math.log(Math.sqrt(b0 * b0 + 1) - b0), r1 = Math.log(Math.sqrt(b1 * b1 + 1) - b1);
+                S2 = (r1 - r0) / ρ;
+                i2 = function(t4) {
+                  var s2 = t4 * S2, coshr0 = d3_cosh(r0), u2 = w0 / (ρ2 * d1) * (coshr0 * d3_tanh(ρ * s2 + r0) - d3_sinh(r0));
+                  return [ux0 + u2 * dx, uy0 + u2 * dy, w0 * coshr0 / d3_cosh(ρ * s2 + r0)];
+                };
+              }
+              i2.duration = S2 * 1e3;
+              return i2;
+            };
+            d3.behavior.zoom = function() {
+              var view = {
+                x: 0,
+                y: 0,
+                k: 1
+              }, translate0, center0, center, size = [960, 500], scaleExtent = d3_behavior_zoomInfinity, duration = 250, zooming = 0, mousedown = "mousedown.zoom", mousemove = "mousemove.zoom", mouseup = "mouseup.zoom", mousewheelTimer, touchstart = "touchstart.zoom", touchtime, event = d3_eventDispatch(zoom, "zoomstart", "zoom", "zoomend"), x0, x1, y0, y1;
+              if (!d3_behavior_zoomWheel) {
+                d3_behavior_zoomWheel = "onwheel" in d3_document ? (d3_behavior_zoomDelta = function() {
+                  return -d3.event.deltaY * (d3.event.deltaMode ? 120 : 1);
+                }, "wheel") : "onmousewheel" in d3_document ? (d3_behavior_zoomDelta = function() {
+                  return d3.event.wheelDelta;
+                }, "mousewheel") : (d3_behavior_zoomDelta = function() {
+                  return -d3.event.detail;
+                }, "MozMousePixelScroll");
+              }
+              function zoom(g2) {
+                g2.on(mousedown, mousedowned).on(d3_behavior_zoomWheel + ".zoom", mousewheeled).on("dblclick.zoom", dblclicked).on(touchstart, touchstarted);
+              }
+              zoom.event = function(g2) {
+                g2.each(function() {
+                  var dispatch = event.of(this, arguments), view1 = view;
+                  if (d3_transitionInheritId) {
+                    d3.select(this).transition().each("start.zoom", function() {
+                      view = this.__chart__ || {
+                        x: 0,
+                        y: 0,
+                        k: 1
+                      };
+                      zoomstarted(dispatch);
+                    }).tween("zoom:zoom", function() {
+                      var dx = size[0], dy = size[1], cx = center0 ? center0[0] : dx / 2, cy = center0 ? center0[1] : dy / 2, i2 = d3.interpolateZoom([(cx - view.x) / view.k, (cy - view.y) / view.k, dx / view.k], [(cx - view1.x) / view1.k, (cy - view1.y) / view1.k, dx / view1.k]);
+                      return function(t4) {
+                        var l2 = i2(t4), k2 = dx / l2[2];
+                        this.__chart__ = view = {
+                          x: cx - l2[0] * k2,
+                          y: cy - l2[1] * k2,
+                          k: k2
+                        };
+                        zoomed(dispatch);
+                      };
+                    }).each("interrupt.zoom", function() {
+                      zoomended(dispatch);
+                    }).each("end.zoom", function() {
+                      zoomended(dispatch);
+                    });
+                  } else {
+                    this.__chart__ = view;
+                    zoomstarted(dispatch);
+                    zoomed(dispatch);
+                    zoomended(dispatch);
+                  }
+                });
+              };
+              zoom.translate = function(_2) {
+                if (!arguments.length) return [view.x, view.y];
+                view = {
+                  x: +_2[0],
+                  y: +_2[1],
+                  k: view.k
+                };
+                rescale();
+                return zoom;
+              };
+              zoom.scale = function(_2) {
+                if (!arguments.length) return view.k;
+                view = {
+                  x: view.x,
+                  y: view.y,
+                  k: null
+                };
+                scaleTo(+_2);
+                rescale();
+                return zoom;
+              };
+              zoom.scaleExtent = function(_2) {
+                if (!arguments.length) return scaleExtent;
+                scaleExtent = _2 == null ? d3_behavior_zoomInfinity : [+_2[0], +_2[1]];
+                return zoom;
+              };
+              zoom.center = function(_2) {
+                if (!arguments.length) return center;
+                center = _2 && [+_2[0], +_2[1]];
+                return zoom;
+              };
+              zoom.size = function(_2) {
+                if (!arguments.length) return size;
+                size = _2 && [+_2[0], +_2[1]];
+                return zoom;
+              };
+              zoom.duration = function(_2) {
+                if (!arguments.length) return duration;
+                duration = +_2;
+                return zoom;
+              };
+              zoom.x = function(z2) {
+                if (!arguments.length) return x1;
+                x1 = z2;
+                x0 = z2.copy();
+                view = {
+                  x: 0,
+                  y: 0,
+                  k: 1
+                };
+                return zoom;
+              };
+              zoom.y = function(z2) {
+                if (!arguments.length) return y1;
+                y1 = z2;
+                y0 = z2.copy();
+                view = {
+                  x: 0,
+                  y: 0,
+                  k: 1
+                };
+                return zoom;
+              };
+              function location2(p2) {
+                return [(p2[0] - view.x) / view.k, (p2[1] - view.y) / view.k];
+              }
+              function point(l2) {
+                return [l2[0] * view.k + view.x, l2[1] * view.k + view.y];
+              }
+              function scaleTo(s2) {
+                view.k = Math.max(scaleExtent[0], Math.min(scaleExtent[1], s2));
+              }
+              function translateTo(p2, l2) {
+                l2 = point(l2);
+                view.x += p2[0] - l2[0];
+                view.y += p2[1] - l2[1];
+              }
+              function zoomTo(that, p2, l2, k2) {
+                that.__chart__ = {
+                  x: view.x,
+                  y: view.y,
+                  k: view.k
+                };
+                scaleTo(Math.pow(2, k2));
+                translateTo(center0 = p2, l2);
+                that = d3.select(that);
+                if (duration > 0) that = that.transition().duration(duration);
+                that.call(zoom.event);
+              }
+              function rescale() {
+                if (x1) x1.domain(x0.range().map(function(x2) {
+                  return (x2 - view.x) / view.k;
+                }).map(x0.invert));
+                if (y1) y1.domain(y0.range().map(function(y2) {
+                  return (y2 - view.y) / view.k;
+                }).map(y0.invert));
+              }
+              function zoomstarted(dispatch) {
+                if (!zooming++) dispatch({
+                  type: "zoomstart"
+                });
+              }
+              function zoomed(dispatch) {
+                rescale();
+                dispatch({
+                  type: "zoom",
+                  scale: view.k,
+                  translate: [view.x, view.y]
+                });
+              }
+              function zoomended(dispatch) {
+                if (!--zooming) dispatch({
+                  type: "zoomend"
+                }), center0 = null;
+              }
+              function mousedowned() {
+                var that = this, dispatch = event.of(that, arguments), dragged = 0, subject = d3.select(d3_window(that)).on(mousemove, moved).on(mouseup, ended), location0 = location2(d3.mouse(that)), dragRestore = d3_event_dragSuppress(that);
+                d3_selection_interrupt.call(that);
+                zoomstarted(dispatch);
+                function moved() {
+                  dragged = 1;
+                  translateTo(d3.mouse(that), location0);
+                  zoomed(dispatch);
+                }
+                function ended() {
+                  subject.on(mousemove, null).on(mouseup, null);
+                  dragRestore(dragged);
+                  zoomended(dispatch);
+                }
+              }
+              function touchstarted() {
+                var that = this, dispatch = event.of(that, arguments), locations0 = {}, distance0 = 0, scale0, zoomName = ".zoom-" + d3.event.changedTouches[0].identifier, touchmove = "touchmove" + zoomName, touchend = "touchend" + zoomName, targets = [], subject = d3.select(that), dragRestore = d3_event_dragSuppress(that);
+                started();
+                zoomstarted(dispatch);
+                subject.on(mousedown, null).on(touchstart, started);
+                function relocate() {
+                  var touches = d3.touches(that);
+                  scale0 = view.k;
+                  touches.forEach(function(t4) {
+                    if (t4.identifier in locations0) locations0[t4.identifier] = location2(t4);
+                  });
+                  return touches;
+                }
+                function started() {
+                  var target = d3.event.target;
+                  d3.select(target).on(touchmove, moved).on(touchend, ended);
+                  targets.push(target);
+                  var changed = d3.event.changedTouches;
+                  for (var i2 = 0, n2 = changed.length; i2 < n2; ++i2) {
+                    locations0[changed[i2].identifier] = null;
+                  }
+                  var touches = relocate(), now = Date.now();
+                  if (touches.length === 1) {
+                    if (now - touchtime < 500) {
+                      var p2 = touches[0];
+                      zoomTo(that, p2, locations0[p2.identifier], Math.floor(Math.log(view.k) / Math.LN2) + 1);
+                      d3_eventPreventDefault();
+                    }
+                    touchtime = now;
+                  } else if (touches.length > 1) {
+                    var p2 = touches[0], q2 = touches[1], dx = p2[0] - q2[0], dy = p2[1] - q2[1];
+                    distance0 = dx * dx + dy * dy;
+                  }
+                }
+                function moved() {
+                  var touches = d3.touches(that), p0, l0, p1, l1;
+                  d3_selection_interrupt.call(that);
+                  for (var i2 = 0, n2 = touches.length; i2 < n2; ++i2, l1 = null) {
+                    p1 = touches[i2];
+                    if (l1 = locations0[p1.identifier]) {
+                      if (l0) break;
+                      p0 = p1, l0 = l1;
+                    }
+                  }
+                  if (l1) {
+                    var distance1 = (distance1 = p1[0] - p0[0]) * distance1 + (distance1 = p1[1] - p0[1]) * distance1, scale1 = distance0 && Math.sqrt(distance1 / distance0);
+                    p0 = [(p0[0] + p1[0]) / 2, (p0[1] + p1[1]) / 2];
+                    l0 = [(l0[0] + l1[0]) / 2, (l0[1] + l1[1]) / 2];
+                    scaleTo(scale1 * scale0);
+                  }
+                  touchtime = null;
+                  translateTo(p0, l0);
+                  zoomed(dispatch);
+                }
+                function ended() {
+                  if (d3.event.touches.length) {
+                    var changed = d3.event.changedTouches;
+                    for (var i2 = 0, n2 = changed.length; i2 < n2; ++i2) {
+                      delete locations0[changed[i2].identifier];
+                    }
+                    for (var identifier in locations0) {
+                      return void relocate();
+                    }
+                  }
+                  d3.selectAll(targets).on(zoomName, null);
+                  subject.on(mousedown, mousedowned).on(touchstart, touchstarted);
+                  dragRestore();
+                  zoomended(dispatch);
+                }
+              }
+              function mousewheeled() {
+                var dispatch = event.of(this, arguments);
+                if (mousewheelTimer) clearTimeout(mousewheelTimer);
+                else d3_selection_interrupt.call(this), translate0 = location2(center0 = center || d3.mouse(this)), zoomstarted(dispatch);
+                mousewheelTimer = setTimeout(function() {
+                  mousewheelTimer = null;
+                  zoomended(dispatch);
+                }, 50);
+                d3_eventPreventDefault();
+                scaleTo(Math.pow(2, d3_behavior_zoomDelta() * 2e-3) * view.k);
+                translateTo(center0, translate0);
+                zoomed(dispatch);
+              }
+              function dblclicked() {
+                var p2 = d3.mouse(this), k2 = Math.log(view.k) / Math.LN2;
+                zoomTo(this, p2, location2(p2), d3.event.shiftKey ? Math.ceil(k2) - 1 : Math.floor(k2) + 1);
+              }
+              return d3.rebind(zoom, event, "on");
+            };
+            var d3_behavior_zoomInfinity = [0, Infinity], d3_behavior_zoomDelta, d3_behavior_zoomWheel;
+            d3.color = d3_color;
+            function d3_color() {
+            }
+            d3_color.prototype.toString = function() {
+              return this.rgb() + "";
+            };
+            d3.hsl = d3_hsl;
+            function d3_hsl(h2, s2, l2) {
+              return this instanceof d3_hsl ? void (this.h = +h2, this.s = +s2, this.l = +l2) : arguments.length < 2 ? h2 instanceof d3_hsl ? new d3_hsl(h2.h, h2.s, h2.l) : d3_rgb_parse("" + h2, d3_rgb_hsl, d3_hsl) : new d3_hsl(h2, s2, l2);
+            }
+            var d3_hslPrototype = d3_hsl.prototype = new d3_color();
+            d3_hslPrototype.brighter = function(k2) {
+              k2 = Math.pow(0.7, arguments.length ? k2 : 1);
+              return new d3_hsl(this.h, this.s, this.l / k2);
+            };
+            d3_hslPrototype.darker = function(k2) {
+              k2 = Math.pow(0.7, arguments.length ? k2 : 1);
+              return new d3_hsl(this.h, this.s, k2 * this.l);
+            };
+            d3_hslPrototype.rgb = function() {
+              return d3_hsl_rgb(this.h, this.s, this.l);
+            };
+            function d3_hsl_rgb(h2, s2, l2) {
+              var m1, m2;
+              h2 = isNaN(h2) ? 0 : (h2 %= 360) < 0 ? h2 + 360 : h2;
+              s2 = isNaN(s2) ? 0 : s2 < 0 ? 0 : s2 > 1 ? 1 : s2;
+              l2 = l2 < 0 ? 0 : l2 > 1 ? 1 : l2;
+              m2 = l2 <= 0.5 ? l2 * (1 + s2) : l2 + s2 - l2 * s2;
+              m1 = 2 * l2 - m2;
+              function v2(h22) {
+                if (h22 > 360) h22 -= 360;
+                else if (h22 < 0) h22 += 360;
+                if (h22 < 60) return m1 + (m2 - m1) * h22 / 60;
+                if (h22 < 180) return m2;
+                if (h22 < 240) return m1 + (m2 - m1) * (240 - h22) / 60;
+                return m1;
+              }
+              function vv(h22) {
+                return Math.round(v2(h22) * 255);
+              }
+              return new d3_rgb(vv(h2 + 120), vv(h2), vv(h2 - 120));
+            }
+            d3.hcl = d3_hcl;
+            function d3_hcl(h2, c2, l2) {
+              return this instanceof d3_hcl ? void (this.h = +h2, this.c = +c2, this.l = +l2) : arguments.length < 2 ? h2 instanceof d3_hcl ? new d3_hcl(h2.h, h2.c, h2.l) : h2 instanceof d3_lab ? d3_lab_hcl(h2.l, h2.a, h2.b) : d3_lab_hcl((h2 = d3_rgb_lab((h2 = d3.rgb(h2)).r, h2.g, h2.b)).l, h2.a, h2.b) : new d3_hcl(h2, c2, l2);
+            }
+            var d3_hclPrototype = d3_hcl.prototype = new d3_color();
+            d3_hclPrototype.brighter = function(k2) {
+              return new d3_hcl(this.h, this.c, Math.min(100, this.l + d3_lab_K * (arguments.length ? k2 : 1)));
+            };
+            d3_hclPrototype.darker = function(k2) {
+              return new d3_hcl(this.h, this.c, Math.max(0, this.l - d3_lab_K * (arguments.length ? k2 : 1)));
+            };
+            d3_hclPrototype.rgb = function() {
+              return d3_hcl_lab(this.h, this.c, this.l).rgb();
+            };
+            function d3_hcl_lab(h2, c2, l2) {
+              if (isNaN(h2)) h2 = 0;
+              if (isNaN(c2)) c2 = 0;
+              return new d3_lab(l2, Math.cos(h2 *= d3_radians) * c2, Math.sin(h2) * c2);
+            }
+            d3.lab = d3_lab;
+            function d3_lab(l2, a2, b2) {
+              return this instanceof d3_lab ? void (this.l = +l2, this.a = +a2, this.b = +b2) : arguments.length < 2 ? l2 instanceof d3_lab ? new d3_lab(l2.l, l2.a, l2.b) : l2 instanceof d3_hcl ? d3_hcl_lab(l2.h, l2.c, l2.l) : d3_rgb_lab((l2 = d3_rgb(l2)).r, l2.g, l2.b) : new d3_lab(l2, a2, b2);
+            }
+            var d3_lab_K = 18;
+            var d3_lab_X = 0.95047, d3_lab_Y = 1, d3_lab_Z = 1.08883;
+            var d3_labPrototype = d3_lab.prototype = new d3_color();
+            d3_labPrototype.brighter = function(k2) {
+              return new d3_lab(Math.min(100, this.l + d3_lab_K * (arguments.length ? k2 : 1)), this.a, this.b);
+            };
+            d3_labPrototype.darker = function(k2) {
+              return new d3_lab(Math.max(0, this.l - d3_lab_K * (arguments.length ? k2 : 1)), this.a, this.b);
+            };
+            d3_labPrototype.rgb = function() {
+              return d3_lab_rgb(this.l, this.a, this.b);
+            };
+            function d3_lab_rgb(l2, a2, b2) {
+              var y2 = (l2 + 16) / 116, x2 = y2 + a2 / 500, z2 = y2 - b2 / 200;
+              x2 = d3_lab_xyz(x2) * d3_lab_X;
+              y2 = d3_lab_xyz(y2) * d3_lab_Y;
+              z2 = d3_lab_xyz(z2) * d3_lab_Z;
+              return new d3_rgb(d3_xyz_rgb(3.2404542 * x2 - 1.5371385 * y2 - 0.4985314 * z2), d3_xyz_rgb(-0.969266 * x2 + 1.8760108 * y2 + 0.041556 * z2), d3_xyz_rgb(0.0556434 * x2 - 0.2040259 * y2 + 1.0572252 * z2));
+            }
+            function d3_lab_hcl(l2, a2, b2) {
+              return l2 > 0 ? new d3_hcl(Math.atan2(b2, a2) * d3_degrees, Math.sqrt(a2 * a2 + b2 * b2), l2) : new d3_hcl(NaN, NaN, l2);
+            }
+            function d3_lab_xyz(x2) {
+              return x2 > 0.206893034 ? x2 * x2 * x2 : (x2 - 4 / 29) / 7.787037;
+            }
+            function d3_xyz_lab(x2) {
+              return x2 > 8856e-6 ? Math.pow(x2, 1 / 3) : 7.787037 * x2 + 4 / 29;
+            }
+            function d3_xyz_rgb(r2) {
+              return Math.round(255 * (r2 <= 304e-5 ? 12.92 * r2 : 1.055 * Math.pow(r2, 1 / 2.4) - 0.055));
+            }
+            d3.rgb = d3_rgb;
+            function d3_rgb(r2, g2, b2) {
+              return this instanceof d3_rgb ? void (this.r = ~~r2, this.g = ~~g2, this.b = ~~b2) : arguments.length < 2 ? r2 instanceof d3_rgb ? new d3_rgb(r2.r, r2.g, r2.b) : d3_rgb_parse("" + r2, d3_rgb, d3_hsl_rgb) : new d3_rgb(r2, g2, b2);
+            }
+            function d3_rgbNumber(value) {
+              return new d3_rgb(value >> 16, value >> 8 & 255, value & 255);
+            }
+            function d3_rgbString(value) {
+              return d3_rgbNumber(value) + "";
+            }
+            var d3_rgbPrototype = d3_rgb.prototype = new d3_color();
+            d3_rgbPrototype.brighter = function(k2) {
+              k2 = Math.pow(0.7, arguments.length ? k2 : 1);
+              var r2 = this.r, g2 = this.g, b2 = this.b, i2 = 30;
+              if (!r2 && !g2 && !b2) return new d3_rgb(i2, i2, i2);
+              if (r2 && r2 < i2) r2 = i2;
+              if (g2 && g2 < i2) g2 = i2;
+              if (b2 && b2 < i2) b2 = i2;
+              return new d3_rgb(Math.min(255, r2 / k2), Math.min(255, g2 / k2), Math.min(255, b2 / k2));
+            };
+            d3_rgbPrototype.darker = function(k2) {
+              k2 = Math.pow(0.7, arguments.length ? k2 : 1);
+              return new d3_rgb(k2 * this.r, k2 * this.g, k2 * this.b);
+            };
+            d3_rgbPrototype.hsl = function() {
+              return d3_rgb_hsl(this.r, this.g, this.b);
+            };
+            d3_rgbPrototype.toString = function() {
+              return "#" + d3_rgb_hex(this.r) + d3_rgb_hex(this.g) + d3_rgb_hex(this.b);
+            };
+            function d3_rgb_hex(v2) {
+              return v2 < 16 ? "0" + Math.max(0, v2).toString(16) : Math.min(255, v2).toString(16);
+            }
+            function d3_rgb_parse(format, rgb2, hsl3) {
+              var r2 = 0, g2 = 0, b2 = 0, m1, m2, color22;
+              m1 = /([a-z]+)\((.*)\)/.exec(format = format.toLowerCase());
+              if (m1) {
+                m2 = m1[2].split(",");
+                switch (m1[1]) {
+                  case "hsl": {
+                    return hsl3(parseFloat(m2[0]), parseFloat(m2[1]) / 100, parseFloat(m2[2]) / 100);
+                  }
+                  case "rgb": {
+                    return rgb2(d3_rgb_parseNumber(m2[0]), d3_rgb_parseNumber(m2[1]), d3_rgb_parseNumber(m2[2]));
+                  }
+                }
+              }
+              if (color22 = d3_rgb_names.get(format)) {
+                return rgb2(color22.r, color22.g, color22.b);
+              }
+              if (format != null && format.charAt(0) === "#" && !isNaN(color22 = parseInt(format.slice(1), 16))) {
+                if (format.length === 4) {
+                  r2 = (color22 & 3840) >> 4;
+                  r2 = r2 >> 4 | r2;
+                  g2 = color22 & 240;
+                  g2 = g2 >> 4 | g2;
+                  b2 = color22 & 15;
+                  b2 = b2 << 4 | b2;
+                } else if (format.length === 7) {
+                  r2 = (color22 & 16711680) >> 16;
+                  g2 = (color22 & 65280) >> 8;
+                  b2 = color22 & 255;
+                }
+              }
+              return rgb2(r2, g2, b2);
+            }
+            function d3_rgb_hsl(r2, g2, b2) {
+              var min = Math.min(r2 /= 255, g2 /= 255, b2 /= 255), max = Math.max(r2, g2, b2), d2 = max - min, h2, s2, l2 = (max + min) / 2;
+              if (d2) {
+                s2 = l2 < 0.5 ? d2 / (max + min) : d2 / (2 - max - min);
+                if (r2 == max) h2 = (g2 - b2) / d2 + (g2 < b2 ? 6 : 0);
+                else if (g2 == max) h2 = (b2 - r2) / d2 + 2;
+                else h2 = (r2 - g2) / d2 + 4;
+                h2 *= 60;
+              } else {
+                h2 = NaN;
+                s2 = l2 > 0 && l2 < 1 ? 0 : h2;
+              }
+              return new d3_hsl(h2, s2, l2);
+            }
+            function d3_rgb_lab(r2, g2, b2) {
+              r2 = d3_rgb_xyz(r2);
+              g2 = d3_rgb_xyz(g2);
+              b2 = d3_rgb_xyz(b2);
+              var x2 = d3_xyz_lab((0.4124564 * r2 + 0.3575761 * g2 + 0.1804375 * b2) / d3_lab_X), y2 = d3_xyz_lab((0.2126729 * r2 + 0.7151522 * g2 + 0.072175 * b2) / d3_lab_Y), z2 = d3_xyz_lab((0.0193339 * r2 + 0.119192 * g2 + 0.9503041 * b2) / d3_lab_Z);
+              return d3_lab(116 * y2 - 16, 500 * (x2 - y2), 200 * (y2 - z2));
+            }
+            function d3_rgb_xyz(r2) {
+              return (r2 /= 255) <= 0.04045 ? r2 / 12.92 : Math.pow((r2 + 0.055) / 1.055, 2.4);
+            }
+            function d3_rgb_parseNumber(c2) {
+              var f2 = parseFloat(c2);
+              return c2.charAt(c2.length - 1) === "%" ? Math.round(f2 * 2.55) : f2;
+            }
+            var d3_rgb_names = d3.map({
+              aliceblue: 15792383,
+              antiquewhite: 16444375,
+              aqua: 65535,
+              aquamarine: 8388564,
+              azure: 15794175,
+              beige: 16119260,
+              bisque: 16770244,
+              black: 0,
+              blanchedalmond: 16772045,
+              blue: 255,
+              blueviolet: 9055202,
+              brown: 10824234,
+              burlywood: 14596231,
+              cadetblue: 6266528,
+              chartreuse: 8388352,
+              chocolate: 13789470,
+              coral: 16744272,
+              cornflowerblue: 6591981,
+              cornsilk: 16775388,
+              crimson: 14423100,
+              cyan: 65535,
+              darkblue: 139,
+              darkcyan: 35723,
+              darkgoldenrod: 12092939,
+              darkgray: 11119017,
+              darkgreen: 25600,
+              darkgrey: 11119017,
+              darkkhaki: 12433259,
+              darkmagenta: 9109643,
+              darkolivegreen: 5597999,
+              darkorange: 16747520,
+              darkorchid: 10040012,
+              darkred: 9109504,
+              darksalmon: 15308410,
+              darkseagreen: 9419919,
+              darkslateblue: 4734347,
+              darkslategray: 3100495,
+              darkslategrey: 3100495,
+              darkturquoise: 52945,
+              darkviolet: 9699539,
+              deeppink: 16716947,
+              deepskyblue: 49151,
+              dimgray: 6908265,
+              dimgrey: 6908265,
+              dodgerblue: 2003199,
+              firebrick: 11674146,
+              floralwhite: 16775920,
+              forestgreen: 2263842,
+              fuchsia: 16711935,
+              gainsboro: 14474460,
+              ghostwhite: 16316671,
+              gold: 16766720,
+              goldenrod: 14329120,
+              gray: 8421504,
+              green: 32768,
+              greenyellow: 11403055,
+              grey: 8421504,
+              honeydew: 15794160,
+              hotpink: 16738740,
+              indianred: 13458524,
+              indigo: 4915330,
+              ivory: 16777200,
+              khaki: 15787660,
+              lavender: 15132410,
+              lavenderblush: 16773365,
+              lawngreen: 8190976,
+              lemonchiffon: 16775885,
+              lightblue: 11393254,
+              lightcoral: 15761536,
+              lightcyan: 14745599,
+              lightgoldenrodyellow: 16448210,
+              lightgray: 13882323,
+              lightgreen: 9498256,
+              lightgrey: 13882323,
+              lightpink: 16758465,
+              lightsalmon: 16752762,
+              lightseagreen: 2142890,
+              lightskyblue: 8900346,
+              lightslategray: 7833753,
+              lightslategrey: 7833753,
+              lightsteelblue: 11584734,
+              lightyellow: 16777184,
+              lime: 65280,
+              limegreen: 3329330,
+              linen: 16445670,
+              magenta: 16711935,
+              maroon: 8388608,
+              mediumaquamarine: 6737322,
+              mediumblue: 205,
+              mediumorchid: 12211667,
+              mediumpurple: 9662683,
+              mediumseagreen: 3978097,
+              mediumslateblue: 8087790,
+              mediumspringgreen: 64154,
+              mediumturquoise: 4772300,
+              mediumvioletred: 13047173,
+              midnightblue: 1644912,
+              mintcream: 16121850,
+              mistyrose: 16770273,
+              moccasin: 16770229,
+              navajowhite: 16768685,
+              navy: 128,
+              oldlace: 16643558,
+              olive: 8421376,
+              olivedrab: 7048739,
+              orange: 16753920,
+              orangered: 16729344,
+              orchid: 14315734,
+              palegoldenrod: 15657130,
+              palegreen: 10025880,
+              paleturquoise: 11529966,
+              palevioletred: 14381203,
+              papayawhip: 16773077,
+              peachpuff: 16767673,
+              peru: 13468991,
+              pink: 16761035,
+              plum: 14524637,
+              powderblue: 11591910,
+              purple: 8388736,
+              rebeccapurple: 6697881,
+              red: 16711680,
+              rosybrown: 12357519,
+              royalblue: 4286945,
+              saddlebrown: 9127187,
+              salmon: 16416882,
+              sandybrown: 16032864,
+              seagreen: 3050327,
+              seashell: 16774638,
+              sienna: 10506797,
+              silver: 12632256,
+              skyblue: 8900331,
+              slateblue: 6970061,
+              slategray: 7372944,
+              slategrey: 7372944,
+              snow: 16775930,
+              springgreen: 65407,
+              steelblue: 4620980,
+              tan: 13808780,
+              teal: 32896,
+              thistle: 14204888,
+              tomato: 16737095,
+              turquoise: 4251856,
+              violet: 15631086,
+              wheat: 16113331,
+              white: 16777215,
+              whitesmoke: 16119285,
+              yellow: 16776960,
+              yellowgreen: 10145074
+            });
+            d3_rgb_names.forEach(function(key, value) {
+              d3_rgb_names.set(key, d3_rgbNumber(value));
+            });
+            function d3_functor(v2) {
+              return typeof v2 === "function" ? v2 : function() {
+                return v2;
+              };
+            }
+            d3.functor = d3_functor;
+            d3.xhr = d3_xhrType(d3_identity);
+            function d3_xhrType(response) {
+              return function(url, mimeType, callback) {
+                if (arguments.length === 2 && typeof mimeType === "function") callback = mimeType, mimeType = null;
+                return d3_xhr(url, mimeType, response, callback);
+              };
+            }
+            function d3_xhr(url, mimeType, response, callback) {
+              var xhr = {}, dispatch = d3.dispatch("beforesend", "progress", "load", "error"), headers = {}, request = new XMLHttpRequest(), responseType = null;
+              if (self.XDomainRequest && !("withCredentials" in request) && /^(http(s)?:)?\/\//.test(url)) request = new XDomainRequest();
+              "onload" in request ? request.onload = request.onerror = respond : request.onreadystatechange = function() {
+                request.readyState > 3 && respond();
+              };
+              function respond() {
+                var status = request.status, result;
+                if (!status && d3_xhrHasResponse(request) || status >= 200 && status < 300 || status === 304) {
+                  try {
+                    result = response.call(xhr, request);
+                  } catch (e2) {
+                    dispatch.error.call(xhr, e2);
+                    return;
+                  }
+                  dispatch.load.call(xhr, result);
+                } else {
+                  dispatch.error.call(xhr, request);
+                }
+              }
+              request.onprogress = function(event) {
+                var o2 = d3.event;
+                d3.event = event;
+                try {
+                  dispatch.progress.call(xhr, request);
+                } finally {
+                  d3.event = o2;
+                }
+              };
+              xhr.header = function(name2, value) {
+                name2 = (name2 + "").toLowerCase();
+                if (arguments.length < 2) return headers[name2];
+                if (value == null) delete headers[name2];
+                else headers[name2] = value + "";
+                return xhr;
+              };
+              xhr.mimeType = function(value) {
+                if (!arguments.length) return mimeType;
+                mimeType = value == null ? null : value + "";
+                return xhr;
+              };
+              xhr.responseType = function(value) {
+                if (!arguments.length) return responseType;
+                responseType = value;
+                return xhr;
+              };
+              xhr.response = function(value) {
+                response = value;
+                return xhr;
+              };
+              ["get", "post"].forEach(function(method) {
+                xhr[method] = function() {
+                  return xhr.send.apply(xhr, [method].concat(d3_array(arguments)));
+                };
+              });
+              xhr.send = function(method, data, callback2) {
+                if (arguments.length === 2 && typeof data === "function") callback2 = data, data = null;
+                request.open(method, url, true);
+                if (mimeType != null && !("accept" in headers)) headers["accept"] = mimeType + ",*/*";
+                if (request.setRequestHeader) for (var name2 in headers) request.setRequestHeader(name2, headers[name2]);
+                if (mimeType != null && request.overrideMimeType) request.overrideMimeType(mimeType);
+                if (responseType != null) request.responseType = responseType;
+                if (callback2 != null) xhr.on("error", callback2).on("load", function(request2) {
+                  callback2(null, request2);
+                });
+                dispatch.beforesend.call(xhr, request);
+                request.send(data == null ? null : data);
+                return xhr;
+              };
+              xhr.abort = function() {
+                request.abort();
+                return xhr;
+              };
+              d3.rebind(xhr, dispatch, "on");
+              return callback == null ? xhr : xhr.get(d3_xhr_fixCallback(callback));
+            }
+            function d3_xhr_fixCallback(callback) {
+              return callback.length === 1 ? function(error, request) {
+                callback(error == null ? request : null);
+              } : callback;
+            }
+            function d3_xhrHasResponse(request) {
+              var type = request.responseType;
+              return type && type !== "text" ? request.response : request.responseText;
+            }
+            d3.dsv = function(delimiter, mimeType) {
+              var reFormat = new RegExp('["' + delimiter + "\n]"), delimiterCode = delimiter.charCodeAt(0);
+              function dsv(url, row, callback) {
+                if (arguments.length < 3) callback = row, row = null;
+                var xhr = d3_xhr(url, mimeType, row == null ? response : typedResponse(row), callback);
+                xhr.row = function(_2) {
+                  return arguments.length ? xhr.response((row = _2) == null ? response : typedResponse(_2)) : row;
+                };
+                return xhr;
+              }
+              function response(request) {
+                return dsv.parse(request.responseText);
+              }
+              function typedResponse(f2) {
+                return function(request) {
+                  return dsv.parse(request.responseText, f2);
+                };
+              }
+              dsv.parse = function(text, f2) {
+                var o2;
+                return dsv.parseRows(text, function(row, i2) {
+                  if (o2) return o2(row, i2 - 1);
+                  var a2 = function(d2) {
+                    var obj = {};
+                    var len2 = row.length;
+                    for (var k2 = 0; k2 < len2; ++k2) {
+                      obj[row[k2]] = d2[k2];
+                    }
+                    return obj;
+                  };
+                  o2 = f2 ? function(row2, i22) {
+                    return f2(a2(row2), i22);
+                  } : a2;
+                });
+              };
+              dsv.parseRows = function(text, f2) {
+                var EOL = {}, EOF = {}, rows = [], N2 = text.length, I2 = 0, n2 = 0, t4, eol;
+                function token() {
+                  if (I2 >= N2) return EOF;
+                  if (eol) return eol = false, EOL;
+                  var j2 = I2;
+                  if (text.charCodeAt(j2) === 34) {
+                    var i2 = j2;
+                    while (i2++ < N2) {
+                      if (text.charCodeAt(i2) === 34) {
+                        if (text.charCodeAt(i2 + 1) !== 34) break;
+                        ++i2;
+                      }
+                    }
+                    I2 = i2 + 2;
+                    var c2 = text.charCodeAt(i2 + 1);
+                    if (c2 === 13) {
+                      eol = true;
+                      if (text.charCodeAt(i2 + 2) === 10) ++I2;
+                    } else if (c2 === 10) {
+                      eol = true;
+                    }
+                    return text.slice(j2 + 1, i2).replace(/""/g, '"');
+                  }
+                  while (I2 < N2) {
+                    var c2 = text.charCodeAt(I2++), k2 = 1;
+                    if (c2 === 10) eol = true;
+                    else if (c2 === 13) {
+                      eol = true;
+                      if (text.charCodeAt(I2) === 10) ++I2, ++k2;
+                    } else if (c2 !== delimiterCode) continue;
+                    return text.slice(j2, I2 - k2);
+                  }
+                  return text.slice(j2);
+                }
+                while ((t4 = token()) !== EOF) {
+                  var a2 = [];
+                  while (t4 !== EOL && t4 !== EOF) {
+                    a2.push(t4);
+                    t4 = token();
+                  }
+                  if (f2 && (a2 = f2(a2, n2++)) == null) continue;
+                  rows.push(a2);
+                }
+                return rows;
+              };
+              dsv.format = function(rows) {
+                if (Array.isArray(rows[0])) return dsv.formatRows(rows);
+                var fieldSet = new d3_Set(), fields = [];
+                rows.forEach(function(row) {
+                  for (var field in row) {
+                    if (!fieldSet.has(field)) {
+                      fields.push(fieldSet.add(field));
+                    }
+                  }
+                });
+                return [fields.map(formatValue2).join(delimiter)].concat(rows.map(function(row) {
+                  return fields.map(function(field) {
+                    return formatValue2(row[field]);
+                  }).join(delimiter);
+                })).join("\n");
+              };
+              dsv.formatRows = function(rows) {
+                return rows.map(formatRow).join("\n");
+              };
+              function formatRow(row) {
+                return row.map(formatValue2).join(delimiter);
+              }
+              function formatValue2(text) {
+                return reFormat.test(text) ? '"' + text.replace(/\"/g, '""') + '"' : text;
+              }
+              return dsv;
+            };
+            d3.csv = d3.dsv(",", "text/csv");
+            d3.tsv = d3.dsv("	", "text/tab-separated-values");
+            var d3_timer_queueHead, d3_timer_queueTail, d3_timer_interval, d3_timer_timeout, d3_timer_frame = this[d3_vendorSymbol(this, "requestAnimationFrame")] || function(callback) {
+              setTimeout(callback, 17);
+            };
+            d3.timer = function() {
+              d3_timer.apply(this, arguments);
+            };
+            function d3_timer(callback, delay, then) {
+              var n2 = arguments.length;
+              if (n2 < 2) delay = 0;
+              if (n2 < 3) then = Date.now();
+              var time = then + delay, timer = {
+                c: callback,
+                t: time,
+                n: null
+              };
+              if (d3_timer_queueTail) d3_timer_queueTail.n = timer;
+              else d3_timer_queueHead = timer;
+              d3_timer_queueTail = timer;
+              if (!d3_timer_interval) {
+                d3_timer_timeout = clearTimeout(d3_timer_timeout);
+                d3_timer_interval = 1;
+                d3_timer_frame(d3_timer_step);
+              }
+              return timer;
+            }
+            function d3_timer_step() {
+              var now = d3_timer_mark(), delay = d3_timer_sweep() - now;
+              if (delay > 24) {
+                if (isFinite(delay)) {
+                  clearTimeout(d3_timer_timeout);
+                  d3_timer_timeout = setTimeout(d3_timer_step, delay);
+                }
+                d3_timer_interval = 0;
+              } else {
+                d3_timer_interval = 1;
+                d3_timer_frame(d3_timer_step);
+              }
+            }
+            d3.timer.flush = function() {
+              d3_timer_mark();
+              d3_timer_sweep();
+            };
+            function d3_timer_mark() {
+              var now = Date.now(), timer = d3_timer_queueHead;
+              while (timer) {
+                if (now >= timer.t && timer.c(now - timer.t)) timer.c = null;
+                timer = timer.n;
+              }
+              return now;
+            }
+            function d3_timer_sweep() {
+              var t02, t12 = d3_timer_queueHead, time = Infinity;
+              while (t12) {
+                if (t12.c) {
+                  if (t12.t < time) time = t12.t;
+                  t12 = (t02 = t12).n;
+                } else {
+                  t12 = t02 ? t02.n = t12.n : d3_timer_queueHead = t12.n;
+                }
+              }
+              d3_timer_queueTail = t02;
+              return time;
+            }
+            d3.round = function(x2, n2) {
+              return n2 ? Math.round(x2 * (n2 = Math.pow(10, n2))) / n2 : Math.round(x2);
+            };
+            d3.geom = {};
+            function d3_geom_pointX(d2) {
+              return d2[0];
+            }
+            function d3_geom_pointY(d2) {
+              return d2[1];
+            }
+            d3.geom.hull = function(vertices) {
+              var x2 = d3_geom_pointX, y2 = d3_geom_pointY;
+              if (arguments.length) return hull(vertices);
+              function hull(data) {
+                if (data.length < 3) return [];
+                var fx = d3_functor(x2), fy = d3_functor(y2), i2, n2 = data.length, points = [], flippedPoints = [];
+                for (i2 = 0; i2 < n2; i2++) {
+                  points.push([+fx.call(this, data[i2], i2), +fy.call(this, data[i2], i2), i2]);
+                }
+                points.sort(d3_geom_hullOrder);
+                for (i2 = 0; i2 < n2; i2++) flippedPoints.push([points[i2][0], -points[i2][1]]);
+                var upper = d3_geom_hullUpper(points), lower = d3_geom_hullUpper(flippedPoints);
+                var skipLeft = lower[0] === upper[0], skipRight = lower[lower.length - 1] === upper[upper.length - 1], polygon = [];
+                for (i2 = upper.length - 1; i2 >= 0; --i2) polygon.push(data[points[upper[i2]][2]]);
+                for (i2 = +skipLeft; i2 < lower.length - skipRight; ++i2) polygon.push(data[points[lower[i2]][2]]);
+                return polygon;
+              }
+              hull.x = function(_2) {
+                return arguments.length ? (x2 = _2, hull) : x2;
+              };
+              hull.y = function(_2) {
+                return arguments.length ? (y2 = _2, hull) : y2;
+              };
+              return hull;
+            };
+            function d3_geom_hullUpper(points) {
+              var n2 = points.length, hull = [0, 1], hs = 2;
+              for (var i2 = 2; i2 < n2; i2++) {
+                while (hs > 1 && d3_cross2d(points[hull[hs - 2]], points[hull[hs - 1]], points[i2]) <= 0) --hs;
+                hull[hs++] = i2;
+              }
+              return hull.slice(0, hs);
+            }
+            function d3_geom_hullOrder(a2, b2) {
+              return a2[0] - b2[0] || a2[1] - b2[1];
+            }
+            d3.geom.polygon = function(coordinates) {
+              d3_subclass(coordinates, d3_geom_polygonPrototype);
+              return coordinates;
+            };
+            var d3_geom_polygonPrototype = d3.geom.polygon.prototype = [];
+            d3_geom_polygonPrototype.area = function() {
+              var i2 = -1, n2 = this.length, a2, b2 = this[n2 - 1], area = 0;
+              while (++i2 < n2) {
+                a2 = b2;
+                b2 = this[i2];
+                area += a2[1] * b2[0] - a2[0] * b2[1];
+              }
+              return area * 0.5;
+            };
+            d3_geom_polygonPrototype.centroid = function(k2) {
+              var i2 = -1, n2 = this.length, x2 = 0, y2 = 0, a2, b2 = this[n2 - 1], c2;
+              if (!arguments.length) k2 = -1 / (6 * this.area());
+              while (++i2 < n2) {
+                a2 = b2;
+                b2 = this[i2];
+                c2 = a2[0] * b2[1] - b2[0] * a2[1];
+                x2 += (a2[0] + b2[0]) * c2;
+                y2 += (a2[1] + b2[1]) * c2;
+              }
+              return [x2 * k2, y2 * k2];
+            };
+            d3_geom_polygonPrototype.clip = function(subject) {
+              var input, closed = d3_geom_polygonClosed(subject), i2 = -1, n2 = this.length - d3_geom_polygonClosed(this), j2, m2, a2 = this[n2 - 1], b2, c2, d2;
+              while (++i2 < n2) {
+                input = subject.slice();
+                subject.length = 0;
+                b2 = this[i2];
+                c2 = input[(m2 = input.length - closed) - 1];
+                j2 = -1;
+                while (++j2 < m2) {
+                  d2 = input[j2];
+                  if (d3_geom_polygonInside(d2, a2, b2)) {
+                    if (!d3_geom_polygonInside(c2, a2, b2)) {
+                      subject.push(d3_geom_polygonIntersect(c2, d2, a2, b2));
+                    }
+                    subject.push(d2);
+                  } else if (d3_geom_polygonInside(c2, a2, b2)) {
+                    subject.push(d3_geom_polygonIntersect(c2, d2, a2, b2));
+                  }
+                  c2 = d2;
+                }
+                if (closed) subject.push(subject[0]);
+                a2 = b2;
+              }
+              return subject;
+            };
+            function d3_geom_polygonInside(p2, a2, b2) {
+              return (b2[0] - a2[0]) * (p2[1] - a2[1]) < (b2[1] - a2[1]) * (p2[0] - a2[0]);
+            }
+            function d3_geom_polygonIntersect(c2, d2, a2, b2) {
+              var x1 = c2[0], x3 = a2[0], x21 = d2[0] - x1, x43 = b2[0] - x3, y1 = c2[1], y3 = a2[1], y21 = d2[1] - y1, y43 = b2[1] - y3, ua2 = (x43 * (y1 - y3) - y43 * (x1 - x3)) / (y43 * x21 - x43 * y21);
+              return [x1 + ua2 * x21, y1 + ua2 * y21];
+            }
+            function d3_geom_polygonClosed(coordinates) {
+              var a2 = coordinates[0], b2 = coordinates[coordinates.length - 1];
+              return !(a2[0] - b2[0] || a2[1] - b2[1]);
+            }
+            var d3_geom_voronoiEdges, d3_geom_voronoiCells, d3_geom_voronoiBeaches, d3_geom_voronoiBeachPool = [], d3_geom_voronoiFirstCircle, d3_geom_voronoiCircles, d3_geom_voronoiCirclePool = [];
+            function d3_geom_voronoiBeach() {
+              d3_geom_voronoiRedBlackNode(this);
+              this.edge = this.site = this.circle = null;
+            }
+            function d3_geom_voronoiCreateBeach(site) {
+              var beach = d3_geom_voronoiBeachPool.pop() || new d3_geom_voronoiBeach();
+              beach.site = site;
+              return beach;
+            }
+            function d3_geom_voronoiDetachBeach(beach) {
+              d3_geom_voronoiDetachCircle(beach);
+              d3_geom_voronoiBeaches.remove(beach);
+              d3_geom_voronoiBeachPool.push(beach);
+              d3_geom_voronoiRedBlackNode(beach);
+            }
+            function d3_geom_voronoiRemoveBeach(beach) {
+              var circle = beach.circle, x2 = circle.x, y2 = circle.cy, vertex2 = {
+                x: x2,
+                y: y2
+              }, previous = beach.P, next = beach.N, disappearing = [beach];
+              d3_geom_voronoiDetachBeach(beach);
+              var lArc = previous;
+              while (lArc.circle && abs(x2 - lArc.circle.x) < ε && abs(y2 - lArc.circle.cy) < ε) {
+                previous = lArc.P;
+                disappearing.unshift(lArc);
+                d3_geom_voronoiDetachBeach(lArc);
+                lArc = previous;
+              }
+              disappearing.unshift(lArc);
+              d3_geom_voronoiDetachCircle(lArc);
+              var rArc = next;
+              while (rArc.circle && abs(x2 - rArc.circle.x) < ε && abs(y2 - rArc.circle.cy) < ε) {
+                next = rArc.N;
+                disappearing.push(rArc);
+                d3_geom_voronoiDetachBeach(rArc);
+                rArc = next;
+              }
+              disappearing.push(rArc);
+              d3_geom_voronoiDetachCircle(rArc);
+              var nArcs = disappearing.length, iArc;
+              for (iArc = 1; iArc < nArcs; ++iArc) {
+                rArc = disappearing[iArc];
+                lArc = disappearing[iArc - 1];
+                d3_geom_voronoiSetEdgeEnd(rArc.edge, lArc.site, rArc.site, vertex2);
+              }
+              lArc = disappearing[0];
+              rArc = disappearing[nArcs - 1];
+              rArc.edge = d3_geom_voronoiCreateEdge(lArc.site, rArc.site, null, vertex2);
+              d3_geom_voronoiAttachCircle(lArc);
+              d3_geom_voronoiAttachCircle(rArc);
+            }
+            function d3_geom_voronoiAddBeach(site) {
+              var x2 = site.x, directrix = site.y, lArc, rArc, dxl, dxr, node = d3_geom_voronoiBeaches._;
+              while (node) {
+                dxl = d3_geom_voronoiLeftBreakPoint(node, directrix) - x2;
+                if (dxl > ε) node = node.L;
+                else {
+                  dxr = x2 - d3_geom_voronoiRightBreakPoint(node, directrix);
+                  if (dxr > ε) {
+                    if (!node.R) {
+                      lArc = node;
+                      break;
+                    }
+                    node = node.R;
+                  } else {
+                    if (dxl > -1e-6) {
+                      lArc = node.P;
+                      rArc = node;
+                    } else if (dxr > -1e-6) {
+                      lArc = node;
+                      rArc = node.N;
+                    } else {
+                      lArc = rArc = node;
+                    }
+                    break;
+                  }
+                }
+              }
+              var newArc = d3_geom_voronoiCreateBeach(site);
+              d3_geom_voronoiBeaches.insert(lArc, newArc);
+              if (!lArc && !rArc) return;
+              if (lArc === rArc) {
+                d3_geom_voronoiDetachCircle(lArc);
+                rArc = d3_geom_voronoiCreateBeach(lArc.site);
+                d3_geom_voronoiBeaches.insert(newArc, rArc);
+                newArc.edge = rArc.edge = d3_geom_voronoiCreateEdge(lArc.site, newArc.site);
+                d3_geom_voronoiAttachCircle(lArc);
+                d3_geom_voronoiAttachCircle(rArc);
+                return;
+              }
+              if (!rArc) {
+                newArc.edge = d3_geom_voronoiCreateEdge(lArc.site, newArc.site);
+                return;
+              }
+              d3_geom_voronoiDetachCircle(lArc);
+              d3_geom_voronoiDetachCircle(rArc);
+              var lSite = lArc.site, ax = lSite.x, ay = lSite.y, bx = site.x - ax, by = site.y - ay, rSite = rArc.site, cx = rSite.x - ax, cy = rSite.y - ay, d2 = 2 * (bx * cy - by * cx), hb2 = bx * bx + by * by, hc2 = cx * cx + cy * cy, vertex2 = {
+                x: (cy * hb2 - by * hc2) / d2 + ax,
+                y: (bx * hc2 - cx * hb2) / d2 + ay
+              };
+              d3_geom_voronoiSetEdgeEnd(rArc.edge, lSite, rSite, vertex2);
+              newArc.edge = d3_geom_voronoiCreateEdge(lSite, site, null, vertex2);
+              rArc.edge = d3_geom_voronoiCreateEdge(site, rSite, null, vertex2);
+              d3_geom_voronoiAttachCircle(lArc);
+              d3_geom_voronoiAttachCircle(rArc);
+            }
+            function d3_geom_voronoiLeftBreakPoint(arc, directrix) {
+              var site = arc.site, rfocx = site.x, rfocy = site.y, pby2 = rfocy - directrix;
+              if (!pby2) return rfocx;
+              var lArc = arc.P;
+              if (!lArc) return -Infinity;
+              site = lArc.site;
+              var lfocx = site.x, lfocy = site.y, plby2 = lfocy - directrix;
+              if (!plby2) return lfocx;
+              var hl2 = lfocx - rfocx, aby2 = 1 / pby2 - 1 / plby2, b2 = hl2 / plby2;
+              if (aby2) return (-b2 + Math.sqrt(b2 * b2 - 2 * aby2 * (hl2 * hl2 / (-2 * plby2) - lfocy + plby2 / 2 + rfocy - pby2 / 2))) / aby2 + rfocx;
+              return (rfocx + lfocx) / 2;
+            }
+            function d3_geom_voronoiRightBreakPoint(arc, directrix) {
+              var rArc = arc.N;
+              if (rArc) return d3_geom_voronoiLeftBreakPoint(rArc, directrix);
+              var site = arc.site;
+              return site.y === directrix ? site.x : Infinity;
+            }
+            function d3_geom_voronoiCell(site) {
+              this.site = site;
+              this.edges = [];
+            }
+            d3_geom_voronoiCell.prototype.prepare = function() {
+              var halfEdges = this.edges, iHalfEdge = halfEdges.length, edge;
+              while (iHalfEdge--) {
+                edge = halfEdges[iHalfEdge].edge;
+                if (!edge.b || !edge.a) halfEdges.splice(iHalfEdge, 1);
+              }
+              halfEdges.sort(d3_geom_voronoiHalfEdgeOrder);
+              return halfEdges.length;
+            };
+            function d3_geom_voronoiCloseCells(extent) {
+              var x0 = extent[0][0], x1 = extent[1][0], y0 = extent[0][1], y1 = extent[1][1], x2, y2, x3, y3, cells = d3_geom_voronoiCells, iCell = cells.length, cell, iHalfEdge, halfEdges, nHalfEdges, start, end;
+              while (iCell--) {
+                cell = cells[iCell];
+                if (!cell || !cell.prepare()) continue;
+                halfEdges = cell.edges;
+                nHalfEdges = halfEdges.length;
+                iHalfEdge = 0;
+                while (iHalfEdge < nHalfEdges) {
+                  end = halfEdges[iHalfEdge].end(), x3 = end.x, y3 = end.y;
+                  start = halfEdges[++iHalfEdge % nHalfEdges].start(), x2 = start.x, y2 = start.y;
+                  if (abs(x3 - x2) > ε || abs(y3 - y2) > ε) {
+                    halfEdges.splice(iHalfEdge, 0, new d3_geom_voronoiHalfEdge(d3_geom_voronoiCreateBorderEdge(cell.site, end, abs(x3 - x0) < ε && y1 - y3 > ε ? {
+                      x: x0,
+                      y: abs(x2 - x0) < ε ? y2 : y1
+                    } : abs(y3 - y1) < ε && x1 - x3 > ε ? {
+                      x: abs(y2 - y1) < ε ? x2 : x1,
+                      y: y1
+                    } : abs(x3 - x1) < ε && y3 - y0 > ε ? {
+                      x: x1,
+                      y: abs(x2 - x1) < ε ? y2 : y0
+                    } : abs(y3 - y0) < ε && x3 - x0 > ε ? {
+                      x: abs(y2 - y0) < ε ? x2 : x0,
+                      y: y0
+                    } : null), cell.site, null));
+                    ++nHalfEdges;
+                  }
+                }
+              }
+            }
+            function d3_geom_voronoiHalfEdgeOrder(a2, b2) {
+              return b2.angle - a2.angle;
+            }
+            function d3_geom_voronoiCircle() {
+              d3_geom_voronoiRedBlackNode(this);
+              this.x = this.y = this.arc = this.site = this.cy = null;
+            }
+            function d3_geom_voronoiAttachCircle(arc) {
+              var lArc = arc.P, rArc = arc.N;
+              if (!lArc || !rArc) return;
+              var lSite = lArc.site, cSite = arc.site, rSite = rArc.site;
+              if (lSite === rSite) return;
+              var bx = cSite.x, by = cSite.y, ax = lSite.x - bx, ay = lSite.y - by, cx = rSite.x - bx, cy = rSite.y - by;
+              var d2 = 2 * (ax * cy - ay * cx);
+              if (d2 >= -1e-12) return;
+              var ha2 = ax * ax + ay * ay, hc2 = cx * cx + cy * cy, x2 = (cy * ha2 - ay * hc2) / d2, y2 = (ax * hc2 - cx * ha2) / d2, cy = y2 + by;
+              var circle = d3_geom_voronoiCirclePool.pop() || new d3_geom_voronoiCircle();
+              circle.arc = arc;
+              circle.site = cSite;
+              circle.x = x2 + bx;
+              circle.y = cy + Math.sqrt(x2 * x2 + y2 * y2);
+              circle.cy = cy;
+              arc.circle = circle;
+              var before = null, node = d3_geom_voronoiCircles._;
+              while (node) {
+                if (circle.y < node.y || circle.y === node.y && circle.x <= node.x) {
+                  if (node.L) node = node.L;
+                  else {
+                    before = node.P;
+                    break;
+                  }
+                } else {
+                  if (node.R) node = node.R;
+                  else {
+                    before = node;
+                    break;
+                  }
+                }
+              }
+              d3_geom_voronoiCircles.insert(before, circle);
+              if (!before) d3_geom_voronoiFirstCircle = circle;
+            }
+            function d3_geom_voronoiDetachCircle(arc) {
+              var circle = arc.circle;
+              if (circle) {
+                if (!circle.P) d3_geom_voronoiFirstCircle = circle.N;
+                d3_geom_voronoiCircles.remove(circle);
+                d3_geom_voronoiCirclePool.push(circle);
+                d3_geom_voronoiRedBlackNode(circle);
+                arc.circle = null;
+              }
+            }
+            function d3_geom_clipLine(x0, y0, x1, y1) {
+              return function(line) {
+                var a2 = line.a, b2 = line.b, ax = a2.x, ay = a2.y, bx = b2.x, by = b2.y, t02 = 0, t12 = 1, dx = bx - ax, dy = by - ay, r2;
+                r2 = x0 - ax;
+                if (!dx && r2 > 0) return;
+                r2 /= dx;
+                if (dx < 0) {
+                  if (r2 < t02) return;
+                  if (r2 < t12) t12 = r2;
+                } else if (dx > 0) {
+                  if (r2 > t12) return;
+                  if (r2 > t02) t02 = r2;
+                }
+                r2 = x1 - ax;
+                if (!dx && r2 < 0) return;
+                r2 /= dx;
+                if (dx < 0) {
+                  if (r2 > t12) return;
+                  if (r2 > t02) t02 = r2;
+                } else if (dx > 0) {
+                  if (r2 < t02) return;
+                  if (r2 < t12) t12 = r2;
+                }
+                r2 = y0 - ay;
+                if (!dy && r2 > 0) return;
+                r2 /= dy;
+                if (dy < 0) {
+                  if (r2 < t02) return;
+                  if (r2 < t12) t12 = r2;
+                } else if (dy > 0) {
+                  if (r2 > t12) return;
+                  if (r2 > t02) t02 = r2;
+                }
+                r2 = y1 - ay;
+                if (!dy && r2 < 0) return;
+                r2 /= dy;
+                if (dy < 0) {
+                  if (r2 > t12) return;
+                  if (r2 > t02) t02 = r2;
+                } else if (dy > 0) {
+                  if (r2 < t02) return;
+                  if (r2 < t12) t12 = r2;
+                }
+                if (t02 > 0) line.a = {
+                  x: ax + t02 * dx,
+                  y: ay + t02 * dy
+                };
+                if (t12 < 1) line.b = {
+                  x: ax + t12 * dx,
+                  y: ay + t12 * dy
+                };
+                return line;
+              };
+            }
+            function d3_geom_voronoiClipEdges(extent) {
+              var edges = d3_geom_voronoiEdges, clip = d3_geom_clipLine(extent[0][0], extent[0][1], extent[1][0], extent[1][1]), i2 = edges.length, e2;
+              while (i2--) {
+                e2 = edges[i2];
+                if (!d3_geom_voronoiConnectEdge(e2, extent) || !clip(e2) || abs(e2.a.x - e2.b.x) < ε && abs(e2.a.y - e2.b.y) < ε) {
+                  e2.a = e2.b = null;
+                  edges.splice(i2, 1);
+                }
+              }
+            }
+            function d3_geom_voronoiConnectEdge(edge, extent) {
+              var vb2 = edge.b;
+              if (vb2) return true;
+              var va2 = edge.a, x0 = extent[0][0], x1 = extent[1][0], y0 = extent[0][1], y1 = extent[1][1], lSite = edge.l, rSite = edge.r, lx = lSite.x, ly = lSite.y, rx = rSite.x, ry = rSite.y, fx = (lx + rx) / 2, fy = (ly + ry) / 2, fm, fb2;
+              if (ry === ly) {
+                if (fx < x0 || fx >= x1) return;
+                if (lx > rx) {
+                  if (!va2) va2 = {
+                    x: fx,
+                    y: y0
+                  };
+                  else if (va2.y >= y1) return;
+                  vb2 = {
+                    x: fx,
+                    y: y1
+                  };
+                } else {
+                  if (!va2) va2 = {
+                    x: fx,
+                    y: y1
+                  };
+                  else if (va2.y < y0) return;
+                  vb2 = {
+                    x: fx,
+                    y: y0
+                  };
+                }
+              } else {
+                fm = (lx - rx) / (ry - ly);
+                fb2 = fy - fm * fx;
+                if (fm < -1 || fm > 1) {
+                  if (lx > rx) {
+                    if (!va2) va2 = {
+                      x: (y0 - fb2) / fm,
+                      y: y0
+                    };
+                    else if (va2.y >= y1) return;
+                    vb2 = {
+                      x: (y1 - fb2) / fm,
+                      y: y1
+                    };
+                  } else {
+                    if (!va2) va2 = {
+                      x: (y1 - fb2) / fm,
+                      y: y1
+                    };
+                    else if (va2.y < y0) return;
+                    vb2 = {
+                      x: (y0 - fb2) / fm,
+                      y: y0
+                    };
+                  }
+                } else {
+                  if (ly < ry) {
+                    if (!va2) va2 = {
+                      x: x0,
+                      y: fm * x0 + fb2
+                    };
+                    else if (va2.x >= x1) return;
+                    vb2 = {
+                      x: x1,
+                      y: fm * x1 + fb2
+                    };
+                  } else {
+                    if (!va2) va2 = {
+                      x: x1,
+                      y: fm * x1 + fb2
+                    };
+                    else if (va2.x < x0) return;
+                    vb2 = {
+                      x: x0,
+                      y: fm * x0 + fb2
+                    };
+                  }
+                }
+              }
+              edge.a = va2;
+              edge.b = vb2;
+              return true;
+            }
+            function d3_geom_voronoiEdge(lSite, rSite) {
+              this.l = lSite;
+              this.r = rSite;
+              this.a = this.b = null;
+            }
+            function d3_geom_voronoiCreateEdge(lSite, rSite, va2, vb2) {
+              var edge = new d3_geom_voronoiEdge(lSite, rSite);
+              d3_geom_voronoiEdges.push(edge);
+              if (va2) d3_geom_voronoiSetEdgeEnd(edge, lSite, rSite, va2);
+              if (vb2) d3_geom_voronoiSetEdgeEnd(edge, rSite, lSite, vb2);
+              d3_geom_voronoiCells[lSite.i].edges.push(new d3_geom_voronoiHalfEdge(edge, lSite, rSite));
+              d3_geom_voronoiCells[rSite.i].edges.push(new d3_geom_voronoiHalfEdge(edge, rSite, lSite));
+              return edge;
+            }
+            function d3_geom_voronoiCreateBorderEdge(lSite, va2, vb2) {
+              var edge = new d3_geom_voronoiEdge(lSite, null);
+              edge.a = va2;
+              edge.b = vb2;
+              d3_geom_voronoiEdges.push(edge);
+              return edge;
+            }
+            function d3_geom_voronoiSetEdgeEnd(edge, lSite, rSite, vertex2) {
+              if (!edge.a && !edge.b) {
+                edge.a = vertex2;
+                edge.l = lSite;
+                edge.r = rSite;
+              } else if (edge.l === rSite) {
+                edge.b = vertex2;
+              } else {
+                edge.a = vertex2;
+              }
+            }
+            function d3_geom_voronoiHalfEdge(edge, lSite, rSite) {
+              var va2 = edge.a, vb2 = edge.b;
+              this.edge = edge;
+              this.site = lSite;
+              this.angle = rSite ? Math.atan2(rSite.y - lSite.y, rSite.x - lSite.x) : edge.l === lSite ? Math.atan2(vb2.x - va2.x, va2.y - vb2.y) : Math.atan2(va2.x - vb2.x, vb2.y - va2.y);
+            }
+            d3_geom_voronoiHalfEdge.prototype = {
+              start: function() {
+                return this.edge.l === this.site ? this.edge.a : this.edge.b;
+              },
+              end: function() {
+                return this.edge.l === this.site ? this.edge.b : this.edge.a;
+              }
+            };
+            function d3_geom_voronoiRedBlackTree() {
+              this._ = null;
+            }
+            function d3_geom_voronoiRedBlackNode(node) {
+              node.U = node.C = node.L = node.R = node.P = node.N = null;
+            }
+            d3_geom_voronoiRedBlackTree.prototype = {
+              insert: function(after, node) {
+                var parent, grandpa, uncle;
+                if (after) {
+                  node.P = after;
+                  node.N = after.N;
+                  if (after.N) after.N.P = node;
+                  after.N = node;
+                  if (after.R) {
+                    after = after.R;
+                    while (after.L) after = after.L;
+                    after.L = node;
+                  } else {
+                    after.R = node;
+                  }
+                  parent = after;
+                } else if (this._) {
+                  after = d3_geom_voronoiRedBlackFirst(this._);
+                  node.P = null;
+                  node.N = after;
+                  after.P = after.L = node;
+                  parent = after;
+                } else {
+                  node.P = node.N = null;
+                  this._ = node;
+                  parent = null;
+                }
+                node.L = node.R = null;
+                node.U = parent;
+                node.C = true;
+                after = node;
+                while (parent && parent.C) {
+                  grandpa = parent.U;
+                  if (parent === grandpa.L) {
+                    uncle = grandpa.R;
+                    if (uncle && uncle.C) {
+                      parent.C = uncle.C = false;
+                      grandpa.C = true;
+                      after = grandpa;
+                    } else {
+                      if (after === parent.R) {
+                        d3_geom_voronoiRedBlackRotateLeft(this, parent);
+                        after = parent;
+                        parent = after.U;
+                      }
+                      parent.C = false;
+                      grandpa.C = true;
+                      d3_geom_voronoiRedBlackRotateRight(this, grandpa);
+                    }
+                  } else {
+                    uncle = grandpa.L;
+                    if (uncle && uncle.C) {
+                      parent.C = uncle.C = false;
+                      grandpa.C = true;
+                      after = grandpa;
+                    } else {
+                      if (after === parent.L) {
+                        d3_geom_voronoiRedBlackRotateRight(this, parent);
+                        after = parent;
+                        parent = after.U;
+                      }
+                      parent.C = false;
+                      grandpa.C = true;
+                      d3_geom_voronoiRedBlackRotateLeft(this, grandpa);
+                    }
+                  }
+                  parent = after.U;
+                }
+                this._.C = false;
+              },
+              remove: function(node) {
+                if (node.N) node.N.P = node.P;
+                if (node.P) node.P.N = node.N;
+                node.N = node.P = null;
+                var parent = node.U, sibling, left = node.L, right = node.R, next, red;
+                if (!left) next = right;
+                else if (!right) next = left;
+                else next = d3_geom_voronoiRedBlackFirst(right);
+                if (parent) {
+                  if (parent.L === node) parent.L = next;
+                  else parent.R = next;
+                } else {
+                  this._ = next;
+                }
+                if (left && right) {
+                  red = next.C;
+                  next.C = node.C;
+                  next.L = left;
+                  left.U = next;
+                  if (next !== right) {
+                    parent = next.U;
+                    next.U = node.U;
+                    node = next.R;
+                    parent.L = node;
+                    next.R = right;
+                    right.U = next;
+                  } else {
+                    next.U = parent;
+                    parent = next;
+                    node = next.R;
+                  }
+                } else {
+                  red = node.C;
+                  node = next;
+                }
+                if (node) node.U = parent;
+                if (red) return;
+                if (node && node.C) {
+                  node.C = false;
+                  return;
+                }
+                do {
+                  if (node === this._) break;
+                  if (node === parent.L) {
+                    sibling = parent.R;
+                    if (sibling.C) {
+                      sibling.C = false;
+                      parent.C = true;
+                      d3_geom_voronoiRedBlackRotateLeft(this, parent);
+                      sibling = parent.R;
+                    }
+                    if (sibling.L && sibling.L.C || sibling.R && sibling.R.C) {
+                      if (!sibling.R || !sibling.R.C) {
+                        sibling.L.C = false;
+                        sibling.C = true;
+                        d3_geom_voronoiRedBlackRotateRight(this, sibling);
+                        sibling = parent.R;
+                      }
+                      sibling.C = parent.C;
+                      parent.C = sibling.R.C = false;
+                      d3_geom_voronoiRedBlackRotateLeft(this, parent);
+                      node = this._;
+                      break;
+                    }
+                  } else {
+                    sibling = parent.L;
+                    if (sibling.C) {
+                      sibling.C = false;
+                      parent.C = true;
+                      d3_geom_voronoiRedBlackRotateRight(this, parent);
+                      sibling = parent.L;
+                    }
+                    if (sibling.L && sibling.L.C || sibling.R && sibling.R.C) {
+                      if (!sibling.L || !sibling.L.C) {
+                        sibling.R.C = false;
+                        sibling.C = true;
+                        d3_geom_voronoiRedBlackRotateLeft(this, sibling);
+                        sibling = parent.L;
+                      }
+                      sibling.C = parent.C;
+                      parent.C = sibling.L.C = false;
+                      d3_geom_voronoiRedBlackRotateRight(this, parent);
+                      node = this._;
+                      break;
+                    }
+                  }
+                  sibling.C = true;
+                  node = parent;
+                  parent = parent.U;
+                } while (!node.C);
+                if (node) node.C = false;
+              }
+            };
+            function d3_geom_voronoiRedBlackRotateLeft(tree, node) {
+              var p2 = node, q2 = node.R, parent = p2.U;
+              if (parent) {
+                if (parent.L === p2) parent.L = q2;
+                else parent.R = q2;
+              } else {
+                tree._ = q2;
+              }
+              q2.U = parent;
+              p2.U = q2;
+              p2.R = q2.L;
+              if (p2.R) p2.R.U = p2;
+              q2.L = p2;
+            }
+            function d3_geom_voronoiRedBlackRotateRight(tree, node) {
+              var p2 = node, q2 = node.L, parent = p2.U;
+              if (parent) {
+                if (parent.L === p2) parent.L = q2;
+                else parent.R = q2;
+              } else {
+                tree._ = q2;
+              }
+              q2.U = parent;
+              p2.U = q2;
+              p2.L = q2.R;
+              if (p2.L) p2.L.U = p2;
+              q2.R = p2;
+            }
+            function d3_geom_voronoiRedBlackFirst(node) {
+              while (node.L) node = node.L;
+              return node;
+            }
+            function d3_geom_voronoi(sites, bbox) {
+              var site = sites.sort(d3_geom_voronoiVertexOrder).pop(), x0, y0, circle;
+              d3_geom_voronoiEdges = [];
+              d3_geom_voronoiCells = new Array(sites.length);
+              d3_geom_voronoiBeaches = new d3_geom_voronoiRedBlackTree();
+              d3_geom_voronoiCircles = new d3_geom_voronoiRedBlackTree();
+              while (true) {
+                circle = d3_geom_voronoiFirstCircle;
+                if (site && (!circle || site.y < circle.y || site.y === circle.y && site.x < circle.x)) {
+                  if (site.x !== x0 || site.y !== y0) {
+                    d3_geom_voronoiCells[site.i] = new d3_geom_voronoiCell(site);
+                    d3_geom_voronoiAddBeach(site);
+                    x0 = site.x, y0 = site.y;
+                  }
+                  site = sites.pop();
+                } else if (circle) {
+                  d3_geom_voronoiRemoveBeach(circle.arc);
+                } else {
+                  break;
+                }
+              }
+              if (bbox) d3_geom_voronoiClipEdges(bbox), d3_geom_voronoiCloseCells(bbox);
+              var diagram = {
+                cells: d3_geom_voronoiCells,
+                edges: d3_geom_voronoiEdges
+              };
+              d3_geom_voronoiBeaches = d3_geom_voronoiCircles = d3_geom_voronoiEdges = d3_geom_voronoiCells = null;
+              return diagram;
+            }
+            function d3_geom_voronoiVertexOrder(a2, b2) {
+              return b2.y - a2.y || b2.x - a2.x;
+            }
+            d3.geom.voronoi = function(points) {
+              var x2 = d3_geom_pointX, y2 = d3_geom_pointY, fx = x2, fy = y2, clipExtent = d3_geom_voronoiClipExtent;
+              if (points) return voronoi(points);
+              function voronoi(data) {
+                var polygons = new Array(data.length), x0 = clipExtent[0][0], y0 = clipExtent[0][1], x1 = clipExtent[1][0], y1 = clipExtent[1][1];
+                d3_geom_voronoi(sites(data), clipExtent).cells.forEach(function(cell, i2) {
+                  var edges = cell.edges, site = cell.site, polygon = polygons[i2] = edges.length ? edges.map(function(e2) {
+                    var s2 = e2.start();
+                    return [s2.x, s2.y];
+                  }) : site.x >= x0 && site.x <= x1 && site.y >= y0 && site.y <= y1 ? [[x0, y1], [x1, y1], [x1, y0], [x0, y0]] : [];
+                  polygon.point = data[i2];
+                });
+                return polygons;
+              }
+              function sites(data) {
+                return data.map(function(d2, i2) {
+                  return {
+                    x: Math.round(fx(d2, i2) / ε) * ε,
+                    y: Math.round(fy(d2, i2) / ε) * ε,
+                    i: i2
+                  };
+                });
+              }
+              voronoi.links = function(data) {
+                return d3_geom_voronoi(sites(data)).edges.filter(function(edge) {
+                  return edge.l && edge.r;
+                }).map(function(edge) {
+                  return {
+                    source: data[edge.l.i],
+                    target: data[edge.r.i]
+                  };
+                });
+              };
+              voronoi.triangles = function(data) {
+                var triangles = [];
+                d3_geom_voronoi(sites(data)).cells.forEach(function(cell, i2) {
+                  var site = cell.site, edges = cell.edges.sort(d3_geom_voronoiHalfEdgeOrder), j2 = -1, m2 = edges.length, s0, e1 = edges[m2 - 1].edge, s1 = e1.l === site ? e1.r : e1.l;
+                  while (++j2 < m2) {
+                    s0 = s1;
+                    e1 = edges[j2].edge;
+                    s1 = e1.l === site ? e1.r : e1.l;
+                    if (i2 < s0.i && i2 < s1.i && d3_geom_voronoiTriangleArea(site, s0, s1) < 0) {
+                      triangles.push([data[i2], data[s0.i], data[s1.i]]);
+                    }
+                  }
+                });
+                return triangles;
+              };
+              voronoi.x = function(_2) {
+                return arguments.length ? (fx = d3_functor(x2 = _2), voronoi) : x2;
+              };
+              voronoi.y = function(_2) {
+                return arguments.length ? (fy = d3_functor(y2 = _2), voronoi) : y2;
+              };
+              voronoi.clipExtent = function(_2) {
+                if (!arguments.length) return clipExtent === d3_geom_voronoiClipExtent ? null : clipExtent;
+                clipExtent = _2 == null ? d3_geom_voronoiClipExtent : _2;
+                return voronoi;
+              };
+              voronoi.size = function(_2) {
+                if (!arguments.length) return clipExtent === d3_geom_voronoiClipExtent ? null : clipExtent && clipExtent[1];
+                return voronoi.clipExtent(_2 && [[0, 0], _2]);
+              };
+              return voronoi;
+            };
+            var d3_geom_voronoiClipExtent = [[-1e6, -1e6], [1e6, 1e6]];
+            function d3_geom_voronoiTriangleArea(a2, b2, c2) {
+              return (a2.x - c2.x) * (b2.y - a2.y) - (a2.x - b2.x) * (c2.y - a2.y);
+            }
+            d3.geom.delaunay = function(vertices) {
+              return d3.geom.voronoi().triangles(vertices);
+            };
+            d3.geom.quadtree = function(points, x1, y1, x2, y2) {
+              var x3 = d3_geom_pointX, y3 = d3_geom_pointY, compat;
+              if (compat = arguments.length) {
+                x3 = d3_geom_quadtreeCompatX;
+                y3 = d3_geom_quadtreeCompatY;
+                if (compat === 3) {
+                  y2 = y1;
+                  x2 = x1;
+                  y1 = x1 = 0;
+                }
+                return quadtree(points);
+              }
+              function quadtree(data) {
+                var d2, fx = d3_functor(x3), fy = d3_functor(y3), xs, ys, i2, n2, x1_, y1_, x2_, y2_;
+                if (x1 != null) {
+                  x1_ = x1, y1_ = y1, x2_ = x2, y2_ = y2;
+                } else {
+                  x2_ = y2_ = -(x1_ = y1_ = Infinity);
+                  xs = [], ys = [];
+                  n2 = data.length;
+                  if (compat) for (i2 = 0; i2 < n2; ++i2) {
+                    d2 = data[i2];
+                    if (d2.x < x1_) x1_ = d2.x;
+                    if (d2.y < y1_) y1_ = d2.y;
+                    if (d2.x > x2_) x2_ = d2.x;
+                    if (d2.y > y2_) y2_ = d2.y;
+                    xs.push(d2.x);
+                    ys.push(d2.y);
+                  }
+                  else for (i2 = 0; i2 < n2; ++i2) {
+                    var x_ = +fx(d2 = data[i2], i2), y_ = +fy(d2, i2);
+                    if (x_ < x1_) x1_ = x_;
+                    if (y_ < y1_) y1_ = y_;
+                    if (x_ > x2_) x2_ = x_;
+                    if (y_ > y2_) y2_ = y_;
+                    xs.push(x_);
+                    ys.push(y_);
+                  }
+                }
+                var dx = x2_ - x1_, dy = y2_ - y1_;
+                if (dx > dy) y2_ = y1_ + dx;
+                else x2_ = x1_ + dy;
+                function insert(n22, d22, x32, y32, x12, y12, x22, y22) {
+                  if (isNaN(x32) || isNaN(y32)) return;
+                  if (n22.leaf) {
+                    var nx = n22.x, ny = n22.y;
+                    if (nx != null) {
+                      if (abs(nx - x32) + abs(ny - y32) < 0.01) {
+                        insertChild(n22, d22, x32, y32, x12, y12, x22, y22);
+                      } else {
+                        var nPoint = n22.point;
+                        n22.x = n22.y = n22.point = null;
+                        insertChild(n22, nPoint, nx, ny, x12, y12, x22, y22);
+                        insertChild(n22, d22, x32, y32, x12, y12, x22, y22);
+                      }
+                    } else {
+                      n22.x = x32, n22.y = y32, n22.point = d22;
+                    }
+                  } else {
+                    insertChild(n22, d22, x32, y32, x12, y12, x22, y22);
+                  }
+                }
+                function insertChild(n22, d22, x32, y32, x12, y12, x22, y22) {
+                  var xm = (x12 + x22) * 0.5, ym = (y12 + y22) * 0.5, right = x32 >= xm, below = y32 >= ym, i22 = below << 1 | right;
+                  n22.leaf = false;
+                  n22 = n22.nodes[i22] || (n22.nodes[i22] = d3_geom_quadtreeNode());
+                  if (right) x12 = xm;
+                  else x22 = xm;
+                  if (below) y12 = ym;
+                  else y22 = ym;
+                  insert(n22, d22, x32, y32, x12, y12, x22, y22);
+                }
+                var root = d3_geom_quadtreeNode();
+                root.add = function(d22) {
+                  insert(root, d22, +fx(d22, ++i2), +fy(d22, i2), x1_, y1_, x2_, y2_);
+                };
+                root.visit = function(f2) {
+                  d3_geom_quadtreeVisit(f2, root, x1_, y1_, x2_, y2_);
+                };
+                root.find = function(point) {
+                  return d3_geom_quadtreeFind(root, point[0], point[1], x1_, y1_, x2_, y2_);
+                };
+                i2 = -1;
+                if (x1 == null) {
+                  while (++i2 < n2) {
+                    insert(root, data[i2], xs[i2], ys[i2], x1_, y1_, x2_, y2_);
+                  }
+                  --i2;
+                } else data.forEach(root.add);
+                xs = ys = data = d2 = null;
+                return root;
+              }
+              quadtree.x = function(_2) {
+                return arguments.length ? (x3 = _2, quadtree) : x3;
+              };
+              quadtree.y = function(_2) {
+                return arguments.length ? (y3 = _2, quadtree) : y3;
+              };
+              quadtree.extent = function(_2) {
+                if (!arguments.length) return x1 == null ? null : [[x1, y1], [x2, y2]];
+                if (_2 == null) x1 = y1 = x2 = y2 = null;
+                else x1 = +_2[0][0], y1 = +_2[0][1], x2 = +_2[1][0], y2 = +_2[1][1];
+                return quadtree;
+              };
+              quadtree.size = function(_2) {
+                if (!arguments.length) return x1 == null ? null : [x2 - x1, y2 - y1];
+                if (_2 == null) x1 = y1 = x2 = y2 = null;
+                else x1 = y1 = 0, x2 = +_2[0], y2 = +_2[1];
+                return quadtree;
+              };
+              return quadtree;
+            };
+            function d3_geom_quadtreeCompatX(d2) {
+              return d2.x;
+            }
+            function d3_geom_quadtreeCompatY(d2) {
+              return d2.y;
+            }
+            function d3_geom_quadtreeNode() {
+              return {
+                leaf: true,
+                nodes: [],
+                point: null,
+                x: null,
+                y: null
+              };
+            }
+            function d3_geom_quadtreeVisit(f2, node, x1, y1, x2, y2) {
+              if (!f2(node, x1, y1, x2, y2)) {
+                var sx = (x1 + x2) * 0.5, sy = (y1 + y2) * 0.5, children = node.nodes;
+                if (children[0]) d3_geom_quadtreeVisit(f2, children[0], x1, y1, sx, sy);
+                if (children[1]) d3_geom_quadtreeVisit(f2, children[1], sx, y1, x2, sy);
+                if (children[2]) d3_geom_quadtreeVisit(f2, children[2], x1, sy, sx, y2);
+                if (children[3]) d3_geom_quadtreeVisit(f2, children[3], sx, sy, x2, y2);
+              }
+            }
+            function d3_geom_quadtreeFind(root, x2, y2, x0, y0, x3, y3) {
+              var minDistance2 = Infinity, closestPoint;
+              (function find(node, x1, y1, x22, y22) {
+                if (x1 > x3 || y1 > y3 || x22 < x0 || y22 < y0) return;
+                if (point = node.point) {
+                  var point, dx = x2 - node.x, dy = y2 - node.y, distance2 = dx * dx + dy * dy;
+                  if (distance2 < minDistance2) {
+                    var distance3 = Math.sqrt(minDistance2 = distance2);
+                    x0 = x2 - distance3, y0 = y2 - distance3;
+                    x3 = x2 + distance3, y3 = y2 + distance3;
+                    closestPoint = point;
+                  }
+                }
+                var children = node.nodes, xm = (x1 + x22) * 0.5, ym = (y1 + y22) * 0.5, right = x2 >= xm, below = y2 >= ym;
+                for (var i2 = below << 1 | right, j2 = i2 + 4; i2 < j2; ++i2) {
+                  if (node = children[i2 & 3]) switch (i2 & 3) {
+                    case 0:
+                      find(node, x1, y1, xm, ym);
+                      break;
+                    case 1:
+                      find(node, xm, y1, x22, ym);
+                      break;
+                    case 2:
+                      find(node, x1, ym, xm, y22);
+                      break;
+                    case 3:
+                      find(node, xm, ym, x22, y22);
+                      break;
+                  }
+                }
+              })(root, x0, y0, x3, y3);
+              return closestPoint;
+            }
+            d3.interpolateRgb = d3_interpolateRgb;
+            function d3_interpolateRgb(a2, b2) {
+              a2 = d3.rgb(a2);
+              b2 = d3.rgb(b2);
+              var ar = a2.r, ag2 = a2.g, ab2 = a2.b, br = b2.r - ar, bg2 = b2.g - ag2, bb2 = b2.b - ab2;
+              return function(t4) {
+                return "#" + d3_rgb_hex(Math.round(ar + br * t4)) + d3_rgb_hex(Math.round(ag2 + bg2 * t4)) + d3_rgb_hex(Math.round(ab2 + bb2 * t4));
+              };
+            }
+            d3.interpolateObject = d3_interpolateObject;
+            function d3_interpolateObject(a2, b2) {
+              var i2 = {}, c2 = {}, k2;
+              for (k2 in a2) {
+                if (k2 in b2) {
+                  i2[k2] = d3_interpolate(a2[k2], b2[k2]);
+                } else {
+                  c2[k2] = a2[k2];
+                }
+              }
+              for (k2 in b2) {
+                if (!(k2 in a2)) {
+                  c2[k2] = b2[k2];
+                }
+              }
+              return function(t4) {
+                for (k2 in i2) c2[k2] = i2[k2](t4);
+                return c2;
+              };
+            }
+            d3.interpolateNumber = d3_interpolateNumber;
+            function d3_interpolateNumber(a2, b2) {
+              a2 = +a2, b2 = +b2;
+              return function(t4) {
+                return a2 * (1 - t4) + b2 * t4;
+              };
+            }
+            d3.interpolateString = d3_interpolateString;
+            function d3_interpolateString(a2, b2) {
+              var bi2 = d3_interpolate_numberA.lastIndex = d3_interpolate_numberB.lastIndex = 0, am, bm, bs, i2 = -1, s2 = [], q2 = [];
+              a2 = a2 + "", b2 = b2 + "";
+              while ((am = d3_interpolate_numberA.exec(a2)) && (bm = d3_interpolate_numberB.exec(b2))) {
+                if ((bs = bm.index) > bi2) {
+                  bs = b2.slice(bi2, bs);
+                  if (s2[i2]) s2[i2] += bs;
+                  else s2[++i2] = bs;
+                }
+                if ((am = am[0]) === (bm = bm[0])) {
+                  if (s2[i2]) s2[i2] += bm;
+                  else s2[++i2] = bm;
+                } else {
+                  s2[++i2] = null;
+                  q2.push({
+                    i: i2,
+                    x: d3_interpolateNumber(am, bm)
+                  });
+                }
+                bi2 = d3_interpolate_numberB.lastIndex;
+              }
+              if (bi2 < b2.length) {
+                bs = b2.slice(bi2);
+                if (s2[i2]) s2[i2] += bs;
+                else s2[++i2] = bs;
+              }
+              return s2.length < 2 ? q2[0] ? (b2 = q2[0].x, function(t4) {
+                return b2(t4) + "";
+              }) : function() {
+                return b2;
+              } : (b2 = q2.length, function(t4) {
+                for (var i22 = 0, o2; i22 < b2; ++i22) s2[(o2 = q2[i22]).i] = o2.x(t4);
+                return s2.join("");
+              });
+            }
+            var d3_interpolate_numberA = /[-+]?(?:\d+\.?\d*|\.?\d+)(?:[eE][-+]?\d+)?/g, d3_interpolate_numberB = new RegExp(d3_interpolate_numberA.source, "g");
+            d3.interpolate = d3_interpolate;
+            function d3_interpolate(a2, b2) {
+              var i2 = d3.interpolators.length, f2;
+              while (--i2 >= 0 && !(f2 = d3.interpolators[i2](a2, b2))) ;
+              return f2;
+            }
+            d3.interpolators = [function(a2, b2) {
+              var t4 = typeof b2;
+              return (t4 === "string" ? d3_rgb_names.has(b2.toLowerCase()) || /^(#|rgb\(|hsl\()/i.test(b2) ? d3_interpolateRgb : d3_interpolateString : b2 instanceof d3_color ? d3_interpolateRgb : Array.isArray(b2) ? d3_interpolateArray : t4 === "object" && isNaN(b2) ? d3_interpolateObject : d3_interpolateNumber)(a2, b2);
+            }];
+            d3.interpolateArray = d3_interpolateArray;
+            function d3_interpolateArray(a2, b2) {
+              var x2 = [], c2 = [], na = a2.length, nb2 = b2.length, n0 = Math.min(a2.length, b2.length), i2;
+              for (i2 = 0; i2 < n0; ++i2) x2.push(d3_interpolate(a2[i2], b2[i2]));
+              for (; i2 < na; ++i2) c2[i2] = a2[i2];
+              for (; i2 < nb2; ++i2) c2[i2] = b2[i2];
+              return function(t4) {
+                for (i2 = 0; i2 < n0; ++i2) c2[i2] = x2[i2](t4);
+                return c2;
+              };
+            }
+            var d3_ease_default = function() {
+              return d3_identity;
+            };
+            var d3_ease = d3.map({
+              linear: d3_ease_default,
+              poly: d3_ease_poly,
+              quad: function() {
+                return d3_ease_quad;
+              },
+              cubic: function() {
+                return d3_ease_cubic;
+              },
+              sin: function() {
+                return d3_ease_sin;
+              },
+              exp: function() {
+                return d3_ease_exp;
+              },
+              circle: function() {
+                return d3_ease_circle;
+              },
+              elastic: d3_ease_elastic,
+              back: d3_ease_back,
+              bounce: function() {
+                return d3_ease_bounce;
+              }
+            });
+            var d3_ease_mode = d3.map({
+              "in": d3_identity,
+              out: d3_ease_reverse,
+              "in-out": d3_ease_reflect,
+              "out-in": function(f2) {
+                return d3_ease_reflect(d3_ease_reverse(f2));
+              }
+            });
+            d3.ease = function(name2) {
+              var i2 = name2.indexOf("-"), t4 = i2 >= 0 ? name2.slice(0, i2) : name2, m2 = i2 >= 0 ? name2.slice(i2 + 1) : "in";
+              t4 = d3_ease.get(t4) || d3_ease_default;
+              m2 = d3_ease_mode.get(m2) || d3_identity;
+              return d3_ease_clamp(m2(t4.apply(null, d3_arraySlice.call(arguments, 1))));
+            };
+            function d3_ease_clamp(f2) {
+              return function(t4) {
+                return t4 <= 0 ? 0 : t4 >= 1 ? 1 : f2(t4);
+              };
+            }
+            function d3_ease_reverse(f2) {
+              return function(t4) {
+                return 1 - f2(1 - t4);
+              };
+            }
+            function d3_ease_reflect(f2) {
+              return function(t4) {
+                return 0.5 * (t4 < 0.5 ? f2(2 * t4) : 2 - f2(2 - 2 * t4));
+              };
+            }
+            function d3_ease_quad(t4) {
+              return t4 * t4;
+            }
+            function d3_ease_cubic(t4) {
+              return t4 * t4 * t4;
+            }
+            function d3_ease_cubicInOut(t4) {
+              if (t4 <= 0) return 0;
+              if (t4 >= 1) return 1;
+              var t22 = t4 * t4, t32 = t22 * t4;
+              return 4 * (t4 < 0.5 ? t32 : 3 * (t4 - t22) + t32 - 0.75);
+            }
+            function d3_ease_poly(e2) {
+              return function(t4) {
+                return Math.pow(t4, e2);
+              };
+            }
+            function d3_ease_sin(t4) {
+              return 1 - Math.cos(t4 * halfπ);
+            }
+            function d3_ease_exp(t4) {
+              return Math.pow(2, 10 * (t4 - 1));
+            }
+            function d3_ease_circle(t4) {
+              return 1 - Math.sqrt(1 - t4 * t4);
+            }
+            function d3_ease_elastic(a2, p2) {
+              var s2;
+              if (arguments.length < 2) p2 = 0.45;
+              if (arguments.length) s2 = p2 / τ * Math.asin(1 / a2);
+              else a2 = 1, s2 = p2 / 4;
+              return function(t4) {
+                return 1 + a2 * Math.pow(2, -10 * t4) * Math.sin((t4 - s2) * τ / p2);
+              };
+            }
+            function d3_ease_back(s2) {
+              if (!s2) s2 = 1.70158;
+              return function(t4) {
+                return t4 * t4 * ((s2 + 1) * t4 - s2);
+              };
+            }
+            function d3_ease_bounce(t4) {
+              return t4 < 1 / 2.75 ? 7.5625 * t4 * t4 : t4 < 2 / 2.75 ? 7.5625 * (t4 -= 1.5 / 2.75) * t4 + 0.75 : t4 < 2.5 / 2.75 ? 7.5625 * (t4 -= 2.25 / 2.75) * t4 + 0.9375 : 7.5625 * (t4 -= 2.625 / 2.75) * t4 + 0.984375;
+            }
+            d3.interpolateHcl = d3_interpolateHcl;
+            function d3_interpolateHcl(a2, b2) {
+              a2 = d3.hcl(a2);
+              b2 = d3.hcl(b2);
+              var ah2 = a2.h, ac2 = a2.c, al2 = a2.l, bh2 = b2.h - ah2, bc2 = b2.c - ac2, bl2 = b2.l - al2;
+              if (isNaN(bc2)) bc2 = 0, ac2 = isNaN(ac2) ? b2.c : ac2;
+              if (isNaN(bh2)) bh2 = 0, ah2 = isNaN(ah2) ? b2.h : ah2;
+              else if (bh2 > 180) bh2 -= 360;
+              else if (bh2 < -180) bh2 += 360;
+              return function(t4) {
+                return d3_hcl_lab(ah2 + bh2 * t4, ac2 + bc2 * t4, al2 + bl2 * t4) + "";
+              };
+            }
+            d3.interpolateHsl = d3_interpolateHsl;
+            function d3_interpolateHsl(a2, b2) {
+              a2 = d3.hsl(a2);
+              b2 = d3.hsl(b2);
+              var ah2 = a2.h, as = a2.s, al2 = a2.l, bh2 = b2.h - ah2, bs = b2.s - as, bl2 = b2.l - al2;
+              if (isNaN(bs)) bs = 0, as = isNaN(as) ? b2.s : as;
+              if (isNaN(bh2)) bh2 = 0, ah2 = isNaN(ah2) ? b2.h : ah2;
+              else if (bh2 > 180) bh2 -= 360;
+              else if (bh2 < -180) bh2 += 360;
+              return function(t4) {
+                return d3_hsl_rgb(ah2 + bh2 * t4, as + bs * t4, al2 + bl2 * t4) + "";
+              };
+            }
+            d3.interpolateLab = d3_interpolateLab;
+            function d3_interpolateLab(a2, b2) {
+              a2 = d3.lab(a2);
+              b2 = d3.lab(b2);
+              var al2 = a2.l, aa2 = a2.a, ab2 = a2.b, bl2 = b2.l - al2, ba = b2.a - aa2, bb2 = b2.b - ab2;
+              return function(t4) {
+                return d3_lab_rgb(al2 + bl2 * t4, aa2 + ba * t4, ab2 + bb2 * t4) + "";
+              };
+            }
+            d3.interpolateRound = d3_interpolateRound;
+            function d3_interpolateRound(a2, b2) {
+              b2 -= a2;
+              return function(t4) {
+                return Math.round(a2 + b2 * t4);
+              };
+            }
+            d3.transform = function(string) {
+              var g2 = d3_document.createElementNS(d3.ns.prefix.svg, "g");
+              return (d3.transform = function(string2) {
+                if (string2 != null) {
+                  g2.setAttribute("transform", string2);
+                  var t4 = g2.transform.baseVal.consolidate();
+                }
+                return new d3_transform(t4 ? t4.matrix : d3_transformIdentity);
+              })(string);
+            };
+            function d3_transform(m2) {
+              var r0 = [m2.a, m2.b], r1 = [m2.c, m2.d], kx = d3_transformNormalize(r0), kz = d3_transformDot(r0, r1), ky = d3_transformNormalize(d3_transformCombine(r1, r0, -kz)) || 0;
+              if (r0[0] * r1[1] < r1[0] * r0[1]) {
+                r0[0] *= -1;
+                r0[1] *= -1;
+                kx *= -1;
+                kz *= -1;
+              }
+              this.rotate = (kx ? Math.atan2(r0[1], r0[0]) : Math.atan2(-r1[0], r1[1])) * d3_degrees;
+              this.translate = [m2.e, m2.f];
+              this.scale = [kx, ky];
+              this.skew = ky ? Math.atan2(kz, ky) * d3_degrees : 0;
+            }
+            d3_transform.prototype.toString = function() {
+              return "translate(" + this.translate + ")rotate(" + this.rotate + ")skewX(" + this.skew + ")scale(" + this.scale + ")";
+            };
+            function d3_transformDot(a2, b2) {
+              return a2[0] * b2[0] + a2[1] * b2[1];
+            }
+            function d3_transformNormalize(a2) {
+              var k2 = Math.sqrt(d3_transformDot(a2, a2));
+              if (k2) {
+                a2[0] /= k2;
+                a2[1] /= k2;
+              }
+              return k2;
+            }
+            function d3_transformCombine(a2, b2, k2) {
+              a2[0] += k2 * b2[0];
+              a2[1] += k2 * b2[1];
+              return a2;
+            }
+            var d3_transformIdentity = {
+              a: 1,
+              b: 0,
+              c: 0,
+              d: 1,
+              e: 0,
+              f: 0
+            };
+            d3.interpolateTransform = d3_interpolateTransform;
+            function d3_interpolateTransformPop(s2) {
+              return s2.length ? s2.pop() + "," : "";
+            }
+            function d3_interpolateTranslate(ta2, tb2, s2, q2) {
+              if (ta2[0] !== tb2[0] || ta2[1] !== tb2[1]) {
+                var i2 = s2.push("translate(", null, ",", null, ")");
+                q2.push({
+                  i: i2 - 4,
+                  x: d3_interpolateNumber(ta2[0], tb2[0])
+                }, {
+                  i: i2 - 2,
+                  x: d3_interpolateNumber(ta2[1], tb2[1])
+                });
+              } else if (tb2[0] || tb2[1]) {
+                s2.push("translate(" + tb2 + ")");
+              }
+            }
+            function d3_interpolateRotate(ra2, rb2, s2, q2) {
+              if (ra2 !== rb2) {
+                if (ra2 - rb2 > 180) rb2 += 360;
+                else if (rb2 - ra2 > 180) ra2 += 360;
+                q2.push({
+                  i: s2.push(d3_interpolateTransformPop(s2) + "rotate(", null, ")") - 2,
+                  x: d3_interpolateNumber(ra2, rb2)
+                });
+              } else if (rb2) {
+                s2.push(d3_interpolateTransformPop(s2) + "rotate(" + rb2 + ")");
+              }
+            }
+            function d3_interpolateSkew(wa2, wb2, s2, q2) {
+              if (wa2 !== wb2) {
+                q2.push({
+                  i: s2.push(d3_interpolateTransformPop(s2) + "skewX(", null, ")") - 2,
+                  x: d3_interpolateNumber(wa2, wb2)
+                });
+              } else if (wb2) {
+                s2.push(d3_interpolateTransformPop(s2) + "skewX(" + wb2 + ")");
+              }
+            }
+            function d3_interpolateScale(ka2, kb2, s2, q2) {
+              if (ka2[0] !== kb2[0] || ka2[1] !== kb2[1]) {
+                var i2 = s2.push(d3_interpolateTransformPop(s2) + "scale(", null, ",", null, ")");
+                q2.push({
+                  i: i2 - 4,
+                  x: d3_interpolateNumber(ka2[0], kb2[0])
+                }, {
+                  i: i2 - 2,
+                  x: d3_interpolateNumber(ka2[1], kb2[1])
+                });
+              } else if (kb2[0] !== 1 || kb2[1] !== 1) {
+                s2.push(d3_interpolateTransformPop(s2) + "scale(" + kb2 + ")");
+              }
+            }
+            function d3_interpolateTransform(a2, b2) {
+              var s2 = [], q2 = [];
+              a2 = d3.transform(a2), b2 = d3.transform(b2);
+              d3_interpolateTranslate(a2.translate, b2.translate, s2, q2);
+              d3_interpolateRotate(a2.rotate, b2.rotate, s2, q2);
+              d3_interpolateSkew(a2.skew, b2.skew, s2, q2);
+              d3_interpolateScale(a2.scale, b2.scale, s2, q2);
+              a2 = b2 = null;
+              return function(t4) {
+                var i2 = -1, n2 = q2.length, o2;
+                while (++i2 < n2) s2[(o2 = q2[i2]).i] = o2.x(t4);
+                return s2.join("");
+              };
+            }
+            function d3_uninterpolateNumber(a2, b2) {
+              b2 = (b2 -= a2 = +a2) || 1 / b2;
+              return function(x2) {
+                return (x2 - a2) / b2;
+              };
+            }
+            function d3_uninterpolateClamp(a2, b2) {
+              b2 = (b2 -= a2 = +a2) || 1 / b2;
+              return function(x2) {
+                return Math.max(0, Math.min(1, (x2 - a2) / b2));
+              };
+            }
+            d3.layout = {};
+            d3.layout.bundle = function() {
+              return function(links) {
+                var paths = [], i2 = -1, n2 = links.length;
+                while (++i2 < n2) paths.push(d3_layout_bundlePath(links[i2]));
+                return paths;
+              };
+            };
+            function d3_layout_bundlePath(link) {
+              var start = link.source, end = link.target, lca = d3_layout_bundleLeastCommonAncestor(start, end), points = [start];
+              while (start !== lca) {
+                start = start.parent;
+                points.push(start);
+              }
+              var k2 = points.length;
+              while (end !== lca) {
+                points.splice(k2, 0, end);
+                end = end.parent;
+              }
+              return points;
+            }
+            function d3_layout_bundleAncestors(node) {
+              var ancestors = [], parent = node.parent;
+              while (parent != null) {
+                ancestors.push(node);
+                node = parent;
+                parent = parent.parent;
+              }
+              ancestors.push(node);
+              return ancestors;
+            }
+            function d3_layout_bundleLeastCommonAncestor(a2, b2) {
+              if (a2 === b2) return a2;
+              var aNodes = d3_layout_bundleAncestors(a2), bNodes = d3_layout_bundleAncestors(b2), aNode = aNodes.pop(), bNode = bNodes.pop(), sharedNode = null;
+              while (aNode === bNode) {
+                sharedNode = aNode;
+                aNode = aNodes.pop();
+                bNode = bNodes.pop();
+              }
+              return sharedNode;
+            }
+            d3.layout.chord = function() {
+              var chord = {}, chords, groups, matrix, n2, padding = 0, sortGroups, sortSubgroups, sortChords;
+              function relayout() {
+                var subgroups = {}, groupSums = [], groupIndex = d3.range(n2), subgroupIndex = [], k2, x2, x0, i2, j2;
+                chords = [];
+                groups = [];
+                k2 = 0, i2 = -1;
+                while (++i2 < n2) {
+                  x2 = 0, j2 = -1;
+                  while (++j2 < n2) {
+                    x2 += matrix[i2][j2];
+                  }
+                  groupSums.push(x2);
+                  subgroupIndex.push(d3.range(n2));
+                  k2 += x2;
+                }
+                if (sortGroups) {
+                  groupIndex.sort(function(a2, b2) {
+                    return sortGroups(groupSums[a2], groupSums[b2]);
+                  });
+                }
+                if (sortSubgroups) {
+                  subgroupIndex.forEach(function(d2, i22) {
+                    d2.sort(function(a2, b2) {
+                      return sortSubgroups(matrix[i22][a2], matrix[i22][b2]);
+                    });
+                  });
+                }
+                k2 = (τ - padding * n2) / k2;
+                x2 = 0, i2 = -1;
+                while (++i2 < n2) {
+                  x0 = x2, j2 = -1;
+                  while (++j2 < n2) {
+                    var di2 = groupIndex[i2], dj2 = subgroupIndex[di2][j2], v2 = matrix[di2][dj2], a0 = x2, a1 = x2 += v2 * k2;
+                    subgroups[di2 + "-" + dj2] = {
+                      index: di2,
+                      subindex: dj2,
+                      startAngle: a0,
+                      endAngle: a1,
+                      value: v2
+                    };
+                  }
+                  groups[di2] = {
+                    index: di2,
+                    startAngle: x0,
+                    endAngle: x2,
+                    value: groupSums[di2]
+                  };
+                  x2 += padding;
+                }
+                i2 = -1;
+                while (++i2 < n2) {
+                  j2 = i2 - 1;
+                  while (++j2 < n2) {
+                    var source2 = subgroups[i2 + "-" + j2], target = subgroups[j2 + "-" + i2];
+                    if (source2.value || target.value) {
+                      chords.push(source2.value < target.value ? {
+                        source: target,
+                        target: source2
+                      } : {
+                        source: source2,
+                        target
+                      });
+                    }
+                  }
+                }
+                if (sortChords) resort();
+              }
+              function resort() {
+                chords.sort(function(a2, b2) {
+                  return sortChords((a2.source.value + a2.target.value) / 2, (b2.source.value + b2.target.value) / 2);
+                });
+              }
+              chord.matrix = function(x2) {
+                if (!arguments.length) return matrix;
+                n2 = (matrix = x2) && matrix.length;
+                chords = groups = null;
+                return chord;
+              };
+              chord.padding = function(x2) {
+                if (!arguments.length) return padding;
+                padding = x2;
+                chords = groups = null;
+                return chord;
+              };
+              chord.sortGroups = function(x2) {
+                if (!arguments.length) return sortGroups;
+                sortGroups = x2;
+                chords = groups = null;
+                return chord;
+              };
+              chord.sortSubgroups = function(x2) {
+                if (!arguments.length) return sortSubgroups;
+                sortSubgroups = x2;
+                chords = null;
+                return chord;
+              };
+              chord.sortChords = function(x2) {
+                if (!arguments.length) return sortChords;
+                sortChords = x2;
+                if (chords) resort();
+                return chord;
+              };
+              chord.chords = function() {
+                if (!chords) relayout();
+                return chords;
+              };
+              chord.groups = function() {
+                if (!groups) relayout();
+                return groups;
+              };
+              return chord;
+            };
+            d3.layout.force = function() {
+              var force = {}, event = d3.dispatch("start", "tick", "end"), timer, size = [1, 1], drag, alpha, friction = 0.9, linkDistance = d3_layout_forceLinkDistance, linkStrength = d3_layout_forceLinkStrength, charge = -30, chargeDistance2 = d3_layout_forceChargeDistance2, gravity = 0.1, theta2 = 0.64, nodes = [], links = [], distances, strengths, charges;
+              function repulse(node) {
+                return function(quad, x1, _2, x2) {
+                  if (quad.point !== node) {
+                    var dx = quad.cx - node.x, dy = quad.cy - node.y, dw = x2 - x1, dn = dx * dx + dy * dy;
+                    if (dw * dw / theta2 < dn) {
+                      if (dn < chargeDistance2) {
+                        var k2 = quad.charge / dn;
+                        node.px -= dx * k2;
+                        node.py -= dy * k2;
+                      }
+                      return true;
+                    }
+                    if (quad.point && dn && dn < chargeDistance2) {
+                      var k2 = quad.pointCharge / dn;
+                      node.px -= dx * k2;
+                      node.py -= dy * k2;
+                    }
+                  }
+                  return !quad.charge;
+                };
+              }
+              force.tick = function() {
+                if ((alpha *= 0.99) < 5e-3) {
+                  timer = null;
+                  event.end({
+                    type: "end",
+                    alpha: alpha = 0
+                  });
+                  return true;
+                }
+                var n2 = nodes.length, m2 = links.length, q2, i2, o2, s2, t4, l2, k2, x2, y2;
+                for (i2 = 0; i2 < m2; ++i2) {
+                  o2 = links[i2];
+                  s2 = o2.source;
+                  t4 = o2.target;
+                  x2 = t4.x - s2.x;
+                  y2 = t4.y - s2.y;
+                  if (l2 = x2 * x2 + y2 * y2) {
+                    l2 = alpha * strengths[i2] * ((l2 = Math.sqrt(l2)) - distances[i2]) / l2;
+                    x2 *= l2;
+                    y2 *= l2;
+                    t4.x -= x2 * (k2 = s2.weight + t4.weight ? s2.weight / (s2.weight + t4.weight) : 0.5);
+                    t4.y -= y2 * k2;
+                    s2.x += x2 * (k2 = 1 - k2);
+                    s2.y += y2 * k2;
+                  }
+                }
+                if (k2 = alpha * gravity) {
+                  x2 = size[0] / 2;
+                  y2 = size[1] / 2;
+                  i2 = -1;
+                  if (k2) while (++i2 < n2) {
+                    o2 = nodes[i2];
+                    o2.x += (x2 - o2.x) * k2;
+                    o2.y += (y2 - o2.y) * k2;
+                  }
+                }
+                if (charge) {
+                  d3_layout_forceAccumulate(q2 = d3.geom.quadtree(nodes), alpha, charges);
+                  i2 = -1;
+                  while (++i2 < n2) {
+                    if (!(o2 = nodes[i2]).fixed) {
+                      q2.visit(repulse(o2));
+                    }
+                  }
+                }
+                i2 = -1;
+                while (++i2 < n2) {
+                  o2 = nodes[i2];
+                  if (o2.fixed) {
+                    o2.x = o2.px;
+                    o2.y = o2.py;
+                  } else {
+                    o2.x -= (o2.px - (o2.px = o2.x)) * friction;
+                    o2.y -= (o2.py - (o2.py = o2.y)) * friction;
+                  }
+                }
+                event.tick({
+                  type: "tick",
+                  alpha
+                });
+              };
+              force.nodes = function(x2) {
+                if (!arguments.length) return nodes;
+                nodes = x2;
+                return force;
+              };
+              force.links = function(x2) {
+                if (!arguments.length) return links;
+                links = x2;
+                return force;
+              };
+              force.size = function(x2) {
+                if (!arguments.length) return size;
+                size = x2;
+                return force;
+              };
+              force.linkDistance = function(x2) {
+                if (!arguments.length) return linkDistance;
+                linkDistance = typeof x2 === "function" ? x2 : +x2;
+                return force;
+              };
+              force.distance = force.linkDistance;
+              force.linkStrength = function(x2) {
+                if (!arguments.length) return linkStrength;
+                linkStrength = typeof x2 === "function" ? x2 : +x2;
+                return force;
+              };
+              force.friction = function(x2) {
+                if (!arguments.length) return friction;
+                friction = +x2;
+                return force;
+              };
+              force.charge = function(x2) {
+                if (!arguments.length) return charge;
+                charge = typeof x2 === "function" ? x2 : +x2;
+                return force;
+              };
+              force.chargeDistance = function(x2) {
+                if (!arguments.length) return Math.sqrt(chargeDistance2);
+                chargeDistance2 = x2 * x2;
+                return force;
+              };
+              force.gravity = function(x2) {
+                if (!arguments.length) return gravity;
+                gravity = +x2;
+                return force;
+              };
+              force.theta = function(x2) {
+                if (!arguments.length) return Math.sqrt(theta2);
+                theta2 = x2 * x2;
+                return force;
+              };
+              force.alpha = function(x2) {
+                if (!arguments.length) return alpha;
+                x2 = +x2;
+                if (alpha) {
+                  if (x2 > 0) {
+                    alpha = x2;
+                  } else {
+                    timer.c = null, timer.t = NaN, timer = null;
+                    event.end({
+                      type: "end",
+                      alpha: alpha = 0
+                    });
+                  }
+                } else if (x2 > 0) {
+                  event.start({
+                    type: "start",
+                    alpha: alpha = x2
+                  });
+                  timer = d3_timer(force.tick);
+                }
+                return force;
+              };
+              force.start = function() {
+                var i2, n2 = nodes.length, m2 = links.length, w2 = size[0], h2 = size[1], neighbors, o2;
+                for (i2 = 0; i2 < n2; ++i2) {
+                  (o2 = nodes[i2]).index = i2;
+                  o2.weight = 0;
+                }
+                for (i2 = 0; i2 < m2; ++i2) {
+                  o2 = links[i2];
+                  if (typeof o2.source == "number") o2.source = nodes[o2.source];
+                  if (typeof o2.target == "number") o2.target = nodes[o2.target];
+                  ++o2.source.weight;
+                  ++o2.target.weight;
+                }
+                for (i2 = 0; i2 < n2; ++i2) {
+                  o2 = nodes[i2];
+                  if (isNaN(o2.x)) o2.x = position("x", w2);
+                  if (isNaN(o2.y)) o2.y = position("y", h2);
+                  if (isNaN(o2.px)) o2.px = o2.x;
+                  if (isNaN(o2.py)) o2.py = o2.y;
+                }
+                distances = [];
+                if (typeof linkDistance === "function") for (i2 = 0; i2 < m2; ++i2) distances[i2] = +linkDistance.call(this, links[i2], i2);
+                else for (i2 = 0; i2 < m2; ++i2) distances[i2] = linkDistance;
+                strengths = [];
+                if (typeof linkStrength === "function") for (i2 = 0; i2 < m2; ++i2) strengths[i2] = +linkStrength.call(this, links[i2], i2);
+                else for (i2 = 0; i2 < m2; ++i2) strengths[i2] = linkStrength;
+                charges = [];
+                if (typeof charge === "function") for (i2 = 0; i2 < n2; ++i2) charges[i2] = +charge.call(this, nodes[i2], i2);
+                else for (i2 = 0; i2 < n2; ++i2) charges[i2] = charge;
+                function position(dimension, size2) {
+                  if (!neighbors) {
+                    neighbors = new Array(n2);
+                    for (j2 = 0; j2 < n2; ++j2) {
+                      neighbors[j2] = [];
+                    }
+                    for (j2 = 0; j2 < m2; ++j2) {
+                      var o22 = links[j2];
+                      neighbors[o22.source.index].push(o22.target);
+                      neighbors[o22.target.index].push(o22.source);
+                    }
+                  }
+                  var candidates = neighbors[i2], j2 = -1, l2 = candidates.length, x2;
+                  while (++j2 < l2) if (!isNaN(x2 = candidates[j2][dimension])) return x2;
+                  return Math.random() * size2;
+                }
+                return force.resume();
+              };
+              force.resume = function() {
+                return force.alpha(0.1);
+              };
+              force.stop = function() {
+                return force.alpha(0);
+              };
+              force.drag = function() {
+                if (!drag) drag = d3.behavior.drag().origin(d3_identity).on("dragstart.force", d3_layout_forceDragstart).on("drag.force", dragmove).on("dragend.force", d3_layout_forceDragend);
+                if (!arguments.length) return drag;
+                this.on("mouseover.force", d3_layout_forceMouseover).on("mouseout.force", d3_layout_forceMouseout).call(drag);
+              };
+              function dragmove(d2) {
+                d2.px = d3.event.x, d2.py = d3.event.y;
+                force.resume();
+              }
+              return d3.rebind(force, event, "on");
+            };
+            function d3_layout_forceDragstart(d2) {
+              d2.fixed |= 2;
+            }
+            function d3_layout_forceDragend(d2) {
+              d2.fixed &= -7;
+            }
+            function d3_layout_forceMouseover(d2) {
+              d2.fixed |= 4;
+              d2.px = d2.x, d2.py = d2.y;
+            }
+            function d3_layout_forceMouseout(d2) {
+              d2.fixed &= -5;
+            }
+            function d3_layout_forceAccumulate(quad, alpha, charges) {
+              var cx = 0, cy = 0;
+              quad.charge = 0;
+              if (!quad.leaf) {
+                var nodes = quad.nodes, n2 = nodes.length, i2 = -1, c2;
+                while (++i2 < n2) {
+                  c2 = nodes[i2];
+                  if (c2 == null) continue;
+                  d3_layout_forceAccumulate(c2, alpha, charges);
+                  quad.charge += c2.charge;
+                  cx += c2.charge * c2.cx;
+                  cy += c2.charge * c2.cy;
+                }
+              }
+              if (quad.point) {
+                if (!quad.leaf) {
+                  quad.point.x += Math.random() - 0.5;
+                  quad.point.y += Math.random() - 0.5;
+                }
+                var k2 = alpha * charges[quad.point.index];
+                quad.charge += quad.pointCharge = k2;
+                cx += k2 * quad.point.x;
+                cy += k2 * quad.point.y;
+              }
+              quad.cx = cx / quad.charge;
+              quad.cy = cy / quad.charge;
+            }
+            var d3_layout_forceLinkDistance = 20, d3_layout_forceLinkStrength = 1, d3_layout_forceChargeDistance2 = Infinity;
+            d3.layout.hierarchy = function() {
+              var sort = d3_layout_hierarchySort, children = d3_layout_hierarchyChildren, value = d3_layout_hierarchyValue;
+              function hierarchy(root) {
+                var stack = [root], nodes = [], node;
+                root.depth = 0;
+                while ((node = stack.pop()) != null) {
+                  nodes.push(node);
+                  if ((childs = children.call(hierarchy, node, node.depth)) && (n2 = childs.length)) {
+                    var n2, childs, child;
+                    while (--n2 >= 0) {
+                      stack.push(child = childs[n2]);
+                      child.parent = node;
+                      child.depth = node.depth + 1;
+                    }
+                    if (value) node.value = 0;
+                    node.children = childs;
+                  } else {
+                    if (value) node.value = +value.call(hierarchy, node, node.depth) || 0;
+                    delete node.children;
+                  }
+                }
+                d3_layout_hierarchyVisitAfter(root, function(node2) {
+                  var childs2, parent;
+                  if (sort && (childs2 = node2.children)) childs2.sort(sort);
+                  if (value && (parent = node2.parent)) parent.value += node2.value;
+                });
+                return nodes;
+              }
+              hierarchy.sort = function(x2) {
+                if (!arguments.length) return sort;
+                sort = x2;
+                return hierarchy;
+              };
+              hierarchy.children = function(x2) {
+                if (!arguments.length) return children;
+                children = x2;
+                return hierarchy;
+              };
+              hierarchy.value = function(x2) {
+                if (!arguments.length) return value;
+                value = x2;
+                return hierarchy;
+              };
+              hierarchy.revalue = function(root) {
+                if (value) {
+                  d3_layout_hierarchyVisitBefore(root, function(node) {
+                    if (node.children) node.value = 0;
+                  });
+                  d3_layout_hierarchyVisitAfter(root, function(node) {
+                    var parent;
+                    if (!node.children) node.value = +value.call(hierarchy, node, node.depth) || 0;
+                    if (parent = node.parent) parent.value += node.value;
+                  });
+                }
+                return root;
+              };
+              return hierarchy;
+            };
+            function d3_layout_hierarchyRebind(object, hierarchy) {
+              d3.rebind(object, hierarchy, "sort", "children", "value");
+              object.nodes = object;
+              object.links = d3_layout_hierarchyLinks;
+              return object;
+            }
+            function d3_layout_hierarchyVisitBefore(node, callback) {
+              var nodes = [node];
+              while ((node = nodes.pop()) != null) {
+                callback(node);
+                if ((children = node.children) && (n2 = children.length)) {
+                  var n2, children;
+                  while (--n2 >= 0) nodes.push(children[n2]);
+                }
+              }
+            }
+            function d3_layout_hierarchyVisitAfter(node, callback) {
+              var nodes = [node], nodes2 = [];
+              while ((node = nodes.pop()) != null) {
+                nodes2.push(node);
+                if ((children = node.children) && (n2 = children.length)) {
+                  var i2 = -1, n2, children;
+                  while (++i2 < n2) nodes.push(children[i2]);
+                }
+              }
+              while ((node = nodes2.pop()) != null) {
+                callback(node);
+              }
+            }
+            function d3_layout_hierarchyChildren(d2) {
+              return d2.children;
+            }
+            function d3_layout_hierarchyValue(d2) {
+              return d2.value;
+            }
+            function d3_layout_hierarchySort(a2, b2) {
+              return b2.value - a2.value;
+            }
+            function d3_layout_hierarchyLinks(nodes) {
+              return d3.merge(nodes.map(function(parent) {
+                return (parent.children || []).map(function(child) {
+                  return {
+                    source: parent,
+                    target: child
+                  };
+                });
+              }));
+            }
+            d3.layout.partition = function() {
+              var hierarchy = d3.layout.hierarchy(), size = [1, 1];
+              function position(node, x2, dx, dy) {
+                var children = node.children;
+                node.x = x2;
+                node.y = node.depth * dy;
+                node.dx = dx;
+                node.dy = dy;
+                if (children && (n2 = children.length)) {
+                  var i2 = -1, n2, c2, d2;
+                  dx = node.value ? dx / node.value : 0;
+                  while (++i2 < n2) {
+                    position(c2 = children[i2], x2, d2 = c2.value * dx, dy);
+                    x2 += d2;
+                  }
+                }
+              }
+              function depth(node) {
+                var children = node.children, d2 = 0;
+                if (children && (n2 = children.length)) {
+                  var i2 = -1, n2;
+                  while (++i2 < n2) d2 = Math.max(d2, depth(children[i2]));
+                }
+                return 1 + d2;
+              }
+              function partition(d2, i2) {
+                var nodes = hierarchy.call(this, d2, i2);
+                position(nodes[0], 0, size[0], size[1] / depth(nodes[0]));
+                return nodes;
+              }
+              partition.size = function(x2) {
+                if (!arguments.length) return size;
+                size = x2;
+                return partition;
+              };
+              return d3_layout_hierarchyRebind(partition, hierarchy);
+            };
+            d3.layout.pie = function() {
+              var value = Number, sort = d3_layout_pieSortByValue, startAngle = 0, endAngle = τ, padAngle = 0;
+              function pie(data) {
+                var n2 = data.length, values = data.map(function(d2, i2) {
+                  return +value.call(pie, d2, i2);
+                }), a2 = +(typeof startAngle === "function" ? startAngle.apply(this, arguments) : startAngle), da2 = (typeof endAngle === "function" ? endAngle.apply(this, arguments) : endAngle) - a2, p2 = Math.min(Math.abs(da2) / n2, +(typeof padAngle === "function" ? padAngle.apply(this, arguments) : padAngle)), pa2 = p2 * (da2 < 0 ? -1 : 1), sum = d3.sum(values), k2 = sum ? (da2 - n2 * pa2) / sum : 0, index = d3.range(n2), arcs = [], v2;
+                if (sort != null) index.sort(sort === d3_layout_pieSortByValue ? function(i2, j2) {
+                  return values[j2] - values[i2];
+                } : function(i2, j2) {
+                  return sort(data[i2], data[j2]);
+                });
+                index.forEach(function(i2) {
+                  arcs[i2] = {
+                    data: data[i2],
+                    value: v2 = values[i2],
+                    startAngle: a2,
+                    endAngle: a2 += v2 * k2 + pa2,
+                    padAngle: p2
+                  };
+                });
+                return arcs;
+              }
+              pie.value = function(_2) {
+                if (!arguments.length) return value;
+                value = _2;
+                return pie;
+              };
+              pie.sort = function(_2) {
+                if (!arguments.length) return sort;
+                sort = _2;
+                return pie;
+              };
+              pie.startAngle = function(_2) {
+                if (!arguments.length) return startAngle;
+                startAngle = _2;
+                return pie;
+              };
+              pie.endAngle = function(_2) {
+                if (!arguments.length) return endAngle;
+                endAngle = _2;
+                return pie;
+              };
+              pie.padAngle = function(_2) {
+                if (!arguments.length) return padAngle;
+                padAngle = _2;
+                return pie;
+              };
+              return pie;
+            };
+            var d3_layout_pieSortByValue = {};
+            d3.layout.stack = function() {
+              var values = d3_identity, order = d3_layout_stackOrderDefault, offset = d3_layout_stackOffsetZero, out = d3_layout_stackOut, x2 = d3_layout_stackX, y2 = d3_layout_stackY;
+              function stack(data, index) {
+                if (!(n2 = data.length)) return data;
+                var series = data.map(function(d2, i22) {
+                  return values.call(stack, d2, i22);
+                });
+                var points = series.map(function(d2) {
+                  return d2.map(function(v2, i22) {
+                    return [x2.call(stack, v2, i22), y2.call(stack, v2, i22)];
+                  });
+                });
+                var orders = order.call(stack, points, index);
+                series = d3.permute(series, orders);
+                points = d3.permute(points, orders);
+                var offsets = offset.call(stack, points, index);
+                var m2 = series[0].length, n2, i2, j2, o2;
+                for (j2 = 0; j2 < m2; ++j2) {
+                  out.call(stack, series[0][j2], o2 = offsets[j2], points[0][j2][1]);
+                  for (i2 = 1; i2 < n2; ++i2) {
+                    out.call(stack, series[i2][j2], o2 += points[i2 - 1][j2][1], points[i2][j2][1]);
+                  }
+                }
+                return data;
+              }
+              stack.values = function(x22) {
+                if (!arguments.length) return values;
+                values = x22;
+                return stack;
+              };
+              stack.order = function(x22) {
+                if (!arguments.length) return order;
+                order = typeof x22 === "function" ? x22 : d3_layout_stackOrders.get(x22) || d3_layout_stackOrderDefault;
+                return stack;
+              };
+              stack.offset = function(x22) {
+                if (!arguments.length) return offset;
+                offset = typeof x22 === "function" ? x22 : d3_layout_stackOffsets.get(x22) || d3_layout_stackOffsetZero;
+                return stack;
+              };
+              stack.x = function(z2) {
+                if (!arguments.length) return x2;
+                x2 = z2;
+                return stack;
+              };
+              stack.y = function(z2) {
+                if (!arguments.length) return y2;
+                y2 = z2;
+                return stack;
+              };
+              stack.out = function(z2) {
+                if (!arguments.length) return out;
+                out = z2;
+                return stack;
+              };
+              return stack;
+            };
+            function d3_layout_stackX(d2) {
+              return d2.x;
+            }
+            function d3_layout_stackY(d2) {
+              return d2.y;
+            }
+            function d3_layout_stackOut(d2, y0, y2) {
+              d2.y0 = y0;
+              d2.y = y2;
+            }
+            var d3_layout_stackOrders = d3.map({
+              "inside-out": function(data) {
+                var n2 = data.length, i2, j2, max = data.map(d3_layout_stackMaxIndex), sums = data.map(d3_layout_stackReduceSum), index = d3.range(n2).sort(function(a2, b2) {
+                  return max[a2] - max[b2];
+                }), top = 0, bottom = 0, tops = [], bottoms = [];
+                for (i2 = 0; i2 < n2; ++i2) {
+                  j2 = index[i2];
+                  if (top < bottom) {
+                    top += sums[j2];
+                    tops.push(j2);
+                  } else {
+                    bottom += sums[j2];
+                    bottoms.push(j2);
+                  }
+                }
+                return bottoms.reverse().concat(tops);
+              },
+              reverse: function(data) {
+                return d3.range(data.length).reverse();
+              },
+              "default": d3_layout_stackOrderDefault
+            });
+            var d3_layout_stackOffsets = d3.map({
+              silhouette: function(data) {
+                var n2 = data.length, m2 = data[0].length, sums = [], max = 0, i2, j2, o2, y0 = [];
+                for (j2 = 0; j2 < m2; ++j2) {
+                  for (i2 = 0, o2 = 0; i2 < n2; i2++) o2 += data[i2][j2][1];
+                  if (o2 > max) max = o2;
+                  sums.push(o2);
+                }
+                for (j2 = 0; j2 < m2; ++j2) {
+                  y0[j2] = (max - sums[j2]) / 2;
+                }
+                return y0;
+              },
+              wiggle: function(data) {
+                var n2 = data.length, x2 = data[0], m2 = x2.length, i2, j2, k2, s1, s2, s3, dx, o2, o0, y0 = [];
+                y0[0] = o2 = o0 = 0;
+                for (j2 = 1; j2 < m2; ++j2) {
+                  for (i2 = 0, s1 = 0; i2 < n2; ++i2) s1 += data[i2][j2][1];
+                  for (i2 = 0, s2 = 0, dx = x2[j2][0] - x2[j2 - 1][0]; i2 < n2; ++i2) {
+                    for (k2 = 0, s3 = (data[i2][j2][1] - data[i2][j2 - 1][1]) / (2 * dx); k2 < i2; ++k2) {
+                      s3 += (data[k2][j2][1] - data[k2][j2 - 1][1]) / dx;
+                    }
+                    s2 += s3 * data[i2][j2][1];
+                  }
+                  y0[j2] = o2 -= s1 ? s2 / s1 * dx : 0;
+                  if (o2 < o0) o0 = o2;
+                }
+                for (j2 = 0; j2 < m2; ++j2) y0[j2] -= o0;
+                return y0;
+              },
+              expand: function(data) {
+                var n2 = data.length, m2 = data[0].length, k2 = 1 / n2, i2, j2, o2, y0 = [];
+                for (j2 = 0; j2 < m2; ++j2) {
+                  for (i2 = 0, o2 = 0; i2 < n2; i2++) o2 += data[i2][j2][1];
+                  if (o2) for (i2 = 0; i2 < n2; i2++) data[i2][j2][1] /= o2;
+                  else for (i2 = 0; i2 < n2; i2++) data[i2][j2][1] = k2;
+                }
+                for (j2 = 0; j2 < m2; ++j2) y0[j2] = 0;
+                return y0;
+              },
+              zero: d3_layout_stackOffsetZero
+            });
+            function d3_layout_stackOrderDefault(data) {
+              return d3.range(data.length);
+            }
+            function d3_layout_stackOffsetZero(data) {
+              var j2 = -1, m2 = data[0].length, y0 = [];
+              while (++j2 < m2) y0[j2] = 0;
+              return y0;
+            }
+            function d3_layout_stackMaxIndex(array) {
+              var i2 = 1, j2 = 0, v2 = array[0][1], k2, n2 = array.length;
+              for (; i2 < n2; ++i2) {
+                if ((k2 = array[i2][1]) > v2) {
+                  j2 = i2;
+                  v2 = k2;
+                }
+              }
+              return j2;
+            }
+            function d3_layout_stackReduceSum(d2) {
+              return d2.reduce(d3_layout_stackSum, 0);
+            }
+            function d3_layout_stackSum(p2, d2) {
+              return p2 + d2[1];
+            }
+            d3.layout.histogram = function() {
+              var frequency = true, valuer = Number, ranger = d3_layout_histogramRange, binner = d3_layout_histogramBinSturges;
+              function histogram(data, i2) {
+                var bins = [], values = data.map(valuer, this), range = ranger.call(this, values, i2), thresholds = binner.call(this, range, values, i2), bin, i2 = -1, n2 = values.length, m2 = thresholds.length - 1, k2 = frequency ? 1 : 1 / n2, x2;
+                while (++i2 < m2) {
+                  bin = bins[i2] = [];
+                  bin.dx = thresholds[i2 + 1] - (bin.x = thresholds[i2]);
+                  bin.y = 0;
+                }
+                if (m2 > 0) {
+                  i2 = -1;
+                  while (++i2 < n2) {
+                    x2 = values[i2];
+                    if (x2 >= range[0] && x2 <= range[1]) {
+                      bin = bins[d3.bisect(thresholds, x2, 1, m2) - 1];
+                      bin.y += k2;
+                      bin.push(data[i2]);
+                    }
+                  }
+                }
+                return bins;
+              }
+              histogram.value = function(x2) {
+                if (!arguments.length) return valuer;
+                valuer = x2;
+                return histogram;
+              };
+              histogram.range = function(x2) {
+                if (!arguments.length) return ranger;
+                ranger = d3_functor(x2);
+                return histogram;
+              };
+              histogram.bins = function(x2) {
+                if (!arguments.length) return binner;
+                binner = typeof x2 === "number" ? function(range) {
+                  return d3_layout_histogramBinFixed(range, x2);
+                } : d3_functor(x2);
+                return histogram;
+              };
+              histogram.frequency = function(x2) {
+                if (!arguments.length) return frequency;
+                frequency = !!x2;
+                return histogram;
+              };
+              return histogram;
+            };
+            function d3_layout_histogramBinSturges(range, values) {
+              return d3_layout_histogramBinFixed(range, Math.ceil(Math.log(values.length) / Math.LN2 + 1));
+            }
+            function d3_layout_histogramBinFixed(range, n2) {
+              var x2 = -1, b2 = +range[0], m2 = (range[1] - b2) / n2, f2 = [];
+              while (++x2 <= n2) f2[x2] = m2 * x2 + b2;
+              return f2;
+            }
+            function d3_layout_histogramRange(values) {
+              return [d3.min(values), d3.max(values)];
+            }
+            d3.layout.pack = function() {
+              var hierarchy = d3.layout.hierarchy().sort(d3_layout_packSort), padding = 0, size = [1, 1], radius;
+              function pack(d2, i2) {
+                var nodes = hierarchy.call(this, d2, i2), root = nodes[0], w2 = size[0], h2 = size[1], r2 = radius == null ? Math.sqrt : typeof radius === "function" ? radius : function() {
+                  return radius;
+                };
+                root.x = root.y = 0;
+                d3_layout_hierarchyVisitAfter(root, function(d22) {
+                  d22.r = +r2(d22.value);
+                });
+                d3_layout_hierarchyVisitAfter(root, d3_layout_packSiblings);
+                if (padding) {
+                  var dr = padding * (radius ? 1 : Math.max(2 * root.r / w2, 2 * root.r / h2)) / 2;
+                  d3_layout_hierarchyVisitAfter(root, function(d22) {
+                    d22.r += dr;
+                  });
+                  d3_layout_hierarchyVisitAfter(root, d3_layout_packSiblings);
+                  d3_layout_hierarchyVisitAfter(root, function(d22) {
+                    d22.r -= dr;
+                  });
+                }
+                d3_layout_packTransform(root, w2 / 2, h2 / 2, radius ? 1 : 1 / Math.max(2 * root.r / w2, 2 * root.r / h2));
+                return nodes;
+              }
+              pack.size = function(_2) {
+                if (!arguments.length) return size;
+                size = _2;
+                return pack;
+              };
+              pack.radius = function(_2) {
+                if (!arguments.length) return radius;
+                radius = _2 == null || typeof _2 === "function" ? _2 : +_2;
+                return pack;
+              };
+              pack.padding = function(_2) {
+                if (!arguments.length) return padding;
+                padding = +_2;
+                return pack;
+              };
+              return d3_layout_hierarchyRebind(pack, hierarchy);
+            };
+            function d3_layout_packSort(a2, b2) {
+              return a2.value - b2.value;
+            }
+            function d3_layout_packInsert(a2, b2) {
+              var c2 = a2._pack_next;
+              a2._pack_next = b2;
+              b2._pack_prev = a2;
+              b2._pack_next = c2;
+              c2._pack_prev = b2;
+            }
+            function d3_layout_packSplice(a2, b2) {
+              a2._pack_next = b2;
+              b2._pack_prev = a2;
+            }
+            function d3_layout_packIntersects(a2, b2) {
+              var dx = b2.x - a2.x, dy = b2.y - a2.y, dr = a2.r + b2.r;
+              return 0.999 * dr * dr > dx * dx + dy * dy;
+            }
+            function d3_layout_packSiblings(node) {
+              if (!(nodes = node.children) || !(n2 = nodes.length)) return;
+              var nodes, xMin = Infinity, xMax = -Infinity, yMin = Infinity, yMax = -Infinity, a2, b2, c2, i2, j2, k2, n2;
+              function bound(node2) {
+                xMin = Math.min(node2.x - node2.r, xMin);
+                xMax = Math.max(node2.x + node2.r, xMax);
+                yMin = Math.min(node2.y - node2.r, yMin);
+                yMax = Math.max(node2.y + node2.r, yMax);
+              }
+              nodes.forEach(d3_layout_packLink);
+              a2 = nodes[0];
+              a2.x = -a2.r;
+              a2.y = 0;
+              bound(a2);
+              if (n2 > 1) {
+                b2 = nodes[1];
+                b2.x = b2.r;
+                b2.y = 0;
+                bound(b2);
+                if (n2 > 2) {
+                  c2 = nodes[2];
+                  d3_layout_packPlace(a2, b2, c2);
+                  bound(c2);
+                  d3_layout_packInsert(a2, c2);
+                  a2._pack_prev = c2;
+                  d3_layout_packInsert(c2, b2);
+                  b2 = a2._pack_next;
+                  for (i2 = 3; i2 < n2; i2++) {
+                    d3_layout_packPlace(a2, b2, c2 = nodes[i2]);
+                    var isect = 0, s1 = 1, s2 = 1;
+                    for (j2 = b2._pack_next; j2 !== b2; j2 = j2._pack_next, s1++) {
+                      if (d3_layout_packIntersects(j2, c2)) {
+                        isect = 1;
+                        break;
+                      }
+                    }
+                    if (isect == 1) {
+                      for (k2 = a2._pack_prev; k2 !== j2._pack_prev; k2 = k2._pack_prev, s2++) {
+                        if (d3_layout_packIntersects(k2, c2)) {
+                          break;
+                        }
+                      }
+                    }
+                    if (isect) {
+                      if (s1 < s2 || s1 == s2 && b2.r < a2.r) d3_layout_packSplice(a2, b2 = j2);
+                      else d3_layout_packSplice(a2 = k2, b2);
+                      i2--;
+                    } else {
+                      d3_layout_packInsert(a2, c2);
+                      b2 = c2;
+                      bound(c2);
+                    }
+                  }
+                }
+              }
+              var cx = (xMin + xMax) / 2, cy = (yMin + yMax) / 2, cr = 0;
+              for (i2 = 0; i2 < n2; i2++) {
+                c2 = nodes[i2];
+                c2.x -= cx;
+                c2.y -= cy;
+                cr = Math.max(cr, c2.r + Math.sqrt(c2.x * c2.x + c2.y * c2.y));
+              }
+              node.r = cr;
+              nodes.forEach(d3_layout_packUnlink);
+            }
+            function d3_layout_packLink(node) {
+              node._pack_next = node._pack_prev = node;
+            }
+            function d3_layout_packUnlink(node) {
+              delete node._pack_next;
+              delete node._pack_prev;
+            }
+            function d3_layout_packTransform(node, x2, y2, k2) {
+              var children = node.children;
+              node.x = x2 += k2 * node.x;
+              node.y = y2 += k2 * node.y;
+              node.r *= k2;
+              if (children) {
+                var i2 = -1, n2 = children.length;
+                while (++i2 < n2) d3_layout_packTransform(children[i2], x2, y2, k2);
+              }
+            }
+            function d3_layout_packPlace(a2, b2, c2) {
+              var db2 = a2.r + c2.r, dx = b2.x - a2.x, dy = b2.y - a2.y;
+              if (db2 && (dx || dy)) {
+                var da2 = b2.r + c2.r, dc2 = dx * dx + dy * dy;
+                da2 *= da2;
+                db2 *= db2;
+                var x2 = 0.5 + (db2 - da2) / (2 * dc2), y2 = Math.sqrt(Math.max(0, 2 * da2 * (db2 + dc2) - (db2 -= dc2) * db2 - da2 * da2)) / (2 * dc2);
+                c2.x = a2.x + x2 * dx + y2 * dy;
+                c2.y = a2.y + x2 * dy - y2 * dx;
+              } else {
+                c2.x = a2.x + db2;
+                c2.y = a2.y;
+              }
+            }
+            d3.layout.tree = function() {
+              var hierarchy = d3.layout.hierarchy().sort(null).value(null), separation = d3_layout_treeSeparation, size = [1, 1], nodeSize = null;
+              function tree(d2, i2) {
+                var nodes = hierarchy.call(this, d2, i2), root0 = nodes[0], root1 = wrapTree(root0);
+                d3_layout_hierarchyVisitAfter(root1, firstWalk), root1.parent.m = -root1.z;
+                d3_layout_hierarchyVisitBefore(root1, secondWalk);
+                if (nodeSize) d3_layout_hierarchyVisitBefore(root0, sizeNode);
+                else {
+                  var left = root0, right = root0, bottom = root0;
+                  d3_layout_hierarchyVisitBefore(root0, function(node) {
+                    if (node.x < left.x) left = node;
+                    if (node.x > right.x) right = node;
+                    if (node.depth > bottom.depth) bottom = node;
+                  });
+                  var tx = separation(left, right) / 2 - left.x, kx = size[0] / (right.x + separation(right, left) / 2 + tx), ky = size[1] / (bottom.depth || 1);
+                  d3_layout_hierarchyVisitBefore(root0, function(node) {
+                    node.x = (node.x + tx) * kx;
+                    node.y = node.depth * ky;
+                  });
+                }
+                return nodes;
+              }
+              function wrapTree(root0) {
+                var root1 = {
+                  A: null,
+                  children: [root0]
+                }, queue = [root1], node1;
+                while ((node1 = queue.pop()) != null) {
+                  for (var children = node1.children, child, i2 = 0, n2 = children.length; i2 < n2; ++i2) {
+                    queue.push((children[i2] = child = {
+                      _: children[i2],
+                      parent: node1,
+                      children: (child = children[i2].children) && child.slice() || [],
+                      A: null,
+                      a: null,
+                      z: 0,
+                      m: 0,
+                      c: 0,
+                      s: 0,
+                      t: null,
+                      i: i2
+                    }).a = child);
+                  }
+                }
+                return root1.children[0];
+              }
+              function firstWalk(v2) {
+                var children = v2.children, siblings = v2.parent.children, w2 = v2.i ? siblings[v2.i - 1] : null;
+                if (children.length) {
+                  d3_layout_treeShift(v2);
+                  var midpoint = (children[0].z + children[children.length - 1].z) / 2;
+                  if (w2) {
+                    v2.z = w2.z + separation(v2._, w2._);
+                    v2.m = v2.z - midpoint;
+                  } else {
+                    v2.z = midpoint;
+                  }
+                } else if (w2) {
+                  v2.z = w2.z + separation(v2._, w2._);
+                }
+                v2.parent.A = apportion(v2, w2, v2.parent.A || siblings[0]);
+              }
+              function secondWalk(v2) {
+                v2._.x = v2.z + v2.parent.m;
+                v2.m += v2.parent.m;
+              }
+              function apportion(v2, w2, ancestor) {
+                if (w2) {
+                  var vip = v2, vop = v2, vim = w2, vom = vip.parent.children[0], sip = vip.m, sop = vop.m, sim = vim.m, som = vom.m, shift;
+                  while (vim = d3_layout_treeRight(vim), vip = d3_layout_treeLeft(vip), vim && vip) {
+                    vom = d3_layout_treeLeft(vom);
+                    vop = d3_layout_treeRight(vop);
+                    vop.a = v2;
+                    shift = vim.z + sim - vip.z - sip + separation(vim._, vip._);
+                    if (shift > 0) {
+                      d3_layout_treeMove(d3_layout_treeAncestor(vim, v2, ancestor), v2, shift);
+                      sip += shift;
+                      sop += shift;
+                    }
+                    sim += vim.m;
+                    sip += vip.m;
+                    som += vom.m;
+                    sop += vop.m;
+                  }
+                  if (vim && !d3_layout_treeRight(vop)) {
+                    vop.t = vim;
+                    vop.m += sim - sop;
+                  }
+                  if (vip && !d3_layout_treeLeft(vom)) {
+                    vom.t = vip;
+                    vom.m += sip - som;
+                    ancestor = v2;
+                  }
+                }
+                return ancestor;
+              }
+              function sizeNode(node) {
+                node.x *= size[0];
+                node.y = node.depth * size[1];
+              }
+              tree.separation = function(x2) {
+                if (!arguments.length) return separation;
+                separation = x2;
+                return tree;
+              };
+              tree.size = function(x2) {
+                if (!arguments.length) return nodeSize ? null : size;
+                nodeSize = (size = x2) == null ? sizeNode : null;
+                return tree;
+              };
+              tree.nodeSize = function(x2) {
+                if (!arguments.length) return nodeSize ? size : null;
+                nodeSize = (size = x2) == null ? null : sizeNode;
+                return tree;
+              };
+              return d3_layout_hierarchyRebind(tree, hierarchy);
+            };
+            function d3_layout_treeSeparation(a2, b2) {
+              return a2.parent == b2.parent ? 1 : 2;
+            }
+            function d3_layout_treeLeft(v2) {
+              var children = v2.children;
+              return children.length ? children[0] : v2.t;
+            }
+            function d3_layout_treeRight(v2) {
+              var children = v2.children, n2;
+              return (n2 = children.length) ? children[n2 - 1] : v2.t;
+            }
+            function d3_layout_treeMove(wm, wp, shift) {
+              var change = shift / (wp.i - wm.i);
+              wp.c -= change;
+              wp.s += shift;
+              wm.c += change;
+              wp.z += shift;
+              wp.m += shift;
+            }
+            function d3_layout_treeShift(v2) {
+              var shift = 0, change = 0, children = v2.children, i2 = children.length, w2;
+              while (--i2 >= 0) {
+                w2 = children[i2];
+                w2.z += shift;
+                w2.m += shift;
+                shift += w2.s + (change += w2.c);
+              }
+            }
+            function d3_layout_treeAncestor(vim, v2, ancestor) {
+              return vim.a.parent === v2.parent ? vim.a : ancestor;
+            }
+            d3.layout.cluster = function() {
+              var hierarchy = d3.layout.hierarchy().sort(null).value(null), separation = d3_layout_treeSeparation, size = [1, 1], nodeSize = false;
+              function cluster(d2, i2) {
+                var nodes = hierarchy.call(this, d2, i2), root = nodes[0], previousNode, x2 = 0;
+                d3_layout_hierarchyVisitAfter(root, function(node) {
+                  var children = node.children;
+                  if (children && children.length) {
+                    node.x = d3_layout_clusterX(children);
+                    node.y = d3_layout_clusterY(children);
+                  } else {
+                    node.x = previousNode ? x2 += separation(node, previousNode) : 0;
+                    node.y = 0;
+                    previousNode = node;
+                  }
+                });
+                var left = d3_layout_clusterLeft(root), right = d3_layout_clusterRight(root), x0 = left.x - separation(left, right) / 2, x1 = right.x + separation(right, left) / 2;
+                d3_layout_hierarchyVisitAfter(root, nodeSize ? function(node) {
+                  node.x = (node.x - root.x) * size[0];
+                  node.y = (root.y - node.y) * size[1];
+                } : function(node) {
+                  node.x = (node.x - x0) / (x1 - x0) * size[0];
+                  node.y = (1 - (root.y ? node.y / root.y : 1)) * size[1];
+                });
+                return nodes;
+              }
+              cluster.separation = function(x2) {
+                if (!arguments.length) return separation;
+                separation = x2;
+                return cluster;
+              };
+              cluster.size = function(x2) {
+                if (!arguments.length) return nodeSize ? null : size;
+                nodeSize = (size = x2) == null;
+                return cluster;
+              };
+              cluster.nodeSize = function(x2) {
+                if (!arguments.length) return nodeSize ? size : null;
+                nodeSize = (size = x2) != null;
+                return cluster;
+              };
+              return d3_layout_hierarchyRebind(cluster, hierarchy);
+            };
+            function d3_layout_clusterY(children) {
+              return 1 + d3.max(children, function(child) {
+                return child.y;
+              });
+            }
+            function d3_layout_clusterX(children) {
+              return children.reduce(function(x2, child) {
+                return x2 + child.x;
+              }, 0) / children.length;
+            }
+            function d3_layout_clusterLeft(node) {
+              var children = node.children;
+              return children && children.length ? d3_layout_clusterLeft(children[0]) : node;
+            }
+            function d3_layout_clusterRight(node) {
+              var children = node.children, n2;
+              return children && (n2 = children.length) ? d3_layout_clusterRight(children[n2 - 1]) : node;
+            }
+            d3.layout.treemap = function() {
+              var hierarchy = d3.layout.hierarchy(), round2 = Math.round, size = [1, 1], padding = null, pad = d3_layout_treemapPadNull, sticky = false, stickies, mode = "squarify", ratio = 0.5 * (1 + Math.sqrt(5));
+              function scale2(children, k2) {
+                var i2 = -1, n2 = children.length, child, area;
+                while (++i2 < n2) {
+                  area = (child = children[i2]).value * (k2 < 0 ? 0 : k2);
+                  child.area = isNaN(area) || area <= 0 ? 0 : area;
+                }
+              }
+              function squarify(node) {
+                var children = node.children;
+                if (children && children.length) {
+                  var rect = pad(node), row = [], remaining = children.slice(), child, best = Infinity, score, u2 = mode === "slice" ? rect.dx : mode === "dice" ? rect.dy : mode === "slice-dice" ? node.depth & 1 ? rect.dy : rect.dx : Math.min(rect.dx, rect.dy), n2;
+                  scale2(remaining, rect.dx * rect.dy / node.value);
+                  row.area = 0;
+                  while ((n2 = remaining.length) > 0) {
+                    row.push(child = remaining[n2 - 1]);
+                    row.area += child.area;
+                    if (mode !== "squarify" || (score = worst(row, u2)) <= best) {
+                      remaining.pop();
+                      best = score;
+                    } else {
+                      row.area -= row.pop().area;
+                      position(row, u2, rect, false);
+                      u2 = Math.min(rect.dx, rect.dy);
+                      row.length = row.area = 0;
+                      best = Infinity;
+                    }
+                  }
+                  if (row.length) {
+                    position(row, u2, rect, true);
+                    row.length = row.area = 0;
+                  }
+                  children.forEach(squarify);
+                }
+              }
+              function stickify(node) {
+                var children = node.children;
+                if (children && children.length) {
+                  var rect = pad(node), remaining = children.slice(), child, row = [];
+                  scale2(remaining, rect.dx * rect.dy / node.value);
+                  row.area = 0;
+                  while (child = remaining.pop()) {
+                    row.push(child);
+                    row.area += child.area;
+                    if (child.z != null) {
+                      position(row, child.z ? rect.dx : rect.dy, rect, !remaining.length);
+                      row.length = row.area = 0;
+                    }
+                  }
+                  children.forEach(stickify);
+                }
+              }
+              function worst(row, u2) {
+                var s2 = row.area, r2, rmax = 0, rmin = Infinity, i2 = -1, n2 = row.length;
+                while (++i2 < n2) {
+                  if (!(r2 = row[i2].area)) continue;
+                  if (r2 < rmin) rmin = r2;
+                  if (r2 > rmax) rmax = r2;
+                }
+                s2 *= s2;
+                u2 *= u2;
+                return s2 ? Math.max(u2 * rmax * ratio / s2, s2 / (u2 * rmin * ratio)) : Infinity;
+              }
+              function position(row, u2, rect, flush) {
+                var i2 = -1, n2 = row.length, x2 = rect.x, y2 = rect.y, v2 = u2 ? round2(row.area / u2) : 0, o2;
+                if (u2 == rect.dx) {
+                  if (flush || v2 > rect.dy) v2 = rect.dy;
+                  while (++i2 < n2) {
+                    o2 = row[i2];
+                    o2.x = x2;
+                    o2.y = y2;
+                    o2.dy = v2;
+                    x2 += o2.dx = Math.min(rect.x + rect.dx - x2, v2 ? round2(o2.area / v2) : 0);
+                  }
+                  o2.z = true;
+                  o2.dx += rect.x + rect.dx - x2;
+                  rect.y += v2;
+                  rect.dy -= v2;
+                } else {
+                  if (flush || v2 > rect.dx) v2 = rect.dx;
+                  while (++i2 < n2) {
+                    o2 = row[i2];
+                    o2.x = x2;
+                    o2.y = y2;
+                    o2.dx = v2;
+                    y2 += o2.dy = Math.min(rect.y + rect.dy - y2, v2 ? round2(o2.area / v2) : 0);
+                  }
+                  o2.z = false;
+                  o2.dy += rect.y + rect.dy - y2;
+                  rect.x += v2;
+                  rect.dx -= v2;
+                }
+              }
+              function treemap(d2) {
+                var nodes = stickies || hierarchy(d2), root = nodes[0];
+                root.x = root.y = 0;
+                if (root.value) root.dx = size[0], root.dy = size[1];
+                else root.dx = root.dy = 0;
+                if (stickies) hierarchy.revalue(root);
+                scale2([root], root.dx * root.dy / root.value);
+                (stickies ? stickify : squarify)(root);
+                if (sticky) stickies = nodes;
+                return nodes;
+              }
+              treemap.size = function(x2) {
+                if (!arguments.length) return size;
+                size = x2;
+                return treemap;
+              };
+              treemap.padding = function(x2) {
+                if (!arguments.length) return padding;
+                function padFunction(node) {
+                  var p2 = x2.call(treemap, node, node.depth);
+                  return p2 == null ? d3_layout_treemapPadNull(node) : d3_layout_treemapPad(node, typeof p2 === "number" ? [p2, p2, p2, p2] : p2);
+                }
+                function padConstant(node) {
+                  return d3_layout_treemapPad(node, x2);
+                }
+                var type;
+                pad = (padding = x2) == null ? d3_layout_treemapPadNull : (type = typeof x2) === "function" ? padFunction : type === "number" ? (x2 = [x2, x2, x2, x2], padConstant) : padConstant;
+                return treemap;
+              };
+              treemap.round = function(x2) {
+                if (!arguments.length) return round2 != Number;
+                round2 = x2 ? Math.round : Number;
+                return treemap;
+              };
+              treemap.sticky = function(x2) {
+                if (!arguments.length) return sticky;
+                sticky = x2;
+                stickies = null;
+                return treemap;
+              };
+              treemap.ratio = function(x2) {
+                if (!arguments.length) return ratio;
+                ratio = x2;
+                return treemap;
+              };
+              treemap.mode = function(x2) {
+                if (!arguments.length) return mode;
+                mode = x2 + "";
+                return treemap;
+              };
+              return d3_layout_hierarchyRebind(treemap, hierarchy);
+            };
+            function d3_layout_treemapPadNull(node) {
+              return {
+                x: node.x,
+                y: node.y,
+                dx: node.dx,
+                dy: node.dy
+              };
+            }
+            function d3_layout_treemapPad(node, padding) {
+              var x2 = node.x + padding[3], y2 = node.y + padding[0], dx = node.dx - padding[1] - padding[3], dy = node.dy - padding[0] - padding[2];
+              if (dx < 0) {
+                x2 += dx / 2;
+                dx = 0;
+              }
+              if (dy < 0) {
+                y2 += dy / 2;
+                dy = 0;
+              }
+              return {
+                x: x2,
+                y: y2,
+                dx,
+                dy
+              };
+            }
+            d3.random = {
+              normal: function(mu, sigma) {
+                var n2 = arguments.length;
+                if (n2 < 2) sigma = 1;
+                if (n2 < 1) mu = 0;
+                return function() {
+                  var x2, y2, r2;
+                  do {
+                    x2 = Math.random() * 2 - 1;
+                    y2 = Math.random() * 2 - 1;
+                    r2 = x2 * x2 + y2 * y2;
+                  } while (!r2 || r2 > 1);
+                  return mu + sigma * x2 * Math.sqrt(-2 * Math.log(r2) / r2);
+                };
+              },
+              logNormal: function() {
+                var random = d3.random.normal.apply(d3, arguments);
+                return function() {
+                  return Math.exp(random());
+                };
+              },
+              bates: function(m2) {
+                var random = d3.random.irwinHall(m2);
+                return function() {
+                  return random() / m2;
+                };
+              },
+              irwinHall: function(m2) {
+                return function() {
+                  for (var s2 = 0, j2 = 0; j2 < m2; j2++) s2 += Math.random();
+                  return s2;
+                };
+              }
+            };
+            d3.scale = {};
+            function d3_scaleExtent(domain) {
+              var start = domain[0], stop = domain[domain.length - 1];
+              return start < stop ? [start, stop] : [stop, start];
+            }
+            function d3_scaleRange(scale2) {
+              return scale2.rangeExtent ? scale2.rangeExtent() : d3_scaleExtent(scale2.range());
+            }
+            function d3_scale_bilinear(domain, range, uninterpolate, interpolate) {
+              var u2 = uninterpolate(domain[0], domain[1]), i2 = interpolate(range[0], range[1]);
+              return function(x2) {
+                return i2(u2(x2));
+              };
+            }
+            function d3_scale_nice(domain, nice) {
+              var i0 = 0, i1 = domain.length - 1, x0 = domain[i0], x1 = domain[i1], dx;
+              if (x1 < x0) {
+                dx = i0, i0 = i1, i1 = dx;
+                dx = x0, x0 = x1, x1 = dx;
+              }
+              domain[i0] = nice.floor(x0);
+              domain[i1] = nice.ceil(x1);
+              return domain;
+            }
+            function d3_scale_niceStep(step) {
+              return step ? {
+                floor: function(x2) {
+                  return Math.floor(x2 / step) * step;
+                },
+                ceil: function(x2) {
+                  return Math.ceil(x2 / step) * step;
+                }
+              } : d3_scale_niceIdentity;
+            }
+            var d3_scale_niceIdentity = {
+              floor: d3_identity,
+              ceil: d3_identity
+            };
+            function d3_scale_polylinear(domain, range, uninterpolate, interpolate) {
+              var u2 = [], i2 = [], j2 = 0, k2 = Math.min(domain.length, range.length) - 1;
+              if (domain[k2] < domain[0]) {
+                domain = domain.slice().reverse();
+                range = range.slice().reverse();
+              }
+              while (++j2 <= k2) {
+                u2.push(uninterpolate(domain[j2 - 1], domain[j2]));
+                i2.push(interpolate(range[j2 - 1], range[j2]));
+              }
+              return function(x2) {
+                var j22 = d3.bisect(domain, x2, 1, k2) - 1;
+                return i2[j22](u2[j22](x2));
+              };
+            }
+            d3.scale.linear = function() {
+              return d3_scale_linear([0, 1], [0, 1], d3_interpolate, false);
+            };
+            function d3_scale_linear(domain, range, interpolate, clamp2) {
+              var output, input;
+              function rescale() {
+                var linear2 = Math.min(domain.length, range.length) > 2 ? d3_scale_polylinear : d3_scale_bilinear, uninterpolate = clamp2 ? d3_uninterpolateClamp : d3_uninterpolateNumber;
+                output = linear2(domain, range, uninterpolate, interpolate);
+                input = linear2(range, domain, uninterpolate, d3_interpolate);
+                return scale2;
+              }
+              function scale2(x2) {
+                return output(x2);
+              }
+              scale2.invert = function(y2) {
+                return input(y2);
+              };
+              scale2.domain = function(x2) {
+                if (!arguments.length) return domain;
+                domain = x2.map(Number);
+                return rescale();
+              };
+              scale2.range = function(x2) {
+                if (!arguments.length) return range;
+                range = x2;
+                return rescale();
+              };
+              scale2.rangeRound = function(x2) {
+                return scale2.range(x2).interpolate(d3_interpolateRound);
+              };
+              scale2.clamp = function(x2) {
+                if (!arguments.length) return clamp2;
+                clamp2 = x2;
+                return rescale();
+              };
+              scale2.interpolate = function(x2) {
+                if (!arguments.length) return interpolate;
+                interpolate = x2;
+                return rescale();
+              };
+              scale2.ticks = function(m2) {
+                return d3_scale_linearTicks(domain, m2);
+              };
+              scale2.tickFormat = function(m2, format) {
+                return d3_scale_linearTickFormat(domain, m2, format);
+              };
+              scale2.nice = function(m2) {
+                d3_scale_linearNice(domain, m2);
+                return rescale();
+              };
+              scale2.copy = function() {
+                return d3_scale_linear(domain, range, interpolate, clamp2);
+              };
+              return rescale();
+            }
+            function d3_scale_linearRebind(scale2, linear2) {
+              return d3.rebind(scale2, linear2, "range", "rangeRound", "interpolate", "clamp");
+            }
+            function d3_scale_linearNice(domain, m2) {
+              d3_scale_nice(domain, d3_scale_niceStep(d3_scale_linearTickRange(domain, m2)[2]));
+              d3_scale_nice(domain, d3_scale_niceStep(d3_scale_linearTickRange(domain, m2)[2]));
+              return domain;
+            }
+            function d3_scale_linearTickRange(domain, m2) {
+              if (m2 == null) m2 = 10;
+              var extent = d3_scaleExtent(domain), span = extent[1] - extent[0], step = Math.pow(10, Math.floor(Math.log(span / m2) / Math.LN10)), err = m2 / span * step;
+              if (err <= 0.15) step *= 10;
+              else if (err <= 0.35) step *= 5;
+              else if (err <= 0.75) step *= 2;
+              extent[0] = Math.ceil(extent[0] / step) * step;
+              extent[1] = Math.floor(extent[1] / step) * step + step * 0.5;
+              extent[2] = step;
+              return extent;
+            }
+            function d3_scale_linearTicks(domain, m2) {
+              return d3.range.apply(d3, d3_scale_linearTickRange(domain, m2));
+            }
+            d3.scale.log = function() {
+              return d3_scale_log(d3.scale.linear().domain([0, 1]), 10, true, [1, 10]);
+            };
+            function d3_scale_log(linear2, base, positive, domain) {
+              function log3(x2) {
+                return (positive ? Math.log(x2 < 0 ? 0 : x2) : -Math.log(x2 > 0 ? 0 : -x2)) / Math.log(base);
+              }
+              function pow(x2) {
+                return positive ? Math.pow(base, x2) : -Math.pow(base, -x2);
+              }
+              function scale2(x2) {
+                return linear2(log3(x2));
+              }
+              scale2.invert = function(x2) {
+                return pow(linear2.invert(x2));
+              };
+              scale2.domain = function(x2) {
+                if (!arguments.length) return domain;
+                positive = x2[0] >= 0;
+                linear2.domain((domain = x2.map(Number)).map(log3));
+                return scale2;
+              };
+              scale2.base = function(_2) {
+                if (!arguments.length) return base;
+                base = +_2;
+                linear2.domain(domain.map(log3));
+                return scale2;
+              };
+              scale2.nice = function() {
+                var niced = d3_scale_nice(domain.map(log3), positive ? Math : d3_scale_logNiceNegative);
+                linear2.domain(niced);
+                domain = niced.map(pow);
+                return scale2;
+              };
+              scale2.ticks = function() {
+                var extent = d3_scaleExtent(domain), ticks = [], u2 = extent[0], v2 = extent[1], i2 = Math.floor(log3(u2)), j2 = Math.ceil(log3(v2)), n2 = base % 1 ? 2 : base;
+                if (isFinite(j2 - i2)) {
+                  if (positive) {
+                    for (; i2 < j2; i2++) for (var k2 = 1; k2 < n2; k2++) ticks.push(pow(i2) * k2);
+                    ticks.push(pow(i2));
+                  } else {
+                    ticks.push(pow(i2));
+                    for (; i2++ < j2; ) for (var k2 = n2 - 1; k2 > 0; k2--) ticks.push(pow(i2) * k2);
+                  }
+                  for (i2 = 0; ticks[i2] < u2; i2++) {
+                  }
+                  for (j2 = ticks.length; ticks[j2 - 1] > v2; j2--) {
+                  }
+                  ticks = ticks.slice(i2, j2);
+                }
+                return ticks;
+              };
+              scale2.copy = function() {
+                return d3_scale_log(linear2.copy(), base, positive, domain);
+              };
+              return d3_scale_linearRebind(scale2, linear2);
+            }
+            var d3_scale_logNiceNegative = {
+              floor: function(x2) {
+                return -Math.ceil(-x2);
+              },
+              ceil: function(x2) {
+                return -Math.floor(-x2);
+              }
+            };
+            d3.scale.pow = function() {
+              return d3_scale_pow(d3.scale.linear(), 1, [0, 1]);
+            };
+            function d3_scale_pow(linear2, exponent, domain) {
+              var powp = d3_scale_powPow(exponent), powb = d3_scale_powPow(1 / exponent);
+              function scale2(x2) {
+                return linear2(powp(x2));
+              }
+              scale2.invert = function(x2) {
+                return powb(linear2.invert(x2));
+              };
+              scale2.domain = function(x2) {
+                if (!arguments.length) return domain;
+                linear2.domain((domain = x2.map(Number)).map(powp));
+                return scale2;
+              };
+              scale2.ticks = function(m2) {
+                return d3_scale_linearTicks(domain, m2);
+              };
+              scale2.tickFormat = function(m2, format) {
+                return d3_scale_linearTickFormat(domain, m2, format);
+              };
+              scale2.nice = function(m2) {
+                return scale2.domain(d3_scale_linearNice(domain, m2));
+              };
+              scale2.exponent = function(x2) {
+                if (!arguments.length) return exponent;
+                powp = d3_scale_powPow(exponent = x2);
+                powb = d3_scale_powPow(1 / exponent);
+                linear2.domain(domain.map(powp));
+                return scale2;
+              };
+              scale2.copy = function() {
+                return d3_scale_pow(linear2.copy(), exponent, domain);
+              };
+              return d3_scale_linearRebind(scale2, linear2);
+            }
+            function d3_scale_powPow(e2) {
+              return function(x2) {
+                return x2 < 0 ? -Math.pow(-x2, e2) : Math.pow(x2, e2);
+              };
+            }
+            d3.scale.sqrt = function() {
+              return d3.scale.pow().exponent(0.5);
+            };
+            d3.scale.ordinal = function() {
+              return d3_scale_ordinal([], {
+                t: "range",
+                a: [[]]
+              });
+            };
+            function d3_scale_ordinal(domain, ranger) {
+              var index, range, rangeBand;
+              function scale2(x2) {
+                return range[((index.get(x2) || (ranger.t === "range" ? index.set(x2, domain.push(x2)) : NaN)) - 1) % range.length];
+              }
+              function steps(start, step) {
+                return d3.range(domain.length).map(function(i2) {
+                  return start + step * i2;
+                });
+              }
+              scale2.domain = function(x2) {
+                if (!arguments.length) return domain;
+                domain = [];
+                index = new d3_Map();
+                var i2 = -1, n2 = x2.length, xi2;
+                while (++i2 < n2) if (!index.has(xi2 = x2[i2])) index.set(xi2, domain.push(xi2));
+                return scale2[ranger.t].apply(scale2, ranger.a);
+              };
+              scale2.range = function(x2) {
+                if (!arguments.length) return range;
+                range = x2;
+                rangeBand = 0;
+                ranger = {
+                  t: "range",
+                  a: arguments
+                };
+                return scale2;
+              };
+              scale2.rangePoints = function(x2, padding) {
+                if (arguments.length < 2) padding = 0;
+                var start = x2[0], stop = x2[1], step = domain.length < 2 ? (start = (start + stop) / 2, 0) : (stop - start) / (domain.length - 1 + padding);
+                range = steps(start + step * padding / 2, step);
+                rangeBand = 0;
+                ranger = {
+                  t: "rangePoints",
+                  a: arguments
+                };
+                return scale2;
+              };
+              scale2.rangeRoundPoints = function(x2, padding) {
+                if (arguments.length < 2) padding = 0;
+                var start = x2[0], stop = x2[1], step = domain.length < 2 ? (start = stop = Math.round((start + stop) / 2), 0) : (stop - start) / (domain.length - 1 + padding) | 0;
+                range = steps(start + Math.round(step * padding / 2 + (stop - start - (domain.length - 1 + padding) * step) / 2), step);
+                rangeBand = 0;
+                ranger = {
+                  t: "rangeRoundPoints",
+                  a: arguments
+                };
+                return scale2;
+              };
+              scale2.rangeBands = function(x2, padding, outerPadding) {
+                if (arguments.length < 2) padding = 0;
+                if (arguments.length < 3) outerPadding = padding;
+                var reverse = x2[1] < x2[0], start = x2[reverse - 0], stop = x2[1 - reverse], step = (stop - start) / (domain.length - padding + 2 * outerPadding);
+                range = steps(start + step * outerPadding, step);
+                if (reverse) range.reverse();
+                rangeBand = step * (1 - padding);
+                ranger = {
+                  t: "rangeBands",
+                  a: arguments
+                };
+                return scale2;
+              };
+              scale2.rangeRoundBands = function(x2, padding, outerPadding) {
+                if (arguments.length < 2) padding = 0;
+                if (arguments.length < 3) outerPadding = padding;
+                var reverse = x2[1] < x2[0], start = x2[reverse - 0], stop = x2[1 - reverse], step = Math.floor((stop - start) / (domain.length - padding + 2 * outerPadding));
+                range = steps(start + Math.round((stop - start - (domain.length - padding) * step) / 2), step);
+                if (reverse) range.reverse();
+                rangeBand = Math.round(step * (1 - padding));
+                ranger = {
+                  t: "rangeRoundBands",
+                  a: arguments
+                };
+                return scale2;
+              };
+              scale2.rangeBand = function() {
+                return rangeBand;
+              };
+              scale2.rangeExtent = function() {
+                return d3_scaleExtent(ranger.a[0]);
+              };
+              scale2.copy = function() {
+                return d3_scale_ordinal(domain, ranger);
+              };
+              return scale2.domain(domain);
+            }
+            d3.scale.category10 = function() {
+              return d3.scale.ordinal().range(d3_category10);
+            };
+            d3.scale.category20 = function() {
+              return d3.scale.ordinal().range(d3_category20);
+            };
+            d3.scale.category20b = function() {
+              return d3.scale.ordinal().range(d3_category20b);
+            };
+            d3.scale.category20c = function() {
+              return d3.scale.ordinal().range(d3_category20c);
+            };
+            var d3_category10 = [2062260, 16744206, 2924588, 14034728, 9725885, 9197131, 14907330, 8355711, 12369186, 1556175].map(d3_rgbString);
+            var d3_category20 = [2062260, 11454440, 16744206, 16759672, 2924588, 10018698, 14034728, 16750742, 9725885, 12955861, 9197131, 12885140, 14907330, 16234194, 8355711, 13092807, 12369186, 14408589, 1556175, 10410725].map(d3_rgbString);
+            var d3_category20b = [3750777, 5395619, 7040719, 10264286, 6519097, 9216594, 11915115, 13556636, 9202993, 12426809, 15186514, 15190932, 8666169, 11356490, 14049643, 15177372, 8077683, 10834324, 13528509, 14589654].map(d3_rgbString);
+            var d3_category20c = [3244733, 7057110, 10406625, 13032431, 15095053, 16616764, 16625259, 16634018, 3253076, 7652470, 10607003, 13101504, 7695281, 10394312, 12369372, 14342891, 6513507, 9868950, 12434877, 14277081].map(d3_rgbString);
+            d3.scale.quantile = function() {
+              return d3_scale_quantile([], []);
+            };
+            function d3_scale_quantile(domain, range) {
+              var thresholds;
+              function rescale() {
+                var k2 = 0, q2 = range.length;
+                thresholds = [];
+                while (++k2 < q2) thresholds[k2 - 1] = d3.quantile(domain, k2 / q2);
+                return scale2;
+              }
+              function scale2(x2) {
+                if (!isNaN(x2 = +x2)) return range[d3.bisect(thresholds, x2)];
+              }
+              scale2.domain = function(x2) {
+                if (!arguments.length) return domain;
+                domain = x2.map(d3_number).filter(d3_numeric).sort(d3_ascending);
+                return rescale();
+              };
+              scale2.range = function(x2) {
+                if (!arguments.length) return range;
+                range = x2;
+                return rescale();
+              };
+              scale2.quantiles = function() {
+                return thresholds;
+              };
+              scale2.invertExtent = function(y2) {
+                y2 = range.indexOf(y2);
+                return y2 < 0 ? [NaN, NaN] : [y2 > 0 ? thresholds[y2 - 1] : domain[0], y2 < thresholds.length ? thresholds[y2] : domain[domain.length - 1]];
+              };
+              scale2.copy = function() {
+                return d3_scale_quantile(domain, range);
+              };
+              return rescale();
+            }
+            d3.scale.quantize = function() {
+              return d3_scale_quantize(0, 1, [0, 1]);
+            };
+            function d3_scale_quantize(x0, x1, range) {
+              var kx, i2;
+              function scale2(x2) {
+                return range[Math.max(0, Math.min(i2, Math.floor(kx * (x2 - x0))))];
+              }
+              function rescale() {
+                kx = range.length / (x1 - x0);
+                i2 = range.length - 1;
+                return scale2;
+              }
+              scale2.domain = function(x2) {
+                if (!arguments.length) return [x0, x1];
+                x0 = +x2[0];
+                x1 = +x2[x2.length - 1];
+                return rescale();
+              };
+              scale2.range = function(x2) {
+                if (!arguments.length) return range;
+                range = x2;
+                return rescale();
+              };
+              scale2.invertExtent = function(y2) {
+                y2 = range.indexOf(y2);
+                y2 = y2 < 0 ? NaN : y2 / kx + x0;
+                return [y2, y2 + 1 / kx];
+              };
+              scale2.copy = function() {
+                return d3_scale_quantize(x0, x1, range);
+              };
+              return rescale();
+            }
+            d3.scale.threshold = function() {
+              return d3_scale_threshold([0.5], [0, 1]);
+            };
+            function d3_scale_threshold(domain, range) {
+              function scale2(x2) {
+                if (x2 <= x2) return range[d3.bisect(domain, x2)];
+              }
+              scale2.domain = function(_2) {
+                if (!arguments.length) return domain;
+                domain = _2;
+                return scale2;
+              };
+              scale2.range = function(_2) {
+                if (!arguments.length) return range;
+                range = _2;
+                return scale2;
+              };
+              scale2.invertExtent = function(y2) {
+                y2 = range.indexOf(y2);
+                return [domain[y2 - 1], domain[y2]];
+              };
+              scale2.copy = function() {
+                return d3_scale_threshold(domain, range);
+              };
+              return scale2;
+            }
+            d3.scale.identity = function() {
+              return d3_scale_identity([0, 1]);
+            };
+            function d3_scale_identity(domain) {
+              function identity22(x2) {
+                return +x2;
+              }
+              identity22.invert = identity22;
+              identity22.domain = identity22.range = function(x2) {
+                if (!arguments.length) return domain;
+                domain = x2.map(identity22);
+                return identity22;
+              };
+              identity22.ticks = function(m2) {
+                return d3_scale_linearTicks(domain, m2);
+              };
+              identity22.tickFormat = function(m2, format) {
+                return d3_scale_linearTickFormat(domain, m2, format);
+              };
+              identity22.copy = function() {
+                return d3_scale_identity(domain);
+              };
+              return identity22;
+            }
+            d3.svg = {};
+            function d3_zero() {
+              return 0;
+            }
+            d3.svg.arc = function() {
+              var innerRadius = d3_svg_arcInnerRadius, outerRadius = d3_svg_arcOuterRadius, cornerRadius = d3_zero, padRadius = d3_svg_arcAuto, startAngle = d3_svg_arcStartAngle, endAngle = d3_svg_arcEndAngle, padAngle = d3_svg_arcPadAngle;
+              function arc() {
+                var r0 = Math.max(0, +innerRadius.apply(this, arguments)), r1 = Math.max(0, +outerRadius.apply(this, arguments)), a0 = startAngle.apply(this, arguments) - halfπ, a1 = endAngle.apply(this, arguments) - halfπ, da2 = Math.abs(a1 - a0), cw = a0 > a1 ? 0 : 1;
+                if (r1 < r0) rc2 = r1, r1 = r0, r0 = rc2;
+                if (da2 >= τε) return circleSegment(r1, cw) + (r0 ? circleSegment(r0, 1 - cw) : "") + "Z";
+                var rc2, cr, rp, ap, p0 = 0, p1 = 0, x0, y0, x1, y1, x2, y2, x3, y3, path = [];
+                if (ap = (+padAngle.apply(this, arguments) || 0) / 2) {
+                  rp = padRadius === d3_svg_arcAuto ? Math.sqrt(r0 * r0 + r1 * r1) : +padRadius.apply(this, arguments);
+                  if (!cw) p1 *= -1;
+                  if (r1) p1 = d3_asin(rp / r1 * Math.sin(ap));
+                  if (r0) p0 = d3_asin(rp / r0 * Math.sin(ap));
+                }
+                if (r1) {
+                  x0 = r1 * Math.cos(a0 + p1);
+                  y0 = r1 * Math.sin(a0 + p1);
+                  x1 = r1 * Math.cos(a1 - p1);
+                  y1 = r1 * Math.sin(a1 - p1);
+                  var l1 = Math.abs(a1 - a0 - 2 * p1) <= π ? 0 : 1;
+                  if (p1 && d3_svg_arcSweep(x0, y0, x1, y1) === cw ^ l1) {
+                    var h1 = (a0 + a1) / 2;
+                    x0 = r1 * Math.cos(h1);
+                    y0 = r1 * Math.sin(h1);
+                    x1 = y1 = null;
+                  }
+                } else {
+                  x0 = y0 = 0;
+                }
+                if (r0) {
+                  x2 = r0 * Math.cos(a1 - p0);
+                  y2 = r0 * Math.sin(a1 - p0);
+                  x3 = r0 * Math.cos(a0 + p0);
+                  y3 = r0 * Math.sin(a0 + p0);
+                  var l0 = Math.abs(a0 - a1 + 2 * p0) <= π ? 0 : 1;
+                  if (p0 && d3_svg_arcSweep(x2, y2, x3, y3) === 1 - cw ^ l0) {
+                    var h0 = (a0 + a1) / 2;
+                    x2 = r0 * Math.cos(h0);
+                    y2 = r0 * Math.sin(h0);
+                    x3 = y3 = null;
+                  }
+                } else {
+                  x2 = y2 = 0;
+                }
+                if (da2 > ε && (rc2 = Math.min(Math.abs(r1 - r0) / 2, +cornerRadius.apply(this, arguments))) > 1e-3) {
+                  cr = r0 < r1 ^ cw ? 0 : 1;
+                  var rc1 = rc2, rc0 = rc2;
+                  if (da2 < π) {
+                    var oc2 = x3 == null ? [x2, y2] : x1 == null ? [x0, y0] : d3_geom_polygonIntersect([x0, y0], [x3, y3], [x1, y1], [x2, y2]), ax = x0 - oc2[0], ay = y0 - oc2[1], bx = x1 - oc2[0], by = y1 - oc2[1], kc2 = 1 / Math.sin(Math.acos((ax * bx + ay * by) / (Math.sqrt(ax * ax + ay * ay) * Math.sqrt(bx * bx + by * by))) / 2), lc2 = Math.sqrt(oc2[0] * oc2[0] + oc2[1] * oc2[1]);
+                    rc0 = Math.min(rc2, (r0 - lc2) / (kc2 - 1));
+                    rc1 = Math.min(rc2, (r1 - lc2) / (kc2 + 1));
+                  }
+                  if (x1 != null) {
+                    var t30 = d3_svg_arcCornerTangents(x3 == null ? [x2, y2] : [x3, y3], [x0, y0], r1, rc1, cw), t12 = d3_svg_arcCornerTangents([x1, y1], [x2, y2], r1, rc1, cw);
+                    if (rc2 === rc1) {
+                      path.push("M", t30[0], "A", rc1, ",", rc1, " 0 0,", cr, " ", t30[1], "A", r1, ",", r1, " 0 ", 1 - cw ^ d3_svg_arcSweep(t30[1][0], t30[1][1], t12[1][0], t12[1][1]), ",", cw, " ", t12[1], "A", rc1, ",", rc1, " 0 0,", cr, " ", t12[0]);
+                    } else {
+                      path.push("M", t30[0], "A", rc1, ",", rc1, " 0 1,", cr, " ", t12[0]);
+                    }
+                  } else {
+                    path.push("M", x0, ",", y0);
+                  }
+                  if (x3 != null) {
+                    var t03 = d3_svg_arcCornerTangents([x0, y0], [x3, y3], r0, -rc0, cw), t21 = d3_svg_arcCornerTangents([x2, y2], x1 == null ? [x0, y0] : [x1, y1], r0, -rc0, cw);
+                    if (rc2 === rc0) {
+                      path.push("L", t21[0], "A", rc0, ",", rc0, " 0 0,", cr, " ", t21[1], "A", r0, ",", r0, " 0 ", cw ^ d3_svg_arcSweep(t21[1][0], t21[1][1], t03[1][0], t03[1][1]), ",", 1 - cw, " ", t03[1], "A", rc0, ",", rc0, " 0 0,", cr, " ", t03[0]);
+                    } else {
+                      path.push("L", t21[0], "A", rc0, ",", rc0, " 0 0,", cr, " ", t03[0]);
+                    }
+                  } else {
+                    path.push("L", x2, ",", y2);
+                  }
+                } else {
+                  path.push("M", x0, ",", y0);
+                  if (x1 != null) path.push("A", r1, ",", r1, " 0 ", l1, ",", cw, " ", x1, ",", y1);
+                  path.push("L", x2, ",", y2);
+                  if (x3 != null) path.push("A", r0, ",", r0, " 0 ", l0, ",", 1 - cw, " ", x3, ",", y3);
+                }
+                path.push("Z");
+                return path.join("");
+              }
+              function circleSegment(r1, cw) {
+                return "M0," + r1 + "A" + r1 + "," + r1 + " 0 1," + cw + " 0," + -r1 + "A" + r1 + "," + r1 + " 0 1," + cw + " 0," + r1;
+              }
+              arc.innerRadius = function(v2) {
+                if (!arguments.length) return innerRadius;
+                innerRadius = d3_functor(v2);
+                return arc;
+              };
+              arc.outerRadius = function(v2) {
+                if (!arguments.length) return outerRadius;
+                outerRadius = d3_functor(v2);
+                return arc;
+              };
+              arc.cornerRadius = function(v2) {
+                if (!arguments.length) return cornerRadius;
+                cornerRadius = d3_functor(v2);
+                return arc;
+              };
+              arc.padRadius = function(v2) {
+                if (!arguments.length) return padRadius;
+                padRadius = v2 == d3_svg_arcAuto ? d3_svg_arcAuto : d3_functor(v2);
+                return arc;
+              };
+              arc.startAngle = function(v2) {
+                if (!arguments.length) return startAngle;
+                startAngle = d3_functor(v2);
+                return arc;
+              };
+              arc.endAngle = function(v2) {
+                if (!arguments.length) return endAngle;
+                endAngle = d3_functor(v2);
+                return arc;
+              };
+              arc.padAngle = function(v2) {
+                if (!arguments.length) return padAngle;
+                padAngle = d3_functor(v2);
+                return arc;
+              };
+              arc.centroid = function() {
+                var r2 = (+innerRadius.apply(this, arguments) + +outerRadius.apply(this, arguments)) / 2, a2 = (+startAngle.apply(this, arguments) + +endAngle.apply(this, arguments)) / 2 - halfπ;
+                return [Math.cos(a2) * r2, Math.sin(a2) * r2];
+              };
+              return arc;
+            };
+            var d3_svg_arcAuto = "auto";
+            function d3_svg_arcInnerRadius(d2) {
+              return d2.innerRadius;
+            }
+            function d3_svg_arcOuterRadius(d2) {
+              return d2.outerRadius;
+            }
+            function d3_svg_arcStartAngle(d2) {
+              return d2.startAngle;
+            }
+            function d3_svg_arcEndAngle(d2) {
+              return d2.endAngle;
+            }
+            function d3_svg_arcPadAngle(d2) {
+              return d2 && d2.padAngle;
+            }
+            function d3_svg_arcSweep(x0, y0, x1, y1) {
+              return (x0 - x1) * y0 - (y0 - y1) * x0 > 0 ? 0 : 1;
+            }
+            function d3_svg_arcCornerTangents(p0, p1, r1, rc2, cw) {
+              var x01 = p0[0] - p1[0], y01 = p0[1] - p1[1], lo = (cw ? rc2 : -rc2) / Math.sqrt(x01 * x01 + y01 * y01), ox = lo * y01, oy = -lo * x01, x1 = p0[0] + ox, y1 = p0[1] + oy, x2 = p1[0] + ox, y2 = p1[1] + oy, x3 = (x1 + x2) / 2, y3 = (y1 + y2) / 2, dx = x2 - x1, dy = y2 - y1, d2 = dx * dx + dy * dy, r2 = r1 - rc2, D22 = x1 * y2 - x2 * y1, d4 = (dy < 0 ? -1 : 1) * Math.sqrt(Math.max(0, r2 * r2 * d2 - D22 * D22)), cx0 = (D22 * dy - dx * d4) / d2, cy0 = (-D22 * dx - dy * d4) / d2, cx1 = (D22 * dy + dx * d4) / d2, cy1 = (-D22 * dx + dy * d4) / d2, dx0 = cx0 - x3, dy0 = cy0 - y3, dx1 = cx1 - x3, dy1 = cy1 - y3;
+              if (dx0 * dx0 + dy0 * dy0 > dx1 * dx1 + dy1 * dy1) cx0 = cx1, cy0 = cy1;
+              return [[cx0 - ox, cy0 - oy], [cx0 * r1 / r2, cy0 * r1 / r2]];
+            }
+            function d3_true() {
+              return true;
+            }
+            function d3_svg_line(projection) {
+              var x2 = d3_geom_pointX, y2 = d3_geom_pointY, defined = d3_true, interpolate = d3_svg_lineLinear, interpolateKey = interpolate.key, tension = 0.7;
+              function line(data) {
+                var segments = [], points = [], i2 = -1, n2 = data.length, d2, fx = d3_functor(x2), fy = d3_functor(y2);
+                function segment() {
+                  segments.push("M", interpolate(projection(points), tension));
+                }
+                while (++i2 < n2) {
+                  if (defined.call(this, d2 = data[i2], i2)) {
+                    points.push([+fx.call(this, d2, i2), +fy.call(this, d2, i2)]);
+                  } else if (points.length) {
+                    segment();
+                    points = [];
+                  }
+                }
+                if (points.length) segment();
+                return segments.length ? segments.join("") : null;
+              }
+              line.x = function(_2) {
+                if (!arguments.length) return x2;
+                x2 = _2;
+                return line;
+              };
+              line.y = function(_2) {
+                if (!arguments.length) return y2;
+                y2 = _2;
+                return line;
+              };
+              line.defined = function(_2) {
+                if (!arguments.length) return defined;
+                defined = _2;
+                return line;
+              };
+              line.interpolate = function(_2) {
+                if (!arguments.length) return interpolateKey;
+                if (typeof _2 === "function") interpolateKey = interpolate = _2;
+                else interpolateKey = (interpolate = d3_svg_lineInterpolators.get(_2) || d3_svg_lineLinear).key;
+                return line;
+              };
+              line.tension = function(_2) {
+                if (!arguments.length) return tension;
+                tension = _2;
+                return line;
+              };
+              return line;
+            }
+            d3.svg.line = function() {
+              return d3_svg_line(d3_identity);
+            };
+            var d3_svg_lineInterpolators = d3.map({
+              linear: d3_svg_lineLinear,
+              "linear-closed": d3_svg_lineLinearClosed,
+              step: d3_svg_lineStep,
+              "step-before": d3_svg_lineStepBefore,
+              "step-after": d3_svg_lineStepAfter,
+              basis: d3_svg_lineBasis,
+              "basis-open": d3_svg_lineBasisOpen,
+              "basis-closed": d3_svg_lineBasisClosed,
+              bundle: d3_svg_lineBundle,
+              cardinal: d3_svg_lineCardinal,
+              "cardinal-open": d3_svg_lineCardinalOpen,
+              "cardinal-closed": d3_svg_lineCardinalClosed,
+              monotone: d3_svg_lineMonotone
+            });
+            d3_svg_lineInterpolators.forEach(function(key, value) {
+              value.key = key;
+              value.closed = /-closed$/.test(key);
+            });
+            function d3_svg_lineLinear(points) {
+              return points.length > 1 ? points.join("L") : points + "Z";
+            }
+            function d3_svg_lineLinearClosed(points) {
+              return points.join("L") + "Z";
+            }
+            function d3_svg_lineStep(points) {
+              var i2 = 0, n2 = points.length, p2 = points[0], path = [p2[0], ",", p2[1]];
+              while (++i2 < n2) path.push("H", (p2[0] + (p2 = points[i2])[0]) / 2, "V", p2[1]);
+              if (n2 > 1) path.push("H", p2[0]);
+              return path.join("");
+            }
+            function d3_svg_lineStepBefore(points) {
+              var i2 = 0, n2 = points.length, p2 = points[0], path = [p2[0], ",", p2[1]];
+              while (++i2 < n2) path.push("V", (p2 = points[i2])[1], "H", p2[0]);
+              return path.join("");
+            }
+            function d3_svg_lineStepAfter(points) {
+              var i2 = 0, n2 = points.length, p2 = points[0], path = [p2[0], ",", p2[1]];
+              while (++i2 < n2) path.push("H", (p2 = points[i2])[0], "V", p2[1]);
+              return path.join("");
+            }
+            function d3_svg_lineCardinalOpen(points, tension) {
+              return points.length < 4 ? d3_svg_lineLinear(points) : points[1] + d3_svg_lineHermite(points.slice(1, -1), d3_svg_lineCardinalTangents(points, tension));
+            }
+            function d3_svg_lineCardinalClosed(points, tension) {
+              return points.length < 3 ? d3_svg_lineLinearClosed(points) : points[0] + d3_svg_lineHermite((points.push(points[0]), points), d3_svg_lineCardinalTangents([points[points.length - 2]].concat(points, [points[1]]), tension));
+            }
+            function d3_svg_lineCardinal(points, tension) {
+              return points.length < 3 ? d3_svg_lineLinear(points) : points[0] + d3_svg_lineHermite(points, d3_svg_lineCardinalTangents(points, tension));
+            }
+            function d3_svg_lineHermite(points, tangents) {
+              if (tangents.length < 1 || points.length != tangents.length && points.length != tangents.length + 2) {
+                return d3_svg_lineLinear(points);
+              }
+              var quad = points.length != tangents.length, path = "", p0 = points[0], p2 = points[1], t02 = tangents[0], t4 = t02, pi2 = 1;
+              if (quad) {
+                path += "Q" + (p2[0] - t02[0] * 2 / 3) + "," + (p2[1] - t02[1] * 2 / 3) + "," + p2[0] + "," + p2[1];
+                p0 = points[1];
+                pi2 = 2;
+              }
+              if (tangents.length > 1) {
+                t4 = tangents[1];
+                p2 = points[pi2];
+                pi2++;
+                path += "C" + (p0[0] + t02[0]) + "," + (p0[1] + t02[1]) + "," + (p2[0] - t4[0]) + "," + (p2[1] - t4[1]) + "," + p2[0] + "," + p2[1];
+                for (var i2 = 2; i2 < tangents.length; i2++, pi2++) {
+                  p2 = points[pi2];
+                  t4 = tangents[i2];
+                  path += "S" + (p2[0] - t4[0]) + "," + (p2[1] - t4[1]) + "," + p2[0] + "," + p2[1];
+                }
+              }
+              if (quad) {
+                var lp = points[pi2];
+                path += "Q" + (p2[0] + t4[0] * 2 / 3) + "," + (p2[1] + t4[1] * 2 / 3) + "," + lp[0] + "," + lp[1];
+              }
+              return path;
+            }
+            function d3_svg_lineCardinalTangents(points, tension) {
+              var tangents = [], a2 = (1 - tension) / 2, p0, p1 = points[0], p2 = points[1], i2 = 1, n2 = points.length;
+              while (++i2 < n2) {
+                p0 = p1;
+                p1 = p2;
+                p2 = points[i2];
+                tangents.push([a2 * (p2[0] - p0[0]), a2 * (p2[1] - p0[1])]);
+              }
+              return tangents;
+            }
+            function d3_svg_lineBasis(points) {
+              if (points.length < 3) return d3_svg_lineLinear(points);
+              var i2 = 1, n2 = points.length, pi2 = points[0], x0 = pi2[0], y0 = pi2[1], px = [x0, x0, x0, (pi2 = points[1])[0]], py = [y0, y0, y0, pi2[1]], path = [x0, ",", y0, "L", d3_svg_lineDot4(d3_svg_lineBasisBezier3, px), ",", d3_svg_lineDot4(d3_svg_lineBasisBezier3, py)];
+              points.push(points[n2 - 1]);
+              while (++i2 <= n2) {
+                pi2 = points[i2];
+                px.shift();
+                px.push(pi2[0]);
+                py.shift();
+                py.push(pi2[1]);
+                d3_svg_lineBasisBezier(path, px, py);
+              }
+              points.pop();
+              path.push("L", pi2);
+              return path.join("");
+            }
+            function d3_svg_lineBasisOpen(points) {
+              if (points.length < 4) return d3_svg_lineLinear(points);
+              var path = [], i2 = -1, n2 = points.length, pi2, px = [0], py = [0];
+              while (++i2 < 3) {
+                pi2 = points[i2];
+                px.push(pi2[0]);
+                py.push(pi2[1]);
+              }
+              path.push(d3_svg_lineDot4(d3_svg_lineBasisBezier3, px) + "," + d3_svg_lineDot4(d3_svg_lineBasisBezier3, py));
+              --i2;
+              while (++i2 < n2) {
+                pi2 = points[i2];
+                px.shift();
+                px.push(pi2[0]);
+                py.shift();
+                py.push(pi2[1]);
+                d3_svg_lineBasisBezier(path, px, py);
+              }
+              return path.join("");
+            }
+            function d3_svg_lineBasisClosed(points) {
+              var path, i2 = -1, n2 = points.length, m2 = n2 + 4, pi2, px = [], py = [];
+              while (++i2 < 4) {
+                pi2 = points[i2 % n2];
+                px.push(pi2[0]);
+                py.push(pi2[1]);
+              }
+              path = [d3_svg_lineDot4(d3_svg_lineBasisBezier3, px), ",", d3_svg_lineDot4(d3_svg_lineBasisBezier3, py)];
+              --i2;
+              while (++i2 < m2) {
+                pi2 = points[i2 % n2];
+                px.shift();
+                px.push(pi2[0]);
+                py.shift();
+                py.push(pi2[1]);
+                d3_svg_lineBasisBezier(path, px, py);
+              }
+              return path.join("");
+            }
+            function d3_svg_lineBundle(points, tension) {
+              var n2 = points.length - 1;
+              if (n2) {
+                var x0 = points[0][0], y0 = points[0][1], dx = points[n2][0] - x0, dy = points[n2][1] - y0, i2 = -1, p2, t4;
+                while (++i2 <= n2) {
+                  p2 = points[i2];
+                  t4 = i2 / n2;
+                  p2[0] = tension * p2[0] + (1 - tension) * (x0 + t4 * dx);
+                  p2[1] = tension * p2[1] + (1 - tension) * (y0 + t4 * dy);
+                }
+              }
+              return d3_svg_lineBasis(points);
+            }
+            function d3_svg_lineDot4(a2, b2) {
+              return a2[0] * b2[0] + a2[1] * b2[1] + a2[2] * b2[2] + a2[3] * b2[3];
+            }
+            var d3_svg_lineBasisBezier1 = [0, 2 / 3, 1 / 3, 0], d3_svg_lineBasisBezier2 = [0, 1 / 3, 2 / 3, 0], d3_svg_lineBasisBezier3 = [0, 1 / 6, 2 / 3, 1 / 6];
+            function d3_svg_lineBasisBezier(path, x2, y2) {
+              path.push("C", d3_svg_lineDot4(d3_svg_lineBasisBezier1, x2), ",", d3_svg_lineDot4(d3_svg_lineBasisBezier1, y2), ",", d3_svg_lineDot4(d3_svg_lineBasisBezier2, x2), ",", d3_svg_lineDot4(d3_svg_lineBasisBezier2, y2), ",", d3_svg_lineDot4(d3_svg_lineBasisBezier3, x2), ",", d3_svg_lineDot4(d3_svg_lineBasisBezier3, y2));
+            }
+            function d3_svg_lineSlope(p0, p1) {
+              return (p1[1] - p0[1]) / (p1[0] - p0[0]);
+            }
+            function d3_svg_lineFiniteDifferences(points) {
+              var i2 = 0, j2 = points.length - 1, m2 = [], p0 = points[0], p1 = points[1], d2 = m2[0] = d3_svg_lineSlope(p0, p1);
+              while (++i2 < j2) {
+                m2[i2] = (d2 + (d2 = d3_svg_lineSlope(p0 = p1, p1 = points[i2 + 1]))) / 2;
+              }
+              m2[i2] = d2;
+              return m2;
+            }
+            function d3_svg_lineMonotoneTangents(points) {
+              var tangents = [], d2, a2, b2, s2, m2 = d3_svg_lineFiniteDifferences(points), i2 = -1, j2 = points.length - 1;
+              while (++i2 < j2) {
+                d2 = d3_svg_lineSlope(points[i2], points[i2 + 1]);
+                if (abs(d2) < ε) {
+                  m2[i2] = m2[i2 + 1] = 0;
+                } else {
+                  a2 = m2[i2] / d2;
+                  b2 = m2[i2 + 1] / d2;
+                  s2 = a2 * a2 + b2 * b2;
+                  if (s2 > 9) {
+                    s2 = d2 * 3 / Math.sqrt(s2);
+                    m2[i2] = s2 * a2;
+                    m2[i2 + 1] = s2 * b2;
+                  }
+                }
+              }
+              i2 = -1;
+              while (++i2 <= j2) {
+                s2 = (points[Math.min(j2, i2 + 1)][0] - points[Math.max(0, i2 - 1)][0]) / (6 * (1 + m2[i2] * m2[i2]));
+                tangents.push([s2 || 0, m2[i2] * s2 || 0]);
+              }
+              return tangents;
+            }
+            function d3_svg_lineMonotone(points) {
+              return points.length < 3 ? d3_svg_lineLinear(points) : points[0] + d3_svg_lineHermite(points, d3_svg_lineMonotoneTangents(points));
+            }
+            d3.svg.line.radial = function() {
+              var line = d3_svg_line(d3_svg_lineRadial);
+              line.radius = line.x, delete line.x;
+              line.angle = line.y, delete line.y;
+              return line;
+            };
+            function d3_svg_lineRadial(points) {
+              var point, i2 = -1, n2 = points.length, r2, a2;
+              while (++i2 < n2) {
+                point = points[i2];
+                r2 = point[0];
+                a2 = point[1] - halfπ;
+                point[0] = r2 * Math.cos(a2);
+                point[1] = r2 * Math.sin(a2);
+              }
+              return points;
+            }
+            function d3_svg_area(projection) {
+              var x0 = d3_geom_pointX, x1 = d3_geom_pointX, y0 = 0, y1 = d3_geom_pointY, defined = d3_true, interpolate = d3_svg_lineLinear, interpolateKey = interpolate.key, interpolateReverse = interpolate, L2 = "L", tension = 0.7;
+              function area(data) {
+                var segments = [], points0 = [], points1 = [], i2 = -1, n2 = data.length, d2, fx0 = d3_functor(x0), fy0 = d3_functor(y0), fx1 = x0 === x1 ? function() {
+                  return x2;
+                } : d3_functor(x1), fy1 = y0 === y1 ? function() {
+                  return y2;
+                } : d3_functor(y1), x2, y2;
+                function segment() {
+                  segments.push("M", interpolate(projection(points1), tension), L2, interpolateReverse(projection(points0.reverse()), tension), "Z");
+                }
+                while (++i2 < n2) {
+                  if (defined.call(this, d2 = data[i2], i2)) {
+                    points0.push([x2 = +fx0.call(this, d2, i2), y2 = +fy0.call(this, d2, i2)]);
+                    points1.push([+fx1.call(this, d2, i2), +fy1.call(this, d2, i2)]);
+                  } else if (points0.length) {
+                    segment();
+                    points0 = [];
+                    points1 = [];
+                  }
+                }
+                if (points0.length) segment();
+                return segments.length ? segments.join("") : null;
+              }
+              area.x = function(_2) {
+                if (!arguments.length) return x1;
+                x0 = x1 = _2;
+                return area;
+              };
+              area.x0 = function(_2) {
+                if (!arguments.length) return x0;
+                x0 = _2;
+                return area;
+              };
+              area.x1 = function(_2) {
+                if (!arguments.length) return x1;
+                x1 = _2;
+                return area;
+              };
+              area.y = function(_2) {
+                if (!arguments.length) return y1;
+                y0 = y1 = _2;
+                return area;
+              };
+              area.y0 = function(_2) {
+                if (!arguments.length) return y0;
+                y0 = _2;
+                return area;
+              };
+              area.y1 = function(_2) {
+                if (!arguments.length) return y1;
+                y1 = _2;
+                return area;
+              };
+              area.defined = function(_2) {
+                if (!arguments.length) return defined;
+                defined = _2;
+                return area;
+              };
+              area.interpolate = function(_2) {
+                if (!arguments.length) return interpolateKey;
+                if (typeof _2 === "function") interpolateKey = interpolate = _2;
+                else interpolateKey = (interpolate = d3_svg_lineInterpolators.get(_2) || d3_svg_lineLinear).key;
+                interpolateReverse = interpolate.reverse || interpolate;
+                L2 = interpolate.closed ? "M" : "L";
+                return area;
+              };
+              area.tension = function(_2) {
+                if (!arguments.length) return tension;
+                tension = _2;
+                return area;
+              };
+              return area;
+            }
+            d3_svg_lineStepBefore.reverse = d3_svg_lineStepAfter;
+            d3_svg_lineStepAfter.reverse = d3_svg_lineStepBefore;
+            d3.svg.area = function() {
+              return d3_svg_area(d3_identity);
+            };
+            d3.svg.area.radial = function() {
+              var area = d3_svg_area(d3_svg_lineRadial);
+              area.radius = area.x, delete area.x;
+              area.innerRadius = area.x0, delete area.x0;
+              area.outerRadius = area.x1, delete area.x1;
+              area.angle = area.y, delete area.y;
+              area.startAngle = area.y0, delete area.y0;
+              area.endAngle = area.y1, delete area.y1;
+              return area;
+            };
+            function d3_source(d2) {
+              return d2.source;
+            }
+            function d3_target(d2) {
+              return d2.target;
+            }
+            d3.svg.chord = function() {
+              var source2 = d3_source, target = d3_target, radius = d3_svg_chordRadius, startAngle = d3_svg_arcStartAngle, endAngle = d3_svg_arcEndAngle;
+              function chord(d2, i2) {
+                var s2 = subgroup(this, source2, d2, i2), t4 = subgroup(this, target, d2, i2);
+                return "M" + s2.p0 + arc(s2.r, s2.p1, s2.a1 - s2.a0) + (equals2(s2, t4) ? curve(s2.r, s2.p1, s2.r, s2.p0) : curve(s2.r, s2.p1, t4.r, t4.p0) + arc(t4.r, t4.p1, t4.a1 - t4.a0) + curve(t4.r, t4.p1, s2.r, s2.p0)) + "Z";
+              }
+              function subgroup(self2, f2, d2, i2) {
+                var subgroup2 = f2.call(self2, d2, i2), r2 = radius.call(self2, subgroup2, i2), a0 = startAngle.call(self2, subgroup2, i2) - halfπ, a1 = endAngle.call(self2, subgroup2, i2) - halfπ;
+                return {
+                  r: r2,
+                  a0,
+                  a1,
+                  p0: [r2 * Math.cos(a0), r2 * Math.sin(a0)],
+                  p1: [r2 * Math.cos(a1), r2 * Math.sin(a1)]
+                };
+              }
+              function equals2(a2, b2) {
+                return a2.a0 == b2.a0 && a2.a1 == b2.a1;
+              }
+              function arc(r2, p2, a2) {
+                return "A" + r2 + "," + r2 + " 0 " + +(a2 > π) + ",1 " + p2;
+              }
+              function curve(r0, p0, r1, p1) {
+                return "Q 0,0 " + p1;
+              }
+              chord.radius = function(v2) {
+                if (!arguments.length) return radius;
+                radius = d3_functor(v2);
+                return chord;
+              };
+              chord.source = function(v2) {
+                if (!arguments.length) return source2;
+                source2 = d3_functor(v2);
+                return chord;
+              };
+              chord.target = function(v2) {
+                if (!arguments.length) return target;
+                target = d3_functor(v2);
+                return chord;
+              };
+              chord.startAngle = function(v2) {
+                if (!arguments.length) return startAngle;
+                startAngle = d3_functor(v2);
+                return chord;
+              };
+              chord.endAngle = function(v2) {
+                if (!arguments.length) return endAngle;
+                endAngle = d3_functor(v2);
+                return chord;
+              };
+              return chord;
+            };
+            function d3_svg_chordRadius(d2) {
+              return d2.radius;
+            }
+            d3.svg.diagonal = function() {
+              var source2 = d3_source, target = d3_target, projection = d3_svg_diagonalProjection;
+              function diagonal(d2, i2) {
+                var p0 = source2.call(this, d2, i2), p3 = target.call(this, d2, i2), m2 = (p0.y + p3.y) / 2, p2 = [p0, {
+                  x: p0.x,
+                  y: m2
+                }, {
+                  x: p3.x,
+                  y: m2
+                }, p3];
+                p2 = p2.map(projection);
+                return "M" + p2[0] + "C" + p2[1] + " " + p2[2] + " " + p2[3];
+              }
+              diagonal.source = function(x2) {
+                if (!arguments.length) return source2;
+                source2 = d3_functor(x2);
+                return diagonal;
+              };
+              diagonal.target = function(x2) {
+                if (!arguments.length) return target;
+                target = d3_functor(x2);
+                return diagonal;
+              };
+              diagonal.projection = function(x2) {
+                if (!arguments.length) return projection;
+                projection = x2;
+                return diagonal;
+              };
+              return diagonal;
+            };
+            function d3_svg_diagonalProjection(d2) {
+              return [d2.x, d2.y];
+            }
+            d3.svg.diagonal.radial = function() {
+              var diagonal = d3.svg.diagonal(), projection = d3_svg_diagonalProjection, projection_ = diagonal.projection;
+              diagonal.projection = function(x2) {
+                return arguments.length ? projection_(d3_svg_diagonalRadialProjection(projection = x2)) : projection;
+              };
+              return diagonal;
+            };
+            function d3_svg_diagonalRadialProjection(projection) {
+              return function() {
+                var d2 = projection.apply(this, arguments), r2 = d2[0], a2 = d2[1] - halfπ;
+                return [r2 * Math.cos(a2), r2 * Math.sin(a2)];
+              };
+            }
+            d3.svg.symbol = function() {
+              var type = d3_svg_symbolType, size = d3_svg_symbolSize;
+              function symbol(d2, i2) {
+                return (d3_svg_symbols.get(type.call(this, d2, i2)) || d3_svg_symbolCircle)(size.call(this, d2, i2));
+              }
+              symbol.type = function(x2) {
+                if (!arguments.length) return type;
+                type = d3_functor(x2);
+                return symbol;
+              };
+              symbol.size = function(x2) {
+                if (!arguments.length) return size;
+                size = d3_functor(x2);
+                return symbol;
+              };
+              return symbol;
+            };
+            function d3_svg_symbolSize() {
+              return 64;
+            }
+            function d3_svg_symbolType() {
+              return "circle";
+            }
+            function d3_svg_symbolCircle(size) {
+              var r2 = Math.sqrt(size / π);
+              return "M0," + r2 + "A" + r2 + "," + r2 + " 0 1,1 0," + -r2 + "A" + r2 + "," + r2 + " 0 1,1 0," + r2 + "Z";
+            }
+            var d3_svg_symbols = d3.map({
+              circle: d3_svg_symbolCircle,
+              cross: function(size) {
+                var r2 = Math.sqrt(size / 5) / 2;
+                return "M" + -3 * r2 + "," + -r2 + "H" + -r2 + "V" + -3 * r2 + "H" + r2 + "V" + -r2 + "H" + 3 * r2 + "V" + r2 + "H" + r2 + "V" + 3 * r2 + "H" + -r2 + "V" + r2 + "H" + -3 * r2 + "Z";
+              },
+              diamond: function(size) {
+                var ry = Math.sqrt(size / (2 * d3_svg_symbolTan30)), rx = ry * d3_svg_symbolTan30;
+                return "M0," + -ry + "L" + rx + ",0 0," + ry + " " + -rx + ",0Z";
+              },
+              square: function(size) {
+                var r2 = Math.sqrt(size) / 2;
+                return "M" + -r2 + "," + -r2 + "L" + r2 + "," + -r2 + " " + r2 + "," + r2 + " " + -r2 + "," + r2 + "Z";
+              },
+              "triangle-down": function(size) {
+                var rx = Math.sqrt(size / d3_svg_symbolSqrt3), ry = rx * d3_svg_symbolSqrt3 / 2;
+                return "M0," + ry + "L" + rx + "," + -ry + " " + -rx + "," + -ry + "Z";
+              },
+              "triangle-up": function(size) {
+                var rx = Math.sqrt(size / d3_svg_symbolSqrt3), ry = rx * d3_svg_symbolSqrt3 / 2;
+                return "M0," + -ry + "L" + rx + "," + ry + " " + -rx + "," + ry + "Z";
+              }
+            });
+            d3.svg.symbolTypes = d3_svg_symbols.keys();
+            var d3_svg_symbolSqrt3 = Math.sqrt(3), d3_svg_symbolTan30 = Math.tan(30 * d3_radians);
+            d3_selectionPrototype.transition = function(name2) {
+              var id2 = d3_transitionInheritId || ++d3_transitionId, ns = d3_transitionNamespace(name2), subgroups = [], subgroup, node, transition = d3_transitionInherit || {
+                time: Date.now(),
+                ease: d3_ease_cubicInOut,
+                delay: 0,
+                duration: 250
+              };
+              for (var j2 = -1, m2 = this.length; ++j2 < m2; ) {
+                subgroups.push(subgroup = []);
+                for (var group = this[j2], i2 = -1, n2 = group.length; ++i2 < n2; ) {
+                  if (node = group[i2]) d3_transitionNode(node, i2, ns, id2, transition);
+                  subgroup.push(node);
+                }
+              }
+              return d3_transition(subgroups, ns, id2);
+            };
+            d3_selectionPrototype.interrupt = function(name2) {
+              return this.each(name2 == null ? d3_selection_interrupt : d3_selection_interruptNS(d3_transitionNamespace(name2)));
+            };
+            var d3_selection_interrupt = d3_selection_interruptNS(d3_transitionNamespace());
+            function d3_selection_interruptNS(ns) {
+              return function() {
+                var lock, activeId, active;
+                if ((lock = this[ns]) && (active = lock[activeId = lock.active])) {
+                  active.timer.c = null;
+                  active.timer.t = NaN;
+                  if (--lock.count) delete lock[activeId];
+                  else delete this[ns];
+                  lock.active += 0.5;
+                  active.event && active.event.interrupt.call(this, this.__data__, active.index);
+                }
+              };
+            }
+            function d3_transition(groups, ns, id2) {
+              d3_subclass(groups, d3_transitionPrototype);
+              groups.namespace = ns;
+              groups.id = id2;
+              return groups;
+            }
+            var d3_transitionPrototype = [], d3_transitionId = 0, d3_transitionInheritId, d3_transitionInherit;
+            d3_transitionPrototype.call = d3_selectionPrototype.call;
+            d3_transitionPrototype.empty = d3_selectionPrototype.empty;
+            d3_transitionPrototype.node = d3_selectionPrototype.node;
+            d3_transitionPrototype.size = d3_selectionPrototype.size;
+            d3.transition = function(selection, name2) {
+              return selection && selection.transition ? d3_transitionInheritId ? selection.transition(name2) : selection : d3.selection().transition(selection);
+            };
+            d3.transition.prototype = d3_transitionPrototype;
+            d3_transitionPrototype.select = function(selector) {
+              var id2 = this.id, ns = this.namespace, subgroups = [], subgroup, subnode, node;
+              selector = d3_selection_selector(selector);
+              for (var j2 = -1, m2 = this.length; ++j2 < m2; ) {
+                subgroups.push(subgroup = []);
+                for (var group = this[j2], i2 = -1, n2 = group.length; ++i2 < n2; ) {
+                  if ((node = group[i2]) && (subnode = selector.call(node, node.__data__, i2, j2))) {
+                    if ("__data__" in node) subnode.__data__ = node.__data__;
+                    d3_transitionNode(subnode, i2, ns, id2, node[ns][id2]);
+                    subgroup.push(subnode);
+                  } else {
+                    subgroup.push(null);
+                  }
+                }
+              }
+              return d3_transition(subgroups, ns, id2);
+            };
+            d3_transitionPrototype.selectAll = function(selector) {
+              var id2 = this.id, ns = this.namespace, subgroups = [], subgroup, subnodes, node, subnode, transition;
+              selector = d3_selection_selectorAll(selector);
+              for (var j2 = -1, m2 = this.length; ++j2 < m2; ) {
+                for (var group = this[j2], i2 = -1, n2 = group.length; ++i2 < n2; ) {
+                  if (node = group[i2]) {
+                    transition = node[ns][id2];
+                    subnodes = selector.call(node, node.__data__, i2, j2);
+                    subgroups.push(subgroup = []);
+                    for (var k2 = -1, o2 = subnodes.length; ++k2 < o2; ) {
+                      if (subnode = subnodes[k2]) d3_transitionNode(subnode, k2, ns, id2, transition);
+                      subgroup.push(subnode);
+                    }
+                  }
+                }
+              }
+              return d3_transition(subgroups, ns, id2);
+            };
+            d3_transitionPrototype.filter = function(filter) {
+              var subgroups = [], subgroup, group, node;
+              if (typeof filter !== "function") filter = d3_selection_filter(filter);
+              for (var j2 = 0, m2 = this.length; j2 < m2; j2++) {
+                subgroups.push(subgroup = []);
+                for (var group = this[j2], i2 = 0, n2 = group.length; i2 < n2; i2++) {
+                  if ((node = group[i2]) && filter.call(node, node.__data__, i2, j2)) {
+                    subgroup.push(node);
+                  }
+                }
+              }
+              return d3_transition(subgroups, this.namespace, this.id);
+            };
+            d3_transitionPrototype.tween = function(name2, tween) {
+              var id2 = this.id, ns = this.namespace;
+              if (arguments.length < 2) return this.node()[ns][id2].tween.get(name2);
+              return d3_selection_each(this, tween == null ? function(node) {
+                node[ns][id2].tween.remove(name2);
+              } : function(node) {
+                node[ns][id2].tween.set(name2, tween);
+              });
+            };
+            function d3_transition_tween(groups, name2, value, tween) {
+              var id2 = groups.id, ns = groups.namespace;
+              return d3_selection_each(groups, typeof value === "function" ? function(node, i2, j2) {
+                node[ns][id2].tween.set(name2, tween(value.call(node, node.__data__, i2, j2)));
+              } : (value = tween(value), function(node) {
+                node[ns][id2].tween.set(name2, value);
+              }));
+            }
+            d3_transitionPrototype.attr = function(nameNS, value) {
+              if (arguments.length < 2) {
+                for (value in nameNS) this.attr(value, nameNS[value]);
+                return this;
+              }
+              var interpolate = nameNS == "transform" ? d3_interpolateTransform : d3_interpolate, name2 = d3.ns.qualify(nameNS);
+              function attrNull() {
+                this.removeAttribute(name2);
+              }
+              function attrNullNS() {
+                this.removeAttributeNS(name2.space, name2.local);
+              }
+              function attrTween(b2) {
+                return b2 == null ? attrNull : (b2 += "", function() {
+                  var a2 = this.getAttribute(name2), i2;
+                  return a2 !== b2 && (i2 = interpolate(a2, b2), function(t4) {
+                    this.setAttribute(name2, i2(t4));
+                  });
+                });
+              }
+              function attrTweenNS(b2) {
+                return b2 == null ? attrNullNS : (b2 += "", function() {
+                  var a2 = this.getAttributeNS(name2.space, name2.local), i2;
+                  return a2 !== b2 && (i2 = interpolate(a2, b2), function(t4) {
+                    this.setAttributeNS(name2.space, name2.local, i2(t4));
+                  });
+                });
+              }
+              return d3_transition_tween(this, "attr." + nameNS, value, name2.local ? attrTweenNS : attrTween);
+            };
+            d3_transitionPrototype.attrTween = function(nameNS, tween) {
+              var name2 = d3.ns.qualify(nameNS);
+              function attrTween(d2, i2) {
+                var f2 = tween.call(this, d2, i2, this.getAttribute(name2));
+                return f2 && function(t4) {
+                  this.setAttribute(name2, f2(t4));
+                };
+              }
+              function attrTweenNS(d2, i2) {
+                var f2 = tween.call(this, d2, i2, this.getAttributeNS(name2.space, name2.local));
+                return f2 && function(t4) {
+                  this.setAttributeNS(name2.space, name2.local, f2(t4));
+                };
+              }
+              return this.tween("attr." + nameNS, name2.local ? attrTweenNS : attrTween);
+            };
+            d3_transitionPrototype.style = function(name2, value, priority) {
+              var n2 = arguments.length;
+              if (n2 < 3) {
+                if (typeof name2 !== "string") {
+                  if (n2 < 2) value = "";
+                  for (priority in name2) this.style(priority, name2[priority], value);
+                  return this;
+                }
+                priority = "";
+              }
+              function styleNull() {
+                this.style.removeProperty(name2);
+              }
+              function styleString(b2) {
+                return b2 == null ? styleNull : (b2 += "", function() {
+                  var a2 = d3_window(this).getComputedStyle(this, null).getPropertyValue(name2), i2;
+                  return a2 !== b2 && (i2 = d3_interpolate(a2, b2), function(t4) {
+                    this.style.setProperty(name2, i2(t4), priority);
+                  });
+                });
+              }
+              return d3_transition_tween(this, "style." + name2, value, styleString);
+            };
+            d3_transitionPrototype.styleTween = function(name2, tween, priority) {
+              if (arguments.length < 3) priority = "";
+              function styleTween(d2, i2) {
+                var f2 = tween.call(this, d2, i2, d3_window(this).getComputedStyle(this, null).getPropertyValue(name2));
+                return f2 && function(t4) {
+                  this.style.setProperty(name2, f2(t4), priority);
+                };
+              }
+              return this.tween("style." + name2, styleTween);
+            };
+            d3_transitionPrototype.text = function(value) {
+              return d3_transition_tween(this, "text", value, d3_transition_text);
+            };
+            function d3_transition_text(b2) {
+              if (b2 == null) b2 = "";
+              return function() {
+                this.textContent = b2;
+              };
+            }
+            d3_transitionPrototype.remove = function() {
+              var ns = this.namespace;
+              return this.each("end.transition", function() {
+                var p2;
+                if (this[ns].count < 2 && (p2 = this.parentNode)) p2.removeChild(this);
+              });
+            };
+            d3_transitionPrototype.ease = function(value) {
+              var id2 = this.id, ns = this.namespace;
+              if (arguments.length < 1) return this.node()[ns][id2].ease;
+              if (typeof value !== "function") value = d3.ease.apply(d3, arguments);
+              return d3_selection_each(this, function(node) {
+                node[ns][id2].ease = value;
+              });
+            };
+            d3_transitionPrototype.delay = function(value) {
+              var id2 = this.id, ns = this.namespace;
+              if (arguments.length < 1) return this.node()[ns][id2].delay;
+              return d3_selection_each(this, typeof value === "function" ? function(node, i2, j2) {
+                node[ns][id2].delay = +value.call(node, node.__data__, i2, j2);
+              } : (value = +value, function(node) {
+                node[ns][id2].delay = value;
+              }));
+            };
+            d3_transitionPrototype.duration = function(value) {
+              var id2 = this.id, ns = this.namespace;
+              if (arguments.length < 1) return this.node()[ns][id2].duration;
+              return d3_selection_each(this, typeof value === "function" ? function(node, i2, j2) {
+                node[ns][id2].duration = Math.max(1, value.call(node, node.__data__, i2, j2));
+              } : (value = Math.max(1, value), function(node) {
+                node[ns][id2].duration = value;
+              }));
+            };
+            d3_transitionPrototype.each = function(type, listener) {
+              var id2 = this.id, ns = this.namespace;
+              if (arguments.length < 2) {
+                var inherit = d3_transitionInherit, inheritId = d3_transitionInheritId;
+                try {
+                  d3_transitionInheritId = id2;
+                  d3_selection_each(this, function(node, i2, j2) {
+                    d3_transitionInherit = node[ns][id2];
+                    type.call(node, node.__data__, i2, j2);
+                  });
+                } finally {
+                  d3_transitionInherit = inherit;
+                  d3_transitionInheritId = inheritId;
+                }
+              } else {
+                d3_selection_each(this, function(node) {
+                  var transition = node[ns][id2];
+                  (transition.event || (transition.event = d3.dispatch("start", "end", "interrupt"))).on(type, listener);
+                });
+              }
+              return this;
+            };
+            d3_transitionPrototype.transition = function() {
+              var id0 = this.id, id1 = ++d3_transitionId, ns = this.namespace, subgroups = [], subgroup, group, node, transition;
+              for (var j2 = 0, m2 = this.length; j2 < m2; j2++) {
+                subgroups.push(subgroup = []);
+                for (var group = this[j2], i2 = 0, n2 = group.length; i2 < n2; i2++) {
+                  if (node = group[i2]) {
+                    transition = node[ns][id0];
+                    d3_transitionNode(node, i2, ns, id1, {
+                      time: transition.time,
+                      ease: transition.ease,
+                      delay: transition.delay + transition.duration,
+                      duration: transition.duration
+                    });
+                  }
+                  subgroup.push(node);
+                }
+              }
+              return d3_transition(subgroups, ns, id1);
+            };
+            function d3_transitionNamespace(name2) {
+              return name2 == null ? "__transition__" : "__transition_" + name2 + "__";
+            }
+            function d3_transitionNode(node, i2, ns, id2, inherit) {
+              var lock = node[ns] || (node[ns] = {
+                active: 0,
+                count: 0
+              }), transition = lock[id2], time, timer, duration, ease, tweens;
+              function schedule(elapsed) {
+                var delay = transition.delay;
+                timer.t = delay + time;
+                if (delay <= elapsed) return start(elapsed - delay);
+                timer.c = start;
+              }
+              function start(elapsed) {
+                var activeId = lock.active, active = lock[activeId];
+                if (active) {
+                  active.timer.c = null;
+                  active.timer.t = NaN;
+                  --lock.count;
+                  delete lock[activeId];
+                  active.event && active.event.interrupt.call(node, node.__data__, active.index);
+                }
+                for (var cancelId in lock) {
+                  if (+cancelId < id2) {
+                    var cancel = lock[cancelId];
+                    cancel.timer.c = null;
+                    cancel.timer.t = NaN;
+                    --lock.count;
+                    delete lock[cancelId];
+                  }
+                }
+                timer.c = tick;
+                d3_timer(function() {
+                  if (timer.c && tick(elapsed || 1)) {
+                    timer.c = null;
+                    timer.t = NaN;
+                  }
+                  return 1;
+                }, 0, time);
+                lock.active = id2;
+                transition.event && transition.event.start.call(node, node.__data__, i2);
+                tweens = [];
+                transition.tween.forEach(function(key, value) {
+                  if (value = value.call(node, node.__data__, i2)) {
+                    tweens.push(value);
+                  }
+                });
+                ease = transition.ease;
+                duration = transition.duration;
+              }
+              function tick(elapsed) {
+                var t4 = elapsed / duration, e2 = ease(t4), n2 = tweens.length;
+                while (n2 > 0) {
+                  tweens[--n2].call(node, e2);
+                }
+                if (t4 >= 1) {
+                  transition.event && transition.event.end.call(node, node.__data__, i2);
+                  if (--lock.count) delete lock[id2];
+                  else delete node[ns];
+                  return 1;
+                }
+              }
+              if (!transition) {
+                time = inherit.time;
+                timer = d3_timer(schedule, 0, time);
+                transition = lock[id2] = {
+                  tween: new d3_Map(),
+                  time,
+                  timer,
+                  delay: inherit.delay,
+                  duration: inherit.duration,
+                  ease: inherit.ease,
+                  index: i2
+                };
+                inherit = null;
+                ++lock.count;
+              }
+            }
+            d3.svg.axis = function() {
+              var scale2 = d3.scale.linear(), orient = d3_svg_axisDefaultOrient, innerTickSize = 6, outerTickSize = 6, tickPadding = 3, tickArguments_ = [10], tickValues = null, tickFormat_;
+              function axis(g2) {
+                g2.each(function() {
+                  var g22 = d3.select(this);
+                  var scale0 = this.__chart__ || scale2, scale1 = this.__chart__ = scale2.copy();
+                  var ticks = tickValues == null ? scale1.ticks ? scale1.ticks.apply(scale1, tickArguments_) : scale1.domain() : tickValues, tickFormat = tickFormat_ == null ? scale1.tickFormat ? scale1.tickFormat.apply(scale1, tickArguments_) : d3_identity : tickFormat_, tick = g22.selectAll(".tick").data(ticks, scale1), tickEnter = tick.enter().insert("g", ".domain").attr("class", "tick").style("opacity", ε), tickExit = d3.transition(tick.exit()).style("opacity", ε).remove(), tickUpdate = d3.transition(tick.order()).style("opacity", 1), tickSpacing = Math.max(innerTickSize, 0) + tickPadding, tickTransform;
+                  var range = d3_scaleRange(scale1), path = g22.selectAll(".domain").data([0]), pathUpdate = (path.enter().append("path").attr("class", "domain"), d3.transition(path));
+                  tickEnter.append("line");
+                  tickEnter.append("text");
+                  var lineEnter = tickEnter.select("line"), lineUpdate = tickUpdate.select("line"), text = tick.select("text").text(tickFormat), textEnter = tickEnter.select("text"), textUpdate = tickUpdate.select("text"), sign = orient === "top" || orient === "left" ? -1 : 1, x1, x2, y1, y2;
+                  if (orient === "bottom" || orient === "top") {
+                    tickTransform = d3_svg_axisX, x1 = "x", y1 = "y", x2 = "x2", y2 = "y2";
+                    text.attr("dy", sign < 0 ? "0em" : ".71em").style("text-anchor", "middle");
+                    pathUpdate.attr("d", "M" + range[0] + "," + sign * outerTickSize + "V0H" + range[1] + "V" + sign * outerTickSize);
+                  } else {
+                    tickTransform = d3_svg_axisY, x1 = "y", y1 = "x", x2 = "y2", y2 = "x2";
+                    text.attr("dy", ".32em").style("text-anchor", sign < 0 ? "end" : "start");
+                    pathUpdate.attr("d", "M" + sign * outerTickSize + "," + range[0] + "H0V" + range[1] + "H" + sign * outerTickSize);
+                  }
+                  lineEnter.attr(y2, sign * innerTickSize);
+                  textEnter.attr(y1, sign * tickSpacing);
+                  lineUpdate.attr(x2, 0).attr(y2, sign * innerTickSize);
+                  textUpdate.attr(x1, 0).attr(y1, sign * tickSpacing);
+                  if (scale1.rangeBand) {
+                    var x3 = scale1, dx = x3.rangeBand() / 2;
+                    scale0 = scale1 = function(d2) {
+                      return x3(d2) + dx;
+                    };
+                  } else if (scale0.rangeBand) {
+                    scale0 = scale1;
+                  } else {
+                    tickExit.call(tickTransform, scale1, scale0);
+                  }
+                  tickEnter.call(tickTransform, scale0, scale1);
+                  tickUpdate.call(tickTransform, scale1, scale1);
+                });
+              }
+              axis.scale = function(x2) {
+                if (!arguments.length) return scale2;
+                scale2 = x2;
+                return axis;
+              };
+              axis.orient = function(x2) {
+                if (!arguments.length) return orient;
+                orient = x2 in d3_svg_axisOrients ? x2 + "" : d3_svg_axisDefaultOrient;
+                return axis;
+              };
+              axis.ticks = function() {
+                if (!arguments.length) return tickArguments_;
+                tickArguments_ = d3_array(arguments);
+                return axis;
+              };
+              axis.tickValues = function(x2) {
+                if (!arguments.length) return tickValues;
+                tickValues = x2;
+                return axis;
+              };
+              axis.tickFormat = function(x2) {
+                if (!arguments.length) return tickFormat_;
+                tickFormat_ = x2;
+                return axis;
+              };
+              axis.tickSize = function(x2) {
+                var n2 = arguments.length;
+                if (!n2) return innerTickSize;
+                innerTickSize = +x2;
+                outerTickSize = +arguments[n2 - 1];
+                return axis;
+              };
+              axis.innerTickSize = function(x2) {
+                if (!arguments.length) return innerTickSize;
+                innerTickSize = +x2;
+                return axis;
+              };
+              axis.outerTickSize = function(x2) {
+                if (!arguments.length) return outerTickSize;
+                outerTickSize = +x2;
+                return axis;
+              };
+              axis.tickPadding = function(x2) {
+                if (!arguments.length) return tickPadding;
+                tickPadding = +x2;
+                return axis;
+              };
+              axis.tickSubdivide = function() {
+                return arguments.length && axis;
+              };
+              return axis;
+            };
+            var d3_svg_axisDefaultOrient = "bottom", d3_svg_axisOrients = {
+              top: 1,
+              right: 1,
+              bottom: 1,
+              left: 1
+            };
+            function d3_svg_axisX(selection, x0, x1) {
+              selection.attr("transform", function(d2) {
+                var v0 = x0(d2);
+                return "translate(" + (isFinite(v0) ? v0 : x1(d2)) + ",0)";
+              });
+            }
+            function d3_svg_axisY(selection, y0, y1) {
+              selection.attr("transform", function(d2) {
+                var v0 = y0(d2);
+                return "translate(0," + (isFinite(v0) ? v0 : y1(d2)) + ")";
+              });
+            }
+            d3.svg.brush = function() {
+              var event = d3_eventDispatch(brush, "brushstart", "brush", "brushend"), x2 = null, y2 = null, xExtent = [0, 0], yExtent = [0, 0], xExtentDomain, yExtentDomain, xClamp = true, yClamp = true, resizes = d3_svg_brushResizes[0];
+              function brush(g2) {
+                g2.each(function() {
+                  var g22 = d3.select(this).style("pointer-events", "all").style("-webkit-tap-highlight-color", "rgba(0,0,0,0)").on("mousedown.brush", brushstart).on("touchstart.brush", brushstart);
+                  var background = g22.selectAll(".background").data([0]);
+                  background.enter().append("rect").attr("class", "background").style("visibility", "hidden").style("cursor", "crosshair");
+                  g22.selectAll(".extent").data([0]).enter().append("rect").attr("class", "extent").style("cursor", "move");
+                  var resize = g22.selectAll(".resize").data(resizes, d3_identity);
+                  resize.exit().remove();
+                  resize.enter().append("g").attr("class", function(d2) {
+                    return "resize " + d2;
+                  }).style("cursor", function(d2) {
+                    return d3_svg_brushCursor[d2];
+                  }).append("rect").attr("x", function(d2) {
+                    return /[ew]$/.test(d2) ? -3 : null;
+                  }).attr("y", function(d2) {
+                    return /^[ns]/.test(d2) ? -3 : null;
+                  }).attr("width", 6).attr("height", 6).style("visibility", "hidden");
+                  resize.style("display", brush.empty() ? "none" : null);
+                  var gUpdate = d3.transition(g22), backgroundUpdate = d3.transition(background), range;
+                  if (x2) {
+                    range = d3_scaleRange(x2);
+                    backgroundUpdate.attr("x", range[0]).attr("width", range[1] - range[0]);
+                    redrawX(gUpdate);
+                  }
+                  if (y2) {
+                    range = d3_scaleRange(y2);
+                    backgroundUpdate.attr("y", range[0]).attr("height", range[1] - range[0]);
+                    redrawY(gUpdate);
+                  }
+                  redraw(gUpdate);
+                });
+              }
+              brush.event = function(g2) {
+                g2.each(function() {
+                  var event_ = event.of(this, arguments), extent1 = {
+                    x: xExtent,
+                    y: yExtent,
+                    i: xExtentDomain,
+                    j: yExtentDomain
+                  }, extent0 = this.__chart__ || extent1;
+                  this.__chart__ = extent1;
+                  if (d3_transitionInheritId) {
+                    d3.select(this).transition().each("start.brush", function() {
+                      xExtentDomain = extent0.i;
+                      yExtentDomain = extent0.j;
+                      xExtent = extent0.x;
+                      yExtent = extent0.y;
+                      event_({
+                        type: "brushstart"
+                      });
+                    }).tween("brush:brush", function() {
+                      var xi2 = d3_interpolateArray(xExtent, extent1.x), yi2 = d3_interpolateArray(yExtent, extent1.y);
+                      xExtentDomain = yExtentDomain = null;
+                      return function(t4) {
+                        xExtent = extent1.x = xi2(t4);
+                        yExtent = extent1.y = yi2(t4);
+                        event_({
+                          type: "brush",
+                          mode: "resize"
+                        });
+                      };
+                    }).each("end.brush", function() {
+                      xExtentDomain = extent1.i;
+                      yExtentDomain = extent1.j;
+                      event_({
+                        type: "brush",
+                        mode: "resize"
+                      });
+                      event_({
+                        type: "brushend"
+                      });
+                    });
+                  } else {
+                    event_({
+                      type: "brushstart"
+                    });
+                    event_({
+                      type: "brush",
+                      mode: "resize"
+                    });
+                    event_({
+                      type: "brushend"
+                    });
+                  }
+                });
+              };
+              function redraw(g2) {
+                g2.selectAll(".resize").attr("transform", function(d2) {
+                  return "translate(" + xExtent[+/e$/.test(d2)] + "," + yExtent[+/^s/.test(d2)] + ")";
+                });
+              }
+              function redrawX(g2) {
+                g2.select(".extent").attr("x", xExtent[0]);
+                g2.selectAll(".extent,.n>rect,.s>rect").attr("width", xExtent[1] - xExtent[0]);
+              }
+              function redrawY(g2) {
+                g2.select(".extent").attr("y", yExtent[0]);
+                g2.selectAll(".extent,.e>rect,.w>rect").attr("height", yExtent[1] - yExtent[0]);
+              }
+              function brushstart() {
+                var target = this, eventTarget = d3.select(d3.event.target), event_ = event.of(target, arguments), g2 = d3.select(target), resizing = eventTarget.datum(), resizingX = !/^(n|s)$/.test(resizing) && x2, resizingY = !/^(e|w)$/.test(resizing) && y2, dragging = eventTarget.classed("extent"), dragRestore = d3_event_dragSuppress(target), center, origin = d3.mouse(target), offset;
+                var w2 = d3.select(d3_window(target)).on("keydown.brush", keydown).on("keyup.brush", keyup);
+                if (d3.event.changedTouches) {
+                  w2.on("touchmove.brush", brushmove).on("touchend.brush", brushend);
+                } else {
+                  w2.on("mousemove.brush", brushmove).on("mouseup.brush", brushend);
+                }
+                g2.interrupt().selectAll("*").interrupt();
+                if (dragging) {
+                  origin[0] = xExtent[0] - origin[0];
+                  origin[1] = yExtent[0] - origin[1];
+                } else if (resizing) {
+                  var ex = +/w$/.test(resizing), ey = +/^n/.test(resizing);
+                  offset = [xExtent[1 - ex] - origin[0], yExtent[1 - ey] - origin[1]];
+                  origin[0] = xExtent[ex];
+                  origin[1] = yExtent[ey];
+                } else if (d3.event.altKey) center = origin.slice();
+                g2.style("pointer-events", "none").selectAll(".resize").style("display", null);
+                d3.select("body").style("cursor", eventTarget.style("cursor"));
+                event_({
+                  type: "brushstart"
+                });
+                brushmove();
+                function keydown() {
+                  if (d3.event.keyCode == 32) {
+                    if (!dragging) {
+                      center = null;
+                      origin[0] -= xExtent[1];
+                      origin[1] -= yExtent[1];
+                      dragging = 2;
+                    }
+                    d3_eventPreventDefault();
+                  }
+                }
+                function keyup() {
+                  if (d3.event.keyCode == 32 && dragging == 2) {
+                    origin[0] += xExtent[1];
+                    origin[1] += yExtent[1];
+                    dragging = 0;
+                    d3_eventPreventDefault();
+                  }
+                }
+                function brushmove() {
+                  var point = d3.mouse(target), moved = false;
+                  if (offset) {
+                    point[0] += offset[0];
+                    point[1] += offset[1];
+                  }
+                  if (!dragging) {
+                    if (d3.event.altKey) {
+                      if (!center) center = [(xExtent[0] + xExtent[1]) / 2, (yExtent[0] + yExtent[1]) / 2];
+                      origin[0] = xExtent[+(point[0] < center[0])];
+                      origin[1] = yExtent[+(point[1] < center[1])];
+                    } else center = null;
+                  }
+                  if (resizingX && move1(point, x2, 0)) {
+                    redrawX(g2);
+                    moved = true;
+                  }
+                  if (resizingY && move1(point, y2, 1)) {
+                    redrawY(g2);
+                    moved = true;
+                  }
+                  if (moved) {
+                    redraw(g2);
+                    event_({
+                      type: "brush",
+                      mode: dragging ? "move" : "resize"
+                    });
+                  }
+                }
+                function move1(point, scale2, i2) {
+                  var range = d3_scaleRange(scale2), r0 = range[0], r1 = range[1], position = origin[i2], extent = i2 ? yExtent : xExtent, size = extent[1] - extent[0], min, max;
+                  if (dragging) {
+                    r0 -= position;
+                    r1 -= size + position;
+                  }
+                  min = (i2 ? yClamp : xClamp) ? Math.max(r0, Math.min(r1, point[i2])) : point[i2];
+                  if (dragging) {
+                    max = (min += position) + size;
+                  } else {
+                    if (center) position = Math.max(r0, Math.min(r1, 2 * center[i2] - min));
+                    if (position < min) {
+                      max = min;
+                      min = position;
+                    } else {
+                      max = position;
+                    }
+                  }
+                  if (extent[0] != min || extent[1] != max) {
+                    if (i2) yExtentDomain = null;
+                    else xExtentDomain = null;
+                    extent[0] = min;
+                    extent[1] = max;
+                    return true;
+                  }
+                }
+                function brushend() {
+                  brushmove();
+                  g2.style("pointer-events", "all").selectAll(".resize").style("display", brush.empty() ? "none" : null);
+                  d3.select("body").style("cursor", null);
+                  w2.on("mousemove.brush", null).on("mouseup.brush", null).on("touchmove.brush", null).on("touchend.brush", null).on("keydown.brush", null).on("keyup.brush", null);
+                  dragRestore();
+                  event_({
+                    type: "brushend"
+                  });
+                }
+              }
+              brush.x = function(z2) {
+                if (!arguments.length) return x2;
+                x2 = z2;
+                resizes = d3_svg_brushResizes[!x2 << 1 | !y2];
+                return brush;
+              };
+              brush.y = function(z2) {
+                if (!arguments.length) return y2;
+                y2 = z2;
+                resizes = d3_svg_brushResizes[!x2 << 1 | !y2];
+                return brush;
+              };
+              brush.clamp = function(z2) {
+                if (!arguments.length) return x2 && y2 ? [xClamp, yClamp] : x2 ? xClamp : y2 ? yClamp : null;
+                if (x2 && y2) xClamp = !!z2[0], yClamp = !!z2[1];
+                else if (x2) xClamp = !!z2;
+                else if (y2) yClamp = !!z2;
+                return brush;
+              };
+              brush.extent = function(z2) {
+                var x0, x1, y0, y1, t4;
+                if (!arguments.length) {
+                  if (x2) {
+                    if (xExtentDomain) {
+                      x0 = xExtentDomain[0], x1 = xExtentDomain[1];
+                    } else {
+                      x0 = xExtent[0], x1 = xExtent[1];
+                      if (x2.invert) x0 = x2.invert(x0), x1 = x2.invert(x1);
+                      if (x1 < x0) t4 = x0, x0 = x1, x1 = t4;
+                    }
+                  }
+                  if (y2) {
+                    if (yExtentDomain) {
+                      y0 = yExtentDomain[0], y1 = yExtentDomain[1];
+                    } else {
+                      y0 = yExtent[0], y1 = yExtent[1];
+                      if (y2.invert) y0 = y2.invert(y0), y1 = y2.invert(y1);
+                      if (y1 < y0) t4 = y0, y0 = y1, y1 = t4;
+                    }
+                  }
+                  return x2 && y2 ? [[x0, y0], [x1, y1]] : x2 ? [x0, x1] : y2 && [y0, y1];
+                }
+                if (x2) {
+                  x0 = z2[0], x1 = z2[1];
+                  if (y2) x0 = x0[0], x1 = x1[0];
+                  xExtentDomain = [x0, x1];
+                  if (x2.invert) x0 = x2(x0), x1 = x2(x1);
+                  if (x1 < x0) t4 = x0, x0 = x1, x1 = t4;
+                  if (x0 != xExtent[0] || x1 != xExtent[1]) xExtent = [x0, x1];
+                }
+                if (y2) {
+                  y0 = z2[0], y1 = z2[1];
+                  if (x2) y0 = y0[1], y1 = y1[1];
+                  yExtentDomain = [y0, y1];
+                  if (y2.invert) y0 = y2(y0), y1 = y2(y1);
+                  if (y1 < y0) t4 = y0, y0 = y1, y1 = t4;
+                  if (y0 != yExtent[0] || y1 != yExtent[1]) yExtent = [y0, y1];
+                }
+                return brush;
+              };
+              brush.clear = function() {
+                if (!brush.empty()) {
+                  xExtent = [0, 0], yExtent = [0, 0];
+                  xExtentDomain = yExtentDomain = null;
+                }
+                return brush;
+              };
+              brush.empty = function() {
+                return !!x2 && xExtent[0] == xExtent[1] || !!y2 && yExtent[0] == yExtent[1];
+              };
+              return d3.rebind(brush, event, "on");
+            };
+            var d3_svg_brushCursor = {
+              n: "ns-resize",
+              e: "ew-resize",
+              s: "ns-resize",
+              w: "ew-resize",
+              nw: "nwse-resize",
+              ne: "nesw-resize",
+              se: "nwse-resize",
+              sw: "nesw-resize"
+            };
+            var d3_svg_brushResizes = [["n", "e", "s", "w", "nw", "ne", "se", "sw"], ["e", "w"], ["n", "s"], []];
+            d3.text = d3_xhrType(function(request) {
+              return request.responseText;
+            });
+            d3.json = function(url, callback) {
+              return d3_xhr(url, "application/json", d3_json, callback);
+            };
+            function d3_json(request) {
+              return JSON.parse(request.responseText);
+            }
+            d3.html = function(url, callback) {
+              return d3_xhr(url, "text/html", d3_html, callback);
+            };
+            function d3_html(request) {
+              var range = d3_document.createRange();
+              range.selectNode(d3_document.body);
+              return range.createContextualFragment(request.responseText);
+            }
+            d3.xml = d3_xhrType(function(request) {
+              return request.responseXML;
+            });
+            if (typeof module2 === "object" && module2.exports) module2.exports = d3;
+            else this.d3 = d3;
+          }).apply(self);
+        }
+      });
+      var require_d3_time = __commonJS({
+        "node_modules/d3-time/dist/d3-time.js"(exports, module2) {
+          (function(global2, factory2) {
+            typeof exports === "object" && typeof module2 !== "undefined" ? factory2(exports) : (global2 = global2 || self, factory2(global2.d3 = global2.d3 || {}));
+          })(exports, function(exports2) {
+            var t02 = /* @__PURE__ */ new Date(), t12 = /* @__PURE__ */ new Date();
+            function newInterval(floori, offseti, count2, field) {
+              function interval(date) {
+                return floori(date = arguments.length === 0 ? /* @__PURE__ */ new Date() : /* @__PURE__ */ new Date(+date)), date;
+              }
+              interval.floor = function(date) {
+                return floori(date = /* @__PURE__ */ new Date(+date)), date;
+              };
+              interval.ceil = function(date) {
+                return floori(date = new Date(date - 1)), offseti(date, 1), floori(date), date;
+              };
+              interval.round = function(date) {
+                var d0 = interval(date), d1 = interval.ceil(date);
+                return date - d0 < d1 - date ? d0 : d1;
+              };
+              interval.offset = function(date, step) {
+                return offseti(date = /* @__PURE__ */ new Date(+date), step == null ? 1 : Math.floor(step)), date;
+              };
+              interval.range = function(start, stop, step) {
+                var range = [], previous;
+                start = interval.ceil(start);
+                step = step == null ? 1 : Math.floor(step);
+                if (!(start < stop) || !(step > 0)) return range;
+                do
+                  range.push(previous = /* @__PURE__ */ new Date(+start)), offseti(start, step), floori(start);
+                while (previous < start && start < stop);
+                return range;
+              };
+              interval.filter = function(test) {
+                return newInterval(function(date) {
+                  if (date >= date) while (floori(date), !test(date)) date.setTime(date - 1);
+                }, function(date, step) {
+                  if (date >= date) {
+                    if (step < 0) while (++step <= 0) {
+                      while (offseti(date, -1), !test(date)) {
+                      }
+                    }
+                    else while (--step >= 0) {
+                      while (offseti(date, 1), !test(date)) {
+                      }
+                    }
+                  }
+                });
+              };
+              if (count2) {
+                interval.count = function(start, end) {
+                  t02.setTime(+start), t12.setTime(+end);
+                  floori(t02), floori(t12);
+                  return Math.floor(count2(t02, t12));
+                };
+                interval.every = function(step) {
+                  step = Math.floor(step);
+                  return !isFinite(step) || !(step > 0) ? null : !(step > 1) ? interval : interval.filter(field ? function(d2) {
+                    return field(d2) % step === 0;
+                  } : function(d2) {
+                    return interval.count(0, d2) % step === 0;
+                  });
+                };
+              }
+              return interval;
+            }
+            var millisecond = newInterval(function() {
+            }, function(date, step) {
+              date.setTime(+date + step);
+            }, function(start, end) {
+              return end - start;
+            });
+            millisecond.every = function(k2) {
+              k2 = Math.floor(k2);
+              if (!isFinite(k2) || !(k2 > 0)) return null;
+              if (!(k2 > 1)) return millisecond;
+              return newInterval(function(date) {
+                date.setTime(Math.floor(date / k2) * k2);
+              }, function(date, step) {
+                date.setTime(+date + step * k2);
+              }, function(start, end) {
+                return (end - start) / k2;
+              });
+            };
+            var milliseconds = millisecond.range;
+            var durationSecond = 1e3;
+            var durationMinute = 6e4;
+            var durationHour = 36e5;
+            var durationDay = 864e5;
+            var durationWeek = 6048e5;
+            var second = newInterval(function(date) {
+              date.setTime(date - date.getMilliseconds());
+            }, function(date, step) {
+              date.setTime(+date + step * durationSecond);
+            }, function(start, end) {
+              return (end - start) / durationSecond;
+            }, function(date) {
+              return date.getUTCSeconds();
+            });
+            var seconds = second.range;
+            var minute = newInterval(function(date) {
+              date.setTime(date - date.getMilliseconds() - date.getSeconds() * durationSecond);
+            }, function(date, step) {
+              date.setTime(+date + step * durationMinute);
+            }, function(start, end) {
+              return (end - start) / durationMinute;
+            }, function(date) {
+              return date.getMinutes();
+            });
+            var minutes = minute.range;
+            var hour = newInterval(function(date) {
+              date.setTime(date - date.getMilliseconds() - date.getSeconds() * durationSecond - date.getMinutes() * durationMinute);
+            }, function(date, step) {
+              date.setTime(+date + step * durationHour);
+            }, function(start, end) {
+              return (end - start) / durationHour;
+            }, function(date) {
+              return date.getHours();
+            });
+            var hours = hour.range;
+            var day = newInterval(function(date) {
+              date.setHours(0, 0, 0, 0);
+            }, function(date, step) {
+              date.setDate(date.getDate() + step);
+            }, function(start, end) {
+              return (end - start - (end.getTimezoneOffset() - start.getTimezoneOffset()) * durationMinute) / durationDay;
+            }, function(date) {
+              return date.getDate() - 1;
+            });
+            var days = day.range;
+            function weekday(i2) {
+              return newInterval(function(date) {
+                date.setDate(date.getDate() - (date.getDay() + 7 - i2) % 7);
+                date.setHours(0, 0, 0, 0);
+              }, function(date, step) {
+                date.setDate(date.getDate() + step * 7);
+              }, function(start, end) {
+                return (end - start - (end.getTimezoneOffset() - start.getTimezoneOffset()) * durationMinute) / durationWeek;
+              });
+            }
+            var sunday = weekday(0);
+            var monday = weekday(1);
+            var tuesday = weekday(2);
+            var wednesday = weekday(3);
+            var thursday = weekday(4);
+            var friday = weekday(5);
+            var saturday = weekday(6);
+            var sundays = sunday.range;
+            var mondays = monday.range;
+            var tuesdays = tuesday.range;
+            var wednesdays = wednesday.range;
+            var thursdays = thursday.range;
+            var fridays = friday.range;
+            var saturdays = saturday.range;
+            var month = newInterval(function(date) {
+              date.setDate(1);
+              date.setHours(0, 0, 0, 0);
+            }, function(date, step) {
+              date.setMonth(date.getMonth() + step);
+            }, function(start, end) {
+              return end.getMonth() - start.getMonth() + (end.getFullYear() - start.getFullYear()) * 12;
+            }, function(date) {
+              return date.getMonth();
+            });
+            var months = month.range;
+            var year = newInterval(function(date) {
+              date.setMonth(0, 1);
+              date.setHours(0, 0, 0, 0);
+            }, function(date, step) {
+              date.setFullYear(date.getFullYear() + step);
+            }, function(start, end) {
+              return end.getFullYear() - start.getFullYear();
+            }, function(date) {
+              return date.getFullYear();
+            });
+            year.every = function(k2) {
+              return !isFinite(k2 = Math.floor(k2)) || !(k2 > 0) ? null : newInterval(function(date) {
+                date.setFullYear(Math.floor(date.getFullYear() / k2) * k2);
+                date.setMonth(0, 1);
+                date.setHours(0, 0, 0, 0);
+              }, function(date, step) {
+                date.setFullYear(date.getFullYear() + step * k2);
+              });
+            };
+            var years = year.range;
+            var utcMinute = newInterval(function(date) {
+              date.setUTCSeconds(0, 0);
+            }, function(date, step) {
+              date.setTime(+date + step * durationMinute);
+            }, function(start, end) {
+              return (end - start) / durationMinute;
+            }, function(date) {
+              return date.getUTCMinutes();
+            });
+            var utcMinutes = utcMinute.range;
+            var utcHour = newInterval(function(date) {
+              date.setUTCMinutes(0, 0, 0);
+            }, function(date, step) {
+              date.setTime(+date + step * durationHour);
+            }, function(start, end) {
+              return (end - start) / durationHour;
+            }, function(date) {
+              return date.getUTCHours();
+            });
+            var utcHours = utcHour.range;
+            var utcDay = newInterval(function(date) {
+              date.setUTCHours(0, 0, 0, 0);
+            }, function(date, step) {
+              date.setUTCDate(date.getUTCDate() + step);
+            }, function(start, end) {
+              return (end - start) / durationDay;
+            }, function(date) {
+              return date.getUTCDate() - 1;
+            });
+            var utcDays = utcDay.range;
+            function utcWeekday(i2) {
+              return newInterval(function(date) {
+                date.setUTCDate(date.getUTCDate() - (date.getUTCDay() + 7 - i2) % 7);
+                date.setUTCHours(0, 0, 0, 0);
+              }, function(date, step) {
+                date.setUTCDate(date.getUTCDate() + step * 7);
+              }, function(start, end) {
+                return (end - start) / durationWeek;
+              });
+            }
+            var utcSunday = utcWeekday(0);
+            var utcMonday = utcWeekday(1);
+            var utcTuesday = utcWeekday(2);
+            var utcWednesday = utcWeekday(3);
+            var utcThursday = utcWeekday(4);
+            var utcFriday = utcWeekday(5);
+            var utcSaturday = utcWeekday(6);
+            var utcSundays = utcSunday.range;
+            var utcMondays = utcMonday.range;
+            var utcTuesdays = utcTuesday.range;
+            var utcWednesdays = utcWednesday.range;
+            var utcThursdays = utcThursday.range;
+            var utcFridays = utcFriday.range;
+            var utcSaturdays = utcSaturday.range;
+            var utcMonth = newInterval(function(date) {
+              date.setUTCDate(1);
+              date.setUTCHours(0, 0, 0, 0);
+            }, function(date, step) {
+              date.setUTCMonth(date.getUTCMonth() + step);
+            }, function(start, end) {
+              return end.getUTCMonth() - start.getUTCMonth() + (end.getUTCFullYear() - start.getUTCFullYear()) * 12;
+            }, function(date) {
+              return date.getUTCMonth();
+            });
+            var utcMonths = utcMonth.range;
+            var utcYear = newInterval(function(date) {
+              date.setUTCMonth(0, 1);
+              date.setUTCHours(0, 0, 0, 0);
+            }, function(date, step) {
+              date.setUTCFullYear(date.getUTCFullYear() + step);
+            }, function(start, end) {
+              return end.getUTCFullYear() - start.getUTCFullYear();
+            }, function(date) {
+              return date.getUTCFullYear();
+            });
+            utcYear.every = function(k2) {
+              return !isFinite(k2 = Math.floor(k2)) || !(k2 > 0) ? null : newInterval(function(date) {
+                date.setUTCFullYear(Math.floor(date.getUTCFullYear() / k2) * k2);
+                date.setUTCMonth(0, 1);
+                date.setUTCHours(0, 0, 0, 0);
+              }, function(date, step) {
+                date.setUTCFullYear(date.getUTCFullYear() + step * k2);
+              });
+            };
+            var utcYears = utcYear.range;
+            exports2.timeDay = day;
+            exports2.timeDays = days;
+            exports2.timeFriday = friday;
+            exports2.timeFridays = fridays;
+            exports2.timeHour = hour;
+            exports2.timeHours = hours;
+            exports2.timeInterval = newInterval;
+            exports2.timeMillisecond = millisecond;
+            exports2.timeMilliseconds = milliseconds;
+            exports2.timeMinute = minute;
+            exports2.timeMinutes = minutes;
+            exports2.timeMonday = monday;
+            exports2.timeMondays = mondays;
+            exports2.timeMonth = month;
+            exports2.timeMonths = months;
+            exports2.timeSaturday = saturday;
+            exports2.timeSaturdays = saturdays;
+            exports2.timeSecond = second;
+            exports2.timeSeconds = seconds;
+            exports2.timeSunday = sunday;
+            exports2.timeSundays = sundays;
+            exports2.timeThursday = thursday;
+            exports2.timeThursdays = thursdays;
+            exports2.timeTuesday = tuesday;
+            exports2.timeTuesdays = tuesdays;
+            exports2.timeWednesday = wednesday;
+            exports2.timeWednesdays = wednesdays;
+            exports2.timeWeek = sunday;
+            exports2.timeWeeks = sundays;
+            exports2.timeYear = year;
+            exports2.timeYears = years;
+            exports2.utcDay = utcDay;
+            exports2.utcDays = utcDays;
+            exports2.utcFriday = utcFriday;
+            exports2.utcFridays = utcFridays;
+            exports2.utcHour = utcHour;
+            exports2.utcHours = utcHours;
+            exports2.utcMillisecond = millisecond;
+            exports2.utcMilliseconds = milliseconds;
+            exports2.utcMinute = utcMinute;
+            exports2.utcMinutes = utcMinutes;
+            exports2.utcMonday = utcMonday;
+            exports2.utcMondays = utcMondays;
+            exports2.utcMonth = utcMonth;
+            exports2.utcMonths = utcMonths;
+            exports2.utcSaturday = utcSaturday;
+            exports2.utcSaturdays = utcSaturdays;
+            exports2.utcSecond = second;
+            exports2.utcSeconds = seconds;
+            exports2.utcSunday = utcSunday;
+            exports2.utcSundays = utcSundays;
+            exports2.utcThursday = utcThursday;
+            exports2.utcThursdays = utcThursdays;
+            exports2.utcTuesday = utcTuesday;
+            exports2.utcTuesdays = utcTuesdays;
+            exports2.utcWednesday = utcWednesday;
+            exports2.utcWednesdays = utcWednesdays;
+            exports2.utcWeek = utcSunday;
+            exports2.utcWeeks = utcSundays;
+            exports2.utcYear = utcYear;
+            exports2.utcYears = utcYears;
+            Object.defineProperty(exports2, "__esModule", { value: true });
+          });
+        }
+      });
+      var require_d3_time_format = __commonJS({
+        "node_modules/d3-time-format/dist/d3-time-format.js"(exports, module2) {
+          (function(global2, factory2) {
+            typeof exports === "object" && typeof module2 !== "undefined" ? factory2(exports, require_d3_time()) : (global2 = global2 || self, factory2(global2.d3 = global2.d3 || {}, global2.d3));
+          })(exports, function(exports2, d3Time) {
+            function localDate(d2) {
+              if (0 <= d2.y && d2.y < 100) {
+                var date = new Date(-1, d2.m, d2.d, d2.H, d2.M, d2.S, d2.L);
+                date.setFullYear(d2.y);
+                return date;
+              }
+              return new Date(d2.y, d2.m, d2.d, d2.H, d2.M, d2.S, d2.L);
+            }
+            function utcDate(d2) {
+              if (0 <= d2.y && d2.y < 100) {
+                var date = new Date(Date.UTC(-1, d2.m, d2.d, d2.H, d2.M, d2.S, d2.L));
+                date.setUTCFullYear(d2.y);
+                return date;
+              }
+              return new Date(Date.UTC(d2.y, d2.m, d2.d, d2.H, d2.M, d2.S, d2.L));
+            }
+            function newDate(y2, m2, d2) {
+              return { y: y2, m: m2, d: d2, H: 0, M: 0, S: 0, L: 0 };
+            }
+            function formatLocale(locale2) {
+              var locale_dateTime = locale2.dateTime, locale_date = locale2.date, locale_time = locale2.time, locale_periods = locale2.periods, locale_weekdays = locale2.days, locale_shortWeekdays = locale2.shortDays, locale_months = locale2.months, locale_shortMonths = locale2.shortMonths;
+              var periodRe = formatRe(locale_periods), periodLookup = formatLookup(locale_periods), weekdayRe = formatRe(locale_weekdays), weekdayLookup = formatLookup(locale_weekdays), shortWeekdayRe = formatRe(locale_shortWeekdays), shortWeekdayLookup = formatLookup(locale_shortWeekdays), monthRe = formatRe(locale_months), monthLookup = formatLookup(locale_months), shortMonthRe = formatRe(locale_shortMonths), shortMonthLookup = formatLookup(locale_shortMonths);
+              var formats = {
+                "a": formatShortWeekday,
+                "A": formatWeekday,
+                "b": formatShortMonth,
+                "B": formatMonth,
+                "c": null,
+                "d": formatDayOfMonth,
+                "e": formatDayOfMonth,
+                "f": formatMicroseconds,
+                "H": formatHour24,
+                "I": formatHour12,
+                "j": formatDayOfYear,
+                "L": formatMilliseconds,
+                "m": formatMonthNumber,
+                "M": formatMinutes,
+                "p": formatPeriod,
+                "q": formatQuarter,
+                "Q": formatUnixTimestamp,
+                "s": formatUnixTimestampSeconds,
+                "S": formatSeconds,
+                "u": formatWeekdayNumberMonday,
+                "U": formatWeekNumberSunday,
+                "V": formatWeekNumberISO,
+                "w": formatWeekdayNumberSunday,
+                "W": formatWeekNumberMonday,
+                "x": null,
+                "X": null,
+                "y": formatYear,
+                "Y": formatFullYear,
+                "Z": formatZone,
+                "%": formatLiteralPercent
+              };
+              var utcFormats = {
+                "a": formatUTCShortWeekday,
+                "A": formatUTCWeekday,
+                "b": formatUTCShortMonth,
+                "B": formatUTCMonth,
+                "c": null,
+                "d": formatUTCDayOfMonth,
+                "e": formatUTCDayOfMonth,
+                "f": formatUTCMicroseconds,
+                "H": formatUTCHour24,
+                "I": formatUTCHour12,
+                "j": formatUTCDayOfYear,
+                "L": formatUTCMilliseconds,
+                "m": formatUTCMonthNumber,
+                "M": formatUTCMinutes,
+                "p": formatUTCPeriod,
+                "q": formatUTCQuarter,
+                "Q": formatUnixTimestamp,
+                "s": formatUnixTimestampSeconds,
+                "S": formatUTCSeconds,
+                "u": formatUTCWeekdayNumberMonday,
+                "U": formatUTCWeekNumberSunday,
+                "V": formatUTCWeekNumberISO,
+                "w": formatUTCWeekdayNumberSunday,
+                "W": formatUTCWeekNumberMonday,
+                "x": null,
+                "X": null,
+                "y": formatUTCYear,
+                "Y": formatUTCFullYear,
+                "Z": formatUTCZone,
+                "%": formatLiteralPercent
+              };
+              var parses = {
+                "a": parseShortWeekday,
+                "A": parseWeekday,
+                "b": parseShortMonth,
+                "B": parseMonth,
+                "c": parseLocaleDateTime,
+                "d": parseDayOfMonth,
+                "e": parseDayOfMonth,
+                "f": parseMicroseconds,
+                "H": parseHour24,
+                "I": parseHour24,
+                "j": parseDayOfYear,
+                "L": parseMilliseconds,
+                "m": parseMonthNumber,
+                "M": parseMinutes,
+                "p": parsePeriod,
+                "q": parseQuarter,
+                "Q": parseUnixTimestamp,
+                "s": parseUnixTimestampSeconds,
+                "S": parseSeconds,
+                "u": parseWeekdayNumberMonday,
+                "U": parseWeekNumberSunday,
+                "V": parseWeekNumberISO,
+                "w": parseWeekdayNumberSunday,
+                "W": parseWeekNumberMonday,
+                "x": parseLocaleDate,
+                "X": parseLocaleTime,
+                "y": parseYear,
+                "Y": parseFullYear,
+                "Z": parseZone,
+                "%": parseLiteralPercent
+              };
+              formats.x = newFormat(locale_date, formats);
+              formats.X = newFormat(locale_time, formats);
+              formats.c = newFormat(locale_dateTime, formats);
+              utcFormats.x = newFormat(locale_date, utcFormats);
+              utcFormats.X = newFormat(locale_time, utcFormats);
+              utcFormats.c = newFormat(locale_dateTime, utcFormats);
+              function newFormat(specifier, formats2) {
+                return function(date) {
+                  var string = [], i2 = -1, j2 = 0, n2 = specifier.length, c2, pad2, format;
+                  if (!(date instanceof Date)) date = /* @__PURE__ */ new Date(+date);
+                  while (++i2 < n2) {
+                    if (specifier.charCodeAt(i2) === 37) {
+                      string.push(specifier.slice(j2, i2));
+                      if ((pad2 = pads[c2 = specifier.charAt(++i2)]) != null) c2 = specifier.charAt(++i2);
+                      else pad2 = c2 === "e" ? " " : "0";
+                      if (format = formats2[c2]) c2 = format(date, pad2);
+                      string.push(c2);
+                      j2 = i2 + 1;
+                    }
+                  }
+                  string.push(specifier.slice(j2, i2));
+                  return string.join("");
+                };
+              }
+              function newParse(specifier, Z2) {
+                return function(string) {
+                  var d2 = newDate(1900, void 0, 1), i2 = parseSpecifier(d2, specifier, string += "", 0), week, day;
+                  if (i2 != string.length) return null;
+                  if ("Q" in d2) return new Date(d2.Q);
+                  if ("s" in d2) return new Date(d2.s * 1e3 + ("L" in d2 ? d2.L : 0));
+                  if (Z2 && !("Z" in d2)) d2.Z = 0;
+                  if ("p" in d2) d2.H = d2.H % 12 + d2.p * 12;
+                  if (d2.m === void 0) d2.m = "q" in d2 ? d2.q : 0;
+                  if ("V" in d2) {
+                    if (d2.V < 1 || d2.V > 53) return null;
+                    if (!("w" in d2)) d2.w = 1;
+                    if ("Z" in d2) {
+                      week = utcDate(newDate(d2.y, 0, 1)), day = week.getUTCDay();
+                      week = day > 4 || day === 0 ? d3Time.utcMonday.ceil(week) : d3Time.utcMonday(week);
+                      week = d3Time.utcDay.offset(week, (d2.V - 1) * 7);
+                      d2.y = week.getUTCFullYear();
+                      d2.m = week.getUTCMonth();
+                      d2.d = week.getUTCDate() + (d2.w + 6) % 7;
+                    } else {
+                      week = localDate(newDate(d2.y, 0, 1)), day = week.getDay();
+                      week = day > 4 || day === 0 ? d3Time.timeMonday.ceil(week) : d3Time.timeMonday(week);
+                      week = d3Time.timeDay.offset(week, (d2.V - 1) * 7);
+                      d2.y = week.getFullYear();
+                      d2.m = week.getMonth();
+                      d2.d = week.getDate() + (d2.w + 6) % 7;
+                    }
+                  } else if ("W" in d2 || "U" in d2) {
+                    if (!("w" in d2)) d2.w = "u" in d2 ? d2.u % 7 : "W" in d2 ? 1 : 0;
+                    day = "Z" in d2 ? utcDate(newDate(d2.y, 0, 1)).getUTCDay() : localDate(newDate(d2.y, 0, 1)).getDay();
+                    d2.m = 0;
+                    d2.d = "W" in d2 ? (d2.w + 6) % 7 + d2.W * 7 - (day + 5) % 7 : d2.w + d2.U * 7 - (day + 6) % 7;
+                  }
+                  if ("Z" in d2) {
+                    d2.H += d2.Z / 100 | 0;
+                    d2.M += d2.Z % 100;
+                    return utcDate(d2);
+                  }
+                  return localDate(d2);
+                };
+              }
+              function parseSpecifier(d2, specifier, string, j2) {
+                var i2 = 0, n2 = specifier.length, m2 = string.length, c2, parse22;
+                while (i2 < n2) {
+                  if (j2 >= m2) return -1;
+                  c2 = specifier.charCodeAt(i2++);
+                  if (c2 === 37) {
+                    c2 = specifier.charAt(i2++);
+                    parse22 = parses[c2 in pads ? specifier.charAt(i2++) : c2];
+                    if (!parse22 || (j2 = parse22(d2, string, j2)) < 0) return -1;
+                  } else if (c2 != string.charCodeAt(j2++)) {
+                    return -1;
+                  }
+                }
+                return j2;
+              }
+              function parsePeriod(d2, string, i2) {
+                var n2 = periodRe.exec(string.slice(i2));
+                return n2 ? (d2.p = periodLookup[n2[0].toLowerCase()], i2 + n2[0].length) : -1;
+              }
+              function parseShortWeekday(d2, string, i2) {
+                var n2 = shortWeekdayRe.exec(string.slice(i2));
+                return n2 ? (d2.w = shortWeekdayLookup[n2[0].toLowerCase()], i2 + n2[0].length) : -1;
+              }
+              function parseWeekday(d2, string, i2) {
+                var n2 = weekdayRe.exec(string.slice(i2));
+                return n2 ? (d2.w = weekdayLookup[n2[0].toLowerCase()], i2 + n2[0].length) : -1;
+              }
+              function parseShortMonth(d2, string, i2) {
+                var n2 = shortMonthRe.exec(string.slice(i2));
+                return n2 ? (d2.m = shortMonthLookup[n2[0].toLowerCase()], i2 + n2[0].length) : -1;
+              }
+              function parseMonth(d2, string, i2) {
+                var n2 = monthRe.exec(string.slice(i2));
+                return n2 ? (d2.m = monthLookup[n2[0].toLowerCase()], i2 + n2[0].length) : -1;
+              }
+              function parseLocaleDateTime(d2, string, i2) {
+                return parseSpecifier(d2, locale_dateTime, string, i2);
+              }
+              function parseLocaleDate(d2, string, i2) {
+                return parseSpecifier(d2, locale_date, string, i2);
+              }
+              function parseLocaleTime(d2, string, i2) {
+                return parseSpecifier(d2, locale_time, string, i2);
+              }
+              function formatShortWeekday(d2) {
+                return locale_shortWeekdays[d2.getDay()];
+              }
+              function formatWeekday(d2) {
+                return locale_weekdays[d2.getDay()];
+              }
+              function formatShortMonth(d2) {
+                return locale_shortMonths[d2.getMonth()];
+              }
+              function formatMonth(d2) {
+                return locale_months[d2.getMonth()];
+              }
+              function formatPeriod(d2) {
+                return locale_periods[+(d2.getHours() >= 12)];
+              }
+              function formatQuarter(d2) {
+                return 1 + ~~(d2.getMonth() / 3);
+              }
+              function formatUTCShortWeekday(d2) {
+                return locale_shortWeekdays[d2.getUTCDay()];
+              }
+              function formatUTCWeekday(d2) {
+                return locale_weekdays[d2.getUTCDay()];
+              }
+              function formatUTCShortMonth(d2) {
+                return locale_shortMonths[d2.getUTCMonth()];
+              }
+              function formatUTCMonth(d2) {
+                return locale_months[d2.getUTCMonth()];
+              }
+              function formatUTCPeriod(d2) {
+                return locale_periods[+(d2.getUTCHours() >= 12)];
+              }
+              function formatUTCQuarter(d2) {
+                return 1 + ~~(d2.getUTCMonth() / 3);
+              }
+              return {
+                format: function(specifier) {
+                  var f2 = newFormat(specifier += "", formats);
+                  f2.toString = function() {
+                    return specifier;
+                  };
+                  return f2;
+                },
+                parse: function(specifier) {
+                  var p2 = newParse(specifier += "", false);
+                  p2.toString = function() {
+                    return specifier;
+                  };
+                  return p2;
+                },
+                utcFormat: function(specifier) {
+                  var f2 = newFormat(specifier += "", utcFormats);
+                  f2.toString = function() {
+                    return specifier;
+                  };
+                  return f2;
+                },
+                utcParse: function(specifier) {
+                  var p2 = newParse(specifier += "", true);
+                  p2.toString = function() {
+                    return specifier;
+                  };
+                  return p2;
+                }
+              };
+            }
+            var pads = { "-": "", "_": " ", "0": "0" }, numberRe = /^\s*\d+/, percentRe = /^%/, requoteRe = /[\\^$*+?|[\]().{}]/g;
+            function pad(value, fill, width) {
+              var sign = value < 0 ? "-" : "", string = (sign ? -value : value) + "", length2 = string.length;
+              return sign + (length2 < width ? new Array(width - length2 + 1).join(fill) + string : string);
+            }
+            function requote(s2) {
+              return s2.replace(requoteRe, "\\$&");
+            }
+            function formatRe(names2) {
+              return new RegExp("^(?:" + names2.map(requote).join("|") + ")", "i");
+            }
+            function formatLookup(names2) {
+              var map2 = {}, i2 = -1, n2 = names2.length;
+              while (++i2 < n2) map2[names2[i2].toLowerCase()] = i2;
+              return map2;
+            }
+            function parseWeekdayNumberSunday(d2, string, i2) {
+              var n2 = numberRe.exec(string.slice(i2, i2 + 1));
+              return n2 ? (d2.w = +n2[0], i2 + n2[0].length) : -1;
+            }
+            function parseWeekdayNumberMonday(d2, string, i2) {
+              var n2 = numberRe.exec(string.slice(i2, i2 + 1));
+              return n2 ? (d2.u = +n2[0], i2 + n2[0].length) : -1;
+            }
+            function parseWeekNumberSunday(d2, string, i2) {
+              var n2 = numberRe.exec(string.slice(i2, i2 + 2));
+              return n2 ? (d2.U = +n2[0], i2 + n2[0].length) : -1;
+            }
+            function parseWeekNumberISO(d2, string, i2) {
+              var n2 = numberRe.exec(string.slice(i2, i2 + 2));
+              return n2 ? (d2.V = +n2[0], i2 + n2[0].length) : -1;
+            }
+            function parseWeekNumberMonday(d2, string, i2) {
+              var n2 = numberRe.exec(string.slice(i2, i2 + 2));
+              return n2 ? (d2.W = +n2[0], i2 + n2[0].length) : -1;
+            }
+            function parseFullYear(d2, string, i2) {
+              var n2 = numberRe.exec(string.slice(i2, i2 + 4));
+              return n2 ? (d2.y = +n2[0], i2 + n2[0].length) : -1;
+            }
+            function parseYear(d2, string, i2) {
+              var n2 = numberRe.exec(string.slice(i2, i2 + 2));
+              return n2 ? (d2.y = +n2[0] + (+n2[0] > 68 ? 1900 : 2e3), i2 + n2[0].length) : -1;
+            }
+            function parseZone(d2, string, i2) {
+              var n2 = /^(Z)|([+-]\d\d)(?::?(\d\d))?/.exec(string.slice(i2, i2 + 6));
+              return n2 ? (d2.Z = n2[1] ? 0 : -(n2[2] + (n2[3] || "00")), i2 + n2[0].length) : -1;
+            }
+            function parseQuarter(d2, string, i2) {
+              var n2 = numberRe.exec(string.slice(i2, i2 + 1));
+              return n2 ? (d2.q = n2[0] * 3 - 3, i2 + n2[0].length) : -1;
+            }
+            function parseMonthNumber(d2, string, i2) {
+              var n2 = numberRe.exec(string.slice(i2, i2 + 2));
+              return n2 ? (d2.m = n2[0] - 1, i2 + n2[0].length) : -1;
+            }
+            function parseDayOfMonth(d2, string, i2) {
+              var n2 = numberRe.exec(string.slice(i2, i2 + 2));
+              return n2 ? (d2.d = +n2[0], i2 + n2[0].length) : -1;
+            }
+            function parseDayOfYear(d2, string, i2) {
+              var n2 = numberRe.exec(string.slice(i2, i2 + 3));
+              return n2 ? (d2.m = 0, d2.d = +n2[0], i2 + n2[0].length) : -1;
+            }
+            function parseHour24(d2, string, i2) {
+              var n2 = numberRe.exec(string.slice(i2, i2 + 2));
+              return n2 ? (d2.H = +n2[0], i2 + n2[0].length) : -1;
+            }
+            function parseMinutes(d2, string, i2) {
+              var n2 = numberRe.exec(string.slice(i2, i2 + 2));
+              return n2 ? (d2.M = +n2[0], i2 + n2[0].length) : -1;
+            }
+            function parseSeconds(d2, string, i2) {
+              var n2 = numberRe.exec(string.slice(i2, i2 + 2));
+              return n2 ? (d2.S = +n2[0], i2 + n2[0].length) : -1;
+            }
+            function parseMilliseconds(d2, string, i2) {
+              var n2 = numberRe.exec(string.slice(i2, i2 + 3));
+              return n2 ? (d2.L = +n2[0], i2 + n2[0].length) : -1;
+            }
+            function parseMicroseconds(d2, string, i2) {
+              var n2 = numberRe.exec(string.slice(i2, i2 + 6));
+              return n2 ? (d2.L = Math.floor(n2[0] / 1e3), i2 + n2[0].length) : -1;
+            }
+            function parseLiteralPercent(d2, string, i2) {
+              var n2 = percentRe.exec(string.slice(i2, i2 + 1));
+              return n2 ? i2 + n2[0].length : -1;
+            }
+            function parseUnixTimestamp(d2, string, i2) {
+              var n2 = numberRe.exec(string.slice(i2));
+              return n2 ? (d2.Q = +n2[0], i2 + n2[0].length) : -1;
+            }
+            function parseUnixTimestampSeconds(d2, string, i2) {
+              var n2 = numberRe.exec(string.slice(i2));
+              return n2 ? (d2.s = +n2[0], i2 + n2[0].length) : -1;
+            }
+            function formatDayOfMonth(d2, p2) {
+              return pad(d2.getDate(), p2, 2);
+            }
+            function formatHour24(d2, p2) {
+              return pad(d2.getHours(), p2, 2);
+            }
+            function formatHour12(d2, p2) {
+              return pad(d2.getHours() % 12 || 12, p2, 2);
+            }
+            function formatDayOfYear(d2, p2) {
+              return pad(1 + d3Time.timeDay.count(d3Time.timeYear(d2), d2), p2, 3);
+            }
+            function formatMilliseconds(d2, p2) {
+              return pad(d2.getMilliseconds(), p2, 3);
+            }
+            function formatMicroseconds(d2, p2) {
+              return formatMilliseconds(d2, p2) + "000";
+            }
+            function formatMonthNumber(d2, p2) {
+              return pad(d2.getMonth() + 1, p2, 2);
+            }
+            function formatMinutes(d2, p2) {
+              return pad(d2.getMinutes(), p2, 2);
+            }
+            function formatSeconds(d2, p2) {
+              return pad(d2.getSeconds(), p2, 2);
+            }
+            function formatWeekdayNumberMonday(d2) {
+              var day = d2.getDay();
+              return day === 0 ? 7 : day;
+            }
+            function formatWeekNumberSunday(d2, p2) {
+              return pad(d3Time.timeSunday.count(d3Time.timeYear(d2) - 1, d2), p2, 2);
+            }
+            function formatWeekNumberISO(d2, p2) {
+              var day = d2.getDay();
+              d2 = day >= 4 || day === 0 ? d3Time.timeThursday(d2) : d3Time.timeThursday.ceil(d2);
+              return pad(d3Time.timeThursday.count(d3Time.timeYear(d2), d2) + (d3Time.timeYear(d2).getDay() === 4), p2, 2);
+            }
+            function formatWeekdayNumberSunday(d2) {
+              return d2.getDay();
+            }
+            function formatWeekNumberMonday(d2, p2) {
+              return pad(d3Time.timeMonday.count(d3Time.timeYear(d2) - 1, d2), p2, 2);
+            }
+            function formatYear(d2, p2) {
+              return pad(d2.getFullYear() % 100, p2, 2);
+            }
+            function formatFullYear(d2, p2) {
+              return pad(d2.getFullYear() % 1e4, p2, 4);
+            }
+            function formatZone(d2) {
+              var z2 = d2.getTimezoneOffset();
+              return (z2 > 0 ? "-" : (z2 *= -1, "+")) + pad(z2 / 60 | 0, "0", 2) + pad(z2 % 60, "0", 2);
+            }
+            function formatUTCDayOfMonth(d2, p2) {
+              return pad(d2.getUTCDate(), p2, 2);
+            }
+            function formatUTCHour24(d2, p2) {
+              return pad(d2.getUTCHours(), p2, 2);
+            }
+            function formatUTCHour12(d2, p2) {
+              return pad(d2.getUTCHours() % 12 || 12, p2, 2);
+            }
+            function formatUTCDayOfYear(d2, p2) {
+              return pad(1 + d3Time.utcDay.count(d3Time.utcYear(d2), d2), p2, 3);
+            }
+            function formatUTCMilliseconds(d2, p2) {
+              return pad(d2.getUTCMilliseconds(), p2, 3);
+            }
+            function formatUTCMicroseconds(d2, p2) {
+              return formatUTCMilliseconds(d2, p2) + "000";
+            }
+            function formatUTCMonthNumber(d2, p2) {
+              return pad(d2.getUTCMonth() + 1, p2, 2);
+            }
+            function formatUTCMinutes(d2, p2) {
+              return pad(d2.getUTCMinutes(), p2, 2);
+            }
+            function formatUTCSeconds(d2, p2) {
+              return pad(d2.getUTCSeconds(), p2, 2);
+            }
+            function formatUTCWeekdayNumberMonday(d2) {
+              var dow = d2.getUTCDay();
+              return dow === 0 ? 7 : dow;
+            }
+            function formatUTCWeekNumberSunday(d2, p2) {
+              return pad(d3Time.utcSunday.count(d3Time.utcYear(d2) - 1, d2), p2, 2);
+            }
+            function formatUTCWeekNumberISO(d2, p2) {
+              var day = d2.getUTCDay();
+              d2 = day >= 4 || day === 0 ? d3Time.utcThursday(d2) : d3Time.utcThursday.ceil(d2);
+              return pad(d3Time.utcThursday.count(d3Time.utcYear(d2), d2) + (d3Time.utcYear(d2).getUTCDay() === 4), p2, 2);
+            }
+            function formatUTCWeekdayNumberSunday(d2) {
+              return d2.getUTCDay();
+            }
+            function formatUTCWeekNumberMonday(d2, p2) {
+              return pad(d3Time.utcMonday.count(d3Time.utcYear(d2) - 1, d2), p2, 2);
+            }
+            function formatUTCYear(d2, p2) {
+              return pad(d2.getUTCFullYear() % 100, p2, 2);
+            }
+            function formatUTCFullYear(d2, p2) {
+              return pad(d2.getUTCFullYear() % 1e4, p2, 4);
+            }
+            function formatUTCZone() {
+              return "+0000";
+            }
+            function formatLiteralPercent() {
+              return "%";
+            }
+            function formatUnixTimestamp(d2) {
+              return +d2;
+            }
+            function formatUnixTimestampSeconds(d2) {
+              return Math.floor(+d2 / 1e3);
+            }
+            var locale;
+            defaultLocale({
+              dateTime: "%x, %X",
+              date: "%-m/%-d/%Y",
+              time: "%-I:%M:%S %p",
+              periods: ["AM", "PM"],
+              days: ["Sunday", "Monday", "Tuesday", "Wednesday", "Thursday", "Friday", "Saturday"],
+              shortDays: ["Sun", "Mon", "Tue", "Wed", "Thu", "Fri", "Sat"],
+              months: ["January", "February", "March", "April", "May", "June", "July", "August", "September", "October", "November", "December"],
+              shortMonths: ["Jan", "Feb", "Mar", "Apr", "May", "Jun", "Jul", "Aug", "Sep", "Oct", "Nov", "Dec"]
+            });
+            function defaultLocale(definition) {
+              locale = formatLocale(definition);
+              exports2.timeFormat = locale.format;
+              exports2.timeParse = locale.parse;
+              exports2.utcFormat = locale.utcFormat;
+              exports2.utcParse = locale.utcParse;
+              return locale;
+            }
+            var isoSpecifier = "%Y-%m-%dT%H:%M:%S.%LZ";
+            function formatIsoNative(date) {
+              return date.toISOString();
+            }
+            var formatIso = Date.prototype.toISOString ? formatIsoNative : exports2.utcFormat(isoSpecifier);
+            function parseIsoNative(string) {
+              var date = new Date(string);
+              return isNaN(date) ? null : date;
+            }
+            var parseIso = +/* @__PURE__ */ new Date("2000-01-01T00:00:00.000Z") ? parseIsoNative : exports2.utcParse(isoSpecifier);
+            exports2.isoFormat = formatIso;
+            exports2.isoParse = parseIso;
+            exports2.timeFormatDefaultLocale = defaultLocale;
+            exports2.timeFormatLocale = formatLocale;
+            Object.defineProperty(exports2, "__esModule", { value: true });
+          });
+        }
+      });
+      var require_d3_format = __commonJS({
+        "node_modules/d3-format/dist/d3-format.js"(exports, module2) {
+          (function(global2, factory2) {
+            typeof exports === "object" && typeof module2 !== "undefined" ? factory2(exports) : (global2 = typeof globalThis !== "undefined" ? globalThis : global2 || self, factory2(global2.d3 = global2.d3 || {}));
+          })(exports, function(exports2) {
+            function formatDecimal(x2) {
+              return Math.abs(x2 = Math.round(x2)) >= 1e21 ? x2.toLocaleString("en").replace(/,/g, "") : x2.toString(10);
+            }
+            function formatDecimalParts(x2, p2) {
+              if ((i2 = (x2 = p2 ? x2.toExponential(p2 - 1) : x2.toExponential()).indexOf("e")) < 0) return null;
+              var i2, coefficient = x2.slice(0, i2);
+              return [
+                coefficient.length > 1 ? coefficient[0] + coefficient.slice(2) : coefficient,
+                +x2.slice(i2 + 1)
+              ];
+            }
+            function exponent(x2) {
+              return x2 = formatDecimalParts(Math.abs(x2)), x2 ? x2[1] : NaN;
+            }
+            function formatGroup(grouping, thousands) {
+              return function(value, width) {
+                var i2 = value.length, t4 = [], j2 = 0, g2 = grouping[0], length2 = 0;
+                while (i2 > 0 && g2 > 0) {
+                  if (length2 + g2 + 1 > width) g2 = Math.max(1, width - length2);
+                  t4.push(value.substring(i2 -= g2, i2 + g2));
+                  if ((length2 += g2 + 1) > width) break;
+                  g2 = grouping[j2 = (j2 + 1) % grouping.length];
+                }
+                return t4.reverse().join(thousands);
+              };
+            }
+            function formatNumerals(numerals) {
+              return function(value) {
+                return value.replace(/[0-9]/g, function(i2) {
+                  return numerals[+i2];
+                });
+              };
+            }
+            var re2 = /^(?:(.)?([<>=^]))?([+\-( ])?([$#])?(0)?(\d+)?(,)?(\.\d+)?(~)?([a-z%])?$/i;
+            function formatSpecifier(specifier) {
+              if (!(match = re2.exec(specifier))) throw new Error("invalid format: " + specifier);
+              var match;
+              return new FormatSpecifier({
+                fill: match[1],
+                align: match[2],
+                sign: match[3],
+                symbol: match[4],
+                zero: match[5],
+                width: match[6],
+                comma: match[7],
+                precision: match[8] && match[8].slice(1),
+                trim: match[9],
+                type: match[10]
+              });
+            }
+            formatSpecifier.prototype = FormatSpecifier.prototype;
+            function FormatSpecifier(specifier) {
+              this.fill = specifier.fill === void 0 ? " " : specifier.fill + "";
+              this.align = specifier.align === void 0 ? ">" : specifier.align + "";
+              this.sign = specifier.sign === void 0 ? "-" : specifier.sign + "";
+              this.symbol = specifier.symbol === void 0 ? "" : specifier.symbol + "";
+              this.zero = !!specifier.zero;
+              this.width = specifier.width === void 0 ? void 0 : +specifier.width;
+              this.comma = !!specifier.comma;
+              this.precision = specifier.precision === void 0 ? void 0 : +specifier.precision;
+              this.trim = !!specifier.trim;
+              this.type = specifier.type === void 0 ? "" : specifier.type + "";
+            }
+            FormatSpecifier.prototype.toString = function() {
+              return this.fill + this.align + this.sign + this.symbol + (this.zero ? "0" : "") + (this.width === void 0 ? "" : Math.max(1, this.width | 0)) + (this.comma ? "," : "") + (this.precision === void 0 ? "" : "." + Math.max(0, this.precision | 0)) + (this.trim ? "~" : "") + this.type;
+            };
+            function formatTrim(s2) {
+              out: for (var n2 = s2.length, i2 = 1, i0 = -1, i1; i2 < n2; ++i2) {
+                switch (s2[i2]) {
+                  case ".":
+                    i0 = i1 = i2;
+                    break;
+                  case "0":
+                    if (i0 === 0) i0 = i2;
+                    i1 = i2;
+                    break;
+                  default:
+                    if (!+s2[i2]) break out;
+                    if (i0 > 0) i0 = 0;
+                    break;
+                }
+              }
+              return i0 > 0 ? s2.slice(0, i0) + s2.slice(i1 + 1) : s2;
+            }
+            var prefixExponent;
+            function formatPrefixAuto(x2, p2) {
+              var d2 = formatDecimalParts(x2, p2);
+              if (!d2) return x2 + "";
+              var coefficient = d2[0], exponent2 = d2[1], i2 = exponent2 - (prefixExponent = Math.max(-8, Math.min(8, Math.floor(exponent2 / 3))) * 3) + 1, n2 = coefficient.length;
+              return i2 === n2 ? coefficient : i2 > n2 ? coefficient + new Array(i2 - n2 + 1).join("0") : i2 > 0 ? coefficient.slice(0, i2) + "." + coefficient.slice(i2) : "0." + new Array(1 - i2).join("0") + formatDecimalParts(x2, Math.max(0, p2 + i2 - 1))[0];
+            }
+            function formatRounded(x2, p2) {
+              var d2 = formatDecimalParts(x2, p2);
+              if (!d2) return x2 + "";
+              var coefficient = d2[0], exponent2 = d2[1];
+              return exponent2 < 0 ? "0." + new Array(-exponent2).join("0") + coefficient : coefficient.length > exponent2 + 1 ? coefficient.slice(0, exponent2 + 1) + "." + coefficient.slice(exponent2 + 1) : coefficient + new Array(exponent2 - coefficient.length + 2).join("0");
+            }
+            var formatTypes = {
+              "%": function(x2, p2) {
+                return (x2 * 100).toFixed(p2);
+              },
+              "b": function(x2) {
+                return Math.round(x2).toString(2);
+              },
+              "c": function(x2) {
+                return x2 + "";
+              },
+              "d": formatDecimal,
+              "e": function(x2, p2) {
+                return x2.toExponential(p2);
+              },
+              "f": function(x2, p2) {
+                return x2.toFixed(p2);
+              },
+              "g": function(x2, p2) {
+                return x2.toPrecision(p2);
+              },
+              "o": function(x2) {
+                return Math.round(x2).toString(8);
+              },
+              "p": function(x2, p2) {
+                return formatRounded(x2 * 100, p2);
+              },
+              "r": formatRounded,
+              "s": formatPrefixAuto,
+              "X": function(x2) {
+                return Math.round(x2).toString(16).toUpperCase();
+              },
+              "x": function(x2) {
+                return Math.round(x2).toString(16);
+              }
+            };
+            function identity22(x2) {
+              return x2;
+            }
+            var map2 = Array.prototype.map, prefixes = ["y", "z", "a", "f", "p", "n", "µ", "m", "", "k", "M", "G", "T", "P", "E", "Z", "Y"];
+            function formatLocale(locale2) {
+              var group = locale2.grouping === void 0 || locale2.thousands === void 0 ? identity22 : formatGroup(map2.call(locale2.grouping, Number), locale2.thousands + ""), currencyPrefix = locale2.currency === void 0 ? "" : locale2.currency[0] + "", currencySuffix = locale2.currency === void 0 ? "" : locale2.currency[1] + "", decimal = locale2.decimal === void 0 ? "." : locale2.decimal + "", numerals = locale2.numerals === void 0 ? identity22 : formatNumerals(map2.call(locale2.numerals, String)), percent = locale2.percent === void 0 ? "%" : locale2.percent + "", minus = locale2.minus === void 0 ? "-" : locale2.minus + "", nan = locale2.nan === void 0 ? "NaN" : locale2.nan + "";
+              function newFormat(specifier) {
+                specifier = formatSpecifier(specifier);
+                var fill = specifier.fill, align = specifier.align, sign = specifier.sign, symbol = specifier.symbol, zero2 = specifier.zero, width = specifier.width, comma = specifier.comma, precision = specifier.precision, trim = specifier.trim, type = specifier.type;
+                if (type === "n") comma = true, type = "g";
+                else if (!formatTypes[type]) precision === void 0 && (precision = 12), trim = true, type = "g";
+                if (zero2 || fill === "0" && align === "=") zero2 = true, fill = "0", align = "=";
+                var prefix = symbol === "$" ? currencyPrefix : symbol === "#" && /[boxX]/.test(type) ? "0" + type.toLowerCase() : "", suffix = symbol === "$" ? currencySuffix : /[%p]/.test(type) ? percent : "";
+                var formatType = formatTypes[type], maybeSuffix = /[defgprs%]/.test(type);
+                precision = precision === void 0 ? 6 : /[gprs]/.test(type) ? Math.max(1, Math.min(21, precision)) : Math.max(0, Math.min(20, precision));
+                function format(value) {
+                  var valuePrefix = prefix, valueSuffix = suffix, i2, n2, c2;
+                  if (type === "c") {
+                    valueSuffix = formatType(value) + valueSuffix;
+                    value = "";
+                  } else {
+                    value = +value;
+                    var valueNegative = value < 0 || 1 / value < 0;
+                    value = isNaN(value) ? nan : formatType(Math.abs(value), precision);
+                    if (trim) value = formatTrim(value);
+                    if (valueNegative && +value === 0 && sign !== "+") valueNegative = false;
+                    valuePrefix = (valueNegative ? sign === "(" ? sign : minus : sign === "-" || sign === "(" ? "" : sign) + valuePrefix;
+                    valueSuffix = (type === "s" ? prefixes[8 + prefixExponent / 3] : "") + valueSuffix + (valueNegative && sign === "(" ? ")" : "");
+                    if (maybeSuffix) {
+                      i2 = -1, n2 = value.length;
+                      while (++i2 < n2) {
+                        if (c2 = value.charCodeAt(i2), 48 > c2 || c2 > 57) {
+                          valueSuffix = (c2 === 46 ? decimal + value.slice(i2 + 1) : value.slice(i2)) + valueSuffix;
+                          value = value.slice(0, i2);
+                          break;
+                        }
+                      }
+                    }
+                  }
+                  if (comma && !zero2) value = group(value, Infinity);
+                  var length2 = valuePrefix.length + value.length + valueSuffix.length, padding = length2 < width ? new Array(width - length2 + 1).join(fill) : "";
+                  if (comma && zero2) value = group(padding + value, padding.length ? width - valueSuffix.length : Infinity), padding = "";
+                  switch (align) {
+                    case "<":
+                      value = valuePrefix + value + valueSuffix + padding;
+                      break;
+                    case "=":
+                      value = valuePrefix + padding + value + valueSuffix;
+                      break;
+                    case "^":
+                      value = padding.slice(0, length2 = padding.length >> 1) + valuePrefix + value + valueSuffix + padding.slice(length2);
+                      break;
+                    default:
+                      value = padding + valuePrefix + value + valueSuffix;
+                      break;
+                  }
+                  return numerals(value);
+                }
+                format.toString = function() {
+                  return specifier + "";
+                };
+                return format;
+              }
+              function formatPrefix(specifier, value) {
+                var f2 = newFormat((specifier = formatSpecifier(specifier), specifier.type = "f", specifier)), e2 = Math.max(-8, Math.min(8, Math.floor(exponent(value) / 3))) * 3, k2 = Math.pow(10, -e2), prefix = prefixes[8 + e2 / 3];
+                return function(value2) {
+                  return f2(k2 * value2) + prefix;
+                };
+              }
+              return {
+                format: newFormat,
+                formatPrefix
+              };
+            }
+            var locale;
+            defaultLocale({
+              decimal: ".",
+              thousands: ",",
+              grouping: [3],
+              currency: ["$", ""],
+              minus: "-"
+            });
+            function defaultLocale(definition) {
+              locale = formatLocale(definition);
+              exports2.format = locale.format;
+              exports2.formatPrefix = locale.formatPrefix;
+              return locale;
+            }
+            function precisionFixed(step) {
+              return Math.max(0, -exponent(Math.abs(step)));
+            }
+            function precisionPrefix(step, value) {
+              return Math.max(0, Math.max(-8, Math.min(8, Math.floor(exponent(value) / 3))) * 3 - exponent(Math.abs(step)));
+            }
+            function precisionRound(step, max) {
+              step = Math.abs(step), max = Math.abs(max) - step;
+              return Math.max(0, exponent(max) - exponent(step)) + 1;
+            }
+            exports2.FormatSpecifier = FormatSpecifier;
+            exports2.formatDefaultLocale = defaultLocale;
+            exports2.formatLocale = formatLocale;
+            exports2.formatSpecifier = formatSpecifier;
+            exports2.precisionFixed = precisionFixed;
+            exports2.precisionPrefix = precisionPrefix;
+            exports2.precisionRound = precisionRound;
+            Object.defineProperty(exports2, "__esModule", { value: true });
+          });
+        }
+      });
+      var require_is_string_blank = __commonJS({
+        "node_modules/is-string-blank/index.js"(exports, module2) {
+          module2.exports = function(str) {
+            var l2 = str.length, a2;
+            for (var i2 = 0; i2 < l2; i2++) {
+              a2 = str.charCodeAt(i2);
+              if ((a2 < 9 || a2 > 13) && a2 !== 32 && a2 !== 133 && a2 !== 160 && a2 !== 5760 && a2 !== 6158 && (a2 < 8192 || a2 > 8205) && a2 !== 8232 && a2 !== 8233 && a2 !== 8239 && a2 !== 8287 && a2 !== 8288 && a2 !== 12288 && a2 !== 65279) {
+                return false;
+              }
+            }
+            return true;
+          };
+        }
+      });
+      var require_fast_isnumeric = __commonJS({
+        "node_modules/fast-isnumeric/index.js"(exports, module2) {
+          var allBlankCharCodes = require_is_string_blank();
+          module2.exports = function(n2) {
+            var type = typeof n2;
+            if (type === "string") {
+              var original = n2;
+              n2 = +n2;
+              if (n2 === 0 && allBlankCharCodes(original)) return false;
+            } else if (type !== "number") return false;
+            return n2 - n2 < 1;
+          };
+        }
+      });
+      var require_numerical = __commonJS({
+        "src/constants/numerical.js"(exports, module2) {
+          module2.exports = {
+            /**
+             * Standardize all missing data in calcdata to use undefined
+             * never null or NaN.
+             * That way we can use !==undefined, or !== BADNUM,
+             * to test for real data
+             */
+            BADNUM: void 0,
+            /*
+             * Limit certain operations to well below floating point max value
+             * to avoid glitches: Make sure that even when you multiply it by the
+             * number of pixels on a giant screen it still works
+             */
+            FP_SAFE: Number.MAX_VALUE * 1e-4,
+            /*
+             * conversion of date units to milliseconds
+             * year and month constants are marked "AVG"
+             * to remind us that not all years and months
+             * have the same length
+             */
+            ONEMAXYEAR: 316224e5,
+            // 366 * ONEDAY
+            ONEAVGYEAR: 315576e5,
+            // 365.25 days
+            ONEMINYEAR: 31536e6,
+            // 365 * ONEDAY
+            ONEMAXQUARTER: 79488e5,
+            // 92 * ONEDAY
+            ONEAVGQUARTER: 78894e5,
+            // 1/4 of ONEAVGYEAR
+            ONEMINQUARTER: 76896e5,
+            // 89 * ONEDAY
+            ONEMAXMONTH: 26784e5,
+            // 31 * ONEDAY
+            ONEAVGMONTH: 26298e5,
+            // 1/12 of ONEAVGYEAR
+            ONEMINMONTH: 24192e5,
+            // 28 * ONEDAY
+            ONEWEEK: 6048e5,
+            // 7 * ONEDAY
+            ONEDAY: 864e5,
+            // 24 * ONEHOUR
+            ONEHOUR: 36e5,
+            ONEMIN: 6e4,
+            ONESEC: 1e3,
+            ONEMILLI: 1,
+            ONEMICROSEC: 1e-3,
+            /*
+             * For fast conversion btwn world calendars and epoch ms, the Julian Day Number
+             * of the unix epoch. From calendars.instance().newDate(1970, 1, 1).toJD()
+             */
+            EPOCHJD: 24405875e-1,
+            /*
+             * Are two values nearly equal? Compare to 1PPM
+             */
+            ALMOST_EQUAL: 1 - 1e-6,
+            /*
+             * If we're asked to clip a non-positive log value, how far off-screen
+             * do we put it?
+             */
+            LOG_CLIP: 10,
+            /*
+             * not a number, but for displaying numbers: the "minus sign" symbol is
+             * wider than the regular ascii dash "-"
+             */
+            MINUS_SIGN: "−"
+          };
+        }
+      });
+      var require_base64_arraybuffer_umd = __commonJS({
+        "node_modules/base64-arraybuffer/dist/base64-arraybuffer.umd.js"(exports, module2) {
+          (function(global2, factory2) {
+            typeof exports === "object" && typeof module2 !== "undefined" ? factory2(exports) : (global2 = typeof globalThis !== "undefined" ? globalThis : global2 || self, factory2(global2["base64-arraybuffer"] = {}));
+          })(exports, function(exports2) {
+            var chars = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
+            var lookup = typeof Uint8Array === "undefined" ? [] : new Uint8Array(256);
+            for (var i2 = 0; i2 < chars.length; i2++) {
+              lookup[chars.charCodeAt(i2)] = i2;
+            }
+            var encode = function(arraybuffer) {
+              var bytes = new Uint8Array(arraybuffer), i22, len2 = bytes.length, base64 = "";
+              for (i22 = 0; i22 < len2; i22 += 3) {
+                base64 += chars[bytes[i22] >> 2];
+                base64 += chars[(bytes[i22] & 3) << 4 | bytes[i22 + 1] >> 4];
+                base64 += chars[(bytes[i22 + 1] & 15) << 2 | bytes[i22 + 2] >> 6];
+                base64 += chars[bytes[i22 + 2] & 63];
+              }
+              if (len2 % 3 === 2) {
+                base64 = base64.substring(0, base64.length - 1) + "=";
+              } else if (len2 % 3 === 1) {
+                base64 = base64.substring(0, base64.length - 2) + "==";
+              }
+              return base64;
+            };
+            var decode = function(base64) {
+              var bufferLength = base64.length * 0.75, len2 = base64.length, i22, p2 = 0, encoded1, encoded2, encoded3, encoded4;
+              if (base64[base64.length - 1] === "=") {
+                bufferLength--;
+                if (base64[base64.length - 2] === "=") {
+                  bufferLength--;
+                }
+              }
+              var arraybuffer = new ArrayBuffer(bufferLength), bytes = new Uint8Array(arraybuffer);
+              for (i22 = 0; i22 < len2; i22 += 4) {
+                encoded1 = lookup[base64.charCodeAt(i22)];
+                encoded2 = lookup[base64.charCodeAt(i22 + 1)];
+                encoded3 = lookup[base64.charCodeAt(i22 + 2)];
+                encoded4 = lookup[base64.charCodeAt(i22 + 3)];
+                bytes[p2++] = encoded1 << 2 | encoded2 >> 4;
+                bytes[p2++] = (encoded2 & 15) << 4 | encoded3 >> 2;
+                bytes[p2++] = (encoded3 & 3) << 6 | encoded4 & 63;
+              }
+              return arraybuffer;
+            };
+            exports2.decode = decode;
+            exports2.encode = encode;
+            Object.defineProperty(exports2, "__esModule", { value: true });
+          });
+        }
+      });
+      var require_is_plain_object = __commonJS({
+        "src/lib/is_plain_object.js"(exports, module2) {
+          module2.exports = function isPlainObject2(obj) {
+            if (window && window.process && window.process.versions) {
+              return Object.prototype.toString.call(obj) === "[object Object]";
+            }
+            return Object.prototype.toString.call(obj) === "[object Object]" && Object.getPrototypeOf(obj).hasOwnProperty("hasOwnProperty");
+          };
+        }
+      });
+      var require_array = __commonJS({
+        "src/lib/array.js"(exports) {
+          var b64decode = require_base64_arraybuffer_umd().decode;
+          var isPlainObject2 = require_is_plain_object();
+          var isArray2 = Array.isArray;
+          var ab2 = ArrayBuffer;
+          var dv = DataView;
+          function isTypedArray2(a2) {
+            return ab2.isView(a2) && !(a2 instanceof dv);
+          }
+          exports.isTypedArray = isTypedArray2;
+          function isArrayOrTypedArray(a2) {
+            return isArray2(a2) || isTypedArray2(a2);
+          }
+          exports.isArrayOrTypedArray = isArrayOrTypedArray;
+          function isArray1D(a2) {
+            return !isArrayOrTypedArray(a2[0]);
+          }
+          exports.isArray1D = isArray1D;
+          exports.ensureArray = function(out, n2) {
+            if (!isArray2(out)) out = [];
+            out.length = n2;
+            return out;
+          };
+          var typedArrays = {
+            u1c: typeof Uint8ClampedArray === "undefined" ? void 0 : Uint8ClampedArray,
+            // not supported in numpy?
+            i1: typeof Int8Array === "undefined" ? void 0 : Int8Array,
+            u1: typeof Uint8Array === "undefined" ? void 0 : Uint8Array,
+            i2: typeof Int16Array === "undefined" ? void 0 : Int16Array,
+            u2: typeof Uint16Array === "undefined" ? void 0 : Uint16Array,
+            i4: typeof Int32Array === "undefined" ? void 0 : Int32Array,
+            u4: typeof Uint32Array === "undefined" ? void 0 : Uint32Array,
+            f4: typeof Float32Array === "undefined" ? void 0 : Float32Array,
+            f8: typeof Float64Array === "undefined" ? void 0 : Float64Array
+            /* TODO: potentially add Big Int
+
+                i8: typeof BigInt64Array === 'undefined' ? undefined :
+                           BigInt64Array,
+
+                u8: typeof BigUint64Array === 'undefined' ? undefined :
+                           BigUint64Array,
+                */
+          };
+          typedArrays.uint8c = typedArrays.u1c;
+          typedArrays.uint8 = typedArrays.u1;
+          typedArrays.int8 = typedArrays.i1;
+          typedArrays.uint16 = typedArrays.u2;
+          typedArrays.int16 = typedArrays.i2;
+          typedArrays.uint32 = typedArrays.u4;
+          typedArrays.int32 = typedArrays.i4;
+          typedArrays.float32 = typedArrays.f4;
+          typedArrays.float64 = typedArrays.f8;
+          function isArrayBuffer(a2) {
+            return a2.constructor === ArrayBuffer;
+          }
+          exports.isArrayBuffer = isArrayBuffer;
+          exports.decodeTypedArraySpec = function(vIn) {
+            var out = [];
+            var v2 = coerceTypedArraySpec(vIn);
+            var dtype = v2.dtype;
+            var T2 = typedArrays[dtype];
+            if (!T2) throw new Error('Error in dtype: "' + dtype + '"');
+            var BYTES_PER_ELEMENT = T2.BYTES_PER_ELEMENT;
+            var buffer = v2.bdata;
+            if (!isArrayBuffer(buffer)) {
+              buffer = b64decode(buffer);
+            }
+            var shape = v2.shape === void 0 ? (
+              // detect 1-d length
+              [buffer.byteLength / BYTES_PER_ELEMENT]
+            ) : (
+              // convert number to string and split to array
+              ("" + v2.shape).split(",")
+            );
+            shape.reverse();
+            var ndim = shape.length;
+            var nj2, j2;
+            var ni2 = +shape[0];
+            var rowBytes = BYTES_PER_ELEMENT * ni2;
+            var pos = 0;
+            if (ndim === 1) {
+              out = new T2(buffer);
+            } else if (ndim === 2) {
+              nj2 = +shape[1];
+              for (j2 = 0; j2 < nj2; j2++) {
+                out[j2] = new T2(buffer, pos, ni2);
+                pos += rowBytes;
+              }
+            } else if (ndim === 3) {
+              nj2 = +shape[1];
+              var nk2 = +shape[2];
+              for (var k2 = 0; k2 < nk2; k2++) {
+                out[k2] = [];
+                for (j2 = 0; j2 < nj2; j2++) {
+                  out[k2][j2] = new T2(buffer, pos, ni2);
+                  pos += rowBytes;
+                }
+              }
+            } else {
+              throw new Error("ndim: " + ndim + 'is not supported with the shape:"' + v2.shape + '"');
+            }
+            out.bdata = v2.bdata;
+            out.dtype = v2.dtype;
+            out.shape = shape.reverse().join(",");
+            vIn._inputArray = out;
+            return out;
+          };
+          exports.isTypedArraySpec = function(v2) {
+            return isPlainObject2(v2) && v2.hasOwnProperty("dtype") && typeof v2.dtype === "string" && v2.hasOwnProperty("bdata") && (typeof v2.bdata === "string" || isArrayBuffer(v2.bdata)) && (v2.shape === void 0 || v2.hasOwnProperty("shape") && (typeof v2.shape === "string" || typeof v2.shape === "number"));
+          };
+          function coerceTypedArraySpec(v2) {
+            return {
+              bdata: v2.bdata,
+              dtype: v2.dtype,
+              shape: v2.shape
+            };
+          }
+          exports.concat = function() {
+            var args = [];
+            var allArray = true;
+            var totalLen = 0;
+            var _constructor, arg0, i2, argi, posi, leni, out, j2;
+            for (i2 = 0; i2 < arguments.length; i2++) {
+              argi = arguments[i2];
+              leni = argi.length;
+              if (leni) {
+                if (arg0) args.push(argi);
+                else {
+                  arg0 = argi;
+                  posi = leni;
+                }
+                if (isArray2(argi)) {
+                  _constructor = false;
+                } else {
+                  allArray = false;
+                  if (!totalLen) {
+                    _constructor = argi.constructor;
+                  } else if (_constructor !== argi.constructor) {
+                    _constructor = false;
+                  }
+                }
+                totalLen += leni;
+              }
+            }
+            if (!totalLen) return [];
+            if (!args.length) return arg0;
+            if (allArray) return arg0.concat.apply(arg0, args);
+            if (_constructor) {
+              out = new _constructor(totalLen);
+              out.set(arg0);
+              for (i2 = 0; i2 < args.length; i2++) {
+                argi = args[i2];
+                out.set(argi, posi);
+                posi += argi.length;
+              }
+              return out;
+            }
+            out = new Array(totalLen);
+            for (j2 = 0; j2 < arg0.length; j2++) out[j2] = arg0[j2];
+            for (i2 = 0; i2 < args.length; i2++) {
+              argi = args[i2];
+              for (j2 = 0; j2 < argi.length; j2++) out[posi + j2] = argi[j2];
+              posi += j2;
+            }
+            return out;
+          };
+          exports.maxRowLength = function(z2) {
+            return _rowLength(z2, Math.max, 0);
+          };
+          exports.minRowLength = function(z2) {
+            return _rowLength(z2, Math.min, Infinity);
+          };
+          function _rowLength(z2, fn, len0) {
+            if (isArrayOrTypedArray(z2)) {
+              if (isArrayOrTypedArray(z2[0])) {
+                var len2 = len0;
+                for (var i2 = 0; i2 < z2.length; i2++) {
+                  len2 = fn(len2, z2[i2].length);
+                }
+                return len2;
+              } else {
+                return z2.length;
+              }
+            }
+            return 0;
+          }
+        }
+      });
+      var require_nested_property = __commonJS({
+        "src/lib/nested_property.js"(exports, module2) {
+          var isNumeric = require_fast_isnumeric();
+          var isArrayOrTypedArray = require_array().isArrayOrTypedArray;
+          module2.exports = function nestedProperty(container, propStr) {
+            if (isNumeric(propStr)) propStr = String(propStr);
+            else if (typeof propStr !== "string" || propStr.slice(-4) === "[-1]") {
+              throw "bad property string";
+            }
+            var propParts = propStr.split(".");
+            var indexed;
+            var indices;
+            var i2, j2;
+            for (j2 = 0; j2 < propParts.length; j2++) {
+              if (String(propParts[j2]).slice(0, 2) === "__") {
+                throw "bad property string";
+              }
+            }
+            j2 = 0;
+            while (j2 < propParts.length) {
+              indexed = String(propParts[j2]).match(/^([^\[\]]*)((\[\-?[0-9]*\])+)$/);
+              if (indexed) {
+                if (indexed[1]) propParts[j2] = indexed[1];
+                else if (j2 === 0) propParts.splice(0, 1);
+                else throw "bad property string";
+                indices = indexed[2].slice(1, -1).split("][");
+                for (i2 = 0; i2 < indices.length; i2++) {
+                  j2++;
+                  propParts.splice(j2, 0, Number(indices[i2]));
+                }
+              }
+              j2++;
+            }
+            if (typeof container !== "object") {
+              return badContainer(container, propStr, propParts);
+            }
+            return {
+              set: npSet(container, propParts, propStr),
+              get: npGet(container, propParts),
+              astr: propStr,
+              parts: propParts,
+              obj: container
+            };
+          };
+          function npGet(cont, parts) {
+            return function(retainNull) {
+              var curCont = cont;
+              var curPart;
+              var allSame;
+              var out;
+              var i2;
+              var j2;
+              for (i2 = 0; i2 < parts.length - 1; i2++) {
+                curPart = parts[i2];
+                if (curPart === -1) {
+                  allSame = true;
+                  out = [];
+                  for (j2 = 0; j2 < curCont.length; j2++) {
+                    out[j2] = npGet(curCont[j2], parts.slice(i2 + 1))(retainNull);
+                    if (out[j2] !== out[0]) allSame = false;
+                  }
+                  return allSame ? out[0] : out;
+                }
+                if (typeof curPart === "number" && !isArrayOrTypedArray(curCont)) {
+                  return void 0;
+                }
+                curCont = curCont[curPart];
+                if (typeof curCont !== "object" || curCont === null) {
+                  return void 0;
+                }
+              }
+              if (typeof curCont !== "object" || curCont === null) return void 0;
+              out = curCont[parts[i2]];
+              if (!retainNull && out === null) return void 0;
+              return out;
+            };
+          }
+          var ARGS_PATTERN = /(^|\.)args\[/;
+          function isDeletable(val, propStr) {
+            return val === void 0 || val === null && !propStr.match(ARGS_PATTERN);
+          }
+          function npSet(cont, parts, propStr) {
+            return function(val) {
+              var curCont = cont;
+              var propPart = "";
+              var toDelete = isDeletable(val, propStr);
+              var curPart;
+              var i2;
+              for (i2 = 0; i2 < parts.length - 1; i2++) {
+                curPart = parts[i2];
+                if (typeof curPart === "number" && !isArrayOrTypedArray(curCont)) {
+                  throw "array index but container is not an array";
+                }
+                if (curPart === -1) {
+                  toDelete = !setArrayAll(curCont, parts.slice(i2 + 1), val, propStr);
+                  if (toDelete) break;
+                  else return;
+                }
+                if (!checkNewContainer(curCont, curPart, parts[i2 + 1], toDelete)) {
+                  break;
+                }
+                curCont = curCont[curPart];
+                if (typeof curCont !== "object" || curCont === null) {
+                  throw "container is not an object";
+                }
+                propPart = joinPropStr(propPart, curPart);
+              }
+              if (toDelete) {
+                if (i2 === parts.length - 1) {
+                  delete curCont[parts[i2]];
+                  if (Array.isArray(curCont) && +parts[i2] === curCont.length - 1) {
+                    while (curCont.length && curCont[curCont.length - 1] === void 0) {
+                      curCont.pop();
+                    }
+                  }
+                }
+              } else curCont[parts[i2]] = val;
+            };
+          }
+          function joinPropStr(propStr, newPart) {
+            var toAdd = newPart;
+            if (isNumeric(newPart)) toAdd = "[" + newPart + "]";
+            else if (propStr) toAdd = "." + newPart;
+            return propStr + toAdd;
+          }
+          function setArrayAll(containerArray, innerParts, val, propStr) {
+            var arrayVal = isArrayOrTypedArray(val);
+            var allSet = true;
+            var thisVal = val;
+            var thisPropStr = propStr.replace("-1", 0);
+            var deleteThis = arrayVal ? false : isDeletable(val, thisPropStr);
+            var firstPart = innerParts[0];
+            var i2;
+            for (i2 = 0; i2 < containerArray.length; i2++) {
+              thisPropStr = propStr.replace("-1", i2);
+              if (arrayVal) {
+                thisVal = val[i2 % val.length];
+                deleteThis = isDeletable(thisVal, thisPropStr);
+              }
+              if (deleteThis) allSet = false;
+              if (!checkNewContainer(containerArray, i2, firstPart, deleteThis)) {
+                continue;
+              }
+              npSet(containerArray[i2], innerParts, propStr.replace("-1", i2))(thisVal);
+            }
+            return allSet;
+          }
+          function checkNewContainer(container, part, nextPart, toDelete) {
+            if (container[part] === void 0) {
+              if (toDelete) return false;
+              if (typeof nextPart === "number") container[part] = [];
+              else container[part] = {};
+            }
+            return true;
+          }
+          function badContainer(container, propStr, propParts) {
+            return {
+              set: function() {
+                throw "bad container";
+              },
+              get: function() {
+              },
+              astr: propStr,
+              parts: propParts,
+              obj: container
+            };
+          }
+        }
+      });
+      var require_keyed_container = __commonJS({
+        "src/lib/keyed_container.js"(exports, module2) {
+          var nestedProperty = require_nested_property();
+          var SIMPLE_PROPERTY_REGEX = /^\w*$/;
+          var NONE = 0;
+          var NAME = 1;
+          var VALUE = 2;
+          var BOTH = 3;
+          var UNSET = 4;
+          module2.exports = function keyedContainer(baseObj, path, keyName, valueName) {
+            keyName = keyName || "name";
+            valueName = valueName || "value";
+            var i2, arr, baseProp;
+            var changeTypes = {};
+            if (path && path.length) {
+              baseProp = nestedProperty(baseObj, path);
+              arr = baseProp.get();
+            } else {
+              arr = baseObj;
+            }
+            path = path || "";
+            var indexLookup = {};
+            if (arr) {
+              for (i2 = 0; i2 < arr.length; i2++) {
+                indexLookup[arr[i2][keyName]] = i2;
+              }
+            }
+            var isSimpleValueProp = SIMPLE_PROPERTY_REGEX.test(valueName);
+            var obj = {
+              set: function(name2, value) {
+                var changeType = value === null ? UNSET : NONE;
+                if (!arr) {
+                  if (!baseProp || changeType === UNSET) return;
+                  arr = [];
+                  baseProp.set(arr);
+                }
+                var idx = indexLookup[name2];
+                if (idx === void 0) {
+                  if (changeType === UNSET) return;
+                  changeType = changeType | BOTH;
+                  idx = arr.length;
+                  indexLookup[name2] = idx;
+                } else if (value !== (isSimpleValueProp ? arr[idx][valueName] : nestedProperty(arr[idx], valueName).get())) {
+                  changeType = changeType | VALUE;
+                }
+                var newValue = arr[idx] = arr[idx] || {};
+                newValue[keyName] = name2;
+                if (isSimpleValueProp) {
+                  newValue[valueName] = value;
+                } else {
+                  nestedProperty(newValue, valueName).set(value);
+                }
+                if (value !== null) {
+                  changeType = changeType & -5;
+                }
+                changeTypes[idx] = changeTypes[idx] | changeType;
+                return obj;
+              },
+              get: function(name2) {
+                if (!arr) return;
+                var idx = indexLookup[name2];
+                if (idx === void 0) {
+                  return void 0;
+                } else if (isSimpleValueProp) {
+                  return arr[idx][valueName];
+                } else {
+                  return nestedProperty(arr[idx], valueName).get();
+                }
+              },
+              rename: function(name2, newName) {
+                var idx = indexLookup[name2];
+                if (idx === void 0) return obj;
+                changeTypes[idx] = changeTypes[idx] | NAME;
+                indexLookup[newName] = idx;
+                delete indexLookup[name2];
+                arr[idx][keyName] = newName;
+                return obj;
+              },
+              remove: function(name2) {
+                var idx = indexLookup[name2];
+                if (idx === void 0) return obj;
+                var object = arr[idx];
+                if (Object.keys(object).length > 2) {
+                  changeTypes[idx] = changeTypes[idx] | VALUE;
+                  return obj.set(name2, null);
+                }
+                if (isSimpleValueProp) {
+                  for (i2 = idx; i2 < arr.length; i2++) {
+                    changeTypes[i2] = changeTypes[i2] | BOTH;
+                  }
+                  for (i2 = idx; i2 < arr.length; i2++) {
+                    indexLookup[arr[i2][keyName]]--;
+                  }
+                  arr.splice(idx, 1);
+                  delete indexLookup[name2];
+                } else {
+                  nestedProperty(object, valueName).set(null);
+                  changeTypes[idx] = changeTypes[idx] | VALUE | UNSET;
+                }
+                return obj;
+              },
+              constructUpdate: function() {
+                var astr, idx;
+                var update = {};
+                var changed = Object.keys(changeTypes);
+                for (var i22 = 0; i22 < changed.length; i22++) {
+                  idx = changed[i22];
+                  astr = path + "[" + idx + "]";
+                  if (arr[idx]) {
+                    if (changeTypes[idx] & NAME) {
+                      update[astr + "." + keyName] = arr[idx][keyName];
+                    }
+                    if (changeTypes[idx] & VALUE) {
+                      if (isSimpleValueProp) {
+                        update[astr + "." + valueName] = changeTypes[idx] & UNSET ? null : arr[idx][valueName];
+                      } else {
+                        update[astr + "." + valueName] = changeTypes[idx] & UNSET ? null : nestedProperty(arr[idx], valueName).get();
+                      }
+                    }
+                  } else {
+                    update[astr] = null;
+                  }
+                }
+                return update;
+              }
+            };
+            return obj;
+          };
+        }
+      });
+      var require_relative_attr = __commonJS({
+        "src/lib/relative_attr.js"(exports, module2) {
+          var ASCEND = /^(.*)(\.[^\.\[\]]+|\[\d\])$/;
+          var SIMPLEATTR = /^[^\.\[\]]+$/;
+          module2.exports = function(baseAttr, relativeAttr) {
+            while (relativeAttr) {
+              var match = baseAttr.match(ASCEND);
+              if (match) baseAttr = match[1];
+              else if (baseAttr.match(SIMPLEATTR)) baseAttr = "";
+              else throw new Error("bad relativeAttr call:" + [baseAttr, relativeAttr]);
+              if (relativeAttr.charAt(0) === "^") relativeAttr = relativeAttr.slice(1);
+              else break;
+            }
+            if (baseAttr && relativeAttr.charAt(0) !== "[") {
+              return baseAttr + "." + relativeAttr;
+            }
+            return baseAttr + relativeAttr;
+          };
+        }
+      });
+      var require_to_log_range = __commonJS({
+        "src/lib/to_log_range.js"(exports, module2) {
+          var isNumeric = require_fast_isnumeric();
+          module2.exports = function toLogRange(val, range) {
+            if (val > 0) return Math.log(val) / Math.LN10;
+            var newVal = Math.log(Math.min(range[0], range[1])) / Math.LN10;
+            if (!isNumeric(newVal)) newVal = Math.log(Math.max(range[0], range[1])) / Math.LN10 - 6;
+            return newVal;
+          };
+        }
+      });
+      var require_relink_private = __commonJS({
+        "src/lib/relink_private.js"(exports, module2) {
+          var isArrayOrTypedArray = require_array().isArrayOrTypedArray;
+          var isPlainObject2 = require_is_plain_object();
+          module2.exports = function relinkPrivateKeys(toContainer, fromContainer) {
+            for (var k2 in fromContainer) {
+              var fromVal = fromContainer[k2];
+              var toVal = toContainer[k2];
+              if (toVal === fromVal) continue;
+              if (k2.charAt(0) === "_" || typeof fromVal === "function") {
+                if (k2 in toContainer) continue;
+                toContainer[k2] = fromVal;
+              } else if (isArrayOrTypedArray(fromVal) && isArrayOrTypedArray(toVal) && isPlainObject2(fromVal[0])) {
+                if (k2 === "customdata" || k2 === "ids") continue;
+                var minLen = Math.min(fromVal.length, toVal.length);
+                for (var j2 = 0; j2 < minLen; j2++) {
+                  if (toVal[j2] !== fromVal[j2] && isPlainObject2(fromVal[j2]) && isPlainObject2(toVal[j2])) {
+                    relinkPrivateKeys(toVal[j2], fromVal[j2]);
+                  }
+                }
+              } else if (isPlainObject2(fromVal) && isPlainObject2(toVal)) {
+                relinkPrivateKeys(toVal, fromVal);
+                if (!Object.keys(toVal).length) delete toContainer[k2];
+              }
+            }
+          };
+        }
+      });
+      var require_mod = __commonJS({
+        "src/lib/mod.js"(exports, module2) {
+          function mod2(v2, d2) {
+            var out = v2 % d2;
+            return out < 0 ? out + d2 : out;
+          }
+          function modHalf(v2, d2) {
+            return Math.abs(v2) > d2 / 2 ? v2 - Math.round(v2 / d2) * d2 : v2;
+          }
+          module2.exports = {
+            mod: mod2,
+            modHalf
+          };
+        }
+      });
+      var require_tinycolor = __commonJS({
+        "node_modules/tinycolor2/tinycolor.js"(exports, module2) {
+          (function(Math2) {
+            var trimLeft = /^\s+/, trimRight = /\s+$/, tinyCounter = 0, mathRound = Math2.round, mathMin = Math2.min, mathMax = Math2.max, mathRandom = Math2.random;
+            function tinycolor(color22, opts) {
+              color22 = color22 ? color22 : "";
+              opts = opts || {};
+              if (color22 instanceof tinycolor) {
+                return color22;
+              }
+              if (!(this instanceof tinycolor)) {
+                return new tinycolor(color22, opts);
+              }
+              var rgb2 = inputToRGB(color22);
+              this._originalInput = color22, this._r = rgb2.r, this._g = rgb2.g, this._b = rgb2.b, this._a = rgb2.a, this._roundA = mathRound(100 * this._a) / 100, this._format = opts.format || rgb2.format;
+              this._gradientType = opts.gradientType;
+              if (this._r < 1) {
+                this._r = mathRound(this._r);
+              }
+              if (this._g < 1) {
+                this._g = mathRound(this._g);
+              }
+              if (this._b < 1) {
+                this._b = mathRound(this._b);
+              }
+              this._ok = rgb2.ok;
+              this._tc_id = tinyCounter++;
+            }
+            tinycolor.prototype = {
+              isDark: function() {
+                return this.getBrightness() < 128;
+              },
+              isLight: function() {
+                return !this.isDark();
+              },
+              isValid: function() {
+                return this._ok;
+              },
+              getOriginalInput: function() {
+                return this._originalInput;
+              },
+              getFormat: function() {
+                return this._format;
+              },
+              getAlpha: function() {
+                return this._a;
+              },
+              getBrightness: function() {
+                var rgb2 = this.toRgb();
+                return (rgb2.r * 299 + rgb2.g * 587 + rgb2.b * 114) / 1e3;
+              },
+              getLuminance: function() {
+                var rgb2 = this.toRgb();
+                var RsRGB, GsRGB, BsRGB, R2, G2, B22;
+                RsRGB = rgb2.r / 255;
+                GsRGB = rgb2.g / 255;
+                BsRGB = rgb2.b / 255;
+                if (RsRGB <= 0.03928) {
+                  R2 = RsRGB / 12.92;
+                } else {
+                  R2 = Math2.pow((RsRGB + 0.055) / 1.055, 2.4);
+                }
+                if (GsRGB <= 0.03928) {
+                  G2 = GsRGB / 12.92;
+                } else {
+                  G2 = Math2.pow((GsRGB + 0.055) / 1.055, 2.4);
+                }
+                if (BsRGB <= 0.03928) {
+                  B22 = BsRGB / 12.92;
+                } else {
+                  B22 = Math2.pow((BsRGB + 0.055) / 1.055, 2.4);
+                }
+                return 0.2126 * R2 + 0.7152 * G2 + 0.0722 * B22;
+              },
+              setAlpha: function(value) {
+                this._a = boundAlpha(value);
+                this._roundA = mathRound(100 * this._a) / 100;
+                return this;
+              },
+              toHsv: function() {
+                var hsv = rgbToHsv(this._r, this._g, this._b);
+                return { h: hsv.h * 360, s: hsv.s, v: hsv.v, a: this._a };
+              },
+              toHsvString: function() {
+                var hsv = rgbToHsv(this._r, this._g, this._b);
+                var h2 = mathRound(hsv.h * 360), s2 = mathRound(hsv.s * 100), v2 = mathRound(hsv.v * 100);
+                return this._a == 1 ? "hsv(" + h2 + ", " + s2 + "%, " + v2 + "%)" : "hsva(" + h2 + ", " + s2 + "%, " + v2 + "%, " + this._roundA + ")";
+              },
+              toHsl: function() {
+                var hsl3 = rgbToHsl(this._r, this._g, this._b);
+                return { h: hsl3.h * 360, s: hsl3.s, l: hsl3.l, a: this._a };
+              },
+              toHslString: function() {
+                var hsl3 = rgbToHsl(this._r, this._g, this._b);
+                var h2 = mathRound(hsl3.h * 360), s2 = mathRound(hsl3.s * 100), l2 = mathRound(hsl3.l * 100);
+                return this._a == 1 ? "hsl(" + h2 + ", " + s2 + "%, " + l2 + "%)" : "hsla(" + h2 + ", " + s2 + "%, " + l2 + "%, " + this._roundA + ")";
+              },
+              toHex: function(allow3Char) {
+                return rgbToHex(this._r, this._g, this._b, allow3Char);
+              },
+              toHexString: function(allow3Char) {
+                return "#" + this.toHex(allow3Char);
+              },
+              toHex8: function(allow4Char) {
+                return rgbaToHex(this._r, this._g, this._b, this._a, allow4Char);
+              },
+              toHex8String: function(allow4Char) {
+                return "#" + this.toHex8(allow4Char);
+              },
+              toRgb: function() {
+                return { r: mathRound(this._r), g: mathRound(this._g), b: mathRound(this._b), a: this._a };
+              },
+              toRgbString: function() {
+                return this._a == 1 ? "rgb(" + mathRound(this._r) + ", " + mathRound(this._g) + ", " + mathRound(this._b) + ")" : "rgba(" + mathRound(this._r) + ", " + mathRound(this._g) + ", " + mathRound(this._b) + ", " + this._roundA + ")";
+              },
+              toPercentageRgb: function() {
+                return { r: mathRound(bound01(this._r, 255) * 100) + "%", g: mathRound(bound01(this._g, 255) * 100) + "%", b: mathRound(bound01(this._b, 255) * 100) + "%", a: this._a };
+              },
+              toPercentageRgbString: function() {
+                return this._a == 1 ? "rgb(" + mathRound(bound01(this._r, 255) * 100) + "%, " + mathRound(bound01(this._g, 255) * 100) + "%, " + mathRound(bound01(this._b, 255) * 100) + "%)" : "rgba(" + mathRound(bound01(this._r, 255) * 100) + "%, " + mathRound(bound01(this._g, 255) * 100) + "%, " + mathRound(bound01(this._b, 255) * 100) + "%, " + this._roundA + ")";
+              },
+              toName: function() {
+                if (this._a === 0) {
+                  return "transparent";
+                }
+                if (this._a < 1) {
+                  return false;
+                }
+                return hexNames[rgbToHex(this._r, this._g, this._b, true)] || false;
+              },
+              toFilter: function(secondColor) {
+                var hex8String = "#" + rgbaToArgbHex(this._r, this._g, this._b, this._a);
+                var secondHex8String = hex8String;
+                var gradientType = this._gradientType ? "GradientType = 1, " : "";
+                if (secondColor) {
+                  var s2 = tinycolor(secondColor);
+                  secondHex8String = "#" + rgbaToArgbHex(s2._r, s2._g, s2._b, s2._a);
+                }
+                return "progid:DXImageTransform.Microsoft.gradient(" + gradientType + "startColorstr=" + hex8String + ",endColorstr=" + secondHex8String + ")";
+              },
+              toString: function(format) {
+                var formatSet = !!format;
+                format = format || this._format;
+                var formattedString = false;
+                var hasAlpha = this._a < 1 && this._a >= 0;
+                var needsAlphaFormat = !formatSet && hasAlpha && (format === "hex" || format === "hex6" || format === "hex3" || format === "hex4" || format === "hex8" || format === "name");
+                if (needsAlphaFormat) {
+                  if (format === "name" && this._a === 0) {
+                    return this.toName();
+                  }
+                  return this.toRgbString();
+                }
+                if (format === "rgb") {
+                  formattedString = this.toRgbString();
+                }
+                if (format === "prgb") {
+                  formattedString = this.toPercentageRgbString();
+                }
+                if (format === "hex" || format === "hex6") {
+                  formattedString = this.toHexString();
+                }
+                if (format === "hex3") {
+                  formattedString = this.toHexString(true);
+                }
+                if (format === "hex4") {
+                  formattedString = this.toHex8String(true);
+                }
+                if (format === "hex8") {
+                  formattedString = this.toHex8String();
+                }
+                if (format === "name") {
+                  formattedString = this.toName();
+                }
+                if (format === "hsl") {
+                  formattedString = this.toHslString();
+                }
+                if (format === "hsv") {
+                  formattedString = this.toHsvString();
+                }
+                return formattedString || this.toHexString();
+              },
+              clone: function() {
+                return tinycolor(this.toString());
+              },
+              _applyModification: function(fn, args) {
+                var color22 = fn.apply(null, [this].concat([].slice.call(args)));
+                this._r = color22._r;
+                this._g = color22._g;
+                this._b = color22._b;
+                this.setAlpha(color22._a);
+                return this;
+              },
+              lighten: function() {
+                return this._applyModification(lighten, arguments);
+              },
+              brighten: function() {
+                return this._applyModification(brighten, arguments);
+              },
+              darken: function() {
+                return this._applyModification(darken, arguments);
+              },
+              desaturate: function() {
+                return this._applyModification(desaturate, arguments);
+              },
+              saturate: function() {
+                return this._applyModification(saturate, arguments);
+              },
+              greyscale: function() {
+                return this._applyModification(greyscale, arguments);
+              },
+              spin: function() {
+                return this._applyModification(spin, arguments);
+              },
+              _applyCombination: function(fn, args) {
+                return fn.apply(null, [this].concat([].slice.call(args)));
+              },
+              analogous: function() {
+                return this._applyCombination(analogous, arguments);
+              },
+              complement: function() {
+                return this._applyCombination(complement, arguments);
+              },
+              monochromatic: function() {
+                return this._applyCombination(monochromatic, arguments);
+              },
+              splitcomplement: function() {
+                return this._applyCombination(splitcomplement, arguments);
+              },
+              triad: function() {
+                return this._applyCombination(triad, arguments);
+              },
+              tetrad: function() {
+                return this._applyCombination(tetrad, arguments);
+              }
+            };
+            tinycolor.fromRatio = function(color22, opts) {
+              if (typeof color22 == "object") {
+                var newColor = {};
+                for (var i2 in color22) {
+                  if (color22.hasOwnProperty(i2)) {
+                    if (i2 === "a") {
+                      newColor[i2] = color22[i2];
+                    } else {
+                      newColor[i2] = convertToPercentage(color22[i2]);
+                    }
+                  }
+                }
+                color22 = newColor;
+              }
+              return tinycolor(color22, opts);
+            };
+            function inputToRGB(color22) {
+              var rgb2 = { r: 0, g: 0, b: 0 };
+              var a2 = 1;
+              var s2 = null;
+              var v2 = null;
+              var l2 = null;
+              var ok2 = false;
+              var format = false;
+              if (typeof color22 == "string") {
+                color22 = stringInputToObject(color22);
+              }
+              if (typeof color22 == "object") {
+                if (isValidCSSUnit(color22.r) && isValidCSSUnit(color22.g) && isValidCSSUnit(color22.b)) {
+                  rgb2 = rgbToRgb(color22.r, color22.g, color22.b);
+                  ok2 = true;
+                  format = String(color22.r).substr(-1) === "%" ? "prgb" : "rgb";
+                } else if (isValidCSSUnit(color22.h) && isValidCSSUnit(color22.s) && isValidCSSUnit(color22.v)) {
+                  s2 = convertToPercentage(color22.s);
+                  v2 = convertToPercentage(color22.v);
+                  rgb2 = hsvToRgb(color22.h, s2, v2);
+                  ok2 = true;
+                  format = "hsv";
+                } else if (isValidCSSUnit(color22.h) && isValidCSSUnit(color22.s) && isValidCSSUnit(color22.l)) {
+                  s2 = convertToPercentage(color22.s);
+                  l2 = convertToPercentage(color22.l);
+                  rgb2 = hslToRgb(color22.h, s2, l2);
+                  ok2 = true;
+                  format = "hsl";
+                }
+                if (color22.hasOwnProperty("a")) {
+                  a2 = color22.a;
+                }
+              }
+              a2 = boundAlpha(a2);
+              return {
+                ok: ok2,
+                format: color22.format || format,
+                r: mathMin(255, mathMax(rgb2.r, 0)),
+                g: mathMin(255, mathMax(rgb2.g, 0)),
+                b: mathMin(255, mathMax(rgb2.b, 0)),
+                a: a2
+              };
+            }
+            function rgbToRgb(r2, g2, b2) {
+              return {
+                r: bound01(r2, 255) * 255,
+                g: bound01(g2, 255) * 255,
+                b: bound01(b2, 255) * 255
+              };
+            }
+            function rgbToHsl(r2, g2, b2) {
+              r2 = bound01(r2, 255);
+              g2 = bound01(g2, 255);
+              b2 = bound01(b2, 255);
+              var max = mathMax(r2, g2, b2), min = mathMin(r2, g2, b2);
+              var h2, s2, l2 = (max + min) / 2;
+              if (max == min) {
+                h2 = s2 = 0;
+              } else {
+                var d2 = max - min;
+                s2 = l2 > 0.5 ? d2 / (2 - max - min) : d2 / (max + min);
+                switch (max) {
+                  case r2:
+                    h2 = (g2 - b2) / d2 + (g2 < b2 ? 6 : 0);
+                    break;
+                  case g2:
+                    h2 = (b2 - r2) / d2 + 2;
+                    break;
+                  case b2:
+                    h2 = (r2 - g2) / d2 + 4;
+                    break;
+                }
+                h2 /= 6;
+              }
+              return { h: h2, s: s2, l: l2 };
+            }
+            function hslToRgb(h2, s2, l2) {
+              var r2, g2, b2;
+              h2 = bound01(h2, 360);
+              s2 = bound01(s2, 100);
+              l2 = bound01(l2, 100);
+              function hue2rgb(p22, q22, t4) {
+                if (t4 < 0) t4 += 1;
+                if (t4 > 1) t4 -= 1;
+                if (t4 < 1 / 6) return p22 + (q22 - p22) * 6 * t4;
+                if (t4 < 1 / 2) return q22;
+                if (t4 < 2 / 3) return p22 + (q22 - p22) * (2 / 3 - t4) * 6;
+                return p22;
+              }
+              if (s2 === 0) {
+                r2 = g2 = b2 = l2;
+              } else {
+                var q2 = l2 < 0.5 ? l2 * (1 + s2) : l2 + s2 - l2 * s2;
+                var p2 = 2 * l2 - q2;
+                r2 = hue2rgb(p2, q2, h2 + 1 / 3);
+                g2 = hue2rgb(p2, q2, h2);
+                b2 = hue2rgb(p2, q2, h2 - 1 / 3);
+              }
+              return { r: r2 * 255, g: g2 * 255, b: b2 * 255 };
+            }
+            function rgbToHsv(r2, g2, b2) {
+              r2 = bound01(r2, 255);
+              g2 = bound01(g2, 255);
+              b2 = bound01(b2, 255);
+              var max = mathMax(r2, g2, b2), min = mathMin(r2, g2, b2);
+              var h2, s2, v2 = max;
+              var d2 = max - min;
+              s2 = max === 0 ? 0 : d2 / max;
+              if (max == min) {
+                h2 = 0;
+              } else {
+                switch (max) {
+                  case r2:
+                    h2 = (g2 - b2) / d2 + (g2 < b2 ? 6 : 0);
+                    break;
+                  case g2:
+                    h2 = (b2 - r2) / d2 + 2;
+                    break;
+                  case b2:
+                    h2 = (r2 - g2) / d2 + 4;
+                    break;
+                }
+                h2 /= 6;
+              }
+              return { h: h2, s: s2, v: v2 };
+            }
+            function hsvToRgb(h2, s2, v2) {
+              h2 = bound01(h2, 360) * 6;
+              s2 = bound01(s2, 100);
+              v2 = bound01(v2, 100);
+              var i2 = Math2.floor(h2), f2 = h2 - i2, p2 = v2 * (1 - s2), q2 = v2 * (1 - f2 * s2), t4 = v2 * (1 - (1 - f2) * s2), mod2 = i2 % 6, r2 = [v2, q2, p2, p2, t4, v2][mod2], g2 = [t4, v2, v2, q2, p2, p2][mod2], b2 = [p2, p2, t4, v2, v2, q2][mod2];
+              return { r: r2 * 255, g: g2 * 255, b: b2 * 255 };
+            }
+            function rgbToHex(r2, g2, b2, allow3Char) {
+              var hex2 = [
+                pad2(mathRound(r2).toString(16)),
+                pad2(mathRound(g2).toString(16)),
+                pad2(mathRound(b2).toString(16))
+              ];
+              if (allow3Char && hex2[0].charAt(0) == hex2[0].charAt(1) && hex2[1].charAt(0) == hex2[1].charAt(1) && hex2[2].charAt(0) == hex2[2].charAt(1)) {
+                return hex2[0].charAt(0) + hex2[1].charAt(0) + hex2[2].charAt(0);
+              }
+              return hex2.join("");
+            }
+            function rgbaToHex(r2, g2, b2, a2, allow4Char) {
+              var hex2 = [
+                pad2(mathRound(r2).toString(16)),
+                pad2(mathRound(g2).toString(16)),
+                pad2(mathRound(b2).toString(16)),
+                pad2(convertDecimalToHex(a2))
+              ];
+              if (allow4Char && hex2[0].charAt(0) == hex2[0].charAt(1) && hex2[1].charAt(0) == hex2[1].charAt(1) && hex2[2].charAt(0) == hex2[2].charAt(1) && hex2[3].charAt(0) == hex2[3].charAt(1)) {
+                return hex2[0].charAt(0) + hex2[1].charAt(0) + hex2[2].charAt(0) + hex2[3].charAt(0);
+              }
+              return hex2.join("");
+            }
+            function rgbaToArgbHex(r2, g2, b2, a2) {
+              var hex2 = [
+                pad2(convertDecimalToHex(a2)),
+                pad2(mathRound(r2).toString(16)),
+                pad2(mathRound(g2).toString(16)),
+                pad2(mathRound(b2).toString(16))
+              ];
+              return hex2.join("");
+            }
+            tinycolor.equals = function(color1, color22) {
+              if (!color1 || !color22) {
+                return false;
+              }
+              return tinycolor(color1).toRgbString() == tinycolor(color22).toRgbString();
+            };
+            tinycolor.random = function() {
+              return tinycolor.fromRatio({
+                r: mathRandom(),
+                g: mathRandom(),
+                b: mathRandom()
+              });
+            };
+            function desaturate(color22, amount) {
+              amount = amount === 0 ? 0 : amount || 10;
+              var hsl3 = tinycolor(color22).toHsl();
+              hsl3.s -= amount / 100;
+              hsl3.s = clamp01(hsl3.s);
+              return tinycolor(hsl3);
+            }
+            function saturate(color22, amount) {
+              amount = amount === 0 ? 0 : amount || 10;
+              var hsl3 = tinycolor(color22).toHsl();
+              hsl3.s += amount / 100;
+              hsl3.s = clamp01(hsl3.s);
+              return tinycolor(hsl3);
+            }
+            function greyscale(color22) {
+              return tinycolor(color22).desaturate(100);
+            }
+            function lighten(color22, amount) {
+              amount = amount === 0 ? 0 : amount || 10;
+              var hsl3 = tinycolor(color22).toHsl();
+              hsl3.l += amount / 100;
+              hsl3.l = clamp01(hsl3.l);
+              return tinycolor(hsl3);
+            }
+            function brighten(color22, amount) {
+              amount = amount === 0 ? 0 : amount || 10;
+              var rgb2 = tinycolor(color22).toRgb();
+              rgb2.r = mathMax(0, mathMin(255, rgb2.r - mathRound(255 * -(amount / 100))));
+              rgb2.g = mathMax(0, mathMin(255, rgb2.g - mathRound(255 * -(amount / 100))));
+              rgb2.b = mathMax(0, mathMin(255, rgb2.b - mathRound(255 * -(amount / 100))));
+              return tinycolor(rgb2);
+            }
+            function darken(color22, amount) {
+              amount = amount === 0 ? 0 : amount || 10;
+              var hsl3 = tinycolor(color22).toHsl();
+              hsl3.l -= amount / 100;
+              hsl3.l = clamp01(hsl3.l);
+              return tinycolor(hsl3);
+            }
+            function spin(color22, amount) {
+              var hsl3 = tinycolor(color22).toHsl();
+              var hue2 = (hsl3.h + amount) % 360;
+              hsl3.h = hue2 < 0 ? 360 + hue2 : hue2;
+              return tinycolor(hsl3);
+            }
+            function complement(color22) {
+              var hsl3 = tinycolor(color22).toHsl();
+              hsl3.h = (hsl3.h + 180) % 360;
+              return tinycolor(hsl3);
+            }
+            function triad(color22) {
+              var hsl3 = tinycolor(color22).toHsl();
+              var h2 = hsl3.h;
+              return [
+                tinycolor(color22),
+                tinycolor({ h: (h2 + 120) % 360, s: hsl3.s, l: hsl3.l }),
+                tinycolor({ h: (h2 + 240) % 360, s: hsl3.s, l: hsl3.l })
+              ];
+            }
+            function tetrad(color22) {
+              var hsl3 = tinycolor(color22).toHsl();
+              var h2 = hsl3.h;
+              return [
+                tinycolor(color22),
+                tinycolor({ h: (h2 + 90) % 360, s: hsl3.s, l: hsl3.l }),
+                tinycolor({ h: (h2 + 180) % 360, s: hsl3.s, l: hsl3.l }),
+                tinycolor({ h: (h2 + 270) % 360, s: hsl3.s, l: hsl3.l })
+              ];
+            }
+            function splitcomplement(color22) {
+              var hsl3 = tinycolor(color22).toHsl();
+              var h2 = hsl3.h;
+              return [
+                tinycolor(color22),
+                tinycolor({ h: (h2 + 72) % 360, s: hsl3.s, l: hsl3.l }),
+                tinycolor({ h: (h2 + 216) % 360, s: hsl3.s, l: hsl3.l })
+              ];
+            }
+            function analogous(color22, results, slices) {
+              results = results || 6;
+              slices = slices || 30;
+              var hsl3 = tinycolor(color22).toHsl();
+              var part = 360 / slices;
+              var ret = [tinycolor(color22)];
+              for (hsl3.h = (hsl3.h - (part * results >> 1) + 720) % 360; --results; ) {
+                hsl3.h = (hsl3.h + part) % 360;
+                ret.push(tinycolor(hsl3));
+              }
+              return ret;
+            }
+            function monochromatic(color22, results) {
+              results = results || 6;
+              var hsv = tinycolor(color22).toHsv();
+              var h2 = hsv.h, s2 = hsv.s, v2 = hsv.v;
+              var ret = [];
+              var modification = 1 / results;
+              while (results--) {
+                ret.push(tinycolor({ h: h2, s: s2, v: v2 }));
+                v2 = (v2 + modification) % 1;
+              }
+              return ret;
+            }
+            tinycolor.mix = function(color1, color22, amount) {
+              amount = amount === 0 ? 0 : amount || 50;
+              var rgb1 = tinycolor(color1).toRgb();
+              var rgb2 = tinycolor(color22).toRgb();
+              var p2 = amount / 100;
+              var rgba3 = {
+                r: (rgb2.r - rgb1.r) * p2 + rgb1.r,
+                g: (rgb2.g - rgb1.g) * p2 + rgb1.g,
+                b: (rgb2.b - rgb1.b) * p2 + rgb1.b,
+                a: (rgb2.a - rgb1.a) * p2 + rgb1.a
+              };
+              return tinycolor(rgba3);
+            };
+            tinycolor.readability = function(color1, color22) {
+              var c1 = tinycolor(color1);
+              var c2 = tinycolor(color22);
+              return (Math2.max(c1.getLuminance(), c2.getLuminance()) + 0.05) / (Math2.min(c1.getLuminance(), c2.getLuminance()) + 0.05);
+            };
+            tinycolor.isReadable = function(color1, color22, wcag2) {
+              var readability = tinycolor.readability(color1, color22);
+              var wcag2Parms, out;
+              out = false;
+              wcag2Parms = validateWCAG2Parms(wcag2);
+              switch (wcag2Parms.level + wcag2Parms.size) {
+                case "AAsmall":
+                case "AAAlarge":
+                  out = readability >= 4.5;
+                  break;
+                case "AAlarge":
+                  out = readability >= 3;
+                  break;
+                case "AAAsmall":
+                  out = readability >= 7;
+                  break;
+              }
+              return out;
+            };
+            tinycolor.mostReadable = function(baseColor, colorList, args) {
+              var bestColor = null;
+              var bestScore = 0;
+              var readability;
+              var includeFallbackColors, level, size;
+              args = args || {};
+              includeFallbackColors = args.includeFallbackColors;
+              level = args.level;
+              size = args.size;
+              for (var i2 = 0; i2 < colorList.length; i2++) {
+                readability = tinycolor.readability(baseColor, colorList[i2]);
+                if (readability > bestScore) {
+                  bestScore = readability;
+                  bestColor = tinycolor(colorList[i2]);
+                }
+              }
+              if (tinycolor.isReadable(baseColor, bestColor, { "level": level, "size": size }) || !includeFallbackColors) {
+                return bestColor;
+              } else {
+                args.includeFallbackColors = false;
+                return tinycolor.mostReadable(baseColor, ["#fff", "#000"], args);
+              }
+            };
+            var names2 = tinycolor.names = {
+              aliceblue: "f0f8ff",
+              antiquewhite: "faebd7",
+              aqua: "0ff",
+              aquamarine: "7fffd4",
+              azure: "f0ffff",
+              beige: "f5f5dc",
+              bisque: "ffe4c4",
+              black: "000",
+              blanchedalmond: "ffebcd",
+              blue: "00f",
+              blueviolet: "8a2be2",
+              brown: "a52a2a",
+              burlywood: "deb887",
+              burntsienna: "ea7e5d",
+              cadetblue: "5f9ea0",
+              chartreuse: "7fff00",
+              chocolate: "d2691e",
+              coral: "ff7f50",
+              cornflowerblue: "6495ed",
+              cornsilk: "fff8dc",
+              crimson: "dc143c",
+              cyan: "0ff",
+              darkblue: "00008b",
+              darkcyan: "008b8b",
+              darkgoldenrod: "b8860b",
+              darkgray: "a9a9a9",
+              darkgreen: "006400",
+              darkgrey: "a9a9a9",
+              darkkhaki: "bdb76b",
+              darkmagenta: "8b008b",
+              darkolivegreen: "556b2f",
+              darkorange: "ff8c00",
+              darkorchid: "9932cc",
+              darkred: "8b0000",
+              darksalmon: "e9967a",
+              darkseagreen: "8fbc8f",
+              darkslateblue: "483d8b",
+              darkslategray: "2f4f4f",
+              darkslategrey: "2f4f4f",
+              darkturquoise: "00ced1",
+              darkviolet: "9400d3",
+              deeppink: "ff1493",
+              deepskyblue: "00bfff",
+              dimgray: "696969",
+              dimgrey: "696969",
+              dodgerblue: "1e90ff",
+              firebrick: "b22222",
+              floralwhite: "fffaf0",
+              forestgreen: "228b22",
+              fuchsia: "f0f",
+              gainsboro: "dcdcdc",
+              ghostwhite: "f8f8ff",
+              gold: "ffd700",
+              goldenrod: "daa520",
+              gray: "808080",
+              green: "008000",
+              greenyellow: "adff2f",
+              grey: "808080",
+              honeydew: "f0fff0",
+              hotpink: "ff69b4",
+              indianred: "cd5c5c",
+              indigo: "4b0082",
+              ivory: "fffff0",
+              khaki: "f0e68c",
+              lavender: "e6e6fa",
+              lavenderblush: "fff0f5",
+              lawngreen: "7cfc00",
+              lemonchiffon: "fffacd",
+              lightblue: "add8e6",
+              lightcoral: "f08080",
+              lightcyan: "e0ffff",
+              lightgoldenrodyellow: "fafad2",
+              lightgray: "d3d3d3",
+              lightgreen: "90ee90",
+              lightgrey: "d3d3d3",
+              lightpink: "ffb6c1",
+              lightsalmon: "ffa07a",
+              lightseagreen: "20b2aa",
+              lightskyblue: "87cefa",
+              lightslategray: "789",
+              lightslategrey: "789",
+              lightsteelblue: "b0c4de",
+              lightyellow: "ffffe0",
+              lime: "0f0",
+              limegreen: "32cd32",
+              linen: "faf0e6",
+              magenta: "f0f",
+              maroon: "800000",
+              mediumaquamarine: "66cdaa",
+              mediumblue: "0000cd",
+              mediumorchid: "ba55d3",
+              mediumpurple: "9370db",
+              mediumseagreen: "3cb371",
+              mediumslateblue: "7b68ee",
+              mediumspringgreen: "00fa9a",
+              mediumturquoise: "48d1cc",
+              mediumvioletred: "c71585",
+              midnightblue: "191970",
+              mintcream: "f5fffa",
+              mistyrose: "ffe4e1",
+              moccasin: "ffe4b5",
+              navajowhite: "ffdead",
+              navy: "000080",
+              oldlace: "fdf5e6",
+              olive: "808000",
+              olivedrab: "6b8e23",
+              orange: "ffa500",
+              orangered: "ff4500",
+              orchid: "da70d6",
+              palegoldenrod: "eee8aa",
+              palegreen: "98fb98",
+              paleturquoise: "afeeee",
+              palevioletred: "db7093",
+              papayawhip: "ffefd5",
+              peachpuff: "ffdab9",
+              peru: "cd853f",
+              pink: "ffc0cb",
+              plum: "dda0dd",
+              powderblue: "b0e0e6",
+              purple: "800080",
+              rebeccapurple: "663399",
+              red: "f00",
+              rosybrown: "bc8f8f",
+              royalblue: "4169e1",
+              saddlebrown: "8b4513",
+              salmon: "fa8072",
+              sandybrown: "f4a460",
+              seagreen: "2e8b57",
+              seashell: "fff5ee",
+              sienna: "a0522d",
+              silver: "c0c0c0",
+              skyblue: "87ceeb",
+              slateblue: "6a5acd",
+              slategray: "708090",
+              slategrey: "708090",
+              snow: "fffafa",
+              springgreen: "00ff7f",
+              steelblue: "4682b4",
+              tan: "d2b48c",
+              teal: "008080",
+              thistle: "d8bfd8",
+              tomato: "ff6347",
+              turquoise: "40e0d0",
+              violet: "ee82ee",
+              wheat: "f5deb3",
+              white: "fff",
+              whitesmoke: "f5f5f5",
+              yellow: "ff0",
+              yellowgreen: "9acd32"
+            };
+            var hexNames = tinycolor.hexNames = flip(names2);
+            function flip(o2) {
+              var flipped = {};
+              for (var i2 in o2) {
+                if (o2.hasOwnProperty(i2)) {
+                  flipped[o2[i2]] = i2;
+                }
+              }
+              return flipped;
+            }
+            function boundAlpha(a2) {
+              a2 = parseFloat(a2);
+              if (isNaN(a2) || a2 < 0 || a2 > 1) {
+                a2 = 1;
+              }
+              return a2;
+            }
+            function bound01(n2, max) {
+              if (isOnePointZero(n2)) {
+                n2 = "100%";
+              }
+              var processPercent = isPercentage(n2);
+              n2 = mathMin(max, mathMax(0, parseFloat(n2)));
+              if (processPercent) {
+                n2 = parseInt(n2 * max, 10) / 100;
+              }
+              if (Math2.abs(n2 - max) < 1e-6) {
+                return 1;
+              }
+              return n2 % max / parseFloat(max);
+            }
+            function clamp01(val) {
+              return mathMin(1, mathMax(0, val));
+            }
+            function parseIntFromHex(val) {
+              return parseInt(val, 16);
+            }
+            function isOnePointZero(n2) {
+              return typeof n2 == "string" && n2.indexOf(".") != -1 && parseFloat(n2) === 1;
+            }
+            function isPercentage(n2) {
+              return typeof n2 === "string" && n2.indexOf("%") != -1;
+            }
+            function pad2(c2) {
+              return c2.length == 1 ? "0" + c2 : "" + c2;
+            }
+            function convertToPercentage(n2) {
+              if (n2 <= 1) {
+                n2 = n2 * 100 + "%";
+              }
+              return n2;
+            }
+            function convertDecimalToHex(d2) {
+              return Math2.round(parseFloat(d2) * 255).toString(16);
+            }
+            function convertHexToDecimal(h2) {
+              return parseIntFromHex(h2) / 255;
+            }
+            var matchers = function() {
+              var CSS_INTEGER = "[-\\+]?\\d+%?";
+              var CSS_NUMBER = "[-\\+]?\\d*\\.\\d+%?";
+              var CSS_UNIT = "(?:" + CSS_NUMBER + ")|(?:" + CSS_INTEGER + ")";
+              var PERMISSIVE_MATCH3 = "[\\s|\\(]+(" + CSS_UNIT + ")[,|\\s]+(" + CSS_UNIT + ")[,|\\s]+(" + CSS_UNIT + ")\\s*\\)?";
+              var PERMISSIVE_MATCH4 = "[\\s|\\(]+(" + CSS_UNIT + ")[,|\\s]+(" + CSS_UNIT + ")[,|\\s]+(" + CSS_UNIT + ")[,|\\s]+(" + CSS_UNIT + ")\\s*\\)?";
+              return {
+                CSS_UNIT: new RegExp(CSS_UNIT),
+                rgb: new RegExp("rgb" + PERMISSIVE_MATCH3),
+                rgba: new RegExp("rgba" + PERMISSIVE_MATCH4),
+                hsl: new RegExp("hsl" + PERMISSIVE_MATCH3),
+                hsla: new RegExp("hsla" + PERMISSIVE_MATCH4),
+                hsv: new RegExp("hsv" + PERMISSIVE_MATCH3),
+                hsva: new RegExp("hsva" + PERMISSIVE_MATCH4),
+                hex3: /^#?([0-9a-fA-F]{1})([0-9a-fA-F]{1})([0-9a-fA-F]{1})$/,
+                hex6: /^#?([0-9a-fA-F]{2})([0-9a-fA-F]{2})([0-9a-fA-F]{2})$/,
+                hex4: /^#?([0-9a-fA-F]{1})([0-9a-fA-F]{1})([0-9a-fA-F]{1})([0-9a-fA-F]{1})$/,
+                hex8: /^#?([0-9a-fA-F]{2})([0-9a-fA-F]{2})([0-9a-fA-F]{2})([0-9a-fA-F]{2})$/
+              };
+            }();
+            function isValidCSSUnit(color22) {
+              return !!matchers.CSS_UNIT.exec(color22);
+            }
+            function stringInputToObject(color22) {
+              color22 = color22.replace(trimLeft, "").replace(trimRight, "").toLowerCase();
+              var named2 = false;
+              if (names2[color22]) {
+                color22 = names2[color22];
+                named2 = true;
+              } else if (color22 == "transparent") {
+                return { r: 0, g: 0, b: 0, a: 0, format: "name" };
+              }
+              var match;
+              if (match = matchers.rgb.exec(color22)) {
+                return { r: match[1], g: match[2], b: match[3] };
+              }
+              if (match = matchers.rgba.exec(color22)) {
+                return { r: match[1], g: match[2], b: match[3], a: match[4] };
+              }
+              if (match = matchers.hsl.exec(color22)) {
+                return { h: match[1], s: match[2], l: match[3] };
+              }
+              if (match = matchers.hsla.exec(color22)) {
+                return { h: match[1], s: match[2], l: match[3], a: match[4] };
+              }
+              if (match = matchers.hsv.exec(color22)) {
+                return { h: match[1], s: match[2], v: match[3] };
+              }
+              if (match = matchers.hsva.exec(color22)) {
+                return { h: match[1], s: match[2], v: match[3], a: match[4] };
+              }
+              if (match = matchers.hex8.exec(color22)) {
+                return {
+                  r: parseIntFromHex(match[1]),
+                  g: parseIntFromHex(match[2]),
+                  b: parseIntFromHex(match[3]),
+                  a: convertHexToDecimal(match[4]),
+                  format: named2 ? "name" : "hex8"
+                };
+              }
+              if (match = matchers.hex6.exec(color22)) {
+                return {
+                  r: parseIntFromHex(match[1]),
+                  g: parseIntFromHex(match[2]),
+                  b: parseIntFromHex(match[3]),
+                  format: named2 ? "name" : "hex"
+                };
+              }
+              if (match = matchers.hex4.exec(color22)) {
+                return {
+                  r: parseIntFromHex(match[1] + "" + match[1]),
+                  g: parseIntFromHex(match[2] + "" + match[2]),
+                  b: parseIntFromHex(match[3] + "" + match[3]),
+                  a: convertHexToDecimal(match[4] + "" + match[4]),
+                  format: named2 ? "name" : "hex8"
+                };
+              }
+              if (match = matchers.hex3.exec(color22)) {
+                return {
+                  r: parseIntFromHex(match[1] + "" + match[1]),
+                  g: parseIntFromHex(match[2] + "" + match[2]),
+                  b: parseIntFromHex(match[3] + "" + match[3]),
+                  format: named2 ? "name" : "hex"
+                };
+              }
+              return false;
+            }
+            function validateWCAG2Parms(parms) {
+              var level, size;
+              parms = parms || { "level": "AA", "size": "small" };
+              level = (parms.level || "AA").toUpperCase();
+              size = (parms.size || "small").toLowerCase();
+              if (level !== "AA" && level !== "AAA") {
+                level = "AA";
+              }
+              if (size !== "small" && size !== "large") {
+                size = "small";
+              }
+              return { "level": level, "size": size };
+            }
+            if (typeof module2 !== "undefined" && module2.exports) {
+              module2.exports = tinycolor;
+            } else {
+              window.tinycolor = tinycolor;
+            }
+          })(Math);
+        }
+      });
+      var require_extend = __commonJS({
+        "src/lib/extend.js"(exports) {
+          var isPlainObject2 = require_is_plain_object();
+          var isArray2 = Array.isArray;
+          function primitivesLoopSplice(source2, target) {
+            var i2, value;
+            for (i2 = 0; i2 < source2.length; i2++) {
+              value = source2[i2];
+              if (value !== null && typeof value === "object") {
+                return false;
+              }
+              if (value !== void 0) {
+                target[i2] = value;
+              }
+            }
+            return true;
+          }
+          exports.extendFlat = function() {
+            return _extend(arguments, false, false, false);
+          };
+          exports.extendDeep = function() {
+            return _extend(arguments, true, false, false);
+          };
+          exports.extendDeepAll = function() {
+            return _extend(arguments, true, true, false);
+          };
+          exports.extendDeepNoArrays = function() {
+            return _extend(arguments, true, false, true);
+          };
+          function _extend(inputs, isDeep, keepAllKeys, noArrayCopies) {
+            var target = inputs[0];
+            var length2 = inputs.length;
+            var input, key, src, copy, copyIsArray, clone, allPrimitives;
+            if (length2 === 2 && isArray2(target) && isArray2(inputs[1]) && target.length === 0) {
+              allPrimitives = primitivesLoopSplice(inputs[1], target);
+              if (allPrimitives) {
+                return target;
+              } else {
+                target.splice(0, target.length);
+              }
+            }
+            for (var i2 = 1; i2 < length2; i2++) {
+              input = inputs[i2];
+              for (key in input) {
+                src = target[key];
+                copy = input[key];
+                if (noArrayCopies && isArray2(copy)) {
+                  target[key] = copy;
+                } else if (isDeep && copy && (isPlainObject2(copy) || (copyIsArray = isArray2(copy)))) {
+                  if (copyIsArray) {
+                    copyIsArray = false;
+                    clone = src && isArray2(src) ? src : [];
+                  } else {
+                    clone = src && isPlainObject2(src) ? src : {};
+                  }
+                  target[key] = _extend([clone, copy], isDeep, keepAllKeys, noArrayCopies);
+                } else if (typeof copy !== "undefined" || keepAllKeys) {
+                  target[key] = copy;
+                }
+              }
+            }
+            return target;
+          }
+        }
+      });
+      var require_font_attributes = __commonJS({
+        "src/plots/font_attributes.js"(exports, module2) {
+          module2.exports = function(opts) {
+            var variantValues = opts.variantValues;
+            var editType = opts.editType;
+            var colorEditType = opts.colorEditType;
+            if (colorEditType === void 0) colorEditType = editType;
+            var weight = {
+              editType,
+              valType: "integer",
+              min: 1,
+              max: 1e3,
+              extras: ["normal", "bold"],
+              dflt: "normal"
+            };
+            if (opts.noNumericWeightValues) {
+              weight.valType = "enumerated";
+              weight.values = weight.extras;
+              weight.extras = void 0;
+              weight.min = void 0;
+              weight.max = void 0;
+            }
+            var attrs = {
+              family: {
+                valType: "string",
+                noBlank: true,
+                strict: true,
+                editType
+              },
+              size: {
+                valType: "number",
+                min: 1,
+                editType
+              },
+              color: {
+                valType: "color",
+                editType: colorEditType
+              },
+              weight,
+              style: {
+                editType,
+                valType: "enumerated",
+                values: ["normal", "italic"],
+                dflt: "normal"
+              },
+              variant: opts.noFontVariant ? void 0 : {
+                editType,
+                valType: "enumerated",
+                values: variantValues || [
+                  "normal",
+                  "small-caps",
+                  "all-small-caps",
+                  "all-petite-caps",
+                  "petite-caps",
+                  "unicase"
+                ],
+                dflt: "normal"
+              },
+              textcase: opts.noFontTextcase ? void 0 : {
+                editType,
+                valType: "enumerated",
+                values: ["normal", "word caps", "upper", "lower"],
+                dflt: "normal"
+              },
+              lineposition: opts.noFontLineposition ? void 0 : {
+                editType,
+                valType: "flaglist",
+                flags: ["under", "over", "through"],
+                extras: ["none"],
+                dflt: "none"
+              },
+              shadow: opts.noFontShadow ? void 0 : {
+                editType,
+                valType: "string",
+                dflt: opts.autoShadowDflt ? "auto" : "none"
+              },
+              editType
+              // blank strings so compress_attributes can remove
+              // TODO - that's uber hacky... better solution?
+            };
+            if (opts.autoSize) attrs.size.dflt = "auto";
+            if (opts.autoColor) attrs.color.dflt = "auto";
+            if (opts.arrayOk) {
+              attrs.family.arrayOk = true;
+              attrs.weight.arrayOk = true;
+              attrs.style.arrayOk = true;
+              if (!opts.noFontVariant) {
+                attrs.variant.arrayOk = true;
+              }
+              if (!opts.noFontTextcase) {
+                attrs.textcase.arrayOk = true;
+              }
+              if (!opts.noFontLineposition) {
+                attrs.lineposition.arrayOk = true;
+              }
+              if (!opts.noFontShadow) {
+                attrs.shadow.arrayOk = true;
+              }
+              attrs.size.arrayOk = true;
+              attrs.color.arrayOk = true;
+            }
+            return attrs;
+          };
+        }
+      });
+      var require_constants = __commonJS({
+        "src/components/fx/constants.js"(exports, module2) {
+          module2.exports = {
+            // hover labels for multiple horizontal bars get tilted by this angle
+            YANGLE: 60,
+            // size and display constants for hover text
+            // pixel size of hover arrows
+            HOVERARROWSIZE: 6,
+            // pixels padding around text
+            HOVERTEXTPAD: 3,
+            // hover font
+            HOVERFONTSIZE: 13,
+            HOVERFONT: "Arial, sans-serif",
+            // minimum time (msec) between hover calls
+            HOVERMINTIME: 50,
+            // ID suffix (with fullLayout._uid) for hover events in the throttle cache
+            HOVERID: "-hover"
+          };
+        }
+      });
+      var require_layout_attributes = __commonJS({
+        "src/components/fx/layout_attributes.js"(exports, module2) {
+          var constants = require_constants();
+          var fontAttrs = require_font_attributes();
+          var font = fontAttrs({
+            editType: "none"
+          });
+          font.family.dflt = constants.HOVERFONT;
+          font.size.dflt = constants.HOVERFONTSIZE;
+          module2.exports = {
+            clickmode: {
+              valType: "flaglist",
+              flags: ["event", "select"],
+              dflt: "event",
+              editType: "plot",
+              extras: ["none"]
+            },
+            dragmode: {
+              valType: "enumerated",
+              values: [
+                "zoom",
+                "pan",
+                "select",
+                "lasso",
+                "drawclosedpath",
+                "drawopenpath",
+                "drawline",
+                "drawrect",
+                "drawcircle",
+                "orbit",
+                "turntable",
+                false
+              ],
+              dflt: "zoom",
+              editType: "modebar"
+            },
+            hovermode: {
+              valType: "enumerated",
+              values: ["x", "y", "closest", false, "x unified", "y unified"],
+              dflt: "closest",
+              editType: "modebar"
+            },
+            hoversubplots: {
+              valType: "enumerated",
+              values: ["single", "overlaying", "axis"],
+              dflt: "overlaying",
+              editType: "none"
+            },
+            hoverdistance: {
+              valType: "integer",
+              min: -1,
+              dflt: 20,
+              editType: "none"
+            },
+            spikedistance: {
+              valType: "integer",
+              min: -1,
+              dflt: -1,
+              editType: "none"
+            },
+            hoverlabel: {
+              bgcolor: {
+                valType: "color",
+                editType: "none"
+              },
+              bordercolor: {
+                valType: "color",
+                editType: "none"
+              },
+              font,
+              grouptitlefont: fontAttrs({
+                editType: "none"
+              }),
+              align: {
+                valType: "enumerated",
+                values: ["left", "right", "auto"],
+                dflt: "auto",
+                editType: "none"
+              },
+              namelength: {
+                valType: "integer",
+                min: -1,
+                dflt: 15,
+                editType: "none"
+              },
+              showarrow: {
+                valType: "boolean",
+                dflt: true,
+                editType: "none"
+              },
+              editType: "none"
+            },
+            selectdirection: {
+              valType: "enumerated",
+              values: ["h", "v", "d", "any"],
+              dflt: "any",
+              editType: "none"
+            }
+          };
+        }
+      });
+      var require_attributes = __commonJS({
+        "src/components/fx/attributes.js"(exports, module2) {
+          var fontAttrs = require_font_attributes();
+          var hoverLabelAttrs = require_layout_attributes().hoverlabel;
+          var extendFlat = require_extend().extendFlat;
+          module2.exports = {
+            hoverlabel: {
+              bgcolor: extendFlat({}, hoverLabelAttrs.bgcolor, {
+                arrayOk: true
+              }),
+              bordercolor: extendFlat({}, hoverLabelAttrs.bordercolor, {
+                arrayOk: true
+              }),
+              font: fontAttrs({
+                arrayOk: true,
+                editType: "none"
+              }),
+              align: extendFlat({}, hoverLabelAttrs.align, { arrayOk: true }),
+              namelength: extendFlat({}, hoverLabelAttrs.namelength, { arrayOk: true }),
+              showarrow: extendFlat({}, hoverLabelAttrs.showarrow),
+              editType: "none"
+            }
+          };
+        }
+      });
+      var require_attributes2 = __commonJS({
+        "src/plots/attributes.js"(exports, module2) {
+          var fontAttrs = require_font_attributes();
+          var fxAttrs = require_attributes();
+          module2.exports = {
+            type: {
+              valType: "enumerated",
+              values: [],
+              // listed dynamically
+              dflt: "scatter",
+              editType: "calc+clearAxisTypes",
+              _noTemplating: true
+              // we handle this at a higher level
+            },
+            visible: {
+              valType: "enumerated",
+              values: [true, false, "legendonly"],
+              dflt: true,
+              editType: "calc"
+            },
+            showlegend: {
+              valType: "boolean",
+              dflt: true,
+              editType: "style"
+            },
+            legend: {
+              valType: "subplotid",
+              dflt: "legend",
+              editType: "style"
+            },
+            legendgroup: {
+              valType: "string",
+              dflt: "",
+              editType: "style"
+            },
+            legendgrouptitle: {
+              text: {
+                valType: "string",
+                dflt: "",
+                editType: "style"
+              },
+              font: fontAttrs({
+                editType: "style"
+              }),
+              editType: "style"
+            },
+            legendrank: {
+              valType: "number",
+              dflt: 1e3,
+              editType: "style"
+            },
+            legendwidth: {
+              valType: "number",
+              min: 0,
+              editType: "style"
+            },
+            opacity: {
+              valType: "number",
+              min: 0,
+              max: 1,
+              dflt: 1,
+              editType: "style"
+            },
+            name: {
+              valType: "string",
+              editType: "style"
+            },
+            uid: {
+              valType: "string",
+              editType: "plot",
+              anim: true
+            },
+            ids: {
+              valType: "data_array",
+              editType: "calc",
+              anim: true
+            },
+            customdata: {
+              valType: "data_array",
+              editType: "calc"
+            },
+            meta: {
+              valType: "any",
+              arrayOk: true,
+              editType: "plot"
+            },
+            // N.B. these cannot be 'data_array' as they do not have the same length as
+            // other data arrays and arrayOk attributes in general
+            //
+            // Maybe add another valType:
+            // https://github.com/plotly/plotly.js/issues/1894
+            selectedpoints: {
+              valType: "any",
+              editType: "calc"
+            },
+            hoverinfo: {
+              valType: "flaglist",
+              flags: ["x", "y", "z", "text", "name"],
+              extras: ["all", "none", "skip"],
+              arrayOk: true,
+              dflt: "all",
+              editType: "none"
+            },
+            hoverlabel: fxAttrs.hoverlabel,
+            stream: {
+              token: {
+                valType: "string",
+                noBlank: true,
+                strict: true,
+                editType: "calc"
+              },
+              maxpoints: {
+                valType: "number",
+                min: 0,
+                max: 1e4,
+                dflt: 500,
+                editType: "calc"
+              },
+              editType: "calc"
+            },
+            uirevision: {
+              valType: "any",
+              editType: "none"
+            }
+          };
+        }
+      });
+      var require_scales = __commonJS({
+        "src/components/colorscale/scales.js"(exports, module2) {
+          var tinycolor = require_tinycolor();
+          var scales = {
+            Greys: [
+              [0, "rgb(0,0,0)"],
+              [1, "rgb(255,255,255)"]
+            ],
+            YlGnBu: [
+              [0, "rgb(8,29,88)"],
+              [0.125, "rgb(37,52,148)"],
+              [0.25, "rgb(34,94,168)"],
+              [0.375, "rgb(29,145,192)"],
+              [0.5, "rgb(65,182,196)"],
+              [0.625, "rgb(127,205,187)"],
+              [0.75, "rgb(199,233,180)"],
+              [0.875, "rgb(237,248,217)"],
+              [1, "rgb(255,255,217)"]
+            ],
+            Greens: [
+              [0, "rgb(0,68,27)"],
+              [0.125, "rgb(0,109,44)"],
+              [0.25, "rgb(35,139,69)"],
+              [0.375, "rgb(65,171,93)"],
+              [0.5, "rgb(116,196,118)"],
+              [0.625, "rgb(161,217,155)"],
+              [0.75, "rgb(199,233,192)"],
+              [0.875, "rgb(229,245,224)"],
+              [1, "rgb(247,252,245)"]
+            ],
+            YlOrRd: [
+              [0, "rgb(128,0,38)"],
+              [0.125, "rgb(189,0,38)"],
+              [0.25, "rgb(227,26,28)"],
+              [0.375, "rgb(252,78,42)"],
+              [0.5, "rgb(253,141,60)"],
+              [0.625, "rgb(254,178,76)"],
+              [0.75, "rgb(254,217,118)"],
+              [0.875, "rgb(255,237,160)"],
+              [1, "rgb(255,255,204)"]
+            ],
+            Bluered: [
+              [0, "rgb(0,0,255)"],
+              [1, "rgb(255,0,0)"]
+            ],
+            // modified RdBu based on
+            // http://www.kennethmoreland.com/color-maps/
+            RdBu: [
+              [0, "rgb(5,10,172)"],
+              [0.35, "rgb(106,137,247)"],
+              [0.5, "rgb(190,190,190)"],
+              [0.6, "rgb(220,170,132)"],
+              [0.7, "rgb(230,145,90)"],
+              [1, "rgb(178,10,28)"]
+            ],
+            // Scale for non-negative numeric values
+            Reds: [
+              [0, "rgb(220,220,220)"],
+              [0.2, "rgb(245,195,157)"],
+              [0.4, "rgb(245,160,105)"],
+              [1, "rgb(178,10,28)"]
+            ],
+            // Scale for non-positive numeric values
+            Blues: [
+              [0, "rgb(5,10,172)"],
+              [0.35, "rgb(40,60,190)"],
+              [0.5, "rgb(70,100,245)"],
+              [0.6, "rgb(90,120,245)"],
+              [0.7, "rgb(106,137,247)"],
+              [1, "rgb(220,220,220)"]
+            ],
+            Picnic: [
+              [0, "rgb(0,0,255)"],
+              [0.1, "rgb(51,153,255)"],
+              [0.2, "rgb(102,204,255)"],
+              [0.3, "rgb(153,204,255)"],
+              [0.4, "rgb(204,204,255)"],
+              [0.5, "rgb(255,255,255)"],
+              [0.6, "rgb(255,204,255)"],
+              [0.7, "rgb(255,153,255)"],
+              [0.8, "rgb(255,102,204)"],
+              [0.9, "rgb(255,102,102)"],
+              [1, "rgb(255,0,0)"]
+            ],
+            Rainbow: [
+              [0, "rgb(150,0,90)"],
+              [0.125, "rgb(0,0,200)"],
+              [0.25, "rgb(0,25,255)"],
+              [0.375, "rgb(0,152,255)"],
+              [0.5, "rgb(44,255,150)"],
+              [0.625, "rgb(151,255,0)"],
+              [0.75, "rgb(255,234,0)"],
+              [0.875, "rgb(255,111,0)"],
+              [1, "rgb(255,0,0)"]
+            ],
+            Portland: [
+              [0, "rgb(12,51,131)"],
+              [0.25, "rgb(10,136,186)"],
+              [0.5, "rgb(242,211,56)"],
+              [0.75, "rgb(242,143,56)"],
+              [1, "rgb(217,30,30)"]
+            ],
+            Jet: [
+              [0, "rgb(0,0,131)"],
+              [0.125, "rgb(0,60,170)"],
+              [0.375, "rgb(5,255,255)"],
+              [0.625, "rgb(255,255,0)"],
+              [0.875, "rgb(250,0,0)"],
+              [1, "rgb(128,0,0)"]
+            ],
+            Hot: [
+              [0, "rgb(0,0,0)"],
+              [0.3, "rgb(230,0,0)"],
+              [0.6, "rgb(255,210,0)"],
+              [1, "rgb(255,255,255)"]
+            ],
+            Blackbody: [
+              [0, "rgb(0,0,0)"],
+              [0.2, "rgb(230,0,0)"],
+              [0.4, "rgb(230,210,0)"],
+              [0.7, "rgb(255,255,255)"],
+              [1, "rgb(160,200,255)"]
+            ],
+            Earth: [
+              [0, "rgb(0,0,130)"],
+              [0.1, "rgb(0,180,180)"],
+              [0.2, "rgb(40,210,40)"],
+              [0.4, "rgb(230,230,50)"],
+              [0.6, "rgb(120,70,20)"],
+              [1, "rgb(255,255,255)"]
+            ],
+            Electric: [
+              [0, "rgb(0,0,0)"],
+              [0.15, "rgb(30,0,100)"],
+              [0.4, "rgb(120,0,100)"],
+              [0.6, "rgb(160,90,0)"],
+              [0.8, "rgb(230,200,0)"],
+              [1, "rgb(255,250,220)"]
+            ],
+            Viridis: [
+              [0, "#440154"],
+              [0.06274509803921569, "#48186a"],
+              [0.12549019607843137, "#472d7b"],
+              [0.18823529411764706, "#424086"],
+              [0.25098039215686274, "#3b528b"],
+              [0.3137254901960784, "#33638d"],
+              [0.3764705882352941, "#2c728e"],
+              [0.4392156862745098, "#26828e"],
+              [0.5019607843137255, "#21918c"],
+              [0.5647058823529412, "#1fa088"],
+              [0.6274509803921569, "#28ae80"],
+              [0.6901960784313725, "#3fbc73"],
+              [0.7529411764705882, "#5ec962"],
+              [0.8156862745098039, "#84d44b"],
+              [0.8784313725490196, "#addc30"],
+              [0.9411764705882353, "#d8e219"],
+              [1, "#fde725"]
+            ],
+            Cividis: [
+              [0, "rgb(0,32,76)"],
+              [0.058824, "rgb(0,42,102)"],
+              [0.117647, "rgb(0,52,110)"],
+              [0.176471, "rgb(39,63,108)"],
+              [0.235294, "rgb(60,74,107)"],
+              [0.294118, "rgb(76,85,107)"],
+              [0.352941, "rgb(91,95,109)"],
+              [0.411765, "rgb(104,106,112)"],
+              [0.470588, "rgb(117,117,117)"],
+              [0.529412, "rgb(131,129,120)"],
+              [0.588235, "rgb(146,140,120)"],
+              [0.647059, "rgb(161,152,118)"],
+              [0.705882, "rgb(176,165,114)"],
+              [0.764706, "rgb(192,177,109)"],
+              [0.823529, "rgb(209,191,102)"],
+              [0.882353, "rgb(225,204,92)"],
+              [0.941176, "rgb(243,219,79)"],
+              [1, "rgb(255,233,69)"]
+            ]
+          };
+          var defaultScale = scales.RdBu;
+          function getScale2(scl, dflt) {
+            if (!dflt) dflt = defaultScale;
+            if (!scl) return dflt;
+            function parseScale() {
+              try {
+                scl = scales[scl] || JSON.parse(scl);
+              } catch (e2) {
+                scl = dflt;
+              }
+            }
+            if (typeof scl === "string") {
+              parseScale();
+              if (typeof scl === "string") parseScale();
+            }
+            if (!isValidScaleArray(scl)) return dflt;
+            return scl;
+          }
+          function isValidScaleArray(scl) {
+            var highestVal = 0;
+            if (!Array.isArray(scl) || scl.length < 2) return false;
+            if (!scl[0] || !scl[scl.length - 1]) return false;
+            if (+scl[0][0] !== 0 || +scl[scl.length - 1][0] !== 1) return false;
+            for (var i2 = 0; i2 < scl.length; i2++) {
+              var si2 = scl[i2];
+              if (si2.length !== 2 || +si2[0] < highestVal || !tinycolor(si2[1]).isValid()) {
+                return false;
+              }
+              highestVal = +si2[0];
+            }
+            return true;
+          }
+          function isValidScale(scl) {
+            if (scales[scl] !== void 0) return true;
+            else return isValidScaleArray(scl);
+          }
+          module2.exports = {
+            scales,
+            defaultScale,
+            get: getScale2,
+            isValid: isValidScale
+          };
+        }
+      });
+      var require_attributes3 = __commonJS({
+        "src/components/color/attributes.js"(exports) {
+          exports.defaults = [
+            "#1f77b4",
+            // muted blue
+            "#ff7f0e",
+            // safety orange
+            "#2ca02c",
+            // cooked asparagus green
+            "#d62728",
+            // brick red
+            "#9467bd",
+            // muted purple
+            "#8c564b",
+            // chestnut brown
+            "#e377c2",
+            // raspberry yogurt pink
+            "#7f7f7f",
+            // middle gray
+            "#bcbd22",
+            // curry yellow-green
+            "#17becf"
+            // blue-teal
+          ];
+          exports.defaultLine = "#444";
+          exports.lightLine = "#eee";
+          exports.background = "#fff";
+          exports.borderLine = "#BEC8D9";
+          exports.lightFraction = 100 * (14 - 4) / (15 - 4);
+        }
+      });
+      var require_color = __commonJS({
+        "src/components/color/index.js"(exports, module2) {
+          var tinycolor = require_tinycolor();
+          var isNumeric = require_fast_isnumeric();
+          var isTypedArray2 = require_array().isTypedArray;
+          var color22 = module2.exports = {};
+          var colorAttrs = require_attributes3();
+          color22.defaults = colorAttrs.defaults;
+          var defaultLine = color22.defaultLine = colorAttrs.defaultLine;
+          color22.lightLine = colorAttrs.lightLine;
+          var background = color22.background = colorAttrs.background;
+          color22.tinyRGB = function(tc2) {
+            var c2 = tc2.toRgb();
+            return "rgb(" + Math.round(c2.r) + ", " + Math.round(c2.g) + ", " + Math.round(c2.b) + ")";
+          };
+          color22.rgb = function(cstr) {
+            return color22.tinyRGB(tinycolor(cstr));
+          };
+          color22.opacity = function(cstr) {
+            return cstr ? tinycolor(cstr).getAlpha() : 0;
+          };
+          color22.addOpacity = function(cstr, op) {
+            var c2 = tinycolor(cstr).toRgb();
+            return "rgba(" + Math.round(c2.r) + ", " + Math.round(c2.g) + ", " + Math.round(c2.b) + ", " + op + ")";
+          };
+          color22.combine = function(front, back) {
+            var fc2 = tinycolor(front).toRgb();
+            if (fc2.a === 1) return tinycolor(front).toRgbString();
+            var bc2 = tinycolor(back || background).toRgb();
+            var bcflat = bc2.a === 1 ? bc2 : {
+              r: 255 * (1 - bc2.a) + bc2.r * bc2.a,
+              g: 255 * (1 - bc2.a) + bc2.g * bc2.a,
+              b: 255 * (1 - bc2.a) + bc2.b * bc2.a
+            };
+            var fcflat = {
+              r: bcflat.r * (1 - fc2.a) + fc2.r * fc2.a,
+              g: bcflat.g * (1 - fc2.a) + fc2.g * fc2.a,
+              b: bcflat.b * (1 - fc2.a) + fc2.b * fc2.a
+            };
+            return tinycolor(fcflat).toRgbString();
+          };
+          color22.interpolate = function(first, second, factor) {
+            var fc2 = tinycolor(first).toRgb();
+            var sc2 = tinycolor(second).toRgb();
+            var ic2 = {
+              r: factor * fc2.r + (1 - factor) * sc2.r,
+              g: factor * fc2.g + (1 - factor) * sc2.g,
+              b: factor * fc2.b + (1 - factor) * sc2.b
+            };
+            return tinycolor(ic2).toRgbString();
+          };
+          color22.contrast = function(cstr, lightAmount, darkAmount) {
+            var tc2 = tinycolor(cstr);
+            if (tc2.getAlpha() !== 1) tc2 = tinycolor(color22.combine(cstr, background));
+            var newColor = tc2.isDark() ? lightAmount ? tc2.lighten(lightAmount) : background : darkAmount ? tc2.darken(darkAmount) : defaultLine;
+            return newColor.toString();
+          };
+          color22.stroke = function(s2, c2) {
+            var tc2 = tinycolor(c2);
+            s2.style({ stroke: color22.tinyRGB(tc2), "stroke-opacity": tc2.getAlpha() });
+          };
+          color22.fill = function(s2, c2) {
+            var tc2 = tinycolor(c2);
+            s2.style({
+              fill: color22.tinyRGB(tc2),
+              "fill-opacity": tc2.getAlpha()
+            });
+          };
+          color22.clean = function(container) {
+            if (!container || typeof container !== "object") return;
+            var keys = Object.keys(container);
+            var i2, j2, key, val;
+            for (i2 = 0; i2 < keys.length; i2++) {
+              key = keys[i2];
+              val = container[key];
+              if (key.slice(-5) === "color") {
+                if (Array.isArray(val)) {
+                  for (j2 = 0; j2 < val.length; j2++) val[j2] = cleanOne(val[j2]);
+                } else container[key] = cleanOne(val);
+              } else if (key.slice(-10) === "colorscale" && Array.isArray(val)) {
+                for (j2 = 0; j2 < val.length; j2++) {
+                  if (Array.isArray(val[j2])) val[j2][1] = cleanOne(val[j2][1]);
+                }
+              } else if (Array.isArray(val)) {
+                var el0 = val[0];
+                if (!Array.isArray(el0) && el0 && typeof el0 === "object") {
+                  for (j2 = 0; j2 < val.length; j2++) color22.clean(val[j2]);
+                }
+              } else if (val && typeof val === "object" && !isTypedArray2(val)) color22.clean(val);
+            }
+          };
+          function cleanOne(val) {
+            if (isNumeric(val) || typeof val !== "string") return val;
+            var valTrim = val.trim();
+            if (valTrim.slice(0, 3) !== "rgb") return val;
+            var match = valTrim.match(/^rgba?\s*\(([^()]*)\)$/);
+            if (!match) return val;
+            var parts = match[1].trim().split(/\s*[\s,]\s*/);
+            var rgba3 = valTrim.charAt(3) === "a" && parts.length === 4;
+            if (!rgba3 && parts.length !== 3) return val;
+            for (var i2 = 0; i2 < parts.length; i2++) {
+              if (!parts[i2].length) return val;
+              parts[i2] = Number(parts[i2]);
+              if (!(parts[i2] >= 0)) {
+                return val;
+              }
+              if (i2 === 3) {
+                if (parts[i2] > 1) parts[i2] = 1;
+              } else if (parts[i2] >= 1) {
+                return val;
+              }
+            }
+            var rgbStr = Math.round(parts[0] * 255) + ", " + Math.round(parts[1] * 255) + ", " + Math.round(parts[2] * 255);
+            if (rgba3) return "rgba(" + rgbStr + ", " + parts[3] + ")";
+            return "rgb(" + rgbStr + ")";
+          }
+        }
+      });
+      var require_interactions = __commonJS({
+        "src/constants/interactions.js"(exports, module2) {
+          module2.exports = {
+            /**
+             * Timing information for interactive elements
+             */
+            SHOW_PLACEHOLDER: 100,
+            HIDE_PLACEHOLDER: 1e3,
+            // opacity dimming fraction for points that are not in selection
+            DESELECTDIM: 0.2
+          };
+        }
+      });
+      var require_regex = __commonJS({
+        "src/lib/regex.js"(exports) {
+          exports.counter = function(head, tail, openEnded, matchBeginning) {
+            var fullTail = (tail || "") + (openEnded ? "" : "$");
+            var startWithPrefix = matchBeginning === false ? "" : "^";
+            if (head === "xy") {
+              return new RegExp(startWithPrefix + "x([2-9]|[1-9][0-9]+)?y([2-9]|[1-9][0-9]+)?" + fullTail);
+            }
+            return new RegExp(startWithPrefix + head + "([2-9]|[1-9][0-9]+)?" + fullTail);
+          };
+        }
+      });
+      var require_coerce = __commonJS({
+        "src/lib/coerce.js"(exports) {
+          var isNumeric = require_fast_isnumeric();
+          var tinycolor = require_tinycolor();
+          var extendFlat = require_extend().extendFlat;
+          var baseTraceAttrs = require_attributes2();
+          var colorscales = require_scales();
+          var Color2 = require_color();
+          var DESELECTDIM = require_interactions().DESELECTDIM;
+          var nestedProperty = require_nested_property();
+          var counterRegex = require_regex().counter;
+          var modHalf = require_mod().modHalf;
+          var isArrayOrTypedArray = require_array().isArrayOrTypedArray;
+          var isTypedArraySpec = require_array().isTypedArraySpec;
+          var decodeTypedArraySpec = require_array().decodeTypedArraySpec;
+          exports.valObjectMeta = {
+            data_array: {
+              // You can use *dflt=[] to force said array to exist though.
+              coerceFunction: function(v2, propOut, dflt) {
+                propOut.set(
+                  isArrayOrTypedArray(v2) ? v2 : isTypedArraySpec(v2) ? decodeTypedArraySpec(v2) : dflt
+                );
+              }
+            },
+            enumerated: {
+              coerceFunction: function(v2, propOut, dflt, opts) {
+                if (opts.coerceNumber) v2 = +v2;
+                if (opts.values.indexOf(v2) === -1) propOut.set(dflt);
+                else propOut.set(v2);
+              },
+              validateFunction: function(v2, opts) {
+                if (opts.coerceNumber) v2 = +v2;
+                var values = opts.values;
+                for (var i2 = 0; i2 < values.length; i2++) {
+                  var k2 = String(values[i2]);
+                  if (k2.charAt(0) === "/" && k2.charAt(k2.length - 1) === "/") {
+                    var regex = new RegExp(k2.slice(1, -1));
+                    if (regex.test(v2)) return true;
+                  } else if (v2 === values[i2]) return true;
+                }
+                return false;
+              }
+            },
+            boolean: {
+              coerceFunction: function(v2, propOut, dflt, opts) {
+                const isBoolean2 = (value) => value === true || value === false;
+                if (isBoolean2(v2) || opts.arrayOk && Array.isArray(v2) && v2.length > 0 && v2.every(isBoolean2)) {
+                  propOut.set(v2);
+                } else {
+                  propOut.set(dflt);
+                }
+              }
+            },
+            number: {
+              coerceFunction: function(v2, propOut, dflt, opts) {
+                if (isTypedArraySpec(v2)) v2 = decodeTypedArraySpec(v2);
+                if (!isNumeric(v2) || opts.min !== void 0 && v2 < opts.min || opts.max !== void 0 && v2 > opts.max) {
+                  propOut.set(dflt);
+                } else propOut.set(+v2);
+              }
+            },
+            integer: {
+              coerceFunction: function(v2, propOut, dflt, opts) {
+                if ((opts.extras || []).indexOf(v2) !== -1) {
+                  propOut.set(v2);
+                  return;
+                }
+                if (isTypedArraySpec(v2)) v2 = decodeTypedArraySpec(v2);
+                if (v2 % 1 || !isNumeric(v2) || opts.min !== void 0 && v2 < opts.min || opts.max !== void 0 && v2 > opts.max) {
+                  propOut.set(dflt);
+                } else propOut.set(+v2);
+              }
+            },
+            string: {
+              // TODO 'values shouldn't be in there (edge case: 'dash' in Scatter)
+              coerceFunction: function(v2, propOut, dflt, opts) {
+                if (typeof v2 !== "string") {
+                  var okToCoerce = typeof v2 === "number";
+                  if (opts.strict === true || !okToCoerce) propOut.set(dflt);
+                  else propOut.set(String(v2));
+                } else if (opts.noBlank && !v2) propOut.set(dflt);
+                else propOut.set(v2);
+              }
+            },
+            color: {
+              coerceFunction: function(v2, propOut, dflt) {
+                if (isTypedArraySpec(v2)) v2 = decodeTypedArraySpec(v2);
+                if (tinycolor(v2).isValid()) propOut.set(v2);
+                else propOut.set(dflt);
+              }
+            },
+            colorlist: {
+              coerceFunction: function(v2, propOut, dflt) {
+                function isColor(color22) {
+                  return tinycolor(color22).isValid();
+                }
+                if (!Array.isArray(v2) || !v2.length) propOut.set(dflt);
+                else if (v2.every(isColor)) propOut.set(v2);
+                else propOut.set(dflt);
+              }
+            },
+            colorscale: {
+              coerceFunction: function(v2, propOut, dflt) {
+                propOut.set(colorscales.get(v2, dflt));
+              }
+            },
+            angle: {
+              coerceFunction: function(v2, propOut, dflt) {
+                if (isTypedArraySpec(v2)) v2 = decodeTypedArraySpec(v2);
+                if (v2 === "auto") propOut.set("auto");
+                else if (!isNumeric(v2)) propOut.set(dflt);
+                else propOut.set(modHalf(+v2, 360));
+              }
+            },
+            subplotid: {
+              coerceFunction: function(v2, propOut, dflt, opts) {
+                var regex = opts.regex || counterRegex(dflt);
+                const isSubplotId = (value) => typeof value === "string" && regex.test(value);
+                if (isSubplotId(v2) || opts.arrayOk && isArrayOrTypedArray(v2) && v2.length > 0 && v2.every(isSubplotId)) {
+                  propOut.set(v2);
+                } else {
+                  propOut.set(dflt);
+                }
+              },
+              validateFunction: function(v2, opts) {
+                var dflt = opts.dflt;
+                if (v2 === dflt) return true;
+                if (typeof v2 !== "string") return false;
+                if (counterRegex(dflt).test(v2)) return true;
+                return false;
+              }
+            },
+            flaglist: {
+              coerceFunction: function(v2, propOut, dflt, opts) {
+                if ((opts.extras || []).indexOf(v2) !== -1) {
+                  propOut.set(v2);
+                  return;
+                }
+                if (typeof v2 !== "string") {
+                  propOut.set(dflt);
+                  return;
+                }
+                var vParts = v2.split("+");
+                var i2 = 0;
+                while (i2 < vParts.length) {
+                  var vi2 = vParts[i2];
+                  if (opts.flags.indexOf(vi2) === -1 || vParts.indexOf(vi2) < i2) {
+                    vParts.splice(i2, 1);
+                  } else i2++;
+                }
+                if (!vParts.length) propOut.set(dflt);
+                else propOut.set(vParts.join("+"));
+              }
+            },
+            any: {
+              coerceFunction: function(v2, propOut, dflt) {
+                if (v2 === void 0) {
+                  propOut.set(dflt);
+                } else {
+                  propOut.set(
+                    isTypedArraySpec(v2) ? decodeTypedArraySpec(v2) : v2
+                  );
+                }
+              }
+            },
+            info_array: {
+              // set `dimensions=2` for a 2D array or '1-2' for either
+              // `items` may be a single object instead of an array, in which case
+              // `freeLength` must be true.
+              // if `dimensions='1-2'` and items is a 1D array, then the value can
+              // either be a matching 1D array or an array of such matching 1D arrays
+              coerceFunction: function(v2, propOut, dflt, opts) {
+                function coercePart(v22, opts2, dflt2) {
+                  var out;
+                  var propPart = { set: function(v3) {
+                    out = v3;
+                  } };
+                  if (dflt2 === void 0) dflt2 = opts2.dflt;
+                  exports.valObjectMeta[opts2.valType].coerceFunction(v22, propPart, dflt2, opts2);
+                  return out;
+                }
+                if (isTypedArraySpec(v2)) v2 = decodeTypedArraySpec(v2);
+                if (!isArrayOrTypedArray(v2)) {
+                  propOut.set(dflt);
+                  return;
+                }
+                var twoD = opts.dimensions === 2 || opts.dimensions === "1-2" && Array.isArray(v2) && isArrayOrTypedArray(v2[0]);
+                var items = opts.items;
+                var vOut = [];
+                var arrayItems = Array.isArray(items);
+                var arrayItems2D = arrayItems && twoD && isArrayOrTypedArray(items[0]);
+                var innerItemsOnly = twoD && arrayItems && !arrayItems2D;
+                var len2 = arrayItems && !innerItemsOnly ? items.length : v2.length;
+                var i2, j2, row, item, len22, vNew;
+                dflt = Array.isArray(dflt) ? dflt : [];
+                if (twoD) {
+                  for (i2 = 0; i2 < len2; i2++) {
+                    vOut[i2] = [];
+                    row = isArrayOrTypedArray(v2[i2]) ? v2[i2] : [];
+                    if (innerItemsOnly) len22 = items.length;
+                    else if (arrayItems) len22 = items[i2].length;
+                    else len22 = row.length;
+                    for (j2 = 0; j2 < len22; j2++) {
+                      if (innerItemsOnly) item = items[j2];
+                      else if (arrayItems) item = items[i2][j2];
+                      else item = items;
+                      vNew = coercePart(row[j2], item, (dflt[i2] || [])[j2]);
+                      if (vNew !== void 0) vOut[i2][j2] = vNew;
+                    }
+                  }
+                } else {
+                  for (i2 = 0; i2 < len2; i2++) {
+                    vNew = coercePart(v2[i2], arrayItems ? items[i2] : items, dflt[i2]);
+                    if (vNew !== void 0) vOut[i2] = vNew;
+                  }
+                }
+                propOut.set(vOut);
+              },
+              validateFunction: function(v2, opts) {
+                if (!isArrayOrTypedArray(v2)) return false;
+                var items = opts.items;
+                var arrayItems = Array.isArray(items);
+                var twoD = opts.dimensions === 2;
+                if (!opts.freeLength && v2.length !== items.length) return false;
+                for (var i2 = 0; i2 < v2.length; i2++) {
+                  if (twoD) {
+                    if (!isArrayOrTypedArray(v2[i2]) || !opts.freeLength && v2[i2].length !== items[i2].length) {
+                      return false;
+                    }
+                    for (var j2 = 0; j2 < v2[i2].length; j2++) {
+                      if (!validate(v2[i2][j2], arrayItems ? items[i2][j2] : items)) {
+                        return false;
+                      }
+                    }
+                  } else if (!validate(v2[i2], arrayItems ? items[i2] : items)) return false;
+                }
+                return true;
+              }
+            }
+          };
+          exports.coerce = function(containerIn, containerOut, attributes, attribute, dflt) {
+            var opts = nestedProperty(attributes, attribute).get();
+            var propIn = nestedProperty(containerIn, attribute);
+            var propOut = nestedProperty(containerOut, attribute);
+            var v2 = propIn.get();
+            var template = containerOut._template;
+            if (v2 === void 0 && template) {
+              v2 = nestedProperty(template, attribute).get();
+              template = 0;
+            }
+            if (dflt === void 0) dflt = opts.dflt;
+            if (opts.arrayOk) {
+              if (isArrayOrTypedArray(v2)) {
+                propOut.set(v2);
+                return v2;
+              } else {
+                if (isTypedArraySpec(v2)) {
+                  v2 = decodeTypedArraySpec(v2);
+                  propOut.set(v2);
+                  return v2;
+                }
+              }
+            }
+            var coerceFunction = exports.valObjectMeta[opts.valType].coerceFunction;
+            coerceFunction(v2, propOut, dflt, opts);
+            var out = propOut.get();
+            if (template && out === dflt && !validate(v2, opts)) {
+              v2 = nestedProperty(template, attribute).get();
+              coerceFunction(v2, propOut, dflt, opts);
+              out = propOut.get();
+            }
+            return out;
+          };
+          exports.coerce2 = function(containerIn, containerOut, attributes, attribute, dflt) {
+            var propIn = nestedProperty(containerIn, attribute);
+            var propOut = exports.coerce(containerIn, containerOut, attributes, attribute, dflt);
+            var valIn = propIn.get();
+            return valIn !== void 0 && valIn !== null ? propOut : false;
+          };
+          exports.coerceFont = function(coerce, attr, dfltObj, opts) {
+            if (!opts) opts = {};
+            dfltObj = extendFlat({}, dfltObj);
+            dfltObj = extendFlat(dfltObj, opts.overrideDflt || {});
+            var out = {
+              family: coerce(attr + ".family", dfltObj.family),
+              size: coerce(attr + ".size", dfltObj.size),
+              color: coerce(attr + ".color", dfltObj.color),
+              weight: coerce(attr + ".weight", dfltObj.weight),
+              style: coerce(attr + ".style", dfltObj.style)
+            };
+            if (!opts.noFontVariant) out.variant = coerce(attr + ".variant", dfltObj.variant);
+            if (!opts.noFontLineposition) out.lineposition = coerce(attr + ".lineposition", dfltObj.lineposition);
+            if (!opts.noFontTextcase) out.textcase = coerce(attr + ".textcase", dfltObj.textcase);
+            if (!opts.noFontShadow) {
+              var dfltShadow = dfltObj.shadow;
+              if (dfltShadow === "none" && opts.autoShadowDflt) {
+                dfltShadow = "auto";
+              }
+              out.shadow = coerce(attr + ".shadow", dfltShadow);
+            }
+            return out;
+          };
+          exports.coercePattern = function(coerce, attr, markerColor, hasMarkerColorscale) {
+            var shape = coerce(attr + ".shape");
+            var path;
+            if (!shape) {
+              path = coerce(attr + ".path");
+            }
+            if (shape || path) {
+              if (shape) {
+                coerce(attr + ".solidity");
+              }
+              coerce(attr + ".size");
+              var fillmode = coerce(attr + ".fillmode");
+              var isOverlay = fillmode === "overlay";
+              if (!hasMarkerColorscale) {
+                var bgcolor = coerce(
+                  attr + ".bgcolor",
+                  isOverlay ? markerColor : void 0
+                );
+                coerce(
+                  attr + ".fgcolor",
+                  isOverlay ? Color2.contrast(bgcolor) : markerColor
+                );
+              }
+              coerce(
+                attr + ".fgopacity",
+                isOverlay ? 0.5 : 1
+              );
+            }
+          };
+          exports.coerceHoverinfo = function(traceIn, traceOut, layoutOut) {
+            var moduleAttrs = traceOut._module.attributes;
+            var attrs = moduleAttrs.hoverinfo ? moduleAttrs : baseTraceAttrs;
+            var valObj = attrs.hoverinfo;
+            var dflt;
+            if (layoutOut._dataLength === 1) {
+              var flags = valObj.dflt === "all" ? valObj.flags.slice() : valObj.dflt.split("+");
+              flags.splice(flags.indexOf("name"), 1);
+              dflt = flags.join("+");
+            }
+            return exports.coerce(traceIn, traceOut, attrs, "hoverinfo", dflt);
+          };
+          exports.coerceSelectionMarkerOpacity = function(traceOut, coerce) {
+            if (!traceOut.marker) return;
+            var mo = traceOut.marker.opacity;
+            if (mo === void 0) return;
+            var smoDflt;
+            var usmoDflt;
+            if (!isArrayOrTypedArray(mo) && !traceOut.selected && !traceOut.unselected) {
+              smoDflt = mo;
+              usmoDflt = DESELECTDIM * mo;
+            }
+            coerce("selected.marker.opacity", smoDflt);
+            coerce("unselected.marker.opacity", usmoDflt);
+          };
+          function validate(value, opts) {
+            var valObjectDef = exports.valObjectMeta[opts.valType];
+            if (opts.arrayOk && isArrayOrTypedArray(value)) return true;
+            if (valObjectDef.validateFunction) {
+              return valObjectDef.validateFunction(value, opts);
+            }
+            var failed = {};
+            var out = failed;
+            var propMock = { set: function(v2) {
+              out = v2;
+            } };
+            valObjectDef.coerceFunction(value, propMock, failed, opts);
+            return out !== failed;
+          }
+          exports.validate = validate;
+        }
+      });
+      var require_plot_config = __commonJS({
+        "src/plot_api/plot_config.js"(exports, module2) {
+          var configAttributes = {
+            staticPlot: {
+              valType: "boolean",
+              dflt: false
+            },
+            typesetMath: {
+              valType: "boolean",
+              dflt: true
+            },
+            plotlyServerURL: {
+              valType: "string",
+              dflt: ""
+            },
+            editable: {
+              valType: "boolean",
+              dflt: false
+            },
+            edits: {
+              annotationPosition: {
+                valType: "boolean",
+                dflt: false
+              },
+              annotationTail: {
+                valType: "boolean",
+                dflt: false
+              },
+              annotationText: {
+                valType: "boolean",
+                dflt: false
+              },
+              axisTitleText: {
+                valType: "boolean",
+                dflt: false
+              },
+              colorbarPosition: {
+                valType: "boolean",
+                dflt: false
+              },
+              colorbarTitleText: {
+                valType: "boolean",
+                dflt: false
+              },
+              legendPosition: {
+                valType: "boolean",
+                dflt: false
+              },
+              legendText: {
+                valType: "boolean",
+                dflt: false
+              },
+              shapePosition: {
+                valType: "boolean",
+                dflt: false
+              },
+              titleText: {
+                valType: "boolean",
+                dflt: false
+              }
+            },
+            editSelection: {
+              valType: "boolean",
+              dflt: true
+            },
+            autosizable: {
+              valType: "boolean",
+              dflt: false
+            },
+            responsive: {
+              valType: "boolean",
+              dflt: false
+            },
+            fillFrame: {
+              valType: "boolean",
+              dflt: false
+            },
+            frameMargins: {
+              valType: "number",
+              dflt: 0,
+              min: 0,
+              max: 0.5
+            },
+            scrollZoom: {
+              valType: "flaglist",
+              flags: ["cartesian", "gl3d", "geo", "mapbox", "map"],
+              extras: [true, false],
+              dflt: "gl3d+geo+map"
+            },
+            doubleClick: {
+              valType: "enumerated",
+              values: [false, "reset", "autosize", "reset+autosize"],
+              dflt: "reset+autosize"
+            },
+            doubleClickDelay: {
+              valType: "number",
+              dflt: 300,
+              min: 0
+            },
+            showAxisDragHandles: {
+              valType: "boolean",
+              dflt: true
+            },
+            showAxisRangeEntryBoxes: {
+              valType: "boolean",
+              dflt: true
+            },
+            showTips: {
+              valType: "boolean",
+              dflt: true
+            },
+            showLink: {
+              valType: "boolean",
+              dflt: false
+            },
+            linkText: {
+              valType: "string",
+              dflt: "Edit chart",
+              noBlank: true
+            },
+            sendData: {
+              valType: "boolean",
+              dflt: true
+            },
+            showSources: {
+              valType: "any",
+              dflt: false
+            },
+            displayModeBar: {
+              valType: "enumerated",
+              values: ["hover", true, false],
+              dflt: "hover"
+            },
+            showSendToCloud: {
+              valType: "boolean",
+              dflt: false
+            },
+            showEditInChartStudio: {
+              valType: "boolean",
+              dflt: false
+            },
+            modeBarButtonsToRemove: {
+              valType: "any",
+              dflt: []
+            },
+            modeBarButtonsToAdd: {
+              valType: "any",
+              dflt: []
+            },
+            modeBarButtons: {
+              valType: "any",
+              dflt: false
+            },
+            toImageButtonOptions: {
+              valType: "any",
+              dflt: {}
+            },
+            displaylogo: {
+              valType: "boolean",
+              dflt: true
+            },
+            watermark: {
+              valType: "boolean",
+              dflt: false
+            },
+            plotGlPixelRatio: {
+              valType: "number",
+              dflt: 2,
+              min: 1,
+              max: 4
+            },
+            setBackground: {
+              valType: "any",
+              dflt: "transparent"
+            },
+            topojsonURL: {
+              valType: "string",
+              noBlank: true,
+              // TODO: Switch the default back to 'https://cdn.plot.ly/' once we remove the legacy maps
+              dflt: "https://cdn.plot.ly/un/"
+            },
+            mapboxAccessToken: {
+              valType: "string",
+              dflt: null
+            },
+            logging: {
+              valType: "integer",
+              min: 0,
+              max: 2,
+              dflt: 1
+            },
+            notifyOnLogging: {
+              valType: "integer",
+              min: 0,
+              max: 2,
+              dflt: 0
+            },
+            queueLength: {
+              valType: "integer",
+              min: 0,
+              dflt: 0
+            },
+            locale: {
+              valType: "string",
+              dflt: "en-US"
+            },
+            locales: {
+              valType: "any",
+              dflt: {}
+            }
+          };
+          var dfltConfig = {};
+          function crawl(src, target) {
+            for (var k2 in src) {
+              var obj = src[k2];
+              if (obj.valType) {
+                target[k2] = obj.dflt;
+              } else {
+                if (!target[k2]) {
+                  target[k2] = {};
+                }
+                crawl(obj, target[k2]);
+              }
+            }
+          }
+          crawl(configAttributes, dfltConfig);
+          module2.exports = {
+            configAttributes,
+            dfltConfig
+          };
+        }
+      });
+      var require_notifier = __commonJS({
+        "src/lib/notifier.js"(exports, module2) {
+          var d3 = require_d3();
+          var isNumeric = require_fast_isnumeric();
+          var NOTEDATA = [];
+          module2.exports = function(text, displayLength) {
+            if (NOTEDATA.indexOf(text) !== -1) return;
+            NOTEDATA.push(text);
+            var ts = 1e3;
+            if (isNumeric(displayLength)) ts = displayLength;
+            else if (displayLength === "long") ts = 3e3;
+            var notifierContainer = d3.select("body").selectAll(".plotly-notifier").data([0]);
+            notifierContainer.enter().append("div").classed("plotly-notifier", true);
+            var notes = notifierContainer.selectAll(".notifier-note").data(NOTEDATA);
+            function killNote(transition) {
+              transition.duration(700).style("opacity", 0).each("end", function(thisText) {
+                var thisIndex = NOTEDATA.indexOf(thisText);
+                if (thisIndex !== -1) NOTEDATA.splice(thisIndex, 1);
+                d3.select(this).remove();
+              });
+            }
+            notes.enter().append("div").classed("notifier-note", true).style("opacity", 0).each(function(thisText) {
+              var note = d3.select(this);
+              note.append("button").classed("notifier-close", true).html("&times;").on("click", function() {
+                note.transition().call(killNote);
+              });
+              var p2 = note.append("p");
+              var lines = thisText.split(/<br\s*\/?>/g);
+              for (var i2 = 0; i2 < lines.length; i2++) {
+                if (i2) p2.append("br");
+                p2.append("span").text(lines[i2]);
+              }
+              if (displayLength === "stick") {
+                note.transition().duration(350).style("opacity", 1);
+              } else {
+                note.transition().duration(700).style("opacity", 1).transition().delay(ts).call(killNote);
+              }
+            });
+          };
+        }
+      });
+      var require_loggers = __commonJS({
+        "src/lib/loggers.js"(exports, module2) {
+          var dfltConfig = require_plot_config().dfltConfig;
+          var notifier = require_notifier();
+          var loggers2 = module2.exports = {};
+          loggers2.log = function() {
+            var i2;
+            if (dfltConfig.logging > 1) {
+              var messages = ["LOG:"];
+              for (i2 = 0; i2 < arguments.length; i2++) {
+                messages.push(arguments[i2]);
+              }
+              console.trace.apply(console, messages);
+            }
+            if (dfltConfig.notifyOnLogging > 1) {
+              var lines = [];
+              for (i2 = 0; i2 < arguments.length; i2++) {
+                lines.push(arguments[i2]);
+              }
+              notifier(lines.join("<br>"), "long");
+            }
+          };
+          loggers2.warn = function() {
+            var i2;
+            if (dfltConfig.logging > 0) {
+              var messages = ["WARN:"];
+              for (i2 = 0; i2 < arguments.length; i2++) {
+                messages.push(arguments[i2]);
+              }
+              console.trace.apply(console, messages);
+            }
+            if (dfltConfig.notifyOnLogging > 0) {
+              var lines = [];
+              for (i2 = 0; i2 < arguments.length; i2++) {
+                lines.push(arguments[i2]);
+              }
+              notifier(lines.join("<br>"), "stick");
+            }
+          };
+          loggers2.error = function() {
+            var i2;
+            if (dfltConfig.logging > 0) {
+              var messages = ["ERROR:"];
+              for (i2 = 0; i2 < arguments.length; i2++) {
+                messages.push(arguments[i2]);
+              }
+              console.error.apply(console, messages);
+            }
+            if (dfltConfig.notifyOnLogging > 0) {
+              var lines = [];
+              for (i2 = 0; i2 < arguments.length; i2++) {
+                lines.push(arguments[i2]);
+              }
+              notifier(lines.join("<br>"), "stick");
+            }
+          };
+        }
+      });
+      var require_noop = __commonJS({
+        "src/lib/noop.js"(exports, module2) {
+          module2.exports = function noop2() {
+          };
+        }
+      });
+      var require_push_unique = __commonJS({
+        "src/lib/push_unique.js"(exports, module2) {
+          module2.exports = function pushUnique(array, item) {
+            if (item instanceof RegExp) {
+              var itemStr = item.toString();
+              for (var i2 = 0; i2 < array.length; i2++) {
+                if (array[i2] instanceof RegExp && array[i2].toString() === itemStr) {
+                  return array;
+                }
+              }
+              array.push(item);
+            } else if ((item || item === 0) && array.indexOf(item) === -1) array.push(item);
+            return array;
+          };
+        }
+      });
+      var require_create = __commonJS({
+        "node_modules/gl-mat4/create.js"(exports, module2) {
+          module2.exports = create2;
+          function create2() {
+            var out = new Float32Array(16);
+            out[0] = 1;
+            out[1] = 0;
+            out[2] = 0;
+            out[3] = 0;
+            out[4] = 0;
+            out[5] = 1;
+            out[6] = 0;
+            out[7] = 0;
+            out[8] = 0;
+            out[9] = 0;
+            out[10] = 1;
+            out[11] = 0;
+            out[12] = 0;
+            out[13] = 0;
+            out[14] = 0;
+            out[15] = 1;
+            return out;
+          }
+        }
+      });
+      var require_clone = __commonJS({
+        "node_modules/gl-mat4/clone.js"(exports, module2) {
+          module2.exports = clone;
+          function clone(a2) {
+            var out = new Float32Array(16);
+            out[0] = a2[0];
+            out[1] = a2[1];
+            out[2] = a2[2];
+            out[3] = a2[3];
+            out[4] = a2[4];
+            out[5] = a2[5];
+            out[6] = a2[6];
+            out[7] = a2[7];
+            out[8] = a2[8];
+            out[9] = a2[9];
+            out[10] = a2[10];
+            out[11] = a2[11];
+            out[12] = a2[12];
+            out[13] = a2[13];
+            out[14] = a2[14];
+            out[15] = a2[15];
+            return out;
+          }
+        }
+      });
+      var require_copy = __commonJS({
+        "node_modules/gl-mat4/copy.js"(exports, module2) {
+          module2.exports = copy;
+          function copy(out, a2) {
+            out[0] = a2[0];
+            out[1] = a2[1];
+            out[2] = a2[2];
+            out[3] = a2[3];
+            out[4] = a2[4];
+            out[5] = a2[5];
+            out[6] = a2[6];
+            out[7] = a2[7];
+            out[8] = a2[8];
+            out[9] = a2[9];
+            out[10] = a2[10];
+            out[11] = a2[11];
+            out[12] = a2[12];
+            out[13] = a2[13];
+            out[14] = a2[14];
+            out[15] = a2[15];
+            return out;
+          }
+        }
+      });
+      var require_identity = __commonJS({
+        "node_modules/gl-mat4/identity.js"(exports, module2) {
+          module2.exports = identity22;
+          function identity22(out) {
+            out[0] = 1;
+            out[1] = 0;
+            out[2] = 0;
+            out[3] = 0;
+            out[4] = 0;
+            out[5] = 1;
+            out[6] = 0;
+            out[7] = 0;
+            out[8] = 0;
+            out[9] = 0;
+            out[10] = 1;
+            out[11] = 0;
+            out[12] = 0;
+            out[13] = 0;
+            out[14] = 0;
+            out[15] = 1;
+            return out;
+          }
+        }
+      });
+      var require_transpose = __commonJS({
+        "node_modules/gl-mat4/transpose.js"(exports, module2) {
+          module2.exports = transpose2;
+          function transpose2(out, a2) {
+            if (out === a2) {
+              var a01 = a2[1], a02 = a2[2], a03 = a2[3], a12 = a2[6], a13 = a2[7], a23 = a2[11];
+              out[1] = a2[4];
+              out[2] = a2[8];
+              out[3] = a2[12];
+              out[4] = a01;
+              out[6] = a2[9];
+              out[7] = a2[13];
+              out[8] = a02;
+              out[9] = a12;
+              out[11] = a2[14];
+              out[12] = a03;
+              out[13] = a13;
+              out[14] = a23;
+            } else {
+              out[0] = a2[0];
+              out[1] = a2[4];
+              out[2] = a2[8];
+              out[3] = a2[12];
+              out[4] = a2[1];
+              out[5] = a2[5];
+              out[6] = a2[9];
+              out[7] = a2[13];
+              out[8] = a2[2];
+              out[9] = a2[6];
+              out[10] = a2[10];
+              out[11] = a2[14];
+              out[12] = a2[3];
+              out[13] = a2[7];
+              out[14] = a2[11];
+              out[15] = a2[15];
+            }
+            return out;
+          }
+        }
+      });
+      var require_invert = __commonJS({
+        "node_modules/gl-mat4/invert.js"(exports, module2) {
+          module2.exports = invert2;
+          function invert2(out, a2) {
+            var a00 = a2[0], a01 = a2[1], a02 = a2[2], a03 = a2[3], a10 = a2[4], a11 = a2[5], a12 = a2[6], a13 = a2[7], a20 = a2[8], a21 = a2[9], a22 = a2[10], a23 = a2[11], a30 = a2[12], a31 = a2[13], a32 = a2[14], a33 = a2[15], b00 = a00 * a11 - a01 * a10, b01 = a00 * a12 - a02 * a10, b02 = a00 * a13 - a03 * a10, b03 = a01 * a12 - a02 * a11, b04 = a01 * a13 - a03 * a11, b05 = a02 * a13 - a03 * a12, b06 = a20 * a31 - a21 * a30, b07 = a20 * a32 - a22 * a30, b08 = a20 * a33 - a23 * a30, b09 = a21 * a32 - a22 * a31, b10 = a21 * a33 - a23 * a31, b11 = a22 * a33 - a23 * a32, det = b00 * b11 - b01 * b10 + b02 * b09 + b03 * b08 - b04 * b07 + b05 * b06;
+            if (!det) {
+              return null;
+            }
+            det = 1 / det;
+            out[0] = (a11 * b11 - a12 * b10 + a13 * b09) * det;
+            out[1] = (a02 * b10 - a01 * b11 - a03 * b09) * det;
+            out[2] = (a31 * b05 - a32 * b04 + a33 * b03) * det;
+            out[3] = (a22 * b04 - a21 * b05 - a23 * b03) * det;
+            out[4] = (a12 * b08 - a10 * b11 - a13 * b07) * det;
+            out[5] = (a00 * b11 - a02 * b08 + a03 * b07) * det;
+            out[6] = (a32 * b02 - a30 * b05 - a33 * b01) * det;
+            out[7] = (a20 * b05 - a22 * b02 + a23 * b01) * det;
+            out[8] = (a10 * b10 - a11 * b08 + a13 * b06) * det;
+            out[9] = (a01 * b08 - a00 * b10 - a03 * b06) * det;
+            out[10] = (a30 * b04 - a31 * b02 + a33 * b00) * det;
+            out[11] = (a21 * b02 - a20 * b04 - a23 * b00) * det;
+            out[12] = (a11 * b07 - a10 * b09 - a12 * b06) * det;
+            out[13] = (a00 * b09 - a01 * b07 + a02 * b06) * det;
+            out[14] = (a31 * b01 - a30 * b03 - a32 * b00) * det;
+            out[15] = (a20 * b03 - a21 * b01 + a22 * b00) * det;
+            return out;
+          }
+        }
+      });
+      var require_adjoint = __commonJS({
+        "node_modules/gl-mat4/adjoint.js"(exports, module2) {
+          module2.exports = adjoint;
+          function adjoint(out, a2) {
+            var a00 = a2[0], a01 = a2[1], a02 = a2[2], a03 = a2[3], a10 = a2[4], a11 = a2[5], a12 = a2[6], a13 = a2[7], a20 = a2[8], a21 = a2[9], a22 = a2[10], a23 = a2[11], a30 = a2[12], a31 = a2[13], a32 = a2[14], a33 = a2[15];
+            out[0] = a11 * (a22 * a33 - a23 * a32) - a21 * (a12 * a33 - a13 * a32) + a31 * (a12 * a23 - a13 * a22);
+            out[1] = -(a01 * (a22 * a33 - a23 * a32) - a21 * (a02 * a33 - a03 * a32) + a31 * (a02 * a23 - a03 * a22));
+            out[2] = a01 * (a12 * a33 - a13 * a32) - a11 * (a02 * a33 - a03 * a32) + a31 * (a02 * a13 - a03 * a12);
+            out[3] = -(a01 * (a12 * a23 - a13 * a22) - a11 * (a02 * a23 - a03 * a22) + a21 * (a02 * a13 - a03 * a12));
+            out[4] = -(a10 * (a22 * a33 - a23 * a32) - a20 * (a12 * a33 - a13 * a32) + a30 * (a12 * a23 - a13 * a22));
+            out[5] = a00 * (a22 * a33 - a23 * a32) - a20 * (a02 * a33 - a03 * a32) + a30 * (a02 * a23 - a03 * a22);
+            out[6] = -(a00 * (a12 * a33 - a13 * a32) - a10 * (a02 * a33 - a03 * a32) + a30 * (a02 * a13 - a03 * a12));
+            out[7] = a00 * (a12 * a23 - a13 * a22) - a10 * (a02 * a23 - a03 * a22) + a20 * (a02 * a13 - a03 * a12);
+            out[8] = a10 * (a21 * a33 - a23 * a31) - a20 * (a11 * a33 - a13 * a31) + a30 * (a11 * a23 - a13 * a21);
+            out[9] = -(a00 * (a21 * a33 - a23 * a31) - a20 * (a01 * a33 - a03 * a31) + a30 * (a01 * a23 - a03 * a21));
+            out[10] = a00 * (a11 * a33 - a13 * a31) - a10 * (a01 * a33 - a03 * a31) + a30 * (a01 * a13 - a03 * a11);
+            out[11] = -(a00 * (a11 * a23 - a13 * a21) - a10 * (a01 * a23 - a03 * a21) + a20 * (a01 * a13 - a03 * a11));
+            out[12] = -(a10 * (a21 * a32 - a22 * a31) - a20 * (a11 * a32 - a12 * a31) + a30 * (a11 * a22 - a12 * a21));
+            out[13] = a00 * (a21 * a32 - a22 * a31) - a20 * (a01 * a32 - a02 * a31) + a30 * (a01 * a22 - a02 * a21);
+            out[14] = -(a00 * (a11 * a32 - a12 * a31) - a10 * (a01 * a32 - a02 * a31) + a30 * (a01 * a12 - a02 * a11));
+            out[15] = a00 * (a11 * a22 - a12 * a21) - a10 * (a01 * a22 - a02 * a21) + a20 * (a01 * a12 - a02 * a11);
+            return out;
+          }
+        }
+      });
+      var require_determinant = __commonJS({
+        "node_modules/gl-mat4/determinant.js"(exports, module2) {
+          module2.exports = determinant2;
+          function determinant2(a2) {
+            var a00 = a2[0], a01 = a2[1], a02 = a2[2], a03 = a2[3], a10 = a2[4], a11 = a2[5], a12 = a2[6], a13 = a2[7], a20 = a2[8], a21 = a2[9], a22 = a2[10], a23 = a2[11], a30 = a2[12], a31 = a2[13], a32 = a2[14], a33 = a2[15], b00 = a00 * a11 - a01 * a10, b01 = a00 * a12 - a02 * a10, b02 = a00 * a13 - a03 * a10, b03 = a01 * a12 - a02 * a11, b04 = a01 * a13 - a03 * a11, b05 = a02 * a13 - a03 * a12, b06 = a20 * a31 - a21 * a30, b07 = a20 * a32 - a22 * a30, b08 = a20 * a33 - a23 * a30, b09 = a21 * a32 - a22 * a31, b10 = a21 * a33 - a23 * a31, b11 = a22 * a33 - a23 * a32;
+            return b00 * b11 - b01 * b10 + b02 * b09 + b03 * b08 - b04 * b07 + b05 * b06;
+          }
+        }
+      });
+      var require_multiply = __commonJS({
+        "node_modules/gl-mat4/multiply.js"(exports, module2) {
+          module2.exports = multiply2;
+          function multiply2(out, a2, b2) {
+            var a00 = a2[0], a01 = a2[1], a02 = a2[2], a03 = a2[3], a10 = a2[4], a11 = a2[5], a12 = a2[6], a13 = a2[7], a20 = a2[8], a21 = a2[9], a22 = a2[10], a23 = a2[11], a30 = a2[12], a31 = a2[13], a32 = a2[14], a33 = a2[15];
+            var b0 = b2[0], b1 = b2[1], b22 = b2[2], b3 = b2[3];
+            out[0] = b0 * a00 + b1 * a10 + b22 * a20 + b3 * a30;
+            out[1] = b0 * a01 + b1 * a11 + b22 * a21 + b3 * a31;
+            out[2] = b0 * a02 + b1 * a12 + b22 * a22 + b3 * a32;
+            out[3] = b0 * a03 + b1 * a13 + b22 * a23 + b3 * a33;
+            b0 = b2[4];
+            b1 = b2[5];
+            b22 = b2[6];
+            b3 = b2[7];
+            out[4] = b0 * a00 + b1 * a10 + b22 * a20 + b3 * a30;
+            out[5] = b0 * a01 + b1 * a11 + b22 * a21 + b3 * a31;
+            out[6] = b0 * a02 + b1 * a12 + b22 * a22 + b3 * a32;
+            out[7] = b0 * a03 + b1 * a13 + b22 * a23 + b3 * a33;
+            b0 = b2[8];
+            b1 = b2[9];
+            b22 = b2[10];
+            b3 = b2[11];
+            out[8] = b0 * a00 + b1 * a10 + b22 * a20 + b3 * a30;
+            out[9] = b0 * a01 + b1 * a11 + b22 * a21 + b3 * a31;
+            out[10] = b0 * a02 + b1 * a12 + b22 * a22 + b3 * a32;
+            out[11] = b0 * a03 + b1 * a13 + b22 * a23 + b3 * a33;
+            b0 = b2[12];
+            b1 = b2[13];
+            b22 = b2[14];
+            b3 = b2[15];
+            out[12] = b0 * a00 + b1 * a10 + b22 * a20 + b3 * a30;
+            out[13] = b0 * a01 + b1 * a11 + b22 * a21 + b3 * a31;
+            out[14] = b0 * a02 + b1 * a12 + b22 * a22 + b3 * a32;
+            out[15] = b0 * a03 + b1 * a13 + b22 * a23 + b3 * a33;
+            return out;
+          }
+        }
+      });
+      var require_translate = __commonJS({
+        "node_modules/gl-mat4/translate.js"(exports, module2) {
+          module2.exports = translate2;
+          function translate2(out, a2, v2) {
+            var x2 = v2[0], y2 = v2[1], z2 = v2[2], a00, a01, a02, a03, a10, a11, a12, a13, a20, a21, a22, a23;
+            if (a2 === out) {
+              out[12] = a2[0] * x2 + a2[4] * y2 + a2[8] * z2 + a2[12];
+              out[13] = a2[1] * x2 + a2[5] * y2 + a2[9] * z2 + a2[13];
+              out[14] = a2[2] * x2 + a2[6] * y2 + a2[10] * z2 + a2[14];
+              out[15] = a2[3] * x2 + a2[7] * y2 + a2[11] * z2 + a2[15];
+            } else {
+              a00 = a2[0];
+              a01 = a2[1];
+              a02 = a2[2];
+              a03 = a2[3];
+              a10 = a2[4];
+              a11 = a2[5];
+              a12 = a2[6];
+              a13 = a2[7];
+              a20 = a2[8];
+              a21 = a2[9];
+              a22 = a2[10];
+              a23 = a2[11];
+              out[0] = a00;
+              out[1] = a01;
+              out[2] = a02;
+              out[3] = a03;
+              out[4] = a10;
+              out[5] = a11;
+              out[6] = a12;
+              out[7] = a13;
+              out[8] = a20;
+              out[9] = a21;
+              out[10] = a22;
+              out[11] = a23;
+              out[12] = a00 * x2 + a10 * y2 + a20 * z2 + a2[12];
+              out[13] = a01 * x2 + a11 * y2 + a21 * z2 + a2[13];
+              out[14] = a02 * x2 + a12 * y2 + a22 * z2 + a2[14];
+              out[15] = a03 * x2 + a13 * y2 + a23 * z2 + a2[15];
+            }
+            return out;
+          }
+        }
+      });
+      var require_scale = __commonJS({
+        "node_modules/gl-mat4/scale.js"(exports, module2) {
+          module2.exports = scale2;
+          function scale2(out, a2, v2) {
+            var x2 = v2[0], y2 = v2[1], z2 = v2[2];
+            out[0] = a2[0] * x2;
+            out[1] = a2[1] * x2;
+            out[2] = a2[2] * x2;
+            out[3] = a2[3] * x2;
+            out[4] = a2[4] * y2;
+            out[5] = a2[5] * y2;
+            out[6] = a2[6] * y2;
+            out[7] = a2[7] * y2;
+            out[8] = a2[8] * z2;
+            out[9] = a2[9] * z2;
+            out[10] = a2[10] * z2;
+            out[11] = a2[11] * z2;
+            out[12] = a2[12];
+            out[13] = a2[13];
+            out[14] = a2[14];
+            out[15] = a2[15];
+            return out;
+          }
+        }
+      });
+      var require_rotate = __commonJS({
+        "node_modules/gl-mat4/rotate.js"(exports, module2) {
+          module2.exports = rotate2;
+          function rotate2(out, a2, rad, axis) {
+            var x2 = axis[0], y2 = axis[1], z2 = axis[2], len2 = Math.sqrt(x2 * x2 + y2 * y2 + z2 * z2), s2, c2, t4, a00, a01, a02, a03, a10, a11, a12, a13, a20, a21, a22, a23, b00, b01, b02, b10, b11, b12, b20, b21, b22;
+            if (Math.abs(len2) < 1e-6) {
+              return null;
+            }
+            len2 = 1 / len2;
+            x2 *= len2;
+            y2 *= len2;
+            z2 *= len2;
+            s2 = Math.sin(rad);
+            c2 = Math.cos(rad);
+            t4 = 1 - c2;
+            a00 = a2[0];
+            a01 = a2[1];
+            a02 = a2[2];
+            a03 = a2[3];
+            a10 = a2[4];
+            a11 = a2[5];
+            a12 = a2[6];
+            a13 = a2[7];
+            a20 = a2[8];
+            a21 = a2[9];
+            a22 = a2[10];
+            a23 = a2[11];
+            b00 = x2 * x2 * t4 + c2;
+            b01 = y2 * x2 * t4 + z2 * s2;
+            b02 = z2 * x2 * t4 - y2 * s2;
+            b10 = x2 * y2 * t4 - z2 * s2;
+            b11 = y2 * y2 * t4 + c2;
+            b12 = z2 * y2 * t4 + x2 * s2;
+            b20 = x2 * z2 * t4 + y2 * s2;
+            b21 = y2 * z2 * t4 - x2 * s2;
+            b22 = z2 * z2 * t4 + c2;
+            out[0] = a00 * b00 + a10 * b01 + a20 * b02;
+            out[1] = a01 * b00 + a11 * b01 + a21 * b02;
+            out[2] = a02 * b00 + a12 * b01 + a22 * b02;
+            out[3] = a03 * b00 + a13 * b01 + a23 * b02;
+            out[4] = a00 * b10 + a10 * b11 + a20 * b12;
+            out[5] = a01 * b10 + a11 * b11 + a21 * b12;
+            out[6] = a02 * b10 + a12 * b11 + a22 * b12;
+            out[7] = a03 * b10 + a13 * b11 + a23 * b12;
+            out[8] = a00 * b20 + a10 * b21 + a20 * b22;
+            out[9] = a01 * b20 + a11 * b21 + a21 * b22;
+            out[10] = a02 * b20 + a12 * b21 + a22 * b22;
+            out[11] = a03 * b20 + a13 * b21 + a23 * b22;
+            if (a2 !== out) {
+              out[12] = a2[12];
+              out[13] = a2[13];
+              out[14] = a2[14];
+              out[15] = a2[15];
+            }
+            return out;
+          }
+        }
+      });
+      var require_rotateX = __commonJS({
+        "node_modules/gl-mat4/rotateX.js"(exports, module2) {
+          module2.exports = rotateX2;
+          function rotateX2(out, a2, rad) {
+            var s2 = Math.sin(rad), c2 = Math.cos(rad), a10 = a2[4], a11 = a2[5], a12 = a2[6], a13 = a2[7], a20 = a2[8], a21 = a2[9], a22 = a2[10], a23 = a2[11];
+            if (a2 !== out) {
+              out[0] = a2[0];
+              out[1] = a2[1];
+              out[2] = a2[2];
+              out[3] = a2[3];
+              out[12] = a2[12];
+              out[13] = a2[13];
+              out[14] = a2[14];
+              out[15] = a2[15];
+            }
+            out[4] = a10 * c2 + a20 * s2;
+            out[5] = a11 * c2 + a21 * s2;
+            out[6] = a12 * c2 + a22 * s2;
+            out[7] = a13 * c2 + a23 * s2;
+            out[8] = a20 * c2 - a10 * s2;
+            out[9] = a21 * c2 - a11 * s2;
+            out[10] = a22 * c2 - a12 * s2;
+            out[11] = a23 * c2 - a13 * s2;
+            return out;
+          }
+        }
+      });
+      var require_rotateY = __commonJS({
+        "node_modules/gl-mat4/rotateY.js"(exports, module2) {
+          module2.exports = rotateY2;
+          function rotateY2(out, a2, rad) {
+            var s2 = Math.sin(rad), c2 = Math.cos(rad), a00 = a2[0], a01 = a2[1], a02 = a2[2], a03 = a2[3], a20 = a2[8], a21 = a2[9], a22 = a2[10], a23 = a2[11];
+            if (a2 !== out) {
+              out[4] = a2[4];
+              out[5] = a2[5];
+              out[6] = a2[6];
+              out[7] = a2[7];
+              out[12] = a2[12];
+              out[13] = a2[13];
+              out[14] = a2[14];
+              out[15] = a2[15];
+            }
+            out[0] = a00 * c2 - a20 * s2;
+            out[1] = a01 * c2 - a21 * s2;
+            out[2] = a02 * c2 - a22 * s2;
+            out[3] = a03 * c2 - a23 * s2;
+            out[8] = a00 * s2 + a20 * c2;
+            out[9] = a01 * s2 + a21 * c2;
+            out[10] = a02 * s2 + a22 * c2;
+            out[11] = a03 * s2 + a23 * c2;
+            return out;
+          }
+        }
+      });
+      var require_rotateZ = __commonJS({
+        "node_modules/gl-mat4/rotateZ.js"(exports, module2) {
+          module2.exports = rotateZ2;
+          function rotateZ2(out, a2, rad) {
+            var s2 = Math.sin(rad), c2 = Math.cos(rad), a00 = a2[0], a01 = a2[1], a02 = a2[2], a03 = a2[3], a10 = a2[4], a11 = a2[5], a12 = a2[6], a13 = a2[7];
+            if (a2 !== out) {
+              out[8] = a2[8];
+              out[9] = a2[9];
+              out[10] = a2[10];
+              out[11] = a2[11];
+              out[12] = a2[12];
+              out[13] = a2[13];
+              out[14] = a2[14];
+              out[15] = a2[15];
+            }
+            out[0] = a00 * c2 + a10 * s2;
+            out[1] = a01 * c2 + a11 * s2;
+            out[2] = a02 * c2 + a12 * s2;
+            out[3] = a03 * c2 + a13 * s2;
+            out[4] = a10 * c2 - a00 * s2;
+            out[5] = a11 * c2 - a01 * s2;
+            out[6] = a12 * c2 - a02 * s2;
+            out[7] = a13 * c2 - a03 * s2;
+            return out;
+          }
+        }
+      });
+      var require_fromRotation = __commonJS({
+        "node_modules/gl-mat4/fromRotation.js"(exports, module2) {
+          module2.exports = fromRotation;
+          function fromRotation(out, rad, axis) {
+            var s2, c2, t4;
+            var x2 = axis[0];
+            var y2 = axis[1];
+            var z2 = axis[2];
+            var len2 = Math.sqrt(x2 * x2 + y2 * y2 + z2 * z2);
+            if (Math.abs(len2) < 1e-6) {
+              return null;
+            }
+            len2 = 1 / len2;
+            x2 *= len2;
+            y2 *= len2;
+            z2 *= len2;
+            s2 = Math.sin(rad);
+            c2 = Math.cos(rad);
+            t4 = 1 - c2;
+            out[0] = x2 * x2 * t4 + c2;
+            out[1] = y2 * x2 * t4 + z2 * s2;
+            out[2] = z2 * x2 * t4 - y2 * s2;
+            out[3] = 0;
+            out[4] = x2 * y2 * t4 - z2 * s2;
+            out[5] = y2 * y2 * t4 + c2;
+            out[6] = z2 * y2 * t4 + x2 * s2;
+            out[7] = 0;
+            out[8] = x2 * z2 * t4 + y2 * s2;
+            out[9] = y2 * z2 * t4 - x2 * s2;
+            out[10] = z2 * z2 * t4 + c2;
+            out[11] = 0;
+            out[12] = 0;
+            out[13] = 0;
+            out[14] = 0;
+            out[15] = 1;
+            return out;
+          }
+        }
+      });
+      var require_fromRotationTranslation = __commonJS({
+        "node_modules/gl-mat4/fromRotationTranslation.js"(exports, module2) {
+          module2.exports = fromRotationTranslation;
+          function fromRotationTranslation(out, q2, v2) {
+            var x2 = q2[0], y2 = q2[1], z2 = q2[2], w2 = q2[3], x22 = x2 + x2, y22 = y2 + y2, z22 = z2 + z2, xx = x2 * x22, xy = x2 * y22, xz = x2 * z22, yy = y2 * y22, yz = y2 * z22, zz = z2 * z22, wx = w2 * x22, wy = w2 * y22, wz = w2 * z22;
+            out[0] = 1 - (yy + zz);
+            out[1] = xy + wz;
+            out[2] = xz - wy;
+            out[3] = 0;
+            out[4] = xy - wz;
+            out[5] = 1 - (xx + zz);
+            out[6] = yz + wx;
+            out[7] = 0;
+            out[8] = xz + wy;
+            out[9] = yz - wx;
+            out[10] = 1 - (xx + yy);
+            out[11] = 0;
+            out[12] = v2[0];
+            out[13] = v2[1];
+            out[14] = v2[2];
+            out[15] = 1;
+            return out;
+          }
+        }
+      });
+      var require_fromScaling = __commonJS({
+        "node_modules/gl-mat4/fromScaling.js"(exports, module2) {
+          module2.exports = fromScaling;
+          function fromScaling(out, v2) {
+            out[0] = v2[0];
+            out[1] = 0;
+            out[2] = 0;
+            out[3] = 0;
+            out[4] = 0;
+            out[5] = v2[1];
+            out[6] = 0;
+            out[7] = 0;
+            out[8] = 0;
+            out[9] = 0;
+            out[10] = v2[2];
+            out[11] = 0;
+            out[12] = 0;
+            out[13] = 0;
+            out[14] = 0;
+            out[15] = 1;
+            return out;
+          }
+        }
+      });
+      var require_fromTranslation = __commonJS({
+        "node_modules/gl-mat4/fromTranslation.js"(exports, module2) {
+          module2.exports = fromTranslation;
+          function fromTranslation(out, v2) {
+            out[0] = 1;
+            out[1] = 0;
+            out[2] = 0;
+            out[3] = 0;
+            out[4] = 0;
+            out[5] = 1;
+            out[6] = 0;
+            out[7] = 0;
+            out[8] = 0;
+            out[9] = 0;
+            out[10] = 1;
+            out[11] = 0;
+            out[12] = v2[0];
+            out[13] = v2[1];
+            out[14] = v2[2];
+            out[15] = 1;
+            return out;
+          }
+        }
+      });
+      var require_fromXRotation = __commonJS({
+        "node_modules/gl-mat4/fromXRotation.js"(exports, module2) {
+          module2.exports = fromXRotation;
+          function fromXRotation(out, rad) {
+            var s2 = Math.sin(rad), c2 = Math.cos(rad);
+            out[0] = 1;
+            out[1] = 0;
+            out[2] = 0;
+            out[3] = 0;
+            out[4] = 0;
+            out[5] = c2;
+            out[6] = s2;
+            out[7] = 0;
+            out[8] = 0;
+            out[9] = -s2;
+            out[10] = c2;
+            out[11] = 0;
+            out[12] = 0;
+            out[13] = 0;
+            out[14] = 0;
+            out[15] = 1;
+            return out;
+          }
+        }
+      });
+      var require_fromYRotation = __commonJS({
+        "node_modules/gl-mat4/fromYRotation.js"(exports, module2) {
+          module2.exports = fromYRotation;
+          function fromYRotation(out, rad) {
+            var s2 = Math.sin(rad), c2 = Math.cos(rad);
+            out[0] = c2;
+            out[1] = 0;
+            out[2] = -s2;
+            out[3] = 0;
+            out[4] = 0;
+            out[5] = 1;
+            out[6] = 0;
+            out[7] = 0;
+            out[8] = s2;
+            out[9] = 0;
+            out[10] = c2;
+            out[11] = 0;
+            out[12] = 0;
+            out[13] = 0;
+            out[14] = 0;
+            out[15] = 1;
+            return out;
+          }
+        }
+      });
+      var require_fromZRotation = __commonJS({
+        "node_modules/gl-mat4/fromZRotation.js"(exports, module2) {
+          module2.exports = fromZRotation;
+          function fromZRotation(out, rad) {
+            var s2 = Math.sin(rad), c2 = Math.cos(rad);
+            out[0] = c2;
+            out[1] = s2;
+            out[2] = 0;
+            out[3] = 0;
+            out[4] = -s2;
+            out[5] = c2;
+            out[6] = 0;
+            out[7] = 0;
+            out[8] = 0;
+            out[9] = 0;
+            out[10] = 1;
+            out[11] = 0;
+            out[12] = 0;
+            out[13] = 0;
+            out[14] = 0;
+            out[15] = 1;
+            return out;
+          }
+        }
+      });
+      var require_fromQuat = __commonJS({
+        "node_modules/gl-mat4/fromQuat.js"(exports, module2) {
+          module2.exports = fromQuat2;
+          function fromQuat2(out, q2) {
+            var x2 = q2[0], y2 = q2[1], z2 = q2[2], w2 = q2[3], x22 = x2 + x2, y22 = y2 + y2, z22 = z2 + z2, xx = x2 * x22, yx = y2 * x22, yy = y2 * y22, zx = z2 * x22, zy = z2 * y22, zz = z2 * z22, wx = w2 * x22, wy = w2 * y22, wz = w2 * z22;
+            out[0] = 1 - yy - zz;
+            out[1] = yx + wz;
+            out[2] = zx - wy;
+            out[3] = 0;
+            out[4] = yx - wz;
+            out[5] = 1 - xx - zz;
+            out[6] = zy + wx;
+            out[7] = 0;
+            out[8] = zx + wy;
+            out[9] = zy - wx;
+            out[10] = 1 - xx - yy;
+            out[11] = 0;
+            out[12] = 0;
+            out[13] = 0;
+            out[14] = 0;
+            out[15] = 1;
+            return out;
+          }
+        }
+      });
+      var require_frustum = __commonJS({
+        "node_modules/gl-mat4/frustum.js"(exports, module2) {
+          module2.exports = frustum2;
+          function frustum2(out, left, right, bottom, top, near, far) {
+            var rl2 = 1 / (right - left), tb2 = 1 / (top - bottom), nf2 = 1 / (near - far);
+            out[0] = near * 2 * rl2;
+            out[1] = 0;
+            out[2] = 0;
+            out[3] = 0;
+            out[4] = 0;
+            out[5] = near * 2 * tb2;
+            out[6] = 0;
+            out[7] = 0;
+            out[8] = (right + left) * rl2;
+            out[9] = (top + bottom) * tb2;
+            out[10] = (far + near) * nf2;
+            out[11] = -1;
+            out[12] = 0;
+            out[13] = 0;
+            out[14] = far * near * 2 * nf2;
+            out[15] = 0;
+            return out;
+          }
+        }
+      });
+      var require_perspective = __commonJS({
+        "node_modules/gl-mat4/perspective.js"(exports, module2) {
+          module2.exports = perspective2;
+          function perspective2(out, fovy, aspect, near, far) {
+            var f2 = 1 / Math.tan(fovy / 2), nf2 = 1 / (near - far);
+            out[0] = f2 / aspect;
+            out[1] = 0;
+            out[2] = 0;
+            out[3] = 0;
+            out[4] = 0;
+            out[5] = f2;
+            out[6] = 0;
+            out[7] = 0;
+            out[8] = 0;
+            out[9] = 0;
+            out[10] = (far + near) * nf2;
+            out[11] = -1;
+            out[12] = 0;
+            out[13] = 0;
+            out[14] = 2 * far * near * nf2;
+            out[15] = 0;
+            return out;
+          }
+        }
+      });
+      var require_perspectiveFromFieldOfView = __commonJS({
+        "node_modules/gl-mat4/perspectiveFromFieldOfView.js"(exports, module2) {
+          module2.exports = perspectiveFromFieldOfView;
+          function perspectiveFromFieldOfView(out, fov, near, far) {
+            var upTan = Math.tan(fov.upDegrees * Math.PI / 180), downTan = Math.tan(fov.downDegrees * Math.PI / 180), leftTan = Math.tan(fov.leftDegrees * Math.PI / 180), rightTan = Math.tan(fov.rightDegrees * Math.PI / 180), xScale = 2 / (leftTan + rightTan), yScale = 2 / (upTan + downTan);
+            out[0] = xScale;
+            out[1] = 0;
+            out[2] = 0;
+            out[3] = 0;
+            out[4] = 0;
+            out[5] = yScale;
+            out[6] = 0;
+            out[7] = 0;
+            out[8] = -((leftTan - rightTan) * xScale * 0.5);
+            out[9] = (upTan - downTan) * yScale * 0.5;
+            out[10] = far / (near - far);
+            out[11] = -1;
+            out[12] = 0;
+            out[13] = 0;
+            out[14] = far * near / (near - far);
+            out[15] = 0;
+            return out;
+          }
+        }
+      });
+      var require_ortho = __commonJS({
+        "node_modules/gl-mat4/ortho.js"(exports, module2) {
+          module2.exports = ortho2;
+          function ortho2(out, left, right, bottom, top, near, far) {
+            var lr = 1 / (left - right), bt = 1 / (bottom - top), nf2 = 1 / (near - far);
+            out[0] = -2 * lr;
+            out[1] = 0;
+            out[2] = 0;
+            out[3] = 0;
+            out[4] = 0;
+            out[5] = -2 * bt;
+            out[6] = 0;
+            out[7] = 0;
+            out[8] = 0;
+            out[9] = 0;
+            out[10] = 2 * nf2;
+            out[11] = 0;
+            out[12] = (left + right) * lr;
+            out[13] = (top + bottom) * bt;
+            out[14] = (far + near) * nf2;
+            out[15] = 1;
+            return out;
+          }
+        }
+      });
+      var require_lookAt = __commonJS({
+        "node_modules/gl-mat4/lookAt.js"(exports, module2) {
+          var identity22 = require_identity();
+          module2.exports = lookAt2;
+          function lookAt2(out, eye, center, up) {
+            var x0, x1, x2, y0, y1, y2, z0, z1, z2, len2, eyex = eye[0], eyey = eye[1], eyez = eye[2], upx = up[0], upy = up[1], upz = up[2], centerx = center[0], centery = center[1], centerz = center[2];
+            if (Math.abs(eyex - centerx) < 1e-6 && Math.abs(eyey - centery) < 1e-6 && Math.abs(eyez - centerz) < 1e-6) {
+              return identity22(out);
+            }
+            z0 = eyex - centerx;
+            z1 = eyey - centery;
+            z2 = eyez - centerz;
+            len2 = 1 / Math.sqrt(z0 * z0 + z1 * z1 + z2 * z2);
+            z0 *= len2;
+            z1 *= len2;
+            z2 *= len2;
+            x0 = upy * z2 - upz * z1;
+            x1 = upz * z0 - upx * z2;
+            x2 = upx * z1 - upy * z0;
+            len2 = Math.sqrt(x0 * x0 + x1 * x1 + x2 * x2);
+            if (!len2) {
+              x0 = 0;
+              x1 = 0;
+              x2 = 0;
+            } else {
+              len2 = 1 / len2;
+              x0 *= len2;
+              x1 *= len2;
+              x2 *= len2;
+            }
+            y0 = z1 * x2 - z2 * x1;
+            y1 = z2 * x0 - z0 * x2;
+            y2 = z0 * x1 - z1 * x0;
+            len2 = Math.sqrt(y0 * y0 + y1 * y1 + y2 * y2);
+            if (!len2) {
+              y0 = 0;
+              y1 = 0;
+              y2 = 0;
+            } else {
+              len2 = 1 / len2;
+              y0 *= len2;
+              y1 *= len2;
+              y2 *= len2;
+            }
+            out[0] = x0;
+            out[1] = y0;
+            out[2] = z0;
+            out[3] = 0;
+            out[4] = x1;
+            out[5] = y1;
+            out[6] = z1;
+            out[7] = 0;
+            out[8] = x2;
+            out[9] = y2;
+            out[10] = z2;
+            out[11] = 0;
+            out[12] = -(x0 * eyex + x1 * eyey + x2 * eyez);
+            out[13] = -(y0 * eyex + y1 * eyey + y2 * eyez);
+            out[14] = -(z0 * eyex + z1 * eyey + z2 * eyez);
+            out[15] = 1;
+            return out;
+          }
+        }
+      });
+      var require_str = __commonJS({
+        "node_modules/gl-mat4/str.js"(exports, module2) {
+          module2.exports = str;
+          function str(a2) {
+            return "mat4(" + a2[0] + ", " + a2[1] + ", " + a2[2] + ", " + a2[3] + ", " + a2[4] + ", " + a2[5] + ", " + a2[6] + ", " + a2[7] + ", " + a2[8] + ", " + a2[9] + ", " + a2[10] + ", " + a2[11] + ", " + a2[12] + ", " + a2[13] + ", " + a2[14] + ", " + a2[15] + ")";
+          }
+        }
+      });
+      var require_gl_mat4 = __commonJS({
+        "node_modules/gl-mat4/index.js"(exports, module2) {
+          module2.exports = {
+            create: require_create(),
+            clone: require_clone(),
+            copy: require_copy(),
+            identity: require_identity(),
+            transpose: require_transpose(),
+            invert: require_invert(),
+            adjoint: require_adjoint(),
+            determinant: require_determinant(),
+            multiply: require_multiply(),
+            translate: require_translate(),
+            scale: require_scale(),
+            rotate: require_rotate(),
+            rotateX: require_rotateX(),
+            rotateY: require_rotateY(),
+            rotateZ: require_rotateZ(),
+            fromRotation: require_fromRotation(),
+            fromRotationTranslation: require_fromRotationTranslation(),
+            fromScaling: require_fromScaling(),
+            fromTranslation: require_fromTranslation(),
+            fromXRotation: require_fromXRotation(),
+            fromYRotation: require_fromYRotation(),
+            fromZRotation: require_fromZRotation(),
+            fromQuat: require_fromQuat(),
+            frustum: require_frustum(),
+            perspective: require_perspective(),
+            perspectiveFromFieldOfView: require_perspectiveFromFieldOfView(),
+            ortho: require_ortho(),
+            lookAt: require_lookAt(),
+            str: require_str()
+          };
+        }
+      });
+      var require_matrix = __commonJS({
+        "src/lib/matrix.js"(exports) {
+          var mat4X4 = require_gl_mat4();
+          exports.init2dArray = function(rowLength, colLength) {
+            var array = new Array(rowLength);
+            for (var i2 = 0; i2 < rowLength; i2++) array[i2] = new Array(colLength);
+            return array;
+          };
+          exports.transposeRagged = function(z2) {
+            var maxlen = 0;
+            var zlen = z2.length;
+            var i2, j2;
+            for (i2 = 0; i2 < zlen; i2++) maxlen = Math.max(maxlen, z2[i2].length);
+            var t4 = new Array(maxlen);
+            for (i2 = 0; i2 < maxlen; i2++) {
+              t4[i2] = new Array(zlen);
+              for (j2 = 0; j2 < zlen; j2++) t4[i2][j2] = z2[j2][i2];
+            }
+            return t4;
+          };
+          exports.dot = function(x2, y2) {
+            if (!(x2.length && y2.length) || x2.length !== y2.length) return null;
+            var len2 = x2.length;
+            var out;
+            var i2;
+            if (x2[0].length) {
+              out = new Array(len2);
+              for (i2 = 0; i2 < len2; i2++) out[i2] = exports.dot(x2[i2], y2);
+            } else if (y2[0].length) {
+              var yTranspose = exports.transposeRagged(y2);
+              out = new Array(yTranspose.length);
+              for (i2 = 0; i2 < yTranspose.length; i2++) out[i2] = exports.dot(x2, yTranspose[i2]);
+            } else {
+              out = 0;
+              for (i2 = 0; i2 < len2; i2++) out += x2[i2] * y2[i2];
+            }
+            return out;
+          };
+          exports.translationMatrix = function(x2, y2) {
+            return [[1, 0, x2], [0, 1, y2], [0, 0, 1]];
+          };
+          exports.rotationMatrix = function(alpha) {
+            var a2 = alpha * Math.PI / 180;
+            return [
+              [Math.cos(a2), -Math.sin(a2), 0],
+              [Math.sin(a2), Math.cos(a2), 0],
+              [0, 0, 1]
+            ];
+          };
+          exports.rotationXYMatrix = function(a2, x2, y2) {
+            return exports.dot(
+              exports.dot(
+                exports.translationMatrix(x2, y2),
+                exports.rotationMatrix(a2)
+              ),
+              exports.translationMatrix(-x2, -y2)
+            );
+          };
+          exports.apply3DTransform = function(transform) {
+            return function() {
+              var args = arguments;
+              var xyz = arguments.length === 1 ? args[0] : [args[0], args[1], args[2] || 0];
+              return exports.dot(transform, [xyz[0], xyz[1], xyz[2], 1]).slice(0, 3);
+            };
+          };
+          exports.apply2DTransform = function(transform) {
+            return function() {
+              var args = arguments;
+              if (args.length === 3) {
+                args = args[0];
+              }
+              var xy = arguments.length === 1 ? args[0] : [args[0], args[1]];
+              return exports.dot(transform, [xy[0], xy[1], 1]).slice(0, 2);
+            };
+          };
+          exports.apply2DTransform2 = function(transform) {
+            var at2 = exports.apply2DTransform(transform);
+            return function(xys) {
+              return at2(xys.slice(0, 2)).concat(at2(xys.slice(2, 4)));
+            };
+          };
+          exports.convertCssMatrix = function(m2) {
+            if (m2) {
+              var len2 = m2.length;
+              if (len2 === 16) return m2;
+              if (len2 === 6) {
+                return [
+                  m2[0],
+                  m2[1],
+                  0,
+                  0,
+                  m2[2],
+                  m2[3],
+                  0,
+                  0,
+                  0,
+                  0,
+                  1,
+                  0,
+                  m2[4],
+                  m2[5],
+                  0,
+                  1
+                ];
+              }
+            }
+            return [
+              1,
+              0,
+              0,
+              0,
+              0,
+              1,
+              0,
+              0,
+              0,
+              0,
+              1,
+              0,
+              0,
+              0,
+              0,
+              1
+            ];
+          };
+          exports.inverseTransformMatrix = function(m2) {
+            var out = [];
+            mat4X4.invert(out, m2);
+            return [
+              [out[0], out[1], out[2], out[3]],
+              [out[4], out[5], out[6], out[7]],
+              [out[8], out[9], out[10], out[11]],
+              [out[12], out[13], out[14], out[15]]
+            ];
+          };
+        }
+      });
+      var require_dom = __commonJS({
+        "src/lib/dom.js"(exports, module2) {
+          var d3 = require_d3();
+          var loggers2 = require_loggers();
+          var matrix = require_matrix();
+          var mat4X4 = require_gl_mat4();
+          function getGraphDiv(gd2) {
+            var gdElement;
+            if (typeof gd2 === "string") {
+              gdElement = document.getElementById(gd2);
+              if (gdElement === null) {
+                throw new Error("No DOM element with id '" + gd2 + "' exists on the page.");
+              }
+              return gdElement;
+            } else if (gd2 === null || gd2 === void 0) {
+              throw new Error("DOM element provided is null or undefined");
+            }
+            return gd2;
+          }
+          function isPlotDiv(el2) {
+            var el3 = d3.select(el2);
+            return el3.node() instanceof HTMLElement && el3.size() && el3.classed("js-plotly-plot");
+          }
+          function removeElement(el2) {
+            var elParent = el2 && el2.parentNode;
+            if (elParent) elParent.removeChild(el2);
+          }
+          function addStyleRule(selector, styleString) {
+            addRelatedStyleRule("global", selector, styleString);
+          }
+          function addRelatedStyleRule(uid2, selector, styleString) {
+            var id2 = "plotly.js-style-" + uid2;
+            var style = document.getElementById(id2);
+            if (style && style.matches(".no-inline-styles")) {
+              return;
+            }
+            if (!style) {
+              style = document.createElement("style");
+              style.setAttribute("id", id2);
+              style.appendChild(document.createTextNode(""));
+              document.head.appendChild(style);
+            }
+            var styleSheet = style.sheet;
+            if (!styleSheet) {
+              loggers2.warn("Cannot addRelatedStyleRule, probably due to strict CSP...");
+            } else if (styleSheet.insertRule) {
+              styleSheet.insertRule(selector + "{" + styleString + "}", 0);
+            } else if (styleSheet.addRule) {
+              styleSheet.addRule(selector, styleString, 0);
+            } else loggers2.warn("addStyleRule failed");
+          }
+          function deleteRelatedStyleRule(uid2) {
+            var id2 = "plotly.js-style-" + uid2;
+            var style = document.getElementById(id2);
+            if (style) removeElement(style);
+          }
+          function setStyleOnHover(selector, activeSelector, childSelector, activeStyle, inactiveStyle, element) {
+            var activeStyleParts = activeStyle.split(":");
+            var inactiveStyleParts = inactiveStyle.split(":");
+            var eventAddedAttrName = "data-btn-style-event-added";
+            if (!element) {
+              element = document;
+            }
+            element.querySelectorAll(selector).forEach(function(el2) {
+              if (!el2.getAttribute(eventAddedAttrName)) {
+                el2.addEventListener("mouseenter", function() {
+                  var childEl = this.querySelector(childSelector);
+                  if (childEl) {
+                    childEl.style[activeStyleParts[0]] = activeStyleParts[1];
+                  }
+                });
+                el2.addEventListener("mouseleave", function() {
+                  var childEl = this.querySelector(childSelector);
+                  if (childEl) {
+                    if (activeSelector && this.matches(activeSelector)) {
+                      childEl.style[activeStyleParts[0]] = activeStyleParts[1];
+                    } else {
+                      childEl.style[inactiveStyleParts[0]] = inactiveStyleParts[1];
+                    }
+                  }
+                });
+                el2.setAttribute(eventAddedAttrName, true);
+              }
+            });
+          }
+          function getFullTransformMatrix(element) {
+            var allElements = getElementAndAncestors(element);
+            var out = [
+              1,
+              0,
+              0,
+              0,
+              0,
+              1,
+              0,
+              0,
+              0,
+              0,
+              1,
+              0,
+              0,
+              0,
+              0,
+              1
+            ];
+            allElements.forEach(function(e2) {
+              var t4 = getElementTransformMatrix(e2);
+              if (t4) {
+                var m2 = matrix.convertCssMatrix(t4);
+                out = mat4X4.multiply(out, out, m2);
+              }
+            });
+            return out;
+          }
+          function getElementTransformMatrix(element) {
+            var style = window.getComputedStyle(element, null);
+            var transform = style.getPropertyValue("-webkit-transform") || style.getPropertyValue("-moz-transform") || style.getPropertyValue("-ms-transform") || style.getPropertyValue("-o-transform") || style.getPropertyValue("transform");
+            if (transform === "none") return null;
+            return transform.replace("matrix", "").replace("3d", "").slice(1, -1).split(",").map(function(n2) {
+              return +n2;
+            });
+          }
+          function getElementAndAncestors(element) {
+            var allElements = [];
+            while (isTransformableElement(element)) {
+              allElements.push(element);
+              element = element.parentNode;
+              if (typeof ShadowRoot === "function" && element instanceof ShadowRoot) {
+                element = element.host;
+              }
+            }
+            return allElements;
+          }
+          function isTransformableElement(element) {
+            return element && (element instanceof Element || element instanceof HTMLElement);
+          }
+          function equalDomRects(a2, b2) {
+            return a2 && b2 && a2.top === b2.top && a2.left === b2.left && a2.right === b2.right && a2.bottom === b2.bottom;
+          }
+          module2.exports = {
+            getGraphDiv,
+            isPlotDiv,
+            removeElement,
+            addStyleRule,
+            addRelatedStyleRule,
+            deleteRelatedStyleRule,
+            setStyleOnHover,
+            getFullTransformMatrix,
+            getElementTransformMatrix,
+            getElementAndAncestors,
+            equalDomRects
+          };
+        }
+      });
+      var require_animation_attributes = __commonJS({
+        "src/plots/animation_attributes.js"(exports, module2) {
+          module2.exports = {
+            mode: {
+              valType: "enumerated",
+              dflt: "afterall",
+              values: ["immediate", "next", "afterall"]
+            },
+            direction: {
+              valType: "enumerated",
+              values: ["forward", "reverse"],
+              dflt: "forward"
+            },
+            fromcurrent: {
+              valType: "boolean",
+              dflt: false
+            },
+            frame: {
+              duration: {
+                valType: "number",
+                min: 0,
+                dflt: 500
+              },
+              redraw: {
+                valType: "boolean",
+                dflt: true
+              }
+            },
+            transition: {
+              duration: {
+                valType: "number",
+                min: 0,
+                dflt: 500,
+                editType: "none"
+              },
+              easing: {
+                valType: "enumerated",
+                dflt: "cubic-in-out",
+                values: [
+                  "linear",
+                  "quad",
+                  "cubic",
+                  "sin",
+                  "exp",
+                  "circle",
+                  "elastic",
+                  "back",
+                  "bounce",
+                  "linear-in",
+                  "quad-in",
+                  "cubic-in",
+                  "sin-in",
+                  "exp-in",
+                  "circle-in",
+                  "elastic-in",
+                  "back-in",
+                  "bounce-in",
+                  "linear-out",
+                  "quad-out",
+                  "cubic-out",
+                  "sin-out",
+                  "exp-out",
+                  "circle-out",
+                  "elastic-out",
+                  "back-out",
+                  "bounce-out",
+                  "linear-in-out",
+                  "quad-in-out",
+                  "cubic-in-out",
+                  "sin-in-out",
+                  "exp-in-out",
+                  "circle-in-out",
+                  "elastic-in-out",
+                  "back-in-out",
+                  "bounce-in-out"
+                ],
+                editType: "none"
+              },
+              ordering: {
+                valType: "enumerated",
+                values: ["layout first", "traces first"],
+                dflt: "layout first",
+                editType: "none"
+              }
+            }
+          };
+        }
+      });
+      var require_edit_types = __commonJS({
+        "src/plot_api/edit_types.js"(exports, module2) {
+          var extendFlat = require_extend().extendFlat;
+          var isPlainObject2 = require_is_plain_object();
+          var traceOpts = {
+            valType: "flaglist",
+            extras: ["none"],
+            flags: ["calc", "clearAxisTypes", "plot", "style", "markerSize", "colorbars"]
+          };
+          var layoutOpts = {
+            valType: "flaglist",
+            extras: ["none"],
+            flags: [
+              "calc",
+              "plot",
+              "legend",
+              "ticks",
+              "axrange",
+              "layoutstyle",
+              "modebar",
+              "camera",
+              "arraydraw",
+              "colorbars"
+            ]
+          };
+          var traceEditTypeFlags = traceOpts.flags.slice().concat(["fullReplot"]);
+          var layoutEditTypeFlags = layoutOpts.flags.slice().concat("layoutReplot");
+          module2.exports = {
+            traces: traceOpts,
+            layout: layoutOpts,
+            /*
+             * default (all false) edit flags for restyle (traces)
+             * creates a new object each call, so the caller can mutate freely
+             */
+            traceFlags: function() {
+              return falseObj(traceEditTypeFlags);
+            },
+            /*
+             * default (all false) edit flags for relayout
+             * creates a new object each call, so the caller can mutate freely
+             */
+            layoutFlags: function() {
+              return falseObj(layoutEditTypeFlags);
+            },
+            /*
+             * update `flags` with the `editType` values found in `attr`
+             */
+            update: function(flags, attr) {
+              var editType = attr.editType;
+              if (editType && editType !== "none") {
+                var editTypeParts = editType.split("+");
+                for (var i2 = 0; i2 < editTypeParts.length; i2++) {
+                  flags[editTypeParts[i2]] = true;
+                }
+              }
+            },
+            overrideAll
+          };
+          function falseObj(keys) {
+            var out = {};
+            for (var i2 = 0; i2 < keys.length; i2++) out[keys[i2]] = false;
+            return out;
+          }
+          function overrideAll(attrs, editTypeOverride, overrideContainers) {
+            var out = extendFlat({}, attrs);
+            for (var key in out) {
+              var attr = out[key];
+              if (isPlainObject2(attr)) {
+                out[key] = overrideOne(attr, editTypeOverride, overrideContainers, key);
+              }
+            }
+            if (overrideContainers === "from-root") out.editType = editTypeOverride;
+            return out;
+          }
+          function overrideOne(attr, editTypeOverride, overrideContainers, key) {
+            if (attr.valType) {
+              var out = extendFlat({}, attr);
+              out.editType = editTypeOverride;
+              if (Array.isArray(attr.items)) {
+                out.items = new Array(attr.items.length);
+                for (var i2 = 0; i2 < attr.items.length; i2++) {
+                  out.items[i2] = overrideOne(attr.items[i2], editTypeOverride);
+                }
+              }
+              return out;
+            } else {
+              return overrideAll(
+                attr,
+                editTypeOverride,
+                key.charAt(0) === "_" ? "nested" : "from-root"
+              );
+            }
+          }
+        }
+      });
+      var require_attributes4 = __commonJS({
+        "src/components/drawing/attributes.js"(exports) {
+          exports.dash = {
+            valType: "string",
+            // string type usually doesn't take values... this one should really be
+            // a special type or at least a special coercion function, from the GUI
+            // you only get these values but elsewhere the user can supply a list of
+            // dash lengths in px, and it will be honored
+            values: ["solid", "dot", "dash", "longdash", "dashdot", "longdashdot"],
+            dflt: "solid",
+            editType: "style"
+          };
+          exports.pattern = {
+            shape: {
+              valType: "enumerated",
+              values: ["", "/", "\\", "x", "-", "|", "+", "."],
+              dflt: "",
+              arrayOk: true,
+              editType: "style"
+            },
+            path: {
+              valType: "string",
+              arrayOk: true,
+              editType: "style"
+            },
+            fillmode: {
+              valType: "enumerated",
+              values: ["replace", "overlay"],
+              dflt: "replace",
+              editType: "style"
+            },
+            bgcolor: {
+              valType: "color",
+              arrayOk: true,
+              editType: "style"
+            },
+            fgcolor: {
+              valType: "color",
+              arrayOk: true,
+              editType: "style"
+            },
+            fgopacity: {
+              valType: "number",
+              editType: "style",
+              min: 0,
+              max: 1
+            },
+            size: {
+              valType: "number",
+              min: 0,
+              dflt: 8,
+              arrayOk: true,
+              editType: "style"
+            },
+            solidity: {
+              valType: "number",
+              min: 0,
+              max: 1,
+              dflt: 0.3,
+              arrayOk: true,
+              editType: "style"
+            },
+            editType: "style"
+          };
+        }
+      });
+      var require_docs = __commonJS({
+        "src/constants/docs.js"(exports, module2) {
+          module2.exports = {
+            FORMAT_LINK: "https://github.com/d3/d3-format/tree/v1.4.5#d3-format",
+            DATE_FORMAT_LINK: "https://github.com/d3/d3-time-format/tree/v2.2.3#locale_format"
+          };
+        }
+      });
+      var require_template_attributes = __commonJS({
+        "src/plots/template_attributes.js"(exports) {
+          var { DATE_FORMAT_LINK, FORMAT_LINK } = require_docs();
+          var MISSING_UNDEFINED_DESCRIPTION = [
+            "Variables that can't be found will be replaced with the specifier.",
+            'For example, a template of "data: %{x}, %{y}" will result in a value of "data: 1, %{y}" if x is 1 and y is missing.',
+            "Variables with an undefined value will be replaced with the fallback value."
+          ].join(" ");
+          function templateFormatStringDescription({ supportOther } = {}) {
+            const supportOtherText = " as well as %{xother}, {%_xother}, {%_xother_}, {%xother_}. When showing info for several points, *xother* will be added to those with different x positions from the first point. An underscore before or after *(x|y)other* will add a space on that side, only when this field is shown.";
+            return [
+              "Variables are inserted using %{variable},",
+              'for example "y: %{y}"' + (supportOther ? supportOtherText : "."),
+              `Numbers are formatted using d3-format's syntax %{variable:d3-format}, for example "Price: %{y:$.2f}".`,
+              FORMAT_LINK,
+              "for details on the formatting syntax.",
+              `Dates are formatted using d3-time-format's syntax %{variable|d3-time-format}, for example "Day: %{2019-01-01|%A}".`,
+              DATE_FORMAT_LINK,
+              "for details on the date formatting syntax.",
+              MISSING_UNDEFINED_DESCRIPTION
+            ].join(" ");
+          }
+          exports.templateFormatStringDescription = templateFormatStringDescription;
+          exports.hovertemplateAttrs = ({ editType = "none", arrayOk } = {}, extra = {}) => __spreadValues({
+            valType: "string",
+            dflt: "",
+            editType
+          }, arrayOk !== false ? { arrayOk: true } : {});
+          exports.texttemplateAttrs = ({ editType = "calc", arrayOk } = {}, extra = {}) => __spreadValues({
+            valType: "string",
+            dflt: "",
+            editType
+          }, arrayOk !== false ? { arrayOk: true } : {});
+          exports.shapeTexttemplateAttrs = ({ editType = "arraydraw", newshape } = {}, extra = {}) => ({
+            valType: "string",
+            dflt: "",
+            editType
+          });
+          exports.templatefallbackAttrs = ({ editType = "none" } = {}) => ({
+            valType: "any",
+            dflt: "-",
+            editType
+          });
+        }
+      });
+      var require_label_texttemplate = __commonJS({
+        "src/components/shapes/label_texttemplate.js"(exports, module2) {
+          function d2l(v2, axis) {
+            return axis ? axis.d2l(v2) : v2;
+          }
+          function l2d(v2, axis) {
+            return axis ? axis.l2d(v2) : v2;
+          }
+          function x0Fn(shape) {
+            return shape.x0;
+          }
+          function x1Fn(shape) {
+            return shape.x1;
+          }
+          function y0Fn(shape) {
+            return shape.y0;
+          }
+          function y1Fn(shape) {
+            return shape.y1;
+          }
+          function x0shiftFn(shape) {
+            return shape.x0shift || 0;
+          }
+          function x1shiftFn(shape) {
+            return shape.x1shift || 0;
+          }
+          function y0shiftFn(shape) {
+            return shape.y0shift || 0;
+          }
+          function y1shiftFn(shape) {
+            return shape.y1shift || 0;
+          }
+          function dxFn(shape, xa) {
+            return d2l(shape.x1, xa) + x1shiftFn(shape) - d2l(shape.x0, xa) - x0shiftFn(shape);
+          }
+          function dyFn(shape, xa, ya2) {
+            return d2l(shape.y1, ya2) + y1shiftFn(shape) - d2l(shape.y0, ya2) - y0shiftFn(shape);
+          }
+          function widthFn(shape, xa) {
+            return Math.abs(dxFn(shape, xa));
+          }
+          function heightFn(shape, xa, ya2) {
+            return Math.abs(dyFn(shape, xa, ya2));
+          }
+          function lengthFn(shape, xa, ya2) {
+            return shape.type !== "line" ? void 0 : Math.sqrt(
+              Math.pow(dxFn(shape, xa), 2) + Math.pow(dyFn(shape, xa, ya2), 2)
+            );
+          }
+          function xcenterFn(shape, xa) {
+            return l2d((d2l(shape.x1, xa) + x1shiftFn(shape) + d2l(shape.x0, xa) + x0shiftFn(shape)) / 2, xa);
+          }
+          function ycenterFn(shape, xa, ya2) {
+            return l2d((d2l(shape.y1, ya2) + y1shiftFn(shape) + d2l(shape.y0, ya2) + y0shiftFn(shape)) / 2, ya2);
+          }
+          function slopeFn(shape, xa, ya2) {
+            return shape.type !== "line" ? void 0 : dyFn(shape, xa, ya2) / dxFn(shape, xa);
+          }
+          var simpleXVariables = ["x0", "x1", "y0", "y1", "dy", "height", "ycenter"];
+          var simpleYVariables = ["x0", "x1", "y0", "y1", "dx", "width", "xcenter"];
+          module2.exports = {
+            x0: x0Fn,
+            x1: x1Fn,
+            y0: y0Fn,
+            y1: y1Fn,
+            slope: slopeFn,
+            dx: dxFn,
+            dy: dyFn,
+            width: widthFn,
+            height: heightFn,
+            length: lengthFn,
+            xcenter: xcenterFn,
+            ycenter: ycenterFn,
+            simpleXVariables,
+            simpleYVariables
+          };
+        }
+      });
+      var require_attributes5 = __commonJS({
+        "src/components/shapes/draw_newshape/attributes.js"(exports, module2) {
+          var overrideAll = require_edit_types().overrideAll;
+          var basePlotAttributes = require_attributes2();
+          var fontAttrs = require_font_attributes();
+          var dash = require_attributes4().dash;
+          var extendFlat = require_extend().extendFlat;
+          var { shapeTexttemplateAttrs, templatefallbackAttrs } = require_template_attributes();
+          var shapeLabelTexttemplateVars = require_label_texttemplate();
+          module2.exports = overrideAll(
+            {
+              newshape: {
+                visible: extendFlat({}, basePlotAttributes.visible, {}),
+                showlegend: {
+                  valType: "boolean",
+                  dflt: false
+                },
+                legend: extendFlat({}, basePlotAttributes.legend, {}),
+                legendgroup: extendFlat({}, basePlotAttributes.legendgroup, {}),
+                legendgrouptitle: {
+                  text: extendFlat({}, basePlotAttributes.legendgrouptitle.text, {}),
+                  font: fontAttrs({})
+                },
+                legendrank: extendFlat({}, basePlotAttributes.legendrank, {}),
+                legendwidth: extendFlat({}, basePlotAttributes.legendwidth, {}),
+                line: {
+                  color: {
+                    valType: "color"
+                  },
+                  width: {
+                    valType: "number",
+                    min: 0,
+                    dflt: 4
+                  },
+                  dash: extendFlat({}, dash, {
+                    dflt: "solid"
+                  })
+                },
+                fillcolor: {
+                  valType: "color",
+                  dflt: "rgba(0,0,0,0)"
+                },
+                fillrule: {
+                  valType: "enumerated",
+                  values: ["evenodd", "nonzero"],
+                  dflt: "evenodd"
+                },
+                opacity: {
+                  valType: "number",
+                  min: 0,
+                  max: 1,
+                  dflt: 1
+                },
+                layer: {
+                  valType: "enumerated",
+                  values: ["below", "above", "between"],
+                  dflt: "above"
+                },
+                drawdirection: {
+                  valType: "enumerated",
+                  values: ["ortho", "horizontal", "vertical", "diagonal"],
+                  dflt: "diagonal"
+                },
+                name: extendFlat({}, basePlotAttributes.name, {}),
+                label: {
+                  text: {
+                    valType: "string",
+                    dflt: ""
+                  },
+                  texttemplate: shapeTexttemplateAttrs(
+                    { newshape: true },
+                    { keys: Object.keys(shapeLabelTexttemplateVars) }
+                  ),
+                  texttemplatefallback: templatefallbackAttrs({ editType: "arraydraw" }),
+                  font: fontAttrs({}),
+                  textposition: {
+                    valType: "enumerated",
+                    values: [
+                      "top left",
+                      "top center",
+                      "top right",
+                      "middle left",
+                      "middle center",
+                      "middle right",
+                      "bottom left",
+                      "bottom center",
+                      "bottom right",
+                      "start",
+                      "middle",
+                      "end"
+                    ]
+                  },
+                  textangle: {
+                    valType: "angle",
+                    dflt: "auto"
+                  },
+                  xanchor: {
+                    valType: "enumerated",
+                    values: ["auto", "left", "center", "right"],
+                    dflt: "auto"
+                  },
+                  yanchor: {
+                    valType: "enumerated",
+                    values: ["top", "middle", "bottom"]
+                  },
+                  padding: {
+                    valType: "number",
+                    dflt: 3,
+                    min: 0
+                  }
+                }
+              },
+              activeshape: {
+                fillcolor: {
+                  valType: "color",
+                  dflt: "rgb(255,0,255)",
+                  description: "Sets the color filling the active shape' interior."
+                },
+                opacity: {
+                  valType: "number",
+                  min: 0,
+                  max: 1,
+                  dflt: 0.5
+                }
+              }
+            },
+            "none",
+            "from-root"
+          );
+        }
+      });
+      var require_attributes6 = __commonJS({
+        "src/components/selections/draw_newselection/attributes.js"(exports, module2) {
+          var dash = require_attributes4().dash;
+          var extendFlat = require_extend().extendFlat;
+          module2.exports = {
+            newselection: {
+              mode: {
+                valType: "enumerated",
+                values: ["immediate", "gradual"],
+                dflt: "immediate",
+                editType: "none"
+              },
+              line: {
+                color: {
+                  valType: "color",
+                  editType: "none"
+                },
+                width: {
+                  valType: "number",
+                  min: 1,
+                  dflt: 1,
+                  editType: "none"
+                },
+                dash: extendFlat({}, dash, {
+                  dflt: "dot",
+                  editType: "none"
+                }),
+                editType: "none"
+              },
+              // no drawdirection here noting that layout.selectdirection is used instead.
+              editType: "none"
+            },
+            activeselection: {
+              fillcolor: {
+                valType: "color",
+                dflt: "rgba(0,0,0,0)",
+                editType: "none"
+              },
+              opacity: {
+                valType: "number",
+                min: 0,
+                max: 1,
+                dflt: 0.5,
+                editType: "none"
+              },
+              editType: "none"
+            }
+          };
+        }
+      });
+      var require_pad_attributes = __commonJS({
+        "src/plots/pad_attributes.js"(exports, module2) {
+          module2.exports = function(opts) {
+            var editType = opts.editType;
+            return {
+              t: {
+                valType: "number",
+                dflt: 0,
+                editType
+              },
+              r: {
+                valType: "number",
+                dflt: 0,
+                editType
+              },
+              b: {
+                valType: "number",
+                dflt: 0,
+                editType
+              },
+              l: {
+                valType: "number",
+                dflt: 0,
+                editType
+              },
+              editType
+            };
+          };
+        }
+      });
+      var require_layout_attributes2 = __commonJS({
+        "src/plots/layout_attributes.js"(exports, module2) {
+          var fontAttrs = require_font_attributes();
+          var animationAttrs = require_animation_attributes();
+          var colorAttrs = require_attributes3();
+          var drawNewShapeAttrs = require_attributes5();
+          var drawNewSelectionAttrs = require_attributes6();
+          var padAttrs = require_pad_attributes();
+          var extendFlat = require_extend().extendFlat;
+          var globalFont = fontAttrs({
+            editType: "calc"
+          });
+          globalFont.family.dflt = '"Open Sans", verdana, arial, sans-serif';
+          globalFont.size.dflt = 12;
+          globalFont.color.dflt = colorAttrs.defaultLine;
+          module2.exports = {
+            font: globalFont,
+            title: {
+              text: {
+                valType: "string",
+                editType: "layoutstyle"
+              },
+              font: fontAttrs({
+                editType: "layoutstyle"
+              }),
+              subtitle: {
+                text: {
+                  valType: "string",
+                  editType: "layoutstyle"
+                },
+                font: fontAttrs({
+                  editType: "layoutstyle"
+                }),
+                editType: "layoutstyle"
+              },
+              xref: {
+                valType: "enumerated",
+                dflt: "container",
+                values: ["container", "paper"],
+                editType: "layoutstyle"
+              },
+              yref: {
+                valType: "enumerated",
+                dflt: "container",
+                values: ["container", "paper"],
+                editType: "layoutstyle"
+              },
+              x: {
+                valType: "number",
+                min: 0,
+                max: 1,
+                dflt: 0.5,
+                editType: "layoutstyle"
+              },
+              y: {
+                valType: "number",
+                min: 0,
+                max: 1,
+                dflt: "auto",
+                editType: "layoutstyle"
+              },
+              xanchor: {
+                valType: "enumerated",
+                dflt: "auto",
+                values: ["auto", "left", "center", "right"],
+                editType: "layoutstyle"
+              },
+              yanchor: {
+                valType: "enumerated",
+                dflt: "auto",
+                values: ["auto", "top", "middle", "bottom"],
+                editType: "layoutstyle"
+              },
+              pad: extendFlat(padAttrs({ editType: "layoutstyle" }), {}),
+              automargin: {
+                valType: "boolean",
+                dflt: false,
+                editType: "plot"
+              },
+              editType: "layoutstyle"
+            },
+            uniformtext: {
+              mode: {
+                valType: "enumerated",
+                values: [false, "hide", "show"],
+                dflt: false,
+                editType: "plot"
+              },
+              minsize: {
+                valType: "number",
+                min: 0,
+                dflt: 0,
+                editType: "plot"
+              },
+              editType: "plot"
+            },
+            autosize: {
+              valType: "boolean",
+              dflt: false,
+              // autosize, width, and height get special editType treatment in _relayout
+              // so we can handle noop resizes more efficiently
+              editType: "none"
+            },
+            width: {
+              valType: "number",
+              min: 10,
+              dflt: 700,
+              editType: "plot"
+            },
+            height: {
+              valType: "number",
+              min: 10,
+              dflt: 450,
+              editType: "plot"
+            },
+            minreducedwidth: {
+              valType: "number",
+              min: 2,
+              dflt: 64,
+              editType: "plot"
+            },
+            minreducedheight: {
+              valType: "number",
+              min: 2,
+              dflt: 64,
+              editType: "plot"
+            },
+            margin: {
+              l: {
+                valType: "number",
+                min: 0,
+                dflt: 80,
+                editType: "plot"
+              },
+              r: {
+                valType: "number",
+                min: 0,
+                dflt: 80,
+                editType: "plot"
+              },
+              t: {
+                valType: "number",
+                min: 0,
+                dflt: 100,
+                editType: "plot"
+              },
+              b: {
+                valType: "number",
+                min: 0,
+                dflt: 80,
+                editType: "plot"
+              },
+              pad: {
+                valType: "number",
+                min: 0,
+                dflt: 0,
+                editType: "plot"
+              },
+              autoexpand: {
+                valType: "boolean",
+                dflt: true,
+                editType: "plot"
+              },
+              editType: "plot"
+            },
+            computed: {
+              valType: "any",
+              editType: "none"
+            },
+            paper_bgcolor: {
+              valType: "color",
+              dflt: colorAttrs.background,
+              editType: "plot"
+            },
+            plot_bgcolor: {
+              // defined here, but set in cartesian.supplyLayoutDefaults
+              // because it needs to know if there are (2D) axes or not
+              valType: "color",
+              dflt: colorAttrs.background,
+              editType: "layoutstyle"
+            },
+            autotypenumbers: {
+              valType: "enumerated",
+              values: ["convert types", "strict"],
+              dflt: "convert types",
+              editType: "calc"
+            },
+            separators: {
+              valType: "string",
+              editType: "plot"
+            },
+            hidesources: {
+              valType: "boolean",
+              dflt: false,
+              editType: "plot"
+            },
+            showlegend: {
+              // handled in legend.supplyLayoutDefaults
+              // but included here because it's not in the legend object
+              valType: "boolean",
+              editType: "legend"
+            },
+            colorway: {
+              valType: "colorlist",
+              dflt: colorAttrs.defaults,
+              editType: "calc"
+            },
+            datarevision: {
+              valType: "any",
+              editType: "calc"
+            },
+            uirevision: {
+              valType: "any",
+              editType: "none"
+            },
+            editrevision: {
+              valType: "any",
+              editType: "none"
+            },
+            selectionrevision: {
+              valType: "any",
+              editType: "none"
+            },
+            template: {
+              valType: "any",
+              editType: "calc"
+            },
+            newshape: drawNewShapeAttrs.newshape,
+            activeshape: drawNewShapeAttrs.activeshape,
+            newselection: drawNewSelectionAttrs.newselection,
+            activeselection: drawNewSelectionAttrs.activeselection,
+            meta: {
+              valType: "any",
+              arrayOk: true,
+              editType: "plot"
+            },
+            transition: extendFlat({}, animationAttrs.transition, {
+              editType: "none"
+            })
+          };
+        }
+      });
+      var require_maplibre_gl = __commonJS({
+        "node_modules/maplibre-gl/dist/maplibre-gl.css"() {
+          (function() {
+            if (!document.getElementById("a75c73da1cd7a97e8992659f6aed556255838daadea9ca0c9fc3af7f1ddf63c0")) {
+              var e2 = document.createElement("style");
+              e2.id = "a75c73da1cd7a97e8992659f6aed556255838daadea9ca0c9fc3af7f1ddf63c0";
+              e2.textContent = `.maplibregl-map{font:12px/20px Helvetica Neue,Arial,Helvetica,sans-serif;overflow:hidden;position:relative;-webkit-tap-highlight-color:rgb(0 0 0/0)}.maplibregl-canvas{left:0;position:absolute;top:0}.maplibregl-map:fullscreen{height:100%;width:100%}.maplibregl-ctrl-group button.maplibregl-ctrl-compass{touch-action:none}.maplibregl-canvas-container.maplibregl-interactive,.maplibregl-ctrl-group button.maplibregl-ctrl-compass{cursor:grab;-webkit-user-select:none;-moz-user-select:none;user-select:none}.maplibregl-canvas-container.maplibregl-interactive.maplibregl-track-pointer{cursor:pointer}.maplibregl-canvas-container.maplibregl-interactive:active,.maplibregl-ctrl-group button.maplibregl-ctrl-compass:active{cursor:grabbing}.maplibregl-canvas-container.maplibregl-touch-zoom-rotate,.maplibregl-canvas-container.maplibregl-touch-zoom-rotate .maplibregl-canvas{touch-action:pan-x pan-y}.maplibregl-canvas-container.maplibregl-touch-drag-pan,.maplibregl-canvas-container.maplibregl-touch-drag-pan .maplibregl-canvas{touch-action:pinch-zoom}.maplibregl-canvas-container.maplibregl-touch-zoom-rotate.maplibregl-touch-drag-pan,.maplibregl-canvas-container.maplibregl-touch-zoom-rotate.maplibregl-touch-drag-pan .maplibregl-canvas{touch-action:none}.maplibregl-canvas-container.maplibregl-touch-drag-pan.maplibregl-cooperative-gestures,.maplibregl-canvas-container.maplibregl-touch-drag-pan.maplibregl-cooperative-gestures .maplibregl-canvas{touch-action:pan-x pan-y}.maplibregl-ctrl-bottom-left,.maplibregl-ctrl-bottom-right,.maplibregl-ctrl-top-left,.maplibregl-ctrl-top-right{pointer-events:none;position:absolute;z-index:2}.maplibregl-ctrl-top-left{left:0;top:0}.maplibregl-ctrl-top-right{right:0;top:0}.maplibregl-ctrl-bottom-left{bottom:0;left:0}.maplibregl-ctrl-bottom-right{bottom:0;right:0}.maplibregl-ctrl{clear:both;pointer-events:auto;transform:translate(0)}.maplibregl-ctrl-top-left .maplibregl-ctrl{float:left;margin:10px 0 0 10px}.maplibregl-ctrl-top-right .maplibregl-ctrl{float:right;margin:10px 10px 0 0}.maplibregl-ctrl-bottom-left .maplibregl-ctrl{float:left;margin:0 0 10px 10px}.maplibregl-ctrl-bottom-right .maplibregl-ctrl{float:right;margin:0 10px 10px 0}.maplibregl-ctrl-group{background:#fff;border-radius:4px}.maplibregl-ctrl-group:not(:empty){box-shadow:0 0 0 2px rgba(0,0,0,.1)}@media (forced-colors:active){.maplibregl-ctrl-group:not(:empty){box-shadow:0 0 0 2px ButtonText}}.maplibregl-ctrl-group button{background-color:transparent;border:0;box-sizing:border-box;cursor:pointer;display:block;height:29px;outline:none;padding:0;width:29px}.maplibregl-ctrl-group button+button{border-top:1px solid #ddd}.maplibregl-ctrl button .maplibregl-ctrl-icon{background-position:50%;background-repeat:no-repeat;display:block;height:100%;width:100%}@media (forced-colors:active){.maplibregl-ctrl-icon{background-color:transparent}.maplibregl-ctrl-group button+button{border-top:1px solid ButtonText}}.maplibregl-ctrl button::-moz-focus-inner{border:0;padding:0}.maplibregl-ctrl-attrib-button:focus,.maplibregl-ctrl-group button:focus{box-shadow:0 0 2px 2px #0096ff}.maplibregl-ctrl button:disabled{cursor:not-allowed}.maplibregl-ctrl button:disabled .maplibregl-ctrl-icon{opacity:.25}.maplibregl-ctrl button:not(:disabled):hover{background-color:rgb(0 0 0/5%)}.maplibregl-ctrl-group button:focus:focus-visible{box-shadow:0 0 2px 2px #0096ff}.maplibregl-ctrl-group button:focus:not(:focus-visible){box-shadow:none}.maplibregl-ctrl-group button:focus:first-child{border-radius:4px 4px 0 0}.maplibregl-ctrl-group button:focus:last-child{border-radius:0 0 4px 4px}.maplibregl-ctrl-group button:focus:only-child{border-radius:inherit}.maplibregl-ctrl button.maplibregl-ctrl-zoom-out .maplibregl-ctrl-icon{background-image:url("data:image/svg+xml;charset=utf-8,%3Csvg xmlns='http://www.w3.org/2000/svg' width='29' height='29' fill='%23333' viewBox='0 0 29 29'%3E%3Cpath d='M10 13c-.75 0-1.5.75-1.5 1.5S9.25 16 10 16h9c.75 0 1.5-.75 1.5-1.5S19.75 13 19 13z'/%3E%3C/svg%3E")}.maplibregl-ctrl button.maplibregl-ctrl-zoom-in .maplibregl-ctrl-icon{background-image:url("data:image/svg+xml;charset=utf-8,%3Csvg xmlns='http://www.w3.org/2000/svg' width='29' height='29' fill='%23333' viewBox='0 0 29 29'%3E%3Cpath d='M14.5 8.5c-.75 0-1.5.75-1.5 1.5v3h-3c-.75 0-1.5.75-1.5 1.5S9.25 16 10 16h3v3c0 .75.75 1.5 1.5 1.5S16 19.75 16 19v-3h3c.75 0 1.5-.75 1.5-1.5S19.75 13 19 13h-3v-3c0-.75-.75-1.5-1.5-1.5'/%3E%3C/svg%3E")}@media (forced-colors:active){.maplibregl-ctrl button.maplibregl-ctrl-zoom-out .maplibregl-ctrl-icon{background-image:url("data:image/svg+xml;charset=utf-8,%3Csvg xmlns='http://www.w3.org/2000/svg' width='29' height='29' fill='%23fff' viewBox='0 0 29 29'%3E%3Cpath d='M10 13c-.75 0-1.5.75-1.5 1.5S9.25 16 10 16h9c.75 0 1.5-.75 1.5-1.5S19.75 13 19 13z'/%3E%3C/svg%3E")}.maplibregl-ctrl button.maplibregl-ctrl-zoom-in .maplibregl-ctrl-icon{background-image:url("data:image/svg+xml;charset=utf-8,%3Csvg xmlns='http://www.w3.org/2000/svg' width='29' height='29' fill='%23fff' viewBox='0 0 29 29'%3E%3Cpath d='M14.5 8.5c-.75 0-1.5.75-1.5 1.5v3h-3c-.75 0-1.5.75-1.5 1.5S9.25 16 10 16h3v3c0 .75.75 1.5 1.5 1.5S16 19.75 16 19v-3h3c.75 0 1.5-.75 1.5-1.5S19.75 13 19 13h-3v-3c0-.75-.75-1.5-1.5-1.5'/%3E%3C/svg%3E")}}@media (forced-colors:active) and (prefers-color-scheme:light){.maplibregl-ctrl button.maplibregl-ctrl-zoom-out .maplibregl-ctrl-icon{background-image:url("data:image/svg+xml;charset=utf-8,%3Csvg xmlns='http://www.w3.org/2000/svg' width='29' height='29' viewBox='0 0 29 29'%3E%3Cpath d='M10 13c-.75 0-1.5.75-1.5 1.5S9.25 16 10 16h9c.75 0 1.5-.75 1.5-1.5S19.75 13 19 13z'/%3E%3C/svg%3E")}.maplibregl-ctrl button.maplibregl-ctrl-zoom-in .maplibregl-ctrl-icon{background-image:url("data:image/svg+xml;charset=utf-8,%3Csvg xmlns='http://www.w3.org/2000/svg' width='29' height='29' viewBox='0 0 29 29'%3E%3Cpath d='M14.5 8.5c-.75 0-1.5.75-1.5 1.5v3h-3c-.75 0-1.5.75-1.5 1.5S9.25 16 10 16h3v3c0 .75.75 1.5 1.5 1.5S16 19.75 16 19v-3h3c.75 0 1.5-.75 1.5-1.5S19.75 13 19 13h-3v-3c0-.75-.75-1.5-1.5-1.5'/%3E%3C/svg%3E")}}.maplibregl-ctrl button.maplibregl-ctrl-fullscreen .maplibregl-ctrl-icon{background-image:url("data:image/svg+xml;charset=utf-8,%3Csvg xmlns='http://www.w3.org/2000/svg' width='29' height='29' fill='%23333' viewBox='0 0 29 29'%3E%3Cpath d='M24 16v5.5c0 1.75-.75 2.5-2.5 2.5H16v-1l3-1.5-4-5.5 1-1 5.5 4 1.5-3zM6 16l1.5 3 5.5-4 1 1-4 5.5 3 1.5v1H7.5C5.75 24 5 23.25 5 21.5V16zm7-11v1l-3 1.5 4 5.5-1 1-5.5-4L6 13H5V7.5C5 5.75 5.75 5 7.5 5zm11 2.5c0-1.75-.75-2.5-2.5-2.5H16v1l3 1.5-4 5.5 1 1 5.5-4 1.5 3h1z'/%3E%3C/svg%3E")}.maplibregl-ctrl button.maplibregl-ctrl-shrink .maplibregl-ctrl-icon{background-image:url("data:image/svg+xml;charset=utf-8,%3Csvg xmlns='http://www.w3.org/2000/svg' width='29' height='29' viewBox='0 0 29 29'%3E%3Cpath d='M18.5 16c-1.75 0-2.5.75-2.5 2.5V24h1l1.5-3 5.5 4 1-1-4-5.5 3-1.5v-1zM13 18.5c0-1.75-.75-2.5-2.5-2.5H5v1l3 1.5L4 24l1 1 5.5-4 1.5 3h1zm3-8c0 1.75.75 2.5 2.5 2.5H24v-1l-3-1.5L25 5l-1-1-5.5 4L17 5h-1zM10.5 13c1.75 0 2.5-.75 2.5-2.5V5h-1l-1.5 3L5 4 4 5l4 5.5L5 12v1z'/%3E%3C/svg%3E")}@media (forced-colors:active){.maplibregl-ctrl button.maplibregl-ctrl-fullscreen .maplibregl-ctrl-icon{background-image:url("data:image/svg+xml;charset=utf-8,%3Csvg xmlns='http://www.w3.org/2000/svg' width='29' height='29' fill='%23fff' viewBox='0 0 29 29'%3E%3Cpath d='M24 16v5.5c0 1.75-.75 2.5-2.5 2.5H16v-1l3-1.5-4-5.5 1-1 5.5 4 1.5-3zM6 16l1.5 3 5.5-4 1 1-4 5.5 3 1.5v1H7.5C5.75 24 5 23.25 5 21.5V16zm7-11v1l-3 1.5 4 5.5-1 1-5.5-4L6 13H5V7.5C5 5.75 5.75 5 7.5 5zm11 2.5c0-1.75-.75-2.5-2.5-2.5H16v1l3 1.5-4 5.5 1 1 5.5-4 1.5 3h1z'/%3E%3C/svg%3E")}.maplibregl-ctrl button.maplibregl-ctrl-shrink .maplibregl-ctrl-icon{background-image:url("data:image/svg+xml;charset=utf-8,%3Csvg xmlns='http://www.w3.org/2000/svg' width='29' height='29' fill='%23fff' viewBox='0 0 29 29'%3E%3Cpath d='M18.5 16c-1.75 0-2.5.75-2.5 2.5V24h1l1.5-3 5.5 4 1-1-4-5.5 3-1.5v-1zM13 18.5c0-1.75-.75-2.5-2.5-2.5H5v1l3 1.5L4 24l1 1 5.5-4 1.5 3h1zm3-8c0 1.75.75 2.5 2.5 2.5H24v-1l-3-1.5L25 5l-1-1-5.5 4L17 5h-1zM10.5 13c1.75 0 2.5-.75 2.5-2.5V5h-1l-1.5 3L5 4 4 5l4 5.5L5 12v1z'/%3E%3C/svg%3E")}}@media (forced-colors:active) and (prefers-color-scheme:light){.maplibregl-ctrl button.maplibregl-ctrl-fullscreen .maplibregl-ctrl-icon{background-image:url("data:image/svg+xml;charset=utf-8,%3Csvg xmlns='http://www.w3.org/2000/svg' width='29' height='29' viewBox='0 0 29 29'%3E%3Cpath d='M24 16v5.5c0 1.75-.75 2.5-2.5 2.5H16v-1l3-1.5-4-5.5 1-1 5.5 4 1.5-3zM6 16l1.5 3 5.5-4 1 1-4 5.5 3 1.5v1H7.5C5.75 24 5 23.25 5 21.5V16zm7-11v1l-3 1.5 4 5.5-1 1-5.5-4L6 13H5V7.5C5 5.75 5.75 5 7.5 5zm11 2.5c0-1.75-.75-2.5-2.5-2.5H16v1l3 1.5-4 5.5 1 1 5.5-4 1.5 3h1z'/%3E%3C/svg%3E")}.maplibregl-ctrl button.maplibregl-ctrl-shrink .maplibregl-ctrl-icon{background-image:url("data:image/svg+xml;charset=utf-8,%3Csvg xmlns='http://www.w3.org/2000/svg' width='29' height='29' viewBox='0 0 29 29'%3E%3Cpath d='M18.5 16c-1.75 0-2.5.75-2.5 2.5V24h1l1.5-3 5.5 4 1-1-4-5.5 3-1.5v-1zM13 18.5c0-1.75-.75-2.5-2.5-2.5H5v1l3 1.5L4 24l1 1 5.5-4 1.5 3h1zm3-8c0 1.75.75 2.5 2.5 2.5H24v-1l-3-1.5L25 5l-1-1-5.5 4L17 5h-1zM10.5 13c1.75 0 2.5-.75 2.5-2.5V5h-1l-1.5 3L5 4 4 5l4 5.5L5 12v1z'/%3E%3C/svg%3E")}}.maplibregl-ctrl button.maplibregl-ctrl-compass .maplibregl-ctrl-icon{background-image:url("data:image/svg+xml;charset=utf-8,%3Csvg xmlns='http://www.w3.org/2000/svg' width='29' height='29' fill='%23333' viewBox='0 0 29 29'%3E%3Cpath d='m10.5 14 4-8 4 8z'/%3E%3Cpath fill='%23ccc' d='m10.5 16 4 8 4-8z'/%3E%3C/svg%3E")}@media (forced-colors:active){.maplibregl-ctrl button.maplibregl-ctrl-compass .maplibregl-ctrl-icon{background-image:url("data:image/svg+xml;charset=utf-8,%3Csvg xmlns='http://www.w3.org/2000/svg' width='29' height='29' fill='%23fff' viewBox='0 0 29 29'%3E%3Cpath d='m10.5 14 4-8 4 8z'/%3E%3Cpath fill='%23ccc' d='m10.5 16 4 8 4-8z'/%3E%3C/svg%3E")}}@media (forced-colors:active) and (prefers-color-scheme:light){.maplibregl-ctrl button.maplibregl-ctrl-compass .maplibregl-ctrl-icon{background-image:url("data:image/svg+xml;charset=utf-8,%3Csvg xmlns='http://www.w3.org/2000/svg' width='29' height='29' viewBox='0 0 29 29'%3E%3Cpath d='m10.5 14 4-8 4 8z'/%3E%3Cpath fill='%23ccc' d='m10.5 16 4 8 4-8z'/%3E%3C/svg%3E")}}.maplibregl-ctrl button.maplibregl-ctrl-terrain .maplibregl-ctrl-icon{background-image:url("data:image/svg+xml;charset=utf-8,%3Csvg xmlns='http://www.w3.org/2000/svg' width='22' height='22' fill='%23333' viewBox='0 0 22 22'%3E%3Cpath d='m1.754 13.406 4.453-4.851 3.09 3.09 3.281 3.277.969-.969-3.309-3.312 3.844-4.121 6.148 6.886h1.082v-.855l-7.207-8.07-4.84 5.187L6.169 6.57l-5.48 5.965v.871ZM.688 16.844h20.625v1.375H.688Zm0 0'/%3E%3C/svg%3E")}.maplibregl-ctrl button.maplibregl-ctrl-terrain-enabled .maplibregl-ctrl-icon{background-image:url("data:image/svg+xml;charset=utf-8,%3Csvg xmlns='http://www.w3.org/2000/svg' width='22' height='22' fill='%2333b5e5' viewBox='0 0 22 22'%3E%3Cpath d='m1.754 13.406 4.453-4.851 3.09 3.09 3.281 3.277.969-.969-3.309-3.312 3.844-4.121 6.148 6.886h1.082v-.855l-7.207-8.07-4.84 5.187L6.169 6.57l-5.48 5.965v.871ZM.688 16.844h20.625v1.375H.688Zm0 0'/%3E%3C/svg%3E")}.maplibregl-ctrl button.maplibregl-ctrl-geolocate .maplibregl-ctrl-icon{background-image:url("data:image/svg+xml;charset=utf-8,%3Csvg xmlns='http://www.w3.org/2000/svg' width='29' height='29' fill='%23333' viewBox='0 0 20 20'%3E%3Cpath d='M10 4C9 4 9 5 9 5v.1A5 5 0 0 0 5.1 9H5s-1 0-1 1 1 1 1 1h.1A5 5 0 0 0 9 14.9v.1s0 1 1 1 1-1 1-1v-.1a5 5 0 0 0 3.9-3.9h.1s1 0 1-1-1-1-1-1h-.1A5 5 0 0 0 11 5.1V5s0-1-1-1m0 2.5a3.5 3.5 0 1 1 0 7 3.5 3.5 0 1 1 0-7'/%3E%3Ccircle cx='10' cy='10' r='2'/%3E%3C/svg%3E")}.maplibregl-ctrl button.maplibregl-ctrl-geolocate:disabled .maplibregl-ctrl-icon{background-image:url("data:image/svg+xml;charset=utf-8,%3Csvg xmlns='http://www.w3.org/2000/svg' width='29' height='29' fill='%23aaa' viewBox='0 0 20 20'%3E%3Cpath d='M10 4C9 4 9 5 9 5v.1A5 5 0 0 0 5.1 9H5s-1 0-1 1 1 1 1 1h.1A5 5 0 0 0 9 14.9v.1s0 1 1 1 1-1 1-1v-.1a5 5 0 0 0 3.9-3.9h.1s1 0 1-1-1-1-1-1h-.1A5 5 0 0 0 11 5.1V5s0-1-1-1m0 2.5a3.5 3.5 0 1 1 0 7 3.5 3.5 0 1 1 0-7'/%3E%3Ccircle cx='10' cy='10' r='2'/%3E%3Cpath fill='red' d='m14 5 1 1-9 9-1-1z'/%3E%3C/svg%3E")}.maplibregl-ctrl button.maplibregl-ctrl-geolocate.maplibregl-ctrl-geolocate-active .maplibregl-ctrl-icon{background-image:url("data:image/svg+xml;charset=utf-8,%3Csvg xmlns='http://www.w3.org/2000/svg' width='29' height='29' fill='%2333b5e5' viewBox='0 0 20 20'%3E%3Cpath d='M10 4C9 4 9 5 9 5v.1A5 5 0 0 0 5.1 9H5s-1 0-1 1 1 1 1 1h.1A5 5 0 0 0 9 14.9v.1s0 1 1 1 1-1 1-1v-.1a5 5 0 0 0 3.9-3.9h.1s1 0 1-1-1-1-1-1h-.1A5 5 0 0 0 11 5.1V5s0-1-1-1m0 2.5a3.5 3.5 0 1 1 0 7 3.5 3.5 0 1 1 0-7'/%3E%3Ccircle cx='10' cy='10' r='2'/%3E%3C/svg%3E")}.maplibregl-ctrl button.maplibregl-ctrl-geolocate.maplibregl-ctrl-geolocate-active-error .maplibregl-ctrl-icon{background-image:url("data:image/svg+xml;charset=utf-8,%3Csvg xmlns='http://www.w3.org/2000/svg' width='29' height='29' fill='%23e58978' viewBox='0 0 20 20'%3E%3Cpath d='M10 4C9 4 9 5 9 5v.1A5 5 0 0 0 5.1 9H5s-1 0-1 1 1 1 1 1h.1A5 5 0 0 0 9 14.9v.1s0 1 1 1 1-1 1-1v-.1a5 5 0 0 0 3.9-3.9h.1s1 0 1-1-1-1-1-1h-.1A5 5 0 0 0 11 5.1V5s0-1-1-1m0 2.5a3.5 3.5 0 1 1 0 7 3.5 3.5 0 1 1 0-7'/%3E%3Ccircle cx='10' cy='10' r='2'/%3E%3C/svg%3E")}.maplibregl-ctrl button.maplibregl-ctrl-geolocate.maplibregl-ctrl-geolocate-background .maplibregl-ctrl-icon{background-image:url("data:image/svg+xml;charset=utf-8,%3Csvg xmlns='http://www.w3.org/2000/svg' width='29' height='29' fill='%2333b5e5' viewBox='0 0 20 20'%3E%3Cpath d='M10 4C9 4 9 5 9 5v.1A5 5 0 0 0 5.1 9H5s-1 0-1 1 1 1 1 1h.1A5 5 0 0 0 9 14.9v.1s0 1 1 1 1-1 1-1v-.1a5 5 0 0 0 3.9-3.9h.1s1 0 1-1-1-1-1-1h-.1A5 5 0 0 0 11 5.1V5s0-1-1-1m0 2.5a3.5 3.5 0 1 1 0 7 3.5 3.5 0 1 1 0-7'/%3E%3C/svg%3E")}.maplibregl-ctrl button.maplibregl-ctrl-geolocate.maplibregl-ctrl-geolocate-background-error .maplibregl-ctrl-icon{background-image:url("data:image/svg+xml;charset=utf-8,%3Csvg xmlns='http://www.w3.org/2000/svg' width='29' height='29' fill='%23e54e33' viewBox='0 0 20 20'%3E%3Cpath d='M10 4C9 4 9 5 9 5v.1A5 5 0 0 0 5.1 9H5s-1 0-1 1 1 1 1 1h.1A5 5 0 0 0 9 14.9v.1s0 1 1 1 1-1 1-1v-.1a5 5 0 0 0 3.9-3.9h.1s1 0 1-1-1-1-1-1h-.1A5 5 0 0 0 11 5.1V5s0-1-1-1m0 2.5a3.5 3.5 0 1 1 0 7 3.5 3.5 0 1 1 0-7'/%3E%3C/svg%3E")}.maplibregl-ctrl button.maplibregl-ctrl-geolocate.maplibregl-ctrl-geolocate-waiting .maplibregl-ctrl-icon{animation:maplibregl-spin 2s linear infinite}@media (forced-colors:active){.maplibregl-ctrl button.maplibregl-ctrl-geolocate .maplibregl-ctrl-icon{background-image:url("data:image/svg+xml;charset=utf-8,%3Csvg xmlns='http://www.w3.org/2000/svg' width='29' height='29' fill='%23fff' viewBox='0 0 20 20'%3E%3Cpath d='M10 4C9 4 9 5 9 5v.1A5 5 0 0 0 5.1 9H5s-1 0-1 1 1 1 1 1h.1A5 5 0 0 0 9 14.9v.1s0 1 1 1 1-1 1-1v-.1a5 5 0 0 0 3.9-3.9h.1s1 0 1-1-1-1-1-1h-.1A5 5 0 0 0 11 5.1V5s0-1-1-1m0 2.5a3.5 3.5 0 1 1 0 7 3.5 3.5 0 1 1 0-7'/%3E%3Ccircle cx='10' cy='10' r='2'/%3E%3C/svg%3E")}.maplibregl-ctrl button.maplibregl-ctrl-geolocate:disabled .maplibregl-ctrl-icon{background-image:url("data:image/svg+xml;charset=utf-8,%3Csvg xmlns='http://www.w3.org/2000/svg' width='29' height='29' fill='%23999' viewBox='0 0 20 20'%3E%3Cpath d='M10 4C9 4 9 5 9 5v.1A5 5 0 0 0 5.1 9H5s-1 0-1 1 1 1 1 1h.1A5 5 0 0 0 9 14.9v.1s0 1 1 1 1-1 1-1v-.1a5 5 0 0 0 3.9-3.9h.1s1 0 1-1-1-1-1-1h-.1A5 5 0 0 0 11 5.1V5s0-1-1-1m0 2.5a3.5 3.5 0 1 1 0 7 3.5 3.5 0 1 1 0-7'/%3E%3Ccircle cx='10' cy='10' r='2'/%3E%3Cpath fill='red' d='m14 5 1 1-9 9-1-1z'/%3E%3C/svg%3E")}.maplibregl-ctrl button.maplibregl-ctrl-geolocate.maplibregl-ctrl-geolocate-active .maplibregl-ctrl-icon{background-image:url("data:image/svg+xml;charset=utf-8,%3Csvg xmlns='http://www.w3.org/2000/svg' width='29' height='29' fill='%2333b5e5' viewBox='0 0 20 20'%3E%3Cpath d='M10 4C9 4 9 5 9 5v.1A5 5 0 0 0 5.1 9H5s-1 0-1 1 1 1 1 1h.1A5 5 0 0 0 9 14.9v.1s0 1 1 1 1-1 1-1v-.1a5 5 0 0 0 3.9-3.9h.1s1 0 1-1-1-1-1-1h-.1A5 5 0 0 0 11 5.1V5s0-1-1-1m0 2.5a3.5 3.5 0 1 1 0 7 3.5 3.5 0 1 1 0-7'/%3E%3Ccircle cx='10' cy='10' r='2'/%3E%3C/svg%3E")}.maplibregl-ctrl button.maplibregl-ctrl-geolocate.maplibregl-ctrl-geolocate-active-error .maplibregl-ctrl-icon{background-image:url("data:image/svg+xml;charset=utf-8,%3Csvg xmlns='http://www.w3.org/2000/svg' width='29' height='29' fill='%23e58978' viewBox='0 0 20 20'%3E%3Cpath d='M10 4C9 4 9 5 9 5v.1A5 5 0 0 0 5.1 9H5s-1 0-1 1 1 1 1 1h.1A5 5 0 0 0 9 14.9v.1s0 1 1 1 1-1 1-1v-.1a5 5 0 0 0 3.9-3.9h.1s1 0 1-1-1-1-1-1h-.1A5 5 0 0 0 11 5.1V5s0-1-1-1m0 2.5a3.5 3.5 0 1 1 0 7 3.5 3.5 0 1 1 0-7'/%3E%3Ccircle cx='10' cy='10' r='2'/%3E%3C/svg%3E")}.maplibregl-ctrl button.maplibregl-ctrl-geolocate.maplibregl-ctrl-geolocate-background .maplibregl-ctrl-icon{background-image:url("data:image/svg+xml;charset=utf-8,%3Csvg xmlns='http://www.w3.org/2000/svg' width='29' height='29' fill='%2333b5e5' viewBox='0 0 20 20'%3E%3Cpath d='M10 4C9 4 9 5 9 5v.1A5 5 0 0 0 5.1 9H5s-1 0-1 1 1 1 1 1h.1A5 5 0 0 0 9 14.9v.1s0 1 1 1 1-1 1-1v-.1a5 5 0 0 0 3.9-3.9h.1s1 0 1-1-1-1-1-1h-.1A5 5 0 0 0 11 5.1V5s0-1-1-1m0 2.5a3.5 3.5 0 1 1 0 7 3.5 3.5 0 1 1 0-7'/%3E%3C/svg%3E")}.maplibregl-ctrl button.maplibregl-ctrl-geolocate.maplibregl-ctrl-geolocate-background-error .maplibregl-ctrl-icon{background-image:url("data:image/svg+xml;charset=utf-8,%3Csvg xmlns='http://www.w3.org/2000/svg' width='29' height='29' fill='%23e54e33' viewBox='0 0 20 20'%3E%3Cpath d='M10 4C9 4 9 5 9 5v.1A5 5 0 0 0 5.1 9H5s-1 0-1 1 1 1 1 1h.1A5 5 0 0 0 9 14.9v.1s0 1 1 1 1-1 1-1v-.1a5 5 0 0 0 3.9-3.9h.1s1 0 1-1-1-1-1-1h-.1A5 5 0 0 0 11 5.1V5s0-1-1-1m0 2.5a3.5 3.5 0 1 1 0 7 3.5 3.5 0 1 1 0-7'/%3E%3C/svg%3E")}}@media (forced-colors:active) and (prefers-color-scheme:light){.maplibregl-ctrl button.maplibregl-ctrl-geolocate .maplibregl-ctrl-icon{background-image:url("data:image/svg+xml;charset=utf-8,%3Csvg xmlns='http://www.w3.org/2000/svg' width='29' height='29' viewBox='0 0 20 20'%3E%3Cpath d='M10 4C9 4 9 5 9 5v.1A5 5 0 0 0 5.1 9H5s-1 0-1 1 1 1 1 1h.1A5 5 0 0 0 9 14.9v.1s0 1 1 1 1-1 1-1v-.1a5 5 0 0 0 3.9-3.9h.1s1 0 1-1-1-1-1-1h-.1A5 5 0 0 0 11 5.1V5s0-1-1-1m0 2.5a3.5 3.5 0 1 1 0 7 3.5 3.5 0 1 1 0-7'/%3E%3Ccircle cx='10' cy='10' r='2'/%3E%3C/svg%3E")}.maplibregl-ctrl button.maplibregl-ctrl-geolocate:disabled .maplibregl-ctrl-icon{background-image:url("data:image/svg+xml;charset=utf-8,%3Csvg xmlns='http://www.w3.org/2000/svg' width='29' height='29' fill='%23666' viewBox='0 0 20 20'%3E%3Cpath d='M10 4C9 4 9 5 9 5v.1A5 5 0 0 0 5.1 9H5s-1 0-1 1 1 1 1 1h.1A5 5 0 0 0 9 14.9v.1s0 1 1 1 1-1 1-1v-.1a5 5 0 0 0 3.9-3.9h.1s1 0 1-1-1-1-1-1h-.1A5 5 0 0 0 11 5.1V5s0-1-1-1m0 2.5a3.5 3.5 0 1 1 0 7 3.5 3.5 0 1 1 0-7'/%3E%3Ccircle cx='10' cy='10' r='2'/%3E%3Cpath fill='red' d='m14 5 1 1-9 9-1-1z'/%3E%3C/svg%3E")}}@keyframes maplibregl-spin{0%{transform:rotate(0deg)}to{transform:rotate(1turn)}}a.maplibregl-ctrl-logo{background-image:url("data:image/svg+xml;charset=utf-8,%3Csvg xmlns='http://www.w3.org/2000/svg' width='88' height='23' fill='none'%3E%3Cpath fill='%23000' fill-opacity='.4' fill-rule='evenodd' d='M17.408 16.796h-1.827l2.501-12.095h.198l3.324 6.533.988 2.19.988-2.19 3.258-6.533h.181l2.6 12.095h-1.81l-1.218-5.644-.362-1.71-.658 1.71-2.929 5.644h-.098l-2.914-5.644-.757-1.71-.345 1.71zm1.958-3.42-.726 3.663a1.255 1.255 0 0 1-1.232 1.011h-1.827a1.255 1.255 0 0 1-1.229-1.509l2.501-12.095a1.255 1.255 0 0 1 1.23-1.001h.197a1.25 1.25 0 0 1 1.12.685l3.19 6.273 3.125-6.263a1.25 1.25 0 0 1 1.123-.695h.181a1.255 1.255 0 0 1 1.227.991l1.443 6.71a5 5 0 0 1 .314-.787l.009-.016a4.6 4.6 0 0 1 1.777-1.887c.782-.46 1.668-.667 2.611-.667a4.6 4.6 0 0 1 1.7.32l.306.134c.21-.16.474-.256.759-.256h1.694a1.255 1.255 0 0 1 1.212.925 1.255 1.255 0 0 1 1.212-.925h1.711c.284 0 .545.094.755.252.613-.3 1.312-.45 2.075-.45 1.356 0 2.557.445 3.482 1.4q.47.48.763 1.064V4.701a1.255 1.255 0 0 1 1.255-1.255h1.86A1.255 1.255 0 0 1 54.44 4.7v9.194h2.217c.19 0 .37.043.532.118v-4.77c0-.356.147-.678.385-.906a2.42 2.42 0 0 1-.682-1.71c0-.665.267-1.253.735-1.7a2.45 2.45 0 0 1 1.722-.674 2.43 2.43 0 0 1 1.705.675q.318.302.504.683V4.7a1.255 1.255 0 0 1 1.255-1.255h1.744A1.255 1.255 0 0 1 65.812 4.7v3.335a4.8 4.8 0 0 1 1.526-.246c.938 0 1.817.214 2.59.69a4.47 4.47 0 0 1 1.67 1.743v-.98a1.255 1.255 0 0 1 1.256-1.256h1.777c.233 0 .451.064.639.174a3.4 3.4 0 0 1 1.567-.372c.346 0 .861.02 1.285.232a1.25 1.25 0 0 1 .689 1.004 4.7 4.7 0 0 1 .853-.588c.795-.44 1.675-.647 2.61-.647 1.385 0 2.65.39 3.525 1.396.836.938 1.168 2.173 1.168 3.528q-.001.515-.056 1.051a1.255 1.255 0 0 1-.947 1.09l.408.952a1.255 1.255 0 0 1-.477 1.552c-.418.268-.92.463-1.458.612-.613.171-1.304.244-2.049.244-1.06 0-2.043-.207-2.886-.698l-.015-.008c-.798-.48-1.419-1.135-1.818-1.963l-.004-.008a5.8 5.8 0 0 1-.548-2.512q0-.429.053-.843a1.3 1.3 0 0 1-.333-.086l-.166-.004c-.223 0-.426.062-.643.228-.03.024-.142.139-.142.59v3.883a1.255 1.255 0 0 1-1.256 1.256h-1.777a1.255 1.255 0 0 1-1.256-1.256V15.69l-.032.057a4.8 4.8 0 0 1-1.86 1.833 5.04 5.04 0 0 1-2.484.634 4.5 4.5 0 0 1-1.935-.424 1.25 1.25 0 0 1-.764.258h-1.71a1.255 1.255 0 0 1-1.256-1.255V7.687a2.4 2.4 0 0 1-.428.625c.253.23.412.561.412.93v7.553a1.255 1.255 0 0 1-1.256 1.255h-1.843a1.25 1.25 0 0 1-.894-.373c-.228.23-.544.373-.894.373H51.32a1.255 1.255 0 0 1-1.256-1.255v-1.251l-.061.117a4.7 4.7 0 0 1-1.782 1.884 4.77 4.77 0 0 1-2.485.67 5.6 5.6 0 0 1-1.485-.188l.009 2.764a1.255 1.255 0 0 1-1.255 1.259h-1.729a1.255 1.255 0 0 1-1.255-1.255v-3.537a1.255 1.255 0 0 1-1.167.793h-1.679a1.25 1.25 0 0 1-.77-.263 4.5 4.5 0 0 1-1.945.429c-.885 0-1.724-.21-2.495-.632l-.017-.01a5 5 0 0 1-1.081-.836 1.255 1.255 0 0 1-1.254 1.312h-1.81a1.255 1.255 0 0 1-1.228-.99l-.782-3.625-2.044 3.939a1.25 1.25 0 0 1-1.115.676h-.098a1.25 1.25 0 0 1-1.116-.68l-2.061-3.994zM35.92 16.63l.207-.114.223-.15q.493-.356.735-.785l.061-.118.033 1.332h1.678V9.242h-1.694l-.033 1.267q-.133-.329-.526-.658l-.032-.028a3.2 3.2 0 0 0-.668-.428l-.27-.12a3.3 3.3 0 0 0-1.235-.23q-1.136-.001-1.974.493a3.36 3.36 0 0 0-1.3 1.382q-.445.89-.444 2.074 0 1.2.51 2.107a3.8 3.8 0 0 0 1.382 1.381 3.9 3.9 0 0 0 1.893.477q.795 0 1.455-.33zm-2.789-5.38q-.576.675-.575 1.762 0 1.102.559 1.794.576.675 1.645.675a2.25 2.25 0 0 0 .934-.19 2.2 2.2 0 0 0 .468-.29l.178-.161a2.2 2.2 0 0 0 .397-.561q.244-.5.244-1.15v-.115q0-.708-.296-1.267l-.043-.077a2.2 2.2 0 0 0-.633-.709l-.13-.086-.047-.028a2.1 2.1 0 0 0-1.073-.285q-1.052 0-1.629.692zm2.316 2.706c.163-.17.28-.407.28-.83v-.114c0-.292-.06-.508-.15-.68a.96.96 0 0 0-.353-.389.85.85 0 0 0-.464-.127c-.4 0-.56.114-.664.239l-.01.012c-.148.174-.275.45-.275.945 0 .506.122.801.27.99.097.11.266.224.68.224.303 0 .504-.09.687-.269zm7.545 1.705a2.6 2.6 0 0 0 .331.423q.319.33.755.548l.173.074q.65.255 1.49.255 1.02 0 1.844-.493a3.45 3.45 0 0 0 1.316-1.4q.493-.904.493-2.089 0-1.909-.988-2.913-.988-1.02-2.584-1.02-.898 0-1.575.347a3 3 0 0 0-.415.262l-.199.166a3.4 3.4 0 0 0-.64.82V9.242h-1.712v11.553h1.729l-.017-5.134zm.53-1.138q.206.29.48.5l.155.11.053.034q.51.296 1.119.297 1.07 0 1.645-.675.577-.69.576-1.762 0-1.119-.576-1.777-.558-.675-1.645-.675-.435 0-.835.16a2 2 0 0 0-.284.136 2 2 0 0 0-.363.254 2.2 2.2 0 0 0-.46.569l-.082.162a2.6 2.6 0 0 0-.213 1.072v.115q0 .707.296 1.267l.135.211zm.964-.818a1.1 1.1 0 0 0 .367.385.94.94 0 0 0 .476.118c.423 0 .59-.117.687-.23.159-.194.28-.478.28-.95 0-.53-.133-.8-.266-.952l-.021-.025c-.078-.094-.231-.221-.68-.221a1 1 0 0 0-.503.135l-.012.007a.86.86 0 0 0-.335.343c-.073.133-.132.324-.132.614v.115a1.4 1.4 0 0 0 .14.66zm15.7-6.222q.347-.346.346-.856a1.05 1.05 0 0 0-.345-.79 1.18 1.18 0 0 0-.84-.329q-.51 0-.855.33a1.05 1.05 0 0 0-.346.79q0 .51.346.855.345.346.856.346.51 0 .839-.346zm4.337 9.314.033-1.332q.191.403.59.747l.098.081a4 4 0 0 0 .316.224l.223.122a3.2 3.2 0 0 0 1.44.322 3.8 3.8 0 0 0 1.875-.477 3.5 3.5 0 0 0 1.382-1.366q.527-.89.526-2.09 0-1.184-.444-2.073a3.24 3.24 0 0 0-1.283-1.399q-.823-.51-1.942-.51a3.5 3.5 0 0 0-1.527.344l-.086.043-.165.09a3 3 0 0 0-.33.214q-.432.315-.656.707a2 2 0 0 0-.099.198l.082-1.283V4.701h-1.744v12.095zm.473-2.509a2.5 2.5 0 0 0 .566.7q.117.098.245.18l.144.08a2.1 2.1 0 0 0 .975.232q1.07 0 1.645-.675.576-.69.576-1.778 0-1.102-.576-1.777-.56-.691-1.645-.692a2.2 2.2 0 0 0-1.015.235q-.22.113-.415.282l-.15.142a2.1 2.1 0 0 0-.42.594q-.223.479-.223 1.1v.115q0 .705.293 1.26zm2.616-.293c.157-.191.28-.479.28-.967 0-.51-.13-.79-.276-.961l-.021-.026c-.082-.1-.232-.225-.67-.225a.87.87 0 0 0-.681.279l-.012.011c-.154.155-.274.38-.274.807v.115c0 .285.057.499.144.669a1.1 1.1 0 0 0 .367.405c.137.082.28.123.455.123.423 0 .59-.118.686-.23zm8.266-3.013q.345-.13.724-.14l.069-.002q.493 0 .642.099l.247-1.794q-.196-.099-.717-.099a2.3 2.3 0 0 0-.545.063 2 2 0 0 0-.411.148 2.2 2.2 0 0 0-.4.249 2.5 2.5 0 0 0-.485.499 2.7 2.7 0 0 0-.32.581l-.05.137v-1.48h-1.778v7.553h1.777v-3.884q0-.546.159-.943a1.5 1.5 0 0 1 .466-.636 2.5 2.5 0 0 1 .399-.253 2 2 0 0 1 .224-.099zm9.784 2.656.05-.922q0-1.743-.856-2.698-.838-.97-2.584-.97-1.119-.001-2.007.493a3.46 3.46 0 0 0-1.4 1.382q-.493.906-.493 2.106 0 1.07.428 1.975.428.89 1.332 1.432.906.526 2.255.526.973 0 1.668-.185l.044-.012.135-.04q.613-.184.984-.421l-.542-1.267q-.3.162-.642.274l-.297.087q-.51.131-1.3.131-.954 0-1.497-.444a1.6 1.6 0 0 1-.192-.193q-.366-.44-.512-1.234l-.004-.021zm-5.427-1.256-.003.022h3.752v-.138q-.011-.727-.288-1.118a1 1 0 0 0-.156-.176q-.46-.428-1.316-.428-.986 0-1.494.604-.379.45-.494 1.234zm-27.053 2.77V4.7h-1.86v12.095h5.333V15.15zm7.103-5.908v7.553h-1.843V9.242h1.843z'/%3E%3Cpath fill='%23fff' d='m19.63 11.151-.757-1.71-.345 1.71-1.12 5.644h-1.827L18.083 4.7h.197l3.325 6.533.988 2.19.988-2.19L26.839 4.7h.181l2.6 12.095h-1.81l-1.218-5.644-.362-1.71-.658 1.71-2.93 5.644h-.098l-2.913-5.644zm14.836 5.81q-1.02 0-1.893-.478a3.8 3.8 0 0 1-1.381-1.382q-.51-.906-.51-2.106 0-1.185.444-2.074a3.36 3.36 0 0 1 1.3-1.382q.839-.494 1.974-.494a3.3 3.3 0 0 1 1.234.231 3.3 3.3 0 0 1 .97.575q.396.33.527.659l.033-1.267h1.694v7.553H37.18l-.033-1.332q-.279.593-1.02 1.053a3.17 3.17 0 0 1-1.662.444zm.296-1.482q.938 0 1.58-.642.642-.66.642-1.711v-.115q0-.708-.296-1.267a2.2 2.2 0 0 0-.807-.872 2.1 2.1 0 0 0-1.119-.313q-1.053 0-1.629.692-.575.675-.575 1.76 0 1.103.559 1.795.577.675 1.645.675zm6.521-6.237h1.711v1.4q.906-1.597 2.83-1.597 1.596 0 2.584 1.02.988 1.005.988 2.914 0 1.185-.493 2.09a3.46 3.46 0 0 1-1.316 1.399 3.5 3.5 0 0 1-1.844.493q-.954 0-1.662-.329a2.67 2.67 0 0 1-1.086-.97l.017 5.134h-1.728zm4.048 6.22q1.07 0 1.645-.674.577-.69.576-1.762 0-1.119-.576-1.777-.558-.675-1.645-.675-.592 0-1.12.296-.51.28-.822.823-.296.527-.296 1.234v.115q0 .708.296 1.267.313.543.823.855.51.296 1.119.297z'/%3E%3Cpath fill='%23e1e3e9' d='M51.325 4.7h1.86v10.45h3.473v1.646h-5.333zm7.12 4.542h1.843v7.553h-1.843zm.905-1.415a1.16 1.16 0 0 1-.856-.346 1.17 1.17 0 0 1-.346-.856 1.05 1.05 0 0 1 .346-.79q.346-.329.856-.329.494 0 .839.33a1.05 1.05 0 0 1 .345.79 1.16 1.16 0 0 1-.345.855q-.33.346-.84.346zm7.875 9.133a3.17 3.17 0 0 1-1.662-.444q-.723-.46-1.004-1.053l-.033 1.332h-1.71V4.701h1.743v4.657l-.082 1.283q.279-.658 1.086-1.119a3.5 3.5 0 0 1 1.778-.477q1.119 0 1.942.51a3.24 3.24 0 0 1 1.283 1.4q.445.888.444 2.072 0 1.201-.526 2.09a3.5 3.5 0 0 1-1.382 1.366 3.8 3.8 0 0 1-1.876.477zm-.296-1.481q1.069 0 1.645-.675.577-.69.577-1.778 0-1.102-.577-1.776-.56-.691-1.645-.692a2.12 2.12 0 0 0-1.58.659q-.642.641-.642 1.694v.115q0 .71.296 1.267a2.4 2.4 0 0 0 .807.872 2.1 2.1 0 0 0 1.119.313zm5.927-6.237h1.777v1.481q.263-.757.856-1.217a2.14 2.14 0 0 1 1.349-.46q.527 0 .724.098l-.247 1.794q-.149-.099-.642-.099-.774 0-1.416.494-.626.493-.626 1.58v3.883h-1.777V9.242zm9.534 7.718q-1.35 0-2.255-.526-.904-.543-1.332-1.432a4.6 4.6 0 0 1-.428-1.975q0-1.2.493-2.106a3.46 3.46 0 0 1 1.4-1.382q.889-.495 2.007-.494 1.744 0 2.584.97.855.956.856 2.7 0 .444-.05.92h-5.43q.18 1.005.708 1.45.542.443 1.497.443.79 0 1.3-.131a4 4 0 0 0 .938-.362l.542 1.267q-.411.263-1.119.46-.708.198-1.711.197zm1.596-4.558q.016-1.02-.444-1.432-.46-.428-1.316-.428-1.728 0-1.991 1.86z'/%3E%3Cpath d='M5.074 15.948a.484.657 0 0 0-.486.659v1.84a.484.657 0 0 0 .486.659h4.101a.484.657 0 0 0 .486-.659v-1.84a.484.657 0 0 0-.486-.659zm3.56 1.16H5.617v.838h3.017z' style='fill:%23fff;fill-rule:evenodd;stroke-width:1.03600001'/%3E%3Cg style='stroke-width:1.12603545'%3E%3Cpath d='M-9.408-1.416c-3.833-.025-7.056 2.912-7.08 6.615-.02 3.08 1.653 4.832 3.107 6.268.903.892 1.721 1.74 2.32 2.902l-.525-.004c-.543-.003-.992.304-1.24.639a1.87 1.87 0 0 0-.362 1.121l-.011 1.877c-.003.402.104.787.347 1.125.244.338.688.653 1.23.656l4.142.028c.542.003.99-.306 1.238-.641a1.87 1.87 0 0 0 .363-1.121l.012-1.875a1.87 1.87 0 0 0-.348-1.127c-.243-.338-.688-.653-1.23-.656l-.518-.004c.597-1.145 1.425-1.983 2.348-2.87 1.473-1.414 3.18-3.149 3.2-6.226-.016-3.59-2.923-6.684-6.993-6.707m-.006 1.1v.002c3.274.02 5.92 2.532 5.9 5.6-.017 2.706-1.39 4.026-2.863 5.44-1.034.994-2.118 2.033-2.814 3.633-.018.041-.052.055-.075.065q-.013.004-.02.01a.34.34 0 0 1-.226.084.34.34 0 0 1-.224-.086l-.092-.077c-.699-1.615-1.768-2.669-2.781-3.67-1.454-1.435-2.797-2.762-2.78-5.478.02-3.067 2.7-5.545 5.975-5.523m-.02 2.826c-1.62-.01-2.944 1.315-2.955 2.96-.01 1.646 1.295 2.988 2.916 2.999h.002c1.621.01 2.943-1.316 2.953-2.961.011-1.646-1.294-2.988-2.916-2.998m-.005 1.1c1.017.006 1.829.83 1.822 1.89s-.83 1.874-1.848 1.867c-1.018-.006-1.829-.83-1.822-1.89s.83-1.874 1.848-1.868m-2.155 11.857 4.14.025c.271.002.49.305.487.676l-.013 1.875c-.003.37-.224.67-.495.668l-4.14-.025c-.27-.002-.487-.306-.485-.676l.012-1.875c.003-.37.224-.67.494-.668' style='color:%23000;font-style:normal;font-variant:normal;font-weight:400;font-stretch:normal;font-size:medium;line-height:normal;font-family:sans-serif;font-variant-ligatures:normal;font-variant-position:normal;font-variant-caps:normal;font-variant-numeric:normal;font-variant-alternates:normal;font-feature-settings:normal;text-indent:0;text-align:start;text-decoration:none;text-decoration-line:none;text-decoration-style:solid;text-decoration-color:%23000;letter-spacing:normal;word-spacing:normal;text-transform:none;writing-mode:lr-tb;direction:ltr;text-orientation:mixed;dominant-baseline:auto;baseline-shift:baseline;text-anchor:start;white-space:normal;shape-padding:0;clip-rule:evenodd;display:inline;overflow:visible;visibility:visible;opacity:1;isolation:auto;mix-blend-mode:normal;color-interpolation:sRGB;color-interpolation-filters:linearRGB;solid-color:%23000;solid-opacity:1;vector-effect:none;fill:%23000;fill-opacity:.4;fill-rule:evenodd;stroke:none;stroke-width:2.47727823;stroke-linecap:butt;stroke-linejoin:miter;stroke-miterlimit:4;stroke-dasharray:none;stroke-dashoffset:0;stroke-opacity:1;color-rendering:auto;image-rendering:auto;shape-rendering:auto;text-rendering:auto' transform='translate(15.553 2.85)scale(.88807)'/%3E%3Cpath d='M-9.415-.316C-12.69-.338-15.37 2.14-15.39 5.207c-.017 2.716 1.326 4.041 2.78 5.477 1.013 1 2.081 2.055 2.78 3.67l.092.076a.34.34 0 0 0 .225.086.34.34 0 0 0 .227-.083l.019-.01c.022-.009.057-.024.074-.064.697-1.6 1.78-2.64 2.814-3.634 1.473-1.414 2.847-2.733 2.864-5.44.02-3.067-2.627-5.58-5.901-5.601m-.057 8.784c1.621.011 2.944-1.315 2.955-2.96.01-1.646-1.295-2.988-2.916-2.999-1.622-.01-2.945 1.315-2.955 2.96s1.295 2.989 2.916 3' style='clip-rule:evenodd;fill:%23e1e3e9;fill-opacity:1;fill-rule:evenodd;stroke:none;stroke-width:2.47727823;stroke-miterlimit:4;stroke-dasharray:none;stroke-opacity:.4' transform='translate(15.553 2.85)scale(.88807)'/%3E%3Cpath d='M-11.594 15.465c-.27-.002-.492.297-.494.668l-.012 1.876c-.003.371.214.673.485.675l4.14.027c.271.002.492-.298.495-.668l.012-1.877c.003-.37-.215-.672-.485-.674z' style='clip-rule:evenodd;fill:%23fff;fill-opacity:1;fill-rule:evenodd;stroke:none;stroke-width:2.47727823;stroke-miterlimit:4;stroke-dasharray:none;stroke-opacity:.4' transform='translate(15.553 2.85)scale(.88807)'/%3E%3C/g%3E%3C/svg%3E");background-repeat:no-repeat;cursor:pointer;display:block;height:23px;margin:0 0 -4px -4px;overflow:hidden;width:88px}a.maplibregl-ctrl-logo.maplibregl-compact{width:14px}@media (forced-colors:active){a.maplibregl-ctrl-logo{background-color:transparent;background-image:url("data:image/svg+xml;charset=utf-8,%3Csvg xmlns='http://www.w3.org/2000/svg' width='88' height='23' fill='none'%3E%3Cpath fill='%23000' fill-opacity='.4' fill-rule='evenodd' d='M17.408 16.796h-1.827l2.501-12.095h.198l3.324 6.533.988 2.19.988-2.19 3.258-6.533h.181l2.6 12.095h-1.81l-1.218-5.644-.362-1.71-.658 1.71-2.929 5.644h-.098l-2.914-5.644-.757-1.71-.345 1.71zm1.958-3.42-.726 3.663a1.255 1.255 0 0 1-1.232 1.011h-1.827a1.255 1.255 0 0 1-1.229-1.509l2.501-12.095a1.255 1.255 0 0 1 1.23-1.001h.197a1.25 1.25 0 0 1 1.12.685l3.19 6.273 3.125-6.263a1.25 1.25 0 0 1 1.123-.695h.181a1.255 1.255 0 0 1 1.227.991l1.443 6.71a5 5 0 0 1 .314-.787l.009-.016a4.6 4.6 0 0 1 1.777-1.887c.782-.46 1.668-.667 2.611-.667a4.6 4.6 0 0 1 1.7.32l.306.134c.21-.16.474-.256.759-.256h1.694a1.255 1.255 0 0 1 1.212.925 1.255 1.255 0 0 1 1.212-.925h1.711c.284 0 .545.094.755.252.613-.3 1.312-.45 2.075-.45 1.356 0 2.557.445 3.482 1.4q.47.48.763 1.064V4.701a1.255 1.255 0 0 1 1.255-1.255h1.86A1.255 1.255 0 0 1 54.44 4.7v9.194h2.217c.19 0 .37.043.532.118v-4.77c0-.356.147-.678.385-.906a2.42 2.42 0 0 1-.682-1.71c0-.665.267-1.253.735-1.7a2.45 2.45 0 0 1 1.722-.674 2.43 2.43 0 0 1 1.705.675q.318.302.504.683V4.7a1.255 1.255 0 0 1 1.255-1.255h1.744A1.255 1.255 0 0 1 65.812 4.7v3.335a4.8 4.8 0 0 1 1.526-.246c.938 0 1.817.214 2.59.69a4.47 4.47 0 0 1 1.67 1.743v-.98a1.255 1.255 0 0 1 1.256-1.256h1.777c.233 0 .451.064.639.174a3.4 3.4 0 0 1 1.567-.372c.346 0 .861.02 1.285.232a1.25 1.25 0 0 1 .689 1.004 4.7 4.7 0 0 1 .853-.588c.795-.44 1.675-.647 2.61-.647 1.385 0 2.65.39 3.525 1.396.836.938 1.168 2.173 1.168 3.528q-.001.515-.056 1.051a1.255 1.255 0 0 1-.947 1.09l.408.952a1.255 1.255 0 0 1-.477 1.552c-.418.268-.92.463-1.458.612-.613.171-1.304.244-2.049.244-1.06 0-2.043-.207-2.886-.698l-.015-.008c-.798-.48-1.419-1.135-1.818-1.963l-.004-.008a5.8 5.8 0 0 1-.548-2.512q0-.429.053-.843a1.3 1.3 0 0 1-.333-.086l-.166-.004c-.223 0-.426.062-.643.228-.03.024-.142.139-.142.59v3.883a1.255 1.255 0 0 1-1.256 1.256h-1.777a1.255 1.255 0 0 1-1.256-1.256V15.69l-.032.057a4.8 4.8 0 0 1-1.86 1.833 5.04 5.04 0 0 1-2.484.634 4.5 4.5 0 0 1-1.935-.424 1.25 1.25 0 0 1-.764.258h-1.71a1.255 1.255 0 0 1-1.256-1.255V7.687a2.4 2.4 0 0 1-.428.625c.253.23.412.561.412.93v7.553a1.255 1.255 0 0 1-1.256 1.255h-1.843a1.25 1.25 0 0 1-.894-.373c-.228.23-.544.373-.894.373H51.32a1.255 1.255 0 0 1-1.256-1.255v-1.251l-.061.117a4.7 4.7 0 0 1-1.782 1.884 4.77 4.77 0 0 1-2.485.67 5.6 5.6 0 0 1-1.485-.188l.009 2.764a1.255 1.255 0 0 1-1.255 1.259h-1.729a1.255 1.255 0 0 1-1.255-1.255v-3.537a1.255 1.255 0 0 1-1.167.793h-1.679a1.25 1.25 0 0 1-.77-.263 4.5 4.5 0 0 1-1.945.429c-.885 0-1.724-.21-2.495-.632l-.017-.01a5 5 0 0 1-1.081-.836 1.255 1.255 0 0 1-1.254 1.312h-1.81a1.255 1.255 0 0 1-1.228-.99l-.782-3.625-2.044 3.939a1.25 1.25 0 0 1-1.115.676h-.098a1.25 1.25 0 0 1-1.116-.68l-2.061-3.994zM35.92 16.63l.207-.114.223-.15q.493-.356.735-.785l.061-.118.033 1.332h1.678V9.242h-1.694l-.033 1.267q-.133-.329-.526-.658l-.032-.028a3.2 3.2 0 0 0-.668-.428l-.27-.12a3.3 3.3 0 0 0-1.235-.23q-1.136-.001-1.974.493a3.36 3.36 0 0 0-1.3 1.382q-.445.89-.444 2.074 0 1.2.51 2.107a3.8 3.8 0 0 0 1.382 1.381 3.9 3.9 0 0 0 1.893.477q.795 0 1.455-.33zm-2.789-5.38q-.576.675-.575 1.762 0 1.102.559 1.794.576.675 1.645.675a2.25 2.25 0 0 0 .934-.19 2.2 2.2 0 0 0 .468-.29l.178-.161a2.2 2.2 0 0 0 .397-.561q.244-.5.244-1.15v-.115q0-.708-.296-1.267l-.043-.077a2.2 2.2 0 0 0-.633-.709l-.13-.086-.047-.028a2.1 2.1 0 0 0-1.073-.285q-1.052 0-1.629.692zm2.316 2.706c.163-.17.28-.407.28-.83v-.114c0-.292-.06-.508-.15-.68a.96.96 0 0 0-.353-.389.85.85 0 0 0-.464-.127c-.4 0-.56.114-.664.239l-.01.012c-.148.174-.275.45-.275.945 0 .506.122.801.27.99.097.11.266.224.68.224.303 0 .504-.09.687-.269zm7.545 1.705a2.6 2.6 0 0 0 .331.423q.319.33.755.548l.173.074q.65.255 1.49.255 1.02 0 1.844-.493a3.45 3.45 0 0 0 1.316-1.4q.493-.904.493-2.089 0-1.909-.988-2.913-.988-1.02-2.584-1.02-.898 0-1.575.347a3 3 0 0 0-.415.262l-.199.166a3.4 3.4 0 0 0-.64.82V9.242h-1.712v11.553h1.729l-.017-5.134zm.53-1.138q.206.29.48.5l.155.11.053.034q.51.296 1.119.297 1.07 0 1.645-.675.577-.69.576-1.762 0-1.119-.576-1.777-.558-.675-1.645-.675-.435 0-.835.16a2 2 0 0 0-.284.136 2 2 0 0 0-.363.254 2.2 2.2 0 0 0-.46.569l-.082.162a2.6 2.6 0 0 0-.213 1.072v.115q0 .707.296 1.267l.135.211zm.964-.818a1.1 1.1 0 0 0 .367.385.94.94 0 0 0 .476.118c.423 0 .59-.117.687-.23.159-.194.28-.478.28-.95 0-.53-.133-.8-.266-.952l-.021-.025c-.078-.094-.231-.221-.68-.221a1 1 0 0 0-.503.135l-.012.007a.86.86 0 0 0-.335.343c-.073.133-.132.324-.132.614v.115a1.4 1.4 0 0 0 .14.66zm15.7-6.222q.347-.346.346-.856a1.05 1.05 0 0 0-.345-.79 1.18 1.18 0 0 0-.84-.329q-.51 0-.855.33a1.05 1.05 0 0 0-.346.79q0 .51.346.855.345.346.856.346.51 0 .839-.346zm4.337 9.314.033-1.332q.191.403.59.747l.098.081a4 4 0 0 0 .316.224l.223.122a3.2 3.2 0 0 0 1.44.322 3.8 3.8 0 0 0 1.875-.477 3.5 3.5 0 0 0 1.382-1.366q.527-.89.526-2.09 0-1.184-.444-2.073a3.24 3.24 0 0 0-1.283-1.399q-.823-.51-1.942-.51a3.5 3.5 0 0 0-1.527.344l-.086.043-.165.09a3 3 0 0 0-.33.214q-.432.315-.656.707a2 2 0 0 0-.099.198l.082-1.283V4.701h-1.744v12.095zm.473-2.509a2.5 2.5 0 0 0 .566.7q.117.098.245.18l.144.08a2.1 2.1 0 0 0 .975.232q1.07 0 1.645-.675.576-.69.576-1.778 0-1.102-.576-1.777-.56-.691-1.645-.692a2.2 2.2 0 0 0-1.015.235q-.22.113-.415.282l-.15.142a2.1 2.1 0 0 0-.42.594q-.223.479-.223 1.1v.115q0 .705.293 1.26zm2.616-.293c.157-.191.28-.479.28-.967 0-.51-.13-.79-.276-.961l-.021-.026c-.082-.1-.232-.225-.67-.225a.87.87 0 0 0-.681.279l-.012.011c-.154.155-.274.38-.274.807v.115c0 .285.057.499.144.669a1.1 1.1 0 0 0 .367.405c.137.082.28.123.455.123.423 0 .59-.118.686-.23zm8.266-3.013q.345-.13.724-.14l.069-.002q.493 0 .642.099l.247-1.794q-.196-.099-.717-.099a2.3 2.3 0 0 0-.545.063 2 2 0 0 0-.411.148 2.2 2.2 0 0 0-.4.249 2.5 2.5 0 0 0-.485.499 2.7 2.7 0 0 0-.32.581l-.05.137v-1.48h-1.778v7.553h1.777v-3.884q0-.546.159-.943a1.5 1.5 0 0 1 .466-.636 2.5 2.5 0 0 1 .399-.253 2 2 0 0 1 .224-.099zm9.784 2.656.05-.922q0-1.743-.856-2.698-.838-.97-2.584-.97-1.119-.001-2.007.493a3.46 3.46 0 0 0-1.4 1.382q-.493.906-.493 2.106 0 1.07.428 1.975.428.89 1.332 1.432.906.526 2.255.526.973 0 1.668-.185l.044-.012.135-.04q.613-.184.984-.421l-.542-1.267q-.3.162-.642.274l-.297.087q-.51.131-1.3.131-.954 0-1.497-.444a1.6 1.6 0 0 1-.192-.193q-.366-.44-.512-1.234l-.004-.021zm-5.427-1.256-.003.022h3.752v-.138q-.011-.727-.288-1.118a1 1 0 0 0-.156-.176q-.46-.428-1.316-.428-.986 0-1.494.604-.379.45-.494 1.234zm-27.053 2.77V4.7h-1.86v12.095h5.333V15.15zm7.103-5.908v7.553h-1.843V9.242h1.843z'/%3E%3Cpath fill='%23fff' d='m19.63 11.151-.757-1.71-.345 1.71-1.12 5.644h-1.827L18.083 4.7h.197l3.325 6.533.988 2.19.988-2.19L26.839 4.7h.181l2.6 12.095h-1.81l-1.218-5.644-.362-1.71-.658 1.71-2.93 5.644h-.098l-2.913-5.644zm14.836 5.81q-1.02 0-1.893-.478a3.8 3.8 0 0 1-1.381-1.382q-.51-.906-.51-2.106 0-1.185.444-2.074a3.36 3.36 0 0 1 1.3-1.382q.839-.494 1.974-.494a3.3 3.3 0 0 1 1.234.231 3.3 3.3 0 0 1 .97.575q.396.33.527.659l.033-1.267h1.694v7.553H37.18l-.033-1.332q-.279.593-1.02 1.053a3.17 3.17 0 0 1-1.662.444zm.296-1.482q.938 0 1.58-.642.642-.66.642-1.711v-.115q0-.708-.296-1.267a2.2 2.2 0 0 0-.807-.872 2.1 2.1 0 0 0-1.119-.313q-1.053 0-1.629.692-.575.675-.575 1.76 0 1.103.559 1.795.577.675 1.645.675zm6.521-6.237h1.711v1.4q.906-1.597 2.83-1.597 1.596 0 2.584 1.02.988 1.005.988 2.914 0 1.185-.493 2.09a3.46 3.46 0 0 1-1.316 1.399 3.5 3.5 0 0 1-1.844.493q-.954 0-1.662-.329a2.67 2.67 0 0 1-1.086-.97l.017 5.134h-1.728zm4.048 6.22q1.07 0 1.645-.674.577-.69.576-1.762 0-1.119-.576-1.777-.558-.675-1.645-.675-.592 0-1.12.296-.51.28-.822.823-.296.527-.296 1.234v.115q0 .708.296 1.267.313.543.823.855.51.296 1.119.297z'/%3E%3Cpath fill='%23e1e3e9' d='M51.325 4.7h1.86v10.45h3.473v1.646h-5.333zm7.12 4.542h1.843v7.553h-1.843zm.905-1.415a1.16 1.16 0 0 1-.856-.346 1.17 1.17 0 0 1-.346-.856 1.05 1.05 0 0 1 .346-.79q.346-.329.856-.329.494 0 .839.33a1.05 1.05 0 0 1 .345.79 1.16 1.16 0 0 1-.345.855q-.33.346-.84.346zm7.875 9.133a3.17 3.17 0 0 1-1.662-.444q-.723-.46-1.004-1.053l-.033 1.332h-1.71V4.701h1.743v4.657l-.082 1.283q.279-.658 1.086-1.119a3.5 3.5 0 0 1 1.778-.477q1.119 0 1.942.51a3.24 3.24 0 0 1 1.283 1.4q.445.888.444 2.072 0 1.201-.526 2.09a3.5 3.5 0 0 1-1.382 1.366 3.8 3.8 0 0 1-1.876.477zm-.296-1.481q1.069 0 1.645-.675.577-.69.577-1.778 0-1.102-.577-1.776-.56-.691-1.645-.692a2.12 2.12 0 0 0-1.58.659q-.642.641-.642 1.694v.115q0 .71.296 1.267a2.4 2.4 0 0 0 .807.872 2.1 2.1 0 0 0 1.119.313zm5.927-6.237h1.777v1.481q.263-.757.856-1.217a2.14 2.14 0 0 1 1.349-.46q.527 0 .724.098l-.247 1.794q-.149-.099-.642-.099-.774 0-1.416.494-.626.493-.626 1.58v3.883h-1.777V9.242zm9.534 7.718q-1.35 0-2.255-.526-.904-.543-1.332-1.432a4.6 4.6 0 0 1-.428-1.975q0-1.2.493-2.106a3.46 3.46 0 0 1 1.4-1.382q.889-.495 2.007-.494 1.744 0 2.584.97.855.956.856 2.7 0 .444-.05.92h-5.43q.18 1.005.708 1.45.542.443 1.497.443.79 0 1.3-.131a4 4 0 0 0 .938-.362l.542 1.267q-.411.263-1.119.46-.708.198-1.711.197zm1.596-4.558q.016-1.02-.444-1.432-.46-.428-1.316-.428-1.728 0-1.991 1.86z'/%3E%3Cpath d='M5.074 15.948a.484.657 0 0 0-.486.659v1.84a.484.657 0 0 0 .486.659h4.101a.484.657 0 0 0 .486-.659v-1.84a.484.657 0 0 0-.486-.659zm3.56 1.16H5.617v.838h3.017z' style='fill:%23fff;fill-rule:evenodd;stroke-width:1.03600001'/%3E%3Cg style='stroke-width:1.12603545'%3E%3Cpath d='M-9.408-1.416c-3.833-.025-7.056 2.912-7.08 6.615-.02 3.08 1.653 4.832 3.107 6.268.903.892 1.721 1.74 2.32 2.902l-.525-.004c-.543-.003-.992.304-1.24.639a1.87 1.87 0 0 0-.362 1.121l-.011 1.877c-.003.402.104.787.347 1.125.244.338.688.653 1.23.656l4.142.028c.542.003.99-.306 1.238-.641a1.87 1.87 0 0 0 .363-1.121l.012-1.875a1.87 1.87 0 0 0-.348-1.127c-.243-.338-.688-.653-1.23-.656l-.518-.004c.597-1.145 1.425-1.983 2.348-2.87 1.473-1.414 3.18-3.149 3.2-6.226-.016-3.59-2.923-6.684-6.993-6.707m-.006 1.1v.002c3.274.02 5.92 2.532 5.9 5.6-.017 2.706-1.39 4.026-2.863 5.44-1.034.994-2.118 2.033-2.814 3.633-.018.041-.052.055-.075.065q-.013.004-.02.01a.34.34 0 0 1-.226.084.34.34 0 0 1-.224-.086l-.092-.077c-.699-1.615-1.768-2.669-2.781-3.67-1.454-1.435-2.797-2.762-2.78-5.478.02-3.067 2.7-5.545 5.975-5.523m-.02 2.826c-1.62-.01-2.944 1.315-2.955 2.96-.01 1.646 1.295 2.988 2.916 2.999h.002c1.621.01 2.943-1.316 2.953-2.961.011-1.646-1.294-2.988-2.916-2.998m-.005 1.1c1.017.006 1.829.83 1.822 1.89s-.83 1.874-1.848 1.867c-1.018-.006-1.829-.83-1.822-1.89s.83-1.874 1.848-1.868m-2.155 11.857 4.14.025c.271.002.49.305.487.676l-.013 1.875c-.003.37-.224.67-.495.668l-4.14-.025c-.27-.002-.487-.306-.485-.676l.012-1.875c.003-.37.224-.67.494-.668' style='color:%23000;font-style:normal;font-variant:normal;font-weight:400;font-stretch:normal;font-size:medium;line-height:normal;font-family:sans-serif;font-variant-ligatures:normal;font-variant-position:normal;font-variant-caps:normal;font-variant-numeric:normal;font-variant-alternates:normal;font-feature-settings:normal;text-indent:0;text-align:start;text-decoration:none;text-decoration-line:none;text-decoration-style:solid;text-decoration-color:%23000;letter-spacing:normal;word-spacing:normal;text-transform:none;writing-mode:lr-tb;direction:ltr;text-orientation:mixed;dominant-baseline:auto;baseline-shift:baseline;text-anchor:start;white-space:normal;shape-padding:0;clip-rule:evenodd;display:inline;overflow:visible;visibility:visible;opacity:1;isolation:auto;mix-blend-mode:normal;color-interpolation:sRGB;color-interpolation-filters:linearRGB;solid-color:%23000;solid-opacity:1;vector-effect:none;fill:%23000;fill-opacity:.4;fill-rule:evenodd;stroke:none;stroke-width:2.47727823;stroke-linecap:butt;stroke-linejoin:miter;stroke-miterlimit:4;stroke-dasharray:none;stroke-dashoffset:0;stroke-opacity:1;color-rendering:auto;image-rendering:auto;shape-rendering:auto;text-rendering:auto' transform='translate(15.553 2.85)scale(.88807)'/%3E%3Cpath d='M-9.415-.316C-12.69-.338-15.37 2.14-15.39 5.207c-.017 2.716 1.326 4.041 2.78 5.477 1.013 1 2.081 2.055 2.78 3.67l.092.076a.34.34 0 0 0 .225.086.34.34 0 0 0 .227-.083l.019-.01c.022-.009.057-.024.074-.064.697-1.6 1.78-2.64 2.814-3.634 1.473-1.414 2.847-2.733 2.864-5.44.02-3.067-2.627-5.58-5.901-5.601m-.057 8.784c1.621.011 2.944-1.315 2.955-2.96.01-1.646-1.295-2.988-2.916-2.999-1.622-.01-2.945 1.315-2.955 2.96s1.295 2.989 2.916 3' style='clip-rule:evenodd;fill:%23e1e3e9;fill-opacity:1;fill-rule:evenodd;stroke:none;stroke-width:2.47727823;stroke-miterlimit:4;stroke-dasharray:none;stroke-opacity:.4' transform='translate(15.553 2.85)scale(.88807)'/%3E%3Cpath d='M-11.594 15.465c-.27-.002-.492.297-.494.668l-.012 1.876c-.003.371.214.673.485.675l4.14.027c.271.002.492-.298.495-.668l.012-1.877c.003-.37-.215-.672-.485-.674z' style='clip-rule:evenodd;fill:%23fff;fill-opacity:1;fill-rule:evenodd;stroke:none;stroke-width:2.47727823;stroke-miterlimit:4;stroke-dasharray:none;stroke-opacity:.4' transform='translate(15.553 2.85)scale(.88807)'/%3E%3C/g%3E%3C/svg%3E")}}@media (forced-colors:active) and (prefers-color-scheme:light){a.maplibregl-ctrl-logo{background-image:url("data:image/svg+xml;charset=utf-8,%3Csvg xmlns='http://www.w3.org/2000/svg' width='88' height='23' fill='none'%3E%3Cpath fill='%23000' fill-opacity='.4' fill-rule='evenodd' d='M17.408 16.796h-1.827l2.501-12.095h.198l3.324 6.533.988 2.19.988-2.19 3.258-6.533h.181l2.6 12.095h-1.81l-1.218-5.644-.362-1.71-.658 1.71-2.929 5.644h-.098l-2.914-5.644-.757-1.71-.345 1.71zm1.958-3.42-.726 3.663a1.255 1.255 0 0 1-1.232 1.011h-1.827a1.255 1.255 0 0 1-1.229-1.509l2.501-12.095a1.255 1.255 0 0 1 1.23-1.001h.197a1.25 1.25 0 0 1 1.12.685l3.19 6.273 3.125-6.263a1.25 1.25 0 0 1 1.123-.695h.181a1.255 1.255 0 0 1 1.227.991l1.443 6.71a5 5 0 0 1 .314-.787l.009-.016a4.6 4.6 0 0 1 1.777-1.887c.782-.46 1.668-.667 2.611-.667a4.6 4.6 0 0 1 1.7.32l.306.134c.21-.16.474-.256.759-.256h1.694a1.255 1.255 0 0 1 1.212.925 1.255 1.255 0 0 1 1.212-.925h1.711c.284 0 .545.094.755.252.613-.3 1.312-.45 2.075-.45 1.356 0 2.557.445 3.482 1.4q.47.48.763 1.064V4.701a1.255 1.255 0 0 1 1.255-1.255h1.86A1.255 1.255 0 0 1 54.44 4.7v9.194h2.217c.19 0 .37.043.532.118v-4.77c0-.356.147-.678.385-.906a2.42 2.42 0 0 1-.682-1.71c0-.665.267-1.253.735-1.7a2.45 2.45 0 0 1 1.722-.674 2.43 2.43 0 0 1 1.705.675q.318.302.504.683V4.7a1.255 1.255 0 0 1 1.255-1.255h1.744A1.255 1.255 0 0 1 65.812 4.7v3.335a4.8 4.8 0 0 1 1.526-.246c.938 0 1.817.214 2.59.69a4.47 4.47 0 0 1 1.67 1.743v-.98a1.255 1.255 0 0 1 1.256-1.256h1.777c.233 0 .451.064.639.174a3.4 3.4 0 0 1 1.567-.372c.346 0 .861.02 1.285.232a1.25 1.25 0 0 1 .689 1.004 4.7 4.7 0 0 1 .853-.588c.795-.44 1.675-.647 2.61-.647 1.385 0 2.65.39 3.525 1.396.836.938 1.168 2.173 1.168 3.528q-.001.515-.056 1.051a1.255 1.255 0 0 1-.947 1.09l.408.952a1.255 1.255 0 0 1-.477 1.552c-.418.268-.92.463-1.458.612-.613.171-1.304.244-2.049.244-1.06 0-2.043-.207-2.886-.698l-.015-.008c-.798-.48-1.419-1.135-1.818-1.963l-.004-.008a5.8 5.8 0 0 1-.548-2.512q0-.429.053-.843a1.3 1.3 0 0 1-.333-.086l-.166-.004c-.223 0-.426.062-.643.228-.03.024-.142.139-.142.59v3.883a1.255 1.255 0 0 1-1.256 1.256h-1.777a1.255 1.255 0 0 1-1.256-1.256V15.69l-.032.057a4.8 4.8 0 0 1-1.86 1.833 5.04 5.04 0 0 1-2.484.634 4.5 4.5 0 0 1-1.935-.424 1.25 1.25 0 0 1-.764.258h-1.71a1.255 1.255 0 0 1-1.256-1.255V7.687a2.4 2.4 0 0 1-.428.625c.253.23.412.561.412.93v7.553a1.255 1.255 0 0 1-1.256 1.255h-1.843a1.25 1.25 0 0 1-.894-.373c-.228.23-.544.373-.894.373H51.32a1.255 1.255 0 0 1-1.256-1.255v-1.251l-.061.117a4.7 4.7 0 0 1-1.782 1.884 4.77 4.77 0 0 1-2.485.67 5.6 5.6 0 0 1-1.485-.188l.009 2.764a1.255 1.255 0 0 1-1.255 1.259h-1.729a1.255 1.255 0 0 1-1.255-1.255v-3.537a1.255 1.255 0 0 1-1.167.793h-1.679a1.25 1.25 0 0 1-.77-.263 4.5 4.5 0 0 1-1.945.429c-.885 0-1.724-.21-2.495-.632l-.017-.01a5 5 0 0 1-1.081-.836 1.255 1.255 0 0 1-1.254 1.312h-1.81a1.255 1.255 0 0 1-1.228-.99l-.782-3.625-2.044 3.939a1.25 1.25 0 0 1-1.115.676h-.098a1.25 1.25 0 0 1-1.116-.68l-2.061-3.994zM35.92 16.63l.207-.114.223-.15q.493-.356.735-.785l.061-.118.033 1.332h1.678V9.242h-1.694l-.033 1.267q-.133-.329-.526-.658l-.032-.028a3.2 3.2 0 0 0-.668-.428l-.27-.12a3.3 3.3 0 0 0-1.235-.23q-1.136-.001-1.974.493a3.36 3.36 0 0 0-1.3 1.382q-.445.89-.444 2.074 0 1.2.51 2.107a3.8 3.8 0 0 0 1.382 1.381 3.9 3.9 0 0 0 1.893.477q.795 0 1.455-.33zm-2.789-5.38q-.576.675-.575 1.762 0 1.102.559 1.794.576.675 1.645.675a2.25 2.25 0 0 0 .934-.19 2.2 2.2 0 0 0 .468-.29l.178-.161a2.2 2.2 0 0 0 .397-.561q.244-.5.244-1.15v-.115q0-.708-.296-1.267l-.043-.077a2.2 2.2 0 0 0-.633-.709l-.13-.086-.047-.028a2.1 2.1 0 0 0-1.073-.285q-1.052 0-1.629.692zm2.316 2.706c.163-.17.28-.407.28-.83v-.114c0-.292-.06-.508-.15-.68a.96.96 0 0 0-.353-.389.85.85 0 0 0-.464-.127c-.4 0-.56.114-.664.239l-.01.012c-.148.174-.275.45-.275.945 0 .506.122.801.27.99.097.11.266.224.68.224.303 0 .504-.09.687-.269zm7.545 1.705a2.6 2.6 0 0 0 .331.423q.319.33.755.548l.173.074q.65.255 1.49.255 1.02 0 1.844-.493a3.45 3.45 0 0 0 1.316-1.4q.493-.904.493-2.089 0-1.909-.988-2.913-.988-1.02-2.584-1.02-.898 0-1.575.347a3 3 0 0 0-.415.262l-.199.166a3.4 3.4 0 0 0-.64.82V9.242h-1.712v11.553h1.729l-.017-5.134zm.53-1.138q.206.29.48.5l.155.11.053.034q.51.296 1.119.297 1.07 0 1.645-.675.577-.69.576-1.762 0-1.119-.576-1.777-.558-.675-1.645-.675-.435 0-.835.16a2 2 0 0 0-.284.136 2 2 0 0 0-.363.254 2.2 2.2 0 0 0-.46.569l-.082.162a2.6 2.6 0 0 0-.213 1.072v.115q0 .707.296 1.267l.135.211zm.964-.818a1.1 1.1 0 0 0 .367.385.94.94 0 0 0 .476.118c.423 0 .59-.117.687-.23.159-.194.28-.478.28-.95 0-.53-.133-.8-.266-.952l-.021-.025c-.078-.094-.231-.221-.68-.221a1 1 0 0 0-.503.135l-.012.007a.86.86 0 0 0-.335.343c-.073.133-.132.324-.132.614v.115a1.4 1.4 0 0 0 .14.66zm15.7-6.222q.347-.346.346-.856a1.05 1.05 0 0 0-.345-.79 1.18 1.18 0 0 0-.84-.329q-.51 0-.855.33a1.05 1.05 0 0 0-.346.79q0 .51.346.855.345.346.856.346.51 0 .839-.346zm4.337 9.314.033-1.332q.191.403.59.747l.098.081a4 4 0 0 0 .316.224l.223.122a3.2 3.2 0 0 0 1.44.322 3.8 3.8 0 0 0 1.875-.477 3.5 3.5 0 0 0 1.382-1.366q.527-.89.526-2.09 0-1.184-.444-2.073a3.24 3.24 0 0 0-1.283-1.399q-.823-.51-1.942-.51a3.5 3.5 0 0 0-1.527.344l-.086.043-.165.09a3 3 0 0 0-.33.214q-.432.315-.656.707a2 2 0 0 0-.099.198l.082-1.283V4.701h-1.744v12.095zm.473-2.509a2.5 2.5 0 0 0 .566.7q.117.098.245.18l.144.08a2.1 2.1 0 0 0 .975.232q1.07 0 1.645-.675.576-.69.576-1.778 0-1.102-.576-1.777-.56-.691-1.645-.692a2.2 2.2 0 0 0-1.015.235q-.22.113-.415.282l-.15.142a2.1 2.1 0 0 0-.42.594q-.223.479-.223 1.1v.115q0 .705.293 1.26zm2.616-.293c.157-.191.28-.479.28-.967 0-.51-.13-.79-.276-.961l-.021-.026c-.082-.1-.232-.225-.67-.225a.87.87 0 0 0-.681.279l-.012.011c-.154.155-.274.38-.274.807v.115c0 .285.057.499.144.669a1.1 1.1 0 0 0 .367.405c.137.082.28.123.455.123.423 0 .59-.118.686-.23zm8.266-3.013q.345-.13.724-.14l.069-.002q.493 0 .642.099l.247-1.794q-.196-.099-.717-.099a2.3 2.3 0 0 0-.545.063 2 2 0 0 0-.411.148 2.2 2.2 0 0 0-.4.249 2.5 2.5 0 0 0-.485.499 2.7 2.7 0 0 0-.32.581l-.05.137v-1.48h-1.778v7.553h1.777v-3.884q0-.546.159-.943a1.5 1.5 0 0 1 .466-.636 2.5 2.5 0 0 1 .399-.253 2 2 0 0 1 .224-.099zm9.784 2.656.05-.922q0-1.743-.856-2.698-.838-.97-2.584-.97-1.119-.001-2.007.493a3.46 3.46 0 0 0-1.4 1.382q-.493.906-.493 2.106 0 1.07.428 1.975.428.89 1.332 1.432.906.526 2.255.526.973 0 1.668-.185l.044-.012.135-.04q.613-.184.984-.421l-.542-1.267q-.3.162-.642.274l-.297.087q-.51.131-1.3.131-.954 0-1.497-.444a1.6 1.6 0 0 1-.192-.193q-.366-.44-.512-1.234l-.004-.021zm-5.427-1.256-.003.022h3.752v-.138q-.011-.727-.288-1.118a1 1 0 0 0-.156-.176q-.46-.428-1.316-.428-.986 0-1.494.604-.379.45-.494 1.234zm-27.053 2.77V4.7h-1.86v12.095h5.333V15.15zm7.103-5.908v7.553h-1.843V9.242h1.843z'/%3E%3Cpath fill='%23fff' d='m19.63 11.151-.757-1.71-.345 1.71-1.12 5.644h-1.827L18.083 4.7h.197l3.325 6.533.988 2.19.988-2.19L26.839 4.7h.181l2.6 12.095h-1.81l-1.218-5.644-.362-1.71-.658 1.71-2.93 5.644h-.098l-2.913-5.644zm14.836 5.81q-1.02 0-1.893-.478a3.8 3.8 0 0 1-1.381-1.382q-.51-.906-.51-2.106 0-1.185.444-2.074a3.36 3.36 0 0 1 1.3-1.382q.839-.494 1.974-.494a3.3 3.3 0 0 1 1.234.231 3.3 3.3 0 0 1 .97.575q.396.33.527.659l.033-1.267h1.694v7.553H37.18l-.033-1.332q-.279.593-1.02 1.053a3.17 3.17 0 0 1-1.662.444zm.296-1.482q.938 0 1.58-.642.642-.66.642-1.711v-.115q0-.708-.296-1.267a2.2 2.2 0 0 0-.807-.872 2.1 2.1 0 0 0-1.119-.313q-1.053 0-1.629.692-.575.675-.575 1.76 0 1.103.559 1.795.577.675 1.645.675zm6.521-6.237h1.711v1.4q.906-1.597 2.83-1.597 1.596 0 2.584 1.02.988 1.005.988 2.914 0 1.185-.493 2.09a3.46 3.46 0 0 1-1.316 1.399 3.5 3.5 0 0 1-1.844.493q-.954 0-1.662-.329a2.67 2.67 0 0 1-1.086-.97l.017 5.134h-1.728zm4.048 6.22q1.07 0 1.645-.674.577-.69.576-1.762 0-1.119-.576-1.777-.558-.675-1.645-.675-.592 0-1.12.296-.51.28-.822.823-.296.527-.296 1.234v.115q0 .708.296 1.267.313.543.823.855.51.296 1.119.297z'/%3E%3Cpath fill='%23e1e3e9' d='M51.325 4.7h1.86v10.45h3.473v1.646h-5.333zm7.12 4.542h1.843v7.553h-1.843zm.905-1.415a1.16 1.16 0 0 1-.856-.346 1.17 1.17 0 0 1-.346-.856 1.05 1.05 0 0 1 .346-.79q.346-.329.856-.329.494 0 .839.33a1.05 1.05 0 0 1 .345.79 1.16 1.16 0 0 1-.345.855q-.33.346-.84.346zm7.875 9.133a3.17 3.17 0 0 1-1.662-.444q-.723-.46-1.004-1.053l-.033 1.332h-1.71V4.701h1.743v4.657l-.082 1.283q.279-.658 1.086-1.119a3.5 3.5 0 0 1 1.778-.477q1.119 0 1.942.51a3.24 3.24 0 0 1 1.283 1.4q.445.888.444 2.072 0 1.201-.526 2.09a3.5 3.5 0 0 1-1.382 1.366 3.8 3.8 0 0 1-1.876.477zm-.296-1.481q1.069 0 1.645-.675.577-.69.577-1.778 0-1.102-.577-1.776-.56-.691-1.645-.692a2.12 2.12 0 0 0-1.58.659q-.642.641-.642 1.694v.115q0 .71.296 1.267a2.4 2.4 0 0 0 .807.872 2.1 2.1 0 0 0 1.119.313zm5.927-6.237h1.777v1.481q.263-.757.856-1.217a2.14 2.14 0 0 1 1.349-.46q.527 0 .724.098l-.247 1.794q-.149-.099-.642-.099-.774 0-1.416.494-.626.493-.626 1.58v3.883h-1.777V9.242zm9.534 7.718q-1.35 0-2.255-.526-.904-.543-1.332-1.432a4.6 4.6 0 0 1-.428-1.975q0-1.2.493-2.106a3.46 3.46 0 0 1 1.4-1.382q.889-.495 2.007-.494 1.744 0 2.584.97.855.956.856 2.7 0 .444-.05.92h-5.43q.18 1.005.708 1.45.542.443 1.497.443.79 0 1.3-.131a4 4 0 0 0 .938-.362l.542 1.267q-.411.263-1.119.46-.708.198-1.711.197zm1.596-4.558q.016-1.02-.444-1.432-.46-.428-1.316-.428-1.728 0-1.991 1.86z'/%3E%3Cpath d='M5.074 15.948a.484.657 0 0 0-.486.659v1.84a.484.657 0 0 0 .486.659h4.101a.484.657 0 0 0 .486-.659v-1.84a.484.657 0 0 0-.486-.659zm3.56 1.16H5.617v.838h3.017z' style='fill:%23fff;fill-rule:evenodd;stroke-width:1.03600001'/%3E%3Cg style='stroke-width:1.12603545'%3E%3Cpath d='M-9.408-1.416c-3.833-.025-7.056 2.912-7.08 6.615-.02 3.08 1.653 4.832 3.107 6.268.903.892 1.721 1.74 2.32 2.902l-.525-.004c-.543-.003-.992.304-1.24.639a1.87 1.87 0 0 0-.362 1.121l-.011 1.877c-.003.402.104.787.347 1.125.244.338.688.653 1.23.656l4.142.028c.542.003.99-.306 1.238-.641a1.87 1.87 0 0 0 .363-1.121l.012-1.875a1.87 1.87 0 0 0-.348-1.127c-.243-.338-.688-.653-1.23-.656l-.518-.004c.597-1.145 1.425-1.983 2.348-2.87 1.473-1.414 3.18-3.149 3.2-6.226-.016-3.59-2.923-6.684-6.993-6.707m-.006 1.1v.002c3.274.02 5.92 2.532 5.9 5.6-.017 2.706-1.39 4.026-2.863 5.44-1.034.994-2.118 2.033-2.814 3.633-.018.041-.052.055-.075.065q-.013.004-.02.01a.34.34 0 0 1-.226.084.34.34 0 0 1-.224-.086l-.092-.077c-.699-1.615-1.768-2.669-2.781-3.67-1.454-1.435-2.797-2.762-2.78-5.478.02-3.067 2.7-5.545 5.975-5.523m-.02 2.826c-1.62-.01-2.944 1.315-2.955 2.96-.01 1.646 1.295 2.988 2.916 2.999h.002c1.621.01 2.943-1.316 2.953-2.961.011-1.646-1.294-2.988-2.916-2.998m-.005 1.1c1.017.006 1.829.83 1.822 1.89s-.83 1.874-1.848 1.867c-1.018-.006-1.829-.83-1.822-1.89s.83-1.874 1.848-1.868m-2.155 11.857 4.14.025c.271.002.49.305.487.676l-.013 1.875c-.003.37-.224.67-.495.668l-4.14-.025c-.27-.002-.487-.306-.485-.676l.012-1.875c.003-.37.224-.67.494-.668' style='color:%23000;font-style:normal;font-variant:normal;font-weight:400;font-stretch:normal;font-size:medium;line-height:normal;font-family:sans-serif;font-variant-ligatures:normal;font-variant-position:normal;font-variant-caps:normal;font-variant-numeric:normal;font-variant-alternates:normal;font-feature-settings:normal;text-indent:0;text-align:start;text-decoration:none;text-decoration-line:none;text-decoration-style:solid;text-decoration-color:%23000;letter-spacing:normal;word-spacing:normal;text-transform:none;writing-mode:lr-tb;direction:ltr;text-orientation:mixed;dominant-baseline:auto;baseline-shift:baseline;text-anchor:start;white-space:normal;shape-padding:0;clip-rule:evenodd;display:inline;overflow:visible;visibility:visible;opacity:1;isolation:auto;mix-blend-mode:normal;color-interpolation:sRGB;color-interpolation-filters:linearRGB;solid-color:%23000;solid-opacity:1;vector-effect:none;fill:%23000;fill-opacity:.4;fill-rule:evenodd;stroke:none;stroke-width:2.47727823;stroke-linecap:butt;stroke-linejoin:miter;stroke-miterlimit:4;stroke-dasharray:none;stroke-dashoffset:0;stroke-opacity:1;color-rendering:auto;image-rendering:auto;shape-rendering:auto;text-rendering:auto' transform='translate(15.553 2.85)scale(.88807)'/%3E%3Cpath d='M-9.415-.316C-12.69-.338-15.37 2.14-15.39 5.207c-.017 2.716 1.326 4.041 2.78 5.477 1.013 1 2.081 2.055 2.78 3.67l.092.076a.34.34 0 0 0 .225.086.34.34 0 0 0 .227-.083l.019-.01c.022-.009.057-.024.074-.064.697-1.6 1.78-2.64 2.814-3.634 1.473-1.414 2.847-2.733 2.864-5.44.02-3.067-2.627-5.58-5.901-5.601m-.057 8.784c1.621.011 2.944-1.315 2.955-2.96.01-1.646-1.295-2.988-2.916-2.999-1.622-.01-2.945 1.315-2.955 2.96s1.295 2.989 2.916 3' style='clip-rule:evenodd;fill:%23e1e3e9;fill-opacity:1;fill-rule:evenodd;stroke:none;stroke-width:2.47727823;stroke-miterlimit:4;stroke-dasharray:none;stroke-opacity:.4' transform='translate(15.553 2.85)scale(.88807)'/%3E%3Cpath d='M-11.594 15.465c-.27-.002-.492.297-.494.668l-.012 1.876c-.003.371.214.673.485.675l4.14.027c.271.002.492-.298.495-.668l.012-1.877c.003-.37-.215-.672-.485-.674z' style='clip-rule:evenodd;fill:%23fff;fill-opacity:1;fill-rule:evenodd;stroke:none;stroke-width:2.47727823;stroke-miterlimit:4;stroke-dasharray:none;stroke-opacity:.4' transform='translate(15.553 2.85)scale(.88807)'/%3E%3C/g%3E%3C/svg%3E")}}.maplibregl-ctrl.maplibregl-ctrl-attrib{background-color:hsla(0,0%,100%,.5);margin:0;padding:0 5px}@media screen{.maplibregl-ctrl-attrib.maplibregl-compact{background-color:#fff;border-radius:12px;box-sizing:content-box;color:#000;margin:10px;min-height:20px;padding:2px 24px 2px 0;position:relative}.maplibregl-ctrl-attrib.maplibregl-compact-show{padding:2px 28px 2px 8px;visibility:visible}.maplibregl-ctrl-bottom-left>.maplibregl-ctrl-attrib.maplibregl-compact-show,.maplibregl-ctrl-top-left>.maplibregl-ctrl-attrib.maplibregl-compact-show{border-radius:12px;padding:2px 8px 2px 28px}.maplibregl-ctrl-attrib.maplibregl-compact .maplibregl-ctrl-attrib-inner{display:none}.maplibregl-ctrl-attrib-button{background-color:hsla(0,0%,100%,.5);background-image:url("data:image/svg+xml;charset=utf-8,%3Csvg xmlns='http://www.w3.org/2000/svg' width='24' height='24' fill-rule='evenodd' viewBox='0 0 20 20'%3E%3Cpath d='M4 10a6 6 0 1 0 12 0 6 6 0 1 0-12 0m5-3a1 1 0 1 0 2 0 1 1 0 1 0-2 0m0 3a1 1 0 1 1 2 0v3a1 1 0 1 1-2 0'/%3E%3C/svg%3E");border:0;border-radius:12px;box-sizing:border-box;cursor:pointer;display:none;height:24px;outline:none;position:absolute;right:0;top:0;width:24px}.maplibregl-ctrl-attrib summary.maplibregl-ctrl-attrib-button{-webkit-appearance:none;-moz-appearance:none;appearance:none;list-style:none}.maplibregl-ctrl-attrib summary.maplibregl-ctrl-attrib-button::-webkit-details-marker{display:none}.maplibregl-ctrl-bottom-left .maplibregl-ctrl-attrib-button,.maplibregl-ctrl-top-left .maplibregl-ctrl-attrib-button{left:0}.maplibregl-ctrl-attrib.maplibregl-compact .maplibregl-ctrl-attrib-button,.maplibregl-ctrl-attrib.maplibregl-compact-show .maplibregl-ctrl-attrib-inner{display:block}.maplibregl-ctrl-attrib.maplibregl-compact-show .maplibregl-ctrl-attrib-button{background-color:rgb(0 0 0/5%)}.maplibregl-ctrl-bottom-right>.maplibregl-ctrl-attrib.maplibregl-compact:after{bottom:0;right:0}.maplibregl-ctrl-top-right>.maplibregl-ctrl-attrib.maplibregl-compact:after{right:0;top:0}.maplibregl-ctrl-top-left>.maplibregl-ctrl-attrib.maplibregl-compact:after{left:0;top:0}.maplibregl-ctrl-bottom-left>.maplibregl-ctrl-attrib.maplibregl-compact:after{bottom:0;left:0}}@media screen and (forced-colors:active){.maplibregl-ctrl-attrib.maplibregl-compact:after{background-image:url("data:image/svg+xml;charset=utf-8,%3Csvg xmlns='http://www.w3.org/2000/svg' width='24' height='24' fill='%23fff' fill-rule='evenodd' viewBox='0 0 20 20'%3E%3Cpath d='M4 10a6 6 0 1 0 12 0 6 6 0 1 0-12 0m5-3a1 1 0 1 0 2 0 1 1 0 1 0-2 0m0 3a1 1 0 1 1 2 0v3a1 1 0 1 1-2 0'/%3E%3C/svg%3E")}}@media screen and (forced-colors:active) and (prefers-color-scheme:light){.maplibregl-ctrl-attrib.maplibregl-compact:after{background-image:url("data:image/svg+xml;charset=utf-8,%3Csvg xmlns='http://www.w3.org/2000/svg' width='24' height='24' fill-rule='evenodd' viewBox='0 0 20 20'%3E%3Cpath d='M4 10a6 6 0 1 0 12 0 6 6 0 1 0-12 0m5-3a1 1 0 1 0 2 0 1 1 0 1 0-2 0m0 3a1 1 0 1 1 2 0v3a1 1 0 1 1-2 0'/%3E%3C/svg%3E")}}.maplibregl-ctrl-attrib a{color:rgba(0,0,0,.75);text-decoration:none}.maplibregl-ctrl-attrib a:hover{color:inherit;text-decoration:underline}.maplibregl-attrib-empty{display:none}.maplibregl-ctrl-scale{background-color:hsla(0,0%,100%,.75);border:2px solid #333;border-top:#333;box-sizing:border-box;color:#333;font-size:10px;padding:0 5px}.maplibregl-popup{display:flex;left:0;pointer-events:none;position:absolute;top:0;will-change:transform}.maplibregl-popup-anchor-top,.maplibregl-popup-anchor-top-left,.maplibregl-popup-anchor-top-right{flex-direction:column}.maplibregl-popup-anchor-bottom,.maplibregl-popup-anchor-bottom-left,.maplibregl-popup-anchor-bottom-right{flex-direction:column-reverse}.maplibregl-popup-anchor-left{flex-direction:row}.maplibregl-popup-anchor-right{flex-direction:row-reverse}.maplibregl-popup-tip{border:10px solid transparent;height:0;width:0;z-index:1}.maplibregl-popup-anchor-top .maplibregl-popup-tip{align-self:center;border-bottom-color:#fff;border-top:none}.maplibregl-popup-anchor-top-left .maplibregl-popup-tip{align-self:flex-start;border-bottom-color:#fff;border-left:none;border-top:none}.maplibregl-popup-anchor-top-right .maplibregl-popup-tip{align-self:flex-end;border-bottom-color:#fff;border-right:none;border-top:none}.maplibregl-popup-anchor-bottom .maplibregl-popup-tip{align-self:center;border-bottom:none;border-top-color:#fff}.maplibregl-popup-anchor-bottom-left .maplibregl-popup-tip{align-self:flex-start;border-bottom:none;border-left:none;border-top-color:#fff}.maplibregl-popup-anchor-bottom-right .maplibregl-popup-tip{align-self:flex-end;border-bottom:none;border-right:none;border-top-color:#fff}.maplibregl-popup-anchor-left .maplibregl-popup-tip{align-self:center;border-left:none;border-right-color:#fff}.maplibregl-popup-anchor-right .maplibregl-popup-tip{align-self:center;border-left-color:#fff;border-right:none}.maplibregl-popup-close-button{background-color:transparent;border:0;border-radius:0 3px 0 0;cursor:pointer;position:absolute;right:0;top:0}.maplibregl-popup-close-button:hover{background-color:rgb(0 0 0/5%)}.maplibregl-popup-content{background:#fff;border-radius:3px;box-shadow:0 1px 2px rgba(0,0,0,.1);padding:15px 10px;pointer-events:auto;position:relative}.maplibregl-popup-anchor-top-left .maplibregl-popup-content{border-top-left-radius:0}.maplibregl-popup-anchor-top-right .maplibregl-popup-content{border-top-right-radius:0}.maplibregl-popup-anchor-bottom-left .maplibregl-popup-content{border-bottom-left-radius:0}.maplibregl-popup-anchor-bottom-right .maplibregl-popup-content{border-bottom-right-radius:0}.maplibregl-popup-track-pointer{display:none}.maplibregl-popup-track-pointer *{pointer-events:none;-webkit-user-select:none;-moz-user-select:none;user-select:none}.maplibregl-map:hover .maplibregl-popup-track-pointer{display:flex}.maplibregl-map:active .maplibregl-popup-track-pointer{display:none}.maplibregl-marker{left:0;position:absolute;top:0;transition:opacity .2s;will-change:transform}.maplibregl-user-location-dot,.maplibregl-user-location-dot:before{background-color:#1da1f2;border-radius:50%;height:15px;width:15px}.maplibregl-user-location-dot:before{animation:maplibregl-user-location-dot-pulse 2s infinite;content:"";position:absolute}.maplibregl-user-location-dot:after{border:2px solid #fff;border-radius:50%;box-shadow:0 0 3px rgba(0,0,0,.35);box-sizing:border-box;content:"";height:19px;left:-2px;position:absolute;top:-2px;width:19px}@keyframes maplibregl-user-location-dot-pulse{0%{opacity:1;transform:scale(1)}70%{opacity:0;transform:scale(3)}to{opacity:0;transform:scale(1)}}.maplibregl-user-location-dot-stale{background-color:#aaa}.maplibregl-user-location-dot-stale:after{display:none}.maplibregl-user-location-accuracy-circle{background-color:#1da1f233;border-radius:100%;height:1px;width:1px}.maplibregl-crosshair,.maplibregl-crosshair .maplibregl-interactive,.maplibregl-crosshair .maplibregl-interactive:active{cursor:crosshair}.maplibregl-boxzoom{background:#fff;border:2px dotted #202020;height:0;left:0;opacity:.5;position:absolute;top:0;width:0}.maplibregl-cooperative-gesture-screen{align-items:center;background:rgba(0,0,0,.4);color:#fff;display:flex;font-size:1.4em;inset:0;justify-content:center;line-height:1.2;opacity:0;padding:1rem;pointer-events:none;position:absolute;transition:opacity 1s ease 1s;z-index:99999}.maplibregl-cooperative-gesture-screen.maplibregl-show{opacity:1;transition:opacity .05s}.maplibregl-cooperative-gesture-screen .maplibregl-mobile-message{display:none}@media (hover:none),(width <= 480px){.maplibregl-cooperative-gesture-screen .maplibregl-desktop-message{display:none}.maplibregl-cooperative-gesture-screen .maplibregl-mobile-message{display:block}}.maplibregl-pseudo-fullscreen{height:100%!important;left:0!important;position:fixed!important;top:0!important;width:100%!important;z-index:99999}`;
+              document.head.appendChild(e2);
+            }
+          })();
+        }
+      });
+      var require_registry = __commonJS({
+        "src/registry.js"(exports) {
+          var Loggers = require_loggers();
+          var noop2 = require_noop();
+          var pushUnique = require_push_unique();
+          var isPlainObject2 = require_is_plain_object();
+          var addStyleRule = require_dom().addStyleRule;
+          var ExtendModule = require_extend();
+          var basePlotAttributes = require_attributes2();
+          var baseLayoutAttributes = require_layout_attributes2();
+          var extendFlat = ExtendModule.extendFlat;
+          var extendDeepAll = ExtendModule.extendDeepAll;
+          exports.modules = {};
+          exports.allCategories = {};
+          exports.allTypes = [];
+          exports.subplotsRegistry = {};
+          exports.componentsRegistry = {};
+          exports.layoutArrayContainers = [];
+          exports.layoutArrayRegexes = [];
+          exports.traceLayoutAttributes = {};
+          exports.localeRegistry = {};
+          exports.apiMethodRegistry = {};
+          exports.collectableSubplotTypes = null;
+          exports.register = function register2(_modules) {
+            exports.collectableSubplotTypes = null;
+            if (!_modules) {
+              throw new Error("No argument passed to Plotly.register.");
+            } else if (_modules && !Array.isArray(_modules)) {
+              _modules = [_modules];
+            }
+            for (var i2 = 0; i2 < _modules.length; i2++) {
+              var newModule = _modules[i2];
+              if (!newModule) {
+                throw new Error("Invalid module was attempted to be registered!");
+              }
+              switch (newModule.moduleType) {
+                case "trace":
+                  registerTraceModule(newModule);
+                  break;
+                case "transform":
+                  registerTransformModule(newModule);
+                  break;
+                case "component":
+                  registerComponentModule(newModule);
+                  break;
+                case "locale":
+                  registerLocale(newModule);
+                  break;
+                case "apiMethod":
+                  var name2 = newModule.name;
+                  exports.apiMethodRegistry[name2] = newModule.fn;
+                  break;
+                default:
+                  throw new Error("Invalid module was attempted to be registered!");
+              }
+            }
+          };
+          exports.getModule = function(trace) {
+            var _module = exports.modules[getTraceType(trace)];
+            if (!_module) return false;
+            return _module._module;
+          };
+          exports.traceIs = function(traceType, category) {
+            traceType = getTraceType(traceType);
+            if (traceType === "various") return false;
+            var _module = exports.modules[traceType];
+            if (!_module) {
+              if (traceType) {
+                Loggers.log("Unrecognized trace type " + traceType + ".");
+              }
+              _module = exports.modules[basePlotAttributes.type.dflt];
+            }
+            return !!_module.categories[category];
+          };
+          exports.getComponentMethod = function(name2, method) {
+            var _module = exports.componentsRegistry[name2];
+            if (!_module) return noop2;
+            return _module[method] || noop2;
+          };
+          exports.call = function() {
+            var name2 = arguments[0];
+            var args = [].slice.call(arguments, 1);
+            return exports.apiMethodRegistry[name2].apply(null, args);
+          };
+          function registerTraceModule(_module) {
+            var thisType = _module.name;
+            var categoriesIn = _module.categories;
+            var meta = _module.meta;
+            if (exports.modules[thisType]) {
+              Loggers.log("Type " + thisType + " already registered");
+              return;
+            }
+            if (!exports.subplotsRegistry[_module.basePlotModule.name]) {
+              registerSubplot(_module.basePlotModule);
+            }
+            var categoryObj = {};
+            for (var i2 = 0; i2 < categoriesIn.length; i2++) {
+              categoryObj[categoriesIn[i2]] = true;
+              exports.allCategories[categoriesIn[i2]] = true;
+            }
+            exports.modules[thisType] = {
+              _module,
+              categories: categoryObj
+            };
+            if (meta && Object.keys(meta).length) {
+              exports.modules[thisType].meta = meta;
+            }
+            exports.allTypes.push(thisType);
+            for (var componentName in exports.componentsRegistry) {
+              mergeComponentAttrsToTrace(componentName, thisType);
+            }
+            if (_module.layoutAttributes) {
+              extendFlat(exports.traceLayoutAttributes, _module.layoutAttributes);
+            }
+            var basePlotModule = _module.basePlotModule;
+            var bpmName = basePlotModule.name;
+            if (bpmName === "mapbox") {
+              var styleRules = basePlotModule.constants.styleRules;
+              for (var k2 in styleRules) {
+                addStyleRule(".js-plotly-plot .plotly .mapboxgl-" + k2, styleRules[k2]);
+              }
+            }
+            if (bpmName === "map") {
+              require_maplibre_gl();
+            }
+            if ((bpmName === "geo" || bpmName === "mapbox" || bpmName === "map") && window.PlotlyGeoAssets === void 0) {
+              window.PlotlyGeoAssets = { topojson: {} };
+            }
+          }
+          function registerSubplot(_module) {
+            var plotType = _module.name;
+            if (exports.subplotsRegistry[plotType]) {
+              Loggers.log("Plot type " + plotType + " already registered.");
+              return;
+            }
+            findArrayRegexps(_module);
+            exports.subplotsRegistry[plotType] = _module;
+            for (var componentName in exports.componentsRegistry) {
+              mergeComponentAttrsToSubplot(componentName, _module.name);
+            }
+          }
+          function registerComponentModule(_module) {
+            if (typeof _module.name !== "string") {
+              throw new Error("Component module *name* must be a string.");
+            }
+            var name2 = _module.name;
+            exports.componentsRegistry[name2] = _module;
+            if (_module.layoutAttributes) {
+              if (_module.layoutAttributes._isLinkedToArray) {
+                pushUnique(exports.layoutArrayContainers, name2);
+              }
+              findArrayRegexps(_module);
+            }
+            for (var traceType in exports.modules) {
+              mergeComponentAttrsToTrace(name2, traceType);
+            }
+            for (var subplotName in exports.subplotsRegistry) {
+              mergeComponentAttrsToSubplot(name2, subplotName);
+            }
+            if (_module.schema && _module.schema.layout) {
+              extendDeepAll(baseLayoutAttributes, _module.schema.layout);
+            }
+          }
+          function registerTransformModule(_module) {
+            if (typeof _module.name !== "string") {
+              throw new Error("Transform module *name* must be a string.");
+            }
+            var prefix = "Transform module " + _module.name;
+            var hasTransform = typeof _module.transform === "function";
+            var hasCalcTransform = typeof _module.calcTransform === "function";
+            if (!hasTransform && !hasCalcTransform) {
+              throw new Error(prefix + " is missing a *transform* or *calcTransform* method.");
+            }
+            if (hasTransform && hasCalcTransform) {
+              Loggers.log([
+                prefix + " has both a *transform* and *calcTransform* methods.",
+                "Please note that all *transform* methods are executed",
+                "before all *calcTransform* methods."
+              ].join(" "));
+            }
+            if (!isPlainObject2(_module.attributes)) {
+              Loggers.log(prefix + " registered without an *attributes* object.");
+            }
+            if (typeof _module.supplyDefaults !== "function") {
+              Loggers.log(prefix + " registered without a *supplyDefaults* method.");
+            }
+          }
+          function registerLocale(_module) {
+            var locale = _module.name;
+            var baseLocale = locale.split("-")[0];
+            var newDict = _module.dictionary;
+            var newFormat = _module.format;
+            var hasDict = newDict && Object.keys(newDict).length;
+            var hasFormat = newFormat && Object.keys(newFormat).length;
+            var locales = exports.localeRegistry;
+            var localeObj = locales[locale];
+            if (!localeObj) locales[locale] = localeObj = {};
+            if (baseLocale !== locale) {
+              var baseLocaleObj = locales[baseLocale];
+              if (!baseLocaleObj) locales[baseLocale] = baseLocaleObj = {};
+              if (hasDict && baseLocaleObj.dictionary === localeObj.dictionary) {
+                baseLocaleObj.dictionary = newDict;
+              }
+              if (hasFormat && baseLocaleObj.format === localeObj.format) {
+                baseLocaleObj.format = newFormat;
+              }
+            }
+            if (hasDict) localeObj.dictionary = newDict;
+            if (hasFormat) localeObj.format = newFormat;
+          }
+          function findArrayRegexps(_module) {
+            if (_module.layoutAttributes) {
+              var arrayAttrRegexps = _module.layoutAttributes._arrayAttrRegexps;
+              if (arrayAttrRegexps) {
+                for (var i2 = 0; i2 < arrayAttrRegexps.length; i2++) {
+                  pushUnique(exports.layoutArrayRegexes, arrayAttrRegexps[i2]);
+                }
+              }
+            }
+          }
+          function mergeComponentAttrsToTrace(componentName, traceType) {
+            var componentSchema = exports.componentsRegistry[componentName].schema;
+            if (!componentSchema || !componentSchema.traces) return;
+            var traceAttrs = componentSchema.traces[traceType];
+            if (traceAttrs) {
+              extendDeepAll(exports.modules[traceType]._module.attributes, traceAttrs);
+            }
+          }
+          function mergeComponentAttrsToSubplot(componentName, subplotName) {
+            var componentSchema = exports.componentsRegistry[componentName].schema;
+            if (!componentSchema || !componentSchema.subplots) return;
+            var subplotModule = exports.subplotsRegistry[subplotName];
+            var subplotAttrs = subplotModule.layoutAttributes;
+            var subplotAttr = subplotModule.attr === "subplot" ? subplotModule.name : subplotModule.attr;
+            if (Array.isArray(subplotAttr)) subplotAttr = subplotAttr[0];
+            var componentLayoutAttrs = componentSchema.subplots[subplotAttr];
+            if (subplotAttrs && componentLayoutAttrs) {
+              extendDeepAll(subplotAttrs, componentLayoutAttrs);
+            }
+          }
+          function getTraceType(traceType) {
+            if (typeof traceType === "object") traceType = traceType.type;
+            return traceType;
+          }
+        }
+      });
+      var require_dates = __commonJS({
+        "src/lib/dates.js"(exports) {
+          var timeFormat = require_d3_time_format().timeFormat;
+          var isNumeric = require_fast_isnumeric();
+          var Loggers = require_loggers();
+          var mod2 = require_mod().mod;
+          var constants = require_numerical();
+          var BADNUM = constants.BADNUM;
+          var ONEDAY = constants.ONEDAY;
+          var ONEHOUR = constants.ONEHOUR;
+          var ONEMIN = constants.ONEMIN;
+          var ONESEC = constants.ONESEC;
+          var EPOCHJD = constants.EPOCHJD;
+          var Registry = require_registry();
+          var utcFormat = require_d3_time_format().utcFormat;
+          var DATETIME_REGEXP = /^\s*(-?\d\d\d\d|\d\d)(-(\d?\d)(-(\d?\d)([ Tt]([01]?\d|2[0-3])(:([0-5]\d)(:([0-5]\d(\.\d+)?))?(Z|z|[+\-]\d\d(:?\d\d)?)?)?)?)?)?\s*$/m;
+          var DATETIME_REGEXP_CN = /^\s*(-?\d\d\d\d|\d\d)(-(\d?\di?)(-(\d?\d)([ Tt]([01]?\d|2[0-3])(:([0-5]\d)(:([0-5]\d(\.\d+)?))?(Z|z|[+\-]\d\d(:?\d\d)?)?)?)?)?)?\s*$/m;
+          var YFIRST = (/* @__PURE__ */ new Date()).getFullYear() - 70;
+          function isWorldCalendar(calendar) {
+            return calendar && Registry.componentsRegistry.calendars && typeof calendar === "string" && calendar !== "gregorian";
+          }
+          exports.dateTick0 = function(calendar, dayOfWeek) {
+            var tick0 = _dateTick0(calendar, !!dayOfWeek);
+            if (dayOfWeek < 2) return tick0;
+            var v2 = exports.dateTime2ms(tick0, calendar);
+            v2 += ONEDAY * (dayOfWeek - 1);
+            return exports.ms2DateTime(v2, 0, calendar);
+          };
+          function _dateTick0(calendar, sunday) {
+            if (isWorldCalendar(calendar)) {
+              return sunday ? Registry.getComponentMethod("calendars", "CANONICAL_SUNDAY")[calendar] : Registry.getComponentMethod("calendars", "CANONICAL_TICK")[calendar];
+            } else {
+              return sunday ? "2000-01-02" : "2000-01-01";
+            }
+          }
+          exports.dfltRange = function(calendar) {
+            if (isWorldCalendar(calendar)) {
+              return Registry.getComponentMethod("calendars", "DFLTRANGE")[calendar];
+            } else {
+              return ["2000-01-01", "2001-01-01"];
+            }
+          };
+          exports.isJSDate = function(v2) {
+            return typeof v2 === "object" && v2 !== null && typeof v2.getTime === "function";
+          };
+          var MIN_MS;
+          var MAX_MS;
+          exports.dateTime2ms = function(s2, calendar) {
+            if (exports.isJSDate(s2)) {
+              var tzOffset = s2.getTimezoneOffset() * ONEMIN;
+              var offsetTweak = (s2.getUTCMinutes() - s2.getMinutes()) * ONEMIN + (s2.getUTCSeconds() - s2.getSeconds()) * ONESEC + (s2.getUTCMilliseconds() - s2.getMilliseconds());
+              if (offsetTweak) {
+                var comb = 3 * ONEMIN;
+                tzOffset = tzOffset - comb / 2 + mod2(offsetTweak - tzOffset + comb / 2, comb);
+              }
+              s2 = Number(s2) - tzOffset;
+              if (s2 >= MIN_MS && s2 <= MAX_MS) return s2;
+              return BADNUM;
+            }
+            if (typeof s2 !== "string" && typeof s2 !== "number") return BADNUM;
+            s2 = String(s2);
+            var isWorld = isWorldCalendar(calendar);
+            var s0 = s2.charAt(0);
+            if (isWorld && (s0 === "G" || s0 === "g")) {
+              s2 = s2.slice(1);
+              calendar = "";
+            }
+            var isChinese = isWorld && calendar.slice(0, 7) === "chinese";
+            var match = s2.match(isChinese ? DATETIME_REGEXP_CN : DATETIME_REGEXP);
+            if (!match) return BADNUM;
+            var y2 = match[1];
+            var m2 = match[3] || "1";
+            var d2 = Number(match[5] || 1);
+            var H2 = Number(match[7] || 0);
+            var M2 = Number(match[9] || 0);
+            var S2 = Number(match[11] || 0);
+            if (isWorld) {
+              if (y2.length === 2) return BADNUM;
+              y2 = Number(y2);
+              var cDate;
+              try {
+                var calInstance = Registry.getComponentMethod("calendars", "getCal")(calendar);
+                if (isChinese) {
+                  var isIntercalary = m2.charAt(m2.length - 1) === "i";
+                  m2 = parseInt(m2, 10);
+                  cDate = calInstance.newDate(y2, calInstance.toMonthIndex(y2, m2, isIntercalary), d2);
+                } else {
+                  cDate = calInstance.newDate(y2, Number(m2), d2);
+                }
+              } catch (e2) {
+                return BADNUM;
+              }
+              if (!cDate) return BADNUM;
+              return (cDate.toJD() - EPOCHJD) * ONEDAY + H2 * ONEHOUR + M2 * ONEMIN + S2 * ONESEC;
+            }
+            if (y2.length === 2) {
+              y2 = (Number(y2) + 2e3 - YFIRST) % 100 + YFIRST;
+            } else y2 = Number(y2);
+            m2 -= 1;
+            var date = new Date(Date.UTC(2e3, m2, d2, H2, M2));
+            date.setUTCFullYear(y2);
+            if (date.getUTCMonth() !== m2) return BADNUM;
+            if (date.getUTCDate() !== d2) return BADNUM;
+            return date.getTime() + S2 * ONESEC;
+          };
+          MIN_MS = exports.MIN_MS = exports.dateTime2ms("-9999");
+          MAX_MS = exports.MAX_MS = exports.dateTime2ms("9999-12-31 23:59:59.9999");
+          exports.isDateTime = function(s2, calendar) {
+            return exports.dateTime2ms(s2, calendar) !== BADNUM;
+          };
+          function lpad(val, digits) {
+            return String(val + Math.pow(10, digits)).slice(1);
+          }
+          var NINETYDAYS = 90 * ONEDAY;
+          var THREEHOURS = 3 * ONEHOUR;
+          var FIVEMIN = 5 * ONEMIN;
+          exports.ms2DateTime = function(ms, r2, calendar) {
+            if (typeof ms !== "number" || !(ms >= MIN_MS && ms <= MAX_MS)) return BADNUM;
+            if (!r2) r2 = 0;
+            var msecTenths = Math.floor(mod2(ms + 0.05, 1) * 10);
+            var msRounded = Math.round(ms - msecTenths / 10);
+            var dateStr, h2, m2, s2, msec10, d2;
+            if (isWorldCalendar(calendar)) {
+              var dateJD = Math.floor(msRounded / ONEDAY) + EPOCHJD;
+              var timeMs = Math.floor(mod2(ms, ONEDAY));
+              try {
+                dateStr = Registry.getComponentMethod("calendars", "getCal")(calendar).fromJD(dateJD).formatDate("yyyy-mm-dd");
+              } catch (e2) {
+                dateStr = utcFormat("G%Y-%m-%d")(new Date(msRounded));
+              }
+              if (dateStr.charAt(0) === "-") {
+                while (dateStr.length < 11) dateStr = "-0" + dateStr.slice(1);
+              } else {
+                while (dateStr.length < 10) dateStr = "0" + dateStr;
+              }
+              h2 = r2 < NINETYDAYS ? Math.floor(timeMs / ONEHOUR) : 0;
+              m2 = r2 < NINETYDAYS ? Math.floor(timeMs % ONEHOUR / ONEMIN) : 0;
+              s2 = r2 < THREEHOURS ? Math.floor(timeMs % ONEMIN / ONESEC) : 0;
+              msec10 = r2 < FIVEMIN ? timeMs % ONESEC * 10 + msecTenths : 0;
+            } else {
+              d2 = new Date(msRounded);
+              dateStr = utcFormat("%Y-%m-%d")(d2);
+              h2 = r2 < NINETYDAYS ? d2.getUTCHours() : 0;
+              m2 = r2 < NINETYDAYS ? d2.getUTCMinutes() : 0;
+              s2 = r2 < THREEHOURS ? d2.getUTCSeconds() : 0;
+              msec10 = r2 < FIVEMIN ? d2.getUTCMilliseconds() * 10 + msecTenths : 0;
+            }
+            return includeTime(dateStr, h2, m2, s2, msec10);
+          };
+          exports.ms2DateTimeLocal = function(ms) {
+            if (!(ms >= MIN_MS + ONEDAY && ms <= MAX_MS - ONEDAY)) return BADNUM;
+            var msecTenths = Math.floor(mod2(ms + 0.05, 1) * 10);
+            var d2 = new Date(Math.round(ms - msecTenths / 10));
+            var dateStr = timeFormat("%Y-%m-%d")(d2);
+            var h2 = d2.getHours();
+            var m2 = d2.getMinutes();
+            var s2 = d2.getSeconds();
+            var msec10 = d2.getUTCMilliseconds() * 10 + msecTenths;
+            return includeTime(dateStr, h2, m2, s2, msec10);
+          };
+          function includeTime(dateStr, h2, m2, s2, msec10) {
+            if (h2 || m2 || s2 || msec10) {
+              dateStr += " " + lpad(h2, 2) + ":" + lpad(m2, 2);
+              if (s2 || msec10) {
+                dateStr += ":" + lpad(s2, 2);
+                if (msec10) {
+                  var digits = 4;
+                  while (msec10 % 10 === 0) {
+                    digits -= 1;
+                    msec10 /= 10;
+                  }
+                  dateStr += "." + lpad(msec10, digits);
+                }
+              }
+            }
+            return dateStr;
+          }
+          exports.cleanDate = function(v2, dflt, calendar) {
+            if (v2 === BADNUM) return dflt;
+            if (exports.isJSDate(v2) || typeof v2 === "number" && isFinite(v2)) {
+              if (isWorldCalendar(calendar)) {
+                Loggers.error("JS Dates and milliseconds are incompatible with world calendars", v2);
+                return dflt;
+              }
+              v2 = exports.ms2DateTimeLocal(+v2);
+              if (!v2 && dflt !== void 0) return dflt;
+            } else if (!exports.isDateTime(v2, calendar)) {
+              Loggers.error("unrecognized date", v2);
+              return dflt;
+            }
+            return v2;
+          };
+          var fracMatch = /%\d?f/g;
+          var halfYearMatch = /%h/g;
+          var quarterToHalfYear = {
+            1: "1",
+            2: "1",
+            3: "2",
+            4: "2"
+          };
+          function modDateFormat(fmt, x2, formatter, calendar) {
+            fmt = fmt.replace(fracMatch, function(match) {
+              var digits = Math.min(+match.charAt(1) || 6, 6);
+              var fracSecs = (x2 / 1e3 % 1 + 2).toFixed(digits).slice(2).replace(/0+$/, "") || "0";
+              return fracSecs;
+            });
+            var d2 = new Date(Math.floor(x2 + 0.05));
+            fmt = fmt.replace(halfYearMatch, function() {
+              return quarterToHalfYear[formatter("%q")(d2)];
+            });
+            if (isWorldCalendar(calendar)) {
+              try {
+                fmt = Registry.getComponentMethod("calendars", "worldCalFmt")(fmt, x2, calendar);
+              } catch (e2) {
+                return "Invalid";
+              }
+            }
+            return formatter(fmt)(d2);
+          }
+          var MAXSECONDS = [59, 59.9, 59.99, 59.999, 59.9999];
+          function formatTime2(x2, tr) {
+            var timePart = mod2(x2 + 0.05, ONEDAY);
+            var timeStr = lpad(Math.floor(timePart / ONEHOUR), 2) + ":" + lpad(mod2(Math.floor(timePart / ONEMIN), 60), 2);
+            if (tr !== "M") {
+              if (!isNumeric(tr)) tr = 0;
+              var sec = Math.min(mod2(x2 / ONESEC, 60), MAXSECONDS[tr]);
+              var secStr = (100 + sec).toFixed(tr).slice(1);
+              if (tr > 0) {
+                secStr = secStr.replace(/0+$/, "").replace(/[\.]$/, "");
+              }
+              timeStr += ":" + secStr;
+            }
+            return timeStr;
+          }
+          exports.formatDate = function(x2, fmt, tr, formatter, calendar, extraFormat) {
+            calendar = isWorldCalendar(calendar) && calendar;
+            if (!fmt) {
+              if (tr === "y") fmt = extraFormat.year;
+              else if (tr === "m") fmt = extraFormat.month;
+              else if (tr === "d") {
+                fmt = extraFormat.dayMonth + "\n" + extraFormat.year;
+              } else {
+                return formatTime2(x2, tr) + "\n" + modDateFormat(extraFormat.dayMonthYear, x2, formatter, calendar);
+              }
+            }
+            return modDateFormat(fmt, x2, formatter, calendar);
+          };
+          var THREEDAYS = 3 * ONEDAY;
+          exports.incrementMonth = function(ms, dMonth, calendar) {
+            calendar = isWorldCalendar(calendar) && calendar;
+            var timeMs = mod2(ms, ONEDAY);
+            ms = Math.round(ms - timeMs);
+            if (calendar) {
+              try {
+                var dateJD = Math.round(ms / ONEDAY) + EPOCHJD;
+                var calInstance = Registry.getComponentMethod("calendars", "getCal")(calendar);
+                var cDate = calInstance.fromJD(dateJD);
+                if (dMonth % 12) calInstance.add(cDate, dMonth, "m");
+                else calInstance.add(cDate, dMonth / 12, "y");
+                return (cDate.toJD() - EPOCHJD) * ONEDAY + timeMs;
+              } catch (e2) {
+                Loggers.error("invalid ms " + ms + " in calendar " + calendar);
+              }
+            }
+            var y2 = new Date(ms + THREEDAYS);
+            return y2.setUTCMonth(y2.getUTCMonth() + dMonth) + timeMs - THREEDAYS;
+          };
+          exports.findExactDates = function(data, calendar) {
+            var exactYears = 0;
+            var exactMonths = 0;
+            var exactDays = 0;
+            var blankCount = 0;
+            var d2;
+            var di2;
+            var calInstance = isWorldCalendar(calendar) && Registry.getComponentMethod("calendars", "getCal")(calendar);
+            for (var i2 = 0; i2 < data.length; i2++) {
+              di2 = data[i2];
+              if (!isNumeric(di2)) {
+                blankCount++;
+                continue;
+              }
+              if (di2 % ONEDAY) continue;
+              if (calInstance) {
+                try {
+                  d2 = calInstance.fromJD(di2 / ONEDAY + EPOCHJD);
+                  if (d2.day() === 1) {
+                    if (d2.month() === 1) exactYears++;
+                    else exactMonths++;
+                  } else exactDays++;
+                } catch (e2) {
+                }
+              } else {
+                d2 = new Date(di2);
+                if (d2.getUTCDate() === 1) {
+                  if (d2.getUTCMonth() === 0) exactYears++;
+                  else exactMonths++;
+                } else exactDays++;
+              }
+            }
+            exactMonths += exactYears;
+            exactDays += exactMonths;
+            var dataCount = data.length - blankCount;
+            return {
+              exactYears: exactYears / dataCount,
+              exactMonths: exactMonths / dataCount,
+              exactDays: exactDays / dataCount
+            };
+          };
+        }
+      });
+      var require_identity2 = __commonJS({
+        "src/lib/identity.js"(exports, module2) {
+          module2.exports = function identity22(d2) {
+            return d2;
+          };
+        }
+      });
+      var require_search = __commonJS({
+        "src/lib/search.js"(exports) {
+          var isNumeric = require_fast_isnumeric();
+          var loggers2 = require_loggers();
+          var identity22 = require_identity2();
+          var BADNUM = require_numerical().BADNUM;
+          var roundingError = 1e-9;
+          exports.findBin = function(val, bins, linelow) {
+            if (isNumeric(bins.start)) {
+              return linelow ? Math.ceil((val - bins.start) / bins.size - roundingError) - 1 : Math.floor((val - bins.start) / bins.size + roundingError);
+            } else {
+              var n1 = 0;
+              var n2 = bins.length;
+              var c2 = 0;
+              var binSize = n2 > 1 ? (bins[n2 - 1] - bins[0]) / (n2 - 1) : 1;
+              var n3, test;
+              if (binSize >= 0) {
+                test = linelow ? lessThan : lessOrEqual;
+              } else {
+                test = linelow ? greaterOrEqual : greaterThan;
+              }
+              val += binSize * roundingError * (linelow ? -1 : 1) * (binSize >= 0 ? 1 : -1);
+              while (n1 < n2 && c2++ < 100) {
+                n3 = Math.floor((n1 + n2) / 2);
+                if (test(bins[n3], val)) n1 = n3 + 1;
+                else n2 = n3;
+              }
+              if (c2 > 90) loggers2.log("Long binary search...");
+              return n1 - 1;
+            }
+          };
+          function lessThan(a2, b2) {
+            return a2 < b2;
+          }
+          function lessOrEqual(a2, b2) {
+            return a2 <= b2;
+          }
+          function greaterThan(a2, b2) {
+            return a2 > b2;
+          }
+          function greaterOrEqual(a2, b2) {
+            return a2 >= b2;
+          }
+          exports.sorterAsc = function(a2, b2) {
+            return a2 - b2;
+          };
+          exports.sorterDes = function(a2, b2) {
+            return b2 - a2;
+          };
+          exports.distinctVals = function(valsIn) {
+            var vals = valsIn.slice();
+            vals.sort(exports.sorterAsc);
+            var last;
+            for (last = vals.length - 1; last > -1; last--) {
+              if (vals[last] !== BADNUM) break;
+            }
+            var minDiff = vals[last] - vals[0] || 1;
+            var errDiff = minDiff / (last || 1) / 1e4;
+            var newVals = [];
+            var preV;
+            for (var i2 = 0; i2 <= last; i2++) {
+              var v2 = vals[i2];
+              var diff = v2 - preV;
+              if (preV === void 0) {
+                newVals.push(v2);
+                preV = v2;
+              } else if (diff > errDiff) {
+                minDiff = Math.min(minDiff, diff);
+                newVals.push(v2);
+                preV = v2;
+              }
+            }
+            return { vals: newVals, minDiff };
+          };
+          exports.roundUp = function(val, arrayIn, reverse) {
+            var low = 0;
+            var high = arrayIn.length - 1;
+            var mid;
+            var c2 = 0;
+            var dlow = reverse ? 0 : 1;
+            var dhigh = reverse ? 1 : 0;
+            var rounded = reverse ? Math.ceil : Math.floor;
+            while (low < high && c2++ < 100) {
+              mid = rounded((low + high) / 2);
+              if (arrayIn[mid] <= val) low = mid + dlow;
+              else high = mid - dhigh;
+            }
+            return arrayIn[low];
+          };
+          exports.sort = function(array, sortFn) {
+            var notOrdered = 0;
+            var notReversed = 0;
+            for (var i2 = 1; i2 < array.length; i2++) {
+              var pairOrder = sortFn(array[i2], array[i2 - 1]);
+              if (pairOrder < 0) notOrdered = 1;
+              else if (pairOrder > 0) notReversed = 1;
+              if (notOrdered && notReversed) return array.sort(sortFn);
+            }
+            return notReversed ? array : array.reverse();
+          };
+          exports.findIndexOfMin = function(arr, fn) {
+            fn = fn || identity22;
+            var min = Infinity;
+            var ind;
+            for (var i2 = 0; i2 < arr.length; i2++) {
+              var v2 = fn(arr[i2]);
+              if (v2 < min) {
+                min = v2;
+                ind = i2;
+              }
+            }
+            return ind;
+          };
+        }
+      });
+      var require_sort_object_keys = __commonJS({
+        "src/lib/sort_object_keys.js"(exports, module2) {
+          module2.exports = function sortObjectKeys(obj) {
+            return Object.keys(obj).sort();
+          };
+        }
+      });
+      var require_stats = __commonJS({
+        "src/lib/stats.js"(exports) {
+          var isNumeric = require_fast_isnumeric();
+          var isArrayOrTypedArray = require_array().isArrayOrTypedArray;
+          exports.aggNums = function(f2, v2, a2, len2) {
+            var i2, b2;
+            if (!len2 || len2 > a2.length) len2 = a2.length;
+            if (!isNumeric(v2)) v2 = false;
+            if (isArrayOrTypedArray(a2[0])) {
+              b2 = new Array(len2);
+              for (i2 = 0; i2 < len2; i2++) b2[i2] = exports.aggNums(f2, v2, a2[i2]);
+              a2 = b2;
+            }
+            for (i2 = 0; i2 < len2; i2++) {
+              if (!isNumeric(v2)) v2 = a2[i2];
+              else if (isNumeric(a2[i2])) v2 = f2(+v2, +a2[i2]);
+            }
+            return v2;
+          };
+          exports.len = function(data) {
+            return exports.aggNums(function(a2) {
+              return a2 + 1;
+            }, 0, data);
+          };
+          exports.mean = function(data, len2) {
+            if (!len2) len2 = exports.len(data);
+            return exports.aggNums(function(a2, b2) {
+              return a2 + b2;
+            }, 0, data) / len2;
+          };
+          exports.geometricMean = function(data, len2) {
+            if (!len2) len2 = exports.len(data);
+            return Math.pow(exports.aggNums(function(a2, b2) {
+              return a2 * b2;
+            }, 1, data), 1 / len2);
+          };
+          exports.midRange = function(numArr) {
+            if (numArr === void 0 || numArr.length === 0) return void 0;
+            return (exports.aggNums(Math.max, null, numArr) + exports.aggNums(Math.min, null, numArr)) / 2;
+          };
+          exports.variance = function(data, len2, mean) {
+            if (!len2) len2 = exports.len(data);
+            if (!isNumeric(mean)) mean = exports.mean(data, len2);
+            return exports.aggNums(function(a2, b2) {
+              return a2 + Math.pow(b2 - mean, 2);
+            }, 0, data) / len2;
+          };
+          exports.stdev = function(data, len2, mean) {
+            return Math.sqrt(exports.variance(data, len2, mean));
+          };
+          exports.median = function(data) {
+            var b2 = data.slice().sort();
+            return exports.interp(b2, 0.5);
+          };
+          exports.interp = function(arr, n2) {
+            if (!isNumeric(n2)) throw "n should be a finite number";
+            n2 = n2 * arr.length - 0.5;
+            if (n2 < 0) return arr[0];
+            if (n2 > arr.length - 1) return arr[arr.length - 1];
+            var frac = n2 % 1;
+            return frac * arr[Math.ceil(n2)] + (1 - frac) * arr[Math.floor(n2)];
+          };
+        }
+      });
+      var require_angles = __commonJS({
+        "src/lib/angles.js"(exports, module2) {
+          var modModule = require_mod();
+          var mod2 = modModule.mod;
+          var modHalf = modModule.modHalf;
+          var PI2 = Math.PI;
+          var twoPI = 2 * PI2;
+          function deg2rad(deg) {
+            return deg / 180 * PI2;
+          }
+          function rad2deg(rad) {
+            return rad / PI2 * 180;
+          }
+          function isFullCircle(aBnds) {
+            return Math.abs(aBnds[1] - aBnds[0]) > twoPI - 1e-14;
+          }
+          function angleDelta(a2, b2) {
+            return modHalf(b2 - a2, twoPI);
+          }
+          function angleDist(a2, b2) {
+            return Math.abs(angleDelta(a2, b2));
+          }
+          function isAngleInsideSector(a2, aBnds) {
+            if (isFullCircle(aBnds)) return true;
+            var s0, s1;
+            if (aBnds[0] < aBnds[1]) {
+              s0 = aBnds[0];
+              s1 = aBnds[1];
+            } else {
+              s0 = aBnds[1];
+              s1 = aBnds[0];
+            }
+            s0 = mod2(s0, twoPI);
+            s1 = mod2(s1, twoPI);
+            if (s0 > s1) s1 += twoPI;
+            var a0 = mod2(a2, twoPI);
+            var a1 = a0 + twoPI;
+            return a0 >= s0 && a0 <= s1 || a1 >= s0 && a1 <= s1;
+          }
+          function isPtInsideSector(r2, a2, rBnds, aBnds) {
+            if (!isAngleInsideSector(a2, aBnds)) return false;
+            var r0, r1;
+            if (rBnds[0] < rBnds[1]) {
+              r0 = rBnds[0];
+              r1 = rBnds[1];
+            } else {
+              r0 = rBnds[1];
+              r1 = rBnds[0];
+            }
+            return r2 >= r0 && r2 <= r1;
+          }
+          function _path(r0, r1, a0, a1, cx, cy, isClosed) {
+            cx = cx || 0;
+            cy = cy || 0;
+            var isCircle = isFullCircle([a0, a1]);
+            var aStart, aMid, aEnd;
+            var rStart, rEnd;
+            if (isCircle) {
+              aStart = 0;
+              aMid = PI2;
+              aEnd = twoPI;
+            } else {
+              if (a0 < a1) {
+                aStart = a0;
+                aEnd = a1;
+              } else {
+                aStart = a1;
+                aEnd = a0;
+              }
+            }
+            if (r0 < r1) {
+              rStart = r0;
+              rEnd = r1;
+            } else {
+              rStart = r1;
+              rEnd = r0;
+            }
+            function pt2(r2, a2) {
+              return [r2 * Math.cos(a2) + cx, cy - r2 * Math.sin(a2)];
+            }
+            var largeArc = Math.abs(aEnd - aStart) <= PI2 ? 0 : 1;
+            function arc(r2, a2, cw) {
+              return "A" + [r2, r2] + " " + [0, largeArc, cw] + " " + pt2(r2, a2);
+            }
+            var p2;
+            if (isCircle) {
+              if (rStart === null) {
+                p2 = "M" + pt2(rEnd, aStart) + arc(rEnd, aMid, 0) + arc(rEnd, aEnd, 0) + "Z";
+              } else {
+                p2 = "M" + pt2(rStart, aStart) + arc(rStart, aMid, 0) + arc(rStart, aEnd, 0) + "ZM" + pt2(rEnd, aStart) + arc(rEnd, aMid, 1) + arc(rEnd, aEnd, 1) + "Z";
+              }
+            } else {
+              if (rStart === null) {
+                p2 = "M" + pt2(rEnd, aStart) + arc(rEnd, aEnd, 0);
+                if (isClosed) p2 += "L0,0Z";
+              } else {
+                p2 = "M" + pt2(rStart, aStart) + "L" + pt2(rEnd, aStart) + arc(rEnd, aEnd, 0) + "L" + pt2(rStart, aEnd) + arc(rStart, aStart, 1) + "Z";
+              }
+            }
+            return p2;
+          }
+          function pathArc(r2, a0, a1, cx, cy) {
+            return _path(null, r2, a0, a1, cx, cy, 0);
+          }
+          function pathSector(r2, a0, a1, cx, cy) {
+            return _path(null, r2, a0, a1, cx, cy, 1);
+          }
+          function pathAnnulus(r0, r1, a0, a1, cx, cy) {
+            return _path(r0, r1, a0, a1, cx, cy, 1);
+          }
+          module2.exports = {
+            deg2rad,
+            rad2deg,
+            angleDelta,
+            angleDist,
+            isFullCircle,
+            isAngleInsideSector,
+            isPtInsideSector,
+            pathArc,
+            pathSector,
+            pathAnnulus
+          };
+        }
+      });
+      var require_anchor_utils = __commonJS({
+        "src/lib/anchor_utils.js"(exports) {
+          exports.isLeftAnchor = function isLeftAnchor(opts) {
+            return opts.xanchor === "left" || opts.xanchor === "auto" && opts.x <= 1 / 3;
+          };
+          exports.isCenterAnchor = function isCenterAnchor(opts) {
+            return opts.xanchor === "center" || opts.xanchor === "auto" && opts.x > 1 / 3 && opts.x < 2 / 3;
+          };
+          exports.isRightAnchor = function isRightAnchor(opts) {
+            return opts.xanchor === "right" || opts.xanchor === "auto" && opts.x >= 2 / 3;
+          };
+          exports.isTopAnchor = function isTopAnchor(opts) {
+            return opts.yanchor === "top" || opts.yanchor === "auto" && opts.y >= 2 / 3;
+          };
+          exports.isMiddleAnchor = function isMiddleAnchor(opts) {
+            return opts.yanchor === "middle" || opts.yanchor === "auto" && opts.y > 1 / 3 && opts.y < 2 / 3;
+          };
+          exports.isBottomAnchor = function isBottomAnchor(opts) {
+            return opts.yanchor === "bottom" || opts.yanchor === "auto" && opts.y <= 1 / 3;
+          };
+        }
+      });
+      var require_geometry2d = __commonJS({
+        "src/lib/geometry2d.js"(exports) {
+          var mod2 = require_mod().mod;
+          exports.segmentsIntersect = segmentsIntersect;
+          function segmentsIntersect(x1, y1, x2, y2, x3, y3, x4, y4) {
+            var a2 = x2 - x1;
+            var b2 = x3 - x1;
+            var c2 = x4 - x3;
+            var d2 = y2 - y1;
+            var e2 = y3 - y1;
+            var f2 = y4 - y3;
+            var det = a2 * f2 - c2 * d2;
+            if (det === 0) return null;
+            var t4 = (b2 * f2 - c2 * e2) / det;
+            var u2 = (b2 * d2 - a2 * e2) / det;
+            if (u2 < 0 || u2 > 1 || t4 < 0 || t4 > 1) return null;
+            return { x: x1 + a2 * t4, y: y1 + d2 * t4 };
+          }
+          exports.segmentDistance = function segmentDistance(x1, y1, x2, y2, x3, y3, x4, y4) {
+            if (segmentsIntersect(x1, y1, x2, y2, x3, y3, x4, y4)) return 0;
+            var x12 = x2 - x1;
+            var y12 = y2 - y1;
+            var x34 = x4 - x3;
+            var y34 = y4 - y3;
+            var ll12 = x12 * x12 + y12 * y12;
+            var ll34 = x34 * x34 + y34 * y34;
+            var dist2 = Math.min(
+              perpDistance2(x12, y12, ll12, x3 - x1, y3 - y1),
+              perpDistance2(x12, y12, ll12, x4 - x1, y4 - y1),
+              perpDistance2(x34, y34, ll34, x1 - x3, y1 - y3),
+              perpDistance2(x34, y34, ll34, x2 - x3, y2 - y3)
+            );
+            return Math.sqrt(dist2);
+          };
+          function perpDistance2(xab, yab, llab, xac, yac) {
+            var fcAB = xac * xab + yac * yab;
+            if (fcAB < 0) {
+              return xac * xac + yac * yac;
+            } else if (fcAB > llab) {
+              var xbc = xac - xab;
+              var ybc = yac - yab;
+              return xbc * xbc + ybc * ybc;
+            } else {
+              var crossProduct = xac * yab - yac * xab;
+              return crossProduct * crossProduct / llab;
+            }
+          }
+          var locationCache;
+          var workingPath;
+          var workingTextWidth;
+          exports.getTextLocation = function getTextLocation(path, totalPathLen, positionOnPath, textWidth) {
+            if (path !== workingPath || textWidth !== workingTextWidth) {
+              locationCache = {};
+              workingPath = path;
+              workingTextWidth = textWidth;
+            }
+            if (locationCache[positionOnPath]) {
+              return locationCache[positionOnPath];
+            }
+            var p0 = path.getPointAtLength(mod2(positionOnPath - textWidth / 2, totalPathLen));
+            var p1 = path.getPointAtLength(mod2(positionOnPath + textWidth / 2, totalPathLen));
+            var theta = Math.atan((p1.y - p0.y) / (p1.x - p0.x));
+            var pCenter = path.getPointAtLength(mod2(positionOnPath, totalPathLen));
+            var x2 = (pCenter.x * 4 + p0.x + p1.x) / 6;
+            var y2 = (pCenter.y * 4 + p0.y + p1.y) / 6;
+            var out = { x: x2, y: y2, theta };
+            locationCache[positionOnPath] = out;
+            return out;
+          };
+          exports.clearLocationCache = function() {
+            workingPath = null;
+          };
+          exports.getVisibleSegment = function getVisibleSegment(path, bounds, buffer) {
+            var left = bounds.left;
+            var right = bounds.right;
+            var top = bounds.top;
+            var bottom = bounds.bottom;
+            var pMin = 0;
+            var pTotal = path.getTotalLength();
+            var pMax = pTotal;
+            var pt0, ptTotal;
+            function getDistToPlot(len2) {
+              var pt2 = path.getPointAtLength(len2);
+              if (len2 === 0) pt0 = pt2;
+              else if (len2 === pTotal) ptTotal = pt2;
+              var dx = pt2.x < left ? left - pt2.x : pt2.x > right ? pt2.x - right : 0;
+              var dy = pt2.y < top ? top - pt2.y : pt2.y > bottom ? pt2.y - bottom : 0;
+              return Math.sqrt(dx * dx + dy * dy);
+            }
+            var distToPlot = getDistToPlot(pMin);
+            while (distToPlot) {
+              pMin += distToPlot + buffer;
+              if (pMin > pMax) return;
+              distToPlot = getDistToPlot(pMin);
+            }
+            distToPlot = getDistToPlot(pMax);
+            while (distToPlot) {
+              pMax -= distToPlot + buffer;
+              if (pMin > pMax) return;
+              distToPlot = getDistToPlot(pMax);
+            }
+            return {
+              min: pMin,
+              max: pMax,
+              len: pMax - pMin,
+              total: pTotal,
+              isClosed: pMin === 0 && pMax === pTotal && Math.abs(pt0.x - ptTotal.x) < 0.1 && Math.abs(pt0.y - ptTotal.y) < 0.1
+            };
+          };
+          exports.findPointOnPath = function findPointOnPath(path, val, coord, opts) {
+            opts = opts || {};
+            var pathLength = opts.pathLength || path.getTotalLength();
+            var tolerance = opts.tolerance || 1e-3;
+            var iterationLimit = opts.iterationLimit || 30;
+            var mul = path.getPointAtLength(0)[coord] > path.getPointAtLength(pathLength)[coord] ? -1 : 1;
+            var i2 = 0;
+            var b0 = 0;
+            var b1 = pathLength;
+            var mid;
+            var pt2;
+            var diff;
+            while (i2 < iterationLimit) {
+              mid = (b0 + b1) / 2;
+              pt2 = path.getPointAtLength(mid);
+              diff = pt2[coord] - val;
+              if (Math.abs(diff) < tolerance) {
+                return pt2;
+              } else {
+                if (mul * diff > 0) {
+                  b1 = mid;
+                } else {
+                  b0 = mid;
+                }
+                i2++;
+              }
+            }
+            return pt2;
+          };
+        }
+      });
+      var require_throttle = __commonJS({
+        "src/lib/throttle.js"(exports) {
+          var timerCache = {};
+          exports.throttle = function throttle(id2, minInterval, callback) {
+            var cache = timerCache[id2];
+            var now = Date.now();
+            if (!cache) {
+              for (var idi in timerCache) {
+                if (timerCache[idi].ts < now - 6e4) {
+                  delete timerCache[idi];
+                }
+              }
+              cache = timerCache[id2] = { ts: 0, timer: null };
+            }
+            _clearTimeout(cache);
+            function exec() {
+              callback();
+              cache.ts = Date.now();
+              if (cache.onDone) {
+                cache.onDone();
+                cache.onDone = null;
+              }
+            }
+            if (now > cache.ts + minInterval) {
+              exec();
+              return;
+            }
+            cache.timer = setTimeout(function() {
+              exec();
+              cache.timer = null;
+            }, minInterval);
+          };
+          exports.done = function(id2) {
+            var cache = timerCache[id2];
+            if (!cache || !cache.timer) return Promise.resolve();
+            return new Promise(function(resolve) {
+              var previousOnDone = cache.onDone;
+              cache.onDone = function onDone() {
+                if (previousOnDone) previousOnDone();
+                resolve();
+                cache.onDone = null;
+              };
+            });
+          };
+          exports.clear = function(id2) {
+            if (id2) {
+              _clearTimeout(timerCache[id2]);
+              delete timerCache[id2];
+            } else {
+              for (var idi in timerCache) exports.clear(idi);
+            }
+          };
+          function _clearTimeout(cache) {
+            if (cache && cache.timer !== null) {
+              clearTimeout(cache.timer);
+              cache.timer = null;
+            }
+          }
+        }
+      });
+      var require_clear_responsive = __commonJS({
+        "src/lib/clear_responsive.js"(exports, module2) {
+          module2.exports = function clearResponsive(gd2) {
+            if (gd2._responsiveChartHandler) {
+              window.removeEventListener("resize", gd2._responsiveChartHandler);
+              delete gd2._responsiveChartHandler;
+            }
+          };
+        }
+      });
+      var require_is_mobile = __commonJS({
+        "node_modules/is-mobile/index.js"(exports, module2) {
+          module2.exports = isMobile2;
+          module2.exports.isMobile = isMobile2;
+          module2.exports.default = isMobile2;
+          var mobileRE = /(android|bb\d+|meego).+mobile|armv7l|avantgo|bada\/|blackberry|blazer|compal|elaine|fennec|hiptop|iemobile|ip(hone|od)|iris|kindle|lge |maemo|midp|mmp|mobile.+firefox|netfront|opera m(ob|in)i|palm( os)?|phone|p(ixi|re)\/|plucker|pocket|psp|series[46]0|samsungbrowser.*mobile|symbian|treo|up\.(browser|link)|vodafone|wap|windows (ce|phone)|xda|xiino/i;
+          var notMobileRE = /CrOS/;
+          var tabletRE = /android|ipad|playbook|silk/i;
+          function isMobile2(opts) {
+            if (!opts) opts = {};
+            let ua2 = opts.ua;
+            if (!ua2 && typeof navigator !== "undefined") ua2 = navigator.userAgent;
+            if (ua2 && ua2.headers && typeof ua2.headers["user-agent"] === "string") {
+              ua2 = ua2.headers["user-agent"];
+            }
+            if (typeof ua2 !== "string") return false;
+            let result = mobileRE.test(ua2) && !notMobileRE.test(ua2) || !!opts.tablet && tabletRE.test(ua2);
+            if (!result && opts.tablet && opts.featureDetect && navigator && navigator.maxTouchPoints > 1 && ua2.indexOf("Macintosh") !== -1 && ua2.indexOf("Safari") !== -1) {
+              result = true;
+            }
+            return result;
+          }
+        }
+      });
+      var require_preserve_drawing_buffer = __commonJS({
+        "src/lib/preserve_drawing_buffer.js"(exports, module2) {
+          var isNumeric = require_fast_isnumeric();
+          var isMobileOrTablet = require_is_mobile();
+          module2.exports = function preserveDrawingBuffer(opts) {
+            var ua2;
+            if (opts && opts.hasOwnProperty("userAgent")) {
+              ua2 = opts.userAgent;
+            } else {
+              ua2 = getUserAgent();
+            }
+            if (typeof ua2 !== "string") return true;
+            var enable2 = isMobileOrTablet({
+              ua: { headers: { "user-agent": ua2 } },
+              tablet: true,
+              featureDetect: false
+            });
+            if (!enable2) {
+              var allParts = ua2.split(" ");
+              for (var i2 = 1; i2 < allParts.length; i2++) {
+                var part = allParts[i2];
+                if (part.indexOf("Safari") !== -1) {
+                  for (var k2 = i2 - 1; k2 > -1; k2--) {
+                    var prevPart = allParts[k2];
+                    if (prevPart.slice(0, 8) === "Version/") {
+                      var v2 = prevPart.slice(8).split(".")[0];
+                      if (isNumeric(v2)) v2 = +v2;
+                      if (v2 >= 13) return true;
+                    }
+                  }
+                }
+              }
+            }
+            return enable2;
+          };
+          function getUserAgent() {
+            var ua2;
+            if (typeof navigator !== "undefined") {
+              ua2 = navigator.userAgent;
+            }
+            if (ua2 && ua2.headers && typeof ua2.headers["user-agent"] === "string") {
+              ua2 = ua2.headers["user-agent"];
+            }
+            return ua2;
+          }
+        }
+      });
+      var require_make_trace_groups = __commonJS({
+        "src/lib/make_trace_groups.js"(exports, module2) {
+          var d3 = require_d3();
+          module2.exports = function makeTraceGroups(traceLayer, cdModule, cls) {
+            var traces = traceLayer.selectAll("g." + cls.replace(/\s/g, ".")).data(cdModule, function(cd2) {
+              return cd2[0].trace.uid;
+            });
+            traces.exit().remove();
+            traces.enter().append("g").attr("class", cls);
+            traces.order();
+            var k2 = traceLayer.classed("rangeplot") ? "nodeRangePlot3" : "node3";
+            traces.each(function(cd2) {
+              cd2[0][k2] = d3.select(this);
+            });
+            return traces;
+          };
+        }
+      });
+      var require_localize = __commonJS({
+        "src/lib/localize.js"(exports, module2) {
+          var Registry = require_registry();
+          module2.exports = function localize(gd2, s2) {
+            var locale = gd2._context.locale;
+            for (var i2 = 0; i2 < 2; i2++) {
+              var locales = gd2._context.locales;
+              for (var j2 = 0; j2 < 2; j2++) {
+                var dict = (locales[locale] || {}).dictionary;
+                if (dict) {
+                  var out = dict[s2];
+                  if (out) return out;
+                }
+                locales = Registry.localeRegistry;
+              }
+              var baseLocale = locale.split("-")[0];
+              if (baseLocale === locale) break;
+              locale = baseLocale;
+            }
+            return s2;
+          };
+        }
+      });
+      var require_filter_unique = __commonJS({
+        "src/lib/filter_unique.js"(exports, module2) {
+          module2.exports = function filterUnique(array) {
+            var seen2 = {};
+            var out = [];
+            var j2 = 0;
+            for (var i2 = 0; i2 < array.length; i2++) {
+              var item = array[i2];
+              if (seen2[item] !== 1) {
+                seen2[item] = 1;
+                out[j2++] = item;
+              }
+            }
+            return out;
+          };
+        }
+      });
+      var require_filter_visible = __commonJS({
+        "src/lib/filter_visible.js"(exports, module2) {
+          module2.exports = function filterVisible(container) {
+            var filterFn = isCalcData(container) ? calcDataFilter : baseFilter;
+            var out = [];
+            for (var i2 = 0; i2 < container.length; i2++) {
+              var item = container[i2];
+              if (filterFn(item)) out.push(item);
+            }
+            return out;
+          };
+          function baseFilter(item) {
+            return item.visible === true;
+          }
+          function calcDataFilter(item) {
+            var trace = item[0].trace;
+            return trace.visible === true && trace._length !== 0;
+          }
+          function isCalcData(cont) {
+            return Array.isArray(cont) && Array.isArray(cont[0]) && cont[0][0] && cont[0][0].trace;
+          }
+        }
+      });
+      var require_increment = __commonJS({
+        "src/lib/increment.js"(exports, module2) {
+          module2.exports = function incrementNumeric(x2, delta) {
+            if (!delta) return x2;
+            var scale2 = 1 / Math.abs(delta);
+            var newX = scale2 > 1 ? (scale2 * x2 + scale2 * delta) / scale2 : x2 + delta;
+            var lenX1 = String(newX).length;
+            if (lenX1 > 16) {
+              var lenDt = String(delta).length;
+              var lenX0 = String(x2).length;
+              if (lenX1 >= lenX0 + lenDt) {
+                var s2 = parseFloat(newX).toPrecision(12);
+                if (s2.indexOf("e+") === -1) newX = +s2;
+              }
+            }
+            return newX;
+          };
+        }
+      });
+      var require_clean_number = __commonJS({
+        "src/lib/clean_number.js"(exports, module2) {
+          var isNumeric = require_fast_isnumeric();
+          var BADNUM = require_numerical().BADNUM;
+          var JUNK = /^['"%,$#\s']+|[, ]|['"%,$#\s']+$/g;
+          module2.exports = function cleanNumber(v2) {
+            if (typeof v2 === "string") {
+              v2 = v2.replace(JUNK, "");
+            }
+            if (isNumeric(v2)) return Number(v2);
+            return BADNUM;
+          };
+        }
+      });
+      var require_lib = __commonJS({
+        "src/lib/index.js"(exports, module2) {
+          var d3 = require_d3();
+          var utcFormat = require_d3_time_format().utcFormat;
+          var d3Format = require_d3_format().format;
+          var isNumeric = require_fast_isnumeric();
+          var numConstants = require_numerical();
+          var MAX_SAFE = numConstants.FP_SAFE;
+          var MIN_SAFE = -MAX_SAFE;
+          var BADNUM = numConstants.BADNUM;
+          var lib = module2.exports = {};
+          lib.adjustFormat = function adjustFormat(formatStr) {
+            if (!formatStr || /^\d[.]\df/.test(formatStr) || /[.]\d%/.test(formatStr)) return formatStr;
+            if (formatStr === "0.f") return "~f";
+            if (/^\d%/.test(formatStr)) return "~%";
+            if (/^\ds/.test(formatStr)) return "~s";
+            if (!/^[~,.0$]/.test(formatStr) && /[&fps]/.test(formatStr)) return "~" + formatStr;
+            return formatStr;
+          };
+          var seenBadFormats = {};
+          lib.warnBadFormat = function(f2) {
+            var key = String(f2);
+            if (!seenBadFormats[key]) {
+              seenBadFormats[key] = 1;
+              lib.warn('encountered bad format: "' + key + '"');
+            }
+          };
+          lib.noFormat = function(value) {
+            return String(value);
+          };
+          lib.numberFormat = function(formatStr) {
+            var fn;
+            try {
+              fn = d3Format(lib.adjustFormat(formatStr));
+            } catch (e2) {
+              lib.warnBadFormat(formatStr);
+              return lib.noFormat;
+            }
+            return fn;
+          };
+          lib.nestedProperty = require_nested_property();
+          lib.keyedContainer = require_keyed_container();
+          lib.relativeAttr = require_relative_attr();
+          lib.isPlainObject = require_is_plain_object();
+          lib.toLogRange = require_to_log_range();
+          lib.relinkPrivateKeys = require_relink_private();
+          var arrayModule = require_array();
+          lib.isArrayBuffer = arrayModule.isArrayBuffer;
+          lib.isTypedArray = arrayModule.isTypedArray;
+          lib.isArrayOrTypedArray = arrayModule.isArrayOrTypedArray;
+          lib.isArray1D = arrayModule.isArray1D;
+          lib.ensureArray = arrayModule.ensureArray;
+          lib.concat = arrayModule.concat;
+          lib.maxRowLength = arrayModule.maxRowLength;
+          lib.minRowLength = arrayModule.minRowLength;
+          var modModule = require_mod();
+          lib.mod = modModule.mod;
+          lib.modHalf = modModule.modHalf;
+          var coerceModule = require_coerce();
+          lib.valObjectMeta = coerceModule.valObjectMeta;
+          lib.coerce = coerceModule.coerce;
+          lib.coerce2 = coerceModule.coerce2;
+          lib.coerceFont = coerceModule.coerceFont;
+          lib.coercePattern = coerceModule.coercePattern;
+          lib.coerceHoverinfo = coerceModule.coerceHoverinfo;
+          lib.coerceSelectionMarkerOpacity = coerceModule.coerceSelectionMarkerOpacity;
+          lib.validate = coerceModule.validate;
+          var datesModule = require_dates();
+          lib.dateTime2ms = datesModule.dateTime2ms;
+          lib.isDateTime = datesModule.isDateTime;
+          lib.ms2DateTime = datesModule.ms2DateTime;
+          lib.ms2DateTimeLocal = datesModule.ms2DateTimeLocal;
+          lib.cleanDate = datesModule.cleanDate;
+          lib.isJSDate = datesModule.isJSDate;
+          lib.formatDate = datesModule.formatDate;
+          lib.incrementMonth = datesModule.incrementMonth;
+          lib.dateTick0 = datesModule.dateTick0;
+          lib.dfltRange = datesModule.dfltRange;
+          lib.findExactDates = datesModule.findExactDates;
+          lib.MIN_MS = datesModule.MIN_MS;
+          lib.MAX_MS = datesModule.MAX_MS;
+          var searchModule = require_search();
+          lib.findBin = searchModule.findBin;
+          lib.sorterAsc = searchModule.sorterAsc;
+          lib.sorterDes = searchModule.sorterDes;
+          lib.distinctVals = searchModule.distinctVals;
+          lib.roundUp = searchModule.roundUp;
+          lib.sort = searchModule.sort;
+          lib.findIndexOfMin = searchModule.findIndexOfMin;
+          lib.sortObjectKeys = require_sort_object_keys();
+          var statsModule = require_stats();
+          lib.aggNums = statsModule.aggNums;
+          lib.len = statsModule.len;
+          lib.mean = statsModule.mean;
+          lib.geometricMean = statsModule.geometricMean;
+          lib.median = statsModule.median;
+          lib.midRange = statsModule.midRange;
+          lib.variance = statsModule.variance;
+          lib.stdev = statsModule.stdev;
+          lib.interp = statsModule.interp;
+          var matrixModule = require_matrix();
+          lib.init2dArray = matrixModule.init2dArray;
+          lib.transposeRagged = matrixModule.transposeRagged;
+          lib.dot = matrixModule.dot;
+          lib.translationMatrix = matrixModule.translationMatrix;
+          lib.rotationMatrix = matrixModule.rotationMatrix;
+          lib.rotationXYMatrix = matrixModule.rotationXYMatrix;
+          lib.apply3DTransform = matrixModule.apply3DTransform;
+          lib.apply2DTransform = matrixModule.apply2DTransform;
+          lib.apply2DTransform2 = matrixModule.apply2DTransform2;
+          lib.convertCssMatrix = matrixModule.convertCssMatrix;
+          lib.inverseTransformMatrix = matrixModule.inverseTransformMatrix;
+          var anglesModule = require_angles();
+          lib.deg2rad = anglesModule.deg2rad;
+          lib.rad2deg = anglesModule.rad2deg;
+          lib.angleDelta = anglesModule.angleDelta;
+          lib.angleDist = anglesModule.angleDist;
+          lib.isFullCircle = anglesModule.isFullCircle;
+          lib.isAngleInsideSector = anglesModule.isAngleInsideSector;
+          lib.isPtInsideSector = anglesModule.isPtInsideSector;
+          lib.pathArc = anglesModule.pathArc;
+          lib.pathSector = anglesModule.pathSector;
+          lib.pathAnnulus = anglesModule.pathAnnulus;
+          var anchorUtils = require_anchor_utils();
+          lib.isLeftAnchor = anchorUtils.isLeftAnchor;
+          lib.isCenterAnchor = anchorUtils.isCenterAnchor;
+          lib.isRightAnchor = anchorUtils.isRightAnchor;
+          lib.isTopAnchor = anchorUtils.isTopAnchor;
+          lib.isMiddleAnchor = anchorUtils.isMiddleAnchor;
+          lib.isBottomAnchor = anchorUtils.isBottomAnchor;
+          var geom2dModule = require_geometry2d();
+          lib.segmentsIntersect = geom2dModule.segmentsIntersect;
+          lib.segmentDistance = geom2dModule.segmentDistance;
+          lib.getTextLocation = geom2dModule.getTextLocation;
+          lib.clearLocationCache = geom2dModule.clearLocationCache;
+          lib.getVisibleSegment = geom2dModule.getVisibleSegment;
+          lib.findPointOnPath = geom2dModule.findPointOnPath;
+          var extendModule = require_extend();
+          lib.extendFlat = extendModule.extendFlat;
+          lib.extendDeep = extendModule.extendDeep;
+          lib.extendDeepAll = extendModule.extendDeepAll;
+          lib.extendDeepNoArrays = extendModule.extendDeepNoArrays;
+          var loggersModule = require_loggers();
+          lib.log = loggersModule.log;
+          lib.warn = loggersModule.warn;
+          lib.error = loggersModule.error;
+          var regexModule = require_regex();
+          lib.counterRegex = regexModule.counter;
+          var throttleModule = require_throttle();
+          lib.throttle = throttleModule.throttle;
+          lib.throttleDone = throttleModule.done;
+          lib.clearThrottle = throttleModule.clear;
+          var domModule = require_dom();
+          lib.getGraphDiv = domModule.getGraphDiv;
+          lib.isPlotDiv = domModule.isPlotDiv;
+          lib.removeElement = domModule.removeElement;
+          lib.addStyleRule = domModule.addStyleRule;
+          lib.addRelatedStyleRule = domModule.addRelatedStyleRule;
+          lib.deleteRelatedStyleRule = domModule.deleteRelatedStyleRule;
+          lib.setStyleOnHover = domModule.setStyleOnHover;
+          lib.getFullTransformMatrix = domModule.getFullTransformMatrix;
+          lib.getElementTransformMatrix = domModule.getElementTransformMatrix;
+          lib.getElementAndAncestors = domModule.getElementAndAncestors;
+          lib.equalDomRects = domModule.equalDomRects;
+          lib.clearResponsive = require_clear_responsive();
+          lib.preserveDrawingBuffer = require_preserve_drawing_buffer();
+          lib.makeTraceGroups = require_make_trace_groups();
+          lib._ = require_localize();
+          lib.notifier = require_notifier();
+          lib.filterUnique = require_filter_unique();
+          lib.filterVisible = require_filter_visible();
+          lib.pushUnique = require_push_unique();
+          lib.increment = require_increment();
+          lib.cleanNumber = require_clean_number();
+          lib.ensureNumber = function ensureNumber(v2) {
+            if (!isNumeric(v2)) return BADNUM;
+            v2 = Number(v2);
+            return v2 > MAX_SAFE || v2 < MIN_SAFE ? BADNUM : v2;
+          };
+          lib.isIndex = function(v2, len2) {
+            if (len2 !== void 0 && v2 >= len2) return false;
+            return isNumeric(v2) && v2 >= 0 && v2 % 1 === 0;
+          };
+          lib.noop = require_noop();
+          lib.identity = require_identity2();
+          lib.repeat = function(v2, cnt) {
+            var out = new Array(cnt);
+            for (var i2 = 0; i2 < cnt; i2++) {
+              out[i2] = v2;
+            }
+            return out;
+          };
+          lib.swapAttrs = function(cont, attrList, part1, part2) {
+            if (!part1) part1 = "x";
+            if (!part2) part2 = "y";
+            for (var i2 = 0; i2 < attrList.length; i2++) {
+              var attr = attrList[i2];
+              var xp = lib.nestedProperty(cont, attr.replace("?", part1));
+              var yp = lib.nestedProperty(cont, attr.replace("?", part2));
+              var temp = xp.get();
+              xp.set(yp.get());
+              yp.set(temp);
+            }
+          };
+          lib.raiseToTop = function raiseToTop(elem) {
+            elem.parentNode.appendChild(elem);
+          };
+          lib.cancelTransition = function(selection) {
+            return selection.transition().duration(0);
+          };
+          lib.constrain = function(v2, v0, v1) {
+            if (v0 > v1) return Math.max(v1, Math.min(v0, v2));
+            return Math.max(v0, Math.min(v1, v2));
+          };
+          lib.bBoxIntersect = function(a2, b2, pad) {
+            pad = pad || 0;
+            return a2.left <= b2.right + pad && b2.left <= a2.right + pad && a2.top <= b2.bottom + pad && b2.top <= a2.bottom + pad;
+          };
+          lib.simpleMap = function(array, func, x1, x2, opts) {
+            var len2 = array.length;
+            var out = new Array(len2);
+            for (var i2 = 0; i2 < len2; i2++) out[i2] = func(array[i2], x1, x2, opts);
+            return out;
+          };
+          lib.randstr = function randstr(existing, bits, base, _recursion) {
+            if (!base) base = 16;
+            if (bits === void 0) bits = 24;
+            if (bits <= 0) return "0";
+            var digits = Math.log(Math.pow(2, bits)) / Math.log(base);
+            var res = "";
+            var i2, b2, x2;
+            for (i2 = 2; digits === Infinity; i2 *= 2) {
+              digits = Math.log(Math.pow(2, bits / i2)) / Math.log(base) * i2;
+            }
+            var rem = digits - Math.floor(digits);
+            for (i2 = 0; i2 < Math.floor(digits); i2++) {
+              x2 = Math.floor(Math.random() * base).toString(base);
+              res = x2 + res;
+            }
+            if (rem) {
+              b2 = Math.pow(base, rem);
+              x2 = Math.floor(Math.random() * b2).toString(base);
+              res = x2 + res;
+            }
+            var parsed = parseInt(res, base);
+            if (existing && existing[res] || parsed !== Infinity && parsed >= Math.pow(2, bits)) {
+              if (_recursion > 10) {
+                lib.warn("randstr failed uniqueness");
+                return res;
+              }
+              return randstr(existing, bits, base, (_recursion || 0) + 1);
+            } else return res;
+          };
+          lib.OptionControl = function(opt, optname) {
+            if (!opt) opt = {};
+            if (!optname) optname = "opt";
+            var self2 = {};
+            self2.optionList = [];
+            self2._newoption = function(optObj) {
+              optObj[optname] = opt;
+              self2[optObj.name] = optObj;
+              self2.optionList.push(optObj);
+            };
+            self2["_" + optname] = opt;
+            return self2;
+          };
+          lib.smooth = function(arrayIn, FWHM) {
+            FWHM = Math.round(FWHM) || 0;
+            if (FWHM < 2) return arrayIn;
+            var alen = arrayIn.length;
+            var alen2 = 2 * alen;
+            var wlen = 2 * FWHM - 1;
+            var w2 = new Array(wlen);
+            var arrayOut = new Array(alen);
+            var i2;
+            var j2;
+            var k2;
+            var v2;
+            for (i2 = 0; i2 < wlen; i2++) {
+              w2[i2] = (1 - Math.cos(Math.PI * (i2 + 1) / FWHM)) / (2 * FWHM);
+            }
+            for (i2 = 0; i2 < alen; i2++) {
+              v2 = 0;
+              for (j2 = 0; j2 < wlen; j2++) {
+                k2 = i2 + j2 + 1 - FWHM;
+                if (k2 < -alen) k2 -= alen2 * Math.round(k2 / alen2);
+                else if (k2 >= alen2) k2 -= alen2 * Math.floor(k2 / alen2);
+                if (k2 < 0) k2 = -1 - k2;
+                else if (k2 >= alen) k2 = alen2 - 1 - k2;
+                v2 += arrayIn[k2] * w2[j2];
+              }
+              arrayOut[i2] = v2;
+            }
+            return arrayOut;
+          };
+          lib.syncOrAsync = function(sequence, arg, finalStep) {
+            var ret, fni;
+            function continueAsync() {
+              return lib.syncOrAsync(sequence, arg, finalStep);
+            }
+            while (sequence.length) {
+              fni = sequence.splice(0, 1)[0];
+              ret = fni(arg);
+              if (ret && ret.then) {
+                return ret.then(continueAsync);
+              }
+            }
+            return finalStep && finalStep(arg);
+          };
+          lib.stripTrailingSlash = function(str) {
+            if (str.slice(-1) === "/") return str.slice(0, -1);
+            return str;
+          };
+          lib.noneOrAll = function(containerIn, containerOut, attrList) {
+            if (!containerIn) return;
+            var hasAny = false;
+            var hasAll = true;
+            var i2;
+            var val;
+            for (i2 = 0; i2 < attrList.length; i2++) {
+              val = containerIn[attrList[i2]];
+              if (val !== void 0 && val !== null) hasAny = true;
+              else hasAll = false;
+            }
+            if (hasAny && !hasAll) {
+              for (i2 = 0; i2 < attrList.length; i2++) {
+                containerIn[attrList[i2]] = containerOut[attrList[i2]];
+              }
+            }
+          };
+          lib.mergeArray = function(traceAttr, cd2, cdAttr, fn) {
+            var hasFn = typeof fn === "function";
+            if (lib.isArrayOrTypedArray(traceAttr)) {
+              var imax = Math.min(traceAttr.length, cd2.length);
+              for (var i2 = 0; i2 < imax; i2++) {
+                var v2 = traceAttr[i2];
+                cd2[i2][cdAttr] = hasFn ? fn(v2) : v2;
+              }
+            }
+          };
+          lib.mergeArrayCastPositive = function(traceAttr, cd2, cdAttr) {
+            return lib.mergeArray(traceAttr, cd2, cdAttr, function(v2) {
+              var w2 = +v2;
+              return !isFinite(w2) ? 0 : w2 > 0 ? w2 : 0;
+            });
+          };
+          lib.fillArray = function(traceAttr, cd2, cdAttr, fn) {
+            fn = fn || lib.identity;
+            if (lib.isArrayOrTypedArray(traceAttr)) {
+              for (var i2 = 0; i2 < cd2.length; i2++) {
+                cd2[i2][cdAttr] = fn(traceAttr[i2]);
+              }
+            }
+          };
+          lib.castOption = function(trace, ptNumber, astr, fn) {
+            fn = fn || lib.identity;
+            var val = lib.nestedProperty(trace, astr).get();
+            if (lib.isArrayOrTypedArray(val)) {
+              if (Array.isArray(ptNumber) && lib.isArrayOrTypedArray(val[ptNumber[0]])) {
+                return fn(val[ptNumber[0]][ptNumber[1]]);
+              } else {
+                return fn(val[ptNumber]);
+              }
+            } else {
+              return val;
+            }
+          };
+          lib.extractOption = function(calcPt, trace, calcKey, traceKey) {
+            if (calcKey in calcPt) return calcPt[calcKey];
+            var traceVal = lib.nestedProperty(trace, traceKey).get();
+            if (!Array.isArray(traceVal)) return traceVal;
+          };
+          function makePtIndex2PtNumber(indexToPoints) {
+            var ptIndex2ptNumber = {};
+            for (var k2 in indexToPoints) {
+              var pts = indexToPoints[k2];
+              for (var j2 = 0; j2 < pts.length; j2++) {
+                ptIndex2ptNumber[pts[j2]] = +k2;
+              }
+            }
+            return ptIndex2ptNumber;
+          }
+          lib.tagSelected = function(calcTrace, trace, ptNumber2cdIndex) {
+            var selectedpoints = trace.selectedpoints;
+            var indexToPoints = trace._indexToPoints;
+            var ptIndex2ptNumber;
+            if (indexToPoints) {
+              ptIndex2ptNumber = makePtIndex2PtNumber(indexToPoints);
+            }
+            function isCdIndexValid(v2) {
+              return v2 !== void 0 && v2 < calcTrace.length;
+            }
+            for (var i2 = 0; i2 < selectedpoints.length; i2++) {
+              var ptIndex = selectedpoints[i2];
+              if (lib.isIndex(ptIndex) || lib.isArrayOrTypedArray(ptIndex) && lib.isIndex(ptIndex[0]) && lib.isIndex(ptIndex[1])) {
+                var ptNumber = ptIndex2ptNumber ? ptIndex2ptNumber[ptIndex] : ptIndex;
+                var cdIndex = ptNumber2cdIndex ? ptNumber2cdIndex[ptNumber] : ptNumber;
+                if (isCdIndexValid(cdIndex)) {
+                  calcTrace[cdIndex].selected = 1;
+                }
+              }
+            }
+          };
+          lib.selIndices2selPoints = function(trace) {
+            var selectedpoints = trace.selectedpoints;
+            var indexToPoints = trace._indexToPoints;
+            if (indexToPoints) {
+              var ptIndex2ptNumber = makePtIndex2PtNumber(indexToPoints);
+              var out = [];
+              for (var i2 = 0; i2 < selectedpoints.length; i2++) {
+                var ptIndex = selectedpoints[i2];
+                if (lib.isIndex(ptIndex)) {
+                  var ptNumber = ptIndex2ptNumber[ptIndex];
+                  if (lib.isIndex(ptNumber)) {
+                    out.push(ptNumber);
+                  }
+                }
+              }
+              return out;
+            } else {
+              return selectedpoints;
+            }
+          };
+          lib.getTargetArray = function(trace, transformOpts) {
+            var target = transformOpts.target;
+            if (typeof target === "string" && target) {
+              var array = lib.nestedProperty(trace, target).get();
+              return lib.isArrayOrTypedArray(array) ? array : false;
+            } else if (lib.isArrayOrTypedArray(target)) {
+              return target;
+            }
+            return false;
+          };
+          function minExtend(obj1, obj2, opt) {
+            var objOut = {};
+            if (typeof obj2 !== "object") obj2 = {};
+            var arrayLen = opt === "pieLike" ? -1 : 3;
+            var keys = Object.keys(obj1);
+            var i2, k2, v2;
+            for (i2 = 0; i2 < keys.length; i2++) {
+              k2 = keys[i2];
+              v2 = obj1[k2];
+              if (k2.charAt(0) === "_" || typeof v2 === "function") continue;
+              else if (k2 === "module") objOut[k2] = v2;
+              else if (Array.isArray(v2)) {
+                if (k2 === "colorscale" || arrayLen === -1) {
+                  objOut[k2] = v2.slice();
+                } else {
+                  objOut[k2] = v2.slice(0, arrayLen);
+                }
+              } else if (lib.isTypedArray(v2)) {
+                if (arrayLen === -1) {
+                  objOut[k2] = v2.subarray();
+                } else {
+                  objOut[k2] = v2.subarray(0, arrayLen);
+                }
+              } else if (v2 && typeof v2 === "object") objOut[k2] = minExtend(obj1[k2], obj2[k2], opt);
+              else objOut[k2] = v2;
+            }
+            keys = Object.keys(obj2);
+            for (i2 = 0; i2 < keys.length; i2++) {
+              k2 = keys[i2];
+              v2 = obj2[k2];
+              if (typeof v2 !== "object" || !(k2 in objOut) || typeof objOut[k2] !== "object") {
+                objOut[k2] = v2;
+              }
+            }
+            return objOut;
+          }
+          lib.minExtend = minExtend;
+          lib.titleCase = function(s2) {
+            return s2.charAt(0).toUpperCase() + s2.slice(1);
+          };
+          lib.containsAny = function(s2, fragments2) {
+            for (var i2 = 0; i2 < fragments2.length; i2++) {
+              if (s2.indexOf(fragments2[i2]) !== -1) return true;
+            }
+            return false;
+          };
+          var IS_SAFARI_REGEX = /Version\/[\d\.]+.*Safari/;
+          lib.isSafari = function() {
+            return IS_SAFARI_REGEX.test(window.navigator.userAgent);
+          };
+          var IS_IOS_REGEX = /iPad|iPhone|iPod/;
+          lib.isIOS = function() {
+            return IS_IOS_REGEX.test(window.navigator.userAgent);
+          };
+          var IS_MAC_WKWEBVIEW_REGEX = /Macintosh.+AppleWebKit.+Gecko\)$/;
+          lib.isMacWKWebView = () => IS_MAC_WKWEBVIEW_REGEX.test(window.navigator.userAgent);
+          var FIREFOX_VERSION_REGEX = /Firefox\/(\d+)\.\d+/;
+          lib.getFirefoxVersion = function() {
+            var match = FIREFOX_VERSION_REGEX.exec(window.navigator.userAgent);
+            if (match && match.length === 2) {
+              var versionInt = parseInt(match[1]);
+              if (!isNaN(versionInt)) {
+                return versionInt;
+              }
+            }
+            return null;
+          };
+          lib.isD3Selection = function(obj) {
+            return obj instanceof d3.selection;
+          };
+          lib.ensureSingle = function(parent, nodeType, className, enterFn) {
+            var sel = parent.select(nodeType + (className ? "." + className : ""));
+            if (sel.size()) return sel;
+            var layer = parent.append(nodeType);
+            if (className) layer.classed(className, true);
+            if (enterFn) layer.call(enterFn);
+            return layer;
+          };
+          lib.ensureSingleById = function(parent, nodeType, id2, enterFn) {
+            var sel = parent.select(nodeType + "#" + id2);
+            if (sel.size()) return sel;
+            var layer = parent.append(nodeType).attr("id", id2);
+            if (enterFn) layer.call(enterFn);
+            return layer;
+          };
+          lib.objectFromPath = function(path, value) {
+            var keys = path.split(".");
+            var tmpObj;
+            var obj = tmpObj = {};
+            for (var i2 = 0; i2 < keys.length; i2++) {
+              var key = keys[i2];
+              var el2 = null;
+              var parts = keys[i2].match(/(.*)\[([0-9]+)\]/);
+              if (parts) {
+                key = parts[1];
+                el2 = parts[2];
+                tmpObj = tmpObj[key] = [];
+                if (i2 === keys.length - 1) {
+                  tmpObj[el2] = value;
+                } else {
+                  tmpObj[el2] = {};
+                }
+                tmpObj = tmpObj[el2];
+              } else {
+                if (i2 === keys.length - 1) {
+                  tmpObj[key] = value;
+                } else {
+                  tmpObj[key] = {};
+                }
+                tmpObj = tmpObj[key];
+              }
+            }
+            return obj;
+          };
+          var dottedPropertyRegex = /^([^\[\.]+)\.(.+)?/;
+          var indexedPropertyRegex = /^([^\.]+)\[([0-9]+)\](\.)?(.+)?/;
+          function notValid(prop) {
+            return prop.slice(0, 2) === "__";
+          }
+          lib.expandObjectPaths = function(data) {
+            var match, key, prop, datum, idx, dest, trailingPath;
+            if (typeof data === "object" && !Array.isArray(data)) {
+              for (key in data) {
+                if (data.hasOwnProperty(key)) {
+                  if (match = key.match(dottedPropertyRegex)) {
+                    datum = data[key];
+                    prop = match[1];
+                    if (notValid(prop)) continue;
+                    delete data[key];
+                    data[prop] = lib.extendDeepNoArrays(
+                      data[prop] || {},
+                      lib.objectFromPath(key, lib.expandObjectPaths(datum))[prop]
+                    );
+                  } else if (match = key.match(indexedPropertyRegex)) {
+                    datum = data[key];
+                    prop = match[1];
+                    if (notValid(prop)) continue;
+                    idx = parseInt(match[2]);
+                    delete data[key];
+                    data[prop] = data[prop] || [];
+                    if (match[3] === ".") {
+                      trailingPath = match[4];
+                      dest = data[prop][idx] = data[prop][idx] || {};
+                      lib.extendDeepNoArrays(dest, lib.objectFromPath(trailingPath, lib.expandObjectPaths(datum)));
+                    } else {
+                      if (notValid(prop)) continue;
+                      data[prop][idx] = lib.expandObjectPaths(datum);
+                    }
+                  } else {
+                    if (notValid(key)) continue;
+                    data[key] = lib.expandObjectPaths(data[key]);
+                  }
+                }
+              }
+            }
+            return data;
+          };
+          lib.numSeparate = function(value, separators, separatethousands) {
+            if (!separatethousands) separatethousands = false;
+            if (typeof separators !== "string" || separators.length === 0) {
+              throw new Error("Separator string required for formatting!");
+            }
+            if (typeof value === "number") {
+              value = String(value);
+            }
+            var thousandsRe = /(\d+)(\d{3})/;
+            var decimalSep = separators.charAt(0);
+            var thouSep = separators.charAt(1);
+            var x2 = value.split(".");
+            var x1 = x2[0];
+            var x22 = x2.length > 1 ? decimalSep + x2[1] : "";
+            if (thouSep && (x2.length > 1 || x1.length > 4 || separatethousands)) {
+              while (thousandsRe.test(x1)) {
+                x1 = x1.replace(thousandsRe, "$1" + thouSep + "$2");
+              }
+            }
+            return x1 + x22;
+          };
+          lib.TEMPLATE_STRING_REGEX = /%{([^\s%{}:]*)([:|\|][^}]*)?}/g;
+          var SIMPLE_PROPERTY_REGEX = /^\w*$/;
+          lib.templateString = function(string, obj) {
+            var getterCache = {};
+            return string.replace(lib.TEMPLATE_STRING_REGEX, function(dummy, key) {
+              var v2;
+              if (SIMPLE_PROPERTY_REGEX.test(key)) {
+                v2 = obj[key];
+              } else {
+                getterCache[key] = getterCache[key] || lib.nestedProperty(obj, key).get;
+                v2 = getterCache[key](true);
+              }
+              return v2 !== void 0 ? v2 : "";
+            });
+          };
+          var hovertemplateWarnings = {
+            max: 10,
+            count: 0,
+            name: "hovertemplate"
+          };
+          lib.hovertemplateString = (params) => templateFormatString(__spreadProps(__spreadValues({}, params), { opts: hovertemplateWarnings }));
+          var texttemplateWarnings = {
+            max: 10,
+            count: 0,
+            name: "texttemplate"
+          };
+          lib.texttemplateString = (params) => templateFormatString(__spreadProps(__spreadValues({}, params), { opts: texttemplateWarnings }));
+          var MULT_DIV_REGEX = /^(\S+)([\*\/])(-?\d+(\.\d+)?)$/;
+          function multDivParser(inputStr) {
+            var match = inputStr.match(MULT_DIV_REGEX);
+            if (match) return { key: match[1], op: match[2], number: Number(match[3]) };
+            return { key: inputStr, op: null, number: null };
+          }
+          var texttemplateWarningsForShapes = {
+            max: 10,
+            count: 0,
+            name: "texttemplate",
+            parseMultDiv: true
+          };
+          lib.texttemplateStringForShapes = (params) => templateFormatString(__spreadProps(__spreadValues({}, params), { opts: texttemplateWarningsForShapes }));
+          var TEMPLATE_STRING_FORMAT_SEPARATOR = /^[:|\|]/;
+          function templateFormatString({ data = [], locale, fallback, labels = {}, opts, template }) {
+            return template.replace(lib.TEMPLATE_STRING_REGEX, (match, key, format) => {
+              const isOther = ["xother", "yother"].includes(key);
+              const isSpaceOther = ["_xother", "_yother"].includes(key);
+              const isSpaceOtherSpace = ["_xother_", "_yother_"].includes(key);
+              const isOtherSpace = ["xother_", "yother_"].includes(key);
+              const hasOther = isOther || isSpaceOther || isOtherSpace || isSpaceOtherSpace;
+              if (isSpaceOther || isSpaceOtherSpace) key = key.substring(1);
+              if (isOtherSpace || isSpaceOtherSpace) key = key.substring(0, key.length - 1);
+              let parsedOp = null;
+              let parsedNumber = null;
+              if (opts.parseMultDiv) {
+                var _match = multDivParser(key);
+                key = _match.key;
+                parsedOp = _match.op;
+                parsedNumber = _match.number;
+              }
+              let value = void 0;
+              if (hasOther) {
+                if (labels[key] === void 0) return "";
+                value = labels[key];
+              } else {
+                for (const obj of data) {
+                  if (!obj) continue;
+                  if (obj.hasOwnProperty(key)) {
+                    value = obj[key];
+                    break;
+                  }
+                  if (!SIMPLE_PROPERTY_REGEX.test(key)) {
+                    value = lib.nestedProperty(obj, key).get(true);
+                  }
+                  if (value !== void 0) break;
+                }
+              }
+              if (value === void 0) {
+                const { count: count2, max, name: name2 } = opts;
+                const fallbackValue = fallback === false ? match : fallback;
+                if (count2 < max) {
+                  lib.warn(
+                    [
+                      `Variable '${key}' in ${name2} could not be found!`,
+                      "Please verify that the template is correct.",
+                      `Using value: '${fallbackValue}'.`
+                    ].join(" ")
+                  );
+                }
+                if (count2 === max) lib.warn(`Too many '${name2}' warnings - additional warnings will be suppressed.`);
+                opts.count++;
+                return fallbackValue;
+              }
+              if (parsedOp === "*") value *= parsedNumber;
+              if (parsedOp === "/") value /= parsedNumber;
+              if (format) {
+                var fmt;
+                if (format[0] === ":") {
+                  fmt = locale ? locale.numberFormat : lib.numberFormat;
+                  if (value !== "") {
+                    value = fmt(format.replace(TEMPLATE_STRING_FORMAT_SEPARATOR, ""))(value);
+                  }
+                }
+                if (format[0] === "|") {
+                  fmt = locale ? locale.timeFormat : utcFormat;
+                  var ms = lib.dateTime2ms(value);
+                  value = lib.formatDate(ms, format.replace(TEMPLATE_STRING_FORMAT_SEPARATOR, ""), false, fmt);
+                }
+              } else {
+                var keyLabel = key + "Label";
+                if (labels.hasOwnProperty(keyLabel)) value = labels[keyLabel];
+              }
+              if (hasOther) {
+                value = "(" + value + ")";
+                if (isSpaceOther || isSpaceOtherSpace) value = " " + value;
+                if (isOtherSpace || isSpaceOtherSpace) value = value + " ";
+              }
+              return value;
+            });
+          }
+          var char0 = 48;
+          var char9 = 57;
+          lib.subplotSort = function(a2, b2) {
+            var l2 = Math.min(a2.length, b2.length) + 1;
+            var numA = 0;
+            var numB = 0;
+            for (var i2 = 0; i2 < l2; i2++) {
+              var charA = a2.charCodeAt(i2) || 0;
+              var charB = b2.charCodeAt(i2) || 0;
+              var isNumA = charA >= char0 && charA <= char9;
+              var isNumB = charB >= char0 && charB <= char9;
+              if (isNumA) numA = 10 * numA + charA - char0;
+              if (isNumB) numB = 10 * numB + charB - char0;
+              if (!isNumA || !isNumB) {
+                if (numA !== numB) return numA - numB;
+                if (charA !== charB) return charA - charB;
+              }
+            }
+            return numB - numA;
+          };
+          var randSeed = 2e9;
+          lib.seedPseudoRandom = function() {
+            randSeed = 2e9;
+          };
+          lib.pseudoRandom = function() {
+            var lastVal = randSeed;
+            randSeed = (69069 * randSeed + 1) % 4294967296;
+            if (Math.abs(randSeed - lastVal) < 429496729) return lib.pseudoRandom();
+            return randSeed / 4294967296;
+          };
+          lib.fillText = function(calcPt, trace, contOut) {
+            var fill = Array.isArray(contOut) ? function(v2) {
+              contOut.push(v2);
+            } : function(v2) {
+              contOut.text = v2;
+            };
+            var htx = lib.extractOption(calcPt, trace, "htx", "hovertext");
+            if (lib.isValidTextValue(htx)) return fill(htx);
+            var tx = lib.extractOption(calcPt, trace, "tx", "text");
+            if (lib.isValidTextValue(tx)) return fill(tx);
+          };
+          lib.isValidTextValue = function(v2) {
+            return v2 || v2 === 0;
+          };
+          lib.formatPercent = function(ratio, n2) {
+            n2 = n2 || 0;
+            var str = (Math.round(100 * ratio * Math.pow(10, n2)) * Math.pow(0.1, n2)).toFixed(n2) + "%";
+            for (var i2 = 0; i2 < n2; i2++) {
+              if (str.indexOf(".") !== -1) {
+                str = str.replace("0%", "%");
+                str = str.replace(".%", "%");
+              }
+            }
+            return str;
+          };
+          lib.isHidden = function(gd2) {
+            var display = window.getComputedStyle(gd2).display;
+            return !display || display === "none";
+          };
+          lib.strTranslate = function(x2, y2) {
+            return x2 || y2 ? "translate(" + x2 + "," + y2 + ")" : "";
+          };
+          lib.strRotate = function(a2) {
+            return a2 ? "rotate(" + a2 + ")" : "";
+          };
+          lib.strScale = function(s2) {
+            return s2 !== 1 ? "scale(" + s2 + ")" : "";
+          };
+          lib.getTextTransform = function(transform) {
+            var noCenter = transform.noCenter;
+            var textX = transform.textX;
+            var textY = transform.textY;
+            var targetX = transform.targetX;
+            var targetY = transform.targetY;
+            var anchorX = transform.anchorX || 0;
+            var anchorY = transform.anchorY || 0;
+            var rotate2 = transform.rotate;
+            var scale2 = transform.scale;
+            if (!scale2) scale2 = 0;
+            else if (scale2 > 1) scale2 = 1;
+            return lib.strTranslate(targetX - scale2 * (textX + anchorX), targetY - scale2 * (textY + anchorY)) + lib.strScale(scale2) + (rotate2 ? "rotate(" + rotate2 + (noCenter ? "" : " " + textX + " " + textY) + ")" : "");
+          };
+          lib.setTransormAndDisplay = function(s2, transform) {
+            s2.attr("transform", lib.getTextTransform(transform));
+            s2.style("display", transform.scale ? null : "none");
+          };
+          lib.ensureUniformFontSize = function(gd2, baseFont) {
+            var out = lib.extendFlat({}, baseFont);
+            out.size = Math.max(baseFont.size, gd2._fullLayout.uniformtext.minsize || 0);
+            return out;
+          };
+          lib.join2 = function(arr, mainSeparator, lastSeparator) {
+            var len2 = arr.length;
+            if (len2 > 1) {
+              return arr.slice(0, -1).join(mainSeparator) + lastSeparator + arr[len2 - 1];
+            }
+            return arr.join(mainSeparator);
+          };
+          lib.bigFont = function(size) {
+            return Math.round(1.2 * size);
+          };
+          var firefoxVersion = lib.getFirefoxVersion();
+          var isProblematicFirefox = firefoxVersion !== null && firefoxVersion < 86;
+          lib.getPositionFromD3Event = function() {
+            if (isProblematicFirefox) {
+              return [d3.event.layerX, d3.event.layerY];
+            } else {
+              return [d3.event.offsetX, d3.event.offsetY];
+            }
+          };
+        }
+      });
+      var require_plotcss = __commonJS({
+        "build/plotcss.js"() {
+          var Lib = require_lib();
+          var rules = {
+            "X,X div": 'direction:ltr;font-family:"Open Sans",verdana,arial,sans-serif;margin:0;padding:0;border:0;',
+            "X input,X button": 'font-family:"Open Sans",verdana,arial,sans-serif;',
+            "X input:focus,X button:focus": "outline:none;",
+            "X a": "text-decoration:none;",
+            "X a:hover": "text-decoration:none;",
+            "X .crisp": "shape-rendering:crispEdges;",
+            "X .user-select-none": "-webkit-user-select:none;-moz-user-select:none;-ms-user-select:none;-o-user-select:none;user-select:none;",
+            "X svg a": "fill:#447adb;",
+            "X svg a:hover": "fill:#3c6dc5;",
+            "X .main-svg": "position:absolute;top:0;left:0;pointer-events:none;",
+            "X .main-svg .draglayer": "pointer-events:all;",
+            "X .cursor-default": "cursor:default;",
+            "X .cursor-pointer": "cursor:pointer;",
+            "X .cursor-crosshair": "cursor:crosshair;",
+            "X .cursor-move": "cursor:move;",
+            "X .cursor-col-resize": "cursor:col-resize;",
+            "X .cursor-row-resize": "cursor:row-resize;",
+            "X .cursor-ns-resize": "cursor:ns-resize;",
+            "X .cursor-ew-resize": "cursor:ew-resize;",
+            "X .cursor-sw-resize": "cursor:sw-resize;",
+            "X .cursor-s-resize": "cursor:s-resize;",
+            "X .cursor-se-resize": "cursor:se-resize;",
+            "X .cursor-w-resize": "cursor:w-resize;",
+            "X .cursor-e-resize": "cursor:e-resize;",
+            "X .cursor-nw-resize": "cursor:nw-resize;",
+            "X .cursor-n-resize": "cursor:n-resize;",
+            "X .cursor-ne-resize": "cursor:ne-resize;",
+            "X .cursor-grab": "cursor:-webkit-grab;cursor:grab;",
+            "X .modebar": "position:absolute;top:2px;right:2px;",
+            "X .ease-bg": "-webkit-transition:background-color .3s ease 0s;-moz-transition:background-color .3s ease 0s;-ms-transition:background-color .3s ease 0s;-o-transition:background-color .3s ease 0s;transition:background-color .3s ease 0s;",
+            "X .modebar--hover>:not(.watermark)": "opacity:0;-webkit-transition:opacity .3s ease 0s;-moz-transition:opacity .3s ease 0s;-ms-transition:opacity .3s ease 0s;-o-transition:opacity .3s ease 0s;transition:opacity .3s ease 0s;",
+            "X:hover .modebar--hover .modebar-group": "opacity:1;",
+            "X:focus-within .modebar--hover .modebar-group": "opacity:1;",
+            "X .modebar-group": "float:left;display:inline-block;box-sizing:border-box;padding-left:8px;position:relative;vertical-align:middle;white-space:nowrap;",
+            "X .modebar-group a": "display:grid;place-content:center;",
+            "X .modebar-btn": "position:relative;font-size:16px;padding:3px 4px;height:22px;cursor:pointer;line-height:normal;box-sizing:border-box;border:none;background:rgba(0,0,0,0);",
+            "X .modebar-btn svg": "position:relative;",
+            "X .modebar-btn:focus-visible": "outline:1px solid #000;outline-offset:1px;border-radius:3px;",
+            "X .modebar.vertical": "display:flex;flex-direction:column;flex-wrap:wrap;align-content:flex-end;max-height:100%;",
+            "X .modebar.vertical svg": "top:-1px;",
+            "X .modebar.vertical .modebar-group": "display:block;float:none;padding-left:0px;padding-bottom:8px;",
+            "X .modebar.vertical .modebar-group .modebar-btn": "display:block;text-align:center;",
+            "X [data-title]:before,X [data-title]:after": "position:absolute;-webkit-transform:translate3d(0, 0, 0);-moz-transform:translate3d(0, 0, 0);-ms-transform:translate3d(0, 0, 0);-o-transform:translate3d(0, 0, 0);transform:translate3d(0, 0, 0);display:none;opacity:0;z-index:1001;pointer-events:none;top:110%;right:50%;",
+            "X [data-title]:hover:before,X [data-title]:hover:after": "display:block;opacity:1;",
+            "X [data-title]:before": 'content:"";position:absolute;background:rgba(0,0,0,0);border:6px solid rgba(0,0,0,0);z-index:1002;margin-top:-12px;border-bottom-color:#69738a;margin-right:-6px;',
+            "X [data-title]:after": "content:attr(data-title);background:#69738a;color:#fff;padding:8px 10px;font-size:12px;line-height:12px;white-space:nowrap;margin-right:-18px;border-radius:2px;",
+            "X .vertical [data-title]:before,X .vertical [data-title]:after": "top:0%;right:200%;",
+            "X .vertical [data-title]:before": "border:6px solid rgba(0,0,0,0);border-left-color:#69738a;margin-top:8px;margin-right:-30px;",
+            Y: 'font-family:"Open Sans",verdana,arial,sans-serif;position:fixed;top:50px;right:20px;z-index:10000;font-size:10pt;max-width:180px;',
+            "Y p": "margin:0;",
+            "Y .notifier-note": "min-width:180px;max-width:250px;border:1px solid #fff;z-index:3000;margin:0;background-color:#8c97af;background-color:rgba(140,151,175,.9);color:#fff;padding:10px;overflow-wrap:break-word;word-wrap:break-word;-ms-hyphens:auto;-webkit-hyphens:auto;hyphens:auto;",
+            "Y .notifier-close": "color:#fff;opacity:.8;float:right;padding:0 5px;background:none;border:none;font-size:20px;font-weight:bold;line-height:20px;",
+            "Y .notifier-close:hover": "color:#444;text-decoration:none;cursor:pointer;"
+          };
+          for (selector in rules) {
+            fullSelector = selector.replace(/^,/, " ,").replace(/X/g, ".js-plotly-plot .plotly").replace(/Y/g, ".plotly-notifier");
+            Lib.addStyleRule(fullSelector, rules[selector]);
+          }
+          var fullSelector;
+          var selector;
+        }
+      });
+      var require_client = __commonJS({
+        "node_modules/is-browser/client.js"(exports, module2) {
+          module2.exports = true;
+        }
+      });
+      var require_has_hover = __commonJS({
+        "node_modules/has-hover/index.js"(exports, module2) {
+          var isBrowser2 = require_client();
+          var hasHover;
+          if (typeof window.matchMedia === "function") {
+            hasHover = !window.matchMedia("(hover: none)").matches;
+          } else {
+            hasHover = isBrowser2;
+          }
+          module2.exports = hasHover;
+        }
+      });
+      var require_events = __commonJS({
+        "node_modules/events/events.js"(exports, module2) {
+          var R2 = typeof Reflect === "object" ? Reflect : null;
+          var ReflectApply = R2 && typeof R2.apply === "function" ? R2.apply : function ReflectApply2(target, receiver, args) {
+            return Function.prototype.apply.call(target, receiver, args);
+          };
+          var ReflectOwnKeys;
+          if (R2 && typeof R2.ownKeys === "function") {
+            ReflectOwnKeys = R2.ownKeys;
+          } else if (Object.getOwnPropertySymbols) {
+            ReflectOwnKeys = function ReflectOwnKeys2(target) {
+              return Object.getOwnPropertyNames(target).concat(Object.getOwnPropertySymbols(target));
+            };
+          } else {
+            ReflectOwnKeys = function ReflectOwnKeys2(target) {
+              return Object.getOwnPropertyNames(target);
+            };
+          }
+          function ProcessEmitWarning(warning) {
+            if (console && console.warn) console.warn(warning);
+          }
+          var NumberIsNaN = Number.isNaN || function NumberIsNaN2(value) {
+            return value !== value;
+          };
+          function EventEmitter() {
+            EventEmitter.init.call(this);
+          }
+          module2.exports = EventEmitter;
+          module2.exports.once = once;
+          EventEmitter.EventEmitter = EventEmitter;
+          EventEmitter.prototype._events = void 0;
+          EventEmitter.prototype._eventsCount = 0;
+          EventEmitter.prototype._maxListeners = void 0;
+          var defaultMaxListeners = 10;
+          function checkListener(listener) {
+            if (typeof listener !== "function") {
+              throw new TypeError('The "listener" argument must be of type Function. Received type ' + typeof listener);
+            }
+          }
+          Object.defineProperty(EventEmitter, "defaultMaxListeners", {
+            enumerable: true,
+            get: function() {
+              return defaultMaxListeners;
+            },
+            set: function(arg) {
+              if (typeof arg !== "number" || arg < 0 || NumberIsNaN(arg)) {
+                throw new RangeError('The value of "defaultMaxListeners" is out of range. It must be a non-negative number. Received ' + arg + ".");
+              }
+              defaultMaxListeners = arg;
+            }
+          });
+          EventEmitter.init = function() {
+            if (this._events === void 0 || this._events === Object.getPrototypeOf(this)._events) {
+              this._events = /* @__PURE__ */ Object.create(null);
+              this._eventsCount = 0;
+            }
+            this._maxListeners = this._maxListeners || void 0;
+          };
+          EventEmitter.prototype.setMaxListeners = function setMaxListeners(n2) {
+            if (typeof n2 !== "number" || n2 < 0 || NumberIsNaN(n2)) {
+              throw new RangeError('The value of "n" is out of range. It must be a non-negative number. Received ' + n2 + ".");
+            }
+            this._maxListeners = n2;
+            return this;
+          };
+          function _getMaxListeners(that) {
+            if (that._maxListeners === void 0)
+              return EventEmitter.defaultMaxListeners;
+            return that._maxListeners;
+          }
+          EventEmitter.prototype.getMaxListeners = function getMaxListeners() {
+            return _getMaxListeners(this);
+          };
+          EventEmitter.prototype.emit = function emit(type) {
+            var args = [];
+            for (var i2 = 1; i2 < arguments.length; i2++) args.push(arguments[i2]);
+            var doError = type === "error";
+            var events = this._events;
+            if (events !== void 0)
+              doError = doError && events.error === void 0;
+            else if (!doError)
+              return false;
+            if (doError) {
+              var er;
+              if (args.length > 0)
+                er = args[0];
+              if (er instanceof Error) {
+                throw er;
+              }
+              var err = new Error("Unhandled error." + (er ? " (" + er.message + ")" : ""));
+              err.context = er;
+              throw err;
+            }
+            var handler = events[type];
+            if (handler === void 0)
+              return false;
+            if (typeof handler === "function") {
+              ReflectApply(handler, this, args);
+            } else {
+              var len2 = handler.length;
+              var listeners = arrayClone(handler, len2);
+              for (var i2 = 0; i2 < len2; ++i2)
+                ReflectApply(listeners[i2], this, args);
+            }
+            return true;
+          };
+          function _addListener(target, type, listener, prepend) {
+            var m2;
+            var events;
+            var existing;
+            checkListener(listener);
+            events = target._events;
+            if (events === void 0) {
+              events = target._events = /* @__PURE__ */ Object.create(null);
+              target._eventsCount = 0;
+            } else {
+              if (events.newListener !== void 0) {
+                target.emit(
+                  "newListener",
+                  type,
+                  listener.listener ? listener.listener : listener
+                );
+                events = target._events;
+              }
+              existing = events[type];
+            }
+            if (existing === void 0) {
+              existing = events[type] = listener;
+              ++target._eventsCount;
+            } else {
+              if (typeof existing === "function") {
+                existing = events[type] = prepend ? [listener, existing] : [existing, listener];
+              } else if (prepend) {
+                existing.unshift(listener);
+              } else {
+                existing.push(listener);
+              }
+              m2 = _getMaxListeners(target);
+              if (m2 > 0 && existing.length > m2 && !existing.warned) {
+                existing.warned = true;
+                var w2 = new Error("Possible EventEmitter memory leak detected. " + existing.length + " " + String(type) + " listeners added. Use emitter.setMaxListeners() to increase limit");
+                w2.name = "MaxListenersExceededWarning";
+                w2.emitter = target;
+                w2.type = type;
+                w2.count = existing.length;
+                ProcessEmitWarning(w2);
+              }
+            }
+            return target;
+          }
+          EventEmitter.prototype.addListener = function addListener(type, listener) {
+            return _addListener(this, type, listener, false);
+          };
+          EventEmitter.prototype.on = EventEmitter.prototype.addListener;
+          EventEmitter.prototype.prependListener = function prependListener(type, listener) {
+            return _addListener(this, type, listener, true);
+          };
+          function onceWrapper() {
+            if (!this.fired) {
+              this.target.removeListener(this.type, this.wrapFn);
+              this.fired = true;
+              if (arguments.length === 0)
+                return this.listener.call(this.target);
+              return this.listener.apply(this.target, arguments);
+            }
+          }
+          function _onceWrap(target, type, listener) {
+            var state = { fired: false, wrapFn: void 0, target, type, listener };
+            var wrapped = onceWrapper.bind(state);
+            wrapped.listener = listener;
+            state.wrapFn = wrapped;
+            return wrapped;
+          }
+          EventEmitter.prototype.once = function once2(type, listener) {
+            checkListener(listener);
+            this.on(type, _onceWrap(this, type, listener));
+            return this;
+          };
+          EventEmitter.prototype.prependOnceListener = function prependOnceListener(type, listener) {
+            checkListener(listener);
+            this.prependListener(type, _onceWrap(this, type, listener));
+            return this;
+          };
+          EventEmitter.prototype.removeListener = function removeListener(type, listener) {
+            var list, events, position, i2, originalListener;
+            checkListener(listener);
+            events = this._events;
+            if (events === void 0)
+              return this;
+            list = events[type];
+            if (list === void 0)
+              return this;
+            if (list === listener || list.listener === listener) {
+              if (--this._eventsCount === 0)
+                this._events = /* @__PURE__ */ Object.create(null);
+              else {
+                delete events[type];
+                if (events.removeListener)
+                  this.emit("removeListener", type, list.listener || listener);
+              }
+            } else if (typeof list !== "function") {
+              position = -1;
+              for (i2 = list.length - 1; i2 >= 0; i2--) {
+                if (list[i2] === listener || list[i2].listener === listener) {
+                  originalListener = list[i2].listener;
+                  position = i2;
+                  break;
+                }
+              }
+              if (position < 0)
+                return this;
+              if (position === 0)
+                list.shift();
+              else {
+                spliceOne(list, position);
+              }
+              if (list.length === 1)
+                events[type] = list[0];
+              if (events.removeListener !== void 0)
+                this.emit("removeListener", type, originalListener || listener);
+            }
+            return this;
+          };
+          EventEmitter.prototype.off = EventEmitter.prototype.removeListener;
+          EventEmitter.prototype.removeAllListeners = function removeAllListeners(type) {
+            var listeners, events, i2;
+            events = this._events;
+            if (events === void 0)
+              return this;
+            if (events.removeListener === void 0) {
+              if (arguments.length === 0) {
+                this._events = /* @__PURE__ */ Object.create(null);
+                this._eventsCount = 0;
+              } else if (events[type] !== void 0) {
+                if (--this._eventsCount === 0)
+                  this._events = /* @__PURE__ */ Object.create(null);
+                else
+                  delete events[type];
+              }
+              return this;
+            }
+            if (arguments.length === 0) {
+              var keys = Object.keys(events);
+              var key;
+              for (i2 = 0; i2 < keys.length; ++i2) {
+                key = keys[i2];
+                if (key === "removeListener") continue;
+                this.removeAllListeners(key);
+              }
+              this.removeAllListeners("removeListener");
+              this._events = /* @__PURE__ */ Object.create(null);
+              this._eventsCount = 0;
+              return this;
+            }
+            listeners = events[type];
+            if (typeof listeners === "function") {
+              this.removeListener(type, listeners);
+            } else if (listeners !== void 0) {
+              for (i2 = listeners.length - 1; i2 >= 0; i2--) {
+                this.removeListener(type, listeners[i2]);
+              }
+            }
+            return this;
+          };
+          function _listeners(target, type, unwrap) {
+            var events = target._events;
+            if (events === void 0)
+              return [];
+            var evlistener = events[type];
+            if (evlistener === void 0)
+              return [];
+            if (typeof evlistener === "function")
+              return unwrap ? [evlistener.listener || evlistener] : [evlistener];
+            return unwrap ? unwrapListeners(evlistener) : arrayClone(evlistener, evlistener.length);
+          }
+          EventEmitter.prototype.listeners = function listeners(type) {
+            return _listeners(this, type, true);
+          };
+          EventEmitter.prototype.rawListeners = function rawListeners(type) {
+            return _listeners(this, type, false);
+          };
+          EventEmitter.listenerCount = function(emitter, type) {
+            if (typeof emitter.listenerCount === "function") {
+              return emitter.listenerCount(type);
+            } else {
+              return listenerCount.call(emitter, type);
+            }
+          };
+          EventEmitter.prototype.listenerCount = listenerCount;
+          function listenerCount(type) {
+            var events = this._events;
+            if (events !== void 0) {
+              var evlistener = events[type];
+              if (typeof evlistener === "function") {
+                return 1;
+              } else if (evlistener !== void 0) {
+                return evlistener.length;
+              }
+            }
+            return 0;
+          }
+          EventEmitter.prototype.eventNames = function eventNames() {
+            return this._eventsCount > 0 ? ReflectOwnKeys(this._events) : [];
+          };
+          function arrayClone(arr, n2) {
+            var copy = new Array(n2);
+            for (var i2 = 0; i2 < n2; ++i2)
+              copy[i2] = arr[i2];
+            return copy;
+          }
+          function spliceOne(list, index) {
+            for (; index + 1 < list.length; index++)
+              list[index] = list[index + 1];
+            list.pop();
+          }
+          function unwrapListeners(arr) {
+            var ret = new Array(arr.length);
+            for (var i2 = 0; i2 < ret.length; ++i2) {
+              ret[i2] = arr[i2].listener || arr[i2];
+            }
+            return ret;
+          }
+          function once(emitter, name2) {
+            return new Promise(function(resolve, reject) {
+              function errorListener(err) {
+                emitter.removeListener(name2, resolver);
+                reject(err);
+              }
+              function resolver() {
+                if (typeof emitter.removeListener === "function") {
+                  emitter.removeListener("error", errorListener);
+                }
+                resolve([].slice.call(arguments));
+              }
+              eventTargetAgnosticAddListener(emitter, name2, resolver, { once: true });
+              if (name2 !== "error") {
+                addErrorHandlerIfEventEmitter(emitter, errorListener, { once: true });
+              }
+            });
+          }
+          function addErrorHandlerIfEventEmitter(emitter, handler, flags) {
+            if (typeof emitter.on === "function") {
+              eventTargetAgnosticAddListener(emitter, "error", handler, flags);
+            }
+          }
+          function eventTargetAgnosticAddListener(emitter, name2, listener, flags) {
+            if (typeof emitter.on === "function") {
+              if (flags.once) {
+                emitter.once(name2, listener);
+              } else {
+                emitter.on(name2, listener);
+              }
+            } else if (typeof emitter.addEventListener === "function") {
+              emitter.addEventListener(name2, function wrapListener(arg) {
+                if (flags.once) {
+                  emitter.removeEventListener(name2, wrapListener);
+                }
+                listener(arg);
+              });
+            } else {
+              throw new TypeError('The "emitter" argument must be of type EventEmitter. Received type ' + typeof emitter);
+            }
+          }
+        }
+      });
+      var require_events2 = __commonJS({
+        "src/lib/events.js"(exports, module2) {
+          var EventEmitter = require_events().EventEmitter;
+          var Events = {
+            init: function(plotObj) {
+              if (plotObj._ev instanceof EventEmitter) return plotObj;
+              var ev = new EventEmitter();
+              var internalEv = new EventEmitter();
+              plotObj._ev = ev;
+              plotObj._internalEv = internalEv;
+              plotObj.on = ev.on.bind(ev);
+              plotObj.once = ev.once.bind(ev);
+              plotObj.removeListener = ev.removeListener.bind(ev);
+              plotObj.removeAllListeners = ev.removeAllListeners.bind(ev);
+              plotObj._internalOn = internalEv.on.bind(internalEv);
+              plotObj._internalOnce = internalEv.once.bind(internalEv);
+              plotObj._removeInternalListener = internalEv.removeListener.bind(internalEv);
+              plotObj._removeAllInternalListeners = internalEv.removeAllListeners.bind(internalEv);
+              plotObj.emit = function(event, data) {
+                ev.emit(event, data);
+                internalEv.emit(event, data);
+              };
+              if (typeof plotObj.addEventListener === "function") {
+                plotObj.addEventListener("wheel", () => {
+                }, { passive: true });
+              }
+              return plotObj;
+            },
+            /*
+             * This function behaves like jQuery's triggerHandler. It calls
+             * all handlers for a particular event and returns the return value
+             * of the LAST handler.
+             */
+            triggerHandler: function(plotObj, event, data) {
+              var nodeEventHandlerValue;
+              var ev = plotObj._ev;
+              if (!ev) return;
+              var handlers = ev._events[event];
+              if (!handlers) return;
+              function apply(handler) {
+                if (handler.listener) {
+                  ev.removeListener(event, handler.listener);
+                  if (!handler.fired) {
+                    handler.fired = true;
+                    return handler.listener.apply(ev, [data]);
+                  }
+                } else {
+                  return handler.apply(ev, [data]);
+                }
+              }
+              handlers = Array.isArray(handlers) ? handlers : [handlers];
+              var i2;
+              for (i2 = 0; i2 < handlers.length - 1; i2++) {
+                apply(handlers[i2]);
+              }
+              nodeEventHandlerValue = apply(handlers[i2]);
+              return nodeEventHandlerValue;
+            },
+            purge: function(plotObj) {
+              delete plotObj._ev;
+              delete plotObj.on;
+              delete plotObj.once;
+              delete plotObj.removeListener;
+              delete plotObj.removeAllListeners;
+              delete plotObj.emit;
+              delete plotObj._ev;
+              delete plotObj._internalEv;
+              delete plotObj._internalOn;
+              delete plotObj._internalOnce;
+              delete plotObj._removeInternalListener;
+              delete plotObj._removeAllInternalListeners;
+              return plotObj;
+            }
+          };
+          module2.exports = Events;
+        }
+      });
+      var require_queue = __commonJS({
+        "src/lib/queue.js"(exports, module2) {
+          var Lib = require_lib();
+          var dfltConfig = require_plot_config().dfltConfig;
+          function copyArgArray(gd2, args) {
+            var copy = [];
+            var arg;
+            for (var i2 = 0; i2 < args.length; i2++) {
+              arg = args[i2];
+              if (arg === gd2) copy[i2] = arg;
+              else if (typeof arg === "object") {
+                copy[i2] = Array.isArray(arg) ? Lib.extendDeep([], arg) : Lib.extendDeepAll({}, arg);
+              } else copy[i2] = arg;
+            }
+            return copy;
+          }
+          var queue = {};
+          queue.add = function(gd2, undoFunc, undoArgs, redoFunc, redoArgs) {
+            var queueObj, queueIndex;
+            gd2.undoQueue = gd2.undoQueue || { index: 0, queue: [], sequence: false };
+            queueIndex = gd2.undoQueue.index;
+            if (gd2.autoplay) {
+              if (!gd2.undoQueue.inSequence) gd2.autoplay = false;
+              return;
+            }
+            if (!gd2.undoQueue.sequence || gd2.undoQueue.beginSequence) {
+              queueObj = { undo: { calls: [], args: [] }, redo: { calls: [], args: [] } };
+              gd2.undoQueue.queue.splice(queueIndex, gd2.undoQueue.queue.length - queueIndex, queueObj);
+              gd2.undoQueue.index += 1;
+            } else {
+              queueObj = gd2.undoQueue.queue[queueIndex - 1];
+            }
+            gd2.undoQueue.beginSequence = false;
+            if (queueObj) {
+              queueObj.undo.calls.unshift(undoFunc);
+              queueObj.undo.args.unshift(undoArgs);
+              queueObj.redo.calls.push(redoFunc);
+              queueObj.redo.args.push(redoArgs);
+            }
+            if (gd2.undoQueue.queue.length > dfltConfig.queueLength) {
+              gd2.undoQueue.queue.shift();
+              gd2.undoQueue.index--;
+            }
+          };
+          queue.startSequence = function(gd2) {
+            gd2.undoQueue = gd2.undoQueue || { index: 0, queue: [], sequence: false };
+            gd2.undoQueue.sequence = true;
+            gd2.undoQueue.beginSequence = true;
+          };
+          queue.stopSequence = function(gd2) {
+            gd2.undoQueue = gd2.undoQueue || { index: 0, queue: [], sequence: false };
+            gd2.undoQueue.sequence = false;
+            gd2.undoQueue.beginSequence = false;
+          };
+          queue.undo = function undo(gd2) {
+            var queueObj, i2;
+            if (gd2.undoQueue === void 0 || isNaN(gd2.undoQueue.index) || gd2.undoQueue.index <= 0) {
+              return;
+            }
+            gd2.undoQueue.index--;
+            queueObj = gd2.undoQueue.queue[gd2.undoQueue.index];
+            gd2.undoQueue.inSequence = true;
+            for (i2 = 0; i2 < queueObj.undo.calls.length; i2++) {
+              queue.plotDo(gd2, queueObj.undo.calls[i2], queueObj.undo.args[i2]);
+            }
+            gd2.undoQueue.inSequence = false;
+            gd2.autoplay = false;
+          };
+          queue.redo = function redo(gd2) {
+            var queueObj, i2;
+            if (gd2.undoQueue === void 0 || isNaN(gd2.undoQueue.index) || gd2.undoQueue.index >= gd2.undoQueue.queue.length) {
+              return;
+            }
+            queueObj = gd2.undoQueue.queue[gd2.undoQueue.index];
+            gd2.undoQueue.inSequence = true;
+            for (i2 = 0; i2 < queueObj.redo.calls.length; i2++) {
+              queue.plotDo(gd2, queueObj.redo.calls[i2], queueObj.redo.args[i2]);
+            }
+            gd2.undoQueue.inSequence = false;
+            gd2.autoplay = false;
+            gd2.undoQueue.index++;
+          };
+          queue.plotDo = function(gd2, func, args) {
+            gd2.autoplay = true;
+            args = copyArgArray(gd2, args);
+            func.apply(null, args);
+          };
+          module2.exports = queue;
+        }
+      });
+      var require_frame_attributes = __commonJS({
+        "src/plots/frame_attributes.js"(exports, module2) {
+          module2.exports = {
+            _isLinkedToArray: "frames_entry",
+            group: {
+              valType: "string"
+            },
+            name: {
+              valType: "string"
+            },
+            traces: {
+              valType: "any"
+            },
+            baseframe: {
+              valType: "string"
+            },
+            data: {
+              valType: "any"
+            },
+            layout: {
+              valType: "any"
+            }
+          };
+        }
+      });
+      var require_plot_schema = __commonJS({
+        "src/plot_api/plot_schema.js"(exports) {
+          var Registry = require_registry();
+          var Lib = require_lib();
+          var baseAttributes = require_attributes2();
+          var baseLayoutAttributes = require_layout_attributes2();
+          var frameAttributes = require_frame_attributes();
+          var animationAttributes = require_animation_attributes();
+          var configAttributes = require_plot_config().configAttributes;
+          var editTypes = require_edit_types();
+          var extendDeepAll = Lib.extendDeepAll;
+          var isPlainObject2 = Lib.isPlainObject;
+          var isArrayOrTypedArray = Lib.isArrayOrTypedArray;
+          var nestedProperty = Lib.nestedProperty;
+          var valObjectMeta = Lib.valObjectMeta;
+          var IS_SUBPLOT_OBJ = "_isSubplotObj";
+          var IS_LINKED_TO_ARRAY = "_isLinkedToArray";
+          var ARRAY_ATTR_REGEXPS = "_arrayAttrRegexps";
+          var DEPRECATED = "_deprecated";
+          var UNDERSCORE_ATTRS = [IS_SUBPLOT_OBJ, IS_LINKED_TO_ARRAY, ARRAY_ATTR_REGEXPS, DEPRECATED];
+          exports.IS_SUBPLOT_OBJ = IS_SUBPLOT_OBJ;
+          exports.IS_LINKED_TO_ARRAY = IS_LINKED_TO_ARRAY;
+          exports.DEPRECATED = DEPRECATED;
+          exports.UNDERSCORE_ATTRS = UNDERSCORE_ATTRS;
+          exports.get = function() {
+            var traces = {};
+            Registry.allTypes.forEach(function(type) {
+              traces[type] = getTraceAttributes(type);
+            });
+            return {
+              defs: {
+                valObjects: valObjectMeta,
+                metaKeys: UNDERSCORE_ATTRS.concat(["description", "role", "editType", "impliedEdits"]),
+                editType: {
+                  traces: editTypes.traces,
+                  layout: editTypes.layout
+                },
+                impliedEdits: {}
+              },
+              traces,
+              layout: getLayoutAttributes(),
+              frames: getFramesAttributes(),
+              animation: formatAttributes(animationAttributes),
+              config: formatAttributes(configAttributes)
+            };
+          };
+          exports.crawl = function(attrs, callback, specifiedLevel, attrString) {
+            var level = specifiedLevel || 0;
+            attrString = attrString || "";
+            Object.keys(attrs).forEach(function(attrName) {
+              var attr = attrs[attrName];
+              if (UNDERSCORE_ATTRS.indexOf(attrName) !== -1) return;
+              var fullAttrString = (attrString ? attrString + "." : "") + attrName;
+              callback(attr, attrName, attrs, level, fullAttrString);
+              if (exports.isValObject(attr)) return;
+              if (isPlainObject2(attr) && attrName !== "impliedEdits") {
+                exports.crawl(attr, callback, level + 1, fullAttrString);
+              }
+            });
+          };
+          exports.isValObject = function(obj) {
+            return obj && obj.valType !== void 0;
+          };
+          exports.findArrayAttributes = function(trace) {
+            var arrayAttributes = [];
+            var stack = [];
+            var isArrayStack = [];
+            var baseContainer, baseAttrName;
+            function callback(attr, attrName, attrs, level) {
+              stack = stack.slice(0, level).concat([attrName]);
+              isArrayStack = isArrayStack.slice(0, level).concat([attr && attr._isLinkedToArray]);
+              var splittableAttr = attr && (attr.valType === "data_array" || attr.arrayOk === true) && !(stack[level - 1] === "colorbar" && (attrName === "ticktext" || attrName === "tickvals"));
+              if (!splittableAttr) return;
+              crawlIntoTrace(baseContainer, 0, "");
+            }
+            function crawlIntoTrace(container, i2, astrPartial) {
+              var item = container[stack[i2]];
+              var newAstrPartial = astrPartial + stack[i2];
+              if (i2 === stack.length - 1) {
+                if (isArrayOrTypedArray(item)) {
+                  arrayAttributes.push(baseAttrName + newAstrPartial);
+                }
+              } else {
+                if (isArrayStack[i2]) {
+                  if (Array.isArray(item)) {
+                    for (var j2 = 0; j2 < item.length; j2++) {
+                      if (isPlainObject2(item[j2])) {
+                        crawlIntoTrace(item[j2], i2 + 1, newAstrPartial + "[" + j2 + "].");
+                      }
+                    }
+                  }
+                } else if (isPlainObject2(item)) {
+                  crawlIntoTrace(item, i2 + 1, newAstrPartial + ".");
+                }
+              }
+            }
+            baseContainer = trace;
+            baseAttrName = "";
+            exports.crawl(baseAttributes, callback);
+            if (trace._module && trace._module.attributes) {
+              exports.crawl(trace._module.attributes, callback);
+            }
+            return arrayAttributes;
+          };
+          exports.getTraceValObject = function(trace, parts) {
+            var head = parts[0];
+            var i2 = 1;
+            var moduleAttrs, valObject;
+            var _module = trace._module;
+            if (!_module) _module = (Registry.modules[trace.type || baseAttributes.type.dflt] || {})._module;
+            if (!_module) return false;
+            moduleAttrs = _module.attributes;
+            valObject = moduleAttrs && moduleAttrs[head];
+            if (!valObject) {
+              var subplotModule = _module.basePlotModule;
+              if (subplotModule && subplotModule.attributes) {
+                valObject = subplotModule.attributes[head];
+              }
+            }
+            if (!valObject) valObject = baseAttributes[head];
+            return recurseIntoValObject(valObject, parts, i2);
+          };
+          exports.getLayoutValObject = function(fullLayout, parts) {
+            var valObject = layoutHeadAttr(fullLayout, parts[0]);
+            return recurseIntoValObject(valObject, parts, 1);
+          };
+          function layoutHeadAttr(fullLayout, head) {
+            var i2, key, _module, attributes;
+            var basePlotModules = fullLayout._basePlotModules;
+            if (basePlotModules) {
+              var out;
+              for (i2 = 0; i2 < basePlotModules.length; i2++) {
+                _module = basePlotModules[i2];
+                if (_module.attrRegex && _module.attrRegex.test(head)) {
+                  if (_module.layoutAttrOverrides) return _module.layoutAttrOverrides;
+                  if (!out && _module.layoutAttributes) out = _module.layoutAttributes;
+                }
+                var baseOverrides = _module.baseLayoutAttrOverrides;
+                if (baseOverrides && head in baseOverrides) return baseOverrides[head];
+              }
+              if (out) return out;
+            }
+            var modules = fullLayout._modules;
+            if (modules) {
+              for (i2 = 0; i2 < modules.length; i2++) {
+                attributes = modules[i2].layoutAttributes;
+                if (attributes && head in attributes) {
+                  return attributes[head];
+                }
+              }
+            }
+            for (key in Registry.componentsRegistry) {
+              _module = Registry.componentsRegistry[key];
+              if (_module.name === "colorscale" && head.indexOf("coloraxis") === 0) {
+                return _module.layoutAttributes[head];
+              } else if (!_module.schema && head === _module.name) {
+                return _module.layoutAttributes;
+              }
+            }
+            if (head in baseLayoutAttributes) return baseLayoutAttributes[head];
+            return false;
+          }
+          function recurseIntoValObject(valObject, parts, i2) {
+            if (!valObject) return false;
+            if (valObject._isLinkedToArray) {
+              if (isIndex2(parts[i2])) i2++;
+              else if (i2 < parts.length) return false;
+            }
+            for (; i2 < parts.length; i2++) {
+              var newValObject = valObject[parts[i2]];
+              if (isPlainObject2(newValObject)) valObject = newValObject;
+              else break;
+              if (i2 === parts.length - 1) break;
+              if (valObject._isLinkedToArray) {
+                i2++;
+                if (!isIndex2(parts[i2])) return false;
+              } else if (valObject.valType === "info_array") {
+                i2++;
+                var index = parts[i2];
+                if (!isIndex2(index)) return false;
+                var items = valObject.items;
+                if (Array.isArray(items)) {
+                  if (index >= items.length) return false;
+                  if (valObject.dimensions === 2) {
+                    i2++;
+                    if (parts.length === i2) return valObject;
+                    var index2 = parts[i2];
+                    if (!isIndex2(index2)) return false;
+                    valObject = items[index][index2];
+                  } else valObject = items[index];
+                } else {
+                  valObject = items;
+                }
+              }
+            }
+            return valObject;
+          }
+          function isIndex2(val) {
+            return val === Math.round(val) && val >= 0;
+          }
+          function getTraceAttributes(type) {
+            var _module, basePlotModule;
+            _module = Registry.modules[type]._module, basePlotModule = _module.basePlotModule;
+            var attributes = {};
+            attributes.type = null;
+            var copyBaseAttributes = extendDeepAll({}, baseAttributes);
+            var copyModuleAttributes = extendDeepAll({}, _module.attributes);
+            exports.crawl(copyModuleAttributes, function(attr, attrName, attrs, level, fullAttrString) {
+              nestedProperty(copyBaseAttributes, fullAttrString).set(void 0);
+              if (attr === void 0) nestedProperty(copyModuleAttributes, fullAttrString).set(void 0);
+            });
+            extendDeepAll(attributes, copyBaseAttributes);
+            if (Registry.traceIs(type, "noOpacity")) {
+              delete attributes.opacity;
+            }
+            if (!Registry.traceIs(type, "showLegend")) {
+              delete attributes.showlegend;
+              delete attributes.legendgroup;
+            }
+            if (Registry.traceIs(type, "noHover")) {
+              delete attributes.hoverinfo;
+              delete attributes.hoverlabel;
+            }
+            if (!_module.selectPoints) {
+              delete attributes.selectedpoints;
+            }
+            extendDeepAll(attributes, copyModuleAttributes);
+            if (basePlotModule.attributes) {
+              extendDeepAll(attributes, basePlotModule.attributes);
+            }
+            attributes.type = type;
+            var out = {
+              meta: _module.meta || {},
+              categories: _module.categories || {},
+              animatable: Boolean(_module.animatable),
+              type,
+              attributes: formatAttributes(attributes)
+            };
+            if (_module.layoutAttributes) {
+              var layoutAttributes = {};
+              extendDeepAll(layoutAttributes, _module.layoutAttributes);
+              out.layoutAttributes = formatAttributes(layoutAttributes);
+            }
+            if (!_module.animatable) {
+              exports.crawl(out, function(attr) {
+                if (exports.isValObject(attr) && "anim" in attr) {
+                  delete attr.anim;
+                }
+              });
+            }
+            return out;
+          }
+          function getLayoutAttributes() {
+            var layoutAttributes = {};
+            var key, _module;
+            extendDeepAll(layoutAttributes, baseLayoutAttributes);
+            for (key in Registry.subplotsRegistry) {
+              _module = Registry.subplotsRegistry[key];
+              if (!_module.layoutAttributes) continue;
+              if (Array.isArray(_module.attr)) {
+                for (var i2 = 0; i2 < _module.attr.length; i2++) {
+                  handleBasePlotModule(layoutAttributes, _module, _module.attr[i2]);
+                }
+              } else {
+                var astr = _module.attr === "subplot" ? _module.name : _module.attr;
+                handleBasePlotModule(layoutAttributes, _module, astr);
+              }
+            }
+            for (key in Registry.componentsRegistry) {
+              _module = Registry.componentsRegistry[key];
+              var schema = _module.schema;
+              if (schema && (schema.subplots || schema.layout)) {
+                var subplots = schema.subplots;
+                if (subplots && subplots.xaxis && !subplots.yaxis) {
+                  for (var xkey in subplots.xaxis) {
+                    delete layoutAttributes.yaxis[xkey];
+                  }
+                }
+                delete layoutAttributes.xaxis.shift;
+                delete layoutAttributes.xaxis.autoshift;
+              } else if (_module.name === "colorscale") {
+                extendDeepAll(layoutAttributes, _module.layoutAttributes);
+              } else if (_module.layoutAttributes) {
+                insertAttrs(layoutAttributes, _module.layoutAttributes, _module.name);
+              }
+            }
+            return {
+              layoutAttributes: formatAttributes(layoutAttributes)
+            };
+          }
+          function getFramesAttributes() {
+            var attrs = {
+              frames: extendDeepAll({}, frameAttributes)
+            };
+            formatAttributes(attrs);
+            return attrs.frames;
+          }
+          function formatAttributes(attrs) {
+            mergeValTypeAndRole(attrs);
+            formatArrayContainers(attrs);
+            stringify(attrs);
+            return attrs;
+          }
+          function mergeValTypeAndRole(attrs) {
+            function makeSrcAttr(attrName) {
+              return {
+                valType: "string",
+                editType: "none"
+              };
+            }
+            function callback(attr, attrName, attrs2) {
+              if (exports.isValObject(attr)) {
+                if (attr.arrayOk === true || attr.valType === "data_array") {
+                  attrs2[attrName + "src"] = makeSrcAttr();
+                }
+              } else if (isPlainObject2(attr)) {
+                attr.role = "object";
+              }
+            }
+            exports.crawl(attrs, callback);
+          }
+          function formatArrayContainers(attrs) {
+            function callback(attr, attrName, attrs2) {
+              if (!attr) return;
+              var itemName = attr[IS_LINKED_TO_ARRAY];
+              if (!itemName) return;
+              delete attr[IS_LINKED_TO_ARRAY];
+              attrs2[attrName] = { items: {} };
+              attrs2[attrName].items[itemName] = attr;
+              attrs2[attrName].role = "object";
+            }
+            exports.crawl(attrs, callback);
+          }
+          function stringify(attrs) {
+            function walk(attr) {
+              for (var k2 in attr) {
+                if (isPlainObject2(attr[k2])) {
+                  walk(attr[k2]);
+                } else if (Array.isArray(attr[k2])) {
+                  for (var i2 = 0; i2 < attr[k2].length; i2++) {
+                    walk(attr[k2][i2]);
+                  }
+                } else {
+                  if (attr[k2] instanceof RegExp) {
+                    attr[k2] = attr[k2].toString();
+                  }
+                }
+              }
+            }
+            walk(attrs);
+          }
+          function handleBasePlotModule(layoutAttributes, _module, astr) {
+            var np = nestedProperty(layoutAttributes, astr);
+            var attrs = extendDeepAll({}, _module.layoutAttributes);
+            attrs[IS_SUBPLOT_OBJ] = true;
+            np.set(attrs);
+          }
+          function insertAttrs(baseAttrs, newAttrs, astr) {
+            var np = nestedProperty(baseAttrs, astr);
+            np.set(extendDeepAll(np.get() || {}, newAttrs));
+          }
+        }
+      });
+      var require_plot_template = __commonJS({
+        "src/plot_api/plot_template.js"(exports) {
+          var Lib = require_lib();
+          var plotAttributes = require_attributes2();
+          var TEMPLATEITEMNAME = "templateitemname";
+          var templateAttrs = {
+            name: {
+              valType: "string",
+              editType: "none"
+            }
+          };
+          templateAttrs[TEMPLATEITEMNAME] = {
+            valType: "string",
+            editType: "calc"
+          };
+          exports.templatedArray = function(name2, attrs) {
+            attrs._isLinkedToArray = name2;
+            attrs.name = templateAttrs.name;
+            attrs[TEMPLATEITEMNAME] = templateAttrs[TEMPLATEITEMNAME];
+            return attrs;
+          };
+          exports.traceTemplater = function(dataTemplate) {
+            var traceCounts = {};
+            var traceType, typeTemplates;
+            for (traceType in dataTemplate) {
+              typeTemplates = dataTemplate[traceType];
+              if (Array.isArray(typeTemplates) && typeTemplates.length) {
+                traceCounts[traceType] = 0;
+              }
+            }
+            function newTrace(traceIn) {
+              traceType = Lib.coerce(traceIn, {}, plotAttributes, "type");
+              var traceOut = { type: traceType, _template: null };
+              if (traceType in traceCounts) {
+                typeTemplates = dataTemplate[traceType];
+                var typei = traceCounts[traceType] % typeTemplates.length;
+                traceCounts[traceType]++;
+                traceOut._template = typeTemplates[typei];
+              }
+              return traceOut;
+            }
+            return {
+              newTrace
+              // TODO: function to figure out what's left & what didn't work
+            };
+          };
+          exports.newContainer = function(container, name2, baseName) {
+            var template = container._template;
+            var part = template && (template[name2] || baseName && template[baseName]);
+            if (!Lib.isPlainObject(part)) part = null;
+            var out = container[name2] = { _template: part };
+            return out;
+          };
+          exports.arrayTemplater = function(container, name2, inclusionAttr) {
+            var template = container._template;
+            var defaultsTemplate = template && template[arrayDefaultKey(name2)];
+            var templateItems = template && template[name2];
+            if (!Array.isArray(templateItems) || !templateItems.length) {
+              templateItems = [];
+            }
+            var usedNames = {};
+            function newItem(itemIn) {
+              var out = { name: itemIn.name, _input: itemIn };
+              var templateItemName = out[TEMPLATEITEMNAME] = itemIn[TEMPLATEITEMNAME];
+              if (!validItemName(templateItemName)) {
+                out._template = defaultsTemplate;
+                return out;
+              }
+              for (var i2 = 0; i2 < templateItems.length; i2++) {
+                var templateItem = templateItems[i2];
+                if (templateItem.name === templateItemName) {
+                  usedNames[templateItemName] = 1;
+                  out._template = templateItem;
+                  return out;
+                }
+              }
+              out[inclusionAttr] = itemIn[inclusionAttr] || false;
+              out._template = false;
+              return out;
+            }
+            function defaultItems() {
+              var out = [];
+              for (var i2 = 0; i2 < templateItems.length; i2++) {
+                var templateItem = templateItems[i2];
+                var name3 = templateItem.name;
+                if (validItemName(name3) && !usedNames[name3]) {
+                  var outi = {
+                    _template: templateItem,
+                    name: name3,
+                    _input: { _templateitemname: name3 }
+                  };
+                  outi[TEMPLATEITEMNAME] = templateItem[TEMPLATEITEMNAME];
+                  out.push(outi);
+                  usedNames[name3] = 1;
+                }
+              }
+              return out;
+            }
+            return {
+              newItem,
+              defaultItems
+            };
+          };
+          function validItemName(name2) {
+            return name2 && typeof name2 === "string";
+          }
+          function arrayDefaultKey(name2) {
+            var lastChar = name2.length - 1;
+            if (name2.charAt(lastChar) !== "s") {
+              Lib.warn("bad argument to arrayDefaultKey: " + name2);
+            }
+            return name2.slice(0, -1) + "defaults";
+          }
+          exports.arrayDefaultKey = arrayDefaultKey;
+          exports.arrayEditor = function(parentIn, containerStr, itemOut) {
+            var lengthIn = (Lib.nestedProperty(parentIn, containerStr).get() || []).length;
+            var index = itemOut._index;
+            var templateItemName = index >= lengthIn && (itemOut._input || {})._templateitemname;
+            if (templateItemName) index = lengthIn;
+            var itemStr = containerStr + "[" + index + "]";
+            var update;
+            function resetUpdate() {
+              update = {};
+              if (templateItemName) {
+                update[itemStr] = {};
+                update[itemStr][TEMPLATEITEMNAME] = templateItemName;
+              }
+            }
+            resetUpdate();
+            function modifyBase(attr, value) {
+              update[attr] = value;
+            }
+            function modifyItem(attr, value) {
+              if (templateItemName) {
+                Lib.nestedProperty(update[itemStr], attr).set(value);
+              } else {
+                update[itemStr + "." + attr] = value;
+              }
+            }
+            function getUpdateObj() {
+              var updateOut = update;
+              resetUpdate();
+              return updateOut;
+            }
+            function applyUpdate(attr, value) {
+              if (attr) modifyItem(attr, value);
+              var updateToApply = getUpdateObj();
+              for (var key in updateToApply) {
+                Lib.nestedProperty(parentIn, key).set(updateToApply[key]);
+              }
+            }
+            return {
+              modifyBase,
+              modifyItem,
+              getUpdateObj,
+              applyUpdate
+            };
+          };
+        }
+      });
+      var require_constants2 = __commonJS({
+        "src/plots/cartesian/constants.js"(exports, module2) {
+          var counterRegex = require_regex().counter;
+          module2.exports = {
+            idRegex: {
+              x: counterRegex("x", "( domain)?"),
+              y: counterRegex("y", "( domain)?")
+            },
+            attrRegex: counterRegex("[xy]axis"),
+            // axis match regular expression
+            xAxisMatch: counterRegex("xaxis"),
+            yAxisMatch: counterRegex("yaxis"),
+            // pattern matching axis ids and names
+            // note that this is more permissive than counterRegex, as
+            // id2name, name2id, and cleanId accept "x1" etc
+            AX_ID_PATTERN: /^[xyz][0-9]*( domain)?$/,
+            AX_NAME_PATTERN: /^[xyz]axis[0-9]*$/,
+            // and for 2D subplots
+            SUBPLOT_PATTERN: /^x([0-9]*)y([0-9]*)$/,
+            HOUR_PATTERN: "hour",
+            WEEKDAY_PATTERN: "day of week",
+            // pixels to move mouse before you stop clamping to starting point
+            MINDRAG: 8,
+            // smallest dimension allowed for a zoombox
+            MINZOOM: 20,
+            // width of axis drag regions
+            DRAGGERSIZE: 20,
+            // delay before a redraw (relayout) after smooth panning and zooming
+            REDRAWDELAY: 50,
+            // last resort axis ranges for x and y axes if we have no data
+            DFLTRANGEX: [-1, 6],
+            DFLTRANGEY: [-1, 4],
+            // Layers to keep trace types in the right order
+            // N.B. each  'unique' plot method must have its own layer
+            traceLayerClasses: [
+              "imagelayer",
+              "heatmaplayer",
+              "contourcarpetlayer",
+              "contourlayer",
+              "funnellayer",
+              "waterfalllayer",
+              "barlayer",
+              "carpetlayer",
+              "violinlayer",
+              "boxlayer",
+              "ohlclayer",
+              "scattercarpetlayer",
+              "scatterlayer"
+            ],
+            clipOnAxisFalseQuery: [
+              ".scatterlayer",
+              ".barlayer",
+              ".funnellayer",
+              ".waterfalllayer"
+            ],
+            layerValue2layerClass: {
+              "above traces": "above",
+              "below traces": "below"
+            },
+            zindexSeparator: "z"
+            // used for zindex of cartesian subplots e.g. xy, xyz2, xyz3, etc.
+          };
+        }
+      });
+      var require_axis_ids = __commonJS({
+        "src/plots/cartesian/axis_ids.js"(exports) {
+          var Registry = require_registry();
+          var constants = require_constants2();
+          exports.id2name = function id2name(id2) {
+            if (typeof id2 !== "string" || !id2.match(constants.AX_ID_PATTERN)) return;
+            var axNum = id2.split(" ")[0].slice(1);
+            if (axNum === "1") axNum = "";
+            return id2.charAt(0) + "axis" + axNum;
+          };
+          exports.name2id = function name2id(name2) {
+            if (!name2.match(constants.AX_NAME_PATTERN)) return;
+            var axNum = name2.slice(5);
+            if (axNum === "1") axNum = "";
+            return name2.charAt(0) + axNum;
+          };
+          exports.cleanId = function cleanId(id2, axLetter, domainId) {
+            var domainTest = /( domain)$/.test(id2);
+            if (typeof id2 !== "string" || !id2.match(constants.AX_ID_PATTERN)) return;
+            if (axLetter && id2.charAt(0) !== axLetter) return;
+            if (domainTest && !domainId) return;
+            var axNum = id2.split(" ")[0].slice(1).replace(/^0+/, "");
+            if (axNum === "1") axNum = "";
+            return id2.charAt(0) + axNum + (domainTest && domainId ? " domain" : "");
+          };
+          exports.list = function(gd2, axLetter, only2d) {
+            var fullLayout = gd2._fullLayout;
+            if (!fullLayout) return [];
+            var idList = exports.listIds(gd2, axLetter);
+            var out = new Array(idList.length);
+            var i2;
+            for (i2 = 0; i2 < idList.length; i2++) {
+              var idi = idList[i2];
+              out[i2] = fullLayout[idi.charAt(0) + "axis" + idi.slice(1)];
+            }
+            if (!only2d) {
+              var sceneIds3D = fullLayout._subplots.gl3d || [];
+              for (i2 = 0; i2 < sceneIds3D.length; i2++) {
+                var scene = fullLayout[sceneIds3D[i2]];
+                if (axLetter) out.push(scene[axLetter + "axis"]);
+                else out.push(scene.xaxis, scene.yaxis, scene.zaxis);
+              }
+            }
+            return out;
+          };
+          exports.listIds = function(gd2, axLetter) {
+            var fullLayout = gd2._fullLayout;
+            if (!fullLayout) return [];
+            var subplotLists = fullLayout._subplots;
+            if (axLetter) return subplotLists[axLetter + "axis"];
+            return subplotLists.xaxis.concat(subplotLists.yaxis);
+          };
+          exports.getFromId = function(gd2, id2, type) {
+            var fullLayout = gd2._fullLayout;
+            id2 = id2 === void 0 || typeof id2 !== "string" ? id2 : id2.replace(" domain", "");
+            if (type === "x") id2 = id2.replace(/y[0-9]*/, "");
+            else if (type === "y") id2 = id2.replace(/x[0-9]*/, "");
+            return fullLayout[exports.id2name(id2)];
+          };
+          exports.getFromTrace = function(gd2, fullTrace, type) {
+            var fullLayout = gd2._fullLayout;
+            var ax = null;
+            if (Registry.traceIs(fullTrace, "gl3d")) {
+              var scene = fullTrace.scene;
+              if (scene.slice(0, 5) === "scene") {
+                ax = fullLayout[scene][type + "axis"];
+              }
+            } else {
+              ax = exports.getFromId(gd2, fullTrace[type + "axis"] || type);
+            }
+            return ax;
+          };
+          exports.idSort = function(id1, id2) {
+            var letter1 = id1.charAt(0);
+            var letter2 = id2.charAt(0);
+            if (letter1 !== letter2) return letter1 > letter2 ? 1 : -1;
+            return +(id1.slice(1) || 1) - +(id2.slice(1) || 1);
+          };
+          exports.ref2id = function(ar) {
+            return /^[xyz]/.test(ar) ? ar.split(" ")[0] : false;
+          };
+          function isFound(axId, list) {
+            if (list && list.length) {
+              for (var i2 = 0; i2 < list.length; i2++) {
+                if (list[i2][axId]) return true;
+              }
+            }
+            return false;
+          }
+          exports.isLinked = function(fullLayout, axId) {
+            return isFound(axId, fullLayout._axisMatchGroups) || isFound(axId, fullLayout._axisConstraintGroups);
+          };
+        }
+      });
+      var require_handle_outline = __commonJS({
+        "src/components/shapes/handle_outline.js"(exports, module2) {
+          function clearOutlineControllers(gd2) {
+            var zoomLayer = gd2._fullLayout._zoomlayer;
+            if (zoomLayer) {
+              zoomLayer.selectAll(".outline-controllers").remove();
+            }
+          }
+          function clearOutline(gd2) {
+            var zoomLayer = gd2._fullLayout._zoomlayer;
+            if (zoomLayer) {
+              zoomLayer.selectAll(".select-outline").remove();
+            }
+            gd2._fullLayout._outlining = false;
+          }
+          module2.exports = {
+            clearOutlineControllers,
+            clearOutline
+          };
+        }
+      });
+      var require_layout_attributes3 = __commonJS({
+        "src/traces/scatter/layout_attributes.js"(exports, module2) {
+          module2.exports = {
+            scattermode: {
+              valType: "enumerated",
+              values: ["group", "overlay"],
+              dflt: "overlay",
+              editType: "calc"
+            },
+            scattergap: {
+              valType: "number",
+              min: 0,
+              max: 1,
+              editType: "calc"
+            }
+          };
+        }
+      });
+      var require_get_data = __commonJS({
+        "src/plots/get_data.js"(exports) {
+          var Registry = require_registry();
+          require_constants2().SUBPLOT_PATTERN;
+          exports.getSubplotCalcData = function(calcData, type, subplotId) {
+            var basePlotModule = Registry.subplotsRegistry[type];
+            if (!basePlotModule) return [];
+            var attr = basePlotModule.attr;
+            var subplotCalcData = [];
+            for (var i2 = 0; i2 < calcData.length; i2++) {
+              var calcTrace = calcData[i2];
+              var trace = calcTrace[0].trace;
+              if (trace[attr] === subplotId) subplotCalcData.push(calcTrace);
+            }
+            return subplotCalcData;
+          };
+          exports.getModuleCalcData = function(calcdata, arg1, arg2) {
+            var moduleCalcData = [];
+            var remainingCalcData = [];
+            var plotMethod;
+            if (typeof arg1 === "string") {
+              plotMethod = Registry.getModule(arg1).plot;
+            } else if (typeof arg1 === "function") {
+              plotMethod = arg1;
+            } else {
+              plotMethod = arg1.plot;
+            }
+            if (!plotMethod) {
+              return [moduleCalcData, calcdata];
+            }
+            var zorder = arg2;
+            for (var i2 = 0; i2 < calcdata.length; i2++) {
+              var cd2 = calcdata[i2];
+              var trace = cd2[0].trace;
+              var filterByZ = trace.zorder !== void 0;
+              if (trace.visible !== true || trace._length === 0) continue;
+              if (trace._module && trace._module.plot === plotMethod && (!filterByZ || trace.zorder === zorder)) {
+                moduleCalcData.push(cd2);
+              } else {
+                remainingCalcData.push(cd2);
+              }
+            }
+            return [moduleCalcData, remainingCalcData];
+          };
+          exports.getSubplotData = function getSubplotData(data, type, subplotId) {
+            if (!Registry.subplotsRegistry[type]) return [];
+            var attr = Registry.subplotsRegistry[type].attr;
+            var subplotData = [];
+            var trace;
+            for (var i2 = 0; i2 < data.length; i2++) {
+              trace = data[i2];
+              if (trace[attr] === subplotId) subplotData.push(trace);
+            }
+            return subplotData;
+          };
+        }
+      });
+      var require_command = __commonJS({
+        "src/plots/command.js"(exports) {
+          var Registry = require_registry();
+          var Lib = require_lib();
+          exports.manageCommandObserver = function(gd2, container, commandList, onchange) {
+            var ret = {};
+            var enabled = true;
+            if (container && container._commandObserver) {
+              ret = container._commandObserver;
+            }
+            if (!ret.cache) {
+              ret.cache = {};
+            }
+            ret.lookupTable = {};
+            var binding = exports.hasSimpleAPICommandBindings(gd2, commandList, ret.lookupTable);
+            if (container && container._commandObserver) {
+              if (!binding) {
+                if (container._commandObserver.remove) {
+                  container._commandObserver.remove();
+                  container._commandObserver = null;
+                  return ret;
+                }
+              } else {
+                return ret;
+              }
+            }
+            if (binding) {
+              bindingValueHasChanged(gd2, binding, ret.cache);
+              ret.check = function check() {
+                if (!enabled) return;
+                var update = bindingValueHasChanged(gd2, binding, ret.cache);
+                if (update.changed && onchange) {
+                  if (ret.lookupTable[update.value] !== void 0) {
+                    ret.disable();
+                    Promise.resolve(onchange({
+                      value: update.value,
+                      type: binding.type,
+                      prop: binding.prop,
+                      traces: binding.traces,
+                      index: ret.lookupTable[update.value]
+                    })).then(ret.enable, ret.enable);
+                  }
+                }
+                return update.changed;
+              };
+              var checkEvents = [
+                "plotly_relayout",
+                "plotly_redraw",
+                "plotly_restyle",
+                "plotly_update",
+                "plotly_animatingframe",
+                "plotly_afterplot"
+              ];
+              for (var i2 = 0; i2 < checkEvents.length; i2++) {
+                gd2._internalOn(checkEvents[i2], ret.check);
+              }
+              ret.remove = function() {
+                for (var i22 = 0; i22 < checkEvents.length; i22++) {
+                  gd2._removeInternalListener(checkEvents[i22], ret.check);
+                }
+              };
+            } else {
+              Lib.log("Unable to automatically bind plot updates to API command");
+              ret.lookupTable = {};
+              ret.remove = function() {
+              };
+            }
+            ret.disable = function disable() {
+              enabled = false;
+            };
+            ret.enable = function enable2() {
+              enabled = true;
+            };
+            if (container) {
+              container._commandObserver = ret;
+            }
+            return ret;
+          };
+          exports.hasSimpleAPICommandBindings = function(gd2, commandList, bindingsByValue) {
+            var i2;
+            var n2 = commandList.length;
+            var refBinding;
+            for (i2 = 0; i2 < n2; i2++) {
+              var binding;
+              var command = commandList[i2];
+              var method = command.method;
+              var args = command.args;
+              if (!Array.isArray(args)) args = [];
+              if (!method) {
+                return false;
+              }
+              var bindings = exports.computeAPICommandBindings(gd2, method, args);
+              if (bindings.length !== 1) {
+                return false;
+              }
+              if (!refBinding) {
+                refBinding = bindings[0];
+                if (Array.isArray(refBinding.traces)) {
+                  refBinding.traces.sort();
+                }
+              } else {
+                binding = bindings[0];
+                if (binding.type !== refBinding.type) {
+                  return false;
+                }
+                if (binding.prop !== refBinding.prop) {
+                  return false;
+                }
+                if (Array.isArray(refBinding.traces)) {
+                  if (Array.isArray(binding.traces)) {
+                    binding.traces.sort();
+                    for (var j2 = 0; j2 < refBinding.traces.length; j2++) {
+                      if (refBinding.traces[j2] !== binding.traces[j2]) {
+                        return false;
+                      }
+                    }
+                  } else {
+                    return false;
+                  }
+                } else {
+                  if (binding.prop !== refBinding.prop) {
+                    return false;
+                  }
+                }
+              }
+              binding = bindings[0];
+              var value = binding.value;
+              if (Array.isArray(value)) {
+                if (value.length === 1) {
+                  value = value[0];
+                } else {
+                  return false;
+                }
+              }
+              if (bindingsByValue) {
+                bindingsByValue[value] = i2;
+              }
+            }
+            return refBinding;
+          };
+          function bindingValueHasChanged(gd2, binding, cache) {
+            var container, value, obj;
+            var changed = false;
+            if (binding.type === "data") {
+              container = gd2._fullData[binding.traces !== null ? binding.traces[0] : 0];
+            } else if (binding.type === "layout") {
+              container = gd2._fullLayout;
+            } else {
+              return false;
+            }
+            value = Lib.nestedProperty(container, binding.prop).get();
+            obj = cache[binding.type] = cache[binding.type] || {};
+            if (obj.hasOwnProperty(binding.prop)) {
+              if (obj[binding.prop] !== value) {
+                changed = true;
+              }
+            }
+            obj[binding.prop] = value;
+            return {
+              changed,
+              value
+            };
+          }
+          exports.executeAPICommand = function(gd2, method, args) {
+            if (method === "skip") return Promise.resolve();
+            var _method = Registry.apiMethodRegistry[method];
+            var allArgs = [gd2];
+            if (!Array.isArray(args)) args = [];
+            for (var i2 = 0; i2 < args.length; i2++) {
+              allArgs.push(args[i2]);
+            }
+            return _method.apply(null, allArgs).catch(function(err) {
+              Lib.warn("API call to Plotly." + method + " rejected.", err);
+              return Promise.reject(err);
+            });
+          };
+          exports.computeAPICommandBindings = function(gd2, method, args) {
+            var bindings;
+            if (!Array.isArray(args)) args = [];
+            switch (method) {
+              case "restyle":
+                bindings = computeDataBindings(gd2, args);
+                break;
+              case "relayout":
+                bindings = computeLayoutBindings(gd2, args);
+                break;
+              case "update":
+                bindings = computeDataBindings(gd2, [args[0], args[2]]).concat(computeLayoutBindings(gd2, [args[1]]));
+                break;
+              case "animate":
+                bindings = computeAnimateBindings(gd2, args);
+                break;
+              default:
+                bindings = [];
+            }
+            return bindings;
+          };
+          function computeAnimateBindings(gd2, args) {
+            if (Array.isArray(args[0]) && args[0].length === 1 && ["string", "number"].indexOf(typeof args[0][0]) !== -1) {
+              return [{ type: "layout", prop: "_currentFrame", value: args[0][0].toString() }];
+            } else {
+              return [];
+            }
+          }
+          function computeLayoutBindings(gd2, args) {
+            var bindings = [];
+            var astr = args[0];
+            var aobj = {};
+            if (typeof astr === "string") {
+              aobj[astr] = args[1];
+            } else if (Lib.isPlainObject(astr)) {
+              aobj = astr;
+            } else {
+              return bindings;
+            }
+            crawl(aobj, function(path, attrName, attr) {
+              bindings.push({ type: "layout", prop: path, value: attr });
+            }, "", 0);
+            return bindings;
+          }
+          function computeDataBindings(gd2, args) {
+            var traces, astr, val, aobj;
+            var bindings = [];
+            astr = args[0];
+            val = args[1];
+            traces = args[2];
+            aobj = {};
+            if (typeof astr === "string") {
+              aobj[astr] = val;
+            } else if (Lib.isPlainObject(astr)) {
+              aobj = astr;
+              if (traces === void 0) {
+                traces = val;
+              }
+            } else {
+              return bindings;
+            }
+            if (traces === void 0) {
+              traces = null;
+            }
+            crawl(aobj, function(path, attrName, _attr) {
+              var thisTraces;
+              var attr;
+              if (Array.isArray(_attr)) {
+                attr = _attr.slice();
+                var nAttr = Math.min(attr.length, gd2.data.length);
+                if (traces) {
+                  nAttr = Math.min(nAttr, traces.length);
+                }
+                thisTraces = [];
+                for (var j2 = 0; j2 < nAttr; j2++) {
+                  thisTraces[j2] = traces ? traces[j2] : j2;
+                }
+              } else {
+                attr = _attr;
+                thisTraces = traces ? traces.slice() : null;
+              }
+              if (thisTraces === null) {
+                if (Array.isArray(attr)) {
+                  attr = attr[0];
+                }
+              } else if (Array.isArray(thisTraces)) {
+                if (!Array.isArray(attr)) {
+                  var tmp2 = attr;
+                  attr = [];
+                  for (var i2 = 0; i2 < thisTraces.length; i2++) {
+                    attr[i2] = tmp2;
+                  }
+                }
+                attr.length = Math.min(thisTraces.length, attr.length);
+              }
+              bindings.push({
+                type: "data",
+                prop: path,
+                traces: thisTraces,
+                value: attr
+              });
+            }, "", 0);
+            return bindings;
+          }
+          function crawl(attrs, callback, path, depth) {
+            Object.keys(attrs).forEach(function(attrName) {
+              var attr = attrs[attrName];
+              if (attrName[0] === "_") return;
+              var thisPath = path + (depth > 0 ? "." : "") + attrName;
+              if (Lib.isPlainObject(attr)) {
+                crawl(attr, callback, thisPath, depth + 1);
+              } else {
+                callback(thisPath, attrName, attr);
+              }
+            });
+          }
+        }
+      });
+      var require_plots = __commonJS({
+        "src/plots/plots.js"(exports, module2) {
+          var d3 = require_d3();
+          var timeFormatLocale = require_d3_time_format().timeFormatLocale;
+          var formatLocale = require_d3_format().formatLocale;
+          var isNumeric = require_fast_isnumeric();
+          var b64encode = require_base64_arraybuffer_umd();
+          var Registry = require_registry();
+          var PlotSchema = require_plot_schema();
+          var Template = require_plot_template();
+          var Lib = require_lib();
+          var Color2 = require_color();
+          var BADNUM = require_numerical().BADNUM;
+          var axisIDs = require_axis_ids();
+          var clearOutline = require_handle_outline().clearOutline;
+          var scatterAttrs = require_layout_attributes3();
+          var animationAttrs = require_animation_attributes();
+          var frameAttrs = require_frame_attributes();
+          var getModuleCalcData = require_get_data().getModuleCalcData;
+          var relinkPrivateKeys = Lib.relinkPrivateKeys;
+          var _2 = Lib._;
+          var plots = module2.exports = {};
+          Lib.extendFlat(plots, Registry);
+          plots.attributes = require_attributes2();
+          plots.attributes.type.values = plots.allTypes;
+          plots.fontAttrs = require_font_attributes();
+          plots.layoutAttributes = require_layout_attributes2();
+          var commandModule = require_command();
+          plots.executeAPICommand = commandModule.executeAPICommand;
+          plots.computeAPICommandBindings = commandModule.computeAPICommandBindings;
+          plots.manageCommandObserver = commandModule.manageCommandObserver;
+          plots.hasSimpleAPICommandBindings = commandModule.hasSimpleAPICommandBindings;
+          plots.redrawText = function(gd2) {
+            gd2 = Lib.getGraphDiv(gd2);
+            return new Promise(function(resolve) {
+              setTimeout(function() {
+                if (!gd2._fullLayout) return;
+                Registry.getComponentMethod("annotations", "draw")(gd2);
+                Registry.getComponentMethod("legend", "draw")(gd2);
+                Registry.getComponentMethod("colorbar", "draw")(gd2);
+                resolve(plots.previousPromises(gd2));
+              }, 300);
+            });
+          };
+          plots.resize = function(gd2) {
+            gd2 = Lib.getGraphDiv(gd2);
+            var resolveLastResize;
+            var p2 = new Promise(function(resolve, reject) {
+              if (!gd2 || Lib.isHidden(gd2)) {
+                reject(new Error("Resize must be passed a displayed plot div element."));
+              }
+              if (gd2._redrawTimer) clearTimeout(gd2._redrawTimer);
+              if (gd2._resolveResize) resolveLastResize = gd2._resolveResize;
+              gd2._resolveResize = resolve;
+              gd2._redrawTimer = setTimeout(function() {
+                if (!gd2.layout || gd2.layout.width && gd2.layout.height || Lib.isHidden(gd2)) {
+                  resolve(gd2);
+                  return;
+                }
+                delete gd2.layout.width;
+                delete gd2.layout.height;
+                var oldchanged = gd2.changed;
+                gd2.autoplay = true;
+                Registry.call("relayout", gd2, { autosize: true }).then(function() {
+                  gd2.changed = oldchanged;
+                  if (gd2._resolveResize === resolve) {
+                    delete gd2._resolveResize;
+                    resolve(gd2);
+                  }
+                });
+              }, 100);
+            });
+            if (resolveLastResize) resolveLastResize(p2);
+            return p2;
+          };
+          plots.previousPromises = function(gd2) {
+            if ((gd2._promises || []).length) {
+              return Promise.all(gd2._promises).then(function() {
+                gd2._promises = [];
+              });
+            }
+          };
+          plots.addLinks = function(gd2) {
+            if (!gd2._context.showLink && !gd2._context.showSources) return;
+            var fullLayout = gd2._fullLayout;
+            var linkContainer = Lib.ensureSingle(fullLayout._paper, "text", "js-plot-link-container", function(s2) {
+              s2.style({
+                "font-family": '"Open Sans", Arial, sans-serif',
+                "font-size": "12px",
+                fill: Color2.defaultLine,
+                "pointer-events": "all"
+              }).each(function() {
+                var links = d3.select(this);
+                links.append("tspan").classed("js-link-to-tool", true);
+                links.append("tspan").classed("js-link-spacer", true);
+                links.append("tspan").classed("js-sourcelinks", true);
+              });
+            });
+            var text = linkContainer.node();
+            var attrs = { y: fullLayout._paper.attr("height") - 9 };
+            if (document.body.contains(text) && text.getComputedTextLength() >= fullLayout.width - 20) {
+              attrs["text-anchor"] = "start";
+              attrs.x = 5;
+            } else {
+              attrs["text-anchor"] = "end";
+              attrs.x = fullLayout._paper.attr("width") - 7;
+            }
+            linkContainer.attr(attrs);
+            var toolspan = linkContainer.select(".js-link-to-tool");
+            var spacespan = linkContainer.select(".js-link-spacer");
+            var sourcespan = linkContainer.select(".js-sourcelinks");
+            if (gd2._context.showSources) gd2._context.showSources(gd2);
+            if (gd2._context.showLink) positionPlayWithData(gd2, toolspan);
+            spacespan.text(toolspan.text() && sourcespan.text() ? " - " : "");
+          };
+          function positionPlayWithData(gd2, container) {
+            container.text("");
+            var link = container.append("a").attr({
+              "xlink:xlink:href": "#",
+              class: "link--impt link--embedview",
+              "font-weight": "bold"
+            }).text(gd2._context.linkText + " " + String.fromCharCode(187));
+            if (gd2._context.sendData) {
+              link.on("click", function() {
+                plots.sendDataToCloud(gd2);
+              });
+            } else {
+              var path = window.location.pathname.split("/");
+              var query = window.location.search;
+              link.attr({
+                "xlink:xlink:show": "new",
+                "xlink:xlink:href": "/" + path[2].split(".")[0] + "/" + path[1] + query
+              });
+            }
+          }
+          plots.sendDataToCloud = function(gd2) {
+            var baseUrl = (window.PLOTLYENV || {}).BASE_URL || gd2._context.plotlyServerURL;
+            if (!baseUrl) return;
+            gd2.emit("plotly_beforeexport");
+            var hiddenformDiv = d3.select(gd2).append("div").attr("id", "hiddenform").style("display", "none");
+            var hiddenform = hiddenformDiv.append("form").attr({
+              action: baseUrl + "/external",
+              method: "post",
+              target: "_blank"
+            });
+            var hiddenformInput = hiddenform.append("input").attr({
+              type: "text",
+              name: "data"
+            });
+            hiddenformInput.node().value = plots.graphJson(gd2, false, "keepdata");
+            hiddenform.node().submit();
+            hiddenformDiv.remove();
+            gd2.emit("plotly_afterexport");
+            return false;
+          };
+          var d3FormatKeys = [
+            "days",
+            "shortDays",
+            "months",
+            "shortMonths",
+            "periods",
+            "dateTime",
+            "date",
+            "time",
+            "decimal",
+            "thousands",
+            "grouping",
+            "currency"
+          ];
+          var extraFormatKeys = [
+            "year",
+            "month",
+            "dayMonth",
+            "dayMonthYear"
+          ];
+          plots.supplyDefaults = function(gd2, opts) {
+            var skipUpdateCalc = opts && opts.skipUpdateCalc;
+            var oldFullLayout = gd2._fullLayout || {};
+            if (oldFullLayout._skipDefaults) {
+              delete oldFullLayout._skipDefaults;
+              return;
+            }
+            var newFullLayout = gd2._fullLayout = {};
+            var newLayout = gd2.layout || {};
+            var oldFullData = gd2._fullData || [];
+            var newFullData = gd2._fullData = [];
+            var newData = gd2.data || [];
+            var oldCalcdata = gd2.calcdata || [];
+            var context = gd2._context || {};
+            var i2;
+            if (!gd2._transitionData) plots.createTransitionData(gd2);
+            newFullLayout._dfltTitle = {
+              plot: _2(gd2, "Click to enter Plot title"),
+              subtitle: _2(gd2, "Click to enter Plot subtitle"),
+              x: _2(gd2, "Click to enter X axis title"),
+              y: _2(gd2, "Click to enter Y axis title"),
+              colorbar: _2(gd2, "Click to enter Colorscale title"),
+              annotation: _2(gd2, "new text")
+            };
+            newFullLayout._traceWord = _2(gd2, "trace");
+            var formatObj = getFormatObj(gd2, d3FormatKeys);
+            newFullLayout._mapboxAccessToken = context.mapboxAccessToken;
+            if (oldFullLayout._initialAutoSizeIsDone) {
+              var oldWidth = oldFullLayout.width;
+              var oldHeight = oldFullLayout.height;
+              plots.supplyLayoutGlobalDefaults(newLayout, newFullLayout, formatObj);
+              if (!newLayout.width) newFullLayout.width = oldWidth;
+              if (!newLayout.height) newFullLayout.height = oldHeight;
+              plots.sanitizeMargins(newFullLayout);
+            } else {
+              plots.supplyLayoutGlobalDefaults(newLayout, newFullLayout, formatObj);
+              var missingWidthOrHeight = !newLayout.width || !newLayout.height;
+              var autosize = newFullLayout.autosize;
+              var autosizable = context.autosizable;
+              var initialAutoSize = missingWidthOrHeight && (autosize || autosizable);
+              if (initialAutoSize) plots.plotAutoSize(gd2, newLayout, newFullLayout);
+              else if (missingWidthOrHeight) plots.sanitizeMargins(newFullLayout);
+              if (!autosize && missingWidthOrHeight) {
+                newLayout.width = newFullLayout.width;
+                newLayout.height = newFullLayout.height;
+              }
+            }
+            newFullLayout._d3locale = getFormatter(formatObj, newFullLayout.separators);
+            newFullLayout._extraFormat = getFormatObj(gd2, extraFormatKeys);
+            newFullLayout._initialAutoSizeIsDone = true;
+            newFullLayout._dataLength = newData.length;
+            newFullLayout._modules = [];
+            newFullLayout._visibleModules = [];
+            newFullLayout._basePlotModules = [];
+            var subplots = newFullLayout._subplots = emptySubplotLists();
+            var splomAxes = newFullLayout._splomAxes = { x: {}, y: {} };
+            var splomSubplots = newFullLayout._splomSubplots = {};
+            newFullLayout._splomGridDflt = {};
+            newFullLayout._scatterStackOpts = {};
+            newFullLayout._firstScatter = {};
+            newFullLayout._alignmentOpts = {};
+            newFullLayout._colorAxes = {};
+            newFullLayout._requestRangeslider = {};
+            newFullLayout._traceUids = getTraceUids(oldFullData, newData);
+            plots.supplyDataDefaults(newData, newFullData, newLayout, newFullLayout);
+            var splomXa = Object.keys(splomAxes.x);
+            var splomYa = Object.keys(splomAxes.y);
+            if (splomXa.length > 1 && splomYa.length > 1) {
+              Registry.getComponentMethod("grid", "sizeDefaults")(newLayout, newFullLayout);
+              for (i2 = 0; i2 < splomXa.length; i2++) {
+                Lib.pushUnique(subplots.xaxis, splomXa[i2]);
+              }
+              for (i2 = 0; i2 < splomYa.length; i2++) {
+                Lib.pushUnique(subplots.yaxis, splomYa[i2]);
+              }
+              for (var k2 in splomSubplots) {
+                Lib.pushUnique(subplots.cartesian, k2);
+              }
+            }
+            newFullLayout._has = plots._hasPlotType.bind(newFullLayout);
+            if (oldFullData.length === newFullData.length) {
+              for (i2 = 0; i2 < newFullData.length; i2++) {
+                relinkPrivateKeys(newFullData[i2], oldFullData[i2]);
+              }
+            }
+            plots.supplyLayoutModuleDefaults(newLayout, newFullLayout, newFullData, gd2._transitionData);
+            var _modules = newFullLayout._visibleModules;
+            var crossTraceDefaultsFuncs = [];
+            for (i2 = 0; i2 < _modules.length; i2++) {
+              var funci = _modules[i2].crossTraceDefaults;
+              if (funci) Lib.pushUnique(crossTraceDefaultsFuncs, funci);
+            }
+            for (i2 = 0; i2 < crossTraceDefaultsFuncs.length; i2++) {
+              crossTraceDefaultsFuncs[i2](newFullData, newFullLayout);
+            }
+            newFullLayout._hasOnlyLargeSploms = newFullLayout._basePlotModules.length === 1 && newFullLayout._basePlotModules[0].name === "splom" && splomXa.length > 15 && splomYa.length > 15 && newFullLayout.shapes.length === 0 && newFullLayout.images.length === 0;
+            plots.linkSubplots(newFullData, newFullLayout, oldFullData, oldFullLayout);
+            plots.cleanPlot(newFullData, newFullLayout, oldFullData, oldFullLayout);
+            var hadCartesian = !!(oldFullLayout._has && oldFullLayout._has("cartesian"));
+            var hasCartesian = !!(newFullLayout._has && newFullLayout._has("cartesian"));
+            var hadBgLayer = hadCartesian;
+            var hasBgLayer = hasCartesian;
+            if (hadBgLayer && !hasBgLayer) {
+              oldFullLayout._bgLayer.remove();
+            } else if (hasBgLayer && !hadBgLayer) {
+              newFullLayout._shouldCreateBgLayer = true;
+            }
+            if (oldFullLayout._zoomlayer && !gd2._dragging) {
+              clearOutline({
+                // mock old gd
+                _fullLayout: oldFullLayout
+              });
+            }
+            fillMetaTextHelpers(newFullData, newFullLayout);
+            relinkPrivateKeys(newFullLayout, oldFullLayout);
+            Registry.getComponentMethod("colorscale", "crossTraceDefaults")(newFullData, newFullLayout);
+            if (!newFullLayout._preGUI) newFullLayout._preGUI = {};
+            if (!newFullLayout._tracePreGUI) newFullLayout._tracePreGUI = {};
+            var tracePreGUI = newFullLayout._tracePreGUI;
+            var uids = {};
+            var uid2;
+            for (uid2 in tracePreGUI) uids[uid2] = "old";
+            for (i2 = 0; i2 < newFullData.length; i2++) {
+              uid2 = newFullData[i2]._fullInput.uid;
+              if (!uids[uid2]) tracePreGUI[uid2] = {};
+              uids[uid2] = "new";
+            }
+            for (uid2 in uids) {
+              if (uids[uid2] === "old") delete tracePreGUI[uid2];
+            }
+            initMargins(newFullLayout);
+            Registry.getComponentMethod("rangeslider", "makeData")(newFullLayout);
+            if (!skipUpdateCalc && oldCalcdata.length === newFullData.length) {
+              plots.supplyDefaultsUpdateCalc(oldCalcdata, newFullData);
+            }
+          };
+          plots.supplyDefaultsUpdateCalc = function(oldCalcdata, newFullData) {
+            for (var i2 = 0; i2 < newFullData.length; i2++) {
+              var newTrace = newFullData[i2];
+              var cd0 = (oldCalcdata[i2] || [])[0];
+              if (cd0 && cd0.trace) {
+                var oldTrace = cd0.trace;
+                if (oldTrace._hasCalcTransform) {
+                  var arrayAttrs = oldTrace._arrayAttrs;
+                  var j2, astr, oldArrayVal;
+                  for (j2 = 0; j2 < arrayAttrs.length; j2++) {
+                    astr = arrayAttrs[j2];
+                    oldArrayVal = Lib.nestedProperty(oldTrace, astr).get().slice();
+                    Lib.nestedProperty(newTrace, astr).set(oldArrayVal);
+                  }
+                }
+                cd0.trace = newTrace;
+              }
+            }
+          };
+          function getTraceUids(oldFullData, newData) {
+            var len2 = newData.length;
+            var oldFullInput = [];
+            var i2, prevFullInput;
+            for (i2 = 0; i2 < oldFullData.length; i2++) {
+              var thisFullInput = oldFullData[i2]._fullInput;
+              if (thisFullInput !== prevFullInput) oldFullInput.push(thisFullInput);
+              prevFullInput = thisFullInput;
+            }
+            var oldLen = oldFullInput.length;
+            var out = new Array(len2);
+            var seenUids = {};
+            function setUid(uid2, i22) {
+              out[i22] = uid2;
+              seenUids[uid2] = 1;
+            }
+            function tryUid(uid2, i22) {
+              if (uid2 && typeof uid2 === "string" && !seenUids[uid2]) {
+                setUid(uid2, i22);
+                return true;
+              }
+            }
+            for (i2 = 0; i2 < len2; i2++) {
+              var newUid = newData[i2].uid;
+              if (typeof newUid === "number") newUid = String(newUid);
+              if (tryUid(newUid, i2)) continue;
+              if (i2 < oldLen && tryUid(oldFullInput[i2].uid, i2)) continue;
+              setUid(Lib.randstr(seenUids), i2);
+            }
+            return out;
+          }
+          function emptySubplotLists() {
+            var collectableSubplotTypes = Registry.collectableSubplotTypes;
+            var out = {};
+            var i2, j2;
+            if (!collectableSubplotTypes) {
+              collectableSubplotTypes = [];
+              var subplotsRegistry = Registry.subplotsRegistry;
+              for (var subplotType in subplotsRegistry) {
+                var subplotModule = subplotsRegistry[subplotType];
+                var subplotAttr = subplotModule.attr;
+                if (subplotAttr) {
+                  collectableSubplotTypes.push(subplotType);
+                  if (Array.isArray(subplotAttr)) {
+                    for (j2 = 0; j2 < subplotAttr.length; j2++) {
+                      Lib.pushUnique(collectableSubplotTypes, subplotAttr[j2]);
+                    }
+                  }
+                }
+              }
+            }
+            for (i2 = 0; i2 < collectableSubplotTypes.length; i2++) {
+              out[collectableSubplotTypes[i2]] = [];
+            }
+            return out;
+          }
+          function getFormatObj(gd2, formatKeys) {
+            var locale = gd2._context.locale;
+            if (!locale) locale = "en-US";
+            var formatDone = false;
+            var formatObj = {};
+            function includeFormat(newFormat) {
+              var formatFinished = true;
+              for (var i22 = 0; i22 < formatKeys.length; i22++) {
+                var formatKey = formatKeys[i22];
+                if (!formatObj[formatKey]) {
+                  if (newFormat[formatKey]) {
+                    formatObj[formatKey] = newFormat[formatKey];
+                  } else formatFinished = false;
+                }
+              }
+              if (formatFinished) formatDone = true;
+            }
+            for (var i2 = 0; i2 < 2; i2++) {
+              var locales = gd2._context.locales;
+              for (var j2 = 0; j2 < 2; j2++) {
+                var formatj = (locales[locale] || {}).format;
+                if (formatj) {
+                  includeFormat(formatj);
+                  if (formatDone) break;
+                }
+                locales = Registry.localeRegistry;
+              }
+              var baseLocale = locale.split("-")[0];
+              if (formatDone || baseLocale === locale) break;
+              locale = baseLocale;
+            }
+            if (!formatDone) includeFormat(Registry.localeRegistry.en.format);
+            return formatObj;
+          }
+          function getFormatter(formatObj, separators) {
+            formatObj.decimal = separators.charAt(0);
+            formatObj.thousands = separators.charAt(1);
+            return {
+              numberFormat: function(formatStr) {
+                try {
+                  formatStr = formatLocale(formatObj).format(
+                    Lib.adjustFormat(formatStr)
+                  );
+                } catch (e2) {
+                  Lib.warnBadFormat(formatStr);
+                  return Lib.noFormat;
+                }
+                return formatStr;
+              },
+              timeFormat: timeFormatLocale(formatObj).utcFormat
+            };
+          }
+          function fillMetaTextHelpers(newFullData, newFullLayout) {
+            var _meta;
+            var meta4data = [];
+            if (newFullLayout.meta) {
+              _meta = newFullLayout._meta = {
+                meta: newFullLayout.meta,
+                layout: { meta: newFullLayout.meta }
+              };
+            }
+            for (var i2 = 0; i2 < newFullData.length; i2++) {
+              var trace = newFullData[i2];
+              if (trace.meta) {
+                meta4data[trace.index] = trace._meta = { meta: trace.meta };
+              } else if (newFullLayout.meta) {
+                trace._meta = { meta: newFullLayout.meta };
+              }
+              if (newFullLayout.meta) {
+                trace._meta.layout = { meta: newFullLayout.meta };
+              }
+            }
+            if (meta4data.length) {
+              if (!_meta) {
+                _meta = newFullLayout._meta = {};
+              }
+              _meta.data = meta4data;
+            }
+          }
+          plots.createTransitionData = function(gd2) {
+            if (!gd2._transitionData) {
+              gd2._transitionData = {};
+            }
+            if (!gd2._transitionData._frames) {
+              gd2._transitionData._frames = [];
+            }
+            if (!gd2._transitionData._frameHash) {
+              gd2._transitionData._frameHash = {};
+            }
+            if (!gd2._transitionData._counter) {
+              gd2._transitionData._counter = 0;
+            }
+            if (!gd2._transitionData._interruptCallbacks) {
+              gd2._transitionData._interruptCallbacks = [];
+            }
+          };
+          plots._hasPlotType = function(category) {
+            var i2;
+            var basePlotModules = this._basePlotModules || [];
+            for (i2 = 0; i2 < basePlotModules.length; i2++) {
+              if (basePlotModules[i2].name === category) return true;
+            }
+            var modules = this._modules || [];
+            for (i2 = 0; i2 < modules.length; i2++) {
+              var name2 = modules[i2].name;
+              if (name2 === category) return true;
+              var _module = Registry.modules[name2];
+              if (_module && _module.categories[category]) return true;
+            }
+            return false;
+          };
+          plots.cleanPlot = function(newFullData, newFullLayout, oldFullData, oldFullLayout) {
+            var i2, j2;
+            var basePlotModules = oldFullLayout._basePlotModules || [];
+            for (i2 = 0; i2 < basePlotModules.length; i2++) {
+              var _module = basePlotModules[i2];
+              if (_module.clean) {
+                _module.clean(newFullData, newFullLayout, oldFullData, oldFullLayout);
+              }
+            }
+            var hadGl = oldFullLayout._has && oldFullLayout._has("gl");
+            var hasGl = newFullLayout._has && newFullLayout._has("gl");
+            if (hadGl && !hasGl) {
+              if (oldFullLayout._glcontainer !== void 0) {
+                oldFullLayout._glcontainer.selectAll(".gl-canvas").remove();
+                oldFullLayout._glcontainer.selectAll(".no-webgl").remove();
+                oldFullLayout._glcanvas = null;
+              }
+            }
+            var hasInfoLayer = !!oldFullLayout._infolayer;
+            oldLoop:
+              for (i2 = 0; i2 < oldFullData.length; i2++) {
+                var oldTrace = oldFullData[i2];
+                var oldUid = oldTrace.uid;
+                for (j2 = 0; j2 < newFullData.length; j2++) {
+                  var newTrace = newFullData[j2];
+                  if (oldUid === newTrace.uid) continue oldLoop;
+                }
+                if (hasInfoLayer) {
+                  oldFullLayout._infolayer.select(".cb" + oldUid).remove();
+                }
+              }
+          };
+          plots.linkSubplots = function(newFullData, newFullLayout, oldFullData, oldFullLayout) {
+            var i2, j2;
+            var oldSubplots = oldFullLayout._plots || {};
+            var newSubplots = newFullLayout._plots = {};
+            var newSubplotList = newFullLayout._subplots;
+            var mockGd = {
+              _fullData: newFullData,
+              _fullLayout: newFullLayout
+            };
+            var ids = newSubplotList.cartesian || [];
+            for (i2 = 0; i2 < ids.length; i2++) {
+              var id2 = ids[i2];
+              var oldSubplot = oldSubplots[id2];
+              var xaxis = axisIDs.getFromId(mockGd, id2, "x");
+              var yaxis = axisIDs.getFromId(mockGd, id2, "y");
+              var plotinfo;
+              if (oldSubplot) {
+                plotinfo = newSubplots[id2] = oldSubplot;
+              } else {
+                plotinfo = newSubplots[id2] = {};
+                plotinfo.id = id2;
+              }
+              xaxis._counterAxes.push(yaxis._id);
+              yaxis._counterAxes.push(xaxis._id);
+              xaxis._subplotsWith.push(id2);
+              yaxis._subplotsWith.push(id2);
+              plotinfo.xaxis = xaxis;
+              plotinfo.yaxis = yaxis;
+              plotinfo._hasClipOnAxisFalse = false;
+              for (j2 = 0; j2 < newFullData.length; j2++) {
+                var trace = newFullData[j2];
+                if (trace.xaxis === plotinfo.xaxis._id && trace.yaxis === plotinfo.yaxis._id && trace.cliponaxis === false) {
+                  plotinfo._hasClipOnAxisFalse = true;
+                  break;
+                }
+              }
+            }
+            var axList = axisIDs.list(mockGd, null, true);
+            var ax;
+            for (i2 = 0; i2 < axList.length; i2++) {
+              ax = axList[i2];
+              var mainAx = null;
+              if (ax.overlaying) {
+                mainAx = axisIDs.getFromId(mockGd, ax.overlaying);
+                if (mainAx && mainAx.overlaying) {
+                  ax.overlaying = false;
+                  mainAx = null;
+                }
+              }
+              ax._mainAxis = mainAx || ax;
+              if (mainAx) ax.domain = mainAx.domain.slice();
+              ax._anchorAxis = ax.anchor === "free" ? null : axisIDs.getFromId(mockGd, ax.anchor);
+            }
+            for (i2 = 0; i2 < axList.length; i2++) {
+              ax = axList[i2];
+              ax._counterAxes.sort(axisIDs.idSort);
+              ax._subplotsWith.sort(Lib.subplotSort);
+              ax._mainSubplot = findMainSubplot(ax, newFullLayout);
+              if (ax._counterAxes.length && (ax.spikemode && ax.spikemode.indexOf("across") !== -1 || ax.automargin && ax.mirror && ax.anchor !== "free" || Registry.getComponentMethod("rangeslider", "isVisible")(ax))) {
+                var min = 1;
+                var max = 0;
+                for (j2 = 0; j2 < ax._counterAxes.length; j2++) {
+                  var ax2 = axisIDs.getFromId(mockGd, ax._counterAxes[j2]);
+                  min = Math.min(min, ax2.domain[0]);
+                  max = Math.max(max, ax2.domain[1]);
+                }
+                if (min < max) {
+                  ax._counterDomainMin = min;
+                  ax._counterDomainMax = max;
+                }
+              }
+            }
+          };
+          function findMainSubplot(ax, fullLayout) {
+            var mockGd = { _fullLayout: fullLayout };
+            var isX = ax._id.charAt(0) === "x";
+            var anchorAx = ax._mainAxis._anchorAxis;
+            var mainSubplotID = "";
+            var nextBestMainSubplotID = "";
+            var anchorID = "";
+            if (anchorAx) {
+              anchorID = anchorAx._mainAxis._id;
+              mainSubplotID = isX ? ax._id + anchorID : anchorID + ax._id;
+            }
+            if (!mainSubplotID || !fullLayout._plots[mainSubplotID]) {
+              mainSubplotID = "";
+              var counterIDs = ax._counterAxes;
+              for (var j2 = 0; j2 < counterIDs.length; j2++) {
+                var counterPart = counterIDs[j2];
+                var id2 = isX ? ax._id + counterPart : counterPart + ax._id;
+                if (!nextBestMainSubplotID) nextBestMainSubplotID = id2;
+                var counterAx = axisIDs.getFromId(mockGd, counterPart);
+                if (anchorID && counterAx.overlaying === anchorID) {
+                  mainSubplotID = id2;
+                  break;
+                }
+              }
+            }
+            return mainSubplotID || nextBestMainSubplotID;
+          }
+          plots.clearExpandedTraceDefaultColors = function(trace) {
+            var colorAttrs, path, i2;
+            function locateColorAttrs(attr, attrName, attrs, level) {
+              path[level] = attrName;
+              path.length = level + 1;
+              if (attr.valType === "color" && attr.dflt === void 0) {
+                colorAttrs.push(path.join("."));
+              }
+            }
+            path = [];
+            colorAttrs = trace._module._colorAttrs;
+            if (!colorAttrs) {
+              trace._module._colorAttrs = colorAttrs = [];
+              PlotSchema.crawl(
+                trace._module.attributes,
+                locateColorAttrs
+              );
+            }
+            for (i2 = 0; i2 < colorAttrs.length; i2++) {
+              var origprop = Lib.nestedProperty(trace, "_input." + colorAttrs[i2]);
+              if (!origprop.get()) {
+                Lib.nestedProperty(trace, colorAttrs[i2]).set(null);
+              }
+            }
+          };
+          plots.supplyDataDefaults = function(dataIn, dataOut, layout, fullLayout) {
+            var modules = fullLayout._modules;
+            var visibleModules = fullLayout._visibleModules;
+            var basePlotModules = fullLayout._basePlotModules;
+            var colorCnt = 0;
+            var i2, fullTrace, trace;
+            fullLayout._transformModules = [];
+            function pushModule(fullTrace2) {
+              dataOut.push(fullTrace2);
+              var _module = fullTrace2._module;
+              if (!_module) return;
+              Lib.pushUnique(modules, _module);
+              if (fullTrace2.visible === true) Lib.pushUnique(visibleModules, _module);
+              Lib.pushUnique(basePlotModules, fullTrace2._module.basePlotModule);
+              if (fullTrace2._input.visible !== false) colorCnt++;
+            }
+            var carpetIndex = {};
+            var carpetDependents = [];
+            var dataTemplate = (layout.template || {}).data || {};
+            var templater = Template.traceTemplater(dataTemplate);
+            for (i2 = 0; i2 < dataIn.length; i2++) {
+              trace = dataIn[i2];
+              fullTrace = templater.newTrace(trace);
+              fullTrace.uid = fullLayout._traceUids[i2];
+              plots.supplyTraceDefaults(trace, fullTrace, colorCnt, fullLayout, i2);
+              fullTrace.index = i2;
+              fullTrace._input = trace;
+              fullTrace._fullInput = fullTrace;
+              pushModule(fullTrace);
+              if (Registry.traceIs(fullTrace, "carpetAxis")) {
+                carpetIndex[fullTrace.carpet] = fullTrace;
+              }
+              if (Registry.traceIs(fullTrace, "carpetDependent")) {
+                carpetDependents.push(i2);
+              }
+            }
+            for (i2 = 0; i2 < carpetDependents.length; i2++) {
+              fullTrace = dataOut[carpetDependents[i2]];
+              if (!fullTrace.visible) continue;
+              var carpetAxis = carpetIndex[fullTrace.carpet];
+              fullTrace._carpet = carpetAxis;
+              if (!carpetAxis || !carpetAxis.visible) {
+                fullTrace.visible = false;
+                continue;
+              }
+              fullTrace.xaxis = carpetAxis.xaxis;
+              fullTrace.yaxis = carpetAxis.yaxis;
+            }
+          };
+          plots.supplyAnimationDefaults = function(opts) {
+            opts = opts || {};
+            var i2;
+            var optsOut = {};
+            function coerce(attr, dflt) {
+              return Lib.coerce(opts || {}, optsOut, animationAttrs, attr, dflt);
+            }
+            coerce("mode");
+            coerce("direction");
+            coerce("fromcurrent");
+            if (Array.isArray(opts.frame)) {
+              optsOut.frame = [];
+              for (i2 = 0; i2 < opts.frame.length; i2++) {
+                optsOut.frame[i2] = plots.supplyAnimationFrameDefaults(opts.frame[i2] || {});
+              }
+            } else {
+              optsOut.frame = plots.supplyAnimationFrameDefaults(opts.frame || {});
+            }
+            if (Array.isArray(opts.transition)) {
+              optsOut.transition = [];
+              for (i2 = 0; i2 < opts.transition.length; i2++) {
+                optsOut.transition[i2] = plots.supplyAnimationTransitionDefaults(opts.transition[i2] || {});
+              }
+            } else {
+              optsOut.transition = plots.supplyAnimationTransitionDefaults(opts.transition || {});
+            }
+            return optsOut;
+          };
+          plots.supplyAnimationFrameDefaults = function(opts) {
+            var optsOut = {};
+            function coerce(attr, dflt) {
+              return Lib.coerce(opts || {}, optsOut, animationAttrs.frame, attr, dflt);
+            }
+            coerce("duration");
+            coerce("redraw");
+            return optsOut;
+          };
+          plots.supplyAnimationTransitionDefaults = function(opts) {
+            var optsOut = {};
+            function coerce(attr, dflt) {
+              return Lib.coerce(opts || {}, optsOut, animationAttrs.transition, attr, dflt);
+            }
+            coerce("duration");
+            coerce("easing");
+            return optsOut;
+          };
+          plots.supplyFrameDefaults = function(frameIn) {
+            var frameOut = {};
+            function coerce(attr, dflt) {
+              return Lib.coerce(frameIn, frameOut, frameAttrs, attr, dflt);
+            }
+            coerce("group");
+            coerce("name");
+            coerce("traces");
+            coerce("baseframe");
+            coerce("data");
+            coerce("layout");
+            return frameOut;
+          };
+          plots.supplyTraceDefaults = function(traceIn, traceOut, colorIndex, layout, traceInIndex) {
+            var colorway = layout.colorway || Color2.defaults;
+            var defaultColor = colorway[colorIndex % colorway.length];
+            var i2;
+            function coerce(attr, dflt) {
+              return Lib.coerce(traceIn, traceOut, plots.attributes, attr, dflt);
+            }
+            var visible = coerce("visible");
+            coerce("type");
+            coerce("name", layout._traceWord + " " + traceInIndex);
+            coerce("uirevision", layout.uirevision);
+            var _module = plots.getModule(traceOut);
+            traceOut._module = _module;
+            if (_module) {
+              var basePlotModule = _module.basePlotModule;
+              var subplotAttr = basePlotModule.attr;
+              var subplotAttrs = basePlotModule.attributes;
+              if (subplotAttr && subplotAttrs) {
+                var subplots = layout._subplots;
+                var subplotId = "";
+                if (Array.isArray(subplotAttr)) {
+                  for (i2 = 0; i2 < subplotAttr.length; i2++) {
+                    var attri = subplotAttr[i2];
+                    var vali = Lib.coerce(traceIn, traceOut, subplotAttrs, attri);
+                    if (subplots[attri]) Lib.pushUnique(subplots[attri], vali);
+                    subplotId += vali;
+                  }
+                } else {
+                  subplotId = Lib.coerce(traceIn, traceOut, subplotAttrs, subplotAttr);
+                }
+                if (subplots[basePlotModule.name]) {
+                  Lib.pushUnique(subplots[basePlotModule.name], subplotId);
+                }
+              }
+            }
+            if (visible) {
+              coerce("customdata");
+              coerce("ids");
+              coerce("meta");
+              if (Registry.traceIs(traceOut, "showLegend")) {
+                Lib.coerce(
+                  traceIn,
+                  traceOut,
+                  _module.attributes.showlegend ? _module.attributes : plots.attributes,
+                  "showlegend"
+                );
+                Lib.coerce(
+                  traceIn,
+                  traceOut,
+                  _module.attributes.legend ? _module.attributes : plots.attributes,
+                  "legend"
+                );
+                coerce("legendwidth");
+                coerce("legendgroup");
+                coerce("legendgrouptitle.text");
+                coerce("legendrank");
+                traceOut._dfltShowLegend = true;
+              } else {
+                traceOut._dfltShowLegend = false;
+              }
+              if (_module) {
+                _module.supplyDefaults(traceIn, traceOut, defaultColor, layout);
+              }
+              if (!Registry.traceIs(traceOut, "noOpacity")) {
+                coerce("opacity");
+              }
+              if (Registry.traceIs(traceOut, "notLegendIsolatable")) {
+                traceOut.visible = !!traceOut.visible;
+              }
+              if (!Registry.traceIs(traceOut, "noHover")) {
+                if (!traceOut.hovertemplate) Lib.coerceHoverinfo(traceIn, traceOut, layout);
+                if (traceOut.type !== "parcats") {
+                  Registry.getComponentMethod("fx", "supplyDefaults")(traceIn, traceOut, defaultColor, layout);
+                }
+              }
+              if (_module && _module.selectPoints) {
+                var selectedpoints = coerce("selectedpoints");
+                if (Lib.isTypedArray(selectedpoints)) {
+                  traceOut.selectedpoints = Array.from(selectedpoints);
+                }
+              }
+            }
+            return traceOut;
+          };
+          plots.supplyLayoutGlobalDefaults = function(layoutIn, layoutOut, formatObj) {
+            function coerce(attr, dflt) {
+              return Lib.coerce(layoutIn, layoutOut, plots.layoutAttributes, attr, dflt);
+            }
+            var template = layoutIn.template;
+            if (Lib.isPlainObject(template)) {
+              layoutOut.template = template;
+              layoutOut._template = template.layout;
+              layoutOut._dataTemplate = template.data;
+            }
+            coerce("autotypenumbers");
+            var font = Lib.coerceFont(coerce, "font");
+            var fontSize = font.size;
+            Lib.coerceFont(coerce, "title.font", font, { overrideDflt: {
+              size: Math.round(fontSize * 1.4)
+            } });
+            coerce("title.text", layoutOut._dfltTitle.plot);
+            coerce("title.xref");
+            var titleYref = coerce("title.yref");
+            coerce("title.pad.t");
+            coerce("title.pad.r");
+            coerce("title.pad.b");
+            coerce("title.pad.l");
+            var titleAutomargin = coerce("title.automargin");
+            coerce("title.x");
+            coerce("title.xanchor");
+            coerce("title.y");
+            coerce("title.yanchor");
+            coerce("title.subtitle.text", layoutOut._dfltTitle.subtitle);
+            Lib.coerceFont(coerce, "title.subtitle.font", font, {
+              overrideDflt: {
+                size: Math.round(layoutOut.title.font.size * 0.7)
+              }
+            });
+            if (titleAutomargin) {
+              if (titleYref === "paper") {
+                if (layoutOut.title.y !== 0) layoutOut.title.y = 1;
+                if (layoutOut.title.yanchor === "auto") {
+                  layoutOut.title.yanchor = layoutOut.title.y === 0 ? "top" : "bottom";
+                }
+              }
+              if (titleYref === "container") {
+                if (layoutOut.title.y === "auto") layoutOut.title.y = 1;
+                if (layoutOut.title.yanchor === "auto") {
+                  layoutOut.title.yanchor = layoutOut.title.y < 0.5 ? "bottom" : "top";
+                }
+              }
+            }
+            var uniformtextMode = coerce("uniformtext.mode");
+            if (uniformtextMode) {
+              coerce("uniformtext.minsize");
+            }
+            coerce("autosize", !(layoutIn.width && layoutIn.height));
+            coerce("width");
+            coerce("height");
+            coerce("minreducedwidth");
+            coerce("minreducedheight");
+            coerce("margin.l");
+            coerce("margin.r");
+            coerce("margin.t");
+            coerce("margin.b");
+            coerce("margin.pad");
+            coerce("margin.autoexpand");
+            if (layoutIn.width && layoutIn.height) plots.sanitizeMargins(layoutOut);
+            Registry.getComponentMethod("grid", "sizeDefaults")(layoutIn, layoutOut);
+            coerce("paper_bgcolor");
+            coerce("separators", formatObj.decimal + formatObj.thousands);
+            coerce("hidesources");
+            coerce("colorway");
+            coerce("datarevision");
+            var uirevision = coerce("uirevision");
+            coerce("editrevision", uirevision);
+            coerce("selectionrevision", uirevision);
+            Registry.getComponentMethod(
+              "modebar",
+              "supplyLayoutDefaults"
+            )(layoutIn, layoutOut);
+            Registry.getComponentMethod(
+              "shapes",
+              "supplyDrawNewShapeDefaults"
+            )(layoutIn, layoutOut, coerce);
+            Registry.getComponentMethod(
+              "selections",
+              "supplyDrawNewSelectionDefaults"
+            )(layoutIn, layoutOut, coerce);
+            coerce("meta");
+            if (Lib.isPlainObject(layoutIn.transition)) {
+              coerce("transition.duration");
+              coerce("transition.easing");
+              coerce("transition.ordering");
+            }
+            Registry.getComponentMethod(
+              "calendars",
+              "handleDefaults"
+            )(layoutIn, layoutOut, "calendar");
+            Registry.getComponentMethod(
+              "fx",
+              "supplyLayoutGlobalDefaults"
+            )(layoutIn, layoutOut, coerce);
+            Lib.coerce(layoutIn, layoutOut, scatterAttrs, "scattermode");
+          };
+          function getComputedSize(attr) {
+            return typeof attr === "string" && attr.slice(-2) === "px" && parseFloat(attr);
+          }
+          plots.plotAutoSize = function plotAutoSize(gd2, layout, fullLayout) {
+            var context = gd2._context || {};
+            var frameMargins = context.frameMargins;
+            var newWidth;
+            var newHeight;
+            var isPlotDiv = Lib.isPlotDiv(gd2);
+            if (isPlotDiv) gd2.emit("plotly_autosize");
+            if (context.fillFrame) {
+              newWidth = window.innerWidth;
+              newHeight = window.innerHeight;
+              document.body.style.overflow = "hidden";
+            } else {
+              var computedStyle = isPlotDiv ? window.getComputedStyle(gd2) : {};
+              newWidth = getComputedSize(computedStyle.width) || getComputedSize(computedStyle.maxWidth) || fullLayout.width;
+              newHeight = getComputedSize(computedStyle.height) || getComputedSize(computedStyle.maxHeight) || fullLayout.height;
+              if (isNumeric(frameMargins) && frameMargins > 0) {
+                var factor = 1 - 2 * frameMargins;
+                newWidth = Math.round(factor * newWidth);
+                newHeight = Math.round(factor * newHeight);
+              }
+            }
+            var minWidth = plots.layoutAttributes.width.min;
+            var minHeight = plots.layoutAttributes.height.min;
+            if (newWidth < minWidth) newWidth = minWidth;
+            if (newHeight < minHeight) newHeight = minHeight;
+            var widthHasChanged = !layout.width && Math.abs(fullLayout.width - newWidth) > 1;
+            var heightHasChanged = !layout.height && Math.abs(fullLayout.height - newHeight) > 1;
+            if (heightHasChanged || widthHasChanged) {
+              if (widthHasChanged) fullLayout.width = newWidth;
+              if (heightHasChanged) fullLayout.height = newHeight;
+            }
+            if (!gd2._initialAutoSize) {
+              gd2._initialAutoSize = { width: newWidth, height: newHeight };
+            }
+            plots.sanitizeMargins(fullLayout);
+          };
+          plots.supplyLayoutModuleDefaults = function(layoutIn, layoutOut, fullData, transitionData) {
+            var componentsRegistry = Registry.componentsRegistry;
+            var basePlotModules = layoutOut._basePlotModules;
+            var component, i2, _module;
+            var Cartesian = Registry.subplotsRegistry.cartesian;
+            for (component in componentsRegistry) {
+              _module = componentsRegistry[component];
+              if (_module.includeBasePlot) {
+                _module.includeBasePlot(layoutIn, layoutOut);
+              }
+            }
+            if (!basePlotModules.length) {
+              basePlotModules.push(Cartesian);
+            }
+            if (layoutOut._has("cartesian")) {
+              Registry.getComponentMethod("grid", "contentDefaults")(layoutIn, layoutOut);
+              Cartesian.finalizeSubplots(layoutIn, layoutOut);
+            }
+            for (var subplotType in layoutOut._subplots) {
+              layoutOut._subplots[subplotType].sort(Lib.subplotSort);
+            }
+            for (i2 = 0; i2 < basePlotModules.length; i2++) {
+              _module = basePlotModules[i2];
+              if (_module.supplyLayoutDefaults) {
+                _module.supplyLayoutDefaults(layoutIn, layoutOut, fullData);
+              }
+            }
+            var modules = layoutOut._modules;
+            for (i2 = 0; i2 < modules.length; i2++) {
+              _module = modules[i2];
+              if (_module.supplyLayoutDefaults) {
+                _module.supplyLayoutDefaults(layoutIn, layoutOut, fullData);
+              }
+            }
+            var transformModules = layoutOut._transformModules;
+            for (i2 = 0; i2 < transformModules.length; i2++) {
+              _module = transformModules[i2];
+              if (_module.supplyLayoutDefaults) {
+                _module.supplyLayoutDefaults(layoutIn, layoutOut, fullData, transitionData);
+              }
+            }
+            for (component in componentsRegistry) {
+              _module = componentsRegistry[component];
+              if (_module.supplyLayoutDefaults) {
+                _module.supplyLayoutDefaults(layoutIn, layoutOut, fullData);
+              }
+            }
+          };
+          plots.purge = function(gd2) {
+            var fullLayout = gd2._fullLayout || {};
+            if (fullLayout._glcontainer !== void 0) {
+              fullLayout._glcontainer.selectAll(".gl-canvas").remove();
+              fullLayout._glcontainer.remove();
+              fullLayout._glcanvas = null;
+            }
+            if (fullLayout._modeBar) fullLayout._modeBar.destroy();
+            if (gd2._transitionData) {
+              if (gd2._transitionData._interruptCallbacks) {
+                gd2._transitionData._interruptCallbacks.length = 0;
+              }
+              if (gd2._transitionData._animationRaf) {
+                window.cancelAnimationFrame(gd2._transitionData._animationRaf);
+              }
+            }
+            Lib.clearThrottle();
+            Lib.clearResponsive(gd2);
+            delete gd2.data;
+            delete gd2.layout;
+            delete gd2._fullData;
+            delete gd2._fullLayout;
+            delete gd2.calcdata;
+            delete gd2.empty;
+            delete gd2.fid;
+            delete gd2.undoqueue;
+            delete gd2.undonum;
+            delete gd2.autoplay;
+            delete gd2.changed;
+            delete gd2._promises;
+            delete gd2._redrawTimer;
+            delete gd2._hmlumcount;
+            delete gd2._hmpixcount;
+            delete gd2._transitionData;
+            delete gd2._transitioning;
+            delete gd2._initialAutoSize;
+            delete gd2._transitioningWithDuration;
+            delete gd2._dragging;
+            delete gd2._dragged;
+            delete gd2._dragdata;
+            delete gd2._hoverdata;
+            delete gd2._snapshotInProgress;
+            delete gd2._editing;
+            delete gd2._mouseDownTime;
+            delete gd2._legendMouseDownTime;
+            if (gd2.removeAllListeners) gd2.removeAllListeners();
+          };
+          plots.style = function(gd2) {
+            var _modules = gd2._fullLayout._visibleModules;
+            var styleModules = [];
+            var i2;
+            for (i2 = 0; i2 < _modules.length; i2++) {
+              var _module = _modules[i2];
+              if (_module.style) {
+                Lib.pushUnique(styleModules, _module.style);
+              }
+            }
+            for (i2 = 0; i2 < styleModules.length; i2++) {
+              styleModules[i2](gd2);
+            }
+          };
+          plots.sanitizeMargins = function(fullLayout) {
+            if (!fullLayout || !fullLayout.margin) return;
+            var width = fullLayout.width;
+            var height = fullLayout.height;
+            var margin = fullLayout.margin;
+            var plotWidth = width - (margin.l + margin.r);
+            var plotHeight = height - (margin.t + margin.b);
+            var correction;
+            if (plotWidth < 0) {
+              correction = (width - 1) / (margin.l + margin.r);
+              margin.l = Math.floor(correction * margin.l);
+              margin.r = Math.floor(correction * margin.r);
+            }
+            if (plotHeight < 0) {
+              correction = (height - 1) / (margin.t + margin.b);
+              margin.t = Math.floor(correction * margin.t);
+              margin.b = Math.floor(correction * margin.b);
+            }
+          };
+          plots.clearAutoMarginIds = function(gd2) {
+            gd2._fullLayout._pushmarginIds = {};
+          };
+          plots.allowAutoMargin = function(gd2, id2) {
+            gd2._fullLayout._pushmarginIds[id2] = 1;
+          };
+          function initMargins(fullLayout) {
+            var margin = fullLayout.margin;
+            if (!fullLayout._size) {
+              var gs = fullLayout._size = {
+                l: Math.round(margin.l),
+                r: Math.round(margin.r),
+                t: Math.round(margin.t),
+                b: Math.round(margin.b),
+                p: Math.round(margin.pad)
+              };
+              gs.w = Math.round(fullLayout.width) - gs.l - gs.r;
+              gs.h = Math.round(fullLayout.height) - gs.t - gs.b;
+            }
+            if (!fullLayout._pushmargin) fullLayout._pushmargin = {};
+            if (!fullLayout._pushmarginIds) fullLayout._pushmarginIds = {};
+            if (!fullLayout._reservedMargin) fullLayout._reservedMargin = {};
+          }
+          var MIN_SPECIFIED_WIDTH = 2;
+          var MIN_SPECIFIED_HEIGHT = 2;
+          plots.autoMargin = function(gd2, id2, o2) {
+            var fullLayout = gd2._fullLayout;
+            var width = fullLayout.width;
+            var height = fullLayout.height;
+            var margin = fullLayout.margin;
+            var minreducedwidth = fullLayout.minreducedwidth;
+            var minreducedheight = fullLayout.minreducedheight;
+            var minFinalWidth = Lib.constrain(
+              width - margin.l - margin.r,
+              MIN_SPECIFIED_WIDTH,
+              minreducedwidth
+            );
+            var minFinalHeight = Lib.constrain(
+              height - margin.t - margin.b,
+              MIN_SPECIFIED_HEIGHT,
+              minreducedheight
+            );
+            var maxSpaceW = Math.max(0, width - minFinalWidth);
+            var maxSpaceH = Math.max(0, height - minFinalHeight);
+            var pushMargin = fullLayout._pushmargin;
+            var pushMarginIds = fullLayout._pushmarginIds;
+            if (margin.autoexpand !== false) {
+              if (!o2) {
+                delete pushMargin[id2];
+                delete pushMarginIds[id2];
+              } else {
+                var pad = o2.pad;
+                if (pad === void 0) {
+                  pad = Math.min(12, margin.l, margin.r, margin.t, margin.b);
+                }
+                if (maxSpaceW) {
+                  var rW = (o2.l + o2.r) / maxSpaceW;
+                  if (rW > 1) {
+                    o2.l /= rW;
+                    o2.r /= rW;
+                  }
+                }
+                if (maxSpaceH) {
+                  var rH = (o2.t + o2.b) / maxSpaceH;
+                  if (rH > 1) {
+                    o2.t /= rH;
+                    o2.b /= rH;
+                  }
+                }
+                var xl = o2.xl !== void 0 ? o2.xl : o2.x;
+                var xr = o2.xr !== void 0 ? o2.xr : o2.x;
+                var yt = o2.yt !== void 0 ? o2.yt : o2.y;
+                var yb2 = o2.yb !== void 0 ? o2.yb : o2.y;
+                pushMargin[id2] = {
+                  l: { val: xl, size: o2.l + pad },
+                  r: { val: xr, size: o2.r + pad },
+                  b: { val: yb2, size: o2.b + pad },
+                  t: { val: yt, size: o2.t + pad }
+                };
+                pushMarginIds[id2] = 1;
+              }
+              if (!fullLayout._replotting) {
+                return plots.doAutoMargin(gd2);
+              }
+            }
+          };
+          function needsRedrawForShift(gd2) {
+            if ("_redrawFromAutoMarginCount" in gd2._fullLayout) {
+              return false;
+            }
+            var axList = axisIDs.list(gd2, "", true);
+            for (var ax in axList) {
+              if (axList[ax].autoshift || axList[ax].shift) return true;
+            }
+            return false;
+          }
+          plots.doAutoMargin = function(gd2) {
+            var fullLayout = gd2._fullLayout;
+            var width = fullLayout.width;
+            var height = fullLayout.height;
+            if (!fullLayout._size) fullLayout._size = {};
+            initMargins(fullLayout);
+            var gs = fullLayout._size;
+            var margin = fullLayout.margin;
+            var reservedMargins = { t: 0, b: 0, l: 0, r: 0 };
+            var oldMargins = Lib.extendFlat({}, gs);
+            var ml2 = margin.l;
+            var mr = margin.r;
+            var mt2 = margin.t;
+            var mb2 = margin.b;
+            var pushMargin = fullLayout._pushmargin;
+            var pushMarginIds = fullLayout._pushmarginIds;
+            var minreducedwidth = fullLayout.minreducedwidth;
+            var minreducedheight = fullLayout.minreducedheight;
+            if (margin.autoexpand !== false) {
+              for (var k2 in pushMargin) {
+                if (!pushMarginIds[k2]) delete pushMargin[k2];
+              }
+              var margins = gd2._fullLayout._reservedMargin;
+              for (var key in margins) {
+                for (var side in margins[key]) {
+                  var val = margins[key][side];
+                  reservedMargins[side] = Math.max(reservedMargins[side], val);
+                }
+              }
+              pushMargin.base = {
+                l: { val: 0, size: ml2 },
+                r: { val: 1, size: mr },
+                t: { val: 1, size: mt2 },
+                b: { val: 0, size: mb2 }
+              };
+              for (var s2 in reservedMargins) {
+                var autoMarginPush = 0;
+                for (var m2 in pushMargin) {
+                  if (m2 !== "base") {
+                    if (isNumeric(pushMargin[m2][s2].size)) {
+                      autoMarginPush = pushMargin[m2][s2].size > autoMarginPush ? pushMargin[m2][s2].size : autoMarginPush;
+                    }
+                  }
+                }
+                var extraMargin = Math.max(0, margin[s2] - autoMarginPush);
+                reservedMargins[s2] = Math.max(0, reservedMargins[s2] - extraMargin);
+              }
+              for (var k1 in pushMargin) {
+                var pushleft = pushMargin[k1].l || {};
+                var pushbottom = pushMargin[k1].b || {};
+                var fl2 = pushleft.val;
+                var pl2 = pushleft.size;
+                var fb2 = pushbottom.val;
+                var pb2 = pushbottom.size;
+                var availableWidth = width - reservedMargins.r - reservedMargins.l;
+                var availableHeight = height - reservedMargins.t - reservedMargins.b;
+                for (var k22 in pushMargin) {
+                  if (isNumeric(pl2) && pushMargin[k22].r) {
+                    var fr = pushMargin[k22].r.val;
+                    var pr = pushMargin[k22].r.size;
+                    if (fr > fl2) {
+                      var newL = (pl2 * fr + (pr - availableWidth) * fl2) / (fr - fl2);
+                      var newR = (pr * (1 - fl2) + (pl2 - availableWidth) * (1 - fr)) / (fr - fl2);
+                      if (newL + newR > ml2 + mr) {
+                        ml2 = newL;
+                        mr = newR;
+                      }
+                    }
+                  }
+                  if (isNumeric(pb2) && pushMargin[k22].t) {
+                    var ft2 = pushMargin[k22].t.val;
+                    var pt2 = pushMargin[k22].t.size;
+                    if (ft2 > fb2) {
+                      var newB = (pb2 * ft2 + (pt2 - availableHeight) * fb2) / (ft2 - fb2);
+                      var newT = (pt2 * (1 - fb2) + (pb2 - availableHeight) * (1 - ft2)) / (ft2 - fb2);
+                      if (newB + newT > mb2 + mt2) {
+                        mb2 = newB;
+                        mt2 = newT;
+                      }
+                    }
+                  }
+                }
+              }
+            }
+            var minFinalWidth = Lib.constrain(
+              width - margin.l - margin.r,
+              MIN_SPECIFIED_WIDTH,
+              minreducedwidth
+            );
+            var minFinalHeight = Lib.constrain(
+              height - margin.t - margin.b,
+              MIN_SPECIFIED_HEIGHT,
+              minreducedheight
+            );
+            var maxSpaceW = Math.max(0, width - minFinalWidth);
+            var maxSpaceH = Math.max(0, height - minFinalHeight);
+            if (maxSpaceW) {
+              var rW = (ml2 + mr) / maxSpaceW;
+              if (rW > 1) {
+                ml2 /= rW;
+                mr /= rW;
+              }
+            }
+            if (maxSpaceH) {
+              var rH = (mb2 + mt2) / maxSpaceH;
+              if (rH > 1) {
+                mb2 /= rH;
+                mt2 /= rH;
+              }
+            }
+            gs.l = Math.round(ml2) + reservedMargins.l;
+            gs.r = Math.round(mr) + reservedMargins.r;
+            gs.t = Math.round(mt2) + reservedMargins.t;
+            gs.b = Math.round(mb2) + reservedMargins.b;
+            gs.p = Math.round(margin.pad);
+            gs.w = Math.round(width) - gs.l - gs.r;
+            gs.h = Math.round(height) - gs.t - gs.b;
+            if (!fullLayout._replotting && (plots.didMarginChange(oldMargins, gs) || needsRedrawForShift(gd2))) {
+              if ("_redrawFromAutoMarginCount" in fullLayout) {
+                fullLayout._redrawFromAutoMarginCount++;
+              } else {
+                fullLayout._redrawFromAutoMarginCount = 1;
+              }
+              var maxNumberOfRedraws = 3 * (1 + Object.keys(pushMarginIds).length);
+              if (fullLayout._redrawFromAutoMarginCount < maxNumberOfRedraws) {
+                return Registry.call("_doPlot", gd2);
+              } else {
+                fullLayout._size = oldMargins;
+                Lib.warn("Too many auto-margin redraws.");
+              }
+            }
+            refineTicks(gd2);
+          };
+          function refineTicks(gd2) {
+            var axList = axisIDs.list(gd2, "", true);
+            [
+              "_adjustTickLabelsOverflow",
+              "_hideCounterAxisInsideTickLabels"
+            ].forEach(function(k2) {
+              for (var i2 = 0; i2 < axList.length; i2++) {
+                var hideFn = axList[i2][k2];
+                if (hideFn) hideFn();
+              }
+            });
+          }
+          var marginKeys = ["l", "r", "t", "b", "p", "w", "h"];
+          plots.didMarginChange = function(margin0, margin1) {
+            for (var i2 = 0; i2 < marginKeys.length; i2++) {
+              var k2 = marginKeys[i2];
+              var m0 = margin0[k2];
+              var m1 = margin1[k2];
+              if (!isNumeric(m0) || Math.abs(m1 - m0) > 1) {
+                return true;
+              }
+            }
+            return false;
+          };
+          plots.graphJson = function(gd2, dataonly, mode, output, useDefaults, includeConfig) {
+            if (useDefaults && dataonly && !gd2._fullData || useDefaults && !dataonly && !gd2._fullLayout) {
+              plots.supplyDefaults(gd2);
+            }
+            var data = useDefaults ? gd2._fullData : gd2.data;
+            var layout = useDefaults ? gd2._fullLayout : gd2.layout;
+            var frames = (gd2._transitionData || {})._frames;
+            function stripObj(d2, keepFunction) {
+              if (typeof d2 === "function") {
+                return keepFunction ? "_function_" : null;
+              }
+              if (Lib.isPlainObject(d2)) {
+                var o2 = {};
+                var src;
+                Object.keys(d2).sort().forEach(function(v2) {
+                  if (["_", "["].indexOf(v2.charAt(0)) !== -1) return;
+                  if (typeof d2[v2] === "function") {
+                    if (keepFunction) o2[v2] = "_function";
+                    return;
+                  }
+                  if (mode === "keepdata") {
+                    if (v2.slice(-3) === "src") {
+                      return;
+                    }
+                  } else if (mode === "keepstream") {
+                    src = d2[v2 + "src"];
+                    if (typeof src === "string" && src.indexOf(":") > 0) {
+                      if (!Lib.isPlainObject(d2.stream)) {
+                        return;
+                      }
+                    }
+                  } else if (mode !== "keepall") {
+                    src = d2[v2 + "src"];
+                    if (typeof src === "string" && src.indexOf(":") > 0) {
+                      return;
+                    }
+                  }
+                  o2[v2] = stripObj(d2[v2], keepFunction);
+                });
+                return o2;
+              }
+              var dIsArray = Array.isArray(d2);
+              var dIsTypedArray = Lib.isTypedArray(d2);
+              if ((dIsArray || dIsTypedArray) && d2.dtype && d2.shape) {
+                var bdata = d2.bdata;
+                return stripObj({
+                  dtype: d2.dtype,
+                  shape: d2.shape,
+                  bdata: (
+                    // case of ArrayBuffer
+                    Lib.isArrayBuffer(bdata) ? b64encode.encode(bdata) : (
+                      // case of b64 string
+                      bdata
+                    )
+                  )
+                }, keepFunction);
+              }
+              if (dIsArray) {
+                return d2.map(function(x2) {
+                  return stripObj(x2, keepFunction);
+                });
+              }
+              if (dIsTypedArray) {
+                return Lib.simpleMap(d2, Lib.identity);
+              }
+              if (Lib.isJSDate(d2)) return Lib.ms2DateTimeLocal(+d2);
+              return d2;
+            }
+            var obj = {
+              data: (data || []).map(function(v2) {
+                var d2 = stripObj(v2);
+                if (dataonly) {
+                  delete d2.fit;
+                }
+                return d2;
+              })
+            };
+            if (!dataonly) {
+              obj.layout = stripObj(layout);
+              if (useDefaults) {
+                var gs = layout._size;
+                obj.layout.computed = {
+                  margin: {
+                    b: gs.b,
+                    l: gs.l,
+                    r: gs.r,
+                    t: gs.t
+                  }
+                };
+              }
+            }
+            if (frames) obj.frames = stripObj(frames);
+            if (includeConfig) obj.config = stripObj(gd2._context, true);
+            return output === "object" ? obj : JSON.stringify(obj);
+          };
+          plots.modifyFrames = function(gd2, operations) {
+            var i2, op, frame;
+            var _frames = gd2._transitionData._frames;
+            var _frameHash = gd2._transitionData._frameHash;
+            for (i2 = 0; i2 < operations.length; i2++) {
+              op = operations[i2];
+              switch (op.type) {
+                case "replace":
+                  frame = op.value;
+                  var oldName = (_frames[op.index] || {}).name;
+                  var newName = frame.name;
+                  _frames[op.index] = _frameHash[newName] = frame;
+                  if (newName !== oldName) {
+                    delete _frameHash[oldName];
+                    _frameHash[newName] = frame;
+                  }
+                  break;
+                case "insert":
+                  frame = op.value;
+                  _frameHash[frame.name] = frame;
+                  _frames.splice(op.index, 0, frame);
+                  break;
+                case "delete":
+                  frame = _frames[op.index];
+                  delete _frameHash[frame.name];
+                  _frames.splice(op.index, 1);
+                  break;
+              }
+            }
+            return Promise.resolve();
+          };
+          plots.computeFrame = function(gd2, frameName) {
+            var frameLookup = gd2._transitionData._frameHash;
+            var i2, traceIndices, traceIndex, destIndex;
+            if (!frameName) {
+              throw new Error("computeFrame must be given a string frame name");
+            }
+            var framePtr = frameLookup[frameName.toString()];
+            if (!framePtr) {
+              return false;
+            }
+            var frameStack = [framePtr];
+            var frameNameStack = [framePtr.name];
+            while (framePtr.baseframe && (framePtr = frameLookup[framePtr.baseframe.toString()])) {
+              if (frameNameStack.indexOf(framePtr.name) !== -1) break;
+              frameStack.push(framePtr);
+              frameNameStack.push(framePtr.name);
+            }
+            var result = {};
+            while (framePtr = frameStack.pop()) {
+              if (framePtr.layout) {
+                result.layout = plots.extendLayout(result.layout, framePtr.layout);
+              }
+              if (framePtr.data) {
+                if (!result.data) {
+                  result.data = [];
+                }
+                traceIndices = framePtr.traces;
+                if (!traceIndices) {
+                  traceIndices = [];
+                  for (i2 = 0; i2 < framePtr.data.length; i2++) {
+                    traceIndices[i2] = i2;
+                  }
+                }
+                if (!result.traces) {
+                  result.traces = [];
+                }
+                for (i2 = 0; i2 < framePtr.data.length; i2++) {
+                  traceIndex = traceIndices[i2];
+                  if (traceIndex === void 0 || traceIndex === null) {
+                    continue;
+                  }
+                  destIndex = result.traces.indexOf(traceIndex);
+                  if (destIndex === -1) {
+                    destIndex = result.data.length;
+                    result.traces[destIndex] = traceIndex;
+                  }
+                  result.data[destIndex] = plots.extendTrace(result.data[destIndex], framePtr.data[i2]);
+                }
+              }
+            }
+            return result;
+          };
+          plots.recomputeFrameHash = function(gd2) {
+            var hash = gd2._transitionData._frameHash = {};
+            var frames = gd2._transitionData._frames;
+            for (var i2 = 0; i2 < frames.length; i2++) {
+              var frame = frames[i2];
+              if (frame && frame.name) {
+                hash[frame.name] = frame;
+              }
+            }
+          };
+          plots.extendObjectWithContainers = function(dest, src, containerPaths) {
+            var containerProp, containerVal, i2, j2, srcProp, destProp, srcContainer, destContainer;
+            var copy = Lib.extendDeepNoArrays({}, src || {});
+            var expandedObj = Lib.expandObjectPaths(copy);
+            var containerObj = {};
+            if (containerPaths && containerPaths.length) {
+              for (i2 = 0; i2 < containerPaths.length; i2++) {
+                containerProp = Lib.nestedProperty(expandedObj, containerPaths[i2]);
+                containerVal = containerProp.get();
+                if (containerVal === void 0) {
+                  Lib.nestedProperty(containerObj, containerPaths[i2]).set(null);
+                } else {
+                  containerProp.set(null);
+                  Lib.nestedProperty(containerObj, containerPaths[i2]).set(containerVal);
+                }
+              }
+            }
+            dest = Lib.extendDeepNoArrays(dest || {}, expandedObj);
+            if (containerPaths && containerPaths.length) {
+              for (i2 = 0; i2 < containerPaths.length; i2++) {
+                srcProp = Lib.nestedProperty(containerObj, containerPaths[i2]);
+                srcContainer = srcProp.get();
+                if (!srcContainer) continue;
+                destProp = Lib.nestedProperty(dest, containerPaths[i2]);
+                destContainer = destProp.get();
+                if (!Array.isArray(destContainer)) {
+                  destContainer = [];
+                  destProp.set(destContainer);
+                }
+                for (j2 = 0; j2 < srcContainer.length; j2++) {
+                  var srcObj = srcContainer[j2];
+                  if (srcObj === null) destContainer[j2] = null;
+                  else {
+                    destContainer[j2] = plots.extendObjectWithContainers(destContainer[j2], srcObj);
+                  }
+                }
+                destProp.set(destContainer);
+              }
+            }
+            return dest;
+          };
+          plots.dataArrayContainers = ["transforms", "dimensions"];
+          plots.layoutArrayContainers = Registry.layoutArrayContainers;
+          plots.extendTrace = function(destTrace, srcTrace) {
+            return plots.extendObjectWithContainers(destTrace, srcTrace, plots.dataArrayContainers);
+          };
+          plots.extendLayout = function(destLayout, srcLayout) {
+            return plots.extendObjectWithContainers(destLayout, srcLayout, plots.layoutArrayContainers);
+          };
+          plots.transition = function(gd2, data, layout, traces, frameOpts, transitionOpts) {
+            var opts = { redraw: frameOpts.redraw };
+            var transitionedTraces = {};
+            var axEdits = [];
+            opts.prepareFn = function() {
+              var dataLength = Array.isArray(data) ? data.length : 0;
+              var traceIndices = traces.slice(0, dataLength);
+              for (var i2 = 0; i2 < traceIndices.length; i2++) {
+                var traceIdx = traceIndices[i2];
+                var trace = gd2._fullData[traceIdx];
+                var _module = trace._module;
+                if (!_module) continue;
+                if (_module.animatable) {
+                  var n2 = _module.basePlotModule.name;
+                  if (!transitionedTraces[n2]) transitionedTraces[n2] = [];
+                  transitionedTraces[n2].push(traceIdx);
+                }
+                gd2.data[traceIndices[i2]] = plots.extendTrace(gd2.data[traceIndices[i2]], data[i2]);
+              }
+              var layoutUpdate = Lib.expandObjectPaths(Lib.extendDeepNoArrays({}, layout));
+              var axisAttrRe = /^[xy]axis[0-9]*$/;
+              for (var attr in layoutUpdate) {
+                if (!axisAttrRe.test(attr)) continue;
+                delete layoutUpdate[attr].range;
+              }
+              plots.extendLayout(gd2.layout, layoutUpdate);
+              delete gd2.calcdata;
+              plots.supplyDefaults(gd2);
+              plots.doCalcdata(gd2);
+              var newLayout = Lib.expandObjectPaths(layout);
+              if (newLayout) {
+                var subplots = gd2._fullLayout._plots;
+                for (var k2 in subplots) {
+                  var plotinfo = subplots[k2];
+                  var xa = plotinfo.xaxis;
+                  var ya2 = plotinfo.yaxis;
+                  var xr0 = xa.range.slice();
+                  var yr0 = ya2.range.slice();
+                  var xr1 = null;
+                  var yr1 = null;
+                  var editX = null;
+                  var editY = null;
+                  if (Array.isArray(newLayout[xa._name + ".range"])) {
+                    xr1 = newLayout[xa._name + ".range"].slice();
+                  } else if (Array.isArray((newLayout[xa._name] || {}).range)) {
+                    xr1 = newLayout[xa._name].range.slice();
+                  }
+                  if (Array.isArray(newLayout[ya2._name + ".range"])) {
+                    yr1 = newLayout[ya2._name + ".range"].slice();
+                  } else if (Array.isArray((newLayout[ya2._name] || {}).range)) {
+                    yr1 = newLayout[ya2._name].range.slice();
+                  }
+                  if (xr0 && xr1 && (xa.r2l(xr0[0]) !== xa.r2l(xr1[0]) || xa.r2l(xr0[1]) !== xa.r2l(xr1[1]))) {
+                    editX = { xr0, xr1 };
+                  }
+                  if (yr0 && yr1 && (ya2.r2l(yr0[0]) !== ya2.r2l(yr1[0]) || ya2.r2l(yr0[1]) !== ya2.r2l(yr1[1]))) {
+                    editY = { yr0, yr1 };
+                  }
+                  if (editX || editY) {
+                    axEdits.push(Lib.extendFlat({ plotinfo }, editX, editY));
+                  }
+                }
+              }
+              return Promise.resolve();
+            };
+            opts.runFn = function(makeCallback) {
+              var traceTransitionOpts;
+              var basePlotModules = gd2._fullLayout._basePlotModules;
+              var hasAxisTransition = axEdits.length;
+              var i2;
+              if (layout) {
+                for (i2 = 0; i2 < basePlotModules.length; i2++) {
+                  if (basePlotModules[i2].transitionAxes) {
+                    basePlotModules[i2].transitionAxes(gd2, axEdits, transitionOpts, makeCallback);
+                  }
+                }
+              }
+              if (hasAxisTransition) {
+                traceTransitionOpts = Lib.extendFlat({}, transitionOpts);
+                traceTransitionOpts.duration = 0;
+                delete transitionedTraces.cartesian;
+              } else {
+                traceTransitionOpts = transitionOpts;
+              }
+              for (var n2 in transitionedTraces) {
+                var traceIndices = transitionedTraces[n2];
+                var _module = gd2._fullData[traceIndices[0]]._module;
+                _module.basePlotModule.plot(gd2, traceIndices, traceTransitionOpts, makeCallback);
+              }
+            };
+            return _transition(gd2, transitionOpts, opts);
+          };
+          plots.transitionFromReact = function(gd2, restyleFlags, relayoutFlags, oldFullLayout) {
+            var fullLayout = gd2._fullLayout;
+            var transitionOpts = fullLayout.transition;
+            var opts = {};
+            var axEdits = [];
+            opts.prepareFn = function() {
+              var subplots = fullLayout._plots;
+              opts.redraw = false;
+              if (restyleFlags.anim === "some") opts.redraw = true;
+              if (relayoutFlags.anim === "some") opts.redraw = true;
+              for (var k2 in subplots) {
+                var plotinfo = subplots[k2];
+                var xa = plotinfo.xaxis;
+                var ya2 = plotinfo.yaxis;
+                var xr0 = oldFullLayout[xa._name].range.slice();
+                var yr0 = oldFullLayout[ya2._name].range.slice();
+                var xr1 = xa.range.slice();
+                var yr1 = ya2.range.slice();
+                xa.setScale();
+                ya2.setScale();
+                var editX = null;
+                var editY = null;
+                if (xa.r2l(xr0[0]) !== xa.r2l(xr1[0]) || xa.r2l(xr0[1]) !== xa.r2l(xr1[1])) {
+                  editX = { xr0, xr1 };
+                }
+                if (ya2.r2l(yr0[0]) !== ya2.r2l(yr1[0]) || ya2.r2l(yr0[1]) !== ya2.r2l(yr1[1])) {
+                  editY = { yr0, yr1 };
+                }
+                if (editX || editY) {
+                  axEdits.push(Lib.extendFlat({ plotinfo }, editX, editY));
+                }
+              }
+              return Promise.resolve();
+            };
+            opts.runFn = function(makeCallback) {
+              var fullData = gd2._fullData;
+              var fullLayout2 = gd2._fullLayout;
+              var basePlotModules = fullLayout2._basePlotModules;
+              var axisTransitionOpts;
+              var traceTransitionOpts;
+              var transitionedTraces;
+              var allTraceIndices = [];
+              for (var i2 = 0; i2 < fullData.length; i2++) {
+                allTraceIndices.push(i2);
+              }
+              function transitionAxes() {
+                if (!gd2._fullLayout) return;
+                for (var j2 = 0; j2 < basePlotModules.length; j2++) {
+                  if (basePlotModules[j2].transitionAxes) {
+                    basePlotModules[j2].transitionAxes(gd2, axEdits, axisTransitionOpts, makeCallback);
+                  }
+                }
+              }
+              function transitionTraces() {
+                if (!gd2._fullLayout) return;
+                for (var j2 = 0; j2 < basePlotModules.length; j2++) {
+                  basePlotModules[j2].plot(gd2, transitionedTraces, traceTransitionOpts, makeCallback);
+                }
+              }
+              if (axEdits.length && restyleFlags.anim) {
+                if (transitionOpts.ordering === "traces first") {
+                  axisTransitionOpts = Lib.extendFlat({}, transitionOpts, { duration: 0 });
+                  transitionedTraces = allTraceIndices;
+                  traceTransitionOpts = transitionOpts;
+                  setTimeout(transitionAxes, transitionOpts.duration);
+                  transitionTraces();
+                } else {
+                  axisTransitionOpts = transitionOpts;
+                  transitionedTraces = null;
+                  traceTransitionOpts = Lib.extendFlat({}, transitionOpts, { duration: 0 });
+                  setTimeout(transitionTraces, axisTransitionOpts.duration);
+                  transitionAxes();
+                }
+              } else if (axEdits.length) {
+                axisTransitionOpts = transitionOpts;
+                transitionAxes();
+              } else if (restyleFlags.anim) {
+                transitionedTraces = allTraceIndices;
+                traceTransitionOpts = transitionOpts;
+                transitionTraces();
+              }
+            };
+            return _transition(gd2, transitionOpts, opts);
+          };
+          function _transition(gd2, transitionOpts, opts) {
+            var aborted = false;
+            function executeCallbacks(list) {
+              var p2 = Promise.resolve();
+              if (!list) return p2;
+              while (list.length) {
+                p2 = p2.then(list.shift());
+              }
+              return p2;
+            }
+            function flushCallbacks(list) {
+              if (!list) return;
+              while (list.length) {
+                list.shift();
+              }
+            }
+            function executeTransitions() {
+              gd2.emit("plotly_transitioning", []);
+              return new Promise(function(resolve) {
+                gd2._transitioning = true;
+                if (transitionOpts.duration > 0) {
+                  gd2._transitioningWithDuration = true;
+                }
+                gd2._transitionData._interruptCallbacks.push(function() {
+                  aborted = true;
+                });
+                if (opts.redraw) {
+                  gd2._transitionData._interruptCallbacks.push(function() {
+                    return Registry.call("redraw", gd2);
+                  });
+                }
+                gd2._transitionData._interruptCallbacks.push(function() {
+                  gd2.emit("plotly_transitioninterrupted", []);
+                });
+                var numCallbacks = 0;
+                var numCompleted = 0;
+                function makeCallback() {
+                  numCallbacks++;
+                  return function() {
+                    numCompleted++;
+                    if (!aborted && numCompleted === numCallbacks) {
+                      completeTransition(resolve);
+                    }
+                  };
+                }
+                opts.runFn(makeCallback);
+                setTimeout(makeCallback());
+              });
+            }
+            function completeTransition(callback) {
+              if (!gd2._transitionData) return;
+              flushCallbacks(gd2._transitionData._interruptCallbacks);
+              return Promise.resolve().then(function() {
+                if (opts.redraw) {
+                  return Registry.call("redraw", gd2);
+                }
+              }).then(function() {
+                gd2._transitioning = false;
+                gd2._transitioningWithDuration = false;
+                gd2.emit("plotly_transitioned", []);
+              }).then(callback);
+            }
+            function interruptPreviousTransitions() {
+              if (!gd2._transitionData) return;
+              gd2._transitioning = false;
+              return executeCallbacks(gd2._transitionData._interruptCallbacks);
+            }
+            var seq = [
+              plots.previousPromises,
+              interruptPreviousTransitions,
+              opts.prepareFn,
+              plots.rehover,
+              plots.reselect,
+              executeTransitions
+            ];
+            var transitionStarting = Lib.syncOrAsync(seq, gd2);
+            if (!transitionStarting || !transitionStarting.then) {
+              transitionStarting = Promise.resolve();
+            }
+            return transitionStarting.then(function() {
+              return gd2;
+            });
+          }
+          plots.doCalcdata = function(gd2, traces) {
+            var axList = axisIDs.list(gd2);
+            var fullData = gd2._fullData;
+            var fullLayout = gd2._fullLayout;
+            var trace, _module, i2, j2;
+            var calcdata = new Array(fullData.length);
+            var oldCalcdata = (gd2.calcdata || []).slice();
+            gd2.calcdata = calcdata;
+            fullLayout._numBoxes = 0;
+            fullLayout._numViolins = 0;
+            fullLayout._violinScaleGroupStats = {};
+            gd2._hmpixcount = 0;
+            gd2._hmlumcount = 0;
+            fullLayout._piecolormap = {};
+            fullLayout._sunburstcolormap = {};
+            fullLayout._treemapcolormap = {};
+            fullLayout._iciclecolormap = {};
+            fullLayout._funnelareacolormap = {};
+            for (i2 = 0; i2 < fullData.length; i2++) {
+              if (Array.isArray(traces) && traces.indexOf(i2) === -1) {
+                calcdata[i2] = oldCalcdata[i2];
+                continue;
+              }
+            }
+            for (i2 = 0; i2 < fullData.length; i2++) {
+              trace = fullData[i2];
+              trace._arrayAttrs = PlotSchema.findArrayAttributes(trace);
+              trace._extremes = {};
+            }
+            var polarIds = fullLayout._subplots.polar || [];
+            for (i2 = 0; i2 < polarIds.length; i2++) {
+              axList.push(
+                fullLayout[polarIds[i2]].radialaxis,
+                fullLayout[polarIds[i2]].angularaxis
+              );
+            }
+            for (var k2 in fullLayout._colorAxes) {
+              var cOpts = fullLayout[k2];
+              if (cOpts.cauto !== false) {
+                delete cOpts.cmin;
+                delete cOpts.cmax;
+              }
+            }
+            var hasCalcTransform = false;
+            function transformCalci(i22) {
+              trace = fullData[i22];
+              _module = trace._module;
+              if (trace.visible === true && trace.transforms) {
+                if (_module && _module.calc) {
+                  var cdi = _module.calc(gd2, trace);
+                  if (cdi[0] && cdi[0].t && cdi[0].t._scene) {
+                    delete cdi[0].t._scene.dirty;
+                  }
+                }
+                for (j2 = 0; j2 < trace.transforms.length; j2++) {
+                  var transform = trace.transforms[j2];
+                  _module = transformsRegistry[transform.type];
+                  if (_module && _module.calcTransform) {
+                    trace._hasCalcTransform = true;
+                    hasCalcTransform = true;
+                    _module.calcTransform(gd2, trace, transform);
+                  }
+                }
+              }
+            }
+            function calci(i22, isContainer) {
+              trace = fullData[i22];
+              _module = trace._module;
+              if (!!_module.isContainer !== isContainer) return;
+              var cd2 = [];
+              if (trace.visible === true && trace._length !== 0) {
+                delete trace._indexToPoints;
+                var transforms = trace.transforms || [];
+                for (j2 = transforms.length - 1; j2 >= 0; j2--) {
+                  if (transforms[j2].enabled) {
+                    trace._indexToPoints = transforms[j2]._indexToPoints;
+                    break;
+                  }
+                }
+                if (_module && _module.calc) {
+                  cd2 = _module.calc(gd2, trace);
+                }
+              }
+              if (!Array.isArray(cd2) || !cd2[0]) {
+                cd2 = [{ x: BADNUM, y: BADNUM }];
+              }
+              if (!cd2[0].t) cd2[0].t = {};
+              cd2[0].trace = trace;
+              calcdata[i22] = cd2;
+            }
+            setupAxisCategories(axList, fullData, fullLayout);
+            for (i2 = 0; i2 < fullData.length; i2++) calci(i2, true);
+            for (i2 = 0; i2 < fullData.length; i2++) transformCalci(i2);
+            if (hasCalcTransform) setupAxisCategories(axList, fullData, fullLayout);
+            for (i2 = 0; i2 < fullData.length; i2++) calci(i2, true);
+            for (i2 = 0; i2 < fullData.length; i2++) calci(i2, false);
+            doCrossTraceCalc(gd2);
+            var sorted = sortAxisCategoriesByValue(axList, gd2);
+            if (sorted.length) {
+              fullLayout._numBoxes = 0;
+              fullLayout._numViolins = 0;
+              for (i2 = 0; i2 < sorted.length; i2++) calci(sorted[i2], true);
+              for (i2 = 0; i2 < sorted.length; i2++) calci(sorted[i2], false);
+              doCrossTraceCalc(gd2);
+            }
+            Registry.getComponentMethod("fx", "calc")(gd2);
+            Registry.getComponentMethod("errorbars", "calc")(gd2);
+          };
+          var sortAxisCategoriesByValueRegex = /(total|sum|min|max|mean|geometric mean|median) (ascending|descending)/;
+          function sortAxisCategoriesByValue(axList, gd2) {
+            var affectedTraces = [];
+            var i2, j2, k2, l2, o2;
+            function zMapCategory(type2, ax2, value2) {
+              var axLetter2 = ax2._id.charAt(0);
+              if (type2 === "histogram2dcontour") {
+                var counterAxLetter = ax2._counterAxes[0];
+                var counterAx = axisIDs.getFromId(gd2, counterAxLetter);
+                var xCategorical = axLetter2 === "x" || counterAxLetter === "x" && counterAx.type === "category";
+                var yCategorical = axLetter2 === "y" || counterAxLetter === "y" && counterAx.type === "category";
+                return function(o22, l22) {
+                  if (o22 === 0 || l22 === 0) return -1;
+                  if (xCategorical && o22 === value2[l22].length - 1) return -1;
+                  if (yCategorical && l22 === value2.length - 1) return -1;
+                  return (axLetter2 === "y" ? l22 : o22) - 1;
+                };
+              } else {
+                return function(o22, l22) {
+                  return axLetter2 === "y" ? l22 : o22;
+                };
+              }
+            }
+            var aggFn = {
+              min: function(values) {
+                return Lib.aggNums(Math.min, null, values);
+              },
+              max: function(values) {
+                return Lib.aggNums(Math.max, null, values);
+              },
+              sum: function(values) {
+                return Lib.aggNums(function(a2, b2) {
+                  return a2 + b2;
+                }, null, values);
+              },
+              total: function(values) {
+                return Lib.aggNums(function(a2, b2) {
+                  return a2 + b2;
+                }, null, values);
+              },
+              mean: function(values) {
+                return Lib.mean(values);
+              },
+              "geometric mean": function(values) {
+                return Lib.geometricMean(values);
+              },
+              median: function(values) {
+                return Lib.median(values);
+              }
+            };
+            function sortAscending(a2, b2) {
+              return a2[1] - b2[1];
+            }
+            function sortDescending(a2, b2) {
+              return b2[1] - a2[1];
+            }
+            for (i2 = 0; i2 < axList.length; i2++) {
+              var ax = axList[i2];
+              if (ax.type !== "category") continue;
+              var match = ax.categoryorder.match(sortAxisCategoriesByValueRegex);
+              if (match) {
+                var aggregator = match[1];
+                var order = match[2];
+                var axLetter = ax._id.charAt(0);
+                var isX = axLetter === "x";
+                var categoriesValue = [];
+                for (j2 = 0; j2 < ax._categories.length; j2++) {
+                  categoriesValue.push([ax._categories[j2], []]);
+                }
+                for (j2 = 0; j2 < ax._traceIndices.length; j2++) {
+                  var traceIndex = ax._traceIndices[j2];
+                  var fullTrace = gd2._fullData[traceIndex];
+                  if (fullTrace.visible !== true) continue;
+                  var type = fullTrace.type;
+                  if (Registry.traceIs(fullTrace, "histogram")) {
+                    delete fullTrace._xautoBinFinished;
+                    delete fullTrace._yautoBinFinished;
+                  }
+                  var isSplom = type === "splom";
+                  var isScattergl = type === "scattergl";
+                  var cd2 = gd2.calcdata[traceIndex];
+                  for (k2 = 0; k2 < cd2.length; k2++) {
+                    var cdi = cd2[k2];
+                    var catIndex, value;
+                    if (isSplom) {
+                      var currentDimensionIndex = fullTrace._axesDim[ax._id];
+                      if (!isX) {
+                        var associatedXAxisID = fullTrace._diag[currentDimensionIndex][0];
+                        if (associatedXAxisID) ax = gd2._fullLayout[axisIDs.id2name(associatedXAxisID)];
+                      }
+                      var categories = cdi.trace.dimensions[currentDimensionIndex].values;
+                      for (l2 = 0; l2 < categories.length; l2++) {
+                        catIndex = ax._categoriesMap[categories[l2]];
+                        for (o2 = 0; o2 < cdi.trace.dimensions.length; o2++) {
+                          if (o2 === currentDimensionIndex) continue;
+                          var dimension = cdi.trace.dimensions[o2];
+                          categoriesValue[catIndex][1].push(dimension.values[l2]);
+                        }
+                      }
+                    } else if (isScattergl) {
+                      for (l2 = 0; l2 < cdi.t.x.length; l2++) {
+                        if (isX) {
+                          catIndex = cdi.t.x[l2];
+                          value = cdi.t.y[l2];
+                        } else {
+                          catIndex = cdi.t.y[l2];
+                          value = cdi.t.x[l2];
+                        }
+                        categoriesValue[catIndex][1].push(value);
+                      }
+                      if (cdi.t && cdi.t._scene) {
+                        delete cdi.t._scene.dirty;
+                      }
+                    } else if (cdi.hasOwnProperty("z")) {
+                      value = cdi.z;
+                      var mapping = zMapCategory(fullTrace.type, ax, value);
+                      for (l2 = 0; l2 < value.length; l2++) {
+                        for (o2 = 0; o2 < value[l2].length; o2++) {
+                          catIndex = mapping(o2, l2);
+                          if (catIndex + 1) categoriesValue[catIndex][1].push(value[l2][o2]);
+                        }
+                      }
+                    } else {
+                      catIndex = cdi.p;
+                      if (catIndex === void 0) catIndex = cdi[axLetter];
+                      value = cdi.s;
+                      if (value === void 0) value = cdi.v;
+                      if (value === void 0) value = isX ? cdi.y : cdi.x;
+                      if (!Array.isArray(value)) {
+                        if (value === void 0) value = [];
+                        else value = [value];
+                      }
+                      for (l2 = 0; l2 < value.length; l2++) {
+                        categoriesValue[catIndex][1].push(value[l2]);
+                      }
+                    }
+                  }
+                }
+                ax._categoriesValue = categoriesValue;
+                var categoriesAggregatedValue = [];
+                for (j2 = 0; j2 < categoriesValue.length; j2++) {
+                  categoriesAggregatedValue.push([
+                    categoriesValue[j2][0],
+                    aggFn[aggregator](categoriesValue[j2][1])
+                  ]);
+                }
+                categoriesAggregatedValue.sort(order === "descending" ? sortDescending : sortAscending);
+                ax._categoriesAggregatedValue = categoriesAggregatedValue;
+                ax._initialCategories = categoriesAggregatedValue.map(function(c2) {
+                  return c2[0];
+                });
+                affectedTraces = affectedTraces.concat(ax.sortByInitialCategories());
+              }
+            }
+            return affectedTraces;
+          }
+          function setupAxisCategories(axList, fullData, fullLayout) {
+            var axLookup = {};
+            function setupOne(ax) {
+              ax.clearCalc();
+              if (ax.type === "multicategory") {
+                ax.setupMultiCategory(fullData);
+              }
+              axLookup[ax._id] = 1;
+            }
+            Lib.simpleMap(axList, setupOne);
+            var matchGroups = fullLayout._axisMatchGroups || [];
+            for (var i2 = 0; i2 < matchGroups.length; i2++) {
+              for (var axId in matchGroups[i2]) {
+                if (!axLookup[axId]) {
+                  setupOne(fullLayout[axisIDs.id2name(axId)]);
+                }
+              }
+            }
+          }
+          function doCrossTraceCalc(gd2) {
+            var fullLayout = gd2._fullLayout;
+            var modules = fullLayout._visibleModules;
+            var hash = {};
+            var i2, j2, k2;
+            for (j2 = 0; j2 < modules.length; j2++) {
+              var _module = modules[j2];
+              var fn = _module.crossTraceCalc;
+              if (fn) {
+                var spType = _module.basePlotModule.name;
+                if (hash[spType]) {
+                  Lib.pushUnique(hash[spType], fn);
+                } else {
+                  hash[spType] = [fn];
+                }
+              }
+            }
+            for (k2 in hash) {
+              var methods = hash[k2];
+              var subplots = fullLayout._subplots[k2];
+              if (Array.isArray(subplots)) {
+                for (i2 = 0; i2 < subplots.length; i2++) {
+                  var sp = subplots[i2];
+                  var spInfo = k2 === "cartesian" ? fullLayout._plots[sp] : fullLayout[sp];
+                  for (j2 = 0; j2 < methods.length; j2++) {
+                    methods[j2](gd2, spInfo, sp);
+                  }
+                }
+              } else {
+                for (j2 = 0; j2 < methods.length; j2++) {
+                  methods[j2](gd2);
+                }
+              }
+            }
+          }
+          plots.rehover = function(gd2) {
+            if (gd2._fullLayout._rehover) {
+              gd2._fullLayout._rehover();
+            }
+          };
+          plots.redrag = function(gd2) {
+            if (gd2._fullLayout._redrag) {
+              gd2._fullLayout._redrag();
+            }
+          };
+          plots.reselect = function(gd2) {
+            var fullLayout = gd2._fullLayout;
+            var A22 = (gd2.layout || {}).selections;
+            var B22 = fullLayout._previousSelections;
+            fullLayout._previousSelections = A22;
+            var mayEmitSelected = fullLayout._reselect || JSON.stringify(A22) !== JSON.stringify(B22);
+            Registry.getComponentMethod("selections", "reselect")(gd2, mayEmitSelected);
+          };
+          plots.generalUpdatePerTraceModule = function(gd2, subplot, subplotCalcData, subplotLayout) {
+            var traceHashOld = subplot.traceHash;
+            var traceHash = {};
+            var i2;
+            for (i2 = 0; i2 < subplotCalcData.length; i2++) {
+              var calcTraces = subplotCalcData[i2];
+              var trace = calcTraces[0].trace;
+              if (trace.visible) {
+                traceHash[trace.type] = traceHash[trace.type] || [];
+                traceHash[trace.type].push(calcTraces);
+              }
+            }
+            for (var moduleNameOld in traceHashOld) {
+              if (!traceHash[moduleNameOld]) {
+                var fakeCalcTrace = traceHashOld[moduleNameOld][0];
+                var fakeTrace = fakeCalcTrace[0].trace;
+                fakeTrace.visible = false;
+                traceHash[moduleNameOld] = [fakeCalcTrace];
+              }
+            }
+            for (var moduleName in traceHash) {
+              var moduleCalcData = traceHash[moduleName];
+              var _module = moduleCalcData[0][0].trace._module;
+              _module.plot(gd2, subplot, Lib.filterVisible(moduleCalcData), subplotLayout);
+            }
+            subplot.traceHash = traceHash;
+          };
+          plots.plotBasePlot = function(desiredType, gd2, traces, transitionOpts, makeOnCompleteCallback) {
+            var _module = Registry.getModule(desiredType);
+            var cdmodule = getModuleCalcData(gd2.calcdata, _module)[0];
+            _module.plot(gd2, cdmodule, transitionOpts, makeOnCompleteCallback);
+          };
+          plots.cleanBasePlot = function(desiredType, newFullData, newFullLayout, oldFullData, oldFullLayout) {
+            var had = oldFullLayout._has && oldFullLayout._has(desiredType);
+            var has = newFullLayout._has && newFullLayout._has(desiredType);
+            if (had && !has) {
+              oldFullLayout["_" + desiredType + "layer"].selectAll("g.trace").remove();
+            }
+          };
+        }
+      });
+      var require_xmlns_namespaces = __commonJS({
+        "src/constants/xmlns_namespaces.js"(exports) {
+          exports.xmlns = "http://www.w3.org/2000/xmlns/";
+          exports.svg = "http://www.w3.org/2000/svg";
+          exports.xlink = "http://www.w3.org/1999/xlink";
+          exports.svgAttrs = {
+            xmlns: exports.svg,
+            "xmlns:xlink": exports.xlink
+          };
+        }
+      });
+      var require_alignment = __commonJS({
+        "src/constants/alignment.js"(exports, module2) {
+          module2.exports = {
+            // from bottom left: this is the origin of our paper-reference
+            // positioning system
+            FROM_BL: {
+              left: 0,
+              center: 0.5,
+              right: 1,
+              bottom: 0,
+              middle: 0.5,
+              top: 1
+            },
+            // from top left: this is the screen pixel positioning origin
+            FROM_TL: {
+              left: 0,
+              center: 0.5,
+              right: 1,
+              bottom: 1,
+              middle: 0.5,
+              top: 0
+            },
+            // from bottom right: sometimes you just need the opposite of ^^
+            FROM_BR: {
+              left: 1,
+              center: 0.5,
+              right: 0,
+              bottom: 0,
+              middle: 0.5,
+              top: 1
+            },
+            // multiple of fontSize to get the vertical offset between lines
+            LINE_SPACING: 1.3,
+            // multiple of fontSize to shift from the baseline
+            // to the cap (captical letter) line
+            // (to use when we don't calculate this shift from Drawing.bBox)
+            // This is an approximation since in reality cap height can differ
+            // from font to font. However, according to Wikipedia
+            //   an "average" font might have a cap height of 70% of the em
+            // https://en.wikipedia.org/wiki/Em_(typography)#History
+            CAP_SHIFT: 0.7,
+            // half the cap height (distance between baseline and cap line)
+            // of an "average" font (for more info see above).
+            MID_SHIFT: 0.35,
+            OPPOSITE_SIDE: {
+              left: "right",
+              right: "left",
+              top: "bottom",
+              bottom: "top"
+            }
+          };
+        }
+      });
+      var require_svg_text_utils = __commonJS({
+        "src/lib/svg_text_utils.js"(exports) {
+          var d3 = require_d3();
+          var Lib = require_lib();
+          var strTranslate = Lib.strTranslate;
+          var xmlnsNamespaces = require_xmlns_namespaces();
+          var LINE_SPACING = require_alignment().LINE_SPACING;
+          var FIND_TEX = /([^$]*)([$]+[^$]*[$]+)([^$]*)/;
+          exports.convertToTspans = function(_context, gd2, _callback) {
+            var str = _context.text();
+            var tex = !_context.attr("data-notex") && gd2 && gd2._context.typesetMath && typeof MathJax !== "undefined" && str.match(FIND_TEX);
+            var parent = d3.select(_context.node().parentNode);
+            if (parent.empty()) return;
+            var svgClass = _context.attr("class") ? _context.attr("class").split(" ")[0] : "text";
+            svgClass += "-math";
+            parent.selectAll("svg." + svgClass).remove();
+            parent.selectAll("g." + svgClass + "-group").remove();
+            _context.style("display", null).attr({
+              // some callers use data-unformatted *from the <text> element* in 'cancel'
+              // so we need it here even if we're going to turn it into math
+              // these two (plus style and text-anchor attributes) form the key we're
+              // going to use for Drawing.bBox
+              "data-unformatted": str,
+              "data-math": "N"
+            });
+            function showText() {
+              if (!parent.empty()) {
+                svgClass = _context.attr("class") + "-math";
+                parent.select("svg." + svgClass).remove();
+              }
+              _context.text("").style("white-space", "pre");
+              var hasLink = buildSVGText(_context.node(), str);
+              if (hasLink) {
+                _context.style("pointer-events", "all");
+              }
+              exports.positionText(_context);
+              if (_callback) _callback.call(_context);
+            }
+            if (tex) {
+              (gd2 && gd2._promises || []).push(new Promise(function(resolve) {
+                _context.style("display", "none");
+                var fontSize = parseInt(_context.node().style.fontSize, 10);
+                var config2 = { fontSize };
+                texToSVG(tex[2], config2, function(_svgEl, _glyphDefs, _svgBBox) {
+                  parent.selectAll("svg." + svgClass).remove();
+                  parent.selectAll("g." + svgClass + "-group").remove();
+                  var newSvg = _svgEl && _svgEl.select("svg");
+                  if (!newSvg || !newSvg.node()) {
+                    showText();
+                    resolve();
+                    return;
+                  }
+                  var mathjaxGroup = parent.append("g").classed(svgClass + "-group", true).attr({
+                    "pointer-events": "none",
+                    "data-unformatted": str,
+                    "data-math": "Y"
+                  });
+                  mathjaxGroup.node().appendChild(newSvg.node());
+                  if (_glyphDefs && _glyphDefs.node()) {
+                    newSvg.node().insertBefore(
+                      _glyphDefs.node().cloneNode(true),
+                      newSvg.node().firstChild
+                    );
+                  }
+                  var w0 = _svgBBox.width;
+                  var h0 = _svgBBox.height;
+                  newSvg.attr({
+                    class: svgClass,
+                    height: h0,
+                    preserveAspectRatio: "xMinYMin meet"
+                  }).style({ overflow: "visible", "pointer-events": "none" });
+                  var fill = _context.node().style.fill || "black";
+                  var g2 = newSvg.select("g");
+                  g2.attr({ fill, stroke: fill });
+                  var bb2 = g2.node().getBoundingClientRect();
+                  var w2 = bb2.width;
+                  var h2 = bb2.height;
+                  if (w2 > w0 || h2 > h0) {
+                    newSvg.style("overflow", "hidden");
+                    bb2 = newSvg.node().getBoundingClientRect();
+                    w2 = bb2.width;
+                    h2 = bb2.height;
+                  }
+                  var x2 = +_context.attr("x");
+                  var y2 = +_context.attr("y");
+                  var textHeight = fontSize || _context.node().getBoundingClientRect().height;
+                  var dy = -textHeight / 4;
+                  if (svgClass[0] === "y") {
+                    mathjaxGroup.attr({
+                      transform: "rotate(" + [-90, x2, y2] + ")" + strTranslate(-w2 / 2, dy - h2 / 2)
+                    });
+                  } else if (svgClass[0] === "l") {
+                    y2 = dy - h2 / 2;
+                  } else if (svgClass[0] === "a" && svgClass.indexOf("atitle") !== 0) {
+                    x2 = 0;
+                    y2 = dy;
+                  } else {
+                    var anchor = _context.attr("text-anchor");
+                    x2 = x2 - w2 * (anchor === "middle" ? 0.5 : anchor === "end" ? 1 : 0);
+                    y2 = y2 + dy - h2 / 2;
+                  }
+                  newSvg.attr({
+                    x: x2,
+                    y: y2
+                  });
+                  if (_callback) _callback.call(_context, mathjaxGroup);
+                  resolve(mathjaxGroup);
+                });
+              }));
+            } else showText();
+            return _context;
+          };
+          var LT_MATCH = /(<|&lt;|&#60;)/g;
+          var GT_MATCH = /(>|&gt;|&#62;)/g;
+          function cleanEscapesForTex(s2) {
+            return s2.replace(LT_MATCH, "\\lt ").replace(GT_MATCH, "\\gt ");
+          }
+          var inlineMath = [["$", "$"], ["\\(", "\\)"]];
+          function texToSVG(_texString, _config, _callback) {
+            var MathJaxVersion = parseInt(
+              (MathJax.version || "").split(".")[0]
+            );
+            if (MathJaxVersion !== 2 && MathJaxVersion !== 3) {
+              Lib.warn("No MathJax version:", MathJax.version);
+              return;
+            }
+            var originalRenderer, originalConfig, originalProcessSectionDelay, tmpDiv;
+            var setConfig2 = function() {
+              originalConfig = Lib.extendDeepAll({}, MathJax.Hub.config);
+              originalProcessSectionDelay = MathJax.Hub.processSectionDelay;
+              if (MathJax.Hub.processSectionDelay !== void 0) {
+                MathJax.Hub.processSectionDelay = 0;
+              }
+              return MathJax.Hub.Config({
+                messageStyle: "none",
+                tex2jax: {
+                  inlineMath
+                },
+                displayAlign: "left"
+              });
+            };
+            var setConfig3 = function() {
+              originalConfig = Lib.extendDeepAll({}, MathJax.config);
+              if (!MathJax.config.tex) {
+                MathJax.config.tex = {};
+              }
+              MathJax.config.tex.inlineMath = inlineMath;
+            };
+            var setRenderer2 = function() {
+              originalRenderer = MathJax.Hub.config.menuSettings.renderer;
+              if (originalRenderer !== "SVG") {
+                return MathJax.Hub.setRenderer("SVG");
+              }
+            };
+            var setRenderer3 = function() {
+              originalRenderer = MathJax.config.startup.output;
+              if (originalRenderer !== "svg") {
+                MathJax.config.startup.output = "svg";
+              }
+            };
+            var initiateMathJax = function() {
+              var randomID = "math-output-" + Lib.randstr({}, 64);
+              tmpDiv = d3.select("body").append("div").attr({ id: randomID }).style({
+                visibility: "hidden",
+                position: "absolute",
+                "font-size": _config.fontSize + "px"
+              }).text(cleanEscapesForTex(_texString));
+              var tmpNode = tmpDiv.node();
+              return MathJaxVersion === 2 ? MathJax.Hub.Typeset(tmpNode) : MathJax.typeset([tmpNode]);
+            };
+            var finalizeMathJax = function() {
+              var sel = tmpDiv.select(
+                MathJaxVersion === 2 ? ".MathJax_SVG" : ".MathJax"
+              );
+              var node = !sel.empty() && tmpDiv.select("svg").node();
+              if (!node) {
+                Lib.log("There was an error in the tex syntax.", _texString);
+                _callback();
+              } else {
+                var nodeBBox = node.getBoundingClientRect();
+                var glyphDefs;
+                if (MathJaxVersion === 2) {
+                  glyphDefs = d3.select("body").select("#MathJax_SVG_glyphs");
+                } else {
+                  glyphDefs = sel.select("defs");
+                }
+                _callback(sel, glyphDefs, nodeBBox);
+              }
+              tmpDiv.remove();
+            };
+            var resetRenderer2 = function() {
+              if (originalRenderer !== "SVG") {
+                return MathJax.Hub.setRenderer(originalRenderer);
+              }
+            };
+            var resetRenderer3 = function() {
+              if (originalRenderer !== "svg") {
+                MathJax.config.startup.output = originalRenderer;
+              }
+            };
+            var resetConfig2 = function() {
+              if (originalProcessSectionDelay !== void 0) {
+                MathJax.Hub.processSectionDelay = originalProcessSectionDelay;
+              }
+              return MathJax.Hub.Config(originalConfig);
+            };
+            var resetConfig3 = function() {
+              MathJax.config = originalConfig;
+            };
+            if (MathJaxVersion === 2) {
+              MathJax.Hub.Queue(
+                setConfig2,
+                setRenderer2,
+                initiateMathJax,
+                finalizeMathJax,
+                resetRenderer2,
+                resetConfig2
+              );
+            } else if (MathJaxVersion === 3) {
+              setConfig3();
+              setRenderer3();
+              MathJax.startup.defaultReady();
+              MathJax.startup.promise.then(function() {
+                initiateMathJax();
+                finalizeMathJax();
+                resetRenderer3();
+                resetConfig3();
+              });
+            }
+          }
+          var TAG_STYLES = {
+            // would like to use baseline-shift for sub/sup but FF doesn't support it
+            // so we need to use dy along with the uber hacky shift-back-to
+            // baseline below
+            sup: "font-size:70%",
+            sub: "font-size:70%",
+            s: "text-decoration:line-through",
+            u: "text-decoration:underline",
+            b: "font-weight:bold",
+            i: "font-style:italic",
+            a: "cursor:pointer",
+            span: "",
+            em: "font-style:italic;font-weight:bold"
+          };
+          var SHIFT_DY = {
+            sub: "0.3em",
+            sup: "-0.6em"
+          };
+          var RESET_DY = {
+            sub: "-0.21em",
+            sup: "0.42em"
+          };
+          var ZERO_WIDTH_SPACE = "​";
+          var PROTOCOLS = ["http:", "https:", "mailto:", "", void 0, ":"];
+          var NEWLINES = exports.NEWLINES = /(\r\n?|\n)/g;
+          var SPLIT_TAGS = /(<[^<>]*>)/;
+          var ONE_TAG = /<(\/?)([^ >]*)(\s+(.*))?>/i;
+          var BR_TAG = /<br(\s+.*)?>/i;
+          exports.BR_TAG_ALL = /<br(\s+.*)?>/gi;
+          var STYLEMATCH = /(^|[\s"'])style\s*=\s*("([^"]*);?"|'([^']*);?')/i;
+          var HREFMATCH = /(^|[\s"'])href\s*=\s*("([^"]*)"|'([^']*)')/i;
+          var TARGETMATCH = /(^|[\s"'])target\s*=\s*("([^"\s]*)"|'([^'\s]*)')/i;
+          var POPUPMATCH = /(^|[\s"'])popup\s*=\s*("([\w=,]*)"|'([\w=,]*)')/i;
+          function getQuotedMatch(_str, re2) {
+            if (!_str) return null;
+            var match = _str.match(re2);
+            var result = match && (match[3] || match[4]);
+            return result && convertEntities(result);
+          }
+          var COLORMATCH = /(^|;)\s*color:/;
+          exports.plainText = function(_str, opts) {
+            opts = opts || {};
+            var len2 = opts.len !== void 0 && opts.len !== -1 ? opts.len : Infinity;
+            var allowedTags = opts.allowedTags !== void 0 ? opts.allowedTags : ["br"];
+            var ellipsis = "...";
+            var eLen = ellipsis.length;
+            var oldParts = _str.split(SPLIT_TAGS);
+            var newParts = [];
+            var prevTag = "";
+            var l2 = 0;
+            for (var i2 = 0; i2 < oldParts.length; i2++) {
+              var p2 = oldParts[i2];
+              var match = p2.match(ONE_TAG);
+              var tagType = match && match[2].toLowerCase();
+              if (tagType) {
+                if (allowedTags.indexOf(tagType) !== -1) {
+                  newParts.push(p2);
+                  prevTag = tagType;
+                }
+              } else {
+                var pLen = p2.length;
+                if (l2 + pLen < len2) {
+                  newParts.push(p2);
+                  l2 += pLen;
+                } else if (l2 < len2) {
+                  var pLen2 = len2 - l2;
+                  if (prevTag && (prevTag !== "br" || pLen2 <= eLen || pLen <= eLen)) {
+                    newParts.pop();
+                  }
+                  if (len2 > eLen) {
+                    newParts.push(p2.slice(0, Math.max(0, pLen2 - eLen)) + ellipsis);
+                  } else {
+                    newParts.push(p2.slice(0, pLen2));
+                  }
+                  break;
+                }
+                prevTag = "";
+              }
+            }
+            return newParts.join("");
+          };
+          var entityToUnicode = {
+            mu: "μ",
+            amp: "&",
+            lt: "<",
+            gt: ">",
+            nbsp: " ",
+            times: "×",
+            plusmn: "±",
+            deg: "°"
+          };
+          var ENTITY_MATCH = /&(#\d+|#x[\da-fA-F]+|[a-z]+);/g;
+          function convertEntities(_str) {
+            return _str.replace(ENTITY_MATCH, function(fullMatch, innerMatch) {
+              var outChar;
+              if (innerMatch.charAt(0) === "#") {
+                outChar = fromCodePoint(
+                  innerMatch.charAt(1) === "x" ? parseInt(innerMatch.slice(2), 16) : parseInt(innerMatch.slice(1), 10)
+                );
+              } else outChar = entityToUnicode[innerMatch];
+              return outChar || fullMatch;
+            });
+          }
+          exports.convertEntities = convertEntities;
+          function fromCodePoint(code) {
+            if (code > 1114111) return;
+            var stringFromCodePoint = String.fromCodePoint;
+            if (stringFromCodePoint) return stringFromCodePoint(code);
+            var stringFromCharCode = String.fromCharCode;
+            if (code <= 65535) return stringFromCharCode(code);
+            return stringFromCharCode(
+              (code >> 10) + 55232,
+              code % 1024 + 56320
+            );
+          }
+          function buildSVGText(containerNode, str) {
+            str = str.replace(NEWLINES, " ");
+            var hasLink = false;
+            var nodeStack = [];
+            var currentNode;
+            var currentLine = -1;
+            function newLine() {
+              currentLine++;
+              var lineNode = document.createElementNS(xmlnsNamespaces.svg, "tspan");
+              d3.select(lineNode).attr({
+                class: "line",
+                dy: currentLine * LINE_SPACING + "em"
+              });
+              containerNode.appendChild(lineNode);
+              currentNode = lineNode;
+              var oldNodeStack = nodeStack;
+              nodeStack = [{ node: lineNode }];
+              if (oldNodeStack.length > 1) {
+                for (var i22 = 1; i22 < oldNodeStack.length; i22++) {
+                  enterNode(oldNodeStack[i22]);
+                }
+              }
+            }
+            function enterNode(nodeSpec2) {
+              var type = nodeSpec2.type;
+              var nodeAttrs = {};
+              var nodeType;
+              if (type === "a") {
+                nodeType = "a";
+                var target = nodeSpec2.target;
+                var href2 = nodeSpec2.href;
+                var popup = nodeSpec2.popup;
+                if (href2) {
+                  nodeAttrs = {
+                    "xlink:xlink:show": target === "_blank" || target.charAt(0) !== "_" ? "new" : "replace",
+                    target,
+                    "xlink:xlink:href": href2
+                  };
+                  if (popup) {
+                    nodeAttrs.onclick = 'window.open(this.href.baseVal,this.target.baseVal,"' + popup + '");return false;';
+                  }
+                }
+              } else nodeType = "tspan";
+              if (nodeSpec2.style) nodeAttrs.style = nodeSpec2.style;
+              var newNode = document.createElementNS(xmlnsNamespaces.svg, nodeType);
+              if (type === "sup" || type === "sub") {
+                addTextNode(currentNode, ZERO_WIDTH_SPACE);
+                currentNode.appendChild(newNode);
+                var resetter = document.createElementNS(xmlnsNamespaces.svg, "tspan");
+                addTextNode(resetter, ZERO_WIDTH_SPACE);
+                d3.select(resetter).attr("dy", RESET_DY[type]);
+                nodeAttrs.dy = SHIFT_DY[type];
+                currentNode.appendChild(newNode);
+                currentNode.appendChild(resetter);
+              } else {
+                currentNode.appendChild(newNode);
+              }
+              d3.select(newNode).attr(nodeAttrs);
+              currentNode = nodeSpec2.node = newNode;
+              nodeStack.push(nodeSpec2);
+            }
+            function addTextNode(node, text) {
+              node.appendChild(document.createTextNode(text));
+            }
+            function exitNode(type) {
+              if (nodeStack.length === 1) {
+                Lib.log("Ignoring unexpected end tag </" + type + ">.", str);
+                return;
+              }
+              var innerNode = nodeStack.pop();
+              if (type !== innerNode.type) {
+                Lib.log("Start tag <" + innerNode.type + "> doesnt match end tag <" + type + ">. Pretending it did match.", str);
+              }
+              currentNode = nodeStack[nodeStack.length - 1].node;
+            }
+            var hasLines = BR_TAG.test(str);
+            if (hasLines) newLine();
+            else {
+              currentNode = containerNode;
+              nodeStack = [{ node: containerNode }];
+            }
+            var parts = str.split(SPLIT_TAGS);
+            for (var i2 = 0; i2 < parts.length; i2++) {
+              var parti = parts[i2];
+              var match = parti.match(ONE_TAG);
+              var tagType = match && match[2].toLowerCase();
+              var tagStyle = TAG_STYLES[tagType];
+              if (tagType === "br") {
+                newLine();
+              } else if (tagStyle === void 0) {
+                addTextNode(currentNode, convertEntities(parti));
+              } else {
+                if (match[1]) {
+                  exitNode(tagType);
+                } else {
+                  var extra = match[4];
+                  var nodeSpec = { type: tagType };
+                  var css = getQuotedMatch(extra, STYLEMATCH);
+                  if (css) {
+                    css = css.replace(COLORMATCH, "$1 fill:");
+                    if (tagStyle) css += ";" + tagStyle;
+                  } else if (tagStyle) css = tagStyle;
+                  if (css) nodeSpec.style = css;
+                  if (tagType === "a") {
+                    hasLink = true;
+                    var href = getQuotedMatch(extra, HREFMATCH);
+                    if (href) {
+                      var safeHref = sanitizeHref(href);
+                      if (safeHref) {
+                        nodeSpec.href = safeHref;
+                        nodeSpec.target = getQuotedMatch(extra, TARGETMATCH) || "_blank";
+                        nodeSpec.popup = getQuotedMatch(extra, POPUPMATCH);
+                      }
+                    }
+                  }
+                  enterNode(nodeSpec);
+                }
+              }
+            }
+            return hasLink;
+          }
+          function sanitizeHref(href) {
+            var decodedHref = encodeURI(decodeURI(href));
+            var dummyAnchor1 = document.createElement("a");
+            var dummyAnchor2 = document.createElement("a");
+            dummyAnchor1.href = href;
+            dummyAnchor2.href = decodedHref;
+            var p1 = dummyAnchor1.protocol;
+            var p2 = dummyAnchor2.protocol;
+            if (PROTOCOLS.indexOf(p1) !== -1 && PROTOCOLS.indexOf(p2) !== -1) {
+              return decodedHref;
+            } else {
+              return "";
+            }
+          }
+          exports.sanitizeHTML = function sanitizeHTML(str) {
+            str = str.replace(NEWLINES, " ");
+            var rootNode = document.createElement("p");
+            var currentNode = rootNode;
+            var nodeStack = [];
+            var parts = str.split(SPLIT_TAGS);
+            for (var i2 = 0; i2 < parts.length; i2++) {
+              var parti = parts[i2];
+              var match = parti.match(ONE_TAG);
+              var tagType = match && match[2].toLowerCase();
+              if (tagType in TAG_STYLES) {
+                if (match[1]) {
+                  if (nodeStack.length) {
+                    currentNode = nodeStack.pop();
+                  }
+                } else {
+                  var extra = match[4];
+                  var css = getQuotedMatch(extra, STYLEMATCH);
+                  var nodeAttrs = css ? { style: css } : {};
+                  if (tagType === "a") {
+                    var href = getQuotedMatch(extra, HREFMATCH);
+                    if (href) {
+                      var safeHref = sanitizeHref(href);
+                      if (safeHref) {
+                        nodeAttrs.href = safeHref;
+                        var target = getQuotedMatch(extra, TARGETMATCH);
+                        if (target) {
+                          nodeAttrs.target = target;
+                        }
+                      }
+                    }
+                  }
+                  var newNode = document.createElement(tagType);
+                  currentNode.appendChild(newNode);
+                  d3.select(newNode).attr(nodeAttrs);
+                  currentNode = newNode;
+                  nodeStack.push(newNode);
+                }
+              } else {
+                currentNode.appendChild(
+                  document.createTextNode(convertEntities(parti))
+                );
+              }
+            }
+            var key = "innerHTML";
+            return rootNode[key];
+          };
+          exports.lineCount = function lineCount(s2) {
+            return s2.selectAll("tspan.line").size() || 1;
+          };
+          exports.positionText = function positionText(s2, x2, y2) {
+            return s2.each(function() {
+              var text = d3.select(this);
+              function setOrGet(attr, val) {
+                if (val === void 0) {
+                  val = text.attr(attr);
+                  if (val === null) {
+                    text.attr(attr, 0);
+                    val = 0;
+                  }
+                } else text.attr(attr, val);
+                return val;
+              }
+              var thisX = setOrGet("x", x2);
+              var thisY = setOrGet("y", y2);
+              if (this.nodeName === "text") {
+                text.selectAll("tspan.line").attr({ x: thisX, y: thisY });
+              }
+            });
+          };
+          function alignHTMLWith(_base, container, options) {
+            var alignH = options.horizontalAlign;
+            var alignV = options.verticalAlign || "top";
+            var bRect = _base.node().getBoundingClientRect();
+            var cRect = container.node().getBoundingClientRect();
+            var thisRect;
+            var getTop;
+            var getLeft;
+            if (alignV === "bottom") {
+              getTop = function() {
+                return bRect.bottom - thisRect.height;
+              };
+            } else if (alignV === "middle") {
+              getTop = function() {
+                return bRect.top + (bRect.height - thisRect.height) / 2;
+              };
+            } else {
+              getTop = function() {
+                return bRect.top;
+              };
+            }
+            if (alignH === "right") {
+              getLeft = function() {
+                return bRect.right - thisRect.width;
+              };
+            } else if (alignH === "center") {
+              getLeft = function() {
+                return bRect.left + (bRect.width - thisRect.width) / 2;
+              };
+            } else {
+              getLeft = function() {
+                return bRect.left;
+              };
+            }
+            return function() {
+              thisRect = this.node().getBoundingClientRect();
+              var x0 = getLeft() - cRect.left;
+              var y0 = getTop() - cRect.top;
+              var gd2 = options.gd || {};
+              if (options.gd) {
+                gd2._fullLayout._calcInverseTransform(gd2);
+                var transformedCoords = Lib.apply3DTransform(gd2._fullLayout._invTransform)(x0, y0);
+                x0 = transformedCoords[0];
+                y0 = transformedCoords[1];
+              }
+              this.style({
+                top: y0 + "px",
+                left: x0 + "px",
+                "z-index": 1e3
+              });
+              return this;
+            };
+          }
+          var onePx = "1px ";
+          exports.makeTextShadow = function(color22) {
+            var x2 = onePx;
+            var y2 = onePx;
+            var b2 = onePx;
+            return x2 + y2 + b2 + color22 + ", -" + x2 + "-" + y2 + b2 + color22 + ", " + x2 + "-" + y2 + b2 + color22 + ", -" + x2 + y2 + b2 + color22;
+          };
+          exports.makeEditable = function(context, options) {
+            var gd2 = options.gd;
+            var _delegate = options.delegate;
+            var dispatch = d3.dispatch("edit", "input", "cancel");
+            var handlerElement = _delegate || context;
+            context.style({ "pointer-events": _delegate ? "none" : "all" });
+            if (context.size() !== 1) throw new Error("boo");
+            function handleClick() {
+              appendEditable();
+              context.style({ opacity: 0 });
+              var svgClass = handlerElement.attr("class");
+              var mathjaxClass;
+              if (svgClass) mathjaxClass = "." + svgClass.split(" ")[0] + "-math-group";
+              else mathjaxClass = "[class*=-math-group]";
+              if (mathjaxClass) {
+                d3.select(context.node().parentNode).select(mathjaxClass).style({ opacity: 0 });
+              }
+            }
+            function selectElementContents(_el) {
+              var el2 = _el.node();
+              var range = document.createRange();
+              range.selectNodeContents(el2);
+              var sel = window.getSelection();
+              sel.removeAllRanges();
+              sel.addRange(range);
+              el2.focus();
+            }
+            function appendEditable() {
+              var plotDiv = d3.select(gd2);
+              var container = plotDiv.select(".svg-container");
+              var div = container.append("div");
+              var cStyle = context.node().style;
+              var fontSize = parseFloat(cStyle.fontSize || 12);
+              var initialText = options.text;
+              if (initialText === void 0) initialText = context.attr("data-unformatted");
+              div.classed("plugin-editable editable", true).style({
+                position: "absolute",
+                "font-family": cStyle.fontFamily || "Arial",
+                "font-size": fontSize,
+                color: options.fill || cStyle.fill || "black",
+                opacity: 1,
+                "background-color": options.background || "transparent",
+                outline: "#ffffff33 1px solid",
+                margin: [-fontSize / 8 + 1, 0, 0, -1].join("px ") + "px",
+                padding: "0",
+                "box-sizing": "border-box"
+              }).attr({ contenteditable: true }).text(initialText).call(alignHTMLWith(context, container, options)).on("blur", function() {
+                gd2._editing = false;
+                context.text(this.textContent).style({ opacity: 1 });
+                var svgClass = d3.select(this).attr("class");
+                var mathjaxClass;
+                if (svgClass) mathjaxClass = "." + svgClass.split(" ")[0] + "-math-group";
+                else mathjaxClass = "[class*=-math-group]";
+                if (mathjaxClass) {
+                  d3.select(context.node().parentNode).select(mathjaxClass).style({ opacity: 0 });
+                }
+                var text = this.textContent;
+                d3.select(this).transition().duration(0).remove();
+                d3.select(document).on("mouseup", null);
+                dispatch.edit.call(context, text);
+              }).on("focus", function() {
+                var editDiv = this;
+                gd2._editing = true;
+                d3.select(document).on("mouseup", function() {
+                  if (d3.event.target === editDiv) return false;
+                  if (document.activeElement === div.node()) div.node().blur();
+                });
+              }).on("keyup", function() {
+                if (d3.event.which === 27) {
+                  gd2._editing = false;
+                  context.style({ opacity: 1 });
+                  d3.select(this).style({ opacity: 0 }).on("blur", function() {
+                    return false;
+                  }).transition().remove();
+                  dispatch.cancel.call(context, this.textContent);
+                } else {
+                  dispatch.input.call(context, this.textContent);
+                  d3.select(this).call(alignHTMLWith(context, container, options));
+                }
+              }).on("keydown", function() {
+                if (d3.event.which === 13) this.blur();
+              }).call(selectElementContents);
+            }
+            if (options.immediate) handleClick();
+            else handlerElement.on("click", handleClick);
+            return d3.rebind(context, dispatch, "on");
+          };
+        }
+      });
+      var require_helpers = __commonJS({
+        "src/components/colorscale/helpers.js"(exports, module2) {
+          var d3 = require_d3();
+          var tinycolor = require_tinycolor();
+          var isNumeric = require_fast_isnumeric();
+          var Lib = require_lib();
+          var Color2 = require_color();
+          var isValidScale = require_scales().isValid;
+          function hasColorscale(trace, containerStr, colorKey) {
+            var container = containerStr ? Lib.nestedProperty(trace, containerStr).get() || {} : trace;
+            var color22 = container[colorKey || "color"];
+            if (color22 && color22._inputArray) color22 = color22._inputArray;
+            var isArrayWithOneNumber = false;
+            if (Lib.isArrayOrTypedArray(color22)) {
+              for (var i2 = 0; i2 < color22.length; i2++) {
+                if (isNumeric(color22[i2])) {
+                  isArrayWithOneNumber = true;
+                  break;
+                }
+              }
+            }
+            return Lib.isPlainObject(container) && (isArrayWithOneNumber || container.showscale === true || isNumeric(container.cmin) && isNumeric(container.cmax) || isValidScale(container.colorscale) || Lib.isPlainObject(container.colorbar));
+          }
+          var constantAttrs = ["showscale", "autocolorscale", "colorscale", "reversescale", "colorbar"];
+          var letterAttrs = ["min", "max", "mid", "auto"];
+          function extractOpts(cont) {
+            var colorAx = cont._colorAx;
+            var cont2 = colorAx ? colorAx : cont;
+            var out = {};
+            var cLetter;
+            var i2, k2;
+            for (i2 = 0; i2 < constantAttrs.length; i2++) {
+              k2 = constantAttrs[i2];
+              out[k2] = cont2[k2];
+            }
+            if (colorAx) {
+              cLetter = "c";
+              for (i2 = 0; i2 < letterAttrs.length; i2++) {
+                k2 = letterAttrs[i2];
+                out[k2] = cont2["c" + k2];
+              }
+            } else {
+              var k22;
+              for (i2 = 0; i2 < letterAttrs.length; i2++) {
+                k2 = letterAttrs[i2];
+                k22 = "c" + k2;
+                if (k22 in cont2) {
+                  out[k2] = cont2[k22];
+                  continue;
+                }
+                k22 = "z" + k2;
+                if (k22 in cont2) {
+                  out[k2] = cont2[k22];
+                }
+              }
+              cLetter = k22.charAt(0);
+            }
+            out._sync = function(k3, v2) {
+              var k222 = letterAttrs.indexOf(k3) !== -1 ? cLetter + k3 : k3;
+              cont2[k222] = cont2["_" + k222] = v2;
+            };
+            return out;
+          }
+          function extractScale(cont) {
+            var cOpts = extractOpts(cont);
+            var cmin = cOpts.min;
+            var cmax = cOpts.max;
+            var scl = cOpts.reversescale ? flipScale(cOpts.colorscale) : cOpts.colorscale;
+            var N2 = scl.length;
+            var domain = new Array(N2);
+            var range = new Array(N2);
+            for (var i2 = 0; i2 < N2; i2++) {
+              var si2 = scl[i2];
+              domain[i2] = cmin + si2[0] * (cmax - cmin);
+              range[i2] = si2[1];
+            }
+            return { domain, range };
+          }
+          function flipScale(scl) {
+            var N2 = scl.length;
+            var sclNew = new Array(N2);
+            for (var i2 = N2 - 1, j2 = 0; i2 >= 0; i2--, j2++) {
+              var si2 = scl[i2];
+              sclNew[j2] = [1 - si2[0], si2[1]];
+            }
+            return sclNew;
+          }
+          function makeColorScaleFunc(specs, opts) {
+            opts = opts || {};
+            var domain = specs.domain;
+            var range = specs.range;
+            var N2 = range.length;
+            var _range = new Array(N2);
+            for (var i2 = 0; i2 < N2; i2++) {
+              var rgba3 = tinycolor(range[i2]).toRgb();
+              _range[i2] = [rgba3.r, rgba3.g, rgba3.b, rgba3.a];
+            }
+            var _sclFunc = d3.scale.linear().domain(domain).range(_range).clamp(true);
+            var noNumericCheck = opts.noNumericCheck;
+            var returnArray = opts.returnArray;
+            var sclFunc;
+            if (noNumericCheck && returnArray) {
+              sclFunc = _sclFunc;
+            } else if (noNumericCheck) {
+              sclFunc = function(v2) {
+                return colorArray2rbga(_sclFunc(v2));
+              };
+            } else if (returnArray) {
+              sclFunc = function(v2) {
+                if (isNumeric(v2)) return _sclFunc(v2);
+                else if (tinycolor(v2).isValid()) return v2;
+                else return Color2.defaultLine;
+              };
+            } else {
+              sclFunc = function(v2) {
+                if (isNumeric(v2)) return colorArray2rbga(_sclFunc(v2));
+                else if (tinycolor(v2).isValid()) return v2;
+                else return Color2.defaultLine;
+              };
+            }
+            sclFunc.domain = _sclFunc.domain;
+            sclFunc.range = function() {
+              return range;
+            };
+            return sclFunc;
+          }
+          function makeColorScaleFuncFromTrace(trace, opts) {
+            return makeColorScaleFunc(extractScale(trace), opts);
+          }
+          function colorArray2rbga(colorArray) {
+            var colorObj = {
+              r: colorArray[0],
+              g: colorArray[1],
+              b: colorArray[2],
+              a: colorArray[3]
+            };
+            return tinycolor(colorObj).toRgbString();
+          }
+          module2.exports = {
+            hasColorscale,
+            extractOpts,
+            extractScale,
+            flipScale,
+            makeColorScaleFunc,
+            makeColorScaleFuncFromTrace
+          };
+        }
+      });
+      var require_axis_format_attributes = __commonJS({
+        "src/plots/cartesian/axis_format_attributes.js"(exports, module2) {
+          var docs = require_docs();
+          var FORMAT_LINK = docs.FORMAT_LINK;
+          var DATE_FORMAT_LINK = docs.DATE_FORMAT_LINK;
+          function axisHoverFormat(x2, noDates) {
+            return {
+              valType: "string",
+              dflt: "",
+              editType: "none",
+              description: (noDates ? descriptionOnlyNumbers : descriptionWithDates)("hover text", x2) + [
+                "By default the values are formatted using " + (noDates ? "generic number format" : "`" + x2 + "axis.hoverformat`") + "."
+              ].join(" ")
+            };
+          }
+          function descriptionOnlyNumbers(label, x2) {
+            return [
+              "Sets the " + label + " formatting rule" + (x2 ? "for `" + x2 + "` " : ""),
+              "using d3 formatting mini-languages",
+              "which are very similar to those in Python. For numbers, see: " + FORMAT_LINK + "."
+            ].join(" ");
+          }
+          function descriptionWithDates(label, x2) {
+            return descriptionOnlyNumbers(label, x2) + [
+              " And for dates see: " + DATE_FORMAT_LINK + ".",
+              "We add two items to d3's date formatter:",
+              "*%h* for half of the year as a decimal number as well as",
+              "*%{n}f* for fractional seconds",
+              "with n digits. For example, *2016-10-13 09:15:23.456* with tickformat",
+              "*%H~%M~%S.%2f* would display *09~15~23.46*"
+            ].join(" ");
+          }
+          module2.exports = {
+            axisHoverFormat,
+            descriptionOnlyNumbers,
+            descriptionWithDates
+          };
+        }
+      });
+      var require_layout_attributes4 = __commonJS({
+        "src/plots/cartesian/layout_attributes.js"(exports, module2) {
+          var fontAttrs = require_font_attributes();
+          var colorAttrs = require_attributes3();
+          var dash = require_attributes4().dash;
+          var extendFlat = require_extend().extendFlat;
+          var templatedArray = require_plot_template().templatedArray;
+          require_template_attributes().templateFormatStringDescription;
+          var descriptionWithDates = require_axis_format_attributes().descriptionWithDates;
+          var ONEDAY = require_numerical().ONEDAY;
+          var constants = require_constants2();
+          var HOUR = constants.HOUR_PATTERN;
+          var DAY_OF_WEEK = constants.WEEKDAY_PATTERN;
+          var minorTickmode = {
+            valType: "enumerated",
+            values: ["auto", "linear", "array"],
+            editType: "ticks",
+            impliedEdits: { tick0: void 0, dtick: void 0 }
+          };
+          var tickmode = extendFlat({}, minorTickmode, {
+            values: minorTickmode.values.slice().concat(["sync"])
+          });
+          function makeNticks(minor) {
+            return {
+              valType: "integer",
+              min: 0,
+              dflt: minor ? 5 : 0,
+              editType: "ticks"
+            };
+          }
+          var tick0 = {
+            valType: "any",
+            editType: "ticks",
+            impliedEdits: { tickmode: "linear" }
+          };
+          var dtick = {
+            valType: "any",
+            editType: "ticks",
+            impliedEdits: { tickmode: "linear" }
+          };
+          var tickvals = {
+            valType: "data_array",
+            editType: "ticks"
+          };
+          var ticks = {
+            valType: "enumerated",
+            values: ["outside", "inside", ""],
+            editType: "ticks"
+          };
+          function makeTicklen(minor) {
+            var obj = {
+              valType: "number",
+              min: 0,
+              editType: "ticks"
+            };
+            if (!minor) obj.dflt = 5;
+            return obj;
+          }
+          function makeTickwidth(minor) {
+            var obj = {
+              valType: "number",
+              min: 0,
+              editType: "ticks"
+            };
+            if (!minor) obj.dflt = 1;
+            return obj;
+          }
+          var tickcolor = {
+            valType: "color",
+            dflt: colorAttrs.defaultLine,
+            editType: "ticks"
+          };
+          var gridcolor = {
+            valType: "color",
+            dflt: colorAttrs.lightLine,
+            editType: "ticks"
+          };
+          function makeGridwidth(minor) {
+            var obj = {
+              valType: "number",
+              min: 0,
+              editType: "ticks"
+            };
+            if (!minor) obj.dflt = 1;
+            return obj;
+          }
+          var griddash = extendFlat({}, dash, { editType: "ticks" });
+          var showgrid = {
+            valType: "boolean",
+            editType: "ticks"
+          };
+          module2.exports = {
+            visible: {
+              valType: "boolean",
+              editType: "plot"
+            },
+            color: {
+              valType: "color",
+              dflt: colorAttrs.defaultLine,
+              editType: "ticks"
+            },
+            title: {
+              text: {
+                valType: "string",
+                editType: "ticks"
+              },
+              font: fontAttrs({
+                editType: "ticks"
+              }),
+              standoff: {
+                valType: "number",
+                min: 0,
+                editType: "ticks"
+              },
+              editType: "ticks"
+            },
+            type: {
+              valType: "enumerated",
+              // '-' means we haven't yet run autotype or couldn't find any data
+              // it gets turned into linear in gd._fullLayout but not copied back
+              // to gd.data like the others are.
+              values: ["-", "linear", "log", "date", "category", "multicategory"],
+              dflt: "-",
+              editType: "calc",
+              // we forget when an axis has been autotyped, just writing the auto
+              // value back to the input - so it doesn't make sense to template this.
+              // Note: we do NOT prohibit this in `coerce`, so if someone enters a
+              // type in the template explicitly it will be honored as the default.
+              _noTemplating: true
+            },
+            autotypenumbers: {
+              valType: "enumerated",
+              values: ["convert types", "strict"],
+              dflt: "convert types",
+              editType: "calc"
+            },
+            autorange: {
+              valType: "enumerated",
+              values: [true, false, "reversed", "min reversed", "max reversed", "min", "max"],
+              dflt: true,
+              editType: "axrange",
+              impliedEdits: { "range[0]": void 0, "range[1]": void 0 }
+            },
+            autorangeoptions: {
+              minallowed: {
+                valType: "any",
+                editType: "plot",
+                impliedEdits: { "range[0]": void 0, "range[1]": void 0 }
+              },
+              maxallowed: {
+                valType: "any",
+                editType: "plot",
+                impliedEdits: { "range[0]": void 0, "range[1]": void 0 }
+              },
+              clipmin: {
+                valType: "any",
+                editType: "plot",
+                impliedEdits: { "range[0]": void 0, "range[1]": void 0 }
+              },
+              clipmax: {
+                valType: "any",
+                editType: "plot",
+                impliedEdits: { "range[0]": void 0, "range[1]": void 0 }
+              },
+              include: {
+                valType: "any",
+                arrayOk: true,
+                editType: "plot",
+                impliedEdits: { "range[0]": void 0, "range[1]": void 0 }
+              },
+              editType: "plot"
+            },
+            rangemode: {
+              valType: "enumerated",
+              values: ["normal", "tozero", "nonnegative"],
+              dflt: "normal",
+              editType: "plot"
+            },
+            range: {
+              valType: "info_array",
+              items: [
+                { valType: "any", editType: "axrange", impliedEdits: { "^autorange": false }, anim: true },
+                { valType: "any", editType: "axrange", impliedEdits: { "^autorange": false }, anim: true }
+              ],
+              editType: "axrange",
+              impliedEdits: { autorange: false },
+              anim: true
+            },
+            minallowed: {
+              valType: "any",
+              editType: "plot",
+              impliedEdits: { "^autorange": false }
+            },
+            maxallowed: {
+              valType: "any",
+              editType: "plot",
+              impliedEdits: { "^autorange": false }
+            },
+            fixedrange: {
+              valType: "boolean",
+              dflt: false,
+              editType: "calc"
+            },
+            modebardisable: {
+              valType: "flaglist",
+              flags: ["autoscale", "zoominout"],
+              extras: ["none"],
+              dflt: "none",
+              editType: "modebar"
+            },
+            insiderange: {
+              valType: "info_array",
+              items: [
+                { valType: "any", editType: "plot" },
+                { valType: "any", editType: "plot" }
+              ],
+              editType: "plot"
+            },
+            // scaleanchor: not used directly, just put here for reference
+            // values are any opposite-letter axis id, or `false`.
+            scaleanchor: {
+              valType: "enumerated",
+              values: [
+                constants.idRegex.x.toString(),
+                constants.idRegex.y.toString(),
+                false
+              ],
+              editType: "plot"
+            },
+            scaleratio: {
+              valType: "number",
+              min: 0,
+              dflt: 1,
+              editType: "plot"
+            },
+            constrain: {
+              valType: "enumerated",
+              values: ["range", "domain"],
+              editType: "plot"
+            },
+            // constraintoward: not used directly, just put here for reference
+            constraintoward: {
+              valType: "enumerated",
+              values: ["left", "center", "right", "top", "middle", "bottom"],
+              editType: "plot"
+            },
+            matches: {
+              valType: "enumerated",
+              values: [
+                constants.idRegex.x.toString(),
+                constants.idRegex.y.toString()
+              ],
+              editType: "calc"
+            },
+            rangebreaks: templatedArray("rangebreak", {
+              enabled: {
+                valType: "boolean",
+                dflt: true,
+                editType: "calc"
+              },
+              bounds: {
+                valType: "info_array",
+                items: [
+                  { valType: "any", editType: "calc" },
+                  { valType: "any", editType: "calc" }
+                ],
+                editType: "calc"
+              },
+              pattern: {
+                valType: "enumerated",
+                values: [DAY_OF_WEEK, HOUR, ""],
+                editType: "calc"
+              },
+              values: {
+                valType: "info_array",
+                freeLength: true,
+                editType: "calc",
+                items: {
+                  valType: "any",
+                  editType: "calc"
+                }
+              },
+              dvalue: {
+                // TODO could become 'any' to add support for 'months', 'years'
+                valType: "number",
+                editType: "calc",
+                min: 0,
+                dflt: ONEDAY
+              },
+              /*
+              gap: {
+                  valType: 'number',
+                  min: 0,
+                  dflt: 0, // for *date* axes, maybe something else for *linear*
+                  editType: 'calc',
+              },
+              gapmode: {
+                  valType: 'enumerated',
+                  values: ['pixels', 'fraction'],
+                  dflt: 'pixels',
+                  editType: 'calc',
+              },
+              */
+              // To complete https://github.com/plotly/plotly.js/issues/4210
+              // we additionally need `gap` and make this work on *linear*, and
+              // possibly all other cartesian axis types. We possibly would also need
+              // some style attributes controlling the zig-zag on the corresponding
+              // axis.
+              editType: "calc"
+            }),
+            // ticks
+            tickmode,
+            nticks: makeNticks(),
+            tick0,
+            dtick,
+            ticklabelstep: {
+              valType: "integer",
+              min: 1,
+              dflt: 1,
+              editType: "ticks"
+            },
+            tickvals,
+            ticktext: {
+              valType: "data_array",
+              editType: "ticks"
+            },
+            ticks,
+            tickson: {
+              valType: "enumerated",
+              values: ["labels", "boundaries"],
+              dflt: "labels",
+              editType: "ticks"
+            },
+            ticklabelmode: {
+              valType: "enumerated",
+              values: ["instant", "period"],
+              dflt: "instant",
+              editType: "ticks"
+            },
+            // ticklabelposition: not used directly, as values depend on direction (similar to side)
+            // left/right options are for x axes, and top/bottom options are for y axes
+            ticklabelposition: {
+              valType: "enumerated",
+              values: [
+                "outside",
+                "inside",
+                "outside top",
+                "inside top",
+                "outside left",
+                "inside left",
+                "outside right",
+                "inside right",
+                "outside bottom",
+                "inside bottom"
+              ],
+              dflt: "outside",
+              editType: "calc"
+            },
+            ticklabeloverflow: {
+              valType: "enumerated",
+              values: [
+                "allow",
+                "hide past div",
+                "hide past domain"
+              ],
+              editType: "calc"
+            },
+            ticklabelshift: {
+              valType: "integer",
+              dflt: 0,
+              editType: "ticks"
+            },
+            ticklabelstandoff: {
+              valType: "integer",
+              dflt: 0,
+              editType: "ticks"
+            },
+            ticklabelindex: {
+              // in the future maybe add `extras: ['all', 'minor']` to allow showing labels for all ticks
+              // or for all minor ticks.
+              valType: "integer",
+              arrayOk: true,
+              editType: "calc"
+            },
+            mirror: {
+              valType: "enumerated",
+              values: [true, "ticks", false, "all", "allticks"],
+              dflt: false,
+              editType: "ticks+layoutstyle"
+            },
+            ticklen: makeTicklen(),
+            tickwidth: makeTickwidth(),
+            tickcolor,
+            showticklabels: {
+              valType: "boolean",
+              dflt: true,
+              editType: "ticks"
+            },
+            labelalias: {
+              valType: "any",
+              dflt: false,
+              editType: "ticks"
+            },
+            automargin: {
+              valType: "flaglist",
+              flags: ["height", "width", "left", "right", "top", "bottom"],
+              extras: [true, false],
+              dflt: false,
+              editType: "ticks"
+            },
+            showspikes: {
+              valType: "boolean",
+              dflt: false,
+              editType: "modebar"
+            },
+            spikecolor: {
+              valType: "color",
+              dflt: null,
+              editType: "none"
+            },
+            spikethickness: {
+              valType: "number",
+              dflt: 3,
+              editType: "none"
+            },
+            spikedash: extendFlat({}, dash, { dflt: "dash", editType: "none" }),
+            spikemode: {
+              valType: "flaglist",
+              flags: ["toaxis", "across", "marker"],
+              dflt: "toaxis",
+              editType: "none"
+            },
+            spikesnap: {
+              valType: "enumerated",
+              values: ["data", "cursor", "hovered data"],
+              dflt: "hovered data",
+              editType: "none"
+            },
+            tickfont: fontAttrs({
+              editType: "ticks"
+            }),
+            tickangle: {
+              valType: "angle",
+              dflt: "auto",
+              editType: "ticks"
+            },
+            autotickangles: {
+              valType: "info_array",
+              freeLength: true,
+              items: {
+                valType: "angle"
+              },
+              dflt: [0, 30, 90],
+              editType: "ticks"
+            },
+            tickprefix: {
+              valType: "string",
+              dflt: "",
+              editType: "ticks"
+            },
+            showtickprefix: {
+              valType: "enumerated",
+              values: ["all", "first", "last", "none"],
+              dflt: "all",
+              editType: "ticks"
+            },
+            ticksuffix: {
+              valType: "string",
+              dflt: "",
+              editType: "ticks"
+            },
+            showticksuffix: {
+              valType: "enumerated",
+              values: ["all", "first", "last", "none"],
+              dflt: "all",
+              editType: "ticks"
+            },
+            showexponent: {
+              valType: "enumerated",
+              values: ["all", "first", "last", "none"],
+              dflt: "all",
+              editType: "ticks"
+            },
+            exponentformat: {
+              valType: "enumerated",
+              values: ["none", "e", "E", "power", "SI", "B", "SI extended"],
+              dflt: "B",
+              editType: "ticks"
+            },
+            minexponent: {
+              valType: "number",
+              dflt: 3,
+              min: 0,
+              editType: "ticks"
+            },
+            separatethousands: {
+              valType: "boolean",
+              dflt: false,
+              editType: "ticks"
+            },
+            tickformat: {
+              valType: "string",
+              dflt: "",
+              editType: "ticks",
+              description: descriptionWithDates("tick label")
+            },
+            tickformatstops: templatedArray("tickformatstop", {
+              enabled: {
+                valType: "boolean",
+                dflt: true,
+                editType: "ticks"
+              },
+              dtickrange: {
+                valType: "info_array",
+                items: [
+                  { valType: "any", editType: "ticks" },
+                  { valType: "any", editType: "ticks" }
+                ],
+                editType: "ticks"
+              },
+              value: {
+                valType: "string",
+                dflt: "",
+                editType: "ticks"
+              },
+              editType: "ticks"
+            }),
+            hoverformat: {
+              valType: "string",
+              dflt: "",
+              editType: "none",
+              description: descriptionWithDates("hover text")
+            },
+            unifiedhovertitle: {
+              text: {
+                valType: "string",
+                dflt: "",
+                editType: "none"
+              },
+              editType: "none"
+            },
+            // lines and grids
+            showline: {
+              valType: "boolean",
+              dflt: false,
+              editType: "ticks+layoutstyle"
+            },
+            linecolor: {
+              valType: "color",
+              dflt: colorAttrs.defaultLine,
+              editType: "layoutstyle"
+            },
+            linewidth: {
+              valType: "number",
+              min: 0,
+              dflt: 1,
+              editType: "ticks+layoutstyle"
+            },
+            showgrid,
+            gridcolor,
+            gridwidth: makeGridwidth(),
+            griddash,
+            zeroline: {
+              valType: "boolean",
+              editType: "ticks"
+            },
+            zerolinecolor: {
+              valType: "color",
+              dflt: colorAttrs.defaultLine,
+              editType: "ticks"
+            },
+            zerolinelayer: {
+              valType: "enumerated",
+              values: ["above traces", "below traces"],
+              dflt: "below traces",
+              editType: "plot"
+            },
+            zerolinewidth: {
+              valType: "number",
+              dflt: 1,
+              editType: "ticks"
+            },
+            showdividers: {
+              valType: "boolean",
+              dflt: true,
+              editType: "ticks"
+            },
+            dividercolor: {
+              valType: "color",
+              dflt: colorAttrs.defaultLine,
+              editType: "ticks"
+            },
+            dividerwidth: {
+              valType: "number",
+              dflt: 1,
+              editType: "ticks"
+            },
+            // TODO dividerlen: that would override "to label base" length?
+            // positioning attributes
+            // anchor: not used directly, just put here for reference
+            // values are any opposite-letter axis id
+            anchor: {
+              valType: "enumerated",
+              values: [
+                "free",
+                constants.idRegex.x.toString(),
+                constants.idRegex.y.toString()
+              ],
+              editType: "plot"
+            },
+            // side: not used directly, as values depend on direction
+            // values are top, bottom for x axes, and left, right for y
+            side: {
+              valType: "enumerated",
+              values: ["top", "bottom", "left", "right"],
+              editType: "plot"
+            },
+            // overlaying: not used directly, just put here for reference
+            // values are false and any other same-letter axis id that's not
+            // itself overlaying anything
+            overlaying: {
+              valType: "enumerated",
+              values: [
+                "free",
+                constants.idRegex.x.toString(),
+                constants.idRegex.y.toString()
+              ],
+              editType: "plot"
+            },
+            minor: {
+              tickmode: minorTickmode,
+              nticks: makeNticks("minor"),
+              tick0,
+              dtick,
+              tickvals,
+              ticks,
+              ticklen: makeTicklen("minor"),
+              tickwidth: makeTickwidth("minor"),
+              tickcolor,
+              gridcolor,
+              gridwidth: makeGridwidth("minor"),
+              griddash,
+              showgrid,
+              editType: "ticks"
+            },
+            minorloglabels: {
+              valType: "enumerated",
+              values: ["small digits", "complete", "none"],
+              dflt: "small digits",
+              editType: "calc"
+            },
+            layer: {
+              valType: "enumerated",
+              values: ["above traces", "below traces"],
+              dflt: "above traces",
+              editType: "plot"
+            },
+            domain: {
+              valType: "info_array",
+              items: [
+                { valType: "number", min: 0, max: 1, editType: "plot" },
+                { valType: "number", min: 0, max: 1, editType: "plot" }
+              ],
+              dflt: [0, 1],
+              editType: "plot"
+            },
+            position: {
+              valType: "number",
+              min: 0,
+              max: 1,
+              dflt: 0,
+              editType: "plot"
+            },
+            autoshift: {
+              valType: "boolean",
+              dflt: false,
+              editType: "plot"
+            },
+            shift: {
+              valType: "number",
+              editType: "plot"
+            },
+            categoryorder: {
+              valType: "enumerated",
+              values: [
+                "trace",
+                "category ascending",
+                "category descending",
+                "array",
+                "total ascending",
+                "total descending",
+                "min ascending",
+                "min descending",
+                "max ascending",
+                "max descending",
+                "sum ascending",
+                "sum descending",
+                "mean ascending",
+                "mean descending",
+                "geometric mean ascending",
+                "geometric mean descending",
+                "median ascending",
+                "median descending"
+              ],
+              dflt: "trace",
+              editType: "calc"
+            },
+            categoryarray: {
+              valType: "data_array",
+              editType: "calc"
+            },
+            uirevision: {
+              valType: "any",
+              editType: "none"
+            },
+            editType: "calc"
+          };
+        }
+      });
+      var require_attributes7 = __commonJS({
+        "src/components/colorbar/attributes.js"(exports, module2) {
+          var axesAttrs = require_layout_attributes4();
+          var fontAttrs = require_font_attributes();
+          var extendFlat = require_extend().extendFlat;
+          var overrideAll = require_edit_types().overrideAll;
+          module2.exports = overrideAll({
+            orientation: {
+              valType: "enumerated",
+              values: ["h", "v"],
+              dflt: "v"
+            },
+            thicknessmode: {
+              valType: "enumerated",
+              values: ["fraction", "pixels"],
+              dflt: "pixels"
+            },
+            thickness: {
+              valType: "number",
+              min: 0,
+              dflt: 30
+            },
+            lenmode: {
+              valType: "enumerated",
+              values: ["fraction", "pixels"],
+              dflt: "fraction"
+            },
+            len: {
+              valType: "number",
+              min: 0,
+              dflt: 1
+            },
+            x: {
+              valType: "number"
+            },
+            xref: {
+              valType: "enumerated",
+              dflt: "paper",
+              values: ["container", "paper"],
+              editType: "layoutstyle"
+            },
+            xanchor: {
+              valType: "enumerated",
+              values: ["left", "center", "right"]
+            },
+            xpad: {
+              valType: "number",
+              min: 0,
+              dflt: 10
+            },
+            y: {
+              valType: "number"
+            },
+            yref: {
+              valType: "enumerated",
+              dflt: "paper",
+              values: ["container", "paper"],
+              editType: "layoutstyle"
+            },
+            yanchor: {
+              valType: "enumerated",
+              values: ["top", "middle", "bottom"]
+            },
+            ypad: {
+              valType: "number",
+              min: 0,
+              dflt: 10
+            },
+            // a possible line around the bar itself
+            outlinecolor: axesAttrs.linecolor,
+            outlinewidth: axesAttrs.linewidth,
+            // Should outlinewidth have {dflt: 0} ?
+            // another possible line outside the padding and tick labels
+            bordercolor: axesAttrs.linecolor,
+            borderwidth: {
+              valType: "number",
+              min: 0,
+              dflt: 0
+            },
+            bgcolor: {
+              valType: "color",
+              dflt: "rgba(0,0,0,0)"
+            },
+            // tick and title properties named and function exactly as in axes
+            tickmode: axesAttrs.minor.tickmode,
+            nticks: axesAttrs.nticks,
+            tick0: axesAttrs.tick0,
+            dtick: axesAttrs.dtick,
+            tickvals: axesAttrs.tickvals,
+            ticktext: axesAttrs.ticktext,
+            ticks: extendFlat({}, axesAttrs.ticks, { dflt: "" }),
+            ticklabeloverflow: extendFlat({}, axesAttrs.ticklabeloverflow, {}),
+            // ticklabelposition: not used directly, as values depend on orientation
+            // left/right options are for x axes, and top/bottom options are for y axes
+            ticklabelposition: {
+              valType: "enumerated",
+              values: [
+                "outside",
+                "inside",
+                "outside top",
+                "inside top",
+                "outside left",
+                "inside left",
+                "outside right",
+                "inside right",
+                "outside bottom",
+                "inside bottom"
+              ],
+              dflt: "outside"
+            },
+            ticklen: axesAttrs.ticklen,
+            tickwidth: axesAttrs.tickwidth,
+            tickcolor: axesAttrs.tickcolor,
+            ticklabelstep: axesAttrs.ticklabelstep,
+            showticklabels: axesAttrs.showticklabels,
+            labelalias: axesAttrs.labelalias,
+            tickfont: fontAttrs({}),
+            tickangle: axesAttrs.tickangle,
+            tickformat: axesAttrs.tickformat,
+            tickformatstops: axesAttrs.tickformatstops,
+            tickprefix: axesAttrs.tickprefix,
+            showtickprefix: axesAttrs.showtickprefix,
+            ticksuffix: axesAttrs.ticksuffix,
+            showticksuffix: axesAttrs.showticksuffix,
+            separatethousands: axesAttrs.separatethousands,
+            exponentformat: axesAttrs.exponentformat,
+            minexponent: axesAttrs.minexponent,
+            showexponent: axesAttrs.showexponent,
+            title: {
+              text: {
+                valType: "string"
+              },
+              font: fontAttrs({}),
+              side: {
+                valType: "enumerated",
+                values: ["right", "top", "bottom"]
+              }
+            }
+          }, "colorbars", "from-root");
+        }
+      });
+      var require_attributes8 = __commonJS({
+        "src/components/colorscale/attributes.js"(exports, module2) {
+          var colorbarAttrs = require_attributes7();
+          var counterRegex = require_regex().counter;
+          var sortObjectKeys = require_sort_object_keys();
+          var palettes = require_scales().scales;
+          sortObjectKeys(palettes);
+          module2.exports = function colorScaleAttrs(context, opts) {
+            context = context || "";
+            opts = opts || {};
+            var cLetter = opts.cLetter || "c";
+            "onlyIfNumerical" in opts ? opts.onlyIfNumerical : Boolean(context);
+            var noScale = "noScale" in opts ? opts.noScale : context === "marker.line";
+            var showScaleDflt = "showScaleDflt" in opts ? opts.showScaleDflt : cLetter === "z";
+            var colorscaleDflt = typeof opts.colorscaleDflt === "string" ? palettes[opts.colorscaleDflt] : null;
+            var editTypeOverride = opts.editTypeOverride || "";
+            var colorAttr;
+            if ("colorAttr" in opts) {
+              colorAttr = opts.colorAttr;
+              opts.colorAttr;
+            } else {
+              colorAttr = { z: "z", c: "color" }[cLetter];
+            }
+            var auto = cLetter + "auto";
+            var min = cLetter + "min";
+            var max = cLetter + "max";
+            var mid = cLetter + "mid";
+            var autoImpliedEdits = {};
+            autoImpliedEdits[min] = autoImpliedEdits[max] = void 0;
+            var minmaxImpliedEdits = {};
+            minmaxImpliedEdits[auto] = false;
+            var attrs = {};
+            if (colorAttr === "color") {
+              attrs.color = {
+                valType: "color",
+                arrayOk: true,
+                editType: editTypeOverride || "style"
+              };
+              if (opts.anim) {
+                attrs.color.anim = true;
+              }
+            }
+            attrs[auto] = {
+              valType: "boolean",
+              dflt: true,
+              editType: "calc",
+              impliedEdits: autoImpliedEdits
+            };
+            attrs[min] = {
+              valType: "number",
+              dflt: null,
+              editType: editTypeOverride || "plot",
+              impliedEdits: minmaxImpliedEdits
+            };
+            attrs[max] = {
+              valType: "number",
+              dflt: null,
+              editType: editTypeOverride || "plot",
+              impliedEdits: minmaxImpliedEdits
+            };
+            attrs[mid] = {
+              valType: "number",
+              dflt: null,
+              editType: "calc",
+              impliedEdits: autoImpliedEdits
+            };
+            attrs.colorscale = {
+              valType: "colorscale",
+              editType: "calc",
+              dflt: colorscaleDflt,
+              impliedEdits: { autocolorscale: false }
+            };
+            attrs.autocolorscale = {
+              valType: "boolean",
+              // gets overrode in 'heatmap' & 'surface' for backwards comp.
+              dflt: opts.autoColorDflt === false ? false : true,
+              editType: "calc",
+              impliedEdits: { colorscale: void 0 }
+            };
+            attrs.reversescale = {
+              valType: "boolean",
+              dflt: false,
+              editType: "plot"
+            };
+            if (!noScale) {
+              attrs.showscale = {
+                valType: "boolean",
+                dflt: showScaleDflt,
+                editType: "calc"
+              };
+              attrs.colorbar = colorbarAttrs;
+            }
+            if (!opts.noColorAxis) {
+              attrs.coloraxis = {
+                valType: "subplotid",
+                regex: counterRegex("coloraxis"),
+                dflt: null,
+                editType: "calc"
+              };
+            }
+            return attrs;
+          };
+        }
+      });
+      var require_layout_attributes5 = __commonJS({
+        "src/components/colorscale/layout_attributes.js"(exports, module2) {
+          var extendFlat = require_extend().extendFlat;
+          var colorScaleAttrs = require_attributes8();
+          var scales = require_scales().scales;
+          module2.exports = {
+            editType: "calc",
+            colorscale: {
+              editType: "calc",
+              sequential: {
+                valType: "colorscale",
+                dflt: scales.Reds,
+                editType: "calc"
+              },
+              sequentialminus: {
+                valType: "colorscale",
+                dflt: scales.Blues,
+                editType: "calc"
+              },
+              diverging: {
+                valType: "colorscale",
+                dflt: scales.RdBu,
+                editType: "calc"
+              }
+            },
+            coloraxis: extendFlat({
+              // not really a 'subplot' attribute container,
+              // but this is the flag we use to denote attributes that
+              // support yaxis, yaxis2, yaxis3, ... counters
+              _isSubplotObj: true,
+              editType: "calc"
+            }, colorScaleAttrs("", {
+              colorAttr: "corresponding trace color array(s)",
+              noColorAxis: true,
+              showScaleDflt: true
+            }))
+          };
+        }
+      });
+      var require_has_colorbar = __commonJS({
+        "src/components/colorbar/has_colorbar.js"(exports, module2) {
+          var Lib = require_lib();
+          module2.exports = function hasColorbar(container) {
+            return Lib.isPlainObject(container.colorbar);
+          };
+        }
+      });
+      var require_clean_ticks = __commonJS({
+        "src/plots/cartesian/clean_ticks.js"(exports) {
+          var isNumeric = require_fast_isnumeric();
+          var Lib = require_lib();
+          var constants = require_numerical();
+          var ONEDAY = constants.ONEDAY;
+          var ONEWEEK = constants.ONEWEEK;
+          exports.dtick = function(dtick, axType) {
+            var isLog = axType === "log";
+            var isDate = axType === "date";
+            var isCat = axType === "category";
+            var dtickDflt = isDate ? ONEDAY : 1;
+            if (!dtick) return dtickDflt;
+            if (isNumeric(dtick)) {
+              dtick = Number(dtick);
+              if (dtick <= 0) return dtickDflt;
+              if (isCat) {
+                return Math.max(1, Math.round(dtick));
+              }
+              if (isDate) {
+                return Math.max(0.1, dtick);
+              }
+              return dtick;
+            }
+            if (typeof dtick !== "string" || !(isDate || isLog)) {
+              return dtickDflt;
+            }
+            var prefix = dtick.charAt(0);
+            var dtickNum = dtick.slice(1);
+            dtickNum = isNumeric(dtickNum) ? Number(dtickNum) : 0;
+            if (dtickNum <= 0 || !// "M<n>" gives ticks every (integer) n months
+            (isDate && prefix === "M" && dtickNum === Math.round(dtickNum) || // "L<f>" gives ticks linearly spaced in data (not in position) every (float) f
+            isLog && prefix === "L" || // "D1" gives powers of 10 with all small digits between, "D2" gives only 2 and 5
+            isLog && prefix === "D" && (dtickNum === 1 || dtickNum === 2))) {
+              return dtickDflt;
+            }
+            return dtick;
+          };
+          exports.tick0 = function(tick0, axType, calendar, dtick) {
+            if (axType === "date") {
+              return Lib.cleanDate(
+                tick0,
+                Lib.dateTick0(calendar, dtick % ONEWEEK === 0 ? 1 : 0)
+              );
+            }
+            if (dtick === "D1" || dtick === "D2") {
+              return void 0;
+            }
+            return isNumeric(tick0) ? Number(tick0) : 0;
+          };
+        }
+      });
+      var require_tick_value_defaults = __commonJS({
+        "src/plots/cartesian/tick_value_defaults.js"(exports, module2) {
+          var cleanTicks = require_clean_ticks();
+          var isArrayOrTypedArray = require_lib().isArrayOrTypedArray;
+          var isTypedArraySpec = require_array().isTypedArraySpec;
+          var decodeTypedArraySpec = require_array().decodeTypedArraySpec;
+          module2.exports = function handleTickValueDefaults(containerIn, containerOut, coerce, axType, opts) {
+            if (!opts) opts = {};
+            var isMinor = opts.isMinor;
+            var cIn = isMinor ? containerIn.minor || {} : containerIn;
+            var cOut = isMinor ? containerOut.minor : containerOut;
+            var prefix = isMinor ? "minor." : "";
+            function readInput(attr) {
+              var v2 = cIn[attr];
+              if (isTypedArraySpec(v2)) v2 = decodeTypedArraySpec(v2);
+              return v2 !== void 0 ? v2 : (cOut._template || {})[attr];
+            }
+            var _tick0 = readInput("tick0");
+            var _dtick = readInput("dtick");
+            var _tickvals = readInput("tickvals");
+            var tickmodeDefault = isArrayOrTypedArray(_tickvals) ? "array" : _dtick ? "linear" : "auto";
+            var tickmode = coerce(prefix + "tickmode", tickmodeDefault);
+            if (tickmode === "auto" || tickmode === "sync") {
+              coerce(prefix + "nticks");
+            } else if (tickmode === "linear") {
+              var dtick = cOut.dtick = cleanTicks.dtick(
+                _dtick,
+                axType
+              );
+              cOut.tick0 = cleanTicks.tick0(
+                _tick0,
+                axType,
+                containerOut.calendar,
+                dtick
+              );
+            } else if (axType !== "multicategory") {
+              var tickvals = coerce(prefix + "tickvals");
+              if (tickvals === void 0) cOut.tickmode = "auto";
+              else if (!isMinor) coerce("ticktext");
+            }
+          };
+        }
+      });
+      var require_tick_mark_defaults = __commonJS({
+        "src/plots/cartesian/tick_mark_defaults.js"(exports, module2) {
+          var Lib = require_lib();
+          var layoutAttributes = require_layout_attributes4();
+          module2.exports = function handleTickMarkDefaults(containerIn, containerOut, coerce, options) {
+            var isMinor = options.isMinor;
+            var cIn = isMinor ? containerIn.minor || {} : containerIn;
+            var cOut = isMinor ? containerOut.minor : containerOut;
+            var lAttr = isMinor ? layoutAttributes.minor : layoutAttributes;
+            var prefix = isMinor ? "minor." : "";
+            var tickLen = Lib.coerce2(cIn, cOut, lAttr, "ticklen", isMinor ? (containerOut.ticklen || 5) * 0.6 : void 0);
+            var tickWidth = Lib.coerce2(cIn, cOut, lAttr, "tickwidth", isMinor ? containerOut.tickwidth || 1 : void 0);
+            var tickColor = Lib.coerce2(cIn, cOut, lAttr, "tickcolor", (isMinor ? containerOut.tickcolor : void 0) || cOut.color);
+            var showTicks = coerce(prefix + "ticks", !isMinor && options.outerTicks || tickLen || tickWidth || tickColor ? "outside" : "");
+            if (!showTicks) {
+              delete cOut.ticklen;
+              delete cOut.tickwidth;
+              delete cOut.tickcolor;
+            }
+          };
+        }
+      });
+      var require_show_dflt = __commonJS({
+        "src/plots/cartesian/show_dflt.js"(exports, module2) {
+          module2.exports = function getShowAttrDflt(containerIn) {
+            var showAttrsAll = ["showexponent", "showtickprefix", "showticksuffix"];
+            var showAttrs = showAttrsAll.filter(function(a2) {
+              return containerIn[a2] !== void 0;
+            });
+            var sameVal = function(a2) {
+              return containerIn[a2] === containerIn[showAttrs[0]];
+            };
+            if (showAttrs.every(sameVal) || showAttrs.length === 1) {
+              return containerIn[showAttrs[0]];
+            }
+          };
+        }
+      });
+      var require_array_container_defaults = __commonJS({
+        "src/plots/array_container_defaults.js"(exports, module2) {
+          var Lib = require_lib();
+          var Template = require_plot_template();
+          module2.exports = function handleArrayContainerDefaults(parentObjIn, parentObjOut, opts) {
+            var name2 = opts.name;
+            var inclusionAttr = opts.inclusionAttr || "visible";
+            var previousContOut = parentObjOut[name2];
+            var contIn = Lib.isArrayOrTypedArray(parentObjIn[name2]) ? parentObjIn[name2] : [];
+            var contOut = parentObjOut[name2] = [];
+            var templater = Template.arrayTemplater(parentObjOut, name2, inclusionAttr);
+            var i2, itemOut;
+            for (i2 = 0; i2 < contIn.length; i2++) {
+              var itemIn = contIn[i2];
+              if (!Lib.isPlainObject(itemIn)) {
+                itemOut = templater.newItem({});
+                itemOut[inclusionAttr] = false;
+              } else {
+                itemOut = templater.newItem(itemIn);
+              }
+              itemOut._index = i2;
+              if (itemOut[inclusionAttr] !== false) {
+                opts.handleItemDefaults(itemIn, itemOut, parentObjOut, opts);
+              }
+              contOut.push(itemOut);
+            }
+            var defaultItems = templater.defaultItems();
+            for (i2 = 0; i2 < defaultItems.length; i2++) {
+              itemOut = defaultItems[i2];
+              itemOut._index = contOut.length;
+              opts.handleItemDefaults({}, itemOut, parentObjOut, opts, {});
+              contOut.push(itemOut);
+            }
+            if (Lib.isArrayOrTypedArray(previousContOut)) {
+              var len2 = Math.min(previousContOut.length, contOut.length);
+              for (i2 = 0; i2 < len2; i2++) {
+                Lib.relinkPrivateKeys(contOut[i2], previousContOut[i2]);
+              }
+            }
+            return contOut;
+          };
+        }
+      });
+      var require_tick_label_defaults = __commonJS({
+        "src/plots/cartesian/tick_label_defaults.js"(exports, module2) {
+          var Lib = require_lib();
+          var contrast = require_color().contrast;
+          var layoutAttributes = require_layout_attributes4();
+          var getShowAttrDflt = require_show_dflt();
+          var handleArrayContainerDefaults = require_array_container_defaults();
+          module2.exports = function handleTickLabelDefaults(containerIn, containerOut, coerce, axType, options) {
+            if (!options) options = {};
+            var labelalias = coerce("labelalias");
+            if (!Lib.isPlainObject(labelalias)) delete containerOut.labelalias;
+            var showAttrDflt = getShowAttrDflt(containerIn);
+            var showTickLabels = coerce("showticklabels");
+            if (showTickLabels) {
+              if (!options.noTicklabelshift) {
+                coerce("ticklabelshift");
+              }
+              if (!options.noTicklabelstandoff) {
+                coerce("ticklabelstandoff");
+              }
+              var font = options.font || {};
+              var contColor = containerOut.color;
+              var position = containerOut.ticklabelposition || "";
+              var dfltFontColor = position.indexOf("inside") !== -1 ? contrast(options.bgColor) : (
+                // as with title.font.color, inherit axis.color only if one was
+                // explicitly provided
+                contColor && contColor !== layoutAttributes.color.dflt ? contColor : font.color
+              );
+              Lib.coerceFont(coerce, "tickfont", font, { overrideDflt: {
+                color: dfltFontColor
+              } });
+              if (!options.noTicklabelstep && axType !== "multicategory" && axType !== "log") {
+                coerce("ticklabelstep");
+              }
+              if (!options.noAng) {
+                var tickAngle = coerce("tickangle");
+                if (!options.noAutotickangles && tickAngle === "auto") {
+                  coerce("autotickangles");
+                }
+              }
+              if (axType !== "category") {
+                var tickFormat = coerce("tickformat");
+                handleArrayContainerDefaults(containerIn, containerOut, {
+                  name: "tickformatstops",
+                  inclusionAttr: "enabled",
+                  handleItemDefaults: tickformatstopDefaults
+                });
+                if (!containerOut.tickformatstops.length) {
+                  delete containerOut.tickformatstops;
+                }
+                if (!options.noExp && !tickFormat && axType !== "date") {
+                  coerce("showexponent", showAttrDflt);
+                  coerce("exponentformat");
+                  coerce("minexponent");
+                  coerce("separatethousands");
+                }
+              }
+              if (!options.noMinorloglabels && axType === "log") {
+                coerce("minorloglabels");
+              }
+            }
+          };
+          function tickformatstopDefaults(valueIn, valueOut) {
+            function coerce(attr, dflt) {
+              return Lib.coerce(valueIn, valueOut, layoutAttributes.tickformatstops, attr, dflt);
+            }
+            var enabled = coerce("enabled");
+            if (enabled) {
+              coerce("dtickrange");
+              coerce("value");
+            }
+          }
+        }
+      });
+      var require_prefix_suffix_defaults = __commonJS({
+        "src/plots/cartesian/prefix_suffix_defaults.js"(exports, module2) {
+          var getShowAttrDflt = require_show_dflt();
+          module2.exports = function handlePrefixSuffixDefaults(containerIn, containerOut, coerce, axType, options) {
+            if (!options) options = {};
+            var tickSuffixDflt = options.tickSuffixDflt;
+            var showAttrDflt = getShowAttrDflt(containerIn);
+            var tickPrefix = coerce("tickprefix");
+            if (tickPrefix) coerce("showtickprefix", showAttrDflt);
+            var tickSuffix = coerce("ticksuffix", tickSuffixDflt);
+            if (tickSuffix) coerce("showticksuffix", showAttrDflt);
+          };
+        }
+      });
+      var require_defaults = __commonJS({
+        "src/components/colorbar/defaults.js"(exports, module2) {
+          var Lib = require_lib();
+          var Template = require_plot_template();
+          var handleTickValueDefaults = require_tick_value_defaults();
+          var handleTickMarkDefaults = require_tick_mark_defaults();
+          var handleTickLabelDefaults = require_tick_label_defaults();
+          var handlePrefixSuffixDefaults = require_prefix_suffix_defaults();
+          var attributes = require_attributes7();
+          module2.exports = function colorbarDefaults(containerIn, containerOut, layout) {
+            var colorbarOut = Template.newContainer(containerOut, "colorbar");
+            var colorbarIn = containerIn.colorbar || {};
+            function coerce(attr, dflt) {
+              return Lib.coerce(colorbarIn, colorbarOut, attributes, attr, dflt);
+            }
+            var margin = layout.margin || { t: 0, b: 0, l: 0, r: 0 };
+            var w2 = layout.width - margin.l - margin.r;
+            var h2 = layout.height - margin.t - margin.b;
+            var orientation = coerce("orientation");
+            var isVertical = orientation === "v";
+            var thicknessmode = coerce("thicknessmode");
+            coerce(
+              "thickness",
+              thicknessmode === "fraction" ? 30 / (isVertical ? w2 : h2) : 30
+            );
+            var lenmode = coerce("lenmode");
+            coerce(
+              "len",
+              lenmode === "fraction" ? 1 : isVertical ? h2 : w2
+            );
+            var yref = coerce("yref");
+            var xref = coerce("xref");
+            var isPaperY = yref === "paper";
+            var isPaperX = xref === "paper";
+            var defaultX, defaultY, defaultYAnchor;
+            var defaultXAnchor = "left";
+            if (isVertical) {
+              defaultYAnchor = "middle";
+              defaultXAnchor = isPaperX ? "left" : "right";
+              defaultX = isPaperX ? 1.02 : 1;
+              defaultY = 0.5;
+            } else {
+              defaultYAnchor = isPaperY ? "bottom" : "top";
+              defaultXAnchor = "center";
+              defaultX = 0.5;
+              defaultY = isPaperY ? 1.02 : 1;
+            }
+            Lib.coerce(colorbarIn, colorbarOut, {
+              x: {
+                valType: "number",
+                min: isPaperX ? -2 : 0,
+                max: isPaperX ? 3 : 1,
+                dflt: defaultX
+              }
+            }, "x");
+            Lib.coerce(colorbarIn, colorbarOut, {
+              y: {
+                valType: "number",
+                min: isPaperY ? -2 : 0,
+                max: isPaperY ? 3 : 1,
+                dflt: defaultY
+              }
+            }, "y");
+            coerce("xanchor", defaultXAnchor);
+            coerce("xpad");
+            coerce("yanchor", defaultYAnchor);
+            coerce("ypad");
+            Lib.noneOrAll(colorbarIn, colorbarOut, ["x", "y"]);
+            coerce("outlinecolor");
+            coerce("outlinewidth");
+            coerce("bordercolor");
+            coerce("borderwidth");
+            coerce("bgcolor");
+            var ticklabelposition = Lib.coerce(colorbarIn, colorbarOut, {
+              ticklabelposition: {
+                valType: "enumerated",
+                dflt: "outside",
+                values: isVertical ? [
+                  "outside",
+                  "inside",
+                  "outside top",
+                  "inside top",
+                  "outside bottom",
+                  "inside bottom"
+                ] : [
+                  "outside",
+                  "inside",
+                  "outside left",
+                  "inside left",
+                  "outside right",
+                  "inside right"
+                ]
+              }
+            }, "ticklabelposition");
+            coerce("ticklabeloverflow", ticklabelposition.indexOf("inside") !== -1 ? "hide past domain" : "hide past div");
+            handleTickValueDefaults(colorbarIn, colorbarOut, coerce, "linear");
+            var font = layout.font;
+            var opts = {
+              noAutotickangles: true,
+              noTicklabelshift: true,
+              noTicklabelstandoff: true,
+              outerTicks: false,
+              font
+            };
+            if (ticklabelposition.indexOf("inside") !== -1) {
+              opts.bgColor = "black";
+            }
+            handlePrefixSuffixDefaults(colorbarIn, colorbarOut, coerce, "linear", opts);
+            handleTickLabelDefaults(colorbarIn, colorbarOut, coerce, "linear", opts);
+            handleTickMarkDefaults(colorbarIn, colorbarOut, coerce, "linear", opts);
+            coerce("title.text", layout._dfltTitle.colorbar);
+            var tickFont = colorbarOut.showticklabels ? colorbarOut.tickfont : font;
+            var dfltTitleFont = Lib.extendFlat({}, font, {
+              family: tickFont.family,
+              size: Lib.bigFont(tickFont.size)
+            });
+            Lib.coerceFont(coerce, "title.font", dfltTitleFont);
+            coerce("title.side", isVertical ? "top" : "right");
+          };
+        }
+      });
+      var require_defaults2 = __commonJS({
+        "src/components/colorscale/defaults.js"(exports, module2) {
+          var isNumeric = require_fast_isnumeric();
+          var Lib = require_lib();
+          var hasColorbar = require_has_colorbar();
+          var colorbarDefaults = require_defaults();
+          var isValidScale = require_scales().isValid;
+          var traceIs = require_registry().traceIs;
+          function npMaybe(parentCont, prefix) {
+            var containerStr = prefix.slice(0, prefix.length - 1);
+            return prefix ? Lib.nestedProperty(parentCont, containerStr).get() || {} : parentCont;
+          }
+          module2.exports = function colorScaleDefaults(parentContIn, parentContOut, layout, coerce, opts) {
+            var prefix = opts.prefix;
+            var cLetter = opts.cLetter;
+            var inTrace = "_module" in parentContOut;
+            var containerIn = npMaybe(parentContIn, prefix);
+            var containerOut = npMaybe(parentContOut, prefix);
+            var template = npMaybe(parentContOut._template || {}, prefix) || {};
+            var thisFn = function() {
+              delete parentContIn.coloraxis;
+              delete parentContOut.coloraxis;
+              return colorScaleDefaults(parentContIn, parentContOut, layout, coerce, opts);
+            };
+            if (inTrace) {
+              var colorAxes = layout._colorAxes || {};
+              var colorAx = coerce(prefix + "coloraxis");
+              if (colorAx) {
+                var colorbarVisuals = traceIs(parentContOut, "contour") && Lib.nestedProperty(parentContOut, "contours.coloring").get() || "heatmap";
+                var stash = colorAxes[colorAx];
+                if (stash) {
+                  stash[2].push(thisFn);
+                  if (stash[0] !== colorbarVisuals) {
+                    stash[0] = false;
+                    Lib.warn([
+                      "Ignoring coloraxis:",
+                      colorAx,
+                      "setting",
+                      "as it is linked to incompatible colorscales."
+                    ].join(" "));
+                  }
+                } else {
+                  colorAxes[colorAx] = [colorbarVisuals, parentContOut, [thisFn]];
+                }
+                return;
+              }
+            }
+            var minIn = containerIn[cLetter + "min"];
+            var maxIn = containerIn[cLetter + "max"];
+            var validMinMax = isNumeric(minIn) && isNumeric(maxIn) && minIn < maxIn;
+            var auto = coerce(prefix + cLetter + "auto", !validMinMax);
+            if (auto) {
+              coerce(prefix + cLetter + "mid");
+            } else {
+              coerce(prefix + cLetter + "min");
+              coerce(prefix + cLetter + "max");
+            }
+            var sclIn = containerIn.colorscale;
+            var sclTemplate = template.colorscale;
+            var autoColorscaleDflt;
+            if (sclIn !== void 0) autoColorscaleDflt = !isValidScale(sclIn);
+            if (sclTemplate !== void 0) autoColorscaleDflt = !isValidScale(sclTemplate);
+            coerce(prefix + "autocolorscale", autoColorscaleDflt);
+            coerce(prefix + "colorscale");
+            coerce(prefix + "reversescale");
+            if (prefix !== "marker.line.") {
+              var showScaleDflt;
+              if (prefix && inTrace) showScaleDflt = hasColorbar(containerIn);
+              var showScale = coerce(prefix + "showscale", showScaleDflt);
+              if (showScale) {
+                if (prefix && template) containerOut._template = template;
+                colorbarDefaults(containerIn, containerOut, layout);
+              }
+            }
+          };
+        }
+      });
+      var require_layout_defaults = __commonJS({
+        "src/components/colorscale/layout_defaults.js"(exports, module2) {
+          var Lib = require_lib();
+          var Template = require_plot_template();
+          var colorScaleAttrs = require_layout_attributes5();
+          var colorScaleDefaults = require_defaults2();
+          module2.exports = function supplyLayoutDefaults(layoutIn, layoutOut) {
+            function coerce(attr, dflt) {
+              return Lib.coerce(layoutIn, layoutOut, colorScaleAttrs, attr, dflt);
+            }
+            coerce("colorscale.sequential");
+            coerce("colorscale.sequentialminus");
+            coerce("colorscale.diverging");
+            var colorAxes = layoutOut._colorAxes;
+            var colorAxIn, colorAxOut;
+            function coerceAx(attr, dflt) {
+              return Lib.coerce(colorAxIn, colorAxOut, colorScaleAttrs.coloraxis, attr, dflt);
+            }
+            for (var k2 in colorAxes) {
+              var stash = colorAxes[k2];
+              if (stash[0]) {
+                colorAxIn = layoutIn[k2] || {};
+                colorAxOut = Template.newContainer(layoutOut, k2, "coloraxis");
+                colorAxOut._name = k2;
+                colorScaleDefaults(colorAxIn, colorAxOut, layoutOut, coerceAx, { prefix: "", cLetter: "c" });
+              } else {
+                for (var i2 = 0; i2 < stash[2].length; i2++) {
+                  stash[2][i2]();
+                }
+                delete layoutOut._colorAxes[k2];
+              }
+            }
+          };
+        }
+      });
+      var require_cross_trace_defaults = __commonJS({
+        "src/components/colorscale/cross_trace_defaults.js"(exports, module2) {
+          var Lib = require_lib();
+          var hasColorscale = require_helpers().hasColorscale;
+          var extractOpts = require_helpers().extractOpts;
+          module2.exports = function crossTraceDefaults(fullData, fullLayout) {
+            function replace(cont, k22) {
+              var val = cont["_" + k22];
+              if (val !== void 0) {
+                cont[k22] = val;
+              }
+            }
+            function relinkColorAttrs(outerCont, cbOpt) {
+              var cont = cbOpt.container ? Lib.nestedProperty(outerCont, cbOpt.container).get() : outerCont;
+              if (cont) {
+                if (cont.coloraxis) {
+                  cont._colorAx = fullLayout[cont.coloraxis];
+                } else {
+                  var cOpts = extractOpts(cont);
+                  var isAuto = cOpts.auto;
+                  if (isAuto || cOpts.min === void 0) {
+                    replace(cont, cbOpt.min);
+                  }
+                  if (isAuto || cOpts.max === void 0) {
+                    replace(cont, cbOpt.max);
+                  }
+                  if (cOpts.autocolorscale) {
+                    replace(cont, "colorscale");
+                  }
+                }
+              }
+            }
+            for (var i2 = 0; i2 < fullData.length; i2++) {
+              var trace = fullData[i2];
+              var cbOpts = trace._module.colorbar;
+              if (cbOpts) {
+                if (Array.isArray(cbOpts)) {
+                  for (var j2 = 0; j2 < cbOpts.length; j2++) {
+                    relinkColorAttrs(trace, cbOpts[j2]);
+                  }
+                } else {
+                  relinkColorAttrs(trace, cbOpts);
+                }
+              }
+              if (hasColorscale(trace, "marker.line")) {
+                relinkColorAttrs(trace, {
+                  container: "marker.line",
+                  min: "cmin",
+                  max: "cmax"
+                });
+              }
+            }
+            for (var k2 in fullLayout._colorAxes) {
+              relinkColorAttrs(fullLayout[k2], { min: "cmin", max: "cmax" });
+            }
+          };
+        }
+      });
+      var require_calc = __commonJS({
+        "src/components/colorscale/calc.js"(exports, module2) {
+          var isNumeric = require_fast_isnumeric();
+          var Lib = require_lib();
+          var extractOpts = require_helpers().extractOpts;
+          module2.exports = function calc(gd2, trace, opts) {
+            var fullLayout = gd2._fullLayout;
+            var vals = opts.vals;
+            var containerStr = opts.containerStr;
+            var container = containerStr ? Lib.nestedProperty(trace, containerStr).get() : trace;
+            var cOpts = extractOpts(container);
+            var auto = cOpts.auto !== false;
+            var min = cOpts.min;
+            var max = cOpts.max;
+            var mid = cOpts.mid;
+            var minVal = function() {
+              return Lib.aggNums(Math.min, null, vals);
+            };
+            var maxVal = function() {
+              return Lib.aggNums(Math.max, null, vals);
+            };
+            if (min === void 0) {
+              min = minVal();
+            } else if (auto) {
+              if (container._colorAx && isNumeric(min)) {
+                min = Math.min(min, minVal());
+              } else {
+                min = minVal();
+              }
+            }
+            if (max === void 0) {
+              max = maxVal();
+            } else if (auto) {
+              if (container._colorAx && isNumeric(max)) {
+                max = Math.max(max, maxVal());
+              } else {
+                max = maxVal();
+              }
+            }
+            if (auto && mid !== void 0) {
+              if (max - mid > mid - min) {
+                min = mid - (max - mid);
+              } else if (max - mid < mid - min) {
+                max = mid + (mid - min);
+              }
+            }
+            if (min === max) {
+              min -= 0.5;
+              max += 0.5;
+            }
+            cOpts._sync("min", min);
+            cOpts._sync("max", max);
+            if (cOpts.autocolorscale) {
+              var scl;
+              if (min * max < 0) scl = fullLayout.colorscale.diverging;
+              else if (min >= 0) scl = fullLayout.colorscale.sequential;
+              else scl = fullLayout.colorscale.sequentialminus;
+              cOpts._sync("colorscale", scl);
+            }
+          };
+        }
+      });
+      var require_colorscale = __commonJS({
+        "src/components/colorscale/index.js"(exports, module2) {
+          var scales = require_scales();
+          var helpers = require_helpers();
+          module2.exports = {
+            moduleType: "component",
+            name: "colorscale",
+            attributes: require_attributes8(),
+            layoutAttributes: require_layout_attributes5(),
+            supplyLayoutDefaults: require_layout_defaults(),
+            handleDefaults: require_defaults2(),
+            crossTraceDefaults: require_cross_trace_defaults(),
+            calc: require_calc(),
+            // ./scales.js is required in lib/coerce.js ;
+            // it needs to be a separate module to avoid a circular dependency
+            scales: scales.scales,
+            defaultScale: scales.defaultScale,
+            getScale: scales.get,
+            isValidScale: scales.isValid,
+            hasColorscale: helpers.hasColorscale,
+            extractOpts: helpers.extractOpts,
+            extractScale: helpers.extractScale,
+            flipScale: helpers.flipScale,
+            makeColorScaleFunc: helpers.makeColorScaleFunc,
+            makeColorScaleFuncFromTrace: helpers.makeColorScaleFuncFromTrace
+          };
+        }
+      });
+      var require_subtypes = __commonJS({
+        "src/traces/scatter/subtypes.js"(exports, module2) {
+          var Lib = require_lib();
+          var isTypedArraySpec = require_array().isTypedArraySpec;
+          module2.exports = {
+            hasLines: function(trace) {
+              return trace.visible && trace.mode && trace.mode.indexOf("lines") !== -1;
+            },
+            hasMarkers: function(trace) {
+              return trace.visible && (trace.mode && trace.mode.indexOf("markers") !== -1 || // until splom implements 'mode'
+              trace.type === "splom");
+            },
+            hasText: function(trace) {
+              return trace.visible && trace.mode && trace.mode.indexOf("text") !== -1;
+            },
+            isBubble: function(trace) {
+              var marker = trace.marker;
+              return Lib.isPlainObject(marker) && (Lib.isArrayOrTypedArray(marker.size) || isTypedArraySpec(marker.size));
+            }
+          };
+        }
+      });
+      var require_make_bubble_size_func = __commonJS({
+        "src/traces/scatter/make_bubble_size_func.js"(exports, module2) {
+          var isNumeric = require_fast_isnumeric();
+          module2.exports = function makeBubbleSizeFn(trace, factor) {
+            if (!factor) {
+              factor = 2;
+            }
+            var marker = trace.marker;
+            var sizeRef = marker.sizeref || 1;
+            var sizeMin = marker.sizemin || 0;
+            var baseFn = marker.sizemode === "area" ? function(v2) {
+              return Math.sqrt(v2 / sizeRef);
+            } : function(v2) {
+              return v2 / sizeRef;
+            };
+            return function(v2) {
+              var baseSize = baseFn(v2 / factor);
+              return isNumeric(baseSize) && baseSize > 0 ? Math.max(baseSize, sizeMin) : 0;
+            };
+          };
+        }
+      });
+      var require_helpers2 = __commonJS({
+        "src/components/fx/helpers.js"(exports) {
+          var Lib = require_lib();
+          exports.getSubplot = function(trace) {
+            return trace.subplot || trace.xaxis + trace.yaxis || trace.geo;
+          };
+          exports.isTraceInSubplots = function(trace, subplots) {
+            if (trace.type === "splom") {
+              var xaxes = trace.xaxes || [];
+              var yaxes = trace.yaxes || [];
+              for (var i2 = 0; i2 < xaxes.length; i2++) {
+                for (var j2 = 0; j2 < yaxes.length; j2++) {
+                  if (subplots.indexOf(xaxes[i2] + yaxes[j2]) !== -1) {
+                    return true;
+                  }
+                }
+              }
+              return false;
+            }
+            return subplots.indexOf(exports.getSubplot(trace)) !== -1;
+          };
+          exports.flat = function(subplots, v2) {
+            var out = new Array(subplots.length);
+            for (var i2 = 0; i2 < subplots.length; i2++) {
+              out[i2] = v2;
+            }
+            return out;
+          };
+          exports.p2c = function(axArray, v2) {
+            var out = new Array(axArray.length);
+            for (var i2 = 0; i2 < axArray.length; i2++) {
+              out[i2] = axArray[i2].p2c(v2);
+            }
+            return out;
+          };
+          exports.getDistanceFunction = function(mode, dx, dy, dxy) {
+            if (mode === "closest") return dxy || exports.quadrature(dx, dy);
+            return mode.charAt(0) === "x" ? dx : dy;
+          };
+          exports.getClosest = function(cd2, distfn, pointData) {
+            if (pointData.index !== false) {
+              if (pointData.index >= 0 && pointData.index < cd2.length) {
+                pointData.distance = 0;
+              } else pointData.index = false;
+            } else {
+              var newDistance = Infinity;
+              var len2 = cd2.length;
+              for (var i2 = 0; i2 < len2; i2++) {
+                newDistance = distfn(cd2[i2]);
+                if (newDistance <= pointData.distance) {
+                  pointData.index = i2;
+                  pointData.distance = newDistance;
+                }
+              }
+            }
+            return pointData;
+          };
+          exports.inbox = function(v0, v1, passVal) {
+            return v0 * v1 < 0 || v0 === 0 ? passVal : Infinity;
+          };
+          exports.quadrature = function(dx, dy) {
+            return function(di2) {
+              var x2 = dx(di2);
+              var y2 = dy(di2);
+              return Math.sqrt(x2 * x2 + y2 * y2);
+            };
+          };
+          exports.makeEventData = function(pt2, trace, cd2) {
+            var pointNumber = "index" in pt2 ? pt2.index : pt2.pointNumber;
+            var out = {
+              data: trace._input,
+              fullData: trace,
+              curveNumber: trace.index,
+              pointNumber
+            };
+            if (trace._indexToPoints) {
+              var pointIndices = trace._indexToPoints[pointNumber];
+              if (pointIndices.length === 1) {
+                out.pointIndex = pointIndices[0];
+              } else {
+                out.pointIndices = pointIndices;
+              }
+            } else {
+              out.pointIndex = pointNumber;
+            }
+            if (trace._module.eventData) {
+              out = trace._module.eventData(out, pt2, trace, cd2, pointNumber);
+            } else {
+              if ("xVal" in pt2) out.x = pt2.xVal;
+              else if ("x" in pt2) out.x = pt2.x;
+              if ("yVal" in pt2) out.y = pt2.yVal;
+              else if ("y" in pt2) out.y = pt2.y;
+              if (pt2.xa) out.xaxis = pt2.xa;
+              if (pt2.ya) out.yaxis = pt2.ya;
+              if (pt2.zLabelVal !== void 0) out.z = pt2.zLabelVal;
+            }
+            exports.appendArrayPointValue(out, trace, pointNumber);
+            return out;
+          };
+          exports.appendArrayPointValue = function(pointData, trace, pointNumber) {
+            var arrayAttrs = trace._arrayAttrs;
+            if (!arrayAttrs) {
+              return;
+            }
+            for (var i2 = 0; i2 < arrayAttrs.length; i2++) {
+              var astr = arrayAttrs[i2];
+              var key = getPointKey(astr);
+              if (pointData[key] === void 0) {
+                var val = Lib.nestedProperty(trace, astr).get();
+                var pointVal = getPointData(val, pointNumber);
+                if (pointVal !== void 0) pointData[key] = pointVal;
+              }
+            }
+          };
+          exports.appendArrayMultiPointValues = function(pointData, trace, pointNumbers) {
+            var arrayAttrs = trace._arrayAttrs;
+            if (!arrayAttrs) {
+              return;
+            }
+            for (var i2 = 0; i2 < arrayAttrs.length; i2++) {
+              var astr = arrayAttrs[i2];
+              var key = getPointKey(astr);
+              if (pointData[key] === void 0) {
+                var val = Lib.nestedProperty(trace, astr).get();
+                var keyVal = new Array(pointNumbers.length);
+                for (var j2 = 0; j2 < pointNumbers.length; j2++) {
+                  keyVal[j2] = getPointData(val, pointNumbers[j2]);
+                }
+                pointData[key] = keyVal;
+              }
+            }
+          };
+          var pointKeyMap = {
+            ids: "id",
+            locations: "location",
+            labels: "label",
+            values: "value",
+            "marker.colors": "color",
+            parents: "parent"
+          };
+          function getPointKey(astr) {
+            return pointKeyMap[astr] || astr;
+          }
+          function getPointData(val, pointNumber) {
+            if (Array.isArray(pointNumber)) {
+              if (Lib.isArrayOrTypedArray(val) && Lib.isArrayOrTypedArray(val[pointNumber[0]])) {
+                return val[pointNumber[0]][pointNumber[1]];
+              }
+            } else {
+              return val[pointNumber];
+            }
+          }
+          var xyHoverMode = {
+            x: true,
+            y: true
+          };
+          var unifiedHoverMode = {
+            "x unified": true,
+            "y unified": true
+          };
+          exports.isUnifiedHover = function(hovermode) {
+            if (typeof hovermode !== "string") return false;
+            return !!unifiedHoverMode[hovermode];
+          };
+          exports.isXYhover = function(hovermode) {
+            if (typeof hovermode !== "string") return false;
+            return !!xyHoverMode[hovermode];
+          };
+        }
+      });
+      var require_parse_svg_path = __commonJS({
+        "node_modules/parse-svg-path/index.js"(exports, module2) {
+          module2.exports = parse22;
+          var length2 = { a: 7, c: 6, h: 1, l: 2, m: 2, q: 4, s: 4, t: 2, v: 1, z: 0 };
+          var segment = /([astvzqmhlc])([^astvzqmhlc]*)/ig;
+          function parse22(path) {
+            var data = [];
+            path.replace(segment, function(_2, command, args) {
+              var type = command.toLowerCase();
+              args = parseValues(args);
+              if (type == "m" && args.length > 2) {
+                data.push([command].concat(args.splice(0, 2)));
+                type = "l";
+                command = command == "m" ? "l" : "L";
+              }
+              while (true) {
+                if (args.length == length2[type]) {
+                  args.unshift(command);
+                  return data.push(args);
+                }
+                if (args.length < length2[type]) throw new Error("malformed path data");
+                data.push([command].concat(args.splice(0, length2[type])));
+              }
+            });
+            return data;
+          }
+          var number = /-?[0-9]*\.?[0-9]+(?:e[-+]?\d+)?/ig;
+          function parseValues(args) {
+            var numbers = args.match(number);
+            return numbers ? numbers.map(Number) : [];
+          }
+        }
+      });
+      var require_symbol_defs = __commonJS({
+        "src/components/drawing/symbol_defs.js"(exports, module2) {
+          var parseSvgPath = require_parse_svg_path();
+          var round2 = (
+            // require('@plotly/d3').round;
+            function(x2, n2) {
+              return n2 ? Math.round(x2 * (n2 = Math.pow(10, n2))) / n2 : Math.round(x2);
+            }
+          );
+          var emptyPath = "M0,0Z";
+          var sqrt2 = Math.sqrt(2);
+          var sqrt3 = Math.sqrt(3);
+          var PI2 = Math.PI;
+          var cos = Math.cos;
+          var sin = Math.sin;
+          module2.exports = {
+            circle: {
+              n: 0,
+              f: function(r2, angle2, standoff) {
+                if (skipAngle(angle2)) return emptyPath;
+                var rs = round2(r2, 2);
+                var circle = "M" + rs + ",0A" + rs + "," + rs + " 0 1,1 0,-" + rs + "A" + rs + "," + rs + " 0 0,1 " + rs + ",0Z";
+                return standoff ? align(angle2, standoff, circle) : circle;
+              }
+            },
+            square: {
+              n: 1,
+              f: function(r2, angle2, standoff) {
+                if (skipAngle(angle2)) return emptyPath;
+                var rs = round2(r2, 2);
+                return align(angle2, standoff, "M" + rs + "," + rs + "H-" + rs + "V-" + rs + "H" + rs + "Z");
+              }
+            },
+            diamond: {
+              n: 2,
+              f: function(r2, angle2, standoff) {
+                if (skipAngle(angle2)) return emptyPath;
+                var rd2 = round2(r2 * 1.3, 2);
+                return align(angle2, standoff, "M" + rd2 + ",0L0," + rd2 + "L-" + rd2 + ",0L0,-" + rd2 + "Z");
+              }
+            },
+            cross: {
+              n: 3,
+              f: function(r2, angle2, standoff) {
+                if (skipAngle(angle2)) return emptyPath;
+                var rc2 = round2(r2 * 0.4, 2);
+                var rc22 = round2(r2 * 1.2, 2);
+                return align(angle2, standoff, "M" + rc22 + "," + rc2 + "H" + rc2 + "V" + rc22 + "H-" + rc2 + "V" + rc2 + "H-" + rc22 + "V-" + rc2 + "H-" + rc2 + "V-" + rc22 + "H" + rc2 + "V-" + rc2 + "H" + rc22 + "Z");
+              }
+            },
+            x: {
+              n: 4,
+              f: function(r2, angle2, standoff) {
+                if (skipAngle(angle2)) return emptyPath;
+                var rx = round2(r2 * 0.8 / sqrt2, 2);
+                var ne2 = "l" + rx + "," + rx;
+                var se2 = "l" + rx + ",-" + rx;
+                var sw = "l-" + rx + ",-" + rx;
+                var nw = "l-" + rx + "," + rx;
+                return align(angle2, standoff, "M0," + rx + ne2 + se2 + sw + se2 + sw + nw + sw + nw + ne2 + nw + ne2 + "Z");
+              }
+            },
+            "triangle-up": {
+              n: 5,
+              f: function(r2, angle2, standoff) {
+                if (skipAngle(angle2)) return emptyPath;
+                var rt2 = round2(r2 * 2 / sqrt3, 2);
+                var r22 = round2(r2 / 2, 2);
+                var rs = round2(r2, 2);
+                return align(angle2, standoff, "M-" + rt2 + "," + r22 + "H" + rt2 + "L0,-" + rs + "Z");
+              }
+            },
+            "triangle-down": {
+              n: 6,
+              f: function(r2, angle2, standoff) {
+                if (skipAngle(angle2)) return emptyPath;
+                var rt2 = round2(r2 * 2 / sqrt3, 2);
+                var r22 = round2(r2 / 2, 2);
+                var rs = round2(r2, 2);
+                return align(angle2, standoff, "M-" + rt2 + ",-" + r22 + "H" + rt2 + "L0," + rs + "Z");
+              }
+            },
+            "triangle-left": {
+              n: 7,
+              f: function(r2, angle2, standoff) {
+                if (skipAngle(angle2)) return emptyPath;
+                var rt2 = round2(r2 * 2 / sqrt3, 2);
+                var r22 = round2(r2 / 2, 2);
+                var rs = round2(r2, 2);
+                return align(angle2, standoff, "M" + r22 + ",-" + rt2 + "V" + rt2 + "L-" + rs + ",0Z");
+              }
+            },
+            "triangle-right": {
+              n: 8,
+              f: function(r2, angle2, standoff) {
+                if (skipAngle(angle2)) return emptyPath;
+                var rt2 = round2(r2 * 2 / sqrt3, 2);
+                var r22 = round2(r2 / 2, 2);
+                var rs = round2(r2, 2);
+                return align(angle2, standoff, "M-" + r22 + ",-" + rt2 + "V" + rt2 + "L" + rs + ",0Z");
+              }
+            },
+            "triangle-ne": {
+              n: 9,
+              f: function(r2, angle2, standoff) {
+                if (skipAngle(angle2)) return emptyPath;
+                var r1 = round2(r2 * 0.6, 2);
+                var r22 = round2(r2 * 1.2, 2);
+                return align(angle2, standoff, "M-" + r22 + ",-" + r1 + "H" + r1 + "V" + r22 + "Z");
+              }
+            },
+            "triangle-se": {
+              n: 10,
+              f: function(r2, angle2, standoff) {
+                if (skipAngle(angle2)) return emptyPath;
+                var r1 = round2(r2 * 0.6, 2);
+                var r22 = round2(r2 * 1.2, 2);
+                return align(angle2, standoff, "M" + r1 + ",-" + r22 + "V" + r1 + "H-" + r22 + "Z");
+              }
+            },
+            "triangle-sw": {
+              n: 11,
+              f: function(r2, angle2, standoff) {
+                if (skipAngle(angle2)) return emptyPath;
+                var r1 = round2(r2 * 0.6, 2);
+                var r22 = round2(r2 * 1.2, 2);
+                return align(angle2, standoff, "M" + r22 + "," + r1 + "H-" + r1 + "V-" + r22 + "Z");
+              }
+            },
+            "triangle-nw": {
+              n: 12,
+              f: function(r2, angle2, standoff) {
+                if (skipAngle(angle2)) return emptyPath;
+                var r1 = round2(r2 * 0.6, 2);
+                var r22 = round2(r2 * 1.2, 2);
+                return align(angle2, standoff, "M-" + r1 + "," + r22 + "V-" + r1 + "H" + r22 + "Z");
+              }
+            },
+            pentagon: {
+              n: 13,
+              f: function(r2, angle2, standoff) {
+                if (skipAngle(angle2)) return emptyPath;
+                var x1 = round2(r2 * 0.951, 2);
+                var x2 = round2(r2 * 0.588, 2);
+                var y0 = round2(-r2, 2);
+                var y1 = round2(r2 * -0.309, 2);
+                var y2 = round2(r2 * 0.809, 2);
+                return align(angle2, standoff, "M" + x1 + "," + y1 + "L" + x2 + "," + y2 + "H-" + x2 + "L-" + x1 + "," + y1 + "L0," + y0 + "Z");
+              }
+            },
+            hexagon: {
+              n: 14,
+              f: function(r2, angle2, standoff) {
+                if (skipAngle(angle2)) return emptyPath;
+                var y0 = round2(r2, 2);
+                var y1 = round2(r2 / 2, 2);
+                var x2 = round2(r2 * sqrt3 / 2, 2);
+                return align(angle2, standoff, "M" + x2 + ",-" + y1 + "V" + y1 + "L0," + y0 + "L-" + x2 + "," + y1 + "V-" + y1 + "L0,-" + y0 + "Z");
+              }
+            },
+            hexagon2: {
+              n: 15,
+              f: function(r2, angle2, standoff) {
+                if (skipAngle(angle2)) return emptyPath;
+                var x0 = round2(r2, 2);
+                var x1 = round2(r2 / 2, 2);
+                var y2 = round2(r2 * sqrt3 / 2, 2);
+                return align(angle2, standoff, "M-" + x1 + "," + y2 + "H" + x1 + "L" + x0 + ",0L" + x1 + ",-" + y2 + "H-" + x1 + "L-" + x0 + ",0Z");
+              }
+            },
+            octagon: {
+              n: 16,
+              f: function(r2, angle2, standoff) {
+                if (skipAngle(angle2)) return emptyPath;
+                var a2 = round2(r2 * 0.924, 2);
+                var b2 = round2(r2 * 0.383, 2);
+                return align(angle2, standoff, "M-" + b2 + ",-" + a2 + "H" + b2 + "L" + a2 + ",-" + b2 + "V" + b2 + "L" + b2 + "," + a2 + "H-" + b2 + "L-" + a2 + "," + b2 + "V-" + b2 + "Z");
+              }
+            },
+            star: {
+              n: 17,
+              f: function(r2, angle2, standoff) {
+                if (skipAngle(angle2)) return emptyPath;
+                var rs = r2 * 1.4;
+                var x1 = round2(rs * 0.225, 2);
+                var x2 = round2(rs * 0.951, 2);
+                var x3 = round2(rs * 0.363, 2);
+                var x4 = round2(rs * 0.588, 2);
+                var y0 = round2(-rs, 2);
+                var y1 = round2(rs * -0.309, 2);
+                var y3 = round2(rs * 0.118, 2);
+                var y4 = round2(rs * 0.809, 2);
+                var y5 = round2(rs * 0.382, 2);
+                return align(angle2, standoff, "M" + x1 + "," + y1 + "H" + x2 + "L" + x3 + "," + y3 + "L" + x4 + "," + y4 + "L0," + y5 + "L-" + x4 + "," + y4 + "L-" + x3 + "," + y3 + "L-" + x2 + "," + y1 + "H-" + x1 + "L0," + y0 + "Z");
+              }
+            },
+            hexagram: {
+              n: 18,
+              f: function(r2, angle2, standoff) {
+                if (skipAngle(angle2)) return emptyPath;
+                var y2 = round2(r2 * 0.66, 2);
+                var x1 = round2(r2 * 0.38, 2);
+                var x2 = round2(r2 * 0.76, 2);
+                return align(angle2, standoff, "M-" + x2 + ",0l-" + x1 + ",-" + y2 + "h" + x2 + "l" + x1 + ",-" + y2 + "l" + x1 + "," + y2 + "h" + x2 + "l-" + x1 + "," + y2 + "l" + x1 + "," + y2 + "h-" + x2 + "l-" + x1 + "," + y2 + "l-" + x1 + ",-" + y2 + "h-" + x2 + "Z");
+              }
+            },
+            "star-triangle-up": {
+              n: 19,
+              f: function(r2, angle2, standoff) {
+                if (skipAngle(angle2)) return emptyPath;
+                var x2 = round2(r2 * sqrt3 * 0.8, 2);
+                var y1 = round2(r2 * 0.8, 2);
+                var y2 = round2(r2 * 1.6, 2);
+                var rc2 = round2(r2 * 4, 2);
+                var aPart = "A " + rc2 + "," + rc2 + " 0 0 1 ";
+                return align(angle2, standoff, "M-" + x2 + "," + y1 + aPart + x2 + "," + y1 + aPart + "0,-" + y2 + aPart + "-" + x2 + "," + y1 + "Z");
+              }
+            },
+            "star-triangle-down": {
+              n: 20,
+              f: function(r2, angle2, standoff) {
+                if (skipAngle(angle2)) return emptyPath;
+                var x2 = round2(r2 * sqrt3 * 0.8, 2);
+                var y1 = round2(r2 * 0.8, 2);
+                var y2 = round2(r2 * 1.6, 2);
+                var rc2 = round2(r2 * 4, 2);
+                var aPart = "A " + rc2 + "," + rc2 + " 0 0 1 ";
+                return align(angle2, standoff, "M" + x2 + ",-" + y1 + aPart + "-" + x2 + ",-" + y1 + aPart + "0," + y2 + aPart + x2 + ",-" + y1 + "Z");
+              }
+            },
+            "star-square": {
+              n: 21,
+              f: function(r2, angle2, standoff) {
+                if (skipAngle(angle2)) return emptyPath;
+                var rp = round2(r2 * 1.1, 2);
+                var rc2 = round2(r2 * 2, 2);
+                var aPart = "A " + rc2 + "," + rc2 + " 0 0 1 ";
+                return align(angle2, standoff, "M-" + rp + ",-" + rp + aPart + "-" + rp + "," + rp + aPart + rp + "," + rp + aPart + rp + ",-" + rp + aPart + "-" + rp + ",-" + rp + "Z");
+              }
+            },
+            "star-diamond": {
+              n: 22,
+              f: function(r2, angle2, standoff) {
+                if (skipAngle(angle2)) return emptyPath;
+                var rp = round2(r2 * 1.4, 2);
+                var rc2 = round2(r2 * 1.9, 2);
+                var aPart = "A " + rc2 + "," + rc2 + " 0 0 1 ";
+                return align(angle2, standoff, "M-" + rp + ",0" + aPart + "0," + rp + aPart + rp + ",0" + aPart + "0,-" + rp + aPart + "-" + rp + ",0Z");
+              }
+            },
+            "diamond-tall": {
+              n: 23,
+              f: function(r2, angle2, standoff) {
+                if (skipAngle(angle2)) return emptyPath;
+                var x2 = round2(r2 * 0.7, 2);
+                var y2 = round2(r2 * 1.4, 2);
+                return align(angle2, standoff, "M0," + y2 + "L" + x2 + ",0L0,-" + y2 + "L-" + x2 + ",0Z");
+              }
+            },
+            "diamond-wide": {
+              n: 24,
+              f: function(r2, angle2, standoff) {
+                if (skipAngle(angle2)) return emptyPath;
+                var x2 = round2(r2 * 1.4, 2);
+                var y2 = round2(r2 * 0.7, 2);
+                return align(angle2, standoff, "M0," + y2 + "L" + x2 + ",0L0,-" + y2 + "L-" + x2 + ",0Z");
+              }
+            },
+            hourglass: {
+              n: 25,
+              f: function(r2, angle2, standoff) {
+                if (skipAngle(angle2)) return emptyPath;
+                var rs = round2(r2, 2);
+                return align(angle2, standoff, "M" + rs + "," + rs + "H-" + rs + "L" + rs + ",-" + rs + "H-" + rs + "Z");
+              },
+              noDot: true
+            },
+            bowtie: {
+              n: 26,
+              f: function(r2, angle2, standoff) {
+                if (skipAngle(angle2)) return emptyPath;
+                var rs = round2(r2, 2);
+                return align(angle2, standoff, "M" + rs + "," + rs + "V-" + rs + "L-" + rs + "," + rs + "V-" + rs + "Z");
+              },
+              noDot: true
+            },
+            "circle-cross": {
+              n: 27,
+              f: function(r2, angle2, standoff) {
+                if (skipAngle(angle2)) return emptyPath;
+                var rs = round2(r2, 2);
+                return align(angle2, standoff, "M0," + rs + "V-" + rs + "M" + rs + ",0H-" + rs + "M" + rs + ",0A" + rs + "," + rs + " 0 1,1 0,-" + rs + "A" + rs + "," + rs + " 0 0,1 " + rs + ",0Z");
+              },
+              needLine: true,
+              noDot: true
+            },
+            "circle-x": {
+              n: 28,
+              f: function(r2, angle2, standoff) {
+                if (skipAngle(angle2)) return emptyPath;
+                var rs = round2(r2, 2);
+                var rc2 = round2(r2 / sqrt2, 2);
+                return align(angle2, standoff, "M" + rc2 + "," + rc2 + "L-" + rc2 + ",-" + rc2 + "M" + rc2 + ",-" + rc2 + "L-" + rc2 + "," + rc2 + "M" + rs + ",0A" + rs + "," + rs + " 0 1,1 0,-" + rs + "A" + rs + "," + rs + " 0 0,1 " + rs + ",0Z");
+              },
+              needLine: true,
+              noDot: true
+            },
+            "square-cross": {
+              n: 29,
+              f: function(r2, angle2, standoff) {
+                if (skipAngle(angle2)) return emptyPath;
+                var rs = round2(r2, 2);
+                return align(angle2, standoff, "M0," + rs + "V-" + rs + "M" + rs + ",0H-" + rs + "M" + rs + "," + rs + "H-" + rs + "V-" + rs + "H" + rs + "Z");
+              },
+              needLine: true,
+              noDot: true
+            },
+            "square-x": {
+              n: 30,
+              f: function(r2, angle2, standoff) {
+                if (skipAngle(angle2)) return emptyPath;
+                var rs = round2(r2, 2);
+                return align(angle2, standoff, "M" + rs + "," + rs + "L-" + rs + ",-" + rs + "M" + rs + ",-" + rs + "L-" + rs + "," + rs + "M" + rs + "," + rs + "H-" + rs + "V-" + rs + "H" + rs + "Z");
+              },
+              needLine: true,
+              noDot: true
+            },
+            "diamond-cross": {
+              n: 31,
+              f: function(r2, angle2, standoff) {
+                if (skipAngle(angle2)) return emptyPath;
+                var rd2 = round2(r2 * 1.3, 2);
+                return align(angle2, standoff, "M" + rd2 + ",0L0," + rd2 + "L-" + rd2 + ",0L0,-" + rd2 + "ZM0,-" + rd2 + "V" + rd2 + "M-" + rd2 + ",0H" + rd2);
+              },
+              needLine: true,
+              noDot: true
+            },
+            "diamond-x": {
+              n: 32,
+              f: function(r2, angle2, standoff) {
+                if (skipAngle(angle2)) return emptyPath;
+                var rd2 = round2(r2 * 1.3, 2);
+                var r22 = round2(r2 * 0.65, 2);
+                return align(angle2, standoff, "M" + rd2 + ",0L0," + rd2 + "L-" + rd2 + ",0L0,-" + rd2 + "ZM-" + r22 + ",-" + r22 + "L" + r22 + "," + r22 + "M-" + r22 + "," + r22 + "L" + r22 + ",-" + r22);
+              },
+              needLine: true,
+              noDot: true
+            },
+            "cross-thin": {
+              n: 33,
+              f: function(r2, angle2, standoff) {
+                if (skipAngle(angle2)) return emptyPath;
+                var rc2 = round2(r2 * 1.4, 2);
+                return align(angle2, standoff, "M0," + rc2 + "V-" + rc2 + "M" + rc2 + ",0H-" + rc2);
+              },
+              needLine: true,
+              noDot: true,
+              noFill: true
+            },
+            "x-thin": {
+              n: 34,
+              f: function(r2, angle2, standoff) {
+                if (skipAngle(angle2)) return emptyPath;
+                var rx = round2(r2, 2);
+                return align(angle2, standoff, "M" + rx + "," + rx + "L-" + rx + ",-" + rx + "M" + rx + ",-" + rx + "L-" + rx + "," + rx);
+              },
+              needLine: true,
+              noDot: true,
+              noFill: true
+            },
+            asterisk: {
+              n: 35,
+              f: function(r2, angle2, standoff) {
+                if (skipAngle(angle2)) return emptyPath;
+                var rc2 = round2(r2 * 1.2, 2);
+                var rs = round2(r2 * 0.85, 2);
+                return align(angle2, standoff, "M0," + rc2 + "V-" + rc2 + "M" + rc2 + ",0H-" + rc2 + "M" + rs + "," + rs + "L-" + rs + ",-" + rs + "M" + rs + ",-" + rs + "L-" + rs + "," + rs);
+              },
+              needLine: true,
+              noDot: true,
+              noFill: true
+            },
+            hash: {
+              n: 36,
+              f: function(r2, angle2, standoff) {
+                if (skipAngle(angle2)) return emptyPath;
+                var r1 = round2(r2 / 2, 2);
+                var r22 = round2(r2, 2);
+                return align(angle2, standoff, "M" + r1 + "," + r22 + "V-" + r22 + "M" + (r1 - r22) + ",-" + r22 + "V" + r22 + "M" + r22 + "," + r1 + "H-" + r22 + "M-" + r22 + "," + (r1 - r22) + "H" + r22);
+              },
+              needLine: true,
+              noFill: true
+            },
+            "y-up": {
+              n: 37,
+              f: function(r2, angle2, standoff) {
+                if (skipAngle(angle2)) return emptyPath;
+                var x2 = round2(r2 * 1.2, 2);
+                var y0 = round2(r2 * 1.6, 2);
+                var y1 = round2(r2 * 0.8, 2);
+                return align(angle2, standoff, "M-" + x2 + "," + y1 + "L0,0M" + x2 + "," + y1 + "L0,0M0,-" + y0 + "L0,0");
+              },
+              needLine: true,
+              noDot: true,
+              noFill: true
+            },
+            "y-down": {
+              n: 38,
+              f: function(r2, angle2, standoff) {
+                if (skipAngle(angle2)) return emptyPath;
+                var x2 = round2(r2 * 1.2, 2);
+                var y0 = round2(r2 * 1.6, 2);
+                var y1 = round2(r2 * 0.8, 2);
+                return align(angle2, standoff, "M-" + x2 + ",-" + y1 + "L0,0M" + x2 + ",-" + y1 + "L0,0M0," + y0 + "L0,0");
+              },
+              needLine: true,
+              noDot: true,
+              noFill: true
+            },
+            "y-left": {
+              n: 39,
+              f: function(r2, angle2, standoff) {
+                if (skipAngle(angle2)) return emptyPath;
+                var y2 = round2(r2 * 1.2, 2);
+                var x0 = round2(r2 * 1.6, 2);
+                var x1 = round2(r2 * 0.8, 2);
+                return align(angle2, standoff, "M" + x1 + "," + y2 + "L0,0M" + x1 + ",-" + y2 + "L0,0M-" + x0 + ",0L0,0");
+              },
+              needLine: true,
+              noDot: true,
+              noFill: true
+            },
+            "y-right": {
+              n: 40,
+              f: function(r2, angle2, standoff) {
+                if (skipAngle(angle2)) return emptyPath;
+                var y2 = round2(r2 * 1.2, 2);
+                var x0 = round2(r2 * 1.6, 2);
+                var x1 = round2(r2 * 0.8, 2);
+                return align(angle2, standoff, "M-" + x1 + "," + y2 + "L0,0M-" + x1 + ",-" + y2 + "L0,0M" + x0 + ",0L0,0");
+              },
+              needLine: true,
+              noDot: true,
+              noFill: true
+            },
+            "line-ew": {
+              n: 41,
+              f: function(r2, angle2, standoff) {
+                if (skipAngle(angle2)) return emptyPath;
+                var rc2 = round2(r2 * 1.4, 2);
+                return align(angle2, standoff, "M" + rc2 + ",0H-" + rc2);
+              },
+              needLine: true,
+              noDot: true,
+              noFill: true
+            },
+            "line-ns": {
+              n: 42,
+              f: function(r2, angle2, standoff) {
+                if (skipAngle(angle2)) return emptyPath;
+                var rc2 = round2(r2 * 1.4, 2);
+                return align(angle2, standoff, "M0," + rc2 + "V-" + rc2);
+              },
+              needLine: true,
+              noDot: true,
+              noFill: true
+            },
+            "line-ne": {
+              n: 43,
+              f: function(r2, angle2, standoff) {
+                if (skipAngle(angle2)) return emptyPath;
+                var rx = round2(r2, 2);
+                return align(angle2, standoff, "M" + rx + ",-" + rx + "L-" + rx + "," + rx);
+              },
+              needLine: true,
+              noDot: true,
+              noFill: true
+            },
+            "line-nw": {
+              n: 44,
+              f: function(r2, angle2, standoff) {
+                if (skipAngle(angle2)) return emptyPath;
+                var rx = round2(r2, 2);
+                return align(angle2, standoff, "M" + rx + "," + rx + "L-" + rx + ",-" + rx);
+              },
+              needLine: true,
+              noDot: true,
+              noFill: true
+            },
+            "arrow-up": {
+              n: 45,
+              f: function(r2, angle2, standoff) {
+                if (skipAngle(angle2)) return emptyPath;
+                var rx = round2(r2, 2);
+                var ry = round2(r2 * 2, 2);
+                return align(angle2, standoff, "M0,0L-" + rx + "," + ry + "H" + rx + "Z");
+              },
+              backoff: 1,
+              noDot: true
+            },
+            "arrow-down": {
+              n: 46,
+              f: function(r2, angle2, standoff) {
+                if (skipAngle(angle2)) return emptyPath;
+                var rx = round2(r2, 2);
+                var ry = round2(r2 * 2, 2);
+                return align(angle2, standoff, "M0,0L-" + rx + ",-" + ry + "H" + rx + "Z");
+              },
+              noDot: true
+            },
+            "arrow-left": {
+              n: 47,
+              f: function(r2, angle2, standoff) {
+                if (skipAngle(angle2)) return emptyPath;
+                var rx = round2(r2 * 2, 2);
+                var ry = round2(r2, 2);
+                return align(angle2, standoff, "M0,0L" + rx + ",-" + ry + "V" + ry + "Z");
+              },
+              noDot: true
+            },
+            "arrow-right": {
+              n: 48,
+              f: function(r2, angle2, standoff) {
+                if (skipAngle(angle2)) return emptyPath;
+                var rx = round2(r2 * 2, 2);
+                var ry = round2(r2, 2);
+                return align(angle2, standoff, "M0,0L-" + rx + ",-" + ry + "V" + ry + "Z");
+              },
+              noDot: true
+            },
+            "arrow-bar-up": {
+              n: 49,
+              f: function(r2, angle2, standoff) {
+                if (skipAngle(angle2)) return emptyPath;
+                var rx = round2(r2, 2);
+                var ry = round2(r2 * 2, 2);
+                return align(angle2, standoff, "M-" + rx + ",0H" + rx + "M0,0L-" + rx + "," + ry + "H" + rx + "Z");
+              },
+              backoff: 1,
+              needLine: true,
+              noDot: true
+            },
+            "arrow-bar-down": {
+              n: 50,
+              f: function(r2, angle2, standoff) {
+                if (skipAngle(angle2)) return emptyPath;
+                var rx = round2(r2, 2);
+                var ry = round2(r2 * 2, 2);
+                return align(angle2, standoff, "M-" + rx + ",0H" + rx + "M0,0L-" + rx + ",-" + ry + "H" + rx + "Z");
+              },
+              needLine: true,
+              noDot: true
+            },
+            "arrow-bar-left": {
+              n: 51,
+              f: function(r2, angle2, standoff) {
+                if (skipAngle(angle2)) return emptyPath;
+                var rx = round2(r2 * 2, 2);
+                var ry = round2(r2, 2);
+                return align(angle2, standoff, "M0,-" + ry + "V" + ry + "M0,0L" + rx + ",-" + ry + "V" + ry + "Z");
+              },
+              needLine: true,
+              noDot: true
+            },
+            "arrow-bar-right": {
+              n: 52,
+              f: function(r2, angle2, standoff) {
+                if (skipAngle(angle2)) return emptyPath;
+                var rx = round2(r2 * 2, 2);
+                var ry = round2(r2, 2);
+                return align(angle2, standoff, "M0,-" + ry + "V" + ry + "M0,0L-" + rx + ",-" + ry + "V" + ry + "Z");
+              },
+              needLine: true,
+              noDot: true
+            },
+            arrow: {
+              n: 53,
+              f: function(r2, angle2, standoff) {
+                if (skipAngle(angle2)) return emptyPath;
+                var headAngle = PI2 / 2.5;
+                var x2 = 2 * r2 * cos(headAngle);
+                var y2 = 2 * r2 * sin(headAngle);
+                return align(
+                  angle2,
+                  standoff,
+                  "M0,0L" + -x2 + "," + y2 + "L" + x2 + "," + y2 + "Z"
+                );
+              },
+              backoff: 0.9,
+              noDot: true
+            },
+            "arrow-wide": {
+              n: 54,
+              f: function(r2, angle2, standoff) {
+                if (skipAngle(angle2)) return emptyPath;
+                var headAngle = PI2 / 4;
+                var x2 = 2 * r2 * cos(headAngle);
+                var y2 = 2 * r2 * sin(headAngle);
+                return align(
+                  angle2,
+                  standoff,
+                  "M0,0L" + -x2 + "," + y2 + "A " + 2 * r2 + "," + 2 * r2 + " 0 0 1 " + x2 + "," + y2 + "Z"
+                );
+              },
+              backoff: 0.4,
+              noDot: true
+            }
+          };
+          function skipAngle(angle2) {
+            return angle2 === null;
+          }
+          var lastPathIn;
+          var lastPathOut;
+          var lastAngle;
+          var lastStandoff;
+          function align(angle2, standoff, path) {
+            if ((!angle2 || angle2 % 360 === 0) && !standoff) return path;
+            if (lastAngle === angle2 && lastStandoff === standoff && lastPathIn === path) return lastPathOut;
+            lastAngle = angle2;
+            lastStandoff = standoff;
+            lastPathIn = path;
+            function rotate2(t42, xy) {
+              var cosT = cos(t42);
+              var sinT = sin(t42);
+              var x22 = xy[0];
+              var y22 = xy[1] + (standoff || 0);
+              return [
+                x22 * cosT - y22 * sinT,
+                x22 * sinT + y22 * cosT
+              ];
+            }
+            var t4 = angle2 / 180 * PI2;
+            var x2 = 0;
+            var y2 = 0;
+            var cmd = parseSvgPath(path);
+            var str = "";
+            for (var i2 = 0; i2 < cmd.length; i2++) {
+              var cmdI = cmd[i2];
+              var op = cmdI[0];
+              var x0 = x2;
+              var y0 = y2;
+              if (op === "M" || op === "L") {
+                x2 = +cmdI[1];
+                y2 = +cmdI[2];
+              } else if (op === "m" || op === "l") {
+                x2 += +cmdI[1];
+                y2 += +cmdI[2];
+              } else if (op === "H") {
+                x2 = +cmdI[1];
+              } else if (op === "h") {
+                x2 += +cmdI[1];
+              } else if (op === "V") {
+                y2 = +cmdI[1];
+              } else if (op === "v") {
+                y2 += +cmdI[1];
+              } else if (op === "A") {
+                x2 = +cmdI[1];
+                y2 = +cmdI[2];
+                var E22 = rotate2(t4, [+cmdI[6], +cmdI[7]]);
+                cmdI[6] = E22[0];
+                cmdI[7] = E22[1];
+                cmdI[3] = +cmdI[3] + angle2;
+              }
+              if (op === "H" || op === "V") op = "L";
+              if (op === "h" || op === "v") op = "l";
+              if (op === "m" || op === "l") {
+                x2 -= x0;
+                y2 -= y0;
+              }
+              var B22 = rotate2(t4, [x2, y2]);
+              if (op === "H" || op === "V") op = "L";
+              if (op === "M" || op === "L" || op === "m" || op === "l") {
+                cmdI[1] = B22[0];
+                cmdI[2] = B22[1];
+              }
+              cmdI[0] = op;
+              str += cmdI[0] + cmdI.slice(1).join(",");
+            }
+            lastPathOut = str;
+            return str;
+          }
+        }
+      });
+      var require_drawing = __commonJS({
+        "src/components/drawing/index.js"(exports, module2) {
+          var d3 = require_d3();
+          var Lib = require_lib();
+          var numberFormat = Lib.numberFormat;
+          var isNumeric = require_fast_isnumeric();
+          var tinycolor = require_tinycolor();
+          var Registry = require_registry();
+          var Color2 = require_color();
+          var Colorscale = require_colorscale();
+          var strTranslate = Lib.strTranslate;
+          var svgTextUtils = require_svg_text_utils();
+          var xmlnsNamespaces = require_xmlns_namespaces();
+          var alignment = require_alignment();
+          var LINE_SPACING = alignment.LINE_SPACING;
+          var DESELECTDIM = require_interactions().DESELECTDIM;
+          var subTypes = require_subtypes();
+          var makeBubbleSizeFn = require_make_bubble_size_func();
+          var appendArrayPointValue = require_helpers2().appendArrayPointValue;
+          var drawing = module2.exports = {};
+          drawing.font = function(s2, font) {
+            var variant = font.variant;
+            var style = font.style;
+            var weight = font.weight;
+            var color22 = font.color;
+            var size = font.size;
+            var family = font.family;
+            var shadow2 = font.shadow;
+            var lineposition = font.lineposition;
+            var textcase = font.textcase;
+            if (family) s2.style("font-family", family);
+            if (size + 1) s2.style("font-size", size + "px");
+            if (color22) s2.call(Color2.fill, color22);
+            if (weight) s2.style("font-weight", weight);
+            if (style) s2.style("font-style", style);
+            if (variant) s2.style("font-variant", variant);
+            if (textcase) s2.style("text-transform", dropNone(textcase2transform(textcase)));
+            if (shadow2)
+              s2.style(
+                "text-shadow",
+                shadow2 === "auto" ? svgTextUtils.makeTextShadow(Color2.contrast(color22)) : dropNone(shadow2)
+              );
+            if (lineposition) s2.style("text-decoration-line", dropNone(lineposition2decorationLine(lineposition)));
+          };
+          function dropNone(a2) {
+            return a2 === "none" ? void 0 : a2;
+          }
+          var textcase2transformOptions = {
+            normal: "none",
+            lower: "lowercase",
+            upper: "uppercase",
+            "word caps": "capitalize"
+          };
+          function textcase2transform(textcase) {
+            return textcase2transformOptions[textcase];
+          }
+          function lineposition2decorationLine(lineposition) {
+            return lineposition.replace("under", "underline").replace("over", "overline").replace("through", "line-through").split("+").join(" ");
+          }
+          drawing.setPosition = function(s2, x2, y2) {
+            s2.attr("x", x2).attr("y", y2);
+          };
+          drawing.setSize = function(s2, w2, h2) {
+            s2.attr("width", w2).attr("height", h2);
+          };
+          drawing.setRect = function(s2, x2, y2, w2, h2) {
+            s2.call(drawing.setPosition, x2, y2).call(drawing.setSize, w2, h2);
+          };
+          drawing.translatePoint = function(d2, sel, xa, ya2) {
+            var x2 = xa.c2p(d2.x);
+            var y2 = ya2.c2p(d2.y);
+            if (isNumeric(x2) && isNumeric(y2) && sel.node()) {
+              if (sel.node().nodeName === "text") {
+                sel.attr("x", x2).attr("y", y2);
+              } else {
+                sel.attr("transform", strTranslate(x2, y2));
+              }
+            } else {
+              return false;
+            }
+            return true;
+          };
+          drawing.translatePoints = function(s2, xa, ya2) {
+            s2.each(function(d2) {
+              var sel = d3.select(this);
+              drawing.translatePoint(d2, sel, xa, ya2);
+            });
+          };
+          drawing.hideOutsideRangePoint = function(d2, sel, xa, ya2, xcalendar, ycalendar) {
+            sel.attr("display", xa.isPtWithinRange(d2, xcalendar) && ya2.isPtWithinRange(d2, ycalendar) ? null : "none");
+          };
+          drawing.hideOutsideRangePoints = function(traceGroups, subplot) {
+            if (!subplot._hasClipOnAxisFalse) return;
+            var xa = subplot.xaxis;
+            var ya2 = subplot.yaxis;
+            traceGroups.each(function(d2) {
+              var trace = d2[0].trace;
+              var xcalendar = trace.xcalendar;
+              var ycalendar = trace.ycalendar;
+              var selector = Registry.traceIs(trace, "bar-like") ? ".bartext" : ".point,.textpoint";
+              traceGroups.selectAll(selector).each(function(d22) {
+                drawing.hideOutsideRangePoint(d22, d3.select(this), xa, ya2, xcalendar, ycalendar);
+              });
+            });
+          };
+          drawing.crispRound = function(gd2, lineWidth, dflt) {
+            if (!lineWidth || !isNumeric(lineWidth)) return dflt || 0;
+            if (gd2._context.staticPlot) return lineWidth;
+            if (lineWidth < 1) return 1;
+            return Math.round(lineWidth);
+          };
+          drawing.singleLineStyle = function(d2, s2, lw, lc2, ld2) {
+            s2.style("fill", "none");
+            var line = (((d2 || [])[0] || {}).trace || {}).line || {};
+            var lw1 = lw || line.width || 0;
+            var dash = ld2 || line.dash || "";
+            Color2.stroke(s2, lc2 || line.color);
+            drawing.dashLine(s2, dash, lw1);
+          };
+          drawing.lineGroupStyle = function(s2, lw, lc2, ld2) {
+            s2.style("fill", "none").each(function(d2) {
+              var line = (((d2 || [])[0] || {}).trace || {}).line || {};
+              var lw1 = lw || line.width || 0;
+              var dash = ld2 || line.dash || "";
+              d3.select(this).call(Color2.stroke, lc2 || line.color).call(drawing.dashLine, dash, lw1);
+            });
+          };
+          drawing.dashLine = function(s2, dash, lineWidth) {
+            lineWidth = +lineWidth || 0;
+            dash = drawing.dashStyle(dash, lineWidth);
+            s2.style({
+              "stroke-dasharray": dash,
+              "stroke-width": lineWidth + "px"
+            });
+          };
+          drawing.dashStyle = function(dash, lineWidth) {
+            lineWidth = +lineWidth || 1;
+            var dlw = Math.max(lineWidth, 3);
+            if (dash === "solid") dash = "";
+            else if (dash === "dot") dash = dlw + "px," + dlw + "px";
+            else if (dash === "dash") dash = 3 * dlw + "px," + 3 * dlw + "px";
+            else if (dash === "longdash") dash = 5 * dlw + "px," + 5 * dlw + "px";
+            else if (dash === "dashdot") {
+              dash = 3 * dlw + "px," + dlw + "px," + dlw + "px," + dlw + "px";
+            } else if (dash === "longdashdot") {
+              dash = 5 * dlw + "px," + 2 * dlw + "px," + dlw + "px," + 2 * dlw + "px";
+            }
+            return dash;
+          };
+          function setFillStyle(sel, trace, gd2, forLegend) {
+            var markerPattern = trace.fillpattern;
+            var fillgradient = trace.fillgradient;
+            var pAttr = drawing.getPatternAttr;
+            var patternShape = markerPattern && (pAttr(markerPattern.shape, 0, "") || pAttr(markerPattern.path, 0, ""));
+            if (patternShape) {
+              var patternBGColor = pAttr(markerPattern.bgcolor, 0, null);
+              var patternFGColor = pAttr(markerPattern.fgcolor, 0, null);
+              var patternFGOpacity = markerPattern.fgopacity;
+              var patternSize = pAttr(markerPattern.size, 0, 8);
+              var patternSolidity = pAttr(markerPattern.solidity, 0, 0.3);
+              var patternID = trace.uid;
+              drawing.pattern(
+                sel,
+                "point",
+                gd2,
+                patternID,
+                patternShape,
+                patternSize,
+                patternSolidity,
+                void 0,
+                markerPattern.fillmode,
+                patternBGColor,
+                patternFGColor,
+                patternFGOpacity
+              );
+            } else if (fillgradient && fillgradient.type !== "none") {
+              var direction = fillgradient.type;
+              var gradientID = "scatterfill-" + trace.uid;
+              if (forLegend) {
+                gradientID = "legendfill-" + trace.uid;
+              }
+              if (!forLegend && (fillgradient.start !== void 0 || fillgradient.stop !== void 0)) {
+                var start, stop;
+                if (direction === "horizontal") {
+                  start = {
+                    x: fillgradient.start,
+                    y: 0
+                  };
+                  stop = {
+                    x: fillgradient.stop,
+                    y: 0
+                  };
+                } else if (direction === "vertical") {
+                  start = {
+                    x: 0,
+                    y: fillgradient.start
+                  };
+                  stop = {
+                    x: 0,
+                    y: fillgradient.stop
+                  };
+                }
+                start.x = trace._xA.c2p(start.x === void 0 ? trace._extremes.x.min[0].val : start.x, true);
+                start.y = trace._yA.c2p(start.y === void 0 ? trace._extremes.y.min[0].val : start.y, true);
+                stop.x = trace._xA.c2p(stop.x === void 0 ? trace._extremes.x.max[0].val : stop.x, true);
+                stop.y = trace._yA.c2p(stop.y === void 0 ? trace._extremes.y.max[0].val : stop.y, true);
+                sel.call(
+                  gradientWithBounds,
+                  gd2,
+                  gradientID,
+                  "linear",
+                  fillgradient.colorscale,
+                  "fill",
+                  start,
+                  stop,
+                  true,
+                  false
+                );
+              } else {
+                if (direction === "horizontal") {
+                  direction = direction + "reversed";
+                }
+                sel.call(drawing.gradient, gd2, gradientID, direction, fillgradient.colorscale, "fill");
+              }
+            } else if (trace.fillcolor) {
+              sel.call(Color2.fill, trace.fillcolor);
+            }
+          }
+          drawing.singleFillStyle = function(sel, gd2) {
+            var node = d3.select(sel.node());
+            var data = node.data();
+            var trace = ((data[0] || [])[0] || {}).trace || {};
+            setFillStyle(sel, trace, gd2, false);
+          };
+          drawing.fillGroupStyle = function(s2, gd2, forLegend) {
+            s2.style("stroke-width", 0).each(function(d2) {
+              var shape = d3.select(this);
+              if (d2[0].trace) {
+                setFillStyle(shape, d2[0].trace, gd2, forLegend);
+              }
+            });
+          };
+          var SYMBOLDEFS = require_symbol_defs();
+          drawing.symbolNames = [];
+          drawing.symbolFuncs = [];
+          drawing.symbolBackOffs = [];
+          drawing.symbolNeedLines = {};
+          drawing.symbolNoDot = {};
+          drawing.symbolNoFill = {};
+          drawing.symbolList = [];
+          Object.keys(SYMBOLDEFS).forEach(function(k2) {
+            var symDef = SYMBOLDEFS[k2];
+            var n2 = symDef.n;
+            drawing.symbolList.push(
+              n2,
+              String(n2),
+              k2,
+              n2 + 100,
+              String(n2 + 100),
+              k2 + "-open"
+            );
+            drawing.symbolNames[n2] = k2;
+            drawing.symbolFuncs[n2] = symDef.f;
+            drawing.symbolBackOffs[n2] = symDef.backoff || 0;
+            if (symDef.needLine) {
+              drawing.symbolNeedLines[n2] = true;
+            }
+            if (symDef.noDot) {
+              drawing.symbolNoDot[n2] = true;
+            } else {
+              drawing.symbolList.push(
+                n2 + 200,
+                String(n2 + 200),
+                k2 + "-dot",
+                n2 + 300,
+                String(n2 + 300),
+                k2 + "-open-dot"
+              );
+            }
+            if (symDef.noFill) {
+              drawing.symbolNoFill[n2] = true;
+            }
+          });
+          var MAXSYMBOL = drawing.symbolNames.length;
+          var DOTPATH = "M0,0.5L0.5,0L0,-0.5L-0.5,0Z";
+          drawing.symbolNumber = function(v2) {
+            if (isNumeric(v2)) {
+              v2 = +v2;
+            } else if (typeof v2 === "string") {
+              var vbase = 0;
+              if (v2.indexOf("-open") > 0) {
+                vbase = 100;
+                v2 = v2.replace("-open", "");
+              }
+              if (v2.indexOf("-dot") > 0) {
+                vbase += 200;
+                v2 = v2.replace("-dot", "");
+              }
+              v2 = drawing.symbolNames.indexOf(v2);
+              if (v2 >= 0) {
+                v2 += vbase;
+              }
+            }
+            return v2 % 100 >= MAXSYMBOL || v2 >= 400 ? 0 : Math.floor(Math.max(v2, 0));
+          };
+          function makePointPath(symbolNumber, r2, t4, s2) {
+            var base = symbolNumber % 100;
+            return drawing.symbolFuncs[base](r2, t4, s2) + (symbolNumber >= 200 ? DOTPATH : "");
+          }
+          var stopFormatter = numberFormat("~f");
+          var gradientInfo = {
+            radial: { type: "radial" },
+            radialreversed: { type: "radial", reversed: true },
+            horizontal: { type: "linear", start: { x: 1, y: 0 }, stop: { x: 0, y: 0 } },
+            horizontalreversed: { type: "linear", start: { x: 1, y: 0 }, stop: { x: 0, y: 0 }, reversed: true },
+            vertical: { type: "linear", start: { x: 0, y: 1 }, stop: { x: 0, y: 0 } },
+            verticalreversed: { type: "linear", start: { x: 0, y: 1 }, stop: { x: 0, y: 0 }, reversed: true }
+          };
+          drawing.gradient = function(sel, gd2, gradientID, type, colorscale, prop) {
+            var info = gradientInfo[type];
+            return gradientWithBounds(
+              sel,
+              gd2,
+              gradientID,
+              info.type,
+              colorscale,
+              prop,
+              info.start,
+              info.stop,
+              false,
+              info.reversed
+            );
+          };
+          function gradientWithBounds(sel, gd2, gradientID, type, colorscale, prop, start, stop, inUserSpace, reversed) {
+            var len2 = colorscale.length;
+            var info;
+            if (type === "linear") {
+              info = {
+                node: "linearGradient",
+                attrs: {
+                  x1: start.x,
+                  y1: start.y,
+                  x2: stop.x,
+                  y2: stop.y,
+                  gradientUnits: inUserSpace ? "userSpaceOnUse" : "objectBoundingBox"
+                },
+                reversed
+              };
+            } else if (type === "radial") {
+              info = {
+                node: "radialGradient",
+                reversed
+              };
+            }
+            var colorStops = new Array(len2);
+            for (var i2 = 0; i2 < len2; i2++) {
+              if (info.reversed) {
+                colorStops[len2 - 1 - i2] = [stopFormatter((1 - colorscale[i2][0]) * 100), colorscale[i2][1]];
+              } else {
+                colorStops[i2] = [stopFormatter(colorscale[i2][0] * 100), colorscale[i2][1]];
+              }
+            }
+            var fullLayout = gd2._fullLayout;
+            var fullID = "g" + fullLayout._uid + "-" + gradientID;
+            var gradient = fullLayout._defs.select(".gradients").selectAll("#" + fullID).data([type + colorStops.join(";")], Lib.identity);
+            gradient.exit().remove();
+            gradient.enter().append(info.node).each(function() {
+              var el2 = d3.select(this);
+              if (info.attrs) el2.attr(info.attrs);
+              el2.attr("id", fullID);
+              var stops = el2.selectAll("stop").data(colorStops);
+              stops.exit().remove();
+              stops.enter().append("stop");
+              stops.each(function(d2) {
+                var tc2 = tinycolor(d2[1]);
+                d3.select(this).attr({
+                  offset: d2[0] + "%",
+                  "stop-color": Color2.tinyRGB(tc2),
+                  "stop-opacity": tc2.getAlpha()
+                });
+              });
+            });
+            sel.style(prop, getFullUrl(fullID, gd2)).style(prop + "-opacity", null);
+            sel.classed("gradient_filled", true);
+          }
+          drawing.pattern = function(sel, calledBy, gd2, patternID, shape, size, solidity, mcc, fillmode, bgcolor, fgcolor, fgopacity) {
+            var isLegend = calledBy === "legend";
+            if (mcc) {
+              if (fillmode === "overlay") {
+                bgcolor = mcc;
+                fgcolor = Color2.contrast(bgcolor);
+              } else {
+                bgcolor = void 0;
+                fgcolor = mcc;
+              }
+            }
+            var fullLayout = gd2._fullLayout;
+            var fullID = "p" + fullLayout._uid + "-" + patternID;
+            var width, height;
+            var linearFn = function(x2, x0, x1, y0, y1) {
+              return y0 + (y1 - y0) * (x2 - x0) / (x1 - x0);
+            };
+            var path, linewidth, radius;
+            var patternTag;
+            var patternAttrs = {};
+            var fgC = tinycolor(fgcolor);
+            var fgRGB = Color2.tinyRGB(fgC);
+            var fgAlpha = fgC.getAlpha();
+            var opacity = fgopacity * fgAlpha;
+            switch (shape) {
+              case "/":
+                width = size * Math.sqrt(2);
+                height = size * Math.sqrt(2);
+                path = "M-" + width / 4 + "," + height / 4 + "l" + width / 2 + ",-" + height / 2 + "M0," + height + "L" + width + ",0M" + width / 4 * 3 + "," + height / 4 * 5 + "l" + width / 2 + ",-" + height / 2;
+                linewidth = solidity * size;
+                patternTag = "path";
+                patternAttrs = {
+                  d: path,
+                  opacity,
+                  stroke: fgRGB,
+                  "stroke-width": linewidth + "px"
+                };
+                break;
+              case "\\":
+                width = size * Math.sqrt(2);
+                height = size * Math.sqrt(2);
+                path = "M" + width / 4 * 3 + ",-" + height / 4 + "l" + width / 2 + "," + height / 2 + "M0,0L" + width + "," + height + "M-" + width / 4 + "," + height / 4 * 3 + "l" + width / 2 + "," + height / 2;
+                linewidth = solidity * size;
+                patternTag = "path";
+                patternAttrs = {
+                  d: path,
+                  opacity,
+                  stroke: fgRGB,
+                  "stroke-width": linewidth + "px"
+                };
+                break;
+              case "x":
+                width = size * Math.sqrt(2);
+                height = size * Math.sqrt(2);
+                path = "M-" + width / 4 + "," + height / 4 + "l" + width / 2 + ",-" + height / 2 + "M0," + height + "L" + width + ",0M" + width / 4 * 3 + "," + height / 4 * 5 + "l" + width / 2 + ",-" + height / 2 + "M" + width / 4 * 3 + ",-" + height / 4 + "l" + width / 2 + "," + height / 2 + "M0,0L" + width + "," + height + "M-" + width / 4 + "," + height / 4 * 3 + "l" + width / 2 + "," + height / 2;
+                linewidth = size - size * Math.sqrt(1 - solidity);
+                patternTag = "path";
+                patternAttrs = {
+                  d: path,
+                  opacity,
+                  stroke: fgRGB,
+                  "stroke-width": linewidth + "px"
+                };
+                break;
+              case "|":
+                width = size;
+                height = size;
+                patternTag = "path";
+                path = "M" + width / 2 + ",0L" + width / 2 + "," + height;
+                linewidth = solidity * size;
+                patternTag = "path";
+                patternAttrs = {
+                  d: path,
+                  opacity,
+                  stroke: fgRGB,
+                  "stroke-width": linewidth + "px"
+                };
+                break;
+              case "-":
+                width = size;
+                height = size;
+                patternTag = "path";
+                path = "M0," + height / 2 + "L" + width + "," + height / 2;
+                linewidth = solidity * size;
+                patternTag = "path";
+                patternAttrs = {
+                  d: path,
+                  opacity,
+                  stroke: fgRGB,
+                  "stroke-width": linewidth + "px"
+                };
+                break;
+              case "+":
+                width = size;
+                height = size;
+                patternTag = "path";
+                path = "M" + width / 2 + ",0L" + width / 2 + "," + height + "M0," + height / 2 + "L" + width + "," + height / 2;
+                linewidth = size - size * Math.sqrt(1 - solidity);
+                patternTag = "path";
+                patternAttrs = {
+                  d: path,
+                  opacity,
+                  stroke: fgRGB,
+                  "stroke-width": linewidth + "px"
+                };
+                break;
+              case ".":
+                width = size;
+                height = size;
+                if (solidity < Math.PI / 4) {
+                  radius = Math.sqrt(solidity * size * size / Math.PI);
+                } else {
+                  radius = linearFn(solidity, Math.PI / 4, 1, size / 2, size / Math.sqrt(2));
+                }
+                patternTag = "circle";
+                patternAttrs = {
+                  cx: width / 2,
+                  cy: height / 2,
+                  r: radius,
+                  opacity,
+                  fill: fgRGB
+                };
+                break;
+              default:
+                width = size;
+                height = size;
+                patternTag = "path";
+                patternAttrs = {
+                  d: shape,
+                  opacity,
+                  fill: fgRGB
+                };
+                break;
+            }
+            var str = [shape || "noSh", bgcolor || "noBg", fgcolor || "noFg", size, solidity].join(";");
+            var pattern = fullLayout._defs.select(".patterns").selectAll("#" + fullID).data([str], Lib.identity);
+            pattern.exit().remove();
+            pattern.enter().append("pattern").each(function() {
+              var el2 = d3.select(this);
+              el2.attr({
+                id: fullID,
+                width: width + "px",
+                height: height + "px",
+                patternUnits: "userSpaceOnUse",
+                // for legends scale down patterns just a bit so that default size (i.e 8) nicely fit in small icons
+                patternTransform: isLegend ? "scale(0.8)" : ""
+              });
+              if (bgcolor) {
+                var bgC = tinycolor(bgcolor);
+                var bgRGB = Color2.tinyRGB(bgC);
+                var bgAlpha = bgC.getAlpha();
+                var rects = el2.selectAll("rect").data([0]);
+                rects.exit().remove();
+                rects.enter().append("rect").attr({
+                  width: width + "px",
+                  height: height + "px",
+                  fill: bgRGB,
+                  "fill-opacity": bgAlpha
+                });
+              }
+              var patterns = el2.selectAll(patternTag).data([0]);
+              patterns.exit().remove();
+              patterns.enter().append(patternTag).attr(patternAttrs);
+            });
+            sel.style("fill", getFullUrl(fullID, gd2)).style("fill-opacity", null);
+            sel.classed("pattern_filled", true);
+          };
+          drawing.initGradients = function(gd2) {
+            var fullLayout = gd2._fullLayout;
+            var gradientsGroup = Lib.ensureSingle(fullLayout._defs, "g", "gradients");
+            gradientsGroup.selectAll("linearGradient,radialGradient").remove();
+            d3.select(gd2).selectAll(".gradient_filled").classed("gradient_filled", false);
+          };
+          drawing.initPatterns = function(gd2) {
+            var fullLayout = gd2._fullLayout;
+            var patternsGroup = Lib.ensureSingle(fullLayout._defs, "g", "patterns");
+            patternsGroup.selectAll("pattern").remove();
+            d3.select(gd2).selectAll(".pattern_filled").classed("pattern_filled", false);
+          };
+          drawing.getPatternAttr = function(mp, i2, dflt) {
+            if (mp && Lib.isArrayOrTypedArray(mp)) {
+              return i2 < mp.length ? mp[i2] : dflt;
+            }
+            return mp;
+          };
+          drawing.pointStyle = function(s2, trace, gd2, pt2) {
+            if (!s2.size()) return;
+            var fns = drawing.makePointStyleFns(trace);
+            s2.each(function(d2) {
+              drawing.singlePointStyle(d2, d3.select(this), trace, fns, gd2, pt2);
+            });
+          };
+          drawing.singlePointStyle = function(d2, sel, trace, fns, gd2, pt2) {
+            var marker = trace.marker;
+            var markerLine = marker.line;
+            if (pt2 && pt2.i >= 0 && d2.i === void 0) d2.i = pt2.i;
+            sel.style("opacity", fns.selectedOpacityFn ? fns.selectedOpacityFn(d2) : d2.mo === void 0 ? marker.opacity : d2.mo);
+            if (fns.ms2mrc) {
+              var r2;
+              if (d2.ms === "various" || marker.size === "various") {
+                r2 = 3;
+              } else {
+                r2 = fns.ms2mrc(d2.ms);
+              }
+              d2.mrc = r2;
+              if (fns.selectedSizeFn) {
+                r2 = d2.mrc = fns.selectedSizeFn(d2);
+              }
+              var x2 = drawing.symbolNumber(d2.mx || marker.symbol) || 0;
+              d2.om = x2 % 200 >= 100;
+              var angle2 = getMarkerAngle(d2, trace);
+              var standoff = getMarkerStandoff(d2, trace);
+              sel.attr("d", makePointPath(x2, r2, angle2, standoff));
+            }
+            var perPointGradient = false;
+            var fillColor, lineColor, lineWidth;
+            if (d2.so) {
+              lineWidth = markerLine.outlierwidth;
+              lineColor = markerLine.outliercolor;
+              fillColor = marker.outliercolor;
+            } else {
+              var markerLineWidth = (markerLine || {}).width;
+              lineWidth = (d2.mlw + 1 || markerLineWidth + 1 || // TODO: we need the latter for legends... can we get rid of it?
+              (d2.trace ? (d2.trace.marker.line || {}).width : 0) + 1) - 1 || 0;
+              if ("mlc" in d2) lineColor = d2.mlcc = fns.lineScale(d2.mlc);
+              else if (Lib.isArrayOrTypedArray(markerLine.color)) lineColor = Color2.defaultLine;
+              else lineColor = markerLine.color;
+              if (Lib.isArrayOrTypedArray(marker.color)) {
+                fillColor = Color2.defaultLine;
+                perPointGradient = true;
+              }
+              if ("mc" in d2) {
+                fillColor = d2.mcc = fns.markerScale(d2.mc);
+              } else {
+                fillColor = marker.color || marker.colors || "rgba(0,0,0,0)";
+              }
+              if (fns.selectedColorFn) {
+                fillColor = fns.selectedColorFn(d2);
+              }
+            }
+            const lineDash = d2.mld || (markerLine || {}).dash;
+            if (lineDash) drawing.dashLine(sel, lineDash, lineWidth);
+            if (d2.om) {
+              sel.call(Color2.stroke, fillColor).style({
+                "stroke-width": (lineWidth || 1) + "px",
+                fill: "none"
+              });
+            } else {
+              sel.style("stroke-width", (d2.isBlank ? 0 : lineWidth) + "px");
+              var markerGradient = marker.gradient;
+              var gradientType = d2.mgt;
+              if (gradientType) perPointGradient = true;
+              else gradientType = markerGradient && markerGradient.type;
+              if (Lib.isArrayOrTypedArray(gradientType)) {
+                gradientType = gradientType[0];
+                if (!gradientInfo[gradientType]) gradientType = 0;
+              }
+              var markerPattern = marker.pattern;
+              var pAttr = drawing.getPatternAttr;
+              var patternShape = markerPattern && (pAttr(markerPattern.shape, d2.i, "") || pAttr(markerPattern.path, d2.i, ""));
+              if (gradientType && gradientType !== "none") {
+                var gradientColor = d2.mgc;
+                if (gradientColor) perPointGradient = true;
+                else gradientColor = markerGradient.color;
+                var gradientID = trace.uid;
+                if (perPointGradient) gradientID += "-" + d2.i;
+                drawing.gradient(
+                  sel,
+                  gd2,
+                  gradientID,
+                  gradientType,
+                  [
+                    [0, gradientColor],
+                    [1, fillColor]
+                  ],
+                  "fill"
+                );
+              } else if (patternShape) {
+                var perPointPattern = false;
+                var fgcolor = markerPattern.fgcolor;
+                if (!fgcolor && pt2 && pt2.color) {
+                  fgcolor = pt2.color;
+                  perPointPattern = true;
+                }
+                var patternFGColor = pAttr(fgcolor, d2.i, pt2 && pt2.color || null);
+                var patternBGColor = pAttr(markerPattern.bgcolor, d2.i, null);
+                var patternFGOpacity = markerPattern.fgopacity;
+                var patternSize = pAttr(markerPattern.size, d2.i, 8);
+                var patternSolidity = pAttr(markerPattern.solidity, d2.i, 0.3);
+                perPointPattern = perPointPattern || d2.mcc || Lib.isArrayOrTypedArray(markerPattern.shape) || Lib.isArrayOrTypedArray(markerPattern.path) || Lib.isArrayOrTypedArray(markerPattern.bgcolor) || Lib.isArrayOrTypedArray(markerPattern.fgcolor) || Lib.isArrayOrTypedArray(markerPattern.size) || Lib.isArrayOrTypedArray(markerPattern.solidity);
+                var patternID = trace.uid;
+                if (perPointPattern) patternID += "-" + d2.i;
+                drawing.pattern(
+                  sel,
+                  "point",
+                  gd2,
+                  patternID,
+                  patternShape,
+                  patternSize,
+                  patternSolidity,
+                  d2.mcc,
+                  markerPattern.fillmode,
+                  patternBGColor,
+                  patternFGColor,
+                  patternFGOpacity
+                );
+              } else {
+                Lib.isArrayOrTypedArray(fillColor) ? Color2.fill(sel, fillColor[d2.i]) : Color2.fill(sel, fillColor);
+              }
+              if (lineWidth) {
+                Color2.stroke(sel, lineColor);
+              }
+            }
+          };
+          drawing.makePointStyleFns = function(trace) {
+            var out = {};
+            var marker = trace.marker;
+            out.markerScale = drawing.tryColorscale(marker, "");
+            out.lineScale = drawing.tryColorscale(marker, "line");
+            if (Registry.traceIs(trace, "symbols")) {
+              out.ms2mrc = subTypes.isBubble(trace) ? makeBubbleSizeFn(trace) : function() {
+                return (marker.size || 6) / 2;
+              };
+            }
+            if (trace.selectedpoints) {
+              Lib.extendFlat(out, drawing.makeSelectedPointStyleFns(trace));
+            }
+            return out;
+          };
+          drawing.makeSelectedPointStyleFns = function(trace) {
+            var out = {};
+            var selectedAttrs = trace.selected || {};
+            var unselectedAttrs = trace.unselected || {};
+            var marker = trace.marker || {};
+            var selectedMarker = selectedAttrs.marker || {};
+            var unselectedMarker = unselectedAttrs.marker || {};
+            var mo = marker.opacity;
+            var smo = selectedMarker.opacity;
+            var usmo = unselectedMarker.opacity;
+            var smoIsDefined = smo !== void 0;
+            var usmoIsDefined = usmo !== void 0;
+            if (Lib.isArrayOrTypedArray(mo) || smoIsDefined || usmoIsDefined) {
+              out.selectedOpacityFn = function(d2) {
+                var base = d2.mo === void 0 ? marker.opacity : d2.mo;
+                if (d2.selected) {
+                  return smoIsDefined ? smo : base;
+                } else {
+                  return usmoIsDefined ? usmo : DESELECTDIM * base;
+                }
+              };
+            }
+            var mc2 = marker.color;
+            var smc = selectedMarker.color;
+            var usmc = unselectedMarker.color;
+            if (smc || usmc) {
+              out.selectedColorFn = function(d2) {
+                var base = d2.mcc || mc2;
+                if (d2.selected) {
+                  return smc || base;
+                } else {
+                  return usmc || base;
+                }
+              };
+            }
+            var ms = marker.size;
+            var sms = selectedMarker.size;
+            var usms = unselectedMarker.size;
+            var smsIsDefined = sms !== void 0;
+            var usmsIsDefined = usms !== void 0;
+            if (Registry.traceIs(trace, "symbols") && (smsIsDefined || usmsIsDefined)) {
+              out.selectedSizeFn = function(d2) {
+                var base = d2.mrc || ms / 2;
+                if (d2.selected) {
+                  return smsIsDefined ? sms / 2 : base;
+                } else {
+                  return usmsIsDefined ? usms / 2 : base;
+                }
+              };
+            }
+            return out;
+          };
+          drawing.makeSelectedTextStyleFns = function(trace) {
+            var out = {};
+            var selectedAttrs = trace.selected || {};
+            var unselectedAttrs = trace.unselected || {};
+            var textFont = trace.textfont || {};
+            var selectedTextFont = selectedAttrs.textfont || {};
+            var unselectedTextFont = unselectedAttrs.textfont || {};
+            var tc2 = textFont.color;
+            var stc = selectedTextFont.color;
+            var utc = unselectedTextFont.color;
+            out.selectedTextColorFn = function(d2) {
+              var base = d2.tc || tc2;
+              if (d2.selected) {
+                return stc || base;
+              } else {
+                if (utc) return utc;
+                else return stc ? base : Color2.addOpacity(base, DESELECTDIM);
+              }
+            };
+            return out;
+          };
+          drawing.selectedPointStyle = function(s2, trace) {
+            if (!s2.size() || !trace.selectedpoints) return;
+            var fns = drawing.makeSelectedPointStyleFns(trace);
+            var marker = trace.marker || {};
+            var seq = [];
+            if (fns.selectedOpacityFn) {
+              seq.push(function(pt2, d2) {
+                pt2.style("opacity", fns.selectedOpacityFn(d2));
+              });
+            }
+            if (fns.selectedColorFn) {
+              seq.push(function(pt2, d2) {
+                Color2.fill(pt2, fns.selectedColorFn(d2));
+              });
+            }
+            if (fns.selectedSizeFn) {
+              seq.push(function(pt2, d2) {
+                var mx = d2.mx || marker.symbol || 0;
+                var mrc2 = fns.selectedSizeFn(d2);
+                pt2.attr(
+                  "d",
+                  makePointPath(drawing.symbolNumber(mx), mrc2, getMarkerAngle(d2, trace), getMarkerStandoff(d2, trace))
+                );
+                d2.mrc2 = mrc2;
+              });
+            }
+            if (seq.length) {
+              s2.each(function(d2) {
+                var pt2 = d3.select(this);
+                for (var i2 = 0; i2 < seq.length; i2++) {
+                  seq[i2](pt2, d2);
+                }
+              });
+            }
+          };
+          drawing.tryColorscale = function(marker, prefix) {
+            var cont = prefix ? Lib.nestedProperty(marker, prefix).get() : marker;
+            if (cont) {
+              var colorArray = cont.color;
+              if ((cont.colorscale || cont._colorAx) && Lib.isArrayOrTypedArray(colorArray)) {
+                return Colorscale.makeColorScaleFuncFromTrace(cont);
+              }
+            }
+            return Lib.identity;
+          };
+          var TEXTOFFSETSIGN = {
+            start: 1,
+            end: -1,
+            middle: 0,
+            bottom: 1,
+            top: -1
+          };
+          function textPointPosition(s2, textPosition, fontSize, markerRadius, dontTouchParent) {
+            var group = d3.select(s2.node().parentNode);
+            var v2 = textPosition.indexOf("top") !== -1 ? "top" : textPosition.indexOf("bottom") !== -1 ? "bottom" : "middle";
+            var h2 = textPosition.indexOf("left") !== -1 ? "end" : textPosition.indexOf("right") !== -1 ? "start" : "middle";
+            var r2 = markerRadius ? markerRadius / 0.8 + 1 : 0;
+            var numLines = (svgTextUtils.lineCount(s2) - 1) * LINE_SPACING + 1;
+            var dx = TEXTOFFSETSIGN[h2] * r2;
+            var dy = fontSize * 0.75 + TEXTOFFSETSIGN[v2] * r2 + (TEXTOFFSETSIGN[v2] - 1) * numLines * fontSize / 2;
+            s2.attr("text-anchor", h2);
+            if (!dontTouchParent) {
+              group.attr("transform", strTranslate(dx, dy));
+            }
+          }
+          function extracTextFontSize(d2, trace) {
+            var fontSize = d2.ts || trace.textfont.size;
+            return isNumeric(fontSize) && fontSize > 0 ? fontSize : 0;
+          }
+          drawing.textPointStyle = function(s2, trace, gd2) {
+            if (!s2.size()) return;
+            var selectedTextColorFn;
+            if (trace.selectedpoints) {
+              var fns = drawing.makeSelectedTextStyleFns(trace);
+              selectedTextColorFn = fns.selectedTextColorFn;
+            }
+            var texttemplate = trace.texttemplate;
+            var fullLayout = gd2._fullLayout;
+            s2.each(function(d2) {
+              var p2 = d3.select(this);
+              var text = texttemplate ? Lib.extractOption(d2, trace, "txt", "texttemplate") : Lib.extractOption(d2, trace, "tx", "text");
+              if (!text && text !== 0) {
+                p2.remove();
+                return;
+              }
+              if (texttemplate) {
+                var fn = trace._module.formatLabels;
+                var labels = fn ? fn(d2, trace, fullLayout) : {};
+                var pointValues = {};
+                appendArrayPointValue(pointValues, trace, d2.i);
+                text = Lib.texttemplateString({
+                  data: [pointValues, d2, trace._meta],
+                  fallback: trace.texttemplatefallback,
+                  labels,
+                  locale: fullLayout._d3locale,
+                  template: text
+                });
+              }
+              var pos = d2.tp || trace.textposition;
+              var fontSize = extracTextFontSize(d2, trace);
+              var fontColor = selectedTextColorFn ? selectedTextColorFn(d2) : d2.tc || trace.textfont.color;
+              p2.call(drawing.font, {
+                family: d2.tf || trace.textfont.family,
+                weight: d2.tw || trace.textfont.weight,
+                style: d2.ty || trace.textfont.style,
+                variant: d2.tv || trace.textfont.variant,
+                textcase: d2.tC || trace.textfont.textcase,
+                lineposition: d2.tE || trace.textfont.lineposition,
+                shadow: d2.tS || trace.textfont.shadow,
+                size: fontSize,
+                color: fontColor
+              }).text(text).call(svgTextUtils.convertToTspans, gd2).call(textPointPosition, pos, fontSize, d2.mrc);
+            });
+          };
+          drawing.selectedTextStyle = function(s2, trace) {
+            if (!s2.size() || !trace.selectedpoints) return;
+            var fns = drawing.makeSelectedTextStyleFns(trace);
+            s2.each(function(d2) {
+              var tx = d3.select(this);
+              var tc2 = fns.selectedTextColorFn(d2);
+              var tp = d2.tp || trace.textposition;
+              var fontSize = extracTextFontSize(d2, trace);
+              Color2.fill(tx, tc2);
+              var dontTouchParent = Registry.traceIs(trace, "bar-like");
+              textPointPosition(tx, tp, fontSize, d2.mrc2 || d2.mrc, dontTouchParent);
+            });
+          };
+          var CatmullRomExp = 0.5;
+          drawing.smoothopen = function(pts, smoothness) {
+            if (pts.length < 3) {
+              return "M" + pts.join("L");
+            }
+            var path = "M" + pts[0];
+            var tangents = [];
+            var i2;
+            for (i2 = 1; i2 < pts.length - 1; i2++) {
+              tangents.push(makeTangent(pts[i2 - 1], pts[i2], pts[i2 + 1], smoothness));
+            }
+            path += "Q" + tangents[0][0] + " " + pts[1];
+            for (i2 = 2; i2 < pts.length - 1; i2++) {
+              path += "C" + tangents[i2 - 2][1] + " " + tangents[i2 - 1][0] + " " + pts[i2];
+            }
+            path += "Q" + tangents[pts.length - 3][1] + " " + pts[pts.length - 1];
+            return path;
+          };
+          drawing.smoothclosed = function(pts, smoothness) {
+            if (pts.length < 3) {
+              return "M" + pts.join("L") + "Z";
+            }
+            var path = "M" + pts[0];
+            var pLast = pts.length - 1;
+            var tangents = [makeTangent(pts[pLast], pts[0], pts[1], smoothness)];
+            var i2;
+            for (i2 = 1; i2 < pLast; i2++) {
+              tangents.push(makeTangent(pts[i2 - 1], pts[i2], pts[i2 + 1], smoothness));
+            }
+            tangents.push(makeTangent(pts[pLast - 1], pts[pLast], pts[0], smoothness));
+            for (i2 = 1; i2 <= pLast; i2++) {
+              path += "C" + tangents[i2 - 1][1] + " " + tangents[i2][0] + " " + pts[i2];
+            }
+            path += "C" + tangents[pLast][1] + " " + tangents[0][0] + " " + pts[0] + "Z";
+            return path;
+          };
+          var lastDrawnX;
+          var lastDrawnY;
+          function roundEnd(pt2, isY, isLastPoint) {
+            if (isLastPoint) pt2 = applyBackoff(pt2);
+            return isY ? roundY(pt2[1]) : roundX(pt2[0]);
+          }
+          function roundX(p2) {
+            var v2 = d3.round(p2, 2);
+            lastDrawnX = v2;
+            return v2;
+          }
+          function roundY(p2) {
+            var v2 = d3.round(p2, 2);
+            lastDrawnY = v2;
+            return v2;
+          }
+          function makeTangent(prevpt, thispt, nextpt, smoothness) {
+            var d1x = prevpt[0] - thispt[0];
+            var d1y = prevpt[1] - thispt[1];
+            var d2x = nextpt[0] - thispt[0];
+            var d2y = nextpt[1] - thispt[1];
+            var d1a = Math.pow(d1x * d1x + d1y * d1y, CatmullRomExp / 2);
+            var d2a = Math.pow(d2x * d2x + d2y * d2y, CatmullRomExp / 2);
+            var numx = (d2a * d2a * d1x - d1a * d1a * d2x) * smoothness;
+            var numy = (d2a * d2a * d1y - d1a * d1a * d2y) * smoothness;
+            var denom1 = 3 * d2a * (d1a + d2a);
+            var denom2 = 3 * d1a * (d1a + d2a);
+            return [
+              [roundX(thispt[0] + (denom1 && numx / denom1)), roundY(thispt[1] + (denom1 && numy / denom1))],
+              [roundX(thispt[0] - (denom2 && numx / denom2)), roundY(thispt[1] - (denom2 && numy / denom2))]
+            ];
+          }
+          var STEPPATH = {
+            hv: function(p0, p1, isLastPoint) {
+              return "H" + roundX(p1[0]) + "V" + roundEnd(p1, 1, isLastPoint);
+            },
+            vh: function(p0, p1, isLastPoint) {
+              return "V" + roundY(p1[1]) + "H" + roundEnd(p1, 0, isLastPoint);
+            },
+            hvh: function(p0, p1, isLastPoint) {
+              return "H" + roundX((p0[0] + p1[0]) / 2) + "V" + roundY(p1[1]) + "H" + roundEnd(p1, 0, isLastPoint);
+            },
+            vhv: function(p0, p1, isLastPoint) {
+              return "V" + roundY((p0[1] + p1[1]) / 2) + "H" + roundX(p1[0]) + "V" + roundEnd(p1, 1, isLastPoint);
+            }
+          };
+          var STEPLINEAR = function(p0, p1, isLastPoint) {
+            return "L" + roundEnd(p1, 0, isLastPoint) + "," + roundEnd(p1, 1, isLastPoint);
+          };
+          drawing.steps = function(shape) {
+            var onestep = STEPPATH[shape] || STEPLINEAR;
+            return function(pts) {
+              var path = "M" + roundX(pts[0][0]) + "," + roundY(pts[0][1]);
+              var len2 = pts.length;
+              for (var i2 = 1; i2 < len2; i2++) {
+                path += onestep(pts[i2 - 1], pts[i2], i2 === len2 - 1);
+              }
+              return path;
+            };
+          };
+          function applyBackoff(pt2, start) {
+            var backoff = pt2.backoff;
+            var trace = pt2.trace;
+            var d2 = pt2.d;
+            var i2 = pt2.i;
+            if (backoff && trace && trace.marker && trace.marker.angle % 360 === 0 && trace.line && trace.line.shape !== "spline") {
+              var arrayBackoff = Lib.isArrayOrTypedArray(backoff);
+              var end = pt2;
+              var x1 = start ? start[0] : lastDrawnX || 0;
+              var y1 = start ? start[1] : lastDrawnY || 0;
+              var x2 = end[0];
+              var y2 = end[1];
+              var dx = x2 - x1;
+              var dy = y2 - y1;
+              var t4 = Math.atan2(dy, dx);
+              var b2 = arrayBackoff ? backoff[i2] : backoff;
+              if (b2 === "auto") {
+                var endI = end.i;
+                if (trace.type === "scatter") endI--;
+                var endMarker = end.marker;
+                var endMarkerSymbol = endMarker.symbol;
+                if (Lib.isArrayOrTypedArray(endMarkerSymbol)) endMarkerSymbol = endMarkerSymbol[endI];
+                var endMarkerSize = endMarker.size;
+                if (Lib.isArrayOrTypedArray(endMarkerSize)) endMarkerSize = endMarkerSize[endI];
+                b2 = endMarker ? drawing.symbolBackOffs[drawing.symbolNumber(endMarkerSymbol)] * endMarkerSize : 0;
+                b2 += drawing.getMarkerStandoff(d2[endI], trace) || 0;
+              }
+              var x3 = x2 - b2 * Math.cos(t4);
+              var y3 = y2 - b2 * Math.sin(t4);
+              if ((x3 <= x2 && x3 >= x1 || x3 >= x2 && x3 <= x1) && (y3 <= y2 && y3 >= y1 || y3 >= y2 && y3 <= y1)) {
+                pt2 = [x3, y3];
+              }
+            }
+            return pt2;
+          }
+          drawing.applyBackoff = applyBackoff;
+          drawing.makeTester = function() {
+            var tester = Lib.ensureSingleById(d3.select("body"), "svg", "js-plotly-tester", function(s2) {
+              s2.attr(xmlnsNamespaces.svgAttrs).style({
+                position: "absolute",
+                left: "-10000px",
+                top: "-10000px",
+                width: "9000px",
+                height: "9000px",
+                "z-index": "1"
+              });
+            });
+            var testref = Lib.ensureSingle(tester, "path", "js-reference-point", function(s2) {
+              s2.attr("d", "M0,0H1V1H0Z").style({
+                "stroke-width": 0,
+                fill: "black"
+              });
+            });
+            drawing.tester = tester;
+            drawing.testref = testref;
+          };
+          drawing.savedBBoxes = {};
+          var savedBBoxesCount = 0;
+          var maxSavedBBoxes = 1e4;
+          drawing.bBox = function(node, inTester, hash) {
+            if (!hash) hash = nodeHash(node);
+            var out;
+            if (hash) {
+              out = drawing.savedBBoxes[hash];
+              if (out) return Lib.extendFlat({}, out);
+            } else if (node.childNodes.length === 1) {
+              var innerNode = node.childNodes[0];
+              hash = nodeHash(innerNode);
+              if (hash) {
+                var x2 = +innerNode.getAttribute("x") || 0;
+                var y2 = +innerNode.getAttribute("y") || 0;
+                var transform = innerNode.getAttribute("transform");
+                if (!transform) {
+                  var innerBB = drawing.bBox(innerNode, false, hash);
+                  if (x2) {
+                    innerBB.left += x2;
+                    innerBB.right += x2;
+                  }
+                  if (y2) {
+                    innerBB.top += y2;
+                    innerBB.bottom += y2;
+                  }
+                  return innerBB;
+                }
+                hash += "~" + x2 + "~" + y2 + "~" + transform;
+                out = drawing.savedBBoxes[hash];
+                if (out) return Lib.extendFlat({}, out);
+              }
+            }
+            var testNode, tester;
+            if (inTester) {
+              testNode = node;
+            } else {
+              tester = drawing.tester.node();
+              testNode = node.cloneNode(true);
+              tester.appendChild(testNode);
+            }
+            d3.select(testNode).attr("transform", null).call(svgTextUtils.positionText, 0, 0);
+            var testRect = testNode.getBoundingClientRect();
+            var refRect = drawing.testref.node().getBoundingClientRect();
+            if (!inTester) tester.removeChild(testNode);
+            var bb2 = {
+              height: testRect.height,
+              width: testRect.width,
+              left: testRect.left - refRect.left,
+              top: testRect.top - refRect.top,
+              right: testRect.right - refRect.left,
+              bottom: testRect.bottom - refRect.top
+            };
+            if (savedBBoxesCount >= maxSavedBBoxes) {
+              drawing.savedBBoxes = {};
+              savedBBoxesCount = 0;
+            }
+            if (hash) drawing.savedBBoxes[hash] = bb2;
+            savedBBoxesCount++;
+            return Lib.extendFlat({}, bb2);
+          };
+          function nodeHash(node) {
+            var inputText = node.getAttribute("data-unformatted");
+            if (inputText === null) return;
+            return inputText + node.getAttribute("data-math") + node.getAttribute("text-anchor") + node.getAttribute("style");
+          }
+          drawing.setClipUrl = function(s2, localId, gd2) {
+            s2.attr("clip-path", getFullUrl(localId, gd2));
+          };
+          function getFullUrl(localId, gd2) {
+            if (!localId) return null;
+            var context = gd2._context;
+            var baseUrl = context._exportedPlot ? "" : context._baseUrl || "";
+            return baseUrl ? "url('" + baseUrl + "#" + localId + "')" : "url(#" + localId + ")";
+          }
+          drawing.getTranslate = function(element) {
+            var re2 = /.*\btranslate\((-?\d*\.?\d*)[^-\d]*(-?\d*\.?\d*)[^\d].*/;
+            var getter = element.attr ? "attr" : "getAttribute";
+            var transform = element[getter]("transform") || "";
+            var translate2 = transform.replace(re2, function(match, p1, p2) {
+              return [p1, p2].join(" ");
+            }).split(" ");
+            return {
+              x: +translate2[0] || 0,
+              y: +translate2[1] || 0
+            };
+          };
+          drawing.setTranslate = function(element, x2, y2) {
+            var re2 = /(\btranslate\(.*?\);?)/;
+            var getter = element.attr ? "attr" : "getAttribute";
+            var setter = element.attr ? "attr" : "setAttribute";
+            var transform = element[getter]("transform") || "";
+            x2 = x2 || 0;
+            y2 = y2 || 0;
+            transform = transform.replace(re2, "").trim();
+            transform += strTranslate(x2, y2);
+            transform = transform.trim();
+            element[setter]("transform", transform);
+            return transform;
+          };
+          drawing.getScale = function(element) {
+            var re2 = /.*\bscale\((\d*\.?\d*)[^\d]*(\d*\.?\d*)[^\d].*/;
+            var getter = element.attr ? "attr" : "getAttribute";
+            var transform = element[getter]("transform") || "";
+            var translate2 = transform.replace(re2, function(match, p1, p2) {
+              return [p1, p2].join(" ");
+            }).split(" ");
+            return {
+              x: +translate2[0] || 1,
+              y: +translate2[1] || 1
+            };
+          };
+          drawing.setScale = function(element, x2, y2) {
+            var re2 = /(\bscale\(.*?\);?)/;
+            var getter = element.attr ? "attr" : "getAttribute";
+            var setter = element.attr ? "attr" : "setAttribute";
+            var transform = element[getter]("transform") || "";
+            x2 = x2 || 1;
+            y2 = y2 || 1;
+            transform = transform.replace(re2, "").trim();
+            transform += "scale(" + x2 + "," + y2 + ")";
+            transform = transform.trim();
+            element[setter]("transform", transform);
+            return transform;
+          };
+          var SCALE_RE = /\s*sc.*/;
+          drawing.setPointGroupScale = function(selection, xScale, yScale) {
+            xScale = xScale || 1;
+            yScale = yScale || 1;
+            if (!selection) return;
+            var scale2 = xScale === 1 && yScale === 1 ? "" : "scale(" + xScale + "," + yScale + ")";
+            selection.each(function() {
+              var t4 = (this.getAttribute("transform") || "").replace(SCALE_RE, "");
+              t4 += scale2;
+              t4 = t4.trim();
+              this.setAttribute("transform", t4);
+            });
+          };
+          var TEXT_POINT_LAST_TRANSLATION_RE = /translate\([^)]*\)\s*$/;
+          drawing.setTextPointsScale = function(selection, xScale, yScale) {
+            if (!selection) return;
+            selection.each(function() {
+              var transforms;
+              var el2 = d3.select(this);
+              var text = el2.select("text");
+              if (!text.node()) return;
+              var x2 = parseFloat(text.attr("x") || 0);
+              var y2 = parseFloat(text.attr("y") || 0);
+              var existingTransform = (el2.attr("transform") || "").match(TEXT_POINT_LAST_TRANSLATION_RE);
+              if (xScale === 1 && yScale === 1) {
+                transforms = [];
+              } else {
+                transforms = [strTranslate(x2, y2), "scale(" + xScale + "," + yScale + ")", strTranslate(-x2, -y2)];
+              }
+              if (existingTransform) {
+                transforms.push(existingTransform);
+              }
+              el2.attr("transform", transforms.join(""));
+            });
+          };
+          function getMarkerStandoff(d2, trace) {
+            var standoff;
+            if (d2) standoff = d2.mf;
+            if (standoff === void 0) {
+              standoff = trace.marker ? trace.marker.standoff || 0 : 0;
+            }
+            if (!trace._geo && !trace._xA) {
+              return -standoff;
+            }
+            return standoff;
+          }
+          drawing.getMarkerStandoff = getMarkerStandoff;
+          var atan2 = Math.atan2;
+          var cos = Math.cos;
+          var sin = Math.sin;
+          function rotate2(t4, xy) {
+            var x2 = xy[0];
+            var y2 = xy[1];
+            return [x2 * cos(t4) - y2 * sin(t4), x2 * sin(t4) + y2 * cos(t4)];
+          }
+          var previousLon;
+          var previousLat;
+          var previousX;
+          var previousY;
+          var previousI;
+          var previousTraceUid;
+          function getMarkerAngle(d2, trace) {
+            var angle2 = d2.ma;
+            if (angle2 === void 0) {
+              angle2 = trace.marker.angle;
+              if (!angle2 || Lib.isArrayOrTypedArray(angle2)) {
+                angle2 = 0;
+              }
+            }
+            var x2, y2;
+            var ref = trace.marker.angleref;
+            if (ref === "previous" || ref === "north") {
+              if (trace._geo) {
+                var p2 = trace._geo.project(d2.lonlat);
+                x2 = p2[0];
+                y2 = p2[1];
+              } else {
+                var xa = trace._xA;
+                var ya2 = trace._yA;
+                if (xa && ya2) {
+                  x2 = xa.c2p(d2.x);
+                  y2 = ya2.c2p(d2.y);
+                } else {
+                  return 90;
+                }
+              }
+              if (trace._geo) {
+                var lon = d2.lonlat[0];
+                var lat = d2.lonlat[1];
+                var north = trace._geo.project([
+                  lon,
+                  lat + 1e-5
+                  // epsilon
+                ]);
+                var east = trace._geo.project([
+                  lon + 1e-5,
+                  // epsilon
+                  lat
+                ]);
+                var u2 = atan2(east[1] - y2, east[0] - x2);
+                var v2 = atan2(north[1] - y2, north[0] - x2);
+                var t4;
+                if (ref === "north") {
+                  t4 = angle2 / 180 * Math.PI;
+                } else if (ref === "previous") {
+                  var lon1 = lon / 180 * Math.PI;
+                  var lat1 = lat / 180 * Math.PI;
+                  var lon2 = previousLon / 180 * Math.PI;
+                  var lat2 = previousLat / 180 * Math.PI;
+                  var dLon = lon2 - lon1;
+                  var deltaY = cos(lat2) * sin(dLon);
+                  var deltaX = sin(lat2) * cos(lat1) - cos(lat2) * sin(lat1) * cos(dLon);
+                  t4 = -atan2(deltaY, deltaX) - Math.PI;
+                  previousLon = lon;
+                  previousLat = lat;
+                }
+                var A22 = rotate2(u2, [cos(t4), 0]);
+                var B22 = rotate2(v2, [sin(t4), 0]);
+                angle2 = atan2(A22[1] + B22[1], A22[0] + B22[0]) / Math.PI * 180;
+                if (ref === "previous" && !(previousTraceUid === trace.uid && d2.i === previousI + 1)) {
+                  angle2 = null;
+                }
+              }
+              if (ref === "previous" && !trace._geo) {
+                if (previousTraceUid === trace.uid && d2.i === previousI + 1 && isNumeric(x2) && isNumeric(y2)) {
+                  var dX = x2 - previousX;
+                  var dY = y2 - previousY;
+                  var shape = trace.line ? trace.line.shape || "" : "";
+                  var lastShapeChar = shape.slice(shape.length - 1);
+                  if (lastShapeChar === "h") dY = 0;
+                  if (lastShapeChar === "v") dX = 0;
+                  angle2 += atan2(dY, dX) / Math.PI * 180 + 90;
+                } else {
+                  angle2 = null;
+                }
+              }
+            }
+            previousX = x2;
+            previousY = y2;
+            previousI = d2.i;
+            previousTraceUid = trace.uid;
+            return angle2;
+          }
+          drawing.getMarkerAngle = getMarkerAngle;
+        }
+      });
+      var require_titles = __commonJS({
+        "src/components/titles/index.js"(exports, module2) {
+          var d3 = require_d3();
+          var isNumeric = require_fast_isnumeric();
+          var Plots = require_plots();
+          var Registry = require_registry();
+          var Lib = require_lib();
+          var strTranslate = Lib.strTranslate;
+          var Drawing = require_drawing();
+          var Color2 = require_color();
+          var svgTextUtils = require_svg_text_utils();
+          var interactConstants = require_interactions();
+          var OPPOSITE_SIDE = require_alignment().OPPOSITE_SIDE;
+          var numStripRE = / [XY][0-9]* /;
+          var SUBTITLE_PADDING_MATHJAX_EM = 1.6;
+          var SUBTITLE_PADDING_EM = 1.6;
+          function draw(gd2, titleClass, options) {
+            var fullLayout = gd2._fullLayout;
+            var cont = options.propContainer;
+            var prop = options.propName;
+            var placeholder = options.placeholder;
+            var traceIndex = options.traceIndex;
+            var avoid = options.avoid || {};
+            var attributes = options.attributes;
+            var transform = options.transform;
+            var group = options.containerGroup;
+            var opacity = 1;
+            var title = cont.title;
+            var txt = (title && title.text ? title.text : "").trim();
+            var titleIsPlaceholder = false;
+            var font = title && title.font ? title.font : {};
+            var fontFamily = font.family;
+            var fontSize = font.size;
+            var fontColor = font.color;
+            var fontWeight = font.weight;
+            var fontStyle = font.style;
+            var fontVariant = font.variant;
+            var fontTextcase = font.textcase;
+            var fontLineposition = font.lineposition;
+            var fontShadow = font.shadow;
+            var subtitleProp = options.subtitlePropName;
+            var subtitleEnabled = !!subtitleProp;
+            var subtitlePlaceholder = options.subtitlePlaceholder;
+            var subtitle = (cont.title || {}).subtitle || { text: "", font: {} };
+            var subtitleTxt = (subtitle.text || "").trim();
+            var subtitleIsPlaceholder = false;
+            var subtitleOpacity = 1;
+            var subtitleFont = subtitle.font;
+            var subFontFamily = subtitleFont.family;
+            var subFontSize = subtitleFont.size;
+            var subFontColor = subtitleFont.color;
+            var subFontWeight = subtitleFont.weight;
+            var subFontStyle = subtitleFont.style;
+            var subFontVariant = subtitleFont.variant;
+            var subFontTextcase = subtitleFont.textcase;
+            var subFontLineposition = subtitleFont.lineposition;
+            var subFontShadow = subtitleFont.shadow;
+            var editAttr;
+            if (prop === "title.text") editAttr = "titleText";
+            else if (prop.indexOf("axis") !== -1) editAttr = "axisTitleText";
+            else if (prop.indexOf("colorbar") !== -1) editAttr = "colorbarTitleText";
+            var editable = gd2._context.edits[editAttr];
+            function matchesPlaceholder(text, placeholder2) {
+              if (text === void 0 || placeholder2 === void 0) return false;
+              return text.replace(numStripRE, " % ") === placeholder2.replace(numStripRE, " % ");
+            }
+            if (txt === "") opacity = 0;
+            else if (matchesPlaceholder(txt, placeholder)) {
+              if (!editable) txt = "";
+              opacity = 0.2;
+              titleIsPlaceholder = true;
+            }
+            if (subtitleEnabled) {
+              if (subtitleTxt === "") subtitleOpacity = 0;
+              else if (matchesPlaceholder(subtitleTxt, subtitlePlaceholder)) {
+                if (!editable) subtitleTxt = "";
+                subtitleOpacity = 0.2;
+                subtitleIsPlaceholder = true;
+              }
+            }
+            if (options._meta) {
+              txt = Lib.templateString(txt, options._meta);
+            } else if (fullLayout._meta) {
+              txt = Lib.templateString(txt, fullLayout._meta);
+            }
+            var elShouldExist = txt || subtitleTxt || editable;
+            var hColorbarMoveTitle;
+            if (!group) {
+              group = Lib.ensureSingle(fullLayout._infolayer, "g", "g-" + titleClass);
+              hColorbarMoveTitle = fullLayout._hColorbarMoveTitle;
+            }
+            var el2 = group.selectAll("text." + titleClass).data(elShouldExist ? [0] : []);
+            el2.enter().append("text");
+            el2.text(txt).attr("class", titleClass);
+            el2.exit().remove();
+            var subtitleEl = null;
+            var subtitleClass = titleClass + "-subtitle";
+            var subtitleElShouldExist = subtitleTxt || editable;
+            if (subtitleEnabled) {
+              subtitleEl = group.selectAll("text." + subtitleClass).data(subtitleElShouldExist ? [0] : []);
+              subtitleEl.enter().append("text");
+              subtitleEl.text(subtitleTxt).attr("class", subtitleClass);
+              subtitleEl.exit().remove();
+            }
+            if (!elShouldExist) return group;
+            function titleLayout(titleEl, subtitleEl2) {
+              Lib.syncOrAsync([drawTitle, scootTitle], { title: titleEl, subtitle: subtitleEl2 });
+            }
+            function drawTitle(titleAndSubtitleEls) {
+              var titleEl = titleAndSubtitleEls.title;
+              var subtitleEl2 = titleAndSubtitleEls.subtitle;
+              var transformVal;
+              if (!transform && hColorbarMoveTitle) {
+                transform = {};
+              }
+              if (transform) {
+                transformVal = "";
+                if (transform.rotate) {
+                  transformVal += "rotate(" + [transform.rotate, attributes.x, attributes.y] + ")";
+                }
+                if (transform.offset || hColorbarMoveTitle) {
+                  transformVal += strTranslate(0, (transform.offset || 0) - (hColorbarMoveTitle || 0));
+                }
+              } else {
+                transformVal = null;
+              }
+              titleEl.attr("transform", transformVal);
+              function adjustSubtitlePosition(titleElMathGroup2) {
+                if (!titleElMathGroup2) return;
+                var subtitleElement = d3.select(titleElMathGroup2.node().parentNode).select("." + subtitleClass);
+                if (!subtitleElement.empty()) {
+                  var titleElMathBbox2 = titleElMathGroup2.node().getBBox();
+                  if (titleElMathBbox2.height) {
+                    var subtitleY3 = titleElMathBbox2.y + titleElMathBbox2.height + SUBTITLE_PADDING_MATHJAX_EM * subFontSize;
+                    subtitleElement.attr("y", subtitleY3);
+                  }
+                }
+              }
+              titleEl.style("opacity", opacity * Color2.opacity(fontColor)).call(Drawing.font, {
+                color: Color2.rgb(fontColor),
+                size: d3.round(fontSize, 2),
+                family: fontFamily,
+                weight: fontWeight,
+                style: fontStyle,
+                variant: fontVariant,
+                textcase: fontTextcase,
+                shadow: fontShadow,
+                lineposition: fontLineposition
+              }).attr(attributes).call(svgTextUtils.convertToTspans, gd2, adjustSubtitlePosition);
+              if (subtitleEl2 && !subtitleEl2.empty()) {
+                var titleElMathGroup = group.select("." + titleClass + "-math-group");
+                var titleElBbox2 = titleEl.node().getBBox();
+                var titleElMathBbox = titleElMathGroup.node() ? titleElMathGroup.node().getBBox() : void 0;
+                var subtitleY2 = titleElMathBbox ? titleElMathBbox.y + titleElMathBbox.height + SUBTITLE_PADDING_MATHJAX_EM * subFontSize : titleElBbox2.y + titleElBbox2.height + SUBTITLE_PADDING_EM * subFontSize;
+                var subtitleAttributes = Lib.extendFlat({}, attributes, {
+                  y: subtitleY2
+                });
+                subtitleEl2.attr("transform", transformVal);
+                subtitleEl2.style("opacity", subtitleOpacity * Color2.opacity(subFontColor)).call(Drawing.font, {
+                  color: Color2.rgb(subFontColor),
+                  size: d3.round(subFontSize, 2),
+                  family: subFontFamily,
+                  weight: subFontWeight,
+                  style: subFontStyle,
+                  variant: subFontVariant,
+                  textcase: subFontTextcase,
+                  shadow: subFontShadow,
+                  lineposition: subFontLineposition
+                }).attr(subtitleAttributes).call(svgTextUtils.convertToTspans, gd2);
+              }
+              return Plots.previousPromises(gd2);
+            }
+            function scootTitle(titleAndSubtitleEls) {
+              var titleElIn = titleAndSubtitleEls.title;
+              var titleGroup = d3.select(titleElIn.node().parentNode);
+              if (avoid && avoid.selection && avoid.side && txt) {
+                titleGroup.attr("transform", null);
+                var backside = OPPOSITE_SIDE[avoid.side];
+                var shiftSign = avoid.side === "left" || avoid.side === "top" ? -1 : 1;
+                var pad = isNumeric(avoid.pad) ? avoid.pad : 2;
+                var titlebb = Drawing.bBox(titleGroup.node());
+                var reservedMargins = { t: 0, b: 0, l: 0, r: 0 };
+                var margins = gd2._fullLayout._reservedMargin;
+                for (var key in margins) {
+                  for (var side in margins[key]) {
+                    var val = margins[key][side];
+                    reservedMargins[side] = Math.max(reservedMargins[side], val);
+                  }
+                }
+                var paperbb = {
+                  left: reservedMargins.l,
+                  top: reservedMargins.t,
+                  right: fullLayout.width - reservedMargins.r,
+                  bottom: fullLayout.height - reservedMargins.b
+                };
+                var maxshift = avoid.maxShift || shiftSign * (paperbb[avoid.side] - titlebb[avoid.side]);
+                var shift = 0;
+                if (maxshift < 0) {
+                  shift = maxshift;
+                } else {
+                  var offsetLeft = avoid.offsetLeft || 0;
+                  var offsetTop = avoid.offsetTop || 0;
+                  titlebb.left -= offsetLeft;
+                  titlebb.right -= offsetLeft;
+                  titlebb.top -= offsetTop;
+                  titlebb.bottom -= offsetTop;
+                  avoid.selection.each(function() {
+                    var avoidbb = Drawing.bBox(this);
+                    if (Lib.bBoxIntersect(titlebb, avoidbb, pad)) {
+                      shift = Math.max(shift, shiftSign * (avoidbb[avoid.side] - titlebb[backside]) + pad);
+                    }
+                  });
+                  shift = Math.min(maxshift, shift);
+                  cont._titleScoot = Math.abs(shift);
+                }
+                if (shift > 0 || maxshift < 0) {
+                  var shiftTemplate = {
+                    left: [-shift, 0],
+                    right: [shift, 0],
+                    top: [0, -shift],
+                    bottom: [0, shift]
+                  }[avoid.side];
+                  titleGroup.attr("transform", strTranslate(shiftTemplate[0], shiftTemplate[1]));
+                }
+              }
+            }
+            el2.call(titleLayout, subtitleEl);
+            function setPlaceholder(element, placeholderText) {
+              element.text(placeholderText).on("mouseover.opacity", function() {
+                d3.select(this).transition().duration(interactConstants.SHOW_PLACEHOLDER).style("opacity", 1);
+              }).on("mouseout.opacity", function() {
+                d3.select(this).transition().duration(interactConstants.HIDE_PLACEHOLDER).style("opacity", 0);
+              });
+            }
+            if (editable) {
+              if (!txt) {
+                setPlaceholder(el2, placeholder);
+                titleIsPlaceholder = true;
+              } else el2.on(".opacity", null);
+              el2.call(svgTextUtils.makeEditable, { gd: gd2 }).on("edit", function(text) {
+                if (traceIndex !== void 0) {
+                  Registry.call("_guiRestyle", gd2, prop, text, traceIndex);
+                } else {
+                  Registry.call("_guiRelayout", gd2, prop, text);
+                }
+              }).on("cancel", function() {
+                this.text(this.attr("data-unformatted")).call(titleLayout);
+              }).on("input", function(d2) {
+                this.text(d2 || " ").call(svgTextUtils.positionText, attributes.x, attributes.y);
+              });
+              if (subtitleEnabled) {
+                if (subtitleEnabled && !txt) {
+                  var titleElBbox = el2.node().getBBox();
+                  var subtitleY = titleElBbox.y + titleElBbox.height + SUBTITLE_PADDING_EM * subFontSize;
+                  subtitleEl.attr("y", subtitleY);
+                }
+                if (!subtitleTxt) {
+                  setPlaceholder(subtitleEl, subtitlePlaceholder);
+                  subtitleIsPlaceholder = true;
+                } else subtitleEl.on(".opacity", null);
+                subtitleEl.call(svgTextUtils.makeEditable, { gd: gd2 }).on("edit", function(text) {
+                  Registry.call("_guiRelayout", gd2, "title.subtitle.text", text);
+                }).on("cancel", function() {
+                  this.text(this.attr("data-unformatted")).call(titleLayout);
+                }).on("input", function(d2) {
+                  this.text(d2 || " ").call(svgTextUtils.positionText, subtitleEl.attr("x"), subtitleEl.attr("y"));
+                });
+              }
+            }
+            el2.classed("js-placeholder", titleIsPlaceholder);
+            if (subtitleEl && !subtitleEl.empty()) subtitleEl.classed("js-placeholder", subtitleIsPlaceholder);
+            return group;
+          }
+          module2.exports = {
+            draw,
+            SUBTITLE_PADDING_EM,
+            SUBTITLE_PADDING_MATHJAX_EM
+          };
+        }
+      });
+      var require_set_convert = __commonJS({
+        "src/plots/cartesian/set_convert.js"(exports, module2) {
+          var d3 = require_d3();
+          var utcFormat = require_d3_time_format().utcFormat;
+          var Lib = require_lib();
+          var numberFormat = Lib.numberFormat;
+          var isNumeric = require_fast_isnumeric();
+          var cleanNumber = Lib.cleanNumber;
+          var ms2DateTime = Lib.ms2DateTime;
+          var dateTime2ms = Lib.dateTime2ms;
+          var ensureNumber = Lib.ensureNumber;
+          var isArrayOrTypedArray = Lib.isArrayOrTypedArray;
+          var numConstants = require_numerical();
+          var FP_SAFE = numConstants.FP_SAFE;
+          var BADNUM = numConstants.BADNUM;
+          var LOG_CLIP = numConstants.LOG_CLIP;
+          var ONEWEEK = numConstants.ONEWEEK;
+          var ONEDAY = numConstants.ONEDAY;
+          var ONEHOUR = numConstants.ONEHOUR;
+          var ONEMIN = numConstants.ONEMIN;
+          var ONESEC = numConstants.ONESEC;
+          var axisIds = require_axis_ids();
+          var constants = require_constants2();
+          var HOUR_PATTERN = constants.HOUR_PATTERN;
+          var WEEKDAY_PATTERN = constants.WEEKDAY_PATTERN;
+          function fromLog(v2) {
+            return Math.pow(10, v2);
+          }
+          function isValidCategory(v2) {
+            return v2 !== null && v2 !== void 0;
+          }
+          module2.exports = function setConvert(ax, fullLayout) {
+            fullLayout = fullLayout || {};
+            var axId = ax._id || "x";
+            var axLetter = axId.charAt(0);
+            function toLog(v2, clip) {
+              if (v2 > 0) return Math.log(v2) / Math.LN10;
+              else if (v2 <= 0 && clip && ax.range && ax.range.length === 2) {
+                var r0 = ax.range[0];
+                var r1 = ax.range[1];
+                return 0.5 * (r0 + r1 - 2 * LOG_CLIP * Math.abs(r0 - r1));
+              } else return BADNUM;
+            }
+            function dt2ms(v2, _2, calendar, opts) {
+              if ((opts || {}).msUTC && isNumeric(v2)) {
+                return +v2;
+              }
+              var ms = dateTime2ms(v2, calendar || ax.calendar);
+              if (ms === BADNUM) {
+                if (isNumeric(v2)) {
+                  v2 = +v2;
+                  var msecTenths = Math.floor(Lib.mod(v2 + 0.05, 1) * 10);
+                  var msRounded = Math.round(v2 - msecTenths / 10);
+                  ms = dateTime2ms(new Date(msRounded)) + msecTenths / 10;
+                } else return BADNUM;
+              }
+              return ms;
+            }
+            function ms2dt(v2, r2, calendar) {
+              return ms2DateTime(v2, r2, calendar || ax.calendar);
+            }
+            function getCategoryName(v2) {
+              return ax._categories[Math.round(v2)];
+            }
+            function setCategoryIndex(v2) {
+              if (isValidCategory(v2)) {
+                if (ax._categoriesMap === void 0) {
+                  ax._categoriesMap = {};
+                }
+                if (ax._categoriesMap[v2] !== void 0) {
+                  return ax._categoriesMap[v2];
+                } else {
+                  ax._categories.push(typeof v2 === "number" ? String(v2) : v2);
+                  var curLength = ax._categories.length - 1;
+                  ax._categoriesMap[v2] = curLength;
+                  return curLength;
+                }
+              }
+              return BADNUM;
+            }
+            function setMultiCategoryIndex(arrayIn, len2) {
+              var arrayOut = new Array(len2);
+              for (var i2 = 0; i2 < len2; i2++) {
+                var v0 = (arrayIn[0] || [])[i2];
+                var v1 = (arrayIn[1] || [])[i2];
+                arrayOut[i2] = getCategoryIndex([v0, v1]);
+              }
+              return arrayOut;
+            }
+            function getCategoryIndex(v2) {
+              if (ax._categoriesMap) {
+                return ax._categoriesMap[v2];
+              }
+            }
+            function getCategoryPosition(v2) {
+              var index = getCategoryIndex(v2);
+              if (index !== void 0) return index;
+              if (isNumeric(v2)) return +v2;
+            }
+            function getRangePosition(v2) {
+              return isNumeric(v2) ? +v2 : getCategoryIndex(v2);
+            }
+            function _l2p(v2, m2, b2) {
+              return d3.round(b2 + m2 * v2, 2);
+            }
+            function _p2l(px, m2, b2) {
+              return (px - b2) / m2;
+            }
+            var l2p = function l2p2(v2) {
+              if (!isNumeric(v2)) return BADNUM;
+              return _l2p(v2, ax._m, ax._b);
+            };
+            var p2l = function(px) {
+              return _p2l(px, ax._m, ax._b);
+            };
+            if (ax.rangebreaks) {
+              var isY = axLetter === "y";
+              l2p = function(v2) {
+                if (!isNumeric(v2)) return BADNUM;
+                var len2 = ax._rangebreaks.length;
+                if (!len2) return _l2p(v2, ax._m, ax._b);
+                var flip = isY;
+                if (ax.range[0] > ax.range[1]) flip = !flip;
+                var signAx = flip ? -1 : 1;
+                var pos = signAx * v2;
+                var q2 = 0;
+                for (var i2 = 0; i2 < len2; i2++) {
+                  var min = signAx * ax._rangebreaks[i2].min;
+                  var max = signAx * ax._rangebreaks[i2].max;
+                  if (pos < min) break;
+                  if (pos > max) q2 = i2 + 1;
+                  else {
+                    q2 = pos < (min + max) / 2 ? i2 : i2 + 1;
+                    break;
+                  }
+                }
+                var b2 = ax._B[q2] || 0;
+                if (!isFinite(b2)) return 0;
+                return _l2p(v2, ax._m2, b2);
+              };
+              p2l = function(px) {
+                var len2 = ax._rangebreaks.length;
+                if (!len2) return _p2l(px, ax._m, ax._b);
+                var q2 = 0;
+                for (var i2 = 0; i2 < len2; i2++) {
+                  if (px < ax._rangebreaks[i2].pmin) break;
+                  if (px > ax._rangebreaks[i2].pmax) q2 = i2 + 1;
+                }
+                return _p2l(px, ax._m2, ax._B[q2]);
+              };
+            }
+            ax.c2l = ax.type === "log" ? toLog : ensureNumber;
+            ax.l2c = ax.type === "log" ? fromLog : ensureNumber;
+            ax.l2p = l2p;
+            ax.p2l = p2l;
+            ax.c2p = ax.type === "log" ? function(v2, clip) {
+              return l2p(toLog(v2, clip));
+            } : l2p;
+            ax.p2c = ax.type === "log" ? function(px) {
+              return fromLog(p2l(px));
+            } : p2l;
+            if (["linear", "-"].indexOf(ax.type) !== -1) {
+              ax.d2r = ax.r2d = ax.d2c = ax.r2c = ax.d2l = ax.r2l = cleanNumber;
+              ax.c2d = ax.c2r = ax.l2d = ax.l2r = ensureNumber;
+              ax.d2p = ax.r2p = function(v2) {
+                return ax.l2p(cleanNumber(v2));
+              };
+              ax.p2d = ax.p2r = p2l;
+              ax.cleanPos = ensureNumber;
+            } else if (ax.type === "log") {
+              ax.d2r = ax.d2l = function(v2, clip) {
+                return toLog(cleanNumber(v2), clip);
+              };
+              ax.r2d = ax.r2c = function(v2) {
+                return fromLog(cleanNumber(v2));
+              };
+              ax.d2c = ax.r2l = cleanNumber;
+              ax.c2d = ax.l2r = ensureNumber;
+              ax.c2r = toLog;
+              ax.l2d = fromLog;
+              ax.d2p = function(v2, clip) {
+                return ax.l2p(ax.d2r(v2, clip));
+              };
+              ax.p2d = function(px) {
+                return fromLog(p2l(px));
+              };
+              ax.r2p = function(v2) {
+                return ax.l2p(cleanNumber(v2));
+              };
+              ax.p2r = p2l;
+              ax.cleanPos = ensureNumber;
+            } else if (ax.type === "date") {
+              ax.d2r = ax.r2d = Lib.identity;
+              ax.d2c = ax.r2c = ax.d2l = ax.r2l = dt2ms;
+              ax.c2d = ax.c2r = ax.l2d = ax.l2r = ms2dt;
+              ax.d2p = ax.r2p = function(v2, _2, calendar) {
+                return ax.l2p(dt2ms(v2, 0, calendar));
+              };
+              ax.p2d = ax.p2r = function(px, r2, calendar) {
+                return ms2dt(p2l(px), r2, calendar);
+              };
+              ax.cleanPos = function(v2) {
+                return Lib.cleanDate(v2, BADNUM, ax.calendar);
+              };
+            } else if (ax.type === "category") {
+              ax.d2c = ax.d2l = setCategoryIndex;
+              ax.r2d = ax.c2d = ax.l2d = getCategoryName;
+              ax.d2r = ax.d2l_noadd = getCategoryPosition;
+              ax.r2c = function(v2) {
+                var index = getRangePosition(v2);
+                return index !== void 0 ? index : ax.fraction2r(0.5);
+              };
+              ax.l2r = ax.c2r = ensureNumber;
+              ax.r2l = getRangePosition;
+              ax.d2p = function(v2) {
+                return ax.l2p(ax.r2c(v2));
+              };
+              ax.p2d = function(px) {
+                return getCategoryName(p2l(px));
+              };
+              ax.r2p = ax.d2p;
+              ax.p2r = p2l;
+              ax.cleanPos = function(v2) {
+                if (typeof v2 === "string" && v2 !== "") return v2;
+                return ensureNumber(v2);
+              };
+            } else if (ax.type === "multicategory") {
+              ax.r2d = ax.c2d = ax.l2d = getCategoryName;
+              ax.d2r = ax.d2l_noadd = getCategoryPosition;
+              ax.r2c = function(v2) {
+                var index = getCategoryPosition(v2);
+                return index !== void 0 ? index : ax.fraction2r(0.5);
+              };
+              ax.r2c_just_indices = getCategoryIndex;
+              ax.l2r = ax.c2r = ensureNumber;
+              ax.r2l = getCategoryPosition;
+              ax.d2p = function(v2) {
+                return ax.l2p(ax.r2c(v2));
+              };
+              ax.p2d = function(px) {
+                return getCategoryName(p2l(px));
+              };
+              ax.r2p = ax.d2p;
+              ax.p2r = p2l;
+              ax.cleanPos = function(v2) {
+                if (Array.isArray(v2) || typeof v2 === "string" && v2 !== "") return v2;
+                return ensureNumber(v2);
+              };
+              ax.setupMultiCategory = function(fullData) {
+                var traceIndices = ax._traceIndices;
+                var i2, j2;
+                var group = ax._matchGroup;
+                if (group && ax._categories.length === 0) {
+                  for (var axId2 in group) {
+                    if (axId2 !== axId) {
+                      var ax2 = fullLayout[axisIds.id2name(axId2)];
+                      traceIndices = traceIndices.concat(ax2._traceIndices);
+                    }
+                  }
+                }
+                var seen2 = [[0, {}], [0, {}]];
+                var list = [];
+                for (i2 = 0; i2 < traceIndices.length; i2++) {
+                  var trace = fullData[traceIndices[i2]];
+                  if (axLetter in trace) {
+                    var arrayIn = trace[axLetter];
+                    var len2 = trace._length || Lib.minRowLength(arrayIn);
+                    if (isArrayOrTypedArray(arrayIn[0]) && isArrayOrTypedArray(arrayIn[1])) {
+                      for (j2 = 0; j2 < len2; j2++) {
+                        var v0 = arrayIn[0][j2];
+                        var v1 = arrayIn[1][j2];
+                        if (isValidCategory(v0) && isValidCategory(v1)) {
+                          list.push([v0, v1]);
+                          if (!(v0 in seen2[0][1])) {
+                            seen2[0][1][v0] = seen2[0][0]++;
+                          }
+                          if (!(v1 in seen2[1][1])) {
+                            seen2[1][1][v1] = seen2[1][0]++;
+                          }
+                        }
+                      }
+                    }
+                  }
+                }
+                list.sort(function(a2, b2) {
+                  var ind0 = seen2[0][1];
+                  var d2 = ind0[a2[0]] - ind0[b2[0]];
+                  if (d2) return d2;
+                  var ind1 = seen2[1][1];
+                  return ind1[a2[1]] - ind1[b2[1]];
+                });
+                for (i2 = 0; i2 < list.length; i2++) {
+                  setCategoryIndex(list[i2]);
+                }
+              };
+            }
+            ax.fraction2r = function(v2) {
+              var rl0 = ax.r2l(ax.range[0]);
+              var rl1 = ax.r2l(ax.range[1]);
+              return ax.l2r(rl0 + v2 * (rl1 - rl0));
+            };
+            ax.r2fraction = function(v2) {
+              var rl0 = ax.r2l(ax.range[0]);
+              var rl1 = ax.r2l(ax.range[1]);
+              return (ax.r2l(v2) - rl0) / (rl1 - rl0);
+            };
+            ax.limitRange = function(rangeAttr) {
+              var minallowed = ax.minallowed;
+              var maxallowed = ax.maxallowed;
+              if (minallowed === void 0 && maxallowed === void 0) return;
+              if (!rangeAttr) rangeAttr = "range";
+              var range = Lib.nestedProperty(ax, rangeAttr).get();
+              var rng = Lib.simpleMap(range, ax.r2l);
+              var axrev = rng[1] < rng[0];
+              if (axrev) rng.reverse();
+              var bounds = Lib.simpleMap([minallowed, maxallowed], ax.r2l);
+              if (minallowed !== void 0 && rng[0] < bounds[0]) range[axrev ? 1 : 0] = minallowed;
+              if (maxallowed !== void 0 && rng[1] > bounds[1]) range[axrev ? 0 : 1] = maxallowed;
+              if (range[0] === range[1]) {
+                var minL = ax.l2r(minallowed);
+                var maxL = ax.l2r(maxallowed);
+                if (minallowed !== void 0) {
+                  var _max = minL + 1;
+                  if (maxallowed !== void 0) _max = Math.min(_max, maxL);
+                  range[axrev ? 1 : 0] = _max;
+                }
+                if (maxallowed !== void 0) {
+                  var _min = maxL + 1;
+                  if (minallowed !== void 0) _min = Math.max(_min, minL);
+                  range[axrev ? 0 : 1] = _min;
+                }
+              }
+            };
+            ax.cleanRange = function(rangeAttr, opts) {
+              ax._cleanRange(rangeAttr, opts);
+              ax.limitRange(rangeAttr);
+            };
+            ax._cleanRange = function(rangeAttr, opts) {
+              if (!opts) opts = {};
+              if (!rangeAttr) rangeAttr = "range";
+              var range = Lib.nestedProperty(ax, rangeAttr).get();
+              var i2, dflt;
+              if (ax.type === "date") dflt = Lib.dfltRange(ax.calendar);
+              else if (axLetter === "y") dflt = constants.DFLTRANGEY;
+              else if (ax._name === "realaxis") dflt = [0, 1];
+              else dflt = opts.dfltRange || constants.DFLTRANGEX;
+              dflt = dflt.slice();
+              if (ax.rangemode === "tozero" || ax.rangemode === "nonnegative") {
+                dflt[0] = 0;
+              }
+              if (!range || range.length !== 2) {
+                Lib.nestedProperty(ax, rangeAttr).set(dflt);
+                return;
+              }
+              var nullRange0 = range[0] === null;
+              var nullRange1 = range[1] === null;
+              if (ax.type === "date" && !ax.autorange) {
+                range[0] = Lib.cleanDate(range[0], BADNUM, ax.calendar);
+                range[1] = Lib.cleanDate(range[1], BADNUM, ax.calendar);
+              }
+              for (i2 = 0; i2 < 2; i2++) {
+                if (ax.type === "date") {
+                  if (!Lib.isDateTime(range[i2], ax.calendar)) {
+                    ax[rangeAttr] = dflt;
+                    break;
+                  }
+                  if (ax.r2l(range[0]) === ax.r2l(range[1])) {
+                    var linCenter = Lib.constrain(
+                      ax.r2l(range[0]),
+                      Lib.MIN_MS + 1e3,
+                      Lib.MAX_MS - 1e3
+                    );
+                    range[0] = ax.l2r(linCenter - 1e3);
+                    range[1] = ax.l2r(linCenter + 1e3);
+                    break;
+                  }
+                } else {
+                  if (!isNumeric(range[i2])) {
+                    if (!(nullRange0 || nullRange1) && isNumeric(range[1 - i2])) {
+                      range[i2] = range[1 - i2] * (i2 ? 10 : 0.1);
+                    } else {
+                      ax[rangeAttr] = dflt;
+                      break;
+                    }
+                  }
+                  if (range[i2] < -FP_SAFE) range[i2] = -FP_SAFE;
+                  else if (range[i2] > FP_SAFE) range[i2] = FP_SAFE;
+                  if (range[0] === range[1]) {
+                    var inc = Math.max(1, Math.abs(range[0] * 1e-6));
+                    range[0] -= inc;
+                    range[1] += inc;
+                  }
+                }
+              }
+            };
+            ax.setScale = function(usePrivateRange) {
+              var gs = fullLayout._size;
+              if (ax.overlaying) {
+                var ax2 = axisIds.getFromId({ _fullLayout: fullLayout }, ax.overlaying);
+                ax.domain = ax2.domain;
+              }
+              var rangeAttr = usePrivateRange && ax._r ? "_r" : "range";
+              var calendar = ax.calendar;
+              ax.cleanRange(rangeAttr);
+              var rl0 = ax.r2l(ax[rangeAttr][0], calendar);
+              var rl1 = ax.r2l(ax[rangeAttr][1], calendar);
+              var isY2 = axLetter === "y";
+              if (isY2) {
+                ax._offset = gs.t + (1 - ax.domain[1]) * gs.h;
+                ax._length = gs.h * (ax.domain[1] - ax.domain[0]);
+                ax._m = ax._length / (rl0 - rl1);
+                ax._b = -ax._m * rl1;
+              } else {
+                ax._offset = gs.l + ax.domain[0] * gs.w;
+                ax._length = gs.w * (ax.domain[1] - ax.domain[0]);
+                ax._m = ax._length / (rl1 - rl0);
+                ax._b = -ax._m * rl0;
+              }
+              ax._rangebreaks = [];
+              ax._lBreaks = 0;
+              ax._m2 = 0;
+              ax._B = [];
+              if (ax.rangebreaks) {
+                var i2, brk;
+                ax._rangebreaks = ax.locateBreaks(
+                  Math.min(rl0, rl1),
+                  Math.max(rl0, rl1)
+                );
+                if (ax._rangebreaks.length) {
+                  for (i2 = 0; i2 < ax._rangebreaks.length; i2++) {
+                    brk = ax._rangebreaks[i2];
+                    ax._lBreaks += Math.abs(brk.max - brk.min);
+                  }
+                  var flip = isY2;
+                  if (rl0 > rl1) flip = !flip;
+                  if (flip) ax._rangebreaks.reverse();
+                  var sign = flip ? -1 : 1;
+                  ax._m2 = sign * ax._length / (Math.abs(rl1 - rl0) - ax._lBreaks);
+                  ax._B.push(-ax._m2 * (isY2 ? rl1 : rl0));
+                  for (i2 = 0; i2 < ax._rangebreaks.length; i2++) {
+                    brk = ax._rangebreaks[i2];
+                    ax._B.push(
+                      ax._B[ax._B.length - 1] - sign * ax._m2 * (brk.max - brk.min)
+                    );
+                  }
+                  for (i2 = 0; i2 < ax._rangebreaks.length; i2++) {
+                    brk = ax._rangebreaks[i2];
+                    brk.pmin = l2p(brk.min);
+                    brk.pmax = l2p(brk.max);
+                  }
+                }
+              }
+              if (!isFinite(ax._m) || !isFinite(ax._b) || ax._length < 0) {
+                fullLayout._replotting = false;
+                throw new Error("Something went wrong with axis scaling");
+              }
+            };
+            ax.maskBreaks = function(v2) {
+              var rangebreaksIn = ax.rangebreaks || [];
+              var bnds, b0, b1, vb2, vDate;
+              if (!rangebreaksIn._cachedPatterns) {
+                rangebreaksIn._cachedPatterns = rangebreaksIn.map(function(brk2) {
+                  return brk2.enabled && brk2.bounds ? Lib.simpleMap(
+                    brk2.bounds,
+                    brk2.pattern ? cleanNumber : ax.d2c
+                    // case of pattern: ''
+                  ) : null;
+                });
+              }
+              if (!rangebreaksIn._cachedValues) {
+                rangebreaksIn._cachedValues = rangebreaksIn.map(function(brk2) {
+                  return brk2.enabled && brk2.values ? Lib.simpleMap(brk2.values, ax.d2c).sort(Lib.sorterAsc) : null;
+                });
+              }
+              for (var i2 = 0; i2 < rangebreaksIn.length; i2++) {
+                var brk = rangebreaksIn[i2];
+                if (brk.enabled) {
+                  if (brk.bounds) {
+                    var pattern = brk.pattern;
+                    bnds = rangebreaksIn._cachedPatterns[i2];
+                    b0 = bnds[0];
+                    b1 = bnds[1];
+                    switch (pattern) {
+                      case WEEKDAY_PATTERN:
+                        vDate = new Date(v2);
+                        vb2 = vDate.getUTCDay();
+                        if (b0 > b1) {
+                          b1 += 7;
+                          if (vb2 < b0) vb2 += 7;
+                        }
+                        break;
+                      case HOUR_PATTERN:
+                        vDate = new Date(v2);
+                        var hours = vDate.getUTCHours();
+                        var minutes = vDate.getUTCMinutes();
+                        var seconds = vDate.getUTCSeconds();
+                        var milliseconds = vDate.getUTCMilliseconds();
+                        vb2 = hours + (minutes / 60 + seconds / 3600 + milliseconds / 36e5);
+                        if (b0 > b1) {
+                          b1 += 24;
+                          if (vb2 < b0) vb2 += 24;
+                        }
+                        break;
+                      case "":
+                        vb2 = v2;
+                        break;
+                    }
+                    if (vb2 >= b0 && vb2 < b1) return BADNUM;
+                  } else {
+                    var vals = rangebreaksIn._cachedValues[i2];
+                    for (var j2 = 0; j2 < vals.length; j2++) {
+                      b0 = vals[j2];
+                      b1 = b0 + brk.dvalue;
+                      if (v2 >= b0 && v2 < b1) return BADNUM;
+                    }
+                  }
+                }
+              }
+              return v2;
+            };
+            ax.locateBreaks = function(r0, r1) {
+              var i2, bnds, b0, b1;
+              var rangebreaksOut = [];
+              if (!ax.rangebreaks) return rangebreaksOut;
+              var rangebreaksIn = ax.rangebreaks.slice().sort(function(a2, b2) {
+                if (a2.pattern === WEEKDAY_PATTERN && b2.pattern === HOUR_PATTERN) return -1;
+                if (b2.pattern === WEEKDAY_PATTERN && a2.pattern === HOUR_PATTERN) return 1;
+                return 0;
+              });
+              var addBreak = function(min, max) {
+                min = Lib.constrain(min, r0, r1);
+                max = Lib.constrain(max, r0, r1);
+                if (min === max) return;
+                var isNewBreak = true;
+                for (var j22 = 0; j22 < rangebreaksOut.length; j22++) {
+                  var brkj = rangebreaksOut[j22];
+                  if (min < brkj.max && max >= brkj.min) {
+                    if (min < brkj.min) {
+                      brkj.min = min;
+                    }
+                    if (max > brkj.max) {
+                      brkj.max = max;
+                    }
+                    isNewBreak = false;
+                  }
+                }
+                if (isNewBreak) {
+                  rangebreaksOut.push({ min, max });
+                }
+              };
+              for (i2 = 0; i2 < rangebreaksIn.length; i2++) {
+                var brk = rangebreaksIn[i2];
+                if (brk.enabled) {
+                  if (brk.bounds) {
+                    var t02 = r0;
+                    var t12 = r1;
+                    if (brk.pattern) {
+                      t02 = Math.floor(t02);
+                    }
+                    bnds = Lib.simpleMap(brk.bounds, brk.pattern ? cleanNumber : ax.r2l);
+                    b0 = bnds[0];
+                    b1 = bnds[1];
+                    var t0Date = new Date(t02);
+                    var bndDelta;
+                    var step;
+                    switch (brk.pattern) {
+                      case WEEKDAY_PATTERN:
+                        step = ONEWEEK;
+                        bndDelta = ((b1 < b0 ? 7 : 0) + (b1 - b0)) * ONEDAY;
+                        t02 += b0 * ONEDAY - (t0Date.getUTCDay() * ONEDAY + t0Date.getUTCHours() * ONEHOUR + t0Date.getUTCMinutes() * ONEMIN + t0Date.getUTCSeconds() * ONESEC + t0Date.getUTCMilliseconds());
+                        break;
+                      case HOUR_PATTERN:
+                        step = ONEDAY;
+                        bndDelta = ((b1 < b0 ? 24 : 0) + (b1 - b0)) * ONEHOUR;
+                        t02 += b0 * ONEHOUR - (t0Date.getUTCHours() * ONEHOUR + t0Date.getUTCMinutes() * ONEMIN + t0Date.getUTCSeconds() * ONESEC + t0Date.getUTCMilliseconds());
+                        break;
+                      default:
+                        t02 = Math.min(bnds[0], bnds[1]);
+                        t12 = Math.max(bnds[0], bnds[1]);
+                        step = t12 - t02;
+                        bndDelta = step;
+                    }
+                    for (var t4 = t02; t4 < t12; t4 += step) {
+                      addBreak(t4, t4 + bndDelta);
+                    }
+                  } else {
+                    var vals = Lib.simpleMap(brk.values, ax.d2c);
+                    for (var j2 = 0; j2 < vals.length; j2++) {
+                      b0 = vals[j2];
+                      b1 = b0 + brk.dvalue;
+                      addBreak(b0, b1);
+                    }
+                  }
+                }
+              }
+              rangebreaksOut.sort(function(a2, b2) {
+                return a2.min - b2.min;
+              });
+              return rangebreaksOut;
+            };
+            ax.makeCalcdata = function(trace, axLetter2, opts) {
+              var arrayIn, arrayOut, i2, len2;
+              var axType = ax.type;
+              var cal = axType === "date" && trace[axLetter2 + "calendar"];
+              if (axLetter2 in trace) {
+                arrayIn = trace[axLetter2];
+                len2 = trace._length || Lib.minRowLength(arrayIn);
+                if (Lib.isTypedArray(arrayIn) && (axType === "linear" || axType === "log")) {
+                  if (len2 === arrayIn.length) {
+                    return arrayIn;
+                  } else if (arrayIn.subarray) {
+                    return arrayIn.subarray(0, len2);
+                  }
+                }
+                if (axType === "multicategory") {
+                  return setMultiCategoryIndex(arrayIn, len2);
+                }
+                arrayOut = new Array(len2);
+                for (i2 = 0; i2 < len2; i2++) {
+                  arrayOut[i2] = ax.d2c(arrayIn[i2], 0, cal, opts);
+                }
+              } else {
+                var v0 = axLetter2 + "0" in trace ? ax.d2c(trace[axLetter2 + "0"], 0, cal) : 0;
+                var dv = trace["d" + axLetter2] ? Number(trace["d" + axLetter2]) : 1;
+                arrayIn = trace[{ x: "y", y: "x" }[axLetter2]];
+                len2 = trace._length || arrayIn.length;
+                arrayOut = new Array(len2);
+                for (i2 = 0; i2 < len2; i2++) {
+                  arrayOut[i2] = v0 + i2 * dv;
+                }
+              }
+              if (ax.rangebreaks) {
+                for (i2 = 0; i2 < len2; i2++) {
+                  arrayOut[i2] = ax.maskBreaks(arrayOut[i2]);
+                }
+              }
+              return arrayOut;
+            };
+            ax.isValidRange = function(range, nullOk) {
+              return Array.isArray(range) && range.length === 2 && (nullOk && range[0] === null || isNumeric(ax.r2l(range[0]))) && (nullOk && range[1] === null || isNumeric(ax.r2l(range[1])));
+            };
+            ax.getAutorangeDflt = function(range, options) {
+              var autorangeDflt = !ax.isValidRange(range, "nullOk");
+              if (autorangeDflt && options && options.reverseDflt) autorangeDflt = "reversed";
+              else if (range) {
+                if (range[0] === null && range[1] === null) {
+                  autorangeDflt = true;
+                } else if (range[0] === null && range[1] !== null) {
+                  autorangeDflt = "min";
+                } else if (range[0] !== null && range[1] === null) {
+                  autorangeDflt = "max";
+                }
+              }
+              return autorangeDflt;
+            };
+            ax.isReversed = function() {
+              var autorange = ax.autorange;
+              return autorange === "reversed" || autorange === "min reversed" || autorange === "max reversed";
+            };
+            ax.isPtWithinRange = function(d2, calendar) {
+              var coord = ax.c2l(d2[axLetter], null, calendar);
+              var r0 = ax.r2l(ax.range[0]);
+              var r1 = ax.r2l(ax.range[1]);
+              if (r0 < r1) {
+                return r0 <= coord && coord <= r1;
+              } else {
+                return r1 <= coord && coord <= r0;
+              }
+            };
+            ax._emptyCategories = function() {
+              ax._categories = [];
+              ax._categoriesMap = {};
+            };
+            ax.clearCalc = function() {
+              var group = ax._matchGroup;
+              if (group) {
+                var categories = null;
+                var categoriesMap = null;
+                for (var axId2 in group) {
+                  var ax2 = fullLayout[axisIds.id2name(axId2)];
+                  if (ax2._categories) {
+                    categories = ax2._categories;
+                    categoriesMap = ax2._categoriesMap;
+                    break;
+                  }
+                }
+                if (categories && categoriesMap) {
+                  ax._categories = categories;
+                  ax._categoriesMap = categoriesMap;
+                } else {
+                  ax._emptyCategories();
+                }
+              } else {
+                ax._emptyCategories();
+              }
+              if (ax._initialCategories) {
+                for (var j2 = 0; j2 < ax._initialCategories.length; j2++) {
+                  setCategoryIndex(ax._initialCategories[j2]);
+                }
+              }
+            };
+            ax.sortByInitialCategories = function() {
+              var affectedTraces = [];
+              ax._emptyCategories();
+              if (ax._initialCategories) {
+                for (var j2 = 0; j2 < ax._initialCategories.length; j2++) {
+                  setCategoryIndex(ax._initialCategories[j2]);
+                }
+              }
+              affectedTraces = affectedTraces.concat(ax._traceIndices);
+              var group = ax._matchGroup;
+              for (var axId2 in group) {
+                if (axId === axId2) continue;
+                var ax2 = fullLayout[axisIds.id2name(axId2)];
+                ax2._categories = ax._categories;
+                ax2._categoriesMap = ax._categoriesMap;
+                affectedTraces = affectedTraces.concat(ax2._traceIndices);
+              }
+              return affectedTraces;
+            };
+            var locale = fullLayout._d3locale;
+            if (ax.type === "date") {
+              ax._dateFormat = locale ? locale.timeFormat : utcFormat;
+              ax._extraFormat = fullLayout._extraFormat;
+            }
+            ax._separators = fullLayout.separators;
+            ax._numFormat = locale ? locale.numberFormat : numberFormat;
+            delete ax._minDtick;
+            delete ax._forceTick0;
+          };
+        }
+      });
+      var require_axis_autotype = __commonJS({
+        "src/plots/cartesian/axis_autotype.js"(exports, module2) {
+          var isNumeric = require_fast_isnumeric();
+          var Lib = require_lib();
+          var BADNUM = require_numerical().BADNUM;
+          var isArrayOrTypedArray = Lib.isArrayOrTypedArray;
+          var isDateTime = Lib.isDateTime;
+          var cleanNumber = Lib.cleanNumber;
+          var round2 = Math.round;
+          module2.exports = function autoType(array, calendar, opts) {
+            var a2 = array;
+            var noMultiCategory = opts.noMultiCategory;
+            if (isArrayOrTypedArray(a2) && !a2.length) return "-";
+            if (!noMultiCategory && multiCategory(a2)) return "multicategory";
+            if (noMultiCategory && Array.isArray(a2[0])) {
+              var b2 = [];
+              for (var i2 = 0; i2 < a2.length; i2++) {
+                if (isArrayOrTypedArray(a2[i2])) {
+                  for (var j2 = 0; j2 < a2[i2].length; j2++) {
+                    b2.push(a2[i2][j2]);
+                  }
+                }
+              }
+              a2 = b2;
+            }
+            if (moreDates(a2, calendar)) return "date";
+            var convertNumeric = opts.autotypenumbers !== "strict";
+            if (category(a2, convertNumeric)) return "category";
+            if (linearOK(a2, convertNumeric)) return "linear";
+            return "-";
+          };
+          function hasTypeNumber(v2, convertNumeric) {
+            return convertNumeric ? isNumeric(v2) : typeof v2 === "number";
+          }
+          function linearOK(a2, convertNumeric) {
+            var len2 = a2.length;
+            for (var i2 = 0; i2 < len2; i2++) {
+              if (hasTypeNumber(a2[i2], convertNumeric)) return true;
+            }
+            return false;
+          }
+          function moreDates(a2, calendar) {
+            var len2 = a2.length;
+            var inc = getIncrement(len2);
+            var dats = 0;
+            var nums = 0;
+            var seen2 = {};
+            for (var f2 = 0; f2 < len2; f2 += inc) {
+              var i2 = round2(f2);
+              var ai2 = a2[i2];
+              var stri = String(ai2);
+              if (seen2[stri]) continue;
+              seen2[stri] = 1;
+              if (isDateTime(ai2, calendar)) dats++;
+              if (isNumeric(ai2)) nums++;
+            }
+            return dats > nums * 2;
+          }
+          function getIncrement(len2) {
+            return Math.max(1, (len2 - 1) / 1e3);
+          }
+          function category(a2, convertNumeric) {
+            var len2 = a2.length;
+            var inc = getIncrement(len2);
+            var nums = 0;
+            var cats = 0;
+            var seen2 = {};
+            for (var f2 = 0; f2 < len2; f2 += inc) {
+              var i2 = round2(f2);
+              var ai2 = a2[i2];
+              var stri = String(ai2);
+              if (seen2[stri]) continue;
+              seen2[stri] = 1;
+              var t4 = typeof ai2;
+              if (t4 === "boolean") cats++;
+              else if (convertNumeric ? cleanNumber(ai2) !== BADNUM : t4 === "number") nums++;
+              else if (t4 === "string") cats++;
+            }
+            return cats > nums * 2;
+          }
+          function multiCategory(a2) {
+            return isArrayOrTypedArray(a2[0]) && isArrayOrTypedArray(a2[1]);
+          }
+        }
+      });
+      var require_autorange = __commonJS({
+        "src/plots/cartesian/autorange.js"(exports, module2) {
+          var d3 = require_d3();
+          var isNumeric = require_fast_isnumeric();
+          var Lib = require_lib();
+          var FP_SAFE = require_numerical().FP_SAFE;
+          var Registry = require_registry();
+          var Drawing = require_drawing();
+          var axIds = require_axis_ids();
+          var getFromId = axIds.getFromId;
+          var isLinked = axIds.isLinked;
+          module2.exports = {
+            applyAutorangeOptions,
+            getAutoRange,
+            makePadFn,
+            doAutoRange,
+            findExtremes,
+            concatExtremes
+          };
+          function getAutoRange(gd2, ax) {
+            var i2, j2;
+            var newRange = [];
+            var fullLayout = gd2._fullLayout;
+            var getPadMin = makePadFn(fullLayout, ax, 0);
+            var getPadMax = makePadFn(fullLayout, ax, 1);
+            var extremes = concatExtremes(gd2, ax);
+            var minArray = extremes.min;
+            var maxArray = extremes.max;
+            if (minArray.length === 0 || maxArray.length === 0) {
+              return Lib.simpleMap(ax.range, ax.r2l);
+            }
+            var minmin = minArray[0].val;
+            var maxmax = maxArray[0].val;
+            for (i2 = 1; i2 < minArray.length; i2++) {
+              if (minmin !== maxmax) break;
+              minmin = Math.min(minmin, minArray[i2].val);
+            }
+            for (i2 = 1; i2 < maxArray.length; i2++) {
+              if (minmin !== maxmax) break;
+              maxmax = Math.max(maxmax, maxArray[i2].val);
+            }
+            var autorange = ax.autorange;
+            var axReverse = autorange === "reversed" || autorange === "min reversed" || autorange === "max reversed";
+            if (!axReverse && ax.range) {
+              var rng = Lib.simpleMap(ax.range, ax.r2l);
+              axReverse = rng[1] < rng[0];
+            }
+            if (ax.autorange === "reversed") {
+              ax.autorange = true;
+            }
+            var rangeMode = ax.rangemode;
+            var toZero = rangeMode === "tozero";
+            var nonNegative = rangeMode === "nonnegative";
+            var axLen = ax._length;
+            var minSpan = axLen / 10;
+            var mbest = 0;
+            var minpt, maxpt, minbest, maxbest, dp, dv;
+            for (i2 = 0; i2 < minArray.length; i2++) {
+              minpt = minArray[i2];
+              for (j2 = 0; j2 < maxArray.length; j2++) {
+                maxpt = maxArray[j2];
+                dv = maxpt.val - minpt.val - calcBreaksLength(ax, minpt.val, maxpt.val);
+                if (dv > 0) {
+                  dp = axLen - getPadMin(minpt) - getPadMax(maxpt);
+                  if (dp > minSpan) {
+                    if (dv / dp > mbest) {
+                      minbest = minpt;
+                      maxbest = maxpt;
+                      mbest = dv / dp;
+                    }
+                  } else if (dv / axLen > mbest) {
+                    minbest = { val: minpt.val, nopad: 1 };
+                    maxbest = { val: maxpt.val, nopad: 1 };
+                    mbest = dv / axLen;
+                  }
+                }
+              }
+            }
+            function maximumPad(prev, pt2) {
+              return Math.max(prev, getPadMax(pt2));
+            }
+            if (minmin === maxmax) {
+              var lower = minmin - 1;
+              var upper = minmin + 1;
+              if (toZero) {
+                if (minmin === 0) {
+                  newRange = [0, 1];
+                } else {
+                  var maxPad = (minmin > 0 ? maxArray : minArray).reduce(maximumPad, 0);
+                  var rangeEnd = minmin / (1 - Math.min(0.5, maxPad / axLen));
+                  newRange = minmin > 0 ? [0, rangeEnd] : [rangeEnd, 0];
+                }
+              } else if (nonNegative) {
+                newRange = [Math.max(0, lower), Math.max(1, upper)];
+              } else {
+                newRange = [lower, upper];
+              }
+            } else {
+              if (toZero) {
+                if (minbest.val >= 0) {
+                  minbest = { val: 0, nopad: 1 };
+                }
+                if (maxbest.val <= 0) {
+                  maxbest = { val: 0, nopad: 1 };
+                }
+              } else if (nonNegative) {
+                if (minbest.val - mbest * getPadMin(minbest) < 0) {
+                  minbest = { val: 0, nopad: 1 };
+                }
+                if (maxbest.val <= 0) {
+                  maxbest = { val: 1, nopad: 1 };
+                }
+              }
+              mbest = (maxbest.val - minbest.val - calcBreaksLength(ax, minpt.val, maxpt.val)) / (axLen - getPadMin(minbest) - getPadMax(maxbest));
+              newRange = [
+                minbest.val - mbest * getPadMin(minbest),
+                maxbest.val + mbest * getPadMax(maxbest)
+              ];
+            }
+            newRange = applyAutorangeOptions(newRange, ax);
+            if (ax.limitRange) ax.limitRange();
+            if (axReverse) newRange.reverse();
+            return Lib.simpleMap(newRange, ax.l2r || Number);
+          }
+          function calcBreaksLength(ax, v0, v1) {
+            var lBreaks = 0;
+            if (ax.rangebreaks) {
+              var rangebreaksOut = ax.locateBreaks(v0, v1);
+              for (var i2 = 0; i2 < rangebreaksOut.length; i2++) {
+                var brk = rangebreaksOut[i2];
+                lBreaks += brk.max - brk.min;
+              }
+            }
+            return lBreaks;
+          }
+          function makePadFn(fullLayout, ax, max) {
+            var extrappad = 0.05 * ax._length;
+            var anchorAxis = ax._anchorAxis || {};
+            if ((ax.ticklabelposition || "").indexOf("inside") !== -1 || (anchorAxis.ticklabelposition || "").indexOf("inside") !== -1) {
+              var axReverse = ax.isReversed();
+              if (!axReverse) {
+                var rng = Lib.simpleMap(ax.range, ax.r2l);
+                axReverse = rng[1] < rng[0];
+              }
+              if (axReverse) max = !max;
+            }
+            var zero2 = 0;
+            if (!isLinked(fullLayout, ax._id)) {
+              zero2 = padInsideLabelsOnAnchorAxis(fullLayout, ax, max);
+            }
+            extrappad = Math.max(zero2, extrappad);
+            if (ax.constrain === "domain" && ax._inputDomain) {
+              extrappad *= (ax._inputDomain[1] - ax._inputDomain[0]) / (ax.domain[1] - ax.domain[0]);
+            }
+            return function getPad(pt2) {
+              if (pt2.nopad) return 0;
+              return pt2.pad + (pt2.extrapad ? extrappad : zero2);
+            };
+          }
+          var TEXTPAD = 3;
+          function padInsideLabelsOnAnchorAxis(fullLayout, ax, max) {
+            var pad = 0;
+            var isX = ax._id.charAt(0) === "x";
+            for (var subplot in fullLayout._plots) {
+              var plotinfo = fullLayout._plots[subplot];
+              if (ax._id !== plotinfo.xaxis._id && ax._id !== plotinfo.yaxis._id) continue;
+              var anchorAxis = (isX ? plotinfo.yaxis : plotinfo.xaxis) || {};
+              if ((anchorAxis.ticklabelposition || "").indexOf("inside") !== -1) {
+                if (!max && (anchorAxis.side === "left" || anchorAxis.side === "bottom") || max && (anchorAxis.side === "top" || anchorAxis.side === "right")) {
+                  if (anchorAxis._vals) {
+                    var rad = Lib.deg2rad(anchorAxis._tickAngles[anchorAxis._id + "tick"] || 0);
+                    var cosA = Math.abs(Math.cos(rad));
+                    var sinA = Math.abs(Math.sin(rad));
+                    if (!anchorAxis._vals[0].bb) {
+                      var cls = anchorAxis._id + "tick";
+                      var tickLabels = anchorAxis._selections[cls];
+                      tickLabels.each(function(d2) {
+                        var thisLabel = d3.select(this);
+                        var mathjaxGroup = thisLabel.select(".text-math-group");
+                        if (mathjaxGroup.empty()) {
+                          d2.bb = Drawing.bBox(thisLabel.node());
+                        }
+                      });
+                    }
+                    for (var i2 = 0; i2 < anchorAxis._vals.length; i2++) {
+                      var t4 = anchorAxis._vals[i2];
+                      var bb2 = t4.bb;
+                      if (bb2) {
+                        var w2 = 2 * TEXTPAD + bb2.width;
+                        var h2 = 2 * TEXTPAD + bb2.height;
+                        pad = Math.max(
+                          pad,
+                          isX ? Math.max(w2 * cosA, h2 * sinA) : Math.max(h2 * cosA, w2 * sinA)
+                        );
+                      }
+                    }
+                  }
+                  if (anchorAxis.ticks === "inside" && anchorAxis.ticklabelposition === "inside") {
+                    pad += anchorAxis.ticklen || 0;
+                  }
+                }
+              }
+            }
+            return pad;
+          }
+          function concatExtremes(gd2, ax, noMatch) {
+            var axId = ax._id;
+            var fullData = gd2._fullData;
+            var fullLayout = gd2._fullLayout;
+            var minArray = [];
+            var maxArray = [];
+            var i2, j2, d2;
+            function _concat(cont, indices) {
+              for (i2 = 0; i2 < indices.length; i2++) {
+                var item = cont[indices[i2]];
+                var extremes = (item._extremes || {})[axId];
+                if (item.visible === true && extremes) {
+                  for (j2 = 0; j2 < extremes.min.length; j2++) {
+                    d2 = extremes.min[j2];
+                    collapseMinArray(minArray, d2.val, d2.pad, { extrapad: d2.extrapad });
+                  }
+                  for (j2 = 0; j2 < extremes.max.length; j2++) {
+                    d2 = extremes.max[j2];
+                    collapseMaxArray(maxArray, d2.val, d2.pad, { extrapad: d2.extrapad });
+                  }
+                }
+              }
+            }
+            _concat(fullData, ax._traceIndices);
+            _concat(fullLayout.annotations || [], ax._annIndices || []);
+            _concat(fullLayout.shapes || [], ax._shapeIndices || []);
+            if (ax._matchGroup && !noMatch) {
+              for (var axId2 in ax._matchGroup) {
+                if (axId2 !== ax._id) {
+                  var ax2 = getFromId(gd2, axId2);
+                  var extremes2 = concatExtremes(gd2, ax2, true);
+                  var lenRatio = ax._length / ax2._length;
+                  for (j2 = 0; j2 < extremes2.min.length; j2++) {
+                    d2 = extremes2.min[j2];
+                    collapseMinArray(minArray, d2.val, d2.pad * lenRatio, { extrapad: d2.extrapad });
+                  }
+                  for (j2 = 0; j2 < extremes2.max.length; j2++) {
+                    d2 = extremes2.max[j2];
+                    collapseMaxArray(maxArray, d2.val, d2.pad * lenRatio, { extrapad: d2.extrapad });
+                  }
+                }
+              }
+            }
+            return { min: minArray, max: maxArray };
+          }
+          function doAutoRange(gd2, ax, presetRange) {
+            ax.setScale();
+            if (ax.autorange) {
+              ax.range = presetRange ? presetRange.slice() : getAutoRange(gd2, ax);
+              ax._r = ax.range.slice();
+              ax._rl = Lib.simpleMap(ax._r, ax.r2l);
+              var axIn = ax._input;
+              var edits = {};
+              edits[ax._attr + ".range"] = ax.range;
+              edits[ax._attr + ".autorange"] = ax.autorange;
+              Registry.call("_storeDirectGUIEdit", gd2.layout, gd2._fullLayout._preGUI, edits);
+              axIn.range = ax.range.slice();
+              axIn.autorange = ax.autorange;
+            }
+            var anchorAx = ax._anchorAxis;
+            if (anchorAx && anchorAx.rangeslider) {
+              var axeRangeOpts = anchorAx.rangeslider[ax._name];
+              if (axeRangeOpts) {
+                if (axeRangeOpts.rangemode === "auto") {
+                  axeRangeOpts.range = getAutoRange(gd2, ax);
+                }
+              }
+              anchorAx._input.rangeslider[ax._name] = Lib.extendFlat({}, axeRangeOpts);
+            }
+          }
+          function findExtremes(ax, data, opts) {
+            if (!opts) opts = {};
+            if (!ax._m) ax.setScale();
+            var minArray = [];
+            var maxArray = [];
+            var len2 = data.length;
+            var extrapad = opts.padded || false;
+            var tozero = opts.tozero && (ax.type === "linear" || ax.type === "-");
+            var isLog = ax.type === "log";
+            var hasArrayOption = false;
+            var vpadLinearized = opts.vpadLinearized || false;
+            var i2, v2, di2, dmin, dmax, ppadiplus, ppadiminus, vmin, vmax;
+            function makePadAccessor(item) {
+              if (Array.isArray(item)) {
+                hasArrayOption = true;
+                return function(i22) {
+                  return Math.max(Number(item[i22] || 0), 0);
+                };
+              } else {
+                var v22 = Math.max(Number(item || 0), 0);
+                return function() {
+                  return v22;
+                };
+              }
+            }
+            var ppadplus = makePadAccessor((ax._m > 0 ? opts.ppadplus : opts.ppadminus) || opts.ppad || 0);
+            var ppadminus = makePadAccessor((ax._m > 0 ? opts.ppadminus : opts.ppadplus) || opts.ppad || 0);
+            var vpadplus = makePadAccessor(opts.vpadplus || opts.vpad);
+            var vpadminus = makePadAccessor(opts.vpadminus || opts.vpad);
+            if (!hasArrayOption) {
+              vmin = Infinity;
+              vmax = -Infinity;
+              if (isLog) {
+                for (i2 = 0; i2 < len2; i2++) {
+                  v2 = data[i2];
+                  if (v2 < vmin && v2 > 0) vmin = v2;
+                  if (v2 > vmax && v2 < FP_SAFE) vmax = v2;
+                }
+              } else {
+                for (i2 = 0; i2 < len2; i2++) {
+                  v2 = data[i2];
+                  if (v2 < vmin && v2 > -FP_SAFE) vmin = v2;
+                  if (v2 > vmax && v2 < FP_SAFE) vmax = v2;
+                }
+              }
+              data = [vmin, vmax];
+              len2 = 2;
+            }
+            var collapseOpts = { tozero, extrapad };
+            function addItem(i22) {
+              di2 = data[i22];
+              if (!isNumeric(di2)) return;
+              ppadiplus = ppadplus(i22);
+              ppadiminus = ppadminus(i22);
+              if (vpadLinearized) {
+                dmin = ax.c2l(di2) - vpadminus(i22);
+                dmax = ax.c2l(di2) + vpadplus(i22);
+              } else {
+                vmin = di2 - vpadminus(i22);
+                vmax = di2 + vpadplus(i22);
+                if (isLog && vmin < vmax / 10) vmin = vmax / 10;
+                dmin = ax.c2l(vmin);
+                dmax = ax.c2l(vmax);
+              }
+              if (tozero) {
+                dmin = Math.min(0, dmin);
+                dmax = Math.max(0, dmax);
+              }
+              if (goodNumber(dmin)) {
+                collapseMinArray(minArray, dmin, ppadiminus, collapseOpts);
+              }
+              if (goodNumber(dmax)) {
+                collapseMaxArray(maxArray, dmax, ppadiplus, collapseOpts);
+              }
+            }
+            var iMax = Math.min(6, len2);
+            for (i2 = 0; i2 < iMax; i2++) addItem(i2);
+            for (i2 = len2 - 1; i2 >= iMax; i2--) addItem(i2);
+            return {
+              min: minArray,
+              max: maxArray,
+              opts
+            };
+          }
+          function collapseMinArray(array, newVal, newPad, opts) {
+            collapseArray(array, newVal, newPad, opts, lessOrEqual);
+          }
+          function collapseMaxArray(array, newVal, newPad, opts) {
+            collapseArray(array, newVal, newPad, opts, greaterOrEqual);
+          }
+          function collapseArray(array, newVal, newPad, opts, atLeastAsExtreme) {
+            var tozero = opts.tozero;
+            var extrapad = opts.extrapad;
+            var includeThis = true;
+            for (var j2 = 0; j2 < array.length && includeThis; j2++) {
+              var v2 = array[j2];
+              if (atLeastAsExtreme(v2.val, newVal) && v2.pad >= newPad && (v2.extrapad || !extrapad)) {
+                includeThis = false;
+                break;
+              } else if (atLeastAsExtreme(newVal, v2.val) && v2.pad <= newPad && (extrapad || !v2.extrapad)) {
+                array.splice(j2, 1);
+                j2--;
+              }
+            }
+            if (includeThis) {
+              var clipAtZero = tozero && newVal === 0;
+              array.push({
+                val: newVal,
+                pad: clipAtZero ? 0 : newPad,
+                extrapad: clipAtZero ? false : extrapad
+              });
+            }
+          }
+          function goodNumber(v2) {
+            return isNumeric(v2) && Math.abs(v2) < FP_SAFE;
+          }
+          function lessOrEqual(v0, v1) {
+            return v0 <= v1;
+          }
+          function greaterOrEqual(v0, v1) {
+            return v0 >= v1;
+          }
+          function applyAutorangeMinOptions(v2, ax) {
+            var autorangeoptions = ax.autorangeoptions;
+            if (autorangeoptions && autorangeoptions.minallowed !== void 0 && hasValidMinAndMax(ax, autorangeoptions.minallowed, autorangeoptions.maxallowed)) {
+              return autorangeoptions.minallowed;
+            }
+            if (autorangeoptions && autorangeoptions.clipmin !== void 0 && hasValidMinAndMax(ax, autorangeoptions.clipmin, autorangeoptions.clipmax)) {
+              return Math.max(v2, ax.d2l(autorangeoptions.clipmin));
+            }
+            return v2;
+          }
+          function applyAutorangeMaxOptions(v2, ax) {
+            var autorangeoptions = ax.autorangeoptions;
+            if (autorangeoptions && autorangeoptions.maxallowed !== void 0 && hasValidMinAndMax(ax, autorangeoptions.minallowed, autorangeoptions.maxallowed)) {
+              return autorangeoptions.maxallowed;
+            }
+            if (autorangeoptions && autorangeoptions.clipmax !== void 0 && hasValidMinAndMax(ax, autorangeoptions.clipmin, autorangeoptions.clipmax)) {
+              return Math.min(v2, ax.d2l(autorangeoptions.clipmax));
+            }
+            return v2;
+          }
+          function hasValidMinAndMax(ax, min, max) {
+            if (min !== void 0 && max !== void 0) {
+              min = ax.d2l(min);
+              max = ax.d2l(max);
+              return min < max;
+            }
+            return true;
+          }
+          function applyAutorangeOptions(range, ax) {
+            if (!ax || !ax.autorangeoptions) return range;
+            var min = range[0];
+            var max = range[1];
+            var include = ax.autorangeoptions.include;
+            if (include !== void 0) {
+              var lMin = ax.d2l(min);
+              var lMax = ax.d2l(max);
+              if (!Lib.isArrayOrTypedArray(include)) include = [include];
+              for (var i2 = 0; i2 < include.length; i2++) {
+                var v2 = ax.d2l(include[i2]);
+                if (lMin >= v2) {
+                  lMin = v2;
+                  min = v2;
+                }
+                if (lMax <= v2) {
+                  lMax = v2;
+                  max = v2;
+                }
+              }
+            }
+            min = applyAutorangeMinOptions(min, ax);
+            max = applyAutorangeMaxOptions(max, ax);
+            return [min, max];
+          }
+        }
+      });
+      var require_axes = __commonJS({
+        "src/plots/cartesian/axes.js"(exports, module2) {
+          var d3 = require_d3();
+          var isNumeric = require_fast_isnumeric();
+          var Plots = require_plots();
+          var Registry = require_registry();
+          var Lib = require_lib();
+          var strTranslate = Lib.strTranslate;
+          var svgTextUtils = require_svg_text_utils();
+          var Titles = require_titles();
+          var Color2 = require_color();
+          var Drawing = require_drawing();
+          var axAttrs = require_layout_attributes4();
+          var cleanTicks = require_clean_ticks();
+          require_constants2();
+          var constants = require_numerical();
+          var ONEMAXYEAR = constants.ONEMAXYEAR;
+          var ONEAVGYEAR = constants.ONEAVGYEAR;
+          var ONEMINYEAR = constants.ONEMINYEAR;
+          var ONEMAXQUARTER = constants.ONEMAXQUARTER;
+          var ONEAVGQUARTER = constants.ONEAVGQUARTER;
+          var ONEMINQUARTER = constants.ONEMINQUARTER;
+          var ONEMAXMONTH = constants.ONEMAXMONTH;
+          var ONEAVGMONTH = constants.ONEAVGMONTH;
+          var ONEMINMONTH = constants.ONEMINMONTH;
+          var ONEWEEK = constants.ONEWEEK;
+          var ONEDAY = constants.ONEDAY;
+          var HALFDAY = ONEDAY / 2;
+          var ONEHOUR = constants.ONEHOUR;
+          var ONEMIN = constants.ONEMIN;
+          var ONESEC = constants.ONESEC;
+          var ONEMILLI = constants.ONEMILLI;
+          var ONEMICROSEC = constants.ONEMICROSEC;
+          var MINUS_SIGN = constants.MINUS_SIGN;
+          var BADNUM = constants.BADNUM;
+          var ZERO_PATH = { K: "zeroline" };
+          var GRID_PATH = { K: "gridline", L: "path" };
+          var MINORGRID_PATH = { K: "minor-gridline", L: "path" };
+          var TICK_PATH = { K: "tick", L: "path" };
+          var TICK_TEXT = { K: "tick", L: "text" };
+          var MARGIN_MAPPING = {
+            width: ["x", "r", "l", "xl", "xr"],
+            height: ["y", "t", "b", "yt", "yb"],
+            right: ["r", "xr"],
+            left: ["l", "xl"],
+            top: ["t", "yt"],
+            bottom: ["b", "yb"]
+          };
+          var alignmentConstants = require_alignment();
+          var MID_SHIFT = alignmentConstants.MID_SHIFT;
+          var CAP_SHIFT = alignmentConstants.CAP_SHIFT;
+          var LINE_SPACING = alignmentConstants.LINE_SPACING;
+          var OPPOSITE_SIDE = alignmentConstants.OPPOSITE_SIDE;
+          var TEXTPAD = 3;
+          var axes = module2.exports = {};
+          axes.setConvert = require_set_convert();
+          var autoType = require_axis_autotype();
+          var axisIds = require_axis_ids();
+          var idSort = axisIds.idSort;
+          var isLinked = axisIds.isLinked;
+          axes.id2name = axisIds.id2name;
+          axes.name2id = axisIds.name2id;
+          axes.cleanId = axisIds.cleanId;
+          axes.list = axisIds.list;
+          axes.listIds = axisIds.listIds;
+          axes.getFromId = axisIds.getFromId;
+          axes.getFromTrace = axisIds.getFromTrace;
+          var autorange = require_autorange();
+          axes.getAutoRange = autorange.getAutoRange;
+          axes.findExtremes = autorange.findExtremes;
+          var epsilon = 1e-4;
+          function expandRange(range) {
+            var delta = (range[1] - range[0]) * epsilon;
+            return [
+              range[0] - delta,
+              range[1] + delta
+            ];
+          }
+          axes.coerceRef = function(containerIn, containerOut, gd2, attr, dflt, extraOption) {
+            var axLetter = attr.charAt(attr.length - 1);
+            var axlist = gd2._fullLayout._subplots[axLetter + "axis"];
+            var refAttr = attr + "ref";
+            var attrDef = {};
+            if (!dflt) dflt = axlist[0] || (typeof extraOption === "string" ? extraOption : extraOption[0]);
+            if (!extraOption) extraOption = dflt;
+            axlist = axlist.concat(axlist.map(function(x2) {
+              return x2 + " domain";
+            }));
+            attrDef[refAttr] = {
+              valType: "enumerated",
+              values: axlist.concat(extraOption ? typeof extraOption === "string" ? [extraOption] : extraOption : []),
+              dflt
+            };
+            return Lib.coerce(containerIn, containerOut, attrDef, refAttr);
+          };
+          axes.coerceRefArray = function(containerIn, containerOut, gd2, attr, dflt, extraOption, expectedLen) {
+            const axLetter = attr.charAt(attr.length - 1);
+            var axlist = gd2._fullLayout._subplots[axLetter + "axis"];
+            const refAttr = attr + "ref";
+            var axRef = containerIn[refAttr];
+            if (!dflt) dflt = axlist[0] || (typeof extraOption === "string" ? extraOption : extraOption[0]);
+            axlist = axlist.concat(axlist.map((x2) => x2 + " domain"));
+            axlist = axlist.concat(extraOption ? extraOption : []);
+            if (axRef.length > expectedLen) {
+              Lib.warn("Array attribute " + refAttr + " has more entries than expected, truncating to " + expectedLen);
+              axRef = axRef.slice(0, expectedLen);
+            } else if (axRef.length < expectedLen) {
+              Lib.warn("Array attribute " + refAttr + " has fewer entries than expected, extending with default value");
+              axRef = axRef.concat(Array(expectedLen - axRef.length).fill(dflt));
+            }
+            for (var i2 = 0; i2 < axRef.length; i2++) {
+              axRef[i2] = axisIds.cleanId(axRef[i2], axLetter, true) || axRef[i2];
+              if (!axlist.includes(axRef[i2])) axRef[i2] = dflt;
+            }
+            containerOut[refAttr] = axRef;
+            return axRef;
+          };
+          axes.getRefType = function(ar) {
+            if (ar === void 0) {
+              return ar;
+            }
+            if (Array.isArray(ar)) {
+              return "array";
+            }
+            if (ar === "paper") {
+              return "paper";
+            }
+            if (ar === "pixel") {
+              return "pixel";
+            }
+            if (/( domain)$/.test(ar)) {
+              return "domain";
+            } else {
+              return "range";
+            }
+          };
+          axes.coercePosition = function(containerOut, gd2, coerce, axRef, attr, dflt) {
+            var cleanPos, pos;
+            var axRefType = axes.getRefType(axRef);
+            if (axRefType !== "range") {
+              cleanPos = Lib.ensureNumber;
+              pos = coerce(attr, dflt);
+            } else {
+              var ax = axes.getFromId(gd2, axRef);
+              dflt = ax.fraction2r(dflt);
+              pos = coerce(attr, dflt);
+              cleanPos = ax.cleanPos;
+            }
+            containerOut[attr] = cleanPos(pos);
+          };
+          axes.cleanPosition = function(pos, gd2, axRef) {
+            var cleanPos = axRef === "paper" || axRef === "pixel" ? Lib.ensureNumber : axes.getFromId(gd2, axRef).cleanPos;
+            return cleanPos(pos);
+          };
+          axes.redrawComponents = function(gd2, axIds) {
+            axIds = axIds ? axIds : axes.listIds(gd2);
+            var fullLayout = gd2._fullLayout;
+            function _redrawOneComp(moduleName, methodName, stashName, shortCircuit) {
+              var method = Registry.getComponentMethod(moduleName, methodName);
+              var stash = {};
+              for (var i2 = 0; i2 < axIds.length; i2++) {
+                var ax = fullLayout[axes.id2name(axIds[i2])];
+                var indices = ax[stashName];
+                for (var j2 = 0; j2 < indices.length; j2++) {
+                  var ind = indices[j2];
+                  if (!stash[ind]) {
+                    method(gd2, ind);
+                    stash[ind] = 1;
+                    if (shortCircuit) return;
+                  }
+                }
+              }
+            }
+            _redrawOneComp("annotations", "drawOne", "_annIndices");
+            _redrawOneComp("shapes", "drawOne", "_shapeIndices");
+            _redrawOneComp("images", "draw", "_imgIndices", true);
+            _redrawOneComp("selections", "drawOne", "_selectionIndices");
+          };
+          var getDataConversions = axes.getDataConversions = function(gd2, trace, target, targetArray) {
+            var ax;
+            var d2cTarget = target === "x" || target === "y" || target === "z" ? target : targetArray;
+            if (Lib.isArrayOrTypedArray(d2cTarget)) {
+              ax = {
+                type: autoType(targetArray, void 0, {
+                  autotypenumbers: gd2._fullLayout.autotypenumbers
+                }),
+                _categories: []
+              };
+              axes.setConvert(ax);
+              if (ax.type === "category") {
+                for (var i2 = 0; i2 < targetArray.length; i2++) {
+                  ax.d2c(targetArray[i2]);
+                }
+              }
+            } else {
+              ax = axes.getFromTrace(gd2, trace, d2cTarget);
+            }
+            if (ax) return { d2c: ax.d2c, c2d: ax.c2d };
+            if (d2cTarget === "ids") return { d2c: toString, c2d: toString };
+            return { d2c: toNum, c2d: toNum };
+          };
+          function toNum(v2) {
+            return +v2;
+          }
+          function toString(v2) {
+            return String(v2);
+          }
+          axes.getDataToCoordFunc = function(gd2, trace, target, targetArray) {
+            return getDataConversions(gd2, trace, target, targetArray).d2c;
+          };
+          axes.counterLetter = function(id2) {
+            var axLetter = id2.charAt(0);
+            if (axLetter === "x") return "y";
+            if (axLetter === "y") return "x";
+          };
+          axes.minDtick = function(ax, newDiff, newFirst, allow) {
+            if (["log", "category", "multicategory"].indexOf(ax.type) !== -1 || !allow) {
+              ax._minDtick = 0;
+            } else if (ax._minDtick === void 0) {
+              ax._minDtick = newDiff;
+              ax._forceTick0 = newFirst;
+            } else if (ax._minDtick) {
+              if ((ax._minDtick / newDiff + 1e-6) % 1 < 2e-6 && // existing minDtick is an integer multiple of newDiff
+              // (within rounding err)
+              // and forceTick0 can be shifted to newFirst
+              ((newFirst - ax._forceTick0) / newDiff % 1 + 1.000001) % 1 < 2e-6) {
+                ax._minDtick = newDiff;
+                ax._forceTick0 = newFirst;
+              } else if ((newDiff / ax._minDtick + 1e-6) % 1 > 2e-6 || // if the converse is true (newDiff is a multiple of minDtick and
+              // newFirst can be shifted to forceTick0) then do nothing - same
+              // forcing stands. Otherwise, cancel forced minimum
+              ((newFirst - ax._forceTick0) / ax._minDtick % 1 + 1.000001) % 1 > 2e-6) {
+                ax._minDtick = 0;
+              }
+            }
+          };
+          axes.saveRangeInitial = function(gd2, overwrite) {
+            var axList = axes.list(gd2, "", true);
+            var hasOneAxisChanged = false;
+            for (var i2 = 0; i2 < axList.length; i2++) {
+              var ax = axList[i2];
+              var isNew = ax._rangeInitial0 === void 0 && ax._rangeInitial1 === void 0;
+              var hasChanged = isNew || (ax.range[0] !== ax._rangeInitial0 || ax.range[1] !== ax._rangeInitial1);
+              var autorange2 = ax.autorange;
+              if (isNew && autorange2 !== true || overwrite && hasChanged) {
+                ax._rangeInitial0 = autorange2 === "min" || autorange2 === "max reversed" ? void 0 : ax.range[0];
+                ax._rangeInitial1 = autorange2 === "max" || autorange2 === "min reversed" ? void 0 : ax.range[1];
+                ax._autorangeInitial = autorange2;
+                hasOneAxisChanged = true;
+              }
+            }
+            return hasOneAxisChanged;
+          };
+          axes.saveShowSpikeInitial = function(gd2, overwrite) {
+            var axList = axes.list(gd2, "", true);
+            var hasOneAxisChanged = false;
+            var allSpikesEnabled = "on";
+            for (var i2 = 0; i2 < axList.length; i2++) {
+              var ax = axList[i2];
+              var isNew = ax._showSpikeInitial === void 0;
+              var hasChanged = isNew || !(ax.showspikes === ax._showspikes);
+              if (isNew || overwrite && hasChanged) {
+                ax._showSpikeInitial = ax.showspikes;
+                hasOneAxisChanged = true;
+              }
+              if (allSpikesEnabled === "on" && !ax.showspikes) {
+                allSpikesEnabled = "off";
+              }
+            }
+            gd2._fullLayout._cartesianSpikesEnabled = allSpikesEnabled;
+            return hasOneAxisChanged;
+          };
+          axes.autoBin = function(data, ax, nbins, is2d, calendar, size) {
+            var dataMin = Lib.aggNums(Math.min, null, data);
+            var dataMax = Lib.aggNums(Math.max, null, data);
+            if (ax.type === "category" || ax.type === "multicategory") {
+              return {
+                start: dataMin - 0.5,
+                end: dataMax + 0.5,
+                size: Math.max(1, Math.round(size) || 1),
+                _dataSpan: dataMax - dataMin
+              };
+            }
+            if (!calendar) calendar = ax.calendar;
+            var dummyAx;
+            if (ax.type === "log") {
+              dummyAx = {
+                type: "linear",
+                range: [dataMin, dataMax]
+              };
+            } else {
+              dummyAx = {
+                type: ax.type,
+                range: Lib.simpleMap([dataMin, dataMax], ax.c2r, 0, calendar),
+                calendar
+              };
+            }
+            axes.setConvert(dummyAx);
+            size = size && cleanTicks.dtick(size, dummyAx.type);
+            if (size) {
+              dummyAx.dtick = size;
+              dummyAx.tick0 = cleanTicks.tick0(void 0, dummyAx.type, calendar);
+            } else {
+              var size0;
+              if (nbins) size0 = (dataMax - dataMin) / nbins;
+              else {
+                var distinctData = Lib.distinctVals(data);
+                var msexp = Math.pow(10, Math.floor(
+                  Math.log(distinctData.minDiff) / Math.LN10
+                ));
+                var minSize = msexp * Lib.roundUp(
+                  distinctData.minDiff / msexp,
+                  [0.9, 1.9, 4.9, 9.9],
+                  true
+                );
+                size0 = Math.max(minSize, 2 * Lib.stdev(data) / Math.pow(data.length, is2d ? 0.25 : 0.4));
+                if (!isNumeric(size0)) size0 = 1;
+              }
+              axes.autoTicks(dummyAx, size0);
+            }
+            var finalSize = dummyAx.dtick;
+            var binStart = axes.tickIncrement(
+              axes.tickFirst(dummyAx),
+              finalSize,
+              "reverse",
+              calendar
+            );
+            var binEnd, bincount;
+            if (typeof finalSize === "number") {
+              binStart = autoShiftNumericBins(binStart, data, dummyAx, dataMin, dataMax);
+              bincount = 1 + Math.floor((dataMax - binStart) / finalSize);
+              binEnd = binStart + bincount * finalSize;
+            } else {
+              if (dummyAx.dtick.charAt(0) === "M") {
+                binStart = autoShiftMonthBins(binStart, data, finalSize, dataMin, calendar);
+              }
+              binEnd = binStart;
+              bincount = 0;
+              while (binEnd <= dataMax) {
+                binEnd = axes.tickIncrement(binEnd, finalSize, false, calendar);
+                bincount++;
+              }
+            }
+            return {
+              start: ax.c2r(binStart, 0, calendar),
+              end: ax.c2r(binEnd, 0, calendar),
+              size: finalSize,
+              _dataSpan: dataMax - dataMin
+            };
+          };
+          function autoShiftNumericBins(binStart, data, ax, dataMin, dataMax) {
+            var edgecount = 0;
+            var midcount = 0;
+            var intcount = 0;
+            var blankCount = 0;
+            function nearEdge(v2) {
+              return (1 + (v2 - binStart) * 100 / ax.dtick) % 100 < 2;
+            }
+            for (var i2 = 0; i2 < data.length; i2++) {
+              if (data[i2] % 1 === 0) intcount++;
+              else if (!isNumeric(data[i2])) blankCount++;
+              if (nearEdge(data[i2])) edgecount++;
+              if (nearEdge(data[i2] + ax.dtick / 2)) midcount++;
+            }
+            var dataCount = data.length - blankCount;
+            if (intcount === dataCount && ax.type !== "date") {
+              if (ax.dtick < 1) {
+                binStart = dataMin - 0.5 * ax.dtick;
+              } else {
+                binStart -= 0.5;
+                if (binStart + ax.dtick < dataMin) binStart += ax.dtick;
+              }
+            } else if (midcount < dataCount * 0.1) {
+              if (edgecount > dataCount * 0.3 || nearEdge(dataMin) || nearEdge(dataMax)) {
+                var binshift = ax.dtick / 2;
+                binStart += binStart + binshift < dataMin ? binshift : -binshift;
+              }
+            }
+            return binStart;
+          }
+          function autoShiftMonthBins(binStart, data, dtick, dataMin, calendar) {
+            var stats = Lib.findExactDates(data, calendar);
+            var threshold = 0.8;
+            if (stats.exactDays > threshold) {
+              var numMonths = Number(dtick.slice(1));
+              if (stats.exactYears > threshold && numMonths % 12 === 0) {
+                binStart = axes.tickIncrement(binStart, "M6", "reverse") + ONEDAY * 1.5;
+              } else if (stats.exactMonths > threshold) {
+                binStart = axes.tickIncrement(binStart, "M1", "reverse") + ONEDAY * 15.5;
+              } else {
+                binStart -= HALFDAY;
+              }
+              var nextBinStart = axes.tickIncrement(binStart, dtick);
+              if (nextBinStart <= dataMin) return nextBinStart;
+            }
+            return binStart;
+          }
+          axes.prepMinorTicks = function(mockAx, ax, opts) {
+            if (!ax.minor.dtick) {
+              delete mockAx.dtick;
+              var hasMajor = ax.dtick && isNumeric(ax._tmin);
+              var mockMinorRange;
+              if (hasMajor) {
+                var tick2 = axes.tickIncrement(ax._tmin, ax.dtick, true);
+                mockMinorRange = [ax._tmin, tick2 * 0.99 + ax._tmin * 0.01];
+              } else {
+                var rl2 = Lib.simpleMap(ax.range, ax.r2l);
+                mockMinorRange = [rl2[0], 0.8 * rl2[0] + 0.2 * rl2[1]];
+              }
+              mockAx.range = Lib.simpleMap(mockMinorRange, ax.l2r);
+              mockAx._isMinor = true;
+              axes.prepTicks(mockAx, opts);
+              if (hasMajor) {
+                var numericMajor = isNumeric(ax.dtick);
+                var numericMinor = isNumeric(mockAx.dtick);
+                var majorNum = numericMajor ? ax.dtick : +ax.dtick.substring(1);
+                var minorNum = numericMinor ? mockAx.dtick : +mockAx.dtick.substring(1);
+                if (numericMajor && numericMinor) {
+                  if (!isMultiple(majorNum, minorNum)) {
+                    if (majorNum === 2 * ONEWEEK && minorNum === 3 * ONEDAY) {
+                      mockAx.dtick = ONEWEEK;
+                    } else if (majorNum === ONEWEEK && !(ax._input.minor || {}).nticks) {
+                      mockAx.dtick = ONEDAY;
+                    } else if (isClose(majorNum / minorNum, 2.5)) {
+                      mockAx.dtick = majorNum / 2;
+                    } else {
+                      mockAx.dtick = majorNum;
+                    }
+                  } else if (majorNum === 2 * ONEWEEK && minorNum === 2 * ONEDAY) {
+                    mockAx.dtick = ONEWEEK;
+                  }
+                } else if (String(ax.dtick).charAt(0) === "M") {
+                  if (numericMinor) {
+                    mockAx.dtick = "M1";
+                  } else {
+                    if (!isMultiple(majorNum, minorNum)) {
+                      mockAx.dtick = ax.dtick;
+                    } else if (majorNum >= 12 && minorNum === 2) {
+                      mockAx.dtick = "M3";
+                    }
+                  }
+                } else if (String(mockAx.dtick).charAt(0) === "L") {
+                  if (String(ax.dtick).charAt(0) === "L") {
+                    if (!isMultiple(majorNum, minorNum)) {
+                      mockAx.dtick = isClose(majorNum / minorNum, 2.5) ? ax.dtick / 2 : ax.dtick;
+                    }
+                  } else {
+                    mockAx.dtick = "D1";
+                  }
+                } else if (mockAx.dtick === "D2" && +ax.dtick > 1) {
+                  mockAx.dtick = 1;
+                }
+              }
+              mockAx.range = ax.range;
+            }
+            if (ax.minor._tick0Init === void 0) {
+              mockAx.tick0 = ax.tick0;
+            }
+          };
+          function isMultiple(bigger, smaller) {
+            return Math.abs((bigger / smaller + 0.5) % 1 - 0.5) < 1e-3;
+          }
+          function isClose(a2, b2) {
+            return Math.abs(a2 / b2 - 1) < 1e-3;
+          }
+          axes.prepTicks = function(ax, opts) {
+            var rng = Lib.simpleMap(ax.range, ax.r2l, void 0, void 0, opts);
+            if (ax.tickmode === "auto" || !ax.dtick) {
+              var nt2 = ax.nticks;
+              var minPx;
+              if (!nt2) {
+                if (ax.type === "category" || ax.type === "multicategory") {
+                  minPx = ax.tickfont ? Lib.bigFont(ax.tickfont.size || 12) : 15;
+                  nt2 = ax._length / minPx;
+                } else {
+                  minPx = ax._id.charAt(0) === "y" ? 40 : 80;
+                  nt2 = Lib.constrain(ax._length / minPx, 4, 9) + 1;
+                }
+                if (ax._name === "radialaxis") nt2 *= 2;
+              }
+              if (!(ax.minor && ax.minor.tickmode !== "array")) {
+                if (ax.tickmode === "array") nt2 *= 100;
+              }
+              ax._roughDTick = Math.abs(rng[1] - rng[0]) / nt2;
+              axes.autoTicks(ax, ax._roughDTick);
+              if (ax._minDtick > 0 && ax.dtick < ax._minDtick * 2) {
+                ax.dtick = ax._minDtick;
+                ax.tick0 = ax.l2r(ax._forceTick0);
+              }
+            }
+            if (ax.ticklabelmode === "period") {
+              adjustPeriodDelta(ax);
+            }
+            if (!ax.tick0) {
+              ax.tick0 = ax.type === "date" ? "2000-01-01" : 0;
+            }
+            if (ax.type === "date" && ax.dtick < 0.1) ax.dtick = 0.1;
+            autoTickRound(ax);
+          };
+          function nMonths(dtick) {
+            return +dtick.substring(1);
+          }
+          function adjustPeriodDelta(ax) {
+            var definedDelta;
+            function mDate() {
+              return !(isNumeric(ax.dtick) || ax.dtick.charAt(0) !== "M");
+            }
+            var isMDate = mDate();
+            var tickformat = axes.getTickFormat(ax);
+            if (tickformat) {
+              var noDtick = ax._dtickInit !== ax.dtick;
+              if (!/%[fLQsSMX]/.test(tickformat)) {
+                if (/%[HI]/.test(tickformat)) {
+                  definedDelta = ONEHOUR;
+                  if (noDtick && !isMDate && ax.dtick < ONEHOUR) ax.dtick = ONEHOUR;
+                } else if (/%p/.test(tickformat)) {
+                  definedDelta = HALFDAY;
+                  if (noDtick && !isMDate && ax.dtick < HALFDAY) ax.dtick = HALFDAY;
+                } else if (/%[Aadejuwx]/.test(tickformat)) {
+                  definedDelta = ONEDAY;
+                  if (noDtick && !isMDate && ax.dtick < ONEDAY) ax.dtick = ONEDAY;
+                } else if (/%[UVW]/.test(tickformat)) {
+                  definedDelta = ONEWEEK;
+                  if (noDtick && !isMDate && ax.dtick < ONEWEEK) ax.dtick = ONEWEEK;
+                } else if (/%[Bbm]/.test(tickformat)) {
+                  definedDelta = ONEAVGMONTH;
+                  if (noDtick && (isMDate ? nMonths(ax.dtick) < 1 : ax.dtick < ONEMINMONTH)) ax.dtick = "M1";
+                } else if (/%[q]/.test(tickformat)) {
+                  definedDelta = ONEAVGQUARTER;
+                  if (noDtick && (isMDate ? nMonths(ax.dtick) < 3 : ax.dtick < ONEMINQUARTER)) ax.dtick = "M3";
+                } else if (/%[Yy]/.test(tickformat)) {
+                  definedDelta = ONEAVGYEAR;
+                  if (noDtick && (isMDate ? nMonths(ax.dtick) < 12 : ax.dtick < ONEMINYEAR)) ax.dtick = "M12";
+                }
+              }
+            }
+            isMDate = mDate();
+            if (isMDate && ax.tick0 === ax._dowTick0) {
+              ax.tick0 = ax._rawTick0;
+            }
+            ax._definedDelta = definedDelta;
+          }
+          function positionPeriodTicks(tickVals, ax, definedDelta) {
+            for (var i2 = 0; i2 < tickVals.length; i2++) {
+              var v2 = tickVals[i2].value;
+              var a2 = i2;
+              var b2 = i2 + 1;
+              if (i2 < tickVals.length - 1) {
+                a2 = i2;
+                b2 = i2 + 1;
+              } else if (i2 > 0) {
+                a2 = i2 - 1;
+                b2 = i2;
+              } else {
+                a2 = i2;
+                b2 = i2;
+              }
+              var A22 = tickVals[a2].value;
+              var B22 = tickVals[b2].value;
+              var actualDelta = Math.abs(B22 - A22);
+              var delta = definedDelta || actualDelta;
+              var periodLength = 0;
+              if (delta >= ONEMINYEAR) {
+                if (actualDelta >= ONEMINYEAR && actualDelta <= ONEMAXYEAR) {
+                  periodLength = actualDelta;
+                } else {
+                  periodLength = ONEAVGYEAR;
+                }
+              } else if (definedDelta === ONEAVGQUARTER && delta >= ONEMINQUARTER) {
+                if (actualDelta >= ONEMINQUARTER && actualDelta <= ONEMAXQUARTER) {
+                  periodLength = actualDelta;
+                } else {
+                  periodLength = ONEAVGQUARTER;
+                }
+              } else if (delta >= ONEMINMONTH) {
+                if (actualDelta >= ONEMINMONTH && actualDelta <= ONEMAXMONTH) {
+                  periodLength = actualDelta;
+                } else {
+                  periodLength = ONEAVGMONTH;
+                }
+              } else if (definedDelta === ONEWEEK && delta >= ONEWEEK) {
+                periodLength = ONEWEEK;
+              } else if (delta >= ONEDAY) {
+                periodLength = ONEDAY;
+              } else if (definedDelta === HALFDAY && delta >= HALFDAY) {
+                periodLength = HALFDAY;
+              } else if (definedDelta === ONEHOUR && delta >= ONEHOUR) {
+                periodLength = ONEHOUR;
+              }
+              var inBetween;
+              if (periodLength >= actualDelta) {
+                periodLength = actualDelta;
+                inBetween = true;
+              }
+              var endPeriod = v2 + periodLength;
+              if (ax.rangebreaks && periodLength > 0) {
+                var nAll = 84;
+                var n2 = 0;
+                for (var c2 = 0; c2 < nAll; c2++) {
+                  var r2 = (c2 + 0.5) / nAll;
+                  if (ax.maskBreaks(v2 * (1 - r2) + r2 * endPeriod) !== BADNUM) n2++;
+                }
+                periodLength *= n2 / nAll;
+                if (!periodLength) {
+                  tickVals[i2].drop = true;
+                }
+                if (inBetween && actualDelta > ONEWEEK) periodLength = actualDelta;
+              }
+              if (periodLength > 0 || // not instant
+              i2 === 0) {
+                tickVals[i2].periodX = v2 + periodLength / 2;
+              }
+            }
+          }
+          axes.calcTicks = function calcTicks(ax, opts) {
+            var type = ax.type;
+            var calendar = ax.calendar;
+            var ticklabelstep = ax.ticklabelstep;
+            var isPeriod = ax.ticklabelmode === "period";
+            var isReversed = ax.range[0] > ax.range[1];
+            var ticklabelIndex = !ax.ticklabelindex || Lib.isArrayOrTypedArray(ax.ticklabelindex) ? ax.ticklabelindex : [ax.ticklabelindex];
+            var rng = Lib.simpleMap(ax.range, ax.r2l, void 0, void 0, opts);
+            var axrev = rng[1] < rng[0];
+            var minRange = Math.min(rng[0], rng[1]);
+            var maxRange = Math.max(rng[0], rng[1]);
+            var maxTicks = Math.max(1e3, ax._length || 0);
+            var ticksOut = [];
+            var minorTicks = [];
+            var tickVals = [];
+            var minorTickVals = [];
+            var allTicklabelVals = [];
+            var hasMinor = ax.minor && (ax.minor.ticks || ax.minor.showgrid);
+            for (var major = 1; major >= (hasMinor ? 0 : 1); major--) {
+              var isMinor = !major;
+              if (major) {
+                ax._dtickInit = ax.dtick;
+                ax._tick0Init = ax.tick0;
+              } else {
+                ax.minor._dtickInit = ax.minor.dtick;
+                ax.minor._tick0Init = ax.minor.tick0;
+              }
+              var mockAx = major ? ax : Lib.extendFlat({}, ax, ax.minor);
+              if (isMinor) {
+                axes.prepMinorTicks(mockAx, ax, opts);
+              } else {
+                axes.prepTicks(mockAx, opts);
+              }
+              if (mockAx.tickmode === "array") {
+                if (major) {
+                  tickVals = [];
+                  ticksOut = arrayTicks(ax, !isMinor);
+                } else {
+                  minorTickVals = [];
+                  minorTicks = arrayTicks(ax, !isMinor);
+                }
+                continue;
+              }
+              if (mockAx.tickmode === "sync") {
+                tickVals = [];
+                ticksOut = syncTicks(ax);
+                continue;
+              }
+              var exRng = expandRange(rng);
+              var startTick = exRng[0];
+              var endTick = exRng[1];
+              var numDtick = isNumeric(mockAx.dtick);
+              var isDLog = type === "log" && !(numDtick || mockAx.dtick.charAt(0) === "L");
+              var x0 = axes.tickFirst(mockAx, opts);
+              if (major) {
+                ax._tmin = x0;
+                if (x0 < startTick !== axrev) break;
+                if (type === "category" || type === "multicategory") {
+                  endTick = axrev ? Math.max(-0.5, endTick) : Math.min(ax._categories.length - 0.5, endTick);
+                }
+              }
+              var prevX = null;
+              var x2 = x0;
+              var majorId;
+              if (major) {
+                var _dTick;
+                if (numDtick) {
+                  _dTick = ax.dtick;
+                } else {
+                  if (type === "date") {
+                    if (typeof ax.dtick === "string" && ax.dtick.charAt(0) === "M") {
+                      _dTick = ONEAVGMONTH * ax.dtick.substring(1);
+                    }
+                  } else {
+                    _dTick = ax._roughDTick;
+                  }
+                }
+                majorId = Math.round((ax.r2l(x2) - ax.r2l(ax.tick0)) / _dTick) - 1;
+              }
+              var dtick = mockAx.dtick;
+              if (mockAx.rangebreaks && mockAx._tick0Init !== mockAx.tick0) {
+                x2 = moveOutsideBreak(x2, ax);
+                if (!axrev) {
+                  x2 = axes.tickIncrement(x2, dtick, !axrev, calendar);
+                }
+              }
+              if (major && isPeriod) {
+                x2 = axes.tickIncrement(x2, dtick, !axrev, calendar);
+                majorId--;
+              }
+              for (; axrev ? x2 >= endTick : x2 <= endTick; x2 = axes.tickIncrement(
+                x2,
+                dtick,
+                axrev,
+                calendar
+              )) {
+                if (major) majorId++;
+                if (mockAx.rangebreaks) {
+                  if (!axrev) {
+                    if (x2 < startTick) continue;
+                    if (mockAx.maskBreaks(x2) === BADNUM && moveOutsideBreak(x2, mockAx) >= maxRange) break;
+                  }
+                }
+                if (tickVals.length > maxTicks || x2 === prevX) break;
+                prevX = x2;
+                var obj = { value: x2 };
+                if (major) {
+                  if (isDLog && x2 !== (x2 | 0)) {
+                    obj.simpleLabel = true;
+                  }
+                  if (ticklabelstep > 1 && majorId % ticklabelstep) {
+                    obj.skipLabel = true;
+                  }
+                  tickVals.push(obj);
+                } else {
+                  obj.minor = true;
+                  minorTickVals.push(obj);
+                }
+              }
+            }
+            if (!minorTickVals || minorTickVals.length < 2) {
+              ticklabelIndex = false;
+            } else {
+              var diff = (minorTickVals[1].value - minorTickVals[0].value) * (isReversed ? -1 : 1);
+              if (!periodCompatibleWithTickformat(diff, ax.tickformat)) {
+                ticklabelIndex = false;
+              }
+            }
+            if (!ticklabelIndex) {
+              allTicklabelVals = tickVals;
+            } else {
+              var allTickVals = tickVals.concat(minorTickVals);
+              if (isPeriod && tickVals.length) {
+                allTickVals = allTickVals.slice(1);
+              }
+              allTickVals = allTickVals.sort(function(a2, b2) {
+                return a2.value - b2.value;
+              }).filter(function(tick, index, self2) {
+                return index === 0 || tick.value !== self2[index - 1].value;
+              });
+              var majorTickIndices = allTickVals.map(function(item, index) {
+                return item.minor === void 0 && !item.skipLabel ? index : null;
+              }).filter(function(index) {
+                return index !== null;
+              });
+              majorTickIndices.forEach(function(majorIdx) {
+                ticklabelIndex.map(function(nextLabelIdx) {
+                  var minorIdx = majorIdx + nextLabelIdx;
+                  if (minorIdx >= 0 && minorIdx < allTickVals.length) {
+                    Lib.pushUnique(allTicklabelVals, allTickVals[minorIdx]);
+                  }
+                });
+              });
+            }
+            if (hasMinor) {
+              var canOverlap = ax.minor.ticks === "inside" && ax.ticks === "outside" || ax.minor.ticks === "outside" && ax.ticks === "inside";
+              if (!canOverlap) {
+                var majorValues = tickVals.map(function(d2) {
+                  return d2.value;
+                });
+                var list = [];
+                for (var k2 = 0; k2 < minorTickVals.length; k2++) {
+                  var T2 = minorTickVals[k2];
+                  var v2 = T2.value;
+                  if (majorValues.indexOf(v2) !== -1) {
+                    continue;
+                  }
+                  var found = false;
+                  for (var q2 = 0; !found && q2 < tickVals.length; q2++) {
+                    if (
+                      // add 10e6 to eliminate problematic digits
+                      1e7 + tickVals[q2].value === 1e7 + v2
+                    ) {
+                      found = true;
+                    }
+                  }
+                  if (!found) list.push(T2);
+                }
+                minorTickVals = list;
+              }
+            }
+            if (isPeriod) positionPeriodTicks(allTicklabelVals, ax, ax._definedDelta);
+            var i2;
+            if (ax.rangebreaks) {
+              var flip = ax._id.charAt(0) === "y";
+              var fontSize = 1;
+              if (ax.tickmode === "auto") {
+                fontSize = ax.tickfont ? ax.tickfont.size : 12;
+              }
+              var prevL = NaN;
+              for (i2 = tickVals.length - 1; i2 > -1; i2--) {
+                if (tickVals[i2].drop) {
+                  tickVals.splice(i2, 1);
+                  continue;
+                }
+                tickVals[i2].value = moveOutsideBreak(tickVals[i2].value, ax);
+                var l2 = ax.c2p(tickVals[i2].value);
+                if (flip ? prevL > l2 - fontSize : prevL < l2 + fontSize) {
+                  tickVals.splice(axrev ? i2 + 1 : i2, 1);
+                } else {
+                  prevL = l2;
+                }
+              }
+            }
+            if (isAngular(ax) && Math.abs(rng[1] - rng[0]) === 360) {
+              tickVals.pop();
+            }
+            ax._tmax = (tickVals[tickVals.length - 1] || {}).value;
+            ax._prevDateHead = "";
+            ax._inCalcTicks = true;
+            var lastVisibleHead;
+            var hideLabel = function(tick) {
+              tick.text = "";
+              ax._prevDateHead = lastVisibleHead;
+            };
+            tickVals = tickVals.concat(minorTickVals);
+            function setTickLabel(ax2, tickVal) {
+              var text = axes.tickText(
+                ax2,
+                tickVal.value,
+                false,
+                // hover
+                tickVal.simpleLabel
+                // noSuffixPrefix
+              );
+              var p2 = tickVal.periodX;
+              if (p2 !== void 0) {
+                text.periodX = p2;
+                if (p2 > maxRange || p2 < minRange) {
+                  if (p2 > maxRange) text.periodX = maxRange;
+                  if (p2 < minRange) text.periodX = minRange;
+                  hideLabel(text);
+                }
+              }
+              return text;
+            }
+            var t4;
+            for (i2 = 0; i2 < tickVals.length; i2++) {
+              var _minor = tickVals[i2].minor;
+              var _value = tickVals[i2].value;
+              if (_minor) {
+                if (ticklabelIndex && allTicklabelVals.indexOf(tickVals[i2]) !== -1) {
+                  t4 = setTickLabel(ax, tickVals[i2]);
+                } else {
+                  t4 = { x: _value };
+                }
+                t4.minor = true;
+                minorTicks.push(t4);
+              } else {
+                lastVisibleHead = ax._prevDateHead;
+                t4 = setTickLabel(ax, tickVals[i2]);
+                if (tickVals[i2].skipLabel || ticklabelIndex && allTicklabelVals.indexOf(tickVals[i2]) === -1) {
+                  hideLabel(t4);
+                }
+                ticksOut.push(t4);
+              }
+            }
+            ticksOut = ticksOut.concat(minorTicks);
+            ax._inCalcTicks = false;
+            if (isPeriod && ticksOut.length) {
+              ticksOut[0].noTick = true;
+            }
+            return ticksOut;
+          };
+          function filterRangeBreaks(ax, ticksOut) {
+            if (ax.rangebreaks) {
+              ticksOut = ticksOut.filter(function(d2) {
+                return ax.maskBreaks(d2.x) !== BADNUM;
+              });
+            }
+            return ticksOut;
+          }
+          function syncTicks(ax) {
+            var baseAxis = ax._mainAxis;
+            var ticksOut = [];
+            if (baseAxis._vals) {
+              for (var i2 = 0; i2 < baseAxis._vals.length; i2++) {
+                if (baseAxis._vals[i2].noTick) {
+                  continue;
+                }
+                var pos = baseAxis.l2p(baseAxis._vals[i2].x);
+                var vali = ax.p2l(pos);
+                var obj = axes.tickText(ax, vali);
+                if (baseAxis._vals[i2].minor) {
+                  obj.minor = true;
+                  obj.text = "";
+                }
+                ticksOut.push(obj);
+              }
+            }
+            ticksOut = filterRangeBreaks(ax, ticksOut);
+            return ticksOut;
+          }
+          function arrayTicks(ax, majorOnly) {
+            var rng = Lib.simpleMap(ax.range, ax.r2l);
+            var exRng = expandRange(rng);
+            var tickMin = Math.min(exRng[0], exRng[1]);
+            var tickMax = Math.max(exRng[0], exRng[1]);
+            var tickVal2l = ax.type === "category" ? ax.d2l_noadd : ax.d2l;
+            if (ax.type === "log" && String(ax.dtick).charAt(0) !== "L") {
+              ax.dtick = "L" + Math.pow(10, Math.floor(Math.min(ax.range[0], ax.range[1])) - 1);
+            }
+            var ticksOut = [];
+            for (var isMinor = 0; isMinor <= 1; isMinor++) {
+              if (majorOnly !== void 0 && (majorOnly && isMinor || majorOnly === false && !isMinor)) continue;
+              if (isMinor && !ax.minor) continue;
+              var vals = !isMinor ? ax.tickvals : ax.minor.tickvals;
+              var text = !isMinor ? ax.ticktext : [];
+              if (!vals) continue;
+              if (!Lib.isArrayOrTypedArray(text)) text = [];
+              for (var i2 = 0; i2 < vals.length; i2++) {
+                var vali = tickVal2l(vals[i2]);
+                if (vali > tickMin && vali < tickMax) {
+                  var obj = axes.tickText(ax, vali, false, String(text[i2]));
+                  if (isMinor) {
+                    obj.minor = true;
+                    obj.text = "";
+                  }
+                  ticksOut.push(obj);
+                }
+              }
+            }
+            ticksOut = filterRangeBreaks(ax, ticksOut);
+            return ticksOut;
+          }
+          var roundBase10 = [2, 5, 10];
+          var roundBase24 = [1, 2, 3, 6, 12];
+          var roundBase60 = [1, 2, 5, 10, 15, 30];
+          var roundDays = [1, 2, 3, 7, 14];
+          var roundLog1 = [-0.046, 0, 0.301, 0.477, 0.602, 0.699, 0.778, 0.845, 0.903, 0.954, 1];
+          var roundLog2 = [-0.301, 0, 0.301, 0.699, 1];
+          var roundAngles = [15, 30, 45, 90, 180];
+          function roundDTick(roughDTick, base, roundingSet) {
+            return base * Lib.roundUp(roughDTick / base, roundingSet);
+          }
+          axes.autoTicks = function(ax, roughDTick, isMinor) {
+            var base;
+            function getBase(v2) {
+              return Math.pow(v2, Math.floor(Math.log(roughDTick) / Math.LN10));
+            }
+            if (ax.type === "date") {
+              ax.tick0 = Lib.dateTick0(ax.calendar, 0);
+              var roughX2 = 2 * roughDTick;
+              if (roughX2 > ONEAVGYEAR) {
+                roughDTick /= ONEAVGYEAR;
+                base = getBase(10);
+                ax.dtick = "M" + 12 * roundDTick(roughDTick, base, roundBase10);
+              } else if (roughX2 > ONEAVGMONTH) {
+                roughDTick /= ONEAVGMONTH;
+                ax.dtick = "M" + roundDTick(roughDTick, 1, roundBase24);
+              } else if (roughX2 > ONEDAY) {
+                ax.dtick = roundDTick(roughDTick, ONEDAY, ax._hasDayOfWeekBreaks ? [1, 2, 7, 14] : roundDays);
+                if (!isMinor) {
+                  var tickformat = axes.getTickFormat(ax);
+                  var isPeriod = ax.ticklabelmode === "period";
+                  if (isPeriod) ax._rawTick0 = ax.tick0;
+                  if (/%[uVW]/.test(tickformat)) {
+                    ax.tick0 = Lib.dateTick0(ax.calendar, 2);
+                  } else {
+                    ax.tick0 = Lib.dateTick0(ax.calendar, 1);
+                  }
+                  if (isPeriod) ax._dowTick0 = ax.tick0;
+                }
+              } else if (roughX2 > ONEHOUR) {
+                ax.dtick = roundDTick(roughDTick, ONEHOUR, roundBase24);
+              } else if (roughX2 > ONEMIN) {
+                ax.dtick = roundDTick(roughDTick, ONEMIN, roundBase60);
+              } else if (roughX2 > ONESEC) {
+                ax.dtick = roundDTick(roughDTick, ONESEC, roundBase60);
+              } else {
+                base = getBase(10);
+                ax.dtick = roundDTick(roughDTick, base, roundBase10);
+              }
+            } else if (ax.type === "log") {
+              ax.tick0 = 0;
+              var rng = Lib.simpleMap(ax.range, ax.r2l);
+              if (ax._isMinor) {
+                roughDTick *= 1.5;
+              }
+              if (roughDTick > 0.7) {
+                ax.dtick = Math.ceil(roughDTick);
+              } else if (Math.abs(rng[1] - rng[0]) < 1) {
+                var nt2 = 1.5 * Math.abs((rng[1] - rng[0]) / roughDTick);
+                roughDTick = Math.abs(Math.pow(10, rng[1]) - Math.pow(10, rng[0])) / nt2;
+                base = getBase(10);
+                ax.dtick = "L" + roundDTick(roughDTick, base, roundBase10);
+              } else {
+                ax.dtick = roughDTick > 0.3 ? "D2" : "D1";
+              }
+            } else if (ax.type === "category" || ax.type === "multicategory") {
+              ax.tick0 = 0;
+              ax.dtick = Math.ceil(Math.max(roughDTick, 1));
+            } else if (isAngular(ax)) {
+              ax.tick0 = 0;
+              base = 1;
+              ax.dtick = roundDTick(roughDTick, base, roundAngles);
+            } else {
+              ax.tick0 = 0;
+              base = getBase(10);
+              ax.dtick = roundDTick(roughDTick, base, roundBase10);
+            }
+            if (ax.dtick === 0) ax.dtick = 1;
+            if (!isNumeric(ax.dtick) && typeof ax.dtick !== "string") {
+              var olddtick = ax.dtick;
+              ax.dtick = 1;
+              throw "ax.dtick error: " + String(olddtick);
+            }
+          };
+          function autoTickRound(ax) {
+            var dtick = ax.dtick;
+            ax._tickexponent = 0;
+            if (!isNumeric(dtick) && typeof dtick !== "string") {
+              dtick = 1;
+            }
+            if (ax.type === "category" || ax.type === "multicategory") {
+              ax._tickround = null;
+            }
+            if (ax.type === "date") {
+              var tick0ms = ax.r2l(ax.tick0);
+              var tick0str = ax.l2r(tick0ms).replace(/(^-|i)/g, "");
+              var tick0len = tick0str.length;
+              if (String(dtick).charAt(0) === "M") {
+                if (tick0len > 10 || tick0str.slice(5) !== "01-01") ax._tickround = "d";
+                else ax._tickround = +dtick.slice(1) % 12 === 0 ? "y" : "m";
+              } else if (dtick >= ONEDAY && tick0len <= 10 || dtick >= ONEDAY * 15) ax._tickround = "d";
+              else if (dtick >= ONEMIN && tick0len <= 16 || dtick >= ONEHOUR) ax._tickround = "M";
+              else if (dtick >= ONESEC && tick0len <= 19 || dtick >= ONEMIN) ax._tickround = "S";
+              else {
+                var tick1len = ax.l2r(tick0ms + dtick).replace(/^-/, "").length;
+                ax._tickround = Math.max(tick0len, tick1len) - 20;
+                if (ax._tickround < 0) ax._tickround = 4;
+              }
+            } else if (isNumeric(dtick) || dtick.charAt(0) === "L") {
+              var rng = ax.range.map(ax.r2d || Number);
+              if (!isNumeric(dtick)) dtick = Number(dtick.slice(1));
+              ax._tickround = 2 - Math.floor(Math.log(dtick) / Math.LN10 + 0.01);
+              var maxend = Math.max(Math.abs(rng[0]), Math.abs(rng[1]));
+              var rangeexp = Math.floor(Math.log(maxend) / Math.LN10 + 0.01);
+              var minexponent = ax.minexponent === void 0 ? 3 : ax.minexponent;
+              if (Math.abs(rangeexp) > minexponent) {
+                if (isSIFormat(ax.exponentformat) && ax.exponentformat !== "SI extended" && !beyondSI(rangeexp) || isSIFormat(ax.exponentformat) && ax.exponentformat === "SI extended" && !beyondSIExtended(rangeexp)) {
+                  ax._tickexponent = 3 * Math.round((rangeexp - 1) / 3);
+                } else ax._tickexponent = rangeexp;
+              }
+            } else {
+              ax._tickround = null;
+            }
+          }
+          axes.tickIncrement = function(x2, dtick, axrev, calendar) {
+            var axSign = axrev ? -1 : 1;
+            if (isNumeric(dtick)) return Lib.increment(x2, axSign * dtick);
+            var tType = dtick.charAt(0);
+            var dtSigned = axSign * Number(dtick.slice(1));
+            if (tType === "M") return Lib.incrementMonth(x2, dtSigned, calendar);
+            if (tType === "L") return Math.log(Math.pow(10, x2) + dtSigned) / Math.LN10;
+            if (tType === "D") {
+              var tickset = dtick === "D2" ? roundLog2 : roundLog1;
+              var x22 = x2 + axSign * 0.01;
+              var frac = Lib.roundUp(Lib.mod(x22, 1), tickset, axrev);
+              return Math.floor(x22) + Math.log(d3.round(Math.pow(10, frac), 1)) / Math.LN10;
+            }
+            throw "unrecognized dtick " + String(dtick);
+          };
+          axes.tickFirst = function(ax, opts) {
+            var r2l = ax.r2l || Number;
+            var rng = Lib.simpleMap(ax.range, r2l, void 0, void 0, opts);
+            var axrev = rng[1] < rng[0];
+            var sRound = axrev ? Math.floor : Math.ceil;
+            var r0 = expandRange(rng)[0];
+            var dtick = ax.dtick;
+            var tick0 = r2l(ax.tick0);
+            if (isNumeric(dtick)) {
+              var tmin = sRound((r0 - tick0) / dtick) * dtick + tick0;
+              if (ax.type === "category" || ax.type === "multicategory") {
+                tmin = Lib.constrain(tmin, 0, ax._categories.length - 1);
+              }
+              return tmin;
+            }
+            var tType = dtick.charAt(0);
+            var dtNum = Number(dtick.slice(1));
+            if (tType === "M") {
+              var cnt = 0;
+              var t02 = tick0;
+              var t12, mult, newDTick;
+              while (cnt < 10) {
+                t12 = axes.tickIncrement(t02, dtick, axrev, ax.calendar);
+                if ((t12 - r0) * (t02 - r0) <= 0) {
+                  if (axrev) return Math.min(t02, t12);
+                  return Math.max(t02, t12);
+                }
+                mult = (r0 - (t02 + t12) / 2) / (t12 - t02);
+                newDTick = tType + (Math.abs(Math.round(mult)) || 1) * dtNum;
+                t02 = axes.tickIncrement(t02, newDTick, mult < 0 ? !axrev : axrev, ax.calendar);
+                cnt++;
+              }
+              Lib.error("tickFirst did not converge", ax);
+              return t02;
+            } else if (tType === "L") {
+              return Math.log(sRound(
+                (Math.pow(10, r0) - tick0) / dtNum
+              ) * dtNum + tick0) / Math.LN10;
+            } else if (tType === "D") {
+              var tickset = dtick === "D2" ? roundLog2 : roundLog1;
+              var frac = Lib.roundUp(Lib.mod(r0, 1), tickset, axrev);
+              return Math.floor(r0) + Math.log(d3.round(Math.pow(10, frac), 1)) / Math.LN10;
+            } else throw "unrecognized dtick " + String(dtick);
+          };
+          axes.tickText = function(ax, x2, hover, noSuffixPrefix) {
+            var out = tickTextObj(ax, x2);
+            var arrayMode = ax.tickmode === "array";
+            var extraPrecision = hover || arrayMode;
+            var axType = ax.type;
+            var tickVal2l = axType === "category" ? ax.d2l_noadd : ax.d2l;
+            var i2;
+            var inbounds = function(v2) {
+              var p2 = ax.l2p(v2);
+              return p2 >= 0 && p2 <= ax._length ? v2 : null;
+            };
+            if (arrayMode && Lib.isArrayOrTypedArray(ax.ticktext)) {
+              var rng = Lib.simpleMap(ax.range, ax.r2l);
+              var minDiff = (Math.abs(rng[1] - rng[0]) - (ax._lBreaks || 0)) / 1e4;
+              for (i2 = 0; i2 < ax.ticktext.length; i2++) {
+                if (Math.abs(x2 - tickVal2l(ax.tickvals[i2])) < minDiff) break;
+              }
+              if (i2 < ax.ticktext.length) {
+                out.text = String(ax.ticktext[i2]);
+                out.xbnd = [
+                  inbounds(out.x - 0.5),
+                  inbounds(out.x + ax.dtick - 0.5)
+                ];
+                return out;
+              }
+            }
+            function isHidden(showAttr) {
+              if (showAttr === void 0) return true;
+              if (hover) return showAttr === "none";
+              var firstOrLast = {
+                first: ax._tmin,
+                last: ax._tmax
+              }[showAttr];
+              return showAttr !== "all" && x2 !== firstOrLast;
+            }
+            var hideexp = hover ? "never" : ax.exponentformat !== "none" && isHidden(ax.showexponent) ? "hide" : "";
+            if (axType === "date") formatDate(ax, out, hover, extraPrecision);
+            else if (axType === "log") formatLog(ax, out, hover, extraPrecision, hideexp);
+            else if (axType === "category") formatCategory(ax, out);
+            else if (axType === "multicategory") formatMultiCategory(ax, out, hover);
+            else if (isAngular(ax)) formatAngle(ax, out, hover, extraPrecision, hideexp);
+            else formatLinear(ax, out, hover, extraPrecision, hideexp);
+            if (!noSuffixPrefix) {
+              if (ax.tickprefix && !isHidden(ax.showtickprefix)) out.text = ax.tickprefix + out.text;
+              if (ax.ticksuffix && !isHidden(ax.showticksuffix)) out.text += ax.ticksuffix;
+            }
+            if (ax.labelalias && ax.labelalias.hasOwnProperty(out.text)) {
+              var t4 = ax.labelalias[out.text];
+              if (typeof t4 === "string") out.text = t4;
+            }
+            if (ax.tickson === "boundaries" || ax.showdividers) {
+              out.xbnd = [
+                inbounds(out.x - 0.5),
+                inbounds(out.x + ax.dtick - 0.5)
+              ];
+            }
+            return out;
+          };
+          axes.hoverLabelText = function(ax, values, hoverformat) {
+            if (hoverformat) ax = Lib.extendFlat({}, ax, { hoverformat });
+            var val = Lib.isArrayOrTypedArray(values) ? values[0] : values;
+            var val2 = Lib.isArrayOrTypedArray(values) ? values[1] : void 0;
+            if (val2 !== void 0 && val2 !== val) {
+              return axes.hoverLabelText(ax, val, hoverformat) + " - " + axes.hoverLabelText(ax, val2, hoverformat);
+            }
+            var logOffScale = ax.type === "log" && val <= 0;
+            var tx = axes.tickText(ax, ax.c2l(logOffScale ? -val : val), "hover").text;
+            if (logOffScale) {
+              return val === 0 ? "0" : MINUS_SIGN + tx;
+            }
+            return tx;
+          };
+          function tickTextObj(ax, x2, text) {
+            var tf2 = ax.tickfont || {};
+            return {
+              x: x2,
+              dx: 0,
+              dy: 0,
+              text: text || "",
+              fontSize: tf2.size,
+              font: tf2.family,
+              fontWeight: tf2.weight,
+              fontStyle: tf2.style,
+              fontVariant: tf2.variant,
+              fontTextcase: tf2.textcase,
+              fontLineposition: tf2.lineposition,
+              fontShadow: tf2.shadow,
+              fontColor: tf2.color
+            };
+          }
+          function formatDate(ax, out, hover, extraPrecision) {
+            var tr = ax._tickround;
+            var fmt = hover && ax.hoverformat || axes.getTickFormat(ax);
+            extraPrecision = !fmt && extraPrecision;
+            if (extraPrecision) {
+              if (isNumeric(tr)) tr = 4;
+              else tr = { y: "m", m: "d", d: "M", M: "S", S: 4 }[tr];
+            }
+            var dateStr = Lib.formatDate(out.x, fmt, tr, ax._dateFormat, ax.calendar, ax._extraFormat);
+            var headStr;
+            var splitIndex = dateStr.indexOf("\n");
+            if (splitIndex !== -1) {
+              headStr = dateStr.slice(splitIndex + 1);
+              dateStr = dateStr.slice(0, splitIndex);
+            }
+            if (extraPrecision) {
+              if (headStr !== void 0 && (dateStr === "00:00:00" || dateStr === "00:00")) {
+                dateStr = headStr;
+                headStr = "";
+              } else if (dateStr.length === 8) {
+                dateStr = dateStr.replace(/:00$/, "");
+              }
+            }
+            if (headStr) {
+              if (hover) {
+                if (tr === "d") dateStr += ", " + headStr;
+                else dateStr = headStr + (dateStr ? ", " + dateStr : "");
+              } else {
+                if (!ax._inCalcTicks || ax._prevDateHead !== headStr) {
+                  ax._prevDateHead = headStr;
+                  dateStr += "<br>" + headStr;
+                } else {
+                  var isInside = insideTicklabelposition(ax);
+                  var side = ax._trueSide || ax.side;
+                  if (!isInside && side === "top" || isInside && side === "bottom") {
+                    dateStr += "<br> ";
+                  }
+                }
+              }
+            }
+            out.text = dateStr;
+          }
+          function formatLog(ax, out, hover, extraPrecision, hideexp) {
+            var dtick = ax.dtick;
+            var x2 = out.x;
+            var tickformat = ax.tickformat;
+            var dtChar0 = typeof dtick === "string" && dtick.charAt(0);
+            if (hideexp === "never") {
+              hideexp = "";
+            }
+            if (extraPrecision && dtChar0 !== "L") {
+              dtick = "L3";
+              dtChar0 = "L";
+            }
+            if (tickformat || dtChar0 === "L") {
+              out.text = numFormat(Math.pow(10, x2), ax, hideexp, extraPrecision);
+            } else if (isNumeric(dtick) || dtChar0 === "D" && (ax.minorloglabels === "complete" || Lib.mod(x2 + 0.01, 1) < 0.1)) {
+              if (ax.minorloglabels === "complete" && !(Lib.mod(x2 + 0.01, 1) < 0.1)) {
+                out.fontSize *= 0.75;
+              }
+              var exponentialString = Math.pow(10, x2).toExponential(0);
+              var parts = exponentialString.split("e");
+              var p2 = +parts[1];
+              var absP = Math.abs(p2);
+              var exponentFormat = ax.exponentformat;
+              if (exponentFormat === "power" || isSIFormat(exponentFormat) && exponentFormat !== "SI extended" && beyondSI(p2) || isSIFormat(exponentFormat) && exponentFormat === "SI extended" && beyondSIExtended(p2)) {
+                out.text = parts[0];
+                if (absP > 0) out.text += "x10";
+                if (out.text === "1x10") out.text = "10";
+                if (p2 !== 0 && p2 !== 1) out.text += "<sup>" + (p2 > 0 ? "" : MINUS_SIGN) + absP + "</sup>";
+                out.fontSize *= 1.25;
+              } else if ((exponentFormat === "e" || exponentFormat === "E") && absP > 2) {
+                out.text = parts[0] + exponentFormat + (p2 > 0 ? "+" : MINUS_SIGN) + absP;
+              } else {
+                out.text = numFormat(Math.pow(10, x2), ax, "", "fakehover");
+                if (dtick === "D1" && ax._id.charAt(0) === "y") {
+                  out.dy -= out.fontSize / 6;
+                }
+              }
+            } else if (dtChar0 === "D") {
+              out.text = ax.minorloglabels === "none" ? "" : (
+                /* ax.minorloglabels === 'small digits' */
+                String(Math.round(Math.pow(10, Lib.mod(x2, 1))))
+              );
+              out.fontSize *= 0.75;
+            } else throw "unrecognized dtick " + String(dtick);
+            if (ax.dtick === "D1") {
+              var firstChar = String(out.text).charAt(0);
+              if (firstChar === "0" || firstChar === "1") {
+                if (ax._id.charAt(0) === "y") {
+                  out.dx -= out.fontSize / 4;
+                } else {
+                  out.dy += out.fontSize / 2;
+                  out.dx += (ax.range[1] > ax.range[0] ? 1 : -1) * out.fontSize * (x2 < 0 ? 0.5 : 0.25);
+                }
+              }
+            }
+          }
+          function formatCategory(ax, out) {
+            var tt2 = ax._categories[Math.round(out.x)];
+            if (tt2 === void 0) tt2 = "";
+            out.text = String(tt2);
+          }
+          function formatMultiCategory(ax, out, hover) {
+            var v2 = Math.round(out.x);
+            var cats = ax._categories[v2] || [];
+            var tt2 = cats[1] === void 0 ? "" : String(cats[1]);
+            var tt22 = cats[0] === void 0 ? "" : String(cats[0]);
+            if (hover) {
+              out.text = tt22 + " - " + tt2;
+            } else {
+              out.text = tt2;
+              out.text2 = tt22;
+            }
+          }
+          function formatLinear(ax, out, hover, extraPrecision, hideexp) {
+            if (hideexp === "never") {
+              hideexp = "";
+            } else if (ax.showexponent === "all" && Math.abs(out.x / ax.dtick) < 1e-6) {
+              hideexp = "hide";
+            }
+            out.text = numFormat(out.x, ax, hideexp, extraPrecision);
+          }
+          function formatAngle(ax, out, hover, extraPrecision, hideexp) {
+            if (ax.thetaunit === "radians" && !hover) {
+              var num = out.x / 180;
+              if (num === 0) {
+                out.text = "0";
+              } else {
+                var frac = num2frac(num);
+                if (frac[1] >= 100) {
+                  out.text = numFormat(Lib.deg2rad(out.x), ax, hideexp, extraPrecision);
+                } else {
+                  var isNeg = out.x < 0;
+                  if (frac[1] === 1) {
+                    if (frac[0] === 1) out.text = "π";
+                    else out.text = frac[0] + "π";
+                  } else {
+                    out.text = [
+                      "<sup>",
+                      frac[0],
+                      "</sup>",
+                      "⁄",
+                      "<sub>",
+                      frac[1],
+                      "</sub>",
+                      "π"
+                    ].join("");
+                  }
+                  if (isNeg) out.text = MINUS_SIGN + out.text;
+                }
+              }
+            } else {
+              out.text = numFormat(out.x, ax, hideexp, extraPrecision);
+            }
+          }
+          function num2frac(num) {
+            function almostEq(a2, b2) {
+              return Math.abs(a2 - b2) <= 1e-6;
+            }
+            function findGCD(a2, b2) {
+              return almostEq(b2, 0) ? a2 : findGCD(b2, a2 % b2);
+            }
+            function findPrecision(n2) {
+              var e2 = 1;
+              while (!almostEq(Math.round(n2 * e2) / e2, n2)) {
+                e2 *= 10;
+              }
+              return e2;
+            }
+            var precision = findPrecision(num);
+            var number = num * precision;
+            var gcd = Math.abs(findGCD(number, precision));
+            return [
+              // numerator
+              Math.round(number / gcd),
+              // denominator
+              Math.round(precision / gcd)
+            ];
+          }
+          var SIPREFIXES = ["f", "p", "n", "μ", "m", "", "k", "M", "G", "T"];
+          var SIPREFIXES_EXTENDED = ["q", "r", "y", "z", "a", ...SIPREFIXES, "P", "E", "Z", "Y", "R", "Q"];
+          var isSIFormat = (exponentFormat) => ["SI", "SI extended", "B"].includes(exponentFormat);
+          function beyondSI(exponent) {
+            return exponent > 14 || exponent < -15;
+          }
+          function beyondSIExtended(exponent) {
+            return exponent > 32 || exponent < -30;
+          }
+          function shouldSwitchSIToPowerFormat(exponent, exponentFormat) {
+            if (!isSIFormat(exponentFormat)) return false;
+            if (exponentFormat === "SI extended" && beyondSIExtended(exponent)) return true;
+            if (exponentFormat !== "SI extended" && beyondSI(exponent)) return true;
+            return false;
+          }
+          function numFormat(v2, ax, fmtoverride, hover) {
+            var isNeg = v2 < 0;
+            var tickRound = ax._tickround;
+            var exponentFormat = fmtoverride || ax.exponentformat || "B";
+            var exponent = ax._tickexponent;
+            var tickformat = axes.getTickFormat(ax);
+            var separatethousands = ax.separatethousands;
+            if (hover) {
+              var ah2 = {
+                exponentformat: exponentFormat,
+                minexponent: ax.minexponent,
+                dtick: ax.showexponent === "none" ? ax.dtick : isNumeric(v2) ? Math.abs(v2) || 1 : 1,
+                // if not showing any exponents, don't change the exponent
+                // from what we calculate
+                range: ax.showexponent === "none" ? ax.range.map(ax.r2d) : [0, v2 || 1]
+              };
+              autoTickRound(ah2);
+              tickRound = (Number(ah2._tickround) || 0) + 4;
+              exponent = ah2._tickexponent;
+              if (ax.hoverformat) tickformat = ax.hoverformat;
+            }
+            if (tickformat) return ax._numFormat(tickformat)(v2).replace(/-/g, MINUS_SIGN);
+            var e2 = Math.pow(10, -tickRound) / 2;
+            if (exponentFormat === "none") exponent = 0;
+            v2 = Math.abs(v2);
+            if (v2 < e2) {
+              v2 = "0";
+              isNeg = false;
+            } else {
+              v2 += e2;
+              if (exponent) {
+                v2 *= Math.pow(10, -exponent);
+                tickRound += exponent;
+              }
+              if (tickRound === 0) v2 = String(Math.floor(v2));
+              else if (tickRound < 0) {
+                v2 = String(Math.round(v2));
+                v2 = v2.slice(0, Math.max(0, v2.length + tickRound));
+                for (var i2 = tickRound; i2 < 0; i2++) v2 += "0";
+              } else {
+                v2 = String(v2);
+                var dp = v2.indexOf(".") + 1;
+                if (dp) v2 = v2.slice(0, dp + tickRound).replace(/\.?0+$/, "");
+              }
+              v2 = Lib.numSeparate(v2, ax._separators, separatethousands);
+            }
+            if (exponent && exponentFormat !== "hide") {
+              if (shouldSwitchSIToPowerFormat(exponent, exponentFormat)) exponentFormat = "power";
+              var signedExponent;
+              if (exponent < 0) signedExponent = MINUS_SIGN + -exponent;
+              else if (exponentFormat !== "power") signedExponent = "+" + exponent;
+              else signedExponent = String(exponent);
+              if (exponentFormat === "e" || exponentFormat === "E") {
+                v2 += exponentFormat + signedExponent;
+              } else if (exponentFormat === "power") {
+                v2 += "×10<sup>" + signedExponent + "</sup>";
+              } else if (exponentFormat === "B" && exponent === 9) {
+                v2 += "B";
+              } else if (isSIFormat(exponentFormat)) {
+                v2 += exponentFormat === "SI extended" ? SIPREFIXES_EXTENDED[exponent / 3 + 10] : SIPREFIXES[exponent / 3 + 5];
+              }
+            }
+            if (isNeg) return MINUS_SIGN + v2;
+            return v2;
+          }
+          axes.getTickFormat = function(ax) {
+            var i2;
+            function convertToMs(dtick) {
+              return typeof dtick !== "string" ? dtick : Number(dtick.replace("M", "")) * ONEAVGMONTH;
+            }
+            function compareLogTicks(left, right) {
+              var priority = ["L", "D"];
+              if (typeof left === typeof right) {
+                if (typeof left === "number") {
+                  return left - right;
+                } else {
+                  var leftPriority = priority.indexOf(left.charAt(0));
+                  var rightPriority = priority.indexOf(right.charAt(0));
+                  if (leftPriority === rightPriority) {
+                    return Number(left.replace(/(L|D)/g, "")) - Number(right.replace(/(L|D)/g, ""));
+                  } else {
+                    return leftPriority - rightPriority;
+                  }
+                }
+              } else {
+                return typeof left === "number" ? 1 : -1;
+              }
+            }
+            function isProperStop(dtick, range, convert) {
+              var convertFn = convert || function(x2) {
+                return x2;
+              };
+              var leftDtick = range[0];
+              var rightDtick = range[1];
+              return (!leftDtick && typeof leftDtick !== "number" || convertFn(leftDtick) <= convertFn(dtick)) && (!rightDtick && typeof rightDtick !== "number" || convertFn(rightDtick) >= convertFn(dtick));
+            }
+            function isProperLogStop(dtick, range) {
+              var isLeftDtickNull = range[0] === null;
+              var isRightDtickNull = range[1] === null;
+              var isDtickInRangeLeft = compareLogTicks(dtick, range[0]) >= 0;
+              var isDtickInRangeRight = compareLogTicks(dtick, range[1]) <= 0;
+              return (isLeftDtickNull || isDtickInRangeLeft) && (isRightDtickNull || isDtickInRangeRight);
+            }
+            var tickstop, stopi;
+            if (ax.tickformatstops && ax.tickformatstops.length > 0) {
+              switch (ax.type) {
+                case "date":
+                case "linear": {
+                  for (i2 = 0; i2 < ax.tickformatstops.length; i2++) {
+                    stopi = ax.tickformatstops[i2];
+                    if (stopi.enabled && isProperStop(ax.dtick, stopi.dtickrange, convertToMs)) {
+                      tickstop = stopi;
+                      break;
+                    }
+                  }
+                  break;
+                }
+                case "log": {
+                  for (i2 = 0; i2 < ax.tickformatstops.length; i2++) {
+                    stopi = ax.tickformatstops[i2];
+                    if (stopi.enabled && isProperLogStop(ax.dtick, stopi.dtickrange)) {
+                      tickstop = stopi;
+                      break;
+                    }
+                  }
+                  break;
+                }
+              }
+            }
+            return tickstop ? tickstop.value : ax.tickformat;
+          };
+          axes.getSubplots = function(gd2, ax) {
+            var subplotObj = gd2._fullLayout._subplots;
+            var allSubplots = subplotObj.cartesian.concat(subplotObj.gl2d || []);
+            var out = ax ? axes.findSubplotsWithAxis(allSubplots, ax) : allSubplots;
+            out.sort(function(a2, b2) {
+              var aParts = a2.slice(1).split("y");
+              var bParts = b2.slice(1).split("y");
+              if (aParts[0] === bParts[0]) return +aParts[1] - +bParts[1];
+              return +aParts[0] - +bParts[0];
+            });
+            return out;
+          };
+          axes.findSubplotsWithAxis = function(subplots, ax) {
+            var axMatch = new RegExp(
+              ax._id.charAt(0) === "x" ? "^" + ax._id + "y" : ax._id + "$"
+            );
+            var subplotsWithAx = [];
+            for (var i2 = 0; i2 < subplots.length; i2++) {
+              var sp = subplots[i2];
+              if (axMatch.test(sp)) subplotsWithAx.push(sp);
+            }
+            return subplotsWithAx;
+          };
+          axes.makeClipPaths = function(gd2) {
+            var fullLayout = gd2._fullLayout;
+            if (fullLayout._hasOnlyLargeSploms) return;
+            var fullWidth = { _offset: 0, _length: fullLayout.width, _id: "" };
+            var fullHeight = { _offset: 0, _length: fullLayout.height, _id: "" };
+            var xaList = axes.list(gd2, "x", true);
+            var yaList = axes.list(gd2, "y", true);
+            var clipList = [];
+            var i2, j2;
+            for (i2 = 0; i2 < xaList.length; i2++) {
+              clipList.push({ x: xaList[i2], y: fullHeight });
+              for (j2 = 0; j2 < yaList.length; j2++) {
+                if (i2 === 0) clipList.push({ x: fullWidth, y: yaList[j2] });
+                clipList.push({ x: xaList[i2], y: yaList[j2] });
+              }
+            }
+            var axClips = fullLayout._clips.selectAll(".axesclip").data(clipList, function(d2) {
+              return d2.x._id + d2.y._id;
+            });
+            axClips.enter().append("clipPath").classed("axesclip", true).attr("id", function(d2) {
+              return "clip" + fullLayout._uid + d2.x._id + d2.y._id;
+            }).append("rect");
+            axClips.exit().remove();
+            axClips.each(function(d2) {
+              d3.select(this).select("rect").attr({
+                x: d2.x._offset || 0,
+                y: d2.y._offset || 0,
+                width: d2.x._length || 1,
+                height: d2.y._length || 1
+              });
+            });
+          };
+          axes.draw = function(gd2, arg, opts) {
+            var fullLayout = gd2._fullLayout;
+            if (arg === "redraw") {
+              fullLayout._paper.selectAll("g.subplot").each(function(d2) {
+                var id2 = d2[0];
+                var plotinfo = fullLayout._plots[id2];
+                if (plotinfo) {
+                  var xa = plotinfo.xaxis;
+                  var ya2 = plotinfo.yaxis;
+                  plotinfo.xaxislayer.selectAll("." + xa._id + "tick").remove();
+                  plotinfo.yaxislayer.selectAll("." + ya2._id + "tick").remove();
+                  plotinfo.xaxislayer.selectAll("." + xa._id + "tick2").remove();
+                  plotinfo.yaxislayer.selectAll("." + ya2._id + "tick2").remove();
+                  plotinfo.xaxislayer.selectAll("." + xa._id + "divider").remove();
+                  plotinfo.yaxislayer.selectAll("." + ya2._id + "divider").remove();
+                  if (plotinfo.minorGridlayer) plotinfo.minorGridlayer.selectAll("path").remove();
+                  if (plotinfo.gridlayer) plotinfo.gridlayer.selectAll("path").remove();
+                  if (plotinfo.zerolinelayer) plotinfo.zerolinelayer.selectAll("path").remove();
+                  if (plotinfo.zerolinelayerAbove) plotinfo.zerolinelayerAbove.selectAll("path").remove();
+                  fullLayout._infolayer.select(".g-" + xa._id + "title").remove();
+                  fullLayout._infolayer.select(".g-" + ya2._id + "title").remove();
+                }
+              });
+            }
+            var axList = !arg || arg === "redraw" ? axes.listIds(gd2) : arg;
+            var fullAxList = axes.list(gd2);
+            var overlayingShiftedAx = fullAxList.filter(function(ax) {
+              return ax.autoshift;
+            }).map(function(ax) {
+              return ax.overlaying;
+            });
+            axList.map(function(axId) {
+              var ax = axes.getFromId(gd2, axId);
+              if (ax.tickmode === "sync" && ax.overlaying) {
+                var overlayingIndex = axList.findIndex(function(axis) {
+                  return axis === ax.overlaying;
+                });
+                if (overlayingIndex >= 0) {
+                  axList.unshift(axList.splice(overlayingIndex, 1).shift());
+                }
+              }
+            });
+            var axShifts = { false: { left: 0, right: 0 } };
+            return Lib.syncOrAsync(axList.map(function(axId) {
+              return function() {
+                if (!axId) return;
+                var ax = axes.getFromId(gd2, axId);
+                if (!opts) opts = {};
+                opts.axShifts = axShifts;
+                opts.overlayingShiftedAx = overlayingShiftedAx;
+                var axDone = axes.drawOne(gd2, ax, opts);
+                if (ax._shiftPusher) {
+                  incrementShift(ax, ax._fullDepth || 0, axShifts, true);
+                }
+                ax._r = ax.range.slice();
+                ax._rl = Lib.simpleMap(ax._r, ax.r2l);
+                return axDone;
+              };
+            }));
+          };
+          axes.drawOne = function(gd2, ax, opts) {
+            opts = opts || {};
+            var axShifts = opts.axShifts || {};
+            var overlayingShiftedAx = opts.overlayingShiftedAx || [];
+            var i2, sp, plotinfo;
+            ax.setScale();
+            var fullLayout = gd2._fullLayout;
+            var axId = ax._id;
+            var axLetter = axId.charAt(0);
+            var counterLetter = axes.counterLetter(axId);
+            var mainPlotinfo = fullLayout._plots[ax._mainSubplot];
+            var zerolineIsAbove = ax.zerolinelayer === "above traces";
+            if (!mainPlotinfo) return;
+            ax._shiftPusher = ax.autoshift || overlayingShiftedAx.indexOf(ax._id) !== -1 || overlayingShiftedAx.indexOf(ax.overlaying) !== -1;
+            if (ax._shiftPusher & ax.anchor === "free") {
+              var selfPush = ax.linewidth / 2 || 0;
+              if (ax.ticks === "inside") {
+                selfPush += ax.ticklen;
+              }
+              incrementShift(ax, selfPush, axShifts, true);
+              incrementShift(ax, ax.shift || 0, axShifts, false);
+            }
+            if (opts.skipTitle !== true || ax._shift === void 0) ax._shift = setShiftVal(ax, axShifts);
+            var mainAxLayer = mainPlotinfo[axLetter + "axislayer"];
+            var mainLinePosition = ax._mainLinePosition;
+            var mainLinePositionShift = mainLinePosition += ax._shift;
+            var mainMirrorPosition = ax._mainMirrorPosition;
+            var vals = ax._vals = axes.calcTicks(ax);
+            var axInfo = [ax.mirror, mainLinePositionShift, mainMirrorPosition].join("_");
+            for (i2 = 0; i2 < vals.length; i2++) {
+              vals[i2].axInfo = axInfo;
+            }
+            ax._selections = {};
+            if (ax._tickAngles) ax._prevTickAngles = ax._tickAngles;
+            ax._tickAngles = {};
+            ax._depth = null;
+            var llbboxes = {};
+            function getLabelLevelBbox(suffix) {
+              var cls = axId + (suffix || "tick");
+              if (!llbboxes[cls]) llbboxes[cls] = calcLabelLevelBbox(ax, cls, mainLinePositionShift);
+              return llbboxes[cls];
+            }
+            if (!ax.visible) return;
+            var transTickFn = axes.makeTransTickFn(ax);
+            var transTickLabelFn = axes.makeTransTickLabelFn(ax);
+            var tickVals;
+            var valsClipped;
+            var insideTicks = ax.ticks === "inside";
+            var outsideTicks = ax.ticks === "outside";
+            if (ax.tickson === "boundaries") {
+              var boundaryVals = getBoundaryVals(ax, vals);
+              valsClipped = axes.clipEnds(ax, boundaryVals);
+              tickVals = insideTicks ? valsClipped : boundaryVals;
+            } else {
+              valsClipped = axes.clipEnds(ax, vals);
+              tickVals = insideTicks && ax.ticklabelmode !== "period" ? valsClipped : vals;
+            }
+            var gridVals = ax._gridVals = valsClipped;
+            var dividerVals = getDividerVals(ax, vals);
+            if (!fullLayout._hasOnlyLargeSploms) {
+              var subplotsWithAx = ax._subplotsWith;
+              var finishedGrids = {};
+              for (i2 = 0; i2 < subplotsWithAx.length; i2++) {
+                sp = subplotsWithAx[i2];
+                plotinfo = fullLayout._plots[sp];
+                var counterAxis = plotinfo[counterLetter + "axis"];
+                var mainCounterID = counterAxis._mainAxis._id;
+                if (finishedGrids[mainCounterID]) continue;
+                finishedGrids[mainCounterID] = 1;
+                var gridPath = axLetter === "x" ? "M0," + counterAxis._offset + "v" + counterAxis._length : "M" + counterAxis._offset + ",0h" + counterAxis._length;
+                axes.drawGrid(gd2, ax, {
+                  vals: gridVals,
+                  counterAxis,
+                  layer: plotinfo.gridlayer.select("." + axId),
+                  minorLayer: plotinfo.minorGridlayer.select("." + axId),
+                  path: gridPath,
+                  transFn: transTickFn
+                });
+                axes.drawZeroLine(gd2, ax, {
+                  counterAxis,
+                  layer: zerolineIsAbove ? plotinfo.zerolinelayerAbove : plotinfo.zerolinelayer,
+                  path: gridPath,
+                  transFn: transTickFn
+                });
+              }
+            }
+            var tickPath;
+            var majorTickSigns = axes.getTickSigns(ax);
+            var minorTickSigns = axes.getTickSigns(ax, "minor");
+            if (ax.ticks || ax.minor && ax.minor.ticks) {
+              var majorTickPath = axes.makeTickPath(ax, mainLinePositionShift, majorTickSigns[2]);
+              var minorTickPath = axes.makeTickPath(ax, mainLinePositionShift, minorTickSigns[2], { minor: true });
+              var mirrorMajorTickPath;
+              var mirrorMinorTickPath;
+              var fullMajorTickPath;
+              var fullMinorTickPath;
+              if (ax._anchorAxis && ax.mirror && ax.mirror !== true) {
+                mirrorMajorTickPath = axes.makeTickPath(ax, mainMirrorPosition, majorTickSigns[3]);
+                mirrorMinorTickPath = axes.makeTickPath(ax, mainMirrorPosition, minorTickSigns[3], { minor: true });
+                fullMajorTickPath = majorTickPath + mirrorMajorTickPath;
+                fullMinorTickPath = minorTickPath + mirrorMinorTickPath;
+              } else {
+                mirrorMajorTickPath = "";
+                mirrorMinorTickPath = "";
+                fullMajorTickPath = majorTickPath;
+                fullMinorTickPath = minorTickPath;
+              }
+              if (ax.showdividers && outsideTicks && ax.tickson === "boundaries") {
+                var dividerLookup = {};
+                for (i2 = 0; i2 < dividerVals.length; i2++) {
+                  dividerLookup[dividerVals[i2].x] = 1;
+                }
+                tickPath = function(d2) {
+                  return dividerLookup[d2.x] ? mirrorMajorTickPath : fullMajorTickPath;
+                };
+              } else {
+                tickPath = function(d2) {
+                  return d2.minor ? fullMinorTickPath : fullMajorTickPath;
+                };
+              }
+            }
+            axes.drawTicks(gd2, ax, {
+              vals: tickVals,
+              layer: mainAxLayer,
+              path: tickPath,
+              transFn: transTickFn
+            });
+            if (ax.mirror === "allticks") {
+              var tickSubplots = Object.keys(ax._linepositions || {});
+              for (i2 = 0; i2 < tickSubplots.length; i2++) {
+                sp = tickSubplots[i2];
+                plotinfo = fullLayout._plots[sp];
+                var linepositions = ax._linepositions[sp] || [];
+                var p0 = linepositions[0];
+                var p1 = linepositions[1];
+                var isMinor = linepositions[2];
+                var spTickPath = axes.makeTickPath(
+                  ax,
+                  p0,
+                  isMinor ? majorTickSigns[0] : minorTickSigns[0],
+                  { minor: isMinor }
+                ) + axes.makeTickPath(
+                  ax,
+                  p1,
+                  isMinor ? majorTickSigns[1] : minorTickSigns[1],
+                  { minor: isMinor }
+                );
+                axes.drawTicks(gd2, ax, {
+                  vals: tickVals,
+                  layer: plotinfo[axLetter + "axislayer"],
+                  path: spTickPath,
+                  transFn: transTickFn
+                });
+              }
+            }
+            var seq = [];
+            seq.push(function() {
+              return axes.drawLabels(gd2, ax, {
+                vals,
+                layer: mainAxLayer,
+                plotinfo,
+                transFn: transTickLabelFn,
+                labelFns: axes.makeLabelFns(ax, mainLinePositionShift)
+              });
+            });
+            if (ax.type === "multicategory") {
+              var pad = { x: 2, y: 10 }[axLetter];
+              seq.push(function() {
+                var bboxKey = { x: "height", y: "width" }[axLetter];
+                var standoff = getLabelLevelBbox()[bboxKey] + pad + (ax._tickAngles[axId + "tick"] ? ax.tickfont.size * LINE_SPACING : 0);
+                return axes.drawLabels(gd2, ax, {
+                  vals: getSecondaryLabelVals(ax, vals),
+                  layer: mainAxLayer,
+                  cls: axId + "tick2",
+                  repositionOnUpdate: true,
+                  secondary: true,
+                  transFn: transTickFn,
+                  labelFns: axes.makeLabelFns(ax, mainLinePositionShift + standoff * majorTickSigns[4])
+                });
+              });
+              seq.push(function() {
+                ax._depth = majorTickSigns[4] * (getLabelLevelBbox("tick2")[ax.side] - mainLinePositionShift);
+                return drawDividers(gd2, ax, {
+                  vals: dividerVals,
+                  layer: mainAxLayer,
+                  path: axes.makeTickPath(ax, mainLinePositionShift, majorTickSigns[4], { len: ax._depth }),
+                  transFn: transTickFn
+                });
+              });
+            } else if (ax.title.hasOwnProperty("standoff")) {
+              seq.push(function() {
+                ax._depth = majorTickSigns[4] * (getLabelLevelBbox()[ax.side] - mainLinePositionShift);
+              });
+            }
+            var hasRangeSlider = Registry.getComponentMethod("rangeslider", "isVisible")(ax);
+            if (!opts.skipTitle && !(hasRangeSlider && ax.side === "bottom")) {
+              seq.push(function() {
+                return drawTitle(gd2, ax);
+              });
+            }
+            seq.push(function() {
+              var s2 = ax.side.charAt(0);
+              var sMirror = OPPOSITE_SIDE[ax.side].charAt(0);
+              var pos = axes.getPxPosition(gd2, ax);
+              var outsideTickLen = outsideTicks ? ax.ticklen : 0;
+              var llbbox;
+              var push;
+              var mirrorPush;
+              var rangeSliderPush;
+              if (ax.automargin || hasRangeSlider || ax._shiftPusher) {
+                if (ax.type === "multicategory") {
+                  llbbox = getLabelLevelBbox("tick2");
+                } else {
+                  llbbox = getLabelLevelBbox();
+                  if (axLetter === "x" && s2 === "b") {
+                    ax._depth = Math.max(llbbox.width > 0 ? llbbox.bottom - pos : 0, outsideTickLen);
+                  }
+                }
+              }
+              var axDepth = 0;
+              var titleDepth = 0;
+              if (ax._shiftPusher) {
+                axDepth = Math.max(
+                  outsideTickLen,
+                  llbbox.height > 0 ? s2 === "l" ? pos - llbbox.left : llbbox.right - pos : 0
+                );
+                if (ax.title.text !== fullLayout._dfltTitle[axLetter]) {
+                  titleDepth = (ax._titleStandoff || 0) + (ax._titleScoot || 0);
+                  if (s2 === "l") {
+                    titleDepth += approxTitleDepth(ax);
+                  }
+                }
+                ax._fullDepth = Math.max(axDepth, titleDepth);
+              }
+              if (ax.automargin) {
+                push = { x: 0, y: 0, r: 0, l: 0, t: 0, b: 0 };
+                var domainIndices = [0, 1];
+                var shift = typeof ax._shift === "number" ? ax._shift : 0;
+                if (axLetter === "x") {
+                  if (s2 === "b") {
+                    push[s2] = ax._depth;
+                  } else {
+                    push[s2] = ax._depth = Math.max(llbbox.width > 0 ? pos - llbbox.top : 0, outsideTickLen);
+                    domainIndices.reverse();
+                  }
+                  if (llbbox.width > 0) {
+                    var rExtra = llbbox.right - (ax._offset + ax._length);
+                    if (rExtra > 0) {
+                      push.xr = 1;
+                      push.r = rExtra;
+                    }
+                    var lExtra = ax._offset - llbbox.left;
+                    if (lExtra > 0) {
+                      push.xl = 0;
+                      push.l = lExtra;
+                    }
+                  }
+                } else {
+                  if (s2 === "l") {
+                    ax._depth = Math.max(llbbox.height > 0 ? pos - llbbox.left : 0, outsideTickLen);
+                    push[s2] = ax._depth - shift;
+                  } else {
+                    ax._depth = Math.max(llbbox.height > 0 ? llbbox.right - pos : 0, outsideTickLen);
+                    push[s2] = ax._depth + shift;
+                    domainIndices.reverse();
+                  }
+                  if (llbbox.height > 0) {
+                    var bExtra = llbbox.bottom - (ax._offset + ax._length);
+                    if (bExtra > 0) {
+                      push.yb = 0;
+                      push.b = bExtra;
+                    }
+                    var tExtra = ax._offset - llbbox.top;
+                    if (tExtra > 0) {
+                      push.yt = 1;
+                      push.t = tExtra;
+                    }
+                  }
+                }
+                push[counterLetter] = ax.anchor === "free" ? ax.position : ax._anchorAxis.domain[domainIndices[0]];
+                if (ax.title.text !== fullLayout._dfltTitle[axLetter]) {
+                  push[s2] += approxTitleDepth(ax) + (ax.title.standoff || 0);
+                }
+                if (ax.mirror && ax.anchor !== "free") {
+                  mirrorPush = { x: 0, y: 0, r: 0, l: 0, t: 0, b: 0 };
+                  mirrorPush[sMirror] = ax.linewidth;
+                  if (ax.mirror && ax.mirror !== true) mirrorPush[sMirror] += outsideTickLen;
+                  if (ax.mirror === true || ax.mirror === "ticks") {
+                    mirrorPush[counterLetter] = ax._anchorAxis.domain[domainIndices[1]];
+                  } else if (ax.mirror === "all" || ax.mirror === "allticks") {
+                    mirrorPush[counterLetter] = [ax._counterDomainMin, ax._counterDomainMax][domainIndices[1]];
+                  }
+                }
+              }
+              if (hasRangeSlider) {
+                rangeSliderPush = Registry.getComponentMethod("rangeslider", "autoMarginOpts")(gd2, ax);
+              }
+              if (typeof ax.automargin === "string") {
+                filterPush(push, ax.automargin);
+                filterPush(mirrorPush, ax.automargin);
+              }
+              Plots.autoMargin(gd2, axAutoMarginID(ax), push);
+              Plots.autoMargin(gd2, axMirrorAutoMarginID(ax), mirrorPush);
+              Plots.autoMargin(gd2, rangeSliderAutoMarginID(ax), rangeSliderPush);
+            });
+            return Lib.syncOrAsync(seq);
+          };
+          function filterPush(push, automargin) {
+            if (!push) return;
+            var keepMargin = Object.keys(MARGIN_MAPPING).reduce(function(data, nextKey) {
+              if (automargin.indexOf(nextKey) !== -1) {
+                MARGIN_MAPPING[nextKey].forEach(function(key) {
+                  data[key] = 1;
+                });
+              }
+              return data;
+            }, {});
+            Object.keys(push).forEach(function(key) {
+              if (!keepMargin[key]) {
+                if (key.length === 1) push[key] = 0;
+                else delete push[key];
+              }
+            });
+          }
+          function getBoundaryVals(ax, vals) {
+            var out = [];
+            var i2;
+            var _push = function(d2, bndIndex) {
+              var xb2 = d2.xbnd[bndIndex];
+              if (xb2 !== null) {
+                out.push(Lib.extendFlat({}, d2, { x: xb2 }));
+              }
+            };
+            if (vals.length) {
+              for (i2 = 0; i2 < vals.length; i2++) {
+                _push(vals[i2], 0);
+              }
+              _push(vals[i2 - 1], 1);
+            }
+            return out;
+          }
+          function getSecondaryLabelVals(ax, vals) {
+            var out = [];
+            var lookup = {};
+            for (var i2 = 0; i2 < vals.length; i2++) {
+              var d2 = vals[i2];
+              if (lookup[d2.text2]) {
+                lookup[d2.text2].push(d2.x);
+              } else {
+                lookup[d2.text2] = [d2.x];
+              }
+            }
+            for (var k2 in lookup) {
+              out.push(tickTextObj(ax, Lib.interp(lookup[k2], 0.5), k2));
+            }
+            return out;
+          }
+          function getDividerVals(ax, vals) {
+            var out = [];
+            var i2, current;
+            var reversed = vals.length && vals[vals.length - 1].x < vals[0].x;
+            var _push = function(d22, bndIndex) {
+              var xb2 = d22.xbnd[bndIndex];
+              if (xb2 !== null) {
+                out.push(Lib.extendFlat({}, d22, { x: xb2 }));
+              }
+            };
+            if (ax.showdividers && vals.length) {
+              for (i2 = 0; i2 < vals.length; i2++) {
+                var d2 = vals[i2];
+                if (d2.text2 !== current) {
+                  _push(d2, reversed ? 1 : 0);
+                }
+                current = d2.text2;
+              }
+              _push(vals[i2 - 1], reversed ? 0 : 1);
+            }
+            return out;
+          }
+          function calcLabelLevelBbox(ax, cls, mainLinePositionShift) {
+            var top, bottom;
+            var left, right;
+            if (ax._selections[cls].size()) {
+              top = Infinity;
+              bottom = -Infinity;
+              left = Infinity;
+              right = -Infinity;
+              ax._selections[cls].each(function() {
+                var thisLabel = selectTickLabel(this);
+                if (thisLabel.node().style.display !== "none") {
+                  var bb2 = Drawing.bBox(thisLabel.node().parentNode);
+                  top = Math.min(top, bb2.top);
+                  bottom = Math.max(bottom, bb2.bottom);
+                  left = Math.min(left, bb2.left);
+                  right = Math.max(right, bb2.right);
+                }
+              });
+            } else {
+              var dummyCalc = axes.makeLabelFns(ax, mainLinePositionShift);
+              top = bottom = dummyCalc.yFn({ dx: 0, dy: 0, fontSize: 0 });
+              left = right = dummyCalc.xFn({ dx: 0, dy: 0, fontSize: 0 });
+            }
+            return {
+              top,
+              bottom,
+              left,
+              right,
+              height: bottom - top,
+              width: right - left
+            };
+          }
+          axes.getTickSigns = function(ax, minor) {
+            var axLetter = ax._id.charAt(0);
+            var sideOpposite = { x: "top", y: "right" }[axLetter];
+            var main = ax.side === sideOpposite ? 1 : -1;
+            var out = [-1, 1, main, -main];
+            var ticks = minor ? (ax.minor || {}).ticks : ax.ticks;
+            if (ticks !== "inside" === (axLetter === "x")) {
+              out = out.map(function(v2) {
+                return -v2;
+              });
+            }
+            if (ax.side) {
+              out.push({ l: -1, t: -1, r: 1, b: 1 }[ax.side.charAt(0)]);
+            }
+            return out;
+          };
+          axes.makeTransTickFn = function(ax) {
+            return ax._id.charAt(0) === "x" ? function(d2) {
+              return strTranslate(ax._offset + ax.l2p(d2.x), 0);
+            } : function(d2) {
+              return strTranslate(0, ax._offset + ax.l2p(d2.x));
+            };
+          };
+          axes.makeTransTickLabelFn = function(ax) {
+            var uv = getTickLabelUV(ax);
+            var shift = ax.ticklabelshift || 0;
+            var standoff = ax.ticklabelstandoff || 0;
+            var u2 = uv[0];
+            var v2 = uv[1];
+            var isReversed = ax.range[0] > ax.range[1];
+            var labelsInside = ax.ticklabelposition && ax.ticklabelposition.indexOf("inside") !== -1;
+            var labelsOutside = !labelsInside;
+            if (shift) {
+              var shiftSign = isReversed ? -1 : 1;
+              shift = shift * shiftSign;
+            }
+            if (standoff) {
+              var side = ax.side;
+              var standoffSign = labelsInside && (side === "top" || side === "left") || labelsOutside && (side === "bottom" || side === "right") ? 1 : -1;
+              standoff = standoff * standoffSign;
+            }
+            return ax._id.charAt(0) === "x" ? function(d2) {
+              return strTranslate(
+                u2 + ax._offset + ax.l2p(getPosX(d2)) + shift,
+                v2 + standoff
+              );
+            } : function(d2) {
+              return strTranslate(
+                v2 + standoff,
+                u2 + ax._offset + ax.l2p(getPosX(d2)) + shift
+              );
+            };
+          };
+          function getPosX(d2) {
+            return d2.periodX !== void 0 ? d2.periodX : d2.x;
+          }
+          function getTickLabelUV(ax) {
+            var ticklabelposition = ax.ticklabelposition || "";
+            var tickson = ax.tickson || "";
+            var has = function(str) {
+              return ticklabelposition.indexOf(str) !== -1;
+            };
+            var isTop = has("top");
+            var isLeft = has("left");
+            var isRight = has("right");
+            var isBottom = has("bottom");
+            var isInside = has("inside");
+            var isAligned = tickson !== "boundaries" && (isBottom || isLeft || isTop || isRight);
+            if (!isAligned && !isInside) return [0, 0];
+            var side = ax.side;
+            var u2 = isAligned ? (ax.tickwidth || 0) / 2 : 0;
+            var v2 = TEXTPAD;
+            var fontSize = ax.tickfont ? ax.tickfont.size : 12;
+            if (isBottom || isTop) {
+              u2 += fontSize * CAP_SHIFT;
+              v2 += (ax.linewidth || 0) / 2;
+            }
+            if (isLeft || isRight) {
+              u2 += (ax.linewidth || 0) / 2;
+              v2 += TEXTPAD;
+            }
+            if (isInside && side === "top") {
+              v2 -= fontSize * (1 - CAP_SHIFT);
+            }
+            if (isLeft || isTop) u2 = -u2;
+            if (side === "bottom" || side === "right") v2 = -v2;
+            return [
+              isAligned ? u2 : 0,
+              isInside ? v2 : 0
+            ];
+          }
+          axes.makeTickPath = function(ax, shift, sgn, opts) {
+            if (!opts) opts = {};
+            var minor = opts.minor;
+            if (minor && !ax.minor) return "";
+            var len2 = opts.len !== void 0 ? opts.len : minor ? ax.minor.ticklen : ax.ticklen;
+            var axLetter = ax._id.charAt(0);
+            var pad = (ax.linewidth || 1) / 2;
+            return axLetter === "x" ? "M0," + (shift + pad * sgn) + "v" + len2 * sgn : "M" + (shift + pad * sgn) + ",0h" + len2 * sgn;
+          };
+          axes.makeLabelFns = function(ax, shift, angle2) {
+            var ticklabelposition = ax.ticklabelposition || "";
+            var tickson = ax.tickson || "";
+            var has = function(str) {
+              return ticklabelposition.indexOf(str) !== -1;
+            };
+            var isTop = has("top");
+            var isLeft = has("left");
+            var isRight = has("right");
+            var isBottom = has("bottom");
+            var isAligned = tickson !== "boundaries" && (isBottom || isLeft || isTop || isRight);
+            var insideTickLabels = has("inside");
+            var labelsOverTicks = ticklabelposition === "inside" && ax.ticks === "inside" || !insideTickLabels && ax.ticks === "outside" && tickson !== "boundaries";
+            var labelStandoff = 0;
+            var labelShift = 0;
+            var tickLen = labelsOverTicks ? ax.ticklen : 0;
+            if (insideTickLabels) {
+              tickLen *= -1;
+            } else if (isAligned) {
+              tickLen = 0;
+            }
+            if (labelsOverTicks) {
+              labelStandoff += tickLen;
+              if (angle2) {
+                var rad = Lib.deg2rad(angle2);
+                labelStandoff = tickLen * Math.cos(rad) + 1;
+                labelShift = tickLen * Math.sin(rad);
+              }
+            }
+            if (ax.showticklabels && (labelsOverTicks || ax.showline)) {
+              labelStandoff += 0.2 * ax.tickfont.size;
+            }
+            labelStandoff += (ax.linewidth || 1) / 2 * (insideTickLabels ? -1 : 1);
+            var out = {
+              labelStandoff,
+              labelShift
+            };
+            var x0, y0, ff2, flipIt;
+            var xQ = 0;
+            var side = ax.side;
+            var axLetter = ax._id.charAt(0);
+            var tickangle = ax.tickangle;
+            var endSide;
+            if (axLetter === "x") {
+              endSide = !insideTickLabels && side === "bottom" || insideTickLabels && side === "top";
+              flipIt = endSide ? 1 : -1;
+              if (insideTickLabels) flipIt *= -1;
+              x0 = labelShift * flipIt;
+              y0 = shift + labelStandoff * flipIt;
+              ff2 = endSide ? 1 : -0.2;
+              if (Math.abs(tickangle) === 90) {
+                if (insideTickLabels) {
+                  ff2 += MID_SHIFT;
+                } else {
+                  if (tickangle === -90 && side === "bottom") {
+                    ff2 = CAP_SHIFT;
+                  } else if (tickangle === 90 && side === "top") {
+                    ff2 = MID_SHIFT;
+                  } else {
+                    ff2 = 0.5;
+                  }
+                }
+                xQ = MID_SHIFT / 2 * (tickangle / 90);
+              }
+              out.xFn = function(d2) {
+                return d2.dx + x0 + xQ * d2.fontSize;
+              };
+              out.yFn = function(d2) {
+                return d2.dy + y0 + d2.fontSize * ff2;
+              };
+              out.anchorFn = function(d2, a2) {
+                if (isAligned) {
+                  if (isLeft) return "end";
+                  if (isRight) return "start";
+                }
+                if (!isNumeric(a2) || a2 === 0 || a2 === 180) {
+                  return "middle";
+                }
+                return a2 * flipIt < 0 !== insideTickLabels ? "end" : "start";
+              };
+              out.heightFn = function(d2, a2, h2) {
+                return a2 < -60 || a2 > 60 ? -0.5 * h2 : ax.side === "top" !== insideTickLabels ? -h2 : 0;
+              };
+            } else if (axLetter === "y") {
+              endSide = !insideTickLabels && side === "left" || insideTickLabels && side === "right";
+              flipIt = endSide ? 1 : -1;
+              if (insideTickLabels) flipIt *= -1;
+              x0 = labelStandoff;
+              y0 = labelShift * flipIt;
+              ff2 = 0;
+              if (!insideTickLabels && Math.abs(tickangle) === 90) {
+                if (tickangle === -90 && side === "left" || tickangle === 90 && side === "right") {
+                  ff2 = CAP_SHIFT;
+                } else {
+                  ff2 = 0.5;
+                }
+              }
+              if (insideTickLabels) {
+                var ang = isNumeric(tickangle) ? +tickangle : 0;
+                if (ang !== 0) {
+                  var rA = Lib.deg2rad(ang);
+                  xQ = Math.abs(Math.sin(rA)) * CAP_SHIFT * flipIt;
+                  ff2 = 0;
+                }
+              }
+              out.xFn = function(d2) {
+                return d2.dx + shift - (x0 + d2.fontSize * ff2) * flipIt + xQ * d2.fontSize;
+              };
+              out.yFn = function(d2) {
+                return d2.dy + y0 + d2.fontSize * MID_SHIFT;
+              };
+              out.anchorFn = function(d2, a2) {
+                if (isNumeric(a2) && Math.abs(a2) === 90) {
+                  return "middle";
+                }
+                return endSide ? "end" : "start";
+              };
+              out.heightFn = function(d2, a2, h2) {
+                if (ax.side === "right") a2 *= -1;
+                return a2 < -30 ? -h2 : a2 < 30 ? -0.5 * h2 : 0;
+              };
+            }
+            return out;
+          };
+          function tickDataFn(d2) {
+            return [d2.text, d2.x, d2.axInfo, d2.font, d2.fontSize, d2.fontColor].join("_");
+          }
+          axes.drawTicks = function(gd2, ax, opts) {
+            opts = opts || {};
+            var cls = ax._id + "tick";
+            var vals = [].concat(
+              ax.minor && ax.minor.ticks ? (
+                // minor vals
+                opts.vals.filter(function(d2) {
+                  return d2.minor && !d2.noTick;
+                })
+              ) : []
+            ).concat(
+              ax.ticks ? (
+                // major vals
+                opts.vals.filter(function(d2) {
+                  return !d2.minor && !d2.noTick;
+                })
+              ) : []
+            );
+            var ticks = opts.layer.selectAll("path." + cls).data(vals, tickDataFn);
+            ticks.exit().remove();
+            ticks.enter().append("path").classed(cls, 1).classed("ticks", 1).classed("crisp", opts.crisp !== false).each(function(d2) {
+              return Color2.stroke(d3.select(this), d2.minor ? ax.minor.tickcolor : ax.tickcolor);
+            }).style("stroke-width", function(d2) {
+              return Drawing.crispRound(
+                gd2,
+                d2.minor ? ax.minor.tickwidth : ax.tickwidth,
+                1
+              ) + "px";
+            }).attr("d", opts.path).style("display", null);
+            hideCounterAxisInsideTickLabels(ax, [TICK_PATH]);
+            ticks.attr("transform", opts.transFn);
+          };
+          axes.drawGrid = function(gd2, ax, opts) {
+            opts = opts || {};
+            if (ax.tickmode === "sync") {
+              return;
+            }
+            var cls = ax._id + "grid";
+            var hasMinor = ax.minor && ax.minor.showgrid;
+            var minorVals = hasMinor ? opts.vals.filter(function(d2) {
+              return d2.minor;
+            }) : [];
+            var majorVals = ax.showgrid ? opts.vals.filter(function(d2) {
+              return !d2.minor;
+            }) : [];
+            var counterAx = opts.counterAxis;
+            if (counterAx && axes.shouldShowZeroLine(gd2, ax, counterAx)) {
+              var isArrayMode = ax.tickmode === "array";
+              for (var i2 = 0; i2 < majorVals.length; i2++) {
+                var xi2 = majorVals[i2].x;
+                if (isArrayMode ? !xi2 : Math.abs(xi2) < ax.dtick / 100) {
+                  majorVals = majorVals.slice(0, i2).concat(majorVals.slice(i2 + 1));
+                  if (isArrayMode) i2--;
+                  else break;
+                }
+              }
+            }
+            ax._gw = Drawing.crispRound(gd2, ax.gridwidth, 1);
+            var wMinor = !hasMinor ? 0 : Drawing.crispRound(gd2, ax.minor.gridwidth, 1);
+            var majorLayer = opts.layer;
+            var minorLayer = opts.minorLayer;
+            for (var major = 1; major >= 0; major--) {
+              var layer = major ? majorLayer : minorLayer;
+              if (!layer) continue;
+              var grid = layer.selectAll("path." + cls).data(major ? majorVals : minorVals, tickDataFn);
+              grid.exit().remove();
+              grid.enter().append("path").classed(cls, 1).classed("crisp", opts.crisp !== false);
+              grid.attr("transform", opts.transFn).attr("d", opts.path).each(function(d2) {
+                return Color2.stroke(
+                  d3.select(this),
+                  d2.minor ? ax.minor.gridcolor : ax.gridcolor || "#ddd"
+                );
+              }).style("stroke-dasharray", function(d2) {
+                return Drawing.dashStyle(
+                  d2.minor ? ax.minor.griddash : ax.griddash,
+                  d2.minor ? ax.minor.gridwidth : ax.gridwidth
+                );
+              }).style("stroke-width", function(d2) {
+                return (d2.minor ? wMinor : ax._gw) + "px";
+              }).style("display", null);
+              if (typeof opts.path === "function") grid.attr("d", opts.path);
+            }
+            hideCounterAxisInsideTickLabels(ax, [GRID_PATH, MINORGRID_PATH]);
+          };
+          axes.drawZeroLine = function(gd2, ax, opts) {
+            opts = opts || opts;
+            var cls = ax._id + "zl";
+            var show = axes.shouldShowZeroLine(gd2, ax, opts.counterAxis);
+            var zl = opts.layer.selectAll("path." + cls).data(show ? [{ x: 0, id: ax._id }] : []);
+            zl.exit().remove();
+            zl.enter().append("path").classed(cls, 1).classed("zl", 1).classed("crisp", opts.crisp !== false).each(function() {
+              opts.layer.selectAll("path").sort(function(da2, db2) {
+                return idSort(da2.id, db2.id);
+              });
+            });
+            zl.attr("transform", opts.transFn).attr("d", opts.path).call(Color2.stroke, ax.zerolinecolor || Color2.defaultLine).style("stroke-width", Drawing.crispRound(gd2, ax.zerolinewidth, ax._gw || 1) + "px").style("display", null);
+            hideCounterAxisInsideTickLabels(ax, [ZERO_PATH]);
+          };
+          axes.drawLabels = function(gd2, ax, opts) {
+            opts = opts || {};
+            var fullLayout = gd2._fullLayout;
+            var axId = ax._id;
+            var zerolineIsAbove = ax.zerolinelayer === "above traces";
+            var cls = opts.cls || axId + "tick";
+            var vals = opts.vals.filter(function(d2) {
+              return d2.text;
+            });
+            var labelFns = opts.labelFns;
+            var tickAngle = opts.secondary ? 0 : ax.tickangle;
+            var prevAngle = (ax._prevTickAngles || {})[cls];
+            var tickLabels = opts.layer.selectAll("g." + cls).data(ax.showticklabels ? vals : [], tickDataFn);
+            var labelsReady = [];
+            tickLabels.enter().append("g").classed(cls, 1).append("text").attr("text-anchor", "middle").each(function(d2) {
+              var thisLabel = d3.select(this);
+              var newPromise = gd2._promises.length;
+              thisLabel.call(svgTextUtils.positionText, labelFns.xFn(d2), labelFns.yFn(d2)).call(Drawing.font, {
+                family: d2.font,
+                size: d2.fontSize,
+                color: d2.fontColor,
+                weight: d2.fontWeight,
+                style: d2.fontStyle,
+                variant: d2.fontVariant,
+                textcase: d2.fontTextcase,
+                lineposition: d2.fontLineposition,
+                shadow: d2.fontShadow
+              }).text(d2.text).call(svgTextUtils.convertToTspans, gd2);
+              if (gd2._promises[newPromise]) {
+                labelsReady.push(gd2._promises.pop().then(function() {
+                  positionLabels(thisLabel, tickAngle);
+                }));
+              } else {
+                positionLabels(thisLabel, tickAngle);
+              }
+            });
+            hideCounterAxisInsideTickLabels(ax, [TICK_TEXT]);
+            tickLabels.exit().remove();
+            if (opts.repositionOnUpdate) {
+              tickLabels.each(function(d2) {
+                d3.select(this).select("text").call(svgTextUtils.positionText, labelFns.xFn(d2), labelFns.yFn(d2));
+              });
+            }
+            function positionLabels(s2, angle2) {
+              s2.each(function(d2) {
+                var thisLabel = d3.select(this);
+                var mathjaxGroup = thisLabel.select(".text-math-group");
+                var anchor = labelFns.anchorFn(d2, angle2);
+                var transform = opts.transFn.call(thisLabel.node(), d2) + (isNumeric(angle2) && +angle2 !== 0 ? " rotate(" + angle2 + "," + labelFns.xFn(d2) + "," + (labelFns.yFn(d2) - d2.fontSize / 2) + ")" : "");
+                var nLines = svgTextUtils.lineCount(thisLabel);
+                var lineHeight = LINE_SPACING * d2.fontSize;
+                var anchorHeight = labelFns.heightFn(d2, isNumeric(angle2) ? +angle2 : 0, (nLines - 1) * lineHeight);
+                if (anchorHeight) {
+                  transform += strTranslate(0, anchorHeight);
+                }
+                if (mathjaxGroup.empty()) {
+                  var thisText = thisLabel.select("text");
+                  thisText.attr({
+                    transform,
+                    "text-anchor": anchor
+                  });
+                  thisText.style("display", null);
+                  if (ax._adjustTickLabelsOverflow) {
+                    ax._adjustTickLabelsOverflow();
+                  }
+                } else {
+                  var mjWidth = Drawing.bBox(mathjaxGroup.node()).width;
+                  var mjShift = mjWidth * { end: -0.5, start: 0.5 }[anchor];
+                  mathjaxGroup.attr("transform", transform + strTranslate(mjShift, 0));
+                }
+              });
+            }
+            ax._adjustTickLabelsOverflow = function() {
+              var ticklabeloverflow = ax.ticklabeloverflow;
+              if (!ticklabeloverflow || ticklabeloverflow === "allow") return;
+              var hideOverflow = ticklabeloverflow.indexOf("hide") !== -1;
+              var isX = ax._id.charAt(0) === "x";
+              var p02 = 0;
+              var p12 = isX ? gd2._fullLayout.width : gd2._fullLayout.height;
+              if (ticklabeloverflow.indexOf("domain") !== -1) {
+                var rl2 = Lib.simpleMap(ax.range, ax.r2l);
+                p02 = ax.l2p(rl2[0]) + ax._offset;
+                p12 = ax.l2p(rl2[1]) + ax._offset;
+              }
+              var min = Math.min(p02, p12);
+              var max = Math.max(p02, p12);
+              var side = ax.side;
+              var visibleLabelMin = Infinity;
+              var visibleLabelMax = -Infinity;
+              tickLabels.each(function(d2) {
+                var thisLabel = d3.select(this);
+                var mathjaxGroup = thisLabel.select(".text-math-group");
+                if (mathjaxGroup.empty()) {
+                  var bb2 = Drawing.bBox(thisLabel.node());
+                  var adjust = 0;
+                  if (isX) {
+                    if (bb2.right > max) adjust = 1;
+                    else if (bb2.left < min) adjust = 1;
+                  } else {
+                    if (bb2.bottom > max) adjust = 1;
+                    else if (bb2.top + (ax.tickangle ? 0 : d2.fontSize / 4) < min) adjust = 1;
+                  }
+                  var t4 = thisLabel.select("text");
+                  if (adjust) {
+                    if (hideOverflow) t4.style("display", "none");
+                  } else if (t4.node().style.display !== "none") {
+                    t4.style("display", null);
+                    if (side === "bottom" || side === "right") {
+                      visibleLabelMin = Math.min(visibleLabelMin, isX ? bb2.top : bb2.left);
+                    } else {
+                      visibleLabelMin = -Infinity;
+                    }
+                    if (side === "top" || side === "left") {
+                      visibleLabelMax = Math.max(visibleLabelMax, isX ? bb2.bottom : bb2.right);
+                    } else {
+                      visibleLabelMax = Infinity;
+                    }
+                  }
+                }
+              });
+              for (var subplot in fullLayout._plots) {
+                var plotinfo = fullLayout._plots[subplot];
+                if (ax._id !== plotinfo.xaxis._id && ax._id !== plotinfo.yaxis._id) continue;
+                var anchorAx2 = isX ? plotinfo.yaxis : plotinfo.xaxis;
+                if (anchorAx2) {
+                  anchorAx2["_visibleLabelMin_" + ax._id] = visibleLabelMin;
+                  anchorAx2["_visibleLabelMax_" + ax._id] = visibleLabelMax;
+                }
+              }
+            };
+            ax._hideCounterAxisInsideTickLabels = function(partialOpts) {
+              var isX = ax._id.charAt(0) === "x";
+              var anchoredAxes = [];
+              for (var subplot in fullLayout._plots) {
+                var plotinfo = fullLayout._plots[subplot];
+                if (ax._id !== plotinfo.xaxis._id && ax._id !== plotinfo.yaxis._id) continue;
+                anchoredAxes.push(isX ? plotinfo.yaxis : plotinfo.xaxis);
+              }
+              anchoredAxes.forEach(function(anchorAx2, idx) {
+                if (anchorAx2 && insideTicklabelposition(anchorAx2)) {
+                  (partialOpts || [
+                    ZERO_PATH,
+                    MINORGRID_PATH,
+                    GRID_PATH,
+                    TICK_PATH,
+                    TICK_TEXT
+                  ]).forEach(function(e2) {
+                    var isPeriodLabel = e2.K === "tick" && e2.L === "text" && ax.ticklabelmode === "period";
+                    var mainPlotinfo = fullLayout._plots[ax._mainSubplot];
+                    var sel;
+                    if (e2.K === ZERO_PATH.K) {
+                      var zerolineLayer = zerolineIsAbove ? mainPlotinfo.zerolinelayerAbove : mainPlotinfo.zerolinelayer;
+                      sel = zerolineLayer.selectAll("." + ax._id + "zl");
+                    } else if (e2.K === MINORGRID_PATH.K) sel = mainPlotinfo.minorGridlayer.selectAll("." + ax._id);
+                    else if (e2.K === GRID_PATH.K) sel = mainPlotinfo.gridlayer.selectAll("." + ax._id);
+                    else sel = mainPlotinfo[ax._id.charAt(0) + "axislayer"];
+                    sel.each(function() {
+                      var w2 = d3.select(this);
+                      if (e2.L) w2 = w2.selectAll(e2.L);
+                      w2.each(function(d2) {
+                        var q2 = ax.l2p(
+                          isPeriodLabel ? getPosX(d2) : d2.x
+                        ) + ax._offset;
+                        var t4 = d3.select(this);
+                        if (q2 < ax["_visibleLabelMax_" + anchorAx2._id] && q2 > ax["_visibleLabelMin_" + anchorAx2._id]) {
+                          t4.style("display", "none");
+                        } else if (e2.K === "tick" && !idx && t4.node().style.display !== "none") {
+                          t4.style("display", null);
+                        }
+                      });
+                    });
+                  });
+                }
+              });
+            };
+            positionLabels(tickLabels, prevAngle + 1 ? prevAngle : tickAngle);
+            function allLabelsReady() {
+              return labelsReady.length && Promise.all(labelsReady);
+            }
+            var autoangle = null;
+            function fixLabelOverlaps() {
+              positionLabels(tickLabels, tickAngle);
+              if (vals.length && ax.autotickangles && (ax.type !== "log" || String(ax.dtick).charAt(0) !== "D")) {
+                autoangle = ax.autotickangles[0];
+                var maxFontSize = 0;
+                var lbbArray = [];
+                var i2;
+                var maxLines = 1;
+                tickLabels.each(function(d2) {
+                  maxFontSize = Math.max(maxFontSize, d2.fontSize);
+                  var x2 = ax.l2p(d2.x);
+                  var thisLabel = selectTickLabel(this);
+                  var bb2 = Drawing.bBox(thisLabel.node());
+                  maxLines = Math.max(maxLines, svgTextUtils.lineCount(thisLabel));
+                  lbbArray.push({
+                    // ignore about y, just deal with x overlaps
+                    top: 0,
+                    bottom: 10,
+                    height: 10,
+                    left: x2 - bb2.width / 2,
+                    // impose a 2px gap
+                    right: x2 + bb2.width / 2 + 2,
+                    width: bb2.width + 2
+                  });
+                });
+                var preventOverlapWithTick = (ax.tickson === "boundaries" || ax.showdividers) && !opts.secondary;
+                var vLen = vals.length;
+                var tickSpacing = Math.abs((vals[vLen - 1].x - vals[0].x) * ax._m) / (vLen - 1);
+                var adjacent = preventOverlapWithTick ? tickSpacing / 2 : tickSpacing;
+                var opposite = preventOverlapWithTick ? ax.ticklen : maxFontSize * 1.25 * maxLines;
+                var hypotenuse = Math.sqrt(Math.pow(adjacent, 2) + Math.pow(opposite, 2));
+                var maxCos = adjacent / hypotenuse;
+                var autoTickAnglesRadians = ax.autotickangles.map(
+                  function(degrees3) {
+                    return degrees3 * Math.PI / 180;
+                  }
+                );
+                var angleRadians = autoTickAnglesRadians.find(
+                  function(angle2) {
+                    return Math.abs(Math.cos(angle2)) <= maxCos;
+                  }
+                );
+                if (angleRadians === void 0) {
+                  angleRadians = autoTickAnglesRadians.reduce(
+                    function(currentMax, nextAngle) {
+                      return Math.abs(Math.cos(currentMax)) < Math.abs(Math.cos(nextAngle)) ? currentMax : nextAngle;
+                    },
+                    autoTickAnglesRadians[0]
+                  );
+                }
+                var newAngle = angleRadians * (180 / Math.PI);
+                if (preventOverlapWithTick) {
+                  var gap = 2;
+                  if (ax.ticks) gap += ax.tickwidth / 2;
+                  for (i2 = 0; i2 < lbbArray.length; i2++) {
+                    var xbnd = vals[i2].xbnd;
+                    var lbb = lbbArray[i2];
+                    if (xbnd[0] !== null && lbb.left - ax.l2p(xbnd[0]) < gap || xbnd[1] !== null && ax.l2p(xbnd[1]) - lbb.right < gap) {
+                      autoangle = newAngle;
+                      break;
+                    }
+                  }
+                } else {
+                  var ticklabelposition = ax.ticklabelposition || "";
+                  var tickson = ax.tickson || "";
+                  var has = function(str) {
+                    return ticklabelposition.indexOf(str) !== -1;
+                  };
+                  var isTop = has("top");
+                  var isLeft = has("left");
+                  var isRight = has("right");
+                  var isBottom = has("bottom");
+                  var isAligned = tickson !== "boundaries" && (isBottom || isLeft || isTop || isRight);
+                  var pad = !isAligned ? 0 : (ax.tickwidth || 0) + 2 * TEXTPAD;
+                  for (i2 = 0; i2 < lbbArray.length - 1; i2++) {
+                    if (Lib.bBoxIntersect(lbbArray[i2], lbbArray[i2 + 1], pad)) {
+                      autoangle = newAngle;
+                      break;
+                    }
+                  }
+                }
+                if (autoangle) {
+                  positionLabels(tickLabels, autoangle);
+                }
+              }
+            }
+            if (ax._selections) {
+              ax._selections[cls] = tickLabels;
+            }
+            var seq = [allLabelsReady];
+            if (ax.automargin && fullLayout._redrawFromAutoMarginCount && prevAngle === 90) {
+              autoangle = prevAngle;
+              seq.push(function() {
+                positionLabels(tickLabels, prevAngle);
+              });
+            } else {
+              seq.push(fixLabelOverlaps);
+            }
+            if (ax._tickAngles) {
+              seq.push(function() {
+                ax._tickAngles[cls] = autoangle === null ? isNumeric(tickAngle) ? tickAngle : 0 : autoangle;
+              });
+            }
+            var computeTickLabelBoundingBoxes = function() {
+              var labelsMaxW = 0;
+              var labelsMaxH = 0;
+              tickLabels.each(function(d2, i2) {
+                var thisLabel = selectTickLabel(this);
+                var mathjaxGroup = thisLabel.select(".text-math-group");
+                if (mathjaxGroup.empty()) {
+                  var bb2;
+                  if (ax._vals[i2]) {
+                    bb2 = ax._vals[i2].bb || Drawing.bBox(thisLabel.node());
+                    ax._vals[i2].bb = bb2;
+                  }
+                  labelsMaxW = Math.max(labelsMaxW, bb2.width);
+                  labelsMaxH = Math.max(labelsMaxH, bb2.height);
+                }
+              });
+              return {
+                labelsMaxW,
+                labelsMaxH
+              };
+            };
+            var anchorAx = ax._anchorAxis;
+            if (anchorAx && (anchorAx.autorange || anchorAx.insiderange) && insideTicklabelposition(ax) && !isLinked(fullLayout, ax._id)) {
+              if (!fullLayout._insideTickLabelsUpdaterange) {
+                fullLayout._insideTickLabelsUpdaterange = {};
+              }
+              if (anchorAx.autorange) {
+                fullLayout._insideTickLabelsUpdaterange[anchorAx._name + ".autorange"] = anchorAx.autorange;
+                seq.push(computeTickLabelBoundingBoxes);
+              }
+              if (anchorAx.insiderange) {
+                var BBs = computeTickLabelBoundingBoxes();
+                var move = ax._id.charAt(0) === "y" ? BBs.labelsMaxW : BBs.labelsMaxH;
+                move += 2 * TEXTPAD;
+                if (ax.ticklabelposition === "inside") {
+                  move += ax.ticklen || 0;
+                }
+                var sgn = ax.side === "right" || ax.side === "top" ? 1 : -1;
+                var index = sgn === 1 ? 1 : 0;
+                var otherIndex = sgn === 1 ? 0 : 1;
+                var newRange = [];
+                newRange[otherIndex] = anchorAx.range[otherIndex];
+                var anchorAxRange = anchorAx.range;
+                var p0 = anchorAx.r2p(anchorAxRange[index]);
+                var p1 = anchorAx.r2p(anchorAxRange[otherIndex]);
+                var _tempNewRange = fullLayout._insideTickLabelsUpdaterange[anchorAx._name + ".range"];
+                if (_tempNewRange) {
+                  var q0 = anchorAx.r2p(_tempNewRange[index]);
+                  var q1 = anchorAx.r2p(_tempNewRange[otherIndex]);
+                  var dir = sgn * (ax._id.charAt(0) === "y" ? 1 : -1);
+                  if (dir * p0 < dir * q0) {
+                    p0 = q0;
+                    newRange[index] = anchorAxRange[index] = _tempNewRange[index];
+                  }
+                  if (dir * p1 > dir * q1) {
+                    p1 = q1;
+                    newRange[otherIndex] = anchorAxRange[otherIndex] = _tempNewRange[otherIndex];
+                  }
+                }
+                var dist = Math.abs(p1 - p0);
+                if (dist - move > 0) {
+                  dist -= move;
+                  move *= 1 + move / dist;
+                } else {
+                  move = 0;
+                }
+                if (ax._id.charAt(0) !== "y") move = -move;
+                newRange[index] = anchorAx.p2r(
+                  anchorAx.r2p(anchorAxRange[index]) + sgn * move
+                );
+                if (anchorAx.autorange === "min" || anchorAx.autorange === "max reversed") {
+                  newRange[0] = null;
+                  anchorAx._rangeInitial0 = void 0;
+                  anchorAx._rangeInitial1 = void 0;
+                } else if (anchorAx.autorange === "max" || anchorAx.autorange === "min reversed") {
+                  newRange[1] = null;
+                  anchorAx._rangeInitial0 = void 0;
+                  anchorAx._rangeInitial1 = void 0;
+                }
+                fullLayout._insideTickLabelsUpdaterange[anchorAx._name + ".range"] = newRange;
+              }
+            }
+            var done = Lib.syncOrAsync(seq);
+            if (done && done.then) gd2._promises.push(done);
+            return done;
+          };
+          function drawDividers(gd2, ax, opts) {
+            var cls = ax._id + "divider";
+            var vals = opts.vals;
+            var dividers = opts.layer.selectAll("path." + cls).data(vals, tickDataFn);
+            dividers.exit().remove();
+            dividers.enter().insert("path", ":first-child").classed(cls, 1).classed("crisp", 1).call(Color2.stroke, ax.dividercolor).style("stroke-width", Drawing.crispRound(gd2, ax.dividerwidth, 1) + "px");
+            dividers.attr("transform", opts.transFn).attr("d", opts.path);
+          }
+          axes.getPxPosition = function(gd2, ax) {
+            var gs = gd2._fullLayout._size;
+            var axLetter = ax._id.charAt(0);
+            var side = ax.side;
+            var anchorAxis;
+            if (ax.anchor !== "free") {
+              anchorAxis = ax._anchorAxis;
+            } else if (axLetter === "x") {
+              anchorAxis = {
+                _offset: gs.t + (1 - (ax.position || 0)) * gs.h,
+                _length: 0
+              };
+            } else if (axLetter === "y") {
+              anchorAxis = {
+                _offset: gs.l + (ax.position || 0) * gs.w + ax._shift,
+                _length: 0
+              };
+            }
+            if (side === "top" || side === "left") {
+              return anchorAxis._offset;
+            } else if (side === "bottom" || side === "right") {
+              return anchorAxis._offset + anchorAxis._length;
+            }
+          };
+          function approxTitleDepth(ax) {
+            var fontSize = ax.title.font.size;
+            var extraLines = (ax.title.text.match(svgTextUtils.BR_TAG_ALL) || []).length;
+            if (ax.title.hasOwnProperty("standoff")) {
+              return fontSize * (CAP_SHIFT + extraLines * LINE_SPACING);
+            } else {
+              return extraLines ? fontSize * (extraLines + 1) * LINE_SPACING : fontSize;
+            }
+          }
+          function drawTitle(gd2, ax) {
+            var fullLayout = gd2._fullLayout;
+            var axId = ax._id;
+            var axLetter = axId.charAt(0);
+            var fontSize = ax.title.font.size;
+            var titleStandoff;
+            var extraLines = (ax.title.text.match(svgTextUtils.BR_TAG_ALL) || []).length;
+            if (ax.title.hasOwnProperty("standoff")) {
+              if (ax.side === "bottom" || ax.side === "right") {
+                titleStandoff = ax._depth + ax.title.standoff + fontSize * CAP_SHIFT;
+              } else if (ax.side === "top" || ax.side === "left") {
+                titleStandoff = ax._depth + ax.title.standoff + fontSize * (MID_SHIFT + extraLines * LINE_SPACING);
+              }
+            } else {
+              var isInside = insideTicklabelposition(ax);
+              if (ax.type === "multicategory") {
+                titleStandoff = ax._depth;
+              } else {
+                var offsetBase = 1.5 * fontSize;
+                if (isInside) {
+                  offsetBase = 0.5 * fontSize;
+                  if (ax.ticks === "outside") {
+                    offsetBase += ax.ticklen;
+                  }
+                }
+                titleStandoff = 10 + offsetBase + (ax.linewidth ? ax.linewidth - 1 : 0);
+              }
+              if (!isInside) {
+                if (axLetter === "x") {
+                  titleStandoff += ax.side === "top" ? fontSize * (ax.showticklabels ? 1 : 0) : fontSize * (ax.showticklabels ? 1.5 : 0.5);
+                } else {
+                  titleStandoff += ax.side === "right" ? fontSize * (ax.showticklabels ? 1 : 0.5) : fontSize * (ax.showticklabels ? 0.5 : 0);
+                }
+              }
+            }
+            var pos = axes.getPxPosition(gd2, ax);
+            var transform, x2, y2;
+            if (axLetter === "x") {
+              x2 = ax._offset + ax._length / 2;
+              y2 = ax.side === "top" ? pos - titleStandoff : pos + titleStandoff;
+            } else {
+              y2 = ax._offset + ax._length / 2;
+              x2 = ax.side === "right" ? pos + titleStandoff : pos - titleStandoff;
+              transform = { rotate: "-90", offset: 0 };
+            }
+            var avoid;
+            if (ax.type !== "multicategory") {
+              var tickLabels = ax._selections[ax._id + "tick"];
+              avoid = {
+                selection: tickLabels,
+                side: ax.side
+              };
+              if (tickLabels && tickLabels.node() && tickLabels.node().parentNode) {
+                var translation = Drawing.getTranslate(tickLabels.node().parentNode);
+                avoid.offsetLeft = translation.x;
+                avoid.offsetTop = translation.y;
+              }
+              if (ax.title.hasOwnProperty("standoff")) {
+                avoid.pad = 0;
+              }
+            }
+            ax._titleStandoff = titleStandoff;
+            return Titles.draw(gd2, axId + "title", {
+              propContainer: ax,
+              propName: ax._name + ".title.text",
+              placeholder: fullLayout._dfltTitle[axLetter],
+              avoid,
+              transform,
+              attributes: { x: x2, y: y2, "text-anchor": "middle" }
+            });
+          }
+          axes.shouldShowZeroLine = function(gd2, ax, counterAxis) {
+            var rng = Lib.simpleMap(ax.range, ax.r2l);
+            return rng[0] * rng[1] <= 0 && ax.zeroline && (ax.type === "linear" || ax.type === "-") && !(ax.rangebreaks && ax.maskBreaks(0) === BADNUM) && (clipEnds(ax, 0) || !anyCounterAxLineAtZero(gd2, ax, counterAxis, rng) || hasBarsOrFill(gd2, ax));
+          };
+          axes.clipEnds = function(ax, vals) {
+            return vals.filter(function(d2) {
+              return clipEnds(ax, d2.x);
+            });
+          };
+          function clipEnds(ax, l2) {
+            var p2 = ax.l2p(l2);
+            return p2 > 1 && p2 < ax._length - 1;
+          }
+          function anyCounterAxLineAtZero(gd2, ax, counterAxis, rng) {
+            var mainCounterAxis = counterAxis._mainAxis;
+            if (!mainCounterAxis) return;
+            var fullLayout = gd2._fullLayout;
+            var axLetter = ax._id.charAt(0);
+            var counterLetter = axes.counterLetter(ax._id);
+            var zeroPosition = ax._offset + (Math.abs(rng[0]) < Math.abs(rng[1]) === (axLetter === "x") ? 0 : ax._length);
+            function lineNearZero(ax2) {
+              if (!ax2.showline || !ax2.linewidth) return false;
+              var tolerance = Math.max((ax2.linewidth + ax.zerolinewidth) / 2, 1);
+              function closeEnough(pos2) {
+                return typeof pos2 === "number" && Math.abs(pos2 - zeroPosition) < tolerance;
+              }
+              if (closeEnough(ax2._mainLinePosition) || closeEnough(ax2._mainMirrorPosition)) {
+                return true;
+              }
+              var linePositions = ax2._linepositions || {};
+              for (var k2 in linePositions) {
+                if (closeEnough(linePositions[k2][0]) || closeEnough(linePositions[k2][1])) {
+                  return true;
+                }
+              }
+            }
+            var plotinfo = fullLayout._plots[counterAxis._mainSubplot];
+            if (!(plotinfo.mainplotinfo || plotinfo).overlays.length) {
+              return lineNearZero(counterAxis);
+            }
+            var counterLetterAxes = axes.list(gd2, counterLetter);
+            for (var i2 = 0; i2 < counterLetterAxes.length; i2++) {
+              var counterAxis2 = counterLetterAxes[i2];
+              if (counterAxis2._mainAxis === mainCounterAxis && lineNearZero(counterAxis2)) {
+                return true;
+              }
+            }
+          }
+          function hasBarsOrFill(gd2, ax) {
+            var fullData = gd2._fullData;
+            var subplot = ax._mainSubplot;
+            var axLetter = ax._id.charAt(0);
+            for (var i2 = 0; i2 < fullData.length; i2++) {
+              var trace = fullData[i2];
+              if (trace.visible === true && trace.xaxis + trace.yaxis === subplot) {
+                if (Registry.traceIs(trace, "bar-like") && trace.orientation === { x: "h", y: "v" }[axLetter]) return true;
+                if (trace.fill && trace.fill.charAt(trace.fill.length - 1) === axLetter) return true;
+              }
+            }
+            return false;
+          }
+          function selectTickLabel(gTick) {
+            var s2 = d3.select(gTick);
+            var mj2 = s2.select(".text-math-group");
+            return mj2.empty() ? s2.select("text") : mj2;
+          }
+          axes.allowAutoMargin = function(gd2) {
+            var axList = axes.list(gd2, "", true);
+            for (var i2 = 0; i2 < axList.length; i2++) {
+              var ax = axList[i2];
+              if (ax.automargin) {
+                Plots.allowAutoMargin(gd2, axAutoMarginID(ax));
+                if (ax.mirror) {
+                  Plots.allowAutoMargin(gd2, axMirrorAutoMarginID(ax));
+                }
+              }
+              if (Registry.getComponentMethod("rangeslider", "isVisible")(ax)) {
+                Plots.allowAutoMargin(gd2, rangeSliderAutoMarginID(ax));
+              }
+            }
+          };
+          function axAutoMarginID(ax) {
+            return ax._id + ".automargin";
+          }
+          function axMirrorAutoMarginID(ax) {
+            return axAutoMarginID(ax) + ".mirror";
+          }
+          function rangeSliderAutoMarginID(ax) {
+            return ax._id + ".rangeslider";
+          }
+          axes.swap = function(gd2, traces) {
+            var axGroups = makeAxisGroups(gd2, traces);
+            for (var i2 = 0; i2 < axGroups.length; i2++) {
+              swapAxisGroup(gd2, axGroups[i2].x, axGroups[i2].y);
+            }
+          };
+          function makeAxisGroups(gd2, traces) {
+            var groups = [];
+            var i2, j2;
+            for (i2 = 0; i2 < traces.length; i2++) {
+              var groupsi = [];
+              var xi2 = gd2._fullData[traces[i2]].xaxis;
+              var yi2 = gd2._fullData[traces[i2]].yaxis;
+              if (!xi2 || !yi2) continue;
+              for (j2 = 0; j2 < groups.length; j2++) {
+                if (groups[j2].x.indexOf(xi2) !== -1 || groups[j2].y.indexOf(yi2) !== -1) {
+                  groupsi.push(j2);
+                }
+              }
+              if (!groupsi.length) {
+                groups.push({ x: [xi2], y: [yi2] });
+                continue;
+              }
+              var group0 = groups[groupsi[0]];
+              var groupj;
+              if (groupsi.length > 1) {
+                for (j2 = 1; j2 < groupsi.length; j2++) {
+                  groupj = groups[groupsi[j2]];
+                  mergeAxisGroups(group0.x, groupj.x);
+                  mergeAxisGroups(group0.y, groupj.y);
+                }
+              }
+              mergeAxisGroups(group0.x, [xi2]);
+              mergeAxisGroups(group0.y, [yi2]);
+            }
+            return groups;
+          }
+          function mergeAxisGroups(intoSet, fromSet) {
+            for (var i2 = 0; i2 < fromSet.length; i2++) {
+              if (intoSet.indexOf(fromSet[i2]) === -1) intoSet.push(fromSet[i2]);
+            }
+          }
+          function swapAxisGroup(gd2, xIds, yIds) {
+            var xFullAxes = [];
+            var yFullAxes = [];
+            var layout = gd2.layout;
+            var i2, j2;
+            for (i2 = 0; i2 < xIds.length; i2++) xFullAxes.push(axes.getFromId(gd2, xIds[i2]));
+            for (i2 = 0; i2 < yIds.length; i2++) yFullAxes.push(axes.getFromId(gd2, yIds[i2]));
+            var allAxKeys = Object.keys(axAttrs);
+            var noSwapAttrs = [
+              "anchor",
+              "domain",
+              "overlaying",
+              "position",
+              "side",
+              "tickangle",
+              "editType"
+            ];
+            var numericTypes = ["linear", "log"];
+            for (i2 = 0; i2 < allAxKeys.length; i2++) {
+              var keyi = allAxKeys[i2];
+              var xVal = xFullAxes[0][keyi];
+              var yVal = yFullAxes[0][keyi];
+              var allEqual = true;
+              var coerceLinearX = false;
+              var coerceLinearY = false;
+              if (keyi.charAt(0) === "_" || typeof xVal === "function" || noSwapAttrs.indexOf(keyi) !== -1) {
+                continue;
+              }
+              for (j2 = 1; j2 < xFullAxes.length && allEqual; j2++) {
+                var xVali = xFullAxes[j2][keyi];
+                if (keyi === "type" && numericTypes.indexOf(xVal) !== -1 && numericTypes.indexOf(xVali) !== -1 && xVal !== xVali) {
+                  coerceLinearX = true;
+                } else if (xVali !== xVal) allEqual = false;
+              }
+              for (j2 = 1; j2 < yFullAxes.length && allEqual; j2++) {
+                var yVali = yFullAxes[j2][keyi];
+                if (keyi === "type" && numericTypes.indexOf(yVal) !== -1 && numericTypes.indexOf(yVali) !== -1 && yVal !== yVali) {
+                  coerceLinearY = true;
+                } else if (yFullAxes[j2][keyi] !== yVal) allEqual = false;
+              }
+              if (allEqual) {
+                if (coerceLinearX) layout[xFullAxes[0]._name].type = "linear";
+                if (coerceLinearY) layout[yFullAxes[0]._name].type = "linear";
+                swapAxisAttrs(layout, keyi, xFullAxes, yFullAxes, gd2._fullLayout._dfltTitle);
+              }
+            }
+            for (i2 = 0; i2 < gd2._fullLayout.annotations.length; i2++) {
+              var ann = gd2._fullLayout.annotations[i2];
+              if (xIds.indexOf(ann.xref) !== -1 && yIds.indexOf(ann.yref) !== -1) {
+                Lib.swapAttrs(layout.annotations[i2], ["?"]);
+              }
+            }
+          }
+          function swapAxisAttrs(layout, key, xFullAxes, yFullAxes, dfltTitle) {
+            var np = Lib.nestedProperty;
+            var xVal = np(layout[xFullAxes[0]._name], key).get();
+            var yVal = np(layout[yFullAxes[0]._name], key).get();
+            var i2;
+            if (key === "title") {
+              if (xVal && xVal.text === dfltTitle.x) {
+                xVal.text = dfltTitle.y;
+              }
+              if (yVal && yVal.text === dfltTitle.y) {
+                yVal.text = dfltTitle.x;
+              }
+            }
+            for (i2 = 0; i2 < xFullAxes.length; i2++) {
+              np(layout, xFullAxes[i2]._name + "." + key).set(yVal);
+            }
+            for (i2 = 0; i2 < yFullAxes.length; i2++) {
+              np(layout, yFullAxes[i2]._name + "." + key).set(xVal);
+            }
+          }
+          function isAngular(ax) {
+            return ax._id === "angularaxis";
+          }
+          function moveOutsideBreak(v2, ax) {
+            var len2 = ax._rangebreaks.length;
+            for (var k2 = 0; k2 < len2; k2++) {
+              var brk = ax._rangebreaks[k2];
+              if (v2 >= brk.min && v2 < brk.max) {
+                return brk.max;
+              }
+            }
+            return v2;
+          }
+          function insideTicklabelposition(ax) {
+            return (ax.ticklabelposition || "").indexOf("inside") !== -1;
+          }
+          function hideCounterAxisInsideTickLabels(ax, opts) {
+            if (insideTicklabelposition(ax._anchorAxis || {})) {
+              if (ax._hideCounterAxisInsideTickLabels) {
+                ax._hideCounterAxisInsideTickLabels(opts);
+              }
+            }
+          }
+          function incrementShift(ax, shiftVal, axShifts, normalize) {
+            var overlay = ax.anchor !== "free" && (ax.overlaying === void 0 || ax.overlaying === false) ? ax._id : ax.overlaying;
+            var shiftValAdj;
+            if (normalize) {
+              shiftValAdj = ax.side === "right" ? shiftVal : -shiftVal;
+            } else {
+              shiftValAdj = shiftVal;
+            }
+            if (!(overlay in axShifts)) {
+              axShifts[overlay] = {};
+            }
+            if (!(ax.side in axShifts[overlay])) {
+              axShifts[overlay][ax.side] = 0;
+            }
+            axShifts[overlay][ax.side] += shiftValAdj;
+          }
+          function setShiftVal(ax, axShifts) {
+            return ax.autoshift ? axShifts[ax.overlaying][ax.side] : ax.shift || 0;
+          }
+          function periodCompatibleWithTickformat(period, tickformat) {
+            return /%f/.test(tickformat) ? period >= ONEMICROSEC : /%L/.test(tickformat) ? period >= ONEMILLI : /%[SX]/.test(tickformat) ? period >= ONESEC : /%M/.test(tickformat) ? period >= ONEMIN : /%[HI]/.test(tickformat) ? period >= ONEHOUR : /%p/.test(tickformat) ? period >= HALFDAY : /%[Aadejuwx]/.test(tickformat) ? period >= ONEDAY : /%[UVW]/.test(tickformat) ? period >= ONEWEEK : /%[Bbm]/.test(tickformat) ? period >= ONEMINMONTH : /%[q]/.test(tickformat) ? period >= ONEMINQUARTER : /%[Yy]/.test(tickformat) ? period >= ONEMINYEAR : true;
+          }
+        }
+      });
+      var require_autorange_options_defaults = __commonJS({
+        "src/plots/cartesian/autorange_options_defaults.js"(exports, module2) {
+          module2.exports = function handleAutorangeOptionsDefaults(coerce, autorange, range) {
+            var minRange, maxRange;
+            if (range) {
+              var isReversed = autorange === "reversed" || autorange === "min reversed" || autorange === "max reversed";
+              minRange = range[isReversed ? 1 : 0];
+              maxRange = range[isReversed ? 0 : 1];
+            }
+            var minallowed = coerce("autorangeoptions.minallowed", maxRange === null ? minRange : void 0);
+            var maxallowed = coerce("autorangeoptions.maxallowed", minRange === null ? maxRange : void 0);
+            if (minallowed === void 0) coerce("autorangeoptions.clipmin");
+            if (maxallowed === void 0) coerce("autorangeoptions.clipmax");
+            coerce("autorangeoptions.include");
+          };
+        }
+      });
+      var require_range_defaults = __commonJS({
+        "src/plots/cartesian/range_defaults.js"(exports, module2) {
+          var handleAutorangeOptionsDefaults = require_autorange_options_defaults();
+          module2.exports = function handleRangeDefaults(containerIn, containerOut, coerce, options) {
+            var axTemplate = containerOut._template || {};
+            var axType = containerOut.type || axTemplate.type || "-";
+            coerce("minallowed");
+            coerce("maxallowed");
+            var range = coerce("range");
+            if (!range) {
+              var insiderange;
+              if (!options.noInsiderange && axType !== "log") {
+                insiderange = coerce("insiderange");
+                if (insiderange && (insiderange[0] === null || insiderange[1] === null)) {
+                  containerOut.insiderange = false;
+                  insiderange = void 0;
+                }
+                if (insiderange) range = coerce("range", insiderange);
+              }
+            }
+            var autorangeDflt = containerOut.getAutorangeDflt(range, options);
+            var autorange = coerce("autorange", autorangeDflt);
+            var shouldAutorange;
+            if (range && (range[0] === null && range[1] === null || (range[0] === null || range[1] === null) && (autorange === "reversed" || autorange === true) || range[0] !== null && (autorange === "min" || autorange === "max reversed") || range[1] !== null && (autorange === "max" || autorange === "min reversed"))) {
+              range = void 0;
+              delete containerOut.range;
+              containerOut.autorange = true;
+              shouldAutorange = true;
+            }
+            if (!shouldAutorange) {
+              autorangeDflt = containerOut.getAutorangeDflt(range, options);
+              autorange = coerce("autorange", autorangeDflt);
+            }
+            if (autorange) {
+              handleAutorangeOptionsDefaults(coerce, autorange, range);
+              if (axType === "linear" || axType === "-") coerce("rangemode");
+            }
+            containerOut.cleanRange();
+          };
+        }
+      });
+      var require_mouse_event_offset = __commonJS({
+        "node_modules/mouse-event-offset/index.js"(exports, module2) {
+          var rootPosition = { left: 0, top: 0 };
+          module2.exports = mouseEventOffset;
+          function mouseEventOffset(ev, target, out) {
+            target = target || ev.currentTarget || ev.srcElement;
+            if (!Array.isArray(out)) {
+              out = [0, 0];
+            }
+            var cx = ev.clientX || 0;
+            var cy = ev.clientY || 0;
+            var rect = getBoundingClientOffset(target);
+            out[0] = cx - rect.left;
+            out[1] = cy - rect.top;
+            return out;
+          }
+          function getBoundingClientOffset(element) {
+            if (element === window || element === document || element === document.body) {
+              return rootPosition;
+            } else {
+              return element.getBoundingClientRect();
+            }
+          }
+        }
+      });
+      var require_has_passive_events = __commonJS({
+        "node_modules/has-passive-events/index.js"(exports, module2) {
+          var isBrowser2 = require_client();
+          function detect() {
+            var supported = false;
+            try {
+              var opts = Object.defineProperty({}, "passive", {
+                get: function() {
+                  supported = true;
+                }
+              });
+              window.addEventListener("test", null, opts);
+              window.removeEventListener("test", null, opts);
+            } catch (e2) {
+              supported = false;
+            }
+            return supported;
+          }
+          module2.exports = isBrowser2 && detect();
+        }
+      });
+      var require_align = __commonJS({
+        "src/components/dragelement/align.js"(exports, module2) {
+          module2.exports = function align(v2, dv, v0, v1, anchor) {
+            var vmin = (v2 - v0) / (v1 - v0);
+            var vmax = vmin + dv / (v1 - v0);
+            var vc2 = (vmin + vmax) / 2;
+            if (anchor === "left" || anchor === "bottom") return vmin;
+            if (anchor === "center" || anchor === "middle") return vc2;
+            if (anchor === "right" || anchor === "top") return vmax;
+            if (vmin < 2 / 3 - vc2) return vmin;
+            if (vmax > 4 / 3 - vc2) return vmax;
+            return vc2;
+          };
+        }
+      });
+      var require_cursor = __commonJS({
+        "src/components/dragelement/cursor.js"(exports, module2) {
+          var Lib = require_lib();
+          var cursorset = [
+            ["sw-resize", "s-resize", "se-resize"],
+            ["w-resize", "move", "e-resize"],
+            ["nw-resize", "n-resize", "ne-resize"]
+          ];
+          module2.exports = function getCursor2(x2, y2, xanchor, yanchor) {
+            if (xanchor === "left") x2 = 0;
+            else if (xanchor === "center") x2 = 1;
+            else if (xanchor === "right") x2 = 2;
+            else x2 = Lib.constrain(Math.floor(x2 * 3), 0, 2);
+            if (yanchor === "bottom") y2 = 0;
+            else if (yanchor === "middle") y2 = 1;
+            else if (yanchor === "top") y2 = 2;
+            else y2 = Lib.constrain(Math.floor(y2 * 3), 0, 2);
+            return cursorset[y2][x2];
+          };
+        }
+      });
+      var require_unhover = __commonJS({
+        "src/components/dragelement/unhover.js"(exports, module2) {
+          var Events = require_events2();
+          var throttle = require_throttle();
+          var getGraphDiv = require_dom().getGraphDiv;
+          var hoverConstants = require_constants();
+          var unhover = module2.exports = {};
+          unhover.wrapped = function(gd2, evt, subplot) {
+            gd2 = getGraphDiv(gd2);
+            if (gd2._fullLayout) {
+              throttle.clear(gd2._fullLayout._uid + hoverConstants.HOVERID);
+            }
+            unhover.raw(gd2, evt, subplot);
+          };
+          unhover.raw = function raw(gd2, evt) {
+            var fullLayout = gd2._fullLayout;
+            var oldhoverdata = gd2._hoverdata;
+            if (!evt) evt = {};
+            if (evt.target && !gd2._dragged && Events.triggerHandler(gd2, "plotly_beforehover", evt) === false) {
+              return;
+            }
+            fullLayout._hoverlayer.selectAll("g").remove();
+            fullLayout._hoverlayer.selectAll("line").remove();
+            fullLayout._hoverlayer.selectAll("circle").remove();
+            gd2._hoverdata = void 0;
+            if (evt.target && oldhoverdata) {
+              gd2.emit("plotly_unhover", {
+                event: evt,
+                points: oldhoverdata
+              });
+            }
+          };
+        }
+      });
+      var require_dragelement = __commonJS({
+        "src/components/dragelement/index.js"(exports, module2) {
+          var mouseOffset = require_mouse_event_offset();
+          var hasHover = require_has_hover();
+          var supportsPassive = require_has_passive_events();
+          var removeElement = require_lib().removeElement;
+          var constants = require_constants2();
+          var dragElement = module2.exports = {};
+          dragElement.align = require_align();
+          dragElement.getCursor = require_cursor();
+          var unhover = require_unhover();
+          dragElement.unhover = unhover.wrapped;
+          dragElement.unhoverRaw = unhover.raw;
+          dragElement.init = function init(options) {
+            var gd2 = options.gd;
+            var numClicks = 1;
+            var doubleClickDelay = gd2._context.doubleClickDelay;
+            var element = options.element;
+            var startX, startY, newMouseDownTime, cursor, dragCover, initialEvent, initialTarget, rightClick;
+            if (!gd2._mouseDownTime) gd2._mouseDownTime = 0;
+            element.style.pointerEvents = "all";
+            element.onmousedown = onStart;
+            if (!supportsPassive) {
+              element.ontouchstart = onStart;
+            } else {
+              if (element._ontouchstart) {
+                element.removeEventListener("touchstart", element._ontouchstart);
+              }
+              element._ontouchstart = onStart;
+              element.addEventListener("touchstart", onStart, { passive: false });
+            }
+            function _clampFn(dx, dy, minDrag) {
+              if (Math.abs(dx) < minDrag) dx = 0;
+              if (Math.abs(dy) < minDrag) dy = 0;
+              return [dx, dy];
+            }
+            var clampFn = options.clampFn || _clampFn;
+            function onStart(e2) {
+              gd2._dragged = false;
+              gd2._dragging = true;
+              var offset = pointerOffset(e2);
+              startX = offset[0];
+              startY = offset[1];
+              initialTarget = e2.target;
+              initialEvent = e2;
+              rightClick = e2.buttons === 2 || e2.ctrlKey;
+              if (typeof e2.clientX === "undefined" && typeof e2.clientY === "undefined") {
+                e2.clientX = startX;
+                e2.clientY = startY;
+              }
+              newMouseDownTime = (/* @__PURE__ */ new Date()).getTime();
+              if (newMouseDownTime - gd2._mouseDownTime < doubleClickDelay) {
+                numClicks += 1;
+              } else {
+                numClicks = 1;
+                gd2._mouseDownTime = newMouseDownTime;
+              }
+              if (options.prepFn) options.prepFn(e2, startX, startY);
+              if (hasHover && !rightClick) {
+                dragCover = coverSlip();
+                dragCover.style.cursor = window.getComputedStyle(element).cursor;
+              } else if (!hasHover) {
+                dragCover = document;
+                cursor = window.getComputedStyle(document.documentElement).cursor;
+                document.documentElement.style.cursor = window.getComputedStyle(element).cursor;
+              }
+              document.addEventListener("mouseup", onDone);
+              document.addEventListener("touchend", onDone);
+              if (options.dragmode !== false) {
+                e2.preventDefault();
+                document.addEventListener("mousemove", onMove);
+                document.addEventListener("touchmove", onMove, { passive: false });
+              }
+              return;
+            }
+            function onMove(e2) {
+              e2.preventDefault();
+              var offset = pointerOffset(e2);
+              var minDrag = options.minDrag || constants.MINDRAG;
+              var dxdy = clampFn(offset[0] - startX, offset[1] - startY, minDrag);
+              var dx = dxdy[0];
+              var dy = dxdy[1];
+              if (dx || dy) {
+                gd2._dragged = true;
+                dragElement.unhover(gd2, e2);
+              }
+              if (gd2._dragged && options.moveFn && !rightClick) {
+                gd2._dragdata = {
+                  element,
+                  dx,
+                  dy
+                };
+                options.moveFn(dx, dy);
+              }
+              return;
+            }
+            function onDone(e2) {
+              delete gd2._dragdata;
+              if (options.dragmode !== false) {
+                e2.preventDefault();
+                document.removeEventListener("mousemove", onMove);
+                document.removeEventListener("touchmove", onMove);
+              }
+              document.removeEventListener("mouseup", onDone);
+              document.removeEventListener("touchend", onDone);
+              if (hasHover) {
+                removeElement(dragCover);
+              } else if (cursor) {
+                dragCover.documentElement.style.cursor = cursor;
+                cursor = null;
+              }
+              if (!gd2._dragging) {
+                gd2._dragged = false;
+                return;
+              }
+              gd2._dragging = false;
+              if ((/* @__PURE__ */ new Date()).getTime() - gd2._mouseDownTime > doubleClickDelay) {
+                numClicks = Math.max(numClicks - 1, 1);
+              }
+              if (gd2._dragged) {
+                if (options.doneFn) options.doneFn();
+              } else {
+                var clickEvent;
+                if (initialEvent.target === initialTarget) {
+                  clickEvent = initialEvent;
+                } else {
+                  clickEvent = {
+                    target: initialTarget,
+                    srcElement: initialTarget,
+                    toElement: initialTarget
+                  };
+                  Object.keys(initialEvent).concat(Object.keys(initialEvent.__proto__)).forEach((k2) => {
+                    var v2 = initialEvent[k2];
+                    if (!clickEvent[k2] && typeof v2 !== "function") {
+                      clickEvent[k2] = v2;
+                    }
+                  });
+                }
+                if (options.clickFn) options.clickFn(numClicks, clickEvent);
+                if (!rightClick) {
+                  initialTarget.dispatchEvent(new MouseEvent("click", e2));
+                }
+              }
+              gd2._dragging = false;
+              gd2._dragged = false;
+              return;
+            }
+          };
+          function coverSlip() {
+            var cover = document.createElement("div");
+            cover.className = "dragcover";
+            var cStyle = cover.style;
+            cStyle.position = "fixed";
+            cStyle.left = 0;
+            cStyle.right = 0;
+            cStyle.top = 0;
+            cStyle.bottom = 0;
+            cStyle.zIndex = 999999999;
+            cStyle.background = "none";
+            document.body.appendChild(cover);
+            return cover;
+          }
+          dragElement.coverSlip = coverSlip;
+          function pointerOffset(e2) {
+            return mouseOffset(
+              e2.changedTouches ? e2.changedTouches[0] : e2,
+              document.body
+            );
+          }
+        }
+      });
+      var require_setcursor = __commonJS({
+        "src/lib/setcursor.js"(exports, module2) {
+          module2.exports = function setCursor(el3, csr) {
+            (el3.attr("class") || "").split(" ").forEach(function(cls) {
+              if (cls.indexOf("cursor-") === 0) el3.classed(cls, false);
+            });
+            if (csr) el3.classed("cursor-" + csr, true);
+          };
+        }
+      });
+      var require_override_cursor = __commonJS({
+        "src/lib/override_cursor.js"(exports, module2) {
+          var setCursor = require_setcursor();
+          var STASHATTR = "data-savedcursor";
+          var NO_CURSOR = "!!";
+          module2.exports = function overrideCursor(el3, csr) {
+            var savedCursor = el3.attr(STASHATTR);
+            if (csr) {
+              if (!savedCursor) {
+                var classes = (el3.attr("class") || "").split(" ");
+                for (var i2 = 0; i2 < classes.length; i2++) {
+                  var cls = classes[i2];
+                  if (cls.indexOf("cursor-") === 0) {
+                    el3.attr(STASHATTR, cls.slice(7)).classed(cls, false);
+                  }
+                }
+                if (!el3.attr(STASHATTR)) {
+                  el3.attr(STASHATTR, NO_CURSOR);
+                }
+              }
+              setCursor(el3, csr);
+            } else if (savedCursor) {
+              el3.attr(STASHATTR, null);
+              if (savedCursor === NO_CURSOR) setCursor(el3);
+              else setCursor(el3, savedCursor);
+            }
+          };
+        }
+      });
+      var require_attributes9 = __commonJS({
+        "src/components/legend/attributes.js"(exports, module2) {
+          var fontAttrs = require_font_attributes();
+          var colorAttrs = require_attributes3();
+          module2.exports = {
+            // not really a 'subplot' attribute container,
+            // but this is the flag we use to denote attributes that
+            // support yaxis, yaxis2, yaxis3, ... counters
+            _isSubplotObj: true,
+            visible: {
+              valType: "boolean",
+              dflt: true,
+              editType: "legend"
+            },
+            bgcolor: {
+              valType: "color",
+              editType: "legend"
+            },
+            bordercolor: {
+              valType: "color",
+              dflt: colorAttrs.defaultLine,
+              editType: "legend"
+            },
+            maxheight: {
+              valType: "number",
+              min: 0,
+              editType: "legend"
+            },
+            borderwidth: {
+              valType: "number",
+              min: 0,
+              dflt: 0,
+              editType: "legend"
+            },
+            font: fontAttrs({
+              editType: "legend"
+            }),
+            grouptitlefont: fontAttrs({
+              editType: "legend"
+            }),
+            orientation: {
+              valType: "enumerated",
+              values: ["v", "h"],
+              dflt: "v",
+              editType: "legend"
+            },
+            traceorder: {
+              valType: "flaglist",
+              flags: ["reversed", "grouped"],
+              extras: ["normal"],
+              editType: "legend"
+            },
+            tracegroupgap: {
+              valType: "number",
+              min: 0,
+              dflt: 10,
+              editType: "legend"
+            },
+            entrywidth: {
+              valType: "number",
+              min: 0,
+              editType: "legend"
+            },
+            entrywidthmode: {
+              valType: "enumerated",
+              values: ["fraction", "pixels"],
+              dflt: "pixels",
+              editType: "legend"
+            },
+            indentation: {
+              valType: "number",
+              min: -15,
+              dflt: 0,
+              editType: "legend"
+            },
+            itemsizing: {
+              valType: "enumerated",
+              values: ["trace", "constant"],
+              dflt: "trace",
+              editType: "legend"
+            },
+            itemwidth: {
+              valType: "number",
+              min: 30,
+              dflt: 30,
+              editType: "legend"
+            },
+            itemclick: {
+              valType: "enumerated",
+              values: ["toggle", "toggleothers", false],
+              dflt: "toggle",
+              editType: "legend"
+            },
+            itemdoubleclick: {
+              valType: "enumerated",
+              values: ["toggle", "toggleothers", false],
+              dflt: "toggleothers",
+              editType: "legend"
+            },
+            groupclick: {
+              valType: "enumerated",
+              values: ["toggleitem", "togglegroup"],
+              dflt: "togglegroup",
+              editType: "legend"
+            },
+            titleclick: {
+              valType: "enumerated",
+              values: ["toggle", "toggleothers", false],
+              editType: "legend"
+            },
+            titledoubleclick: {
+              valType: "enumerated",
+              values: ["toggle", "toggleothers", false],
+              editType: "legend"
+            },
+            x: {
+              valType: "number",
+              editType: "legend"
+            },
+            xref: {
+              valType: "enumerated",
+              dflt: "paper",
+              values: ["container", "paper"],
+              editType: "layoutstyle"
+            },
+            xanchor: {
+              valType: "enumerated",
+              values: ["auto", "left", "center", "right"],
+              dflt: "left",
+              editType: "legend"
+            },
+            y: {
+              valType: "number",
+              editType: "legend"
+            },
+            yref: {
+              valType: "enumerated",
+              dflt: "paper",
+              values: ["container", "paper"],
+              editType: "layoutstyle"
+            },
+            yanchor: {
+              valType: "enumerated",
+              values: ["auto", "top", "middle", "bottom"],
+              editType: "legend"
+            },
+            uirevision: {
+              valType: "any",
+              editType: "none"
+            },
+            valign: {
+              valType: "enumerated",
+              values: ["top", "middle", "bottom"],
+              dflt: "middle",
+              editType: "legend"
+            },
+            title: {
+              text: {
+                valType: "string",
+                dflt: "",
+                editType: "legend"
+              },
+              font: fontAttrs({
+                editType: "legend"
+              }),
+              side: {
+                valType: "enumerated",
+                values: ["top", "left", "top left", "top center", "top right"],
+                editType: "legend"
+              },
+              editType: "legend"
+            },
+            editType: "legend"
+          };
+        }
+      });
+      var require_helpers3 = __commonJS({
+        "src/components/legend/helpers.js"(exports) {
+          exports.isGrouped = function isGrouped(legendLayout) {
+            return (legendLayout.traceorder || "").indexOf("grouped") !== -1;
+          };
+          exports.isVertical = function isVertical(legendLayout) {
+            return legendLayout.orientation !== "h";
+          };
+          exports.isReversed = function isReversed(legendLayout) {
+            return (legendLayout.traceorder || "").indexOf("reversed") !== -1;
+          };
+          exports.getId = function getId2(legendObj) {
+            return legendObj._id || "legend";
+          };
+        }
+      });
+      var require_defaults3 = __commonJS({
+        "src/components/legend/defaults.js"(exports, module2) {
+          var Registry = require_registry();
+          var Lib = require_lib();
+          var Template = require_plot_template();
+          var plotsAttrs = require_attributes2();
+          var attributes = require_attributes9();
+          var basePlotLayoutAttributes = require_layout_attributes2();
+          var helpers = require_helpers3();
+          function groupDefaults(legendId, layoutIn, layoutOut, fullData, legendCount) {
+            var containerIn = layoutIn[legendId] || {};
+            var containerOut = Template.newContainer(layoutOut, legendId);
+            function coerce(attr, dflt) {
+              return Lib.coerce(containerIn, containerOut, attributes, attr, dflt);
+            }
+            var itemFont = Lib.coerceFont(coerce, "font", layoutOut.font);
+            coerce("bgcolor", layoutOut.paper_bgcolor);
+            coerce("bordercolor");
+            var visible = coerce("visible");
+            if (!visible) return;
+            var trace;
+            var traceCoerce = function(attr, dflt) {
+              var traceIn = trace._input;
+              var traceOut = trace;
+              return Lib.coerce(traceIn, traceOut, plotsAttrs, attr, dflt);
+            };
+            var globalFont = layoutOut.font || {};
+            var grouptitlefont = Lib.coerceFont(coerce, "grouptitlefont", globalFont, {
+              overrideDflt: {
+                size: Math.round(globalFont.size * 1.1)
+              }
+            });
+            var legendTraceCount = 0;
+            var legendReallyHasATrace = false;
+            var defaultOrder = "normal";
+            var shapesWithLegend = (layoutOut.shapes || []).filter(function(d2) {
+              return d2.showlegend;
+            });
+            function isPieWithLegendArray(trace2) {
+              return Registry.traceIs(trace2, "pie-like") && trace2._length != null && (Array.isArray(trace2.legend) || Array.isArray(trace2.showlegend));
+            }
+            fullData.filter(isPieWithLegendArray).forEach(function(trace2) {
+              if (trace2.visible) {
+                legendTraceCount++;
+              }
+              for (var index = 0; index < trace2._length; index++) {
+                var legend = (Array.isArray(trace2.legend) ? trace2.legend[index] : trace2.legend) || "legend";
+                if (legend === legendId) {
+                  const showInLegend = Array.isArray(trace2.showlegend) ? trace2.showlegend[index] : trace2.showlegend;
+                  if (showInLegend || trace2._dfltShowLegend) {
+                    legendReallyHasATrace = true;
+                    legendTraceCount++;
+                  }
+                }
+              }
+              if (legendId === "legend" && trace2._length > trace2.legend.length) {
+                for (var idx = trace2.legend.length; idx < trace2._length; idx++) {
+                  legendReallyHasATrace = true;
+                  legendTraceCount++;
+                }
+              }
+            });
+            var allLegendItems = fullData.concat(shapesWithLegend).filter(function(d2) {
+              return !isPieWithLegendArray(trace) && legendId === (d2.legend || "legend");
+            });
+            for (var i2 = 0; i2 < allLegendItems.length; i2++) {
+              trace = allLegendItems[i2];
+              if (!trace.visible) continue;
+              var isShape = trace._isShape;
+              if (trace.showlegend || trace._dfltShowLegend && !(trace._module && trace._module.attributes && trace._module.attributes.showlegend && trace._module.attributes.showlegend.dflt === false)) {
+                legendTraceCount++;
+                if (trace.showlegend) {
+                  legendReallyHasATrace = true;
+                  if (!isShape && Registry.traceIs(trace, "pie-like") || trace._input.showlegend === true) {
+                    legendTraceCount++;
+                  }
+                }
+                Lib.coerceFont(traceCoerce, "legendgrouptitle.font", grouptitlefont);
+              }
+              if (!isShape && Registry.traceIs(trace, "bar") && layoutOut.barmode === "stack" || ["tonextx", "tonexty"].indexOf(trace.fill) !== -1) {
+                defaultOrder = helpers.isGrouped({ traceorder: defaultOrder }) ? "grouped+reversed" : "reversed";
+              }
+              if (trace.legendgroup !== void 0 && trace.legendgroup !== "") {
+                defaultOrder = helpers.isReversed({ traceorder: defaultOrder }) ? "reversed+grouped" : "grouped";
+              }
+            }
+            var showLegend = Lib.coerce(
+              layoutIn,
+              layoutOut,
+              basePlotLayoutAttributes,
+              "showlegend",
+              layoutOut.showlegend || legendReallyHasATrace && legendTraceCount > (legendId === "legend" ? 1 : 0)
+            );
+            if (showLegend === false) layoutOut[legendId] = void 0;
+            if (showLegend === false && !containerIn.uirevision) return;
+            coerce("uirevision", layoutOut.uirevision);
+            if (showLegend === false) return;
+            coerce("borderwidth");
+            var orientation = coerce("orientation");
+            var yref = coerce("yref");
+            var xref = coerce("xref");
+            var isHorizontal = orientation === "h";
+            var isPaperY = yref === "paper";
+            var isPaperX = xref === "paper";
+            var defaultX, defaultY, defaultYAnchor;
+            var defaultXAnchor = "left";
+            if (isHorizontal) {
+              defaultX = 0;
+              if (Registry.getComponentMethod("rangeslider", "isVisible")(layoutIn.xaxis)) {
+                if (isPaperY) {
+                  defaultY = 1.1;
+                  defaultYAnchor = "bottom";
+                } else {
+                  defaultY = 1;
+                  defaultYAnchor = "top";
+                }
+              } else {
+                if (isPaperY) {
+                  defaultY = -0.1;
+                  defaultYAnchor = "top";
+                } else {
+                  defaultY = 0;
+                  defaultYAnchor = "bottom";
+                }
+              }
+            } else {
+              defaultY = 1;
+              defaultYAnchor = "auto";
+              if (isPaperX) {
+                defaultX = 1.02;
+              } else {
+                defaultX = 1;
+                defaultXAnchor = "right";
+              }
+            }
+            Lib.coerce(containerIn, containerOut, {
+              x: {
+                valType: "number",
+                editType: "legend",
+                min: isPaperX ? -2 : 0,
+                max: isPaperX ? 3 : 1,
+                dflt: defaultX
+              }
+            }, "x");
+            Lib.coerce(containerIn, containerOut, {
+              y: {
+                valType: "number",
+                editType: "legend",
+                min: isPaperY ? -2 : 0,
+                max: isPaperY ? 3 : 1,
+                dflt: defaultY
+              }
+            }, "y");
+            coerce("traceorder", defaultOrder);
+            if (helpers.isGrouped(layoutOut[legendId])) coerce("tracegroupgap");
+            coerce("entrywidth");
+            coerce("entrywidthmode");
+            coerce("indentation");
+            coerce("itemsizing");
+            coerce("itemwidth");
+            coerce("itemclick");
+            coerce("itemdoubleclick");
+            coerce("groupclick");
+            coerce("xanchor", defaultXAnchor);
+            coerce("yanchor", defaultYAnchor);
+            coerce("maxheight");
+            coerce("valign");
+            Lib.noneOrAll(containerIn, containerOut, ["x", "y"]);
+            var titleText = coerce("title.text");
+            if (titleText) {
+              coerce("title.side", isHorizontal ? "left" : "top");
+              var dfltTitleFont = Lib.extendFlat({}, itemFont, {
+                size: Lib.bigFont(itemFont.size)
+              });
+              Lib.coerceFont(coerce, "title.font", dfltTitleFont);
+              const hasMultipleLegends = legendCount > 1;
+              coerce("titleclick", hasMultipleLegends ? "toggle" : false);
+              coerce("titledoubleclick", hasMultipleLegends ? "toggleothers" : false);
+            }
+          }
+          module2.exports = function legendDefaults(layoutIn, layoutOut, fullData) {
+            var i2;
+            var allLegendsData = fullData.slice();
+            var shapes = layoutOut.shapes;
+            if (shapes) {
+              for (i2 = 0; i2 < shapes.length; i2++) {
+                var shape = shapes[i2];
+                if (!shape.showlegend) continue;
+                var mockTrace = {
+                  _input: shape._input,
+                  visible: shape.visible,
+                  showlegend: shape.showlegend,
+                  legend: shape.legend
+                };
+                allLegendsData.push(mockTrace);
+              }
+            }
+            var legends = ["legend"];
+            for (i2 = 0; i2 < allLegendsData.length; i2++) {
+              if (Array.isArray(allLegendsData[i2].legend)) {
+                legends = legends.concat(allLegendsData[i2].legend);
+              } else {
+                Lib.pushUnique(legends, allLegendsData[i2].legend);
+              }
+            }
+            layoutOut._legends = [];
+            for (i2 = 0; i2 < legends.length; i2++) {
+              var legendId = legends[i2];
+              groupDefaults(legendId, layoutIn, layoutOut, allLegendsData, legends.length);
+              if (layoutOut[legendId]) {
+                layoutOut[legendId]._id = legendId;
+              }
+              layoutOut._legends.push(legendId);
+            }
+          };
+        }
+      });
+      var require_handle_click = __commonJS({
+        "src/components/legend/handle_click.js"(exports) {
+          var Registry = require_registry();
+          var Lib = require_lib();
+          var pushUnique = Lib.pushUnique;
+          var helpers = require_helpers3();
+          var SHOWISOLATETIP = true;
+          exports.handleItemClick = function handleItemClick(g2, gd2, legendObj, mode) {
+            var fullLayout = gd2._fullLayout;
+            if (gd2._dragged || gd2._editing) return;
+            var legendItem = g2.data()[0][0];
+            if (legendItem.groupTitle && legendItem.noClick) return;
+            var groupClick = legendObj.groupclick;
+            if (mode === "toggle" && legendObj.itemdoubleclick === "toggleothers" && SHOWISOLATETIP && gd2.data && gd2._context.showTips) {
+              Lib.notifier(Lib._(gd2, "Double-click on legend to isolate one trace"), "long");
+              SHOWISOLATETIP = false;
+            }
+            var toggleGroup = groupClick === "togglegroup";
+            var hiddenSlices = fullLayout.hiddenlabels ? fullLayout.hiddenlabels.slice() : [];
+            var fullData = gd2._fullData;
+            var shapesWithLegend = (fullLayout.shapes || []).filter(function(d22) {
+              return d22.showlegend;
+            });
+            var allLegendItems = fullData.concat(shapesWithLegend);
+            var fullTrace = legendItem.trace;
+            if (fullTrace._isShape) {
+              fullTrace = fullTrace._fullInput;
+            }
+            var legendgroup = fullTrace.legendgroup;
+            var i2, j2, kcont, key, keys, val;
+            var dataUpdate = {};
+            var dataIndices = [];
+            var carrs = [];
+            var carrIdx = [];
+            function insertDataUpdate(traceIndex, value) {
+              var attrIndex = dataIndices.indexOf(traceIndex);
+              var valueArray = dataUpdate.visible;
+              if (!valueArray) {
+                valueArray = dataUpdate.visible = [];
+              }
+              if (dataIndices.indexOf(traceIndex) === -1) {
+                dataIndices.push(traceIndex);
+                attrIndex = dataIndices.length - 1;
+              }
+              valueArray[attrIndex] = value;
+              return attrIndex;
+            }
+            var updatedShapes = (fullLayout.shapes || []).map(function(d22) {
+              return d22._input;
+            });
+            var shapesUpdated = false;
+            function insertShapesUpdate(shapeIndex, value) {
+              updatedShapes[shapeIndex].visible = value;
+              shapesUpdated = true;
+            }
+            function setVisibility(fullTrace2, visibility) {
+              if (legendItem.groupTitle && !toggleGroup) return;
+              var fullInput2 = fullTrace2._fullInput || fullTrace2;
+              var isShape2 = fullInput2._isShape;
+              var index = fullInput2.index;
+              if (index === void 0) index = fullInput2._index;
+              var nextVisibility2 = fullInput2.visible === false ? false : visibility;
+              if (isShape2) {
+                insertShapesUpdate(index, nextVisibility2);
+              } else {
+                insertDataUpdate(index, nextVisibility2);
+              }
+            }
+            var thisLegend = fullTrace.legend;
+            var fullInput = fullTrace._fullInput;
+            var isShape = fullInput && fullInput._isShape;
+            if (!isShape && Registry.traceIs(fullTrace, "pie-like")) {
+              var thisLabel = legendItem.label;
+              var thisLabelIndex = hiddenSlices.indexOf(thisLabel);
+              if (mode === "toggle") {
+                if (thisLabelIndex === -1) hiddenSlices.push(thisLabel);
+                else hiddenSlices.splice(thisLabelIndex, 1);
+              } else if (mode === "toggleothers") {
+                var changed = thisLabelIndex !== -1;
+                var unhideList = [];
+                for (i2 = 0; i2 < gd2.calcdata.length; i2++) {
+                  var cdi = gd2.calcdata[i2];
+                  for (j2 = 0; j2 < cdi.length; j2++) {
+                    var d2 = cdi[j2];
+                    var dLabel = d2.label;
+                    if (thisLegend === cdi[0].trace.legend) {
+                      if (thisLabel !== dLabel) {
+                        if (hiddenSlices.indexOf(dLabel) === -1) changed = true;
+                        pushUnique(hiddenSlices, dLabel);
+                        unhideList.push(dLabel);
+                      }
+                    }
+                  }
+                }
+                if (!changed) {
+                  for (var q2 = 0; q2 < unhideList.length; q2++) {
+                    var pos = hiddenSlices.indexOf(unhideList[q2]);
+                    if (pos !== -1) {
+                      hiddenSlices.splice(pos, 1);
+                    }
+                  }
+                }
+              }
+              Registry.call("_guiRelayout", gd2, "hiddenlabels", hiddenSlices);
+            } else {
+              var hasLegendgroup = legendgroup && legendgroup.length;
+              var traceIndicesInGroup = [];
+              var tracei;
+              if (hasLegendgroup) {
+                for (i2 = 0; i2 < allLegendItems.length; i2++) {
+                  tracei = allLegendItems[i2];
+                  if (!tracei.visible) continue;
+                  if (tracei.legendgroup === legendgroup) {
+                    traceIndicesInGroup.push(i2);
+                  }
+                }
+              }
+              if (mode === "toggle") {
+                var nextVisibility;
+                switch (fullTrace.visible) {
+                  case true:
+                    nextVisibility = "legendonly";
+                    break;
+                  case false:
+                    nextVisibility = false;
+                    break;
+                  case "legendonly":
+                    nextVisibility = true;
+                    break;
+                }
+                if (hasLegendgroup) {
+                  if (toggleGroup) {
+                    for (i2 = 0; i2 < allLegendItems.length; i2++) {
+                      var item = allLegendItems[i2];
+                      if (item.visible !== false && item.legendgroup === legendgroup) {
+                        setVisibility(item, nextVisibility);
+                      }
+                    }
+                  } else {
+                    setVisibility(fullTrace, nextVisibility);
+                  }
+                } else {
+                  setVisibility(fullTrace, nextVisibility);
+                }
+              } else if (mode === "toggleothers") {
+                var isClicked, isInGroup, notInLegend, otherState, _item;
+                var isIsolated = true;
+                for (i2 = 0; i2 < allLegendItems.length; i2++) {
+                  _item = allLegendItems[i2];
+                  isClicked = _item === fullTrace;
+                  notInLegend = _item.showlegend !== true;
+                  if (isClicked || notInLegend) continue;
+                  isInGroup = hasLegendgroup && _item.legendgroup === legendgroup;
+                  if (!isInGroup && _item.legend === thisLegend && _item.visible === true && !Registry.traceIs(_item, "notLegendIsolatable")) {
+                    isIsolated = false;
+                    break;
+                  }
+                }
+                for (i2 = 0; i2 < allLegendItems.length; i2++) {
+                  _item = allLegendItems[i2];
+                  if (_item.visible === false || _item.legend !== thisLegend) continue;
+                  if (Registry.traceIs(_item, "notLegendIsolatable")) {
+                    continue;
+                  }
+                  switch (fullTrace.visible) {
+                    case "legendonly":
+                      setVisibility(_item, true);
+                      break;
+                    case true:
+                      otherState = isIsolated ? true : "legendonly";
+                      isClicked = _item === fullTrace;
+                      notInLegend = _item.showlegend !== true && !_item.legendgroup;
+                      isInGroup = isClicked || hasLegendgroup && _item.legendgroup === legendgroup;
+                      setVisibility(_item, isInGroup || notInLegend ? true : otherState);
+                      break;
+                  }
+                }
+              }
+              for (i2 = 0; i2 < carrs.length; i2++) {
+                kcont = carrs[i2];
+                if (!kcont) continue;
+                var update = kcont.constructUpdate();
+                var updateKeys = Object.keys(update);
+                for (j2 = 0; j2 < updateKeys.length; j2++) {
+                  key = updateKeys[j2];
+                  val = dataUpdate[key] = dataUpdate[key] || [];
+                  val[carrIdx[i2]] = update[key];
+                }
+              }
+              keys = Object.keys(dataUpdate);
+              for (i2 = 0; i2 < keys.length; i2++) {
+                key = keys[i2];
+                for (j2 = 0; j2 < dataIndices.length; j2++) {
+                  if (!dataUpdate[key].hasOwnProperty(j2)) {
+                    dataUpdate[key][j2] = void 0;
+                  }
+                }
+              }
+              if (shapesUpdated) {
+                Registry.call("_guiUpdate", gd2, dataUpdate, { shapes: updatedShapes }, dataIndices);
+              } else {
+                Registry.call("_guiRestyle", gd2, dataUpdate, dataIndices);
+              }
+            }
+          };
+          exports.handleTitleClick = function handleTitleClick(gd2, legendObj, mode) {
+            const fullLayout = gd2._fullLayout;
+            const fullData = gd2._fullData;
+            const legendId = helpers.getId(legendObj);
+            const shapesWithLegend = (fullLayout.shapes || []).filter(function(d2) {
+              return d2.showlegend;
+            });
+            const allLegendItems = fullData.concat(shapesWithLegend);
+            function isInLegend(item) {
+              return (item.legend || "legend") === legendId;
+            }
+            var toggleThisLegend;
+            var toggleOtherLegends;
+            if (mode === "toggle") {
+              const anyVisibleHere = allLegendItems.some(function(item) {
+                return isInLegend(item) && item.visible === true;
+              });
+              toggleThisLegend = !anyVisibleHere;
+              toggleOtherLegends = false;
+            } else {
+              const anyVisibleElsewhere = allLegendItems.some(function(item) {
+                return !isInLegend(item) && item.visible === true && item.showlegend !== false;
+              });
+              toggleThisLegend = true;
+              toggleOtherLegends = !anyVisibleElsewhere;
+            }
+            const dataUpdate = { visible: [] };
+            const dataIndices = [];
+            const updatedShapes = (fullLayout.shapes || []).map(function(d2) {
+              return d2._input;
+            });
+            var shapesUpdated = false;
+            for (var i2 = 0; i2 < allLegendItems.length; i2++) {
+              const item = allLegendItems[i2];
+              const inThisLegend = isInLegend(item);
+              if (!inThisLegend) {
+                const notDisplayed = item.showlegend !== true && !item.legendgroup;
+                if (mode === "toggle" || notDisplayed) continue;
+              }
+              const shouldShow = inThisLegend ? toggleThisLegend : toggleOtherLegends;
+              const newVis = shouldShow ? true : "legendonly";
+              if (item.visible !== false && item.visible !== newVis) {
+                if (item._isShape) {
+                  updatedShapes[item._index].visible = newVis;
+                  shapesUpdated = true;
+                } else {
+                  dataIndices.push(item.index);
+                  dataUpdate.visible.push(newVis);
+                }
+              }
+            }
+            if (shapesUpdated) {
+              Registry.call("_guiUpdate", gd2, dataUpdate, { shapes: updatedShapes }, dataIndices);
+            } else if (dataIndices.length) {
+              Registry.call("_guiRestyle", gd2, dataUpdate, dataIndices);
+            }
+          };
+        }
+      });
+      var require_constants3 = __commonJS({
+        "src/components/legend/constants.js"(exports, module2) {
+          module2.exports = {
+            scrollBarWidth: 6,
+            scrollBarMinHeight: 20,
+            scrollBarColor: "#808BA4",
+            scrollBarMargin: 4,
+            scrollBarEnterAttrs: { rx: 20, ry: 3, width: 0, height: 0 },
+            // number of px between legend title and (left) side of legend (always in x direction and from inner border)
+            titlePad: 2,
+            // number of px between each legend item (x and/or y direction)
+            itemGap: 5
+          };
+        }
+      });
+      var require_get_legend_data = __commonJS({
+        "src/components/legend/get_legend_data.js"(exports, module2) {
+          var Registry = require_registry();
+          var helpers = require_helpers3();
+          module2.exports = function getLegendData(calcdata, opts, hasMultipleLegends) {
+            var inHover = opts._inHover;
+            var grouped = helpers.isGrouped(opts);
+            var reversed = helpers.isReversed(opts);
+            var lgroupToTraces = {};
+            var lgroups = [];
+            var hasOneNonBlankGroup = false;
+            var slicesShown = {};
+            var lgroupi = 0;
+            var maxNameLength = 0;
+            var i2, j2;
+            function addOneItem(legendId, legendGroup, legendItem) {
+              if (opts.visible === false) return;
+              if (hasMultipleLegends && legendId !== opts._id) return;
+              if (legendGroup === "" || !helpers.isGrouped(opts)) {
+                var uniqueGroup = "~~i" + lgroupi;
+                lgroups.push(uniqueGroup);
+                lgroupToTraces[uniqueGroup] = [legendItem];
+                lgroupi++;
+              } else if (lgroups.indexOf(legendGroup) === -1) {
+                lgroups.push(legendGroup);
+                hasOneNonBlankGroup = true;
+                lgroupToTraces[legendGroup] = [legendItem];
+              } else {
+                lgroupToTraces[legendGroup].push(legendItem);
+              }
+            }
+            for (i2 = 0; i2 < calcdata.length; i2++) {
+              var cd2 = calcdata[i2];
+              var cd0 = cd2[0];
+              var trace = cd0.trace;
+              var lid = trace.legend;
+              var lgroup = trace.legendgroup;
+              if (!inHover && (!trace.visible || !trace.showlegend)) continue;
+              if (Registry.traceIs(trace, "pie-like")) {
+                var legendPerSlice = Array.isArray(trace.legend);
+                var showlegendPerSlice = Array.isArray(trace.showlegend);
+                if (!slicesShown[lgroup]) slicesShown[lgroup] = {};
+                for (j2 = 0; j2 < cd2.length; j2++) {
+                  if (showlegendPerSlice && trace.showlegend[cd2[j2].i] === false) {
+                    continue;
+                  }
+                  if (legendPerSlice) {
+                    lid = trace.legend[cd2[j2].i] || "legend";
+                  }
+                  var labelj = cd2[j2].label;
+                  if (!slicesShown[lgroup][labelj]) {
+                    addOneItem(lid, lgroup, {
+                      label: labelj,
+                      color: cd2[j2].color,
+                      i: cd2[j2].i,
+                      trace,
+                      pts: cd2[j2].pts
+                    });
+                    slicesShown[lgroup][labelj] = true;
+                    maxNameLength = Math.max(maxNameLength, (labelj || "").length);
+                  }
+                }
+              } else {
+                addOneItem(lid, lgroup, cd0);
+                maxNameLength = Math.max(maxNameLength, (trace.name || "").length);
+              }
+            }
+            if (!lgroups.length) return [];
+            var shouldCollapse = !hasOneNonBlankGroup || !grouped;
+            var legendData = [];
+            for (i2 = 0; i2 < lgroups.length; i2++) {
+              var t4 = lgroupToTraces[lgroups[i2]];
+              if (shouldCollapse) {
+                legendData.push(t4[0]);
+              } else {
+                legendData.push(t4);
+              }
+            }
+            if (shouldCollapse) legendData = [legendData];
+            for (i2 = 0; i2 < legendData.length; i2++) {
+              var groupMinRank = Infinity;
+              for (j2 = 0; j2 < legendData[i2].length; j2++) {
+                var rank = legendData[i2][j2].trace.legendrank;
+                if (groupMinRank > rank) groupMinRank = rank;
+              }
+              legendData[i2][0]._groupMinRank = groupMinRank;
+              legendData[i2][0]._preGroupSort = i2;
+            }
+            var orderFn1 = function(a2, b2) {
+              return a2[0]._groupMinRank - b2[0]._groupMinRank || a2[0]._preGroupSort - b2[0]._preGroupSort;
+            };
+            var orderFn2 = function(a2, b2) {
+              return a2.trace.legendrank - b2.trace.legendrank || a2._preSort - b2._preSort;
+            };
+            legendData.forEach(function(a2, k2) {
+              a2[0]._preGroupSort = k2;
+            });
+            legendData.sort(orderFn1);
+            for (i2 = 0; i2 < legendData.length; i2++) {
+              legendData[i2].forEach(function(a2, k2) {
+                a2._preSort = k2;
+              });
+              legendData[i2].sort(orderFn2);
+              var firstItemTrace = legendData[i2][0].trace;
+              var groupTitle = null;
+              for (j2 = 0; j2 < legendData[i2].length; j2++) {
+                var gt2 = legendData[i2][j2].trace.legendgrouptitle;
+                if (gt2 && gt2.text) {
+                  groupTitle = gt2;
+                  if (inHover) gt2.font = opts._groupTitleFont;
+                  break;
+                }
+              }
+              if (reversed) legendData[i2].reverse();
+              if (groupTitle) {
+                var hasPieLike = false;
+                for (j2 = 0; j2 < legendData[i2].length; j2++) {
+                  if (Registry.traceIs(legendData[i2][j2].trace, "pie-like")) {
+                    hasPieLike = true;
+                    break;
+                  }
+                }
+                legendData[i2].unshift({
+                  i: -1,
+                  groupTitle,
+                  noClick: hasPieLike,
+                  trace: {
+                    showlegend: firstItemTrace.showlegend,
+                    legendgroup: firstItemTrace.legendgroup,
+                    legend: firstItemTrace.legend,
+                    visible: opts.groupclick === "toggleitem" ? true : firstItemTrace.visible
+                  }
+                });
+              }
+              for (j2 = 0; j2 < legendData[i2].length; j2++) {
+                legendData[i2][j2] = [
+                  legendData[i2][j2]
+                ];
+              }
+            }
+            opts._lgroupsLength = legendData.length;
+            opts._maxNameLength = maxNameLength;
+            return legendData;
+          };
+        }
+      });
+      var require_helpers4 = __commonJS({
+        "src/traces/pie/helpers.js"(exports) {
+          var Lib = require_lib();
+          function format(vRounded) {
+            return vRounded.indexOf("e") !== -1 ? vRounded.replace(/[.]?0+e/, "e") : vRounded.indexOf(".") !== -1 ? vRounded.replace(/[.]?0+$/, "") : vRounded;
+          }
+          exports.formatPiePercent = function formatPiePercent(v2, separators) {
+            var vRounded = format((v2 * 100).toPrecision(3));
+            return Lib.numSeparate(vRounded, separators) + "%";
+          };
+          exports.formatPieValue = function formatPieValue(v2, separators) {
+            var vRounded = format(v2.toPrecision(10));
+            return Lib.numSeparate(vRounded, separators);
+          };
+          exports.getFirstFilled = function getFirstFilled(array, indices) {
+            if (!Lib.isArrayOrTypedArray(array)) return;
+            for (var i2 = 0; i2 < indices.length; i2++) {
+              var v2 = array[indices[i2]];
+              if (v2 || v2 === 0 || v2 === "") return v2;
+            }
+          };
+          exports.castOption = function castOption(item, indices) {
+            if (Lib.isArrayOrTypedArray(item)) return exports.getFirstFilled(item, indices);
+            else if (item) return item;
+          };
+          exports.getRotationAngle = function(rotation) {
+            return (rotation === "auto" ? 0 : rotation) * Math.PI / 180;
+          };
+        }
+      });
+      var require_fill_one = __commonJS({
+        "src/traces/pie/fill_one.js"(exports, module2) {
+          var Drawing = require_drawing();
+          var Color2 = require_color();
+          module2.exports = function fillOne(s2, pt2, trace, gd2) {
+            var pattern = trace.marker.pattern;
+            if (pattern && pattern.shape) {
+              Drawing.pointStyle(s2, trace, gd2, pt2);
+            } else {
+              Color2.fill(s2, pt2.color);
+            }
+          };
+        }
+      });
+      var require_style_one = __commonJS({
+        "src/traces/pie/style_one.js"(exports, module2) {
+          var Color2 = require_color();
+          var castOption = require_helpers4().castOption;
+          var fillOne = require_fill_one();
+          module2.exports = function styleOne(s2, pt2, trace, gd2) {
+            var line = trace.marker.line;
+            var lineColor = castOption(line.color, pt2.pts) || Color2.defaultLine;
+            var lineWidth = castOption(line.width, pt2.pts) || 0;
+            s2.call(fillOne, pt2, trace, gd2).style("stroke-width", lineWidth).call(Color2.stroke, lineColor);
+          };
+        }
+      });
+      var require_style = __commonJS({
+        "src/components/legend/style.js"(exports, module2) {
+          var d3 = require_d3();
+          var Registry = require_registry();
+          var Lib = require_lib();
+          var strTranslate = Lib.strTranslate;
+          var Drawing = require_drawing();
+          var Color2 = require_color();
+          var extractOpts = require_helpers().extractOpts;
+          var subTypes = require_subtypes();
+          var stylePie = require_style_one();
+          var pieCastOption = require_helpers4().castOption;
+          var constants = require_constants3();
+          var CST_MARKER_SIZE = 12;
+          var CST_LINE_WIDTH = 5;
+          var CST_MARKER_LINE_WIDTH = 2;
+          var MAX_LINE_WIDTH = 10;
+          var MAX_MARKER_LINE_WIDTH = 5;
+          module2.exports = function style(s2, gd2, legend) {
+            var fullLayout = gd2._fullLayout;
+            if (!legend) legend = fullLayout.legend;
+            var constantItemSizing = legend.itemsizing === "constant";
+            var itemWidth = legend.itemwidth;
+            var centerPos = (itemWidth + constants.itemGap * 2) / 2;
+            var centerTransform = strTranslate(centerPos, 0);
+            var boundLineWidth = function(mlw, cont, max, cst) {
+              var v2;
+              if (mlw + 1) {
+                v2 = mlw;
+              } else if (cont && cont.width > 0) {
+                v2 = cont.width;
+              } else {
+                return 0;
+              }
+              return constantItemSizing ? cst : Math.min(v2, max);
+            };
+            s2.each(function(d2) {
+              var traceGroup = d3.select(this);
+              var layers = Lib.ensureSingle(traceGroup, "g", "layers");
+              layers.style("opacity", d2[0].trace.opacity);
+              var indentation = legend.indentation;
+              var valign = legend.valign;
+              var lineHeight = d2[0].lineHeight;
+              var height = d2[0].height;
+              if (valign === "middle" && indentation === 0 || !lineHeight || !height) {
+                layers.attr("transform", null);
+              } else {
+                var factor = { top: 1, bottom: -1 }[valign];
+                var markerOffsetY = factor * (0.5 * (lineHeight - height + 3)) || 0;
+                var markerOffsetX = legend.indentation;
+                layers.attr("transform", strTranslate(markerOffsetX, markerOffsetY));
+              }
+              var fill = layers.selectAll("g.legendfill").data([d2]);
+              fill.enter().append("g").classed("legendfill", true);
+              var line = layers.selectAll("g.legendlines").data([d2]);
+              line.enter().append("g").classed("legendlines", true);
+              var symbol = layers.selectAll("g.legendsymbols").data([d2]);
+              symbol.enter().append("g").classed("legendsymbols", true);
+              symbol.selectAll("g.legendpoints").data([d2]).enter().append("g").classed("legendpoints", true);
+            }).each(styleSpatial).each(styleWaterfalls).each(styleFunnels).each(styleBars).each(styleBoxes).each(styleFunnelareas).each(stylePies).each(styleLines).each(stylePoints).each(styleCandles).each(styleOHLC);
+            function styleLines(d2) {
+              var styleGuide = getStyleGuide(d2);
+              var showFill = styleGuide.showFill;
+              var showLine = styleGuide.showLine;
+              var showGradientLine = styleGuide.showGradientLine;
+              var showGradientFill = styleGuide.showGradientFill;
+              var anyFill = styleGuide.anyFill;
+              var anyLine = styleGuide.anyLine;
+              var d0 = d2[0];
+              var trace = d0.trace;
+              var dMod, tMod;
+              var cOpts = extractOpts(trace);
+              var colorscale = cOpts.colorscale;
+              var reversescale = cOpts.reversescale;
+              var fillStyle = function(s22) {
+                if (s22.size()) {
+                  if (showFill) {
+                    Drawing.fillGroupStyle(s22, gd2, true);
+                  } else {
+                    var gradientID = "legendfill-" + trace.uid;
+                    Drawing.gradient(s22, gd2, gradientID, getGradientDirection(reversescale), colorscale, "fill");
+                  }
+                }
+              };
+              var lineGradient = function(s22) {
+                if (s22.size()) {
+                  var gradientID = "legendline-" + trace.uid;
+                  Drawing.lineGroupStyle(s22);
+                  Drawing.gradient(s22, gd2, gradientID, getGradientDirection(reversescale), colorscale, "stroke");
+                }
+              };
+              var pathStart = subTypes.hasMarkers(trace) || !anyFill ? "M5,0" : (
+                // with a line leave it slightly below center, to leave room for the
+                // line thickness and because the line is usually more prominent
+                anyLine ? "M5,-2" : "M5,-3"
+              );
+              var this3 = d3.select(this);
+              var fill = this3.select(".legendfill").selectAll("path").data(showFill || showGradientFill ? [d2] : []);
+              fill.enter().append("path").classed("js-fill", true);
+              fill.exit().remove();
+              fill.attr("d", pathStart + "h" + itemWidth + "v6h-" + itemWidth + "z").call(fillStyle);
+              if (showLine || showGradientLine) {
+                var lw = boundLineWidth(void 0, trace.line, MAX_LINE_WIDTH, CST_LINE_WIDTH);
+                tMod = Lib.minExtend(trace, { line: { width: lw } });
+                dMod = [Lib.minExtend(d0, { trace: tMod })];
+              }
+              var line = this3.select(".legendlines").selectAll("path").data(showLine || showGradientLine ? [dMod] : []);
+              line.enter().append("path").classed("js-line", true);
+              line.exit().remove();
+              line.attr("d", pathStart + (showGradientLine ? "l" + itemWidth + ",0.0001" : "h" + itemWidth)).call(
+                showLine ? Drawing.lineGroupStyle : lineGradient
+              );
+            }
+            function stylePoints(d2) {
+              var styleGuide = getStyleGuide(d2);
+              var anyFill = styleGuide.anyFill;
+              var anyLine = styleGuide.anyLine;
+              var showLine = styleGuide.showLine;
+              var showMarker = styleGuide.showMarker;
+              var d0 = d2[0];
+              var trace = d0.trace;
+              var showText = !showMarker && !anyLine && !anyFill && subTypes.hasText(trace);
+              var dMod, tMod;
+              function boundVal(attrIn, arrayToValFn, bounds, cst) {
+                var valIn = Lib.nestedProperty(trace, attrIn).get();
+                var valToBound = Lib.isArrayOrTypedArray(valIn) && arrayToValFn ? arrayToValFn(valIn) : valIn;
+                if (constantItemSizing && valToBound && cst !== void 0) {
+                  valToBound = cst;
+                }
+                if (bounds) {
+                  if (valToBound < bounds[0]) return bounds[0];
+                  else if (valToBound > bounds[1]) return bounds[1];
+                }
+                return valToBound;
+              }
+              function pickFirst(array) {
+                if (d0._distinct && d0.index && array[d0.index]) return array[d0.index];
+                return array[0];
+              }
+              if (showMarker || showText || showLine) {
+                var dEdit = {};
+                var tEdit = {};
+                if (showMarker) {
+                  dEdit.mc = boundVal("marker.color", pickFirst);
+                  dEdit.mx = boundVal("marker.symbol", pickFirst);
+                  dEdit.mo = boundVal("marker.opacity", Lib.mean, [0.2, 1]);
+                  dEdit.mlc = boundVal("marker.line.color", pickFirst);
+                  dEdit.mlw = boundVal("marker.line.width", Lib.mean, [0, 5], CST_MARKER_LINE_WIDTH);
+                  dEdit.mld = trace._isShape ? "solid" : boundVal("marker.line.dash", pickFirst);
+                  tEdit.marker = {
+                    sizeref: 1,
+                    sizemin: 1,
+                    sizemode: "diameter"
+                  };
+                  var ms = boundVal("marker.size", Lib.mean, [2, 16], CST_MARKER_SIZE);
+                  dEdit.ms = ms;
+                  tEdit.marker.size = ms;
+                }
+                if (showLine) {
+                  tEdit.line = {
+                    width: boundVal("line.width", pickFirst, [0, 10], CST_LINE_WIDTH)
+                  };
+                }
+                if (showText) {
+                  dEdit.tx = "Aa";
+                  dEdit.tp = boundVal("textposition", pickFirst);
+                  dEdit.ts = 10;
+                  dEdit.tc = boundVal("textfont.color", pickFirst);
+                  dEdit.tf = boundVal("textfont.family", pickFirst);
+                  dEdit.tw = boundVal("textfont.weight", pickFirst);
+                  dEdit.ty = boundVal("textfont.style", pickFirst);
+                  dEdit.tv = boundVal("textfont.variant", pickFirst);
+                  dEdit.tC = boundVal("textfont.textcase", pickFirst);
+                  dEdit.tE = boundVal("textfont.lineposition", pickFirst);
+                  dEdit.tS = boundVal("textfont.shadow", pickFirst);
+                }
+                dMod = [Lib.minExtend(d0, dEdit)];
+                tMod = Lib.minExtend(trace, tEdit);
+                tMod.selectedpoints = null;
+                tMod.texttemplate = null;
+              }
+              var ptgroup = d3.select(this).select("g.legendpoints");
+              var pts = ptgroup.selectAll("path.scatterpts").data(showMarker ? dMod : []);
+              pts.enter().insert("path", ":first-child").classed("scatterpts", true).attr("transform", centerTransform);
+              pts.exit().remove();
+              pts.call(Drawing.pointStyle, tMod, gd2);
+              if (showMarker) dMod[0].mrc = 3;
+              var txt = ptgroup.selectAll("g.pointtext").data(showText ? dMod : []);
+              txt.enter().append("g").classed("pointtext", true).append("text").attr("transform", centerTransform);
+              txt.exit().remove();
+              txt.selectAll("text").call(Drawing.textPointStyle, tMod, gd2);
+            }
+            function styleWaterfalls(d2) {
+              var trace = d2[0].trace;
+              var isWaterfall = trace.type === "waterfall";
+              if (d2[0]._distinct && isWaterfall) {
+                var cont = d2[0].trace[d2[0].dir].marker;
+                d2[0].mc = cont.color;
+                d2[0].mlw = cont.line.width;
+                d2[0].mlc = cont.line.color;
+                return styleBarLike(d2, this, "waterfall");
+              }
+              var ptsData = [];
+              if (trace.visible && isWaterfall) {
+                ptsData = d2[0].hasTotals ? [
+                  ["increasing", "M-6,-6V6H0Z"],
+                  ["totals", "M6,6H0L-6,-6H-0Z"],
+                  ["decreasing", "M6,6V-6H0Z"]
+                ] : [
+                  ["increasing", "M-6,-6V6H6Z"],
+                  ["decreasing", "M6,6V-6H-6Z"]
+                ];
+              }
+              var pts = d3.select(this).select("g.legendpoints").selectAll("path.legendwaterfall").data(ptsData);
+              pts.enter().append("path").classed("legendwaterfall", true).attr("transform", centerTransform).style("stroke-miterlimit", 1);
+              pts.exit().remove();
+              pts.each(function(dd2) {
+                var pt2 = d3.select(this);
+                var cont2 = trace[dd2[0]].marker;
+                var lw = boundLineWidth(void 0, cont2.line, MAX_MARKER_LINE_WIDTH, CST_MARKER_LINE_WIDTH);
+                pt2.attr("d", dd2[1]).style("stroke-width", lw + "px").call(Color2.fill, cont2.color);
+                if (lw) {
+                  pt2.call(Color2.stroke, cont2.line.color);
+                }
+              });
+            }
+            function styleBars(d2) {
+              styleBarLike(d2, this);
+            }
+            function styleFunnels(d2) {
+              styleBarLike(d2, this, "funnel");
+            }
+            function styleBarLike(d2, lThis, desiredType) {
+              var trace = d2[0].trace;
+              var marker = trace.marker || {};
+              var markerLine = marker.line || {};
+              var pathStr = marker.cornerradius ? "M6,3a3,3,0,0,1-3,3H-3a3,3,0,0,1-3-3V-3a3,3,0,0,1,3-3H3a3,3,0,0,1,3,3Z" : (
+                // Square with rounded corners
+                "M6,6H-6V-6H6Z"
+              );
+              var isVisible = !desiredType ? Registry.traceIs(trace, "bar") : trace.visible && trace.type === desiredType;
+              var barpath = d3.select(lThis).select("g.legendpoints").selectAll("path.legend" + desiredType).data(isVisible ? [d2] : []);
+              barpath.enter().append("path").classed("legend" + desiredType, true).attr("d", pathStr).attr("transform", centerTransform);
+              barpath.exit().remove();
+              barpath.each(function(d22) {
+                var p2 = d3.select(this);
+                var d0 = d22[0];
+                var w2 = boundLineWidth(d0.mlw, marker.line, MAX_MARKER_LINE_WIDTH, CST_MARKER_LINE_WIDTH);
+                p2.style("stroke-width", w2 + "px");
+                var mcc = d0.mcc;
+                if (!legend._inHover && "mc" in d0) {
+                  var cOpts = extractOpts(marker);
+                  var mid = cOpts.mid;
+                  if (mid === void 0) mid = (cOpts.max + cOpts.min) / 2;
+                  mcc = Drawing.tryColorscale(marker, "")(mid);
+                }
+                var fillColor = mcc || d0.mc || marker.color;
+                var markerPattern = marker.pattern;
+                var pAttr = Drawing.getPatternAttr;
+                var patternShape = markerPattern && (pAttr(markerPattern.shape, 0, "") || pAttr(markerPattern.path, 0, ""));
+                if (patternShape) {
+                  var patternBGColor = pAttr(markerPattern.bgcolor, 0, null);
+                  var patternFGColor = pAttr(markerPattern.fgcolor, 0, null);
+                  var patternFGOpacity = markerPattern.fgopacity;
+                  var patternSize = dimAttr(markerPattern.size, 8, 10);
+                  var patternSolidity = dimAttr(markerPattern.solidity, 0.5, 1);
+                  var patternID = "legend-" + trace.uid;
+                  p2.call(
+                    Drawing.pattern,
+                    "legend",
+                    gd2,
+                    patternID,
+                    patternShape,
+                    patternSize,
+                    patternSolidity,
+                    mcc,
+                    markerPattern.fillmode,
+                    patternBGColor,
+                    patternFGColor,
+                    patternFGOpacity
+                  );
+                } else {
+                  p2.call(Color2.fill, fillColor);
+                }
+                if (w2) Color2.stroke(p2, d0.mlc || markerLine.color);
+              });
+            }
+            function styleBoxes(d2) {
+              var trace = d2[0].trace;
+              var pts = d3.select(this).select("g.legendpoints").selectAll("path.legendbox").data(trace.visible && Registry.traceIs(trace, "box-violin") ? [d2] : []);
+              pts.enter().append("path").classed("legendbox", true).attr("d", "M6,6H-6V-6H6Z").attr("transform", centerTransform);
+              pts.exit().remove();
+              pts.each(function() {
+                var p2 = d3.select(this);
+                if ((trace.boxpoints === "all" || trace.points === "all") && Color2.opacity(trace.fillcolor) === 0 && Color2.opacity((trace.line || {}).color) === 0) {
+                  var tMod = Lib.minExtend(trace, {
+                    marker: {
+                      size: constantItemSizing ? CST_MARKER_SIZE : Lib.constrain(trace.marker.size, 2, 16),
+                      sizeref: 1,
+                      sizemin: 1,
+                      sizemode: "diameter"
+                    }
+                  });
+                  pts.call(Drawing.pointStyle, tMod, gd2);
+                } else {
+                  var w2 = boundLineWidth(void 0, trace.line, MAX_MARKER_LINE_WIDTH, CST_MARKER_LINE_WIDTH);
+                  p2.style("stroke-width", w2 + "px").call(Color2.fill, trace.fillcolor);
+                  if (w2) Color2.stroke(p2, trace.line.color);
+                }
+              });
+            }
+            function styleCandles(d2) {
+              var trace = d2[0].trace;
+              var pts = d3.select(this).select("g.legendpoints").selectAll("path.legendcandle").data(trace.visible && trace.type === "candlestick" ? [d2, d2] : []);
+              pts.enter().append("path").classed("legendcandle", true).attr("d", function(_2, i2) {
+                if (i2) return "M-15,0H-8M-8,6V-6H8Z";
+                return "M15,0H8M8,-6V6H-8Z";
+              }).attr("transform", centerTransform).style("stroke-miterlimit", 1);
+              pts.exit().remove();
+              pts.each(function(_2, i2) {
+                var p2 = d3.select(this);
+                var cont = trace[i2 ? "increasing" : "decreasing"];
+                var w2 = boundLineWidth(void 0, cont.line, MAX_MARKER_LINE_WIDTH, CST_MARKER_LINE_WIDTH);
+                p2.style("stroke-width", w2 + "px").call(Color2.fill, cont.fillcolor);
+                if (w2) Color2.stroke(p2, cont.line.color);
+              });
+            }
+            function styleOHLC(d2) {
+              var trace = d2[0].trace;
+              var pts = d3.select(this).select("g.legendpoints").selectAll("path.legendohlc").data(trace.visible && trace.type === "ohlc" ? [d2, d2] : []);
+              pts.enter().append("path").classed("legendohlc", true).attr("d", function(_2, i2) {
+                if (i2) return "M-15,0H0M-8,-6V0";
+                return "M15,0H0M8,6V0";
+              }).attr("transform", centerTransform).style("stroke-miterlimit", 1);
+              pts.exit().remove();
+              pts.each(function(_2, i2) {
+                var p2 = d3.select(this);
+                var cont = trace[i2 ? "increasing" : "decreasing"];
+                var w2 = boundLineWidth(void 0, cont.line, MAX_MARKER_LINE_WIDTH, CST_MARKER_LINE_WIDTH);
+                p2.style("fill", "none").call(Drawing.dashLine, cont.line.dash, w2);
+                if (w2) Color2.stroke(p2, cont.line.color);
+              });
+            }
+            function stylePies(d2) {
+              stylePieLike(d2, this, "pie");
+            }
+            function styleFunnelareas(d2) {
+              stylePieLike(d2, this, "funnelarea");
+            }
+            function stylePieLike(d2, lThis, desiredType) {
+              var d0 = d2[0];
+              var trace = d0.trace;
+              var isVisible = !desiredType ? Registry.traceIs(trace, desiredType) : trace.visible && trace.type === desiredType;
+              var pts = d3.select(lThis).select("g.legendpoints").selectAll("path.legend" + desiredType).data(isVisible ? [d2] : []);
+              pts.enter().append("path").classed("legend" + desiredType, true).attr("d", "M6,6H-6V-6H6Z").attr("transform", centerTransform);
+              pts.exit().remove();
+              if (pts.size()) {
+                var cont = trace.marker || {};
+                var lw = boundLineWidth(
+                  pieCastOption(cont.line.width, d0.pts),
+                  cont.line,
+                  MAX_MARKER_LINE_WIDTH,
+                  CST_MARKER_LINE_WIDTH
+                );
+                var opt = "pieLike";
+                var tMod = Lib.minExtend(trace, { marker: { line: { width: lw } } }, opt);
+                var d0Mod = Lib.minExtend(d0, { trace: tMod }, opt);
+                stylePie(pts, d0Mod, tMod, gd2);
+              }
+            }
+            function styleSpatial(d2) {
+              var trace = d2[0].trace;
+              var useGradient;
+              var ptsData = [];
+              if (trace.visible) {
+                switch (trace.type) {
+                  case "histogram2d":
+                  case "heatmap":
+                    ptsData = [
+                      ["M-15,-2V4H15V-2Z"]
+                      // similar to contour
+                    ];
+                    useGradient = true;
+                    break;
+                  case "choropleth":
+                  case "choroplethmapbox":
+                  case "choroplethmap":
+                    ptsData = [["M-6,-6V6H6V-6Z"]];
+                    useGradient = true;
+                    break;
+                  case "densitymapbox":
+                  case "densitymap":
+                    ptsData = [["M-6,0 a6,6 0 1,0 12,0 a 6,6 0 1,0 -12,0"]];
+                    useGradient = "radial";
+                    break;
+                  case "cone":
+                    ptsData = [
+                      ["M-6,2 A2,2 0 0,0 -6,6 V6L6,4Z"],
+                      ["M-6,-6 A2,2 0 0,0 -6,-2 L6,-4Z"],
+                      ["M-6,-2 A2,2 0 0,0 -6,2 L6,0Z"]
+                    ];
+                    useGradient = false;
+                    break;
+                  case "streamtube":
+                    ptsData = [
+                      ["M-6,2 A2,2 0 0,0 -6,6 H6 A2,2 0 0,1 6,2 Z"],
+                      ["M-6,-6 A2,2 0 0,0 -6,-2 H6 A2,2 0 0,1 6,-6 Z"],
+                      ["M-6,-2 A2,2 0 0,0 -6,2 H6 A2,2 0 0,1 6,-2 Z"]
+                    ];
+                    useGradient = false;
+                    break;
+                  case "surface":
+                    ptsData = [
+                      ["M-6,-6 A2,3 0 0,0 -6,0 H6 A2,3 0 0,1 6,-6 Z"],
+                      ["M-6,1 A2,3 0 0,1 -6,6 H6 A2,3 0 0,0 6,0 Z"]
+                    ];
+                    useGradient = true;
+                    break;
+                  case "mesh3d":
+                    ptsData = [["M-6,6H0L-6,-6Z"], ["M6,6H0L6,-6Z"], ["M-6,-6H6L0,6Z"]];
+                    useGradient = false;
+                    break;
+                  case "volume":
+                    ptsData = [["M-6,6H0L-6,-6Z"], ["M6,6H0L6,-6Z"], ["M-6,-6H6L0,6Z"]];
+                    useGradient = true;
+                    break;
+                  case "isosurface":
+                    ptsData = [["M-6,6H0L-6,-6Z"], ["M6,6H0L6,-6Z"], ["M-6,-6 A12,24 0 0,0 6,-6 L0,6Z"]];
+                    useGradient = false;
+                    break;
+                }
+              }
+              var pts = d3.select(this).select("g.legendpoints").selectAll("path.legend3dandfriends").data(ptsData);
+              pts.enter().append("path").classed("legend3dandfriends", true).attr("transform", centerTransform).style("stroke-miterlimit", 1);
+              pts.exit().remove();
+              pts.each(function(dd2, i2) {
+                var pt2 = d3.select(this);
+                var cOpts = extractOpts(trace);
+                var colorscale = cOpts.colorscale;
+                var reversescale = cOpts.reversescale;
+                var fillGradient = function(s22) {
+                  if (s22.size()) {
+                    var gradientID = "legendfill-" + trace.uid;
+                    Drawing.gradient(
+                      s22,
+                      gd2,
+                      gradientID,
+                      getGradientDirection(reversescale, useGradient === "radial"),
+                      colorscale,
+                      "fill"
+                    );
+                  }
+                };
+                var fillColor;
+                if (!colorscale) {
+                  var color22 = trace.vertexcolor || trace.facecolor || trace.color;
+                  fillColor = Lib.isArrayOrTypedArray(color22) ? color22[i2] || color22[0] : color22;
+                } else {
+                  if (!useGradient) {
+                    var len2 = colorscale.length;
+                    fillColor = i2 === 0 ? colorscale[reversescale ? len2 - 1 : 0][1] : (
+                      // minimum
+                      i2 === 1 ? colorscale[reversescale ? 0 : len2 - 1][1] : (
+                        // maximum
+                        colorscale[Math.floor((len2 - 1) / 2)][1]
+                      )
+                    );
+                  }
+                }
+                pt2.attr("d", dd2[0]);
+                if (fillColor) {
+                  pt2.call(Color2.fill, fillColor);
+                } else {
+                  pt2.call(fillGradient);
+                }
+              });
+            }
+          };
+          function getGradientDirection(reversescale, isRadial) {
+            var str = isRadial ? "radial" : "horizontal";
+            return str + (reversescale ? "" : "reversed");
+          }
+          function getStyleGuide(d2) {
+            var trace = d2[0].trace;
+            var contours = trace.contours;
+            var showLine = subTypes.hasLines(trace);
+            var showMarker = subTypes.hasMarkers(trace);
+            var showFill = trace.visible && trace.fill && trace.fill !== "none";
+            var showGradientLine = false;
+            var showGradientFill = false;
+            if (contours) {
+              var coloring = contours.coloring;
+              if (coloring === "lines") {
+                showGradientLine = true;
+              } else {
+                showLine = coloring === "none" || coloring === "heatmap" || contours.showlines;
+              }
+              if (contours.type === "constraint") {
+                showFill = contours._operation !== "=";
+              } else if (coloring === "fill" || coloring === "heatmap") {
+                showGradientFill = true;
+              }
+            }
+            return {
+              showMarker,
+              showLine,
+              showFill,
+              showGradientLine,
+              showGradientFill,
+              anyLine: showLine || showGradientLine,
+              anyFill: showFill || showGradientFill
+            };
+          }
+          function dimAttr(v2, dflt, max) {
+            if (v2 && Lib.isArrayOrTypedArray(v2)) return dflt;
+            if (v2 > max) return max;
+            return v2;
+          }
+        }
+      });
+      var require_draw = __commonJS({
+        "src/components/legend/draw.js"(exports, module2) {
+          var d3 = require_d3();
+          var Lib = require_lib();
+          var Plots = require_plots();
+          var Registry = require_registry();
+          var Events = require_events2();
+          var dragElement = require_dragelement();
+          var Drawing = require_drawing();
+          var Color2 = require_color();
+          var svgTextUtils = require_svg_text_utils();
+          var handleItemClick = require_handle_click().handleItemClick;
+          var handleTitleClick = require_handle_click().handleTitleClick;
+          var constants = require_constants3();
+          var alignmentConstants = require_alignment();
+          var LINE_SPACING = alignmentConstants.LINE_SPACING;
+          var FROM_TL = alignmentConstants.FROM_TL;
+          var FROM_BR = alignmentConstants.FROM_BR;
+          var getLegendData = require_get_legend_data();
+          var style = require_style();
+          var helpers = require_helpers3();
+          var MAIN_TITLE = 1;
+          var LEGEND_PATTERN = /^legend[0-9]*$/;
+          module2.exports = function draw(gd2, opts) {
+            if (opts) {
+              drawOne(gd2, opts);
+            } else {
+              var fullLayout = gd2._fullLayout;
+              var newLegends = fullLayout._legends;
+              var oldLegends = fullLayout._infolayer.selectAll('[class^="legend"]');
+              oldLegends.each(function() {
+                var el2 = d3.select(this);
+                var classes = el2.attr("class");
+                var cls = classes.split(" ")[0];
+                if (cls.match(LEGEND_PATTERN) && newLegends.indexOf(cls) === -1) {
+                  el2.remove();
+                }
+              });
+              for (var i2 = 0; i2 < newLegends.length; i2++) {
+                var legendId = newLegends[i2];
+                var legendObj = gd2._fullLayout[legendId];
+                drawOne(gd2, legendObj);
+              }
+            }
+          };
+          function horizontalAlignTitle(titleEl, legendObj, bw) {
+            if (legendObj.title.side !== "top center" && legendObj.title.side !== "top right") return;
+            var font = legendObj.title.font;
+            var lineHeight = font.size * LINE_SPACING;
+            var titleOffset = 0;
+            var textNode = titleEl.node();
+            var width = Drawing.bBox(textNode).width;
+            if (legendObj.title.side === "top center") {
+              titleOffset = 0.5 * (legendObj._width - 2 * bw - 2 * constants.titlePad - width);
+            } else if (legendObj.title.side === "top right") {
+              titleOffset = legendObj._width - 2 * bw - 2 * constants.titlePad - width;
+            }
+            svgTextUtils.positionText(
+              titleEl,
+              bw + constants.titlePad + titleOffset,
+              bw + lineHeight
+            );
+          }
+          function drawOne(gd2, opts) {
+            var legendObj = opts || {};
+            var fullLayout = gd2._fullLayout;
+            var legendId = helpers.getId(legendObj);
+            var clipId, layer;
+            var inHover = legendObj._inHover;
+            if (inHover) {
+              layer = legendObj.layer;
+              clipId = "hover";
+            } else {
+              layer = fullLayout._infolayer;
+              clipId = legendId;
+            }
+            if (!layer) return;
+            clipId += fullLayout._uid;
+            if (!gd2._legendMouseDownTime) gd2._legendMouseDownTime = 0;
+            var legendData;
+            if (!inHover) {
+              var calcdata = (gd2.calcdata || []).slice();
+              var shapes = fullLayout.shapes;
+              for (var i2 = 0; i2 < shapes.length; i2++) {
+                var shape = shapes[i2];
+                if (!shape.showlegend) continue;
+                var shapeLegend = {
+                  _isShape: true,
+                  _fullInput: shape,
+                  index: shape._index,
+                  name: shape.name || shape.label.text || "shape " + shape._index,
+                  legend: shape.legend,
+                  legendgroup: shape.legendgroup,
+                  legendgrouptitle: shape.legendgrouptitle,
+                  legendrank: shape.legendrank,
+                  legendwidth: shape.legendwidth,
+                  showlegend: shape.showlegend,
+                  visible: shape.visible,
+                  opacity: shape.opacity,
+                  mode: shape.type === "line" ? "lines" : "markers",
+                  line: shape.line,
+                  marker: {
+                    line: shape.line,
+                    color: shape.fillcolor,
+                    size: 12,
+                    symbol: shape.type === "rect" ? "square" : shape.type === "circle" ? "circle" : (
+                      // case of path
+                      "hexagon2"
+                    )
+                  }
+                };
+                calcdata.push([{ trace: shapeLegend }]);
+              }
+              legendData = fullLayout.showlegend && getLegendData(calcdata, legendObj, fullLayout._legends.length > 1);
+            } else {
+              if (!legendObj.entries) return;
+              legendData = getLegendData(legendObj.entries, legendObj);
+            }
+            var hiddenSlices = fullLayout.hiddenlabels || [];
+            if (!inHover && (!fullLayout.showlegend || !legendData.length)) {
+              layer.selectAll("." + legendId).remove();
+              fullLayout._topdefs.select("#" + clipId).remove();
+              return Plots.autoMargin(gd2, legendId);
+            }
+            var legend = Lib.ensureSingle(layer, "g", legendId, function(s2) {
+              if (!inHover) s2.attr("pointer-events", "all");
+            });
+            var clipPath = Lib.ensureSingleById(fullLayout._topdefs, "clipPath", clipId, function(s2) {
+              s2.append("rect");
+            });
+            var bg2 = Lib.ensureSingle(legend, "rect", "bg", function(s2) {
+              s2.attr("shape-rendering", "crispEdges");
+            });
+            bg2.call(Color2.stroke, legendObj.bordercolor).call(Color2.fill, legendObj.bgcolor).style("stroke-width", legendObj.borderwidth + "px");
+            var scrollBox = Lib.ensureSingle(legend, "g", "scrollbox");
+            var title = legendObj.title;
+            legendObj._titleWidth = 0;
+            legendObj._titleHeight = 0;
+            var titleEl;
+            if (title.text) {
+              titleEl = Lib.ensureSingle(scrollBox, "text", legendId + "titletext");
+              titleEl.attr("text-anchor", "start").call(Drawing.font, title.font).text(title.text);
+              textLayout(titleEl, scrollBox, gd2, legendObj, MAIN_TITLE);
+              if (!inHover && (legendObj.titleclick || legendObj.titledoubleclick)) {
+                setupTitleToggle(scrollBox, gd2, legendObj, legendId);
+              }
+            } else {
+              scrollBox.selectAll("." + legendId + "titletext").remove();
+              scrollBox.selectAll("." + legendId + "titletoggle").remove();
+            }
+            var scrollBar = Lib.ensureSingle(legend, "rect", "scrollbar", function(s2) {
+              s2.attr(constants.scrollBarEnterAttrs).call(Color2.fill, constants.scrollBarColor);
+            });
+            var groups = scrollBox.selectAll("g.groups").data(legendData);
+            groups.enter().append("g").attr("class", "groups");
+            groups.exit().remove();
+            var traces = groups.selectAll("g.traces").data(Lib.identity);
+            traces.enter().append("g").attr("class", "traces");
+            traces.exit().remove();
+            traces.style("opacity", function(d2) {
+              const legendItem = d2[0];
+              const trace = legendItem.trace;
+              if (legendItem.groupTitle) {
+                const groupName = trace.legendgroup;
+                const shapes2 = (fullLayout.shapes || []).filter(function(s2) {
+                  return s2.showlegend;
+                });
+                const anyVisible = gd2._fullData.concat(shapes2).some(function(item) {
+                  return item.legendgroup === groupName && (item.legend || "legend") === legendId && item.visible === true;
+                });
+                return anyVisible ? 1 : 0.5;
+              }
+              if (Registry.traceIs(trace, "pie-like")) {
+                return hiddenSlices.indexOf(d2[0].label) !== -1 ? 0.5 : 1;
+              } else {
+                return trace.visible === "legendonly" ? 0.5 : 1;
+              }
+            }).each(function() {
+              d3.select(this).call(drawTexts, gd2, legendObj);
+            }).call(style, gd2, legendObj).each(function(d2) {
+              if (inHover) return;
+              if (d2[0].groupTitle && legendObj.groupclick === "toggleitem") return;
+              d3.select(this).call(setupTraceToggle, gd2, legendId);
+            });
+            Lib.syncOrAsync([
+              Plots.previousPromises,
+              function() {
+                return computeLegendDimensions(gd2, groups, traces, legendObj, scrollBox);
+              },
+              function() {
+                var gs = fullLayout._size;
+                var bw = legendObj.borderwidth;
+                var isPaperX = legendObj.xref === "paper";
+                var isPaperY = legendObj.yref === "paper";
+                if (title.text) {
+                  const shapes2 = (fullLayout.shapes || []).filter(function(s2) {
+                    return s2.showlegend;
+                  });
+                  const anyVisible = gd2._fullData.concat(shapes2).some(function(item) {
+                    const legendAttr = item.legend || "legend";
+                    var inThisLegend = Array.isArray(legendAttr) ? legendAttr.includes(legendId) : legendAttr === legendId;
+                    return inThisLegend && item.visible === true;
+                  });
+                  titleEl.style("opacity", anyVisible ? 1 : 0.5);
+                }
+                if (!inHover) {
+                  var lx, ly;
+                  if (isPaperX) {
+                    lx = gs.l + gs.w * legendObj.x - FROM_TL[getXanchor(legendObj)] * legendObj._width;
+                  } else {
+                    lx = fullLayout.width * legendObj.x - FROM_TL[getXanchor(legendObj)] * legendObj._width;
+                  }
+                  if (isPaperY) {
+                    ly = gs.t + gs.h * (1 - legendObj.y) - FROM_TL[getYanchor(legendObj)] * legendObj._effHeight;
+                  } else {
+                    ly = fullLayout.height * (1 - legendObj.y) - FROM_TL[getYanchor(legendObj)] * legendObj._effHeight;
+                  }
+                  var expMargin = expandMargin(gd2, legendId, lx, ly);
+                  if (expMargin) return;
+                  if (fullLayout.margin.autoexpand) {
+                    var lx0 = lx;
+                    var ly0 = ly;
+                    lx = isPaperX ? Lib.constrain(lx, 0, fullLayout.width - legendObj._width) : lx0;
+                    ly = isPaperY ? Lib.constrain(ly, 0, fullLayout.height - legendObj._effHeight) : ly0;
+                    if (lx !== lx0) {
+                      Lib.log("Constrain " + legendId + ".x to make legend fit inside graph");
+                    }
+                    if (ly !== ly0) {
+                      Lib.log("Constrain " + legendId + ".y to make legend fit inside graph");
+                    }
+                  }
+                  Drawing.setTranslate(legend, lx, ly);
+                }
+                scrollBar.on(".drag", null);
+                legend.on("wheel", null);
+                if (inHover || legendObj._height <= legendObj._maxHeight || gd2._context.staticPlot) {
+                  var height = legendObj._effHeight;
+                  if (inHover) height = legendObj._height;
+                  bg2.attr({
+                    width: legendObj._width - bw,
+                    height: height - bw,
+                    x: bw / 2,
+                    y: bw / 2
+                  });
+                  Drawing.setTranslate(scrollBox, 0, 0);
+                  clipPath.select("rect").attr({
+                    width: legendObj._width - 2 * bw,
+                    height: height - 2 * bw,
+                    x: bw,
+                    y: bw
+                  });
+                  Drawing.setClipUrl(scrollBox, clipId, gd2);
+                  Drawing.setRect(scrollBar, 0, 0, 0, 0);
+                  delete legendObj._scrollY;
+                } else {
+                  var scrollBarHeight = Math.max(
+                    constants.scrollBarMinHeight,
+                    legendObj._effHeight * legendObj._effHeight / legendObj._height
+                  );
+                  var scrollBarYMax = legendObj._effHeight - scrollBarHeight - 2 * constants.scrollBarMargin;
+                  var scrollBoxYMax = legendObj._height - legendObj._effHeight;
+                  var scrollRatio = scrollBarYMax / scrollBoxYMax;
+                  var scrollBoxY = Math.min(legendObj._scrollY || 0, scrollBoxYMax);
+                  bg2.attr({
+                    width: legendObj._width - 2 * bw + constants.scrollBarWidth + constants.scrollBarMargin,
+                    height: legendObj._effHeight - bw,
+                    x: bw / 2,
+                    y: bw / 2
+                  });
+                  clipPath.select("rect").attr({
+                    width: legendObj._width - 2 * bw + constants.scrollBarWidth + constants.scrollBarMargin,
+                    height: legendObj._effHeight - 2 * bw,
+                    x: bw,
+                    y: bw + scrollBoxY
+                  });
+                  Drawing.setClipUrl(scrollBox, clipId, gd2);
+                  scrollHandler(scrollBoxY, scrollBarHeight, scrollRatio);
+                  legend.on("wheel", function() {
+                    scrollBoxY = Lib.constrain(
+                      legendObj._scrollY + d3.event.deltaY / scrollBoxYMax * scrollBarYMax,
+                      0,
+                      scrollBoxYMax
+                    );
+                    scrollHandler(scrollBoxY, scrollBarHeight, scrollRatio);
+                    if (scrollBoxY !== 0 && scrollBoxY !== scrollBoxYMax) {
+                      d3.event.preventDefault();
+                    }
+                  });
+                  var eventY0, eventY1, scrollBoxY0;
+                  var getScrollBarDragY = function(scrollBoxY02, eventY02, eventY12) {
+                    var y2 = (eventY12 - eventY02) / scrollRatio + scrollBoxY02;
+                    return Lib.constrain(y2, 0, scrollBoxYMax);
+                  };
+                  var getNaturalDragY = function(scrollBoxY02, eventY02, eventY12) {
+                    var y2 = (eventY02 - eventY12) / scrollRatio + scrollBoxY02;
+                    return Lib.constrain(y2, 0, scrollBoxYMax);
+                  };
+                  var scrollBarDrag = d3.behavior.drag().on("dragstart", function() {
+                    var e2 = d3.event.sourceEvent;
+                    if (e2.type === "touchstart") {
+                      eventY0 = e2.changedTouches[0].clientY;
+                    } else {
+                      eventY0 = e2.clientY;
+                    }
+                    scrollBoxY0 = scrollBoxY;
+                  }).on("drag", function() {
+                    var e2 = d3.event.sourceEvent;
+                    if (e2.buttons === 2 || e2.ctrlKey) return;
+                    if (e2.type === "touchmove") {
+                      eventY1 = e2.changedTouches[0].clientY;
+                    } else {
+                      eventY1 = e2.clientY;
+                    }
+                    scrollBoxY = getScrollBarDragY(scrollBoxY0, eventY0, eventY1);
+                    scrollHandler(scrollBoxY, scrollBarHeight, scrollRatio);
+                  });
+                  scrollBar.call(scrollBarDrag);
+                  var scrollBoxTouchDrag = d3.behavior.drag().on("dragstart", function() {
+                    var e2 = d3.event.sourceEvent;
+                    if (e2.type === "touchstart") {
+                      eventY0 = e2.changedTouches[0].clientY;
+                      scrollBoxY0 = scrollBoxY;
+                    }
+                  }).on("drag", function() {
+                    var e2 = d3.event.sourceEvent;
+                    if (e2.type === "touchmove") {
+                      eventY1 = e2.changedTouches[0].clientY;
+                      scrollBoxY = getNaturalDragY(scrollBoxY0, eventY0, eventY1);
+                      scrollHandler(scrollBoxY, scrollBarHeight, scrollRatio);
+                    }
+                  });
+                  scrollBox.call(scrollBoxTouchDrag);
+                }
+                function scrollHandler(scrollBoxY2, scrollBarHeight2, scrollRatio2) {
+                  legendObj._scrollY = gd2._fullLayout[legendId]._scrollY = scrollBoxY2;
+                  Drawing.setTranslate(scrollBox, 0, -scrollBoxY2);
+                  Drawing.setRect(
+                    scrollBar,
+                    legendObj._width,
+                    constants.scrollBarMargin + scrollBoxY2 * scrollRatio2,
+                    constants.scrollBarWidth,
+                    scrollBarHeight2
+                  );
+                  clipPath.select("rect").attr("y", bw + scrollBoxY2);
+                }
+                if (gd2._context.edits.legendPosition) {
+                  var xf2, yf2, x0, y0;
+                  legend.classed("cursor-move", true);
+                  dragElement.init({
+                    element: legend.node(),
+                    gd: gd2,
+                    prepFn: function(e2) {
+                      if (e2.target === scrollBar.node()) {
+                        return;
+                      }
+                      var transform = Drawing.getTranslate(legend);
+                      x0 = transform.x;
+                      y0 = transform.y;
+                    },
+                    moveFn: function(dx, dy) {
+                      if (x0 !== void 0 && y0 !== void 0) {
+                        var newX = x0 + dx;
+                        var newY = y0 + dy;
+                        Drawing.setTranslate(legend, newX, newY);
+                        xf2 = dragElement.align(newX, legendObj._width, gs.l, gs.l + gs.w, legendObj.xanchor);
+                        yf2 = dragElement.align(newY + legendObj._height, -legendObj._height, gs.t + gs.h, gs.t, legendObj.yanchor);
+                      }
+                    },
+                    doneFn: function() {
+                      if (xf2 !== void 0 && yf2 !== void 0) {
+                        var obj = {};
+                        obj[legendId + ".x"] = xf2;
+                        obj[legendId + ".y"] = yf2;
+                        Registry.call("_guiRelayout", gd2, obj);
+                      }
+                    },
+                    clickFn: function(numClicks, e2) {
+                      var clickedTrace = layer.selectAll("g.traces").filter(function() {
+                        var bbox = this.getBoundingClientRect();
+                        return e2.clientX >= bbox.left && e2.clientX <= bbox.right && e2.clientY >= bbox.top && e2.clientY <= bbox.bottom;
+                      });
+                      if (clickedTrace.size() > 0) {
+                        clickOrDoubleClick(gd2, legendObj, clickedTrace, numClicks, e2);
+                      }
+                    }
+                  });
+                }
+              }
+            ], gd2);
+          }
+          function getTraceWidth(d2, legendObj, textGap) {
+            var legendItem = d2[0];
+            var legendWidth = legendItem.width;
+            var mode = legendObj.entrywidthmode;
+            var traceLegendWidth = legendItem.trace.legendwidth || legendObj.entrywidth;
+            if (mode === "fraction") return legendObj._maxWidth * traceLegendWidth;
+            return textGap + (traceLegendWidth || legendWidth);
+          }
+          function clickOrDoubleClick(gd2, legend, legendItem, numClicks, evt) {
+            var fullLayout = gd2._fullLayout;
+            var trace = legendItem.data()[0][0].trace;
+            var itemClick = legend.itemclick;
+            var itemDoubleClick = legend.itemdoubleclick;
+            var evtData = {
+              event: evt,
+              node: legendItem.node(),
+              curveNumber: trace.index,
+              expandedIndex: trace.index,
+              data: gd2.data,
+              layout: gd2.layout,
+              frames: gd2._transitionData._frames,
+              config: gd2._context,
+              fullData: gd2._fullData,
+              fullLayout
+            };
+            if (trace._group) {
+              evtData.group = trace._group;
+            }
+            if (Registry.traceIs(trace, "pie-like")) {
+              evtData.label = legendItem.datum()[0].label;
+            }
+            var clickVal = Events.triggerHandler(gd2, "plotly_legendclick", evtData);
+            if (numClicks === 1) {
+              if (clickVal === false) return;
+              legend._clickTimeout = setTimeout(function() {
+                if (!gd2._fullLayout) return;
+                if (itemClick) handleItemClick(legendItem, gd2, legend, itemClick);
+              }, gd2._context.doubleClickDelay);
+            } else if (numClicks === 2) {
+              if (legend._clickTimeout) clearTimeout(legend._clickTimeout);
+              gd2._legendMouseDownTime = 0;
+              var dblClickVal = Events.triggerHandler(gd2, "plotly_legenddoubleclick", evtData);
+              if (dblClickVal !== false && clickVal !== false && itemDoubleClick) {
+                handleItemClick(legendItem, gd2, legend, itemDoubleClick);
+              }
+            }
+          }
+          function drawTexts(g2, gd2, legendObj) {
+            var legendId = helpers.getId(legendObj);
+            var legendItem = g2.data()[0][0];
+            var trace = legendItem.trace;
+            var isPieLike = Registry.traceIs(trace, "pie-like");
+            var isEditable = !legendObj._inHover && gd2._context.edits.legendText && !isPieLike;
+            var maxNameLength = legendObj._maxNameLength;
+            var name2, font;
+            if (legendItem.groupTitle) {
+              name2 = legendItem.groupTitle.text;
+              font = legendItem.groupTitle.font;
+            } else {
+              font = legendObj.font;
+              if (!legendObj.entries) {
+                name2 = isPieLike ? legendItem.label : trace.name;
+                if (trace._meta) {
+                  name2 = Lib.templateString(name2, trace._meta);
+                }
+              } else {
+                name2 = legendItem.text;
+              }
+            }
+            var textEl = Lib.ensureSingle(g2, "text", legendId + "text");
+            textEl.attr("text-anchor", "start").call(Drawing.font, font).text(isEditable ? ensureLength(name2, maxNameLength) : name2);
+            var textGap = legendObj.indentation + legendObj.itemwidth + constants.itemGap * 2;
+            svgTextUtils.positionText(textEl, textGap, 0);
+            if (isEditable) {
+              textEl.call(svgTextUtils.makeEditable, { gd: gd2, text: name2 }).call(textLayout, g2, gd2, legendObj).on("edit", function(newName) {
+                this.text(ensureLength(newName, maxNameLength)).call(textLayout, g2, gd2, legendObj);
+                var fullInput = legendItem.trace._fullInput || {};
+                var update = {};
+                update.name = newName;
+                if (fullInput._isShape) {
+                  return Registry.call("_guiRelayout", gd2, "shapes[" + trace.index + "].name", update.name);
+                } else {
+                  return Registry.call("_guiRestyle", gd2, update, trace.index);
+                }
+              });
+            } else {
+              textLayout(textEl, g2, gd2, legendObj);
+            }
+          }
+          function ensureLength(str, maxLength) {
+            var targetLength = Math.max(4, maxLength);
+            if (str && str.trim().length >= targetLength / 2) return str;
+            str = str || "";
+            for (var i2 = targetLength - str.length; i2 > 0; i2--) str += " ";
+            return str;
+          }
+          function setupTraceToggle(g2, gd2, legendId) {
+            var doubleClickDelay = gd2._context.doubleClickDelay;
+            var newMouseDownTime;
+            var numClicks = 1;
+            var traceToggle = Lib.ensureSingle(g2, "rect", legendId + "toggle", function(s2) {
+              if (!gd2._context.staticPlot) {
+                s2.style("cursor", "pointer").attr("pointer-events", "all");
+              }
+              s2.call(Color2.fill, "rgba(0,0,0,0)");
+            });
+            if (gd2._context.staticPlot) return;
+            traceToggle.on("mousedown", function() {
+              newMouseDownTime = (/* @__PURE__ */ new Date()).getTime();
+              if (newMouseDownTime - gd2._legendMouseDownTime < doubleClickDelay) {
+                numClicks += 1;
+              } else {
+                numClicks = 1;
+                gd2._legendMouseDownTime = newMouseDownTime;
+              }
+            });
+            traceToggle.on("mouseup", function() {
+              if (gd2._dragged || gd2._editing) return;
+              var legend = gd2._fullLayout[legendId];
+              if ((/* @__PURE__ */ new Date()).getTime() - gd2._legendMouseDownTime > doubleClickDelay) {
+                numClicks = Math.max(numClicks - 1, 1);
+              }
+              clickOrDoubleClick(gd2, legend, g2, numClicks, d3.event);
+            });
+          }
+          function setupTitleToggle(scrollBox, gd2, legendObj, legendId) {
+            const hasPie = gd2._fullData.some(function(trace) {
+              const legend = trace.legend || "legend";
+              const inThisLegend = Array.isArray(legend) ? legend.includes(legendId) : legend === legendId;
+              return inThisLegend && Registry.traceIs(trace, "pie-like");
+            });
+            if (hasPie) return;
+            const doubleClickDelay = gd2._context.doubleClickDelay;
+            var newMouseDownTime;
+            var numClicks = 1;
+            const titleToggle = Lib.ensureSingle(scrollBox, "rect", legendId + "titletoggle", function(s2) {
+              if (!gd2._context.staticPlot) {
+                s2.style("cursor", "pointer").attr("pointer-events", "all");
+              }
+              s2.call(Color2.fill, "rgba(0,0,0,0)");
+            });
+            if (gd2._context.staticPlot) return;
+            titleToggle.on("mousedown", function() {
+              newMouseDownTime = (/* @__PURE__ */ new Date()).getTime();
+              if (newMouseDownTime - gd2._legendMouseDownTime < doubleClickDelay) {
+                numClicks += 1;
+              } else {
+                numClicks = 1;
+                gd2._legendMouseDownTime = newMouseDownTime;
+              }
+            });
+            titleToggle.on("mouseup", function() {
+              if (gd2._dragged || gd2._editing) return;
+              if ((/* @__PURE__ */ new Date()).getTime() - gd2._legendMouseDownTime > doubleClickDelay) {
+                numClicks = Math.max(numClicks - 1, 1);
+              }
+              const evtData = {
+                event: d3.event,
+                legendId,
+                data: gd2.data,
+                layout: gd2.layout,
+                fullData: gd2._fullData,
+                fullLayout: gd2._fullLayout
+              };
+              if (numClicks === 1 && legendObj.titleclick) {
+                const clickVal = Events.triggerHandler(gd2, "plotly_legendtitleclick", evtData);
+                if (clickVal === false) return;
+                legendObj._titleClickTimeout = setTimeout(function() {
+                  if (gd2._fullLayout) handleTitleClick(gd2, legendObj, legendObj.titleclick);
+                }, doubleClickDelay);
+              } else if (numClicks === 2) {
+                if (legendObj._titleClickTimeout) clearTimeout(legendObj._titleClickTimeout);
+                gd2._legendMouseDownTime = 0;
+                const dblClickVal = Events.triggerHandler(gd2, "plotly_legendtitledoubleclick", evtData);
+                if (dblClickVal !== false && legendObj.titledoubleclick) handleTitleClick(gd2, legendObj, legendObj.titledoubleclick);
+              }
+            });
+          }
+          function textLayout(s2, g2, gd2, legendObj, aTitle) {
+            if (legendObj._inHover) s2.attr("data-notex", true);
+            svgTextUtils.convertToTspans(s2, gd2, function() {
+              computeTextDimensions(g2, gd2, legendObj, aTitle);
+            });
+          }
+          function computeTextDimensions(g2, gd2, legendObj, aTitle) {
+            var legendItem = g2.data()[0][0];
+            var showlegend = legendItem && legendItem.trace.showlegend;
+            if (Array.isArray(showlegend)) {
+              showlegend = showlegend[legendItem.i] !== false;
+            }
+            if (!legendObj._inHover && legendItem && !showlegend) {
+              g2.remove();
+              return;
+            }
+            var mathjaxGroup = g2.select("g[class*=math-group]");
+            var mathjaxNode = mathjaxGroup.node();
+            var legendId = helpers.getId(legendObj);
+            if (!legendObj) {
+              legendObj = gd2._fullLayout[legendId];
+            }
+            var bw = legendObj.borderwidth;
+            var font;
+            if (aTitle === MAIN_TITLE) {
+              font = legendObj.title.font;
+            } else if (legendItem.groupTitle) {
+              font = legendItem.groupTitle.font;
+            } else {
+              font = legendObj.font;
+            }
+            var lineHeight = font.size * LINE_SPACING;
+            var height, width;
+            if (mathjaxNode) {
+              var mathjaxBB = Drawing.bBox(mathjaxNode);
+              height = mathjaxBB.height;
+              width = mathjaxBB.width;
+              if (aTitle === MAIN_TITLE) {
+                Drawing.setTranslate(mathjaxGroup, bw, bw + height * 0.75);
+              } else {
+                Drawing.setTranslate(mathjaxGroup, 0, height * 0.25);
+              }
+            } else {
+              var cls = "." + legendId + (aTitle === MAIN_TITLE ? "title" : "") + "text";
+              var textEl = g2.select(cls);
+              var textLines = svgTextUtils.lineCount(textEl);
+              var textNode = textEl.node();
+              height = lineHeight * textLines;
+              width = textNode ? Drawing.bBox(textNode).width : 0;
+              if (aTitle === MAIN_TITLE) {
+                if (legendObj.title.side === "left") {
+                  width += constants.itemGap * 2;
+                }
+                svgTextUtils.positionText(
+                  textEl,
+                  bw + constants.titlePad,
+                  bw + lineHeight
+                );
+              } else {
+                var x2 = constants.itemGap * 2 + legendObj.indentation + legendObj.itemwidth;
+                if (legendItem.groupTitle) {
+                  x2 = constants.itemGap;
+                  width -= legendObj.indentation + legendObj.itemwidth;
+                }
+                svgTextUtils.positionText(
+                  textEl,
+                  x2,
+                  -lineHeight * ((textLines - 1) / 2 - 0.3)
+                );
+              }
+            }
+            if (aTitle === MAIN_TITLE) {
+              legendObj._titleWidth = width;
+              legendObj._titleHeight = height;
+            } else {
+              legendItem.lineHeight = lineHeight;
+              legendItem.height = Math.max(height, 16) + 3;
+              legendItem.width = width;
+            }
+          }
+          function getTitleSize(legendObj) {
+            var w2 = 0;
+            var h2 = 0;
+            var side = legendObj.title.side;
+            if (side) {
+              if (side.indexOf("left") !== -1) {
+                w2 = legendObj._titleWidth;
+              }
+              if (side.indexOf("top") !== -1) {
+                h2 = legendObj._titleHeight;
+              }
+            }
+            return [w2, h2];
+          }
+          function computeLegendDimensions(gd2, groups, traces, legendObj, scrollBox) {
+            var fullLayout = gd2._fullLayout;
+            var legendId = helpers.getId(legendObj);
+            if (!legendObj) {
+              legendObj = fullLayout[legendId];
+            }
+            var gs = fullLayout._size;
+            var isVertical = helpers.isVertical(legendObj);
+            var isGrouped = helpers.isGrouped(legendObj);
+            var isFraction = legendObj.entrywidthmode === "fraction";
+            var bw = legendObj.borderwidth;
+            var bw2 = 2 * bw;
+            var itemGap = constants.itemGap;
+            var textGap = legendObj.indentation + legendObj.itemwidth + itemGap * 2;
+            var endPad = 2 * (bw + itemGap);
+            var yanchor = getYanchor(legendObj);
+            var isBelowPlotArea = legendObj.y < 0 || legendObj.y === 0 && yanchor === "top";
+            var isAbovePlotArea = legendObj.y > 1 || legendObj.y === 1 && yanchor === "bottom";
+            var traceGroupGap = legendObj.tracegroupgap;
+            var legendGroupWidths = {};
+            const { orientation, yref } = legendObj;
+            let { maxheight } = legendObj;
+            const useFullLayoutHeight = isBelowPlotArea || isAbovePlotArea || orientation !== "v" || yref !== "paper";
+            maxheight || (maxheight = useFullLayoutHeight ? 0.5 : 1);
+            const heightToBeScaled = useFullLayoutHeight ? fullLayout.height : gs.h;
+            legendObj._maxHeight = Math.max(maxheight > 1 ? maxheight : maxheight * heightToBeScaled, 30);
+            var toggleRectWidth = 0;
+            legendObj._width = 0;
+            legendObj._height = 0;
+            var titleSize = getTitleSize(legendObj);
+            if (isVertical) {
+              traces.each(function(d2) {
+                var h2 = d2[0].height;
+                Drawing.setTranslate(
+                  this,
+                  bw + titleSize[0],
+                  bw + titleSize[1] + legendObj._height + h2 / 2 + itemGap
+                );
+                legendObj._height += h2;
+                legendObj._width = Math.max(legendObj._width, d2[0].width);
+              });
+              toggleRectWidth = textGap + legendObj._width;
+              legendObj._width += itemGap + textGap + bw2;
+              legendObj._height += endPad;
+              if (isGrouped) {
+                groups.each(function(d2, i2) {
+                  Drawing.setTranslate(this, 0, i2 * legendObj.tracegroupgap);
+                });
+                legendObj._height += (legendObj._lgroupsLength - 1) * legendObj.tracegroupgap;
+              }
+            } else {
+              var xanchor = getXanchor(legendObj);
+              var isLeftOfPlotArea = legendObj.x < 0 || legendObj.x === 0 && xanchor === "right";
+              var isRightOfPlotArea = legendObj.x > 1 || legendObj.x === 1 && xanchor === "left";
+              var isBeyondPlotAreaY = isAbovePlotArea || isBelowPlotArea;
+              var hw = fullLayout.width / 2;
+              legendObj._maxWidth = Math.max(
+                isLeftOfPlotArea ? isBeyondPlotAreaY && xanchor === "left" ? gs.l + gs.w : hw : isRightOfPlotArea ? isBeyondPlotAreaY && xanchor === "right" ? gs.r + gs.w : hw : gs.w,
+                2 * textGap
+              );
+              var maxItemWidth = 0;
+              var combinedItemWidth = 0;
+              traces.each(function(d2) {
+                var w2 = getTraceWidth(d2, legendObj, textGap);
+                maxItemWidth = Math.max(maxItemWidth, w2);
+                combinedItemWidth += w2;
+              });
+              toggleRectWidth = null;
+              var maxRowWidth = 0;
+              if (isGrouped) {
+                var maxGroupHeightInRow = 0;
+                var groupOffsetX = 0;
+                var groupOffsetY = 0;
+                groups.each(function() {
+                  var maxWidthInGroup = 0;
+                  var offsetY2 = 0;
+                  d3.select(this).selectAll("g.traces").each(function(d2) {
+                    var w2 = getTraceWidth(d2, legendObj, textGap);
+                    var h2 = d2[0].height;
+                    Drawing.setTranslate(
+                      this,
+                      titleSize[0],
+                      titleSize[1] + bw + itemGap + h2 / 2 + offsetY2
+                    );
+                    offsetY2 += h2;
+                    maxWidthInGroup = Math.max(maxWidthInGroup, w2);
+                    legendGroupWidths[d2[0].trace.legendgroup] = maxWidthInGroup;
+                  });
+                  var next = maxWidthInGroup + itemGap;
+                  if (
+                    // not on the first column already
+                    groupOffsetX > 0 && // goes beyound limit
+                    next + bw + groupOffsetX > legendObj._maxWidth
+                  ) {
+                    maxRowWidth = Math.max(maxRowWidth, groupOffsetX);
+                    groupOffsetX = 0;
+                    groupOffsetY += maxGroupHeightInRow + traceGroupGap;
+                    maxGroupHeightInRow = offsetY2;
+                  } else {
+                    maxGroupHeightInRow = Math.max(maxGroupHeightInRow, offsetY2);
+                  }
+                  Drawing.setTranslate(this, groupOffsetX, groupOffsetY);
+                  groupOffsetX += next;
+                });
+                legendObj._width = Math.max(maxRowWidth, groupOffsetX) + bw;
+                legendObj._height = groupOffsetY + maxGroupHeightInRow + endPad;
+              } else {
+                var nTraces = traces.size();
+                var oneRowLegend = combinedItemWidth + bw2 + (nTraces - 1) * itemGap < legendObj._maxWidth;
+                var maxItemHeightInRow = 0;
+                var offsetX = 0;
+                var offsetY = 0;
+                var rowWidth = 0;
+                traces.each(function(d2) {
+                  var h2 = d2[0].height;
+                  var w2 = getTraceWidth(d2, legendObj, textGap);
+                  var next = oneRowLegend ? w2 : maxItemWidth;
+                  if (!isFraction) {
+                    next += itemGap;
+                  }
+                  if (next + bw + offsetX - itemGap >= legendObj._maxWidth) {
+                    maxRowWidth = Math.max(maxRowWidth, rowWidth);
+                    offsetX = 0;
+                    offsetY += maxItemHeightInRow;
+                    legendObj._height += maxItemHeightInRow;
+                    maxItemHeightInRow = 0;
+                  }
+                  Drawing.setTranslate(
+                    this,
+                    titleSize[0] + bw + offsetX,
+                    titleSize[1] + bw + offsetY + h2 / 2 + itemGap
+                  );
+                  rowWidth = offsetX + w2 + itemGap;
+                  offsetX += next;
+                  maxItemHeightInRow = Math.max(maxItemHeightInRow, h2);
+                });
+                if (oneRowLegend) {
+                  legendObj._width = offsetX + bw2;
+                  legendObj._height = maxItemHeightInRow + endPad;
+                } else {
+                  legendObj._width = Math.max(maxRowWidth, rowWidth) + bw2;
+                  legendObj._height += maxItemHeightInRow + endPad;
+                }
+              }
+            }
+            legendObj._width = Math.ceil(
+              Math.max(
+                legendObj._width + titleSize[0],
+                legendObj._titleWidth + 2 * (bw + constants.titlePad)
+              )
+            );
+            legendObj._height = Math.ceil(
+              Math.max(
+                legendObj._height + titleSize[1],
+                legendObj._titleHeight + 2 * (bw + constants.itemGap)
+              )
+            );
+            legendObj._effHeight = Math.min(legendObj._height, legendObj._maxHeight);
+            var edits = gd2._context.edits;
+            var isEditable = edits.legendText || edits.legendPosition;
+            traces.each(function(d2) {
+              var traceToggle = d3.select(this).select("." + legendId + "toggle");
+              var h2 = d2[0].height;
+              var legendgroup = d2[0].trace.legendgroup;
+              var traceWidth = getTraceWidth(d2, legendObj, textGap);
+              if (isGrouped && legendgroup !== "") {
+                traceWidth = legendGroupWidths[legendgroup];
+              }
+              var w2 = isEditable ? textGap : toggleRectWidth || traceWidth;
+              if (!isVertical && !isFraction) {
+                w2 += itemGap / 2;
+              }
+              Drawing.setRect(traceToggle, 0, -h2 / 2, w2, h2);
+            });
+            var titleEl = scrollBox.select("." + legendId + "titletext");
+            if (titleEl.node()) {
+              horizontalAlignTitle(titleEl, legendObj, bw);
+            }
+            var titleToggle = scrollBox.select("." + legendId + "titletoggle");
+            if (titleToggle.size() && titleEl.node()) {
+              var titleX = titleEl.attr("x") || 0;
+              var pad = constants.titlePad;
+              Drawing.setRect(
+                titleToggle,
+                titleX - pad,
+                bw,
+                legendObj._titleWidth + 2 * pad,
+                legendObj._titleHeight + 2 * pad
+              );
+            }
+          }
+          function expandMargin(gd2, legendId, lx, ly) {
+            var fullLayout = gd2._fullLayout;
+            var legendObj = fullLayout[legendId];
+            var xanchor = getXanchor(legendObj);
+            var yanchor = getYanchor(legendObj);
+            var isPaperX = legendObj.xref === "paper";
+            var isPaperY = legendObj.yref === "paper";
+            gd2._fullLayout._reservedMargin[legendId] = {};
+            var sideY = legendObj.y < 0.5 ? "b" : "t";
+            var sideX = legendObj.x < 0.5 ? "l" : "r";
+            var possibleReservedMargins = {
+              r: fullLayout.width - lx,
+              l: lx + legendObj._width,
+              b: fullLayout.height - ly,
+              t: ly + legendObj._effHeight
+            };
+            if (isPaperX && isPaperY) {
+              return Plots.autoMargin(gd2, legendId, {
+                x: legendObj.x,
+                y: legendObj.y,
+                l: legendObj._width * FROM_TL[xanchor],
+                r: legendObj._width * FROM_BR[xanchor],
+                b: legendObj._effHeight * FROM_BR[yanchor],
+                t: legendObj._effHeight * FROM_TL[yanchor]
+              });
+            } else if (isPaperX) {
+              gd2._fullLayout._reservedMargin[legendId][sideY] = possibleReservedMargins[sideY];
+            } else if (isPaperY) {
+              gd2._fullLayout._reservedMargin[legendId][sideX] = possibleReservedMargins[sideX];
+            } else {
+              if (legendObj.orientation === "v") {
+                gd2._fullLayout._reservedMargin[legendId][sideX] = possibleReservedMargins[sideX];
+              } else {
+                gd2._fullLayout._reservedMargin[legendId][sideY] = possibleReservedMargins[sideY];
+              }
+            }
+          }
+          function getXanchor(legendObj) {
+            return Lib.isRightAnchor(legendObj) ? "right" : Lib.isCenterAnchor(legendObj) ? "center" : "left";
+          }
+          function getYanchor(legendObj) {
+            return Lib.isBottomAnchor(legendObj) ? "bottom" : Lib.isMiddleAnchor(legendObj) ? "middle" : "top";
+          }
+        }
+      });
+      var require_hover = __commonJS({
+        "src/components/fx/hover.js"(exports) {
+          var d3 = require_d3();
+          var isNumeric = require_fast_isnumeric();
+          var tinycolor = require_tinycolor();
+          var Lib = require_lib();
+          var pushUnique = Lib.pushUnique;
+          var strTranslate = Lib.strTranslate;
+          var strRotate = Lib.strRotate;
+          var Events = require_events2();
+          var svgTextUtils = require_svg_text_utils();
+          var overrideCursor = require_override_cursor();
+          var Drawing = require_drawing();
+          var Color2 = require_color();
+          var dragElement = require_dragelement();
+          var Axes = require_axes();
+          var zindexSeparator = require_constants2().zindexSeparator;
+          var Registry = require_registry();
+          var helpers = require_helpers2();
+          var constants = require_constants();
+          var legendSupplyDefaults = require_defaults3();
+          var legendDraw = require_draw();
+          var YANGLE = constants.YANGLE;
+          var YA_RADIANS = Math.PI * YANGLE / 180;
+          var YFACTOR = 1 / Math.sin(YA_RADIANS);
+          var YSHIFTX = Math.cos(YA_RADIANS);
+          var YSHIFTY = Math.sin(YA_RADIANS);
+          var HOVERARROWSIZE = constants.HOVERARROWSIZE;
+          var HOVERTEXTPAD = constants.HOVERTEXTPAD;
+          var multipleHoverPoints = {
+            box: true,
+            ohlc: true,
+            violin: true,
+            candlestick: true
+          };
+          var cartesianScatterPoints = {
+            scatter: true,
+            scattergl: true,
+            splom: true
+          };
+          function distanceSort(a2, b2) {
+            return a2.distance - b2.distance;
+          }
+          exports.hover = function hover(gd2, evt, subplot, noHoverEvent) {
+            gd2 = Lib.getGraphDiv(gd2);
+            var eventTarget = evt.target;
+            Lib.throttle(gd2._fullLayout._uid + constants.HOVERID, constants.HOVERMINTIME, function() {
+              _hover(gd2, evt, subplot, noHoverEvent, eventTarget);
+            });
+          };
+          exports.loneHover = function loneHover(hoverItems, opts) {
+            var multiHover = true;
+            if (!Array.isArray(hoverItems)) {
+              multiHover = false;
+              hoverItems = [hoverItems];
+            }
+            var gd2 = opts.gd;
+            var gTop = getTopOffset(gd2);
+            var gLeft = getLeftOffset(gd2);
+            var pointsData = hoverItems.map(function(hoverItem) {
+              var _x0 = hoverItem._x0 || hoverItem.x0 || hoverItem.x || 0;
+              var _x1 = hoverItem._x1 || hoverItem.x1 || hoverItem.x || 0;
+              var _y0 = hoverItem._y0 || hoverItem.y0 || hoverItem.y || 0;
+              var _y1 = hoverItem._y1 || hoverItem.y1 || hoverItem.y || 0;
+              var eventData = hoverItem.eventData;
+              if (eventData) {
+                var x0 = Math.min(_x0, _x1);
+                var x1 = Math.max(_x0, _x1);
+                var y0 = Math.min(_y0, _y1);
+                var y1 = Math.max(_y0, _y1);
+                var trace = hoverItem.trace;
+                if (Registry.traceIs(trace, "gl3d")) {
+                  var container = gd2._fullLayout[trace.scene]._scene.container;
+                  var dx = container.offsetLeft;
+                  var dy = container.offsetTop;
+                  x0 += dx;
+                  x1 += dx;
+                  y0 += dy;
+                  y1 += dy;
+                }
+                eventData.bbox = {
+                  x0: x0 + gLeft,
+                  x1: x1 + gLeft,
+                  y0: y0 + gTop,
+                  y1: y1 + gTop
+                };
+                if (opts.inOut_bbox) {
+                  opts.inOut_bbox.push(eventData.bbox);
+                }
+              } else {
+                eventData = false;
+              }
+              return {
+                color: hoverItem.color || Color2.defaultLine,
+                x0: hoverItem.x0 || hoverItem.x || 0,
+                x1: hoverItem.x1 || hoverItem.x || 0,
+                y0: hoverItem.y0 || hoverItem.y || 0,
+                y1: hoverItem.y1 || hoverItem.y || 0,
+                xLabel: hoverItem.xLabel,
+                yLabel: hoverItem.yLabel,
+                zLabel: hoverItem.zLabel,
+                text: hoverItem.text,
+                name: hoverItem.name,
+                idealAlign: hoverItem.idealAlign,
+                // optional extra bits of styling
+                borderColor: hoverItem.borderColor,
+                fontFamily: hoverItem.fontFamily,
+                fontSize: hoverItem.fontSize,
+                fontColor: hoverItem.fontColor,
+                fontWeight: hoverItem.fontWeight,
+                fontStyle: hoverItem.fontStyle,
+                fontVariant: hoverItem.fontVariant,
+                nameLength: hoverItem.nameLength,
+                textAlign: hoverItem.textAlign,
+                // filler to make createHoverText happy
+                trace: hoverItem.trace || {
+                  index: 0,
+                  hoverinfo: ""
+                },
+                xa: { _offset: 0 },
+                ya: { _offset: 0 },
+                index: 0,
+                hovertemplate: hoverItem.hovertemplate || false,
+                hovertemplateLabels: hoverItem.hovertemplateLabels || false,
+                eventData
+              };
+            });
+            var rotateLabels = false;
+            var hoverText = createHoverText(pointsData, {
+              gd: gd2,
+              hovermode: "closest",
+              rotateLabels,
+              bgColor: opts.bgColor || Color2.background,
+              container: d3.select(opts.container),
+              outerContainer: opts.outerContainer || opts.container
+            });
+            var hoverLabel = hoverText.hoverLabels;
+            var tooltipSpacing = 5;
+            var lastBottomY = 0;
+            var anchor = 0;
+            hoverLabel.sort(function(a2, b2) {
+              return a2.y0 - b2.y0;
+            }).each(function(d2, i2) {
+              var topY = d2.y0 - d2.by / 2;
+              if (topY - tooltipSpacing < lastBottomY) {
+                d2.offset = lastBottomY - topY + tooltipSpacing;
+              } else {
+                d2.offset = 0;
+              }
+              lastBottomY = topY + d2.by + d2.offset;
+              if (i2 === opts.anchorIndex || 0) anchor = d2.offset;
+            }).each(function(d2) {
+              d2.offset -= anchor;
+            });
+            var scaleX2 = gd2._fullLayout._invScaleX;
+            var scaleY2 = gd2._fullLayout._invScaleY;
+            alignHoverText(hoverLabel, rotateLabels, scaleX2, scaleY2);
+            return multiHover ? hoverLabel : hoverLabel.node();
+          };
+          function _hover(gd2, evt, subplot, noHoverEvent, eventTarget) {
+            if (!subplot) subplot = "xy";
+            if (typeof subplot === "string") {
+              subplot = subplot.split(zindexSeparator)[0];
+            }
+            var subplots = Array.isArray(subplot) ? subplot : [subplot];
+            var spId;
+            var fullLayout = gd2._fullLayout;
+            var hoversubplots = fullLayout.hoversubplots;
+            var plots = fullLayout._plots || [];
+            var plotinfo = plots[subplot];
+            var hasCartesian = fullLayout._has("cartesian");
+            var hovermode = evt.hovermode || fullLayout.hovermode;
+            var hovermodeHasX = (hovermode || "").charAt(0) === "x";
+            var hovermodeHasY = (hovermode || "").charAt(0) === "y";
+            var firstXaxis;
+            var firstYaxis;
+            if (hasCartesian && (hovermodeHasX || hovermodeHasY) && hoversubplots === "axis") {
+              var subplotsLength = subplots.length;
+              for (var p2 = 0; p2 < subplotsLength; p2++) {
+                spId = subplots[p2];
+                if (plots[spId]) {
+                  firstXaxis = Axes.getFromId(gd2, spId, "x");
+                  firstYaxis = Axes.getFromId(gd2, spId, "y");
+                  var subplotsWith = (hovermodeHasX ? firstXaxis : firstYaxis)._subplotsWith;
+                  if (subplotsWith && subplotsWith.length) {
+                    for (var q2 = 0; q2 < subplotsWith.length; q2++) {
+                      pushUnique(subplots, subplotsWith[q2]);
+                    }
+                  }
+                }
+              }
+            }
+            if (plotinfo && hoversubplots !== "single") {
+              var overlayedSubplots = plotinfo.overlays.map(function(pi2) {
+                return pi2.id;
+              });
+              subplots = subplots.concat(overlayedSubplots);
+            }
+            var len2 = subplots.length;
+            var xaArray = new Array(len2);
+            var yaArray = new Array(len2);
+            var supportsCompare = false;
+            for (var i2 = 0; i2 < len2; i2++) {
+              spId = subplots[i2];
+              if (plots[spId]) {
+                supportsCompare = true;
+                xaArray[i2] = plots[spId].xaxis;
+                yaArray[i2] = plots[spId].yaxis;
+              } else if (fullLayout[spId] && fullLayout[spId]._subplot) {
+                var _subplot = fullLayout[spId]._subplot;
+                xaArray[i2] = _subplot.xaxis;
+                yaArray[i2] = _subplot.yaxis;
+              } else {
+                Lib.warn("Unrecognized subplot: " + spId);
+                return;
+              }
+            }
+            if (hovermode && !supportsCompare) hovermode = "closest";
+            if (["x", "y", "closest", "x unified", "y unified"].indexOf(hovermode) === -1 || !gd2.calcdata || gd2.querySelector(".zoombox") || gd2._dragging) {
+              return dragElement.unhoverRaw(gd2, evt);
+            }
+            var hoverdistance = fullLayout.hoverdistance;
+            if (hoverdistance === -1) hoverdistance = Infinity;
+            var spikedistance = fullLayout.spikedistance;
+            if (spikedistance === -1) spikedistance = Infinity;
+            var hoverData = [];
+            var searchData = [];
+            var xvalArray, yvalArray;
+            var itemnum, curvenum, cd2, trace, subplotId, subploti, _mode, xval, yval, pointData, closedataPreviousLength;
+            var spikePoints = {
+              hLinePoint: null,
+              vLinePoint: null
+            };
+            var hasOneHorizontalTrace = false;
+            if (Array.isArray(evt)) {
+              hovermode = "array";
+              for (itemnum = 0; itemnum < evt.length; itemnum++) {
+                cd2 = gd2.calcdata[evt[itemnum].curveNumber || 0];
+                if (cd2) {
+                  trace = cd2[0].trace;
+                  if (cd2[0].trace.hoverinfo !== "skip") {
+                    searchData.push(cd2);
+                    if (trace.orientation === "h") {
+                      hasOneHorizontalTrace = true;
+                    }
+                  }
+                }
+              }
+            } else {
+              var zorderedCalcdata = gd2.calcdata.slice();
+              zorderedCalcdata.sort(function(a2, b2) {
+                var aZorder = a2[0].trace.zorder || 0;
+                var bZorder = b2[0].trace.zorder || 0;
+                return aZorder - bZorder;
+              });
+              for (curvenum = 0; curvenum < zorderedCalcdata.length; curvenum++) {
+                cd2 = zorderedCalcdata[curvenum];
+                trace = cd2[0].trace;
+                if (trace.hoverinfo !== "skip" && helpers.isTraceInSubplots(trace, subplots)) {
+                  searchData.push(cd2);
+                  if (trace.orientation === "h") {
+                    hasOneHorizontalTrace = true;
+                  }
+                }
+              }
+              var hasUserCalledHover = !eventTarget;
+              var xpx, ypx;
+              if (hasUserCalledHover) {
+                if ("xpx" in evt) xpx = evt.xpx;
+                else xpx = xaArray[0]._length / 2;
+                if ("ypx" in evt) ypx = evt.ypx;
+                else ypx = yaArray[0]._length / 2;
+              } else {
+                if (Events.triggerHandler(gd2, "plotly_beforehover", evt) === false) {
+                  return;
+                }
+                var dbb = eventTarget.getBoundingClientRect();
+                xpx = evt.clientX - dbb.left;
+                ypx = evt.clientY - dbb.top;
+                fullLayout._calcInverseTransform(gd2);
+                var transformedCoords = Lib.apply3DTransform(fullLayout._invTransform)(xpx, ypx);
+                xpx = transformedCoords[0];
+                ypx = transformedCoords[1];
+                if (xpx < 0 || xpx > xaArray[0]._length || ypx < 0 || ypx > yaArray[0]._length) {
+                  return dragElement.unhoverRaw(gd2, evt);
+                }
+              }
+              evt.pointerX = xpx + xaArray[0]._offset;
+              evt.pointerY = ypx + yaArray[0]._offset;
+              if ("xval" in evt) xvalArray = helpers.flat(subplots, evt.xval);
+              else xvalArray = helpers.p2c(xaArray, xpx);
+              if ("yval" in evt) yvalArray = helpers.flat(subplots, evt.yval);
+              else yvalArray = helpers.p2c(yaArray, ypx);
+              if (!isNumeric(xvalArray[0]) || !isNumeric(yvalArray[0])) {
+                Lib.warn("Fx.hover failed", evt, gd2);
+                return dragElement.unhoverRaw(gd2, evt);
+              }
+            }
+            var distance2 = Infinity;
+            function findHoverPoints(customXVal, customYVal) {
+              for (curvenum = 0; curvenum < searchData.length; curvenum++) {
+                cd2 = searchData[curvenum];
+                if (!cd2 || !cd2[0] || !cd2[0].trace) continue;
+                trace = cd2[0].trace;
+                if (trace.visible !== true || trace._length === 0) continue;
+                if (["carpet", "contourcarpet"].indexOf(trace._module.name) !== -1) continue;
+                _mode = hovermode;
+                if (helpers.isUnifiedHover(_mode)) {
+                  _mode = _mode.charAt(0);
+                }
+                if (trace.type === "splom") {
+                  subploti = 0;
+                  subplotId = subplots[subploti];
+                } else {
+                  subplotId = helpers.getSubplot(trace);
+                  subploti = subplots.indexOf(subplotId);
+                }
+                pointData = {
+                  // trace properties
+                  cd: cd2,
+                  trace,
+                  xa: xaArray[subploti],
+                  ya: yaArray[subploti],
+                  // max distances for hover and spikes - for points that want to show but do not
+                  // want to override other points, set distance/spikeDistance equal to max*Distance
+                  // and it will not get filtered out but it will be guaranteed to have a greater
+                  // distance than any point that calculated a real distance.
+                  maxHoverDistance: hoverdistance,
+                  maxSpikeDistance: spikedistance,
+                  // point properties - override all of these
+                  index: false,
+                  // point index in trace - only used by plotly.js hoverdata consumers
+                  distance: Math.min(distance2, hoverdistance),
+                  // pixel distance or pseudo-distance
+                  // distance/pseudo-distance for spikes. This distance should always be calculated
+                  // as if in "closest" mode, and should only be set if this point should
+                  // generate a spike.
+                  spikeDistance: Infinity,
+                  // in some cases the spikes have different positioning from the hover label
+                  // they don't need x0/x1, just one position
+                  xSpike: void 0,
+                  ySpike: void 0,
+                  // where and how to display the hover label
+                  color: Color2.defaultLine,
+                  // trace color
+                  name: trace.name,
+                  x0: void 0,
+                  x1: void 0,
+                  y0: void 0,
+                  y1: void 0,
+                  xLabelVal: void 0,
+                  yLabelVal: void 0,
+                  zLabelVal: void 0,
+                  text: void 0
+                };
+                if (fullLayout[subplotId]) {
+                  pointData.subplot = fullLayout[subplotId]._subplot;
+                }
+                if (fullLayout._splomScenes && fullLayout._splomScenes[trace.uid]) {
+                  pointData.scene = fullLayout._splomScenes[trace.uid];
+                }
+                if (_mode === "array") {
+                  var selection = evt[curvenum];
+                  if ("pointNumber" in selection) {
+                    pointData.index = selection.pointNumber;
+                    _mode = "closest";
+                  } else {
+                    _mode = "";
+                    if ("xval" in selection) {
+                      xval = selection.xval;
+                      _mode = "x";
+                    }
+                    if ("yval" in selection) {
+                      yval = selection.yval;
+                      _mode = _mode ? "closest" : "y";
+                    }
+                  }
+                } else if (customXVal !== void 0 && customYVal !== void 0) {
+                  xval = customXVal;
+                  yval = customYVal;
+                } else {
+                  xval = xvalArray[subploti];
+                  yval = yvalArray[subploti];
+                }
+                closedataPreviousLength = hoverData.length;
+                if (hoverdistance !== 0) {
+                  if (trace._module && trace._module.hoverPoints) {
+                    var newPoints = trace._module.hoverPoints(pointData, xval, yval, _mode, {
+                      finiteRange: true,
+                      hoverLayer: fullLayout._hoverlayer,
+                      // options for splom when hovering on same axis
+                      hoversubplots,
+                      gd: gd2
+                    });
+                    if (newPoints) {
+                      var newPoint;
+                      for (var newPointNum = 0; newPointNum < newPoints.length; newPointNum++) {
+                        newPoint = newPoints[newPointNum];
+                        if (isNumeric(newPoint.x0) && isNumeric(newPoint.y0)) {
+                          hoverData.push(cleanPoint(newPoint, hovermode));
+                        }
+                      }
+                    }
+                  } else {
+                    Lib.log("Unrecognized trace type in hover:", trace);
+                  }
+                }
+                if (hovermode === "closest" && hoverData.length > closedataPreviousLength) {
+                  hoverData.splice(0, closedataPreviousLength);
+                  distance2 = hoverData[0].distance;
+                }
+                if (hasCartesian && spikedistance !== 0) {
+                  if (hoverData.length === 0) {
+                    pointData.distance = spikedistance;
+                    pointData.index = false;
+                    var closestPoints = trace._module.hoverPoints(pointData, xval, yval, "closest", {
+                      hoverLayer: fullLayout._hoverlayer
+                    });
+                    if (closestPoints) {
+                      closestPoints = closestPoints.filter(function(point) {
+                        return point.spikeDistance <= spikedistance;
+                      });
+                    }
+                    if (closestPoints && closestPoints.length) {
+                      var tmpPoint;
+                      var closestVPoints = closestPoints.filter(function(point) {
+                        return point.xa.showspikes && point.xa.spikesnap !== "hovered data";
+                      });
+                      if (closestVPoints.length) {
+                        var closestVPt = closestVPoints[0];
+                        if (isNumeric(closestVPt.x0) && isNumeric(closestVPt.y0)) {
+                          tmpPoint = fillSpikePoint(closestVPt);
+                          if (!spikePoints.vLinePoint || spikePoints.vLinePoint.spikeDistance > tmpPoint.spikeDistance) {
+                            spikePoints.vLinePoint = tmpPoint;
+                          }
+                        }
+                      }
+                      var closestHPoints = closestPoints.filter(function(point) {
+                        return point.ya.showspikes && point.ya.spikesnap !== "hovered data";
+                      });
+                      if (closestHPoints.length) {
+                        var closestHPt = closestHPoints[0];
+                        if (isNumeric(closestHPt.x0) && isNumeric(closestHPt.y0)) {
+                          tmpPoint = fillSpikePoint(closestHPt);
+                          if (!spikePoints.hLinePoint || spikePoints.hLinePoint.spikeDistance > tmpPoint.spikeDistance) {
+                            spikePoints.hLinePoint = tmpPoint;
+                          }
+                        }
+                      }
+                    }
+                  }
+                }
+              }
+            }
+            findHoverPoints();
+            function selectClosestPoint(pointsData, spikedistance2, spikeOnWinning2) {
+              var resultPoint = null;
+              var minDistance = Infinity;
+              var thisSpikeDistance;
+              for (var i22 = 0; i22 < pointsData.length; i22++) {
+                if (firstXaxis && firstXaxis._id !== pointsData[i22].xa._id) continue;
+                if (firstYaxis && firstYaxis._id !== pointsData[i22].ya._id) continue;
+                thisSpikeDistance = pointsData[i22].spikeDistance;
+                if (spikeOnWinning2 && i22 === 0) thisSpikeDistance = -Infinity;
+                if (thisSpikeDistance <= minDistance && thisSpikeDistance <= spikedistance2) {
+                  resultPoint = pointsData[i22];
+                  minDistance = thisSpikeDistance;
+                }
+              }
+              return resultPoint;
+            }
+            function fillSpikePoint(point) {
+              if (!point) return null;
+              return {
+                xa: point.xa,
+                ya: point.ya,
+                x: point.xSpike !== void 0 ? point.xSpike : (point.x0 + point.x1) / 2,
+                y: point.ySpike !== void 0 ? point.ySpike : (point.y0 + point.y1) / 2,
+                distance: point.distance,
+                spikeDistance: point.spikeDistance,
+                curveNumber: point.trace.index,
+                color: point.color,
+                pointNumber: point.index
+              };
+            }
+            var spikelineOpts = {
+              fullLayout,
+              container: fullLayout._hoverlayer,
+              event: evt
+            };
+            gd2._spikepoints;
+            var newspikepoints = {
+              vLinePoint: spikePoints.vLinePoint,
+              hLinePoint: spikePoints.hLinePoint
+            };
+            gd2._spikepoints = newspikepoints;
+            var sortHoverData = function() {
+              var hoverDataInSubplot = hoverData.filter(function(a2) {
+                return firstXaxis && firstXaxis._id === a2.xa._id && firstYaxis && firstYaxis._id === a2.ya._id;
+              });
+              var hoverDataOutSubplot = hoverData.filter(function(a2) {
+                return !(firstXaxis && firstXaxis._id === a2.xa._id && firstYaxis && firstYaxis._id === a2.ya._id);
+              });
+              hoverDataInSubplot.sort(distanceSort);
+              hoverDataOutSubplot.sort(distanceSort);
+              hoverData = hoverDataInSubplot.concat(hoverDataOutSubplot);
+              hoverData = orderRangePoints(hoverData, hovermode);
+            };
+            sortHoverData();
+            var axLetter = hovermode.charAt(0);
+            var spikeOnWinning = (axLetter === "x" || axLetter === "y") && hoverData[0] && cartesianScatterPoints[hoverData[0].trace.type];
+            if (hasCartesian && spikedistance !== 0) {
+              if (hoverData.length !== 0) {
+                var tmpHPointData = hoverData.filter(function(point) {
+                  return point.ya.showspikes;
+                });
+                var tmpHPoint = selectClosestPoint(tmpHPointData, spikedistance, spikeOnWinning);
+                spikePoints.hLinePoint = fillSpikePoint(tmpHPoint);
+                var tmpVPointData = hoverData.filter(function(point) {
+                  return point.xa.showspikes;
+                });
+                var tmpVPoint = selectClosestPoint(tmpVPointData, spikedistance, spikeOnWinning);
+                spikePoints.vLinePoint = fillSpikePoint(tmpVPoint);
+              }
+            }
+            if (hoverData.length === 0) {
+              var result = dragElement.unhoverRaw(gd2, evt);
+              if (hasCartesian && (spikePoints.hLinePoint !== null || spikePoints.vLinePoint !== null)) {
+                if (spikesChanged()) {
+                  createSpikelines(gd2, spikePoints, spikelineOpts);
+                }
+              }
+              return result;
+            }
+            if (hasCartesian) {
+              if (spikesChanged()) {
+                createSpikelines(gd2, spikePoints, spikelineOpts);
+              }
+            }
+            if (helpers.isXYhover(_mode) && hoverData[0].length !== 0 && hoverData[0].trace.type !== "splom") {
+              var winningPoint = hoverData[0];
+              if (multipleHoverPoints[winningPoint.trace.type]) {
+                hoverData = hoverData.filter((d2) => d2.trace.index === winningPoint.trace.index);
+              } else {
+                hoverData = [winningPoint];
+              }
+              var initLen = hoverData.length;
+              var winX = getCoord("x", winningPoint, fullLayout);
+              var winY = getCoord("y", winningPoint, fullLayout);
+              findHoverPoints(winX, winY);
+              var finalPoints = [];
+              var seen2 = {};
+              var id2 = 0;
+              var insert = function(newHd) {
+                var key = multipleHoverPoints[newHd.trace.type] ? hoverDataKey(newHd) : newHd.trace.index;
+                if (!seen2[key]) {
+                  id2++;
+                  seen2[key] = id2;
+                  finalPoints.push(newHd);
+                } else {
+                  var oldId = seen2[key] - 1;
+                  var oldHd = finalPoints[oldId];
+                  if (oldId > 0 && Math.abs(newHd.distance) < Math.abs(oldHd.distance)) {
+                    finalPoints[oldId] = newHd;
+                  }
+                }
+              };
+              var k2;
+              for (k2 = 0; k2 < initLen; k2++) {
+                insert(hoverData[k2]);
+              }
+              for (k2 = hoverData.length - 1; k2 > initLen - 1; k2--) {
+                insert(hoverData[k2]);
+              }
+              hoverData = finalPoints;
+              sortHoverData();
+            }
+            var oldhoverdata = gd2._hoverdata;
+            var newhoverdata = [];
+            var gTop = getTopOffset(gd2);
+            var gLeft = getLeftOffset(gd2);
+            for (const pt2 of hoverData) {
+              var eventData = helpers.makeEventData(pt2, pt2.trace, pt2.cd);
+              if (pt2.hovertemplate !== false) {
+                var ht2 = false;
+                if (pt2.cd[pt2.index] && pt2.cd[pt2.index].ht) {
+                  ht2 = pt2.cd[pt2.index].ht;
+                }
+                pt2.hovertemplate = ht2 || pt2.trace.hovertemplate || false;
+              }
+              if (pt2.xa && pt2.ya) {
+                var _x0 = pt2.x0 + pt2.xa._offset;
+                var _x1 = pt2.x1 + pt2.xa._offset;
+                var _y0 = pt2.y0 + pt2.ya._offset;
+                var _y1 = pt2.y1 + pt2.ya._offset;
+                var x0 = Math.min(_x0, _x1);
+                var x1 = Math.max(_x0, _x1);
+                var y0 = Math.min(_y0, _y1);
+                var y1 = Math.max(_y0, _y1);
+                eventData.bbox = {
+                  x0: x0 + gLeft,
+                  x1: x1 + gLeft,
+                  y0: y0 + gTop,
+                  y1: y1 + gTop
+                };
+              }
+              pt2.eventData = [eventData];
+              newhoverdata.push(eventData);
+            }
+            gd2._hoverdata = newhoverdata;
+            var rotateLabels = hovermode === "y" && (searchData.length > 1 || hoverData.length > 1) || hovermode === "closest" && hasOneHorizontalTrace && hoverData.length > 1;
+            var bgColor = Color2.combine(fullLayout.plot_bgcolor || Color2.background, fullLayout.paper_bgcolor);
+            var hoverText = createHoverText(hoverData, {
+              gd: gd2,
+              hovermode,
+              rotateLabels,
+              bgColor,
+              container: fullLayout._hoverlayer,
+              outerContainer: fullLayout._paper.node(),
+              commonLabelOpts: fullLayout.hoverlabel,
+              hoverdistance: fullLayout.hoverdistance
+            });
+            var hoverLabels = hoverText.hoverLabels;
+            if (!helpers.isUnifiedHover(hovermode)) {
+              hoverAvoidOverlaps(hoverLabels, rotateLabels, fullLayout, hoverText.commonLabelBoundingBox);
+              alignHoverText(hoverLabels, rotateLabels, fullLayout._invScaleX, fullLayout._invScaleY);
+            }
+            if (eventTarget && eventTarget.tagName) {
+              var hasClickToShow = Registry.getComponentMethod("annotations", "hasClickToShow")(gd2, newhoverdata);
+              overrideCursor(d3.select(eventTarget), hasClickToShow ? "pointer" : "");
+            }
+            if (!eventTarget || noHoverEvent || !hoverChanged(gd2, evt, oldhoverdata)) return;
+            if (oldhoverdata) {
+              gd2.emit("plotly_unhover", {
+                event: evt,
+                points: oldhoverdata
+              });
+            }
+            gd2.emit("plotly_hover", {
+              event: evt,
+              points: gd2._hoverdata,
+              xaxes: xaArray,
+              yaxes: yaArray,
+              xvals: xvalArray,
+              yvals: yvalArray
+            });
+          }
+          function hoverDataKey(d2) {
+            return [d2.trace.index, d2.index, d2.x0, d2.y0, d2.name, d2.attr, d2.xa ? d2.xa._id : "", d2.ya ? d2.ya._id : ""].join(",");
+          }
+          var EXTRA_STRING_REGEX = /<extra>([\s\S]*)<\/extra>/;
+          function createHoverText(hoverData, opts) {
+            var gd2 = opts.gd;
+            var fullLayout = gd2._fullLayout;
+            var hovermode = opts.hovermode;
+            var rotateLabels = opts.rotateLabels;
+            var bgColor = opts.bgColor;
+            var container = opts.container;
+            var outerContainer = opts.outerContainer;
+            var commonLabelOpts = opts.commonLabelOpts || {};
+            if (hoverData.length === 0) return [[]];
+            var fontFamily = opts.fontFamily || constants.HOVERFONT;
+            var fontSize = opts.fontSize || constants.HOVERFONTSIZE;
+            var fontWeight = opts.fontWeight || fullLayout.font.weight;
+            var fontStyle = opts.fontStyle || fullLayout.font.style;
+            var fontVariant = opts.fontVariant || fullLayout.font.variant;
+            var fontTextcase = opts.fontTextcase || fullLayout.font.textcase;
+            var fontLineposition = opts.fontLineposition || fullLayout.font.lineposition;
+            var fontShadow = opts.fontShadow || fullLayout.font.shadow;
+            var c0 = hoverData[0];
+            var xa = c0.xa;
+            var ya2 = c0.ya;
+            var axLetter = hovermode.charAt(0);
+            var axLabel = axLetter + "Label";
+            var t02 = c0[axLabel];
+            if (t02 === void 0 && xa.type === "multicategory") {
+              for (var q2 = 0; q2 < hoverData.length; q2++) {
+                t02 = hoverData[q2][axLabel];
+                if (t02 !== void 0) break;
+              }
+            }
+            var outerContainerBB = getBoundingClientRect(gd2, outerContainer);
+            var outerTop = outerContainerBB.top;
+            var outerWidth = outerContainerBB.width;
+            var outerHeight = outerContainerBB.height;
+            var showCommonLabel = t02 !== void 0 && c0.distance <= opts.hoverdistance && (hovermode === "x" || hovermode === "y");
+            if (showCommonLabel) {
+              var allHaveZ = true;
+              var i2, traceHoverinfo;
+              for (i2 = 0; i2 < hoverData.length; i2++) {
+                if (allHaveZ && hoverData[i2].zLabel === void 0) allHaveZ = false;
+                traceHoverinfo = hoverData[i2].hoverinfo || hoverData[i2].trace.hoverinfo;
+                if (traceHoverinfo) {
+                  var parts = Array.isArray(traceHoverinfo) ? traceHoverinfo : traceHoverinfo.split("+");
+                  if (parts.indexOf("all") === -1 && parts.indexOf(hovermode) === -1) {
+                    showCommonLabel = false;
+                    break;
+                  }
+                }
+              }
+              if (allHaveZ) showCommonLabel = false;
+            }
+            var commonLabel = container.selectAll("g.axistext").data(showCommonLabel ? [0] : []);
+            commonLabel.enter().append("g").classed("axistext", true);
+            commonLabel.exit().remove();
+            var commonLabelRect = {
+              minX: 0,
+              maxX: 0,
+              minY: 0,
+              maxY: 0
+            };
+            commonLabel.each(function() {
+              var label = d3.select(this);
+              var lpath = Lib.ensureSingle(label, "path", "", function(s2) {
+                s2.style({ "stroke-width": "1px" });
+              });
+              var ltext = Lib.ensureSingle(label, "text", "", function(s2) {
+                s2.attr("data-notex", 1);
+              });
+              var commonBgColor = commonLabelOpts.bgcolor || Color2.defaultLine;
+              var commonStroke = commonLabelOpts.bordercolor || Color2.contrast(commonBgColor);
+              var contrastColor = Color2.contrast(commonBgColor);
+              var commonLabelOptsFont = commonLabelOpts.font;
+              var commonLabelFont = {
+                weight: commonLabelOptsFont.weight || fontWeight,
+                style: commonLabelOptsFont.style || fontStyle,
+                variant: commonLabelOptsFont.variant || fontVariant,
+                textcase: commonLabelOptsFont.textcase || fontTextcase,
+                lineposition: commonLabelOptsFont.lineposition || fontLineposition,
+                shadow: commonLabelOptsFont.shadow || fontShadow,
+                family: commonLabelOptsFont.family || fontFamily,
+                size: commonLabelOptsFont.size || fontSize,
+                color: commonLabelOptsFont.color || contrastColor
+              };
+              lpath.style({
+                fill: commonBgColor,
+                stroke: commonStroke
+              });
+              ltext.text(t02).call(Drawing.font, commonLabelFont).call(svgTextUtils.positionText, 0, 0).call(svgTextUtils.convertToTspans, gd2);
+              label.attr("transform", "");
+              var tbb2 = getBoundingClientRect(gd2, ltext.node());
+              var lx2, ly2;
+              if (hovermode === "x") {
+                var topsign = xa.side === "top" ? "-" : "";
+                ltext.attr("text-anchor", "middle").call(
+                  svgTextUtils.positionText,
+                  0,
+                  xa.side === "top" ? outerTop - tbb2.bottom - HOVERARROWSIZE - HOVERTEXTPAD : outerTop - tbb2.top + HOVERARROWSIZE + HOVERTEXTPAD
+                );
+                lx2 = xa._offset + (c0.x0 + c0.x1) / 2;
+                ly2 = ya2._offset + (xa.side === "top" ? 0 : ya2._length);
+                var halfWidth = tbb2.width / 2 + HOVERTEXTPAD;
+                var tooltipMidX = lx2;
+                if (lx2 < halfWidth) {
+                  tooltipMidX = halfWidth;
+                } else if (lx2 > fullLayout.width - halfWidth) {
+                  tooltipMidX = fullLayout.width - halfWidth;
+                }
+                lpath.attr(
+                  "d",
+                  "M" + (lx2 - tooltipMidX) + ",0L" + (lx2 - tooltipMidX + HOVERARROWSIZE) + "," + topsign + HOVERARROWSIZE + "H" + halfWidth + "v" + topsign + (HOVERTEXTPAD * 2 + tbb2.height) + "H" + -halfWidth + "V" + topsign + HOVERARROWSIZE + "H" + (lx2 - tooltipMidX - HOVERARROWSIZE) + "Z"
+                );
+                lx2 = tooltipMidX;
+                commonLabelRect.minX = lx2 - halfWidth;
+                commonLabelRect.maxX = lx2 + halfWidth;
+                if (xa.side === "top") {
+                  commonLabelRect.minY = ly2 - (HOVERTEXTPAD * 2 + tbb2.height);
+                  commonLabelRect.maxY = ly2 - HOVERTEXTPAD;
+                } else {
+                  commonLabelRect.minY = ly2 + HOVERTEXTPAD;
+                  commonLabelRect.maxY = ly2 + (HOVERTEXTPAD * 2 + tbb2.height);
+                }
+              } else {
+                var anchor;
+                var sgn;
+                var leftsign;
+                if (ya2.side === "right") {
+                  anchor = "start";
+                  sgn = 1;
+                  leftsign = "";
+                  lx2 = xa._offset + xa._length;
+                } else {
+                  anchor = "end";
+                  sgn = -1;
+                  leftsign = "-";
+                  lx2 = xa._offset;
+                }
+                ly2 = ya2._offset + (c0.y0 + c0.y1) / 2;
+                ltext.attr("text-anchor", anchor);
+                lpath.attr(
+                  "d",
+                  "M0,0L" + leftsign + HOVERARROWSIZE + "," + HOVERARROWSIZE + "V" + (HOVERTEXTPAD + tbb2.height / 2) + "h" + leftsign + (HOVERTEXTPAD * 2 + tbb2.width) + "V-" + (HOVERTEXTPAD + tbb2.height / 2) + "H" + leftsign + HOVERARROWSIZE + "V-" + HOVERARROWSIZE + "Z"
+                );
+                commonLabelRect.minY = ly2 - (HOVERTEXTPAD + tbb2.height / 2);
+                commonLabelRect.maxY = ly2 + (HOVERTEXTPAD + tbb2.height / 2);
+                if (ya2.side === "right") {
+                  commonLabelRect.minX = lx2 + HOVERARROWSIZE;
+                  commonLabelRect.maxX = lx2 + HOVERARROWSIZE + (HOVERTEXTPAD * 2 + tbb2.width);
+                } else {
+                  commonLabelRect.minX = lx2 - HOVERARROWSIZE - (HOVERTEXTPAD * 2 + tbb2.width);
+                  commonLabelRect.maxX = lx2 - HOVERARROWSIZE;
+                }
+                var halfHeight = tbb2.height / 2;
+                var lty = outerTop - tbb2.top - halfHeight;
+                var clipId = "clip" + fullLayout._uid + "commonlabel" + ya2._id;
+                var clipPath;
+                if (lx2 < tbb2.width + 2 * HOVERTEXTPAD + HOVERARROWSIZE) {
+                  clipPath = "M-" + (HOVERARROWSIZE + HOVERTEXTPAD) + "-" + halfHeight + "h-" + (tbb2.width - HOVERTEXTPAD) + "V" + halfHeight + "h" + (tbb2.width - HOVERTEXTPAD) + "Z";
+                  var ltx = tbb2.width - lx2 + HOVERTEXTPAD;
+                  svgTextUtils.positionText(ltext, ltx, lty);
+                  if (anchor === "end") {
+                    ltext.selectAll("tspan").each(function() {
+                      var s2 = d3.select(this);
+                      var dummy = Drawing.tester.append("text").text(s2.text()).call(Drawing.font, commonLabelFont);
+                      var dummyBB = getBoundingClientRect(gd2, dummy.node());
+                      if (Math.round(dummyBB.width) < Math.round(tbb2.width)) {
+                        s2.attr("x", ltx - dummyBB.width);
+                      }
+                      dummy.remove();
+                    });
+                  }
+                } else {
+                  svgTextUtils.positionText(ltext, sgn * (HOVERTEXTPAD + HOVERARROWSIZE), lty);
+                  clipPath = null;
+                }
+                var textClip = fullLayout._topclips.selectAll("#" + clipId).data(clipPath ? [0] : []);
+                textClip.enter().append("clipPath").attr("id", clipId).append("path");
+                textClip.exit().remove();
+                textClip.select("path").attr("d", clipPath);
+                Drawing.setClipUrl(ltext, clipPath ? clipId : null, gd2);
+              }
+              label.attr("transform", strTranslate(lx2, ly2));
+            });
+            if (helpers.isUnifiedHover(hovermode)) {
+              container.selectAll("g.hovertext").remove();
+              const groupedHoverData = hoverData.filter((data) => data.hoverinfo !== "none");
+              if (groupedHoverData.length === 0) return [];
+              var hoverlabel = fullLayout.hoverlabel;
+              var font = hoverlabel.font;
+              var item0 = groupedHoverData[0];
+              var unifiedhovertitleText = ((hovermode === "x unified" ? item0.xa : item0.ya).unifiedhovertitle || {}).text;
+              var mainText = !unifiedhovertitleText ? t02 : Lib.hovertemplateString({
+                data: hovermode === "x unified" ? [{ xa: item0.xa, x: item0.xVal }] : [{ ya: item0.ya, y: item0.yVal }],
+                fallback: item0.trace.hovertemplatefallback,
+                locale: fullLayout._d3locale,
+                template: unifiedhovertitleText
+              });
+              var mockLayoutIn = {
+                showlegend: true,
+                legend: {
+                  title: { text: mainText, font },
+                  font,
+                  bgcolor: hoverlabel.bgcolor,
+                  bordercolor: hoverlabel.bordercolor,
+                  borderwidth: 1,
+                  tracegroupgap: 7,
+                  traceorder: fullLayout.legend ? fullLayout.legend.traceorder : void 0,
+                  orientation: "v"
+                }
+              };
+              var mockLayoutOut = {
+                font
+              };
+              legendSupplyDefaults(mockLayoutIn, mockLayoutOut, gd2._fullData);
+              var mockLegend = mockLayoutOut.legend;
+              mockLegend.entries = [];
+              for (var j2 = 0; j2 < groupedHoverData.length; j2++) {
+                var pt2 = groupedHoverData[j2];
+                if (pt2.hoverinfo === "none") continue;
+                var texts = getHoverLabelText(pt2, true, hovermode, fullLayout, t02);
+                var text = texts[0];
+                var name2 = texts[1];
+                pt2.name = name2;
+                if (name2 !== "") {
+                  pt2.text = name2 + " : " + text;
+                } else {
+                  pt2.text = text;
+                }
+                var cd2 = pt2.cd[pt2.index];
+                if (cd2) {
+                  if (cd2.mc) pt2.mc = cd2.mc;
+                  if (cd2.mcc) pt2.mc = cd2.mcc;
+                  if (cd2.mlc) pt2.mlc = cd2.mlc;
+                  if (cd2.mlcc) pt2.mlc = cd2.mlcc;
+                  if (cd2.mlw) pt2.mlw = cd2.mlw;
+                  if (cd2.mrc) pt2.mrc = cd2.mrc;
+                  if (cd2.dir) pt2.dir = cd2.dir;
+                }
+                pt2._distinct = true;
+                mockLegend.entries.push([pt2]);
+              }
+              mockLegend.entries.sort(function(a2, b2) {
+                return a2[0].trace.index - b2[0].trace.index;
+              });
+              mockLegend.layer = container;
+              mockLegend._inHover = true;
+              mockLegend._groupTitleFont = hoverlabel.grouptitlefont;
+              legendDraw(gd2, mockLegend);
+              var legendContainer = container.select("g.legend");
+              var tbb = getBoundingClientRect(gd2, legendContainer.node());
+              var tWidth = tbb.width + 2 * HOVERTEXTPAD;
+              var tHeight = tbb.height + 2 * HOVERTEXTPAD;
+              var winningPoint = groupedHoverData[0];
+              var avgX = (winningPoint.x0 + winningPoint.x1) / 2;
+              var avgY = (winningPoint.y0 + winningPoint.y1) / 2;
+              var pointWon = !(Registry.traceIs(winningPoint.trace, "bar-like") || Registry.traceIs(winningPoint.trace, "box-violin"));
+              var lyBottom, lyTop;
+              if (axLetter === "y") {
+                if (pointWon) {
+                  lyTop = avgY - HOVERTEXTPAD;
+                  lyBottom = avgY + HOVERTEXTPAD;
+                } else {
+                  lyTop = Math.min.apply(
+                    null,
+                    groupedHoverData.map(function(c2) {
+                      return Math.min(c2.y0, c2.y1);
+                    })
+                  );
+                  lyBottom = Math.max.apply(
+                    null,
+                    groupedHoverData.map(function(c2) {
+                      return Math.max(c2.y0, c2.y1);
+                    })
+                  );
+                }
+              } else {
+                lyTop = lyBottom = Lib.mean(
+                  groupedHoverData.map(function(c2) {
+                    return (c2.y0 + c2.y1) / 2;
+                  })
+                ) - tHeight / 2;
+              }
+              var lxRight, lxLeft;
+              if (axLetter === "x") {
+                if (pointWon) {
+                  lxRight = avgX + HOVERTEXTPAD;
+                  lxLeft = avgX - HOVERTEXTPAD;
+                } else {
+                  lxRight = Math.max.apply(
+                    null,
+                    groupedHoverData.map(function(c2) {
+                      return Math.max(c2.x0, c2.x1);
+                    })
+                  );
+                  lxLeft = Math.min.apply(
+                    null,
+                    groupedHoverData.map(function(c2) {
+                      return Math.min(c2.x0, c2.x1);
+                    })
+                  );
+                }
+              } else {
+                lxRight = lxLeft = Lib.mean(
+                  groupedHoverData.map(function(c2) {
+                    return (c2.x0 + c2.x1) / 2;
+                  })
+                ) - tWidth / 2;
+              }
+              var xOffset = xa._offset;
+              var yOffset = ya2._offset;
+              lyBottom += yOffset;
+              lxRight += xOffset;
+              lxLeft += xOffset - tWidth;
+              lyTop += yOffset - tHeight;
+              var lx, ly;
+              if (lxRight + tWidth < outerWidth && lxRight >= 0) {
+                lx = lxRight;
+              } else if (lxLeft + tWidth < outerWidth && lxLeft >= 0) {
+                lx = lxLeft;
+              } else if (xOffset + tWidth < outerWidth) {
+                lx = xOffset;
+              } else {
+                if (lxRight - avgX < avgX - lxLeft + tWidth) {
+                  lx = outerWidth - tWidth;
+                } else {
+                  lx = 0;
+                }
+              }
+              lx += HOVERTEXTPAD;
+              if (lyBottom + tHeight < outerHeight && lyBottom >= 0) {
+                ly = lyBottom;
+              } else if (lyTop + tHeight < outerHeight && lyTop >= 0) {
+                ly = lyTop;
+              } else if (yOffset + tHeight < outerHeight) {
+                ly = yOffset;
+              } else {
+                if (lyBottom - avgY < avgY - lyTop + tHeight) {
+                  ly = outerHeight - tHeight;
+                } else {
+                  ly = 0;
+                }
+              }
+              ly += HOVERTEXTPAD;
+              legendContainer.attr("transform", strTranslate(lx - 1, ly - 1));
+              return legendContainer;
+            }
+            var hoverLabels = container.selectAll("g.hovertext").data(hoverData, function(d2) {
+              return hoverDataKey(d2);
+            });
+            hoverLabels.enter().append("g").classed("hovertext", true).each(function() {
+              var g2 = d3.select(this);
+              g2.append("rect").call(Color2.fill, Color2.addOpacity(bgColor, 0.8));
+              g2.append("text").classed("name", true);
+              g2.append("path").style("stroke-width", "1px");
+              g2.append("text").classed("nums", true).call(Drawing.font, {
+                weight: fontWeight,
+                style: fontStyle,
+                variant: fontVariant,
+                textcase: fontTextcase,
+                lineposition: fontLineposition,
+                shadow: fontShadow,
+                family: fontFamily,
+                size: fontSize
+              });
+            });
+            hoverLabels.exit().remove();
+            hoverLabels.each(function(d2) {
+              var g2 = d3.select(this).attr("transform", "");
+              var dColor = d2.color;
+              if (Array.isArray(dColor)) {
+                dColor = dColor[d2.eventData[0].pointNumber];
+              }
+              var color0 = d2.bgcolor || dColor;
+              var numsColor = Color2.combine(Color2.opacity(color0) ? color0 : Color2.defaultLine, bgColor);
+              var nameColor = Color2.combine(Color2.opacity(dColor) ? dColor : Color2.defaultLine, bgColor);
+              var contrastColor = d2.borderColor || Color2.contrast(numsColor);
+              var texts2 = getHoverLabelText(d2, showCommonLabel, hovermode, fullLayout, t02, g2);
+              var text2 = texts2[0];
+              var name3 = texts2[1];
+              var tx = g2.select("text.nums").call(Drawing.font, {
+                family: d2.fontFamily || fontFamily,
+                size: d2.fontSize || fontSize,
+                color: d2.fontColor || contrastColor,
+                weight: d2.fontWeight || fontWeight,
+                style: d2.fontStyle || fontStyle,
+                variant: d2.fontVariant || fontVariant,
+                textcase: d2.fontTextcase || fontTextcase,
+                lineposition: d2.fontLineposition || fontLineposition,
+                shadow: d2.fontShadow || fontShadow
+              }).text(text2).attr("data-notex", 1).call(svgTextUtils.positionText, 0, 0).call(svgTextUtils.convertToTspans, gd2);
+              var tx2 = g2.select("text.name");
+              var tx2width = 0;
+              var tx2height = 0;
+              if (name3 && name3 !== text2) {
+                tx2.call(Drawing.font, {
+                  family: d2.fontFamily || fontFamily,
+                  size: d2.fontSize || fontSize,
+                  color: nameColor,
+                  weight: d2.fontWeight || fontWeight,
+                  style: d2.fontStyle || fontStyle,
+                  variant: d2.fontVariant || fontVariant,
+                  textcase: d2.fontTextcase || fontTextcase,
+                  lineposition: d2.fontLineposition || fontLineposition,
+                  shadow: d2.fontShadow || fontShadow
+                }).text(name3).attr("data-notex", 1).call(svgTextUtils.positionText, 0, 0).call(svgTextUtils.convertToTspans, gd2);
+                var t2bb = getBoundingClientRect(gd2, tx2.node());
+                tx2width = t2bb.width + 2 * HOVERTEXTPAD;
+                tx2height = t2bb.height + 2 * HOVERTEXTPAD;
+              } else {
+                tx2.remove();
+                g2.select("rect").remove();
+              }
+              g2.select("path").style({
+                fill: numsColor,
+                stroke: contrastColor
+              });
+              var htx = d2.xa._offset + (d2.x0 + d2.x1) / 2;
+              var hty = d2.ya._offset + (d2.y0 + d2.y1) / 2;
+              var dx = Math.abs(d2.x1 - d2.x0);
+              var dy = Math.abs(d2.y1 - d2.y0);
+              var tbb2 = getBoundingClientRect(gd2, tx.node());
+              var tbbWidth = tbb2.width / fullLayout._invScaleX;
+              var tbbHeight = tbb2.height / fullLayout._invScaleY;
+              d2.ty0 = (outerTop - tbb2.top) / fullLayout._invScaleY;
+              d2.bx = tbbWidth + 2 * HOVERTEXTPAD;
+              d2.by = Math.max(tbbHeight + 2 * HOVERTEXTPAD, tx2height);
+              d2.anchor = "start";
+              d2.txwidth = tbbWidth;
+              d2.tx2width = tx2width;
+              d2.offset = 0;
+              var txTotalWidth = (tbbWidth + HOVERARROWSIZE + HOVERTEXTPAD + tx2width) * fullLayout._invScaleX;
+              var anchorStartOK, anchorEndOK;
+              if (rotateLabels) {
+                d2.pos = htx;
+                anchorStartOK = hty + dy / 2 + txTotalWidth <= outerHeight;
+                anchorEndOK = hty - dy / 2 - txTotalWidth >= 0;
+                if ((d2.idealAlign === "top" || !anchorStartOK) && anchorEndOK) {
+                  hty -= dy / 2;
+                  d2.anchor = "end";
+                } else if (anchorStartOK) {
+                  hty += dy / 2;
+                  d2.anchor = "start";
+                } else {
+                  d2.anchor = "middle";
+                }
+                d2.crossPos = hty;
+              } else {
+                d2.pos = hty;
+                anchorStartOK = htx + dx / 2 + txTotalWidth <= outerWidth;
+                anchorEndOK = htx - dx / 2 - txTotalWidth >= 0;
+                if ((d2.idealAlign === "left" || !anchorStartOK) && anchorEndOK) {
+                  htx -= dx / 2;
+                  d2.anchor = "end";
+                } else if (anchorStartOK) {
+                  htx += dx / 2;
+                  d2.anchor = "start";
+                } else {
+                  d2.anchor = "middle";
+                  var txHalfWidth = txTotalWidth / 2;
+                  var overflowR = htx + txHalfWidth - outerWidth;
+                  var overflowL = htx - txHalfWidth;
+                  if (overflowR > 0) htx -= overflowR;
+                  if (overflowL < 0) htx += -overflowL;
+                }
+                d2.crossPos = htx;
+              }
+              tx.attr("text-anchor", d2.anchor);
+              if (tx2width) tx2.attr("text-anchor", d2.anchor);
+              g2.attr("transform", strTranslate(htx, hty) + (rotateLabels ? strRotate(YANGLE) : ""));
+            });
+            return {
+              hoverLabels,
+              commonLabelBoundingBox: commonLabelRect
+            };
+          }
+          function getHoverLabelText(d2, showCommonLabel, hovermode, fullLayout, t02, g2) {
+            var _a3, _b3;
+            var name2 = "";
+            var text = "";
+            if (d2.nameOverride !== void 0) d2.name = d2.nameOverride;
+            if (d2.name) {
+              if (d2.trace._meta) d2.name = Lib.templateString(d2.name, d2.trace._meta);
+              name2 = plainText(d2.name, d2.nameLength);
+            }
+            var h0 = hovermode.charAt(0);
+            var h1 = h0 === "x" ? "y" : "x";
+            if (d2.zLabel !== void 0) {
+              if (d2.xLabel !== void 0) text += "x: " + d2.xLabel + "<br>";
+              if (d2.yLabel !== void 0) text += "y: " + d2.yLabel + "<br>";
+              if (d2.trace.type !== "choropleth" && d2.trace.type !== "choroplethmapbox" && d2.trace.type !== "choroplethmap") {
+                text += (text ? "z: " : "") + d2.zLabel;
+              }
+            } else if (showCommonLabel && d2[h0 + "Label"] === t02) {
+              text = d2[h1 + "Label"] || "";
+            } else if (d2.xLabel === void 0) {
+              if (d2.yLabel !== void 0 && d2.trace.type !== "scattercarpet") {
+                text = d2.yLabel;
+              }
+            } else if (d2.yLabel === void 0) text = d2.xLabel;
+            else text = "(" + d2.xLabel + ", " + d2.yLabel + ")";
+            if ((d2.text || d2.text === 0) && !Array.isArray(d2.text)) {
+              text += (text ? "<br>" : "") + d2.text;
+            }
+            if (d2.extraText !== void 0) text += (text ? "<br>" : "") + d2.extraText;
+            if (g2 && text === "" && !d2.hovertemplate) {
+              if (name2 === "") g2.remove();
+              text = name2;
+            }
+            if ((_b3 = (_a3 = d2.trace) == null ? void 0 : _a3.hoverlabel) == null ? void 0 : _b3.split) d2.hovertemplate = "";
+            const { hovertemplate = false } = d2;
+            if (hovertemplate) {
+              const labels = d2.hovertemplateLabels || d2;
+              if (d2[h0 + "Label"] !== t02) {
+                labels[h0 + "other"] = labels[h0 + "Val"];
+                labels[h0 + "otherLabel"] = labels[h0 + "Label"];
+              }
+              text = Lib.hovertemplateString({
+                data: [d2.eventData[0] || {}, d2.trace._meta],
+                fallback: d2.trace.hovertemplatefallback,
+                labels,
+                locale: fullLayout._d3locale,
+                template: hovertemplate
+              });
+              text = text.replace(EXTRA_STRING_REGEX, (_2, extra) => {
+                name2 = plainText(extra, d2.nameLength);
+                return "";
+              });
+            }
+            return [text, name2];
+          }
+          function hoverAvoidOverlaps(hoverLabels, rotateLabels, fullLayout, commonLabelBoundingBox) {
+            var axKey = rotateLabels ? "xa" : "ya";
+            var crossAxKey = rotateLabels ? "ya" : "xa";
+            var nummoves = 0;
+            var axSign = 1;
+            var nLabels = hoverLabels.size();
+            var pointgroups = new Array(nLabels);
+            var k2 = 0;
+            var axisLabelMinX = commonLabelBoundingBox.minX;
+            var axisLabelMaxX = commonLabelBoundingBox.maxX;
+            var axisLabelMinY = commonLabelBoundingBox.minY;
+            var axisLabelMaxY = commonLabelBoundingBox.maxY;
+            var pX = function(x2) {
+              return x2 * fullLayout._invScaleX;
+            };
+            var pY = function(y2) {
+              return y2 * fullLayout._invScaleY;
+            };
+            hoverLabels.each(function(d2) {
+              var ax = d2[axKey];
+              var crossAx = d2[crossAxKey];
+              var axIsX = ax._id.charAt(0) === "x";
+              var rng = ax.range;
+              if (k2 === 0 && rng && rng[0] > rng[1] !== axIsX) {
+                axSign = -1;
+              }
+              var pmin = 0;
+              var pmax = axIsX ? fullLayout.width : fullLayout.height;
+              if (fullLayout.hovermode === "x" || fullLayout.hovermode === "y") {
+                var offsets = getHoverLabelOffsets(d2, rotateLabels);
+                var anchor = d2.anchor;
+                var horzSign = anchor === "end" ? -1 : 1;
+                var labelMin;
+                var labelMax;
+                if (anchor === "middle") {
+                  labelMin = d2.crossPos + (axIsX ? pY(offsets.y - d2.by / 2) : pX(d2.bx / 2 + d2.tx2width / 2));
+                  labelMax = labelMin + (axIsX ? pY(d2.by) : pX(d2.bx));
+                } else {
+                  if (axIsX) {
+                    labelMin = d2.crossPos + pY(HOVERARROWSIZE + offsets.y) - pY(d2.by / 2 - HOVERARROWSIZE);
+                    labelMax = labelMin + pY(d2.by);
+                  } else {
+                    var startX = pX(horzSign * HOVERARROWSIZE + offsets.x);
+                    var endX = startX + pX(horzSign * d2.bx);
+                    labelMin = d2.crossPos + Math.min(startX, endX);
+                    labelMax = d2.crossPos + Math.max(startX, endX);
+                  }
+                }
+                if (axIsX) {
+                  if (axisLabelMinY !== void 0 && axisLabelMaxY !== void 0 && Math.min(labelMax, axisLabelMaxY) - Math.max(labelMin, axisLabelMinY) > 1) {
+                    if (crossAx.side === "left") {
+                      pmin = crossAx._mainLinePosition;
+                      pmax = fullLayout.width;
+                    } else {
+                      pmax = crossAx._mainLinePosition;
+                    }
+                  }
+                } else {
+                  if (axisLabelMinX !== void 0 && axisLabelMaxX !== void 0 && Math.min(labelMax, axisLabelMaxX) - Math.max(labelMin, axisLabelMinX) > 1) {
+                    if (crossAx.side === "top") {
+                      pmin = crossAx._mainLinePosition;
+                      pmax = fullLayout.height;
+                    } else {
+                      pmax = crossAx._mainLinePosition;
+                    }
+                  }
+                }
+              }
+              pointgroups[k2++] = [
+                {
+                  datum: d2,
+                  traceIndex: d2.trace.index,
+                  dp: 0,
+                  pos: d2.pos,
+                  posref: d2.posref,
+                  size: d2.by * (axIsX ? YFACTOR : 1) / 2,
+                  pmin,
+                  pmax
+                }
+              ];
+            });
+            pointgroups.sort(function(a2, b2) {
+              return a2[0].posref - b2[0].posref || // for equal positions, sort trace indices increasing or decreasing
+              // depending on whether the axis is reversed or not... so stacked
+              // traces will generally keep their order even if one trace adds
+              // nothing to the stack.
+              axSign * (b2[0].traceIndex - a2[0].traceIndex);
+            });
+            var donepositioning, topOverlap, bottomOverlap, i2, j2, pti, sumdp;
+            function constrainGroup(grp2) {
+              var minPt = grp2[0];
+              var maxPt = grp2[grp2.length - 1];
+              topOverlap = minPt.pmin - minPt.pos - minPt.dp + minPt.size;
+              bottomOverlap = maxPt.pos + maxPt.dp + maxPt.size - minPt.pmax;
+              if (topOverlap > 0.01) {
+                for (j2 = grp2.length - 1; j2 >= 0; j2--) grp2[j2].dp += topOverlap;
+                donepositioning = false;
+              }
+              if (bottomOverlap < 0.01) return;
+              if (topOverlap < -0.01) {
+                for (j2 = grp2.length - 1; j2 >= 0; j2--) grp2[j2].dp -= bottomOverlap;
+                donepositioning = false;
+              }
+              if (!donepositioning) return;
+              var deleteCount = 0;
+              for (i2 = 0; i2 < grp2.length; i2++) {
+                pti = grp2[i2];
+                if (pti.pos + pti.dp + pti.size > minPt.pmax) deleteCount++;
+              }
+              for (i2 = grp2.length - 1; i2 >= 0; i2--) {
+                if (deleteCount <= 0) break;
+                pti = grp2[i2];
+                if (pti.pos > minPt.pmax - 1) {
+                  pti.del = true;
+                  deleteCount--;
+                }
+              }
+              for (i2 = 0; i2 < grp2.length; i2++) {
+                if (deleteCount <= 0) break;
+                pti = grp2[i2];
+                if (pti.pos < minPt.pmin + 1) {
+                  pti.del = true;
+                  deleteCount--;
+                  bottomOverlap = pti.size * 2;
+                  for (j2 = grp2.length - 1; j2 >= 0; j2--) grp2[j2].dp -= bottomOverlap;
+                }
+              }
+              for (i2 = grp2.length - 1; i2 >= 0; i2--) {
+                if (deleteCount <= 0) break;
+                pti = grp2[i2];
+                if (pti.pos + pti.dp + pti.size > minPt.pmax) {
+                  pti.del = true;
+                  deleteCount--;
+                }
+              }
+            }
+            while (!donepositioning && nummoves <= nLabels) {
+              nummoves++;
+              donepositioning = true;
+              i2 = 0;
+              while (i2 < pointgroups.length - 1) {
+                var g0 = pointgroups[i2];
+                var g1 = pointgroups[i2 + 1];
+                var p0 = g0[g0.length - 1];
+                var p1 = g1[0];
+                topOverlap = p0.pos + p0.dp + p0.size - p1.pos - p1.dp + p1.size;
+                if (topOverlap > 0.01) {
+                  for (j2 = g1.length - 1; j2 >= 0; j2--) g1[j2].dp += topOverlap;
+                  g0.push.apply(g0, g1);
+                  pointgroups.splice(i2 + 1, 1);
+                  sumdp = 0;
+                  for (j2 = g0.length - 1; j2 >= 0; j2--) sumdp += g0[j2].dp;
+                  bottomOverlap = sumdp / g0.length;
+                  for (j2 = g0.length - 1; j2 >= 0; j2--) g0[j2].dp -= bottomOverlap;
+                  donepositioning = false;
+                } else i2++;
+              }
+              pointgroups.forEach(constrainGroup);
+            }
+            for (i2 = pointgroups.length - 1; i2 >= 0; i2--) {
+              var grp = pointgroups[i2];
+              for (j2 = grp.length - 1; j2 >= 0; j2--) {
+                var pt2 = grp[j2];
+                var hoverPt = pt2.datum;
+                hoverPt.offset = pt2.dp;
+                hoverPt.del = pt2.del;
+              }
+            }
+          }
+          function getHoverLabelOffsets(hoverLabel, rotateLabels) {
+            var offsetX = 0;
+            var offsetY = hoverLabel.offset;
+            if (rotateLabels) {
+              offsetY *= -YSHIFTY;
+              offsetX = hoverLabel.offset * YSHIFTX;
+            }
+            return {
+              x: offsetX,
+              y: offsetY
+            };
+          }
+          function getTextShiftX(hoverLabel) {
+            var alignShift = { start: 1, end: -1, middle: 0 }[hoverLabel.anchor];
+            var textShiftX = alignShift * (HOVERARROWSIZE + HOVERTEXTPAD);
+            var text2ShiftX = textShiftX + alignShift * (hoverLabel.txwidth + HOVERTEXTPAD);
+            var isMiddle = hoverLabel.anchor === "middle";
+            if (isMiddle) {
+              textShiftX -= hoverLabel.tx2width / 2;
+              text2ShiftX += hoverLabel.txwidth / 2 + HOVERTEXTPAD;
+            }
+            return {
+              alignShift,
+              textShiftX,
+              text2ShiftX
+            };
+          }
+          function alignHoverText(hoverLabels, rotateLabels, scaleX2, scaleY2) {
+            var pX = function(x2) {
+              return x2 * scaleX2;
+            };
+            var pY = function(y2) {
+              return y2 * scaleY2;
+            };
+            hoverLabels.each(function(d2) {
+              var g2 = d3.select(this);
+              if (d2.del) return g2.remove();
+              var tx = g2.select("text.nums");
+              var anchor = d2.anchor;
+              var horzSign = anchor === "end" ? -1 : 1;
+              var shiftX = getTextShiftX(d2);
+              var offsets = getHoverLabelOffsets(d2, rotateLabels);
+              var offsetX = offsets.x;
+              var offsetY = offsets.y;
+              var isMiddle = anchor === "middle";
+              var showArrow = "hoverlabel" in d2.trace ? d2.trace.hoverlabel.showarrow : true;
+              var pathStr;
+              if (isMiddle) {
+                pathStr = "M-" + pX(d2.bx / 2 + d2.tx2width / 2) + "," + pY(offsetY - d2.by / 2) + "h" + pX(d2.bx) + "v" + pY(d2.by) + "h-" + pX(d2.bx) + "Z";
+              } else if (showArrow) {
+                pathStr = "M0,0L" + pX(horzSign * HOVERARROWSIZE + offsetX) + "," + pY(HOVERARROWSIZE + offsetY) + "v" + pY(d2.by / 2 - HOVERARROWSIZE) + "h" + pX(horzSign * d2.bx) + "v-" + pY(d2.by) + "H" + pX(horzSign * HOVERARROWSIZE + offsetX) + "V" + pY(offsetY - HOVERARROWSIZE) + "Z";
+              } else {
+                pathStr = "M" + pX(horzSign * HOVERARROWSIZE + offsetX) + "," + pY(offsetY - d2.by / 2) + "h" + pX(horzSign * d2.bx) + "v" + pY(d2.by) + "h" + pX(-horzSign * d2.bx) + "Z";
+              }
+              g2.select("path").attr("d", pathStr);
+              var posX = offsetX + shiftX.textShiftX;
+              var posY = offsetY + d2.ty0 - d2.by / 2 + HOVERTEXTPAD;
+              var textAlign = d2.textAlign || "auto";
+              if (textAlign !== "auto") {
+                if (textAlign === "left" && anchor !== "start") {
+                  tx.attr("text-anchor", "start");
+                  posX = isMiddle ? -d2.bx / 2 - d2.tx2width / 2 + HOVERTEXTPAD : -d2.bx - HOVERTEXTPAD;
+                } else if (textAlign === "right" && anchor !== "end") {
+                  tx.attr("text-anchor", "end");
+                  posX = isMiddle ? d2.bx / 2 - d2.tx2width / 2 - HOVERTEXTPAD : d2.bx + HOVERTEXTPAD;
+                }
+              }
+              tx.call(svgTextUtils.positionText, pX(posX), pY(posY));
+              if (d2.tx2width) {
+                g2.select("text.name").call(
+                  svgTextUtils.positionText,
+                  pX(shiftX.text2ShiftX + shiftX.alignShift * HOVERTEXTPAD + offsetX),
+                  pY(offsetY + d2.ty0 - d2.by / 2 + HOVERTEXTPAD)
+                );
+                g2.select("rect").call(
+                  Drawing.setRect,
+                  pX(shiftX.text2ShiftX + (shiftX.alignShift - 1) * d2.tx2width / 2 + offsetX),
+                  pY(offsetY - d2.by / 2 - 1),
+                  pX(d2.tx2width),
+                  pY(d2.by + 2)
+                );
+              }
+            });
+          }
+          function cleanPoint(d2, hovermode) {
+            var index = d2.index;
+            var trace = d2.trace || {};
+            var cd0 = d2.cd[0];
+            var cd2 = d2.cd[index] || {};
+            function pass(v2) {
+              return v2 || isNumeric(v2) && v2 === 0;
+            }
+            var getVal = Array.isArray(index) ? function(calcKey, traceKey) {
+              var v2 = Lib.castOption(cd0, index, calcKey);
+              return pass(v2) ? v2 : Lib.extractOption({}, trace, "", traceKey);
+            } : function(calcKey, traceKey) {
+              return Lib.extractOption(cd2, trace, calcKey, traceKey);
+            };
+            function fill(key, calcKey, traceKey) {
+              var val = getVal(calcKey, traceKey);
+              if (pass(val)) d2[key] = val;
+            }
+            fill("hoverinfo", "hi", "hoverinfo");
+            fill("bgcolor", "hbg", "hoverlabel.bgcolor");
+            fill("borderColor", "hbc", "hoverlabel.bordercolor");
+            fill("fontFamily", "htf", "hoverlabel.font.family");
+            fill("fontSize", "hts", "hoverlabel.font.size");
+            fill("fontColor", "htc", "hoverlabel.font.color");
+            fill("fontWeight", "htw", "hoverlabel.font.weight");
+            fill("fontStyle", "hty", "hoverlabel.font.style");
+            fill("fontVariant", "htv", "hoverlabel.font.variant");
+            fill("nameLength", "hnl", "hoverlabel.namelength");
+            fill("textAlign", "hta", "hoverlabel.align");
+            d2.posref = hovermode === "y" || hovermode === "closest" && trace.orientation === "h" ? d2.xa._offset + (d2.x0 + d2.x1) / 2 : d2.ya._offset + (d2.y0 + d2.y1) / 2;
+            d2.x0 = Lib.constrain(d2.x0, 0, d2.xa._length);
+            d2.x1 = Lib.constrain(d2.x1, 0, d2.xa._length);
+            d2.y0 = Lib.constrain(d2.y0, 0, d2.ya._length);
+            d2.y1 = Lib.constrain(d2.y1, 0, d2.ya._length);
+            if (d2.xLabelVal !== void 0) {
+              d2.xLabel = "xLabel" in d2 ? d2.xLabel : Axes.hoverLabelText(d2.xa, d2.xLabelVal, trace.xhoverformat);
+              d2.xVal = d2.xa.c2d(d2.xLabelVal);
+            }
+            if (d2.yLabelVal !== void 0) {
+              d2.yLabel = "yLabel" in d2 ? d2.yLabel : Axes.hoverLabelText(d2.ya, d2.yLabelVal, trace.yhoverformat);
+              d2.yVal = d2.ya.c2d(d2.yLabelVal);
+            }
+            if (d2.zLabelVal !== void 0 && d2.zLabel === void 0) {
+              d2.zLabel = String(d2.zLabelVal);
+            }
+            if (!isNaN(d2.xerr) && !(d2.xa.type === "log" && d2.xerr <= 0)) {
+              var xeText = Axes.tickText(d2.xa, d2.xa.c2l(d2.xerr), "hover").text;
+              if (d2.xerrneg !== void 0) {
+                d2.xLabel += " +" + xeText + " / -" + Axes.tickText(d2.xa, d2.xa.c2l(d2.xerrneg), "hover").text;
+              } else d2.xLabel += " ± " + xeText;
+              if (hovermode === "x") d2.distance += 1;
+            }
+            if (!isNaN(d2.yerr) && !(d2.ya.type === "log" && d2.yerr <= 0)) {
+              var yeText = Axes.tickText(d2.ya, d2.ya.c2l(d2.yerr), "hover").text;
+              if (d2.yerrneg !== void 0) {
+                d2.yLabel += " +" + yeText + " / -" + Axes.tickText(d2.ya, d2.ya.c2l(d2.yerrneg), "hover").text;
+              } else d2.yLabel += " ± " + yeText;
+              if (hovermode === "y") d2.distance += 1;
+            }
+            var infomode = d2.hoverinfo || d2.trace.hoverinfo;
+            if (infomode && infomode !== "all") {
+              infomode = Array.isArray(infomode) ? infomode : infomode.split("+");
+              if (infomode.indexOf("x") === -1) d2.xLabel = void 0;
+              if (infomode.indexOf("y") === -1) d2.yLabel = void 0;
+              if (infomode.indexOf("z") === -1) d2.zLabel = void 0;
+              if (infomode.indexOf("text") === -1) d2.text = void 0;
+              if (infomode.indexOf("name") === -1) d2.name = void 0;
+            }
+            return d2;
+          }
+          function createSpikelines(gd2, closestPoints, opts) {
+            var container = opts.container;
+            var fullLayout = opts.fullLayout;
+            var gs = fullLayout._size;
+            var evt = opts.event;
+            var showY = !!closestPoints.hLinePoint;
+            var showX = !!closestPoints.vLinePoint;
+            var xa, ya2;
+            container.selectAll(".spikeline").remove();
+            if (!(showX || showY)) return;
+            var contrastColor = Color2.combine(fullLayout.plot_bgcolor, fullLayout.paper_bgcolor);
+            if (showY) {
+              var hLinePoint = closestPoints.hLinePoint;
+              var hLinePointX, hLinePointY;
+              xa = hLinePoint && hLinePoint.xa;
+              ya2 = hLinePoint && hLinePoint.ya;
+              var ySnap = ya2.spikesnap;
+              if (ySnap === "cursor") {
+                hLinePointX = evt.pointerX;
+                hLinePointY = evt.pointerY;
+              } else {
+                hLinePointX = xa._offset + hLinePoint.x;
+                hLinePointY = ya2._offset + hLinePoint.y;
+              }
+              var dfltHLineColor = tinycolor.readability(hLinePoint.color, contrastColor) < 1.5 ? Color2.contrast(contrastColor) : hLinePoint.color;
+              var yMode = ya2.spikemode;
+              var yThickness = ya2.spikethickness;
+              var yColor = ya2.spikecolor || dfltHLineColor;
+              var xEdge = Axes.getPxPosition(gd2, ya2);
+              var xBase, xEndSpike;
+              if (yMode.indexOf("toaxis") !== -1 || yMode.indexOf("across") !== -1) {
+                if (yMode.indexOf("toaxis") !== -1) {
+                  xBase = xEdge;
+                  xEndSpike = hLinePointX;
+                }
+                if (yMode.indexOf("across") !== -1) {
+                  var xAcross0 = ya2._counterDomainMin;
+                  var xAcross1 = ya2._counterDomainMax;
+                  if (ya2.anchor === "free") {
+                    xAcross0 = Math.min(xAcross0, ya2.position);
+                    xAcross1 = Math.max(xAcross1, ya2.position);
+                  }
+                  xBase = gs.l + xAcross0 * gs.w;
+                  xEndSpike = gs.l + xAcross1 * gs.w;
+                }
+                container.insert("line", ":first-child").attr({
+                  x1: xBase,
+                  x2: xEndSpike,
+                  y1: hLinePointY,
+                  y2: hLinePointY,
+                  "stroke-width": yThickness,
+                  stroke: yColor,
+                  "stroke-dasharray": Drawing.dashStyle(ya2.spikedash, yThickness)
+                }).classed("spikeline", true).classed("crisp", true);
+                container.insert("line", ":first-child").attr({
+                  x1: xBase,
+                  x2: xEndSpike,
+                  y1: hLinePointY,
+                  y2: hLinePointY,
+                  "stroke-width": yThickness + 2,
+                  stroke: contrastColor
+                }).classed("spikeline", true).classed("crisp", true);
+              }
+              if (yMode.indexOf("marker") !== -1) {
+                container.insert("circle", ":first-child").attr({
+                  cx: xEdge + (ya2.side !== "right" ? yThickness : -yThickness),
+                  cy: hLinePointY,
+                  r: yThickness,
+                  fill: yColor
+                }).classed("spikeline", true);
+              }
+            }
+            if (showX) {
+              var vLinePoint = closestPoints.vLinePoint;
+              var vLinePointX, vLinePointY;
+              xa = vLinePoint && vLinePoint.xa;
+              ya2 = vLinePoint && vLinePoint.ya;
+              var xSnap = xa.spikesnap;
+              if (xSnap === "cursor") {
+                vLinePointX = evt.pointerX;
+                vLinePointY = evt.pointerY;
+              } else {
+                vLinePointX = xa._offset + vLinePoint.x;
+                vLinePointY = ya2._offset + vLinePoint.y;
+              }
+              var dfltVLineColor = tinycolor.readability(vLinePoint.color, contrastColor) < 1.5 ? Color2.contrast(contrastColor) : vLinePoint.color;
+              var xMode = xa.spikemode;
+              var xThickness = xa.spikethickness;
+              var xColor = xa.spikecolor || dfltVLineColor;
+              var yEdge = Axes.getPxPosition(gd2, xa);
+              var yBase, yEndSpike;
+              if (xMode.indexOf("toaxis") !== -1 || xMode.indexOf("across") !== -1) {
+                if (xMode.indexOf("toaxis") !== -1) {
+                  yBase = yEdge;
+                  yEndSpike = vLinePointY;
+                }
+                if (xMode.indexOf("across") !== -1) {
+                  var yAcross0 = xa._counterDomainMin;
+                  var yAcross1 = xa._counterDomainMax;
+                  if (xa.anchor === "free") {
+                    yAcross0 = Math.min(yAcross0, xa.position);
+                    yAcross1 = Math.max(yAcross1, xa.position);
+                  }
+                  yBase = gs.t + (1 - yAcross1) * gs.h;
+                  yEndSpike = gs.t + (1 - yAcross0) * gs.h;
+                }
+                container.insert("line", ":first-child").attr({
+                  x1: vLinePointX,
+                  x2: vLinePointX,
+                  y1: yBase,
+                  y2: yEndSpike,
+                  "stroke-width": xThickness,
+                  stroke: xColor,
+                  "stroke-dasharray": Drawing.dashStyle(xa.spikedash, xThickness)
+                }).classed("spikeline", true).classed("crisp", true);
+                container.insert("line", ":first-child").attr({
+                  x1: vLinePointX,
+                  x2: vLinePointX,
+                  y1: yBase,
+                  y2: yEndSpike,
+                  "stroke-width": xThickness + 2,
+                  stroke: contrastColor
+                }).classed("spikeline", true).classed("crisp", true);
+              }
+              if (xMode.indexOf("marker") !== -1) {
+                container.insert("circle", ":first-child").attr({
+                  cx: vLinePointX,
+                  cy: yEdge - (xa.side !== "top" ? xThickness : -xThickness),
+                  r: xThickness,
+                  fill: xColor
+                }).classed("spikeline", true);
+              }
+            }
+          }
+          function hoverChanged(gd2, evt, oldhoverdata) {
+            if (!oldhoverdata || oldhoverdata.length !== gd2._hoverdata.length) return true;
+            for (var i2 = oldhoverdata.length - 1; i2 >= 0; i2--) {
+              var oldPt = oldhoverdata[i2];
+              var newPt = gd2._hoverdata[i2];
+              if (oldPt.curveNumber !== newPt.curveNumber || String(oldPt.pointNumber) !== String(newPt.pointNumber) || String(oldPt.pointNumbers) !== String(newPt.pointNumbers) || oldPt.binNumber !== newPt.binNumber) {
+                return true;
+              }
+            }
+            return false;
+          }
+          function spikesChanged(gd2, oldspikepoints) {
+            return true;
+          }
+          function plainText(s2, len2) {
+            return svgTextUtils.plainText(s2 || "", {
+              len: len2,
+              allowedTags: ["br", "sub", "sup", "b", "i", "em", "s", "u"]
+            });
+          }
+          function orderRangePoints(hoverData, hovermode) {
+            var axLetter = hovermode.charAt(0);
+            var first = [];
+            var second = [];
+            var last = [];
+            for (var i2 = 0; i2 < hoverData.length; i2++) {
+              var d2 = hoverData[i2];
+              if (Registry.traceIs(d2.trace, "bar-like") || Registry.traceIs(d2.trace, "box-violin")) {
+                last.push(d2);
+              } else if (d2.trace[axLetter + "period"]) {
+                second.push(d2);
+              } else {
+                first.push(d2);
+              }
+            }
+            return first.concat(second).concat(last);
+          }
+          function getCoord(axLetter, winningPoint, fullLayout) {
+            var ax = winningPoint[axLetter + "a"];
+            var val = winningPoint[axLetter + "Val"];
+            var cd0 = winningPoint.cd[0];
+            if (ax.type === "category" || ax.type === "multicategory") val = ax._categoriesMap[val];
+            else if (ax.type === "date") {
+              var periodalignment = winningPoint.trace[axLetter + "periodalignment"];
+              if (periodalignment) {
+                var d2 = winningPoint.cd[winningPoint.index];
+                var start = d2[axLetter + "Start"];
+                if (start === void 0) start = d2[axLetter];
+                var end = d2[axLetter + "End"];
+                if (end === void 0) end = d2[axLetter];
+                var diff = end - start;
+                if (periodalignment === "end") {
+                  val += diff;
+                } else if (periodalignment === "middle") {
+                  val += diff / 2;
+                }
+              }
+              val = ax.d2c(val);
+            }
+            if (cd0 && cd0.t && cd0.t.posLetter === ax._id) {
+              if (fullLayout.boxmode === "group" || fullLayout.violinmode === "group") {
+                val += cd0.t.dPos;
+              }
+            }
+            return val;
+          }
+          var getTopOffset = (gd2) => gd2.offsetTop + gd2.clientTop;
+          var getLeftOffset = (gd2) => gd2.offsetLeft + gd2.clientLeft;
+          function getBoundingClientRect(gd2, node) {
+            var fullLayout = gd2._fullLayout;
+            var rect = node.getBoundingClientRect();
+            var x0 = rect.left;
+            var y0 = rect.top;
+            var x1 = x0 + rect.width;
+            var y1 = y0 + rect.height;
+            var A22 = Lib.apply3DTransform(fullLayout._invTransform)(x0, y0);
+            var B22 = Lib.apply3DTransform(fullLayout._invTransform)(x1, y1);
+            var Ax = A22[0];
+            var Ay = A22[1];
+            var Bx = B22[0];
+            var By = B22[1];
+            return {
+              x: Ax,
+              y: Ay,
+              width: Bx - Ax,
+              height: By - Ay,
+              top: Math.min(Ay, By),
+              left: Math.min(Ax, Bx),
+              right: Math.max(Ax, Bx),
+              bottom: Math.max(Ay, By)
+            };
+          }
+        }
+      });
+      var require_hoverlabel_defaults = __commonJS({
+        "src/components/fx/hoverlabel_defaults.js"(exports, module2) {
+          var Lib = require_lib();
+          var Color2 = require_color();
+          var isUnifiedHover = require_helpers2().isUnifiedHover;
+          module2.exports = function handleHoverLabelDefaults(contIn, contOut, coerce, opts) {
+            opts = opts || {};
+            var hasLegend = contOut.legend;
+            function inheritFontAttr(attr) {
+              if (!opts.font[attr]) {
+                opts.font[attr] = hasLegend ? contOut.legend.font[attr] : contOut.font[attr];
+              }
+            }
+            if (contOut && isUnifiedHover(contOut.hovermode)) {
+              if (!opts.font) opts.font = {};
+              inheritFontAttr("size");
+              inheritFontAttr("family");
+              inheritFontAttr("color");
+              inheritFontAttr("weight");
+              inheritFontAttr("style");
+              inheritFontAttr("variant");
+              if (hasLegend) {
+                if (!opts.bgcolor) opts.bgcolor = Color2.combine(contOut.legend.bgcolor, contOut.paper_bgcolor);
+                if (!opts.bordercolor) opts.bordercolor = contOut.legend.bordercolor;
+              } else {
+                if (!opts.bgcolor) opts.bgcolor = contOut.paper_bgcolor;
+              }
+            }
+            coerce("hoverlabel.bgcolor", opts.bgcolor);
+            coerce("hoverlabel.bordercolor", opts.bordercolor);
+            coerce("hoverlabel.namelength", opts.namelength);
+            coerce("hoverlabel.showarrow", opts.showarrow);
+            Lib.coerceFont(coerce, "hoverlabel.font", opts.font);
+            coerce("hoverlabel.align", opts.align);
+          };
+        }
+      });
+      var require_layout_global_defaults = __commonJS({
+        "src/components/fx/layout_global_defaults.js"(exports, module2) {
+          var Lib = require_lib();
+          var handleHoverLabelDefaults = require_hoverlabel_defaults();
+          var layoutAttributes = require_layout_attributes();
+          module2.exports = function supplyLayoutGlobalDefaults(layoutIn, layoutOut) {
+            function coerce(attr, dflt) {
+              return Lib.coerce(layoutIn, layoutOut, layoutAttributes, attr, dflt);
+            }
+            handleHoverLabelDefaults(layoutIn, layoutOut, coerce);
+          };
+        }
+      });
+      var require_defaults4 = __commonJS({
+        "src/components/fx/defaults.js"(exports, module2) {
+          var Lib = require_lib();
+          var attributes = require_attributes();
+          var handleHoverLabelDefaults = require_hoverlabel_defaults();
+          module2.exports = function supplyDefaults(traceIn, traceOut, defaultColor, layout) {
+            function coerce(attr, dflt) {
+              return Lib.coerce(traceIn, traceOut, attributes, attr, dflt);
+            }
+            var opts = Lib.extendFlat({}, layout.hoverlabel);
+            if (traceOut.hovertemplate) opts.namelength = -1;
+            handleHoverLabelDefaults(traceIn, traceOut, coerce, opts);
+          };
+        }
+      });
+      var require_hovermode_defaults = __commonJS({
+        "src/components/fx/hovermode_defaults.js"(exports, module2) {
+          var Lib = require_lib();
+          var layoutAttributes = require_layout_attributes();
+          module2.exports = function handleHoverModeDefaults(layoutIn, layoutOut) {
+            function coerce(attr, dflt) {
+              if (layoutOut[attr] !== void 0) return layoutOut[attr];
+              return Lib.coerce(layoutIn, layoutOut, layoutAttributes, attr, dflt);
+            }
+            coerce("clickmode");
+            coerce("hoversubplots");
+            return coerce("hovermode");
+          };
+        }
+      });
+      var require_layout_defaults2 = __commonJS({
+        "src/components/fx/layout_defaults.js"(exports, module2) {
+          var Lib = require_lib();
+          var layoutAttributes = require_layout_attributes();
+          var handleHoverModeDefaults = require_hovermode_defaults();
+          var handleHoverLabelDefaults = require_hoverlabel_defaults();
+          module2.exports = function supplyLayoutDefaults(layoutIn, layoutOut) {
+            function coerce(attr, dflt) {
+              return Lib.coerce(layoutIn, layoutOut, layoutAttributes, attr, dflt);
+            }
+            var hoverMode = handleHoverModeDefaults(layoutIn, layoutOut);
+            if (hoverMode) {
+              coerce("hoverdistance");
+              coerce("spikedistance");
+            }
+            var dragMode = coerce("dragmode");
+            if (dragMode === "select") coerce("selectdirection");
+            var hasMapbox = layoutOut._has("mapbox");
+            var hasMap = layoutOut._has("map");
+            var hasGeo = layoutOut._has("geo");
+            var len2 = layoutOut._basePlotModules.length;
+            if (layoutOut.dragmode === "zoom" && ((hasMapbox || hasMap || hasGeo) && len2 === 1 || (hasMapbox || hasMap) && hasGeo && len2 === 2)) {
+              layoutOut.dragmode = "pan";
+            }
+            handleHoverLabelDefaults(layoutIn, layoutOut, coerce);
+            Lib.coerceFont(coerce, "hoverlabel.grouptitlefont", layoutOut.hoverlabel.font);
+          };
+        }
+      });
+      var require_calc2 = __commonJS({
+        "src/components/fx/calc.js"(exports, module2) {
+          var Lib = require_lib();
+          var Registry = require_registry();
+          module2.exports = function calc(gd2) {
+            var calcdata = gd2.calcdata;
+            var fullLayout = gd2._fullLayout;
+            function makeCoerceHoverInfo(trace2) {
+              return function(val) {
+                return Lib.coerceHoverinfo({ hoverinfo: val }, { _module: trace2._module }, fullLayout);
+              };
+            }
+            for (var i2 = 0; i2 < calcdata.length; i2++) {
+              var cd2 = calcdata[i2];
+              var trace = cd2[0].trace;
+              if (Registry.traceIs(trace, "pie-like")) continue;
+              var fillFn = Registry.traceIs(trace, "2dMap") ? paste : Lib.fillArray;
+              fillFn(trace.hoverinfo, cd2, "hi", makeCoerceHoverInfo(trace));
+              if (trace.hovertemplate) fillFn(trace.hovertemplate, cd2, "ht");
+              if (!trace.hoverlabel) continue;
+              fillFn(trace.hoverlabel.bgcolor, cd2, "hbg");
+              fillFn(trace.hoverlabel.bordercolor, cd2, "hbc");
+              fillFn(trace.hoverlabel.font.size, cd2, "hts");
+              fillFn(trace.hoverlabel.font.color, cd2, "htc");
+              fillFn(trace.hoverlabel.font.family, cd2, "htf");
+              fillFn(trace.hoverlabel.font.weight, cd2, "htw");
+              fillFn(trace.hoverlabel.font.style, cd2, "hty");
+              fillFn(trace.hoverlabel.font.variant, cd2, "htv");
+              fillFn(trace.hoverlabel.namelength, cd2, "hnl");
+              fillFn(trace.hoverlabel.align, cd2, "hta");
+              fillFn(trace.hoverlabel.showarrow, cd2, "htsa");
+            }
+          };
+          function paste(traceAttr, cd2, cdAttr, fn) {
+            fn = fn || Lib.identity;
+            if (Array.isArray(traceAttr)) {
+              cd2[0][cdAttr] = fn(traceAttr);
+            }
+          }
+        }
+      });
+      var require_click = __commonJS({
+        "src/components/fx/click.js"(exports, module2) {
+          var Registry = require_registry();
+          var hover = require_hover().hover;
+          module2.exports = function click(gd2, evt, subplot) {
+            var annotationsDone = Registry.getComponentMethod("annotations", "onClick")(gd2, gd2._hoverdata);
+            if (subplot !== void 0) {
+              hover(gd2, evt, subplot, true);
+            }
+            function emitClick() {
+              gd2.emit("plotly_click", { points: gd2._hoverdata, event: evt });
+            }
+            if (gd2._hoverdata && evt && evt.target) {
+              if (annotationsDone && annotationsDone.then) {
+                annotationsDone.then(emitClick);
+              } else emitClick();
+              if (evt.stopImmediatePropagation) evt.stopImmediatePropagation();
+            }
+          };
+        }
+      });
+      var require_fx = __commonJS({
+        "src/components/fx/index.js"(exports, module2) {
+          var d3 = require_d3();
+          var Lib = require_lib();
+          var dragElement = require_dragelement();
+          var helpers = require_helpers2();
+          var layoutAttributes = require_layout_attributes();
+          var hoverModule = require_hover();
+          module2.exports = {
+            moduleType: "component",
+            name: "fx",
+            constants: require_constants(),
+            schema: {
+              layout: layoutAttributes
+            },
+            attributes: require_attributes(),
+            layoutAttributes,
+            supplyLayoutGlobalDefaults: require_layout_global_defaults(),
+            supplyDefaults: require_defaults4(),
+            supplyLayoutDefaults: require_layout_defaults2(),
+            calc: require_calc2(),
+            getDistanceFunction: helpers.getDistanceFunction,
+            getClosest: helpers.getClosest,
+            inbox: helpers.inbox,
+            quadrature: helpers.quadrature,
+            appendArrayPointValue: helpers.appendArrayPointValue,
+            castHoverOption,
+            castHoverinfo,
+            hover: hoverModule.hover,
+            unhover: dragElement.unhover,
+            loneHover: hoverModule.loneHover,
+            loneUnhover,
+            click: require_click()
+          };
+          function loneUnhover(containerOrSelection) {
+            var selection = Lib.isD3Selection(containerOrSelection) ? containerOrSelection : d3.select(containerOrSelection);
+            selection.selectAll("g.hovertext").remove();
+            selection.selectAll(".spikeline").remove();
+          }
+          function castHoverOption(trace, ptNumber, attr) {
+            return Lib.castOption(trace, ptNumber, "hoverlabel." + attr);
+          }
+          function castHoverinfo(trace, fullLayout, ptNumber) {
+            function _coerce(val) {
+              return Lib.coerceHoverinfo({ hoverinfo: val }, { _module: trace._module }, fullLayout);
+            }
+            return Lib.castOption(trace, ptNumber, "hoverinfo", _coerce);
+          }
+        }
+      });
+      var require_helpers5 = __commonJS({
+        "src/components/dragelement/helpers.js"(exports) {
+          exports.selectMode = function(dragmode) {
+            return dragmode === "lasso" || dragmode === "select";
+          };
+          exports.drawMode = function(dragmode) {
+            return dragmode === "drawclosedpath" || dragmode === "drawopenpath" || dragmode === "drawline" || dragmode === "drawrect" || dragmode === "drawcircle";
+          };
+          exports.openMode = function(dragmode) {
+            return dragmode === "drawline" || dragmode === "drawopenpath";
+          };
+          exports.rectMode = function(dragmode) {
+            return dragmode === "select" || dragmode === "drawline" || dragmode === "drawrect" || dragmode === "drawcircle";
+          };
+          exports.freeMode = function(dragmode) {
+            return dragmode === "lasso" || dragmode === "drawclosedpath" || dragmode === "drawopenpath";
+          };
+          exports.selectingOrDrawing = function(dragmode) {
+            return exports.freeMode(dragmode) || exports.rectMode(dragmode);
+          };
+        }
+      });
+      var require_clear_gl_canvases = __commonJS({
+        "src/lib/clear_gl_canvases.js"(exports, module2) {
+          module2.exports = function clearGlCanvases(gd2) {
+            var fullLayout = gd2._fullLayout;
+            if (fullLayout._glcanvas && fullLayout._glcanvas.size()) {
+              fullLayout._glcanvas.each(function(d2) {
+                if (d2.regl) d2.regl.clear({ color: true, depth: true });
+              });
+            }
+          };
+        }
+      });
+      var require_ploticon = __commonJS({
+        "src/fonts/ploticon.js"(exports, module2) {
+          module2.exports = {
+            undo: {
+              width: 857.1,
+              height: 1e3,
+              path: "m857 350q0-87-34-166t-91-137-137-92-166-34q-96 0-183 41t-147 114q-4 6-4 13t5 11l76 77q6 5 14 5 9-1 13-7 41-53 100-82t126-29q58 0 110 23t92 61 61 91 22 111-22 111-61 91-92 61-110 23q-55 0-105-20t-90-57l77-77q17-16 8-38-10-23-33-23h-250q-15 0-25 11t-11 25v250q0 24 22 33 22 10 39-8l72-72q60 57 137 88t159 31q87 0 166-34t137-92 91-137 34-166z",
+              transform: "matrix(1 0 0 -1 0 850)"
+            },
+            home: {
+              width: 928.6,
+              height: 1e3,
+              path: "m786 296v-267q0-15-11-26t-25-10h-214v214h-143v-214h-214q-15 0-25 10t-11 26v267q0 1 0 2t0 2l321 264 321-264q1-1 1-4z m124 39l-34-41q-5-5-12-6h-2q-7 0-12 3l-386 322-386-322q-7-4-13-4-7 2-12 7l-35 41q-4 5-3 13t6 12l401 334q18 15 42 15t43-15l136-114v109q0 8 5 13t13 5h107q8 0 13-5t5-13v-227l122-102q5-5 6-12t-4-13z",
+              transform: "matrix(1 0 0 -1 0 850)"
+            },
+            "camera-retro": {
+              width: 1e3,
+              height: 1e3,
+              path: "m518 386q0 8-5 13t-13 5q-37 0-63-27t-26-63q0-8 5-13t13-5 12 5 5 13q0 23 16 38t38 16q8 0 13 5t5 13z m125-73q0-59-42-101t-101-42-101 42-42 101 42 101 101 42 101-42 42-101z m-572-320h858v71h-858v-71z m643 320q0 89-62 152t-152 62-151-62-63-152 63-151 151-63 152 63 62 151z m-571 358h214v72h-214v-72z m-72-107h858v143h-462l-36-71h-360v-72z m929 143v-714q0-30-21-51t-50-21h-858q-29 0-50 21t-21 51v714q0 30 21 51t50 21h858q29 0 50-21t21-51z",
+              transform: "matrix(1 0 0 -1 0 850)"
+            },
+            zoombox: {
+              width: 1e3,
+              height: 1e3,
+              path: "m1000-25l-250 251c40 63 63 138 63 218 0 224-182 406-407 406-224 0-406-182-406-406s183-406 407-406c80 0 155 22 218 62l250-250 125 125z m-812 250l0 438 437 0 0-438-437 0z m62 375l313 0 0-312-313 0 0 312z",
+              transform: "matrix(1 0 0 -1 0 850)"
+            },
+            pan: {
+              width: 1e3,
+              height: 1e3,
+              path: "m1000 350l-187 188 0-125-250 0 0 250 125 0-188 187-187-187 125 0 0-250-250 0 0 125-188-188 186-187 0 125 252 0 0-250-125 0 187-188 188 188-125 0 0 250 250 0 0-126 187 188z",
+              transform: "matrix(1 0 0 -1 0 850)"
+            },
+            zoom_plus: {
+              width: 875,
+              height: 1e3,
+              path: "m1 787l0-875 875 0 0 875-875 0z m687-500l-187 0 0-187-125 0 0 187-188 0 0 125 188 0 0 187 125 0 0-187 187 0 0-125z",
+              transform: "matrix(1 0 0 -1 0 850)"
+            },
+            zoom_minus: {
+              width: 875,
+              height: 1e3,
+              path: "m0 788l0-876 875 0 0 876-875 0z m688-500l-500 0 0 125 500 0 0-125z",
+              transform: "matrix(1 0 0 -1 0 850)"
+            },
+            autoscale: {
+              width: 1e3,
+              height: 1e3,
+              path: "m250 850l-187 0-63 0 0-62 0-188 63 0 0 188 187 0 0 62z m688 0l-188 0 0-62 188 0 0-188 62 0 0 188 0 62-62 0z m-875-938l0 188-63 0 0-188 0-62 63 0 187 0 0 62-187 0z m875 188l0-188-188 0 0-62 188 0 62 0 0 62 0 188-62 0z m-125 188l-1 0-93-94-156 156 156 156 92-93 2 0 0 250-250 0 0-2 93-92-156-156-156 156 94 92 0 2-250 0 0-250 0 0 93 93 157-156-157-156-93 94 0 0 0-250 250 0 0 0-94 93 156 157 156-157-93-93 0 0 250 0 0 250z",
+              transform: "matrix(1 0 0 -1 0 850)"
+            },
+            tooltip_basic: {
+              width: 1500,
+              height: 1e3,
+              path: "m375 725l0 0-375-375 375-374 0-1 1125 0 0 750-1125 0z",
+              transform: "matrix(1 0 0 -1 0 850)"
+            },
+            tooltip_compare: {
+              width: 1125,
+              height: 1e3,
+              path: "m187 786l0 2-187-188 188-187 0 0 937 0 0 373-938 0z m0-499l0 1-187-188 188-188 0 0 937 0 0 376-938-1z",
+              transform: "matrix(1 0 0 -1 0 850)"
+            },
+            plotlylogo: {
+              width: 1542,
+              height: 1e3,
+              path: "m0-10h182v-140h-182v140z m228 146h183v-286h-183v286z m225 714h182v-1000h-182v1000z m225-285h182v-715h-182v715z m225 142h183v-857h-183v857z m231-428h182v-429h-182v429z m225-291h183v-138h-183v138z",
+              transform: "matrix(1 0 0 -1 0 850)"
+            },
+            "z-axis": {
+              width: 1e3,
+              height: 1e3,
+              path: "m833 5l-17 108v41l-130-65 130-66c0 0 0 38 0 39 0-1 36-14 39-25 4-15-6-22-16-30-15-12-39-16-56-20-90-22-187-23-279-23-261 0-341 34-353 59 3 60 228 110 228 110-140-8-351-35-351-116 0-120 293-142 474-142 155 0 477 22 477 142 0 50-74 79-163 96z m-374 94c-58-5-99-21-99-40 0-24 65-43 144-43 79 0 143 19 143 43 0 19-42 34-98 40v216h87l-132 135-133-135h88v-216z m167 515h-136v1c16 16 31 34 46 52l84 109v54h-230v-71h124v-1c-16-17-28-32-44-51l-89-114v-51h245v72z",
+              transform: "matrix(1 0 0 -1 0 850)"
+            },
+            "3d_rotate": {
+              width: 1e3,
+              height: 1e3,
+              path: "m922 660c-5 4-9 7-14 11-359 263-580-31-580-31l-102 28 58-400c0 1 1 1 2 2 118 108 351 249 351 249s-62 27-100 42c88 83 222 183 347 122 16-8 30-17 44-27-2 1-4 2-6 4z m36-329c0 0 64 229-88 296-62 27-124 14-175-11 157-78 225-208 249-266 8-19 11-31 11-31 2 5 6 15 11 32-5-13-8-20-8-20z m-775-239c70-31 117-50 198-32-121 80-199 346-199 346l-96-15-58-12c0 0 55-226 155-287z m603 133l-317-139c0 0 4-4 19-14 7-5 24-15 24-15s-177-147-389 4c235-287 536-112 536-112l31-22 100 299-4-1z m-298-153c6-4 14-9 24-15 0 0-17 10-24 15z",
+              transform: "matrix(1 0 0 -1 0 850)"
+            },
+            camera: {
+              width: 1e3,
+              height: 1e3,
+              path: "m500 450c-83 0-150-67-150-150 0-83 67-150 150-150 83 0 150 67 150 150 0 83-67 150-150 150z m400 150h-120c-16 0-34 13-39 29l-31 93c-6 15-23 28-40 28h-340c-16 0-34-13-39-28l-31-94c-6-15-23-28-40-28h-120c-55 0-100-45-100-100v-450c0-55 45-100 100-100h800c55 0 100 45 100 100v450c0 55-45 100-100 100z m-400-550c-138 0-250 112-250 250 0 138 112 250 250 250 138 0 250-112 250-250 0-138-112-250-250-250z m365 380c-19 0-35 16-35 35 0 19 16 35 35 35 19 0 35-16 35-35 0-19-16-35-35-35z",
+              transform: "matrix(1 0 0 -1 0 850)"
+            },
+            movie: {
+              width: 1e3,
+              height: 1e3,
+              path: "m938 413l-188-125c0 37-17 71-44 94 64 38 107 107 107 187 0 121-98 219-219 219-121 0-219-98-219-219 0-61 25-117 66-156h-115c30 33 49 76 49 125 0 103-84 187-187 187s-188-84-188-187c0-57 26-107 65-141-38-22-65-62-65-109v-250c0-70 56-126 125-126h500c69 0 125 56 125 126l188-126c34 0 62 28 62 63v375c0 35-28 63-62 63z m-750 0c-69 0-125 56-125 125s56 125 125 125 125-56 125-125-56-125-125-125z m406-1c-87 0-157 70-157 157 0 86 70 156 157 156s156-70 156-156-70-157-156-157z",
+              transform: "matrix(1 0 0 -1 0 850)"
+            },
+            question: {
+              width: 857.1,
+              height: 1e3,
+              path: "m500 82v107q0 8-5 13t-13 5h-107q-8 0-13-5t-5-13v-107q0-8 5-13t13-5h107q8 0 13 5t5 13z m143 375q0 49-31 91t-77 65-95 23q-136 0-207-119-9-14 4-24l74-55q4-4 10-4 9 0 14 7 30 38 48 51 19 14 48 14 27 0 48-15t21-33q0-21-11-34t-38-25q-35-16-65-48t-29-70v-20q0-8 5-13t13-5h107q8 0 13 5t5 13q0 10 12 27t30 28q18 10 28 16t25 19 25 27 16 34 7 45z m214-107q0-117-57-215t-156-156-215-58-216 58-155 156-58 215 58 215 155 156 216 58 215-58 156-156 57-215z",
+              transform: "matrix(1 0 0 -1 0 850)"
+            },
+            disk: {
+              width: 857.1,
+              height: 1e3,
+              path: "m214-7h429v214h-429v-214z m500 0h72v500q0 8-6 21t-11 20l-157 156q-5 6-19 12t-22 5v-232q0-22-15-38t-38-16h-322q-22 0-37 16t-16 38v232h-72v-714h72v232q0 22 16 38t37 16h465q22 0 38-16t15-38v-232z m-214 518v178q0 8-5 13t-13 5h-107q-7 0-13-5t-5-13v-178q0-8 5-13t13-5h107q7 0 13 5t5 13z m357-18v-518q0-22-15-38t-38-16h-750q-23 0-38 16t-16 38v750q0 22 16 38t38 16h517q23 0 50-12t42-26l156-157q16-15 27-42t11-49z",
+              transform: "matrix(1 0 0 -1 0 850)"
+            },
+            drawopenpath: {
+              width: 70,
+              height: 70,
+              path: "M33.21,85.65a7.31,7.31,0,0,1-2.59-.48c-8.16-3.11-9.27-19.8-9.88-41.3-.1-3.58-.19-6.68-.35-9-.15-2.1-.67-3.48-1.43-3.79-2.13-.88-7.91,2.32-12,5.86L3,32.38c1.87-1.64,11.55-9.66,18.27-6.9,2.13.87,4.75,3.14,5.17,9,.17,2.43.26,5.59.36,9.25a224.17,224.17,0,0,0,1.5,23.4c1.54,10.76,4,12.22,4.48,12.4.84.32,2.79-.46,5.76-3.59L43,80.07C41.53,81.57,37.68,85.64,33.21,85.65ZM74.81,69a11.34,11.34,0,0,0,6.09-6.72L87.26,44.5,74.72,32,56.9,38.35c-2.37.86-5.57,3.42-6.61,6L38.65,72.14l8.42,8.43ZM55,46.27a7.91,7.91,0,0,1,3.64-3.17l14.8-5.3,8,8L76.11,60.6l-.06.19a6.37,6.37,0,0,1-3,3.43L48.25,74.59,44.62,71Zm16.57,7.82A6.9,6.9,0,1,0,64.64,61,6.91,6.91,0,0,0,71.54,54.09Zm-4.05,0a2.85,2.85,0,1,1-2.85-2.85A2.86,2.86,0,0,1,67.49,54.09Zm-4.13,5.22L60.5,56.45,44.26,72.7l2.86,2.86ZM97.83,35.67,84.14,22l-8.57,8.57L89.26,44.24Zm-13.69-8,8,8-2.85,2.85-8-8Z",
+              transform: "matrix(1 0 0 1 -15 -15)"
+            },
+            drawclosedpath: {
+              width: 90,
+              height: 90,
+              path: "M88.41,21.12a26.56,26.56,0,0,0-36.18,0l-2.07,2-2.07-2a26.57,26.57,0,0,0-36.18,0,23.74,23.74,0,0,0,0,34.8L48,90.12a3.22,3.22,0,0,0,4.42,0l36-34.21a23.73,23.73,0,0,0,0-34.79ZM84,51.24,50.16,83.35,16.35,51.25a17.28,17.28,0,0,1,0-25.47,20,20,0,0,1,27.3,0l4.29,4.07a3.23,3.23,0,0,0,4.44,0l4.29-4.07a20,20,0,0,1,27.3,0,17.27,17.27,0,0,1,0,25.46ZM66.76,47.68h-33v6.91h33ZM53.35,35H46.44V68h6.91Z",
+              transform: "matrix(1 0 0 1 -5 -5)"
+            },
+            lasso: {
+              width: 1031,
+              height: 1e3,
+              path: "m1018 538c-36 207-290 336-568 286-277-48-473-256-436-463 10-57 36-108 76-151-13-66 11-137 68-183 34-28 75-41 114-42l-55-70 0 0c-2-1-3-2-4-3-10-14-8-34 5-45 14-11 34-8 45 4 1 1 2 3 2 5l0 0 113 140c16 11 31 24 45 40 4 3 6 7 8 11 48-3 100 0 151 9 278 48 473 255 436 462z m-624-379c-80 14-149 48-197 96 42 42 109 47 156 9 33-26 47-66 41-105z m-187-74c-19 16-33 37-39 60 50-32 109-55 174-68-42-25-95-24-135 8z m360 75c-34-7-69-9-102-8 8 62-16 128-68 170-73 59-175 54-244-5-9 20-16 40-20 61-28 159 121 317 333 354s407-60 434-217c28-159-121-318-333-355z",
+              transform: "matrix(1 0 0 -1 0 850)"
+            },
+            selectbox: {
+              width: 1e3,
+              height: 1e3,
+              path: "m0 850l0-143 143 0 0 143-143 0z m286 0l0-143 143 0 0 143-143 0z m285 0l0-143 143 0 0 143-143 0z m286 0l0-143 143 0 0 143-143 0z m-857-286l0-143 143 0 0 143-143 0z m857 0l0-143 143 0 0 143-143 0z m-857-285l0-143 143 0 0 143-143 0z m857 0l0-143 143 0 0 143-143 0z m-857-286l0-143 143 0 0 143-143 0z m286 0l0-143 143 0 0 143-143 0z m285 0l0-143 143 0 0 143-143 0z m286 0l0-143 143 0 0 143-143 0z",
+              transform: "matrix(1 0 0 -1 0 850)"
+            },
+            drawline: {
+              width: 70,
+              height: 70,
+              path: "M60.64,62.3a11.29,11.29,0,0,0,6.09-6.72l6.35-17.72L60.54,25.31l-17.82,6.4c-2.36.86-5.57,3.41-6.6,6L24.48,65.5l8.42,8.42ZM40.79,39.63a7.89,7.89,0,0,1,3.65-3.17l14.79-5.31,8,8L61.94,54l-.06.19a6.44,6.44,0,0,1-3,3.43L34.07,68l-3.62-3.63Zm16.57,7.81a6.9,6.9,0,1,0-6.89,6.9A6.9,6.9,0,0,0,57.36,47.44Zm-4,0a2.86,2.86,0,1,1-2.85-2.85A2.86,2.86,0,0,1,53.32,47.44Zm-4.13,5.22L46.33,49.8,30.08,66.05l2.86,2.86ZM83.65,29,70,15.34,61.4,23.9,75.09,37.59ZM70,21.06l8,8-2.84,2.85-8-8ZM87,80.49H10.67V87H87Z",
+              transform: "matrix(1 0 0 1 -15 -15)"
+            },
+            drawrect: {
+              width: 80,
+              height: 80,
+              path: "M78,22V79H21V22H78m9-9H12V88H87V13ZM68,46.22H31V54H68ZM53,32H45.22V69H53Z",
+              transform: "matrix(1 0 0 1 -10 -10)"
+            },
+            drawcircle: {
+              width: 80,
+              height: 80,
+              path: "M50,84.72C26.84,84.72,8,69.28,8,50.3S26.84,15.87,50,15.87,92,31.31,92,50.3,73.16,84.72,50,84.72Zm0-60.59c-18.6,0-33.74,11.74-33.74,26.17S31.4,76.46,50,76.46,83.74,64.72,83.74,50.3,68.6,24.13,50,24.13Zm17.15,22h-34v7.11h34Zm-13.8-13H46.24v34h7.11Z",
+              transform: "matrix(1 0 0 1 -10 -10)"
+            },
+            eraseshape: {
+              width: 80,
+              height: 80,
+              path: "M82.77,78H31.85L6,49.57,31.85,21.14H82.77a8.72,8.72,0,0,1,8.65,8.77V69.24A8.72,8.72,0,0,1,82.77,78ZM35.46,69.84H82.77a.57.57,0,0,0,.49-.6V29.91a.57.57,0,0,0-.49-.61H35.46L17,49.57Zm32.68-34.7-24,24,5,5,24-24Zm-19,.53-5,5,24,24,5-5Z",
+              transform: "matrix(1 0 0 1 -10 -10)"
+            },
+            spikeline: {
+              width: 1e3,
+              height: 1e3,
+              path: "M512 409c0-57-46-104-103-104-57 0-104 47-104 104 0 57 47 103 104 103 57 0 103-46 103-103z m-327-39l92 0 0 92-92 0z m-185 0l92 0 0 92-92 0z m370-186l92 0 0 93-92 0z m0-184l92 0 0 92-92 0z",
+              transform: "matrix(1.5 0 0 -1.5 0 850)"
+            },
+            pencil: {
+              width: 1792,
+              height: 1792,
+              path: "M491 1536l91-91-235-235-91 91v107h128v128h107zm523-928q0-22-22-22-10 0-17 7l-542 542q-7 7-7 17 0 22 22 22 10 0 17-7l542-542q7-7 7-17zm-54-192l416 416-832 832h-416v-416zm683 96q0 53-37 90l-166 166-416-416 166-165q36-38 90-38 53 0 91 38l235 234q37 39 37 91z",
+              transform: "matrix(1 0 0 1 0 1)"
+            },
+            newplotlylogo: {
+              name: "newplotlylogo",
+              svg: [
+                "<svg xmlns='http://www.w3.org/2000/svg' viewBox='0 0 132 132'>",
+                " <title>plotly-logomark</title>",
+                " <g id='symbol'>",
+                "  <rect fill='#000' x='0' y='0' width='132' height='132' rx='18' ry='18'/>",
+                "  <circle fill='#9EF' cx='102' cy='30' r='6'/>",
+                "  <circle fill='#BAC' cx='78' cy='30' r='6'/>",
+                "  <circle fill='#BAC' cx='78' cy='54' r='6'/>",
+                "  <circle fill='#D69' cx='54' cy='30' r='6'/>",
+                "  <circle fill='#F26' cx='30' cy='30' r='6'/>",
+                "  <circle fill='#F26' cx='30' cy='54' r='6'/>",
+                "  <path fill='#FFF' d='M30,72a6,6,0,0,0-6,6v24a6,6,0,0,0,12,0V78A6,6,0,0,0,30,72Z'/>",
+                "  <path fill='#FFF' d='M78,72a6,6,0,0,0-6,6v24a6,6,0,0,0,12,0V78A6,6,0,0,0,78,72Z'/>",
+                "  <path fill='#FFF' d='M54,48a6,6,0,0,0-6,6v48a6,6,0,0,0,12,0V54A6,6,0,0,0,54,48Z'/>",
+                "  <path fill='#FFF' d='M102,48a6,6,0,0,0-6,6v48a6,6,0,0,0,12,0V54A6,6,0,0,0,102,48Z'/>",
+                " </g>",
+                "</svg>"
+              ].join("")
+            }
+          };
+        }
+      });
+      var require_constants4 = __commonJS({
+        "src/components/shapes/draw_newshape/constants.js"(exports, module2) {
+          var CIRCLE_SIDES = 32;
+          module2.exports = {
+            CIRCLE_SIDES,
+            i000: 0,
+            i090: CIRCLE_SIDES / 4,
+            i180: CIRCLE_SIDES / 2,
+            i270: CIRCLE_SIDES / 4 * 3,
+            cos45: Math.cos(Math.PI / 4),
+            sin45: Math.sin(Math.PI / 4),
+            SQRT2: Math.sqrt(2)
+          };
+        }
+      });
+      var require_helpers6 = __commonJS({
+        "src/components/selections/helpers.js"(exports, module2) {
+          var strTranslate = require_lib().strTranslate;
+          function p2r(ax, v2) {
+            switch (ax.type) {
+              case "log":
+                return ax.p2d(v2);
+              case "date":
+                return ax.p2r(v2, 0, ax.calendar);
+              default:
+                return ax.p2r(v2);
+            }
+          }
+          function r2p(ax, v2) {
+            switch (ax.type) {
+              case "log":
+                return ax.d2p(v2);
+              case "date":
+                return ax.r2p(v2, 0, ax.calendar);
+              default:
+                return ax.r2p(v2);
+            }
+          }
+          function axValue(ax) {
+            var index = ax._id.charAt(0) === "y" ? 1 : 0;
+            return function(v2) {
+              return p2r(ax, v2[index]);
+            };
+          }
+          function getTransform2(plotinfo) {
+            return strTranslate(
+              plotinfo.xaxis._offset,
+              plotinfo.yaxis._offset
+            );
+          }
+          module2.exports = {
+            p2r,
+            r2p,
+            axValue,
+            getTransform: getTransform2
+          };
+        }
+      });
+      var require_helpers7 = __commonJS({
+        "src/components/shapes/draw_newshape/helpers.js"(exports) {
+          var parseSvgPath = require_parse_svg_path();
+          var constants = require_constants4();
+          var CIRCLE_SIDES = constants.CIRCLE_SIDES;
+          var SQRT2 = constants.SQRT2;
+          var cartesianHelpers = require_helpers6();
+          var p2r = cartesianHelpers.p2r;
+          var r2p = cartesianHelpers.r2p;
+          var iC = [0, 3, 4, 5, 6, 1, 2];
+          var iQS = [0, 3, 4, 1, 2];
+          exports.writePaths = function(polygons) {
+            var nI = polygons.length;
+            if (!nI) return "M0,0Z";
+            var str = "";
+            for (var i2 = 0; i2 < nI; i2++) {
+              var nJ = polygons[i2].length;
+              for (var j2 = 0; j2 < nJ; j2++) {
+                var w2 = polygons[i2][j2][0];
+                if (w2 === "Z") {
+                  str += "Z";
+                } else {
+                  var nK = polygons[i2][j2].length;
+                  for (var k2 = 0; k2 < nK; k2++) {
+                    var realK = k2;
+                    if (w2 === "Q" || w2 === "S") {
+                      realK = iQS[k2];
+                    } else if (w2 === "C") {
+                      realK = iC[k2];
+                    }
+                    str += polygons[i2][j2][realK];
+                    if (k2 > 0 && k2 < nK - 1) {
+                      str += ",";
+                    }
+                  }
+                }
+              }
+            }
+            return str;
+          };
+          exports.readPaths = function(str, gd2, plotinfo, isActiveShape) {
+            var cmd = parseSvgPath(str);
+            var polys = [];
+            var n2 = -1;
+            var newPoly = function() {
+              n2++;
+              polys[n2] = [];
+            };
+            var k2;
+            var x2 = 0;
+            var y2 = 0;
+            var initX;
+            var initY;
+            var recStart = function() {
+              initX = x2;
+              initY = y2;
+            };
+            recStart();
+            for (var i2 = 0; i2 < cmd.length; i2++) {
+              var newPos = [];
+              var x1, x22, y1, y22;
+              var c2 = cmd[i2][0];
+              var w2 = c2;
+              switch (c2) {
+                case "M":
+                  newPoly();
+                  x2 = +cmd[i2][1];
+                  y2 = +cmd[i2][2];
+                  newPos.push([w2, x2, y2]);
+                  recStart();
+                  break;
+                case "Q":
+                case "S":
+                  x1 = +cmd[i2][1];
+                  y1 = +cmd[i2][2];
+                  x2 = +cmd[i2][3];
+                  y2 = +cmd[i2][4];
+                  newPos.push([w2, x2, y2, x1, y1]);
+                  break;
+                case "C":
+                  x1 = +cmd[i2][1];
+                  y1 = +cmd[i2][2];
+                  x22 = +cmd[i2][3];
+                  y22 = +cmd[i2][4];
+                  x2 = +cmd[i2][5];
+                  y2 = +cmd[i2][6];
+                  newPos.push([w2, x2, y2, x1, y1, x22, y22]);
+                  break;
+                case "T":
+                case "L":
+                  x2 = +cmd[i2][1];
+                  y2 = +cmd[i2][2];
+                  newPos.push([w2, x2, y2]);
+                  break;
+                case "H":
+                  w2 = "L";
+                  x2 = +cmd[i2][1];
+                  newPos.push([w2, x2, y2]);
+                  break;
+                case "V":
+                  w2 = "L";
+                  y2 = +cmd[i2][1];
+                  newPos.push([w2, x2, y2]);
+                  break;
+                case "A":
+                  w2 = "L";
+                  var rx = +cmd[i2][1];
+                  var ry = +cmd[i2][2];
+                  if (!+cmd[i2][4]) {
+                    rx = -rx;
+                    ry = -ry;
+                  }
+                  var cenX = x2 - rx;
+                  var cenY = y2;
+                  for (k2 = 1; k2 <= CIRCLE_SIDES / 2; k2++) {
+                    var t4 = 2 * Math.PI * k2 / CIRCLE_SIDES;
+                    newPos.push([
+                      w2,
+                      cenX + rx * Math.cos(t4),
+                      cenY + ry * Math.sin(t4)
+                    ]);
+                  }
+                  break;
+                case "Z":
+                  if (x2 !== initX || y2 !== initY) {
+                    x2 = initX;
+                    y2 = initY;
+                    newPos.push([w2, x2, y2]);
+                  }
+                  break;
+              }
+              var domain = (plotinfo || {}).domain;
+              var size = gd2._fullLayout._size;
+              var xPixelSized = plotinfo && plotinfo.xsizemode === "pixel";
+              var yPixelSized = plotinfo && plotinfo.ysizemode === "pixel";
+              var noOffset = isActiveShape === false;
+              for (var j2 = 0; j2 < newPos.length; j2++) {
+                for (k2 = 0; k2 + 2 < 7; k2 += 2) {
+                  var _x2 = newPos[j2][k2 + 1];
+                  var _y = newPos[j2][k2 + 2];
+                  if (_x2 === void 0 || _y === void 0) continue;
+                  x2 = _x2;
+                  y2 = _y;
+                  if (plotinfo) {
+                    if (plotinfo.xaxis && plotinfo.xaxis.p2r) {
+                      if (noOffset) _x2 -= plotinfo.xaxis._offset;
+                      if (xPixelSized) {
+                        _x2 = r2p(plotinfo.xaxis, plotinfo.xanchor) + _x2;
+                      } else {
+                        _x2 = p2r(plotinfo.xaxis, _x2);
+                      }
+                    } else {
+                      if (noOffset) _x2 -= size.l;
+                      if (domain) _x2 = domain.x[0] + _x2 / size.w;
+                      else _x2 = _x2 / size.w;
+                    }
+                    if (plotinfo.yaxis && plotinfo.yaxis.p2r) {
+                      if (noOffset) _y -= plotinfo.yaxis._offset;
+                      if (yPixelSized) {
+                        _y = r2p(plotinfo.yaxis, plotinfo.yanchor) - _y;
+                      } else {
+                        _y = p2r(plotinfo.yaxis, _y);
+                      }
+                    } else {
+                      if (noOffset) _y -= size.t;
+                      if (domain) _y = domain.y[1] - _y / size.h;
+                      else _y = 1 - _y / size.h;
+                    }
+                  }
+                  newPos[j2][k2 + 1] = _x2;
+                  newPos[j2][k2 + 2] = _y;
+                }
+                polys[n2].push(
+                  newPos[j2].slice()
+                );
+              }
+            }
+            return polys;
+          };
+          function almostEq(a2, b2) {
+            return Math.abs(a2 - b2) <= 1e-6;
+          }
+          function dist(a2, b2) {
+            var dx = b2[1] - a2[1];
+            var dy = b2[2] - a2[2];
+            return Math.sqrt(
+              dx * dx + dy * dy
+            );
+          }
+          exports.pointsOnRectangle = function(cell) {
+            var len2 = cell.length;
+            if (len2 !== 5) return false;
+            for (var j2 = 1; j2 < 3; j2++) {
+              var e01 = cell[0][j2] - cell[1][j2];
+              var e32 = cell[3][j2] - cell[2][j2];
+              if (!almostEq(e01, e32)) return false;
+              var e03 = cell[0][j2] - cell[3][j2];
+              var e12 = cell[1][j2] - cell[2][j2];
+              if (!almostEq(e03, e12)) return false;
+            }
+            if (!almostEq(cell[0][1], cell[1][1]) && !almostEq(cell[0][1], cell[3][1])) return false;
+            return !!(dist(cell[0], cell[1]) * dist(cell[0], cell[3]));
+          };
+          exports.pointsOnEllipse = function(cell) {
+            var len2 = cell.length;
+            if (len2 !== CIRCLE_SIDES + 1) return false;
+            len2 = CIRCLE_SIDES;
+            for (var i2 = 0; i2 < len2; i2++) {
+              var k2 = (len2 * 2 - i2) % len2;
+              var k22 = (len2 / 2 + k2) % len2;
+              var i22 = (len2 / 2 + i2) % len2;
+              if (!almostEq(
+                dist(cell[i2], cell[i22]),
+                dist(cell[k2], cell[k22])
+              )) return false;
+            }
+            return true;
+          };
+          exports.handleEllipse = function(isEllipse, start, end) {
+            if (!isEllipse) return [start, end];
+            var pos = exports.ellipseOver({
+              x0: start[0],
+              y0: start[1],
+              x1: end[0],
+              y1: end[1]
+            });
+            var cx = (pos.x1 + pos.x0) / 2;
+            var cy = (pos.y1 + pos.y0) / 2;
+            var rx = (pos.x1 - pos.x0) / 2;
+            var ry = (pos.y1 - pos.y0) / 2;
+            if (!rx) rx = ry = ry / SQRT2;
+            if (!ry) ry = rx = rx / SQRT2;
+            var cell = [];
+            for (var i2 = 0; i2 < CIRCLE_SIDES; i2++) {
+              var t4 = i2 * 2 * Math.PI / CIRCLE_SIDES;
+              cell.push([
+                cx + rx * Math.cos(t4),
+                cy + ry * Math.sin(t4)
+              ]);
+            }
+            return cell;
+          };
+          exports.ellipseOver = function(pos) {
+            var x0 = pos.x0;
+            var y0 = pos.y0;
+            var x1 = pos.x1;
+            var y1 = pos.y1;
+            var dx = x1 - x0;
+            var dy = y1 - y0;
+            x0 -= dx;
+            y0 -= dy;
+            var cx = (x0 + x1) / 2;
+            var cy = (y0 + y1) / 2;
+            var scale2 = SQRT2;
+            dx *= scale2;
+            dy *= scale2;
+            return {
+              x0: cx - dx,
+              y0: cy - dy,
+              x1: cx + dx,
+              y1: cy + dy
+            };
+          };
+          exports.fixDatesForPaths = function(polygons, xaxis, yaxis) {
+            var xIsDate = xaxis.type === "date";
+            var yIsDate = yaxis.type === "date";
+            if (!xIsDate && !yIsDate) return polygons;
+            for (var i2 = 0; i2 < polygons.length; i2++) {
+              for (var j2 = 0; j2 < polygons[i2].length; j2++) {
+                for (var k2 = 0; k2 + 2 < polygons[i2][j2].length; k2 += 2) {
+                  if (xIsDate) polygons[i2][j2][k2 + 1] = polygons[i2][j2][k2 + 1].replace(" ", "_");
+                  if (yIsDate) polygons[i2][j2][k2 + 2] = polygons[i2][j2][k2 + 2].replace(" ", "_");
+                }
+              }
+            }
+            return polygons;
+          };
+        }
+      });
+      var require_newshapes = __commonJS({
+        "src/components/shapes/draw_newshape/newshapes.js"(exports, module2) {
+          var axis_ids = require_axis_ids();
+          var dragHelpers = require_helpers5();
+          var drawMode = dragHelpers.drawMode;
+          var openMode = dragHelpers.openMode;
+          var constants = require_constants4();
+          var i000 = constants.i000;
+          var i090 = constants.i090;
+          var i180 = constants.i180;
+          var i270 = constants.i270;
+          var cos45 = constants.cos45;
+          var sin45 = constants.sin45;
+          var cartesianHelpers = require_helpers6();
+          var p2r = cartesianHelpers.p2r;
+          var r2p = cartesianHelpers.r2p;
+          var handleOutline = require_handle_outline();
+          var clearOutline = handleOutline.clearOutline;
+          var helpers = require_helpers7();
+          var readPaths = helpers.readPaths;
+          var writePaths = helpers.writePaths;
+          var ellipseOver = helpers.ellipseOver;
+          var fixDatesForPaths = helpers.fixDatesForPaths;
+          function newShapes(outlines, dragOptions) {
+            if (!outlines.length) return;
+            var e2 = outlines[0][0];
+            if (!e2) return;
+            var gd2 = dragOptions.gd;
+            var isActiveShape = dragOptions.isActiveShape;
+            var dragmode = dragOptions.dragmode;
+            var shapes = (gd2.layout || {}).shapes || [];
+            if (!drawMode(dragmode) && isActiveShape !== void 0) {
+              var id2 = gd2._fullLayout._activeShapeIndex;
+              if (id2 < shapes.length) {
+                switch (gd2._fullLayout.shapes[id2].type) {
+                  case "rect":
+                    dragmode = "drawrect";
+                    break;
+                  case "circle":
+                    dragmode = "drawcircle";
+                    break;
+                  case "line":
+                    dragmode = "drawline";
+                    break;
+                  case "path":
+                    var path = shapes[id2].path || "";
+                    if (path[path.length - 1] === "Z") {
+                      dragmode = "drawclosedpath";
+                    } else {
+                      dragmode = "drawopenpath";
+                    }
+                    break;
+                }
+              }
+            }
+            var newShape = createShapeObj(outlines, dragOptions, dragmode);
+            clearOutline(gd2);
+            var editHelpers = dragOptions.editHelpers;
+            var modifyItem = (editHelpers || {}).modifyItem;
+            var allShapes = [];
+            for (var q2 = 0; q2 < shapes.length; q2++) {
+              var beforeEdit = gd2._fullLayout.shapes[q2];
+              allShapes[q2] = beforeEdit._input;
+              if (isActiveShape !== void 0 && q2 === gd2._fullLayout._activeShapeIndex) {
+                var afterEdit = newShape;
+                switch (beforeEdit.type) {
+                  case "line":
+                  case "rect":
+                  case "circle":
+                    var xaxis = axis_ids.getFromId(gd2, beforeEdit.xref);
+                    if (beforeEdit.xref.charAt(0) === "x" && xaxis.type.includes("category")) {
+                      modifyItem("x0", afterEdit.x0 - (beforeEdit.x0shift || 0));
+                      modifyItem("x1", afterEdit.x1 - (beforeEdit.x1shift || 0));
+                    } else {
+                      modifyItem("x0", afterEdit.x0);
+                      modifyItem("x1", afterEdit.x1);
+                    }
+                    var yaxis = axis_ids.getFromId(gd2, beforeEdit.yref);
+                    if (beforeEdit.yref.charAt(0) === "y" && yaxis.type.includes("category")) {
+                      modifyItem("y0", afterEdit.y0 - (beforeEdit.y0shift || 0));
+                      modifyItem("y1", afterEdit.y1 - (beforeEdit.y1shift || 0));
+                    } else {
+                      modifyItem("y0", afterEdit.y0);
+                      modifyItem("y1", afterEdit.y1);
+                    }
+                    break;
+                  case "path":
+                    modifyItem("path", afterEdit.path);
+                    break;
+                }
+              }
+            }
+            if (isActiveShape === void 0) {
+              allShapes.push(newShape);
+              return allShapes;
+            }
+            return editHelpers ? editHelpers.getUpdateObj() : {};
+          }
+          function createShapeObj(outlines, dragOptions, dragmode) {
+            var e2 = outlines[0][0];
+            var gd2 = dragOptions.gd;
+            var d2 = e2.getAttribute("d");
+            var newStyle = gd2._fullLayout.newshape;
+            var plotinfo = dragOptions.plotinfo;
+            var isActiveShape = dragOptions.isActiveShape;
+            var xaxis = plotinfo.xaxis;
+            var yaxis = plotinfo.yaxis;
+            var xPaper = !!plotinfo.domain || !plotinfo.xaxis;
+            var yPaper = !!plotinfo.domain || !plotinfo.yaxis;
+            var isOpenMode = openMode(dragmode);
+            var polygons = readPaths(d2, gd2, plotinfo, isActiveShape);
+            var newShape = {
+              editable: true,
+              visible: newStyle.visible,
+              name: newStyle.name,
+              showlegend: newStyle.showlegend,
+              legend: newStyle.legend,
+              legendwidth: newStyle.legendwidth,
+              legendgroup: newStyle.legendgroup,
+              legendgrouptitle: {
+                text: newStyle.legendgrouptitle.text,
+                font: newStyle.legendgrouptitle.font
+              },
+              legendrank: newStyle.legendrank,
+              label: newStyle.label,
+              xref: xPaper ? "paper" : xaxis._id,
+              yref: yPaper ? "paper" : yaxis._id,
+              layer: newStyle.layer,
+              opacity: newStyle.opacity,
+              line: {
+                color: newStyle.line.color,
+                width: newStyle.line.width,
+                dash: newStyle.line.dash
+              }
+            };
+            if (!isOpenMode) {
+              newShape.fillcolor = newStyle.fillcolor;
+              newShape.fillrule = newStyle.fillrule;
+            }
+            var cell;
+            if (polygons.length === 1) cell = polygons[0];
+            if (cell && cell.length === 5 && // ensure we only have 4 corners for a rect
+            dragmode === "drawrect") {
+              newShape.type = "rect";
+              newShape.x0 = cell[0][1];
+              newShape.y0 = cell[0][2];
+              newShape.x1 = cell[2][1];
+              newShape.y1 = cell[2][2];
+            } else if (cell && dragmode === "drawline") {
+              newShape.type = "line";
+              newShape.x0 = cell[0][1];
+              newShape.y0 = cell[0][2];
+              newShape.x1 = cell[1][1];
+              newShape.y1 = cell[1][2];
+            } else if (cell && dragmode === "drawcircle") {
+              newShape.type = "circle";
+              var xA = cell[i000][1];
+              var xB = cell[i090][1];
+              var xC = cell[i180][1];
+              var xD = cell[i270][1];
+              var yA = cell[i000][2];
+              var yB = cell[i090][2];
+              var yC = cell[i180][2];
+              var yD = cell[i270][2];
+              var xDateOrLog = plotinfo.xaxis && (plotinfo.xaxis.type === "date" || plotinfo.xaxis.type === "log");
+              var yDateOrLog = plotinfo.yaxis && (plotinfo.yaxis.type === "date" || plotinfo.yaxis.type === "log");
+              if (xDateOrLog) {
+                xA = r2p(plotinfo.xaxis, xA);
+                xB = r2p(plotinfo.xaxis, xB);
+                xC = r2p(plotinfo.xaxis, xC);
+                xD = r2p(plotinfo.xaxis, xD);
+              }
+              if (yDateOrLog) {
+                yA = r2p(plotinfo.yaxis, yA);
+                yB = r2p(plotinfo.yaxis, yB);
+                yC = r2p(plotinfo.yaxis, yC);
+                yD = r2p(plotinfo.yaxis, yD);
+              }
+              var x0 = (xB + xD) / 2;
+              var y0 = (yA + yC) / 2;
+              var rx = (xD - xB + xC - xA) / 2;
+              var ry = (yD - yB + yC - yA) / 2;
+              var pos = ellipseOver({
+                x0,
+                y0,
+                x1: x0 + rx * cos45,
+                y1: y0 + ry * sin45
+              });
+              if (xDateOrLog) {
+                pos.x0 = p2r(plotinfo.xaxis, pos.x0);
+                pos.x1 = p2r(plotinfo.xaxis, pos.x1);
+              }
+              if (yDateOrLog) {
+                pos.y0 = p2r(plotinfo.yaxis, pos.y0);
+                pos.y1 = p2r(plotinfo.yaxis, pos.y1);
+              }
+              newShape.x0 = pos.x0;
+              newShape.y0 = pos.y0;
+              newShape.x1 = pos.x1;
+              newShape.y1 = pos.y1;
+            } else {
+              newShape.type = "path";
+              if (xaxis && yaxis) fixDatesForPaths(polygons, xaxis, yaxis);
+              newShape.path = writePaths(polygons);
+              cell = null;
+            }
+            return newShape;
+          }
+          module2.exports = {
+            newShapes,
+            createShapeObj
+          };
+        }
+      });
+      var require_newselections = __commonJS({
+        "src/components/selections/draw_newselection/newselections.js"(exports, module2) {
+          var dragHelpers = require_helpers5();
+          var selectMode = dragHelpers.selectMode;
+          var handleOutline = require_handle_outline();
+          var clearOutline = handleOutline.clearOutline;
+          var helpers = require_helpers7();
+          var readPaths = helpers.readPaths;
+          var writePaths = helpers.writePaths;
+          var fixDatesForPaths = helpers.fixDatesForPaths;
+          module2.exports = function newSelections(outlines, dragOptions) {
+            if (!outlines.length) return;
+            var e2 = outlines[0][0];
+            if (!e2) return;
+            var d2 = e2.getAttribute("d");
+            var gd2 = dragOptions.gd;
+            var newStyle = gd2._fullLayout.newselection;
+            var plotinfo = dragOptions.plotinfo;
+            var xaxis = plotinfo.xaxis;
+            var yaxis = plotinfo.yaxis;
+            var isActiveSelection = dragOptions.isActiveSelection;
+            var dragmode = dragOptions.dragmode;
+            var selections = (gd2.layout || {}).selections || [];
+            if (!selectMode(dragmode) && isActiveSelection !== void 0) {
+              var id2 = gd2._fullLayout._activeSelectionIndex;
+              if (id2 < selections.length) {
+                switch (gd2._fullLayout.selections[id2].type) {
+                  case "rect":
+                    dragmode = "select";
+                    break;
+                  case "path":
+                    dragmode = "lasso";
+                    break;
+                }
+              }
+            }
+            var polygons = readPaths(d2, gd2, plotinfo, isActiveSelection);
+            var newSelection = {
+              xref: xaxis._id,
+              yref: yaxis._id,
+              opacity: newStyle.opacity,
+              line: {
+                color: newStyle.line.color,
+                width: newStyle.line.width,
+                dash: newStyle.line.dash
+              }
+            };
+            var cell;
+            if (polygons.length === 1) cell = polygons[0];
+            if (cell && cell.length === 5 && // ensure we only have 4 corners for a rect
+            dragmode === "select") {
+              newSelection.type = "rect";
+              newSelection.x0 = cell[0][1];
+              newSelection.y0 = cell[0][2];
+              newSelection.x1 = cell[2][1];
+              newSelection.y1 = cell[2][2];
+            } else {
+              newSelection.type = "path";
+              if (xaxis && yaxis) fixDatesForPaths(polygons, xaxis, yaxis);
+              newSelection.path = writePaths(polygons);
+              cell = null;
+            }
+            clearOutline(gd2);
+            var editHelpers = dragOptions.editHelpers;
+            var modifyItem = (editHelpers || {}).modifyItem;
+            var allSelections = [];
+            for (var q2 = 0; q2 < selections.length; q2++) {
+              var beforeEdit = gd2._fullLayout.selections[q2];
+              if (!beforeEdit) {
+                allSelections[q2] = beforeEdit;
+                continue;
+              }
+              allSelections[q2] = beforeEdit._input;
+              if (isActiveSelection !== void 0 && q2 === gd2._fullLayout._activeSelectionIndex) {
+                var afterEdit = newSelection;
+                switch (beforeEdit.type) {
+                  case "rect":
+                    modifyItem("x0", afterEdit.x0);
+                    modifyItem("x1", afterEdit.x1);
+                    modifyItem("y0", afterEdit.y0);
+                    modifyItem("y1", afterEdit.y1);
+                    break;
+                  case "path":
+                    modifyItem("path", afterEdit.path);
+                    break;
+                }
+              }
+            }
+            if (isActiveSelection === void 0) {
+              allSelections.push(newSelection);
+              return allSelections;
+            }
+            return editHelpers ? editHelpers.getUpdateObj() : {};
+          };
+        }
+      });
+      var require_constants5 = __commonJS({
+        "src/components/shapes/constants.js"(exports, module2) {
+          module2.exports = {
+            segmentRE: /[MLHVQCTSZ][^MLHVQCTSZ]*/g,
+            paramRE: /[^\s,]+/g,
+            // which numbers in each path segment are x (or y) values
+            // drawn is which param is a drawn point, as opposed to a
+            // control point (which doesn't count toward autorange.
+            // TODO: this means curved paths could extend beyond the
+            // autorange bounds. This is a bit tricky to get right
+            // unless we revert to bounding boxes, but perhaps there's
+            // a calculation we could do...)
+            paramIsX: {
+              M: { 0: true, drawn: 0 },
+              L: { 0: true, drawn: 0 },
+              H: { 0: true, drawn: 0 },
+              V: {},
+              Q: { 0: true, 2: true, drawn: 2 },
+              C: { 0: true, 2: true, 4: true, drawn: 4 },
+              T: { 0: true, drawn: 0 },
+              S: { 0: true, 2: true, drawn: 2 },
+              // A: {0: true, 5: true},
+              Z: {}
+            },
+            paramIsY: {
+              M: { 1: true, drawn: 1 },
+              L: { 1: true, drawn: 1 },
+              H: {},
+              V: { 0: true, drawn: 0 },
+              Q: { 1: true, 3: true, drawn: 3 },
+              C: { 1: true, 3: true, 5: true, drawn: 5 },
+              T: { 1: true, drawn: 1 },
+              S: { 1: true, 3: true, drawn: 3 },
+              // A: {1: true, 6: true},
+              Z: {}
+            },
+            numParams: {
+              M: 2,
+              L: 2,
+              H: 1,
+              V: 1,
+              Q: 4,
+              C: 6,
+              T: 2,
+              S: 4,
+              // A: 7,
+              Z: 0
+            }
+          };
+        }
+      });
+      var require_helpers8 = __commonJS({
+        "src/components/shapes/helpers.js"(exports) {
+          var constants = require_constants5();
+          var Lib = require_lib();
+          var Axes = require_axes();
+          exports.rangeToShapePosition = function(ax) {
+            return ax.type === "log" ? ax.r2d : function(v2) {
+              return v2;
+            };
+          };
+          exports.shapePositionToRange = function(ax) {
+            return ax.type === "log" ? ax.d2r : function(v2) {
+              return v2;
+            };
+          };
+          exports.decodeDate = function(convertToPx) {
+            return function(v2) {
+              if (v2.replace) v2 = v2.replace("_", " ");
+              return convertToPx(v2);
+            };
+          };
+          exports.encodeDate = function(convertToDate) {
+            return function(v2) {
+              return convertToDate(v2).replace(" ", "_");
+            };
+          };
+          exports.extractPathCoords = function(path, paramsToUse, isRaw) {
+            var extractedCoordinates = [];
+            var segments = path.match(constants.segmentRE);
+            segments.forEach(function(segment) {
+              var relevantParamIdx = paramsToUse[segment.charAt(0)].drawn;
+              if (relevantParamIdx === void 0) return;
+              var params = segment.slice(1).match(constants.paramRE);
+              if (!params || params.length < relevantParamIdx) return;
+              var str = params[relevantParamIdx];
+              var pos = isRaw ? str : Lib.cleanNumber(str);
+              extractedCoordinates.push(pos);
+            });
+            return extractedCoordinates;
+          };
+          exports.countDefiningCoords = function(shapeType, path, axLetter) {
+            if (shapeType !== "path") return 2;
+            if (!path) return 0;
+            const segments = path.match(constants.segmentRE);
+            if (!segments) return 0;
+            const paramIsAxis = axLetter === "x" ? constants.paramIsX : constants.paramIsY;
+            return segments.reduce((coordCount, segment) => {
+              const segmentType = segment.charAt(0);
+              const hasDrawn = paramIsAxis[segmentType].drawn !== void 0;
+              return coordCount + (hasDrawn ? 1 : 0);
+            }, 0);
+          };
+          exports.getDataToPixel = function(gd2, axis, shift, isVertical, refType) {
+            var gs = gd2._fullLayout._size;
+            var dataToPixel;
+            if (axis) {
+              if (refType === "domain") {
+                dataToPixel = function(v2) {
+                  return axis._length * (isVertical ? 1 - v2 : v2) + axis._offset;
+                };
+              } else {
+                var d2r = exports.shapePositionToRange(axis);
+                dataToPixel = function(v2) {
+                  var shiftPixels = getPixelShift(axis, shift);
+                  return axis._offset + axis.r2p(d2r(v2, true)) + shiftPixels;
+                };
+                if (axis.type === "date") dataToPixel = exports.decodeDate(dataToPixel);
+              }
+            } else if (isVertical) {
+              dataToPixel = function(v2) {
+                return gs.t + gs.h * (1 - v2);
+              };
+            } else {
+              dataToPixel = function(v2) {
+                return gs.l + gs.w * v2;
+              };
+            }
+            return dataToPixel;
+          };
+          exports.getPixelToData = function(gd2, axis, isVertical, opt) {
+            var gs = gd2._fullLayout._size;
+            var pixelToData;
+            if (axis) {
+              if (opt === "domain") {
+                pixelToData = function(p2) {
+                  var q2 = (p2 - axis._offset) / axis._length;
+                  return isVertical ? 1 - q2 : q2;
+                };
+              } else {
+                var r2d = exports.rangeToShapePosition(axis);
+                pixelToData = function(p2) {
+                  return r2d(axis.p2r(p2 - axis._offset));
+                };
+              }
+            } else if (isVertical) {
+              pixelToData = function(p2) {
+                return 1 - (p2 - gs.t) / gs.h;
+              };
+            } else {
+              pixelToData = function(p2) {
+                return (p2 - gs.l) / gs.w;
+              };
+            }
+            return pixelToData;
+          };
+          exports.roundPositionForSharpStrokeRendering = function(pos, strokeWidth) {
+            var strokeWidthIsOdd = Math.round(strokeWidth % 2) === 1;
+            var posValAsInt = Math.round(pos);
+            return strokeWidthIsOdd ? posValAsInt + 0.5 : posValAsInt;
+          };
+          exports.makeShapesOptionsAndPlotinfo = function(gd2, index) {
+            var options = gd2._fullLayout.shapes[index] || {};
+            var plotinfo = gd2._fullLayout._plots[options.xref + options.yref];
+            var hasPlotinfo = !!plotinfo;
+            if (hasPlotinfo) {
+              plotinfo._hadPlotinfo = true;
+            } else {
+              plotinfo = {};
+              if (options.xref && options.xref !== "paper") plotinfo.xaxis = gd2._fullLayout[options.xref + "axis"];
+              if (options.yref && options.yref !== "paper") plotinfo.yaxis = gd2._fullLayout[options.yref + "axis"];
+            }
+            plotinfo.xsizemode = options.xsizemode;
+            plotinfo.ysizemode = options.ysizemode;
+            plotinfo.xanchor = options.xanchor;
+            plotinfo.yanchor = options.yanchor;
+            return {
+              options,
+              plotinfo
+            };
+          };
+          exports.makeSelectionsOptionsAndPlotinfo = function(gd2, index) {
+            var options = gd2._fullLayout.selections[index] || {};
+            var plotinfo = gd2._fullLayout._plots[options.xref + options.yref];
+            var hasPlotinfo = !!plotinfo;
+            if (hasPlotinfo) {
+              plotinfo._hadPlotinfo = true;
+            } else {
+              plotinfo = {};
+              if (options.xref) plotinfo.xaxis = gd2._fullLayout[options.xref + "axis"];
+              if (options.yref) plotinfo.yaxis = gd2._fullLayout[options.yref + "axis"];
+            }
+            return {
+              options,
+              plotinfo
+            };
+          };
+          exports.getPathString = function(gd2, options) {
+            const shapeType = options.type;
+            const xRefType = Axes.getRefType(options.xref);
+            const yRefType = Axes.getRefType(options.yref);
+            const gs = gd2._fullLayout._size;
+            var xa, ya2;
+            var xShiftStart, xShiftEnd, yShiftStart, yShiftEnd;
+            var x2p, y2p;
+            var x0, x1, y0, y1;
+            function getConverter(axis, refType, shapeType2, isVertical) {
+              var converter;
+              if (axis) {
+                if (refType === "domain") {
+                  if (isVertical) {
+                    converter = function(v2) {
+                      return axis._offset + axis._length * (1 - v2);
+                    };
+                  } else {
+                    converter = function(v2) {
+                      return axis._offset + axis._length * v2;
+                    };
+                  }
+                } else {
+                  const d2r = exports.shapePositionToRange(axis);
+                  converter = function(v2) {
+                    return axis._offset + axis.r2p(d2r(v2, true));
+                  };
+                  if (shapeType2 === "path" && axis.type === "date") converter = exports.decodeDate(converter);
+                }
+              } else {
+                if (isVertical) {
+                  converter = function(v2) {
+                    return gs.t + gs.h * (1 - v2);
+                  };
+                } else {
+                  converter = function(v2) {
+                    return gs.l + gs.w * v2;
+                  };
+                }
+              }
+              return converter;
+            }
+            if (xRefType === "array") {
+              x2p = [];
+              xa = options.xref.map(function(ref) {
+                return Axes.getFromId(gd2, ref);
+              });
+              x2p = options.xref.map(function(ref, i2) {
+                return getConverter(xa[i2], Axes.getRefType(ref), shapeType, false);
+              });
+            } else {
+              xa = Axes.getFromId(gd2, options.xref);
+              x2p = getConverter(xa, xRefType, shapeType, false);
+            }
+            if (yRefType === "array") {
+              y2p = [];
+              ya2 = options.yref.map(function(ref) {
+                return Axes.getFromId(gd2, ref);
+              });
+              y2p = options.yref.map(function(ref, i2) {
+                return getConverter(ya2[i2], Axes.getRefType(ref), shapeType, true);
+              });
+            } else {
+              ya2 = Axes.getFromId(gd2, options.yref);
+              y2p = getConverter(ya2, yRefType, shapeType, true);
+            }
+            if (shapeType === "path") {
+              return convertPath(options, x2p, y2p);
+            }
+            if (xRefType === "array") {
+              xShiftStart = getPixelShift(xa[0], options.x0shift);
+              xShiftEnd = getPixelShift(xa[1], options.x1shift);
+              x0 = x2p[0](options.x0) + xShiftStart;
+              x1 = x2p[1](options.x1) + xShiftEnd;
+            } else {
+              xShiftStart = getPixelShift(xa, options.x0shift);
+              xShiftEnd = getPixelShift(xa, options.x1shift);
+              if (options.xsizemode === "pixel") {
+                const xAnchorPos = x2p(options.xanchor);
+                x0 = xAnchorPos + options.x0 + xShiftStart;
+                x1 = xAnchorPos + options.x1 + xShiftEnd;
+              } else {
+                x0 = x2p(options.x0) + xShiftStart;
+                x1 = x2p(options.x1) + xShiftEnd;
+              }
+            }
+            if (yRefType === "array") {
+              yShiftStart = getPixelShift(ya2[0], options.y0shift);
+              yShiftEnd = getPixelShift(ya2[1], options.y1shift);
+              y0 = y2p[0](options.y0) + yShiftStart;
+              y1 = y2p[1](options.y1) + yShiftEnd;
+            } else {
+              yShiftStart = getPixelShift(ya2, options.y0shift);
+              yShiftEnd = getPixelShift(ya2, options.y1shift);
+              if (options.ysizemode === "pixel") {
+                const yAnchorPos = y2p(options.yanchor);
+                y0 = yAnchorPos - options.y0 + yShiftStart;
+                y1 = yAnchorPos - options.y1 + yShiftEnd;
+              } else {
+                y0 = y2p(options.y0) + yShiftStart;
+                y1 = y2p(options.y1) + yShiftEnd;
+              }
+            }
+            if (shapeType === "line") return "M" + x0 + "," + y0 + "L" + x1 + "," + y1;
+            if (shapeType === "rect") return "M" + x0 + "," + y0 + "H" + x1 + "V" + y1 + "H" + x0 + "Z";
+            var cx = (x0 + x1) / 2;
+            var cy = (y0 + y1) / 2;
+            var rx = Math.abs(cx - x0);
+            var ry = Math.abs(cy - y0);
+            var rArc = "A" + rx + "," + ry;
+            var rightPt = cx + rx + "," + cy;
+            var topPt = cx + "," + (cy - ry);
+            return "M" + rightPt + rArc + " 0 1,1 " + topPt + rArc + " 0 0,1 " + rightPt + "Z";
+          };
+          function convertPath(options, x2p, y2p) {
+            const pathIn = options.path;
+            const xSizemode = options.xsizemode;
+            const ySizemode = options.ysizemode;
+            const xAnchor = options.xanchor;
+            const yAnchor = options.yanchor;
+            const isArrayXref = Array.isArray(options.xref);
+            const isArrayYref = Array.isArray(options.yref);
+            var xVertexIndex = 0;
+            var yVertexIndex = 0;
+            return pathIn.replace(constants.segmentRE, function(segment) {
+              var paramNumber = 0;
+              var segmentType = segment.charAt(0);
+              var xParams = constants.paramIsX[segmentType];
+              var yParams = constants.paramIsY[segmentType];
+              var nParams = constants.numParams[segmentType];
+              const hasDrawnX = xParams.drawn !== void 0;
+              const hasDrawnY = yParams.drawn !== void 0;
+              const segmentX2p = isArrayXref ? x2p[xVertexIndex] : x2p;
+              const segmentY2p = isArrayYref ? y2p[yVertexIndex] : y2p;
+              var paramString = segment.slice(1).replace(constants.paramRE, function(param) {
+                if (xParams[paramNumber]) {
+                  if (xSizemode === "pixel") param = segmentX2p(xAnchor) + Number(param);
+                  else param = segmentX2p(param);
+                } else if (yParams[paramNumber]) {
+                  if (ySizemode === "pixel") param = segmentY2p(yAnchor) - Number(param);
+                  else param = segmentY2p(param);
+                }
+                paramNumber++;
+                if (paramNumber > nParams) param = "X";
+                return param;
+              });
+              if (paramNumber > nParams) {
+                paramString = paramString.replace(/[\s,]*X.*/, "");
+                Lib.log("Ignoring extra params in segment " + segment);
+              }
+              if (hasDrawnX) xVertexIndex++;
+              if (hasDrawnY) yVertexIndex++;
+              return segmentType + paramString;
+            });
+          }
+          function getPixelShift(axis, shift) {
+            shift = shift || 0;
+            var shiftPixels = 0;
+            if (shift && axis && (axis.type === "category" || axis.type === "multicategory")) {
+              shiftPixels = (axis.r2p(1) - axis.r2p(0)) * shift;
+            }
+            return shiftPixels;
+          }
+        }
+      });
+      var require_display_labels = __commonJS({
+        "src/components/shapes/display_labels.js"(exports, module2) {
+          var Lib = require_lib();
+          var Axes = require_axes();
+          var svgTextUtils = require_svg_text_utils();
+          var Drawing = require_drawing();
+          var readPaths = require_helpers7().readPaths;
+          var helpers = require_helpers8();
+          var getPathString = helpers.getPathString;
+          var shapeLabelTexttemplateVars = require_label_texttemplate();
+          var FROM_TL = require_alignment().FROM_TL;
+          module2.exports = function drawLabel(gd2, index, options, shapeGroup) {
+            shapeGroup.selectAll(".shape-label").remove();
+            if (!(options.label.text || options.label.texttemplate)) return;
+            var text;
+            if (options.label.texttemplate) {
+              var templateValues = {};
+              if (options.type !== "path") {
+                var _xa = Axes.getFromId(gd2, options.xref);
+                var _ya = Axes.getFromId(gd2, options.yref);
+                const isMultiAxisX = Array.isArray(options.xref);
+                const isMultiAxisY = Array.isArray(options.yref);
+                for (var key in shapeLabelTexttemplateVars) {
+                  var isFunction2 = typeof shapeLabelTexttemplateVars[key] === "function";
+                  var isValidForX = !isMultiAxisX || shapeLabelTexttemplateVars.simpleXVariables.includes(key);
+                  var isValidForY = !isMultiAxisY || shapeLabelTexttemplateVars.simpleYVariables.includes(key);
+                  if (isFunction2 && isValidForX && isValidForY) {
+                    var val = shapeLabelTexttemplateVars[key](options, _xa, _ya);
+                    if (val !== void 0) templateValues[key] = val;
+                  }
+                }
+              }
+              text = Lib.texttemplateStringForShapes({
+                data: [templateValues],
+                fallback: options.label.texttemplatefallback,
+                locale: gd2._fullLayout._d3locale,
+                template: options.label.texttemplate
+              });
+            } else {
+              text = options.label.text;
+            }
+            var labelGroupAttrs = {
+              "data-index": index
+            };
+            var font = options.label.font;
+            var labelTextAttrs = {
+              "data-notex": 1
+            };
+            var labelGroup = shapeGroup.append("g").attr(labelGroupAttrs).classed("shape-label", true);
+            var labelText = labelGroup.append("text").attr(labelTextAttrs).classed("shape-label-text", true).text(text);
+            var shapex0, shapex1, shapey0, shapey1;
+            if (options.path) {
+              var d2 = getPathString(gd2, options);
+              var polygons = readPaths(d2, gd2);
+              shapex0 = Infinity;
+              shapey0 = Infinity;
+              shapex1 = -Infinity;
+              shapey1 = -Infinity;
+              for (var i2 = 0; i2 < polygons.length; i2++) {
+                for (var j2 = 0; j2 < polygons[i2].length; j2++) {
+                  var p2 = polygons[i2][j2];
+                  for (var k2 = 1; k2 < p2.length; k2 += 2) {
+                    var _x2 = p2[k2];
+                    var _y = p2[k2 + 1];
+                    shapex0 = Math.min(shapex0, _x2);
+                    shapex1 = Math.max(shapex1, _x2);
+                    shapey0 = Math.min(shapey0, _y);
+                    shapey1 = Math.max(shapey1, _y);
+                  }
+                }
+              }
+            } else {
+              const isArrayXref = Array.isArray(options.xref);
+              const isArrayYref = Array.isArray(options.yref);
+              const xa0 = Axes.getFromId(gd2, isArrayXref ? options.xref[0] : options.xref);
+              const xa1 = Axes.getFromId(gd2, isArrayXref ? options.xref[1] : options.xref);
+              const ya0 = Axes.getFromId(gd2, isArrayYref ? options.yref[0] : options.yref);
+              const ya1 = Axes.getFromId(gd2, isArrayYref ? options.yref[1] : options.yref);
+              const xRefType0 = Axes.getRefType(isArrayXref ? options.xref[0] : options.xref);
+              const xRefType1 = Axes.getRefType(isArrayXref ? options.xref[1] : options.xref);
+              const yRefType0 = Axes.getRefType(isArrayYref ? options.yref[0] : options.yref);
+              const yRefType1 = Axes.getRefType(isArrayYref ? options.yref[1] : options.yref);
+              const x2p = function(v2, shift, xa, xRefType) {
+                return helpers.getDataToPixel(gd2, xa, shift, false, xRefType)(v2);
+              };
+              const y2p = function(v2, shift, ya2, yRefType) {
+                return helpers.getDataToPixel(gd2, ya2, shift, true, yRefType)(v2);
+              };
+              shapex0 = x2p(options.x0, options.x0shift, xa0, xRefType0);
+              shapex1 = x2p(options.x1, options.x1shift, xa1, xRefType1);
+              shapey0 = y2p(options.y0, options.y0shift, ya0, yRefType0);
+              shapey1 = y2p(options.y1, options.y1shift, ya1, yRefType1);
+            }
+            var textangle = options.label.textangle;
+            if (textangle === "auto") {
+              if (options.type === "line") {
+                textangle = calcTextAngle(shapex0, shapey0, shapex1, shapey1);
+              } else {
+                textangle = 0;
+              }
+            }
+            labelText.call(function(s2) {
+              s2.call(Drawing.font, font).attr({});
+              svgTextUtils.convertToTspans(s2, gd2);
+              return s2;
+            });
+            var textBB = Drawing.bBox(labelText.node());
+            var textPos = calcTextPosition(shapex0, shapey0, shapex1, shapey1, options, textangle, textBB);
+            var textx = textPos.textx;
+            var texty = textPos.texty;
+            var xanchor = textPos.xanchor;
+            labelText.attr({
+              "text-anchor": {
+                left: "start",
+                center: "middle",
+                right: "end"
+              }[xanchor],
+              y: texty,
+              x: textx,
+              transform: "rotate(" + textangle + "," + textx + "," + texty + ")"
+            }).call(svgTextUtils.positionText, textx, texty);
+          };
+          function calcTextAngle(shapex0, shapey0, shapex1, shapey1) {
+            var dy, dx;
+            dx = Math.abs(shapex1 - shapex0);
+            if (shapex1 >= shapex0) {
+              dy = shapey0 - shapey1;
+            } else {
+              dy = shapey1 - shapey0;
+            }
+            return -180 / Math.PI * Math.atan2(dy, dx);
+          }
+          function calcTextPosition(shapex0, shapey0, shapex1, shapey1, shapeOptions, actualTextAngle, textBB) {
+            var textPosition = shapeOptions.label.textposition;
+            var textAngle = shapeOptions.label.textangle;
+            var textPadding = shapeOptions.label.padding;
+            var shapeType = shapeOptions.type;
+            var textAngleRad = Math.PI / 180 * actualTextAngle;
+            var sinA = Math.sin(textAngleRad);
+            var cosA = Math.cos(textAngleRad);
+            var xanchor = shapeOptions.label.xanchor;
+            var yanchor = shapeOptions.label.yanchor;
+            var textx, texty, paddingX, paddingY;
+            if (shapeType === "line") {
+              if (textPosition === "start") {
+                textx = shapex0;
+                texty = shapey0;
+              } else if (textPosition === "end") {
+                textx = shapex1;
+                texty = shapey1;
+              } else {
+                textx = (shapex0 + shapex1) / 2;
+                texty = (shapey0 + shapey1) / 2;
+              }
+              if (xanchor === "auto") {
+                if (textPosition === "start") {
+                  if (textAngle === "auto") {
+                    if (shapex1 > shapex0) xanchor = "left";
+                    else if (shapex1 < shapex0) xanchor = "right";
+                    else xanchor = "center";
+                  } else {
+                    if (shapex1 > shapex0) xanchor = "right";
+                    else if (shapex1 < shapex0) xanchor = "left";
+                    else xanchor = "center";
+                  }
+                } else if (textPosition === "end") {
+                  if (textAngle === "auto") {
+                    if (shapex1 > shapex0) xanchor = "right";
+                    else if (shapex1 < shapex0) xanchor = "left";
+                    else xanchor = "center";
+                  } else {
+                    if (shapex1 > shapex0) xanchor = "left";
+                    else if (shapex1 < shapex0) xanchor = "right";
+                    else xanchor = "center";
+                  }
+                } else {
+                  xanchor = "center";
+                }
+              }
+              var paddingConstantsX = { left: 1, center: 0, right: -1 };
+              var paddingConstantsY = { bottom: -1, middle: 0, top: 1 };
+              if (textAngle === "auto") {
+                var paddingDirection = paddingConstantsY[yanchor];
+                paddingX = -textPadding * sinA * paddingDirection;
+                paddingY = textPadding * cosA * paddingDirection;
+              } else {
+                var paddingDirectionX = paddingConstantsX[xanchor];
+                var paddingDirectionY = paddingConstantsY[yanchor];
+                paddingX = textPadding * paddingDirectionX;
+                paddingY = textPadding * paddingDirectionY;
+              }
+              textx = textx + paddingX;
+              texty = texty + paddingY;
+            } else {
+              paddingX = textPadding + 3;
+              if (textPosition.indexOf("right") !== -1) {
+                textx = Math.max(shapex0, shapex1) - paddingX;
+                if (xanchor === "auto") xanchor = "right";
+              } else if (textPosition.indexOf("left") !== -1) {
+                textx = Math.min(shapex0, shapex1) + paddingX;
+                if (xanchor === "auto") xanchor = "left";
+              } else {
+                textx = (shapex0 + shapex1) / 2;
+                if (xanchor === "auto") xanchor = "center";
+              }
+              if (textPosition.indexOf("top") !== -1) {
+                texty = Math.min(shapey0, shapey1);
+              } else if (textPosition.indexOf("bottom") !== -1) {
+                texty = Math.max(shapey0, shapey1);
+              } else {
+                texty = (shapey0 + shapey1) / 2;
+              }
+              paddingY = textPadding;
+              if (yanchor === "bottom") {
+                texty = texty - paddingY;
+              } else if (yanchor === "top") {
+                texty = texty + paddingY;
+              }
+            }
+            var shiftFraction = FROM_TL[yanchor];
+            var baselineAdjust = shapeOptions.label.font.size;
+            var textHeight = textBB.height;
+            var xshift = (textHeight * shiftFraction - baselineAdjust) * sinA;
+            var yshift = -(textHeight * shiftFraction - baselineAdjust) * cosA;
+            return { textx: textx + xshift, texty: texty + yshift, xanchor };
+          }
+        }
+      });
+      var require_display_outlines = __commonJS({
+        "src/components/shapes/display_outlines.js"(exports, module2) {
+          var Lib = require_lib();
+          var strTranslate = Lib.strTranslate;
+          var dragElement = require_dragelement();
+          var dragHelpers = require_helpers5();
+          var drawMode = dragHelpers.drawMode;
+          var selectMode = dragHelpers.selectMode;
+          var Registry = require_registry();
+          var Color2 = require_color();
+          var constants = require_constants4();
+          var i000 = constants.i000;
+          var i090 = constants.i090;
+          var i180 = constants.i180;
+          var i270 = constants.i270;
+          var handleOutline = require_handle_outline();
+          var clearOutlineControllers = handleOutline.clearOutlineControllers;
+          var helpers = require_helpers7();
+          var pointsOnRectangle = helpers.pointsOnRectangle;
+          var pointsOnEllipse = helpers.pointsOnEllipse;
+          var writePaths = helpers.writePaths;
+          var newShapes = require_newshapes().newShapes;
+          var createShapeObj = require_newshapes().createShapeObj;
+          var newSelections = require_newselections();
+          var drawLabel = require_display_labels();
+          module2.exports = function displayOutlines(polygons, outlines, dragOptions, nCalls) {
+            if (!nCalls) nCalls = 0;
+            var gd2 = dragOptions.gd;
+            function redraw() {
+              displayOutlines(polygons, outlines, dragOptions, nCalls++);
+              if (pointsOnEllipse(polygons[0]) || dragOptions.hasText) {
+                update({ redrawing: true });
+              }
+            }
+            function update(opts) {
+              var updateObject = {};
+              if (dragOptions.isActiveShape !== void 0) {
+                dragOptions.isActiveShape = false;
+                updateObject = newShapes(outlines, dragOptions);
+              }
+              if (dragOptions.isActiveSelection !== void 0) {
+                dragOptions.isActiveSelection = false;
+                updateObject = newSelections(outlines, dragOptions);
+                gd2._fullLayout._reselect = true;
+              }
+              if (Object.keys(updateObject).length) {
+                Registry.call((opts || {}).redrawing ? "relayout" : "_guiRelayout", gd2, updateObject);
+              }
+            }
+            var fullLayout = gd2._fullLayout;
+            var zoomLayer = fullLayout._zoomlayer;
+            var dragmode = dragOptions.dragmode;
+            var isDrawMode = drawMode(dragmode);
+            var isSelectMode = selectMode(dragmode);
+            if (isDrawMode || isSelectMode) {
+              gd2._fullLayout._outlining = true;
+            }
+            clearOutlineControllers(gd2);
+            outlines.attr("d", writePaths(polygons));
+            var vertexDragOptions;
+            var groupDragOptions;
+            var indexI;
+            var indexJ;
+            var copyPolygons;
+            if (!nCalls && (dragOptions.isActiveShape || dragOptions.isActiveSelection)) {
+              copyPolygons = recordPositions([], polygons);
+              var g2 = zoomLayer.append("g").attr("class", "outline-controllers");
+              addVertexControllers(g2);
+              addGroupControllers();
+            }
+            if (isDrawMode && dragOptions.hasText) {
+              var shapeGroup = zoomLayer.select(".label-temp");
+              var shapeOptions = createShapeObj(outlines, dragOptions, dragOptions.dragmode);
+              drawLabel(gd2, "label-temp", shapeOptions, shapeGroup);
+            }
+            function startDragVertex(evt) {
+              indexI = +evt.srcElement.getAttribute("data-i");
+              indexJ = +evt.srcElement.getAttribute("data-j");
+              vertexDragOptions[indexI][indexJ].moveFn = moveVertexController;
+            }
+            function moveVertexController(dx, dy) {
+              if (!polygons.length) return;
+              var x0 = copyPolygons[indexI][indexJ][1];
+              var y0 = copyPolygons[indexI][indexJ][2];
+              var cell = polygons[indexI];
+              var len2 = cell.length;
+              if (pointsOnRectangle(cell)) {
+                var _dx = dx;
+                var _dy = dy;
+                if (dragOptions.isActiveSelection) {
+                  var nextPoint = getNextPoint(cell, indexJ);
+                  if (nextPoint[1] === cell[indexJ][1]) {
+                    _dy = 0;
+                  } else {
+                    _dx = 0;
+                  }
+                }
+                for (var q2 = 0; q2 < len2; q2++) {
+                  if (q2 === indexJ) continue;
+                  var pos = cell[q2];
+                  if (pos[1] === cell[indexJ][1]) {
+                    pos[1] = x0 + _dx;
+                  }
+                  if (pos[2] === cell[indexJ][2]) {
+                    pos[2] = y0 + _dy;
+                  }
+                }
+                cell[indexJ][1] = x0 + _dx;
+                cell[indexJ][2] = y0 + _dy;
+                if (!pointsOnRectangle(cell)) {
+                  for (var j2 = 0; j2 < len2; j2++) {
+                    for (var k2 = 0; k2 < cell[j2].length; k2++) {
+                      cell[j2][k2] = copyPolygons[indexI][j2][k2];
+                    }
+                  }
+                }
+              } else {
+                cell[indexJ][1] = x0 + dx;
+                cell[indexJ][2] = y0 + dy;
+              }
+              redraw();
+            }
+            function endDragVertexController() {
+              update();
+            }
+            function removeVertex() {
+              if (!polygons.length) return;
+              if (!polygons[indexI]) return;
+              if (!polygons[indexI].length) return;
+              var newPolygon = [];
+              for (var j2 = 0; j2 < polygons[indexI].length; j2++) {
+                if (j2 !== indexJ) {
+                  newPolygon.push(
+                    polygons[indexI][j2]
+                  );
+                }
+              }
+              if (newPolygon.length > 1 && !(newPolygon.length === 2 && newPolygon[1][0] === "Z")) {
+                if (indexJ === 0) {
+                  newPolygon[0][0] = "M";
+                }
+                polygons[indexI] = newPolygon;
+                redraw();
+                update();
+              }
+            }
+            function clickVertexController(numClicks, evt) {
+              if (numClicks === 2) {
+                indexI = +evt.srcElement.getAttribute("data-i");
+                indexJ = +evt.srcElement.getAttribute("data-j");
+                var cell = polygons[indexI];
+                if (!pointsOnRectangle(cell) && !pointsOnEllipse(cell)) {
+                  removeVertex();
+                }
+              }
+            }
+            function addVertexControllers(g22) {
+              vertexDragOptions = [];
+              for (var i2 = 0; i2 < polygons.length; i2++) {
+                var cell = polygons[i2];
+                var onRect = pointsOnRectangle(cell);
+                var onEllipse = !onRect && pointsOnEllipse(cell);
+                vertexDragOptions[i2] = [];
+                var len2 = cell.length;
+                for (var j2 = 0; j2 < len2; j2++) {
+                  if (cell[j2][0] === "Z") continue;
+                  if (onEllipse && j2 !== i000 && j2 !== i090 && j2 !== i180 && j2 !== i270) {
+                    continue;
+                  }
+                  var rectSelection = onRect && dragOptions.isActiveSelection;
+                  var nextPoint;
+                  if (rectSelection) nextPoint = getNextPoint(cell, j2);
+                  var x2 = cell[j2][1];
+                  var y2 = cell[j2][2];
+                  var vertex2 = g22.append(rectSelection ? "rect" : "circle").attr("data-i", i2).attr("data-j", j2).style({
+                    fill: Color2.background,
+                    stroke: Color2.defaultLine,
+                    "stroke-width": 1,
+                    "shape-rendering": "crispEdges"
+                  });
+                  if (rectSelection) {
+                    var dx = nextPoint[1] - x2;
+                    var dy = nextPoint[2] - y2;
+                    var width = dy ? 5 : Math.max(Math.min(25, Math.abs(dx) - 5), 5);
+                    var height = dx ? 5 : Math.max(Math.min(25, Math.abs(dy) - 5), 5);
+                    vertex2.classed(dy ? "cursor-ew-resize" : "cursor-ns-resize", true).attr("width", width).attr("height", height).attr("x", x2 - width / 2).attr("y", y2 - height / 2).attr("transform", strTranslate(dx / 2, dy / 2));
+                  } else {
+                    vertex2.classed("cursor-grab", true).attr("r", 5).attr("cx", x2).attr("cy", y2);
+                  }
+                  vertexDragOptions[i2][j2] = {
+                    element: vertex2.node(),
+                    gd: gd2,
+                    prepFn: startDragVertex,
+                    doneFn: endDragVertexController,
+                    clickFn: clickVertexController
+                  };
+                  dragElement.init(vertexDragOptions[i2][j2]);
+                }
+              }
+            }
+            function moveGroup(dx, dy) {
+              if (!polygons.length) return;
+              for (var i2 = 0; i2 < polygons.length; i2++) {
+                for (var j2 = 0; j2 < polygons[i2].length; j2++) {
+                  for (var k2 = 0; k2 + 2 < polygons[i2][j2].length; k2 += 2) {
+                    polygons[i2][j2][k2 + 1] = copyPolygons[i2][j2][k2 + 1] + dx;
+                    polygons[i2][j2][k2 + 2] = copyPolygons[i2][j2][k2 + 2] + dy;
+                  }
+                }
+              }
+            }
+            function moveGroupController(dx, dy) {
+              moveGroup(dx, dy);
+              redraw();
+            }
+            function startDragGroupController(evt) {
+              indexI = +evt.srcElement.getAttribute("data-i");
+              if (!indexI) indexI = 0;
+              groupDragOptions[indexI].moveFn = moveGroupController;
+            }
+            function endDragGroupController() {
+              update();
+            }
+            function clickGroupController(numClicks) {
+              if (numClicks === 2) {
+                eraseActiveSelection(gd2);
+              }
+            }
+            function addGroupControllers() {
+              groupDragOptions = [];
+              if (!polygons.length) return;
+              var i2 = 0;
+              groupDragOptions[i2] = {
+                element: outlines[0][0],
+                gd: gd2,
+                prepFn: startDragGroupController,
+                doneFn: endDragGroupController,
+                clickFn: clickGroupController
+              };
+              dragElement.init(groupDragOptions[i2]);
+            }
+          };
+          function recordPositions(polygonsOut, polygonsIn) {
+            for (var i2 = 0; i2 < polygonsIn.length; i2++) {
+              var cell = polygonsIn[i2];
+              polygonsOut[i2] = [];
+              for (var j2 = 0; j2 < cell.length; j2++) {
+                polygonsOut[i2][j2] = [];
+                for (var k2 = 0; k2 < cell[j2].length; k2++) {
+                  polygonsOut[i2][j2][k2] = cell[j2][k2];
+                }
+              }
+            }
+            return polygonsOut;
+          }
+          function getNextPoint(cell, j2) {
+            var x2 = cell[j2][1];
+            var y2 = cell[j2][2];
+            var len2 = cell.length;
+            var nextJ, nextX, nextY;
+            nextJ = (j2 + 1) % len2;
+            nextX = cell[nextJ][1];
+            nextY = cell[nextJ][2];
+            if (nextX === x2 && nextY === y2) {
+              nextJ = (j2 + 2) % len2;
+              nextX = cell[nextJ][1];
+              nextY = cell[nextJ][2];
+            }
+            return [nextJ, nextX, nextY];
+          }
+          function eraseActiveSelection(gd2) {
+            if (!selectMode(gd2._fullLayout.dragmode)) return;
+            clearOutlineControllers(gd2);
+            var id2 = gd2._fullLayout._activeSelectionIndex;
+            var selections = (gd2.layout || {}).selections || [];
+            if (id2 < selections.length) {
+              var list = [];
+              for (var q2 = 0; q2 < selections.length; q2++) {
+                if (q2 !== id2) {
+                  list.push(selections[q2]);
+                }
+              }
+              delete gd2._fullLayout._activeSelectionIndex;
+              var erasedSelection = gd2._fullLayout.selections[id2];
+              gd2._fullLayout._deselect = {
+                xref: erasedSelection.xref,
+                yref: erasedSelection.yref
+              };
+              Registry.call("_guiRelayout", gd2, {
+                selections: list
+              });
+            }
+          }
+        }
+      });
+      var require_draw2 = __commonJS({
+        "src/components/shapes/draw.js"(exports, module2) {
+          var d3 = require_d3();
+          var Registry = require_registry();
+          var Lib = require_lib();
+          var Axes = require_axes();
+          var readPaths = require_helpers7().readPaths;
+          var displayOutlines = require_display_outlines();
+          var drawLabel = require_display_labels();
+          var clearOutlineControllers = require_handle_outline().clearOutlineControllers;
+          var Color2 = require_color();
+          var Drawing = require_drawing();
+          var arrayEditor = require_plot_template().arrayEditor;
+          var dragElement = require_dragelement();
+          var setCursor = require_setcursor();
+          var constants = require_constants5();
+          var helpers = require_helpers8();
+          var getPathString = helpers.getPathString;
+          module2.exports = {
+            draw,
+            drawOne,
+            eraseActiveShape,
+            drawLabel
+          };
+          function draw(gd2) {
+            var fullLayout = gd2._fullLayout;
+            fullLayout._shapeUpperLayer.selectAll("path").remove();
+            fullLayout._shapeLowerLayer.selectAll("path").remove();
+            fullLayout._shapeUpperLayer.selectAll("text").remove();
+            fullLayout._shapeLowerLayer.selectAll("text").remove();
+            for (var k2 in fullLayout._plots) {
+              var shapelayer = fullLayout._plots[k2].shapelayer;
+              if (shapelayer) {
+                shapelayer.selectAll("path").remove();
+                shapelayer.selectAll("text").remove();
+              }
+            }
+            for (var i2 = 0; i2 < fullLayout.shapes.length; i2++) {
+              if (fullLayout.shapes[i2].visible === true) {
+                drawOne(gd2, i2);
+              }
+            }
+          }
+          function shouldSkipEdits(gd2) {
+            return !!gd2._fullLayout._outlining;
+          }
+          function couldHaveActiveShape(gd2) {
+            return !gd2._context.edits.shapePosition;
+          }
+          function drawOne(gd2, index) {
+            gd2._fullLayout._paperdiv.selectAll('.shapelayer [data-index="' + index + '"]').remove();
+            var o2 = helpers.makeShapesOptionsAndPlotinfo(gd2, index);
+            var options = o2.options;
+            var plotinfo = o2.plotinfo;
+            if (!options._input || options.visible !== true) return;
+            const isMultiAxisShape = Array.isArray(options.xref) || Array.isArray(options.yref);
+            if (options.layer === "above") {
+              drawShape(gd2._fullLayout._shapeUpperLayer);
+            } else if (options.xref.includes("paper") || options.yref.includes("paper")) {
+              drawShape(gd2._fullLayout._shapeLowerLayer);
+            } else if (options.layer === "between" && !isMultiAxisShape) {
+              drawShape(plotinfo.shapelayerBetween);
+            } else {
+              if (plotinfo._hadPlotinfo) {
+                var mainPlot = plotinfo.mainplotinfo || plotinfo;
+                drawShape(mainPlot.shapelayer);
+              } else {
+                drawShape(gd2._fullLayout._shapeLowerLayer);
+              }
+            }
+            function drawShape(shapeLayer) {
+              var d2 = getPathString(gd2, options);
+              var attrs = {
+                "data-index": index,
+                "fill-rule": options.fillrule,
+                d: d2
+              };
+              var opacity = options.opacity;
+              var fillColor = options.fillcolor;
+              var lineColor = options.line.width ? options.line.color : "rgba(0,0,0,0)";
+              var lineWidth = options.line.width;
+              var lineDash = options.line.dash;
+              if (!lineWidth && options.editable === true) {
+                lineWidth = 5;
+                lineDash = "solid";
+              }
+              var isOpen = d2[d2.length - 1] !== "Z";
+              var isActiveShape = couldHaveActiveShape(gd2) && options.editable && gd2._fullLayout._activeShapeIndex === index;
+              if (isActiveShape) {
+                fillColor = isOpen ? "rgba(0,0,0,0)" : gd2._fullLayout.activeshape.fillcolor;
+                opacity = gd2._fullLayout.activeshape.opacity;
+              }
+              var shapeGroup = shapeLayer.append("g").classed("shape-group", true).attr({ "data-index": index });
+              var path = shapeGroup.append("path").attr(attrs).style("opacity", opacity).call(Color2.stroke, lineColor).call(Color2.fill, fillColor).call(Drawing.dashLine, lineDash, lineWidth);
+              setClipPath(shapeGroup, gd2, options);
+              drawLabel(gd2, index, options, shapeGroup);
+              var editHelpers;
+              if (isActiveShape || gd2._context.edits.shapePosition) editHelpers = arrayEditor(gd2.layout, "shapes", options);
+              if (isActiveShape) {
+                path.style({
+                  cursor: "move"
+                });
+                var dragOptions = {
+                  element: path.node(),
+                  plotinfo,
+                  gd: gd2,
+                  editHelpers,
+                  hasText: options.label.text || options.label.texttemplate,
+                  isActiveShape: true
+                  // i.e. to enable controllers
+                };
+                var polygons = readPaths(d2, gd2);
+                displayOutlines(polygons, path, dragOptions);
+              } else {
+                if (gd2._context.edits.shapePosition) {
+                  setupDragElement(gd2, path, options, index, shapeLayer, editHelpers);
+                } else if (options.editable === true) {
+                  path.style(
+                    "pointer-events",
+                    isOpen || Color2.opacity(fillColor) * opacity <= 0.5 ? "stroke" : "all"
+                  );
+                }
+              }
+              path.node().addEventListener("click", function() {
+                return activateShape(gd2, path);
+              });
+            }
+          }
+          function setClipPath(shapePath, gd2, shapeOptions) {
+            const xref = shapeOptions.xref;
+            const yref = shapeOptions.yref;
+            if (Array.isArray(xref) || Array.isArray(yref)) {
+              const clipId = "clip" + gd2._fullLayout._uid + "shape" + shapeOptions._index;
+              const rect = getMultiAxisClipRect(gd2, xref, yref);
+              Lib.ensureSingleById(gd2._fullLayout._clips, "clipPath", clipId, function(s2) {
+                s2.append("rect");
+              }).select("rect").attr(rect);
+              Drawing.setClipUrl(shapePath, clipId, gd2);
+            } else {
+              const clipAxes = (xref + yref).replace(/paper/g, "").replace(/[xyz][0-9]* *domain/g, "");
+              Drawing.setClipUrl(shapePath, clipAxes ? "clip" + gd2._fullLayout._uid + clipAxes : null, gd2);
+            }
+          }
+          function getMultiAxisClipRect(gd2, xref, yref) {
+            const gs = gd2._fullLayout._size;
+            function getBounds2(refs, isVertical) {
+              const axes = (Array.isArray(refs) ? refs : [refs]).map((r2) => Axes.getFromId(gd2, r2)).filter(Boolean);
+              if (!axes.length) {
+                return isVertical ? [gs.t, gs.t + gs.h] : [gs.l, gs.l + gs.w];
+              }
+              const startBounds = axes.map(function(ax) {
+                return ax._offset;
+              });
+              const endBounds = axes.map(function(ax) {
+                return ax._offset + ax._length;
+              });
+              return [Math.min(...startBounds), Math.max(...endBounds)];
+            }
+            const xb2 = getBounds2(xref, false);
+            const yb2 = getBounds2(yref, true);
+            return { x: xb2[0], y: yb2[0], width: xb2[1] - xb2[0], height: yb2[1] - yb2[0] };
+          }
+          function setupDragElement(gd2, shapePath, shapeOptions, index, shapeLayer, editHelpers) {
+            var MINWIDTH = 10;
+            var MINHEIGHT = 10;
+            var xPixelSized = shapeOptions.xsizemode === "pixel";
+            var yPixelSized = shapeOptions.ysizemode === "pixel";
+            var isLine = shapeOptions.type === "line";
+            var isPath = shapeOptions.type === "path";
+            var modifyItem = editHelpers.modifyItem;
+            var x0, y0, x1, y1, xAnchor, yAnchor;
+            var n0, s0, w0, e0, optN, optS, optW, optE;
+            var pathIn;
+            var shapeGroup = d3.select(shapePath.node().parentNode);
+            var xa = Axes.getFromId(gd2, shapeOptions.xref);
+            var xRefType = Axes.getRefType(shapeOptions.xref);
+            var ya2 = Axes.getFromId(gd2, shapeOptions.yref);
+            var yRefType = Axes.getRefType(shapeOptions.yref);
+            var shiftXStart = shapeOptions.x0shift;
+            var shiftXEnd = shapeOptions.x1shift;
+            var shiftYStart = shapeOptions.y0shift;
+            var shiftYEnd = shapeOptions.y1shift;
+            var x2p = function(v2, shift) {
+              var dataToPixel = helpers.getDataToPixel(gd2, xa, shift, false, xRefType);
+              return dataToPixel(v2);
+            };
+            var y2p = function(v2, shift) {
+              var dataToPixel = helpers.getDataToPixel(gd2, ya2, shift, true, yRefType);
+              return dataToPixel(v2);
+            };
+            var p2x = helpers.getPixelToData(gd2, xa, false, xRefType);
+            var p2y = helpers.getPixelToData(gd2, ya2, true, yRefType);
+            var sensoryElement = obtainSensoryElement();
+            var dragOptions = {
+              element: sensoryElement.node(),
+              gd: gd2,
+              prepFn: startDrag,
+              doneFn: endDrag,
+              clickFn: abortDrag
+            };
+            var dragMode;
+            dragElement.init(dragOptions);
+            sensoryElement.node().onmousemove = updateDragMode;
+            function obtainSensoryElement() {
+              return isLine ? createLineDragHandles() : shapePath;
+            }
+            function createLineDragHandles() {
+              var minSensoryWidth = 10;
+              var sensoryWidth = Math.max(shapeOptions.line.width, minSensoryWidth);
+              var g2 = shapeLayer.append("g").attr("data-index", index).attr("drag-helper", true);
+              g2.append("path").attr("d", shapePath.attr("d")).style({
+                cursor: "move",
+                "stroke-width": sensoryWidth,
+                "stroke-opacity": "0"
+                // ensure not visible
+              });
+              var circleStyle = {
+                "fill-opacity": "0"
+                // ensure not visible
+              };
+              var circleRadius = Math.max(sensoryWidth / 2, minSensoryWidth);
+              g2.append("circle").attr({
+                "data-line-point": "start-point",
+                cx: xPixelSized ? x2p(shapeOptions.xanchor) + shapeOptions.x0 : x2p(shapeOptions.x0, shiftXStart),
+                cy: yPixelSized ? y2p(shapeOptions.yanchor) - shapeOptions.y0 : y2p(shapeOptions.y0, shiftYStart),
+                r: circleRadius
+              }).style(circleStyle).classed("cursor-grab", true);
+              g2.append("circle").attr({
+                "data-line-point": "end-point",
+                cx: xPixelSized ? x2p(shapeOptions.xanchor) + shapeOptions.x1 : x2p(shapeOptions.x1, shiftXEnd),
+                cy: yPixelSized ? y2p(shapeOptions.yanchor) - shapeOptions.y1 : y2p(shapeOptions.y1, shiftYEnd),
+                r: circleRadius
+              }).style(circleStyle).classed("cursor-grab", true);
+              return g2;
+            }
+            function updateDragMode(evt) {
+              if (shouldSkipEdits(gd2)) {
+                dragMode = null;
+                return;
+              }
+              if (isLine) {
+                if (evt.target.tagName === "path") {
+                  dragMode = "move";
+                } else {
+                  dragMode = evt.target.attributes["data-line-point"].value === "start-point" ? "resize-over-start-point" : "resize-over-end-point";
+                }
+              } else {
+                var dragBBox = dragOptions.element.getBoundingClientRect();
+                var w2 = dragBBox.right - dragBBox.left;
+                var h2 = dragBBox.bottom - dragBBox.top;
+                var x2 = evt.clientX - dragBBox.left;
+                var y2 = evt.clientY - dragBBox.top;
+                var cursor = !isPath && w2 > MINWIDTH && h2 > MINHEIGHT && !evt.shiftKey ? dragElement.getCursor(x2 / w2, 1 - y2 / h2) : "move";
+                setCursor(shapePath, cursor);
+                dragMode = cursor.split("-")[0];
+              }
+            }
+            function startDrag(evt) {
+              if (shouldSkipEdits(gd2)) return;
+              if (xPixelSized) {
+                xAnchor = x2p(shapeOptions.xanchor);
+              }
+              if (yPixelSized) {
+                yAnchor = y2p(shapeOptions.yanchor);
+              }
+              if (shapeOptions.type === "path") {
+                pathIn = shapeOptions.path;
+              } else {
+                x0 = xPixelSized ? shapeOptions.x0 : x2p(shapeOptions.x0);
+                y0 = yPixelSized ? shapeOptions.y0 : y2p(shapeOptions.y0);
+                x1 = xPixelSized ? shapeOptions.x1 : x2p(shapeOptions.x1);
+                y1 = yPixelSized ? shapeOptions.y1 : y2p(shapeOptions.y1);
+              }
+              if (x0 < x1) {
+                w0 = x0;
+                optW = "x0";
+                e0 = x1;
+                optE = "x1";
+              } else {
+                w0 = x1;
+                optW = "x1";
+                e0 = x0;
+                optE = "x0";
+              }
+              if (!yPixelSized && y0 < y1 || yPixelSized && y0 > y1) {
+                n0 = y0;
+                optN = "y0";
+                s0 = y1;
+                optS = "y1";
+              } else {
+                n0 = y1;
+                optN = "y1";
+                s0 = y0;
+                optS = "y0";
+              }
+              updateDragMode(evt);
+              renderVisualCues(shapeLayer, shapeOptions);
+              deactivateClipPathTemporarily(shapePath, shapeOptions, gd2);
+              dragOptions.moveFn = dragMode === "move" ? moveShape : resizeShape;
+              dragOptions.altKey = evt.altKey;
+            }
+            function endDrag() {
+              if (shouldSkipEdits(gd2)) return;
+              setCursor(shapePath);
+              removeVisualCues(shapeLayer);
+              setClipPath(shapePath, gd2, shapeOptions);
+              Registry.call("_guiRelayout", gd2, editHelpers.getUpdateObj());
+            }
+            function abortDrag() {
+              if (shouldSkipEdits(gd2)) return;
+              removeVisualCues(shapeLayer);
+            }
+            function moveShape(dx, dy) {
+              if (shapeOptions.type === "path") {
+                var noOp = function(coord) {
+                  return coord;
+                };
+                var moveX = noOp;
+                var moveY = noOp;
+                if (xPixelSized) {
+                  modifyItem("xanchor", shapeOptions.xanchor = p2x(xAnchor + dx));
+                } else {
+                  moveX = function moveX2(x2) {
+                    return p2x(x2p(x2) + dx);
+                  };
+                  if (xa && xa.type === "date") moveX = helpers.encodeDate(moveX);
+                }
+                if (yPixelSized) {
+                  modifyItem("yanchor", shapeOptions.yanchor = p2y(yAnchor + dy));
+                } else {
+                  moveY = function moveY2(y2) {
+                    return p2y(y2p(y2) + dy);
+                  };
+                  if (ya2 && ya2.type === "date") moveY = helpers.encodeDate(moveY);
+                }
+                modifyItem("path", shapeOptions.path = movePath(pathIn, moveX, moveY));
+              } else {
+                if (xPixelSized) {
+                  modifyItem("xanchor", shapeOptions.xanchor = p2x(xAnchor + dx));
+                } else {
+                  modifyItem("x0", shapeOptions.x0 = p2x(x0 + dx));
+                  modifyItem("x1", shapeOptions.x1 = p2x(x1 + dx));
+                }
+                if (yPixelSized) {
+                  modifyItem("yanchor", shapeOptions.yanchor = p2y(yAnchor + dy));
+                } else {
+                  modifyItem("y0", shapeOptions.y0 = p2y(y0 + dy));
+                  modifyItem("y1", shapeOptions.y1 = p2y(y1 + dy));
+                }
+              }
+              shapePath.attr("d", getPathString(gd2, shapeOptions));
+              renderVisualCues(shapeLayer, shapeOptions);
+              drawLabel(gd2, index, shapeOptions, shapeGroup);
+            }
+            function resizeShape(dx, dy) {
+              if (isPath) {
+                var noOp = function(coord) {
+                  return coord;
+                };
+                var moveX = noOp;
+                var moveY = noOp;
+                if (xPixelSized) {
+                  modifyItem("xanchor", shapeOptions.xanchor = p2x(xAnchor + dx));
+                } else {
+                  moveX = function moveX2(x2) {
+                    return p2x(x2p(x2) + dx);
+                  };
+                  if (xa && xa.type === "date") moveX = helpers.encodeDate(moveX);
+                }
+                if (yPixelSized) {
+                  modifyItem("yanchor", shapeOptions.yanchor = p2y(yAnchor + dy));
+                } else {
+                  moveY = function moveY2(y2) {
+                    return p2y(y2p(y2) + dy);
+                  };
+                  if (ya2 && ya2.type === "date") moveY = helpers.encodeDate(moveY);
+                }
+                modifyItem("path", shapeOptions.path = movePath(pathIn, moveX, moveY));
+              } else if (isLine) {
+                if (dragMode === "resize-over-start-point") {
+                  var newX0 = x0 + dx;
+                  var newY0 = yPixelSized ? y0 - dy : y0 + dy;
+                  modifyItem("x0", shapeOptions.x0 = xPixelSized ? newX0 : p2x(newX0));
+                  modifyItem("y0", shapeOptions.y0 = yPixelSized ? newY0 : p2y(newY0));
+                } else if (dragMode === "resize-over-end-point") {
+                  var newX1 = x1 + dx;
+                  var newY1 = yPixelSized ? y1 - dy : y1 + dy;
+                  modifyItem("x1", shapeOptions.x1 = xPixelSized ? newX1 : p2x(newX1));
+                  modifyItem("y1", shapeOptions.y1 = yPixelSized ? newY1 : p2y(newY1));
+                }
+              } else {
+                var has = function(str) {
+                  return dragMode.indexOf(str) !== -1;
+                };
+                var hasN = has("n");
+                var hasS = has("s");
+                var hasW = has("w");
+                var hasE = has("e");
+                var newN = hasN ? n0 + dy : n0;
+                var newS = hasS ? s0 + dy : s0;
+                var newW = hasW ? w0 + dx : w0;
+                var newE = hasE ? e0 + dx : e0;
+                if (yPixelSized) {
+                  if (hasN) newN = n0 - dy;
+                  if (hasS) newS = s0 - dy;
+                }
+                if (!yPixelSized && newS - newN > MINHEIGHT || yPixelSized && newN - newS > MINHEIGHT) {
+                  modifyItem(optN, shapeOptions[optN] = yPixelSized ? newN : p2y(newN));
+                  modifyItem(optS, shapeOptions[optS] = yPixelSized ? newS : p2y(newS));
+                }
+                if (newE - newW > MINWIDTH) {
+                  modifyItem(optW, shapeOptions[optW] = xPixelSized ? newW : p2x(newW));
+                  modifyItem(optE, shapeOptions[optE] = xPixelSized ? newE : p2x(newE));
+                }
+              }
+              shapePath.attr("d", getPathString(gd2, shapeOptions));
+              renderVisualCues(shapeLayer, shapeOptions);
+              drawLabel(gd2, index, shapeOptions, shapeGroup);
+            }
+            function renderVisualCues(shapeLayer2, shapeOptions2) {
+              if (xPixelSized || yPixelSized) {
+                renderAnchor();
+              }
+              function renderAnchor() {
+                var isNotPath = shapeOptions2.type !== "path";
+                var visualCues = shapeLayer2.selectAll(".visual-cue").data([0]);
+                var strokeWidth = 1;
+                visualCues.enter().append("path").attr({
+                  fill: "#fff",
+                  "fill-rule": "evenodd",
+                  stroke: "#000",
+                  "stroke-width": strokeWidth
+                }).classed("visual-cue", true);
+                var posX = x2p(
+                  xPixelSized ? shapeOptions2.xanchor : Lib.midRange(
+                    isNotPath ? [shapeOptions2.x0, shapeOptions2.x1] : helpers.extractPathCoords(shapeOptions2.path, constants.paramIsX)
+                  )
+                );
+                var posY = y2p(
+                  yPixelSized ? shapeOptions2.yanchor : Lib.midRange(
+                    isNotPath ? [shapeOptions2.y0, shapeOptions2.y1] : helpers.extractPathCoords(shapeOptions2.path, constants.paramIsY)
+                  )
+                );
+                posX = helpers.roundPositionForSharpStrokeRendering(posX, strokeWidth);
+                posY = helpers.roundPositionForSharpStrokeRendering(posY, strokeWidth);
+                if (xPixelSized && yPixelSized) {
+                  var crossPath = "M" + (posX - 1 - strokeWidth) + "," + (posY - 1 - strokeWidth) + "h-8v2h8 v8h2v-8 h8v-2h-8 v-8h-2 Z";
+                  visualCues.attr("d", crossPath);
+                } else if (xPixelSized) {
+                  var vBarPath = "M" + (posX - 1 - strokeWidth) + "," + (posY - 9 - strokeWidth) + "v18 h2 v-18 Z";
+                  visualCues.attr("d", vBarPath);
+                } else {
+                  var hBarPath = "M" + (posX - 9 - strokeWidth) + "," + (posY - 1 - strokeWidth) + "h18 v2 h-18 Z";
+                  visualCues.attr("d", hBarPath);
+                }
+              }
+            }
+            function removeVisualCues(shapeLayer2) {
+              shapeLayer2.selectAll(".visual-cue").remove();
+            }
+            function deactivateClipPathTemporarily(shapePath2, shapeOptions2, gd22) {
+              var xref = shapeOptions2.xref;
+              var yref = shapeOptions2.yref;
+              var xa2 = Axes.getFromId(gd22, xref);
+              var ya22 = Axes.getFromId(gd22, yref);
+              var clipAxes = "";
+              if (xref !== "paper" && !xa2.autorange) clipAxes += xref;
+              if (yref !== "paper" && !ya22.autorange) clipAxes += yref;
+              Drawing.setClipUrl(
+                shapePath2,
+                clipAxes ? "clip" + gd22._fullLayout._uid + clipAxes : null,
+                gd22
+              );
+            }
+          }
+          function movePath(pathIn, moveX, moveY) {
+            return pathIn.replace(constants.segmentRE, function(segment) {
+              var paramNumber = 0;
+              var segmentType = segment.charAt(0);
+              var xParams = constants.paramIsX[segmentType];
+              var yParams = constants.paramIsY[segmentType];
+              var nParams = constants.numParams[segmentType];
+              var paramString = segment.slice(1).replace(constants.paramRE, function(param) {
+                if (paramNumber >= nParams) return param;
+                if (xParams[paramNumber]) param = moveX(param);
+                else if (yParams[paramNumber]) param = moveY(param);
+                paramNumber++;
+                return param;
+              });
+              return segmentType + paramString;
+            });
+          }
+          function activateShape(gd2, path) {
+            if (!couldHaveActiveShape(gd2)) return;
+            var element = path.node();
+            var id2 = +element.getAttribute("data-index");
+            if (id2 >= 0) {
+              if (id2 === gd2._fullLayout._activeShapeIndex) {
+                deactivateShape(gd2);
+                return;
+              }
+              gd2._fullLayout._activeShapeIndex = id2;
+              gd2._fullLayout._deactivateShape = deactivateShape;
+              draw(gd2);
+            }
+          }
+          function deactivateShape(gd2) {
+            if (!couldHaveActiveShape(gd2)) return;
+            var id2 = gd2._fullLayout._activeShapeIndex;
+            if (id2 >= 0) {
+              clearOutlineControllers(gd2);
+              delete gd2._fullLayout._activeShapeIndex;
+              draw(gd2);
+            }
+          }
+          function eraseActiveShape(gd2) {
+            if (!couldHaveActiveShape(gd2)) return;
+            clearOutlineControllers(gd2);
+            var id2 = gd2._fullLayout._activeShapeIndex;
+            var shapes = (gd2.layout || {}).shapes || [];
+            if (id2 < shapes.length) {
+              var list = [];
+              for (var q2 = 0; q2 < shapes.length; q2++) {
+                if (q2 !== id2) {
+                  list.push(shapes[q2]);
+                }
+              }
+              delete gd2._fullLayout._activeShapeIndex;
+              return Registry.call("_guiRelayout", gd2, {
+                shapes: list
+              });
+            }
+          }
+        }
+      });
+      var require_buttons = __commonJS({
+        "src/components/modebar/buttons.js"(exports, module2) {
+          var Registry = require_registry();
+          var Plots = require_plots();
+          var axisIds = require_axis_ids();
+          var Icons = require_ploticon();
+          var eraseActiveShape = require_draw2().eraseActiveShape;
+          var Lib = require_lib();
+          var _2 = Lib._;
+          var modeBarButtons = module2.exports = {};
+          modeBarButtons.toImage = {
+            name: "toImage",
+            title: function(gd2) {
+              var opts = gd2._context.toImageButtonOptions || {};
+              var format = opts.format || "png";
+              return format === "png" ? _2(gd2, "Download plot as a PNG") : (
+                // legacy text
+                _2(gd2, "Download plot")
+              );
+            },
+            icon: Icons.camera,
+            click: function(gd2) {
+              var toImageButtonOptions = gd2._context.toImageButtonOptions;
+              var opts = { format: toImageButtonOptions.format || "png" };
+              Lib.notifier(_2(gd2, "Taking snapshot - this may take a few seconds"), "long");
+              ["filename", "width", "height", "scale"].forEach(function(key) {
+                if (key in toImageButtonOptions) {
+                  opts[key] = toImageButtonOptions[key];
+                }
+              });
+              Registry.call("downloadImage", gd2, opts).then(function(filename2) {
+                Lib.notifier(_2(gd2, "Snapshot succeeded") + " - " + filename2, "long");
+              }).catch(function() {
+                Lib.notifier(_2(gd2, "Sorry, there was a problem downloading your snapshot!"), "long");
+              });
+            }
+          };
+          modeBarButtons.sendDataToCloud = {
+            name: "sendDataToCloud",
+            title: function(gd2) {
+              return _2(gd2, "Edit in Chart Studio");
+            },
+            icon: Icons.disk,
+            click: function(gd2) {
+              Plots.sendDataToCloud(gd2);
+            }
+          };
+          modeBarButtons.editInChartStudio = {
+            name: "editInChartStudio",
+            title: function(gd2) {
+              return _2(gd2, "Edit in Chart Studio");
+            },
+            icon: Icons.pencil,
+            click: function(gd2) {
+              Plots.sendDataToCloud(gd2);
+            }
+          };
+          modeBarButtons.zoom2d = {
+            name: "zoom2d",
+            _cat: "zoom",
+            title: function(gd2) {
+              return _2(gd2, "Zoom");
+            },
+            attr: "dragmode",
+            val: "zoom",
+            icon: Icons.zoombox,
+            click: handleCartesian
+          };
+          modeBarButtons.pan2d = {
+            name: "pan2d",
+            _cat: "pan",
+            title: function(gd2) {
+              return _2(gd2, "Pan");
+            },
+            attr: "dragmode",
+            val: "pan",
+            icon: Icons.pan,
+            click: handleCartesian
+          };
+          modeBarButtons.select2d = {
+            name: "select2d",
+            _cat: "select",
+            title: function(gd2) {
+              return _2(gd2, "Box Select");
+            },
+            attr: "dragmode",
+            val: "select",
+            icon: Icons.selectbox,
+            click: handleCartesian
+          };
+          modeBarButtons.lasso2d = {
+            name: "lasso2d",
+            _cat: "lasso",
+            title: function(gd2) {
+              return _2(gd2, "Lasso Select");
+            },
+            attr: "dragmode",
+            val: "lasso",
+            icon: Icons.lasso,
+            click: handleCartesian
+          };
+          modeBarButtons.drawclosedpath = {
+            name: "drawclosedpath",
+            title: function(gd2) {
+              return _2(gd2, "Draw closed freeform");
+            },
+            attr: "dragmode",
+            val: "drawclosedpath",
+            icon: Icons.drawclosedpath,
+            click: handleCartesian
+          };
+          modeBarButtons.drawopenpath = {
+            name: "drawopenpath",
+            title: function(gd2) {
+              return _2(gd2, "Draw open freeform");
+            },
+            attr: "dragmode",
+            val: "drawopenpath",
+            icon: Icons.drawopenpath,
+            click: handleCartesian
+          };
+          modeBarButtons.drawline = {
+            name: "drawline",
+            title: function(gd2) {
+              return _2(gd2, "Draw line");
+            },
+            attr: "dragmode",
+            val: "drawline",
+            icon: Icons.drawline,
+            click: handleCartesian
+          };
+          modeBarButtons.drawrect = {
+            name: "drawrect",
+            title: function(gd2) {
+              return _2(gd2, "Draw rectangle");
+            },
+            attr: "dragmode",
+            val: "drawrect",
+            icon: Icons.drawrect,
+            click: handleCartesian
+          };
+          modeBarButtons.drawcircle = {
+            name: "drawcircle",
+            title: function(gd2) {
+              return _2(gd2, "Draw circle");
+            },
+            attr: "dragmode",
+            val: "drawcircle",
+            icon: Icons.drawcircle,
+            click: handleCartesian
+          };
+          modeBarButtons.eraseshape = {
+            name: "eraseshape",
+            title: function(gd2) {
+              return _2(gd2, "Erase active shape");
+            },
+            icon: Icons.eraseshape,
+            click: eraseActiveShape
+          };
+          modeBarButtons.zoomIn2d = {
+            name: "zoomIn2d",
+            _cat: "zoomin",
+            title: function(gd2) {
+              return _2(gd2, "Zoom in");
+            },
+            attr: "zoom",
+            val: "in",
+            icon: Icons.zoom_plus,
+            click: handleCartesian
+          };
+          modeBarButtons.zoomOut2d = {
+            name: "zoomOut2d",
+            _cat: "zoomout",
+            title: function(gd2) {
+              return _2(gd2, "Zoom out");
+            },
+            attr: "zoom",
+            val: "out",
+            icon: Icons.zoom_minus,
+            click: handleCartesian
+          };
+          modeBarButtons.autoScale2d = {
+            name: "autoScale2d",
+            _cat: "autoscale",
+            title: function(gd2) {
+              return _2(gd2, "Autoscale");
+            },
+            attr: "zoom",
+            val: "auto",
+            icon: Icons.autoscale,
+            click: handleCartesian
+          };
+          modeBarButtons.resetScale2d = {
+            name: "resetScale2d",
+            _cat: "resetscale",
+            title: function(gd2) {
+              return _2(gd2, "Reset axes");
+            },
+            attr: "zoom",
+            val: "reset",
+            icon: Icons.home,
+            click: handleCartesian
+          };
+          modeBarButtons.hoverClosestCartesian = {
+            name: "hoverClosestCartesian",
+            _cat: "hoverclosest",
+            title: function(gd2) {
+              return _2(gd2, "Show closest data on hover");
+            },
+            attr: "hovermode",
+            val: "closest",
+            icon: Icons.tooltip_basic,
+            gravity: "ne",
+            click: handleCartesian
+          };
+          modeBarButtons.hoverCompareCartesian = {
+            name: "hoverCompareCartesian",
+            _cat: "hoverCompare",
+            title: function(gd2) {
+              return _2(gd2, "Compare data on hover");
+            },
+            attr: "hovermode",
+            val: function(gd2) {
+              return gd2._fullLayout._isHoriz ? "y" : "x";
+            },
+            icon: Icons.tooltip_compare,
+            gravity: "ne",
+            click: handleCartesian
+          };
+          function handleCartesian(gd2, ev) {
+            var button = ev.currentTarget;
+            var astr = button.getAttribute("data-attr");
+            var val = button.getAttribute("data-val") || true;
+            var fullLayout = gd2._fullLayout;
+            var aobj = {};
+            var axList = axisIds.list(gd2, null, true);
+            var allSpikesEnabled = fullLayout._cartesianSpikesEnabled;
+            var ax, i2;
+            if (astr === "zoom") {
+              var mag = val === "in" ? 0.5 : 2;
+              var r0 = (1 + mag) / 2;
+              var r1 = (1 - mag) / 2;
+              var axName, allowed;
+              for (i2 = 0; i2 < axList.length; i2++) {
+                ax = axList[i2];
+                allowed = ax.modebardisable === "none" || ax.modebardisable.indexOf(
+                  val === "auto" || val === "reset" ? "autoscale" : "zoominout"
+                ) === -1;
+                if (allowed && !ax.fixedrange) {
+                  axName = ax._name;
+                  if (val === "auto") {
+                    aobj[axName + ".autorange"] = true;
+                  } else if (val === "reset") {
+                    if (ax._rangeInitial0 === void 0 && ax._rangeInitial1 === void 0) {
+                      aobj[axName + ".autorange"] = true;
+                    } else if (ax._rangeInitial0 === void 0) {
+                      aobj[axName + ".autorange"] = ax._autorangeInitial;
+                      aobj[axName + ".range"] = [null, ax._rangeInitial1];
+                    } else if (ax._rangeInitial1 === void 0) {
+                      aobj[axName + ".range"] = [ax._rangeInitial0, null];
+                      aobj[axName + ".autorange"] = ax._autorangeInitial;
+                    } else {
+                      aobj[axName + ".range"] = [ax._rangeInitial0, ax._rangeInitial1];
+                    }
+                    if (ax._showSpikeInitial !== void 0) {
+                      aobj[axName + ".showspikes"] = ax._showSpikeInitial;
+                      if (allSpikesEnabled === "on" && !ax._showSpikeInitial) {
+                        allSpikesEnabled = "off";
+                      }
+                    }
+                  } else {
+                    var rangeNow = [
+                      ax.r2l(ax.range[0]),
+                      ax.r2l(ax.range[1])
+                    ];
+                    var rangeNew = [
+                      r0 * rangeNow[0] + r1 * rangeNow[1],
+                      r0 * rangeNow[1] + r1 * rangeNow[0]
+                    ];
+                    aobj[axName + ".range[0]"] = ax.l2r(rangeNew[0]);
+                    aobj[axName + ".range[1]"] = ax.l2r(rangeNew[1]);
+                  }
+                }
+              }
+            } else {
+              if (astr === "hovermode" && (val === "x" || val === "y")) {
+                val = fullLayout._isHoriz ? "y" : "x";
+                button.setAttribute("data-val", val);
+              }
+              aobj[astr] = val;
+            }
+            fullLayout._cartesianSpikesEnabled = allSpikesEnabled;
+            Registry.call("_guiRelayout", gd2, aobj);
+          }
+          modeBarButtons.zoom3d = {
+            name: "zoom3d",
+            _cat: "zoom",
+            title: function(gd2) {
+              return _2(gd2, "Zoom");
+            },
+            attr: "scene.dragmode",
+            val: "zoom",
+            icon: Icons.zoombox,
+            click: handleDrag3d
+          };
+          modeBarButtons.pan3d = {
+            name: "pan3d",
+            _cat: "pan",
+            title: function(gd2) {
+              return _2(gd2, "Pan");
+            },
+            attr: "scene.dragmode",
+            val: "pan",
+            icon: Icons.pan,
+            click: handleDrag3d
+          };
+          modeBarButtons.orbitRotation = {
+            name: "orbitRotation",
+            title: function(gd2) {
+              return _2(gd2, "Orbital rotation");
+            },
+            attr: "scene.dragmode",
+            val: "orbit",
+            icon: Icons["3d_rotate"],
+            click: handleDrag3d
+          };
+          modeBarButtons.tableRotation = {
+            name: "tableRotation",
+            title: function(gd2) {
+              return _2(gd2, "Turntable rotation");
+            },
+            attr: "scene.dragmode",
+            val: "turntable",
+            icon: Icons["z-axis"],
+            click: handleDrag3d
+          };
+          function handleDrag3d(gd2, ev) {
+            var button = ev.currentTarget;
+            var attr = button.getAttribute("data-attr");
+            var val = button.getAttribute("data-val") || true;
+            var sceneIds = gd2._fullLayout._subplots.gl3d || [];
+            var layoutUpdate = {};
+            var parts = attr.split(".");
+            for (var i2 = 0; i2 < sceneIds.length; i2++) {
+              layoutUpdate[sceneIds[i2] + "." + parts[1]] = val;
+            }
+            var val2d = val === "pan" ? val : "zoom";
+            layoutUpdate.dragmode = val2d;
+            Registry.call("_guiRelayout", gd2, layoutUpdate);
+          }
+          modeBarButtons.resetCameraDefault3d = {
+            name: "resetCameraDefault3d",
+            _cat: "resetCameraDefault",
+            title: function(gd2) {
+              return _2(gd2, "Reset camera to default");
+            },
+            attr: "resetDefault",
+            icon: Icons.home,
+            click: handleCamera3d
+          };
+          modeBarButtons.resetCameraLastSave3d = {
+            name: "resetCameraLastSave3d",
+            _cat: "resetCameraLastSave",
+            title: function(gd2) {
+              return _2(gd2, "Reset camera to last save");
+            },
+            attr: "resetLastSave",
+            icon: Icons.movie,
+            click: handleCamera3d
+          };
+          function handleCamera3d(gd2, ev) {
+            var button = ev.currentTarget;
+            var attr = button.getAttribute("data-attr");
+            var resetLastSave = attr === "resetLastSave";
+            var resetDefault = attr === "resetDefault";
+            var fullLayout = gd2._fullLayout;
+            var sceneIds = fullLayout._subplots.gl3d || [];
+            var aobj = {};
+            for (var i2 = 0; i2 < sceneIds.length; i2++) {
+              var sceneId = sceneIds[i2];
+              var camera = sceneId + ".camera";
+              var aspectratio = sceneId + ".aspectratio";
+              var aspectmode = sceneId + ".aspectmode";
+              var scene = fullLayout[sceneId]._scene;
+              var didUpdate;
+              if (resetLastSave) {
+                aobj[camera + ".up"] = scene.viewInitial.up;
+                aobj[camera + ".eye"] = scene.viewInitial.eye;
+                aobj[camera + ".center"] = scene.viewInitial.center;
+                didUpdate = true;
+              } else if (resetDefault) {
+                aobj[camera + ".up"] = null;
+                aobj[camera + ".eye"] = null;
+                aobj[camera + ".center"] = null;
+                didUpdate = true;
+              }
+              if (didUpdate) {
+                aobj[aspectratio + ".x"] = scene.viewInitial.aspectratio.x;
+                aobj[aspectratio + ".y"] = scene.viewInitial.aspectratio.y;
+                aobj[aspectratio + ".z"] = scene.viewInitial.aspectratio.z;
+                aobj[aspectmode] = scene.viewInitial.aspectmode;
+              }
+            }
+            Registry.call("_guiRelayout", gd2, aobj);
+          }
+          modeBarButtons.hoverClosest3d = {
+            name: "hoverClosest3d",
+            _cat: "hoverclosest",
+            title: function(gd2) {
+              return _2(gd2, "Toggle show closest data on hover");
+            },
+            attr: "hovermode",
+            val: null,
+            toggle: true,
+            icon: Icons.tooltip_basic,
+            gravity: "ne",
+            click: handleHover3d
+          };
+          function getNextHover3d(gd2, ev) {
+            var button = ev.currentTarget;
+            var val = button._previousVal;
+            var fullLayout = gd2._fullLayout;
+            var sceneIds = fullLayout._subplots.gl3d || [];
+            var axes = ["xaxis", "yaxis", "zaxis"];
+            var currentSpikes = {};
+            var layoutUpdate = {};
+            if (val) {
+              layoutUpdate = val;
+              button._previousVal = null;
+            } else {
+              for (var i2 = 0; i2 < sceneIds.length; i2++) {
+                var sceneId = sceneIds[i2];
+                var sceneLayout = fullLayout[sceneId];
+                var hovermodeAStr = sceneId + ".hovermode";
+                currentSpikes[hovermodeAStr] = sceneLayout.hovermode;
+                layoutUpdate[hovermodeAStr] = false;
+                for (var j2 = 0; j2 < 3; j2++) {
+                  var axis = axes[j2];
+                  var spikeAStr = sceneId + "." + axis + ".showspikes";
+                  layoutUpdate[spikeAStr] = false;
+                  currentSpikes[spikeAStr] = sceneLayout[axis].showspikes;
+                }
+              }
+              button._previousVal = currentSpikes;
+            }
+            return layoutUpdate;
+          }
+          function handleHover3d(gd2, ev) {
+            var layoutUpdate = getNextHover3d(gd2, ev);
+            Registry.call("_guiRelayout", gd2, layoutUpdate);
+          }
+          modeBarButtons.zoomInGeo = {
+            name: "zoomInGeo",
+            _cat: "zoomin",
+            title: function(gd2) {
+              return _2(gd2, "Zoom in");
+            },
+            attr: "zoom",
+            val: "in",
+            icon: Icons.zoom_plus,
+            click: handleGeo
+          };
+          modeBarButtons.zoomOutGeo = {
+            name: "zoomOutGeo",
+            _cat: "zoomout",
+            title: function(gd2) {
+              return _2(gd2, "Zoom out");
+            },
+            attr: "zoom",
+            val: "out",
+            icon: Icons.zoom_minus,
+            click: handleGeo
+          };
+          modeBarButtons.resetGeo = {
+            name: "resetGeo",
+            _cat: "reset",
+            title: function(gd2) {
+              return _2(gd2, "Reset");
+            },
+            attr: "reset",
+            val: null,
+            icon: Icons.autoscale,
+            click: handleGeo
+          };
+          modeBarButtons.hoverClosestGeo = {
+            name: "hoverClosestGeo",
+            _cat: "hoverclosest",
+            title: function(gd2) {
+              return _2(gd2, "Toggle show closest data on hover");
+            },
+            attr: "hovermode",
+            val: null,
+            toggle: true,
+            icon: Icons.tooltip_basic,
+            gravity: "ne",
+            click: toggleHover
+          };
+          function handleGeo(gd2, ev) {
+            var button = ev.currentTarget;
+            var attr = button.getAttribute("data-attr");
+            var val = button.getAttribute("data-val") || true;
+            var fullLayout = gd2._fullLayout;
+            var geoIds = fullLayout._subplots.geo || [];
+            for (var i2 = 0; i2 < geoIds.length; i2++) {
+              var id2 = geoIds[i2];
+              var geoLayout = fullLayout[id2];
+              if (attr === "zoom") {
+                var scale2 = geoLayout.projection.scale;
+                var newScale = val === "in" ? 2 * scale2 : 0.5 * scale2;
+                Registry.call("_guiRelayout", gd2, id2 + ".projection.scale", newScale);
+              }
+            }
+            if (attr === "reset") {
+              resetView(gd2, "geo");
+            }
+          }
+          modeBarButtons.hoverClosestPie = {
+            name: "hoverClosestPie",
+            _cat: "hoverclosest",
+            title: function(gd2) {
+              return _2(gd2, "Toggle show closest data on hover");
+            },
+            attr: "hovermode",
+            val: "closest",
+            icon: Icons.tooltip_basic,
+            gravity: "ne",
+            click: toggleHover
+          };
+          function getNextHover(gd2) {
+            var fullLayout = gd2._fullLayout;
+            if (fullLayout.hovermode) return false;
+            if (fullLayout._has("cartesian")) {
+              return fullLayout._isHoriz ? "y" : "x";
+            }
+            return "closest";
+          }
+          function toggleHover(gd2) {
+            var newHover = getNextHover(gd2);
+            Registry.call("_guiRelayout", gd2, "hovermode", newHover);
+          }
+          modeBarButtons.resetViewSankey = {
+            name: "resetSankeyGroup",
+            title: function(gd2) {
+              return _2(gd2, "Reset view");
+            },
+            icon: Icons.home,
+            click: function(gd2) {
+              var aObj = {
+                "node.groups": [],
+                "node.x": [],
+                "node.y": []
+              };
+              for (var i2 = 0; i2 < gd2._fullData.length; i2++) {
+                var viewInitial = gd2._fullData[i2]._viewInitial;
+                aObj["node.groups"].push(viewInitial.node.groups.slice());
+                aObj["node.x"].push(viewInitial.node.x.slice());
+                aObj["node.y"].push(viewInitial.node.y.slice());
+              }
+              Registry.call("restyle", gd2, aObj);
+            }
+          };
+          modeBarButtons.toggleHover = {
+            name: "toggleHover",
+            title: function(gd2) {
+              return _2(gd2, "Toggle show closest data on hover");
+            },
+            attr: "hovermode",
+            val: null,
+            toggle: true,
+            icon: Icons.tooltip_basic,
+            gravity: "ne",
+            click: function(gd2, ev) {
+              var layoutUpdate = getNextHover3d(gd2, ev);
+              layoutUpdate.hovermode = getNextHover(gd2);
+              Registry.call("_guiRelayout", gd2, layoutUpdate);
+            }
+          };
+          modeBarButtons.resetViews = {
+            name: "resetViews",
+            title: function(gd2) {
+              return _2(gd2, "Reset views");
+            },
+            icon: Icons.home,
+            click: function(gd2, ev) {
+              var button = ev.currentTarget;
+              button.setAttribute("data-attr", "zoom");
+              button.setAttribute("data-val", "reset");
+              handleCartesian(gd2, ev);
+              button.setAttribute("data-attr", "resetLastSave");
+              handleCamera3d(gd2, ev);
+              resetView(gd2, "geo");
+              resetView(gd2, "mapbox");
+              resetView(gd2, "map");
+            }
+          };
+          modeBarButtons.toggleSpikelines = {
+            name: "toggleSpikelines",
+            title: function(gd2) {
+              return _2(gd2, "Toggle Spike Lines");
+            },
+            icon: Icons.spikeline,
+            attr: "_cartesianSpikesEnabled",
+            val: "on",
+            click: function(gd2) {
+              var fullLayout = gd2._fullLayout;
+              var allSpikesEnabled = fullLayout._cartesianSpikesEnabled;
+              fullLayout._cartesianSpikesEnabled = allSpikesEnabled === "on" ? "off" : "on";
+              Registry.call("_guiRelayout", gd2, setSpikelineVisibility(gd2));
+            }
+          };
+          function setSpikelineVisibility(gd2) {
+            var fullLayout = gd2._fullLayout;
+            var areSpikesOn = fullLayout._cartesianSpikesEnabled === "on";
+            var axList = axisIds.list(gd2, null, true);
+            var aobj = {};
+            for (var i2 = 0; i2 < axList.length; i2++) {
+              var ax = axList[i2];
+              aobj[ax._name + ".showspikes"] = areSpikesOn ? true : ax._showSpikeInitial;
+            }
+            return aobj;
+          }
+          modeBarButtons.resetViewMapbox = {
+            name: "resetViewMapbox",
+            _cat: "resetView",
+            title: function(gd2) {
+              return _2(gd2, "Reset view");
+            },
+            attr: "reset",
+            icon: Icons.home,
+            click: function(gd2) {
+              resetView(gd2, "mapbox");
+            }
+          };
+          modeBarButtons.resetViewMap = {
+            name: "resetViewMap",
+            _cat: "resetView",
+            title: function(gd2) {
+              return _2(gd2, "Reset view");
+            },
+            attr: "reset",
+            icon: Icons.home,
+            click: function(gd2) {
+              resetView(gd2, "map");
+            }
+          };
+          modeBarButtons.zoomInMapbox = {
+            name: "zoomInMapbox",
+            _cat: "zoomin",
+            title: function(gd2) {
+              return _2(gd2, "Zoom in");
+            },
+            attr: "zoom",
+            val: "in",
+            icon: Icons.zoom_plus,
+            click: handleMapboxZoom
+          };
+          modeBarButtons.zoomInMap = {
+            name: "zoomInMap",
+            _cat: "zoomin",
+            title: function(gd2) {
+              return _2(gd2, "Zoom in");
+            },
+            attr: "zoom",
+            val: "in",
+            icon: Icons.zoom_plus,
+            click: handleMapZoom
+          };
+          modeBarButtons.zoomOutMapbox = {
+            name: "zoomOutMapbox",
+            _cat: "zoomout",
+            title: function(gd2) {
+              return _2(gd2, "Zoom out");
+            },
+            attr: "zoom",
+            val: "out",
+            icon: Icons.zoom_minus,
+            click: handleMapboxZoom
+          };
+          modeBarButtons.zoomOutMap = {
+            name: "zoomOutMap",
+            _cat: "zoomout",
+            title: function(gd2) {
+              return _2(gd2, "Zoom out");
+            },
+            attr: "zoom",
+            val: "out",
+            icon: Icons.zoom_minus,
+            click: handleMapZoom
+          };
+          function handleMapboxZoom(gd2, ev) {
+            _handleMapZoom(gd2, ev, "mapbox");
+          }
+          function handleMapZoom(gd2, ev) {
+            _handleMapZoom(gd2, ev, "map");
+          }
+          function _handleMapZoom(gd2, ev, mapType) {
+            var button = ev.currentTarget;
+            var val = button.getAttribute("data-val");
+            var fullLayout = gd2._fullLayout;
+            var subplotIds = fullLayout._subplots[mapType] || [];
+            var scalar = 1.05;
+            var aObj = {};
+            for (var i2 = 0; i2 < subplotIds.length; i2++) {
+              var id2 = subplotIds[i2];
+              var current = fullLayout[id2].zoom;
+              var next = val === "in" ? scalar * current : current / scalar;
+              aObj[id2 + ".zoom"] = next;
+            }
+            Registry.call("_guiRelayout", gd2, aObj);
+          }
+          function resetView(gd2, subplotType) {
+            var fullLayout = gd2._fullLayout;
+            var subplotIds = fullLayout._subplots[subplotType] || [];
+            var aObj = {};
+            for (var i2 = 0; i2 < subplotIds.length; i2++) {
+              var id2 = subplotIds[i2];
+              var subplotObj = fullLayout[id2]._subplot;
+              var viewInitial = subplotObj.viewInitial;
+              var viewKeys = Object.keys(viewInitial);
+              for (var j2 = 0; j2 < viewKeys.length; j2++) {
+                var key = viewKeys[j2];
+                aObj[id2 + "." + key] = viewInitial[key];
+              }
+            }
+            Registry.call("_guiRelayout", gd2, aObj);
+          }
+        }
+      });
+      var require_constants6 = __commonJS({
+        "src/components/modebar/constants.js"(exports, module2) {
+          var modeBarButtons = require_buttons();
+          var buttonList = Object.keys(modeBarButtons);
+          var DRAW_MODES = [
+            "drawline",
+            "drawopenpath",
+            "drawclosedpath",
+            "drawcircle",
+            "drawrect",
+            "eraseshape"
+          ];
+          var backButtons = [
+            "v1hovermode",
+            "hoverclosest",
+            "hovercompare",
+            "togglehover",
+            "togglespikelines"
+          ].concat(DRAW_MODES);
+          var foreButtons = [];
+          var addToForeButtons = function(b2) {
+            if (backButtons.indexOf(b2._cat || b2.name) !== -1) return;
+            var name2 = b2.name;
+            var _cat = (b2._cat || b2.name).toLowerCase();
+            if (foreButtons.indexOf(name2) === -1) foreButtons.push(name2);
+            if (foreButtons.indexOf(_cat) === -1) foreButtons.push(_cat);
+          };
+          buttonList.forEach(function(k2) {
+            addToForeButtons(modeBarButtons[k2]);
+          });
+          foreButtons.sort();
+          module2.exports = {
+            DRAW_MODES,
+            backButtons,
+            foreButtons
+          };
+        }
+      });
+      var require_attributes10 = __commonJS({
+        "src/components/modebar/attributes.js"(exports, module2) {
+          require_constants6();
+          module2.exports = {
+            editType: "modebar",
+            orientation: {
+              valType: "enumerated",
+              values: ["v", "h"],
+              dflt: "h",
+              editType: "modebar"
+            },
+            bgcolor: {
+              valType: "color",
+              editType: "modebar"
+            },
+            color: {
+              valType: "color",
+              editType: "modebar"
+            },
+            activecolor: {
+              valType: "color",
+              editType: "modebar"
+            },
+            uirevision: {
+              valType: "any",
+              editType: "none"
+            },
+            add: {
+              valType: "string",
+              arrayOk: true,
+              dflt: "",
+              editType: "modebar"
+            },
+            remove: {
+              valType: "string",
+              arrayOk: true,
+              dflt: "",
+              editType: "modebar"
+            }
+          };
+        }
+      });
+      var require_defaults5 = __commonJS({
+        "src/components/modebar/defaults.js"(exports, module2) {
+          var Lib = require_lib();
+          var Color2 = require_color();
+          var Template = require_plot_template();
+          var attributes = require_attributes10();
+          module2.exports = function supplyLayoutDefaults(layoutIn, layoutOut) {
+            var containerIn = layoutIn.modebar || {};
+            var containerOut = Template.newContainer(layoutOut, "modebar");
+            function coerce(attr, dflt) {
+              return Lib.coerce(containerIn, containerOut, attributes, attr, dflt);
+            }
+            coerce("orientation");
+            coerce("bgcolor", Color2.addOpacity(layoutOut.paper_bgcolor, 0.5));
+            var defaultColor = Color2.contrast(Color2.rgb(layoutOut.modebar.bgcolor));
+            coerce("color", Color2.addOpacity(defaultColor, 0.3));
+            coerce("activecolor", Color2.addOpacity(defaultColor, 0.7));
+            coerce("uirevision", layoutOut.uirevision);
+            coerce("add");
+            coerce("remove");
+          };
+        }
+      });
+      var require_modebar = __commonJS({
+        "src/components/modebar/modebar.js"(exports, module2) {
+          var d3 = require_d3();
+          var isNumeric = require_fast_isnumeric();
+          var Lib = require_lib();
+          var Icons = require_ploticon();
+          var version2 = require_version().version;
+          var Parser = new DOMParser();
+          function ModeBar(opts) {
+            this.container = opts.container;
+            this.element = document.createElement("div");
+            this.update(opts.graphInfo, opts.buttons);
+            this.container.appendChild(this.element);
+          }
+          var proto = ModeBar.prototype;
+          proto.update = function(graphInfo, buttons) {
+            this.graphInfo = graphInfo;
+            var context = this.graphInfo._context;
+            var fullLayout = this.graphInfo._fullLayout;
+            var modeBarId = "modebar-" + fullLayout._uid;
+            this.element.setAttribute("id", modeBarId);
+            this.element.setAttribute("role", "toolbar");
+            this._uid = modeBarId;
+            this.element.className = "modebar modebar--custom";
+            if (context.displayModeBar === "hover") this.element.className += " modebar--hover ease-bg";
+            if (fullLayout.modebar.orientation === "v") {
+              this.element.className += " vertical";
+              buttons = buttons.reverse();
+            }
+            var style = fullLayout.modebar;
+            var groupSelector = "#" + modeBarId + " .modebar-group";
+            document.querySelectorAll(groupSelector).forEach(function(group) {
+              group.style.backgroundColor = style.bgcolor;
+            });
+            var needsNewButtons = !this.hasButtons(buttons);
+            var needsNewLogo = this.hasLogo !== context.displaylogo;
+            var needsNewLocale = this.locale !== context.locale;
+            this.locale = context.locale;
+            if (needsNewButtons || needsNewLogo || needsNewLocale) {
+              this.removeAllButtons();
+              this.updateButtons(buttons);
+              if (context.watermark || context.displaylogo) {
+                var logoGroup = this.getLogo();
+                if (context.watermark) {
+                  logoGroup.className = logoGroup.className + " watermark";
+                }
+                if (fullLayout.modebar.orientation === "v") {
+                  this.element.insertBefore(logoGroup, this.element.childNodes[0]);
+                } else {
+                  this.element.appendChild(logoGroup);
+                }
+                this.hasLogo = true;
+              }
+            }
+            this.updateActiveButton();
+            Lib.setStyleOnHover("#" + modeBarId + " .modebar-btn", ".active", ".icon path", "fill: " + style.activecolor, "fill: " + style.color, this.element);
+          };
+          proto.updateButtons = function(buttons) {
+            var _this = this;
+            this.buttons = buttons;
+            this.buttonElements = [];
+            this.buttonsNames = [];
+            this.buttons.forEach(function(buttonGroup) {
+              var group = _this.createGroup();
+              buttonGroup.forEach(function(buttonConfig) {
+                var buttonName = buttonConfig.name;
+                if (!buttonName) {
+                  throw new Error("must provide button 'name' in button config");
+                }
+                if (_this.buttonsNames.indexOf(buttonName) !== -1) {
+                  throw new Error("button name '" + buttonName + "' is taken");
+                }
+                _this.buttonsNames.push(buttonName);
+                var button = _this.createButton(buttonConfig);
+                _this.buttonElements.push(button);
+                group.appendChild(button);
+              });
+              _this.element.appendChild(group);
+            });
+          };
+          proto.createGroup = function() {
+            var group = document.createElement("div");
+            group.className = "modebar-group";
+            var style = this.graphInfo._fullLayout.modebar;
+            group.style.backgroundColor = style.bgcolor;
+            return group;
+          };
+          proto.createButton = function(config2) {
+            var _this = this;
+            var button = document.createElement("button");
+            button.setAttribute("type", "button");
+            button.setAttribute("rel", "tooltip");
+            button.className = "modebar-btn";
+            var title = config2.title;
+            if (title === void 0) title = config2.name;
+            else if (typeof title === "function") title = title(this.graphInfo);
+            if (title || title === 0) {
+              button.setAttribute("data-title", title);
+              button.setAttribute("aria-label", title);
+            }
+            if (config2.attr !== void 0) button.setAttribute("data-attr", config2.attr);
+            var val = config2.val;
+            if (val !== void 0) {
+              if (typeof val === "function") val = val(this.graphInfo);
+              button.setAttribute("data-val", val);
+            }
+            var click = config2.click;
+            if (typeof click !== "function") {
+              throw new Error("must provide button 'click' function in button config");
+            } else {
+              button.addEventListener("click", function(ev) {
+                config2.click(_this.graphInfo, ev);
+                _this.updateActiveButton(ev.currentTarget);
+              });
+            }
+            button.setAttribute("data-toggle", config2.toggle || false);
+            if (config2.toggle) d3.select(button).classed("active", true);
+            var icon = config2.icon;
+            if (typeof icon === "function") {
+              button.appendChild(icon());
+            } else {
+              button.appendChild(this.createIcon(icon || Icons.question));
+            }
+            button.setAttribute("data-gravity", config2.gravity || "n");
+            return button;
+          };
+          proto.createIcon = function(thisIcon) {
+            var iconHeight = isNumeric(thisIcon.height) ? Number(thisIcon.height) : thisIcon.ascent - thisIcon.descent;
+            var svgNS = "http://www.w3.org/2000/svg";
+            var icon;
+            if (thisIcon.path) {
+              icon = document.createElementNS(svgNS, "svg");
+              icon.setAttribute("viewBox", [0, 0, thisIcon.width, iconHeight].join(" "));
+              icon.setAttribute("class", "icon");
+              var path = document.createElementNS(svgNS, "path");
+              path.setAttribute("d", thisIcon.path);
+              if (thisIcon.transform) {
+                path.setAttribute("transform", thisIcon.transform);
+              } else if (thisIcon.ascent !== void 0) {
+                path.setAttribute("transform", "matrix(1 0 0 -1 0 " + thisIcon.ascent + ")");
+              }
+              icon.appendChild(path);
+            }
+            if (thisIcon.svg) {
+              var svgDoc = Parser.parseFromString(thisIcon.svg, "application/xml");
+              icon = svgDoc.childNodes[0];
+            }
+            icon.setAttribute("height", "1em");
+            icon.setAttribute("width", "1em");
+            return icon;
+          };
+          proto.updateActiveButton = function(buttonClicked) {
+            var fullLayout = this.graphInfo._fullLayout;
+            var dataAttrClicked = buttonClicked !== void 0 ? buttonClicked.getAttribute("data-attr") : null;
+            this.buttonElements.forEach(function(button) {
+              var thisval = button.getAttribute("data-val") || true;
+              var dataAttr = button.getAttribute("data-attr");
+              var isToggleButton = button.getAttribute("data-toggle") === "true";
+              var button3 = d3.select(button);
+              var updateButtonStyle = function(button2, isActive2) {
+                var style = fullLayout.modebar;
+                var childEl = button2.querySelector(".icon path");
+                if (childEl) {
+                  if (isActive2 || button2.matches(":hover")) {
+                    childEl.style.fill = style.activecolor;
+                  } else {
+                    childEl.style.fill = style.color;
+                  }
+                }
+              };
+              if (isToggleButton) {
+                if (dataAttr === dataAttrClicked) {
+                  var isActive = !button3.classed("active");
+                  button3.classed("active", isActive);
+                  updateButtonStyle(button, isActive);
+                }
+              } else {
+                var val = dataAttr === null ? dataAttr : Lib.nestedProperty(fullLayout, dataAttr).get();
+                button3.classed("active", val === thisval);
+                updateButtonStyle(button, val === thisval);
+              }
+            });
+          };
+          proto.hasButtons = function(buttons) {
+            var currentButtons = this.buttons;
+            if (!currentButtons) return false;
+            if (buttons.length !== currentButtons.length) return false;
+            for (var i2 = 0; i2 < buttons.length; ++i2) {
+              if (buttons[i2].length !== currentButtons[i2].length) return false;
+              for (var j2 = 0; j2 < buttons[i2].length; j2++) {
+                if (buttons[i2][j2].name !== currentButtons[i2][j2].name) return false;
+              }
+            }
+            return true;
+          };
+          function jsVersion(str) {
+            return str + " (v" + version2 + ")";
+          }
+          proto.getLogo = function() {
+            var group = this.createGroup();
+            var a2 = document.createElement("a");
+            a2.href = "https://plotly.com/";
+            a2.target = "_blank";
+            a2.setAttribute("data-title", jsVersion(Lib._(this.graphInfo, "Produced with Plotly.js")));
+            a2.className = "modebar-btn plotlyjsicon modebar-btn--logo";
+            a2.appendChild(this.createIcon(Icons.newplotlylogo));
+            group.appendChild(a2);
+            return group;
+          };
+          proto.removeAllButtons = function() {
+            while (this.element.firstChild) {
+              this.element.removeChild(this.element.firstChild);
+            }
+            this.hasLogo = false;
+          };
+          proto.destroy = function() {
+            Lib.removeElement(this.container.querySelector(".modebar"));
+          };
+          function createModeBar(gd2, buttons) {
+            var fullLayout = gd2._fullLayout;
+            var modeBar = new ModeBar({
+              graphInfo: gd2,
+              container: fullLayout._modebardiv.node(),
+              buttons
+            });
+            if (fullLayout._privateplot) {
+              d3.select(modeBar.element).append("span").classed("badge-private float--left", true).text("PRIVATE");
+            }
+            return modeBar;
+          }
+          module2.exports = createModeBar;
+        }
+      });
+      var require_manage = __commonJS({
+        "src/components/modebar/manage.js"(exports, module2) {
+          var axisIds = require_axis_ids();
+          var scatterSubTypes = require_subtypes();
+          var Registry = require_registry();
+          var isUnifiedHover = require_helpers2().isUnifiedHover;
+          var createModeBar = require_modebar();
+          var modeBarButtons = require_buttons();
+          var DRAW_MODES = require_constants6().DRAW_MODES;
+          var extendDeep = require_lib().extendDeep;
+          module2.exports = function manageModeBar(gd2) {
+            var fullLayout = gd2._fullLayout;
+            var context = gd2._context;
+            var modeBar = fullLayout._modeBar;
+            if (!context.displayModeBar && !context.watermark) {
+              if (modeBar) {
+                modeBar.destroy();
+                delete fullLayout._modeBar;
+              }
+              return;
+            }
+            if (!Array.isArray(context.modeBarButtonsToRemove)) {
+              throw new Error([
+                "*modeBarButtonsToRemove* configuration options",
+                "must be an array."
+              ].join(" "));
+            }
+            if (!Array.isArray(context.modeBarButtonsToAdd)) {
+              throw new Error([
+                "*modeBarButtonsToAdd* configuration options",
+                "must be an array."
+              ].join(" "));
+            }
+            var customButtons = context.modeBarButtons;
+            var buttonGroups;
+            if (Array.isArray(customButtons) && customButtons.length) {
+              buttonGroups = fillCustomButton(customButtons);
+            } else if (!context.displayModeBar && context.watermark) {
+              buttonGroups = [];
+            } else {
+              buttonGroups = getButtonGroups(gd2);
+            }
+            if (modeBar) modeBar.update(gd2, buttonGroups);
+            else fullLayout._modeBar = createModeBar(gd2, buttonGroups);
+          };
+          function getButtonGroups(gd2) {
+            var fullLayout = gd2._fullLayout;
+            var fullData = gd2._fullData;
+            var context = gd2._context;
+            function match(name2, B22) {
+              if (typeof B22 === "string") {
+                if (B22.toLowerCase() === name2.toLowerCase()) return true;
+              } else {
+                var v0 = B22.name;
+                var v1 = B22._cat || B22.name;
+                if (v0 === name2 || v1 === name2.toLowerCase()) return true;
+              }
+              return false;
+            }
+            var layoutAdd = fullLayout.modebar.add;
+            if (typeof layoutAdd === "string") layoutAdd = [layoutAdd];
+            var layoutRemove = fullLayout.modebar.remove;
+            if (typeof layoutRemove === "string") layoutRemove = [layoutRemove];
+            var buttonsToAdd = context.modeBarButtonsToAdd.concat(
+              layoutAdd.filter(function(e2) {
+                for (var i22 = 0; i22 < context.modeBarButtonsToRemove.length; i22++) {
+                  if (match(e2, context.modeBarButtonsToRemove[i22])) return false;
+                }
+                return true;
+              })
+            );
+            var buttonsToRemove = context.modeBarButtonsToRemove.concat(
+              layoutRemove.filter(function(e2) {
+                for (var i22 = 0; i22 < context.modeBarButtonsToAdd.length; i22++) {
+                  if (match(e2, context.modeBarButtonsToAdd[i22])) return false;
+                }
+                return true;
+              })
+            );
+            var hasCartesian = fullLayout._has("cartesian");
+            var hasGL3D = fullLayout._has("gl3d");
+            var hasGeo = fullLayout._has("geo");
+            var hasPie = fullLayout._has("pie");
+            var hasFunnelarea = fullLayout._has("funnelarea");
+            var hasTernary = fullLayout._has("ternary");
+            var hasMapbox = fullLayout._has("mapbox");
+            var hasMap = fullLayout._has("map");
+            var hasPolar = fullLayout._has("polar");
+            var hasSmith = fullLayout._has("smith");
+            var hasSankey = fullLayout._has("sankey");
+            var allAxesFixed = areAllAxesFixed(fullLayout);
+            var hasUnifiedHoverLabel = isUnifiedHover(fullLayout.hovermode);
+            var groups = [];
+            function addGroup(newGroup) {
+              if (!newGroup.length) return;
+              var out = [];
+              for (var i22 = 0; i22 < newGroup.length; i22++) {
+                var name2 = newGroup[i22];
+                var B22 = modeBarButtons[name2];
+                var v0 = B22.name.toLowerCase();
+                var v1 = (B22._cat || B22.name).toLowerCase();
+                var found = false;
+                for (var q2 = 0; q2 < buttonsToRemove.length; q2++) {
+                  var t4 = buttonsToRemove[q2].toLowerCase();
+                  if (t4 === v0 || t4 === v1) {
+                    found = true;
+                    break;
+                  }
+                }
+                if (found) continue;
+                out.push(modeBarButtons[name2]);
+              }
+              groups.push(out);
+            }
+            var commonGroup = ["toImage"];
+            if (context.showEditInChartStudio) commonGroup.push("editInChartStudio");
+            else if (context.showSendToCloud) commonGroup.push("sendDataToCloud");
+            addGroup(commonGroup);
+            var zoomGroup = [];
+            var hoverGroup = [];
+            var resetGroup = [];
+            var dragModeGroup = [];
+            if ((hasCartesian || hasPie || hasFunnelarea || hasTernary) + hasGeo + hasGL3D + hasMapbox + hasMap + hasPolar + hasSmith > 1) {
+              hoverGroup = ["toggleHover"];
+              resetGroup = ["resetViews"];
+            } else if (hasGeo) {
+              zoomGroup = ["zoomInGeo", "zoomOutGeo"];
+              hoverGroup = ["hoverClosestGeo"];
+              resetGroup = ["resetGeo"];
+            } else if (hasGL3D) {
+              hoverGroup = ["hoverClosest3d"];
+              resetGroup = ["resetCameraDefault3d", "resetCameraLastSave3d"];
+            } else if (hasMapbox) {
+              zoomGroup = ["zoomInMapbox", "zoomOutMapbox"];
+              hoverGroup = ["toggleHover"];
+              resetGroup = ["resetViewMapbox"];
+            } else if (hasMap) {
+              zoomGroup = ["zoomInMap", "zoomOutMap"];
+              hoverGroup = ["toggleHover"];
+              resetGroup = ["resetViewMap"];
+            } else if (hasPie) {
+              hoverGroup = ["hoverClosestPie"];
+            } else if (hasSankey) {
+              hoverGroup = ["hoverClosestCartesian", "hoverCompareCartesian"];
+              resetGroup = ["resetViewSankey"];
+            } else {
+              hoverGroup = ["toggleHover"];
+            }
+            if (hasCartesian) {
+              hoverGroup.push("toggleSpikelines", "hoverClosestCartesian", "hoverCompareCartesian");
+            }
+            if (hasNoHover(fullData) || hasUnifiedHoverLabel) {
+              hoverGroup = [];
+            }
+            if (hasCartesian && !allAxesFixed) {
+              zoomGroup = ["zoomIn2d", "zoomOut2d", "autoScale2d"];
+              if (resetGroup[0] !== "resetViews") resetGroup = ["resetScale2d"];
+            }
+            if (hasGL3D) {
+              dragModeGroup = ["zoom3d", "pan3d", "orbitRotation", "tableRotation"];
+            } else if (hasCartesian && !allAxesFixed || hasTernary) {
+              dragModeGroup = ["zoom2d", "pan2d"];
+            } else if (hasMapbox || hasMap || hasGeo) {
+              dragModeGroup = ["pan2d"];
+            } else if (hasPolar) {
+              dragModeGroup = ["zoom2d"];
+            }
+            if (isSelectable(fullData)) {
+              dragModeGroup.push("select2d", "lasso2d");
+            }
+            var enabledHoverGroup = [];
+            var enableHover = function(a2) {
+              if (enabledHoverGroup.indexOf(a2) !== -1) return;
+              if (hoverGroup.indexOf(a2) !== -1) {
+                enabledHoverGroup.push(a2);
+              }
+            };
+            if (Array.isArray(buttonsToAdd)) {
+              var newList = [];
+              for (var i2 = 0; i2 < buttonsToAdd.length; i2++) {
+                var b2 = buttonsToAdd[i2];
+                if (typeof b2 === "string") {
+                  b2 = b2.toLowerCase();
+                  if (DRAW_MODES.indexOf(b2) !== -1) {
+                    if (fullLayout._has("mapbox") || fullLayout._has("map") || // draw shapes in paper coordinate (could be improved in future to support data coordinate, when there is no pitch)
+                    fullLayout._has("cartesian")) {
+                      dragModeGroup.push(b2);
+                    }
+                  } else if (b2 === "togglespikelines") {
+                    enableHover("toggleSpikelines");
+                  } else if (b2 === "togglehover") {
+                    enableHover("toggleHover");
+                  } else if (b2 === "hovercompare") {
+                    enableHover("hoverCompareCartesian");
+                  } else if (b2 === "hoverclosest") {
+                    enableHover("hoverClosestCartesian");
+                    enableHover("hoverClosestGeo");
+                    enableHover("hoverClosest3d");
+                    enableHover("hoverClosestPie");
+                  } else if (b2 === "v1hovermode") {
+                    enableHover("hoverClosestCartesian");
+                    enableHover("hoverCompareCartesian");
+                    enableHover("hoverClosestGeo");
+                    enableHover("hoverClosest3d");
+                    enableHover("hoverClosestPie");
+                  }
+                } else newList.push(b2);
+              }
+              buttonsToAdd = newList;
+            }
+            addGroup(dragModeGroup);
+            addGroup(zoomGroup.concat(resetGroup));
+            addGroup(enabledHoverGroup);
+            return appendButtonsToGroups(groups, buttonsToAdd);
+          }
+          function areAllAxesFixed(fullLayout) {
+            var axList = axisIds.list({ _fullLayout: fullLayout }, null, true);
+            for (var i2 = 0; i2 < axList.length; i2++) {
+              var disabled = axList[i2].modebardisable;
+              if (!axList[i2].fixedrange && disabled !== "autoscale+zoominout" && disabled !== "zoominout+autoscale") {
+                return false;
+              }
+            }
+            return true;
+          }
+          function isSelectable(fullData) {
+            var selectable = false;
+            for (var i2 = 0; i2 < fullData.length; i2++) {
+              if (selectable) break;
+              var trace = fullData[i2];
+              if (!trace._module || !trace._module.selectPoints) continue;
+              if (Registry.traceIs(trace, "scatter-like")) {
+                if (scatterSubTypes.hasMarkers(trace) || scatterSubTypes.hasText(trace)) {
+                  selectable = true;
+                }
+              } else if (Registry.traceIs(trace, "box-violin")) {
+                if (trace.boxpoints === "all" || trace.points === "all") {
+                  selectable = true;
+                }
+              } else {
+                selectable = true;
+              }
+            }
+            return selectable;
+          }
+          function hasNoHover(fullData) {
+            for (var i2 = 0; i2 < fullData.length; i2++) {
+              if (!Registry.traceIs(fullData[i2], "noHover")) return false;
+            }
+            return true;
+          }
+          function appendButtonsToGroups(groups, buttons) {
+            if (buttons.length) {
+              if (Array.isArray(buttons[0])) {
+                for (var i2 = 0; i2 < buttons.length; i2++) {
+                  groups.push(buttons[i2]);
+                }
+              } else groups.push(buttons);
+            }
+            return groups;
+          }
+          function fillCustomButton(originalModeBarButtons) {
+            var customButtons = extendDeep([], originalModeBarButtons);
+            for (var i2 = 0; i2 < customButtons.length; i2++) {
+              var buttonGroup = customButtons[i2];
+              for (var j2 = 0; j2 < buttonGroup.length; j2++) {
+                var button = buttonGroup[j2];
+                if (typeof button === "string") {
+                  if (modeBarButtons[button] !== void 0) {
+                    customButtons[i2][j2] = modeBarButtons[button];
+                  } else {
+                    throw new Error([
+                      "*modeBarButtons* configuration options",
+                      "invalid button name"
+                    ].join(" "));
+                  }
+                }
+              }
+            }
+            return customButtons;
+          }
+        }
+      });
+      var require_modebar2 = __commonJS({
+        "src/components/modebar/index.js"(exports, module2) {
+          module2.exports = {
+            moduleType: "component",
+            name: "modebar",
+            layoutAttributes: require_attributes10(),
+            supplyLayoutDefaults: require_defaults5(),
+            manage: require_manage()
+          };
+        }
+      });
+      var require_scale_zoom = __commonJS({
+        "src/plots/cartesian/scale_zoom.js"(exports, module2) {
+          var FROM_BL = require_alignment().FROM_BL;
+          module2.exports = function scaleZoom(ax, factor, centerFraction) {
+            if (centerFraction === void 0) {
+              centerFraction = FROM_BL[ax.constraintoward || "center"];
+            }
+            var rangeLinear = [ax.r2l(ax.range[0]), ax.r2l(ax.range[1])];
+            var center = rangeLinear[0] + (rangeLinear[1] - rangeLinear[0]) * centerFraction;
+            ax.range = ax._input.range = [
+              ax.l2r(center + (rangeLinear[0] - center) * factor),
+              ax.l2r(center + (rangeLinear[1] - center) * factor)
+            ];
+            ax.setScale();
+          };
+        }
+      });
+      var require_constraints = __commonJS({
+        "src/plots/cartesian/constraints.js"(exports) {
+          var Lib = require_lib();
+          var autorange = require_autorange();
+          var id2name = require_axis_ids().id2name;
+          var layoutAttributes = require_layout_attributes4();
+          var scaleZoom = require_scale_zoom();
+          var setConvert = require_set_convert();
+          var ALMOST_EQUAL = require_numerical().ALMOST_EQUAL;
+          var FROM_BL = require_alignment().FROM_BL;
+          exports.handleDefaults = function(layoutIn, layoutOut, opts) {
+            var axIds = opts.axIds;
+            var axHasImage = opts.axHasImage;
+            var constraintGroups = layoutOut._axisConstraintGroups = [];
+            var matchGroups = layoutOut._axisMatchGroups = [];
+            var i2, group, axId, axName, axIn, axOut, attr, val;
+            for (i2 = 0; i2 < axIds.length; i2++) {
+              axName = id2name(axIds[i2]);
+              axIn = layoutIn[axName];
+              axOut = layoutOut[axName];
+              handleOneAxDefaults(axIn, axOut, {
+                axIds,
+                layoutOut,
+                hasImage: axHasImage[axName]
+              });
+            }
+            function stash(groups, stashAttr) {
+              for (i2 = 0; i2 < groups.length; i2++) {
+                group = groups[i2];
+                for (axId in group) {
+                  layoutOut[id2name(axId)][stashAttr] = group;
+                }
+              }
+            }
+            stash(matchGroups, "_matchGroup");
+            for (i2 = 0; i2 < constraintGroups.length; i2++) {
+              group = constraintGroups[i2];
+              for (axId in group) {
+                axOut = layoutOut[id2name(axId)];
+                if (axOut.fixedrange) {
+                  for (var axId2 in group) {
+                    var axName2 = id2name(axId2);
+                    if ((layoutIn[axName2] || {}).fixedrange === false) {
+                      Lib.warn(
+                        "fixedrange was specified as false for axis " + axName2 + " but was overridden because another axis in its constraint group has fixedrange true"
+                      );
+                    }
+                    layoutOut[axName2].fixedrange = true;
+                  }
+                  break;
+                }
+              }
+            }
+            i2 = 0;
+            while (i2 < constraintGroups.length) {
+              group = constraintGroups[i2];
+              for (axId in group) {
+                axOut = layoutOut[id2name(axId)];
+                if (axOut._matchGroup && Object.keys(axOut._matchGroup).length === Object.keys(group).length) {
+                  constraintGroups.splice(i2, 1);
+                  i2--;
+                }
+                break;
+              }
+              i2++;
+            }
+            stash(constraintGroups, "_constraintGroup");
+            var matchAttrs = [
+              "constrain",
+              "range",
+              "autorange",
+              "rangemode",
+              "rangebreaks",
+              "categoryorder",
+              "categoryarray"
+            ];
+            var hasRange = false;
+            var hasDayOfWeekBreaks = false;
+            function setAttrVal() {
+              val = axOut[attr];
+              if (attr === "rangebreaks") {
+                hasDayOfWeekBreaks = axOut._hasDayOfWeekBreaks;
+              }
+            }
+            for (i2 = 0; i2 < matchGroups.length; i2++) {
+              group = matchGroups[i2];
+              for (var j2 = 0; j2 < matchAttrs.length; j2++) {
+                attr = matchAttrs[j2];
+                val = null;
+                var baseAx;
+                for (axId in group) {
+                  axName = id2name(axId);
+                  axIn = layoutIn[axName];
+                  axOut = layoutOut[axName];
+                  if (!(attr in axOut)) {
+                    continue;
+                  }
+                  if (!axOut.matches) {
+                    baseAx = axOut;
+                    if (attr in axIn) {
+                      setAttrVal();
+                      break;
+                    }
+                  }
+                  if (val === null && attr in axIn) {
+                    setAttrVal();
+                  }
+                }
+                if (attr === "range" && val && axIn.range && axIn.range.length === 2 && axIn.range[0] !== null && axIn.range[1] !== null) {
+                  hasRange = true;
+                }
+                if (attr === "autorange" && val === null && hasRange) {
+                  val = false;
+                }
+                if (val === null && attr in baseAx) {
+                  val = baseAx[attr];
+                }
+                if (val !== null) {
+                  for (axId in group) {
+                    axOut = layoutOut[id2name(axId)];
+                    axOut[attr] = attr === "range" ? val.slice() : val;
+                    if (attr === "rangebreaks") {
+                      axOut._hasDayOfWeekBreaks = hasDayOfWeekBreaks;
+                      setConvert(axOut, layoutOut);
+                    }
+                  }
+                }
+              }
+            }
+          };
+          function handleOneAxDefaults(axIn, axOut, opts) {
+            var axIds = opts.axIds;
+            var layoutOut = opts.layoutOut;
+            var hasImage = opts.hasImage;
+            var constraintGroups = layoutOut._axisConstraintGroups;
+            var matchGroups = layoutOut._axisMatchGroups;
+            var axId = axOut._id;
+            var axLetter = axId.charAt(0);
+            var splomStash = ((layoutOut._splomAxes || {})[axLetter] || {})[axId] || {};
+            var thisID = axOut._id;
+            var isX = thisID.charAt(0) === "x";
+            axOut._matchGroup = null;
+            axOut._constraintGroup = null;
+            function coerce(attr, dflt) {
+              return Lib.coerce(axIn, axOut, layoutAttributes, attr, dflt);
+            }
+            coerce("constrain", hasImage ? "domain" : "range");
+            Lib.coerce(axIn, axOut, {
+              constraintoward: {
+                valType: "enumerated",
+                values: isX ? ["left", "center", "right"] : ["bottom", "middle", "top"],
+                dflt: isX ? "center" : "middle"
+              }
+            }, "constraintoward");
+            var thisType = axOut.type;
+            var i2, idi;
+            var linkableAxes = [];
+            for (i2 = 0; i2 < axIds.length; i2++) {
+              idi = axIds[i2];
+              if (idi === thisID) continue;
+              var axi = layoutOut[id2name(idi)];
+              if (axi.type === thisType) {
+                linkableAxes.push(idi);
+              }
+            }
+            var thisGroup = getConstraintGroup(constraintGroups, thisID);
+            if (thisGroup) {
+              var linkableAxesNoLoops = [];
+              for (i2 = 0; i2 < linkableAxes.length; i2++) {
+                idi = linkableAxes[i2];
+                if (!thisGroup[idi]) linkableAxesNoLoops.push(idi);
+              }
+              linkableAxes = linkableAxesNoLoops;
+            }
+            var canLink = linkableAxes.length;
+            var matches2, scaleanchor;
+            if (canLink && (axIn.matches || splomStash.matches)) {
+              matches2 = Lib.coerce(axIn, axOut, {
+                matches: {
+                  valType: "enumerated",
+                  values: linkableAxes,
+                  dflt: linkableAxes.indexOf(splomStash.matches) !== -1 ? splomStash.matches : void 0
+                }
+              }, "matches");
+            }
+            var scaleanchorDflt = hasImage && !isX ? axOut.anchor : void 0;
+            if (canLink && !matches2 && (axIn.scaleanchor || scaleanchorDflt)) {
+              scaleanchor = Lib.coerce(axIn, axOut, {
+                scaleanchor: {
+                  valType: "enumerated",
+                  values: linkableAxes.concat([false])
+                }
+              }, "scaleanchor", scaleanchorDflt);
+            }
+            if (matches2) {
+              axOut._matchGroup = updateConstraintGroups(matchGroups, thisID, matches2, 1);
+              var matchedAx = layoutOut[id2name(matches2)];
+              var matchRatio = extent(layoutOut, axOut) / extent(layoutOut, matchedAx);
+              if (isX !== (matches2.charAt(0) === "x")) {
+                matchRatio = (isX ? "x" : "y") + matchRatio;
+              }
+              updateConstraintGroups(constraintGroups, thisID, matches2, matchRatio);
+            } else if (axIn.matches && axIds.indexOf(axIn.matches) !== -1) {
+              Lib.warn("ignored " + axOut._name + '.matches: "' + axIn.matches + '" to avoid an infinite loop');
+            }
+            if (scaleanchor) {
+              var scaleratio = coerce("scaleratio");
+              if (!scaleratio) scaleratio = axOut.scaleratio = 1;
+              updateConstraintGroups(constraintGroups, thisID, scaleanchor, scaleratio);
+            } else if (axIn.scaleanchor && axIds.indexOf(axIn.scaleanchor) !== -1) {
+              Lib.warn("ignored " + axOut._name + '.scaleanchor: "' + axIn.scaleanchor + '" to avoid either an infinite loop and possibly inconsistent scaleratios, or because this axis declares a *matches* constraint.');
+            }
+          }
+          function extent(layoutOut, ax) {
+            var domain = ax.domain;
+            if (!domain) {
+              domain = layoutOut[id2name(ax.overlaying)].domain;
+            }
+            return domain[1] - domain[0];
+          }
+          function getConstraintGroup(groups, thisID) {
+            for (var i2 = 0; i2 < groups.length; i2++) {
+              if (groups[i2][thisID]) {
+                return groups[i2];
+              }
+            }
+            return null;
+          }
+          function updateConstraintGroups(constraintGroups, thisID, thatID, scaleratio) {
+            var i2, j2, groupi, keyj, thisGroupIndex;
+            var thisGroup = getConstraintGroup(constraintGroups, thisID);
+            if (thisGroup === null) {
+              thisGroup = {};
+              thisGroup[thisID] = 1;
+              thisGroupIndex = constraintGroups.length;
+              constraintGroups.push(thisGroup);
+            } else {
+              thisGroupIndex = constraintGroups.indexOf(thisGroup);
+            }
+            var thisGroupKeys = Object.keys(thisGroup);
+            for (i2 = 0; i2 < constraintGroups.length; i2++) {
+              groupi = constraintGroups[i2];
+              if (i2 !== thisGroupIndex && groupi[thatID]) {
+                var baseScale = groupi[thatID];
+                for (j2 = 0; j2 < thisGroupKeys.length; j2++) {
+                  keyj = thisGroupKeys[j2];
+                  groupi[keyj] = multiplyScales(baseScale, multiplyScales(scaleratio, thisGroup[keyj]));
+                }
+                constraintGroups.splice(thisGroupIndex, 1);
+                return;
+              }
+            }
+            if (scaleratio !== 1) {
+              for (j2 = 0; j2 < thisGroupKeys.length; j2++) {
+                var key = thisGroupKeys[j2];
+                thisGroup[key] = multiplyScales(scaleratio, thisGroup[key]);
+              }
+            }
+            thisGroup[thatID] = 1;
+          }
+          function multiplyScales(a2, b2) {
+            var aPrefix = "";
+            var bPrefix = "";
+            var aLen, bLen;
+            if (typeof a2 === "string") {
+              aPrefix = a2.match(/^[xy]*/)[0];
+              aLen = aPrefix.length;
+              a2 = +a2.slice(aLen);
+            }
+            if (typeof b2 === "string") {
+              bPrefix = b2.match(/^[xy]*/)[0];
+              bLen = bPrefix.length;
+              b2 = +b2.slice(bLen);
+            }
+            var c2 = a2 * b2;
+            if (!aLen && !bLen) {
+              return c2;
+            }
+            if (!aLen || !bLen || aPrefix.charAt(0) === bPrefix.charAt(0)) {
+              return aPrefix + bPrefix + a2 * b2;
+            }
+            if (aLen === bLen) {
+              return c2;
+            }
+            return (aLen > bLen ? aPrefix.slice(bLen) : bPrefix.slice(aLen)) + c2;
+          }
+          function finalRatios(group, fullLayout) {
+            var size = fullLayout._size;
+            var yRatio = size.h / size.w;
+            var out = {};
+            var keys = Object.keys(group);
+            for (var i2 = 0; i2 < keys.length; i2++) {
+              var key = keys[i2];
+              var val = group[key];
+              if (typeof val === "string") {
+                var prefix = val.match(/^[xy]*/)[0];
+                var pLen = prefix.length;
+                val = +val.slice(pLen);
+                var mult = prefix.charAt(0) === "y" ? yRatio : 1 / yRatio;
+                for (var j2 = 0; j2 < pLen; j2++) {
+                  val *= mult;
+                }
+              }
+              out[key] = val;
+            }
+            return out;
+          }
+          exports.enforce = function enforce(gd2) {
+            var fullLayout = gd2._fullLayout;
+            var constraintGroups = fullLayout._axisConstraintGroups || [];
+            var i2, j2, group, axisID, ax, normScale, mode, factor;
+            for (i2 = 0; i2 < constraintGroups.length; i2++) {
+              group = finalRatios(constraintGroups[i2], fullLayout);
+              var axisIDs = Object.keys(group);
+              var minScale = Infinity;
+              var maxScale = 0;
+              var matchScale = Infinity;
+              var normScales = {};
+              var axes = {};
+              var hasAnyDomainConstraint = false;
+              for (j2 = 0; j2 < axisIDs.length; j2++) {
+                axisID = axisIDs[j2];
+                axes[axisID] = ax = fullLayout[id2name(axisID)];
+                if (ax._inputDomain) ax.domain = ax._inputDomain.slice();
+                else ax._inputDomain = ax.domain.slice();
+                if (!ax._inputRange) ax._inputRange = ax.range.slice();
+                ax.setScale();
+                normScales[axisID] = normScale = Math.abs(ax._m) / group[axisID];
+                minScale = Math.min(minScale, normScale);
+                if (ax.constrain === "domain" || !ax._constraintShrinkable) {
+                  matchScale = Math.min(matchScale, normScale);
+                }
+                delete ax._constraintShrinkable;
+                maxScale = Math.max(maxScale, normScale);
+                if (ax.constrain === "domain") hasAnyDomainConstraint = true;
+              }
+              if (minScale > ALMOST_EQUAL * maxScale && !hasAnyDomainConstraint) continue;
+              for (j2 = 0; j2 < axisIDs.length; j2++) {
+                axisID = axisIDs[j2];
+                normScale = normScales[axisID];
+                ax = axes[axisID];
+                mode = ax.constrain;
+                if (normScale !== matchScale || mode === "domain") {
+                  factor = normScale / matchScale;
+                  if (mode === "range") {
+                    scaleZoom(ax, factor);
+                  } else {
+                    var inputDomain = ax._inputDomain;
+                    var domainShrunk = (ax.domain[1] - ax.domain[0]) / (inputDomain[1] - inputDomain[0]);
+                    var rangeShrunk = (ax.r2l(ax.range[1]) - ax.r2l(ax.range[0])) / (ax.r2l(ax._inputRange[1]) - ax.r2l(ax._inputRange[0]));
+                    factor /= domainShrunk;
+                    if (factor * rangeShrunk < 1) {
+                      ax.domain = ax._input.domain = inputDomain.slice();
+                      scaleZoom(ax, factor);
+                      continue;
+                    }
+                    if (rangeShrunk < 1) {
+                      ax.range = ax._input.range = ax._inputRange.slice();
+                      factor *= rangeShrunk;
+                    }
+                    if (ax.autorange) {
+                      var rl0 = ax.r2l(ax.range[0]);
+                      var rl1 = ax.r2l(ax.range[1]);
+                      var rangeCenter = (rl0 + rl1) / 2;
+                      var rangeMin = rangeCenter;
+                      var rangeMax = rangeCenter;
+                      var halfRange = Math.abs(rl1 - rangeCenter);
+                      var outerMin = rangeCenter - halfRange * factor * 1.0001;
+                      var outerMax = rangeCenter + halfRange * factor * 1.0001;
+                      var getPadMin = autorange.makePadFn(fullLayout, ax, 0);
+                      var getPadMax = autorange.makePadFn(fullLayout, ax, 1);
+                      updateDomain(ax, factor);
+                      var m2 = Math.abs(ax._m);
+                      var extremes = autorange.concatExtremes(gd2, ax);
+                      var minArray = extremes.min;
+                      var maxArray = extremes.max;
+                      var newVal;
+                      var k2;
+                      for (k2 = 0; k2 < minArray.length; k2++) {
+                        newVal = minArray[k2].val - getPadMin(minArray[k2]) / m2;
+                        if (newVal > outerMin && newVal < rangeMin) {
+                          rangeMin = newVal;
+                        }
+                      }
+                      for (k2 = 0; k2 < maxArray.length; k2++) {
+                        newVal = maxArray[k2].val + getPadMax(maxArray[k2]) / m2;
+                        if (newVal < outerMax && newVal > rangeMax) {
+                          rangeMax = newVal;
+                        }
+                      }
+                      var domainExpand = (rangeMax - rangeMin) / (2 * halfRange);
+                      factor /= domainExpand;
+                      rangeMin = ax.l2r(rangeMin);
+                      rangeMax = ax.l2r(rangeMax);
+                      ax.range = ax._input.range = rl0 < rl1 ? [rangeMin, rangeMax] : [rangeMax, rangeMin];
+                    }
+                    updateDomain(ax, factor);
+                  }
+                }
+              }
+            }
+          };
+          exports.getAxisGroup = function getAxisGroup(fullLayout, axId) {
+            var matchGroups = fullLayout._axisMatchGroups;
+            for (var i2 = 0; i2 < matchGroups.length; i2++) {
+              var group = matchGroups[i2];
+              if (group[axId]) return "g" + i2;
+            }
+            return axId;
+          };
+          exports.clean = function clean(gd2, ax) {
+            if (ax._inputDomain) {
+              var isConstrained = false;
+              var axId = ax._id;
+              var constraintGroups = gd2._fullLayout._axisConstraintGroups;
+              for (var j2 = 0; j2 < constraintGroups.length; j2++) {
+                if (constraintGroups[j2][axId]) {
+                  isConstrained = true;
+                  break;
+                }
+              }
+              if (!isConstrained || ax.constrain !== "domain") {
+                ax._input.domain = ax.domain = ax._inputDomain;
+                delete ax._inputDomain;
+              }
+            }
+          };
+          function updateDomain(ax, factor) {
+            var inputDomain = ax._inputDomain;
+            var centerFraction = FROM_BL[ax.constraintoward];
+            var center = inputDomain[0] + (inputDomain[1] - inputDomain[0]) * centerFraction;
+            ax.domain = ax._input.domain = [
+              center + (inputDomain[0] - center) / factor,
+              center + (inputDomain[1] - center) / factor
+            ];
+            ax.setScale();
+          }
+        }
+      });
+      var require_subroutines = __commonJS({
+        "src/plot_api/subroutines.js"(exports) {
+          var d3 = require_d3();
+          var Registry = require_registry();
+          var Plots = require_plots();
+          var Lib = require_lib();
+          var svgTextUtils = require_svg_text_utils();
+          var clearGlCanvases = require_clear_gl_canvases();
+          var Color2 = require_color();
+          var Drawing = require_drawing();
+          var Titles = require_titles();
+          var ModeBar = require_modebar2();
+          var Axes = require_axes();
+          var alignmentConstants = require_alignment();
+          var axisConstraints = require_constraints();
+          var enforceAxisConstraints = axisConstraints.enforce;
+          var cleanAxisConstraints = axisConstraints.clean;
+          var doAutoRange = require_autorange().doAutoRange;
+          var SVG_TEXT_ANCHOR_START = "start";
+          var SVG_TEXT_ANCHOR_MIDDLE = "middle";
+          var SVG_TEXT_ANCHOR_END = "end";
+          var zindexSeparator = require_constants2().zindexSeparator;
+          exports.layoutStyles = function(gd2) {
+            return Lib.syncOrAsync([Plots.doAutoMargin, lsInner], gd2);
+          };
+          function overlappingDomain(xDomain, yDomain, domains) {
+            for (var i2 = 0; i2 < domains.length; i2++) {
+              var existingX = domains[i2][0];
+              var existingY = domains[i2][1];
+              if (existingX[0] >= xDomain[1] || existingX[1] <= xDomain[0]) {
+                continue;
+              }
+              if (existingY[0] < yDomain[1] && existingY[1] > yDomain[0]) {
+                return true;
+              }
+            }
+            return false;
+          }
+          function lsInner(gd2) {
+            var fullLayout = gd2._fullLayout;
+            var gs = fullLayout._size;
+            var pad = gs.p;
+            var axList = Axes.list(gd2, "", true);
+            var i2, subplot, plotinfo, ax, xa, ya2;
+            fullLayout._paperdiv.style({
+              width: gd2._context.responsive && fullLayout.autosize && !gd2._context._hasZeroWidth && !gd2.layout.width ? "100%" : fullLayout.width + "px",
+              height: gd2._context.responsive && fullLayout.autosize && !gd2._context._hasZeroHeight && !gd2.layout.height ? "100%" : fullLayout.height + "px"
+            }).selectAll(".main-svg").call(Drawing.setSize, fullLayout.width, fullLayout.height);
+            gd2._context.setBackground(gd2, fullLayout.paper_bgcolor);
+            exports.drawMainTitle(gd2);
+            ModeBar.manage(gd2);
+            if (!fullLayout._has("cartesian")) {
+              return Plots.previousPromises(gd2);
+            }
+            function getLinePosition(ax2, counterAx2, side) {
+              var lwHalf = ax2._lw / 2;
+              if (ax2._id.charAt(0) === "x") {
+                if (!counterAx2) return gs.t + gs.h * (1 - (ax2.position || 0)) + lwHalf % 1;
+                else if (side === "top") return counterAx2._offset - pad - lwHalf;
+                return counterAx2._offset + counterAx2._length + pad + lwHalf;
+              }
+              if (!counterAx2) return gs.l + gs.w * (ax2.position || 0) + lwHalf % 1;
+              else if (side === "right") return counterAx2._offset + counterAx2._length + pad + lwHalf;
+              return counterAx2._offset - pad - lwHalf;
+            }
+            for (i2 = 0; i2 < axList.length; i2++) {
+              ax = axList[i2];
+              var counterAx = ax._anchorAxis;
+              ax._linepositions = {};
+              ax._lw = Drawing.crispRound(gd2, ax.linewidth, 1);
+              ax._mainLinePosition = getLinePosition(ax, counterAx, ax.side);
+              ax._mainMirrorPosition = ax.mirror && counterAx ? getLinePosition(
+                ax,
+                counterAx,
+                alignmentConstants.OPPOSITE_SIDE[ax.side]
+              ) : null;
+            }
+            var lowerBackgroundIDs = [];
+            var backgroundIds = [];
+            var lowerDomains = [];
+            var noNeedForBg = Color2.opacity(fullLayout.paper_bgcolor) === 1 && Color2.opacity(fullLayout.plot_bgcolor) === 1 && fullLayout.paper_bgcolor === fullLayout.plot_bgcolor;
+            for (subplot in fullLayout._plots) {
+              plotinfo = fullLayout._plots[subplot];
+              if (plotinfo.mainplot) {
+                if (plotinfo.bg) {
+                  plotinfo.bg.remove();
+                }
+                plotinfo.bg = void 0;
+              } else {
+                var xDomain = plotinfo.xaxis.domain;
+                var yDomain = plotinfo.yaxis.domain;
+                var plotgroup = plotinfo.plotgroup;
+                if (overlappingDomain(xDomain, yDomain, lowerDomains) && subplot.indexOf(zindexSeparator) === -1) {
+                  var pgNode = plotgroup.node();
+                  var plotgroupBg = plotinfo.bg = Lib.ensureSingle(plotgroup, "rect", "bg");
+                  pgNode.insertBefore(plotgroupBg.node(), pgNode.childNodes[0]);
+                  backgroundIds.push(subplot);
+                } else {
+                  plotgroup.select("rect.bg").remove();
+                  lowerDomains.push([xDomain, yDomain]);
+                  if (!noNeedForBg) {
+                    lowerBackgroundIDs.push(subplot);
+                    backgroundIds.push(subplot);
+                  }
+                }
+              }
+            }
+            var lowerBackgrounds = fullLayout._bgLayer.selectAll(".bg").data(lowerBackgroundIDs);
+            lowerBackgrounds.enter().append("rect").classed("bg", true);
+            lowerBackgrounds.exit().remove();
+            lowerBackgrounds.each(function(subplot2) {
+              fullLayout._plots[subplot2].bg = d3.select(this);
+            });
+            for (i2 = 0; i2 < backgroundIds.length; i2++) {
+              plotinfo = fullLayout._plots[backgroundIds[i2]];
+              xa = plotinfo.xaxis;
+              ya2 = plotinfo.yaxis;
+              if (plotinfo.bg && xa._offset !== void 0 && ya2._offset !== void 0) {
+                plotinfo.bg.call(
+                  Drawing.setRect,
+                  xa._offset - pad,
+                  ya2._offset - pad,
+                  xa._length + 2 * pad,
+                  ya2._length + 2 * pad
+                ).call(Color2.fill, fullLayout.plot_bgcolor).style("stroke-width", 0);
+              }
+            }
+            if (!fullLayout._hasOnlyLargeSploms) {
+              for (subplot in fullLayout._plots) {
+                plotinfo = fullLayout._plots[subplot];
+                xa = plotinfo.xaxis;
+                ya2 = plotinfo.yaxis;
+                var clipId = plotinfo.clipId = "clip" + fullLayout._uid + subplot + "plot";
+                var plotClip = Lib.ensureSingleById(fullLayout._clips, "clipPath", clipId, function(s2) {
+                  s2.classed("plotclip", true).append("rect");
+                });
+                plotinfo.clipRect = plotClip.select("rect").attr({
+                  width: xa._length,
+                  height: ya2._length
+                });
+                Drawing.setTranslate(plotinfo.plot, xa._offset, ya2._offset);
+                var plotClipId;
+                var layerClipId;
+                if (plotinfo._hasClipOnAxisFalse) {
+                  plotClipId = null;
+                  layerClipId = clipId;
+                } else {
+                  plotClipId = clipId;
+                  layerClipId = null;
+                }
+                Drawing.setClipUrl(plotinfo.plot, plotClipId, gd2);
+                plotinfo.layerClipId = layerClipId;
+              }
+            }
+            var xLinesXLeft, xLinesXRight, xLinesYBottom, xLinesYTop, leftYLineWidth, rightYLineWidth;
+            var yLinesYBottom, yLinesYTop, yLinesXLeft, yLinesXRight, connectYBottom, connectYTop;
+            var extraSubplot;
+            function xLinePath(y2) {
+              return "M" + xLinesXLeft + "," + y2 + "H" + xLinesXRight;
+            }
+            function xLinePathFree(y2) {
+              return "M" + xa._offset + "," + y2 + "h" + xa._length;
+            }
+            function yLinePath(x2) {
+              return "M" + x2 + "," + yLinesYTop + "V" + yLinesYBottom;
+            }
+            function yLinePathFree(x2) {
+              if (ya2._shift !== void 0) {
+                x2 += ya2._shift;
+              }
+              return "M" + x2 + "," + ya2._offset + "v" + ya2._length;
+            }
+            function mainPath(ax2, pathFn, pathFnFree) {
+              if (!ax2.showline || subplot !== ax2._mainSubplot) return "";
+              if (!ax2._anchorAxis) return pathFnFree(ax2._mainLinePosition);
+              var out = pathFn(ax2._mainLinePosition);
+              if (ax2.mirror) out += pathFn(ax2._mainMirrorPosition);
+              return out;
+            }
+            for (subplot in fullLayout._plots) {
+              plotinfo = fullLayout._plots[subplot];
+              xa = plotinfo.xaxis;
+              ya2 = plotinfo.yaxis;
+              var xPath = "M0,0";
+              if (shouldShowLinesOrTicks(xa, subplot)) {
+                leftYLineWidth = findCounterAxisLineWidth(xa, "left", ya2, axList);
+                xLinesXLeft = xa._offset - (leftYLineWidth ? pad + leftYLineWidth : 0);
+                rightYLineWidth = findCounterAxisLineWidth(xa, "right", ya2, axList);
+                xLinesXRight = xa._offset + xa._length + (rightYLineWidth ? pad + rightYLineWidth : 0);
+                xLinesYBottom = getLinePosition(xa, ya2, "bottom");
+                xLinesYTop = getLinePosition(xa, ya2, "top");
+                extraSubplot = !xa._anchorAxis || subplot !== xa._mainSubplot;
+                if (extraSubplot && (xa.mirror === "allticks" || xa.mirror === "all")) {
+                  xa._linepositions[subplot] = [xLinesYBottom, xLinesYTop];
+                }
+                xPath = mainPath(xa, xLinePath, xLinePathFree);
+                if (extraSubplot && xa.showline && (xa.mirror === "all" || xa.mirror === "allticks")) {
+                  xPath += xLinePath(xLinesYBottom) + xLinePath(xLinesYTop);
+                }
+                plotinfo.xlines.style("stroke-width", xa._lw + "px").call(Color2.stroke, xa.showline ? xa.linecolor : "rgba(0,0,0,0)");
+              }
+              plotinfo.xlines.attr("d", xPath);
+              var yPath = "M0,0";
+              if (shouldShowLinesOrTicks(ya2, subplot)) {
+                connectYBottom = findCounterAxisLineWidth(ya2, "bottom", xa, axList);
+                yLinesYBottom = ya2._offset + ya2._length + (connectYBottom ? pad : 0);
+                connectYTop = findCounterAxisLineWidth(ya2, "top", xa, axList);
+                yLinesYTop = ya2._offset - (connectYTop ? pad : 0);
+                yLinesXLeft = getLinePosition(ya2, xa, "left");
+                yLinesXRight = getLinePosition(ya2, xa, "right");
+                extraSubplot = !ya2._anchorAxis || subplot !== ya2._mainSubplot;
+                if (extraSubplot && (ya2.mirror === "allticks" || ya2.mirror === "all")) {
+                  ya2._linepositions[subplot] = [yLinesXLeft, yLinesXRight];
+                }
+                yPath = mainPath(ya2, yLinePath, yLinePathFree);
+                if (extraSubplot && ya2.showline && (ya2.mirror === "all" || ya2.mirror === "allticks")) {
+                  yPath += yLinePath(yLinesXLeft) + yLinePath(yLinesXRight);
+                }
+                plotinfo.ylines.style("stroke-width", ya2._lw + "px").call(Color2.stroke, ya2.showline ? ya2.linecolor : "rgba(0,0,0,0)");
+              }
+              plotinfo.ylines.attr("d", yPath);
+            }
+            Axes.makeClipPaths(gd2);
+            return Plots.previousPromises(gd2);
+          }
+          function shouldShowLinesOrTicks(ax, subplot) {
+            return (ax.ticks || ax.showline) && (subplot === ax._mainSubplot || ax.mirror === "all" || ax.mirror === "allticks");
+          }
+          function shouldShowLineThisSide(ax, side, counterAx) {
+            if (!counterAx.showline || !counterAx._lw) return false;
+            if (counterAx.mirror === "all" || counterAx.mirror === "allticks") return true;
+            var anchorAx = counterAx._anchorAxis;
+            if (!anchorAx) return false;
+            var sideIndex = alignmentConstants.FROM_BL[side];
+            if (counterAx.side === side) {
+              return anchorAx.domain[sideIndex] === ax.domain[sideIndex];
+            }
+            return counterAx.mirror && anchorAx.domain[1 - sideIndex] === ax.domain[1 - sideIndex];
+          }
+          function findCounterAxisLineWidth(ax, side, counterAx, axList) {
+            if (shouldShowLineThisSide(ax, side, counterAx)) {
+              return counterAx._lw;
+            }
+            for (var i2 = 0; i2 < axList.length; i2++) {
+              var axi = axList[i2];
+              if (axi._mainAxis === counterAx._mainAxis && shouldShowLineThisSide(ax, side, axi)) {
+                return axi._lw;
+              }
+            }
+            return 0;
+          }
+          exports.drawMainTitle = function(gd2) {
+            var title = gd2._fullLayout.title;
+            var fullLayout = gd2._fullLayout;
+            var textAnchor = getMainTitleTextAnchor(fullLayout);
+            var dy = getMainTitleDy(fullLayout);
+            var y2 = getMainTitleY(fullLayout, dy);
+            var x2 = getMainTitleX(fullLayout, textAnchor);
+            Titles.draw(gd2, "gtitle", {
+              propContainer: fullLayout,
+              propName: "title.text",
+              subtitlePropName: "title.subtitle.text",
+              placeholder: fullLayout._dfltTitle.plot,
+              subtitlePlaceholder: fullLayout._dfltTitle.subtitle,
+              attributes: {
+                x: x2,
+                y: y2,
+                "text-anchor": textAnchor,
+                dy
+              }
+            });
+            if (title.text && title.automargin) {
+              var titleObj = d3.select(gd2).selectAll(".gtitle");
+              var titleHeight = Drawing.bBox(d3.select(gd2).selectAll(".g-gtitle").node()).height;
+              var pushMargin = needsMarginPush(gd2, title, titleHeight);
+              if (pushMargin > 0) {
+                applyTitleAutoMargin(gd2, y2, pushMargin, titleHeight);
+                titleObj.attr({
+                  x: x2,
+                  y: y2,
+                  "text-anchor": textAnchor,
+                  dy: getMainTitleDyAdj(title.yanchor)
+                }).call(svgTextUtils.positionText, x2, y2);
+                var extraLines = (title.text.match(svgTextUtils.BR_TAG_ALL) || []).length;
+                if (extraLines) {
+                  var delta = alignmentConstants.LINE_SPACING * extraLines + alignmentConstants.MID_SHIFT;
+                  if (title.y === 0) {
+                    delta = -delta;
+                  }
+                  titleObj.selectAll(".line").each(function() {
+                    var newDy = +this.getAttribute("dy").slice(0, -2) - delta + "em";
+                    this.setAttribute("dy", newDy);
+                  });
+                }
+                var subtitleObj = d3.select(gd2).selectAll(".gtitle-subtitle");
+                if (subtitleObj.node()) {
+                  var titleBB = titleObj.node().getBBox();
+                  var titleBottom = titleBB.y + titleBB.height;
+                  var subtitleY = titleBottom + Titles.SUBTITLE_PADDING_EM * title.subtitle.font.size;
+                  subtitleObj.attr({
+                    x: x2,
+                    y: subtitleY,
+                    "text-anchor": textAnchor,
+                    dy: getMainTitleDyAdj(title.yanchor)
+                  }).call(svgTextUtils.positionText, x2, subtitleY);
+                }
+              }
+            }
+          };
+          function isOutsideContainer(gd2, title, position, y2, titleHeight) {
+            var plotHeight = title.yref === "paper" ? gd2._fullLayout._size.h : gd2._fullLayout.height;
+            var yPosTop = Lib.isTopAnchor(title) ? y2 : y2 - titleHeight;
+            var yPosRel = position === "b" ? plotHeight - yPosTop : yPosTop;
+            if (Lib.isTopAnchor(title) && position === "t" || Lib.isBottomAnchor(title) && position === "b") {
+              return false;
+            } else {
+              return yPosRel < titleHeight;
+            }
+          }
+          function containerPushVal(position, titleY, titleYanchor, height, titleDepth) {
+            var push = 0;
+            if (titleYanchor === "middle") {
+              push += titleDepth / 2;
+            }
+            if (position === "t") {
+              if (titleYanchor === "top") {
+                push += titleDepth;
+              }
+              push += height - titleY * height;
+            } else {
+              if (titleYanchor === "bottom") {
+                push += titleDepth;
+              }
+              push += titleY * height;
+            }
+            return push;
+          }
+          function needsMarginPush(gd2, title, titleHeight) {
+            var titleY = title.y;
+            var titleYanchor = title.yanchor;
+            var position = titleY > 0.5 ? "t" : "b";
+            var curMargin = gd2._fullLayout.margin[position];
+            var pushMargin = 0;
+            if (title.yref === "paper") {
+              pushMargin = titleHeight + title.pad.t + title.pad.b;
+            } else if (title.yref === "container") {
+              pushMargin = containerPushVal(position, titleY, titleYanchor, gd2._fullLayout.height, titleHeight) + title.pad.t + title.pad.b;
+            }
+            if (pushMargin > curMargin) {
+              return pushMargin;
+            }
+            return 0;
+          }
+          function applyTitleAutoMargin(gd2, y2, pushMargin, titleHeight) {
+            var titleID = "title.automargin";
+            var title = gd2._fullLayout.title;
+            var position = title.y > 0.5 ? "t" : "b";
+            var push = {
+              x: title.x,
+              y: title.y,
+              t: 0,
+              b: 0
+            };
+            var reservedPush = {};
+            if (title.yref === "paper" && isOutsideContainer(gd2, title, position, y2, titleHeight)) {
+              push[position] = pushMargin;
+            } else if (title.yref === "container") {
+              reservedPush[position] = pushMargin;
+              gd2._fullLayout._reservedMargin[titleID] = reservedPush;
+            }
+            Plots.allowAutoMargin(gd2, titleID);
+            Plots.autoMargin(gd2, titleID, push);
+          }
+          function getMainTitleX(fullLayout, textAnchor) {
+            var title = fullLayout.title;
+            var gs = fullLayout._size;
+            var hPadShift = 0;
+            if (textAnchor === SVG_TEXT_ANCHOR_START) {
+              hPadShift = title.pad.l;
+            } else if (textAnchor === SVG_TEXT_ANCHOR_END) {
+              hPadShift = -title.pad.r;
+            }
+            switch (title.xref) {
+              case "paper":
+                return gs.l + gs.w * title.x + hPadShift;
+              case "container":
+              default:
+                return fullLayout.width * title.x + hPadShift;
+            }
+          }
+          function getMainTitleY(fullLayout, dy) {
+            var title = fullLayout.title;
+            var gs = fullLayout._size;
+            var vPadShift = 0;
+            if (dy === "0em" || !dy) {
+              vPadShift = -title.pad.b;
+            } else if (dy === alignmentConstants.CAP_SHIFT + "em") {
+              vPadShift = title.pad.t;
+            }
+            if (title.y === "auto") {
+              return gs.t / 2;
+            } else {
+              switch (title.yref) {
+                case "paper":
+                  return gs.t + gs.h - gs.h * title.y + vPadShift;
+                case "container":
+                default:
+                  return fullLayout.height - fullLayout.height * title.y + vPadShift;
+              }
+            }
+          }
+          function getMainTitleDyAdj(yanchor) {
+            if (yanchor === "top") {
+              return alignmentConstants.CAP_SHIFT + 0.3 + "em";
+            } else if (yanchor === "bottom") {
+              return "-0.3em";
+            } else {
+              return alignmentConstants.MID_SHIFT + "em";
+            }
+          }
+          function getMainTitleTextAnchor(fullLayout) {
+            var title = fullLayout.title;
+            var textAnchor = SVG_TEXT_ANCHOR_MIDDLE;
+            if (Lib.isRightAnchor(title)) {
+              textAnchor = SVG_TEXT_ANCHOR_END;
+            } else if (Lib.isLeftAnchor(title)) {
+              textAnchor = SVG_TEXT_ANCHOR_START;
+            }
+            return textAnchor;
+          }
+          function getMainTitleDy(fullLayout) {
+            var title = fullLayout.title;
+            var dy = "0em";
+            if (Lib.isTopAnchor(title)) {
+              dy = alignmentConstants.CAP_SHIFT + "em";
+            } else if (Lib.isMiddleAnchor(title)) {
+              dy = alignmentConstants.MID_SHIFT + "em";
+            }
+            return dy;
+          }
+          exports.doTraceStyle = function(gd2) {
+            var calcdata = gd2.calcdata;
+            var editStyleCalls = [];
+            var i2;
+            for (i2 = 0; i2 < calcdata.length; i2++) {
+              var cd2 = calcdata[i2];
+              var cd0 = cd2[0] || {};
+              var trace = cd0.trace || {};
+              var _module = trace._module || {};
+              var arraysToCalcdata = _module.arraysToCalcdata;
+              if (arraysToCalcdata) arraysToCalcdata(cd2, trace);
+              var editStyle = _module.editStyle;
+              if (editStyle) editStyleCalls.push({ fn: editStyle, cd0 });
+            }
+            if (editStyleCalls.length) {
+              for (i2 = 0; i2 < editStyleCalls.length; i2++) {
+                var edit = editStyleCalls[i2];
+                edit.fn(gd2, edit.cd0);
+              }
+              clearGlCanvases(gd2);
+              exports.redrawReglTraces(gd2);
+            }
+            Plots.style(gd2);
+            Registry.getComponentMethod("legend", "draw")(gd2);
+            return Plots.previousPromises(gd2);
+          };
+          exports.doColorBars = function(gd2) {
+            Registry.getComponentMethod("colorbar", "draw")(gd2);
+            return Plots.previousPromises(gd2);
+          };
+          exports.layoutReplot = function(gd2) {
+            var layout = gd2.layout;
+            gd2.layout = void 0;
+            return Registry.call("_doPlot", gd2, "", layout);
+          };
+          exports.doLegend = function(gd2) {
+            Registry.getComponentMethod("legend", "draw")(gd2);
+            return Plots.previousPromises(gd2);
+          };
+          exports.doTicksRelayout = function(gd2) {
+            Axes.draw(gd2, "redraw");
+            if (gd2._fullLayout._hasOnlyLargeSploms) {
+              Registry.subplotsRegistry.splom.updateGrid(gd2);
+              clearGlCanvases(gd2);
+              exports.redrawReglTraces(gd2);
+            }
+            exports.drawMainTitle(gd2);
+            return Plots.previousPromises(gd2);
+          };
+          exports.doModeBar = function(gd2) {
+            var fullLayout = gd2._fullLayout;
+            ModeBar.manage(gd2);
+            for (var i2 = 0; i2 < fullLayout._basePlotModules.length; i2++) {
+              var updateFx = fullLayout._basePlotModules[i2].updateFx;
+              if (updateFx) updateFx(gd2);
+            }
+            return Plots.previousPromises(gd2);
+          };
+          exports.doCamera = function(gd2) {
+            var fullLayout = gd2._fullLayout;
+            var sceneIds = fullLayout._subplots.gl3d;
+            for (var i2 = 0; i2 < sceneIds.length; i2++) {
+              var sceneLayout = fullLayout[sceneIds[i2]];
+              var scene = sceneLayout._scene;
+              scene.setViewport(sceneLayout);
+            }
+          };
+          exports.drawData = function(gd2) {
+            var fullLayout = gd2._fullLayout;
+            clearGlCanvases(gd2);
+            var basePlotModules = fullLayout._basePlotModules;
+            for (var i2 = 0; i2 < basePlotModules.length; i2++) {
+              basePlotModules[i2].plot(gd2);
+            }
+            exports.redrawReglTraces(gd2);
+            Plots.style(gd2);
+            Registry.getComponentMethod("selections", "draw")(gd2);
+            Registry.getComponentMethod("shapes", "draw")(gd2);
+            Registry.getComponentMethod("annotations", "draw")(gd2);
+            Registry.getComponentMethod("images", "draw")(gd2);
+            fullLayout._replotting = false;
+            return Plots.previousPromises(gd2);
+          };
+          exports.redrawReglTraces = function(gd2) {
+            var fullLayout = gd2._fullLayout;
+            if (fullLayout._has("regl")) {
+              var fullData = gd2._fullData;
+              var cartesianIds = [];
+              var polarIds = [];
+              var i2, sp;
+              if (fullLayout._hasOnlyLargeSploms) {
+                fullLayout._splomGrid.draw();
+              }
+              for (i2 = 0; i2 < fullData.length; i2++) {
+                var trace = fullData[i2];
+                if (trace.visible === true && trace._length !== 0) {
+                  if (trace.type === "splom") {
+                    fullLayout._splomScenes[trace.uid].draw();
+                  } else if (trace.type === "scattergl") {
+                    Lib.pushUnique(cartesianIds, trace.xaxis + trace.yaxis);
+                  } else if (trace.type === "scatterpolargl") {
+                    Lib.pushUnique(polarIds, trace.subplot);
+                  }
+                }
+              }
+              for (i2 = 0; i2 < cartesianIds.length; i2++) {
+                sp = fullLayout._plots[cartesianIds[i2]];
+                if (sp._scene) sp._scene.draw();
+              }
+              for (i2 = 0; i2 < polarIds.length; i2++) {
+                sp = fullLayout[polarIds[i2]]._subplot;
+                if (sp._scene) sp._scene.draw();
+              }
+            }
+          };
+          exports.doAutoRangeAndConstraints = function(gd2) {
+            var axList = Axes.list(gd2, "", true);
+            var ax;
+            var autoRangeDone = {};
+            for (var i2 = 0; i2 < axList.length; i2++) {
+              ax = axList[i2];
+              if (!autoRangeDone[ax._id]) {
+                autoRangeDone[ax._id] = 1;
+                cleanAxisConstraints(gd2, ax);
+                doAutoRange(gd2, ax);
+                var matchGroup = ax._matchGroup;
+                if (matchGroup) {
+                  for (var id2 in matchGroup) {
+                    var ax2 = Axes.getFromId(gd2, id2);
+                    doAutoRange(gd2, ax2, ax.range);
+                    autoRangeDone[id2] = 1;
+                  }
+                }
+              }
+            }
+            enforceAxisConstraints(gd2);
+          };
+          exports.finalDraw = function(gd2) {
+            Registry.getComponentMethod("rangeslider", "draw")(gd2);
+            Registry.getComponentMethod("rangeselector", "draw")(gd2);
+          };
+          exports.drawMarginPushers = function(gd2) {
+            Registry.getComponentMethod("legend", "draw")(gd2);
+            Registry.getComponentMethod("rangeselector", "draw")(gd2);
+            Registry.getComponentMethod("sliders", "draw")(gd2);
+            Registry.getComponentMethod("updatemenus", "draw")(gd2);
+            Registry.getComponentMethod("colorbar", "draw")(gd2);
+          };
+        }
+      });
+      var require_draw3 = __commonJS({
+        "src/components/selections/draw.js"(exports, module2) {
+          var readPaths = require_helpers7().readPaths;
+          var displayOutlines = require_display_outlines();
+          var clearOutlineControllers = require_handle_outline().clearOutlineControllers;
+          var Color2 = require_color();
+          var Drawing = require_drawing();
+          var arrayEditor = require_plot_template().arrayEditor;
+          var helpers = require_helpers8();
+          var getPathString = helpers.getPathString;
+          module2.exports = {
+            draw,
+            drawOne,
+            activateLastSelection
+          };
+          function draw(gd2) {
+            var fullLayout = gd2._fullLayout;
+            clearOutlineControllers(gd2);
+            fullLayout._selectionLayer.selectAll("path").remove();
+            for (var k2 in fullLayout._plots) {
+              var selectionLayer = fullLayout._plots[k2].selectionLayer;
+              if (selectionLayer) selectionLayer.selectAll("path").remove();
+            }
+            for (var i2 = 0; i2 < fullLayout.selections.length; i2++) {
+              drawOne(gd2, i2);
+            }
+          }
+          function couldHaveActiveSelection(gd2) {
+            return gd2._context.editSelection;
+          }
+          function drawOne(gd2, index) {
+            gd2._fullLayout._paperdiv.selectAll('.selectionlayer [data-index="' + index + '"]').remove();
+            var o2 = helpers.makeSelectionsOptionsAndPlotinfo(gd2, index);
+            var options = o2.options;
+            var plotinfo = o2.plotinfo;
+            if (!options._input) return;
+            drawSelection(gd2._fullLayout._selectionLayer);
+            function drawSelection(selectionLayer) {
+              var d2 = getPathString(gd2, options);
+              var attrs = {
+                "data-index": index,
+                "fill-rule": "evenodd",
+                d: d2
+              };
+              var opacity = options.opacity;
+              var fillColor = "rgba(0,0,0,0)";
+              var lineColor = options.line.color || Color2.contrast(gd2._fullLayout.plot_bgcolor);
+              var lineWidth = options.line.width;
+              var lineDash = options.line.dash;
+              if (!lineWidth) {
+                lineWidth = 5;
+                lineDash = "solid";
+              }
+              var isActiveSelection = couldHaveActiveSelection(gd2) && gd2._fullLayout._activeSelectionIndex === index;
+              if (isActiveSelection) {
+                fillColor = gd2._fullLayout.activeselection.fillcolor;
+                opacity = gd2._fullLayout.activeselection.opacity;
+              }
+              var allPaths = [];
+              for (var sensory = 1; sensory >= 0; sensory--) {
+                var path = selectionLayer.append("path").attr(attrs).style("opacity", sensory ? 0.1 : opacity).call(Color2.stroke, lineColor).call(Color2.fill, fillColor).call(
+                  Drawing.dashLine,
+                  sensory ? "solid" : lineDash,
+                  sensory ? 4 + lineWidth : lineWidth
+                );
+                setClipPath(path, gd2, options);
+                if (isActiveSelection) {
+                  var editHelpers = arrayEditor(gd2.layout, "selections", options);
+                  path.style({
+                    cursor: "move"
+                  });
+                  var dragOptions = {
+                    element: path.node(),
+                    plotinfo,
+                    gd: gd2,
+                    editHelpers,
+                    isActiveSelection: true
+                    // i.e. to enable controllers
+                  };
+                  var polygons = readPaths(d2, gd2);
+                  displayOutlines(polygons, path, dragOptions);
+                } else {
+                  path.style("pointer-events", sensory ? "all" : "none");
+                }
+                allPaths[sensory] = path;
+              }
+              var forePath = allPaths[0];
+              var backPath = allPaths[1];
+              backPath.node().addEventListener("click", function() {
+                return activateSelection(gd2, forePath);
+              });
+            }
+          }
+          function setClipPath(selectionPath, gd2, selectionOptions) {
+            var clipAxes = selectionOptions.xref + selectionOptions.yref;
+            Drawing.setClipUrl(
+              selectionPath,
+              "clip" + gd2._fullLayout._uid + clipAxes,
+              gd2
+            );
+          }
+          function activateSelection(gd2, path) {
+            if (!couldHaveActiveSelection(gd2)) return;
+            var element = path.node();
+            var id2 = +element.getAttribute("data-index");
+            if (id2 >= 0) {
+              if (id2 === gd2._fullLayout._activeSelectionIndex) {
+                deactivateSelection(gd2);
+                return;
+              }
+              gd2._fullLayout._activeSelectionIndex = id2;
+              gd2._fullLayout._deactivateSelection = deactivateSelection;
+              draw(gd2);
+            }
+          }
+          function activateLastSelection(gd2) {
+            if (!couldHaveActiveSelection(gd2)) return;
+            var id2 = gd2._fullLayout.selections.length - 1;
+            gd2._fullLayout._activeSelectionIndex = id2;
+            gd2._fullLayout._deactivateSelection = deactivateSelection;
+            draw(gd2);
+          }
+          function deactivateSelection(gd2) {
+            if (!couldHaveActiveSelection(gd2)) return;
+            var id2 = gd2._fullLayout._activeSelectionIndex;
+            if (id2 >= 0) {
+              clearOutlineControllers(gd2);
+              delete gd2._fullLayout._activeSelectionIndex;
+              draw(gd2);
+            }
+          }
+        }
+      });
+      var require_build_log = __commonJS({
+        "node_modules/polybooljs/lib/build-log.js"(exports, module2) {
+          function BuildLog() {
+            var my;
+            var nextSegmentId = 0;
+            var curVert = false;
+            function push(type, data) {
+              my.list.push({
+                type,
+                data: data ? JSON.parse(JSON.stringify(data)) : void 0
+              });
+              return my;
+            }
+            my = {
+              list: [],
+              segmentId: function() {
+                return nextSegmentId++;
+              },
+              checkIntersection: function(seg1, seg2) {
+                return push("check", { seg1, seg2 });
+              },
+              segmentChop: function(seg, end) {
+                push("div_seg", { seg, pt: end });
+                return push("chop", { seg, pt: end });
+              },
+              statusRemove: function(seg) {
+                return push("pop_seg", { seg });
+              },
+              segmentUpdate: function(seg) {
+                return push("seg_update", { seg });
+              },
+              segmentNew: function(seg, primary) {
+                return push("new_seg", { seg, primary });
+              },
+              segmentRemove: function(seg) {
+                return push("rem_seg", { seg });
+              },
+              tempStatus: function(seg, above, below) {
+                return push("temp_status", { seg, above, below });
+              },
+              rewind: function(seg) {
+                return push("rewind", { seg });
+              },
+              status: function(seg, above, below) {
+                return push("status", { seg, above, below });
+              },
+              vert: function(x2) {
+                if (x2 === curVert)
+                  return my;
+                curVert = x2;
+                return push("vert", { x: x2 });
+              },
+              log: function(data) {
+                if (typeof data !== "string")
+                  data = JSON.stringify(data, false, "  ");
+                return push("log", { txt: data });
+              },
+              reset: function() {
+                return push("reset");
+              },
+              selected: function(segs) {
+                return push("selected", { segs });
+              },
+              chainStart: function(seg) {
+                return push("chain_start", { seg });
+              },
+              chainRemoveHead: function(index, pt2) {
+                return push("chain_rem_head", { index, pt: pt2 });
+              },
+              chainRemoveTail: function(index, pt2) {
+                return push("chain_rem_tail", { index, pt: pt2 });
+              },
+              chainNew: function(pt1, pt2) {
+                return push("chain_new", { pt1, pt2 });
+              },
+              chainMatch: function(index) {
+                return push("chain_match", { index });
+              },
+              chainClose: function(index) {
+                return push("chain_close", { index });
+              },
+              chainAddHead: function(index, pt2) {
+                return push("chain_add_head", { index, pt: pt2 });
+              },
+              chainAddTail: function(index, pt2) {
+                return push("chain_add_tail", { index, pt: pt2 });
+              },
+              chainConnect: function(index1, index2) {
+                return push("chain_con", { index1, index2 });
+              },
+              chainReverse: function(index) {
+                return push("chain_rev", { index });
+              },
+              chainJoin: function(index1, index2) {
+                return push("chain_join", { index1, index2 });
+              },
+              done: function() {
+                return push("done");
+              }
+            };
+            return my;
+          }
+          module2.exports = BuildLog;
+        }
+      });
+      var require_epsilon = __commonJS({
+        "node_modules/polybooljs/lib/epsilon.js"(exports, module2) {
+          function Epsilon(eps) {
+            if (typeof eps !== "number")
+              eps = 1e-10;
+            var my = {
+              epsilon: function(v2) {
+                if (typeof v2 === "number")
+                  eps = v2;
+                return eps;
+              },
+              pointAboveOrOnLine: function(pt2, left, right) {
+                var Ax = left[0];
+                var Ay = left[1];
+                var Bx = right[0];
+                var By = right[1];
+                var Cx = pt2[0];
+                var Cy = pt2[1];
+                return (Bx - Ax) * (Cy - Ay) - (By - Ay) * (Cx - Ax) >= -eps;
+              },
+              pointBetween: function(p2, left, right) {
+                var d_py_ly = p2[1] - left[1];
+                var d_rx_lx = right[0] - left[0];
+                var d_px_lx = p2[0] - left[0];
+                var d_ry_ly = right[1] - left[1];
+                var dot2 = d_px_lx * d_rx_lx + d_py_ly * d_ry_ly;
+                if (dot2 < eps)
+                  return false;
+                var sqlen = d_rx_lx * d_rx_lx + d_ry_ly * d_ry_ly;
+                if (dot2 - sqlen > -eps)
+                  return false;
+                return true;
+              },
+              pointsSameX: function(p1, p2) {
+                return Math.abs(p1[0] - p2[0]) < eps;
+              },
+              pointsSameY: function(p1, p2) {
+                return Math.abs(p1[1] - p2[1]) < eps;
+              },
+              pointsSame: function(p1, p2) {
+                return my.pointsSameX(p1, p2) && my.pointsSameY(p1, p2);
+              },
+              pointsCompare: function(p1, p2) {
+                if (my.pointsSameX(p1, p2))
+                  return my.pointsSameY(p1, p2) ? 0 : p1[1] < p2[1] ? -1 : 1;
+                return p1[0] < p2[0] ? -1 : 1;
+              },
+              pointsCollinear: function(pt1, pt2, pt3) {
+                var dx1 = pt1[0] - pt2[0];
+                var dy1 = pt1[1] - pt2[1];
+                var dx2 = pt2[0] - pt3[0];
+                var dy2 = pt2[1] - pt3[1];
+                return Math.abs(dx1 * dy2 - dx2 * dy1) < eps;
+              },
+              linesIntersect: function(a0, a1, b0, b1) {
+                var adx = a1[0] - a0[0];
+                var ady = a1[1] - a0[1];
+                var bdx = b1[0] - b0[0];
+                var bdy = b1[1] - b0[1];
+                var axb = adx * bdy - ady * bdx;
+                if (Math.abs(axb) < eps)
+                  return false;
+                var dx = a0[0] - b0[0];
+                var dy = a0[1] - b0[1];
+                var A22 = (bdx * dy - bdy * dx) / axb;
+                var B22 = (adx * dy - ady * dx) / axb;
+                var ret = {
+                  alongA: 0,
+                  alongB: 0,
+                  pt: [
+                    a0[0] + A22 * adx,
+                    a0[1] + A22 * ady
+                  ]
+                };
+                if (A22 <= -eps)
+                  ret.alongA = -2;
+                else if (A22 < eps)
+                  ret.alongA = -1;
+                else if (A22 - 1 <= -eps)
+                  ret.alongA = 0;
+                else if (A22 - 1 < eps)
+                  ret.alongA = 1;
+                else
+                  ret.alongA = 2;
+                if (B22 <= -eps)
+                  ret.alongB = -2;
+                else if (B22 < eps)
+                  ret.alongB = -1;
+                else if (B22 - 1 <= -eps)
+                  ret.alongB = 0;
+                else if (B22 - 1 < eps)
+                  ret.alongB = 1;
+                else
+                  ret.alongB = 2;
+                return ret;
+              },
+              pointInsideRegion: function(pt2, region) {
+                var x2 = pt2[0];
+                var y2 = pt2[1];
+                var last_x = region[region.length - 1][0];
+                var last_y = region[region.length - 1][1];
+                var inside = false;
+                for (var i2 = 0; i2 < region.length; i2++) {
+                  var curr_x = region[i2][0];
+                  var curr_y = region[i2][1];
+                  if (curr_y - y2 > eps != last_y - y2 > eps && (last_x - curr_x) * (y2 - curr_y) / (last_y - curr_y) + curr_x - x2 > eps)
+                    inside = !inside;
+                  last_x = curr_x;
+                  last_y = curr_y;
+                }
+                return inside;
+              }
+            };
+            return my;
+          }
+          module2.exports = Epsilon;
+        }
+      });
+      var require_linked_list = __commonJS({
+        "node_modules/polybooljs/lib/linked-list.js"(exports, module2) {
+          var LinkedList = {
+            create: function() {
+              var my = {
+                root: { root: true, next: null },
+                exists: function(node) {
+                  if (node === null || node === my.root)
+                    return false;
+                  return true;
+                },
+                isEmpty: function() {
+                  return my.root.next === null;
+                },
+                getHead: function() {
+                  return my.root.next;
+                },
+                insertBefore: function(node, check) {
+                  var last = my.root;
+                  var here = my.root.next;
+                  while (here !== null) {
+                    if (check(here)) {
+                      node.prev = here.prev;
+                      node.next = here;
+                      here.prev.next = node;
+                      here.prev = node;
+                      return;
+                    }
+                    last = here;
+                    here = here.next;
+                  }
+                  last.next = node;
+                  node.prev = last;
+                  node.next = null;
+                },
+                findTransition: function(check) {
+                  var prev = my.root;
+                  var here = my.root.next;
+                  while (here !== null) {
+                    if (check(here))
+                      break;
+                    prev = here;
+                    here = here.next;
+                  }
+                  return {
+                    before: prev === my.root ? null : prev,
+                    after: here,
+                    insert: function(node) {
+                      node.prev = prev;
+                      node.next = here;
+                      prev.next = node;
+                      if (here !== null)
+                        here.prev = node;
+                      return node;
+                    }
+                  };
+                }
+              };
+              return my;
+            },
+            node: function(data) {
+              data.prev = null;
+              data.next = null;
+              data.remove = function() {
+                data.prev.next = data.next;
+                if (data.next)
+                  data.next.prev = data.prev;
+                data.prev = null;
+                data.next = null;
+              };
+              return data;
+            }
+          };
+          module2.exports = LinkedList;
+        }
+      });
+      var require_intersecter = __commonJS({
+        "node_modules/polybooljs/lib/intersecter.js"(exports, module2) {
+          var LinkedList = require_linked_list();
+          function Intersecter(selfIntersection, eps, buildLog) {
+            function segmentNew(start, end) {
+              return {
+                id: buildLog ? buildLog.segmentId() : -1,
+                start,
+                end,
+                myFill: {
+                  above: null,
+                  // is there fill above us?
+                  below: null
+                  // is there fill below us?
+                },
+                otherFill: null
+              };
+            }
+            function segmentCopy(start, end, seg) {
+              return {
+                id: buildLog ? buildLog.segmentId() : -1,
+                start,
+                end,
+                myFill: {
+                  above: seg.myFill.above,
+                  below: seg.myFill.below
+                },
+                otherFill: null
+              };
+            }
+            var event_root = LinkedList.create();
+            function eventCompare(p1_isStart, p1_1, p1_2, p2_isStart, p2_1, p2_2) {
+              var comp = eps.pointsCompare(p1_1, p2_1);
+              if (comp !== 0)
+                return comp;
+              if (eps.pointsSame(p1_2, p2_2))
+                return 0;
+              if (p1_isStart !== p2_isStart)
+                return p1_isStart ? 1 : -1;
+              return eps.pointAboveOrOnLine(
+                p1_2,
+                p2_isStart ? p2_1 : p2_2,
+                // order matters
+                p2_isStart ? p2_2 : p2_1
+              ) ? 1 : -1;
+            }
+            function eventAdd(ev, other_pt) {
+              event_root.insertBefore(ev, function(here) {
+                var comp = eventCompare(
+                  ev.isStart,
+                  ev.pt,
+                  other_pt,
+                  here.isStart,
+                  here.pt,
+                  here.other.pt
+                );
+                return comp < 0;
+              });
+            }
+            function eventAddSegmentStart(seg, primary) {
+              var ev_start = LinkedList.node({
+                isStart: true,
+                pt: seg.start,
+                seg,
+                primary,
+                other: null,
+                status: null
+              });
+              eventAdd(ev_start, seg.end);
+              return ev_start;
+            }
+            function eventAddSegmentEnd(ev_start, seg, primary) {
+              var ev_end = LinkedList.node({
+                isStart: false,
+                pt: seg.end,
+                seg,
+                primary,
+                other: ev_start,
+                status: null
+              });
+              ev_start.other = ev_end;
+              eventAdd(ev_end, ev_start.pt);
+            }
+            function eventAddSegment(seg, primary) {
+              var ev_start = eventAddSegmentStart(seg, primary);
+              eventAddSegmentEnd(ev_start, seg, primary);
+              return ev_start;
+            }
+            function eventUpdateEnd(ev, end) {
+              if (buildLog)
+                buildLog.segmentChop(ev.seg, end);
+              ev.other.remove();
+              ev.seg.end = end;
+              ev.other.pt = end;
+              eventAdd(ev.other, ev.pt);
+            }
+            function eventDivide(ev, pt2) {
+              var ns = segmentCopy(pt2, ev.seg.end, ev.seg);
+              eventUpdateEnd(ev, pt2);
+              return eventAddSegment(ns, ev.primary);
+            }
+            function calculate(primaryPolyInverted, secondaryPolyInverted) {
+              var status_root = LinkedList.create();
+              function statusCompare(ev1, ev2) {
+                var a1 = ev1.seg.start;
+                var a2 = ev1.seg.end;
+                var b1 = ev2.seg.start;
+                var b2 = ev2.seg.end;
+                if (eps.pointsCollinear(a1, b1, b2)) {
+                  if (eps.pointsCollinear(a2, b1, b2))
+                    return 1;
+                  return eps.pointAboveOrOnLine(a2, b1, b2) ? 1 : -1;
+                }
+                return eps.pointAboveOrOnLine(a1, b1, b2) ? 1 : -1;
+              }
+              function statusFindSurrounding(ev2) {
+                return status_root.findTransition(function(here) {
+                  var comp = statusCompare(ev2, here.ev);
+                  return comp > 0;
+                });
+              }
+              function checkIntersection(ev1, ev2) {
+                var seg1 = ev1.seg;
+                var seg2 = ev2.seg;
+                var a1 = seg1.start;
+                var a2 = seg1.end;
+                var b1 = seg2.start;
+                var b2 = seg2.end;
+                if (buildLog)
+                  buildLog.checkIntersection(seg1, seg2);
+                var i2 = eps.linesIntersect(a1, a2, b1, b2);
+                if (i2 === false) {
+                  if (!eps.pointsCollinear(a1, a2, b1))
+                    return false;
+                  if (eps.pointsSame(a1, b2) || eps.pointsSame(a2, b1))
+                    return false;
+                  var a1_equ_b1 = eps.pointsSame(a1, b1);
+                  var a2_equ_b2 = eps.pointsSame(a2, b2);
+                  if (a1_equ_b1 && a2_equ_b2)
+                    return ev2;
+                  var a1_between = !a1_equ_b1 && eps.pointBetween(a1, b1, b2);
+                  var a2_between = !a2_equ_b2 && eps.pointBetween(a2, b1, b2);
+                  if (a1_equ_b1) {
+                    if (a2_between) {
+                      eventDivide(ev2, a2);
+                    } else {
+                      eventDivide(ev1, b2);
+                    }
+                    return ev2;
+                  } else if (a1_between) {
+                    if (!a2_equ_b2) {
+                      if (a2_between) {
+                        eventDivide(ev2, a2);
+                      } else {
+                        eventDivide(ev1, b2);
+                      }
+                    }
+                    eventDivide(ev2, a1);
+                  }
+                } else {
+                  if (i2.alongA === 0) {
+                    if (i2.alongB === -1)
+                      eventDivide(ev1, b1);
+                    else if (i2.alongB === 0)
+                      eventDivide(ev1, i2.pt);
+                    else if (i2.alongB === 1)
+                      eventDivide(ev1, b2);
+                  }
+                  if (i2.alongB === 0) {
+                    if (i2.alongA === -1)
+                      eventDivide(ev2, a1);
+                    else if (i2.alongA === 0)
+                      eventDivide(ev2, i2.pt);
+                    else if (i2.alongA === 1)
+                      eventDivide(ev2, a2);
+                  }
+                }
+                return false;
+              }
+              var segments = [];
+              while (!event_root.isEmpty()) {
+                var ev = event_root.getHead();
+                if (buildLog)
+                  buildLog.vert(ev.pt[0]);
+                if (ev.isStart) {
+                  let checkBothIntersections2 = function() {
+                    if (above) {
+                      var eve2 = checkIntersection(ev, above);
+                      if (eve2)
+                        return eve2;
+                    }
+                    if (below)
+                      return checkIntersection(ev, below);
+                    return false;
+                  };
+                  if (buildLog)
+                    buildLog.segmentNew(ev.seg, ev.primary);
+                  var surrounding = statusFindSurrounding(ev);
+                  var above = surrounding.before ? surrounding.before.ev : null;
+                  var below = surrounding.after ? surrounding.after.ev : null;
+                  if (buildLog) {
+                    buildLog.tempStatus(
+                      ev.seg,
+                      above ? above.seg : false,
+                      below ? below.seg : false
+                    );
+                  }
+                  var eve = checkBothIntersections2();
+                  if (eve) {
+                    if (selfIntersection) {
+                      var toggle;
+                      if (ev.seg.myFill.below === null)
+                        toggle = true;
+                      else
+                        toggle = ev.seg.myFill.above !== ev.seg.myFill.below;
+                      if (toggle)
+                        eve.seg.myFill.above = !eve.seg.myFill.above;
+                    } else {
+                      eve.seg.otherFill = ev.seg.myFill;
+                    }
+                    if (buildLog)
+                      buildLog.segmentUpdate(eve.seg);
+                    ev.other.remove();
+                    ev.remove();
+                  }
+                  if (event_root.getHead() !== ev) {
+                    if (buildLog)
+                      buildLog.rewind(ev.seg);
+                    continue;
+                  }
+                  if (selfIntersection) {
+                    var toggle;
+                    if (ev.seg.myFill.below === null)
+                      toggle = true;
+                    else
+                      toggle = ev.seg.myFill.above !== ev.seg.myFill.below;
+                    if (!below) {
+                      ev.seg.myFill.below = primaryPolyInverted;
+                    } else {
+                      ev.seg.myFill.below = below.seg.myFill.above;
+                    }
+                    if (toggle)
+                      ev.seg.myFill.above = !ev.seg.myFill.below;
+                    else
+                      ev.seg.myFill.above = ev.seg.myFill.below;
+                  } else {
+                    if (ev.seg.otherFill === null) {
+                      var inside;
+                      if (!below) {
+                        inside = ev.primary ? secondaryPolyInverted : primaryPolyInverted;
+                      } else {
+                        if (ev.primary === below.primary)
+                          inside = below.seg.otherFill.above;
+                        else
+                          inside = below.seg.myFill.above;
+                      }
+                      ev.seg.otherFill = {
+                        above: inside,
+                        below: inside
+                      };
+                    }
+                  }
+                  if (buildLog) {
+                    buildLog.status(
+                      ev.seg,
+                      above ? above.seg : false,
+                      below ? below.seg : false
+                    );
+                  }
+                  ev.other.status = surrounding.insert(LinkedList.node({ ev }));
+                } else {
+                  var st2 = ev.status;
+                  if (st2 === null) {
+                    throw new Error("PolyBool: Zero-length segment detected; your epsilon is probably too small or too large");
+                  }
+                  if (status_root.exists(st2.prev) && status_root.exists(st2.next))
+                    checkIntersection(st2.prev.ev, st2.next.ev);
+                  if (buildLog)
+                    buildLog.statusRemove(st2.ev.seg);
+                  st2.remove();
+                  if (!ev.primary) {
+                    var s2 = ev.seg.myFill;
+                    ev.seg.myFill = ev.seg.otherFill;
+                    ev.seg.otherFill = s2;
+                  }
+                  segments.push(ev.seg);
+                }
+                event_root.getHead().remove();
+              }
+              if (buildLog)
+                buildLog.done();
+              return segments;
+            }
+            if (!selfIntersection) {
+              return {
+                calculate: function(segments1, inverted1, segments2, inverted2) {
+                  segments1.forEach(function(seg) {
+                    eventAddSegment(segmentCopy(seg.start, seg.end, seg), true);
+                  });
+                  segments2.forEach(function(seg) {
+                    eventAddSegment(segmentCopy(seg.start, seg.end, seg), false);
+                  });
+                  return calculate(inverted1, inverted2);
+                }
+              };
+            }
+            return {
+              addRegion: function(region) {
+                var pt1;
+                var pt2 = region[region.length - 1];
+                for (var i2 = 0; i2 < region.length; i2++) {
+                  pt1 = pt2;
+                  pt2 = region[i2];
+                  var forward = eps.pointsCompare(pt1, pt2);
+                  if (forward === 0)
+                    continue;
+                  eventAddSegment(
+                    segmentNew(
+                      forward < 0 ? pt1 : pt2,
+                      forward < 0 ? pt2 : pt1
+                    ),
+                    true
+                  );
+                }
+              },
+              calculate: function(inverted) {
+                return calculate(inverted, false);
+              }
+            };
+          }
+          module2.exports = Intersecter;
+        }
+      });
+      var require_segment_chainer = __commonJS({
+        "node_modules/polybooljs/lib/segment-chainer.js"(exports, module2) {
+          function SegmentChainer(segments, eps, buildLog) {
+            var chains = [];
+            var regions = [];
+            segments.forEach(function(seg) {
+              var pt1 = seg.start;
+              var pt2 = seg.end;
+              if (eps.pointsSame(pt1, pt2)) {
+                console.warn("PolyBool: Warning: Zero-length segment detected; your epsilon is probably too small or too large");
+                return;
+              }
+              if (buildLog)
+                buildLog.chainStart(seg);
+              var first_match = {
+                index: 0,
+                matches_head: false,
+                matches_pt1: false
+              };
+              var second_match = {
+                index: 0,
+                matches_head: false,
+                matches_pt1: false
+              };
+              var next_match = first_match;
+              function setMatch(index2, matches_head, matches_pt1) {
+                next_match.index = index2;
+                next_match.matches_head = matches_head;
+                next_match.matches_pt1 = matches_pt1;
+                if (next_match === first_match) {
+                  next_match = second_match;
+                  return false;
+                }
+                next_match = null;
+                return true;
+              }
+              for (var i2 = 0; i2 < chains.length; i2++) {
+                var chain = chains[i2];
+                var head = chain[0];
+                chain[1];
+                var tail = chain[chain.length - 1];
+                chain[chain.length - 2];
+                if (eps.pointsSame(head, pt1)) {
+                  if (setMatch(i2, true, true))
+                    break;
+                } else if (eps.pointsSame(head, pt2)) {
+                  if (setMatch(i2, true, false))
+                    break;
+                } else if (eps.pointsSame(tail, pt1)) {
+                  if (setMatch(i2, false, true))
+                    break;
+                } else if (eps.pointsSame(tail, pt2)) {
+                  if (setMatch(i2, false, false))
+                    break;
+                }
+              }
+              if (next_match === first_match) {
+                chains.push([pt1, pt2]);
+                if (buildLog)
+                  buildLog.chainNew(pt1, pt2);
+                return;
+              }
+              if (next_match === second_match) {
+                if (buildLog)
+                  buildLog.chainMatch(first_match.index);
+                var index = first_match.index;
+                var pt3 = first_match.matches_pt1 ? pt2 : pt1;
+                var addToHead = first_match.matches_head;
+                var chain = chains[index];
+                var grow = addToHead ? chain[0] : chain[chain.length - 1];
+                var grow2 = addToHead ? chain[1] : chain[chain.length - 2];
+                var oppo = addToHead ? chain[chain.length - 1] : chain[0];
+                var oppo2 = addToHead ? chain[chain.length - 2] : chain[1];
+                if (eps.pointsCollinear(grow2, grow, pt3)) {
+                  if (addToHead) {
+                    if (buildLog)
+                      buildLog.chainRemoveHead(first_match.index, pt3);
+                    chain.shift();
+                  } else {
+                    if (buildLog)
+                      buildLog.chainRemoveTail(first_match.index, pt3);
+                    chain.pop();
+                  }
+                  grow = grow2;
+                }
+                if (eps.pointsSame(oppo, pt3)) {
+                  chains.splice(index, 1);
+                  if (eps.pointsCollinear(oppo2, oppo, grow)) {
+                    if (addToHead) {
+                      if (buildLog)
+                        buildLog.chainRemoveTail(first_match.index, grow);
+                      chain.pop();
+                    } else {
+                      if (buildLog)
+                        buildLog.chainRemoveHead(first_match.index, grow);
+                      chain.shift();
+                    }
+                  }
+                  if (buildLog)
+                    buildLog.chainClose(first_match.index);
+                  regions.push(chain);
+                  return;
+                }
+                if (addToHead) {
+                  if (buildLog)
+                    buildLog.chainAddHead(first_match.index, pt3);
+                  chain.unshift(pt3);
+                } else {
+                  if (buildLog)
+                    buildLog.chainAddTail(first_match.index, pt3);
+                  chain.push(pt3);
+                }
+                return;
+              }
+              function reverseChain(index2) {
+                if (buildLog)
+                  buildLog.chainReverse(index2);
+                chains[index2].reverse();
+              }
+              function appendChain(index1, index2) {
+                var chain1 = chains[index1];
+                var chain2 = chains[index2];
+                var tail3 = chain1[chain1.length - 1];
+                var tail22 = chain1[chain1.length - 2];
+                var head3 = chain2[0];
+                var head22 = chain2[1];
+                if (eps.pointsCollinear(tail22, tail3, head3)) {
+                  if (buildLog)
+                    buildLog.chainRemoveTail(index1, tail3);
+                  chain1.pop();
+                  tail3 = tail22;
+                }
+                if (eps.pointsCollinear(tail3, head3, head22)) {
+                  if (buildLog)
+                    buildLog.chainRemoveHead(index2, head3);
+                  chain2.shift();
+                }
+                if (buildLog)
+                  buildLog.chainJoin(index1, index2);
+                chains[index1] = chain1.concat(chain2);
+                chains.splice(index2, 1);
+              }
+              var F2 = first_match.index;
+              var S2 = second_match.index;
+              if (buildLog)
+                buildLog.chainConnect(F2, S2);
+              var reverseF = chains[F2].length < chains[S2].length;
+              if (first_match.matches_head) {
+                if (second_match.matches_head) {
+                  if (reverseF) {
+                    reverseChain(F2);
+                    appendChain(F2, S2);
+                  } else {
+                    reverseChain(S2);
+                    appendChain(S2, F2);
+                  }
+                } else {
+                  appendChain(S2, F2);
+                }
+              } else {
+                if (second_match.matches_head) {
+                  appendChain(F2, S2);
+                } else {
+                  if (reverseF) {
+                    reverseChain(F2);
+                    appendChain(S2, F2);
+                  } else {
+                    reverseChain(S2);
+                    appendChain(F2, S2);
+                  }
+                }
+              }
+            });
+            return regions;
+          }
+          module2.exports = SegmentChainer;
+        }
+      });
+      var require_segment_selector = __commonJS({
+        "node_modules/polybooljs/lib/segment-selector.js"(exports, module2) {
+          function select(segments, selection, buildLog) {
+            var result = [];
+            segments.forEach(function(seg) {
+              var index = (seg.myFill.above ? 8 : 0) + (seg.myFill.below ? 4 : 0) + (seg.otherFill && seg.otherFill.above ? 2 : 0) + (seg.otherFill && seg.otherFill.below ? 1 : 0);
+              if (selection[index] !== 0) {
+                result.push({
+                  id: buildLog ? buildLog.segmentId() : -1,
+                  start: seg.start,
+                  end: seg.end,
+                  myFill: {
+                    above: selection[index] === 1,
+                    // 1 if filled above
+                    below: selection[index] === 2
+                    // 2 if filled below
+                  },
+                  otherFill: null
+                });
+              }
+            });
+            if (buildLog)
+              buildLog.selected(result);
+            return result;
+          }
+          var SegmentSelector = {
+            union: function(segments, buildLog) {
+              return select(segments, [
+                0,
+                2,
+                1,
+                0,
+                2,
+                2,
+                0,
+                0,
+                1,
+                0,
+                1,
+                0,
+                0,
+                0,
+                0,
+                0
+              ], buildLog);
+            },
+            intersect: function(segments, buildLog) {
+              return select(segments, [
+                0,
+                0,
+                0,
+                0,
+                0,
+                2,
+                0,
+                2,
+                0,
+                0,
+                1,
+                1,
+                0,
+                2,
+                1,
+                0
+              ], buildLog);
+            },
+            difference: function(segments, buildLog) {
+              return select(segments, [
+                0,
+                0,
+                0,
+                0,
+                2,
+                0,
+                2,
+                0,
+                1,
+                1,
+                0,
+                0,
+                0,
+                1,
+                2,
+                0
+              ], buildLog);
+            },
+            differenceRev: function(segments, buildLog) {
+              return select(segments, [
+                0,
+                2,
+                1,
+                0,
+                0,
+                0,
+                1,
+                1,
+                0,
+                2,
+                0,
+                2,
+                0,
+                0,
+                0,
+                0
+              ], buildLog);
+            },
+            xor: function(segments, buildLog) {
+              return select(segments, [
+                0,
+                2,
+                1,
+                0,
+                2,
+                0,
+                0,
+                1,
+                1,
+                0,
+                0,
+                2,
+                0,
+                1,
+                2,
+                0
+              ], buildLog);
+            }
+          };
+          module2.exports = SegmentSelector;
+        }
+      });
+      var require_geojson = __commonJS({
+        "node_modules/polybooljs/lib/geojson.js"(exports, module2) {
+          var GeoJSON = {
+            // convert a GeoJSON object to a PolyBool polygon
+            toPolygon: function(PolyBool, geojson) {
+              function GeoPoly(coords) {
+                if (coords.length <= 0)
+                  return PolyBool.segments({ inverted: false, regions: [] });
+                function LineString(ls) {
+                  var reg = ls.slice(0, ls.length - 1);
+                  return PolyBool.segments({ inverted: false, regions: [reg] });
+                }
+                var out2 = LineString(coords[0]);
+                for (var i22 = 1; i22 < coords.length; i22++)
+                  out2 = PolyBool.selectDifference(PolyBool.combine(out2, LineString(coords[i22])));
+                return out2;
+              }
+              if (geojson.type === "Polygon") {
+                return PolyBool.polygon(GeoPoly(geojson.coordinates));
+              } else if (geojson.type === "MultiPolygon") {
+                var out = PolyBool.segments({ inverted: false, regions: [] });
+                for (var i2 = 0; i2 < geojson.coordinates.length; i2++)
+                  out = PolyBool.selectUnion(PolyBool.combine(out, GeoPoly(geojson.coordinates[i2])));
+                return PolyBool.polygon(out);
+              }
+              throw new Error("PolyBool: Cannot convert GeoJSON object to PolyBool polygon");
+            },
+            // convert a PolyBool polygon to a GeoJSON object
+            fromPolygon: function(PolyBool, eps, poly) {
+              poly = PolyBool.polygon(PolyBool.segments(poly));
+              function regionInsideRegion(r1, r2) {
+                return eps.pointInsideRegion([
+                  (r1[0][0] + r1[1][0]) * 0.5,
+                  (r1[0][1] + r1[1][1]) * 0.5
+                ], r2);
+              }
+              function newNode(region2) {
+                return {
+                  region: region2,
+                  children: []
+                };
+              }
+              var roots = newNode(null);
+              function addChild(root, region2) {
+                for (var i22 = 0; i22 < root.children.length; i22++) {
+                  var child = root.children[i22];
+                  if (regionInsideRegion(region2, child.region)) {
+                    addChild(child, region2);
+                    return;
+                  }
+                }
+                var node = newNode(region2);
+                for (var i22 = 0; i22 < root.children.length; i22++) {
+                  var child = root.children[i22];
+                  if (regionInsideRegion(child.region, region2)) {
+                    node.children.push(child);
+                    root.children.splice(i22, 1);
+                    i22--;
+                  }
+                }
+                root.children.push(node);
+              }
+              for (var i2 = 0; i2 < poly.regions.length; i2++) {
+                var region = poly.regions[i2];
+                if (region.length < 3)
+                  continue;
+                addChild(roots, region);
+              }
+              function forceWinding(region2, clockwise) {
+                var winding = 0;
+                var last_x = region2[region2.length - 1][0];
+                var last_y = region2[region2.length - 1][1];
+                var copy = [];
+                for (var i22 = 0; i22 < region2.length; i22++) {
+                  var curr_x = region2[i22][0];
+                  var curr_y = region2[i22][1];
+                  copy.push([curr_x, curr_y]);
+                  winding += curr_y * last_x - curr_x * last_y;
+                  last_x = curr_x;
+                  last_y = curr_y;
+                }
+                var isclockwise = winding < 0;
+                if (isclockwise !== clockwise)
+                  copy.reverse();
+                copy.push([copy[0][0], copy[0][1]]);
+                return copy;
+              }
+              var geopolys = [];
+              function addExterior(node) {
+                var poly2 = [forceWinding(node.region, false)];
+                geopolys.push(poly2);
+                for (var i22 = 0; i22 < node.children.length; i22++)
+                  poly2.push(getInterior(node.children[i22]));
+              }
+              function getInterior(node) {
+                for (var i22 = 0; i22 < node.children.length; i22++)
+                  addExterior(node.children[i22]);
+                return forceWinding(node.region, true);
+              }
+              for (var i2 = 0; i2 < roots.children.length; i2++)
+                addExterior(roots.children[i2]);
+              if (geopolys.length <= 0)
+                return { type: "Polygon", coordinates: [] };
+              if (geopolys.length == 1)
+                return { type: "Polygon", coordinates: geopolys[0] };
+              return {
+                // otherwise, use a GeoJSON MultiPolygon
+                type: "MultiPolygon",
+                coordinates: geopolys
+              };
+            }
+          };
+          module2.exports = GeoJSON;
+        }
+      });
+      var require_polybooljs = __commonJS({
+        "node_modules/polybooljs/index.js"(exports, module2) {
+          var BuildLog = require_build_log();
+          var Epsilon = require_epsilon();
+          var Intersecter = require_intersecter();
+          var SegmentChainer = require_segment_chainer();
+          var SegmentSelector = require_segment_selector();
+          var GeoJSON = require_geojson();
+          var buildLog = false;
+          var epsilon = Epsilon();
+          var PolyBool;
+          PolyBool = {
+            // getter/setter for buildLog
+            buildLog: function(bl2) {
+              if (bl2 === true)
+                buildLog = BuildLog();
+              else if (bl2 === false)
+                buildLog = false;
+              return buildLog === false ? false : buildLog.list;
+            },
+            // getter/setter for epsilon
+            epsilon: function(v2) {
+              return epsilon.epsilon(v2);
+            },
+            // core API
+            segments: function(poly) {
+              var i2 = Intersecter(true, epsilon, buildLog);
+              poly.regions.forEach(i2.addRegion);
+              return {
+                segments: i2.calculate(poly.inverted),
+                inverted: poly.inverted
+              };
+            },
+            combine: function(segments1, segments2) {
+              var i3 = Intersecter(false, epsilon, buildLog);
+              return {
+                combined: i3.calculate(
+                  segments1.segments,
+                  segments1.inverted,
+                  segments2.segments,
+                  segments2.inverted
+                ),
+                inverted1: segments1.inverted,
+                inverted2: segments2.inverted
+              };
+            },
+            selectUnion: function(combined) {
+              return {
+                segments: SegmentSelector.union(combined.combined, buildLog),
+                inverted: combined.inverted1 || combined.inverted2
+              };
+            },
+            selectIntersect: function(combined) {
+              return {
+                segments: SegmentSelector.intersect(combined.combined, buildLog),
+                inverted: combined.inverted1 && combined.inverted2
+              };
+            },
+            selectDifference: function(combined) {
+              return {
+                segments: SegmentSelector.difference(combined.combined, buildLog),
+                inverted: combined.inverted1 && !combined.inverted2
+              };
+            },
+            selectDifferenceRev: function(combined) {
+              return {
+                segments: SegmentSelector.differenceRev(combined.combined, buildLog),
+                inverted: !combined.inverted1 && combined.inverted2
+              };
+            },
+            selectXor: function(combined) {
+              return {
+                segments: SegmentSelector.xor(combined.combined, buildLog),
+                inverted: combined.inverted1 !== combined.inverted2
+              };
+            },
+            polygon: function(segments) {
+              return {
+                regions: SegmentChainer(segments.segments, epsilon, buildLog),
+                inverted: segments.inverted
+              };
+            },
+            // GeoJSON converters
+            polygonFromGeoJSON: function(geojson) {
+              return GeoJSON.toPolygon(PolyBool, geojson);
+            },
+            polygonToGeoJSON: function(poly) {
+              return GeoJSON.fromPolygon(PolyBool, epsilon, poly);
+            },
+            // helper functions for common operations
+            union: function(poly1, poly2) {
+              return operate(poly1, poly2, PolyBool.selectUnion);
+            },
+            intersect: function(poly1, poly2) {
+              return operate(poly1, poly2, PolyBool.selectIntersect);
+            },
+            difference: function(poly1, poly2) {
+              return operate(poly1, poly2, PolyBool.selectDifference);
+            },
+            differenceRev: function(poly1, poly2) {
+              return operate(poly1, poly2, PolyBool.selectDifferenceRev);
+            },
+            xor: function(poly1, poly2) {
+              return operate(poly1, poly2, PolyBool.selectXor);
+            }
+          };
+          function operate(poly1, poly2, selector) {
+            var seg1 = PolyBool.segments(poly1);
+            var seg2 = PolyBool.segments(poly2);
+            var comb = PolyBool.combine(seg1, seg2);
+            var seg3 = selector(comb);
+            return PolyBool.polygon(seg3);
+          }
+          if (typeof window === "object")
+            window.PolyBool = PolyBool;
+          module2.exports = PolyBool;
+        }
+      });
+      var require_nested = __commonJS({
+        "node_modules/point-in-polygon/nested.js"(exports, module2) {
+          module2.exports = function pointInPolygonNested(point, vs2, start, end) {
+            var x2 = point[0], y2 = point[1];
+            var inside = false;
+            if (start === void 0) start = 0;
+            if (end === void 0) end = vs2.length;
+            var len2 = end - start;
+            for (var i2 = 0, j2 = len2 - 1; i2 < len2; j2 = i2++) {
+              var xi2 = vs2[i2 + start][0], yi2 = vs2[i2 + start][1];
+              var xj2 = vs2[j2 + start][0], yj2 = vs2[j2 + start][1];
+              var intersect = yi2 > y2 !== yj2 > y2 && x2 < (xj2 - xi2) * (y2 - yi2) / (yj2 - yi2) + xi2;
+              if (intersect) inside = !inside;
+            }
+            return inside;
+          };
+        }
+      });
+      var require_polygon = __commonJS({
+        "src/lib/polygon.js"(exports, module2) {
+          var dot2 = require_matrix().dot;
+          var BADNUM = require_numerical().BADNUM;
+          var polygon = module2.exports = {};
+          polygon.tester = function tester(ptsIn) {
+            var pts = ptsIn.slice();
+            var xmin = pts[0][0];
+            var xmax = xmin;
+            var ymin = pts[0][1];
+            var ymax = ymin;
+            var i2;
+            if (pts[pts.length - 1][0] !== pts[0][0] || pts[pts.length - 1][1] !== pts[0][1]) {
+              pts.push(pts[0]);
+            }
+            for (i2 = 1; i2 < pts.length; i2++) {
+              xmin = Math.min(xmin, pts[i2][0]);
+              xmax = Math.max(xmax, pts[i2][0]);
+              ymin = Math.min(ymin, pts[i2][1]);
+              ymax = Math.max(ymax, pts[i2][1]);
+            }
+            var isRect = false;
+            var rectFirstEdgeTest;
+            if (pts.length === 5) {
+              if (pts[0][0] === pts[1][0]) {
+                if (pts[2][0] === pts[3][0] && pts[0][1] === pts[3][1] && pts[1][1] === pts[2][1]) {
+                  isRect = true;
+                  rectFirstEdgeTest = function(pt2) {
+                    return pt2[0] === pts[0][0];
+                  };
+                }
+              } else if (pts[0][1] === pts[1][1]) {
+                if (pts[2][1] === pts[3][1] && pts[0][0] === pts[3][0] && pts[1][0] === pts[2][0]) {
+                  isRect = true;
+                  rectFirstEdgeTest = function(pt2) {
+                    return pt2[1] === pts[0][1];
+                  };
+                }
+              }
+            }
+            function rectContains(pt2, omitFirstEdge) {
+              var x2 = pt2[0];
+              var y2 = pt2[1];
+              if (x2 === BADNUM || x2 < xmin || x2 > xmax || y2 === BADNUM || y2 < ymin || y2 > ymax) {
+                return false;
+              }
+              if (omitFirstEdge && rectFirstEdgeTest(pt2)) return false;
+              return true;
+            }
+            function contains(pt2, omitFirstEdge) {
+              var x2 = pt2[0];
+              var y2 = pt2[1];
+              if (x2 === BADNUM || x2 < xmin || x2 > xmax || y2 === BADNUM || y2 < ymin || y2 > ymax) {
+                return false;
+              }
+              var imax = pts.length;
+              var x1 = pts[0][0];
+              var y1 = pts[0][1];
+              var crossings = 0;
+              var i22;
+              var x0;
+              var y0;
+              var xmini;
+              var ycross;
+              for (i22 = 1; i22 < imax; i22++) {
+                x0 = x1;
+                y0 = y1;
+                x1 = pts[i22][0];
+                y1 = pts[i22][1];
+                xmini = Math.min(x0, x1);
+                if (x2 < xmini || x2 > Math.max(x0, x1) || y2 > Math.max(y0, y1)) {
+                  continue;
+                } else if (y2 < Math.min(y0, y1)) {
+                  if (x2 !== xmini) crossings++;
+                } else {
+                  if (x1 === x0) ycross = y2;
+                  else ycross = y0 + (x2 - x0) * (y1 - y0) / (x1 - x0);
+                  if (y2 === ycross) {
+                    if (i22 === 1 && omitFirstEdge) return false;
+                    return true;
+                  }
+                  if (y2 <= ycross && x2 !== xmini) crossings++;
+                }
+              }
+              return crossings % 2 === 1;
+            }
+            var degenerate = true;
+            var lastPt = pts[0];
+            for (i2 = 1; i2 < pts.length; i2++) {
+              if (lastPt[0] !== pts[i2][0] || lastPt[1] !== pts[i2][1]) {
+                degenerate = false;
+                break;
+              }
+            }
+            return {
+              xmin,
+              xmax,
+              ymin,
+              ymax,
+              pts,
+              contains: isRect ? rectContains : contains,
+              isRect,
+              degenerate
+            };
+          };
+          polygon.isSegmentBent = function isSegmentBent(pts, start, end, tolerance) {
+            var startPt = pts[start];
+            var segment = [pts[end][0] - startPt[0], pts[end][1] - startPt[1]];
+            var segmentSquared = dot2(segment, segment);
+            var segmentLen = Math.sqrt(segmentSquared);
+            var unitPerp = [-segment[1] / segmentLen, segment[0] / segmentLen];
+            var i2;
+            var part;
+            var partParallel;
+            for (i2 = start + 1; i2 < end; i2++) {
+              part = [pts[i2][0] - startPt[0], pts[i2][1] - startPt[1]];
+              partParallel = dot2(part, segment);
+              if (partParallel < 0 || partParallel > segmentSquared || Math.abs(dot2(part, unitPerp)) > tolerance) return true;
+            }
+            return false;
+          };
+          polygon.filter = function filter(pts, tolerance) {
+            var ptsFiltered = [pts[0]];
+            var doneRawIndex = 0;
+            var doneFilteredIndex = 0;
+            function addPt(pt2) {
+              pts.push(pt2);
+              var prevFilterLen = ptsFiltered.length;
+              var iLast = doneRawIndex;
+              ptsFiltered.splice(doneFilteredIndex + 1);
+              for (var i2 = iLast + 1; i2 < pts.length; i2++) {
+                if (i2 === pts.length - 1 || polygon.isSegmentBent(pts, iLast, i2 + 1, tolerance)) {
+                  ptsFiltered.push(pts[i2]);
+                  if (ptsFiltered.length < prevFilterLen - 2) {
+                    doneRawIndex = i2;
+                    doneFilteredIndex = ptsFiltered.length - 1;
+                  }
+                  iLast = i2;
+                }
+              }
+            }
+            if (pts.length > 1) {
+              var lastPt = pts.pop();
+              addPt(lastPt);
+            }
+            return {
+              addPt,
+              raw: pts,
+              filtered: ptsFiltered
+            };
+          };
+        }
+      });
+      var require_constants7 = __commonJS({
+        "src/components/selections/constants.js"(exports, module2) {
+          module2.exports = {
+            // max pixels off straight before a lasso select line counts as bent
+            BENDPX: 1.5,
+            // smallest dimension allowed for a select box
+            MINSELECT: 12,
+            // throttling limit (ms) for selectPoints calls
+            SELECTDELAY: 100,
+            // cache ID suffix for throttle
+            SELECTID: "-select"
+          };
+        }
+      });
+      var require_select = __commonJS({
+        "src/components/selections/select.js"(exports, module2) {
+          var polybool = require_polybooljs();
+          var pointInPolygon = require_nested();
+          var Registry = require_registry();
+          var dashStyle = require_drawing().dashStyle;
+          var Color2 = require_color();
+          var Fx = require_fx();
+          var makeEventData = require_helpers2().makeEventData;
+          var dragHelpers = require_helpers5();
+          var freeMode = dragHelpers.freeMode;
+          var rectMode = dragHelpers.rectMode;
+          var drawMode = dragHelpers.drawMode;
+          var openMode = dragHelpers.openMode;
+          var selectMode = dragHelpers.selectMode;
+          var shapeHelpers = require_helpers8();
+          var shapeConstants = require_constants5();
+          var displayOutlines = require_display_outlines();
+          var clearOutline = require_handle_outline().clearOutline;
+          var newShapeHelpers = require_helpers7();
+          var handleEllipse = newShapeHelpers.handleEllipse;
+          var readPaths = newShapeHelpers.readPaths;
+          var newShapes = require_newshapes().newShapes;
+          var newSelections = require_newselections();
+          var activateLastSelection = require_draw3().activateLastSelection;
+          var Lib = require_lib();
+          var ascending = Lib.sorterAsc;
+          var libPolygon = require_polygon();
+          var throttle = require_throttle();
+          var getFromId = require_axis_ids().getFromId;
+          var clearGlCanvases = require_clear_gl_canvases();
+          var redrawReglTraces = require_subroutines().redrawReglTraces;
+          var constants = require_constants7();
+          var MINSELECT = constants.MINSELECT;
+          var filteredPolygon = libPolygon.filter;
+          var polygonTester = libPolygon.tester;
+          var helpers = require_helpers6();
+          var p2r = helpers.p2r;
+          var axValue = helpers.axValue;
+          var getTransform2 = helpers.getTransform;
+          function hasSubplot(dragOptions) {
+            return dragOptions.subplot !== void 0;
+          }
+          function prepSelect(evt, startX, startY, dragOptions, mode) {
+            var isCartesian = !hasSubplot(dragOptions);
+            var isFreeMode = freeMode(mode);
+            var isRectMode = rectMode(mode);
+            var isOpenMode = openMode(mode);
+            var isDrawMode = drawMode(mode);
+            var isSelectMode = selectMode(mode);
+            var isLine = mode === "drawline";
+            var isEllipse = mode === "drawcircle";
+            var isLineOrEllipse = isLine || isEllipse;
+            var gd2 = dragOptions.gd;
+            var fullLayout = gd2._fullLayout;
+            var immediateSelect = isSelectMode && fullLayout.newselection.mode === "immediate" && isCartesian;
+            var zoomLayer = fullLayout._zoomlayer;
+            var dragBBox = dragOptions.element.getBoundingClientRect();
+            var plotinfo = dragOptions.plotinfo;
+            var transform = getTransform2(plotinfo);
+            var x0 = startX - dragBBox.left;
+            var y0 = startY - dragBBox.top;
+            fullLayout._calcInverseTransform(gd2);
+            var transformedCoords = Lib.apply3DTransform(fullLayout._invTransform)(x0, y0);
+            x0 = transformedCoords[0];
+            y0 = transformedCoords[1];
+            var scaleX2 = fullLayout._invScaleX;
+            var scaleY2 = fullLayout._invScaleY;
+            var x1 = x0;
+            var y1 = y0;
+            var path0 = "M" + x0 + "," + y0;
+            var xAxis = dragOptions.xaxes[0];
+            var yAxis = dragOptions.yaxes[0];
+            var pw = xAxis._length;
+            var ph2 = yAxis._length;
+            var subtract2 = evt.altKey && !(drawMode(mode) && isOpenMode);
+            var filterPoly, selectionTesters, mergedPolygons, currentPolygon;
+            var i2, searchInfo, eventData;
+            coerceSelectionsCache(evt, gd2, dragOptions);
+            if (isFreeMode) {
+              filterPoly = filteredPolygon([[x0, y0]], constants.BENDPX);
+            }
+            var outlines = zoomLayer.selectAll("path.select-outline-" + plotinfo.id).data([1]);
+            var newStyle = isDrawMode ? fullLayout.newshape : fullLayout.newselection;
+            if (isDrawMode) {
+              dragOptions.hasText = newStyle.label.text || newStyle.label.texttemplate;
+            }
+            var fillC = isDrawMode && !isOpenMode ? newStyle.fillcolor : "rgba(0,0,0,0)";
+            var strokeC = newStyle.line.color || (isCartesian ? Color2.contrast(gd2._fullLayout.plot_bgcolor) : "#7f7f7f");
+            outlines.enter().append("path").attr("class", "select-outline select-outline-" + plotinfo.id).style({
+              opacity: isDrawMode ? newStyle.opacity / 2 : 1,
+              "stroke-dasharray": dashStyle(newStyle.line.dash, newStyle.line.width),
+              "stroke-width": newStyle.line.width + "px",
+              "shape-rendering": "crispEdges"
+            }).call(Color2.stroke, strokeC).call(Color2.fill, fillC).attr("fill-rule", "evenodd").classed("cursor-move", isDrawMode ? true : false).attr("transform", transform).attr("d", path0 + "Z");
+            var corners = zoomLayer.append("path").attr("class", "zoombox-corners").style({
+              fill: Color2.background,
+              stroke: Color2.defaultLine,
+              "stroke-width": 1
+            }).attr("transform", transform).attr("d", "M0,0Z");
+            if (isDrawMode && dragOptions.hasText) {
+              var shapeGroup = zoomLayer.select(".label-temp");
+              if (shapeGroup.empty()) {
+                shapeGroup = zoomLayer.append("g").classed("label-temp", true).classed("select-outline", true).style({ opacity: 0.8 });
+              }
+            }
+            var throttleID = fullLayout._uid + constants.SELECTID;
+            var selection = [];
+            var searchTraces = determineSearchTraces(
+              gd2,
+              dragOptions.xaxes,
+              dragOptions.yaxes,
+              dragOptions.subplot
+            );
+            if (immediateSelect && !evt.shiftKey) {
+              dragOptions._clearSubplotSelections = function() {
+                if (!isCartesian) return;
+                var xRef = xAxis._id;
+                var yRef = yAxis._id;
+                deselectSubplot(gd2, xRef, yRef, searchTraces);
+                var selections = (gd2.layout || {}).selections || [];
+                var list = [];
+                var selectionErased = false;
+                for (var q2 = 0; q2 < selections.length; q2++) {
+                  var s2 = fullLayout.selections[q2];
+                  if (!s2 || s2.xref !== xRef || s2.yref !== yRef) {
+                    list.push(selections[q2]);
+                  } else {
+                    selectionErased = true;
+                  }
+                }
+                if (selectionErased) {
+                  gd2._fullLayout._noEmitSelectedAtStart = true;
+                  Registry.call("_guiRelayout", gd2, {
+                    selections: list
+                  });
+                }
+              };
+            }
+            var fillRangeItems = getFillRangeItems(dragOptions);
+            dragOptions.moveFn = function(dx0, dy0) {
+              if (dragOptions._clearSubplotSelections) {
+                dragOptions._clearSubplotSelections();
+                dragOptions._clearSubplotSelections = void 0;
+              }
+              x1 = Math.max(0, Math.min(pw, scaleX2 * dx0 + x0));
+              y1 = Math.max(0, Math.min(ph2, scaleY2 * dy0 + y0));
+              var dx = Math.abs(x1 - x0);
+              var dy = Math.abs(y1 - y0);
+              if (isRectMode) {
+                var direction;
+                var start, end;
+                if (isSelectMode) {
+                  var q2 = fullLayout.selectdirection;
+                  if (q2 === "any") {
+                    if (dy < Math.min(dx * 0.6, MINSELECT)) {
+                      direction = "h";
+                    } else if (dx < Math.min(dy * 0.6, MINSELECT)) {
+                      direction = "v";
+                    } else {
+                      direction = "d";
+                    }
+                  } else {
+                    direction = q2;
+                  }
+                  switch (direction) {
+                    case "h":
+                      start = isEllipse ? ph2 / 2 : 0;
+                      end = ph2;
+                      break;
+                    case "v":
+                      start = isEllipse ? pw / 2 : 0;
+                      end = pw;
+                      break;
+                  }
+                }
+                if (isDrawMode) {
+                  switch (fullLayout.newshape.drawdirection) {
+                    case "vertical":
+                      direction = "h";
+                      start = isEllipse ? ph2 / 2 : 0;
+                      end = ph2;
+                      break;
+                    case "horizontal":
+                      direction = "v";
+                      start = isEllipse ? pw / 2 : 0;
+                      end = pw;
+                      break;
+                    case "ortho":
+                      if (dx < dy) {
+                        direction = "h";
+                        start = y0;
+                        end = y1;
+                      } else {
+                        direction = "v";
+                        start = x0;
+                        end = x1;
+                      }
+                      break;
+                    default:
+                      direction = "d";
+                  }
+                }
+                if (direction === "h") {
+                  currentPolygon = isLineOrEllipse ? handleEllipse(isEllipse, [x1, start], [x1, end]) : (
+                    // using x1 instead of x0 allows adjusting the line while drawing
+                    [[x0, start], [x0, end], [x1, end], [x1, start]]
+                  );
+                  currentPolygon.xmin = isLineOrEllipse ? x1 : Math.min(x0, x1);
+                  currentPolygon.xmax = isLineOrEllipse ? x1 : Math.max(x0, x1);
+                  currentPolygon.ymin = Math.min(start, end);
+                  currentPolygon.ymax = Math.max(start, end);
+                  corners.attr("d", "M" + currentPolygon.xmin + "," + (y0 - MINSELECT) + "h-4v" + 2 * MINSELECT + "h4ZM" + (currentPolygon.xmax - 1) + "," + (y0 - MINSELECT) + "h4v" + 2 * MINSELECT + "h-4Z");
+                } else if (direction === "v") {
+                  currentPolygon = isLineOrEllipse ? handleEllipse(isEllipse, [start, y1], [end, y1]) : (
+                    // using y1 instead of y0 allows adjusting the line while drawing
+                    [[start, y0], [start, y1], [end, y1], [end, y0]]
+                  );
+                  currentPolygon.xmin = Math.min(start, end);
+                  currentPolygon.xmax = Math.max(start, end);
+                  currentPolygon.ymin = isLineOrEllipse ? y1 : Math.min(y0, y1);
+                  currentPolygon.ymax = isLineOrEllipse ? y1 : Math.max(y0, y1);
+                  corners.attr("d", "M" + (x0 - MINSELECT) + "," + currentPolygon.ymin + "v-4h" + 2 * MINSELECT + "v4ZM" + (x0 - MINSELECT) + "," + (currentPolygon.ymax - 1) + "v4h" + 2 * MINSELECT + "v-4Z");
+                } else if (direction === "d") {
+                  currentPolygon = isLineOrEllipse ? handleEllipse(isEllipse, [x0, y0], [x1, y1]) : [[x0, y0], [x0, y1], [x1, y1], [x1, y0]];
+                  currentPolygon.xmin = Math.min(x0, x1);
+                  currentPolygon.xmax = Math.max(x0, x1);
+                  currentPolygon.ymin = Math.min(y0, y1);
+                  currentPolygon.ymax = Math.max(y0, y1);
+                  corners.attr("d", "M0,0Z");
+                }
+              } else if (isFreeMode) {
+                filterPoly.addPt([x1, y1]);
+                currentPolygon = filterPoly.filtered;
+              }
+              if (dragOptions.selectionDefs && dragOptions.selectionDefs.length) {
+                mergedPolygons = mergePolygons(dragOptions.mergedPolygons, currentPolygon, subtract2);
+                currentPolygon.subtract = subtract2;
+                selectionTesters = multiTester(dragOptions.selectionDefs.concat([currentPolygon]));
+              } else {
+                mergedPolygons = [currentPolygon];
+                selectionTesters = polygonTester(currentPolygon);
+              }
+              displayOutlines(convertPoly(mergedPolygons, isOpenMode), outlines, dragOptions);
+              if (isSelectMode) {
+                var _res = reselect(gd2, false);
+                var extraPoints = _res.eventData ? _res.eventData.points.slice() : [];
+                _res = reselect(gd2, false, selectionTesters, searchTraces, dragOptions);
+                selectionTesters = _res.selectionTesters;
+                eventData = _res.eventData;
+                var poly;
+                if (filterPoly) {
+                  poly = filterPoly.filtered;
+                } else {
+                  poly = castMultiPolygon(mergedPolygons);
+                }
+                throttle.throttle(
+                  throttleID,
+                  constants.SELECTDELAY,
+                  function() {
+                    selection = _doSelect(selectionTesters, searchTraces);
+                    var newPoints = selection.slice();
+                    for (var w2 = 0; w2 < extraPoints.length; w2++) {
+                      var p2 = extraPoints[w2];
+                      var found = false;
+                      for (var u2 = 0; u2 < newPoints.length; u2++) {
+                        if (newPoints[u2].curveNumber === p2.curveNumber && newPoints[u2].pointNumber === p2.pointNumber) {
+                          found = true;
+                          break;
+                        }
+                      }
+                      if (!found) newPoints.push(p2);
+                    }
+                    if (newPoints.length) {
+                      if (!eventData) eventData = {};
+                      eventData.points = newPoints;
+                    }
+                    fillRangeItems(eventData, poly);
+                    emitSelecting(gd2, eventData);
+                  }
+                );
+              }
+            };
+            dragOptions.clickFn = function(numClicks, evt2) {
+              corners.remove();
+              if (gd2._fullLayout._activeShapeIndex >= 0) {
+                gd2._fullLayout._deactivateShape(gd2);
+                return;
+              }
+              if (isDrawMode) return;
+              var clickmode = fullLayout.clickmode;
+              throttle.done(throttleID).then(function() {
+                throttle.clear(throttleID);
+                if (numClicks === 2) {
+                  outlines.remove();
+                  for (i2 = 0; i2 < searchTraces.length; i2++) {
+                    searchInfo = searchTraces[i2];
+                    searchInfo._module.selectPoints(searchInfo, false);
+                  }
+                  updateSelectedState(gd2, searchTraces);
+                  clearSelectionsCache(dragOptions);
+                  emitDeselect(gd2);
+                  if (searchTraces.length) {
+                    var clickedXaxis = searchTraces[0].xaxis;
+                    var clickedYaxis = searchTraces[0].yaxis;
+                    if (clickedXaxis && clickedYaxis) {
+                      var subSelections = [];
+                      var allSelections = gd2._fullLayout.selections;
+                      for (var k2 = 0; k2 < allSelections.length; k2++) {
+                        var s2 = allSelections[k2];
+                        if (!s2) continue;
+                        if (s2.xref !== clickedXaxis._id || s2.yref !== clickedYaxis._id) {
+                          subSelections.push(s2);
+                        }
+                      }
+                      if (subSelections.length < allSelections.length) {
+                        gd2._fullLayout._noEmitSelectedAtStart = true;
+                        Registry.call("_guiRelayout", gd2, {
+                          selections: subSelections
+                        });
+                      }
+                    }
+                  }
+                } else {
+                  if (clickmode.indexOf("select") > -1) {
+                    selectOnClick(
+                      evt2,
+                      gd2,
+                      dragOptions.xaxes,
+                      dragOptions.yaxes,
+                      dragOptions.subplot,
+                      dragOptions,
+                      outlines
+                    );
+                  }
+                  if (clickmode === "event") {
+                    emitSelected(gd2, void 0);
+                  }
+                }
+                Fx.click(gd2, evt2, plotinfo.id);
+              }).catch(Lib.error);
+            };
+            dragOptions.doneFn = function() {
+              corners.remove();
+              throttle.done(throttleID).then(function() {
+                throttle.clear(throttleID);
+                if (!immediateSelect && currentPolygon && dragOptions.selectionDefs) {
+                  currentPolygon.subtract = subtract2;
+                  dragOptions.selectionDefs.push(currentPolygon);
+                  dragOptions.mergedPolygons.length = 0;
+                  [].push.apply(dragOptions.mergedPolygons, mergedPolygons);
+                }
+                if (immediateSelect || isDrawMode) {
+                  clearSelectionsCache(dragOptions, immediateSelect);
+                }
+                if (dragOptions.doneFnCompleted) {
+                  dragOptions.doneFnCompleted(selection);
+                }
+                if (isSelectMode) {
+                  emitSelected(gd2, eventData);
+                }
+              }).catch(Lib.error);
+            };
+          }
+          function selectOnClick(evt, gd2, xAxes, yAxes, subplot, dragOptions, polygonOutlines) {
+            var hoverData = gd2._hoverdata;
+            var fullLayout = gd2._fullLayout;
+            var clickmode = fullLayout.clickmode;
+            var sendEvents = clickmode.indexOf("event") > -1;
+            var selection = [];
+            var searchTraces, searchInfo, currentSelectionDef, selectionTesters, traceSelection;
+            var thisTracesSelection, pointOrBinSelected, subtract2, eventData, i2;
+            if (isHoverDataSet(hoverData)) {
+              coerceSelectionsCache(evt, gd2, dragOptions);
+              searchTraces = determineSearchTraces(gd2, xAxes, yAxes, subplot);
+              var clickedPtInfo = extractClickedPtInfo(hoverData, searchTraces);
+              var isBinnedTrace = clickedPtInfo.pointNumbers.length > 0;
+              if (isBinnedTrace ? isOnlyThisBinSelected(searchTraces, clickedPtInfo) : isOnlyOnePointSelected(searchTraces) && (pointOrBinSelected = isPointOrBinSelected(clickedPtInfo))) {
+                if (polygonOutlines) polygonOutlines.remove();
+                for (i2 = 0; i2 < searchTraces.length; i2++) {
+                  searchInfo = searchTraces[i2];
+                  searchInfo._module.selectPoints(searchInfo, false);
+                }
+                updateSelectedState(gd2, searchTraces);
+                clearSelectionsCache(dragOptions);
+                if (sendEvents) {
+                  emitDeselect(gd2);
+                }
+              } else {
+                subtract2 = evt.shiftKey && (pointOrBinSelected !== void 0 ? pointOrBinSelected : isPointOrBinSelected(clickedPtInfo));
+                currentSelectionDef = newPointSelectionDef(clickedPtInfo.pointNumber, clickedPtInfo.searchInfo, subtract2);
+                var allSelectionDefs = dragOptions.selectionDefs.concat([currentSelectionDef]);
+                selectionTesters = multiTester(allSelectionDefs);
+                for (i2 = 0; i2 < searchTraces.length; i2++) {
+                  traceSelection = searchTraces[i2]._module.selectPoints(searchTraces[i2], selectionTesters);
+                  thisTracesSelection = fillSelectionItem(traceSelection, searchTraces[i2]);
+                  if (selection.length) {
+                    for (var j2 = 0; j2 < thisTracesSelection.length; j2++) {
+                      selection.push(thisTracesSelection[j2]);
+                    }
+                  } else selection = thisTracesSelection;
+                }
+                eventData = { points: selection };
+                updateSelectedState(gd2, searchTraces, eventData);
+                if (currentSelectionDef && dragOptions) {
+                  dragOptions.selectionDefs.push(currentSelectionDef);
+                }
+                if (polygonOutlines) {
+                  var polygons = dragOptions.mergedPolygons;
+                  var isOpenMode = openMode(dragOptions.dragmode);
+                  displayOutlines(convertPoly(polygons, isOpenMode), polygonOutlines, dragOptions);
+                }
+                if (sendEvents) {
+                  emitSelected(gd2, eventData);
+                }
+              }
+            }
+          }
+          function newPointSelectionDef(pointNumber, searchInfo, subtract2) {
+            return {
+              pointNumber,
+              searchInfo,
+              subtract: !!subtract2
+            };
+          }
+          function isPointSelectionDef(o2) {
+            return "pointNumber" in o2 && "searchInfo" in o2;
+          }
+          function newPointNumTester(pointSelectionDef) {
+            return {
+              xmin: 0,
+              xmax: 0,
+              ymin: 0,
+              ymax: 0,
+              pts: [],
+              contains: function(pt2, omitFirstEdge, pointNumber, searchInfo) {
+                var idxWantedTrace = pointSelectionDef.searchInfo.cd[0].trace.index;
+                var idxActualTrace = searchInfo.cd[0].trace.index;
+                return idxActualTrace === idxWantedTrace && pointNumber === pointSelectionDef.pointNumber;
+              },
+              isRect: false,
+              degenerate: false,
+              subtract: !!pointSelectionDef.subtract
+            };
+          }
+          function multiTester(list) {
+            if (!list.length) return;
+            var testers = [];
+            var xmin = isPointSelectionDef(list[0]) ? 0 : list[0][0][0];
+            var xmax = xmin;
+            var ymin = isPointSelectionDef(list[0]) ? 0 : list[0][0][1];
+            var ymax = ymin;
+            for (var i2 = 0; i2 < list.length; i2++) {
+              if (isPointSelectionDef(list[i2])) {
+                testers.push(newPointNumTester(list[i2]));
+              } else {
+                var tester = polygonTester(list[i2]);
+                tester.subtract = !!list[i2].subtract;
+                testers.push(tester);
+                xmin = Math.min(xmin, tester.xmin);
+                xmax = Math.max(xmax, tester.xmax);
+                ymin = Math.min(ymin, tester.ymin);
+                ymax = Math.max(ymax, tester.ymax);
+              }
+            }
+            function contains(pt2, arg, pointNumber, searchInfo) {
+              var contained = false;
+              for (var i22 = 0; i22 < testers.length; i22++) {
+                if (testers[i22].contains(pt2, arg, pointNumber, searchInfo)) {
+                  contained = !testers[i22].subtract;
+                }
+              }
+              return contained;
+            }
+            return {
+              xmin,
+              xmax,
+              ymin,
+              ymax,
+              pts: [],
+              contains,
+              isRect: false,
+              degenerate: false
+            };
+          }
+          function coerceSelectionsCache(evt, gd2, dragOptions) {
+            var fullLayout = gd2._fullLayout;
+            var plotinfo = dragOptions.plotinfo;
+            var dragmode = dragOptions.dragmode;
+            var selectingOnSameSubplot = fullLayout._lastSelectedSubplot && fullLayout._lastSelectedSubplot === plotinfo.id;
+            var hasModifierKey = (evt.shiftKey || evt.altKey) && !(drawMode(dragmode) && openMode(dragmode));
+            if (selectingOnSameSubplot && hasModifierKey && plotinfo.selection && plotinfo.selection.selectionDefs && !dragOptions.selectionDefs) {
+              dragOptions.selectionDefs = plotinfo.selection.selectionDefs;
+              dragOptions.mergedPolygons = plotinfo.selection.mergedPolygons;
+            } else if (!hasModifierKey || !plotinfo.selection) {
+              clearSelectionsCache(dragOptions);
+            }
+            if (!selectingOnSameSubplot) {
+              clearOutline(gd2);
+              fullLayout._lastSelectedSubplot = plotinfo.id;
+            }
+          }
+          function hasActiveShape(gd2) {
+            return gd2._fullLayout._activeShapeIndex >= 0;
+          }
+          function hasActiveSelection(gd2) {
+            return gd2._fullLayout._activeSelectionIndex >= 0;
+          }
+          function clearSelectionsCache(dragOptions, immediateSelect) {
+            var dragmode = dragOptions.dragmode;
+            var plotinfo = dragOptions.plotinfo;
+            var gd2 = dragOptions.gd;
+            if (hasActiveShape(gd2)) {
+              gd2._fullLayout._deactivateShape(gd2);
+            }
+            if (hasActiveSelection(gd2)) {
+              gd2._fullLayout._deactivateSelection(gd2);
+            }
+            var fullLayout = gd2._fullLayout;
+            var zoomLayer = fullLayout._zoomlayer;
+            var isDrawMode = drawMode(dragmode);
+            var isSelectMode = selectMode(dragmode);
+            if (isDrawMode || isSelectMode) {
+              var outlines = zoomLayer.selectAll(".select-outline-" + plotinfo.id);
+              if (outlines && gd2._fullLayout._outlining) {
+                var shapes;
+                if (isDrawMode) {
+                  shapes = newShapes(outlines, dragOptions);
+                }
+                if (shapes) {
+                  Registry.call("_guiRelayout", gd2, {
+                    shapes
+                  });
+                }
+                var selections;
+                if (isSelectMode && !hasSubplot(dragOptions)) {
+                  selections = newSelections(outlines, dragOptions);
+                }
+                if (selections) {
+                  gd2._fullLayout._noEmitSelectedAtStart = true;
+                  Registry.call("_guiRelayout", gd2, {
+                    selections
+                  }).then(function() {
+                    if (immediateSelect) {
+                      activateLastSelection(gd2);
+                    }
+                  });
+                }
+                gd2._fullLayout._outlining = false;
+              }
+            }
+            plotinfo.selection = {};
+            plotinfo.selection.selectionDefs = dragOptions.selectionDefs = [];
+            plotinfo.selection.mergedPolygons = dragOptions.mergedPolygons = [];
+          }
+          function getAxId(ax) {
+            return ax._id;
+          }
+          function determineSearchTraces(gd2, xAxes, yAxes, subplot) {
+            if (!gd2.calcdata) return [];
+            var searchTraces = [];
+            var xAxisIds = xAxes.map(getAxId);
+            var yAxisIds = yAxes.map(getAxId);
+            var cd2, trace, i2;
+            for (i2 = 0; i2 < gd2.calcdata.length; i2++) {
+              cd2 = gd2.calcdata[i2];
+              trace = cd2[0].trace;
+              if (trace.visible !== true || !trace._module || !trace._module.selectPoints) continue;
+              if (hasSubplot({ subplot }) && (trace.subplot === subplot || trace.geo === subplot)) {
+                searchTraces.push(createSearchInfo(trace._module, cd2, xAxes[0], yAxes[0]));
+              } else if (trace.type === "splom") {
+                if (trace._xaxes[xAxisIds[0]] && trace._yaxes[yAxisIds[0]]) {
+                  var info = createSearchInfo(trace._module, cd2, xAxes[0], yAxes[0]);
+                  info.scene = gd2._fullLayout._splomScenes[trace.uid];
+                  searchTraces.push(info);
+                }
+              } else if (trace.type === "sankey") {
+                var sankeyInfo = createSearchInfo(trace._module, cd2, xAxes[0], yAxes[0]);
+                searchTraces.push(sankeyInfo);
+              } else {
+                if (xAxisIds.indexOf(trace.xaxis) === -1 && (!trace._xA || !trace._xA.overlaying)) continue;
+                if (yAxisIds.indexOf(trace.yaxis) === -1 && (!trace._yA || !trace._yA.overlaying)) continue;
+                searchTraces.push(createSearchInfo(
+                  trace._module,
+                  cd2,
+                  getFromId(gd2, trace.xaxis),
+                  getFromId(gd2, trace.yaxis)
+                ));
+              }
+            }
+            return searchTraces;
+          }
+          function createSearchInfo(module22, calcData, xaxis, yaxis) {
+            return {
+              _module: module22,
+              cd: calcData,
+              xaxis,
+              yaxis
+            };
+          }
+          function isHoverDataSet(hoverData) {
+            return hoverData && Array.isArray(hoverData) && hoverData[0].hoverOnBox !== true;
+          }
+          function extractClickedPtInfo(hoverData, searchTraces) {
+            var hoverDatum = hoverData[0];
+            var pointNumber = -1;
+            var pointNumbers = [];
+            var searchInfo, i2;
+            for (i2 = 0; i2 < searchTraces.length; i2++) {
+              searchInfo = searchTraces[i2];
+              if (hoverDatum.fullData.index === searchInfo.cd[0].trace.index) {
+                if (hoverDatum.hoverOnBox === true) {
+                  break;
+                }
+                if (hoverDatum.pointNumber !== void 0) {
+                  pointNumber = hoverDatum.pointNumber;
+                } else if (hoverDatum.binNumber !== void 0) {
+                  pointNumber = hoverDatum.binNumber;
+                  pointNumbers = hoverDatum.pointNumbers;
+                }
+                break;
+              }
+            }
+            return {
+              pointNumber,
+              pointNumbers,
+              searchInfo
+            };
+          }
+          function isPointOrBinSelected(clickedPtInfo) {
+            var trace = clickedPtInfo.searchInfo.cd[0].trace;
+            var ptNum = clickedPtInfo.pointNumber;
+            var ptNums = clickedPtInfo.pointNumbers;
+            var ptNumsSet = ptNums.length > 0;
+            var ptNumToTest = ptNumsSet ? ptNums[0] : ptNum;
+            return trace.selectedpoints ? trace.selectedpoints.indexOf(ptNumToTest) > -1 : false;
+          }
+          function isOnlyThisBinSelected(searchTraces, clickedPtInfo) {
+            var tracesWithSelectedPts = [];
+            var searchInfo, trace, isSameTrace, i2;
+            for (i2 = 0; i2 < searchTraces.length; i2++) {
+              searchInfo = searchTraces[i2];
+              if (searchInfo.cd[0].trace.selectedpoints && searchInfo.cd[0].trace.selectedpoints.length > 0) {
+                tracesWithSelectedPts.push(searchInfo);
+              }
+            }
+            if (tracesWithSelectedPts.length === 1) {
+              isSameTrace = tracesWithSelectedPts[0] === clickedPtInfo.searchInfo;
+              if (isSameTrace) {
+                trace = clickedPtInfo.searchInfo.cd[0].trace;
+                if (trace.selectedpoints.length === clickedPtInfo.pointNumbers.length) {
+                  for (i2 = 0; i2 < clickedPtInfo.pointNumbers.length; i2++) {
+                    if (trace.selectedpoints.indexOf(clickedPtInfo.pointNumbers[i2]) < 0) {
+                      return false;
+                    }
+                  }
+                  return true;
+                }
+              }
+            }
+            return false;
+          }
+          function isOnlyOnePointSelected(searchTraces) {
+            var len2 = 0;
+            var searchInfo, trace, i2;
+            for (i2 = 0; i2 < searchTraces.length; i2++) {
+              searchInfo = searchTraces[i2];
+              trace = searchInfo.cd[0].trace;
+              if (trace.selectedpoints) {
+                if (trace.selectedpoints.length > 1) return false;
+                len2 += trace.selectedpoints.length;
+                if (len2 > 1) return false;
+              }
+            }
+            return len2 === 1;
+          }
+          function updateSelectedState(gd2, searchTraces, eventData) {
+            var i2;
+            for (i2 = 0; i2 < searchTraces.length; i2++) {
+              var fullInputTrace = searchTraces[i2].cd[0].trace._fullInput;
+              var tracePreGUI = gd2._fullLayout._tracePreGUI[fullInputTrace.uid] || {};
+              if (tracePreGUI.selectedpoints === void 0) {
+                tracePreGUI.selectedpoints = fullInputTrace._input.selectedpoints || null;
+              }
+            }
+            var trace;
+            if (eventData) {
+              var pts = eventData.points || [];
+              for (i2 = 0; i2 < searchTraces.length; i2++) {
+                trace = searchTraces[i2].cd[0].trace;
+                trace._input.selectedpoints = trace._fullInput.selectedpoints = [];
+                if (trace._fullInput !== trace) trace.selectedpoints = [];
+              }
+              for (var k2 = 0; k2 < pts.length; k2++) {
+                var pt2 = pts[k2];
+                var data = pt2.data;
+                var fullData = pt2.fullData;
+                var pointIndex = pt2.pointIndex;
+                var pointIndices = pt2.pointIndices;
+                if (pointIndices) {
+                  [].push.apply(data.selectedpoints, pointIndices);
+                  if (trace._fullInput !== trace) {
+                    [].push.apply(fullData.selectedpoints, pointIndices);
+                  }
+                } else {
+                  data.selectedpoints.push(pointIndex);
+                  if (trace._fullInput !== trace) {
+                    fullData.selectedpoints.push(pointIndex);
+                  }
+                }
+              }
+            } else {
+              for (i2 = 0; i2 < searchTraces.length; i2++) {
+                trace = searchTraces[i2].cd[0].trace;
+                delete trace.selectedpoints;
+                delete trace._input.selectedpoints;
+                if (trace._fullInput !== trace) {
+                  delete trace._fullInput.selectedpoints;
+                }
+              }
+            }
+            updateReglSelectedState(gd2, searchTraces);
+          }
+          function updateReglSelectedState(gd2, searchTraces) {
+            var hasRegl = false;
+            for (var i2 = 0; i2 < searchTraces.length; i2++) {
+              var searchInfo = searchTraces[i2];
+              var cd2 = searchInfo.cd;
+              if (Registry.traceIs(cd2[0].trace, "regl")) {
+                hasRegl = true;
+              }
+              var _module = searchInfo._module;
+              var fn = _module.styleOnSelect || _module.style;
+              if (fn) {
+                fn(gd2, cd2, cd2[0].node3);
+                if (cd2[0].nodeRangePlot3) fn(gd2, cd2, cd2[0].nodeRangePlot3);
+              }
+            }
+            if (hasRegl) {
+              clearGlCanvases(gd2);
+              redrawReglTraces(gd2);
+            }
+          }
+          function mergePolygons(list, poly, subtract2) {
+            var fn = subtract2 ? polybool.difference : polybool.union;
+            var res = fn({
+              regions: list
+            }, {
+              regions: [poly]
+            });
+            var allPolygons = res.regions.reverse();
+            for (var i2 = 0; i2 < allPolygons.length; i2++) {
+              var polygon = allPolygons[i2];
+              polygon.subtract = getSubtract(polygon, allPolygons.slice(0, i2));
+            }
+            return allPolygons;
+          }
+          function fillSelectionItem(selection, searchInfo) {
+            if (Array.isArray(selection)) {
+              var cd2 = searchInfo.cd;
+              var trace = searchInfo.cd[0].trace;
+              for (var i2 = 0; i2 < selection.length; i2++) {
+                selection[i2] = makeEventData(selection[i2], trace, cd2);
+              }
+            }
+            return selection;
+          }
+          function convertPoly(polygonsIn, isOpenMode) {
+            var polygonsOut = [];
+            for (var i2 = 0; i2 < polygonsIn.length; i2++) {
+              polygonsOut[i2] = [];
+              for (var j2 = 0; j2 < polygonsIn[i2].length; j2++) {
+                polygonsOut[i2][j2] = [];
+                polygonsOut[i2][j2][0] = j2 ? "L" : "M";
+                for (var k2 = 0; k2 < polygonsIn[i2][j2].length; k2++) {
+                  polygonsOut[i2][j2].push(
+                    polygonsIn[i2][j2][k2]
+                  );
+                }
+              }
+              if (!isOpenMode) {
+                polygonsOut[i2].push([
+                  "Z",
+                  polygonsOut[i2][0][1],
+                  // initial x
+                  polygonsOut[i2][0][2]
+                  // initial y
+                ]);
+              }
+            }
+            return polygonsOut;
+          }
+          function _doSelect(selectionTesters, searchTraces) {
+            var allSelections = [];
+            var thisSelection;
+            var traceSelection;
+            for (var i2 = 0; i2 < searchTraces.length; i2++) {
+              var searchInfo = searchTraces[i2];
+              traceSelection = searchInfo._module.selectPoints(searchInfo, selectionTesters);
+              thisSelection = fillSelectionItem(traceSelection, searchInfo);
+              allSelections = allSelections.concat(thisSelection);
+            }
+            return allSelections;
+          }
+          function reselect(gd2, mayEmitSelected, selectionTesters, searchTraces, dragOptions) {
+            var hadSearchTraces = !!searchTraces;
+            var plotinfo, xRef, yRef;
+            if (dragOptions) {
+              plotinfo = dragOptions.plotinfo;
+              xRef = dragOptions.xaxes[0]._id;
+              yRef = dragOptions.yaxes[0]._id;
+            }
+            var allSelections = [];
+            var allSearchTraces = [];
+            var layoutPolygons = getLayoutPolygons(gd2);
+            var fullLayout = gd2._fullLayout;
+            if (plotinfo) {
+              var zoomLayer = fullLayout._zoomlayer;
+              var mode = fullLayout.dragmode;
+              var isDrawMode = drawMode(mode);
+              var isSelectMode = selectMode(mode);
+              if (isDrawMode || isSelectMode) {
+                var xaxis = getFromId(gd2, xRef, "x");
+                var yaxis = getFromId(gd2, yRef, "y");
+                if (xaxis && yaxis) {
+                  var outlines = zoomLayer.selectAll(".select-outline-" + plotinfo.id);
+                  if (outlines && gd2._fullLayout._outlining) {
+                    if (outlines.length) {
+                      var e2 = outlines[0][0];
+                      var d2 = e2.getAttribute("d");
+                      var outlinePolys = readPaths(d2, gd2, plotinfo);
+                      var draftPolygons = [];
+                      for (var u2 = 0; u2 < outlinePolys.length; u2++) {
+                        var p2 = outlinePolys[u2];
+                        var polygon = [];
+                        for (var t4 = 0; t4 < p2.length; t4++) {
+                          polygon.push([
+                            convert(xaxis, p2[t4][1]),
+                            convert(yaxis, p2[t4][2])
+                          ]);
+                        }
+                        polygon.xref = xRef;
+                        polygon.yref = yRef;
+                        polygon.subtract = getSubtract(polygon, draftPolygons);
+                        draftPolygons.push(polygon);
+                      }
+                      layoutPolygons = layoutPolygons.concat(draftPolygons);
+                    }
+                  }
+                }
+              }
+            }
+            var subplots = xRef && yRef ? [xRef + yRef] : fullLayout._subplots.cartesian;
+            epmtySplomSelectionBatch(gd2);
+            var seenSplom = {};
+            for (var i2 = 0; i2 < subplots.length; i2++) {
+              var subplot = subplots[i2];
+              var yAt = subplot.indexOf("y");
+              var _xRef = subplot.slice(0, yAt);
+              var _yRef = subplot.slice(yAt);
+              var _selectionTesters = xRef && yRef ? selectionTesters : void 0;
+              _selectionTesters = addTester(layoutPolygons, _xRef, _yRef, _selectionTesters);
+              if (_selectionTesters) {
+                var _searchTraces = searchTraces;
+                if (!hadSearchTraces) {
+                  var _xA = getFromId(gd2, _xRef, "x");
+                  var _yA = getFromId(gd2, _yRef, "y");
+                  _searchTraces = determineSearchTraces(
+                    gd2,
+                    [_xA],
+                    [_yA],
+                    subplot
+                  );
+                  for (var w2 = 0; w2 < _searchTraces.length; w2++) {
+                    var s2 = _searchTraces[w2];
+                    var cd0 = s2.cd[0];
+                    var trace = cd0.trace;
+                    if (s2._module.name === "scattergl" && !cd0.t.xpx) {
+                      var x2 = trace.x;
+                      var y2 = trace.y;
+                      var len2 = trace._length;
+                      cd0.t.xpx = [];
+                      cd0.t.ypx = [];
+                      for (var j2 = 0; j2 < len2; j2++) {
+                        cd0.t.xpx[j2] = _xA.c2p(x2[j2]);
+                        cd0.t.ypx[j2] = _yA.c2p(y2[j2]);
+                      }
+                    }
+                    if (s2._module.name === "splom") {
+                      if (!seenSplom[trace.uid]) {
+                        seenSplom[trace.uid] = true;
+                      }
+                    }
+                  }
+                }
+                var selection = _doSelect(_selectionTesters, _searchTraces);
+                allSelections = allSelections.concat(selection);
+                allSearchTraces = allSearchTraces.concat(_searchTraces);
+              }
+            }
+            var eventData = { points: allSelections };
+            updateSelectedState(gd2, allSearchTraces, eventData);
+            var clickmode = fullLayout.clickmode;
+            var sendEvents = clickmode.indexOf("event") > -1 && mayEmitSelected;
+            if (!plotinfo && // get called from plot_api & plots
+            mayEmitSelected) {
+              var activePolygons = getLayoutPolygons(gd2, true);
+              if (activePolygons.length) {
+                var xref = activePolygons[0].xref;
+                var yref = activePolygons[0].yref;
+                if (xref && yref) {
+                  var poly = castMultiPolygon(activePolygons);
+                  var fillRangeItems = makeFillRangeItems([
+                    getFromId(gd2, xref, "x"),
+                    getFromId(gd2, yref, "y")
+                  ]);
+                  fillRangeItems(eventData, poly);
+                }
+              }
+              if (gd2._fullLayout._noEmitSelectedAtStart) {
+                gd2._fullLayout._noEmitSelectedAtStart = false;
+              } else {
+                if (sendEvents) emitSelected(gd2, eventData);
+              }
+              fullLayout._reselect = false;
+            }
+            if (!plotinfo && // get called from plot_api & plots
+            fullLayout._deselect) {
+              var deselect = fullLayout._deselect;
+              xRef = deselect.xref;
+              yRef = deselect.yref;
+              if (!subplotSelected(xRef, yRef, allSearchTraces)) {
+                deselectSubplot(gd2, xRef, yRef, searchTraces);
+              }
+              if (sendEvents) {
+                if (eventData.points.length) {
+                  emitSelected(gd2, eventData);
+                } else {
+                  emitDeselect(gd2);
+                }
+              }
+              fullLayout._deselect = false;
+            }
+            return {
+              eventData,
+              selectionTesters
+            };
+          }
+          function epmtySplomSelectionBatch(gd2) {
+            var cd2 = gd2.calcdata;
+            if (!cd2) return;
+            for (var i2 = 0; i2 < cd2.length; i2++) {
+              var cd0 = cd2[i2][0];
+              var trace = cd0.trace;
+              var splomScenes = gd2._fullLayout._splomScenes;
+              if (splomScenes) {
+                var scene = splomScenes[trace.uid];
+                if (scene) {
+                  scene.selectBatch = [];
+                }
+              }
+            }
+          }
+          function subplotSelected(xRef, yRef, searchTraces) {
+            for (var i2 = 0; i2 < searchTraces.length; i2++) {
+              var s2 = searchTraces[i2];
+              if (s2.xaxis && s2.xaxis._id === xRef && (s2.yaxis && s2.yaxis._id === yRef)) {
+                return true;
+              }
+            }
+            return false;
+          }
+          function deselectSubplot(gd2, xRef, yRef, searchTraces) {
+            searchTraces = determineSearchTraces(
+              gd2,
+              [getFromId(gd2, xRef, "x")],
+              [getFromId(gd2, yRef, "y")],
+              xRef + yRef
+            );
+            for (var k2 = 0; k2 < searchTraces.length; k2++) {
+              var searchInfo = searchTraces[k2];
+              searchInfo._module.selectPoints(searchInfo, false);
+            }
+            updateSelectedState(gd2, searchTraces);
+          }
+          function addTester(layoutPolygons, xRef, yRef, selectionTesters) {
+            var mergedPolygons;
+            for (var i2 = 0; i2 < layoutPolygons.length; i2++) {
+              var currentPolygon = layoutPolygons[i2];
+              if (xRef !== currentPolygon.xref || yRef !== currentPolygon.yref) continue;
+              if (mergedPolygons) {
+                var subtract2 = !!currentPolygon.subtract;
+                mergedPolygons = mergePolygons(mergedPolygons, currentPolygon, subtract2);
+                selectionTesters = multiTester(mergedPolygons);
+              } else {
+                mergedPolygons = [currentPolygon];
+                selectionTesters = polygonTester(currentPolygon);
+              }
+            }
+            return selectionTesters;
+          }
+          function getLayoutPolygons(gd2, onlyActiveOnes) {
+            var allPolygons = [];
+            var fullLayout = gd2._fullLayout;
+            var allSelections = fullLayout.selections;
+            var len2 = allSelections.length;
+            for (var i2 = 0; i2 < len2; i2++) {
+              if (onlyActiveOnes && i2 !== fullLayout._activeSelectionIndex) continue;
+              var selection = allSelections[i2];
+              if (!selection) continue;
+              var xref = selection.xref;
+              var yref = selection.yref;
+              var xaxis = getFromId(gd2, xref, "x");
+              var yaxis = getFromId(gd2, yref, "y");
+              var xmin, xmax, ymin, ymax;
+              var polygon;
+              if (selection.type === "rect") {
+                polygon = [];
+                var x0 = convert(xaxis, selection.x0);
+                var x1 = convert(xaxis, selection.x1);
+                var y0 = convert(yaxis, selection.y0);
+                var y1 = convert(yaxis, selection.y1);
+                polygon = [[x0, y0], [x0, y1], [x1, y1], [x1, y0]];
+                xmin = Math.min(x0, x1);
+                xmax = Math.max(x0, x1);
+                ymin = Math.min(y0, y1);
+                ymax = Math.max(y0, y1);
+                polygon.xmin = xmin;
+                polygon.xmax = xmax;
+                polygon.ymin = ymin;
+                polygon.ymax = ymax;
+                polygon.xref = xref;
+                polygon.yref = yref;
+                polygon.subtract = false;
+                polygon.isRect = true;
+                allPolygons.push(polygon);
+              } else if (selection.type === "path") {
+                var segments = selection.path.split("Z");
+                var multiPolygons = [];
+                for (var j2 = 0; j2 < segments.length; j2++) {
+                  var path = segments[j2];
+                  if (!path) continue;
+                  path += "Z";
+                  var allX = shapeHelpers.extractPathCoords(path, shapeConstants.paramIsX, "raw");
+                  var allY = shapeHelpers.extractPathCoords(path, shapeConstants.paramIsY, "raw");
+                  xmin = Infinity;
+                  xmax = -Infinity;
+                  ymin = Infinity;
+                  ymax = -Infinity;
+                  polygon = [];
+                  for (var k2 = 0; k2 < allX.length; k2++) {
+                    var x2 = convert(xaxis, allX[k2]);
+                    var y2 = convert(yaxis, allY[k2]);
+                    polygon.push([x2, y2]);
+                    xmin = Math.min(x2, xmin);
+                    xmax = Math.max(x2, xmax);
+                    ymin = Math.min(y2, ymin);
+                    ymax = Math.max(y2, ymax);
+                  }
+                  polygon.xmin = xmin;
+                  polygon.xmax = xmax;
+                  polygon.ymin = ymin;
+                  polygon.ymax = ymax;
+                  polygon.xref = xref;
+                  polygon.yref = yref;
+                  polygon.subtract = getSubtract(polygon, multiPolygons);
+                  multiPolygons.push(polygon);
+                  allPolygons.push(polygon);
+                }
+              }
+            }
+            return allPolygons;
+          }
+          function getSubtract(polygon, previousPolygons) {
+            var subtract2 = false;
+            for (var i2 = 0; i2 < previousPolygons.length; i2++) {
+              var previousPolygon = previousPolygons[i2];
+              for (var k2 = 0; k2 < polygon.length; k2++) {
+                if (pointInPolygon(polygon[k2], previousPolygon)) {
+                  subtract2 = !subtract2;
+                  break;
+                }
+              }
+            }
+            return subtract2;
+          }
+          function convert(ax, d2) {
+            if (ax.type === "date") d2 = d2.replace("_", " ");
+            return ax.type === "log" ? ax.c2p(d2) : ax.r2p(d2, null, ax.calendar);
+          }
+          function castMultiPolygon(allPolygons) {
+            var len2 = allPolygons.length;
+            var p2 = [];
+            for (var i2 = 0; i2 < len2; i2++) {
+              var polygon = allPolygons[i2];
+              p2 = p2.concat(polygon);
+              p2 = p2.concat([polygon[0]]);
+            }
+            return computeRectAndRanges(p2);
+          }
+          function computeRectAndRanges(poly) {
+            poly.isRect = poly.length === 5 && poly[0][0] === poly[4][0] && poly[0][1] === poly[4][1] && (poly[0][0] === poly[1][0] && poly[2][0] === poly[3][0] && poly[0][1] === poly[3][1] && poly[1][1] === poly[2][1]) || poly[0][1] === poly[1][1] && poly[2][1] === poly[3][1] && poly[0][0] === poly[3][0] && poly[1][0] === poly[2][0];
+            if (poly.isRect) {
+              poly.xmin = Math.min(poly[0][0], poly[2][0]);
+              poly.xmax = Math.max(poly[0][0], poly[2][0]);
+              poly.ymin = Math.min(poly[0][1], poly[2][1]);
+              poly.ymax = Math.max(poly[0][1], poly[2][1]);
+            }
+            return poly;
+          }
+          function makeFillRangeItems(allAxes) {
+            return function(eventData, poly) {
+              var range;
+              var lassoPoints;
+              for (var i2 = 0; i2 < allAxes.length; i2++) {
+                var ax = allAxes[i2];
+                var id2 = ax._id;
+                var axLetter = id2.charAt(0);
+                if (poly.isRect) {
+                  if (!range) range = {};
+                  var min = poly[axLetter + "min"];
+                  var max = poly[axLetter + "max"];
+                  if (min !== void 0 && max !== void 0) {
+                    range[id2] = [
+                      p2r(ax, min),
+                      p2r(ax, max)
+                    ].sort(ascending);
+                  }
+                } else {
+                  if (!lassoPoints) lassoPoints = {};
+                  lassoPoints[id2] = poly.map(axValue(ax));
+                }
+              }
+              if (range) {
+                eventData.range = range;
+              }
+              if (lassoPoints) {
+                eventData.lassoPoints = lassoPoints;
+              }
+            };
+          }
+          function getFillRangeItems(dragOptions) {
+            var plotinfo = dragOptions.plotinfo;
+            return plotinfo.fillRangeItems || // allow subplots (i.e. geo, mapbox, map, sankey) to override fillRangeItems routine
+            makeFillRangeItems(dragOptions.xaxes.concat(dragOptions.yaxes));
+          }
+          function emitSelecting(gd2, eventData) {
+            gd2.emit("plotly_selecting", eventData);
+          }
+          function emitSelected(gd2, eventData) {
+            if (eventData) {
+              eventData.selections = (gd2.layout || {}).selections || [];
+            }
+            gd2.emit("plotly_selected", eventData);
+          }
+          function emitDeselect(gd2) {
+            gd2.emit("plotly_deselect", null);
+          }
+          module2.exports = {
+            reselect,
+            prepSelect,
+            clearOutline,
+            clearSelectionsCache,
+            selectOnClick
+          };
+        }
+      });
+      var require_arrow_paths = __commonJS({
+        "src/components/annotations/arrow_paths.js"(exports, module2) {
+          module2.exports = [
+            // no arrow
+            {
+              path: "",
+              backoff: 0
+            },
+            // wide with flat back
+            {
+              path: "M-2.4,-3V3L0.6,0Z",
+              backoff: 0.6
+            },
+            // narrower with flat back
+            {
+              path: "M-3.7,-2.5V2.5L1.3,0Z",
+              backoff: 1.3
+            },
+            // barbed
+            {
+              path: "M-4.45,-3L-1.65,-0.2V0.2L-4.45,3L1.55,0Z",
+              backoff: 1.55
+            },
+            // wide line-drawn
+            {
+              path: "M-2.2,-2.2L-0.2,-0.2V0.2L-2.2,2.2L-1.4,3L1.6,0L-1.4,-3Z",
+              backoff: 1.6
+            },
+            // narrower line-drawn
+            {
+              path: "M-4.4,-2.1L-0.6,-0.2V0.2L-4.4,2.1L-4,3L2,0L-4,-3Z",
+              backoff: 2
+            },
+            // circle
+            {
+              path: "M2,0A2,2 0 1,1 0,-2A2,2 0 0,1 2,0Z",
+              backoff: 0,
+              noRotate: true
+            },
+            // square
+            {
+              path: "M2,2V-2H-2V2Z",
+              backoff: 0,
+              noRotate: true
+            }
+          ];
+        }
+      });
+      var require_axis_placeable_objects = __commonJS({
+        "src/constants/axis_placeable_objects.js"(exports, module2) {
+          module2.exports = {
+            axisRefDescription: function(axisname, lower, upper) {
+              return [
+                "If set to a",
+                axisname,
+                "axis id (e.g. *" + axisname + "* or",
+                "*" + axisname + "2*), the `" + axisname + "` position refers to a",
+                axisname,
+                "coordinate. If set to *paper*, the `" + axisname + "`",
+                "position refers to the distance from the",
+                lower,
+                "of the plotting",
+                "area in normalized coordinates where *0* (*1*) corresponds to the",
+                lower,
+                "(" + upper + "). If set to a",
+                axisname,
+                "axis ID followed by",
+                "*domain* (separated by a space), the position behaves like for",
+                "*paper*, but refers to the distance in fractions of the domain",
+                "length from the",
+                lower,
+                "of the domain of that axis: e.g.,",
+                "*" + axisname + "2 domain* refers to the domain of the second",
+                axisname,
+                " axis and a",
+                axisname,
+                "position of 0.5 refers to the",
+                "point between the",
+                lower,
+                "and the",
+                upper,
+                "of the domain of the",
+                "second",
+                axisname,
+                "axis."
+              ].join(" ");
+            }
+          };
+        }
+      });
+      var require_attributes11 = __commonJS({
+        "src/components/annotations/attributes.js"(exports, module2) {
+          var ARROWPATHS = require_arrow_paths();
+          var fontAttrs = require_font_attributes();
+          var cartesianConstants = require_constants2();
+          var templatedArray = require_plot_template().templatedArray;
+          require_axis_placeable_objects();
+          module2.exports = templatedArray("annotation", {
+            visible: {
+              valType: "boolean",
+              dflt: true,
+              editType: "calc+arraydraw"
+            },
+            text: {
+              valType: "string",
+              editType: "calc+arraydraw"
+            },
+            textangle: {
+              valType: "angle",
+              dflt: 0,
+              editType: "calc+arraydraw"
+            },
+            font: fontAttrs({
+              editType: "calc+arraydraw",
+              colorEditType: "arraydraw"
+            }),
+            width: {
+              valType: "number",
+              min: 1,
+              dflt: null,
+              editType: "calc+arraydraw"
+            },
+            height: {
+              valType: "number",
+              min: 1,
+              dflt: null,
+              editType: "calc+arraydraw"
+            },
+            opacity: {
+              valType: "number",
+              min: 0,
+              max: 1,
+              dflt: 1,
+              editType: "arraydraw"
+            },
+            align: {
+              valType: "enumerated",
+              values: ["left", "center", "right"],
+              dflt: "center",
+              editType: "arraydraw"
+            },
+            valign: {
+              valType: "enumerated",
+              values: ["top", "middle", "bottom"],
+              dflt: "middle",
+              editType: "arraydraw"
+            },
+            bgcolor: {
+              valType: "color",
+              dflt: "rgba(0,0,0,0)",
+              editType: "arraydraw"
+            },
+            bordercolor: {
+              valType: "color",
+              dflt: "rgba(0,0,0,0)",
+              editType: "arraydraw"
+            },
+            borderpad: {
+              valType: "number",
+              min: 0,
+              dflt: 1,
+              editType: "calc+arraydraw"
+            },
+            borderwidth: {
+              valType: "number",
+              min: 0,
+              dflt: 1,
+              editType: "calc+arraydraw"
+            },
+            // arrow
+            showarrow: {
+              valType: "boolean",
+              dflt: true,
+              editType: "calc+arraydraw"
+            },
+            arrowcolor: {
+              valType: "color",
+              editType: "arraydraw"
+            },
+            arrowhead: {
+              valType: "integer",
+              min: 0,
+              max: ARROWPATHS.length,
+              dflt: 1,
+              editType: "arraydraw"
+            },
+            startarrowhead: {
+              valType: "integer",
+              min: 0,
+              max: ARROWPATHS.length,
+              dflt: 1,
+              editType: "arraydraw"
+            },
+            arrowside: {
+              valType: "flaglist",
+              flags: ["end", "start"],
+              extras: ["none"],
+              dflt: "end",
+              editType: "arraydraw"
+            },
+            arrowsize: {
+              valType: "number",
+              min: 0.3,
+              dflt: 1,
+              editType: "calc+arraydraw"
+            },
+            startarrowsize: {
+              valType: "number",
+              min: 0.3,
+              dflt: 1,
+              editType: "calc+arraydraw"
+            },
+            arrowwidth: {
+              valType: "number",
+              min: 0.1,
+              editType: "calc+arraydraw"
+            },
+            standoff: {
+              valType: "number",
+              min: 0,
+              dflt: 0,
+              editType: "calc+arraydraw"
+            },
+            startstandoff: {
+              valType: "number",
+              min: 0,
+              dflt: 0,
+              editType: "calc+arraydraw"
+            },
+            ax: {
+              valType: "any",
+              editType: "calc+arraydraw"
+            },
+            ay: {
+              valType: "any",
+              editType: "calc+arraydraw"
+            },
+            axref: {
+              valType: "enumerated",
+              dflt: "pixel",
+              values: [
+                "pixel",
+                cartesianConstants.idRegex.x.toString()
+              ],
+              editType: "calc"
+            },
+            ayref: {
+              valType: "enumerated",
+              dflt: "pixel",
+              values: [
+                "pixel",
+                cartesianConstants.idRegex.y.toString()
+              ],
+              editType: "calc"
+            },
+            // positioning
+            xref: {
+              valType: "enumerated",
+              values: [
+                "paper",
+                cartesianConstants.idRegex.x.toString()
+              ],
+              editType: "calc"
+            },
+            x: {
+              valType: "any",
+              editType: "calc+arraydraw"
+            },
+            xanchor: {
+              valType: "enumerated",
+              values: ["auto", "left", "center", "right"],
+              dflt: "auto",
+              editType: "calc+arraydraw"
+            },
+            xshift: {
+              valType: "number",
+              dflt: 0,
+              editType: "calc+arraydraw"
+            },
+            yref: {
+              valType: "enumerated",
+              values: [
+                "paper",
+                cartesianConstants.idRegex.y.toString()
+              ],
+              editType: "calc"
+            },
+            y: {
+              valType: "any",
+              editType: "calc+arraydraw"
+            },
+            yanchor: {
+              valType: "enumerated",
+              values: ["auto", "top", "middle", "bottom"],
+              dflt: "auto",
+              editType: "calc+arraydraw"
+            },
+            yshift: {
+              valType: "number",
+              dflt: 0,
+              editType: "calc+arraydraw"
+            },
+            clicktoshow: {
+              valType: "enumerated",
+              values: [false, "onoff", "onout"],
+              dflt: false,
+              editType: "arraydraw"
+            },
+            xclick: {
+              valType: "any",
+              editType: "arraydraw"
+            },
+            yclick: {
+              valType: "any",
+              editType: "arraydraw"
+            },
+            hovertext: {
+              valType: "string",
+              editType: "arraydraw"
+            },
+            hoverlabel: {
+              bgcolor: {
+                valType: "color",
+                editType: "arraydraw"
+              },
+              bordercolor: {
+                valType: "color",
+                editType: "arraydraw"
+              },
+              font: fontAttrs({
+                editType: "arraydraw"
+              }),
+              editType: "arraydraw"
+            },
+            captureevents: {
+              valType: "boolean",
+              editType: "arraydraw"
+            },
+            editType: "calc"
+          });
+        }
+      });
+      var require_constants8 = __commonJS({
+        "src/traces/scatter/constants.js"(exports, module2) {
+          module2.exports = {
+            PTS_LINESONLY: 20,
+            // fixed parameters of clustering and clipping algorithms
+            // fraction of clustering tolerance "so close we don't even consider it a new point"
+            minTolerance: 0.2,
+            // how fast does clustering tolerance increase as you get away from the visible region
+            toleranceGrowth: 10,
+            // number of viewport sizes away from the visible region
+            // at which we clip all lines to the perimeter
+            maxScreensAway: 20,
+            eventDataKeys: []
+          };
+        }
+      });
+      var require_fillcolor_attribute = __commonJS({
+        "src/traces/scatter/fillcolor_attribute.js"(exports, module2) {
+          module2.exports = function makeFillcolorAttr(hasFillgradient) {
+            return {
+              valType: "color",
+              editType: "style",
+              anim: true
+            };
+          };
+        }
+      });
+      var require_attributes12 = __commonJS({
+        "src/traces/scatter/attributes.js"(exports, module2) {
+          var axisHoverFormat = require_axis_format_attributes().axisHoverFormat;
+          var { hovertemplateAttrs, texttemplateAttrs, templatefallbackAttrs } = require_template_attributes();
+          var colorScaleAttrs = require_attributes8();
+          var fontAttrs = require_font_attributes();
+          var dash = require_attributes4().dash;
+          var pattern = require_attributes4().pattern;
+          var Drawing = require_drawing();
+          var constants = require_constants8();
+          var extendFlat = require_extend().extendFlat;
+          var makeFillcolorAttr = require_fillcolor_attribute();
+          function axisPeriod(axis) {
+            return {
+              valType: "any",
+              dflt: 0,
+              editType: "calc"
+            };
+          }
+          function axisPeriod0(axis) {
+            return {
+              valType: "any",
+              editType: "calc"
+            };
+          }
+          function axisPeriodAlignment(axis) {
+            return {
+              valType: "enumerated",
+              values: ["start", "middle", "end"],
+              dflt: "middle",
+              editType: "calc"
+            };
+          }
+          module2.exports = {
+            x: {
+              valType: "data_array",
+              editType: "calc+clearAxisTypes",
+              anim: true
+            },
+            x0: {
+              valType: "any",
+              dflt: 0,
+              editType: "calc+clearAxisTypes",
+              anim: true
+            },
+            dx: {
+              valType: "number",
+              dflt: 1,
+              editType: "calc",
+              anim: true
+            },
+            y: {
+              valType: "data_array",
+              editType: "calc+clearAxisTypes",
+              anim: true
+            },
+            y0: {
+              valType: "any",
+              dflt: 0,
+              editType: "calc+clearAxisTypes",
+              anim: true
+            },
+            dy: {
+              valType: "number",
+              dflt: 1,
+              editType: "calc",
+              anim: true
+            },
+            xperiod: axisPeriod(),
+            yperiod: axisPeriod(),
+            xperiod0: axisPeriod0(),
+            yperiod0: axisPeriod0(),
+            xperiodalignment: axisPeriodAlignment(),
+            yperiodalignment: axisPeriodAlignment(),
+            xhoverformat: axisHoverFormat("x"),
+            yhoverformat: axisHoverFormat("y"),
+            offsetgroup: {
+              valType: "string",
+              dflt: "",
+              editType: "calc"
+            },
+            alignmentgroup: {
+              valType: "string",
+              dflt: "",
+              editType: "calc"
+            },
+            stackgroup: {
+              valType: "string",
+              dflt: "",
+              editType: "calc"
+            },
+            orientation: {
+              valType: "enumerated",
+              values: ["v", "h"],
+              editType: "calc"
+            },
+            groupnorm: {
+              valType: "enumerated",
+              values: ["", "fraction", "percent"],
+              dflt: "",
+              editType: "calc"
+            },
+            stackgaps: {
+              valType: "enumerated",
+              values: ["infer zero", "interpolate"],
+              dflt: "infer zero",
+              editType: "calc"
+            },
+            text: {
+              valType: "string",
+              dflt: "",
+              arrayOk: true,
+              editType: "calc"
+            },
+            texttemplate: texttemplateAttrs(),
+            texttemplatefallback: templatefallbackAttrs({ editType: "calc" }),
+            hovertext: {
+              valType: "string",
+              dflt: "",
+              arrayOk: true,
+              editType: "style"
+            },
+            mode: {
+              valType: "flaglist",
+              flags: ["lines", "markers", "text"],
+              extras: ["none"],
+              editType: "calc"
+            },
+            hoveron: {
+              valType: "flaglist",
+              flags: ["points", "fills"],
+              editType: "style"
+            },
+            hovertemplate: hovertemplateAttrs({}, { keys: constants.eventDataKeys }),
+            hovertemplatefallback: templatefallbackAttrs(),
+            line: {
+              color: {
+                valType: "color",
+                editType: "style",
+                anim: true
+              },
+              width: {
+                valType: "number",
+                min: 0,
+                dflt: 2,
+                editType: "style",
+                anim: true
+              },
+              shape: {
+                valType: "enumerated",
+                values: ["linear", "spline", "hv", "vh", "hvh", "vhv"],
+                dflt: "linear",
+                editType: "plot"
+              },
+              smoothing: {
+                valType: "number",
+                min: 0,
+                max: 1.3,
+                dflt: 1,
+                editType: "plot"
+              },
+              dash: extendFlat({}, dash, { editType: "style" }),
+              backoff: {
+                // we want to have a similar option for the start of the line
+                valType: "number",
+                min: 0,
+                dflt: "auto",
+                arrayOk: true,
+                editType: "plot"
+              },
+              simplify: {
+                valType: "boolean",
+                dflt: true,
+                editType: "plot"
+              },
+              editType: "plot"
+            },
+            connectgaps: {
+              valType: "boolean",
+              dflt: false,
+              editType: "calc"
+            },
+            cliponaxis: {
+              valType: "boolean",
+              dflt: true,
+              editType: "plot"
+            },
+            fill: {
+              valType: "enumerated",
+              values: ["none", "tozeroy", "tozerox", "tonexty", "tonextx", "toself", "tonext"],
+              editType: "calc"
+            },
+            fillcolor: makeFillcolorAttr(true),
+            fillgradient: extendFlat({
+              type: {
+                valType: "enumerated",
+                values: ["radial", "horizontal", "vertical", "none"],
+                dflt: "none",
+                editType: "calc"
+              },
+              start: {
+                valType: "number",
+                editType: "calc"
+              },
+              stop: {
+                valType: "number",
+                editType: "calc"
+              },
+              colorscale: {
+                valType: "colorscale",
+                editType: "style"
+              },
+              editType: "calc"
+            }),
+            fillpattern: pattern,
+            marker: extendFlat(
+              {
+                symbol: {
+                  valType: "enumerated",
+                  values: Drawing.symbolList,
+                  dflt: "circle",
+                  arrayOk: true,
+                  editType: "style"
+                },
+                opacity: {
+                  valType: "number",
+                  min: 0,
+                  max: 1,
+                  arrayOk: true,
+                  editType: "style",
+                  anim: true
+                },
+                angle: {
+                  valType: "angle",
+                  dflt: 0,
+                  arrayOk: true,
+                  editType: "plot",
+                  anim: false
+                  // TODO: possibly set to true in future
+                },
+                angleref: {
+                  valType: "enumerated",
+                  values: ["previous", "up"],
+                  dflt: "up",
+                  editType: "plot",
+                  anim: false
+                },
+                standoff: {
+                  valType: "number",
+                  min: 0,
+                  dflt: 0,
+                  arrayOk: true,
+                  editType: "plot",
+                  anim: true
+                },
+                size: {
+                  valType: "number",
+                  min: 0,
+                  dflt: 6,
+                  arrayOk: true,
+                  editType: "calc",
+                  anim: true
+                },
+                maxdisplayed: {
+                  valType: "number",
+                  min: 0,
+                  dflt: 0,
+                  editType: "plot"
+                },
+                sizeref: {
+                  valType: "number",
+                  dflt: 1,
+                  editType: "calc"
+                },
+                sizemin: {
+                  valType: "number",
+                  min: 0,
+                  dflt: 0,
+                  editType: "calc"
+                },
+                sizemode: {
+                  valType: "enumerated",
+                  values: ["diameter", "area"],
+                  dflt: "diameter",
+                  editType: "calc"
+                },
+                line: extendFlat(
+                  {
+                    width: {
+                      valType: "number",
+                      min: 0,
+                      arrayOk: true,
+                      editType: "style",
+                      anim: true
+                    },
+                    dash: extendFlat({}, dash, {
+                      arrayOk: true
+                    }),
+                    editType: "calc"
+                  },
+                  colorScaleAttrs("marker.line", { anim: true })
+                ),
+                gradient: {
+                  type: {
+                    valType: "enumerated",
+                    values: ["radial", "horizontal", "vertical", "none"],
+                    arrayOk: true,
+                    dflt: "none",
+                    editType: "calc"
+                  },
+                  color: {
+                    valType: "color",
+                    arrayOk: true,
+                    editType: "calc"
+                  },
+                  editType: "calc"
+                },
+                editType: "calc"
+              },
+              colorScaleAttrs("marker", { anim: true })
+            ),
+            selected: {
+              marker: {
+                opacity: {
+                  valType: "number",
+                  min: 0,
+                  max: 1,
+                  editType: "style"
+                },
+                color: {
+                  valType: "color",
+                  editType: "style"
+                },
+                size: {
+                  valType: "number",
+                  min: 0,
+                  editType: "style"
+                },
+                editType: "style"
+              },
+              textfont: {
+                color: {
+                  valType: "color",
+                  editType: "style"
+                },
+                editType: "style"
+              },
+              editType: "style"
+            },
+            unselected: {
+              marker: {
+                opacity: {
+                  valType: "number",
+                  min: 0,
+                  max: 1,
+                  editType: "style"
+                },
+                color: {
+                  valType: "color",
+                  editType: "style"
+                },
+                size: {
+                  valType: "number",
+                  min: 0,
+                  editType: "style"
+                },
+                editType: "style"
+              },
+              textfont: {
+                color: {
+                  valType: "color",
+                  editType: "style"
+                },
+                editType: "style"
+              },
+              editType: "style"
+            },
+            textposition: {
+              valType: "enumerated",
+              values: [
+                "top left",
+                "top center",
+                "top right",
+                "middle left",
+                "middle center",
+                "middle right",
+                "bottom left",
+                "bottom center",
+                "bottom right"
+              ],
+              dflt: "middle center",
+              arrayOk: true,
+              editType: "calc"
+            },
+            textfont: fontAttrs({
+              editType: "calc",
+              colorEditType: "style",
+              arrayOk: true
+            }),
+            zorder: {
+              valType: "integer",
+              dflt: 0,
+              editType: "plot"
+            }
+          };
+        }
+      });
+      var require_attributes13 = __commonJS({
+        "src/components/selections/attributes.js"(exports, module2) {
+          var annAttrs = require_attributes11();
+          var scatterLineAttrs = require_attributes12().line;
+          var dash = require_attributes4().dash;
+          var extendFlat = require_extend().extendFlat;
+          var overrideAll = require_edit_types().overrideAll;
+          var templatedArray = require_plot_template().templatedArray;
+          require_axis_placeable_objects();
+          module2.exports = overrideAll(templatedArray("selection", {
+            type: {
+              valType: "enumerated",
+              values: ["rect", "path"]
+            },
+            xref: extendFlat({}, annAttrs.xref, {}),
+            yref: extendFlat({}, annAttrs.yref, {}),
+            x0: {
+              valType: "any"
+            },
+            x1: {
+              valType: "any"
+            },
+            y0: {
+              valType: "any"
+            },
+            y1: {
+              valType: "any"
+            },
+            path: {
+              valType: "string",
+              editType: "arraydraw"
+            },
+            opacity: {
+              valType: "number",
+              min: 0,
+              max: 1,
+              dflt: 0.7,
+              editType: "arraydraw"
+            },
+            line: {
+              color: scatterLineAttrs.color,
+              width: extendFlat({}, scatterLineAttrs.width, {
+                min: 1,
+                dflt: 1
+              }),
+              dash: extendFlat({}, dash, {
+                dflt: "dot"
+              })
+            }
+          }), "arraydraw", "from-root");
+        }
+      });
+      var require_defaults6 = __commonJS({
+        "src/components/selections/defaults.js"(exports, module2) {
+          var Lib = require_lib();
+          var Axes = require_axes();
+          var handleArrayContainerDefaults = require_array_container_defaults();
+          var attributes = require_attributes13();
+          var helpers = require_helpers8();
+          module2.exports = function supplyLayoutDefaults(layoutIn, layoutOut) {
+            handleArrayContainerDefaults(layoutIn, layoutOut, {
+              name: "selections",
+              handleItemDefaults: handleSelectionDefaults
+            });
+            var selections = layoutOut.selections;
+            for (var i2 = 0; i2 < selections.length; i2++) {
+              var selection = selections[i2];
+              if (!selection) continue;
+              if (selection.path === void 0) {
+                if (selection.x0 === void 0 || selection.x1 === void 0 || selection.y0 === void 0 || selection.y1 === void 0) {
+                  layoutOut.selections[i2] = null;
+                }
+              }
+            }
+          };
+          function handleSelectionDefaults(selectionIn, selectionOut, fullLayout) {
+            function coerce(attr, dflt) {
+              return Lib.coerce(selectionIn, selectionOut, attributes, attr, dflt);
+            }
+            var path = coerce("path");
+            var dfltType = path ? "path" : "rect";
+            var selectionType = coerce("type", dfltType);
+            var noPath = selectionType !== "path";
+            if (noPath) delete selectionOut.path;
+            coerce("opacity");
+            coerce("line.color");
+            coerce("line.width");
+            coerce("line.dash");
+            var axLetters = ["x", "y"];
+            for (var i2 = 0; i2 < 2; i2++) {
+              var axLetter = axLetters[i2];
+              var gdMock = { _fullLayout: fullLayout };
+              var ax;
+              var pos2r;
+              var r2pos;
+              var axRef = Axes.coerceRef(selectionIn, selectionOut, gdMock, axLetter);
+              ax = Axes.getFromId(gdMock, axRef);
+              ax._selectionIndices.push(selectionOut._index);
+              r2pos = helpers.rangeToShapePosition(ax);
+              pos2r = helpers.shapePositionToRange(ax);
+              if (noPath) {
+                var attr0 = axLetter + "0";
+                var attr1 = axLetter + "1";
+                var in0 = selectionIn[attr0];
+                var in1 = selectionIn[attr1];
+                selectionIn[attr0] = pos2r(selectionIn[attr0], true);
+                selectionIn[attr1] = pos2r(selectionIn[attr1], true);
+                Axes.coercePosition(selectionOut, gdMock, coerce, axRef, attr0);
+                Axes.coercePosition(selectionOut, gdMock, coerce, axRef, attr1);
+                var p0 = selectionOut[attr0];
+                var p1 = selectionOut[attr1];
+                if (p0 !== void 0 && p1 !== void 0) {
+                  selectionOut[attr0] = r2pos(p0);
+                  selectionOut[attr1] = r2pos(p1);
+                  selectionIn[attr0] = in0;
+                  selectionIn[attr1] = in1;
+                }
+              }
+            }
+            if (noPath) {
+              Lib.noneOrAll(selectionIn, selectionOut, ["x0", "x1", "y0", "y1"]);
+            }
+          }
+        }
+      });
+      var require_defaults7 = __commonJS({
+        "src/components/selections/draw_newselection/defaults.js"(exports, module2) {
+          module2.exports = function supplyDrawNewSelectionDefaults(layoutIn, layoutOut, coerce) {
+            coerce("newselection.mode");
+            var newselectionLineWidth = coerce("newselection.line.width");
+            if (newselectionLineWidth) {
+              coerce("newselection.line.color");
+              coerce("newselection.line.dash");
+            }
+            coerce("activeselection.fillcolor");
+            coerce("activeselection.opacity");
+          };
+        }
+      });
+      var require_include_components = __commonJS({
+        "src/plots/cartesian/include_components.js"(exports, module2) {
+          var Registry = require_registry();
+          var Lib = require_lib();
+          var axisIds = require_axis_ids();
+          module2.exports = function makeIncludeComponents(containerArrayName) {
+            return function includeComponents(layoutIn, layoutOut) {
+              var array = layoutIn[containerArrayName];
+              if (!Array.isArray(array)) return;
+              var Cartesian = Registry.subplotsRegistry.cartesian;
+              var idRegex = Cartesian.idRegex;
+              var subplots = layoutOut._subplots;
+              var xaList = subplots.xaxis;
+              var yaList = subplots.yaxis;
+              var cartesianList = subplots.cartesian;
+              var hasCartesian = layoutOut._has("cartesian");
+              for (var i2 = 0; i2 < array.length; i2++) {
+                var itemi = array[i2];
+                if (!Lib.isPlainObject(itemi)) continue;
+                var xref = axisIds.cleanId(itemi.xref, "x", false);
+                var yref = axisIds.cleanId(itemi.yref, "y", false);
+                var hasXref = idRegex.x.test(xref);
+                var hasYref = idRegex.y.test(yref);
+                if (hasXref || hasYref) {
+                  if (!hasCartesian) Lib.pushUnique(layoutOut._basePlotModules, Cartesian);
+                  var newAxis = false;
+                  if (hasXref && xaList.indexOf(xref) === -1) {
+                    xaList.push(xref);
+                    newAxis = true;
+                  }
+                  if (hasYref && yaList.indexOf(yref) === -1) {
+                    yaList.push(yref);
+                    newAxis = true;
+                  }
+                  if (newAxis && hasXref && hasYref) {
+                    cartesianList.push(xref + yref);
+                  }
+                }
+              }
+            };
+          };
+        }
+      });
+      var require_selections = __commonJS({
+        "src/components/selections/index.js"(exports, module2) {
+          var drawModule = require_draw3();
+          var select = require_select();
+          module2.exports = {
+            moduleType: "component",
+            name: "selections",
+            layoutAttributes: require_attributes13(),
+            supplyLayoutDefaults: require_defaults6(),
+            supplyDrawNewSelectionDefaults: require_defaults7(),
+            includeBasePlot: require_include_components()("selections"),
+            draw: drawModule.draw,
+            drawOne: drawModule.drawOne,
+            reselect: select.reselect,
+            prepSelect: select.prepSelect,
+            clearOutline: select.clearOutline,
+            clearSelectionsCache: select.clearSelectionsCache,
+            selectOnClick: select.selectOnClick
+          };
+        }
+      });
+      var require_dragbox = __commonJS({
+        "src/plots/cartesian/dragbox.js"(exports, module2) {
+          var d3 = require_d3();
+          var Lib = require_lib();
+          var numberFormat = Lib.numberFormat;
+          var tinycolor = require_tinycolor();
+          var supportsPassive = require_has_passive_events();
+          var Registry = require_registry();
+          var strTranslate = Lib.strTranslate;
+          var svgTextUtils = require_svg_text_utils();
+          var Color2 = require_color();
+          var Drawing = require_drawing();
+          var Fx = require_fx();
+          var Axes = require_axes();
+          var setCursor = require_setcursor();
+          var dragElement = require_dragelement();
+          var helpers = require_helpers5();
+          var selectingOrDrawing = helpers.selectingOrDrawing;
+          var freeMode = helpers.freeMode;
+          var FROM_TL = require_alignment().FROM_TL;
+          var clearGlCanvases = require_clear_gl_canvases();
+          var redrawReglTraces = require_subroutines().redrawReglTraces;
+          var Plots = require_plots();
+          var getFromId = require_axis_ids().getFromId;
+          var prepSelect = require_selections().prepSelect;
+          var clearOutline = require_selections().clearOutline;
+          var selectOnClick = require_selections().selectOnClick;
+          var scaleZoom = require_scale_zoom();
+          var constants = require_constants2();
+          var MINDRAG = constants.MINDRAG;
+          var MINZOOM = constants.MINZOOM;
+          var SHOWZOOMOUTTIP = true;
+          function makeDragBox(gd2, plotinfo, x2, y2, w2, h2, ns, ew) {
+            var zoomlayer = gd2._fullLayout._zoomlayer;
+            var isMainDrag = ns + ew === "nsew";
+            var singleEnd = (ns + ew).length === 1;
+            var xa0, ya0;
+            var xaHash, yaHash;
+            var xaxes, yaxes;
+            var xs, ys;
+            var pw, ph2;
+            var links;
+            var matches2;
+            var xActive, yActive;
+            var allFixedRanges;
+            var editX, editY;
+            var hasScatterGl, hasSplom, hasSVG;
+            var updates;
+            var scaleX2;
+            var scaleY2;
+            x2 += plotinfo.yaxis._shift;
+            function recomputeAxisLists() {
+              xa0 = plotinfo.xaxis;
+              ya0 = plotinfo.yaxis;
+              pw = xa0._length;
+              ph2 = ya0._length;
+              xs = xa0._offset;
+              ys = ya0._offset;
+              xaHash = {};
+              xaHash[xa0._id] = xa0;
+              yaHash = {};
+              yaHash[ya0._id] = ya0;
+              if (ns && ew) {
+                var overlays = plotinfo.overlays;
+                for (var i2 = 0; i2 < overlays.length; i2++) {
+                  var xa = overlays[i2].xaxis;
+                  xaHash[xa._id] = xa;
+                  var ya2 = overlays[i2].yaxis;
+                  yaHash[ya2._id] = ya2;
+                }
+              }
+              xaxes = hashValues(xaHash);
+              yaxes = hashValues(yaHash);
+              xActive = isDirectionActive(xaxes, ew);
+              yActive = isDirectionActive(yaxes, ns);
+              allFixedRanges = !yActive && !xActive;
+              matches2 = calcLinks(gd2, gd2._fullLayout._axisMatchGroups, xaHash, yaHash);
+              links = calcLinks(gd2, gd2._fullLayout._axisConstraintGroups, xaHash, yaHash, matches2);
+              var spConstrained = links.isSubplotConstrained || matches2.isSubplotConstrained;
+              editX = ew || spConstrained;
+              editY = ns || spConstrained;
+              var fullLayout = gd2._fullLayout;
+              hasScatterGl = fullLayout._has("scattergl");
+              hasSplom = fullLayout._has("splom");
+              hasSVG = fullLayout._has("svg");
+            }
+            recomputeAxisLists();
+            var cursor = getDragCursor(yActive + xActive, gd2._fullLayout.dragmode, isMainDrag);
+            var dragger = makeRectDragger(plotinfo, ns + ew + "drag", cursor, x2, y2, w2, h2);
+            if (allFixedRanges && !isMainDrag) {
+              dragger.onmousedown = null;
+              dragger.style.pointerEvents = "none";
+              return dragger;
+            }
+            var dragOptions = {
+              element: dragger,
+              gd: gd2,
+              plotinfo
+            };
+            dragOptions.prepFn = function(e2, startX, startY) {
+              var dragModePrev = dragOptions.dragmode;
+              var dragModeNow = gd2._fullLayout.dragmode;
+              if (dragModeNow !== dragModePrev) {
+                dragOptions.dragmode = dragModeNow;
+              }
+              recomputeAxisLists();
+              scaleX2 = gd2._fullLayout._invScaleX;
+              scaleY2 = gd2._fullLayout._invScaleY;
+              if (!allFixedRanges) {
+                if (isMainDrag) {
+                  if (e2.shiftKey) {
+                    if (dragModeNow === "pan") dragModeNow = "zoom";
+                    else if (!selectingOrDrawing(dragModeNow)) dragModeNow = "pan";
+                  } else if (e2.ctrlKey) {
+                    dragModeNow = "pan";
+                  }
+                } else {
+                  dragModeNow = "pan";
+                }
+              }
+              if (freeMode(dragModeNow)) dragOptions.minDrag = 1;
+              else dragOptions.minDrag = void 0;
+              if (selectingOrDrawing(dragModeNow)) {
+                dragOptions.xaxes = xaxes;
+                dragOptions.yaxes = yaxes;
+                prepSelect(e2, startX, startY, dragOptions, dragModeNow);
+              } else {
+                dragOptions.clickFn = clickFn;
+                if (selectingOrDrawing(dragModePrev)) {
+                  clearAndResetSelect();
+                }
+                if (!allFixedRanges) {
+                  if (dragModeNow === "zoom") {
+                    dragOptions.moveFn = zoomMove;
+                    dragOptions.doneFn = zoomDone;
+                    dragOptions.minDrag = 1;
+                    zoomPrep(e2, startX, startY);
+                  } else if (dragModeNow === "pan") {
+                    dragOptions.moveFn = plotDrag;
+                    dragOptions.doneFn = dragTail;
+                  }
+                }
+              }
+              gd2._fullLayout._redrag = function() {
+                var dragDataNow = gd2._dragdata;
+                if (dragDataNow && dragDataNow.element === dragger) {
+                  var dragModeNow2 = gd2._fullLayout.dragmode;
+                  if (!selectingOrDrawing(dragModeNow2)) {
+                    recomputeAxisLists();
+                    updateSubplots([0, 0, pw, ph2]);
+                    dragOptions.moveFn(dragDataNow.dx, dragDataNow.dy);
+                  }
+                }
+              };
+            };
+            function clearAndResetSelect() {
+              dragOptions.plotinfo.selection = false;
+              clearOutline(gd2);
+            }
+            function clickFn(numClicks, evt) {
+              var gd22 = dragOptions.gd;
+              if (gd22._fullLayout._activeShapeIndex >= 0) {
+                gd22._fullLayout._deactivateShape(gd22);
+                return;
+              }
+              var clickmode = gd22._fullLayout.clickmode;
+              removeZoombox(gd22);
+              if (numClicks === 2 && !singleEnd) doubleClick();
+              if (isMainDrag) {
+                if (clickmode.indexOf("select") > -1) {
+                  selectOnClick(evt, gd22, xaxes, yaxes, plotinfo.id, dragOptions);
+                }
+                if (clickmode.indexOf("event") > -1) {
+                  Fx.click(gd22, evt, plotinfo.id);
+                }
+              } else if (numClicks === 1 && singleEnd) {
+                var ax = ns ? ya0 : xa0;
+                var end = ns === "s" || ew === "w" ? 0 : 1;
+                var attrStr = ax._name + ".range[" + end + "]";
+                var initialText = getEndText(ax, end);
+                var hAlign = "left";
+                var vAlign = "middle";
+                if (ax.fixedrange) return;
+                if (ns) {
+                  vAlign = ns === "n" ? "top" : "bottom";
+                  if (ax.side === "right") hAlign = "right";
+                } else if (ew === "e") hAlign = "right";
+                if (gd22._context.showAxisRangeEntryBoxes) {
+                  d3.select(dragger).call(svgTextUtils.makeEditable, {
+                    gd: gd22,
+                    immediate: true,
+                    background: gd22._fullLayout.paper_bgcolor,
+                    text: String(initialText),
+                    fill: ax.tickfont ? ax.tickfont.color : "#444",
+                    horizontalAlign: hAlign,
+                    verticalAlign: vAlign
+                  }).on("edit", function(text) {
+                    var v2 = ax.d2r(text);
+                    if (v2 !== void 0) {
+                      Registry.call("_guiRelayout", gd22, attrStr, v2);
+                    }
+                  });
+                }
+              }
+            }
+            dragElement.init(dragOptions);
+            var x0, y0;
+            var box;
+            var lum;
+            var path0;
+            var dimmed;
+            var zoomMode;
+            var zb2;
+            var corners;
+            var zoomDragged;
+            function zoomPrep(e2, startX, startY) {
+              var dragBBox = dragger.getBoundingClientRect();
+              x0 = startX - dragBBox.left;
+              y0 = startY - dragBBox.top;
+              gd2._fullLayout._calcInverseTransform(gd2);
+              var transformedCoords = Lib.apply3DTransform(gd2._fullLayout._invTransform)(x0, y0);
+              x0 = transformedCoords[0];
+              y0 = transformedCoords[1];
+              box = { l: x0, r: x0, w: 0, t: y0, b: y0, h: 0 };
+              lum = gd2._hmpixcount ? gd2._hmlumcount / gd2._hmpixcount : tinycolor(gd2._fullLayout.plot_bgcolor).getLuminance();
+              path0 = "M0,0H" + pw + "V" + ph2 + "H0V0";
+              dimmed = false;
+              zoomMode = "xy";
+              zoomDragged = false;
+              zb2 = makeZoombox(zoomlayer, lum, xs, ys, path0);
+              corners = makeCorners(zoomlayer, xs, ys);
+            }
+            function zoomMove(dx0, dy0) {
+              if (gd2._transitioningWithDuration) {
+                return false;
+              }
+              var x1 = Math.max(0, Math.min(pw, scaleX2 * dx0 + x0));
+              var y1 = Math.max(0, Math.min(ph2, scaleY2 * dy0 + y0));
+              var dx = Math.abs(x1 - x0);
+              var dy = Math.abs(y1 - y0);
+              box.l = Math.min(x0, x1);
+              box.r = Math.max(x0, x1);
+              box.t = Math.min(y0, y1);
+              box.b = Math.max(y0, y1);
+              function noZoom() {
+                zoomMode = "";
+                box.r = box.l;
+                box.t = box.b;
+                corners.attr("d", "M0,0Z");
+              }
+              if (links.isSubplotConstrained) {
+                if (dx > MINZOOM || dy > MINZOOM) {
+                  zoomMode = "xy";
+                  if (dx / pw > dy / ph2) {
+                    dy = dx * ph2 / pw;
+                    if (y0 > y1) box.t = y0 - dy;
+                    else box.b = y0 + dy;
+                  } else {
+                    dx = dy * pw / ph2;
+                    if (x0 > x1) box.l = x0 - dx;
+                    else box.r = x0 + dx;
+                  }
+                  corners.attr("d", xyCorners(box));
+                } else {
+                  noZoom();
+                }
+              } else if (matches2.isSubplotConstrained) {
+                if (dx > MINZOOM || dy > MINZOOM) {
+                  zoomMode = "xy";
+                  var r0 = Math.min(box.l / pw, (ph2 - box.b) / ph2);
+                  var r1 = Math.max(box.r / pw, (ph2 - box.t) / ph2);
+                  box.l = r0 * pw;
+                  box.r = r1 * pw;
+                  box.b = (1 - r0) * ph2;
+                  box.t = (1 - r1) * ph2;
+                  corners.attr("d", xyCorners(box));
+                } else {
+                  noZoom();
+                }
+              } else if (!yActive || dy < Math.min(Math.max(dx * 0.6, MINDRAG), MINZOOM)) {
+                if (dx < MINDRAG || !xActive) {
+                  noZoom();
+                } else {
+                  box.t = 0;
+                  box.b = ph2;
+                  zoomMode = "x";
+                  corners.attr("d", xCorners(box, y0));
+                }
+              } else if (!xActive || dx < Math.min(dy * 0.6, MINZOOM)) {
+                box.l = 0;
+                box.r = pw;
+                zoomMode = "y";
+                corners.attr("d", yCorners(box, x0));
+              } else {
+                zoomMode = "xy";
+                corners.attr("d", xyCorners(box));
+              }
+              box.w = box.r - box.l;
+              box.h = box.b - box.t;
+              if (zoomMode) zoomDragged = true;
+              gd2._dragged = zoomDragged;
+              updateZoombox(zb2, corners, box, path0, dimmed, lum);
+              computeZoomUpdates();
+              gd2.emit("plotly_relayouting", updates);
+              dimmed = true;
+            }
+            function computeZoomUpdates() {
+              updates = {};
+              if (zoomMode === "xy" || zoomMode === "x") {
+                zoomAxRanges(xaxes, box.l / pw, box.r / pw, updates, links.xaxes);
+                updateMatchedAxRange("x", updates);
+              }
+              if (zoomMode === "xy" || zoomMode === "y") {
+                zoomAxRanges(yaxes, (ph2 - box.b) / ph2, (ph2 - box.t) / ph2, updates, links.yaxes);
+                updateMatchedAxRange("y", updates);
+              }
+            }
+            function zoomDone() {
+              computeZoomUpdates();
+              removeZoombox(gd2);
+              dragTail();
+              showDoubleClickNotifier(gd2);
+            }
+            var scrollViewBox = [0, 0, pw, ph2];
+            var redrawTimer = null;
+            var REDRAWDELAY = constants.REDRAWDELAY;
+            var mainplot = plotinfo.mainplot ? gd2._fullLayout._plots[plotinfo.mainplot] : plotinfo;
+            function zoomWheel(e2) {
+              if (!gd2._context._scrollZoom.cartesian && !gd2._fullLayout._enablescrollzoom) {
+                return;
+              }
+              clearAndResetSelect();
+              if (gd2._transitioningWithDuration) {
+                e2.preventDefault();
+                e2.stopPropagation();
+                return;
+              }
+              recomputeAxisLists();
+              clearTimeout(redrawTimer);
+              var wheelDelta = -e2.deltaY;
+              if (!isFinite(wheelDelta)) wheelDelta = e2.wheelDelta / 10;
+              if (!isFinite(wheelDelta)) {
+                Lib.log("Did not find wheel motion attributes: ", e2);
+                return;
+              }
+              var zoom = Math.exp(-Math.min(Math.max(wheelDelta, -20), 20) / 200);
+              var gbb = mainplot.draglayer.select(".nsewdrag").node().getBoundingClientRect();
+              var xfrac = (e2.clientX - gbb.left) / gbb.width;
+              var yfrac = (gbb.bottom - e2.clientY) / gbb.height;
+              var i2;
+              function zoomWheelOneAxis(ax, centerFraction, zoom2) {
+                if (ax.fixedrange) return;
+                var axRange = Lib.simpleMap(ax.range, ax.r2l);
+                var v0 = axRange[0] + (axRange[1] - axRange[0]) * centerFraction;
+                function doZoom(v2) {
+                  return ax.l2r(v0 + (v2 - v0) * zoom2);
+                }
+                ax.range = axRange.map(doZoom);
+              }
+              if (editX) {
+                if (!ew) xfrac = 0.5;
+                for (i2 = 0; i2 < xaxes.length; i2++) {
+                  zoomWheelOneAxis(xaxes[i2], xfrac, zoom);
+                }
+                updateMatchedAxRange("x");
+                scrollViewBox[2] *= zoom;
+                scrollViewBox[0] += scrollViewBox[2] * xfrac * (1 / zoom - 1);
+              }
+              if (editY) {
+                if (!ns) yfrac = 0.5;
+                for (i2 = 0; i2 < yaxes.length; i2++) {
+                  zoomWheelOneAxis(yaxes[i2], yfrac, zoom);
+                }
+                updateMatchedAxRange("y");
+                scrollViewBox[3] *= zoom;
+                scrollViewBox[1] += scrollViewBox[3] * (1 - yfrac) * (1 / zoom - 1);
+              }
+              updateSubplots(scrollViewBox);
+              ticksAndAnnotations();
+              gd2.emit("plotly_relayouting", updates);
+              redrawTimer = setTimeout(function() {
+                if (!gd2._fullLayout) return;
+                scrollViewBox = [0, 0, pw, ph2];
+                dragTail();
+              }, REDRAWDELAY);
+              e2.preventDefault();
+              return;
+            }
+            if (ns.length * ew.length !== 1) {
+              attachWheelEventHandler(dragger, zoomWheel);
+            }
+            function plotDrag(dx, dy) {
+              dx = dx * scaleX2;
+              dy = dy * scaleY2;
+              if (gd2._transitioningWithDuration) {
+                return;
+              }
+              gd2._fullLayout._replotting = true;
+              if (xActive === "ew" || yActive === "ns") {
+                var spDx = xActive ? -dx : 0;
+                var spDy = yActive ? -dy : 0;
+                if (matches2.isSubplotConstrained) {
+                  if (xActive && yActive) {
+                    var frac = (dx / pw - dy / ph2) / 2;
+                    dx = frac * pw;
+                    dy = -frac * ph2;
+                    spDx = -dx;
+                    spDy = -dy;
+                  }
+                  if (yActive) {
+                    spDx = -spDy * pw / ph2;
+                  } else {
+                    spDy = -spDx * ph2 / pw;
+                  }
+                }
+                if (xActive) {
+                  dragAxList(xaxes, dx);
+                  updateMatchedAxRange("x");
+                }
+                if (yActive) {
+                  dragAxList(yaxes, dy);
+                  updateMatchedAxRange("y");
+                }
+                updateSubplots([spDx, spDy, pw, ph2]);
+                ticksAndAnnotations();
+                gd2.emit("plotly_relayouting", updates);
+                return;
+              }
+              function dz(axArray, end, d2) {
+                var otherEnd = 1 - end;
+                var movedAx;
+                var newLinearizedEnd;
+                for (var i22 = 0; i22 < axArray.length; i22++) {
+                  var axi = axArray[i22];
+                  if (axi.fixedrange) continue;
+                  movedAx = axi;
+                  newLinearizedEnd = axi._rl[otherEnd] + (axi._rl[end] - axi._rl[otherEnd]) / dZoom(d2 / axi._length);
+                  var newEnd = axi.l2r(newLinearizedEnd);
+                  if (newEnd !== false && newEnd !== void 0) axi.range[end] = newEnd;
+                }
+                return movedAx._length * (movedAx._rl[end] - newLinearizedEnd) / (movedAx._rl[end] - movedAx._rl[otherEnd]);
+              }
+              var dxySign = xActive === "w" === (yActive === "n") ? 1 : -1;
+              if (xActive && yActive && (links.isSubplotConstrained || matches2.isSubplotConstrained)) {
+                var dxyFraction = (dx / pw + dxySign * dy / ph2) / 2;
+                dx = dxyFraction * pw;
+                dy = dxySign * dxyFraction * ph2;
+              }
+              var xStart, yStart;
+              if (xActive === "w") dx = dz(xaxes, 0, dx);
+              else if (xActive === "e") dx = dz(xaxes, 1, -dx);
+              else if (!xActive) dx = 0;
+              if (yActive === "n") dy = dz(yaxes, 1, dy);
+              else if (yActive === "s") dy = dz(yaxes, 0, -dy);
+              else if (!yActive) dy = 0;
+              xStart = xActive === "w" ? dx : 0;
+              yStart = yActive === "n" ? dy : 0;
+              if (links.isSubplotConstrained && !matches2.isSubplotConstrained || // NW or SE on matching axes - create a symmetric zoom
+              matches2.isSubplotConstrained && xActive && yActive && dxySign > 0) {
+                var i2;
+                if (matches2.isSubplotConstrained || !xActive && yActive.length === 1) {
+                  for (i2 = 0; i2 < xaxes.length; i2++) {
+                    xaxes[i2].range = xaxes[i2]._r.slice();
+                    scaleZoom(xaxes[i2], 1 - dy / ph2);
+                  }
+                  dx = dy * pw / ph2;
+                  xStart = dx / 2;
+                }
+                if (matches2.isSubplotConstrained || !yActive && xActive.length === 1) {
+                  for (i2 = 0; i2 < yaxes.length; i2++) {
+                    yaxes[i2].range = yaxes[i2]._r.slice();
+                    scaleZoom(yaxes[i2], 1 - dx / pw);
+                  }
+                  dy = dx * ph2 / pw;
+                  yStart = dy / 2;
+                }
+              }
+              if (!matches2.isSubplotConstrained || !yActive) {
+                updateMatchedAxRange("x");
+              }
+              if (!matches2.isSubplotConstrained || !xActive) {
+                updateMatchedAxRange("y");
+              }
+              var xSize = pw - dx;
+              var ySize = ph2 - dy;
+              if (matches2.isSubplotConstrained && !(xActive && yActive)) {
+                if (xActive) {
+                  yStart = xStart ? 0 : dx * ph2 / pw;
+                  ySize = xSize * ph2 / pw;
+                } else {
+                  xStart = yStart ? 0 : dy * pw / ph2;
+                  xSize = ySize * pw / ph2;
+                }
+              }
+              updateSubplots([xStart, yStart, xSize, ySize]);
+              ticksAndAnnotations();
+              gd2.emit("plotly_relayouting", updates);
+            }
+            function updateMatchedAxRange(axLetter, out) {
+              var matchedAxes = matches2.isSubplotConstrained ? { x: yaxes, y: xaxes }[axLetter] : matches2[axLetter + "axes"];
+              var constrainedAxes = matches2.isSubplotConstrained ? { x: xaxes, y: yaxes }[axLetter] : [];
+              for (var i2 = 0; i2 < matchedAxes.length; i2++) {
+                var ax = matchedAxes[i2];
+                var axId = ax._id;
+                var axId2 = matches2.xLinks[axId] || matches2.yLinks[axId];
+                var ax2 = constrainedAxes[0] || xaHash[axId2] || yaHash[axId2];
+                if (ax2) {
+                  if (out) {
+                    out[ax._name + ".range[0]"] = out[ax2._name + ".range[0]"];
+                    out[ax._name + ".range[1]"] = out[ax2._name + ".range[1]"];
+                  } else {
+                    ax.range = ax2.range.slice();
+                  }
+                }
+              }
+            }
+            function ticksAndAnnotations() {
+              var activeAxIds = [];
+              var i2;
+              function pushActiveAxIds(axList) {
+                for (i2 = 0; i2 < axList.length; i2++) {
+                  if (!axList[i2].fixedrange) activeAxIds.push(axList[i2]._id);
+                }
+              }
+              function pushActiveAxIdsSynced(axList, axisType) {
+                for (i2 = 0; i2 < axList.length; i2++) {
+                  var axListI = axList[i2];
+                  var axListIType = axListI[axisType];
+                  if (!axListI.fixedrange && axListIType.tickmode === "sync") activeAxIds.push(axListIType._id);
+                }
+              }
+              if (editX) {
+                pushActiveAxIds(xaxes);
+                pushActiveAxIds(links.xaxes);
+                pushActiveAxIds(matches2.xaxes);
+                pushActiveAxIdsSynced(plotinfo.overlays, "xaxis");
+              }
+              if (editY) {
+                pushActiveAxIds(yaxes);
+                pushActiveAxIds(links.yaxes);
+                pushActiveAxIds(matches2.yaxes);
+                pushActiveAxIdsSynced(plotinfo.overlays, "yaxis");
+              }
+              updates = {};
+              for (i2 = 0; i2 < activeAxIds.length; i2++) {
+                var axId = activeAxIds[i2];
+                var ax = getFromId(gd2, axId);
+                Axes.drawOne(gd2, ax, { skipTitle: true });
+                updates[ax._name + ".range[0]"] = ax.range[0];
+                updates[ax._name + ".range[1]"] = ax.range[1];
+              }
+              Axes.redrawComponents(gd2, activeAxIds);
+            }
+            function doubleClick() {
+              if (gd2._transitioningWithDuration) return;
+              var doubleClickConfig = gd2._context.doubleClick;
+              var axList = [];
+              if (xActive) axList = axList.concat(xaxes);
+              if (yActive) axList = axList.concat(yaxes);
+              if (matches2.xaxes) axList = axList.concat(matches2.xaxes);
+              if (matches2.yaxes) axList = axList.concat(matches2.yaxes);
+              var attrs = {};
+              var ax, i2;
+              if (doubleClickConfig === "reset+autosize") {
+                doubleClickConfig = "autosize";
+                for (i2 = 0; i2 < axList.length; i2++) {
+                  ax = axList[i2];
+                  var r0 = ax._rangeInitial0;
+                  var r1 = ax._rangeInitial1;
+                  var hasRangeInitial = r0 !== void 0 || r1 !== void 0;
+                  if (hasRangeInitial && (r0 !== void 0 && r0 !== ax.range[0] || r1 !== void 0 && r1 !== ax.range[1]) || !hasRangeInitial && ax.autorange !== true) {
+                    doubleClickConfig = "reset";
+                    break;
+                  }
+                }
+              }
+              if (doubleClickConfig === "autosize") {
+                for (i2 = 0; i2 < axList.length; i2++) {
+                  ax = axList[i2];
+                  if (!ax.fixedrange) attrs[ax._name + ".autorange"] = true;
+                }
+              } else if (doubleClickConfig === "reset") {
+                if (xActive || links.isSubplotConstrained) axList = axList.concat(links.xaxes);
+                if (yActive && !links.isSubplotConstrained) axList = axList.concat(links.yaxes);
+                if (links.isSubplotConstrained) {
+                  if (!xActive) axList = axList.concat(xaxes);
+                  else if (!yActive) axList = axList.concat(yaxes);
+                }
+                for (i2 = 0; i2 < axList.length; i2++) {
+                  ax = axList[i2];
+                  if (!ax.fixedrange) {
+                    var axName = ax._name;
+                    var autorangeInitial = ax._autorangeInitial;
+                    if (ax._rangeInitial0 === void 0 && ax._rangeInitial1 === void 0) {
+                      attrs[axName + ".autorange"] = true;
+                    } else if (ax._rangeInitial0 === void 0) {
+                      attrs[axName + ".autorange"] = autorangeInitial;
+                      attrs[axName + ".range"] = [null, ax._rangeInitial1];
+                    } else if (ax._rangeInitial1 === void 0) {
+                      attrs[axName + ".range"] = [ax._rangeInitial0, null];
+                      attrs[axName + ".autorange"] = autorangeInitial;
+                    } else {
+                      attrs[axName + ".range"] = [ax._rangeInitial0, ax._rangeInitial1];
+                    }
+                  }
+                }
+              }
+              gd2.emit("plotly_doubleclick", null);
+              Registry.call("_guiRelayout", gd2, attrs);
+            }
+            function dragTail() {
+              updateSubplots([0, 0, pw, ph2]);
+              Lib.syncOrAsync([
+                Plots.previousPromises,
+                function() {
+                  gd2._fullLayout._replotting = false;
+                  Registry.call("_guiRelayout", gd2, updates);
+                }
+              ], gd2);
+            }
+            function updateSubplots(viewBox) {
+              var fullLayout = gd2._fullLayout;
+              var plotinfos = fullLayout._plots;
+              var subplots = fullLayout._subplots.cartesian;
+              var i2, sp, xa, ya2;
+              if (hasSplom) {
+                Registry.subplotsRegistry.splom.drag(gd2);
+              }
+              if (hasScatterGl) {
+                for (i2 = 0; i2 < subplots.length; i2++) {
+                  sp = plotinfos[subplots[i2]];
+                  xa = sp.xaxis;
+                  ya2 = sp.yaxis;
+                  if (sp._scene) {
+                    if (xa.limitRange) xa.limitRange();
+                    if (ya2.limitRange) ya2.limitRange();
+                    var xrng = Lib.simpleMap(xa.range, xa.r2l);
+                    var yrng = Lib.simpleMap(ya2.range, ya2.r2l);
+                    sp._scene.update({ range: [xrng[0], yrng[0], xrng[1], yrng[1]] });
+                  }
+                }
+              }
+              if (hasSplom || hasScatterGl) {
+                clearGlCanvases(gd2);
+                redrawReglTraces(gd2);
+              }
+              if (hasSVG) {
+                var xScaleFactor = viewBox[2] / xa0._length;
+                var yScaleFactor = viewBox[3] / ya0._length;
+                for (i2 = 0; i2 < subplots.length; i2++) {
+                  sp = plotinfos[subplots[i2]];
+                  xa = sp.xaxis;
+                  ya2 = sp.yaxis;
+                  var editX2 = (editX || matches2.isSubplotConstrained) && !xa.fixedrange && xaHash[xa._id];
+                  var editY2 = (editY || matches2.isSubplotConstrained) && !ya2.fixedrange && yaHash[ya2._id];
+                  var xScaleFactor2, yScaleFactor2;
+                  var clipDx, clipDy;
+                  if (editX2) {
+                    xScaleFactor2 = xScaleFactor;
+                    clipDx = ew || matches2.isSubplotConstrained ? viewBox[0] : getShift(xa, xScaleFactor2);
+                  } else if (matches2.xaHash[xa._id]) {
+                    xScaleFactor2 = xScaleFactor;
+                    clipDx = viewBox[0] * xa._length / xa0._length;
+                  } else if (matches2.yaHash[xa._id]) {
+                    xScaleFactor2 = yScaleFactor;
+                    clipDx = yActive === "ns" ? -viewBox[1] * xa._length / ya0._length : getShift(xa, xScaleFactor2, { n: "top", s: "bottom" }[yActive]);
+                  } else {
+                    xScaleFactor2 = getLinkedScaleFactor(xa, xScaleFactor, yScaleFactor);
+                    clipDx = scaleAndGetShift(xa, xScaleFactor2);
+                  }
+                  if (xScaleFactor2 > 1 && (xa.maxallowed !== void 0 && editX === (xa.range[0] < xa.range[1] ? "e" : "w") || xa.minallowed !== void 0 && editX === (xa.range[0] < xa.range[1] ? "w" : "e"))) {
+                    xScaleFactor2 = 1;
+                    clipDx = 0;
+                  }
+                  if (editY2) {
+                    yScaleFactor2 = yScaleFactor;
+                    clipDy = ns || matches2.isSubplotConstrained ? viewBox[1] : getShift(ya2, yScaleFactor2);
+                  } else if (matches2.yaHash[ya2._id]) {
+                    yScaleFactor2 = yScaleFactor;
+                    clipDy = viewBox[1] * ya2._length / ya0._length;
+                  } else if (matches2.xaHash[ya2._id]) {
+                    yScaleFactor2 = xScaleFactor;
+                    clipDy = xActive === "ew" ? -viewBox[0] * ya2._length / xa0._length : getShift(ya2, yScaleFactor2, { e: "right", w: "left" }[xActive]);
+                  } else {
+                    yScaleFactor2 = getLinkedScaleFactor(ya2, xScaleFactor, yScaleFactor);
+                    clipDy = scaleAndGetShift(ya2, yScaleFactor2);
+                  }
+                  if (yScaleFactor2 > 1 && (ya2.maxallowed !== void 0 && editY === (ya2.range[0] < ya2.range[1] ? "n" : "s") || ya2.minallowed !== void 0 && editY === (ya2.range[0] < ya2.range[1] ? "s" : "n"))) {
+                    yScaleFactor2 = 1;
+                    clipDy = 0;
+                  }
+                  if (!xScaleFactor2 && !yScaleFactor2) {
+                    continue;
+                  }
+                  if (!xScaleFactor2) xScaleFactor2 = 1;
+                  if (!yScaleFactor2) yScaleFactor2 = 1;
+                  var plotDx = xa._offset - clipDx / xScaleFactor2;
+                  var plotDy = ya2._offset - clipDy / yScaleFactor2;
+                  sp.clipRect.call(Drawing.setTranslate, clipDx, clipDy).call(Drawing.setScale, xScaleFactor2, yScaleFactor2);
+                  sp.plot.call(Drawing.setTranslate, plotDx, plotDy).call(Drawing.setScale, 1 / xScaleFactor2, 1 / yScaleFactor2);
+                  if (xScaleFactor2 !== sp.xScaleFactor || yScaleFactor2 !== sp.yScaleFactor) {
+                    Drawing.setPointGroupScale(sp.zoomScalePts, xScaleFactor2, yScaleFactor2);
+                    Drawing.setTextPointsScale(sp.zoomScaleTxt, xScaleFactor2, yScaleFactor2);
+                  }
+                  Drawing.hideOutsideRangePoints(sp.clipOnAxisFalseTraces, sp);
+                  sp.xScaleFactor = xScaleFactor2;
+                  sp.yScaleFactor = yScaleFactor2;
+                }
+              }
+            }
+            function getLinkedScaleFactor(ax, xScaleFactor, yScaleFactor) {
+              if (ax.fixedrange) return 0;
+              if (editX && links.xaHash[ax._id]) {
+                return xScaleFactor;
+              }
+              if (editY && (links.isSubplotConstrained ? links.xaHash : links.yaHash)[ax._id]) {
+                return yScaleFactor;
+              }
+              return 0;
+            }
+            function scaleAndGetShift(ax, scaleFactor) {
+              if (scaleFactor) {
+                ax.range = ax._r.slice();
+                scaleZoom(ax, scaleFactor);
+                return getShift(ax, scaleFactor);
+              }
+              return 0;
+            }
+            function getShift(ax, scaleFactor, from) {
+              return ax._length * (1 - scaleFactor) * FROM_TL[from || ax.constraintoward || "middle"];
+            }
+            return dragger;
+          }
+          function makeDragger(plotinfo, nodeName, dragClass, cursor) {
+            var dragger3 = Lib.ensureSingle(plotinfo.draglayer, nodeName, dragClass, function(s2) {
+              s2.classed("drag", true).style({ fill: "transparent", "stroke-width": 0 }).attr("data-subplot", plotinfo.id);
+            });
+            dragger3.call(setCursor, cursor);
+            return dragger3.node();
+          }
+          function makeRectDragger(plotinfo, dragClass, cursor, x2, y2, w2, h2) {
+            var dragger = makeDragger(plotinfo, "rect", dragClass, cursor);
+            d3.select(dragger).call(Drawing.setRect, x2, y2, w2, h2);
+            return dragger;
+          }
+          function isDirectionActive(axList, activeVal) {
+            for (var i2 = 0; i2 < axList.length; i2++) {
+              if (!axList[i2].fixedrange) return activeVal;
+            }
+            return "";
+          }
+          function getEndText(ax, end) {
+            var initialVal = ax.range[end];
+            var diff = Math.abs(initialVal - ax.range[1 - end]);
+            var dig;
+            if (ax.type === "date") {
+              return initialVal;
+            } else if (ax.type === "log") {
+              dig = Math.ceil(Math.max(0, -Math.log(diff) / Math.LN10)) + 3;
+              return numberFormat("." + dig + "g")(Math.pow(10, initialVal));
+            } else {
+              dig = Math.floor(Math.log(Math.abs(initialVal)) / Math.LN10) - Math.floor(Math.log(diff) / Math.LN10) + 4;
+              return numberFormat("." + String(dig) + "g")(initialVal);
+            }
+          }
+          function zoomAxRanges(axList, r0Fraction, r1Fraction, updates, linkedAxes) {
+            for (var i2 = 0; i2 < axList.length; i2++) {
+              var axi = axList[i2];
+              if (axi.fixedrange) continue;
+              if (axi.rangebreaks) {
+                var isY = axi._id.charAt(0) === "y";
+                var r0F = isY ? 1 - r0Fraction : r0Fraction;
+                var r1F = isY ? 1 - r1Fraction : r1Fraction;
+                updates[axi._name + ".range[0]"] = axi.l2r(axi.p2l(r0F * axi._length));
+                updates[axi._name + ".range[1]"] = axi.l2r(axi.p2l(r1F * axi._length));
+              } else {
+                var axRangeLinear0 = axi._rl[0];
+                var axRangeLinearSpan = axi._rl[1] - axRangeLinear0;
+                updates[axi._name + ".range[0]"] = axi.l2r(axRangeLinear0 + axRangeLinearSpan * r0Fraction);
+                updates[axi._name + ".range[1]"] = axi.l2r(axRangeLinear0 + axRangeLinearSpan * r1Fraction);
+              }
+            }
+            if (linkedAxes && linkedAxes.length) {
+              var linkedR0Fraction = (r0Fraction + (1 - r1Fraction)) / 2;
+              zoomAxRanges(linkedAxes, linkedR0Fraction, 1 - linkedR0Fraction, updates, []);
+            }
+          }
+          function dragAxList(axList, pix) {
+            for (var i2 = 0; i2 < axList.length; i2++) {
+              var axi = axList[i2];
+              if (!axi.fixedrange) {
+                if (axi.rangebreaks) {
+                  var p0 = 0;
+                  var p1 = axi._length;
+                  var d0 = axi.p2l(p0 + pix) - axi.p2l(p0);
+                  var d1 = axi.p2l(p1 + pix) - axi.p2l(p1);
+                  var delta = (d0 + d1) / 2;
+                  axi.range = [
+                    axi.l2r(axi._rl[0] - delta),
+                    axi.l2r(axi._rl[1] - delta)
+                  ];
+                } else {
+                  axi.range = [
+                    axi.l2r(axi._rl[0] - pix / axi._m),
+                    axi.l2r(axi._rl[1] - pix / axi._m)
+                  ];
+                }
+                if (axi.limitRange) axi.limitRange();
+              }
+            }
+          }
+          function dZoom(d2) {
+            return 1 - (d2 >= 0 ? Math.min(d2, 0.9) : 1 / (1 / Math.max(d2, -0.3) + 3.222));
+          }
+          function getDragCursor(nsew, dragmode, isMainDrag) {
+            if (!nsew) return "pointer";
+            if (nsew === "nsew") {
+              if (isMainDrag) return "";
+              if (dragmode === "pan") return "move";
+              return "crosshair";
+            }
+            return nsew.toLowerCase() + "-resize";
+          }
+          function makeZoombox(zoomlayer, lum, xs, ys, path0) {
+            return zoomlayer.append("path").attr("class", "zoombox").style({
+              fill: lum > 0.2 ? "rgba(0,0,0,0)" : "rgba(255,255,255,0)",
+              "stroke-width": 0
+            }).attr("transform", strTranslate(xs, ys)).attr("d", path0 + "Z");
+          }
+          function makeCorners(zoomlayer, xs, ys) {
+            return zoomlayer.append("path").attr("class", "zoombox-corners").style({
+              fill: Color2.background,
+              stroke: Color2.defaultLine,
+              "stroke-width": 1,
+              opacity: 0
+            }).attr("transform", strTranslate(xs, ys)).attr("d", "M0,0Z");
+          }
+          function updateZoombox(zb2, corners, box, path0, dimmed, lum) {
+            zb2.attr(
+              "d",
+              path0 + "M" + box.l + "," + box.t + "v" + box.h + "h" + box.w + "v-" + box.h + "h-" + box.w + "Z"
+            );
+            transitionZoombox(zb2, corners, dimmed, lum);
+          }
+          function transitionZoombox(zb2, corners, dimmed, lum) {
+            if (!dimmed) {
+              zb2.transition().style("fill", lum > 0.2 ? "rgba(0,0,0,0.4)" : "rgba(255,255,255,0.3)").duration(200);
+              corners.transition().style("opacity", 1).duration(200);
+            }
+          }
+          function removeZoombox(gd2) {
+            d3.select(gd2).selectAll(".zoombox,.js-zoombox-backdrop,.js-zoombox-menu,.zoombox-corners").remove();
+          }
+          function showDoubleClickNotifier(gd2) {
+            if (SHOWZOOMOUTTIP && gd2.data && gd2._context.showTips) {
+              Lib.notifier(Lib._(gd2, "Double-click to zoom back out"), "long");
+              SHOWZOOMOUTTIP = false;
+            }
+          }
+          function xCorners(box, y0) {
+            return "M" + (box.l - 0.5) + "," + (y0 - MINZOOM - 0.5) + "h-3v" + (2 * MINZOOM + 1) + "h3ZM" + (box.r + 0.5) + "," + (y0 - MINZOOM - 0.5) + "h3v" + (2 * MINZOOM + 1) + "h-3Z";
+          }
+          function yCorners(box, x0) {
+            return "M" + (x0 - MINZOOM - 0.5) + "," + (box.t - 0.5) + "v-3h" + (2 * MINZOOM + 1) + "v3ZM" + (x0 - MINZOOM - 0.5) + "," + (box.b + 0.5) + "v3h" + (2 * MINZOOM + 1) + "v-3Z";
+          }
+          function xyCorners(box) {
+            var clen = Math.floor(Math.min(box.b - box.t, box.r - box.l, MINZOOM) / 2);
+            return "M" + (box.l - 3.5) + "," + (box.t - 0.5 + clen) + "h3v" + -clen + "h" + clen + "v-3h-" + (clen + 3) + "ZM" + (box.r + 3.5) + "," + (box.t - 0.5 + clen) + "h-3v" + -clen + "h" + -clen + "v-3h" + (clen + 3) + "ZM" + (box.r + 3.5) + "," + (box.b + 0.5 - clen) + "h-3v" + clen + "h" + -clen + "v3h" + (clen + 3) + "ZM" + (box.l - 3.5) + "," + (box.b + 0.5 - clen) + "h3v" + clen + "h" + clen + "v3h-" + (clen + 3) + "Z";
+          }
+          function calcLinks(gd2, groups, xaHash, yaHash, exclude) {
+            var isSubplotConstrained = false;
+            var xLinks = {};
+            var yLinks = {};
+            var xID, yID, xLinkID, yLinkID;
+            var xExclude = (exclude || {}).xaHash;
+            var yExclude = (exclude || {}).yaHash;
+            for (var i2 = 0; i2 < groups.length; i2++) {
+              var group = groups[i2];
+              for (xID in xaHash) {
+                if (group[xID]) {
+                  for (xLinkID in group) {
+                    if (!(exclude && (xExclude[xLinkID] || yExclude[xLinkID])) && !(xLinkID.charAt(0) === "x" ? xaHash : yaHash)[xLinkID]) {
+                      xLinks[xLinkID] = xID;
+                    }
+                  }
+                  for (yID in yaHash) {
+                    if (!(exclude && (xExclude[yID] || yExclude[yID])) && group[yID]) {
+                      isSubplotConstrained = true;
+                    }
+                  }
+                }
+              }
+              for (yID in yaHash) {
+                if (group[yID]) {
+                  for (yLinkID in group) {
+                    if (!(exclude && (xExclude[yLinkID] || yExclude[yLinkID])) && !(yLinkID.charAt(0) === "x" ? xaHash : yaHash)[yLinkID]) {
+                      yLinks[yLinkID] = yID;
+                    }
+                  }
+                }
+              }
+            }
+            if (isSubplotConstrained) {
+              Lib.extendFlat(xLinks, yLinks);
+              yLinks = {};
+            }
+            var xaHashLinked = {};
+            var xaxesLinked = [];
+            for (xLinkID in xLinks) {
+              var xa = getFromId(gd2, xLinkID);
+              xaxesLinked.push(xa);
+              xaHashLinked[xa._id] = xa;
+            }
+            var yaHashLinked = {};
+            var yaxesLinked = [];
+            for (yLinkID in yLinks) {
+              var ya2 = getFromId(gd2, yLinkID);
+              yaxesLinked.push(ya2);
+              yaHashLinked[ya2._id] = ya2;
+            }
+            return {
+              xaHash: xaHashLinked,
+              yaHash: yaHashLinked,
+              xaxes: xaxesLinked,
+              yaxes: yaxesLinked,
+              xLinks,
+              yLinks,
+              isSubplotConstrained
+            };
+          }
+          function attachWheelEventHandler(element, handler) {
+            if (!supportsPassive) {
+              if (element.onwheel !== void 0) element.onwheel = handler;
+              else if (element.onmousewheel !== void 0) element.onmousewheel = handler;
+              else if (!element.isAddedWheelEvent) {
+                element.isAddedWheelEvent = true;
+                element.addEventListener("wheel", handler, { passive: false });
+              }
+            } else {
+              var wheelEventName = element.onwheel !== void 0 ? "wheel" : "mousewheel";
+              if (element._onwheel) {
+                element.removeEventListener(wheelEventName, element._onwheel);
+              }
+              element._onwheel = handler;
+              element.addEventListener(wheelEventName, handler, { passive: false });
+            }
+          }
+          function hashValues(hash) {
+            var out = [];
+            for (var k2 in hash) out.push(hash[k2]);
+            return out;
+          }
+          module2.exports = {
+            makeDragBox,
+            makeDragger,
+            makeRectDragger,
+            makeZoombox,
+            makeCorners,
+            updateZoombox,
+            xyCorners,
+            transitionZoombox,
+            removeZoombox,
+            showDoubleClickNotifier,
+            attachWheelEventHandler
+          };
+        }
+      });
+      var require_graph_interact = __commonJS({
+        "src/plots/cartesian/graph_interact.js"(exports) {
+          var d3 = require_d3();
+          var Fx = require_fx();
+          var dragElement = require_dragelement();
+          var setCursor = require_setcursor();
+          var makeDragBox = require_dragbox().makeDragBox;
+          var DRAGGERSIZE = require_constants2().DRAGGERSIZE;
+          exports.initInteractions = function initInteractions(gd2) {
+            var fullLayout = gd2._fullLayout;
+            if (gd2._context.staticPlot) {
+              d3.select(gd2).selectAll(".drag").remove();
+              return;
+            }
+            if (!fullLayout._has("cartesian") && !fullLayout._has("splom")) return;
+            var subplots = Object.keys(fullLayout._plots || {}).sort(function(a2, b2) {
+              if ((fullLayout._plots[a2].mainplot && true) === (fullLayout._plots[b2].mainplot && true)) {
+                var aParts = a2.split("y");
+                var bParts = b2.split("y");
+                return aParts[0] === bParts[0] ? Number(aParts[1] || 1) - Number(bParts[1] || 1) : Number(aParts[0] || 1) - Number(bParts[0] || 1);
+              }
+              return fullLayout._plots[a2].mainplot ? 1 : -1;
+            });
+            subplots.forEach(function(subplot) {
+              var plotinfo = fullLayout._plots[subplot];
+              var xa = plotinfo.xaxis;
+              var ya2 = plotinfo.yaxis;
+              if (!plotinfo.mainplot) {
+                var maindrag = makeDragBox(
+                  gd2,
+                  plotinfo,
+                  xa._offset,
+                  ya2._offset,
+                  xa._length,
+                  ya2._length,
+                  "ns",
+                  "ew"
+                );
+                maindrag.onmousemove = function(evt) {
+                  gd2._fullLayout._rehover = function() {
+                    if (gd2._fullLayout._hoversubplot === subplot && gd2._fullLayout._plots[subplot]) {
+                      Fx.hover(gd2, evt, subplot);
+                    }
+                  };
+                  Fx.hover(gd2, evt, subplot);
+                  gd2._fullLayout._lasthover = maindrag;
+                  gd2._fullLayout._hoversubplot = subplot;
+                };
+                maindrag.onmouseout = function(evt) {
+                  if (gd2._dragging) return;
+                  gd2._fullLayout._hoversubplot = null;
+                  dragElement.unhover(gd2, evt);
+                };
+                if (gd2._context.showAxisDragHandles) {
+                  makeDragBox(
+                    gd2,
+                    plotinfo,
+                    xa._offset - DRAGGERSIZE,
+                    ya2._offset - DRAGGERSIZE,
+                    DRAGGERSIZE,
+                    DRAGGERSIZE,
+                    "n",
+                    "w"
+                  );
+                  makeDragBox(
+                    gd2,
+                    plotinfo,
+                    xa._offset + xa._length,
+                    ya2._offset - DRAGGERSIZE,
+                    DRAGGERSIZE,
+                    DRAGGERSIZE,
+                    "n",
+                    "e"
+                  );
+                  makeDragBox(
+                    gd2,
+                    plotinfo,
+                    xa._offset - DRAGGERSIZE,
+                    ya2._offset + ya2._length,
+                    DRAGGERSIZE,
+                    DRAGGERSIZE,
+                    "s",
+                    "w"
+                  );
+                  makeDragBox(
+                    gd2,
+                    plotinfo,
+                    xa._offset + xa._length,
+                    ya2._offset + ya2._length,
+                    DRAGGERSIZE,
+                    DRAGGERSIZE,
+                    "s",
+                    "e"
+                  );
+                }
+              }
+              if (gd2._context.showAxisDragHandles) {
+                if (subplot === xa._mainSubplot) {
+                  var y0 = xa._mainLinePosition;
+                  if (xa.side === "top") y0 -= DRAGGERSIZE;
+                  makeDragBox(
+                    gd2,
+                    plotinfo,
+                    xa._offset + xa._length * 0.1,
+                    y0,
+                    xa._length * 0.8,
+                    DRAGGERSIZE,
+                    "",
+                    "ew"
+                  );
+                  makeDragBox(
+                    gd2,
+                    plotinfo,
+                    xa._offset,
+                    y0,
+                    xa._length * 0.1,
+                    DRAGGERSIZE,
+                    "",
+                    "w"
+                  );
+                  makeDragBox(
+                    gd2,
+                    plotinfo,
+                    xa._offset + xa._length * 0.9,
+                    y0,
+                    xa._length * 0.1,
+                    DRAGGERSIZE,
+                    "",
+                    "e"
+                  );
+                }
+                if (subplot === ya2._mainSubplot) {
+                  var x0 = ya2._mainLinePosition;
+                  if (ya2.side !== "right") x0 -= DRAGGERSIZE;
+                  makeDragBox(
+                    gd2,
+                    plotinfo,
+                    x0,
+                    ya2._offset + ya2._length * 0.1,
+                    DRAGGERSIZE,
+                    ya2._length * 0.8,
+                    "ns",
+                    ""
+                  );
+                  makeDragBox(
+                    gd2,
+                    plotinfo,
+                    x0,
+                    ya2._offset + ya2._length * 0.9,
+                    DRAGGERSIZE,
+                    ya2._length * 0.1,
+                    "s",
+                    ""
+                  );
+                  makeDragBox(
+                    gd2,
+                    plotinfo,
+                    x0,
+                    ya2._offset,
+                    DRAGGERSIZE,
+                    ya2._length * 0.1,
+                    "n",
+                    ""
+                  );
+                }
+              }
+            });
+            var hoverLayer = fullLayout._hoverlayer.node();
+            hoverLayer.onmousemove = function(evt) {
+              evt.target = gd2._fullLayout._lasthover;
+              Fx.hover(gd2, evt, fullLayout._hoversubplot);
+            };
+            hoverLayer.onclick = function(evt) {
+              evt.target = gd2._fullLayout._lasthover;
+              Fx.click(gd2, evt);
+            };
+            hoverLayer.onmousedown = function(evt) {
+              gd2._fullLayout._lasthover.onmousedown(evt);
+            };
+            exports.updateFx(gd2);
+          };
+          exports.updateFx = function(gd2) {
+            var fullLayout = gd2._fullLayout;
+            var cursor = fullLayout.dragmode === "pan" ? "move" : "crosshair";
+            setCursor(fullLayout._draggers, cursor);
+          };
+        }
+      });
+      var require_container_array_match = __commonJS({
+        "src/plot_api/container_array_match.js"(exports, module2) {
+          var Registry = require_registry();
+          module2.exports = function containerArrayMatch(astr) {
+            var rootContainers = Registry.layoutArrayContainers;
+            var regexpContainers = Registry.layoutArrayRegexes;
+            var rootPart = astr.split("[")[0];
+            var arrayStr;
+            var match;
+            for (var i2 = 0; i2 < regexpContainers.length; i2++) {
+              match = astr.match(regexpContainers[i2]);
+              if (match && match.index === 0) {
+                arrayStr = match[0];
+                break;
+              }
+            }
+            if (!arrayStr) arrayStr = rootContainers[rootContainers.indexOf(rootPart)];
+            if (!arrayStr) return false;
+            var tail = astr.slice(arrayStr.length);
+            if (!tail) return { array: arrayStr, index: "", property: "" };
+            match = tail.match(/^\[(0|[1-9][0-9]*)\](\.(.+))?$/);
+            if (!match) return false;
+            return { array: arrayStr, index: Number(match[1]), property: match[3] || "" };
+          };
+        }
+      });
+      var require_manage_arrays = __commonJS({
+        "src/plot_api/manage_arrays.js"(exports) {
+          var isPlainObject2 = require_is_plain_object();
+          var noop2 = require_noop();
+          var Loggers = require_loggers();
+          var sorterAsc = require_search().sorterAsc;
+          var Registry = require_registry();
+          exports.containerArrayMatch = require_container_array_match();
+          var isAddVal = exports.isAddVal = function isAddVal2(val) {
+            return val === "add" || isPlainObject2(val);
+          };
+          var isRemoveVal = exports.isRemoveVal = function isRemoveVal2(val) {
+            return val === null || val === "remove";
+          };
+          exports.applyContainerArrayChanges = function applyContainerArrayChanges(gd2, np, edits, flags, _nestedProperty) {
+            var componentType = np.astr;
+            var supplyComponentDefaults = Registry.getComponentMethod(componentType, "supplyLayoutDefaults");
+            var draw = Registry.getComponentMethod(componentType, "draw");
+            var drawOne = Registry.getComponentMethod(componentType, "drawOne");
+            var replotLater = flags.replot || flags.recalc || supplyComponentDefaults === noop2 || draw === noop2;
+            var layout = gd2.layout;
+            var fullLayout = gd2._fullLayout;
+            if (edits[""]) {
+              if (Object.keys(edits).length > 1) {
+                Loggers.warn(
+                  "Full array edits are incompatible with other edits",
+                  componentType
+                );
+              }
+              var fullVal = edits[""][""];
+              if (isRemoveVal(fullVal)) np.set(null);
+              else if (Array.isArray(fullVal)) np.set(fullVal);
+              else {
+                Loggers.warn("Unrecognized full array edit value", componentType, fullVal);
+                return true;
+              }
+              if (replotLater) return false;
+              supplyComponentDefaults(layout, fullLayout);
+              draw(gd2);
+              return true;
+            }
+            var componentNums = Object.keys(edits).map(Number).sort(sorterAsc);
+            var componentArrayIn = np.get();
+            var componentArray = componentArrayIn || [];
+            var componentArrayFull = _nestedProperty(fullLayout, componentType).get();
+            var deletes = [];
+            var firstIndexChange = -1;
+            var maxIndex = componentArray.length;
+            var i2;
+            var j2;
+            var componentNum;
+            var objEdits;
+            var objKeys;
+            var objVal;
+            var adding, prefix;
+            for (i2 = 0; i2 < componentNums.length; i2++) {
+              componentNum = componentNums[i2];
+              objEdits = edits[componentNum];
+              objKeys = Object.keys(objEdits);
+              objVal = objEdits[""], adding = isAddVal(objVal);
+              if (componentNum < 0 || componentNum > componentArray.length - (adding ? 0 : 1)) {
+                Loggers.warn("index out of range", componentType, componentNum);
+                continue;
+              }
+              if (objVal !== void 0) {
+                if (objKeys.length > 1) {
+                  Loggers.warn(
+                    "Insertion & removal are incompatible with edits to the same index.",
+                    componentType,
+                    componentNum
+                  );
+                }
+                if (isRemoveVal(objVal)) {
+                  deletes.push(componentNum);
+                } else if (adding) {
+                  if (objVal === "add") objVal = {};
+                  componentArray.splice(componentNum, 0, objVal);
+                  if (componentArrayFull) componentArrayFull.splice(componentNum, 0, {});
+                } else {
+                  Loggers.warn(
+                    "Unrecognized full object edit value",
+                    componentType,
+                    componentNum,
+                    objVal
+                  );
+                }
+                if (firstIndexChange === -1) firstIndexChange = componentNum;
+              } else {
+                for (j2 = 0; j2 < objKeys.length; j2++) {
+                  prefix = componentType + "[" + componentNum + "].";
+                  _nestedProperty(componentArray[componentNum], objKeys[j2], prefix).set(objEdits[objKeys[j2]]);
+                }
+              }
+            }
+            for (i2 = deletes.length - 1; i2 >= 0; i2--) {
+              componentArray.splice(deletes[i2], 1);
+              if (componentArrayFull) componentArrayFull.splice(deletes[i2], 1);
+            }
+            if (!componentArray.length) np.set(null);
+            else if (!componentArrayIn) np.set(componentArray);
+            if (replotLater) return false;
+            supplyComponentDefaults(layout, fullLayout);
+            if (drawOne !== noop2) {
+              var indicesToDraw;
+              if (firstIndexChange === -1) {
+                indicesToDraw = componentNums;
+              } else {
+                maxIndex = Math.max(componentArray.length, maxIndex);
+                indicesToDraw = [];
+                for (i2 = 0; i2 < componentNums.length; i2++) {
+                  componentNum = componentNums[i2];
+                  if (componentNum >= firstIndexChange) break;
+                  indicesToDraw.push(componentNum);
+                }
+                for (i2 = firstIndexChange; i2 < maxIndex; i2++) {
+                  indicesToDraw.push(i2);
+                }
+              }
+              for (i2 = 0; i2 < indicesToDraw.length; i2++) {
+                drawOne(gd2, indicesToDraw[i2]);
+              }
+            } else draw(gd2);
+            return true;
+          };
+        }
+      });
+      var require_helpers9 = __commonJS({
+        "src/plot_api/helpers.js"(exports) {
+          var isNumeric = require_fast_isnumeric();
+          var Registry = require_registry();
+          var Lib = require_lib();
+          var Plots = require_plots();
+          var AxisIds = require_axis_ids();
+          var Color2 = require_color();
+          var cleanId = AxisIds.cleanId;
+          var getFromTrace = AxisIds.getFromTrace;
+          var traceIs = Registry.traceIs;
+          var AX_LETTERS = ["x", "y", "z"];
+          exports.clearPromiseQueue = function(gd2) {
+            if (Array.isArray(gd2._promises) && gd2._promises.length > 0) {
+              Lib.log("Clearing previous rejected promises from queue.");
+            }
+            gd2._promises = [];
+          };
+          exports.cleanLayout = function(layout) {
+            var i2;
+            if (!layout) layout = {};
+            if (layout.xaxis1) {
+              if (!layout.xaxis) layout.xaxis = layout.xaxis1;
+              delete layout.xaxis1;
+            }
+            if (layout.yaxis1) {
+              if (!layout.yaxis) layout.yaxis = layout.yaxis1;
+              delete layout.yaxis1;
+            }
+            if (layout.scene1) {
+              if (!layout.scene) layout.scene = layout.scene1;
+              delete layout.scene1;
+            }
+            var axisAttrRegex = (Plots.subplotsRegistry.cartesian || {}).attrRegex;
+            (Plots.subplotsRegistry.polar || {}).attrRegex;
+            (Plots.subplotsRegistry.ternary || {}).attrRegex;
+            (Plots.subplotsRegistry.gl3d || {}).attrRegex;
+            var keys = Object.keys(layout);
+            for (i2 = 0; i2 < keys.length; i2++) {
+              var key = keys[i2];
+              if (axisAttrRegex && axisAttrRegex.test(key)) {
+                var ax = layout[key];
+                if (ax.anchor && ax.anchor !== "free") {
+                  ax.anchor = cleanId(ax.anchor);
+                }
+                if (ax.overlaying) ax.overlaying = cleanId(ax.overlaying);
+                if (!ax.type) {
+                  if (ax.isdate) ax.type = "date";
+                  else if (ax.islog) ax.type = "log";
+                  else if (ax.isdate === false && ax.islog === false) ax.type = "linear";
+                }
+                if (ax.autorange === "withzero" || ax.autorange === "tozero") {
+                  ax.autorange = true;
+                  ax.rangemode = "tozero";
+                }
+                if (ax.insiderange) delete ax.range;
+                delete ax.islog;
+                delete ax.isdate;
+                delete ax.categories;
+                if (emptyContainer(ax, "domain")) delete ax.domain;
+              }
+            }
+            var annotationsLen = Array.isArray(layout.annotations) ? layout.annotations.length : 0;
+            for (i2 = 0; i2 < annotationsLen; i2++) {
+              var ann = layout.annotations[i2];
+              if (!Lib.isPlainObject(ann)) continue;
+              cleanAxRef(ann, "xref");
+              cleanAxRef(ann, "yref");
+            }
+            var shapesLen = Array.isArray(layout.shapes) ? layout.shapes.length : 0;
+            for (i2 = 0; i2 < shapesLen; i2++) {
+              var shape = layout.shapes[i2];
+              if (!Lib.isPlainObject(shape)) continue;
+              cleanAxRef(shape, "xref", true);
+              cleanAxRef(shape, "yref", true);
+            }
+            var imagesLen = Array.isArray(layout.images) ? layout.images.length : 0;
+            for (i2 = 0; i2 < imagesLen; i2++) {
+              var image = layout.images[i2];
+              if (!Lib.isPlainObject(image)) continue;
+              cleanAxRef(image, "xref");
+              cleanAxRef(image, "yref");
+            }
+            var legend = layout.legend;
+            if (legend) {
+              if (legend.x > 3) {
+                legend.x = 1.02;
+                legend.xanchor = "left";
+              } else if (legend.x < -2) {
+                legend.x = -0.02;
+                legend.xanchor = "right";
+              }
+              if (legend.y > 3) {
+                legend.y = 1.02;
+                legend.yanchor = "bottom";
+              } else if (legend.y < -2) {
+                legend.y = -0.02;
+                legend.yanchor = "top";
+              }
+            }
+            if (layout.dragmode === "rotate") layout.dragmode = "orbit";
+            Color2.clean(layout);
+            if (layout.template && layout.template.layout) {
+              exports.cleanLayout(layout.template.layout);
+            }
+            return layout;
+          };
+          function cleanAxRef(container, attr, isShape = false) {
+            var valIn = container[attr];
+            var axLetter = attr.charAt(0);
+            if (isShape && Array.isArray(valIn)) return;
+            if (valIn && valIn !== "paper") {
+              container[attr] = cleanId(valIn, axLetter, true);
+            }
+          }
+          exports.cleanData = function(data) {
+            for (var tracei = 0; tracei < data.length; tracei++) {
+              var trace = data[tracei];
+              var i2;
+              if (trace.type === "histogramy" && "xbins" in trace && !("ybins" in trace)) {
+                trace.ybins = trace.xbins;
+                delete trace.xbins;
+              }
+              if (trace.type === "histogramy") exports.swapXYData(trace);
+              if (trace.type === "histogramx" || trace.type === "histogramy") {
+                trace.type = "histogram";
+              }
+              if ("scl" in trace && !("colorscale" in trace)) {
+                trace.colorscale = trace.scl;
+                delete trace.scl;
+              }
+              if ("reversescl" in trace && !("reversescale" in trace)) {
+                trace.reversescale = trace.reversescl;
+                delete trace.reversescl;
+              }
+              if (trace.xaxis) trace.xaxis = cleanId(trace.xaxis, "x");
+              if (trace.yaxis) trace.yaxis = cleanId(trace.yaxis, "y");
+              if (traceIs(trace, "gl3d") && trace.scene) {
+                trace.scene = Plots.subplotsRegistry.gl3d.cleanId(trace.scene);
+              }
+              if (!traceIs(trace, "pie-like") && !traceIs(trace, "bar-like")) {
+                if (Array.isArray(trace.textposition)) {
+                  for (i2 = 0; i2 < trace.textposition.length; i2++) {
+                    trace.textposition[i2] = cleanTextPosition(trace.textposition[i2]);
+                  }
+                } else if (trace.textposition) {
+                  trace.textposition = cleanTextPosition(trace.textposition);
+                }
+              }
+              var _module = Registry.getModule(trace);
+              if (_module && _module.colorbar) {
+                var containerName = _module.colorbar.container;
+                var container = containerName ? trace[containerName] : trace;
+                if (container && container.colorscale) {
+                  if (container.colorscale === "YIGnBu") container.colorscale = "YlGnBu";
+                  if (container.colorscale === "YIOrRd") container.colorscale = "YlOrRd";
+                }
+              }
+              if (trace.type === "surface" && Lib.isPlainObject(trace.contours)) {
+                var dims = ["x", "y", "z"];
+                for (i2 = 0; i2 < dims.length; i2++) {
+                  var opts = trace.contours[dims[i2]];
+                  if (!Lib.isPlainObject(opts)) continue;
+                  if (opts.highlightColor) {
+                    opts.highlightcolor = opts.highlightColor;
+                    delete opts.highlightColor;
+                  }
+                  if (opts.highlightWidth) {
+                    opts.highlightwidth = opts.highlightWidth;
+                    delete opts.highlightWidth;
+                  }
+                }
+              }
+              if (trace.type === "candlestick" || trace.type === "ohlc") {
+                var increasingShowlegend = (trace.increasing || {}).showlegend !== false;
+                var decreasingShowlegend = (trace.decreasing || {}).showlegend !== false;
+                var increasingName = cleanFinanceDir(trace.increasing);
+                var decreasingName = cleanFinanceDir(trace.decreasing);
+                if (increasingName !== false && decreasingName !== false) {
+                  var newName = commonPrefix(increasingName, decreasingName, increasingShowlegend, decreasingShowlegend);
+                  if (newName) trace.name = newName;
+                } else if ((increasingName || decreasingName) && !trace.name) {
+                  trace.name = increasingName || decreasingName;
+                }
+              }
+              if (emptyContainer(trace, "line")) delete trace.line;
+              if ("marker" in trace) {
+                if (emptyContainer(trace.marker, "line")) delete trace.marker.line;
+                if (emptyContainer(trace, "marker")) delete trace.marker;
+              }
+              Color2.clean(trace);
+              if (trace.autobinx) {
+                delete trace.autobinx;
+                delete trace.xbins;
+              }
+              if (trace.autobiny) {
+                delete trace.autobiny;
+                delete trace.ybins;
+              }
+            }
+          };
+          function cleanFinanceDir(dirContainer) {
+            if (!Lib.isPlainObject(dirContainer)) return false;
+            var dirName = dirContainer.name;
+            delete dirContainer.name;
+            delete dirContainer.showlegend;
+            return (typeof dirName === "string" || typeof dirName === "number") && String(dirName);
+          }
+          function commonPrefix(name1, name2, show1, show2) {
+            if (show1 && !show2) return name1;
+            if (show2 && !show1) return name2;
+            if (!name1.trim()) return name2;
+            if (!name2.trim()) return name1;
+            var minLen = Math.min(name1.length, name2.length);
+            var i2;
+            for (i2 = 0; i2 < minLen; i2++) {
+              if (name1.charAt(i2) !== name2.charAt(i2)) break;
+            }
+            var out = name1.slice(0, i2);
+            return out.trim();
+          }
+          function cleanTextPosition(textposition) {
+            var posY = "middle";
+            var posX = "center";
+            if (typeof textposition === "string") {
+              if (textposition.indexOf("top") !== -1) posY = "top";
+              else if (textposition.indexOf("bottom") !== -1) posY = "bottom";
+              if (textposition.indexOf("left") !== -1) posX = "left";
+              else if (textposition.indexOf("right") !== -1) posX = "right";
+            }
+            return posY + " " + posX;
+          }
+          function emptyContainer(outer, innerStr) {
+            return innerStr in outer && typeof outer[innerStr] === "object" && Object.keys(outer[innerStr]).length === 0;
+          }
+          exports.swapXYData = function(trace) {
+            var i2;
+            Lib.swapAttrs(trace, ["?", "?0", "d?", "?bins", "nbins?", "autobin?", "?src", "error_?"]);
+            if (Array.isArray(trace.z) && Array.isArray(trace.z[0])) {
+              if (trace.transpose) delete trace.transpose;
+              else trace.transpose = true;
+            }
+            if (trace.error_x && trace.error_y) {
+              var errorY = trace.error_y;
+              var copyYstyle = "copy_ystyle" in errorY ? errorY.copy_ystyle : !(errorY.color || errorY.thickness || errorY.width);
+              Lib.swapAttrs(trace, ["error_?.copy_ystyle"]);
+              if (copyYstyle) {
+                Lib.swapAttrs(trace, ["error_?.color", "error_?.thickness", "error_?.width"]);
+              }
+            }
+            if (typeof trace.hoverinfo === "string") {
+              var hoverInfoParts = trace.hoverinfo.split("+");
+              for (i2 = 0; i2 < hoverInfoParts.length; i2++) {
+                if (hoverInfoParts[i2] === "x") hoverInfoParts[i2] = "y";
+                else if (hoverInfoParts[i2] === "y") hoverInfoParts[i2] = "x";
+              }
+              trace.hoverinfo = hoverInfoParts.join("+");
+            }
+          };
+          exports.coerceTraceIndices = function(gd2, traceIndices) {
+            if (isNumeric(traceIndices)) {
+              return [traceIndices];
+            } else if (!Array.isArray(traceIndices) || !traceIndices.length) {
+              return gd2.data.map(function(_2, i22) {
+                return i22;
+              });
+            } else if (Array.isArray(traceIndices)) {
+              var traceIndicesOut = [];
+              for (var i2 = 0; i2 < traceIndices.length; i2++) {
+                if (Lib.isIndex(traceIndices[i2], gd2.data.length)) {
+                  traceIndicesOut.push(traceIndices[i2]);
+                } else {
+                  Lib.warn("trace index (", traceIndices[i2], ") is not a number or is out of bounds");
+                }
+              }
+              return traceIndicesOut;
+            }
+            return traceIndices;
+          };
+          exports.manageArrayContainers = function(np, newVal, undoit) {
+            var obj = np.obj;
+            var parts = np.parts;
+            var pLength = parts.length;
+            var pLast = parts[pLength - 1];
+            var pLastIsNumber = isNumeric(pLast);
+            if (pLastIsNumber && newVal === null) {
+              var contPath = parts.slice(0, pLength - 1).join(".");
+              var cont = Lib.nestedProperty(obj, contPath).get();
+              cont.splice(pLast, 1);
+            } else if (pLastIsNumber && np.get() === void 0) {
+              if (np.get() === void 0) undoit[np.astr] = null;
+              np.set(newVal);
+            } else {
+              np.set(newVal);
+            }
+          };
+          var ATTR_TAIL_RE = /(\.[^\[\]\.]+|\[[^\[\]\.]+\])$/;
+          function getParent(attr) {
+            var tail = attr.search(ATTR_TAIL_RE);
+            if (tail > 0) return attr.slice(0, tail);
+          }
+          exports.hasParent = function(aobj, attr) {
+            var attrParent = getParent(attr);
+            while (attrParent) {
+              if (attrParent in aobj) return true;
+              attrParent = getParent(attrParent);
+            }
+            return false;
+          };
+          exports.clearAxisTypes = function(gd2, traces, layoutUpdate) {
+            for (var i2 = 0; i2 < traces.length; i2++) {
+              var trace = gd2._fullData[i2];
+              for (var j2 = 0; j2 < 3; j2++) {
+                var ax = getFromTrace(gd2, trace, AX_LETTERS[j2]);
+                if (ax && ax.type !== "log") {
+                  var axAttr = ax._name;
+                  var sceneName = ax._id.slice(1);
+                  if (sceneName.slice(0, 5) === "scene") {
+                    if (layoutUpdate[sceneName] !== void 0) continue;
+                    axAttr = sceneName + "." + axAttr;
+                  }
+                  var typeAttr = axAttr + ".type";
+                  if (layoutUpdate[axAttr] === void 0 && layoutUpdate[typeAttr] === void 0) {
+                    Lib.nestedProperty(gd2.layout, typeAttr).set(null);
+                  }
+                }
+              }
+            }
+          };
+          var collectionsAreEqual = (collection1, collection2) => {
+            const isArrayOrObject = (...vals) => vals.every((v2) => Lib.isPlainObject(v2)) || vals.every((v2) => Array.isArray(v2));
+            if ([collection1, collection2].every((a2) => Array.isArray(a2))) {
+              if (collection1.length !== collection2.length) return false;
+              for (let i2 = 0; i2 < collection1.length; i2++) {
+                const oldVal = collection1[i2];
+                const newVal = collection2[i2];
+                if (oldVal !== newVal) {
+                  const equal = isArrayOrObject(oldVal, newVal) ? collectionsAreEqual(oldVal, newVal) : false;
+                  if (!equal) return false;
+                }
+              }
+              return true;
+            } else if ([collection1, collection2].every((a2) => Lib.isPlainObject(a2))) {
+              if (Object.keys(collection1).length !== Object.keys(collection2).length) return false;
+              for (const k2 in collection1) {
+                if (k2.startsWith("_")) continue;
+                const oldVal = collection1[k2];
+                const newVal = collection2[k2];
+                if (oldVal !== newVal) {
+                  const equal = isArrayOrObject(oldVal, newVal) ? collectionsAreEqual(oldVal, newVal) : false;
+                  if (!equal) return false;
+                }
+              }
+              return true;
+            }
+            return false;
+          };
+          exports.collectionsAreEqual = collectionsAreEqual;
+        }
+      });
+      var require_plot_api = __commonJS({
+        "src/plot_api/plot_api.js"(exports) {
+          var d3 = require_d3();
+          var isNumeric = require_fast_isnumeric();
+          var hasHover = require_has_hover();
+          var Lib = require_lib();
+          var nestedProperty = Lib.nestedProperty;
+          var Events = require_events2();
+          var Queue = require_queue();
+          var Registry = require_registry();
+          var PlotSchema = require_plot_schema();
+          var Plots = require_plots();
+          var Axes = require_axes();
+          var handleRangeDefaults = require_range_defaults();
+          var cartesianLayoutAttributes = require_layout_attributes4();
+          var Drawing = require_drawing();
+          var Color2 = require_color();
+          var initInteractions = require_graph_interact().initInteractions;
+          var xmlnsNamespaces = require_xmlns_namespaces();
+          var clearOutline = require_selections().clearOutline;
+          var dfltConfig = require_plot_config().dfltConfig;
+          var manageArrays = require_manage_arrays();
+          var helpers = require_helpers9();
+          var subroutines = require_subroutines();
+          var editTypes = require_edit_types();
+          var AX_NAME_PATTERN = require_constants2().AX_NAME_PATTERN;
+          var numericNameWarningCount = 0;
+          var numericNameWarningCountLimit = 5;
+          function _doPlot(gd2, data, layout, config2) {
+            var frames;
+            gd2 = Lib.getGraphDiv(gd2);
+            Events.init(gd2);
+            if (Lib.isPlainObject(data)) {
+              var obj = data;
+              data = obj.data;
+              layout = obj.layout;
+              config2 = obj.config;
+              frames = obj.frames;
+            }
+            var okToPlot = Events.triggerHandler(gd2, "plotly_beforeplot", [data, layout, config2]);
+            if (okToPlot === false) return Promise.reject();
+            if (!data && !layout && !Lib.isPlotDiv(gd2)) {
+              Lib.warn("Calling _doPlot as if redrawing but this container doesn't yet have a plot.", gd2);
+            }
+            function addFrames2() {
+              if (frames) {
+                return exports.addFrames(gd2, frames);
+              }
+            }
+            setPlotContext(gd2, config2);
+            if (!layout) layout = {};
+            d3.select(gd2).classed("js-plotly-plot", true);
+            Drawing.makeTester();
+            if (!Array.isArray(gd2._promises)) gd2._promises = [];
+            var graphWasEmpty = (gd2.data || []).length === 0 && Array.isArray(data);
+            if (Array.isArray(data)) {
+              helpers.cleanData(data);
+              if (graphWasEmpty) gd2.data = data;
+              else gd2.data.push.apply(gd2.data, data);
+              gd2.empty = false;
+            }
+            if (!gd2.layout || graphWasEmpty) {
+              gd2.layout = helpers.cleanLayout(layout);
+            }
+            Plots.supplyDefaults(gd2);
+            var fullLayout = gd2._fullLayout;
+            var hasCartesian = fullLayout._has("cartesian");
+            fullLayout._replotting = true;
+            if (graphWasEmpty || fullLayout._shouldCreateBgLayer) {
+              makePlotFramework(gd2);
+              if (fullLayout._shouldCreateBgLayer) {
+                delete fullLayout._shouldCreateBgLayer;
+              }
+            }
+            Drawing.initGradients(gd2);
+            Drawing.initPatterns(gd2);
+            if (graphWasEmpty) Axes.saveShowSpikeInitial(gd2);
+            var recalc = !gd2.calcdata || gd2.calcdata.length !== (gd2._fullData || []).length;
+            if (recalc) Plots.doCalcdata(gd2);
+            for (var i2 = 0; i2 < gd2.calcdata.length; i2++) {
+              gd2.calcdata[i2][0].trace = gd2._fullData[i2];
+            }
+            if (gd2._context.responsive) {
+              if (!gd2._responsiveChartHandler) {
+                gd2._responsiveChartHandler = function() {
+                  if (!Lib.isHidden(gd2)) Plots.resize(gd2);
+                };
+                window.addEventListener("resize", gd2._responsiveChartHandler);
+              }
+            } else {
+              Lib.clearResponsive(gd2);
+            }
+            var oldMargins = Lib.extendFlat({}, fullLayout._size);
+            var drawFrameworkCalls = 0;
+            function drawFramework() {
+              var basePlotModules = fullLayout._basePlotModules;
+              for (var i22 = 0; i22 < basePlotModules.length; i22++) {
+                if (basePlotModules[i22].drawFramework) {
+                  basePlotModules[i22].drawFramework(gd2);
+                }
+              }
+              if (!fullLayout._glcanvas && fullLayout._has("gl")) {
+                fullLayout._glcanvas = fullLayout._glcontainer.selectAll(".gl-canvas").data(
+                  [
+                    {
+                      key: "contextLayer",
+                      context: true,
+                      pick: false
+                    },
+                    {
+                      key: "focusLayer",
+                      context: false,
+                      pick: false
+                    },
+                    {
+                      key: "pickLayer",
+                      context: false,
+                      pick: true
+                    }
+                  ],
+                  function(d2) {
+                    return d2.key;
+                  }
+                );
+                fullLayout._glcanvas.enter().append("canvas").attr("class", function(d2) {
+                  return "gl-canvas gl-canvas-" + d2.key.replace("Layer", "");
+                }).style({
+                  position: "absolute",
+                  top: 0,
+                  left: 0,
+                  overflow: "visible",
+                  "pointer-events": "none"
+                });
+              }
+              var plotGlPixelRatio = gd2._context.plotGlPixelRatio;
+              if (fullLayout._glcanvas) {
+                fullLayout._glcanvas.attr("width", fullLayout.width * plotGlPixelRatio).attr("height", fullLayout.height * plotGlPixelRatio).style("width", fullLayout.width + "px").style("height", fullLayout.height + "px");
+                var regl = fullLayout._glcanvas.data()[0].regl;
+                if (regl) {
+                  if (Math.floor(fullLayout.width * plotGlPixelRatio) !== regl._gl.drawingBufferWidth || Math.floor(fullLayout.height * plotGlPixelRatio) !== regl._gl.drawingBufferHeight) {
+                    var msg = "WebGL context buffer and canvas dimensions do not match due to browser/WebGL bug.";
+                    if (drawFrameworkCalls) {
+                      Lib.error(msg);
+                    } else {
+                      Lib.log(msg + " Clearing graph and plotting again.");
+                      Plots.cleanPlot([], {}, gd2._fullData, fullLayout);
+                      Plots.supplyDefaults(gd2);
+                      fullLayout = gd2._fullLayout;
+                      Plots.doCalcdata(gd2);
+                      drawFrameworkCalls++;
+                      return drawFramework();
+                    }
+                  }
+                }
+              }
+              if (fullLayout.modebar.orientation === "h") {
+                fullLayout._modebardiv.style("height", null).style("width", "100%");
+              } else {
+                fullLayout._modebardiv.style("width", null).style("height", fullLayout.height + "px");
+              }
+              return Plots.previousPromises(gd2);
+            }
+            function marginPushers() {
+              Plots.clearAutoMarginIds(gd2);
+              subroutines.drawMarginPushers(gd2);
+              Axes.allowAutoMargin(gd2);
+              if (gd2._fullLayout.title.text && gd2._fullLayout.title.automargin) Plots.allowAutoMargin(gd2, "title.automargin");
+              if (fullLayout._has("pie")) {
+                var fullData = gd2._fullData;
+                for (var i22 = 0; i22 < fullData.length; i22++) {
+                  var trace = fullData[i22];
+                  if (trace.type === "pie" && trace.automargin) {
+                    Plots.allowAutoMargin(gd2, "pie." + trace.uid + ".automargin");
+                  }
+                }
+              }
+              Plots.doAutoMargin(gd2);
+              return Plots.previousPromises(gd2);
+            }
+            function marginPushersAgain() {
+              if (!Plots.didMarginChange(oldMargins, fullLayout._size)) return;
+              return Lib.syncOrAsync([marginPushers, subroutines.layoutStyles], gd2);
+            }
+            function positionAndAutorange() {
+              if (!recalc) {
+                doAutoRangeAndConstraints();
+                return;
+              }
+              return Lib.syncOrAsync(
+                [
+                  Registry.getComponentMethod("shapes", "calcAutorange"),
+                  Registry.getComponentMethod("annotations", "calcAutorange"),
+                  doAutoRangeAndConstraints
+                ],
+                gd2
+              );
+            }
+            function doAutoRangeAndConstraints() {
+              if (gd2._transitioning) return;
+              subroutines.doAutoRangeAndConstraints(gd2);
+              if (graphWasEmpty) Axes.saveRangeInitial(gd2);
+              Registry.getComponentMethod("rangeslider", "calcAutorange")(gd2);
+            }
+            function drawAxes() {
+              return Axes.draw(gd2, graphWasEmpty ? "" : "redraw");
+            }
+            var seq = [Plots.previousPromises, addFrames2, drawFramework, marginPushers, marginPushersAgain];
+            if (hasCartesian) seq.push(positionAndAutorange);
+            seq.push(subroutines.layoutStyles);
+            if (hasCartesian) {
+              seq.push(drawAxes, function insideTickLabelsAutorange(gd22) {
+                var insideTickLabelsUpdaterange = gd22._fullLayout._insideTickLabelsUpdaterange;
+                if (insideTickLabelsUpdaterange) {
+                  gd22._fullLayout._insideTickLabelsUpdaterange = void 0;
+                  return relayout(gd22, insideTickLabelsUpdaterange).then(function() {
+                    Axes.saveRangeInitial(gd22, true);
+                  });
+                }
+              });
+            }
+            seq.push(
+              subroutines.drawData,
+              subroutines.finalDraw,
+              initInteractions,
+              Plots.addLinks,
+              Plots.rehover,
+              Plots.redrag,
+              Plots.reselect,
+              // TODO: doAutoMargin is only needed here for axis automargin, which
+              // happens outside of marginPushers where all the other automargins are
+              // calculated. Would be much better to separate margin calculations from
+              // component drawing - see https://github.com/plotly/plotly.js/issues/2704
+              Plots.doAutoMargin,
+              Plots.previousPromises
+            );
+            var plotDone = Lib.syncOrAsync(seq, gd2);
+            if (!plotDone || !plotDone.then) plotDone = Promise.resolve();
+            return plotDone.then(function() {
+              emitAfterPlot(gd2);
+              return gd2;
+            });
+          }
+          function emitAfterPlot(gd2) {
+            var fullLayout = gd2._fullLayout;
+            if (fullLayout._redrawFromAutoMarginCount) {
+              fullLayout._redrawFromAutoMarginCount--;
+            } else {
+              gd2.emit("plotly_afterplot");
+            }
+          }
+          function setPlotConfig(obj) {
+            return Lib.extendFlat(dfltConfig, obj);
+          }
+          function setBackground(gd2, bgColor) {
+            try {
+              gd2._fullLayout._paper.style("background", bgColor);
+            } catch (e2) {
+              Lib.error(e2);
+            }
+          }
+          function opaqueSetBackground(gd2, bgColor) {
+            var blend = Color2.combine(bgColor, "white");
+            setBackground(gd2, blend);
+          }
+          function setPlotContext(gd2, config2) {
+            if (!gd2._context) {
+              gd2._context = Lib.extendDeep({}, dfltConfig);
+              var base = d3.select("base");
+              gd2._context._baseUrl = base.size() && base.attr("href") ? window.location.href.split("#")[0] : "";
+            }
+            var context = gd2._context;
+            var i2, keys, key;
+            if (config2) {
+              keys = Object.keys(config2);
+              for (i2 = 0; i2 < keys.length; i2++) {
+                key = keys[i2];
+                if (key === "editable" || key === "edits") continue;
+                if (key in context) {
+                  if (key === "setBackground" && config2[key] === "opaque") {
+                    context[key] = opaqueSetBackground;
+                  } else {
+                    context[key] = config2[key];
+                  }
+                }
+              }
+              var editable = config2.editable;
+              if (editable !== void 0) {
+                context.editable = editable;
+                keys = Object.keys(context.edits);
+                for (i2 = 0; i2 < keys.length; i2++) {
+                  context.edits[keys[i2]] = editable;
+                }
+              }
+              if (config2.edits) {
+                keys = Object.keys(config2.edits);
+                for (i2 = 0; i2 < keys.length; i2++) {
+                  key = keys[i2];
+                  if (key in context.edits) {
+                    context.edits[key] = config2.edits[key];
+                  }
+                }
+              }
+              context._exportedPlot = config2._exportedPlot;
+            }
+            if (context.staticPlot) {
+              context.editable = false;
+              context.edits = {};
+              context.autosizable = false;
+              context.scrollZoom = false;
+              context.doubleClick = false;
+              context.showTips = false;
+              context.showLink = false;
+              context.displayModeBar = false;
+            }
+            if (context.displayModeBar === "hover" && !hasHover) {
+              context.displayModeBar = true;
+            }
+            if (context.setBackground === "transparent" || typeof context.setBackground !== "function") {
+              context.setBackground = setBackground;
+            }
+            context._hasZeroHeight = context._hasZeroHeight || gd2.clientHeight === 0;
+            context._hasZeroWidth = context._hasZeroWidth || gd2.clientWidth === 0;
+            var szIn = context.scrollZoom;
+            var szOut = context._scrollZoom = {};
+            if (szIn === true) {
+              szOut.cartesian = 1;
+              szOut.gl3d = 1;
+              szOut.geo = 1;
+              szOut.mapbox = 1;
+              szOut.map = 1;
+            } else if (typeof szIn === "string") {
+              var parts = szIn.split("+");
+              for (i2 = 0; i2 < parts.length; i2++) {
+                szOut[parts[i2]] = 1;
+              }
+            } else if (szIn !== false) {
+              szOut.gl3d = 1;
+              szOut.geo = 1;
+              szOut.mapbox = 1;
+              szOut.map = 1;
+            }
+          }
+          function redraw(gd2) {
+            gd2 = Lib.getGraphDiv(gd2);
+            if (!Lib.isPlotDiv(gd2)) {
+              throw new Error("This element is not a Plotly plot: " + gd2);
+            }
+            helpers.cleanData(gd2.data);
+            helpers.cleanLayout(gd2.layout);
+            gd2.calcdata = void 0;
+            return exports._doPlot(gd2).then(function() {
+              gd2.emit("plotly_redraw");
+              return gd2;
+            });
+          }
+          function newPlot(gd2, data, layout, config2) {
+            gd2 = Lib.getGraphDiv(gd2);
+            Plots.cleanPlot([], {}, gd2._fullData || [], gd2._fullLayout || {});
+            Plots.purge(gd2);
+            return exports._doPlot(gd2, data, layout, config2);
+          }
+          function positivifyIndices(indices, maxIndex) {
+            var parentLength = maxIndex + 1;
+            var positiveIndices = [];
+            var i2;
+            var index;
+            for (i2 = 0; i2 < indices.length; i2++) {
+              index = indices[i2];
+              if (index < 0) {
+                positiveIndices.push(parentLength + index);
+              } else {
+                positiveIndices.push(index);
+              }
+            }
+            return positiveIndices;
+          }
+          function assertIndexArray(gd2, indices, arrayName) {
+            var i2, index;
+            for (i2 = 0; i2 < indices.length; i2++) {
+              index = indices[i2];
+              if (index !== parseInt(index, 10)) {
+                throw new Error("all values in " + arrayName + " must be integers");
+              }
+              if (index >= gd2.data.length || index < -gd2.data.length) {
+                throw new Error(arrayName + " must be valid indices for gd.data.");
+              }
+              if (indices.indexOf(index, i2 + 1) > -1 || index >= 0 && indices.indexOf(-gd2.data.length + index) > -1 || index < 0 && indices.indexOf(gd2.data.length + index) > -1) {
+                throw new Error("each index in " + arrayName + " must be unique.");
+              }
+            }
+          }
+          function checkMoveTracesArgs(gd2, currentIndices, newIndices) {
+            if (!Array.isArray(gd2.data)) {
+              throw new Error("gd.data must be an array.");
+            }
+            if (typeof currentIndices === "undefined") {
+              throw new Error("currentIndices is a required argument.");
+            } else if (!Array.isArray(currentIndices)) {
+              currentIndices = [currentIndices];
+            }
+            assertIndexArray(gd2, currentIndices, "currentIndices");
+            if (typeof newIndices !== "undefined" && !Array.isArray(newIndices)) {
+              newIndices = [newIndices];
+            }
+            if (typeof newIndices !== "undefined") {
+              assertIndexArray(gd2, newIndices, "newIndices");
+            }
+            if (typeof newIndices !== "undefined" && currentIndices.length !== newIndices.length) {
+              throw new Error("current and new indices must be of equal length.");
+            }
+          }
+          function checkAddTracesArgs(gd2, traces, newIndices) {
+            var i2, value;
+            if (!Array.isArray(gd2.data)) {
+              throw new Error("gd.data must be an array.");
+            }
+            if (typeof traces === "undefined") {
+              throw new Error("traces must be defined.");
+            }
+            if (!Array.isArray(traces)) {
+              traces = [traces];
+            }
+            for (i2 = 0; i2 < traces.length; i2++) {
+              value = traces[i2];
+              if (typeof value !== "object" || Array.isArray(value) || value === null) {
+                throw new Error("all values in traces array must be non-array objects");
+              }
+            }
+            if (typeof newIndices !== "undefined" && !Array.isArray(newIndices)) {
+              newIndices = [newIndices];
+            }
+            if (typeof newIndices !== "undefined" && newIndices.length !== traces.length) {
+              throw new Error("if indices is specified, traces.length must equal indices.length");
+            }
+          }
+          function assertExtendTracesArgs(gd2, update2, indices, maxPoints) {
+            var maxPointsIsObject = Lib.isPlainObject(maxPoints);
+            if (!Array.isArray(gd2.data)) {
+              throw new Error("gd.data must be an array");
+            }
+            if (!Lib.isPlainObject(update2)) {
+              throw new Error("update must be a key:value object");
+            }
+            if (typeof indices === "undefined") {
+              throw new Error("indices must be an integer or array of integers");
+            }
+            assertIndexArray(gd2, indices, "indices");
+            for (var key in update2) {
+              if (!Array.isArray(update2[key]) || update2[key].length !== indices.length) {
+                throw new Error("attribute " + key + " must be an array of length equal to indices array length");
+              }
+              if (maxPointsIsObject && (!(key in maxPoints) || !Array.isArray(maxPoints[key]) || maxPoints[key].length !== update2[key].length)) {
+                throw new Error(
+                  "when maxPoints is set as a key:value object it must contain a 1:1 correspondence with the keys and number of traces in the update object"
+                );
+              }
+            }
+          }
+          function getExtendProperties(gd2, update2, indices, maxPoints) {
+            var maxPointsIsObject = Lib.isPlainObject(maxPoints);
+            var updateProps = [];
+            var trace, target, prop, insert, maxp;
+            if (!Array.isArray(indices)) indices = [indices];
+            indices = positivifyIndices(indices, gd2.data.length - 1);
+            for (var key in update2) {
+              for (var j2 = 0; j2 < indices.length; j2++) {
+                trace = gd2.data[indices[j2]];
+                prop = nestedProperty(trace, key);
+                target = prop.get();
+                insert = update2[key][j2];
+                if (!Lib.isArrayOrTypedArray(insert)) {
+                  throw new Error("attribute: " + key + " index: " + j2 + " must be an array");
+                }
+                if (!Lib.isArrayOrTypedArray(target)) {
+                  throw new Error("cannot extend missing or non-array attribute: " + key);
+                }
+                if (target.constructor !== insert.constructor) {
+                  throw new Error("cannot extend array with an array of a different type: " + key);
+                }
+                maxp = maxPointsIsObject ? maxPoints[key][j2] : maxPoints;
+                if (!isNumeric(maxp)) maxp = -1;
+                updateProps.push({
+                  prop,
+                  target,
+                  insert,
+                  maxp: Math.floor(maxp)
+                });
+              }
+            }
+            return updateProps;
+          }
+          function spliceTraces(gd2, update2, indices, maxPoints, updateArray) {
+            assertExtendTracesArgs(gd2, update2, indices, maxPoints);
+            var updateProps = getExtendProperties(gd2, update2, indices, maxPoints);
+            var undoUpdate = {};
+            var undoPoints = {};
+            for (var i2 = 0; i2 < updateProps.length; i2++) {
+              var prop = updateProps[i2].prop;
+              var maxp = updateProps[i2].maxp;
+              var out = updateArray(updateProps[i2].target, updateProps[i2].insert, maxp);
+              prop.set(out[0]);
+              if (!Array.isArray(undoUpdate[prop.astr])) undoUpdate[prop.astr] = [];
+              undoUpdate[prop.astr].push(out[1]);
+              if (!Array.isArray(undoPoints[prop.astr])) undoPoints[prop.astr] = [];
+              undoPoints[prop.astr].push(updateProps[i2].target.length);
+            }
+            return { update: undoUpdate, maxPoints: undoPoints };
+          }
+          function concatTypedArray(arr0, arr1) {
+            var arr2 = new arr0.constructor(arr0.length + arr1.length);
+            arr2.set(arr0);
+            arr2.set(arr1, arr0.length);
+            return arr2;
+          }
+          function extendTraces(gd2, update2, indices, maxPoints) {
+            gd2 = Lib.getGraphDiv(gd2);
+            function updateArray(target, insert, maxp) {
+              var newArray, remainder;
+              if (Lib.isTypedArray(target)) {
+                if (maxp < 0) {
+                  var none = new target.constructor(0);
+                  var both = concatTypedArray(target, insert);
+                  if (maxp < 0) {
+                    newArray = both;
+                    remainder = none;
+                  } else {
+                    newArray = none;
+                    remainder = both;
+                  }
+                } else {
+                  newArray = new target.constructor(maxp);
+                  remainder = new target.constructor(target.length + insert.length - maxp);
+                  if (maxp === insert.length) {
+                    newArray.set(insert);
+                    remainder.set(target);
+                  } else if (maxp < insert.length) {
+                    var numberOfItemsFromInsert = insert.length - maxp;
+                    newArray.set(insert.subarray(numberOfItemsFromInsert));
+                    remainder.set(target);
+                    remainder.set(insert.subarray(0, numberOfItemsFromInsert), target.length);
+                  } else {
+                    var numberOfItemsFromTarget = maxp - insert.length;
+                    var targetBegin = target.length - numberOfItemsFromTarget;
+                    newArray.set(target.subarray(targetBegin));
+                    newArray.set(insert, numberOfItemsFromTarget);
+                    remainder.set(target.subarray(0, targetBegin));
+                  }
+                }
+              } else {
+                newArray = target.concat(insert);
+                remainder = maxp >= 0 && maxp < newArray.length ? newArray.splice(0, newArray.length - maxp) : [];
+              }
+              return [newArray, remainder];
+            }
+            var undo = spliceTraces(gd2, update2, indices, maxPoints, updateArray);
+            var promise = exports.redraw(gd2);
+            var undoArgs = [gd2, undo.update, indices, undo.maxPoints];
+            Queue.add(gd2, exports.prependTraces, undoArgs, extendTraces, arguments);
+            return promise;
+          }
+          function prependTraces(gd2, update2, indices, maxPoints) {
+            gd2 = Lib.getGraphDiv(gd2);
+            function updateArray(target, insert, maxp) {
+              var newArray, remainder;
+              if (Lib.isTypedArray(target)) {
+                if (maxp <= 0) {
+                  var none = new target.constructor(0);
+                  var both = concatTypedArray(insert, target);
+                  if (maxp < 0) {
+                    newArray = both;
+                    remainder = none;
+                  } else {
+                    newArray = none;
+                    remainder = both;
+                  }
+                } else {
+                  newArray = new target.constructor(maxp);
+                  remainder = new target.constructor(target.length + insert.length - maxp);
+                  if (maxp === insert.length) {
+                    newArray.set(insert);
+                    remainder.set(target);
+                  } else if (maxp < insert.length) {
+                    var numberOfItemsFromInsert = insert.length - maxp;
+                    newArray.set(insert.subarray(0, numberOfItemsFromInsert));
+                    remainder.set(insert.subarray(numberOfItemsFromInsert));
+                    remainder.set(target, numberOfItemsFromInsert);
+                  } else {
+                    var numberOfItemsFromTarget = maxp - insert.length;
+                    newArray.set(insert);
+                    newArray.set(target.subarray(0, numberOfItemsFromTarget), insert.length);
+                    remainder.set(target.subarray(numberOfItemsFromTarget));
+                  }
+                }
+              } else {
+                newArray = insert.concat(target);
+                remainder = maxp >= 0 && maxp < newArray.length ? newArray.splice(maxp, newArray.length) : [];
+              }
+              return [newArray, remainder];
+            }
+            var undo = spliceTraces(gd2, update2, indices, maxPoints, updateArray);
+            var promise = exports.redraw(gd2);
+            var undoArgs = [gd2, undo.update, indices, undo.maxPoints];
+            Queue.add(gd2, exports.extendTraces, undoArgs, prependTraces, arguments);
+            return promise;
+          }
+          function addTraces(gd2, traces, newIndices) {
+            gd2 = Lib.getGraphDiv(gd2);
+            var currentIndices = [];
+            var undoFunc = exports.deleteTraces;
+            var redoFunc = addTraces;
+            var undoArgs = [gd2, currentIndices];
+            var redoArgs = [gd2, traces];
+            var i2;
+            var promise;
+            checkAddTracesArgs(gd2, traces, newIndices);
+            if (!Array.isArray(traces)) {
+              traces = [traces];
+            }
+            traces = traces.map(function(trace) {
+              return Lib.extendFlat({}, trace);
+            });
+            helpers.cleanData(traces);
+            for (i2 = 0; i2 < traces.length; i2++) {
+              gd2.data.push(traces[i2]);
+            }
+            for (i2 = 0; i2 < traces.length; i2++) {
+              currentIndices.push(-traces.length + i2);
+            }
+            if (typeof newIndices === "undefined") {
+              promise = exports.redraw(gd2);
+              Queue.add(gd2, undoFunc, undoArgs, redoFunc, redoArgs);
+              return promise;
+            }
+            if (!Array.isArray(newIndices)) {
+              newIndices = [newIndices];
+            }
+            try {
+              checkMoveTracesArgs(gd2, currentIndices, newIndices);
+            } catch (error) {
+              gd2.data.splice(gd2.data.length - traces.length, traces.length);
+              throw error;
+            }
+            Queue.startSequence(gd2);
+            Queue.add(gd2, undoFunc, undoArgs, redoFunc, redoArgs);
+            promise = exports.moveTraces(gd2, currentIndices, newIndices);
+            Queue.stopSequence(gd2);
+            return promise;
+          }
+          function deleteTraces(gd2, indices) {
+            gd2 = Lib.getGraphDiv(gd2);
+            var traces = [];
+            var undoFunc = exports.addTraces;
+            var redoFunc = deleteTraces;
+            var undoArgs = [gd2, traces, indices];
+            var redoArgs = [gd2, indices];
+            var i2;
+            var deletedTrace;
+            if (typeof indices === "undefined") {
+              throw new Error("indices must be an integer or array of integers.");
+            } else if (!Array.isArray(indices)) {
+              indices = [indices];
+            }
+            assertIndexArray(gd2, indices, "indices");
+            indices = positivifyIndices(indices, gd2.data.length - 1);
+            indices.sort(Lib.sorterDes);
+            for (i2 = 0; i2 < indices.length; i2 += 1) {
+              deletedTrace = gd2.data.splice(indices[i2], 1)[0];
+              traces.push(deletedTrace);
+            }
+            var promise = exports.redraw(gd2);
+            Queue.add(gd2, undoFunc, undoArgs, redoFunc, redoArgs);
+            return promise;
+          }
+          function moveTraces(gd2, currentIndices, newIndices) {
+            gd2 = Lib.getGraphDiv(gd2);
+            var newData = [];
+            var movingTraceMap = [];
+            var undoFunc = moveTraces;
+            var redoFunc = moveTraces;
+            var undoArgs = [gd2, newIndices, currentIndices];
+            var redoArgs = [gd2, currentIndices, newIndices];
+            var i2;
+            checkMoveTracesArgs(gd2, currentIndices, newIndices);
+            currentIndices = Array.isArray(currentIndices) ? currentIndices : [currentIndices];
+            if (typeof newIndices === "undefined") {
+              newIndices = [];
+              for (i2 = 0; i2 < currentIndices.length; i2++) {
+                newIndices.push(-currentIndices.length + i2);
+              }
+            }
+            newIndices = Array.isArray(newIndices) ? newIndices : [newIndices];
+            currentIndices = positivifyIndices(currentIndices, gd2.data.length - 1);
+            newIndices = positivifyIndices(newIndices, gd2.data.length - 1);
+            for (i2 = 0; i2 < gd2.data.length; i2++) {
+              if (currentIndices.indexOf(i2) === -1) {
+                newData.push(gd2.data[i2]);
+              }
+            }
+            for (i2 = 0; i2 < currentIndices.length; i2++) {
+              movingTraceMap.push({ newIndex: newIndices[i2], trace: gd2.data[currentIndices[i2]] });
+            }
+            movingTraceMap.sort(function(a2, b2) {
+              return a2.newIndex - b2.newIndex;
+            });
+            for (i2 = 0; i2 < movingTraceMap.length; i2 += 1) {
+              newData.splice(movingTraceMap[i2].newIndex, 0, movingTraceMap[i2].trace);
+            }
+            gd2.data = newData;
+            var promise = exports.redraw(gd2);
+            Queue.add(gd2, undoFunc, undoArgs, redoFunc, redoArgs);
+            return promise;
+          }
+          function restyle(gd2, astr, val, _traces) {
+            gd2 = Lib.getGraphDiv(gd2);
+            helpers.clearPromiseQueue(gd2);
+            var aobj = {};
+            if (typeof astr === "string") aobj[astr] = val;
+            else if (Lib.isPlainObject(astr)) {
+              aobj = Lib.extendFlat({}, astr);
+              if (_traces === void 0) _traces = val;
+            } else {
+              Lib.warn("Restyle fail.", astr, val, _traces);
+              return Promise.reject();
+            }
+            if (Object.keys(aobj).length) gd2.changed = true;
+            var traces = helpers.coerceTraceIndices(gd2, _traces);
+            var specs = _restyle(gd2, aobj, traces);
+            var flags = specs.flags;
+            if (flags.calc) gd2.calcdata = void 0;
+            if (flags.clearAxisTypes) helpers.clearAxisTypes(gd2, traces, {});
+            var seq = [];
+            if (flags.fullReplot) {
+              seq.push(exports._doPlot);
+            } else {
+              seq.push(Plots.previousPromises);
+              Plots.supplyDefaults(gd2);
+              if (flags.markerSize) {
+                Plots.doCalcdata(gd2);
+                addAxRangeSequence(seq);
+              }
+              if (flags.style) seq.push(subroutines.doTraceStyle);
+              if (flags.colorbars) seq.push(subroutines.doColorBars);
+              seq.push(emitAfterPlot);
+            }
+            seq.push(Plots.rehover, Plots.redrag, Plots.reselect);
+            Queue.add(gd2, restyle, [gd2, specs.undoit, specs.traces], restyle, [gd2, specs.redoit, specs.traces]);
+            var plotDone = Lib.syncOrAsync(seq, gd2);
+            if (!plotDone || !plotDone.then) plotDone = Promise.resolve();
+            return plotDone.then(function() {
+              gd2.emit("plotly_restyle", specs.eventData);
+              return gd2;
+            });
+          }
+          function undefinedToNull(val) {
+            if (val === void 0) return null;
+            return val;
+          }
+          function makeNP(preGUI, guiEditFlag) {
+            if (!guiEditFlag) return nestedProperty;
+            return function(container, attr, prefix) {
+              var np = nestedProperty(container, attr);
+              var npSet = np.set;
+              np.set = function(val) {
+                var fullAttr = (prefix || "") + attr;
+                storeCurrent(fullAttr, np.get(), val, preGUI);
+                npSet(val);
+              };
+              return np;
+            };
+          }
+          function storeCurrent(attr, val, newVal, preGUI) {
+            if (Array.isArray(val) || Array.isArray(newVal)) {
+              var arrayVal = Array.isArray(val) ? val : [];
+              var arrayNew = Array.isArray(newVal) ? newVal : [];
+              var maxLen = Math.max(arrayVal.length, arrayNew.length);
+              for (var i2 = 0; i2 < maxLen; i2++) {
+                storeCurrent(attr + "[" + i2 + "]", arrayVal[i2], arrayNew[i2], preGUI);
+              }
+            } else if (Lib.isPlainObject(val) || Lib.isPlainObject(newVal)) {
+              var objVal = Lib.isPlainObject(val) ? val : {};
+              var objNew = Lib.isPlainObject(newVal) ? newVal : {};
+              var objBoth = Lib.extendFlat({}, objVal, objNew);
+              for (var key in objBoth) {
+                storeCurrent(attr + "." + key, objVal[key], objNew[key], preGUI);
+              }
+            } else if (preGUI[attr] === void 0) {
+              preGUI[attr] = undefinedToNull(val);
+            }
+          }
+          function _storeDirectGUIEdit(container, preGUI, edits) {
+            for (var attr in edits) {
+              var np = nestedProperty(container, attr);
+              storeCurrent(attr, np.get(), edits[attr], preGUI);
+            }
+          }
+          function _restyle(gd2, aobj, traces) {
+            var fullLayout = gd2._fullLayout;
+            var fullData = gd2._fullData;
+            var data = gd2.data;
+            var guiEditFlag = fullLayout._guiEditing;
+            var layoutNP = makeNP(fullLayout._preGUI, guiEditFlag);
+            var eventData = Lib.extendDeepAll({}, aobj);
+            var i2;
+            var flags = editTypes.traceFlags();
+            var redoit = {};
+            var undoit = {};
+            var axlist;
+            function a0() {
+              return traces.map(function() {
+                return void 0;
+              });
+            }
+            function addToAxlist(axid) {
+              var axName = Axes.id2name(axid);
+              if (axlist.indexOf(axName) === -1) axlist.push(axName);
+            }
+            function autorangeAttr(axName) {
+              return "LAYOUT" + axName + ".autorange";
+            }
+            function rangeAttr(axName) {
+              return "LAYOUT" + axName + ".range";
+            }
+            function getFullTrace(traceIndex) {
+              for (var j2 = traceIndex; j2 < fullData.length; j2++) {
+                if (fullData[j2]._input === data[traceIndex]) return fullData[j2];
+              }
+            }
+            function doextra(attr, val, i22) {
+              if (Array.isArray(attr)) {
+                attr.forEach(function(a2) {
+                  doextra(a2, val, i22);
+                });
+                return;
+              }
+              if (attr in aobj || helpers.hasParent(aobj, attr)) return;
+              var extraparam;
+              if (attr.slice(0, 6) === "LAYOUT") {
+                extraparam = layoutNP(gd2.layout, attr.replace("LAYOUT", ""));
+              } else {
+                var tracei = traces[i22];
+                var preGUI2 = fullLayout._tracePreGUI[getFullTrace(tracei)._fullInput.uid];
+                extraparam = makeNP(preGUI2, guiEditFlag)(data[tracei], attr);
+              }
+              if (!(attr in undoit)) {
+                undoit[attr] = a0();
+              }
+              if (undoit[attr][i22] === void 0) {
+                undoit[attr][i22] = undefinedToNull(extraparam.get());
+              }
+              if (val !== void 0) {
+                extraparam.set(val);
+              }
+            }
+            function allBins(binAttr) {
+              return function(j2) {
+                return fullData[j2][binAttr];
+              };
+            }
+            function arrayBins(binAttr) {
+              return function(vij, j2) {
+                return vij === false ? fullData[traces[j2]][binAttr] : null;
+              };
+            }
+            for (var ai2 in aobj) {
+              if (helpers.hasParent(aobj, ai2)) {
+                throw new Error("cannot set " + ai2 + " and a parent attribute simultaneously");
+              }
+              var vi2 = aobj[ai2];
+              var cont;
+              var contFull;
+              var param;
+              var oldVal;
+              var newVal;
+              var valObject;
+              if (ai2 === "autobinx" || ai2 === "autobiny") {
+                ai2 = ai2.charAt(ai2.length - 1) + "bins";
+                if (Array.isArray(vi2)) vi2 = vi2.map(arrayBins(ai2));
+                else if (vi2 === false) vi2 = traces.map(allBins(ai2));
+                else vi2 = null;
+              }
+              redoit[ai2] = vi2;
+              if (ai2.slice(0, 6) === "LAYOUT") {
+                param = layoutNP(gd2.layout, ai2.replace("LAYOUT", ""));
+                undoit[ai2] = [undefinedToNull(param.get())];
+                param.set(Array.isArray(vi2) ? vi2[0] : vi2);
+                flags.calc = true;
+                continue;
+              }
+              undoit[ai2] = a0();
+              for (i2 = 0; i2 < traces.length; i2++) {
+                cont = data[traces[i2]];
+                contFull = getFullTrace(traces[i2]);
+                var preGUI = fullLayout._tracePreGUI[contFull._fullInput.uid];
+                param = makeNP(preGUI, guiEditFlag)(cont, ai2);
+                oldVal = param.get();
+                newVal = Array.isArray(vi2) ? vi2[i2 % vi2.length] : vi2;
+                if (newVal === void 0) continue;
+                var finalPart = param.parts[param.parts.length - 1];
+                var prefix = ai2.slice(0, ai2.length - finalPart.length - 1);
+                var prefixDot = prefix ? prefix + "." : "";
+                var innerContFull = prefix ? nestedProperty(contFull, prefix).get() : contFull;
+                valObject = PlotSchema.getTraceValObject(contFull, param.parts);
+                if (valObject && valObject.impliedEdits && newVal !== null) {
+                  for (var impliedKey in valObject.impliedEdits) {
+                    doextra(Lib.relativeAttr(ai2, impliedKey), valObject.impliedEdits[impliedKey], i2);
+                  }
+                } else if ((finalPart === "thicknessmode" || finalPart === "lenmode") && oldVal !== newVal && (newVal === "fraction" || newVal === "pixels") && innerContFull) {
+                  var gs = fullLayout._size;
+                  var orient = innerContFull.orient;
+                  var topOrBottom = orient === "top" || orient === "bottom";
+                  if (finalPart === "thicknessmode") {
+                    var thicknorm = topOrBottom ? gs.h : gs.w;
+                    doextra(
+                      prefixDot + "thickness",
+                      innerContFull.thickness * (newVal === "fraction" ? 1 / thicknorm : thicknorm),
+                      i2
+                    );
+                  } else {
+                    var lennorm = topOrBottom ? gs.w : gs.h;
+                    doextra(prefixDot + "len", innerContFull.len * (newVal === "fraction" ? 1 / lennorm : lennorm), i2);
+                  }
+                } else if (ai2 === "type" && (newVal === "pie" !== (oldVal === "pie") || newVal === "funnelarea" !== (oldVal === "funnelarea"))) {
+                  var labelsTo = "x";
+                  var valuesTo = "y";
+                  if ((newVal === "bar" || oldVal === "bar") && cont.orientation === "h") {
+                    labelsTo = "y";
+                    valuesTo = "x";
+                  }
+                  Lib.swapAttrs(cont, ["?", "?src"], "labels", labelsTo);
+                  Lib.swapAttrs(cont, ["d?", "?0"], "label", labelsTo);
+                  Lib.swapAttrs(cont, ["?", "?src"], "values", valuesTo);
+                  if (oldVal === "pie" || oldVal === "funnelarea") {
+                    nestedProperty(cont, "marker.color").set(nestedProperty(cont, "marker.colors").get());
+                    fullLayout._pielayer.selectAll("g.trace").remove();
+                  } else if (Registry.traceIs(cont, "cartesian")) {
+                    nestedProperty(cont, "marker.colors").set(nestedProperty(cont, "marker.color").get());
+                  }
+                }
+                undoit[ai2][i2] = undefinedToNull(oldVal);
+                var swapAttrs = ["swapxy", "swapxyaxes", "orientation", "orientationaxes"];
+                if (swapAttrs.indexOf(ai2) !== -1) {
+                  if (ai2 === "orientation") {
+                    param.set(newVal);
+                    var defaultOrientation = cont.x && !cont.y ? "h" : "v";
+                    if ((param.get() || defaultOrientation) === contFull.orientation) {
+                      continue;
+                    }
+                  } else if (ai2 === "orientationaxes") {
+                    cont.orientation = { v: "h", h: "v" }[contFull.orientation];
+                  }
+                  helpers.swapXYData(cont);
+                  flags.calc = flags.clearAxisTypes = true;
+                } else if (Plots.dataArrayContainers.indexOf(param.parts[0]) !== -1) {
+                  helpers.manageArrayContainers(param, newVal, undoit);
+                  flags.calc = true;
+                } else {
+                  if (valObject) {
+                    if (valObject.arrayOk && !Registry.traceIs(contFull, "regl") && (Lib.isArrayOrTypedArray(newVal) || Lib.isArrayOrTypedArray(oldVal))) {
+                      flags.calc = true;
+                    } else editTypes.update(flags, valObject);
+                  } else {
+                    flags.calc = true;
+                  }
+                  param.set(newVal);
+                }
+              }
+              if (["swapxyaxes", "orientationaxes"].indexOf(ai2) !== -1) {
+                Axes.swap(gd2, traces);
+              }
+              if (ai2 === "orientationaxes") {
+                var hovermode = nestedProperty(gd2.layout, "hovermode");
+                var h2 = hovermode.get();
+                if (h2 === "x") {
+                  hovermode.set("y");
+                } else if (h2 === "y") {
+                  hovermode.set("x");
+                } else if (h2 === "x unified") {
+                  hovermode.set("y unified");
+                } else if (h2 === "y unified") {
+                  hovermode.set("x unified");
+                }
+              }
+              if (["orientation", "type"].indexOf(ai2) !== -1) {
+                axlist = [];
+                for (i2 = 0; i2 < traces.length; i2++) {
+                  var trace = data[traces[i2]];
+                  if (Registry.traceIs(trace, "cartesian")) {
+                    addToAxlist(trace.xaxis || "x");
+                    addToAxlist(trace.yaxis || "y");
+                  }
+                }
+                doextra(axlist.map(autorangeAttr), true, 0);
+                doextra(axlist.map(rangeAttr), [0, 1], 0);
+              }
+            }
+            if (flags.calc || flags.plot) {
+              flags.fullReplot = true;
+            }
+            return {
+              flags,
+              undoit,
+              redoit,
+              traces,
+              eventData: Lib.extendDeepNoArrays([], [eventData, traces])
+            };
+          }
+          function relayout(gd2, astr, val) {
+            gd2 = Lib.getGraphDiv(gd2);
+            helpers.clearPromiseQueue(gd2);
+            var aobj = {};
+            if (typeof astr === "string") {
+              aobj[astr] = val;
+            } else if (Lib.isPlainObject(astr)) {
+              aobj = Lib.extendFlat({}, astr);
+            } else {
+              Lib.warn("Relayout fail.", astr, val);
+              return Promise.reject();
+            }
+            if (Object.keys(aobj).length) gd2.changed = true;
+            var specs = _relayout(gd2, aobj);
+            var flags = specs.flags;
+            if (flags.calc) gd2.calcdata = void 0;
+            var seq = [Plots.previousPromises];
+            if (flags.layoutReplot) {
+              seq.push(subroutines.layoutReplot);
+            } else if (Object.keys(aobj).length) {
+              axRangeSupplyDefaultsByPass(gd2, flags, specs) || Plots.supplyDefaults(gd2);
+              if (flags.legend) seq.push(subroutines.doLegend);
+              if (flags.layoutstyle) seq.push(subroutines.layoutStyles);
+              if (flags.axrange) addAxRangeSequence(seq, specs.rangesAltered);
+              if (flags.ticks) seq.push(subroutines.doTicksRelayout);
+              if (flags.modebar) seq.push(subroutines.doModeBar);
+              if (flags.camera) seq.push(subroutines.doCamera);
+              if (flags.colorbars) seq.push(subroutines.doColorBars);
+              seq.push(emitAfterPlot);
+            }
+            seq.push(Plots.rehover, Plots.redrag, Plots.reselect);
+            Queue.add(gd2, relayout, [gd2, specs.undoit], relayout, [gd2, specs.redoit]);
+            var plotDone = Lib.syncOrAsync(seq, gd2);
+            if (!plotDone || !plotDone.then) plotDone = Promise.resolve(gd2);
+            return plotDone.then(function() {
+              gd2.emit("plotly_relayout", specs.eventData);
+              return gd2;
+            });
+          }
+          function axRangeSupplyDefaultsByPass(gd2, flags, specs) {
+            var fullLayout = gd2._fullLayout;
+            if (!flags.axrange) return false;
+            for (var k2 in flags) {
+              if (k2 !== "axrange" && flags[k2]) return false;
+            }
+            var axIn, axOut;
+            var coerce = function(attr, dflt) {
+              return Lib.coerce(axIn, axOut, cartesianLayoutAttributes, attr, dflt);
+            };
+            var options = {};
+            for (var axId in specs.rangesAltered) {
+              var axName = Axes.id2name(axId);
+              axIn = gd2.layout[axName];
+              axOut = fullLayout[axName];
+              handleRangeDefaults(axIn, axOut, coerce, options);
+              if (axOut._matchGroup) {
+                for (var axId2 in axOut._matchGroup) {
+                  if (axId2 !== axId) {
+                    var ax2 = fullLayout[Axes.id2name(axId2)];
+                    ax2.autorange = axOut.autorange;
+                    ax2.range = axOut.range.slice();
+                    ax2._input.range = axOut.range.slice();
+                  }
+                }
+              }
+            }
+            return true;
+          }
+          function addAxRangeSequence(seq, rangesAltered) {
+            var drawAxes = rangesAltered ? function(gd2) {
+              var axIds = [];
+              var skipTitle = true;
+              for (var id2 in rangesAltered) {
+                var ax = Axes.getFromId(gd2, id2);
+                axIds.push(id2);
+                if ((ax.ticklabelposition || "").indexOf("inside") !== -1) {
+                  if (ax._anchorAxis) {
+                    axIds.push(ax._anchorAxis._id);
+                  }
+                }
+                if (ax._matchGroup) {
+                  for (var id22 in ax._matchGroup) {
+                    if (!rangesAltered[id22]) {
+                      axIds.push(id22);
+                    }
+                  }
+                }
+              }
+              return Axes.draw(gd2, axIds, { skipTitle });
+            } : function(gd2) {
+              return Axes.draw(gd2, "redraw");
+            };
+            seq.push(
+              clearOutline,
+              subroutines.doAutoRangeAndConstraints,
+              drawAxes,
+              subroutines.drawData,
+              subroutines.finalDraw
+            );
+          }
+          var AX_RANGE_RE = /^[xyz]axis[0-9]*\.range(\[[0|1]\])?$/;
+          var AX_AUTORANGE_RE = /^[xyz]axis[0-9]*\.autorange$/;
+          var AX_DOMAIN_RE = /^[xyz]axis[0-9]*\.domain(\[[0|1]\])?$/;
+          function _relayout(gd2, aobj) {
+            var layout = gd2.layout;
+            var fullLayout = gd2._fullLayout;
+            var guiEditFlag = fullLayout._guiEditing;
+            var layoutNP = makeNP(fullLayout._preGUI, guiEditFlag);
+            var keys = Object.keys(aobj);
+            var axes = Axes.list(gd2);
+            var eventData = Lib.extendDeepAll({}, aobj);
+            var arrayEdits = {};
+            var arrayStr, i2, j2;
+            keys = Object.keys(aobj);
+            for (i2 = 0; i2 < keys.length; i2++) {
+              if (keys[i2].indexOf("allaxes") === 0) {
+                for (j2 = 0; j2 < axes.length; j2++) {
+                  var scene = axes[j2]._id.slice(1);
+                  var axisAttr = scene.indexOf("scene") !== -1 ? scene + "." : "";
+                  var newkey = keys[i2].replace("allaxes", axisAttr + axes[j2]._name);
+                  if (!aobj[newkey]) aobj[newkey] = aobj[keys[i2]];
+                }
+                delete aobj[keys[i2]];
+              }
+            }
+            var flags = editTypes.layoutFlags();
+            var redoit = {};
+            var undoit = {};
+            function doextra(attr, val) {
+              if (Array.isArray(attr)) {
+                attr.forEach(function(a2) {
+                  doextra(a2, val);
+                });
+                return;
+              }
+              if (attr in aobj || helpers.hasParent(aobj, attr)) return;
+              var p22 = layoutNP(layout, attr);
+              if (!(attr in undoit)) {
+                undoit[attr] = undefinedToNull(p22.get());
+              }
+              if (val !== void 0) p22.set(val);
+            }
+            var rangesAltered = {};
+            var ax;
+            function recordAlteredAxis(pleafPlus2) {
+              var axId2 = Axes.name2id(pleafPlus2.split(".")[0]);
+              rangesAltered[axId2] = 1;
+              return axId2;
+            }
+            for (var ai2 in aobj) {
+              if (helpers.hasParent(aobj, ai2)) {
+                throw new Error("cannot set " + ai2 + " and a parent attribute simultaneously");
+              }
+              var p2 = layoutNP(layout, ai2);
+              var vi2 = aobj[ai2];
+              var plen = p2.parts.length;
+              var pend = plen - 1;
+              while (pend > 0 && typeof p2.parts[pend] !== "string") pend--;
+              var pleaf = p2.parts[pend];
+              var pleafPlus = p2.parts[pend - 1] + "." + pleaf;
+              var ptrunk = p2.parts.slice(0, pend).join(".");
+              var parentIn = nestedProperty(gd2.layout, ptrunk).get();
+              var parentFull = nestedProperty(fullLayout, ptrunk).get();
+              var vOld = p2.get();
+              if (vi2 === void 0) continue;
+              redoit[ai2] = vi2;
+              undoit[ai2] = pleaf === "reverse" ? vi2 : undefinedToNull(vOld);
+              var valObject = PlotSchema.getLayoutValObject(fullLayout, p2.parts);
+              if (valObject && valObject.impliedEdits && vi2 !== null) {
+                for (var impliedKey in valObject.impliedEdits) {
+                  doextra(Lib.relativeAttr(ai2, impliedKey), valObject.impliedEdits[impliedKey]);
+                }
+              }
+              if (["width", "height"].indexOf(ai2) !== -1) {
+                if (vi2) {
+                  doextra("autosize", null);
+                  var oppositeAttr = ai2 === "height" ? "width" : "height";
+                  doextra(oppositeAttr, fullLayout[oppositeAttr]);
+                } else {
+                  fullLayout[ai2] = gd2._initialAutoSize[ai2];
+                }
+              } else if (ai2 === "autosize") {
+                doextra("width", vi2 ? null : fullLayout.width);
+                doextra("height", vi2 ? null : fullLayout.height);
+              } else if (pleafPlus.match(AX_RANGE_RE)) {
+                recordAlteredAxis(pleafPlus);
+                nestedProperty(fullLayout, ptrunk + "._inputRange").set(null);
+              } else if (pleafPlus.match(AX_AUTORANGE_RE)) {
+                recordAlteredAxis(pleafPlus);
+                nestedProperty(fullLayout, ptrunk + "._inputRange").set(null);
+                var axFull = nestedProperty(fullLayout, ptrunk).get();
+                if (axFull._inputDomain) {
+                  axFull._input.domain = axFull._inputDomain.slice();
+                }
+              } else if (pleafPlus.match(AX_DOMAIN_RE)) {
+                nestedProperty(fullLayout, ptrunk + "._inputDomain").set(null);
+              }
+              if (pleaf === "type") {
+                ax = parentIn;
+                var toLog = parentFull.type === "linear" && vi2 === "log";
+                var fromLog = parentFull.type === "log" && vi2 === "linear";
+                if (toLog || fromLog) {
+                  if (!ax || !ax.range) {
+                    doextra(ptrunk + ".autorange", true);
+                  } else if (!parentFull.autorange) {
+                    var r0 = ax.range[0];
+                    var r1 = ax.range[1];
+                    if (toLog) {
+                      if (r0 <= 0 && r1 <= 0) {
+                        doextra(ptrunk + ".autorange", true);
+                      }
+                      if (r0 <= 0) r0 = r1 / 1e6;
+                      else if (r1 <= 0) r1 = r0 / 1e6;
+                      doextra(ptrunk + ".range[0]", Math.log(r0) / Math.LN10);
+                      doextra(ptrunk + ".range[1]", Math.log(r1) / Math.LN10);
+                    } else {
+                      doextra(ptrunk + ".range[0]", Math.pow(10, r0));
+                      doextra(ptrunk + ".range[1]", Math.pow(10, r1));
+                    }
+                  } else if (toLog) {
+                    ax.range = ax.range[1] > ax.range[0] ? [1, 2] : [2, 1];
+                  }
+                  if (Array.isArray(fullLayout._subplots.polar) && fullLayout._subplots.polar.length && fullLayout[p2.parts[0]] && p2.parts[1] === "radialaxis") {
+                    delete fullLayout[p2.parts[0]]._subplot.viewInitial["radialaxis.range"];
+                  }
+                  Registry.getComponentMethod("annotations", "convertCoords")(gd2, parentFull, vi2, doextra);
+                  Registry.getComponentMethod("images", "convertCoords")(gd2, parentFull, vi2, doextra);
+                } else {
+                  doextra(ptrunk + ".autorange", true);
+                  doextra(ptrunk + ".range", null);
+                }
+                nestedProperty(fullLayout, ptrunk + "._inputRange").set(null);
+              } else if (pleaf.match(AX_NAME_PATTERN)) {
+                var fullProp = nestedProperty(fullLayout, ai2).get();
+                var newType = (vi2 || {}).type;
+                if (!newType || newType === "-") newType = "linear";
+                Registry.getComponentMethod("annotations", "convertCoords")(gd2, fullProp, newType, doextra);
+                Registry.getComponentMethod("images", "convertCoords")(gd2, fullProp, newType, doextra);
+              }
+              var containerArrayMatch = manageArrays.containerArrayMatch(ai2);
+              if (containerArrayMatch) {
+                arrayStr = containerArrayMatch.array;
+                i2 = containerArrayMatch.index;
+                var propStr = containerArrayMatch.property;
+                var updateValObject = valObject || { editType: "calc" };
+                if (i2 !== "" && propStr === "") {
+                  if (manageArrays.isAddVal(vi2)) {
+                    undoit[ai2] = null;
+                  } else if (manageArrays.isRemoveVal(vi2)) {
+                    undoit[ai2] = (nestedProperty(layout, arrayStr).get() || [])[i2];
+                  } else {
+                    Lib.warn("unrecognized full object value", aobj);
+                  }
+                }
+                editTypes.update(flags, updateValObject);
+                if (!arrayEdits[arrayStr]) arrayEdits[arrayStr] = {};
+                var objEdits = arrayEdits[arrayStr][i2];
+                if (!objEdits) objEdits = arrayEdits[arrayStr][i2] = {};
+                objEdits[propStr] = vi2;
+                delete aobj[ai2];
+              } else if (pleaf === "reverse") {
+                if (parentIn.range) parentIn.range.reverse();
+                else {
+                  doextra(ptrunk + ".autorange", true);
+                  parentIn.range = [1, 0];
+                }
+                if (parentFull.autorange) flags.calc = true;
+                else flags.plot = true;
+              } else {
+                if (ai2 === "dragmode" && (vi2 === false && vOld !== false || vi2 !== false && vOld === false)) {
+                  flags.plot = true;
+                } else if (fullLayout._has("scatter-like") && fullLayout._has("regl") && ai2 === "dragmode" && (vi2 === "lasso" || vi2 === "select") && !(vOld === "lasso" || vOld === "select")) {
+                  flags.plot = true;
+                } else if (valObject) editTypes.update(flags, valObject);
+                else flags.calc = true;
+                p2.set(vi2);
+              }
+            }
+            for (arrayStr in arrayEdits) {
+              var finished = manageArrays.applyContainerArrayChanges(
+                gd2,
+                layoutNP(layout, arrayStr),
+                arrayEdits[arrayStr],
+                flags,
+                layoutNP
+              );
+              if (!finished) flags.plot = true;
+            }
+            for (var axId in rangesAltered) {
+              ax = Axes.getFromId(gd2, axId);
+              var group = ax && ax._constraintGroup;
+              if (group) {
+                flags.calc = true;
+                for (var groupAxId in group) {
+                  if (!rangesAltered[groupAxId]) {
+                    Axes.getFromId(gd2, groupAxId)._constraintShrinkable = true;
+                  }
+                }
+              }
+            }
+            if (updateAutosize(gd2) || aobj.height || aobj.width) flags.plot = true;
+            var shapes = fullLayout.shapes;
+            for (i2 = 0; i2 < shapes.length; i2++) {
+              if (shapes[i2].showlegend) {
+                flags.calc = true;
+                break;
+              }
+            }
+            if (flags.plot || flags.calc) {
+              flags.layoutReplot = true;
+            }
+            return {
+              flags,
+              rangesAltered,
+              undoit,
+              redoit,
+              eventData
+            };
+          }
+          function updateAutosize(gd2) {
+            var fullLayout = gd2._fullLayout;
+            var oldWidth = fullLayout.width;
+            var oldHeight = fullLayout.height;
+            if (gd2.layout.autosize) Plots.plotAutoSize(gd2, gd2.layout, fullLayout);
+            return fullLayout.width !== oldWidth || fullLayout.height !== oldHeight;
+          }
+          function update(gd2, traceUpdate, layoutUpdate, _traces) {
+            gd2 = Lib.getGraphDiv(gd2);
+            helpers.clearPromiseQueue(gd2);
+            if (!Lib.isPlainObject(traceUpdate)) traceUpdate = {};
+            if (!Lib.isPlainObject(layoutUpdate)) layoutUpdate = {};
+            if (Object.keys(traceUpdate).length) gd2.changed = true;
+            if (Object.keys(layoutUpdate).length) gd2.changed = true;
+            var traces = helpers.coerceTraceIndices(gd2, _traces);
+            var restyleSpecs = _restyle(gd2, Lib.extendFlat({}, traceUpdate), traces);
+            var restyleFlags = restyleSpecs.flags;
+            var relayoutSpecs = _relayout(gd2, Lib.extendFlat({}, layoutUpdate));
+            var relayoutFlags = relayoutSpecs.flags;
+            if (restyleFlags.calc || relayoutFlags.calc) gd2.calcdata = void 0;
+            if (restyleFlags.clearAxisTypes) helpers.clearAxisTypes(gd2, traces, layoutUpdate);
+            var seq = [];
+            if (relayoutFlags.layoutReplot) {
+              seq.push(subroutines.layoutReplot);
+            } else if (restyleFlags.fullReplot) {
+              seq.push(exports._doPlot);
+            } else {
+              seq.push(Plots.previousPromises);
+              axRangeSupplyDefaultsByPass(gd2, relayoutFlags, relayoutSpecs) || Plots.supplyDefaults(gd2);
+              if (restyleFlags.style) seq.push(subroutines.doTraceStyle);
+              if (restyleFlags.colorbars || relayoutFlags.colorbars) seq.push(subroutines.doColorBars);
+              if (relayoutFlags.legend) seq.push(subroutines.doLegend);
+              if (relayoutFlags.layoutstyle) seq.push(subroutines.layoutStyles);
+              if (relayoutFlags.axrange) addAxRangeSequence(seq, relayoutSpecs.rangesAltered);
+              if (relayoutFlags.ticks) seq.push(subroutines.doTicksRelayout);
+              if (relayoutFlags.modebar) seq.push(subroutines.doModeBar);
+              if (relayoutFlags.camera) seq.push(subroutines.doCamera);
+              seq.push(emitAfterPlot);
+            }
+            seq.push(Plots.rehover, Plots.redrag, Plots.reselect);
+            Queue.add(gd2, update, [gd2, restyleSpecs.undoit, relayoutSpecs.undoit, restyleSpecs.traces], update, [
+              gd2,
+              restyleSpecs.redoit,
+              relayoutSpecs.redoit,
+              restyleSpecs.traces
+            ]);
+            var plotDone = Lib.syncOrAsync(seq, gd2);
+            if (!plotDone || !plotDone.then) plotDone = Promise.resolve(gd2);
+            return plotDone.then(function() {
+              gd2.emit("plotly_update", {
+                data: restyleSpecs.eventData,
+                layout: relayoutSpecs.eventData
+              });
+              return gd2;
+            });
+          }
+          function guiEdit(func) {
+            return function wrappedEdit(gd2) {
+              gd2._fullLayout._guiEditing = true;
+              var p2 = func.apply(null, arguments);
+              gd2._fullLayout._guiEditing = false;
+              return p2;
+            };
+          }
+          var layoutUIControlPatterns = [
+            { pattern: /^hiddenlabels/, attr: "legend.uirevision" },
+            { pattern: /^((x|y)axis\d*)\.((auto)?range|title\.text)/ },
+            // showspikes and modes include those nested inside scenes
+            { pattern: /axis\d*\.showspikes$/, attr: "modebar.uirevision" },
+            { pattern: /(hover|drag)mode$/, attr: "modebar.uirevision" },
+            { pattern: /^(scene\d*)\.camera/ },
+            { pattern: /^(geo\d*)\.(projection|center|fitbounds)/ },
+            { pattern: /^(ternary\d*\.[abc]axis)\.(min|title\.text)$/ },
+            { pattern: /^(polar\d*\.radialaxis)\.((auto)?range|angle|title\.text)/ },
+            { pattern: /^(polar\d*\.angularaxis)\.rotation/ },
+            { pattern: /^(mapbox\d*)\.(center|zoom|bearing|pitch)/ },
+            { pattern: /^(map\d*)\.(center|zoom|bearing|pitch)/ },
+            { pattern: /^legend\.(x|y)$/, attr: "editrevision" },
+            { pattern: /^(shapes|annotations)/, attr: "editrevision" },
+            { pattern: /^title\.text$/, attr: "editrevision" }
+          ];
+          var traceUIControlPatterns = [
+            { pattern: /^selectedpoints$/, attr: "selectionrevision" },
+            // "visible" includes trace.transforms[i].styles[j].value.visible
+            { pattern: /(^|value\.)visible$/, attr: "legend.uirevision" },
+            { pattern: /^dimensions\[\d+\]\.constraintrange/ },
+            { pattern: /^node\.(x|y|groups)/ },
+            // for Sankey nodes
+            { pattern: /^level$/ },
+            // for Sunburst, Treemap and Icicle traces
+            // below this you must be in editable: true mode
+            // TODO: I still put name and title with `trace.uirevision`
+            // reasonable or should these be `editrevision`?
+            // Also applies to axis titles up in the layout section
+            // "name" also includes transform.styles
+            { pattern: /(^|value\.)name$/ },
+            // including nested colorbar attributes (ie marker.colorbar)
+            { pattern: /colorbar\.title\.text$/ },
+            { pattern: /colorbar\.(x|y)$/, attr: "editrevision" }
+          ];
+          function findUIPattern(key, patternSpecs) {
+            for (var i2 = 0; i2 < patternSpecs.length; i2++) {
+              var spec = patternSpecs[i2];
+              var match = key.match(spec.pattern);
+              if (match) {
+                var head = match[1] || "";
+                return { head, tail: key.slice(head.length + 1), attr: spec.attr };
+              }
+            }
+          }
+          function getNewRev(revAttr, container) {
+            var newRev = nestedProperty(container, revAttr).get();
+            if (newRev !== void 0) return newRev;
+            var parts = revAttr.split(".");
+            parts.pop();
+            while (parts.length > 1) {
+              parts.pop();
+              newRev = nestedProperty(container, parts.join(".") + ".uirevision").get();
+              if (newRev !== void 0) return newRev;
+            }
+            return container.uirevision;
+          }
+          function getFullTraceIndexFromUid(uid2, fullData) {
+            for (var i2 = 0; i2 < fullData.length; i2++) {
+              if (fullData[i2]._fullInput.uid === uid2) return i2;
+            }
+            return -1;
+          }
+          function getTraceIndexFromUid(uid2, data, tracei) {
+            for (var i2 = 0; i2 < data.length; i2++) {
+              if (data[i2].uid === uid2) return i2;
+            }
+            return !data[tracei] || data[tracei].uid ? -1 : tracei;
+          }
+          function valsMatch(v1, v2) {
+            var v1IsObj = Lib.isPlainObject(v1);
+            var v1IsArray = Array.isArray(v1);
+            if (v1IsObj || v1IsArray) {
+              return (v1IsObj && Lib.isPlainObject(v2) || v1IsArray && Array.isArray(v2)) && JSON.stringify(v1) === JSON.stringify(v2);
+            }
+            return v1 === v2;
+          }
+          function applyUIRevisions(data, layout, oldFullData, oldFullLayout) {
+            var layoutPreGUI = oldFullLayout._preGUI;
+            var key, revAttr, oldRev, newRev, match, preGUIVal, newNP, newVal, head, tail;
+            var bothInheritAutorange = [];
+            var newAutorangeIn = {};
+            var newRangeAccepted = {};
+            for (key in layoutPreGUI) {
+              match = findUIPattern(key, layoutUIControlPatterns);
+              if (match) {
+                head = match.head;
+                tail = match.tail;
+                revAttr = match.attr || head + ".uirevision";
+                oldRev = nestedProperty(oldFullLayout, revAttr).get();
+                newRev = oldRev && getNewRev(revAttr, layout);
+                if (newRev && newRev === oldRev) {
+                  preGUIVal = layoutPreGUI[key];
+                  if (preGUIVal === null) preGUIVal = void 0;
+                  newNP = nestedProperty(layout, key);
+                  newVal = newNP.get();
+                  if (valsMatch(newVal, preGUIVal)) {
+                    if (newVal === void 0 && tail === "autorange") {
+                      bothInheritAutorange.push(head);
+                    }
+                    newNP.set(undefinedToNull(nestedProperty(oldFullLayout, key).get()));
+                    continue;
+                  } else if (tail === "autorange" || tail.slice(0, 6) === "range[") {
+                    var pre0 = layoutPreGUI[head + ".range[0]"];
+                    var pre1 = layoutPreGUI[head + ".range[1]"];
+                    var preAuto = layoutPreGUI[head + ".autorange"];
+                    if (preAuto || preAuto === null && pre0 === null && pre1 === null) {
+                      if (!(head in newAutorangeIn)) {
+                        var newContainer = nestedProperty(layout, head).get();
+                        newAutorangeIn[head] = newContainer && (newContainer.autorange || newContainer.autorange !== false && (!newContainer.range || newContainer.range.length !== 2));
+                      }
+                      if (newAutorangeIn[head]) {
+                        newNP.set(undefinedToNull(nestedProperty(oldFullLayout, key).get()));
+                        continue;
+                      }
+                    }
+                  }
+                }
+              } else {
+                Lib.warn("unrecognized GUI edit: " + key);
+              }
+              delete layoutPreGUI[key];
+              if (match && match.tail.slice(0, 6) === "range[") {
+                newRangeAccepted[match.head] = 1;
+              }
+            }
+            for (var i2 = 0; i2 < bothInheritAutorange.length; i2++) {
+              var axAttr = bothInheritAutorange[i2];
+              if (newRangeAccepted[axAttr]) {
+                var newAx = nestedProperty(layout, axAttr).get();
+                if (newAx) delete newAx.autorange;
+              }
+            }
+            var allTracePreGUI = oldFullLayout._tracePreGUI;
+            for (var uid2 in allTracePreGUI) {
+              var tracePreGUI = allTracePreGUI[uid2];
+              var newTrace = null;
+              var fullInput;
+              for (key in tracePreGUI) {
+                if (!newTrace) {
+                  var fulli = getFullTraceIndexFromUid(uid2, oldFullData);
+                  if (fulli < 0) {
+                    delete allTracePreGUI[uid2];
+                    break;
+                  }
+                  var fullTrace = oldFullData[fulli];
+                  fullInput = fullTrace._fullInput;
+                  var newTracei = getTraceIndexFromUid(uid2, data, fullInput.index);
+                  if (newTracei < 0) {
+                    delete allTracePreGUI[uid2];
+                    break;
+                  }
+                  newTrace = data[newTracei];
+                }
+                match = findUIPattern(key, traceUIControlPatterns);
+                if (match) {
+                  if (match.attr) {
+                    oldRev = nestedProperty(oldFullLayout, match.attr).get();
+                    newRev = oldRev && getNewRev(match.attr, layout);
+                  } else {
+                    oldRev = fullInput.uirevision;
+                    newRev = newTrace.uirevision;
+                    if (newRev === void 0) newRev = layout.uirevision;
+                  }
+                  if (newRev && newRev === oldRev) {
+                    preGUIVal = tracePreGUI[key];
+                    if (preGUIVal === null) preGUIVal = void 0;
+                    newNP = nestedProperty(newTrace, key);
+                    newVal = newNP.get();
+                    if (valsMatch(newVal, preGUIVal)) {
+                      newNP.set(undefinedToNull(nestedProperty(fullInput, key).get()));
+                      continue;
+                    }
+                  }
+                } else {
+                  Lib.warn("unrecognized GUI edit: " + key + " in trace uid " + uid2);
+                }
+                delete tracePreGUI[key];
+              }
+            }
+          }
+          function react2(gd2, data, layout, config2) {
+            var frames, plotDone;
+            function addFrames2() {
+              return exports.addFrames(gd2, frames);
+            }
+            gd2 = Lib.getGraphDiv(gd2);
+            helpers.clearPromiseQueue(gd2);
+            var oldFullData = gd2._fullData;
+            var oldFullLayout = gd2._fullLayout;
+            if (!Lib.isPlotDiv(gd2) || !oldFullData || !oldFullLayout) {
+              plotDone = exports.newPlot(gd2, data, layout, config2);
+            } else {
+              if (Lib.isPlainObject(data)) {
+                var obj = data;
+                data = obj.data;
+                layout = obj.layout;
+                config2 = obj.config;
+                frames = obj.frames;
+              }
+              var configChanged = false;
+              if (config2) {
+                const oldConfig = Lib.extendDeepAll({}, gd2._context);
+                gd2._context = void 0;
+                setPlotContext(gd2, config2);
+                configChanged = !helpers.collectionsAreEqual(oldConfig, gd2._context);
+              }
+              if (configChanged) {
+                const eventListeners = gd2._ev.eventNames().map((name3) => [name3, gd2._ev.listeners(name3)]);
+                plotDone = exports.newPlot(gd2, data, layout, config2).then(() => {
+                  for (const [name3, callbacks] of eventListeners) {
+                    callbacks.forEach((cb2) => gd2.on(name3, cb2));
+                  }
+                  return exports.react(gd2, data, layout, config2);
+                });
+              } else {
+                gd2.data = data || [];
+                helpers.cleanData(gd2.data);
+                gd2.layout = layout || {};
+                helpers.cleanLayout(gd2.layout);
+                applyUIRevisions(gd2.data, gd2.layout, oldFullData, oldFullLayout);
+                Plots.supplyDefaults(gd2, { skipUpdateCalc: true });
+                var newFullData = gd2._fullData;
+                var newFullLayout = gd2._fullLayout;
+                var immutable = newFullLayout.datarevision === void 0;
+                var transition = newFullLayout.transition;
+                var relayoutFlags = diffLayout(gd2, oldFullLayout, newFullLayout, immutable, transition);
+                var newDataRevision = relayoutFlags.newDataRevision;
+                var restyleFlags = diffData(gd2, oldFullData, newFullData, immutable, transition, newDataRevision);
+                if (updateAutosize(gd2)) relayoutFlags.layoutReplot = true;
+                if (restyleFlags.calc || relayoutFlags.calc) {
+                  gd2.calcdata = void 0;
+                  var allNames = Object.getOwnPropertyNames(newFullLayout);
+                  for (var q2 = 0; q2 < allNames.length; q2++) {
+                    var name2 = allNames[q2];
+                    var start = name2.substring(0, 5);
+                    if (start === "xaxis" || start === "yaxis") {
+                      var emptyCategories = newFullLayout[name2]._emptyCategories;
+                      if (emptyCategories) emptyCategories();
+                    }
+                  }
+                } else {
+                  Plots.supplyDefaultsUpdateCalc(gd2.calcdata, newFullData);
+                }
+                var seq = [];
+                if (frames) {
+                  gd2._transitionData = {};
+                  Plots.createTransitionData(gd2);
+                  seq.push(addFrames2);
+                }
+                if (newFullLayout.transition && (restyleFlags.anim || relayoutFlags.anim)) {
+                  if (relayoutFlags.ticks) seq.push(subroutines.doTicksRelayout);
+                  Plots.doCalcdata(gd2);
+                  subroutines.doAutoRangeAndConstraints(gd2);
+                  seq.push(function() {
+                    return Plots.transitionFromReact(gd2, restyleFlags, relayoutFlags, oldFullLayout);
+                  });
+                } else if (restyleFlags.fullReplot || relayoutFlags.layoutReplot) {
+                  gd2._fullLayout._skipDefaults = true;
+                  seq.push(exports._doPlot);
+                } else {
+                  for (var componentType in relayoutFlags.arrays) {
+                    var indices = relayoutFlags.arrays[componentType];
+                    if (indices.length) {
+                      var drawOne = Registry.getComponentMethod(componentType, "drawOne");
+                      if (drawOne !== Lib.noop) {
+                        for (var i2 = 0; i2 < indices.length; i2++) {
+                          drawOne(gd2, indices[i2]);
+                        }
+                      } else {
+                        var draw = Registry.getComponentMethod(componentType, "draw");
+                        if (draw === Lib.noop) {
+                          throw new Error("cannot draw components: " + componentType);
+                        }
+                        draw(gd2);
+                      }
+                    }
+                  }
+                  seq.push(Plots.previousPromises);
+                  if (restyleFlags.style) seq.push(subroutines.doTraceStyle);
+                  if (restyleFlags.colorbars || relayoutFlags.colorbars) seq.push(subroutines.doColorBars);
+                  if (relayoutFlags.legend) seq.push(subroutines.doLegend);
+                  if (relayoutFlags.layoutstyle) seq.push(subroutines.layoutStyles);
+                  if (relayoutFlags.axrange) addAxRangeSequence(seq);
+                  if (relayoutFlags.ticks) seq.push(subroutines.doTicksRelayout);
+                  if (relayoutFlags.modebar) seq.push(subroutines.doModeBar);
+                  if (relayoutFlags.camera) seq.push(subroutines.doCamera);
+                  seq.push(emitAfterPlot);
+                }
+                seq.push(Plots.rehover, Plots.redrag, Plots.reselect);
+                plotDone = Lib.syncOrAsync(seq, gd2);
+                if (!plotDone || !plotDone.then) plotDone = Promise.resolve(gd2);
+              }
+            }
+            return plotDone.then(() => {
+              if (!configChanged) gd2.emit("plotly_react", { config: config2, data, layout });
+              return gd2;
+            });
+          }
+          function diffData(gd2, oldFullData, newFullData, immutable, transition, newDataRevision) {
+            var sameTraceLength = oldFullData.length === newFullData.length;
+            if (!transition && !sameTraceLength) {
+              return {
+                fullReplot: true,
+                calc: true
+              };
+            }
+            var flags = editTypes.traceFlags();
+            flags.arrays = {};
+            flags.nChanges = 0;
+            flags.nChangesAnim = 0;
+            var i2, trace;
+            function getTraceValObject(parts) {
+              var out = PlotSchema.getTraceValObject(trace, parts);
+              if (!trace._module.animatable && out.anim) {
+                out.anim = false;
+              }
+              return out;
+            }
+            var diffOpts = {
+              getValObject: getTraceValObject,
+              flags,
+              immutable,
+              transition,
+              newDataRevision,
+              gd: gd2
+            };
+            var seenUIDs = {};
+            for (i2 = 0; i2 < oldFullData.length; i2++) {
+              if (newFullData[i2]) {
+                trace = newFullData[i2]._fullInput;
+                if (seenUIDs[trace.uid]) continue;
+                seenUIDs[trace.uid] = 1;
+                getDiffFlags(oldFullData[i2]._fullInput, trace, [], diffOpts);
+              }
+            }
+            if (flags.calc || flags.plot) {
+              flags.fullReplot = true;
+            }
+            if (transition && flags.nChanges && flags.nChangesAnim) {
+              flags.anim = flags.nChanges === flags.nChangesAnim && sameTraceLength ? "all" : "some";
+            }
+            return flags;
+          }
+          function diffLayout(gd2, oldFullLayout, newFullLayout, immutable, transition) {
+            var flags = editTypes.layoutFlags();
+            flags.arrays = {};
+            flags.rangesAltered = {};
+            flags.nChanges = 0;
+            flags.nChangesAnim = 0;
+            function getLayoutValObject(parts) {
+              return PlotSchema.getLayoutValObject(newFullLayout, parts);
+            }
+            for (var key in newFullLayout) {
+              if (!key.startsWith("xaxis") && !key.startsWith("yaxis")) {
+                continue;
+              }
+              if (!oldFullLayout[key]) {
+                continue;
+              }
+              var newDomain = newFullLayout[key].domain;
+              var oldDomain = oldFullLayout[key].domain;
+              var oldInputDomain = oldFullLayout[key]._inputDomain;
+              if (oldFullLayout[key]._inputDomain) {
+                if (newDomain[0] === oldInputDomain[0] && newDomain[1] === oldInputDomain[1]) {
+                  newFullLayout[key].domain = oldFullLayout[key].domain;
+                } else if (newDomain[0] !== oldDomain[0] || newDomain[1] !== oldDomain[1]) {
+                  newFullLayout[key]._inputDomain = null;
+                }
+              }
+            }
+            var diffOpts = {
+              getValObject: getLayoutValObject,
+              flags,
+              immutable,
+              transition,
+              gd: gd2
+            };
+            getDiffFlags(oldFullLayout, newFullLayout, [], diffOpts);
+            if (flags.plot || flags.calc) {
+              flags.layoutReplot = true;
+            }
+            if (transition && flags.nChanges && flags.nChangesAnim) {
+              flags.anim = flags.nChanges === flags.nChangesAnim ? "all" : "some";
+            }
+            return flags;
+          }
+          function getDiffFlags(oldContainer, newContainer, outerparts, opts) {
+            var valObject, key, astr;
+            var getValObject = opts.getValObject;
+            var flags = opts.flags;
+            var immutable = opts.immutable;
+            var inArray = opts.inArray;
+            var arrayIndex = opts.arrayIndex;
+            function changed() {
+              var editType = valObject.editType;
+              if (inArray && editType.indexOf("arraydraw") !== -1) {
+                Lib.pushUnique(flags.arrays[inArray], arrayIndex);
+                return;
+              }
+              editTypes.update(flags, valObject);
+              if (editType !== "none") {
+                flags.nChanges++;
+              }
+              if (opts.transition && valObject.anim) {
+                flags.nChangesAnim++;
+              }
+              if (AX_RANGE_RE.test(astr) || AX_AUTORANGE_RE.test(astr)) {
+                flags.rangesAltered[outerparts[0]] = 1;
+              }
+              if (key === "datarevision") {
+                flags.newDataRevision = 1;
+              }
+            }
+            function valObjectCanBeDataArray(valObject2) {
+              return valObject2.valType === "data_array" || valObject2.arrayOk;
+            }
+            for (key in oldContainer) {
+              if (flags.calc && !opts.transition) return;
+              var oldVal = oldContainer[key];
+              var newVal = newContainer[key];
+              var parts = outerparts.concat(key);
+              astr = parts.join(".");
+              if (key.charAt(0) === "_" || typeof oldVal === "function" || oldVal === newVal) continue;
+              if ((key === "tick0" || key === "dtick") && outerparts[0] !== "geo") {
+                var tickMode = newContainer.tickmode;
+                if (tickMode === "auto" || tickMode === "array" || !tickMode) continue;
+              }
+              if (key === "range" && newContainer.autorange) continue;
+              if ((key === "zmin" || key === "zmax") && newContainer.type === "contourcarpet") continue;
+              valObject = getValObject(parts);
+              if (!valObject) continue;
+              if (valObject._compareAsJSON && JSON.stringify(oldVal) === JSON.stringify(newVal)) continue;
+              var valType = valObject.valType;
+              var i2;
+              var canBeDataArray = valObjectCanBeDataArray(valObject);
+              var wasArray = Array.isArray(oldVal);
+              var nowArray = Array.isArray(newVal);
+              if (wasArray && nowArray) {
+                var inputKey = "_input_" + key;
+                var oldValIn = oldContainer[inputKey];
+                var newValIn = newContainer[inputKey];
+                if (Array.isArray(oldValIn) && oldValIn === newValIn) continue;
+              }
+              if (newVal === void 0) {
+                if (canBeDataArray && wasArray) flags.calc = true;
+                else changed();
+              } else if (valObject._isLinkedToArray) {
+                var arrayEditIndices = [];
+                var extraIndices = false;
+                if (!inArray) flags.arrays[key] = arrayEditIndices;
+                var minLen = Math.min(oldVal.length, newVal.length);
+                var maxLen = Math.max(oldVal.length, newVal.length);
+                if (minLen !== maxLen) {
+                  if (valObject.editType === "arraydraw") {
+                    extraIndices = true;
+                  } else {
+                    changed();
+                    continue;
+                  }
+                }
+                for (i2 = 0; i2 < minLen; i2++) {
+                  getDiffFlags(
+                    oldVal[i2],
+                    newVal[i2],
+                    parts.concat(i2),
+                    // add array indices, but not if we're already in an array
+                    Lib.extendFlat({ inArray: key, arrayIndex: i2 }, opts)
+                  );
+                }
+                if (extraIndices) {
+                  for (i2 = minLen; i2 < maxLen; i2++) {
+                    arrayEditIndices.push(i2);
+                  }
+                }
+              } else if (!valType && Lib.isPlainObject(oldVal)) {
+                getDiffFlags(oldVal, newVal, parts, opts);
+              } else if (canBeDataArray) {
+                if (wasArray && nowArray) {
+                  if (immutable) {
+                    flags.calc = true;
+                  }
+                  if (immutable || opts.newDataRevision) {
+                    changed();
+                  }
+                } else if (wasArray !== nowArray) {
+                  flags.calc = true;
+                } else changed();
+              } else if (wasArray && nowArray) {
+                if (oldVal.length !== newVal.length || String(oldVal) !== String(newVal)) {
+                  changed();
+                }
+              } else {
+                changed();
+              }
+            }
+            for (key in newContainer) {
+              if (!(key in oldContainer || key.charAt(0) === "_" || typeof newContainer[key] === "function")) {
+                valObject = getValObject(outerparts.concat(key));
+                if (valObjectCanBeDataArray(valObject) && Array.isArray(newContainer[key])) {
+                  flags.calc = true;
+                  return;
+                } else changed();
+              }
+            }
+          }
+          function animate(gd2, frameOrGroupNameOrFrameList, animationOpts) {
+            gd2 = Lib.getGraphDiv(gd2);
+            if (!Lib.isPlotDiv(gd2)) {
+              throw new Error(
+                "This element is not a Plotly plot: " + gd2 + ". It's likely that you've failed to create a plot before animating it. For more details, see https://plotly.com/javascript/animations/"
+              );
+            }
+            var trans = gd2._transitionData;
+            if (!trans._frameQueue) {
+              trans._frameQueue = [];
+            }
+            animationOpts = Plots.supplyAnimationDefaults(animationOpts);
+            var transitionOpts = animationOpts.transition;
+            var frameOpts = animationOpts.frame;
+            if (trans._frameWaitingCnt === void 0) {
+              trans._frameWaitingCnt = 0;
+            }
+            function getTransitionOpts(i2) {
+              if (Array.isArray(transitionOpts)) {
+                if (i2 >= transitionOpts.length) {
+                  return transitionOpts[0];
+                } else {
+                  return transitionOpts[i2];
+                }
+              } else {
+                return transitionOpts;
+              }
+            }
+            function getFrameOpts(i2) {
+              if (Array.isArray(frameOpts)) {
+                if (i2 >= frameOpts.length) {
+                  return frameOpts[0];
+                } else {
+                  return frameOpts[i2];
+                }
+              } else {
+                return frameOpts;
+              }
+            }
+            function callbackOnNthTime(cb2, n2) {
+              var cnt = 0;
+              return function() {
+                if (cb2 && ++cnt === n2) {
+                  return cb2();
+                }
+              };
+            }
+            return new Promise(function(resolve, reject) {
+              function discardExistingFrames() {
+                if (trans._frameQueue.length === 0) {
+                  return;
+                }
+                while (trans._frameQueue.length) {
+                  var next = trans._frameQueue.pop();
+                  if (next.onInterrupt) {
+                    next.onInterrupt();
+                  }
+                }
+                gd2.emit("plotly_animationinterrupted", []);
+              }
+              function queueFrames(frameList2) {
+                if (frameList2.length === 0) return;
+                for (var i22 = 0; i22 < frameList2.length; i22++) {
+                  var computedFrame;
+                  if (frameList2[i22].type === "byname") {
+                    computedFrame = Plots.computeFrame(gd2, frameList2[i22].name);
+                  } else {
+                    computedFrame = frameList2[i22].data;
+                  }
+                  var frameOpts2 = getFrameOpts(i22);
+                  var transitionOpts2 = getTransitionOpts(i22);
+                  transitionOpts2.duration = Math.min(transitionOpts2.duration, frameOpts2.duration);
+                  var nextFrame2 = {
+                    frame: computedFrame,
+                    name: frameList2[i22].name,
+                    frameOpts: frameOpts2,
+                    transitionOpts: transitionOpts2
+                  };
+                  if (i22 === frameList2.length - 1) {
+                    nextFrame2.onComplete = callbackOnNthTime(resolve, 2);
+                    nextFrame2.onInterrupt = reject;
+                  }
+                  trans._frameQueue.push(nextFrame2);
+                }
+                if (animationOpts.mode === "immediate") {
+                  trans._lastFrameAt = -Infinity;
+                }
+                if (!trans._animationRaf) {
+                  beginAnimationLoop();
+                }
+              }
+              function stopAnimationLoop() {
+                gd2.emit("plotly_animated");
+                window.cancelAnimationFrame(trans._animationRaf);
+                trans._animationRaf = null;
+              }
+              function nextFrame() {
+                if (trans._currentFrame && trans._currentFrame.onComplete) {
+                  trans._currentFrame.onComplete();
+                }
+                var newFrame = trans._currentFrame = trans._frameQueue.shift();
+                if (newFrame) {
+                  var stringName = newFrame.name ? newFrame.name.toString() : null;
+                  gd2._fullLayout._currentFrame = stringName;
+                  trans._lastFrameAt = Date.now();
+                  trans._timeToNext = newFrame.frameOpts.duration;
+                  Plots.transition(
+                    gd2,
+                    newFrame.frame.data,
+                    newFrame.frame.layout,
+                    helpers.coerceTraceIndices(gd2, newFrame.frame.traces),
+                    newFrame.frameOpts,
+                    newFrame.transitionOpts
+                  ).then(function() {
+                    if (newFrame.onComplete) {
+                      newFrame.onComplete();
+                    }
+                  });
+                  gd2.emit("plotly_animatingframe", {
+                    name: stringName,
+                    frame: newFrame.frame,
+                    animation: {
+                      frame: newFrame.frameOpts,
+                      transition: newFrame.transitionOpts
+                    }
+                  });
+                } else {
+                  stopAnimationLoop();
+                }
+              }
+              function beginAnimationLoop() {
+                gd2.emit("plotly_animating");
+                trans._lastFrameAt = -Infinity;
+                trans._timeToNext = 0;
+                trans._runningTransitions = 0;
+                trans._currentFrame = null;
+                var doFrame = function() {
+                  trans._animationRaf = window.requestAnimationFrame(doFrame);
+                  if (Date.now() - trans._lastFrameAt > trans._timeToNext) {
+                    nextFrame();
+                  }
+                };
+                doFrame();
+              }
+              var configCounter = 0;
+              function setTransitionConfig(frame2) {
+                if (Array.isArray(transitionOpts)) {
+                  if (configCounter >= transitionOpts.length) {
+                    frame2.transitionOpts = transitionOpts[configCounter];
+                  } else {
+                    frame2.transitionOpts = transitionOpts[0];
+                  }
+                } else {
+                  frame2.transitionOpts = transitionOpts;
+                }
+                configCounter++;
+                return frame2;
+              }
+              var i2, frame;
+              var frameList = [];
+              var allFrames = frameOrGroupNameOrFrameList === void 0 || frameOrGroupNameOrFrameList === null;
+              var isFrameArray = Array.isArray(frameOrGroupNameOrFrameList);
+              var isSingleFrame = !allFrames && !isFrameArray && Lib.isPlainObject(frameOrGroupNameOrFrameList);
+              if (isSingleFrame) {
+                frameList.push({
+                  type: "object",
+                  data: setTransitionConfig(Lib.extendFlat({}, frameOrGroupNameOrFrameList))
+                });
+              } else if (allFrames || ["string", "number"].indexOf(typeof frameOrGroupNameOrFrameList) !== -1) {
+                for (i2 = 0; i2 < trans._frames.length; i2++) {
+                  frame = trans._frames[i2];
+                  if (!frame) continue;
+                  if (allFrames || String(frame.group) === String(frameOrGroupNameOrFrameList)) {
+                    frameList.push({
+                      type: "byname",
+                      name: String(frame.name),
+                      data: setTransitionConfig({ name: frame.name })
+                    });
+                  }
+                }
+              } else if (isFrameArray) {
+                for (i2 = 0; i2 < frameOrGroupNameOrFrameList.length; i2++) {
+                  var frameOrName = frameOrGroupNameOrFrameList[i2];
+                  if (["number", "string"].indexOf(typeof frameOrName) !== -1) {
+                    frameOrName = String(frameOrName);
+                    frameList.push({
+                      type: "byname",
+                      name: frameOrName,
+                      data: setTransitionConfig({ name: frameOrName })
+                    });
+                  } else if (Lib.isPlainObject(frameOrName)) {
+                    frameList.push({
+                      type: "object",
+                      data: setTransitionConfig(Lib.extendFlat({}, frameOrName))
+                    });
+                  }
+                }
+              }
+              for (i2 = 0; i2 < frameList.length; i2++) {
+                frame = frameList[i2];
+                if (frame.type === "byname" && !trans._frameHash[frame.data.name]) {
+                  Lib.warn('animate failure: frame not found: "' + frame.data.name + '"');
+                  reject();
+                  return;
+                }
+              }
+              if (["next", "immediate"].indexOf(animationOpts.mode) !== -1) {
+                discardExistingFrames();
+              }
+              if (animationOpts.direction === "reverse") {
+                frameList.reverse();
+              }
+              var currentFrame = gd2._fullLayout._currentFrame;
+              if (currentFrame && animationOpts.fromcurrent) {
+                var idx = -1;
+                for (i2 = 0; i2 < frameList.length; i2++) {
+                  frame = frameList[i2];
+                  if (frame.type === "byname" && frame.name === currentFrame) {
+                    idx = i2;
+                    break;
+                  }
+                }
+                if (idx > 0 && idx < frameList.length - 1) {
+                  var filteredFrameList = [];
+                  for (i2 = 0; i2 < frameList.length; i2++) {
+                    frame = frameList[i2];
+                    if (frameList[i2].type !== "byname" || i2 > idx) {
+                      filteredFrameList.push(frame);
+                    }
+                  }
+                  frameList = filteredFrameList;
+                }
+              }
+              if (frameList.length > 0) {
+                queueFrames(frameList);
+              } else {
+                gd2.emit("plotly_animated");
+                resolve();
+              }
+            });
+          }
+          function addFrames(gd2, frameList, indices) {
+            gd2 = Lib.getGraphDiv(gd2);
+            if (frameList === null || frameList === void 0) {
+              return Promise.resolve();
+            }
+            if (!Lib.isPlotDiv(gd2)) {
+              throw new Error(
+                "This element is not a Plotly plot: " + gd2 + ". It's likely that you've failed to create a plot before adding frames. For more details, see https://plotly.com/javascript/animations/"
+              );
+            }
+            var i2, frame, j2, idx;
+            var _frames = gd2._transitionData._frames;
+            var _frameHash = gd2._transitionData._frameHash;
+            if (!Array.isArray(frameList)) {
+              throw new Error("addFrames failure: frameList must be an Array of frame definitions" + frameList);
+            }
+            var bigIndex = _frames.length + frameList.length * 2;
+            var insertions = [];
+            var _frameHashLocal = {};
+            for (i2 = frameList.length - 1; i2 >= 0; i2--) {
+              if (!Lib.isPlainObject(frameList[i2])) continue;
+              var lookupName = frameList[i2].name;
+              var name2 = (_frameHash[lookupName] || _frameHashLocal[lookupName] || {}).name;
+              var newName = frameList[i2].name;
+              var collisionPresent = _frameHash[name2] || _frameHashLocal[name2];
+              if (name2 && newName && typeof newName === "number" && collisionPresent && numericNameWarningCount < numericNameWarningCountLimit) {
+                numericNameWarningCount++;
+                Lib.warn(
+                  'addFrames: overwriting frame "' + (_frameHash[name2] || _frameHashLocal[name2]).name + '" with a frame whose name of type "number" also equates to "' + name2 + '". This is valid but may potentially lead to unexpected behavior since all plotly.js frame names are stored internally as strings.'
+                );
+                if (numericNameWarningCount === numericNameWarningCountLimit) {
+                  Lib.warn(
+                    "addFrames: This API call has yielded too many of these warnings. For the rest of this call, further warnings about numeric frame names will be suppressed."
+                  );
+                }
+              }
+              _frameHashLocal[lookupName] = { name: lookupName };
+              insertions.push({
+                frame: Plots.supplyFrameDefaults(frameList[i2]),
+                index: indices && indices[i2] !== void 0 && indices[i2] !== null ? indices[i2] : bigIndex + i2
+              });
+            }
+            insertions.sort(function(a2, b2) {
+              if (a2.index > b2.index) return -1;
+              if (a2.index < b2.index) return 1;
+              return 0;
+            });
+            var ops = [];
+            var revops = [];
+            var frameCount = _frames.length;
+            for (i2 = insertions.length - 1; i2 >= 0; i2--) {
+              frame = insertions[i2].frame;
+              if (typeof frame.name === "number") {
+                Lib.warn(
+                  "Warning: addFrames accepts frames with numeric names, but the numbers areimplicitly cast to strings"
+                );
+              }
+              if (!frame.name) {
+                while (_frameHash[frame.name = "frame " + gd2._transitionData._counter++]) ;
+              }
+              if (_frameHash[frame.name]) {
+                for (j2 = 0; j2 < _frames.length; j2++) {
+                  if ((_frames[j2] || {}).name === frame.name) break;
+                }
+                ops.push({ type: "replace", index: j2, value: frame });
+                revops.unshift({ type: "replace", index: j2, value: _frames[j2] });
+              } else {
+                idx = Math.max(0, Math.min(insertions[i2].index, frameCount));
+                ops.push({ type: "insert", index: idx, value: frame });
+                revops.unshift({ type: "delete", index: idx });
+                frameCount++;
+              }
+            }
+            var undoFunc = Plots.modifyFrames;
+            var redoFunc = Plots.modifyFrames;
+            var undoArgs = [gd2, revops];
+            var redoArgs = [gd2, ops];
+            if (Queue) Queue.add(gd2, undoFunc, undoArgs, redoFunc, redoArgs);
+            return Plots.modifyFrames(gd2, ops);
+          }
+          function deleteFrames(gd2, frameList) {
+            gd2 = Lib.getGraphDiv(gd2);
+            if (!Lib.isPlotDiv(gd2)) {
+              throw new Error("This element is not a Plotly plot: " + gd2);
+            }
+            var i2, idx;
+            var _frames = gd2._transitionData._frames;
+            var ops = [];
+            var revops = [];
+            if (!frameList) {
+              frameList = [];
+              for (i2 = 0; i2 < _frames.length; i2++) {
+                frameList.push(i2);
+              }
+            }
+            frameList = frameList.slice();
+            frameList.sort();
+            for (i2 = frameList.length - 1; i2 >= 0; i2--) {
+              idx = frameList[i2];
+              ops.push({ type: "delete", index: idx });
+              revops.unshift({ type: "insert", index: idx, value: _frames[idx] });
+            }
+            var undoFunc = Plots.modifyFrames;
+            var redoFunc = Plots.modifyFrames;
+            var undoArgs = [gd2, revops];
+            var redoArgs = [gd2, ops];
+            if (Queue) Queue.add(gd2, undoFunc, undoArgs, redoFunc, redoArgs);
+            return Plots.modifyFrames(gd2, ops);
+          }
+          function purge(gd2) {
+            gd2 = Lib.getGraphDiv(gd2);
+            var fullLayout = gd2._fullLayout || {};
+            var fullData = gd2._fullData || [];
+            Plots.cleanPlot([], {}, fullData, fullLayout);
+            Plots.purge(gd2);
+            Events.purge(gd2);
+            if (fullLayout._container) fullLayout._container.remove();
+            delete gd2._context;
+            return gd2;
+          }
+          function calcInverseTransform(gd2) {
+            var fullLayout = gd2._fullLayout;
+            var newBBox = gd2.getBoundingClientRect();
+            if (Lib.equalDomRects(newBBox, fullLayout._lastBBox)) return;
+            var m2 = fullLayout._invTransform = Lib.inverseTransformMatrix(Lib.getFullTransformMatrix(gd2));
+            fullLayout._invScaleX = Math.sqrt(m2[0][0] * m2[0][0] + m2[0][1] * m2[0][1] + m2[0][2] * m2[0][2]);
+            fullLayout._invScaleY = Math.sqrt(m2[1][0] * m2[1][0] + m2[1][1] * m2[1][1] + m2[1][2] * m2[1][2]);
+            fullLayout._lastBBox = newBBox;
+          }
+          function makePlotFramework(gd2) {
+            var gd3 = d3.select(gd2);
+            var fullLayout = gd2._fullLayout;
+            fullLayout._calcInverseTransform = calcInverseTransform;
+            fullLayout._calcInverseTransform(gd2);
+            fullLayout._container = gd3.selectAll(".plot-container").data([0]);
+            fullLayout._container.enter().insert("div", ":first-child").classed("plot-container", true).classed("plotly", true).style({
+              width: "100%",
+              height: "100%"
+            });
+            fullLayout._paperdiv = fullLayout._container.selectAll(".svg-container").data([0]);
+            fullLayout._paperdiv.enter().append("div").classed("user-select-none", true).classed("svg-container", true).style("position", "relative");
+            fullLayout._glcontainer = fullLayout._paperdiv.selectAll(".gl-container").data([{}]);
+            fullLayout._glcontainer.enter().append("div").classed("gl-container", true);
+            fullLayout._paperdiv.selectAll(".main-svg").remove();
+            fullLayout._paperdiv.select(".modebar-container").remove();
+            fullLayout._paper = fullLayout._paperdiv.insert("svg", ":first-child").classed("main-svg", true);
+            fullLayout._toppaper = fullLayout._paperdiv.append("svg").classed("main-svg", true);
+            fullLayout._modebardiv = fullLayout._paperdiv.append("div");
+            delete fullLayout._modeBar;
+            fullLayout._hoverpaper = fullLayout._paperdiv.append("svg").classed("main-svg", true);
+            if (!fullLayout._uid) {
+              var otherUids = {};
+              d3.selectAll("defs").each(function() {
+                if (this.id) otherUids[this.id.split("-")[1]] = 1;
+              });
+              fullLayout._uid = Lib.randstr(otherUids);
+            }
+            fullLayout._paperdiv.selectAll(".main-svg").attr(xmlnsNamespaces.svgAttrs);
+            fullLayout._defs = fullLayout._paper.append("defs").attr("id", "defs-" + fullLayout._uid);
+            fullLayout._clips = fullLayout._defs.append("g").classed("clips", true);
+            fullLayout._topdefs = fullLayout._toppaper.append("defs").attr("id", "topdefs-" + fullLayout._uid);
+            fullLayout._topclips = fullLayout._topdefs.append("g").classed("clips", true);
+            fullLayout._bgLayer = fullLayout._paper.append("g").classed("bglayer", true);
+            fullLayout._draggers = fullLayout._paper.append("g").classed("draglayer", true);
+            var layerBelow = fullLayout._paper.append("g").classed("layer-below", true);
+            fullLayout._imageLowerLayer = layerBelow.append("g").classed("imagelayer", true);
+            fullLayout._shapeLowerLayer = layerBelow.append("g").classed("shapelayer", true);
+            fullLayout._cartesianlayer = fullLayout._paper.append("g").classed("cartesianlayer", true);
+            fullLayout._polarlayer = fullLayout._paper.append("g").classed("polarlayer", true);
+            fullLayout._smithlayer = fullLayout._paper.append("g").classed("smithlayer", true);
+            fullLayout._ternarylayer = fullLayout._paper.append("g").classed("ternarylayer", true);
+            fullLayout._geolayer = fullLayout._paper.append("g").classed("geolayer", true);
+            fullLayout._funnelarealayer = fullLayout._paper.append("g").classed("funnelarealayer", true);
+            fullLayout._pielayer = fullLayout._paper.append("g").classed("pielayer", true);
+            fullLayout._iciclelayer = fullLayout._paper.append("g").classed("iciclelayer", true);
+            fullLayout._treemaplayer = fullLayout._paper.append("g").classed("treemaplayer", true);
+            fullLayout._sunburstlayer = fullLayout._paper.append("g").classed("sunburstlayer", true);
+            fullLayout._indicatorlayer = fullLayout._toppaper.append("g").classed("indicatorlayer", true);
+            fullLayout._glimages = fullLayout._paper.append("g").classed("glimages", true);
+            var layerAbove = fullLayout._toppaper.append("g").classed("layer-above", true);
+            fullLayout._imageUpperLayer = layerAbove.append("g").classed("imagelayer", true);
+            fullLayout._shapeUpperLayer = layerAbove.append("g").classed("shapelayer", true);
+            fullLayout._selectionLayer = fullLayout._toppaper.append("g").classed("selectionlayer", true);
+            fullLayout._infolayer = fullLayout._toppaper.append("g").classed("infolayer", true);
+            fullLayout._menulayer = fullLayout._toppaper.append("g").classed("menulayer", true);
+            fullLayout._zoomlayer = fullLayout._toppaper.append("g").classed("zoomlayer", true);
+            fullLayout._hoverlayer = fullLayout._hoverpaper.append("g").classed("hoverlayer", true);
+            fullLayout._modebardiv.classed("modebar-container", true).style("position", "absolute").style("top", "0px").style("right", "0px");
+            gd2.emit("plotly_framework");
+          }
+          exports.animate = animate;
+          exports.addFrames = addFrames;
+          exports.deleteFrames = deleteFrames;
+          exports.addTraces = addTraces;
+          exports.deleteTraces = deleteTraces;
+          exports.extendTraces = extendTraces;
+          exports.moveTraces = moveTraces;
+          exports.prependTraces = prependTraces;
+          exports.newPlot = newPlot;
+          exports._doPlot = _doPlot;
+          exports.purge = purge;
+          exports.react = react2;
+          exports.redraw = redraw;
+          exports.relayout = relayout;
+          exports.restyle = restyle;
+          exports.setPlotConfig = setPlotConfig;
+          exports.update = update;
+          exports._guiRelayout = guiEdit(relayout);
+          exports._guiRestyle = guiEdit(restyle);
+          exports._guiUpdate = guiEdit(update);
+          exports._storeDirectGUIEdit = _storeDirectGUIEdit;
+        }
+      });
+      var require_helpers10 = __commonJS({
+        "src/snapshot/helpers.js"(exports) {
+          var Registry = require_registry();
+          exports.getDelay = function(fullLayout) {
+            if (!fullLayout._has) return 0;
+            return fullLayout._has("gl3d") || fullLayout._has("mapbox") || fullLayout._has("map") ? 500 : 0;
+          };
+          exports.getRedrawFunc = function(gd2) {
+            return function() {
+              Registry.getComponentMethod("colorbar", "draw")(gd2);
+            };
+          };
+          exports.encodeSVG = function(svg) {
+            return "data:image/svg+xml," + encodeURIComponent(svg);
+          };
+          exports.encodeJSON = function(json) {
+            return "data:application/json," + encodeURIComponent(json);
+          };
+          var DOM_URL = window.URL || window.webkitURL;
+          exports.createObjectURL = function(blob) {
+            return DOM_URL.createObjectURL(blob);
+          };
+          exports.revokeObjectURL = function(url) {
+            return DOM_URL.revokeObjectURL(url);
+          };
+          exports.createBlob = function(url, format) {
+            if (format === "svg") {
+              return new window.Blob([url], { type: "image/svg+xml;charset=utf-8" });
+            } else if (format === "full-json") {
+              return new window.Blob([url], { type: "application/json;charset=utf-8" });
+            } else {
+              var binary = fixBinary(window.atob(url));
+              return new window.Blob([binary], { type: "image/" + format });
+            }
+          };
+          exports.octetStream = function(s2) {
+            document.location.href = "data:application/octet-stream" + s2;
+          };
+          function fixBinary(b2) {
+            var len2 = b2.length;
+            var buf = new ArrayBuffer(len2);
+            var arr = new Uint8Array(buf);
+            for (var i2 = 0; i2 < len2; i2++) {
+              arr[i2] = b2.charCodeAt(i2);
+            }
+            return buf;
+          }
+          exports.IMAGE_URL_PREFIX = /^data:image\/\w+;base64,/;
+        }
+      });
+      var require_tosvg = __commonJS({
+        "src/snapshot/tosvg.js"(exports, module2) {
+          var d3 = require_d3();
+          require_lib();
+          var Drawing = require_drawing();
+          var Color2 = require_color();
+          require_xmlns_namespaces();
+          var DOUBLEQUOTE_REGEX = /"/g;
+          var DUMMY_SUB = "TOBESTRIPPED";
+          var DUMMY_REGEX = new RegExp('("' + DUMMY_SUB + ")|(" + DUMMY_SUB + '")', "g");
+          function htmlEntityDecode(s2) {
+            var hiddenDiv = d3.select("body").append("div").style({ display: "none" }).html("");
+            var replaced = s2.replace(/(&[^;]*;)/gi, function(d2) {
+              if (d2 === "&lt;") {
+                return "&#60;";
+              }
+              if (d2 === "&rt;") {
+                return "&#62;";
+              }
+              if (d2.indexOf("<") !== -1 || d2.indexOf(">") !== -1) {
+                return "";
+              }
+              return hiddenDiv.html(d2).text();
+            });
+            hiddenDiv.remove();
+            return replaced;
+          }
+          function xmlEntityEncode(str) {
+            return str.replace(/&(?!\w+;|\#[0-9]+;| \#x[0-9A-F]+;)/g, "&amp;");
+          }
+          module2.exports = function toSVG(gd2, format, scale2) {
+            var fullLayout = gd2._fullLayout;
+            var svg = fullLayout._paper;
+            var toppaper = fullLayout._toppaper;
+            var width = fullLayout.width;
+            var height = fullLayout.height;
+            var i2;
+            svg.insert("rect", ":first-child").call(Drawing.setRect, 0, 0, width, height).call(Color2.fill, fullLayout.paper_bgcolor);
+            var basePlotModules = fullLayout._basePlotModules || [];
+            for (i2 = 0; i2 < basePlotModules.length; i2++) {
+              var _module = basePlotModules[i2];
+              if (_module.toSVG) _module.toSVG(gd2);
+            }
+            if (toppaper) {
+              var nodes = toppaper.node().childNodes;
+              var topGroups = Array.prototype.slice.call(nodes);
+              for (i2 = 0; i2 < topGroups.length; i2++) {
+                var topGroup = topGroups[i2];
+                if (topGroup.childNodes.length) svg.node().appendChild(topGroup);
+              }
+            }
+            if (fullLayout._draggers) {
+              fullLayout._draggers.remove();
+            }
+            svg.node().style.background = "";
+            svg.selectAll("text").attr({ "data-unformatted": null, "data-math": null }).each(function() {
+              var txt = d3.select(this);
+              if (this.style.visibility === "hidden" || this.style.display === "none") {
+                txt.remove();
+                return;
+              } else {
+                txt.style({ visibility: null, display: null });
+              }
+              var ff2 = this.style.fontFamily;
+              if (ff2 && ff2.indexOf('"') !== -1) {
+                txt.style("font-family", ff2.replace(DOUBLEQUOTE_REGEX, DUMMY_SUB));
+              }
+              var fw = this.style.fontWeight;
+              if (fw && (fw === "normal" || fw === "400")) {
+                txt.style("font-weight", void 0);
+              }
+              var fs2 = this.style.fontStyle;
+              if (fs2 && fs2 === "normal") {
+                txt.style("font-style", void 0);
+              }
+              var fv = this.style.fontVariant;
+              if (fv && fv === "normal") {
+                txt.style("font-variant", void 0);
+              }
+            });
+            svg.selectAll(".gradient_filled,.pattern_filled").each(function() {
+              var pt2 = d3.select(this);
+              var fill = this.style.fill;
+              if (fill && fill.indexOf("url(") !== -1) {
+                pt2.style("fill", fill.replace(DOUBLEQUOTE_REGEX, DUMMY_SUB));
+              }
+              var stroke = this.style.stroke;
+              if (stroke && stroke.indexOf("url(") !== -1) {
+                pt2.style("stroke", stroke.replace(DOUBLEQUOTE_REGEX, DUMMY_SUB));
+              }
+            });
+            if (format === "pdf" || format === "eps") {
+              svg.selectAll("#MathJax_SVG_glyphs path").attr("stroke-width", 0);
+            }
+            if (format === "svg" && scale2) {
+              svg.attr("width", scale2 * width);
+              svg.attr("height", scale2 * height);
+              svg.attr("viewBox", "0 0 " + width + " " + height);
+            }
+            var s2 = new window.XMLSerializer().serializeToString(svg.node());
+            s2 = htmlEntityDecode(s2);
+            s2 = xmlEntityEncode(s2);
+            s2 = s2.replace(DUMMY_REGEX, "'");
+            return s2;
+          };
+        }
+      });
+      var require_svgtoimg = __commonJS({
+        "src/snapshot/svgtoimg.js"(exports, module2) {
+          var Lib = require_lib();
+          var EventEmitter = require_events().EventEmitter;
+          var helpers = require_helpers10();
+          function svgToImg(opts) {
+            var ev = opts.emitter || new EventEmitter();
+            var promise = new Promise(function(resolve, reject) {
+              var Image2 = window.Image;
+              var svg = opts.svg;
+              var format = opts.format || "png";
+              var canvas2 = opts.canvas;
+              var scale2 = opts.scale || 1;
+              var w0 = opts.width || 300;
+              var h0 = opts.height || 150;
+              var w1 = scale2 * w0;
+              var h1 = scale2 * h0;
+              var ctx2 = canvas2.getContext("2d", { willReadFrequently: true });
+              var img = new Image2();
+              var svgBlob, url;
+              if (format === "svg" || Lib.isSafari()) {
+                url = helpers.encodeSVG(svg);
+              } else {
+                svgBlob = helpers.createBlob(svg, "svg");
+                url = helpers.createObjectURL(svgBlob);
+              }
+              canvas2.width = w1;
+              canvas2.height = h1;
+              img.onload = function() {
+                var imgData;
+                svgBlob = null;
+                helpers.revokeObjectURL(url);
+                if (format !== "svg") {
+                  ctx2.drawImage(img, 0, 0, w1, h1);
+                }
+                switch (format) {
+                  case "jpeg":
+                    imgData = canvas2.toDataURL("image/jpeg");
+                    break;
+                  case "png":
+                    imgData = canvas2.toDataURL("image/png");
+                    break;
+                  case "webp":
+                    imgData = canvas2.toDataURL("image/webp");
+                    break;
+                  case "svg":
+                    imgData = url;
+                    break;
+                  default:
+                    var errorMsg = "Image format is not jpeg, png, svg or webp.";
+                    reject(new Error(errorMsg));
+                    if (!opts.promise) {
+                      return ev.emit("error", errorMsg);
+                    }
+                }
+                resolve(imgData);
+                if (!opts.promise) {
+                  ev.emit("success", imgData);
+                }
+              };
+              img.onerror = function(err) {
+                svgBlob = null;
+                helpers.revokeObjectURL(url);
+                reject(err);
+                if (!opts.promise) {
+                  return ev.emit("error", err);
+                }
+              };
+              img.src = url;
+            });
+            if (opts.promise) {
+              return promise;
+            }
+            return ev;
+          }
+          module2.exports = svgToImg;
+        }
+      });
+      var require_to_image = __commonJS({
+        "src/plot_api/to_image.js"(exports, module2) {
+          var isNumeric = require_fast_isnumeric();
+          var plotApi = require_plot_api();
+          var plots = require_plots();
+          var Lib = require_lib();
+          var helpers = require_helpers10();
+          var toSVG = require_tosvg();
+          var svgToImg = require_svgtoimg();
+          var version2 = require_version().version;
+          var attrs = {
+            format: {
+              valType: "enumerated",
+              values: ["png", "jpeg", "webp", "svg", "full-json"],
+              dflt: "png"
+            },
+            width: {
+              valType: "number",
+              min: 1
+            },
+            height: {
+              valType: "number",
+              min: 1
+            },
+            scale: {
+              valType: "number",
+              min: 0,
+              dflt: 1
+            },
+            setBackground: {
+              valType: "any",
+              dflt: false
+            },
+            imageDataOnly: {
+              valType: "boolean",
+              dflt: false
+            }
+          };
+          function toImage(gd2, opts) {
+            opts = opts || {};
+            var data;
+            var layout;
+            var config2;
+            var fullLayout;
+            if (Lib.isPlainObject(gd2)) {
+              data = gd2.data || [];
+              layout = gd2.layout || {};
+              config2 = gd2.config || {};
+              fullLayout = {};
+            } else {
+              gd2 = Lib.getGraphDiv(gd2);
+              data = Lib.extendDeep([], gd2.data);
+              layout = Lib.extendDeep({}, gd2.layout);
+              config2 = gd2._context;
+              fullLayout = gd2._fullLayout || {};
+            }
+            function isImpliedOrValid(attr) {
+              return !(attr in opts) || Lib.validate(opts[attr], attrs[attr]);
+            }
+            if (!isImpliedOrValid("width") && opts.width !== null || !isImpliedOrValid("height") && opts.height !== null) {
+              throw new Error("Height and width should be pixel values.");
+            }
+            if (!isImpliedOrValid("format")) {
+              throw new Error("Export format is not " + Lib.join2(attrs.format.values, ", ", " or ") + ".");
+            }
+            var fullOpts = {};
+            function coerce(attr, dflt) {
+              return Lib.coerce(opts, fullOpts, attrs, attr, dflt);
+            }
+            var format = coerce("format");
+            var width = coerce("width");
+            var height = coerce("height");
+            var scale2 = coerce("scale");
+            var setBackground = coerce("setBackground");
+            var imageDataOnly = coerce("imageDataOnly");
+            var clonedGd = document.createElement("div");
+            clonedGd.style.position = "absolute";
+            clonedGd.style.left = "-5000px";
+            document.body.appendChild(clonedGd);
+            var layoutImage = Lib.extendFlat({}, layout);
+            if (width) {
+              layoutImage.width = width;
+            } else if (opts.width === null && isNumeric(fullLayout.width)) {
+              layoutImage.width = fullLayout.width;
+            }
+            if (height) {
+              layoutImage.height = height;
+            } else if (opts.height === null && isNumeric(fullLayout.height)) {
+              layoutImage.height = fullLayout.height;
+            }
+            var configImage = Lib.extendFlat({}, config2, {
+              _exportedPlot: true,
+              staticPlot: true,
+              setBackground
+            });
+            var redrawFunc = helpers.getRedrawFunc(clonedGd);
+            function wait() {
+              return new Promise(function(resolve) {
+                setTimeout(resolve, helpers.getDelay(clonedGd._fullLayout));
+              });
+            }
+            function convert() {
+              return new Promise(function(resolve, reject) {
+                var svg = toSVG(clonedGd, format, scale2);
+                var width2 = clonedGd._fullLayout.width;
+                var height2 = clonedGd._fullLayout.height;
+                function cleanup() {
+                  plotApi.purge(clonedGd);
+                  document.body.removeChild(clonedGd);
+                }
+                if (format === "full-json") {
+                  var json = plots.graphJson(clonedGd, false, "keepdata", "object", true, true);
+                  json.version = version2;
+                  json = JSON.stringify(json);
+                  cleanup();
+                  if (imageDataOnly) {
+                    return resolve(json);
+                  } else {
+                    return resolve(helpers.encodeJSON(json));
+                  }
+                }
+                cleanup();
+                if (format === "svg") {
+                  if (imageDataOnly) {
+                    return resolve(svg);
+                  } else {
+                    return resolve(helpers.encodeSVG(svg));
+                  }
+                }
+                var canvas2 = document.createElement("canvas");
+                canvas2.id = Lib.randstr();
+                svgToImg({
+                  format,
+                  width: width2,
+                  height: height2,
+                  scale: scale2,
+                  canvas: canvas2,
+                  svg,
+                  // ask svgToImg to return a Promise
+                  //  rather than EventEmitter
+                  //  leave EventEmitter for backward
+                  //  compatibility
+                  promise: true
+                }).then(resolve).catch(reject);
+              });
+            }
+            function urlToImageData(url) {
+              if (imageDataOnly) {
+                return url.replace(helpers.IMAGE_URL_PREFIX, "");
+              } else {
+                return url;
+              }
+            }
+            return new Promise(function(resolve, reject) {
+              plotApi.newPlot(clonedGd, data, layoutImage, configImage).then(redrawFunc).then(wait).then(convert).then(function(url) {
+                resolve(urlToImageData(url));
+              }).catch(function(err) {
+                reject(err);
+              });
+            });
+          }
+          module2.exports = toImage;
+        }
+      });
+      var require_validate = __commonJS({
+        "src/plot_api/validate.js"(exports, module2) {
+          var Lib = require_lib();
+          var Plots = require_plots();
+          var PlotSchema = require_plot_schema();
+          var dfltConfig = require_plot_config().dfltConfig;
+          var isPlainObject2 = Lib.isPlainObject;
+          var isArray2 = Array.isArray;
+          var isArrayOrTypedArray = Lib.isArrayOrTypedArray;
+          module2.exports = function validate(data, layout) {
+            if (data === void 0) data = [];
+            if (layout === void 0) layout = {};
+            var schema = PlotSchema.get();
+            var errorList = [];
+            var gd2 = { _context: Lib.extendFlat({}, dfltConfig) };
+            var dataIn, layoutIn;
+            if (isArray2(data)) {
+              gd2.data = Lib.extendDeep([], data);
+              dataIn = data;
+            } else {
+              gd2.data = [];
+              dataIn = [];
+              errorList.push(format("array", "data"));
+            }
+            if (isPlainObject2(layout)) {
+              gd2.layout = Lib.extendDeep({}, layout);
+              layoutIn = layout;
+            } else {
+              gd2.layout = {};
+              layoutIn = {};
+              if (arguments.length > 1) {
+                errorList.push(format("object", "layout"));
+              }
+            }
+            Plots.supplyDefaults(gd2);
+            var dataOut = gd2._fullData;
+            var len2 = dataIn.length;
+            for (var i2 = 0; i2 < len2; i2++) {
+              var traceIn = dataIn[i2];
+              var base = ["data", i2];
+              if (!isPlainObject2(traceIn)) {
+                errorList.push(format("object", base));
+                continue;
+              }
+              var traceOut = dataOut[i2];
+              var traceType = traceOut.type;
+              var traceSchema = schema.traces[traceType].attributes;
+              traceSchema.type = {
+                valType: "enumerated",
+                values: [traceType]
+              };
+              if (traceOut.visible === false && traceIn.visible !== false) {
+                errorList.push(format("invisible", base));
+              }
+              crawl(traceIn, traceOut, traceSchema, errorList, base);
+            }
+            var layoutOut = gd2._fullLayout;
+            var layoutSchema = fillLayoutSchema(schema, dataOut);
+            crawl(layoutIn, layoutOut, layoutSchema, errorList, "layout");
+            return errorList.length === 0 ? void 0 : errorList;
+          };
+          function crawl(objIn, objOut, schema, list, base, path) {
+            path = path || [];
+            var keys = Object.keys(objIn);
+            for (var i2 = 0; i2 < keys.length; i2++) {
+              var k2 = keys[i2];
+              var p2 = path.slice();
+              p2.push(k2);
+              var valIn = objIn[k2];
+              var valOut = objOut[k2];
+              var nestedSchema = getNestedSchema(schema, k2);
+              var nestedValType = (nestedSchema || {}).valType;
+              var isInfoArray = nestedValType === "info_array";
+              var isColorscale = nestedValType === "colorscale";
+              var items = (nestedSchema || {}).items;
+              if (!isInSchema(schema, k2)) {
+                list.push(format("schema", base, p2));
+              } else if (isPlainObject2(valIn) && isPlainObject2(valOut) && nestedValType !== "any") {
+                crawl(valIn, valOut, nestedSchema, list, base, p2);
+              } else if (isInfoArray && isArray2(valIn)) {
+                if (valIn.length > valOut.length) {
+                  list.push(format("unused", base, p2.concat(valOut.length)));
+                }
+                var len2 = valOut.length;
+                var arrayItems = Array.isArray(items);
+                if (arrayItems) len2 = Math.min(len2, items.length);
+                var m2, n2, item, valInPart, valOutPart;
+                if (nestedSchema.dimensions === 2) {
+                  for (n2 = 0; n2 < len2; n2++) {
+                    if (isArray2(valIn[n2])) {
+                      if (valIn[n2].length > valOut[n2].length) {
+                        list.push(format("unused", base, p2.concat(n2, valOut[n2].length)));
+                      }
+                      var len22 = valOut[n2].length;
+                      for (m2 = 0; m2 < (arrayItems ? Math.min(len22, items[n2].length) : len22); m2++) {
+                        item = arrayItems ? items[n2][m2] : items;
+                        valInPart = valIn[n2][m2];
+                        valOutPart = valOut[n2][m2];
+                        if (!Lib.validate(valInPart, item)) {
+                          list.push(format("value", base, p2.concat(n2, m2), valInPart));
+                        } else if (valOutPart !== valInPart && valOutPart !== +valInPart) {
+                          list.push(format("dynamic", base, p2.concat(n2, m2), valInPart, valOutPart));
+                        }
+                      }
+                    } else {
+                      list.push(format("array", base, p2.concat(n2), valIn[n2]));
+                    }
+                  }
+                } else {
+                  for (n2 = 0; n2 < len2; n2++) {
+                    item = arrayItems ? items[n2] : items;
+                    valInPart = valIn[n2];
+                    valOutPart = valOut[n2];
+                    if (!Lib.validate(valInPart, item)) {
+                      list.push(format("value", base, p2.concat(n2), valInPart));
+                    } else if (valOutPart !== valInPart && valOutPart !== +valInPart) {
+                      list.push(format("dynamic", base, p2.concat(n2), valInPart, valOutPart));
+                    }
+                  }
+                }
+              } else if (nestedSchema.items && !isInfoArray && isArray2(valIn)) {
+                var _nestedSchema = items[Object.keys(items)[0]];
+                var indexList = [];
+                var j2, _p2;
+                for (j2 = 0; j2 < valOut.length; j2++) {
+                  var _index = valOut[j2]._index || j2;
+                  _p2 = p2.slice();
+                  _p2.push(_index);
+                  if (isPlainObject2(valIn[_index]) && isPlainObject2(valOut[j2])) {
+                    indexList.push(_index);
+                    var valInj = valIn[_index];
+                    var valOutj = valOut[j2];
+                    if (isPlainObject2(valInj) && valInj.visible !== false && valOutj.visible === false) {
+                      list.push(format("invisible", base, _p2));
+                    } else crawl(valInj, valOutj, _nestedSchema, list, base, _p2);
+                  }
+                }
+                for (j2 = 0; j2 < valIn.length; j2++) {
+                  _p2 = p2.slice();
+                  _p2.push(j2);
+                  if (!isPlainObject2(valIn[j2])) {
+                    list.push(format("object", base, _p2, valIn[j2]));
+                  } else if (indexList.indexOf(j2) === -1) {
+                    list.push(format("unused", base, _p2));
+                  }
+                }
+              } else if (!isPlainObject2(valIn) && isPlainObject2(valOut)) {
+                list.push(format("object", base, p2, valIn));
+              } else if (!isArrayOrTypedArray(valIn) && isArrayOrTypedArray(valOut) && !isInfoArray && !isColorscale) {
+                list.push(format("array", base, p2, valIn));
+              } else if (!(k2 in objOut)) {
+                list.push(format("unused", base, p2, valIn));
+              } else if (!Lib.validate(valIn, nestedSchema)) {
+                list.push(format("value", base, p2, valIn));
+              } else if (nestedSchema.valType === "enumerated" && (nestedSchema.coerceNumber && valIn !== +valOut || !isArrayOrTypedArray(valIn) && valIn !== valOut || String(valIn) !== String(valOut))) {
+                list.push(format("dynamic", base, p2, valIn, valOut));
+              }
+            }
+            return list;
+          }
+          function fillLayoutSchema(schema, dataOut) {
+            var layoutSchema = schema.layout.layoutAttributes;
+            for (var i2 = 0; i2 < dataOut.length; i2++) {
+              var traceOut = dataOut[i2];
+              var traceSchema = schema.traces[traceOut.type];
+              var traceLayoutAttr = traceSchema.layoutAttributes;
+              if (traceLayoutAttr) {
+                if (traceOut.subplot) {
+                  Lib.extendFlat(layoutSchema[traceSchema.attributes.subplot.dflt], traceLayoutAttr);
+                } else {
+                  Lib.extendFlat(layoutSchema, traceLayoutAttr);
+                }
+              }
+            }
+            return layoutSchema;
+          }
+          var code2msgFunc = {
+            object: function(base, astr) {
+              var prefix;
+              if (base === "layout" && astr === "") prefix = "The layout argument";
+              else if (base[0] === "data" && astr === "") {
+                prefix = "Trace " + base[1] + " in the data argument";
+              } else prefix = inBase(base) + "key " + astr;
+              return prefix + " must be linked to an object container";
+            },
+            array: function(base, astr) {
+              var prefix;
+              if (base === "data") prefix = "The data argument";
+              else prefix = inBase(base) + "key " + astr;
+              return prefix + " must be linked to an array container";
+            },
+            schema: function(base, astr) {
+              return inBase(base) + "key " + astr + " is not part of the schema";
+            },
+            unused: function(base, astr, valIn) {
+              var target = isPlainObject2(valIn) ? "container" : "key";
+              return inBase(base) + target + " " + astr + " did not get coerced";
+            },
+            dynamic: function(base, astr, valIn, valOut) {
+              return [
+                inBase(base) + "key",
+                astr,
+                "(set to '" + valIn + "')",
+                "got reset to",
+                "'" + valOut + "'",
+                "during defaults."
+              ].join(" ");
+            },
+            invisible: function(base, astr) {
+              return (astr ? inBase(base) + "item " + astr : "Trace " + base[1]) + " got defaulted to be not visible";
+            },
+            value: function(base, astr, valIn) {
+              return [
+                inBase(base) + "key " + astr,
+                "is set to an invalid value (" + valIn + ")"
+              ].join(" ");
+            }
+          };
+          function inBase(base) {
+            if (isArray2(base)) return "In data trace " + base[1] + ", ";
+            return "In " + base + ", ";
+          }
+          function format(code, base, path, valIn, valOut) {
+            path = path || "";
+            var container, trace;
+            if (isArray2(base)) {
+              container = base[0];
+              trace = base[1];
+            } else {
+              container = base;
+              trace = null;
+            }
+            var astr = convertPathToAttributeString(path);
+            var msg = code2msgFunc[code](base, astr, valIn, valOut);
+            Lib.log(msg);
+            return {
+              code,
+              container,
+              trace,
+              path,
+              astr,
+              msg
+            };
+          }
+          function isInSchema(schema, key) {
+            var parts = splitKey(key);
+            var keyMinusId = parts.keyMinusId;
+            var id2 = parts.id;
+            if (keyMinusId in schema && schema[keyMinusId]._isSubplotObj && id2) {
+              return true;
+            }
+            return key in schema;
+          }
+          function getNestedSchema(schema, key) {
+            if (key in schema) return schema[key];
+            var parts = splitKey(key);
+            return schema[parts.keyMinusId];
+          }
+          var idRegex = Lib.counterRegex("([a-z]+)");
+          function splitKey(key) {
+            var idMatch = key.match(idRegex);
+            return {
+              keyMinusId: idMatch && idMatch[1],
+              id: idMatch && idMatch[2]
+            };
+          }
+          function convertPathToAttributeString(path) {
+            if (!isArray2(path)) return String(path);
+            var astr = "";
+            for (var i2 = 0; i2 < path.length; i2++) {
+              var p2 = path[i2];
+              if (typeof p2 === "number") {
+                astr = astr.slice(0, -1) + "[" + p2 + "]";
+              } else {
+                astr += p2;
+              }
+              if (i2 < path.length - 1) astr += ".";
+            }
+            return astr;
+          }
+        }
+      });
+      var require_filesaver = __commonJS({
+        "src/snapshot/filesaver.js"(exports, module2) {
+          var Lib = require_lib();
+          var helpers = require_helpers10();
+          function fileSaver(url, name2, format) {
+            var saveLink = document.createElement("a");
+            var canUseSaveLink = "download" in saveLink;
+            var promise = new Promise(function(resolve, reject) {
+              var blob;
+              var objectUrl;
+              if (canUseSaveLink) {
+                blob = helpers.createBlob(url, format);
+                objectUrl = helpers.createObjectURL(blob);
+                saveLink.href = objectUrl;
+                saveLink.download = name2;
+                document.body.appendChild(saveLink);
+                saveLink.click();
+                document.body.removeChild(saveLink);
+                helpers.revokeObjectURL(objectUrl);
+                blob = null;
+                return resolve(name2);
+              }
+              if (Lib.isSafari()) {
+                var prefix = format === "svg" ? "," : ";base64,";
+                helpers.octetStream(prefix + encodeURIComponent(url));
+                return resolve(name2);
+              }
+              reject(new Error("download error"));
+            });
+            return promise;
+          }
+          module2.exports = fileSaver;
+        }
+      });
+      var require_download = __commonJS({
+        "src/snapshot/download.js"(exports, module2) {
+          var Lib = require_lib();
+          var toImage = require_to_image();
+          var fileSaver = require_filesaver();
+          require_helpers10();
+          function downloadImage(gd2, opts) {
+            var _gd;
+            if (!Lib.isPlainObject(gd2)) _gd = Lib.getGraphDiv(gd2);
+            opts = opts || {};
+            opts.format = opts.format || "png";
+            opts.width = opts.width || null;
+            opts.height = opts.height || null;
+            opts.imageDataOnly = true;
+            return new Promise(function(resolve, reject) {
+              if (_gd && _gd._snapshotInProgress) {
+                reject(new Error("Snapshotting already in progress."));
+              }
+              if (_gd) _gd._snapshotInProgress = true;
+              var promise = toImage(gd2, opts);
+              var filename2 = opts.filename || gd2.fn || "newplot";
+              filename2 += "." + opts.format.replace("-", ".");
+              promise.then(function(result) {
+                if (_gd) _gd._snapshotInProgress = false;
+                return fileSaver(result, filename2, opts.format);
+              }).then(function(name2) {
+                resolve(name2);
+              }).catch(function(err) {
+                if (_gd) _gd._snapshotInProgress = false;
+                reject(err);
+              });
+            });
+          }
+          module2.exports = downloadImage;
+        }
+      });
+      var require_template_api = __commonJS({
+        "src/plot_api/template_api.js"(exports) {
+          var Lib = require_lib();
+          var isPlainObject2 = Lib.isPlainObject;
+          var PlotSchema = require_plot_schema();
+          var Plots = require_plots();
+          var plotAttributes = require_attributes2();
+          var Template = require_plot_template();
+          var dfltConfig = require_plot_config().dfltConfig;
+          exports.makeTemplate = function(figure) {
+            figure = Lib.isPlainObject(figure) ? figure : Lib.getGraphDiv(figure);
+            figure = Lib.extendDeep({ _context: dfltConfig }, { data: figure.data, layout: figure.layout });
+            Plots.supplyDefaults(figure);
+            var data = figure.data || [];
+            var layout = figure.layout || {};
+            layout._basePlotModules = figure._fullLayout._basePlotModules;
+            layout._modules = figure._fullLayout._modules;
+            var template = {
+              data: {},
+              layout: {}
+            };
+            data.forEach(function(trace) {
+              var traceTemplate = {};
+              walkStyleKeys(trace, traceTemplate, getTraceInfo.bind(null, trace));
+              var traceType2 = Lib.coerce(trace, {}, plotAttributes, "type");
+              var typeTemplates2 = template.data[traceType2];
+              if (!typeTemplates2) typeTemplates2 = template.data[traceType2] = [];
+              typeTemplates2.push(traceTemplate);
+            });
+            walkStyleKeys(layout, template.layout, getLayoutInfo.bind(null, layout));
+            delete template.layout.template;
+            var oldTemplate = layout.template;
+            if (isPlainObject2(oldTemplate)) {
+              var oldLayoutTemplate = oldTemplate.layout;
+              var i2, traceType, oldTypeTemplates, oldTypeLen, typeTemplates, typeLen;
+              if (isPlainObject2(oldLayoutTemplate)) {
+                mergeTemplates(oldLayoutTemplate, template.layout);
+              }
+              var oldDataTemplate = oldTemplate.data;
+              if (isPlainObject2(oldDataTemplate)) {
+                for (traceType in template.data) {
+                  oldTypeTemplates = oldDataTemplate[traceType];
+                  if (Array.isArray(oldTypeTemplates)) {
+                    typeTemplates = template.data[traceType];
+                    typeLen = typeTemplates.length;
+                    oldTypeLen = oldTypeTemplates.length;
+                    for (i2 = 0; i2 < typeLen; i2++) {
+                      mergeTemplates(oldTypeTemplates[i2 % oldTypeLen], typeTemplates[i2]);
+                    }
+                    for (i2 = typeLen; i2 < oldTypeLen; i2++) {
+                      typeTemplates.push(Lib.extendDeep({}, oldTypeTemplates[i2]));
+                    }
+                  }
+                }
+                for (traceType in oldDataTemplate) {
+                  if (!(traceType in template.data)) {
+                    template.data[traceType] = Lib.extendDeep([], oldDataTemplate[traceType]);
+                  }
+                }
+              }
+            }
+            return template;
+          };
+          function mergeTemplates(oldTemplate, newTemplate) {
+            oldTemplate = Lib.extendDeep({}, oldTemplate);
+            var oldKeys = Object.keys(oldTemplate).sort();
+            var i2, j2;
+            function mergeOne(oldVal2, newVal, key3) {
+              if (isPlainObject2(newVal) && isPlainObject2(oldVal2)) {
+                mergeTemplates(oldVal2, newVal);
+              } else if (Array.isArray(newVal) && Array.isArray(oldVal2)) {
+                var templater = Template.arrayTemplater({ _template: oldTemplate }, key3);
+                for (j2 = 0; j2 < newVal.length; j2++) {
+                  var item = newVal[j2];
+                  var oldItem = templater.newItem(item)._template;
+                  if (oldItem) mergeTemplates(oldItem, item);
+                }
+                var defaultItems = templater.defaultItems();
+                for (j2 = 0; j2 < defaultItems.length; j2++) newVal.push(defaultItems[j2]._template);
+                for (j2 = 0; j2 < newVal.length; j2++) delete newVal[j2].templateitemname;
+              }
+            }
+            for (i2 = 0; i2 < oldKeys.length; i2++) {
+              var key = oldKeys[i2];
+              var oldVal = oldTemplate[key];
+              if (key in newTemplate) {
+                mergeOne(oldVal, newTemplate[key], key);
+              } else newTemplate[key] = oldVal;
+              if (getBaseKey(key) === key) {
+                for (var key2 in newTemplate) {
+                  var baseKey2 = getBaseKey(key2);
+                  if (key2 !== baseKey2 && baseKey2 === key && !(key2 in oldTemplate)) {
+                    mergeOne(oldVal, newTemplate[key2], key);
+                  }
+                }
+              }
+            }
+          }
+          function getBaseKey(key) {
+            return key.replace(/[0-9]+$/, "");
+          }
+          function walkStyleKeys(parent, templateOut, getAttributeInfo, path, basePath) {
+            var pathAttr = basePath && getAttributeInfo(basePath);
+            for (var key in parent) {
+              var child = parent[key];
+              var nextPath = getNextPath(parent, key, path);
+              var nextBasePath = getNextPath(parent, key, basePath);
+              var attr = getAttributeInfo(nextBasePath);
+              if (!attr) {
+                var baseKey = getBaseKey(key);
+                if (baseKey !== key) {
+                  nextBasePath = getNextPath(parent, baseKey, basePath);
+                  attr = getAttributeInfo(nextBasePath);
+                }
+              }
+              if (pathAttr && pathAttr === attr) continue;
+              if (!attr || attr._noTemplating || attr.valType === "data_array" || attr.arrayOk && Array.isArray(child)) {
+                continue;
+              }
+              if (!attr.valType && isPlainObject2(child)) {
+                walkStyleKeys(child, templateOut, getAttributeInfo, nextPath, nextBasePath);
+              } else if (attr._isLinkedToArray && Array.isArray(child)) {
+                var dfltDone = false;
+                var namedIndex = 0;
+                var usedNames = {};
+                for (var i2 = 0; i2 < child.length; i2++) {
+                  var item = child[i2];
+                  if (isPlainObject2(item)) {
+                    var name2 = item.name;
+                    if (name2) {
+                      if (!usedNames[name2]) {
+                        walkStyleKeys(
+                          item,
+                          templateOut,
+                          getAttributeInfo,
+                          getNextPath(child, namedIndex, nextPath),
+                          getNextPath(child, namedIndex, nextBasePath)
+                        );
+                        namedIndex++;
+                        usedNames[name2] = 1;
+                      }
+                    } else if (!dfltDone) {
+                      var dfltKey = Template.arrayDefaultKey(key);
+                      var dfltPath = getNextPath(parent, dfltKey, path);
+                      var pathInArray = getNextPath(child, namedIndex, nextPath);
+                      walkStyleKeys(
+                        item,
+                        templateOut,
+                        getAttributeInfo,
+                        pathInArray,
+                        getNextPath(child, namedIndex, nextBasePath)
+                      );
+                      var itemPropInArray = Lib.nestedProperty(templateOut, pathInArray);
+                      var dfltProp = Lib.nestedProperty(templateOut, dfltPath);
+                      dfltProp.set(itemPropInArray.get());
+                      itemPropInArray.set(null);
+                      dfltDone = true;
+                    }
+                  }
+                }
+              } else {
+                var templateProp = Lib.nestedProperty(templateOut, nextPath);
+                templateProp.set(child);
+              }
+            }
+          }
+          function getLayoutInfo(layout, path) {
+            return PlotSchema.getLayoutValObject(
+              layout,
+              Lib.nestedProperty({}, path).parts
+            );
+          }
+          function getTraceInfo(trace, path) {
+            return PlotSchema.getTraceValObject(
+              trace,
+              Lib.nestedProperty({}, path).parts
+            );
+          }
+          function getNextPath(parent, key, path) {
+            var nextPath;
+            if (!path) nextPath = key;
+            else if (Array.isArray(parent)) nextPath = path + "[" + key + "]";
+            else nextPath = path + "." + key;
+            return nextPath;
+          }
+          exports.validateTemplate = function(figureIn, template) {
+            var figure = Lib.extendDeep({}, {
+              _context: dfltConfig,
+              data: figureIn.data,
+              layout: figureIn.layout
+            });
+            var layout = figure.layout || {};
+            if (!isPlainObject2(template)) template = layout.template || {};
+            var layoutTemplate = template.layout;
+            var dataTemplate = template.data;
+            var errorList = [];
+            figure.layout = layout;
+            figure.layout.template = template;
+            Plots.supplyDefaults(figure);
+            var fullLayout = figure._fullLayout;
+            var fullData = figure._fullData;
+            var layoutPaths = {};
+            function crawlLayoutForContainers(obj, paths) {
+              for (var key in obj) {
+                if (key.charAt(0) !== "_" && isPlainObject2(obj[key])) {
+                  var baseKey = getBaseKey(key);
+                  var nextPaths = [];
+                  var i22;
+                  for (i22 = 0; i22 < paths.length; i22++) {
+                    nextPaths.push(getNextPath(obj, key, paths[i22]));
+                    if (baseKey !== key) nextPaths.push(getNextPath(obj, baseKey, paths[i22]));
+                  }
+                  for (i22 = 0; i22 < nextPaths.length; i22++) {
+                    layoutPaths[nextPaths[i22]] = 1;
+                  }
+                  crawlLayoutForContainers(obj[key], nextPaths);
+                }
+              }
+            }
+            function crawlLayoutTemplateForContainers(obj, path) {
+              for (var key in obj) {
+                if (key.indexOf("defaults") === -1 && isPlainObject2(obj[key])) {
+                  var nextPath = getNextPath(obj, key, path);
+                  if (layoutPaths[nextPath]) {
+                    crawlLayoutTemplateForContainers(obj[key], nextPath);
+                  } else {
+                    errorList.push({ code: "unused", path: nextPath });
+                  }
+                }
+              }
+            }
+            if (!isPlainObject2(layoutTemplate)) {
+              errorList.push({ code: "layout" });
+            } else {
+              crawlLayoutForContainers(fullLayout, ["layout"]);
+              crawlLayoutTemplateForContainers(layoutTemplate, "layout");
+            }
+            if (!isPlainObject2(dataTemplate)) {
+              errorList.push({ code: "data" });
+            } else {
+              var typeCount = {};
+              var traceType;
+              for (var i2 = 0; i2 < fullData.length; i2++) {
+                var fullTrace = fullData[i2];
+                traceType = fullTrace.type;
+                typeCount[traceType] = (typeCount[traceType] || 0) + 1;
+                if (!fullTrace._fullInput._template) {
+                  errorList.push({
+                    code: "missing",
+                    index: fullTrace.index,
+                    traceType
+                  });
+                }
+              }
+              for (traceType in dataTemplate) {
+                var templateCount = dataTemplate[traceType].length;
+                var dataCount = typeCount[traceType] || 0;
+                if (templateCount > dataCount) {
+                  errorList.push({
+                    code: "unused",
+                    traceType,
+                    templateCount,
+                    dataCount
+                  });
+                } else if (dataCount > templateCount) {
+                  errorList.push({
+                    code: "reused",
+                    traceType,
+                    templateCount,
+                    dataCount
+                  });
+                }
+              }
+            }
+            function crawlForMissingTemplates(obj, path) {
+              for (var key in obj) {
+                if (key.charAt(0) === "_") continue;
+                var val = obj[key];
+                var nextPath = getNextPath(obj, key, path);
+                if (isPlainObject2(val)) {
+                  if (Array.isArray(obj) && val._template === false && val.templateitemname) {
+                    errorList.push({
+                      code: "missing",
+                      path: nextPath,
+                      templateitemname: val.templateitemname
+                    });
+                  }
+                  crawlForMissingTemplates(val, nextPath);
+                } else if (Array.isArray(val) && hasPlainObject(val)) {
+                  crawlForMissingTemplates(val, nextPath);
+                }
+              }
+            }
+            crawlForMissingTemplates({ data: fullData, layout: fullLayout }, "");
+            if (errorList.length) return errorList.map(format);
+          };
+          function hasPlainObject(arr) {
+            for (var i2 = 0; i2 < arr.length; i2++) {
+              if (isPlainObject2(arr[i2])) return true;
+            }
+          }
+          function format(opts) {
+            var msg;
+            switch (opts.code) {
+              case "data":
+                msg = "The template has no key data.";
+                break;
+              case "layout":
+                msg = "The template has no key layout.";
+                break;
+              case "missing":
+                if (opts.path) {
+                  msg = "There are no templates for item " + opts.path + " with name " + opts.templateitemname;
+                } else {
+                  msg = "There are no templates for trace " + opts.index + ", of type " + opts.traceType + ".";
+                }
+                break;
+              case "unused":
+                if (opts.path) {
+                  msg = "The template item at " + opts.path + " was not used in constructing the plot.";
+                } else if (opts.dataCount) {
+                  msg = "Some of the templates of type " + opts.traceType + " were not used. The template has " + opts.templateCount + " traces, the data only has " + opts.dataCount + " of this type.";
+                } else {
+                  msg = "The template has " + opts.templateCount + " traces of type " + opts.traceType + " but there are none in the data.";
+                }
+                break;
+              case "reused":
+                msg = "Some of the templates of type " + opts.traceType + " were used more than once. The template has " + opts.templateCount + " traces, the data has " + opts.dataCount + " of this type.";
+                break;
+            }
+            opts.msg = msg;
+            return opts;
+          }
+        }
+      });
+      var require_plot_api2 = __commonJS({
+        "src/plot_api/index.js"(exports) {
+          var main = require_plot_api();
+          exports._doPlot = main._doPlot;
+          exports.newPlot = main.newPlot;
+          exports.restyle = main.restyle;
+          exports.relayout = main.relayout;
+          exports.redraw = main.redraw;
+          exports.update = main.update;
+          exports._guiRestyle = main._guiRestyle;
+          exports._guiRelayout = main._guiRelayout;
+          exports._guiUpdate = main._guiUpdate;
+          exports._storeDirectGUIEdit = main._storeDirectGUIEdit;
+          exports.react = main.react;
+          exports.extendTraces = main.extendTraces;
+          exports.prependTraces = main.prependTraces;
+          exports.addTraces = main.addTraces;
+          exports.deleteTraces = main.deleteTraces;
+          exports.moveTraces = main.moveTraces;
+          exports.purge = main.purge;
+          exports.addFrames = main.addFrames;
+          exports.deleteFrames = main.deleteFrames;
+          exports.animate = main.animate;
+          exports.setPlotConfig = main.setPlotConfig;
+          var getGraphDiv = require_dom().getGraphDiv;
+          var eraseActiveShape = require_draw2().eraseActiveShape;
+          exports.deleteActiveShape = function(gd2) {
+            return eraseActiveShape(getGraphDiv(gd2));
+          };
+          exports.toImage = require_to_image();
+          exports.validate = require_validate();
+          exports.downloadImage = require_download();
+          var templateApi = require_template_api();
+          exports.makeTemplate = templateApi.makeTemplate;
+          exports.validateTemplate = templateApi.validateTemplate;
+        }
+      });
+      var require_xy_defaults = __commonJS({
+        "src/traces/scatter/xy_defaults.js"(exports, module2) {
+          var Lib = require_lib();
+          var Registry = require_registry();
+          module2.exports = function handleXYDefaults(traceIn, traceOut, layout, coerce) {
+            var x2 = coerce("x");
+            var y2 = coerce("y");
+            var len2;
+            var handleCalendarDefaults = Registry.getComponentMethod("calendars", "handleTraceDefaults");
+            handleCalendarDefaults(traceIn, traceOut, ["x", "y"], layout);
+            if (x2) {
+              var xlen = Lib.minRowLength(x2);
+              if (y2) {
+                len2 = Math.min(xlen, Lib.minRowLength(y2));
+              } else {
+                len2 = xlen;
+                coerce("y0");
+                coerce("dy");
+              }
+            } else {
+              if (!y2) return 0;
+              len2 = Lib.minRowLength(y2);
+              coerce("x0");
+              coerce("dx");
+            }
+            traceOut._length = len2;
+            return len2;
+          };
+        }
+      });
+      var require_period_defaults = __commonJS({
+        "src/traces/scatter/period_defaults.js"(exports, module2) {
+          var dateTick0 = require_lib().dateTick0;
+          var numConstants = require_numerical();
+          var ONEWEEK = numConstants.ONEWEEK;
+          function getPeriod0Dflt(period, calendar) {
+            if (period % ONEWEEK === 0) {
+              return dateTick0(calendar, 1);
+            }
+            return dateTick0(calendar, 0);
+          }
+          module2.exports = function handlePeriodDefaults(traceIn, traceOut, layout, coerce, opts) {
+            if (!opts) {
+              opts = {
+                x: true,
+                y: true
+              };
+            }
+            if (opts.x) {
+              var xperiod = coerce("xperiod");
+              if (xperiod) {
+                coerce("xperiod0", getPeriod0Dflt(xperiod, traceOut.xcalendar));
+                coerce("xperiodalignment");
+              }
+            }
+            if (opts.y) {
+              var yperiod = coerce("yperiod");
+              if (yperiod) {
+                coerce("yperiod0", getPeriod0Dflt(yperiod, traceOut.ycalendar));
+                coerce("yperiodalignment");
+              }
+            }
+          };
+        }
+      });
+      var require_stack_defaults = __commonJS({
+        "src/traces/scatter/stack_defaults.js"(exports, module2) {
+          var perStackAttrs = ["orientation", "groupnorm", "stackgaps"];
+          module2.exports = function handleStackDefaults(traceIn, traceOut, layout, coerce) {
+            var stackOpts = layout._scatterStackOpts;
+            var stackGroup = coerce("stackgroup");
+            if (stackGroup) {
+              var subplot = traceOut.xaxis + traceOut.yaxis;
+              var subplotStackOpts = stackOpts[subplot];
+              if (!subplotStackOpts) subplotStackOpts = stackOpts[subplot] = {};
+              var groupOpts = subplotStackOpts[stackGroup];
+              var firstTrace = false;
+              if (groupOpts) {
+                groupOpts.traces.push(traceOut);
+              } else {
+                groupOpts = subplotStackOpts[stackGroup] = {
+                  // keep track of trace indices for use during stacking calculations
+                  // this will be filled in during `calc` and used during `crossTraceCalc`
+                  // so it's OK if we don't recreate it during a non-calc edit
+                  traceIndices: [],
+                  // Hold on to the whole set of prior traces
+                  // First one is most important, so we can clear defaults
+                  // there if we find explicit values only in later traces.
+                  // We're only going to *use* the values stored in groupOpts,
+                  // but for the editor and validate we want things self-consistent
+                  // The full set of traces is used only to fix `fill` default if
+                  // we find `orientation: 'h'` beyond the first trace
+                  traces: [traceOut]
+                };
+                firstTrace = true;
+              }
+              var dflts = {
+                orientation: traceOut.x && !traceOut.y ? "h" : "v"
+              };
+              for (var i2 = 0; i2 < perStackAttrs.length; i2++) {
+                var attr = perStackAttrs[i2];
+                var attrFound = attr + "Found";
+                if (!groupOpts[attrFound]) {
+                  var traceHasAttr = traceIn[attr] !== void 0;
+                  var isOrientation = attr === "orientation";
+                  if (traceHasAttr || firstTrace) {
+                    groupOpts[attr] = coerce(attr, dflts[attr]);
+                    if (isOrientation) {
+                      groupOpts.fillDflt = groupOpts[attr] === "h" ? "tonextx" : "tonexty";
+                    }
+                    if (traceHasAttr) {
+                      groupOpts[attrFound] = true;
+                      if (!firstTrace) {
+                        delete groupOpts.traces[0][attr];
+                        if (isOrientation) {
+                          for (var j2 = 0; j2 < groupOpts.traces.length - 1; j2++) {
+                            var trace2 = groupOpts.traces[j2];
+                            if (trace2._input.fill !== trace2.fill) {
+                              trace2.fill = groupOpts.fillDflt;
+                            }
+                          }
+                        }
+                      }
+                    }
+                  }
+                }
+              }
+              return groupOpts;
+            }
+          };
+        }
+      });
+      var require_marker_defaults = __commonJS({
+        "src/traces/scatter/marker_defaults.js"(exports, module2) {
+          var Color2 = require_color();
+          var hasColorscale = require_helpers().hasColorscale;
+          var colorscaleDefaults = require_defaults2();
+          var subTypes = require_subtypes();
+          module2.exports = function markerDefaults(traceIn, traceOut, defaultColor, layout, coerce, opts = {}) {
+            var isBubble = subTypes.isBubble(traceIn);
+            var lineColor = (traceIn.line || {}).color;
+            var defaultMLC;
+            if (lineColor) defaultColor = lineColor;
+            coerce("marker.symbol");
+            coerce("marker.opacity", isBubble ? 0.7 : 1);
+            coerce("marker.size");
+            if (!opts.noAngle) {
+              coerce("marker.angle");
+              if (!opts.noAngleRef) coerce("marker.angleref");
+              if (!opts.noStandOff) coerce("marker.standoff");
+            }
+            coerce("marker.color", defaultColor);
+            if (hasColorscale(traceIn, "marker")) {
+              colorscaleDefaults(traceIn, traceOut, layout, coerce, { prefix: "marker.", cLetter: "c" });
+            }
+            if (!opts.noSelect) {
+              coerce("selected.marker.color");
+              coerce("unselected.marker.color");
+              coerce("selected.marker.size");
+              coerce("unselected.marker.size");
+            }
+            if (!opts.noLine) {
+              if (lineColor && !Array.isArray(lineColor) && traceOut.marker.color !== lineColor) {
+                defaultMLC = lineColor;
+              } else if (isBubble) {
+                defaultMLC = Color2.background;
+              } else {
+                defaultMLC = Color2.defaultLine;
+              }
+              coerce("marker.line.color", defaultMLC);
+              if (hasColorscale(traceIn, "marker.line")) {
+                colorscaleDefaults(traceIn, traceOut, layout, coerce, { prefix: "marker.line.", cLetter: "c" });
+              }
+              coerce("marker.line.width", isBubble ? 1 : 0);
+              if (!opts.noLineDash) coerce("marker.line.dash");
+            }
+            if (isBubble) {
+              coerce("marker.sizeref");
+              coerce("marker.sizemin");
+              coerce("marker.sizemode");
+            }
+            if (opts.gradient) {
+              var gradientType = coerce("marker.gradient.type");
+              if (gradientType !== "none") coerce("marker.gradient.color");
+            }
+          };
+        }
+      });
+      var require_line_defaults = __commonJS({
+        "src/traces/scatter/line_defaults.js"(exports, module2) {
+          var isArrayOrTypedArray = require_lib().isArrayOrTypedArray;
+          var hasColorscale = require_helpers().hasColorscale;
+          var colorscaleDefaults = require_defaults2();
+          module2.exports = function lineDefaults(traceIn, traceOut, defaultColor, layout, coerce, opts) {
+            if (!opts) opts = {};
+            var markerColor = (traceIn.marker || {}).color;
+            if (markerColor && markerColor._inputArray) markerColor = markerColor._inputArray;
+            coerce("line.color", defaultColor);
+            if (hasColorscale(traceIn, "line")) {
+              colorscaleDefaults(traceIn, traceOut, layout, coerce, { prefix: "line.", cLetter: "c" });
+            } else {
+              var lineColorDflt = (isArrayOrTypedArray(markerColor) ? false : markerColor) || defaultColor;
+              coerce("line.color", lineColorDflt);
+            }
+            coerce("line.width");
+            if (!opts.noDash) coerce("line.dash");
+            if (opts.backoff) coerce("line.backoff");
+          };
+        }
+      });
+      var require_line_shape_defaults = __commonJS({
+        "src/traces/scatter/line_shape_defaults.js"(exports, module2) {
+          module2.exports = function handleLineShapeDefaults(traceIn, traceOut, coerce) {
+            var shape = coerce("line.shape");
+            if (shape === "spline") coerce("line.smoothing");
+          };
+        }
+      });
+      var require_text_defaults = __commonJS({
+        "src/traces/scatter/text_defaults.js"(exports, module2) {
+          var Lib = require_lib();
+          module2.exports = function(traceIn, traceOut, layout, coerce, opts) {
+            opts = opts || {};
+            coerce("textposition");
+            Lib.coerceFont(coerce, "textfont", opts.font || layout.font, opts);
+            if (!opts.noSelect) {
+              coerce("selected.textfont.color");
+              coerce("unselected.textfont.color");
+            }
+          };
+        }
+      });
+      var require_fillcolor_defaults = __commonJS({
+        "src/traces/scatter/fillcolor_defaults.js"(exports, module2) {
+          var Color2 = require_color();
+          var isArrayOrTypedArray = require_lib().isArrayOrTypedArray;
+          function averageColors(colorscale) {
+            var color22 = Color2.interpolate(colorscale[0][1], colorscale[1][1], 0.5);
+            for (var i2 = 2; i2 < colorscale.length; i2++) {
+              var averageColorI = Color2.interpolate(colorscale[i2 - 1][1], colorscale[i2][1], 0.5);
+              color22 = Color2.interpolate(color22, averageColorI, colorscale[i2 - 1][0] / colorscale[i2][0]);
+            }
+            return color22;
+          }
+          module2.exports = function fillColorDefaults(traceIn, traceOut, defaultColor, coerce, opts) {
+            if (!opts) opts = {};
+            var inheritColorFromMarker = false;
+            if (traceOut.marker) {
+              var markerColor = traceOut.marker.color;
+              var markerLineColor = (traceOut.marker.line || {}).color;
+              if (markerColor && !isArrayOrTypedArray(markerColor)) {
+                inheritColorFromMarker = markerColor;
+              } else if (markerLineColor && !isArrayOrTypedArray(markerLineColor)) {
+                inheritColorFromMarker = markerLineColor;
+              }
+            }
+            var averageGradientColor;
+            if (opts.moduleHasFillgradient) {
+              var gradientOrientation = coerce("fillgradient.type");
+              if (gradientOrientation !== "none") {
+                coerce("fillgradient.start");
+                coerce("fillgradient.stop");
+                var gradientColorscale = coerce("fillgradient.colorscale");
+                if (gradientColorscale) {
+                  averageGradientColor = averageColors(gradientColorscale);
+                }
+              }
+            }
+            coerce("fillcolor", Color2.addOpacity(
+              (traceOut.line || {}).color || inheritColorFromMarker || averageGradientColor || defaultColor,
+              0.5
+            ));
+          };
+        }
+      });
+      var require_defaults8 = __commonJS({
+        "src/traces/scatter/defaults.js"(exports, module2) {
+          var Lib = require_lib();
+          var Registry = require_registry();
+          var attributes = require_attributes12();
+          var constants = require_constants8();
+          var subTypes = require_subtypes();
+          var handleXYDefaults = require_xy_defaults();
+          var handlePeriodDefaults = require_period_defaults();
+          var handleStackDefaults = require_stack_defaults();
+          var handleMarkerDefaults = require_marker_defaults();
+          var handleLineDefaults = require_line_defaults();
+          var handleLineShapeDefaults = require_line_shape_defaults();
+          var handleTextDefaults = require_text_defaults();
+          var handleFillColorDefaults = require_fillcolor_defaults();
+          var coercePattern = require_lib().coercePattern;
+          module2.exports = function supplyDefaults(traceIn, traceOut, defaultColor, layout) {
+            function coerce(attr, dflt) {
+              return Lib.coerce(traceIn, traceOut, attributes, attr, dflt);
+            }
+            var len2 = handleXYDefaults(traceIn, traceOut, layout, coerce);
+            if (!len2) traceOut.visible = false;
+            if (!traceOut.visible) return;
+            handlePeriodDefaults(traceIn, traceOut, layout, coerce);
+            coerce("xhoverformat");
+            coerce("yhoverformat");
+            coerce("zorder");
+            var stackGroupOpts = handleStackDefaults(traceIn, traceOut, layout, coerce);
+            if (layout.scattermode === "group" && traceOut.orientation === void 0) {
+              coerce("orientation", "v");
+            }
+            var defaultMode = !stackGroupOpts && len2 < constants.PTS_LINESONLY ? "lines+markers" : "lines";
+            coerce("text");
+            coerce("hovertext");
+            coerce("mode", defaultMode);
+            if (subTypes.hasMarkers(traceOut)) {
+              handleMarkerDefaults(traceIn, traceOut, defaultColor, layout, coerce, { gradient: true });
+            }
+            if (subTypes.hasLines(traceOut)) {
+              handleLineDefaults(traceIn, traceOut, defaultColor, layout, coerce, { backoff: true });
+              handleLineShapeDefaults(traceIn, traceOut, coerce);
+              coerce("connectgaps");
+              coerce("line.simplify");
+            }
+            if (subTypes.hasText(traceOut)) {
+              coerce("texttemplate");
+              coerce("texttemplatefallback");
+              handleTextDefaults(traceIn, traceOut, layout, coerce);
+            }
+            var dfltHoverOn = [];
+            if (subTypes.hasMarkers(traceOut) || subTypes.hasText(traceOut)) {
+              coerce("cliponaxis");
+              coerce("marker.maxdisplayed");
+              dfltHoverOn.push("points");
+            }
+            coerce("fill", stackGroupOpts ? stackGroupOpts.fillDflt : "none");
+            if (traceOut.fill !== "none") {
+              handleFillColorDefaults(traceIn, traceOut, defaultColor, coerce, {
+                moduleHasFillgradient: true
+              });
+              if (!subTypes.hasLines(traceOut)) handleLineShapeDefaults(traceIn, traceOut, coerce);
+              coercePattern(coerce, "fillpattern", traceOut.fillcolor, false);
+            }
+            var lineColor = (traceOut.line || {}).color;
+            var markerColor = (traceOut.marker || {}).color;
+            if (traceOut.fill === "tonext" || traceOut.fill === "toself") {
+              dfltHoverOn.push("fills");
+            }
+            coerce("hoveron", dfltHoverOn.join("+") || "points");
+            if (traceOut.hoveron !== "fills") {
+              coerce("hovertemplate");
+              coerce("hovertemplatefallback");
+            }
+            var errorBarsSupplyDefaults = Registry.getComponentMethod("errorbars", "supplyDefaults");
+            errorBarsSupplyDefaults(traceIn, traceOut, lineColor || markerColor || defaultColor, { axis: "y" });
+            errorBarsSupplyDefaults(traceIn, traceOut, lineColor || markerColor || defaultColor, { axis: "x", inherit: "y" });
+            Lib.coerceSelectionMarkerOpacity(traceOut, coerce);
+          };
+        }
+      });
+      var require_grouping_defaults = __commonJS({
+        "src/traces/scatter/grouping_defaults.js"(exports, module2) {
+          var getAxisGroup = require_constraints().getAxisGroup;
+          module2.exports = function handleGroupingDefaults(traceIn, traceOut, fullLayout, coerce, barmode) {
+            var orientation = traceOut.orientation;
+            var posAxId = traceOut[{ v: "x", h: "y" }[orientation] + "axis"];
+            var groupId = getAxisGroup(fullLayout, posAxId) + orientation;
+            var alignmentOpts = fullLayout._alignmentOpts || {};
+            var alignmentgroup = coerce("alignmentgroup");
+            var alignmentGroups = alignmentOpts[groupId];
+            if (!alignmentGroups) alignmentGroups = alignmentOpts[groupId] = {};
+            var alignmentGroupOpts = alignmentGroups[alignmentgroup];
+            if (alignmentGroupOpts) {
+              alignmentGroupOpts.traces.push(traceOut);
+            } else {
+              alignmentGroupOpts = alignmentGroups[alignmentgroup] = {
+                traces: [traceOut],
+                alignmentIndex: Object.keys(alignmentGroups).length,
+                offsetGroups: {}
+              };
+            }
+            var offsetgroup = coerce("offsetgroup") || "";
+            var offsetGroups = alignmentGroupOpts.offsetGroups;
+            var offsetGroupOpts = offsetGroups[offsetgroup];
+            traceOut._offsetIndex = 0;
+            if (barmode !== "group" || offsetgroup) {
+              if (!offsetGroupOpts) {
+                offsetGroupOpts = offsetGroups[offsetgroup] = {
+                  offsetIndex: Object.keys(offsetGroups).length
+                };
+              }
+              traceOut._offsetIndex = offsetGroupOpts.offsetIndex;
+            }
+          };
+        }
+      });
+      var require_cross_trace_defaults2 = __commonJS({
+        "src/traces/scatter/cross_trace_defaults.js"(exports, module2) {
+          var Lib = require_lib();
+          var handleGroupingDefaults = require_grouping_defaults();
+          var attributes = require_attributes12();
+          module2.exports = function crossTraceDefaults(fullData, fullLayout) {
+            var traceIn, traceOut, i2;
+            var scattermode = fullLayout.scattermode;
+            function coerce(attr) {
+              return Lib.coerce(traceOut._input, traceOut, attributes, attr);
+            }
+            if (fullLayout.scattermode === "group") {
+              for (i2 = 0; i2 < fullData.length; i2++) {
+                traceOut = fullData[i2];
+                if (traceOut.type === "scatter") {
+                  traceIn = traceOut._input;
+                  handleGroupingDefaults(traceIn, traceOut, fullLayout, coerce, scattermode);
+                }
+              }
+            }
+            for (i2 = 0; i2 < fullData.length; i2++) {
+              var tracei = fullData[i2];
+              if (tracei.type !== "scatter") continue;
+              var filli = tracei.fill;
+              if (filli === "none" || filli === "toself") continue;
+              tracei.opacity = void 0;
+              if (filli === "tonexty" || filli === "tonextx") {
+                for (var j2 = i2 - 1; j2 >= 0; j2--) {
+                  var tracej = fullData[j2];
+                  if (tracej.type === "scatter" && tracej.xaxis === tracei.xaxis && tracej.yaxis === tracei.yaxis) {
+                    tracej.opacity = void 0;
+                    break;
+                  }
+                }
+              }
+            }
+          };
+        }
+      });
+      var require_layout_defaults3 = __commonJS({
+        "src/traces/scatter/layout_defaults.js"(exports, module2) {
+          var Lib = require_lib();
+          var layoutAttributes = require_layout_attributes3();
+          module2.exports = function(layoutIn, layoutOut) {
+            function coerce(attr, dflt) {
+              return Lib.coerce(layoutIn, layoutOut, layoutAttributes, attr, dflt);
+            }
+            var groupBarmode = layoutOut.barmode === "group";
+            if (layoutOut.scattermode === "group") {
+              coerce("scattergap", groupBarmode ? layoutOut.bargap : 0.2);
+            }
+          };
+        }
+      });
+      var require_align_period = __commonJS({
+        "src/plots/cartesian/align_period.js"(exports, module2) {
+          var isNumeric = require_fast_isnumeric();
+          var Lib = require_lib();
+          var dateTime2ms = Lib.dateTime2ms;
+          var incrementMonth = Lib.incrementMonth;
+          var constants = require_numerical();
+          var ONEAVGMONTH = constants.ONEAVGMONTH;
+          module2.exports = function alignPeriod(trace, ax, axLetter, vals) {
+            if (ax.type !== "date") return { vals };
+            var alignment = trace[axLetter + "periodalignment"];
+            if (!alignment) return { vals };
+            var period = trace[axLetter + "period"];
+            var mPeriod;
+            if (isNumeric(period)) {
+              period = +period;
+              if (period <= 0) return { vals };
+            } else if (typeof period === "string" && period.charAt(0) === "M") {
+              var n2 = +period.substring(1);
+              if (n2 > 0 && Math.round(n2) === n2) {
+                mPeriod = n2;
+              } else return { vals };
+            }
+            var calendar = ax.calendar;
+            var isStart = "start" === alignment;
+            var isEnd = "end" === alignment;
+            var period0 = trace[axLetter + "period0"];
+            var base = dateTime2ms(period0, calendar) || 0;
+            var newVals = [];
+            var starts = [];
+            var ends = [];
+            var len2 = vals.length;
+            for (var i2 = 0; i2 < len2; i2++) {
+              var v2 = vals[i2];
+              var nEstimated, startTime, endTime;
+              if (mPeriod) {
+                nEstimated = Math.round((v2 - base) / (mPeriod * ONEAVGMONTH));
+                endTime = incrementMonth(base, mPeriod * nEstimated, calendar);
+                while (endTime > v2) {
+                  endTime = incrementMonth(endTime, -mPeriod, calendar);
+                }
+                while (endTime <= v2) {
+                  endTime = incrementMonth(endTime, mPeriod, calendar);
+                }
+                startTime = incrementMonth(endTime, -mPeriod, calendar);
+              } else {
+                nEstimated = Math.round((v2 - base) / period);
+                endTime = base + nEstimated * period;
+                while (endTime > v2) {
+                  endTime -= period;
+                }
+                while (endTime <= v2) {
+                  endTime += period;
+                }
+                startTime = endTime - period;
+              }
+              newVals[i2] = isStart ? startTime : isEnd ? endTime : (startTime + endTime) / 2;
+              starts[i2] = startTime;
+              ends[i2] = endTime;
+            }
+            return {
+              vals: newVals,
+              starts,
+              ends
+            };
+          };
+        }
+      });
+      var require_colorscale_calc = __commonJS({
+        "src/traces/scatter/colorscale_calc.js"(exports, module2) {
+          var hasColorscale = require_helpers().hasColorscale;
+          var calcColorscale = require_calc();
+          var subTypes = require_subtypes();
+          module2.exports = function calcMarkerColorscale(gd2, trace) {
+            if (subTypes.hasLines(trace) && hasColorscale(trace, "line")) {
+              calcColorscale(gd2, trace, {
+                vals: trace.line.color,
+                containerStr: "line",
+                cLetter: "c"
+              });
+            }
+            if (subTypes.hasMarkers(trace)) {
+              if (hasColorscale(trace, "marker")) {
+                calcColorscale(gd2, trace, {
+                  vals: trace.marker.color,
+                  containerStr: "marker",
+                  cLetter: "c"
+                });
+              }
+              if (hasColorscale(trace, "marker.line")) {
+                calcColorscale(gd2, trace, {
+                  vals: trace.marker.line.color,
+                  containerStr: "marker.line",
+                  cLetter: "c"
+                });
+              }
+            }
+          };
+        }
+      });
+      var require_arrays_to_calcdata = __commonJS({
+        "src/traces/scatter/arrays_to_calcdata.js"(exports, module2) {
+          var Lib = require_lib();
+          module2.exports = function arraysToCalcdata(cd2, trace) {
+            for (var i2 = 0; i2 < cd2.length; i2++) cd2[i2].i = i2;
+            Lib.mergeArray(trace.text, cd2, "tx");
+            Lib.mergeArray(trace.texttemplate, cd2, "txt");
+            Lib.mergeArray(trace.hovertext, cd2, "htx");
+            Lib.mergeArray(trace.customdata, cd2, "data");
+            Lib.mergeArray(trace.textposition, cd2, "tp");
+            if (trace.textfont) {
+              Lib.mergeArrayCastPositive(trace.textfont.size, cd2, "ts");
+              Lib.mergeArray(trace.textfont.color, cd2, "tc");
+              Lib.mergeArray(trace.textfont.family, cd2, "tf");
+              Lib.mergeArray(trace.textfont.weight, cd2, "tw");
+              Lib.mergeArray(trace.textfont.style, cd2, "ty");
+              Lib.mergeArray(trace.textfont.variant, cd2, "tv");
+              Lib.mergeArray(trace.textfont.textcase, cd2, "tC");
+              Lib.mergeArray(trace.textfont.lineposition, cd2, "tE");
+              Lib.mergeArray(trace.textfont.shadow, cd2, "tS");
+            }
+            var marker = trace.marker;
+            if (marker) {
+              Lib.mergeArrayCastPositive(marker.size, cd2, "ms");
+              Lib.mergeArrayCastPositive(marker.opacity, cd2, "mo");
+              Lib.mergeArray(marker.symbol, cd2, "mx");
+              Lib.mergeArray(marker.angle, cd2, "ma");
+              Lib.mergeArray(marker.standoff, cd2, "mf");
+              Lib.mergeArray(marker.color, cd2, "mc");
+              var markerLine = marker.line;
+              if (marker.line) {
+                Lib.mergeArray(markerLine.color, cd2, "mlc");
+                Lib.mergeArrayCastPositive(markerLine.width, cd2, "mlw");
+                Lib.mergeArray(markerLine.dash, cd2, "mld");
+              }
+              var markerGradient = marker.gradient;
+              if (markerGradient && markerGradient.type !== "none") {
+                Lib.mergeArray(markerGradient.type, cd2, "mgt");
+                Lib.mergeArray(markerGradient.color, cd2, "mgc");
+              }
+            }
+          };
+        }
+      });
+      var require_calc_selection = __commonJS({
+        "src/traces/scatter/calc_selection.js"(exports, module2) {
+          var Lib = require_lib();
+          module2.exports = function calcSelection(cd2, trace) {
+            if (Lib.isArrayOrTypedArray(trace.selectedpoints)) {
+              Lib.tagSelected(cd2, trace);
+            }
+          };
+        }
+      });
+      var require_calc3 = __commonJS({
+        "src/traces/scatter/calc.js"(exports, module2) {
+          var isNumeric = require_fast_isnumeric();
+          var Lib = require_lib();
+          var Axes = require_axes();
+          var alignPeriod = require_align_period();
+          var BADNUM = require_numerical().BADNUM;
+          var subTypes = require_subtypes();
+          var calcColorscale = require_colorscale_calc();
+          var arraysToCalcdata = require_arrays_to_calcdata();
+          var calcSelection = require_calc_selection();
+          function calc(gd2, trace) {
+            var fullLayout = gd2._fullLayout;
+            var xa = trace._xA = Axes.getFromId(gd2, trace.xaxis || "x", "x");
+            var ya2 = trace._yA = Axes.getFromId(gd2, trace.yaxis || "y", "y");
+            var origX = xa.makeCalcdata(trace, "x");
+            var origY = ya2.makeCalcdata(trace, "y");
+            var xObj = alignPeriod(trace, xa, "x", origX);
+            var yObj = alignPeriod(trace, ya2, "y", origY);
+            var x2 = xObj.vals;
+            var y2 = yObj.vals;
+            var serieslen = trace._length;
+            var cd2 = new Array(serieslen);
+            var ids = trace.ids;
+            var stackGroupOpts = getStackOpts(trace, fullLayout, xa, ya2);
+            var interpolateGaps = false;
+            var isV, i2, j2, k2, interpolate, vali;
+            setFirstScatter(fullLayout, trace);
+            var xAttr = "x";
+            var yAttr = "y";
+            var posAttr;
+            if (stackGroupOpts) {
+              Lib.pushUnique(stackGroupOpts.traceIndices, trace.index);
+              isV = stackGroupOpts.orientation === "v";
+              if (isV) {
+                yAttr = "s";
+                posAttr = "x";
+              } else {
+                xAttr = "s";
+                posAttr = "y";
+              }
+              interpolate = stackGroupOpts.stackgaps === "interpolate";
+            } else {
+              var ppad = calcMarkerSize(trace, serieslen);
+              calcAxisExpansion(gd2, trace, xa, ya2, x2, y2, ppad);
+            }
+            var hasPeriodX = !!trace.xperiodalignment;
+            var hasPeriodY = !!trace.yperiodalignment;
+            for (i2 = 0; i2 < serieslen; i2++) {
+              var cdi = cd2[i2] = {};
+              var xValid = isNumeric(x2[i2]);
+              var yValid = isNumeric(y2[i2]);
+              if (xValid && yValid) {
+                cdi[xAttr] = x2[i2];
+                cdi[yAttr] = y2[i2];
+                if (hasPeriodX) {
+                  cdi.orig_x = origX[i2];
+                  cdi.xEnd = xObj.ends[i2];
+                  cdi.xStart = xObj.starts[i2];
+                }
+                if (hasPeriodY) {
+                  cdi.orig_y = origY[i2];
+                  cdi.yEnd = yObj.ends[i2];
+                  cdi.yStart = yObj.starts[i2];
+                }
+              } else if (stackGroupOpts && (isV ? xValid : yValid)) {
+                cdi[posAttr] = isV ? x2[i2] : y2[i2];
+                cdi.gap = true;
+                if (interpolate) {
+                  cdi.s = BADNUM;
+                  interpolateGaps = true;
+                } else {
+                  cdi.s = 0;
+                }
+              } else {
+                cdi[xAttr] = cdi[yAttr] = BADNUM;
+              }
+              if (ids) {
+                cdi.id = String(ids[i2]);
+              }
+            }
+            arraysToCalcdata(cd2, trace);
+            calcColorscale(gd2, trace);
+            calcSelection(cd2, trace);
+            if (stackGroupOpts) {
+              i2 = 0;
+              while (i2 < cd2.length) {
+                if (cd2[i2][posAttr] === BADNUM) {
+                  cd2.splice(i2, 1);
+                } else i2++;
+              }
+              Lib.sort(cd2, function(a2, b2) {
+                return a2[posAttr] - b2[posAttr] || a2.i - b2.i;
+              });
+              if (interpolateGaps) {
+                i2 = 0;
+                while (i2 < cd2.length - 1 && cd2[i2].gap) {
+                  i2++;
+                }
+                vali = cd2[i2].s;
+                if (!vali) vali = cd2[i2].s = 0;
+                for (j2 = 0; j2 < i2; j2++) {
+                  cd2[j2].s = vali;
+                }
+                k2 = cd2.length - 1;
+                while (k2 > i2 && cd2[k2].gap) {
+                  k2--;
+                }
+                vali = cd2[k2].s;
+                for (j2 = cd2.length - 1; j2 > k2; j2--) {
+                  cd2[j2].s = vali;
+                }
+                while (i2 < k2) {
+                  i2++;
+                  if (cd2[i2].gap) {
+                    j2 = i2 + 1;
+                    while (cd2[j2].gap) {
+                      j2++;
+                    }
+                    var pos0 = cd2[i2 - 1][posAttr];
+                    var size0 = cd2[i2 - 1].s;
+                    var m2 = (cd2[j2].s - size0) / (cd2[j2][posAttr] - pos0);
+                    while (i2 < j2) {
+                      cd2[i2].s = size0 + (cd2[i2][posAttr] - pos0) * m2;
+                      i2++;
+                    }
+                  }
+                }
+              }
+            }
+            return cd2;
+          }
+          function calcAxisExpansion(gd2, trace, xa, ya2, x2, y2, ppad) {
+            var serieslen = trace._length;
+            var fullLayout = gd2._fullLayout;
+            var xId = xa._id;
+            var yId = ya2._id;
+            var firstScatter = fullLayout._firstScatter[firstScatterGroup(trace)] === trace.uid;
+            var stackOrientation = (getStackOpts(trace, fullLayout, xa, ya2) || {}).orientation;
+            var fill = trace.fill;
+            xa._minDtick = 0;
+            ya2._minDtick = 0;
+            var xOptions = { padded: true };
+            var yOptions = { padded: true };
+            if (ppad) {
+              xOptions.ppad = yOptions.ppad = ppad;
+            }
+            var openEnded = serieslen < 2 || x2[0] !== x2[serieslen - 1] || y2[0] !== y2[serieslen - 1];
+            if (openEnded && (fill === "tozerox" || fill === "tonextx" && (firstScatter || stackOrientation === "h"))) {
+              xOptions.tozero = true;
+            } else if (!(trace.error_y || {}).visible && // if no error bars, markers or text, or fill to y=0 remove x padding
+            (fill === "tonexty" || fill === "tozeroy" || !subTypes.hasMarkers(trace) && !subTypes.hasText(trace))) {
+              xOptions.padded = false;
+              xOptions.ppad = 0;
+            }
+            if (openEnded && (fill === "tozeroy" || fill === "tonexty" && (firstScatter || stackOrientation === "v"))) {
+              yOptions.tozero = true;
+            } else if (fill === "tonextx" || fill === "tozerox") {
+              yOptions.padded = false;
+            }
+            if (xId) trace._extremes[xId] = Axes.findExtremes(xa, x2, xOptions);
+            if (yId) trace._extremes[yId] = Axes.findExtremes(ya2, y2, yOptions);
+          }
+          function calcMarkerSize(trace, serieslen) {
+            if (!subTypes.hasMarkers(trace)) return;
+            var marker = trace.marker;
+            var sizeref = 1.6 * (trace.marker.sizeref || 1);
+            var markerTrans;
+            if (trace.marker.sizemode === "area") {
+              markerTrans = function(v2) {
+                return Math.max(Math.sqrt((v2 || 0) / sizeref), 3);
+              };
+            } else {
+              markerTrans = function(v2) {
+                return Math.max((v2 || 0) / sizeref, 3);
+              };
+            }
+            if (Lib.isArrayOrTypedArray(marker.size)) {
+              var ax = { type: "linear" };
+              Axes.setConvert(ax);
+              var s2 = ax.makeCalcdata(trace.marker, "size");
+              var sizeOut = new Array(serieslen);
+              for (var i2 = 0; i2 < serieslen; i2++) {
+                sizeOut[i2] = markerTrans(s2[i2]);
+              }
+              return sizeOut;
+            } else {
+              return markerTrans(marker.size);
+            }
+          }
+          function setFirstScatter(fullLayout, trace) {
+            var group = firstScatterGroup(trace);
+            var firstScatter = fullLayout._firstScatter;
+            if (!firstScatter[group]) firstScatter[group] = trace.uid;
+          }
+          function firstScatterGroup(trace) {
+            var stackGroup = trace.stackgroup;
+            return trace.xaxis + trace.yaxis + trace.type + (stackGroup ? "-" + stackGroup : "");
+          }
+          function getStackOpts(trace, fullLayout, xa, ya2) {
+            var stackGroup = trace.stackgroup;
+            if (!stackGroup) return;
+            var stackOpts = fullLayout._scatterStackOpts[xa._id + ya2._id][stackGroup];
+            var stackAx = stackOpts.orientation === "v" ? ya2 : xa;
+            if (stackAx.type === "linear" || stackAx.type === "log") return stackOpts;
+          }
+          module2.exports = {
+            calc,
+            calcMarkerSize,
+            calcAxisExpansion,
+            setFirstScatter,
+            getStackOpts
+          };
+        }
+      });
+      var require_sieve = __commonJS({
+        "src/traces/bar/sieve.js"(exports, module2) {
+          module2.exports = Sieve;
+          var distinctVals = require_lib().distinctVals;
+          function Sieve(traces, opts) {
+            this.traces = traces;
+            this.sepNegVal = opts.sepNegVal;
+            this.overlapNoMerge = opts.overlapNoMerge;
+            var width1 = Infinity;
+            var axLetter = opts.posAxis._id.charAt(0);
+            var positions = [];
+            for (var i2 = 0; i2 < traces.length; i2++) {
+              var trace = traces[i2];
+              for (var j2 = 0; j2 < trace.length; j2++) {
+                var bar = trace[j2];
+                var pos = bar.p;
+                if (pos === void 0) {
+                  pos = bar[axLetter];
+                }
+                if (pos !== void 0) positions.push(pos);
+              }
+              if (trace[0] && trace[0].width1) {
+                width1 = Math.min(trace[0].width1, width1);
+              }
+            }
+            this.positions = positions;
+            var dv = distinctVals(positions);
+            this.distinctPositions = dv.vals;
+            if (dv.vals.length === 1 && width1 !== Infinity) this.minDiff = width1;
+            else this.minDiff = Math.min(dv.minDiff, width1);
+            var type = (opts.posAxis || {}).type;
+            if (type === "category" || type === "multicategory") {
+              this.minDiff = 1;
+            }
+            this.binWidth = this.minDiff;
+            this.bins = {};
+          }
+          Sieve.prototype.put = function put(position, group, value) {
+            var label = this.getLabel(position, group, value);
+            var oldValue = this.bins[label] || 0;
+            this.bins[label] = oldValue + value;
+            return oldValue;
+          };
+          Sieve.prototype.get = function get(position, group, value) {
+            var label = this.getLabel(position, group, value);
+            return this.bins[label] || 0;
+          };
+          Sieve.prototype.getLabel = function getLabel(position, group, value) {
+            var prefix = value < 0 && this.sepNegVal ? "v" : "^";
+            var label = this.overlapNoMerge ? position : Math.round(position / this.binWidth);
+            return prefix + label + "g" + group;
+          };
+        }
+      });
+      var require_constants9 = __commonJS({
+        "src/traces/bar/constants.js"(exports, module2) {
+          module2.exports = {
+            // padding in pixels around text
+            TEXTPAD: 3,
+            // 'value' and 'label' are not really necessary for bar traces,
+            // but they were made available to `texttemplate` (maybe by accident)
+            // via tokens `%{value}` and `%{label}` starting in 1.50.0,
+            // so let's include them in the event data also.
+            eventDataKeys: ["value", "label"]
+          };
+        }
+      });
+      var require_cross_trace_calc = __commonJS({
+        "src/traces/bar/cross_trace_calc.js"(exports, module2) {
+          var isNumeric = require_fast_isnumeric();
+          var { isArrayOrTypedArray } = require_lib();
+          var { BADNUM } = require_numerical();
+          var Registry = require_registry();
+          var Axes = require_axes();
+          var { getAxisGroup } = require_constraints();
+          var Sieve = require_sieve();
+          var { TEXTPAD } = require_constants9();
+          var { LINE_SPACING } = require_alignment();
+          var { BR_TAG_ALL } = require_svg_text_utils();
+          function crossTraceCalc(gd2, plotinfo) {
+            var xa = plotinfo.xaxis;
+            var ya2 = plotinfo.yaxis;
+            var fullLayout = gd2._fullLayout;
+            var fullTraces = gd2._fullData;
+            var calcTraces = gd2.calcdata;
+            var calcTracesHorz = [];
+            var calcTracesVert = [];
+            for (var i2 = 0; i2 < fullTraces.length; i2++) {
+              var fullTrace = fullTraces[i2];
+              if (fullTrace.visible === true && Registry.traceIs(fullTrace, "bar") && fullTrace.xaxis === xa._id && fullTrace.yaxis === ya2._id) {
+                if (fullTrace.orientation === "h") {
+                  calcTracesHorz.push(calcTraces[i2]);
+                } else {
+                  calcTracesVert.push(calcTraces[i2]);
+                }
+                if (fullTrace._computePh) {
+                  var cd2 = gd2.calcdata[i2];
+                  for (var j2 = 0; j2 < cd2.length; j2++) {
+                    if (typeof cd2[j2].ph0 === "function") cd2[j2].ph0 = cd2[j2].ph0();
+                    if (typeof cd2[j2].ph1 === "function") cd2[j2].ph1 = cd2[j2].ph1();
+                  }
+                }
+              }
+            }
+            var opts = {
+              xCat: xa.type === "category" || xa.type === "multicategory",
+              yCat: ya2.type === "category" || ya2.type === "multicategory",
+              mode: fullLayout.barmode,
+              norm: fullLayout.barnorm,
+              gap: fullLayout.bargap,
+              groupgap: fullLayout.bargroupgap
+            };
+            setGroupPositions(gd2, xa, ya2, calcTracesVert, opts);
+            setGroupPositions(gd2, ya2, xa, calcTracesHorz, opts);
+          }
+          function setGroupPositions(gd2, pa2, sa2, calcTraces, opts) {
+            if (!calcTraces.length) return;
+            var excluded;
+            var included;
+            var i2, calcTrace, fullTrace;
+            initBase(sa2, calcTraces);
+            switch (opts.mode) {
+              case "overlay":
+                setGroupPositionsInOverlayMode(gd2, pa2, sa2, calcTraces, opts);
+                break;
+              case "group":
+                excluded = [];
+                included = [];
+                for (i2 = 0; i2 < calcTraces.length; i2++) {
+                  calcTrace = calcTraces[i2];
+                  fullTrace = calcTrace[0].trace;
+                  if (fullTrace.offset === void 0) included.push(calcTrace);
+                  else excluded.push(calcTrace);
+                }
+                if (included.length) {
+                  setGroupPositionsInGroupMode(gd2, pa2, sa2, included, opts);
+                }
+                if (excluded.length) {
+                  setGroupPositionsInOverlayMode(gd2, pa2, sa2, excluded, opts);
+                }
+                break;
+              case "stack":
+              case "relative":
+                excluded = [];
+                included = [];
+                for (i2 = 0; i2 < calcTraces.length; i2++) {
+                  calcTrace = calcTraces[i2];
+                  fullTrace = calcTrace[0].trace;
+                  if (fullTrace.base === void 0) included.push(calcTrace);
+                  else excluded.push(calcTrace);
+                }
+                standardizeCornerradius(included);
+                if (included.length) {
+                  setGroupPositionsInStackOrRelativeMode(gd2, pa2, sa2, included, opts);
+                }
+                if (excluded.length) {
+                  setGroupPositionsInOverlayMode(gd2, pa2, sa2, excluded, opts);
+                }
+                break;
+            }
+            setCornerradius(calcTraces);
+            collectExtents(calcTraces, pa2);
+          }
+          function setCornerradius(calcTraces) {
+            var i2, calcTrace, fullTrace, t4, cr, crValue, crForm;
+            for (i2 = 0; i2 < calcTraces.length; i2++) {
+              calcTrace = calcTraces[i2];
+              fullTrace = calcTrace[0].trace;
+              t4 = calcTrace[0].t;
+              if (t4.cornerradiusvalue === void 0) {
+                cr = fullTrace.marker ? fullTrace.marker.cornerradius : void 0;
+                if (cr !== void 0) {
+                  crValue = isNumeric(cr) ? +cr : +cr.slice(0, -1);
+                  crForm = isNumeric(cr) ? "px" : "%";
+                  t4.cornerradiusvalue = crValue;
+                  t4.cornerradiusform = crForm;
+                }
+              }
+            }
+          }
+          function standardizeCornerradius(calcTraces) {
+            if (calcTraces.length < 2) return;
+            var i2, calcTrace, fullTrace, t4;
+            var cr, crValue, crForm;
+            for (i2 = 0; i2 < calcTraces.length; i2++) {
+              calcTrace = calcTraces[i2];
+              fullTrace = calcTrace[0].trace;
+              cr = fullTrace.marker ? fullTrace.marker.cornerradius : void 0;
+              if (cr !== void 0) break;
+            }
+            if (cr !== void 0) {
+              crValue = isNumeric(cr) ? +cr : +cr.slice(0, -1);
+              crForm = isNumeric(cr) ? "px" : "%";
+              for (i2 = 0; i2 < calcTraces.length; i2++) {
+                calcTrace = calcTraces[i2];
+                t4 = calcTrace[0].t;
+                t4.cornerradiusvalue = crValue;
+                t4.cornerradiusform = crForm;
+              }
+            }
+          }
+          function initBase(sa2, calcTraces) {
+            var i2, j2;
+            for (i2 = 0; i2 < calcTraces.length; i2++) {
+              var cd2 = calcTraces[i2];
+              var trace = cd2[0].trace;
+              var base = trace.type === "funnel" ? trace._base : trace.base;
+              var b2;
+              var scalendar = trace.orientation === "h" ? trace.xcalendar : trace.ycalendar;
+              var d2c = sa2.type === "category" || sa2.type === "multicategory" ? function() {
+                return null;
+              } : sa2.d2c;
+              if (isArrayOrTypedArray(base)) {
+                for (j2 = 0; j2 < Math.min(base.length, cd2.length); j2++) {
+                  b2 = d2c(base[j2], 0, scalendar);
+                  if (isNumeric(b2)) {
+                    cd2[j2].b = +b2;
+                    cd2[j2].hasB = 1;
+                  } else cd2[j2].b = 0;
+                }
+                for (; j2 < cd2.length; j2++) {
+                  cd2[j2].b = 0;
+                }
+              } else {
+                b2 = d2c(base, 0, scalendar);
+                var hasBase = isNumeric(b2);
+                b2 = hasBase ? b2 : 0;
+                for (j2 = 0; j2 < cd2.length; j2++) {
+                  cd2[j2].b = b2;
+                  if (hasBase) cd2[j2].hasB = 1;
+                }
+              }
+            }
+          }
+          function setGroupPositionsInOverlayMode(gd2, pa2, sa2, calcTraces, opts) {
+            for (var i2 = 0; i2 < calcTraces.length; i2++) {
+              var calcTrace = calcTraces[i2];
+              var sieve = new Sieve([calcTrace], {
+                posAxis: pa2,
+                sepNegVal: false,
+                overlapNoMerge: !opts.norm
+              });
+              setOffsetAndWidth(gd2, pa2, sieve, opts);
+              if (opts.norm) {
+                sieveBars(sieve);
+                normalizeBars(sa2, sieve, opts);
+              } else {
+                setBaseAndTop(sa2, sieve);
+              }
+            }
+          }
+          function setGroupPositionsInGroupMode(gd2, pa2, sa2, calcTraces, opts) {
+            var sieve = new Sieve(calcTraces, {
+              posAxis: pa2,
+              sepNegVal: false,
+              overlapNoMerge: !opts.norm
+            });
+            setOffsetAndWidth(gd2, pa2, sieve, opts);
+            unhideBarsWithinTrace(sieve, pa2);
+            if (opts.norm) {
+              sieveBars(sieve);
+              normalizeBars(sa2, sieve, opts);
+            } else {
+              setBaseAndTop(sa2, sieve);
+            }
+          }
+          function setGroupPositionsInStackOrRelativeMode(gd2, pa2, sa2, calcTraces, opts) {
+            var sieve = new Sieve(calcTraces, {
+              posAxis: pa2,
+              sepNegVal: opts.mode === "relative",
+              overlapNoMerge: !(opts.norm || opts.mode === "stack" || opts.mode === "relative")
+            });
+            setOffsetAndWidth(gd2, pa2, sieve, opts);
+            stackBars(sa2, sieve, opts);
+            for (var i2 = 0; i2 < calcTraces.length; i2++) {
+              var calcTrace = calcTraces[i2];
+              var offsetIndex = calcTrace[0].t.offsetindex;
+              for (var j2 = 0; j2 < calcTrace.length; j2++) {
+                var bar = calcTrace[j2];
+                if (bar.s !== BADNUM) {
+                  var isOutmostBar = bar.b + bar.s === sieve.get(bar.p, offsetIndex, bar.s);
+                  if (isOutmostBar) bar._outmost = true;
+                }
+              }
+            }
+            if (opts.norm) normalizeBars(sa2, sieve, opts);
+          }
+          function setOffsetAndWidth(gd2, pa2, sieve, opts) {
+            var fullLayout = gd2._fullLayout;
+            var positions = sieve.positions;
+            var distinctPositions = sieve.distinctPositions;
+            var minDiff = sieve.minDiff;
+            var calcTraces = sieve.traces;
+            var nTraces = calcTraces.length;
+            var overlap = positions.length !== distinctPositions.length;
+            var barGroupWidth = minDiff * (1 - opts.gap);
+            var barWidthPlusGap;
+            var barWidth;
+            var offsetFromCenter;
+            var alignmentGroups;
+            if (pa2._id === "angularaxis") {
+              barWidthPlusGap = barGroupWidth;
+              barWidth = barWidthPlusGap * (1 - (opts.groupgap || 0));
+              offsetFromCenter = -barWidth / 2;
+            } else {
+              var groupId = getAxisGroup(fullLayout, pa2._id) + calcTraces[0][0].trace.orientation;
+              alignmentGroups = fullLayout._alignmentOpts[groupId] || {};
+            }
+            for (var i2 = 0; i2 < nTraces; i2++) {
+              var calcTrace = calcTraces[i2];
+              var trace = calcTrace[0].trace;
+              if (pa2._id !== "angularaxis") {
+                var alignmentGroupOpts = alignmentGroups[trace.alignmentgroup] || {};
+                var nOffsetGroups = Object.keys(alignmentGroupOpts.offsetGroups || {}).length;
+                if (nOffsetGroups) {
+                  barWidthPlusGap = barGroupWidth / nOffsetGroups;
+                } else {
+                  barWidthPlusGap = overlap ? barGroupWidth / nTraces : barGroupWidth;
+                }
+                barWidth = barWidthPlusGap * (1 - (opts.groupgap || 0));
+                if (nOffsetGroups) {
+                  offsetFromCenter = ((2 * trace._offsetIndex + 1 - nOffsetGroups) * barWidthPlusGap - barWidth) / 2;
+                } else {
+                  offsetFromCenter = overlap ? ((2 * i2 + 1 - nTraces) * barWidthPlusGap - barWidth) / 2 : -barWidth / 2;
+                }
+              }
+              var t4 = calcTrace[0].t;
+              t4.barwidth = barWidth;
+              t4.offsetindex = trace._offsetIndex || 0;
+              t4.poffset = offsetFromCenter;
+              t4.bargroupwidth = barGroupWidth;
+              t4.bardelta = minDiff;
+            }
+            sieve.binWidth = calcTraces[0][0].t.barwidth / 100;
+            applyAttributes(sieve);
+            setBarCenterAndWidth(pa2, sieve);
+            if (pa2._id === "angularaxis") {
+              updatePositionAxis(pa2, sieve);
+            } else {
+              updatePositionAxis(pa2, sieve, overlap);
+            }
+          }
+          function applyAttributes(sieve) {
+            var calcTraces = sieve.traces;
+            var i2, j2;
+            for (i2 = 0; i2 < calcTraces.length; i2++) {
+              var calcTrace = calcTraces[i2];
+              var calcTrace0 = calcTrace[0];
+              var fullTrace = calcTrace0.trace;
+              var t4 = calcTrace0.t;
+              var offset = fullTrace._offset || fullTrace.offset;
+              var initialPoffset = t4.poffset;
+              var newPoffset;
+              if (isArrayOrTypedArray(offset)) {
+                newPoffset = Array.prototype.slice.call(offset, 0, calcTrace.length);
+                for (j2 = 0; j2 < newPoffset.length; j2++) {
+                  if (!isNumeric(newPoffset[j2])) {
+                    newPoffset[j2] = initialPoffset;
+                  }
+                }
+                for (j2 = newPoffset.length; j2 < calcTrace.length; j2++) {
+                  newPoffset.push(initialPoffset);
+                }
+                t4.poffset = newPoffset;
+              } else if (offset !== void 0) {
+                t4.poffset = offset;
+              }
+              var width = fullTrace._width || fullTrace.width;
+              var initialBarwidth = t4.barwidth;
+              if (isArrayOrTypedArray(width)) {
+                var newBarwidth = Array.prototype.slice.call(width, 0, calcTrace.length);
+                for (j2 = 0; j2 < newBarwidth.length; j2++) {
+                  if (!isNumeric(newBarwidth[j2])) newBarwidth[j2] = initialBarwidth;
+                }
+                for (j2 = newBarwidth.length; j2 < calcTrace.length; j2++) {
+                  newBarwidth.push(initialBarwidth);
+                }
+                t4.barwidth = newBarwidth;
+                if (offset === void 0) {
+                  newPoffset = [];
+                  for (j2 = 0; j2 < calcTrace.length; j2++) {
+                    newPoffset.push(initialPoffset + (initialBarwidth - newBarwidth[j2]) / 2);
+                  }
+                  t4.poffset = newPoffset;
+                }
+              } else if (width !== void 0) {
+                t4.barwidth = width;
+                if (offset === void 0) {
+                  t4.poffset = initialPoffset + (initialBarwidth - width) / 2;
+                }
+              }
+            }
+          }
+          function setBarCenterAndWidth(pa2, sieve) {
+            var calcTraces = sieve.traces;
+            var pLetter = getAxisLetter(pa2);
+            for (var i2 = 0; i2 < calcTraces.length; i2++) {
+              var calcTrace = calcTraces[i2];
+              var t4 = calcTrace[0].t;
+              var poffset = t4.poffset;
+              var poffsetIsArray = isArrayOrTypedArray(poffset);
+              var barwidth = t4.barwidth;
+              var barwidthIsArray = isArrayOrTypedArray(barwidth);
+              for (var j2 = 0; j2 < calcTrace.length; j2++) {
+                var calcBar = calcTrace[j2];
+                var width = calcBar.w = barwidthIsArray ? barwidth[j2] : barwidth;
+                if (calcBar.p === void 0) {
+                  calcBar.p = calcBar[pLetter];
+                  calcBar["orig_" + pLetter] = calcBar[pLetter];
+                }
+                var delta = (poffsetIsArray ? poffset[j2] : poffset) + width / 2;
+                calcBar[pLetter] = calcBar.p + delta;
+              }
+            }
+          }
+          function updatePositionAxis(pa2, sieve, allowMinDtick) {
+            var calcTraces = sieve.traces;
+            var minDiff = sieve.minDiff;
+            var vpad = minDiff / 2;
+            Axes.minDtick(pa2, sieve.minDiff, sieve.distinctPositions[0], allowMinDtick);
+            for (var i2 = 0; i2 < calcTraces.length; i2++) {
+              var calcTrace = calcTraces[i2];
+              var calcTrace0 = calcTrace[0];
+              var fullTrace = calcTrace0.trace;
+              var pts = [];
+              var bar, l2, r2, j2;
+              for (j2 = 0; j2 < calcTrace.length; j2++) {
+                bar = calcTrace[j2];
+                l2 = bar.p - vpad;
+                r2 = bar.p + vpad;
+                pts.push(l2, r2);
+              }
+              if (fullTrace.width || fullTrace.offset) {
+                var t4 = calcTrace0.t;
+                var poffset = t4.poffset;
+                var barwidth = t4.barwidth;
+                var poffsetIsArray = isArrayOrTypedArray(poffset);
+                var barwidthIsArray = isArrayOrTypedArray(barwidth);
+                for (j2 = 0; j2 < calcTrace.length; j2++) {
+                  bar = calcTrace[j2];
+                  var calcBarOffset = poffsetIsArray ? poffset[j2] : poffset;
+                  var calcBarWidth = barwidthIsArray ? barwidth[j2] : barwidth;
+                  l2 = bar.p + calcBarOffset;
+                  r2 = l2 + calcBarWidth;
+                  pts.push(l2, r2);
+                }
+              }
+              fullTrace._extremes[pa2._id] = Axes.findExtremes(pa2, pts, { padded: false });
+            }
+          }
+          function setBaseAndTop(sa2, sieve) {
+            var calcTraces = sieve.traces;
+            var sLetter = getAxisLetter(sa2);
+            for (var i2 = 0; i2 < calcTraces.length; i2++) {
+              var calcTrace = calcTraces[i2];
+              var fullTrace = calcTrace[0].trace;
+              var isScatter = fullTrace.type === "scatter";
+              var isVertical = fullTrace.orientation === "v";
+              var pts = [];
+              var tozero = false;
+              for (var j2 = 0; j2 < calcTrace.length; j2++) {
+                var bar = calcTrace[j2];
+                var base = isScatter ? 0 : bar.b;
+                var top = isScatter ? isVertical ? bar.y : bar.x : base + bar.s;
+                bar[sLetter] = top;
+                pts.push(top);
+                if (bar.hasB) pts.push(base);
+                if (!bar.hasB || !bar.b) {
+                  tozero = true;
+                }
+              }
+              const { ppadminus, ppadplus } = estimateAxisPaddingForText(fullTrace, calcTrace);
+              fullTrace._extremes[sa2._id] = Axes.findExtremes(sa2, pts, {
+                tozero,
+                padded: true,
+                ppadplus,
+                ppadminus
+              });
+            }
+          }
+          function stackBars(sa2, sieve, opts) {
+            var sLetter = getAxisLetter(sa2);
+            var calcTraces = sieve.traces;
+            var calcTrace;
+            var fullTrace;
+            var isFunnel;
+            var i2, j2;
+            var bar;
+            var offsetIndex;
+            for (i2 = 0; i2 < calcTraces.length; i2++) {
+              calcTrace = calcTraces[i2];
+              fullTrace = calcTrace[0].trace;
+              if (fullTrace.type === "funnel") {
+                offsetIndex = calcTrace[0].t.offsetindex;
+                for (j2 = 0; j2 < calcTrace.length; j2++) {
+                  bar = calcTrace[j2];
+                  if (bar.s !== BADNUM) {
+                    sieve.put(bar.p, offsetIndex, -0.5 * bar.s);
+                  }
+                }
+              }
+            }
+            for (i2 = 0; i2 < calcTraces.length; i2++) {
+              calcTrace = calcTraces[i2];
+              fullTrace = calcTrace[0].trace;
+              isFunnel = fullTrace.type === "funnel";
+              offsetIndex = fullTrace.type === "barpolar" ? 0 : calcTrace[0].t.offsetindex;
+              var pts = [];
+              for (j2 = 0; j2 < calcTrace.length; j2++) {
+                bar = calcTrace[j2];
+                if (bar.s !== BADNUM) {
+                  var value;
+                  if (isFunnel) {
+                    value = bar.s;
+                  } else {
+                    value = bar.s + bar.b;
+                  }
+                  var base = sieve.put(bar.p, offsetIndex, value);
+                  var top = base + value;
+                  bar.b = base;
+                  bar[sLetter] = top;
+                  if (!opts.norm) {
+                    pts.push(top);
+                    if (bar.hasB) {
+                      pts.push(base);
+                    }
+                  }
+                }
+              }
+              if (!opts.norm) {
+                const { ppadminus, ppadplus } = estimateAxisPaddingForText(fullTrace, calcTrace);
+                fullTrace._extremes[sa2._id] = Axes.findExtremes(sa2, pts, {
+                  // N.B. we don't stack base with 'base',
+                  // so set tozero:true always!
+                  tozero: true,
+                  padded: true,
+                  ppadplus,
+                  ppadminus
+                });
+              }
+            }
+          }
+          function sieveBars(sieve) {
+            var calcTraces = sieve.traces;
+            for (var i2 = 0; i2 < calcTraces.length; i2++) {
+              var calcTrace = calcTraces[i2];
+              var offsetIndex = calcTrace[0].t.offsetindex;
+              for (var j2 = 0; j2 < calcTrace.length; j2++) {
+                var bar = calcTrace[j2];
+                if (bar.s !== BADNUM) {
+                  sieve.put(bar.p, offsetIndex, bar.b + bar.s);
+                }
+              }
+            }
+          }
+          function unhideBarsWithinTrace(sieve, pa2) {
+            var calcTraces = sieve.traces;
+            for (var i2 = 0; i2 < calcTraces.length; i2++) {
+              var calcTrace = calcTraces[i2];
+              var fullTrace = calcTrace[0].trace;
+              var offsetIndex = calcTrace[0].t.offsetindex;
+              if (fullTrace.base === void 0) {
+                var inTraceSieve = new Sieve([calcTrace], {
+                  posAxis: pa2,
+                  sepNegVal: true,
+                  overlapNoMerge: true
+                });
+                for (var j2 = 0; j2 < calcTrace.length; j2++) {
+                  var bar = calcTrace[j2];
+                  if (bar.p !== BADNUM) {
+                    var base = inTraceSieve.put(bar.p, offsetIndex, bar.b + bar.s);
+                    if (base) bar.b = base;
+                  }
+                }
+              }
+            }
+          }
+          function normalizeBars(sa2, sieve, opts) {
+            var calcTraces = sieve.traces;
+            var sLetter = getAxisLetter(sa2);
+            var sTop = opts.norm === "fraction" ? 1 : 100;
+            var sTiny = sTop / 1e9;
+            var sMin = sa2.l2c(sa2.c2l(0));
+            var sMax = opts.mode === "stack" ? sTop : sMin;
+            function needsPadding(v2) {
+              return isNumeric(sa2.c2l(v2)) && (v2 < sMin - sTiny || v2 > sMax + sTiny || !isNumeric(sMin));
+            }
+            for (var i2 = 0; i2 < calcTraces.length; i2++) {
+              var calcTrace = calcTraces[i2];
+              var offsetIndex = calcTrace[0].t.offsetindex;
+              var fullTrace = calcTrace[0].trace;
+              var pts = [];
+              var tozero = false;
+              var padded = false;
+              for (var j2 = 0; j2 < calcTrace.length; j2++) {
+                var bar = calcTrace[j2];
+                if (bar.s !== BADNUM) {
+                  var scale2 = Math.abs(sTop / sieve.get(bar.p, offsetIndex, bar.s));
+                  bar.b *= scale2;
+                  bar.s *= scale2;
+                  var base = bar.b;
+                  var top = base + bar.s;
+                  bar[sLetter] = top;
+                  pts.push(top);
+                  padded = padded || needsPadding(top);
+                  if (bar.hasB) {
+                    pts.push(base);
+                    padded = padded || needsPadding(base);
+                  }
+                  if (!bar.hasB || !bar.b) {
+                    tozero = true;
+                  }
+                }
+              }
+              const { ppadminus, ppadplus } = estimateAxisPaddingForText(fullTrace, calcTrace);
+              fullTrace._extremes[sa2._id] = Axes.findExtremes(sa2, pts, {
+                tozero,
+                padded,
+                ppadplus,
+                ppadminus
+              });
+            }
+          }
+          function estimateAxisPaddingForText(trace, calcTrace) {
+            if (trace.orientation === "v" && (trace.text || trace.texttemplate) && trace.textposition === "outside" && (trace.textangle === "auto" || trace.textangle === 0)) {
+              let countLines = function(text) {
+                if (!text || typeof text !== "string") return 0;
+                return (text.match(BR_TAG_ALL) || []).length + 1;
+              };
+              var nLines;
+              if (trace.texttemplate) {
+                nLines = countLines(trace.texttemplate);
+              } else {
+                nLines = isArrayOrTypedArray(trace.text) ? Math.max(...trace.text.map((t4) => countLines(t4))) : countLines(trace.text);
+              }
+              const padAmount = trace.outsidetextfont.size * LINE_SPACING * nLines + TEXTPAD;
+              return {
+                // ppadplus corresponds to the negative-direction bars and
+                // ppadminus corresponds to the positive-direction bars (for some reason)
+                ppadplus: calcTrace.some((bar) => bar.s < 0) ? padAmount : 0,
+                ppadminus: calcTrace.some((bar) => bar.s >= 0) ? padAmount : 0
+              };
+            }
+            return { ppadplus: void 0, ppadminus: void 0 };
+          }
+          function setHelperValuesForRoundedCorners(calcTraces, sMinByPos, sMaxByPos, pa2) {
+            var pLetter = getAxisLetter(pa2);
+            for (var i2 = 0; i2 < calcTraces.length; i2++) {
+              var calcTrace = calcTraces[i2];
+              for (var j2 = 0; j2 < calcTrace.length; j2++) {
+                var bar = calcTrace[j2];
+                var pos = bar[pLetter];
+                bar._sMin = sMinByPos[pos];
+                bar._sMax = sMaxByPos[pos];
+              }
+            }
+          }
+          function collectExtents(calcTraces, pa2) {
+            var pLetter = getAxisLetter(pa2);
+            var extents = {};
+            var i2, j2, cd2;
+            var pMin = Infinity;
+            var pMax = -Infinity;
+            for (i2 = 0; i2 < calcTraces.length; i2++) {
+              cd2 = calcTraces[i2];
+              for (j2 = 0; j2 < cd2.length; j2++) {
+                var p2 = cd2[j2].p;
+                if (isNumeric(p2)) {
+                  pMin = Math.min(pMin, p2);
+                  pMax = Math.max(pMax, p2);
+                }
+              }
+            }
+            var roundFactor = 1e4 / (pMax - pMin);
+            var round2 = extents.round = function(p22) {
+              return String(Math.round(roundFactor * (p22 - pMin)));
+            };
+            var sMinByPos = {};
+            var sMaxByPos = {};
+            var anyTraceHasCornerradius = calcTraces.some(function(x2) {
+              var trace = x2[0].trace;
+              return "marker" in trace && trace.marker.cornerradius;
+            });
+            for (i2 = 0; i2 < calcTraces.length; i2++) {
+              cd2 = calcTraces[i2];
+              cd2[0].t.extents = extents;
+              var poffset = cd2[0].t.poffset;
+              var poffsetIsArray = isArrayOrTypedArray(poffset);
+              for (j2 = 0; j2 < cd2.length; j2++) {
+                var di2 = cd2[j2];
+                var p0 = di2[pLetter] - di2.w / 2;
+                if (isNumeric(p0)) {
+                  var p1 = di2[pLetter] + di2.w / 2;
+                  var pVal = round2(di2.p);
+                  if (extents[pVal]) {
+                    extents[pVal] = [Math.min(p0, extents[pVal][0]), Math.max(p1, extents[pVal][1])];
+                  } else {
+                    extents[pVal] = [p0, p1];
+                  }
+                }
+                di2.p0 = di2.p + (poffsetIsArray ? poffset[j2] : poffset);
+                di2.p1 = di2.p0 + di2.w;
+                di2.s0 = di2.b;
+                di2.s1 = di2.s0 + di2.s;
+                if (anyTraceHasCornerradius) {
+                  var sMin = Math.min(di2.s0, di2.s1) || 0;
+                  var sMax = Math.max(di2.s0, di2.s1) || 0;
+                  var pos = di2[pLetter];
+                  sMinByPos[pos] = pos in sMinByPos ? Math.min(sMinByPos[pos], sMin) : sMin;
+                  sMaxByPos[pos] = pos in sMaxByPos ? Math.max(sMaxByPos[pos], sMax) : sMax;
+                }
+              }
+            }
+            if (anyTraceHasCornerradius) {
+              setHelperValuesForRoundedCorners(calcTraces, sMinByPos, sMaxByPos, pa2);
+            }
+          }
+          function getAxisLetter(ax) {
+            return ax._id.charAt(0);
+          }
+          module2.exports = {
+            crossTraceCalc,
+            setGroupPositions
+          };
+        }
+      });
+      var require_cross_trace_calc2 = __commonJS({
+        "src/traces/scatter/cross_trace_calc.js"(exports, module2) {
+          var calc = require_calc3();
+          var setGroupPositions = require_cross_trace_calc().setGroupPositions;
+          function groupCrossTraceCalc(gd2, plotinfo) {
+            var xa = plotinfo.xaxis;
+            var ya2 = plotinfo.yaxis;
+            var fullLayout = gd2._fullLayout;
+            var fullTraces = gd2._fullData;
+            var calcTraces = gd2.calcdata;
+            var calcTracesHorz = [];
+            var calcTracesVert = [];
+            for (var i2 = 0; i2 < fullTraces.length; i2++) {
+              var fullTrace = fullTraces[i2];
+              if (fullTrace.visible === true && fullTrace.type === "scatter" && fullTrace.xaxis === xa._id && fullTrace.yaxis === ya2._id) {
+                if (fullTrace.orientation === "h") {
+                  calcTracesHorz.push(calcTraces[i2]);
+                } else if (fullTrace.orientation === "v") {
+                  calcTracesVert.push(calcTraces[i2]);
+                }
+              }
+            }
+            var opts = {
+              mode: fullLayout.scattermode,
+              gap: fullLayout.scattergap
+            };
+            setGroupPositions(gd2, xa, ya2, calcTracesVert, opts);
+            setGroupPositions(gd2, ya2, xa, calcTracesHorz, opts);
+          }
+          module2.exports = function crossTraceCalc(gd2, plotinfo) {
+            if (gd2._fullLayout.scattermode === "group") {
+              groupCrossTraceCalc(gd2, plotinfo);
+            }
+            var xa = plotinfo.xaxis;
+            var ya2 = plotinfo.yaxis;
+            var subplot = xa._id + ya2._id;
+            var subplotStackOpts = gd2._fullLayout._scatterStackOpts[subplot];
+            if (!subplotStackOpts) return;
+            var calcTraces = gd2.calcdata;
+            var i2, j2, k2, i22, cd2, cd0, posj, sumj, norm;
+            var groupOpts, interpolate, groupnorm, posAttr, valAttr;
+            var hasAnyBlanks;
+            for (var stackGroup in subplotStackOpts) {
+              groupOpts = subplotStackOpts[stackGroup];
+              var indices = groupOpts.traceIndices;
+              if (!indices.length) continue;
+              interpolate = groupOpts.stackgaps === "interpolate";
+              groupnorm = groupOpts.groupnorm;
+              if (groupOpts.orientation === "v") {
+                posAttr = "x";
+                valAttr = "y";
+              } else {
+                posAttr = "y";
+                valAttr = "x";
+              }
+              hasAnyBlanks = new Array(indices.length);
+              for (i2 = 0; i2 < hasAnyBlanks.length; i2++) {
+                hasAnyBlanks[i2] = false;
+              }
+              cd0 = calcTraces[indices[0]];
+              var allPositions = new Array(cd0.length);
+              for (i2 = 0; i2 < cd0.length; i2++) {
+                allPositions[i2] = cd0[i2][posAttr];
+              }
+              for (i2 = 1; i2 < indices.length; i2++) {
+                cd2 = calcTraces[indices[i2]];
+                for (j2 = k2 = 0; j2 < cd2.length; j2++) {
+                  posj = cd2[j2][posAttr];
+                  for (; posj > allPositions[k2] && k2 < allPositions.length; k2++) {
+                    insertBlank(cd2, j2, allPositions[k2], i2, hasAnyBlanks, interpolate, posAttr);
+                    j2++;
+                  }
+                  if (posj !== allPositions[k2]) {
+                    for (i22 = 0; i22 < i2; i22++) {
+                      insertBlank(calcTraces[indices[i22]], k2, posj, i22, hasAnyBlanks, interpolate, posAttr);
+                    }
+                    allPositions.splice(k2, 0, posj);
+                  }
+                  k2++;
+                }
+                for (; k2 < allPositions.length; k2++) {
+                  insertBlank(cd2, j2, allPositions[k2], i2, hasAnyBlanks, interpolate, posAttr);
+                  j2++;
+                }
+              }
+              var serieslen = allPositions.length;
+              for (j2 = 0; j2 < cd0.length; j2++) {
+                sumj = cd0[j2][valAttr] = cd0[j2].s;
+                for (i2 = 1; i2 < indices.length; i2++) {
+                  cd2 = calcTraces[indices[i2]];
+                  cd2[0].trace._rawLength = cd2[0].trace._length;
+                  cd2[0].trace._length = serieslen;
+                  sumj += cd2[j2].s;
+                  cd2[j2][valAttr] = sumj;
+                }
+                if (groupnorm) {
+                  norm = (groupnorm === "fraction" ? sumj : sumj / 100) || 1;
+                  for (i2 = 0; i2 < indices.length; i2++) {
+                    var cdj = calcTraces[indices[i2]][j2];
+                    cdj[valAttr] /= norm;
+                    cdj.sNorm = cdj.s / norm;
+                  }
+                }
+              }
+              for (i2 = 0; i2 < indices.length; i2++) {
+                cd2 = calcTraces[indices[i2]];
+                var trace = cd2[0].trace;
+                var ppad = calc.calcMarkerSize(trace, trace._rawLength);
+                var arrayPad = Array.isArray(ppad);
+                if (ppad && hasAnyBlanks[i2] || arrayPad) {
+                  var ppadRaw = ppad;
+                  ppad = new Array(serieslen);
+                  for (j2 = 0; j2 < serieslen; j2++) {
+                    ppad[j2] = cd2[j2].gap ? 0 : arrayPad ? ppadRaw[cd2[j2].i] : ppadRaw;
+                  }
+                }
+                var x2 = new Array(serieslen);
+                var y2 = new Array(serieslen);
+                for (j2 = 0; j2 < serieslen; j2++) {
+                  x2[j2] = cd2[j2].x;
+                  y2[j2] = cd2[j2].y;
+                }
+                calc.calcAxisExpansion(gd2, trace, xa, ya2, x2, y2, ppad);
+                cd2[0].t.orientation = groupOpts.orientation;
+              }
+            }
+          };
+          function insertBlank(calcTrace, index, position, traceIndex, hasAnyBlanks, interpolate, posAttr) {
+            hasAnyBlanks[traceIndex] = true;
+            var newEntry = {
+              i: null,
+              gap: true,
+              s: 0
+            };
+            newEntry[posAttr] = position;
+            calcTrace.splice(index, 0, newEntry);
+            if (index && position === calcTrace[index - 1][posAttr]) {
+              var prevEntry = calcTrace[index - 1];
+              newEntry.s = prevEntry.s;
+              newEntry.i = prevEntry.i;
+              newEntry.gap = prevEntry.gap;
+            } else if (interpolate) {
+              newEntry.s = getInterp(calcTrace, index, position, posAttr);
+            }
+            if (!index) {
+              calcTrace[0].t = calcTrace[1].t;
+              calcTrace[0].trace = calcTrace[1].trace;
+              delete calcTrace[1].t;
+              delete calcTrace[1].trace;
+            }
+          }
+          function getInterp(calcTrace, index, position, posAttr) {
+            var pt0 = calcTrace[index - 1];
+            var pt1 = calcTrace[index + 1];
+            if (!pt1) return pt0.s;
+            if (!pt0) return pt1.s;
+            return pt0.s + (pt1.s - pt0.s) * (position - pt0[posAttr]) / (pt1[posAttr] - pt0[posAttr]);
+          }
+        }
+      });
+      var require_line_points = __commonJS({
+        "src/traces/scatter/line_points.js"(exports, module2) {
+          var Drawing = require_drawing();
+          var numConstants = require_numerical();
+          var BADNUM = numConstants.BADNUM;
+          var LOG_CLIP = numConstants.LOG_CLIP;
+          var LOG_CLIP_PLUS = LOG_CLIP + 0.5;
+          var LOG_CLIP_MINUS = LOG_CLIP - 0.5;
+          var Lib = require_lib();
+          var segmentsIntersect = Lib.segmentsIntersect;
+          var constrain = Lib.constrain;
+          var constants = require_constants8();
+          module2.exports = function linePoints(d2, opts) {
+            var trace = opts.trace || {};
+            var xa = opts.xaxis;
+            var ya2 = opts.yaxis;
+            var xLog = xa.type === "log";
+            var yLog = ya2.type === "log";
+            var xLen = xa._length;
+            var yLen = ya2._length;
+            var backoff = opts.backoff;
+            var marker = trace.marker;
+            var connectGaps = opts.connectGaps;
+            var baseTolerance = opts.baseTolerance;
+            var shape = opts.shape;
+            var linear2 = shape === "linear";
+            var fill = trace.fill && trace.fill !== "none";
+            var segments = [];
+            var minTolerance = constants.minTolerance;
+            var len2 = d2.length;
+            var pts = new Array(len2);
+            var pti = 0;
+            var i2;
+            var clusterStartPt, clusterEndPt, clusterHighPt, clusterLowPt;
+            var thisPt;
+            var clusterHighFirst;
+            var clusterUnitVector;
+            var thisVector;
+            var clusterRefDist, clusterHighVal, clusterLowVal, thisVal;
+            var clusterMinDeviation, clusterMaxDeviation, thisDeviation;
+            function getPt(index) {
+              var di2 = d2[index];
+              if (!di2) return false;
+              var x2 = opts.linearized ? xa.l2p(di2.x) : xa.c2p(di2.x);
+              var y2 = opts.linearized ? ya2.l2p(di2.y) : ya2.c2p(di2.y);
+              if (x2 === BADNUM) {
+                if (xLog) x2 = xa.c2p(di2.x, true);
+                if (x2 === BADNUM) return false;
+                if (yLog && y2 === BADNUM) {
+                  x2 *= Math.abs(xa._m * yLen * (xa._m > 0 ? LOG_CLIP_PLUS : LOG_CLIP_MINUS) / (ya2._m * xLen * (ya2._m > 0 ? LOG_CLIP_PLUS : LOG_CLIP_MINUS)));
+                }
+                x2 *= 1e3;
+              }
+              if (y2 === BADNUM) {
+                if (yLog) y2 = ya2.c2p(di2.y, true);
+                if (y2 === BADNUM) return false;
+                y2 *= 1e3;
+              }
+              return [x2, y2];
+            }
+            function crossesViewport(xFrac0, yFrac0, xFrac1, yFrac1) {
+              var dx = xFrac1 - xFrac0;
+              var dy = yFrac1 - yFrac0;
+              var dx0 = 0.5 - xFrac0;
+              var dy0 = 0.5 - yFrac0;
+              var norm2 = dx * dx + dy * dy;
+              var dot2 = dx * dx0 + dy * dy0;
+              if (dot2 > 0 && dot2 < norm2) {
+                var cross2 = dx0 * dy - dy0 * dx;
+                if (cross2 * cross2 < norm2) return true;
+              }
+            }
+            var latestXFrac, latestYFrac;
+            function getTolerance(pt2, nextPt2) {
+              var xFrac = pt2[0] / xLen;
+              var yFrac = pt2[1] / yLen;
+              var offScreenFraction = Math.max(0, -xFrac, xFrac - 1, -yFrac, yFrac - 1);
+              if (offScreenFraction && latestXFrac !== void 0 && crossesViewport(xFrac, yFrac, latestXFrac, latestYFrac)) {
+                offScreenFraction = 0;
+              }
+              if (offScreenFraction && nextPt2 && crossesViewport(xFrac, yFrac, nextPt2[0] / xLen, nextPt2[1] / yLen)) {
+                offScreenFraction = 0;
+              }
+              return (1 + constants.toleranceGrowth * offScreenFraction) * baseTolerance;
+            }
+            function ptDist(pt1, pt2) {
+              var dx = pt1[0] - pt2[0];
+              var dy = pt1[1] - pt2[1];
+              return Math.sqrt(dx * dx + dy * dy);
+            }
+            var maxScreensAway = constants.maxScreensAway;
+            var xEdge0 = -xLen * maxScreensAway;
+            var xEdge1 = xLen * (1 + maxScreensAway);
+            var yEdge0 = -yLen * maxScreensAway;
+            var yEdge1 = yLen * (1 + maxScreensAway);
+            var edges = [
+              [xEdge0, yEdge0, xEdge1, yEdge0],
+              [xEdge1, yEdge0, xEdge1, yEdge1],
+              [xEdge1, yEdge1, xEdge0, yEdge1],
+              [xEdge0, yEdge1, xEdge0, yEdge0]
+            ];
+            var xEdge, yEdge, lastXEdge, lastYEdge, lastFarPt, edgePt;
+            function getLinearEdgeIntersections(pt1, pt2) {
+              var out = [];
+              var ptCount = 0;
+              for (var i22 = 0; i22 < 4; i22++) {
+                var edge = edges[i22];
+                var ptInt = segmentsIntersect(
+                  pt1[0],
+                  pt1[1],
+                  pt2[0],
+                  pt2[1],
+                  edge[0],
+                  edge[1],
+                  edge[2],
+                  edge[3]
+                );
+                if (ptInt && (!ptCount || Math.abs(ptInt.x - out[0][0]) > 1 || Math.abs(ptInt.y - out[0][1]) > 1)) {
+                  ptInt = [ptInt.x, ptInt.y];
+                  if (ptCount && ptDist(ptInt, pt1) < ptDist(out[0], pt1)) out.unshift(ptInt);
+                  else out.push(ptInt);
+                  ptCount++;
+                }
+              }
+              return out;
+            }
+            function onlyConstrainedPoint(pt2) {
+              if (pt2[0] < xEdge0 || pt2[0] > xEdge1 || pt2[1] < yEdge0 || pt2[1] > yEdge1) {
+                return [constrain(pt2[0], xEdge0, xEdge1), constrain(pt2[1], yEdge0, yEdge1)];
+              }
+            }
+            function sameEdge(pt1, pt2) {
+              if (pt1[0] === pt2[0] && (pt1[0] === xEdge0 || pt1[0] === xEdge1)) return true;
+              if (pt1[1] === pt2[1] && (pt1[1] === yEdge0 || pt1[1] === yEdge1)) return true;
+            }
+            function getHVEdgeIntersections(pt1, pt2) {
+              var out = [];
+              var ptInt1 = onlyConstrainedPoint(pt1);
+              var ptInt2 = onlyConstrainedPoint(pt2);
+              if (ptInt1 && ptInt2 && sameEdge(ptInt1, ptInt2)) return out;
+              if (ptInt1) out.push(ptInt1);
+              if (ptInt2) out.push(ptInt2);
+              return out;
+            }
+            function getABAEdgeIntersections(dim, limit0, limit1) {
+              return function(pt1, pt2) {
+                var ptInt1 = onlyConstrainedPoint(pt1);
+                var ptInt2 = onlyConstrainedPoint(pt2);
+                var out = [];
+                if (ptInt1 && ptInt2 && sameEdge(ptInt1, ptInt2)) return out;
+                if (ptInt1) out.push(ptInt1);
+                if (ptInt2) out.push(ptInt2);
+                var midShift = 2 * Lib.constrain((pt1[dim] + pt2[dim]) / 2, limit0, limit1) - ((ptInt1 || pt1)[dim] + (ptInt2 || pt2)[dim]);
+                if (midShift) {
+                  var ptToAlter;
+                  if (ptInt1 && ptInt2) {
+                    ptToAlter = midShift > 0 === ptInt1[dim] > ptInt2[dim] ? ptInt1 : ptInt2;
+                  } else ptToAlter = ptInt1 || ptInt2;
+                  ptToAlter[dim] += midShift;
+                }
+                return out;
+              };
+            }
+            var getEdgeIntersections;
+            if (shape === "linear" || shape === "spline") {
+              getEdgeIntersections = getLinearEdgeIntersections;
+            } else if (shape === "hv" || shape === "vh") {
+              getEdgeIntersections = getHVEdgeIntersections;
+            } else if (shape === "hvh") getEdgeIntersections = getABAEdgeIntersections(0, xEdge0, xEdge1);
+            else if (shape === "vhv") getEdgeIntersections = getABAEdgeIntersections(1, yEdge0, yEdge1);
+            function getClosestCorner(pt1, pt2) {
+              var dx = pt2[0] - pt1[0];
+              var m2 = (pt2[1] - pt1[1]) / dx;
+              var b2 = (pt1[1] * pt2[0] - pt2[1] * pt1[0]) / dx;
+              if (b2 > 0) return [m2 > 0 ? xEdge0 : xEdge1, yEdge1];
+              else return [m2 > 0 ? xEdge1 : xEdge0, yEdge0];
+            }
+            function updateEdge(pt2) {
+              var x2 = pt2[0];
+              var y2 = pt2[1];
+              var xSame = x2 === pts[pti - 1][0];
+              var ySame = y2 === pts[pti - 1][1];
+              if (xSame && ySame) return;
+              if (pti > 1) {
+                var xSame2 = x2 === pts[pti - 2][0];
+                var ySame2 = y2 === pts[pti - 2][1];
+                if (xSame && (x2 === xEdge0 || x2 === xEdge1) && xSame2) {
+                  if (ySame2) pti--;
+                  else pts[pti - 1] = pt2;
+                } else if (ySame && (y2 === yEdge0 || y2 === yEdge1) && ySame2) {
+                  if (xSame2) pti--;
+                  else pts[pti - 1] = pt2;
+                } else pts[pti++] = pt2;
+              } else pts[pti++] = pt2;
+            }
+            function updateEdgesForReentry(pt2) {
+              if (pts[pti - 1][0] !== pt2[0] && pts[pti - 1][1] !== pt2[1]) {
+                updateEdge([lastXEdge, lastYEdge]);
+              }
+              updateEdge(pt2);
+              lastFarPt = null;
+              lastXEdge = lastYEdge = 0;
+            }
+            var arrayMarker = Lib.isArrayOrTypedArray(marker);
+            function addPt(pt2) {
+              if (pt2 && backoff) {
+                pt2.i = i2;
+                pt2.d = d2;
+                pt2.trace = trace;
+                pt2.marker = arrayMarker ? marker[pt2.i] : marker;
+                pt2.backoff = backoff;
+              }
+              latestXFrac = pt2[0] / xLen;
+              latestYFrac = pt2[1] / yLen;
+              xEdge = pt2[0] < xEdge0 ? xEdge0 : pt2[0] > xEdge1 ? xEdge1 : 0;
+              yEdge = pt2[1] < yEdge0 ? yEdge0 : pt2[1] > yEdge1 ? yEdge1 : 0;
+              if (xEdge || yEdge) {
+                if (!pti) {
+                  pts[pti++] = [xEdge || pt2[0], yEdge || pt2[1]];
+                } else if (lastFarPt) {
+                  var intersections = getEdgeIntersections(lastFarPt, pt2);
+                  if (intersections.length > 1) {
+                    updateEdgesForReentry(intersections[0]);
+                    pts[pti++] = intersections[1];
+                  }
+                } else {
+                  edgePt = getEdgeIntersections(pts[pti - 1], pt2)[0];
+                  pts[pti++] = edgePt;
+                }
+                var lastPt = pts[pti - 1];
+                if (xEdge && yEdge && (lastPt[0] !== xEdge || lastPt[1] !== yEdge)) {
+                  if (lastFarPt) {
+                    if (lastXEdge !== xEdge && lastYEdge !== yEdge) {
+                      if (lastXEdge && lastYEdge) {
+                        updateEdge(getClosestCorner(lastFarPt, pt2));
+                      } else {
+                        updateEdge([lastXEdge || xEdge, lastYEdge || yEdge]);
+                      }
+                    } else if (lastXEdge && lastYEdge) {
+                      updateEdge([lastXEdge, lastYEdge]);
+                    }
+                  }
+                  updateEdge([xEdge, yEdge]);
+                } else if (lastXEdge - xEdge && lastYEdge - yEdge) {
+                  updateEdge([xEdge || lastXEdge, yEdge || lastYEdge]);
+                }
+                lastFarPt = pt2;
+                lastXEdge = xEdge;
+                lastYEdge = yEdge;
+              } else {
+                if (lastFarPt) {
+                  updateEdgesForReentry(getEdgeIntersections(lastFarPt, pt2)[0]);
+                }
+                pts[pti++] = pt2;
+              }
+            }
+            for (i2 = 0; i2 < len2; i2++) {
+              clusterStartPt = getPt(i2);
+              if (!clusterStartPt) continue;
+              pti = 0;
+              lastFarPt = null;
+              addPt(clusterStartPt);
+              for (i2++; i2 < len2; i2++) {
+                clusterHighPt = getPt(i2);
+                if (!clusterHighPt) {
+                  if (connectGaps) continue;
+                  else break;
+                }
+                if (!linear2 || !opts.simplify) {
+                  addPt(clusterHighPt);
+                  continue;
+                }
+                var nextPt = getPt(i2 + 1);
+                clusterRefDist = ptDist(clusterHighPt, clusterStartPt);
+                if (!(fill && (pti === 0 || pti === len2 - 1)) && clusterRefDist < getTolerance(clusterHighPt, nextPt) * minTolerance) continue;
+                clusterUnitVector = [
+                  (clusterHighPt[0] - clusterStartPt[0]) / clusterRefDist,
+                  (clusterHighPt[1] - clusterStartPt[1]) / clusterRefDist
+                ];
+                clusterLowPt = clusterStartPt;
+                clusterHighVal = clusterRefDist;
+                clusterLowVal = clusterMinDeviation = clusterMaxDeviation = 0;
+                clusterHighFirst = false;
+                clusterEndPt = clusterHighPt;
+                for (i2++; i2 < d2.length; i2++) {
+                  thisPt = nextPt;
+                  nextPt = getPt(i2 + 1);
+                  if (!thisPt) {
+                    if (connectGaps) continue;
+                    else break;
+                  }
+                  thisVector = [
+                    thisPt[0] - clusterStartPt[0],
+                    thisPt[1] - clusterStartPt[1]
+                  ];
+                  thisDeviation = thisVector[0] * clusterUnitVector[1] - thisVector[1] * clusterUnitVector[0];
+                  clusterMinDeviation = Math.min(clusterMinDeviation, thisDeviation);
+                  clusterMaxDeviation = Math.max(clusterMaxDeviation, thisDeviation);
+                  if (clusterMaxDeviation - clusterMinDeviation > getTolerance(thisPt, nextPt)) break;
+                  clusterEndPt = thisPt;
+                  thisVal = thisVector[0] * clusterUnitVector[0] + thisVector[1] * clusterUnitVector[1];
+                  if (thisVal > clusterHighVal) {
+                    clusterHighVal = thisVal;
+                    clusterHighPt = thisPt;
+                    clusterHighFirst = false;
+                  } else if (thisVal < clusterLowVal) {
+                    clusterLowVal = thisVal;
+                    clusterLowPt = thisPt;
+                    clusterHighFirst = true;
+                  }
+                }
+                if (clusterHighFirst) {
+                  addPt(clusterHighPt);
+                  if (clusterEndPt !== clusterLowPt) addPt(clusterLowPt);
+                } else {
+                  if (clusterLowPt !== clusterStartPt) addPt(clusterLowPt);
+                  if (clusterEndPt !== clusterHighPt) addPt(clusterHighPt);
+                }
+                addPt(clusterEndPt);
+                if (i2 >= d2.length || !thisPt) break;
+                addPt(thisPt);
+                clusterStartPt = thisPt;
+              }
+              if (lastFarPt) updateEdge([lastXEdge || lastFarPt[0], lastYEdge || lastFarPt[1]]);
+              segments.push(pts.slice(0, pti));
+            }
+            var lastShapeChar = shape.slice(shape.length - 1);
+            if (backoff && lastShapeChar !== "h" && lastShapeChar !== "v") {
+              var trimmed = false;
+              var n2 = -1;
+              var newSegments = [];
+              for (var j2 = 0; j2 < segments.length; j2++) {
+                for (var k2 = 0; k2 < segments[j2].length - 1; k2++) {
+                  var start = segments[j2][k2];
+                  var end = segments[j2][k2 + 1];
+                  var xy = Drawing.applyBackoff(end, start);
+                  if (xy[0] !== end[0] || xy[1] !== end[1]) {
+                    trimmed = true;
+                  }
+                  if (!newSegments[n2 + 1]) {
+                    n2++;
+                    newSegments[n2] = [
+                      start,
+                      [xy[0], xy[1]]
+                    ];
+                  }
+                }
+              }
+              return trimmed ? newSegments : segments;
+            }
+            return segments;
+          };
+        }
+      });
+      var require_link_traces = __commonJS({
+        "src/traces/scatter/link_traces.js"(exports, module2) {
+          var LINKEDFILLS = { tonextx: 1, tonexty: 1, tonext: 1 };
+          module2.exports = function linkTraces(gd2, plotinfo, cdscatter) {
+            var trace, i2, group, prevtrace, groupIndex;
+            var groupIndices = {};
+            var needsSort = false;
+            var prevGroupIndex = -1;
+            var nextGroupIndex = 0;
+            var prevUnstackedGroupIndex = -1;
+            for (i2 = 0; i2 < cdscatter.length; i2++) {
+              trace = cdscatter[i2][0].trace;
+              group = trace.stackgroup || "";
+              if (group) {
+                if (group in groupIndices) {
+                  groupIndex = groupIndices[group];
+                } else {
+                  groupIndex = groupIndices[group] = nextGroupIndex;
+                  nextGroupIndex++;
+                }
+              } else if (trace.fill in LINKEDFILLS && prevUnstackedGroupIndex >= 0) {
+                groupIndex = prevUnstackedGroupIndex;
+              } else {
+                groupIndex = prevUnstackedGroupIndex = nextGroupIndex;
+                nextGroupIndex++;
+              }
+              if (groupIndex < prevGroupIndex) needsSort = true;
+              trace._groupIndex = prevGroupIndex = groupIndex;
+            }
+            var cdscatterSorted = cdscatter.slice();
+            if (needsSort) {
+              cdscatterSorted.sort(function(a2, b2) {
+                var traceA = a2[0].trace;
+                var traceB = b2[0].trace;
+                return traceA._groupIndex - traceB._groupIndex || traceA.index - traceB.index;
+              });
+            }
+            var prevtraces = {};
+            for (i2 = 0; i2 < cdscatterSorted.length; i2++) {
+              trace = cdscatterSorted[i2][0].trace;
+              group = trace.stackgroup || "";
+              if (trace.visible === true) {
+                trace._nexttrace = null;
+                if (trace.fill in LINKEDFILLS) {
+                  prevtrace = prevtraces[group];
+                  trace._prevtrace = prevtrace || null;
+                  if (prevtrace) {
+                    prevtrace._nexttrace = trace;
+                  }
+                }
+                trace._ownfill = trace.fill && (trace.fill.slice(0, 6) === "tozero" || trace.fill === "toself" || trace.fill.slice(0, 2) === "to" && !trace._prevtrace);
+                prevtraces[group] = trace;
+              } else {
+                trace._prevtrace = trace._nexttrace = trace._ownfill = null;
+              }
+            }
+            return cdscatterSorted;
+          };
+        }
+      });
+      var require_plot = __commonJS({
+        "src/traces/scatter/plot.js"(exports, module2) {
+          var d3 = require_d3();
+          var Registry = require_registry();
+          var Lib = require_lib();
+          var ensureSingle = Lib.ensureSingle;
+          var identity22 = Lib.identity;
+          var Drawing = require_drawing();
+          var subTypes = require_subtypes();
+          var linePoints = require_line_points();
+          var linkTraces = require_link_traces();
+          var polygonTester = require_polygon().tester;
+          module2.exports = function plot(gd2, plotinfo, cdscatter, scatterLayer, transitionOpts, makeOnCompleteCallback) {
+            var join, onComplete;
+            var isFullReplot = !transitionOpts;
+            var hasTransition = !!transitionOpts && transitionOpts.duration > 0;
+            var cdscatterSorted = linkTraces(gd2, plotinfo, cdscatter);
+            join = scatterLayer.selectAll("g.trace").data(cdscatterSorted, function(d2) {
+              return d2[0].trace.uid;
+            });
+            join.enter().append("g").attr("class", function(d2) {
+              return "trace scatter trace" + d2[0].trace.uid;
+            }).style("stroke-miterlimit", 2);
+            join.order();
+            createFills(gd2, join, plotinfo);
+            if (hasTransition) {
+              if (makeOnCompleteCallback) {
+                onComplete = makeOnCompleteCallback();
+              }
+              var transition = d3.transition().duration(transitionOpts.duration).ease(transitionOpts.easing).each("end", function() {
+                onComplete && onComplete();
+              }).each("interrupt", function() {
+                onComplete && onComplete();
+              });
+              transition.each(function() {
+                scatterLayer.selectAll("g.trace").each(function(d2, i2) {
+                  plotOne(gd2, i2, plotinfo, d2, cdscatterSorted, this, transitionOpts);
+                });
+              });
+            } else {
+              join.each(function(d2, i2) {
+                plotOne(gd2, i2, plotinfo, d2, cdscatterSorted, this, transitionOpts);
+              });
+            }
+            if (isFullReplot) {
+              join.exit().remove();
+            }
+            scatterLayer.selectAll("path:not([d])").remove();
+          };
+          function createFills(gd2, traceJoin, plotinfo) {
+            traceJoin.each(function(d2) {
+              var fills = ensureSingle(d3.select(this), "g", "fills");
+              Drawing.setClipUrl(fills, plotinfo.layerClipId, gd2);
+              var trace = d2[0].trace;
+              trace._ownFill = null;
+              trace._nextFill = null;
+              var fillData = [];
+              if (trace._ownfill) fillData.push("_ownFill");
+              if (trace._nexttrace) fillData.push("_nextFill");
+              var fillJoin = fills.selectAll("g").data(fillData, identity22);
+              fillJoin.enter().append("g");
+              fillJoin.exit().remove();
+              fillJoin.order().each(function(d22) {
+                trace[d22] = ensureSingle(d3.select(this), "path", "js-fill");
+              });
+            });
+          }
+          function plotOne(gd2, idx, plotinfo, cdscatter, cdscatterAll, element, transitionOpts) {
+            var isStatic = gd2._context.staticPlot;
+            var i2;
+            selectMarkers(gd2, idx, plotinfo, cdscatter, cdscatterAll);
+            var hasTransition = !!transitionOpts && transitionOpts.duration > 0;
+            function transition(selection) {
+              return hasTransition ? selection.transition() : selection;
+            }
+            var xa = plotinfo.xaxis;
+            var ya2 = plotinfo.yaxis;
+            var trace = cdscatter[0].trace;
+            var line = trace.line;
+            var tr = d3.select(element);
+            var errorBarGroup = ensureSingle(tr, "g", "errorbars");
+            var lines = ensureSingle(tr, "g", "lines");
+            var points = ensureSingle(tr, "g", "points");
+            var text = ensureSingle(tr, "g", "text");
+            Registry.getComponentMethod("errorbars", "plot")(gd2, errorBarGroup, plotinfo, transitionOpts);
+            if (trace.visible !== true) return;
+            transition(tr).style("opacity", trace.opacity);
+            var ownFillEl3, tonext;
+            var ownFillDir = trace.fill.charAt(trace.fill.length - 1);
+            if (ownFillDir !== "x" && ownFillDir !== "y") ownFillDir = "";
+            var fillAxisIndex, fillAxisZero;
+            if (ownFillDir === "y") {
+              fillAxisIndex = 1;
+              fillAxisZero = ya2.c2p(0, true);
+            } else if (ownFillDir === "x") {
+              fillAxisIndex = 0;
+              fillAxisZero = xa.c2p(0, true);
+            }
+            cdscatter[0][plotinfo.isRangePlot ? "nodeRangePlot3" : "node3"] = tr;
+            var prevRevpath = "";
+            var prevPolygons = [];
+            var prevtrace = trace._prevtrace;
+            var prevFillsegments = null;
+            var prevFillElement = null;
+            if (prevtrace) {
+              prevRevpath = prevtrace._prevRevpath || "";
+              tonext = prevtrace._nextFill;
+              prevPolygons = prevtrace._ownPolygons;
+              prevFillsegments = prevtrace._fillsegments;
+              prevFillElement = prevtrace._fillElement;
+            }
+            var thispath;
+            var thisrevpath;
+            var fullpath = "";
+            var revpath = "";
+            var pathfn, revpathbase, revpathfn;
+            var pt0, lastSegment, pt1;
+            var thisPolygons = [];
+            trace._polygons = [];
+            var fillsegments = [];
+            var segments = [];
+            var makeUpdate = Lib.noop;
+            ownFillEl3 = trace._ownFill;
+            if (subTypes.hasLines(trace) || trace.fill !== "none") {
+              if (tonext) {
+                tonext.datum(cdscatter);
+              }
+              if (["hv", "vh", "hvh", "vhv"].indexOf(line.shape) !== -1) {
+                pathfn = Drawing.steps(line.shape);
+                revpathbase = Drawing.steps(
+                  line.shape.split("").reverse().join("")
+                );
+              } else if (line.shape === "spline") {
+                pathfn = revpathbase = function(pts2) {
+                  var pLast = pts2[pts2.length - 1];
+                  if (pts2.length > 1 && pts2[0][0] === pLast[0] && pts2[0][1] === pLast[1]) {
+                    return Drawing.smoothclosed(pts2.slice(1), line.smoothing);
+                  } else {
+                    return Drawing.smoothopen(pts2, line.smoothing);
+                  }
+                };
+              } else {
+                pathfn = revpathbase = function(pts2) {
+                  return "M" + pts2.join("L");
+                };
+              }
+              revpathfn = function(pts2) {
+                return revpathbase(pts2.reverse());
+              };
+              segments = linePoints(cdscatter, {
+                xaxis: xa,
+                yaxis: ya2,
+                trace,
+                connectGaps: trace.connectgaps,
+                baseTolerance: Math.max(line.width || 1, 3) / 4,
+                shape: line.shape,
+                backoff: line.backoff,
+                simplify: line.simplify,
+                fill: trace.fill
+              });
+              fillsegments = new Array(segments.length);
+              var fillsegmentCount = 0;
+              for (i2 = 0; i2 < segments.length; i2++) {
+                var curpoints;
+                var pts = segments[i2];
+                if (!curpoints || !ownFillDir) {
+                  curpoints = pts.slice();
+                  fillsegments[fillsegmentCount] = curpoints;
+                  fillsegmentCount++;
+                } else {
+                  curpoints.push.apply(curpoints, pts);
+                }
+              }
+              trace._fillElement = null;
+              trace._fillExclusionElement = prevFillElement;
+              trace._fillsegments = fillsegments.slice(0, fillsegmentCount);
+              fillsegments = trace._fillsegments;
+              if (segments.length) {
+                pt0 = segments[0][0].slice();
+                lastSegment = segments[segments.length - 1];
+                pt1 = lastSegment[lastSegment.length - 1].slice();
+              }
+              makeUpdate = function(isEnter) {
+                return function(pts2) {
+                  thispath = pathfn(pts2);
+                  thisrevpath = revpathfn(pts2);
+                  if (!fullpath) {
+                    fullpath = thispath;
+                    revpath = thisrevpath;
+                  } else if (ownFillDir) {
+                    fullpath += "L" + thispath.slice(1);
+                    revpath = thisrevpath + ("L" + revpath.slice(1));
+                  } else {
+                    fullpath += "Z" + thispath;
+                    revpath = thisrevpath + "Z" + revpath;
+                  }
+                  if (subTypes.hasLines(trace)) {
+                    var el2 = d3.select(this);
+                    el2.datum(cdscatter);
+                    if (isEnter) {
+                      transition(el2.style("opacity", 0).attr("d", thispath).call(Drawing.lineGroupStyle)).style("opacity", 1);
+                    } else {
+                      var sel = transition(el2);
+                      sel.attr("d", thispath);
+                      Drawing.singleLineStyle(cdscatter, sel);
+                    }
+                  }
+                };
+              };
+            }
+            var lineJoin = lines.selectAll(".js-line").data(segments);
+            transition(lineJoin.exit()).style("opacity", 0).remove();
+            lineJoin.each(makeUpdate(false));
+            lineJoin.enter().append("path").classed("js-line", true).style("vector-effect", isStatic ? "none" : "non-scaling-stroke").call(Drawing.lineGroupStyle).each(makeUpdate(true));
+            Drawing.setClipUrl(lineJoin, plotinfo.layerClipId, gd2);
+            function clearFill(selection) {
+              transition(selection).attr("d", "M0,0Z");
+            }
+            var makeSelfPolygons = function() {
+              var polygons = new Array(fillsegments.length);
+              for (i2 = 0; i2 < fillsegments.length; i2++) {
+                polygons[i2] = polygonTester(fillsegments[i2]);
+              }
+              return polygons;
+            };
+            var makePolygonsToPrevious = function(prevFillsegments2) {
+              var polygons, i22;
+              if (!prevFillsegments2 || prevFillsegments2.length === 0) {
+                polygons = new Array(fillsegments.length);
+                for (i22 = 0; i22 < fillsegments.length; i22++) {
+                  var pt02 = fillsegments[i22][0].slice();
+                  var pt12 = fillsegments[i22][fillsegments[i22].length - 1].slice();
+                  pt02[fillAxisIndex] = pt12[fillAxisIndex] = fillAxisZero;
+                  var zeropoints = [pt12, pt02];
+                  var polypoints = zeropoints.concat(fillsegments[i22]);
+                  polygons[i22] = polygonTester(polypoints);
+                }
+              } else {
+                polygons = new Array(prevFillsegments2.length - 1 + fillsegments.length);
+                for (i22 = 0; i22 < prevFillsegments2.length - 1; i22++) {
+                  polygons[i22] = polygonTester(prevFillsegments2[i22]);
+                }
+                var reversedPrevFillsegment = prevFillsegments2[prevFillsegments2.length - 1].slice();
+                reversedPrevFillsegment.reverse();
+                for (i22 = 0; i22 < fillsegments.length; i22++) {
+                  polygons[prevFillsegments2.length - 1 + i22] = polygonTester(fillsegments[i22].concat(reversedPrevFillsegment));
+                }
+              }
+              return polygons;
+            };
+            if (segments.length) {
+              if (ownFillEl3) {
+                ownFillEl3.datum(cdscatter);
+                if (pt0 && pt1) {
+                  if (ownFillDir) {
+                    pt0[fillAxisIndex] = pt1[fillAxisIndex] = fillAxisZero;
+                    transition(ownFillEl3).attr("d", "M" + pt1 + "L" + pt0 + "L" + fullpath.slice(1)).call(Drawing.singleFillStyle, gd2);
+                    thisPolygons = makePolygonsToPrevious(null);
+                  } else {
+                    transition(ownFillEl3).attr("d", fullpath + "Z").call(Drawing.singleFillStyle, gd2);
+                    thisPolygons = makeSelfPolygons();
+                  }
+                }
+                trace._polygons = thisPolygons;
+                trace._fillElement = ownFillEl3;
+              } else if (tonext) {
+                if (trace.fill.slice(0, 6) === "tonext" && fullpath && prevRevpath) {
+                  if (trace.fill === "tonext") {
+                    transition(tonext).attr("d", fullpath + "Z" + prevRevpath + "Z").call(Drawing.singleFillStyle, gd2);
+                    thisPolygons = makeSelfPolygons();
+                    trace._polygons = thisPolygons.concat(prevPolygons);
+                  } else {
+                    transition(tonext).attr("d", fullpath + "L" + prevRevpath.slice(1) + "Z").call(Drawing.singleFillStyle, gd2);
+                    thisPolygons = makePolygonsToPrevious(prevFillsegments);
+                    trace._polygons = thisPolygons;
+                  }
+                  trace._fillElement = tonext;
+                } else {
+                  clearFill(tonext);
+                }
+              }
+              trace._prevRevpath = revpath;
+            } else {
+              if (ownFillEl3) clearFill(ownFillEl3);
+              else if (tonext) clearFill(tonext);
+              trace._prevRevpath = null;
+            }
+            trace._ownPolygons = thisPolygons;
+            function visFilter(d2) {
+              return d2.filter(function(v2) {
+                return !v2.gap && v2.vis;
+              });
+            }
+            function visFilterWithGaps(d2) {
+              return d2.filter(function(v2) {
+                return v2.vis;
+              });
+            }
+            function gapFilter(d2) {
+              return d2.filter(function(v2) {
+                return !v2.gap;
+              });
+            }
+            function keyFunc(d2) {
+              return d2.id;
+            }
+            function getKeyFunc(trace2) {
+              if (trace2.ids) {
+                return keyFunc;
+              }
+            }
+            function hideFilter() {
+              return false;
+            }
+            function makePoints(points2, text2, cdscatter2) {
+              var join, selection, hasNode;
+              var trace2 = cdscatter2[0].trace;
+              var showMarkers = subTypes.hasMarkers(trace2);
+              var showText = subTypes.hasText(trace2);
+              var keyFunc2 = getKeyFunc(trace2);
+              var markerFilter = hideFilter;
+              var textFilter = hideFilter;
+              if (showMarkers || showText) {
+                var showFilter = identity22;
+                var stackGroup = trace2.stackgroup;
+                var isInferZero = stackGroup && gd2._fullLayout._scatterStackOpts[xa._id + ya2._id][stackGroup].stackgaps === "infer zero";
+                if (trace2.marker.maxdisplayed || trace2._needsCull) {
+                  showFilter = isInferZero ? visFilterWithGaps : visFilter;
+                } else if (stackGroup && !isInferZero) {
+                  showFilter = gapFilter;
+                }
+                if (showMarkers) markerFilter = showFilter;
+                if (showText) textFilter = showFilter;
+              }
+              selection = points2.selectAll("path.point");
+              join = selection.data(markerFilter, keyFunc2);
+              var enter = join.enter().append("path").classed("point", true);
+              if (hasTransition) {
+                enter.call(Drawing.pointStyle, trace2, gd2).call(Drawing.translatePoints, xa, ya2).style("opacity", 0).transition().style("opacity", 1);
+              }
+              join.order();
+              var styleFns;
+              if (showMarkers) {
+                styleFns = Drawing.makePointStyleFns(trace2);
+              }
+              join.each(function(d2) {
+                var el2 = d3.select(this);
+                var sel = transition(el2);
+                hasNode = Drawing.translatePoint(d2, sel, xa, ya2);
+                if (hasNode) {
+                  Drawing.singlePointStyle(d2, sel, trace2, styleFns, gd2);
+                  if (plotinfo.layerClipId) {
+                    Drawing.hideOutsideRangePoint(d2, sel, xa, ya2, trace2.xcalendar, trace2.ycalendar);
+                  }
+                  if (trace2.customdata) {
+                    el2.classed("plotly-customdata", d2.data !== null && d2.data !== void 0);
+                  }
+                } else {
+                  sel.remove();
+                }
+              });
+              if (hasTransition) {
+                join.exit().transition().style("opacity", 0).remove();
+              } else {
+                join.exit().remove();
+              }
+              selection = text2.selectAll("g");
+              join = selection.data(textFilter, keyFunc2);
+              join.enter().append("g").classed("textpoint", true).append("text");
+              join.order();
+              join.each(function(d2) {
+                var g2 = d3.select(this);
+                var sel = transition(g2.select("text"));
+                hasNode = Drawing.translatePoint(d2, sel, xa, ya2);
+                if (hasNode) {
+                  if (plotinfo.layerClipId) {
+                    Drawing.hideOutsideRangePoint(d2, g2, xa, ya2, trace2.xcalendar, trace2.ycalendar);
+                  }
+                } else {
+                  g2.remove();
+                }
+              });
+              join.selectAll("text").call(Drawing.textPointStyle, trace2, gd2).each(function(d2) {
+                var x2 = xa.c2p(d2.x);
+                var y2 = ya2.c2p(d2.y);
+                d3.select(this).selectAll("tspan.line").each(function() {
+                  transition(d3.select(this)).attr({ x: x2, y: y2 });
+                });
+              });
+              join.exit().remove();
+            }
+            points.datum(cdscatter);
+            text.datum(cdscatter);
+            makePoints(points, text, cdscatter);
+            var hasClipOnAxisFalse = trace.cliponaxis === false;
+            var clipUrl = hasClipOnAxisFalse ? null : plotinfo.layerClipId;
+            Drawing.setClipUrl(points, clipUrl, gd2);
+            Drawing.setClipUrl(text, clipUrl, gd2);
+          }
+          function selectMarkers(gd2, idx, plotinfo, cdscatter, cdscatterAll) {
+            var xa = plotinfo.xaxis;
+            var ya2 = plotinfo.yaxis;
+            var xr = d3.extent(Lib.simpleMap(xa.range, xa.r2c));
+            var yr = d3.extent(Lib.simpleMap(ya2.range, ya2.r2c));
+            var trace = cdscatter[0].trace;
+            if (!subTypes.hasMarkers(trace)) return;
+            var mnum = trace.marker.maxdisplayed;
+            if (mnum === 0) return;
+            var cd2 = cdscatter.filter(function(v2) {
+              return v2.x >= xr[0] && v2.x <= xr[1] && v2.y >= yr[0] && v2.y <= yr[1];
+            });
+            var inc = Math.ceil(cd2.length / mnum);
+            var tnum = 0;
+            cdscatterAll.forEach(function(cdj, j2) {
+              var tracei = cdj[0].trace;
+              if (subTypes.hasMarkers(tracei) && tracei.marker.maxdisplayed > 0 && j2 < idx) {
+                tnum++;
+              }
+            });
+            var i0 = Math.round(tnum * inc / 3 + Math.floor(tnum / 3) * inc / 7.1);
+            cdscatter.forEach(function(v2) {
+              delete v2.vis;
+            });
+            cd2.forEach(function(v2, i2) {
+              if (Math.round((i2 + i0) % inc) === 0) v2.vis = true;
+            });
+          }
+        }
+      });
+      var require_marker_colorbar = __commonJS({
+        "src/traces/scatter/marker_colorbar.js"(exports, module2) {
+          module2.exports = {
+            container: "marker",
+            min: "cmin",
+            max: "cmax"
+          };
+        }
+      });
+      var require_format_labels = __commonJS({
+        "src/traces/scatter/format_labels.js"(exports, module2) {
+          var Axes = require_axes();
+          module2.exports = function formatLabels(cdi, trace, fullLayout) {
+            var labels = {};
+            var mockGd = { _fullLayout: fullLayout };
+            var xa = Axes.getFromTrace(mockGd, trace, "x");
+            var ya2 = Axes.getFromTrace(mockGd, trace, "y");
+            var x2 = cdi.orig_x;
+            if (x2 === void 0) x2 = cdi.x;
+            var y2 = cdi.orig_y;
+            if (y2 === void 0) y2 = cdi.y;
+            labels.xLabel = Axes.tickText(xa, xa.c2l(x2), true).text;
+            labels.yLabel = Axes.tickText(ya2, ya2.c2l(y2), true).text;
+            return labels;
+          };
+        }
+      });
+      var require_style2 = __commonJS({
+        "src/traces/scatter/style.js"(exports, module2) {
+          var d3 = require_d3();
+          var Drawing = require_drawing();
+          var Registry = require_registry();
+          function style(gd2) {
+            var s2 = d3.select(gd2).selectAll("g.trace.scatter");
+            s2.style("opacity", function(d2) {
+              return d2[0].trace.opacity;
+            });
+            s2.selectAll("g.points").each(function(d2) {
+              var sel = d3.select(this);
+              var trace = d2.trace || d2[0].trace;
+              stylePoints(sel, trace, gd2);
+            });
+            s2.selectAll("g.text").each(function(d2) {
+              var sel = d3.select(this);
+              var trace = d2.trace || d2[0].trace;
+              styleText(sel, trace, gd2);
+            });
+            s2.selectAll("g.trace path.js-line").call(Drawing.lineGroupStyle);
+            s2.selectAll("g.trace path.js-fill").call(Drawing.fillGroupStyle, gd2, false);
+            Registry.getComponentMethod("errorbars", "style")(s2);
+          }
+          function stylePoints(sel, trace, gd2) {
+            Drawing.pointStyle(sel.selectAll("path.point"), trace, gd2);
+          }
+          function styleText(sel, trace, gd2) {
+            Drawing.textPointStyle(sel.selectAll("text"), trace, gd2);
+          }
+          function styleOnSelect(gd2, cd2, sel) {
+            var trace = cd2[0].trace;
+            if (trace.selectedpoints) {
+              Drawing.selectedPointStyle(sel.selectAll("path.point"), trace);
+              Drawing.selectedTextStyle(sel.selectAll("text"), trace);
+            } else {
+              stylePoints(sel, trace, gd2);
+              styleText(sel, trace, gd2);
+            }
+          }
+          module2.exports = {
+            style,
+            stylePoints,
+            styleText,
+            styleOnSelect
+          };
+        }
+      });
+      var require_get_trace_color = __commonJS({
+        "src/traces/scatter/get_trace_color.js"(exports, module2) {
+          var Color2 = require_color();
+          var subtypes = require_subtypes();
+          module2.exports = function getTraceColor(trace, di2) {
+            var lc2, tc2;
+            if (trace.mode === "lines") {
+              lc2 = trace.line.color;
+              return lc2 && Color2.opacity(lc2) ? lc2 : trace.fillcolor;
+            } else if (trace.mode === "none") {
+              return trace.fill ? trace.fillcolor : "";
+            } else {
+              var mc2 = di2.mcc || (trace.marker || {}).color;
+              var mlc = di2.mlcc || ((trace.marker || {}).line || {}).color;
+              tc2 = mc2 && Color2.opacity(mc2) ? mc2 : mlc && Color2.opacity(mlc) && (di2.mlw || ((trace.marker || {}).line || {}).width) ? mlc : "";
+              if (tc2) {
+                if (Color2.opacity(tc2) < 0.3) {
+                  return Color2.addOpacity(tc2, 0.3);
+                } else return tc2;
+              } else {
+                lc2 = (trace.line || {}).color;
+                return lc2 && Color2.opacity(lc2) && subtypes.hasLines(trace) && trace.line.width ? lc2 : trace.fillcolor;
+              }
+            }
+          };
+        }
+      });
+      var require_hover2 = __commonJS({
+        "src/traces/scatter/hover.js"(exports, module2) {
+          var Lib = require_lib();
+          var Fx = require_fx();
+          var Registry = require_registry();
+          var getTraceColor = require_get_trace_color();
+          var Color2 = require_color();
+          var fillText = Lib.fillText;
+          module2.exports = function hoverPoints(pointData, xval, yval, hovermode) {
+            var cd2 = pointData.cd;
+            var trace = cd2[0].trace;
+            var xa = pointData.xa;
+            var ya2 = pointData.ya;
+            var xpx = xa.c2p(xval);
+            var ypx = ya2.c2p(yval);
+            var pt2 = [xpx, ypx];
+            var hoveron = trace.hoveron || "";
+            var minRad = trace.mode.indexOf("markers") !== -1 ? 3 : 0.5;
+            var xPeriod = !!trace.xperiodalignment;
+            var yPeriod = !!trace.yperiodalignment;
+            if (hoveron.indexOf("points") !== -1) {
+              var dx = function(di22) {
+                if (xPeriod) {
+                  var x0 = xa.c2p(di22.xStart);
+                  var x1 = xa.c2p(di22.xEnd);
+                  return xpx >= Math.min(x0, x1) && xpx <= Math.max(x0, x1) ? 0 : Infinity;
+                }
+                var rad2 = Math.max(3, di22.mrc || 0);
+                var kink = 1 - 1 / rad2;
+                var dxRaw = Math.abs(xa.c2p(di22.x) - xpx);
+                return dxRaw < rad2 ? kink * dxRaw / rad2 : dxRaw - rad2 + kink;
+              };
+              var dy = function(di22) {
+                if (yPeriod) {
+                  var y0 = ya2.c2p(di22.yStart);
+                  var y1 = ya2.c2p(di22.yEnd);
+                  return ypx >= Math.min(y0, y1) && ypx <= Math.max(y0, y1) ? 0 : Infinity;
+                }
+                var rad2 = Math.max(3, di22.mrc || 0);
+                var kink = 1 - 1 / rad2;
+                var dyRaw = Math.abs(ya2.c2p(di22.y) - ypx);
+                return dyRaw < rad2 ? kink * dyRaw / rad2 : dyRaw - rad2 + kink;
+              };
+              var dxy = function(di22) {
+                var rad2 = Math.max(minRad, di22.mrc || 0);
+                var dx2 = xa.c2p(di22.x) - xpx;
+                var dy2 = ya2.c2p(di22.y) - ypx;
+                return Math.max(Math.sqrt(dx2 * dx2 + dy2 * dy2) - rad2, 1 - minRad / rad2);
+              };
+              var distfn = Fx.getDistanceFunction(hovermode, dx, dy, dxy);
+              Fx.getClosest(cd2, distfn, pointData);
+              if (pointData.index !== false) {
+                var di2 = cd2[pointData.index];
+                var xc2 = xa.c2p(di2.x, true);
+                var yc2 = ya2.c2p(di2.y, true);
+                var rad = di2.mrc || 1;
+                pointData.index = di2.i;
+                var orientation = cd2[0].t.orientation;
+                var sizeVal = orientation && (di2.sNorm || di2.s);
+                var xLabelVal = orientation === "h" ? sizeVal : di2.orig_x !== void 0 ? di2.orig_x : di2.x;
+                var yLabelVal = orientation === "v" ? sizeVal : di2.orig_y !== void 0 ? di2.orig_y : di2.y;
+                Lib.extendFlat(pointData, {
+                  color: getTraceColor(trace, di2),
+                  x0: xc2 - rad,
+                  x1: xc2 + rad,
+                  xLabelVal,
+                  y0: yc2 - rad,
+                  y1: yc2 + rad,
+                  yLabelVal,
+                  spikeDistance: dxy(di2),
+                  hovertemplate: trace.hovertemplate
+                });
+                fillText(di2, trace, pointData);
+                Registry.getComponentMethod("errorbars", "hoverInfo")(di2, trace, pointData);
+                return [pointData];
+              }
+            }
+            function isHoverPointInFillElement(el2) {
+              if (!el2) {
+                return false;
+              }
+              var svgElement = el2.node();
+              try {
+                var domPoint = new DOMPoint(pt2[0], pt2[1]);
+                return svgElement.isPointInFill(domPoint);
+              } catch (TypeError2) {
+                var svgPoint = svgElement.ownerSVGElement.createSVGPoint();
+                svgPoint.x = pt2[0];
+                svgPoint.y = pt2[1];
+                return svgElement.isPointInFill(svgPoint);
+              }
+            }
+            function getHoverLabelPosition(polygons) {
+              var i2;
+              var polygonsIn = [];
+              var xmin = Infinity;
+              var xmax = -Infinity;
+              var ymin = Infinity;
+              var ymax = -Infinity;
+              var yPos;
+              for (i2 = 0; i2 < polygons.length; i2++) {
+                var polygon = polygons[i2];
+                if (polygon.contains(pt2)) {
+                  polygonsIn.push(polygon);
+                  ymin = Math.min(ymin, polygon.ymin);
+                  ymax = Math.max(ymax, polygon.ymax);
+                }
+              }
+              if (polygonsIn.length === 0) {
+                return null;
+              }
+              ymin = Math.max(ymin, 0);
+              ymax = Math.min(ymax, ya2._length);
+              yPos = (ymin + ymax) / 2;
+              var j2, pts, xAtYPos, x0, x1, y0, y1;
+              for (i2 = 0; i2 < polygonsIn.length; i2++) {
+                pts = polygonsIn[i2].pts;
+                for (j2 = 1; j2 < pts.length; j2++) {
+                  y0 = pts[j2 - 1][1];
+                  y1 = pts[j2][1];
+                  if (y0 > yPos !== y1 >= yPos) {
+                    x0 = pts[j2 - 1][0];
+                    x1 = pts[j2][0];
+                    if (y1 - y0) {
+                      xAtYPos = x0 + (x1 - x0) * (yPos - y0) / (y1 - y0);
+                      xmin = Math.min(xmin, xAtYPos);
+                      xmax = Math.max(xmax, xAtYPos);
+                    }
+                  }
+                }
+              }
+              xmin = Math.max(xmin, 0);
+              xmax = Math.min(xmax, xa._length);
+              return {
+                x0: xmin,
+                x1: xmax,
+                y0: yPos,
+                y1: yPos
+              };
+            }
+            if (hoveron.indexOf("fills") !== -1 && trace._fillElement) {
+              var inside = isHoverPointInFillElement(trace._fillElement) && !isHoverPointInFillElement(trace._fillExclusionElement);
+              if (inside) {
+                var hoverLabelCoords = getHoverLabelPosition(trace._polygons);
+                if (hoverLabelCoords === null) {
+                  hoverLabelCoords = {
+                    x0: pt2[0],
+                    x1: pt2[0],
+                    y0: pt2[1],
+                    y1: pt2[1]
+                  };
+                }
+                var color22 = Color2.defaultLine;
+                if (Color2.opacity(trace.fillcolor)) color22 = trace.fillcolor;
+                else if (Color2.opacity((trace.line || {}).color)) {
+                  color22 = trace.line.color;
+                }
+                Lib.extendFlat(pointData, {
+                  // never let a 2D override 1D type as closest point
+                  // also: no spikeDistance, it's not allowed for fills
+                  distance: pointData.maxHoverDistance,
+                  x0: hoverLabelCoords.x0,
+                  x1: hoverLabelCoords.x1,
+                  y0: hoverLabelCoords.y0,
+                  y1: hoverLabelCoords.y1,
+                  color: color22,
+                  hovertemplate: false
+                });
+                delete pointData.index;
+                if (trace.text && !Lib.isArrayOrTypedArray(trace.text)) {
+                  pointData.text = String(trace.text);
+                } else pointData.text = trace.name;
+                return [pointData];
+              }
+            }
+          };
+        }
+      });
+      var require_select2 = __commonJS({
+        "src/traces/scatter/select.js"(exports, module2) {
+          var subtypes = require_subtypes();
+          module2.exports = function selectPoints(searchInfo, selectionTester) {
+            var cd2 = searchInfo.cd;
+            var xa = searchInfo.xaxis;
+            var ya2 = searchInfo.yaxis;
+            var selection = [];
+            var trace = cd2[0].trace;
+            var i2;
+            var di2;
+            var x2;
+            var y2;
+            var hasOnlyLines = !subtypes.hasMarkers(trace) && !subtypes.hasText(trace);
+            if (hasOnlyLines) return [];
+            if (selectionTester === false) {
+              for (i2 = 0; i2 < cd2.length; i2++) {
+                cd2[i2].selected = 0;
+              }
+            } else {
+              for (i2 = 0; i2 < cd2.length; i2++) {
+                di2 = cd2[i2];
+                x2 = xa.c2p(di2.x);
+                y2 = ya2.c2p(di2.y);
+                if (di2.i !== null && selectionTester.contains([x2, y2], false, i2, searchInfo)) {
+                  selection.push({
+                    pointNumber: di2.i,
+                    x: xa.c2d(di2.x),
+                    y: ya2.c2d(di2.y)
+                  });
+                  di2.selected = 1;
+                } else {
+                  di2.selected = 0;
+                }
+              }
+            }
+            return selection;
+          };
+        }
+      });
+      var require_attributes14 = __commonJS({
+        "src/plots/cartesian/attributes.js"(exports, module2) {
+          module2.exports = {
+            xaxis: {
+              valType: "subplotid",
+              dflt: "x",
+              editType: "calc+clearAxisTypes"
+            },
+            yaxis: {
+              valType: "subplotid",
+              dflt: "y",
+              editType: "calc+clearAxisTypes"
+            }
+          };
+        }
+      });
+      var require_type_defaults = __commonJS({
+        "src/plots/cartesian/type_defaults.js"(exports, module2) {
+          var traceIs = require_registry().traceIs;
+          var autoType = require_axis_autotype();
+          module2.exports = function handleTypeDefaults(containerIn, containerOut, coerce, options) {
+            coerce("autotypenumbers", options.autotypenumbersDflt);
+            var axType = coerce("type", (options.splomStash || {}).type);
+            if (axType === "-") {
+              setAutoType(containerOut, options.data);
+              if (containerOut.type === "-") {
+                containerOut.type = "linear";
+              } else {
+                containerIn.type = containerOut.type;
+              }
+            }
+          };
+          function setAutoType(ax, data) {
+            if (ax.type !== "-") return;
+            var id2 = ax._id;
+            var axLetter = id2.charAt(0);
+            var i2;
+            if (id2.indexOf("scene") !== -1) id2 = axLetter;
+            var d0 = getFirstNonEmptyTrace(data, id2, axLetter);
+            if (!d0) return;
+            if (d0.type === "histogram" && axLetter === { v: "y", h: "x" }[d0.orientation || "v"]) {
+              ax.type = "linear";
+              return;
+            }
+            var calAttr = axLetter + "calendar";
+            var calendar = d0[calAttr];
+            var opts = { noMultiCategory: !traceIs(d0, "cartesian") || traceIs(d0, "noMultiCategory") };
+            if (d0.type === "box" && d0._hasPreCompStats && axLetter === { h: "x", v: "y" }[d0.orientation || "v"]) {
+              opts.noMultiCategory = true;
+            }
+            opts.autotypenumbers = ax.autotypenumbers;
+            if (isBoxWithoutPositionCoords(d0, axLetter)) {
+              var posLetter = getBoxPosLetter(d0);
+              var boxPositions = [];
+              for (i2 = 0; i2 < data.length; i2++) {
+                var trace = data[i2];
+                if (!traceIs(trace, "box-violin") || (trace[axLetter + "axis"] || axLetter) !== id2) continue;
+                if (trace[posLetter] !== void 0) boxPositions.push(trace[posLetter][0]);
+                else if (trace.name !== void 0) boxPositions.push(trace.name);
+                else boxPositions.push("text");
+                if (trace[calAttr] !== calendar) calendar = void 0;
+              }
+              ax.type = autoType(boxPositions, calendar, opts);
+            } else if (d0.type === "splom") {
+              var dimensions = d0.dimensions;
+              var dim = dimensions[d0._axesDim[id2]];
+              if (dim.visible) ax.type = autoType(dim.values, calendar, opts);
+            } else {
+              ax.type = autoType(d0[axLetter] || [d0[axLetter + "0"]], calendar, opts);
+            }
+          }
+          function getFirstNonEmptyTrace(data, id2, axLetter) {
+            for (var i2 = 0; i2 < data.length; i2++) {
+              var trace = data[i2];
+              if (trace.type === "splom" && trace._length > 0 && (trace["_" + axLetter + "axes"] || {})[id2]) {
+                return trace;
+              }
+              if ((trace[axLetter + "axis"] || axLetter) === id2) {
+                if (isBoxWithoutPositionCoords(trace, axLetter)) {
+                  return trace;
+                } else if ((trace[axLetter] || []).length || trace[axLetter + "0"]) {
+                  return trace;
+                }
+              }
+            }
+          }
+          function getBoxPosLetter(trace) {
+            return { v: "x", h: "y" }[trace.orientation || "v"];
+          }
+          function isBoxWithoutPositionCoords(trace, axLetter) {
+            var posLetter = getBoxPosLetter(trace);
+            var isBox = traceIs(trace, "box-violin");
+            var isCandlestick = traceIs(trace._fullInput || {}, "candlestick");
+            return isBox && !isCandlestick && axLetter === posLetter && trace[posLetter] === void 0 && trace[posLetter + "0"] === void 0;
+          }
+        }
+      });
+      var require_category_order_defaults = __commonJS({
+        "src/plots/cartesian/category_order_defaults.js"(exports, module2) {
+          var isTypedArraySpec = require_array().isTypedArraySpec;
+          function findCategories(ax, opts) {
+            var dataAttr = opts.dataAttr || ax._id.charAt(0);
+            var lookup = {};
+            var axData;
+            var i2, j2;
+            if (opts.axData) {
+              axData = opts.axData;
+            } else {
+              axData = [];
+              for (i2 = 0; i2 < opts.data.length; i2++) {
+                var trace = opts.data[i2];
+                if (trace[dataAttr + "axis"] === ax._id) {
+                  axData.push(trace);
+                }
+              }
+            }
+            for (i2 = 0; i2 < axData.length; i2++) {
+              var vals = axData[i2][dataAttr];
+              for (j2 = 0; j2 < vals.length; j2++) {
+                var v2 = vals[j2];
+                if (v2 !== null && v2 !== void 0) {
+                  lookup[v2] = 1;
+                }
+              }
+            }
+            return Object.keys(lookup);
+          }
+          module2.exports = function handleCategoryOrderDefaults(containerIn, containerOut, coerce, opts) {
+            if (containerOut.type !== "category") return;
+            var arrayIn = containerIn.categoryarray;
+            var isValidArray = Array.isArray(arrayIn) && arrayIn.length > 0 || isTypedArraySpec(arrayIn);
+            var orderDefault;
+            if (isValidArray) orderDefault = "array";
+            var order = coerce("categoryorder", orderDefault);
+            var array;
+            if (order === "array") {
+              array = coerce("categoryarray");
+            }
+            if (!isValidArray && order === "array") {
+              order = containerOut.categoryorder = "trace";
+            }
+            if (order === "trace") {
+              containerOut._initialCategories = [];
+            } else if (order === "array") {
+              containerOut._initialCategories = array.slice();
+            } else {
+              array = findCategories(containerOut, opts).sort();
+              if (order === "category ascending") {
+                containerOut._initialCategories = array;
+              } else if (order === "category descending") {
+                containerOut._initialCategories = array.reverse();
+              }
+            }
+          };
+        }
+      });
+      var require_line_grid_defaults = __commonJS({
+        "src/plots/cartesian/line_grid_defaults.js"(exports, module2) {
+          var colorMix = require_tinycolor().mix;
+          var colorAttrs = require_attributes3();
+          var Lib = require_lib();
+          module2.exports = function handleLineGridDefaults(containerIn, containerOut, coerce, opts) {
+            opts = opts || {};
+            var dfltColor = opts.dfltColor;
+            function coerce2(attr, dflt) {
+              return Lib.coerce2(containerIn, containerOut, opts.attributes, attr, dflt);
+            }
+            var lineColor = coerce2("linecolor", dfltColor);
+            var lineWidth = coerce2("linewidth");
+            var showLine = coerce("showline", opts.showLine || !!lineColor || !!lineWidth);
+            if (!showLine) {
+              delete containerOut.linecolor;
+              delete containerOut.linewidth;
+            }
+            var gridColorDflt = colorMix(dfltColor, opts.bgColor, opts.blend || colorAttrs.lightFraction).toRgbString();
+            var gridColor = coerce2("gridcolor", gridColorDflt);
+            var gridWidth = coerce2("gridwidth");
+            var gridDash = coerce2("griddash");
+            var showGridLines = coerce(
+              "showgrid",
+              opts.showGrid || !!gridColor || !!gridWidth || !!gridDash
+            );
+            if (!showGridLines) {
+              delete containerOut.gridcolor;
+              delete containerOut.gridwidth;
+              delete containerOut.griddash;
+            }
+            if (opts.hasMinor) {
+              var minorGridColorDflt = colorMix(containerOut.gridcolor, opts.bgColor, 67).toRgbString();
+              var minorGridColor = coerce2("minor.gridcolor", minorGridColorDflt);
+              var minorGridWidth = coerce2("minor.gridwidth", containerOut.gridwidth || 1);
+              var minorGridDash = coerce2("minor.griddash", containerOut.griddash || "solid");
+              var minorShowGridLines = coerce(
+                "minor.showgrid",
+                !!minorGridColor || !!minorGridWidth || !!minorGridDash
+              );
+              if (!minorShowGridLines) {
+                delete containerOut.minor.gridcolor;
+                delete containerOut.minor.gridwidth;
+                delete containerOut.minor.griddash;
+              }
+            }
+            if (!opts.noZeroLine) {
+              coerce2("zerolinelayer");
+              var zeroLineColor = coerce2("zerolinecolor", dfltColor);
+              var zeroLineWidth = coerce2("zerolinewidth");
+              var showZeroLine = coerce("zeroline", opts.showGrid || !!zeroLineColor || !!zeroLineWidth);
+              if (!showZeroLine) {
+                delete containerOut.zerolinelayer;
+                delete containerOut.zerolinecolor;
+                delete containerOut.zerolinewidth;
+              }
+            }
+          };
+        }
+      });
+      var require_axis_defaults = __commonJS({
+        "src/plots/cartesian/axis_defaults.js"(exports, module2) {
+          var isNumeric = require_fast_isnumeric();
+          var Registry = require_registry();
+          var Lib = require_lib();
+          var Template = require_plot_template();
+          var handleArrayContainerDefaults = require_array_container_defaults();
+          var layoutAttributes = require_layout_attributes4();
+          var handleTickValueDefaults = require_tick_value_defaults();
+          var handleTickMarkDefaults = require_tick_mark_defaults();
+          var handleTickLabelDefaults = require_tick_label_defaults();
+          var handlePrefixSuffixDefaults = require_prefix_suffix_defaults();
+          var handleCategoryOrderDefaults = require_category_order_defaults();
+          var handleLineGridDefaults = require_line_grid_defaults();
+          var handleRangeDefaults = require_range_defaults();
+          var setConvert = require_set_convert();
+          var DAY_OF_WEEK = require_constants2().WEEKDAY_PATTERN;
+          var HOUR = require_constants2().HOUR_PATTERN;
+          module2.exports = function handleAxisDefaults(containerIn, containerOut, coerce, options, layoutOut) {
+            var letter = options.letter;
+            var font = options.font || {};
+            var splomStash = options.splomStash || {};
+            var visible = coerce("visible", !options.visibleDflt);
+            var axTemplate = containerOut._template || {};
+            var axType = containerOut.type || axTemplate.type || "-";
+            var ticklabelmode;
+            if (axType === "date") {
+              var handleCalendarDefaults = Registry.getComponentMethod("calendars", "handleDefaults");
+              handleCalendarDefaults(containerIn, containerOut, "calendar", options.calendar);
+              if (!options.noTicklabelmode) {
+                ticklabelmode = coerce("ticklabelmode");
+              }
+            }
+            if (!options.noTicklabelindex && (axType === "date" || axType === "linear")) {
+              coerce("ticklabelindex");
+            }
+            var ticklabelposition = "";
+            if (!options.noTicklabelposition || axType === "multicategory") {
+              ticklabelposition = Lib.coerce(containerIn, containerOut, {
+                ticklabelposition: {
+                  valType: "enumerated",
+                  dflt: "outside",
+                  values: ticklabelmode === "period" ? ["outside", "inside"] : letter === "x" ? [
+                    "outside",
+                    "inside",
+                    "outside left",
+                    "inside left",
+                    "outside right",
+                    "inside right"
+                  ] : [
+                    "outside",
+                    "inside",
+                    "outside top",
+                    "inside top",
+                    "outside bottom",
+                    "inside bottom"
+                  ]
+                }
+              }, "ticklabelposition");
+            }
+            if (!options.noTicklabeloverflow) {
+              coerce(
+                "ticklabeloverflow",
+                ticklabelposition.indexOf("inside") !== -1 ? "hide past domain" : axType === "category" || axType === "multicategory" ? "allow" : "hide past div"
+              );
+            }
+            setConvert(containerOut, layoutOut);
+            handleRangeDefaults(containerIn, containerOut, coerce, options);
+            handleCategoryOrderDefaults(containerIn, containerOut, coerce, options);
+            if (!options.noHover) {
+              if (axType !== "category") coerce("hoverformat");
+              if (!options.noUnifiedhovertitle) {
+                coerce("unifiedhovertitle.text");
+              }
+            }
+            var dfltColor = coerce("color");
+            var dfltFontColor = dfltColor !== layoutAttributes.color.dflt ? dfltColor : font.color;
+            var dfltTitle = splomStash.label || layoutOut._dfltTitle[letter];
+            handlePrefixSuffixDefaults(containerIn, containerOut, coerce, axType, options);
+            if (!visible) return containerOut;
+            coerce("title.text", dfltTitle);
+            Lib.coerceFont(coerce, "title.font", font, { overrideDflt: {
+              size: Lib.bigFont(font.size),
+              color: dfltFontColor
+            } });
+            handleTickValueDefaults(containerIn, containerOut, coerce, axType);
+            var hasMinor = options.hasMinor;
+            if (hasMinor) {
+              Template.newContainer(containerOut, "minor");
+              handleTickValueDefaults(containerIn, containerOut, coerce, axType, { isMinor: true });
+            }
+            handleTickLabelDefaults(containerIn, containerOut, coerce, axType, options);
+            handleTickMarkDefaults(containerIn, containerOut, coerce, options);
+            if (hasMinor) {
+              var keepIsMinor = options.isMinor;
+              options.isMinor = true;
+              handleTickMarkDefaults(containerIn, containerOut, coerce, options);
+              options.isMinor = keepIsMinor;
+            }
+            handleLineGridDefaults(containerIn, containerOut, coerce, {
+              dfltColor,
+              bgColor: options.bgColor,
+              showGrid: options.showGrid,
+              hasMinor,
+              attributes: layoutAttributes
+            });
+            if (hasMinor && !containerOut.minor.ticks && !containerOut.minor.showgrid) {
+              delete containerOut.minor;
+            }
+            if (containerOut.showline || containerOut.ticks) coerce("mirror");
+            var isMultiCategory = axType === "multicategory";
+            if (!options.noTickson && (axType === "category" || isMultiCategory) && (containerOut.ticks || containerOut.showgrid)) {
+              if (isMultiCategory) {
+                coerce("tickson", "boundaries");
+                delete containerOut.ticklabelposition;
+              } else {
+                coerce("tickson");
+              }
+            }
+            if (isMultiCategory) {
+              var showDividers = coerce("showdividers");
+              if (showDividers) {
+                coerce("dividercolor");
+                coerce("dividerwidth");
+              }
+            }
+            if (axType === "date") {
+              handleArrayContainerDefaults(containerIn, containerOut, {
+                name: "rangebreaks",
+                inclusionAttr: "enabled",
+                handleItemDefaults: rangebreaksDefaults
+              });
+              if (!containerOut.rangebreaks.length) {
+                delete containerOut.rangebreaks;
+              } else {
+                for (var k2 = 0; k2 < containerOut.rangebreaks.length; k2++) {
+                  if (containerOut.rangebreaks[k2].pattern === DAY_OF_WEEK) {
+                    containerOut._hasDayOfWeekBreaks = true;
+                    break;
+                  }
+                }
+                setConvert(containerOut, layoutOut);
+                if (layoutOut._has("scattergl") || layoutOut._has("splom")) {
+                  for (var i2 = 0; i2 < options.data.length; i2++) {
+                    var trace = options.data[i2];
+                    if (trace.type === "scattergl" || trace.type === "splom") {
+                      trace.visible = false;
+                      Lib.warn(trace.type + " traces do not work on axes with rangebreaks. Setting trace " + trace.index + " to `visible: false`.");
+                    }
+                  }
+                }
+              }
+            }
+            return containerOut;
+          };
+          function rangebreaksDefaults(itemIn, itemOut, containerOut) {
+            function coerce(attr, dflt) {
+              return Lib.coerce(itemIn, itemOut, layoutAttributes.rangebreaks, attr, dflt);
+            }
+            var enabled = coerce("enabled");
+            if (enabled) {
+              var bnds = coerce("bounds");
+              if (bnds && bnds.length >= 2) {
+                var dfltPattern = "";
+                var i2, q2;
+                if (bnds.length === 2) {
+                  for (i2 = 0; i2 < 2; i2++) {
+                    q2 = indexOfDay(bnds[i2]);
+                    if (q2) {
+                      dfltPattern = DAY_OF_WEEK;
+                      break;
+                    }
+                  }
+                }
+                var pattern = coerce("pattern", dfltPattern);
+                if (pattern === DAY_OF_WEEK) {
+                  for (i2 = 0; i2 < 2; i2++) {
+                    q2 = indexOfDay(bnds[i2]);
+                    if (q2) {
+                      itemOut.bounds[i2] = bnds[i2] = q2 - 1;
+                    }
+                  }
+                }
+                if (pattern) {
+                  for (i2 = 0; i2 < 2; i2++) {
+                    q2 = bnds[i2];
+                    switch (pattern) {
+                      case DAY_OF_WEEK:
+                        if (!isNumeric(q2)) {
+                          itemOut.enabled = false;
+                          return;
+                        }
+                        q2 = +q2;
+                        if (q2 !== Math.floor(q2) || // don't accept fractional days for mow
+                        q2 < 0 || q2 >= 7) {
+                          itemOut.enabled = false;
+                          return;
+                        }
+                        itemOut.bounds[i2] = bnds[i2] = q2;
+                        break;
+                      case HOUR:
+                        if (!isNumeric(q2)) {
+                          itemOut.enabled = false;
+                          return;
+                        }
+                        q2 = +q2;
+                        if (q2 < 0 || q2 > 24) {
+                          itemOut.enabled = false;
+                          return;
+                        }
+                        itemOut.bounds[i2] = bnds[i2] = q2;
+                        break;
+                    }
+                  }
+                }
+                if (containerOut.autorange === false) {
+                  var rng = containerOut.range;
+                  if (rng[0] < rng[1]) {
+                    if (bnds[0] < rng[0] && bnds[1] > rng[1]) {
+                      itemOut.enabled = false;
+                      return;
+                    }
+                  } else if (bnds[0] > rng[0] && bnds[1] < rng[1]) {
+                    itemOut.enabled = false;
+                    return;
+                  }
+                }
+              } else {
+                var values = coerce("values");
+                if (values && values.length) {
+                  coerce("dvalue");
+                } else {
+                  itemOut.enabled = false;
+                  return;
+                }
+              }
+            }
+          }
+          var dayStrToNum = {
+            sun: 1,
+            mon: 2,
+            tue: 3,
+            wed: 4,
+            thu: 5,
+            fri: 6,
+            sat: 7
+          };
+          function indexOfDay(v2) {
+            if (typeof v2 !== "string") return;
+            return dayStrToNum[v2.slice(0, 3).toLowerCase()];
+          }
+        }
+      });
+      var require_position_defaults = __commonJS({
+        "src/plots/cartesian/position_defaults.js"(exports, module2) {
+          var isNumeric = require_fast_isnumeric();
+          var Lib = require_lib();
+          module2.exports = function handlePositionDefaults(containerIn, containerOut, coerce, options) {
+            var counterAxes = options.counterAxes || [];
+            var overlayableAxes = options.overlayableAxes || [];
+            var letter = options.letter;
+            var grid = options.grid;
+            var overlayingDomain = options.overlayingDomain;
+            var dfltAnchor, dfltDomain, dfltSide, dfltPosition, dfltShift, dfltAutomargin;
+            if (grid) {
+              dfltDomain = grid._domains[letter][grid._axisMap[containerOut._id]];
+              dfltAnchor = grid._anchors[containerOut._id];
+              if (dfltDomain) {
+                dfltSide = grid[letter + "side"].split(" ")[0];
+                dfltPosition = grid.domain[letter][dfltSide === "right" || dfltSide === "top" ? 1 : 0];
+              }
+            }
+            dfltDomain = dfltDomain || [0, 1];
+            dfltAnchor = dfltAnchor || (isNumeric(containerIn.position) ? "free" : counterAxes[0] || "free");
+            dfltSide = dfltSide || (letter === "x" ? "bottom" : "left");
+            dfltPosition = dfltPosition || 0;
+            dfltShift = 0;
+            dfltAutomargin = false;
+            var anchor = Lib.coerce(containerIn, containerOut, {
+              anchor: {
+                valType: "enumerated",
+                values: ["free"].concat(counterAxes),
+                dflt: dfltAnchor
+              }
+            }, "anchor");
+            var side = Lib.coerce(containerIn, containerOut, {
+              side: {
+                valType: "enumerated",
+                values: letter === "x" ? ["bottom", "top"] : ["left", "right"],
+                dflt: dfltSide
+              }
+            }, "side");
+            if (anchor === "free") {
+              if (letter === "y") {
+                var autoshift = coerce("autoshift");
+                if (autoshift) {
+                  dfltPosition = side === "left" ? overlayingDomain[0] : overlayingDomain[1];
+                  dfltAutomargin = containerOut.automargin ? containerOut.automargin : true;
+                  dfltShift = side === "left" ? -3 : 3;
+                }
+                coerce("shift", dfltShift);
+              }
+              coerce("position", dfltPosition);
+            }
+            coerce("automargin", dfltAutomargin);
+            var overlaying = false;
+            if (overlayableAxes.length) {
+              overlaying = Lib.coerce(containerIn, containerOut, {
+                overlaying: {
+                  valType: "enumerated",
+                  values: [false].concat(overlayableAxes),
+                  dflt: false
+                }
+              }, "overlaying");
+            }
+            if (!overlaying) {
+              var domain = coerce("domain", dfltDomain);
+              if (domain[0] > domain[1] - 1 / 4096) containerOut.domain = dfltDomain;
+              Lib.noneOrAll(containerIn.domain, containerOut.domain, dfltDomain);
+              if (containerOut.tickmode === "sync") {
+                containerOut.tickmode = "auto";
+              }
+            }
+            coerce("layer");
+            return containerOut;
+          };
+        }
+      });
+      var require_layout_defaults4 = __commonJS({
+        "src/plots/cartesian/layout_defaults.js"(exports, module2) {
+          var Lib = require_lib();
+          var Color2 = require_color();
+          var isUnifiedHover = require_helpers2().isUnifiedHover;
+          var handleHoverModeDefaults = require_hovermode_defaults();
+          var Template = require_plot_template();
+          var basePlotLayoutAttributes = require_layout_attributes2();
+          var layoutAttributes = require_layout_attributes4();
+          var handleTypeDefaults = require_type_defaults();
+          var handleAxisDefaults = require_axis_defaults();
+          var constraints = require_constraints();
+          var handlePositionDefaults = require_position_defaults();
+          var axisIds = require_axis_ids();
+          var id2name = axisIds.id2name;
+          var name2id = axisIds.name2id;
+          var AX_ID_PATTERN = require_constants2().AX_ID_PATTERN;
+          var Registry = require_registry();
+          var traceIs = Registry.traceIs;
+          var getComponentMethod = Registry.getComponentMethod;
+          function appendList(cont, k2, item) {
+            if (Array.isArray(cont[k2])) cont[k2].push(item);
+            else cont[k2] = [item];
+          }
+          module2.exports = function supplyLayoutDefaults(layoutIn, layoutOut, fullData) {
+            var autotypenumbersDflt = layoutOut.autotypenumbers;
+            var ax2traces = {};
+            var xaMayHide = {};
+            var yaMayHide = {};
+            var xaMustDisplay = {};
+            var yaMustDisplay = {};
+            var yaMustNotReverse = {};
+            var yaMayReverse = {};
+            var axHasImage = {};
+            var outerTicks = {};
+            var noGrids = {};
+            var i2, j2;
+            for (i2 = 0; i2 < fullData.length; i2++) {
+              var trace = fullData[i2];
+              if (!traceIs(trace, "cartesian")) continue;
+              var xaName;
+              if (trace.xaxis) {
+                xaName = id2name(trace.xaxis);
+                appendList(ax2traces, xaName, trace);
+              } else if (trace.xaxes) {
+                for (j2 = 0; j2 < trace.xaxes.length; j2++) {
+                  appendList(ax2traces, id2name(trace.xaxes[j2]), trace);
+                }
+              }
+              var yaName;
+              if (trace.yaxis) {
+                yaName = id2name(trace.yaxis);
+                appendList(ax2traces, yaName, trace);
+              } else if (trace.yaxes) {
+                for (j2 = 0; j2 < trace.yaxes.length; j2++) {
+                  appendList(ax2traces, id2name(trace.yaxes[j2]), trace);
+                }
+              }
+              if (trace.type === "funnel") {
+                if (trace.orientation === "h") {
+                  if (xaName) xaMayHide[xaName] = true;
+                  if (yaName) yaMayReverse[yaName] = true;
+                } else {
+                  if (yaName) yaMayHide[yaName] = true;
+                }
+              } else if (trace.type === "image") {
+                if (yaName) axHasImage[yaName] = true;
+                if (xaName) axHasImage[xaName] = true;
+              } else {
+                if (yaName) {
+                  yaMustDisplay[yaName] = true;
+                  yaMustNotReverse[yaName] = true;
+                }
+                if (!traceIs(trace, "carpet") || trace.type === "carpet" && !trace._cheater) {
+                  if (xaName) xaMustDisplay[xaName] = true;
+                }
+              }
+              if (trace.type === "carpet" && trace._cheater) {
+                if (xaName) xaMayHide[xaName] = true;
+              }
+              if (traceIs(trace, "2dMap")) {
+                outerTicks[xaName] = true;
+                outerTicks[yaName] = true;
+              }
+              if (traceIs(trace, "oriented")) {
+                var positionAxis = trace.orientation === "h" ? yaName : xaName;
+                noGrids[positionAxis] = true;
+              }
+            }
+            var subplots = layoutOut._subplots;
+            var xIds = subplots.xaxis;
+            var yIds = subplots.yaxis;
+            var xNames = Lib.simpleMap(xIds, id2name);
+            var yNames = Lib.simpleMap(yIds, id2name);
+            var axNames = xNames.concat(yNames);
+            var plotBgColor = Color2.background;
+            if (xIds.length && yIds.length) {
+              plotBgColor = Lib.coerce(layoutIn, layoutOut, basePlotLayoutAttributes, "plot_bgcolor");
+            }
+            var bgColor = Color2.combine(plotBgColor, layoutOut.paper_bgcolor);
+            var axName;
+            var axId;
+            var axLetter;
+            var axLayoutIn;
+            var axLayoutOut;
+            function newAxLayoutOut() {
+              var traces = ax2traces[axName] || [];
+              axLayoutOut._traceIndices = traces.map(function(t4) {
+                return t4.index;
+              });
+              axLayoutOut._annIndices = [];
+              axLayoutOut._shapeIndices = [];
+              axLayoutOut._selectionIndices = [];
+              axLayoutOut._imgIndices = [];
+              axLayoutOut._subplotsWith = [];
+              axLayoutOut._counterAxes = [];
+              axLayoutOut._name = axLayoutOut._attr = axName;
+              axLayoutOut._id = axId;
+            }
+            function coerce(attr, dflt) {
+              return Lib.coerce(axLayoutIn, axLayoutOut, layoutAttributes, attr, dflt);
+            }
+            function coerce2(attr, dflt) {
+              return Lib.coerce2(axLayoutIn, axLayoutOut, layoutAttributes, attr, dflt);
+            }
+            function getCounterAxes(axLetter2) {
+              return axLetter2 === "x" ? yIds : xIds;
+            }
+            function getOverlayableAxes(axLetter2, axName2) {
+              var list = axLetter2 === "x" ? xNames : yNames;
+              var out = [];
+              for (var j22 = 0; j22 < list.length; j22++) {
+                var axName22 = list[j22];
+                if (axName22 !== axName2 && !(layoutIn[axName22] || {}).overlaying) {
+                  out.push(name2id(axName22));
+                }
+              }
+              return out;
+            }
+            var counterAxes = { x: getCounterAxes("x"), y: getCounterAxes("y") };
+            var allAxisIds = counterAxes.x.concat(counterAxes.y);
+            var missingMatchedAxisIdsLookup = {};
+            var missingMatchedAxisIds = [];
+            function addMissingMatchedAxis() {
+              var matchesIn = axLayoutIn.matches;
+              if (AX_ID_PATTERN.test(matchesIn) && allAxisIds.indexOf(matchesIn) === -1) {
+                missingMatchedAxisIdsLookup[matchesIn] = axLayoutIn.type;
+                missingMatchedAxisIds = Object.keys(missingMatchedAxisIdsLookup);
+              }
+            }
+            var hovermode = handleHoverModeDefaults(layoutIn, layoutOut);
+            var unifiedHover = isUnifiedHover(hovermode);
+            for (i2 = 0; i2 < axNames.length; i2++) {
+              axName = axNames[i2];
+              axId = name2id(axName);
+              axLetter = axName.charAt(0);
+              if (!Lib.isPlainObject(layoutIn[axName])) {
+                layoutIn[axName] = {};
+              }
+              axLayoutIn = layoutIn[axName];
+              axLayoutOut = Template.newContainer(layoutOut, axName, axLetter + "axis");
+              newAxLayoutOut();
+              var visibleDflt = axLetter === "x" && !xaMustDisplay[axName] && xaMayHide[axName] || axLetter === "y" && !yaMustDisplay[axName] && yaMayHide[axName];
+              var reverseDflt = axLetter === "y" && (!yaMustNotReverse[axName] && yaMayReverse[axName] || axHasImage[axName]);
+              var defaultOptions2 = {
+                hasMinor: true,
+                letter: axLetter,
+                font: layoutOut.font,
+                outerTicks: outerTicks[axName],
+                showGrid: !noGrids[axName],
+                data: ax2traces[axName] || [],
+                bgColor,
+                calendar: layoutOut.calendar,
+                automargin: true,
+                visibleDflt,
+                reverseDflt,
+                autotypenumbersDflt,
+                splomStash: ((layoutOut._splomAxes || {})[axLetter] || {})[axId],
+                noAutotickangles: axLetter === "y"
+              };
+              coerce("uirevision", layoutOut.uirevision);
+              handleTypeDefaults(axLayoutIn, axLayoutOut, coerce, defaultOptions2);
+              handleAxisDefaults(axLayoutIn, axLayoutOut, coerce, defaultOptions2, layoutOut);
+              var unifiedSpike = unifiedHover && axLetter === hovermode.charAt(0);
+              var spikecolor = coerce2("spikecolor", unifiedHover ? axLayoutOut.color : void 0);
+              var spikethickness = coerce2("spikethickness", unifiedHover ? 1.5 : void 0);
+              var spikedash = coerce2("spikedash", unifiedHover ? "dot" : void 0);
+              var spikemode = coerce2("spikemode", unifiedHover ? "across" : void 0);
+              var spikesnap = coerce2("spikesnap");
+              var showSpikes = coerce("showspikes", !!unifiedSpike || !!spikecolor || !!spikethickness || !!spikedash || !!spikemode || !!spikesnap);
+              if (!showSpikes) {
+                delete axLayoutOut.spikecolor;
+                delete axLayoutOut.spikethickness;
+                delete axLayoutOut.spikedash;
+                delete axLayoutOut.spikemode;
+                delete axLayoutOut.spikesnap;
+              }
+              var overlayingAxis = id2name(axLayoutIn.overlaying);
+              var overlayingAnchorDomain = [0, 1];
+              if (layoutOut[overlayingAxis] !== void 0) {
+                var overlayingAnchor = id2name(layoutOut[overlayingAxis].anchor);
+                if (layoutOut[overlayingAnchor] !== void 0) {
+                  overlayingAnchorDomain = layoutOut[overlayingAnchor].domain;
+                }
+              }
+              handlePositionDefaults(axLayoutIn, axLayoutOut, coerce, {
+                letter: axLetter,
+                counterAxes: counterAxes[axLetter],
+                overlayableAxes: getOverlayableAxes(axLetter, axName),
+                grid: layoutOut.grid,
+                overlayingDomain: overlayingAnchorDomain
+              });
+              coerce("title.standoff");
+              addMissingMatchedAxis();
+              axLayoutOut._input = axLayoutIn;
+            }
+            i2 = 0;
+            while (i2 < missingMatchedAxisIds.length) {
+              axId = missingMatchedAxisIds[i2++];
+              axName = id2name(axId);
+              axLetter = axName.charAt(0);
+              if (!Lib.isPlainObject(layoutIn[axName])) {
+                layoutIn[axName] = {};
+              }
+              axLayoutIn = layoutIn[axName];
+              axLayoutOut = Template.newContainer(layoutOut, axName, axLetter + "axis");
+              newAxLayoutOut();
+              var defaultOptions22 = {
+                letter: axLetter,
+                font: layoutOut.font,
+                outerTicks: outerTicks[axName],
+                showGrid: !noGrids[axName],
+                data: [],
+                bgColor,
+                calendar: layoutOut.calendar,
+                automargin: true,
+                visibleDflt: false,
+                reverseDflt: false,
+                autotypenumbersDflt,
+                splomStash: ((layoutOut._splomAxes || {})[axLetter] || {})[axId]
+              };
+              coerce("uirevision", layoutOut.uirevision);
+              axLayoutOut.type = missingMatchedAxisIdsLookup[axId] || "linear";
+              handleAxisDefaults(axLayoutIn, axLayoutOut, coerce, defaultOptions22, layoutOut);
+              handlePositionDefaults(axLayoutIn, axLayoutOut, coerce, {
+                letter: axLetter,
+                counterAxes: counterAxes[axLetter],
+                overlayableAxes: getOverlayableAxes(axLetter, axName),
+                grid: layoutOut.grid
+              });
+              coerce("fixedrange");
+              coerce("modebardisable");
+              addMissingMatchedAxis();
+              axLayoutOut._input = axLayoutIn;
+            }
+            var rangeSliderDefaults = getComponentMethod("rangeslider", "handleDefaults");
+            var rangeSelectorDefaults = getComponentMethod("rangeselector", "handleDefaults");
+            for (i2 = 0; i2 < xNames.length; i2++) {
+              axName = xNames[i2];
+              axLayoutIn = layoutIn[axName];
+              axLayoutOut = layoutOut[axName];
+              rangeSliderDefaults(layoutIn, layoutOut, axName);
+              if (axLayoutOut.type === "date") {
+                rangeSelectorDefaults(
+                  axLayoutIn,
+                  axLayoutOut,
+                  layoutOut,
+                  yNames,
+                  axLayoutOut.calendar
+                );
+              }
+              coerce("fixedrange");
+              coerce("modebardisable");
+            }
+            for (i2 = 0; i2 < yNames.length; i2++) {
+              axName = yNames[i2];
+              axLayoutIn = layoutIn[axName];
+              axLayoutOut = layoutOut[axName];
+              var anchoredAxis = layoutOut[id2name(axLayoutOut.anchor)];
+              var fixedRangeDflt = getComponentMethod("rangeslider", "isVisible")(anchoredAxis);
+              coerce("fixedrange", fixedRangeDflt);
+              coerce("modebardisable");
+            }
+            constraints.handleDefaults(layoutIn, layoutOut, {
+              axIds: allAxisIds.concat(missingMatchedAxisIds).sort(axisIds.idSort),
+              axHasImage
+            });
+          };
+        }
+      });
+      var require_transition_axes = __commonJS({
+        "src/plots/cartesian/transition_axes.js"(exports, module2) {
+          var d3 = require_d3();
+          var Registry = require_registry();
+          var Lib = require_lib();
+          var Drawing = require_drawing();
+          var Axes = require_axes();
+          module2.exports = function transitionAxes(gd2, edits, transitionOpts, makeOnCompleteCallback) {
+            var fullLayout = gd2._fullLayout;
+            if (edits.length === 0) {
+              Axes.redrawComponents(gd2);
+              return;
+            }
+            function unsetSubplotTransform(subplot) {
+              var xa = subplot.xaxis;
+              var ya2 = subplot.yaxis;
+              fullLayout._defs.select("#" + subplot.clipId + "> rect").call(Drawing.setTranslate, 0, 0).call(Drawing.setScale, 1, 1);
+              subplot.plot.call(Drawing.setTranslate, xa._offset, ya2._offset).call(Drawing.setScale, 1, 1);
+              var traceGroups = subplot.plot.selectAll(".scatterlayer .trace");
+              traceGroups.selectAll(".point").call(Drawing.setPointGroupScale, 1, 1);
+              traceGroups.selectAll(".textpoint").call(Drawing.setTextPointsScale, 1, 1);
+              traceGroups.call(Drawing.hideOutsideRangePoints, subplot);
+            }
+            function updateSubplot(edit, progress) {
+              var plotinfo = edit.plotinfo;
+              var xa = plotinfo.xaxis;
+              var ya2 = plotinfo.yaxis;
+              var xlen = xa._length;
+              var ylen = ya2._length;
+              var editX = !!edit.xr1;
+              var editY = !!edit.yr1;
+              var viewBox = [];
+              if (editX) {
+                var xr0 = Lib.simpleMap(edit.xr0, xa.r2l);
+                var xr1 = Lib.simpleMap(edit.xr1, xa.r2l);
+                var dx0 = xr0[1] - xr0[0];
+                var dx1 = xr1[1] - xr1[0];
+                viewBox[0] = (xr0[0] * (1 - progress) + progress * xr1[0] - xr0[0]) / (xr0[1] - xr0[0]) * xlen;
+                viewBox[2] = xlen * (1 - progress + progress * dx1 / dx0);
+                xa.range[0] = xa.l2r(xr0[0] * (1 - progress) + progress * xr1[0]);
+                xa.range[1] = xa.l2r(xr0[1] * (1 - progress) + progress * xr1[1]);
+              } else {
+                viewBox[0] = 0;
+                viewBox[2] = xlen;
+              }
+              if (editY) {
+                var yr0 = Lib.simpleMap(edit.yr0, ya2.r2l);
+                var yr1 = Lib.simpleMap(edit.yr1, ya2.r2l);
+                var dy0 = yr0[1] - yr0[0];
+                var dy1 = yr1[1] - yr1[0];
+                viewBox[1] = (yr0[1] * (1 - progress) + progress * yr1[1] - yr0[1]) / (yr0[0] - yr0[1]) * ylen;
+                viewBox[3] = ylen * (1 - progress + progress * dy1 / dy0);
+                ya2.range[0] = xa.l2r(yr0[0] * (1 - progress) + progress * yr1[0]);
+                ya2.range[1] = ya2.l2r(yr0[1] * (1 - progress) + progress * yr1[1]);
+              } else {
+                viewBox[1] = 0;
+                viewBox[3] = ylen;
+              }
+              Axes.drawOne(gd2, xa, { skipTitle: true });
+              Axes.drawOne(gd2, ya2, { skipTitle: true });
+              Axes.redrawComponents(gd2, [xa._id, ya2._id]);
+              var xScaleFactor = editX ? xlen / viewBox[2] : 1;
+              var yScaleFactor = editY ? ylen / viewBox[3] : 1;
+              var clipDx = editX ? viewBox[0] : 0;
+              var clipDy = editY ? viewBox[1] : 0;
+              var fracDx = editX ? viewBox[0] / viewBox[2] * xlen : 0;
+              var fracDy = editY ? viewBox[1] / viewBox[3] * ylen : 0;
+              var plotDx = xa._offset - fracDx;
+              var plotDy = ya2._offset - fracDy;
+              plotinfo.clipRect.call(Drawing.setTranslate, clipDx, clipDy).call(Drawing.setScale, 1 / xScaleFactor, 1 / yScaleFactor);
+              plotinfo.plot.call(Drawing.setTranslate, plotDx, plotDy).call(Drawing.setScale, xScaleFactor, yScaleFactor);
+              Drawing.setPointGroupScale(plotinfo.zoomScalePts, 1 / xScaleFactor, 1 / yScaleFactor);
+              Drawing.setTextPointsScale(plotinfo.zoomScaleTxt, 1 / xScaleFactor, 1 / yScaleFactor);
+            }
+            var onComplete;
+            if (makeOnCompleteCallback) {
+              onComplete = makeOnCompleteCallback();
+            }
+            function transitionComplete() {
+              var aobj = {};
+              for (var i2 = 0; i2 < edits.length; i2++) {
+                var edit = edits[i2];
+                var xa = edit.plotinfo.xaxis;
+                var ya2 = edit.plotinfo.yaxis;
+                if (edit.xr1) aobj[xa._name + ".range"] = edit.xr1.slice();
+                if (edit.yr1) aobj[ya2._name + ".range"] = edit.yr1.slice();
+              }
+              onComplete && onComplete();
+              return Registry.call("relayout", gd2, aobj).then(function() {
+                for (var i22 = 0; i22 < edits.length; i22++) {
+                  unsetSubplotTransform(edits[i22].plotinfo);
+                }
+              });
+            }
+            function transitionInterrupt() {
+              var aobj = {};
+              for (var i2 = 0; i2 < edits.length; i2++) {
+                var edit = edits[i2];
+                var xa = edit.plotinfo.xaxis;
+                var ya2 = edit.plotinfo.yaxis;
+                if (edit.xr0) aobj[xa._name + ".range"] = edit.xr0.slice();
+                if (edit.yr0) aobj[ya2._name + ".range"] = edit.yr0.slice();
+              }
+              return Registry.call("relayout", gd2, aobj).then(function() {
+                for (var i22 = 0; i22 < edits.length; i22++) {
+                  unsetSubplotTransform(edits[i22].plotinfo);
+                }
+              });
+            }
+            var t12, t22, raf;
+            var easeFn = d3.ease(transitionOpts.easing);
+            gd2._transitionData._interruptCallbacks.push(function() {
+              window.cancelAnimationFrame(raf);
+              raf = null;
+              return transitionInterrupt();
+            });
+            function doFrame() {
+              t22 = Date.now();
+              var tInterp = Math.min(1, (t22 - t12) / transitionOpts.duration);
+              var progress = easeFn(tInterp);
+              for (var i2 = 0; i2 < edits.length; i2++) {
+                updateSubplot(edits[i2], progress);
+              }
+              if (t22 - t12 > transitionOpts.duration) {
+                transitionComplete();
+                raf = window.cancelAnimationFrame(doFrame);
+              } else {
+                raf = window.requestAnimationFrame(doFrame);
+              }
+            }
+            t12 = Date.now();
+            raf = window.requestAnimationFrame(doFrame);
+            return Promise.resolve();
+          };
+        }
+      });
+      var require_cartesian = __commonJS({
+        "src/plots/cartesian/index.js"(exports) {
+          var d3 = require_d3();
+          var Registry = require_registry();
+          var Lib = require_lib();
+          var Plots = require_plots();
+          var Drawing = require_drawing();
+          var getModuleCalcData = require_get_data().getModuleCalcData;
+          var axisIds = require_axis_ids();
+          var constants = require_constants2();
+          var xmlnsNamespaces = require_xmlns_namespaces();
+          var ensureSingle = Lib.ensureSingle;
+          function ensureSingleAndAddDatum(parent, nodeType, className) {
+            return Lib.ensureSingle(parent, nodeType, className, function(s2) {
+              s2.datum(className);
+            });
+          }
+          var zindexSeparator = constants.zindexSeparator;
+          exports.name = "cartesian";
+          exports.attr = ["xaxis", "yaxis"];
+          exports.idRoot = ["x", "y"];
+          exports.idRegex = constants.idRegex;
+          exports.attrRegex = constants.attrRegex;
+          exports.attributes = require_attributes14();
+          exports.layoutAttributes = require_layout_attributes4();
+          exports.supplyLayoutDefaults = require_layout_defaults4();
+          exports.transitionAxes = require_transition_axes();
+          exports.finalizeSubplots = function(layoutIn, layoutOut) {
+            var subplots = layoutOut._subplots;
+            var xList = subplots.xaxis;
+            var yList = subplots.yaxis;
+            var spSVG = subplots.cartesian;
+            var spAll = spSVG;
+            var allX = {};
+            var allY = {};
+            var i2, xi2, yi2;
+            for (i2 = 0; i2 < spAll.length; i2++) {
+              var parts = spAll[i2].split("y");
+              allX[parts[0]] = 1;
+              allY["y" + parts[1]] = 1;
+            }
+            for (i2 = 0; i2 < xList.length; i2++) {
+              xi2 = xList[i2];
+              if (!allX[xi2]) {
+                yi2 = (layoutIn[axisIds.id2name(xi2)] || {}).anchor;
+                if (!constants.idRegex.y.test(yi2)) yi2 = "y";
+                spSVG.push(xi2 + yi2);
+                spAll.push(xi2 + yi2);
+                if (!allY[yi2]) {
+                  allY[yi2] = 1;
+                  Lib.pushUnique(yList, yi2);
+                }
+              }
+            }
+            for (i2 = 0; i2 < yList.length; i2++) {
+              yi2 = yList[i2];
+              if (!allY[yi2]) {
+                xi2 = (layoutIn[axisIds.id2name(yi2)] || {}).anchor;
+                if (!constants.idRegex.x.test(xi2)) xi2 = "x";
+                spSVG.push(xi2 + yi2);
+                spAll.push(xi2 + yi2);
+                if (!allX[xi2]) {
+                  allX[xi2] = 1;
+                  Lib.pushUnique(xList, xi2);
+                }
+              }
+            }
+            if (!spAll.length) {
+              xi2 = "";
+              yi2 = "";
+              for (var ki2 in layoutIn) {
+                if (constants.attrRegex.test(ki2)) {
+                  var axLetter = ki2.charAt(0);
+                  if (axLetter === "x") {
+                    if (!xi2 || +ki2.slice(5) < +xi2.slice(5)) {
+                      xi2 = ki2;
+                    }
+                  } else if (!yi2 || +ki2.slice(5) < +yi2.slice(5)) {
+                    yi2 = ki2;
+                  }
+                }
+              }
+              xi2 = xi2 ? axisIds.name2id(xi2) : "x";
+              yi2 = yi2 ? axisIds.name2id(yi2) : "y";
+              xList.push(xi2);
+              yList.push(yi2);
+              spSVG.push(xi2 + yi2);
+            }
+          };
+          exports.plot = function(gd2, traces, transitionOpts, makeOnCompleteCallback) {
+            var fullLayout = gd2._fullLayout;
+            var subplots = fullLayout._subplots.cartesian;
+            var calcdata = gd2.calcdata;
+            var i2;
+            if (!Array.isArray(traces)) {
+              traces = [];
+              for (i2 = 0; i2 < calcdata.length; i2++) traces.push(i2);
+            }
+            var zindices = fullLayout._zindices;
+            for (var z2 = 0; z2 < zindices.length; z2++) {
+              var zorder = zindices[z2];
+              for (i2 = 0; i2 < subplots.length; i2++) {
+                var subplot = subplots[i2];
+                var subplotInfo = fullLayout._plots[subplot];
+                if (z2 > 0) {
+                  var idWithZ = subplotInfo.id;
+                  if (idWithZ.indexOf(zindexSeparator) !== -1) continue;
+                  idWithZ += zindexSeparator + (z2 + 1);
+                  subplotInfo = Lib.extendFlat({}, subplotInfo, {
+                    id: idWithZ,
+                    plot: fullLayout._cartesianlayer.selectAll(".subplot").select("." + idWithZ)
+                  });
+                }
+                var cdSubplot = [];
+                var pcd;
+                for (var j2 = 0; j2 < calcdata.length; j2++) {
+                  var cd2 = calcdata[j2];
+                  var trace = cd2[0].trace;
+                  if (zorder !== (trace.zorder || 0)) continue;
+                  if (trace.xaxis + trace.yaxis === subplot) {
+                    if (traces.indexOf(trace.index) !== -1 || trace.carpet) {
+                      if (pcd && pcd[0].trace.xaxis + pcd[0].trace.yaxis === subplot && ["tonextx", "tonexty", "tonext"].indexOf(trace.fill) !== -1 && cdSubplot.indexOf(pcd) === -1) {
+                        cdSubplot.push(pcd);
+                      }
+                      cdSubplot.push(cd2);
+                    }
+                    pcd = cd2;
+                  }
+                }
+                plotOne(gd2, subplotInfo, cdSubplot, transitionOpts, makeOnCompleteCallback);
+              }
+            }
+          };
+          function plotOne(gd2, plotinfo, cdSubplot, transitionOpts, makeOnCompleteCallback) {
+            var traceLayerClasses = constants.traceLayerClasses;
+            var fullLayout = gd2._fullLayout;
+            var zindices = fullLayout._zindices;
+            var modules = fullLayout._modules;
+            var _module, cdModuleAndOthers, cdModule;
+            var layerData = [];
+            var zoomScaleQueryParts = [];
+            for (var z2 = 0; z2 < zindices.length; z2++) {
+              var zorder = zindices[z2];
+              for (var i2 = 0; i2 < modules.length; i2++) {
+                _module = modules[i2];
+                var name2 = _module.name;
+                var categories = Registry.modules[name2].categories;
+                if (categories.svg) {
+                  var classBaseName = _module.layerName || name2 + "layer";
+                  var className = classBaseName + (z2 ? Number(z2) + 1 : "");
+                  var plotMethod = _module.plot;
+                  cdModuleAndOthers = getModuleCalcData(cdSubplot, plotMethod, zorder);
+                  cdModule = cdModuleAndOthers[0];
+                  cdSubplot = cdModuleAndOthers[1];
+                  if (cdModule.length) {
+                    layerData.push({
+                      i: traceLayerClasses.indexOf(classBaseName),
+                      zindex: z2,
+                      className,
+                      plotMethod,
+                      cdModule
+                    });
+                  }
+                  if (categories.zoomScale) {
+                    zoomScaleQueryParts.push("." + className);
+                  }
+                }
+              }
+            }
+            layerData.sort(function(a2, b2) {
+              return (a2.zindex || 0) - (b2.zindex || 0) || a2.i - b2.i;
+            });
+            var layers = plotinfo.plot.selectAll("g.mlayer").data(layerData, function(d2) {
+              return d2.className;
+            });
+            layers.enter().append("g").attr("class", function(d2) {
+              return d2.className;
+            }).classed("mlayer", true).classed("rangeplot", plotinfo.isRangePlot);
+            layers.exit().remove();
+            layers.order();
+            layers.each(function(d2) {
+              var sel = d3.select(this);
+              var className2 = d2.className;
+              d2.plotMethod(
+                gd2,
+                plotinfo,
+                d2.cdModule,
+                sel,
+                transitionOpts,
+                makeOnCompleteCallback
+              );
+              if (constants.clipOnAxisFalseQuery.indexOf("." + className2) === -1) {
+                Drawing.setClipUrl(sel, plotinfo.layerClipId, gd2);
+              }
+            });
+            if (fullLayout._has("scattergl")) {
+              _module = Registry.getModule("scattergl");
+              cdModule = getModuleCalcData(cdSubplot, _module)[0];
+              _module.plot(gd2, plotinfo, cdModule);
+            }
+            if (!gd2._context.staticPlot) {
+              if (plotinfo._hasClipOnAxisFalse) {
+                plotinfo.clipOnAxisFalseTraces = plotinfo.plot.selectAll(constants.clipOnAxisFalseQuery.join(",")).selectAll(".trace");
+              }
+              if (zoomScaleQueryParts.length) {
+                var traces = plotinfo.plot.selectAll(zoomScaleQueryParts.join(",")).selectAll(".trace");
+                plotinfo.zoomScalePts = traces.selectAll("path.point");
+                plotinfo.zoomScaleTxt = traces.selectAll(".textpoint");
+              }
+            }
+          }
+          exports.clean = function(newFullData, newFullLayout, oldFullData, oldFullLayout) {
+            var oldPlots = oldFullLayout._plots || {};
+            var newPlots = newFullLayout._plots || {};
+            var oldSubplotList = oldFullLayout._subplots || {};
+            var plotinfo;
+            var i2, k2;
+            if (oldFullLayout._hasOnlyLargeSploms && !newFullLayout._hasOnlyLargeSploms) {
+              for (k2 in oldPlots) {
+                plotinfo = oldPlots[k2];
+                if (plotinfo.plotgroup) plotinfo.plotgroup.remove();
+              }
+            }
+            var hadGl = oldFullLayout._has && oldFullLayout._has("gl");
+            var hasGl = newFullLayout._has && newFullLayout._has("gl");
+            if (hadGl && !hasGl) {
+              for (k2 in oldPlots) {
+                plotinfo = oldPlots[k2];
+                if (plotinfo._scene) plotinfo._scene.destroy();
+              }
+            }
+            if (oldSubplotList.xaxis && oldSubplotList.yaxis) {
+              var oldAxIDs = axisIds.listIds({ _fullLayout: oldFullLayout });
+              for (i2 = 0; i2 < oldAxIDs.length; i2++) {
+                var oldAxId = oldAxIDs[i2];
+                if (!newFullLayout[axisIds.id2name(oldAxId)]) {
+                  oldFullLayout._infolayer.selectAll(".g-" + oldAxId + "title").remove();
+                }
+              }
+            }
+            var hadCartesian = oldFullLayout._has && oldFullLayout._has("cartesian");
+            var hasCartesian = newFullLayout._has && newFullLayout._has("cartesian");
+            if (hadCartesian && !hasCartesian) {
+              purgeSubplotLayers(oldFullLayout._cartesianlayer.selectAll(".subplot"), oldFullLayout);
+              oldFullLayout._defs.selectAll(".axesclip").remove();
+              delete oldFullLayout._axisConstraintGroups;
+              delete oldFullLayout._axisMatchGroups;
+            } else if (oldSubplotList.cartesian) {
+              for (i2 = 0; i2 < oldSubplotList.cartesian.length; i2++) {
+                var oldSubplotId = oldSubplotList.cartesian[i2];
+                if (oldSubplotId.indexOf(zindexSeparator) !== -1) continue;
+                if (!newPlots[oldSubplotId]) {
+                  var selector = "." + oldSubplotId + ",." + oldSubplotId + "-x,." + oldSubplotId + "-y";
+                  oldFullLayout._cartesianlayer.selectAll(selector).remove();
+                  removeSubplotExtras(oldSubplotId, oldFullLayout);
+                }
+              }
+            }
+          };
+          exports.drawFramework = function(gd2) {
+            var fullLayout = gd2._fullLayout;
+            var calcdata = gd2.calcdata;
+            var i2;
+            var traceZorderGroups = {};
+            for (i2 = 0; i2 < calcdata.length; i2++) {
+              var cdi = calcdata[i2][0];
+              var trace = cdi.trace;
+              var zi2 = trace.zorder || 0;
+              if (!traceZorderGroups[zi2]) traceZorderGroups[zi2] = [];
+              traceZorderGroups[zi2].push(cdi);
+            }
+            var zindices = Object.keys(traceZorderGroups).map(Number).sort(Lib.sorterAsc);
+            if (!zindices.length) zindices = [0];
+            fullLayout._zindices = zindices;
+            var initialSubplotData = makeSubplotData(gd2);
+            var len2 = initialSubplotData.length;
+            var subplotData = [];
+            for (i2 = 0; i2 < len2; i2++) {
+              subplotData[i2] = initialSubplotData[i2].slice();
+            }
+            for (var z2 = 1; z2 < zindices.length; z2++) {
+              var newSubplotData = [];
+              for (i2 = 0; i2 < len2; i2++) {
+                newSubplotData[i2] = initialSubplotData[i2].slice();
+                newSubplotData[i2][0] += zindexSeparator + (z2 + 1);
+              }
+              subplotData = subplotData.concat(newSubplotData);
+            }
+            var subplotLayers = fullLayout._cartesianlayer.selectAll(".subplot").data(subplotData, String);
+            subplotLayers.enter().append("g").attr("class", function(d2) {
+              return "subplot " + d2[0];
+            });
+            subplotLayers.order();
+            subplotLayers.exit().call(purgeSubplotLayers, fullLayout);
+            subplotLayers.each(function(d2) {
+              var id2 = d2[0];
+              var posZ = id2.indexOf(zindexSeparator);
+              var hasZ = posZ !== -1;
+              var idWithoutZ = hasZ ? id2.slice(0, posZ) : id2;
+              var plotinfo = fullLayout._plots[id2];
+              if (!plotinfo) {
+                plotinfo = Lib.extendFlat({}, fullLayout._plots[idWithoutZ]);
+                if (plotinfo) {
+                  plotinfo.id = id2;
+                  fullLayout._plots[id2] = plotinfo;
+                  fullLayout._subplots.cartesian.push(id2);
+                }
+              }
+              if (plotinfo) {
+                plotinfo.plotgroup = d3.select(this);
+                makeSubplotLayer(gd2, plotinfo);
+                if (!hasZ) {
+                  plotinfo.draglayer = ensureSingle(fullLayout._draggers, "g", id2);
+                }
+              }
+            });
+          };
+          exports.rangePlot = function(gd2, plotinfo, cdSubplot) {
+            makeSubplotLayer(gd2, plotinfo);
+            plotOne(gd2, plotinfo, cdSubplot);
+            Plots.style(gd2);
+          };
+          function makeSubplotData(gd2) {
+            var fullLayout = gd2._fullLayout;
+            var numZ = fullLayout._zindices.length;
+            var ids = fullLayout._subplots.cartesian;
+            var len2 = ids.length;
+            var i2, j2, id2, plotinfo, xa, ya2;
+            var regulars = [];
+            var overlays = [];
+            for (i2 = 0; i2 < len2; i2++) {
+              id2 = ids[i2];
+              plotinfo = fullLayout._plots[id2];
+              xa = plotinfo.xaxis;
+              ya2 = plotinfo.yaxis;
+              var xa2 = xa._mainAxis;
+              var ya22 = ya2._mainAxis;
+              var mainplot = xa2._id + ya22._id;
+              var mainplotinfo = fullLayout._plots[mainplot];
+              plotinfo.overlays = [];
+              if (mainplot !== id2 && mainplotinfo) {
+                plotinfo.mainplot = mainplot;
+                plotinfo.mainplotinfo = mainplotinfo;
+                overlays.push(id2);
+              } else {
+                plotinfo.mainplot = void 0;
+                plotinfo.mainplotinfo = void 0;
+                regulars.push(id2);
+              }
+            }
+            for (i2 = 0; i2 < overlays.length; i2++) {
+              id2 = overlays[i2];
+              plotinfo = fullLayout._plots[id2];
+              plotinfo.mainplotinfo.overlays.push(plotinfo);
+            }
+            var subplotIds = regulars.concat(overlays);
+            var subplotData = [];
+            for (i2 = 0; i2 < len2; i2++) {
+              id2 = subplotIds[i2];
+              plotinfo = fullLayout._plots[id2];
+              xa = plotinfo.xaxis;
+              ya2 = plotinfo.yaxis;
+              var d2 = [];
+              for (var z2 = 1; z2 <= numZ; z2++) {
+                var zStr = "";
+                if (z2 > 1) zStr += zindexSeparator + z2;
+                d2.push(id2 + zStr);
+                for (j2 = 0; j2 < plotinfo.overlays.length; j2++) {
+                  d2.push(plotinfo.overlays[j2].id + zStr);
+                }
+              }
+              d2 = d2.concat([
+                xa.layer,
+                ya2.layer,
+                xa.overlaying || "",
+                ya2.overlaying || ""
+              ]);
+              subplotData.push(d2);
+            }
+            return subplotData;
+          }
+          function makeSubplotLayer(gd2, plotinfo) {
+            var fullLayout = gd2._fullLayout;
+            var plotgroup = plotinfo.plotgroup;
+            var id2 = plotinfo.id;
+            var posZ = id2.indexOf(zindexSeparator);
+            var hasZ = posZ !== -1;
+            var xLayer = constants.layerValue2layerClass[plotinfo.xaxis.layer];
+            var yLayer = constants.layerValue2layerClass[plotinfo.yaxis.layer];
+            var hasOnlyLargeSploms = fullLayout._hasOnlyLargeSploms;
+            var hasMultipleZ = fullLayout._zindices.length > 1;
+            var mainplotinfo = plotinfo.mainplotinfo;
+            if (!plotinfo.mainplot || hasMultipleZ) {
+              if (hasOnlyLargeSploms) {
+                plotinfo.xlines = ensureSingle(plotgroup, "path", "xlines-above");
+                plotinfo.ylines = ensureSingle(plotgroup, "path", "ylines-above");
+                plotinfo.xaxislayer = ensureSingle(plotgroup, "g", "xaxislayer-above");
+                plotinfo.yaxislayer = ensureSingle(plotgroup, "g", "yaxislayer-above");
+              } else {
+                if (!hasZ) {
+                  var backLayer = ensureSingle(plotgroup, "g", "layer-subplot");
+                  plotinfo.shapelayer = ensureSingle(backLayer, "g", "shapelayer");
+                  plotinfo.imagelayer = ensureSingle(backLayer, "g", "imagelayer");
+                  if (mainplotinfo && hasMultipleZ) {
+                    plotinfo.minorGridlayer = mainplotinfo.minorGridlayer;
+                    plotinfo.gridlayer = mainplotinfo.gridlayer;
+                    plotinfo.zerolinelayer = mainplotinfo.zerolinelayer;
+                  } else {
+                    plotinfo.minorGridlayer = ensureSingle(plotgroup, "g", "minor-gridlayer");
+                    plotinfo.gridlayer = ensureSingle(plotgroup, "g", "gridlayer");
+                    plotinfo.zerolinelayer = ensureSingle(plotgroup, "g", "zerolinelayer");
+                  }
+                  var betweenLayer = ensureSingle(plotgroup, "g", "layer-between");
+                  plotinfo.shapelayerBetween = ensureSingle(betweenLayer, "g", "shapelayer");
+                  plotinfo.imagelayerBetween = ensureSingle(betweenLayer, "g", "imagelayer");
+                  ensureSingle(plotgroup, "path", "xlines-below");
+                  ensureSingle(plotgroup, "path", "ylines-below");
+                  plotinfo.overlinesBelow = ensureSingle(plotgroup, "g", "overlines-below");
+                  ensureSingle(plotgroup, "g", "xaxislayer-below");
+                  ensureSingle(plotgroup, "g", "yaxislayer-below");
+                  plotinfo.overaxesBelow = ensureSingle(plotgroup, "g", "overaxes-below");
+                }
+                plotinfo.overplot = ensureSingle(plotgroup, "g", "overplot");
+                plotinfo.plot = ensureSingle(plotinfo.overplot, "g", id2);
+                if (mainplotinfo && hasMultipleZ) {
+                  plotinfo.zerolinelayerAbove = mainplotinfo.zerolinelayerAbove;
+                } else {
+                  plotinfo.zerolinelayerAbove = ensureSingle(plotgroup, "g", "zerolinelayer-above");
+                }
+                if (!hasZ) {
+                  plotinfo.xlines = ensureSingle(plotgroup, "path", "xlines-above");
+                  plotinfo.ylines = ensureSingle(plotgroup, "path", "ylines-above");
+                  plotinfo.overlinesAbove = ensureSingle(plotgroup, "g", "overlines-above");
+                  ensureSingle(plotgroup, "g", "xaxislayer-above");
+                  ensureSingle(plotgroup, "g", "yaxislayer-above");
+                  plotinfo.overaxesAbove = ensureSingle(plotgroup, "g", "overaxes-above");
+                  plotinfo.xlines = plotgroup.select(".xlines-" + xLayer);
+                  plotinfo.ylines = plotgroup.select(".ylines-" + yLayer);
+                  plotinfo.xaxislayer = plotgroup.select(".xaxislayer-" + xLayer);
+                  plotinfo.yaxislayer = plotgroup.select(".yaxislayer-" + yLayer);
+                }
+              }
+            } else {
+              var mainplotgroup = mainplotinfo.plotgroup;
+              var xId = id2 + "-x";
+              var yId = id2 + "-y";
+              plotinfo.minorGridlayer = mainplotinfo.minorGridlayer;
+              plotinfo.gridlayer = mainplotinfo.gridlayer;
+              plotinfo.zerolinelayer = mainplotinfo.zerolinelayer;
+              plotinfo.zerolinelayerAbove = mainplotinfo.zerolinelayerAbove;
+              ensureSingle(mainplotinfo.overlinesBelow, "path", xId);
+              ensureSingle(mainplotinfo.overlinesBelow, "path", yId);
+              ensureSingle(mainplotinfo.overaxesBelow, "g", xId);
+              ensureSingle(mainplotinfo.overaxesBelow, "g", yId);
+              plotinfo.plot = ensureSingle(mainplotinfo.overplot, "g", id2);
+              ensureSingle(mainplotinfo.overlinesAbove, "path", xId);
+              ensureSingle(mainplotinfo.overlinesAbove, "path", yId);
+              ensureSingle(mainplotinfo.overaxesAbove, "g", xId);
+              ensureSingle(mainplotinfo.overaxesAbove, "g", yId);
+              plotinfo.xlines = mainplotgroup.select(".overlines-" + xLayer).select("." + xId);
+              plotinfo.ylines = mainplotgroup.select(".overlines-" + yLayer).select("." + yId);
+              plotinfo.xaxislayer = mainplotgroup.select(".overaxes-" + xLayer).select("." + xId);
+              plotinfo.yaxislayer = mainplotgroup.select(".overaxes-" + yLayer).select("." + yId);
+            }
+            if (!hasZ) {
+              if (!hasOnlyLargeSploms) {
+                ensureSingleAndAddDatum(plotinfo.minorGridlayer, "g", plotinfo.xaxis._id);
+                ensureSingleAndAddDatum(plotinfo.minorGridlayer, "g", plotinfo.yaxis._id);
+                plotinfo.minorGridlayer.selectAll("g").map(function(d2) {
+                  return d2[0];
+                }).sort(axisIds.idSort);
+                ensureSingleAndAddDatum(plotinfo.gridlayer, "g", plotinfo.xaxis._id);
+                ensureSingleAndAddDatum(plotinfo.gridlayer, "g", plotinfo.yaxis._id);
+                plotinfo.gridlayer.selectAll("g").map(function(d2) {
+                  return d2[0];
+                }).sort(axisIds.idSort);
+              }
+              plotinfo.xlines.style("fill", "none").classed("crisp", true);
+              plotinfo.ylines.style("fill", "none").classed("crisp", true);
+            }
+          }
+          function purgeSubplotLayers(layers, fullLayout) {
+            if (!layers) return;
+            var overlayIdsToRemove = {};
+            layers.each(function(d2) {
+              var id2 = d2[0];
+              var plotgroup = d3.select(this);
+              plotgroup.remove();
+              removeSubplotExtras(id2, fullLayout);
+              overlayIdsToRemove[id2] = true;
+            });
+            for (var k2 in fullLayout._plots) {
+              var subplotInfo = fullLayout._plots[k2];
+              var overlays = subplotInfo.overlays || [];
+              for (var j2 = 0; j2 < overlays.length; j2++) {
+                var overlayInfo = overlays[j2];
+                if (overlayIdsToRemove[overlayInfo.id]) {
+                  overlayInfo.plot.selectAll(".trace").remove();
+                }
+              }
+            }
+          }
+          function removeSubplotExtras(subplotId, fullLayout) {
+            fullLayout._draggers.selectAll("g." + subplotId).remove();
+            fullLayout._defs.select("#clip" + fullLayout._uid + subplotId + "plot").remove();
+          }
+          exports.toSVG = function(gd2) {
+            var imageRoot = gd2._fullLayout._glimages;
+            var root = d3.select(gd2).selectAll(".svg-container");
+            var canvases = root.filter(function(d2, i2) {
+              return i2 === root.size() - 1;
+            }).selectAll(".gl-canvas-context, .gl-canvas-focus");
+            function canvasToImage() {
+              var canvas2 = this;
+              var imageData = canvas2.toDataURL("image/png");
+              var image = imageRoot.append("svg:image");
+              image.attr({
+                xmlns: xmlnsNamespaces.svg,
+                "xlink:href": imageData,
+                preserveAspectRatio: "none",
+                x: 0,
+                y: 0,
+                width: canvas2.style.width,
+                height: canvas2.style.height
+              });
+            }
+            canvases.each(canvasToImage);
+          };
+          exports.updateFx = require_graph_interact().updateFx;
+        }
+      });
+      var require_scatter = __commonJS({
+        "src/traces/scatter/index.js"(exports, module2) {
+          var subtypes = require_subtypes();
+          module2.exports = {
+            hasLines: subtypes.hasLines,
+            hasMarkers: subtypes.hasMarkers,
+            hasText: subtypes.hasText,
+            isBubble: subtypes.isBubble,
+            attributes: require_attributes12(),
+            layoutAttributes: require_layout_attributes3(),
+            supplyDefaults: require_defaults8(),
+            crossTraceDefaults: require_cross_trace_defaults2(),
+            supplyLayoutDefaults: require_layout_defaults3(),
+            calc: require_calc3().calc,
+            crossTraceCalc: require_cross_trace_calc2(),
+            arraysToCalcdata: require_arrays_to_calcdata(),
+            plot: require_plot(),
+            colorbar: require_marker_colorbar(),
+            formatLabels: require_format_labels(),
+            style: require_style2().style,
+            styleOnSelect: require_style2().styleOnSelect,
+            hoverPoints: require_hover2(),
+            selectPoints: require_select2(),
+            animatable: true,
+            moduleType: "trace",
+            name: "scatter",
+            basePlotModule: require_cartesian(),
+            categories: [
+              "cartesian",
+              "svg",
+              "symbols",
+              "errorBarsOK",
+              "showLegend",
+              "scatter-like",
+              "zoomScale"
+            ],
+            meta: {}
+          };
+        }
+      });
+      var require_draw_arrow_head = __commonJS({
+        "src/components/annotations/draw_arrow_head.js"(exports, module2) {
+          var d3 = require_d3();
+          var Color2 = require_color();
+          var ARROWPATHS = require_arrow_paths();
+          var Lib = require_lib();
+          var strScale = Lib.strScale;
+          var strRotate = Lib.strRotate;
+          var strTranslate = Lib.strTranslate;
+          module2.exports = function drawArrowHead(el3, ends, options) {
+            var el2 = el3.node();
+            var headStyle = ARROWPATHS[options.arrowhead || 0];
+            var startHeadStyle = ARROWPATHS[options.startarrowhead || 0];
+            var scale2 = (options.arrowwidth || 1) * (options.arrowsize || 1);
+            var startScale = (options.arrowwidth || 1) * (options.startarrowsize || 1);
+            var doStart = ends.indexOf("start") >= 0;
+            var doEnd = ends.indexOf("end") >= 0;
+            var backOff = headStyle.backoff * scale2 + options.standoff;
+            var startBackOff = startHeadStyle.backoff * startScale + options.startstandoff;
+            var start, end, startRot, endRot;
+            if (el2.nodeName === "line") {
+              start = { x: +el3.attr("x1"), y: +el3.attr("y1") };
+              end = { x: +el3.attr("x2"), y: +el3.attr("y2") };
+              var dx = start.x - end.x;
+              var dy = start.y - end.y;
+              startRot = Math.atan2(dy, dx);
+              endRot = startRot + Math.PI;
+              if (backOff && startBackOff) {
+                if (backOff + startBackOff > Math.sqrt(dx * dx + dy * dy)) {
+                  hideLine();
+                  return;
+                }
+              }
+              if (backOff) {
+                if (backOff * backOff > dx * dx + dy * dy) {
+                  hideLine();
+                  return;
+                }
+                var backOffX = backOff * Math.cos(startRot);
+                var backOffY = backOff * Math.sin(startRot);
+                end.x += backOffX;
+                end.y += backOffY;
+                el3.attr({ x2: end.x, y2: end.y });
+              }
+              if (startBackOff) {
+                if (startBackOff * startBackOff > dx * dx + dy * dy) {
+                  hideLine();
+                  return;
+                }
+                var startBackOffX = startBackOff * Math.cos(startRot);
+                var startbackOffY = startBackOff * Math.sin(startRot);
+                start.x -= startBackOffX;
+                start.y -= startbackOffY;
+                el3.attr({ x1: start.x, y1: start.y });
+              }
+            } else if (el2.nodeName === "path") {
+              var pathlen = el2.getTotalLength();
+              var dashArray = "";
+              if (pathlen < backOff + startBackOff) {
+                hideLine();
+                return;
+              }
+              var start0 = el2.getPointAtLength(0);
+              var dstart = el2.getPointAtLength(0.1);
+              startRot = Math.atan2(start0.y - dstart.y, start0.x - dstart.x);
+              start = el2.getPointAtLength(Math.min(startBackOff, pathlen));
+              dashArray = "0px," + startBackOff + "px,";
+              var end0 = el2.getPointAtLength(pathlen);
+              var dend = el2.getPointAtLength(pathlen - 0.1);
+              endRot = Math.atan2(end0.y - dend.y, end0.x - dend.x);
+              end = el2.getPointAtLength(Math.max(0, pathlen - backOff));
+              var shortening = dashArray ? startBackOff + backOff : backOff;
+              dashArray += pathlen - shortening + "px," + pathlen + "px";
+              el3.style("stroke-dasharray", dashArray);
+            }
+            function hideLine() {
+              el3.style("stroke-dasharray", "0px,100px");
+            }
+            function drawhead(arrowHeadStyle, p2, rot, arrowScale) {
+              if (!arrowHeadStyle.path) return;
+              if (arrowHeadStyle.noRotate) rot = 0;
+              d3.select(el2.parentNode).append("path").attr({
+                class: el3.attr("class"),
+                d: arrowHeadStyle.path,
+                transform: strTranslate(p2.x, p2.y) + strRotate(rot * 180 / Math.PI) + strScale(arrowScale)
+              }).style({
+                fill: Color2.rgb(options.arrowcolor),
+                "stroke-width": 0
+              });
+            }
+            if (doStart) drawhead(startHeadStyle, start, startRot, startScale);
+            if (doEnd) drawhead(headStyle, end, endRot, scale2);
+          };
+        }
+      });
+      var require_draw4 = __commonJS({
+        "src/components/annotations/draw.js"(exports, module2) {
+          var d3 = require_d3();
+          var Registry = require_registry();
+          var Plots = require_plots();
+          var Lib = require_lib();
+          var strTranslate = Lib.strTranslate;
+          var Axes = require_axes();
+          var Color2 = require_color();
+          var Drawing = require_drawing();
+          var Fx = require_fx();
+          var svgTextUtils = require_svg_text_utils();
+          var setCursor = require_setcursor();
+          var dragElement = require_dragelement();
+          var arrayEditor = require_plot_template().arrayEditor;
+          var drawArrowHead = require_draw_arrow_head();
+          module2.exports = {
+            draw,
+            drawOne,
+            drawRaw
+          };
+          function draw(gd2) {
+            var fullLayout = gd2._fullLayout;
+            fullLayout._infolayer.selectAll(".annotation").remove();
+            for (var i2 = 0; i2 < fullLayout.annotations.length; i2++) {
+              if (fullLayout.annotations[i2].visible) {
+                drawOne(gd2, i2);
+              }
+            }
+            return Plots.previousPromises(gd2);
+          }
+          function drawOne(gd2, index) {
+            var fullLayout = gd2._fullLayout;
+            var options = fullLayout.annotations[index] || {};
+            var xa = Axes.getFromId(gd2, options.xref);
+            var ya2 = Axes.getFromId(gd2, options.yref);
+            if (xa) xa.setScale();
+            if (ya2) ya2.setScale();
+            drawRaw(gd2, options, index, false, xa, ya2);
+          }
+          function shiftPosition(axa, dAx, axLetter, gs, options) {
+            var optAx = options[axLetter];
+            var axRef = options[axLetter + "ref"];
+            var vertical = axLetter.indexOf("y") !== -1;
+            var axDomainRef = Axes.getRefType(axRef) === "domain";
+            var gsDim = vertical ? gs.h : gs.w;
+            if (axa) {
+              if (axDomainRef) {
+                return optAx + (vertical ? -dAx : dAx) / axa._length;
+              } else {
+                return axa.p2r(axa.r2p(optAx) + dAx);
+              }
+            } else {
+              return optAx + (vertical ? -dAx : dAx) / gsDim;
+            }
+          }
+          function drawRaw(gd2, options, index, subplotId, xa, ya2) {
+            var fullLayout = gd2._fullLayout;
+            var gs = gd2._fullLayout._size;
+            var edits = gd2._context.edits;
+            var className, containerStr;
+            if (subplotId) {
+              className = "annotation-" + subplotId;
+              containerStr = subplotId + ".annotations";
+            } else {
+              className = "annotation";
+              containerStr = "annotations";
+            }
+            var editHelpers = arrayEditor(gd2.layout, containerStr, options);
+            var modifyBase = editHelpers.modifyBase;
+            var modifyItem = editHelpers.modifyItem;
+            var getUpdateObj = editHelpers.getUpdateObj;
+            fullLayout._infolayer.selectAll("." + className + '[data-index="' + index + '"]').remove();
+            var annClipID = "clip" + fullLayout._uid + "_ann" + index;
+            if (!options._input || options.visible === false) {
+              d3.selectAll("#" + annClipID).remove();
+              return;
+            }
+            var annPosPx = { x: {}, y: {} };
+            var textangle = +options.textangle || 0;
+            var annGroup = fullLayout._infolayer.append("g").classed(className, true).attr("data-index", String(index)).style("opacity", options.opacity);
+            var annTextGroup = annGroup.append("g").classed("annotation-text-g", true);
+            var editTextPosition = edits[options.showarrow ? "annotationTail" : "annotationPosition"];
+            var textEvents = options.captureevents || edits.annotationText || editTextPosition;
+            function makeEventData(initialEvent) {
+              var eventData = {
+                index,
+                annotation: options._input,
+                fullAnnotation: options,
+                event: initialEvent
+              };
+              if (subplotId) {
+                eventData.subplotId = subplotId;
+              }
+              return eventData;
+            }
+            var annTextGroupInner = annTextGroup.append("g").style("pointer-events", textEvents ? "all" : null).call(setCursor, "pointer").on("click", function() {
+              gd2._dragging = false;
+              gd2.emit("plotly_clickannotation", makeEventData(d3.event));
+            });
+            if (options.hovertext) {
+              annTextGroupInner.on("mouseover", function() {
+                var hoverOptions = options.hoverlabel;
+                var hoverFont = hoverOptions.font;
+                var bBox = this.getBoundingClientRect();
+                var bBoxRef = gd2.getBoundingClientRect();
+                Fx.loneHover({
+                  x0: bBox.left - bBoxRef.left,
+                  x1: bBox.right - bBoxRef.left,
+                  y: (bBox.top + bBox.bottom) / 2 - bBoxRef.top,
+                  text: options.hovertext,
+                  color: hoverOptions.bgcolor,
+                  borderColor: hoverOptions.bordercolor,
+                  fontFamily: hoverFont.family,
+                  fontSize: hoverFont.size,
+                  fontColor: hoverFont.color,
+                  fontWeight: hoverFont.weight,
+                  fontStyle: hoverFont.style,
+                  fontVariant: hoverFont.variant,
+                  fontShadow: hoverFont.fontShadow,
+                  fontLineposition: hoverFont.fontLineposition,
+                  fontTextcase: hoverFont.fontTextcase
+                }, {
+                  container: fullLayout._hoverlayer.node(),
+                  outerContainer: fullLayout._paper.node(),
+                  gd: gd2
+                });
+              }).on("mouseout", function() {
+                Fx.loneUnhover(fullLayout._hoverlayer.node());
+              });
+            }
+            var borderwidth = options.borderwidth;
+            var borderpad = options.borderpad;
+            var borderfull = borderwidth + borderpad;
+            var annTextBG = annTextGroupInner.append("rect").attr("class", "bg").style("stroke-width", borderwidth + "px").call(Color2.stroke, options.bordercolor).call(Color2.fill, options.bgcolor);
+            var isSizeConstrained = options.width || options.height;
+            var annTextClip = fullLayout._topclips.selectAll("#" + annClipID).data(isSizeConstrained ? [0] : []);
+            annTextClip.enter().append("clipPath").classed("annclip", true).attr("id", annClipID).append("rect");
+            annTextClip.exit().remove();
+            var font = options.font;
+            var text = fullLayout._meta ? Lib.templateString(options.text, fullLayout._meta) : options.text;
+            var annText = annTextGroupInner.append("text").classed("annotation-text", true).text(text);
+            function textLayout(s2) {
+              s2.call(Drawing.font, font).attr({
+                "text-anchor": {
+                  left: "start",
+                  right: "end"
+                }[options.align] || "middle"
+              });
+              svgTextUtils.convertToTspans(s2, gd2, drawGraphicalElements);
+              return s2;
+            }
+            function drawGraphicalElements() {
+              var anchor3 = annText.selectAll("a");
+              if (anchor3.size() === 1 && anchor3.text() === annText.text()) {
+                var wholeLink = annTextGroupInner.insert("a", ":first-child").attr({
+                  "xlink:xlink:href": anchor3.attr("xlink:href"),
+                  "xlink:xlink:show": anchor3.attr("xlink:show")
+                }).style({ cursor: "pointer" });
+                wholeLink.node().appendChild(annTextBG.node());
+              }
+              var mathjaxGroup = annTextGroupInner.select(".annotation-text-math-group");
+              var hasMathjax = !mathjaxGroup.empty();
+              var anntextBB = Drawing.bBox(
+                (hasMathjax ? mathjaxGroup : annText).node()
+              );
+              var textWidth = anntextBB.width;
+              var textHeight = anntextBB.height;
+              var annWidth = options.width || textWidth;
+              var annHeight = options.height || textHeight;
+              var outerWidth = Math.round(annWidth + 2 * borderfull);
+              var outerHeight = Math.round(annHeight + 2 * borderfull);
+              function shiftFraction(v2, anchor2) {
+                if (anchor2 === "auto") {
+                  if (v2 < 1 / 3) anchor2 = "left";
+                  else if (v2 > 2 / 3) anchor2 = "right";
+                  else anchor2 = "center";
+                }
+                return {
+                  center: 0,
+                  middle: 0,
+                  left: 0.5,
+                  bottom: -0.5,
+                  right: -0.5,
+                  top: 0.5
+                }[anchor2];
+              }
+              var annotationIsOffscreen = false;
+              var letters = ["x", "y"];
+              for (var i2 = 0; i2 < letters.length; i2++) {
+                var axLetter = letters[i2];
+                var axRef = options[axLetter + "ref"] || axLetter;
+                var tailRef = options["a" + axLetter + "ref"];
+                var ax = { x: xa, y: ya2 }[axLetter];
+                var dimAngle = (textangle + (axLetter === "x" ? 0 : -90)) * Math.PI / 180;
+                var annSizeFromWidth = outerWidth * Math.cos(dimAngle);
+                var annSizeFromHeight = outerHeight * Math.sin(dimAngle);
+                var annSize = Math.abs(annSizeFromWidth) + Math.abs(annSizeFromHeight);
+                var anchor = options[axLetter + "anchor"];
+                var overallShift = options[axLetter + "shift"] * (axLetter === "x" ? 1 : -1);
+                var posPx = annPosPx[axLetter];
+                var basePx;
+                var textPadShift;
+                var alignPosition;
+                var autoAlignFraction;
+                var textShift;
+                var axRefType = Axes.getRefType(axRef);
+                if (ax && axRefType !== "domain") {
+                  var posFraction = ax.r2fraction(options[axLetter]);
+                  if (posFraction < 0 || posFraction > 1) {
+                    if (tailRef === axRef) {
+                      posFraction = ax.r2fraction(options["a" + axLetter]);
+                      if (posFraction < 0 || posFraction > 1) {
+                        annotationIsOffscreen = true;
+                      }
+                    } else {
+                      annotationIsOffscreen = true;
+                    }
+                  }
+                  basePx = ax._offset + ax.r2p(options[axLetter]);
+                  autoAlignFraction = 0.5;
+                } else {
+                  var axRefTypeEqDomain = axRefType === "domain";
+                  if (axLetter === "x") {
+                    alignPosition = options[axLetter];
+                    basePx = axRefTypeEqDomain ? ax._offset + ax._length * alignPosition : basePx = gs.l + gs.w * alignPosition;
+                  } else {
+                    alignPosition = 1 - options[axLetter];
+                    basePx = axRefTypeEqDomain ? ax._offset + ax._length * alignPosition : basePx = gs.t + gs.h * alignPosition;
+                  }
+                  autoAlignFraction = options.showarrow ? 0.5 : alignPosition;
+                }
+                if (options.showarrow) {
+                  posPx.head = basePx;
+                  var arrowLength = options["a" + axLetter];
+                  textShift = annSizeFromWidth * shiftFraction(0.5, options.xanchor) - annSizeFromHeight * shiftFraction(0.5, options.yanchor);
+                  if (tailRef === axRef) {
+                    var tailRefType = Axes.getRefType(tailRef);
+                    if (tailRefType === "domain") {
+                      if (axLetter === "y") {
+                        arrowLength = 1 - arrowLength;
+                      }
+                      posPx.tail = ax._offset + ax._length * arrowLength;
+                    } else if (tailRefType === "paper") {
+                      if (axLetter === "y") {
+                        arrowLength = 1 - arrowLength;
+                        posPx.tail = gs.t + gs.h * arrowLength;
+                      } else {
+                        posPx.tail = gs.l + gs.w * arrowLength;
+                      }
+                    } else {
+                      posPx.tail = ax._offset + ax.r2p(arrowLength);
+                    }
+                    textPadShift = textShift;
+                  } else {
+                    posPx.tail = basePx + arrowLength;
+                    textPadShift = textShift + arrowLength;
+                  }
+                  posPx.text = posPx.tail + textShift;
+                  var maxPx = fullLayout[axLetter === "x" ? "width" : "height"];
+                  if (axRef === "paper") {
+                    posPx.head = Lib.constrain(posPx.head, 1, maxPx - 1);
+                  }
+                  if (tailRef === "pixel") {
+                    var shiftPlus = -Math.max(posPx.tail - 3, posPx.text);
+                    var shiftMinus = Math.min(posPx.tail + 3, posPx.text) - maxPx;
+                    if (shiftPlus > 0) {
+                      posPx.tail += shiftPlus;
+                      posPx.text += shiftPlus;
+                    } else if (shiftMinus > 0) {
+                      posPx.tail -= shiftMinus;
+                      posPx.text -= shiftMinus;
+                    }
+                  }
+                  posPx.tail += overallShift;
+                  posPx.head += overallShift;
+                } else {
+                  textShift = annSize * shiftFraction(autoAlignFraction, anchor);
+                  textPadShift = textShift;
+                  posPx.text = basePx + textShift;
+                }
+                posPx.text += overallShift;
+                textShift += overallShift;
+                textPadShift += overallShift;
+                options["_" + axLetter + "padplus"] = annSize / 2 + textPadShift;
+                options["_" + axLetter + "padminus"] = annSize / 2 - textPadShift;
+                options["_" + axLetter + "size"] = annSize;
+                options["_" + axLetter + "shift"] = textShift;
+              }
+              if (annotationIsOffscreen) {
+                annTextGroupInner.remove();
+                return;
+              }
+              var xShift = 0;
+              var yShift = 0;
+              if (options.align !== "left") {
+                xShift = (annWidth - textWidth) * (options.align === "center" ? 0.5 : 1);
+              }
+              if (options.valign !== "top") {
+                yShift = (annHeight - textHeight) * (options.valign === "middle" ? 0.5 : 1);
+              }
+              if (hasMathjax) {
+                mathjaxGroup.select("svg").attr({
+                  x: borderfull + xShift - 1,
+                  y: borderfull + yShift
+                }).call(Drawing.setClipUrl, isSizeConstrained ? annClipID : null, gd2);
+              } else {
+                var texty = borderfull + yShift - anntextBB.top;
+                var textx = borderfull + xShift - anntextBB.left;
+                annText.call(svgTextUtils.positionText, textx, texty).call(Drawing.setClipUrl, isSizeConstrained ? annClipID : null, gd2);
+              }
+              annTextClip.select("rect").call(
+                Drawing.setRect,
+                borderfull,
+                borderfull,
+                annWidth,
+                annHeight
+              );
+              annTextBG.call(
+                Drawing.setRect,
+                borderwidth / 2,
+                borderwidth / 2,
+                outerWidth - borderwidth,
+                outerHeight - borderwidth
+              );
+              annTextGroupInner.call(
+                Drawing.setTranslate,
+                Math.round(annPosPx.x.text - outerWidth / 2),
+                Math.round(annPosPx.y.text - outerHeight / 2)
+              );
+              annTextGroup.attr({ transform: "rotate(" + textangle + "," + annPosPx.x.text + "," + annPosPx.y.text + ")" });
+              var drawArrow = function(dx, dy) {
+                annGroup.selectAll(".annotation-arrow-g").remove();
+                var headX = annPosPx.x.head;
+                var headY = annPosPx.y.head;
+                var tailX = annPosPx.x.tail + dx;
+                var tailY = annPosPx.y.tail + dy;
+                var textX = annPosPx.x.text + dx;
+                var textY = annPosPx.y.text + dy;
+                var transform = Lib.rotationXYMatrix(textangle, textX, textY);
+                var applyTransform = Lib.apply2DTransform(transform);
+                var applyTransform2 = Lib.apply2DTransform2(transform);
+                var width = +annTextBG.attr("width");
+                var height = +annTextBG.attr("height");
+                var xLeft = textX - 0.5 * width;
+                var xRight = xLeft + width;
+                var yTop = textY - 0.5 * height;
+                var yBottom = yTop + height;
+                var edges = [
+                  [xLeft, yTop, xLeft, yBottom],
+                  [xLeft, yBottom, xRight, yBottom],
+                  [xRight, yBottom, xRight, yTop],
+                  [xRight, yTop, xLeft, yTop]
+                ].map(applyTransform2);
+                if (edges.reduce(function(a2, x2) {
+                  return a2 ^ !!Lib.segmentsIntersect(
+                    headX,
+                    headY,
+                    headX + 1e6,
+                    headY + 1e6,
+                    x2[0],
+                    x2[1],
+                    x2[2],
+                    x2[3]
+                  );
+                }, false)) {
+                  return;
+                }
+                edges.forEach(function(x2) {
+                  var p2 = Lib.segmentsIntersect(
+                    tailX,
+                    tailY,
+                    headX,
+                    headY,
+                    x2[0],
+                    x2[1],
+                    x2[2],
+                    x2[3]
+                  );
+                  if (p2) {
+                    tailX = p2.x;
+                    tailY = p2.y;
+                  }
+                });
+                var strokewidth = options.arrowwidth;
+                var arrowColor = options.arrowcolor;
+                var arrowSide = options.arrowside;
+                var arrowGroup = annGroup.append("g").style({ opacity: Color2.opacity(arrowColor) }).classed("annotation-arrow-g", true);
+                var arrow = arrowGroup.append("path").attr("d", "M" + tailX + "," + tailY + "L" + headX + "," + headY).style("stroke-width", strokewidth + "px").call(Color2.stroke, Color2.rgb(arrowColor));
+                drawArrowHead(arrow, arrowSide, options);
+                if (edits.annotationPosition && arrow.node().parentNode && !subplotId) {
+                  var arrowDragHeadX = headX;
+                  var arrowDragHeadY = headY;
+                  if (options.standoff) {
+                    var arrowLength2 = Math.sqrt(Math.pow(headX - tailX, 2) + Math.pow(headY - tailY, 2));
+                    arrowDragHeadX += options.standoff * (tailX - headX) / arrowLength2;
+                    arrowDragHeadY += options.standoff * (tailY - headY) / arrowLength2;
+                  }
+                  var arrowDrag = arrowGroup.append("path").classed("annotation-arrow", true).classed("anndrag", true).classed("cursor-move", true).attr({
+                    d: "M3,3H-3V-3H3ZM0,0L" + (tailX - arrowDragHeadX) + "," + (tailY - arrowDragHeadY),
+                    transform: strTranslate(arrowDragHeadX, arrowDragHeadY)
+                  }).style("stroke-width", strokewidth + 6 + "px").call(Color2.stroke, "rgba(0,0,0,0)").call(Color2.fill, "rgba(0,0,0,0)");
+                  var annx0, anny0;
+                  dragElement.init({
+                    element: arrowDrag.node(),
+                    gd: gd2,
+                    prepFn: function() {
+                      var pos = Drawing.getTranslate(annTextGroupInner);
+                      annx0 = pos.x;
+                      anny0 = pos.y;
+                      if (xa && xa.autorange) {
+                        modifyBase(xa._name + ".autorange", true);
+                      }
+                      if (ya2 && ya2.autorange) {
+                        modifyBase(ya2._name + ".autorange", true);
+                      }
+                    },
+                    moveFn: function(dx2, dy2) {
+                      var annxy0 = applyTransform(annx0, anny0);
+                      var xcenter = annxy0[0] + dx2;
+                      var ycenter = annxy0[1] + dy2;
+                      annTextGroupInner.call(Drawing.setTranslate, xcenter, ycenter);
+                      modifyItem(
+                        "x",
+                        shiftPosition(xa, dx2, "x", gs, options)
+                      );
+                      modifyItem(
+                        "y",
+                        shiftPosition(ya2, dy2, "y", gs, options)
+                      );
+                      if (options.axref === options.xref) {
+                        modifyItem("ax", shiftPosition(xa, dx2, "ax", gs, options));
+                      }
+                      if (options.ayref === options.yref) {
+                        modifyItem("ay", shiftPosition(ya2, dy2, "ay", gs, options));
+                      }
+                      arrowGroup.attr("transform", strTranslate(dx2, dy2));
+                      annTextGroup.attr({
+                        transform: "rotate(" + textangle + "," + xcenter + "," + ycenter + ")"
+                      });
+                    },
+                    doneFn: function() {
+                      Registry.call("_guiRelayout", gd2, getUpdateObj());
+                      var notesBox = document.querySelector(".js-notes-box-panel");
+                      if (notesBox) notesBox.redraw(notesBox.selectedObj);
+                    }
+                  });
+                }
+              };
+              if (options.showarrow) drawArrow(0, 0);
+              if (editTextPosition) {
+                var baseTextTransform;
+                dragElement.init({
+                  element: annTextGroupInner.node(),
+                  gd: gd2,
+                  prepFn: function() {
+                    baseTextTransform = annTextGroup.attr("transform");
+                  },
+                  moveFn: function(dx, dy) {
+                    var csr = "pointer";
+                    if (options.showarrow) {
+                      if (options.axref === options.xref) {
+                        modifyItem("ax", shiftPosition(xa, dx, "ax", gs, options));
+                      } else {
+                        modifyItem("ax", options.ax + dx);
+                      }
+                      if (options.ayref === options.yref) {
+                        modifyItem("ay", shiftPosition(ya2, dy, "ay", gs.w, options));
+                      } else {
+                        modifyItem("ay", options.ay + dy);
+                      }
+                      drawArrow(dx, dy);
+                    } else if (!subplotId) {
+                      var xUpdate, yUpdate;
+                      if (xa) {
+                        xUpdate = shiftPosition(xa, dx, "x", gs, options);
+                      } else {
+                        var widthFraction = options._xsize / gs.w;
+                        var xLeft = options.x + (options._xshift - options.xshift) / gs.w - widthFraction / 2;
+                        xUpdate = dragElement.align(
+                          xLeft + dx / gs.w,
+                          widthFraction,
+                          0,
+                          1,
+                          options.xanchor
+                        );
+                      }
+                      if (ya2) {
+                        yUpdate = shiftPosition(ya2, dy, "y", gs, options);
+                      } else {
+                        var heightFraction = options._ysize / gs.h;
+                        var yBottom = options.y - (options._yshift + options.yshift) / gs.h - heightFraction / 2;
+                        yUpdate = dragElement.align(
+                          yBottom - dy / gs.h,
+                          heightFraction,
+                          0,
+                          1,
+                          options.yanchor
+                        );
+                      }
+                      modifyItem("x", xUpdate);
+                      modifyItem("y", yUpdate);
+                      if (!xa || !ya2) {
+                        csr = dragElement.getCursor(
+                          xa ? 0.5 : xUpdate,
+                          ya2 ? 0.5 : yUpdate,
+                          options.xanchor,
+                          options.yanchor
+                        );
+                      }
+                    } else return;
+                    annTextGroup.attr({
+                      transform: strTranslate(dx, dy) + baseTextTransform
+                    });
+                    setCursor(annTextGroupInner, csr);
+                  },
+                  clickFn: function(_2, initialEvent) {
+                    if (options.captureevents) {
+                      gd2.emit("plotly_clickannotation", makeEventData(initialEvent));
+                    }
+                  },
+                  doneFn: function() {
+                    setCursor(annTextGroupInner);
+                    Registry.call("_guiRelayout", gd2, getUpdateObj());
+                    var notesBox = document.querySelector(".js-notes-box-panel");
+                    if (notesBox) notesBox.redraw(notesBox.selectedObj);
+                  }
+                });
+              }
+            }
+            if (edits.annotationText) {
+              annText.call(svgTextUtils.makeEditable, { delegate: annTextGroupInner, gd: gd2 }).call(textLayout).on("edit", function(_text) {
+                options.text = _text;
+                this.call(textLayout);
+                modifyItem("text", _text);
+                if (xa && xa.autorange) {
+                  modifyBase(xa._name + ".autorange", true);
+                }
+                if (ya2 && ya2.autorange) {
+                  modifyBase(ya2._name + ".autorange", true);
+                }
+                Registry.call("_guiRelayout", gd2, getUpdateObj());
+              });
+            } else annText.call(textLayout);
+          }
+        }
+      });
+      var require_click2 = __commonJS({
+        "src/components/annotations/click.js"(exports, module2) {
+          var Lib = require_lib();
+          var Registry = require_registry();
+          var arrayEditor = require_plot_template().arrayEditor;
+          module2.exports = {
+            hasClickToShow,
+            onClick
+          };
+          function hasClickToShow(gd2, hoverData) {
+            var sets = getToggleSets(gd2, hoverData);
+            return sets.on.length > 0 || sets.explicitOff.length > 0;
+          }
+          function onClick(gd2, hoverData) {
+            var toggleSets = getToggleSets(gd2, hoverData);
+            var onSet = toggleSets.on;
+            var offSet = toggleSets.off.concat(toggleSets.explicitOff);
+            var update = {};
+            var annotationsOut = gd2._fullLayout.annotations;
+            var i2, editHelpers;
+            if (!(onSet.length || offSet.length)) return;
+            for (i2 = 0; i2 < onSet.length; i2++) {
+              editHelpers = arrayEditor(gd2.layout, "annotations", annotationsOut[onSet[i2]]);
+              editHelpers.modifyItem("visible", true);
+              Lib.extendFlat(update, editHelpers.getUpdateObj());
+            }
+            for (i2 = 0; i2 < offSet.length; i2++) {
+              editHelpers = arrayEditor(gd2.layout, "annotations", annotationsOut[offSet[i2]]);
+              editHelpers.modifyItem("visible", false);
+              Lib.extendFlat(update, editHelpers.getUpdateObj());
+            }
+            return Registry.call("update", gd2, {}, update);
+          }
+          function getToggleSets(gd2, hoverData) {
+            var annotations = gd2._fullLayout.annotations;
+            var onSet = [];
+            var offSet = [];
+            var explicitOffSet = [];
+            var hoverLen = (hoverData || []).length;
+            var i2, j2, anni, showMode, pointj, xa, ya2, toggleType;
+            for (i2 = 0; i2 < annotations.length; i2++) {
+              anni = annotations[i2];
+              showMode = anni.clicktoshow;
+              if (showMode) {
+                for (j2 = 0; j2 < hoverLen; j2++) {
+                  pointj = hoverData[j2];
+                  xa = pointj.xaxis;
+                  ya2 = pointj.yaxis;
+                  if (xa._id === anni.xref && ya2._id === anni.yref && xa.d2r(pointj.x) === clickData2r(anni._xclick, xa) && ya2.d2r(pointj.y) === clickData2r(anni._yclick, ya2)) {
+                    if (anni.visible) {
+                      if (showMode === "onout") toggleType = offSet;
+                      else toggleType = explicitOffSet;
+                    } else {
+                      toggleType = onSet;
+                    }
+                    toggleType.push(i2);
+                    break;
+                  }
+                }
+                if (j2 === hoverLen) {
+                  if (anni.visible && showMode === "onout") offSet.push(i2);
+                }
+              }
+            }
+            return { on: onSet, off: offSet, explicitOff: explicitOffSet };
+          }
+          function clickData2r(d2, ax) {
+            return ax.type === "log" ? ax.l2r(d2) : ax.d2r(d2);
+          }
+        }
+      });
+      var require_common_defaults = __commonJS({
+        "src/components/annotations/common_defaults.js"(exports, module2) {
+          var Lib = require_lib();
+          var Color2 = require_color();
+          module2.exports = function handleAnnotationCommonDefaults(annIn, annOut, fullLayout, coerce) {
+            coerce("opacity");
+            var bgColor = coerce("bgcolor");
+            var borderColor = coerce("bordercolor");
+            var borderOpacity = Color2.opacity(borderColor);
+            coerce("borderpad");
+            var borderWidth = coerce("borderwidth");
+            var showArrow = coerce("showarrow");
+            coerce("text", showArrow ? " " : fullLayout._dfltTitle.annotation);
+            coerce("textangle");
+            Lib.coerceFont(coerce, "font", fullLayout.font);
+            coerce("width");
+            coerce("align");
+            var h2 = coerce("height");
+            if (h2) coerce("valign");
+            if (showArrow) {
+              var arrowside = coerce("arrowside");
+              var arrowhead;
+              var arrowsize;
+              if (arrowside.indexOf("end") !== -1) {
+                arrowhead = coerce("arrowhead");
+                arrowsize = coerce("arrowsize");
+              }
+              if (arrowside.indexOf("start") !== -1) {
+                coerce("startarrowhead", arrowhead);
+                coerce("startarrowsize", arrowsize);
+              }
+              coerce("arrowcolor", borderOpacity ? annOut.bordercolor : Color2.defaultLine);
+              coerce("arrowwidth", (borderOpacity && borderWidth || 1) * 2);
+              coerce("standoff");
+              coerce("startstandoff");
+            }
+            var hoverText = coerce("hovertext");
+            var globalHoverLabel = fullLayout.hoverlabel || {};
+            if (hoverText) {
+              var hoverBG = coerce(
+                "hoverlabel.bgcolor",
+                globalHoverLabel.bgcolor || (Color2.opacity(bgColor) ? Color2.rgb(bgColor) : Color2.defaultLine)
+              );
+              var hoverBorder = coerce(
+                "hoverlabel.bordercolor",
+                globalHoverLabel.bordercolor || Color2.contrast(hoverBG)
+              );
+              var fontDflt = Lib.extendFlat({}, globalHoverLabel.font);
+              if (!fontDflt.color) {
+                fontDflt.color = hoverBorder;
+              }
+              Lib.coerceFont(coerce, "hoverlabel.font", fontDflt);
+            }
+            coerce("captureevents", !!hoverText);
+          };
+        }
+      });
+      var require_defaults9 = __commonJS({
+        "src/components/annotations/defaults.js"(exports, module2) {
+          var Lib = require_lib();
+          var Axes = require_axes();
+          var handleArrayContainerDefaults = require_array_container_defaults();
+          var handleAnnotationCommonDefaults = require_common_defaults();
+          var attributes = require_attributes11();
+          module2.exports = function supplyLayoutDefaults(layoutIn, layoutOut) {
+            handleArrayContainerDefaults(layoutIn, layoutOut, {
+              name: "annotations",
+              handleItemDefaults: handleAnnotationDefaults
+            });
+          };
+          function handleAnnotationDefaults(annIn, annOut, fullLayout) {
+            function coerce(attr, dflt) {
+              return Lib.coerce(annIn, annOut, attributes, attr, dflt);
+            }
+            var visible = coerce("visible");
+            var clickToShow = coerce("clicktoshow");
+            if (!(visible || clickToShow)) return;
+            handleAnnotationCommonDefaults(annIn, annOut, fullLayout, coerce);
+            var showArrow = annOut.showarrow;
+            var axLetters = ["x", "y"];
+            var arrowPosDflt = [-10, -30];
+            var gdMock = { _fullLayout: fullLayout };
+            for (var i2 = 0; i2 < 2; i2++) {
+              var axLetter = axLetters[i2];
+              var axRef = Axes.coerceRef(annIn, annOut, gdMock, axLetter, "", "paper");
+              if (axRef !== "paper") {
+                var ax = Axes.getFromId(gdMock, axRef);
+                ax._annIndices.push(annOut._index);
+              }
+              Axes.coercePosition(annOut, gdMock, coerce, axRef, axLetter, 0.5);
+              if (showArrow) {
+                var arrowPosAttr = "a" + axLetter;
+                var aaxRef = Axes.coerceRef(
+                  annIn,
+                  annOut,
+                  gdMock,
+                  arrowPosAttr,
+                  "pixel",
+                  ["pixel", "paper"]
+                );
+                if (aaxRef !== "pixel" && aaxRef !== axRef) {
+                  aaxRef = annOut[arrowPosAttr] = "pixel";
+                }
+                var aDflt = aaxRef === "pixel" ? arrowPosDflt[i2] : 0.4;
+                Axes.coercePosition(annOut, gdMock, coerce, aaxRef, arrowPosAttr, aDflt);
+              }
+              coerce(axLetter + "anchor");
+              coerce(axLetter + "shift");
+            }
+            Lib.noneOrAll(annIn, annOut, ["x", "y"]);
+            if (showArrow) {
+              Lib.noneOrAll(annIn, annOut, ["ax", "ay"]);
+            }
+            if (clickToShow) {
+              var xClick = coerce("xclick");
+              var yClick = coerce("yclick");
+              annOut._xclick = xClick === void 0 ? annOut.x : Axes.cleanPosition(xClick, gdMock, annOut.xref);
+              annOut._yclick = yClick === void 0 ? annOut.y : Axes.cleanPosition(yClick, gdMock, annOut.yref);
+            }
+          }
+        }
+      });
+      var require_calc_autorange = __commonJS({
+        "src/components/annotations/calc_autorange.js"(exports, module2) {
+          var Lib = require_lib();
+          var Axes = require_axes();
+          var draw = require_draw4().draw;
+          module2.exports = function calcAutorange(gd2) {
+            var fullLayout = gd2._fullLayout;
+            var annotationList = Lib.filterVisible(fullLayout.annotations);
+            if (annotationList.length && gd2._fullData.length) {
+              return Lib.syncOrAsync([draw, annAutorange], gd2);
+            }
+          };
+          function annAutorange(gd2) {
+            var fullLayout = gd2._fullLayout;
+            Lib.filterVisible(fullLayout.annotations).forEach(function(ann) {
+              var xa = Axes.getFromId(gd2, ann.xref);
+              var ya2 = Axes.getFromId(gd2, ann.yref);
+              var xRefType = Axes.getRefType(ann.xref);
+              var yRefType = Axes.getRefType(ann.yref);
+              ann._extremes = {};
+              if (xRefType === "range") calcAxisExpansion(ann, xa);
+              if (yRefType === "range") calcAxisExpansion(ann, ya2);
+            });
+          }
+          function calcAxisExpansion(ann, ax) {
+            var axId = ax._id;
+            var letter = axId.charAt(0);
+            var pos = ann[letter];
+            var apos = ann["a" + letter];
+            var ref = ann[letter + "ref"];
+            var aref = ann["a" + letter + "ref"];
+            var padplus = ann["_" + letter + "padplus"];
+            var padminus = ann["_" + letter + "padminus"];
+            var shift = { x: 1, y: -1 }[letter] * ann[letter + "shift"];
+            var headSize = 3 * ann.arrowsize * ann.arrowwidth || 0;
+            var headPlus = headSize + shift;
+            var headMinus = headSize - shift;
+            var startHeadSize = 3 * ann.startarrowsize * ann.arrowwidth || 0;
+            var startHeadPlus = startHeadSize + shift;
+            var startHeadMinus = startHeadSize - shift;
+            var extremes;
+            if (aref === ref) {
+              var extremeArrowHead = Axes.findExtremes(ax, [ax.r2c(pos)], {
+                ppadplus: headPlus,
+                ppadminus: headMinus
+              });
+              var extremeText = Axes.findExtremes(ax, [ax.r2c(apos)], {
+                ppadplus: Math.max(padplus, startHeadPlus),
+                ppadminus: Math.max(padminus, startHeadMinus)
+              });
+              extremes = {
+                min: [extremeArrowHead.min[0], extremeText.min[0]],
+                max: [extremeArrowHead.max[0], extremeText.max[0]]
+              };
+            } else {
+              startHeadPlus = apos ? startHeadPlus + apos : startHeadPlus;
+              startHeadMinus = apos ? startHeadMinus - apos : startHeadMinus;
+              extremes = Axes.findExtremes(ax, [ax.r2c(pos)], {
+                ppadplus: Math.max(padplus, headPlus, startHeadPlus),
+                ppadminus: Math.max(padminus, headMinus, startHeadMinus)
+              });
+            }
+            ann._extremes[axId] = extremes;
+          }
+        }
+      });
+      var require_convert_coords = __commonJS({
+        "src/components/annotations/convert_coords.js"(exports, module2) {
+          var isNumeric = require_fast_isnumeric();
+          var toLogRange = require_to_log_range();
+          module2.exports = function convertCoords(gd2, ax, newType, doExtra) {
+            ax = ax || {};
+            var toLog = newType === "log" && ax.type === "linear";
+            var fromLog = newType === "linear" && ax.type === "log";
+            if (!(toLog || fromLog)) return;
+            var annotations = gd2._fullLayout.annotations;
+            var axLetter = ax._id.charAt(0);
+            var ann;
+            var attrPrefix;
+            function convert(attr) {
+              var currentVal = ann[attr];
+              var newVal = null;
+              if (toLog) newVal = toLogRange(currentVal, ax.range);
+              else newVal = Math.pow(10, currentVal);
+              if (!isNumeric(newVal)) newVal = null;
+              doExtra(attrPrefix + attr, newVal);
+            }
+            for (var i2 = 0; i2 < annotations.length; i2++) {
+              ann = annotations[i2];
+              attrPrefix = "annotations[" + i2 + "].";
+              if (ann[axLetter + "ref"] === ax._id) convert(axLetter);
+              if (ann["a" + axLetter + "ref"] === ax._id) convert("a" + axLetter);
+            }
+          };
+        }
+      });
+      var require_annotations = __commonJS({
+        "src/components/annotations/index.js"(exports, module2) {
+          var drawModule = require_draw4();
+          var clickModule = require_click2();
+          module2.exports = {
+            moduleType: "component",
+            name: "annotations",
+            layoutAttributes: require_attributes11(),
+            supplyLayoutDefaults: require_defaults9(),
+            includeBasePlot: require_include_components()("annotations"),
+            calcAutorange: require_calc_autorange(),
+            draw: drawModule.draw,
+            drawOne: drawModule.drawOne,
+            drawRaw: drawModule.drawRaw,
+            hasClickToShow: clickModule.hasClickToShow,
+            onClick: clickModule.onClick,
+            convertCoords: require_convert_coords()
+          };
+        }
+      });
+      var require_attributes15 = __commonJS({
+        "src/components/annotations3d/attributes.js"(exports, module2) {
+          var annAttrs = require_attributes11();
+          var overrideAll = require_edit_types().overrideAll;
+          var templatedArray = require_plot_template().templatedArray;
+          module2.exports = overrideAll(templatedArray("annotation", {
+            visible: annAttrs.visible,
+            x: {
+              valType: "any"
+            },
+            y: {
+              valType: "any"
+            },
+            z: {
+              valType: "any"
+            },
+            ax: {
+              valType: "number"
+            },
+            ay: {
+              valType: "number"
+            },
+            xanchor: annAttrs.xanchor,
+            xshift: annAttrs.xshift,
+            yanchor: annAttrs.yanchor,
+            yshift: annAttrs.yshift,
+            text: annAttrs.text,
+            textangle: annAttrs.textangle,
+            font: annAttrs.font,
+            width: annAttrs.width,
+            height: annAttrs.height,
+            opacity: annAttrs.opacity,
+            align: annAttrs.align,
+            valign: annAttrs.valign,
+            bgcolor: annAttrs.bgcolor,
+            bordercolor: annAttrs.bordercolor,
+            borderpad: annAttrs.borderpad,
+            borderwidth: annAttrs.borderwidth,
+            showarrow: annAttrs.showarrow,
+            arrowcolor: annAttrs.arrowcolor,
+            arrowhead: annAttrs.arrowhead,
+            startarrowhead: annAttrs.startarrowhead,
+            arrowside: annAttrs.arrowside,
+            arrowsize: annAttrs.arrowsize,
+            startarrowsize: annAttrs.startarrowsize,
+            arrowwidth: annAttrs.arrowwidth,
+            standoff: annAttrs.standoff,
+            startstandoff: annAttrs.startstandoff,
+            hovertext: annAttrs.hovertext,
+            hoverlabel: annAttrs.hoverlabel,
+            captureevents: annAttrs.captureevents
+            // maybes later?
+            // clicktoshow: annAttrs.clicktoshow,
+            // xclick: annAttrs.xclick,
+            // yclick: annAttrs.yclick,
+            // not needed!
+            // axref: 'pixel'
+            // ayref: 'pixel'
+            // xref: 'x'
+            // yref: 'y
+            // zref: 'z'
+          }), "calc", "from-root");
+        }
+      });
+      var require_defaults10 = __commonJS({
+        "src/components/annotations3d/defaults.js"(exports, module2) {
+          var Lib = require_lib();
+          var Axes = require_axes();
+          var handleArrayContainerDefaults = require_array_container_defaults();
+          var handleAnnotationCommonDefaults = require_common_defaults();
+          var attributes = require_attributes15();
+          module2.exports = function handleDefaults(sceneLayoutIn, sceneLayoutOut, opts) {
+            handleArrayContainerDefaults(sceneLayoutIn, sceneLayoutOut, {
+              name: "annotations",
+              handleItemDefaults: handleAnnotationDefaults,
+              fullLayout: opts.fullLayout
+            });
+          };
+          function handleAnnotationDefaults(annIn, annOut, sceneLayout, opts) {
+            function coerce(attr, dflt) {
+              return Lib.coerce(annIn, annOut, attributes, attr, dflt);
+            }
+            function coercePosition(axLetter) {
+              var axName = axLetter + "axis";
+              var gdMock = { _fullLayout: {} };
+              gdMock._fullLayout[axName] = sceneLayout[axName];
+              return Axes.coercePosition(annOut, gdMock, coerce, axLetter, axLetter, 0.5);
+            }
+            var visible = coerce("visible");
+            if (!visible) return;
+            handleAnnotationCommonDefaults(annIn, annOut, opts.fullLayout, coerce);
+            coercePosition("x");
+            coercePosition("y");
+            coercePosition("z");
+            Lib.noneOrAll(annIn, annOut, ["x", "y", "z"]);
+            annOut.xref = "x";
+            annOut.yref = "y";
+            annOut.zref = "z";
+            coerce("xanchor");
+            coerce("yanchor");
+            coerce("xshift");
+            coerce("yshift");
+            if (annOut.showarrow) {
+              annOut.axref = "pixel";
+              annOut.ayref = "pixel";
+              coerce("ax", -10);
+              coerce("ay", -30);
+              Lib.noneOrAll(annIn, annOut, ["ax", "ay"]);
+            }
+          }
+        }
+      });
+      var require_convert = __commonJS({
+        "src/components/annotations3d/convert.js"(exports, module2) {
+          var Lib = require_lib();
+          var Axes = require_axes();
+          module2.exports = function convert(scene) {
+            var fullSceneLayout = scene.fullSceneLayout;
+            var anns = fullSceneLayout.annotations;
+            for (var i2 = 0; i2 < anns.length; i2++) {
+              mockAnnAxes(anns[i2], scene);
+            }
+            scene.fullLayout._infolayer.selectAll(".annotation-" + scene.id).remove();
+          };
+          function mockAnnAxes(ann, scene) {
+            var fullSceneLayout = scene.fullSceneLayout;
+            var domain = fullSceneLayout.domain;
+            var size = scene.fullLayout._size;
+            var base = {
+              // this gets fill in on render
+              pdata: null,
+              // to get setConvert to not execute cleanly
+              type: "linear",
+              // don't try to update them on `editable: true`
+              autorange: false,
+              // set infinite range so that annotation draw routine
+              // does not try to remove 'outside-range' annotations,
+              // this case is handled in the render loop
+              range: [-Infinity, Infinity]
+            };
+            ann._xa = {};
+            Lib.extendFlat(ann._xa, base);
+            Axes.setConvert(ann._xa);
+            ann._xa._offset = size.l + domain.x[0] * size.w;
+            ann._xa.l2p = function() {
+              return 0.5 * (1 + ann._pdata[0] / ann._pdata[3]) * size.w * (domain.x[1] - domain.x[0]);
+            };
+            ann._ya = {};
+            Lib.extendFlat(ann._ya, base);
+            Axes.setConvert(ann._ya);
+            ann._ya._offset = size.t + (1 - domain.y[1]) * size.h;
+            ann._ya.l2p = function() {
+              return 0.5 * (1 - ann._pdata[1] / ann._pdata[3]) * size.h * (domain.y[1] - domain.y[0]);
+            };
+          }
+        }
+      });
+      var require_project = __commonJS({
+        "src/plots/gl3d/project.js"(exports, module2) {
+          function xformMatrix(m2, v2) {
+            var out = [0, 0, 0, 0];
+            var i2, j2;
+            for (i2 = 0; i2 < 4; ++i2) {
+              for (j2 = 0; j2 < 4; ++j2) {
+                out[j2] += m2[4 * i2 + j2] * v2[i2];
+              }
+            }
+            return out;
+          }
+          function project2(camera, v2) {
+            var p2 = xformMatrix(
+              camera.projection,
+              xformMatrix(
+                camera.view,
+                xformMatrix(camera.model, [v2[0], v2[1], v2[2], 1])
+              )
+            );
+            return p2;
+          }
+          module2.exports = project2;
+        }
+      });
+      var require_draw5 = __commonJS({
+        "src/components/annotations3d/draw.js"(exports, module2) {
+          var drawRaw = require_draw4().drawRaw;
+          var project2 = require_project();
+          var axLetters = ["x", "y", "z"];
+          module2.exports = function draw(scene) {
+            var fullSceneLayout = scene.fullSceneLayout;
+            var dataScale = scene.dataScale;
+            var anns = fullSceneLayout.annotations;
+            for (var i2 = 0; i2 < anns.length; i2++) {
+              var ann = anns[i2];
+              var annotationIsOffscreen = false;
+              for (var j2 = 0; j2 < 3; j2++) {
+                var axLetter = axLetters[j2];
+                var pos = ann[axLetter];
+                var ax = fullSceneLayout[axLetter + "axis"];
+                var posFraction = ax.r2fraction(pos);
+                if (posFraction < 0 || posFraction > 1) {
+                  annotationIsOffscreen = true;
+                  break;
+                }
+              }
+              if (annotationIsOffscreen) {
+                scene.fullLayout._infolayer.select(".annotation-" + scene.id + '[data-index="' + i2 + '"]').remove();
+              } else {
+                ann._pdata = project2(scene.glplot.cameraParams, [
+                  fullSceneLayout.xaxis.r2l(ann.x) * dataScale[0],
+                  fullSceneLayout.yaxis.r2l(ann.y) * dataScale[1],
+                  fullSceneLayout.zaxis.r2l(ann.z) * dataScale[2]
+                ]);
+                drawRaw(scene.graphDiv, ann, i2, scene.id, ann._xa, ann._ya);
+              }
+            }
+          };
+        }
+      });
+      var require_annotations3d = __commonJS({
+        "src/components/annotations3d/index.js"(exports, module2) {
+          var Registry = require_registry();
+          var Lib = require_lib();
+          module2.exports = {
+            moduleType: "component",
+            name: "annotations3d",
+            schema: {
+              subplots: {
+                scene: { annotations: require_attributes15() }
+              }
+            },
+            layoutAttributes: require_attributes15(),
+            handleDefaults: require_defaults10(),
+            includeBasePlot: includeGL3D,
+            convert: require_convert(),
+            draw: require_draw5()
+          };
+          function includeGL3D(layoutIn, layoutOut) {
+            var GL3D = Registry.subplotsRegistry.gl3d;
+            if (!GL3D) return;
+            var attrRegex = GL3D.attrRegex;
+            var keys = Object.keys(layoutIn);
+            for (var i2 = 0; i2 < keys.length; i2++) {
+              var k2 = keys[i2];
+              if (attrRegex.test(k2) && (layoutIn[k2].annotations || []).length) {
+                Lib.pushUnique(layoutOut._basePlotModules, GL3D);
+                Lib.pushUnique(layoutOut._subplots.gl3d, k2);
+              }
+            }
+          }
+        }
+      });
+      var require_attributes16 = __commonJS({
+        "src/components/shapes/attributes.js"(exports, module2) {
+          require_constants2();
+          var fontAttrs = require_font_attributes();
+          var scatterLineAttrs = require_attributes12().line;
+          var dash = require_attributes4().dash;
+          var extendFlat = require_extend().extendFlat;
+          var templatedArray = require_plot_template().templatedArray;
+          require_axis_placeable_objects();
+          var basePlotAttributes = require_attributes2();
+          var annAttrs = require_attributes11();
+          var { shapeTexttemplateAttrs, templatefallbackAttrs } = require_template_attributes();
+          var shapeLabelTexttemplateVars = require_label_texttemplate();
+          module2.exports = templatedArray("shape", {
+            visible: extendFlat({}, basePlotAttributes.visible, {
+              editType: "calc+arraydraw"
+            }),
+            showlegend: {
+              valType: "boolean",
+              dflt: false,
+              editType: "calc+arraydraw"
+            },
+            legend: extendFlat({}, basePlotAttributes.legend, {
+              editType: "calc+arraydraw"
+            }),
+            legendgroup: extendFlat({}, basePlotAttributes.legendgroup, {
+              editType: "calc+arraydraw"
+            }),
+            legendgrouptitle: {
+              text: extendFlat({}, basePlotAttributes.legendgrouptitle.text, {
+                editType: "calc+arraydraw"
+              }),
+              font: fontAttrs({
+                editType: "calc+arraydraw"
+              }),
+              editType: "calc+arraydraw"
+            },
+            legendrank: extendFlat({}, basePlotAttributes.legendrank, {
+              editType: "calc+arraydraw"
+            }),
+            legendwidth: extendFlat({}, basePlotAttributes.legendwidth, {
+              editType: "calc+arraydraw"
+            }),
+            type: {
+              valType: "enumerated",
+              values: ["circle", "rect", "path", "line"],
+              editType: "calc+arraydraw"
+            },
+            layer: {
+              valType: "enumerated",
+              values: ["below", "above", "between"],
+              dflt: "above",
+              editType: "arraydraw"
+            },
+            xref: extendFlat({}, annAttrs.xref, {
+              arrayOk: true
+            }),
+            xsizemode: {
+              valType: "enumerated",
+              values: ["scaled", "pixel"],
+              dflt: "scaled",
+              editType: "calc+arraydraw"
+            },
+            xanchor: {
+              valType: "any",
+              editType: "calc+arraydraw"
+            },
+            x0: {
+              valType: "any",
+              editType: "calc+arraydraw"
+            },
+            x1: {
+              valType: "any",
+              editType: "calc+arraydraw"
+            },
+            x0shift: {
+              valType: "number",
+              dflt: 0,
+              min: -1,
+              max: 1,
+              editType: "calc"
+            },
+            x1shift: {
+              valType: "number",
+              dflt: 0,
+              min: -1,
+              max: 1,
+              editType: "calc"
+            },
+            yref: extendFlat({}, annAttrs.yref, {
+              arrayOk: true
+            }),
+            ysizemode: {
+              valType: "enumerated",
+              values: ["scaled", "pixel"],
+              dflt: "scaled",
+              editType: "calc+arraydraw"
+            },
+            yanchor: {
+              valType: "any",
+              editType: "calc+arraydraw"
+            },
+            y0: {
+              valType: "any",
+              editType: "calc+arraydraw"
+            },
+            y1: {
+              valType: "any",
+              editType: "calc+arraydraw"
+            },
+            y0shift: {
+              valType: "number",
+              dflt: 0,
+              min: -1,
+              max: 1,
+              editType: "calc"
+            },
+            y1shift: {
+              valType: "number",
+              dflt: 0,
+              min: -1,
+              max: 1,
+              editType: "calc"
+            },
+            path: {
+              valType: "string",
+              editType: "calc+arraydraw"
+            },
+            opacity: {
+              valType: "number",
+              min: 0,
+              max: 1,
+              dflt: 1,
+              editType: "arraydraw"
+            },
+            line: {
+              color: extendFlat({}, scatterLineAttrs.color, { editType: "arraydraw" }),
+              width: extendFlat({}, scatterLineAttrs.width, { editType: "calc+arraydraw" }),
+              dash: extendFlat({}, dash, { editType: "arraydraw" }),
+              editType: "calc+arraydraw"
+            },
+            fillcolor: {
+              valType: "color",
+              dflt: "rgba(0,0,0,0)",
+              editType: "arraydraw"
+            },
+            fillrule: {
+              valType: "enumerated",
+              values: ["evenodd", "nonzero"],
+              dflt: "evenodd",
+              editType: "arraydraw"
+            },
+            editable: {
+              valType: "boolean",
+              dflt: false,
+              editType: "calc+arraydraw"
+            },
+            label: {
+              text: {
+                valType: "string",
+                dflt: "",
+                editType: "arraydraw"
+              },
+              texttemplate: shapeTexttemplateAttrs({}, { keys: Object.keys(shapeLabelTexttemplateVars) }),
+              texttemplatefallback: templatefallbackAttrs({ editType: "arraydraw" }),
+              font: fontAttrs({
+                editType: "calc+arraydraw",
+                colorEditType: "arraydraw"
+              }),
+              textposition: {
+                valType: "enumerated",
+                values: [
+                  "top left",
+                  "top center",
+                  "top right",
+                  "middle left",
+                  "middle center",
+                  "middle right",
+                  "bottom left",
+                  "bottom center",
+                  "bottom right",
+                  "start",
+                  "middle",
+                  "end"
+                ],
+                editType: "arraydraw"
+              },
+              textangle: {
+                valType: "angle",
+                dflt: "auto",
+                editType: "calc+arraydraw"
+              },
+              xanchor: {
+                valType: "enumerated",
+                values: ["auto", "left", "center", "right"],
+                dflt: "auto",
+                editType: "calc+arraydraw"
+              },
+              yanchor: {
+                valType: "enumerated",
+                values: ["top", "middle", "bottom"],
+                editType: "calc+arraydraw"
+              },
+              padding: {
+                valType: "number",
+                dflt: 3,
+                min: 0,
+                editType: "arraydraw"
+              },
+              editType: "arraydraw"
+            },
+            editType: "arraydraw"
+          });
+        }
+      });
+      var require_defaults11 = __commonJS({
+        "src/components/shapes/defaults.js"(exports, module2) {
+          var Lib = require_lib();
+          var Axes = require_axes();
+          var handleArrayContainerDefaults = require_array_container_defaults();
+          var attributes = require_attributes16();
+          var helpers = require_helpers8();
+          module2.exports = function supplyLayoutDefaults(layoutIn, layoutOut) {
+            handleArrayContainerDefaults(layoutIn, layoutOut, {
+              name: "shapes",
+              handleItemDefaults: handleShapeDefaults
+            });
+          };
+          function dfltLabelYanchor(isLine, labelTextPosition) {
+            return isLine ? "bottom" : labelTextPosition.indexOf("top") !== -1 ? "top" : labelTextPosition.indexOf("bottom") !== -1 ? "bottom" : "middle";
+          }
+          function handleShapeDefaults(shapeIn, shapeOut, fullLayout) {
+            function coerce(attr, dflt) {
+              return Lib.coerce(shapeIn, shapeOut, attributes, attr, dflt);
+            }
+            shapeOut._isShape = true;
+            var visible = coerce("visible");
+            if (!visible) return;
+            var showlegend = coerce("showlegend");
+            if (showlegend) {
+              coerce("legend");
+              coerce("legendwidth");
+              coerce("legendgroup");
+              coerce("legendgrouptitle.text");
+              Lib.coerceFont(coerce, "legendgrouptitle.font");
+              coerce("legendrank");
+            }
+            var path = coerce("path");
+            var dfltType = path ? "path" : "rect";
+            var shapeType = coerce("type", dfltType);
+            var noPath = shapeType !== "path";
+            if (noPath) delete shapeOut.path;
+            coerce("editable");
+            coerce("layer");
+            coerce("opacity");
+            coerce("fillcolor");
+            coerce("fillrule");
+            var lineWidth = coerce("line.width");
+            if (lineWidth) {
+              coerce("line.color");
+              coerce("line.dash");
+            }
+            var xSizeMode = coerce("xsizemode");
+            var ySizeMode = coerce("ysizemode");
+            const dflts = [0.25, 0.75];
+            const pixelDflts = [0, 10];
+            ["x", "y"].forEach((axLetter) => {
+              var attrAnchor = axLetter + "anchor";
+              var sizeMode = axLetter === "x" ? xSizeMode : ySizeMode;
+              var gdMock = { _fullLayout: fullLayout };
+              var ax;
+              var pos2r;
+              var r2pos;
+              var axRef;
+              const refAttr = axLetter + "ref";
+              const inputRef = shapeIn[refAttr];
+              if (Array.isArray(inputRef) && inputRef.length > 0) {
+                const expectedLen = helpers.countDefiningCoords(shapeType, path, axLetter);
+                axRef = Axes.coerceRefArray(shapeIn, shapeOut, gdMock, axLetter, void 0, "paper", expectedLen);
+                shapeOut["_" + axLetter + "refArray"] = true;
+              } else {
+                axRef = Axes.coerceRef(shapeIn, shapeOut, gdMock, axLetter, void 0, "paper");
+              }
+              if (Array.isArray(axRef)) {
+                axRef.forEach(function(ref) {
+                  if (Axes.getRefType(ref) === "range") {
+                    ax = Axes.getFromId(gdMock, ref);
+                    if (ax && ax._shapeIndices.indexOf(shapeOut._index) === -1) {
+                      ax._shapeIndices.push(shapeOut._index);
+                    }
+                  }
+                });
+                if (noPath) {
+                  [0, 1].forEach(function(i2) {
+                    const ref = axRef[i2];
+                    const refType = Axes.getRefType(ref);
+                    if (refType === "range") {
+                      ax = Axes.getFromId(gdMock, ref);
+                      pos2r = helpers.shapePositionToRange(ax);
+                      r2pos = helpers.rangeToShapePosition(ax);
+                      if (ax.type === "category" || ax.type === "multicategory") {
+                        coerce(axLetter + i2 + "shift");
+                      }
+                    } else {
+                      pos2r = r2pos = Lib.identity;
+                    }
+                    const attr = axLetter + i2;
+                    const inValue = shapeIn[attr];
+                    shapeIn[attr] = pos2r(shapeIn[attr], true);
+                    if (sizeMode === "pixel") {
+                      coerce(attr, pixelDflts[i2]);
+                    } else {
+                      Axes.coercePosition(shapeOut, gdMock, coerce, ref, attr, dflts[i2]);
+                    }
+                    shapeOut[attr] = r2pos(shapeOut[attr]);
+                    shapeIn[attr] = inValue;
+                    if (i2 === 0 && sizeMode === "pixel") {
+                      const inAnchor = shapeIn[attrAnchor];
+                      shapeIn[attrAnchor] = pos2r(shapeIn[attrAnchor], true);
+                      Axes.coercePosition(shapeOut, gdMock, coerce, ref, attrAnchor, 0.25);
+                      shapeOut[attrAnchor] = r2pos(shapeOut[attrAnchor]);
+                      shapeIn[attrAnchor] = inAnchor;
+                    }
+                  });
+                }
+              } else {
+                const axRefType = Axes.getRefType(axRef);
+                if (axRefType === "range") {
+                  ax = Axes.getFromId(gdMock, axRef);
+                  ax._shapeIndices.push(shapeOut._index);
+                  r2pos = helpers.rangeToShapePosition(ax);
+                  pos2r = helpers.shapePositionToRange(ax);
+                  if (noPath && (ax.type === "category" || ax.type === "multicategory")) {
+                    coerce(axLetter + "0shift");
+                    coerce(axLetter + "1shift");
+                  }
+                } else {
+                  pos2r = r2pos = Lib.identity;
+                }
+                if (noPath) {
+                  const attr0 = axLetter + "0";
+                  const attr1 = axLetter + "1";
+                  const in0 = shapeIn[attr0];
+                  const in1 = shapeIn[attr1];
+                  shapeIn[attr0] = pos2r(shapeIn[attr0], true);
+                  shapeIn[attr1] = pos2r(shapeIn[attr1], true);
+                  if (sizeMode === "pixel") {
+                    coerce(attr0, pixelDflts[0]);
+                    coerce(attr1, pixelDflts[1]);
+                  } else {
+                    Axes.coercePosition(shapeOut, gdMock, coerce, axRef, attr0, dflts[0]);
+                    Axes.coercePosition(shapeOut, gdMock, coerce, axRef, attr1, dflts[1]);
+                  }
+                  shapeOut[attr0] = r2pos(shapeOut[attr0]);
+                  shapeOut[attr1] = r2pos(shapeOut[attr1]);
+                  shapeIn[attr0] = in0;
+                  shapeIn[attr1] = in1;
+                }
+                if (sizeMode === "pixel") {
+                  const inAnchor = shapeIn[attrAnchor];
+                  shapeIn[attrAnchor] = pos2r(shapeIn[attrAnchor], true);
+                  Axes.coercePosition(shapeOut, gdMock, coerce, axRef, attrAnchor, 0.25);
+                  shapeOut[attrAnchor] = r2pos(shapeOut[attrAnchor]);
+                  shapeIn[attrAnchor] = inAnchor;
+                }
+              }
+            });
+            if (noPath) {
+              Lib.noneOrAll(shapeIn, shapeOut, ["x0", "x1", "y0", "y1"]);
+            }
+            var isLine = shapeType === "line";
+            var labelTextTemplate, labelText;
+            if (noPath) {
+              labelTextTemplate = coerce("label.texttemplate");
+              coerce("label.texttemplatefallback");
+            }
+            if (!labelTextTemplate) {
+              labelText = coerce("label.text");
+            }
+            if (labelText || labelTextTemplate) {
+              coerce("label.textangle");
+              var labelTextPosition = coerce("label.textposition", isLine ? "middle" : "middle center");
+              coerce("label.xanchor");
+              coerce("label.yanchor", dfltLabelYanchor(isLine, labelTextPosition));
+              coerce("label.padding");
+              Lib.coerceFont(coerce, "label.font", fullLayout.font);
+            }
+          }
+        }
+      });
+      var require_defaults12 = __commonJS({
+        "src/components/shapes/draw_newshape/defaults.js"(exports, module2) {
+          var Color2 = require_color();
+          var Lib = require_lib();
+          function dfltLabelYanchor(isLine, labelTextPosition) {
+            return isLine ? "bottom" : labelTextPosition.indexOf("top") !== -1 ? "top" : labelTextPosition.indexOf("bottom") !== -1 ? "bottom" : "middle";
+          }
+          module2.exports = function supplyDrawNewShapeDefaults(layoutIn, layoutOut, coerce) {
+            coerce("newshape.visible");
+            coerce("newshape.name");
+            coerce("newshape.showlegend");
+            coerce("newshape.legend");
+            coerce("newshape.legendwidth");
+            coerce("newshape.legendgroup");
+            coerce("newshape.legendgrouptitle.text");
+            Lib.coerceFont(coerce, "newshape.legendgrouptitle.font");
+            coerce("newshape.legendrank");
+            coerce("newshape.drawdirection");
+            coerce("newshape.layer");
+            coerce("newshape.fillcolor");
+            coerce("newshape.fillrule");
+            coerce("newshape.opacity");
+            var newshapeLineWidth = coerce("newshape.line.width");
+            if (newshapeLineWidth) {
+              var bgcolor = (layoutIn || {}).plot_bgcolor || "#FFF";
+              coerce("newshape.line.color", Color2.contrast(bgcolor));
+              coerce("newshape.line.dash");
+            }
+            var isLine = layoutIn.dragmode === "drawline";
+            var labelText = coerce("newshape.label.text");
+            var labelTextTemplate = coerce("newshape.label.texttemplate");
+            coerce("newshape.label.texttemplatefallback");
+            if (labelText || labelTextTemplate) {
+              coerce("newshape.label.textangle");
+              var labelTextPosition = coerce("newshape.label.textposition", isLine ? "middle" : "middle center");
+              coerce("newshape.label.xanchor");
+              coerce("newshape.label.yanchor", dfltLabelYanchor(isLine, labelTextPosition));
+              coerce("newshape.label.padding");
+              Lib.coerceFont(coerce, "newshape.label.font", layoutOut.font);
+            }
+            coerce("activeshape.fillcolor");
+            coerce("activeshape.opacity");
+          };
+        }
+      });
+      var require_calc_autorange2 = __commonJS({
+        "src/components/shapes/calc_autorange.js"(exports, module2) {
+          var Lib = require_lib();
+          var Axes = require_axes();
+          var constants = require_constants5();
+          var helpers = require_helpers8();
+          module2.exports = function calcAutorange(gd2) {
+            var fullLayout = gd2._fullLayout;
+            var shapeList = Lib.filterVisible(fullLayout.shapes);
+            if (!shapeList.length || !gd2._fullData.length) return;
+            for (var i2 = 0; i2 < shapeList.length; i2++) {
+              var shape = shapeList[i2];
+              shape._extremes = {};
+              var ax;
+              var bounds;
+              var xRefType = Axes.getRefType(shape.xref);
+              var yRefType = Axes.getRefType(shape.yref);
+              if (xRefType === "array") {
+                const extremesForRefArray = calcArrayRefAutorange(gd2, shape, "x");
+                Object.entries(extremesForRefArray).forEach(([axID, axExtremes]) => {
+                  ax = Axes.getFromId(gd2, axID);
+                  shape._extremes[ax._id] = Axes.findExtremes(ax, axExtremes, calcXPaddingOptions(shape));
+                });
+              } else if (shape.xref !== "paper" && xRefType !== "domain") {
+                ax = Axes.getFromId(gd2, shape.xref);
+                bounds = shapeBounds(ax, shape, constants.paramIsX);
+                if (bounds) {
+                  shape._extremes[ax._id] = Axes.findExtremes(ax, bounds, calcXPaddingOptions(shape));
+                }
+              }
+              if (yRefType === "array") {
+                const extremesForRefArray = calcArrayRefAutorange(gd2, shape, "y");
+                Object.entries(extremesForRefArray).forEach(([axID, axExtremes]) => {
+                  ax = Axes.getFromId(gd2, axID);
+                  shape._extremes[ax._id] = Axes.findExtremes(ax, axExtremes, calcYPaddingOptions(shape));
+                });
+              } else if (shape.yref !== "paper" && yRefType !== "domain") {
+                ax = Axes.getFromId(gd2, shape.yref);
+                bounds = shapeBounds(ax, shape, constants.paramIsY);
+                if (bounds) {
+                  shape._extremes[ax._id] = Axes.findExtremes(ax, bounds, calcYPaddingOptions(shape));
+                }
+              }
+            }
+          };
+          function calcArrayRefAutorange(gd2, shape, axLetter) {
+            const refs = shape[axLetter + "ref"];
+            const paramsToUse = axLetter === "x" ? constants.paramIsX : constants.paramIsY;
+            function addToAxisGroup(ref, val) {
+              if (ref === "paper" || Axes.getRefType(ref) === "domain") return;
+              if (!axisGroups[ref]) axisGroups[ref] = [];
+              axisGroups[ref].push(val);
+            }
+            const axisGroups = {};
+            if (shape.type === "path" && shape.path) {
+              const segments = shape.path.match(constants.segmentRE) || [];
+              var refIndex = 0;
+              for (var i2 = 0; i2 < segments.length; i2++) {
+                const segment = segments[i2];
+                const command = segment.charAt(0);
+                const drawnIndex = paramsToUse[command].drawn;
+                if (drawnIndex === void 0) continue;
+                const params = segment.slice(1).match(constants.paramRE);
+                if (params && params.length > drawnIndex) {
+                  addToAxisGroup(refs[refIndex], params[drawnIndex]);
+                  refIndex++;
+                }
+              }
+            } else {
+              addToAxisGroup(refs[0], shape[axLetter + "0"]);
+              addToAxisGroup(refs[1], shape[axLetter + "1"]);
+            }
+            const convertedGroups = {};
+            for (const axId in axisGroups) {
+              const ax = Axes.getFromId(gd2, axId);
+              if (!ax) continue;
+              var convertVal = ax.type === "category" || ax.type === "multicategory" ? ax.r2c : ax.d2c;
+              if (ax.type === "date") convertVal = helpers.decodeDate(convertVal);
+              convertedGroups[ax._id] = axisGroups[axId].map(convertVal);
+            }
+            return convertedGroups;
+          }
+          function calcXPaddingOptions(shape) {
+            return calcPaddingOptions(shape.line.width, shape.xsizemode, shape.x0, shape.x1, shape.path, false);
+          }
+          function calcYPaddingOptions(shape) {
+            return calcPaddingOptions(shape.line.width, shape.ysizemode, shape.y0, shape.y1, shape.path, true);
+          }
+          function calcPaddingOptions(lineWidth, sizeMode, v0, v1, path, isYAxis) {
+            var ppad = lineWidth / 2;
+            var axisDirectionReverted = isYAxis;
+            if (sizeMode === "pixel") {
+              var coords = path ? helpers.extractPathCoords(path, isYAxis ? constants.paramIsY : constants.paramIsX) : [v0, v1];
+              var maxValue = Lib.aggNums(Math.max, null, coords);
+              var minValue = Lib.aggNums(Math.min, null, coords);
+              var beforePad = minValue < 0 ? Math.abs(minValue) + ppad : ppad;
+              var afterPad = maxValue > 0 ? maxValue + ppad : ppad;
+              return {
+                ppad,
+                ppadplus: axisDirectionReverted ? beforePad : afterPad,
+                ppadminus: axisDirectionReverted ? afterPad : beforePad
+              };
+            } else {
+              return { ppad };
+            }
+          }
+          function shapeBounds(ax, shape, paramsToUse) {
+            var dim = ax._id.charAt(0) === "x" ? "x" : "y";
+            var isCategory = ax.type === "category" || ax.type === "multicategory";
+            var v0;
+            var v1;
+            var shiftStart = 0;
+            var shiftEnd = 0;
+            var convertVal = isCategory ? ax.r2c : ax.d2c;
+            var isSizeModeScale = shape[dim + "sizemode"] === "scaled";
+            if (isSizeModeScale) {
+              v0 = shape[dim + "0"];
+              v1 = shape[dim + "1"];
+              if (isCategory) {
+                shiftStart = shape[dim + "0shift"];
+                shiftEnd = shape[dim + "1shift"];
+              }
+            } else {
+              v0 = shape[dim + "anchor"];
+              v1 = shape[dim + "anchor"];
+            }
+            if (v0 !== void 0) return [convertVal(v0) + shiftStart, convertVal(v1) + shiftEnd];
+            if (!shape.path) return;
+            var min = Infinity;
+            var max = -Infinity;
+            var segments = shape.path.match(constants.segmentRE);
+            var i2;
+            var segment;
+            var drawnParam;
+            var params;
+            var val;
+            if (ax.type === "date") convertVal = helpers.decodeDate(convertVal);
+            for (i2 = 0; i2 < segments.length; i2++) {
+              segment = segments[i2];
+              drawnParam = paramsToUse[segment.charAt(0)].drawn;
+              if (drawnParam === void 0) continue;
+              params = segments[i2].slice(1).match(constants.paramRE);
+              if (!params || params.length < drawnParam) continue;
+              val = convertVal(params[drawnParam]);
+              if (val < min) min = val;
+              if (val > max) max = val;
+            }
+            if (max >= min) return [min, max];
+          }
+        }
+      });
+      var require_shapes = __commonJS({
+        "src/components/shapes/index.js"(exports, module2) {
+          var drawModule = require_draw2();
+          module2.exports = {
+            moduleType: "component",
+            name: "shapes",
+            layoutAttributes: require_attributes16(),
+            supplyLayoutDefaults: require_defaults11(),
+            supplyDrawNewShapeDefaults: require_defaults12(),
+            includeBasePlot: require_include_components()("shapes"),
+            calcAutorange: require_calc_autorange2(),
+            draw: drawModule.draw,
+            drawOne: drawModule.drawOne
+          };
+        }
+      });
+      var require_attributes17 = __commonJS({
+        "src/components/images/attributes.js"(exports, module2) {
+          var cartesianConstants = require_constants2();
+          var templatedArray = require_plot_template().templatedArray;
+          require_axis_placeable_objects();
+          module2.exports = templatedArray("image", {
+            visible: {
+              valType: "boolean",
+              dflt: true,
+              editType: "arraydraw"
+            },
+            source: {
+              valType: "string",
+              editType: "arraydraw"
+            },
+            layer: {
+              valType: "enumerated",
+              values: ["below", "above"],
+              dflt: "above",
+              editType: "arraydraw"
+            },
+            sizex: {
+              valType: "number",
+              dflt: 0,
+              editType: "arraydraw"
+            },
+            sizey: {
+              valType: "number",
+              dflt: 0,
+              editType: "arraydraw"
+            },
+            sizing: {
+              valType: "enumerated",
+              values: ["fill", "contain", "stretch"],
+              dflt: "contain",
+              editType: "arraydraw"
+            },
+            opacity: {
+              valType: "number",
+              min: 0,
+              max: 1,
+              dflt: 1,
+              editType: "arraydraw"
+            },
+            x: {
+              valType: "any",
+              dflt: 0,
+              editType: "arraydraw"
+            },
+            y: {
+              valType: "any",
+              dflt: 0,
+              editType: "arraydraw"
+            },
+            xanchor: {
+              valType: "enumerated",
+              values: ["left", "center", "right"],
+              dflt: "left",
+              editType: "arraydraw"
+            },
+            yanchor: {
+              valType: "enumerated",
+              values: ["top", "middle", "bottom"],
+              dflt: "top",
+              editType: "arraydraw"
+            },
+            xref: {
+              valType: "enumerated",
+              values: [
+                "paper",
+                cartesianConstants.idRegex.x.toString()
+              ],
+              dflt: "paper",
+              editType: "arraydraw"
+            },
+            yref: {
+              valType: "enumerated",
+              values: [
+                "paper",
+                cartesianConstants.idRegex.y.toString()
+              ],
+              dflt: "paper",
+              editType: "arraydraw"
+            },
+            editType: "arraydraw"
+          });
+        }
+      });
+      var require_defaults13 = __commonJS({
+        "src/components/images/defaults.js"(exports, module2) {
+          var Lib = require_lib();
+          var Axes = require_axes();
+          var handleArrayContainerDefaults = require_array_container_defaults();
+          var attributes = require_attributes17();
+          var name2 = "images";
+          module2.exports = function supplyLayoutDefaults(layoutIn, layoutOut) {
+            var opts = {
+              name: name2,
+              handleItemDefaults: imageDefaults
+            };
+            handleArrayContainerDefaults(layoutIn, layoutOut, opts);
+          };
+          function imageDefaults(imageIn, imageOut, fullLayout) {
+            function coerce(attr, dflt) {
+              return Lib.coerce(imageIn, imageOut, attributes, attr, dflt);
+            }
+            var source2 = coerce("source");
+            var visible = coerce("visible", !!source2);
+            if (!visible) return imageOut;
+            coerce("layer");
+            coerce("xanchor");
+            coerce("yanchor");
+            coerce("sizex");
+            coerce("sizey");
+            coerce("sizing");
+            coerce("opacity");
+            var gdMock = { _fullLayout: fullLayout };
+            var axLetters = ["x", "y"];
+            for (var i2 = 0; i2 < 2; i2++) {
+              var axLetter = axLetters[i2];
+              var axRef = Axes.coerceRef(imageIn, imageOut, gdMock, axLetter, "paper", void 0);
+              if (axRef !== "paper") {
+                var ax = Axes.getFromId(gdMock, axRef);
+                ax._imgIndices.push(imageOut._index);
+              }
+              Axes.coercePosition(imageOut, gdMock, coerce, axRef, axLetter, 0);
+            }
+            return imageOut;
+          }
+        }
+      });
+      var require_draw6 = __commonJS({
+        "src/components/images/draw.js"(exports, module2) {
+          var d3 = require_d3();
+          var Drawing = require_drawing();
+          var Axes = require_axes();
+          var axisIds = require_axis_ids();
+          var xmlnsNamespaces = require_xmlns_namespaces();
+          module2.exports = function draw(gd2) {
+            var fullLayout = gd2._fullLayout;
+            var imageDataAbove = [];
+            var imageDataSubplot = {};
+            var imageDataBelow = [];
+            var subplot;
+            var i2;
+            for (i2 = 0; i2 < fullLayout.images.length; i2++) {
+              var img = fullLayout.images[i2];
+              if (img.visible) {
+                if (img.layer === "below" && img.xref !== "paper" && img.yref !== "paper") {
+                  subplot = axisIds.ref2id(img.xref) + axisIds.ref2id(img.yref);
+                  var plotinfo = fullLayout._plots[subplot];
+                  if (!plotinfo) {
+                    imageDataBelow.push(img);
+                    continue;
+                  }
+                  if (plotinfo.mainplot) {
+                    subplot = plotinfo.mainplot.id;
+                  }
+                  if (!imageDataSubplot[subplot]) {
+                    imageDataSubplot[subplot] = [];
+                  }
+                  imageDataSubplot[subplot].push(img);
+                } else if (img.layer === "above") {
+                  imageDataAbove.push(img);
+                } else {
+                  imageDataBelow.push(img);
+                }
+              }
+            }
+            var anchors = {
+              x: {
+                left: { sizing: "xMin", offset: 0 },
+                center: { sizing: "xMid", offset: -1 / 2 },
+                right: { sizing: "xMax", offset: -1 }
+              },
+              y: {
+                top: { sizing: "YMin", offset: 0 },
+                middle: { sizing: "YMid", offset: -1 / 2 },
+                bottom: { sizing: "YMax", offset: -1 }
+              }
+            };
+            function setImage(d2) {
+              var thisImage = d3.select(this);
+              if (this._imgSrc === d2.source) {
+                return;
+              }
+              thisImage.attr("xmlns", xmlnsNamespaces.svg);
+              if (!gd2._context.staticPlot || d2.source && d2.source.slice(0, 5) === "data:") {
+                thisImage.attr("xlink:href", d2.source);
+                this._imgSrc = d2.source;
+              } else {
+                var imagePromise = new Promise((function(resolve) {
+                  var img2 = new Image();
+                  this.img = img2;
+                  img2.setAttribute("crossOrigin", "anonymous");
+                  img2.onerror = errorHandler;
+                  img2.onload = function() {
+                    var canvas2 = document.createElement("canvas");
+                    canvas2.width = this.width;
+                    canvas2.height = this.height;
+                    var ctx2 = canvas2.getContext("2d", { willReadFrequently: true });
+                    ctx2.drawImage(this, 0, 0);
+                    var dataURL = canvas2.toDataURL("image/png");
+                    thisImage.attr("xlink:href", dataURL);
+                    resolve();
+                  };
+                  thisImage.on("error", errorHandler);
+                  img2.src = d2.source;
+                  this._imgSrc = d2.source;
+                  function errorHandler() {
+                    thisImage.remove();
+                    resolve();
+                  }
+                }).bind(this));
+                gd2._promises.push(imagePromise);
+              }
+            }
+            function applyAttributes(d2) {
+              var thisImage = d3.select(this);
+              var xa = Axes.getFromId(gd2, d2.xref);
+              var ya2 = Axes.getFromId(gd2, d2.yref);
+              var xIsDomain = Axes.getRefType(d2.xref) === "domain";
+              var yIsDomain = Axes.getRefType(d2.yref) === "domain";
+              var size = fullLayout._size;
+              var width, height;
+              if (xa !== void 0) {
+                width = typeof d2.xref === "string" && xIsDomain ? xa._length * d2.sizex : Math.abs(xa.l2p(d2.sizex) - xa.l2p(0));
+              } else {
+                width = d2.sizex * size.w;
+              }
+              if (ya2 !== void 0) {
+                height = typeof d2.yref === "string" && yIsDomain ? ya2._length * d2.sizey : Math.abs(ya2.l2p(d2.sizey) - ya2.l2p(0));
+              } else {
+                height = d2.sizey * size.h;
+              }
+              var xOffset = width * anchors.x[d2.xanchor].offset;
+              var yOffset = height * anchors.y[d2.yanchor].offset;
+              var sizing = anchors.x[d2.xanchor].sizing + anchors.y[d2.yanchor].sizing;
+              var xPos, yPos;
+              if (xa !== void 0) {
+                xPos = typeof d2.xref === "string" && xIsDomain ? xa._length * d2.x + xa._offset : xa.r2p(d2.x) + xa._offset;
+              } else {
+                xPos = d2.x * size.w + size.l;
+              }
+              xPos += xOffset;
+              if (ya2 !== void 0) {
+                yPos = typeof d2.yref === "string" && yIsDomain ? (
+                  // consistent with "paper" yref value, where positive values
+                  // move up the page
+                  ya2._length * (1 - d2.y) + ya2._offset
+                ) : ya2.r2p(d2.y) + ya2._offset;
+              } else {
+                yPos = size.h - d2.y * size.h + size.t;
+              }
+              yPos += yOffset;
+              switch (d2.sizing) {
+                case "fill":
+                  sizing += " slice";
+                  break;
+                case "stretch":
+                  sizing = "none";
+                  break;
+              }
+              thisImage.attr({
+                x: xPos,
+                y: yPos,
+                width,
+                height,
+                preserveAspectRatio: sizing,
+                opacity: d2.opacity
+              });
+              var xId = xa && Axes.getRefType(d2.xref) !== "domain" ? xa._id : "";
+              var yId = ya2 && Axes.getRefType(d2.yref) !== "domain" ? ya2._id : "";
+              var clipAxes = xId + yId;
+              Drawing.setClipUrl(
+                thisImage,
+                clipAxes ? "clip" + fullLayout._uid + clipAxes : null,
+                gd2
+              );
+            }
+            function imgDataFunc(d2) {
+              return [d2.xref, d2.x, d2.sizex, d2.yref, d2.y, d2.sizey].join("_");
+            }
+            function imgSort(a2, b2) {
+              return a2._index - b2._index;
+            }
+            var imagesBelow = fullLayout._imageLowerLayer.selectAll("image").data(imageDataBelow, imgDataFunc);
+            var imagesAbove = fullLayout._imageUpperLayer.selectAll("image").data(imageDataAbove, imgDataFunc);
+            imagesBelow.enter().append("image");
+            imagesAbove.enter().append("image");
+            imagesBelow.exit().remove();
+            imagesAbove.exit().remove();
+            imagesBelow.each(function(d2) {
+              setImage.bind(this)(d2);
+              applyAttributes.bind(this)(d2);
+            });
+            imagesAbove.each(function(d2) {
+              setImage.bind(this)(d2);
+              applyAttributes.bind(this)(d2);
+            });
+            imagesBelow.sort(imgSort);
+            imagesAbove.sort(imgSort);
+            var allSubplots = Object.keys(fullLayout._plots);
+            for (i2 = 0; i2 < allSubplots.length; i2++) {
+              subplot = allSubplots[i2];
+              var subplotObj = fullLayout._plots[subplot];
+              if (!subplotObj.imagelayer) continue;
+              var imagesOnSubplot = subplotObj.imagelayer.selectAll("image").data(imageDataSubplot[subplot] || [], imgDataFunc);
+              imagesOnSubplot.enter().append("image");
+              imagesOnSubplot.exit().remove();
+              imagesOnSubplot.each(function(d2) {
+                setImage.bind(this)(d2);
+                applyAttributes.bind(this)(d2);
+              });
+              imagesOnSubplot.sort(imgSort);
+            }
+          };
+        }
+      });
+      var require_convert_coords2 = __commonJS({
+        "src/components/images/convert_coords.js"(exports, module2) {
+          var isNumeric = require_fast_isnumeric();
+          var toLogRange = require_to_log_range();
+          module2.exports = function convertCoords(gd2, ax, newType, doExtra) {
+            ax = ax || {};
+            var toLog = newType === "log" && ax.type === "linear";
+            var fromLog = newType === "linear" && ax.type === "log";
+            if (!(toLog || fromLog)) return;
+            var images = gd2._fullLayout.images;
+            var axLetter = ax._id.charAt(0);
+            var image;
+            var attrPrefix;
+            for (var i2 = 0; i2 < images.length; i2++) {
+              image = images[i2];
+              attrPrefix = "images[" + i2 + "].";
+              if (image[axLetter + "ref"] === ax._id) {
+                var currentPos = image[axLetter];
+                var currentSize = image["size" + axLetter];
+                var newPos = null;
+                var newSize = null;
+                if (toLog) {
+                  newPos = toLogRange(currentPos, ax.range);
+                  var dx = currentSize / Math.pow(10, newPos) / 2;
+                  newSize = 2 * Math.log(dx + Math.sqrt(1 + dx * dx)) / Math.LN10;
+                } else {
+                  newPos = Math.pow(10, currentPos);
+                  newSize = newPos * (Math.pow(10, currentSize / 2) - Math.pow(10, -currentSize / 2));
+                }
+                if (!isNumeric(newPos)) {
+                  newPos = null;
+                  newSize = null;
+                } else if (!isNumeric(newSize)) newSize = null;
+                doExtra(attrPrefix + axLetter, newPos);
+                doExtra(attrPrefix + "size" + axLetter, newSize);
+              }
+            }
+          };
+        }
+      });
+      var require_images = __commonJS({
+        "src/components/images/index.js"(exports, module2) {
+          module2.exports = {
+            moduleType: "component",
+            name: "images",
+            layoutAttributes: require_attributes17(),
+            supplyLayoutDefaults: require_defaults13(),
+            includeBasePlot: require_include_components()("images"),
+            draw: require_draw6(),
+            convertCoords: require_convert_coords2()
+          };
+        }
+      });
+      var require_constants10 = __commonJS({
+        "src/components/updatemenus/constants.js"(exports, module2) {
+          module2.exports = {
+            // layout attribute name
+            name: "updatemenus",
+            // class names
+            containerClassName: "updatemenu-container",
+            headerGroupClassName: "updatemenu-header-group",
+            headerClassName: "updatemenu-header",
+            headerArrowClassName: "updatemenu-header-arrow",
+            dropdownButtonGroupClassName: "updatemenu-dropdown-button-group",
+            dropdownButtonClassName: "updatemenu-dropdown-button",
+            buttonClassName: "updatemenu-button",
+            itemRectClassName: "updatemenu-item-rect",
+            itemTextClassName: "updatemenu-item-text",
+            // DOM attribute name in button group keeping track
+            // of active update menu
+            menuIndexAttrName: "updatemenu-active-index",
+            // id root pass to Plots.autoMargin
+            autoMarginIdRoot: "updatemenu-",
+            // options when 'active: -1'
+            blankHeaderOpts: { label: "  " },
+            // min item width / height
+            minWidth: 30,
+            minHeight: 30,
+            // padding around item text
+            textPadX: 24,
+            arrowPadX: 16,
+            // item rect radii
+            rx: 2,
+            ry: 2,
+            // item  text x offset off left edge
+            textOffsetX: 12,
+            // item  text y offset (w.r.t. middle)
+            textOffsetY: 3,
+            // arrow offset off right edge
+            arrowOffsetX: 4,
+            // gap between header and buttons
+            gapButtonHeader: 5,
+            // gap between between buttons
+            gapButton: 2,
+            // color given to active buttons
+            activeColor: "#F4FAFF",
+            // color given to hovered buttons
+            hoverColor: "#F4FAFF",
+            // symbol for menu open arrow
+            arrowSymbol: {
+              left: "◄",
+              right: "►",
+              up: "▲",
+              down: "▼"
+            }
+          };
+        }
+      });
+      var require_attributes18 = __commonJS({
+        "src/components/updatemenus/attributes.js"(exports, module2) {
+          var fontAttrs = require_font_attributes();
+          var colorAttrs = require_attributes3();
+          var extendFlat = require_extend().extendFlat;
+          var overrideAll = require_edit_types().overrideAll;
+          var padAttrs = require_pad_attributes();
+          var templatedArray = require_plot_template().templatedArray;
+          var buttonsAttrs = templatedArray("button", {
+            visible: {
+              valType: "boolean"
+            },
+            method: {
+              valType: "enumerated",
+              values: ["restyle", "relayout", "animate", "update", "skip"],
+              dflt: "restyle"
+            },
+            args: {
+              valType: "info_array",
+              freeLength: true,
+              items: [
+                { valType: "any" },
+                { valType: "any" },
+                { valType: "any" }
+              ]
+            },
+            args2: {
+              valType: "info_array",
+              freeLength: true,
+              items: [
+                { valType: "any" },
+                { valType: "any" },
+                { valType: "any" }
+              ]
+            },
+            label: {
+              valType: "string",
+              dflt: ""
+            },
+            execute: {
+              valType: "boolean",
+              dflt: true
+            }
+          });
+          module2.exports = overrideAll(templatedArray("updatemenu", {
+            _arrayAttrRegexps: [/^updatemenus\[(0|[1-9][0-9]+)\]\.buttons/],
+            visible: {
+              valType: "boolean"
+            },
+            type: {
+              valType: "enumerated",
+              values: ["dropdown", "buttons"],
+              dflt: "dropdown"
+            },
+            direction: {
+              valType: "enumerated",
+              values: ["left", "right", "up", "down"],
+              dflt: "down"
+            },
+            active: {
+              valType: "integer",
+              min: -1,
+              dflt: 0
+            },
+            showactive: {
+              valType: "boolean",
+              dflt: true
+            },
+            buttons: buttonsAttrs,
+            x: {
+              valType: "number",
+              min: -2,
+              max: 3,
+              dflt: -0.05
+            },
+            xanchor: {
+              valType: "enumerated",
+              values: ["auto", "left", "center", "right"],
+              dflt: "right"
+            },
+            y: {
+              valType: "number",
+              min: -2,
+              max: 3,
+              dflt: 1
+            },
+            yanchor: {
+              valType: "enumerated",
+              values: ["auto", "top", "middle", "bottom"],
+              dflt: "top"
+            },
+            pad: extendFlat(padAttrs({ editType: "arraydraw" }), {}),
+            font: fontAttrs({}),
+            bgcolor: {
+              valType: "color"
+            },
+            bordercolor: {
+              valType: "color",
+              dflt: colorAttrs.borderLine
+            },
+            borderwidth: {
+              valType: "number",
+              min: 0,
+              dflt: 1,
+              editType: "arraydraw"
+            }
+          }), "arraydraw", "from-root");
+        }
+      });
+      var require_defaults14 = __commonJS({
+        "src/components/updatemenus/defaults.js"(exports, module2) {
+          var Lib = require_lib();
+          var handleArrayContainerDefaults = require_array_container_defaults();
+          var attributes = require_attributes18();
+          var constants = require_constants10();
+          var name2 = constants.name;
+          var buttonAttrs = attributes.buttons;
+          module2.exports = function updateMenusDefaults(layoutIn, layoutOut) {
+            var opts = {
+              name: name2,
+              handleItemDefaults: menuDefaults
+            };
+            handleArrayContainerDefaults(layoutIn, layoutOut, opts);
+          };
+          function menuDefaults(menuIn, menuOut, layoutOut) {
+            function coerce(attr, dflt) {
+              return Lib.coerce(menuIn, menuOut, attributes, attr, dflt);
+            }
+            var buttons = handleArrayContainerDefaults(menuIn, menuOut, {
+              name: "buttons",
+              handleItemDefaults: buttonDefaults
+            });
+            var visible = coerce("visible", buttons.length > 0);
+            if (!visible) return;
+            coerce("active");
+            coerce("direction");
+            coerce("type");
+            coerce("showactive");
+            coerce("x");
+            coerce("y");
+            Lib.noneOrAll(menuIn, menuOut, ["x", "y"]);
+            coerce("xanchor");
+            coerce("yanchor");
+            coerce("pad.t");
+            coerce("pad.r");
+            coerce("pad.b");
+            coerce("pad.l");
+            Lib.coerceFont(coerce, "font", layoutOut.font);
+            coerce("bgcolor", layoutOut.paper_bgcolor);
+            coerce("bordercolor");
+            coerce("borderwidth");
+          }
+          function buttonDefaults(buttonIn, buttonOut) {
+            function coerce(attr, dflt) {
+              return Lib.coerce(buttonIn, buttonOut, buttonAttrs, attr, dflt);
+            }
+            var visible = coerce(
+              "visible",
+              buttonIn.method === "skip" || Array.isArray(buttonIn.args)
+            );
+            if (visible) {
+              coerce("method");
+              coerce("args");
+              coerce("args2");
+              coerce("label");
+              coerce("execute");
+            }
+          }
+        }
+      });
+      var require_scrollbox = __commonJS({
+        "src/components/updatemenus/scrollbox.js"(exports, module2) {
+          module2.exports = ScrollBox;
+          var d3 = require_d3();
+          var Color2 = require_color();
+          var Drawing = require_drawing();
+          var Lib = require_lib();
+          function ScrollBox(gd2, container, id2) {
+            this.gd = gd2;
+            this.container = container;
+            this.id = id2;
+            this.position = null;
+            this.translateX = null;
+            this.translateY = null;
+            this.hbar = null;
+            this.vbar = null;
+            this.bg = this.container.selectAll("rect.scrollbox-bg").data([0]);
+            this.bg.exit().on(".drag", null).on("wheel", null).remove();
+            this.bg.enter().append("rect").classed("scrollbox-bg", true).style("pointer-events", "all").attr({
+              opacity: 0,
+              x: 0,
+              y: 0,
+              width: 0,
+              height: 0
+            });
+          }
+          ScrollBox.barWidth = 2;
+          ScrollBox.barLength = 20;
+          ScrollBox.barRadius = 2;
+          ScrollBox.barPad = 1;
+          ScrollBox.barColor = "#808BA4";
+          ScrollBox.prototype.enable = function enable2(position, translateX, translateY) {
+            var fullLayout = this.gd._fullLayout;
+            var fullWidth = fullLayout.width;
+            var fullHeight = fullLayout.height;
+            this.position = position;
+            var l2 = this.position.l;
+            var w2 = this.position.w;
+            var t4 = this.position.t;
+            var h2 = this.position.h;
+            var direction = this.position.direction;
+            var isDown = direction === "down";
+            var isLeft = direction === "left";
+            var isRight = direction === "right";
+            var isUp = direction === "up";
+            var boxW = w2;
+            var boxH = h2;
+            var boxL, boxR;
+            var boxT, boxB;
+            if (!isDown && !isLeft && !isRight && !isUp) {
+              this.position.direction = "down";
+              isDown = true;
+            }
+            var isVertical = isDown || isUp;
+            if (isVertical) {
+              boxL = l2;
+              boxR = boxL + boxW;
+              if (isDown) {
+                boxT = t4;
+                boxB = Math.min(boxT + boxH, fullHeight);
+                boxH = boxB - boxT;
+              } else {
+                boxB = t4 + boxH;
+                boxT = Math.max(boxB - boxH, 0);
+                boxH = boxB - boxT;
+              }
+            } else {
+              boxT = t4;
+              boxB = boxT + boxH;
+              if (isLeft) {
+                boxR = l2 + boxW;
+                boxL = Math.max(boxR - boxW, 0);
+                boxW = boxR - boxL;
+              } else {
+                boxL = l2;
+                boxR = Math.min(boxL + boxW, fullWidth);
+                boxW = boxR - boxL;
+              }
+            }
+            this._box = {
+              l: boxL,
+              t: boxT,
+              w: boxW,
+              h: boxH
+            };
+            var needsHorizontalScrollBar = w2 > boxW;
+            var hbarW = ScrollBox.barLength + 2 * ScrollBox.barPad;
+            var hbarH = ScrollBox.barWidth + 2 * ScrollBox.barPad;
+            var hbarL = l2;
+            var hbarT = t4 + h2;
+            if (hbarT + hbarH > fullHeight) hbarT = fullHeight - hbarH;
+            var hbar = this.container.selectAll("rect.scrollbar-horizontal").data(
+              needsHorizontalScrollBar ? [0] : []
+            );
+            hbar.exit().on(".drag", null).remove();
+            hbar.enter().append("rect").classed("scrollbar-horizontal", true).call(Color2.fill, ScrollBox.barColor);
+            if (needsHorizontalScrollBar) {
+              this.hbar = hbar.attr({
+                rx: ScrollBox.barRadius,
+                ry: ScrollBox.barRadius,
+                x: hbarL,
+                y: hbarT,
+                width: hbarW,
+                height: hbarH
+              });
+              this._hbarXMin = hbarL + hbarW / 2;
+              this._hbarTranslateMax = boxW - hbarW;
+            } else {
+              delete this.hbar;
+              delete this._hbarXMin;
+              delete this._hbarTranslateMax;
+            }
+            var needsVerticalScrollBar = h2 > boxH;
+            var vbarW = ScrollBox.barWidth + 2 * ScrollBox.barPad;
+            var vbarH = ScrollBox.barLength + 2 * ScrollBox.barPad;
+            var vbarL = l2 + w2;
+            var vbarT = t4;
+            if (vbarL + vbarW > fullWidth) vbarL = fullWidth - vbarW;
+            var vbar = this.container.selectAll("rect.scrollbar-vertical").data(
+              needsVerticalScrollBar ? [0] : []
+            );
+            vbar.exit().on(".drag", null).remove();
+            vbar.enter().append("rect").classed("scrollbar-vertical", true).call(Color2.fill, ScrollBox.barColor);
+            if (needsVerticalScrollBar) {
+              this.vbar = vbar.attr({
+                rx: ScrollBox.barRadius,
+                ry: ScrollBox.barRadius,
+                x: vbarL,
+                y: vbarT,
+                width: vbarW,
+                height: vbarH
+              });
+              this._vbarYMin = vbarT + vbarH / 2;
+              this._vbarTranslateMax = boxH - vbarH;
+            } else {
+              delete this.vbar;
+              delete this._vbarYMin;
+              delete this._vbarTranslateMax;
+            }
+            var clipId = this.id;
+            var clipL = boxL - 0.5;
+            var clipR = needsVerticalScrollBar ? boxR + vbarW + 0.5 : boxR + 0.5;
+            var clipT = boxT - 0.5;
+            var clipB = needsHorizontalScrollBar ? boxB + hbarH + 0.5 : boxB + 0.5;
+            var clipPath = fullLayout._topdefs.selectAll("#" + clipId).data(needsHorizontalScrollBar || needsVerticalScrollBar ? [0] : []);
+            clipPath.exit().remove();
+            clipPath.enter().append("clipPath").attr("id", clipId).append("rect");
+            if (needsHorizontalScrollBar || needsVerticalScrollBar) {
+              this._clipRect = clipPath.select("rect").attr({
+                x: Math.floor(clipL),
+                y: Math.floor(clipT),
+                width: Math.ceil(clipR) - Math.floor(clipL),
+                height: Math.ceil(clipB) - Math.floor(clipT)
+              });
+              this.container.call(Drawing.setClipUrl, clipId, this.gd);
+              this.bg.attr({
+                x: l2,
+                y: t4,
+                width: w2,
+                height: h2
+              });
+            } else {
+              this.bg.attr({
+                width: 0,
+                height: 0
+              });
+              this.container.on("wheel", null).on(".drag", null).call(Drawing.setClipUrl, null);
+              delete this._clipRect;
+            }
+            if (needsHorizontalScrollBar || needsVerticalScrollBar) {
+              var onBoxDrag = d3.behavior.drag().on("dragstart", function() {
+                d3.event.sourceEvent.preventDefault();
+              }).on("drag", this._onBoxDrag.bind(this));
+              this.container.on("wheel", null).on("wheel", this._onBoxWheel.bind(this)).on(".drag", null).call(onBoxDrag);
+              var onBarDrag = d3.behavior.drag().on("dragstart", function() {
+                d3.event.sourceEvent.preventDefault();
+                d3.event.sourceEvent.stopPropagation();
+              }).on("drag", this._onBarDrag.bind(this));
+              if (needsHorizontalScrollBar) {
+                this.hbar.on(".drag", null).call(onBarDrag);
+              }
+              if (needsVerticalScrollBar) {
+                this.vbar.on(".drag", null).call(onBarDrag);
+              }
+            }
+            this.setTranslate(translateX, translateY);
+          };
+          ScrollBox.prototype.disable = function disable() {
+            if (this.hbar || this.vbar) {
+              this.bg.attr({
+                width: 0,
+                height: 0
+              });
+              this.container.on("wheel", null).on(".drag", null).call(Drawing.setClipUrl, null);
+              delete this._clipRect;
+            }
+            if (this.hbar) {
+              this.hbar.on(".drag", null);
+              this.hbar.remove();
+              delete this.hbar;
+              delete this._hbarXMin;
+              delete this._hbarTranslateMax;
+            }
+            if (this.vbar) {
+              this.vbar.on(".drag", null);
+              this.vbar.remove();
+              delete this.vbar;
+              delete this._vbarYMin;
+              delete this._vbarTranslateMax;
+            }
+          };
+          ScrollBox.prototype._onBoxDrag = function _onBoxDrag() {
+            var translateX = this.translateX;
+            var translateY = this.translateY;
+            if (this.hbar) {
+              translateX -= d3.event.dx;
+            }
+            if (this.vbar) {
+              translateY -= d3.event.dy;
+            }
+            this.setTranslate(translateX, translateY);
+          };
+          ScrollBox.prototype._onBoxWheel = function _onBoxWheel() {
+            var translateX = this.translateX;
+            var translateY = this.translateY;
+            if (this.hbar) {
+              translateX += d3.event.deltaY;
+            }
+            if (this.vbar) {
+              translateY += d3.event.deltaY;
+            }
+            this.setTranslate(translateX, translateY);
+          };
+          ScrollBox.prototype._onBarDrag = function _onBarDrag() {
+            var translateX = this.translateX;
+            var translateY = this.translateY;
+            if (this.hbar) {
+              var xMin = translateX + this._hbarXMin;
+              var xMax = xMin + this._hbarTranslateMax;
+              var x2 = Lib.constrain(d3.event.x, xMin, xMax);
+              var xf2 = (x2 - xMin) / (xMax - xMin);
+              var translateXMax = this.position.w - this._box.w;
+              translateX = xf2 * translateXMax;
+            }
+            if (this.vbar) {
+              var yMin = translateY + this._vbarYMin;
+              var yMax = yMin + this._vbarTranslateMax;
+              var y2 = Lib.constrain(d3.event.y, yMin, yMax);
+              var yf2 = (y2 - yMin) / (yMax - yMin);
+              var translateYMax = this.position.h - this._box.h;
+              translateY = yf2 * translateYMax;
+            }
+            this.setTranslate(translateX, translateY);
+          };
+          ScrollBox.prototype.setTranslate = function setTranslate(translateX, translateY) {
+            var translateXMax = this.position.w - this._box.w;
+            var translateYMax = this.position.h - this._box.h;
+            translateX = Lib.constrain(translateX || 0, 0, translateXMax);
+            translateY = Lib.constrain(translateY || 0, 0, translateYMax);
+            this.translateX = translateX;
+            this.translateY = translateY;
+            this.container.call(
+              Drawing.setTranslate,
+              this._box.l - this.position.l - translateX,
+              this._box.t - this.position.t - translateY
+            );
+            if (this._clipRect) {
+              this._clipRect.attr({
+                x: Math.floor(this.position.l + translateX - 0.5),
+                y: Math.floor(this.position.t + translateY - 0.5)
+              });
+            }
+            if (this.hbar) {
+              var xf2 = translateX / translateXMax;
+              this.hbar.call(
+                Drawing.setTranslate,
+                translateX + xf2 * this._hbarTranslateMax,
+                translateY
+              );
+            }
+            if (this.vbar) {
+              var yf2 = translateY / translateYMax;
+              this.vbar.call(
+                Drawing.setTranslate,
+                translateX,
+                translateY + yf2 * this._vbarTranslateMax
+              );
+            }
+          };
+        }
+      });
+      var require_draw7 = __commonJS({
+        "src/components/updatemenus/draw.js"(exports, module2) {
+          var d3 = require_d3();
+          var Plots = require_plots();
+          var Color2 = require_color();
+          var Drawing = require_drawing();
+          var Lib = require_lib();
+          var svgTextUtils = require_svg_text_utils();
+          var arrayEditor = require_plot_template().arrayEditor;
+          var LINE_SPACING = require_alignment().LINE_SPACING;
+          var constants = require_constants10();
+          var ScrollBox = require_scrollbox();
+          module2.exports = function draw(gd2) {
+            var fullLayout = gd2._fullLayout;
+            var menuData = Lib.filterVisible(fullLayout[constants.name]);
+            function clearAutoMargin(menuOpts2) {
+              Plots.autoMargin(gd2, autoMarginId(menuOpts2));
+            }
+            var menus = fullLayout._menulayer.selectAll("g." + constants.containerClassName).data(menuData.length > 0 ? [0] : []);
+            menus.enter().append("g").classed(constants.containerClassName, true).style("cursor", "pointer");
+            menus.exit().each(function() {
+              d3.select(this).selectAll("g." + constants.headerGroupClassName).each(clearAutoMargin);
+            }).remove();
+            if (menuData.length === 0) return;
+            var headerGroups = menus.selectAll("g." + constants.headerGroupClassName).data(menuData, keyFunction);
+            headerGroups.enter().append("g").classed(constants.headerGroupClassName, true);
+            var gButton = Lib.ensureSingle(menus, "g", constants.dropdownButtonGroupClassName, function(s2) {
+              s2.style("pointer-events", "all");
+            });
+            for (var i2 = 0; i2 < menuData.length; i2++) {
+              var menuOpts = menuData[i2];
+              findDimensions(gd2, menuOpts);
+            }
+            var scrollBoxId = "updatemenus" + fullLayout._uid;
+            var scrollBox = new ScrollBox(gd2, gButton, scrollBoxId);
+            if (headerGroups.enter().size()) {
+              gButton.node().parentNode.appendChild(gButton.node());
+              gButton.call(removeAllButtons);
+            }
+            headerGroups.exit().each(function(menuOpts2) {
+              gButton.call(removeAllButtons);
+              clearAutoMargin(menuOpts2);
+            }).remove();
+            headerGroups.each(function(menuOpts2) {
+              var gHeader = d3.select(this);
+              var _gButton = menuOpts2.type === "dropdown" ? gButton : null;
+              Plots.manageCommandObserver(gd2, menuOpts2, menuOpts2.buttons, function(data) {
+                setActive(gd2, menuOpts2, menuOpts2.buttons[data.index], gHeader, _gButton, scrollBox, data.index, true);
+              });
+              if (menuOpts2.type === "dropdown") {
+                drawHeader(gd2, gHeader, gButton, scrollBox, menuOpts2);
+                if (isActive(gButton, menuOpts2)) {
+                  drawButtons(gd2, gHeader, gButton, scrollBox, menuOpts2);
+                }
+              } else {
+                drawButtons(gd2, gHeader, null, null, menuOpts2);
+              }
+            });
+          };
+          function keyFunction(menuOpts) {
+            return menuOpts._index;
+          }
+          function isFolded(gButton) {
+            return +gButton.attr(constants.menuIndexAttrName) === -1;
+          }
+          function isActive(gButton, menuOpts) {
+            return +gButton.attr(constants.menuIndexAttrName) === menuOpts._index;
+          }
+          function setActive(gd2, menuOpts, buttonOpts, gHeader, gButton, scrollBox, buttonIndex, isSilentUpdate) {
+            menuOpts.active = buttonIndex;
+            arrayEditor(gd2.layout, constants.name, menuOpts).applyUpdate("active", buttonIndex);
+            if (menuOpts.type === "buttons") {
+              drawButtons(gd2, gHeader, null, null, menuOpts);
+            } else if (menuOpts.type === "dropdown") {
+              gButton.attr(constants.menuIndexAttrName, "-1");
+              drawHeader(gd2, gHeader, gButton, scrollBox, menuOpts);
+              if (!isSilentUpdate) {
+                drawButtons(gd2, gHeader, gButton, scrollBox, menuOpts);
+              }
+            }
+          }
+          function drawHeader(gd2, gHeader, gButton, scrollBox, menuOpts) {
+            var header = Lib.ensureSingle(gHeader, "g", constants.headerClassName, function(s2) {
+              s2.style("pointer-events", "all");
+            });
+            var dims = menuOpts._dims;
+            var active = menuOpts.active;
+            var headerOpts = menuOpts.buttons[active] || constants.blankHeaderOpts;
+            var posOpts = { y: menuOpts.pad.t, yPad: 0, x: menuOpts.pad.l, xPad: 0, index: 0 };
+            var positionOverrides = {
+              width: dims.headerWidth,
+              height: dims.headerHeight
+            };
+            header.call(drawItem, menuOpts, headerOpts, gd2).call(setItemPosition, menuOpts, posOpts, positionOverrides);
+            var arrow = Lib.ensureSingle(gHeader, "text", constants.headerArrowClassName, function(s2) {
+              s2.attr("text-anchor", "end").call(Drawing.font, menuOpts.font).text(constants.arrowSymbol[menuOpts.direction]);
+            });
+            arrow.attr({
+              x: dims.headerWidth - constants.arrowOffsetX + menuOpts.pad.l,
+              y: dims.headerHeight / 2 + constants.textOffsetY + menuOpts.pad.t
+            });
+            header.on("click", function() {
+              gButton.call(
+                removeAllButtons,
+                String(isActive(gButton, menuOpts) ? -1 : menuOpts._index)
+              );
+              drawButtons(gd2, gHeader, gButton, scrollBox, menuOpts);
+            });
+            header.on("mouseover", function() {
+              header.call(styleOnMouseOver);
+            });
+            header.on("mouseout", function() {
+              header.call(styleOnMouseOut, menuOpts);
+            });
+            Drawing.setTranslate(gHeader, dims.lx, dims.ly);
+          }
+          function drawButtons(gd2, gHeader, gButton, scrollBox, menuOpts) {
+            if (!gButton) {
+              gButton = gHeader;
+              gButton.attr("pointer-events", "all");
+            }
+            var buttonData = !isFolded(gButton) || menuOpts.type === "buttons" ? menuOpts.buttons : [];
+            var klass = menuOpts.type === "dropdown" ? constants.dropdownButtonClassName : constants.buttonClassName;
+            var buttons = gButton.selectAll("g." + klass).data(Lib.filterVisible(buttonData));
+            var enter = buttons.enter().append("g").classed(klass, true);
+            var exit = buttons.exit();
+            if (menuOpts.type === "dropdown") {
+              enter.attr("opacity", "0").transition().attr("opacity", "1");
+              exit.transition().attr("opacity", "0").remove();
+            } else {
+              exit.remove();
+            }
+            var x0 = 0;
+            var y0 = 0;
+            var dims = menuOpts._dims;
+            var isVertical = ["up", "down"].indexOf(menuOpts.direction) !== -1;
+            if (menuOpts.type === "dropdown") {
+              if (isVertical) {
+                y0 = dims.headerHeight + constants.gapButtonHeader;
+              } else {
+                x0 = dims.headerWidth + constants.gapButtonHeader;
+              }
+            }
+            if (menuOpts.type === "dropdown" && menuOpts.direction === "up") {
+              y0 = -constants.gapButtonHeader + constants.gapButton - dims.openHeight;
+            }
+            if (menuOpts.type === "dropdown" && menuOpts.direction === "left") {
+              x0 = -constants.gapButtonHeader + constants.gapButton - dims.openWidth;
+            }
+            var posOpts = {
+              x: dims.lx + x0 + menuOpts.pad.l,
+              y: dims.ly + y0 + menuOpts.pad.t,
+              yPad: constants.gapButton,
+              xPad: constants.gapButton,
+              index: 0
+            };
+            var scrollBoxPosition = {
+              l: posOpts.x + menuOpts.borderwidth,
+              t: posOpts.y + menuOpts.borderwidth
+            };
+            buttons.each(function(buttonOpts, buttonIndex) {
+              var button = d3.select(this);
+              button.call(drawItem, menuOpts, buttonOpts, gd2).call(setItemPosition, menuOpts, posOpts);
+              button.on("click", function() {
+                if (d3.event.defaultPrevented) return;
+                if (buttonOpts.execute) {
+                  if (buttonOpts.args2 && menuOpts.active === buttonIndex) {
+                    setActive(gd2, menuOpts, buttonOpts, gHeader, gButton, scrollBox, -1);
+                    Plots.executeAPICommand(gd2, buttonOpts.method, buttonOpts.args2);
+                  } else {
+                    setActive(gd2, menuOpts, buttonOpts, gHeader, gButton, scrollBox, buttonIndex);
+                    Plots.executeAPICommand(gd2, buttonOpts.method, buttonOpts.args);
+                  }
+                }
+                gd2.emit("plotly_buttonclicked", { menu: menuOpts, button: buttonOpts, active: menuOpts.active });
+              });
+              button.on("mouseover", function() {
+                button.call(styleOnMouseOver);
+              });
+              button.on("mouseout", function() {
+                button.call(styleOnMouseOut, menuOpts);
+                buttons.call(styleButtons, menuOpts);
+              });
+            });
+            buttons.call(styleButtons, menuOpts);
+            if (isVertical) {
+              scrollBoxPosition.w = Math.max(dims.openWidth, dims.headerWidth);
+              scrollBoxPosition.h = posOpts.y - scrollBoxPosition.t;
+            } else {
+              scrollBoxPosition.w = posOpts.x - scrollBoxPosition.l;
+              scrollBoxPosition.h = Math.max(dims.openHeight, dims.headerHeight);
+            }
+            scrollBoxPosition.direction = menuOpts.direction;
+            if (scrollBox) {
+              if (buttons.size()) {
+                drawScrollBox(gd2, gHeader, gButton, scrollBox, menuOpts, scrollBoxPosition);
+              } else {
+                hideScrollBox(scrollBox);
+              }
+            }
+          }
+          function drawScrollBox(gd2, gHeader, gButton, scrollBox, menuOpts, position) {
+            var direction = menuOpts.direction;
+            var isVertical = direction === "up" || direction === "down";
+            var dims = menuOpts._dims;
+            var active = menuOpts.active;
+            var translateX, translateY;
+            var i2;
+            if (isVertical) {
+              translateY = 0;
+              for (i2 = 0; i2 < active; i2++) {
+                translateY += dims.heights[i2] + constants.gapButton;
+              }
+            } else {
+              translateX = 0;
+              for (i2 = 0; i2 < active; i2++) {
+                translateX += dims.widths[i2] + constants.gapButton;
+              }
+            }
+            scrollBox.enable(position, translateX, translateY);
+            if (scrollBox.hbar) {
+              scrollBox.hbar.attr("opacity", "0").transition().attr("opacity", "1");
+            }
+            if (scrollBox.vbar) {
+              scrollBox.vbar.attr("opacity", "0").transition().attr("opacity", "1");
+            }
+          }
+          function hideScrollBox(scrollBox) {
+            var hasHBar = !!scrollBox.hbar;
+            var hasVBar = !!scrollBox.vbar;
+            if (hasHBar) {
+              scrollBox.hbar.transition().attr("opacity", "0").each("end", function() {
+                hasHBar = false;
+                if (!hasVBar) scrollBox.disable();
+              });
+            }
+            if (hasVBar) {
+              scrollBox.vbar.transition().attr("opacity", "0").each("end", function() {
+                hasVBar = false;
+                if (!hasHBar) scrollBox.disable();
+              });
+            }
+          }
+          function drawItem(item, menuOpts, itemOpts, gd2) {
+            item.call(drawItemRect, menuOpts).call(drawItemText, menuOpts, itemOpts, gd2);
+          }
+          function drawItemRect(item, menuOpts) {
+            var rect = Lib.ensureSingle(item, "rect", constants.itemRectClassName, function(s2) {
+              s2.attr({
+                rx: constants.rx,
+                ry: constants.ry,
+                "shape-rendering": "crispEdges"
+              });
+            });
+            rect.call(Color2.stroke, menuOpts.bordercolor).call(Color2.fill, menuOpts.bgcolor).style("stroke-width", menuOpts.borderwidth + "px");
+          }
+          function drawItemText(item, menuOpts, itemOpts, gd2) {
+            var text = Lib.ensureSingle(item, "text", constants.itemTextClassName, function(s2) {
+              s2.attr({
+                "text-anchor": "start",
+                "data-notex": 1
+              });
+            });
+            var tx = itemOpts.label;
+            var _meta = gd2._fullLayout._meta;
+            if (_meta) tx = Lib.templateString(tx, _meta);
+            text.call(Drawing.font, menuOpts.font).text(tx).call(svgTextUtils.convertToTspans, gd2);
+          }
+          function styleButtons(buttons, menuOpts) {
+            var active = menuOpts.active;
+            buttons.each(function(buttonOpts, i2) {
+              var button = d3.select(this);
+              if (i2 === active && menuOpts.showactive) {
+                button.select("rect." + constants.itemRectClassName).call(Color2.fill, constants.activeColor);
+              }
+            });
+          }
+          function styleOnMouseOver(item) {
+            item.select("rect." + constants.itemRectClassName).call(Color2.fill, constants.hoverColor);
+          }
+          function styleOnMouseOut(item, menuOpts) {
+            item.select("rect." + constants.itemRectClassName).call(Color2.fill, menuOpts.bgcolor);
+          }
+          function findDimensions(gd2, menuOpts) {
+            var dims = menuOpts._dims = {
+              width1: 0,
+              height1: 0,
+              heights: [],
+              widths: [],
+              totalWidth: 0,
+              totalHeight: 0,
+              openWidth: 0,
+              openHeight: 0,
+              lx: 0,
+              ly: 0
+            };
+            var fakeButtons = Drawing.tester.selectAll("g." + constants.dropdownButtonClassName).data(Lib.filterVisible(menuOpts.buttons));
+            fakeButtons.enter().append("g").classed(constants.dropdownButtonClassName, true);
+            var isVertical = ["up", "down"].indexOf(menuOpts.direction) !== -1;
+            fakeButtons.each(function(buttonOpts, i2) {
+              var button = d3.select(this);
+              button.call(drawItem, menuOpts, buttonOpts, gd2);
+              var text = button.select("." + constants.itemTextClassName);
+              var tWidth = text.node() && Drawing.bBox(text.node()).width;
+              var wEff = Math.max(tWidth + constants.textPadX, constants.minWidth);
+              var tHeight = menuOpts.font.size * LINE_SPACING;
+              var tLines = svgTextUtils.lineCount(text);
+              var hEff = Math.max(tHeight * tLines, constants.minHeight) + constants.textOffsetY;
+              hEff = Math.ceil(hEff);
+              wEff = Math.ceil(wEff);
+              dims.widths[i2] = wEff;
+              dims.heights[i2] = hEff;
+              dims.height1 = Math.max(dims.height1, hEff);
+              dims.width1 = Math.max(dims.width1, wEff);
+              if (isVertical) {
+                dims.totalWidth = Math.max(dims.totalWidth, wEff);
+                dims.openWidth = dims.totalWidth;
+                dims.totalHeight += hEff + constants.gapButton;
+                dims.openHeight += hEff + constants.gapButton;
+              } else {
+                dims.totalWidth += wEff + constants.gapButton;
+                dims.openWidth += wEff + constants.gapButton;
+                dims.totalHeight = Math.max(dims.totalHeight, hEff);
+                dims.openHeight = dims.totalHeight;
+              }
+            });
+            if (isVertical) {
+              dims.totalHeight -= constants.gapButton;
+            } else {
+              dims.totalWidth -= constants.gapButton;
+            }
+            dims.headerWidth = dims.width1 + constants.arrowPadX;
+            dims.headerHeight = dims.height1;
+            if (menuOpts.type === "dropdown") {
+              if (isVertical) {
+                dims.width1 += constants.arrowPadX;
+                dims.totalHeight = dims.height1;
+              } else {
+                dims.totalWidth = dims.width1;
+              }
+              dims.totalWidth += constants.arrowPadX;
+            }
+            fakeButtons.remove();
+            var paddedWidth = dims.totalWidth + menuOpts.pad.l + menuOpts.pad.r;
+            var paddedHeight = dims.totalHeight + menuOpts.pad.t + menuOpts.pad.b;
+            var graphSize = gd2._fullLayout._size;
+            dims.lx = graphSize.l + graphSize.w * menuOpts.x;
+            dims.ly = graphSize.t + graphSize.h * (1 - menuOpts.y);
+            var xanchor = "left";
+            if (Lib.isRightAnchor(menuOpts)) {
+              dims.lx -= paddedWidth;
+              xanchor = "right";
+            }
+            if (Lib.isCenterAnchor(menuOpts)) {
+              dims.lx -= paddedWidth / 2;
+              xanchor = "center";
+            }
+            var yanchor = "top";
+            if (Lib.isBottomAnchor(menuOpts)) {
+              dims.ly -= paddedHeight;
+              yanchor = "bottom";
+            }
+            if (Lib.isMiddleAnchor(menuOpts)) {
+              dims.ly -= paddedHeight / 2;
+              yanchor = "middle";
+            }
+            dims.totalWidth = Math.ceil(dims.totalWidth);
+            dims.totalHeight = Math.ceil(dims.totalHeight);
+            dims.lx = Math.round(dims.lx);
+            dims.ly = Math.round(dims.ly);
+            Plots.autoMargin(gd2, autoMarginId(menuOpts), {
+              x: menuOpts.x,
+              y: menuOpts.y,
+              l: paddedWidth * ({ right: 1, center: 0.5 }[xanchor] || 0),
+              r: paddedWidth * ({ left: 1, center: 0.5 }[xanchor] || 0),
+              b: paddedHeight * ({ top: 1, middle: 0.5 }[yanchor] || 0),
+              t: paddedHeight * ({ bottom: 1, middle: 0.5 }[yanchor] || 0)
+            });
+          }
+          function autoMarginId(menuOpts) {
+            return constants.autoMarginIdRoot + menuOpts._index;
+          }
+          function setItemPosition(item, menuOpts, posOpts, overrideOpts) {
+            overrideOpts = overrideOpts || {};
+            var rect = item.select("." + constants.itemRectClassName);
+            var text = item.select("." + constants.itemTextClassName);
+            var borderWidth = menuOpts.borderwidth;
+            var index = posOpts.index;
+            var dims = menuOpts._dims;
+            Drawing.setTranslate(item, borderWidth + posOpts.x, borderWidth + posOpts.y);
+            var isVertical = ["up", "down"].indexOf(menuOpts.direction) !== -1;
+            var finalHeight = overrideOpts.height || (isVertical ? dims.heights[index] : dims.height1);
+            rect.attr({
+              x: 0,
+              y: 0,
+              width: overrideOpts.width || (isVertical ? dims.width1 : dims.widths[index]),
+              height: finalHeight
+            });
+            var tHeight = menuOpts.font.size * LINE_SPACING;
+            var tLines = svgTextUtils.lineCount(text);
+            var spanOffset = (tLines - 1) * tHeight / 2;
+            svgTextUtils.positionText(
+              text,
+              constants.textOffsetX,
+              finalHeight / 2 - spanOffset + constants.textOffsetY
+            );
+            if (isVertical) {
+              posOpts.y += dims.heights[index] + posOpts.yPad;
+            } else {
+              posOpts.x += dims.widths[index] + posOpts.xPad;
+            }
+            posOpts.index++;
+          }
+          function removeAllButtons(gButton, newMenuIndexAttr) {
+            gButton.attr(constants.menuIndexAttrName, newMenuIndexAttr || "-1").selectAll("g." + constants.dropdownButtonClassName).remove();
+          }
+        }
+      });
+      var require_updatemenus = __commonJS({
+        "src/components/updatemenus/index.js"(exports, module2) {
+          var constants = require_constants10();
+          module2.exports = {
+            moduleType: "component",
+            name: constants.name,
+            layoutAttributes: require_attributes18(),
+            supplyLayoutDefaults: require_defaults14(),
+            draw: require_draw7()
+          };
+        }
+      });
+      var require_constants11 = __commonJS({
+        "src/components/sliders/constants.js"(exports, module2) {
+          module2.exports = {
+            // layout attribute name
+            name: "sliders",
+            // class names
+            containerClassName: "slider-container",
+            groupClassName: "slider-group",
+            inputAreaClass: "slider-input-area",
+            railRectClass: "slider-rail-rect",
+            railTouchRectClass: "slider-rail-touch-rect",
+            gripRectClass: "slider-grip-rect",
+            tickRectClass: "slider-tick-rect",
+            inputProxyClass: "slider-input-proxy",
+            labelsClass: "slider-labels",
+            labelGroupClass: "slider-label-group",
+            labelClass: "slider-label",
+            currentValueClass: "slider-current-value",
+            railHeight: 5,
+            // DOM attribute name in button group keeping track
+            // of active update menu
+            menuIndexAttrName: "slider-active-index",
+            // id root pass to Plots.autoMargin
+            autoMarginIdRoot: "slider-",
+            // min item width / height
+            minWidth: 30,
+            minHeight: 30,
+            // padding around item text
+            textPadX: 40,
+            // arrow offset off right edge
+            arrowOffsetX: 4,
+            railRadius: 2,
+            railWidth: 5,
+            railBorder: 4,
+            railBorderWidth: 1,
+            railBorderColor: "#bec8d9",
+            railBgColor: "#f8fafc",
+            // The distance of the rail from the edge of the touchable area
+            // Slightly less than the step inset because of the curved edges
+            // of the rail
+            railInset: 8,
+            // The distance from the extremal tick marks to the edge of the
+            // touchable area. This is basically the same as the grip radius,
+            // but for other styles it wouldn't really need to be.
+            stepInset: 10,
+            gripRadius: 10,
+            gripWidth: 20,
+            gripHeight: 20,
+            gripBorder: 20,
+            gripBorderWidth: 1,
+            gripBorderColor: "#bec8d9",
+            gripBgColor: "#f6f8fa",
+            gripBgActiveColor: "#dbdde0",
+            labelPadding: 8,
+            labelOffset: 0,
+            tickWidth: 1,
+            tickColor: "#333",
+            tickOffset: 25,
+            tickLength: 7,
+            minorTickOffset: 25,
+            minorTickColor: "#333",
+            minorTickLength: 4,
+            // Extra space below the current value label:
+            currentValuePadding: 8,
+            currentValueInset: 0
+          };
+        }
+      });
+      var require_attributes19 = __commonJS({
+        "src/components/sliders/attributes.js"(exports, module2) {
+          var fontAttrs = require_font_attributes();
+          var padAttrs = require_pad_attributes();
+          var extendDeepAll = require_extend().extendDeepAll;
+          var overrideAll = require_edit_types().overrideAll;
+          var animationAttrs = require_animation_attributes();
+          var templatedArray = require_plot_template().templatedArray;
+          var constants = require_constants11();
+          var stepsAttrs = templatedArray("step", {
+            visible: {
+              valType: "boolean",
+              dflt: true
+            },
+            method: {
+              valType: "enumerated",
+              values: ["restyle", "relayout", "animate", "update", "skip"],
+              dflt: "restyle"
+            },
+            args: {
+              valType: "info_array",
+              freeLength: true,
+              items: [
+                { valType: "any" },
+                { valType: "any" },
+                { valType: "any" }
+              ]
+            },
+            label: {
+              valType: "string"
+            },
+            value: {
+              valType: "string"
+            },
+            execute: {
+              valType: "boolean",
+              dflt: true
+            }
+          });
+          module2.exports = overrideAll(templatedArray("slider", {
+            visible: {
+              valType: "boolean",
+              dflt: true
+            },
+            active: {
+              valType: "number",
+              min: 0,
+              dflt: 0
+            },
+            steps: stepsAttrs,
+            lenmode: {
+              valType: "enumerated",
+              values: ["fraction", "pixels"],
+              dflt: "fraction"
+            },
+            len: {
+              valType: "number",
+              min: 0,
+              dflt: 1
+            },
+            x: {
+              valType: "number",
+              min: -2,
+              max: 3,
+              dflt: 0
+            },
+            pad: extendDeepAll(padAttrs({ editType: "arraydraw" }), {}, { t: { dflt: 20 } }),
+            xanchor: {
+              valType: "enumerated",
+              values: ["auto", "left", "center", "right"],
+              dflt: "left"
+            },
+            y: {
+              valType: "number",
+              min: -2,
+              max: 3,
+              dflt: 0
+            },
+            yanchor: {
+              valType: "enumerated",
+              values: ["auto", "top", "middle", "bottom"],
+              dflt: "top"
+            },
+            transition: {
+              duration: {
+                valType: "number",
+                min: 0,
+                dflt: 150
+              },
+              easing: {
+                valType: "enumerated",
+                values: animationAttrs.transition.easing.values,
+                dflt: "cubic-in-out"
+              }
+            },
+            currentvalue: {
+              visible: {
+                valType: "boolean",
+                dflt: true
+              },
+              xanchor: {
+                valType: "enumerated",
+                values: ["left", "center", "right"],
+                dflt: "left"
+              },
+              offset: {
+                valType: "number",
+                dflt: 10
+              },
+              prefix: {
+                valType: "string"
+              },
+              suffix: {
+                valType: "string"
+              },
+              font: fontAttrs({})
+            },
+            font: fontAttrs({}),
+            activebgcolor: {
+              valType: "color",
+              dflt: constants.gripBgActiveColor
+            },
+            bgcolor: {
+              valType: "color",
+              dflt: constants.railBgColor
+            },
+            bordercolor: {
+              valType: "color",
+              dflt: constants.railBorderColor
+            },
+            borderwidth: {
+              valType: "number",
+              min: 0,
+              dflt: constants.railBorderWidth
+            },
+            ticklen: {
+              valType: "number",
+              min: 0,
+              dflt: constants.tickLength
+            },
+            tickcolor: {
+              valType: "color",
+              dflt: constants.tickColor
+            },
+            tickwidth: {
+              valType: "number",
+              min: 0,
+              dflt: 1
+            },
+            minorticklen: {
+              valType: "number",
+              min: 0,
+              dflt: constants.minorTickLength
+            }
+          }), "arraydraw", "from-root");
+        }
+      });
+      var require_defaults15 = __commonJS({
+        "src/components/sliders/defaults.js"(exports, module2) {
+          var Lib = require_lib();
+          var handleArrayContainerDefaults = require_array_container_defaults();
+          var attributes = require_attributes19();
+          var constants = require_constants11();
+          var name2 = constants.name;
+          var stepAttrs = attributes.steps;
+          module2.exports = function slidersDefaults(layoutIn, layoutOut) {
+            handleArrayContainerDefaults(layoutIn, layoutOut, {
+              name: name2,
+              handleItemDefaults: sliderDefaults
+            });
+          };
+          function sliderDefaults(sliderIn, sliderOut, layoutOut) {
+            function coerce(attr, dflt) {
+              return Lib.coerce(sliderIn, sliderOut, attributes, attr, dflt);
+            }
+            var steps = handleArrayContainerDefaults(sliderIn, sliderOut, {
+              name: "steps",
+              handleItemDefaults: stepDefaults
+            });
+            var stepCount = 0;
+            for (var i2 = 0; i2 < steps.length; i2++) {
+              if (steps[i2].visible) stepCount++;
+            }
+            var visible;
+            if (stepCount < 2) visible = sliderOut.visible = false;
+            else visible = coerce("visible");
+            if (!visible) return;
+            sliderOut._stepCount = stepCount;
+            var visSteps = sliderOut._visibleSteps = Lib.filterVisible(steps);
+            var active = coerce("active");
+            if (!(steps[active] || {}).visible) sliderOut.active = visSteps[0]._index;
+            coerce("x");
+            coerce("y");
+            Lib.noneOrAll(sliderIn, sliderOut, ["x", "y"]);
+            coerce("xanchor");
+            coerce("yanchor");
+            coerce("len");
+            coerce("lenmode");
+            coerce("pad.t");
+            coerce("pad.r");
+            coerce("pad.b");
+            coerce("pad.l");
+            Lib.coerceFont(coerce, "font", layoutOut.font);
+            var currentValueIsVisible = coerce("currentvalue.visible");
+            if (currentValueIsVisible) {
+              coerce("currentvalue.xanchor");
+              coerce("currentvalue.prefix");
+              coerce("currentvalue.suffix");
+              coerce("currentvalue.offset");
+              Lib.coerceFont(coerce, "currentvalue.font", sliderOut.font);
+            }
+            coerce("transition.duration");
+            coerce("transition.easing");
+            coerce("bgcolor");
+            coerce("activebgcolor");
+            coerce("bordercolor");
+            coerce("borderwidth");
+            coerce("ticklen");
+            coerce("tickwidth");
+            coerce("tickcolor");
+            coerce("minorticklen");
+          }
+          function stepDefaults(valueIn, valueOut) {
+            function coerce(attr, dflt) {
+              return Lib.coerce(valueIn, valueOut, stepAttrs, attr, dflt);
+            }
+            var visible;
+            if (valueIn.method !== "skip" && !Array.isArray(valueIn.args)) {
+              visible = valueOut.visible = false;
+            } else visible = coerce("visible");
+            if (visible) {
+              coerce("method");
+              coerce("args");
+              var label = coerce("label", "step-" + valueOut._index);
+              coerce("value", label);
+              coerce("execute");
+            }
+          }
+        }
+      });
+      var require_draw8 = __commonJS({
+        "src/components/sliders/draw.js"(exports, module2) {
+          var d3 = require_d3();
+          var Plots = require_plots();
+          var Color2 = require_color();
+          var Drawing = require_drawing();
+          var Lib = require_lib();
+          var strTranslate = Lib.strTranslate;
+          var svgTextUtils = require_svg_text_utils();
+          var arrayEditor = require_plot_template().arrayEditor;
+          var constants = require_constants11();
+          var alignmentConstants = require_alignment();
+          var LINE_SPACING = alignmentConstants.LINE_SPACING;
+          var FROM_TL = alignmentConstants.FROM_TL;
+          var FROM_BR = alignmentConstants.FROM_BR;
+          module2.exports = function draw(gd2) {
+            var staticPlot = gd2._context.staticPlot;
+            var fullLayout = gd2._fullLayout;
+            var sliderData = makeSliderData(fullLayout, gd2);
+            var sliders = fullLayout._infolayer.selectAll("g." + constants.containerClassName).data(sliderData.length > 0 ? [0] : []);
+            sliders.enter().append("g").classed(constants.containerClassName, true).style("cursor", staticPlot ? null : "ew-resize");
+            function clearSlider(sliderOpts2) {
+              if (sliderOpts2._commandObserver) {
+                sliderOpts2._commandObserver.remove();
+                delete sliderOpts2._commandObserver;
+              }
+              Plots.autoMargin(gd2, autoMarginId(sliderOpts2));
+            }
+            sliders.exit().each(function() {
+              d3.select(this).selectAll("g." + constants.groupClassName).each(clearSlider);
+            }).remove();
+            if (sliderData.length === 0) return;
+            var sliderGroups = sliders.selectAll("g." + constants.groupClassName).data(sliderData, keyFunction);
+            sliderGroups.enter().append("g").classed(constants.groupClassName, true);
+            sliderGroups.exit().each(clearSlider).remove();
+            for (var i2 = 0; i2 < sliderData.length; i2++) {
+              var sliderOpts = sliderData[i2];
+              findDimensions(gd2, sliderOpts);
+            }
+            sliderGroups.each(function(sliderOpts2) {
+              var gSlider = d3.select(this);
+              computeLabelSteps(sliderOpts2);
+              Plots.manageCommandObserver(gd2, sliderOpts2, sliderOpts2._visibleSteps, function(data) {
+                var opts = gSlider.data()[0];
+                if (opts.active === data.index) return;
+                if (opts._dragging) return;
+                setActive(gd2, gSlider, opts, data.index, false, true);
+              });
+              drawSlider(gd2, d3.select(this), sliderOpts2);
+            });
+          };
+          function autoMarginId(sliderOpts) {
+            return constants.autoMarginIdRoot + sliderOpts._index;
+          }
+          function makeSliderData(fullLayout, gd2) {
+            var contOpts = fullLayout[constants.name];
+            var sliderData = [];
+            for (var i2 = 0; i2 < contOpts.length; i2++) {
+              var item = contOpts[i2];
+              if (!item.visible) continue;
+              item._gd = gd2;
+              sliderData.push(item);
+            }
+            return sliderData;
+          }
+          function keyFunction(opts) {
+            return opts._index;
+          }
+          function findDimensions(gd2, sliderOpts) {
+            var sliderLabels = Drawing.tester.selectAll("g." + constants.labelGroupClass).data(sliderOpts._visibleSteps);
+            sliderLabels.enter().append("g").classed(constants.labelGroupClass, true);
+            var maxLabelWidth = 0;
+            var labelHeight = 0;
+            sliderLabels.each(function(stepOpts) {
+              var labelGroup = d3.select(this);
+              var text = drawLabel(labelGroup, { step: stepOpts }, sliderOpts);
+              var textNode = text.node();
+              if (textNode) {
+                var bBox = Drawing.bBox(textNode);
+                labelHeight = Math.max(labelHeight, bBox.height);
+                maxLabelWidth = Math.max(maxLabelWidth, bBox.width);
+              }
+            });
+            sliderLabels.remove();
+            var dims = sliderOpts._dims = {};
+            dims.inputAreaWidth = Math.max(
+              constants.railWidth,
+              constants.gripHeight
+            );
+            var graphSize = gd2._fullLayout._size;
+            dims.lx = graphSize.l + graphSize.w * sliderOpts.x;
+            dims.ly = graphSize.t + graphSize.h * (1 - sliderOpts.y);
+            if (sliderOpts.lenmode === "fraction") {
+              dims.outerLength = Math.round(graphSize.w * sliderOpts.len);
+            } else {
+              dims.outerLength = sliderOpts.len;
+            }
+            dims.inputAreaStart = 0;
+            dims.inputAreaLength = Math.round(dims.outerLength - sliderOpts.pad.l - sliderOpts.pad.r);
+            var textableInputLength = dims.inputAreaLength - 2 * constants.stepInset;
+            var availableSpacePerLabel = textableInputLength / (sliderOpts._stepCount - 1);
+            var computedSpacePerLabel = maxLabelWidth + constants.labelPadding;
+            dims.labelStride = Math.max(1, Math.ceil(computedSpacePerLabel / availableSpacePerLabel));
+            dims.labelHeight = labelHeight;
+            dims.currentValueMaxWidth = 0;
+            dims.currentValueHeight = 0;
+            dims.currentValueTotalHeight = 0;
+            dims.currentValueMaxLines = 1;
+            if (sliderOpts.currentvalue.visible) {
+              var dummyGroup = Drawing.tester.append("g");
+              sliderLabels.each(function(stepOpts) {
+                var curValPrefix = drawCurrentValue(dummyGroup, sliderOpts, stepOpts.label);
+                var curValSize = curValPrefix.node() && Drawing.bBox(curValPrefix.node()) || { width: 0, height: 0 };
+                var lines = svgTextUtils.lineCount(curValPrefix);
+                dims.currentValueMaxWidth = Math.max(dims.currentValueMaxWidth, Math.ceil(curValSize.width));
+                dims.currentValueHeight = Math.max(dims.currentValueHeight, Math.ceil(curValSize.height));
+                dims.currentValueMaxLines = Math.max(dims.currentValueMaxLines, lines);
+              });
+              dims.currentValueTotalHeight = dims.currentValueHeight + sliderOpts.currentvalue.offset;
+              dummyGroup.remove();
+            }
+            dims.height = dims.currentValueTotalHeight + constants.tickOffset + sliderOpts.ticklen + constants.labelOffset + dims.labelHeight + sliderOpts.pad.t + sliderOpts.pad.b;
+            var xanchor = "left";
+            if (Lib.isRightAnchor(sliderOpts)) {
+              dims.lx -= dims.outerLength;
+              xanchor = "right";
+            }
+            if (Lib.isCenterAnchor(sliderOpts)) {
+              dims.lx -= dims.outerLength / 2;
+              xanchor = "center";
+            }
+            var yanchor = "top";
+            if (Lib.isBottomAnchor(sliderOpts)) {
+              dims.ly -= dims.height;
+              yanchor = "bottom";
+            }
+            if (Lib.isMiddleAnchor(sliderOpts)) {
+              dims.ly -= dims.height / 2;
+              yanchor = "middle";
+            }
+            dims.outerLength = Math.ceil(dims.outerLength);
+            dims.height = Math.ceil(dims.height);
+            dims.lx = Math.round(dims.lx);
+            dims.ly = Math.round(dims.ly);
+            var marginOpts = {
+              y: sliderOpts.y,
+              b: dims.height * FROM_BR[yanchor],
+              t: dims.height * FROM_TL[yanchor]
+            };
+            if (sliderOpts.lenmode === "fraction") {
+              marginOpts.l = 0;
+              marginOpts.xl = sliderOpts.x - sliderOpts.len * FROM_TL[xanchor];
+              marginOpts.r = 0;
+              marginOpts.xr = sliderOpts.x + sliderOpts.len * FROM_BR[xanchor];
+            } else {
+              marginOpts.x = sliderOpts.x;
+              marginOpts.l = dims.outerLength * FROM_TL[xanchor];
+              marginOpts.r = dims.outerLength * FROM_BR[xanchor];
+            }
+            Plots.autoMargin(gd2, autoMarginId(sliderOpts), marginOpts);
+          }
+          function drawSlider(gd2, sliderGroup, sliderOpts) {
+            if (!(sliderOpts.steps[sliderOpts.active] || {}).visible) {
+              sliderOpts.active = sliderOpts._visibleSteps[0]._index;
+            }
+            sliderGroup.call(drawCurrentValue, sliderOpts).call(drawRail, sliderOpts).call(drawLabelGroup, sliderOpts).call(drawTicks, sliderOpts).call(drawTouchRect, gd2, sliderOpts).call(drawGrip, gd2, sliderOpts);
+            var dims = sliderOpts._dims;
+            Drawing.setTranslate(sliderGroup, dims.lx + sliderOpts.pad.l, dims.ly + sliderOpts.pad.t);
+            sliderGroup.call(setGripPosition, sliderOpts, false);
+            sliderGroup.call(drawCurrentValue, sliderOpts);
+          }
+          function drawCurrentValue(sliderGroup, sliderOpts, valueOverride) {
+            if (!sliderOpts.currentvalue.visible) return;
+            var dims = sliderOpts._dims;
+            var x0, textAnchor;
+            switch (sliderOpts.currentvalue.xanchor) {
+              case "right":
+                x0 = dims.inputAreaLength - constants.currentValueInset - dims.currentValueMaxWidth;
+                textAnchor = "left";
+                break;
+              case "center":
+                x0 = dims.inputAreaLength * 0.5;
+                textAnchor = "middle";
+                break;
+              default:
+                x0 = constants.currentValueInset;
+                textAnchor = "left";
+            }
+            var text = Lib.ensureSingle(sliderGroup, "text", constants.labelClass, function(s2) {
+              s2.attr({
+                "text-anchor": textAnchor,
+                "data-notex": 1
+              });
+            });
+            var str = sliderOpts.currentvalue.prefix ? sliderOpts.currentvalue.prefix : "";
+            if (typeof valueOverride === "string") {
+              str += valueOverride;
+            } else {
+              var curVal = sliderOpts.steps[sliderOpts.active].label;
+              var _meta = sliderOpts._gd._fullLayout._meta;
+              if (_meta) curVal = Lib.templateString(curVal, _meta);
+              str += curVal;
+            }
+            if (sliderOpts.currentvalue.suffix) {
+              str += sliderOpts.currentvalue.suffix;
+            }
+            text.call(Drawing.font, sliderOpts.currentvalue.font).text(str).call(svgTextUtils.convertToTspans, sliderOpts._gd);
+            var lines = svgTextUtils.lineCount(text);
+            var y0 = (dims.currentValueMaxLines + 1 - lines) * sliderOpts.currentvalue.font.size * LINE_SPACING;
+            svgTextUtils.positionText(text, x0, y0);
+            return text;
+          }
+          function drawGrip(sliderGroup, gd2, sliderOpts) {
+            var grip = Lib.ensureSingle(sliderGroup, "rect", constants.gripRectClass, function(s2) {
+              s2.call(attachGripEvents, gd2, sliderGroup, sliderOpts).style("pointer-events", "all");
+            });
+            grip.attr({
+              width: constants.gripWidth,
+              height: constants.gripHeight,
+              rx: constants.gripRadius,
+              ry: constants.gripRadius
+            }).call(Color2.stroke, sliderOpts.bordercolor).call(Color2.fill, sliderOpts.bgcolor).style("stroke-width", sliderOpts.borderwidth + "px");
+          }
+          function drawLabel(item, data, sliderOpts) {
+            var text = Lib.ensureSingle(item, "text", constants.labelClass, function(s2) {
+              s2.attr({
+                "text-anchor": "middle",
+                "data-notex": 1
+              });
+            });
+            var tx = data.step.label;
+            var _meta = sliderOpts._gd._fullLayout._meta;
+            if (_meta) tx = Lib.templateString(tx, _meta);
+            text.call(Drawing.font, sliderOpts.font).text(tx).call(svgTextUtils.convertToTspans, sliderOpts._gd);
+            return text;
+          }
+          function drawLabelGroup(sliderGroup, sliderOpts) {
+            var labels = Lib.ensureSingle(sliderGroup, "g", constants.labelsClass);
+            var dims = sliderOpts._dims;
+            var labelItems = labels.selectAll("g." + constants.labelGroupClass).data(dims.labelSteps);
+            labelItems.enter().append("g").classed(constants.labelGroupClass, true);
+            labelItems.exit().remove();
+            labelItems.each(function(d2) {
+              var item = d3.select(this);
+              item.call(drawLabel, d2, sliderOpts);
+              Drawing.setTranslate(
+                item,
+                normalizedValueToPosition(sliderOpts, d2.fraction),
+                constants.tickOffset + sliderOpts.ticklen + // position is the baseline of the top line of text only, even
+                // if the label spans multiple lines
+                sliderOpts.font.size * LINE_SPACING + constants.labelOffset + dims.currentValueTotalHeight
+              );
+            });
+          }
+          function handleInput(gd2, sliderGroup, sliderOpts, normalizedPosition, doTransition) {
+            var quantizedPosition = Math.round(normalizedPosition * (sliderOpts._stepCount - 1));
+            var quantizedIndex = sliderOpts._visibleSteps[quantizedPosition]._index;
+            if (quantizedIndex !== sliderOpts.active) {
+              setActive(gd2, sliderGroup, sliderOpts, quantizedIndex, true, doTransition);
+            }
+          }
+          function setActive(gd2, sliderGroup, sliderOpts, index, doCallback, doTransition) {
+            var previousActive = sliderOpts.active;
+            sliderOpts.active = index;
+            arrayEditor(gd2.layout, constants.name, sliderOpts).applyUpdate("active", index);
+            var step = sliderOpts.steps[sliderOpts.active];
+            sliderGroup.call(setGripPosition, sliderOpts, doTransition);
+            sliderGroup.call(drawCurrentValue, sliderOpts);
+            gd2.emit("plotly_sliderchange", {
+              slider: sliderOpts,
+              step: sliderOpts.steps[sliderOpts.active],
+              interaction: doCallback,
+              previousActive
+            });
+            if (step && step.method && doCallback) {
+              if (sliderGroup._nextMethod) {
+                sliderGroup._nextMethod.step = step;
+                sliderGroup._nextMethod.doCallback = doCallback;
+                sliderGroup._nextMethod.doTransition = doTransition;
+              } else {
+                sliderGroup._nextMethod = { step, doCallback, doTransition };
+                sliderGroup._nextMethodRaf = window.requestAnimationFrame(function() {
+                  var _step = sliderGroup._nextMethod.step;
+                  if (!_step.method) return;
+                  if (_step.execute) {
+                    Plots.executeAPICommand(gd2, _step.method, _step.args);
+                  }
+                  sliderGroup._nextMethod = null;
+                  sliderGroup._nextMethodRaf = null;
+                });
+              }
+            }
+          }
+          function attachGripEvents(item, gd2, sliderGroup) {
+            if (gd2._context.staticPlot) return;
+            var node = sliderGroup.node();
+            var $gd = d3.select(gd2);
+            function getSliderOpts() {
+              return sliderGroup.data()[0];
+            }
+            function mouseDownHandler() {
+              var sliderOpts = getSliderOpts();
+              gd2.emit("plotly_sliderstart", { slider: sliderOpts });
+              var grip = sliderGroup.select("." + constants.gripRectClass);
+              d3.event.stopPropagation();
+              d3.event.preventDefault();
+              grip.call(Color2.fill, sliderOpts.activebgcolor);
+              var normalizedPosition = positionToNormalizedValue(sliderOpts, d3.mouse(node)[0]);
+              handleInput(gd2, sliderGroup, sliderOpts, normalizedPosition, true);
+              sliderOpts._dragging = true;
+              function mouseMoveHandler() {
+                var sliderOpts2 = getSliderOpts();
+                var normalizedPosition2 = positionToNormalizedValue(sliderOpts2, d3.mouse(node)[0]);
+                handleInput(gd2, sliderGroup, sliderOpts2, normalizedPosition2, false);
+              }
+              $gd.on("mousemove", mouseMoveHandler);
+              $gd.on("touchmove", mouseMoveHandler);
+              function mouseUpHandler() {
+                var sliderOpts2 = getSliderOpts();
+                sliderOpts2._dragging = false;
+                grip.call(Color2.fill, sliderOpts2.bgcolor);
+                $gd.on("mouseup", null);
+                $gd.on("mousemove", null);
+                $gd.on("touchend", null);
+                $gd.on("touchmove", null);
+                gd2.emit("plotly_sliderend", {
+                  slider: sliderOpts2,
+                  step: sliderOpts2.steps[sliderOpts2.active]
+                });
+              }
+              $gd.on("mouseup", mouseUpHandler);
+              $gd.on("touchend", mouseUpHandler);
+            }
+            item.on("mousedown", mouseDownHandler);
+            item.on("touchstart", mouseDownHandler);
+          }
+          function drawTicks(sliderGroup, sliderOpts) {
+            var tick = sliderGroup.selectAll("rect." + constants.tickRectClass).data(sliderOpts._visibleSteps);
+            var dims = sliderOpts._dims;
+            tick.enter().append("rect").classed(constants.tickRectClass, true);
+            tick.exit().remove();
+            tick.attr({
+              width: sliderOpts.tickwidth + "px",
+              "shape-rendering": "crispEdges"
+            });
+            tick.each(function(d2, i2) {
+              var isMajor = i2 % dims.labelStride === 0;
+              var item = d3.select(this);
+              item.attr({ height: isMajor ? sliderOpts.ticklen : sliderOpts.minorticklen }).call(Color2.fill, isMajor ? sliderOpts.tickcolor : sliderOpts.tickcolor);
+              Drawing.setTranslate(
+                item,
+                normalizedValueToPosition(sliderOpts, i2 / (sliderOpts._stepCount - 1)) - 0.5 * sliderOpts.tickwidth,
+                (isMajor ? constants.tickOffset : constants.minorTickOffset) + dims.currentValueTotalHeight
+              );
+            });
+          }
+          function computeLabelSteps(sliderOpts) {
+            var dims = sliderOpts._dims;
+            dims.labelSteps = [];
+            var nsteps = sliderOpts._stepCount;
+            for (var i2 = 0; i2 < nsteps; i2 += dims.labelStride) {
+              dims.labelSteps.push({
+                fraction: i2 / (nsteps - 1),
+                step: sliderOpts._visibleSteps[i2]
+              });
+            }
+          }
+          function setGripPosition(sliderGroup, sliderOpts, doTransition) {
+            var grip = sliderGroup.select("rect." + constants.gripRectClass);
+            var quantizedIndex = 0;
+            for (var i2 = 0; i2 < sliderOpts._stepCount; i2++) {
+              if (sliderOpts._visibleSteps[i2]._index === sliderOpts.active) {
+                quantizedIndex = i2;
+                break;
+              }
+            }
+            var x2 = normalizedValueToPosition(sliderOpts, quantizedIndex / (sliderOpts._stepCount - 1));
+            if (sliderOpts._invokingCommand) return;
+            var el2 = grip;
+            if (doTransition && sliderOpts.transition.duration > 0) {
+              el2 = el2.transition().duration(sliderOpts.transition.duration).ease(sliderOpts.transition.easing);
+            }
+            el2.attr("transform", strTranslate(x2 - constants.gripWidth * 0.5, sliderOpts._dims.currentValueTotalHeight));
+          }
+          function normalizedValueToPosition(sliderOpts, normalizedPosition) {
+            var dims = sliderOpts._dims;
+            return dims.inputAreaStart + constants.stepInset + (dims.inputAreaLength - 2 * constants.stepInset) * Math.min(1, Math.max(0, normalizedPosition));
+          }
+          function positionToNormalizedValue(sliderOpts, position) {
+            var dims = sliderOpts._dims;
+            return Math.min(1, Math.max(0, (position - constants.stepInset - dims.inputAreaStart) / (dims.inputAreaLength - 2 * constants.stepInset - 2 * dims.inputAreaStart)));
+          }
+          function drawTouchRect(sliderGroup, gd2, sliderOpts) {
+            var dims = sliderOpts._dims;
+            var rect = Lib.ensureSingle(sliderGroup, "rect", constants.railTouchRectClass, function(s2) {
+              s2.call(attachGripEvents, gd2, sliderGroup, sliderOpts).style("pointer-events", "all");
+            });
+            rect.attr({
+              width: dims.inputAreaLength,
+              height: Math.max(dims.inputAreaWidth, constants.tickOffset + sliderOpts.ticklen + dims.labelHeight)
+            }).call(Color2.fill, sliderOpts.bgcolor).attr("opacity", 0);
+            Drawing.setTranslate(rect, 0, dims.currentValueTotalHeight);
+          }
+          function drawRail(sliderGroup, sliderOpts) {
+            var dims = sliderOpts._dims;
+            var computedLength = dims.inputAreaLength - constants.railInset * 2;
+            var rect = Lib.ensureSingle(sliderGroup, "rect", constants.railRectClass);
+            rect.attr({
+              width: computedLength,
+              height: constants.railWidth,
+              rx: constants.railRadius,
+              ry: constants.railRadius,
+              "shape-rendering": "crispEdges"
+            }).call(Color2.stroke, sliderOpts.bordercolor).call(Color2.fill, sliderOpts.bgcolor).style("stroke-width", sliderOpts.borderwidth + "px");
+            Drawing.setTranslate(
+              rect,
+              constants.railInset,
+              (dims.inputAreaWidth - constants.railWidth) * 0.5 + dims.currentValueTotalHeight
+            );
+          }
+        }
+      });
+      var require_sliders = __commonJS({
+        "src/components/sliders/index.js"(exports, module2) {
+          var constants = require_constants11();
+          module2.exports = {
+            moduleType: "component",
+            name: constants.name,
+            layoutAttributes: require_attributes19(),
+            supplyLayoutDefaults: require_defaults15(),
+            draw: require_draw8()
+          };
+        }
+      });
+      var require_attributes20 = __commonJS({
+        "src/components/rangeslider/attributes.js"(exports, module2) {
+          var colorAttributes = require_attributes3();
+          module2.exports = {
+            bgcolor: {
+              valType: "color",
+              dflt: colorAttributes.background,
+              editType: "plot"
+            },
+            bordercolor: {
+              valType: "color",
+              dflt: colorAttributes.defaultLine,
+              editType: "plot"
+            },
+            borderwidth: {
+              valType: "integer",
+              dflt: 0,
+              min: 0,
+              editType: "plot"
+            },
+            autorange: {
+              valType: "boolean",
+              dflt: true,
+              editType: "calc",
+              impliedEdits: { "range[0]": void 0, "range[1]": void 0 }
+            },
+            range: {
+              valType: "info_array",
+              items: [
+                { valType: "any", editType: "calc", impliedEdits: { "^autorange": false } },
+                { valType: "any", editType: "calc", impliedEdits: { "^autorange": false } }
+              ],
+              editType: "calc",
+              impliedEdits: { autorange: false }
+            },
+            thickness: {
+              valType: "number",
+              dflt: 0.15,
+              min: 0,
+              max: 1,
+              editType: "plot"
+            },
+            visible: {
+              valType: "boolean",
+              dflt: true,
+              editType: "calc"
+            },
+            editType: "calc"
+          };
+        }
+      });
+      var require_oppaxis_attributes = __commonJS({
+        "src/components/rangeslider/oppaxis_attributes.js"(exports, module2) {
+          module2.exports = {
+            // not really a 'subplot' attribute container,
+            // but this is the flag we use to denote attributes that
+            // support yaxis, yaxis2, yaxis3, ... counters
+            _isSubplotObj: true,
+            rangemode: {
+              valType: "enumerated",
+              values: ["auto", "fixed", "match"],
+              dflt: "match",
+              editType: "calc"
+            },
+            range: {
+              valType: "info_array",
+              items: [
+                { valType: "any", editType: "plot" },
+                { valType: "any", editType: "plot" }
+              ],
+              editType: "plot"
+            },
+            editType: "calc"
+          };
+        }
+      });
+      var require_constants12 = __commonJS({
+        "src/components/rangeslider/constants.js"(exports, module2) {
+          module2.exports = {
+            // attribute container name
+            name: "rangeslider",
+            // class names
+            containerClassName: "rangeslider-container",
+            bgClassName: "rangeslider-bg",
+            rangePlotClassName: "rangeslider-rangeplot",
+            maskMinClassName: "rangeslider-mask-min",
+            maskMaxClassName: "rangeslider-mask-max",
+            slideBoxClassName: "rangeslider-slidebox",
+            grabberMinClassName: "rangeslider-grabber-min",
+            grabAreaMinClassName: "rangeslider-grabarea-min",
+            handleMinClassName: "rangeslider-handle-min",
+            grabberMaxClassName: "rangeslider-grabber-max",
+            grabAreaMaxClassName: "rangeslider-grabarea-max",
+            handleMaxClassName: "rangeslider-handle-max",
+            maskMinOppAxisClassName: "rangeslider-mask-min-opp-axis",
+            maskMaxOppAxisClassName: "rangeslider-mask-max-opp-axis",
+            // style constants
+            maskColor: "rgba(0,0,0,0.4)",
+            maskOppAxisColor: "rgba(0,0,0,0.2)",
+            slideBoxFill: "transparent",
+            slideBoxCursor: "ew-resize",
+            grabAreaFill: "transparent",
+            grabAreaCursor: "col-resize",
+            grabAreaWidth: 10,
+            handleWidth: 4,
+            handleRadius: 1,
+            handleStrokeWidth: 1,
+            extraPad: 15
+          };
+        }
+      });
+      var require_helpers11 = __commonJS({
+        "src/components/rangeslider/helpers.js"(exports) {
+          var axisIDs = require_axis_ids();
+          var svgTextUtils = require_svg_text_utils();
+          var constants = require_constants12();
+          var LINE_SPACING = require_alignment().LINE_SPACING;
+          var name2 = constants.name;
+          function isVisible(ax) {
+            var rangeSlider = ax && ax[name2];
+            return rangeSlider && rangeSlider.visible;
+          }
+          exports.isVisible = isVisible;
+          exports.makeData = function(fullLayout) {
+            var axes = axisIDs.list({ _fullLayout: fullLayout }, "x", true);
+            var margin = fullLayout.margin;
+            var rangeSliderData = [];
+            for (var i2 = 0; i2 < axes.length; i2++) {
+              var ax = axes[i2];
+              if (isVisible(ax)) {
+                rangeSliderData.push(ax);
+                var opts = ax[name2];
+                opts._id = name2 + ax._id;
+                opts._height = (fullLayout.height - margin.b - margin.t) * opts.thickness;
+                opts._offsetShift = Math.floor(opts.borderwidth / 2);
+              }
+            }
+            fullLayout._rangeSliderData = rangeSliderData;
+          };
+          exports.autoMarginOpts = function(gd2, ax) {
+            var fullLayout = gd2._fullLayout;
+            var opts = ax[name2];
+            var axLetter = ax._id.charAt(0);
+            var bottomDepth = 0;
+            var titleHeight = 0;
+            if (ax.side === "bottom") {
+              bottomDepth = ax._depth;
+              if (ax.title.text !== fullLayout._dfltTitle[axLetter]) {
+                titleHeight = 1.5 * ax.title.font.size + 10 + opts._offsetShift;
+                var extraLines = (ax.title.text.match(svgTextUtils.BR_TAG_ALL) || []).length;
+                titleHeight += extraLines * ax.title.font.size * LINE_SPACING;
+              }
+            }
+            return {
+              x: 0,
+              y: ax._counterDomainMin,
+              l: 0,
+              r: 0,
+              t: 0,
+              b: opts._height + bottomDepth + Math.max(fullLayout.margin.b, titleHeight),
+              pad: constants.extraPad + opts._offsetShift * 2
+            };
+          };
+        }
+      });
+      var require_defaults16 = __commonJS({
+        "src/components/rangeslider/defaults.js"(exports, module2) {
+          var Lib = require_lib();
+          var Template = require_plot_template();
+          var axisIds = require_axis_ids();
+          var attributes = require_attributes20();
+          var oppAxisAttrs = require_oppaxis_attributes();
+          module2.exports = function handleDefaults(layoutIn, layoutOut, axName) {
+            var axIn = layoutIn[axName];
+            var axOut = layoutOut[axName];
+            if (!(axIn.rangeslider || layoutOut._requestRangeslider[axOut._id])) return;
+            if (!Lib.isPlainObject(axIn.rangeslider)) {
+              axIn.rangeslider = {};
+            }
+            var containerIn = axIn.rangeslider;
+            var containerOut = Template.newContainer(axOut, "rangeslider");
+            function coerce(attr, dflt) {
+              return Lib.coerce(containerIn, containerOut, attributes, attr, dflt);
+            }
+            var rangeContainerIn, rangeContainerOut;
+            function coerceRange(attr, dflt) {
+              return Lib.coerce(rangeContainerIn, rangeContainerOut, oppAxisAttrs, attr, dflt);
+            }
+            var visible = coerce("visible");
+            if (!visible) return;
+            coerce("bgcolor", layoutOut.plot_bgcolor);
+            coerce("bordercolor");
+            coerce("borderwidth");
+            coerce("thickness");
+            coerce("autorange", !axOut.isValidRange(containerIn.range));
+            coerce("range");
+            var subplots = layoutOut._subplots;
+            if (subplots) {
+              var yIds = subplots.cartesian.filter(function(subplotId) {
+                return subplotId.slice(0, Math.max(0, subplotId.indexOf("y"))) === axisIds.name2id(axName);
+              }).map(function(subplotId) {
+                return subplotId.slice(subplotId.indexOf("y"), subplotId.length);
+              });
+              var yNames = Lib.simpleMap(yIds, axisIds.id2name);
+              for (var i2 = 0; i2 < yNames.length; i2++) {
+                var yName = yNames[i2];
+                rangeContainerIn = containerIn[yName] || {};
+                rangeContainerOut = Template.newContainer(containerOut, yName, "yaxis");
+                var yAxOut = layoutOut[yName];
+                var rangemodeDflt;
+                if (rangeContainerIn.range && yAxOut.isValidRange(rangeContainerIn.range)) {
+                  rangemodeDflt = "fixed";
+                }
+                var rangeMode = coerceRange("rangemode", rangemodeDflt);
+                if (rangeMode !== "match") {
+                  coerceRange("range", yAxOut.range.slice());
+                }
+              }
+            }
+            containerOut._input = containerIn;
+          };
+        }
+      });
+      var require_calc_autorange3 = __commonJS({
+        "src/components/rangeslider/calc_autorange.js"(exports, module2) {
+          var listAxes = require_axis_ids().list;
+          var getAutoRange = require_autorange().getAutoRange;
+          var constants = require_constants12();
+          module2.exports = function calcAutorange(gd2) {
+            var axes = listAxes(gd2, "x", true);
+            for (var i2 = 0; i2 < axes.length; i2++) {
+              var ax = axes[i2];
+              var opts = ax[constants.name];
+              if (opts && opts.visible && opts.autorange) {
+                opts._input.autorange = true;
+                opts._input.range = opts.range = getAutoRange(gd2, ax);
+              }
+            }
+          };
+        }
+      });
+      var require_draw9 = __commonJS({
+        "src/components/rangeslider/draw.js"(exports, module2) {
+          var d3 = require_d3();
+          var Registry = require_registry();
+          var Plots = require_plots();
+          var Lib = require_lib();
+          var strTranslate = Lib.strTranslate;
+          var Drawing = require_drawing();
+          var Color2 = require_color();
+          var Titles = require_titles();
+          var Cartesian = require_cartesian();
+          var axisIDs = require_axis_ids();
+          var dragElement = require_dragelement();
+          var setCursor = require_setcursor();
+          var constants = require_constants12();
+          module2.exports = function(gd2) {
+            var fullLayout = gd2._fullLayout;
+            var rangeSliderData = fullLayout._rangeSliderData;
+            for (var i2 = 0; i2 < rangeSliderData.length; i2++) {
+              var opts = rangeSliderData[i2][constants.name];
+              opts._clipId = opts._id + "-" + fullLayout._uid;
+            }
+            function keyFunction(axisOpts) {
+              return axisOpts._name;
+            }
+            var rangeSliders = fullLayout._infolayer.selectAll("g." + constants.containerClassName).data(rangeSliderData, keyFunction);
+            rangeSliders.exit().each(function(axisOpts) {
+              var opts2 = axisOpts[constants.name];
+              fullLayout._topdefs.select("#" + opts2._clipId).remove();
+            }).remove();
+            if (rangeSliderData.length === 0) return;
+            rangeSliders.enter().append("g").classed(constants.containerClassName, true).attr("pointer-events", "all");
+            rangeSliders.each(function(axisOpts) {
+              var rangeSlider = d3.select(this);
+              var opts2 = axisOpts[constants.name];
+              var oppAxisOpts = fullLayout[axisIDs.id2name(axisOpts.anchor)];
+              var oppAxisRangeOpts = opts2[axisIDs.id2name(axisOpts.anchor)];
+              if (opts2.range) {
+                var rng = Lib.simpleMap(opts2.range, axisOpts.r2l);
+                var axRng = Lib.simpleMap(axisOpts.range, axisOpts.r2l);
+                var newRng;
+                if (axRng[0] < axRng[1]) {
+                  newRng = [
+                    Math.min(rng[0], axRng[0]),
+                    Math.max(rng[1], axRng[1])
+                  ];
+                } else {
+                  newRng = [
+                    Math.max(rng[0], axRng[0]),
+                    Math.min(rng[1], axRng[1])
+                  ];
+                }
+                opts2.range = opts2._input.range = Lib.simpleMap(newRng, axisOpts.l2r);
+              }
+              axisOpts.cleanRange("rangeslider.range");
+              var gs = fullLayout._size;
+              var domain = axisOpts.domain;
+              opts2._width = gs.w * (domain[1] - domain[0]);
+              var x2 = Math.round(gs.l + gs.w * domain[0]);
+              var y2 = Math.round(
+                gs.t + gs.h * (1 - axisOpts._counterDomainMin) + (axisOpts.side === "bottom" ? axisOpts._depth : 0) + opts2._offsetShift + constants.extraPad
+              );
+              rangeSlider.attr("transform", strTranslate(x2, y2));
+              opts2._rl = Lib.simpleMap(opts2.range, axisOpts.r2l);
+              var rl0 = opts2._rl[0];
+              var rl1 = opts2._rl[1];
+              var drl = rl1 - rl0;
+              opts2.p2d = function(v2) {
+                return v2 / opts2._width * drl + rl0;
+              };
+              opts2.d2p = function(v2) {
+                return (v2 - rl0) / drl * opts2._width;
+              };
+              if (axisOpts.rangebreaks) {
+                var rsBreaks = axisOpts.locateBreaks(rl0, rl1);
+                if (rsBreaks.length) {
+                  var j2, brk;
+                  var lBreaks = 0;
+                  for (j2 = 0; j2 < rsBreaks.length; j2++) {
+                    brk = rsBreaks[j2];
+                    lBreaks += brk.max - brk.min;
+                  }
+                  var m2 = opts2._width / (rl1 - rl0 - lBreaks);
+                  var _B = [-m2 * rl0];
+                  for (j2 = 0; j2 < rsBreaks.length; j2++) {
+                    brk = rsBreaks[j2];
+                    _B.push(_B[_B.length - 1] - m2 * (brk.max - brk.min));
+                  }
+                  opts2.d2p = function(v2) {
+                    var b2 = _B[0];
+                    for (var j22 = 0; j22 < rsBreaks.length; j22++) {
+                      var brk2 = rsBreaks[j22];
+                      if (v2 >= brk2.max) b2 = _B[j22 + 1];
+                      else if (v2 < brk2.min) break;
+                    }
+                    return b2 + m2 * v2;
+                  };
+                  for (j2 = 0; j2 < rsBreaks.length; j2++) {
+                    brk = rsBreaks[j2];
+                    brk.pmin = opts2.d2p(brk.min);
+                    brk.pmax = opts2.d2p(brk.max);
+                  }
+                  opts2.p2d = function(v2) {
+                    var b2 = _B[0];
+                    for (var j22 = 0; j22 < rsBreaks.length; j22++) {
+                      var brk2 = rsBreaks[j22];
+                      if (v2 >= brk2.pmax) b2 = _B[j22 + 1];
+                      else if (v2 < brk2.pmin) break;
+                    }
+                    return (v2 - b2) / m2;
+                  };
+                }
+              }
+              if (oppAxisRangeOpts.rangemode !== "match") {
+                var range0OppAxis = oppAxisOpts.r2l(oppAxisRangeOpts.range[0]);
+                var range1OppAxis = oppAxisOpts.r2l(oppAxisRangeOpts.range[1]);
+                var distOppAxis = range1OppAxis - range0OppAxis;
+                opts2.d2pOppAxis = function(v2) {
+                  return (v2 - range0OppAxis) / distOppAxis * opts2._height;
+                };
+              }
+              rangeSlider.call(drawBg, gd2, axisOpts, opts2).call(addClipPath, gd2, axisOpts, opts2).call(drawRangePlot, gd2, axisOpts, opts2).call(drawMasks, gd2, axisOpts, opts2, oppAxisRangeOpts).call(drawSlideBox, gd2, axisOpts, opts2).call(drawGrabbers, gd2, axisOpts, opts2);
+              setupDragElement(rangeSlider, gd2, axisOpts, opts2);
+              setPixelRange(rangeSlider, gd2, axisOpts, opts2, oppAxisOpts, oppAxisRangeOpts);
+              if (axisOpts.side === "bottom") {
+                Titles.draw(gd2, axisOpts._id + "title", {
+                  propContainer: axisOpts,
+                  propName: axisOpts._name + ".title.text",
+                  placeholder: fullLayout._dfltTitle.x,
+                  attributes: {
+                    x: axisOpts._offset + axisOpts._length / 2,
+                    y: y2 + opts2._height + opts2._offsetShift + 10 + 1.5 * axisOpts.title.font.size,
+                    "text-anchor": "middle"
+                  }
+                });
+              }
+            });
+          };
+          function eventX(event) {
+            if (typeof event.clientX === "number") {
+              return event.clientX;
+            }
+            if (event.touches && event.touches.length > 0) {
+              return event.touches[0].clientX;
+            }
+            return 0;
+          }
+          function setupDragElement(rangeSlider, gd2, axisOpts, opts) {
+            if (gd2._context.staticPlot) return;
+            var slideBox = rangeSlider.select("rect." + constants.slideBoxClassName).node();
+            var grabAreaMin = rangeSlider.select("rect." + constants.grabAreaMinClassName).node();
+            var grabAreaMax = rangeSlider.select("rect." + constants.grabAreaMaxClassName).node();
+            function mouseDownHandler() {
+              var event = d3.event;
+              var target = event.target;
+              var startX = eventX(event);
+              var offsetX = startX - rangeSlider.node().getBoundingClientRect().left;
+              var minVal = opts.d2p(axisOpts._rl[0]);
+              var maxVal = opts.d2p(axisOpts._rl[1]);
+              var dragCover = dragElement.coverSlip();
+              this.addEventListener("touchmove", mouseMove);
+              this.addEventListener("touchend", mouseUp);
+              dragCover.addEventListener("mousemove", mouseMove);
+              dragCover.addEventListener("mouseup", mouseUp);
+              function mouseMove(e2) {
+                var clientX = eventX(e2);
+                var delta = +clientX - startX;
+                var pixelMin, pixelMax, cursor;
+                switch (target) {
+                  case slideBox:
+                    cursor = "ew-resize";
+                    if (minVal + delta > axisOpts._length || maxVal + delta < 0) {
+                      return;
+                    }
+                    pixelMin = minVal + delta;
+                    pixelMax = maxVal + delta;
+                    break;
+                  case grabAreaMin:
+                    cursor = "col-resize";
+                    if (minVal + delta > axisOpts._length) {
+                      return;
+                    }
+                    pixelMin = minVal + delta;
+                    pixelMax = maxVal;
+                    break;
+                  case grabAreaMax:
+                    cursor = "col-resize";
+                    if (maxVal + delta < 0) {
+                      return;
+                    }
+                    pixelMin = minVal;
+                    pixelMax = maxVal + delta;
+                    break;
+                  default:
+                    cursor = "ew-resize";
+                    pixelMin = offsetX;
+                    pixelMax = offsetX + delta;
+                    break;
+                }
+                if (pixelMax < pixelMin) {
+                  var tmp2 = pixelMax;
+                  pixelMax = pixelMin;
+                  pixelMin = tmp2;
+                }
+                opts._pixelMin = pixelMin;
+                opts._pixelMax = pixelMax;
+                setCursor(d3.select(dragCover), cursor);
+                setDataRange(rangeSlider, gd2, axisOpts, opts);
+              }
+              function mouseUp() {
+                dragCover.removeEventListener("mousemove", mouseMove);
+                dragCover.removeEventListener("mouseup", mouseUp);
+                this.removeEventListener("touchmove", mouseMove);
+                this.removeEventListener("touchend", mouseUp);
+                Lib.removeElement(dragCover);
+              }
+            }
+            rangeSlider.on("mousedown", mouseDownHandler);
+            rangeSlider.on("touchstart", mouseDownHandler);
+          }
+          function setDataRange(rangeSlider, gd2, axisOpts, opts) {
+            function clamp2(v2) {
+              return axisOpts.l2r(Lib.constrain(v2, opts._rl[0], opts._rl[1]));
+            }
+            var dataMin = clamp2(opts.p2d(opts._pixelMin));
+            var dataMax = clamp2(opts.p2d(opts._pixelMax));
+            window.requestAnimationFrame(function() {
+              Registry.call("_guiRelayout", gd2, axisOpts._name + ".range", [dataMin, dataMax]);
+            });
+          }
+          function setPixelRange(rangeSlider, gd2, axisOpts, opts, oppAxisOpts, oppAxisRangeOpts) {
+            var hw2 = constants.handleWidth / 2;
+            function clamp2(v2) {
+              return Lib.constrain(v2, 0, opts._width);
+            }
+            function clampOppAxis(v2) {
+              return Lib.constrain(v2, 0, opts._height);
+            }
+            function clampHandle(v2) {
+              return Lib.constrain(v2, -hw2, opts._width + hw2);
+            }
+            var pixelMin = clamp2(opts.d2p(axisOpts._rl[0]));
+            var pixelMax = clamp2(opts.d2p(axisOpts._rl[1]));
+            rangeSlider.select("rect." + constants.slideBoxClassName).attr("x", pixelMin).attr("width", pixelMax - pixelMin);
+            rangeSlider.select("rect." + constants.maskMinClassName).attr("width", pixelMin);
+            rangeSlider.select("rect." + constants.maskMaxClassName).attr("x", pixelMax).attr("width", opts._width - pixelMax);
+            if (oppAxisRangeOpts.rangemode !== "match") {
+              var pixelMinOppAxis = opts._height - clampOppAxis(opts.d2pOppAxis(oppAxisOpts._rl[1]));
+              var pixelMaxOppAxis = opts._height - clampOppAxis(opts.d2pOppAxis(oppAxisOpts._rl[0]));
+              rangeSlider.select("rect." + constants.maskMinOppAxisClassName).attr("x", pixelMin).attr("height", pixelMinOppAxis).attr("width", pixelMax - pixelMin);
+              rangeSlider.select("rect." + constants.maskMaxOppAxisClassName).attr("x", pixelMin).attr("y", pixelMaxOppAxis).attr("height", opts._height - pixelMaxOppAxis).attr("width", pixelMax - pixelMin);
+              rangeSlider.select("rect." + constants.slideBoxClassName).attr("y", pixelMinOppAxis).attr("height", pixelMaxOppAxis - pixelMinOppAxis);
+            }
+            var offset = 0.5;
+            var xMin = Math.round(clampHandle(pixelMin - hw2)) - offset;
+            var xMax = Math.round(clampHandle(pixelMax - hw2)) + offset;
+            rangeSlider.select("g." + constants.grabberMinClassName).attr("transform", strTranslate(xMin, offset));
+            rangeSlider.select("g." + constants.grabberMaxClassName).attr("transform", strTranslate(xMax, offset));
+          }
+          function drawBg(rangeSlider, gd2, axisOpts, opts) {
+            var bg2 = Lib.ensureSingle(rangeSlider, "rect", constants.bgClassName, function(s2) {
+              s2.attr({
+                x: 0,
+                y: 0,
+                "shape-rendering": "crispEdges"
+              });
+            });
+            var borderCorrect = opts.borderwidth % 2 === 0 ? opts.borderwidth : opts.borderwidth - 1;
+            var offsetShift = -opts._offsetShift;
+            var lw = Drawing.crispRound(gd2, opts.borderwidth);
+            bg2.attr({
+              width: opts._width + borderCorrect,
+              height: opts._height + borderCorrect,
+              transform: strTranslate(offsetShift, offsetShift),
+              "stroke-width": lw
+            }).call(Color2.stroke, opts.bordercolor).call(Color2.fill, opts.bgcolor);
+          }
+          function addClipPath(rangeSlider, gd2, axisOpts, opts) {
+            var fullLayout = gd2._fullLayout;
+            var clipPath = Lib.ensureSingleById(fullLayout._topdefs, "clipPath", opts._clipId, function(s2) {
+              s2.append("rect").attr({ x: 0, y: 0 });
+            });
+            clipPath.select("rect").attr({
+              width: opts._width,
+              height: opts._height
+            });
+          }
+          function drawRangePlot(rangeSlider, gd2, axisOpts, opts) {
+            var calcData = gd2.calcdata;
+            var rangePlots = rangeSlider.selectAll("g." + constants.rangePlotClassName).data(axisOpts._subplotsWith, Lib.identity);
+            rangePlots.enter().append("g").attr("class", function(id2) {
+              return constants.rangePlotClassName + " " + id2;
+            }).call(Drawing.setClipUrl, opts._clipId, gd2);
+            rangePlots.order();
+            rangePlots.exit().remove();
+            var mainplotinfo;
+            rangePlots.each(function(id2, i2) {
+              var plotgroup = d3.select(this);
+              var isMainPlot = i2 === 0;
+              var oppAxisOpts = axisIDs.getFromId(gd2, id2, "y");
+              var oppAxisName = oppAxisOpts._name;
+              var oppAxisRangeOpts = opts[oppAxisName];
+              var mockFigure = {
+                data: [],
+                layout: {
+                  xaxis: {
+                    type: axisOpts.type,
+                    domain: [0, 1],
+                    range: opts.range.slice(),
+                    calendar: axisOpts.calendar
+                  },
+                  width: opts._width,
+                  height: opts._height,
+                  margin: { t: 0, b: 0, l: 0, r: 0 }
+                },
+                _context: gd2._context
+              };
+              if (axisOpts.rangebreaks) {
+                mockFigure.layout.xaxis.rangebreaks = axisOpts.rangebreaks;
+              }
+              mockFigure.layout[oppAxisName] = {
+                type: oppAxisOpts.type,
+                domain: [0, 1],
+                range: oppAxisRangeOpts.rangemode !== "match" ? oppAxisRangeOpts.range.slice() : oppAxisOpts.range.slice(),
+                calendar: oppAxisOpts.calendar
+              };
+              if (oppAxisOpts.rangebreaks) {
+                mockFigure.layout[oppAxisName].rangebreaks = oppAxisOpts.rangebreaks;
+              }
+              Plots.supplyDefaults(mockFigure);
+              var xa = mockFigure._fullLayout.xaxis;
+              var ya2 = mockFigure._fullLayout[oppAxisName];
+              xa.clearCalc();
+              xa.setScale();
+              ya2.clearCalc();
+              ya2.setScale();
+              var plotinfo = {
+                id: id2,
+                plotgroup,
+                xaxis: xa,
+                yaxis: ya2,
+                isRangePlot: true
+              };
+              if (isMainPlot) mainplotinfo = plotinfo;
+              else {
+                plotinfo.mainplot = "xy";
+                plotinfo.mainplotinfo = mainplotinfo;
+              }
+              Cartesian.rangePlot(gd2, plotinfo, filterRangePlotCalcData(calcData, id2));
+            });
+          }
+          function filterRangePlotCalcData(calcData, subplotId) {
+            var out = [];
+            for (var i2 = 0; i2 < calcData.length; i2++) {
+              var calcTrace = calcData[i2];
+              var trace = calcTrace[0].trace;
+              if (trace.xaxis + trace.yaxis === subplotId) {
+                out.push(calcTrace);
+              }
+            }
+            return out;
+          }
+          function drawMasks(rangeSlider, gd2, axisOpts, opts, oppAxisRangeOpts) {
+            var maskMin = Lib.ensureSingle(rangeSlider, "rect", constants.maskMinClassName, function(s2) {
+              s2.attr({
+                x: 0,
+                y: 0,
+                "shape-rendering": "crispEdges"
+              });
+            });
+            maskMin.attr("height", opts._height).call(Color2.fill, constants.maskColor);
+            var maskMax = Lib.ensureSingle(rangeSlider, "rect", constants.maskMaxClassName, function(s2) {
+              s2.attr({
+                y: 0,
+                "shape-rendering": "crispEdges"
+              });
+            });
+            maskMax.attr("height", opts._height).call(Color2.fill, constants.maskColor);
+            if (oppAxisRangeOpts.rangemode !== "match") {
+              var maskMinOppAxis = Lib.ensureSingle(rangeSlider, "rect", constants.maskMinOppAxisClassName, function(s2) {
+                s2.attr({
+                  y: 0,
+                  "shape-rendering": "crispEdges"
+                });
+              });
+              maskMinOppAxis.attr("width", opts._width).call(Color2.fill, constants.maskOppAxisColor);
+              var maskMaxOppAxis = Lib.ensureSingle(rangeSlider, "rect", constants.maskMaxOppAxisClassName, function(s2) {
+                s2.attr({
+                  y: 0,
+                  "shape-rendering": "crispEdges"
+                });
+              });
+              maskMaxOppAxis.attr("width", opts._width).style("border-top", constants.maskOppBorder).call(Color2.fill, constants.maskOppAxisColor);
+            }
+          }
+          function drawSlideBox(rangeSlider, gd2, axisOpts, opts) {
+            if (gd2._context.staticPlot) return;
+            var slideBox = Lib.ensureSingle(rangeSlider, "rect", constants.slideBoxClassName, function(s2) {
+              s2.attr({
+                y: 0,
+                cursor: constants.slideBoxCursor,
+                "shape-rendering": "crispEdges"
+              });
+            });
+            slideBox.attr({
+              height: opts._height,
+              fill: constants.slideBoxFill
+            });
+          }
+          function drawGrabbers(rangeSlider, gd2, axisOpts, opts) {
+            var grabberMin = Lib.ensureSingle(rangeSlider, "g", constants.grabberMinClassName);
+            var grabberMax = Lib.ensureSingle(rangeSlider, "g", constants.grabberMaxClassName);
+            var handleFixAttrs = {
+              x: 0,
+              width: constants.handleWidth,
+              rx: constants.handleRadius,
+              fill: Color2.background,
+              stroke: Color2.defaultLine,
+              "stroke-width": constants.handleStrokeWidth,
+              "shape-rendering": "crispEdges"
+            };
+            var handleDynamicAttrs = {
+              y: Math.round(opts._height / 4),
+              height: Math.round(opts._height / 2)
+            };
+            var handleMin = Lib.ensureSingle(grabberMin, "rect", constants.handleMinClassName, function(s2) {
+              s2.attr(handleFixAttrs);
+            });
+            handleMin.attr(handleDynamicAttrs);
+            var handleMax = Lib.ensureSingle(grabberMax, "rect", constants.handleMaxClassName, function(s2) {
+              s2.attr(handleFixAttrs);
+            });
+            handleMax.attr(handleDynamicAttrs);
+            var grabAreaFixAttrs = {
+              width: constants.grabAreaWidth,
+              x: 0,
+              y: 0,
+              fill: constants.grabAreaFill,
+              cursor: !gd2._context.staticPlot ? constants.grabAreaCursor : void 0
+            };
+            var grabAreaMin = Lib.ensureSingle(grabberMin, "rect", constants.grabAreaMinClassName, function(s2) {
+              s2.attr(grabAreaFixAttrs);
+            });
+            grabAreaMin.attr("height", opts._height);
+            var grabAreaMax = Lib.ensureSingle(grabberMax, "rect", constants.grabAreaMaxClassName, function(s2) {
+              s2.attr(grabAreaFixAttrs);
+            });
+            grabAreaMax.attr("height", opts._height);
+          }
+        }
+      });
+      var require_rangeslider = __commonJS({
+        "src/components/rangeslider/index.js"(exports, module2) {
+          var Lib = require_lib();
+          var attrs = require_attributes20();
+          var oppAxisAttrs = require_oppaxis_attributes();
+          var helpers = require_helpers11();
+          module2.exports = {
+            moduleType: "component",
+            name: "rangeslider",
+            schema: {
+              subplots: {
+                xaxis: {
+                  rangeslider: Lib.extendFlat({}, attrs, {
+                    yaxis: oppAxisAttrs
+                  })
+                }
+              }
+            },
+            layoutAttributes: require_attributes20(),
+            handleDefaults: require_defaults16(),
+            calcAutorange: require_calc_autorange3(),
+            draw: require_draw9(),
+            isVisible: helpers.isVisible,
+            makeData: helpers.makeData,
+            autoMarginOpts: helpers.autoMarginOpts
+          };
+        }
+      });
+      var require_attributes21 = __commonJS({
+        "src/components/rangeselector/attributes.js"(exports, module2) {
+          var fontAttrs = require_font_attributes();
+          var colorAttrs = require_attributes3();
+          var templatedArray = require_plot_template().templatedArray;
+          var buttonAttrs = templatedArray("button", {
+            visible: {
+              valType: "boolean",
+              dflt: true,
+              editType: "plot"
+            },
+            step: {
+              valType: "enumerated",
+              values: ["month", "year", "day", "hour", "minute", "second", "all"],
+              dflt: "month",
+              editType: "plot"
+            },
+            stepmode: {
+              valType: "enumerated",
+              values: ["backward", "todate"],
+              dflt: "backward",
+              editType: "plot"
+            },
+            count: {
+              valType: "number",
+              min: 0,
+              dflt: 1,
+              editType: "plot"
+            },
+            label: {
+              valType: "string",
+              editType: "plot"
+            },
+            editType: "plot"
+          });
+          module2.exports = {
+            visible: {
+              valType: "boolean",
+              editType: "plot"
+            },
+            buttons: buttonAttrs,
+            x: {
+              valType: "number",
+              min: -2,
+              max: 3,
+              editType: "plot"
+            },
+            xanchor: {
+              valType: "enumerated",
+              values: ["auto", "left", "center", "right"],
+              dflt: "left",
+              editType: "plot"
+            },
+            y: {
+              valType: "number",
+              min: -2,
+              max: 3,
+              editType: "plot"
+            },
+            yanchor: {
+              valType: "enumerated",
+              values: ["auto", "top", "middle", "bottom"],
+              dflt: "bottom",
+              editType: "plot"
+            },
+            font: fontAttrs({
+              editType: "plot"
+            }),
+            bgcolor: {
+              valType: "color",
+              dflt: colorAttrs.lightLine,
+              editType: "plot"
+            },
+            activecolor: {
+              valType: "color",
+              editType: "plot"
+            },
+            bordercolor: {
+              valType: "color",
+              dflt: colorAttrs.defaultLine,
+              editType: "plot"
+            },
+            borderwidth: {
+              valType: "number",
+              min: 0,
+              dflt: 0,
+              editType: "plot"
+            },
+            editType: "plot"
+          };
+        }
+      });
+      var require_constants13 = __commonJS({
+        "src/components/rangeselector/constants.js"(exports, module2) {
+          module2.exports = {
+            // 'y' position pad above counter axis domain
+            yPad: 0.02,
+            // minimum button width (regardless of text size)
+            minButtonWidth: 30,
+            // buttons rect radii
+            rx: 3,
+            ry: 3,
+            // light fraction used to compute the 'activecolor' default
+            lightAmount: 25,
+            darkAmount: 10
+          };
+        }
+      });
+      var require_defaults17 = __commonJS({
+        "src/components/rangeselector/defaults.js"(exports, module2) {
+          var Lib = require_lib();
+          var Color2 = require_color();
+          var Template = require_plot_template();
+          var handleArrayContainerDefaults = require_array_container_defaults();
+          var attributes = require_attributes21();
+          var constants = require_constants13();
+          module2.exports = function handleDefaults(containerIn, containerOut, layout, counterAxes, calendar) {
+            var selectorIn = containerIn.rangeselector || {};
+            var selectorOut = Template.newContainer(containerOut, "rangeselector");
+            function coerce(attr, dflt) {
+              return Lib.coerce(selectorIn, selectorOut, attributes, attr, dflt);
+            }
+            var buttons = handleArrayContainerDefaults(selectorIn, selectorOut, {
+              name: "buttons",
+              handleItemDefaults: buttonDefaults,
+              calendar
+            });
+            var visible = coerce("visible", buttons.length > 0);
+            if (visible) {
+              var posDflt = getPosDflt(containerOut, layout, counterAxes);
+              coerce("x", posDflt[0]);
+              coerce("y", posDflt[1]);
+              Lib.noneOrAll(containerIn, containerOut, ["x", "y"]);
+              coerce("xanchor");
+              coerce("yanchor");
+              Lib.coerceFont(coerce, "font", layout.font);
+              var bgColor = coerce("bgcolor");
+              coerce("activecolor", Color2.contrast(bgColor, constants.lightAmount, constants.darkAmount));
+              coerce("bordercolor");
+              coerce("borderwidth");
+            }
+          };
+          function buttonDefaults(buttonIn, buttonOut, selectorOut, opts) {
+            var calendar = opts.calendar;
+            function coerce(attr, dflt) {
+              return Lib.coerce(buttonIn, buttonOut, attributes.buttons, attr, dflt);
+            }
+            var visible = coerce("visible");
+            if (visible) {
+              var step = coerce("step");
+              if (step !== "all") {
+                if (calendar && calendar !== "gregorian" && (step === "month" || step === "year")) {
+                  buttonOut.stepmode = "backward";
+                } else {
+                  coerce("stepmode");
+                }
+                coerce("count");
+              }
+              coerce("label");
+            }
+          }
+          function getPosDflt(containerOut, layout, counterAxes) {
+            var anchoredList = counterAxes.filter(function(ax) {
+              return layout[ax].anchor === containerOut._id;
+            });
+            var posY = 0;
+            for (var i2 = 0; i2 < anchoredList.length; i2++) {
+              var domain = layout[anchoredList[i2]].domain;
+              if (domain) posY = Math.max(domain[1], posY);
+            }
+            return [containerOut.domain[0], posY + constants.yPad];
+          }
+        }
+      });
+      var require_get_update_object = __commonJS({
+        "src/components/rangeselector/get_update_object.js"(exports, module2) {
+          var d3Time = require_d3_time();
+          var titleCase = require_lib().titleCase;
+          module2.exports = function getUpdateObject(axisLayout, buttonLayout) {
+            var axName = axisLayout._name;
+            var update = {};
+            if (buttonLayout.step === "all") {
+              update[axName + ".autorange"] = true;
+            } else {
+              var xrange = getXRange(axisLayout, buttonLayout);
+              update[axName + ".range[0]"] = xrange[0];
+              update[axName + ".range[1]"] = xrange[1];
+            }
+            return update;
+          };
+          function getXRange(axisLayout, buttonLayout) {
+            var currentRange = axisLayout.range;
+            var base = new Date(axisLayout.r2l(currentRange[1]));
+            var step = buttonLayout.step;
+            var utcStep = d3Time["utc" + titleCase(step)];
+            var count2 = buttonLayout.count;
+            var range0;
+            switch (buttonLayout.stepmode) {
+              case "backward":
+                range0 = axisLayout.l2r(+utcStep.offset(base, -count2));
+                break;
+              case "todate":
+                var base2 = utcStep.offset(base, -count2);
+                range0 = axisLayout.l2r(+utcStep.ceil(base2));
+                break;
+            }
+            var range1 = currentRange[1];
+            return [range0, range1];
+          }
+        }
+      });
+      var require_draw10 = __commonJS({
+        "src/components/rangeselector/draw.js"(exports, module2) {
+          var d3 = require_d3();
+          var Registry = require_registry();
+          var Plots = require_plots();
+          var Color2 = require_color();
+          var Drawing = require_drawing();
+          var Lib = require_lib();
+          var strTranslate = Lib.strTranslate;
+          var svgTextUtils = require_svg_text_utils();
+          var axisIds = require_axis_ids();
+          var alignmentConstants = require_alignment();
+          var LINE_SPACING = alignmentConstants.LINE_SPACING;
+          var FROM_TL = alignmentConstants.FROM_TL;
+          var FROM_BR = alignmentConstants.FROM_BR;
+          var constants = require_constants13();
+          var getUpdateObject = require_get_update_object();
+          module2.exports = function draw(gd2) {
+            var fullLayout = gd2._fullLayout;
+            var selectors = fullLayout._infolayer.selectAll(".rangeselector").data(makeSelectorData(gd2), selectorKeyFunc);
+            selectors.enter().append("g").classed("rangeselector", true);
+            selectors.exit().remove();
+            selectors.style({
+              cursor: "pointer",
+              "pointer-events": "all"
+            });
+            selectors.each(function(d2) {
+              var selector = d3.select(this);
+              var axisLayout = d2;
+              var selectorLayout = axisLayout.rangeselector;
+              var buttons = selector.selectAll("g.button").data(Lib.filterVisible(selectorLayout.buttons));
+              buttons.enter().append("g").classed("button", true);
+              buttons.exit().remove();
+              buttons.each(function(d22) {
+                var button = d3.select(this);
+                var update = getUpdateObject(axisLayout, d22);
+                d22._isActive = isActive(axisLayout, d22, update);
+                button.call(drawButtonRect, selectorLayout, d22);
+                button.call(drawButtonText, selectorLayout, d22, gd2);
+                button.on("click", function() {
+                  if (gd2._dragged) return;
+                  Registry.call("_guiRelayout", gd2, update);
+                });
+                button.on("mouseover", function() {
+                  d22._isHovered = true;
+                  button.call(drawButtonRect, selectorLayout, d22);
+                });
+                button.on("mouseout", function() {
+                  d22._isHovered = false;
+                  button.call(drawButtonRect, selectorLayout, d22);
+                });
+              });
+              reposition(gd2, buttons, selectorLayout, axisLayout._name, selector);
+            });
+          };
+          function makeSelectorData(gd2) {
+            var axes = axisIds.list(gd2, "x", true);
+            var data = [];
+            for (var i2 = 0; i2 < axes.length; i2++) {
+              var axis = axes[i2];
+              if (axis.rangeselector && axis.rangeselector.visible) {
+                data.push(axis);
+              }
+            }
+            return data;
+          }
+          function selectorKeyFunc(d2) {
+            return d2._id;
+          }
+          function isActive(axisLayout, opts, update) {
+            if (opts.step === "all") {
+              return axisLayout.autorange === true;
+            } else {
+              var keys = Object.keys(update);
+              return axisLayout.range[0] === update[keys[0]] && axisLayout.range[1] === update[keys[1]];
+            }
+          }
+          function drawButtonRect(button, selectorLayout, d2) {
+            var rect = Lib.ensureSingle(button, "rect", "selector-rect", function(s2) {
+              s2.attr("shape-rendering", "crispEdges");
+            });
+            rect.attr({
+              rx: constants.rx,
+              ry: constants.ry
+            });
+            rect.call(Color2.stroke, selectorLayout.bordercolor).call(Color2.fill, getFillColor(selectorLayout, d2)).style("stroke-width", selectorLayout.borderwidth + "px");
+          }
+          function getFillColor(selectorLayout, d2) {
+            return d2._isActive || d2._isHovered ? selectorLayout.activecolor : selectorLayout.bgcolor;
+          }
+          function drawButtonText(button, selectorLayout, d2, gd2) {
+            function textLayout(s2) {
+              svgTextUtils.convertToTspans(s2, gd2);
+            }
+            var text = Lib.ensureSingle(button, "text", "selector-text", function(s2) {
+              s2.attr("text-anchor", "middle");
+            });
+            text.call(Drawing.font, selectorLayout.font).text(getLabel(d2, gd2._fullLayout._meta)).call(textLayout);
+          }
+          function getLabel(opts, _meta) {
+            if (opts.label) {
+              return _meta ? Lib.templateString(opts.label, _meta) : opts.label;
+            }
+            if (opts.step === "all") return "all";
+            return opts.count + opts.step.charAt(0);
+          }
+          function reposition(gd2, buttons, opts, axName, selector) {
+            var width = 0;
+            var height = 0;
+            var borderWidth = opts.borderwidth;
+            buttons.each(function() {
+              var button = d3.select(this);
+              var text = button.select(".selector-text");
+              var tHeight = opts.font.size * LINE_SPACING;
+              var hEff = Math.max(tHeight * svgTextUtils.lineCount(text), 16) + 3;
+              height = Math.max(height, hEff);
+            });
+            buttons.each(function() {
+              var button = d3.select(this);
+              var rect = button.select(".selector-rect");
+              var text = button.select(".selector-text");
+              var tWidth = text.node() && Drawing.bBox(text.node()).width;
+              var tHeight = opts.font.size * LINE_SPACING;
+              var tLines = svgTextUtils.lineCount(text);
+              var wEff = Math.max(tWidth + 10, constants.minButtonWidth);
+              button.attr("transform", strTranslate(borderWidth + width, borderWidth));
+              rect.attr({
+                x: 0,
+                y: 0,
+                width: wEff,
+                height
+              });
+              svgTextUtils.positionText(
+                text,
+                wEff / 2,
+                height / 2 - (tLines - 1) * tHeight / 2 + 3
+              );
+              width += wEff + 5;
+            });
+            var graphSize = gd2._fullLayout._size;
+            var lx = graphSize.l + graphSize.w * opts.x;
+            var ly = graphSize.t + graphSize.h * (1 - opts.y);
+            var xanchor = "left";
+            if (Lib.isRightAnchor(opts)) {
+              lx -= width;
+              xanchor = "right";
+            }
+            if (Lib.isCenterAnchor(opts)) {
+              lx -= width / 2;
+              xanchor = "center";
+            }
+            var yanchor = "top";
+            if (Lib.isBottomAnchor(opts)) {
+              ly -= height;
+              yanchor = "bottom";
+            }
+            if (Lib.isMiddleAnchor(opts)) {
+              ly -= height / 2;
+              yanchor = "middle";
+            }
+            width = Math.ceil(width);
+            height = Math.ceil(height);
+            lx = Math.round(lx);
+            ly = Math.round(ly);
+            Plots.autoMargin(gd2, axName + "-range-selector", {
+              x: opts.x,
+              y: opts.y,
+              l: width * FROM_TL[xanchor],
+              r: width * FROM_BR[xanchor],
+              b: height * FROM_BR[yanchor],
+              t: height * FROM_TL[yanchor]
+            });
+            selector.attr("transform", strTranslate(lx, ly));
+          }
+        }
+      });
+      var require_rangeselector = __commonJS({
+        "src/components/rangeselector/index.js"(exports, module2) {
+          module2.exports = {
+            moduleType: "component",
+            name: "rangeselector",
+            schema: {
+              subplots: {
+                xaxis: { rangeselector: require_attributes21() }
+              }
+            },
+            layoutAttributes: require_attributes21(),
+            handleDefaults: require_defaults17(),
+            draw: require_draw10()
+          };
+        }
+      });
+      var require_domain = __commonJS({
+        "src/plots/domain.js"(exports) {
+          var extendFlat = require_extend().extendFlat;
+          exports.attributes = function(opts, extra) {
+            opts = opts || {};
+            extra = extra || {};
+            var base = {
+              valType: "info_array",
+              editType: opts.editType,
+              items: [
+                { valType: "number", min: 0, max: 1, editType: opts.editType },
+                { valType: "number", min: 0, max: 1, editType: opts.editType }
+              ],
+              dflt: [0, 1]
+            };
+            opts.name ? opts.name + " " : "";
+            opts.trace ? "trace " : "subplot ";
+            extra.description ? " " + extra.description : "";
+            var out = {
+              x: extendFlat({}, base, {}),
+              y: extendFlat({}, base, {}),
+              editType: opts.editType
+            };
+            if (!opts.noGridCell) {
+              out.row = {
+                valType: "integer",
+                min: 0,
+                dflt: 0,
+                editType: opts.editType
+              };
+              out.column = {
+                valType: "integer",
+                min: 0,
+                dflt: 0,
+                editType: opts.editType
+              };
+            }
+            return out;
+          };
+          exports.defaults = function(containerOut, layout, coerce, dfltDomains) {
+            var dfltX = dfltDomains && dfltDomains.x || [0, 1];
+            var dfltY = dfltDomains && dfltDomains.y || [0, 1];
+            var grid = layout.grid;
+            if (grid) {
+              var column = coerce("domain.column");
+              if (column !== void 0) {
+                if (column < grid.columns) dfltX = grid._domains.x[column];
+                else delete containerOut.domain.column;
+              }
+              var row = coerce("domain.row");
+              if (row !== void 0) {
+                if (row < grid.rows) dfltY = grid._domains.y[row];
+                else delete containerOut.domain.row;
+              }
+            }
+            var x2 = coerce("domain.x", dfltX);
+            var y2 = coerce("domain.y", dfltY);
+            if (!(x2[0] < x2[1])) containerOut.domain.x = dfltX.slice();
+            if (!(y2[0] < y2[1])) containerOut.domain.y = dfltY.slice();
+          };
+        }
+      });
+      var require_grid = __commonJS({
+        "src/components/grid/index.js"(exports, module2) {
+          var Lib = require_lib();
+          var counterRegex = require_regex().counter;
+          var domainAttrs = require_domain().attributes;
+          var cartesianIdRegex = require_constants2().idRegex;
+          var Template = require_plot_template();
+          var gridAttrs = {
+            rows: {
+              valType: "integer",
+              min: 1,
+              editType: "plot"
+            },
+            roworder: {
+              valType: "enumerated",
+              values: ["top to bottom", "bottom to top"],
+              dflt: "top to bottom",
+              editType: "plot"
+            },
+            columns: {
+              valType: "integer",
+              min: 1,
+              editType: "plot"
+            },
+            subplots: {
+              valType: "info_array",
+              freeLength: true,
+              dimensions: 2,
+              items: { valType: "enumerated", values: [counterRegex("xy").toString(), ""], editType: "plot" },
+              editType: "plot"
+            },
+            xaxes: {
+              valType: "info_array",
+              freeLength: true,
+              items: { valType: "enumerated", values: [cartesianIdRegex.x.toString(), ""], editType: "plot" },
+              editType: "plot"
+            },
+            yaxes: {
+              valType: "info_array",
+              freeLength: true,
+              items: { valType: "enumerated", values: [cartesianIdRegex.y.toString(), ""], editType: "plot" },
+              editType: "plot"
+            },
+            pattern: {
+              valType: "enumerated",
+              values: ["independent", "coupled"],
+              dflt: "coupled",
+              editType: "plot"
+            },
+            xgap: {
+              valType: "number",
+              min: 0,
+              max: 1,
+              editType: "plot"
+            },
+            ygap: {
+              valType: "number",
+              min: 0,
+              max: 1,
+              editType: "plot"
+            },
+            domain: domainAttrs({ name: "grid", editType: "plot", noGridCell: true }, {}),
+            xside: {
+              valType: "enumerated",
+              values: ["bottom", "bottom plot", "top plot", "top"],
+              dflt: "bottom plot",
+              editType: "plot"
+            },
+            yside: {
+              valType: "enumerated",
+              values: ["left", "left plot", "right plot", "right"],
+              dflt: "left plot",
+              editType: "plot"
+            },
+            editType: "plot"
+          };
+          function getAxes(layout, grid, axLetter) {
+            var gridVal = grid[axLetter + "axes"];
+            var splomVal = Object.keys((layout._splomAxes || {})[axLetter] || {});
+            if (Array.isArray(gridVal)) return gridVal;
+            if (splomVal.length) return splomVal;
+          }
+          function sizeDefaults(layoutIn, layoutOut) {
+            var gridIn = layoutIn.grid || {};
+            var xAxes = getAxes(layoutOut, gridIn, "x");
+            var yAxes = getAxes(layoutOut, gridIn, "y");
+            if (!layoutIn.grid && !xAxes && !yAxes) return;
+            var hasSubplotGrid = Array.isArray(gridIn.subplots) && Array.isArray(gridIn.subplots[0]);
+            var hasXaxes = Array.isArray(xAxes);
+            var hasYaxes = Array.isArray(yAxes);
+            var isSplomGenerated = hasXaxes && xAxes !== gridIn.xaxes && hasYaxes && yAxes !== gridIn.yaxes;
+            var dfltRows, dfltColumns;
+            if (hasSubplotGrid) {
+              dfltRows = gridIn.subplots.length;
+              dfltColumns = gridIn.subplots[0].length;
+            } else {
+              if (hasYaxes) dfltRows = yAxes.length;
+              if (hasXaxes) dfltColumns = xAxes.length;
+            }
+            var gridOut = Template.newContainer(layoutOut, "grid");
+            function coerce(attr, dflt) {
+              return Lib.coerce(gridIn, gridOut, gridAttrs, attr, dflt);
+            }
+            var rows = coerce("rows", dfltRows);
+            var columns = coerce("columns", dfltColumns);
+            if (!(rows * columns > 1)) {
+              delete layoutOut.grid;
+              return;
+            }
+            if (!hasSubplotGrid && !hasXaxes && !hasYaxes) {
+              var useDefaultSubplots = coerce("pattern") === "independent";
+              if (useDefaultSubplots) hasSubplotGrid = true;
+            }
+            gridOut._hasSubplotGrid = hasSubplotGrid;
+            var rowOrder = coerce("roworder");
+            var reversed = rowOrder === "top to bottom";
+            var dfltGapX = hasSubplotGrid ? 0.2 : 0.1;
+            var dfltGapY = hasSubplotGrid ? 0.3 : 0.1;
+            var dfltSideX, dfltSideY;
+            if (isSplomGenerated && layoutOut._splomGridDflt) {
+              dfltSideX = layoutOut._splomGridDflt.xside;
+              dfltSideY = layoutOut._splomGridDflt.yside;
+            }
+            gridOut._domains = {
+              x: fillGridPositions("x", coerce, dfltGapX, dfltSideX, columns),
+              y: fillGridPositions("y", coerce, dfltGapY, dfltSideY, rows, reversed)
+            };
+          }
+          function fillGridPositions(axLetter, coerce, dfltGap, dfltSide, len2, reversed) {
+            var dirGap = coerce(axLetter + "gap", dfltGap);
+            var domain = coerce("domain." + axLetter);
+            coerce(axLetter + "side", dfltSide);
+            var out = new Array(len2);
+            var start = domain[0];
+            var step = (domain[1] - start) / (len2 - dirGap);
+            var cellDomain = step * (1 - dirGap);
+            for (var i2 = 0; i2 < len2; i2++) {
+              var cellStart = start + step * i2;
+              out[reversed ? len2 - 1 - i2 : i2] = [cellStart, cellStart + cellDomain];
+            }
+            return out;
+          }
+          function contentDefaults(layoutIn, layoutOut) {
+            var gridOut = layoutOut.grid;
+            if (!gridOut || !gridOut._domains) return;
+            var gridIn = layoutIn.grid || {};
+            var subplots = layoutOut._subplots;
+            var hasSubplotGrid = gridOut._hasSubplotGrid;
+            var rows = gridOut.rows;
+            var columns = gridOut.columns;
+            var useDefaultSubplots = gridOut.pattern === "independent";
+            var i2, j2, xId, yId, subplotId, subplotsOut, yPos;
+            var axisMap = gridOut._axisMap = {};
+            if (hasSubplotGrid) {
+              var subplotsIn = gridIn.subplots || [];
+              subplotsOut = gridOut.subplots = new Array(rows);
+              var index = 1;
+              for (i2 = 0; i2 < rows; i2++) {
+                var rowOut = subplotsOut[i2] = new Array(columns);
+                var rowIn = subplotsIn[i2] || [];
+                for (j2 = 0; j2 < columns; j2++) {
+                  if (useDefaultSubplots) {
+                    subplotId = index === 1 ? "xy" : "x" + index + "y" + index;
+                    index++;
+                  } else subplotId = rowIn[j2];
+                  rowOut[j2] = "";
+                  if (subplots.cartesian.indexOf(subplotId) !== -1) {
+                    yPos = subplotId.indexOf("y");
+                    xId = subplotId.slice(0, yPos);
+                    yId = subplotId.slice(yPos);
+                    if (axisMap[xId] !== void 0 && axisMap[xId] !== j2 || axisMap[yId] !== void 0 && axisMap[yId] !== i2) {
+                      continue;
+                    }
+                    rowOut[j2] = subplotId;
+                    axisMap[xId] = j2;
+                    axisMap[yId] = i2;
+                  }
+                }
+              }
+            } else {
+              var xAxes = getAxes(layoutOut, gridIn, "x");
+              var yAxes = getAxes(layoutOut, gridIn, "y");
+              gridOut.xaxes = fillGridAxes(xAxes, subplots.xaxis, columns, axisMap, "x");
+              gridOut.yaxes = fillGridAxes(yAxes, subplots.yaxis, rows, axisMap, "y");
+            }
+            var anchors = gridOut._anchors = {};
+            var reversed = gridOut.roworder === "top to bottom";
+            for (var axisId in axisMap) {
+              var axLetter = axisId.charAt(0);
+              var side = gridOut[axLetter + "side"];
+              var i0, inc, iFinal;
+              if (side.length < 8) {
+                anchors[axisId] = "free";
+              } else if (axLetter === "x") {
+                if (side.charAt(0) === "t" === reversed) {
+                  i0 = 0;
+                  inc = 1;
+                  iFinal = rows;
+                } else {
+                  i0 = rows - 1;
+                  inc = -1;
+                  iFinal = -1;
+                }
+                if (hasSubplotGrid) {
+                  var column = axisMap[axisId];
+                  for (i2 = i0; i2 !== iFinal; i2 += inc) {
+                    subplotId = subplotsOut[i2][column];
+                    if (!subplotId) continue;
+                    yPos = subplotId.indexOf("y");
+                    if (subplotId.slice(0, yPos) === axisId) {
+                      anchors[axisId] = subplotId.slice(yPos);
+                      break;
+                    }
+                  }
+                } else {
+                  for (i2 = i0; i2 !== iFinal; i2 += inc) {
+                    yId = gridOut.yaxes[i2];
+                    if (subplots.cartesian.indexOf(axisId + yId) !== -1) {
+                      anchors[axisId] = yId;
+                      break;
+                    }
+                  }
+                }
+              } else {
+                if (side.charAt(0) === "l") {
+                  i0 = 0;
+                  inc = 1;
+                  iFinal = columns;
+                } else {
+                  i0 = columns - 1;
+                  inc = -1;
+                  iFinal = -1;
+                }
+                if (hasSubplotGrid) {
+                  var row = axisMap[axisId];
+                  for (i2 = i0; i2 !== iFinal; i2 += inc) {
+                    subplotId = subplotsOut[row][i2];
+                    if (!subplotId) continue;
+                    yPos = subplotId.indexOf("y");
+                    if (subplotId.slice(yPos) === axisId) {
+                      anchors[axisId] = subplotId.slice(0, yPos);
+                      break;
+                    }
+                  }
+                } else {
+                  for (i2 = i0; i2 !== iFinal; i2 += inc) {
+                    xId = gridOut.xaxes[i2];
+                    if (subplots.cartesian.indexOf(xId + axisId) !== -1) {
+                      anchors[axisId] = xId;
+                      break;
+                    }
+                  }
+                }
+              }
+            }
+          }
+          function fillGridAxes(axesIn, axesAllowed, len2, axisMap, axLetter) {
+            var out = new Array(len2);
+            var i2;
+            function fillOneAxis(i22, axisId) {
+              if (axesAllowed.indexOf(axisId) !== -1 && axisMap[axisId] === void 0) {
+                out[i22] = axisId;
+                axisMap[axisId] = i22;
+              } else out[i22] = "";
+            }
+            if (Array.isArray(axesIn)) {
+              for (i2 = 0; i2 < len2; i2++) {
+                fillOneAxis(i2, axesIn[i2]);
+              }
+            } else {
+              fillOneAxis(0, axLetter);
+              for (i2 = 1; i2 < len2; i2++) {
+                fillOneAxis(i2, axLetter + (i2 + 1));
+              }
+            }
+            return out;
+          }
+          module2.exports = {
+            moduleType: "component",
+            name: "grid",
+            schema: {
+              layout: { grid: gridAttrs }
+            },
+            layoutAttributes: gridAttrs,
+            sizeDefaults,
+            contentDefaults
+          };
+        }
+      });
+      var require_attributes22 = __commonJS({
+        "src/components/errorbars/attributes.js"(exports, module2) {
+          module2.exports = {
+            visible: {
+              valType: "boolean",
+              editType: "calc"
+            },
+            type: {
+              valType: "enumerated",
+              values: ["percent", "constant", "sqrt", "data"],
+              editType: "calc"
+            },
+            symmetric: {
+              valType: "boolean",
+              editType: "calc"
+            },
+            array: {
+              valType: "data_array",
+              editType: "calc"
+            },
+            arrayminus: {
+              valType: "data_array",
+              editType: "calc"
+            },
+            value: {
+              valType: "number",
+              min: 0,
+              dflt: 10,
+              editType: "calc"
+            },
+            valueminus: {
+              valType: "number",
+              min: 0,
+              dflt: 10,
+              editType: "calc"
+            },
+            traceref: {
+              valType: "integer",
+              min: 0,
+              dflt: 0,
+              editType: "style"
+            },
+            tracerefminus: {
+              valType: "integer",
+              min: 0,
+              dflt: 0,
+              editType: "style"
+            },
+            copy_ystyle: {
+              valType: "boolean",
+              editType: "plot"
+            },
+            copy_zstyle: {
+              valType: "boolean",
+              editType: "style"
+            },
+            color: {
+              valType: "color",
+              editType: "style"
+            },
+            thickness: {
+              valType: "number",
+              min: 0,
+              dflt: 2,
+              editType: "style"
+            },
+            width: {
+              valType: "number",
+              min: 0,
+              editType: "plot"
+            },
+            editType: "calc"
+          };
+        }
+      });
+      var require_defaults18 = __commonJS({
+        "src/components/errorbars/defaults.js"(exports, module2) {
+          var isNumeric = require_fast_isnumeric();
+          var Registry = require_registry();
+          var Lib = require_lib();
+          var Template = require_plot_template();
+          var attributes = require_attributes22();
+          module2.exports = function(traceIn, traceOut, defaultColor, opts) {
+            var objName = "error_" + opts.axis;
+            var containerOut = Template.newContainer(traceOut, objName);
+            var containerIn = traceIn[objName] || {};
+            function coerce(attr, dflt) {
+              return Lib.coerce(containerIn, containerOut, attributes, attr, dflt);
+            }
+            var hasErrorBars = containerIn.array !== void 0 || containerIn.value !== void 0 || containerIn.type === "sqrt";
+            var visible = coerce("visible", hasErrorBars);
+            if (visible === false) return;
+            var type = coerce("type", "array" in containerIn ? "data" : "percent");
+            var symmetric = true;
+            if (type !== "sqrt") {
+              symmetric = coerce(
+                "symmetric",
+                !((type === "data" ? "arrayminus" : "valueminus") in containerIn)
+              );
+            }
+            if (type === "data") {
+              coerce("array");
+              coerce("traceref");
+              if (!symmetric) {
+                coerce("arrayminus");
+                coerce("tracerefminus");
+              }
+            } else if (type === "percent" || type === "constant") {
+              coerce("value");
+              if (!symmetric) coerce("valueminus");
+            }
+            var copyAttr = "copy_" + opts.inherit + "style";
+            if (opts.inherit) {
+              var inheritObj = traceOut["error_" + opts.inherit];
+              if ((inheritObj || {}).visible) {
+                coerce(copyAttr, !(containerIn.color || isNumeric(containerIn.thickness) || isNumeric(containerIn.width)));
+              }
+            }
+            if (!opts.inherit || !containerOut[copyAttr]) {
+              coerce("color", defaultColor);
+              coerce("thickness");
+              coerce("width", Registry.traceIs(traceOut, "gl3d") ? 0 : 4);
+            }
+          };
+        }
+      });
+      var require_compute_error = __commonJS({
+        "src/components/errorbars/compute_error.js"(exports, module2) {
+          module2.exports = function makeComputeError(opts) {
+            var type = opts.type;
+            var symmetric = opts.symmetric;
+            if (type === "data") {
+              var array = opts.array || [];
+              if (symmetric) {
+                return function computeError(dataPt, index) {
+                  var val = +array[index];
+                  return [val, val];
+                };
+              } else {
+                var arrayminus = opts.arrayminus || [];
+                return function computeError(dataPt, index) {
+                  var val = +array[index];
+                  var valMinus = +arrayminus[index];
+                  if (!isNaN(val) || !isNaN(valMinus)) {
+                    return [valMinus || 0, val || 0];
+                  }
+                  return [NaN, NaN];
+                };
+              }
+            } else {
+              var computeErrorValue = makeComputeErrorValue(type, opts.value);
+              var computeErrorValueMinus = makeComputeErrorValue(type, opts.valueminus);
+              if (symmetric || opts.valueminus === void 0) {
+                return function computeError(dataPt) {
+                  var val = computeErrorValue(dataPt);
+                  return [val, val];
+                };
+              } else {
+                return function computeError(dataPt) {
+                  return [
+                    computeErrorValueMinus(dataPt),
+                    computeErrorValue(dataPt)
+                  ];
+                };
+              }
+            }
+          };
+          function makeComputeErrorValue(type, value) {
+            if (type === "percent") {
+              return function(dataPt) {
+                return Math.abs(dataPt * value / 100);
+              };
+            }
+            if (type === "constant") {
+              return function() {
+                return Math.abs(value);
+              };
+            }
+            if (type === "sqrt") {
+              return function(dataPt) {
+                return Math.sqrt(Math.abs(dataPt));
+              };
+            }
+          }
+        }
+      });
+      var require_calc4 = __commonJS({
+        "src/components/errorbars/calc.js"(exports, module2) {
+          var isNumeric = require_fast_isnumeric();
+          var Registry = require_registry();
+          var Axes = require_axes();
+          var Lib = require_lib();
+          var makeComputeError = require_compute_error();
+          module2.exports = function calc(gd2) {
+            var calcdata = gd2.calcdata;
+            for (var i2 = 0; i2 < calcdata.length; i2++) {
+              var calcTrace = calcdata[i2];
+              var trace = calcTrace[0].trace;
+              if (trace.visible === true && Registry.traceIs(trace, "errorBarsOK")) {
+                var xa = Axes.getFromId(gd2, trace.xaxis);
+                var ya2 = Axes.getFromId(gd2, trace.yaxis);
+                calcOneAxis(calcTrace, trace, xa, "x");
+                calcOneAxis(calcTrace, trace, ya2, "y");
+              }
+            }
+          };
+          function calcOneAxis(calcTrace, trace, axis, coord) {
+            var opts = trace["error_" + coord] || {};
+            var isVisible = opts.visible && ["linear", "log"].indexOf(axis.type) !== -1;
+            var vals = [];
+            if (!isVisible) return;
+            var computeError = makeComputeError(opts);
+            for (var i2 = 0; i2 < calcTrace.length; i2++) {
+              var calcPt = calcTrace[i2];
+              var iIn = calcPt.i;
+              if (iIn === void 0) iIn = i2;
+              else if (iIn === null) continue;
+              var calcCoord = calcPt[coord];
+              if (!isNumeric(axis.c2l(calcCoord))) continue;
+              var errors = computeError(calcCoord, iIn);
+              if (isNumeric(errors[0]) && isNumeric(errors[1])) {
+                var shoe = calcPt[coord + "s"] = calcCoord - errors[0];
+                var hat = calcPt[coord + "h"] = calcCoord + errors[1];
+                vals.push(shoe, hat);
+              }
+            }
+            var axId = axis._id;
+            var baseExtremes = trace._extremes[axId];
+            var extremes = Axes.findExtremes(
+              axis,
+              vals,
+              Lib.extendFlat({ tozero: baseExtremes.opts.tozero }, { padded: true })
+            );
+            baseExtremes.min = baseExtremes.min.concat(extremes.min);
+            baseExtremes.max = baseExtremes.max.concat(extremes.max);
+          }
+        }
+      });
+      var require_plot2 = __commonJS({
+        "src/components/errorbars/plot.js"(exports, module2) {
+          var d3 = require_d3();
+          var isNumeric = require_fast_isnumeric();
+          var Drawing = require_drawing();
+          var subTypes = require_subtypes();
+          module2.exports = function plot(gd2, traces, plotinfo, transitionOpts) {
+            var isNew;
+            var xa = plotinfo.xaxis;
+            var ya2 = plotinfo.yaxis;
+            var hasAnimation = transitionOpts && transitionOpts.duration > 0;
+            var isStatic = gd2._context.staticPlot;
+            traces.each(function(d2) {
+              var trace = d2[0].trace;
+              var xObj = trace.error_x || {};
+              var yObj = trace.error_y || {};
+              var keyFunc;
+              if (trace.ids) {
+                keyFunc = function(d22) {
+                  return d22.id;
+                };
+              }
+              var sparse = subTypes.hasMarkers(trace) && trace.marker.maxdisplayed > 0;
+              if (!yObj.visible && !xObj.visible) d2 = [];
+              var errorbars = d3.select(this).selectAll("g.errorbar").data(d2, keyFunc);
+              errorbars.exit().remove();
+              if (!d2.length) return;
+              if (!xObj.visible) errorbars.selectAll("path.xerror").remove();
+              if (!yObj.visible) errorbars.selectAll("path.yerror").remove();
+              errorbars.style("opacity", 1);
+              var enter = errorbars.enter().append("g").classed("errorbar", true);
+              if (hasAnimation) {
+                enter.style("opacity", 0).transition().duration(transitionOpts.duration).style("opacity", 1);
+              }
+              Drawing.setClipUrl(errorbars, plotinfo.layerClipId, gd2);
+              errorbars.each(function(d22) {
+                var errorbar = d3.select(this);
+                var coords = errorCoords(d22, xa, ya2);
+                if (sparse && !d22.vis) return;
+                var path;
+                var yerror = errorbar.select("path.yerror");
+                if (yObj.visible && isNumeric(coords.x) && isNumeric(coords.yh) && isNumeric(coords.ys)) {
+                  var yw = yObj.width;
+                  path = "M" + (coords.x - yw) + "," + coords.yh + "h" + 2 * yw + // hat
+                  "m-" + yw + ",0V" + coords.ys;
+                  if (!coords.noYS) path += "m-" + yw + ",0h" + 2 * yw;
+                  isNew = !yerror.size();
+                  if (isNew) {
+                    yerror = errorbar.append("path").style("vector-effect", isStatic ? "none" : "non-scaling-stroke").classed("yerror", true);
+                  } else if (hasAnimation) {
+                    yerror = yerror.transition().duration(transitionOpts.duration).ease(transitionOpts.easing);
+                  }
+                  yerror.attr("d", path);
+                } else yerror.remove();
+                var xerror = errorbar.select("path.xerror");
+                if (xObj.visible && isNumeric(coords.y) && isNumeric(coords.xh) && isNumeric(coords.xs)) {
+                  var xw = (xObj.copy_ystyle ? yObj : xObj).width;
+                  path = "M" + coords.xh + "," + (coords.y - xw) + "v" + 2 * xw + // hat
+                  "m0,-" + xw + "H" + coords.xs;
+                  if (!coords.noXS) path += "m0,-" + xw + "v" + 2 * xw;
+                  isNew = !xerror.size();
+                  if (isNew) {
+                    xerror = errorbar.append("path").style("vector-effect", isStatic ? "none" : "non-scaling-stroke").classed("xerror", true);
+                  } else if (hasAnimation) {
+                    xerror = xerror.transition().duration(transitionOpts.duration).ease(transitionOpts.easing);
+                  }
+                  xerror.attr("d", path);
+                } else xerror.remove();
+              });
+            });
+          };
+          function errorCoords(d2, xa, ya2) {
+            var out = {
+              x: xa.c2p(d2.x),
+              y: ya2.c2p(d2.y)
+            };
+            if (d2.yh !== void 0) {
+              out.yh = ya2.c2p(d2.yh);
+              out.ys = ya2.c2p(d2.ys);
+              if (!isNumeric(out.ys)) {
+                out.noYS = true;
+                out.ys = ya2.c2p(d2.ys, true);
+              }
+            }
+            if (d2.xh !== void 0) {
+              out.xh = xa.c2p(d2.xh);
+              out.xs = xa.c2p(d2.xs);
+              if (!isNumeric(out.xs)) {
+                out.noXS = true;
+                out.xs = xa.c2p(d2.xs, true);
+              }
+            }
+            return out;
+          }
+        }
+      });
+      var require_style3 = __commonJS({
+        "src/components/errorbars/style.js"(exports, module2) {
+          var d3 = require_d3();
+          var Color2 = require_color();
+          module2.exports = function style(traces) {
+            traces.each(function(d2) {
+              var trace = d2[0].trace;
+              var yObj = trace.error_y || {};
+              var xObj = trace.error_x || {};
+              var s2 = d3.select(this);
+              s2.selectAll("path.yerror").style("stroke-width", yObj.thickness + "px").call(Color2.stroke, yObj.color);
+              if (xObj.copy_ystyle) xObj = yObj;
+              s2.selectAll("path.xerror").style("stroke-width", xObj.thickness + "px").call(Color2.stroke, xObj.color);
+            });
+          };
+        }
+      });
+      var require_errorbars = __commonJS({
+        "src/components/errorbars/index.js"(exports, module2) {
+          var Lib = require_lib();
+          var overrideAll = require_edit_types().overrideAll;
+          var attributes = require_attributes22();
+          var xyAttrs = {
+            error_x: Lib.extendFlat({}, attributes),
+            error_y: Lib.extendFlat({}, attributes)
+          };
+          delete xyAttrs.error_x.copy_zstyle;
+          delete xyAttrs.error_y.copy_zstyle;
+          delete xyAttrs.error_y.copy_ystyle;
+          var xyzAttrs = {
+            error_x: Lib.extendFlat({}, attributes),
+            error_y: Lib.extendFlat({}, attributes),
+            error_z: Lib.extendFlat({}, attributes)
+          };
+          delete xyzAttrs.error_x.copy_ystyle;
+          delete xyzAttrs.error_y.copy_ystyle;
+          delete xyzAttrs.error_z.copy_ystyle;
+          delete xyzAttrs.error_z.copy_zstyle;
+          module2.exports = {
+            moduleType: "component",
+            name: "errorbars",
+            schema: {
+              traces: {
+                scatter: xyAttrs,
+                bar: xyAttrs,
+                histogram: xyAttrs,
+                scatter3d: overrideAll(xyzAttrs, "calc", "nested"),
+                scattergl: overrideAll(xyAttrs, "calc", "nested")
+              }
+            },
+            supplyDefaults: require_defaults18(),
+            calc: require_calc4(),
+            makeComputeError: require_compute_error(),
+            plot: require_plot2(),
+            style: require_style3(),
+            hoverInfo
+          };
+          function hoverInfo(calcPoint, trace, hoverPoint) {
+            if ((trace.error_y || {}).visible) {
+              hoverPoint.yerr = calcPoint.yh - calcPoint.y;
+              if (!trace.error_y.symmetric) hoverPoint.yerrneg = calcPoint.y - calcPoint.ys;
+            }
+            if ((trace.error_x || {}).visible) {
+              hoverPoint.xerr = calcPoint.xh - calcPoint.x;
+              if (!trace.error_x.symmetric) hoverPoint.xerrneg = calcPoint.x - calcPoint.xs;
+            }
+          }
+        }
+      });
+      var require_constants14 = __commonJS({
+        "src/components/colorbar/constants.js"(exports, module2) {
+          module2.exports = {
+            cn: {
+              colorbar: "colorbar",
+              cbbg: "cbbg",
+              cbfill: "cbfill",
+              cbfills: "cbfills",
+              cbline: "cbline",
+              cblines: "cblines",
+              cbaxis: "cbaxis",
+              cbtitleunshift: "cbtitleunshift",
+              cbtitle: "cbtitle",
+              cboutline: "cboutline",
+              crisp: "crisp",
+              jsPlaceholder: "js-placeholder"
+            }
+          };
+        }
+      });
+      var require_draw11 = __commonJS({
+        "src/components/colorbar/draw.js"(exports, module2) {
+          var d3 = require_d3();
+          var tinycolor = require_tinycolor();
+          var Plots = require_plots();
+          var Registry = require_registry();
+          var Axes = require_axes();
+          var dragElement = require_dragelement();
+          var Lib = require_lib();
+          var strTranslate = Lib.strTranslate;
+          var extendFlat = require_extend().extendFlat;
+          var setCursor = require_setcursor();
+          var Drawing = require_drawing();
+          var Color2 = require_color();
+          var Titles = require_titles();
+          var svgTextUtils = require_svg_text_utils();
+          var flipScale = require_helpers().flipScale;
+          var handleAxisDefaults = require_axis_defaults();
+          var handleAxisPositionDefaults = require_position_defaults();
+          var axisLayoutAttrs = require_layout_attributes4();
+          var alignmentConstants = require_alignment();
+          var LINE_SPACING = alignmentConstants.LINE_SPACING;
+          var FROM_TL = alignmentConstants.FROM_TL;
+          var FROM_BR = alignmentConstants.FROM_BR;
+          var cn = require_constants14().cn;
+          function draw(gd2) {
+            var fullLayout = gd2._fullLayout;
+            var colorBars = fullLayout._infolayer.selectAll("g." + cn.colorbar).data(makeColorBarData(gd2), function(opts) {
+              return opts._id;
+            });
+            colorBars.enter().append("g").attr("class", function(opts) {
+              return opts._id;
+            }).classed(cn.colorbar, true);
+            colorBars.each(function(opts) {
+              var g2 = d3.select(this);
+              Lib.ensureSingle(g2, "rect", cn.cbbg);
+              Lib.ensureSingle(g2, "g", cn.cbfills);
+              Lib.ensureSingle(g2, "g", cn.cblines);
+              Lib.ensureSingle(g2, "g", cn.cbaxis, function(s2) {
+                s2.classed(cn.crisp, true);
+              });
+              Lib.ensureSingle(g2, "g", cn.cbtitleunshift, function(s2) {
+                s2.append("g").classed(cn.cbtitle, true);
+              });
+              Lib.ensureSingle(g2, "rect", cn.cboutline);
+              var done = drawColorBar(g2, opts, gd2);
+              if (done && done.then) (gd2._promises || []).push(done);
+              if (gd2._context.edits.colorbarPosition) {
+                makeEditable(g2, opts, gd2);
+              }
+            });
+            colorBars.exit().each(function(opts) {
+              Plots.autoMargin(gd2, opts._id);
+            }).remove();
+            colorBars.order();
+          }
+          function makeColorBarData(gd2) {
+            var fullLayout = gd2._fullLayout;
+            var calcdata = gd2.calcdata;
+            var out = [];
+            var opts;
+            var cont;
+            var trace;
+            var cbOpt;
+            function initOpts(opts2) {
+              return extendFlat(opts2, {
+                // fillcolor can be a d3 scale, domain is z values, range is colors
+                // or leave it out for no fill,
+                // or set to a string constant for single-color fill
+                _fillcolor: null,
+                // line.color has the same options as fillcolor
+                _line: { color: null, width: null, dash: null },
+                // levels of lines to draw.
+                // note that this DOES NOT determine the extent of the bar
+                // that's given by the domain of fillcolor
+                // (or line.color if no fillcolor domain)
+                _levels: { start: null, end: null, size: null },
+                // separate fill levels (for example, heatmap coloring of a
+                // contour map) if this is omitted, fillcolors will be
+                // evaluated halfway between levels
+                _filllevels: null,
+                // for continuous colorscales: fill with a gradient instead of explicit levels
+                // value should be the colorscale [[0, c0], [v1, c1], ..., [1, cEnd]]
+                _fillgradient: null,
+                // when using a gradient, we need the data range specified separately
+                _zrange: null
+              });
+            }
+            function calcOpts() {
+              if (typeof cbOpt.calc === "function") {
+                cbOpt.calc(gd2, trace, opts);
+              } else {
+                opts._fillgradient = cont.reversescale ? flipScale(cont.colorscale) : cont.colorscale;
+                opts._zrange = [cont[cbOpt.min], cont[cbOpt.max]];
+              }
+            }
+            for (var i2 = 0; i2 < calcdata.length; i2++) {
+              var cd2 = calcdata[i2];
+              trace = cd2[0].trace;
+              if (!trace._module) continue;
+              var moduleOpts = trace._module.colorbar;
+              if (trace.visible === true && moduleOpts) {
+                var allowsMultiplotCbs = Array.isArray(moduleOpts);
+                var cbOpts = allowsMultiplotCbs ? moduleOpts : [moduleOpts];
+                for (var j2 = 0; j2 < cbOpts.length; j2++) {
+                  cbOpt = cbOpts[j2];
+                  var contName = cbOpt.container;
+                  cont = contName ? trace[contName] : trace;
+                  if (cont && cont.showscale) {
+                    opts = initOpts(cont.colorbar);
+                    opts._id = "cb" + trace.uid + (allowsMultiplotCbs && contName ? "-" + contName : "");
+                    opts._traceIndex = trace.index;
+                    opts._propPrefix = (contName ? contName + "." : "") + "colorbar.";
+                    opts._meta = trace._meta;
+                    calcOpts();
+                    out.push(opts);
+                  }
+                }
+              }
+            }
+            for (var k2 in fullLayout._colorAxes) {
+              cont = fullLayout[k2];
+              if (cont.showscale) {
+                var colorAxOpts = fullLayout._colorAxes[k2];
+                opts = initOpts(cont.colorbar);
+                opts._id = "cb" + k2;
+                opts._propPrefix = k2 + ".colorbar.";
+                opts._meta = fullLayout._meta;
+                cbOpt = { min: "cmin", max: "cmax" };
+                if (colorAxOpts[0] !== "heatmap") {
+                  trace = colorAxOpts[1];
+                  cbOpt.calc = trace._module.colorbar.calc;
+                }
+                calcOpts();
+                out.push(opts);
+              }
+            }
+            return out;
+          }
+          function drawColorBar(g2, opts, gd2) {
+            var isVertical = opts.orientation === "v";
+            var len2 = opts.len;
+            var lenmode = opts.lenmode;
+            var thickness = opts.thickness;
+            var thicknessmode = opts.thicknessmode;
+            var outlinewidth = opts.outlinewidth;
+            var borderwidth = opts.borderwidth;
+            var bgcolor = opts.bgcolor;
+            var xanchor = opts.xanchor;
+            var yanchor = opts.yanchor;
+            var xpad = opts.xpad;
+            var ypad = opts.ypad;
+            var optsX = opts.x;
+            var optsY = isVertical ? opts.y : 1 - opts.y;
+            var isPaperY = opts.yref === "paper";
+            var isPaperX = opts.xref === "paper";
+            var fullLayout = gd2._fullLayout;
+            var gs = fullLayout._size;
+            var fillColor = opts._fillcolor;
+            var line = opts._line;
+            var title = opts.title;
+            var titleSide = title.side;
+            var zrange = opts._zrange || d3.extent((typeof fillColor === "function" ? fillColor : line.color).domain());
+            var lineColormap = typeof line.color === "function" ? line.color : function() {
+              return line.color;
+            };
+            var fillColormap = typeof fillColor === "function" ? fillColor : function() {
+              return fillColor;
+            };
+            var levelsIn = opts._levels;
+            var levelsOut = calcLevels(gd2, opts, zrange);
+            var fillLevels = levelsOut.fill;
+            var lineLevels = levelsOut.line;
+            var thickPx = Math.round(thickness * (thicknessmode === "fraction" ? isVertical ? gs.w : gs.h : 1));
+            var thickFrac = thickPx / (isVertical ? gs.w : gs.h);
+            var lenPx = Math.round(len2 * (lenmode === "fraction" ? isVertical ? gs.h : gs.w : 1));
+            var lenFrac = lenPx / (isVertical ? gs.h : gs.w);
+            var posW = isPaperX ? gs.w : gd2._fullLayout.width;
+            var posH = isPaperY ? gs.h : gd2._fullLayout.height;
+            var uPx = Math.round(
+              isVertical ? optsX * posW + xpad : optsY * posH + ypad
+            );
+            var xRatio = { center: 0.5, right: 1 }[xanchor] || 0;
+            var yRatio = { top: 1, middle: 0.5 }[yanchor] || 0;
+            var uFrac = isVertical ? optsX - xRatio * thickFrac : optsY - yRatio * thickFrac;
+            var vFrac = isVertical ? optsY - yRatio * lenFrac : optsX - xRatio * lenFrac;
+            var vPx = Math.round(
+              isVertical ? posH * (1 - vFrac) : posW * vFrac
+            );
+            opts._lenFrac = lenFrac;
+            opts._thickFrac = thickFrac;
+            opts._uFrac = uFrac;
+            opts._vFrac = vFrac;
+            var ax = opts._axis = mockColorBarAxis(gd2, opts, zrange);
+            ax.position = thickFrac + (isVertical ? optsX + xpad / gs.w : optsY + ypad / gs.h);
+            var topOrBottom = ["top", "bottom"].indexOf(titleSide) !== -1;
+            if (isVertical && topOrBottom) {
+              ax.title.side = titleSide;
+              ax.titlex = optsX + xpad / gs.w;
+              ax.titley = vFrac + (title.side === "top" ? lenFrac - ypad / gs.h : ypad / gs.h);
+            }
+            if (!isVertical && !topOrBottom) {
+              ax.title.side = titleSide;
+              ax.titley = optsY + ypad / gs.h;
+              ax.titlex = vFrac + xpad / gs.w;
+            }
+            if (line.color && opts.tickmode === "auto") {
+              ax.tickmode = "linear";
+              ax.tick0 = levelsIn.start;
+              var dtick = levelsIn.size;
+              var autoNtick = Lib.constrain(lenPx / 50, 4, 15) + 1;
+              var dtFactor = (zrange[1] - zrange[0]) / ((opts.nticks || autoNtick) * dtick);
+              if (dtFactor > 1) {
+                var dtexp = Math.pow(10, Math.floor(Math.log(dtFactor) / Math.LN10));
+                dtick *= dtexp * Lib.roundUp(dtFactor / dtexp, [2, 5, 10]);
+                if ((Math.abs(levelsIn.start) / levelsIn.size + 1e-6) % 1 < 2e-6) {
+                  ax.tick0 = 0;
+                }
+              }
+              ax.dtick = dtick;
+            }
+            ax.domain = isVertical ? [
+              vFrac + ypad / gs.h,
+              vFrac + lenFrac - ypad / gs.h
+            ] : [
+              vFrac + xpad / gs.w,
+              vFrac + lenFrac - xpad / gs.w
+            ];
+            ax.setScale();
+            g2.attr("transform", strTranslate(Math.round(gs.l), Math.round(gs.t)));
+            var titleCont = g2.select("." + cn.cbtitleunshift).attr("transform", strTranslate(-Math.round(gs.l), -Math.round(gs.t)));
+            var ticklabelposition = ax.ticklabelposition;
+            var titleFontSize = ax.title.font.size;
+            var axLayer = g2.select("." + cn.cbaxis);
+            var titleEl;
+            var titleHeight = 0;
+            var titleWidth = 0;
+            function drawTitle(titleClass, titleOpts) {
+              var dfltTitleOpts = {
+                propContainer: ax,
+                propName: opts._propPrefix + "title.text",
+                traceIndex: opts._traceIndex,
+                _meta: opts._meta,
+                placeholder: fullLayout._dfltTitle.colorbar,
+                containerGroup: g2.select("." + cn.cbtitle)
+              };
+              var otherClass = titleClass.charAt(0) === "h" ? titleClass.slice(1) : "h" + titleClass;
+              g2.selectAll("." + otherClass + ",." + otherClass + "-math-group").remove();
+              Titles.draw(gd2, titleClass, extendFlat(dfltTitleOpts, titleOpts || {}));
+            }
+            function drawDummyTitle() {
+              if (isVertical && topOrBottom || !isVertical && !topOrBottom) {
+                var x2, y2;
+                if (titleSide === "top") {
+                  x2 = xpad + gs.l + posW * optsX;
+                  y2 = ypad + gs.t + posH * (1 - vFrac - lenFrac) + 3 + titleFontSize * 0.75;
+                }
+                if (titleSide === "bottom") {
+                  x2 = xpad + gs.l + posW * optsX;
+                  y2 = ypad + gs.t + posH * (1 - vFrac) - 3 - titleFontSize * 0.25;
+                }
+                if (titleSide === "right") {
+                  y2 = ypad + gs.t + posH * optsY + 3 + titleFontSize * 0.75;
+                  x2 = xpad + gs.l + posW * vFrac;
+                }
+                drawTitle(ax._id + "title", {
+                  attributes: { x: x2, y: y2, "text-anchor": isVertical ? "start" : "middle" }
+                });
+              }
+            }
+            function drawCbTitle() {
+              if (isVertical && !topOrBottom || !isVertical && topOrBottom) {
+                var pos = ax.position || 0;
+                var mid = ax._offset + ax._length / 2;
+                var x2, y2;
+                if (titleSide === "right") {
+                  y2 = mid;
+                  x2 = gs.l + posW * pos + 10 + titleFontSize * (ax.showticklabels ? 1 : 0.5);
+                } else {
+                  x2 = mid;
+                  if (titleSide === "bottom") {
+                    y2 = gs.t + posH * pos + 10 + (ticklabelposition.indexOf("inside") === -1 ? ax.tickfont.size : 0) + (ax.ticks !== "inside" ? opts.ticklen || 0 : 0);
+                  }
+                  if (titleSide === "top") {
+                    var nlines = title.text.split("<br>").length;
+                    y2 = gs.t + posH * pos + 10 - thickPx - LINE_SPACING * titleFontSize * nlines;
+                  }
+                }
+                drawTitle((isVertical ? (
+                  // the 'h' + is a hack to get around the fact that
+                  // convertToTspans rotates any 'y...' class by 90 degrees.
+                  // TODO: find a better way to control this.
+                  "h"
+                ) : "v") + ax._id + "title", {
+                  avoid: {
+                    selection: d3.select(gd2).selectAll("g." + ax._id + "tick"),
+                    side: titleSide,
+                    offsetTop: isVertical ? 0 : gs.t,
+                    offsetLeft: isVertical ? gs.l : 0,
+                    maxShift: isVertical ? fullLayout.width : fullLayout.height
+                  },
+                  attributes: { x: x2, y: y2, "text-anchor": "middle" },
+                  transform: { rotate: isVertical ? -90 : 0, offset: 0 }
+                });
+              }
+            }
+            function drawAxis() {
+              if (!isVertical && !topOrBottom || isVertical && topOrBottom) {
+                var titleGroup = g2.select("." + cn.cbtitle);
+                var titleText = titleGroup.select("text");
+                var titleTrans = [-outlinewidth / 2, outlinewidth / 2];
+                var mathJaxNode = titleGroup.select(".h" + ax._id + "title-math-group").node();
+                var lineSize = 15.6;
+                if (titleText.node()) {
+                  lineSize = parseInt(titleText.node().style.fontSize, 10) * LINE_SPACING;
+                }
+                var bb2;
+                if (mathJaxNode) {
+                  bb2 = Drawing.bBox(mathJaxNode);
+                  titleWidth = bb2.width;
+                  titleHeight = bb2.height;
+                  if (titleHeight > lineSize) {
+                    titleTrans[1] -= (titleHeight - lineSize) / 2;
+                  }
+                } else if (titleText.node() && !titleText.classed(cn.jsPlaceholder)) {
+                  bb2 = Drawing.bBox(titleText.node());
+                  titleWidth = bb2.width;
+                  titleHeight = bb2.height;
+                }
+                if (isVertical) {
+                  if (titleHeight) {
+                    titleHeight += 5;
+                    if (titleSide === "top") {
+                      ax.domain[1] -= titleHeight / gs.h;
+                      titleTrans[1] *= -1;
+                    } else {
+                      ax.domain[0] += titleHeight / gs.h;
+                      var nlines = svgTextUtils.lineCount(titleText);
+                      titleTrans[1] += (1 - nlines) * lineSize;
+                    }
+                    titleGroup.attr("transform", strTranslate(titleTrans[0], titleTrans[1]));
+                    ax.setScale();
+                  }
+                } else {
+                  if (titleWidth) {
+                    if (titleSide === "right") {
+                      ax.domain[0] += (titleWidth + titleFontSize / 2) / gs.w;
+                    }
+                    titleGroup.attr("transform", strTranslate(titleTrans[0], titleTrans[1]));
+                    ax.setScale();
+                  }
+                }
+              }
+              g2.selectAll("." + cn.cbfills + ",." + cn.cblines).attr(
+                "transform",
+                isVertical ? strTranslate(0, Math.round(gs.h * (1 - ax.domain[1]))) : strTranslate(Math.round(gs.w * ax.domain[0]), 0)
+              );
+              axLayer.attr(
+                "transform",
+                isVertical ? strTranslate(0, Math.round(-gs.t)) : strTranslate(Math.round(-gs.l), 0)
+              );
+              var fills = g2.select("." + cn.cbfills).selectAll("rect." + cn.cbfill).attr("style", "").data(fillLevels);
+              fills.enter().append("rect").classed(cn.cbfill, true).attr("style", "");
+              fills.exit().remove();
+              var zBounds = zrange.map(ax.c2p).map(Math.round).sort(function(a2, b2) {
+                return a2 - b2;
+              });
+              fills.each(function(d2, i2) {
+                var z2 = [
+                  i2 === 0 ? zrange[0] : (fillLevels[i2] + fillLevels[i2 - 1]) / 2,
+                  i2 === fillLevels.length - 1 ? zrange[1] : (fillLevels[i2] + fillLevels[i2 + 1]) / 2
+                ].map(ax.c2p).map(Math.round);
+                if (isVertical) {
+                  z2[1] = Lib.constrain(z2[1] + (z2[1] > z2[0]) ? 1 : -1, zBounds[0], zBounds[1]);
+                }
+                var fillEl = d3.select(this).attr(isVertical ? "x" : "y", uPx).attr(isVertical ? "y" : "x", d3.min(z2)).attr(isVertical ? "width" : "height", Math.max(thickPx, 2)).attr(isVertical ? "height" : "width", Math.max(d3.max(z2) - d3.min(z2), 2));
+                if (opts._fillgradient) {
+                  Drawing.gradient(fillEl, gd2, opts._id, isVertical ? "vertical" : "horizontalreversed", opts._fillgradient, "fill");
+                } else {
+                  var colorString = fillColormap(d2).replace("e-", "");
+                  fillEl.attr("fill", tinycolor(colorString).toHexString());
+                }
+              });
+              var lines = g2.select("." + cn.cblines).selectAll("path." + cn.cbline).data(line.color && line.width ? lineLevels : []);
+              lines.enter().append("path").classed(cn.cbline, true);
+              lines.exit().remove();
+              lines.each(function(d2) {
+                var a2 = uPx;
+                var b2 = Math.round(ax.c2p(d2)) + line.width / 2 % 1;
+                d3.select(this).attr(
+                  "d",
+                  "M" + (isVertical ? a2 + "," + b2 : b2 + "," + a2) + (isVertical ? "h" : "v") + thickPx
+                ).call(Drawing.lineGroupStyle, line.width, lineColormap(d2), line.dash);
+              });
+              axLayer.selectAll("g." + ax._id + "tick,path").remove();
+              var shift = uPx + thickPx + (outlinewidth || 0) / 2 - (opts.ticks === "outside" ? 1 : 0);
+              var vals = Axes.calcTicks(ax);
+              var tickSign = Axes.getTickSigns(ax)[2];
+              Axes.drawTicks(gd2, ax, {
+                vals: ax.ticks === "inside" ? Axes.clipEnds(ax, vals) : vals,
+                layer: axLayer,
+                path: Axes.makeTickPath(ax, shift, tickSign),
+                transFn: Axes.makeTransTickFn(ax)
+              });
+              return Axes.drawLabels(gd2, ax, {
+                vals,
+                layer: axLayer,
+                transFn: Axes.makeTransTickLabelFn(ax),
+                labelFns: Axes.makeLabelFns(ax, shift)
+              });
+            }
+            function positionCB() {
+              var bb2;
+              var innerThickness = thickPx + outlinewidth / 2;
+              if (ticklabelposition.indexOf("inside") === -1) {
+                bb2 = Drawing.bBox(axLayer.node());
+                innerThickness += isVertical ? bb2.width : bb2.height;
+              }
+              titleEl = titleCont.select("text");
+              var titleWidth2 = 0;
+              var topSideVertical = isVertical && titleSide === "top";
+              var rightSideHorizontal = !isVertical && titleSide === "right";
+              var moveY = 0;
+              if (titleEl.node() && !titleEl.classed(cn.jsPlaceholder)) {
+                var _titleHeight;
+                var mathJaxNode = titleCont.select(".h" + ax._id + "title-math-group").node();
+                if (mathJaxNode && (isVertical && topOrBottom || !isVertical && !topOrBottom)) {
+                  bb2 = Drawing.bBox(mathJaxNode);
+                  titleWidth2 = bb2.width;
+                  _titleHeight = bb2.height;
+                } else {
+                  bb2 = Drawing.bBox(titleCont.node());
+                  titleWidth2 = bb2.right - gs.l - (isVertical ? uPx : vPx);
+                  _titleHeight = bb2.bottom - gs.t - (isVertical ? vPx : uPx);
+                  if (!isVertical && titleSide === "top") {
+                    innerThickness += bb2.height;
+                    moveY = bb2.height;
+                  }
+                }
+                if (rightSideHorizontal) {
+                  titleEl.attr("transform", strTranslate(titleWidth2 / 2 + titleFontSize / 2, 0));
+                  titleWidth2 *= 2;
+                }
+                innerThickness = Math.max(
+                  innerThickness,
+                  isVertical ? titleWidth2 : _titleHeight
+                );
+              }
+              var outerThickness = (isVertical ? xpad : ypad) * 2 + innerThickness + borderwidth + outlinewidth / 2;
+              var hColorbarMoveTitle = 0;
+              if (!isVertical && title.text && yanchor === "bottom" && optsY <= 0) {
+                hColorbarMoveTitle = outerThickness / 2;
+                outerThickness += hColorbarMoveTitle;
+                moveY += hColorbarMoveTitle;
+              }
+              fullLayout._hColorbarMoveTitle = hColorbarMoveTitle;
+              fullLayout._hColorbarMoveCBTitle = moveY;
+              var extraW = borderwidth + outlinewidth;
+              var lx = (isVertical ? uPx : vPx) - extraW / 2 - (isVertical ? xpad : 0);
+              var ly = (isVertical ? vPx : uPx) - (isVertical ? lenPx : ypad + moveY - hColorbarMoveTitle);
+              g2.select("." + cn.cbbg).attr("x", lx).attr("y", ly).attr(isVertical ? "width" : "height", Math.max(outerThickness - hColorbarMoveTitle, 2)).attr(isVertical ? "height" : "width", Math.max(lenPx + extraW, 2)).call(Color2.fill, bgcolor).call(Color2.stroke, opts.bordercolor).style("stroke-width", borderwidth);
+              var moveX = rightSideHorizontal ? Math.max(titleWidth2 - 10, 0) : 0;
+              g2.selectAll("." + cn.cboutline).attr("x", (isVertical ? uPx : vPx + xpad) + moveX).attr("y", (isVertical ? vPx + ypad - lenPx : uPx) + (topSideVertical ? titleHeight : 0)).attr(isVertical ? "width" : "height", Math.max(thickPx, 2)).attr(isVertical ? "height" : "width", Math.max(lenPx - (isVertical ? 2 * ypad + titleHeight : 2 * xpad + moveX), 2)).call(Color2.stroke, opts.outlinecolor).style({
+                fill: "none",
+                "stroke-width": outlinewidth
+              });
+              var xShift = isVertical ? xRatio * outerThickness : 0;
+              var yShift = isVertical ? 0 : (1 - yRatio) * outerThickness - moveY;
+              xShift = isPaperX ? gs.l - xShift : -xShift;
+              yShift = isPaperY ? gs.t - yShift : -yShift;
+              g2.attr("transform", strTranslate(
+                xShift,
+                yShift
+              ));
+              if (!isVertical && (borderwidth || tinycolor(bgcolor).getAlpha() && !tinycolor.equals(fullLayout.paper_bgcolor, bgcolor))) {
+                var tickLabels = axLayer.selectAll("text");
+                var numTicks = tickLabels[0].length;
+                var border = g2.select("." + cn.cbbg).node();
+                var oBb = Drawing.bBox(border);
+                var oTr = Drawing.getTranslate(g2);
+                var TEXTPAD = 2;
+                tickLabels.each(function(d2, i2) {
+                  var first = 0;
+                  var last = numTicks - 1;
+                  if (i2 === first || i2 === last) {
+                    var iBb = Drawing.bBox(this);
+                    var iTr = Drawing.getTranslate(this);
+                    var deltaX;
+                    if (i2 === last) {
+                      var iRight = iBb.right + iTr.x;
+                      var oRight = oBb.right + oTr.x + vPx - borderwidth - TEXTPAD + optsX;
+                      deltaX = oRight - iRight;
+                      if (deltaX > 0) deltaX = 0;
+                    } else if (i2 === first) {
+                      var iLeft = iBb.left + iTr.x;
+                      var oLeft = oBb.left + oTr.x + vPx + borderwidth + TEXTPAD;
+                      deltaX = oLeft - iLeft;
+                      if (deltaX < 0) deltaX = 0;
+                    }
+                    if (deltaX) {
+                      if (numTicks < 3) {
+                        this.setAttribute(
+                          "transform",
+                          "translate(" + deltaX + ",0) " + this.getAttribute("transform")
+                        );
+                      } else {
+                        this.setAttribute("visibility", "hidden");
+                      }
+                    }
+                  }
+                });
+              }
+              var marginOpts = {};
+              var lFrac = FROM_TL[xanchor];
+              var rFrac = FROM_BR[xanchor];
+              var tFrac = FROM_TL[yanchor];
+              var bFrac = FROM_BR[yanchor];
+              var extraThickness = outerThickness - thickPx;
+              if (isVertical) {
+                if (lenmode === "pixels") {
+                  marginOpts.y = optsY;
+                  marginOpts.t = lenPx * tFrac;
+                  marginOpts.b = lenPx * bFrac;
+                } else {
+                  marginOpts.t = marginOpts.b = 0;
+                  marginOpts.yt = optsY + len2 * tFrac;
+                  marginOpts.yb = optsY - len2 * bFrac;
+                }
+                if (thicknessmode === "pixels") {
+                  marginOpts.x = optsX;
+                  marginOpts.l = outerThickness * lFrac;
+                  marginOpts.r = outerThickness * rFrac;
+                } else {
+                  marginOpts.l = extraThickness * lFrac;
+                  marginOpts.r = extraThickness * rFrac;
+                  marginOpts.xl = optsX - thickness * lFrac;
+                  marginOpts.xr = optsX + thickness * rFrac;
+                }
+              } else {
+                if (lenmode === "pixels") {
+                  marginOpts.x = optsX;
+                  marginOpts.l = lenPx * lFrac;
+                  marginOpts.r = lenPx * rFrac;
+                } else {
+                  marginOpts.l = marginOpts.r = 0;
+                  marginOpts.xl = optsX + len2 * lFrac;
+                  marginOpts.xr = optsX - len2 * rFrac;
+                }
+                if (thicknessmode === "pixels") {
+                  marginOpts.y = 1 - optsY;
+                  marginOpts.t = outerThickness * tFrac;
+                  marginOpts.b = outerThickness * bFrac;
+                } else {
+                  marginOpts.t = extraThickness * tFrac;
+                  marginOpts.b = extraThickness * bFrac;
+                  marginOpts.yt = optsY - thickness * tFrac;
+                  marginOpts.yb = optsY + thickness * bFrac;
+                }
+              }
+              var sideY = opts.y < 0.5 ? "b" : "t";
+              var sideX = opts.x < 0.5 ? "l" : "r";
+              gd2._fullLayout._reservedMargin[opts._id] = {};
+              var possibleReservedMargins = {
+                r: fullLayout.width - lx - xShift,
+                l: lx + marginOpts.r,
+                b: fullLayout.height - ly - yShift,
+                t: ly + marginOpts.b
+              };
+              if (isPaperX && isPaperY) {
+                Plots.autoMargin(gd2, opts._id, marginOpts);
+              } else if (isPaperX) {
+                gd2._fullLayout._reservedMargin[opts._id][sideY] = possibleReservedMargins[sideY];
+              } else if (isPaperY) {
+                gd2._fullLayout._reservedMargin[opts._id][sideX] = possibleReservedMargins[sideX];
+              } else {
+                if (isVertical) {
+                  gd2._fullLayout._reservedMargin[opts._id][sideX] = possibleReservedMargins[sideX];
+                } else {
+                  gd2._fullLayout._reservedMargin[opts._id][sideY] = possibleReservedMargins[sideY];
+                }
+              }
+            }
+            return Lib.syncOrAsync([
+              Plots.previousPromises,
+              drawDummyTitle,
+              drawAxis,
+              drawCbTitle,
+              Plots.previousPromises,
+              positionCB
+            ], gd2);
+          }
+          function makeEditable(g2, opts, gd2) {
+            var isVertical = opts.orientation === "v";
+            var fullLayout = gd2._fullLayout;
+            var gs = fullLayout._size;
+            var t02, xf2, yf2;
+            dragElement.init({
+              element: g2.node(),
+              gd: gd2,
+              prepFn: function() {
+                t02 = g2.attr("transform");
+                setCursor(g2);
+              },
+              moveFn: function(dx, dy) {
+                g2.attr("transform", t02 + strTranslate(dx, dy));
+                xf2 = dragElement.align(
+                  (isVertical ? opts._uFrac : opts._vFrac) + dx / gs.w,
+                  isVertical ? opts._thickFrac : opts._lenFrac,
+                  0,
+                  1,
+                  opts.xanchor
+                );
+                yf2 = dragElement.align(
+                  (isVertical ? opts._vFrac : 1 - opts._uFrac) - dy / gs.h,
+                  isVertical ? opts._lenFrac : opts._thickFrac,
+                  0,
+                  1,
+                  opts.yanchor
+                );
+                var csr = dragElement.getCursor(xf2, yf2, opts.xanchor, opts.yanchor);
+                setCursor(g2, csr);
+              },
+              doneFn: function() {
+                setCursor(g2);
+                if (xf2 !== void 0 && yf2 !== void 0) {
+                  var update = {};
+                  update[opts._propPrefix + "x"] = xf2;
+                  update[opts._propPrefix + "y"] = yf2;
+                  if (opts._traceIndex !== void 0) {
+                    Registry.call("_guiRestyle", gd2, update, opts._traceIndex);
+                  } else {
+                    Registry.call("_guiRelayout", gd2, update);
+                  }
+                }
+              }
+            });
+          }
+          function calcLevels(gd2, opts, zrange) {
+            var levelsIn = opts._levels;
+            var lineLevels = [];
+            var fillLevels = [];
+            var l2;
+            var i2;
+            var l0 = levelsIn.end + levelsIn.size / 100;
+            var ls = levelsIn.size;
+            var zr0 = 1.001 * zrange[0] - 1e-3 * zrange[1];
+            var zr1 = 1.001 * zrange[1] - 1e-3 * zrange[0];
+            for (i2 = 0; i2 < 1e5; i2++) {
+              l2 = levelsIn.start + i2 * ls;
+              if (ls > 0 ? l2 >= l0 : l2 <= l0) break;
+              if (l2 > zr0 && l2 < zr1) lineLevels.push(l2);
+            }
+            if (opts._fillgradient) {
+              fillLevels = [0];
+            } else if (typeof opts._fillcolor === "function") {
+              var fillLevelsIn = opts._filllevels;
+              if (fillLevelsIn) {
+                l0 = fillLevelsIn.end + fillLevelsIn.size / 100;
+                ls = fillLevelsIn.size;
+                for (i2 = 0; i2 < 1e5; i2++) {
+                  l2 = fillLevelsIn.start + i2 * ls;
+                  if (ls > 0 ? l2 >= l0 : l2 <= l0) break;
+                  if (l2 > zrange[0] && l2 < zrange[1]) fillLevels.push(l2);
+                }
+              } else {
+                fillLevels = lineLevels.map(function(v2) {
+                  return v2 - levelsIn.size / 2;
+                });
+                fillLevels.push(fillLevels[fillLevels.length - 1] + levelsIn.size);
+              }
+            } else if (opts._fillcolor && typeof opts._fillcolor === "string") {
+              fillLevels = [0];
+            }
+            if (levelsIn.size < 0) {
+              lineLevels.reverse();
+              fillLevels.reverse();
+            }
+            return { line: lineLevels, fill: fillLevels };
+          }
+          function mockColorBarAxis(gd2, opts, zrange) {
+            var fullLayout = gd2._fullLayout;
+            var isVertical = opts.orientation === "v";
+            var cbAxisIn = {
+              type: "linear",
+              range: zrange,
+              tickmode: opts.tickmode,
+              nticks: opts.nticks,
+              tick0: opts.tick0,
+              dtick: opts.dtick,
+              tickvals: opts.tickvals,
+              ticktext: opts.ticktext,
+              ticks: opts.ticks,
+              ticklen: opts.ticklen,
+              tickwidth: opts.tickwidth,
+              tickcolor: opts.tickcolor,
+              showticklabels: opts.showticklabels,
+              labelalias: opts.labelalias,
+              ticklabelposition: opts.ticklabelposition,
+              ticklabeloverflow: opts.ticklabeloverflow,
+              ticklabelstep: opts.ticklabelstep,
+              tickfont: opts.tickfont,
+              tickangle: opts.tickangle,
+              tickformat: opts.tickformat,
+              exponentformat: opts.exponentformat,
+              minexponent: opts.minexponent,
+              separatethousands: opts.separatethousands,
+              showexponent: opts.showexponent,
+              showtickprefix: opts.showtickprefix,
+              tickprefix: opts.tickprefix,
+              showticksuffix: opts.showticksuffix,
+              ticksuffix: opts.ticksuffix,
+              title: opts.title,
+              showline: true,
+              anchor: "free",
+              side: isVertical ? "right" : "bottom",
+              position: 1
+            };
+            var letter = isVertical ? "y" : "x";
+            var cbAxisOut = {
+              type: "linear",
+              _id: letter + opts._id
+            };
+            var axisOptions = {
+              letter,
+              font: fullLayout.font,
+              noAutotickangles: letter === "y",
+              noHover: true,
+              noTickson: true,
+              noTicklabelmode: true,
+              noInsideRange: true,
+              calendar: fullLayout.calendar
+              // not really necessary (yet?)
+            };
+            function coerce(attr, dflt) {
+              return Lib.coerce(cbAxisIn, cbAxisOut, axisLayoutAttrs, attr, dflt);
+            }
+            handleAxisDefaults(cbAxisIn, cbAxisOut, coerce, axisOptions, fullLayout);
+            handleAxisPositionDefaults(cbAxisIn, cbAxisOut, coerce, axisOptions);
+            return cbAxisOut;
+          }
+          module2.exports = {
+            draw
+          };
+        }
+      });
+      var require_colorbar = __commonJS({
+        "src/components/colorbar/index.js"(exports, module2) {
+          module2.exports = {
+            moduleType: "component",
+            name: "colorbar",
+            attributes: require_attributes7(),
+            supplyDefaults: require_defaults(),
+            draw: require_draw11().draw,
+            hasColorbar: require_has_colorbar()
+          };
+        }
+      });
+      var require_legend = __commonJS({
+        "src/components/legend/index.js"(exports, module2) {
+          module2.exports = {
+            moduleType: "component",
+            name: "legend",
+            layoutAttributes: require_attributes9(),
+            supplyLayoutDefaults: require_defaults3(),
+            draw: require_draw(),
+            style: require_style()
+          };
+        }
+      });
+      var require_locale_en = __commonJS({
+        "src/locale-en.js"(exports, module2) {
+          module2.exports = {
+            moduleType: "locale",
+            name: "en",
+            dictionary: {
+              "Click to enter Colorscale title": "Click to enter Colourscale title"
+            },
+            format: {
+              days: ["Sunday", "Monday", "Tuesday", "Wednesday", "Thursday", "Friday", "Saturday"],
+              shortDays: ["Sun", "Mon", "Tue", "Wed", "Thu", "Fri", "Sat"],
+              months: [
+                "January",
+                "February",
+                "March",
+                "April",
+                "May",
+                "June",
+                "July",
+                "August",
+                "September",
+                "October",
+                "November",
+                "December"
+              ],
+              shortMonths: [
+                "Jan",
+                "Feb",
+                "Mar",
+                "Apr",
+                "May",
+                "Jun",
+                "Jul",
+                "Aug",
+                "Sep",
+                "Oct",
+                "Nov",
+                "Dec"
+              ],
+              periods: ["AM", "PM"],
+              dateTime: "%a %b %e %X %Y",
+              date: "%d/%m/%Y",
+              time: "%H:%M:%S",
+              decimal: ".",
+              thousands: ",",
+              grouping: [3],
+              currency: ["$", ""],
+              year: "%Y",
+              month: "%b %Y",
+              dayMonth: "%b %-d",
+              dayMonthYear: "%b %-d, %Y"
+            }
+          };
+        }
+      });
+      var require_locale_en_us = __commonJS({
+        "src/locale-en-us.js"(exports, module2) {
+          module2.exports = {
+            moduleType: "locale",
+            name: "en-US",
+            dictionary: {
+              "Click to enter Colorscale title": "Click to enter Colorscale title"
+            },
+            format: {
+              date: "%m/%d/%Y"
+            }
+          };
+        }
+      });
+      var require_cloneplot = __commonJS({
+        "src/snapshot/cloneplot.js"(exports, module2) {
+          var Registry = require_registry();
+          var Lib = require_lib();
+          var extendFlat = Lib.extendFlat;
+          var extendDeep = Lib.extendDeep;
+          function cloneLayoutOverride(tileClass) {
+            var override;
+            switch (tileClass) {
+              case "themes__thumb":
+                override = {
+                  autosize: true,
+                  width: 150,
+                  height: 150,
+                  title: { text: "" },
+                  showlegend: false,
+                  margin: { l: 5, r: 5, t: 5, b: 5, pad: 0 },
+                  annotations: []
+                };
+                break;
+              case "thumbnail":
+                override = {
+                  title: { text: "" },
+                  hidesources: true,
+                  showlegend: false,
+                  borderwidth: 0,
+                  bordercolor: "",
+                  margin: { l: 1, r: 1, t: 1, b: 1, pad: 0 },
+                  annotations: []
+                };
+                break;
+              default:
+                override = {};
+            }
+            return override;
+          }
+          function keyIsAxis(keyName) {
+            var types = ["xaxis", "yaxis", "zaxis"];
+            return types.indexOf(keyName.slice(0, 5)) > -1;
+          }
+          module2.exports = function clonePlot(graphObj, options) {
+            var i2;
+            var oldData = graphObj.data;
+            var oldLayout = graphObj.layout;
+            var newData = extendDeep([], oldData);
+            var newLayout = extendDeep({}, oldLayout, cloneLayoutOverride(options.tileClass));
+            var context = graphObj._context || {};
+            if (options.width) newLayout.width = options.width;
+            if (options.height) newLayout.height = options.height;
+            if (options.tileClass === "thumbnail" || options.tileClass === "themes__thumb") {
+              newLayout.annotations = [];
+              var keys = Object.keys(newLayout);
+              for (i2 = 0; i2 < keys.length; i2++) {
+                if (keyIsAxis(keys[i2])) {
+                  newLayout[keys[i2]].title = { text: "" };
+                }
+              }
+              for (i2 = 0; i2 < newData.length; i2++) {
+                var trace = newData[i2];
+                trace.showscale = false;
+                if (trace.marker) trace.marker.showscale = false;
+                if (Registry.traceIs(trace, "pie-like")) trace.textposition = "none";
+              }
+            }
+            if (Array.isArray(options.annotations)) {
+              for (i2 = 0; i2 < options.annotations.length; i2++) {
+                newLayout.annotations.push(options.annotations[i2]);
+              }
+            }
+            var sceneIds = Object.keys(newLayout).filter(function(key) {
+              return key.match(/^scene\d*$/);
+            });
+            if (sceneIds.length) {
+              var axesImageOverride = {};
+              if (options.tileClass === "thumbnail") {
+                axesImageOverride = {
+                  title: { text: "" },
+                  showaxeslabels: false,
+                  showticklabels: false,
+                  linetickenable: false
+                };
+              }
+              for (i2 = 0; i2 < sceneIds.length; i2++) {
+                var scene = newLayout[sceneIds[i2]];
+                if (!scene.xaxis) {
+                  scene.xaxis = {};
+                }
+                if (!scene.yaxis) {
+                  scene.yaxis = {};
+                }
+                if (!scene.zaxis) {
+                  scene.zaxis = {};
+                }
+                extendFlat(scene.xaxis, axesImageOverride);
+                extendFlat(scene.yaxis, axesImageOverride);
+                extendFlat(scene.zaxis, axesImageOverride);
+                scene._scene = null;
+              }
+            }
+            var gd2 = document.createElement("div");
+            if (options.tileClass) gd2.className = options.tileClass;
+            var plotTile = {
+              gd: gd2,
+              td: gd2,
+              // for external (image server) compatibility
+              layout: newLayout,
+              data: newData,
+              config: {
+                staticPlot: options.staticPlot === void 0 ? true : options.staticPlot,
+                plotGlPixelRatio: options.plotGlPixelRatio === void 0 ? 2 : options.plotGlPixelRatio,
+                displaylogo: options.displaylogo || false,
+                showLink: options.showLink || false,
+                showTips: options.showTips || false,
+                mapboxAccessToken: context.mapboxAccessToken
+              }
+            };
+            if (options.setBackground !== "transparent") {
+              plotTile.config.setBackground = options.setBackground || "opaque";
+            }
+            plotTile.gd.defaultLayout = cloneLayoutOverride(options.tileClass);
+            return plotTile;
+          };
+        }
+      });
+      var require_toimage = __commonJS({
+        "src/snapshot/toimage.js"(exports, module2) {
+          var EventEmitter = require_events().EventEmitter;
+          var Registry = require_registry();
+          var Lib = require_lib();
+          var helpers = require_helpers10();
+          var clonePlot = require_cloneplot();
+          var toSVG = require_tosvg();
+          var svgToImg = require_svgtoimg();
+          function toImage(gd2, opts) {
+            var ev = new EventEmitter();
+            var clone = clonePlot(gd2, { format: "png" });
+            var clonedGd = clone.gd;
+            clonedGd.style.position = "absolute";
+            clonedGd.style.left = "-5000px";
+            document.body.appendChild(clonedGd);
+            function wait() {
+              var delay = helpers.getDelay(clonedGd._fullLayout);
+              setTimeout(function() {
+                var svg = toSVG(clonedGd);
+                var canvas2 = document.createElement("canvas");
+                canvas2.id = Lib.randstr();
+                ev = svgToImg({
+                  format: opts.format,
+                  width: clonedGd._fullLayout.width,
+                  height: clonedGd._fullLayout.height,
+                  canvas: canvas2,
+                  emitter: ev,
+                  svg
+                });
+                ev.clean = function() {
+                  if (clonedGd) document.body.removeChild(clonedGd);
+                };
+              }, delay);
+            }
+            var redrawFunc = helpers.getRedrawFunc(clonedGd);
+            Registry.call("_doPlot", clonedGd, clone.data, clone.layout, clone.config).then(redrawFunc).then(wait).catch(function(err) {
+              ev.emit("error", err);
+            });
+            return ev;
+          }
+          module2.exports = toImage;
+        }
+      });
+      var require_snapshot = __commonJS({
+        "src/snapshot/index.js"(exports, module2) {
+          var helpers = require_helpers10();
+          var Snapshot = {
+            getDelay: helpers.getDelay,
+            getRedrawFunc: helpers.getRedrawFunc,
+            clone: require_cloneplot(),
+            toSVG: require_tosvg(),
+            svgToImg: require_svgtoimg(),
+            toImage: require_toimage(),
+            downloadImage: require_download()
+          };
+          module2.exports = Snapshot;
+        }
+      });
+      var require_core = __commonJS({
+        "src/core.js"(exports) {
+          exports.version = require_version().version;
+          require_npo_src();
+          require_plotcss();
+          var Registry = require_registry();
+          var register2 = exports.register = Registry.register;
+          var plotApi = require_plot_api2();
+          var methodNames = Object.keys(plotApi);
+          for (i2 = 0; i2 < methodNames.length; i2++) {
+            name2 = methodNames[i2];
+            if (name2.charAt(0) !== "_") exports[name2] = plotApi[name2];
+            register2({
+              moduleType: "apiMethod",
+              name: name2,
+              fn: plotApi[name2]
+            });
+          }
+          var name2;
+          var i2;
+          register2(require_scatter());
+          register2([
+            require_annotations(),
+            require_annotations3d(),
+            require_selections(),
+            require_shapes(),
+            require_images(),
+            require_updatemenus(),
+            require_sliders(),
+            require_rangeslider(),
+            require_rangeselector(),
+            require_grid(),
+            require_errorbars(),
+            require_colorscale(),
+            require_colorbar(),
+            require_legend(),
+            // legend needs to come after shape | legend defaults depends on shapes
+            require_fx(),
+            // fx needs to come after legend | unified hover defaults depends on legends
+            require_modebar2()
+          ]);
+          register2([
+            require_locale_en(),
+            require_locale_en_us()
+          ]);
+          if (window.PlotlyLocales && Array.isArray(window.PlotlyLocales)) {
+            register2(window.PlotlyLocales);
+            delete window.PlotlyLocales;
+          }
+          exports.Icons = require_ploticon();
+          var Fx = require_fx();
+          var Plots = require_plots();
+          exports.Plots = {
+            resize: Plots.resize,
+            graphJson: Plots.graphJson,
+            sendDataToCloud: Plots.sendDataToCloud
+          };
+          exports.Fx = {
+            hover: Fx.hover,
+            unhover: Fx.unhover,
+            loneHover: Fx.loneHover,
+            loneUnhover: Fx.loneUnhover
+          };
+          exports.Snapshot = require_snapshot();
+          exports.PlotSchema = require_plot_schema();
+        }
+      });
+      var require_core2 = __commonJS({
+        "lib/core.js"(exports, module2) {
+          module2.exports = require_core();
+        }
+      });
+      var require_attributes23 = __commonJS({
+        "src/traces/bar/attributes.js"(exports, module2) {
+          var scatterAttrs = require_attributes12();
+          var axisHoverFormat = require_axis_format_attributes().axisHoverFormat;
+          var { hovertemplateAttrs, texttemplateAttrs, templatefallbackAttrs } = require_template_attributes();
+          var colorScaleAttrs = require_attributes8();
+          var fontAttrs = require_font_attributes();
+          var constants = require_constants9();
+          var pattern = require_attributes4().pattern;
+          var extendFlat = require_extend().extendFlat;
+          var textFontAttrs = fontAttrs({
+            editType: "calc",
+            arrayOk: true,
+            colorEditType: "style"
+          });
+          var scatterMarkerAttrs = scatterAttrs.marker;
+          var scatterMarkerLineAttrs = scatterMarkerAttrs.line;
+          var markerLineWidth = extendFlat({}, scatterMarkerLineAttrs.width, { dflt: 0 });
+          var markerLine = extendFlat(
+            {
+              width: markerLineWidth,
+              editType: "calc"
+            },
+            colorScaleAttrs("marker.line")
+          );
+          var marker = extendFlat(
+            {
+              line: markerLine,
+              editType: "calc"
+            },
+            colorScaleAttrs("marker"),
+            {
+              opacity: {
+                valType: "number",
+                arrayOk: true,
+                dflt: 1,
+                min: 0,
+                max: 1,
+                editType: "style"
+              },
+              pattern,
+              cornerradius: {
+                valType: "any",
+                editType: "calc"
+              }
+            }
+          );
+          module2.exports = {
+            x: scatterAttrs.x,
+            x0: scatterAttrs.x0,
+            dx: scatterAttrs.dx,
+            y: scatterAttrs.y,
+            y0: scatterAttrs.y0,
+            dy: scatterAttrs.dy,
+            xperiod: scatterAttrs.xperiod,
+            yperiod: scatterAttrs.yperiod,
+            xperiod0: scatterAttrs.xperiod0,
+            yperiod0: scatterAttrs.yperiod0,
+            xperiodalignment: scatterAttrs.xperiodalignment,
+            yperiodalignment: scatterAttrs.yperiodalignment,
+            xhoverformat: axisHoverFormat("x"),
+            yhoverformat: axisHoverFormat("y"),
+            text: scatterAttrs.text,
+            texttemplate: texttemplateAttrs({ editType: "plot" }, { keys: constants.eventDataKeys }),
+            texttemplatefallback: templatefallbackAttrs({ editType: "plot" }),
+            hovertext: scatterAttrs.hovertext,
+            hovertemplate: hovertemplateAttrs({}, { keys: constants.eventDataKeys }),
+            hovertemplatefallback: templatefallbackAttrs(),
+            textposition: {
+              valType: "enumerated",
+              values: ["inside", "outside", "auto", "none"],
+              dflt: "auto",
+              arrayOk: true,
+              editType: "calc"
+            },
+            insidetextanchor: {
+              valType: "enumerated",
+              values: ["end", "middle", "start"],
+              dflt: "end",
+              editType: "plot"
+            },
+            textangle: {
+              valType: "angle",
+              dflt: "auto",
+              editType: "plot"
+            },
+            textfont: extendFlat({}, textFontAttrs, {}),
+            insidetextfont: extendFlat({}, textFontAttrs, {}),
+            outsidetextfont: extendFlat({}, textFontAttrs, {}),
+            constraintext: {
+              valType: "enumerated",
+              values: ["inside", "outside", "both", "none"],
+              dflt: "both",
+              editType: "calc"
+            },
+            cliponaxis: extendFlat({}, scatterAttrs.cliponaxis, {}),
+            orientation: {
+              valType: "enumerated",
+              values: ["v", "h"],
+              editType: "calc+clearAxisTypes"
+            },
+            base: {
+              valType: "any",
+              dflt: null,
+              arrayOk: true,
+              editType: "calc"
+            },
+            offset: {
+              valType: "number",
+              dflt: null,
+              arrayOk: true,
+              editType: "calc"
+            },
+            width: {
+              valType: "number",
+              dflt: null,
+              min: 0,
+              arrayOk: true,
+              editType: "calc"
+            },
+            marker,
+            offsetgroup: scatterAttrs.offsetgroup,
+            alignmentgroup: scatterAttrs.alignmentgroup,
+            selected: {
+              marker: {
+                opacity: scatterAttrs.selected.marker.opacity,
+                color: scatterAttrs.selected.marker.color,
+                editType: "style"
+              },
+              textfont: scatterAttrs.selected.textfont,
+              editType: "style"
+            },
+            unselected: {
+              marker: {
+                opacity: scatterAttrs.unselected.marker.opacity,
+                color: scatterAttrs.unselected.marker.color,
+                editType: "style"
+              },
+              textfont: scatterAttrs.unselected.textfont,
+              editType: "style"
+            },
+            zorder: scatterAttrs.zorder
+          };
+        }
+      });
+      var require_layout_attributes6 = __commonJS({
+        "src/traces/bar/layout_attributes.js"(exports, module2) {
+          module2.exports = {
+            barmode: {
+              valType: "enumerated",
+              values: ["stack", "group", "overlay", "relative"],
+              dflt: "group",
+              editType: "calc"
+            },
+            barnorm: {
+              valType: "enumerated",
+              values: ["", "fraction", "percent"],
+              dflt: "",
+              editType: "calc"
+            },
+            bargap: {
+              valType: "number",
+              min: 0,
+              max: 1,
+              editType: "calc"
+            },
+            bargroupgap: {
+              valType: "number",
+              min: 0,
+              max: 1,
+              dflt: 0,
+              editType: "calc"
+            },
+            barcornerradius: {
+              valType: "any",
+              editType: "calc"
+            }
+          };
+        }
+      });
+      var require_style_defaults = __commonJS({
+        "src/traces/bar/style_defaults.js"(exports, module2) {
+          var Color2 = require_color();
+          var hasColorscale = require_helpers().hasColorscale;
+          var colorscaleDefaults = require_defaults2();
+          var coercePattern = require_lib().coercePattern;
+          module2.exports = function handleStyleDefaults(traceIn, traceOut, coerce, defaultColor, layout) {
+            var markerColor = coerce("marker.color", defaultColor);
+            var hasMarkerColorscale = hasColorscale(traceIn, "marker");
+            if (hasMarkerColorscale) {
+              colorscaleDefaults(
+                traceIn,
+                traceOut,
+                layout,
+                coerce,
+                { prefix: "marker.", cLetter: "c" }
+              );
+            }
+            coerce("marker.line.color", Color2.defaultLine);
+            if (hasColorscale(traceIn, "marker.line")) {
+              colorscaleDefaults(
+                traceIn,
+                traceOut,
+                layout,
+                coerce,
+                { prefix: "marker.line.", cLetter: "c" }
+              );
+            }
+            coerce("marker.line.width");
+            coerce("marker.opacity");
+            coercePattern(coerce, "marker.pattern", markerColor, hasMarkerColorscale);
+            coerce("selected.marker.color");
+            coerce("unselected.marker.color");
+          };
+        }
+      });
+      var require_defaults19 = __commonJS({
+        "src/traces/bar/defaults.js"(exports, module2) {
+          var isNumeric = require_fast_isnumeric();
+          var Lib = require_lib();
+          var Color2 = require_color();
+          var Registry = require_registry();
+          var handleXYDefaults = require_xy_defaults();
+          var handlePeriodDefaults = require_period_defaults();
+          var handleStyleDefaults = require_style_defaults();
+          var handleGroupingDefaults = require_grouping_defaults();
+          var attributes = require_attributes23();
+          var coerceFont = Lib.coerceFont;
+          function supplyDefaults(traceIn, traceOut, defaultColor, layout) {
+            function coerce(attr, dflt) {
+              return Lib.coerce(traceIn, traceOut, attributes, attr, dflt);
+            }
+            var len2 = handleXYDefaults(traceIn, traceOut, layout, coerce);
+            if (!len2) {
+              traceOut.visible = false;
+              return;
+            }
+            handlePeriodDefaults(traceIn, traceOut, layout, coerce);
+            coerce("xhoverformat");
+            coerce("yhoverformat");
+            coerce("zorder");
+            coerce("orientation", traceOut.x && !traceOut.y ? "h" : "v");
+            coerce("base");
+            coerce("offset");
+            coerce("width");
+            coerce("text");
+            coerce("hovertext");
+            coerce("hovertemplate");
+            coerce("hovertemplatefallback");
+            var textposition = coerce("textposition");
+            handleText(traceIn, traceOut, layout, coerce, textposition, {
+              moduleHasSelected: true,
+              moduleHasUnselected: true,
+              moduleHasConstrain: true,
+              moduleHasCliponaxis: true,
+              moduleHasTextangle: true,
+              moduleHasInsideanchor: true
+            });
+            handleStyleDefaults(traceIn, traceOut, coerce, defaultColor, layout);
+            var lineColor = (traceOut.marker.line || {}).color;
+            var errorBarsSupplyDefaults = Registry.getComponentMethod("errorbars", "supplyDefaults");
+            errorBarsSupplyDefaults(traceIn, traceOut, lineColor || Color2.defaultLine, { axis: "y" });
+            errorBarsSupplyDefaults(traceIn, traceOut, lineColor || Color2.defaultLine, { axis: "x", inherit: "y" });
+            Lib.coerceSelectionMarkerOpacity(traceOut, coerce);
+          }
+          function crossTraceDefaults(fullData, fullLayout) {
+            var traceIn, traceOut;
+            function coerce(attr, dflt) {
+              return Lib.coerce(traceOut._input, traceOut, attributes, attr, dflt);
+            }
+            for (var i2 = 0; i2 < fullData.length; i2++) {
+              traceOut = fullData[i2];
+              if (traceOut.type === "bar") {
+                traceIn = traceOut._input;
+                var r2 = coerce("marker.cornerradius", fullLayout.barcornerradius);
+                if (traceOut.marker) {
+                  traceOut.marker.cornerradius = validateCornerradius(r2);
+                }
+                handleGroupingDefaults(traceIn, traceOut, fullLayout, coerce, fullLayout.barmode);
+              }
+            }
+          }
+          function validateCornerradius(r2) {
+            if (isNumeric(r2)) {
+              r2 = +r2;
+              if (r2 >= 0) return r2;
+            } else if (typeof r2 === "string") {
+              r2 = r2.trim();
+              if (r2.slice(-1) === "%" && isNumeric(r2.slice(0, -1))) {
+                r2 = +r2.slice(0, -1);
+                if (r2 >= 0) return r2 + "%";
+              }
+            }
+            return void 0;
+          }
+          function handleText(traceIn, traceOut, layout, coerce, textposition, opts) {
+            opts = opts || {};
+            var moduleHasSelected = !(opts.moduleHasSelected === false);
+            var moduleHasUnselected = !(opts.moduleHasUnselected === false);
+            var moduleHasConstrain = !(opts.moduleHasConstrain === false);
+            var moduleHasCliponaxis = !(opts.moduleHasCliponaxis === false);
+            var moduleHasTextangle = !(opts.moduleHasTextangle === false);
+            var moduleHasInsideanchor = !(opts.moduleHasInsideanchor === false);
+            var hasPathbar = !!opts.hasPathbar;
+            var hasBoth = Array.isArray(textposition) || textposition === "auto";
+            var hasInside = hasBoth || textposition === "inside";
+            var hasOutside = hasBoth || textposition === "outside";
+            if (hasInside || hasOutside) {
+              var dfltFont = coerceFont(coerce, "textfont", layout.font);
+              var insideTextFontDefault = Lib.extendFlat({}, dfltFont);
+              var isTraceTextfontColorSet = traceIn.textfont && traceIn.textfont.color;
+              var isColorInheritedFromLayoutFont = !isTraceTextfontColorSet;
+              if (isColorInheritedFromLayoutFont) {
+                delete insideTextFontDefault.color;
+              }
+              coerceFont(coerce, "insidetextfont", insideTextFontDefault);
+              if (hasPathbar) {
+                var pathbarTextFontDefault = Lib.extendFlat({}, dfltFont);
+                if (isColorInheritedFromLayoutFont) {
+                  delete pathbarTextFontDefault.color;
+                }
+                coerceFont(coerce, "pathbar.textfont", pathbarTextFontDefault);
+              }
+              if (hasOutside) coerceFont(coerce, "outsidetextfont", dfltFont);
+              if (moduleHasSelected) coerce("selected.textfont.color");
+              if (moduleHasUnselected) coerce("unselected.textfont.color");
+              if (moduleHasConstrain) coerce("constraintext");
+              if (moduleHasCliponaxis) coerce("cliponaxis");
+              if (moduleHasTextangle) coerce("textangle");
+              coerce("texttemplate");
+              coerce("texttemplatefallback");
+            }
+            if (hasInside) {
+              if (moduleHasInsideanchor) coerce("insidetextanchor");
+            }
+          }
+          module2.exports = {
+            supplyDefaults,
+            crossTraceDefaults,
+            handleText,
+            validateCornerradius
+          };
+        }
+      });
+      var require_layout_defaults5 = __commonJS({
+        "src/traces/bar/layout_defaults.js"(exports, module2) {
+          var Registry = require_registry();
+          var Axes = require_axes();
+          var Lib = require_lib();
+          var layoutAttributes = require_layout_attributes6();
+          var validateCornerradius = require_defaults19().validateCornerradius;
+          module2.exports = function(layoutIn, layoutOut, fullData) {
+            function coerce(attr, dflt) {
+              return Lib.coerce(layoutIn, layoutOut, layoutAttributes, attr, dflt);
+            }
+            var hasBars = false;
+            var shouldBeGapless = false;
+            var gappedAnyway = false;
+            var usedSubplots = {};
+            var mode = coerce("barmode");
+            var isGroup = mode === "group";
+            for (var i2 = 0; i2 < fullData.length; i2++) {
+              var trace = fullData[i2];
+              if (Registry.traceIs(trace, "bar") && trace.visible) hasBars = true;
+              else continue;
+              var subploti = trace.xaxis + trace.yaxis;
+              if (isGroup) {
+                if (usedSubplots[subploti]) gappedAnyway = true;
+                usedSubplots[subploti] = true;
+              } else {
+                subploti += trace._input.offsetgroup;
+                if (usedSubplots.length > 0 && !usedSubplots[subploti]) gappedAnyway = true;
+                usedSubplots[subploti] = true;
+              }
+              if (trace.visible && trace.type === "histogram") {
+                var pa2 = Axes.getFromId(
+                  { _fullLayout: layoutOut },
+                  trace[trace.orientation === "v" ? "xaxis" : "yaxis"]
+                );
+                if (pa2.type !== "category") shouldBeGapless = true;
+              }
+            }
+            if (!hasBars) {
+              delete layoutOut.barmode;
+              return;
+            }
+            if (mode !== "overlay") coerce("barnorm");
+            coerce("bargap", shouldBeGapless && !gappedAnyway ? 0 : 0.2);
+            coerce("bargroupgap");
+            var r2 = coerce("barcornerradius");
+            layoutOut.barcornerradius = validateCornerradius(r2);
+          };
+        }
+      });
+      var require_arrays_to_calcdata2 = __commonJS({
+        "src/traces/bar/arrays_to_calcdata.js"(exports, module2) {
+          var Lib = require_lib();
+          module2.exports = function arraysToCalcdata(cd2, trace) {
+            for (var i2 = 0; i2 < cd2.length; i2++) cd2[i2].i = i2;
+            Lib.mergeArray(trace.text, cd2, "tx");
+            Lib.mergeArray(trace.hovertext, cd2, "htx");
+            var marker = trace.marker;
+            if (marker) {
+              Lib.mergeArray(marker.opacity, cd2, "mo", true);
+              Lib.mergeArray(marker.color, cd2, "mc");
+              var markerLine = marker.line;
+              if (markerLine) {
+                Lib.mergeArray(markerLine.color, cd2, "mlc");
+                Lib.mergeArrayCastPositive(markerLine.width, cd2, "mlw");
+              }
+            }
+          };
+        }
+      });
+      var require_calc5 = __commonJS({
+        "src/traces/bar/calc.js"(exports, module2) {
+          var Axes = require_axes();
+          var alignPeriod = require_align_period();
+          var hasColorscale = require_helpers().hasColorscale;
+          var colorscaleCalc = require_calc();
+          var arraysToCalcdata = require_arrays_to_calcdata2();
+          var calcSelection = require_calc_selection();
+          module2.exports = function calc(gd2, trace) {
+            var xa = Axes.getFromId(gd2, trace.xaxis || "x");
+            var ya2 = Axes.getFromId(gd2, trace.yaxis || "y");
+            var size, pos, origPos, pObj, hasPeriod, pLetter;
+            var sizeOpts = {
+              msUTC: !!(trace.base || trace.base === 0)
+            };
+            if (trace.orientation === "h") {
+              size = xa.makeCalcdata(trace, "x", sizeOpts);
+              origPos = ya2.makeCalcdata(trace, "y");
+              pObj = alignPeriod(trace, ya2, "y", origPos);
+              hasPeriod = !!trace.yperiodalignment;
+              pLetter = "y";
+            } else {
+              size = ya2.makeCalcdata(trace, "y", sizeOpts);
+              origPos = xa.makeCalcdata(trace, "x");
+              pObj = alignPeriod(trace, xa, "x", origPos);
+              hasPeriod = !!trace.xperiodalignment;
+              pLetter = "x";
+            }
+            pos = pObj.vals;
+            var serieslen = Math.min(pos.length, size.length);
+            var cd2 = new Array(serieslen);
+            for (var i2 = 0; i2 < serieslen; i2++) {
+              cd2[i2] = { p: pos[i2], s: size[i2] };
+              if (hasPeriod) {
+                cd2[i2].orig_p = origPos[i2];
+                cd2[i2][pLetter + "End"] = pObj.ends[i2];
+                cd2[i2][pLetter + "Start"] = pObj.starts[i2];
+              }
+              if (trace.ids) {
+                cd2[i2].id = String(trace.ids[i2]);
+              }
+            }
+            if (hasColorscale(trace, "marker")) {
+              colorscaleCalc(gd2, trace, {
+                vals: trace.marker.color,
+                containerStr: "marker",
+                cLetter: "c"
+              });
+            }
+            if (hasColorscale(trace, "marker.line")) {
+              colorscaleCalc(gd2, trace, {
+                vals: trace.marker.line.color,
+                containerStr: "marker.line",
+                cLetter: "c"
+              });
+            }
+            arraysToCalcdata(cd2, trace);
+            calcSelection(cd2, trace);
+            return cd2;
+          };
+        }
+      });
+      var require_uniform_text = __commonJS({
+        "src/traces/bar/uniform_text.js"(exports, module2) {
+          var d3 = require_d3();
+          var Lib = require_lib();
+          function resizeText(gd2, gTrace, traceType) {
+            var fullLayout = gd2._fullLayout;
+            var minSize = fullLayout["_" + traceType + "Text_minsize"];
+            if (minSize) {
+              var shouldHide = fullLayout.uniformtext.mode === "hide";
+              var selector;
+              switch (traceType) {
+                case "funnelarea":
+                case "pie":
+                case "sunburst":
+                  selector = "g.slice";
+                  break;
+                case "treemap":
+                case "icicle":
+                  selector = "g.slice, g.pathbar";
+                  break;
+                default:
+                  selector = "g.points > g.point";
+              }
+              gTrace.selectAll(selector).each(function(d2) {
+                var transform = d2.transform;
+                if (transform) {
+                  transform.scale = shouldHide && transform.hide ? 0 : minSize / transform.fontSize;
+                  var el2 = d3.select(this).select("text");
+                  Lib.setTransormAndDisplay(el2, transform);
+                }
+              });
+            }
+          }
+          function recordMinTextSize(traceType, transform, fullLayout) {
+            if (fullLayout.uniformtext.mode) {
+              var minKey = getMinKey(traceType);
+              var minSize = fullLayout.uniformtext.minsize;
+              var size = transform.scale * transform.fontSize;
+              transform.hide = size < minSize;
+              fullLayout[minKey] = fullLayout[minKey] || Infinity;
+              if (!transform.hide) {
+                fullLayout[minKey] = Math.min(
+                  fullLayout[minKey],
+                  Math.max(size, minSize)
+                );
+              }
+            }
+          }
+          function clearMinTextSize(traceType, fullLayout) {
+            var minKey = getMinKey(traceType);
+            fullLayout[minKey] = void 0;
+          }
+          function getMinKey(traceType) {
+            return "_" + traceType + "Text_minsize";
+          }
+          module2.exports = {
+            recordMinTextSize,
+            clearMinTextSize,
+            resizeText
+          };
+        }
+      });
+      var require_helpers12 = __commonJS({
+        "src/traces/bar/helpers.js"(exports) {
+          var isNumeric = require_fast_isnumeric();
+          var tinycolor = require_tinycolor();
+          var isArrayOrTypedArray = require_lib().isArrayOrTypedArray;
+          exports.coerceString = function(attributeDefinition, value, defaultValue) {
+            if (typeof value === "string") {
+              if (value || !attributeDefinition.noBlank) return value;
+            } else if (typeof value === "number" || value === true) {
+              if (!attributeDefinition.strict) return String(value);
+            }
+            return defaultValue !== void 0 ? defaultValue : attributeDefinition.dflt;
+          };
+          exports.coerceNumber = function(attributeDefinition, value, defaultValue) {
+            if (isNumeric(value)) {
+              value = +value;
+              var min = attributeDefinition.min;
+              var max = attributeDefinition.max;
+              var isOutOfBounds = min !== void 0 && value < min || max !== void 0 && value > max;
+              if (!isOutOfBounds) return value;
+            }
+            return defaultValue !== void 0 ? defaultValue : attributeDefinition.dflt;
+          };
+          exports.coerceColor = function(attributeDefinition, value, defaultValue) {
+            if (tinycolor(value).isValid()) return value;
+            return defaultValue !== void 0 ? defaultValue : attributeDefinition.dflt;
+          };
+          exports.coerceEnumerated = function(attributeDefinition, value, defaultValue) {
+            if (attributeDefinition.coerceNumber) value = +value;
+            if (attributeDefinition.values.indexOf(value) !== -1) return value;
+            return defaultValue !== void 0 ? defaultValue : attributeDefinition.dflt;
+          };
+          exports.getValue = function(arrayOrScalar, index) {
+            var value;
+            if (!isArrayOrTypedArray(arrayOrScalar)) value = arrayOrScalar;
+            else if (index < arrayOrScalar.length) value = arrayOrScalar[index];
+            return value;
+          };
+          exports.getLineWidth = function(trace, di2) {
+            var w2 = 0 < di2.mlw ? di2.mlw : !isArrayOrTypedArray(trace.marker.line.width) ? trace.marker.line.width : 0;
+            return w2;
+          };
+        }
+      });
+      var require_style4 = __commonJS({
+        "src/traces/bar/style.js"(exports, module2) {
+          var d3 = require_d3();
+          var Color2 = require_color();
+          var Drawing = require_drawing();
+          var Lib = require_lib();
+          var Registry = require_registry();
+          var resizeText = require_uniform_text().resizeText;
+          var attributes = require_attributes23();
+          var attributeTextFont = attributes.textfont;
+          var attributeInsideTextFont = attributes.insidetextfont;
+          var attributeOutsideTextFont = attributes.outsidetextfont;
+          var helpers = require_helpers12();
+          function style(gd2) {
+            var s2 = d3.select(gd2).selectAll('g[class^="barlayer"]').selectAll("g.trace");
+            resizeText(gd2, s2, "bar");
+            var barcount = s2.size();
+            var fullLayout = gd2._fullLayout;
+            s2.style("opacity", function(d2) {
+              return d2[0].trace.opacity;
+            }).each(function(d2) {
+              if (fullLayout.barmode === "stack" && barcount > 1 || fullLayout.bargap === 0 && fullLayout.bargroupgap === 0 && !d2[0].trace.marker.line.width) {
+                d3.select(this).attr("shape-rendering", "crispEdges");
+              }
+            });
+            s2.selectAll("g.points").each(function(d2) {
+              var sel = d3.select(this);
+              var trace = d2[0].trace;
+              stylePoints(sel, trace, gd2);
+            });
+            Registry.getComponentMethod("errorbars", "style")(s2);
+          }
+          function stylePoints(sel, trace, gd2) {
+            Drawing.pointStyle(sel.selectAll("path"), trace, gd2);
+            styleTextPoints(sel, trace, gd2);
+          }
+          function styleTextPoints(sel, trace, gd2) {
+            sel.selectAll("text").each(function(d2) {
+              var tx = d3.select(this);
+              var font = Lib.ensureUniformFontSize(gd2, determineFont(tx, d2, trace, gd2));
+              Drawing.font(tx, font);
+            });
+          }
+          function styleOnSelect(gd2, cd2, sel) {
+            var trace = cd2[0].trace;
+            if (trace.selectedpoints) {
+              stylePointsInSelectionMode(sel, trace, gd2);
+            } else {
+              stylePoints(sel, trace, gd2);
+              Registry.getComponentMethod("errorbars", "style")(sel);
+            }
+          }
+          function stylePointsInSelectionMode(s2, trace, gd2) {
+            Drawing.selectedPointStyle(s2.selectAll("path"), trace);
+            styleTextInSelectionMode(s2.selectAll("text"), trace, gd2);
+          }
+          function styleTextInSelectionMode(txs, trace, gd2) {
+            txs.each(function(d2) {
+              var tx = d3.select(this);
+              var font;
+              if (d2.selected) {
+                font = Lib.ensureUniformFontSize(gd2, determineFont(tx, d2, trace, gd2));
+                var selectedFontColor = trace.selected.textfont && trace.selected.textfont.color;
+                if (selectedFontColor) {
+                  font.color = selectedFontColor;
+                }
+                Drawing.font(tx, font);
+              } else {
+                Drawing.selectedTextStyle(tx, trace);
+              }
+            });
+          }
+          function determineFont(tx, d2, trace, gd2) {
+            var layoutFont = gd2._fullLayout.font;
+            var textFont = trace.textfont;
+            if (tx.classed("bartext-inside")) {
+              var barColor = getBarColor(d2, trace);
+              textFont = getInsideTextFont(trace, d2.i, layoutFont, barColor);
+            } else if (tx.classed("bartext-outside")) {
+              textFont = getOutsideTextFont(trace, d2.i, layoutFont);
+            }
+            return textFont;
+          }
+          function getTextFont(trace, index, defaultValue) {
+            return getFontValue(
+              attributeTextFont,
+              trace.textfont,
+              index,
+              defaultValue
+            );
+          }
+          function getInsideTextFont(trace, index, layoutFont, barColor) {
+            var defaultFont = getTextFont(trace, index, layoutFont);
+            var wouldFallBackToLayoutFont = trace._input.textfont === void 0 || trace._input.textfont.color === void 0 || Array.isArray(trace.textfont.color) && trace.textfont.color[index] === void 0;
+            if (wouldFallBackToLayoutFont) {
+              defaultFont = {
+                color: Color2.contrast(barColor),
+                family: defaultFont.family,
+                size: defaultFont.size,
+                weight: defaultFont.weight,
+                style: defaultFont.style,
+                variant: defaultFont.variant,
+                textcase: defaultFont.textcase,
+                lineposition: defaultFont.lineposition,
+                shadow: defaultFont.shadow
+              };
+            }
+            return getFontValue(
+              attributeInsideTextFont,
+              trace.insidetextfont,
+              index,
+              defaultFont
+            );
+          }
+          function getOutsideTextFont(trace, index, layoutFont) {
+            var defaultFont = getTextFont(trace, index, layoutFont);
+            return getFontValue(
+              attributeOutsideTextFont,
+              trace.outsidetextfont,
+              index,
+              defaultFont
+            );
+          }
+          function getFontValue(attributeDefinition, attributeValue, index, defaultValue) {
+            attributeValue = attributeValue || {};
+            var familyValue = helpers.getValue(attributeValue.family, index);
+            var sizeValue = helpers.getValue(attributeValue.size, index);
+            var colorValue = helpers.getValue(attributeValue.color, index);
+            var weightValue = helpers.getValue(attributeValue.weight, index);
+            var styleValue = helpers.getValue(attributeValue.style, index);
+            var variantValue = helpers.getValue(attributeValue.variant, index);
+            var textcaseValue = helpers.getValue(attributeValue.textcase, index);
+            var linepositionValue = helpers.getValue(attributeValue.lineposition, index);
+            var shadowValue = helpers.getValue(attributeValue.shadow, index);
+            return {
+              family: helpers.coerceString(
+                attributeDefinition.family,
+                familyValue,
+                defaultValue.family
+              ),
+              size: helpers.coerceNumber(
+                attributeDefinition.size,
+                sizeValue,
+                defaultValue.size
+              ),
+              color: helpers.coerceColor(
+                attributeDefinition.color,
+                colorValue,
+                defaultValue.color
+              ),
+              weight: helpers.coerceString(
+                attributeDefinition.weight,
+                weightValue,
+                defaultValue.weight
+              ),
+              style: helpers.coerceString(
+                attributeDefinition.style,
+                styleValue,
+                defaultValue.style
+              ),
+              variant: helpers.coerceString(
+                attributeDefinition.variant,
+                variantValue,
+                defaultValue.variant
+              ),
+              textcase: helpers.coerceString(
+                attributeDefinition.variant,
+                textcaseValue,
+                defaultValue.textcase
+              ),
+              lineposition: helpers.coerceString(
+                attributeDefinition.variant,
+                linepositionValue,
+                defaultValue.lineposition
+              ),
+              shadow: helpers.coerceString(
+                attributeDefinition.variant,
+                shadowValue,
+                defaultValue.shadow
+              )
+            };
+          }
+          function getBarColor(cd2, trace) {
+            if (trace.type === "waterfall") {
+              return trace[cd2.dir].marker.color;
+            }
+            return cd2.mcc || cd2.mc || trace.marker.color;
+          }
+          module2.exports = {
+            style,
+            styleTextPoints,
+            styleOnSelect,
+            getInsideTextFont,
+            getOutsideTextFont,
+            getBarColor,
+            resizeText
+          };
+        }
+      });
+      var require_plot3 = __commonJS({
+        "src/traces/bar/plot.js"(exports, module2) {
+          var d3 = require_d3();
+          var isNumeric = require_fast_isnumeric();
+          var Lib = require_lib();
+          var svgTextUtils = require_svg_text_utils();
+          var Color2 = require_color();
+          var Drawing = require_drawing();
+          var Registry = require_registry();
+          var tickText = require_axes().tickText;
+          var uniformText = require_uniform_text();
+          var recordMinTextSize = uniformText.recordMinTextSize;
+          var clearMinTextSize = uniformText.clearMinTextSize;
+          var style = require_style4();
+          var helpers = require_helpers12();
+          var constants = require_constants9();
+          var attributes = require_attributes23();
+          var attributeText = attributes.text;
+          var attributeTextPosition = attributes.textposition;
+          var appendArrayPointValue = require_helpers2().appendArrayPointValue;
+          var TEXTPAD = constants.TEXTPAD;
+          function keyFunc(d2) {
+            return d2.id;
+          }
+          function getKeyFunc(trace) {
+            if (trace.ids) {
+              return keyFunc;
+            }
+          }
+          function sign(v2) {
+            return (v2 > 0) - (v2 < 0);
+          }
+          function dirSign(a2, b2) {
+            return a2 < b2 ? 1 : -1;
+          }
+          function getXY(di2, xa, ya2, isHorizontal) {
+            var s2 = [];
+            var p2 = [];
+            var sAxis = isHorizontal ? xa : ya2;
+            var pAxis = isHorizontal ? ya2 : xa;
+            s2[0] = sAxis.c2p(di2.s0, true);
+            p2[0] = pAxis.c2p(di2.p0, true);
+            s2[1] = sAxis.c2p(di2.s1, true);
+            p2[1] = pAxis.c2p(di2.p1, true);
+            return isHorizontal ? [s2, p2] : [p2, s2];
+          }
+          function transition(selection, fullLayout, opts, makeOnCompleteCallback) {
+            if (!fullLayout.uniformtext.mode && hasTransition(opts)) {
+              var onComplete;
+              if (makeOnCompleteCallback) {
+                onComplete = makeOnCompleteCallback();
+              }
+              return selection.transition().duration(opts.duration).ease(opts.easing).each("end", function() {
+                onComplete && onComplete();
+              }).each("interrupt", function() {
+                onComplete && onComplete();
+              });
+            } else {
+              return selection;
+            }
+          }
+          function hasTransition(transitionOpts) {
+            return transitionOpts && transitionOpts.duration > 0;
+          }
+          function plot(gd2, plotinfo, cdModule, traceLayer, opts, makeOnCompleteCallback) {
+            var xa = plotinfo.xaxis;
+            var ya2 = plotinfo.yaxis;
+            var fullLayout = gd2._fullLayout;
+            var isStatic = gd2._context.staticPlot;
+            if (!opts) {
+              opts = {
+                mode: fullLayout.barmode,
+                norm: fullLayout.barmode,
+                gap: fullLayout.bargap,
+                groupgap: fullLayout.bargroupgap
+              };
+              clearMinTextSize("bar", fullLayout);
+            }
+            var bartraces = Lib.makeTraceGroups(traceLayer, cdModule, "trace bars").each(function(cd2) {
+              var plotGroup = d3.select(this);
+              var trace = cd2[0].trace;
+              var t4 = cd2[0].t;
+              var isWaterfall = trace.type === "waterfall";
+              var isFunnel = trace.type === "funnel";
+              var isHistogram = trace.type === "histogram";
+              var isBar = trace.type === "bar";
+              var shouldDisplayZeros = isBar || isFunnel;
+              var adjustPixel = 0;
+              if (isWaterfall && trace.connector.visible && trace.connector.mode === "between") {
+                adjustPixel = trace.connector.line.width / 2;
+              }
+              var isHorizontal = trace.orientation === "h";
+              var withTransition = hasTransition(opts);
+              var pointGroup = Lib.ensureSingle(plotGroup, "g", "points");
+              var keyFunc2 = getKeyFunc(trace);
+              var bars = pointGroup.selectAll("g.point").data(Lib.identity, keyFunc2);
+              bars.enter().append("g").classed("point", true);
+              bars.exit().remove();
+              bars.each(function(di2, i2) {
+                var bar = d3.select(this);
+                var xy = getXY(di2, xa, ya2, isHorizontal);
+                var x0 = xy[0][0];
+                var x1 = xy[0][1];
+                var y0 = xy[1][0];
+                var y1 = xy[1][1];
+                var isBlank = (isHorizontal ? x1 - x0 : y1 - y0) === 0;
+                if (isBlank && shouldDisplayZeros && helpers.getLineWidth(trace, di2)) {
+                  isBlank = false;
+                }
+                if (!isBlank) {
+                  isBlank = !isNumeric(x0) || !isNumeric(x1) || !isNumeric(y0) || !isNumeric(y1);
+                }
+                di2.isBlank = isBlank;
+                if (isBlank) {
+                  if (isHorizontal) {
+                    x1 = x0;
+                  } else {
+                    y1 = y0;
+                  }
+                }
+                if (adjustPixel && !isBlank) {
+                  if (isHorizontal) {
+                    x0 -= dirSign(x0, x1) * adjustPixel;
+                    x1 += dirSign(x0, x1) * adjustPixel;
+                  } else {
+                    y0 -= dirSign(y0, y1) * adjustPixel;
+                    y1 += dirSign(y0, y1) * adjustPixel;
+                  }
+                }
+                var lw;
+                var mc2;
+                if (trace.type === "waterfall") {
+                  if (!isBlank) {
+                    var cont = trace[di2.dir].marker;
+                    lw = cont.line.width;
+                    mc2 = cont.color;
+                  }
+                } else {
+                  lw = helpers.getLineWidth(trace, di2);
+                  mc2 = di2.mc || trace.marker.color;
+                }
+                function roundWithLine(v2) {
+                  var offset = d3.round(lw / 2 % 1, 2);
+                  return opts.gap === 0 && opts.groupgap === 0 ? d3.round(Math.round(v2) - offset, 2) : v2;
+                }
+                function expandToVisible(v2, vc2, hideZeroSpan) {
+                  if (hideZeroSpan && v2 === vc2) {
+                    return v2;
+                  }
+                  return Math.abs(v2 - vc2) >= 2 ? roundWithLine(v2) : (
+                    // but if it's very thin, expand it so it's
+                    // necessarily visible, even if it might overlap
+                    // its neighbor
+                    v2 > vc2 ? Math.ceil(v2) : Math.floor(v2)
+                  );
+                }
+                var op = Color2.opacity(mc2);
+                var fixpx = op < 1 || lw > 0.01 ? roundWithLine : expandToVisible;
+                if (!gd2._context.staticPlot) {
+                  x0 = fixpx(x0, x1, isHorizontal);
+                  x1 = fixpx(x1, x0, isHorizontal);
+                  y0 = fixpx(y0, y1, !isHorizontal);
+                  y1 = fixpx(y1, y0, !isHorizontal);
+                }
+                var c2p = isHorizontal ? xa.c2p : ya2.c2p;
+                var outerBound;
+                if (di2.s0 > 0) {
+                  outerBound = di2._sMax;
+                } else if (di2.s0 < 0) {
+                  outerBound = di2._sMin;
+                } else {
+                  outerBound = di2.s1 > 0 ? di2._sMax : di2._sMin;
+                }
+                function calcCornerRadius(crValue, crForm) {
+                  if (!crValue) return 0;
+                  var barWidth = isHorizontal ? Math.abs(y1 - y0) : Math.abs(x1 - x0);
+                  var barLength = isHorizontal ? Math.abs(x1 - x0) : Math.abs(y1 - y0);
+                  var stackedBarTotalLength = fixpx(Math.abs(c2p(outerBound, true) - c2p(0, true)));
+                  var maxRadius = di2.hasB ? Math.min(barWidth / 2, barLength / 2) : Math.min(barWidth / 2, stackedBarTotalLength);
+                  var crPx;
+                  if (crForm === "%") {
+                    var crPercent = Math.min(50, crValue);
+                    crPx = barWidth * (crPercent / 100);
+                  } else {
+                    crPx = crValue;
+                  }
+                  return fixpx(Math.max(Math.min(crPx, maxRadius), 0));
+                }
+                var r2 = isBar || isHistogram ? calcCornerRadius(t4.cornerradiusvalue, t4.cornerradiusform) : 0;
+                var path, h2;
+                var rectanglePath = "M" + x0 + "," + y0 + "V" + y1 + "H" + x1 + "V" + y0 + "Z";
+                var overhead = 0;
+                if (r2 && di2.s) {
+                  var refPoint = sign(di2.s0) === 0 || sign(di2.s) === sign(di2.s0) ? di2.s1 : di2.s0;
+                  overhead = fixpx(!di2.hasB ? Math.abs(c2p(outerBound, true) - c2p(refPoint, true)) : 0);
+                  if (overhead < r2) {
+                    var xdir = dirSign(x0, x1);
+                    var ydir = dirSign(y0, y1);
+                    var cornersweep = xdir === -ydir ? 1 : 0;
+                    if (isHorizontal) {
+                      if (di2.hasB) {
+                        path = "M" + (x0 + r2 * xdir) + "," + y0 + "A " + r2 + "," + r2 + " 0 0 " + cornersweep + " " + x0 + "," + (y0 + r2 * ydir) + "V" + (y1 - r2 * ydir) + "A " + r2 + "," + r2 + " 0 0 " + cornersweep + " " + (x0 + r2 * xdir) + "," + y1 + "H" + (x1 - r2 * xdir) + "A " + r2 + "," + r2 + " 0 0 " + cornersweep + " " + x1 + "," + (y1 - r2 * ydir) + "V" + (y0 + r2 * ydir) + "A " + r2 + "," + r2 + " 0 0 " + cornersweep + " " + (x1 - r2 * xdir) + "," + y0 + "Z";
+                      } else {
+                        h2 = Math.abs(x1 - x0) + overhead;
+                        var dy1 = h2 < r2 ? r2 - Math.sqrt(h2 * (2 * r2 - h2)) : 0;
+                        var dy2 = overhead > 0 ? Math.sqrt(overhead * (2 * r2 - overhead)) : 0;
+                        var xminfunc = xdir > 0 ? Math.max : Math.min;
+                        path = "M" + x0 + "," + y0 + "V" + (y1 - dy1 * ydir) + "H" + xminfunc(x1 - (r2 - overhead) * xdir, x0) + "A " + r2 + "," + r2 + " 0 0 " + cornersweep + " " + x1 + "," + (y1 - r2 * ydir - dy2) + "V" + (y0 + r2 * ydir + dy2) + "A " + r2 + "," + r2 + " 0 0 " + cornersweep + " " + xminfunc(x1 - (r2 - overhead) * xdir, x0) + "," + (y0 + dy1 * ydir) + "Z";
+                      }
+                    } else {
+                      if (di2.hasB) {
+                        path = "M" + (x0 + r2 * xdir) + "," + y0 + "A " + r2 + "," + r2 + " 0 0 " + cornersweep + " " + x0 + "," + (y0 + r2 * ydir) + "V" + (y1 - r2 * ydir) + "A " + r2 + "," + r2 + " 0 0 " + cornersweep + " " + (x0 + r2 * xdir) + "," + y1 + "H" + (x1 - r2 * xdir) + "A " + r2 + "," + r2 + " 0 0 " + cornersweep + " " + x1 + "," + (y1 - r2 * ydir) + "V" + (y0 + r2 * ydir) + "A " + r2 + "," + r2 + " 0 0 " + cornersweep + " " + (x1 - r2 * xdir) + "," + y0 + "Z";
+                      } else {
+                        h2 = Math.abs(y1 - y0) + overhead;
+                        var dx1 = h2 < r2 ? r2 - Math.sqrt(h2 * (2 * r2 - h2)) : 0;
+                        var dx2 = overhead > 0 ? Math.sqrt(overhead * (2 * r2 - overhead)) : 0;
+                        var yminfunc = ydir > 0 ? Math.max : Math.min;
+                        path = "M" + (x0 + dx1 * xdir) + "," + y0 + "V" + yminfunc(y1 - (r2 - overhead) * ydir, y0) + "A " + r2 + "," + r2 + " 0 0 " + cornersweep + " " + (x0 + r2 * xdir - dx2) + "," + y1 + "H" + (x1 - r2 * xdir + dx2) + "A " + r2 + "," + r2 + " 0 0 " + cornersweep + " " + (x1 - dx1 * xdir) + "," + yminfunc(y1 - (r2 - overhead) * ydir, y0) + "V" + y0 + "Z";
+                      }
+                    }
+                  } else {
+                    path = rectanglePath;
+                  }
+                } else {
+                  path = rectanglePath;
+                }
+                var sel = transition(Lib.ensureSingle(bar, "path"), fullLayout, opts, makeOnCompleteCallback);
+                sel.style("vector-effect", isStatic ? "none" : "non-scaling-stroke").attr("d", isNaN((x1 - x0) * (y1 - y0)) || isBlank && gd2._context.staticPlot ? "M0,0Z" : path).call(Drawing.setClipUrl, plotinfo.layerClipId, gd2);
+                if (!fullLayout.uniformtext.mode && withTransition) {
+                  var styleFns = Drawing.makePointStyleFns(trace);
+                  Drawing.singlePointStyle(di2, sel, trace, styleFns, gd2);
+                }
+                appendBarText(gd2, plotinfo, bar, cd2, i2, x0, x1, y0, y1, r2, overhead, opts, makeOnCompleteCallback);
+                if (plotinfo.layerClipId) {
+                  Drawing.hideOutsideRangePoint(di2, bar.select("text"), xa, ya2, trace.xcalendar, trace.ycalendar);
+                }
+              });
+              var hasClipOnAxisFalse = trace.cliponaxis === false;
+              Drawing.setClipUrl(plotGroup, hasClipOnAxisFalse ? null : plotinfo.layerClipId, gd2);
+            });
+            Registry.getComponentMethod("errorbars", "plot")(gd2, bartraces, plotinfo, opts);
+          }
+          function appendBarText(gd2, plotinfo, bar, cd2, i2, x0, x1, y0, y1, r2, overhead, opts, makeOnCompleteCallback) {
+            var xa = plotinfo.xaxis;
+            var ya2 = plotinfo.yaxis;
+            var fullLayout = gd2._fullLayout;
+            var textPosition;
+            function appendTextNode(bar2, text2, font2) {
+              var textSelection2 = Lib.ensureSingle(bar2, "text").text(text2).attr({
+                class: "bartext bartext-" + textPosition,
+                "text-anchor": "middle",
+                // prohibit tex interpretation until we can handle
+                // tex and regular text together
+                "data-notex": 1
+              }).call(Drawing.font, font2).call(svgTextUtils.convertToTspans, gd2);
+              return textSelection2;
+            }
+            var trace = cd2[0].trace;
+            var isHorizontal = trace.orientation === "h";
+            var text = getText(fullLayout, cd2, i2, xa, ya2);
+            textPosition = getTextPosition(trace, i2);
+            var inStackOrRelativeMode = opts.mode === "stack" || opts.mode === "relative";
+            var calcBar = cd2[i2];
+            var isOutmostBar = !inStackOrRelativeMode || calcBar._outmost;
+            var hasB = calcBar.hasB;
+            var barIsRounded = r2 && r2 - overhead > TEXTPAD;
+            if (!text || textPosition === "none" || (calcBar.isBlank || x0 === x1 || y0 === y1) && (textPosition === "auto" || textPosition === "inside")) {
+              bar.select("text").remove();
+              return;
+            }
+            var layoutFont = fullLayout.font;
+            var barColor = style.getBarColor(cd2[i2], trace);
+            var insideTextFont = style.getInsideTextFont(trace, i2, layoutFont, barColor);
+            var outsideTextFont = style.getOutsideTextFont(trace, i2, layoutFont);
+            var insidetextanchor = trace.insidetextanchor || "end";
+            var di2 = bar.datum();
+            if (isHorizontal) {
+              if (xa.type === "log" && di2.s0 <= 0) {
+                if (xa.range[0] < xa.range[1]) {
+                  x0 = 0;
+                } else {
+                  x0 = xa._length;
+                }
+              }
+            } else {
+              if (ya2.type === "log" && di2.s0 <= 0) {
+                if (ya2.range[0] < ya2.range[1]) {
+                  y0 = ya2._length;
+                } else {
+                  y0 = 0;
+                }
+              }
+            }
+            var lx = Math.abs(x1 - x0);
+            var ly = Math.abs(y1 - y0);
+            var barWidth = lx - 2 * TEXTPAD;
+            var barHeight = ly - 2 * TEXTPAD;
+            var textSelection;
+            var textBB;
+            var textWidth;
+            var textHeight;
+            var font;
+            if (textPosition === "outside") {
+              if (!isOutmostBar && !calcBar.hasB) textPosition = "inside";
+            }
+            if (textPosition === "auto") {
+              if (isOutmostBar) {
+                textPosition = "inside";
+                font = Lib.ensureUniformFontSize(gd2, insideTextFont);
+                textSelection = appendTextNode(bar, text, font);
+                textBB = Drawing.bBox(textSelection.node());
+                textWidth = textBB.width;
+                textHeight = textBB.height;
+                var textHasSize = textWidth > 0 && textHeight > 0;
+                var fitsInside;
+                if (barIsRounded) {
+                  if (hasB) {
+                    fitsInside = textfitsInsideBar(barWidth - 2 * r2, barHeight, textWidth, textHeight, isHorizontal) || textfitsInsideBar(barWidth, barHeight - 2 * r2, textWidth, textHeight, isHorizontal);
+                  } else if (isHorizontal) {
+                    fitsInside = textfitsInsideBar(barWidth - (r2 - overhead), barHeight, textWidth, textHeight, isHorizontal) || textfitsInsideBar(
+                      barWidth,
+                      barHeight - 2 * (r2 - overhead),
+                      textWidth,
+                      textHeight,
+                      isHorizontal
+                    );
+                  } else {
+                    fitsInside = textfitsInsideBar(barWidth, barHeight - (r2 - overhead), textWidth, textHeight, isHorizontal) || textfitsInsideBar(
+                      barWidth - 2 * (r2 - overhead),
+                      barHeight,
+                      textWidth,
+                      textHeight,
+                      isHorizontal
+                    );
+                  }
+                } else {
+                  fitsInside = textfitsInsideBar(barWidth, barHeight, textWidth, textHeight, isHorizontal);
+                }
+                if (textHasSize && fitsInside) {
+                  textPosition = "inside";
+                } else {
+                  textPosition = "outside";
+                  textSelection.remove();
+                  textSelection = null;
+                }
+              } else {
+                textPosition = "inside";
+              }
+            }
+            if (!textSelection) {
+              font = Lib.ensureUniformFontSize(gd2, textPosition === "outside" ? outsideTextFont : insideTextFont);
+              textSelection = appendTextNode(bar, text, font);
+              var currentTransform = textSelection.attr("transform");
+              textSelection.attr("transform", "");
+              textBB = Drawing.bBox(textSelection.node()), textWidth = textBB.width, textHeight = textBB.height;
+              textSelection.attr("transform", currentTransform);
+              if (textWidth <= 0 || textHeight <= 0) {
+                textSelection.remove();
+                return;
+              }
+            }
+            var angle2 = trace.textangle;
+            var transform, constrained;
+            if (textPosition === "outside") {
+              constrained = trace.constraintext === "both" || trace.constraintext === "outside";
+              transform = toMoveOutsideBar(x0, x1, y0, y1, textBB, {
+                isHorizontal,
+                constrained,
+                angle: angle2
+              });
+            } else {
+              constrained = trace.constraintext === "both" || trace.constraintext === "inside";
+              transform = toMoveInsideBar(x0, x1, y0, y1, textBB, {
+                isHorizontal,
+                constrained,
+                angle: angle2,
+                anchor: insidetextanchor,
+                hasB,
+                r: r2,
+                overhead
+              });
+            }
+            transform.fontSize = font.size;
+            recordMinTextSize(trace.type === "histogram" ? "bar" : trace.type, transform, fullLayout);
+            calcBar.transform = transform;
+            var s2 = transition(textSelection, fullLayout, opts, makeOnCompleteCallback);
+            Lib.setTransormAndDisplay(s2, transform);
+          }
+          function textfitsInsideBar(barWidth, barHeight, textWidth, textHeight, isHorizontal) {
+            if (barWidth < 0 || barHeight < 0) return false;
+            var fitsInside = textWidth <= barWidth && textHeight <= barHeight;
+            var fitsInsideIfRotated = textWidth <= barHeight && textHeight <= barWidth;
+            var fitsInsideIfShrunk = isHorizontal ? barWidth >= textWidth * (barHeight / textHeight) : barHeight >= textHeight * (barWidth / textWidth);
+            return fitsInside || fitsInsideIfRotated || fitsInsideIfShrunk;
+          }
+          function getRotateFromAngle(angle2) {
+            return angle2 === "auto" ? 0 : angle2;
+          }
+          function getRotatedTextSize(textBB, rotate2) {
+            var a2 = Math.PI / 180 * rotate2;
+            var absSin = Math.abs(Math.sin(a2));
+            var absCos = Math.abs(Math.cos(a2));
+            return {
+              x: textBB.width * absCos + textBB.height * absSin,
+              y: textBB.width * absSin + textBB.height * absCos
+            };
+          }
+          function toMoveInsideBar(x0, x1, y0, y1, textBB, opts) {
+            var isHorizontal = !!opts.isHorizontal;
+            var constrained = !!opts.constrained;
+            var angle2 = opts.angle || 0;
+            var anchor = opts.anchor;
+            var isEnd = anchor === "end";
+            var isStart = anchor === "start";
+            var leftToRight = opts.leftToRight || 0;
+            var toRight = (leftToRight + 1) / 2;
+            var toLeft = 1 - toRight;
+            var hasB = opts.hasB;
+            var r2 = opts.r;
+            var overhead = opts.overhead;
+            var textWidth = textBB.width;
+            var textHeight = textBB.height;
+            var lx = Math.abs(x1 - x0);
+            var ly = Math.abs(y1 - y0);
+            var textpad = lx > 2 * TEXTPAD && ly > 2 * TEXTPAD ? TEXTPAD : 0;
+            lx -= 2 * textpad;
+            ly -= 2 * textpad;
+            var rotate2 = getRotateFromAngle(angle2);
+            if (angle2 === "auto" && !(textWidth <= lx && textHeight <= ly) && (textWidth > lx || textHeight > ly) && (!(textWidth > ly || textHeight > lx) || textWidth < textHeight !== lx < ly)) {
+              rotate2 += 90;
+            }
+            var t4 = getRotatedTextSize(textBB, rotate2);
+            var scale2, padForRounding;
+            if (r2 && r2 - overhead > TEXTPAD) {
+              var scaleAndPad = scaleTextForRoundedBar(x0, x1, y0, y1, t4, r2, overhead, isHorizontal, hasB);
+              scale2 = scaleAndPad.scale;
+              padForRounding = scaleAndPad.pad;
+            } else {
+              scale2 = 1;
+              if (constrained) {
+                scale2 = Math.min(1, lx / t4.x, ly / t4.y);
+              }
+              padForRounding = 0;
+            }
+            var textX = textBB.left * toLeft + textBB.right * toRight;
+            var textY = (textBB.top + textBB.bottom) / 2;
+            var targetX = (x0 + TEXTPAD) * toLeft + (x1 - TEXTPAD) * toRight;
+            var targetY = (y0 + y1) / 2;
+            var anchorX = 0;
+            var anchorY = 0;
+            if (isStart || isEnd) {
+              var extrapad = (isHorizontal ? t4.x : t4.y) / 2;
+              if (r2 && (isEnd || hasB)) {
+                textpad += padForRounding;
+              }
+              var dir = isHorizontal ? dirSign(x0, x1) : dirSign(y0, y1);
+              if (isHorizontal) {
+                if (isStart) {
+                  targetX = x0 + dir * textpad;
+                  anchorX = -dir * extrapad;
+                } else {
+                  targetX = x1 - dir * textpad;
+                  anchorX = dir * extrapad;
+                }
+              } else {
+                if (isStart) {
+                  targetY = y0 + dir * textpad;
+                  anchorY = -dir * extrapad;
+                } else {
+                  targetY = y1 - dir * textpad;
+                  anchorY = dir * extrapad;
+                }
+              }
+            }
+            return {
+              textX,
+              textY,
+              targetX,
+              targetY,
+              anchorX,
+              anchorY,
+              scale: scale2,
+              rotate: rotate2
+            };
+          }
+          function scaleTextForRoundedBar(x0, x1, y0, y1, t4, r2, overhead, isHorizontal, hasB) {
+            var barWidth = Math.max(0, Math.abs(x1 - x0) - 2 * TEXTPAD);
+            var barHeight = Math.max(0, Math.abs(y1 - y0) - 2 * TEXTPAD);
+            var R2 = r2 - TEXTPAD;
+            var clippedR = overhead ? R2 - Math.sqrt(R2 * R2 - (R2 - overhead) * (R2 - overhead)) : R2;
+            var rX = hasB ? R2 * 2 : isHorizontal ? R2 - overhead : 2 * clippedR;
+            var rY = hasB ? R2 * 2 : isHorizontal ? 2 * clippedR : R2 - overhead;
+            var a2, b2, c2;
+            var scale2, pad;
+            if (t4.y / t4.x >= barHeight / (barWidth - rX)) {
+              scale2 = barHeight / t4.y;
+            } else if (t4.y / t4.x <= (barHeight - rY) / barWidth) {
+              scale2 = barWidth / t4.x;
+            } else if (!hasB && isHorizontal) {
+              a2 = t4.x * t4.x + t4.y * t4.y / 4;
+              b2 = -2 * t4.x * (barWidth - R2) - t4.y * (barHeight / 2 - R2);
+              c2 = (barWidth - R2) * (barWidth - R2) + (barHeight / 2 - R2) * (barHeight / 2 - R2) - R2 * R2;
+              scale2 = (-b2 + Math.sqrt(b2 * b2 - 4 * a2 * c2)) / (2 * a2);
+            } else if (!hasB) {
+              a2 = t4.x * t4.x / 4 + t4.y * t4.y;
+              b2 = -t4.x * (barWidth / 2 - R2) - 2 * t4.y * (barHeight - R2);
+              c2 = (barWidth / 2 - R2) * (barWidth / 2 - R2) + (barHeight - R2) * (barHeight - R2) - R2 * R2;
+              scale2 = (-b2 + Math.sqrt(b2 * b2 - 4 * a2 * c2)) / (2 * a2);
+            } else {
+              a2 = (t4.x * t4.x + t4.y * t4.y) / 4;
+              b2 = -t4.x * (barWidth / 2 - R2) - t4.y * (barHeight / 2 - R2);
+              c2 = (barWidth / 2 - R2) * (barWidth / 2 - R2) + (barHeight / 2 - R2) * (barHeight / 2 - R2) - R2 * R2;
+              scale2 = (-b2 + Math.sqrt(b2 * b2 - 4 * a2 * c2)) / (2 * a2);
+            }
+            scale2 = Math.min(1, scale2);
+            if (isHorizontal) {
+              pad = Math.max(
+                0,
+                R2 - Math.sqrt(
+                  Math.max(0, R2 * R2 - (R2 - (barHeight - t4.y * scale2) / 2) * (R2 - (barHeight - t4.y * scale2) / 2))
+                ) - overhead
+              );
+            } else {
+              pad = Math.max(
+                0,
+                R2 - Math.sqrt(
+                  Math.max(0, R2 * R2 - (R2 - (barWidth - t4.x * scale2) / 2) * (R2 - (barWidth - t4.x * scale2) / 2))
+                ) - overhead
+              );
+            }
+            return { scale: scale2, pad };
+          }
+          function toMoveOutsideBar(x0, x1, y0, y1, textBB, opts) {
+            var isHorizontal = !!opts.isHorizontal;
+            var constrained = !!opts.constrained;
+            var angle2 = opts.angle || 0;
+            var textWidth = textBB.width;
+            var textHeight = textBB.height;
+            var lx = Math.abs(x1 - x0);
+            var ly = Math.abs(y1 - y0);
+            var textpad;
+            if (isHorizontal) {
+              textpad = ly > 2 * TEXTPAD ? TEXTPAD : 0;
+            } else {
+              textpad = lx > 2 * TEXTPAD ? TEXTPAD : 0;
+            }
+            var scale2 = 1;
+            if (constrained) {
+              scale2 = isHorizontal ? Math.min(1, ly / textHeight) : Math.min(1, lx / textWidth);
+            }
+            var rotate2 = getRotateFromAngle(angle2);
+            var t4 = getRotatedTextSize(textBB, rotate2);
+            var extrapad = (isHorizontal ? t4.x : t4.y) / 2;
+            var textX = (textBB.left + textBB.right) / 2;
+            var textY = (textBB.top + textBB.bottom) / 2;
+            var targetX = (x0 + x1) / 2;
+            var targetY = (y0 + y1) / 2;
+            var anchorX = 0;
+            var anchorY = 0;
+            var dir = isHorizontal ? dirSign(x1, x0) : dirSign(y0, y1);
+            if (isHorizontal) {
+              targetX = x1 - dir * textpad;
+              anchorX = dir * extrapad;
+            } else {
+              targetY = y1 + dir * textpad;
+              anchorY = -dir * extrapad;
+            }
+            return {
+              textX,
+              textY,
+              targetX,
+              targetY,
+              anchorX,
+              anchorY,
+              scale: scale2,
+              rotate: rotate2
+            };
+          }
+          function getText(fullLayout, cd2, index, xa, ya2) {
+            var trace = cd2[0].trace;
+            var texttemplate = trace.texttemplate;
+            var value;
+            if (texttemplate) {
+              value = calcTexttemplate(fullLayout, cd2, index, xa, ya2);
+            } else if (trace.textinfo) {
+              value = calcTextinfo(cd2, index, xa, ya2);
+            } else {
+              value = helpers.getValue(trace.text, index);
+            }
+            return helpers.coerceString(attributeText, value);
+          }
+          function getTextPosition(trace, index) {
+            var value = helpers.getValue(trace.textposition, index);
+            return helpers.coerceEnumerated(attributeTextPosition, value);
+          }
+          function calcTexttemplate(fullLayout, cd2, index, xa, ya2) {
+            var trace = cd2[0].trace;
+            var texttemplate = Lib.castOption(trace, index, "texttemplate");
+            if (!texttemplate) return "";
+            var isHistogram = trace.type === "histogram";
+            var isWaterfall = trace.type === "waterfall";
+            var isFunnel = trace.type === "funnel";
+            var isHorizontal = trace.orientation === "h";
+            var pLetter, pAxis;
+            var vLetter, vAxis;
+            if (isHorizontal) {
+              pLetter = "y";
+              pAxis = ya2;
+              vLetter = "x";
+              vAxis = xa;
+            } else {
+              pLetter = "x";
+              pAxis = xa;
+              vLetter = "y";
+              vAxis = ya2;
+            }
+            function formatLabel(u2) {
+              return tickText(pAxis, pAxis.c2l(u2), true).text;
+            }
+            function formatNumber(v2) {
+              return tickText(vAxis, vAxis.c2l(v2), true).text;
+            }
+            var cdi = cd2[index];
+            var obj = {};
+            obj.label = cdi.p;
+            obj.labelLabel = obj[pLetter + "Label"] = formatLabel(cdi.p);
+            var tx = Lib.castOption(trace, cdi.i, "text");
+            if (tx === 0 || tx) obj.text = tx;
+            obj.value = cdi.s;
+            obj.valueLabel = obj[vLetter + "Label"] = formatNumber(cdi.s);
+            var pt2 = {};
+            appendArrayPointValue(pt2, trace, cdi.i);
+            if (isHistogram || pt2.x === void 0) pt2.x = isHorizontal ? obj.value : obj.label;
+            if (isHistogram || pt2.y === void 0) pt2.y = isHorizontal ? obj.label : obj.value;
+            if (isHistogram || pt2.xLabel === void 0) pt2.xLabel = isHorizontal ? obj.valueLabel : obj.labelLabel;
+            if (isHistogram || pt2.yLabel === void 0) pt2.yLabel = isHorizontal ? obj.labelLabel : obj.valueLabel;
+            if (isWaterfall) {
+              obj.delta = +cdi.rawS || cdi.s;
+              obj.deltaLabel = formatNumber(obj.delta);
+              obj.final = cdi.v;
+              obj.finalLabel = formatNumber(obj.final);
+              obj.initial = obj.final - obj.delta;
+              obj.initialLabel = formatNumber(obj.initial);
+            }
+            if (isFunnel) {
+              obj.value = cdi.s;
+              obj.valueLabel = formatNumber(obj.value);
+              obj.percentInitial = cdi.begR;
+              obj.percentInitialLabel = Lib.formatPercent(cdi.begR);
+              obj.percentPrevious = cdi.difR;
+              obj.percentPreviousLabel = Lib.formatPercent(cdi.difR);
+              obj.percentTotal = cdi.sumR;
+              obj.percenTotalLabel = Lib.formatPercent(cdi.sumR);
+            }
+            var customdata = Lib.castOption(trace, cdi.i, "customdata");
+            if (customdata) obj.customdata = customdata;
+            return Lib.texttemplateString({
+              data: [pt2, obj, trace._meta],
+              fallback: trace.texttemplatefallback,
+              labels: obj,
+              locale: fullLayout._d3locale,
+              template: texttemplate
+            });
+          }
+          function calcTextinfo(cd2, index, xa, ya2) {
+            var trace = cd2[0].trace;
+            var isHorizontal = trace.orientation === "h";
+            var isWaterfall = trace.type === "waterfall";
+            var isFunnel = trace.type === "funnel";
+            function formatLabel(u2) {
+              var pAxis = isHorizontal ? ya2 : xa;
+              return tickText(pAxis, u2, true).text;
+            }
+            function formatNumber(v2) {
+              var sAxis = isHorizontal ? xa : ya2;
+              return tickText(sAxis, +v2, true).text;
+            }
+            var textinfo = trace.textinfo;
+            var cdi = cd2[index];
+            var parts = textinfo.split("+");
+            var text = [];
+            var tx;
+            var hasFlag = function(flag) {
+              return parts.indexOf(flag) !== -1;
+            };
+            if (hasFlag("label")) {
+              text.push(formatLabel(cd2[index].p));
+            }
+            if (hasFlag("text")) {
+              tx = Lib.castOption(trace, cdi.i, "text");
+              if (tx === 0 || tx) text.push(tx);
+            }
+            if (isWaterfall) {
+              var delta = +cdi.rawS || cdi.s;
+              var final = cdi.v;
+              var initial = final - delta;
+              if (hasFlag("initial")) text.push(formatNumber(initial));
+              if (hasFlag("delta")) text.push(formatNumber(delta));
+              if (hasFlag("final")) text.push(formatNumber(final));
+            }
+            if (isFunnel) {
+              if (hasFlag("value")) text.push(formatNumber(cdi.s));
+              var nPercent = 0;
+              if (hasFlag("percent initial")) nPercent++;
+              if (hasFlag("percent previous")) nPercent++;
+              if (hasFlag("percent total")) nPercent++;
+              var hasMultiplePercents = nPercent > 1;
+              if (hasFlag("percent initial")) {
+                tx = Lib.formatPercent(cdi.begR);
+                if (hasMultiplePercents) tx += " of initial";
+                text.push(tx);
+              }
+              if (hasFlag("percent previous")) {
+                tx = Lib.formatPercent(cdi.difR);
+                if (hasMultiplePercents) tx += " of previous";
+                text.push(tx);
+              }
+              if (hasFlag("percent total")) {
+                tx = Lib.formatPercent(cdi.sumR);
+                if (hasMultiplePercents) tx += " of total";
+                text.push(tx);
+              }
+            }
+            return text.join("<br>");
+          }
+          module2.exports = {
+            plot,
+            toMoveInsideBar
+          };
+        }
+      });
+      var require_hover3 = __commonJS({
+        "src/traces/bar/hover.js"(exports, module2) {
+          var Fx = require_fx();
+          var Registry = require_registry();
+          var Color2 = require_color();
+          var fillText = require_lib().fillText;
+          var getLineWidth = require_helpers12().getLineWidth;
+          var hoverLabelText = require_axes().hoverLabelText;
+          var BADNUM = require_numerical().BADNUM;
+          function hoverPoints(pointData, xval, yval, hovermode, opts) {
+            var barPointData = hoverOnBars(pointData, xval, yval, hovermode, opts);
+            if (barPointData) {
+              var cd2 = barPointData.cd;
+              var trace = cd2[0].trace;
+              var di2 = cd2[barPointData.index];
+              barPointData.color = getTraceColor(trace, di2);
+              Registry.getComponentMethod("errorbars", "hoverInfo")(di2, trace, barPointData);
+              return [barPointData];
+            }
+          }
+          function hoverOnBars(pointData, xval, yval, hovermode, opts) {
+            var cd2 = pointData.cd;
+            var trace = cd2[0].trace;
+            var t4 = cd2[0].t;
+            var isClosest = hovermode === "closest";
+            var isWaterfall = trace.type === "waterfall";
+            var maxHoverDistance = pointData.maxHoverDistance;
+            var maxSpikeDistance = pointData.maxSpikeDistance;
+            var posVal, sizeVal, posLetter, sizeLetter, dx, dy, pRangeCalc;
+            if (trace.orientation === "h") {
+              posVal = yval;
+              sizeVal = xval;
+              posLetter = "y";
+              sizeLetter = "x";
+              dx = sizeFn;
+              dy = positionFn;
+            } else {
+              posVal = xval;
+              sizeVal = yval;
+              posLetter = "x";
+              sizeLetter = "y";
+              dy = sizeFn;
+              dx = positionFn;
+            }
+            var period = trace[posLetter + "period"];
+            var isClosestOrPeriod = isClosest || period;
+            function thisBarMinPos(di22) {
+              return thisBarExtPos(di22, -1);
+            }
+            function thisBarMaxPos(di22) {
+              return thisBarExtPos(di22, 1);
+            }
+            function thisBarExtPos(di22, sgn) {
+              var w2 = di22.w;
+              return di22[posLetter] + sgn * w2 / 2;
+            }
+            function periodLength(di22) {
+              return di22[posLetter + "End"] - di22[posLetter + "Start"];
+            }
+            var minPos = isClosest ? thisBarMinPos : period ? function(di22) {
+              return di22.p - periodLength(di22) / 2;
+            } : function(di22) {
+              return Math.min(thisBarMinPos(di22), di22.p - t4.bardelta / 2);
+            };
+            var maxPos = isClosest ? thisBarMaxPos : period ? function(di22) {
+              return di22.p + periodLength(di22) / 2;
+            } : function(di22) {
+              return Math.max(thisBarMaxPos(di22), di22.p + t4.bardelta / 2);
+            };
+            function inbox(_minPos, _maxPos, maxDistance) {
+              if (opts.finiteRange) maxDistance = 0;
+              return Fx.inbox(
+                _minPos - posVal,
+                _maxPos - posVal,
+                maxDistance + Math.min(1, Math.abs(_maxPos - _minPos) / pRangeCalc) - 1
+              );
+            }
+            function positionFn(di22) {
+              return inbox(minPos(di22), maxPos(di22), maxHoverDistance);
+            }
+            function thisBarPositionFn(di22) {
+              return inbox(thisBarMinPos(di22), thisBarMaxPos(di22), maxSpikeDistance);
+            }
+            function getSize(di22) {
+              var s2 = di22[sizeLetter];
+              if (isWaterfall) {
+                var rawS = Math.abs(di22.rawS) || 0;
+                if (sizeVal > 0) {
+                  s2 += rawS;
+                } else if (sizeVal < 0) {
+                  s2 -= rawS;
+                }
+              }
+              return s2;
+            }
+            function sizeFn(di22) {
+              var v2 = sizeVal;
+              var b2 = di22.b;
+              var s2 = getSize(di22);
+              return Fx.inbox(b2 - v2, s2 - v2, maxHoverDistance + (s2 - v2) / (s2 - b2) - 1);
+            }
+            function thisBarSizeFn(di22) {
+              var v2 = sizeVal;
+              var b2 = di22.b;
+              var s2 = getSize(di22);
+              return Fx.inbox(b2 - v2, s2 - v2, maxSpikeDistance + (s2 - v2) / (s2 - b2) - 1);
+            }
+            var pa2 = pointData[posLetter + "a"];
+            var sa2 = pointData[sizeLetter + "a"];
+            pRangeCalc = Math.abs(pa2.r2c(pa2.range[1]) - pa2.r2c(pa2.range[0]));
+            function dxy(di22) {
+              return (dx(di22) + dy(di22)) / 2;
+            }
+            var distfn = Fx.getDistanceFunction(hovermode, dx, dy, dxy);
+            Fx.getClosest(cd2, distfn, pointData);
+            if (pointData.index === false) return;
+            if (cd2[pointData.index].p === BADNUM) return;
+            if (!isClosestOrPeriod) {
+              minPos = function(di22) {
+                return Math.min(thisBarMinPos(di22), di22.p - t4.bargroupwidth / 2);
+              };
+              maxPos = function(di22) {
+                return Math.max(thisBarMaxPos(di22), di22.p + t4.bargroupwidth / 2);
+              };
+            }
+            var index = pointData.index;
+            var di2 = cd2[index];
+            var size = trace.base ? di2.b + di2.s : di2.s;
+            pointData[sizeLetter + "0"] = pointData[sizeLetter + "1"] = sa2.c2p(di2[sizeLetter], true);
+            pointData[sizeLetter + "LabelVal"] = size;
+            var extent = t4.extents[t4.extents.round(di2.p)];
+            pointData[posLetter + "0"] = pa2.c2p(isClosest ? minPos(di2) : extent[0], true);
+            pointData[posLetter + "1"] = pa2.c2p(isClosest ? maxPos(di2) : extent[1], true);
+            var hasPeriod = di2.orig_p !== void 0;
+            pointData[posLetter + "LabelVal"] = hasPeriod ? di2.orig_p : di2.p;
+            pointData.labelLabel = hoverLabelText(pa2, pointData[posLetter + "LabelVal"], trace[posLetter + "hoverformat"]);
+            pointData.valueLabel = hoverLabelText(sa2, pointData[sizeLetter + "LabelVal"], trace[sizeLetter + "hoverformat"]);
+            pointData.baseLabel = hoverLabelText(sa2, di2.b, trace[sizeLetter + "hoverformat"]);
+            pointData.spikeDistance = (thisBarSizeFn(di2) + thisBarPositionFn(di2)) / 2;
+            pointData[posLetter + "Spike"] = pa2.c2p(di2.p, true);
+            fillText(di2, trace, pointData);
+            pointData.hovertemplate = trace.hovertemplate;
+            return pointData;
+          }
+          function getTraceColor(trace, di2) {
+            var mc2 = di2.mcc || trace.marker.color;
+            var mlc = di2.mlcc || trace.marker.line.color;
+            var mlw = getLineWidth(trace, di2);
+            if (Color2.opacity(mc2)) return mc2;
+            else if (Color2.opacity(mlc) && mlw) return mlc;
+          }
+          module2.exports = {
+            hoverPoints,
+            hoverOnBars,
+            getTraceColor
+          };
+        }
+      });
+      var require_event_data = __commonJS({
+        "src/traces/bar/event_data.js"(exports, module2) {
+          module2.exports = function eventData(out, pt2, trace) {
+            out.x = "xVal" in pt2 ? pt2.xVal : pt2.x;
+            out.y = "yVal" in pt2 ? pt2.yVal : pt2.y;
+            if (pt2.xa) out.xaxis = pt2.xa;
+            if (pt2.ya) out.yaxis = pt2.ya;
+            if (trace.orientation === "h") {
+              out.label = out.y;
+              out.value = out.x;
+            } else {
+              out.label = out.x;
+              out.value = out.y;
+            }
+            return out;
+          };
+        }
+      });
+      var require_select3 = __commonJS({
+        "src/traces/bar/select.js"(exports, module2) {
+          module2.exports = function selectPoints(searchInfo, selectionTester) {
+            var cd2 = searchInfo.cd;
+            var xa = searchInfo.xaxis;
+            var ya2 = searchInfo.yaxis;
+            var trace = cd2[0].trace;
+            var isFunnel = trace.type === "funnel";
+            var isHorizontal = trace.orientation === "h";
+            var selection = [];
+            var i2;
+            if (selectionTester === false) {
+              for (i2 = 0; i2 < cd2.length; i2++) {
+                cd2[i2].selected = 0;
+              }
+            } else {
+              for (i2 = 0; i2 < cd2.length; i2++) {
+                var di2 = cd2[i2];
+                var ct2 = "ct" in di2 ? di2.ct : getCentroid(di2, xa, ya2, isHorizontal, isFunnel);
+                if (selectionTester.contains(ct2, false, i2, searchInfo)) {
+                  selection.push({
+                    pointNumber: i2,
+                    x: xa.c2d(di2.x),
+                    y: ya2.c2d(di2.y)
+                  });
+                  di2.selected = 1;
+                } else {
+                  di2.selected = 0;
+                }
+              }
+            }
+            return selection;
+          };
+          function getCentroid(d2, xa, ya2, isHorizontal, isFunnel) {
+            var x0 = xa.c2p(isHorizontal ? d2.s0 : d2.p0, true);
+            var x1 = xa.c2p(isHorizontal ? d2.s1 : d2.p1, true);
+            var y0 = ya2.c2p(isHorizontal ? d2.p0 : d2.s0, true);
+            var y1 = ya2.c2p(isHorizontal ? d2.p1 : d2.s1, true);
+            if (isFunnel) {
+              return [(x0 + x1) / 2, (y0 + y1) / 2];
+            } else {
+              if (isHorizontal) {
+                return [x1, (y0 + y1) / 2];
+              } else {
+                return [(x0 + x1) / 2, y1];
+              }
+            }
+          }
+        }
+      });
+      var require_bar = __commonJS({
+        "src/traces/bar/index.js"(exports, module2) {
+          module2.exports = {
+            attributes: require_attributes23(),
+            layoutAttributes: require_layout_attributes6(),
+            supplyDefaults: require_defaults19().supplyDefaults,
+            crossTraceDefaults: require_defaults19().crossTraceDefaults,
+            supplyLayoutDefaults: require_layout_defaults5(),
+            calc: require_calc5(),
+            crossTraceCalc: require_cross_trace_calc().crossTraceCalc,
+            colorbar: require_marker_colorbar(),
+            arraysToCalcdata: require_arrays_to_calcdata2(),
+            plot: require_plot3().plot,
+            style: require_style4().style,
+            styleOnSelect: require_style4().styleOnSelect,
+            hoverPoints: require_hover3().hoverPoints,
+            eventData: require_event_data(),
+            selectPoints: require_select3(),
+            moduleType: "trace",
+            name: "bar",
+            basePlotModule: require_cartesian(),
+            categories: ["bar-like", "cartesian", "svg", "bar", "oriented", "errorBarsOK", "showLegend", "zoomScale"],
+            animatable: true,
+            meta: {}
+          };
+        }
+      });
+      var require_bar2 = __commonJS({
+        "lib/bar.js"(exports, module2) {
+          module2.exports = require_bar();
+        }
+      });
+      var require_attributes24 = __commonJS({
+        "src/traces/box/attributes.js"(exports, module2) {
+          var makeFillcolorAttr = require_fillcolor_attribute();
+          var scatterAttrs = require_attributes12();
+          var barAttrs = require_attributes23();
+          var colorAttrs = require_attributes3();
+          var axisHoverFormat = require_axis_format_attributes().axisHoverFormat;
+          var { hovertemplateAttrs, templatefallbackAttrs } = require_template_attributes();
+          var extendFlat = require_extend().extendFlat;
+          var scatterMarkerAttrs = scatterAttrs.marker;
+          var scatterMarkerLineAttrs = scatterMarkerAttrs.line;
+          module2.exports = {
+            y: {
+              valType: "data_array",
+              editType: "calc+clearAxisTypes"
+            },
+            x: {
+              valType: "data_array",
+              editType: "calc+clearAxisTypes"
+            },
+            x0: {
+              valType: "any",
+              editType: "calc+clearAxisTypes"
+            },
+            y0: {
+              valType: "any",
+              editType: "calc+clearAxisTypes"
+            },
+            dx: {
+              valType: "number",
+              editType: "calc"
+            },
+            dy: {
+              valType: "number",
+              editType: "calc"
+            },
+            xperiod: scatterAttrs.xperiod,
+            yperiod: scatterAttrs.yperiod,
+            xperiod0: scatterAttrs.xperiod0,
+            yperiod0: scatterAttrs.yperiod0,
+            xperiodalignment: scatterAttrs.xperiodalignment,
+            yperiodalignment: scatterAttrs.yperiodalignment,
+            xhoverformat: axisHoverFormat("x"),
+            yhoverformat: axisHoverFormat("y"),
+            name: {
+              valType: "string",
+              editType: "calc+clearAxisTypes"
+            },
+            q1: {
+              valType: "data_array",
+              editType: "calc+clearAxisTypes"
+            },
+            median: {
+              valType: "data_array",
+              editType: "calc+clearAxisTypes"
+            },
+            q3: {
+              valType: "data_array",
+              editType: "calc+clearAxisTypes"
+            },
+            lowerfence: {
+              valType: "data_array",
+              editType: "calc"
+            },
+            upperfence: {
+              valType: "data_array",
+              editType: "calc"
+            },
+            notched: {
+              valType: "boolean",
+              editType: "calc"
+            },
+            notchwidth: {
+              valType: "number",
+              min: 0,
+              max: 0.5,
+              dflt: 0.25,
+              editType: "calc"
+            },
+            notchspan: {
+              valType: "data_array",
+              editType: "calc"
+            },
+            // TODO
+            // maybe add
+            // - loweroutlierbound / upperoutlierbound
+            // - lowersuspectedoutlierbound / uppersuspectedoutlierbound
+            boxpoints: {
+              valType: "enumerated",
+              values: ["all", "outliers", "suspectedoutliers", false],
+              editType: "calc"
+            },
+            jitter: {
+              valType: "number",
+              min: 0,
+              max: 1,
+              editType: "calc"
+            },
+            pointpos: {
+              valType: "number",
+              min: -2,
+              max: 2,
+              editType: "calc"
+            },
+            sdmultiple: {
+              valType: "number",
+              min: 0,
+              editType: "calc",
+              dflt: 1
+            },
+            sizemode: {
+              valType: "enumerated",
+              values: ["quartiles", "sd"],
+              editType: "calc",
+              dflt: "quartiles"
+            },
+            boxmean: {
+              valType: "enumerated",
+              values: [true, "sd", false],
+              editType: "calc"
+            },
+            mean: {
+              valType: "data_array",
+              editType: "calc"
+            },
+            sd: {
+              valType: "data_array",
+              editType: "calc"
+            },
+            orientation: {
+              valType: "enumerated",
+              values: ["v", "h"],
+              editType: "calc+clearAxisTypes"
+            },
+            quartilemethod: {
+              valType: "enumerated",
+              values: ["linear", "exclusive", "inclusive"],
+              dflt: "linear",
+              editType: "calc"
+            },
+            width: {
+              valType: "number",
+              min: 0,
+              dflt: 0,
+              editType: "calc"
+            },
+            marker: {
+              outliercolor: {
+                valType: "color",
+                dflt: "rgba(0, 0, 0, 0)",
+                editType: "style"
+              },
+              symbol: extendFlat({}, scatterMarkerAttrs.symbol, { arrayOk: false, editType: "plot" }),
+              opacity: extendFlat({}, scatterMarkerAttrs.opacity, { arrayOk: false, dflt: 1, editType: "style" }),
+              angle: extendFlat({}, scatterMarkerAttrs.angle, { arrayOk: false, editType: "calc" }),
+              size: extendFlat({}, scatterMarkerAttrs.size, { arrayOk: false, editType: "calc" }),
+              color: extendFlat({}, scatterMarkerAttrs.color, { arrayOk: false, editType: "style" }),
+              line: {
+                color: extendFlat({}, scatterMarkerLineAttrs.color, {
+                  arrayOk: false,
+                  dflt: colorAttrs.defaultLine,
+                  editType: "style"
+                }),
+                width: extendFlat({}, scatterMarkerLineAttrs.width, { arrayOk: false, dflt: 0, editType: "style" }),
+                outliercolor: {
+                  valType: "color",
+                  editType: "style"
+                },
+                outlierwidth: {
+                  valType: "number",
+                  min: 0,
+                  dflt: 1,
+                  editType: "style"
+                },
+                editType: "style"
+              },
+              editType: "plot"
+            },
+            line: {
+              color: {
+                valType: "color",
+                editType: "style"
+              },
+              width: {
+                valType: "number",
+                min: 0,
+                dflt: 2,
+                editType: "style"
+              },
+              editType: "plot"
+            },
+            fillcolor: makeFillcolorAttr(),
+            whiskerwidth: {
+              valType: "number",
+              min: 0,
+              max: 1,
+              dflt: 0.5,
+              editType: "calc"
+            },
+            showwhiskers: {
+              valType: "boolean",
+              editType: "calc"
+            },
+            offsetgroup: barAttrs.offsetgroup,
+            alignmentgroup: barAttrs.alignmentgroup,
+            selected: {
+              marker: scatterAttrs.selected.marker,
+              editType: "style"
+            },
+            unselected: {
+              marker: scatterAttrs.unselected.marker,
+              editType: "style"
+            },
+            text: extendFlat({}, scatterAttrs.text, {}),
+            hovertext: extendFlat({}, scatterAttrs.hovertext, {}),
+            hovertemplate: hovertemplateAttrs({}),
+            hovertemplatefallback: templatefallbackAttrs(),
+            hoveron: {
+              valType: "flaglist",
+              flags: ["boxes", "points"],
+              dflt: "boxes+points",
+              editType: "style"
+            },
+            zorder: scatterAttrs.zorder
+          };
+        }
+      });
+      var require_layout_attributes7 = __commonJS({
+        "src/traces/box/layout_attributes.js"(exports, module2) {
+          module2.exports = {
+            boxmode: {
+              valType: "enumerated",
+              values: ["group", "overlay"],
+              dflt: "overlay",
+              editType: "calc"
+            },
+            boxgap: {
+              valType: "number",
+              min: 0,
+              max: 1,
+              dflt: 0.3,
+              editType: "calc"
+            },
+            boxgroupgap: {
+              valType: "number",
+              min: 0,
+              max: 1,
+              dflt: 0.3,
+              editType: "calc"
+            }
+          };
+        }
+      });
+      var require_defaults20 = __commonJS({
+        "src/traces/box/defaults.js"(exports, module2) {
+          var Lib = require_lib();
+          var Registry = require_registry();
+          var Color2 = require_color();
+          var handlePeriodDefaults = require_period_defaults();
+          var handleGroupingDefaults = require_grouping_defaults();
+          var autoType = require_axis_autotype();
+          var attributes = require_attributes24();
+          function supplyDefaults(traceIn, traceOut, defaultColor, layout) {
+            function coerce(attr, dflt) {
+              return Lib.coerce(traceIn, traceOut, attributes, attr, dflt);
+            }
+            handleSampleDefaults(traceIn, traceOut, coerce, layout);
+            if (traceOut.visible === false) return;
+            handlePeriodDefaults(traceIn, traceOut, layout, coerce);
+            coerce("xhoverformat");
+            coerce("yhoverformat");
+            var hasPreCompStats = traceOut._hasPreCompStats;
+            if (hasPreCompStats) {
+              coerce("lowerfence");
+              coerce("upperfence");
+            }
+            coerce("line.color", (traceIn.marker || {}).color || defaultColor);
+            coerce("line.width");
+            coerce("fillcolor", Color2.addOpacity(traceOut.line.color, 0.5));
+            var boxmeanDflt = false;
+            if (hasPreCompStats) {
+              var mean = coerce("mean");
+              var sd2 = coerce("sd");
+              if (mean && mean.length) {
+                boxmeanDflt = true;
+                if (sd2 && sd2.length) boxmeanDflt = "sd";
+              }
+            }
+            coerce("whiskerwidth");
+            var sizemode = coerce("sizemode");
+            var boxmean;
+            if (sizemode === "quartiles") {
+              boxmean = coerce("boxmean", boxmeanDflt);
+            }
+            coerce("showwhiskers", sizemode === "quartiles");
+            if (sizemode === "sd" || boxmean === "sd") {
+              coerce("sdmultiple");
+            }
+            coerce("width");
+            coerce("quartilemethod");
+            var notchedDflt = false;
+            if (hasPreCompStats) {
+              var notchspan = coerce("notchspan");
+              if (notchspan && notchspan.length) {
+                notchedDflt = true;
+              }
+            } else if (Lib.validate(traceIn.notchwidth, attributes.notchwidth)) {
+              notchedDflt = true;
+            }
+            var notched = coerce("notched", notchedDflt);
+            if (notched) coerce("notchwidth");
+            handlePointsDefaults(traceIn, traceOut, coerce, { prefix: "box" });
+            coerce("zorder");
+          }
+          function handleSampleDefaults(traceIn, traceOut, coerce, layout) {
+            function getDims(arr) {
+              var dims = 0;
+              if (arr && arr.length) {
+                dims += 1;
+                if (Lib.isArrayOrTypedArray(arr[0]) && arr[0].length) {
+                  dims += 1;
+                }
+              }
+              return dims;
+            }
+            function valid(astr) {
+              return Lib.validate(traceIn[astr], attributes[astr]);
+            }
+            var y2 = coerce("y");
+            var x2 = coerce("x");
+            var sLen;
+            if (traceOut.type === "box") {
+              var q1 = coerce("q1");
+              var median = coerce("median");
+              var q3 = coerce("q3");
+              traceOut._hasPreCompStats = q1 && q1.length && median && median.length && q3 && q3.length;
+              sLen = Math.min(Lib.minRowLength(q1), Lib.minRowLength(median), Lib.minRowLength(q3));
+            }
+            var yDims = getDims(y2);
+            var xDims = getDims(x2);
+            var yLen = yDims && Lib.minRowLength(y2);
+            var xLen = xDims && Lib.minRowLength(x2);
+            var calendar = layout.calendar;
+            var opts = {
+              autotypenumbers: layout.autotypenumbers
+            };
+            var defaultOrientation, len2;
+            if (traceOut._hasPreCompStats) {
+              switch (String(xDims) + String(yDims)) {
+                case "00":
+                  var setInX = valid("x0") || valid("dx");
+                  var setInY = valid("y0") || valid("dy");
+                  if (setInY && !setInX) {
+                    defaultOrientation = "h";
+                  } else {
+                    defaultOrientation = "v";
+                  }
+                  len2 = sLen;
+                  break;
+                case "10":
+                  defaultOrientation = "v";
+                  len2 = Math.min(sLen, xLen);
+                  break;
+                case "20":
+                  defaultOrientation = "h";
+                  len2 = Math.min(sLen, x2.length);
+                  break;
+                case "01":
+                  defaultOrientation = "h";
+                  len2 = Math.min(sLen, yLen);
+                  break;
+                case "02":
+                  defaultOrientation = "v";
+                  len2 = Math.min(sLen, y2.length);
+                  break;
+                case "12":
+                  defaultOrientation = "v";
+                  len2 = Math.min(sLen, xLen, y2.length);
+                  break;
+                case "21":
+                  defaultOrientation = "h";
+                  len2 = Math.min(sLen, x2.length, yLen);
+                  break;
+                case "11":
+                  len2 = 0;
+                  break;
+                case "22":
+                  var hasCategories = false;
+                  var i2;
+                  for (i2 = 0; i2 < x2.length; i2++) {
+                    if (autoType(x2[i2], calendar, opts) === "category") {
+                      hasCategories = true;
+                      break;
+                    }
+                  }
+                  if (hasCategories) {
+                    defaultOrientation = "v";
+                    len2 = Math.min(sLen, xLen, y2.length);
+                  } else {
+                    for (i2 = 0; i2 < y2.length; i2++) {
+                      if (autoType(y2[i2], calendar, opts) === "category") {
+                        hasCategories = true;
+                        break;
+                      }
+                    }
+                    if (hasCategories) {
+                      defaultOrientation = "h";
+                      len2 = Math.min(sLen, x2.length, yLen);
+                    } else {
+                      defaultOrientation = "v";
+                      len2 = Math.min(sLen, xLen, y2.length);
+                    }
+                  }
+                  break;
+              }
+            } else if (yDims > 0) {
+              defaultOrientation = "v";
+              if (xDims > 0) {
+                len2 = Math.min(xLen, yLen);
+              } else {
+                len2 = Math.min(yLen);
+              }
+            } else if (xDims > 0) {
+              defaultOrientation = "h";
+              len2 = Math.min(xLen);
+            } else {
+              len2 = 0;
+            }
+            if (!len2) {
+              traceOut.visible = false;
+              return;
+            }
+            traceOut._length = len2;
+            var orientation = coerce("orientation", defaultOrientation);
+            if (traceOut._hasPreCompStats) {
+              if (orientation === "v" && xDims === 0) {
+                coerce("x0", 0);
+                coerce("dx", 1);
+              } else if (orientation === "h" && yDims === 0) {
+                coerce("y0", 0);
+                coerce("dy", 1);
+              }
+            } else {
+              if (orientation === "v" && xDims === 0) {
+                coerce("x0");
+              } else if (orientation === "h" && yDims === 0) {
+                coerce("y0");
+              }
+            }
+            var handleCalendarDefaults = Registry.getComponentMethod("calendars", "handleTraceDefaults");
+            handleCalendarDefaults(traceIn, traceOut, ["x", "y"], layout);
+          }
+          function handlePointsDefaults(traceIn, traceOut, coerce, opts) {
+            var prefix = opts.prefix;
+            var outlierColorDflt = Lib.coerce2(traceIn, traceOut, attributes, "marker.outliercolor");
+            var lineoutliercolor = coerce("marker.line.outliercolor");
+            var modeDflt = "outliers";
+            if (traceOut._hasPreCompStats) {
+              modeDflt = "all";
+            } else if (outlierColorDflt || lineoutliercolor) {
+              modeDflt = "suspectedoutliers";
+            }
+            var mode = coerce(prefix + "points", modeDflt);
+            if (mode) {
+              coerce("jitter", mode === "all" ? 0.3 : 0);
+              coerce("pointpos", mode === "all" ? -1.5 : 0);
+              coerce("marker.symbol");
+              coerce("marker.opacity");
+              coerce("marker.size");
+              coerce("marker.angle");
+              coerce("marker.color", traceOut.line.color);
+              coerce("marker.line.color");
+              coerce("marker.line.width");
+              if (mode === "suspectedoutliers") {
+                coerce("marker.line.outliercolor", traceOut.marker.color);
+                coerce("marker.line.outlierwidth");
+              }
+              coerce("selected.marker.color");
+              coerce("unselected.marker.color");
+              coerce("selected.marker.size");
+              coerce("unselected.marker.size");
+              coerce("text");
+              coerce("hovertext");
+            } else {
+              delete traceOut.marker;
+            }
+            var hoveron = coerce("hoveron");
+            if (hoveron === "all" || hoveron.indexOf("points") !== -1) {
+              coerce("hovertemplate");
+              coerce("hovertemplatefallback");
+            }
+            Lib.coerceSelectionMarkerOpacity(traceOut, coerce);
+          }
+          function crossTraceDefaults(fullData, fullLayout) {
+            var traceIn, traceOut;
+            function coerce(attr) {
+              return Lib.coerce(traceOut._input, traceOut, attributes, attr);
+            }
+            for (var i2 = 0; i2 < fullData.length; i2++) {
+              traceOut = fullData[i2];
+              var traceType = traceOut.type;
+              if (traceType === "box" || traceType === "violin") {
+                traceIn = traceOut._input;
+                var mode = fullLayout[traceType + "mode"];
+                if (mode === "group") {
+                  handleGroupingDefaults(traceIn, traceOut, fullLayout, coerce, mode);
+                }
+              }
+            }
+          }
+          module2.exports = {
+            supplyDefaults,
+            crossTraceDefaults,
+            handleSampleDefaults,
+            handlePointsDefaults
+          };
+        }
+      });
+      var require_layout_defaults6 = __commonJS({
+        "src/traces/box/layout_defaults.js"(exports, module2) {
+          var Registry = require_registry();
+          var Lib = require_lib();
+          var layoutAttributes = require_layout_attributes7();
+          function _supply(layoutIn, layoutOut, fullData, coerce, traceType) {
+            var category = traceType + "Layout";
+            var hasTraceType = false;
+            for (var i2 = 0; i2 < fullData.length; i2++) {
+              var trace = fullData[i2];
+              if (Registry.traceIs(trace, category)) {
+                hasTraceType = true;
+                break;
+              }
+            }
+            if (!hasTraceType) return;
+            coerce(traceType + "mode");
+            coerce(traceType + "gap");
+            coerce(traceType + "groupgap");
+          }
+          function supplyLayoutDefaults(layoutIn, layoutOut, fullData) {
+            function coerce(attr, dflt) {
+              return Lib.coerce(layoutIn, layoutOut, layoutAttributes, attr, dflt);
+            }
+            _supply(layoutIn, layoutOut, fullData, coerce, "box");
+          }
+          module2.exports = {
+            supplyLayoutDefaults,
+            _supply
+          };
+        }
+      });
+      var require_calc6 = __commonJS({
+        "src/traces/box/calc.js"(exports, module2) {
+          var isNumeric = require_fast_isnumeric();
+          var Axes = require_axes();
+          var alignPeriod = require_align_period();
+          var Lib = require_lib();
+          var BADNUM = require_numerical().BADNUM;
+          var _2 = Lib._;
+          module2.exports = function calc(gd2, trace) {
+            var fullLayout = gd2._fullLayout;
+            var xa = Axes.getFromId(gd2, trace.xaxis || "x");
+            var ya2 = Axes.getFromId(gd2, trace.yaxis || "y");
+            var cd2 = [];
+            var numKey = trace.type === "violin" ? "_numViolins" : "_numBoxes";
+            var i2, j2;
+            var valAxis, valLetter;
+            var posAxis, posLetter;
+            var hasPeriod;
+            if (trace.orientation === "h") {
+              valAxis = xa;
+              valLetter = "x";
+              posAxis = ya2;
+              posLetter = "y";
+              hasPeriod = !!trace.yperiodalignment;
+            } else {
+              valAxis = ya2;
+              valLetter = "y";
+              posAxis = xa;
+              posLetter = "x";
+              hasPeriod = !!trace.xperiodalignment;
+            }
+            var allPosArrays = getPosArrays(trace, posLetter, posAxis, fullLayout[numKey]);
+            var posArray = allPosArrays[0];
+            var origPos = allPosArrays[1];
+            var dv = Lib.distinctVals(posArray, posAxis);
+            var posDistinct = dv.vals;
+            var dPos = dv.minDiff / 2;
+            var cdi;
+            var pts;
+            var boxVals;
+            var N2;
+            var pt2;
+            var v2;
+            var ptFilterFn = (trace.boxpoints || trace.points) === "all" ? Lib.identity : function(pt22) {
+              return pt22.v < cdi.lf || pt22.v > cdi.uf;
+            };
+            if (trace._hasPreCompStats) {
+              var valArrayRaw = trace[valLetter];
+              var d2c = function(k2) {
+                return valAxis.d2c((trace[k2] || [])[i2]);
+              };
+              var minVal = Infinity;
+              var maxVal = -Infinity;
+              for (i2 = 0; i2 < trace._length; i2++) {
+                var posi = posArray[i2];
+                if (!isNumeric(posi)) continue;
+                cdi = {};
+                cdi.pos = cdi[posLetter] = posi;
+                if (hasPeriod && origPos) {
+                  cdi.orig_p = origPos[i2];
+                }
+                cdi.q1 = d2c("q1");
+                cdi.med = d2c("median");
+                cdi.q3 = d2c("q3");
+                pts = [];
+                if (valArrayRaw && Lib.isArrayOrTypedArray(valArrayRaw[i2])) {
+                  for (j2 = 0; j2 < valArrayRaw[i2].length; j2++) {
+                    v2 = valAxis.d2c(valArrayRaw[i2][j2]);
+                    if (v2 !== BADNUM) {
+                      pt2 = { v: v2, i: [i2, j2] };
+                      arraysToCalcdata(pt2, trace, [i2, j2]);
+                      pts.push(pt2);
+                    }
+                  }
+                }
+                cdi.pts = pts.sort(sortByVal);
+                boxVals = cdi[valLetter] = pts.map(extractVal);
+                N2 = boxVals.length;
+                if (cdi.med !== BADNUM && cdi.q1 !== BADNUM && cdi.q3 !== BADNUM && cdi.med >= cdi.q1 && cdi.q3 >= cdi.med) {
+                  var lf2 = d2c("lowerfence");
+                  cdi.lf = lf2 !== BADNUM && lf2 <= cdi.q1 ? lf2 : computeLowerFence(cdi, boxVals, N2);
+                  var uf2 = d2c("upperfence");
+                  cdi.uf = uf2 !== BADNUM && uf2 >= cdi.q3 ? uf2 : computeUpperFence(cdi, boxVals, N2);
+                  var mean = d2c("mean");
+                  cdi.mean = mean !== BADNUM ? mean : N2 ? Lib.mean(boxVals, N2) : (cdi.q1 + cdi.q3) / 2;
+                  var sd2 = d2c("sd");
+                  cdi.sd = mean !== BADNUM && sd2 >= 0 ? sd2 : N2 ? Lib.stdev(boxVals, N2, cdi.mean) : cdi.q3 - cdi.q1;
+                  cdi.lo = computeLowerOutlierBound(cdi);
+                  cdi.uo = computeUpperOutlierBound(cdi);
+                  var ns = d2c("notchspan");
+                  ns = ns !== BADNUM && ns > 0 ? ns : computeNotchSpan(cdi, N2);
+                  cdi.ln = cdi.med - ns;
+                  cdi.un = cdi.med + ns;
+                  var imin = cdi.lf;
+                  var imax = cdi.uf;
+                  if (trace.boxpoints && boxVals.length) {
+                    imin = Math.min(imin, boxVals[0]);
+                    imax = Math.max(imax, boxVals[N2 - 1]);
+                  }
+                  if (trace.notched) {
+                    imin = Math.min(imin, cdi.ln);
+                    imax = Math.max(imax, cdi.un);
+                  }
+                  cdi.min = imin;
+                  cdi.max = imax;
+                } else {
+                  Lib.warn([
+                    "Invalid input - make sure that q1 <= median <= q3",
+                    "q1 = " + cdi.q1,
+                    "median = " + cdi.med,
+                    "q3 = " + cdi.q3
+                  ].join("\n"));
+                  var v0;
+                  if (cdi.med !== BADNUM) {
+                    v0 = cdi.med;
+                  } else if (cdi.q1 !== BADNUM) {
+                    if (cdi.q3 !== BADNUM) v0 = (cdi.q1 + cdi.q3) / 2;
+                    else v0 = cdi.q1;
+                  } else if (cdi.q3 !== BADNUM) {
+                    v0 = cdi.q3;
+                  } else {
+                    v0 = 0;
+                  }
+                  cdi.med = v0;
+                  cdi.q1 = cdi.q3 = v0;
+                  cdi.lf = cdi.uf = v0;
+                  cdi.mean = cdi.sd = v0;
+                  cdi.ln = cdi.un = v0;
+                  cdi.min = cdi.max = v0;
+                }
+                minVal = Math.min(minVal, cdi.min);
+                maxVal = Math.max(maxVal, cdi.max);
+                cdi.pts2 = pts.filter(ptFilterFn);
+                cd2.push(cdi);
+              }
+              trace._extremes[valAxis._id] = Axes.findExtremes(
+                valAxis,
+                [minVal, maxVal],
+                { padded: true }
+              );
+            } else {
+              var valArray = valAxis.makeCalcdata(trace, valLetter);
+              var posBins = makeBins(posDistinct, dPos);
+              var pLen = posDistinct.length;
+              var ptsPerBin = initNestedArray(pLen);
+              for (i2 = 0; i2 < trace._length; i2++) {
+                v2 = valArray[i2];
+                if (!isNumeric(v2)) continue;
+                var n2 = Lib.findBin(posArray[i2], posBins);
+                if (n2 >= 0 && n2 < pLen) {
+                  pt2 = { v: v2, i: i2 };
+                  arraysToCalcdata(pt2, trace, i2);
+                  ptsPerBin[n2].push(pt2);
+                }
+              }
+              var minLowerNotch = Infinity;
+              var maxUpperNotch = -Infinity;
+              var quartilemethod = trace.quartilemethod;
+              var usesExclusive = quartilemethod === "exclusive";
+              var usesInclusive = quartilemethod === "inclusive";
+              for (i2 = 0; i2 < pLen; i2++) {
+                if (ptsPerBin[i2].length > 0) {
+                  cdi = {};
+                  cdi.pos = cdi[posLetter] = posDistinct[i2];
+                  pts = cdi.pts = ptsPerBin[i2].sort(sortByVal);
+                  boxVals = cdi[valLetter] = pts.map(extractVal);
+                  N2 = boxVals.length;
+                  cdi.min = boxVals[0];
+                  cdi.max = boxVals[N2 - 1];
+                  cdi.mean = Lib.mean(boxVals, N2);
+                  cdi.sd = Lib.stdev(boxVals, N2, cdi.mean) * trace.sdmultiple;
+                  cdi.med = Lib.interp(boxVals, 0.5);
+                  if (N2 % 2 && (usesExclusive || usesInclusive)) {
+                    var lower;
+                    var upper;
+                    if (usesExclusive) {
+                      lower = boxVals.slice(0, N2 / 2);
+                      upper = boxVals.slice(N2 / 2 + 1);
+                    } else if (usesInclusive) {
+                      lower = boxVals.slice(0, N2 / 2 + 1);
+                      upper = boxVals.slice(N2 / 2);
+                    }
+                    cdi.q1 = Lib.interp(lower, 0.5);
+                    cdi.q3 = Lib.interp(upper, 0.5);
+                  } else {
+                    cdi.q1 = Lib.interp(boxVals, 0.25);
+                    cdi.q3 = Lib.interp(boxVals, 0.75);
+                  }
+                  cdi.lf = computeLowerFence(cdi, boxVals, N2);
+                  cdi.uf = computeUpperFence(cdi, boxVals, N2);
+                  cdi.lo = computeLowerOutlierBound(cdi);
+                  cdi.uo = computeUpperOutlierBound(cdi);
+                  var mci = computeNotchSpan(cdi, N2);
+                  cdi.ln = cdi.med - mci;
+                  cdi.un = cdi.med + mci;
+                  minLowerNotch = Math.min(minLowerNotch, cdi.ln);
+                  maxUpperNotch = Math.max(maxUpperNotch, cdi.un);
+                  cdi.pts2 = pts.filter(ptFilterFn);
+                  cd2.push(cdi);
+                }
+              }
+              if (trace.notched && Lib.isTypedArray(valArray)) valArray = Array.from(valArray);
+              trace._extremes[valAxis._id] = Axes.findExtremes(
+                valAxis,
+                trace.notched ? valArray.concat([minLowerNotch, maxUpperNotch]) : valArray,
+                { padded: true }
+              );
+            }
+            calcSelection(cd2, trace);
+            if (cd2.length > 0) {
+              cd2[0].t = {
+                num: fullLayout[numKey],
+                dPos,
+                posLetter,
+                valLetter,
+                labels: {
+                  med: _2(gd2, "median:"),
+                  min: _2(gd2, "min:"),
+                  q1: _2(gd2, "q1:"),
+                  q3: _2(gd2, "q3:"),
+                  max: _2(gd2, "max:"),
+                  mean: trace.boxmean === "sd" || trace.sizemode === "sd" ? _2(gd2, "mean ± σ:").replace("σ", trace.sdmultiple === 1 ? "σ" : trace.sdmultiple + "σ") : (
+                    // displaying mean +- Nσ whilst supporting translations
+                    _2(gd2, "mean:")
+                  ),
+                  lf: _2(gd2, "lower fence:"),
+                  uf: _2(gd2, "upper fence:")
+                }
+              };
+              fullLayout[numKey]++;
+              return cd2;
+            } else {
+              return [{ t: { empty: true } }];
+            }
+          };
+          function getPosArrays(trace, posLetter, posAxis, num) {
+            var hasPosArray = posLetter in trace;
+            var hasPos0 = posLetter + "0" in trace;
+            var hasPosStep = "d" + posLetter in trace;
+            if (hasPosArray || hasPos0 && hasPosStep) {
+              var origPos = posAxis.makeCalcdata(trace, posLetter);
+              var pos = alignPeriod(trace, posAxis, posLetter, origPos).vals;
+              return [pos, origPos];
+            }
+            var pos0;
+            if (hasPos0) {
+              pos0 = trace[posLetter + "0"];
+            } else if ("name" in trace && (posAxis.type === "category" || isNumeric(trace.name) && ["linear", "log"].indexOf(posAxis.type) !== -1 || Lib.isDateTime(trace.name) && posAxis.type === "date")) {
+              pos0 = trace.name;
+            } else {
+              pos0 = num;
+            }
+            var pos0c = posAxis.type === "multicategory" ? posAxis.r2c_just_indices(pos0) : posAxis.d2c(pos0, 0, trace[posLetter + "calendar"]);
+            var len2 = trace._length;
+            var out = new Array(len2);
+            for (var i2 = 0; i2 < len2; i2++) out[i2] = pos0c;
+            return [out];
+          }
+          function makeBins(x2, dx) {
+            var len2 = x2.length;
+            var bins = new Array(len2 + 1);
+            for (var i2 = 0; i2 < len2; i2++) {
+              bins[i2] = x2[i2] - dx;
+            }
+            bins[len2] = x2[len2 - 1] + dx;
+            return bins;
+          }
+          function initNestedArray(len2) {
+            var arr = new Array(len2);
+            for (var i2 = 0; i2 < len2; i2++) {
+              arr[i2] = [];
+            }
+            return arr;
+          }
+          var TRACE_TO_CALC = {
+            text: "tx",
+            hovertext: "htx"
+          };
+          function arraysToCalcdata(pt2, trace, ptNumber) {
+            for (var k2 in TRACE_TO_CALC) {
+              if (Lib.isArrayOrTypedArray(trace[k2])) {
+                if (Array.isArray(ptNumber)) {
+                  if (Lib.isArrayOrTypedArray(trace[k2][ptNumber[0]])) {
+                    pt2[TRACE_TO_CALC[k2]] = trace[k2][ptNumber[0]][ptNumber[1]];
+                  }
+                } else {
+                  pt2[TRACE_TO_CALC[k2]] = trace[k2][ptNumber];
+                }
+              }
+            }
+          }
+          function calcSelection(cd2, trace) {
+            if (Lib.isArrayOrTypedArray(trace.selectedpoints)) {
+              for (var i2 = 0; i2 < cd2.length; i2++) {
+                var pts = cd2[i2].pts || [];
+                var ptNumber2cdIndex = {};
+                for (var j2 = 0; j2 < pts.length; j2++) {
+                  ptNumber2cdIndex[pts[j2].i] = j2;
+                }
+                Lib.tagSelected(pts, trace, ptNumber2cdIndex);
+              }
+            }
+          }
+          function sortByVal(a2, b2) {
+            return a2.v - b2.v;
+          }
+          function extractVal(o2) {
+            return o2.v;
+          }
+          function computeLowerFence(cdi, boxVals, N2) {
+            if (N2 === 0) return cdi.q1;
+            return Math.min(
+              cdi.q1,
+              boxVals[Math.min(
+                Lib.findBin(2.5 * cdi.q1 - 1.5 * cdi.q3, boxVals, true) + 1,
+                N2 - 1
+              )]
+            );
+          }
+          function computeUpperFence(cdi, boxVals, N2) {
+            if (N2 === 0) return cdi.q3;
+            return Math.max(
+              cdi.q3,
+              boxVals[Math.max(
+                Lib.findBin(2.5 * cdi.q3 - 1.5 * cdi.q1, boxVals),
+                0
+              )]
+            );
+          }
+          function computeLowerOutlierBound(cdi) {
+            return 4 * cdi.q1 - 3 * cdi.q3;
+          }
+          function computeUpperOutlierBound(cdi) {
+            return 4 * cdi.q3 - 3 * cdi.q1;
+          }
+          function computeNotchSpan(cdi, N2) {
+            if (N2 === 0) return 0;
+            return 1.57 * (cdi.q3 - cdi.q1) / Math.sqrt(N2);
+          }
+        }
+      });
+      var require_cross_trace_calc3 = __commonJS({
+        "src/traces/box/cross_trace_calc.js"(exports, module2) {
+          var Axes = require_axes();
+          var Lib = require_lib();
+          var getAxisGroup = require_constraints().getAxisGroup;
+          var orientations = ["v", "h"];
+          function crossTraceCalc(gd2, plotinfo) {
+            var calcdata = gd2.calcdata;
+            var xa = plotinfo.xaxis;
+            var ya2 = plotinfo.yaxis;
+            for (var i2 = 0; i2 < orientations.length; i2++) {
+              var orientation = orientations[i2];
+              var posAxis = orientation === "h" ? ya2 : xa;
+              var boxList = [];
+              for (var j2 = 0; j2 < calcdata.length; j2++) {
+                var cd2 = calcdata[j2];
+                var t4 = cd2[0].t;
+                var trace = cd2[0].trace;
+                if (trace.visible === true && (trace.type === "box" || trace.type === "candlestick") && !t4.empty && (trace.orientation || "v") === orientation && trace.xaxis === xa._id && trace.yaxis === ya2._id) {
+                  boxList.push(j2);
+                }
+              }
+              setPositionOffset("box", gd2, boxList, posAxis);
+            }
+          }
+          function setPositionOffset(traceType, gd2, boxList, posAxis) {
+            var calcdata = gd2.calcdata;
+            var fullLayout = gd2._fullLayout;
+            var axId = posAxis._id;
+            var axLetter = axId.charAt(0);
+            var i2, j2, calcTrace;
+            var pointList = [];
+            var shownPts = 0;
+            for (i2 = 0; i2 < boxList.length; i2++) {
+              calcTrace = calcdata[boxList[i2]];
+              for (j2 = 0; j2 < calcTrace.length; j2++) {
+                pointList.push(posAxis.c2l(calcTrace[j2].pos, true));
+                shownPts += (calcTrace[j2].pts2 || []).length;
+              }
+            }
+            if (!pointList.length) return;
+            var boxdv = Lib.distinctVals(pointList);
+            if (posAxis.type === "category" || posAxis.type === "multicategory") {
+              boxdv.minDiff = 1;
+            }
+            var dPos0 = boxdv.minDiff / 2;
+            Axes.minDtick(posAxis, boxdv.minDiff, boxdv.vals[0], true);
+            var numKey = traceType === "violin" ? "_numViolins" : "_numBoxes";
+            var numTotal = fullLayout[numKey];
+            var group = fullLayout[traceType + "mode"] === "group" && numTotal > 1;
+            var groupFraction = 1 - fullLayout[traceType + "gap"];
+            var groupGapFraction = 1 - fullLayout[traceType + "groupgap"];
+            for (i2 = 0; i2 < boxList.length; i2++) {
+              calcTrace = calcdata[boxList[i2]];
+              var trace = calcTrace[0].trace;
+              var t4 = calcTrace[0].t;
+              var width = trace.width;
+              var side = trace.side;
+              var dPos;
+              var bdPos;
+              var bPos;
+              var wHover;
+              if (width) {
+                dPos = bdPos = wHover = width / 2;
+                bPos = 0;
+              } else {
+                dPos = dPos0;
+                if (group) {
+                  var groupId = getAxisGroup(fullLayout, posAxis._id) + trace.orientation;
+                  var alignmentGroups = fullLayout._alignmentOpts[groupId] || {};
+                  var alignmentGroupOpts = alignmentGroups[trace.alignmentgroup] || {};
+                  var nOffsetGroups = Object.keys(alignmentGroupOpts.offsetGroups || {}).length;
+                  var num = nOffsetGroups || numTotal;
+                  var shift = nOffsetGroups ? trace._offsetIndex : t4.num;
+                  bdPos = dPos * groupFraction * groupGapFraction / num;
+                  bPos = 2 * dPos * (-0.5 + (shift + 0.5) / num) * groupFraction;
+                  wHover = dPos * groupFraction / num;
+                } else {
+                  bdPos = dPos * groupFraction * groupGapFraction;
+                  bPos = 0;
+                  wHover = dPos;
+                }
+              }
+              t4.dPos = dPos;
+              t4.bPos = bPos;
+              t4.bdPos = bdPos;
+              t4.wHover = wHover;
+              var pushplus;
+              var pushminus;
+              var edge = bPos + bdPos;
+              var edgeplus;
+              var edgeminus;
+              var vpadplus;
+              var vpadminus;
+              var ppadplus;
+              var ppadminus;
+              var padded = Boolean(width);
+              var hasPts = (trace.boxpoints || trace.points) && shownPts > 0;
+              if (side === "positive") {
+                pushplus = dPos * (width ? 1 : 0.5);
+                edgeplus = edge;
+                pushminus = edgeplus = bPos;
+              } else if (side === "negative") {
+                pushplus = edgeplus = bPos;
+                pushminus = dPos * (width ? 1 : 0.5);
+                edgeminus = edge;
+              } else {
+                pushplus = pushminus = dPos;
+                edgeplus = edgeminus = edge;
+              }
+              if (hasPts) {
+                var pointpos = trace.pointpos;
+                var jitter = trace.jitter;
+                var ms = trace.marker.size / 2;
+                var pp = 0;
+                if (pointpos + jitter >= 0) {
+                  pp = edge * (pointpos + jitter);
+                  if (pp > pushplus) {
+                    padded = true;
+                    ppadplus = ms;
+                    vpadplus = pp;
+                  } else if (pp > edgeplus) {
+                    ppadplus = ms;
+                    vpadplus = pushplus;
+                  }
+                }
+                if (pp <= pushplus) {
+                  vpadplus = pushplus;
+                }
+                var pm = 0;
+                if (pointpos - jitter <= 0) {
+                  pm = -edge * (pointpos - jitter);
+                  if (pm > pushminus) {
+                    padded = true;
+                    ppadminus = ms;
+                    vpadminus = pm;
+                  } else if (pm > edgeminus) {
+                    ppadminus = ms;
+                    vpadminus = pushminus;
+                  }
+                }
+                if (pm <= pushminus) {
+                  vpadminus = pushminus;
+                }
+              } else {
+                vpadplus = pushplus;
+                vpadminus = pushminus;
+              }
+              var pos = new Array(calcTrace.length);
+              for (j2 = 0; j2 < calcTrace.length; j2++) {
+                pos[j2] = calcTrace[j2].pos;
+              }
+              trace._extremes[axId] = Axes.findExtremes(posAxis, pos, {
+                padded,
+                vpadminus,
+                vpadplus,
+                vpadLinearized: true,
+                // N.B. SVG px-space positive/negative
+                ppadminus: { x: ppadminus, y: ppadplus }[axLetter],
+                ppadplus: { x: ppadplus, y: ppadminus }[axLetter]
+              });
+            }
+          }
+          module2.exports = {
+            crossTraceCalc,
+            setPositionOffset
+          };
+        }
+      });
+      var require_plot4 = __commonJS({
+        "src/traces/box/plot.js"(exports, module2) {
+          var d3 = require_d3();
+          var Lib = require_lib();
+          var Drawing = require_drawing();
+          var JITTERCOUNT = 5;
+          var JITTERSPREAD = 0.01;
+          function plot(gd2, plotinfo, cdbox, boxLayer) {
+            var isStatic = gd2._context.staticPlot;
+            var xa = plotinfo.xaxis;
+            var ya2 = plotinfo.yaxis;
+            Lib.makeTraceGroups(boxLayer, cdbox, "trace boxes").each(function(cd2) {
+              var plotGroup = d3.select(this);
+              var cd0 = cd2[0];
+              var t4 = cd0.t;
+              var trace = cd0.trace;
+              t4.wdPos = t4.bdPos * trace.whiskerwidth;
+              if (trace.visible !== true || t4.empty) {
+                plotGroup.remove();
+                return;
+              }
+              var posAxis, valAxis;
+              if (trace.orientation === "h") {
+                posAxis = ya2;
+                valAxis = xa;
+              } else {
+                posAxis = xa;
+                valAxis = ya2;
+              }
+              plotBoxAndWhiskers(plotGroup, { pos: posAxis, val: valAxis }, trace, t4, isStatic);
+              plotPoints(plotGroup, { x: xa, y: ya2 }, trace, t4);
+              plotBoxMean(plotGroup, { pos: posAxis, val: valAxis }, trace, t4);
+            });
+          }
+          function plotBoxAndWhiskers(sel, axes, trace, t4, isStatic) {
+            var isHorizontal = trace.orientation === "h";
+            var valAxis = axes.val;
+            var posAxis = axes.pos;
+            var posHasRangeBreaks = !!posAxis.rangebreaks;
+            var bPos = t4.bPos;
+            var wdPos = t4.wdPos || 0;
+            var bPosPxOffset = t4.bPosPxOffset || 0;
+            var whiskerWidth = trace.whiskerwidth || 0;
+            var showWhiskers = trace.showwhiskers !== false;
+            var notched = trace.notched || false;
+            var nw = notched ? 1 - 2 * trace.notchwidth : 1;
+            var bdPos0;
+            var bdPos1;
+            if (Array.isArray(t4.bdPos)) {
+              bdPos0 = t4.bdPos[0];
+              bdPos1 = t4.bdPos[1];
+            } else {
+              bdPos0 = t4.bdPos;
+              bdPos1 = t4.bdPos;
+            }
+            var paths = sel.selectAll("path.box").data(trace.type !== "violin" || trace.box.visible ? Lib.identity : []);
+            paths.enter().append("path").style("vector-effect", isStatic ? "none" : "non-scaling-stroke").attr("class", "box");
+            paths.exit().remove();
+            paths.each(function(d2) {
+              if (d2.empty) return d3.select(this).attr("d", "M0,0Z");
+              var lcenter = posAxis.c2l(d2.pos + bPos, true);
+              var pos0 = posAxis.l2p(lcenter - bdPos0) + bPosPxOffset;
+              var pos1 = posAxis.l2p(lcenter + bdPos1) + bPosPxOffset;
+              var posc = posHasRangeBreaks ? (pos0 + pos1) / 2 : posAxis.l2p(lcenter) + bPosPxOffset;
+              var r2 = trace.whiskerwidth;
+              var posw0 = posHasRangeBreaks ? pos0 * r2 + (1 - r2) * posc : posAxis.l2p(lcenter - wdPos) + bPosPxOffset;
+              var posw1 = posHasRangeBreaks ? pos1 * r2 + (1 - r2) * posc : posAxis.l2p(lcenter + wdPos) + bPosPxOffset;
+              var posm0 = posAxis.l2p(lcenter - bdPos0 * nw) + bPosPxOffset;
+              var posm1 = posAxis.l2p(lcenter + bdPos1 * nw) + bPosPxOffset;
+              var sdmode = trace.sizemode === "sd";
+              var q1 = valAxis.c2p(sdmode ? d2.mean - d2.sd : d2.q1, true);
+              var q3 = sdmode ? valAxis.c2p(d2.mean + d2.sd, true) : valAxis.c2p(d2.q3, true);
+              var m2 = Lib.constrain(
+                sdmode ? valAxis.c2p(d2.mean, true) : valAxis.c2p(d2.med, true),
+                Math.min(q1, q3) + 1,
+                Math.max(q1, q3) - 1
+              );
+              var useExtremes = d2.lf === void 0 || trace.boxpoints === false || sdmode;
+              var lf2 = valAxis.c2p(useExtremes ? d2.min : d2.lf, true);
+              var uf2 = valAxis.c2p(useExtremes ? d2.max : d2.uf, true);
+              var ln = valAxis.c2p(d2.ln, true);
+              var un = valAxis.c2p(d2.un, true);
+              if (isHorizontal) {
+                d3.select(this).attr(
+                  "d",
+                  "M" + m2 + "," + posm0 + "V" + posm1 + // median line
+                  "M" + q1 + "," + pos0 + "V" + pos1 + // left edge
+                  (notched ? "H" + ln + "L" + m2 + "," + posm1 + "L" + un + "," + pos1 : "") + // top notched edge
+                  "H" + q3 + // end of the top edge
+                  "V" + pos0 + // right edge
+                  (notched ? "H" + un + "L" + m2 + "," + posm0 + "L" + ln + "," + pos0 : "") + // bottom notched edge
+                  "Z" + // end of the box
+                  (showWhiskers ? "M" + q1 + "," + posc + "H" + lf2 + "M" + q3 + "," + posc + "H" + uf2 + // whiskers
+                  (whiskerWidth === 0 ? "" : (
+                    // whisker caps
+                    "M" + lf2 + "," + posw0 + "V" + posw1 + "M" + uf2 + "," + posw0 + "V" + posw1
+                  )) : "")
+                );
+              } else {
+                d3.select(this).attr(
+                  "d",
+                  "M" + posm0 + "," + m2 + "H" + posm1 + // median line
+                  "M" + pos0 + "," + q1 + "H" + pos1 + // top of the box
+                  (notched ? "V" + ln + "L" + posm1 + "," + m2 + "L" + pos1 + "," + un : "") + // notched right edge
+                  "V" + q3 + // end of the right edge
+                  "H" + pos0 + // bottom of the box
+                  (notched ? "V" + un + "L" + posm0 + "," + m2 + "L" + pos0 + "," + ln : "") + // notched left edge
+                  "Z" + // end of the box
+                  (showWhiskers ? "M" + posc + "," + q1 + "V" + lf2 + "M" + posc + "," + q3 + "V" + uf2 + // whiskers
+                  (whiskerWidth === 0 ? "" : (
+                    // whisker caps
+                    "M" + posw0 + "," + lf2 + "H" + posw1 + "M" + posw0 + "," + uf2 + "H" + posw1
+                  )) : "")
+                );
+              }
+            });
+          }
+          function plotPoints(sel, axes, trace, t4) {
+            var xa = axes.x;
+            var ya2 = axes.y;
+            var bdPos = t4.bdPos;
+            var bPos = t4.bPos;
+            var mode = trace.boxpoints || trace.points;
+            Lib.seedPseudoRandom();
+            var fn = function(d2) {
+              d2.forEach(function(v2) {
+                v2.t = t4;
+                v2.trace = trace;
+              });
+              return d2;
+            };
+            var gPoints = sel.selectAll("g.points").data(mode ? fn : []);
+            gPoints.enter().append("g").attr("class", "points");
+            gPoints.exit().remove();
+            var paths = gPoints.selectAll("path").data(function(d2) {
+              var i2;
+              var pts = d2.pts2;
+              var typicalSpread = Math.max((d2.max - d2.min) / 10, d2.q3 - d2.q1);
+              var minSpread = typicalSpread * 1e-9;
+              var spreadLimit = typicalSpread * JITTERSPREAD;
+              var jitterFactors = [];
+              var maxJitterFactor = 0;
+              var newJitter;
+              if (trace.jitter) {
+                if (typicalSpread === 0) {
+                  maxJitterFactor = 1;
+                  jitterFactors = new Array(pts.length);
+                  for (i2 = 0; i2 < pts.length; i2++) {
+                    jitterFactors[i2] = 1;
+                  }
+                } else {
+                  for (i2 = 0; i2 < pts.length; i2++) {
+                    var i0 = Math.max(0, i2 - JITTERCOUNT);
+                    var pmin = pts[i0].v;
+                    var i1 = Math.min(pts.length - 1, i2 + JITTERCOUNT);
+                    var pmax = pts[i1].v;
+                    if (mode !== "all") {
+                      if (pts[i2].v < d2.lf) pmax = Math.min(pmax, d2.lf);
+                      else pmin = Math.max(pmin, d2.uf);
+                    }
+                    var jitterFactor = Math.sqrt(spreadLimit * (i1 - i0) / (pmax - pmin + minSpread)) || 0;
+                    jitterFactor = Lib.constrain(Math.abs(jitterFactor), 0, 1);
+                    jitterFactors.push(jitterFactor);
+                    maxJitterFactor = Math.max(jitterFactor, maxJitterFactor);
+                  }
+                }
+                newJitter = trace.jitter * 2 / (maxJitterFactor || 1);
+              }
+              for (i2 = 0; i2 < pts.length; i2++) {
+                var pt2 = pts[i2];
+                var v2 = pt2.v;
+                var jitterOffset = trace.jitter ? newJitter * jitterFactors[i2] * (Lib.pseudoRandom() - 0.5) : 0;
+                var posPx = d2.pos + bPos + bdPos * (trace.pointpos + jitterOffset);
+                if (trace.orientation === "h") {
+                  pt2.y = posPx;
+                  pt2.x = v2;
+                } else {
+                  pt2.x = posPx;
+                  pt2.y = v2;
+                }
+                if (mode === "suspectedoutliers" && v2 < d2.uo && v2 > d2.lo) {
+                  pt2.so = true;
+                }
+              }
+              return pts;
+            });
+            paths.enter().append("path").classed("point", true);
+            paths.exit().remove();
+            paths.call(Drawing.translatePoints, xa, ya2);
+          }
+          function plotBoxMean(sel, axes, trace, t4) {
+            var valAxis = axes.val;
+            var posAxis = axes.pos;
+            var posHasRangeBreaks = !!posAxis.rangebreaks;
+            var bPos = t4.bPos;
+            var bPosPxOffset = t4.bPosPxOffset || 0;
+            var mode = trace.boxmean || (trace.meanline || {}).visible;
+            var bdPos0;
+            var bdPos1;
+            if (Array.isArray(t4.bdPos)) {
+              bdPos0 = t4.bdPos[0];
+              bdPos1 = t4.bdPos[1];
+            } else {
+              bdPos0 = t4.bdPos;
+              bdPos1 = t4.bdPos;
+            }
+            var paths = sel.selectAll("path.mean").data(trace.type === "box" && trace.boxmean || trace.type === "violin" && trace.box.visible && trace.meanline.visible ? Lib.identity : []);
+            paths.enter().append("path").attr("class", "mean").style({
+              fill: "none",
+              "vector-effect": "non-scaling-stroke"
+            });
+            paths.exit().remove();
+            paths.each(function(d2) {
+              var lcenter = posAxis.c2l(d2.pos + bPos, true);
+              var pos0 = posAxis.l2p(lcenter - bdPos0) + bPosPxOffset;
+              var pos1 = posAxis.l2p(lcenter + bdPos1) + bPosPxOffset;
+              var posc = posHasRangeBreaks ? (pos0 + pos1) / 2 : posAxis.l2p(lcenter) + bPosPxOffset;
+              var m2 = valAxis.c2p(d2.mean, true);
+              var sl2 = valAxis.c2p(d2.mean - d2.sd, true);
+              var sh2 = valAxis.c2p(d2.mean + d2.sd, true);
+              if (trace.orientation === "h") {
+                d3.select(this).attr(
+                  "d",
+                  "M" + m2 + "," + pos0 + "V" + pos1 + (mode === "sd" ? "m0,0L" + sl2 + "," + posc + "L" + m2 + "," + pos0 + "L" + sh2 + "," + posc + "Z" : "")
+                );
+              } else {
+                d3.select(this).attr(
+                  "d",
+                  "M" + pos0 + "," + m2 + "H" + pos1 + (mode === "sd" ? "m0,0L" + posc + "," + sl2 + "L" + pos0 + "," + m2 + "L" + posc + "," + sh2 + "Z" : "")
+                );
+              }
+            });
+          }
+          module2.exports = {
+            plot,
+            plotBoxAndWhiskers,
+            plotPoints,
+            plotBoxMean
+          };
+        }
+      });
+      var require_style5 = __commonJS({
+        "src/traces/box/style.js"(exports, module2) {
+          var d3 = require_d3();
+          var Color2 = require_color();
+          var Drawing = require_drawing();
+          function style(gd2, cd2, sel) {
+            var s2 = sel ? sel : d3.select(gd2).selectAll("g.trace.boxes");
+            s2.style("opacity", function(d2) {
+              return d2[0].trace.opacity;
+            });
+            s2.each(function(d2) {
+              var el2 = d3.select(this);
+              var trace = d2[0].trace;
+              var lineWidth = trace.line.width;
+              function styleBox(boxSel, lineWidth2, lineColor, fillColor) {
+                boxSel.style("stroke-width", lineWidth2 + "px").call(Color2.stroke, lineColor).call(Color2.fill, fillColor);
+              }
+              var allBoxes = el2.selectAll("path.box");
+              if (trace.type === "candlestick") {
+                allBoxes.each(function(boxData) {
+                  if (boxData.empty) return;
+                  var thisBox = d3.select(this);
+                  var container = trace[boxData.dir];
+                  styleBox(thisBox, container.line.width, container.line.color, container.fillcolor);
+                  thisBox.style("opacity", trace.selectedpoints && !boxData.selected ? 0.3 : 1);
+                });
+              } else {
+                styleBox(allBoxes, lineWidth, trace.line.color, trace.fillcolor);
+                el2.selectAll("path.mean").style({
+                  "stroke-width": lineWidth,
+                  "stroke-dasharray": 2 * lineWidth + "px," + lineWidth + "px"
+                }).call(Color2.stroke, trace.line.color);
+                var pts = el2.selectAll("path.point");
+                Drawing.pointStyle(pts, trace, gd2);
+              }
+            });
+          }
+          function styleOnSelect(gd2, cd2, sel) {
+            var trace = cd2[0].trace;
+            var pts = sel.selectAll("path.point");
+            if (trace.selectedpoints) {
+              Drawing.selectedPointStyle(pts, trace);
+            } else {
+              Drawing.pointStyle(pts, trace, gd2);
+            }
+          }
+          module2.exports = {
+            style,
+            styleOnSelect
+          };
+        }
+      });
+      var require_hover4 = __commonJS({
+        "src/traces/box/hover.js"(exports, module2) {
+          var Axes = require_axes();
+          var Lib = require_lib();
+          var Fx = require_fx();
+          var Color2 = require_color();
+          var fillText = Lib.fillText;
+          function hoverPoints(pointData, xval, yval, hovermode) {
+            var cd2 = pointData.cd;
+            var trace = cd2[0].trace;
+            var hoveron = trace.hoveron;
+            var closeBoxData = [];
+            var closePtData;
+            if (hoveron.indexOf("boxes") !== -1) {
+              closeBoxData = closeBoxData.concat(hoverOnBoxes(pointData, xval, yval, hovermode));
+            }
+            if (hoveron.indexOf("points") !== -1) {
+              closePtData = hoverOnPoints(pointData, xval, yval);
+            }
+            if (hovermode === "closest") {
+              if (closePtData) return [closePtData];
+              return closeBoxData;
+            }
+            if (closePtData) {
+              closeBoxData.push(closePtData);
+              return closeBoxData;
+            }
+            return closeBoxData;
+          }
+          function hoverOnBoxes(pointData, xval, yval, hovermode) {
+            var cd2 = pointData.cd;
+            var xa = pointData.xa;
+            var ya2 = pointData.ya;
+            var trace = cd2[0].trace;
+            var t4 = cd2[0].t;
+            var isViolin = trace.type === "violin";
+            var pLetter, vLetter, pAxis, vAxis, vVal, pVal, dx, dy, dPos, hoverPseudoDistance, spikePseudoDistance;
+            var boxDelta = t4.bdPos;
+            var boxDeltaPos, boxDeltaNeg;
+            var posAcceptance = t4.wHover;
+            var shiftPos = function(di22) {
+              return pAxis.c2l(di22.pos) + t4.bPos - pAxis.c2l(pVal);
+            };
+            if (isViolin && trace.side !== "both") {
+              if (trace.side === "positive") {
+                dPos = function(di22) {
+                  var pos = shiftPos(di22);
+                  return Fx.inbox(pos, pos + posAcceptance, hoverPseudoDistance);
+                };
+                boxDeltaPos = boxDelta;
+                boxDeltaNeg = 0;
+              }
+              if (trace.side === "negative") {
+                dPos = function(di22) {
+                  var pos = shiftPos(di22);
+                  return Fx.inbox(pos - posAcceptance, pos, hoverPseudoDistance);
+                };
+                boxDeltaPos = 0;
+                boxDeltaNeg = boxDelta;
+              }
+            } else {
+              dPos = function(di22) {
+                var pos = shiftPos(di22);
+                return Fx.inbox(pos - posAcceptance, pos + posAcceptance, hoverPseudoDistance);
+              };
+              boxDeltaPos = boxDeltaNeg = boxDelta;
+            }
+            var dVal;
+            if (isViolin) {
+              dVal = function(di22) {
+                return Fx.inbox(di22.span[0] - vVal, di22.span[1] - vVal, hoverPseudoDistance);
+              };
+            } else {
+              dVal = function(di22) {
+                return Fx.inbox(di22.min - vVal, di22.max - vVal, hoverPseudoDistance);
+              };
+            }
+            if (trace.orientation === "h") {
+              vVal = xval;
+              pVal = yval;
+              dx = dVal;
+              dy = dPos;
+              pLetter = "y";
+              pAxis = ya2;
+              vLetter = "x";
+              vAxis = xa;
+            } else {
+              vVal = yval;
+              pVal = xval;
+              dx = dPos;
+              dy = dVal;
+              pLetter = "x";
+              pAxis = xa;
+              vLetter = "y";
+              vAxis = ya2;
+            }
+            var pseudoDistance = Math.min(1, boxDelta / Math.abs(pAxis.r2c(pAxis.range[1]) - pAxis.r2c(pAxis.range[0])));
+            hoverPseudoDistance = pointData.maxHoverDistance - pseudoDistance;
+            spikePseudoDistance = pointData.maxSpikeDistance - pseudoDistance;
+            function dxy(di22) {
+              return (dx(di22) + dy(di22)) / 2;
+            }
+            var distfn = Fx.getDistanceFunction(hovermode, dx, dy, dxy);
+            Fx.getClosest(cd2, distfn, pointData);
+            if (pointData.index === false) return [];
+            var di2 = cd2[pointData.index];
+            var lc2 = trace.line.color;
+            var mc2 = (trace.marker || {}).color;
+            if (Color2.opacity(lc2) && trace.line.width) pointData.color = lc2;
+            else if (Color2.opacity(mc2) && trace.boxpoints) pointData.color = mc2;
+            else pointData.color = trace.fillcolor;
+            pointData[pLetter + "0"] = pAxis.c2p(di2.pos + t4.bPos - boxDeltaNeg, true);
+            pointData[pLetter + "1"] = pAxis.c2p(di2.pos + t4.bPos + boxDeltaPos, true);
+            pointData[pLetter + "LabelVal"] = di2.orig_p !== void 0 ? di2.orig_p : di2.pos;
+            var spikePosAttr = pLetter + "Spike";
+            pointData.spikeDistance = dxy(di2) * spikePseudoDistance / hoverPseudoDistance;
+            pointData[spikePosAttr] = pAxis.c2p(di2.pos, true);
+            var hasMean = trace.boxmean || trace.sizemode === "sd" || (trace.meanline || {}).visible;
+            var hasFences = trace.boxpoints || trace.points;
+            var attrs = hasFences && hasMean ? ["max", "uf", "q3", "med", "mean", "q1", "lf", "min"] : hasFences && !hasMean ? ["max", "uf", "q3", "med", "q1", "lf", "min"] : !hasFences && hasMean ? ["max", "q3", "med", "mean", "q1", "min"] : ["max", "q3", "med", "q1", "min"];
+            var rev = vAxis.range[1] < vAxis.range[0];
+            if (trace.orientation === (rev ? "v" : "h")) {
+              attrs.reverse();
+            }
+            var spikeDistance = pointData.spikeDistance;
+            var spikePosition = pointData[spikePosAttr];
+            var closeBoxData = [];
+            for (var i2 = 0; i2 < attrs.length; i2++) {
+              var attr = attrs[i2];
+              if (!(attr in di2)) continue;
+              var val = di2[attr];
+              var valPx = vAxis.c2p(val, true);
+              var pointData2 = Lib.extendFlat({}, pointData);
+              pointData2.attr = attr;
+              pointData2[vLetter + "0"] = pointData2[vLetter + "1"] = valPx;
+              pointData2[vLetter + "LabelVal"] = val;
+              pointData2[vLetter + "Label"] = (t4.labels ? t4.labels[attr] + " " : "") + Axes.hoverLabelText(vAxis, val, trace[vLetter + "hoverformat"]);
+              pointData2.hoverOnBox = true;
+              if (attr === "mean" && "sd" in di2 && (trace.boxmean === "sd" || trace.sizemode === "sd")) {
+                pointData2[vLetter + "err"] = di2.sd;
+              }
+              pointData2.hovertemplate = false;
+              closeBoxData.push(pointData2);
+            }
+            pointData.name = "";
+            pointData.spikeDistance = void 0;
+            pointData[spikePosAttr] = void 0;
+            for (var k2 = 0; k2 < closeBoxData.length; k2++) {
+              if (closeBoxData[k2].attr !== "med") {
+                closeBoxData[k2].name = "";
+                closeBoxData[k2].spikeDistance = void 0;
+                closeBoxData[k2][spikePosAttr] = void 0;
+              } else {
+                closeBoxData[k2].spikeDistance = spikeDistance;
+                closeBoxData[k2][spikePosAttr] = spikePosition;
+              }
+            }
+            return closeBoxData;
+          }
+          function hoverOnPoints(pointData, xval, yval) {
+            var cd2 = pointData.cd;
+            var xa = pointData.xa;
+            var ya2 = pointData.ya;
+            var trace = cd2[0].trace;
+            var xPx = xa.c2p(xval);
+            var yPx = ya2.c2p(yval);
+            var closePtData;
+            var dx = function(di22) {
+              var rad2 = Math.max(3, di22.mrc || 0);
+              return Math.max(Math.abs(xa.c2p(di22.x) - xPx) - rad2, 1 - 3 / rad2);
+            };
+            var dy = function(di22) {
+              var rad2 = Math.max(3, di22.mrc || 0);
+              return Math.max(Math.abs(ya2.c2p(di22.y) - yPx) - rad2, 1 - 3 / rad2);
+            };
+            var distfn = Fx.quadrature(dx, dy);
+            var ijClosest = false;
+            var di2, pt2;
+            for (var i2 = 0; i2 < cd2.length; i2++) {
+              di2 = cd2[i2];
+              for (var j2 = 0; j2 < (di2.pts || []).length; j2++) {
+                pt2 = di2.pts[j2];
+                var newDistance = distfn(pt2);
+                if (newDistance <= pointData.distance) {
+                  pointData.distance = newDistance;
+                  ijClosest = [i2, j2];
+                }
+              }
+            }
+            if (!ijClosest) return false;
+            di2 = cd2[ijClosest[0]];
+            pt2 = di2.pts[ijClosest[1]];
+            var xc2 = xa.c2p(pt2.x, true);
+            var yc2 = ya2.c2p(pt2.y, true);
+            var rad = pt2.mrc || 1;
+            closePtData = Lib.extendFlat({}, pointData, {
+              // corresponds to index in x/y input data array
+              index: pt2.i,
+              color: (trace.marker || {}).color,
+              name: trace.name,
+              x0: xc2 - rad,
+              x1: xc2 + rad,
+              y0: yc2 - rad,
+              y1: yc2 + rad,
+              spikeDistance: pointData.distance,
+              hovertemplate: trace.hovertemplate
+            });
+            var origPos = di2.orig_p;
+            var pos = origPos !== void 0 ? origPos : di2.pos;
+            var pa2;
+            if (trace.orientation === "h") {
+              pa2 = ya2;
+              closePtData.xLabelVal = pt2.x;
+              closePtData.yLabelVal = pos;
+            } else {
+              pa2 = xa;
+              closePtData.xLabelVal = pos;
+              closePtData.yLabelVal = pt2.y;
+            }
+            var pLetter = pa2._id.charAt(0);
+            closePtData[pLetter + "Spike"] = pa2.c2p(di2.pos, true);
+            fillText(pt2, trace, closePtData);
+            return closePtData;
+          }
+          module2.exports = {
+            hoverPoints,
+            hoverOnBoxes,
+            hoverOnPoints
+          };
+        }
+      });
+      var require_event_data2 = __commonJS({
+        "src/traces/box/event_data.js"(exports, module2) {
+          module2.exports = function eventData(out, pt2) {
+            if (pt2.hoverOnBox) out.hoverOnBox = pt2.hoverOnBox;
+            if ("xVal" in pt2) out.x = pt2.xVal;
+            if ("yVal" in pt2) out.y = pt2.yVal;
+            if (pt2.xa) out.xaxis = pt2.xa;
+            if (pt2.ya) out.yaxis = pt2.ya;
+            return out;
+          };
+        }
+      });
+      var require_select4 = __commonJS({
+        "src/traces/box/select.js"(exports, module2) {
+          module2.exports = function selectPoints(searchInfo, selectionTester) {
+            var cd2 = searchInfo.cd;
+            var xa = searchInfo.xaxis;
+            var ya2 = searchInfo.yaxis;
+            var selection = [];
+            var i2, j2;
+            if (selectionTester === false) {
+              for (i2 = 0; i2 < cd2.length; i2++) {
+                for (j2 = 0; j2 < (cd2[i2].pts || []).length; j2++) {
+                  cd2[i2].pts[j2].selected = 0;
+                }
+              }
+            } else {
+              for (i2 = 0; i2 < cd2.length; i2++) {
+                for (j2 = 0; j2 < (cd2[i2].pts || []).length; j2++) {
+                  var pt2 = cd2[i2].pts[j2];
+                  var x2 = xa.c2p(pt2.x);
+                  var y2 = ya2.c2p(pt2.y);
+                  if (selectionTester.contains([x2, y2], null, pt2.i, searchInfo)) {
+                    selection.push({
+                      pointNumber: pt2.i,
+                      x: xa.c2d(pt2.x),
+                      y: ya2.c2d(pt2.y)
+                    });
+                    pt2.selected = 1;
+                  } else {
+                    pt2.selected = 0;
+                  }
+                }
+              }
+            }
+            return selection;
+          };
+        }
+      });
+      var require_box = __commonJS({
+        "src/traces/box/index.js"(exports, module2) {
+          module2.exports = {
+            attributes: require_attributes24(),
+            layoutAttributes: require_layout_attributes7(),
+            supplyDefaults: require_defaults20().supplyDefaults,
+            crossTraceDefaults: require_defaults20().crossTraceDefaults,
+            supplyLayoutDefaults: require_layout_defaults6().supplyLayoutDefaults,
+            calc: require_calc6(),
+            crossTraceCalc: require_cross_trace_calc3().crossTraceCalc,
+            plot: require_plot4().plot,
+            style: require_style5().style,
+            styleOnSelect: require_style5().styleOnSelect,
+            hoverPoints: require_hover4().hoverPoints,
+            eventData: require_event_data2(),
+            selectPoints: require_select4(),
+            moduleType: "trace",
+            name: "box",
+            basePlotModule: require_cartesian(),
+            categories: ["cartesian", "svg", "symbols", "oriented", "box-violin", "showLegend", "boxLayout", "zoomScale"],
+            meta: {}
+          };
+        }
+      });
+      var require_box2 = __commonJS({
+        "lib/box.js"(exports, module2) {
+          module2.exports = require_box();
+        }
+      });
+      var require_attributes25 = __commonJS({
+        "src/traces/heatmap/attributes.js"(exports, module2) {
+          var colorScaleAttrs = require_attributes8();
+          var { extendFlat } = require_extend();
+          var baseAttrs = require_attributes2();
+          var { axisHoverFormat } = require_axis_format_attributes();
+          var fontAttrs = require_font_attributes();
+          var { hovertemplateAttrs, templatefallbackAttrs, texttemplateAttrs } = require_template_attributes();
+          var scatterAttrs = require_attributes12();
+          module2.exports = extendFlat(
+            {
+              z: {
+                valType: "data_array",
+                editType: "calc"
+              },
+              x: extendFlat({}, scatterAttrs.x, { impliedEdits: { xtype: "array" } }),
+              x0: extendFlat({}, scatterAttrs.x0, { impliedEdits: { xtype: "scaled" } }),
+              dx: extendFlat({}, scatterAttrs.dx, { impliedEdits: { xtype: "scaled" } }),
+              y: extendFlat({}, scatterAttrs.y, { impliedEdits: { ytype: "array" } }),
+              y0: extendFlat({}, scatterAttrs.y0, { impliedEdits: { ytype: "scaled" } }),
+              dy: extendFlat({}, scatterAttrs.dy, { impliedEdits: { ytype: "scaled" } }),
+              xperiod: extendFlat({}, scatterAttrs.xperiod, { impliedEdits: { xtype: "scaled" } }),
+              yperiod: extendFlat({}, scatterAttrs.yperiod, { impliedEdits: { ytype: "scaled" } }),
+              xperiod0: extendFlat({}, scatterAttrs.xperiod0, { impliedEdits: { xtype: "scaled" } }),
+              yperiod0: extendFlat({}, scatterAttrs.yperiod0, { impliedEdits: { ytype: "scaled" } }),
+              xperiodalignment: extendFlat({}, scatterAttrs.xperiodalignment, { impliedEdits: { xtype: "scaled" } }),
+              yperiodalignment: extendFlat({}, scatterAttrs.yperiodalignment, { impliedEdits: { ytype: "scaled" } }),
+              text: {
+                valType: "data_array",
+                editType: "calc"
+              },
+              hovertext: {
+                valType: "data_array",
+                editType: "calc"
+              },
+              transpose: {
+                valType: "boolean",
+                dflt: false,
+                editType: "calc"
+              },
+              xtype: {
+                valType: "enumerated",
+                values: ["array", "scaled"],
+                editType: "calc+clearAxisTypes"
+              },
+              ytype: {
+                valType: "enumerated",
+                values: ["array", "scaled"],
+                editType: "calc+clearAxisTypes"
+              },
+              zsmooth: {
+                valType: "enumerated",
+                values: ["fast", "best", false],
+                dflt: false,
+                editType: "calc"
+              },
+              hoverongaps: {
+                valType: "boolean",
+                dflt: true,
+                editType: "none"
+              },
+              connectgaps: {
+                valType: "boolean",
+                editType: "calc"
+              },
+              xgap: {
+                valType: "number",
+                dflt: 0,
+                min: 0,
+                editType: "plot"
+              },
+              ygap: {
+                valType: "number",
+                dflt: 0,
+                min: 0,
+                editType: "plot"
+              },
+              xhoverformat: axisHoverFormat("x"),
+              yhoverformat: axisHoverFormat("y"),
+              zhoverformat: axisHoverFormat("z", 1),
+              hovertemplate: hovertemplateAttrs(),
+              hovertemplatefallback: templatefallbackAttrs(),
+              texttemplate: texttemplateAttrs({ arrayOk: false, editType: "plot" }, { keys: ["x", "y", "z", "text"] }),
+              texttemplatefallback: templatefallbackAttrs({ editType: "plot" }),
+              textfont: fontAttrs({
+                editType: "plot",
+                autoSize: true,
+                autoColor: true,
+                colorEditType: "style"
+              }),
+              showlegend: extendFlat({}, baseAttrs.showlegend, { dflt: false }),
+              zorder: scatterAttrs.zorder
+            },
+            colorScaleAttrs("", { cLetter: "z", autoColorDflt: false })
+          );
+        }
+      });
+      var require_xyz_defaults = __commonJS({
+        "src/traces/heatmap/xyz_defaults.js"(exports, module2) {
+          var isNumeric = require_fast_isnumeric();
+          var Lib = require_lib();
+          var Registry = require_registry();
+          module2.exports = function handleXYZDefaults(traceIn, traceOut, coerce, layout, xName, yName) {
+            var z2 = coerce("z");
+            xName = xName || "x";
+            yName = yName || "y";
+            var x2, y2;
+            if (z2 === void 0 || !z2.length) return 0;
+            if (Lib.isArray1D(z2)) {
+              x2 = coerce(xName);
+              y2 = coerce(yName);
+              var xlen = Lib.minRowLength(x2);
+              var ylen = Lib.minRowLength(y2);
+              if (xlen === 0 || ylen === 0) return 0;
+              traceOut._length = Math.min(xlen, ylen, z2.length);
+            } else {
+              x2 = coordDefaults(xName, coerce);
+              y2 = coordDefaults(yName, coerce);
+              if (!isValidZ(z2)) return 0;
+              coerce("transpose");
+              traceOut._length = null;
+            }
+            var handleCalendarDefaults = Registry.getComponentMethod("calendars", "handleTraceDefaults");
+            handleCalendarDefaults(traceIn, traceOut, [xName, yName], layout);
+            return true;
+          };
+          function coordDefaults(coordStr, coerce) {
+            var coord = coerce(coordStr);
+            var coordType = coord ? coerce(coordStr + "type", "array") : "scaled";
+            if (coordType === "scaled") {
+              coerce(coordStr + "0");
+              coerce("d" + coordStr);
+            }
+            return coord;
+          }
+          function isValidZ(z2) {
+            var allRowsAreArrays = true;
+            var oneRowIsFilled = false;
+            var hasOneNumber = false;
+            var zi2;
+            for (var i2 = 0; i2 < z2.length; i2++) {
+              zi2 = z2[i2];
+              if (!Lib.isArrayOrTypedArray(zi2)) {
+                allRowsAreArrays = false;
+                break;
+              }
+              if (zi2.length > 0) oneRowIsFilled = true;
+              for (var j2 = 0; j2 < zi2.length; j2++) {
+                if (isNumeric(zi2[j2])) {
+                  hasOneNumber = true;
+                  break;
+                }
+              }
+            }
+            return allRowsAreArrays && oneRowIsFilled && hasOneNumber;
+          }
+        }
+      });
+      var require_label_defaults = __commonJS({
+        "src/traces/heatmap/label_defaults.js"(exports, module2) {
+          var Lib = require_lib();
+          module2.exports = function handleHeatmapLabelDefaults(coerce, layout) {
+            coerce("texttemplate");
+            coerce("texttemplatefallback");
+            var fontDflt = Lib.extendFlat({}, layout.font, {
+              color: "auto",
+              size: "auto"
+            });
+            Lib.coerceFont(coerce, "textfont", fontDflt);
+          };
+        }
+      });
+      var require_style_defaults2 = __commonJS({
+        "src/traces/heatmap/style_defaults.js"(exports, module2) {
+          module2.exports = function handleStyleDefaults(traceIn, traceOut, coerce) {
+            var zsmooth = coerce("zsmooth");
+            if (zsmooth === false) {
+              coerce("xgap");
+              coerce("ygap");
+            }
+            coerce("zhoverformat");
+          };
+        }
+      });
+      var require_defaults21 = __commonJS({
+        "src/traces/heatmap/defaults.js"(exports, module2) {
+          var Lib = require_lib();
+          var handleXYZDefaults = require_xyz_defaults();
+          var handleHeatmapLabelDefaults = require_label_defaults();
+          var handlePeriodDefaults = require_period_defaults();
+          var handleStyleDefaults = require_style_defaults2();
+          var colorscaleDefaults = require_defaults2();
+          var attributes = require_attributes25();
+          module2.exports = function supplyDefaults(traceIn, traceOut, defaultColor, layout) {
+            function coerce(attr, dflt) {
+              return Lib.coerce(traceIn, traceOut, attributes, attr, dflt);
+            }
+            var validData = handleXYZDefaults(traceIn, traceOut, coerce, layout);
+            if (!validData) {
+              traceOut.visible = false;
+              return;
+            }
+            handlePeriodDefaults(traceIn, traceOut, layout, coerce);
+            coerce("xhoverformat");
+            coerce("yhoverformat");
+            coerce("text");
+            coerce("hovertext");
+            coerce("hovertemplate");
+            coerce("hovertemplatefallback");
+            handleHeatmapLabelDefaults(coerce, layout);
+            handleStyleDefaults(traceIn, traceOut, coerce, layout);
+            coerce("hoverongaps");
+            coerce("connectgaps", Lib.isArray1D(traceOut.z) && traceOut.zsmooth !== false);
+            colorscaleDefaults(traceIn, traceOut, layout, coerce, { prefix: "", cLetter: "z" });
+            coerce("zorder");
+          };
+        }
+      });
+      var require_bin_functions = __commonJS({
+        "src/traces/histogram/bin_functions.js"(exports, module2) {
+          var isNumeric = require_fast_isnumeric();
+          module2.exports = {
+            count: function(n2, i2, size) {
+              size[n2]++;
+              return 1;
+            },
+            sum: function(n2, i2, size, counterData) {
+              var v2 = counterData[i2];
+              if (isNumeric(v2)) {
+                v2 = Number(v2);
+                size[n2] += v2;
+                return v2;
+              }
+              return 0;
+            },
+            avg: function(n2, i2, size, counterData, counts) {
+              var v2 = counterData[i2];
+              if (isNumeric(v2)) {
+                v2 = Number(v2);
+                size[n2] += v2;
+                counts[n2]++;
+              }
+              return 0;
+            },
+            min: function(n2, i2, size, counterData) {
+              var v2 = counterData[i2];
+              if (isNumeric(v2)) {
+                v2 = Number(v2);
+                if (!isNumeric(size[n2])) {
+                  size[n2] = v2;
+                  return v2;
+                } else if (size[n2] > v2) {
+                  var delta = v2 - size[n2];
+                  size[n2] = v2;
+                  return delta;
+                }
+              }
+              return 0;
+            },
+            max: function(n2, i2, size, counterData) {
+              var v2 = counterData[i2];
+              if (isNumeric(v2)) {
+                v2 = Number(v2);
+                if (!isNumeric(size[n2])) {
+                  size[n2] = v2;
+                  return v2;
+                } else if (size[n2] < v2) {
+                  var delta = v2 - size[n2];
+                  size[n2] = v2;
+                  return delta;
+                }
+              }
+              return 0;
+            }
+          };
+        }
+      });
+      var require_norm_functions = __commonJS({
+        "src/traces/histogram/norm_functions.js"(exports, module2) {
+          module2.exports = {
+            percent: function(size, total) {
+              var nMax = size.length;
+              var norm = 100 / total;
+              for (var n2 = 0; n2 < nMax; n2++) size[n2] *= norm;
+            },
+            probability: function(size, total) {
+              var nMax = size.length;
+              for (var n2 = 0; n2 < nMax; n2++) size[n2] /= total;
+            },
+            density: function(size, total, inc, yinc) {
+              var nMax = size.length;
+              yinc = yinc || 1;
+              for (var n2 = 0; n2 < nMax; n2++) size[n2] *= inc[n2] * yinc;
+            },
+            "probability density": function(size, total, inc, yinc) {
+              var nMax = size.length;
+              if (yinc) total /= yinc;
+              for (var n2 = 0; n2 < nMax; n2++) size[n2] *= inc[n2] / total;
+            }
+          };
+        }
+      });
+      var require_average = __commonJS({
+        "src/traces/histogram/average.js"(exports, module2) {
+          module2.exports = function doAvg(size, counts) {
+            var nMax = size.length;
+            var total = 0;
+            for (var i2 = 0; i2 < nMax; i2++) {
+              if (counts[i2]) {
+                size[i2] /= counts[i2];
+                total += size[i2];
+              } else size[i2] = null;
+            }
+            return total;
+          };
+        }
+      });
+      var require_bin_label_vals = __commonJS({
+        "src/traces/histogram/bin_label_vals.js"(exports, module2) {
+          var numConstants = require_numerical();
+          var oneYear = numConstants.ONEAVGYEAR;
+          var oneMonth = numConstants.ONEAVGMONTH;
+          var oneDay = numConstants.ONEDAY;
+          var oneHour = numConstants.ONEHOUR;
+          var oneMin = numConstants.ONEMIN;
+          var oneSec = numConstants.ONESEC;
+          var tickIncrement = require_axes().tickIncrement;
+          module2.exports = function getBinSpanLabelRound(leftGap, rightGap, binEdges, pa2, calendar) {
+            var dv0 = -1.1 * rightGap;
+            var dv1 = -0.1 * rightGap;
+            var dv2 = leftGap - dv1;
+            var edge0 = binEdges[0];
+            var edge1 = binEdges[1];
+            var leftDigit = Math.min(
+              biggestDigitChanged(edge0 + dv1, edge0 + dv2, pa2, calendar),
+              biggestDigitChanged(edge1 + dv1, edge1 + dv2, pa2, calendar)
+            );
+            var rightDigit = Math.min(
+              biggestDigitChanged(edge0 + dv0, edge0 + dv1, pa2, calendar),
+              biggestDigitChanged(edge1 + dv0, edge1 + dv1, pa2, calendar)
+            );
+            var digit, disambiguateEdges;
+            if (leftDigit > rightDigit && rightDigit < Math.abs(edge1 - edge0) / 4e3) {
+              digit = leftDigit;
+              disambiguateEdges = false;
+            } else {
+              digit = Math.min(leftDigit, rightDigit);
+              disambiguateEdges = true;
+            }
+            if (pa2.type === "date" && digit > oneDay) {
+              var dashExclude = digit === oneYear ? 1 : 6;
+              var increment = digit === oneYear ? "M12" : "M1";
+              return function(v2, isRightEdge) {
+                var dateStr = pa2.c2d(v2, oneYear, calendar);
+                var dashPos = dateStr.indexOf("-", dashExclude);
+                if (dashPos > 0) dateStr = dateStr.slice(0, dashPos);
+                var roundedV = pa2.d2c(dateStr, 0, calendar);
+                if (roundedV < v2) {
+                  var nextV = tickIncrement(roundedV, increment, false, calendar);
+                  if ((roundedV + nextV) / 2 < v2 + leftGap) roundedV = nextV;
+                }
+                if (isRightEdge && disambiguateEdges) {
+                  return tickIncrement(roundedV, increment, true, calendar);
+                }
+                return roundedV;
+              };
+            }
+            return function(v2, isRightEdge) {
+              var roundedV = digit * Math.round(v2 / digit);
+              if (roundedV + digit / 10 < v2 && roundedV + digit * 0.9 < v2 + leftGap) {
+                roundedV += digit;
+              }
+              if (isRightEdge && disambiguateEdges) {
+                roundedV -= digit;
+              }
+              return roundedV;
+            };
+          };
+          function biggestDigitChanged(v1, v2, pa2, calendar) {
+            if (v1 * v2 <= 0) return Infinity;
+            var dv = Math.abs(v2 - v1);
+            var isDate = pa2.type === "date";
+            var digit = biggestGuaranteedDigitChanged(dv, isDate);
+            for (var i2 = 0; i2 < 10; i2++) {
+              var nextDigit = biggestGuaranteedDigitChanged(digit * 80, isDate);
+              if (digit === nextDigit) break;
+              if (didDigitChange(nextDigit, v1, v2, isDate, pa2, calendar)) digit = nextDigit;
+              else break;
+            }
+            return digit;
+          }
+          function biggestGuaranteedDigitChanged(dv, isDate) {
+            if (isDate && dv > oneSec) {
+              if (dv > oneDay) {
+                if (dv > oneYear * 1.1) return oneYear;
+                if (dv > oneMonth * 1.1) return oneMonth;
+                return oneDay;
+              }
+              if (dv > oneHour) return oneHour;
+              if (dv > oneMin) return oneMin;
+              return oneSec;
+            }
+            return Math.pow(10, Math.floor(Math.log(dv) / Math.LN10));
+          }
+          function didDigitChange(digit, v1, v2, isDate, pa2, calendar) {
+            if (isDate && digit > oneDay) {
+              var dateParts1 = dateParts(v1, pa2, calendar);
+              var dateParts2 = dateParts(v2, pa2, calendar);
+              var parti = digit === oneYear ? 0 : 1;
+              return dateParts1[parti] !== dateParts2[parti];
+            }
+            return Math.floor(v2 / digit) - Math.floor(v1 / digit) > 0.1;
+          }
+          function dateParts(v2, pa2, calendar) {
+            var parts = pa2.c2d(v2, oneYear, calendar).split("-");
+            if (parts[0] === "") {
+              parts.unshift();
+              parts[0] = "-" + parts[0];
+            }
+            return parts;
+          }
+        }
+      });
+      var require_calc7 = __commonJS({
+        "src/traces/histogram/calc.js"(exports, module2) {
+          var isNumeric = require_fast_isnumeric();
+          var Lib = require_lib();
+          var Registry = require_registry();
+          var Axes = require_axes();
+          var { hasColorscale } = require_helpers();
+          var colorscaleCalc = require_calc();
+          var arraysToCalcdata = require_arrays_to_calcdata2();
+          var binFunctions = require_bin_functions();
+          var normFunctions = require_norm_functions();
+          var doAvg = require_average();
+          var getBinSpanLabelRound = require_bin_label_vals();
+          function calc(gd2, trace) {
+            var pos = [];
+            var size = [];
+            var isHorizontal = trace.orientation === "h";
+            var pa2 = Axes.getFromId(gd2, isHorizontal ? trace.yaxis : trace.xaxis);
+            var mainData = isHorizontal ? "y" : "x";
+            var counterData = { x: "y", y: "x" }[mainData];
+            var calendar = trace[mainData + "calendar"];
+            var cumulativeSpec = trace.cumulative;
+            var i2;
+            var binsAndPos = calcAllAutoBins(gd2, trace, pa2, mainData);
+            var binSpec = binsAndPos[0];
+            var pos0 = binsAndPos[1];
+            var nonuniformBins = typeof binSpec.size === "string";
+            var binEdges = [];
+            var bins = nonuniformBins ? binEdges : binSpec;
+            var inc = [];
+            var counts = [];
+            var inputPoints = [];
+            var total = 0;
+            var norm = trace.histnorm;
+            var func = trace.histfunc;
+            var densityNorm = norm.indexOf("density") !== -1;
+            var i22, binEnd, n2;
+            if (cumulativeSpec.enabled && densityNorm) {
+              norm = norm.replace(/ ?density$/, "");
+              densityNorm = false;
+            }
+            var extremeFunc = func === "max" || func === "min";
+            var sizeInit = extremeFunc ? null : 0;
+            var binFunc = binFunctions.count;
+            var normFunc = normFunctions[norm];
+            var isAvg = false;
+            var pr2c = function(v2) {
+              return pa2.r2c(v2, 0, calendar);
+            };
+            var rawCounterData;
+            if (Lib.isArrayOrTypedArray(trace[counterData]) && func !== "count") {
+              rawCounterData = trace[counterData];
+              isAvg = func === "avg";
+              binFunc = binFunctions[func];
+            }
+            i2 = pr2c(binSpec.start);
+            binEnd = pr2c(binSpec.end) + (i2 - Axes.tickIncrement(i2, binSpec.size, false, calendar)) / 1e6;
+            while (i2 < binEnd && pos.length < 1e6) {
+              i22 = Axes.tickIncrement(i2, binSpec.size, false, calendar);
+              pos.push((i2 + i22) / 2);
+              size.push(sizeInit);
+              inputPoints.push([]);
+              binEdges.push(i2);
+              if (densityNorm) inc.push(1 / (i22 - i2));
+              if (isAvg) counts.push(0);
+              if (i22 <= i2) break;
+              i2 = i22;
+            }
+            binEdges.push(i2);
+            if (!nonuniformBins && pa2.type === "date") {
+              bins = {
+                start: pr2c(bins.start),
+                end: pr2c(bins.end),
+                size: bins.size
+              };
+            }
+            if (!gd2._fullLayout._roundFnOpts) gd2._fullLayout._roundFnOpts = {};
+            var groupName = trace["_" + mainData + "bingroup"];
+            var roundFnOpts = { leftGap: Infinity, rightGap: Infinity };
+            if (groupName) {
+              if (!gd2._fullLayout._roundFnOpts[groupName]) gd2._fullLayout._roundFnOpts[groupName] = roundFnOpts;
+              roundFnOpts = gd2._fullLayout._roundFnOpts[groupName];
+            }
+            var nMax = size.length;
+            var uniqueValsPerBin = true;
+            var leftGap = roundFnOpts.leftGap;
+            var rightGap = roundFnOpts.rightGap;
+            var ptNumber2cdIndex = {};
+            for (i2 = 0; i2 < pos0.length; i2++) {
+              var posi = pos0[i2];
+              n2 = Lib.findBin(posi, bins);
+              if (n2 >= 0 && n2 < nMax) {
+                total += binFunc(n2, i2, size, rawCounterData, counts);
+                if (uniqueValsPerBin && inputPoints[n2].length && posi !== pos0[inputPoints[n2][0]]) {
+                  uniqueValsPerBin = false;
+                }
+                inputPoints[n2].push(i2);
+                ptNumber2cdIndex[i2] = n2;
+                leftGap = Math.min(leftGap, posi - binEdges[n2]);
+                rightGap = Math.min(rightGap, binEdges[n2 + 1] - posi);
+              }
+            }
+            roundFnOpts.leftGap = leftGap;
+            roundFnOpts.rightGap = rightGap;
+            var roundFn;
+            if (!uniqueValsPerBin) {
+              roundFn = function(v2, isRightEdge) {
+                return function() {
+                  var roundFnOpts2 = gd2._fullLayout._roundFnOpts[groupName];
+                  return getBinSpanLabelRound(
+                    roundFnOpts2.leftGap,
+                    roundFnOpts2.rightGap,
+                    binEdges,
+                    pa2,
+                    calendar
+                  )(v2, isRightEdge);
+                };
+              };
+            }
+            if (isAvg) total = doAvg(size, counts);
+            if (normFunc) normFunc(size, total, inc);
+            if (cumulativeSpec.enabled) cdf(size, cumulativeSpec.direction, cumulativeSpec.currentbin);
+            var seriesLen = Math.min(pos.length, size.length);
+            var cd2 = [];
+            var firstNonzero = 0;
+            var lastNonzero = seriesLen - 1;
+            for (i2 = 0; i2 < seriesLen; i2++) {
+              if (size[i2]) {
+                firstNonzero = i2;
+                break;
+              }
+            }
+            for (i2 = seriesLen - 1; i2 >= firstNonzero; i2--) {
+              if (size[i2]) {
+                lastNonzero = i2;
+                break;
+              }
+            }
+            for (i2 = firstNonzero; i2 <= lastNonzero; i2++) {
+              if (isNumeric(pos[i2]) && isNumeric(size[i2])) {
+                var cdi = {
+                  p: pos[i2],
+                  s: size[i2],
+                  b: 0
+                };
+                if (!cumulativeSpec.enabled) {
+                  cdi.pts = inputPoints[i2];
+                  if (uniqueValsPerBin) {
+                    cdi.ph0 = cdi.ph1 = inputPoints[i2].length ? pos0[inputPoints[i2][0]] : pos[i2];
+                  } else {
+                    trace._computePh = true;
+                    cdi.ph0 = roundFn(binEdges[i2]);
+                    cdi.ph1 = roundFn(binEdges[i2 + 1], true);
+                  }
+                }
+                cd2.push(cdi);
+              }
+            }
+            if (cd2.length === 1) {
+              cd2[0].width1 = Axes.tickIncrement(cd2[0].p, binSpec.size, false, calendar) - cd2[0].p;
+            }
+            if (hasColorscale(trace, "marker")) {
+              colorscaleCalc(gd2, trace, {
+                vals: trace.marker.color,
+                containerStr: "marker",
+                cLetter: "c"
+              });
+            }
+            if (hasColorscale(trace, "marker.line")) {
+              colorscaleCalc(gd2, trace, {
+                vals: trace.marker.line.color,
+                containerStr: "marker.line",
+                cLetter: "c"
+              });
+            }
+            arraysToCalcdata(cd2, trace);
+            if (Lib.isArrayOrTypedArray(trace.selectedpoints)) {
+              Lib.tagSelected(cd2, trace, ptNumber2cdIndex);
+            }
+            return cd2;
+          }
+          function calcAllAutoBins(gd2, trace, pa2, mainData, _overlayEdgeCase) {
+            var binAttr = mainData + "bins";
+            var fullLayout = gd2._fullLayout;
+            var groupName = trace["_" + mainData + "bingroup"];
+            var binOpts = fullLayout._histogramBinOpts[groupName];
+            var isOverlay = fullLayout.barmode === "overlay";
+            var i2, traces, tracei, calendar, pos0, autoVals, cumulativeSpec;
+            var r2c = function(v2) {
+              return pa2.r2c(v2, 0, calendar);
+            };
+            var c2r = function(v2) {
+              return pa2.c2r(v2, 0, calendar);
+            };
+            var cleanBound = pa2.type === "date" ? function(v2) {
+              return v2 || v2 === 0 ? Lib.cleanDate(v2, null, calendar) : null;
+            } : function(v2) {
+              return isNumeric(v2) ? Number(v2) : null;
+            };
+            function setBound(attr, bins, newBins) {
+              if (bins[attr + "Found"]) {
+                bins[attr] = cleanBound(bins[attr]);
+                if (bins[attr] === null) bins[attr] = newBins[attr];
+              } else {
+                autoVals[attr] = bins[attr] = newBins[attr];
+                Lib.nestedProperty(traces[0], binAttr + "." + attr).set(newBins[attr]);
+              }
+            }
+            if (trace["_" + mainData + "autoBinFinished"]) {
+              delete trace["_" + mainData + "autoBinFinished"];
+            } else {
+              traces = binOpts.traces;
+              var allPos = [];
+              var isFirstVisible = true;
+              var has2dMap = false;
+              var hasHist2dContour = false;
+              for (i2 = 0; i2 < traces.length; i2++) {
+                tracei = traces[i2];
+                if (tracei.visible) {
+                  var mainDatai = binOpts.dirs[i2];
+                  pos0 = tracei["_" + mainDatai + "pos0"] = pa2.makeCalcdata(tracei, mainDatai);
+                  allPos = Lib.concat(allPos, pos0);
+                  delete tracei["_" + mainData + "autoBinFinished"];
+                  if (trace.visible === true) {
+                    if (isFirstVisible) {
+                      isFirstVisible = false;
+                    } else {
+                      delete tracei._autoBin;
+                      tracei["_" + mainData + "autoBinFinished"] = 1;
+                    }
+                    if (Registry.traceIs(tracei, "2dMap")) {
+                      has2dMap = true;
+                    }
+                    if (tracei.type === "histogram2dcontour") {
+                      hasHist2dContour = true;
+                    }
+                  }
+                }
+              }
+              calendar = traces[0][mainData + "calendar"];
+              var newBinSpec = Axes.autoBin(allPos, pa2, binOpts.nbins, has2dMap, calendar, binOpts.sizeFound && binOpts.size);
+              var autoBin = traces[0]._autoBin = {};
+              autoVals = autoBin[binOpts.dirs[0]] = {};
+              if (hasHist2dContour) {
+                if (!binOpts.size) {
+                  newBinSpec.start = c2r(Axes.tickIncrement(
+                    r2c(newBinSpec.start),
+                    newBinSpec.size,
+                    true,
+                    calendar
+                  ));
+                }
+                if (binOpts.end === void 0) {
+                  newBinSpec.end = c2r(Axes.tickIncrement(
+                    r2c(newBinSpec.end),
+                    newBinSpec.size,
+                    false,
+                    calendar
+                  ));
+                }
+              }
+              if (isOverlay && !Registry.traceIs(trace, "2dMap") && newBinSpec._dataSpan === 0 && pa2.type !== "category" && pa2.type !== "multicategory" && trace.bingroup === "" && typeof trace.xbins === "undefined") {
+                if (_overlayEdgeCase) return [newBinSpec, pos0, true];
+                newBinSpec = handleSingleValueOverlays(gd2, trace, pa2, mainData, binAttr);
+              }
+              cumulativeSpec = tracei.cumulative || {};
+              if (cumulativeSpec.enabled && cumulativeSpec.currentbin !== "include") {
+                if (cumulativeSpec.direction === "decreasing") {
+                  newBinSpec.start = c2r(Axes.tickIncrement(
+                    r2c(newBinSpec.start),
+                    newBinSpec.size,
+                    true,
+                    calendar
+                  ));
+                } else {
+                  newBinSpec.end = c2r(Axes.tickIncrement(
+                    r2c(newBinSpec.end),
+                    newBinSpec.size,
+                    false,
+                    calendar
+                  ));
+                }
+              }
+              binOpts.size = newBinSpec.size;
+              if (!binOpts.sizeFound) {
+                autoVals.size = newBinSpec.size;
+                Lib.nestedProperty(traces[0], binAttr + ".size").set(newBinSpec.size);
+              }
+              setBound("start", binOpts, newBinSpec);
+              setBound("end", binOpts, newBinSpec);
+            }
+            pos0 = trace["_" + mainData + "pos0"];
+            delete trace["_" + mainData + "pos0"];
+            var traceInputBins = trace._input[binAttr] || {};
+            var traceBinOptsCalc = Lib.extendFlat({}, binOpts);
+            var mainStart = binOpts.start;
+            var startIn = pa2.r2l(traceInputBins.start);
+            var hasStart = startIn !== void 0;
+            if ((binOpts.startFound || hasStart) && startIn !== pa2.r2l(mainStart)) {
+              var traceStart = hasStart ? startIn : Lib.aggNums(Math.min, null, pos0);
+              var dummyAx = {
+                type: pa2.type === "category" || pa2.type === "multicategory" ? "linear" : pa2.type,
+                r2l: pa2.r2l,
+                dtick: binOpts.size,
+                tick0: mainStart,
+                calendar,
+                range: [traceStart, Axes.tickIncrement(traceStart, binOpts.size, false, calendar)].map(pa2.l2r)
+              };
+              var newStart = Axes.tickFirst(dummyAx);
+              if (newStart > pa2.r2l(traceStart)) {
+                newStart = Axes.tickIncrement(newStart, binOpts.size, true, calendar);
+              }
+              traceBinOptsCalc.start = pa2.l2r(newStart);
+              if (!hasStart) Lib.nestedProperty(trace, binAttr + ".start").set(traceBinOptsCalc.start);
+            }
+            var mainEnd = binOpts.end;
+            var endIn = pa2.r2l(traceInputBins.end);
+            var hasEnd = endIn !== void 0;
+            if ((binOpts.endFound || hasEnd) && endIn !== pa2.r2l(mainEnd)) {
+              var traceEnd = hasEnd ? endIn : Lib.aggNums(Math.max, null, pos0);
+              traceBinOptsCalc.end = pa2.l2r(traceEnd);
+              if (!hasEnd) Lib.nestedProperty(trace, binAttr + ".start").set(traceBinOptsCalc.end);
+            }
+            var autoBinAttr = "autobin" + mainData;
+            if (trace._input[autoBinAttr] === false) {
+              trace._input[binAttr] = Lib.extendFlat({}, trace[binAttr] || {});
+              delete trace._input[autoBinAttr];
+              delete trace[autoBinAttr];
+            }
+            return [traceBinOptsCalc, pos0];
+          }
+          function handleSingleValueOverlays(gd2, trace, pa2, mainData, binAttr) {
+            var fullLayout = gd2._fullLayout;
+            var overlaidTraceGroup = getConnectedHistograms(gd2, trace);
+            var pastThisTrace = false;
+            var minSize = Infinity;
+            var singleValuedTraces = [trace];
+            var i2, tracei, binOpts;
+            for (i2 = 0; i2 < overlaidTraceGroup.length; i2++) {
+              tracei = overlaidTraceGroup[i2];
+              if (tracei === trace) {
+                pastThisTrace = true;
+              } else if (!pastThisTrace) {
+                binOpts = fullLayout._histogramBinOpts[tracei["_" + mainData + "bingroup"]];
+                minSize = Math.min(minSize, binOpts.size || tracei[binAttr].size);
+              } else {
+                var resulti = calcAllAutoBins(gd2, tracei, pa2, mainData, true);
+                var binSpeci = resulti[0];
+                var isSingleValued = resulti[2];
+                tracei["_" + mainData + "autoBinFinished"] = 1;
+                tracei["_" + mainData + "pos0"] = resulti[1];
+                if (isSingleValued) {
+                  singleValuedTraces.push(tracei);
+                } else {
+                  minSize = Math.min(minSize, binSpeci.size);
+                }
+              }
+            }
+            var dataVals = new Array(singleValuedTraces.length);
+            for (i2 = 0; i2 < singleValuedTraces.length; i2++) {
+              var pos0 = singleValuedTraces[i2]["_" + mainData + "pos0"];
+              for (var j2 = 0; j2 < pos0.length; j2++) {
+                if (pos0[j2] !== void 0) {
+                  dataVals[i2] = pos0[j2];
+                  break;
+                }
+              }
+            }
+            if (!isFinite(minSize)) {
+              minSize = Lib.distinctVals(dataVals).minDiff;
+            }
+            for (i2 = 0; i2 < singleValuedTraces.length; i2++) {
+              tracei = singleValuedTraces[i2];
+              var calendar = tracei[mainData + "calendar"];
+              var newBins = {
+                start: pa2.c2r(dataVals[i2] - minSize / 2, 0, calendar),
+                end: pa2.c2r(dataVals[i2] + minSize / 2, 0, calendar),
+                size: minSize
+              };
+              tracei._input[binAttr] = tracei[binAttr] = newBins;
+              binOpts = fullLayout._histogramBinOpts[tracei["_" + mainData + "bingroup"]];
+              if (binOpts) Lib.extendFlat(binOpts, newBins);
+            }
+            return trace[binAttr];
+          }
+          function getConnectedHistograms(gd2, trace) {
+            var xid = trace.xaxis;
+            var yid = trace.yaxis;
+            var orientation = trace.orientation;
+            var out = [];
+            var fullData = gd2._fullData;
+            for (var i2 = 0; i2 < fullData.length; i2++) {
+              var tracei = fullData[i2];
+              if (tracei.type === "histogram" && tracei.visible === true && tracei.orientation === orientation && tracei.xaxis === xid && tracei.yaxis === yid) {
+                out.push(tracei);
+              }
+            }
+            return out;
+          }
+          function cdf(size, direction, currentBin) {
+            var i2, vi2, prevSum;
+            function firstHalfPoint(i22) {
+              prevSum = size[i22];
+              size[i22] /= 2;
+            }
+            function nextHalfPoint(i22) {
+              vi2 = size[i22];
+              size[i22] = prevSum + vi2 / 2;
+              prevSum += vi2;
+            }
+            if (currentBin === "half") {
+              if (direction === "increasing") {
+                firstHalfPoint(0);
+                for (i2 = 1; i2 < size.length; i2++) {
+                  nextHalfPoint(i2);
+                }
+              } else {
+                firstHalfPoint(size.length - 1);
+                for (i2 = size.length - 2; i2 >= 0; i2--) {
+                  nextHalfPoint(i2);
+                }
+              }
+            } else if (direction === "increasing") {
+              for (i2 = 1; i2 < size.length; i2++) {
+                size[i2] += size[i2 - 1];
+              }
+              if (currentBin === "exclude") {
+                size.unshift(0);
+                size.pop();
+              }
+            } else {
+              for (i2 = size.length - 2; i2 >= 0; i2--) {
+                size[i2] += size[i2 + 1];
+              }
+              if (currentBin === "exclude") {
+                size.push(0);
+                size.shift();
+              }
+            }
+          }
+          module2.exports = {
+            calc,
+            calcAllAutoBins
+          };
+        }
+      });
+      var require_calc8 = __commonJS({
+        "src/traces/histogram2d/calc.js"(exports, module2) {
+          var Lib = require_lib();
+          var Axes = require_axes();
+          var binFunctions = require_bin_functions();
+          var normFunctions = require_norm_functions();
+          var doAvg = require_average();
+          var getBinSpanLabelRound = require_bin_label_vals();
+          var calcAllAutoBins = require_calc7().calcAllAutoBins;
+          module2.exports = function calc(gd2, trace) {
+            var xa = Axes.getFromId(gd2, trace.xaxis);
+            var ya2 = Axes.getFromId(gd2, trace.yaxis);
+            var xcalendar = trace.xcalendar;
+            var ycalendar = trace.ycalendar;
+            var xr2c = function(v2) {
+              return xa.r2c(v2, 0, xcalendar);
+            };
+            var yr2c = function(v2) {
+              return ya2.r2c(v2, 0, ycalendar);
+            };
+            var xc2r = function(v2) {
+              return xa.c2r(v2, 0, xcalendar);
+            };
+            var yc2r = function(v2) {
+              return ya2.c2r(v2, 0, ycalendar);
+            };
+            var i2, j2, n2, m2;
+            var xBinsAndPos = calcAllAutoBins(gd2, trace, xa, "x");
+            var xBinSpec = xBinsAndPos[0];
+            var xPos0 = xBinsAndPos[1];
+            var yBinsAndPos = calcAllAutoBins(gd2, trace, ya2, "y");
+            var yBinSpec = yBinsAndPos[0];
+            var yPos0 = yBinsAndPos[1];
+            var serieslen = trace._length;
+            if (xPos0.length > serieslen) xPos0.splice(serieslen, xPos0.length - serieslen);
+            if (yPos0.length > serieslen) yPos0.splice(serieslen, yPos0.length - serieslen);
+            var z2 = [];
+            var onecol = [];
+            var zerocol = [];
+            var nonuniformBinsX = typeof xBinSpec.size === "string";
+            var nonuniformBinsY = typeof yBinSpec.size === "string";
+            var xEdges = [];
+            var yEdges = [];
+            var xbins = nonuniformBinsX ? xEdges : xBinSpec;
+            var ybins = nonuniformBinsY ? yEdges : yBinSpec;
+            var total = 0;
+            var counts = [];
+            var inputPoints = [];
+            var norm = trace.histnorm;
+            var func = trace.histfunc;
+            var densitynorm = norm.indexOf("density") !== -1;
+            var extremefunc = func === "max" || func === "min";
+            var sizeinit = extremefunc ? null : 0;
+            var binfunc = binFunctions.count;
+            var normfunc = normFunctions[norm];
+            var doavg = false;
+            var xinc = [];
+            var yinc = [];
+            var rawCounterData = "z" in trace ? trace.z : "marker" in trace && Array.isArray(trace.marker.color) ? trace.marker.color : "";
+            if (rawCounterData && func !== "count") {
+              doavg = func === "avg";
+              binfunc = binFunctions[func];
+            }
+            var xBinSize = xBinSpec.size;
+            var xBinStart = xr2c(xBinSpec.start);
+            var xBinEnd = xr2c(xBinSpec.end) + (xBinStart - Axes.tickIncrement(xBinStart, xBinSize, false, xcalendar)) / 1e6;
+            for (i2 = xBinStart; i2 < xBinEnd; i2 = Axes.tickIncrement(i2, xBinSize, false, xcalendar)) {
+              onecol.push(sizeinit);
+              xEdges.push(i2);
+              if (doavg) zerocol.push(0);
+            }
+            xEdges.push(i2);
+            var nx = onecol.length;
+            var dx = (i2 - xBinStart) / nx;
+            var x0 = xc2r(xBinStart + dx / 2);
+            var yBinSize = yBinSpec.size;
+            var yBinStart = yr2c(yBinSpec.start);
+            var yBinEnd = yr2c(yBinSpec.end) + (yBinStart - Axes.tickIncrement(yBinStart, yBinSize, false, ycalendar)) / 1e6;
+            for (i2 = yBinStart; i2 < yBinEnd; i2 = Axes.tickIncrement(i2, yBinSize, false, ycalendar)) {
+              z2.push(onecol.slice());
+              yEdges.push(i2);
+              var ipCol = new Array(nx);
+              for (j2 = 0; j2 < nx; j2++) ipCol[j2] = [];
+              inputPoints.push(ipCol);
+              if (doavg) counts.push(zerocol.slice());
+            }
+            yEdges.push(i2);
+            var ny = z2.length;
+            var dy = (i2 - yBinStart) / ny;
+            var y0 = yc2r(yBinStart + dy / 2);
+            if (densitynorm) {
+              xinc = makeIncrements(onecol.length, xbins, dx, nonuniformBinsX);
+              yinc = makeIncrements(z2.length, ybins, dy, nonuniformBinsY);
+            }
+            if (!nonuniformBinsX && xa.type === "date") xbins = binsToCalc(xr2c, xbins);
+            if (!nonuniformBinsY && ya2.type === "date") ybins = binsToCalc(yr2c, ybins);
+            var uniqueValsPerX = true;
+            var uniqueValsPerY = true;
+            var xVals = new Array(nx);
+            var yVals = new Array(ny);
+            var xGapLow = Infinity;
+            var xGapHigh = Infinity;
+            var yGapLow = Infinity;
+            var yGapHigh = Infinity;
+            for (i2 = 0; i2 < serieslen; i2++) {
+              var xi2 = xPos0[i2];
+              var yi2 = yPos0[i2];
+              n2 = Lib.findBin(xi2, xbins);
+              m2 = Lib.findBin(yi2, ybins);
+              if (n2 >= 0 && n2 < nx && m2 >= 0 && m2 < ny) {
+                total += binfunc(n2, i2, z2[m2], rawCounterData, counts[m2]);
+                inputPoints[m2][n2].push(i2);
+                if (uniqueValsPerX) {
+                  if (xVals[n2] === void 0) xVals[n2] = xi2;
+                  else if (xVals[n2] !== xi2) uniqueValsPerX = false;
+                }
+                if (uniqueValsPerY) {
+                  if (yVals[m2] === void 0) yVals[m2] = yi2;
+                  else if (yVals[m2] !== yi2) uniqueValsPerY = false;
+                }
+                xGapLow = Math.min(xGapLow, xi2 - xEdges[n2]);
+                xGapHigh = Math.min(xGapHigh, xEdges[n2 + 1] - xi2);
+                yGapLow = Math.min(yGapLow, yi2 - yEdges[m2]);
+                yGapHigh = Math.min(yGapHigh, yEdges[m2 + 1] - yi2);
+              }
+            }
+            if (doavg) {
+              for (m2 = 0; m2 < ny; m2++) total += doAvg(z2[m2], counts[m2]);
+            }
+            if (normfunc) {
+              for (m2 = 0; m2 < ny; m2++) normfunc(z2[m2], total, xinc, yinc[m2]);
+            }
+            return {
+              x: xPos0,
+              xRanges: getRanges(xEdges, uniqueValsPerX && xVals, xGapLow, xGapHigh, xa, xcalendar),
+              x0,
+              dx,
+              y: yPos0,
+              yRanges: getRanges(yEdges, uniqueValsPerY && yVals, yGapLow, yGapHigh, ya2, ycalendar),
+              y0,
+              dy,
+              z: z2,
+              pts: inputPoints
+            };
+          };
+          function makeIncrements(len2, bins, dv, nonuniform) {
+            var out = new Array(len2);
+            var i2;
+            if (nonuniform) {
+              for (i2 = 0; i2 < len2; i2++) out[i2] = 1 / (bins[i2 + 1] - bins[i2]);
+            } else {
+              var inc = 1 / dv;
+              for (i2 = 0; i2 < len2; i2++) out[i2] = inc;
+            }
+            return out;
+          }
+          function binsToCalc(r2c, bins) {
+            return {
+              start: r2c(bins.start),
+              end: r2c(bins.end),
+              size: bins.size
+            };
+          }
+          function getRanges(edges, uniqueVals, gapLow, gapHigh, ax, calendar) {
+            var i2;
+            var len2 = edges.length - 1;
+            var out = new Array(len2);
+            var roundFn = getBinSpanLabelRound(gapLow, gapHigh, edges, ax, calendar);
+            for (i2 = 0; i2 < len2; i2++) {
+              var v2 = (uniqueVals || [])[i2];
+              out[i2] = v2 === void 0 ? [roundFn(edges[i2]), roundFn(edges[i2 + 1], true)] : [v2, v2];
+            }
+            return out;
+          }
+        }
+      });
+      var require_convert_column_xyz = __commonJS({
+        "src/traces/heatmap/convert_column_xyz.js"(exports, module2) {
+          var Lib = require_lib();
+          var BADNUM = require_numerical().BADNUM;
+          var alignPeriod = require_align_period();
+          module2.exports = function convertColumnData(trace, ax1, ax2, var1Name, var2Name, arrayVarNames) {
+            var colLen = trace._length;
+            var col1 = ax1.makeCalcdata(trace, var1Name);
+            var col2 = ax2.makeCalcdata(trace, var2Name);
+            col1 = alignPeriod(trace, ax1, var1Name, col1).vals;
+            col2 = alignPeriod(trace, ax2, var2Name, col2).vals;
+            var textCol = trace.text;
+            var hasColumnText = textCol !== void 0 && Lib.isArray1D(textCol);
+            var hoverTextCol = trace.hovertext;
+            var hasColumnHoverText = hoverTextCol !== void 0 && Lib.isArray1D(hoverTextCol);
+            var i2, j2;
+            var col1dv = Lib.distinctVals(col1);
+            var col1vals = col1dv.vals;
+            var col2dv = Lib.distinctVals(col2);
+            var col2vals = col2dv.vals;
+            var newArrays = [];
+            var text;
+            var hovertext;
+            var nI = col2vals.length;
+            var nJ = col1vals.length;
+            for (i2 = 0; i2 < arrayVarNames.length; i2++) {
+              newArrays[i2] = Lib.init2dArray(nI, nJ);
+            }
+            if (hasColumnText) {
+              text = Lib.init2dArray(nI, nJ);
+            }
+            if (hasColumnHoverText) {
+              hovertext = Lib.init2dArray(nI, nJ);
+            }
+            var after2before = Lib.init2dArray(nI, nJ);
+            for (i2 = 0; i2 < colLen; i2++) {
+              if (col1[i2] !== BADNUM && col2[i2] !== BADNUM) {
+                var i1 = Lib.findBin(col1[i2] + col1dv.minDiff / 2, col1vals);
+                var i22 = Lib.findBin(col2[i2] + col2dv.minDiff / 2, col2vals);
+                for (j2 = 0; j2 < arrayVarNames.length; j2++) {
+                  var arrayVarName = arrayVarNames[j2];
+                  var arrayVar = trace[arrayVarName];
+                  var newArray = newArrays[j2];
+                  newArray[i22][i1] = arrayVar[i2];
+                  after2before[i22][i1] = i2;
+                }
+                if (hasColumnText) text[i22][i1] = textCol[i2];
+                if (hasColumnHoverText) hovertext[i22][i1] = hoverTextCol[i2];
+              }
+            }
+            trace["_" + var1Name] = col1vals;
+            trace["_" + var2Name] = col2vals;
+            for (j2 = 0; j2 < arrayVarNames.length; j2++) {
+              trace["_" + arrayVarNames[j2]] = newArrays[j2];
+            }
+            if (hasColumnText) trace._text = text;
+            if (hasColumnHoverText) trace._hovertext = hovertext;
+            if (ax1 && ax1.type === "category") {
+              trace["_" + var1Name + "CategoryMap"] = col1vals.map(function(v2) {
+                return ax1._categories[v2];
+              });
+            }
+            if (ax2 && ax2.type === "category") {
+              trace["_" + var2Name + "CategoryMap"] = col2vals.map(function(v2) {
+                return ax2._categories[v2];
+              });
+            }
+            trace._after2before = after2before;
+          };
+        }
+      });
+      var require_clean_2d_array = __commonJS({
+        "src/traces/heatmap/clean_2d_array.js"(exports, module2) {
+          var isNumeric = require_fast_isnumeric();
+          var Lib = require_lib();
+          var BADNUM = require_numerical().BADNUM;
+          module2.exports = function clean2dArray(zOld, trace, xa, ya2) {
+            var rowlen, collen, getCollen, old2new, i2, j2;
+            function cleanZvalue(v2) {
+              if (!isNumeric(v2)) return void 0;
+              return +v2;
+            }
+            if (trace && trace.transpose) {
+              rowlen = 0;
+              for (i2 = 0; i2 < zOld.length; i2++) rowlen = Math.max(rowlen, zOld[i2].length);
+              if (rowlen === 0) return false;
+              getCollen = function(zOld2) {
+                return zOld2.length;
+              };
+              old2new = function(zOld2, i22, j22) {
+                return (zOld2[j22] || [])[i22];
+              };
+            } else {
+              rowlen = zOld.length;
+              getCollen = function(zOld2, i22) {
+                return zOld2[i22].length;
+              };
+              old2new = function(zOld2, i22, j22) {
+                return (zOld2[i22] || [])[j22];
+              };
+            }
+            var padOld2new = function(zOld2, i22, j22) {
+              if (i22 === BADNUM || j22 === BADNUM) return BADNUM;
+              return old2new(zOld2, i22, j22);
+            };
+            function axisMapping(ax) {
+              if (trace && trace.type !== "carpet" && trace.type !== "contourcarpet" && ax && ax.type === "category" && trace["_" + ax._id.charAt(0)].length) {
+                var axLetter = ax._id.charAt(0);
+                var axMapping = {};
+                var traceCategories = trace["_" + axLetter + "CategoryMap"] || trace[axLetter];
+                for (i2 = 0; i2 < traceCategories.length; i2++) {
+                  axMapping[traceCategories[i2]] = i2;
+                }
+                return function(i22) {
+                  var ind = axMapping[ax._categories[i22]];
+                  return ind + 1 ? ind : BADNUM;
+                };
+              } else {
+                return Lib.identity;
+              }
+            }
+            var xMap = axisMapping(xa);
+            var yMap = axisMapping(ya2);
+            if (ya2 && ya2.type === "category") rowlen = ya2._categories.length;
+            var zNew = new Array(rowlen);
+            for (i2 = 0; i2 < rowlen; i2++) {
+              if (xa && xa.type === "category") {
+                collen = xa._categories.length;
+              } else {
+                collen = getCollen(zOld, i2);
+              }
+              zNew[i2] = new Array(collen);
+              for (j2 = 0; j2 < collen; j2++) zNew[i2][j2] = cleanZvalue(padOld2new(zOld, yMap(i2), xMap(j2)));
+            }
+            return zNew;
+          };
+        }
+      });
+      var require_interp2d = __commonJS({
+        "src/traces/heatmap/interp2d.js"(exports, module2) {
+          var Lib = require_lib();
+          var INTERPTHRESHOLD = 0.01;
+          var NEIGHBORSHIFTS = [[-1, 0], [1, 0], [0, -1], [0, 1]];
+          function correctionOvershoot(maxFractionalChange) {
+            return 0.5 - 0.25 * Math.min(1, maxFractionalChange * 0.5);
+          }
+          module2.exports = function interp2d(z2, emptyPoints) {
+            var maxFractionalChange = 1;
+            var i2;
+            iterateInterp2d(z2, emptyPoints);
+            for (i2 = 0; i2 < emptyPoints.length; i2++) {
+              if (emptyPoints[i2][2] < 4) break;
+            }
+            emptyPoints = emptyPoints.slice(i2);
+            for (i2 = 0; i2 < 100 && maxFractionalChange > INTERPTHRESHOLD; i2++) {
+              maxFractionalChange = iterateInterp2d(
+                z2,
+                emptyPoints,
+                correctionOvershoot(maxFractionalChange)
+              );
+            }
+            if (maxFractionalChange > INTERPTHRESHOLD) {
+              Lib.log("interp2d didn't converge quickly", maxFractionalChange);
+            }
+            return z2;
+          };
+          function iterateInterp2d(z2, emptyPoints, overshoot) {
+            var maxFractionalChange = 0;
+            var thisPt;
+            var i2;
+            var j2;
+            var p2;
+            var q2;
+            var neighborShift;
+            var neighborRow;
+            var neighborVal;
+            var neighborCount;
+            var neighborSum;
+            var initialVal;
+            var minNeighbor;
+            var maxNeighbor;
+            for (p2 = 0; p2 < emptyPoints.length; p2++) {
+              thisPt = emptyPoints[p2];
+              i2 = thisPt[0];
+              j2 = thisPt[1];
+              initialVal = z2[i2][j2];
+              neighborSum = 0;
+              neighborCount = 0;
+              for (q2 = 0; q2 < 4; q2++) {
+                neighborShift = NEIGHBORSHIFTS[q2];
+                neighborRow = z2[i2 + neighborShift[0]];
+                if (!neighborRow) continue;
+                neighborVal = neighborRow[j2 + neighborShift[1]];
+                if (neighborVal !== void 0) {
+                  if (neighborSum === 0) {
+                    minNeighbor = maxNeighbor = neighborVal;
+                  } else {
+                    minNeighbor = Math.min(minNeighbor, neighborVal);
+                    maxNeighbor = Math.max(maxNeighbor, neighborVal);
+                  }
+                  neighborCount++;
+                  neighborSum += neighborVal;
+                }
+              }
+              if (neighborCount === 0) {
+                throw "iterateInterp2d order is wrong: no defined neighbors";
+              }
+              z2[i2][j2] = neighborSum / neighborCount;
+              if (initialVal === void 0) {
+                if (neighborCount < 4) maxFractionalChange = 1;
+              } else {
+                z2[i2][j2] = (1 + overshoot) * z2[i2][j2] - overshoot * initialVal;
+                if (maxNeighbor > minNeighbor) {
+                  maxFractionalChange = Math.max(
+                    maxFractionalChange,
+                    Math.abs(z2[i2][j2] - initialVal) / (maxNeighbor - minNeighbor)
+                  );
+                }
+              }
+            }
+            return maxFractionalChange;
+          }
+        }
+      });
+      var require_find_empties = __commonJS({
+        "src/traces/heatmap/find_empties.js"(exports, module2) {
+          var maxRowLength = require_lib().maxRowLength;
+          module2.exports = function findEmpties(z2) {
+            var empties = [];
+            var neighborHash = {};
+            var noNeighborList = [];
+            var nextRow = z2[0];
+            var row = [];
+            var blank = [0, 0, 0];
+            var rowLength = maxRowLength(z2);
+            var prevRow;
+            var i2;
+            var j2;
+            var thisPt;
+            var p2;
+            var neighborCount;
+            var newNeighborHash;
+            var foundNewNeighbors;
+            for (i2 = 0; i2 < z2.length; i2++) {
+              prevRow = row;
+              row = nextRow;
+              nextRow = z2[i2 + 1] || [];
+              for (j2 = 0; j2 < rowLength; j2++) {
+                if (row[j2] === void 0) {
+                  neighborCount = (row[j2 - 1] !== void 0 ? 1 : 0) + (row[j2 + 1] !== void 0 ? 1 : 0) + (prevRow[j2] !== void 0 ? 1 : 0) + (nextRow[j2] !== void 0 ? 1 : 0);
+                  if (neighborCount) {
+                    if (i2 === 0) neighborCount++;
+                    if (j2 === 0) neighborCount++;
+                    if (i2 === z2.length - 1) neighborCount++;
+                    if (j2 === row.length - 1) neighborCount++;
+                    if (neighborCount < 4) {
+                      neighborHash[[i2, j2]] = [i2, j2, neighborCount];
+                    }
+                    empties.push([i2, j2, neighborCount]);
+                  } else noNeighborList.push([i2, j2]);
+                }
+              }
+            }
+            while (noNeighborList.length) {
+              newNeighborHash = {};
+              foundNewNeighbors = false;
+              for (p2 = noNeighborList.length - 1; p2 >= 0; p2--) {
+                thisPt = noNeighborList[p2];
+                i2 = thisPt[0];
+                j2 = thisPt[1];
+                neighborCount = ((neighborHash[[i2 - 1, j2]] || blank)[2] + (neighborHash[[i2 + 1, j2]] || blank)[2] + (neighborHash[[i2, j2 - 1]] || blank)[2] + (neighborHash[[i2, j2 + 1]] || blank)[2]) / 20;
+                if (neighborCount) {
+                  newNeighborHash[thisPt] = [i2, j2, neighborCount];
+                  noNeighborList.splice(p2, 1);
+                  foundNewNeighbors = true;
+                }
+              }
+              if (!foundNewNeighbors) {
+                throw "findEmpties iterated with no new neighbors";
+              }
+              for (thisPt in newNeighborHash) {
+                neighborHash[thisPt] = newNeighborHash[thisPt];
+                empties.push(newNeighborHash[thisPt]);
+              }
+            }
+            return empties.sort(function(a2, b2) {
+              return b2[2] - a2[2];
+            });
+          };
+        }
+      });
+      var require_make_bound_array = __commonJS({
+        "src/traces/heatmap/make_bound_array.js"(exports, module2) {
+          var Registry = require_registry();
+          var isArrayOrTypedArray = require_lib().isArrayOrTypedArray;
+          module2.exports = function makeBoundArray(trace, arrayIn, v0In, dvIn, numbricks, ax) {
+            var arrayOut = [];
+            var isContour = Registry.traceIs(trace, "contour");
+            var isHist = Registry.traceIs(trace, "histogram");
+            var v0;
+            var dv;
+            var i2;
+            var isArrayOfTwoItemsOrMore = isArrayOrTypedArray(arrayIn) && arrayIn.length > 1;
+            if (isArrayOfTwoItemsOrMore && !isHist && ax.type !== "category") {
+              var len2 = arrayIn.length;
+              if (len2 <= numbricks) {
+                if (isContour) arrayOut = Array.from(arrayIn).slice(0, numbricks);
+                else if (numbricks === 1) {
+                  if (ax.type === "log") {
+                    arrayOut = [0.5 * arrayIn[0], 2 * arrayIn[0]];
+                  } else {
+                    arrayOut = [arrayIn[0] - 0.5, arrayIn[0] + 0.5];
+                  }
+                } else if (ax.type === "log") {
+                  arrayOut = [Math.pow(arrayIn[0], 1.5) / Math.pow(arrayIn[1], 0.5)];
+                  for (i2 = 1; i2 < len2; i2++) {
+                    arrayOut.push(Math.sqrt(arrayIn[i2 - 1] * arrayIn[i2]));
+                  }
+                  arrayOut.push(Math.pow(arrayIn[len2 - 1], 1.5) / Math.pow(arrayIn[len2 - 2], 0.5));
+                } else {
+                  arrayOut = [1.5 * arrayIn[0] - 0.5 * arrayIn[1]];
+                  for (i2 = 1; i2 < len2; i2++) {
+                    arrayOut.push((arrayIn[i2 - 1] + arrayIn[i2]) * 0.5);
+                  }
+                  arrayOut.push(1.5 * arrayIn[len2 - 1] - 0.5 * arrayIn[len2 - 2]);
+                }
+                if (len2 < numbricks) {
+                  var lastPt = arrayOut[arrayOut.length - 1];
+                  var delta;
+                  if (ax.type === "log") {
+                    delta = lastPt / arrayOut[arrayOut.length - 2];
+                    for (i2 = len2; i2 < numbricks; i2++) {
+                      lastPt *= delta;
+                      arrayOut.push(lastPt);
+                    }
+                  } else {
+                    delta = lastPt - arrayOut[arrayOut.length - 2];
+                    for (i2 = len2; i2 < numbricks; i2++) {
+                      lastPt += delta;
+                      arrayOut.push(lastPt);
+                    }
+                  }
+                }
+              } else {
+                return isContour ? arrayIn.slice(0, numbricks) : (
+                  // we must be strict for contours
+                  arrayIn.slice(0, numbricks + 1)
+                );
+              }
+            } else {
+              var calendar = trace[ax._id.charAt(0) + "calendar"];
+              if (isHist) {
+                v0 = ax.r2c(v0In, 0, calendar);
+              } else {
+                if (isArrayOrTypedArray(arrayIn) && arrayIn.length === 1) {
+                  v0 = arrayIn[0];
+                } else if (v0In === void 0) {
+                  v0 = 0;
+                } else {
+                  var fn = ax.type === "log" ? ax.d2c : ax.r2c;
+                  v0 = fn(v0In, 0, calendar);
+                }
+              }
+              dv = dvIn || 1;
+              for (i2 = isContour ? 0 : -0.5; i2 < numbricks; i2++) {
+                arrayOut.push(v0 + dv * i2);
+              }
+            }
+            return arrayOut;
+          };
+        }
+      });
+      var require_calc9 = __commonJS({
+        "src/traces/heatmap/calc.js"(exports, module2) {
+          var Registry = require_registry();
+          var Lib = require_lib();
+          var Axes = require_axes();
+          var alignPeriod = require_align_period();
+          var histogram2dCalc = require_calc8();
+          var colorscaleCalc = require_calc();
+          var convertColumnData = require_convert_column_xyz();
+          var clean2dArray = require_clean_2d_array();
+          var interp2d = require_interp2d();
+          var findEmpties = require_find_empties();
+          var makeBoundArray = require_make_bound_array();
+          var BADNUM = require_numerical().BADNUM;
+          module2.exports = function calc(gd2, trace) {
+            var xa = Axes.getFromId(gd2, trace.xaxis || "x");
+            var ya2 = Axes.getFromId(gd2, trace.yaxis || "y");
+            var isContour = Registry.traceIs(trace, "contour");
+            var isHist = Registry.traceIs(trace, "histogram");
+            var zsmooth = isContour ? "best" : trace.zsmooth;
+            var x2, x0, dx, origX;
+            var y2, y0, dy, origY;
+            var z2, i2, binned;
+            xa._minDtick = 0;
+            ya2._minDtick = 0;
+            if (isHist) {
+              binned = histogram2dCalc(gd2, trace);
+              origX = binned.orig_x;
+              x2 = binned.x;
+              x0 = binned.x0;
+              dx = binned.dx;
+              origY = binned.orig_y;
+              y2 = binned.y;
+              y0 = binned.y0;
+              dy = binned.dy;
+              z2 = binned.z;
+            } else {
+              var zIn = trace.z;
+              if (Lib.isArray1D(zIn)) {
+                convertColumnData(trace, xa, ya2, "x", "y", ["z"]);
+                x2 = trace._x;
+                y2 = trace._y;
+                zIn = trace._z;
+              } else {
+                origX = trace.x ? xa.makeCalcdata(trace, "x") : [];
+                origY = trace.y ? ya2.makeCalcdata(trace, "y") : [];
+                x2 = alignPeriod(trace, xa, "x", origX).vals;
+                y2 = alignPeriod(trace, ya2, "y", origY).vals;
+                trace._x = x2;
+                trace._y = y2;
+              }
+              x0 = trace.x0;
+              dx = trace.dx;
+              y0 = trace.y0;
+              dy = trace.dy;
+              z2 = clean2dArray(zIn, trace, xa, ya2);
+            }
+            if (xa.rangebreaks || ya2.rangebreaks) {
+              z2 = dropZonBreaks(x2, y2, z2);
+              if (!isHist) {
+                x2 = skipBreaks(x2);
+                y2 = skipBreaks(y2);
+                trace._x = x2;
+                trace._y = y2;
+              }
+            }
+            if (!isHist && (isContour || trace.connectgaps)) {
+              trace._emptypoints = findEmpties(z2);
+              interp2d(z2, trace._emptypoints);
+            }
+            function noZsmooth(msg) {
+              zsmooth = trace._input.zsmooth = trace.zsmooth = false;
+              Lib.warn('cannot use zsmooth: "fast": ' + msg);
+            }
+            function scaleIsLinear(s2) {
+              if (s2.length > 1) {
+                var avgdx = (s2[s2.length - 1] - s2[0]) / (s2.length - 1);
+                var maxErrX = Math.abs(avgdx / 100);
+                for (i2 = 0; i2 < s2.length - 1; i2++) {
+                  if (Math.abs(s2[i2 + 1] - s2[i2] - avgdx) > maxErrX) {
+                    return false;
+                  }
+                }
+              }
+              return true;
+            }
+            trace._islinear = false;
+            if (xa.type === "log" || ya2.type === "log") {
+              if (zsmooth === "fast") {
+                noZsmooth("log axis found");
+              }
+            } else if (!scaleIsLinear(x2)) {
+              if (zsmooth === "fast") noZsmooth("x scale is not linear");
+            } else if (!scaleIsLinear(y2)) {
+              if (zsmooth === "fast") noZsmooth("y scale is not linear");
+            } else {
+              trace._islinear = true;
+            }
+            var xlen = Lib.maxRowLength(z2);
+            var xIn = trace.xtype === "scaled" ? "" : x2;
+            var xArray = makeBoundArray(trace, xIn, x0, dx, xlen, xa);
+            var yIn = trace.ytype === "scaled" ? "" : y2;
+            var yArray = makeBoundArray(trace, yIn, y0, dy, z2.length, ya2);
+            trace._extremes[xa._id] = Axes.findExtremes(xa, xArray);
+            trace._extremes[ya2._id] = Axes.findExtremes(ya2, yArray);
+            var cd0 = {
+              x: xArray,
+              y: yArray,
+              z: z2,
+              text: trace._text || trace.text,
+              hovertext: trace._hovertext || trace.hovertext
+            };
+            if (trace.xperiodalignment && origX) {
+              cd0.orig_x = origX;
+            }
+            if (trace.yperiodalignment && origY) {
+              cd0.orig_y = origY;
+            }
+            if (xIn && xIn.length === xArray.length - 1) cd0.xCenter = xIn;
+            if (yIn && yIn.length === yArray.length - 1) cd0.yCenter = yIn;
+            if (isHist) {
+              cd0.xRanges = binned.xRanges;
+              cd0.yRanges = binned.yRanges;
+              cd0.pts = binned.pts;
+            }
+            if (!isContour) {
+              colorscaleCalc(gd2, trace, { vals: z2, cLetter: "z" });
+            }
+            if (isContour && trace.contours && trace.contours.coloring === "heatmap") {
+              var dummyTrace = {
+                type: trace.type === "contour" ? "heatmap" : "histogram2d",
+                xcalendar: trace.xcalendar,
+                ycalendar: trace.ycalendar
+              };
+              cd0.xfill = makeBoundArray(dummyTrace, xIn, x0, dx, xlen, xa);
+              cd0.yfill = makeBoundArray(dummyTrace, yIn, y0, dy, z2.length, ya2);
+            }
+            return [cd0];
+          };
+          function skipBreaks(a2) {
+            var b2 = [];
+            var len2 = a2.length;
+            for (var i2 = 0; i2 < len2; i2++) {
+              var v2 = a2[i2];
+              if (v2 !== BADNUM) b2.push(v2);
+            }
+            return b2;
+          }
+          function dropZonBreaks(x2, y2, z2) {
+            var newZ = [];
+            var k2 = -1;
+            for (var i2 = 0; i2 < z2.length; i2++) {
+              if (y2[i2] === BADNUM) continue;
+              k2++;
+              newZ[k2] = [];
+              for (var j2 = 0; j2 < z2[i2].length; j2++) {
+                if (x2[j2] === BADNUM) continue;
+                newZ[k2].push(z2[i2][j2]);
+              }
+            }
+            return newZ;
+          }
+        }
+      });
+      var require_pixelated_image = __commonJS({
+        "src/constants/pixelated_image.js"(exports) {
+          exports.CSS_DECLARATIONS = [
+            ["image-rendering", "optimizeSpeed"],
+            ["image-rendering", "-moz-crisp-edges"],
+            ["image-rendering", "-o-crisp-edges"],
+            ["image-rendering", "-webkit-optimize-contrast"],
+            ["image-rendering", "optimize-contrast"],
+            ["image-rendering", "crisp-edges"],
+            ["image-rendering", "pixelated"]
+          ];
+          exports.STYLE = exports.CSS_DECLARATIONS.map(function(d2) {
+            return d2.join(": ") + "; ";
+          }).join("");
+        }
+      });
+      var require_supports_pixelated_image = __commonJS({
+        "src/lib/supports_pixelated_image.js"(exports, module2) {
+          var constants = require_pixelated_image();
+          var Drawing = require_drawing();
+          var Lib = require_lib();
+          var _supportsPixelated = null;
+          function supportsPixelatedImage() {
+            if (_supportsPixelated !== null) {
+              return _supportsPixelated;
+            }
+            _supportsPixelated = false;
+            var unsupportedBrowser = Lib.isSafari() || Lib.isMacWKWebView() || Lib.isIOS();
+            if (window.navigator.userAgent && !unsupportedBrowser) {
+              var declarations = Array.from(constants.CSS_DECLARATIONS).reverse();
+              var supports = window.CSS && window.CSS.supports || window.supportsCSS;
+              if (typeof supports === "function") {
+                _supportsPixelated = declarations.some(function(d2) {
+                  return supports.apply(null, d2);
+                });
+              } else {
+                var image3 = Drawing.tester.append("image").attr("style", constants.STYLE);
+                var cStyles = window.getComputedStyle(image3.node());
+                var imageRendering = cStyles.imageRendering;
+                _supportsPixelated = declarations.some(function(d2) {
+                  var value = d2[1];
+                  return imageRendering === value || imageRendering === value.toLowerCase();
+                });
+                image3.remove();
+              }
+            }
+            return _supportsPixelated;
+          }
+          module2.exports = supportsPixelatedImage;
+        }
+      });
+      var require_plot5 = __commonJS({
+        "src/traces/heatmap/plot.js"(exports, module2) {
+          var d3 = require_d3();
+          var tinycolor = require_tinycolor();
+          var Registry = require_registry();
+          var Drawing = require_drawing();
+          var Axes = require_axes();
+          var Lib = require_lib();
+          var svgTextUtils = require_svg_text_utils();
+          var formatLabels = require_format_labels();
+          var Color2 = require_color();
+          var extractOpts = require_colorscale().extractOpts;
+          var makeColorScaleFuncFromTrace = require_colorscale().makeColorScaleFuncFromTrace;
+          var xmlnsNamespaces = require_xmlns_namespaces();
+          var alignmentConstants = require_alignment();
+          var LINE_SPACING = alignmentConstants.LINE_SPACING;
+          var supportsPixelatedImage = require_supports_pixelated_image();
+          var PIXELATED_IMAGE_STYLE = require_pixelated_image().STYLE;
+          var labelClass = "heatmap-label";
+          function selectLabels(plotGroup) {
+            return plotGroup.selectAll("g." + labelClass);
+          }
+          function removeLabels(plotGroup) {
+            selectLabels(plotGroup).remove();
+          }
+          module2.exports = function(gd2, plotinfo, cdheatmaps, heatmapLayer) {
+            var xa = plotinfo.xaxis;
+            var ya2 = plotinfo.yaxis;
+            Lib.makeTraceGroups(heatmapLayer, cdheatmaps, "hm").each(function(cd2) {
+              var plotGroup = d3.select(this);
+              var cd0 = cd2[0];
+              var trace = cd0.trace;
+              var xGap = trace.xgap || 0;
+              var yGap = trace.ygap || 0;
+              var z2 = cd0.z;
+              var x2 = cd0.x;
+              var y2 = cd0.y;
+              var xc2 = cd0.xCenter;
+              var yc2 = cd0.yCenter;
+              var isContour = Registry.traceIs(trace, "contour");
+              var zsmooth = isContour ? "best" : trace.zsmooth;
+              var m2 = z2.length;
+              var n2 = Lib.maxRowLength(z2);
+              var xrev = false;
+              var yrev = false;
+              var left, right, temp, top, bottom, i2, j2, k2;
+              i2 = 0;
+              while (left === void 0 && i2 < x2.length - 1) {
+                left = xa.c2p(x2[i2]);
+                i2++;
+              }
+              i2 = x2.length - 1;
+              while (right === void 0 && i2 > 0) {
+                right = xa.c2p(x2[i2]);
+                i2--;
+              }
+              if (right < left) {
+                temp = right;
+                right = left;
+                left = temp;
+                xrev = true;
+              }
+              i2 = 0;
+              while (top === void 0 && i2 < y2.length - 1) {
+                top = ya2.c2p(y2[i2]);
+                i2++;
+              }
+              i2 = y2.length - 1;
+              while (bottom === void 0 && i2 > 0) {
+                bottom = ya2.c2p(y2[i2]);
+                i2--;
+              }
+              if (bottom < top) {
+                temp = top;
+                top = bottom;
+                bottom = temp;
+                yrev = true;
+              }
+              if (isContour) {
+                xc2 = x2;
+                yc2 = y2;
+                x2 = cd0.xfill;
+                y2 = cd0.yfill;
+              }
+              var drawingMethod = "default";
+              if (zsmooth) {
+                drawingMethod = zsmooth === "best" ? "smooth" : "fast";
+              } else if (trace._islinear && xGap === 0 && yGap === 0 && supportsPixelatedImage()) {
+                drawingMethod = "fast";
+              }
+              if (drawingMethod !== "fast") {
+                var extra = zsmooth === "best" ? 0 : 0.5;
+                left = Math.max(-extra * xa._length, left);
+                right = Math.min((1 + extra) * xa._length, right);
+                top = Math.max(-extra * ya2._length, top);
+                bottom = Math.min((1 + extra) * ya2._length, bottom);
+              }
+              var imageWidth = Math.round(right - left);
+              var imageHeight = Math.round(bottom - top);
+              var isOffScreen = left >= xa._length || right <= 0 || top >= ya2._length || bottom <= 0;
+              if (isOffScreen) {
+                var noImage = plotGroup.selectAll("image").data([]);
+                noImage.exit().remove();
+                removeLabels(plotGroup);
+                return;
+              }
+              var canvasW, canvasH;
+              if (drawingMethod === "fast") {
+                canvasW = n2;
+                canvasH = m2;
+              } else {
+                canvasW = imageWidth;
+                canvasH = imageHeight;
+              }
+              var canvas2 = document.createElement("canvas");
+              canvas2.width = canvasW;
+              canvas2.height = canvasH;
+              var context = canvas2.getContext("2d", { willReadFrequently: true });
+              var sclFunc = makeColorScaleFuncFromTrace(trace, { noNumericCheck: true, returnArray: true });
+              var xpx, ypx;
+              if (drawingMethod === "fast") {
+                xpx = xrev ? function(index) {
+                  return n2 - 1 - index;
+                } : Lib.identity;
+                ypx = yrev ? function(index) {
+                  return m2 - 1 - index;
+                } : Lib.identity;
+              } else {
+                xpx = function(index) {
+                  return Lib.constrain(Math.round(xa.c2p(x2[index]) - left), 0, imageWidth);
+                };
+                ypx = function(index) {
+                  return Lib.constrain(Math.round(ya2.c2p(y2[index]) - top), 0, imageHeight);
+                };
+              }
+              var yi2 = ypx(0);
+              var yb2 = [yi2, yi2];
+              var xbi = xrev ? 0 : 1;
+              var ybi = yrev ? 0 : 1;
+              var pixcount = 0;
+              var rcount = 0;
+              var gcount = 0;
+              var bcount = 0;
+              var xb2, xi2, v2, row, c2;
+              function setColor(v22, pixsize) {
+                if (v22 !== void 0) {
+                  var c22 = sclFunc(v22);
+                  c22[0] = Math.round(c22[0]);
+                  c22[1] = Math.round(c22[1]);
+                  c22[2] = Math.round(c22[2]);
+                  pixcount += pixsize;
+                  rcount += c22[0] * pixsize;
+                  gcount += c22[1] * pixsize;
+                  bcount += c22[2] * pixsize;
+                  return c22;
+                }
+                return [0, 0, 0, 0];
+              }
+              function interpColor(r02, r12, xinterp, yinterp2) {
+                var z00 = r02[xinterp.bin0];
+                if (z00 === void 0) return setColor(void 0, 1);
+                var z01 = r02[xinterp.bin1];
+                var z10 = r12[xinterp.bin0];
+                var z11 = r12[xinterp.bin1];
+                var dx2 = z01 - z00 || 0;
+                var dy2 = z10 - z00 || 0;
+                var dxy;
+                if (z01 === void 0) {
+                  if (z11 === void 0) dxy = 0;
+                  else if (z10 === void 0) dxy = 2 * (z11 - z00);
+                  else dxy = (2 * z11 - z10 - z00) * 2 / 3;
+                } else if (z11 === void 0) {
+                  if (z10 === void 0) dxy = 0;
+                  else dxy = (2 * z00 - z01 - z10) * 2 / 3;
+                } else if (z10 === void 0) dxy = (2 * z11 - z01 - z00) * 2 / 3;
+                else dxy = z11 + z00 - z01 - z10;
+                return setColor(z00 + xinterp.frac * dx2 + yinterp2.frac * (dy2 + xinterp.frac * dxy));
+              }
+              if (drawingMethod !== "default") {
+                var pxIndex = 0;
+                var pixels;
+                try {
+                  pixels = new Uint8Array(canvasW * canvasH * 4);
+                } catch (e2) {
+                  pixels = new Array(canvasW * canvasH * 4);
+                }
+                if (drawingMethod === "smooth") {
+                  var xForPx = xc2 || x2;
+                  var yForPx = yc2 || y2;
+                  var xPixArray = new Array(xForPx.length);
+                  var yPixArray = new Array(yForPx.length);
+                  var xinterpArray = new Array(imageWidth);
+                  var findInterpX = xc2 ? findInterpFromCenters : findInterp;
+                  var findInterpY = yc2 ? findInterpFromCenters : findInterp;
+                  var yinterp, r0, r1;
+                  for (i2 = 0; i2 < xForPx.length; i2++) xPixArray[i2] = Math.round(xa.c2p(xForPx[i2]) - left);
+                  for (i2 = 0; i2 < yForPx.length; i2++) yPixArray[i2] = Math.round(ya2.c2p(yForPx[i2]) - top);
+                  for (i2 = 0; i2 < imageWidth; i2++) xinterpArray[i2] = findInterpX(i2, xPixArray);
+                  for (j2 = 0; j2 < imageHeight; j2++) {
+                    yinterp = findInterpY(j2, yPixArray);
+                    r0 = z2[yinterp.bin0];
+                    r1 = z2[yinterp.bin1];
+                    for (i2 = 0; i2 < imageWidth; i2++, pxIndex += 4) {
+                      c2 = interpColor(r0, r1, xinterpArray[i2], yinterp);
+                      putColor(pixels, pxIndex, c2);
+                    }
+                  }
+                } else {
+                  for (j2 = 0; j2 < m2; j2++) {
+                    row = z2[j2];
+                    yb2 = ypx(j2);
+                    for (i2 = 0; i2 < n2; i2++) {
+                      c2 = setColor(row[i2], 1);
+                      pxIndex = (yb2 * n2 + xpx(i2)) * 4;
+                      putColor(pixels, pxIndex, c2);
+                    }
+                  }
+                }
+                var imageData = context.createImageData(canvasW, canvasH);
+                try {
+                  imageData.data.set(pixels);
+                } catch (e2) {
+                  var pxArray = imageData.data;
+                  var dlen = pxArray.length;
+                  for (j2 = 0; j2 < dlen; j2++) {
+                    pxArray[j2] = pixels[j2];
+                  }
+                }
+                context.putImageData(imageData, 0, 0);
+              } else {
+                var xGapLeft = Math.floor(xGap / 2);
+                var yGapTop = Math.floor(yGap / 2);
+                for (j2 = 0; j2 < m2; j2++) {
+                  row = z2[j2];
+                  yb2.reverse();
+                  yb2[ybi] = ypx(j2 + 1);
+                  if (yb2[0] === yb2[1] || yb2[0] === void 0 || yb2[1] === void 0) {
+                    continue;
+                  }
+                  xi2 = xpx(0);
+                  xb2 = [xi2, xi2];
+                  for (i2 = 0; i2 < n2; i2++) {
+                    xb2.reverse();
+                    xb2[xbi] = xpx(i2 + 1);
+                    if (xb2[0] === xb2[1] || xb2[0] === void 0 || xb2[1] === void 0) {
+                      continue;
+                    }
+                    v2 = row[i2];
+                    c2 = setColor(v2, (xb2[1] - xb2[0]) * (yb2[1] - yb2[0]));
+                    context.fillStyle = "rgba(" + c2.join(",") + ")";
+                    context.fillRect(xb2[0] + xGapLeft, yb2[0] + yGapTop, xb2[1] - xb2[0] - xGap, yb2[1] - yb2[0] - yGap);
+                  }
+                }
+              }
+              rcount = Math.round(rcount / pixcount);
+              gcount = Math.round(gcount / pixcount);
+              bcount = Math.round(bcount / pixcount);
+              var avgColor = tinycolor("rgb(" + rcount + "," + gcount + "," + bcount + ")");
+              gd2._hmpixcount = (gd2._hmpixcount || 0) + pixcount;
+              gd2._hmlumcount = (gd2._hmlumcount || 0) + pixcount * avgColor.getLuminance();
+              var image3 = plotGroup.selectAll("image").data(cd2);
+              image3.enter().append("svg:image").attr({
+                xmlns: xmlnsNamespaces.svg,
+                preserveAspectRatio: "none"
+              });
+              image3.attr({
+                height: imageHeight,
+                width: imageWidth,
+                x: left,
+                y: top,
+                "xlink:href": canvas2.toDataURL("image/png")
+              });
+              if (drawingMethod === "fast" && !zsmooth) {
+                image3.attr("style", PIXELATED_IMAGE_STYLE);
+              }
+              removeLabels(plotGroup);
+              var texttemplate = trace.texttemplate;
+              if (texttemplate) {
+                var cOpts = extractOpts(trace);
+                var dummyAx = {
+                  type: "linear",
+                  range: [cOpts.min, cOpts.max],
+                  _separators: xa._separators,
+                  _numFormat: xa._numFormat
+                };
+                var aHistogram2dContour = trace.type === "histogram2dcontour";
+                var aContour = trace.type === "contour";
+                var iStart = aContour ? 1 : 0;
+                var iStop = aContour ? m2 - 1 : m2;
+                var jStart = aContour ? 1 : 0;
+                var jStop = aContour ? n2 - 1 : n2;
+                var textData = [];
+                for (i2 = iStart; i2 < iStop; i2++) {
+                  var yVal;
+                  if (aContour) {
+                    yVal = cd0.y[i2];
+                  } else if (aHistogram2dContour) {
+                    if (i2 === 0 || i2 === m2 - 1) continue;
+                    yVal = cd0.y[i2];
+                  } else if (cd0.yCenter) {
+                    yVal = cd0.yCenter[i2];
+                  } else {
+                    if (i2 + 1 === m2 && cd0.y[i2 + 1] === void 0) continue;
+                    yVal = (cd0.y[i2] + cd0.y[i2 + 1]) / 2;
+                  }
+                  var _y = Math.round(ya2.c2p(yVal));
+                  if (0 > _y || _y > ya2._length) continue;
+                  for (j2 = jStart; j2 < jStop; j2++) {
+                    var xVal;
+                    if (aContour) {
+                      xVal = cd0.x[j2];
+                    } else if (aHistogram2dContour) {
+                      if (j2 === 0 || j2 === n2 - 1) continue;
+                      xVal = cd0.x[j2];
+                    } else if (cd0.xCenter) {
+                      xVal = cd0.xCenter[j2];
+                    } else {
+                      if (j2 + 1 === n2 && cd0.x[j2 + 1] === void 0) continue;
+                      xVal = (cd0.x[j2] + cd0.x[j2 + 1]) / 2;
+                    }
+                    var _x2 = Math.round(xa.c2p(xVal));
+                    if (0 > _x2 || _x2 > xa._length) continue;
+                    var obj = formatLabels(
+                      {
+                        x: xVal,
+                        y: yVal
+                      },
+                      trace,
+                      gd2._fullLayout
+                    );
+                    obj.x = xVal;
+                    obj.y = yVal;
+                    var zVal = cd0.z[i2][j2];
+                    if (zVal === void 0) {
+                      obj.z = "";
+                      obj.zLabel = "";
+                    } else {
+                      obj.z = zVal;
+                      obj.zLabel = Axes.tickText(dummyAx, zVal, "hover").text;
+                    }
+                    var theText = cd0.text && cd0.text[i2] && cd0.text[i2][j2];
+                    if (theText === void 0 || theText === false) theText = "";
+                    obj.text = theText;
+                    var _t2 = Lib.texttemplateString({
+                      data: [obj, trace._meta],
+                      fallback: trace.texttemplatefallback,
+                      labels: obj,
+                      locale: gd2._fullLayout._d3locale,
+                      template: texttemplate
+                    });
+                    if (!_t2) continue;
+                    var lines = _t2.split("<br>");
+                    var nL = lines.length;
+                    var nC = 0;
+                    for (k2 = 0; k2 < nL; k2++) {
+                      nC = Math.max(nC, lines[k2].length);
+                    }
+                    textData.push({
+                      l: nL,
+                      // number of lines
+                      c: nC,
+                      // maximum number of chars in a line
+                      t: _t2,
+                      // text
+                      x: _x2,
+                      y: _y,
+                      z: zVal
+                    });
+                  }
+                }
+                var font = trace.textfont;
+                var fontSize = font.size;
+                var globalFontSize = gd2._fullLayout.font.size;
+                if (!fontSize || fontSize === "auto") {
+                  var minW = Infinity;
+                  var minH = Infinity;
+                  var maxL = 0;
+                  var maxC = 0;
+                  for (k2 = 0; k2 < textData.length; k2++) {
+                    var d2 = textData[k2];
+                    maxL = Math.max(maxL, d2.l);
+                    maxC = Math.max(maxC, d2.c);
+                    if (k2 < textData.length - 1) {
+                      var nextD = textData[k2 + 1];
+                      var dx = Math.abs(nextD.x - d2.x);
+                      var dy = Math.abs(nextD.y - d2.y);
+                      if (dx) minW = Math.min(minW, dx);
+                      if (dy) minH = Math.min(minH, dy);
+                    }
+                  }
+                  if (!isFinite(minW) || !isFinite(minH)) {
+                    fontSize = globalFontSize;
+                  } else {
+                    minW -= xGap;
+                    minH -= yGap;
+                    minW /= maxC;
+                    minH /= maxL;
+                    minW /= LINE_SPACING / 2;
+                    minH /= LINE_SPACING;
+                    fontSize = Math.min(Math.floor(minW), Math.floor(minH), globalFontSize);
+                  }
+                }
+                if (fontSize <= 0 || !isFinite(fontSize)) return;
+                var xFn = function(d22) {
+                  return d22.x;
+                };
+                var yFn = function(d22) {
+                  return d22.y - fontSize * (d22.l * LINE_SPACING / 2 - 1);
+                };
+                var labels = selectLabels(plotGroup).data(textData);
+                labels.enter().append("g").classed(labelClass, 1).append("text").attr("text-anchor", "middle").each(function(d22) {
+                  var thisLabel = d3.select(this);
+                  var fontColor = font.color;
+                  if (!fontColor || fontColor === "auto") {
+                    fontColor = Color2.contrast(
+                      d22.z === void 0 ? gd2._fullLayout.plot_bgcolor : "rgba(" + sclFunc(d22.z).join() + ")"
+                    );
+                  }
+                  thisLabel.attr("data-notex", 1).call(svgTextUtils.positionText, xFn(d22), yFn(d22)).call(Drawing.font, {
+                    family: font.family,
+                    size: fontSize,
+                    color: fontColor,
+                    weight: font.weight,
+                    style: font.style,
+                    variant: font.variant,
+                    textcase: font.textcase,
+                    lineposition: font.lineposition,
+                    shadow: font.shadow
+                  }).text(d22.t).call(svgTextUtils.convertToTspans, gd2);
+                });
+              }
+            });
+          };
+          function findInterp(pixel, pixArray) {
+            var maxBin = pixArray.length - 2;
+            var bin = Lib.constrain(Lib.findBin(pixel, pixArray), 0, maxBin);
+            var pix0 = pixArray[bin];
+            var pix1 = pixArray[bin + 1];
+            var interp = Lib.constrain(bin + (pixel - pix0) / (pix1 - pix0) - 0.5, 0, maxBin);
+            var bin0 = Math.round(interp);
+            var frac = Math.abs(interp - bin0);
+            if (!interp || interp === maxBin || !frac) {
+              return {
+                bin0,
+                bin1: bin0,
+                frac: 0
+              };
+            }
+            return {
+              bin0,
+              frac,
+              bin1: Math.round(bin0 + frac / (interp - bin0))
+            };
+          }
+          function findInterpFromCenters(pixel, centerPixArray) {
+            var maxBin = centerPixArray.length - 1;
+            var bin = Lib.constrain(Lib.findBin(pixel, centerPixArray), 0, maxBin);
+            var pix0 = centerPixArray[bin];
+            var pix1 = centerPixArray[bin + 1];
+            var frac = (pixel - pix0) / (pix1 - pix0) || 0;
+            if (frac <= 0) {
+              return {
+                bin0: bin,
+                bin1: bin,
+                frac: 0
+              };
+            }
+            if (frac < 0.5) {
+              return {
+                bin0: bin,
+                bin1: bin + 1,
+                frac
+              };
+            }
+            return {
+              bin0: bin + 1,
+              bin1: bin,
+              frac: 1 - frac
+            };
+          }
+          function putColor(pixels, pxIndex, c2) {
+            pixels[pxIndex] = c2[0];
+            pixels[pxIndex + 1] = c2[1];
+            pixels[pxIndex + 2] = c2[2];
+            pixels[pxIndex + 3] = Math.round(c2[3] * 255);
+          }
+        }
+      });
+      var require_colorbar2 = __commonJS({
+        "src/traces/heatmap/colorbar.js"(exports, module2) {
+          module2.exports = {
+            min: "zmin",
+            max: "zmax"
+          };
+        }
+      });
+      var require_style6 = __commonJS({
+        "src/traces/heatmap/style.js"(exports, module2) {
+          var d3 = require_d3();
+          module2.exports = function style(gd2) {
+            d3.select(gd2).selectAll(".hm image").style("opacity", function(d2) {
+              return d2.trace.opacity;
+            });
+          };
+        }
+      });
+      var require_hover5 = __commonJS({
+        "src/traces/heatmap/hover.js"(exports, module2) {
+          var Fx = require_fx();
+          var Lib = require_lib();
+          var isArrayOrTypedArray = Lib.isArrayOrTypedArray;
+          var Axes = require_axes();
+          var extractOpts = require_colorscale().extractOpts;
+          module2.exports = function hoverPoints(pointData, xval, yval, hovermode, opts) {
+            if (!opts) opts = {};
+            var isContour = opts.isContour;
+            var cd0 = pointData.cd[0];
+            var trace = cd0.trace;
+            var xa = pointData.xa;
+            var ya2 = pointData.ya;
+            var x2 = cd0.x;
+            var y2 = cd0.y;
+            var z2 = cd0.z;
+            var xc2 = cd0.xCenter;
+            var yc2 = cd0.yCenter;
+            var zmask = cd0.zmask;
+            var zhoverformat = trace.zhoverformat;
+            var x22 = x2;
+            var y22 = y2;
+            var xl, yl, nx, ny;
+            if (pointData.index !== false) {
+              try {
+                nx = Math.round(pointData.index[1]);
+                ny = Math.round(pointData.index[0]);
+              } catch (e2) {
+                Lib.error("Error hovering on heatmap, pointNumber must be [row,col], found:", pointData.index);
+                return;
+              }
+              if (nx < 0 || nx >= z2[0].length || ny < 0 || ny > z2.length) {
+                return;
+              }
+            } else if (Fx.inbox(xval - x2[0], xval - x2[x2.length - 1], 0) > 0 || Fx.inbox(yval - y2[0], yval - y2[y2.length - 1], 0) > 0) {
+              return;
+            } else {
+              if (isContour) {
+                var i2;
+                x22 = [2 * x2[0] - x2[1]];
+                for (i2 = 1; i2 < x2.length; i2++) {
+                  x22.push((x2[i2] + x2[i2 - 1]) / 2);
+                }
+                x22.push([2 * x2[x2.length - 1] - x2[x2.length - 2]]);
+                y22 = [2 * y2[0] - y2[1]];
+                for (i2 = 1; i2 < y2.length; i2++) {
+                  y22.push((y2[i2] + y2[i2 - 1]) / 2);
+                }
+                y22.push([2 * y2[y2.length - 1] - y2[y2.length - 2]]);
+              }
+              nx = Math.max(0, Math.min(x22.length - 2, Lib.findBin(xval, x22)));
+              ny = Math.max(0, Math.min(y22.length - 2, Lib.findBin(yval, y22)));
+            }
+            var x0 = xa.c2p(x2[nx]);
+            var x1 = xa.c2p(x2[nx + 1]);
+            var y0 = ya2.c2p(y2[ny]);
+            var y1 = ya2.c2p(y2[ny + 1]);
+            var _x2, _y;
+            if (isContour) {
+              _x2 = cd0.orig_x || x2;
+              _y = cd0.orig_y || y2;
+              x1 = x0;
+              xl = _x2[nx];
+              y1 = y0;
+              yl = _y[ny];
+            } else {
+              _x2 = cd0.orig_x || xc2 || x2;
+              _y = cd0.orig_y || yc2 || y2;
+              xl = xc2 ? _x2[nx] : (_x2[nx] + _x2[nx + 1]) / 2;
+              yl = yc2 ? _y[ny] : (_y[ny] + _y[ny + 1]) / 2;
+              if (xa && xa.type === "category") xl = x2[nx];
+              if (ya2 && ya2.type === "category") yl = y2[ny];
+              if (trace.zsmooth) {
+                x0 = x1 = xa.c2p(xl);
+                y0 = y1 = ya2.c2p(yl);
+              }
+            }
+            var zVal = z2[ny][nx];
+            if (zmask && !zmask[ny][nx]) zVal = void 0;
+            if (zVal === void 0 && !trace.hoverongaps) return;
+            var text;
+            if (isArrayOrTypedArray(cd0.hovertext) && isArrayOrTypedArray(cd0.hovertext[ny])) {
+              text = cd0.hovertext[ny][nx];
+            } else if (isArrayOrTypedArray(cd0.text) && isArrayOrTypedArray(cd0.text[ny])) {
+              text = cd0.text[ny][nx];
+            }
+            var cOpts = extractOpts(trace);
+            var dummyAx = {
+              type: "linear",
+              range: [cOpts.min, cOpts.max],
+              hoverformat: zhoverformat,
+              _separators: xa._separators,
+              _numFormat: xa._numFormat
+            };
+            var zLabel = Axes.tickText(dummyAx, zVal, "hover").text;
+            return [Lib.extendFlat(pointData, {
+              index: trace._after2before ? trace._after2before[ny][nx] : [ny, nx],
+              // never let a 2D override 1D type as closest point
+              distance: pointData.maxHoverDistance,
+              spikeDistance: pointData.maxSpikeDistance,
+              x0,
+              x1,
+              y0,
+              y1,
+              xLabelVal: xl,
+              yLabelVal: yl,
+              zLabelVal: zVal,
+              zLabel,
+              text
+            })];
+          };
+        }
+      });
+      var require_heatmap = __commonJS({
+        "src/traces/heatmap/index.js"(exports, module2) {
+          module2.exports = {
+            attributes: require_attributes25(),
+            supplyDefaults: require_defaults21(),
+            calc: require_calc9(),
+            plot: require_plot5(),
+            colorbar: require_colorbar2(),
+            style: require_style6(),
+            hoverPoints: require_hover5(),
+            moduleType: "trace",
+            name: "heatmap",
+            basePlotModule: require_cartesian(),
+            categories: ["cartesian", "svg", "2dMap", "showLegend"],
+            meta: {}
+          };
+        }
+      });
+      var require_heatmap2 = __commonJS({
+        "lib/heatmap.js"(exports, module2) {
+          module2.exports = require_heatmap();
+        }
+      });
+      var require_bin_attributes = __commonJS({
+        "src/traces/histogram/bin_attributes.js"(exports, module2) {
+          module2.exports = function makeBinAttrs(axLetter, match) {
+            return {
+              start: {
+                valType: "any",
+                // for date axes
+                editType: "calc"
+              },
+              end: {
+                valType: "any",
+                // for date axes
+                editType: "calc"
+              },
+              size: {
+                valType: "any",
+                // for date axes
+                editType: "calc"
+              },
+              editType: "calc"
+            };
+          };
+        }
+      });
+      var require_constants15 = __commonJS({
+        "src/traces/histogram/constants.js"(exports, module2) {
+          module2.exports = {
+            eventDataKeys: ["binNumber"]
+          };
+        }
+      });
+      var require_attributes26 = __commonJS({
+        "src/traces/histogram/attributes.js"(exports, module2) {
+          var barAttrs = require_attributes23();
+          var axisHoverFormat = require_axis_format_attributes().axisHoverFormat;
+          var { hovertemplateAttrs, texttemplateAttrs, templatefallbackAttrs } = require_template_attributes();
+          var fontAttrs = require_font_attributes();
+          var makeBinAttrs = require_bin_attributes();
+          var constants = require_constants15();
+          var extendFlat = require_extend().extendFlat;
+          module2.exports = {
+            x: {
+              valType: "data_array",
+              editType: "calc+clearAxisTypes"
+            },
+            y: {
+              valType: "data_array",
+              editType: "calc+clearAxisTypes"
+            },
+            xhoverformat: axisHoverFormat("x"),
+            yhoverformat: axisHoverFormat("y"),
+            text: extendFlat({}, barAttrs.text, {}),
+            hovertext: extendFlat({}, barAttrs.hovertext, {}),
+            orientation: barAttrs.orientation,
+            histfunc: {
+              valType: "enumerated",
+              values: ["count", "sum", "avg", "min", "max"],
+              dflt: "count",
+              editType: "calc"
+            },
+            histnorm: {
+              valType: "enumerated",
+              values: ["", "percent", "probability", "density", "probability density"],
+              dflt: "",
+              editType: "calc"
+            },
+            cumulative: {
+              enabled: {
+                valType: "boolean",
+                dflt: false,
+                editType: "calc"
+              },
+              direction: {
+                valType: "enumerated",
+                values: ["increasing", "decreasing"],
+                dflt: "increasing",
+                editType: "calc"
+              },
+              currentbin: {
+                valType: "enumerated",
+                values: ["include", "exclude", "half"],
+                dflt: "include",
+                editType: "calc"
+              },
+              editType: "calc"
+            },
+            nbinsx: {
+              valType: "integer",
+              min: 0,
+              dflt: 0,
+              editType: "calc"
+            },
+            xbins: makeBinAttrs("x", true),
+            nbinsy: {
+              valType: "integer",
+              min: 0,
+              dflt: 0,
+              editType: "calc"
+            },
+            ybins: makeBinAttrs("y", true),
+            autobinx: {
+              valType: "boolean",
+              dflt: null,
+              editType: "calc"
+            },
+            autobiny: {
+              valType: "boolean",
+              dflt: null,
+              editType: "calc"
+            },
+            bingroup: {
+              valType: "string",
+              dflt: "",
+              editType: "calc"
+            },
+            hovertemplate: hovertemplateAttrs({}, { keys: constants.eventDataKeys }),
+            hovertemplatefallback: templatefallbackAttrs(),
+            texttemplate: texttemplateAttrs({ arrayOk: false, editType: "plot" }, { keys: ["label", "value"] }),
+            texttemplatefallback: templatefallbackAttrs({ editType: "plot" }),
+            textposition: extendFlat({}, barAttrs.textposition, {
+              arrayOk: false
+            }),
+            textfont: fontAttrs({
+              arrayOk: false,
+              editType: "plot",
+              colorEditType: "style"
+            }),
+            outsidetextfont: fontAttrs({
+              arrayOk: false,
+              editType: "plot",
+              colorEditType: "style"
+            }),
+            insidetextfont: fontAttrs({
+              arrayOk: false,
+              editType: "plot",
+              colorEditType: "style"
+            }),
+            insidetextanchor: barAttrs.insidetextanchor,
+            textangle: barAttrs.textangle,
+            cliponaxis: barAttrs.cliponaxis,
+            constraintext: barAttrs.constraintext,
+            marker: barAttrs.marker,
+            offsetgroup: barAttrs.offsetgroup,
+            alignmentgroup: barAttrs.alignmentgroup,
+            selected: barAttrs.selected,
+            unselected: barAttrs.unselected,
+            zorder: barAttrs.zorder
+          };
+        }
+      });
+      var require_defaults22 = __commonJS({
+        "src/traces/histogram/defaults.js"(exports, module2) {
+          var Registry = require_registry();
+          var Lib = require_lib();
+          var Color2 = require_color();
+          var handleText = require_defaults19().handleText;
+          var handleStyleDefaults = require_style_defaults();
+          var attributes = require_attributes26();
+          module2.exports = function supplyDefaults(traceIn, traceOut, defaultColor, layout) {
+            function coerce(attr, dflt) {
+              return Lib.coerce(traceIn, traceOut, attributes, attr, dflt);
+            }
+            var x2 = coerce("x");
+            var y2 = coerce("y");
+            var cumulative = coerce("cumulative.enabled");
+            if (cumulative) {
+              coerce("cumulative.direction");
+              coerce("cumulative.currentbin");
+            }
+            coerce("text");
+            var textposition = coerce("textposition");
+            handleText(traceIn, traceOut, layout, coerce, textposition, {
+              moduleHasSelected: true,
+              moduleHasUnselected: true,
+              moduleHasConstrain: true,
+              moduleHasCliponaxis: true,
+              moduleHasTextangle: true,
+              moduleHasInsideanchor: true
+            });
+            coerce("hovertext");
+            coerce("hovertemplate");
+            coerce("hovertemplatefallback");
+            coerce("xhoverformat");
+            coerce("yhoverformat");
+            var orientation = coerce("orientation", y2 && !x2 ? "h" : "v");
+            var sampleLetter = orientation === "v" ? "x" : "y";
+            var aggLetter = orientation === "v" ? "y" : "x";
+            var len2 = x2 && y2 ? Math.min(Lib.minRowLength(x2) && Lib.minRowLength(y2)) : Lib.minRowLength(traceOut[sampleLetter] || []);
+            if (!len2) {
+              traceOut.visible = false;
+              return;
+            }
+            traceOut._length = len2;
+            var handleCalendarDefaults = Registry.getComponentMethod("calendars", "handleTraceDefaults");
+            handleCalendarDefaults(traceIn, traceOut, ["x", "y"], layout);
+            var hasAggregationData = traceOut[aggLetter];
+            if (hasAggregationData) coerce("histfunc");
+            coerce("histnorm");
+            coerce("autobin" + sampleLetter);
+            handleStyleDefaults(traceIn, traceOut, coerce, defaultColor, layout);
+            Lib.coerceSelectionMarkerOpacity(traceOut, coerce);
+            var lineColor = (traceOut.marker.line || {}).color;
+            var errorBarsSupplyDefaults = Registry.getComponentMethod("errorbars", "supplyDefaults");
+            errorBarsSupplyDefaults(traceIn, traceOut, lineColor || Color2.defaultLine, { axis: "y" });
+            errorBarsSupplyDefaults(traceIn, traceOut, lineColor || Color2.defaultLine, { axis: "x", inherit: "y" });
+            coerce("zorder");
+          };
+        }
+      });
+      var require_cross_trace_defaults3 = __commonJS({
+        "src/traces/histogram/cross_trace_defaults.js"(exports, module2) {
+          var Lib = require_lib();
+          var axisIds = require_axis_ids();
+          var traceIs = require_registry().traceIs;
+          var handleGroupingDefaults = require_grouping_defaults();
+          var validateCornerradius = require_defaults19().validateCornerradius;
+          var nestedProperty = Lib.nestedProperty;
+          var getAxisGroup = require_constraints().getAxisGroup;
+          var BINATTRS = [
+            { aStr: { x: "xbins.start", y: "ybins.start" }, name: "start" },
+            { aStr: { x: "xbins.end", y: "ybins.end" }, name: "end" },
+            { aStr: { x: "xbins.size", y: "ybins.size" }, name: "size" },
+            { aStr: { x: "nbinsx", y: "nbinsy" }, name: "nbins" }
+          ];
+          var BINDIRECTIONS = ["x", "y"];
+          module2.exports = function crossTraceDefaults(fullData, fullLayout) {
+            var allBinOpts = fullLayout._histogramBinOpts = {};
+            var histTraces = [];
+            var mustMatchTracesLookup = {};
+            var otherTracesList = [];
+            var traceOut, traces, groupName, binDir;
+            var i2, j2, k2;
+            function coerce(attr2, dflt) {
+              return Lib.coerce(traceOut._input, traceOut, traceOut._module.attributes, attr2, dflt);
+            }
+            function orientation2binDir(traceOut2) {
+              return traceOut2.orientation === "v" ? "x" : "y";
+            }
+            function getAxisType(traceOut2, binDir2) {
+              var ax = axisIds.getFromTrace({ _fullLayout: fullLayout }, traceOut2, binDir2);
+              return ax.type;
+            }
+            function fillBinOpts(traceOut2, groupName2, binDir2) {
+              var fallbackGroupName = traceOut2.uid + "__" + binDir2;
+              if (!groupName2) groupName2 = fallbackGroupName;
+              var axType = getAxisType(traceOut2, binDir2);
+              var calendar = traceOut2[binDir2 + "calendar"] || "";
+              var binOpts2 = allBinOpts[groupName2];
+              var needsNewItem = true;
+              if (binOpts2) {
+                if (axType === binOpts2.axType && calendar === binOpts2.calendar) {
+                  needsNewItem = false;
+                  binOpts2.traces.push(traceOut2);
+                  binOpts2.dirs.push(binDir2);
+                } else {
+                  groupName2 = fallbackGroupName;
+                  if (axType !== binOpts2.axType) {
+                    Lib.warn([
+                      "Attempted to group the bins of trace",
+                      traceOut2.index,
+                      "set on a",
+                      "type:" + axType,
+                      "axis",
+                      "with bins on",
+                      "type:" + binOpts2.axType,
+                      "axis."
+                    ].join(" "));
+                  }
+                  if (calendar !== binOpts2.calendar) {
+                    Lib.warn([
+                      "Attempted to group the bins of trace",
+                      traceOut2.index,
+                      "set with a",
+                      calendar,
+                      "calendar",
+                      "with bins",
+                      binOpts2.calendar ? "on a " + binOpts2.calendar + " calendar" : "w/o a set calendar"
+                    ].join(" "));
+                  }
+                }
+              }
+              if (needsNewItem) {
+                allBinOpts[groupName2] = {
+                  traces: [traceOut2],
+                  dirs: [binDir2],
+                  axType,
+                  calendar: traceOut2[binDir2 + "calendar"] || ""
+                };
+              }
+              traceOut2["_" + binDir2 + "bingroup"] = groupName2;
+            }
+            for (i2 = 0; i2 < fullData.length; i2++) {
+              traceOut = fullData[i2];
+              if (traceIs(traceOut, "histogram")) {
+                histTraces.push(traceOut);
+                delete traceOut._xautoBinFinished;
+                delete traceOut._yautoBinFinished;
+                if (traceOut.type === "histogram") {
+                  var r2 = coerce("marker.cornerradius", fullLayout.barcornerradius);
+                  if (traceOut.marker) {
+                    traceOut.marker.cornerradius = validateCornerradius(r2);
+                  }
+                }
+                if (!traceIs(traceOut, "2dMap")) {
+                  handleGroupingDefaults(traceOut._input, traceOut, fullLayout, coerce, fullLayout.barmode);
+                }
+              }
+            }
+            var alignmentOpts = fullLayout._alignmentOpts || {};
+            for (i2 = 0; i2 < histTraces.length; i2++) {
+              traceOut = histTraces[i2];
+              groupName = "";
+              if (!traceIs(traceOut, "2dMap")) {
+                binDir = orientation2binDir(traceOut);
+                if (fullLayout.barmode === "group" && traceOut.alignmentgroup) {
+                  var pa2 = traceOut[binDir + "axis"];
+                  var aGroupId = getAxisGroup(fullLayout, pa2) + traceOut.orientation;
+                  if ((alignmentOpts[aGroupId] || {})[traceOut.alignmentgroup]) {
+                    groupName = aGroupId;
+                  }
+                }
+                if (!groupName && fullLayout.barmode !== "overlay") {
+                  groupName = getAxisGroup(fullLayout, traceOut.xaxis) + getAxisGroup(fullLayout, traceOut.yaxis) + orientation2binDir(traceOut);
+                }
+              }
+              if (groupName) {
+                if (!mustMatchTracesLookup[groupName]) {
+                  mustMatchTracesLookup[groupName] = [];
+                }
+                mustMatchTracesLookup[groupName].push(traceOut);
+              } else {
+                otherTracesList.push(traceOut);
+              }
+            }
+            for (groupName in mustMatchTracesLookup) {
+              traces = mustMatchTracesLookup[groupName];
+              if (traces.length === 1) {
+                otherTracesList.push(traces[0]);
+                continue;
+              }
+              var binGroupFound = false;
+              if (traces.length) {
+                traceOut = traces[0];
+                binGroupFound = coerce("bingroup");
+              }
+              groupName = binGroupFound || groupName;
+              for (i2 = 0; i2 < traces.length; i2++) {
+                traceOut = traces[i2];
+                var bingroupIn = traceOut._input.bingroup;
+                if (bingroupIn && bingroupIn !== groupName) {
+                  Lib.warn([
+                    "Trace",
+                    traceOut.index,
+                    "must match",
+                    "within bingroup",
+                    groupName + ".",
+                    "Ignoring its bingroup:",
+                    bingroupIn,
+                    "setting."
+                  ].join(" "));
+                }
+                traceOut.bingroup = groupName;
+                fillBinOpts(traceOut, groupName, orientation2binDir(traceOut));
+              }
+            }
+            for (i2 = 0; i2 < otherTracesList.length; i2++) {
+              traceOut = otherTracesList[i2];
+              var binGroup = coerce("bingroup");
+              if (traceIs(traceOut, "2dMap")) {
+                for (k2 = 0; k2 < 2; k2++) {
+                  binDir = BINDIRECTIONS[k2];
+                  var binGroupInDir = coerce(
+                    binDir + "bingroup",
+                    binGroup ? binGroup + "__" + binDir : null
+                  );
+                  fillBinOpts(traceOut, binGroupInDir, binDir);
+                }
+              } else {
+                fillBinOpts(traceOut, binGroup, orientation2binDir(traceOut));
+              }
+            }
+            for (groupName in allBinOpts) {
+              var binOpts = allBinOpts[groupName];
+              traces = binOpts.traces;
+              for (j2 = 0; j2 < BINATTRS.length; j2++) {
+                var attrSpec = BINATTRS[j2];
+                var attr = attrSpec.name;
+                var aStr;
+                var autoVals;
+                if (attr === "nbins" && binOpts.sizeFound) continue;
+                for (i2 = 0; i2 < traces.length; i2++) {
+                  traceOut = traces[i2];
+                  binDir = binOpts.dirs[i2];
+                  aStr = attrSpec.aStr[binDir];
+                  if (nestedProperty(traceOut._input, aStr).get() !== void 0) {
+                    binOpts[attr] = coerce(aStr);
+                    binOpts[attr + "Found"] = true;
+                    break;
+                  }
+                  autoVals = (traceOut._autoBin || {})[binDir] || {};
+                  if (autoVals[attr]) {
+                    nestedProperty(traceOut, aStr).set(autoVals[attr]);
+                  }
+                }
+                if (attr === "start" || attr === "end") {
+                  for (; i2 < traces.length; i2++) {
+                    traceOut = traces[i2];
+                    if (traceOut["_" + binDir + "bingroup"]) {
+                      autoVals = (traceOut._autoBin || {})[binDir] || {};
+                      coerce(aStr, autoVals[attr]);
+                    }
+                  }
+                }
+                if (attr === "nbins" && !binOpts.sizeFound && !binOpts.nbinsFound) {
+                  traceOut = traces[0];
+                  binOpts[attr] = coerce(aStr);
+                }
+              }
+            }
+          };
+        }
+      });
+      var require_hover6 = __commonJS({
+        "src/traces/histogram/hover.js"(exports, module2) {
+          var barHover = require_hover3().hoverPoints;
+          var hoverLabelText = require_axes().hoverLabelText;
+          module2.exports = function hoverPoints(pointData, xval, yval, hovermode, opts) {
+            var pts = barHover(pointData, xval, yval, hovermode, opts);
+            if (!pts) return;
+            pointData = pts[0];
+            var di2 = pointData.cd[pointData.index];
+            var trace = pointData.cd[0].trace;
+            if (!trace.cumulative.enabled) {
+              var posLetter = trace.orientation === "h" ? "y" : "x";
+              pointData[posLetter + "Label"] = hoverLabelText(pointData[posLetter + "a"], [di2.ph0, di2.ph1], trace[posLetter + "hoverformat"]);
+            }
+            return pts;
+          };
+        }
+      });
+      var require_event_data3 = __commonJS({
+        "src/traces/histogram/event_data.js"(exports, module2) {
+          module2.exports = function eventData(out, pt2, trace, cd2, pointNumber) {
+            out.x = "xVal" in pt2 ? pt2.xVal : pt2.x;
+            out.y = "yVal" in pt2 ? pt2.yVal : pt2.y;
+            if ("zLabelVal" in pt2) out.z = pt2.zLabelVal;
+            if (pt2.xa) out.xaxis = pt2.xa;
+            if (pt2.ya) out.yaxis = pt2.ya;
+            if (!(trace.cumulative || {}).enabled) {
+              var pts = Array.isArray(pointNumber) ? cd2[0].pts[pointNumber[0]][pointNumber[1]] : cd2[pointNumber].pts;
+              out.pointNumbers = pts;
+              out.binNumber = out.pointNumber;
+              delete out.pointNumber;
+              delete out.pointIndex;
+              var pointIndices;
+              if (trace._indexToPoints) {
+                pointIndices = [];
+                for (var i2 = 0; i2 < pts.length; i2++) {
+                  pointIndices = pointIndices.concat(trace._indexToPoints[pts[i2]]);
+                }
+              } else {
+                pointIndices = pts;
+              }
+              out.pointIndices = pointIndices;
+            }
+            return out;
+          };
+        }
+      });
+      var require_histogram = __commonJS({
+        "src/traces/histogram/index.js"(exports, module2) {
+          module2.exports = {
+            attributes: require_attributes26(),
+            layoutAttributes: require_layout_attributes6(),
+            supplyDefaults: require_defaults22(),
+            crossTraceDefaults: require_cross_trace_defaults3(),
+            supplyLayoutDefaults: require_layout_defaults5(),
+            calc: require_calc7().calc,
+            crossTraceCalc: require_cross_trace_calc().crossTraceCalc,
+            plot: require_plot3().plot,
+            layerName: "barlayer",
+            style: require_style4().style,
+            styleOnSelect: require_style4().styleOnSelect,
+            colorbar: require_marker_colorbar(),
+            hoverPoints: require_hover6(),
+            selectPoints: require_select3(),
+            eventData: require_event_data3(),
+            moduleType: "trace",
+            name: "histogram",
+            basePlotModule: require_cartesian(),
+            categories: ["bar-like", "cartesian", "svg", "bar", "histogram", "oriented", "errorBarsOK", "showLegend"],
+            meta: {}
+          };
+        }
+      });
+      var require_histogram2 = __commonJS({
+        "lib/histogram.js"(exports, module2) {
+          module2.exports = require_histogram();
+        }
+      });
+      var require_attributes27 = __commonJS({
+        "src/traces/histogram2d/attributes.js"(exports, module2) {
+          var histogramAttrs = require_attributes26();
+          var makeBinAttrs = require_bin_attributes();
+          var heatmapAttrs = require_attributes25();
+          var baseAttrs = require_attributes2();
+          var axisHoverFormat = require_axis_format_attributes().axisHoverFormat;
+          var { hovertemplateAttrs, texttemplateAttrs, templatefallbackAttrs } = require_template_attributes();
+          var colorScaleAttrs = require_attributes8();
+          var extendFlat = require_extend().extendFlat;
+          module2.exports = extendFlat(
+            {
+              x: histogramAttrs.x,
+              y: histogramAttrs.y,
+              z: {
+                valType: "data_array",
+                editType: "calc"
+              },
+              marker: {
+                color: {
+                  valType: "data_array",
+                  editType: "calc"
+                },
+                editType: "calc"
+              },
+              histnorm: histogramAttrs.histnorm,
+              histfunc: histogramAttrs.histfunc,
+              nbinsx: histogramAttrs.nbinsx,
+              xbins: makeBinAttrs("x"),
+              nbinsy: histogramAttrs.nbinsy,
+              ybins: makeBinAttrs("y"),
+              autobinx: histogramAttrs.autobinx,
+              autobiny: histogramAttrs.autobiny,
+              bingroup: extendFlat({}, histogramAttrs.bingroup, {}),
+              xbingroup: extendFlat({}, histogramAttrs.bingroup, {}),
+              ybingroup: extendFlat({}, histogramAttrs.bingroup, {}),
+              xgap: heatmapAttrs.xgap,
+              ygap: heatmapAttrs.ygap,
+              zsmooth: heatmapAttrs.zsmooth,
+              xhoverformat: axisHoverFormat("x"),
+              yhoverformat: axisHoverFormat("y"),
+              zhoverformat: axisHoverFormat("z", 1),
+              hovertemplate: hovertemplateAttrs({}, { keys: ["z"] }),
+              hovertemplatefallback: templatefallbackAttrs(),
+              texttemplate: texttemplateAttrs({ arrayOk: false, editType: "plot" }, { keys: ["z"] }),
+              texttemplatefallback: templatefallbackAttrs({ editType: "plot" }),
+              textfont: heatmapAttrs.textfont,
+              showlegend: extendFlat({}, baseAttrs.showlegend, { dflt: false })
+            },
+            colorScaleAttrs("", { cLetter: "z", autoColorDflt: false })
+          );
+        }
+      });
+      var require_sample_defaults = __commonJS({
+        "src/traces/histogram2d/sample_defaults.js"(exports, module2) {
+          var Registry = require_registry();
+          var Lib = require_lib();
+          module2.exports = function handleSampleDefaults(traceIn, traceOut, coerce, layout) {
+            var x2 = coerce("x");
+            var y2 = coerce("y");
+            var xlen = Lib.minRowLength(x2);
+            var ylen = Lib.minRowLength(y2);
+            if (!xlen || !ylen) {
+              traceOut.visible = false;
+              return;
+            }
+            traceOut._length = Math.min(xlen, ylen);
+            var handleCalendarDefaults = Registry.getComponentMethod("calendars", "handleTraceDefaults");
+            handleCalendarDefaults(traceIn, traceOut, ["x", "y"], layout);
+            var hasAggregationData = coerce("z") || coerce("marker.color");
+            if (hasAggregationData) coerce("histfunc");
+            coerce("histnorm");
+            coerce("autobinx");
+            coerce("autobiny");
+          };
+        }
+      });
+      var require_defaults23 = __commonJS({
+        "src/traces/histogram2d/defaults.js"(exports, module2) {
+          var Lib = require_lib();
+          var handleSampleDefaults = require_sample_defaults();
+          var handleStyleDefaults = require_style_defaults2();
+          var colorscaleDefaults = require_defaults2();
+          var handleHeatmapLabelDefaults = require_label_defaults();
+          var attributes = require_attributes27();
+          module2.exports = function supplyDefaults(traceIn, traceOut, defaultColor, layout) {
+            function coerce(attr, dflt) {
+              return Lib.coerce(traceIn, traceOut, attributes, attr, dflt);
+            }
+            handleSampleDefaults(traceIn, traceOut, coerce, layout);
+            if (traceOut.visible === false) return;
+            handleStyleDefaults(traceIn, traceOut, coerce, layout);
+            colorscaleDefaults(traceIn, traceOut, layout, coerce, { prefix: "", cLetter: "z" });
+            coerce("hovertemplate");
+            coerce("hovertemplatefallback");
+            handleHeatmapLabelDefaults(coerce, layout);
+            coerce("xhoverformat");
+            coerce("yhoverformat");
+          };
+        }
+      });
+      var require_hover7 = __commonJS({
+        "src/traces/histogram2d/hover.js"(exports, module2) {
+          var heatmapHover = require_hover5();
+          var hoverLabelText = require_axes().hoverLabelText;
+          module2.exports = function hoverPoints(pointData, xval, yval, hovermode, opts) {
+            var pts = heatmapHover(pointData, xval, yval, hovermode, opts);
+            if (!pts) return;
+            pointData = pts[0];
+            var indices = pointData.index;
+            var ny = indices[0];
+            var nx = indices[1];
+            var cd0 = pointData.cd[0];
+            var trace = cd0.trace;
+            var xRange = cd0.xRanges[nx];
+            var yRange = cd0.yRanges[ny];
+            pointData.xLabel = hoverLabelText(pointData.xa, [xRange[0], xRange[1]], trace.xhoverformat);
+            pointData.yLabel = hoverLabelText(pointData.ya, [yRange[0], yRange[1]], trace.yhoverformat);
+            return pts;
+          };
+        }
+      });
+      var require_histogram2d = __commonJS({
+        "src/traces/histogram2d/index.js"(exports, module2) {
+          module2.exports = {
+            attributes: require_attributes27(),
+            supplyDefaults: require_defaults23(),
+            crossTraceDefaults: require_cross_trace_defaults3(),
+            calc: require_calc9(),
+            plot: require_plot5(),
+            layerName: "heatmaplayer",
+            colorbar: require_colorbar2(),
+            style: require_style6(),
+            hoverPoints: require_hover7(),
+            eventData: require_event_data3(),
+            moduleType: "trace",
+            name: "histogram2d",
+            basePlotModule: require_cartesian(),
+            categories: ["cartesian", "svg", "2dMap", "histogram", "showLegend"],
+            meta: {}
+          };
+        }
+      });
+      var require_histogram2d2 = __commonJS({
+        "lib/histogram2d.js"(exports, module2) {
+          module2.exports = require_histogram2d();
+        }
+      });
+      var require_filter_ops = __commonJS({
+        "src/constants/filter_ops.js"(exports, module2) {
+          module2.exports = {
+            COMPARISON_OPS: ["=", "!=", "<", ">=", ">", "<="],
+            COMPARISON_OPS2: ["=", "<", ">=", ">", "<="],
+            INTERVAL_OPS: ["[]", "()", "[)", "(]", "][", ")(", "](", ")["],
+            SET_OPS: ["{}", "}{"],
+            CONSTRAINT_REDUCTION: {
+              // for contour constraints, open/closed endpoints are equivalent
+              "=": "=",
+              "<": "<",
+              "<=": "<",
+              ">": ">",
+              ">=": ">",
+              "[]": "[]",
+              "()": "[]",
+              "[)": "[]",
+              "(]": "[]",
+              "][": "][",
+              ")(": "][",
+              "](": "][",
+              ")[": "]["
+            }
+          };
+        }
+      });
+      var require_attributes28 = __commonJS({
+        "src/traces/contour/attributes.js"(exports, module2) {
+          var heatmapAttrs = require_attributes25();
+          var scatterAttrs = require_attributes12();
+          var axisFormat = require_axis_format_attributes();
+          var axisHoverFormat = axisFormat.axisHoverFormat;
+          var descriptionOnlyNumbers = axisFormat.descriptionOnlyNumbers;
+          var colorScaleAttrs = require_attributes8();
+          var dash = require_attributes4().dash;
+          var fontAttrs = require_font_attributes();
+          var extendFlat = require_extend().extendFlat;
+          var filterOps = require_filter_ops();
+          var COMPARISON_OPS2 = filterOps.COMPARISON_OPS2;
+          var INTERVAL_OPS = filterOps.INTERVAL_OPS;
+          var scatterLineAttrs = scatterAttrs.line;
+          module2.exports = extendFlat(
+            {
+              z: heatmapAttrs.z,
+              x: heatmapAttrs.x,
+              x0: heatmapAttrs.x0,
+              dx: heatmapAttrs.dx,
+              y: heatmapAttrs.y,
+              y0: heatmapAttrs.y0,
+              dy: heatmapAttrs.dy,
+              xperiod: heatmapAttrs.xperiod,
+              yperiod: heatmapAttrs.yperiod,
+              xperiod0: scatterAttrs.xperiod0,
+              yperiod0: scatterAttrs.yperiod0,
+              xperiodalignment: heatmapAttrs.xperiodalignment,
+              yperiodalignment: heatmapAttrs.yperiodalignment,
+              text: heatmapAttrs.text,
+              hovertext: heatmapAttrs.hovertext,
+              transpose: heatmapAttrs.transpose,
+              xtype: heatmapAttrs.xtype,
+              ytype: heatmapAttrs.ytype,
+              xhoverformat: axisHoverFormat("x"),
+              yhoverformat: axisHoverFormat("y"),
+              zhoverformat: axisHoverFormat("z", 1),
+              hovertemplate: heatmapAttrs.hovertemplate,
+              hovertemplatefallback: heatmapAttrs.hovertemplatefallback,
+              texttemplate: extendFlat({}, heatmapAttrs.texttemplate, {}),
+              texttemplatefallback: heatmapAttrs.texttemplatefallback,
+              textfont: extendFlat({}, heatmapAttrs.textfont, {}),
+              hoverongaps: heatmapAttrs.hoverongaps,
+              connectgaps: extendFlat({}, heatmapAttrs.connectgaps, {}),
+              fillcolor: {
+                valType: "color",
+                editType: "calc"
+              },
+              autocontour: {
+                valType: "boolean",
+                dflt: true,
+                editType: "calc",
+                impliedEdits: {
+                  "contours.start": void 0,
+                  "contours.end": void 0,
+                  "contours.size": void 0
+                }
+              },
+              ncontours: {
+                valType: "integer",
+                dflt: 15,
+                min: 1,
+                editType: "calc"
+              },
+              contours: {
+                type: {
+                  valType: "enumerated",
+                  values: ["levels", "constraint"],
+                  dflt: "levels",
+                  editType: "calc"
+                },
+                start: {
+                  valType: "number",
+                  dflt: null,
+                  editType: "plot",
+                  impliedEdits: { "^autocontour": false }
+                },
+                end: {
+                  valType: "number",
+                  dflt: null,
+                  editType: "plot",
+                  impliedEdits: { "^autocontour": false }
+                },
+                size: {
+                  valType: "number",
+                  dflt: null,
+                  min: 0,
+                  editType: "plot",
+                  impliedEdits: { "^autocontour": false }
+                },
+                coloring: {
+                  valType: "enumerated",
+                  values: ["fill", "heatmap", "lines", "none"],
+                  dflt: "fill",
+                  editType: "calc"
+                },
+                showlines: {
+                  valType: "boolean",
+                  dflt: true,
+                  editType: "plot"
+                },
+                showlabels: {
+                  valType: "boolean",
+                  dflt: false,
+                  editType: "plot"
+                },
+                labelfont: fontAttrs({
+                  editType: "plot",
+                  colorEditType: "style"
+                }),
+                labelformat: {
+                  valType: "string",
+                  dflt: "",
+                  editType: "plot",
+                  description: descriptionOnlyNumbers("contour label")
+                },
+                operation: {
+                  valType: "enumerated",
+                  values: [].concat(COMPARISON_OPS2).concat(INTERVAL_OPS),
+                  dflt: "=",
+                  editType: "calc"
+                },
+                value: {
+                  valType: "any",
+                  dflt: 0,
+                  editType: "calc"
+                },
+                editType: "calc",
+                impliedEdits: { autocontour: false }
+              },
+              line: {
+                color: extendFlat({}, scatterLineAttrs.color, {
+                  editType: "style+colorbars"
+                }),
+                width: {
+                  valType: "number",
+                  min: 0,
+                  editType: "style+colorbars"
+                },
+                dash,
+                smoothing: extendFlat({}, scatterLineAttrs.smoothing, {}),
+                editType: "plot"
+              },
+              zorder: scatterAttrs.zorder
+            },
+            colorScaleAttrs("", {
+              cLetter: "z",
+              autoColorDflt: false,
+              editTypeOverride: "calc"
+            })
+          );
+        }
+      });
+      var require_attributes29 = __commonJS({
+        "src/traces/histogram2dcontour/attributes.js"(exports, module2) {
+          var histogram2dAttrs = require_attributes27();
+          var contourAttrs = require_attributes28();
+          var colorScaleAttrs = require_attributes8();
+          var axisHoverFormat = require_axis_format_attributes().axisHoverFormat;
+          var extendFlat = require_extend().extendFlat;
+          module2.exports = extendFlat(
+            {
+              x: histogram2dAttrs.x,
+              y: histogram2dAttrs.y,
+              z: histogram2dAttrs.z,
+              marker: histogram2dAttrs.marker,
+              histnorm: histogram2dAttrs.histnorm,
+              histfunc: histogram2dAttrs.histfunc,
+              nbinsx: histogram2dAttrs.nbinsx,
+              xbins: histogram2dAttrs.xbins,
+              nbinsy: histogram2dAttrs.nbinsy,
+              ybins: histogram2dAttrs.ybins,
+              autobinx: histogram2dAttrs.autobinx,
+              autobiny: histogram2dAttrs.autobiny,
+              bingroup: histogram2dAttrs.bingroup,
+              xbingroup: histogram2dAttrs.xbingroup,
+              ybingroup: histogram2dAttrs.ybingroup,
+              autocontour: contourAttrs.autocontour,
+              ncontours: contourAttrs.ncontours,
+              contours: contourAttrs.contours,
+              line: {
+                color: contourAttrs.line.color,
+                width: extendFlat({}, contourAttrs.line.width, {
+                  dflt: 0.5
+                }),
+                dash: contourAttrs.line.dash,
+                smoothing: contourAttrs.line.smoothing,
+                editType: "plot"
+              },
+              xhoverformat: axisHoverFormat("x"),
+              yhoverformat: axisHoverFormat("y"),
+              zhoverformat: axisHoverFormat("z", 1),
+              hovertemplate: histogram2dAttrs.hovertemplate,
+              hovertemplatefallback: histogram2dAttrs.hovertemplatefallback,
+              texttemplate: contourAttrs.texttemplate,
+              texttemplatefallback: contourAttrs.texttemplatefallback,
+              textfont: contourAttrs.textfont
+            },
+            colorScaleAttrs("", {
+              cLetter: "z",
+              editTypeOverride: "calc"
+            })
+          );
+        }
+      });
+      var require_contours_defaults = __commonJS({
+        "src/traces/contour/contours_defaults.js"(exports, module2) {
+          module2.exports = function handleContourDefaults(traceIn, traceOut, coerce, coerce2) {
+            var contourStart = coerce2("contours.start");
+            var contourEnd = coerce2("contours.end");
+            var missingEnd = contourStart === false || contourEnd === false;
+            var contourSize = coerce("contours.size");
+            var autoContour;
+            if (missingEnd) autoContour = traceOut.autocontour = true;
+            else autoContour = coerce("autocontour", false);
+            if (autoContour || !contourSize) coerce("ncontours");
+          };
+        }
+      });
+      var require_label_defaults2 = __commonJS({
+        "src/traces/contour/label_defaults.js"(exports, module2) {
+          var Lib = require_lib();
+          module2.exports = function handleLabelDefaults(coerce, layout, lineColor, opts) {
+            if (!opts) opts = {};
+            var showLabels = coerce("contours.showlabels");
+            if (showLabels) {
+              var globalFont = layout.font;
+              Lib.coerceFont(coerce, "contours.labelfont", globalFont, { overrideDflt: {
+                color: lineColor
+              } });
+              coerce("contours.labelformat");
+            }
+            if (opts.hasHover !== false) coerce("zhoverformat");
+          };
+        }
+      });
+      var require_style_defaults3 = __commonJS({
+        "src/traces/contour/style_defaults.js"(exports, module2) {
+          var colorscaleDefaults = require_defaults2();
+          var handleLabelDefaults = require_label_defaults2();
+          module2.exports = function handleStyleDefaults(traceIn, traceOut, coerce, layout, opts) {
+            var coloring = coerce("contours.coloring");
+            var showLines;
+            var lineColor = "";
+            if (coloring === "fill") showLines = coerce("contours.showlines");
+            if (showLines !== false) {
+              if (coloring !== "lines") lineColor = coerce("line.color", "#000");
+              coerce("line.width", 0.5);
+              coerce("line.dash");
+            }
+            if (coloring !== "none") {
+              if (traceIn.showlegend !== true) traceOut.showlegend = false;
+              traceOut._dfltShowLegend = false;
+              colorscaleDefaults(
+                traceIn,
+                traceOut,
+                layout,
+                coerce,
+                { prefix: "", cLetter: "z" }
+              );
+            }
+            coerce("line.smoothing");
+            handleLabelDefaults(coerce, layout, lineColor, opts);
+          };
+        }
+      });
+      var require_defaults24 = __commonJS({
+        "src/traces/histogram2dcontour/defaults.js"(exports, module2) {
+          var Lib = require_lib();
+          var handleSampleDefaults = require_sample_defaults();
+          var handleContoursDefaults = require_contours_defaults();
+          var handleStyleDefaults = require_style_defaults3();
+          var handleHeatmapLabelDefaults = require_label_defaults();
+          var attributes = require_attributes29();
+          module2.exports = function supplyDefaults(traceIn, traceOut, defaultColor, layout) {
+            function coerce(attr, dflt) {
+              return Lib.coerce(traceIn, traceOut, attributes, attr, dflt);
+            }
+            function coerce2(attr) {
+              return Lib.coerce2(traceIn, traceOut, attributes, attr);
+            }
+            handleSampleDefaults(traceIn, traceOut, coerce, layout);
+            if (traceOut.visible === false) return;
+            handleContoursDefaults(traceIn, traceOut, coerce, coerce2);
+            handleStyleDefaults(traceIn, traceOut, coerce, layout);
+            coerce("xhoverformat");
+            coerce("yhoverformat");
+            coerce("hovertemplate");
+            coerce("hovertemplatefallback");
+            if (traceOut.contours && traceOut.contours.coloring === "heatmap") {
+              handleHeatmapLabelDefaults(coerce, layout);
+            }
+          };
+        }
+      });
+      var require_set_contours = __commonJS({
+        "src/traces/contour/set_contours.js"(exports, module2) {
+          var Axes = require_axes();
+          var Lib = require_lib();
+          module2.exports = function setContours(trace, vals) {
+            var contours = trace.contours;
+            if (trace.autocontour) {
+              var zmin = trace.zmin;
+              var zmax = trace.zmax;
+              if (trace.zauto || zmin === void 0) {
+                zmin = Lib.aggNums(Math.min, null, vals);
+              }
+              if (trace.zauto || zmax === void 0) {
+                zmax = Lib.aggNums(Math.max, null, vals);
+              }
+              var dummyAx = autoContours(zmin, zmax, trace.ncontours);
+              contours.size = dummyAx.dtick;
+              contours.start = Axes.tickFirst(dummyAx);
+              dummyAx.range.reverse();
+              contours.end = Axes.tickFirst(dummyAx);
+              if (contours.start === zmin) contours.start += contours.size;
+              if (contours.end === zmax) contours.end -= contours.size;
+              if (contours.start > contours.end) {
+                contours.start = contours.end = (contours.start + contours.end) / 2;
+              }
+              if (!trace._input.contours) trace._input.contours = {};
+              Lib.extendFlat(trace._input.contours, {
+                start: contours.start,
+                end: contours.end,
+                size: contours.size
+              });
+              trace._input.autocontour = true;
+            } else if (contours.type !== "constraint") {
+              var start = contours.start;
+              var end = contours.end;
+              var inputContours = trace._input.contours;
+              if (start > end) {
+                contours.start = inputContours.start = end;
+                end = contours.end = inputContours.end = start;
+                start = contours.start;
+              }
+              if (!(contours.size > 0)) {
+                var sizeOut;
+                if (start === end) sizeOut = 1;
+                else sizeOut = autoContours(start, end, trace.ncontours).dtick;
+                inputContours.size = contours.size = sizeOut;
+              }
+            }
+          };
+          function autoContours(start, end, ncontours) {
+            var dummyAx = {
+              type: "linear",
+              range: [start, end]
+            };
+            Axes.autoTicks(
+              dummyAx,
+              (end - start) / (ncontours || 15)
+            );
+            return dummyAx;
+          }
+        }
+      });
+      var require_end_plus = __commonJS({
+        "src/traces/contour/end_plus.js"(exports, module2) {
+          module2.exports = function endPlus(contours) {
+            return contours.end + contours.size / 1e6;
+          };
+        }
+      });
+      var require_calc10 = __commonJS({
+        "src/traces/contour/calc.js"(exports, module2) {
+          var Colorscale = require_colorscale();
+          var heatmapCalc = require_calc9();
+          var setContours = require_set_contours();
+          var endPlus = require_end_plus();
+          module2.exports = function calc(gd2, trace) {
+            var cd2 = heatmapCalc(gd2, trace);
+            var zOut = cd2[0].z;
+            setContours(trace, zOut);
+            var contours = trace.contours;
+            var cOpts = Colorscale.extractOpts(trace);
+            var cVals;
+            if (contours.coloring === "heatmap" && cOpts.auto && trace.autocontour === false) {
+              var start = contours.start;
+              var end = endPlus(contours);
+              var cs = contours.size || 1;
+              var nc2 = Math.floor((end - start) / cs) + 1;
+              if (!isFinite(cs)) {
+                cs = 1;
+                nc2 = 1;
+              }
+              var min0 = start - cs / 2;
+              var max0 = min0 + nc2 * cs;
+              cVals = [min0, max0];
+            } else {
+              cVals = zOut;
+            }
+            Colorscale.calc(gd2, trace, { vals: cVals, cLetter: "z" });
+            return cd2;
+          };
+        }
+      });
+      var require_constants16 = __commonJS({
+        "src/traces/contour/constants.js"(exports, module2) {
+          module2.exports = {
+            // some constants to help with marching squares algorithm
+            // where does the path start for each index?
+            BOTTOMSTART: [1, 9, 13, 104, 713],
+            TOPSTART: [4, 6, 7, 104, 713],
+            LEFTSTART: [8, 12, 14, 208, 1114],
+            RIGHTSTART: [2, 3, 11, 208, 1114],
+            // which way [dx,dy] do we leave a given index?
+            // saddles are already disambiguated
+            NEWDELTA: [
+              null,
+              [-1, 0],
+              [0, -1],
+              [-1, 0],
+              [1, 0],
+              null,
+              [0, -1],
+              [-1, 0],
+              [0, 1],
+              [0, 1],
+              null,
+              [0, 1],
+              [1, 0],
+              [1, 0],
+              [0, -1]
+            ],
+            // for each saddle, the first index here is used
+            // for dx||dy<0, the second for dx||dy>0
+            CHOOSESADDLE: {
+              104: [4, 1],
+              208: [2, 8],
+              713: [7, 13],
+              1114: [11, 14]
+            },
+            // after one index has been used for a saddle, which do we
+            // substitute to be used up later?
+            SADDLEREMAINDER: { 1: 4, 2: 8, 4: 1, 7: 13, 8: 2, 11: 14, 13: 7, 14: 11 },
+            // length of a contour, as a multiple of the plot area diagonal, per label
+            LABELDISTANCE: 2,
+            // number of contour levels after which we start increasing the number of
+            // labels we draw. Many contours means they will generally be close
+            // together, so it will be harder to follow a long way to find a label
+            LABELINCREASE: 10,
+            // minimum length of a contour line, as a multiple of the label length,
+            // at which we draw *any* labels
+            LABELMIN: 3,
+            // max number of labels to draw on a single contour path, no matter how long
+            LABELMAX: 10,
+            // constants for the label position cost function
+            LABELOPTIMIZER: {
+              // weight given to edge proximity
+              EDGECOST: 1,
+              // weight given to the angle off horizontal
+              ANGLECOST: 1,
+              // weight given to distance from already-placed labels
+              NEIGHBORCOST: 5,
+              // cost multiplier for labels on the same level
+              SAMELEVELFACTOR: 10,
+              // minimum distance (as a multiple of the label length)
+              // for labels on the same level
+              SAMELEVELDISTANCE: 5,
+              // maximum cost before we won't even place the label
+              MAXCOST: 100,
+              // number of evenly spaced points to look at in the first
+              // iteration of the search
+              INITIALSEARCHPOINTS: 10,
+              // number of binary search iterations after the initial wide search
+              ITERATIONS: 5
+            }
+          };
+        }
+      });
+      var require_make_crossings = __commonJS({
+        "src/traces/contour/make_crossings.js"(exports, module2) {
+          var constants = require_constants16();
+          module2.exports = function makeCrossings(pathinfo) {
+            var z2 = pathinfo[0].z;
+            var m2 = z2.length;
+            var n2 = z2[0].length;
+            var twoWide = m2 === 2 || n2 === 2;
+            var xi2;
+            var yi2;
+            var startIndices;
+            var ystartIndices;
+            var label;
+            var corners;
+            var mi2;
+            var pi2;
+            var i2;
+            for (yi2 = 0; yi2 < m2 - 1; yi2++) {
+              ystartIndices = [];
+              if (yi2 === 0) ystartIndices = ystartIndices.concat(constants.BOTTOMSTART);
+              if (yi2 === m2 - 2) ystartIndices = ystartIndices.concat(constants.TOPSTART);
+              for (xi2 = 0; xi2 < n2 - 1; xi2++) {
+                startIndices = ystartIndices.slice();
+                if (xi2 === 0) startIndices = startIndices.concat(constants.LEFTSTART);
+                if (xi2 === n2 - 2) startIndices = startIndices.concat(constants.RIGHTSTART);
+                label = xi2 + "," + yi2;
+                corners = [
+                  [z2[yi2][xi2], z2[yi2][xi2 + 1]],
+                  [z2[yi2 + 1][xi2], z2[yi2 + 1][xi2 + 1]]
+                ];
+                for (i2 = 0; i2 < pathinfo.length; i2++) {
+                  pi2 = pathinfo[i2];
+                  mi2 = getMarchingIndex(pi2.level, corners);
+                  if (!mi2) continue;
+                  pi2.crossings[label] = mi2;
+                  if (startIndices.indexOf(mi2) !== -1) {
+                    pi2.starts.push([xi2, yi2]);
+                    if (twoWide && startIndices.indexOf(
+                      mi2,
+                      startIndices.indexOf(mi2) + 1
+                    ) !== -1) {
+                      pi2.starts.push([xi2, yi2]);
+                    }
+                  }
+                }
+              }
+            }
+          };
+          function getMarchingIndex(val, corners) {
+            var mi2 = (corners[0][0] > val ? 0 : 1) + (corners[0][1] > val ? 0 : 2) + (corners[1][1] > val ? 0 : 4) + (corners[1][0] > val ? 0 : 8);
+            if (mi2 === 5 || mi2 === 10) {
+              var avg = (corners[0][0] + corners[0][1] + corners[1][0] + corners[1][1]) / 4;
+              if (val > avg) return mi2 === 5 ? 713 : 1114;
+              return mi2 === 5 ? 104 : 208;
+            }
+            return mi2 === 15 ? 0 : mi2;
+          }
+        }
+      });
+      var require_find_all_paths = __commonJS({
+        "src/traces/contour/find_all_paths.js"(exports, module2) {
+          var Lib = require_lib();
+          var constants = require_constants16();
+          module2.exports = function findAllPaths(pathinfo, xtol, ytol) {
+            var cnt, startLoc, i2, pi2, j2;
+            xtol = xtol || 0.01;
+            ytol = ytol || 0.01;
+            for (i2 = 0; i2 < pathinfo.length; i2++) {
+              pi2 = pathinfo[i2];
+              for (j2 = 0; j2 < pi2.starts.length; j2++) {
+                startLoc = pi2.starts[j2];
+                makePath(pi2, startLoc, "edge", xtol, ytol);
+              }
+              cnt = 0;
+              while (Object.keys(pi2.crossings).length && cnt < 1e4) {
+                cnt++;
+                startLoc = Object.keys(pi2.crossings)[0].split(",").map(Number);
+                makePath(pi2, startLoc, void 0, xtol, ytol);
+              }
+              if (cnt === 1e4) Lib.log("Infinite loop in contour?");
+            }
+          };
+          function equalPts(pt1, pt2, xtol, ytol) {
+            return Math.abs(pt1[0] - pt2[0]) < xtol && Math.abs(pt1[1] - pt2[1]) < ytol;
+          }
+          function ptDist(pt1, pt2) {
+            var dx = pt1[2] - pt2[2];
+            var dy = pt1[3] - pt2[3];
+            return Math.sqrt(dx * dx + dy * dy);
+          }
+          function makePath(pi2, loc, edgeflag, xtol, ytol) {
+            var locStr = loc.join(",");
+            var mi2 = pi2.crossings[locStr];
+            var marchStep = getStartStep(mi2, edgeflag, loc);
+            var pts = [getInterpPx(pi2, loc, [-marchStep[0], -marchStep[1]])];
+            var m2 = pi2.z.length;
+            var n2 = pi2.z[0].length;
+            var startLoc = loc.slice();
+            var startStep = marchStep.slice();
+            var cnt;
+            for (cnt = 0; cnt < 1e4; cnt++) {
+              if (mi2 > 20) {
+                mi2 = constants.CHOOSESADDLE[mi2][(marchStep[0] || marchStep[1]) < 0 ? 0 : 1];
+                pi2.crossings[locStr] = constants.SADDLEREMAINDER[mi2];
+              } else {
+                delete pi2.crossings[locStr];
+              }
+              marchStep = constants.NEWDELTA[mi2];
+              if (!marchStep) {
+                Lib.log("Found bad marching index:", mi2, loc, pi2.level);
+                break;
+              }
+              pts.push(getInterpPx(pi2, loc, marchStep));
+              loc[0] += marchStep[0];
+              loc[1] += marchStep[1];
+              locStr = loc.join(",");
+              if (equalPts(pts[pts.length - 1], pts[pts.length - 2], xtol, ytol)) pts.pop();
+              var atEdge = marchStep[0] && (loc[0] < 0 || loc[0] > n2 - 2) || marchStep[1] && (loc[1] < 0 || loc[1] > m2 - 2);
+              var closedLoop = loc[0] === startLoc[0] && loc[1] === startLoc[1] && marchStep[0] === startStep[0] && marchStep[1] === startStep[1];
+              if (closedLoop || edgeflag && atEdge) break;
+              mi2 = pi2.crossings[locStr];
+            }
+            if (cnt === 1e4) {
+              Lib.log("Infinite loop in contour?");
+            }
+            var closedpath = equalPts(pts[0], pts[pts.length - 1], xtol, ytol);
+            var totaldist = 0;
+            var distThresholdFactor = 0.2 * pi2.smoothing;
+            var alldists = [];
+            var cropstart = 0;
+            var distgroup, cnt2, cnt3, newpt, ptcnt, ptavg, thisdist, i2, j2, edgepathi, edgepathj;
+            for (cnt = 1; cnt < pts.length; cnt++) {
+              thisdist = ptDist(pts[cnt], pts[cnt - 1]);
+              totaldist += thisdist;
+              alldists.push(thisdist);
+            }
+            var distThreshold = totaldist / alldists.length * distThresholdFactor;
+            function getpt(i22) {
+              return pts[i22 % pts.length];
+            }
+            for (cnt = pts.length - 2; cnt >= cropstart; cnt--) {
+              distgroup = alldists[cnt];
+              if (distgroup < distThreshold) {
+                cnt3 = 0;
+                for (cnt2 = cnt - 1; cnt2 >= cropstart; cnt2--) {
+                  if (distgroup + alldists[cnt2] < distThreshold) {
+                    distgroup += alldists[cnt2];
+                  } else break;
+                }
+                if (closedpath && cnt === pts.length - 2) {
+                  for (cnt3 = 0; cnt3 < cnt2; cnt3++) {
+                    if (distgroup + alldists[cnt3] < distThreshold) {
+                      distgroup += alldists[cnt3];
+                    } else break;
+                  }
+                }
+                ptcnt = cnt - cnt2 + cnt3 + 1;
+                ptavg = Math.floor((cnt + cnt2 + cnt3 + 2) / 2);
+                if (!closedpath && cnt === pts.length - 2) newpt = pts[pts.length - 1];
+                else if (!closedpath && cnt2 === -1) newpt = pts[0];
+                else if (ptcnt % 2) newpt = getpt(ptavg);
+                else {
+                  newpt = [
+                    (getpt(ptavg)[0] + getpt(ptavg + 1)[0]) / 2,
+                    (getpt(ptavg)[1] + getpt(ptavg + 1)[1]) / 2
+                  ];
+                }
+                pts.splice(cnt2 + 1, cnt - cnt2 + 1, newpt);
+                cnt = cnt2 + 1;
+                if (cnt3) cropstart = cnt3;
+                if (closedpath) {
+                  if (cnt === pts.length - 2) pts[cnt3] = pts[pts.length - 1];
+                  else if (cnt === 0) pts[pts.length - 1] = pts[0];
+                }
+              }
+            }
+            pts.splice(0, cropstart);
+            for (cnt = 0; cnt < pts.length; cnt++) pts[cnt].length = 2;
+            if (pts.length < 2) return;
+            else if (closedpath) {
+              pts.pop();
+              pi2.paths.push(pts);
+            } else {
+              if (!edgeflag) {
+                Lib.log(
+                  "Unclosed interior contour?",
+                  pi2.level,
+                  startLoc.join(","),
+                  pts.join("L")
+                );
+              }
+              var merged = false;
+              for (i2 = 0; i2 < pi2.edgepaths.length; i2++) {
+                edgepathi = pi2.edgepaths[i2];
+                if (!merged && equalPts(edgepathi[0], pts[pts.length - 1], xtol, ytol)) {
+                  pts.pop();
+                  merged = true;
+                  var doublemerged = false;
+                  for (j2 = 0; j2 < pi2.edgepaths.length; j2++) {
+                    edgepathj = pi2.edgepaths[j2];
+                    if (equalPts(edgepathj[edgepathj.length - 1], pts[0], xtol, ytol)) {
+                      doublemerged = true;
+                      pts.shift();
+                      pi2.edgepaths.splice(i2, 1);
+                      if (j2 === i2) {
+                        pi2.paths.push(pts.concat(edgepathj));
+                      } else {
+                        if (j2 > i2) j2--;
+                        pi2.edgepaths[j2] = edgepathj.concat(pts, edgepathi);
+                      }
+                      break;
+                    }
+                  }
+                  if (!doublemerged) {
+                    pi2.edgepaths[i2] = pts.concat(edgepathi);
+                  }
+                }
+              }
+              for (i2 = 0; i2 < pi2.edgepaths.length; i2++) {
+                if (merged) break;
+                edgepathi = pi2.edgepaths[i2];
+                if (equalPts(edgepathi[edgepathi.length - 1], pts[0], xtol, ytol)) {
+                  pts.shift();
+                  pi2.edgepaths[i2] = edgepathi.concat(pts);
+                  merged = true;
+                }
+              }
+              if (!merged) pi2.edgepaths.push(pts);
+            }
+          }
+          function getStartStep(mi2, edgeflag, loc) {
+            var dx = 0;
+            var dy = 0;
+            if (mi2 > 20 && edgeflag) {
+              if (mi2 === 208 || mi2 === 1114) {
+                dx = loc[0] === 0 ? 1 : -1;
+              } else {
+                dy = loc[1] === 0 ? 1 : -1;
+              }
+            } else if (constants.BOTTOMSTART.indexOf(mi2) !== -1) dy = 1;
+            else if (constants.LEFTSTART.indexOf(mi2) !== -1) dx = 1;
+            else if (constants.TOPSTART.indexOf(mi2) !== -1) dy = -1;
+            else dx = -1;
+            return [dx, dy];
+          }
+          function getInterpPx(pi2, loc, step) {
+            var locx = loc[0] + Math.max(step[0], 0);
+            var locy = loc[1] + Math.max(step[1], 0);
+            var zxy = pi2.z[locy][locx];
+            var xa = pi2.xaxis;
+            var ya2 = pi2.yaxis;
+            if (step[1]) {
+              var dx = (pi2.level - zxy) / (pi2.z[locy][locx + 1] - zxy);
+              var dxl = (dx !== 1 ? (1 - dx) * xa.c2l(pi2.x[locx]) : 0) + (dx !== 0 ? dx * xa.c2l(pi2.x[locx + 1]) : 0);
+              return [
+                xa.c2p(xa.l2c(dxl), true),
+                ya2.c2p(pi2.y[locy], true),
+                locx + dx,
+                locy
+              ];
+            } else {
+              var dy = (pi2.level - zxy) / (pi2.z[locy + 1][locx] - zxy);
+              var dyl = (dy !== 1 ? (1 - dy) * ya2.c2l(pi2.y[locy]) : 0) + (dy !== 0 ? dy * ya2.c2l(pi2.y[locy + 1]) : 0);
+              return [
+                xa.c2p(pi2.x[locx], true),
+                ya2.c2p(ya2.l2c(dyl), true),
+                locx,
+                locy + dy
+              ];
+            }
+          }
+        }
+      });
+      var require_constraint_mapping = __commonJS({
+        "src/traces/contour/constraint_mapping.js"(exports, module2) {
+          var filterOps = require_filter_ops();
+          var isNumeric = require_fast_isnumeric();
+          module2.exports = {
+            "[]": makeRangeSettings("[]"),
+            "][": makeRangeSettings("]["),
+            ">": makeInequalitySettings(">"),
+            "<": makeInequalitySettings("<"),
+            "=": makeInequalitySettings("=")
+          };
+          function coerceValue(operation, value) {
+            var hasArrayValue = Array.isArray(value);
+            var coercedValue;
+            function coerce(value2) {
+              return isNumeric(value2) ? +value2 : null;
+            }
+            if (filterOps.COMPARISON_OPS2.indexOf(operation) !== -1) {
+              coercedValue = hasArrayValue ? coerce(value[0]) : coerce(value);
+            } else if (filterOps.INTERVAL_OPS.indexOf(operation) !== -1) {
+              coercedValue = hasArrayValue ? [coerce(value[0]), coerce(value[1])] : [coerce(value), coerce(value)];
+            } else if (filterOps.SET_OPS.indexOf(operation) !== -1) {
+              coercedValue = hasArrayValue ? value.map(coerce) : [coerce(value)];
+            }
+            return coercedValue;
+          }
+          function makeRangeSettings(operation) {
+            return function(value) {
+              value = coerceValue(operation, value);
+              var min = Math.min(value[0], value[1]);
+              var max = Math.max(value[0], value[1]);
+              return {
+                start: min,
+                end: max,
+                size: max - min
+              };
+            };
+          }
+          function makeInequalitySettings(operation) {
+            return function(value) {
+              value = coerceValue(operation, value);
+              return {
+                start: value,
+                end: Infinity,
+                size: Infinity
+              };
+            };
+          }
+        }
+      });
+      var require_empty_pathinfo = __commonJS({
+        "src/traces/contour/empty_pathinfo.js"(exports, module2) {
+          var Lib = require_lib();
+          var constraintMapping = require_constraint_mapping();
+          var endPlus = require_end_plus();
+          module2.exports = function emptyPathinfo(contours, plotinfo, cd0) {
+            var contoursFinal = contours.type === "constraint" ? constraintMapping[contours._operation](contours.value) : contours;
+            var cs = contoursFinal.size;
+            var pathinfo = [];
+            var end = endPlus(contoursFinal);
+            var carpet = cd0.trace._carpetTrace;
+            var basePathinfo = carpet ? {
+              // store axes so we can convert to px
+              xaxis: carpet.aaxis,
+              yaxis: carpet.baxis,
+              // full data arrays to use for interpolation
+              x: cd0.a,
+              y: cd0.b
+            } : {
+              xaxis: plotinfo.xaxis,
+              yaxis: plotinfo.yaxis,
+              x: cd0.x,
+              y: cd0.y
+            };
+            for (var ci2 = contoursFinal.start; ci2 < end; ci2 += cs) {
+              pathinfo.push(Lib.extendFlat({
+                level: ci2,
+                // all the cells with nontrivial marching index
+                crossings: {},
+                // starting points on the edges of the lattice for each contour
+                starts: [],
+                // all unclosed paths (may have less items than starts,
+                // if a path is closed by rounding)
+                edgepaths: [],
+                // all closed paths
+                paths: [],
+                z: cd0.z,
+                smoothing: cd0.trace.line.smoothing
+              }, basePathinfo));
+              if (pathinfo.length > 1e3) {
+                Lib.warn("Too many contours, clipping at 1000", contours);
+                break;
+              }
+            }
+            return pathinfo;
+          };
+        }
+      });
+      var require_convert_to_constraints = __commonJS({
+        "src/traces/contour/convert_to_constraints.js"(exports, module2) {
+          var Lib = require_lib();
+          module2.exports = function(pathinfo, operation) {
+            var i2, pi0, pi1;
+            var op0 = function(arr) {
+              return arr.reverse();
+            };
+            var op1 = function(arr) {
+              return arr;
+            };
+            switch (operation) {
+              case "=":
+              case "<":
+                return pathinfo;
+              case ">":
+                if (pathinfo.length !== 1) {
+                  Lib.warn("Contour data invalid for the specified inequality operation.");
+                }
+                pi0 = pathinfo[0];
+                for (i2 = 0; i2 < pi0.edgepaths.length; i2++) {
+                  pi0.edgepaths[i2] = op0(pi0.edgepaths[i2]);
+                }
+                for (i2 = 0; i2 < pi0.paths.length; i2++) {
+                  pi0.paths[i2] = op0(pi0.paths[i2]);
+                }
+                for (i2 = 0; i2 < pi0.starts.length; i2++) {
+                  pi0.starts[i2] = op0(pi0.starts[i2]);
+                }
+                return pathinfo;
+              case "][":
+                var tmp2 = op0;
+                op0 = op1;
+                op1 = tmp2;
+              case "[]":
+                if (pathinfo.length !== 2) {
+                  Lib.warn("Contour data invalid for the specified inequality range operation.");
+                }
+                pi0 = copyPathinfo(pathinfo[0]);
+                pi1 = copyPathinfo(pathinfo[1]);
+                for (i2 = 0; i2 < pi0.edgepaths.length; i2++) {
+                  pi0.edgepaths[i2] = op0(pi0.edgepaths[i2]);
+                }
+                for (i2 = 0; i2 < pi0.paths.length; i2++) {
+                  pi0.paths[i2] = op0(pi0.paths[i2]);
+                }
+                for (i2 = 0; i2 < pi0.starts.length; i2++) {
+                  pi0.starts[i2] = op0(pi0.starts[i2]);
+                }
+                while (pi1.edgepaths.length) {
+                  pi0.edgepaths.push(op1(pi1.edgepaths.shift()));
+                }
+                while (pi1.paths.length) {
+                  pi0.paths.push(op1(pi1.paths.shift()));
+                }
+                while (pi1.starts.length) {
+                  pi0.starts.push(op1(pi1.starts.shift()));
+                }
+                return [pi0];
+            }
+          };
+          function copyPathinfo(pi2) {
+            return Lib.extendFlat({}, pi2, {
+              edgepaths: Lib.extendDeep([], pi2.edgepaths),
+              paths: Lib.extendDeep([], pi2.paths),
+              starts: Lib.extendDeep([], pi2.starts)
+            });
+          }
+        }
+      });
+      var require_close_boundaries = __commonJS({
+        "src/traces/contour/close_boundaries.js"(exports, module2) {
+          module2.exports = function(pathinfo, contours) {
+            var pi0 = pathinfo[0];
+            var z2 = pi0.z;
+            var i2;
+            switch (contours.type) {
+              case "levels":
+                var edgeVal2 = Math.min(z2[0][0], z2[0][1]);
+                for (i2 = 0; i2 < pathinfo.length; i2++) {
+                  var pi2 = pathinfo[i2];
+                  pi2.prefixBoundary = !pi2.edgepaths.length && (edgeVal2 > pi2.level || pi2.starts.length && edgeVal2 === pi2.level);
+                }
+                break;
+              case "constraint":
+                pi0.prefixBoundary = false;
+                if (pi0.edgepaths.length) return;
+                var na = pi0.x.length;
+                var nb2 = pi0.y.length;
+                var boundaryMax = -Infinity;
+                var boundaryMin = Infinity;
+                for (i2 = 0; i2 < nb2; i2++) {
+                  boundaryMin = Math.min(boundaryMin, z2[i2][0]);
+                  boundaryMin = Math.min(boundaryMin, z2[i2][na - 1]);
+                  boundaryMax = Math.max(boundaryMax, z2[i2][0]);
+                  boundaryMax = Math.max(boundaryMax, z2[i2][na - 1]);
+                }
+                for (i2 = 1; i2 < na - 1; i2++) {
+                  boundaryMin = Math.min(boundaryMin, z2[0][i2]);
+                  boundaryMin = Math.min(boundaryMin, z2[nb2 - 1][i2]);
+                  boundaryMax = Math.max(boundaryMax, z2[0][i2]);
+                  boundaryMax = Math.max(boundaryMax, z2[nb2 - 1][i2]);
+                }
+                var contoursValue = contours.value;
+                var v1, v2;
+                switch (contours._operation) {
+                  case ">":
+                    if (contoursValue > boundaryMax) {
+                      pi0.prefixBoundary = true;
+                    }
+                    break;
+                  case "<":
+                    if (contoursValue < boundaryMin || pi0.starts.length && contoursValue === boundaryMin) {
+                      pi0.prefixBoundary = true;
+                    }
+                    break;
+                  case "[]":
+                    v1 = Math.min(contoursValue[0], contoursValue[1]);
+                    v2 = Math.max(contoursValue[0], contoursValue[1]);
+                    if (v2 < boundaryMin || v1 > boundaryMax || pi0.starts.length && v2 === boundaryMin) {
+                      pi0.prefixBoundary = true;
+                    }
+                    break;
+                  case "][":
+                    v1 = Math.min(contoursValue[0], contoursValue[1]);
+                    v2 = Math.max(contoursValue[0], contoursValue[1]);
+                    if (v1 < boundaryMin && v2 > boundaryMax) {
+                      pi0.prefixBoundary = true;
+                    }
+                    break;
+                }
+                break;
+            }
+          };
+        }
+      });
+      var require_plot6 = __commonJS({
+        "src/traces/contour/plot.js"(exports) {
+          var d3 = require_d3();
+          var Lib = require_lib();
+          var Drawing = require_drawing();
+          var Colorscale = require_colorscale();
+          var svgTextUtils = require_svg_text_utils();
+          var Axes = require_axes();
+          var setConvert = require_set_convert();
+          var heatmapPlot = require_plot5();
+          var makeCrossings = require_make_crossings();
+          var findAllPaths = require_find_all_paths();
+          var emptyPathinfo = require_empty_pathinfo();
+          var convertToConstraints = require_convert_to_constraints();
+          var closeBoundaries = require_close_boundaries();
+          var constants = require_constants16();
+          var costConstants = constants.LABELOPTIMIZER;
+          exports.plot = function plot(gd2, plotinfo, cdcontours, contourLayer) {
+            var xa = plotinfo.xaxis;
+            var ya2 = plotinfo.yaxis;
+            Lib.makeTraceGroups(contourLayer, cdcontours, "contour").each(function(cd2) {
+              var plotGroup = d3.select(this);
+              var cd0 = cd2[0];
+              var trace = cd0.trace;
+              var x2 = cd0.x;
+              var y2 = cd0.y;
+              var contours = trace.contours;
+              var pathinfo = emptyPathinfo(contours, plotinfo, cd0);
+              var heatmapColoringLayer = Lib.ensureSingle(plotGroup, "g", "heatmapcoloring");
+              var cdheatmaps = [];
+              if (contours.coloring === "heatmap") {
+                cdheatmaps = [cd2];
+              }
+              heatmapPlot(gd2, plotinfo, cdheatmaps, heatmapColoringLayer);
+              makeCrossings(pathinfo);
+              findAllPaths(pathinfo);
+              var leftedge = xa.c2p(x2[0], true);
+              var rightedge = xa.c2p(x2[x2.length - 1], true);
+              var bottomedge = ya2.c2p(y2[0], true);
+              var topedge = ya2.c2p(y2[y2.length - 1], true);
+              var perimeter = [
+                [leftedge, topedge],
+                [rightedge, topedge],
+                [rightedge, bottomedge],
+                [leftedge, bottomedge]
+              ];
+              var fillPathinfo = pathinfo;
+              if (contours.type === "constraint") {
+                fillPathinfo = convertToConstraints(pathinfo, contours._operation);
+              }
+              makeBackground(plotGroup, perimeter, contours);
+              makeFills(plotGroup, fillPathinfo, perimeter, contours);
+              makeLinesAndLabels(plotGroup, pathinfo, gd2, cd0, contours);
+              clipGaps(plotGroup, plotinfo, gd2, cd0, perimeter);
+            });
+          };
+          function makeBackground(plotgroup, perimeter, contours) {
+            var bggroup = Lib.ensureSingle(plotgroup, "g", "contourbg");
+            var bgfill = bggroup.selectAll("path").data(contours.coloring === "fill" ? [0] : []);
+            bgfill.enter().append("path");
+            bgfill.exit().remove();
+            bgfill.attr("d", "M" + perimeter.join("L") + "Z").style("stroke", "none");
+          }
+          function makeFills(plotgroup, pathinfo, perimeter, contours) {
+            var hasFills = contours.coloring === "fill" || contours.type === "constraint" && contours._operation !== "=";
+            var boundaryPath = "M" + perimeter.join("L") + "Z";
+            if (hasFills) {
+              closeBoundaries(pathinfo, contours);
+            }
+            var fillgroup = Lib.ensureSingle(plotgroup, "g", "contourfill");
+            var fillitems = fillgroup.selectAll("path").data(hasFills ? pathinfo : []);
+            fillitems.enter().append("path");
+            fillitems.exit().remove();
+            fillitems.each(function(pi2) {
+              var fullpath = (pi2.prefixBoundary ? boundaryPath : "") + joinAllPaths(pi2, perimeter);
+              if (!fullpath) {
+                d3.select(this).remove();
+              } else {
+                d3.select(this).attr("d", fullpath).style("stroke", "none");
+              }
+            });
+          }
+          function joinAllPaths(pi2, perimeter) {
+            var fullpath = "";
+            var i2 = 0;
+            var startsleft = pi2.edgepaths.map(function(v2, i22) {
+              return i22;
+            });
+            var newloop = true;
+            var endpt;
+            var newendpt;
+            var cnt;
+            var nexti;
+            var possiblei;
+            var addpath;
+            function istop(pt2) {
+              return Math.abs(pt2[1] - perimeter[0][1]) < 0.01;
+            }
+            function isbottom(pt2) {
+              return Math.abs(pt2[1] - perimeter[2][1]) < 0.01;
+            }
+            function isleft(pt2) {
+              return Math.abs(pt2[0] - perimeter[0][0]) < 0.01;
+            }
+            function isright(pt2) {
+              return Math.abs(pt2[0] - perimeter[2][0]) < 0.01;
+            }
+            while (startsleft.length) {
+              addpath = Drawing.smoothopen(pi2.edgepaths[i2], pi2.smoothing);
+              fullpath += newloop ? addpath : addpath.replace(/^M/, "L");
+              startsleft.splice(startsleft.indexOf(i2), 1);
+              endpt = pi2.edgepaths[i2][pi2.edgepaths[i2].length - 1];
+              nexti = -1;
+              for (cnt = 0; cnt < 4; cnt++) {
+                if (!endpt) {
+                  Lib.log("Missing end?", i2, pi2);
+                  break;
+                }
+                if (istop(endpt) && !isright(endpt)) newendpt = perimeter[1];
+                else if (isleft(endpt)) newendpt = perimeter[0];
+                else if (isbottom(endpt)) newendpt = perimeter[3];
+                else if (isright(endpt)) newendpt = perimeter[2];
+                for (possiblei = 0; possiblei < pi2.edgepaths.length; possiblei++) {
+                  var ptNew = pi2.edgepaths[possiblei][0];
+                  if (Math.abs(endpt[0] - newendpt[0]) < 0.01) {
+                    if (Math.abs(endpt[0] - ptNew[0]) < 0.01 && (ptNew[1] - endpt[1]) * (newendpt[1] - ptNew[1]) >= 0) {
+                      newendpt = ptNew;
+                      nexti = possiblei;
+                    }
+                  } else if (Math.abs(endpt[1] - newendpt[1]) < 0.01) {
+                    if (Math.abs(endpt[1] - ptNew[1]) < 0.01 && (ptNew[0] - endpt[0]) * (newendpt[0] - ptNew[0]) >= 0) {
+                      newendpt = ptNew;
+                      nexti = possiblei;
+                    }
+                  } else {
+                    Lib.log(
+                      "endpt to newendpt is not vert. or horz.",
+                      endpt,
+                      newendpt,
+                      ptNew
+                    );
+                  }
+                }
+                endpt = newendpt;
+                if (nexti >= 0) break;
+                fullpath += "L" + newendpt;
+              }
+              if (nexti === pi2.edgepaths.length) {
+                Lib.log("unclosed perimeter path");
+                break;
+              }
+              i2 = nexti;
+              newloop = startsleft.indexOf(i2) === -1;
+              if (newloop) {
+                i2 = startsleft[0];
+                fullpath += "Z";
+              }
+            }
+            for (i2 = 0; i2 < pi2.paths.length; i2++) {
+              fullpath += Drawing.smoothclosed(pi2.paths[i2], pi2.smoothing);
+            }
+            return fullpath;
+          }
+          function makeLinesAndLabels(plotgroup, pathinfo, gd2, cd0, contours) {
+            var isStatic = gd2._context.staticPlot;
+            var lineContainer = Lib.ensureSingle(plotgroup, "g", "contourlines");
+            var showLines = contours.showlines !== false;
+            var showLabels = contours.showlabels;
+            var clipLinesForLabels = showLines && showLabels;
+            var linegroup = exports.createLines(lineContainer, showLines || showLabels, pathinfo, isStatic);
+            var lineClip = exports.createLineClip(lineContainer, clipLinesForLabels, gd2, cd0.trace.uid);
+            var labelGroup = plotgroup.selectAll("g.contourlabels").data(showLabels ? [0] : []);
+            labelGroup.exit().remove();
+            labelGroup.enter().append("g").classed("contourlabels", true);
+            if (showLabels) {
+              var labelClipPathData = [];
+              var labelData = [];
+              Lib.clearLocationCache();
+              var contourFormat = exports.labelFormatter(gd2, cd0);
+              var dummyText = Drawing.tester.append("text").attr("data-notex", 1).call(Drawing.font, contours.labelfont);
+              var xa = pathinfo[0].xaxis;
+              var ya2 = pathinfo[0].yaxis;
+              var xLen = xa._length;
+              var yLen = ya2._length;
+              var xRng = xa.range;
+              var yRng = ya2.range;
+              var xMin = Lib.aggNums(Math.min, null, cd0.x);
+              var xMax = Lib.aggNums(Math.max, null, cd0.x);
+              var yMin = Lib.aggNums(Math.min, null, cd0.y);
+              var yMax = Lib.aggNums(Math.max, null, cd0.y);
+              var x0 = Math.max(xa.c2p(xMin, true), 0);
+              var x1 = Math.min(xa.c2p(xMax, true), xLen);
+              var y0 = Math.max(ya2.c2p(yMax, true), 0);
+              var y1 = Math.min(ya2.c2p(yMin, true), yLen);
+              var bounds = {};
+              if (xRng[0] < xRng[1]) {
+                bounds.left = x0;
+                bounds.right = x1;
+              } else {
+                bounds.left = x1;
+                bounds.right = x0;
+              }
+              if (yRng[0] < yRng[1]) {
+                bounds.top = y0;
+                bounds.bottom = y1;
+              } else {
+                bounds.top = y1;
+                bounds.bottom = y0;
+              }
+              bounds.middle = (bounds.top + bounds.bottom) / 2;
+              bounds.center = (bounds.left + bounds.right) / 2;
+              labelClipPathData.push([
+                [bounds.left, bounds.top],
+                [bounds.right, bounds.top],
+                [bounds.right, bounds.bottom],
+                [bounds.left, bounds.bottom]
+              ]);
+              var plotDiagonal = Math.sqrt(xLen * xLen + yLen * yLen);
+              var normLength = constants.LABELDISTANCE * plotDiagonal / Math.max(1, pathinfo.length / constants.LABELINCREASE);
+              linegroup.each(function(d2) {
+                var textOpts = exports.calcTextOpts(d2.level, contourFormat, dummyText, gd2);
+                d3.select(this).selectAll("path").each(function() {
+                  var path = this;
+                  var pathBounds = Lib.getVisibleSegment(path, bounds, textOpts.height / 2);
+                  if (!pathBounds) return;
+                  if (pathBounds.len < (textOpts.width + textOpts.height) * constants.LABELMIN) return;
+                  var maxLabels = Math.min(
+                    Math.ceil(pathBounds.len / normLength),
+                    constants.LABELMAX
+                  );
+                  for (var i2 = 0; i2 < maxLabels; i2++) {
+                    var loc = exports.findBestTextLocation(
+                      path,
+                      pathBounds,
+                      textOpts,
+                      labelData,
+                      bounds
+                    );
+                    if (!loc) break;
+                    exports.addLabelData(loc, textOpts, labelData, labelClipPathData);
+                  }
+                });
+              });
+              dummyText.remove();
+              exports.drawLabels(
+                labelGroup,
+                labelData,
+                gd2,
+                lineClip,
+                clipLinesForLabels ? labelClipPathData : null
+              );
+            }
+            if (showLabels && !showLines) linegroup.remove();
+          }
+          exports.createLines = function(lineContainer, makeLines, pathinfo, isStatic) {
+            var smoothing = pathinfo[0].smoothing;
+            var linegroup = lineContainer.selectAll("g.contourlevel").data(makeLines ? pathinfo : []);
+            linegroup.exit().remove();
+            linegroup.enter().append("g").classed("contourlevel", true);
+            if (makeLines) {
+              var opencontourlines = linegroup.selectAll("path.openline").data(function(d2) {
+                return d2.pedgepaths || d2.edgepaths;
+              });
+              opencontourlines.exit().remove();
+              opencontourlines.enter().append("path").classed("openline", true);
+              opencontourlines.attr("d", function(d2) {
+                return Drawing.smoothopen(d2, smoothing);
+              }).style("stroke-miterlimit", 1).style("vector-effect", isStatic ? "none" : "non-scaling-stroke");
+              var closedcontourlines = linegroup.selectAll("path.closedline").data(function(d2) {
+                return d2.ppaths || d2.paths;
+              });
+              closedcontourlines.exit().remove();
+              closedcontourlines.enter().append("path").classed("closedline", true);
+              closedcontourlines.attr("d", function(d2) {
+                return Drawing.smoothclosed(d2, smoothing);
+              }).style("stroke-miterlimit", 1).style("vector-effect", isStatic ? "none" : "non-scaling-stroke");
+            }
+            return linegroup;
+          };
+          exports.createLineClip = function(lineContainer, clipLinesForLabels, gd2, uid2) {
+            var clips = gd2._fullLayout._clips;
+            var clipId = clipLinesForLabels ? "clipline" + uid2 : null;
+            var lineClip = clips.selectAll("#" + clipId).data(clipLinesForLabels ? [0] : []);
+            lineClip.exit().remove();
+            lineClip.enter().append("clipPath").classed("contourlineclip", true).attr("id", clipId);
+            Drawing.setClipUrl(lineContainer, clipId, gd2);
+            return lineClip;
+          };
+          exports.labelFormatter = function(gd2, cd0) {
+            var fullLayout = gd2._fullLayout;
+            var trace = cd0.trace;
+            var contours = trace.contours;
+            var formatAxis = {
+              type: "linear",
+              _id: "ycontour",
+              showexponent: "all",
+              exponentformat: "B"
+            };
+            if (contours.labelformat) {
+              formatAxis.tickformat = contours.labelformat;
+              setConvert(formatAxis, fullLayout);
+            } else {
+              var cOpts = Colorscale.extractOpts(trace);
+              if (cOpts && cOpts.colorbar && cOpts.colorbar._axis) {
+                formatAxis = cOpts.colorbar._axis;
+              } else {
+                if (contours.type === "constraint") {
+                  var value = contours.value;
+                  if (Lib.isArrayOrTypedArray(value)) {
+                    formatAxis.range = [value[0], value[value.length - 1]];
+                  } else formatAxis.range = [value, value];
+                } else {
+                  formatAxis.range = [contours.start, contours.end];
+                  formatAxis.nticks = (contours.end - contours.start) / contours.size;
+                }
+                if (formatAxis.range[0] === formatAxis.range[1]) {
+                  formatAxis.range[1] += formatAxis.range[0] || 1;
+                }
+                if (!formatAxis.nticks) formatAxis.nticks = 1e3;
+                setConvert(formatAxis, fullLayout);
+                Axes.prepTicks(formatAxis);
+                formatAxis._tmin = null;
+                formatAxis._tmax = null;
+              }
+            }
+            return function(v2) {
+              return Axes.tickText(formatAxis, v2).text;
+            };
+          };
+          exports.calcTextOpts = function(level, contourFormat, dummyText, gd2) {
+            var text = contourFormat(level);
+            dummyText.text(text).call(svgTextUtils.convertToTspans, gd2);
+            var el2 = dummyText.node();
+            var bBox = Drawing.bBox(el2, true);
+            return {
+              text,
+              width: bBox.width,
+              height: bBox.height,
+              fontSize: +el2.style["font-size"].replace("px", ""),
+              level,
+              dy: (bBox.top + bBox.bottom) / 2
+            };
+          };
+          exports.findBestTextLocation = function(path, pathBounds, textOpts, labelData, plotBounds) {
+            var textWidth = textOpts.width;
+            var p0, dp, pMax, pMin, loc;
+            if (pathBounds.isClosed) {
+              dp = pathBounds.len / costConstants.INITIALSEARCHPOINTS;
+              p0 = pathBounds.min + dp / 2;
+              pMax = pathBounds.max;
+            } else {
+              dp = (pathBounds.len - textWidth) / (costConstants.INITIALSEARCHPOINTS + 1);
+              p0 = pathBounds.min + dp + textWidth / 2;
+              pMax = pathBounds.max - (dp + textWidth) / 2;
+            }
+            var cost = Infinity;
+            for (var j2 = 0; j2 < costConstants.ITERATIONS; j2++) {
+              for (var p2 = p0; p2 < pMax; p2 += dp) {
+                var newLocation = Lib.getTextLocation(path, pathBounds.total, p2, textWidth);
+                var newCost = locationCost(newLocation, textOpts, labelData, plotBounds);
+                if (newCost < cost) {
+                  cost = newCost;
+                  loc = newLocation;
+                  pMin = p2;
+                }
+              }
+              if (cost > costConstants.MAXCOST * 2) break;
+              if (j2) dp /= 2;
+              p0 = pMin - dp / 2;
+              pMax = p0 + dp * 1.5;
+            }
+            if (cost <= costConstants.MAXCOST) return loc;
+          };
+          function locationCost(loc, textOpts, labelData, bounds) {
+            var halfWidth = textOpts.width / 2;
+            var halfHeight = textOpts.height / 2;
+            var x2 = loc.x;
+            var y2 = loc.y;
+            var theta = loc.theta;
+            var dx = Math.cos(theta) * halfWidth;
+            var dy = Math.sin(theta) * halfWidth;
+            var normX = (x2 > bounds.center ? bounds.right - x2 : x2 - bounds.left) / (dx + Math.abs(Math.sin(theta) * halfHeight));
+            var normY = (y2 > bounds.middle ? bounds.bottom - y2 : y2 - bounds.top) / (Math.abs(dy) + Math.cos(theta) * halfHeight);
+            if (normX < 1 || normY < 1) return Infinity;
+            var cost = costConstants.EDGECOST * (1 / (normX - 1) + 1 / (normY - 1));
+            cost += costConstants.ANGLECOST * theta * theta;
+            var x1 = x2 - dx;
+            var y1 = y2 - dy;
+            var x22 = x2 + dx;
+            var y22 = y2 + dy;
+            for (var i2 = 0; i2 < labelData.length; i2++) {
+              var labeli = labelData[i2];
+              var dxd = Math.cos(labeli.theta) * labeli.width / 2;
+              var dyd = Math.sin(labeli.theta) * labeli.width / 2;
+              var dist = Lib.segmentDistance(
+                x1,
+                y1,
+                x22,
+                y22,
+                labeli.x - dxd,
+                labeli.y - dyd,
+                labeli.x + dxd,
+                labeli.y + dyd
+              ) * 2 / (textOpts.height + labeli.height);
+              var sameLevel = labeli.level === textOpts.level;
+              var distOffset = sameLevel ? costConstants.SAMELEVELDISTANCE : 1;
+              if (dist <= distOffset) return Infinity;
+              var distFactor = costConstants.NEIGHBORCOST * (sameLevel ? costConstants.SAMELEVELFACTOR : 1);
+              cost += distFactor / (dist - distOffset);
+            }
+            return cost;
+          }
+          exports.addLabelData = function(loc, textOpts, labelData, labelClipPathData) {
+            var fontSize = textOpts.fontSize;
+            var w2 = textOpts.width + fontSize / 3;
+            var h2 = Math.max(0, textOpts.height - fontSize / 3);
+            var x2 = loc.x;
+            var y2 = loc.y;
+            var theta = loc.theta;
+            var sin = Math.sin(theta);
+            var cos = Math.cos(theta);
+            var rotateXY = function(dx, dy) {
+              return [
+                x2 + dx * cos - dy * sin,
+                y2 + dx * sin + dy * cos
+              ];
+            };
+            var bBoxPts = [
+              rotateXY(-w2 / 2, -h2 / 2),
+              rotateXY(-w2 / 2, h2 / 2),
+              rotateXY(w2 / 2, h2 / 2),
+              rotateXY(w2 / 2, -h2 / 2)
+            ];
+            labelData.push({
+              text: textOpts.text,
+              x: x2,
+              y: y2,
+              dy: textOpts.dy,
+              theta,
+              level: textOpts.level,
+              width: w2,
+              height: h2
+            });
+            labelClipPathData.push(bBoxPts);
+          };
+          exports.drawLabels = function(labelGroup, labelData, gd2, lineClip, labelClipPathData) {
+            var labels = labelGroup.selectAll("text").data(labelData, function(d2) {
+              return d2.text + "," + d2.x + "," + d2.y + "," + d2.theta;
+            });
+            labels.exit().remove();
+            labels.enter().append("text").attr({
+              "data-notex": 1,
+              "text-anchor": "middle"
+            }).each(function(d2) {
+              var x2 = d2.x + Math.sin(d2.theta) * d2.dy;
+              var y2 = d2.y - Math.cos(d2.theta) * d2.dy;
+              d3.select(this).text(d2.text).attr({
+                x: x2,
+                y: y2,
+                transform: "rotate(" + 180 * d2.theta / Math.PI + " " + x2 + " " + y2 + ")"
+              }).call(svgTextUtils.convertToTspans, gd2);
+            });
+            if (labelClipPathData) {
+              var clipPath = "";
+              for (var i2 = 0; i2 < labelClipPathData.length; i2++) {
+                clipPath += "M" + labelClipPathData[i2].join("L") + "Z";
+              }
+              var lineClipPath = Lib.ensureSingle(lineClip, "path", "");
+              lineClipPath.attr("d", clipPath);
+            }
+          };
+          function clipGaps(plotGroup, plotinfo, gd2, cd0, perimeter) {
+            var trace = cd0.trace;
+            var clips = gd2._fullLayout._clips;
+            var clipId = "clip" + trace.uid;
+            var clipPath = clips.selectAll("#" + clipId).data(trace.connectgaps ? [] : [0]);
+            clipPath.enter().append("clipPath").classed("contourclip", true).attr("id", clipId);
+            clipPath.exit().remove();
+            if (trace.connectgaps === false) {
+              var clipPathInfo = {
+                // fraction of the way from missing to present point
+                // to draw the boundary.
+                // if you make this 1 (or 1-epsilon) then a point in
+                // a sea of missing data will disappear entirely.
+                level: 0.9,
+                crossings: {},
+                starts: [],
+                edgepaths: [],
+                paths: [],
+                xaxis: plotinfo.xaxis,
+                yaxis: plotinfo.yaxis,
+                x: cd0.x,
+                y: cd0.y,
+                // 0 = no data, 1 = data
+                z: makeClipMask(cd0),
+                smoothing: 0
+              };
+              makeCrossings([clipPathInfo]);
+              findAllPaths([clipPathInfo]);
+              closeBoundaries([clipPathInfo], { type: "levels" });
+              var path = Lib.ensureSingle(clipPath, "path", "");
+              path.attr(
+                "d",
+                (clipPathInfo.prefixBoundary ? "M" + perimeter.join("L") + "Z" : "") + joinAllPaths(clipPathInfo, perimeter)
+              );
+            } else clipId = null;
+            Drawing.setClipUrl(plotGroup, clipId, gd2);
+          }
+          function makeClipMask(cd0) {
+            var empties = cd0.trace._emptypoints;
+            var z2 = [];
+            var m2 = cd0.z.length;
+            var n2 = cd0.z[0].length;
+            var i2;
+            var row = [];
+            var emptyPoint;
+            for (i2 = 0; i2 < n2; i2++) row.push(1);
+            for (i2 = 0; i2 < m2; i2++) z2.push(row.slice());
+            for (i2 = 0; i2 < empties.length; i2++) {
+              emptyPoint = empties[i2];
+              z2[emptyPoint[0]][emptyPoint[1]] = 0;
+            }
+            cd0.zmask = z2;
+            return z2;
+          }
+        }
+      });
+      var require_make_color_map = __commonJS({
+        "src/traces/contour/make_color_map.js"(exports, module2) {
+          var d3 = require_d3();
+          var Colorscale = require_colorscale();
+          var endPlus = require_end_plus();
+          module2.exports = function makeColorMap(trace) {
+            var contours = trace.contours;
+            var start = contours.start;
+            var end = endPlus(contours);
+            var cs = contours.size || 1;
+            var nc2 = Math.floor((end - start) / cs) + 1;
+            var extra = contours.coloring === "lines" ? 0 : 1;
+            var cOpts = Colorscale.extractOpts(trace);
+            if (!isFinite(cs)) {
+              cs = 1;
+              nc2 = 1;
+            }
+            var scl = cOpts.reversescale ? Colorscale.flipScale(cOpts.colorscale) : cOpts.colorscale;
+            var len2 = scl.length;
+            var domain = new Array(len2);
+            var range = new Array(len2);
+            var si2, i2;
+            var zmin0 = cOpts.min;
+            var zmax0 = cOpts.max;
+            if (contours.coloring === "heatmap") {
+              for (i2 = 0; i2 < len2; i2++) {
+                si2 = scl[i2];
+                domain[i2] = si2[0] * (zmax0 - zmin0) + zmin0;
+                range[i2] = si2[1];
+              }
+              var zRange = d3.extent([
+                zmin0,
+                zmax0,
+                contours.start,
+                contours.start + cs * (nc2 - 1)
+              ]);
+              var zmin = zRange[zmin0 < zmax0 ? 0 : 1];
+              var zmax = zRange[zmin0 < zmax0 ? 1 : 0];
+              if (zmin !== zmin0) {
+                domain.splice(0, 0, zmin);
+                range.splice(0, 0, range[0]);
+              }
+              if (zmax !== zmax0) {
+                domain.push(zmax);
+                range.push(range[range.length - 1]);
+              }
+            } else {
+              var zRangeInput = trace._input && (typeof trace._input.zmin === "number" && typeof trace._input.zmax === "number");
+              if (zRangeInput && (start <= zmin0 || end >= zmax0)) {
+                if (start <= zmin0) start = zmin0;
+                if (end >= zmax0) end = zmax0;
+                nc2 = Math.floor((end - start) / cs) + 1;
+                extra = 0;
+              }
+              for (i2 = 0; i2 < len2; i2++) {
+                si2 = scl[i2];
+                domain[i2] = (si2[0] * (nc2 + extra - 1) - extra / 2) * cs + start;
+                range[i2] = si2[1];
+              }
+              if (zRangeInput || trace.autocontour) {
+                if (domain[0] > zmin0) {
+                  domain.unshift(zmin0);
+                  range.unshift(range[0]);
+                }
+                if (domain[domain.length - 1] < zmax0) {
+                  domain.push(zmax0);
+                  range.push(range[range.length - 1]);
+                }
+              }
+            }
+            return Colorscale.makeColorScaleFunc(
+              { domain, range },
+              { noNumericCheck: true }
+            );
+          };
+        }
+      });
+      var require_style7 = __commonJS({
+        "src/traces/contour/style.js"(exports, module2) {
+          var d3 = require_d3();
+          var Drawing = require_drawing();
+          var heatmapStyle = require_style6();
+          var makeColorMap = require_make_color_map();
+          module2.exports = function style(gd2) {
+            var contours = d3.select(gd2).selectAll("g.contour");
+            contours.style("opacity", function(d2) {
+              return d2[0].trace.opacity;
+            });
+            contours.each(function(d2) {
+              var c2 = d3.select(this);
+              var trace = d2[0].trace;
+              var contours2 = trace.contours;
+              var line = trace.line;
+              var cs = contours2.size || 1;
+              var start = contours2.start;
+              var isConstraintType = contours2.type === "constraint";
+              var colorLines = !isConstraintType && contours2.coloring === "lines";
+              var colorFills = !isConstraintType && contours2.coloring === "fill";
+              var colorMap = colorLines || colorFills ? makeColorMap(trace) : null;
+              c2.selectAll("g.contourlevel").each(function(d22) {
+                d3.select(this).selectAll("path").call(
+                  Drawing.lineGroupStyle,
+                  line.width,
+                  colorLines ? colorMap(d22.level) : line.color,
+                  line.dash
+                );
+              });
+              var labelFont = contours2.labelfont;
+              c2.selectAll("g.contourlabels text").each(function(d22) {
+                Drawing.font(d3.select(this), {
+                  weight: labelFont.weight,
+                  style: labelFont.style,
+                  variant: labelFont.variant,
+                  textcase: labelFont.textcase,
+                  lineposition: labelFont.lineposition,
+                  shadow: labelFont.shadow,
+                  family: labelFont.family,
+                  size: labelFont.size,
+                  color: labelFont.color || (colorLines ? colorMap(d22.level) : line.color)
+                });
+              });
+              if (isConstraintType) {
+                c2.selectAll("g.contourfill path").style("fill", trace.fillcolor);
+              } else if (colorFills) {
+                var firstFill;
+                c2.selectAll("g.contourfill path").style("fill", function(d22) {
+                  if (firstFill === void 0) firstFill = d22.level;
+                  return colorMap(d22.level + 0.5 * cs);
+                });
+                if (firstFill === void 0) firstFill = start;
+                c2.selectAll("g.contourbg path").style("fill", colorMap(firstFill - 0.5 * cs));
+              }
+            });
+            heatmapStyle(gd2);
+          };
+        }
+      });
+      var require_colorbar3 = __commonJS({
+        "src/traces/contour/colorbar.js"(exports, module2) {
+          var Colorscale = require_colorscale();
+          var makeColorMap = require_make_color_map();
+          var endPlus = require_end_plus();
+          function calc(gd2, trace, opts) {
+            var contours = trace.contours;
+            var line = trace.line;
+            var cs = contours.size || 1;
+            var coloring = contours.coloring;
+            var colorMap = makeColorMap(trace, { isColorbar: true });
+            if (coloring === "heatmap") {
+              var cOpts = Colorscale.extractOpts(trace);
+              opts._fillgradient = cOpts.reversescale ? Colorscale.flipScale(cOpts.colorscale) : cOpts.colorscale;
+              opts._zrange = [cOpts.min, cOpts.max];
+            } else if (coloring === "fill") {
+              opts._fillcolor = colorMap;
+            }
+            opts._line = {
+              color: coloring === "lines" ? colorMap : line.color,
+              width: contours.showlines !== false ? line.width : 0,
+              dash: line.dash
+            };
+            opts._levels = {
+              start: contours.start,
+              end: endPlus(contours),
+              size: cs
+            };
+          }
+          module2.exports = {
+            min: "zmin",
+            max: "zmax",
+            calc
+          };
+        }
+      });
+      var require_hover8 = __commonJS({
+        "src/traces/contour/hover.js"(exports, module2) {
+          var Color2 = require_color();
+          var heatmapHoverPoints = require_hover5();
+          module2.exports = function hoverPoints(pointData, xval, yval, hovermode, opts) {
+            if (!opts) opts = {};
+            opts.isContour = true;
+            var hoverData = heatmapHoverPoints(pointData, xval, yval, hovermode, opts);
+            if (hoverData) {
+              hoverData.forEach(function(hoverPt) {
+                var trace = hoverPt.trace;
+                if (trace.contours.type === "constraint") {
+                  if (trace.fillcolor && Color2.opacity(trace.fillcolor)) {
+                    hoverPt.color = Color2.addOpacity(trace.fillcolor, 1);
+                  } else if (trace.contours.showlines && Color2.opacity(trace.line.color)) {
+                    hoverPt.color = Color2.addOpacity(trace.line.color, 1);
+                  }
+                }
+              });
+            }
+            return hoverData;
+          };
+        }
+      });
+      var require_histogram2dcontour = __commonJS({
+        "src/traces/histogram2dcontour/index.js"(exports, module2) {
+          module2.exports = {
+            attributes: require_attributes29(),
+            supplyDefaults: require_defaults24(),
+            crossTraceDefaults: require_cross_trace_defaults3(),
+            calc: require_calc10(),
+            plot: require_plot6().plot,
+            layerName: "contourlayer",
+            style: require_style7(),
+            colorbar: require_colorbar3(),
+            hoverPoints: require_hover8(),
+            moduleType: "trace",
+            name: "histogram2dcontour",
+            basePlotModule: require_cartesian(),
+            categories: ["cartesian", "svg", "2dMap", "contour", "histogram", "showLegend"],
+            meta: {}
+          };
+        }
+      });
+      var require_histogram2dcontour2 = __commonJS({
+        "lib/histogram2dcontour.js"(exports, module2) {
+          module2.exports = require_histogram2dcontour();
+        }
+      });
+      var require_constraint_defaults = __commonJS({
+        "src/traces/contour/constraint_defaults.js"(exports, module2) {
+          var isNumeric = require_fast_isnumeric();
+          var handleLabelDefaults = require_label_defaults2();
+          var Color2 = require_color();
+          var addOpacity = Color2.addOpacity;
+          var opacity = Color2.opacity;
+          var filterOps = require_filter_ops();
+          var isArrayOrTypedArray = require_lib().isArrayOrTypedArray;
+          var CONSTRAINT_REDUCTION = filterOps.CONSTRAINT_REDUCTION;
+          var COMPARISON_OPS2 = filterOps.COMPARISON_OPS2;
+          module2.exports = function handleConstraintDefaults(traceIn, traceOut, coerce, layout, defaultColor, opts) {
+            var contours = traceOut.contours;
+            var showLines, lineColor, fillColor;
+            var operation = coerce("contours.operation");
+            contours._operation = CONSTRAINT_REDUCTION[operation];
+            handleConstraintValueDefaults(coerce, contours);
+            if (operation === "=") {
+              showLines = contours.showlines = true;
+            } else {
+              showLines = coerce("contours.showlines");
+              fillColor = coerce("fillcolor", addOpacity(
+                (traceIn.line || {}).color || defaultColor,
+                0.5
+              ));
+            }
+            if (showLines) {
+              var lineDfltColor = fillColor && opacity(fillColor) ? addOpacity(traceOut.fillcolor, 1) : defaultColor;
+              lineColor = coerce("line.color", lineDfltColor);
+              coerce("line.width", 2);
+              coerce("line.dash");
+            }
+            coerce("line.smoothing");
+            handleLabelDefaults(coerce, layout, lineColor, opts);
+          };
+          function handleConstraintValueDefaults(coerce, contours) {
+            var zvalue;
+            if (COMPARISON_OPS2.indexOf(contours.operation) === -1) {
+              coerce("contours.value", [0, 1]);
+              if (!isArrayOrTypedArray(contours.value)) {
+                if (isNumeric(contours.value)) {
+                  zvalue = parseFloat(contours.value);
+                  contours.value = [zvalue, zvalue + 1];
+                }
+              } else if (contours.value.length > 2) {
+                contours.value = contours.value.slice(2);
+              } else if (contours.length === 0) {
+                contours.value = [0, 1];
+              } else if (contours.length < 2) {
+                zvalue = parseFloat(contours.value[0]);
+                contours.value = [zvalue, zvalue + 1];
+              } else {
+                contours.value = [
+                  parseFloat(contours.value[0]),
+                  parseFloat(contours.value[1])
+                ];
+              }
+            } else {
+              coerce("contours.value", 0);
+              if (!isNumeric(contours.value)) {
+                if (isArrayOrTypedArray(contours.value)) {
+                  contours.value = parseFloat(contours.value[0]);
+                } else {
+                  contours.value = 0;
+                }
+              }
+            }
+          }
+        }
+      });
+      var require_defaults25 = __commonJS({
+        "src/traces/contour/defaults.js"(exports, module2) {
+          var Lib = require_lib();
+          var handleXYZDefaults = require_xyz_defaults();
+          var handlePeriodDefaults = require_period_defaults();
+          var handleConstraintDefaults = require_constraint_defaults();
+          var handleContoursDefaults = require_contours_defaults();
+          var handleStyleDefaults = require_style_defaults3();
+          var handleHeatmapLabelDefaults = require_label_defaults();
+          var attributes = require_attributes28();
+          module2.exports = function supplyDefaults(traceIn, traceOut, defaultColor, layout) {
+            function coerce(attr, dflt) {
+              return Lib.coerce(traceIn, traceOut, attributes, attr, dflt);
+            }
+            function coerce2(attr) {
+              return Lib.coerce2(traceIn, traceOut, attributes, attr);
+            }
+            var len2 = handleXYZDefaults(traceIn, traceOut, coerce, layout);
+            if (!len2) {
+              traceOut.visible = false;
+              return;
+            }
+            handlePeriodDefaults(traceIn, traceOut, layout, coerce);
+            coerce("xhoverformat");
+            coerce("yhoverformat");
+            coerce("text");
+            coerce("hovertext");
+            coerce("hoverongaps");
+            coerce("hovertemplate");
+            coerce("hovertemplatefallback");
+            var isConstraint = coerce("contours.type") === "constraint";
+            coerce("connectgaps", Lib.isArray1D(traceOut.z));
+            if (isConstraint) {
+              handleConstraintDefaults(traceIn, traceOut, coerce, layout, defaultColor);
+            } else {
+              handleContoursDefaults(traceIn, traceOut, coerce, coerce2);
+              handleStyleDefaults(traceIn, traceOut, coerce, layout);
+            }
+            if (traceOut.contours && traceOut.contours.coloring === "heatmap") {
+              handleHeatmapLabelDefaults(coerce, layout);
+            }
+            coerce("zorder");
+          };
+        }
+      });
+      var require_contour = __commonJS({
+        "src/traces/contour/index.js"(exports, module2) {
+          module2.exports = {
+            attributes: require_attributes28(),
+            supplyDefaults: require_defaults25(),
+            calc: require_calc10(),
+            plot: require_plot6().plot,
+            style: require_style7(),
+            colorbar: require_colorbar3(),
+            hoverPoints: require_hover8(),
+            moduleType: "trace",
+            name: "contour",
+            basePlotModule: require_cartesian(),
+            categories: ["cartesian", "svg", "2dMap", "contour", "showLegend"],
+            meta: {}
+          };
+        }
+      });
+      var require_contour2 = __commonJS({
+        "lib/contour.js"(exports, module2) {
+          module2.exports = require_contour();
+        }
+      });
+      var require_attributes30 = __commonJS({
+        "src/traces/scatterternary/attributes.js"(exports, module2) {
+          var { hovertemplateAttrs, texttemplateAttrs, templatefallbackAttrs } = require_template_attributes();
+          var makeFillcolorAttr = require_fillcolor_attribute();
+          var scatterAttrs = require_attributes12();
+          var baseAttrs = require_attributes2();
+          var colorScaleAttrs = require_attributes8();
+          var dash = require_attributes4().dash;
+          var extendFlat = require_extend().extendFlat;
+          var scatterMarkerAttrs = scatterAttrs.marker;
+          var scatterLineAttrs = scatterAttrs.line;
+          var scatterMarkerLineAttrs = scatterMarkerAttrs.line;
+          module2.exports = {
+            a: {
+              valType: "data_array",
+              editType: "calc"
+            },
+            b: {
+              valType: "data_array",
+              editType: "calc"
+            },
+            c: {
+              valType: "data_array",
+              editType: "calc"
+            },
+            sum: {
+              valType: "number",
+              dflt: 0,
+              min: 0,
+              editType: "calc"
+            },
+            mode: extendFlat({}, scatterAttrs.mode, { dflt: "markers" }),
+            text: extendFlat({}, scatterAttrs.text, {}),
+            texttemplate: texttemplateAttrs({ editType: "plot" }, { keys: ["a", "b", "c", "text"] }),
+            texttemplatefallback: templatefallbackAttrs({ editType: "plot" }),
+            hovertext: extendFlat({}, scatterAttrs.hovertext, {}),
+            line: {
+              color: scatterLineAttrs.color,
+              width: scatterLineAttrs.width,
+              dash,
+              backoff: scatterLineAttrs.backoff,
+              shape: extendFlat({}, scatterLineAttrs.shape, { values: ["linear", "spline"] }),
+              smoothing: scatterLineAttrs.smoothing,
+              editType: "calc"
+            },
+            connectgaps: scatterAttrs.connectgaps,
+            cliponaxis: scatterAttrs.cliponaxis,
+            fill: extendFlat({}, scatterAttrs.fill, {
+              values: ["none", "toself", "tonext"],
+              dflt: "none"
+            }),
+            fillcolor: makeFillcolorAttr(),
+            marker: extendFlat(
+              {
+                symbol: scatterMarkerAttrs.symbol,
+                opacity: scatterMarkerAttrs.opacity,
+                angle: scatterMarkerAttrs.angle,
+                angleref: scatterMarkerAttrs.angleref,
+                standoff: scatterMarkerAttrs.standoff,
+                maxdisplayed: scatterMarkerAttrs.maxdisplayed,
+                size: scatterMarkerAttrs.size,
+                sizeref: scatterMarkerAttrs.sizeref,
+                sizemin: scatterMarkerAttrs.sizemin,
+                sizemode: scatterMarkerAttrs.sizemode,
+                line: extendFlat(
+                  {
+                    width: scatterMarkerLineAttrs.width,
+                    dash: scatterMarkerLineAttrs.dash,
+                    editType: "calc"
+                  },
+                  colorScaleAttrs("marker.line")
+                ),
+                gradient: scatterMarkerAttrs.gradient,
+                editType: "calc"
+              },
+              colorScaleAttrs("marker")
+            ),
+            textfont: scatterAttrs.textfont,
+            textposition: scatterAttrs.textposition,
+            selected: scatterAttrs.selected,
+            unselected: scatterAttrs.unselected,
+            hoverinfo: extendFlat({}, baseAttrs.hoverinfo, {
+              flags: ["a", "b", "c", "text", "name"]
+            }),
+            hoveron: scatterAttrs.hoveron,
+            hovertemplate: hovertemplateAttrs(),
+            hovertemplatefallback: templatefallbackAttrs()
+          };
+        }
+      });
+      var require_defaults26 = __commonJS({
+        "src/traces/scatterternary/defaults.js"(exports, module2) {
+          var Lib = require_lib();
+          var constants = require_constants8();
+          var subTypes = require_subtypes();
+          var handleMarkerDefaults = require_marker_defaults();
+          var handleLineDefaults = require_line_defaults();
+          var handleLineShapeDefaults = require_line_shape_defaults();
+          var handleTextDefaults = require_text_defaults();
+          var handleFillColorDefaults = require_fillcolor_defaults();
+          var attributes = require_attributes30();
+          module2.exports = function supplyDefaults(traceIn, traceOut, defaultColor, layout) {
+            function coerce(attr, dflt) {
+              return Lib.coerce(traceIn, traceOut, attributes, attr, dflt);
+            }
+            var a2 = coerce("a");
+            var b2 = coerce("b");
+            var c2 = coerce("c");
+            var len2;
+            if (a2) {
+              len2 = a2.length;
+              if (b2) {
+                len2 = Math.min(len2, b2.length);
+                if (c2) len2 = Math.min(len2, c2.length);
+              } else if (c2) len2 = Math.min(len2, c2.length);
+              else len2 = 0;
+            } else if (b2 && c2) {
+              len2 = Math.min(b2.length, c2.length);
+            }
+            if (!len2) {
+              traceOut.visible = false;
+              return;
+            }
+            traceOut._length = len2;
+            coerce("sum");
+            coerce("text");
+            coerce("hovertext");
+            if (traceOut.hoveron !== "fills") {
+              coerce("hovertemplate");
+              coerce("hovertemplatefallback");
+            }
+            var defaultMode = len2 < constants.PTS_LINESONLY ? "lines+markers" : "lines";
+            coerce("mode", defaultMode);
+            if (subTypes.hasMarkers(traceOut)) {
+              handleMarkerDefaults(traceIn, traceOut, defaultColor, layout, coerce, { gradient: true });
+            }
+            if (subTypes.hasLines(traceOut)) {
+              handleLineDefaults(traceIn, traceOut, defaultColor, layout, coerce, { backoff: true });
+              handleLineShapeDefaults(traceIn, traceOut, coerce);
+              coerce("connectgaps");
+            }
+            if (subTypes.hasText(traceOut)) {
+              coerce("texttemplate");
+              coerce("texttemplatefallback");
+              handleTextDefaults(traceIn, traceOut, layout, coerce);
+            }
+            var dfltHoverOn = [];
+            if (subTypes.hasMarkers(traceOut) || subTypes.hasText(traceOut)) {
+              coerce("cliponaxis");
+              coerce("marker.maxdisplayed");
+              dfltHoverOn.push("points");
+            }
+            coerce("fill");
+            if (traceOut.fill !== "none") {
+              handleFillColorDefaults(traceIn, traceOut, defaultColor, coerce);
+              if (!subTypes.hasLines(traceOut)) handleLineShapeDefaults(traceIn, traceOut, coerce);
+            }
+            if (traceOut.fill === "tonext" || traceOut.fill === "toself") {
+              dfltHoverOn.push("fills");
+            }
+            coerce("hoveron", dfltHoverOn.join("+") || "points");
+            Lib.coerceSelectionMarkerOpacity(traceOut, coerce);
+          };
+        }
+      });
+      var require_format_labels2 = __commonJS({
+        "src/traces/scatterternary/format_labels.js"(exports, module2) {
+          var Axes = require_axes();
+          module2.exports = function formatLabels(cdi, trace, fullLayout) {
+            var labels = {};
+            var subplot = fullLayout[trace.subplot]._subplot;
+            labels.aLabel = Axes.tickText(subplot.aaxis, cdi.a, true).text;
+            labels.bLabel = Axes.tickText(subplot.baxis, cdi.b, true).text;
+            labels.cLabel = Axes.tickText(subplot.caxis, cdi.c, true).text;
+            return labels;
+          };
+        }
+      });
+      var require_calc11 = __commonJS({
+        "src/traces/scatterternary/calc.js"(exports, module2) {
+          var isNumeric = require_fast_isnumeric();
+          var calcColorscale = require_colorscale_calc();
+          var arraysToCalcdata = require_arrays_to_calcdata();
+          var calcSelection = require_calc_selection();
+          var calcMarkerSize = require_calc3().calcMarkerSize;
+          var dataArrays = ["a", "b", "c"];
+          var arraysToFill = { a: ["b", "c"], b: ["a", "c"], c: ["a", "b"] };
+          module2.exports = function calc(gd2, trace) {
+            var ternary = gd2._fullLayout[trace.subplot];
+            var displaySum = ternary.sum;
+            var normSum = trace.sum || displaySum;
+            var arrays = { a: trace.a, b: trace.b, c: trace.c };
+            var ids = trace.ids;
+            var i2, j2, dataArray, newArray, fillArray1, fillArray2;
+            for (i2 = 0; i2 < dataArrays.length; i2++) {
+              dataArray = dataArrays[i2];
+              if (arrays[dataArray]) continue;
+              fillArray1 = arrays[arraysToFill[dataArray][0]];
+              fillArray2 = arrays[arraysToFill[dataArray][1]];
+              newArray = new Array(fillArray1.length);
+              for (j2 = 0; j2 < fillArray1.length; j2++) {
+                newArray[j2] = normSum - fillArray1[j2] - fillArray2[j2];
+              }
+              arrays[dataArray] = newArray;
+            }
+            var serieslen = trace._length;
+            var cd2 = new Array(serieslen);
+            var a2, b2, c2, norm, x2, y2;
+            for (i2 = 0; i2 < serieslen; i2++) {
+              a2 = arrays.a[i2];
+              b2 = arrays.b[i2];
+              c2 = arrays.c[i2];
+              if (isNumeric(a2) && isNumeric(b2) && isNumeric(c2)) {
+                a2 = +a2;
+                b2 = +b2;
+                c2 = +c2;
+                norm = displaySum / (a2 + b2 + c2);
+                if (norm !== 1) {
+                  a2 *= norm;
+                  b2 *= norm;
+                  c2 *= norm;
+                }
+                y2 = a2;
+                x2 = c2 - b2;
+                cd2[i2] = { x: x2, y: y2, a: a2, b: b2, c: c2 };
+                if (ids) {
+                  cd2[i2].id = ids[i2];
+                }
+              } else cd2[i2] = { x: false, y: false };
+            }
+            calcMarkerSize(trace, serieslen);
+            calcColorscale(gd2, trace);
+            arraysToCalcdata(cd2, trace);
+            calcSelection(cd2, trace);
+            return cd2;
+          };
+        }
+      });
+      var require_plot7 = __commonJS({
+        "src/traces/scatterternary/plot.js"(exports, module2) {
+          var scatterPlot = require_plot();
+          module2.exports = function plot(gd2, ternary, moduleCalcData) {
+            var plotContainer = ternary.plotContainer;
+            plotContainer.select(".scatterlayer").selectAll("*").remove();
+            var xa = ternary.xaxis;
+            var ya2 = ternary.yaxis;
+            var plotinfo = {
+              xaxis: xa,
+              yaxis: ya2,
+              plot: plotContainer,
+              layerClipId: ternary._hasClipOnAxisFalse ? ternary.clipIdRelative : null
+            };
+            var scatterLayer = ternary.layers.frontplot.select("g.scatterlayer");
+            for (var i2 = 0; i2 < moduleCalcData.length; i2++) {
+              var cdi = moduleCalcData[i2];
+              if (cdi.length) {
+                cdi[0].trace._xA = xa;
+                cdi[0].trace._yA = ya2;
+              }
+            }
+            scatterPlot(gd2, plotinfo, moduleCalcData, scatterLayer);
+          };
+        }
+      });
+      var require_hover9 = __commonJS({
+        "src/traces/scatterternary/hover.js"(exports, module2) {
+          var scatterHover = require_hover2();
+          module2.exports = function hoverPoints(pointData, xval, yval, hovermode) {
+            var scatterPointData = scatterHover(pointData, xval, yval, hovermode);
+            if (!scatterPointData || scatterPointData[0].index === false) return;
+            var newPointData = scatterPointData[0];
+            if (newPointData.index === void 0) {
+              var yFracUp = 1 - newPointData.y0 / pointData.ya._length;
+              var xLen = pointData.xa._length;
+              var xMin = xLen * yFracUp / 2;
+              var xMax = xLen - xMin;
+              newPointData.x0 = Math.max(Math.min(newPointData.x0, xMax), xMin);
+              newPointData.x1 = Math.max(Math.min(newPointData.x1, xMax), xMin);
+              return scatterPointData;
+            }
+            var cdi = newPointData.cd[newPointData.index];
+            var trace = newPointData.trace;
+            var subplot = newPointData.subplot;
+            newPointData.a = cdi.a;
+            newPointData.b = cdi.b;
+            newPointData.c = cdi.c;
+            newPointData.xLabelVal = void 0;
+            newPointData.yLabelVal = void 0;
+            var fullLayout = {};
+            fullLayout[trace.subplot] = { _subplot: subplot };
+            var labels = trace._module.formatLabels(cdi, trace, fullLayout);
+            newPointData.aLabel = labels.aLabel;
+            newPointData.bLabel = labels.bLabel;
+            newPointData.cLabel = labels.cLabel;
+            var hoverinfo = cdi.hi || trace.hoverinfo;
+            var text = [];
+            function textPart(ax, val) {
+              text.push(ax._hovertitle + ": " + val);
+            }
+            if (!trace.hovertemplate) {
+              var parts = hoverinfo.split("+");
+              if (parts.indexOf("all") !== -1) parts = ["a", "b", "c"];
+              if (parts.indexOf("a") !== -1) textPart(subplot.aaxis, newPointData.aLabel);
+              if (parts.indexOf("b") !== -1) textPart(subplot.baxis, newPointData.bLabel);
+              if (parts.indexOf("c") !== -1) textPart(subplot.caxis, newPointData.cLabel);
+            }
+            newPointData.extraText = text.join("<br>");
+            newPointData.hovertemplate = trace.hovertemplate;
+            return scatterPointData;
+          };
+        }
+      });
+      var require_event_data4 = __commonJS({
+        "src/traces/scatterternary/event_data.js"(exports, module2) {
+          module2.exports = function eventData(out, pt2, trace, cd2, pointNumber) {
+            if (pt2.xa) out.xaxis = pt2.xa;
+            if (pt2.ya) out.yaxis = pt2.ya;
+            if (cd2[pointNumber]) {
+              var cdi = cd2[pointNumber];
+              out.a = cdi.a;
+              out.b = cdi.b;
+              out.c = cdi.c;
+            } else {
+              out.a = pt2.a;
+              out.b = pt2.b;
+              out.c = pt2.c;
+            }
+            return out;
+          };
+        }
+      });
+      var require_ternary = __commonJS({
+        "src/plots/ternary/ternary.js"(exports, module2) {
+          var d3 = require_d3();
+          var tinycolor = require_tinycolor();
+          var Registry = require_registry();
+          var Lib = require_lib();
+          var strTranslate = Lib.strTranslate;
+          var _2 = Lib._;
+          var Color2 = require_color();
+          var Drawing = require_drawing();
+          var setConvert = require_set_convert();
+          var extendFlat = require_extend().extendFlat;
+          var Plots = require_plots();
+          var Axes = require_axes();
+          var dragElement = require_dragelement();
+          var Fx = require_fx();
+          var dragHelpers = require_helpers5();
+          var freeMode = dragHelpers.freeMode;
+          var rectMode = dragHelpers.rectMode;
+          var Titles = require_titles();
+          var prepSelect = require_selections().prepSelect;
+          var selectOnClick = require_selections().selectOnClick;
+          var clearOutline = require_selections().clearOutline;
+          var clearSelectionsCache = require_selections().clearSelectionsCache;
+          var constants = require_constants2();
+          function Ternary(options, fullLayout) {
+            this.id = options.id;
+            this.graphDiv = options.graphDiv;
+            this.init(fullLayout);
+            this.makeFramework(fullLayout);
+            this.updateFx(fullLayout);
+            this.aTickLayout = null;
+            this.bTickLayout = null;
+            this.cTickLayout = null;
+          }
+          module2.exports = Ternary;
+          var proto = Ternary.prototype;
+          proto.init = function(fullLayout) {
+            this.container = fullLayout._ternarylayer;
+            this.defs = fullLayout._defs;
+            this.layoutId = fullLayout._uid;
+            this.traceHash = {};
+            this.layers = {};
+          };
+          proto.plot = function(ternaryCalcData, fullLayout) {
+            var _this = this;
+            var ternaryLayout = fullLayout[_this.id];
+            var graphSize = fullLayout._size;
+            _this._hasClipOnAxisFalse = false;
+            for (var i2 = 0; i2 < ternaryCalcData.length; i2++) {
+              var trace = ternaryCalcData[i2][0].trace;
+              if (trace.cliponaxis === false) {
+                _this._hasClipOnAxisFalse = true;
+                break;
+              }
+            }
+            _this.updateLayers(ternaryLayout);
+            _this.adjustLayout(ternaryLayout, graphSize);
+            Plots.generalUpdatePerTraceModule(_this.graphDiv, _this, ternaryCalcData, ternaryLayout);
+            _this.layers.plotbg.select("path").call(Color2.fill, ternaryLayout.bgcolor);
+          };
+          proto.makeFramework = function(fullLayout) {
+            var _this = this;
+            var gd2 = _this.graphDiv;
+            var ternaryLayout = fullLayout[_this.id];
+            var clipId = _this.clipId = "clip" + _this.layoutId + _this.id;
+            var clipIdRelative = _this.clipIdRelative = "clip-relative" + _this.layoutId + _this.id;
+            _this.clipDef = Lib.ensureSingleById(fullLayout._clips, "clipPath", clipId, function(s2) {
+              s2.append("path").attr("d", "M0,0Z");
+            });
+            _this.clipDefRelative = Lib.ensureSingleById(fullLayout._clips, "clipPath", clipIdRelative, function(s2) {
+              s2.append("path").attr("d", "M0,0Z");
+            });
+            _this.plotContainer = Lib.ensureSingle(_this.container, "g", _this.id);
+            _this.updateLayers(ternaryLayout);
+            Drawing.setClipUrl(_this.layers.backplot, clipId, gd2);
+            Drawing.setClipUrl(_this.layers.grids, clipId, gd2);
+          };
+          proto.updateFx = function(fullLayout) {
+            fullLayout._ternarylayer.selectAll("g.toplevel").style("cursor", fullLayout.dragmode === "pan" ? "move" : "crosshair");
+          };
+          proto.updateLayers = function(ternaryLayout) {
+            var _this = this;
+            var layers = _this.layers;
+            var plotLayers = ["draglayer", "plotbg", "backplot", "grids"];
+            if (ternaryLayout.aaxis.layer === "below traces") {
+              plotLayers.push("aaxis", "aline");
+            }
+            if (ternaryLayout.baxis.layer === "below traces") {
+              plotLayers.push("baxis", "bline");
+            }
+            if (ternaryLayout.caxis.layer === "below traces") {
+              plotLayers.push("caxis", "cline");
+            }
+            plotLayers.push("frontplot");
+            if (ternaryLayout.aaxis.layer === "above traces") {
+              plotLayers.push("aaxis", "aline");
+            }
+            if (ternaryLayout.baxis.layer === "above traces") {
+              plotLayers.push("baxis", "bline");
+            }
+            if (ternaryLayout.caxis.layer === "above traces") {
+              plotLayers.push("caxis", "cline");
+            }
+            var toplevel = _this.plotContainer.selectAll("g.toplevel").data(plotLayers, String);
+            var grids = ["agrid", "bgrid", "cgrid"];
+            toplevel.enter().append("g").attr("class", function(d2) {
+              return "toplevel " + d2;
+            }).each(function(d2) {
+              var s2 = d3.select(this);
+              layers[d2] = s2;
+              if (d2 === "frontplot") {
+                s2.append("g").classed("scatterlayer", true);
+              } else if (d2 === "backplot") {
+                s2.append("g").classed("maplayer", true);
+              } else if (d2 === "plotbg") {
+                s2.append("path").attr("d", "M0,0Z");
+              } else if (d2 === "aline" || d2 === "bline" || d2 === "cline") {
+                s2.append("path");
+              } else if (d2 === "grids") {
+                grids.forEach(function(d22) {
+                  layers[d22] = s2.append("g").classed("grid " + d22, true);
+                });
+              }
+            });
+            toplevel.order();
+          };
+          var whRatio = Math.sqrt(4 / 3);
+          proto.adjustLayout = function(ternaryLayout, graphSize) {
+            var _this = this;
+            var domain = ternaryLayout.domain;
+            var xDomainCenter = (domain.x[0] + domain.x[1]) / 2;
+            var yDomainCenter = (domain.y[0] + domain.y[1]) / 2;
+            var xDomain = domain.x[1] - domain.x[0];
+            var yDomain = domain.y[1] - domain.y[0];
+            var wmax = xDomain * graphSize.w;
+            var hmax = yDomain * graphSize.h;
+            var sum = ternaryLayout.sum;
+            var amin = ternaryLayout.aaxis.min;
+            var bmin = ternaryLayout.baxis.min;
+            var cmin = ternaryLayout.caxis.min;
+            var x0, y0, w2, h2, xDomainFinal, yDomainFinal;
+            if (wmax > whRatio * hmax) {
+              h2 = hmax;
+              w2 = h2 * whRatio;
+            } else {
+              w2 = wmax;
+              h2 = w2 / whRatio;
+            }
+            xDomainFinal = xDomain * w2 / wmax;
+            yDomainFinal = yDomain * h2 / hmax;
+            x0 = graphSize.l + graphSize.w * xDomainCenter - w2 / 2;
+            y0 = graphSize.t + graphSize.h * (1 - yDomainCenter) - h2 / 2;
+            _this.x0 = x0;
+            _this.y0 = y0;
+            _this.w = w2;
+            _this.h = h2;
+            _this.sum = sum;
+            _this.xaxis = {
+              type: "linear",
+              range: [amin + 2 * cmin - sum, sum - amin - 2 * bmin],
+              domain: [
+                xDomainCenter - xDomainFinal / 2,
+                xDomainCenter + xDomainFinal / 2
+              ],
+              _id: "x"
+            };
+            setConvert(_this.xaxis, _this.graphDiv._fullLayout);
+            _this.xaxis.setScale();
+            _this.xaxis.isPtWithinRange = function(d2) {
+              return d2.a >= _this.aaxis.range[0] && d2.a <= _this.aaxis.range[1] && d2.b >= _this.baxis.range[1] && d2.b <= _this.baxis.range[0] && d2.c >= _this.caxis.range[1] && d2.c <= _this.caxis.range[0];
+            };
+            _this.yaxis = {
+              type: "linear",
+              range: [amin, sum - bmin - cmin],
+              domain: [
+                yDomainCenter - yDomainFinal / 2,
+                yDomainCenter + yDomainFinal / 2
+              ],
+              _id: "y"
+            };
+            setConvert(_this.yaxis, _this.graphDiv._fullLayout);
+            _this.yaxis.setScale();
+            _this.yaxis.isPtWithinRange = function() {
+              return true;
+            };
+            var yDomain0 = _this.yaxis.domain[0];
+            var aaxis = _this.aaxis = extendFlat({}, ternaryLayout.aaxis, {
+              range: [amin, sum - bmin - cmin],
+              side: "left",
+              // tickangle = 'auto' means 0 anyway for a y axis, need to coerce to 0 here
+              // so we can shift by 30.
+              tickangle: (+ternaryLayout.aaxis.tickangle || 0) - 30,
+              domain: [yDomain0, yDomain0 + yDomainFinal * whRatio],
+              anchor: "free",
+              position: 0,
+              _id: "y",
+              _length: w2
+            });
+            setConvert(aaxis, _this.graphDiv._fullLayout);
+            aaxis.setScale();
+            var baxis = _this.baxis = extendFlat({}, ternaryLayout.baxis, {
+              range: [sum - amin - cmin, bmin],
+              side: "bottom",
+              domain: _this.xaxis.domain,
+              anchor: "free",
+              position: 0,
+              _id: "x",
+              _length: w2
+            });
+            setConvert(baxis, _this.graphDiv._fullLayout);
+            baxis.setScale();
+            var caxis = _this.caxis = extendFlat({}, ternaryLayout.caxis, {
+              range: [sum - amin - bmin, cmin],
+              side: "right",
+              tickangle: (+ternaryLayout.caxis.tickangle || 0) + 30,
+              domain: [yDomain0, yDomain0 + yDomainFinal * whRatio],
+              anchor: "free",
+              position: 0,
+              _id: "y",
+              _length: w2
+            });
+            setConvert(caxis, _this.graphDiv._fullLayout);
+            caxis.setScale();
+            var triangleClip = "M" + x0 + "," + (y0 + h2) + "h" + w2 + "l-" + w2 / 2 + ",-" + h2 + "Z";
+            _this.clipDef.select("path").attr("d", triangleClip);
+            _this.layers.plotbg.select("path").attr("d", triangleClip);
+            var triangleClipRelative = "M0," + h2 + "h" + w2 + "l-" + w2 / 2 + ",-" + h2 + "Z";
+            _this.clipDefRelative.select("path").attr("d", triangleClipRelative);
+            var plotTransform = strTranslate(x0, y0);
+            _this.plotContainer.selectAll(".scatterlayer,.maplayer").attr("transform", plotTransform);
+            _this.clipDefRelative.select("path").attr("transform", null);
+            var bTransform = strTranslate(x0 - baxis._offset, y0 + h2);
+            _this.layers.baxis.attr("transform", bTransform);
+            _this.layers.bgrid.attr("transform", bTransform);
+            var aTransform = strTranslate(x0 + w2 / 2, y0) + "rotate(30)" + strTranslate(0, -aaxis._offset);
+            _this.layers.aaxis.attr("transform", aTransform);
+            _this.layers.agrid.attr("transform", aTransform);
+            var cTransform = strTranslate(x0 + w2 / 2, y0) + "rotate(-30)" + strTranslate(0, -caxis._offset);
+            _this.layers.caxis.attr("transform", cTransform);
+            _this.layers.cgrid.attr("transform", cTransform);
+            _this.drawAxes(true);
+            _this.layers.aline.select("path").attr("d", aaxis.showline ? "M" + x0 + "," + (y0 + h2) + "l" + w2 / 2 + ",-" + h2 : "M0,0").call(Color2.stroke, aaxis.linecolor || "#000").style("stroke-width", (aaxis.linewidth || 0) + "px");
+            _this.layers.bline.select("path").attr("d", baxis.showline ? "M" + x0 + "," + (y0 + h2) + "h" + w2 : "M0,0").call(Color2.stroke, baxis.linecolor || "#000").style("stroke-width", (baxis.linewidth || 0) + "px");
+            _this.layers.cline.select("path").attr("d", caxis.showline ? "M" + (x0 + w2 / 2) + "," + y0 + "l" + w2 / 2 + "," + h2 : "M0,0").call(Color2.stroke, caxis.linecolor || "#000").style("stroke-width", (caxis.linewidth || 0) + "px");
+            if (!_this.graphDiv._context.staticPlot) {
+              _this.initInteractions();
+            }
+            Drawing.setClipUrl(
+              _this.layers.frontplot,
+              _this._hasClipOnAxisFalse ? null : _this.clipId,
+              _this.graphDiv
+            );
+          };
+          proto.drawAxes = function(doTitles) {
+            var _this = this;
+            var gd2 = _this.graphDiv;
+            var titlesuffix = _this.id.slice(7) + "title";
+            var layers = _this.layers;
+            var aaxis = _this.aaxis;
+            var baxis = _this.baxis;
+            var caxis = _this.caxis;
+            _this.drawAx(aaxis);
+            _this.drawAx(baxis);
+            _this.drawAx(caxis);
+            if (doTitles) {
+              var apad = Math.max(
+                aaxis.showticklabels ? aaxis.tickfont.size / 2 : 0,
+                (caxis.showticklabels ? caxis.tickfont.size * 0.75 : 0) + (caxis.ticks === "outside" ? caxis.ticklen * 0.87 : 0)
+              );
+              var bpad = (baxis.showticklabels ? baxis.tickfont.size : 0) + (baxis.ticks === "outside" ? baxis.ticklen : 0) + 3;
+              layers["a-title"] = Titles.draw(gd2, "a" + titlesuffix, {
+                propContainer: aaxis,
+                propName: _this.id + ".aaxis.title.text",
+                placeholder: _2(gd2, "Click to enter Component A title"),
+                attributes: {
+                  x: _this.x0 + _this.w / 2,
+                  y: _this.y0 - aaxis.title.font.size / 3 - apad,
+                  "text-anchor": "middle"
+                }
+              });
+              layers["b-title"] = Titles.draw(gd2, "b" + titlesuffix, {
+                propContainer: baxis,
+                propName: _this.id + ".baxis.title.text",
+                placeholder: _2(gd2, "Click to enter Component B title"),
+                attributes: {
+                  x: _this.x0 - bpad,
+                  y: _this.y0 + _this.h + baxis.title.font.size * 0.83 + bpad,
+                  "text-anchor": "middle"
+                }
+              });
+              layers["c-title"] = Titles.draw(gd2, "c" + titlesuffix, {
+                propContainer: caxis,
+                propName: _this.id + ".caxis.title.text",
+                placeholder: _2(gd2, "Click to enter Component C title"),
+                attributes: {
+                  x: _this.x0 + _this.w + bpad,
+                  y: _this.y0 + _this.h + caxis.title.font.size * 0.83 + bpad,
+                  "text-anchor": "middle"
+                }
+              });
+            }
+          };
+          proto.drawAx = function(ax) {
+            var _this = this;
+            var gd2 = _this.graphDiv;
+            var axName = ax._name;
+            var axLetter = axName.charAt(0);
+            var axId = ax._id;
+            var axLayer = _this.layers[axName];
+            var counterAngle = 30;
+            var stashKey = axLetter + "tickLayout";
+            var newTickLayout = strTickLayout(ax);
+            if (_this[stashKey] !== newTickLayout) {
+              axLayer.selectAll("." + axId + "tick").remove();
+              _this[stashKey] = newTickLayout;
+            }
+            ax.setScale();
+            var vals = Axes.calcTicks(ax);
+            var valsClipped = Axes.clipEnds(ax, vals);
+            var transFn = Axes.makeTransTickFn(ax);
+            var tickSign = Axes.getTickSigns(ax)[2];
+            var caRad = Lib.deg2rad(counterAngle);
+            var pad = tickSign * (ax.linewidth || 1) / 2;
+            var len2 = tickSign * ax.ticklen;
+            var w2 = _this.w;
+            var h2 = _this.h;
+            var tickPath = axLetter === "b" ? "M0," + pad + "l" + Math.sin(caRad) * len2 + "," + Math.cos(caRad) * len2 : "M" + pad + ",0l" + Math.cos(caRad) * len2 + "," + -Math.sin(caRad) * len2;
+            var gridPath = {
+              a: "M0,0l" + h2 + ",-" + w2 / 2,
+              b: "M0,0l-" + w2 / 2 + ",-" + h2,
+              c: "M0,0l-" + h2 + "," + w2 / 2
+            }[axLetter];
+            Axes.drawTicks(gd2, ax, {
+              vals: ax.ticks === "inside" ? valsClipped : vals,
+              layer: axLayer,
+              path: tickPath,
+              transFn,
+              crisp: false
+            });
+            Axes.drawGrid(gd2, ax, {
+              vals: valsClipped,
+              layer: _this.layers[axLetter + "grid"],
+              path: gridPath,
+              transFn,
+              crisp: false
+            });
+            Axes.drawLabels(gd2, ax, {
+              vals,
+              layer: axLayer,
+              transFn,
+              labelFns: Axes.makeLabelFns(ax, 0, counterAngle)
+            });
+          };
+          function strTickLayout(axLayout) {
+            return axLayout.ticks + String(axLayout.ticklen) + String(axLayout.showticklabels);
+          }
+          var CLEN = constants.MINZOOM / 2 + 0.87;
+          var BLPATH = "m-0.87,.5h" + CLEN + "v3h-" + (CLEN + 5.2) + "l" + (CLEN / 2 + 2.6) + ",-" + (CLEN * 0.87 + 4.5) + "l2.6,1.5l-" + CLEN / 2 + "," + CLEN * 0.87 + "Z";
+          var BRPATH = "m0.87,.5h-" + CLEN + "v3h" + (CLEN + 5.2) + "l-" + (CLEN / 2 + 2.6) + ",-" + (CLEN * 0.87 + 4.5) + "l-2.6,1.5l" + CLEN / 2 + "," + CLEN * 0.87 + "Z";
+          var TOPPATH = "m0,1l" + CLEN / 2 + "," + CLEN * 0.87 + "l2.6,-1.5l-" + (CLEN / 2 + 2.6) + ",-" + (CLEN * 0.87 + 4.5) + "l-" + (CLEN / 2 + 2.6) + "," + (CLEN * 0.87 + 4.5) + "l2.6,1.5l" + CLEN / 2 + ",-" + CLEN * 0.87 + "Z";
+          var STARTMARKER = "m0.5,0.5h5v-2h-5v-5h-2v5h-5v2h5v5h2Z";
+          var SHOWZOOMOUTTIP = true;
+          proto.clearOutline = function() {
+            clearSelectionsCache(this.dragOptions);
+            clearOutline(this.dragOptions.gd);
+          };
+          proto.initInteractions = function() {
+            var _this = this;
+            var dragger = _this.layers.plotbg.select("path").node();
+            var gd2 = _this.graphDiv;
+            var zoomLayer = gd2._fullLayout._zoomlayer;
+            var scaleX2;
+            var scaleY2;
+            this.dragOptions = {
+              element: dragger,
+              gd: gd2,
+              plotinfo: {
+                id: _this.id,
+                domain: gd2._fullLayout[_this.id].domain,
+                xaxis: _this.xaxis,
+                yaxis: _this.yaxis
+              },
+              subplot: _this.id,
+              prepFn: function(e2, startX, startY) {
+                _this.dragOptions.xaxes = [_this.xaxis];
+                _this.dragOptions.yaxes = [_this.yaxis];
+                scaleX2 = gd2._fullLayout._invScaleX;
+                scaleY2 = gd2._fullLayout._invScaleY;
+                var dragModeNow = _this.dragOptions.dragmode = gd2._fullLayout.dragmode;
+                if (freeMode(dragModeNow)) _this.dragOptions.minDrag = 1;
+                else _this.dragOptions.minDrag = void 0;
+                if (dragModeNow === "zoom") {
+                  _this.dragOptions.moveFn = zoomMove;
+                  _this.dragOptions.clickFn = clickZoomPan;
+                  _this.dragOptions.doneFn = zoomDone;
+                  zoomPrep(e2, startX, startY);
+                } else if (dragModeNow === "pan") {
+                  _this.dragOptions.moveFn = plotDrag;
+                  _this.dragOptions.clickFn = clickZoomPan;
+                  _this.dragOptions.doneFn = dragDone;
+                  panPrep();
+                  _this.clearOutline(gd2);
+                } else if (rectMode(dragModeNow) || freeMode(dragModeNow)) {
+                  prepSelect(e2, startX, startY, _this.dragOptions, dragModeNow);
+                }
+              }
+            };
+            var x0, y0, mins0, span0, mins, lum, path0, dimmed, zb2, corners;
+            function makeUpdate(_mins) {
+              var attrs = {};
+              attrs[_this.id + ".aaxis.min"] = _mins.a;
+              attrs[_this.id + ".baxis.min"] = _mins.b;
+              attrs[_this.id + ".caxis.min"] = _mins.c;
+              return attrs;
+            }
+            function clickZoomPan(numClicks, evt) {
+              var clickMode = gd2._fullLayout.clickmode;
+              removeZoombox(gd2);
+              if (numClicks === 2) {
+                gd2.emit("plotly_doubleclick", null);
+                Registry.call("_guiRelayout", gd2, makeUpdate({ a: 0, b: 0, c: 0 }));
+              }
+              if (clickMode.indexOf("select") > -1 && numClicks === 1) {
+                selectOnClick(evt, gd2, [_this.xaxis], [_this.yaxis], _this.id, _this.dragOptions);
+              }
+              if (clickMode.indexOf("event") > -1) {
+                Fx.click(gd2, evt, _this.id);
+              }
+            }
+            function zoomPrep(e2, startX, startY) {
+              var dragBBox = dragger.getBoundingClientRect();
+              x0 = startX - dragBBox.left;
+              y0 = startY - dragBBox.top;
+              gd2._fullLayout._calcInverseTransform(gd2);
+              var inverse = gd2._fullLayout._invTransform;
+              var transformedCoords = Lib.apply3DTransform(inverse)(x0, y0);
+              x0 = transformedCoords[0];
+              y0 = transformedCoords[1];
+              mins0 = {
+                a: _this.aaxis.range[0],
+                b: _this.baxis.range[1],
+                c: _this.caxis.range[1]
+              };
+              mins = mins0;
+              span0 = _this.aaxis.range[1] - mins0.a;
+              lum = tinycolor(_this.graphDiv._fullLayout[_this.id].bgcolor).getLuminance();
+              path0 = "M0," + _this.h + "L" + _this.w / 2 + ", 0L" + _this.w + "," + _this.h + "Z";
+              dimmed = false;
+              zb2 = zoomLayer.append("path").attr("class", "zoombox").attr("transform", strTranslate(_this.x0, _this.y0)).style({
+                fill: lum > 0.2 ? "rgba(0,0,0,0)" : "rgba(255,255,255,0)",
+                "stroke-width": 0
+              }).attr("d", path0);
+              corners = zoomLayer.append("path").attr("class", "zoombox-corners").attr("transform", strTranslate(_this.x0, _this.y0)).style({
+                fill: Color2.background,
+                stroke: Color2.defaultLine,
+                "stroke-width": 1,
+                opacity: 0
+              }).attr("d", "M0,0Z");
+              _this.clearOutline(gd2);
+            }
+            function getAFrac(x2, y2) {
+              return 1 - y2 / _this.h;
+            }
+            function getBFrac(x2, y2) {
+              return 1 - (x2 + (_this.h - y2) / Math.sqrt(3)) / _this.w;
+            }
+            function getCFrac(x2, y2) {
+              return (x2 - (_this.h - y2) / Math.sqrt(3)) / _this.w;
+            }
+            function zoomMove(dx0, dy0) {
+              var x1 = x0 + dx0 * scaleX2;
+              var y1 = y0 + dy0 * scaleY2;
+              var afrac = Math.max(0, Math.min(1, getAFrac(x0, y0), getAFrac(x1, y1)));
+              var bfrac = Math.max(0, Math.min(1, getBFrac(x0, y0), getBFrac(x1, y1)));
+              var cfrac = Math.max(0, Math.min(1, getCFrac(x0, y0), getCFrac(x1, y1)));
+              var xLeft = (afrac / 2 + cfrac) * _this.w;
+              var xRight = (1 - afrac / 2 - bfrac) * _this.w;
+              var xCenter = (xLeft + xRight) / 2;
+              var xSpan = xRight - xLeft;
+              var yBottom = (1 - afrac) * _this.h;
+              var yTop = yBottom - xSpan / whRatio;
+              if (xSpan < constants.MINZOOM) {
+                mins = mins0;
+                zb2.attr("d", path0);
+                corners.attr("d", "M0,0Z");
+              } else {
+                mins = {
+                  a: mins0.a + afrac * span0,
+                  b: mins0.b + bfrac * span0,
+                  c: mins0.c + cfrac * span0
+                };
+                zb2.attr("d", path0 + "M" + xLeft + "," + yBottom + "H" + xRight + "L" + xCenter + "," + yTop + "L" + xLeft + "," + yBottom + "Z");
+                corners.attr("d", "M" + x0 + "," + y0 + STARTMARKER + "M" + xLeft + "," + yBottom + BLPATH + "M" + xRight + "," + yBottom + BRPATH + "M" + xCenter + "," + yTop + TOPPATH);
+              }
+              if (!dimmed) {
+                zb2.transition().style("fill", lum > 0.2 ? "rgba(0,0,0,0.4)" : "rgba(255,255,255,0.3)").duration(200);
+                corners.transition().style("opacity", 1).duration(200);
+                dimmed = true;
+              }
+              gd2.emit("plotly_relayouting", makeUpdate(mins));
+            }
+            function zoomDone() {
+              removeZoombox(gd2);
+              if (mins === mins0) return;
+              Registry.call("_guiRelayout", gd2, makeUpdate(mins));
+              if (SHOWZOOMOUTTIP && gd2.data && gd2._context.showTips) {
+                Lib.notifier(_2(gd2, "Double-click to zoom back out"), "long");
+                SHOWZOOMOUTTIP = false;
+              }
+            }
+            function panPrep() {
+              mins0 = {
+                a: _this.aaxis.range[0],
+                b: _this.baxis.range[1],
+                c: _this.caxis.range[1]
+              };
+              mins = mins0;
+            }
+            function plotDrag(dx, dy) {
+              var dxScaled = dx / _this.xaxis._m;
+              var dyScaled = dy / _this.yaxis._m;
+              mins = {
+                a: mins0.a - dyScaled,
+                b: mins0.b + (dxScaled + dyScaled) / 2,
+                c: mins0.c - (dxScaled - dyScaled) / 2
+              };
+              var minsorted = [mins.a, mins.b, mins.c].sort(Lib.sorterAsc);
+              var minindices = {
+                a: minsorted.indexOf(mins.a),
+                b: minsorted.indexOf(mins.b),
+                c: minsorted.indexOf(mins.c)
+              };
+              if (minsorted[0] < 0) {
+                if (minsorted[1] + minsorted[0] / 2 < 0) {
+                  minsorted[2] += minsorted[0] + minsorted[1];
+                  minsorted[0] = minsorted[1] = 0;
+                } else {
+                  minsorted[2] += minsorted[0] / 2;
+                  minsorted[1] += minsorted[0] / 2;
+                  minsorted[0] = 0;
+                }
+                mins = {
+                  a: minsorted[minindices.a],
+                  b: minsorted[minindices.b],
+                  c: minsorted[minindices.c]
+                };
+                dy = (mins0.a - mins.a) * _this.yaxis._m;
+                dx = (mins0.c - mins.c - mins0.b + mins.b) * _this.xaxis._m;
+              }
+              var plotTransform = strTranslate(_this.x0 + dx, _this.y0 + dy);
+              _this.plotContainer.selectAll(".scatterlayer,.maplayer").attr("transform", plotTransform);
+              var plotTransform2 = strTranslate(-dx, -dy);
+              _this.clipDefRelative.select("path").attr("transform", plotTransform2);
+              _this.aaxis.range = [mins.a, _this.sum - mins.b - mins.c];
+              _this.baxis.range = [_this.sum - mins.a - mins.c, mins.b];
+              _this.caxis.range = [_this.sum - mins.a - mins.b, mins.c];
+              _this.drawAxes(false);
+              if (_this._hasClipOnAxisFalse) {
+                _this.plotContainer.select(".scatterlayer").selectAll(".trace").call(Drawing.hideOutsideRangePoints, _this);
+              }
+              gd2.emit("plotly_relayouting", makeUpdate(mins));
+            }
+            function dragDone() {
+              Registry.call("_guiRelayout", gd2, makeUpdate(mins));
+            }
+            dragger.onmousemove = function(evt) {
+              Fx.hover(gd2, evt, _this.id);
+              gd2._fullLayout._lasthover = dragger;
+              gd2._fullLayout._hoversubplot = _this.id;
+            };
+            dragger.onmouseout = function(evt) {
+              if (gd2._dragging) return;
+              dragElement.unhover(gd2, evt);
+            };
+            dragElement.init(this.dragOptions);
+          };
+          function removeZoombox(gd2) {
+            d3.select(gd2).selectAll(".zoombox,.js-zoombox-backdrop,.js-zoombox-menu,.zoombox-corners").remove();
+          }
+        }
+      });
+      var require_layout_attributes8 = __commonJS({
+        "src/plots/ternary/layout_attributes.js"(exports, module2) {
+          var colorAttrs = require_attributes3();
+          var domainAttrs = require_domain().attributes;
+          var axesAttrs = require_layout_attributes4();
+          var overrideAll = require_edit_types().overrideAll;
+          var extendFlat = require_extend().extendFlat;
+          var ternaryAxesAttrs = {
+            title: {
+              text: axesAttrs.title.text,
+              font: axesAttrs.title.font
+              // TODO does standoff here make sense?
+            },
+            color: axesAttrs.color,
+            // ticks
+            tickmode: axesAttrs.minor.tickmode,
+            nticks: extendFlat({}, axesAttrs.nticks, { dflt: 6, min: 1 }),
+            tick0: axesAttrs.tick0,
+            dtick: axesAttrs.dtick,
+            tickvals: axesAttrs.tickvals,
+            ticktext: axesAttrs.ticktext,
+            ticks: axesAttrs.ticks,
+            ticklen: axesAttrs.ticklen,
+            tickwidth: axesAttrs.tickwidth,
+            tickcolor: axesAttrs.tickcolor,
+            ticklabelstep: axesAttrs.ticklabelstep,
+            showticklabels: axesAttrs.showticklabels,
+            labelalias: axesAttrs.labelalias,
+            showtickprefix: axesAttrs.showtickprefix,
+            tickprefix: axesAttrs.tickprefix,
+            showticksuffix: axesAttrs.showticksuffix,
+            ticksuffix: axesAttrs.ticksuffix,
+            showexponent: axesAttrs.showexponent,
+            exponentformat: axesAttrs.exponentformat,
+            minexponent: axesAttrs.minexponent,
+            separatethousands: axesAttrs.separatethousands,
+            tickfont: axesAttrs.tickfont,
+            tickangle: axesAttrs.tickangle,
+            tickformat: axesAttrs.tickformat,
+            tickformatstops: axesAttrs.tickformatstops,
+            hoverformat: axesAttrs.hoverformat,
+            // lines and grids
+            showline: extendFlat({}, axesAttrs.showline, { dflt: true }),
+            linecolor: axesAttrs.linecolor,
+            linewidth: axesAttrs.linewidth,
+            showgrid: extendFlat({}, axesAttrs.showgrid, { dflt: true }),
+            gridcolor: axesAttrs.gridcolor,
+            gridwidth: axesAttrs.gridwidth,
+            griddash: axesAttrs.griddash,
+            layer: axesAttrs.layer,
+            // range
+            min: {
+              valType: "number",
+              dflt: 0,
+              min: 0
+            }
+          };
+          var attrs = module2.exports = overrideAll({
+            domain: domainAttrs({ name: "ternary" }),
+            bgcolor: {
+              valType: "color",
+              dflt: colorAttrs.background
+            },
+            sum: {
+              valType: "number",
+              dflt: 1,
+              min: 0
+            },
+            aaxis: ternaryAxesAttrs,
+            baxis: ternaryAxesAttrs,
+            caxis: ternaryAxesAttrs
+          }, "plot", "from-root");
+          attrs.uirevision = {
+            valType: "any",
+            editType: "none"
+          };
+          attrs.aaxis.uirevision = attrs.baxis.uirevision = attrs.caxis.uirevision = {
+            valType: "any",
+            editType: "none"
+          };
+        }
+      });
+      var require_subplot_defaults = __commonJS({
+        "src/plots/subplot_defaults.js"(exports, module2) {
+          var Lib = require_lib();
+          var Template = require_plot_template();
+          var handleDomainDefaults = require_domain().defaults;
+          module2.exports = function handleSubplotDefaults(layoutIn, layoutOut, fullData, opts) {
+            var subplotType = opts.type;
+            var subplotAttributes = opts.attributes;
+            var handleDefaults = opts.handleDefaults;
+            var partition = opts.partition || "x";
+            var ids = layoutOut._subplots[subplotType];
+            var idsLength = ids.length;
+            var baseId = idsLength && ids[0].replace(/\d+$/, "");
+            var subplotLayoutIn, subplotLayoutOut;
+            function coerce(attr, dflt) {
+              return Lib.coerce(subplotLayoutIn, subplotLayoutOut, subplotAttributes, attr, dflt);
+            }
+            for (var i2 = 0; i2 < idsLength; i2++) {
+              var id2 = ids[i2];
+              if (layoutIn[id2]) subplotLayoutIn = layoutIn[id2];
+              else subplotLayoutIn = layoutIn[id2] = {};
+              subplotLayoutOut = Template.newContainer(layoutOut, id2, baseId);
+              if (!opts.noUirevision) coerce("uirevision", layoutOut.uirevision);
+              var dfltDomains = {};
+              dfltDomains[partition] = [i2 / idsLength, (i2 + 1) / idsLength];
+              handleDomainDefaults(subplotLayoutOut, layoutOut, coerce, dfltDomains);
+              opts.id = id2;
+              handleDefaults(subplotLayoutIn, subplotLayoutOut, coerce, opts);
+            }
+          };
+        }
+      });
+      var require_layout_defaults7 = __commonJS({
+        "src/plots/ternary/layout_defaults.js"(exports, module2) {
+          var Color2 = require_color();
+          var Template = require_plot_template();
+          var Lib = require_lib();
+          var handleSubplotDefaults = require_subplot_defaults();
+          var handleTickLabelDefaults = require_tick_label_defaults();
+          var handlePrefixSuffixDefaults = require_prefix_suffix_defaults();
+          var handleTickMarkDefaults = require_tick_mark_defaults();
+          var handleTickValueDefaults = require_tick_value_defaults();
+          var handleLineGridDefaults = require_line_grid_defaults();
+          var layoutAttributes = require_layout_attributes8();
+          var axesNames = ["aaxis", "baxis", "caxis"];
+          module2.exports = function supplyLayoutDefaults(layoutIn, layoutOut, fullData) {
+            handleSubplotDefaults(layoutIn, layoutOut, fullData, {
+              type: "ternary",
+              attributes: layoutAttributes,
+              handleDefaults: handleTernaryDefaults,
+              font: layoutOut.font,
+              paper_bgcolor: layoutOut.paper_bgcolor
+            });
+          };
+          function handleTernaryDefaults(ternaryLayoutIn, ternaryLayoutOut, coerce, options) {
+            var bgColor = coerce("bgcolor");
+            var sum = coerce("sum");
+            options.bgColor = Color2.combine(bgColor, options.paper_bgcolor);
+            var axName, containerIn, containerOut;
+            for (var j2 = 0; j2 < axesNames.length; j2++) {
+              axName = axesNames[j2];
+              containerIn = ternaryLayoutIn[axName] || {};
+              containerOut = Template.newContainer(ternaryLayoutOut, axName);
+              containerOut._name = axName;
+              handleAxisDefaults(containerIn, containerOut, options, ternaryLayoutOut);
+            }
+            var aaxis = ternaryLayoutOut.aaxis;
+            var baxis = ternaryLayoutOut.baxis;
+            var caxis = ternaryLayoutOut.caxis;
+            if (aaxis.min + baxis.min + caxis.min >= sum) {
+              aaxis.min = 0;
+              baxis.min = 0;
+              caxis.min = 0;
+              if (ternaryLayoutIn.aaxis) delete ternaryLayoutIn.aaxis.min;
+              if (ternaryLayoutIn.baxis) delete ternaryLayoutIn.baxis.min;
+              if (ternaryLayoutIn.caxis) delete ternaryLayoutIn.caxis.min;
+            }
+          }
+          function handleAxisDefaults(containerIn, containerOut, options, ternaryLayoutOut) {
+            var axAttrs = layoutAttributes[containerOut._name];
+            function coerce(attr, dflt) {
+              return Lib.coerce(containerIn, containerOut, axAttrs, attr, dflt);
+            }
+            coerce("uirevision", ternaryLayoutOut.uirevision);
+            containerOut.type = "linear";
+            var dfltColor = coerce("color");
+            var dfltFontColor = dfltColor !== axAttrs.color.dflt ? dfltColor : options.font.color;
+            var axName = containerOut._name;
+            var letterUpper = axName.charAt(0).toUpperCase();
+            var dfltTitle = "Component " + letterUpper;
+            var title = coerce("title.text", dfltTitle);
+            containerOut._hovertitle = title === dfltTitle ? title : letterUpper;
+            Lib.coerceFont(coerce, "title.font", options.font, { overrideDflt: {
+              size: Lib.bigFont(options.font.size),
+              color: dfltFontColor
+            } });
+            coerce("min");
+            handleTickValueDefaults(containerIn, containerOut, coerce, "linear");
+            handlePrefixSuffixDefaults(containerIn, containerOut, coerce, "linear");
+            handleTickLabelDefaults(containerIn, containerOut, coerce, "linear", {
+              noAutotickangles: true,
+              noTicklabelshift: true,
+              noTicklabelstandoff: true
+            });
+            handleTickMarkDefaults(
+              containerIn,
+              containerOut,
+              coerce,
+              { outerTicks: true }
+            );
+            var showTickLabels = coerce("showticklabels");
+            if (showTickLabels) {
+              Lib.coerceFont(coerce, "tickfont", options.font, { overrideDflt: {
+                color: dfltFontColor
+              } });
+              coerce("tickangle");
+              coerce("tickformat");
+            }
+            handleLineGridDefaults(containerIn, containerOut, coerce, {
+              dfltColor,
+              bgColor: options.bgColor,
+              // default grid color is darker here (60%, vs cartesian default ~91%)
+              // because the grid is not square so the eye needs heavier cues to follow
+              blend: 60,
+              showLine: true,
+              showGrid: true,
+              noZeroLine: true,
+              attributes: axAttrs
+            });
+            coerce("hoverformat");
+            coerce("layer");
+          }
+        }
+      });
+      var require_ternary2 = __commonJS({
+        "src/plots/ternary/index.js"(exports) {
+          var Ternary = require_ternary();
+          var getSubplotCalcData = require_get_data().getSubplotCalcData;
+          var counterRegex = require_lib().counterRegex;
+          var TERNARY = "ternary";
+          exports.name = TERNARY;
+          var attr = exports.attr = "subplot";
+          exports.idRoot = TERNARY;
+          exports.idRegex = exports.attrRegex = counterRegex(TERNARY);
+          var attributes = exports.attributes = {};
+          attributes[attr] = {
+            valType: "subplotid",
+            dflt: "ternary",
+            editType: "calc"
+          };
+          exports.layoutAttributes = require_layout_attributes8();
+          exports.supplyLayoutDefaults = require_layout_defaults7();
+          exports.plot = function plot(gd2) {
+            var fullLayout = gd2._fullLayout;
+            var calcData = gd2.calcdata;
+            var ternaryIds = fullLayout._subplots[TERNARY];
+            for (var i2 = 0; i2 < ternaryIds.length; i2++) {
+              var ternaryId = ternaryIds[i2];
+              var ternaryCalcData = getSubplotCalcData(calcData, TERNARY, ternaryId);
+              var ternary = fullLayout[ternaryId]._subplot;
+              if (!ternary) {
+                ternary = new Ternary(
+                  {
+                    id: ternaryId,
+                    graphDiv: gd2,
+                    container: fullLayout._ternarylayer.node()
+                  },
+                  fullLayout
+                );
+                fullLayout[ternaryId]._subplot = ternary;
+              }
+              ternary.plot(ternaryCalcData, fullLayout, gd2._promises);
+            }
+          };
+          exports.clean = function(newFullData, newFullLayout, oldFullData, oldFullLayout) {
+            var oldTernaryKeys = oldFullLayout._subplots[TERNARY] || [];
+            for (var i2 = 0; i2 < oldTernaryKeys.length; i2++) {
+              var oldTernaryKey = oldTernaryKeys[i2];
+              var oldTernary = oldFullLayout[oldTernaryKey]._subplot;
+              if (!newFullLayout[oldTernaryKey] && !!oldTernary) {
+                oldTernary.plotContainer.remove();
+                oldTernary.clipDef.remove();
+                oldTernary.clipDefRelative.remove();
+                oldTernary.layers["a-title"].remove();
+                oldTernary.layers["b-title"].remove();
+                oldTernary.layers["c-title"].remove();
+              }
+            }
+          };
+          exports.updateFx = function(gd2) {
+            var fullLayout = gd2._fullLayout;
+            fullLayout._ternarylayer.selectAll("g.toplevel").style("cursor", fullLayout.dragmode === "pan" ? "move" : "crosshair");
+          };
+        }
+      });
+      var require_scatterternary = __commonJS({
+        "src/traces/scatterternary/index.js"(exports, module2) {
+          module2.exports = {
+            attributes: require_attributes30(),
+            supplyDefaults: require_defaults26(),
+            colorbar: require_marker_colorbar(),
+            formatLabels: require_format_labels2(),
+            calc: require_calc11(),
+            plot: require_plot7(),
+            style: require_style2().style,
+            styleOnSelect: require_style2().styleOnSelect,
+            hoverPoints: require_hover9(),
+            selectPoints: require_select2(),
+            eventData: require_event_data4(),
+            moduleType: "trace",
+            name: "scatterternary",
+            basePlotModule: require_ternary2(),
+            categories: ["ternary", "symbols", "showLegend", "scatter-like"],
+            meta: {}
+          };
+        }
+      });
+      var require_scatterternary2 = __commonJS({
+        "lib/scatterternary.js"(exports, module2) {
+          module2.exports = require_scatterternary();
+        }
+      });
+      var require_attributes31 = __commonJS({
+        "src/traces/violin/attributes.js"(exports, module2) {
+          var boxAttrs = require_attributes24();
+          var extendFlat = require_extend().extendFlat;
+          var axisHoverFormat = require_axis_format_attributes().axisHoverFormat;
+          module2.exports = {
+            y: boxAttrs.y,
+            x: boxAttrs.x,
+            x0: boxAttrs.x0,
+            y0: boxAttrs.y0,
+            xhoverformat: axisHoverFormat("x"),
+            yhoverformat: axisHoverFormat("y"),
+            name: extendFlat({}, boxAttrs.name, {}),
+            orientation: extendFlat({}, boxAttrs.orientation, {}),
+            bandwidth: {
+              valType: "number",
+              min: 0,
+              editType: "calc"
+            },
+            scalegroup: {
+              valType: "string",
+              dflt: "",
+              editType: "calc"
+            },
+            scalemode: {
+              valType: "enumerated",
+              values: ["width", "count"],
+              dflt: "width",
+              editType: "calc"
+            },
+            spanmode: {
+              valType: "enumerated",
+              values: ["soft", "hard", "manual"],
+              dflt: "soft",
+              editType: "calc"
+            },
+            span: {
+              valType: "info_array",
+              items: [
+                { valType: "any", editType: "calc" },
+                { valType: "any", editType: "calc" }
+              ],
+              editType: "calc"
+            },
+            line: {
+              color: {
+                valType: "color",
+                editType: "style"
+              },
+              width: {
+                valType: "number",
+                min: 0,
+                dflt: 2,
+                editType: "style"
+              },
+              editType: "plot"
+            },
+            fillcolor: boxAttrs.fillcolor,
+            points: extendFlat({}, boxAttrs.boxpoints, {}),
+            jitter: extendFlat({}, boxAttrs.jitter, {}),
+            pointpos: extendFlat({}, boxAttrs.pointpos, {}),
+            width: extendFlat({}, boxAttrs.width, {}),
+            marker: boxAttrs.marker,
+            text: boxAttrs.text,
+            hovertext: boxAttrs.hovertext,
+            hovertemplate: boxAttrs.hovertemplate,
+            hovertemplatefallback: boxAttrs.hovertemplatefallback,
+            quartilemethod: boxAttrs.quartilemethod,
+            box: {
+              visible: {
+                valType: "boolean",
+                dflt: false,
+                editType: "plot"
+              },
+              width: {
+                valType: "number",
+                min: 0,
+                max: 1,
+                dflt: 0.25,
+                editType: "plot"
+              },
+              fillcolor: {
+                valType: "color",
+                editType: "style"
+              },
+              line: {
+                color: {
+                  valType: "color",
+                  editType: "style"
+                },
+                width: {
+                  valType: "number",
+                  min: 0,
+                  editType: "style"
+                },
+                editType: "style"
+              },
+              editType: "plot"
+            },
+            meanline: {
+              visible: {
+                valType: "boolean",
+                dflt: false,
+                editType: "plot"
+              },
+              color: {
+                valType: "color",
+                editType: "style"
+              },
+              width: {
+                valType: "number",
+                min: 0,
+                editType: "style"
+              },
+              editType: "plot"
+            },
+            side: {
+              valType: "enumerated",
+              values: ["both", "positive", "negative"],
+              dflt: "both",
+              editType: "calc"
+            },
+            offsetgroup: boxAttrs.offsetgroup,
+            alignmentgroup: boxAttrs.alignmentgroup,
+            selected: boxAttrs.selected,
+            unselected: boxAttrs.unselected,
+            hoveron: {
+              valType: "flaglist",
+              flags: ["violins", "points", "kde"],
+              dflt: "violins+points+kde",
+              extras: ["all"],
+              editType: "style"
+            },
+            zorder: boxAttrs.zorder
+          };
+        }
+      });
+      var require_layout_attributes9 = __commonJS({
+        "src/traces/violin/layout_attributes.js"(exports, module2) {
+          var boxLayoutAttrs = require_layout_attributes7();
+          var extendFlat = require_lib().extendFlat;
+          module2.exports = {
+            violinmode: extendFlat({}, boxLayoutAttrs.boxmode, {}),
+            violingap: extendFlat({}, boxLayoutAttrs.boxgap, {}),
+            violingroupgap: extendFlat({}, boxLayoutAttrs.boxgroupgap, {})
+          };
+        }
+      });
+      var require_defaults27 = __commonJS({
+        "src/traces/violin/defaults.js"(exports, module2) {
+          var Lib = require_lib();
+          var Color2 = require_color();
+          var boxDefaults = require_defaults20();
+          var attributes = require_attributes31();
+          module2.exports = function supplyDefaults(traceIn, traceOut, defaultColor, layout) {
+            function coerce(attr, dflt) {
+              return Lib.coerce(traceIn, traceOut, attributes, attr, dflt);
+            }
+            function coerce2(attr, dflt) {
+              return Lib.coerce2(traceIn, traceOut, attributes, attr, dflt);
+            }
+            boxDefaults.handleSampleDefaults(traceIn, traceOut, coerce, layout);
+            if (traceOut.visible === false) return;
+            coerce("bandwidth");
+            coerce("side");
+            var width = coerce("width");
+            if (!width) {
+              coerce("scalegroup", traceOut.name);
+              coerce("scalemode");
+            }
+            var span = coerce("span");
+            var spanmodeDflt;
+            if (Array.isArray(span)) spanmodeDflt = "manual";
+            coerce("spanmode", spanmodeDflt);
+            var lineColor = coerce("line.color", (traceIn.marker || {}).color || defaultColor);
+            var lineWidth = coerce("line.width");
+            var fillColor = coerce("fillcolor", Color2.addOpacity(traceOut.line.color, 0.5));
+            boxDefaults.handlePointsDefaults(traceIn, traceOut, coerce, { prefix: "" });
+            var boxWidth = coerce2("box.width");
+            var boxFillColor = coerce2("box.fillcolor", fillColor);
+            var boxLineColor = coerce2("box.line.color", lineColor);
+            var boxLineWidth = coerce2("box.line.width", lineWidth);
+            var boxVisible = coerce("box.visible", Boolean(boxWidth || boxFillColor || boxLineColor || boxLineWidth));
+            if (!boxVisible) traceOut.box = { visible: false };
+            var meanLineColor = coerce2("meanline.color", lineColor);
+            var meanLineWidth = coerce2("meanline.width", lineWidth);
+            var meanLineVisible = coerce("meanline.visible", Boolean(meanLineColor || meanLineWidth));
+            if (!meanLineVisible) traceOut.meanline = { visible: false };
+            coerce("quartilemethod");
+            coerce("zorder");
+          };
+        }
+      });
+      var require_layout_defaults8 = __commonJS({
+        "src/traces/violin/layout_defaults.js"(exports, module2) {
+          var Lib = require_lib();
+          var layoutAttributes = require_layout_attributes9();
+          var boxLayoutDefaults = require_layout_defaults6();
+          module2.exports = function supplyLayoutDefaults(layoutIn, layoutOut, fullData) {
+            function coerce(attr, dflt) {
+              return Lib.coerce(layoutIn, layoutOut, layoutAttributes, attr, dflt);
+            }
+            boxLayoutDefaults._supply(layoutIn, layoutOut, fullData, coerce, "violin");
+          };
+        }
+      });
+      var require_helpers13 = __commonJS({
+        "src/traces/violin/helpers.js"(exports) {
+          var Lib = require_lib();
+          var kernels = {
+            gaussian: function(v2) {
+              return 1 / Math.sqrt(2 * Math.PI) * Math.exp(-0.5 * v2 * v2);
+            }
+          };
+          exports.makeKDE = function(calcItem, trace, vals) {
+            var len2 = vals.length;
+            var kernel = kernels.gaussian;
+            var bandwidth = calcItem.bandwidth;
+            var factor = 1 / (len2 * bandwidth);
+            return function(x2) {
+              var sum = 0;
+              for (var i2 = 0; i2 < len2; i2++) {
+                sum += kernel((x2 - vals[i2]) / bandwidth);
+              }
+              return factor * sum;
+            };
+          };
+          exports.getPositionOnKdePath = function(calcItem, trace, valuePx) {
+            var posLetter, valLetter;
+            if (trace.orientation === "h") {
+              posLetter = "y";
+              valLetter = "x";
+            } else {
+              posLetter = "x";
+              valLetter = "y";
+            }
+            var pointOnPath = Lib.findPointOnPath(
+              calcItem.path,
+              valuePx,
+              valLetter,
+              { pathLength: calcItem.pathLength }
+            );
+            var posCenterPx = calcItem.posCenterPx;
+            var posOnPath0 = pointOnPath[posLetter];
+            var posOnPath1 = trace.side === "both" ? 2 * posCenterPx - posOnPath0 : posCenterPx;
+            return [posOnPath0, posOnPath1];
+          };
+          exports.getKdeValue = function(calcItem, trace, valueDist) {
+            var vals = calcItem.pts.map(exports.extractVal);
+            var kde = exports.makeKDE(calcItem, trace, vals);
+            return kde(valueDist) / calcItem.posDensityScale;
+          };
+          exports.extractVal = function(o2) {
+            return o2.v;
+          };
+        }
+      });
+      var require_calc12 = __commonJS({
+        "src/traces/violin/calc.js"(exports, module2) {
+          var Lib = require_lib();
+          var Axes = require_axes();
+          var boxCalc = require_calc6();
+          var helpers = require_helpers13();
+          var BADNUM = require_numerical().BADNUM;
+          module2.exports = function calc(gd2, trace) {
+            var cd2 = boxCalc(gd2, trace);
+            if (cd2[0].t.empty) return cd2;
+            var fullLayout = gd2._fullLayout;
+            var valAxis = Axes.getFromId(
+              gd2,
+              trace[trace.orientation === "h" ? "xaxis" : "yaxis"]
+            );
+            var spanMin = Infinity;
+            var spanMax = -Infinity;
+            var maxKDE = 0;
+            var maxCount = 0;
+            for (var i2 = 0; i2 < cd2.length; i2++) {
+              var cdi = cd2[i2];
+              var vals = cdi.pts.map(helpers.extractVal);
+              var bandwidth = cdi.bandwidth = calcBandwidth(trace, cdi, vals);
+              var span = cdi.span = calcSpan(trace, cdi, valAxis, bandwidth);
+              if (cdi.min === cdi.max && bandwidth === 0) {
+                span = cdi.span = [cdi.min, cdi.max];
+                cdi.density = [{ v: 1, t: span[0] }];
+                cdi.bandwidth = bandwidth;
+                maxKDE = Math.max(maxKDE, 1);
+              } else {
+                var dist = span[1] - span[0];
+                var n2 = Math.ceil(dist / (bandwidth / 3));
+                var step = dist / n2;
+                if (!isFinite(step) || !isFinite(n2)) {
+                  Lib.error("Something went wrong with computing the violin span");
+                  cd2[0].t.empty = true;
+                  return cd2;
+                }
+                var kde = helpers.makeKDE(cdi, trace, vals);
+                cdi.density = new Array(n2 + 1);
+                for (var k2 = 0; k2 < cdi.density.length; k2++) {
+                  var t4 = span[0] + k2 * step;
+                  var v2 = kde(t4);
+                  cdi.density[k2] = { v: v2, t: t4 };
+                  maxKDE = Math.max(maxKDE, v2);
+                }
+              }
+              maxCount = Math.max(maxCount, vals.length);
+              spanMin = Math.min(spanMin, span[0]);
+              spanMax = Math.max(spanMax, span[1]);
+            }
+            var extremes = Axes.findExtremes(valAxis, [spanMin, spanMax], { padded: true });
+            trace._extremes[valAxis._id] = extremes;
+            if (trace.width) {
+              cd2[0].t.maxKDE = maxKDE;
+            } else {
+              var violinScaleGroupStats = fullLayout._violinScaleGroupStats;
+              var scaleGroup = trace.scalegroup;
+              var groupStats = violinScaleGroupStats[scaleGroup];
+              if (groupStats) {
+                groupStats.maxKDE = Math.max(groupStats.maxKDE, maxKDE);
+                groupStats.maxCount = Math.max(groupStats.maxCount, maxCount);
+              } else {
+                violinScaleGroupStats[scaleGroup] = {
+                  maxKDE,
+                  maxCount
+                };
+              }
+            }
+            cd2[0].t.labels.kde = Lib._(gd2, "kde:");
+            return cd2;
+          };
+          function silvermanRule(len2, ssd, iqr) {
+            var a2 = Math.min(ssd, iqr / 1.349);
+            return 1.059 * a2 * Math.pow(len2, -0.2);
+          }
+          function calcBandwidth(trace, cdi, vals) {
+            var span = cdi.max - cdi.min;
+            if (!span) {
+              if (trace.bandwidth) {
+                return trace.bandwidth;
+              } else {
+                return 0;
+              }
+            }
+            if (trace.bandwidth) {
+              return Math.max(trace.bandwidth, span / 1e4);
+            } else {
+              var len2 = vals.length;
+              var ssd = Lib.stdev(vals, len2 - 1, cdi.mean);
+              return Math.max(
+                silvermanRule(len2, ssd, cdi.q3 - cdi.q1),
+                span / 100
+              );
+            }
+          }
+          function calcSpan(trace, cdi, valAxis, bandwidth) {
+            var spanmode = trace.spanmode;
+            var spanIn = trace.span || [];
+            var spanTight = [cdi.min, cdi.max];
+            var spanLoose = [cdi.min - 2 * bandwidth, cdi.max + 2 * bandwidth];
+            var spanOut;
+            function calcSpanItem(index) {
+              var s2 = spanIn[index];
+              var sc2 = valAxis.type === "multicategory" ? valAxis.r2c(s2) : valAxis.d2c(s2, 0, trace[cdi.valLetter + "calendar"]);
+              return sc2 === BADNUM ? spanLoose[index] : sc2;
+            }
+            if (spanmode === "soft") {
+              spanOut = spanLoose;
+            } else if (spanmode === "hard") {
+              spanOut = spanTight;
+            } else {
+              spanOut = [calcSpanItem(0), calcSpanItem(1)];
+            }
+            var dummyAx = {
+              type: "linear",
+              range: spanOut
+            };
+            Axes.setConvert(dummyAx);
+            dummyAx.cleanRange();
+            return spanOut;
+          }
+        }
+      });
+      var require_cross_trace_calc4 = __commonJS({
+        "src/traces/violin/cross_trace_calc.js"(exports, module2) {
+          var setPositionOffset = require_cross_trace_calc3().setPositionOffset;
+          var orientations = ["v", "h"];
+          module2.exports = function crossTraceCalc(gd2, plotinfo) {
+            var calcdata = gd2.calcdata;
+            var xa = plotinfo.xaxis;
+            var ya2 = plotinfo.yaxis;
+            for (var i2 = 0; i2 < orientations.length; i2++) {
+              var orientation = orientations[i2];
+              var posAxis = orientation === "h" ? ya2 : xa;
+              var violinList = [];
+              for (var j2 = 0; j2 < calcdata.length; j2++) {
+                var cd2 = calcdata[j2];
+                var t4 = cd2[0].t;
+                var trace = cd2[0].trace;
+                if (trace.visible === true && trace.type === "violin" && !t4.empty && trace.orientation === orientation && trace.xaxis === xa._id && trace.yaxis === ya2._id) {
+                  violinList.push(j2);
+                }
+              }
+              setPositionOffset("violin", gd2, violinList, posAxis);
+            }
+          };
+        }
+      });
+      var require_plot8 = __commonJS({
+        "src/traces/violin/plot.js"(exports, module2) {
+          var d3 = require_d3();
+          var Lib = require_lib();
+          var Drawing = require_drawing();
+          var boxPlot = require_plot4();
+          var linePoints = require_line_points();
+          var helpers = require_helpers13();
+          module2.exports = function plot(gd2, plotinfo, cdViolins, violinLayer) {
+            var isStatic = gd2._context.staticPlot;
+            var fullLayout = gd2._fullLayout;
+            var xa = plotinfo.xaxis;
+            var ya2 = plotinfo.yaxis;
+            function makePath(pts, trace) {
+              var segments = linePoints(pts, {
+                xaxis: xa,
+                yaxis: ya2,
+                trace,
+                connectGaps: true,
+                baseTolerance: 0.75,
+                shape: "spline",
+                simplify: true,
+                linearized: true
+              });
+              return Drawing.smoothopen(segments[0], 1);
+            }
+            Lib.makeTraceGroups(violinLayer, cdViolins, "trace violins").each(function(cd2) {
+              var plotGroup = d3.select(this);
+              var cd0 = cd2[0];
+              var t4 = cd0.t;
+              var trace = cd0.trace;
+              if (trace.visible !== true || t4.empty) {
+                plotGroup.remove();
+                return;
+              }
+              var bPos = t4.bPos;
+              var bdPos = t4.bdPos;
+              var valAxis = plotinfo[t4.valLetter + "axis"];
+              var posAxis = plotinfo[t4.posLetter + "axis"];
+              var hasBothSides = trace.side === "both";
+              var hasPositiveSide = hasBothSides || trace.side === "positive";
+              var hasNegativeSide = hasBothSides || trace.side === "negative";
+              var violins = plotGroup.selectAll("path.violin").data(Lib.identity);
+              violins.enter().append("path").style("vector-effect", isStatic ? "none" : "non-scaling-stroke").attr("class", "violin");
+              violins.exit().remove();
+              violins.each(function(d2) {
+                var pathSel = d3.select(this);
+                var density = d2.density;
+                var len2 = density.length;
+                var posCenter = posAxis.c2l(d2.pos + bPos, true);
+                var posCenterPx = posAxis.l2p(posCenter);
+                var scale2;
+                if (trace.width) {
+                  scale2 = t4.maxKDE / bdPos;
+                } else {
+                  var groupStats = fullLayout._violinScaleGroupStats[trace.scalegroup];
+                  scale2 = trace.scalemode === "count" ? groupStats.maxKDE / bdPos * (groupStats.maxCount / d2.pts.length) : groupStats.maxKDE / bdPos;
+                }
+                var pathPos, pathNeg, path;
+                var i2, k2, pts, pt2;
+                if (hasPositiveSide) {
+                  pts = new Array(len2);
+                  for (i2 = 0; i2 < len2; i2++) {
+                    pt2 = pts[i2] = {};
+                    pt2[t4.posLetter] = posCenter + density[i2].v / scale2;
+                    pt2[t4.valLetter] = valAxis.c2l(density[i2].t, true);
+                  }
+                  pathPos = makePath(pts, trace);
+                }
+                if (hasNegativeSide) {
+                  pts = new Array(len2);
+                  for (k2 = 0, i2 = len2 - 1; k2 < len2; k2++, i2--) {
+                    pt2 = pts[k2] = {};
+                    pt2[t4.posLetter] = posCenter - density[i2].v / scale2;
+                    pt2[t4.valLetter] = valAxis.c2l(density[i2].t, true);
+                  }
+                  pathNeg = makePath(pts, trace);
+                }
+                if (hasBothSides) {
+                  path = pathPos + "L" + pathNeg.slice(1) + "Z";
+                } else {
+                  var startPt = [posCenterPx, valAxis.c2p(density[0].t)];
+                  var endPt = [posCenterPx, valAxis.c2p(density[len2 - 1].t)];
+                  if (trace.orientation === "h") {
+                    startPt.reverse();
+                    endPt.reverse();
+                  }
+                  if (hasPositiveSide) {
+                    path = "M" + startPt + "L" + pathPos.slice(1) + "L" + endPt;
+                  } else {
+                    path = "M" + endPt + "L" + pathNeg.slice(1) + "L" + startPt;
+                  }
+                }
+                pathSel.attr("d", path);
+                d2.posCenterPx = posCenterPx;
+                d2.posDensityScale = scale2 * bdPos;
+                d2.path = pathSel.node();
+                d2.pathLength = d2.path.getTotalLength() / (hasBothSides ? 2 : 1);
+              });
+              var boxAttrs = trace.box;
+              var boxWidth = boxAttrs.width;
+              var boxLineWidth = (boxAttrs.line || {}).width;
+              var bdPosScaled;
+              var bPosPxOffset;
+              if (hasBothSides) {
+                bdPosScaled = bdPos * boxWidth;
+                bPosPxOffset = 0;
+              } else if (hasPositiveSide) {
+                bdPosScaled = [0, bdPos * boxWidth / 2];
+                bPosPxOffset = boxLineWidth * { x: 1, y: -1 }[t4.posLetter];
+              } else {
+                bdPosScaled = [bdPos * boxWidth / 2, 0];
+                bPosPxOffset = boxLineWidth * { x: -1, y: 1 }[t4.posLetter];
+              }
+              boxPlot.plotBoxAndWhiskers(plotGroup, { pos: posAxis, val: valAxis }, trace, {
+                bPos,
+                bdPos: bdPosScaled,
+                bPosPxOffset
+              });
+              boxPlot.plotBoxMean(plotGroup, { pos: posAxis, val: valAxis }, trace, {
+                bPos,
+                bdPos: bdPosScaled,
+                bPosPxOffset
+              });
+              var fn;
+              if (!trace.box.visible && trace.meanline.visible) {
+                fn = Lib.identity;
+              }
+              var meanPaths = plotGroup.selectAll("path.meanline").data(fn || []);
+              meanPaths.enter().append("path").attr("class", "meanline").style("fill", "none").style("vector-effect", isStatic ? "none" : "non-scaling-stroke");
+              meanPaths.exit().remove();
+              meanPaths.each(function(d2) {
+                var v2 = valAxis.c2p(d2.mean, true);
+                var p2 = helpers.getPositionOnKdePath(d2, trace, v2);
+                d3.select(this).attr(
+                  "d",
+                  trace.orientation === "h" ? "M" + v2 + "," + p2[0] + "V" + p2[1] : "M" + p2[0] + "," + v2 + "H" + p2[1]
+                );
+              });
+              boxPlot.plotPoints(plotGroup, { x: xa, y: ya2 }, trace, t4);
+            });
+          };
+        }
+      });
+      var require_style8 = __commonJS({
+        "src/traces/violin/style.js"(exports, module2) {
+          var d3 = require_d3();
+          var Color2 = require_color();
+          var stylePoints = require_style2().stylePoints;
+          module2.exports = function style(gd2) {
+            var s2 = d3.select(gd2).selectAll("g.trace.violins");
+            s2.style("opacity", function(d2) {
+              return d2[0].trace.opacity;
+            });
+            s2.each(function(d2) {
+              var trace = d2[0].trace;
+              var sel = d3.select(this);
+              var box = trace.box || {};
+              var boxLine = box.line || {};
+              var meanline = trace.meanline || {};
+              var meanLineWidth = meanline.width;
+              sel.selectAll("path.violin").style("stroke-width", trace.line.width + "px").call(Color2.stroke, trace.line.color).call(Color2.fill, trace.fillcolor);
+              sel.selectAll("path.box").style("stroke-width", boxLine.width + "px").call(Color2.stroke, boxLine.color).call(Color2.fill, box.fillcolor);
+              var meanLineStyle = {
+                "stroke-width": meanLineWidth + "px",
+                "stroke-dasharray": 2 * meanLineWidth + "px," + meanLineWidth + "px"
+              };
+              sel.selectAll("path.mean").style(meanLineStyle).call(Color2.stroke, meanline.color);
+              sel.selectAll("path.meanline").style(meanLineStyle).call(Color2.stroke, meanline.color);
+              stylePoints(sel, trace, gd2);
+            });
+          };
+        }
+      });
+      var require_hover10 = __commonJS({
+        "src/traces/violin/hover.js"(exports, module2) {
+          var Color2 = require_color();
+          var Lib = require_lib();
+          var Axes = require_axes();
+          var boxHoverPoints = require_hover4();
+          var helpers = require_helpers13();
+          module2.exports = function hoverPoints(pointData, xval, yval, hovermode, opts) {
+            if (!opts) opts = {};
+            var hoverLayer = opts.hoverLayer;
+            var cd2 = pointData.cd;
+            var trace = cd2[0].trace;
+            var hoveron = trace.hoveron;
+            var hasHoveronViolins = hoveron.indexOf("violins") !== -1;
+            var hasHoveronKDE = hoveron.indexOf("kde") !== -1;
+            var closeData = [];
+            var closePtData;
+            var violinLineAttrs;
+            if (hasHoveronViolins || hasHoveronKDE) {
+              var closeBoxData = boxHoverPoints.hoverOnBoxes(pointData, xval, yval, hovermode);
+              if (hasHoveronKDE && closeBoxData.length > 0) {
+                var xa = pointData.xa;
+                var ya2 = pointData.ya;
+                var pLetter, vLetter, pAxis, vAxis, vVal;
+                if (trace.orientation === "h") {
+                  vVal = xval;
+                  pLetter = "y";
+                  pAxis = ya2;
+                  vLetter = "x";
+                  vAxis = xa;
+                } else {
+                  vVal = yval;
+                  pLetter = "x";
+                  pAxis = xa;
+                  vLetter = "y";
+                  vAxis = ya2;
+                }
+                var di2 = cd2[pointData.index];
+                if (vVal >= di2.span[0] && vVal <= di2.span[1]) {
+                  var kdePointData = Lib.extendFlat({}, pointData);
+                  var vValPx = vAxis.c2p(vVal, true);
+                  var kdeVal = helpers.getKdeValue(di2, trace, vVal);
+                  var pOnPath = helpers.getPositionOnKdePath(di2, trace, vValPx);
+                  var paOffset = pAxis._offset;
+                  var paLength = pAxis._length;
+                  kdePointData[pLetter + "0"] = pOnPath[0];
+                  kdePointData[pLetter + "1"] = pOnPath[1];
+                  kdePointData[vLetter + "0"] = kdePointData[vLetter + "1"] = vValPx;
+                  kdePointData[vLetter + "Label"] = vLetter + ": " + Axes.hoverLabelText(vAxis, vVal, trace[vLetter + "hoverformat"]) + ", " + cd2[0].t.labels.kde + " " + kdeVal.toFixed(3);
+                  var medId = 0;
+                  for (var k2 = 0; k2 < closeBoxData.length; k2++) {
+                    if (closeBoxData[k2].attr === "med") {
+                      medId = k2;
+                      break;
+                    }
+                  }
+                  kdePointData.spikeDistance = closeBoxData[medId].spikeDistance;
+                  var spikePosAttr = pLetter + "Spike";
+                  kdePointData[spikePosAttr] = closeBoxData[medId][spikePosAttr];
+                  closeBoxData[medId].spikeDistance = void 0;
+                  closeBoxData[medId][spikePosAttr] = void 0;
+                  kdePointData.hovertemplate = false;
+                  closeData.push(kdePointData);
+                  violinLineAttrs = {};
+                  violinLineAttrs[pLetter + "1"] = Lib.constrain(paOffset + pOnPath[0], paOffset, paOffset + paLength);
+                  violinLineAttrs[pLetter + "2"] = Lib.constrain(paOffset + pOnPath[1], paOffset, paOffset + paLength);
+                  violinLineAttrs[vLetter + "1"] = violinLineAttrs[vLetter + "2"] = vAxis._offset + vValPx;
+                }
+              }
+              if (hasHoveronViolins) {
+                closeData = closeData.concat(closeBoxData);
+              }
+            }
+            if (hoveron.indexOf("points") !== -1) {
+              closePtData = boxHoverPoints.hoverOnPoints(pointData, xval, yval);
+            }
+            var violinLine = hoverLayer.selectAll(".violinline-" + trace.uid).data(violinLineAttrs ? [0] : []);
+            violinLine.enter().append("line").classed("violinline-" + trace.uid, true).attr("stroke-width", 1.5);
+            violinLine.exit().remove();
+            violinLine.attr(violinLineAttrs).call(Color2.stroke, pointData.color);
+            if (hovermode === "closest") {
+              if (closePtData) return [closePtData];
+              return closeData;
+            }
+            if (closePtData) {
+              closeData.push(closePtData);
+              return closeData;
+            }
+            return closeData;
+          };
+        }
+      });
+      var require_violin = __commonJS({
+        "src/traces/violin/index.js"(exports, module2) {
+          module2.exports = {
+            attributes: require_attributes31(),
+            layoutAttributes: require_layout_attributes9(),
+            supplyDefaults: require_defaults27(),
+            crossTraceDefaults: require_defaults20().crossTraceDefaults,
+            supplyLayoutDefaults: require_layout_defaults8(),
+            calc: require_calc12(),
+            crossTraceCalc: require_cross_trace_calc4(),
+            plot: require_plot8(),
+            style: require_style8(),
+            styleOnSelect: require_style2().styleOnSelect,
+            hoverPoints: require_hover10(),
+            selectPoints: require_select4(),
+            moduleType: "trace",
+            name: "violin",
+            basePlotModule: require_cartesian(),
+            categories: ["cartesian", "svg", "symbols", "oriented", "box-violin", "showLegend", "violinLayout", "zoomScale"],
+            meta: {}
+          };
+        }
+      });
+      var require_violin2 = __commonJS({
+        "lib/violin.js"(exports, module2) {
+          module2.exports = require_violin();
+        }
+      });
+      var require_constants17 = __commonJS({
+        "src/traces/funnel/constants.js"(exports, module2) {
+          module2.exports = {
+            eventDataKeys: [
+              "percentInitial",
+              "percentPrevious",
+              "percentTotal"
+            ]
+          };
+        }
+      });
+      var require_attributes32 = __commonJS({
+        "src/traces/funnel/attributes.js"(exports, module2) {
+          var barAttrs = require_attributes23();
+          var lineAttrs = require_attributes12().line;
+          var baseAttrs = require_attributes2();
+          var axisHoverFormat = require_axis_format_attributes().axisHoverFormat;
+          var { hovertemplateAttrs, texttemplateAttrs, templatefallbackAttrs } = require_template_attributes();
+          var constants = require_constants17();
+          var extendFlat = require_extend().extendFlat;
+          var Color2 = require_color();
+          module2.exports = {
+            x: barAttrs.x,
+            x0: barAttrs.x0,
+            dx: barAttrs.dx,
+            y: barAttrs.y,
+            y0: barAttrs.y0,
+            dy: barAttrs.dy,
+            xperiod: barAttrs.xperiod,
+            yperiod: barAttrs.yperiod,
+            xperiod0: barAttrs.xperiod0,
+            yperiod0: barAttrs.yperiod0,
+            xperiodalignment: barAttrs.xperiodalignment,
+            yperiodalignment: barAttrs.yperiodalignment,
+            xhoverformat: axisHoverFormat("x"),
+            yhoverformat: axisHoverFormat("y"),
+            hovertext: barAttrs.hovertext,
+            hovertemplate: hovertemplateAttrs({}, { keys: constants.eventDataKeys }),
+            hovertemplatefallback: templatefallbackAttrs(),
+            hoverinfo: extendFlat({}, baseAttrs.hoverinfo, {
+              flags: ["name", "x", "y", "text", "percent initial", "percent previous", "percent total"]
+            }),
+            textinfo: {
+              valType: "flaglist",
+              flags: ["label", "text", "percent initial", "percent previous", "percent total", "value"],
+              extras: ["none"],
+              editType: "plot",
+              arrayOk: false
+            },
+            // TODO: incorporate `label` and `value` in the eventData
+            texttemplate: texttemplateAttrs({ editType: "plot" }, { keys: constants.eventDataKeys.concat(["label", "value"]) }),
+            texttemplatefallback: templatefallbackAttrs({ editType: "plot" }),
+            text: barAttrs.text,
+            textposition: barAttrs.textposition,
+            insidetextanchor: extendFlat({}, barAttrs.insidetextanchor, { dflt: "middle" }),
+            textangle: extendFlat({}, barAttrs.textangle, { dflt: 0 }),
+            textfont: barAttrs.textfont,
+            insidetextfont: barAttrs.insidetextfont,
+            outsidetextfont: barAttrs.outsidetextfont,
+            constraintext: barAttrs.constraintext,
+            cliponaxis: barAttrs.cliponaxis,
+            orientation: extendFlat({}, barAttrs.orientation, {}),
+            offset: extendFlat({}, barAttrs.offset, { arrayOk: false }),
+            width: extendFlat({}, barAttrs.width, { arrayOk: false }),
+            marker: funnelMarker(),
+            connector: {
+              fillcolor: {
+                valType: "color",
+                editType: "style"
+              },
+              line: {
+                color: extendFlat({}, lineAttrs.color, { dflt: Color2.defaultLine }),
+                width: extendFlat({}, lineAttrs.width, {
+                  dflt: 0,
+                  editType: "plot"
+                }),
+                dash: lineAttrs.dash,
+                editType: "style"
+              },
+              visible: {
+                valType: "boolean",
+                dflt: true,
+                editType: "plot"
+              },
+              editType: "plot"
+            },
+            offsetgroup: barAttrs.offsetgroup,
+            alignmentgroup: barAttrs.alignmentgroup,
+            zorder: barAttrs.zorder
+          };
+          function funnelMarker() {
+            var marker = extendFlat({}, barAttrs.marker);
+            delete marker.pattern;
+            delete marker.cornerradius;
+            return marker;
+          }
+        }
+      });
+      var require_layout_attributes10 = __commonJS({
+        "src/traces/funnel/layout_attributes.js"(exports, module2) {
+          module2.exports = {
+            funnelmode: {
+              valType: "enumerated",
+              values: ["stack", "group", "overlay"],
+              dflt: "stack",
+              editType: "calc"
+            },
+            funnelgap: {
+              valType: "number",
+              min: 0,
+              max: 1,
+              editType: "calc"
+            },
+            funnelgroupgap: {
+              valType: "number",
+              min: 0,
+              max: 1,
+              dflt: 0,
+              editType: "calc"
+            }
+          };
+        }
+      });
+      var require_defaults28 = __commonJS({
+        "src/traces/funnel/defaults.js"(exports, module2) {
+          var Lib = require_lib();
+          var handleGroupingDefaults = require_grouping_defaults();
+          var handleText = require_defaults19().handleText;
+          var handleXYDefaults = require_xy_defaults();
+          var handlePeriodDefaults = require_period_defaults();
+          var attributes = require_attributes32();
+          var Color2 = require_color();
+          function supplyDefaults(traceIn, traceOut, defaultColor, layout) {
+            function coerce(attr, dflt) {
+              return Lib.coerce(traceIn, traceOut, attributes, attr, dflt);
+            }
+            var len2 = handleXYDefaults(traceIn, traceOut, layout, coerce);
+            if (!len2) {
+              traceOut.visible = false;
+              return;
+            }
+            handlePeriodDefaults(traceIn, traceOut, layout, coerce);
+            coerce("xhoverformat");
+            coerce("yhoverformat");
+            coerce("orientation", traceOut.y && !traceOut.x ? "v" : "h");
+            coerce("offset");
+            coerce("width");
+            var text = coerce("text");
+            coerce("hovertext");
+            coerce("hovertemplate");
+            coerce("hovertemplatefallback");
+            var textposition = coerce("textposition");
+            handleText(traceIn, traceOut, layout, coerce, textposition, {
+              moduleHasSelected: false,
+              moduleHasUnselected: false,
+              moduleHasConstrain: true,
+              moduleHasCliponaxis: true,
+              moduleHasTextangle: true,
+              moduleHasInsideanchor: true
+            });
+            if (traceOut.textposition !== "none" && !traceOut.texttemplate) {
+              coerce("textinfo", Lib.isArrayOrTypedArray(text) ? "text+value" : "value");
+            }
+            var markerColor = coerce("marker.color", defaultColor);
+            coerce("marker.line.color", Color2.defaultLine);
+            coerce("marker.line.width");
+            var connectorVisible = coerce("connector.visible");
+            if (connectorVisible) {
+              coerce("connector.fillcolor", defaultFillColor(markerColor));
+              var connectorLineWidth = coerce("connector.line.width");
+              if (connectorLineWidth) {
+                coerce("connector.line.color");
+                coerce("connector.line.dash");
+              }
+            }
+            coerce("zorder");
+          }
+          function defaultFillColor(markerColor) {
+            var cBase = Lib.isArrayOrTypedArray(markerColor) ? "#000" : markerColor;
+            return Color2.addOpacity(cBase, 0.5 * Color2.opacity(cBase));
+          }
+          function crossTraceDefaults(fullData, fullLayout) {
+            var traceIn, traceOut;
+            function coerce(attr) {
+              return Lib.coerce(traceOut._input, traceOut, attributes, attr);
+            }
+            for (var i2 = 0; i2 < fullData.length; i2++) {
+              traceOut = fullData[i2];
+              if (traceOut.type === "funnel") {
+                traceIn = traceOut._input;
+                handleGroupingDefaults(traceIn, traceOut, fullLayout, coerce, fullLayout.funnelmode);
+              }
+            }
+          }
+          module2.exports = {
+            supplyDefaults,
+            crossTraceDefaults
+          };
+        }
+      });
+      var require_layout_defaults9 = __commonJS({
+        "src/traces/funnel/layout_defaults.js"(exports, module2) {
+          var Lib = require_lib();
+          var layoutAttributes = require_layout_attributes10();
+          module2.exports = function(layoutIn, layoutOut, fullData) {
+            var hasTraceType = false;
+            function coerce(attr, dflt) {
+              return Lib.coerce(layoutIn, layoutOut, layoutAttributes, attr, dflt);
+            }
+            for (var i2 = 0; i2 < fullData.length; i2++) {
+              var trace = fullData[i2];
+              if (trace.visible && trace.type === "funnel") {
+                hasTraceType = true;
+                break;
+              }
+            }
+            if (hasTraceType) {
+              coerce("funnelmode");
+              coerce("funnelgap", 0.2);
+              coerce("funnelgroupgap");
+            }
+          };
+        }
+      });
+      var require_arrays_to_calcdata3 = __commonJS({
+        "src/traces/funnel/arrays_to_calcdata.js"(exports, module2) {
+          var Lib = require_lib();
+          module2.exports = function arraysToCalcdata(cd2, trace) {
+            for (var i2 = 0; i2 < cd2.length; i2++) cd2[i2].i = i2;
+            Lib.mergeArray(trace.text, cd2, "tx");
+            Lib.mergeArray(trace.hovertext, cd2, "htx");
+            var marker = trace.marker;
+            if (marker) {
+              Lib.mergeArray(marker.opacity, cd2, "mo");
+              Lib.mergeArray(marker.color, cd2, "mc");
+              var markerLine = marker.line;
+              if (markerLine) {
+                Lib.mergeArray(markerLine.color, cd2, "mlc");
+                Lib.mergeArrayCastPositive(markerLine.width, cd2, "mlw");
+              }
+            }
+          };
+        }
+      });
+      var require_calc13 = __commonJS({
+        "src/traces/funnel/calc.js"(exports, module2) {
+          var Axes = require_axes();
+          var alignPeriod = require_align_period();
+          var arraysToCalcdata = require_arrays_to_calcdata3();
+          var calcSelection = require_calc_selection();
+          var BADNUM = require_numerical().BADNUM;
+          module2.exports = function calc(gd2, trace) {
+            var xa = Axes.getFromId(gd2, trace.xaxis || "x");
+            var ya2 = Axes.getFromId(gd2, trace.yaxis || "y");
+            var size, pos, origPos, pObj, hasPeriod, pLetter, i2, cdi;
+            if (trace.orientation === "h") {
+              size = xa.makeCalcdata(trace, "x");
+              origPos = ya2.makeCalcdata(trace, "y");
+              pObj = alignPeriod(trace, ya2, "y", origPos);
+              hasPeriod = !!trace.yperiodalignment;
+              pLetter = "y";
+            } else {
+              size = ya2.makeCalcdata(trace, "y");
+              origPos = xa.makeCalcdata(trace, "x");
+              pObj = alignPeriod(trace, xa, "x", origPos);
+              hasPeriod = !!trace.xperiodalignment;
+              pLetter = "x";
+            }
+            pos = pObj.vals;
+            var serieslen = Math.min(pos.length, size.length);
+            var cd2 = new Array(serieslen);
+            trace._base = [];
+            for (i2 = 0; i2 < serieslen; i2++) {
+              if (size[i2] < 0) size[i2] = BADNUM;
+              var connectToNext = false;
+              if (size[i2] !== BADNUM) {
+                if (i2 + 1 < serieslen && size[i2 + 1] !== BADNUM) {
+                  connectToNext = true;
+                }
+              }
+              cdi = cd2[i2] = {
+                p: pos[i2],
+                s: size[i2],
+                cNext: connectToNext
+              };
+              trace._base[i2] = -0.5 * cdi.s;
+              if (hasPeriod) {
+                cd2[i2].orig_p = origPos[i2];
+                cd2[i2][pLetter + "End"] = pObj.ends[i2];
+                cd2[i2][pLetter + "Start"] = pObj.starts[i2];
+              }
+              if (trace.ids) {
+                cdi.id = String(trace.ids[i2]);
+              }
+              if (i2 === 0) cd2[0].vTotal = 0;
+              cd2[0].vTotal += fixNum(cdi.s);
+              cdi.begR = fixNum(cdi.s) / fixNum(cd2[0].s);
+            }
+            var prevGoodNum;
+            for (i2 = 0; i2 < serieslen; i2++) {
+              cdi = cd2[i2];
+              if (cdi.s === BADNUM) continue;
+              cdi.sumR = cdi.s / cd2[0].vTotal;
+              cdi.difR = prevGoodNum !== void 0 ? cdi.s / prevGoodNum : 1;
+              prevGoodNum = cdi.s;
+            }
+            arraysToCalcdata(cd2, trace);
+            calcSelection(cd2, trace);
+            return cd2;
+          };
+          function fixNum(a2) {
+            return a2 === BADNUM ? 0 : a2;
+          }
+        }
+      });
+      var require_cross_trace_calc5 = __commonJS({
+        "src/traces/funnel/cross_trace_calc.js"(exports, module2) {
+          var setGroupPositions = require_cross_trace_calc().setGroupPositions;
+          module2.exports = function crossTraceCalc(gd2, plotinfo) {
+            var fullLayout = gd2._fullLayout;
+            var fullData = gd2._fullData;
+            var calcdata = gd2.calcdata;
+            var xa = plotinfo.xaxis;
+            var ya2 = plotinfo.yaxis;
+            var funnels = [];
+            var funnelsVert = [];
+            var funnelsHorz = [];
+            var cd2, i2;
+            for (i2 = 0; i2 < fullData.length; i2++) {
+              var fullTrace = fullData[i2];
+              var isHorizontal = fullTrace.orientation === "h";
+              if (fullTrace.visible === true && fullTrace.xaxis === xa._id && fullTrace.yaxis === ya2._id && fullTrace.type === "funnel") {
+                cd2 = calcdata[i2];
+                if (isHorizontal) {
+                  funnelsHorz.push(cd2);
+                } else {
+                  funnelsVert.push(cd2);
+                }
+                funnels.push(cd2);
+              }
+            }
+            var opts = {
+              mode: fullLayout.funnelmode,
+              norm: fullLayout.funnelnorm,
+              gap: fullLayout.funnelgap,
+              groupgap: fullLayout.funnelgroupgap
+            };
+            setGroupPositions(gd2, xa, ya2, funnelsVert, opts);
+            setGroupPositions(gd2, ya2, xa, funnelsHorz, opts);
+            for (i2 = 0; i2 < funnels.length; i2++) {
+              cd2 = funnels[i2];
+              for (var j2 = 0; j2 < cd2.length; j2++) {
+                if (j2 + 1 < cd2.length) {
+                  cd2[j2].nextP0 = cd2[j2 + 1].p0;
+                  cd2[j2].nextS0 = cd2[j2 + 1].s0;
+                  cd2[j2].nextP1 = cd2[j2 + 1].p1;
+                  cd2[j2].nextS1 = cd2[j2 + 1].s1;
+                }
+              }
+            }
+          };
+        }
+      });
+      var require_plot9 = __commonJS({
+        "src/traces/funnel/plot.js"(exports, module2) {
+          var d3 = require_d3();
+          var Lib = require_lib();
+          var Drawing = require_drawing();
+          var BADNUM = require_numerical().BADNUM;
+          var barPlot = require_plot3();
+          var clearMinTextSize = require_uniform_text().clearMinTextSize;
+          module2.exports = function plot(gd2, plotinfo, cdModule, traceLayer) {
+            var fullLayout = gd2._fullLayout;
+            clearMinTextSize("funnel", fullLayout);
+            plotConnectorRegions(gd2, plotinfo, cdModule, traceLayer);
+            plotConnectorLines(gd2, plotinfo, cdModule, traceLayer);
+            barPlot.plot(gd2, plotinfo, cdModule, traceLayer, {
+              mode: fullLayout.funnelmode,
+              norm: fullLayout.funnelmode,
+              gap: fullLayout.funnelgap,
+              groupgap: fullLayout.funnelgroupgap
+            });
+          };
+          function plotConnectorRegions(gd2, plotinfo, cdModule, traceLayer) {
+            var xa = plotinfo.xaxis;
+            var ya2 = plotinfo.yaxis;
+            Lib.makeTraceGroups(traceLayer, cdModule, "trace bars").each(function(cd2) {
+              var plotGroup = d3.select(this);
+              var trace = cd2[0].trace;
+              var group = Lib.ensureSingle(plotGroup, "g", "regions");
+              if (!trace.connector || !trace.connector.visible) {
+                group.remove();
+                return;
+              }
+              var isHorizontal = trace.orientation === "h";
+              var connectors = group.selectAll("g.region").data(Lib.identity);
+              connectors.enter().append("g").classed("region", true);
+              connectors.exit().remove();
+              var len2 = connectors.size();
+              connectors.each(function(di2, i2) {
+                if (i2 !== len2 - 1 && !di2.cNext) return;
+                var xy = getXY(di2, xa, ya2, isHorizontal);
+                var x2 = xy[0];
+                var y2 = xy[1];
+                var shape = "";
+                if (x2[0] !== BADNUM && y2[0] !== BADNUM && x2[1] !== BADNUM && y2[1] !== BADNUM && x2[2] !== BADNUM && y2[2] !== BADNUM && x2[3] !== BADNUM && y2[3] !== BADNUM) {
+                  if (isHorizontal) {
+                    shape += "M" + x2[0] + "," + y2[1] + "L" + x2[2] + "," + y2[2] + "H" + x2[3] + "L" + x2[1] + "," + y2[1] + "Z";
+                  } else {
+                    shape += "M" + x2[1] + "," + y2[1] + "L" + x2[2] + "," + y2[3] + "V" + y2[2] + "L" + x2[1] + "," + y2[0] + "Z";
+                  }
+                }
+                if (shape === "") shape = "M0,0Z";
+                Lib.ensureSingle(d3.select(this), "path").attr("d", shape).call(Drawing.setClipUrl, plotinfo.layerClipId, gd2);
+              });
+            });
+          }
+          function plotConnectorLines(gd2, plotinfo, cdModule, traceLayer) {
+            var xa = plotinfo.xaxis;
+            var ya2 = plotinfo.yaxis;
+            Lib.makeTraceGroups(traceLayer, cdModule, "trace bars").each(function(cd2) {
+              var plotGroup = d3.select(this);
+              var trace = cd2[0].trace;
+              var group = Lib.ensureSingle(plotGroup, "g", "lines");
+              if (!trace.connector || !trace.connector.visible || !trace.connector.line.width) {
+                group.remove();
+                return;
+              }
+              var isHorizontal = trace.orientation === "h";
+              var connectors = group.selectAll("g.line").data(Lib.identity);
+              connectors.enter().append("g").classed("line", true);
+              connectors.exit().remove();
+              var len2 = connectors.size();
+              connectors.each(function(di2, i2) {
+                if (i2 !== len2 - 1 && !di2.cNext) return;
+                var xy = getXY(di2, xa, ya2, isHorizontal);
+                var x2 = xy[0];
+                var y2 = xy[1];
+                var shape = "";
+                if (x2[3] !== void 0 && y2[3] !== void 0) {
+                  if (isHorizontal) {
+                    shape += "M" + x2[0] + "," + y2[1] + "L" + x2[2] + "," + y2[2];
+                    shape += "M" + x2[1] + "," + y2[1] + "L" + x2[3] + "," + y2[2];
+                  } else {
+                    shape += "M" + x2[1] + "," + y2[1] + "L" + x2[2] + "," + y2[3];
+                    shape += "M" + x2[1] + "," + y2[0] + "L" + x2[2] + "," + y2[2];
+                  }
+                }
+                if (shape === "") shape = "M0,0Z";
+                Lib.ensureSingle(d3.select(this), "path").attr("d", shape).call(Drawing.setClipUrl, plotinfo.layerClipId, gd2);
+              });
+            });
+          }
+          function getXY(di2, xa, ya2, isHorizontal) {
+            var s2 = [];
+            var p2 = [];
+            var sAxis = isHorizontal ? xa : ya2;
+            var pAxis = isHorizontal ? ya2 : xa;
+            s2[0] = sAxis.c2p(di2.s0, true);
+            p2[0] = pAxis.c2p(di2.p0, true);
+            s2[1] = sAxis.c2p(di2.s1, true);
+            p2[1] = pAxis.c2p(di2.p1, true);
+            s2[2] = sAxis.c2p(di2.nextS0, true);
+            p2[2] = pAxis.c2p(di2.nextP0, true);
+            s2[3] = sAxis.c2p(di2.nextS1, true);
+            p2[3] = pAxis.c2p(di2.nextP1, true);
+            return isHorizontal ? [s2, p2] : [p2, s2];
+          }
+        }
+      });
+      var require_style9 = __commonJS({
+        "src/traces/funnel/style.js"(exports, module2) {
+          var d3 = require_d3();
+          var Drawing = require_drawing();
+          var Color2 = require_color();
+          var DESELECTDIM = require_interactions().DESELECTDIM;
+          var barStyle = require_style4();
+          var resizeText = require_uniform_text().resizeText;
+          var styleTextPoints = barStyle.styleTextPoints;
+          function style(gd2, cd2, sel) {
+            var s2 = sel ? sel : d3.select(gd2).selectAll('g[class^="funnellayer"]').selectAll("g.trace");
+            resizeText(gd2, s2, "funnel");
+            s2.style("opacity", function(d2) {
+              return d2[0].trace.opacity;
+            });
+            s2.each(function(d2) {
+              var gTrace = d3.select(this);
+              var trace = d2[0].trace;
+              gTrace.selectAll(".point > path").each(function(di2) {
+                if (!di2.isBlank) {
+                  var cont = trace.marker;
+                  d3.select(this).call(Color2.fill, di2.mc || cont.color).call(Color2.stroke, di2.mlc || cont.line.color).call(Drawing.dashLine, cont.line.dash, di2.mlw || cont.line.width).style("opacity", trace.selectedpoints && !di2.selected ? DESELECTDIM : 1);
+                }
+              });
+              styleTextPoints(gTrace, trace, gd2);
+              gTrace.selectAll(".regions").each(function() {
+                d3.select(this).selectAll("path").style("stroke-width", 0).call(Color2.fill, trace.connector.fillcolor);
+              });
+              gTrace.selectAll(".lines").each(function() {
+                var cont = trace.connector.line;
+                Drawing.lineGroupStyle(
+                  d3.select(this).selectAll("path"),
+                  cont.width,
+                  cont.color,
+                  cont.dash
+                );
+              });
+            });
+          }
+          module2.exports = {
+            style
+          };
+        }
+      });
+      var require_hover11 = __commonJS({
+        "src/traces/funnel/hover.js"(exports, module2) {
+          var opacity = require_color().opacity;
+          var hoverOnBars = require_hover3().hoverOnBars;
+          var formatPercent = require_lib().formatPercent;
+          module2.exports = function hoverPoints(pointData, xval, yval, hovermode, opts) {
+            var point = hoverOnBars(pointData, xval, yval, hovermode, opts);
+            if (!point) return;
+            var cd2 = point.cd;
+            var trace = cd2[0].trace;
+            var isHorizontal = trace.orientation === "h";
+            var index = point.index;
+            var di2 = cd2[index];
+            var sizeLetter = isHorizontal ? "x" : "y";
+            point[sizeLetter + "LabelVal"] = di2.s;
+            point.percentInitial = di2.begR;
+            point.percentInitialLabel = formatPercent(di2.begR, 1);
+            point.percentPrevious = di2.difR;
+            point.percentPreviousLabel = formatPercent(di2.difR, 1);
+            point.percentTotal = di2.sumR;
+            point.percentTotalLabel = formatPercent(di2.sumR, 1);
+            var hoverinfo = di2.hi || trace.hoverinfo;
+            var text = [];
+            if (hoverinfo && hoverinfo !== "none" && hoverinfo !== "skip") {
+              var isAll = hoverinfo === "all";
+              var parts = hoverinfo.split("+");
+              var hasFlag = function(flag) {
+                return isAll || parts.indexOf(flag) !== -1;
+              };
+              if (hasFlag("percent initial")) {
+                text.push(point.percentInitialLabel + " of initial");
+              }
+              if (hasFlag("percent previous")) {
+                text.push(point.percentPreviousLabel + " of previous");
+              }
+              if (hasFlag("percent total")) {
+                text.push(point.percentTotalLabel + " of total");
+              }
+            }
+            point.extraText = text.join("<br>");
+            point.color = getTraceColor(trace, di2);
+            return [point];
+          };
+          function getTraceColor(trace, di2) {
+            var cont = trace.marker;
+            var mc2 = di2.mc || cont.color;
+            var mlc = di2.mlc || cont.line.color;
+            var mlw = di2.mlw || cont.line.width;
+            if (opacity(mc2)) return mc2;
+            else if (opacity(mlc) && mlw) return mlc;
+          }
+        }
+      });
+      var require_event_data5 = __commonJS({
+        "src/traces/funnel/event_data.js"(exports, module2) {
+          module2.exports = function eventData(out, pt2) {
+            out.x = "xVal" in pt2 ? pt2.xVal : pt2.x;
+            out.y = "yVal" in pt2 ? pt2.yVal : pt2.y;
+            if ("percentInitial" in pt2) out.percentInitial = pt2.percentInitial;
+            if ("percentPrevious" in pt2) out.percentPrevious = pt2.percentPrevious;
+            if ("percentTotal" in pt2) out.percentTotal = pt2.percentTotal;
+            if (pt2.xa) out.xaxis = pt2.xa;
+            if (pt2.ya) out.yaxis = pt2.ya;
+            return out;
+          };
+        }
+      });
+      var require_funnel = __commonJS({
+        "src/traces/funnel/index.js"(exports, module2) {
+          module2.exports = {
+            attributes: require_attributes32(),
+            layoutAttributes: require_layout_attributes10(),
+            supplyDefaults: require_defaults28().supplyDefaults,
+            crossTraceDefaults: require_defaults28().crossTraceDefaults,
+            supplyLayoutDefaults: require_layout_defaults9(),
+            calc: require_calc13(),
+            crossTraceCalc: require_cross_trace_calc5(),
+            plot: require_plot9(),
+            style: require_style9().style,
+            hoverPoints: require_hover11(),
+            eventData: require_event_data5(),
+            selectPoints: require_select3(),
+            moduleType: "trace",
+            name: "funnel",
+            basePlotModule: require_cartesian(),
+            categories: ["bar-like", "cartesian", "svg", "oriented", "showLegend", "zoomScale"],
+            meta: {}
+          };
+        }
+      });
+      var require_funnel2 = __commonJS({
+        "lib/funnel.js"(exports, module2) {
+          module2.exports = require_funnel();
+        }
+      });
+      var require_constants18 = __commonJS({
+        "src/traces/waterfall/constants.js"(exports, module2) {
+          module2.exports = {
+            eventDataKeys: [
+              "initial",
+              "delta",
+              "final"
+            ]
+          };
+        }
+      });
+      var require_attributes33 = __commonJS({
+        "src/traces/waterfall/attributes.js"(exports, module2) {
+          var barAttrs = require_attributes23();
+          var lineAttrs = require_attributes12().line;
+          var baseAttrs = require_attributes2();
+          var axisHoverFormat = require_axis_format_attributes().axisHoverFormat;
+          var { hovertemplateAttrs, texttemplateAttrs, templatefallbackAttrs } = require_template_attributes();
+          var constants = require_constants18();
+          var extendFlat = require_extend().extendFlat;
+          var Color2 = require_color();
+          function directionAttrs(dirTxt) {
+            return {
+              marker: {
+                color: extendFlat({}, barAttrs.marker.color, {
+                  arrayOk: false,
+                  editType: "style"
+                }),
+                line: {
+                  color: extendFlat({}, barAttrs.marker.line.color, {
+                    arrayOk: false,
+                    editType: "style"
+                  }),
+                  width: extendFlat({}, barAttrs.marker.line.width, {
+                    arrayOk: false,
+                    editType: "style"
+                  }),
+                  editType: "style"
+                },
+                editType: "style"
+              },
+              editType: "style"
+            };
+          }
+          module2.exports = {
+            measure: {
+              valType: "data_array",
+              dflt: [],
+              editType: "calc"
+            },
+            base: {
+              valType: "number",
+              dflt: null,
+              arrayOk: false,
+              editType: "calc"
+            },
+            x: barAttrs.x,
+            x0: barAttrs.x0,
+            dx: barAttrs.dx,
+            y: barAttrs.y,
+            y0: barAttrs.y0,
+            dy: barAttrs.dy,
+            xperiod: barAttrs.xperiod,
+            yperiod: barAttrs.yperiod,
+            xperiod0: barAttrs.xperiod0,
+            yperiod0: barAttrs.yperiod0,
+            xperiodalignment: barAttrs.xperiodalignment,
+            yperiodalignment: barAttrs.yperiodalignment,
+            xhoverformat: axisHoverFormat("x"),
+            yhoverformat: axisHoverFormat("y"),
+            hovertext: barAttrs.hovertext,
+            hovertemplate: hovertemplateAttrs({}, { keys: constants.eventDataKeys }),
+            hovertemplatefallback: templatefallbackAttrs(),
+            hoverinfo: extendFlat({}, baseAttrs.hoverinfo, {
+              flags: ["name", "x", "y", "text", "initial", "delta", "final"]
+            }),
+            textinfo: {
+              valType: "flaglist",
+              flags: ["label", "text", "initial", "delta", "final"],
+              extras: ["none"],
+              editType: "plot",
+              arrayOk: false
+            },
+            // TODO: incorporate `label` and `value` in the eventData
+            texttemplate: texttemplateAttrs({ editType: "plot" }, { keys: constants.eventDataKeys.concat(["label"]) }),
+            texttemplatefallback: templatefallbackAttrs({ editType: "plot" }),
+            text: barAttrs.text,
+            textposition: barAttrs.textposition,
+            insidetextanchor: barAttrs.insidetextanchor,
+            textangle: barAttrs.textangle,
+            textfont: barAttrs.textfont,
+            insidetextfont: barAttrs.insidetextfont,
+            outsidetextfont: barAttrs.outsidetextfont,
+            constraintext: barAttrs.constraintext,
+            cliponaxis: barAttrs.cliponaxis,
+            orientation: barAttrs.orientation,
+            offset: barAttrs.offset,
+            width: barAttrs.width,
+            increasing: directionAttrs(),
+            decreasing: directionAttrs(),
+            totals: directionAttrs(),
+            connector: {
+              line: {
+                color: extendFlat({}, lineAttrs.color, { dflt: Color2.defaultLine }),
+                width: extendFlat({}, lineAttrs.width, {
+                  editType: "plot"
+                  // i.e. to adjust bars is mode: 'between'. See https://github.com/plotly/plotly.js/issues/3787
+                }),
+                dash: lineAttrs.dash,
+                editType: "plot"
+              },
+              mode: {
+                valType: "enumerated",
+                values: ["spanning", "between"],
+                dflt: "between",
+                editType: "plot"
+              },
+              visible: {
+                valType: "boolean",
+                dflt: true,
+                editType: "plot"
+              },
+              editType: "plot"
+            },
+            offsetgroup: barAttrs.offsetgroup,
+            alignmentgroup: barAttrs.alignmentgroup,
+            zorder: barAttrs.zorder
+          };
+        }
+      });
+      var require_layout_attributes11 = __commonJS({
+        "src/traces/waterfall/layout_attributes.js"(exports, module2) {
+          module2.exports = {
+            waterfallmode: {
+              valType: "enumerated",
+              values: ["group", "overlay"],
+              dflt: "group",
+              editType: "calc"
+            },
+            waterfallgap: {
+              valType: "number",
+              min: 0,
+              max: 1,
+              editType: "calc"
+            },
+            waterfallgroupgap: {
+              valType: "number",
+              min: 0,
+              max: 1,
+              dflt: 0,
+              editType: "calc"
+            }
+          };
+        }
+      });
+      var require_delta = __commonJS({
+        "src/constants/delta.js"(exports, module2) {
+          module2.exports = {
+            INCREASING: {
+              COLOR: "#3D9970",
+              SYMBOL: "▲"
+            },
+            DECREASING: {
+              COLOR: "#FF4136",
+              SYMBOL: "▼"
+            }
+          };
+        }
+      });
+      var require_defaults29 = __commonJS({
+        "src/traces/waterfall/defaults.js"(exports, module2) {
+          var Lib = require_lib();
+          var handleGroupingDefaults = require_grouping_defaults();
+          var handleText = require_defaults19().handleText;
+          var handleXYDefaults = require_xy_defaults();
+          var handlePeriodDefaults = require_period_defaults();
+          var attributes = require_attributes33();
+          var Color2 = require_color();
+          var delta = require_delta();
+          var INCREASING_COLOR = delta.INCREASING.COLOR;
+          var DECREASING_COLOR = delta.DECREASING.COLOR;
+          var TOTALS_COLOR = "#4499FF";
+          function handleDirection(coerce, direction, defaultColor) {
+            coerce(direction + ".marker.color", defaultColor);
+            coerce(direction + ".marker.line.color", Color2.defaultLine);
+            coerce(direction + ".marker.line.width");
+          }
+          function supplyDefaults(traceIn, traceOut, defaultColor, layout) {
+            function coerce(attr, dflt) {
+              return Lib.coerce(traceIn, traceOut, attributes, attr, dflt);
+            }
+            var len2 = handleXYDefaults(traceIn, traceOut, layout, coerce);
+            if (!len2) {
+              traceOut.visible = false;
+              return;
+            }
+            handlePeriodDefaults(traceIn, traceOut, layout, coerce);
+            coerce("xhoverformat");
+            coerce("yhoverformat");
+            coerce("measure");
+            coerce("orientation", traceOut.x && !traceOut.y ? "h" : "v");
+            coerce("base");
+            coerce("offset");
+            coerce("width");
+            coerce("text");
+            coerce("hovertext");
+            coerce("hovertemplate");
+            coerce("hovertemplatefallback");
+            var textposition = coerce("textposition");
+            handleText(traceIn, traceOut, layout, coerce, textposition, {
+              moduleHasSelected: false,
+              moduleHasUnselected: false,
+              moduleHasConstrain: true,
+              moduleHasCliponaxis: true,
+              moduleHasTextangle: true,
+              moduleHasInsideanchor: true
+            });
+            if (traceOut.textposition !== "none") {
+              coerce("texttemplate");
+              coerce("texttemplatefallback");
+              if (!traceOut.texttemplate) coerce("textinfo");
+            }
+            handleDirection(coerce, "increasing", INCREASING_COLOR);
+            handleDirection(coerce, "decreasing", DECREASING_COLOR);
+            handleDirection(coerce, "totals", TOTALS_COLOR);
+            var connectorVisible = coerce("connector.visible");
+            if (connectorVisible) {
+              coerce("connector.mode");
+              var connectorLineWidth = coerce("connector.line.width");
+              if (connectorLineWidth) {
+                coerce("connector.line.color");
+                coerce("connector.line.dash");
+              }
+            }
+            coerce("zorder");
+          }
+          function crossTraceDefaults(fullData, fullLayout) {
+            var traceIn, traceOut;
+            function coerce(attr) {
+              return Lib.coerce(traceOut._input, traceOut, attributes, attr);
+            }
+            if (fullLayout.waterfallmode === "group") {
+              for (var i2 = 0; i2 < fullData.length; i2++) {
+                traceOut = fullData[i2];
+                traceIn = traceOut._input;
+                handleGroupingDefaults(traceIn, traceOut, fullLayout, coerce, fullLayout.waterfallmode);
+              }
+            }
+          }
+          module2.exports = {
+            supplyDefaults,
+            crossTraceDefaults
+          };
+        }
+      });
+      var require_layout_defaults10 = __commonJS({
+        "src/traces/waterfall/layout_defaults.js"(exports, module2) {
+          var Lib = require_lib();
+          var layoutAttributes = require_layout_attributes11();
+          module2.exports = function(layoutIn, layoutOut, fullData) {
+            var hasTraceType = false;
+            function coerce(attr, dflt) {
+              return Lib.coerce(layoutIn, layoutOut, layoutAttributes, attr, dflt);
+            }
+            for (var i2 = 0; i2 < fullData.length; i2++) {
+              var trace = fullData[i2];
+              if (trace.visible && trace.type === "waterfall") {
+                hasTraceType = true;
+                break;
+              }
+            }
+            if (hasTraceType) {
+              coerce("waterfallmode");
+              coerce("waterfallgap", 0.2);
+              coerce("waterfallgroupgap");
+            }
+          };
+        }
+      });
+      var require_calc14 = __commonJS({
+        "src/traces/waterfall/calc.js"(exports, module2) {
+          var Axes = require_axes();
+          var alignPeriod = require_align_period();
+          var mergeArray = require_lib().mergeArray;
+          var calcSelection = require_calc_selection();
+          var BADNUM = require_numerical().BADNUM;
+          function isAbsolute(a2) {
+            return a2 === "a" || a2 === "absolute";
+          }
+          function isTotal(a2) {
+            return a2 === "t" || a2 === "total";
+          }
+          module2.exports = function calc(gd2, trace) {
+            var xa = Axes.getFromId(gd2, trace.xaxis || "x");
+            var ya2 = Axes.getFromId(gd2, trace.yaxis || "y");
+            var size, pos, origPos, pObj, hasPeriod, pLetter;
+            if (trace.orientation === "h") {
+              size = xa.makeCalcdata(trace, "x");
+              origPos = ya2.makeCalcdata(trace, "y");
+              pObj = alignPeriod(trace, ya2, "y", origPos);
+              hasPeriod = !!trace.yperiodalignment;
+              pLetter = "y";
+            } else {
+              size = ya2.makeCalcdata(trace, "y");
+              origPos = xa.makeCalcdata(trace, "x");
+              pObj = alignPeriod(trace, xa, "x", origPos);
+              hasPeriod = !!trace.xperiodalignment;
+              pLetter = "x";
+            }
+            pos = pObj.vals;
+            var serieslen = Math.min(pos.length, size.length);
+            var cd2 = new Array(serieslen);
+            var previousSum = 0;
+            var newSize;
+            var hasTotals = false;
+            for (var i2 = 0; i2 < serieslen; i2++) {
+              var amount = size[i2] || 0;
+              var connectToNext = false;
+              if (size[i2] !== BADNUM || isTotal(trace.measure[i2]) || isAbsolute(trace.measure[i2])) {
+                if (i2 + 1 < serieslen && (size[i2 + 1] !== BADNUM || isTotal(trace.measure[i2 + 1]) || isAbsolute(trace.measure[i2 + 1]))) {
+                  connectToNext = true;
+                }
+              }
+              var cdi = cd2[i2] = {
+                i: i2,
+                p: pos[i2],
+                s: amount,
+                rawS: amount,
+                cNext: connectToNext
+              };
+              if (isAbsolute(trace.measure[i2])) {
+                previousSum = cdi.s;
+                cdi.isSum = true;
+                cdi.dir = "totals";
+                cdi.s = previousSum;
+              } else if (isTotal(trace.measure[i2])) {
+                cdi.isSum = true;
+                cdi.dir = "totals";
+                cdi.s = previousSum;
+              } else {
+                cdi.isSum = false;
+                cdi.dir = cdi.rawS < 0 ? "decreasing" : "increasing";
+                newSize = cdi.s;
+                cdi.s = previousSum + newSize;
+                previousSum += newSize;
+              }
+              if (cdi.dir === "totals") {
+                hasTotals = true;
+              }
+              if (hasPeriod) {
+                cd2[i2].orig_p = origPos[i2];
+                cd2[i2][pLetter + "End"] = pObj.ends[i2];
+                cd2[i2][pLetter + "Start"] = pObj.starts[i2];
+              }
+              if (trace.ids) {
+                cdi.id = String(trace.ids[i2]);
+              }
+              cdi.v = (trace.base || 0) + previousSum;
+            }
+            if (cd2.length) cd2[0].hasTotals = hasTotals;
+            mergeArray(trace.text, cd2, "tx");
+            mergeArray(trace.hovertext, cd2, "htx");
+            calcSelection(cd2, trace);
+            return cd2;
+          };
+        }
+      });
+      var require_cross_trace_calc6 = __commonJS({
+        "src/traces/waterfall/cross_trace_calc.js"(exports, module2) {
+          var setGroupPositions = require_cross_trace_calc().setGroupPositions;
+          module2.exports = function crossTraceCalc(gd2, plotinfo) {
+            var fullLayout = gd2._fullLayout;
+            var fullData = gd2._fullData;
+            var calcdata = gd2.calcdata;
+            var xa = plotinfo.xaxis;
+            var ya2 = plotinfo.yaxis;
+            var waterfalls = [];
+            var waterfallsVert = [];
+            var waterfallsHorz = [];
+            var cd2, i2;
+            for (i2 = 0; i2 < fullData.length; i2++) {
+              var fullTrace = fullData[i2];
+              if (fullTrace.visible === true && fullTrace.xaxis === xa._id && fullTrace.yaxis === ya2._id && fullTrace.type === "waterfall") {
+                cd2 = calcdata[i2];
+                if (fullTrace.orientation === "h") {
+                  waterfallsHorz.push(cd2);
+                } else {
+                  waterfallsVert.push(cd2);
+                }
+                waterfalls.push(cd2);
+              }
+            }
+            var opts = {
+              mode: fullLayout.waterfallmode,
+              norm: fullLayout.waterfallnorm,
+              gap: fullLayout.waterfallgap,
+              groupgap: fullLayout.waterfallgroupgap
+            };
+            setGroupPositions(gd2, xa, ya2, waterfallsVert, opts);
+            setGroupPositions(gd2, ya2, xa, waterfallsHorz, opts);
+            for (i2 = 0; i2 < waterfalls.length; i2++) {
+              cd2 = waterfalls[i2];
+              for (var j2 = 0; j2 < cd2.length; j2++) {
+                var di2 = cd2[j2];
+                if (di2.isSum === false) {
+                  di2.s0 += j2 === 0 ? 0 : cd2[j2 - 1].s;
+                }
+                if (j2 + 1 < cd2.length) {
+                  cd2[j2].nextP0 = cd2[j2 + 1].p0;
+                  cd2[j2].nextS0 = cd2[j2 + 1].s0;
+                }
+              }
+            }
+          };
+        }
+      });
+      var require_plot10 = __commonJS({
+        "src/traces/waterfall/plot.js"(exports, module2) {
+          var d3 = require_d3();
+          var Lib = require_lib();
+          var Drawing = require_drawing();
+          var BADNUM = require_numerical().BADNUM;
+          var barPlot = require_plot3();
+          var clearMinTextSize = require_uniform_text().clearMinTextSize;
+          module2.exports = function plot(gd2, plotinfo, cdModule, traceLayer) {
+            var fullLayout = gd2._fullLayout;
+            clearMinTextSize("waterfall", fullLayout);
+            barPlot.plot(gd2, plotinfo, cdModule, traceLayer, {
+              mode: fullLayout.waterfallmode,
+              norm: fullLayout.waterfallmode,
+              gap: fullLayout.waterfallgap,
+              groupgap: fullLayout.waterfallgroupgap
+            });
+            plotConnectors(gd2, plotinfo, cdModule, traceLayer);
+          };
+          function plotConnectors(gd2, plotinfo, cdModule, traceLayer) {
+            var xa = plotinfo.xaxis;
+            var ya2 = plotinfo.yaxis;
+            Lib.makeTraceGroups(traceLayer, cdModule, "trace bars").each(function(cd2) {
+              var plotGroup = d3.select(this);
+              var trace = cd2[0].trace;
+              var group = Lib.ensureSingle(plotGroup, "g", "lines");
+              if (!trace.connector || !trace.connector.visible) {
+                group.remove();
+                return;
+              }
+              var isHorizontal = trace.orientation === "h";
+              var mode = trace.connector.mode;
+              var connectors = group.selectAll("g.line").data(Lib.identity);
+              connectors.enter().append("g").classed("line", true);
+              connectors.exit().remove();
+              var len2 = connectors.size();
+              connectors.each(function(di2, i2) {
+                if (i2 !== len2 - 1 && !di2.cNext) return;
+                var xy = getXY(di2, xa, ya2, isHorizontal);
+                var x2 = xy[0];
+                var y2 = xy[1];
+                var shape = "";
+                if (x2[0] !== BADNUM && y2[0] !== BADNUM && x2[1] !== BADNUM && y2[1] !== BADNUM) {
+                  if (mode === "spanning") {
+                    if (!di2.isSum && i2 > 0) {
+                      if (isHorizontal) {
+                        shape += "M" + x2[0] + "," + y2[1] + "V" + y2[0];
+                      } else {
+                        shape += "M" + x2[1] + "," + y2[0] + "H" + x2[0];
+                      }
+                    }
+                  }
+                  if (mode !== "between") {
+                    if (di2.isSum || i2 < len2 - 1) {
+                      if (isHorizontal) {
+                        shape += "M" + x2[1] + "," + y2[0] + "V" + y2[1];
+                      } else {
+                        shape += "M" + x2[0] + "," + y2[1] + "H" + x2[1];
+                      }
+                    }
+                  }
+                  if (x2[2] !== BADNUM && y2[2] !== BADNUM) {
+                    if (isHorizontal) {
+                      shape += "M" + x2[1] + "," + y2[1] + "V" + y2[2];
+                    } else {
+                      shape += "M" + x2[1] + "," + y2[1] + "H" + x2[2];
+                    }
+                  }
+                }
+                if (shape === "") shape = "M0,0Z";
+                Lib.ensureSingle(d3.select(this), "path").attr("d", shape).call(Drawing.setClipUrl, plotinfo.layerClipId, gd2);
+              });
+            });
+          }
+          function getXY(di2, xa, ya2, isHorizontal) {
+            var s2 = [];
+            var p2 = [];
+            var sAxis = isHorizontal ? xa : ya2;
+            var pAxis = isHorizontal ? ya2 : xa;
+            s2[0] = sAxis.c2p(di2.s0, true);
+            p2[0] = pAxis.c2p(di2.p0, true);
+            s2[1] = sAxis.c2p(di2.s1, true);
+            p2[1] = pAxis.c2p(di2.p1, true);
+            s2[2] = sAxis.c2p(di2.nextS0, true);
+            p2[2] = pAxis.c2p(di2.nextP0, true);
+            return isHorizontal ? [s2, p2] : [p2, s2];
+          }
+        }
+      });
+      var require_style10 = __commonJS({
+        "src/traces/waterfall/style.js"(exports, module2) {
+          var d3 = require_d3();
+          var Drawing = require_drawing();
+          var Color2 = require_color();
+          var DESELECTDIM = require_interactions().DESELECTDIM;
+          var barStyle = require_style4();
+          var resizeText = require_uniform_text().resizeText;
+          var styleTextPoints = barStyle.styleTextPoints;
+          function style(gd2, cd2, sel) {
+            var s2 = sel ? sel : d3.select(gd2).selectAll('g[class^="waterfalllayer"]').selectAll("g.trace");
+            resizeText(gd2, s2, "waterfall");
+            s2.style("opacity", function(d2) {
+              return d2[0].trace.opacity;
+            });
+            s2.each(function(d2) {
+              var gTrace = d3.select(this);
+              var trace = d2[0].trace;
+              gTrace.selectAll(".point > path").each(function(di2) {
+                if (!di2.isBlank) {
+                  var cont = trace[di2.dir].marker;
+                  d3.select(this).call(Color2.fill, cont.color).call(Color2.stroke, cont.line.color).call(Drawing.dashLine, cont.line.dash, cont.line.width).style("opacity", trace.selectedpoints && !di2.selected ? DESELECTDIM : 1);
+                }
+              });
+              styleTextPoints(gTrace, trace, gd2);
+              gTrace.selectAll(".lines").each(function() {
+                var cont = trace.connector.line;
+                Drawing.lineGroupStyle(
+                  d3.select(this).selectAll("path"),
+                  cont.width,
+                  cont.color,
+                  cont.dash
+                );
+              });
+            });
+          }
+          module2.exports = {
+            style
+          };
+        }
+      });
+      var require_hover12 = __commonJS({
+        "src/traces/waterfall/hover.js"(exports, module2) {
+          var hoverLabelText = require_axes().hoverLabelText;
+          var opacity = require_color().opacity;
+          var hoverOnBars = require_hover3().hoverOnBars;
+          var delta = require_delta();
+          var DIRSYMBOL = {
+            increasing: delta.INCREASING.SYMBOL,
+            decreasing: delta.DECREASING.SYMBOL
+          };
+          module2.exports = function hoverPoints(pointData, xval, yval, hovermode, opts) {
+            var point = hoverOnBars(pointData, xval, yval, hovermode, opts);
+            if (!point) return;
+            var cd2 = point.cd;
+            var trace = cd2[0].trace;
+            var isHorizontal = trace.orientation === "h";
+            var vLetter = isHorizontal ? "x" : "y";
+            var vAxis = isHorizontal ? pointData.xa : pointData.ya;
+            function formatNumber(a2) {
+              return hoverLabelText(vAxis, a2, trace[vLetter + "hoverformat"]);
+            }
+            var index = point.index;
+            var di2 = cd2[index];
+            var size = di2.isSum ? di2.b + di2.s : di2.rawS;
+            point.initial = di2.b + di2.s - size;
+            point.delta = size;
+            point.final = point.initial + point.delta;
+            var v2 = formatNumber(Math.abs(point.delta));
+            point.deltaLabel = size < 0 ? "(" + v2 + ")" : v2;
+            point.finalLabel = formatNumber(point.final);
+            point.initialLabel = formatNumber(point.initial);
+            var hoverinfo = di2.hi || trace.hoverinfo;
+            var text = [];
+            if (hoverinfo && hoverinfo !== "none" && hoverinfo !== "skip") {
+              var isAll = hoverinfo === "all";
+              var parts = hoverinfo.split("+");
+              var hasFlag = function(flag) {
+                return isAll || parts.indexOf(flag) !== -1;
+              };
+              if (!di2.isSum) {
+                if (hasFlag("final") && (isHorizontal ? !hasFlag("x") : !hasFlag("y"))) {
+                  text.push(point.finalLabel);
+                }
+                if (hasFlag("delta")) {
+                  if (size < 0) {
+                    text.push(point.deltaLabel + " " + DIRSYMBOL.decreasing);
+                  } else {
+                    text.push(point.deltaLabel + " " + DIRSYMBOL.increasing);
+                  }
+                }
+                if (hasFlag("initial")) {
+                  text.push("Initial: " + point.initialLabel);
+                }
+              }
+            }
+            if (text.length) point.extraText = text.join("<br>");
+            point.color = getTraceColor(trace, di2);
+            return [point];
+          };
+          function getTraceColor(trace, di2) {
+            var cont = trace[di2.dir].marker;
+            var mc2 = cont.color;
+            var mlc = cont.line.color;
+            var mlw = cont.line.width;
+            if (opacity(mc2)) return mc2;
+            else if (opacity(mlc) && mlw) return mlc;
+          }
+        }
+      });
+      var require_event_data6 = __commonJS({
+        "src/traces/waterfall/event_data.js"(exports, module2) {
+          module2.exports = function eventData(out, pt2) {
+            out.x = "xVal" in pt2 ? pt2.xVal : pt2.x;
+            out.y = "yVal" in pt2 ? pt2.yVal : pt2.y;
+            if ("initial" in pt2) out.initial = pt2.initial;
+            if ("delta" in pt2) out.delta = pt2.delta;
+            if ("final" in pt2) out.final = pt2.final;
+            if (pt2.xa) out.xaxis = pt2.xa;
+            if (pt2.ya) out.yaxis = pt2.ya;
+            return out;
+          };
+        }
+      });
+      var require_waterfall = __commonJS({
+        "src/traces/waterfall/index.js"(exports, module2) {
+          module2.exports = {
+            attributes: require_attributes33(),
+            layoutAttributes: require_layout_attributes11(),
+            supplyDefaults: require_defaults29().supplyDefaults,
+            crossTraceDefaults: require_defaults29().crossTraceDefaults,
+            supplyLayoutDefaults: require_layout_defaults10(),
+            calc: require_calc14(),
+            crossTraceCalc: require_cross_trace_calc6(),
+            plot: require_plot10(),
+            style: require_style10().style,
+            hoverPoints: require_hover12(),
+            eventData: require_event_data6(),
+            selectPoints: require_select3(),
+            moduleType: "trace",
+            name: "waterfall",
+            basePlotModule: require_cartesian(),
+            categories: ["bar-like", "cartesian", "svg", "oriented", "showLegend", "zoomScale"],
+            meta: {}
+          };
+        }
+      });
+      var require_waterfall2 = __commonJS({
+        "lib/waterfall.js"(exports, module2) {
+          module2.exports = require_waterfall();
+        }
+      });
+      var require_constants19 = __commonJS({
+        "src/traces/image/constants.js"(exports, module2) {
+          module2.exports = {
+            colormodel: {
+              // min and max define the numerical range accepted in CSS
+              // If z(min|max)Dflt are not defined, z(min|max) will default to min/max
+              rgb: {
+                min: [0, 0, 0],
+                max: [255, 255, 255],
+                fmt: function(c2) {
+                  return c2.slice(0, 3);
+                },
+                suffix: ["", "", ""]
+              },
+              rgba: {
+                min: [0, 0, 0, 0],
+                max: [255, 255, 255, 1],
+                fmt: function(c2) {
+                  return c2.slice(0, 4);
+                },
+                suffix: ["", "", "", ""]
+              },
+              rgba256: {
+                colormodel: "rgba",
+                // because rgba256 is not an accept colormodel in CSS
+                zminDflt: [0, 0, 0, 0],
+                zmaxDflt: [255, 255, 255, 255],
+                min: [0, 0, 0, 0],
+                max: [255, 255, 255, 1],
+                fmt: function(c2) {
+                  return c2.slice(0, 4);
+                },
+                suffix: ["", "", "", ""]
+              },
+              hsl: {
+                min: [0, 0, 0],
+                max: [360, 100, 100],
+                fmt: function(c2) {
+                  var p2 = c2.slice(0, 3);
+                  p2[1] = p2[1] + "%";
+                  p2[2] = p2[2] + "%";
+                  return p2;
+                },
+                suffix: ["°", "%", "%"]
+              },
+              hsla: {
+                min: [0, 0, 0, 0],
+                max: [360, 100, 100, 1],
+                fmt: function(c2) {
+                  var p2 = c2.slice(0, 4);
+                  p2[1] = p2[1] + "%";
+                  p2[2] = p2[2] + "%";
+                  return p2;
+                },
+                suffix: ["°", "%", "%", ""]
+              }
+            }
+          };
+        }
+      });
+      var require_attributes34 = __commonJS({
+        "src/traces/image/attributes.js"(exports, module2) {
+          var baseAttrs = require_attributes2();
+          var zorder = require_attributes12().zorder;
+          var { hovertemplateAttrs, templatefallbackAttrs } = require_template_attributes();
+          var extendFlat = require_extend().extendFlat;
+          var colormodel = require_constants19().colormodel;
+          var cm = ["rgb", "rgba", "rgba256", "hsl", "hsla"];
+          var zminDesc = [];
+          var zmaxDesc = [];
+          for (i2 = 0; i2 < cm.length; i2++) {
+            cr = colormodel[cm[i2]];
+            zminDesc.push("For the `" + cm[i2] + "` colormodel, it is [" + (cr.zminDflt || cr.min).join(", ") + "].");
+            zmaxDesc.push("For the `" + cm[i2] + "` colormodel, it is [" + (cr.zmaxDflt || cr.max).join(", ") + "].");
+          }
+          var cr;
+          var i2;
+          module2.exports = extendFlat({
+            source: {
+              valType: "string",
+              editType: "calc"
+            },
+            z: {
+              valType: "data_array",
+              editType: "calc"
+            },
+            colormodel: {
+              valType: "enumerated",
+              values: cm,
+              editType: "calc"
+            },
+            zsmooth: {
+              valType: "enumerated",
+              values: ["fast", false],
+              dflt: false,
+              editType: "plot"
+            },
+            zmin: {
+              valType: "info_array",
+              items: [
+                { valType: "number", editType: "calc" },
+                { valType: "number", editType: "calc" },
+                { valType: "number", editType: "calc" },
+                { valType: "number", editType: "calc" }
+              ],
+              editType: "calc"
+            },
+            zmax: {
+              valType: "info_array",
+              items: [
+                { valType: "number", editType: "calc" },
+                { valType: "number", editType: "calc" },
+                { valType: "number", editType: "calc" },
+                { valType: "number", editType: "calc" }
+              ],
+              editType: "calc"
+            },
+            x0: {
+              valType: "any",
+              dflt: 0,
+              editType: "calc+clearAxisTypes"
+            },
+            y0: {
+              valType: "any",
+              dflt: 0,
+              editType: "calc+clearAxisTypes"
+            },
+            dx: {
+              valType: "number",
+              dflt: 1,
+              editType: "calc",
+              description: "Set the pixel's horizontal size."
+            },
+            dy: {
+              valType: "number",
+              dflt: 1,
+              editType: "calc",
+              description: "Set the pixel's vertical size"
+            },
+            text: {
+              valType: "data_array",
+              editType: "plot"
+            },
+            hovertext: {
+              valType: "data_array",
+              editType: "plot"
+            },
+            hoverinfo: extendFlat({}, baseAttrs.hoverinfo, {
+              flags: ["x", "y", "z", "color", "name", "text"],
+              dflt: "x+y+z+text+name"
+            }),
+            hovertemplate: hovertemplateAttrs({}, { keys: ["z", "color", "colormodel"] }),
+            hovertemplatefallback: templatefallbackAttrs(),
+            zorder
+          });
+        }
+      });
+      var require_defaults30 = __commonJS({
+        "src/traces/image/defaults.js"(exports, module2) {
+          var Lib = require_lib();
+          var attributes = require_attributes34();
+          var constants = require_constants19();
+          var dataUri = require_helpers10().IMAGE_URL_PREFIX;
+          module2.exports = function supplyDefaults(traceIn, traceOut) {
+            function coerce(attr, dflt) {
+              return Lib.coerce(traceIn, traceOut, attributes, attr, dflt);
+            }
+            coerce("source");
+            if (traceOut.source && !traceOut.source.match(dataUri)) delete traceOut.source;
+            traceOut._hasSource = !!traceOut.source;
+            var z2 = coerce("z");
+            traceOut._hasZ = !(z2 === void 0 || !z2.length || !z2[0] || !z2[0].length);
+            if (!traceOut._hasZ && !traceOut._hasSource) {
+              traceOut.visible = false;
+              return;
+            }
+            coerce("x0");
+            coerce("y0");
+            coerce("dx");
+            coerce("dy");
+            var cm;
+            if (traceOut._hasZ) {
+              coerce("colormodel", "rgb");
+              cm = constants.colormodel[traceOut.colormodel];
+              coerce("zmin", cm.zminDflt || cm.min);
+              coerce("zmax", cm.zmaxDflt || cm.max);
+            } else if (traceOut._hasSource) {
+              traceOut.colormodel = "rgba256";
+              cm = constants.colormodel[traceOut.colormodel];
+              traceOut.zmin = cm.zminDflt;
+              traceOut.zmax = cm.zmaxDflt;
+            }
+            coerce("zsmooth");
+            coerce("text");
+            coerce("hovertext");
+            coerce("hovertemplate");
+            coerce("hovertemplatefallback");
+            traceOut._length = null;
+            coerce("zorder");
+          };
+        }
+      });
+      var require_inherits_browser = __commonJS({
+        "node_modules/inherits/inherits_browser.js"(exports, module2) {
+          if (typeof Object.create === "function") {
+            module2.exports = function inherits(ctor, superCtor) {
+              if (superCtor) {
+                ctor.super_ = superCtor;
+                ctor.prototype = Object.create(superCtor.prototype, {
+                  constructor: {
+                    value: ctor,
+                    enumerable: false,
+                    writable: true,
+                    configurable: true
+                  }
+                });
+              }
+            };
+          } else {
+            module2.exports = function inherits(ctor, superCtor) {
+              if (superCtor) {
+                ctor.super_ = superCtor;
+                var TempCtor = function() {
+                };
+                TempCtor.prototype = superCtor.prototype;
+                ctor.prototype = new TempCtor();
+                ctor.prototype.constructor = ctor;
+              }
+            };
+          }
+        }
+      });
+      var require_stream_browser = __commonJS({
+        "node_modules/stream-browserify/node_modules/readable-stream/lib/internal/streams/stream-browser.js"(exports, module2) {
+          module2.exports = require_events().EventEmitter;
+        }
+      });
+      var require_base64_js = __commonJS({
+        "node_modules/base64-js/index.js"(exports) {
+          exports.byteLength = byteLength;
+          exports.toByteArray = toByteArray;
+          exports.fromByteArray = fromByteArray;
+          var lookup = [];
+          var revLookup = [];
+          var Arr = typeof Uint8Array !== "undefined" ? Uint8Array : Array;
+          var code = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
+          for (i2 = 0, len2 = code.length; i2 < len2; ++i2) {
+            lookup[i2] = code[i2];
+            revLookup[code.charCodeAt(i2)] = i2;
+          }
+          var i2;
+          var len2;
+          revLookup["-".charCodeAt(0)] = 62;
+          revLookup["_".charCodeAt(0)] = 63;
+          function getLens(b64) {
+            var len22 = b64.length;
+            if (len22 % 4 > 0) {
+              throw new Error("Invalid string. Length must be a multiple of 4");
+            }
+            var validLen = b64.indexOf("=");
+            if (validLen === -1) validLen = len22;
+            var placeHoldersLen = validLen === len22 ? 0 : 4 - validLen % 4;
+            return [validLen, placeHoldersLen];
+          }
+          function byteLength(b64) {
+            var lens = getLens(b64);
+            var validLen = lens[0];
+            var placeHoldersLen = lens[1];
+            return (validLen + placeHoldersLen) * 3 / 4 - placeHoldersLen;
+          }
+          function _byteLength(b64, validLen, placeHoldersLen) {
+            return (validLen + placeHoldersLen) * 3 / 4 - placeHoldersLen;
+          }
+          function toByteArray(b64) {
+            var tmp2;
+            var lens = getLens(b64);
+            var validLen = lens[0];
+            var placeHoldersLen = lens[1];
+            var arr = new Arr(_byteLength(b64, validLen, placeHoldersLen));
+            var curByte = 0;
+            var len22 = placeHoldersLen > 0 ? validLen - 4 : validLen;
+            var i22;
+            for (i22 = 0; i22 < len22; i22 += 4) {
+              tmp2 = revLookup[b64.charCodeAt(i22)] << 18 | revLookup[b64.charCodeAt(i22 + 1)] << 12 | revLookup[b64.charCodeAt(i22 + 2)] << 6 | revLookup[b64.charCodeAt(i22 + 3)];
+              arr[curByte++] = tmp2 >> 16 & 255;
+              arr[curByte++] = tmp2 >> 8 & 255;
+              arr[curByte++] = tmp2 & 255;
+            }
+            if (placeHoldersLen === 2) {
+              tmp2 = revLookup[b64.charCodeAt(i22)] << 2 | revLookup[b64.charCodeAt(i22 + 1)] >> 4;
+              arr[curByte++] = tmp2 & 255;
+            }
+            if (placeHoldersLen === 1) {
+              tmp2 = revLookup[b64.charCodeAt(i22)] << 10 | revLookup[b64.charCodeAt(i22 + 1)] << 4 | revLookup[b64.charCodeAt(i22 + 2)] >> 2;
+              arr[curByte++] = tmp2 >> 8 & 255;
+              arr[curByte++] = tmp2 & 255;
+            }
+            return arr;
+          }
+          function tripletToBase64(num) {
+            return lookup[num >> 18 & 63] + lookup[num >> 12 & 63] + lookup[num >> 6 & 63] + lookup[num & 63];
+          }
+          function encodeChunk(uint8, start, end) {
+            var tmp2;
+            var output = [];
+            for (var i22 = start; i22 < end; i22 += 3) {
+              tmp2 = (uint8[i22] << 16 & 16711680) + (uint8[i22 + 1] << 8 & 65280) + (uint8[i22 + 2] & 255);
+              output.push(tripletToBase64(tmp2));
+            }
+            return output.join("");
+          }
+          function fromByteArray(uint8) {
+            var tmp2;
+            var len22 = uint8.length;
+            var extraBytes = len22 % 3;
+            var parts = [];
+            var maxChunkLength = 16383;
+            for (var i22 = 0, len222 = len22 - extraBytes; i22 < len222; i22 += maxChunkLength) {
+              parts.push(encodeChunk(
+                uint8,
+                i22,
+                i22 + maxChunkLength > len222 ? len222 : i22 + maxChunkLength
+              ));
+            }
+            if (extraBytes === 1) {
+              tmp2 = uint8[len22 - 1];
+              parts.push(
+                lookup[tmp2 >> 2] + lookup[tmp2 << 4 & 63] + "=="
+              );
+            } else if (extraBytes === 2) {
+              tmp2 = (uint8[len22 - 2] << 8) + uint8[len22 - 1];
+              parts.push(
+                lookup[tmp2 >> 10] + lookup[tmp2 >> 4 & 63] + lookup[tmp2 << 2 & 63] + "="
+              );
+            }
+            return parts.join("");
+          }
+        }
+      });
+      var require_ieee754 = __commonJS({
+        "node_modules/ieee754/index.js"(exports) {
+          exports.read = function(buffer, offset, isLE, mLen, nBytes) {
+            var e2, m2;
+            var eLen = nBytes * 8 - mLen - 1;
+            var eMax = (1 << eLen) - 1;
+            var eBias = eMax >> 1;
+            var nBits = -7;
+            var i2 = isLE ? nBytes - 1 : 0;
+            var d2 = isLE ? -1 : 1;
+            var s2 = buffer[offset + i2];
+            i2 += d2;
+            e2 = s2 & (1 << -nBits) - 1;
+            s2 >>= -nBits;
+            nBits += eLen;
+            for (; nBits > 0; e2 = e2 * 256 + buffer[offset + i2], i2 += d2, nBits -= 8) {
+            }
+            m2 = e2 & (1 << -nBits) - 1;
+            e2 >>= -nBits;
+            nBits += mLen;
+            for (; nBits > 0; m2 = m2 * 256 + buffer[offset + i2], i2 += d2, nBits -= 8) {
+            }
+            if (e2 === 0) {
+              e2 = 1 - eBias;
+            } else if (e2 === eMax) {
+              return m2 ? NaN : (s2 ? -1 : 1) * Infinity;
+            } else {
+              m2 = m2 + Math.pow(2, mLen);
+              e2 = e2 - eBias;
+            }
+            return (s2 ? -1 : 1) * m2 * Math.pow(2, e2 - mLen);
+          };
+          exports.write = function(buffer, value, offset, isLE, mLen, nBytes) {
+            var e2, m2, c2;
+            var eLen = nBytes * 8 - mLen - 1;
+            var eMax = (1 << eLen) - 1;
+            var eBias = eMax >> 1;
+            var rt2 = mLen === 23 ? Math.pow(2, -24) - Math.pow(2, -77) : 0;
+            var i2 = isLE ? 0 : nBytes - 1;
+            var d2 = isLE ? 1 : -1;
+            var s2 = value < 0 || value === 0 && 1 / value < 0 ? 1 : 0;
+            value = Math.abs(value);
+            if (isNaN(value) || value === Infinity) {
+              m2 = isNaN(value) ? 1 : 0;
+              e2 = eMax;
+            } else {
+              e2 = Math.floor(Math.log(value) / Math.LN2);
+              if (value * (c2 = Math.pow(2, -e2)) < 1) {
+                e2--;
+                c2 *= 2;
+              }
+              if (e2 + eBias >= 1) {
+                value += rt2 / c2;
+              } else {
+                value += rt2 * Math.pow(2, 1 - eBias);
+              }
+              if (value * c2 >= 2) {
+                e2++;
+                c2 /= 2;
+              }
+              if (e2 + eBias >= eMax) {
+                m2 = 0;
+                e2 = eMax;
+              } else if (e2 + eBias >= 1) {
+                m2 = (value * c2 - 1) * Math.pow(2, mLen);
+                e2 = e2 + eBias;
+              } else {
+                m2 = value * Math.pow(2, eBias - 1) * Math.pow(2, mLen);
+                e2 = 0;
+              }
+            }
+            for (; mLen >= 8; buffer[offset + i2] = m2 & 255, i2 += d2, m2 /= 256, mLen -= 8) {
+            }
+            e2 = e2 << mLen | m2;
+            eLen += mLen;
+            for (; eLen > 0; buffer[offset + i2] = e2 & 255, i2 += d2, e2 /= 256, eLen -= 8) {
+            }
+            buffer[offset + i2 - d2] |= s2 * 128;
+          };
+        }
+      });
+      var require_buffer = __commonJS({
+        "node_modules/buffer/index.js"(exports) {
+          var base64 = require_base64_js();
+          var ieee754 = require_ieee754();
+          var customInspectSymbol = typeof Symbol === "function" && typeof Symbol["for"] === "function" ? Symbol["for"]("nodejs.util.inspect.custom") : null;
+          exports.Buffer = Buffer22;
+          exports.SlowBuffer = SlowBuffer;
+          exports.INSPECT_MAX_BYTES = 50;
+          var K_MAX_LENGTH = 2147483647;
+          exports.kMaxLength = K_MAX_LENGTH;
+          Buffer22.TYPED_ARRAY_SUPPORT = typedArraySupport();
+          if (!Buffer22.TYPED_ARRAY_SUPPORT && typeof console !== "undefined" && typeof console.error === "function") {
+            console.error(
+              "This browser lacks typed array (Uint8Array) support which is required by `buffer` v5.x. Use `buffer` v4.x if you require old browser support."
+            );
+          }
+          function typedArraySupport() {
+            try {
+              const arr = new Uint8Array(1);
+              const proto = { foo: function() {
+                return 42;
+              } };
+              Object.setPrototypeOf(proto, Uint8Array.prototype);
+              Object.setPrototypeOf(arr, proto);
+              return arr.foo() === 42;
+            } catch (e2) {
+              return false;
+            }
+          }
+          Object.defineProperty(Buffer22.prototype, "parent", {
+            enumerable: true,
+            get: function() {
+              if (!Buffer22.isBuffer(this)) return void 0;
+              return this.buffer;
+            }
+          });
+          Object.defineProperty(Buffer22.prototype, "offset", {
+            enumerable: true,
+            get: function() {
+              if (!Buffer22.isBuffer(this)) return void 0;
+              return this.byteOffset;
+            }
+          });
+          function createBuffer(length2) {
+            if (length2 > K_MAX_LENGTH) {
+              throw new RangeError('The value "' + length2 + '" is invalid for option "size"');
+            }
+            const buf = new Uint8Array(length2);
+            Object.setPrototypeOf(buf, Buffer22.prototype);
+            return buf;
+          }
+          function Buffer22(arg, encodingOrOffset, length2) {
+            if (typeof arg === "number") {
+              if (typeof encodingOrOffset === "string") {
+                throw new TypeError(
+                  'The "string" argument must be of type string. Received type number'
+                );
+              }
+              return allocUnsafe(arg);
+            }
+            return from(arg, encodingOrOffset, length2);
+          }
+          Buffer22.poolSize = 8192;
+          function from(value, encodingOrOffset, length2) {
+            if (typeof value === "string") {
+              return fromString(value, encodingOrOffset);
+            }
+            if (ArrayBuffer.isView(value)) {
+              return fromArrayView(value);
+            }
+            if (value == null) {
+              throw new TypeError(
+                "The first argument must be one of type string, Buffer, ArrayBuffer, Array, or Array-like Object. Received type " + typeof value
+              );
+            }
+            if (isInstance(value, ArrayBuffer) || value && isInstance(value.buffer, ArrayBuffer)) {
+              return fromArrayBuffer(value, encodingOrOffset, length2);
+            }
+            if (typeof SharedArrayBuffer !== "undefined" && (isInstance(value, SharedArrayBuffer) || value && isInstance(value.buffer, SharedArrayBuffer))) {
+              return fromArrayBuffer(value, encodingOrOffset, length2);
+            }
+            if (typeof value === "number") {
+              throw new TypeError(
+                'The "value" argument must not be of type number. Received type number'
+              );
+            }
+            const valueOf = value.valueOf && value.valueOf();
+            if (valueOf != null && valueOf !== value) {
+              return Buffer22.from(valueOf, encodingOrOffset, length2);
+            }
+            const b2 = fromObject(value);
+            if (b2) return b2;
+            if (typeof Symbol !== "undefined" && Symbol.toPrimitive != null && typeof value[Symbol.toPrimitive] === "function") {
+              return Buffer22.from(value[Symbol.toPrimitive]("string"), encodingOrOffset, length2);
+            }
+            throw new TypeError(
+              "The first argument must be one of type string, Buffer, ArrayBuffer, Array, or Array-like Object. Received type " + typeof value
+            );
+          }
+          Buffer22.from = function(value, encodingOrOffset, length2) {
+            return from(value, encodingOrOffset, length2);
+          };
+          Object.setPrototypeOf(Buffer22.prototype, Uint8Array.prototype);
+          Object.setPrototypeOf(Buffer22, Uint8Array);
+          function assertSize(size) {
+            if (typeof size !== "number") {
+              throw new TypeError('"size" argument must be of type number');
+            } else if (size < 0) {
+              throw new RangeError('The value "' + size + '" is invalid for option "size"');
+            }
+          }
+          function alloc(size, fill, encoding) {
+            assertSize(size);
+            if (size <= 0) {
+              return createBuffer(size);
+            }
+            if (fill !== void 0) {
+              return typeof encoding === "string" ? createBuffer(size).fill(fill, encoding) : createBuffer(size).fill(fill);
+            }
+            return createBuffer(size);
+          }
+          Buffer22.alloc = function(size, fill, encoding) {
+            return alloc(size, fill, encoding);
+          };
+          function allocUnsafe(size) {
+            assertSize(size);
+            return createBuffer(size < 0 ? 0 : checked(size) | 0);
+          }
+          Buffer22.allocUnsafe = function(size) {
+            return allocUnsafe(size);
+          };
+          Buffer22.allocUnsafeSlow = function(size) {
+            return allocUnsafe(size);
+          };
+          function fromString(string, encoding) {
+            if (typeof encoding !== "string" || encoding === "") {
+              encoding = "utf8";
+            }
+            if (!Buffer22.isEncoding(encoding)) {
+              throw new TypeError("Unknown encoding: " + encoding);
+            }
+            const length2 = byteLength(string, encoding) | 0;
+            let buf = createBuffer(length2);
+            const actual = buf.write(string, encoding);
+            if (actual !== length2) {
+              buf = buf.slice(0, actual);
+            }
+            return buf;
+          }
+          function fromArrayLike(array) {
+            const length2 = array.length < 0 ? 0 : checked(array.length) | 0;
+            const buf = createBuffer(length2);
+            for (let i2 = 0; i2 < length2; i2 += 1) {
+              buf[i2] = array[i2] & 255;
+            }
+            return buf;
+          }
+          function fromArrayView(arrayView) {
+            if (isInstance(arrayView, Uint8Array)) {
+              const copy = new Uint8Array(arrayView);
+              return fromArrayBuffer(copy.buffer, copy.byteOffset, copy.byteLength);
+            }
+            return fromArrayLike(arrayView);
+          }
+          function fromArrayBuffer(array, byteOffset, length2) {
+            if (byteOffset < 0 || array.byteLength < byteOffset) {
+              throw new RangeError('"offset" is outside of buffer bounds');
+            }
+            if (array.byteLength < byteOffset + (length2 || 0)) {
+              throw new RangeError('"length" is outside of buffer bounds');
+            }
+            let buf;
+            if (byteOffset === void 0 && length2 === void 0) {
+              buf = new Uint8Array(array);
+            } else if (length2 === void 0) {
+              buf = new Uint8Array(array, byteOffset);
+            } else {
+              buf = new Uint8Array(array, byteOffset, length2);
+            }
+            Object.setPrototypeOf(buf, Buffer22.prototype);
+            return buf;
+          }
+          function fromObject(obj) {
+            if (Buffer22.isBuffer(obj)) {
+              const len2 = checked(obj.length) | 0;
+              const buf = createBuffer(len2);
+              if (buf.length === 0) {
+                return buf;
+              }
+              obj.copy(buf, 0, 0, len2);
+              return buf;
+            }
+            if (obj.length !== void 0) {
+              if (typeof obj.length !== "number" || numberIsNaN(obj.length)) {
+                return createBuffer(0);
+              }
+              return fromArrayLike(obj);
+            }
+            if (obj.type === "Buffer" && Array.isArray(obj.data)) {
+              return fromArrayLike(obj.data);
+            }
+          }
+          function checked(length2) {
+            if (length2 >= K_MAX_LENGTH) {
+              throw new RangeError("Attempt to allocate Buffer larger than maximum size: 0x" + K_MAX_LENGTH.toString(16) + " bytes");
+            }
+            return length2 | 0;
+          }
+          function SlowBuffer(length2) {
+            if (+length2 != length2) {
+              length2 = 0;
+            }
+            return Buffer22.alloc(+length2);
+          }
+          Buffer22.isBuffer = function isBuffer2(b2) {
+            return b2 != null && b2._isBuffer === true && b2 !== Buffer22.prototype;
+          };
+          Buffer22.compare = function compare(a2, b2) {
+            if (isInstance(a2, Uint8Array)) a2 = Buffer22.from(a2, a2.offset, a2.byteLength);
+            if (isInstance(b2, Uint8Array)) b2 = Buffer22.from(b2, b2.offset, b2.byteLength);
+            if (!Buffer22.isBuffer(a2) || !Buffer22.isBuffer(b2)) {
+              throw new TypeError(
+                'The "buf1", "buf2" arguments must be one of type Buffer or Uint8Array'
+              );
+            }
+            if (a2 === b2) return 0;
+            let x2 = a2.length;
+            let y2 = b2.length;
+            for (let i2 = 0, len2 = Math.min(x2, y2); i2 < len2; ++i2) {
+              if (a2[i2] !== b2[i2]) {
+                x2 = a2[i2];
+                y2 = b2[i2];
+                break;
+              }
+            }
+            if (x2 < y2) return -1;
+            if (y2 < x2) return 1;
+            return 0;
+          };
+          Buffer22.isEncoding = function isEncoding(encoding) {
+            switch (String(encoding).toLowerCase()) {
+              case "hex":
+              case "utf8":
+              case "utf-8":
+              case "ascii":
+              case "latin1":
+              case "binary":
+              case "base64":
+              case "ucs2":
+              case "ucs-2":
+              case "utf16le":
+              case "utf-16le":
+                return true;
+              default:
+                return false;
+            }
+          };
+          Buffer22.concat = function concat(list, length2) {
+            if (!Array.isArray(list)) {
+              throw new TypeError('"list" argument must be an Array of Buffers');
+            }
+            if (list.length === 0) {
+              return Buffer22.alloc(0);
+            }
+            let i2;
+            if (length2 === void 0) {
+              length2 = 0;
+              for (i2 = 0; i2 < list.length; ++i2) {
+                length2 += list[i2].length;
+              }
+            }
+            const buffer = Buffer22.allocUnsafe(length2);
+            let pos = 0;
+            for (i2 = 0; i2 < list.length; ++i2) {
+              let buf = list[i2];
+              if (isInstance(buf, Uint8Array)) {
+                if (pos + buf.length > buffer.length) {
+                  if (!Buffer22.isBuffer(buf)) buf = Buffer22.from(buf);
+                  buf.copy(buffer, pos);
+                } else {
+                  Uint8Array.prototype.set.call(
+                    buffer,
+                    buf,
+                    pos
+                  );
+                }
+              } else if (!Buffer22.isBuffer(buf)) {
+                throw new TypeError('"list" argument must be an Array of Buffers');
+              } else {
+                buf.copy(buffer, pos);
+              }
+              pos += buf.length;
+            }
+            return buffer;
+          };
+          function byteLength(string, encoding) {
+            if (Buffer22.isBuffer(string)) {
+              return string.length;
+            }
+            if (ArrayBuffer.isView(string) || isInstance(string, ArrayBuffer)) {
+              return string.byteLength;
+            }
+            if (typeof string !== "string") {
+              throw new TypeError(
+                'The "string" argument must be one of type string, Buffer, or ArrayBuffer. Received type ' + typeof string
+              );
+            }
+            const len2 = string.length;
+            const mustMatch = arguments.length > 2 && arguments[2] === true;
+            if (!mustMatch && len2 === 0) return 0;
+            let loweredCase = false;
+            for (; ; ) {
+              switch (encoding) {
+                case "ascii":
+                case "latin1":
+                case "binary":
+                  return len2;
+                case "utf8":
+                case "utf-8":
+                  return utf8ToBytes(string).length;
+                case "ucs2":
+                case "ucs-2":
+                case "utf16le":
+                case "utf-16le":
+                  return len2 * 2;
+                case "hex":
+                  return len2 >>> 1;
+                case "base64":
+                  return base64ToBytes(string).length;
+                default:
+                  if (loweredCase) {
+                    return mustMatch ? -1 : utf8ToBytes(string).length;
+                  }
+                  encoding = ("" + encoding).toLowerCase();
+                  loweredCase = true;
+              }
+            }
+          }
+          Buffer22.byteLength = byteLength;
+          function slowToString(encoding, start, end) {
+            let loweredCase = false;
+            if (start === void 0 || start < 0) {
+              start = 0;
+            }
+            if (start > this.length) {
+              return "";
+            }
+            if (end === void 0 || end > this.length) {
+              end = this.length;
+            }
+            if (end <= 0) {
+              return "";
+            }
+            end >>>= 0;
+            start >>>= 0;
+            if (end <= start) {
+              return "";
+            }
+            if (!encoding) encoding = "utf8";
+            while (true) {
+              switch (encoding) {
+                case "hex":
+                  return hexSlice(this, start, end);
+                case "utf8":
+                case "utf-8":
+                  return utf8Slice(this, start, end);
+                case "ascii":
+                  return asciiSlice(this, start, end);
+                case "latin1":
+                case "binary":
+                  return latin1Slice(this, start, end);
+                case "base64":
+                  return base64Slice(this, start, end);
+                case "ucs2":
+                case "ucs-2":
+                case "utf16le":
+                case "utf-16le":
+                  return utf16leSlice(this, start, end);
+                default:
+                  if (loweredCase) throw new TypeError("Unknown encoding: " + encoding);
+                  encoding = (encoding + "").toLowerCase();
+                  loweredCase = true;
+              }
+            }
+          }
+          Buffer22.prototype._isBuffer = true;
+          function swap(b2, n2, m2) {
+            const i2 = b2[n2];
+            b2[n2] = b2[m2];
+            b2[m2] = i2;
+          }
+          Buffer22.prototype.swap16 = function swap16() {
+            const len2 = this.length;
+            if (len2 % 2 !== 0) {
+              throw new RangeError("Buffer size must be a multiple of 16-bits");
+            }
+            for (let i2 = 0; i2 < len2; i2 += 2) {
+              swap(this, i2, i2 + 1);
+            }
+            return this;
+          };
+          Buffer22.prototype.swap32 = function swap32() {
+            const len2 = this.length;
+            if (len2 % 4 !== 0) {
+              throw new RangeError("Buffer size must be a multiple of 32-bits");
+            }
+            for (let i2 = 0; i2 < len2; i2 += 4) {
+              swap(this, i2, i2 + 3);
+              swap(this, i2 + 1, i2 + 2);
+            }
+            return this;
+          };
+          Buffer22.prototype.swap64 = function swap64() {
+            const len2 = this.length;
+            if (len2 % 8 !== 0) {
+              throw new RangeError("Buffer size must be a multiple of 64-bits");
+            }
+            for (let i2 = 0; i2 < len2; i2 += 8) {
+              swap(this, i2, i2 + 7);
+              swap(this, i2 + 1, i2 + 6);
+              swap(this, i2 + 2, i2 + 5);
+              swap(this, i2 + 3, i2 + 4);
+            }
+            return this;
+          };
+          Buffer22.prototype.toString = function toString() {
+            const length2 = this.length;
+            if (length2 === 0) return "";
+            if (arguments.length === 0) return utf8Slice(this, 0, length2);
+            return slowToString.apply(this, arguments);
+          };
+          Buffer22.prototype.toLocaleString = Buffer22.prototype.toString;
+          Buffer22.prototype.equals = function equals2(b2) {
+            if (!Buffer22.isBuffer(b2)) throw new TypeError("Argument must be a Buffer");
+            if (this === b2) return true;
+            return Buffer22.compare(this, b2) === 0;
+          };
+          Buffer22.prototype.inspect = function inspect() {
+            let str = "";
+            const max = exports.INSPECT_MAX_BYTES;
+            str = this.toString("hex", 0, max).replace(/(.{2})/g, "$1 ").trim();
+            if (this.length > max) str += " ... ";
+            return "<Buffer " + str + ">";
+          };
+          if (customInspectSymbol) {
+            Buffer22.prototype[customInspectSymbol] = Buffer22.prototype.inspect;
+          }
+          Buffer22.prototype.compare = function compare(target, start, end, thisStart, thisEnd) {
+            if (isInstance(target, Uint8Array)) {
+              target = Buffer22.from(target, target.offset, target.byteLength);
+            }
+            if (!Buffer22.isBuffer(target)) {
+              throw new TypeError(
+                'The "target" argument must be one of type Buffer or Uint8Array. Received type ' + typeof target
+              );
+            }
+            if (start === void 0) {
+              start = 0;
+            }
+            if (end === void 0) {
+              end = target ? target.length : 0;
+            }
+            if (thisStart === void 0) {
+              thisStart = 0;
+            }
+            if (thisEnd === void 0) {
+              thisEnd = this.length;
+            }
+            if (start < 0 || end > target.length || thisStart < 0 || thisEnd > this.length) {
+              throw new RangeError("out of range index");
+            }
+            if (thisStart >= thisEnd && start >= end) {
+              return 0;
+            }
+            if (thisStart >= thisEnd) {
+              return -1;
+            }
+            if (start >= end) {
+              return 1;
+            }
+            start >>>= 0;
+            end >>>= 0;
+            thisStart >>>= 0;
+            thisEnd >>>= 0;
+            if (this === target) return 0;
+            let x2 = thisEnd - thisStart;
+            let y2 = end - start;
+            const len2 = Math.min(x2, y2);
+            const thisCopy = this.slice(thisStart, thisEnd);
+            const targetCopy = target.slice(start, end);
+            for (let i2 = 0; i2 < len2; ++i2) {
+              if (thisCopy[i2] !== targetCopy[i2]) {
+                x2 = thisCopy[i2];
+                y2 = targetCopy[i2];
+                break;
+              }
+            }
+            if (x2 < y2) return -1;
+            if (y2 < x2) return 1;
+            return 0;
+          };
+          function bidirectionalIndexOf(buffer, val, byteOffset, encoding, dir) {
+            if (buffer.length === 0) return -1;
+            if (typeof byteOffset === "string") {
+              encoding = byteOffset;
+              byteOffset = 0;
+            } else if (byteOffset > 2147483647) {
+              byteOffset = 2147483647;
+            } else if (byteOffset < -2147483648) {
+              byteOffset = -2147483648;
+            }
+            byteOffset = +byteOffset;
+            if (numberIsNaN(byteOffset)) {
+              byteOffset = dir ? 0 : buffer.length - 1;
+            }
+            if (byteOffset < 0) byteOffset = buffer.length + byteOffset;
+            if (byteOffset >= buffer.length) {
+              if (dir) return -1;
+              else byteOffset = buffer.length - 1;
+            } else if (byteOffset < 0) {
+              if (dir) byteOffset = 0;
+              else return -1;
+            }
+            if (typeof val === "string") {
+              val = Buffer22.from(val, encoding);
+            }
+            if (Buffer22.isBuffer(val)) {
+              if (val.length === 0) {
+                return -1;
+              }
+              return arrayIndexOf(buffer, val, byteOffset, encoding, dir);
+            } else if (typeof val === "number") {
+              val = val & 255;
+              if (typeof Uint8Array.prototype.indexOf === "function") {
+                if (dir) {
+                  return Uint8Array.prototype.indexOf.call(buffer, val, byteOffset);
+                } else {
+                  return Uint8Array.prototype.lastIndexOf.call(buffer, val, byteOffset);
+                }
+              }
+              return arrayIndexOf(buffer, [val], byteOffset, encoding, dir);
+            }
+            throw new TypeError("val must be string, number or Buffer");
+          }
+          function arrayIndexOf(arr, val, byteOffset, encoding, dir) {
+            let indexSize = 1;
+            let arrLength = arr.length;
+            let valLength = val.length;
+            if (encoding !== void 0) {
+              encoding = String(encoding).toLowerCase();
+              if (encoding === "ucs2" || encoding === "ucs-2" || encoding === "utf16le" || encoding === "utf-16le") {
+                if (arr.length < 2 || val.length < 2) {
+                  return -1;
+                }
+                indexSize = 2;
+                arrLength /= 2;
+                valLength /= 2;
+                byteOffset /= 2;
+              }
+            }
+            function read(buf, i22) {
+              if (indexSize === 1) {
+                return buf[i22];
+              } else {
+                return buf.readUInt16BE(i22 * indexSize);
+              }
+            }
+            let i2;
+            if (dir) {
+              let foundIndex = -1;
+              for (i2 = byteOffset; i2 < arrLength; i2++) {
+                if (read(arr, i2) === read(val, foundIndex === -1 ? 0 : i2 - foundIndex)) {
+                  if (foundIndex === -1) foundIndex = i2;
+                  if (i2 - foundIndex + 1 === valLength) return foundIndex * indexSize;
+                } else {
+                  if (foundIndex !== -1) i2 -= i2 - foundIndex;
+                  foundIndex = -1;
+                }
+              }
+            } else {
+              if (byteOffset + valLength > arrLength) byteOffset = arrLength - valLength;
+              for (i2 = byteOffset; i2 >= 0; i2--) {
+                let found = true;
+                for (let j2 = 0; j2 < valLength; j2++) {
+                  if (read(arr, i2 + j2) !== read(val, j2)) {
+                    found = false;
+                    break;
+                  }
+                }
+                if (found) return i2;
+              }
+            }
+            return -1;
+          }
+          Buffer22.prototype.includes = function includes(val, byteOffset, encoding) {
+            return this.indexOf(val, byteOffset, encoding) !== -1;
+          };
+          Buffer22.prototype.indexOf = function indexOf(val, byteOffset, encoding) {
+            return bidirectionalIndexOf(this, val, byteOffset, encoding, true);
+          };
+          Buffer22.prototype.lastIndexOf = function lastIndexOf(val, byteOffset, encoding) {
+            return bidirectionalIndexOf(this, val, byteOffset, encoding, false);
+          };
+          function hexWrite(buf, string, offset, length2) {
+            offset = Number(offset) || 0;
+            const remaining = buf.length - offset;
+            if (!length2) {
+              length2 = remaining;
+            } else {
+              length2 = Number(length2);
+              if (length2 > remaining) {
+                length2 = remaining;
+              }
+            }
+            const strLen = string.length;
+            if (length2 > strLen / 2) {
+              length2 = strLen / 2;
+            }
+            let i2;
+            for (i2 = 0; i2 < length2; ++i2) {
+              const parsed = parseInt(string.substr(i2 * 2, 2), 16);
+              if (numberIsNaN(parsed)) return i2;
+              buf[offset + i2] = parsed;
+            }
+            return i2;
+          }
+          function utf8Write(buf, string, offset, length2) {
+            return blitBuffer(utf8ToBytes(string, buf.length - offset), buf, offset, length2);
+          }
+          function asciiWrite(buf, string, offset, length2) {
+            return blitBuffer(asciiToBytes(string), buf, offset, length2);
+          }
+          function base64Write(buf, string, offset, length2) {
+            return blitBuffer(base64ToBytes(string), buf, offset, length2);
+          }
+          function ucs2Write(buf, string, offset, length2) {
+            return blitBuffer(utf16leToBytes(string, buf.length - offset), buf, offset, length2);
+          }
+          Buffer22.prototype.write = function write(string, offset, length2, encoding) {
+            if (offset === void 0) {
+              encoding = "utf8";
+              length2 = this.length;
+              offset = 0;
+            } else if (length2 === void 0 && typeof offset === "string") {
+              encoding = offset;
+              length2 = this.length;
+              offset = 0;
+            } else if (isFinite(offset)) {
+              offset = offset >>> 0;
+              if (isFinite(length2)) {
+                length2 = length2 >>> 0;
+                if (encoding === void 0) encoding = "utf8";
+              } else {
+                encoding = length2;
+                length2 = void 0;
+              }
+            } else {
+              throw new Error(
+                "Buffer.write(string, encoding, offset[, length]) is no longer supported"
+              );
+            }
+            const remaining = this.length - offset;
+            if (length2 === void 0 || length2 > remaining) length2 = remaining;
+            if (string.length > 0 && (length2 < 0 || offset < 0) || offset > this.length) {
+              throw new RangeError("Attempt to write outside buffer bounds");
+            }
+            if (!encoding) encoding = "utf8";
+            let loweredCase = false;
+            for (; ; ) {
+              switch (encoding) {
+                case "hex":
+                  return hexWrite(this, string, offset, length2);
+                case "utf8":
+                case "utf-8":
+                  return utf8Write(this, string, offset, length2);
+                case "ascii":
+                case "latin1":
+                case "binary":
+                  return asciiWrite(this, string, offset, length2);
+                case "base64":
+                  return base64Write(this, string, offset, length2);
+                case "ucs2":
+                case "ucs-2":
+                case "utf16le":
+                case "utf-16le":
+                  return ucs2Write(this, string, offset, length2);
+                default:
+                  if (loweredCase) throw new TypeError("Unknown encoding: " + encoding);
+                  encoding = ("" + encoding).toLowerCase();
+                  loweredCase = true;
+              }
+            }
+          };
+          Buffer22.prototype.toJSON = function toJSON() {
+            return {
+              type: "Buffer",
+              data: Array.prototype.slice.call(this._arr || this, 0)
+            };
+          };
+          function base64Slice(buf, start, end) {
+            if (start === 0 && end === buf.length) {
+              return base64.fromByteArray(buf);
+            } else {
+              return base64.fromByteArray(buf.slice(start, end));
+            }
+          }
+          function utf8Slice(buf, start, end) {
+            end = Math.min(buf.length, end);
+            const res = [];
+            let i2 = start;
+            while (i2 < end) {
+              const firstByte = buf[i2];
+              let codePoint = null;
+              let bytesPerSequence = firstByte > 239 ? 4 : firstByte > 223 ? 3 : firstByte > 191 ? 2 : 1;
+              if (i2 + bytesPerSequence <= end) {
+                let secondByte, thirdByte, fourthByte, tempCodePoint;
+                switch (bytesPerSequence) {
+                  case 1:
+                    if (firstByte < 128) {
+                      codePoint = firstByte;
+                    }
+                    break;
+                  case 2:
+                    secondByte = buf[i2 + 1];
+                    if ((secondByte & 192) === 128) {
+                      tempCodePoint = (firstByte & 31) << 6 | secondByte & 63;
+                      if (tempCodePoint > 127) {
+                        codePoint = tempCodePoint;
+                      }
+                    }
+                    break;
+                  case 3:
+                    secondByte = buf[i2 + 1];
+                    thirdByte = buf[i2 + 2];
+                    if ((secondByte & 192) === 128 && (thirdByte & 192) === 128) {
+                      tempCodePoint = (firstByte & 15) << 12 | (secondByte & 63) << 6 | thirdByte & 63;
+                      if (tempCodePoint > 2047 && (tempCodePoint < 55296 || tempCodePoint > 57343)) {
+                        codePoint = tempCodePoint;
+                      }
+                    }
+                    break;
+                  case 4:
+                    secondByte = buf[i2 + 1];
+                    thirdByte = buf[i2 + 2];
+                    fourthByte = buf[i2 + 3];
+                    if ((secondByte & 192) === 128 && (thirdByte & 192) === 128 && (fourthByte & 192) === 128) {
+                      tempCodePoint = (firstByte & 15) << 18 | (secondByte & 63) << 12 | (thirdByte & 63) << 6 | fourthByte & 63;
+                      if (tempCodePoint > 65535 && tempCodePoint < 1114112) {
+                        codePoint = tempCodePoint;
+                      }
+                    }
+                }
+              }
+              if (codePoint === null) {
+                codePoint = 65533;
+                bytesPerSequence = 1;
+              } else if (codePoint > 65535) {
+                codePoint -= 65536;
+                res.push(codePoint >>> 10 & 1023 | 55296);
+                codePoint = 56320 | codePoint & 1023;
+              }
+              res.push(codePoint);
+              i2 += bytesPerSequence;
+            }
+            return decodeCodePointsArray(res);
+          }
+          var MAX_ARGUMENTS_LENGTH = 4096;
+          function decodeCodePointsArray(codePoints) {
+            const len2 = codePoints.length;
+            if (len2 <= MAX_ARGUMENTS_LENGTH) {
+              return String.fromCharCode.apply(String, codePoints);
+            }
+            let res = "";
+            let i2 = 0;
+            while (i2 < len2) {
+              res += String.fromCharCode.apply(
+                String,
+                codePoints.slice(i2, i2 += MAX_ARGUMENTS_LENGTH)
+              );
+            }
+            return res;
+          }
+          function asciiSlice(buf, start, end) {
+            let ret = "";
+            end = Math.min(buf.length, end);
+            for (let i2 = start; i2 < end; ++i2) {
+              ret += String.fromCharCode(buf[i2] & 127);
+            }
+            return ret;
+          }
+          function latin1Slice(buf, start, end) {
+            let ret = "";
+            end = Math.min(buf.length, end);
+            for (let i2 = start; i2 < end; ++i2) {
+              ret += String.fromCharCode(buf[i2]);
+            }
+            return ret;
+          }
+          function hexSlice(buf, start, end) {
+            const len2 = buf.length;
+            if (!start || start < 0) start = 0;
+            if (!end || end < 0 || end > len2) end = len2;
+            let out = "";
+            for (let i2 = start; i2 < end; ++i2) {
+              out += hexSliceLookupTable[buf[i2]];
+            }
+            return out;
+          }
+          function utf16leSlice(buf, start, end) {
+            const bytes = buf.slice(start, end);
+            let res = "";
+            for (let i2 = 0; i2 < bytes.length - 1; i2 += 2) {
+              res += String.fromCharCode(bytes[i2] + bytes[i2 + 1] * 256);
+            }
+            return res;
+          }
+          Buffer22.prototype.slice = function slice(start, end) {
+            const len2 = this.length;
+            start = ~~start;
+            end = end === void 0 ? len2 : ~~end;
+            if (start < 0) {
+              start += len2;
+              if (start < 0) start = 0;
+            } else if (start > len2) {
+              start = len2;
+            }
+            if (end < 0) {
+              end += len2;
+              if (end < 0) end = 0;
+            } else if (end > len2) {
+              end = len2;
+            }
+            if (end < start) end = start;
+            const newBuf = this.subarray(start, end);
+            Object.setPrototypeOf(newBuf, Buffer22.prototype);
+            return newBuf;
+          };
+          function checkOffset(offset, ext, length2) {
+            if (offset % 1 !== 0 || offset < 0) throw new RangeError("offset is not uint");
+            if (offset + ext > length2) throw new RangeError("Trying to access beyond buffer length");
+          }
+          Buffer22.prototype.readUintLE = Buffer22.prototype.readUIntLE = function readUIntLE(offset, byteLength2, noAssert) {
+            offset = offset >>> 0;
+            byteLength2 = byteLength2 >>> 0;
+            if (!noAssert) checkOffset(offset, byteLength2, this.length);
+            let val = this[offset];
+            let mul = 1;
+            let i2 = 0;
+            while (++i2 < byteLength2 && (mul *= 256)) {
+              val += this[offset + i2] * mul;
+            }
+            return val;
+          };
+          Buffer22.prototype.readUintBE = Buffer22.prototype.readUIntBE = function readUIntBE(offset, byteLength2, noAssert) {
+            offset = offset >>> 0;
+            byteLength2 = byteLength2 >>> 0;
+            if (!noAssert) {
+              checkOffset(offset, byteLength2, this.length);
+            }
+            let val = this[offset + --byteLength2];
+            let mul = 1;
+            while (byteLength2 > 0 && (mul *= 256)) {
+              val += this[offset + --byteLength2] * mul;
+            }
+            return val;
+          };
+          Buffer22.prototype.readUint8 = Buffer22.prototype.readUInt8 = function readUInt8(offset, noAssert) {
+            offset = offset >>> 0;
+            if (!noAssert) checkOffset(offset, 1, this.length);
+            return this[offset];
+          };
+          Buffer22.prototype.readUint16LE = Buffer22.prototype.readUInt16LE = function readUInt16LE(offset, noAssert) {
+            offset = offset >>> 0;
+            if (!noAssert) checkOffset(offset, 2, this.length);
+            return this[offset] | this[offset + 1] << 8;
+          };
+          Buffer22.prototype.readUint16BE = Buffer22.prototype.readUInt16BE = function readUInt16BE(offset, noAssert) {
+            offset = offset >>> 0;
+            if (!noAssert) checkOffset(offset, 2, this.length);
+            return this[offset] << 8 | this[offset + 1];
+          };
+          Buffer22.prototype.readUint32LE = Buffer22.prototype.readUInt32LE = function readUInt32LE(offset, noAssert) {
+            offset = offset >>> 0;
+            if (!noAssert) checkOffset(offset, 4, this.length);
+            return (this[offset] | this[offset + 1] << 8 | this[offset + 2] << 16) + this[offset + 3] * 16777216;
+          };
+          Buffer22.prototype.readUint32BE = Buffer22.prototype.readUInt32BE = function readUInt32BE(offset, noAssert) {
+            offset = offset >>> 0;
+            if (!noAssert) checkOffset(offset, 4, this.length);
+            return this[offset] * 16777216 + (this[offset + 1] << 16 | this[offset + 2] << 8 | this[offset + 3]);
+          };
+          Buffer22.prototype.readBigUInt64LE = defineBigIntMethod(function readBigUInt64LE(offset) {
+            offset = offset >>> 0;
+            validateNumber(offset, "offset");
+            const first = this[offset];
+            const last = this[offset + 7];
+            if (first === void 0 || last === void 0) {
+              boundsError(offset, this.length - 8);
+            }
+            const lo = first + this[++offset] * 2 ** 8 + this[++offset] * 2 ** 16 + this[++offset] * 2 ** 24;
+            const hi2 = this[++offset] + this[++offset] * 2 ** 8 + this[++offset] * 2 ** 16 + last * 2 ** 24;
+            return BigInt(lo) + (BigInt(hi2) << BigInt(32));
+          });
+          Buffer22.prototype.readBigUInt64BE = defineBigIntMethod(function readBigUInt64BE(offset) {
+            offset = offset >>> 0;
+            validateNumber(offset, "offset");
+            const first = this[offset];
+            const last = this[offset + 7];
+            if (first === void 0 || last === void 0) {
+              boundsError(offset, this.length - 8);
+            }
+            const hi2 = first * 2 ** 24 + this[++offset] * 2 ** 16 + this[++offset] * 2 ** 8 + this[++offset];
+            const lo = this[++offset] * 2 ** 24 + this[++offset] * 2 ** 16 + this[++offset] * 2 ** 8 + last;
+            return (BigInt(hi2) << BigInt(32)) + BigInt(lo);
+          });
+          Buffer22.prototype.readIntLE = function readIntLE(offset, byteLength2, noAssert) {
+            offset = offset >>> 0;
+            byteLength2 = byteLength2 >>> 0;
+            if (!noAssert) checkOffset(offset, byteLength2, this.length);
+            let val = this[offset];
+            let mul = 1;
+            let i2 = 0;
+            while (++i2 < byteLength2 && (mul *= 256)) {
+              val += this[offset + i2] * mul;
+            }
+            mul *= 128;
+            if (val >= mul) val -= Math.pow(2, 8 * byteLength2);
+            return val;
+          };
+          Buffer22.prototype.readIntBE = function readIntBE(offset, byteLength2, noAssert) {
+            offset = offset >>> 0;
+            byteLength2 = byteLength2 >>> 0;
+            if (!noAssert) checkOffset(offset, byteLength2, this.length);
+            let i2 = byteLength2;
+            let mul = 1;
+            let val = this[offset + --i2];
+            while (i2 > 0 && (mul *= 256)) {
+              val += this[offset + --i2] * mul;
+            }
+            mul *= 128;
+            if (val >= mul) val -= Math.pow(2, 8 * byteLength2);
+            return val;
+          };
+          Buffer22.prototype.readInt8 = function readInt8(offset, noAssert) {
+            offset = offset >>> 0;
+            if (!noAssert) checkOffset(offset, 1, this.length);
+            if (!(this[offset] & 128)) return this[offset];
+            return (255 - this[offset] + 1) * -1;
+          };
+          Buffer22.prototype.readInt16LE = function readInt16LE(offset, noAssert) {
+            offset = offset >>> 0;
+            if (!noAssert) checkOffset(offset, 2, this.length);
+            const val = this[offset] | this[offset + 1] << 8;
+            return val & 32768 ? val | 4294901760 : val;
+          };
+          Buffer22.prototype.readInt16BE = function readInt16BE(offset, noAssert) {
+            offset = offset >>> 0;
+            if (!noAssert) checkOffset(offset, 2, this.length);
+            const val = this[offset + 1] | this[offset] << 8;
+            return val & 32768 ? val | 4294901760 : val;
+          };
+          Buffer22.prototype.readInt32LE = function readInt32LE(offset, noAssert) {
+            offset = offset >>> 0;
+            if (!noAssert) checkOffset(offset, 4, this.length);
+            return this[offset] | this[offset + 1] << 8 | this[offset + 2] << 16 | this[offset + 3] << 24;
+          };
+          Buffer22.prototype.readInt32BE = function readInt32BE(offset, noAssert) {
+            offset = offset >>> 0;
+            if (!noAssert) checkOffset(offset, 4, this.length);
+            return this[offset] << 24 | this[offset + 1] << 16 | this[offset + 2] << 8 | this[offset + 3];
+          };
+          Buffer22.prototype.readBigInt64LE = defineBigIntMethod(function readBigInt64LE(offset) {
+            offset = offset >>> 0;
+            validateNumber(offset, "offset");
+            const first = this[offset];
+            const last = this[offset + 7];
+            if (first === void 0 || last === void 0) {
+              boundsError(offset, this.length - 8);
+            }
+            const val = this[offset + 4] + this[offset + 5] * 2 ** 8 + this[offset + 6] * 2 ** 16 + (last << 24);
+            return (BigInt(val) << BigInt(32)) + BigInt(first + this[++offset] * 2 ** 8 + this[++offset] * 2 ** 16 + this[++offset] * 2 ** 24);
+          });
+          Buffer22.prototype.readBigInt64BE = defineBigIntMethod(function readBigInt64BE(offset) {
+            offset = offset >>> 0;
+            validateNumber(offset, "offset");
+            const first = this[offset];
+            const last = this[offset + 7];
+            if (first === void 0 || last === void 0) {
+              boundsError(offset, this.length - 8);
+            }
+            const val = (first << 24) + // Overflow
+            this[++offset] * 2 ** 16 + this[++offset] * 2 ** 8 + this[++offset];
+            return (BigInt(val) << BigInt(32)) + BigInt(this[++offset] * 2 ** 24 + this[++offset] * 2 ** 16 + this[++offset] * 2 ** 8 + last);
+          });
+          Buffer22.prototype.readFloatLE = function readFloatLE(offset, noAssert) {
+            offset = offset >>> 0;
+            if (!noAssert) checkOffset(offset, 4, this.length);
+            return ieee754.read(this, offset, true, 23, 4);
+          };
+          Buffer22.prototype.readFloatBE = function readFloatBE(offset, noAssert) {
+            offset = offset >>> 0;
+            if (!noAssert) checkOffset(offset, 4, this.length);
+            return ieee754.read(this, offset, false, 23, 4);
+          };
+          Buffer22.prototype.readDoubleLE = function readDoubleLE(offset, noAssert) {
+            offset = offset >>> 0;
+            if (!noAssert) checkOffset(offset, 8, this.length);
+            return ieee754.read(this, offset, true, 52, 8);
+          };
+          Buffer22.prototype.readDoubleBE = function readDoubleBE(offset, noAssert) {
+            offset = offset >>> 0;
+            if (!noAssert) checkOffset(offset, 8, this.length);
+            return ieee754.read(this, offset, false, 52, 8);
+          };
+          function checkInt(buf, value, offset, ext, max, min) {
+            if (!Buffer22.isBuffer(buf)) throw new TypeError('"buffer" argument must be a Buffer instance');
+            if (value > max || value < min) throw new RangeError('"value" argument is out of bounds');
+            if (offset + ext > buf.length) throw new RangeError("Index out of range");
+          }
+          Buffer22.prototype.writeUintLE = Buffer22.prototype.writeUIntLE = function writeUIntLE(value, offset, byteLength2, noAssert) {
+            value = +value;
+            offset = offset >>> 0;
+            byteLength2 = byteLength2 >>> 0;
+            if (!noAssert) {
+              const maxBytes = Math.pow(2, 8 * byteLength2) - 1;
+              checkInt(this, value, offset, byteLength2, maxBytes, 0);
+            }
+            let mul = 1;
+            let i2 = 0;
+            this[offset] = value & 255;
+            while (++i2 < byteLength2 && (mul *= 256)) {
+              this[offset + i2] = value / mul & 255;
+            }
+            return offset + byteLength2;
+          };
+          Buffer22.prototype.writeUintBE = Buffer22.prototype.writeUIntBE = function writeUIntBE(value, offset, byteLength2, noAssert) {
+            value = +value;
+            offset = offset >>> 0;
+            byteLength2 = byteLength2 >>> 0;
+            if (!noAssert) {
+              const maxBytes = Math.pow(2, 8 * byteLength2) - 1;
+              checkInt(this, value, offset, byteLength2, maxBytes, 0);
+            }
+            let i2 = byteLength2 - 1;
+            let mul = 1;
+            this[offset + i2] = value & 255;
+            while (--i2 >= 0 && (mul *= 256)) {
+              this[offset + i2] = value / mul & 255;
+            }
+            return offset + byteLength2;
+          };
+          Buffer22.prototype.writeUint8 = Buffer22.prototype.writeUInt8 = function writeUInt8(value, offset, noAssert) {
+            value = +value;
+            offset = offset >>> 0;
+            if (!noAssert) checkInt(this, value, offset, 1, 255, 0);
+            this[offset] = value & 255;
+            return offset + 1;
+          };
+          Buffer22.prototype.writeUint16LE = Buffer22.prototype.writeUInt16LE = function writeUInt16LE(value, offset, noAssert) {
+            value = +value;
+            offset = offset >>> 0;
+            if (!noAssert) checkInt(this, value, offset, 2, 65535, 0);
+            this[offset] = value & 255;
+            this[offset + 1] = value >>> 8;
+            return offset + 2;
+          };
+          Buffer22.prototype.writeUint16BE = Buffer22.prototype.writeUInt16BE = function writeUInt16BE(value, offset, noAssert) {
+            value = +value;
+            offset = offset >>> 0;
+            if (!noAssert) checkInt(this, value, offset, 2, 65535, 0);
+            this[offset] = value >>> 8;
+            this[offset + 1] = value & 255;
+            return offset + 2;
+          };
+          Buffer22.prototype.writeUint32LE = Buffer22.prototype.writeUInt32LE = function writeUInt32LE(value, offset, noAssert) {
+            value = +value;
+            offset = offset >>> 0;
+            if (!noAssert) checkInt(this, value, offset, 4, 4294967295, 0);
+            this[offset + 3] = value >>> 24;
+            this[offset + 2] = value >>> 16;
+            this[offset + 1] = value >>> 8;
+            this[offset] = value & 255;
+            return offset + 4;
+          };
+          Buffer22.prototype.writeUint32BE = Buffer22.prototype.writeUInt32BE = function writeUInt32BE(value, offset, noAssert) {
+            value = +value;
+            offset = offset >>> 0;
+            if (!noAssert) checkInt(this, value, offset, 4, 4294967295, 0);
+            this[offset] = value >>> 24;
+            this[offset + 1] = value >>> 16;
+            this[offset + 2] = value >>> 8;
+            this[offset + 3] = value & 255;
+            return offset + 4;
+          };
+          function wrtBigUInt64LE(buf, value, offset, min, max) {
+            checkIntBI(value, min, max, buf, offset, 7);
+            let lo = Number(value & BigInt(4294967295));
+            buf[offset++] = lo;
+            lo = lo >> 8;
+            buf[offset++] = lo;
+            lo = lo >> 8;
+            buf[offset++] = lo;
+            lo = lo >> 8;
+            buf[offset++] = lo;
+            let hi2 = Number(value >> BigInt(32) & BigInt(4294967295));
+            buf[offset++] = hi2;
+            hi2 = hi2 >> 8;
+            buf[offset++] = hi2;
+            hi2 = hi2 >> 8;
+            buf[offset++] = hi2;
+            hi2 = hi2 >> 8;
+            buf[offset++] = hi2;
+            return offset;
+          }
+          function wrtBigUInt64BE(buf, value, offset, min, max) {
+            checkIntBI(value, min, max, buf, offset, 7);
+            let lo = Number(value & BigInt(4294967295));
+            buf[offset + 7] = lo;
+            lo = lo >> 8;
+            buf[offset + 6] = lo;
+            lo = lo >> 8;
+            buf[offset + 5] = lo;
+            lo = lo >> 8;
+            buf[offset + 4] = lo;
+            let hi2 = Number(value >> BigInt(32) & BigInt(4294967295));
+            buf[offset + 3] = hi2;
+            hi2 = hi2 >> 8;
+            buf[offset + 2] = hi2;
+            hi2 = hi2 >> 8;
+            buf[offset + 1] = hi2;
+            hi2 = hi2 >> 8;
+            buf[offset] = hi2;
+            return offset + 8;
+          }
+          Buffer22.prototype.writeBigUInt64LE = defineBigIntMethod(function writeBigUInt64LE(value, offset = 0) {
+            return wrtBigUInt64LE(this, value, offset, BigInt(0), BigInt("0xffffffffffffffff"));
+          });
+          Buffer22.prototype.writeBigUInt64BE = defineBigIntMethod(function writeBigUInt64BE(value, offset = 0) {
+            return wrtBigUInt64BE(this, value, offset, BigInt(0), BigInt("0xffffffffffffffff"));
+          });
+          Buffer22.prototype.writeIntLE = function writeIntLE(value, offset, byteLength2, noAssert) {
+            value = +value;
+            offset = offset >>> 0;
+            if (!noAssert) {
+              const limit = Math.pow(2, 8 * byteLength2 - 1);
+              checkInt(this, value, offset, byteLength2, limit - 1, -limit);
+            }
+            let i2 = 0;
+            let mul = 1;
+            let sub2 = 0;
+            this[offset] = value & 255;
+            while (++i2 < byteLength2 && (mul *= 256)) {
+              if (value < 0 && sub2 === 0 && this[offset + i2 - 1] !== 0) {
+                sub2 = 1;
+              }
+              this[offset + i2] = (value / mul >> 0) - sub2 & 255;
+            }
+            return offset + byteLength2;
+          };
+          Buffer22.prototype.writeIntBE = function writeIntBE(value, offset, byteLength2, noAssert) {
+            value = +value;
+            offset = offset >>> 0;
+            if (!noAssert) {
+              const limit = Math.pow(2, 8 * byteLength2 - 1);
+              checkInt(this, value, offset, byteLength2, limit - 1, -limit);
+            }
+            let i2 = byteLength2 - 1;
+            let mul = 1;
+            let sub2 = 0;
+            this[offset + i2] = value & 255;
+            while (--i2 >= 0 && (mul *= 256)) {
+              if (value < 0 && sub2 === 0 && this[offset + i2 + 1] !== 0) {
+                sub2 = 1;
+              }
+              this[offset + i2] = (value / mul >> 0) - sub2 & 255;
+            }
+            return offset + byteLength2;
+          };
+          Buffer22.prototype.writeInt8 = function writeInt8(value, offset, noAssert) {
+            value = +value;
+            offset = offset >>> 0;
+            if (!noAssert) checkInt(this, value, offset, 1, 127, -128);
+            if (value < 0) value = 255 + value + 1;
+            this[offset] = value & 255;
+            return offset + 1;
+          };
+          Buffer22.prototype.writeInt16LE = function writeInt16LE(value, offset, noAssert) {
+            value = +value;
+            offset = offset >>> 0;
+            if (!noAssert) checkInt(this, value, offset, 2, 32767, -32768);
+            this[offset] = value & 255;
+            this[offset + 1] = value >>> 8;
+            return offset + 2;
+          };
+          Buffer22.prototype.writeInt16BE = function writeInt16BE(value, offset, noAssert) {
+            value = +value;
+            offset = offset >>> 0;
+            if (!noAssert) checkInt(this, value, offset, 2, 32767, -32768);
+            this[offset] = value >>> 8;
+            this[offset + 1] = value & 255;
+            return offset + 2;
+          };
+          Buffer22.prototype.writeInt32LE = function writeInt32LE(value, offset, noAssert) {
+            value = +value;
+            offset = offset >>> 0;
+            if (!noAssert) checkInt(this, value, offset, 4, 2147483647, -2147483648);
+            this[offset] = value & 255;
+            this[offset + 1] = value >>> 8;
+            this[offset + 2] = value >>> 16;
+            this[offset + 3] = value >>> 24;
+            return offset + 4;
+          };
+          Buffer22.prototype.writeInt32BE = function writeInt32BE(value, offset, noAssert) {
+            value = +value;
+            offset = offset >>> 0;
+            if (!noAssert) checkInt(this, value, offset, 4, 2147483647, -2147483648);
+            if (value < 0) value = 4294967295 + value + 1;
+            this[offset] = value >>> 24;
+            this[offset + 1] = value >>> 16;
+            this[offset + 2] = value >>> 8;
+            this[offset + 3] = value & 255;
+            return offset + 4;
+          };
+          Buffer22.prototype.writeBigInt64LE = defineBigIntMethod(function writeBigInt64LE(value, offset = 0) {
+            return wrtBigUInt64LE(this, value, offset, -BigInt("0x8000000000000000"), BigInt("0x7fffffffffffffff"));
+          });
+          Buffer22.prototype.writeBigInt64BE = defineBigIntMethod(function writeBigInt64BE(value, offset = 0) {
+            return wrtBigUInt64BE(this, value, offset, -BigInt("0x8000000000000000"), BigInt("0x7fffffffffffffff"));
+          });
+          function checkIEEE754(buf, value, offset, ext, max, min) {
+            if (offset + ext > buf.length) throw new RangeError("Index out of range");
+            if (offset < 0) throw new RangeError("Index out of range");
+          }
+          function writeFloat(buf, value, offset, littleEndian, noAssert) {
+            value = +value;
+            offset = offset >>> 0;
+            if (!noAssert) {
+              checkIEEE754(buf, value, offset, 4);
+            }
+            ieee754.write(buf, value, offset, littleEndian, 23, 4);
+            return offset + 4;
+          }
+          Buffer22.prototype.writeFloatLE = function writeFloatLE(value, offset, noAssert) {
+            return writeFloat(this, value, offset, true, noAssert);
+          };
+          Buffer22.prototype.writeFloatBE = function writeFloatBE(value, offset, noAssert) {
+            return writeFloat(this, value, offset, false, noAssert);
+          };
+          function writeDouble(buf, value, offset, littleEndian, noAssert) {
+            value = +value;
+            offset = offset >>> 0;
+            if (!noAssert) {
+              checkIEEE754(buf, value, offset, 8);
+            }
+            ieee754.write(buf, value, offset, littleEndian, 52, 8);
+            return offset + 8;
+          }
+          Buffer22.prototype.writeDoubleLE = function writeDoubleLE(value, offset, noAssert) {
+            return writeDouble(this, value, offset, true, noAssert);
+          };
+          Buffer22.prototype.writeDoubleBE = function writeDoubleBE(value, offset, noAssert) {
+            return writeDouble(this, value, offset, false, noAssert);
+          };
+          Buffer22.prototype.copy = function copy(target, targetStart, start, end) {
+            if (!Buffer22.isBuffer(target)) throw new TypeError("argument should be a Buffer");
+            if (!start) start = 0;
+            if (!end && end !== 0) end = this.length;
+            if (targetStart >= target.length) targetStart = target.length;
+            if (!targetStart) targetStart = 0;
+            if (end > 0 && end < start) end = start;
+            if (end === start) return 0;
+            if (target.length === 0 || this.length === 0) return 0;
+            if (targetStart < 0) {
+              throw new RangeError("targetStart out of bounds");
+            }
+            if (start < 0 || start >= this.length) throw new RangeError("Index out of range");
+            if (end < 0) throw new RangeError("sourceEnd out of bounds");
+            if (end > this.length) end = this.length;
+            if (target.length - targetStart < end - start) {
+              end = target.length - targetStart + start;
+            }
+            const len2 = end - start;
+            if (this === target && typeof Uint8Array.prototype.copyWithin === "function") {
+              this.copyWithin(targetStart, start, end);
+            } else {
+              Uint8Array.prototype.set.call(
+                target,
+                this.subarray(start, end),
+                targetStart
+              );
+            }
+            return len2;
+          };
+          Buffer22.prototype.fill = function fill(val, start, end, encoding) {
+            if (typeof val === "string") {
+              if (typeof start === "string") {
+                encoding = start;
+                start = 0;
+                end = this.length;
+              } else if (typeof end === "string") {
+                encoding = end;
+                end = this.length;
+              }
+              if (encoding !== void 0 && typeof encoding !== "string") {
+                throw new TypeError("encoding must be a string");
+              }
+              if (typeof encoding === "string" && !Buffer22.isEncoding(encoding)) {
+                throw new TypeError("Unknown encoding: " + encoding);
+              }
+              if (val.length === 1) {
+                const code = val.charCodeAt(0);
+                if (encoding === "utf8" && code < 128 || encoding === "latin1") {
+                  val = code;
+                }
+              }
+            } else if (typeof val === "number") {
+              val = val & 255;
+            } else if (typeof val === "boolean") {
+              val = Number(val);
+            }
+            if (start < 0 || this.length < start || this.length < end) {
+              throw new RangeError("Out of range index");
+            }
+            if (end <= start) {
+              return this;
+            }
+            start = start >>> 0;
+            end = end === void 0 ? this.length : end >>> 0;
+            if (!val) val = 0;
+            let i2;
+            if (typeof val === "number") {
+              for (i2 = start; i2 < end; ++i2) {
+                this[i2] = val;
+              }
+            } else {
+              const bytes = Buffer22.isBuffer(val) ? val : Buffer22.from(val, encoding);
+              const len2 = bytes.length;
+              if (len2 === 0) {
+                throw new TypeError('The value "' + val + '" is invalid for argument "value"');
+              }
+              for (i2 = 0; i2 < end - start; ++i2) {
+                this[i2 + start] = bytes[i2 % len2];
+              }
+            }
+            return this;
+          };
+          var errors = {};
+          function E22(sym, getMessage, Base) {
+            errors[sym] = class NodeError extends Base {
+              constructor() {
+                super();
+                Object.defineProperty(this, "message", {
+                  value: getMessage.apply(this, arguments),
+                  writable: true,
+                  configurable: true
+                });
+                this.name = `${this.name} [${sym}]`;
+                this.stack;
+                delete this.name;
+              }
+              get code() {
+                return sym;
+              }
+              set code(value) {
+                Object.defineProperty(this, "code", {
+                  configurable: true,
+                  enumerable: true,
+                  value,
+                  writable: true
+                });
+              }
+              toString() {
+                return `${this.name} [${sym}]: ${this.message}`;
+              }
+            };
+          }
+          E22(
+            "ERR_BUFFER_OUT_OF_BOUNDS",
+            function(name2) {
+              if (name2) {
+                return `${name2} is outside of buffer bounds`;
+              }
+              return "Attempt to access memory outside buffer bounds";
+            },
+            RangeError
+          );
+          E22(
+            "ERR_INVALID_ARG_TYPE",
+            function(name2, actual) {
+              return `The "${name2}" argument must be of type number. Received type ${typeof actual}`;
+            },
+            TypeError
+          );
+          E22(
+            "ERR_OUT_OF_RANGE",
+            function(str, range, input) {
+              let msg = `The value of "${str}" is out of range.`;
+              let received = input;
+              if (Number.isInteger(input) && Math.abs(input) > 2 ** 32) {
+                received = addNumericalSeparator(String(input));
+              } else if (typeof input === "bigint") {
+                received = String(input);
+                if (input > BigInt(2) ** BigInt(32) || input < -(BigInt(2) ** BigInt(32))) {
+                  received = addNumericalSeparator(received);
+                }
+                received += "n";
+              }
+              msg += ` It must be ${range}. Received ${received}`;
+              return msg;
+            },
+            RangeError
+          );
+          function addNumericalSeparator(val) {
+            let res = "";
+            let i2 = val.length;
+            const start = val[0] === "-" ? 1 : 0;
+            for (; i2 >= start + 4; i2 -= 3) {
+              res = `_${val.slice(i2 - 3, i2)}${res}`;
+            }
+            return `${val.slice(0, i2)}${res}`;
+          }
+          function checkBounds(buf, offset, byteLength2) {
+            validateNumber(offset, "offset");
+            if (buf[offset] === void 0 || buf[offset + byteLength2] === void 0) {
+              boundsError(offset, buf.length - (byteLength2 + 1));
+            }
+          }
+          function checkIntBI(value, min, max, buf, offset, byteLength2) {
+            if (value > max || value < min) {
+              const n2 = typeof min === "bigint" ? "n" : "";
+              let range;
+              {
+                if (min === 0 || min === BigInt(0)) {
+                  range = `>= 0${n2} and < 2${n2} ** ${(byteLength2 + 1) * 8}${n2}`;
+                } else {
+                  range = `>= -(2${n2} ** ${(byteLength2 + 1) * 8 - 1}${n2}) and < 2 ** ${(byteLength2 + 1) * 8 - 1}${n2}`;
+                }
+              }
+              throw new errors.ERR_OUT_OF_RANGE("value", range, value);
+            }
+            checkBounds(buf, offset, byteLength2);
+          }
+          function validateNumber(value, name2) {
+            if (typeof value !== "number") {
+              throw new errors.ERR_INVALID_ARG_TYPE(name2, "number", value);
+            }
+          }
+          function boundsError(value, length2, type) {
+            if (Math.floor(value) !== value) {
+              validateNumber(value, type);
+              throw new errors.ERR_OUT_OF_RANGE("offset", "an integer", value);
+            }
+            if (length2 < 0) {
+              throw new errors.ERR_BUFFER_OUT_OF_BOUNDS();
+            }
+            throw new errors.ERR_OUT_OF_RANGE(
+              "offset",
+              `>= ${0} and <= ${length2}`,
+              value
+            );
+          }
+          var INVALID_BASE64_RE = /[^+/0-9A-Za-z-_]/g;
+          function base64clean(str) {
+            str = str.split("=")[0];
+            str = str.trim().replace(INVALID_BASE64_RE, "");
+            if (str.length < 2) return "";
+            while (str.length % 4 !== 0) {
+              str = str + "=";
+            }
+            return str;
+          }
+          function utf8ToBytes(string, units) {
+            units = units || Infinity;
+            let codePoint;
+            const length2 = string.length;
+            let leadSurrogate = null;
+            const bytes = [];
+            for (let i2 = 0; i2 < length2; ++i2) {
+              codePoint = string.charCodeAt(i2);
+              if (codePoint > 55295 && codePoint < 57344) {
+                if (!leadSurrogate) {
+                  if (codePoint > 56319) {
+                    if ((units -= 3) > -1) bytes.push(239, 191, 189);
+                    continue;
+                  } else if (i2 + 1 === length2) {
+                    if ((units -= 3) > -1) bytes.push(239, 191, 189);
+                    continue;
+                  }
+                  leadSurrogate = codePoint;
+                  continue;
+                }
+                if (codePoint < 56320) {
+                  if ((units -= 3) > -1) bytes.push(239, 191, 189);
+                  leadSurrogate = codePoint;
+                  continue;
+                }
+                codePoint = (leadSurrogate - 55296 << 10 | codePoint - 56320) + 65536;
+              } else if (leadSurrogate) {
+                if ((units -= 3) > -1) bytes.push(239, 191, 189);
+              }
+              leadSurrogate = null;
+              if (codePoint < 128) {
+                if ((units -= 1) < 0) break;
+                bytes.push(codePoint);
+              } else if (codePoint < 2048) {
+                if ((units -= 2) < 0) break;
+                bytes.push(
+                  codePoint >> 6 | 192,
+                  codePoint & 63 | 128
+                );
+              } else if (codePoint < 65536) {
+                if ((units -= 3) < 0) break;
+                bytes.push(
+                  codePoint >> 12 | 224,
+                  codePoint >> 6 & 63 | 128,
+                  codePoint & 63 | 128
+                );
+              } else if (codePoint < 1114112) {
+                if ((units -= 4) < 0) break;
+                bytes.push(
+                  codePoint >> 18 | 240,
+                  codePoint >> 12 & 63 | 128,
+                  codePoint >> 6 & 63 | 128,
+                  codePoint & 63 | 128
+                );
+              } else {
+                throw new Error("Invalid code point");
+              }
+            }
+            return bytes;
+          }
+          function asciiToBytes(str) {
+            const byteArray = [];
+            for (let i2 = 0; i2 < str.length; ++i2) {
+              byteArray.push(str.charCodeAt(i2) & 255);
+            }
+            return byteArray;
+          }
+          function utf16leToBytes(str, units) {
+            let c2, hi2, lo;
+            const byteArray = [];
+            for (let i2 = 0; i2 < str.length; ++i2) {
+              if ((units -= 2) < 0) break;
+              c2 = str.charCodeAt(i2);
+              hi2 = c2 >> 8;
+              lo = c2 % 256;
+              byteArray.push(lo);
+              byteArray.push(hi2);
+            }
+            return byteArray;
+          }
+          function base64ToBytes(str) {
+            return base64.toByteArray(base64clean(str));
+          }
+          function blitBuffer(src, dst, offset, length2) {
+            let i2;
+            for (i2 = 0; i2 < length2; ++i2) {
+              if (i2 + offset >= dst.length || i2 >= src.length) break;
+              dst[i2 + offset] = src[i2];
+            }
+            return i2;
+          }
+          function isInstance(obj, type) {
+            return obj instanceof type || obj != null && obj.constructor != null && obj.constructor.name != null && obj.constructor.name === type.name;
+          }
+          function numberIsNaN(obj) {
+            return obj !== obj;
+          }
+          var hexSliceLookupTable = function() {
+            const alphabet = "0123456789abcdef";
+            const table = new Array(256);
+            for (let i2 = 0; i2 < 16; ++i2) {
+              const i16 = i2 * 16;
+              for (let j2 = 0; j2 < 16; ++j2) {
+                table[i16 + j2] = alphabet[i2] + alphabet[j2];
+              }
+            }
+            return table;
+          }();
+          function defineBigIntMethod(fn) {
+            return typeof BigInt === "undefined" ? BufferBigIntNotDefined : fn;
+          }
+          function BufferBigIntNotDefined() {
+            throw new Error("BigInt not supported");
+          }
+        }
+      });
+      var require_shams = __commonJS({
+        "node_modules/has-symbols/shams.js"(exports, module2) {
+          module2.exports = function hasSymbols() {
+            if (typeof Symbol !== "function" || typeof Object.getOwnPropertySymbols !== "function") {
+              return false;
+            }
+            if (typeof Symbol.iterator === "symbol") {
+              return true;
+            }
+            var obj = {};
+            var sym = Symbol("test");
+            var symObj = Object(sym);
+            if (typeof sym === "string") {
+              return false;
+            }
+            if (Object.prototype.toString.call(sym) !== "[object Symbol]") {
+              return false;
+            }
+            if (Object.prototype.toString.call(symObj) !== "[object Symbol]") {
+              return false;
+            }
+            var symVal = 42;
+            obj[sym] = symVal;
+            for (var _2 in obj) {
+              return false;
+            }
+            if (typeof Object.keys === "function" && Object.keys(obj).length !== 0) {
+              return false;
+            }
+            if (typeof Object.getOwnPropertyNames === "function" && Object.getOwnPropertyNames(obj).length !== 0) {
+              return false;
+            }
+            var syms = Object.getOwnPropertySymbols(obj);
+            if (syms.length !== 1 || syms[0] !== sym) {
+              return false;
+            }
+            if (!Object.prototype.propertyIsEnumerable.call(obj, sym)) {
+              return false;
+            }
+            if (typeof Object.getOwnPropertyDescriptor === "function") {
+              var descriptor = (
+                /** @type {PropertyDescriptor} */
+                Object.getOwnPropertyDescriptor(obj, sym)
+              );
+              if (descriptor.value !== symVal || descriptor.enumerable !== true) {
+                return false;
+              }
+            }
+            return true;
+          };
+        }
+      });
+      var require_shams2 = __commonJS({
+        "node_modules/has-tostringtag/shams.js"(exports, module2) {
+          var hasSymbols = require_shams();
+          module2.exports = function hasToStringTagShams() {
+            return hasSymbols() && !!Symbol.toStringTag;
+          };
+        }
+      });
+      var require_es_object_atoms = __commonJS({
+        "node_modules/es-object-atoms/index.js"(exports, module2) {
+          module2.exports = Object;
+        }
+      });
+      var require_es_errors = __commonJS({
+        "node_modules/es-errors/index.js"(exports, module2) {
+          module2.exports = Error;
+        }
+      });
+      var require_eval = __commonJS({
+        "node_modules/es-errors/eval.js"(exports, module2) {
+          module2.exports = EvalError;
+        }
+      });
+      var require_range = __commonJS({
+        "node_modules/es-errors/range.js"(exports, module2) {
+          module2.exports = RangeError;
+        }
+      });
+      var require_ref = __commonJS({
+        "node_modules/es-errors/ref.js"(exports, module2) {
+          module2.exports = ReferenceError;
+        }
+      });
+      var require_syntax = __commonJS({
+        "node_modules/es-errors/syntax.js"(exports, module2) {
+          module2.exports = SyntaxError;
+        }
+      });
+      var require_type = __commonJS({
+        "node_modules/es-errors/type.js"(exports, module2) {
+          module2.exports = TypeError;
+        }
+      });
+      var require_uri = __commonJS({
+        "node_modules/es-errors/uri.js"(exports, module2) {
+          module2.exports = URIError;
+        }
+      });
+      var require_abs = __commonJS({
+        "node_modules/math-intrinsics/abs.js"(exports, module2) {
+          module2.exports = Math.abs;
+        }
+      });
+      var require_floor = __commonJS({
+        "node_modules/math-intrinsics/floor.js"(exports, module2) {
+          module2.exports = Math.floor;
+        }
+      });
+      var require_max = __commonJS({
+        "node_modules/math-intrinsics/max.js"(exports, module2) {
+          module2.exports = Math.max;
+        }
+      });
+      var require_min = __commonJS({
+        "node_modules/math-intrinsics/min.js"(exports, module2) {
+          module2.exports = Math.min;
+        }
+      });
+      var require_pow = __commonJS({
+        "node_modules/math-intrinsics/pow.js"(exports, module2) {
+          module2.exports = Math.pow;
+        }
+      });
+      var require_round = __commonJS({
+        "node_modules/math-intrinsics/round.js"(exports, module2) {
+          module2.exports = Math.round;
+        }
+      });
+      var require_isNaN = __commonJS({
+        "node_modules/math-intrinsics/isNaN.js"(exports, module2) {
+          module2.exports = Number.isNaN || function isNaN2(a2) {
+            return a2 !== a2;
+          };
+        }
+      });
+      var require_sign = __commonJS({
+        "node_modules/math-intrinsics/sign.js"(exports, module2) {
+          var $isNaN = require_isNaN();
+          module2.exports = function sign(number) {
+            if ($isNaN(number) || number === 0) {
+              return number;
+            }
+            return number < 0 ? -1 : 1;
+          };
+        }
+      });
+      var require_gOPD = __commonJS({
+        "node_modules/gopd/gOPD.js"(exports, module2) {
+          module2.exports = Object.getOwnPropertyDescriptor;
+        }
+      });
+      var require_gopd = __commonJS({
+        "node_modules/gopd/index.js"(exports, module2) {
+          var $gOPD = require_gOPD();
+          if ($gOPD) {
+            try {
+              $gOPD([], "length");
+            } catch (e2) {
+              $gOPD = null;
+            }
+          }
+          module2.exports = $gOPD;
+        }
+      });
+      var require_es_define_property = __commonJS({
+        "node_modules/es-define-property/index.js"(exports, module2) {
+          var $defineProperty = Object.defineProperty || false;
+          if ($defineProperty) {
+            try {
+              $defineProperty({}, "a", { value: 1 });
+            } catch (e2) {
+              $defineProperty = false;
+            }
+          }
+          module2.exports = $defineProperty;
+        }
+      });
+      var require_has_symbols = __commonJS({
+        "node_modules/has-symbols/index.js"(exports, module2) {
+          var origSymbol = typeof Symbol !== "undefined" && Symbol;
+          var hasSymbolSham = require_shams();
+          module2.exports = function hasNativeSymbols() {
+            if (typeof origSymbol !== "function") {
+              return false;
+            }
+            if (typeof Symbol !== "function") {
+              return false;
+            }
+            if (typeof origSymbol("foo") !== "symbol") {
+              return false;
+            }
+            if (typeof Symbol("bar") !== "symbol") {
+              return false;
+            }
+            return hasSymbolSham();
+          };
+        }
+      });
+      var require_Reflect_getPrototypeOf = __commonJS({
+        "node_modules/get-proto/Reflect.getPrototypeOf.js"(exports, module2) {
+          module2.exports = typeof Reflect !== "undefined" && Reflect.getPrototypeOf || null;
+        }
+      });
+      var require_Object_getPrototypeOf = __commonJS({
+        "node_modules/get-proto/Object.getPrototypeOf.js"(exports, module2) {
+          var $Object = require_es_object_atoms();
+          module2.exports = $Object.getPrototypeOf || null;
+        }
+      });
+      var require_implementation = __commonJS({
+        "node_modules/function-bind/implementation.js"(exports, module2) {
+          var ERROR_MESSAGE2 = "Function.prototype.bind called on incompatible ";
+          var toStr = Object.prototype.toString;
+          var max = Math.max;
+          var funcType = "[object Function]";
+          var concatty = function concatty2(a2, b2) {
+            var arr = [];
+            for (var i2 = 0; i2 < a2.length; i2 += 1) {
+              arr[i2] = a2[i2];
+            }
+            for (var j2 = 0; j2 < b2.length; j2 += 1) {
+              arr[j2 + a2.length] = b2[j2];
+            }
+            return arr;
+          };
+          var slicy = function slicy2(arrLike, offset) {
+            var arr = [];
+            for (var i2 = offset, j2 = 0; i2 < arrLike.length; i2 += 1, j2 += 1) {
+              arr[j2] = arrLike[i2];
+            }
+            return arr;
+          };
+          var joiny = function(arr, joiner) {
+            var str = "";
+            for (var i2 = 0; i2 < arr.length; i2 += 1) {
+              str += arr[i2];
+              if (i2 + 1 < arr.length) {
+                str += joiner;
+              }
+            }
+            return str;
+          };
+          module2.exports = function bind(that) {
+            var target = this;
+            if (typeof target !== "function" || toStr.apply(target) !== funcType) {
+              throw new TypeError(ERROR_MESSAGE2 + target);
+            }
+            var args = slicy(arguments, 1);
+            var bound;
+            var binder = function() {
+              if (this instanceof bound) {
+                var result = target.apply(
+                  this,
+                  concatty(args, arguments)
+                );
+                if (Object(result) === result) {
+                  return result;
+                }
+                return this;
+              }
+              return target.apply(
+                that,
+                concatty(args, arguments)
+              );
+            };
+            var boundLength = max(0, target.length - args.length);
+            var boundArgs = [];
+            for (var i2 = 0; i2 < boundLength; i2++) {
+              boundArgs[i2] = "$" + i2;
+            }
+            bound = Function("binder", "return function (" + joiny(boundArgs, ",") + "){ return binder.apply(this,arguments); }")(binder);
+            if (target.prototype) {
+              var Empty = function Empty2() {
+              };
+              Empty.prototype = target.prototype;
+              bound.prototype = new Empty();
+              Empty.prototype = null;
+            }
+            return bound;
+          };
+        }
+      });
+      var require_function_bind = __commonJS({
+        "node_modules/function-bind/index.js"(exports, module2) {
+          var implementation = require_implementation();
+          module2.exports = Function.prototype.bind || implementation;
+        }
+      });
+      var require_functionCall = __commonJS({
+        "node_modules/call-bind-apply-helpers/functionCall.js"(exports, module2) {
+          module2.exports = Function.prototype.call;
+        }
+      });
+      var require_functionApply = __commonJS({
+        "node_modules/call-bind-apply-helpers/functionApply.js"(exports, module2) {
+          module2.exports = Function.prototype.apply;
+        }
+      });
+      var require_reflectApply = __commonJS({
+        "node_modules/call-bind-apply-helpers/reflectApply.js"(exports, module2) {
+          module2.exports = typeof Reflect !== "undefined" && Reflect && Reflect.apply;
+        }
+      });
+      var require_actualApply = __commonJS({
+        "node_modules/call-bind-apply-helpers/actualApply.js"(exports, module2) {
+          var bind = require_function_bind();
+          var $apply = require_functionApply();
+          var $call = require_functionCall();
+          var $reflectApply = require_reflectApply();
+          module2.exports = $reflectApply || bind.call($call, $apply);
+        }
+      });
+      var require_call_bind_apply_helpers = __commonJS({
+        "node_modules/call-bind-apply-helpers/index.js"(exports, module2) {
+          var bind = require_function_bind();
+          var $TypeError = require_type();
+          var $call = require_functionCall();
+          var $actualApply = require_actualApply();
+          module2.exports = function callBindBasic(args) {
+            if (args.length < 1 || typeof args[0] !== "function") {
+              throw new $TypeError("a function is required");
+            }
+            return $actualApply(bind, $call, args);
+          };
+        }
+      });
+      var require_get = __commonJS({
+        "node_modules/dunder-proto/get.js"(exports, module2) {
+          var callBind = require_call_bind_apply_helpers();
+          var gOPD = require_gopd();
+          var hasProtoAccessor;
+          try {
+            hasProtoAccessor = /** @type {{ __proto__?: typeof Array.prototype }} */
+            [].__proto__ === Array.prototype;
+          } catch (e2) {
+            if (!e2 || typeof e2 !== "object" || !("code" in e2) || e2.code !== "ERR_PROTO_ACCESS") {
+              throw e2;
+            }
+          }
+          var desc = !!hasProtoAccessor && gOPD && gOPD(
+            Object.prototype,
+            /** @type {keyof typeof Object.prototype} */
+            "__proto__"
+          );
+          var $Object = Object;
+          var $getPrototypeOf = $Object.getPrototypeOf;
+          module2.exports = desc && typeof desc.get === "function" ? callBind([desc.get]) : typeof $getPrototypeOf === "function" ? (
+            /** @type {import('./get')} */
+            function getDunder(value) {
+              return $getPrototypeOf(value == null ? value : $Object(value));
+            }
+          ) : false;
+        }
+      });
+      var require_get_proto = __commonJS({
+        "node_modules/get-proto/index.js"(exports, module2) {
+          var reflectGetProto = require_Reflect_getPrototypeOf();
+          var originalGetProto = require_Object_getPrototypeOf();
+          var getDunderProto = require_get();
+          module2.exports = reflectGetProto ? function getProto(O2) {
+            return reflectGetProto(O2);
+          } : originalGetProto ? function getProto(O2) {
+            if (!O2 || typeof O2 !== "object" && typeof O2 !== "function") {
+              throw new TypeError("getProto: not an object");
+            }
+            return originalGetProto(O2);
+          } : getDunderProto ? function getProto(O2) {
+            return getDunderProto(O2);
+          } : null;
+        }
+      });
+      var require_hasown = __commonJS({
+        "node_modules/hasown/index.js"(exports, module2) {
+          var call = Function.prototype.call;
+          var $hasOwn = Object.prototype.hasOwnProperty;
+          var bind = require_function_bind();
+          module2.exports = bind.call(call, $hasOwn);
+        }
+      });
+      var require_get_intrinsic = __commonJS({
+        "node_modules/get-intrinsic/index.js"(exports, module2) {
+          var undefined2;
+          var $Object = require_es_object_atoms();
+          var $Error = require_es_errors();
+          var $EvalError = require_eval();
+          var $RangeError = require_range();
+          var $ReferenceError = require_ref();
+          var $SyntaxError = require_syntax();
+          var $TypeError = require_type();
+          var $URIError = require_uri();
+          var abs = require_abs();
+          var floor = require_floor();
+          var max = require_max();
+          var min = require_min();
+          var pow = require_pow();
+          var round2 = require_round();
+          var sign = require_sign();
+          var $Function = Function;
+          var getEvalledConstructor = function(expressionSyntax) {
+            try {
+              return $Function('"use strict"; return (' + expressionSyntax + ").constructor;")();
+            } catch (e2) {
+            }
+          };
+          var $gOPD = require_gopd();
+          var $defineProperty = require_es_define_property();
+          var throwTypeError = function() {
+            throw new $TypeError();
+          };
+          var ThrowTypeError = $gOPD ? function() {
+            try {
+              arguments.callee;
+              return throwTypeError;
+            } catch (calleeThrows) {
+              try {
+                return $gOPD(arguments, "callee").get;
+              } catch (gOPDthrows) {
+                return throwTypeError;
+              }
+            }
+          }() : throwTypeError;
+          var hasSymbols = require_has_symbols()();
+          var getProto = require_get_proto();
+          var $ObjectGPO = require_Object_getPrototypeOf();
+          var $ReflectGPO = require_Reflect_getPrototypeOf();
+          var $apply = require_functionApply();
+          var $call = require_functionCall();
+          var needsEval = {};
+          var TypedArray = typeof Uint8Array === "undefined" || !getProto ? undefined2 : getProto(Uint8Array);
+          var INTRINSICS = {
+            __proto__: null,
+            "%AggregateError%": typeof AggregateError === "undefined" ? undefined2 : AggregateError,
+            "%Array%": Array,
+            "%ArrayBuffer%": typeof ArrayBuffer === "undefined" ? undefined2 : ArrayBuffer,
+            "%ArrayIteratorPrototype%": hasSymbols && getProto ? getProto([][Symbol.iterator]()) : undefined2,
+            "%AsyncFromSyncIteratorPrototype%": undefined2,
+            "%AsyncFunction%": needsEval,
+            "%AsyncGenerator%": needsEval,
+            "%AsyncGeneratorFunction%": needsEval,
+            "%AsyncIteratorPrototype%": needsEval,
+            "%Atomics%": typeof Atomics === "undefined" ? undefined2 : Atomics,
+            "%BigInt%": typeof BigInt === "undefined" ? undefined2 : BigInt,
+            "%BigInt64Array%": typeof BigInt64Array === "undefined" ? undefined2 : BigInt64Array,
+            "%BigUint64Array%": typeof BigUint64Array === "undefined" ? undefined2 : BigUint64Array,
+            "%Boolean%": Boolean,
+            "%DataView%": typeof DataView === "undefined" ? undefined2 : DataView,
+            "%Date%": Date,
+            "%decodeURI%": decodeURI,
+            "%decodeURIComponent%": decodeURIComponent,
+            "%encodeURI%": encodeURI,
+            "%encodeURIComponent%": encodeURIComponent,
+            "%Error%": $Error,
+            "%eval%": eval,
+            // eslint-disable-line no-eval
+            "%EvalError%": $EvalError,
+            "%Float16Array%": typeof Float16Array === "undefined" ? undefined2 : Float16Array,
+            "%Float32Array%": typeof Float32Array === "undefined" ? undefined2 : Float32Array,
+            "%Float64Array%": typeof Float64Array === "undefined" ? undefined2 : Float64Array,
+            "%FinalizationRegistry%": typeof FinalizationRegistry === "undefined" ? undefined2 : FinalizationRegistry,
+            "%Function%": $Function,
+            "%GeneratorFunction%": needsEval,
+            "%Int8Array%": typeof Int8Array === "undefined" ? undefined2 : Int8Array,
+            "%Int16Array%": typeof Int16Array === "undefined" ? undefined2 : Int16Array,
+            "%Int32Array%": typeof Int32Array === "undefined" ? undefined2 : Int32Array,
+            "%isFinite%": isFinite,
+            "%isNaN%": isNaN,
+            "%IteratorPrototype%": hasSymbols && getProto ? getProto(getProto([][Symbol.iterator]())) : undefined2,
+            "%JSON%": typeof JSON === "object" ? JSON : undefined2,
+            "%Map%": typeof Map === "undefined" ? undefined2 : Map,
+            "%MapIteratorPrototype%": typeof Map === "undefined" || !hasSymbols || !getProto ? undefined2 : getProto((/* @__PURE__ */ new Map())[Symbol.iterator]()),
+            "%Math%": Math,
+            "%Number%": Number,
+            "%Object%": $Object,
+            "%Object.getOwnPropertyDescriptor%": $gOPD,
+            "%parseFloat%": parseFloat,
+            "%parseInt%": parseInt,
+            "%Promise%": typeof Promise === "undefined" ? undefined2 : Promise,
+            "%Proxy%": typeof Proxy === "undefined" ? undefined2 : Proxy,
+            "%RangeError%": $RangeError,
+            "%ReferenceError%": $ReferenceError,
+            "%Reflect%": typeof Reflect === "undefined" ? undefined2 : Reflect,
+            "%RegExp%": RegExp,
+            "%Set%": typeof Set === "undefined" ? undefined2 : Set,
+            "%SetIteratorPrototype%": typeof Set === "undefined" || !hasSymbols || !getProto ? undefined2 : getProto((/* @__PURE__ */ new Set())[Symbol.iterator]()),
+            "%SharedArrayBuffer%": typeof SharedArrayBuffer === "undefined" ? undefined2 : SharedArrayBuffer,
+            "%String%": String,
+            "%StringIteratorPrototype%": hasSymbols && getProto ? getProto(""[Symbol.iterator]()) : undefined2,
+            "%Symbol%": hasSymbols ? Symbol : undefined2,
+            "%SyntaxError%": $SyntaxError,
+            "%ThrowTypeError%": ThrowTypeError,
+            "%TypedArray%": TypedArray,
+            "%TypeError%": $TypeError,
+            "%Uint8Array%": typeof Uint8Array === "undefined" ? undefined2 : Uint8Array,
+            "%Uint8ClampedArray%": typeof Uint8ClampedArray === "undefined" ? undefined2 : Uint8ClampedArray,
+            "%Uint16Array%": typeof Uint16Array === "undefined" ? undefined2 : Uint16Array,
+            "%Uint32Array%": typeof Uint32Array === "undefined" ? undefined2 : Uint32Array,
+            "%URIError%": $URIError,
+            "%WeakMap%": typeof WeakMap === "undefined" ? undefined2 : WeakMap,
+            "%WeakRef%": typeof WeakRef === "undefined" ? undefined2 : WeakRef,
+            "%WeakSet%": typeof WeakSet === "undefined" ? undefined2 : WeakSet,
+            "%Function.prototype.call%": $call,
+            "%Function.prototype.apply%": $apply,
+            "%Object.defineProperty%": $defineProperty,
+            "%Object.getPrototypeOf%": $ObjectGPO,
+            "%Math.abs%": abs,
+            "%Math.floor%": floor,
+            "%Math.max%": max,
+            "%Math.min%": min,
+            "%Math.pow%": pow,
+            "%Math.round%": round2,
+            "%Math.sign%": sign,
+            "%Reflect.getPrototypeOf%": $ReflectGPO
+          };
+          if (getProto) {
+            try {
+              null.error;
+            } catch (e2) {
+              errorProto = getProto(getProto(e2));
+              INTRINSICS["%Error.prototype%"] = errorProto;
+            }
+          }
+          var errorProto;
+          var doEval = function doEval2(name2) {
+            var value;
+            if (name2 === "%AsyncFunction%") {
+              value = getEvalledConstructor("async function () {}");
+            } else if (name2 === "%GeneratorFunction%") {
+              value = getEvalledConstructor("function* () {}");
+            } else if (name2 === "%AsyncGeneratorFunction%") {
+              value = getEvalledConstructor("async function* () {}");
+            } else if (name2 === "%AsyncGenerator%") {
+              var fn = doEval2("%AsyncGeneratorFunction%");
+              if (fn) {
+                value = fn.prototype;
+              }
+            } else if (name2 === "%AsyncIteratorPrototype%") {
+              var gen = doEval2("%AsyncGenerator%");
+              if (gen && getProto) {
+                value = getProto(gen.prototype);
+              }
+            }
+            INTRINSICS[name2] = value;
+            return value;
+          };
+          var LEGACY_ALIASES = {
+            __proto__: null,
+            "%ArrayBufferPrototype%": ["ArrayBuffer", "prototype"],
+            "%ArrayPrototype%": ["Array", "prototype"],
+            "%ArrayProto_entries%": ["Array", "prototype", "entries"],
+            "%ArrayProto_forEach%": ["Array", "prototype", "forEach"],
+            "%ArrayProto_keys%": ["Array", "prototype", "keys"],
+            "%ArrayProto_values%": ["Array", "prototype", "values"],
+            "%AsyncFunctionPrototype%": ["AsyncFunction", "prototype"],
+            "%AsyncGenerator%": ["AsyncGeneratorFunction", "prototype"],
+            "%AsyncGeneratorPrototype%": ["AsyncGeneratorFunction", "prototype", "prototype"],
+            "%BooleanPrototype%": ["Boolean", "prototype"],
+            "%DataViewPrototype%": ["DataView", "prototype"],
+            "%DatePrototype%": ["Date", "prototype"],
+            "%ErrorPrototype%": ["Error", "prototype"],
+            "%EvalErrorPrototype%": ["EvalError", "prototype"],
+            "%Float32ArrayPrototype%": ["Float32Array", "prototype"],
+            "%Float64ArrayPrototype%": ["Float64Array", "prototype"],
+            "%FunctionPrototype%": ["Function", "prototype"],
+            "%Generator%": ["GeneratorFunction", "prototype"],
+            "%GeneratorPrototype%": ["GeneratorFunction", "prototype", "prototype"],
+            "%Int8ArrayPrototype%": ["Int8Array", "prototype"],
+            "%Int16ArrayPrototype%": ["Int16Array", "prototype"],
+            "%Int32ArrayPrototype%": ["Int32Array", "prototype"],
+            "%JSONParse%": ["JSON", "parse"],
+            "%JSONStringify%": ["JSON", "stringify"],
+            "%MapPrototype%": ["Map", "prototype"],
+            "%NumberPrototype%": ["Number", "prototype"],
+            "%ObjectPrototype%": ["Object", "prototype"],
+            "%ObjProto_toString%": ["Object", "prototype", "toString"],
+            "%ObjProto_valueOf%": ["Object", "prototype", "valueOf"],
+            "%PromisePrototype%": ["Promise", "prototype"],
+            "%PromiseProto_then%": ["Promise", "prototype", "then"],
+            "%Promise_all%": ["Promise", "all"],
+            "%Promise_reject%": ["Promise", "reject"],
+            "%Promise_resolve%": ["Promise", "resolve"],
+            "%RangeErrorPrototype%": ["RangeError", "prototype"],
+            "%ReferenceErrorPrototype%": ["ReferenceError", "prototype"],
+            "%RegExpPrototype%": ["RegExp", "prototype"],
+            "%SetPrototype%": ["Set", "prototype"],
+            "%SharedArrayBufferPrototype%": ["SharedArrayBuffer", "prototype"],
+            "%StringPrototype%": ["String", "prototype"],
+            "%SymbolPrototype%": ["Symbol", "prototype"],
+            "%SyntaxErrorPrototype%": ["SyntaxError", "prototype"],
+            "%TypedArrayPrototype%": ["TypedArray", "prototype"],
+            "%TypeErrorPrototype%": ["TypeError", "prototype"],
+            "%Uint8ArrayPrototype%": ["Uint8Array", "prototype"],
+            "%Uint8ClampedArrayPrototype%": ["Uint8ClampedArray", "prototype"],
+            "%Uint16ArrayPrototype%": ["Uint16Array", "prototype"],
+            "%Uint32ArrayPrototype%": ["Uint32Array", "prototype"],
+            "%URIErrorPrototype%": ["URIError", "prototype"],
+            "%WeakMapPrototype%": ["WeakMap", "prototype"],
+            "%WeakSetPrototype%": ["WeakSet", "prototype"]
+          };
+          var bind = require_function_bind();
+          var hasOwn = require_hasown();
+          var $concat = bind.call($call, Array.prototype.concat);
+          var $spliceApply = bind.call($apply, Array.prototype.splice);
+          var $replace = bind.call($call, String.prototype.replace);
+          var $strSlice = bind.call($call, String.prototype.slice);
+          var $exec = bind.call($call, RegExp.prototype.exec);
+          var rePropName = /[^%.[\]]+|\[(?:(-?\d+(?:\.\d+)?)|(["'])((?:(?!\2)[^\\]|\\.)*?)\2)\]|(?=(?:\.|\[\])(?:\.|\[\]|%$))/g;
+          var reEscapeChar = /\\(\\)?/g;
+          var stringToPath = function stringToPath2(string) {
+            var first = $strSlice(string, 0, 1);
+            var last = $strSlice(string, -1);
+            if (first === "%" && last !== "%") {
+              throw new $SyntaxError("invalid intrinsic syntax, expected closing `%`");
+            } else if (last === "%" && first !== "%") {
+              throw new $SyntaxError("invalid intrinsic syntax, expected opening `%`");
+            }
+            var result = [];
+            $replace(string, rePropName, function(match, number, quote, subString) {
+              result[result.length] = quote ? $replace(subString, reEscapeChar, "$1") : number || match;
+            });
+            return result;
+          };
+          var getBaseIntrinsic = function getBaseIntrinsic2(name2, allowMissing) {
+            var intrinsicName = name2;
+            var alias;
+            if (hasOwn(LEGACY_ALIASES, intrinsicName)) {
+              alias = LEGACY_ALIASES[intrinsicName];
+              intrinsicName = "%" + alias[0] + "%";
+            }
+            if (hasOwn(INTRINSICS, intrinsicName)) {
+              var value = INTRINSICS[intrinsicName];
+              if (value === needsEval) {
+                value = doEval(intrinsicName);
+              }
+              if (typeof value === "undefined" && !allowMissing) {
+                throw new $TypeError("intrinsic " + name2 + " exists, but is not available. Please file an issue!");
+              }
+              return {
+                alias,
+                name: intrinsicName,
+                value
+              };
+            }
+            throw new $SyntaxError("intrinsic " + name2 + " does not exist!");
+          };
+          module2.exports = function GetIntrinsic(name2, allowMissing) {
+            if (typeof name2 !== "string" || name2.length === 0) {
+              throw new $TypeError("intrinsic name must be a non-empty string");
+            }
+            if (arguments.length > 1 && typeof allowMissing !== "boolean") {
+              throw new $TypeError('"allowMissing" argument must be a boolean');
+            }
+            if ($exec(/^%?[^%]*%?$/, name2) === null) {
+              throw new $SyntaxError("`%` may not be present anywhere but at the beginning and end of the intrinsic name");
+            }
+            var parts = stringToPath(name2);
+            var intrinsicBaseName = parts.length > 0 ? parts[0] : "";
+            var intrinsic = getBaseIntrinsic("%" + intrinsicBaseName + "%", allowMissing);
+            var intrinsicRealName = intrinsic.name;
+            var value = intrinsic.value;
+            var skipFurtherCaching = false;
+            var alias = intrinsic.alias;
+            if (alias) {
+              intrinsicBaseName = alias[0];
+              $spliceApply(parts, $concat([0, 1], alias));
+            }
+            for (var i2 = 1, isOwn = true; i2 < parts.length; i2 += 1) {
+              var part = parts[i2];
+              var first = $strSlice(part, 0, 1);
+              var last = $strSlice(part, -1);
+              if ((first === '"' || first === "'" || first === "`" || (last === '"' || last === "'" || last === "`")) && first !== last) {
+                throw new $SyntaxError("property names with quotes must have matching quotes");
+              }
+              if (part === "constructor" || !isOwn) {
+                skipFurtherCaching = true;
+              }
+              intrinsicBaseName += "." + part;
+              intrinsicRealName = "%" + intrinsicBaseName + "%";
+              if (hasOwn(INTRINSICS, intrinsicRealName)) {
+                value = INTRINSICS[intrinsicRealName];
+              } else if (value != null) {
+                if (!(part in value)) {
+                  if (!allowMissing) {
+                    throw new $TypeError("base intrinsic for " + name2 + " exists, but the property is not available.");
+                  }
+                  return void 0;
+                }
+                if ($gOPD && i2 + 1 >= parts.length) {
+                  var desc = $gOPD(value, part);
+                  isOwn = !!desc;
+                  if (isOwn && "get" in desc && !("originalValue" in desc.get)) {
+                    value = desc.get;
+                  } else {
+                    value = value[part];
+                  }
+                } else {
+                  isOwn = hasOwn(value, part);
+                  value = value[part];
+                }
+                if (isOwn && !skipFurtherCaching) {
+                  INTRINSICS[intrinsicRealName] = value;
+                }
+              }
+            }
+            return value;
+          };
+        }
+      });
+      var require_define_data_property = __commonJS({
+        "node_modules/define-data-property/index.js"(exports, module2) {
+          var $defineProperty = require_es_define_property();
+          var $SyntaxError = require_syntax();
+          var $TypeError = require_type();
+          var gopd = require_gopd();
+          module2.exports = function defineDataProperty(obj, property, value) {
+            if (!obj || typeof obj !== "object" && typeof obj !== "function") {
+              throw new $TypeError("`obj` must be an object or a function`");
+            }
+            if (typeof property !== "string" && typeof property !== "symbol") {
+              throw new $TypeError("`property` must be a string or a symbol`");
+            }
+            if (arguments.length > 3 && typeof arguments[3] !== "boolean" && arguments[3] !== null) {
+              throw new $TypeError("`nonEnumerable`, if provided, must be a boolean or null");
+            }
+            if (arguments.length > 4 && typeof arguments[4] !== "boolean" && arguments[4] !== null) {
+              throw new $TypeError("`nonWritable`, if provided, must be a boolean or null");
+            }
+            if (arguments.length > 5 && typeof arguments[5] !== "boolean" && arguments[5] !== null) {
+              throw new $TypeError("`nonConfigurable`, if provided, must be a boolean or null");
+            }
+            if (arguments.length > 6 && typeof arguments[6] !== "boolean") {
+              throw new $TypeError("`loose`, if provided, must be a boolean");
+            }
+            var nonEnumerable = arguments.length > 3 ? arguments[3] : null;
+            var nonWritable = arguments.length > 4 ? arguments[4] : null;
+            var nonConfigurable = arguments.length > 5 ? arguments[5] : null;
+            var loose = arguments.length > 6 ? arguments[6] : false;
+            var desc = !!gopd && gopd(obj, property);
+            if ($defineProperty) {
+              $defineProperty(obj, property, {
+                configurable: nonConfigurable === null && desc ? desc.configurable : !nonConfigurable,
+                enumerable: nonEnumerable === null && desc ? desc.enumerable : !nonEnumerable,
+                value,
+                writable: nonWritable === null && desc ? desc.writable : !nonWritable
+              });
+            } else if (loose || !nonEnumerable && !nonWritable && !nonConfigurable) {
+              obj[property] = value;
+            } else {
+              throw new $SyntaxError("This environment does not support defining a property as non-configurable, non-writable, or non-enumerable.");
+            }
+          };
+        }
+      });
+      var require_has_property_descriptors = __commonJS({
+        "node_modules/has-property-descriptors/index.js"(exports, module2) {
+          var $defineProperty = require_es_define_property();
+          var hasPropertyDescriptors = function hasPropertyDescriptors2() {
+            return !!$defineProperty;
+          };
+          hasPropertyDescriptors.hasArrayLengthDefineBug = function hasArrayLengthDefineBug() {
+            if (!$defineProperty) {
+              return null;
+            }
+            try {
+              return $defineProperty([], "length", { value: 1 }).length !== 1;
+            } catch (e2) {
+              return true;
+            }
+          };
+          module2.exports = hasPropertyDescriptors;
+        }
+      });
+      var require_set_function_length = __commonJS({
+        "node_modules/set-function-length/index.js"(exports, module2) {
+          var GetIntrinsic = require_get_intrinsic();
+          var define2 = require_define_data_property();
+          var hasDescriptors = require_has_property_descriptors()();
+          var gOPD = require_gopd();
+          var $TypeError = require_type();
+          var $floor = GetIntrinsic("%Math.floor%");
+          module2.exports = function setFunctionLength(fn, length2) {
+            if (typeof fn !== "function") {
+              throw new $TypeError("`fn` is not a function");
+            }
+            if (typeof length2 !== "number" || length2 < 0 || length2 > 4294967295 || $floor(length2) !== length2) {
+              throw new $TypeError("`length` must be a positive 32-bit integer");
+            }
+            var loose = arguments.length > 2 && !!arguments[2];
+            var functionLengthIsConfigurable = true;
+            var functionLengthIsWritable = true;
+            if ("length" in fn && gOPD) {
+              var desc = gOPD(fn, "length");
+              if (desc && !desc.configurable) {
+                functionLengthIsConfigurable = false;
+              }
+              if (desc && !desc.writable) {
+                functionLengthIsWritable = false;
+              }
+            }
+            if (functionLengthIsConfigurable || functionLengthIsWritable || !loose) {
+              if (hasDescriptors) {
+                define2(
+                  /** @type {Parameters<define>[0]} */
+                  fn,
+                  "length",
+                  length2,
+                  true,
+                  true
+                );
+              } else {
+                define2(
+                  /** @type {Parameters<define>[0]} */
+                  fn,
+                  "length",
+                  length2
+                );
+              }
+            }
+            return fn;
+          };
+        }
+      });
+      var require_call_bind = __commonJS({
+        "node_modules/call-bind/index.js"(exports, module2) {
+          var bind = require_function_bind();
+          var GetIntrinsic = require_get_intrinsic();
+          var setFunctionLength = require_set_function_length();
+          var $TypeError = require_type();
+          var $apply = GetIntrinsic("%Function.prototype.apply%");
+          var $call = GetIntrinsic("%Function.prototype.call%");
+          var $reflectApply = GetIntrinsic("%Reflect.apply%", true) || bind.call($call, $apply);
+          var $defineProperty = require_es_define_property();
+          var $max = GetIntrinsic("%Math.max%");
+          module2.exports = function callBind(originalFunction) {
+            if (typeof originalFunction !== "function") {
+              throw new $TypeError("a function is required");
+            }
+            var func = $reflectApply(bind, $call, arguments);
+            return setFunctionLength(
+              func,
+              1 + $max(0, originalFunction.length - (arguments.length - 1)),
+              true
+            );
+          };
+          var applyBind = function applyBind2() {
+            return $reflectApply(bind, $apply, arguments);
+          };
+          if ($defineProperty) {
+            $defineProperty(module2.exports, "apply", { value: applyBind });
+          } else {
+            module2.exports.apply = applyBind;
+          }
+        }
+      });
+      var require_callBound = __commonJS({
+        "node_modules/call-bind/callBound.js"(exports, module2) {
+          var GetIntrinsic = require_get_intrinsic();
+          var callBind = require_call_bind();
+          var $indexOf = callBind(GetIntrinsic("String.prototype.indexOf"));
+          module2.exports = function callBoundIntrinsic(name2, allowMissing) {
+            var intrinsic = GetIntrinsic(name2, !!allowMissing);
+            if (typeof intrinsic === "function" && $indexOf(name2, ".prototype.") > -1) {
+              return callBind(intrinsic);
+            }
+            return intrinsic;
+          };
+        }
+      });
+      var require_is_arguments = __commonJS({
+        "node_modules/is-arguments/index.js"(exports, module2) {
+          var hasToStringTag = require_shams2()();
+          var callBound = require_callBound();
+          var $toString = callBound("Object.prototype.toString");
+          var isStandardArguments = function isArguments(value) {
+            if (hasToStringTag && value && typeof value === "object" && Symbol.toStringTag in value) {
+              return false;
+            }
+            return $toString(value) === "[object Arguments]";
+          };
+          var isLegacyArguments = function isArguments(value) {
+            if (isStandardArguments(value)) {
+              return true;
+            }
+            return value !== null && typeof value === "object" && typeof value.length === "number" && value.length >= 0 && $toString(value) !== "[object Array]" && $toString(value.callee) === "[object Function]";
+          };
+          var supportsStandardArguments = function() {
+            return isStandardArguments(arguments);
+          }();
+          isStandardArguments.isLegacyArguments = isLegacyArguments;
+          module2.exports = supportsStandardArguments ? isStandardArguments : isLegacyArguments;
+        }
+      });
+      var require_is_generator_function = __commonJS({
+        "node_modules/is-generator-function/index.js"(exports, module2) {
+          var toStr = Object.prototype.toString;
+          var fnToStr = Function.prototype.toString;
+          var isFnRegex = /^\s*(?:function)?\*/;
+          var hasToStringTag = require_shams2()();
+          var getProto = Object.getPrototypeOf;
+          var getGeneratorFunc = function() {
+            if (!hasToStringTag) {
+              return false;
+            }
+            try {
+              return Function("return function*() {}")();
+            } catch (e2) {
+            }
+          };
+          var GeneratorFunction;
+          module2.exports = function isGeneratorFunction(fn) {
+            if (typeof fn !== "function") {
+              return false;
+            }
+            if (isFnRegex.test(fnToStr.call(fn))) {
+              return true;
+            }
+            if (!hasToStringTag) {
+              var str = toStr.call(fn);
+              return str === "[object GeneratorFunction]";
+            }
+            if (!getProto) {
+              return false;
+            }
+            if (typeof GeneratorFunction === "undefined") {
+              var generatorFunc = getGeneratorFunc();
+              GeneratorFunction = generatorFunc ? getProto(generatorFunc) : false;
+            }
+            return getProto(fn) === GeneratorFunction;
+          };
+        }
+      });
+      var require_is_callable = __commonJS({
+        "node_modules/is-callable/index.js"(exports, module2) {
+          var fnToStr = Function.prototype.toString;
+          var reflectApply = typeof Reflect === "object" && Reflect !== null && Reflect.apply;
+          var badArrayLike;
+          var isCallableMarker;
+          if (typeof reflectApply === "function" && typeof Object.defineProperty === "function") {
+            try {
+              badArrayLike = Object.defineProperty({}, "length", {
+                get: function() {
+                  throw isCallableMarker;
+                }
+              });
+              isCallableMarker = {};
+              reflectApply(function() {
+                throw 42;
+              }, null, badArrayLike);
+            } catch (_2) {
+              if (_2 !== isCallableMarker) {
+                reflectApply = null;
+              }
+            }
+          } else {
+            reflectApply = null;
+          }
+          var constructorRegex = /^\s*class\b/;
+          var isES6ClassFn = function isES6ClassFunction(value) {
+            try {
+              var fnStr = fnToStr.call(value);
+              return constructorRegex.test(fnStr);
+            } catch (e2) {
+              return false;
+            }
+          };
+          var tryFunctionObject = function tryFunctionToStr(value) {
+            try {
+              if (isES6ClassFn(value)) {
+                return false;
+              }
+              fnToStr.call(value);
+              return true;
+            } catch (e2) {
+              return false;
+            }
+          };
+          var toStr = Object.prototype.toString;
+          var objectClass = "[object Object]";
+          var fnClass = "[object Function]";
+          var genClass = "[object GeneratorFunction]";
+          var ddaClass = "[object HTMLAllCollection]";
+          var ddaClass2 = "[object HTML document.all class]";
+          var ddaClass3 = "[object HTMLCollection]";
+          var hasToStringTag = typeof Symbol === "function" && !!Symbol.toStringTag;
+          var isIE68 = !(0 in [,]);
+          var isDDA = function isDocumentDotAll() {
+            return false;
+          };
+          if (typeof document === "object") {
+            all = document.all;
+            if (toStr.call(all) === toStr.call(document.all)) {
+              isDDA = function isDocumentDotAll(value) {
+                if ((isIE68 || !value) && (typeof value === "undefined" || typeof value === "object")) {
+                  try {
+                    var str = toStr.call(value);
+                    return (str === ddaClass || str === ddaClass2 || str === ddaClass3 || str === objectClass) && value("") == null;
+                  } catch (e2) {
+                  }
+                }
+                return false;
+              };
+            }
+          }
+          var all;
+          module2.exports = reflectApply ? function isCallable(value) {
+            if (isDDA(value)) {
+              return true;
+            }
+            if (!value) {
+              return false;
+            }
+            if (typeof value !== "function" && typeof value !== "object") {
+              return false;
+            }
+            try {
+              reflectApply(value, null, badArrayLike);
+            } catch (e2) {
+              if (e2 !== isCallableMarker) {
+                return false;
+              }
+            }
+            return !isES6ClassFn(value) && tryFunctionObject(value);
+          } : function isCallable(value) {
+            if (isDDA(value)) {
+              return true;
+            }
+            if (!value) {
+              return false;
+            }
+            if (typeof value !== "function" && typeof value !== "object") {
+              return false;
+            }
+            if (hasToStringTag) {
+              return tryFunctionObject(value);
+            }
+            if (isES6ClassFn(value)) {
+              return false;
+            }
+            var strClass = toStr.call(value);
+            if (strClass !== fnClass && strClass !== genClass && !/^\[object HTML/.test(strClass)) {
+              return false;
+            }
+            return tryFunctionObject(value);
+          };
+        }
+      });
+      var require_for_each = __commonJS({
+        "node_modules/for-each/index.js"(exports, module2) {
+          var isCallable = require_is_callable();
+          var toStr = Object.prototype.toString;
+          var hasOwnProperty2 = Object.prototype.hasOwnProperty;
+          var forEachArray = function forEachArray2(array, iterator, receiver) {
+            for (var i2 = 0, len2 = array.length; i2 < len2; i2++) {
+              if (hasOwnProperty2.call(array, i2)) {
+                if (receiver == null) {
+                  iterator(array[i2], i2, array);
+                } else {
+                  iterator.call(receiver, array[i2], i2, array);
+                }
+              }
+            }
+          };
+          var forEachString = function forEachString2(string, iterator, receiver) {
+            for (var i2 = 0, len2 = string.length; i2 < len2; i2++) {
+              if (receiver == null) {
+                iterator(string.charAt(i2), i2, string);
+              } else {
+                iterator.call(receiver, string.charAt(i2), i2, string);
+              }
+            }
+          };
+          var forEachObject = function forEachObject2(object, iterator, receiver) {
+            for (var k2 in object) {
+              if (hasOwnProperty2.call(object, k2)) {
+                if (receiver == null) {
+                  iterator(object[k2], k2, object);
+                } else {
+                  iterator.call(receiver, object[k2], k2, object);
+                }
+              }
+            }
+          };
+          var forEach = function forEach2(list, iterator, thisArg) {
+            if (!isCallable(iterator)) {
+              throw new TypeError("iterator must be a function");
+            }
+            var receiver;
+            if (arguments.length >= 3) {
+              receiver = thisArg;
+            }
+            if (toStr.call(list) === "[object Array]") {
+              forEachArray(list, iterator, receiver);
+            } else if (typeof list === "string") {
+              forEachString(list, iterator, receiver);
+            } else {
+              forEachObject(list, iterator, receiver);
+            }
+          };
+          module2.exports = forEach;
+        }
+      });
+      var require_available_typed_arrays = __commonJS({
+        "node_modules/available-typed-arrays/index.js"(exports, module2) {
+          var possibleNames = [
+            "BigInt64Array",
+            "BigUint64Array",
+            "Float32Array",
+            "Float64Array",
+            "Int16Array",
+            "Int32Array",
+            "Int8Array",
+            "Uint16Array",
+            "Uint32Array",
+            "Uint8Array",
+            "Uint8ClampedArray"
+          ];
+          var g2 = typeof globalThis === "undefined" ? window : globalThis;
+          module2.exports = function availableTypedArrays() {
+            var out = [];
+            for (var i2 = 0; i2 < possibleNames.length; i2++) {
+              if (typeof g2[possibleNames[i2]] === "function") {
+                out[out.length] = possibleNames[i2];
+              }
+            }
+            return out;
+          };
+        }
+      });
+      var require_which_typed_array = __commonJS({
+        "node_modules/which-typed-array/index.js"(exports, module2) {
+          var forEach = require_for_each();
+          var availableTypedArrays = require_available_typed_arrays();
+          var callBind = require_call_bind();
+          var callBound = require_callBound();
+          var gOPD = require_gopd();
+          var $toString = callBound("Object.prototype.toString");
+          var hasToStringTag = require_shams2()();
+          var g2 = typeof globalThis === "undefined" ? window : globalThis;
+          var typedArrays = availableTypedArrays();
+          var $slice = callBound("String.prototype.slice");
+          var getPrototypeOf = Object.getPrototypeOf;
+          var $indexOf = callBound("Array.prototype.indexOf", true) || /** @type {(array: readonly unknown[], value: unknown) => keyof array} */
+          function indexOf(array, value) {
+            for (var i2 = 0; i2 < array.length; i2 += 1) {
+              if (array[i2] === value) {
+                return i2;
+              }
+            }
+            return -1;
+          };
+          var cache = { __proto__: null };
+          if (hasToStringTag && gOPD && getPrototypeOf) {
+            forEach(typedArrays, function(typedArray) {
+              var arr = new g2[typedArray]();
+              if (Symbol.toStringTag in arr) {
+                var proto = getPrototypeOf(arr);
+                var descriptor = gOPD(proto, Symbol.toStringTag);
+                if (!descriptor) {
+                  var superProto = getPrototypeOf(proto);
+                  descriptor = gOPD(superProto, Symbol.toStringTag);
+                }
+                cache["$" + typedArray] = callBind(descriptor.get);
+              }
+            });
+          } else {
+            forEach(typedArrays, function(typedArray) {
+              var arr = new g2[typedArray]();
+              var fn = arr.slice || arr.set;
+              if (fn) {
+                cache["$" + typedArray] = callBind(fn);
+              }
+            });
+          }
+          var tryTypedArrays = function tryAllTypedArrays(value) {
+            var found = false;
+            forEach(
+              // eslint-disable-next-line no-extra-parens
+              /** @type {Record<`\$${TypedArrayName}`, typeof cache>} */
+              /** @type {any} */
+              cache,
+              /** @type {(getter: typeof cache, name: `\$${TypedArrayName}`) => void} */
+              function(getter, typedArray) {
+                if (!found) {
+                  try {
+                    if ("$" + getter(value) === typedArray) {
+                      found = $slice(typedArray, 1);
+                    }
+                  } catch (e2) {
+                  }
+                }
+              }
+            );
+            return found;
+          };
+          var trySlices = function tryAllSlices(value) {
+            var found = false;
+            forEach(
+              // eslint-disable-next-line no-extra-parens
+              /** @type {any} */
+              cache,
+              /** @type {(getter: typeof cache, name: `\$${TypedArrayName}`) => void} */
+              function(getter, name2) {
+                if (!found) {
+                  try {
+                    getter(value);
+                    found = $slice(name2, 1);
+                  } catch (e2) {
+                  }
+                }
+              }
+            );
+            return found;
+          };
+          module2.exports = function whichTypedArray(value) {
+            if (!value || typeof value !== "object") {
+              return false;
+            }
+            if (!hasToStringTag) {
+              var tag = $slice($toString(value), 8, -1);
+              if ($indexOf(typedArrays, tag) > -1) {
+                return tag;
+              }
+              if (tag !== "Object") {
+                return false;
+              }
+              return trySlices(value);
+            }
+            if (!gOPD) {
+              return null;
+            }
+            return tryTypedArrays(value);
+          };
+        }
+      });
+      var require_is_typed_array = __commonJS({
+        "node_modules/is-typed-array/index.js"(exports, module2) {
+          var forEach = require_for_each();
+          var availableTypedArrays = require_available_typed_arrays();
+          var callBound = require_callBound();
+          var $toString = callBound("Object.prototype.toString");
+          var hasToStringTag = require_shams2()();
+          var gOPD = require_gopd();
+          var g2 = typeof globalThis === "undefined" ? window : globalThis;
+          var typedArrays = availableTypedArrays();
+          var $indexOf = callBound("Array.prototype.indexOf", true) || function indexOf(array, value) {
+            for (var i2 = 0; i2 < array.length; i2 += 1) {
+              if (array[i2] === value) {
+                return i2;
+              }
+            }
+            return -1;
+          };
+          var $slice = callBound("String.prototype.slice");
+          var toStrTags = {};
+          var getPrototypeOf = Object.getPrototypeOf;
+          if (hasToStringTag && gOPD && getPrototypeOf) {
+            forEach(typedArrays, function(typedArray) {
+              var arr = new g2[typedArray]();
+              if (Symbol.toStringTag in arr) {
+                var proto = getPrototypeOf(arr);
+                var descriptor = gOPD(proto, Symbol.toStringTag);
+                if (!descriptor) {
+                  var superProto = getPrototypeOf(proto);
+                  descriptor = gOPD(superProto, Symbol.toStringTag);
+                }
+                toStrTags[typedArray] = descriptor.get;
+              }
+            });
+          }
+          var tryTypedArrays = function tryAllTypedArrays(value) {
+            var anyTrue = false;
+            forEach(toStrTags, function(getter, typedArray) {
+              if (!anyTrue) {
+                try {
+                  anyTrue = getter.call(value) === typedArray;
+                } catch (e2) {
+                }
+              }
+            });
+            return anyTrue;
+          };
+          module2.exports = function isTypedArray2(value) {
+            if (!value || typeof value !== "object") {
+              return false;
+            }
+            if (!hasToStringTag || !(Symbol.toStringTag in value)) {
+              var tag = $slice($toString(value), 8, -1);
+              return $indexOf(typedArrays, tag) > -1;
+            }
+            if (!gOPD) {
+              return false;
+            }
+            return tryTypedArrays(value);
+          };
+        }
+      });
+      var require_types = __commonJS({
+        "node_modules/util/support/types.js"(exports) {
+          var isArgumentsObject = require_is_arguments();
+          var isGeneratorFunction = require_is_generator_function();
+          var whichTypedArray = require_which_typed_array();
+          var isTypedArray2 = require_is_typed_array();
+          function uncurryThis(f2) {
+            return f2.call.bind(f2);
+          }
+          var BigIntSupported = typeof BigInt !== "undefined";
+          var SymbolSupported = typeof Symbol !== "undefined";
+          var ObjectToString = uncurryThis(Object.prototype.toString);
+          var numberValue = uncurryThis(Number.prototype.valueOf);
+          var stringValue = uncurryThis(String.prototype.valueOf);
+          var booleanValue = uncurryThis(Boolean.prototype.valueOf);
+          if (BigIntSupported) {
+            bigIntValue = uncurryThis(BigInt.prototype.valueOf);
+          }
+          var bigIntValue;
+          if (SymbolSupported) {
+            symbolValue = uncurryThis(Symbol.prototype.valueOf);
+          }
+          var symbolValue;
+          function checkBoxedPrimitive(value, prototypeValueOf) {
+            if (typeof value !== "object") {
+              return false;
+            }
+            try {
+              prototypeValueOf(value);
+              return true;
+            } catch (e2) {
+              return false;
+            }
+          }
+          exports.isArgumentsObject = isArgumentsObject;
+          exports.isGeneratorFunction = isGeneratorFunction;
+          exports.isTypedArray = isTypedArray2;
+          function isPromise2(input) {
+            return typeof Promise !== "undefined" && input instanceof Promise || input !== null && typeof input === "object" && typeof input.then === "function" && typeof input.catch === "function";
+          }
+          exports.isPromise = isPromise2;
+          function isArrayBufferView(value) {
+            if (typeof ArrayBuffer !== "undefined" && ArrayBuffer.isView) {
+              return ArrayBuffer.isView(value);
+            }
+            return isTypedArray2(value) || isDataView(value);
+          }
+          exports.isArrayBufferView = isArrayBufferView;
+          function isUint8Array(value) {
+            return whichTypedArray(value) === "Uint8Array";
+          }
+          exports.isUint8Array = isUint8Array;
+          function isUint8ClampedArray(value) {
+            return whichTypedArray(value) === "Uint8ClampedArray";
+          }
+          exports.isUint8ClampedArray = isUint8ClampedArray;
+          function isUint16Array(value) {
+            return whichTypedArray(value) === "Uint16Array";
+          }
+          exports.isUint16Array = isUint16Array;
+          function isUint32Array(value) {
+            return whichTypedArray(value) === "Uint32Array";
+          }
+          exports.isUint32Array = isUint32Array;
+          function isInt8Array(value) {
+            return whichTypedArray(value) === "Int8Array";
+          }
+          exports.isInt8Array = isInt8Array;
+          function isInt16Array(value) {
+            return whichTypedArray(value) === "Int16Array";
+          }
+          exports.isInt16Array = isInt16Array;
+          function isInt32Array(value) {
+            return whichTypedArray(value) === "Int32Array";
+          }
+          exports.isInt32Array = isInt32Array;
+          function isFloat32Array(value) {
+            return whichTypedArray(value) === "Float32Array";
+          }
+          exports.isFloat32Array = isFloat32Array;
+          function isFloat64Array(value) {
+            return whichTypedArray(value) === "Float64Array";
+          }
+          exports.isFloat64Array = isFloat64Array;
+          function isBigInt64Array(value) {
+            return whichTypedArray(value) === "BigInt64Array";
+          }
+          exports.isBigInt64Array = isBigInt64Array;
+          function isBigUint64Array(value) {
+            return whichTypedArray(value) === "BigUint64Array";
+          }
+          exports.isBigUint64Array = isBigUint64Array;
+          function isMapToString(value) {
+            return ObjectToString(value) === "[object Map]";
+          }
+          isMapToString.working = typeof Map !== "undefined" && isMapToString(/* @__PURE__ */ new Map());
+          function isMap(value) {
+            if (typeof Map === "undefined") {
+              return false;
+            }
+            return isMapToString.working ? isMapToString(value) : value instanceof Map;
+          }
+          exports.isMap = isMap;
+          function isSetToString(value) {
+            return ObjectToString(value) === "[object Set]";
+          }
+          isSetToString.working = typeof Set !== "undefined" && isSetToString(/* @__PURE__ */ new Set());
+          function isSet(value) {
+            if (typeof Set === "undefined") {
+              return false;
+            }
+            return isSetToString.working ? isSetToString(value) : value instanceof Set;
+          }
+          exports.isSet = isSet;
+          function isWeakMapToString(value) {
+            return ObjectToString(value) === "[object WeakMap]";
+          }
+          isWeakMapToString.working = typeof WeakMap !== "undefined" && isWeakMapToString(/* @__PURE__ */ new WeakMap());
+          function isWeakMap(value) {
+            if (typeof WeakMap === "undefined") {
+              return false;
+            }
+            return isWeakMapToString.working ? isWeakMapToString(value) : value instanceof WeakMap;
+          }
+          exports.isWeakMap = isWeakMap;
+          function isWeakSetToString(value) {
+            return ObjectToString(value) === "[object WeakSet]";
+          }
+          isWeakSetToString.working = typeof WeakSet !== "undefined" && isWeakSetToString(/* @__PURE__ */ new WeakSet());
+          function isWeakSet(value) {
+            return isWeakSetToString(value);
+          }
+          exports.isWeakSet = isWeakSet;
+          function isArrayBufferToString(value) {
+            return ObjectToString(value) === "[object ArrayBuffer]";
+          }
+          isArrayBufferToString.working = typeof ArrayBuffer !== "undefined" && isArrayBufferToString(new ArrayBuffer());
+          function isArrayBuffer(value) {
+            if (typeof ArrayBuffer === "undefined") {
+              return false;
+            }
+            return isArrayBufferToString.working ? isArrayBufferToString(value) : value instanceof ArrayBuffer;
+          }
+          exports.isArrayBuffer = isArrayBuffer;
+          function isDataViewToString(value) {
+            return ObjectToString(value) === "[object DataView]";
+          }
+          isDataViewToString.working = typeof ArrayBuffer !== "undefined" && typeof DataView !== "undefined" && isDataViewToString(new DataView(new ArrayBuffer(1), 0, 1));
+          function isDataView(value) {
+            if (typeof DataView === "undefined") {
+              return false;
+            }
+            return isDataViewToString.working ? isDataViewToString(value) : value instanceof DataView;
+          }
+          exports.isDataView = isDataView;
+          var SharedArrayBufferCopy = typeof SharedArrayBuffer !== "undefined" ? SharedArrayBuffer : void 0;
+          function isSharedArrayBufferToString(value) {
+            return ObjectToString(value) === "[object SharedArrayBuffer]";
+          }
+          function isSharedArrayBuffer(value) {
+            if (typeof SharedArrayBufferCopy === "undefined") {
+              return false;
+            }
+            if (typeof isSharedArrayBufferToString.working === "undefined") {
+              isSharedArrayBufferToString.working = isSharedArrayBufferToString(new SharedArrayBufferCopy());
+            }
+            return isSharedArrayBufferToString.working ? isSharedArrayBufferToString(value) : value instanceof SharedArrayBufferCopy;
+          }
+          exports.isSharedArrayBuffer = isSharedArrayBuffer;
+          function isAsyncFunction(value) {
+            return ObjectToString(value) === "[object AsyncFunction]";
+          }
+          exports.isAsyncFunction = isAsyncFunction;
+          function isMapIterator(value) {
+            return ObjectToString(value) === "[object Map Iterator]";
+          }
+          exports.isMapIterator = isMapIterator;
+          function isSetIterator(value) {
+            return ObjectToString(value) === "[object Set Iterator]";
+          }
+          exports.isSetIterator = isSetIterator;
+          function isGeneratorObject(value) {
+            return ObjectToString(value) === "[object Generator]";
+          }
+          exports.isGeneratorObject = isGeneratorObject;
+          function isWebAssemblyCompiledModule(value) {
+            return ObjectToString(value) === "[object WebAssembly.Module]";
+          }
+          exports.isWebAssemblyCompiledModule = isWebAssemblyCompiledModule;
+          function isNumberObject(value) {
+            return checkBoxedPrimitive(value, numberValue);
+          }
+          exports.isNumberObject = isNumberObject;
+          function isStringObject(value) {
+            return checkBoxedPrimitive(value, stringValue);
+          }
+          exports.isStringObject = isStringObject;
+          function isBooleanObject(value) {
+            return checkBoxedPrimitive(value, booleanValue);
+          }
+          exports.isBooleanObject = isBooleanObject;
+          function isBigIntObject(value) {
+            return BigIntSupported && checkBoxedPrimitive(value, bigIntValue);
+          }
+          exports.isBigIntObject = isBigIntObject;
+          function isSymbolObject(value) {
+            return SymbolSupported && checkBoxedPrimitive(value, symbolValue);
+          }
+          exports.isSymbolObject = isSymbolObject;
+          function isBoxedPrimitive(value) {
+            return isNumberObject(value) || isStringObject(value) || isBooleanObject(value) || isBigIntObject(value) || isSymbolObject(value);
+          }
+          exports.isBoxedPrimitive = isBoxedPrimitive;
+          function isAnyArrayBuffer(value) {
+            return typeof Uint8Array !== "undefined" && (isArrayBuffer(value) || isSharedArrayBuffer(value));
+          }
+          exports.isAnyArrayBuffer = isAnyArrayBuffer;
+          ["isProxy", "isExternal", "isModuleNamespaceObject"].forEach(function(method) {
+            Object.defineProperty(exports, method, {
+              enumerable: false,
+              value: function() {
+                throw new Error(method + " is not supported in userland");
+              }
+            });
+          });
+        }
+      });
+      var require_isBufferBrowser = __commonJS({
+        "node_modules/util/support/isBufferBrowser.js"(exports, module2) {
+          module2.exports = function isBuffer2(arg) {
+            return arg && typeof arg === "object" && typeof arg.copy === "function" && typeof arg.fill === "function" && typeof arg.readUInt8 === "function";
+          };
+        }
+      });
+      var require_util = __commonJS({
+        "(disabled):node_modules/util/util.js"(exports) {
+          var getOwnPropertyDescriptors = Object.getOwnPropertyDescriptors || function getOwnPropertyDescriptors2(obj) {
+            var keys = Object.keys(obj);
+            var descriptors = {};
+            for (var i2 = 0; i2 < keys.length; i2++) {
+              descriptors[keys[i2]] = Object.getOwnPropertyDescriptor(obj, keys[i2]);
+            }
+            return descriptors;
+          };
+          var formatRegExp = /%[sdj%]/g;
+          exports.format = function(f2) {
+            if (!isString(f2)) {
+              var objects = [];
+              for (var i2 = 0; i2 < arguments.length; i2++) {
+                objects.push(inspect(arguments[i2]));
+              }
+              return objects.join(" ");
+            }
+            var i2 = 1;
+            var args = arguments;
+            var len2 = args.length;
+            var str = String(f2).replace(formatRegExp, function(x22) {
+              if (x22 === "%%") return "%";
+              if (i2 >= len2) return x22;
+              switch (x22) {
+                case "%s":
+                  return String(args[i2++]);
+                case "%d":
+                  return Number(args[i2++]);
+                case "%j":
+                  try {
+                    return JSON.stringify(args[i2++]);
+                  } catch (_2) {
+                    return "[Circular]";
+                  }
+                default:
+                  return x22;
+              }
+            });
+            for (var x2 = args[i2]; i2 < len2; x2 = args[++i2]) {
+              if (isNull(x2) || !isObject2(x2)) {
+                str += " " + x2;
+              } else {
+                str += " " + inspect(x2);
+              }
+            }
+            return str;
+          };
+          exports.deprecate = function(fn, msg) {
+            if (typeof process !== "undefined" && process.noDeprecation === true) {
+              return fn;
+            }
+            if (typeof process === "undefined") {
+              return function() {
+                return exports.deprecate(fn, msg).apply(this, arguments);
+              };
+            }
+            var warned = false;
+            function deprecated() {
+              if (!warned) {
+                if (process.throwDeprecation) {
+                  throw new Error(msg);
+                } else if (process.traceDeprecation) {
+                  console.trace(msg);
+                } else {
+                  console.error(msg);
+                }
+                warned = true;
+              }
+              return fn.apply(this, arguments);
+            }
+            return deprecated;
+          };
+          var debugs = {};
+          var debugEnvRegex = /^$/;
+          {
+            debugEnv = "false";
+            debugEnv = debugEnv.replace(/[|\\{}()[\]^$+?.]/g, "\\$&").replace(/\*/g, ".*").replace(/,/g, "$|^").toUpperCase();
+            debugEnvRegex = new RegExp("^" + debugEnv + "$", "i");
+          }
+          var debugEnv;
+          exports.debuglog = function(set) {
+            set = set.toUpperCase();
+            if (!debugs[set]) {
+              if (debugEnvRegex.test(set)) {
+                var pid = process.pid;
+                debugs[set] = function() {
+                  var msg = exports.format.apply(exports, arguments);
+                  console.error("%s %d: %s", set, pid, msg);
+                };
+              } else {
+                debugs[set] = function() {
+                };
+              }
+            }
+            return debugs[set];
+          };
+          function inspect(obj, opts) {
+            var ctx2 = {
+              seen: [],
+              stylize: stylizeNoColor
+            };
+            if (arguments.length >= 3) ctx2.depth = arguments[2];
+            if (arguments.length >= 4) ctx2.colors = arguments[3];
+            if (isBoolean2(opts)) {
+              ctx2.showHidden = opts;
+            } else if (opts) {
+              exports._extend(ctx2, opts);
+            }
+            if (isUndefined(ctx2.showHidden)) ctx2.showHidden = false;
+            if (isUndefined(ctx2.depth)) ctx2.depth = 2;
+            if (isUndefined(ctx2.colors)) ctx2.colors = false;
+            if (isUndefined(ctx2.customInspect)) ctx2.customInspect = true;
+            if (ctx2.colors) ctx2.stylize = stylizeWithColor;
+            return formatValue2(ctx2, obj, ctx2.depth);
+          }
+          exports.inspect = inspect;
+          inspect.colors = {
+            "bold": [1, 22],
+            "italic": [3, 23],
+            "underline": [4, 24],
+            "inverse": [7, 27],
+            "white": [37, 39],
+            "grey": [90, 39],
+            "black": [30, 39],
+            "blue": [34, 39],
+            "cyan": [36, 39],
+            "green": [32, 39],
+            "magenta": [35, 39],
+            "red": [31, 39],
+            "yellow": [33, 39]
+          };
+          inspect.styles = {
+            "special": "cyan",
+            "number": "yellow",
+            "boolean": "yellow",
+            "undefined": "grey",
+            "null": "bold",
+            "string": "green",
+            "date": "magenta",
+            // "name": intentionally not styling
+            "regexp": "red"
+          };
+          function stylizeWithColor(str, styleType) {
+            var style = inspect.styles[styleType];
+            if (style) {
+              return "\x1B[" + inspect.colors[style][0] + "m" + str + "\x1B[" + inspect.colors[style][1] + "m";
+            } else {
+              return str;
+            }
+          }
+          function stylizeNoColor(str, styleType) {
+            return str;
+          }
+          function arrayToHash(array) {
+            var hash = {};
+            array.forEach(function(val, idx) {
+              hash[val] = true;
+            });
+            return hash;
+          }
+          function formatValue2(ctx2, value, recurseTimes) {
+            if (ctx2.customInspect && value && isFunction2(value.inspect) && // Filter out the util module, it's inspect function is special
+            value.inspect !== exports.inspect && // Also filter out any prototype objects using the circular check.
+            !(value.constructor && value.constructor.prototype === value)) {
+              var ret = value.inspect(recurseTimes, ctx2);
+              if (!isString(ret)) {
+                ret = formatValue2(ctx2, ret, recurseTimes);
+              }
+              return ret;
+            }
+            var primitive = formatPrimitive(ctx2, value);
+            if (primitive) {
+              return primitive;
+            }
+            var keys = Object.keys(value);
+            var visibleKeys = arrayToHash(keys);
+            if (ctx2.showHidden) {
+              keys = Object.getOwnPropertyNames(value);
+            }
+            if (isError(value) && (keys.indexOf("message") >= 0 || keys.indexOf("description") >= 0)) {
+              return formatError(value);
+            }
+            if (keys.length === 0) {
+              if (isFunction2(value)) {
+                var name2 = value.name ? ": " + value.name : "";
+                return ctx2.stylize("[Function" + name2 + "]", "special");
+              }
+              if (isRegExp(value)) {
+                return ctx2.stylize(RegExp.prototype.toString.call(value), "regexp");
+              }
+              if (isDate(value)) {
+                return ctx2.stylize(Date.prototype.toString.call(value), "date");
+              }
+              if (isError(value)) {
+                return formatError(value);
+              }
+            }
+            var base = "", array = false, braces = ["{", "}"];
+            if (isArray2(value)) {
+              array = true;
+              braces = ["[", "]"];
+            }
+            if (isFunction2(value)) {
+              var n2 = value.name ? ": " + value.name : "";
+              base = " [Function" + n2 + "]";
+            }
+            if (isRegExp(value)) {
+              base = " " + RegExp.prototype.toString.call(value);
+            }
+            if (isDate(value)) {
+              base = " " + Date.prototype.toUTCString.call(value);
+            }
+            if (isError(value)) {
+              base = " " + formatError(value);
+            }
+            if (keys.length === 0 && (!array || value.length == 0)) {
+              return braces[0] + base + braces[1];
+            }
+            if (recurseTimes < 0) {
+              if (isRegExp(value)) {
+                return ctx2.stylize(RegExp.prototype.toString.call(value), "regexp");
+              } else {
+                return ctx2.stylize("[Object]", "special");
+              }
+            }
+            ctx2.seen.push(value);
+            var output;
+            if (array) {
+              output = formatArray(ctx2, value, recurseTimes, visibleKeys, keys);
+            } else {
+              output = keys.map(function(key) {
+                return formatProperty(ctx2, value, recurseTimes, visibleKeys, key, array);
+              });
+            }
+            ctx2.seen.pop();
+            return reduceToSingleString(output, base, braces);
+          }
+          function formatPrimitive(ctx2, value) {
+            if (isUndefined(value))
+              return ctx2.stylize("undefined", "undefined");
+            if (isString(value)) {
+              var simple = "'" + JSON.stringify(value).replace(/^"|"$/g, "").replace(/'/g, "\\'").replace(/\\"/g, '"') + "'";
+              return ctx2.stylize(simple, "string");
+            }
+            if (isNumber2(value))
+              return ctx2.stylize("" + value, "number");
+            if (isBoolean2(value))
+              return ctx2.stylize("" + value, "boolean");
+            if (isNull(value))
+              return ctx2.stylize("null", "null");
+          }
+          function formatError(value) {
+            return "[" + Error.prototype.toString.call(value) + "]";
+          }
+          function formatArray(ctx2, value, recurseTimes, visibleKeys, keys) {
+            var output = [];
+            for (var i2 = 0, l2 = value.length; i2 < l2; ++i2) {
+              if (hasOwnProperty2(value, String(i2))) {
+                output.push(formatProperty(
+                  ctx2,
+                  value,
+                  recurseTimes,
+                  visibleKeys,
+                  String(i2),
+                  true
+                ));
+              } else {
+                output.push("");
+              }
+            }
+            keys.forEach(function(key) {
+              if (!key.match(/^\d+$/)) {
+                output.push(formatProperty(
+                  ctx2,
+                  value,
+                  recurseTimes,
+                  visibleKeys,
+                  key,
+                  true
+                ));
+              }
+            });
+            return output;
+          }
+          function formatProperty(ctx2, value, recurseTimes, visibleKeys, key, array) {
+            var name2, str, desc;
+            desc = Object.getOwnPropertyDescriptor(value, key) || { value: value[key] };
+            if (desc.get) {
+              if (desc.set) {
+                str = ctx2.stylize("[Getter/Setter]", "special");
+              } else {
+                str = ctx2.stylize("[Getter]", "special");
+              }
+            } else {
+              if (desc.set) {
+                str = ctx2.stylize("[Setter]", "special");
+              }
+            }
+            if (!hasOwnProperty2(visibleKeys, key)) {
+              name2 = "[" + key + "]";
+            }
+            if (!str) {
+              if (ctx2.seen.indexOf(desc.value) < 0) {
+                if (isNull(recurseTimes)) {
+                  str = formatValue2(ctx2, desc.value, null);
+                } else {
+                  str = formatValue2(ctx2, desc.value, recurseTimes - 1);
+                }
+                if (str.indexOf("\n") > -1) {
+                  if (array) {
+                    str = str.split("\n").map(function(line) {
+                      return "  " + line;
+                    }).join("\n").slice(2);
+                  } else {
+                    str = "\n" + str.split("\n").map(function(line) {
+                      return "   " + line;
+                    }).join("\n");
+                  }
+                }
+              } else {
+                str = ctx2.stylize("[Circular]", "special");
+              }
+            }
+            if (isUndefined(name2)) {
+              if (array && key.match(/^\d+$/)) {
+                return str;
+              }
+              name2 = JSON.stringify("" + key);
+              if (name2.match(/^"([a-zA-Z_][a-zA-Z_0-9]*)"$/)) {
+                name2 = name2.slice(1, -1);
+                name2 = ctx2.stylize(name2, "name");
+              } else {
+                name2 = name2.replace(/'/g, "\\'").replace(/\\"/g, '"').replace(/(^"|"$)/g, "'");
+                name2 = ctx2.stylize(name2, "string");
+              }
+            }
+            return name2 + ": " + str;
+          }
+          function reduceToSingleString(output, base, braces) {
+            var length2 = output.reduce(function(prev, cur) {
+              if (cur.indexOf("\n") >= 0) ;
+              return prev + cur.replace(/\u001b\[\d\d?m/g, "").length + 1;
+            }, 0);
+            if (length2 > 60) {
+              return braces[0] + (base === "" ? "" : base + "\n ") + " " + output.join(",\n  ") + " " + braces[1];
+            }
+            return braces[0] + base + " " + output.join(", ") + " " + braces[1];
+          }
+          exports.types = require_types();
+          function isArray2(ar) {
+            return Array.isArray(ar);
+          }
+          exports.isArray = isArray2;
+          function isBoolean2(arg) {
+            return typeof arg === "boolean";
+          }
+          exports.isBoolean = isBoolean2;
+          function isNull(arg) {
+            return arg === null;
+          }
+          exports.isNull = isNull;
+          function isNullOrUndefined(arg) {
+            return arg == null;
+          }
+          exports.isNullOrUndefined = isNullOrUndefined;
+          function isNumber2(arg) {
+            return typeof arg === "number";
+          }
+          exports.isNumber = isNumber2;
+          function isString(arg) {
+            return typeof arg === "string";
+          }
+          exports.isString = isString;
+          function isSymbol(arg) {
+            return typeof arg === "symbol";
+          }
+          exports.isSymbol = isSymbol;
+          function isUndefined(arg) {
+            return arg === void 0;
+          }
+          exports.isUndefined = isUndefined;
+          function isRegExp(re2) {
+            return isObject2(re2) && objectToString(re2) === "[object RegExp]";
+          }
+          exports.isRegExp = isRegExp;
+          exports.types.isRegExp = isRegExp;
+          function isObject2(arg) {
+            return typeof arg === "object" && arg !== null;
+          }
+          exports.isObject = isObject2;
+          function isDate(d2) {
+            return isObject2(d2) && objectToString(d2) === "[object Date]";
+          }
+          exports.isDate = isDate;
+          exports.types.isDate = isDate;
+          function isError(e2) {
+            return isObject2(e2) && (objectToString(e2) === "[object Error]" || e2 instanceof Error);
+          }
+          exports.isError = isError;
+          exports.types.isNativeError = isError;
+          function isFunction2(arg) {
+            return typeof arg === "function";
+          }
+          exports.isFunction = isFunction2;
+          function isPrimitive(arg) {
+            return arg === null || typeof arg === "boolean" || typeof arg === "number" || typeof arg === "string" || typeof arg === "symbol" || // ES6 symbol
+            typeof arg === "undefined";
+          }
+          exports.isPrimitive = isPrimitive;
+          exports.isBuffer = require_isBufferBrowser();
+          function objectToString(o2) {
+            return Object.prototype.toString.call(o2);
+          }
+          function pad(n2) {
+            return n2 < 10 ? "0" + n2.toString(10) : n2.toString(10);
+          }
+          var months = [
+            "Jan",
+            "Feb",
+            "Mar",
+            "Apr",
+            "May",
+            "Jun",
+            "Jul",
+            "Aug",
+            "Sep",
+            "Oct",
+            "Nov",
+            "Dec"
+          ];
+          function timestamp() {
+            var d2 = /* @__PURE__ */ new Date();
+            var time = [
+              pad(d2.getHours()),
+              pad(d2.getMinutes()),
+              pad(d2.getSeconds())
+            ].join(":");
+            return [d2.getDate(), months[d2.getMonth()], time].join(" ");
+          }
+          exports.log = function() {
+            console.log("%s - %s", timestamp(), exports.format.apply(exports, arguments));
+          };
+          exports.inherits = require_inherits_browser();
+          exports._extend = function(origin, add2) {
+            if (!add2 || !isObject2(add2)) return origin;
+            var keys = Object.keys(add2);
+            var i2 = keys.length;
+            while (i2--) {
+              origin[keys[i2]] = add2[keys[i2]];
+            }
+            return origin;
+          };
+          function hasOwnProperty2(obj, prop) {
+            return Object.prototype.hasOwnProperty.call(obj, prop);
+          }
+          var kCustomPromisifiedSymbol = typeof Symbol !== "undefined" ? Symbol("util.promisify.custom") : void 0;
+          exports.promisify = function promisify(original) {
+            if (typeof original !== "function")
+              throw new TypeError('The "original" argument must be of type Function');
+            if (kCustomPromisifiedSymbol && original[kCustomPromisifiedSymbol]) {
+              var fn = original[kCustomPromisifiedSymbol];
+              if (typeof fn !== "function") {
+                throw new TypeError('The "util.promisify.custom" argument must be of type Function');
+              }
+              Object.defineProperty(fn, kCustomPromisifiedSymbol, {
+                value: fn,
+                enumerable: false,
+                writable: false,
+                configurable: true
+              });
+              return fn;
+            }
+            function fn() {
+              var promiseResolve, promiseReject;
+              var promise = new Promise(function(resolve, reject) {
+                promiseResolve = resolve;
+                promiseReject = reject;
+              });
+              var args = [];
+              for (var i2 = 0; i2 < arguments.length; i2++) {
+                args.push(arguments[i2]);
+              }
+              args.push(function(err, value) {
+                if (err) {
+                  promiseReject(err);
+                } else {
+                  promiseResolve(value);
+                }
+              });
+              try {
+                original.apply(this, args);
+              } catch (err) {
+                promiseReject(err);
+              }
+              return promise;
+            }
+            Object.setPrototypeOf(fn, Object.getPrototypeOf(original));
+            if (kCustomPromisifiedSymbol) Object.defineProperty(fn, kCustomPromisifiedSymbol, {
+              value: fn,
+              enumerable: false,
+              writable: false,
+              configurable: true
+            });
+            return Object.defineProperties(
+              fn,
+              getOwnPropertyDescriptors(original)
+            );
+          };
+          exports.promisify.custom = kCustomPromisifiedSymbol;
+          function callbackifyOnRejected(reason, cb2) {
+            if (!reason) {
+              var newReason = new Error("Promise was rejected with a falsy value");
+              newReason.reason = reason;
+              reason = newReason;
+            }
+            return cb2(reason);
+          }
+          function callbackify(original) {
+            if (typeof original !== "function") {
+              throw new TypeError('The "original" argument must be of type Function');
+            }
+            function callbackified() {
+              var args = [];
+              for (var i2 = 0; i2 < arguments.length; i2++) {
+                args.push(arguments[i2]);
+              }
+              var maybeCb = args.pop();
+              if (typeof maybeCb !== "function") {
+                throw new TypeError("The last argument must be of type Function");
+              }
+              var self2 = this;
+              var cb2 = function() {
+                return maybeCb.apply(self2, arguments);
+              };
+              original.apply(this, args).then(
+                function(ret) {
+                  process.nextTick(cb2.bind(null, null, ret));
+                },
+                function(rej) {
+                  process.nextTick(callbackifyOnRejected.bind(null, rej, cb2));
+                }
+              );
+            }
+            Object.setPrototypeOf(callbackified, Object.getPrototypeOf(original));
+            Object.defineProperties(
+              callbackified,
+              getOwnPropertyDescriptors(original)
+            );
+            return callbackified;
+          }
+          exports.callbackify = callbackify;
+        }
+      });
+      var require_buffer_list = __commonJS({
+        "node_modules/stream-browserify/node_modules/readable-stream/lib/internal/streams/buffer_list.js"(exports, module2) {
+          function ownKeys(object, enumerableOnly) {
+            var keys = Object.keys(object);
+            if (Object.getOwnPropertySymbols) {
+              var symbols = Object.getOwnPropertySymbols(object);
+              if (enumerableOnly) symbols = symbols.filter(function(sym) {
+                return Object.getOwnPropertyDescriptor(object, sym).enumerable;
+              });
+              keys.push.apply(keys, symbols);
+            }
+            return keys;
+          }
+          function _objectSpread(target) {
+            for (var i2 = 1; i2 < arguments.length; i2++) {
+              var source2 = arguments[i2] != null ? arguments[i2] : {};
+              if (i2 % 2) {
+                ownKeys(Object(source2), true).forEach(function(key) {
+                  _defineProperty(target, key, source2[key]);
+                });
+              } else if (Object.getOwnPropertyDescriptors) {
+                Object.defineProperties(target, Object.getOwnPropertyDescriptors(source2));
+              } else {
+                ownKeys(Object(source2)).forEach(function(key) {
+                  Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source2, key));
+                });
+              }
+            }
+            return target;
+          }
+          function _defineProperty(obj, key, value) {
+            if (key in obj) {
+              Object.defineProperty(obj, key, { value, enumerable: true, configurable: true, writable: true });
+            } else {
+              obj[key] = value;
+            }
+            return obj;
+          }
+          function _classCallCheck(instance2, Constructor) {
+            if (!(instance2 instanceof Constructor)) {
+              throw new TypeError("Cannot call a class as a function");
+            }
+          }
+          function _defineProperties(target, props) {
+            for (var i2 = 0; i2 < props.length; i2++) {
+              var descriptor = props[i2];
+              descriptor.enumerable = descriptor.enumerable || false;
+              descriptor.configurable = true;
+              if ("value" in descriptor) descriptor.writable = true;
+              Object.defineProperty(target, descriptor.key, descriptor);
+            }
+          }
+          function _createClass(Constructor, protoProps, staticProps) {
+            if (protoProps) _defineProperties(Constructor.prototype, protoProps);
+            return Constructor;
+          }
+          var _require = require_buffer();
+          var Buffer22 = _require.Buffer;
+          var _require2 = require_util();
+          var inspect = _require2.inspect;
+          var custom = inspect && inspect.custom || "inspect";
+          function copyBuffer(src, target, offset) {
+            Buffer22.prototype.copy.call(src, target, offset);
+          }
+          module2.exports = /* @__PURE__ */ function() {
+            function BufferList() {
+              _classCallCheck(this, BufferList);
+              this.head = null;
+              this.tail = null;
+              this.length = 0;
+            }
+            _createClass(BufferList, [{
+              key: "push",
+              value: function push(v2) {
+                var entry = {
+                  data: v2,
+                  next: null
+                };
+                if (this.length > 0) this.tail.next = entry;
+                else this.head = entry;
+                this.tail = entry;
+                ++this.length;
+              }
+            }, {
+              key: "unshift",
+              value: function unshift(v2) {
+                var entry = {
+                  data: v2,
+                  next: this.head
+                };
+                if (this.length === 0) this.tail = entry;
+                this.head = entry;
+                ++this.length;
+              }
+            }, {
+              key: "shift",
+              value: function shift() {
+                if (this.length === 0) return;
+                var ret = this.head.data;
+                if (this.length === 1) this.head = this.tail = null;
+                else this.head = this.head.next;
+                --this.length;
+                return ret;
+              }
+            }, {
+              key: "clear",
+              value: function clear() {
+                this.head = this.tail = null;
+                this.length = 0;
+              }
+            }, {
+              key: "join",
+              value: function join(s2) {
+                if (this.length === 0) return "";
+                var p2 = this.head;
+                var ret = "" + p2.data;
+                while (p2 = p2.next) {
+                  ret += s2 + p2.data;
+                }
+                return ret;
+              }
+            }, {
+              key: "concat",
+              value: function concat(n2) {
+                if (this.length === 0) return Buffer22.alloc(0);
+                var ret = Buffer22.allocUnsafe(n2 >>> 0);
+                var p2 = this.head;
+                var i2 = 0;
+                while (p2) {
+                  copyBuffer(p2.data, ret, i2);
+                  i2 += p2.data.length;
+                  p2 = p2.next;
+                }
+                return ret;
+              }
+              // Consumes a specified amount of bytes or characters from the buffered data.
+            }, {
+              key: "consume",
+              value: function consume(n2, hasStrings) {
+                var ret;
+                if (n2 < this.head.data.length) {
+                  ret = this.head.data.slice(0, n2);
+                  this.head.data = this.head.data.slice(n2);
+                } else if (n2 === this.head.data.length) {
+                  ret = this.shift();
+                } else {
+                  ret = hasStrings ? this._getString(n2) : this._getBuffer(n2);
+                }
+                return ret;
+              }
+            }, {
+              key: "first",
+              value: function first() {
+                return this.head.data;
+              }
+              // Consumes a specified amount of characters from the buffered data.
+            }, {
+              key: "_getString",
+              value: function _getString(n2) {
+                var p2 = this.head;
+                var c2 = 1;
+                var ret = p2.data;
+                n2 -= ret.length;
+                while (p2 = p2.next) {
+                  var str = p2.data;
+                  var nb2 = n2 > str.length ? str.length : n2;
+                  if (nb2 === str.length) ret += str;
+                  else ret += str.slice(0, n2);
+                  n2 -= nb2;
+                  if (n2 === 0) {
+                    if (nb2 === str.length) {
+                      ++c2;
+                      if (p2.next) this.head = p2.next;
+                      else this.head = this.tail = null;
+                    } else {
+                      this.head = p2;
+                      p2.data = str.slice(nb2);
+                    }
+                    break;
+                  }
+                  ++c2;
+                }
+                this.length -= c2;
+                return ret;
+              }
+              // Consumes a specified amount of bytes from the buffered data.
+            }, {
+              key: "_getBuffer",
+              value: function _getBuffer(n2) {
+                var ret = Buffer22.allocUnsafe(n2);
+                var p2 = this.head;
+                var c2 = 1;
+                p2.data.copy(ret);
+                n2 -= p2.data.length;
+                while (p2 = p2.next) {
+                  var buf = p2.data;
+                  var nb2 = n2 > buf.length ? buf.length : n2;
+                  buf.copy(ret, ret.length - n2, 0, nb2);
+                  n2 -= nb2;
+                  if (n2 === 0) {
+                    if (nb2 === buf.length) {
+                      ++c2;
+                      if (p2.next) this.head = p2.next;
+                      else this.head = this.tail = null;
+                    } else {
+                      this.head = p2;
+                      p2.data = buf.slice(nb2);
+                    }
+                    break;
+                  }
+                  ++c2;
+                }
+                this.length -= c2;
+                return ret;
+              }
+              // Make sure the linked list only shows the minimal necessary information.
+            }, {
+              key: custom,
+              value: function value(_2, options) {
+                return inspect(this, _objectSpread({}, options, {
+                  // Only inspect one level.
+                  depth: 0,
+                  // It should not recurse.
+                  customInspect: false
+                }));
+              }
+            }]);
+            return BufferList;
+          }();
+        }
+      });
+      var require_destroy = __commonJS({
+        "node_modules/stream-browserify/node_modules/readable-stream/lib/internal/streams/destroy.js"(exports, module2) {
+          function destroy(err, cb2) {
+            var _this = this;
+            var readableDestroyed = this._readableState && this._readableState.destroyed;
+            var writableDestroyed = this._writableState && this._writableState.destroyed;
+            if (readableDestroyed || writableDestroyed) {
+              if (cb2) {
+                cb2(err);
+              } else if (err) {
+                if (!this._writableState) {
+                  process.nextTick(emitErrorNT, this, err);
+                } else if (!this._writableState.errorEmitted) {
+                  this._writableState.errorEmitted = true;
+                  process.nextTick(emitErrorNT, this, err);
+                }
+              }
+              return this;
+            }
+            if (this._readableState) {
+              this._readableState.destroyed = true;
+            }
+            if (this._writableState) {
+              this._writableState.destroyed = true;
+            }
+            this._destroy(err || null, function(err2) {
+              if (!cb2 && err2) {
+                if (!_this._writableState) {
+                  process.nextTick(emitErrorAndCloseNT, _this, err2);
+                } else if (!_this._writableState.errorEmitted) {
+                  _this._writableState.errorEmitted = true;
+                  process.nextTick(emitErrorAndCloseNT, _this, err2);
+                } else {
+                  process.nextTick(emitCloseNT, _this);
+                }
+              } else if (cb2) {
+                process.nextTick(emitCloseNT, _this);
+                cb2(err2);
+              } else {
+                process.nextTick(emitCloseNT, _this);
+              }
+            });
+            return this;
+          }
+          function emitErrorAndCloseNT(self2, err) {
+            emitErrorNT(self2, err);
+            emitCloseNT(self2);
+          }
+          function emitCloseNT(self2) {
+            if (self2._writableState && !self2._writableState.emitClose) return;
+            if (self2._readableState && !self2._readableState.emitClose) return;
+            self2.emit("close");
+          }
+          function undestroy() {
+            if (this._readableState) {
+              this._readableState.destroyed = false;
+              this._readableState.reading = false;
+              this._readableState.ended = false;
+              this._readableState.endEmitted = false;
+            }
+            if (this._writableState) {
+              this._writableState.destroyed = false;
+              this._writableState.ended = false;
+              this._writableState.ending = false;
+              this._writableState.finalCalled = false;
+              this._writableState.prefinished = false;
+              this._writableState.finished = false;
+              this._writableState.errorEmitted = false;
+            }
+          }
+          function emitErrorNT(self2, err) {
+            self2.emit("error", err);
+          }
+          function errorOrDestroy(stream, err) {
+            var rState = stream._readableState;
+            var wState = stream._writableState;
+            if (rState && rState.autoDestroy || wState && wState.autoDestroy) stream.destroy(err);
+            else stream.emit("error", err);
+          }
+          module2.exports = {
+            destroy,
+            undestroy,
+            errorOrDestroy
+          };
+        }
+      });
+      var require_errors_browser = __commonJS({
+        "node_modules/stream-browserify/node_modules/readable-stream/errors-browser.js"(exports, module2) {
+          function _inheritsLoose(subClass, superClass) {
+            subClass.prototype = Object.create(superClass.prototype);
+            subClass.prototype.constructor = subClass;
+            subClass.__proto__ = superClass;
+          }
+          var codes = {};
+          function createErrorType(code, message2, Base) {
+            if (!Base) {
+              Base = Error;
+            }
+            function getMessage(arg1, arg2, arg3) {
+              if (typeof message2 === "string") {
+                return message2;
+              } else {
+                return message2(arg1, arg2, arg3);
+              }
+            }
+            var NodeError = /* @__PURE__ */ function(_Base) {
+              _inheritsLoose(NodeError2, _Base);
+              function NodeError2(arg1, arg2, arg3) {
+                return _Base.call(this, getMessage(arg1, arg2, arg3)) || this;
+              }
+              return NodeError2;
+            }(Base);
+            NodeError.prototype.name = Base.name;
+            NodeError.prototype.code = code;
+            codes[code] = NodeError;
+          }
+          function oneOf(expected, thing) {
+            if (Array.isArray(expected)) {
+              var len2 = expected.length;
+              expected = expected.map(function(i2) {
+                return String(i2);
+              });
+              if (len2 > 2) {
+                return "one of ".concat(thing, " ").concat(expected.slice(0, len2 - 1).join(", "), ", or ") + expected[len2 - 1];
+              } else if (len2 === 2) {
+                return "one of ".concat(thing, " ").concat(expected[0], " or ").concat(expected[1]);
+              } else {
+                return "of ".concat(thing, " ").concat(expected[0]);
+              }
+            } else {
+              return "of ".concat(thing, " ").concat(String(expected));
+            }
+          }
+          function startsWith(str, search, pos) {
+            return str.substr(0, search.length) === search;
+          }
+          function endsWith(str, search, this_len) {
+            if (this_len === void 0 || this_len > str.length) {
+              this_len = str.length;
+            }
+            return str.substring(this_len - search.length, this_len) === search;
+          }
+          function includes(str, search, start) {
+            if (typeof start !== "number") {
+              start = 0;
+            }
+            if (start + search.length > str.length) {
+              return false;
+            } else {
+              return str.indexOf(search, start) !== -1;
+            }
+          }
+          createErrorType("ERR_INVALID_OPT_VALUE", function(name2, value) {
+            return 'The value "' + value + '" is invalid for option "' + name2 + '"';
+          }, TypeError);
+          createErrorType("ERR_INVALID_ARG_TYPE", function(name2, expected, actual) {
+            var determiner;
+            if (typeof expected === "string" && startsWith(expected, "not ")) {
+              determiner = "must not be";
+              expected = expected.replace(/^not /, "");
+            } else {
+              determiner = "must be";
+            }
+            var msg;
+            if (endsWith(name2, " argument")) {
+              msg = "The ".concat(name2, " ").concat(determiner, " ").concat(oneOf(expected, "type"));
+            } else {
+              var type = includes(name2, ".") ? "property" : "argument";
+              msg = 'The "'.concat(name2, '" ').concat(type, " ").concat(determiner, " ").concat(oneOf(expected, "type"));
+            }
+            msg += ". Received type ".concat(typeof actual);
+            return msg;
+          }, TypeError);
+          createErrorType("ERR_STREAM_PUSH_AFTER_EOF", "stream.push() after EOF");
+          createErrorType("ERR_METHOD_NOT_IMPLEMENTED", function(name2) {
+            return "The " + name2 + " method is not implemented";
+          });
+          createErrorType("ERR_STREAM_PREMATURE_CLOSE", "Premature close");
+          createErrorType("ERR_STREAM_DESTROYED", function(name2) {
+            return "Cannot call " + name2 + " after a stream was destroyed";
+          });
+          createErrorType("ERR_MULTIPLE_CALLBACK", "Callback called multiple times");
+          createErrorType("ERR_STREAM_CANNOT_PIPE", "Cannot pipe, not readable");
+          createErrorType("ERR_STREAM_WRITE_AFTER_END", "write after end");
+          createErrorType("ERR_STREAM_NULL_VALUES", "May not write null values to stream", TypeError);
+          createErrorType("ERR_UNKNOWN_ENCODING", function(arg) {
+            return "Unknown encoding: " + arg;
+          }, TypeError);
+          createErrorType("ERR_STREAM_UNSHIFT_AFTER_END_EVENT", "stream.unshift() after end event");
+          module2.exports.codes = codes;
+        }
+      });
+      var require_state = __commonJS({
+        "node_modules/stream-browserify/node_modules/readable-stream/lib/internal/streams/state.js"(exports, module2) {
+          var ERR_INVALID_OPT_VALUE = require_errors_browser().codes.ERR_INVALID_OPT_VALUE;
+          function highWaterMarkFrom(options, isDuplex, duplexKey) {
+            return options.highWaterMark != null ? options.highWaterMark : isDuplex ? options[duplexKey] : null;
+          }
+          function getHighWaterMark(state, options, duplexKey, isDuplex) {
+            var hwm = highWaterMarkFrom(options, isDuplex, duplexKey);
+            if (hwm != null) {
+              if (!(isFinite(hwm) && Math.floor(hwm) === hwm) || hwm < 0) {
+                var name2 = isDuplex ? duplexKey : "highWaterMark";
+                throw new ERR_INVALID_OPT_VALUE(name2, hwm);
+              }
+              return Math.floor(hwm);
+            }
+            return state.objectMode ? 16 : 16 * 1024;
+          }
+          module2.exports = {
+            getHighWaterMark
+          };
+        }
+      });
+      var require_browser = __commonJS({
+        "node_modules/util-deprecate/browser.js"(exports, module2) {
+          module2.exports = deprecate;
+          function deprecate(fn, msg) {
+            if (config2("noDeprecation")) {
+              return fn;
+            }
+            var warned = false;
+            function deprecated() {
+              if (!warned) {
+                if (config2("throwDeprecation")) {
+                  throw new Error(msg);
+                } else if (config2("traceDeprecation")) {
+                  console.trace(msg);
+                } else {
+                  console.warn(msg);
+                }
+                warned = true;
+              }
+              return fn.apply(this, arguments);
+            }
+            return deprecated;
+          }
+          function config2(name2) {
+            try {
+              if (!window.localStorage) return false;
+            } catch (_2) {
+              return false;
+            }
+            var val = window.localStorage[name2];
+            if (null == val) return false;
+            return String(val).toLowerCase() === "true";
+          }
+        }
+      });
+      var require_stream_writable = __commonJS({
+        "node_modules/stream-browserify/node_modules/readable-stream/lib/_stream_writable.js"(exports, module2) {
+          module2.exports = Writable;
+          function CorkedRequest(state) {
+            var _this = this;
+            this.next = null;
+            this.entry = null;
+            this.finish = function() {
+              onCorkedFinish(_this, state);
+            };
+          }
+          var Duplex;
+          Writable.WritableState = WritableState;
+          var internalUtil = {
+            deprecate: require_browser()
+          };
+          var Stream = require_stream_browser();
+          var Buffer22 = require_buffer().Buffer;
+          var OurUint8Array = window.Uint8Array || function() {
+          };
+          function _uint8ArrayToBuffer(chunk) {
+            return Buffer22.from(chunk);
+          }
+          function _isUint8Array(obj) {
+            return Buffer22.isBuffer(obj) || obj instanceof OurUint8Array;
+          }
+          var destroyImpl = require_destroy();
+          var _require = require_state();
+          var getHighWaterMark = _require.getHighWaterMark;
+          var _require$codes = require_errors_browser().codes;
+          var ERR_INVALID_ARG_TYPE = _require$codes.ERR_INVALID_ARG_TYPE;
+          var ERR_METHOD_NOT_IMPLEMENTED = _require$codes.ERR_METHOD_NOT_IMPLEMENTED;
+          var ERR_MULTIPLE_CALLBACK = _require$codes.ERR_MULTIPLE_CALLBACK;
+          var ERR_STREAM_CANNOT_PIPE = _require$codes.ERR_STREAM_CANNOT_PIPE;
+          var ERR_STREAM_DESTROYED = _require$codes.ERR_STREAM_DESTROYED;
+          var ERR_STREAM_NULL_VALUES = _require$codes.ERR_STREAM_NULL_VALUES;
+          var ERR_STREAM_WRITE_AFTER_END = _require$codes.ERR_STREAM_WRITE_AFTER_END;
+          var ERR_UNKNOWN_ENCODING = _require$codes.ERR_UNKNOWN_ENCODING;
+          var errorOrDestroy = destroyImpl.errorOrDestroy;
+          require_inherits_browser()(Writable, Stream);
+          function nop() {
+          }
+          function WritableState(options, stream, isDuplex) {
+            Duplex = Duplex || require_stream_duplex();
+            options = options || {};
+            if (typeof isDuplex !== "boolean") isDuplex = stream instanceof Duplex;
+            this.objectMode = !!options.objectMode;
+            if (isDuplex) this.objectMode = this.objectMode || !!options.writableObjectMode;
+            this.highWaterMark = getHighWaterMark(this, options, "writableHighWaterMark", isDuplex);
+            this.finalCalled = false;
+            this.needDrain = false;
+            this.ending = false;
+            this.ended = false;
+            this.finished = false;
+            this.destroyed = false;
+            var noDecode = options.decodeStrings === false;
+            this.decodeStrings = !noDecode;
+            this.defaultEncoding = options.defaultEncoding || "utf8";
+            this.length = 0;
+            this.writing = false;
+            this.corked = 0;
+            this.sync = true;
+            this.bufferProcessing = false;
+            this.onwrite = function(er) {
+              onwrite(stream, er);
+            };
+            this.writecb = null;
+            this.writelen = 0;
+            this.bufferedRequest = null;
+            this.lastBufferedRequest = null;
+            this.pendingcb = 0;
+            this.prefinished = false;
+            this.errorEmitted = false;
+            this.emitClose = options.emitClose !== false;
+            this.autoDestroy = !!options.autoDestroy;
+            this.bufferedRequestCount = 0;
+            this.corkedRequestsFree = new CorkedRequest(this);
+          }
+          WritableState.prototype.getBuffer = function getBuffer() {
+            var current = this.bufferedRequest;
+            var out = [];
+            while (current) {
+              out.push(current);
+              current = current.next;
+            }
+            return out;
+          };
+          (function() {
+            try {
+              Object.defineProperty(WritableState.prototype, "buffer", {
+                get: internalUtil.deprecate(function writableStateBufferGetter() {
+                  return this.getBuffer();
+                }, "_writableState.buffer is deprecated. Use _writableState.getBuffer instead.", "DEP0003")
+              });
+            } catch (_2) {
+            }
+          })();
+          var realHasInstance;
+          if (typeof Symbol === "function" && Symbol.hasInstance && typeof Function.prototype[Symbol.hasInstance] === "function") {
+            realHasInstance = Function.prototype[Symbol.hasInstance];
+            Object.defineProperty(Writable, Symbol.hasInstance, {
+              value: function value(object) {
+                if (realHasInstance.call(this, object)) return true;
+                if (this !== Writable) return false;
+                return object && object._writableState instanceof WritableState;
+              }
+            });
+          } else {
+            realHasInstance = function realHasInstance2(object) {
+              return object instanceof this;
+            };
+          }
+          function Writable(options) {
+            Duplex = Duplex || require_stream_duplex();
+            var isDuplex = this instanceof Duplex;
+            if (!isDuplex && !realHasInstance.call(Writable, this)) return new Writable(options);
+            this._writableState = new WritableState(options, this, isDuplex);
+            this.writable = true;
+            if (options) {
+              if (typeof options.write === "function") this._write = options.write;
+              if (typeof options.writev === "function") this._writev = options.writev;
+              if (typeof options.destroy === "function") this._destroy = options.destroy;
+              if (typeof options.final === "function") this._final = options.final;
+            }
+            Stream.call(this);
+          }
+          Writable.prototype.pipe = function() {
+            errorOrDestroy(this, new ERR_STREAM_CANNOT_PIPE());
+          };
+          function writeAfterEnd(stream, cb2) {
+            var er = new ERR_STREAM_WRITE_AFTER_END();
+            errorOrDestroy(stream, er);
+            process.nextTick(cb2, er);
+          }
+          function validChunk(stream, state, chunk, cb2) {
+            var er;
+            if (chunk === null) {
+              er = new ERR_STREAM_NULL_VALUES();
+            } else if (typeof chunk !== "string" && !state.objectMode) {
+              er = new ERR_INVALID_ARG_TYPE("chunk", ["string", "Buffer"], chunk);
+            }
+            if (er) {
+              errorOrDestroy(stream, er);
+              process.nextTick(cb2, er);
+              return false;
+            }
+            return true;
+          }
+          Writable.prototype.write = function(chunk, encoding, cb2) {
+            var state = this._writableState;
+            var ret = false;
+            var isBuf = !state.objectMode && _isUint8Array(chunk);
+            if (isBuf && !Buffer22.isBuffer(chunk)) {
+              chunk = _uint8ArrayToBuffer(chunk);
+            }
+            if (typeof encoding === "function") {
+              cb2 = encoding;
+              encoding = null;
+            }
+            if (isBuf) encoding = "buffer";
+            else if (!encoding) encoding = state.defaultEncoding;
+            if (typeof cb2 !== "function") cb2 = nop;
+            if (state.ending) writeAfterEnd(this, cb2);
+            else if (isBuf || validChunk(this, state, chunk, cb2)) {
+              state.pendingcb++;
+              ret = writeOrBuffer(this, state, isBuf, chunk, encoding, cb2);
+            }
+            return ret;
+          };
+          Writable.prototype.cork = function() {
+            this._writableState.corked++;
+          };
+          Writable.prototype.uncork = function() {
+            var state = this._writableState;
+            if (state.corked) {
+              state.corked--;
+              if (!state.writing && !state.corked && !state.bufferProcessing && state.bufferedRequest) clearBuffer(this, state);
+            }
+          };
+          Writable.prototype.setDefaultEncoding = function setDefaultEncoding(encoding) {
+            if (typeof encoding === "string") encoding = encoding.toLowerCase();
+            if (!(["hex", "utf8", "utf-8", "ascii", "binary", "base64", "ucs2", "ucs-2", "utf16le", "utf-16le", "raw"].indexOf((encoding + "").toLowerCase()) > -1)) throw new ERR_UNKNOWN_ENCODING(encoding);
+            this._writableState.defaultEncoding = encoding;
+            return this;
+          };
+          Object.defineProperty(Writable.prototype, "writableBuffer", {
+            // making it explicit this property is not enumerable
+            // because otherwise some prototype manipulation in
+            // userland will fail
+            enumerable: false,
+            get: function get() {
+              return this._writableState && this._writableState.getBuffer();
+            }
+          });
+          function decodeChunk(state, chunk, encoding) {
+            if (!state.objectMode && state.decodeStrings !== false && typeof chunk === "string") {
+              chunk = Buffer22.from(chunk, encoding);
+            }
+            return chunk;
+          }
+          Object.defineProperty(Writable.prototype, "writableHighWaterMark", {
+            // making it explicit this property is not enumerable
+            // because otherwise some prototype manipulation in
+            // userland will fail
+            enumerable: false,
+            get: function get() {
+              return this._writableState.highWaterMark;
+            }
+          });
+          function writeOrBuffer(stream, state, isBuf, chunk, encoding, cb2) {
+            if (!isBuf) {
+              var newChunk = decodeChunk(state, chunk, encoding);
+              if (chunk !== newChunk) {
+                isBuf = true;
+                encoding = "buffer";
+                chunk = newChunk;
+              }
+            }
+            var len2 = state.objectMode ? 1 : chunk.length;
+            state.length += len2;
+            var ret = state.length < state.highWaterMark;
+            if (!ret) state.needDrain = true;
+            if (state.writing || state.corked) {
+              var last = state.lastBufferedRequest;
+              state.lastBufferedRequest = {
+                chunk,
+                encoding,
+                isBuf,
+                callback: cb2,
+                next: null
+              };
+              if (last) {
+                last.next = state.lastBufferedRequest;
+              } else {
+                state.bufferedRequest = state.lastBufferedRequest;
+              }
+              state.bufferedRequestCount += 1;
+            } else {
+              doWrite(stream, state, false, len2, chunk, encoding, cb2);
+            }
+            return ret;
+          }
+          function doWrite(stream, state, writev, len2, chunk, encoding, cb2) {
+            state.writelen = len2;
+            state.writecb = cb2;
+            state.writing = true;
+            state.sync = true;
+            if (state.destroyed) state.onwrite(new ERR_STREAM_DESTROYED("write"));
+            else if (writev) stream._writev(chunk, state.onwrite);
+            else stream._write(chunk, encoding, state.onwrite);
+            state.sync = false;
+          }
+          function onwriteError(stream, state, sync, er, cb2) {
+            --state.pendingcb;
+            if (sync) {
+              process.nextTick(cb2, er);
+              process.nextTick(finishMaybe, stream, state);
+              stream._writableState.errorEmitted = true;
+              errorOrDestroy(stream, er);
+            } else {
+              cb2(er);
+              stream._writableState.errorEmitted = true;
+              errorOrDestroy(stream, er);
+              finishMaybe(stream, state);
+            }
+          }
+          function onwriteStateUpdate(state) {
+            state.writing = false;
+            state.writecb = null;
+            state.length -= state.writelen;
+            state.writelen = 0;
+          }
+          function onwrite(stream, er) {
+            var state = stream._writableState;
+            var sync = state.sync;
+            var cb2 = state.writecb;
+            if (typeof cb2 !== "function") throw new ERR_MULTIPLE_CALLBACK();
+            onwriteStateUpdate(state);
+            if (er) onwriteError(stream, state, sync, er, cb2);
+            else {
+              var finished = needFinish(state) || stream.destroyed;
+              if (!finished && !state.corked && !state.bufferProcessing && state.bufferedRequest) {
+                clearBuffer(stream, state);
+              }
+              if (sync) {
+                process.nextTick(afterWrite, stream, state, finished, cb2);
+              } else {
+                afterWrite(stream, state, finished, cb2);
+              }
+            }
+          }
+          function afterWrite(stream, state, finished, cb2) {
+            if (!finished) onwriteDrain(stream, state);
+            state.pendingcb--;
+            cb2();
+            finishMaybe(stream, state);
+          }
+          function onwriteDrain(stream, state) {
+            if (state.length === 0 && state.needDrain) {
+              state.needDrain = false;
+              stream.emit("drain");
+            }
+          }
+          function clearBuffer(stream, state) {
+            state.bufferProcessing = true;
+            var entry = state.bufferedRequest;
+            if (stream._writev && entry && entry.next) {
+              var l2 = state.bufferedRequestCount;
+              var buffer = new Array(l2);
+              var holder = state.corkedRequestsFree;
+              holder.entry = entry;
+              var count2 = 0;
+              var allBuffers = true;
+              while (entry) {
+                buffer[count2] = entry;
+                if (!entry.isBuf) allBuffers = false;
+                entry = entry.next;
+                count2 += 1;
+              }
+              buffer.allBuffers = allBuffers;
+              doWrite(stream, state, true, state.length, buffer, "", holder.finish);
+              state.pendingcb++;
+              state.lastBufferedRequest = null;
+              if (holder.next) {
+                state.corkedRequestsFree = holder.next;
+                holder.next = null;
+              } else {
+                state.corkedRequestsFree = new CorkedRequest(state);
+              }
+              state.bufferedRequestCount = 0;
+            } else {
+              while (entry) {
+                var chunk = entry.chunk;
+                var encoding = entry.encoding;
+                var cb2 = entry.callback;
+                var len2 = state.objectMode ? 1 : chunk.length;
+                doWrite(stream, state, false, len2, chunk, encoding, cb2);
+                entry = entry.next;
+                state.bufferedRequestCount--;
+                if (state.writing) {
+                  break;
+                }
+              }
+              if (entry === null) state.lastBufferedRequest = null;
+            }
+            state.bufferedRequest = entry;
+            state.bufferProcessing = false;
+          }
+          Writable.prototype._write = function(chunk, encoding, cb2) {
+            cb2(new ERR_METHOD_NOT_IMPLEMENTED("_write()"));
+          };
+          Writable.prototype._writev = null;
+          Writable.prototype.end = function(chunk, encoding, cb2) {
+            var state = this._writableState;
+            if (typeof chunk === "function") {
+              cb2 = chunk;
+              chunk = null;
+              encoding = null;
+            } else if (typeof encoding === "function") {
+              cb2 = encoding;
+              encoding = null;
+            }
+            if (chunk !== null && chunk !== void 0) this.write(chunk, encoding);
+            if (state.corked) {
+              state.corked = 1;
+              this.uncork();
+            }
+            if (!state.ending) endWritable(this, state, cb2);
+            return this;
+          };
+          Object.defineProperty(Writable.prototype, "writableLength", {
+            // making it explicit this property is not enumerable
+            // because otherwise some prototype manipulation in
+            // userland will fail
+            enumerable: false,
+            get: function get() {
+              return this._writableState.length;
+            }
+          });
+          function needFinish(state) {
+            return state.ending && state.length === 0 && state.bufferedRequest === null && !state.finished && !state.writing;
+          }
+          function callFinal(stream, state) {
+            stream._final(function(err) {
+              state.pendingcb--;
+              if (err) {
+                errorOrDestroy(stream, err);
+              }
+              state.prefinished = true;
+              stream.emit("prefinish");
+              finishMaybe(stream, state);
+            });
+          }
+          function prefinish(stream, state) {
+            if (!state.prefinished && !state.finalCalled) {
+              if (typeof stream._final === "function" && !state.destroyed) {
+                state.pendingcb++;
+                state.finalCalled = true;
+                process.nextTick(callFinal, stream, state);
+              } else {
+                state.prefinished = true;
+                stream.emit("prefinish");
+              }
+            }
+          }
+          function finishMaybe(stream, state) {
+            var need = needFinish(state);
+            if (need) {
+              prefinish(stream, state);
+              if (state.pendingcb === 0) {
+                state.finished = true;
+                stream.emit("finish");
+                if (state.autoDestroy) {
+                  var rState = stream._readableState;
+                  if (!rState || rState.autoDestroy && rState.endEmitted) {
+                    stream.destroy();
+                  }
+                }
+              }
+            }
+            return need;
+          }
+          function endWritable(stream, state, cb2) {
+            state.ending = true;
+            finishMaybe(stream, state);
+            if (cb2) {
+              if (state.finished) process.nextTick(cb2);
+              else stream.once("finish", cb2);
+            }
+            state.ended = true;
+            stream.writable = false;
+          }
+          function onCorkedFinish(corkReq, state, err) {
+            var entry = corkReq.entry;
+            corkReq.entry = null;
+            while (entry) {
+              var cb2 = entry.callback;
+              state.pendingcb--;
+              cb2(err);
+              entry = entry.next;
+            }
+            state.corkedRequestsFree.next = corkReq;
+          }
+          Object.defineProperty(Writable.prototype, "destroyed", {
+            // making it explicit this property is not enumerable
+            // because otherwise some prototype manipulation in
+            // userland will fail
+            enumerable: false,
+            get: function get() {
+              if (this._writableState === void 0) {
+                return false;
+              }
+              return this._writableState.destroyed;
+            },
+            set: function set(value) {
+              if (!this._writableState) {
+                return;
+              }
+              this._writableState.destroyed = value;
+            }
+          });
+          Writable.prototype.destroy = destroyImpl.destroy;
+          Writable.prototype._undestroy = destroyImpl.undestroy;
+          Writable.prototype._destroy = function(err, cb2) {
+            cb2(err);
+          };
+        }
+      });
+      var require_stream_duplex = __commonJS({
+        "node_modules/stream-browserify/node_modules/readable-stream/lib/_stream_duplex.js"(exports, module2) {
+          var objectKeys = Object.keys || function(obj) {
+            var keys2 = [];
+            for (var key in obj) {
+              keys2.push(key);
+            }
+            return keys2;
+          };
+          module2.exports = Duplex;
+          var Readable = require_stream_readable();
+          var Writable = require_stream_writable();
+          require_inherits_browser()(Duplex, Readable);
+          {
+            keys = objectKeys(Writable.prototype);
+            for (v2 = 0; v2 < keys.length; v2++) {
+              method = keys[v2];
+              if (!Duplex.prototype[method]) Duplex.prototype[method] = Writable.prototype[method];
+            }
+          }
+          var keys;
+          var method;
+          var v2;
+          function Duplex(options) {
+            if (!(this instanceof Duplex)) return new Duplex(options);
+            Readable.call(this, options);
+            Writable.call(this, options);
+            this.allowHalfOpen = true;
+            if (options) {
+              if (options.readable === false) this.readable = false;
+              if (options.writable === false) this.writable = false;
+              if (options.allowHalfOpen === false) {
+                this.allowHalfOpen = false;
+                this.once("end", onend);
+              }
+            }
+          }
+          Object.defineProperty(Duplex.prototype, "writableHighWaterMark", {
+            // making it explicit this property is not enumerable
+            // because otherwise some prototype manipulation in
+            // userland will fail
+            enumerable: false,
+            get: function get() {
+              return this._writableState.highWaterMark;
+            }
+          });
+          Object.defineProperty(Duplex.prototype, "writableBuffer", {
+            // making it explicit this property is not enumerable
+            // because otherwise some prototype manipulation in
+            // userland will fail
+            enumerable: false,
+            get: function get() {
+              return this._writableState && this._writableState.getBuffer();
+            }
+          });
+          Object.defineProperty(Duplex.prototype, "writableLength", {
+            // making it explicit this property is not enumerable
+            // because otherwise some prototype manipulation in
+            // userland will fail
+            enumerable: false,
+            get: function get() {
+              return this._writableState.length;
+            }
+          });
+          function onend() {
+            if (this._writableState.ended) return;
+            process.nextTick(onEndNT, this);
+          }
+          function onEndNT(self2) {
+            self2.end();
+          }
+          Object.defineProperty(Duplex.prototype, "destroyed", {
+            // making it explicit this property is not enumerable
+            // because otherwise some prototype manipulation in
+            // userland will fail
+            enumerable: false,
+            get: function get() {
+              if (this._readableState === void 0 || this._writableState === void 0) {
+                return false;
+              }
+              return this._readableState.destroyed && this._writableState.destroyed;
+            },
+            set: function set(value) {
+              if (this._readableState === void 0 || this._writableState === void 0) {
+                return;
+              }
+              this._readableState.destroyed = value;
+              this._writableState.destroyed = value;
+            }
+          });
+        }
+      });
+      var require_safe_buffer = __commonJS({
+        "node_modules/safe-buffer/index.js"(exports, module2) {
+          var buffer = require_buffer();
+          var Buffer22 = buffer.Buffer;
+          function copyProps(src, dst) {
+            for (var key in src) {
+              dst[key] = src[key];
+            }
+          }
+          if (Buffer22.from && Buffer22.alloc && Buffer22.allocUnsafe && Buffer22.allocUnsafeSlow) {
+            module2.exports = buffer;
+          } else {
+            copyProps(buffer, exports);
+            exports.Buffer = SafeBuffer;
+          }
+          function SafeBuffer(arg, encodingOrOffset, length2) {
+            return Buffer22(arg, encodingOrOffset, length2);
+          }
+          SafeBuffer.prototype = Object.create(Buffer22.prototype);
+          copyProps(Buffer22, SafeBuffer);
+          SafeBuffer.from = function(arg, encodingOrOffset, length2) {
+            if (typeof arg === "number") {
+              throw new TypeError("Argument must not be a number");
+            }
+            return Buffer22(arg, encodingOrOffset, length2);
+          };
+          SafeBuffer.alloc = function(size, fill, encoding) {
+            if (typeof size !== "number") {
+              throw new TypeError("Argument must be a number");
+            }
+            var buf = Buffer22(size);
+            if (fill !== void 0) {
+              if (typeof encoding === "string") {
+                buf.fill(fill, encoding);
+              } else {
+                buf.fill(fill);
+              }
+            } else {
+              buf.fill(0);
+            }
+            return buf;
+          };
+          SafeBuffer.allocUnsafe = function(size) {
+            if (typeof size !== "number") {
+              throw new TypeError("Argument must be a number");
+            }
+            return Buffer22(size);
+          };
+          SafeBuffer.allocUnsafeSlow = function(size) {
+            if (typeof size !== "number") {
+              throw new TypeError("Argument must be a number");
+            }
+            return buffer.SlowBuffer(size);
+          };
+        }
+      });
+      var require_string_decoder = __commonJS({
+        "node_modules/stream-browserify/node_modules/string_decoder/lib/string_decoder.js"(exports) {
+          var Buffer22 = require_safe_buffer().Buffer;
+          var isEncoding = Buffer22.isEncoding || function(encoding) {
+            encoding = "" + encoding;
+            switch (encoding && encoding.toLowerCase()) {
+              case "hex":
+              case "utf8":
+              case "utf-8":
+              case "ascii":
+              case "binary":
+              case "base64":
+              case "ucs2":
+              case "ucs-2":
+              case "utf16le":
+              case "utf-16le":
+              case "raw":
+                return true;
+              default:
+                return false;
+            }
+          };
+          function _normalizeEncoding(enc) {
+            if (!enc) return "utf8";
+            var retried;
+            while (true) {
+              switch (enc) {
+                case "utf8":
+                case "utf-8":
+                  return "utf8";
+                case "ucs2":
+                case "ucs-2":
+                case "utf16le":
+                case "utf-16le":
+                  return "utf16le";
+                case "latin1":
+                case "binary":
+                  return "latin1";
+                case "base64":
+                case "ascii":
+                case "hex":
+                  return enc;
+                default:
+                  if (retried) return;
+                  enc = ("" + enc).toLowerCase();
+                  retried = true;
+              }
+            }
+          }
+          function normalizeEncoding(enc) {
+            var nenc = _normalizeEncoding(enc);
+            if (typeof nenc !== "string" && (Buffer22.isEncoding === isEncoding || !isEncoding(enc))) throw new Error("Unknown encoding: " + enc);
+            return nenc || enc;
+          }
+          exports.StringDecoder = StringDecoder;
+          function StringDecoder(encoding) {
+            this.encoding = normalizeEncoding(encoding);
+            var nb2;
+            switch (this.encoding) {
+              case "utf16le":
+                this.text = utf16Text;
+                this.end = utf16End;
+                nb2 = 4;
+                break;
+              case "utf8":
+                this.fillLast = utf8FillLast;
+                nb2 = 4;
+                break;
+              case "base64":
+                this.text = base64Text;
+                this.end = base64End;
+                nb2 = 3;
+                break;
+              default:
+                this.write = simpleWrite;
+                this.end = simpleEnd;
+                return;
+            }
+            this.lastNeed = 0;
+            this.lastTotal = 0;
+            this.lastChar = Buffer22.allocUnsafe(nb2);
+          }
+          StringDecoder.prototype.write = function(buf) {
+            if (buf.length === 0) return "";
+            var r2;
+            var i2;
+            if (this.lastNeed) {
+              r2 = this.fillLast(buf);
+              if (r2 === void 0) return "";
+              i2 = this.lastNeed;
+              this.lastNeed = 0;
+            } else {
+              i2 = 0;
+            }
+            if (i2 < buf.length) return r2 ? r2 + this.text(buf, i2) : this.text(buf, i2);
+            return r2 || "";
+          };
+          StringDecoder.prototype.end = utf8End;
+          StringDecoder.prototype.text = utf8Text;
+          StringDecoder.prototype.fillLast = function(buf) {
+            if (this.lastNeed <= buf.length) {
+              buf.copy(this.lastChar, this.lastTotal - this.lastNeed, 0, this.lastNeed);
+              return this.lastChar.toString(this.encoding, 0, this.lastTotal);
+            }
+            buf.copy(this.lastChar, this.lastTotal - this.lastNeed, 0, buf.length);
+            this.lastNeed -= buf.length;
+          };
+          function utf8CheckByte(byte) {
+            if (byte <= 127) return 0;
+            else if (byte >> 5 === 6) return 2;
+            else if (byte >> 4 === 14) return 3;
+            else if (byte >> 3 === 30) return 4;
+            return byte >> 6 === 2 ? -1 : -2;
+          }
+          function utf8CheckIncomplete(self2, buf, i2) {
+            var j2 = buf.length - 1;
+            if (j2 < i2) return 0;
+            var nb2 = utf8CheckByte(buf[j2]);
+            if (nb2 >= 0) {
+              if (nb2 > 0) self2.lastNeed = nb2 - 1;
+              return nb2;
+            }
+            if (--j2 < i2 || nb2 === -2) return 0;
+            nb2 = utf8CheckByte(buf[j2]);
+            if (nb2 >= 0) {
+              if (nb2 > 0) self2.lastNeed = nb2 - 2;
+              return nb2;
+            }
+            if (--j2 < i2 || nb2 === -2) return 0;
+            nb2 = utf8CheckByte(buf[j2]);
+            if (nb2 >= 0) {
+              if (nb2 > 0) {
+                if (nb2 === 2) nb2 = 0;
+                else self2.lastNeed = nb2 - 3;
+              }
+              return nb2;
+            }
+            return 0;
+          }
+          function utf8CheckExtraBytes(self2, buf, p2) {
+            if ((buf[0] & 192) !== 128) {
+              self2.lastNeed = 0;
+              return "�";
+            }
+            if (self2.lastNeed > 1 && buf.length > 1) {
+              if ((buf[1] & 192) !== 128) {
+                self2.lastNeed = 1;
+                return "�";
+              }
+              if (self2.lastNeed > 2 && buf.length > 2) {
+                if ((buf[2] & 192) !== 128) {
+                  self2.lastNeed = 2;
+                  return "�";
+                }
+              }
+            }
+          }
+          function utf8FillLast(buf) {
+            var p2 = this.lastTotal - this.lastNeed;
+            var r2 = utf8CheckExtraBytes(this, buf);
+            if (r2 !== void 0) return r2;
+            if (this.lastNeed <= buf.length) {
+              buf.copy(this.lastChar, p2, 0, this.lastNeed);
+              return this.lastChar.toString(this.encoding, 0, this.lastTotal);
+            }
+            buf.copy(this.lastChar, p2, 0, buf.length);
+            this.lastNeed -= buf.length;
+          }
+          function utf8Text(buf, i2) {
+            var total = utf8CheckIncomplete(this, buf, i2);
+            if (!this.lastNeed) return buf.toString("utf8", i2);
+            this.lastTotal = total;
+            var end = buf.length - (total - this.lastNeed);
+            buf.copy(this.lastChar, 0, end);
+            return buf.toString("utf8", i2, end);
+          }
+          function utf8End(buf) {
+            var r2 = buf && buf.length ? this.write(buf) : "";
+            if (this.lastNeed) return r2 + "�";
+            return r2;
+          }
+          function utf16Text(buf, i2) {
+            if ((buf.length - i2) % 2 === 0) {
+              var r2 = buf.toString("utf16le", i2);
+              if (r2) {
+                var c2 = r2.charCodeAt(r2.length - 1);
+                if (c2 >= 55296 && c2 <= 56319) {
+                  this.lastNeed = 2;
+                  this.lastTotal = 4;
+                  this.lastChar[0] = buf[buf.length - 2];
+                  this.lastChar[1] = buf[buf.length - 1];
+                  return r2.slice(0, -1);
+                }
+              }
+              return r2;
+            }
+            this.lastNeed = 1;
+            this.lastTotal = 2;
+            this.lastChar[0] = buf[buf.length - 1];
+            return buf.toString("utf16le", i2, buf.length - 1);
+          }
+          function utf16End(buf) {
+            var r2 = buf && buf.length ? this.write(buf) : "";
+            if (this.lastNeed) {
+              var end = this.lastTotal - this.lastNeed;
+              return r2 + this.lastChar.toString("utf16le", 0, end);
+            }
+            return r2;
+          }
+          function base64Text(buf, i2) {
+            var n2 = (buf.length - i2) % 3;
+            if (n2 === 0) return buf.toString("base64", i2);
+            this.lastNeed = 3 - n2;
+            this.lastTotal = 3;
+            if (n2 === 1) {
+              this.lastChar[0] = buf[buf.length - 1];
+            } else {
+              this.lastChar[0] = buf[buf.length - 2];
+              this.lastChar[1] = buf[buf.length - 1];
+            }
+            return buf.toString("base64", i2, buf.length - n2);
+          }
+          function base64End(buf) {
+            var r2 = buf && buf.length ? this.write(buf) : "";
+            if (this.lastNeed) return r2 + this.lastChar.toString("base64", 0, 3 - this.lastNeed);
+            return r2;
+          }
+          function simpleWrite(buf) {
+            return buf.toString(this.encoding);
+          }
+          function simpleEnd(buf) {
+            return buf && buf.length ? this.write(buf) : "";
+          }
+        }
+      });
+      var require_end_of_stream = __commonJS({
+        "node_modules/stream-browserify/node_modules/readable-stream/lib/internal/streams/end-of-stream.js"(exports, module2) {
+          var ERR_STREAM_PREMATURE_CLOSE = require_errors_browser().codes.ERR_STREAM_PREMATURE_CLOSE;
+          function once(callback) {
+            var called = false;
+            return function() {
+              if (called) return;
+              called = true;
+              for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
+                args[_key] = arguments[_key];
+              }
+              callback.apply(this, args);
+            };
+          }
+          function noop2() {
+          }
+          function isRequest(stream) {
+            return stream.setHeader && typeof stream.abort === "function";
+          }
+          function eos(stream, opts, callback) {
+            if (typeof opts === "function") return eos(stream, null, opts);
+            if (!opts) opts = {};
+            callback = once(callback || noop2);
+            var readable = opts.readable || opts.readable !== false && stream.readable;
+            var writable = opts.writable || opts.writable !== false && stream.writable;
+            var onlegacyfinish = function onlegacyfinish2() {
+              if (!stream.writable) onfinish();
+            };
+            var writableEnded = stream._writableState && stream._writableState.finished;
+            var onfinish = function onfinish2() {
+              writable = false;
+              writableEnded = true;
+              if (!readable) callback.call(stream);
+            };
+            var readableEnded = stream._readableState && stream._readableState.endEmitted;
+            var onend = function onend2() {
+              readable = false;
+              readableEnded = true;
+              if (!writable) callback.call(stream);
+            };
+            var onerror = function onerror2(err) {
+              callback.call(stream, err);
+            };
+            var onclose = function onclose2() {
+              var err;
+              if (readable && !readableEnded) {
+                if (!stream._readableState || !stream._readableState.ended) err = new ERR_STREAM_PREMATURE_CLOSE();
+                return callback.call(stream, err);
+              }
+              if (writable && !writableEnded) {
+                if (!stream._writableState || !stream._writableState.ended) err = new ERR_STREAM_PREMATURE_CLOSE();
+                return callback.call(stream, err);
+              }
+            };
+            var onrequest = function onrequest2() {
+              stream.req.on("finish", onfinish);
+            };
+            if (isRequest(stream)) {
+              stream.on("complete", onfinish);
+              stream.on("abort", onclose);
+              if (stream.req) onrequest();
+              else stream.on("request", onrequest);
+            } else if (writable && !stream._writableState) {
+              stream.on("end", onlegacyfinish);
+              stream.on("close", onlegacyfinish);
+            }
+            stream.on("end", onend);
+            stream.on("finish", onfinish);
+            if (opts.error !== false) stream.on("error", onerror);
+            stream.on("close", onclose);
+            return function() {
+              stream.removeListener("complete", onfinish);
+              stream.removeListener("abort", onclose);
+              stream.removeListener("request", onrequest);
+              if (stream.req) stream.req.removeListener("finish", onfinish);
+              stream.removeListener("end", onlegacyfinish);
+              stream.removeListener("close", onlegacyfinish);
+              stream.removeListener("finish", onfinish);
+              stream.removeListener("end", onend);
+              stream.removeListener("error", onerror);
+              stream.removeListener("close", onclose);
+            };
+          }
+          module2.exports = eos;
+        }
+      });
+      var require_async_iterator = __commonJS({
+        "node_modules/stream-browserify/node_modules/readable-stream/lib/internal/streams/async_iterator.js"(exports, module2) {
+          var _Object$setPrototypeO;
+          function _defineProperty(obj, key, value) {
+            if (key in obj) {
+              Object.defineProperty(obj, key, { value, enumerable: true, configurable: true, writable: true });
+            } else {
+              obj[key] = value;
+            }
+            return obj;
+          }
+          var finished = require_end_of_stream();
+          var kLastResolve = Symbol("lastResolve");
+          var kLastReject = Symbol("lastReject");
+          var kError = Symbol("error");
+          var kEnded = Symbol("ended");
+          var kLastPromise = Symbol("lastPromise");
+          var kHandlePromise = Symbol("handlePromise");
+          var kStream = Symbol("stream");
+          function createIterResult(value, done) {
+            return {
+              value,
+              done
+            };
+          }
+          function readAndResolve(iter) {
+            var resolve = iter[kLastResolve];
+            if (resolve !== null) {
+              var data = iter[kStream].read();
+              if (data !== null) {
+                iter[kLastPromise] = null;
+                iter[kLastResolve] = null;
+                iter[kLastReject] = null;
+                resolve(createIterResult(data, false));
+              }
+            }
+          }
+          function onReadable(iter) {
+            process.nextTick(readAndResolve, iter);
+          }
+          function wrapForNext(lastPromise, iter) {
+            return function(resolve, reject) {
+              lastPromise.then(function() {
+                if (iter[kEnded]) {
+                  resolve(createIterResult(void 0, true));
+                  return;
+                }
+                iter[kHandlePromise](resolve, reject);
+              }, reject);
+            };
+          }
+          var AsyncIteratorPrototype = Object.getPrototypeOf(function() {
+          });
+          var ReadableStreamAsyncIteratorPrototype = Object.setPrototypeOf((_Object$setPrototypeO = {
+            get stream() {
+              return this[kStream];
+            },
+            next: function next() {
+              var _this = this;
+              var error = this[kError];
+              if (error !== null) {
+                return Promise.reject(error);
+              }
+              if (this[kEnded]) {
+                return Promise.resolve(createIterResult(void 0, true));
+              }
+              if (this[kStream].destroyed) {
+                return new Promise(function(resolve, reject) {
+                  process.nextTick(function() {
+                    if (_this[kError]) {
+                      reject(_this[kError]);
+                    } else {
+                      resolve(createIterResult(void 0, true));
+                    }
+                  });
+                });
+              }
+              var lastPromise = this[kLastPromise];
+              var promise;
+              if (lastPromise) {
+                promise = new Promise(wrapForNext(lastPromise, this));
+              } else {
+                var data = this[kStream].read();
+                if (data !== null) {
+                  return Promise.resolve(createIterResult(data, false));
+                }
+                promise = new Promise(this[kHandlePromise]);
+              }
+              this[kLastPromise] = promise;
+              return promise;
+            }
+          }, _defineProperty(_Object$setPrototypeO, Symbol.asyncIterator, function() {
+            return this;
+          }), _defineProperty(_Object$setPrototypeO, "return", function _return() {
+            var _this2 = this;
+            return new Promise(function(resolve, reject) {
+              _this2[kStream].destroy(null, function(err) {
+                if (err) {
+                  reject(err);
+                  return;
+                }
+                resolve(createIterResult(void 0, true));
+              });
+            });
+          }), _Object$setPrototypeO), AsyncIteratorPrototype);
+          var createReadableStreamAsyncIterator = function createReadableStreamAsyncIterator2(stream) {
+            var _Object$create;
+            var iterator = Object.create(ReadableStreamAsyncIteratorPrototype, (_Object$create = {}, _defineProperty(_Object$create, kStream, {
+              value: stream,
+              writable: true
+            }), _defineProperty(_Object$create, kLastResolve, {
+              value: null,
+              writable: true
+            }), _defineProperty(_Object$create, kLastReject, {
+              value: null,
+              writable: true
+            }), _defineProperty(_Object$create, kError, {
+              value: null,
+              writable: true
+            }), _defineProperty(_Object$create, kEnded, {
+              value: stream._readableState.endEmitted,
+              writable: true
+            }), _defineProperty(_Object$create, kHandlePromise, {
+              value: function value(resolve, reject) {
+                var data = iterator[kStream].read();
+                if (data) {
+                  iterator[kLastPromise] = null;
+                  iterator[kLastResolve] = null;
+                  iterator[kLastReject] = null;
+                  resolve(createIterResult(data, false));
+                } else {
+                  iterator[kLastResolve] = resolve;
+                  iterator[kLastReject] = reject;
+                }
+              },
+              writable: true
+            }), _Object$create));
+            iterator[kLastPromise] = null;
+            finished(stream, function(err) {
+              if (err && err.code !== "ERR_STREAM_PREMATURE_CLOSE") {
+                var reject = iterator[kLastReject];
+                if (reject !== null) {
+                  iterator[kLastPromise] = null;
+                  iterator[kLastResolve] = null;
+                  iterator[kLastReject] = null;
+                  reject(err);
+                }
+                iterator[kError] = err;
+                return;
+              }
+              var resolve = iterator[kLastResolve];
+              if (resolve !== null) {
+                iterator[kLastPromise] = null;
+                iterator[kLastResolve] = null;
+                iterator[kLastReject] = null;
+                resolve(createIterResult(void 0, true));
+              }
+              iterator[kEnded] = true;
+            });
+            stream.on("readable", onReadable.bind(null, iterator));
+            return iterator;
+          };
+          module2.exports = createReadableStreamAsyncIterator;
+        }
+      });
+      var require_from_browser = __commonJS({
+        "node_modules/stream-browserify/node_modules/readable-stream/lib/internal/streams/from-browser.js"(exports, module2) {
+          module2.exports = function() {
+            throw new Error("Readable.from is not available in the browser");
+          };
+        }
+      });
+      var require_stream_readable = __commonJS({
+        "node_modules/stream-browserify/node_modules/readable-stream/lib/_stream_readable.js"(exports, module2) {
+          module2.exports = Readable;
+          var Duplex;
+          Readable.ReadableState = ReadableState;
+          require_events().EventEmitter;
+          var EElistenerCount = function EElistenerCount2(emitter, type) {
+            return emitter.listeners(type).length;
+          };
+          var Stream = require_stream_browser();
+          var Buffer22 = require_buffer().Buffer;
+          var OurUint8Array = window.Uint8Array || function() {
+          };
+          function _uint8ArrayToBuffer(chunk) {
+            return Buffer22.from(chunk);
+          }
+          function _isUint8Array(obj) {
+            return Buffer22.isBuffer(obj) || obj instanceof OurUint8Array;
+          }
+          var debugUtil = require_util();
+          var debug2;
+          if (debugUtil && debugUtil.debuglog) {
+            debug2 = debugUtil.debuglog("stream");
+          } else {
+            debug2 = function debug22() {
+            };
+          }
+          var BufferList = require_buffer_list();
+          var destroyImpl = require_destroy();
+          var _require = require_state();
+          var getHighWaterMark = _require.getHighWaterMark;
+          var _require$codes = require_errors_browser().codes;
+          var ERR_INVALID_ARG_TYPE = _require$codes.ERR_INVALID_ARG_TYPE;
+          var ERR_STREAM_PUSH_AFTER_EOF = _require$codes.ERR_STREAM_PUSH_AFTER_EOF;
+          var ERR_METHOD_NOT_IMPLEMENTED = _require$codes.ERR_METHOD_NOT_IMPLEMENTED;
+          var ERR_STREAM_UNSHIFT_AFTER_END_EVENT = _require$codes.ERR_STREAM_UNSHIFT_AFTER_END_EVENT;
+          var StringDecoder;
+          var createReadableStreamAsyncIterator;
+          var from;
+          require_inherits_browser()(Readable, Stream);
+          var errorOrDestroy = destroyImpl.errorOrDestroy;
+          var kProxyEvents = ["error", "close", "destroy", "pause", "resume"];
+          function prependListener(emitter, event, fn) {
+            if (typeof emitter.prependListener === "function") return emitter.prependListener(event, fn);
+            if (!emitter._events || !emitter._events[event]) emitter.on(event, fn);
+            else if (Array.isArray(emitter._events[event])) emitter._events[event].unshift(fn);
+            else emitter._events[event] = [fn, emitter._events[event]];
+          }
+          function ReadableState(options, stream, isDuplex) {
+            Duplex = Duplex || require_stream_duplex();
+            options = options || {};
+            if (typeof isDuplex !== "boolean") isDuplex = stream instanceof Duplex;
+            this.objectMode = !!options.objectMode;
+            if (isDuplex) this.objectMode = this.objectMode || !!options.readableObjectMode;
+            this.highWaterMark = getHighWaterMark(this, options, "readableHighWaterMark", isDuplex);
+            this.buffer = new BufferList();
+            this.length = 0;
+            this.pipes = null;
+            this.pipesCount = 0;
+            this.flowing = null;
+            this.ended = false;
+            this.endEmitted = false;
+            this.reading = false;
+            this.sync = true;
+            this.needReadable = false;
+            this.emittedReadable = false;
+            this.readableListening = false;
+            this.resumeScheduled = false;
+            this.paused = true;
+            this.emitClose = options.emitClose !== false;
+            this.autoDestroy = !!options.autoDestroy;
+            this.destroyed = false;
+            this.defaultEncoding = options.defaultEncoding || "utf8";
+            this.awaitDrain = 0;
+            this.readingMore = false;
+            this.decoder = null;
+            this.encoding = null;
+            if (options.encoding) {
+              if (!StringDecoder) StringDecoder = require_string_decoder().StringDecoder;
+              this.decoder = new StringDecoder(options.encoding);
+              this.encoding = options.encoding;
+            }
+          }
+          function Readable(options) {
+            Duplex = Duplex || require_stream_duplex();
+            if (!(this instanceof Readable)) return new Readable(options);
+            var isDuplex = this instanceof Duplex;
+            this._readableState = new ReadableState(options, this, isDuplex);
+            this.readable = true;
+            if (options) {
+              if (typeof options.read === "function") this._read = options.read;
+              if (typeof options.destroy === "function") this._destroy = options.destroy;
+            }
+            Stream.call(this);
+          }
+          Object.defineProperty(Readable.prototype, "destroyed", {
+            // making it explicit this property is not enumerable
+            // because otherwise some prototype manipulation in
+            // userland will fail
+            enumerable: false,
+            get: function get() {
+              if (this._readableState === void 0) {
+                return false;
+              }
+              return this._readableState.destroyed;
+            },
+            set: function set(value) {
+              if (!this._readableState) {
+                return;
+              }
+              this._readableState.destroyed = value;
+            }
+          });
+          Readable.prototype.destroy = destroyImpl.destroy;
+          Readable.prototype._undestroy = destroyImpl.undestroy;
+          Readable.prototype._destroy = function(err, cb2) {
+            cb2(err);
+          };
+          Readable.prototype.push = function(chunk, encoding) {
+            var state = this._readableState;
+            var skipChunkCheck;
+            if (!state.objectMode) {
+              if (typeof chunk === "string") {
+                encoding = encoding || state.defaultEncoding;
+                if (encoding !== state.encoding) {
+                  chunk = Buffer22.from(chunk, encoding);
+                  encoding = "";
+                }
+                skipChunkCheck = true;
+              }
+            } else {
+              skipChunkCheck = true;
+            }
+            return readableAddChunk(this, chunk, encoding, false, skipChunkCheck);
+          };
+          Readable.prototype.unshift = function(chunk) {
+            return readableAddChunk(this, chunk, null, true, false);
+          };
+          function readableAddChunk(stream, chunk, encoding, addToFront, skipChunkCheck) {
+            debug2("readableAddChunk", chunk);
+            var state = stream._readableState;
+            if (chunk === null) {
+              state.reading = false;
+              onEofChunk(stream, state);
+            } else {
+              var er;
+              if (!skipChunkCheck) er = chunkInvalid(state, chunk);
+              if (er) {
+                errorOrDestroy(stream, er);
+              } else if (state.objectMode || chunk && chunk.length > 0) {
+                if (typeof chunk !== "string" && !state.objectMode && Object.getPrototypeOf(chunk) !== Buffer22.prototype) {
+                  chunk = _uint8ArrayToBuffer(chunk);
+                }
+                if (addToFront) {
+                  if (state.endEmitted) errorOrDestroy(stream, new ERR_STREAM_UNSHIFT_AFTER_END_EVENT());
+                  else addChunk(stream, state, chunk, true);
+                } else if (state.ended) {
+                  errorOrDestroy(stream, new ERR_STREAM_PUSH_AFTER_EOF());
+                } else if (state.destroyed) {
+                  return false;
+                } else {
+                  state.reading = false;
+                  if (state.decoder && !encoding) {
+                    chunk = state.decoder.write(chunk);
+                    if (state.objectMode || chunk.length !== 0) addChunk(stream, state, chunk, false);
+                    else maybeReadMore(stream, state);
+                  } else {
+                    addChunk(stream, state, chunk, false);
+                  }
+                }
+              } else if (!addToFront) {
+                state.reading = false;
+                maybeReadMore(stream, state);
+              }
+            }
+            return !state.ended && (state.length < state.highWaterMark || state.length === 0);
+          }
+          function addChunk(stream, state, chunk, addToFront) {
+            if (state.flowing && state.length === 0 && !state.sync) {
+              state.awaitDrain = 0;
+              stream.emit("data", chunk);
+            } else {
+              state.length += state.objectMode ? 1 : chunk.length;
+              if (addToFront) state.buffer.unshift(chunk);
+              else state.buffer.push(chunk);
+              if (state.needReadable) emitReadable(stream);
+            }
+            maybeReadMore(stream, state);
+          }
+          function chunkInvalid(state, chunk) {
+            var er;
+            if (!_isUint8Array(chunk) && typeof chunk !== "string" && chunk !== void 0 && !state.objectMode) {
+              er = new ERR_INVALID_ARG_TYPE("chunk", ["string", "Buffer", "Uint8Array"], chunk);
+            }
+            return er;
+          }
+          Readable.prototype.isPaused = function() {
+            return this._readableState.flowing === false;
+          };
+          Readable.prototype.setEncoding = function(enc) {
+            if (!StringDecoder) StringDecoder = require_string_decoder().StringDecoder;
+            var decoder2 = new StringDecoder(enc);
+            this._readableState.decoder = decoder2;
+            this._readableState.encoding = this._readableState.decoder.encoding;
+            var p2 = this._readableState.buffer.head;
+            var content = "";
+            while (p2 !== null) {
+              content += decoder2.write(p2.data);
+              p2 = p2.next;
+            }
+            this._readableState.buffer.clear();
+            if (content !== "") this._readableState.buffer.push(content);
+            this._readableState.length = content.length;
+            return this;
+          };
+          var MAX_HWM = 1073741824;
+          function computeNewHighWaterMark(n2) {
+            if (n2 >= MAX_HWM) {
+              n2 = MAX_HWM;
+            } else {
+              n2--;
+              n2 |= n2 >>> 1;
+              n2 |= n2 >>> 2;
+              n2 |= n2 >>> 4;
+              n2 |= n2 >>> 8;
+              n2 |= n2 >>> 16;
+              n2++;
+            }
+            return n2;
+          }
+          function howMuchToRead(n2, state) {
+            if (n2 <= 0 || state.length === 0 && state.ended) return 0;
+            if (state.objectMode) return 1;
+            if (n2 !== n2) {
+              if (state.flowing && state.length) return state.buffer.head.data.length;
+              else return state.length;
+            }
+            if (n2 > state.highWaterMark) state.highWaterMark = computeNewHighWaterMark(n2);
+            if (n2 <= state.length) return n2;
+            if (!state.ended) {
+              state.needReadable = true;
+              return 0;
+            }
+            return state.length;
+          }
+          Readable.prototype.read = function(n2) {
+            debug2("read", n2);
+            n2 = parseInt(n2, 10);
+            var state = this._readableState;
+            var nOrig = n2;
+            if (n2 !== 0) state.emittedReadable = false;
+            if (n2 === 0 && state.needReadable && ((state.highWaterMark !== 0 ? state.length >= state.highWaterMark : state.length > 0) || state.ended)) {
+              debug2("read: emitReadable", state.length, state.ended);
+              if (state.length === 0 && state.ended) endReadable(this);
+              else emitReadable(this);
+              return null;
+            }
+            n2 = howMuchToRead(n2, state);
+            if (n2 === 0 && state.ended) {
+              if (state.length === 0) endReadable(this);
+              return null;
+            }
+            var doRead = state.needReadable;
+            debug2("need readable", doRead);
+            if (state.length === 0 || state.length - n2 < state.highWaterMark) {
+              doRead = true;
+              debug2("length less than watermark", doRead);
+            }
+            if (state.ended || state.reading) {
+              doRead = false;
+              debug2("reading or ended", doRead);
+            } else if (doRead) {
+              debug2("do read");
+              state.reading = true;
+              state.sync = true;
+              if (state.length === 0) state.needReadable = true;
+              this._read(state.highWaterMark);
+              state.sync = false;
+              if (!state.reading) n2 = howMuchToRead(nOrig, state);
+            }
+            var ret;
+            if (n2 > 0) ret = fromList(n2, state);
+            else ret = null;
+            if (ret === null) {
+              state.needReadable = state.length <= state.highWaterMark;
+              n2 = 0;
+            } else {
+              state.length -= n2;
+              state.awaitDrain = 0;
+            }
+            if (state.length === 0) {
+              if (!state.ended) state.needReadable = true;
+              if (nOrig !== n2 && state.ended) endReadable(this);
+            }
+            if (ret !== null) this.emit("data", ret);
+            return ret;
+          };
+          function onEofChunk(stream, state) {
+            debug2("onEofChunk");
+            if (state.ended) return;
+            if (state.decoder) {
+              var chunk = state.decoder.end();
+              if (chunk && chunk.length) {
+                state.buffer.push(chunk);
+                state.length += state.objectMode ? 1 : chunk.length;
+              }
+            }
+            state.ended = true;
+            if (state.sync) {
+              emitReadable(stream);
+            } else {
+              state.needReadable = false;
+              if (!state.emittedReadable) {
+                state.emittedReadable = true;
+                emitReadable_(stream);
+              }
+            }
+          }
+          function emitReadable(stream) {
+            var state = stream._readableState;
+            debug2("emitReadable", state.needReadable, state.emittedReadable);
+            state.needReadable = false;
+            if (!state.emittedReadable) {
+              debug2("emitReadable", state.flowing);
+              state.emittedReadable = true;
+              process.nextTick(emitReadable_, stream);
+            }
+          }
+          function emitReadable_(stream) {
+            var state = stream._readableState;
+            debug2("emitReadable_", state.destroyed, state.length, state.ended);
+            if (!state.destroyed && (state.length || state.ended)) {
+              stream.emit("readable");
+              state.emittedReadable = false;
+            }
+            state.needReadable = !state.flowing && !state.ended && state.length <= state.highWaterMark;
+            flow(stream);
+          }
+          function maybeReadMore(stream, state) {
+            if (!state.readingMore) {
+              state.readingMore = true;
+              process.nextTick(maybeReadMore_, stream, state);
+            }
+          }
+          function maybeReadMore_(stream, state) {
+            while (!state.reading && !state.ended && (state.length < state.highWaterMark || state.flowing && state.length === 0)) {
+              var len2 = state.length;
+              debug2("maybeReadMore read 0");
+              stream.read(0);
+              if (len2 === state.length)
+                break;
+            }
+            state.readingMore = false;
+          }
+          Readable.prototype._read = function(n2) {
+            errorOrDestroy(this, new ERR_METHOD_NOT_IMPLEMENTED("_read()"));
+          };
+          Readable.prototype.pipe = function(dest, pipeOpts) {
+            var src = this;
+            var state = this._readableState;
+            switch (state.pipesCount) {
+              case 0:
+                state.pipes = dest;
+                break;
+              case 1:
+                state.pipes = [state.pipes, dest];
+                break;
+              default:
+                state.pipes.push(dest);
+                break;
+            }
+            state.pipesCount += 1;
+            debug2("pipe count=%d opts=%j", state.pipesCount, pipeOpts);
+            var doEnd = (!pipeOpts || pipeOpts.end !== false) && dest !== process.stdout && dest !== process.stderr;
+            var endFn = doEnd ? onend : unpipe;
+            if (state.endEmitted) process.nextTick(endFn);
+            else src.once("end", endFn);
+            dest.on("unpipe", onunpipe);
+            function onunpipe(readable, unpipeInfo) {
+              debug2("onunpipe");
+              if (readable === src) {
+                if (unpipeInfo && unpipeInfo.hasUnpiped === false) {
+                  unpipeInfo.hasUnpiped = true;
+                  cleanup();
+                }
+              }
+            }
+            function onend() {
+              debug2("onend");
+              dest.end();
+            }
+            var ondrain = pipeOnDrain(src);
+            dest.on("drain", ondrain);
+            var cleanedUp = false;
+            function cleanup() {
+              debug2("cleanup");
+              dest.removeListener("close", onclose);
+              dest.removeListener("finish", onfinish);
+              dest.removeListener("drain", ondrain);
+              dest.removeListener("error", onerror);
+              dest.removeListener("unpipe", onunpipe);
+              src.removeListener("end", onend);
+              src.removeListener("end", unpipe);
+              src.removeListener("data", ondata);
+              cleanedUp = true;
+              if (state.awaitDrain && (!dest._writableState || dest._writableState.needDrain)) ondrain();
+            }
+            src.on("data", ondata);
+            function ondata(chunk) {
+              debug2("ondata");
+              var ret = dest.write(chunk);
+              debug2("dest.write", ret);
+              if (ret === false) {
+                if ((state.pipesCount === 1 && state.pipes === dest || state.pipesCount > 1 && indexOf(state.pipes, dest) !== -1) && !cleanedUp) {
+                  debug2("false write response, pause", state.awaitDrain);
+                  state.awaitDrain++;
+                }
+                src.pause();
+              }
+            }
+            function onerror(er) {
+              debug2("onerror", er);
+              unpipe();
+              dest.removeListener("error", onerror);
+              if (EElistenerCount(dest, "error") === 0) errorOrDestroy(dest, er);
+            }
+            prependListener(dest, "error", onerror);
+            function onclose() {
+              dest.removeListener("finish", onfinish);
+              unpipe();
+            }
+            dest.once("close", onclose);
+            function onfinish() {
+              debug2("onfinish");
+              dest.removeListener("close", onclose);
+              unpipe();
+            }
+            dest.once("finish", onfinish);
+            function unpipe() {
+              debug2("unpipe");
+              src.unpipe(dest);
+            }
+            dest.emit("pipe", src);
+            if (!state.flowing) {
+              debug2("pipe resume");
+              src.resume();
+            }
+            return dest;
+          };
+          function pipeOnDrain(src) {
+            return function pipeOnDrainFunctionResult() {
+              var state = src._readableState;
+              debug2("pipeOnDrain", state.awaitDrain);
+              if (state.awaitDrain) state.awaitDrain--;
+              if (state.awaitDrain === 0 && EElistenerCount(src, "data")) {
+                state.flowing = true;
+                flow(src);
+              }
+            };
+          }
+          Readable.prototype.unpipe = function(dest) {
+            var state = this._readableState;
+            var unpipeInfo = {
+              hasUnpiped: false
+            };
+            if (state.pipesCount === 0) return this;
+            if (state.pipesCount === 1) {
+              if (dest && dest !== state.pipes) return this;
+              if (!dest) dest = state.pipes;
+              state.pipes = null;
+              state.pipesCount = 0;
+              state.flowing = false;
+              if (dest) dest.emit("unpipe", this, unpipeInfo);
+              return this;
+            }
+            if (!dest) {
+              var dests = state.pipes;
+              var len2 = state.pipesCount;
+              state.pipes = null;
+              state.pipesCount = 0;
+              state.flowing = false;
+              for (var i2 = 0; i2 < len2; i2++) {
+                dests[i2].emit("unpipe", this, {
+                  hasUnpiped: false
+                });
+              }
+              return this;
+            }
+            var index = indexOf(state.pipes, dest);
+            if (index === -1) return this;
+            state.pipes.splice(index, 1);
+            state.pipesCount -= 1;
+            if (state.pipesCount === 1) state.pipes = state.pipes[0];
+            dest.emit("unpipe", this, unpipeInfo);
+            return this;
+          };
+          Readable.prototype.on = function(ev, fn) {
+            var res = Stream.prototype.on.call(this, ev, fn);
+            var state = this._readableState;
+            if (ev === "data") {
+              state.readableListening = this.listenerCount("readable") > 0;
+              if (state.flowing !== false) this.resume();
+            } else if (ev === "readable") {
+              if (!state.endEmitted && !state.readableListening) {
+                state.readableListening = state.needReadable = true;
+                state.flowing = false;
+                state.emittedReadable = false;
+                debug2("on readable", state.length, state.reading);
+                if (state.length) {
+                  emitReadable(this);
+                } else if (!state.reading) {
+                  process.nextTick(nReadingNextTick, this);
+                }
+              }
+            }
+            return res;
+          };
+          Readable.prototype.addListener = Readable.prototype.on;
+          Readable.prototype.removeListener = function(ev, fn) {
+            var res = Stream.prototype.removeListener.call(this, ev, fn);
+            if (ev === "readable") {
+              process.nextTick(updateReadableListening, this);
+            }
+            return res;
+          };
+          Readable.prototype.removeAllListeners = function(ev) {
+            var res = Stream.prototype.removeAllListeners.apply(this, arguments);
+            if (ev === "readable" || ev === void 0) {
+              process.nextTick(updateReadableListening, this);
+            }
+            return res;
+          };
+          function updateReadableListening(self2) {
+            var state = self2._readableState;
+            state.readableListening = self2.listenerCount("readable") > 0;
+            if (state.resumeScheduled && !state.paused) {
+              state.flowing = true;
+            } else if (self2.listenerCount("data") > 0) {
+              self2.resume();
+            }
+          }
+          function nReadingNextTick(self2) {
+            debug2("readable nexttick read 0");
+            self2.read(0);
+          }
+          Readable.prototype.resume = function() {
+            var state = this._readableState;
+            if (!state.flowing) {
+              debug2("resume");
+              state.flowing = !state.readableListening;
+              resume(this, state);
+            }
+            state.paused = false;
+            return this;
+          };
+          function resume(stream, state) {
+            if (!state.resumeScheduled) {
+              state.resumeScheduled = true;
+              process.nextTick(resume_, stream, state);
+            }
+          }
+          function resume_(stream, state) {
+            debug2("resume", state.reading);
+            if (!state.reading) {
+              stream.read(0);
+            }
+            state.resumeScheduled = false;
+            stream.emit("resume");
+            flow(stream);
+            if (state.flowing && !state.reading) stream.read(0);
+          }
+          Readable.prototype.pause = function() {
+            debug2("call pause flowing=%j", this._readableState.flowing);
+            if (this._readableState.flowing !== false) {
+              debug2("pause");
+              this._readableState.flowing = false;
+              this.emit("pause");
+            }
+            this._readableState.paused = true;
+            return this;
+          };
+          function flow(stream) {
+            var state = stream._readableState;
+            debug2("flow", state.flowing);
+            while (state.flowing && stream.read() !== null) {
+            }
+          }
+          Readable.prototype.wrap = function(stream) {
+            var _this = this;
+            var state = this._readableState;
+            var paused = false;
+            stream.on("end", function() {
+              debug2("wrapped end");
+              if (state.decoder && !state.ended) {
+                var chunk = state.decoder.end();
+                if (chunk && chunk.length) _this.push(chunk);
+              }
+              _this.push(null);
+            });
+            stream.on("data", function(chunk) {
+              debug2("wrapped data");
+              if (state.decoder) chunk = state.decoder.write(chunk);
+              if (state.objectMode && (chunk === null || chunk === void 0)) return;
+              else if (!state.objectMode && (!chunk || !chunk.length)) return;
+              var ret = _this.push(chunk);
+              if (!ret) {
+                paused = true;
+                stream.pause();
+              }
+            });
+            for (var i2 in stream) {
+              if (this[i2] === void 0 && typeof stream[i2] === "function") {
+                this[i2] = /* @__PURE__ */ function methodWrap(method) {
+                  return function methodWrapReturnFunction() {
+                    return stream[method].apply(stream, arguments);
+                  };
+                }(i2);
+              }
+            }
+            for (var n2 = 0; n2 < kProxyEvents.length; n2++) {
+              stream.on(kProxyEvents[n2], this.emit.bind(this, kProxyEvents[n2]));
+            }
+            this._read = function(n22) {
+              debug2("wrapped _read", n22);
+              if (paused) {
+                paused = false;
+                stream.resume();
+              }
+            };
+            return this;
+          };
+          if (typeof Symbol === "function") {
+            Readable.prototype[Symbol.asyncIterator] = function() {
+              if (createReadableStreamAsyncIterator === void 0) {
+                createReadableStreamAsyncIterator = require_async_iterator();
+              }
+              return createReadableStreamAsyncIterator(this);
+            };
+          }
+          Object.defineProperty(Readable.prototype, "readableHighWaterMark", {
+            // making it explicit this property is not enumerable
+            // because otherwise some prototype manipulation in
+            // userland will fail
+            enumerable: false,
+            get: function get() {
+              return this._readableState.highWaterMark;
+            }
+          });
+          Object.defineProperty(Readable.prototype, "readableBuffer", {
+            // making it explicit this property is not enumerable
+            // because otherwise some prototype manipulation in
+            // userland will fail
+            enumerable: false,
+            get: function get() {
+              return this._readableState && this._readableState.buffer;
+            }
+          });
+          Object.defineProperty(Readable.prototype, "readableFlowing", {
+            // making it explicit this property is not enumerable
+            // because otherwise some prototype manipulation in
+            // userland will fail
+            enumerable: false,
+            get: function get() {
+              return this._readableState.flowing;
+            },
+            set: function set(state) {
+              if (this._readableState) {
+                this._readableState.flowing = state;
+              }
+            }
+          });
+          Readable._fromList = fromList;
+          Object.defineProperty(Readable.prototype, "readableLength", {
+            // making it explicit this property is not enumerable
+            // because otherwise some prototype manipulation in
+            // userland will fail
+            enumerable: false,
+            get: function get() {
+              return this._readableState.length;
+            }
+          });
+          function fromList(n2, state) {
+            if (state.length === 0) return null;
+            var ret;
+            if (state.objectMode) ret = state.buffer.shift();
+            else if (!n2 || n2 >= state.length) {
+              if (state.decoder) ret = state.buffer.join("");
+              else if (state.buffer.length === 1) ret = state.buffer.first();
+              else ret = state.buffer.concat(state.length);
+              state.buffer.clear();
+            } else {
+              ret = state.buffer.consume(n2, state.decoder);
+            }
+            return ret;
+          }
+          function endReadable(stream) {
+            var state = stream._readableState;
+            debug2("endReadable", state.endEmitted);
+            if (!state.endEmitted) {
+              state.ended = true;
+              process.nextTick(endReadableNT, state, stream);
+            }
+          }
+          function endReadableNT(state, stream) {
+            debug2("endReadableNT", state.endEmitted, state.length);
+            if (!state.endEmitted && state.length === 0) {
+              state.endEmitted = true;
+              stream.readable = false;
+              stream.emit("end");
+              if (state.autoDestroy) {
+                var wState = stream._writableState;
+                if (!wState || wState.autoDestroy && wState.finished) {
+                  stream.destroy();
+                }
+              }
+            }
+          }
+          if (typeof Symbol === "function") {
+            Readable.from = function(iterable, opts) {
+              if (from === void 0) {
+                from = require_from_browser();
+              }
+              return from(Readable, iterable, opts);
+            };
+          }
+          function indexOf(xs, x2) {
+            for (var i2 = 0, l2 = xs.length; i2 < l2; i2++) {
+              if (xs[i2] === x2) return i2;
+            }
+            return -1;
+          }
+        }
+      });
+      var require_stream_transform = __commonJS({
+        "node_modules/stream-browserify/node_modules/readable-stream/lib/_stream_transform.js"(exports, module2) {
+          module2.exports = Transform;
+          var _require$codes = require_errors_browser().codes;
+          var ERR_METHOD_NOT_IMPLEMENTED = _require$codes.ERR_METHOD_NOT_IMPLEMENTED;
+          var ERR_MULTIPLE_CALLBACK = _require$codes.ERR_MULTIPLE_CALLBACK;
+          var ERR_TRANSFORM_ALREADY_TRANSFORMING = _require$codes.ERR_TRANSFORM_ALREADY_TRANSFORMING;
+          var ERR_TRANSFORM_WITH_LENGTH_0 = _require$codes.ERR_TRANSFORM_WITH_LENGTH_0;
+          var Duplex = require_stream_duplex();
+          require_inherits_browser()(Transform, Duplex);
+          function afterTransform(er, data) {
+            var ts = this._transformState;
+            ts.transforming = false;
+            var cb2 = ts.writecb;
+            if (cb2 === null) {
+              return this.emit("error", new ERR_MULTIPLE_CALLBACK());
+            }
+            ts.writechunk = null;
+            ts.writecb = null;
+            if (data != null)
+              this.push(data);
+            cb2(er);
+            var rs = this._readableState;
+            rs.reading = false;
+            if (rs.needReadable || rs.length < rs.highWaterMark) {
+              this._read(rs.highWaterMark);
+            }
+          }
+          function Transform(options) {
+            if (!(this instanceof Transform)) return new Transform(options);
+            Duplex.call(this, options);
+            this._transformState = {
+              afterTransform: afterTransform.bind(this),
+              needTransform: false,
+              transforming: false,
+              writecb: null,
+              writechunk: null,
+              writeencoding: null
+            };
+            this._readableState.needReadable = true;
+            this._readableState.sync = false;
+            if (options) {
+              if (typeof options.transform === "function") this._transform = options.transform;
+              if (typeof options.flush === "function") this._flush = options.flush;
+            }
+            this.on("prefinish", prefinish);
+          }
+          function prefinish() {
+            var _this = this;
+            if (typeof this._flush === "function" && !this._readableState.destroyed) {
+              this._flush(function(er, data) {
+                done(_this, er, data);
+              });
+            } else {
+              done(this, null, null);
+            }
+          }
+          Transform.prototype.push = function(chunk, encoding) {
+            this._transformState.needTransform = false;
+            return Duplex.prototype.push.call(this, chunk, encoding);
+          };
+          Transform.prototype._transform = function(chunk, encoding, cb2) {
+            cb2(new ERR_METHOD_NOT_IMPLEMENTED("_transform()"));
+          };
+          Transform.prototype._write = function(chunk, encoding, cb2) {
+            var ts = this._transformState;
+            ts.writecb = cb2;
+            ts.writechunk = chunk;
+            ts.writeencoding = encoding;
+            if (!ts.transforming) {
+              var rs = this._readableState;
+              if (ts.needTransform || rs.needReadable || rs.length < rs.highWaterMark) this._read(rs.highWaterMark);
+            }
+          };
+          Transform.prototype._read = function(n2) {
+            var ts = this._transformState;
+            if (ts.writechunk !== null && !ts.transforming) {
+              ts.transforming = true;
+              this._transform(ts.writechunk, ts.writeencoding, ts.afterTransform);
+            } else {
+              ts.needTransform = true;
+            }
+          };
+          Transform.prototype._destroy = function(err, cb2) {
+            Duplex.prototype._destroy.call(this, err, function(err2) {
+              cb2(err2);
+            });
+          };
+          function done(stream, er, data) {
+            if (er) return stream.emit("error", er);
+            if (data != null)
+              stream.push(data);
+            if (stream._writableState.length) throw new ERR_TRANSFORM_WITH_LENGTH_0();
+            if (stream._transformState.transforming) throw new ERR_TRANSFORM_ALREADY_TRANSFORMING();
+            return stream.push(null);
+          }
+        }
+      });
+      var require_stream_passthrough = __commonJS({
+        "node_modules/stream-browserify/node_modules/readable-stream/lib/_stream_passthrough.js"(exports, module2) {
+          module2.exports = PassThrough;
+          var Transform = require_stream_transform();
+          require_inherits_browser()(PassThrough, Transform);
+          function PassThrough(options) {
+            if (!(this instanceof PassThrough)) return new PassThrough(options);
+            Transform.call(this, options);
+          }
+          PassThrough.prototype._transform = function(chunk, encoding, cb2) {
+            cb2(null, chunk);
+          };
+        }
+      });
+      var require_pipeline = __commonJS({
+        "node_modules/stream-browserify/node_modules/readable-stream/lib/internal/streams/pipeline.js"(exports, module2) {
+          var eos;
+          function once(callback) {
+            var called = false;
+            return function() {
+              if (called) return;
+              called = true;
+              callback.apply(void 0, arguments);
+            };
+          }
+          var _require$codes = require_errors_browser().codes;
+          var ERR_MISSING_ARGS = _require$codes.ERR_MISSING_ARGS;
+          var ERR_STREAM_DESTROYED = _require$codes.ERR_STREAM_DESTROYED;
+          function noop2(err) {
+            if (err) throw err;
+          }
+          function isRequest(stream) {
+            return stream.setHeader && typeof stream.abort === "function";
+          }
+          function destroyer(stream, reading, writing, callback) {
+            callback = once(callback);
+            var closed = false;
+            stream.on("close", function() {
+              closed = true;
+            });
+            if (eos === void 0) eos = require_end_of_stream();
+            eos(stream, {
+              readable: reading,
+              writable: writing
+            }, function(err) {
+              if (err) return callback(err);
+              closed = true;
+              callback();
+            });
+            var destroyed = false;
+            return function(err) {
+              if (closed) return;
+              if (destroyed) return;
+              destroyed = true;
+              if (isRequest(stream)) return stream.abort();
+              if (typeof stream.destroy === "function") return stream.destroy();
+              callback(err || new ERR_STREAM_DESTROYED("pipe"));
+            };
+          }
+          function call(fn) {
+            fn();
+          }
+          function pipe(from, to) {
+            return from.pipe(to);
+          }
+          function popCallback(streams) {
+            if (!streams.length) return noop2;
+            if (typeof streams[streams.length - 1] !== "function") return noop2;
+            return streams.pop();
+          }
+          function pipeline() {
+            for (var _len = arguments.length, streams = new Array(_len), _key = 0; _key < _len; _key++) {
+              streams[_key] = arguments[_key];
+            }
+            var callback = popCallback(streams);
+            if (Array.isArray(streams[0])) streams = streams[0];
+            if (streams.length < 2) {
+              throw new ERR_MISSING_ARGS("streams");
+            }
+            var error;
+            var destroys = streams.map(function(stream, i2) {
+              var reading = i2 < streams.length - 1;
+              var writing = i2 > 0;
+              return destroyer(stream, reading, writing, function(err) {
+                if (!error) error = err;
+                if (err) destroys.forEach(call);
+                if (reading) return;
+                destroys.forEach(call);
+                callback(error);
+              });
+            });
+            return streams.reduce(pipe);
+          }
+          module2.exports = pipeline;
+        }
+      });
+      var require_stream_browserify = __commonJS({
+        "node_modules/stream-browserify/index.js"(exports, module2) {
+          module2.exports = Stream;
+          var EE = require_events().EventEmitter;
+          var inherits = require_inherits_browser();
+          inherits(Stream, EE);
+          Stream.Readable = require_stream_readable();
+          Stream.Writable = require_stream_writable();
+          Stream.Duplex = require_stream_duplex();
+          Stream.Transform = require_stream_transform();
+          Stream.PassThrough = require_stream_passthrough();
+          Stream.finished = require_end_of_stream();
+          Stream.pipeline = require_pipeline();
+          Stream.Stream = Stream;
+          function Stream() {
+            EE.call(this);
+          }
+          Stream.prototype.pipe = function(dest, options) {
+            var source2 = this;
+            function ondata(chunk) {
+              if (dest.writable) {
+                if (false === dest.write(chunk) && source2.pause) {
+                  source2.pause();
+                }
+              }
+            }
+            source2.on("data", ondata);
+            function ondrain() {
+              if (source2.readable && source2.resume) {
+                source2.resume();
+              }
+            }
+            dest.on("drain", ondrain);
+            if (!dest._isStdio && (!options || options.end !== false)) {
+              source2.on("end", onend);
+              source2.on("close", onclose);
+            }
+            var didOnEnd = false;
+            function onend() {
+              if (didOnEnd) return;
+              didOnEnd = true;
+              dest.end();
+            }
+            function onclose() {
+              if (didOnEnd) return;
+              didOnEnd = true;
+              if (typeof dest.destroy === "function") dest.destroy();
+            }
+            function onerror(er) {
+              cleanup();
+              if (EE.listenerCount(this, "error") === 0) {
+                throw er;
+              }
+            }
+            source2.on("error", onerror);
+            dest.on("error", onerror);
+            function cleanup() {
+              source2.removeListener("data", ondata);
+              dest.removeListener("drain", ondrain);
+              source2.removeListener("end", onend);
+              source2.removeListener("close", onclose);
+              source2.removeListener("error", onerror);
+              dest.removeListener("error", onerror);
+              source2.removeListener("end", cleanup);
+              source2.removeListener("close", cleanup);
+              dest.removeListener("close", cleanup);
+            }
+            source2.on("end", cleanup);
+            source2.on("close", cleanup);
+            dest.on("close", cleanup);
+            dest.emit("pipe", source2);
+            return dest;
+          };
+        }
+      });
+      var require_util2 = __commonJS({
+        "node_modules/util/util.js"(exports) {
+          var getOwnPropertyDescriptors = Object.getOwnPropertyDescriptors || function getOwnPropertyDescriptors2(obj) {
+            var keys = Object.keys(obj);
+            var descriptors = {};
+            for (var i2 = 0; i2 < keys.length; i2++) {
+              descriptors[keys[i2]] = Object.getOwnPropertyDescriptor(obj, keys[i2]);
+            }
+            return descriptors;
+          };
+          var formatRegExp = /%[sdj%]/g;
+          exports.format = function(f2) {
+            if (!isString(f2)) {
+              var objects = [];
+              for (var i2 = 0; i2 < arguments.length; i2++) {
+                objects.push(inspect(arguments[i2]));
+              }
+              return objects.join(" ");
+            }
+            var i2 = 1;
+            var args = arguments;
+            var len2 = args.length;
+            var str = String(f2).replace(formatRegExp, function(x22) {
+              if (x22 === "%%") return "%";
+              if (i2 >= len2) return x22;
+              switch (x22) {
+                case "%s":
+                  return String(args[i2++]);
+                case "%d":
+                  return Number(args[i2++]);
+                case "%j":
+                  try {
+                    return JSON.stringify(args[i2++]);
+                  } catch (_2) {
+                    return "[Circular]";
+                  }
+                default:
+                  return x22;
+              }
+            });
+            for (var x2 = args[i2]; i2 < len2; x2 = args[++i2]) {
+              if (isNull(x2) || !isObject2(x2)) {
+                str += " " + x2;
+              } else {
+                str += " " + inspect(x2);
+              }
+            }
+            return str;
+          };
+          exports.deprecate = function(fn, msg) {
+            if (typeof process !== "undefined" && process.noDeprecation === true) {
+              return fn;
+            }
+            if (typeof process === "undefined") {
+              return function() {
+                return exports.deprecate(fn, msg).apply(this, arguments);
+              };
+            }
+            var warned = false;
+            function deprecated() {
+              if (!warned) {
+                if (process.throwDeprecation) {
+                  throw new Error(msg);
+                } else if (process.traceDeprecation) {
+                  console.trace(msg);
+                } else {
+                  console.error(msg);
+                }
+                warned = true;
+              }
+              return fn.apply(this, arguments);
+            }
+            return deprecated;
+          };
+          var debugs = {};
+          var debugEnvRegex = /^$/;
+          {
+            debugEnv = "false";
+            debugEnv = debugEnv.replace(/[|\\{}()[\]^$+?.]/g, "\\$&").replace(/\*/g, ".*").replace(/,/g, "$|^").toUpperCase();
+            debugEnvRegex = new RegExp("^" + debugEnv + "$", "i");
+          }
+          var debugEnv;
+          exports.debuglog = function(set) {
+            set = set.toUpperCase();
+            if (!debugs[set]) {
+              if (debugEnvRegex.test(set)) {
+                var pid = process.pid;
+                debugs[set] = function() {
+                  var msg = exports.format.apply(exports, arguments);
+                  console.error("%s %d: %s", set, pid, msg);
+                };
+              } else {
+                debugs[set] = function() {
+                };
+              }
+            }
+            return debugs[set];
+          };
+          function inspect(obj, opts) {
+            var ctx2 = {
+              seen: [],
+              stylize: stylizeNoColor
+            };
+            if (arguments.length >= 3) ctx2.depth = arguments[2];
+            if (arguments.length >= 4) ctx2.colors = arguments[3];
+            if (isBoolean2(opts)) {
+              ctx2.showHidden = opts;
+            } else if (opts) {
+              exports._extend(ctx2, opts);
+            }
+            if (isUndefined(ctx2.showHidden)) ctx2.showHidden = false;
+            if (isUndefined(ctx2.depth)) ctx2.depth = 2;
+            if (isUndefined(ctx2.colors)) ctx2.colors = false;
+            if (isUndefined(ctx2.customInspect)) ctx2.customInspect = true;
+            if (ctx2.colors) ctx2.stylize = stylizeWithColor;
+            return formatValue2(ctx2, obj, ctx2.depth);
+          }
+          exports.inspect = inspect;
+          inspect.colors = {
+            "bold": [1, 22],
+            "italic": [3, 23],
+            "underline": [4, 24],
+            "inverse": [7, 27],
+            "white": [37, 39],
+            "grey": [90, 39],
+            "black": [30, 39],
+            "blue": [34, 39],
+            "cyan": [36, 39],
+            "green": [32, 39],
+            "magenta": [35, 39],
+            "red": [31, 39],
+            "yellow": [33, 39]
+          };
+          inspect.styles = {
+            "special": "cyan",
+            "number": "yellow",
+            "boolean": "yellow",
+            "undefined": "grey",
+            "null": "bold",
+            "string": "green",
+            "date": "magenta",
+            // "name": intentionally not styling
+            "regexp": "red"
+          };
+          function stylizeWithColor(str, styleType) {
+            var style = inspect.styles[styleType];
+            if (style) {
+              return "\x1B[" + inspect.colors[style][0] + "m" + str + "\x1B[" + inspect.colors[style][1] + "m";
+            } else {
+              return str;
+            }
+          }
+          function stylizeNoColor(str, styleType) {
+            return str;
+          }
+          function arrayToHash(array) {
+            var hash = {};
+            array.forEach(function(val, idx) {
+              hash[val] = true;
+            });
+            return hash;
+          }
+          function formatValue2(ctx2, value, recurseTimes) {
+            if (ctx2.customInspect && value && isFunction2(value.inspect) && // Filter out the util module, it's inspect function is special
+            value.inspect !== exports.inspect && // Also filter out any prototype objects using the circular check.
+            !(value.constructor && value.constructor.prototype === value)) {
+              var ret = value.inspect(recurseTimes, ctx2);
+              if (!isString(ret)) {
+                ret = formatValue2(ctx2, ret, recurseTimes);
+              }
+              return ret;
+            }
+            var primitive = formatPrimitive(ctx2, value);
+            if (primitive) {
+              return primitive;
+            }
+            var keys = Object.keys(value);
+            var visibleKeys = arrayToHash(keys);
+            if (ctx2.showHidden) {
+              keys = Object.getOwnPropertyNames(value);
+            }
+            if (isError(value) && (keys.indexOf("message") >= 0 || keys.indexOf("description") >= 0)) {
+              return formatError(value);
+            }
+            if (keys.length === 0) {
+              if (isFunction2(value)) {
+                var name2 = value.name ? ": " + value.name : "";
+                return ctx2.stylize("[Function" + name2 + "]", "special");
+              }
+              if (isRegExp(value)) {
+                return ctx2.stylize(RegExp.prototype.toString.call(value), "regexp");
+              }
+              if (isDate(value)) {
+                return ctx2.stylize(Date.prototype.toString.call(value), "date");
+              }
+              if (isError(value)) {
+                return formatError(value);
+              }
+            }
+            var base = "", array = false, braces = ["{", "}"];
+            if (isArray2(value)) {
+              array = true;
+              braces = ["[", "]"];
+            }
+            if (isFunction2(value)) {
+              var n2 = value.name ? ": " + value.name : "";
+              base = " [Function" + n2 + "]";
+            }
+            if (isRegExp(value)) {
+              base = " " + RegExp.prototype.toString.call(value);
+            }
+            if (isDate(value)) {
+              base = " " + Date.prototype.toUTCString.call(value);
+            }
+            if (isError(value)) {
+              base = " " + formatError(value);
+            }
+            if (keys.length === 0 && (!array || value.length == 0)) {
+              return braces[0] + base + braces[1];
+            }
+            if (recurseTimes < 0) {
+              if (isRegExp(value)) {
+                return ctx2.stylize(RegExp.prototype.toString.call(value), "regexp");
+              } else {
+                return ctx2.stylize("[Object]", "special");
+              }
+            }
+            ctx2.seen.push(value);
+            var output;
+            if (array) {
+              output = formatArray(ctx2, value, recurseTimes, visibleKeys, keys);
+            } else {
+              output = keys.map(function(key) {
+                return formatProperty(ctx2, value, recurseTimes, visibleKeys, key, array);
+              });
+            }
+            ctx2.seen.pop();
+            return reduceToSingleString(output, base, braces);
+          }
+          function formatPrimitive(ctx2, value) {
+            if (isUndefined(value))
+              return ctx2.stylize("undefined", "undefined");
+            if (isString(value)) {
+              var simple = "'" + JSON.stringify(value).replace(/^"|"$/g, "").replace(/'/g, "\\'").replace(/\\"/g, '"') + "'";
+              return ctx2.stylize(simple, "string");
+            }
+            if (isNumber2(value))
+              return ctx2.stylize("" + value, "number");
+            if (isBoolean2(value))
+              return ctx2.stylize("" + value, "boolean");
+            if (isNull(value))
+              return ctx2.stylize("null", "null");
+          }
+          function formatError(value) {
+            return "[" + Error.prototype.toString.call(value) + "]";
+          }
+          function formatArray(ctx2, value, recurseTimes, visibleKeys, keys) {
+            var output = [];
+            for (var i2 = 0, l2 = value.length; i2 < l2; ++i2) {
+              if (hasOwnProperty2(value, String(i2))) {
+                output.push(formatProperty(
+                  ctx2,
+                  value,
+                  recurseTimes,
+                  visibleKeys,
+                  String(i2),
+                  true
+                ));
+              } else {
+                output.push("");
+              }
+            }
+            keys.forEach(function(key) {
+              if (!key.match(/^\d+$/)) {
+                output.push(formatProperty(
+                  ctx2,
+                  value,
+                  recurseTimes,
+                  visibleKeys,
+                  key,
+                  true
+                ));
+              }
+            });
+            return output;
+          }
+          function formatProperty(ctx2, value, recurseTimes, visibleKeys, key, array) {
+            var name2, str, desc;
+            desc = Object.getOwnPropertyDescriptor(value, key) || { value: value[key] };
+            if (desc.get) {
+              if (desc.set) {
+                str = ctx2.stylize("[Getter/Setter]", "special");
+              } else {
+                str = ctx2.stylize("[Getter]", "special");
+              }
+            } else {
+              if (desc.set) {
+                str = ctx2.stylize("[Setter]", "special");
+              }
+            }
+            if (!hasOwnProperty2(visibleKeys, key)) {
+              name2 = "[" + key + "]";
+            }
+            if (!str) {
+              if (ctx2.seen.indexOf(desc.value) < 0) {
+                if (isNull(recurseTimes)) {
+                  str = formatValue2(ctx2, desc.value, null);
+                } else {
+                  str = formatValue2(ctx2, desc.value, recurseTimes - 1);
+                }
+                if (str.indexOf("\n") > -1) {
+                  if (array) {
+                    str = str.split("\n").map(function(line) {
+                      return "  " + line;
+                    }).join("\n").slice(2);
+                  } else {
+                    str = "\n" + str.split("\n").map(function(line) {
+                      return "   " + line;
+                    }).join("\n");
+                  }
+                }
+              } else {
+                str = ctx2.stylize("[Circular]", "special");
+              }
+            }
+            if (isUndefined(name2)) {
+              if (array && key.match(/^\d+$/)) {
+                return str;
+              }
+              name2 = JSON.stringify("" + key);
+              if (name2.match(/^"([a-zA-Z_][a-zA-Z_0-9]*)"$/)) {
+                name2 = name2.slice(1, -1);
+                name2 = ctx2.stylize(name2, "name");
+              } else {
+                name2 = name2.replace(/'/g, "\\'").replace(/\\"/g, '"').replace(/(^"|"$)/g, "'");
+                name2 = ctx2.stylize(name2, "string");
+              }
+            }
+            return name2 + ": " + str;
+          }
+          function reduceToSingleString(output, base, braces) {
+            var length2 = output.reduce(function(prev, cur) {
+              if (cur.indexOf("\n") >= 0) ;
+              return prev + cur.replace(/\u001b\[\d\d?m/g, "").length + 1;
+            }, 0);
+            if (length2 > 60) {
+              return braces[0] + (base === "" ? "" : base + "\n ") + " " + output.join(",\n  ") + " " + braces[1];
+            }
+            return braces[0] + base + " " + output.join(", ") + " " + braces[1];
+          }
+          exports.types = require_types();
+          function isArray2(ar) {
+            return Array.isArray(ar);
+          }
+          exports.isArray = isArray2;
+          function isBoolean2(arg) {
+            return typeof arg === "boolean";
+          }
+          exports.isBoolean = isBoolean2;
+          function isNull(arg) {
+            return arg === null;
+          }
+          exports.isNull = isNull;
+          function isNullOrUndefined(arg) {
+            return arg == null;
+          }
+          exports.isNullOrUndefined = isNullOrUndefined;
+          function isNumber2(arg) {
+            return typeof arg === "number";
+          }
+          exports.isNumber = isNumber2;
+          function isString(arg) {
+            return typeof arg === "string";
+          }
+          exports.isString = isString;
+          function isSymbol(arg) {
+            return typeof arg === "symbol";
+          }
+          exports.isSymbol = isSymbol;
+          function isUndefined(arg) {
+            return arg === void 0;
+          }
+          exports.isUndefined = isUndefined;
+          function isRegExp(re2) {
+            return isObject2(re2) && objectToString(re2) === "[object RegExp]";
+          }
+          exports.isRegExp = isRegExp;
+          exports.types.isRegExp = isRegExp;
+          function isObject2(arg) {
+            return typeof arg === "object" && arg !== null;
+          }
+          exports.isObject = isObject2;
+          function isDate(d2) {
+            return isObject2(d2) && objectToString(d2) === "[object Date]";
+          }
+          exports.isDate = isDate;
+          exports.types.isDate = isDate;
+          function isError(e2) {
+            return isObject2(e2) && (objectToString(e2) === "[object Error]" || e2 instanceof Error);
+          }
+          exports.isError = isError;
+          exports.types.isNativeError = isError;
+          function isFunction2(arg) {
+            return typeof arg === "function";
+          }
+          exports.isFunction = isFunction2;
+          function isPrimitive(arg) {
+            return arg === null || typeof arg === "boolean" || typeof arg === "number" || typeof arg === "string" || typeof arg === "symbol" || // ES6 symbol
+            typeof arg === "undefined";
+          }
+          exports.isPrimitive = isPrimitive;
+          exports.isBuffer = require_isBufferBrowser();
+          function objectToString(o2) {
+            return Object.prototype.toString.call(o2);
+          }
+          function pad(n2) {
+            return n2 < 10 ? "0" + n2.toString(10) : n2.toString(10);
+          }
+          var months = [
+            "Jan",
+            "Feb",
+            "Mar",
+            "Apr",
+            "May",
+            "Jun",
+            "Jul",
+            "Aug",
+            "Sep",
+            "Oct",
+            "Nov",
+            "Dec"
+          ];
+          function timestamp() {
+            var d2 = /* @__PURE__ */ new Date();
+            var time = [
+              pad(d2.getHours()),
+              pad(d2.getMinutes()),
+              pad(d2.getSeconds())
+            ].join(":");
+            return [d2.getDate(), months[d2.getMonth()], time].join(" ");
+          }
+          exports.log = function() {
+            console.log("%s - %s", timestamp(), exports.format.apply(exports, arguments));
+          };
+          exports.inherits = require_inherits_browser();
+          exports._extend = function(origin, add2) {
+            if (!add2 || !isObject2(add2)) return origin;
+            var keys = Object.keys(add2);
+            var i2 = keys.length;
+            while (i2--) {
+              origin[keys[i2]] = add2[keys[i2]];
+            }
+            return origin;
+          };
+          function hasOwnProperty2(obj, prop) {
+            return Object.prototype.hasOwnProperty.call(obj, prop);
+          }
+          var kCustomPromisifiedSymbol = typeof Symbol !== "undefined" ? Symbol("util.promisify.custom") : void 0;
+          exports.promisify = function promisify(original) {
+            if (typeof original !== "function")
+              throw new TypeError('The "original" argument must be of type Function');
+            if (kCustomPromisifiedSymbol && original[kCustomPromisifiedSymbol]) {
+              var fn = original[kCustomPromisifiedSymbol];
+              if (typeof fn !== "function") {
+                throw new TypeError('The "util.promisify.custom" argument must be of type Function');
+              }
+              Object.defineProperty(fn, kCustomPromisifiedSymbol, {
+                value: fn,
+                enumerable: false,
+                writable: false,
+                configurable: true
+              });
+              return fn;
+            }
+            function fn() {
+              var promiseResolve, promiseReject;
+              var promise = new Promise(function(resolve, reject) {
+                promiseResolve = resolve;
+                promiseReject = reject;
+              });
+              var args = [];
+              for (var i2 = 0; i2 < arguments.length; i2++) {
+                args.push(arguments[i2]);
+              }
+              args.push(function(err, value) {
+                if (err) {
+                  promiseReject(err);
+                } else {
+                  promiseResolve(value);
+                }
+              });
+              try {
+                original.apply(this, args);
+              } catch (err) {
+                promiseReject(err);
+              }
+              return promise;
+            }
+            Object.setPrototypeOf(fn, Object.getPrototypeOf(original));
+            if (kCustomPromisifiedSymbol) Object.defineProperty(fn, kCustomPromisifiedSymbol, {
+              value: fn,
+              enumerable: false,
+              writable: false,
+              configurable: true
+            });
+            return Object.defineProperties(
+              fn,
+              getOwnPropertyDescriptors(original)
+            );
+          };
+          exports.promisify.custom = kCustomPromisifiedSymbol;
+          function callbackifyOnRejected(reason, cb2) {
+            if (!reason) {
+              var newReason = new Error("Promise was rejected with a falsy value");
+              newReason.reason = reason;
+              reason = newReason;
+            }
+            return cb2(reason);
+          }
+          function callbackify(original) {
+            if (typeof original !== "function") {
+              throw new TypeError('The "original" argument must be of type Function');
+            }
+            function callbackified() {
+              var args = [];
+              for (var i2 = 0; i2 < arguments.length; i2++) {
+                args.push(arguments[i2]);
+              }
+              var maybeCb = args.pop();
+              if (typeof maybeCb !== "function") {
+                throw new TypeError("The last argument must be of type Function");
+              }
+              var self2 = this;
+              var cb2 = function() {
+                return maybeCb.apply(self2, arguments);
+              };
+              original.apply(this, args).then(
+                function(ret) {
+                  process.nextTick(cb2.bind(null, null, ret));
+                },
+                function(rej) {
+                  process.nextTick(callbackifyOnRejected.bind(null, rej, cb2));
+                }
+              );
+            }
+            Object.setPrototypeOf(callbackified, Object.getPrototypeOf(original));
+            Object.defineProperties(
+              callbackified,
+              getOwnPropertyDescriptors(original)
+            );
+            return callbackified;
+          }
+          exports.callbackify = callbackify;
+        }
+      });
+      var require_errors = __commonJS({
+        "node_modules/assert/build/internal/errors.js"(exports, module2) {
+          function _typeof(o2) {
+            "@babel/helpers - typeof";
+            return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function(o22) {
+              return typeof o22;
+            } : function(o22) {
+              return o22 && "function" == typeof Symbol && o22.constructor === Symbol && o22 !== Symbol.prototype ? "symbol" : typeof o22;
+            }, _typeof(o2);
+          }
+          function _createClass(Constructor, protoProps, staticProps) {
+            Object.defineProperty(Constructor, "prototype", { writable: false });
+            return Constructor;
+          }
+          function _classCallCheck(instance2, Constructor) {
+            if (!(instance2 instanceof Constructor)) {
+              throw new TypeError("Cannot call a class as a function");
+            }
+          }
+          function _inherits(subClass, superClass) {
+            if (typeof superClass !== "function" && superClass !== null) {
+              throw new TypeError("Super expression must either be null or a function");
+            }
+            subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, writable: true, configurable: true } });
+            Object.defineProperty(subClass, "prototype", { writable: false });
+            if (superClass) _setPrototypeOf(subClass, superClass);
+          }
+          function _setPrototypeOf(o2, p2) {
+            _setPrototypeOf = Object.setPrototypeOf ? Object.setPrototypeOf.bind() : function _setPrototypeOf2(o22, p22) {
+              o22.__proto__ = p22;
+              return o22;
+            };
+            return _setPrototypeOf(o2, p2);
+          }
+          function _createSuper(Derived) {
+            var hasNativeReflectConstruct = _isNativeReflectConstruct();
+            return function _createSuperInternal() {
+              var Super = _getPrototypeOf(Derived), result;
+              if (hasNativeReflectConstruct) {
+                var NewTarget = _getPrototypeOf(this).constructor;
+                result = Reflect.construct(Super, arguments, NewTarget);
+              } else {
+                result = Super.apply(this, arguments);
+              }
+              return _possibleConstructorReturn(this, result);
+            };
+          }
+          function _possibleConstructorReturn(self2, call) {
+            if (call && (_typeof(call) === "object" || typeof call === "function")) {
+              return call;
+            } else if (call !== void 0) {
+              throw new TypeError("Derived constructors may only return object or undefined");
+            }
+            return _assertThisInitialized(self2);
+          }
+          function _assertThisInitialized(self2) {
+            if (self2 === void 0) {
+              throw new ReferenceError("this hasn't been initialised - super() hasn't been called");
+            }
+            return self2;
+          }
+          function _isNativeReflectConstruct() {
+            if (typeof Reflect === "undefined" || !Reflect.construct) return false;
+            if (Reflect.construct.sham) return false;
+            if (typeof Proxy === "function") return true;
+            try {
+              Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function() {
+              }));
+              return true;
+            } catch (e2) {
+              return false;
+            }
+          }
+          function _getPrototypeOf(o2) {
+            _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf.bind() : function _getPrototypeOf2(o22) {
+              return o22.__proto__ || Object.getPrototypeOf(o22);
+            };
+            return _getPrototypeOf(o2);
+          }
+          var codes = {};
+          var assert2;
+          var util;
+          function createErrorType(code, message2, Base) {
+            if (!Base) {
+              Base = Error;
+            }
+            function getMessage(arg1, arg2, arg3) {
+              if (typeof message2 === "string") {
+                return message2;
+              } else {
+                return message2(arg1, arg2, arg3);
+              }
+            }
+            var NodeError = /* @__PURE__ */ function(_Base) {
+              _inherits(NodeError2, _Base);
+              var _super = _createSuper(NodeError2);
+              function NodeError2(arg1, arg2, arg3) {
+                var _this;
+                _classCallCheck(this, NodeError2);
+                _this = _super.call(this, getMessage(arg1, arg2, arg3));
+                _this.code = code;
+                return _this;
+              }
+              return _createClass(NodeError2);
+            }(Base);
+            codes[code] = NodeError;
+          }
+          function oneOf(expected, thing) {
+            if (Array.isArray(expected)) {
+              var len2 = expected.length;
+              expected = expected.map(function(i2) {
+                return String(i2);
+              });
+              if (len2 > 2) {
+                return "one of ".concat(thing, " ").concat(expected.slice(0, len2 - 1).join(", "), ", or ") + expected[len2 - 1];
+              } else if (len2 === 2) {
+                return "one of ".concat(thing, " ").concat(expected[0], " or ").concat(expected[1]);
+              } else {
+                return "of ".concat(thing, " ").concat(expected[0]);
+              }
+            } else {
+              return "of ".concat(thing, " ").concat(String(expected));
+            }
+          }
+          function startsWith(str, search, pos) {
+            return str.substr(0, search.length) === search;
+          }
+          function endsWith(str, search, this_len) {
+            if (this_len === void 0 || this_len > str.length) {
+              this_len = str.length;
+            }
+            return str.substring(this_len - search.length, this_len) === search;
+          }
+          function includes(str, search, start) {
+            if (typeof start !== "number") {
+              start = 0;
+            }
+            if (start + search.length > str.length) {
+              return false;
+            } else {
+              return str.indexOf(search, start) !== -1;
+            }
+          }
+          createErrorType("ERR_AMBIGUOUS_ARGUMENT", 'The "%s" argument is ambiguous. %s', TypeError);
+          createErrorType("ERR_INVALID_ARG_TYPE", function(name2, expected, actual) {
+            if (assert2 === void 0) assert2 = require_assert();
+            assert2(typeof name2 === "string", "'name' must be a string");
+            var determiner;
+            if (typeof expected === "string" && startsWith(expected, "not ")) {
+              determiner = "must not be";
+              expected = expected.replace(/^not /, "");
+            } else {
+              determiner = "must be";
+            }
+            var msg;
+            if (endsWith(name2, " argument")) {
+              msg = "The ".concat(name2, " ").concat(determiner, " ").concat(oneOf(expected, "type"));
+            } else {
+              var type = includes(name2, ".") ? "property" : "argument";
+              msg = 'The "'.concat(name2, '" ').concat(type, " ").concat(determiner, " ").concat(oneOf(expected, "type"));
+            }
+            msg += ". Received type ".concat(_typeof(actual));
+            return msg;
+          }, TypeError);
+          createErrorType("ERR_INVALID_ARG_VALUE", function(name2, value) {
+            var reason = arguments.length > 2 && arguments[2] !== void 0 ? arguments[2] : "is invalid";
+            if (util === void 0) util = require_util2();
+            var inspected = util.inspect(value);
+            if (inspected.length > 128) {
+              inspected = "".concat(inspected.slice(0, 128), "...");
+            }
+            return "The argument '".concat(name2, "' ").concat(reason, ". Received ").concat(inspected);
+          }, TypeError);
+          createErrorType("ERR_INVALID_RETURN_VALUE", function(input, name2, value) {
+            var type;
+            if (value && value.constructor && value.constructor.name) {
+              type = "instance of ".concat(value.constructor.name);
+            } else {
+              type = "type ".concat(_typeof(value));
+            }
+            return "Expected ".concat(input, ' to be returned from the "').concat(name2, '"') + " function but got ".concat(type, ".");
+          }, TypeError);
+          createErrorType("ERR_MISSING_ARGS", function() {
+            for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
+              args[_key] = arguments[_key];
+            }
+            if (assert2 === void 0) assert2 = require_assert();
+            assert2(args.length > 0, "At least one arg needs to be specified");
+            var msg = "The ";
+            var len2 = args.length;
+            args = args.map(function(a2) {
+              return '"'.concat(a2, '"');
+            });
+            switch (len2) {
+              case 1:
+                msg += "".concat(args[0], " argument");
+                break;
+              case 2:
+                msg += "".concat(args[0], " and ").concat(args[1], " arguments");
+                break;
+              default:
+                msg += args.slice(0, len2 - 1).join(", ");
+                msg += ", and ".concat(args[len2 - 1], " arguments");
+                break;
+            }
+            return "".concat(msg, " must be specified");
+          }, TypeError);
+          module2.exports.codes = codes;
+        }
+      });
+      var require_assertion_error = __commonJS({
+        "node_modules/assert/build/internal/assert/assertion_error.js"(exports, module2) {
+          function ownKeys(e2, r2) {
+            var t4 = Object.keys(e2);
+            if (Object.getOwnPropertySymbols) {
+              var o2 = Object.getOwnPropertySymbols(e2);
+              r2 && (o2 = o2.filter(function(r22) {
+                return Object.getOwnPropertyDescriptor(e2, r22).enumerable;
+              })), t4.push.apply(t4, o2);
+            }
+            return t4;
+          }
+          function _objectSpread(e2) {
+            for (var r2 = 1; r2 < arguments.length; r2++) {
+              var t4 = null != arguments[r2] ? arguments[r2] : {};
+              r2 % 2 ? ownKeys(Object(t4), true).forEach(function(r22) {
+                _defineProperty(e2, r22, t4[r22]);
+              }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e2, Object.getOwnPropertyDescriptors(t4)) : ownKeys(Object(t4)).forEach(function(r22) {
+                Object.defineProperty(e2, r22, Object.getOwnPropertyDescriptor(t4, r22));
+              });
+            }
+            return e2;
+          }
+          function _defineProperty(obj, key, value) {
+            key = _toPropertyKey(key);
+            if (key in obj) {
+              Object.defineProperty(obj, key, { value, enumerable: true, configurable: true, writable: true });
+            } else {
+              obj[key] = value;
+            }
+            return obj;
+          }
+          function _classCallCheck(instance2, Constructor) {
+            if (!(instance2 instanceof Constructor)) {
+              throw new TypeError("Cannot call a class as a function");
+            }
+          }
+          function _defineProperties(target, props) {
+            for (var i2 = 0; i2 < props.length; i2++) {
+              var descriptor = props[i2];
+              descriptor.enumerable = descriptor.enumerable || false;
+              descriptor.configurable = true;
+              if ("value" in descriptor) descriptor.writable = true;
+              Object.defineProperty(target, _toPropertyKey(descriptor.key), descriptor);
+            }
+          }
+          function _createClass(Constructor, protoProps, staticProps) {
+            if (protoProps) _defineProperties(Constructor.prototype, protoProps);
+            Object.defineProperty(Constructor, "prototype", { writable: false });
+            return Constructor;
+          }
+          function _toPropertyKey(arg) {
+            var key = _toPrimitive(arg, "string");
+            return _typeof(key) === "symbol" ? key : String(key);
+          }
+          function _toPrimitive(input, hint2) {
+            if (_typeof(input) !== "object" || input === null) return input;
+            var prim = input[Symbol.toPrimitive];
+            if (prim !== void 0) {
+              var res = prim.call(input, hint2);
+              if (_typeof(res) !== "object") return res;
+              throw new TypeError("@@toPrimitive must return a primitive value.");
+            }
+            return String(input);
+          }
+          function _inherits(subClass, superClass) {
+            if (typeof superClass !== "function" && superClass !== null) {
+              throw new TypeError("Super expression must either be null or a function");
+            }
+            subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, writable: true, configurable: true } });
+            Object.defineProperty(subClass, "prototype", { writable: false });
+            if (superClass) _setPrototypeOf(subClass, superClass);
+          }
+          function _createSuper(Derived) {
+            var hasNativeReflectConstruct = _isNativeReflectConstruct();
+            return function _createSuperInternal() {
+              var Super = _getPrototypeOf(Derived), result;
+              if (hasNativeReflectConstruct) {
+                var NewTarget = _getPrototypeOf(this).constructor;
+                result = Reflect.construct(Super, arguments, NewTarget);
+              } else {
+                result = Super.apply(this, arguments);
+              }
+              return _possibleConstructorReturn(this, result);
+            };
+          }
+          function _possibleConstructorReturn(self2, call) {
+            if (call && (_typeof(call) === "object" || typeof call === "function")) {
+              return call;
+            } else if (call !== void 0) {
+              throw new TypeError("Derived constructors may only return object or undefined");
+            }
+            return _assertThisInitialized(self2);
+          }
+          function _assertThisInitialized(self2) {
+            if (self2 === void 0) {
+              throw new ReferenceError("this hasn't been initialised - super() hasn't been called");
+            }
+            return self2;
+          }
+          function _wrapNativeSuper(Class) {
+            var _cache = typeof Map === "function" ? /* @__PURE__ */ new Map() : void 0;
+            _wrapNativeSuper = function _wrapNativeSuper2(Class2) {
+              if (Class2 === null || !_isNativeFunction(Class2)) return Class2;
+              if (typeof Class2 !== "function") {
+                throw new TypeError("Super expression must either be null or a function");
+              }
+              if (typeof _cache !== "undefined") {
+                if (_cache.has(Class2)) return _cache.get(Class2);
+                _cache.set(Class2, Wrapper);
+              }
+              function Wrapper() {
+                return _construct(Class2, arguments, _getPrototypeOf(this).constructor);
+              }
+              Wrapper.prototype = Object.create(Class2.prototype, { constructor: { value: Wrapper, enumerable: false, writable: true, configurable: true } });
+              return _setPrototypeOf(Wrapper, Class2);
+            };
+            return _wrapNativeSuper(Class);
+          }
+          function _construct(Parent, args, Class) {
+            if (_isNativeReflectConstruct()) {
+              _construct = Reflect.construct.bind();
+            } else {
+              _construct = function _construct2(Parent2, args2, Class2) {
+                var a2 = [null];
+                a2.push.apply(a2, args2);
+                var Constructor = Function.bind.apply(Parent2, a2);
+                var instance2 = new Constructor();
+                if (Class2) _setPrototypeOf(instance2, Class2.prototype);
+                return instance2;
+              };
+            }
+            return _construct.apply(null, arguments);
+          }
+          function _isNativeReflectConstruct() {
+            if (typeof Reflect === "undefined" || !Reflect.construct) return false;
+            if (Reflect.construct.sham) return false;
+            if (typeof Proxy === "function") return true;
+            try {
+              Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function() {
+              }));
+              return true;
+            } catch (e2) {
+              return false;
+            }
+          }
+          function _isNativeFunction(fn) {
+            return Function.toString.call(fn).indexOf("[native code]") !== -1;
+          }
+          function _setPrototypeOf(o2, p2) {
+            _setPrototypeOf = Object.setPrototypeOf ? Object.setPrototypeOf.bind() : function _setPrototypeOf2(o22, p22) {
+              o22.__proto__ = p22;
+              return o22;
+            };
+            return _setPrototypeOf(o2, p2);
+          }
+          function _getPrototypeOf(o2) {
+            _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf.bind() : function _getPrototypeOf2(o22) {
+              return o22.__proto__ || Object.getPrototypeOf(o22);
+            };
+            return _getPrototypeOf(o2);
+          }
+          function _typeof(o2) {
+            "@babel/helpers - typeof";
+            return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function(o22) {
+              return typeof o22;
+            } : function(o22) {
+              return o22 && "function" == typeof Symbol && o22.constructor === Symbol && o22 !== Symbol.prototype ? "symbol" : typeof o22;
+            }, _typeof(o2);
+          }
+          var _require = require_util2();
+          var inspect = _require.inspect;
+          var _require2 = require_errors();
+          var ERR_INVALID_ARG_TYPE = _require2.codes.ERR_INVALID_ARG_TYPE;
+          function endsWith(str, search, this_len) {
+            if (this_len === void 0 || this_len > str.length) {
+              this_len = str.length;
+            }
+            return str.substring(this_len - search.length, this_len) === search;
+          }
+          function repeat(str, count2) {
+            count2 = Math.floor(count2);
+            if (str.length == 0 || count2 == 0) return "";
+            var maxCount = str.length * count2;
+            count2 = Math.floor(Math.log(count2) / Math.log(2));
+            while (count2) {
+              str += str;
+              count2--;
+            }
+            str += str.substring(0, maxCount - str.length);
+            return str;
+          }
+          var blue = "";
+          var green = "";
+          var red = "";
+          var white = "";
+          var kReadableOperator = {
+            deepStrictEqual: "Expected values to be strictly deep-equal:",
+            strictEqual: "Expected values to be strictly equal:",
+            strictEqualObject: 'Expected "actual" to be reference-equal to "expected":',
+            deepEqual: "Expected values to be loosely deep-equal:",
+            equal: "Expected values to be loosely equal:",
+            notDeepStrictEqual: 'Expected "actual" not to be strictly deep-equal to:',
+            notStrictEqual: 'Expected "actual" to be strictly unequal to:',
+            notStrictEqualObject: 'Expected "actual" not to be reference-equal to "expected":',
+            notDeepEqual: 'Expected "actual" not to be loosely deep-equal to:',
+            notEqual: 'Expected "actual" to be loosely unequal to:',
+            notIdentical: "Values identical but not reference-equal:"
+          };
+          var kMaxShortLength = 10;
+          function copyError(source2) {
+            var keys = Object.keys(source2);
+            var target = Object.create(Object.getPrototypeOf(source2));
+            keys.forEach(function(key) {
+              target[key] = source2[key];
+            });
+            Object.defineProperty(target, "message", {
+              value: source2.message
+            });
+            return target;
+          }
+          function inspectValue(val) {
+            return inspect(val, {
+              compact: false,
+              customInspect: false,
+              depth: 1e3,
+              maxArrayLength: Infinity,
+              // Assert compares only enumerable properties (with a few exceptions).
+              showHidden: false,
+              // Having a long line as error is better than wrapping the line for
+              // comparison for now.
+              // TODO(BridgeAR): `breakLength` should be limited as soon as soon as we
+              // have meta information about the inspected properties (i.e., know where
+              // in what line the property starts and ends).
+              breakLength: Infinity,
+              // Assert does not detect proxies currently.
+              showProxy: false,
+              sorted: true,
+              // Inspect getters as we also check them when comparing entries.
+              getters: true
+            });
+          }
+          function createErrDiff(actual, expected, operator) {
+            var other = "";
+            var res = "";
+            var lastPos = 0;
+            var end = "";
+            var skipped = false;
+            var actualInspected = inspectValue(actual);
+            var actualLines = actualInspected.split("\n");
+            var expectedLines = inspectValue(expected).split("\n");
+            var i2 = 0;
+            var indicator = "";
+            if (operator === "strictEqual" && _typeof(actual) === "object" && _typeof(expected) === "object" && actual !== null && expected !== null) {
+              operator = "strictEqualObject";
+            }
+            if (actualLines.length === 1 && expectedLines.length === 1 && actualLines[0] !== expectedLines[0]) {
+              var inputLength = actualLines[0].length + expectedLines[0].length;
+              if (inputLength <= kMaxShortLength) {
+                if ((_typeof(actual) !== "object" || actual === null) && (_typeof(expected) !== "object" || expected === null) && (actual !== 0 || expected !== 0)) {
+                  return "".concat(kReadableOperator[operator], "\n\n") + "".concat(actualLines[0], " !== ").concat(expectedLines[0], "\n");
+                }
+              } else if (operator !== "strictEqualObject") {
+                var maxLength = process.stderr && process.stderr.isTTY ? process.stderr.columns : 80;
+                if (inputLength < maxLength) {
+                  while (actualLines[0][i2] === expectedLines[0][i2]) {
+                    i2++;
+                  }
+                  if (i2 > 2) {
+                    indicator = "\n  ".concat(repeat(" ", i2), "^");
+                    i2 = 0;
+                  }
+                }
+              }
+            }
+            var a2 = actualLines[actualLines.length - 1];
+            var b2 = expectedLines[expectedLines.length - 1];
+            while (a2 === b2) {
+              if (i2++ < 2) {
+                end = "\n  ".concat(a2).concat(end);
+              } else {
+                other = a2;
+              }
+              actualLines.pop();
+              expectedLines.pop();
+              if (actualLines.length === 0 || expectedLines.length === 0) break;
+              a2 = actualLines[actualLines.length - 1];
+              b2 = expectedLines[expectedLines.length - 1];
+            }
+            var maxLines = Math.max(actualLines.length, expectedLines.length);
+            if (maxLines === 0) {
+              var _actualLines = actualInspected.split("\n");
+              if (_actualLines.length > 30) {
+                _actualLines[26] = "".concat(blue, "...").concat(white);
+                while (_actualLines.length > 27) {
+                  _actualLines.pop();
+                }
+              }
+              return "".concat(kReadableOperator.notIdentical, "\n\n").concat(_actualLines.join("\n"), "\n");
+            }
+            if (i2 > 3) {
+              end = "\n".concat(blue, "...").concat(white).concat(end);
+              skipped = true;
+            }
+            if (other !== "") {
+              end = "\n  ".concat(other).concat(end);
+              other = "";
+            }
+            var printedLines = 0;
+            var msg = kReadableOperator[operator] + "\n".concat(green, "+ actual").concat(white, " ").concat(red, "- expected").concat(white);
+            var skippedMsg = " ".concat(blue, "...").concat(white, " Lines skipped");
+            for (i2 = 0; i2 < maxLines; i2++) {
+              var cur = i2 - lastPos;
+              if (actualLines.length < i2 + 1) {
+                if (cur > 1 && i2 > 2) {
+                  if (cur > 4) {
+                    res += "\n".concat(blue, "...").concat(white);
+                    skipped = true;
+                  } else if (cur > 3) {
+                    res += "\n  ".concat(expectedLines[i2 - 2]);
+                    printedLines++;
+                  }
+                  res += "\n  ".concat(expectedLines[i2 - 1]);
+                  printedLines++;
+                }
+                lastPos = i2;
+                other += "\n".concat(red, "-").concat(white, " ").concat(expectedLines[i2]);
+                printedLines++;
+              } else if (expectedLines.length < i2 + 1) {
+                if (cur > 1 && i2 > 2) {
+                  if (cur > 4) {
+                    res += "\n".concat(blue, "...").concat(white);
+                    skipped = true;
+                  } else if (cur > 3) {
+                    res += "\n  ".concat(actualLines[i2 - 2]);
+                    printedLines++;
+                  }
+                  res += "\n  ".concat(actualLines[i2 - 1]);
+                  printedLines++;
+                }
+                lastPos = i2;
+                res += "\n".concat(green, "+").concat(white, " ").concat(actualLines[i2]);
+                printedLines++;
+              } else {
+                var expectedLine = expectedLines[i2];
+                var actualLine = actualLines[i2];
+                var divergingLines = actualLine !== expectedLine && (!endsWith(actualLine, ",") || actualLine.slice(0, -1) !== expectedLine);
+                if (divergingLines && endsWith(expectedLine, ",") && expectedLine.slice(0, -1) === actualLine) {
+                  divergingLines = false;
+                  actualLine += ",";
+                }
+                if (divergingLines) {
+                  if (cur > 1 && i2 > 2) {
+                    if (cur > 4) {
+                      res += "\n".concat(blue, "...").concat(white);
+                      skipped = true;
+                    } else if (cur > 3) {
+                      res += "\n  ".concat(actualLines[i2 - 2]);
+                      printedLines++;
+                    }
+                    res += "\n  ".concat(actualLines[i2 - 1]);
+                    printedLines++;
+                  }
+                  lastPos = i2;
+                  res += "\n".concat(green, "+").concat(white, " ").concat(actualLine);
+                  other += "\n".concat(red, "-").concat(white, " ").concat(expectedLine);
+                  printedLines += 2;
+                } else {
+                  res += other;
+                  other = "";
+                  if (cur === 1 || i2 === 0) {
+                    res += "\n  ".concat(actualLine);
+                    printedLines++;
+                  }
+                }
+              }
+              if (printedLines > 20 && i2 < maxLines - 2) {
+                return "".concat(msg).concat(skippedMsg, "\n").concat(res, "\n").concat(blue, "...").concat(white).concat(other, "\n") + "".concat(blue, "...").concat(white);
+              }
+            }
+            return "".concat(msg).concat(skipped ? skippedMsg : "", "\n").concat(res).concat(other).concat(end).concat(indicator);
+          }
+          var AssertionError = /* @__PURE__ */ function(_Error, _inspect$custom) {
+            _inherits(AssertionError2, _Error);
+            var _super = _createSuper(AssertionError2);
+            function AssertionError2(options) {
+              var _this;
+              _classCallCheck(this, AssertionError2);
+              if (_typeof(options) !== "object" || options === null) {
+                throw new ERR_INVALID_ARG_TYPE("options", "Object", options);
+              }
+              var message2 = options.message, operator = options.operator, stackStartFn = options.stackStartFn;
+              var actual = options.actual, expected = options.expected;
+              var limit = Error.stackTraceLimit;
+              Error.stackTraceLimit = 0;
+              if (message2 != null) {
+                _this = _super.call(this, String(message2));
+              } else {
+                if (process.stderr && process.stderr.isTTY) {
+                  if (process.stderr && process.stderr.getColorDepth && process.stderr.getColorDepth() !== 1) {
+                    blue = "\x1B[34m";
+                    green = "\x1B[32m";
+                    white = "\x1B[39m";
+                    red = "\x1B[31m";
+                  } else {
+                    blue = "";
+                    green = "";
+                    white = "";
+                    red = "";
+                  }
+                }
+                if (_typeof(actual) === "object" && actual !== null && _typeof(expected) === "object" && expected !== null && "stack" in actual && actual instanceof Error && "stack" in expected && expected instanceof Error) {
+                  actual = copyError(actual);
+                  expected = copyError(expected);
+                }
+                if (operator === "deepStrictEqual" || operator === "strictEqual") {
+                  _this = _super.call(this, createErrDiff(actual, expected, operator));
+                } else if (operator === "notDeepStrictEqual" || operator === "notStrictEqual") {
+                  var base = kReadableOperator[operator];
+                  var res = inspectValue(actual).split("\n");
+                  if (operator === "notStrictEqual" && _typeof(actual) === "object" && actual !== null) {
+                    base = kReadableOperator.notStrictEqualObject;
+                  }
+                  if (res.length > 30) {
+                    res[26] = "".concat(blue, "...").concat(white);
+                    while (res.length > 27) {
+                      res.pop();
+                    }
+                  }
+                  if (res.length === 1) {
+                    _this = _super.call(this, "".concat(base, " ").concat(res[0]));
+                  } else {
+                    _this = _super.call(this, "".concat(base, "\n\n").concat(res.join("\n"), "\n"));
+                  }
+                } else {
+                  var _res = inspectValue(actual);
+                  var other = "";
+                  var knownOperators = kReadableOperator[operator];
+                  if (operator === "notDeepEqual" || operator === "notEqual") {
+                    _res = "".concat(kReadableOperator[operator], "\n\n").concat(_res);
+                    if (_res.length > 1024) {
+                      _res = "".concat(_res.slice(0, 1021), "...");
+                    }
+                  } else {
+                    other = "".concat(inspectValue(expected));
+                    if (_res.length > 512) {
+                      _res = "".concat(_res.slice(0, 509), "...");
+                    }
+                    if (other.length > 512) {
+                      other = "".concat(other.slice(0, 509), "...");
+                    }
+                    if (operator === "deepEqual" || operator === "equal") {
+                      _res = "".concat(knownOperators, "\n\n").concat(_res, "\n\nshould equal\n\n");
+                    } else {
+                      other = " ".concat(operator, " ").concat(other);
+                    }
+                  }
+                  _this = _super.call(this, "".concat(_res).concat(other));
+                }
+              }
+              Error.stackTraceLimit = limit;
+              _this.generatedMessage = !message2;
+              Object.defineProperty(_assertThisInitialized(_this), "name", {
+                value: "AssertionError [ERR_ASSERTION]",
+                enumerable: false,
+                writable: true,
+                configurable: true
+              });
+              _this.code = "ERR_ASSERTION";
+              _this.actual = actual;
+              _this.expected = expected;
+              _this.operator = operator;
+              if (Error.captureStackTrace) {
+                Error.captureStackTrace(_assertThisInitialized(_this), stackStartFn);
+              }
+              _this.stack;
+              _this.name = "AssertionError";
+              return _possibleConstructorReturn(_this);
+            }
+            _createClass(AssertionError2, [{
+              key: "toString",
+              value: function toString() {
+                return "".concat(this.name, " [").concat(this.code, "]: ").concat(this.message);
+              }
+            }, {
+              key: _inspect$custom,
+              value: function value(recurseTimes, ctx2) {
+                return inspect(this, _objectSpread(_objectSpread({}, ctx2), {}, {
+                  customInspect: false,
+                  depth: 0
+                }));
+              }
+            }]);
+            return AssertionError2;
+          }(/* @__PURE__ */ _wrapNativeSuper(Error), inspect.custom);
+          module2.exports = AssertionError;
+        }
+      });
+      var require_isArguments = __commonJS({
+        "node_modules/object-keys/isArguments.js"(exports, module2) {
+          var toStr = Object.prototype.toString;
+          module2.exports = function isArguments(value) {
+            var str = toStr.call(value);
+            var isArgs = str === "[object Arguments]";
+            if (!isArgs) {
+              isArgs = str !== "[object Array]" && value !== null && typeof value === "object" && typeof value.length === "number" && value.length >= 0 && toStr.call(value.callee) === "[object Function]";
+            }
+            return isArgs;
+          };
+        }
+      });
+      var require_implementation2 = __commonJS({
+        "node_modules/object-keys/implementation.js"(exports, module2) {
+          var keysShim;
+          if (!Object.keys) {
+            has = Object.prototype.hasOwnProperty;
+            toStr = Object.prototype.toString;
+            isArgs = require_isArguments();
+            isEnumerable = Object.prototype.propertyIsEnumerable;
+            hasDontEnumBug = !isEnumerable.call({ toString: null }, "toString");
+            hasProtoEnumBug = isEnumerable.call(function() {
+            }, "prototype");
+            dontEnums = [
+              "toString",
+              "toLocaleString",
+              "valueOf",
+              "hasOwnProperty",
+              "isPrototypeOf",
+              "propertyIsEnumerable",
+              "constructor"
+            ];
+            equalsConstructorPrototype = function(o2) {
+              var ctor = o2.constructor;
+              return ctor && ctor.prototype === o2;
+            };
+            excludedKeys = {
+              $applicationCache: true,
+              $console: true,
+              $external: true,
+              $frame: true,
+              $frameElement: true,
+              $frames: true,
+              $innerHeight: true,
+              $innerWidth: true,
+              $onmozfullscreenchange: true,
+              $onmozfullscreenerror: true,
+              $outerHeight: true,
+              $outerWidth: true,
+              $pageXOffset: true,
+              $pageYOffset: true,
+              $parent: true,
+              $scrollLeft: true,
+              $scrollTop: true,
+              $scrollX: true,
+              $scrollY: true,
+              $self: true,
+              $webkitIndexedDB: true,
+              $webkitStorageInfo: true,
+              $window: true
+            };
+            hasAutomationEqualityBug = function() {
+              if (typeof window === "undefined") {
+                return false;
+              }
+              for (var k2 in window) {
+                try {
+                  if (!excludedKeys["$" + k2] && has.call(window, k2) && window[k2] !== null && typeof window[k2] === "object") {
+                    try {
+                      equalsConstructorPrototype(window[k2]);
+                    } catch (e2) {
+                      return true;
+                    }
+                  }
+                } catch (e2) {
+                  return true;
+                }
+              }
+              return false;
+            }();
+            equalsConstructorPrototypeIfNotBuggy = function(o2) {
+              if (typeof window === "undefined" || !hasAutomationEqualityBug) {
+                return equalsConstructorPrototype(o2);
+              }
+              try {
+                return equalsConstructorPrototype(o2);
+              } catch (e2) {
+                return false;
+              }
+            };
+            keysShim = function keys(object) {
+              var isObject2 = object !== null && typeof object === "object";
+              var isFunction2 = toStr.call(object) === "[object Function]";
+              var isArguments = isArgs(object);
+              var isString = isObject2 && toStr.call(object) === "[object String]";
+              var theKeys = [];
+              if (!isObject2 && !isFunction2 && !isArguments) {
+                throw new TypeError("Object.keys called on a non-object");
+              }
+              var skipProto = hasProtoEnumBug && isFunction2;
+              if (isString && object.length > 0 && !has.call(object, 0)) {
+                for (var i2 = 0; i2 < object.length; ++i2) {
+                  theKeys.push(String(i2));
+                }
+              }
+              if (isArguments && object.length > 0) {
+                for (var j2 = 0; j2 < object.length; ++j2) {
+                  theKeys.push(String(j2));
+                }
+              } else {
+                for (var name2 in object) {
+                  if (!(skipProto && name2 === "prototype") && has.call(object, name2)) {
+                    theKeys.push(String(name2));
+                  }
+                }
+              }
+              if (hasDontEnumBug) {
+                var skipConstructor = equalsConstructorPrototypeIfNotBuggy(object);
+                for (var k2 = 0; k2 < dontEnums.length; ++k2) {
+                  if (!(skipConstructor && dontEnums[k2] === "constructor") && has.call(object, dontEnums[k2])) {
+                    theKeys.push(dontEnums[k2]);
+                  }
+                }
+              }
+              return theKeys;
+            };
+          }
+          var has;
+          var toStr;
+          var isArgs;
+          var isEnumerable;
+          var hasDontEnumBug;
+          var hasProtoEnumBug;
+          var dontEnums;
+          var equalsConstructorPrototype;
+          var excludedKeys;
+          var hasAutomationEqualityBug;
+          var equalsConstructorPrototypeIfNotBuggy;
+          module2.exports = keysShim;
+        }
+      });
+      var require_object_keys = __commonJS({
+        "node_modules/object-keys/index.js"(exports, module2) {
+          var slice = Array.prototype.slice;
+          var isArgs = require_isArguments();
+          var origKeys = Object.keys;
+          var keysShim = origKeys ? function keys(o2) {
+            return origKeys(o2);
+          } : require_implementation2();
+          var originalKeys = Object.keys;
+          keysShim.shim = function shimObjectKeys() {
+            if (Object.keys) {
+              var keysWorksWithArguments = function() {
+                var args = Object.keys(arguments);
+                return args && args.length === arguments.length;
+              }(1, 2);
+              if (!keysWorksWithArguments) {
+                Object.keys = function keys(object) {
+                  if (isArgs(object)) {
+                    return originalKeys(slice.call(object));
+                  }
+                  return originalKeys(object);
+                };
+              }
+            } else {
+              Object.keys = keysShim;
+            }
+            return Object.keys || keysShim;
+          };
+          module2.exports = keysShim;
+        }
+      });
+      var require_implementation3 = __commonJS({
+        "node_modules/object.assign/implementation.js"(exports, module2) {
+          var objectKeys = require_object_keys();
+          var hasSymbols = require_shams()();
+          var callBound = require_callBound();
+          var toObject = Object;
+          var $push = callBound("Array.prototype.push");
+          var $propIsEnumerable = callBound("Object.prototype.propertyIsEnumerable");
+          var originalGetSymbols = hasSymbols ? Object.getOwnPropertySymbols : null;
+          module2.exports = function assign(target, source1) {
+            if (target == null) {
+              throw new TypeError("target must be an object");
+            }
+            var to = toObject(target);
+            if (arguments.length === 1) {
+              return to;
+            }
+            for (var s2 = 1; s2 < arguments.length; ++s2) {
+              var from = toObject(arguments[s2]);
+              var keys = objectKeys(from);
+              var getSymbols = hasSymbols && (Object.getOwnPropertySymbols || originalGetSymbols);
+              if (getSymbols) {
+                var syms = getSymbols(from);
+                for (var j2 = 0; j2 < syms.length; ++j2) {
+                  var key = syms[j2];
+                  if ($propIsEnumerable(from, key)) {
+                    $push(keys, key);
+                  }
+                }
+              }
+              for (var i2 = 0; i2 < keys.length; ++i2) {
+                var nextKey = keys[i2];
+                if ($propIsEnumerable(from, nextKey)) {
+                  var propValue = from[nextKey];
+                  to[nextKey] = propValue;
+                }
+              }
+            }
+            return to;
+          };
+        }
+      });
+      var require_polyfill = __commonJS({
+        "node_modules/object.assign/polyfill.js"(exports, module2) {
+          var implementation = require_implementation3();
+          var lacksProperEnumerationOrder = function() {
+            if (!Object.assign) {
+              return false;
+            }
+            var str = "abcdefghijklmnopqrst";
+            var letters = str.split("");
+            var map2 = {};
+            for (var i2 = 0; i2 < letters.length; ++i2) {
+              map2[letters[i2]] = letters[i2];
+            }
+            var obj = Object.assign({}, map2);
+            var actual = "";
+            for (var k2 in obj) {
+              actual += k2;
+            }
+            return str !== actual;
+          };
+          var assignHasPendingExceptions = function() {
+            if (!Object.assign || !Object.preventExtensions) {
+              return false;
+            }
+            var thrower = Object.preventExtensions({ 1: 2 });
+            try {
+              Object.assign(thrower, "xy");
+            } catch (e2) {
+              return thrower[1] === "y";
+            }
+            return false;
+          };
+          module2.exports = function getPolyfill() {
+            if (!Object.assign) {
+              return implementation;
+            }
+            if (lacksProperEnumerationOrder()) {
+              return implementation;
+            }
+            if (assignHasPendingExceptions()) {
+              return implementation;
+            }
+            return Object.assign;
+          };
+        }
+      });
+      var require_implementation4 = __commonJS({
+        "node_modules/object-is/implementation.js"(exports, module2) {
+          var numberIsNaN = function(value) {
+            return value !== value;
+          };
+          module2.exports = function is(a2, b2) {
+            if (a2 === 0 && b2 === 0) {
+              return 1 / a2 === 1 / b2;
+            }
+            if (a2 === b2) {
+              return true;
+            }
+            if (numberIsNaN(a2) && numberIsNaN(b2)) {
+              return true;
+            }
+            return false;
+          };
+        }
+      });
+      var require_polyfill2 = __commonJS({
+        "node_modules/object-is/polyfill.js"(exports, module2) {
+          var implementation = require_implementation4();
+          module2.exports = function getPolyfill() {
+            return typeof Object.is === "function" ? Object.is : implementation;
+          };
+        }
+      });
+      var require_define_properties = __commonJS({
+        "node_modules/define-properties/index.js"(exports, module2) {
+          var keys = require_object_keys();
+          var hasSymbols = typeof Symbol === "function" && typeof Symbol("foo") === "symbol";
+          var toStr = Object.prototype.toString;
+          var concat = Array.prototype.concat;
+          var origDefineProperty = Object.defineProperty;
+          var isFunction2 = function(fn) {
+            return typeof fn === "function" && toStr.call(fn) === "[object Function]";
+          };
+          var hasPropertyDescriptors = require_has_property_descriptors()();
+          var supportsDescriptors = origDefineProperty && hasPropertyDescriptors;
+          var defineProperty = function(object, name2, value, predicate) {
+            if (name2 in object) {
+              if (predicate === true) {
+                if (object[name2] === value) {
+                  return;
+                }
+              } else if (!isFunction2(predicate) || !predicate()) {
+                return;
+              }
+            }
+            if (supportsDescriptors) {
+              origDefineProperty(object, name2, {
+                configurable: true,
+                enumerable: false,
+                value,
+                writable: true
+              });
+            } else {
+              object[name2] = value;
+            }
+          };
+          var defineProperties = function(object, map2) {
+            var predicates = arguments.length > 2 ? arguments[2] : {};
+            var props = keys(map2);
+            if (hasSymbols) {
+              props = concat.call(props, Object.getOwnPropertySymbols(map2));
+            }
+            for (var i2 = 0; i2 < props.length; i2 += 1) {
+              defineProperty(object, props[i2], map2[props[i2]], predicates[props[i2]]);
+            }
+          };
+          defineProperties.supportsDescriptors = !!supportsDescriptors;
+          module2.exports = defineProperties;
+        }
+      });
+      var require_shim = __commonJS({
+        "node_modules/object-is/shim.js"(exports, module2) {
+          var getPolyfill = require_polyfill2();
+          var define2 = require_define_properties();
+          module2.exports = function shimObjectIs() {
+            var polyfill2 = getPolyfill();
+            define2(Object, { is: polyfill2 }, {
+              is: function testObjectIs() {
+                return Object.is !== polyfill2;
+              }
+            });
+            return polyfill2;
+          };
+        }
+      });
+      var require_object_is = __commonJS({
+        "node_modules/object-is/index.js"(exports, module2) {
+          var define2 = require_define_properties();
+          var callBind = require_call_bind();
+          var implementation = require_implementation4();
+          var getPolyfill = require_polyfill2();
+          var shim = require_shim();
+          var polyfill2 = callBind(getPolyfill(), Object);
+          define2(polyfill2, {
+            getPolyfill,
+            implementation,
+            shim
+          });
+          module2.exports = polyfill2;
+        }
+      });
+      var require_implementation5 = __commonJS({
+        "node_modules/is-nan/implementation.js"(exports, module2) {
+          module2.exports = function isNaN2(value) {
+            return value !== value;
+          };
+        }
+      });
+      var require_polyfill3 = __commonJS({
+        "node_modules/is-nan/polyfill.js"(exports, module2) {
+          var implementation = require_implementation5();
+          module2.exports = function getPolyfill() {
+            if (Number.isNaN && Number.isNaN(NaN) && !Number.isNaN("a")) {
+              return Number.isNaN;
+            }
+            return implementation;
+          };
+        }
+      });
+      var require_shim2 = __commonJS({
+        "node_modules/is-nan/shim.js"(exports, module2) {
+          var define2 = require_define_properties();
+          var getPolyfill = require_polyfill3();
+          module2.exports = function shimNumberIsNaN() {
+            var polyfill2 = getPolyfill();
+            define2(Number, { isNaN: polyfill2 }, {
+              isNaN: function testIsNaN() {
+                return Number.isNaN !== polyfill2;
+              }
+            });
+            return polyfill2;
+          };
+        }
+      });
+      var require_is_nan = __commonJS({
+        "node_modules/is-nan/index.js"(exports, module2) {
+          var callBind = require_call_bind();
+          var define2 = require_define_properties();
+          var implementation = require_implementation5();
+          var getPolyfill = require_polyfill3();
+          var shim = require_shim2();
+          var polyfill2 = callBind(getPolyfill(), Number);
+          define2(polyfill2, {
+            getPolyfill,
+            implementation,
+            shim
+          });
+          module2.exports = polyfill2;
+        }
+      });
+      var require_comparisons = __commonJS({
+        "node_modules/assert/build/internal/util/comparisons.js"(exports, module2) {
+          function _slicedToArray(arr, i2) {
+            return _arrayWithHoles(arr) || _iterableToArrayLimit(arr, i2) || _unsupportedIterableToArray(arr, i2) || _nonIterableRest();
+          }
+          function _nonIterableRest() {
+            throw new TypeError("Invalid attempt to destructure non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
+          }
+          function _unsupportedIterableToArray(o2, minLen) {
+            if (!o2) return;
+            if (typeof o2 === "string") return _arrayLikeToArray(o2, minLen);
+            var n2 = Object.prototype.toString.call(o2).slice(8, -1);
+            if (n2 === "Object" && o2.constructor) n2 = o2.constructor.name;
+            if (n2 === "Map" || n2 === "Set") return Array.from(o2);
+            if (n2 === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n2)) return _arrayLikeToArray(o2, minLen);
+          }
+          function _arrayLikeToArray(arr, len2) {
+            if (len2 == null || len2 > arr.length) len2 = arr.length;
+            for (var i2 = 0, arr2 = new Array(len2); i2 < len2; i2++) arr2[i2] = arr[i2];
+            return arr2;
+          }
+          function _iterableToArrayLimit(r2, l2) {
+            var t4 = null == r2 ? null : "undefined" != typeof Symbol && r2[Symbol.iterator] || r2["@@iterator"];
+            if (null != t4) {
+              var e2, n2, i2, u2, a2 = [], f2 = true, o2 = false;
+              try {
+                if (i2 = (t4 = t4.call(r2)).next, 0 === l2) ;
+                else for (; !(f2 = (e2 = i2.call(t4)).done) && (a2.push(e2.value), a2.length !== l2); f2 = true) ;
+              } catch (r22) {
+                o2 = true, n2 = r22;
+              } finally {
+                try {
+                  if (!f2 && null != t4.return && (u2 = t4.return(), Object(u2) !== u2)) return;
+                } finally {
+                  if (o2) throw n2;
+                }
+              }
+              return a2;
+            }
+          }
+          function _arrayWithHoles(arr) {
+            if (Array.isArray(arr)) return arr;
+          }
+          function _typeof(o2) {
+            "@babel/helpers - typeof";
+            return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function(o22) {
+              return typeof o22;
+            } : function(o22) {
+              return o22 && "function" == typeof Symbol && o22.constructor === Symbol && o22 !== Symbol.prototype ? "symbol" : typeof o22;
+            }, _typeof(o2);
+          }
+          var regexFlagsSupported = /a/g.flags !== void 0;
+          var arrayFromSet = function arrayFromSet2(set) {
+            var array = [];
+            set.forEach(function(value) {
+              return array.push(value);
+            });
+            return array;
+          };
+          var arrayFromMap = function arrayFromMap2(map2) {
+            var array = [];
+            map2.forEach(function(value, key) {
+              return array.push([key, value]);
+            });
+            return array;
+          };
+          var objectIs = Object.is ? Object.is : require_object_is();
+          var objectGetOwnPropertySymbols = Object.getOwnPropertySymbols ? Object.getOwnPropertySymbols : function() {
+            return [];
+          };
+          var numberIsNaN = Number.isNaN ? Number.isNaN : require_is_nan();
+          function uncurryThis(f2) {
+            return f2.call.bind(f2);
+          }
+          var hasOwnProperty2 = uncurryThis(Object.prototype.hasOwnProperty);
+          var propertyIsEnumerable = uncurryThis(Object.prototype.propertyIsEnumerable);
+          var objectToString = uncurryThis(Object.prototype.toString);
+          var _require$types = require_util2().types;
+          var isAnyArrayBuffer = _require$types.isAnyArrayBuffer;
+          var isArrayBufferView = _require$types.isArrayBufferView;
+          var isDate = _require$types.isDate;
+          var isMap = _require$types.isMap;
+          var isRegExp = _require$types.isRegExp;
+          var isSet = _require$types.isSet;
+          var isNativeError = _require$types.isNativeError;
+          var isBoxedPrimitive = _require$types.isBoxedPrimitive;
+          var isNumberObject = _require$types.isNumberObject;
+          var isStringObject = _require$types.isStringObject;
+          var isBooleanObject = _require$types.isBooleanObject;
+          var isBigIntObject = _require$types.isBigIntObject;
+          var isSymbolObject = _require$types.isSymbolObject;
+          var isFloat32Array = _require$types.isFloat32Array;
+          var isFloat64Array = _require$types.isFloat64Array;
+          function isNonIndex(key) {
+            if (key.length === 0 || key.length > 10) return true;
+            for (var i2 = 0; i2 < key.length; i2++) {
+              var code = key.charCodeAt(i2);
+              if (code < 48 || code > 57) return true;
+            }
+            return key.length === 10 && key >= Math.pow(2, 32);
+          }
+          function getOwnNonIndexProperties(value) {
+            return Object.keys(value).filter(isNonIndex).concat(objectGetOwnPropertySymbols(value).filter(Object.prototype.propertyIsEnumerable.bind(value)));
+          }
+          function compare(a2, b2) {
+            if (a2 === b2) {
+              return 0;
+            }
+            var x2 = a2.length;
+            var y2 = b2.length;
+            for (var i2 = 0, len2 = Math.min(x2, y2); i2 < len2; ++i2) {
+              if (a2[i2] !== b2[i2]) {
+                x2 = a2[i2];
+                y2 = b2[i2];
+                break;
+              }
+            }
+            if (x2 < y2) {
+              return -1;
+            }
+            if (y2 < x2) {
+              return 1;
+            }
+            return 0;
+          }
+          var kStrict = true;
+          var kLoose = false;
+          var kNoIterator = 0;
+          var kIsArray = 1;
+          var kIsSet = 2;
+          var kIsMap = 3;
+          function areSimilarRegExps(a2, b2) {
+            return regexFlagsSupported ? a2.source === b2.source && a2.flags === b2.flags : RegExp.prototype.toString.call(a2) === RegExp.prototype.toString.call(b2);
+          }
+          function areSimilarFloatArrays(a2, b2) {
+            if (a2.byteLength !== b2.byteLength) {
+              return false;
+            }
+            for (var offset = 0; offset < a2.byteLength; offset++) {
+              if (a2[offset] !== b2[offset]) {
+                return false;
+              }
+            }
+            return true;
+          }
+          function areSimilarTypedArrays(a2, b2) {
+            if (a2.byteLength !== b2.byteLength) {
+              return false;
+            }
+            return compare(new Uint8Array(a2.buffer, a2.byteOffset, a2.byteLength), new Uint8Array(b2.buffer, b2.byteOffset, b2.byteLength)) === 0;
+          }
+          function areEqualArrayBuffers(buf1, buf2) {
+            return buf1.byteLength === buf2.byteLength && compare(new Uint8Array(buf1), new Uint8Array(buf2)) === 0;
+          }
+          function isEqualBoxedPrimitive(val1, val2) {
+            if (isNumberObject(val1)) {
+              return isNumberObject(val2) && objectIs(Number.prototype.valueOf.call(val1), Number.prototype.valueOf.call(val2));
+            }
+            if (isStringObject(val1)) {
+              return isStringObject(val2) && String.prototype.valueOf.call(val1) === String.prototype.valueOf.call(val2);
+            }
+            if (isBooleanObject(val1)) {
+              return isBooleanObject(val2) && Boolean.prototype.valueOf.call(val1) === Boolean.prototype.valueOf.call(val2);
+            }
+            if (isBigIntObject(val1)) {
+              return isBigIntObject(val2) && BigInt.prototype.valueOf.call(val1) === BigInt.prototype.valueOf.call(val2);
+            }
+            return isSymbolObject(val2) && Symbol.prototype.valueOf.call(val1) === Symbol.prototype.valueOf.call(val2);
+          }
+          function innerDeepEqual(val1, val2, strict, memos) {
+            if (val1 === val2) {
+              if (val1 !== 0) return true;
+              return strict ? objectIs(val1, val2) : true;
+            }
+            if (strict) {
+              if (_typeof(val1) !== "object") {
+                return typeof val1 === "number" && numberIsNaN(val1) && numberIsNaN(val2);
+              }
+              if (_typeof(val2) !== "object" || val1 === null || val2 === null) {
+                return false;
+              }
+              if (Object.getPrototypeOf(val1) !== Object.getPrototypeOf(val2)) {
+                return false;
+              }
+            } else {
+              if (val1 === null || _typeof(val1) !== "object") {
+                if (val2 === null || _typeof(val2) !== "object") {
+                  return val1 == val2;
+                }
+                return false;
+              }
+              if (val2 === null || _typeof(val2) !== "object") {
+                return false;
+              }
+            }
+            var val1Tag = objectToString(val1);
+            var val2Tag = objectToString(val2);
+            if (val1Tag !== val2Tag) {
+              return false;
+            }
+            if (Array.isArray(val1)) {
+              if (val1.length !== val2.length) {
+                return false;
+              }
+              var keys1 = getOwnNonIndexProperties(val1);
+              var keys2 = getOwnNonIndexProperties(val2);
+              if (keys1.length !== keys2.length) {
+                return false;
+              }
+              return keyCheck(val1, val2, strict, memos, kIsArray, keys1);
+            }
+            if (val1Tag === "[object Object]") {
+              if (!isMap(val1) && isMap(val2) || !isSet(val1) && isSet(val2)) {
+                return false;
+              }
+            }
+            if (isDate(val1)) {
+              if (!isDate(val2) || Date.prototype.getTime.call(val1) !== Date.prototype.getTime.call(val2)) {
+                return false;
+              }
+            } else if (isRegExp(val1)) {
+              if (!isRegExp(val2) || !areSimilarRegExps(val1, val2)) {
+                return false;
+              }
+            } else if (isNativeError(val1) || val1 instanceof Error) {
+              if (val1.message !== val2.message || val1.name !== val2.name) {
+                return false;
+              }
+            } else if (isArrayBufferView(val1)) {
+              if (!strict && (isFloat32Array(val1) || isFloat64Array(val1))) {
+                if (!areSimilarFloatArrays(val1, val2)) {
+                  return false;
+                }
+              } else if (!areSimilarTypedArrays(val1, val2)) {
+                return false;
+              }
+              var _keys = getOwnNonIndexProperties(val1);
+              var _keys2 = getOwnNonIndexProperties(val2);
+              if (_keys.length !== _keys2.length) {
+                return false;
+              }
+              return keyCheck(val1, val2, strict, memos, kNoIterator, _keys);
+            } else if (isSet(val1)) {
+              if (!isSet(val2) || val1.size !== val2.size) {
+                return false;
+              }
+              return keyCheck(val1, val2, strict, memos, kIsSet);
+            } else if (isMap(val1)) {
+              if (!isMap(val2) || val1.size !== val2.size) {
+                return false;
+              }
+              return keyCheck(val1, val2, strict, memos, kIsMap);
+            } else if (isAnyArrayBuffer(val1)) {
+              if (!areEqualArrayBuffers(val1, val2)) {
+                return false;
+              }
+            } else if (isBoxedPrimitive(val1) && !isEqualBoxedPrimitive(val1, val2)) {
+              return false;
+            }
+            return keyCheck(val1, val2, strict, memos, kNoIterator);
+          }
+          function getEnumerables(val, keys) {
+            return keys.filter(function(k2) {
+              return propertyIsEnumerable(val, k2);
+            });
+          }
+          function keyCheck(val1, val2, strict, memos, iterationType, aKeys) {
+            if (arguments.length === 5) {
+              aKeys = Object.keys(val1);
+              var bKeys = Object.keys(val2);
+              if (aKeys.length !== bKeys.length) {
+                return false;
+              }
+            }
+            var i2 = 0;
+            for (; i2 < aKeys.length; i2++) {
+              if (!hasOwnProperty2(val2, aKeys[i2])) {
+                return false;
+              }
+            }
+            if (strict && arguments.length === 5) {
+              var symbolKeysA = objectGetOwnPropertySymbols(val1);
+              if (symbolKeysA.length !== 0) {
+                var count2 = 0;
+                for (i2 = 0; i2 < symbolKeysA.length; i2++) {
+                  var key = symbolKeysA[i2];
+                  if (propertyIsEnumerable(val1, key)) {
+                    if (!propertyIsEnumerable(val2, key)) {
+                      return false;
+                    }
+                    aKeys.push(key);
+                    count2++;
+                  } else if (propertyIsEnumerable(val2, key)) {
+                    return false;
+                  }
+                }
+                var symbolKeysB = objectGetOwnPropertySymbols(val2);
+                if (symbolKeysA.length !== symbolKeysB.length && getEnumerables(val2, symbolKeysB).length !== count2) {
+                  return false;
+                }
+              } else {
+                var _symbolKeysB = objectGetOwnPropertySymbols(val2);
+                if (_symbolKeysB.length !== 0 && getEnumerables(val2, _symbolKeysB).length !== 0) {
+                  return false;
+                }
+              }
+            }
+            if (aKeys.length === 0 && (iterationType === kNoIterator || iterationType === kIsArray && val1.length === 0 || val1.size === 0)) {
+              return true;
+            }
+            if (memos === void 0) {
+              memos = {
+                val1: /* @__PURE__ */ new Map(),
+                val2: /* @__PURE__ */ new Map(),
+                position: 0
+              };
+            } else {
+              var val2MemoA = memos.val1.get(val1);
+              if (val2MemoA !== void 0) {
+                var val2MemoB = memos.val2.get(val2);
+                if (val2MemoB !== void 0) {
+                  return val2MemoA === val2MemoB;
+                }
+              }
+              memos.position++;
+            }
+            memos.val1.set(val1, memos.position);
+            memos.val2.set(val2, memos.position);
+            var areEq = objEquiv(val1, val2, strict, aKeys, memos, iterationType);
+            memos.val1.delete(val1);
+            memos.val2.delete(val2);
+            return areEq;
+          }
+          function setHasEqualElement(set, val1, strict, memo) {
+            var setValues = arrayFromSet(set);
+            for (var i2 = 0; i2 < setValues.length; i2++) {
+              var val2 = setValues[i2];
+              if (innerDeepEqual(val1, val2, strict, memo)) {
+                set.delete(val2);
+                return true;
+              }
+            }
+            return false;
+          }
+          function findLooseMatchingPrimitives(prim) {
+            switch (_typeof(prim)) {
+              case "undefined":
+                return null;
+              case "object":
+                return void 0;
+              case "symbol":
+                return false;
+              case "string":
+                prim = +prim;
+              case "number":
+                if (numberIsNaN(prim)) {
+                  return false;
+                }
+            }
+            return true;
+          }
+          function setMightHaveLoosePrim(a2, b2, prim) {
+            var altValue = findLooseMatchingPrimitives(prim);
+            if (altValue != null) return altValue;
+            return b2.has(altValue) && !a2.has(altValue);
+          }
+          function mapMightHaveLoosePrim(a2, b2, prim, item, memo) {
+            var altValue = findLooseMatchingPrimitives(prim);
+            if (altValue != null) {
+              return altValue;
+            }
+            var curB = b2.get(altValue);
+            if (curB === void 0 && !b2.has(altValue) || !innerDeepEqual(item, curB, false, memo)) {
+              return false;
+            }
+            return !a2.has(altValue) && innerDeepEqual(item, curB, false, memo);
+          }
+          function setEquiv(a2, b2, strict, memo) {
+            var set = null;
+            var aValues = arrayFromSet(a2);
+            for (var i2 = 0; i2 < aValues.length; i2++) {
+              var val = aValues[i2];
+              if (_typeof(val) === "object" && val !== null) {
+                if (set === null) {
+                  set = /* @__PURE__ */ new Set();
+                }
+                set.add(val);
+              } else if (!b2.has(val)) {
+                if (strict) return false;
+                if (!setMightHaveLoosePrim(a2, b2, val)) {
+                  return false;
+                }
+                if (set === null) {
+                  set = /* @__PURE__ */ new Set();
+                }
+                set.add(val);
+              }
+            }
+            if (set !== null) {
+              var bValues = arrayFromSet(b2);
+              for (var _i = 0; _i < bValues.length; _i++) {
+                var _val = bValues[_i];
+                if (_typeof(_val) === "object" && _val !== null) {
+                  if (!setHasEqualElement(set, _val, strict, memo)) return false;
+                } else if (!strict && !a2.has(_val) && !setHasEqualElement(set, _val, strict, memo)) {
+                  return false;
+                }
+              }
+              return set.size === 0;
+            }
+            return true;
+          }
+          function mapHasEqualEntry(set, map2, key1, item1, strict, memo) {
+            var setValues = arrayFromSet(set);
+            for (var i2 = 0; i2 < setValues.length; i2++) {
+              var key2 = setValues[i2];
+              if (innerDeepEqual(key1, key2, strict, memo) && innerDeepEqual(item1, map2.get(key2), strict, memo)) {
+                set.delete(key2);
+                return true;
+              }
+            }
+            return false;
+          }
+          function mapEquiv(a2, b2, strict, memo) {
+            var set = null;
+            var aEntries = arrayFromMap(a2);
+            for (var i2 = 0; i2 < aEntries.length; i2++) {
+              var _aEntries$i = _slicedToArray(aEntries[i2], 2), key = _aEntries$i[0], item1 = _aEntries$i[1];
+              if (_typeof(key) === "object" && key !== null) {
+                if (set === null) {
+                  set = /* @__PURE__ */ new Set();
+                }
+                set.add(key);
+              } else {
+                var item2 = b2.get(key);
+                if (item2 === void 0 && !b2.has(key) || !innerDeepEqual(item1, item2, strict, memo)) {
+                  if (strict) return false;
+                  if (!mapMightHaveLoosePrim(a2, b2, key, item1, memo)) return false;
+                  if (set === null) {
+                    set = /* @__PURE__ */ new Set();
+                  }
+                  set.add(key);
+                }
+              }
+            }
+            if (set !== null) {
+              var bEntries = arrayFromMap(b2);
+              for (var _i2 = 0; _i2 < bEntries.length; _i2++) {
+                var _bEntries$_i = _slicedToArray(bEntries[_i2], 2), _key = _bEntries$_i[0], item = _bEntries$_i[1];
+                if (_typeof(_key) === "object" && _key !== null) {
+                  if (!mapHasEqualEntry(set, a2, _key, item, strict, memo)) return false;
+                } else if (!strict && (!a2.has(_key) || !innerDeepEqual(a2.get(_key), item, false, memo)) && !mapHasEqualEntry(set, a2, _key, item, false, memo)) {
+                  return false;
+                }
+              }
+              return set.size === 0;
+            }
+            return true;
+          }
+          function objEquiv(a2, b2, strict, keys, memos, iterationType) {
+            var i2 = 0;
+            if (iterationType === kIsSet) {
+              if (!setEquiv(a2, b2, strict, memos)) {
+                return false;
+              }
+            } else if (iterationType === kIsMap) {
+              if (!mapEquiv(a2, b2, strict, memos)) {
+                return false;
+              }
+            } else if (iterationType === kIsArray) {
+              for (; i2 < a2.length; i2++) {
+                if (hasOwnProperty2(a2, i2)) {
+                  if (!hasOwnProperty2(b2, i2) || !innerDeepEqual(a2[i2], b2[i2], strict, memos)) {
+                    return false;
+                  }
+                } else if (hasOwnProperty2(b2, i2)) {
+                  return false;
+                } else {
+                  var keysA = Object.keys(a2);
+                  for (; i2 < keysA.length; i2++) {
+                    var key = keysA[i2];
+                    if (!hasOwnProperty2(b2, key) || !innerDeepEqual(a2[key], b2[key], strict, memos)) {
+                      return false;
+                    }
+                  }
+                  if (keysA.length !== Object.keys(b2).length) {
+                    return false;
+                  }
+                  return true;
+                }
+              }
+            }
+            for (i2 = 0; i2 < keys.length; i2++) {
+              var _key2 = keys[i2];
+              if (!innerDeepEqual(a2[_key2], b2[_key2], strict, memos)) {
+                return false;
+              }
+            }
+            return true;
+          }
+          function isDeepEqual(val1, val2) {
+            return innerDeepEqual(val1, val2, kLoose);
+          }
+          function isDeepStrictEqual(val1, val2) {
+            return innerDeepEqual(val1, val2, kStrict);
+          }
+          module2.exports = {
+            isDeepEqual,
+            isDeepStrictEqual
+          };
+        }
+      });
+      var require_assert = __commonJS({
+        "node_modules/assert/build/assert.js"(exports, module2) {
+          function _typeof(o2) {
+            "@babel/helpers - typeof";
+            return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function(o22) {
+              return typeof o22;
+            } : function(o22) {
+              return o22 && "function" == typeof Symbol && o22.constructor === Symbol && o22 !== Symbol.prototype ? "symbol" : typeof o22;
+            }, _typeof(o2);
+          }
+          function _createClass(Constructor, protoProps, staticProps) {
+            Object.defineProperty(Constructor, "prototype", { writable: false });
+            return Constructor;
+          }
+          function _classCallCheck(instance2, Constructor) {
+            if (!(instance2 instanceof Constructor)) {
+              throw new TypeError("Cannot call a class as a function");
+            }
+          }
+          var _require = require_errors();
+          var _require$codes = _require.codes;
+          var ERR_AMBIGUOUS_ARGUMENT = _require$codes.ERR_AMBIGUOUS_ARGUMENT;
+          var ERR_INVALID_ARG_TYPE = _require$codes.ERR_INVALID_ARG_TYPE;
+          var ERR_INVALID_ARG_VALUE = _require$codes.ERR_INVALID_ARG_VALUE;
+          var ERR_INVALID_RETURN_VALUE = _require$codes.ERR_INVALID_RETURN_VALUE;
+          var ERR_MISSING_ARGS = _require$codes.ERR_MISSING_ARGS;
+          var AssertionError = require_assertion_error();
+          var _require2 = require_util2();
+          var inspect = _require2.inspect;
+          var _require$types = require_util2().types;
+          var isPromise2 = _require$types.isPromise;
+          var isRegExp = _require$types.isRegExp;
+          var objectAssign = require_polyfill()();
+          var objectIs = require_polyfill2()();
+          var RegExpPrototypeTest = require_callBound()("RegExp.prototype.test");
+          var isDeepEqual;
+          var isDeepStrictEqual;
+          function lazyLoadComparison() {
+            var comparison = require_comparisons();
+            isDeepEqual = comparison.isDeepEqual;
+            isDeepStrictEqual = comparison.isDeepStrictEqual;
+          }
+          var warned = false;
+          var assert2 = module2.exports = ok2;
+          var NO_EXCEPTION_SENTINEL = {};
+          function innerFail(obj) {
+            if (obj.message instanceof Error) throw obj.message;
+            throw new AssertionError(obj);
+          }
+          function fail(actual, expected, message2, operator, stackStartFn) {
+            var argsLen = arguments.length;
+            var internalMessage;
+            if (argsLen === 0) {
+              internalMessage = "Failed";
+            } else if (argsLen === 1) {
+              message2 = actual;
+              actual = void 0;
+            } else {
+              if (warned === false) {
+                warned = true;
+                var warn = process.emitWarning ? process.emitWarning : console.warn.bind(console);
+                warn("assert.fail() with more than one argument is deprecated. Please use assert.strictEqual() instead or only pass a message.", "DeprecationWarning", "DEP0094");
+              }
+              if (argsLen === 2) operator = "!=";
+            }
+            if (message2 instanceof Error) throw message2;
+            var errArgs = {
+              actual,
+              expected,
+              operator: operator === void 0 ? "fail" : operator,
+              stackStartFn: stackStartFn || fail
+            };
+            if (message2 !== void 0) {
+              errArgs.message = message2;
+            }
+            var err = new AssertionError(errArgs);
+            if (internalMessage) {
+              err.message = internalMessage;
+              err.generatedMessage = true;
+            }
+            throw err;
+          }
+          assert2.fail = fail;
+          assert2.AssertionError = AssertionError;
+          function innerOk(fn, argLen, value, message2) {
+            if (!value) {
+              var generatedMessage = false;
+              if (argLen === 0) {
+                generatedMessage = true;
+                message2 = "No value argument passed to `assert.ok()`";
+              } else if (message2 instanceof Error) {
+                throw message2;
+              }
+              var err = new AssertionError({
+                actual: value,
+                expected: true,
+                message: message2,
+                operator: "==",
+                stackStartFn: fn
+              });
+              err.generatedMessage = generatedMessage;
+              throw err;
+            }
+          }
+          function ok2() {
+            for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
+              args[_key] = arguments[_key];
+            }
+            innerOk.apply(void 0, [ok2, args.length].concat(args));
+          }
+          assert2.ok = ok2;
+          assert2.equal = function equal(actual, expected, message2) {
+            if (arguments.length < 2) {
+              throw new ERR_MISSING_ARGS("actual", "expected");
+            }
+            if (actual != expected) {
+              innerFail({
+                actual,
+                expected,
+                message: message2,
+                operator: "==",
+                stackStartFn: equal
+              });
+            }
+          };
+          assert2.notEqual = function notEqual(actual, expected, message2) {
+            if (arguments.length < 2) {
+              throw new ERR_MISSING_ARGS("actual", "expected");
+            }
+            if (actual == expected) {
+              innerFail({
+                actual,
+                expected,
+                message: message2,
+                operator: "!=",
+                stackStartFn: notEqual
+              });
+            }
+          };
+          assert2.deepEqual = function deepEqual2(actual, expected, message2) {
+            if (arguments.length < 2) {
+              throw new ERR_MISSING_ARGS("actual", "expected");
+            }
+            if (isDeepEqual === void 0) lazyLoadComparison();
+            if (!isDeepEqual(actual, expected)) {
+              innerFail({
+                actual,
+                expected,
+                message: message2,
+                operator: "deepEqual",
+                stackStartFn: deepEqual2
+              });
+            }
+          };
+          assert2.notDeepEqual = function notDeepEqual(actual, expected, message2) {
+            if (arguments.length < 2) {
+              throw new ERR_MISSING_ARGS("actual", "expected");
+            }
+            if (isDeepEqual === void 0) lazyLoadComparison();
+            if (isDeepEqual(actual, expected)) {
+              innerFail({
+                actual,
+                expected,
+                message: message2,
+                operator: "notDeepEqual",
+                stackStartFn: notDeepEqual
+              });
+            }
+          };
+          assert2.deepStrictEqual = function deepStrictEqual(actual, expected, message2) {
+            if (arguments.length < 2) {
+              throw new ERR_MISSING_ARGS("actual", "expected");
+            }
+            if (isDeepEqual === void 0) lazyLoadComparison();
+            if (!isDeepStrictEqual(actual, expected)) {
+              innerFail({
+                actual,
+                expected,
+                message: message2,
+                operator: "deepStrictEqual",
+                stackStartFn: deepStrictEqual
+              });
+            }
+          };
+          assert2.notDeepStrictEqual = notDeepStrictEqual;
+          function notDeepStrictEqual(actual, expected, message2) {
+            if (arguments.length < 2) {
+              throw new ERR_MISSING_ARGS("actual", "expected");
+            }
+            if (isDeepEqual === void 0) lazyLoadComparison();
+            if (isDeepStrictEqual(actual, expected)) {
+              innerFail({
+                actual,
+                expected,
+                message: message2,
+                operator: "notDeepStrictEqual",
+                stackStartFn: notDeepStrictEqual
+              });
+            }
+          }
+          assert2.strictEqual = function strictEqual(actual, expected, message2) {
+            if (arguments.length < 2) {
+              throw new ERR_MISSING_ARGS("actual", "expected");
+            }
+            if (!objectIs(actual, expected)) {
+              innerFail({
+                actual,
+                expected,
+                message: message2,
+                operator: "strictEqual",
+                stackStartFn: strictEqual
+              });
+            }
+          };
+          assert2.notStrictEqual = function notStrictEqual(actual, expected, message2) {
+            if (arguments.length < 2) {
+              throw new ERR_MISSING_ARGS("actual", "expected");
+            }
+            if (objectIs(actual, expected)) {
+              innerFail({
+                actual,
+                expected,
+                message: message2,
+                operator: "notStrictEqual",
+                stackStartFn: notStrictEqual
+              });
+            }
+          };
+          var Comparison = /* @__PURE__ */ _createClass(function Comparison2(obj, keys, actual) {
+            var _this = this;
+            _classCallCheck(this, Comparison2);
+            keys.forEach(function(key) {
+              if (key in obj) {
+                if (actual !== void 0 && typeof actual[key] === "string" && isRegExp(obj[key]) && RegExpPrototypeTest(obj[key], actual[key])) {
+                  _this[key] = actual[key];
+                } else {
+                  _this[key] = obj[key];
+                }
+              }
+            });
+          });
+          function compareExceptionKey(actual, expected, key, message2, keys, fn) {
+            if (!(key in actual) || !isDeepStrictEqual(actual[key], expected[key])) {
+              if (!message2) {
+                var a2 = new Comparison(actual, keys);
+                var b2 = new Comparison(expected, keys, actual);
+                var err = new AssertionError({
+                  actual: a2,
+                  expected: b2,
+                  operator: "deepStrictEqual",
+                  stackStartFn: fn
+                });
+                err.actual = actual;
+                err.expected = expected;
+                err.operator = fn.name;
+                throw err;
+              }
+              innerFail({
+                actual,
+                expected,
+                message: message2,
+                operator: fn.name,
+                stackStartFn: fn
+              });
+            }
+          }
+          function expectedException(actual, expected, msg, fn) {
+            if (typeof expected !== "function") {
+              if (isRegExp(expected)) return RegExpPrototypeTest(expected, actual);
+              if (arguments.length === 2) {
+                throw new ERR_INVALID_ARG_TYPE("expected", ["Function", "RegExp"], expected);
+              }
+              if (_typeof(actual) !== "object" || actual === null) {
+                var err = new AssertionError({
+                  actual,
+                  expected,
+                  message: msg,
+                  operator: "deepStrictEqual",
+                  stackStartFn: fn
+                });
+                err.operator = fn.name;
+                throw err;
+              }
+              var keys = Object.keys(expected);
+              if (expected instanceof Error) {
+                keys.push("name", "message");
+              } else if (keys.length === 0) {
+                throw new ERR_INVALID_ARG_VALUE("error", expected, "may not be an empty object");
+              }
+              if (isDeepEqual === void 0) lazyLoadComparison();
+              keys.forEach(function(key) {
+                if (typeof actual[key] === "string" && isRegExp(expected[key]) && RegExpPrototypeTest(expected[key], actual[key])) {
+                  return;
+                }
+                compareExceptionKey(actual, expected, key, msg, keys, fn);
+              });
+              return true;
+            }
+            if (expected.prototype !== void 0 && actual instanceof expected) {
+              return true;
+            }
+            if (Error.isPrototypeOf(expected)) {
+              return false;
+            }
+            return expected.call({}, actual) === true;
+          }
+          function getActual(fn) {
+            if (typeof fn !== "function") {
+              throw new ERR_INVALID_ARG_TYPE("fn", "Function", fn);
+            }
+            try {
+              fn();
+            } catch (e2) {
+              return e2;
+            }
+            return NO_EXCEPTION_SENTINEL;
+          }
+          function checkIsPromise(obj) {
+            return isPromise2(obj) || obj !== null && _typeof(obj) === "object" && typeof obj.then === "function" && typeof obj.catch === "function";
+          }
+          function waitForActual(promiseFn) {
+            return Promise.resolve().then(function() {
+              var resultPromise;
+              if (typeof promiseFn === "function") {
+                resultPromise = promiseFn();
+                if (!checkIsPromise(resultPromise)) {
+                  throw new ERR_INVALID_RETURN_VALUE("instance of Promise", "promiseFn", resultPromise);
+                }
+              } else if (checkIsPromise(promiseFn)) {
+                resultPromise = promiseFn;
+              } else {
+                throw new ERR_INVALID_ARG_TYPE("promiseFn", ["Function", "Promise"], promiseFn);
+              }
+              return Promise.resolve().then(function() {
+                return resultPromise;
+              }).then(function() {
+                return NO_EXCEPTION_SENTINEL;
+              }).catch(function(e2) {
+                return e2;
+              });
+            });
+          }
+          function expectsError(stackStartFn, actual, error, message2) {
+            if (typeof error === "string") {
+              if (arguments.length === 4) {
+                throw new ERR_INVALID_ARG_TYPE("error", ["Object", "Error", "Function", "RegExp"], error);
+              }
+              if (_typeof(actual) === "object" && actual !== null) {
+                if (actual.message === error) {
+                  throw new ERR_AMBIGUOUS_ARGUMENT("error/message", 'The error message "'.concat(actual.message, '" is identical to the message.'));
+                }
+              } else if (actual === error) {
+                throw new ERR_AMBIGUOUS_ARGUMENT("error/message", 'The error "'.concat(actual, '" is identical to the message.'));
+              }
+              message2 = error;
+              error = void 0;
+            } else if (error != null && _typeof(error) !== "object" && typeof error !== "function") {
+              throw new ERR_INVALID_ARG_TYPE("error", ["Object", "Error", "Function", "RegExp"], error);
+            }
+            if (actual === NO_EXCEPTION_SENTINEL) {
+              var details = "";
+              if (error && error.name) {
+                details += " (".concat(error.name, ")");
+              }
+              details += message2 ? ": ".concat(message2) : ".";
+              var fnType = stackStartFn.name === "rejects" ? "rejection" : "exception";
+              innerFail({
+                actual: void 0,
+                expected: error,
+                operator: stackStartFn.name,
+                message: "Missing expected ".concat(fnType).concat(details),
+                stackStartFn
+              });
+            }
+            if (error && !expectedException(actual, error, message2, stackStartFn)) {
+              throw actual;
+            }
+          }
+          function expectsNoError(stackStartFn, actual, error, message2) {
+            if (actual === NO_EXCEPTION_SENTINEL) return;
+            if (typeof error === "string") {
+              message2 = error;
+              error = void 0;
+            }
+            if (!error || expectedException(actual, error)) {
+              var details = message2 ? ": ".concat(message2) : ".";
+              var fnType = stackStartFn.name === "doesNotReject" ? "rejection" : "exception";
+              innerFail({
+                actual,
+                expected: error,
+                operator: stackStartFn.name,
+                message: "Got unwanted ".concat(fnType).concat(details, "\n") + 'Actual message: "'.concat(actual && actual.message, '"'),
+                stackStartFn
+              });
+            }
+            throw actual;
+          }
+          assert2.throws = function throws(promiseFn) {
+            for (var _len2 = arguments.length, args = new Array(_len2 > 1 ? _len2 - 1 : 0), _key2 = 1; _key2 < _len2; _key2++) {
+              args[_key2 - 1] = arguments[_key2];
+            }
+            expectsError.apply(void 0, [throws, getActual(promiseFn)].concat(args));
+          };
+          assert2.rejects = function rejects(promiseFn) {
+            for (var _len3 = arguments.length, args = new Array(_len3 > 1 ? _len3 - 1 : 0), _key3 = 1; _key3 < _len3; _key3++) {
+              args[_key3 - 1] = arguments[_key3];
+            }
+            return waitForActual(promiseFn).then(function(result) {
+              return expectsError.apply(void 0, [rejects, result].concat(args));
+            });
+          };
+          assert2.doesNotThrow = function doesNotThrow(fn) {
+            for (var _len4 = arguments.length, args = new Array(_len4 > 1 ? _len4 - 1 : 0), _key4 = 1; _key4 < _len4; _key4++) {
+              args[_key4 - 1] = arguments[_key4];
+            }
+            expectsNoError.apply(void 0, [doesNotThrow, getActual(fn)].concat(args));
+          };
+          assert2.doesNotReject = function doesNotReject(fn) {
+            for (var _len5 = arguments.length, args = new Array(_len5 > 1 ? _len5 - 1 : 0), _key5 = 1; _key5 < _len5; _key5++) {
+              args[_key5 - 1] = arguments[_key5];
+            }
+            return waitForActual(fn).then(function(result) {
+              return expectsNoError.apply(void 0, [doesNotReject, result].concat(args));
+            });
+          };
+          assert2.ifError = function ifError(err) {
+            if (err !== null && err !== void 0) {
+              var message2 = "ifError got unwanted exception: ";
+              if (_typeof(err) === "object" && typeof err.message === "string") {
+                if (err.message.length === 0 && err.constructor) {
+                  message2 += err.constructor.name;
+                } else {
+                  message2 += err.message;
+                }
+              } else {
+                message2 += inspect(err);
+              }
+              var newErr = new AssertionError({
+                actual: err,
+                expected: null,
+                operator: "ifError",
+                message: message2,
+                stackStartFn: ifError
+              });
+              var origStack = err.stack;
+              if (typeof origStack === "string") {
+                var tmp2 = origStack.split("\n");
+                tmp2.shift();
+                var tmp1 = newErr.stack.split("\n");
+                for (var i2 = 0; i2 < tmp2.length; i2++) {
+                  var pos = tmp1.indexOf(tmp2[i2]);
+                  if (pos !== -1) {
+                    tmp1 = tmp1.slice(0, pos);
+                    break;
+                  }
+                }
+                newErr.stack = "".concat(tmp1.join("\n"), "\n").concat(tmp2.join("\n"));
+              }
+              throw newErr;
+            }
+          };
+          function internalMatch(string, regexp, message2, fn, fnName) {
+            if (!isRegExp(regexp)) {
+              throw new ERR_INVALID_ARG_TYPE("regexp", "RegExp", regexp);
+            }
+            var match = fnName === "match";
+            if (typeof string !== "string" || RegExpPrototypeTest(regexp, string) !== match) {
+              if (message2 instanceof Error) {
+                throw message2;
+              }
+              var generatedMessage = !message2;
+              message2 = message2 || (typeof string !== "string" ? 'The "string" argument must be of type string. Received type ' + "".concat(_typeof(string), " (").concat(inspect(string), ")") : (match ? "The input did not match the regular expression " : "The input was expected to not match the regular expression ") + "".concat(inspect(regexp), ". Input:\n\n").concat(inspect(string), "\n"));
+              var err = new AssertionError({
+                actual: string,
+                expected: regexp,
+                message: message2,
+                operator: fnName,
+                stackStartFn: fn
+              });
+              err.generatedMessage = generatedMessage;
+              throw err;
+            }
+          }
+          assert2.match = function match(string, regexp, message2) {
+            internalMatch(string, regexp, message2, match, "match");
+          };
+          assert2.doesNotMatch = function doesNotMatch(string, regexp, message2) {
+            internalMatch(string, regexp, message2, doesNotMatch, "doesNotMatch");
+          };
+          function strict() {
+            for (var _len6 = arguments.length, args = new Array(_len6), _key6 = 0; _key6 < _len6; _key6++) {
+              args[_key6] = arguments[_key6];
+            }
+            innerOk.apply(void 0, [strict, args.length].concat(args));
+          }
+          assert2.strict = objectAssign(strict, assert2, {
+            equal: assert2.strictEqual,
+            deepEqual: assert2.deepStrictEqual,
+            notEqual: assert2.notStrictEqual,
+            notDeepEqual: assert2.notDeepStrictEqual
+          });
+          assert2.strict.strict = assert2.strict;
+        }
+      });
+      var require_ms = __commonJS({
+        "node_modules/stream-parser/node_modules/ms/index.js"(exports, module2) {
+          var s2 = 1e3;
+          var m2 = s2 * 60;
+          var h2 = m2 * 60;
+          var d2 = h2 * 24;
+          var y2 = d2 * 365.25;
+          module2.exports = function(val, options) {
+            options = options || {};
+            var type = typeof val;
+            if (type === "string" && val.length > 0) {
+              return parse22(val);
+            } else if (type === "number" && isNaN(val) === false) {
+              return options.long ? fmtLong(val) : fmtShort(val);
+            }
+            throw new Error(
+              "val is not a non-empty string or a valid number. val=" + JSON.stringify(val)
+            );
+          };
+          function parse22(str) {
+            str = String(str);
+            if (str.length > 100) {
+              return;
+            }
+            var match = /^((?:\d+)?\.?\d+) *(milliseconds?|msecs?|ms|seconds?|secs?|s|minutes?|mins?|m|hours?|hrs?|h|days?|d|years?|yrs?|y)?$/i.exec(
+              str
+            );
+            if (!match) {
+              return;
+            }
+            var n2 = parseFloat(match[1]);
+            var type = (match[2] || "ms").toLowerCase();
+            switch (type) {
+              case "years":
+              case "year":
+              case "yrs":
+              case "yr":
+              case "y":
+                return n2 * y2;
+              case "days":
+              case "day":
+              case "d":
+                return n2 * d2;
+              case "hours":
+              case "hour":
+              case "hrs":
+              case "hr":
+              case "h":
+                return n2 * h2;
+              case "minutes":
+              case "minute":
+              case "mins":
+              case "min":
+              case "m":
+                return n2 * m2;
+              case "seconds":
+              case "second":
+              case "secs":
+              case "sec":
+              case "s":
+                return n2 * s2;
+              case "milliseconds":
+              case "millisecond":
+              case "msecs":
+              case "msec":
+              case "ms":
+                return n2;
+              default:
+                return void 0;
+            }
+          }
+          function fmtShort(ms) {
+            if (ms >= d2) {
+              return Math.round(ms / d2) + "d";
+            }
+            if (ms >= h2) {
+              return Math.round(ms / h2) + "h";
+            }
+            if (ms >= m2) {
+              return Math.round(ms / m2) + "m";
+            }
+            if (ms >= s2) {
+              return Math.round(ms / s2) + "s";
+            }
+            return ms + "ms";
+          }
+          function fmtLong(ms) {
+            return plural(ms, d2, "day") || plural(ms, h2, "hour") || plural(ms, m2, "minute") || plural(ms, s2, "second") || ms + " ms";
+          }
+          function plural(ms, n2, name2) {
+            if (ms < n2) {
+              return;
+            }
+            if (ms < n2 * 1.5) {
+              return Math.floor(ms / n2) + " " + name2;
+            }
+            return Math.ceil(ms / n2) + " " + name2 + "s";
+          }
+        }
+      });
+      var require_debug = __commonJS({
+        "node_modules/stream-parser/node_modules/debug/src/debug.js"(exports, module2) {
+          exports = module2.exports = createDebug.debug = createDebug["default"] = createDebug;
+          exports.coerce = coerce;
+          exports.disable = disable;
+          exports.enable = enable2;
+          exports.enabled = enabled;
+          exports.humanize = require_ms();
+          exports.names = [];
+          exports.skips = [];
+          exports.formatters = {};
+          var prevTime;
+          function selectColor(namespace) {
+            var hash = 0, i2;
+            for (i2 in namespace) {
+              hash = (hash << 5) - hash + namespace.charCodeAt(i2);
+              hash |= 0;
+            }
+            return exports.colors[Math.abs(hash) % exports.colors.length];
+          }
+          function createDebug(namespace) {
+            function debug2() {
+              if (!debug2.enabled) return;
+              var self2 = debug2;
+              var curr = +/* @__PURE__ */ new Date();
+              var ms = curr - (prevTime || curr);
+              self2.diff = ms;
+              self2.prev = prevTime;
+              self2.curr = curr;
+              prevTime = curr;
+              var args = new Array(arguments.length);
+              for (var i2 = 0; i2 < args.length; i2++) {
+                args[i2] = arguments[i2];
+              }
+              args[0] = exports.coerce(args[0]);
+              if ("string" !== typeof args[0]) {
+                args.unshift("%O");
+              }
+              var index = 0;
+              args[0] = args[0].replace(/%([a-zA-Z%])/g, function(match, format) {
+                if (match === "%%") return match;
+                index++;
+                var formatter = exports.formatters[format];
+                if ("function" === typeof formatter) {
+                  var val = args[index];
+                  match = formatter.call(self2, val);
+                  args.splice(index, 1);
+                  index--;
+                }
+                return match;
+              });
+              exports.formatArgs.call(self2, args);
+              var logFn = debug2.log || exports.log || console.log.bind(console);
+              logFn.apply(self2, args);
+            }
+            debug2.namespace = namespace;
+            debug2.enabled = exports.enabled(namespace);
+            debug2.useColors = exports.useColors();
+            debug2.color = selectColor(namespace);
+            if ("function" === typeof exports.init) {
+              exports.init(debug2);
+            }
+            return debug2;
+          }
+          function enable2(namespaces) {
+            exports.save(namespaces);
+            exports.names = [];
+            exports.skips = [];
+            var split = (typeof namespaces === "string" ? namespaces : "").split(/[\s,]+/);
+            var len2 = split.length;
+            for (var i2 = 0; i2 < len2; i2++) {
+              if (!split[i2]) continue;
+              namespaces = split[i2].replace(/\*/g, ".*?");
+              if (namespaces[0] === "-") {
+                exports.skips.push(new RegExp("^" + namespaces.substr(1) + "$"));
+              } else {
+                exports.names.push(new RegExp("^" + namespaces + "$"));
+              }
+            }
+          }
+          function disable() {
+            exports.enable("");
+          }
+          function enabled(name2) {
+            var i2, len2;
+            for (i2 = 0, len2 = exports.skips.length; i2 < len2; i2++) {
+              if (exports.skips[i2].test(name2)) {
+                return false;
+              }
+            }
+            for (i2 = 0, len2 = exports.names.length; i2 < len2; i2++) {
+              if (exports.names[i2].test(name2)) {
+                return true;
+              }
+            }
+            return false;
+          }
+          function coerce(val) {
+            if (val instanceof Error) return val.stack || val.message;
+            return val;
+          }
+        }
+      });
+      var require_browser2 = __commonJS({
+        "node_modules/stream-parser/node_modules/debug/src/browser.js"(exports, module2) {
+          exports = module2.exports = require_debug();
+          exports.log = log3;
+          exports.formatArgs = formatArgs;
+          exports.save = save;
+          exports.load = load2;
+          exports.useColors = useColors;
+          exports.storage = "undefined" != typeof chrome && "undefined" != typeof chrome.storage ? chrome.storage.local : localstorage();
+          exports.colors = [
+            "lightseagreen",
+            "forestgreen",
+            "goldenrod",
+            "dodgerblue",
+            "darkorchid",
+            "crimson"
+          ];
+          function useColors() {
+            if (typeof window !== "undefined" && window.process && window.process.type === "renderer") {
+              return true;
+            }
+            return typeof document !== "undefined" && document.documentElement && document.documentElement.style && document.documentElement.style.WebkitAppearance || // is firebug? http://stackoverflow.com/a/398120/376773
+            typeof window !== "undefined" && window.console && (window.console.firebug || window.console.exception && window.console.table) || // is firefox >= v31?
+            // https://developer.mozilla.org/en-US/docs/Tools/Web_Console#Styling_messages
+            typeof navigator !== "undefined" && navigator.userAgent && navigator.userAgent.toLowerCase().match(/firefox\/(\d+)/) && parseInt(RegExp.$1, 10) >= 31 || // double check webkit in userAgent just in case we are in a worker
+            typeof navigator !== "undefined" && navigator.userAgent && navigator.userAgent.toLowerCase().match(/applewebkit\/(\d+)/);
+          }
+          exports.formatters.j = function(v2) {
+            try {
+              return JSON.stringify(v2);
+            } catch (err) {
+              return "[UnexpectedJSONParseError]: " + err.message;
+            }
+          };
+          function formatArgs(args) {
+            var useColors2 = this.useColors;
+            args[0] = (useColors2 ? "%c" : "") + this.namespace + (useColors2 ? " %c" : " ") + args[0] + (useColors2 ? "%c " : " ") + "+" + exports.humanize(this.diff);
+            if (!useColors2) return;
+            var c2 = "color: " + this.color;
+            args.splice(1, 0, c2, "color: inherit");
+            var index = 0;
+            var lastC = 0;
+            args[0].replace(/%[a-zA-Z%]/g, function(match) {
+              if ("%%" === match) return;
+              index++;
+              if ("%c" === match) {
+                lastC = index;
+              }
+            });
+            args.splice(lastC, 0, c2);
+          }
+          function log3() {
+            return "object" === typeof console && console.log && Function.prototype.apply.call(console.log, console, arguments);
+          }
+          function save(namespaces) {
+            try {
+              if (null == namespaces) {
+                exports.storage.removeItem("debug");
+              } else {
+                exports.storage.debug = namespaces;
+              }
+            } catch (e2) {
+            }
+          }
+          function load2() {
+            var r2;
+            try {
+              r2 = exports.storage.debug;
+            } catch (e2) {
+            }
+            if (!r2 && typeof process !== "undefined" && "env" in process) {
+              r2 = define_process_env_default.DEBUG;
+            }
+            return r2;
+          }
+          exports.enable(load2());
+          function localstorage() {
+            try {
+              return window.localStorage;
+            } catch (e2) {
+            }
+          }
+        }
+      });
+      var require_stream_parser = __commonJS({
+        "node_modules/stream-parser/index.js"(exports, module2) {
+          var assert2 = require_assert();
+          var debug2 = require_browser2()("stream-parser");
+          module2.exports = Parser;
+          var INIT = -1;
+          var BUFFERING = 0;
+          var SKIPPING = 1;
+          var PASSTHROUGH = 2;
+          function Parser(stream) {
+            var isTransform = stream && "function" == typeof stream._transform;
+            var isWritable = stream && "function" == typeof stream._write;
+            if (!isTransform && !isWritable) throw new Error("must pass a Writable or Transform stream in");
+            debug2("extending Parser into stream");
+            stream._bytes = _bytes;
+            stream._skipBytes = _skipBytes;
+            if (isTransform) stream._passthrough = _passthrough;
+            if (isTransform) {
+              stream._transform = transform;
+            } else {
+              stream._write = write;
+            }
+          }
+          function init(stream) {
+            debug2("initializing parser stream");
+            stream._parserBytesLeft = 0;
+            stream._parserBuffers = [];
+            stream._parserBuffered = 0;
+            stream._parserState = INIT;
+            stream._parserCallback = null;
+            if ("function" == typeof stream.push) {
+              stream._parserOutput = stream.push.bind(stream);
+            }
+            stream._parserInit = true;
+          }
+          function _bytes(n2, fn) {
+            assert2(!this._parserCallback, 'there is already a "callback" set!');
+            assert2(isFinite(n2) && n2 > 0, 'can only buffer a finite number of bytes > 0, got "' + n2 + '"');
+            if (!this._parserInit) init(this);
+            debug2("buffering %o bytes", n2);
+            this._parserBytesLeft = n2;
+            this._parserCallback = fn;
+            this._parserState = BUFFERING;
+          }
+          function _skipBytes(n2, fn) {
+            assert2(!this._parserCallback, 'there is already a "callback" set!');
+            assert2(n2 > 0, 'can only skip > 0 bytes, got "' + n2 + '"');
+            if (!this._parserInit) init(this);
+            debug2("skipping %o bytes", n2);
+            this._parserBytesLeft = n2;
+            this._parserCallback = fn;
+            this._parserState = SKIPPING;
+          }
+          function _passthrough(n2, fn) {
+            assert2(!this._parserCallback, 'There is already a "callback" set!');
+            assert2(n2 > 0, 'can only pass through > 0 bytes, got "' + n2 + '"');
+            if (!this._parserInit) init(this);
+            debug2("passing through %o bytes", n2);
+            this._parserBytesLeft = n2;
+            this._parserCallback = fn;
+            this._parserState = PASSTHROUGH;
+          }
+          function write(chunk, encoding, fn) {
+            if (!this._parserInit) init(this);
+            debug2("write(%o bytes)", chunk.length);
+            if ("function" == typeof encoding) fn = encoding;
+            data(this, chunk, null, fn);
+          }
+          function transform(chunk, output, fn) {
+            if (!this._parserInit) init(this);
+            debug2("transform(%o bytes)", chunk.length);
+            if ("function" != typeof output) {
+              output = this._parserOutput;
+            }
+            data(this, chunk, output, fn);
+          }
+          function _data(stream, chunk, output, fn) {
+            if (stream._parserBytesLeft <= 0) {
+              return fn(new Error("got data but not currently parsing anything"));
+            }
+            if (chunk.length <= stream._parserBytesLeft) {
+              return function() {
+                return process2(stream, chunk, output, fn);
+              };
+            } else {
+              return function() {
+                var b2 = chunk.slice(0, stream._parserBytesLeft);
+                return process2(stream, b2, output, function(err) {
+                  if (err) return fn(err);
+                  if (chunk.length > b2.length) {
+                    return function() {
+                      return _data(stream, chunk.slice(b2.length), output, fn);
+                    };
+                  }
+                });
+              };
+            }
+          }
+          function process2(stream, chunk, output, fn) {
+            stream._parserBytesLeft -= chunk.length;
+            debug2("%o bytes left for stream piece", stream._parserBytesLeft);
+            if (stream._parserState === BUFFERING) {
+              stream._parserBuffers.push(chunk);
+              stream._parserBuffered += chunk.length;
+            } else if (stream._parserState === PASSTHROUGH) {
+              output(chunk);
+            }
+            if (0 === stream._parserBytesLeft) {
+              var cb2 = stream._parserCallback;
+              if (cb2 && stream._parserState === BUFFERING && stream._parserBuffers.length > 1) {
+                chunk = Buffer.concat(stream._parserBuffers, stream._parserBuffered);
+              }
+              if (stream._parserState !== BUFFERING) {
+                chunk = null;
+              }
+              stream._parserCallback = null;
+              stream._parserBuffered = 0;
+              stream._parserState = INIT;
+              stream._parserBuffers.splice(0);
+              if (cb2) {
+                var args = [];
+                if (chunk) {
+                  args.push(chunk);
+                }
+                if (output) {
+                  args.push(output);
+                }
+                var async = cb2.length > args.length;
+                if (async) {
+                  args.push(trampoline(fn));
+                }
+                var rtn = cb2.apply(stream, args);
+                if (!async || fn === rtn) return fn;
+              }
+            } else {
+              return fn;
+            }
+          }
+          var data = trampoline(_data);
+          function trampoline(fn) {
+            return function() {
+              var result = fn.apply(this, arguments);
+              while ("function" == typeof result) {
+                result = result();
+              }
+              return result;
+            };
+          }
+        }
+      });
+      var require_common = __commonJS({
+        "node_modules/probe-image-size/lib/common.js"(exports) {
+          var Transform = require_stream_browserify().Transform;
+          var streamParser = require_stream_parser();
+          function ParserStream() {
+            Transform.call(this, { readableObjectMode: true });
+          }
+          ParserStream.prototype = Object.create(Transform.prototype);
+          ParserStream.prototype.constructor = ParserStream;
+          streamParser(ParserStream.prototype);
+          exports.ParserStream = ParserStream;
+          exports.sliceEq = function(src, start, dest) {
+            for (var i2 = start, j2 = 0; j2 < dest.length; ) {
+              if (src[i2++] !== dest[j2++]) return false;
+            }
+            return true;
+          };
+          exports.str2arr = function(str, format) {
+            var arr = [], i2 = 0;
+            if (format && format === "hex") {
+              while (i2 < str.length) {
+                arr.push(parseInt(str.slice(i2, i2 + 2), 16));
+                i2 += 2;
+              }
+            } else {
+              for (; i2 < str.length; i2++) {
+                arr.push(str.charCodeAt(i2) & 255);
+              }
+            }
+            return arr;
+          };
+          exports.readUInt16LE = function(data, offset) {
+            return data[offset] | data[offset + 1] << 8;
+          };
+          exports.readUInt16BE = function(data, offset) {
+            return data[offset + 1] | data[offset] << 8;
+          };
+          exports.readUInt32LE = function(data, offset) {
+            return data[offset] | data[offset + 1] << 8 | data[offset + 2] << 16 | data[offset + 3] * 16777216;
+          };
+          exports.readUInt32BE = function(data, offset) {
+            return data[offset + 3] | data[offset + 2] << 8 | data[offset + 1] << 16 | data[offset] * 16777216;
+          };
+          function ProbeError(message2, code, statusCode) {
+            Error.call(this);
+            if (Error.captureStackTrace) {
+              Error.captureStackTrace(this, this.constructor);
+            } else {
+              this.stack = new Error().stack || "";
+            }
+            this.name = this.constructor.name;
+            this.message = message2;
+            if (code) this.code = code;
+            if (statusCode) this.statusCode = statusCode;
+          }
+          ProbeError.prototype = Object.create(Error.prototype);
+          ProbeError.prototype.constructor = ProbeError;
+          exports.ProbeError = ProbeError;
+        }
+      });
+      var require_miaf_utils = __commonJS({
+        "node_modules/probe-image-size/lib/miaf_utils.js"(exports, module2) {
+          var readUInt16BE = require_common().readUInt16BE;
+          var readUInt32BE = require_common().readUInt32BE;
+          function unbox(data, offset) {
+            if (data.length < 4 + offset) return null;
+            var size = readUInt32BE(data, offset);
+            if (data.length < size + offset || size < 8) return null;
+            return {
+              boxtype: String.fromCharCode.apply(null, data.slice(offset + 4, offset + 8)),
+              data: data.slice(offset + 8, offset + size),
+              end: offset + size
+            };
+          }
+          module2.exports.unbox = unbox;
+          function scan_ipco(data, sandbox) {
+            var offset = 0;
+            for (; ; ) {
+              var box = unbox(data, offset);
+              if (!box) break;
+              switch (box.boxtype) {
+                case "ispe":
+                  sandbox.sizes.push({
+                    width: readUInt32BE(box.data, 4),
+                    height: readUInt32BE(box.data, 8)
+                  });
+                  break;
+                case "irot":
+                  sandbox.transforms.push({
+                    type: "irot",
+                    value: box.data[0] & 3
+                  });
+                  break;
+                case "imir":
+                  sandbox.transforms.push({
+                    type: "imir",
+                    value: box.data[0] & 1
+                  });
+                  break;
+              }
+              offset = box.end;
+            }
+          }
+          function readUIntBE(data, offset, size) {
+            var result = 0;
+            for (var i2 = 0; i2 < size; i2++) {
+              result = result * 256 + (data[offset + i2] || 0);
+            }
+            return result;
+          }
+          function scan_iloc(data, sandbox) {
+            var offset_size = data[4] >> 4 & 15;
+            var length_size = data[4] & 15;
+            var base_offset_size = data[5] >> 4 & 15;
+            var item_count = readUInt16BE(data, 6);
+            var offset = 8;
+            for (var i2 = 0; i2 < item_count; i2++) {
+              var item_ID = readUInt16BE(data, offset);
+              offset += 2;
+              var data_reference_index = readUInt16BE(data, offset);
+              offset += 2;
+              var base_offset = readUIntBE(data, offset, base_offset_size);
+              offset += base_offset_size;
+              var extent_count = readUInt16BE(data, offset);
+              offset += 2;
+              if (data_reference_index === 0 && extent_count === 1) {
+                var first_extent_offset = readUIntBE(data, offset, offset_size);
+                var first_extent_length = readUIntBE(data, offset + offset_size, length_size);
+                sandbox.item_loc[item_ID] = { length: first_extent_length, offset: first_extent_offset + base_offset };
+              }
+              offset += extent_count * (offset_size + length_size);
+            }
+          }
+          function scan_iinf(data, sandbox) {
+            var item_count = readUInt16BE(data, 4);
+            var offset = 6;
+            for (var i2 = 0; i2 < item_count; i2++) {
+              var box = unbox(data, offset);
+              if (!box) break;
+              if (box.boxtype === "infe") {
+                var item_id = readUInt16BE(box.data, 4);
+                var item_name = "";
+                for (var pos = 8; pos < box.data.length && box.data[pos]; pos++) {
+                  item_name += String.fromCharCode(box.data[pos]);
+                }
+                sandbox.item_inf[item_name] = item_id;
+              }
+              offset = box.end;
+            }
+          }
+          function scan_iprp(data, sandbox) {
+            var offset = 0;
+            for (; ; ) {
+              var box = unbox(data, offset);
+              if (!box) break;
+              if (box.boxtype === "ipco") scan_ipco(box.data, sandbox);
+              offset = box.end;
+            }
+          }
+          function scan_meta(data, sandbox) {
+            var offset = 4;
+            for (; ; ) {
+              var box = unbox(data, offset);
+              if (!box) break;
+              if (box.boxtype === "iprp") scan_iprp(box.data, sandbox);
+              if (box.boxtype === "iloc") scan_iloc(box.data, sandbox);
+              if (box.boxtype === "iinf") scan_iinf(box.data, sandbox);
+              offset = box.end;
+            }
+          }
+          function getMaxSize(sizes) {
+            var maxWidthSize = sizes.reduce(function(a2, b2) {
+              return a2.width > b2.width || a2.width === b2.width && a2.height > b2.height ? a2 : b2;
+            });
+            var maxHeightSize = sizes.reduce(function(a2, b2) {
+              return a2.height > b2.height || a2.height === b2.height && a2.width > b2.width ? a2 : b2;
+            });
+            var maxSize;
+            if (maxWidthSize.width > maxHeightSize.height || maxWidthSize.width === maxHeightSize.height && maxWidthSize.height > maxHeightSize.width) {
+              maxSize = maxWidthSize;
+            } else {
+              maxSize = maxHeightSize;
+            }
+            return maxSize;
+          }
+          module2.exports.readSizeFromMeta = function(data) {
+            var sandbox = {
+              sizes: [],
+              transforms: [],
+              item_inf: {},
+              item_loc: {}
+            };
+            scan_meta(data, sandbox);
+            if (!sandbox.sizes.length) return;
+            var maxSize = getMaxSize(sandbox.sizes);
+            var orientation = 1;
+            sandbox.transforms.forEach(function(transform) {
+              var rotate_ccw = { 1: 6, 2: 5, 3: 8, 4: 7, 5: 4, 6: 3, 7: 2, 8: 1 };
+              var mirror_vert = { 1: 4, 2: 3, 3: 2, 4: 1, 5: 6, 6: 5, 7: 8, 8: 7 };
+              if (transform.type === "imir") {
+                if (transform.value === 0) {
+                  orientation = mirror_vert[orientation];
+                } else {
+                  orientation = mirror_vert[orientation];
+                  orientation = rotate_ccw[orientation];
+                  orientation = rotate_ccw[orientation];
+                }
+              }
+              if (transform.type === "irot") {
+                for (var i2 = 0; i2 < transform.value; i2++) {
+                  orientation = rotate_ccw[orientation];
+                }
+              }
+            });
+            var exif_location = null;
+            if (sandbox.item_inf.Exif) {
+              exif_location = sandbox.item_loc[sandbox.item_inf.Exif];
+            }
+            return {
+              width: maxSize.width,
+              height: maxSize.height,
+              orientation: sandbox.transforms.length ? orientation : null,
+              variants: sandbox.sizes,
+              exif_location
+            };
+          };
+          module2.exports.getMimeType = function(data) {
+            var brand = String.fromCharCode.apply(null, data.slice(0, 4));
+            var compat = {};
+            compat[brand] = true;
+            for (var i2 = 8; i2 < data.length; i2 += 4) {
+              compat[String.fromCharCode.apply(null, data.slice(i2, i2 + 4))] = true;
+            }
+            if (!compat.mif1 && !compat.msf1 && !compat.miaf) return;
+            if (brand === "avif" || brand === "avis" || brand === "avio") {
+              return { type: "avif", mime: "image/avif" };
+            }
+            if (brand === "heic" || brand === "heix") {
+              return { type: "heic", mime: "image/heic" };
+            }
+            if (brand === "hevc" || brand === "hevx") {
+              return { type: "heic", mime: "image/heic-sequence" };
+            }
+            if (compat.avif || compat.avis) {
+              return { type: "avif", mime: "image/avif" };
+            }
+            if (compat.heic || compat.heix || compat.hevc || compat.hevx || compat.heis) {
+              if (compat.msf1) {
+                return { type: "heif", mime: "image/heif-sequence" };
+              }
+              return { type: "heif", mime: "image/heif" };
+            }
+            return { type: "avif", mime: "image/avif" };
+          };
+        }
+      });
+      var require_exif_utils = __commonJS({
+        "node_modules/probe-image-size/lib/exif_utils.js"(exports, module2) {
+          function error(message2, code) {
+            var err = new Error(message2);
+            err.code = code;
+            return err;
+          }
+          function utf8_decode(str) {
+            try {
+              return decodeURIComponent(escape(str));
+            } catch (_2) {
+              return str;
+            }
+          }
+          function ExifParser(jpeg_bin, exif_start, exif_end) {
+            this.input = jpeg_bin.subarray(exif_start, exif_end);
+            this.start = exif_start;
+            var sig = String.fromCharCode.apply(null, this.input.subarray(0, 4));
+            if (sig !== "II*\0" && sig !== "MM\0*") {
+              throw error("invalid TIFF signature", "EBADDATA");
+            }
+            this.big_endian = sig[0] === "M";
+          }
+          ExifParser.prototype.each = function(on_entry) {
+            this.aborted = false;
+            var offset = this.read_uint32(4);
+            this.ifds_to_read = [{
+              id: 0,
+              offset
+            }];
+            while (this.ifds_to_read.length > 0 && !this.aborted) {
+              var i2 = this.ifds_to_read.shift();
+              if (!i2.offset) continue;
+              this.scan_ifd(i2.id, i2.offset, on_entry);
+            }
+          };
+          ExifParser.prototype.read_uint16 = function(offset) {
+            var d2 = this.input;
+            if (offset + 2 > d2.length) throw error("unexpected EOF", "EBADDATA");
+            return this.big_endian ? d2[offset] * 256 + d2[offset + 1] : d2[offset] + d2[offset + 1] * 256;
+          };
+          ExifParser.prototype.read_uint32 = function(offset) {
+            var d2 = this.input;
+            if (offset + 4 > d2.length) throw error("unexpected EOF", "EBADDATA");
+            return this.big_endian ? d2[offset] * 16777216 + d2[offset + 1] * 65536 + d2[offset + 2] * 256 + d2[offset + 3] : d2[offset] + d2[offset + 1] * 256 + d2[offset + 2] * 65536 + d2[offset + 3] * 16777216;
+          };
+          ExifParser.prototype.is_subifd_link = function(ifd, tag) {
+            return ifd === 0 && tag === 34665 || // SubIFD
+            ifd === 0 && tag === 34853 || // GPS Info
+            ifd === 34665 && tag === 40965;
+          };
+          ExifParser.prototype.exif_format_length = function(format) {
+            switch (format) {
+              case 1:
+              case 2:
+              case 6:
+              case 7:
+                return 1;
+              case 3:
+              case 8:
+                return 2;
+              case 4:
+              case 9:
+              case 11:
+                return 4;
+              case 5:
+              case 10:
+              case 12:
+                return 8;
+              default:
+                return 0;
+            }
+          };
+          ExifParser.prototype.exif_format_read = function(format, offset) {
+            var v2;
+            switch (format) {
+              case 1:
+              case 2:
+                v2 = this.input[offset];
+                return v2;
+              case 6:
+                v2 = this.input[offset];
+                return v2 | (v2 & 128) * 33554430;
+              case 3:
+                v2 = this.read_uint16(offset);
+                return v2;
+              case 8:
+                v2 = this.read_uint16(offset);
+                return v2 | (v2 & 32768) * 131070;
+              case 4:
+                v2 = this.read_uint32(offset);
+                return v2;
+              case 9:
+                v2 = this.read_uint32(offset);
+                return v2 | 0;
+              case 5:
+              case 10:
+              case 11:
+              case 12:
+                return null;
+              case 7:
+                return null;
+              default:
+                return null;
+            }
+          };
+          ExifParser.prototype.scan_ifd = function(ifd_no, offset, on_entry) {
+            var entry_count = this.read_uint16(offset);
+            offset += 2;
+            for (var i2 = 0; i2 < entry_count; i2++) {
+              var tag = this.read_uint16(offset);
+              var format = this.read_uint16(offset + 2);
+              var count2 = this.read_uint32(offset + 4);
+              var comp_length = this.exif_format_length(format);
+              var data_length = count2 * comp_length;
+              var data_offset = data_length <= 4 ? offset + 8 : this.read_uint32(offset + 8);
+              var is_subifd_link = false;
+              if (data_offset + data_length > this.input.length) {
+                throw error("unexpected EOF", "EBADDATA");
+              }
+              var value = [];
+              var comp_offset = data_offset;
+              for (var j2 = 0; j2 < count2; j2++, comp_offset += comp_length) {
+                var item = this.exif_format_read(format, comp_offset);
+                if (item === null) {
+                  value = null;
+                  break;
+                }
+                value.push(item);
+              }
+              if (Array.isArray(value) && format === 2) {
+                value = utf8_decode(String.fromCharCode.apply(null, value));
+                if (value && value[value.length - 1] === "\0") value = value.slice(0, -1);
+              }
+              if (this.is_subifd_link(ifd_no, tag)) {
+                if (Array.isArray(value) && Number.isInteger(value[0]) && value[0] > 0) {
+                  this.ifds_to_read.push({
+                    id: tag,
+                    offset: value[0]
+                  });
+                  is_subifd_link = true;
+                }
+              }
+              var entry = {
+                is_big_endian: this.big_endian,
+                ifd: ifd_no,
+                tag,
+                format,
+                count: count2,
+                entry_offset: offset + this.start,
+                data_length,
+                data_offset: data_offset + this.start,
+                value,
+                is_subifd_link
+              };
+              if (on_entry(entry) === false) {
+                this.aborted = true;
+                return;
+              }
+              offset += 12;
+            }
+            if (ifd_no === 0) {
+              this.ifds_to_read.push({
+                id: 1,
+                offset: this.read_uint32(offset)
+              });
+            }
+          };
+          module2.exports.ExifParser = ExifParser;
+          module2.exports.get_orientation = function(data) {
+            var orientation = 0;
+            try {
+              new ExifParser(data, 0, data.length).each(function(entry) {
+                if (entry.ifd === 0 && entry.tag === 274 && Array.isArray(entry.value)) {
+                  orientation = entry.value[0];
+                  return false;
+                }
+              });
+              return orientation;
+            } catch (err) {
+              return -1;
+            }
+          };
+        }
+      });
+      var require_avif = __commonJS({
+        "node_modules/probe-image-size/lib/parse_sync/avif.js"(exports, module2) {
+          var str2arr = require_common().str2arr;
+          var sliceEq = require_common().sliceEq;
+          var readUInt32BE = require_common().readUInt32BE;
+          var miaf = require_miaf_utils();
+          var exif = require_exif_utils();
+          var SIG_FTYP = str2arr("ftyp");
+          module2.exports = function(data) {
+            if (!sliceEq(data, 4, SIG_FTYP)) return;
+            var firstBox = miaf.unbox(data, 0);
+            if (!firstBox) return;
+            var fileType = miaf.getMimeType(firstBox.data);
+            if (!fileType) return;
+            var meta, offset = firstBox.end;
+            for (; ; ) {
+              var box = miaf.unbox(data, offset);
+              if (!box) break;
+              offset = box.end;
+              if (box.boxtype === "mdat") return;
+              if (box.boxtype === "meta") {
+                meta = box.data;
+                break;
+              }
+            }
+            if (!meta) return;
+            var imgSize = miaf.readSizeFromMeta(meta);
+            if (!imgSize) return;
+            var result = {
+              width: imgSize.width,
+              height: imgSize.height,
+              type: fileType.type,
+              mime: fileType.mime,
+              wUnits: "px",
+              hUnits: "px"
+            };
+            if (imgSize.variants.length > 1) {
+              result.variants = imgSize.variants;
+            }
+            if (imgSize.orientation) {
+              result.orientation = imgSize.orientation;
+            }
+            if (imgSize.exif_location && imgSize.exif_location.offset + imgSize.exif_location.length <= data.length) {
+              var sig_offset = readUInt32BE(data, imgSize.exif_location.offset);
+              var exif_data = data.slice(
+                imgSize.exif_location.offset + sig_offset + 4,
+                imgSize.exif_location.offset + imgSize.exif_location.length
+              );
+              var orientation = exif.get_orientation(exif_data);
+              if (orientation > 0) result.orientation = orientation;
+            }
+            return result;
+          };
+        }
+      });
+      var require_bmp = __commonJS({
+        "node_modules/probe-image-size/lib/parse_sync/bmp.js"(exports, module2) {
+          var str2arr = require_common().str2arr;
+          var sliceEq = require_common().sliceEq;
+          var readUInt16LE = require_common().readUInt16LE;
+          var SIG_BM = str2arr("BM");
+          module2.exports = function(data) {
+            if (data.length < 26) return;
+            if (!sliceEq(data, 0, SIG_BM)) return;
+            return {
+              width: readUInt16LE(data, 18),
+              height: readUInt16LE(data, 22),
+              type: "bmp",
+              mime: "image/bmp",
+              wUnits: "px",
+              hUnits: "px"
+            };
+          };
+        }
+      });
+      var require_gif = __commonJS({
+        "node_modules/probe-image-size/lib/parse_sync/gif.js"(exports, module2) {
+          var str2arr = require_common().str2arr;
+          var sliceEq = require_common().sliceEq;
+          var readUInt16LE = require_common().readUInt16LE;
+          var SIG_GIF87a = str2arr("GIF87a");
+          var SIG_GIF89a = str2arr("GIF89a");
+          module2.exports = function(data) {
+            if (data.length < 10) return;
+            if (!sliceEq(data, 0, SIG_GIF87a) && !sliceEq(data, 0, SIG_GIF89a)) return;
+            return {
+              width: readUInt16LE(data, 6),
+              height: readUInt16LE(data, 8),
+              type: "gif",
+              mime: "image/gif",
+              wUnits: "px",
+              hUnits: "px"
+            };
+          };
+        }
+      });
+      var require_ico = __commonJS({
+        "node_modules/probe-image-size/lib/parse_sync/ico.js"(exports, module2) {
+          var readUInt16LE = require_common().readUInt16LE;
+          var HEADER = 0;
+          var TYPE_ICO = 1;
+          var INDEX_SIZE = 16;
+          module2.exports = function(data) {
+            var header = readUInt16LE(data, 0);
+            var type = readUInt16LE(data, 2);
+            var numImages = readUInt16LE(data, 4);
+            if (header !== HEADER || type !== TYPE_ICO || !numImages) {
+              return;
+            }
+            var variants = [];
+            var maxSize = { width: 0, height: 0 };
+            for (var i2 = 0; i2 < numImages; i2++) {
+              var width = data[6 + INDEX_SIZE * i2] || 256;
+              var height = data[6 + INDEX_SIZE * i2 + 1] || 256;
+              var size = { width, height };
+              variants.push(size);
+              if (width > maxSize.width || height > maxSize.height) {
+                maxSize = size;
+              }
+            }
+            return {
+              width: maxSize.width,
+              height: maxSize.height,
+              variants,
+              type: "ico",
+              mime: "image/x-icon",
+              wUnits: "px",
+              hUnits: "px"
+            };
+          };
+        }
+      });
+      var require_jpeg = __commonJS({
+        "node_modules/probe-image-size/lib/parse_sync/jpeg.js"(exports, module2) {
+          var readUInt16BE = require_common().readUInt16BE;
+          var str2arr = require_common().str2arr;
+          var sliceEq = require_common().sliceEq;
+          var exif = require_exif_utils();
+          var SIG_EXIF = str2arr("Exif\0\0");
+          module2.exports = function(data) {
+            if (data.length < 2) return;
+            if (data[0] !== 255 || data[1] !== 216 || data[2] !== 255) return;
+            var offset = 2;
+            for (; ; ) {
+              for (; ; ) {
+                if (data.length - offset < 2) return;
+                if (data[offset++] === 255) break;
+              }
+              var code = data[offset++];
+              var length2;
+              while (code === 255) code = data[offset++];
+              if (208 <= code && code <= 217 || code === 1) {
+                length2 = 0;
+              } else if (192 <= code && code <= 254) {
+                if (data.length - offset < 2) return;
+                length2 = readUInt16BE(data, offset) - 2;
+                offset += 2;
+              } else {
+                return;
+              }
+              if (code === 217 || code === 218) {
+                return;
+              }
+              var orientation;
+              if (code === 225 && length2 >= 10 && sliceEq(data, offset, SIG_EXIF)) {
+                orientation = exif.get_orientation(data.slice(offset + 6, offset + length2));
+              }
+              if (length2 >= 5 && (192 <= code && code <= 207) && code !== 196 && code !== 200 && code !== 204) {
+                if (data.length - offset < length2) return;
+                var result = {
+                  width: readUInt16BE(data, offset + 3),
+                  height: readUInt16BE(data, offset + 1),
+                  type: "jpg",
+                  mime: "image/jpeg",
+                  wUnits: "px",
+                  hUnits: "px"
+                };
+                if (orientation > 0) {
+                  result.orientation = orientation;
+                }
+                return result;
+              }
+              offset += length2;
+            }
+          };
+        }
+      });
+      var require_png = __commonJS({
+        "node_modules/probe-image-size/lib/parse_sync/png.js"(exports, module2) {
+          var str2arr = require_common().str2arr;
+          var sliceEq = require_common().sliceEq;
+          var readUInt32BE = require_common().readUInt32BE;
+          var SIG_PNG = str2arr("‰PNG\r\n\n");
+          var SIG_IHDR = str2arr("IHDR");
+          module2.exports = function(data) {
+            if (data.length < 24) return;
+            if (!sliceEq(data, 0, SIG_PNG)) return;
+            if (!sliceEq(data, 12, SIG_IHDR)) return;
+            return {
+              width: readUInt32BE(data, 16),
+              height: readUInt32BE(data, 20),
+              type: "png",
+              mime: "image/png",
+              wUnits: "px",
+              hUnits: "px"
+            };
+          };
+        }
+      });
+      var require_psd = __commonJS({
+        "node_modules/probe-image-size/lib/parse_sync/psd.js"(exports, module2) {
+          var str2arr = require_common().str2arr;
+          var sliceEq = require_common().sliceEq;
+          var readUInt32BE = require_common().readUInt32BE;
+          var SIG_8BPS = str2arr("8BPS\0
");
+          module2.exports = function(data) {
+            if (data.length < 6 + 16) return;
+            if (!sliceEq(data, 0, SIG_8BPS)) return;
+            return {
+              width: readUInt32BE(data, 6 + 12),
+              height: readUInt32BE(data, 6 + 8),
+              type: "psd",
+              mime: "image/vnd.adobe.photoshop",
+              wUnits: "px",
+              hUnits: "px"
+            };
+          };
+        }
+      });
+      var require_svg = __commonJS({
+        "node_modules/probe-image-size/lib/parse_sync/svg.js"(exports, module2) {
+          function isWhiteSpace(chr) {
+            return chr === 32 || chr === 9 || chr === 13 || chr === 10;
+          }
+          function isFinitePositive(val) {
+            return typeof val === "number" && isFinite(val) && val > 0;
+          }
+          function canBeSvg(buf) {
+            var i2 = 0, max = buf.length;
+            if (buf[0] === 239 && buf[1] === 187 && buf[2] === 191) i2 = 3;
+            while (i2 < max && isWhiteSpace(buf[i2])) i2++;
+            if (i2 === max) return false;
+            return buf[i2] === 60;
+          }
+          var SVG_HEADER_RE = /<[-_.:a-zA-Z0-9][^>]*>/;
+          var SVG_TAG_RE = /^<([-_.:a-zA-Z0-9]+:)?svg\s/;
+          var SVG_WIDTH_RE = /[^-]\bwidth="([^%]+?)"|[^-]\bwidth='([^%]+?)'/;
+          var SVG_HEIGHT_RE = /\bheight="([^%]+?)"|\bheight='([^%]+?)'/;
+          var SVG_VIEWBOX_RE = /\bview[bB]ox="(.+?)"|\bview[bB]ox='(.+?)'/;
+          var SVG_UNITS_RE = /in$|mm$|cm$|pt$|pc$|px$|em$|ex$/;
+          function svgAttrs(str) {
+            var width = str.match(SVG_WIDTH_RE);
+            var height = str.match(SVG_HEIGHT_RE);
+            var viewbox = str.match(SVG_VIEWBOX_RE);
+            return {
+              width: width && (width[1] || width[2]),
+              height: height && (height[1] || height[2]),
+              viewbox: viewbox && (viewbox[1] || viewbox[2])
+            };
+          }
+          function units(str) {
+            if (!SVG_UNITS_RE.test(str)) return "px";
+            return str.match(SVG_UNITS_RE)[0];
+          }
+          module2.exports = function(data) {
+            if (!canBeSvg(data)) return;
+            var str = "";
+            for (var i2 = 0; i2 < data.length; i2++) {
+              str += String.fromCharCode(data[i2]);
+            }
+            var svgTag = (str.match(SVG_HEADER_RE) || [""])[0];
+            if (!SVG_TAG_RE.test(svgTag)) return;
+            var attrs = svgAttrs(svgTag);
+            var width = parseFloat(attrs.width);
+            var height = parseFloat(attrs.height);
+            if (attrs.width && attrs.height) {
+              if (!isFinitePositive(width) || !isFinitePositive(height)) return;
+              return {
+                width,
+                height,
+                type: "svg",
+                mime: "image/svg+xml",
+                wUnits: units(attrs.width),
+                hUnits: units(attrs.height)
+              };
+            }
+            var parts = (attrs.viewbox || "").split(" ");
+            var viewbox = {
+              width: parts[2],
+              height: parts[3]
+            };
+            var vbWidth = parseFloat(viewbox.width);
+            var vbHeight = parseFloat(viewbox.height);
+            if (!isFinitePositive(vbWidth) || !isFinitePositive(vbHeight)) return;
+            if (units(viewbox.width) !== units(viewbox.height)) return;
+            var ratio = vbWidth / vbHeight;
+            if (attrs.width) {
+              if (!isFinitePositive(width)) return;
+              return {
+                width,
+                height: width / ratio,
+                type: "svg",
+                mime: "image/svg+xml",
+                wUnits: units(attrs.width),
+                hUnits: units(attrs.width)
+              };
+            }
+            if (attrs.height) {
+              if (!isFinitePositive(height)) return;
+              return {
+                width: height * ratio,
+                height,
+                type: "svg",
+                mime: "image/svg+xml",
+                wUnits: units(attrs.height),
+                hUnits: units(attrs.height)
+              };
+            }
+            return {
+              width: vbWidth,
+              height: vbHeight,
+              type: "svg",
+              mime: "image/svg+xml",
+              wUnits: units(viewbox.width),
+              hUnits: units(viewbox.height)
+            };
+          };
+        }
+      });
+      var require_tiff = __commonJS({
+        "node_modules/probe-image-size/lib/parse_sync/tiff.js"(exports, module2) {
+          var str2arr = require_common().str2arr;
+          var sliceEq = require_common().sliceEq;
+          var readUInt16LE = require_common().readUInt16LE;
+          var readUInt16BE = require_common().readUInt16BE;
+          var readUInt32LE = require_common().readUInt32LE;
+          var readUInt32BE = require_common().readUInt32BE;
+          var SIG_1 = str2arr("II*\0");
+          var SIG_2 = str2arr("MM\0*");
+          function readUInt16(buffer, offset, is_big_endian) {
+            return is_big_endian ? readUInt16BE(buffer, offset) : readUInt16LE(buffer, offset);
+          }
+          function readUInt32(buffer, offset, is_big_endian) {
+            return is_big_endian ? readUInt32BE(buffer, offset) : readUInt32LE(buffer, offset);
+          }
+          function readIFDValue(data, data_offset, is_big_endian) {
+            var type = readUInt16(data, data_offset + 2, is_big_endian);
+            var values = readUInt32(data, data_offset + 4, is_big_endian);
+            if (values !== 1 || type !== 3 && type !== 4) return null;
+            if (type === 3) {
+              return readUInt16(data, data_offset + 8, is_big_endian);
+            }
+            return readUInt32(data, data_offset + 8, is_big_endian);
+          }
+          module2.exports = function(data) {
+            if (data.length < 8) return;
+            if (!sliceEq(data, 0, SIG_1) && !sliceEq(data, 0, SIG_2)) return;
+            var is_big_endian = data[0] === 77;
+            var count2 = readUInt32(data, 4, is_big_endian) - 8;
+            if (count2 < 0) return;
+            var offset = count2 + 8;
+            if (data.length - offset < 2) return;
+            var ifd_size = readUInt16(data, offset + 0, is_big_endian) * 12;
+            if (ifd_size <= 0) return;
+            offset += 2;
+            if (data.length - offset < ifd_size) return;
+            var i2, width, height, tag;
+            for (i2 = 0; i2 < ifd_size; i2 += 12) {
+              tag = readUInt16(data, offset + i2, is_big_endian);
+              if (tag === 256) {
+                width = readIFDValue(data, offset + i2, is_big_endian);
+              } else if (tag === 257) {
+                height = readIFDValue(data, offset + i2, is_big_endian);
+              }
+            }
+            if (width && height) {
+              return {
+                width,
+                height,
+                type: "tiff",
+                mime: "image/tiff",
+                wUnits: "px",
+                hUnits: "px"
+              };
+            }
+          };
+        }
+      });
+      var require_webp = __commonJS({
+        "node_modules/probe-image-size/lib/parse_sync/webp.js"(exports, module2) {
+          var str2arr = require_common().str2arr;
+          var sliceEq = require_common().sliceEq;
+          var readUInt16LE = require_common().readUInt16LE;
+          var readUInt32LE = require_common().readUInt32LE;
+          var exif = require_exif_utils();
+          var SIG_RIFF = str2arr("RIFF");
+          var SIG_WEBP = str2arr("WEBP");
+          function parseVP8(data, offset) {
+            if (data[offset + 3] !== 157 || data[offset + 4] !== 1 || data[offset + 5] !== 42) {
+              return;
+            }
+            return {
+              width: readUInt16LE(data, offset + 6) & 16383,
+              height: readUInt16LE(data, offset + 8) & 16383,
+              type: "webp",
+              mime: "image/webp",
+              wUnits: "px",
+              hUnits: "px"
+            };
+          }
+          function parseVP8L(data, offset) {
+            if (data[offset] !== 47) return;
+            var bits = readUInt32LE(data, offset + 1);
+            return {
+              width: (bits & 16383) + 1,
+              height: (bits >> 14 & 16383) + 1,
+              type: "webp",
+              mime: "image/webp",
+              wUnits: "px",
+              hUnits: "px"
+            };
+          }
+          function parseVP8X(data, offset) {
+            return {
+              // TODO: replace with `data.readUIntLE(8, 3) + 1`
+              //       when 0.10 support is dropped
+              width: (data[offset + 6] << 16 | data[offset + 5] << 8 | data[offset + 4]) + 1,
+              height: (data[offset + 9] << offset | data[offset + 8] << 8 | data[offset + 7]) + 1,
+              type: "webp",
+              mime: "image/webp",
+              wUnits: "px",
+              hUnits: "px"
+            };
+          }
+          module2.exports = function(data) {
+            if (data.length < 16) return;
+            if (!sliceEq(data, 0, SIG_RIFF) && !sliceEq(data, 8, SIG_WEBP)) return;
+            var offset = 12;
+            var result = null;
+            var exif_orientation = 0;
+            var fileLength = readUInt32LE(data, 4) + 8;
+            if (fileLength > data.length) return;
+            while (offset + 8 < fileLength) {
+              if (data[offset] === 0) {
+                offset++;
+                continue;
+              }
+              var header = String.fromCharCode.apply(null, data.slice(offset, offset + 4));
+              var length2 = readUInt32LE(data, offset + 4);
+              if (header === "VP8 " && length2 >= 10) {
+                result = result || parseVP8(data, offset + 8);
+              } else if (header === "VP8L" && length2 >= 9) {
+                result = result || parseVP8L(data, offset + 8);
+              } else if (header === "VP8X" && length2 >= 10) {
+                result = result || parseVP8X(data, offset + 8);
+              } else if (header === "EXIF") {
+                exif_orientation = exif.get_orientation(data.slice(offset + 8, offset + 8 + length2));
+                offset = Infinity;
+              }
+              offset += 8 + length2;
+            }
+            if (!result) return;
+            if (exif_orientation > 0) {
+              result.orientation = exif_orientation;
+            }
+            return result;
+          };
+        }
+      });
+      var require_parsers_sync = __commonJS({
+        "node_modules/probe-image-size/lib/parsers_sync.js"(exports, module2) {
+          module2.exports = {
+            avif: require_avif(),
+            bmp: require_bmp(),
+            gif: require_gif(),
+            ico: require_ico(),
+            jpeg: require_jpeg(),
+            png: require_png(),
+            psd: require_psd(),
+            svg: require_svg(),
+            tiff: require_tiff(),
+            webp: require_webp()
+          };
+        }
+      });
+      var require_sync = __commonJS({
+        "node_modules/probe-image-size/sync.js"(exports, module2) {
+          var parsers = require_parsers_sync();
+          function probeBuffer(buffer) {
+            var parser_names = Object.keys(parsers);
+            for (var i2 = 0; i2 < parser_names.length; i2++) {
+              var result = parsers[parser_names[i2]](buffer);
+              if (result) return result;
+            }
+            return null;
+          }
+          module2.exports = function get_image_size(src) {
+            return probeBuffer(src);
+          };
+          module2.exports.parsers = parsers;
+        }
+      });
+      var require_helpers14 = __commonJS({
+        "src/traces/image/helpers.js"(exports) {
+          var probeSync = require_sync();
+          var dataUri = require_helpers10().IMAGE_URL_PREFIX;
+          var Buffer22 = require_buffer().Buffer;
+          exports.getImageSize = function(src) {
+            var data = src.replace(dataUri, "");
+            var buff = new Buffer22(data, "base64");
+            return probeSync(buff);
+          };
+        }
+      });
+      var require_calc15 = __commonJS({
+        "src/traces/image/calc.js"(exports, module2) {
+          var Lib = require_lib();
+          var constants = require_constants19();
+          var isNumeric = require_fast_isnumeric();
+          var Axes = require_axes();
+          var maxRowLength = require_lib().maxRowLength;
+          var getImageSize = require_helpers14().getImageSize;
+          module2.exports = function calc(gd2, trace) {
+            var h2;
+            var w2;
+            if (trace._hasZ) {
+              h2 = trace.z.length;
+              w2 = maxRowLength(trace.z);
+            } else if (trace._hasSource) {
+              var size = getImageSize(trace.source);
+              h2 = size.height;
+              w2 = size.width;
+            }
+            var xa = Axes.getFromId(gd2, trace.xaxis || "x");
+            var ya2 = Axes.getFromId(gd2, trace.yaxis || "y");
+            var x0 = xa.d2c(trace.x0) - trace.dx / 2;
+            var y0 = ya2.d2c(trace.y0) - trace.dy / 2;
+            var i2;
+            var xrange = [x0, x0 + w2 * trace.dx];
+            var yrange = [y0, y0 + h2 * trace.dy];
+            if (xa && xa.type === "log") for (i2 = 0; i2 < w2; i2++) xrange.push(x0 + i2 * trace.dx);
+            if (ya2 && ya2.type === "log") for (i2 = 0; i2 < h2; i2++) yrange.push(y0 + i2 * trace.dy);
+            trace._extremes[xa._id] = Axes.findExtremes(xa, xrange);
+            trace._extremes[ya2._id] = Axes.findExtremes(ya2, yrange);
+            trace._scaler = makeScaler(trace);
+            var cd0 = {
+              x0,
+              y0,
+              z: trace.z,
+              w: w2,
+              h: h2
+            };
+            return [cd0];
+          };
+          function scale2(zero2, ratio, min, max) {
+            return function(c2) {
+              return Lib.constrain((c2 - zero2) * ratio, min, max);
+            };
+          }
+          function constrain(min, max) {
+            return function(c2) {
+              return Lib.constrain(c2, min, max);
+            };
+          }
+          function makeScaler(trace) {
+            var cr = constants.colormodel[trace.colormodel];
+            var colormodel = cr.colormodel || trace.colormodel;
+            var n2 = colormodel.length;
+            trace._sArray = [];
+            for (var k2 = 0; k2 < n2; k2++) {
+              if (cr.min[k2] !== trace.zmin[k2] || cr.max[k2] !== trace.zmax[k2]) {
+                trace._sArray.push(scale2(
+                  trace.zmin[k2],
+                  (cr.max[k2] - cr.min[k2]) / (trace.zmax[k2] - trace.zmin[k2]),
+                  cr.min[k2],
+                  cr.max[k2]
+                ));
+              } else {
+                trace._sArray.push(constrain(cr.min[k2], cr.max[k2]));
+              }
+            }
+            return function(pixel) {
+              var c2 = pixel.slice(0, n2);
+              for (var k22 = 0; k22 < n2; k22++) {
+                var ck2 = c2[k22];
+                if (!isNumeric(ck2)) return false;
+                c2[k22] = trace._sArray[k22](ck2);
+              }
+              return c2;
+            };
+          }
+        }
+      });
+      var require_plot11 = __commonJS({
+        "src/traces/image/plot.js"(exports, module2) {
+          var d3 = require_d3();
+          var Lib = require_lib();
+          var strTranslate = Lib.strTranslate;
+          var xmlnsNamespaces = require_xmlns_namespaces();
+          var constants = require_constants19();
+          var supportsPixelatedImage = require_supports_pixelated_image();
+          var PIXELATED_IMAGE_STYLE = require_pixelated_image().STYLE;
+          module2.exports = function plot(gd2, plotinfo, cdimage, imageLayer) {
+            var xa = plotinfo.xaxis;
+            var ya2 = plotinfo.yaxis;
+            var supportsPixelated = !gd2._context._exportedPlot && supportsPixelatedImage();
+            Lib.makeTraceGroups(imageLayer, cdimage, "im").each(function(cd2) {
+              var plotGroup = d3.select(this);
+              var cd0 = cd2[0];
+              var trace = cd0.trace;
+              var realImage = (trace.zsmooth === "fast" || trace.zsmooth === false && supportsPixelated) && !trace._hasZ && trace._hasSource && xa.type === "linear" && ya2.type === "linear";
+              trace._realImage = realImage;
+              var z2 = cd0.z;
+              var x0 = cd0.x0;
+              var y0 = cd0.y0;
+              var w2 = cd0.w;
+              var h2 = cd0.h;
+              var dx = trace.dx;
+              var dy = trace.dy;
+              var left, right, temp, top, bottom, i2;
+              i2 = 0;
+              while (left === void 0 && i2 < w2) {
+                left = xa.c2p(x0 + i2 * dx);
+                i2++;
+              }
+              i2 = w2;
+              while (right === void 0 && i2 > 0) {
+                right = xa.c2p(x0 + i2 * dx);
+                i2--;
+              }
+              i2 = 0;
+              while (top === void 0 && i2 < h2) {
+                top = ya2.c2p(y0 + i2 * dy);
+                i2++;
+              }
+              i2 = h2;
+              while (bottom === void 0 && i2 > 0) {
+                bottom = ya2.c2p(y0 + i2 * dy);
+                i2--;
+              }
+              if (right < left) {
+                temp = right;
+                right = left;
+                left = temp;
+              }
+              if (bottom < top) {
+                temp = top;
+                top = bottom;
+                bottom = temp;
+              }
+              if (!realImage) {
+                var extra = 0.5;
+                left = Math.max(-extra * xa._length, left);
+                right = Math.min((1 + extra) * xa._length, right);
+                top = Math.max(-extra * ya2._length, top);
+                bottom = Math.min((1 + extra) * ya2._length, bottom);
+              }
+              var imageWidth = Math.round(right - left);
+              var imageHeight = Math.round(bottom - top);
+              var isOffScreen = imageWidth <= 0 || imageHeight <= 0;
+              if (isOffScreen) {
+                var noImage = plotGroup.selectAll("image").data([]);
+                noImage.exit().remove();
+                return;
+              }
+              function drawMagnifiedPixelsOnCanvas(readPixel) {
+                var canvas2 = document.createElement("canvas");
+                canvas2.width = imageWidth;
+                canvas2.height = imageHeight;
+                var context = canvas2.getContext("2d", { willReadFrequently: true });
+                var ipx = function(i22) {
+                  return Lib.constrain(Math.round(xa.c2p(x0 + i22 * dx) - left), 0, imageWidth);
+                };
+                var jpx = function(j22) {
+                  return Lib.constrain(Math.round(ya2.c2p(y0 + j22 * dy) - top), 0, imageHeight);
+                };
+                var cr = constants.colormodel[trace.colormodel];
+                var colormodel = cr.colormodel || trace.colormodel;
+                var fmt = cr.fmt;
+                var c2;
+                for (i2 = 0; i2 < cd0.w; i2++) {
+                  var ipx0 = ipx(i2);
+                  var ipx1 = ipx(i2 + 1);
+                  if (ipx1 === ipx0 || isNaN(ipx1) || isNaN(ipx0)) continue;
+                  for (var j2 = 0; j2 < cd0.h; j2++) {
+                    var jpx0 = jpx(j2);
+                    var jpx1 = jpx(j2 + 1);
+                    if (jpx1 === jpx0 || isNaN(jpx1) || isNaN(jpx0) || !readPixel(i2, j2)) continue;
+                    c2 = trace._scaler(readPixel(i2, j2));
+                    if (c2) {
+                      context.fillStyle = colormodel + "(" + fmt(c2).join(",") + ")";
+                    } else {
+                      context.fillStyle = "rgba(0,0,0,0)";
+                    }
+                    context.fillRect(ipx0, jpx0, ipx1 - ipx0, jpx1 - jpx0);
+                  }
+                }
+                return canvas2;
+              }
+              var image3 = plotGroup.selectAll("image").data([cd2]);
+              image3.enter().append("svg:image").attr({
+                xmlns: xmlnsNamespaces.svg,
+                preserveAspectRatio: "none"
+              });
+              image3.exit().remove();
+              var style = trace.zsmooth === false ? PIXELATED_IMAGE_STYLE : "";
+              if (realImage) {
+                var xRange = Lib.simpleMap(xa.range, xa.r2l);
+                var yRange = Lib.simpleMap(ya2.range, ya2.r2l);
+                var flipX = xRange[1] < xRange[0];
+                var flipY = yRange[1] > yRange[0];
+                if (flipX || flipY) {
+                  var tx = left + imageWidth / 2;
+                  var ty = top + imageHeight / 2;
+                  style += "transform:" + strTranslate(tx + "px", ty + "px") + "scale(" + (flipX ? -1 : 1) + "," + (flipY ? -1 : 1) + ")" + strTranslate(-tx + "px", -ty + "px") + ";";
+                }
+              }
+              image3.attr("style", style);
+              var p2 = new Promise(function(resolve) {
+                if (trace._hasZ) {
+                  resolve();
+                } else if (trace._hasSource) {
+                  if (trace._canvas && trace._canvas.el.width === w2 && trace._canvas.el.height === h2 && trace._canvas.source === trace.source) {
+                    resolve();
+                  } else {
+                    var canvas2 = document.createElement("canvas");
+                    canvas2.width = w2;
+                    canvas2.height = h2;
+                    var context = canvas2.getContext("2d", { willReadFrequently: true });
+                    trace._image = trace._image || new Image();
+                    var image = trace._image;
+                    image.onload = function() {
+                      context.drawImage(image, 0, 0);
+                      trace._canvas = {
+                        el: canvas2,
+                        source: trace.source
+                      };
+                      resolve();
+                    };
+                    image.setAttribute("src", trace.source);
+                  }
+                }
+              }).then(function() {
+                var href, canvas2;
+                if (trace._hasZ) {
+                  canvas2 = drawMagnifiedPixelsOnCanvas(function(i22, j2) {
+                    var _z = z2[j2][i22];
+                    if (Lib.isTypedArray(_z)) _z = Array.from(_z);
+                    return _z;
+                  });
+                  href = canvas2.toDataURL("image/png");
+                } else if (trace._hasSource) {
+                  if (realImage) {
+                    href = trace.source;
+                  } else {
+                    var context = trace._canvas.el.getContext("2d", { willReadFrequently: true });
+                    var data = context.getImageData(0, 0, w2, h2).data;
+                    canvas2 = drawMagnifiedPixelsOnCanvas(function(i22, j2) {
+                      var index = 4 * (j2 * w2 + i22);
+                      return [
+                        data[index],
+                        data[index + 1],
+                        data[index + 2],
+                        data[index + 3]
+                      ];
+                    });
+                    href = canvas2.toDataURL("image/png");
+                  }
+                }
+                image3.attr({
+                  "xlink:href": href,
+                  height: imageHeight,
+                  width: imageWidth,
+                  x: left,
+                  y: top
+                });
+              });
+              gd2._promises.push(p2);
+            });
+          };
+        }
+      });
+      var require_style11 = __commonJS({
+        "src/traces/image/style.js"(exports, module2) {
+          var d3 = require_d3();
+          module2.exports = function style(gd2) {
+            d3.select(gd2).selectAll(".im image").style("opacity", function(d2) {
+              return d2[0].trace.opacity;
+            });
+          };
+        }
+      });
+      var require_hover13 = __commonJS({
+        "src/traces/image/hover.js"(exports, module2) {
+          var Fx = require_fx();
+          var Lib = require_lib();
+          var isArrayOrTypedArray = Lib.isArrayOrTypedArray;
+          var constants = require_constants19();
+          module2.exports = function hoverPoints(pointData, xval, yval) {
+            var cd0 = pointData.cd[0];
+            var trace = cd0.trace;
+            var xa = pointData.xa;
+            var ya2 = pointData.ya;
+            if (Fx.inbox(xval - cd0.x0, xval - (cd0.x0 + cd0.w * trace.dx), 0) > 0 || Fx.inbox(yval - cd0.y0, yval - (cd0.y0 + cd0.h * trace.dy), 0) > 0) {
+              return;
+            }
+            var nx = Math.floor((xval - cd0.x0) / trace.dx);
+            var ny = Math.floor(Math.abs(yval - cd0.y0) / trace.dy);
+            var pixel;
+            if (trace._hasZ) {
+              pixel = cd0.z[ny][nx];
+            } else if (trace._hasSource) {
+              pixel = trace._canvas.el.getContext("2d", { willReadFrequently: true }).getImageData(nx, ny, 1, 1).data;
+            }
+            if (!pixel) return;
+            var hoverinfo = cd0.hi || trace.hoverinfo;
+            var fmtColor;
+            if (hoverinfo) {
+              var parts = hoverinfo.split("+");
+              if (parts.indexOf("all") !== -1) parts = ["color"];
+              if (parts.indexOf("color") !== -1) fmtColor = true;
+            }
+            var cr = constants.colormodel[trace.colormodel];
+            var colormodel = cr.colormodel || trace.colormodel;
+            var dims = colormodel.length;
+            var c2 = trace._scaler(pixel);
+            var s2 = cr.suffix;
+            var colorstring = [];
+            if (trace.hovertemplate || fmtColor) {
+              colorstring.push("[" + [c2[0] + s2[0], c2[1] + s2[1], c2[2] + s2[2]].join(", "));
+              if (dims === 4) colorstring.push(", " + c2[3] + s2[3]);
+              colorstring.push("]");
+              colorstring = colorstring.join("");
+              pointData.extraText = colormodel.toUpperCase() + ": " + colorstring;
+            }
+            var text;
+            if (isArrayOrTypedArray(trace.hovertext) && isArrayOrTypedArray(trace.hovertext[ny])) {
+              text = trace.hovertext[ny][nx];
+            } else if (isArrayOrTypedArray(trace.text) && isArrayOrTypedArray(trace.text[ny])) {
+              text = trace.text[ny][nx];
+            }
+            var py = ya2.c2p(cd0.y0 + (ny + 0.5) * trace.dy);
+            var xVal = cd0.x0 + (nx + 0.5) * trace.dx;
+            var yVal = cd0.y0 + (ny + 0.5) * trace.dy;
+            var zLabel = "[" + pixel.slice(0, trace.colormodel.length).join(", ") + "]";
+            return [Lib.extendFlat(pointData, {
+              index: [ny, nx],
+              x0: xa.c2p(cd0.x0 + nx * trace.dx),
+              x1: xa.c2p(cd0.x0 + (nx + 1) * trace.dx),
+              y0: py,
+              y1: py,
+              color: c2,
+              xVal,
+              xLabelVal: xVal,
+              yVal,
+              yLabelVal: yVal,
+              zLabelVal: zLabel,
+              text,
+              hovertemplateLabels: {
+                zLabel,
+                colorLabel: colorstring,
+                "color[0]Label": c2[0] + s2[0],
+                "color[1]Label": c2[1] + s2[1],
+                "color[2]Label": c2[2] + s2[2],
+                "color[3]Label": c2[3] + s2[3]
+              }
+            })];
+          };
+        }
+      });
+      var require_event_data7 = __commonJS({
+        "src/traces/image/event_data.js"(exports, module2) {
+          module2.exports = function eventData(out, pt2) {
+            if ("xVal" in pt2) out.x = pt2.xVal;
+            if ("yVal" in pt2) out.y = pt2.yVal;
+            if (pt2.xa) out.xaxis = pt2.xa;
+            if (pt2.ya) out.yaxis = pt2.ya;
+            out.color = pt2.color;
+            out.colormodel = pt2.trace.colormodel;
+            if (!out.z) out.z = pt2.color;
+            return out;
+          };
+        }
+      });
+      var require_image = __commonJS({
+        "src/traces/image/index.js"(exports, module2) {
+          module2.exports = {
+            attributes: require_attributes34(),
+            supplyDefaults: require_defaults30(),
+            calc: require_calc15(),
+            plot: require_plot11(),
+            style: require_style11(),
+            hoverPoints: require_hover13(),
+            eventData: require_event_data7(),
+            moduleType: "trace",
+            name: "image",
+            basePlotModule: require_cartesian(),
+            categories: ["cartesian", "svg", "2dMap", "noSortingByValue"],
+            animatable: false,
+            meta: {}
+          };
+        }
+      });
+      var require_image2 = __commonJS({
+        "lib/image.js"(exports, module2) {
+          module2.exports = require_image();
+        }
+      });
+      var require_attributes35 = __commonJS({
+        "src/traces/pie/attributes.js"(exports, module2) {
+          var baseAttrs = require_attributes2();
+          var domainAttrs = require_domain().attributes;
+          var fontAttrs = require_font_attributes();
+          var colorAttrs = require_attributes3();
+          var { hovertemplateAttrs, texttemplateAttrs, templatefallbackAttrs } = require_template_attributes();
+          var extendFlat = require_extend().extendFlat;
+          var pattern = require_attributes4().pattern;
+          var textFontAttrs = fontAttrs({
+            editType: "plot",
+            arrayOk: true,
+            colorEditType: "plot"
+          });
+          module2.exports = {
+            labels: {
+              valType: "data_array",
+              editType: "calc"
+            },
+            // equivalent of x0 and dx, if label is missing
+            label0: {
+              valType: "number",
+              dflt: 0,
+              editType: "calc"
+            },
+            dlabel: {
+              valType: "number",
+              dflt: 1,
+              editType: "calc"
+            },
+            values: {
+              valType: "data_array",
+              editType: "calc"
+            },
+            marker: {
+              colors: {
+                valType: "data_array",
+                // TODO 'color_array' ?
+                editType: "calc"
+              },
+              line: {
+                color: {
+                  valType: "color",
+                  dflt: colorAttrs.defaultLine,
+                  arrayOk: true,
+                  editType: "style"
+                },
+                width: {
+                  valType: "number",
+                  min: 0,
+                  dflt: 0,
+                  arrayOk: true,
+                  editType: "style"
+                },
+                editType: "calc"
+              },
+              pattern,
+              editType: "calc"
+            },
+            text: {
+              valType: "data_array",
+              editType: "plot"
+            },
+            hovertext: {
+              valType: "string",
+              dflt: "",
+              arrayOk: true,
+              editType: "style"
+            },
+            // 'see eg:'
+            // 'https://www.e-education.psu.edu/natureofgeoinfo/sites/www.e-education.psu.edu.natureofgeoinfo/files/image/hisp_pies.gif',
+            // '(this example involves a map too - may someday be a whole trace type',
+            // 'of its own. but the point is the size of the whole pie is important.)'
+            scalegroup: {
+              valType: "string",
+              dflt: "",
+              editType: "calc"
+            },
+            // labels (legend is handled by plots.attributes.showlegend and layout.hiddenlabels)
+            textinfo: {
+              valType: "flaglist",
+              flags: ["label", "text", "value", "percent"],
+              extras: ["none"],
+              editType: "calc"
+            },
+            hoverinfo: extendFlat({}, baseAttrs.hoverinfo, {
+              flags: ["label", "text", "value", "percent", "name"]
+            }),
+            hovertemplate: hovertemplateAttrs({}, { keys: ["label", "color", "value", "percent", "text"] }),
+            hovertemplatefallback: templatefallbackAttrs(),
+            texttemplate: texttemplateAttrs({ editType: "plot" }, { keys: ["label", "color", "value", "percent", "text"] }),
+            texttemplatefallback: templatefallbackAttrs({ editType: "plot" }),
+            textposition: {
+              valType: "enumerated",
+              values: ["inside", "outside", "auto", "none"],
+              dflt: "auto",
+              arrayOk: true,
+              editType: "plot"
+            },
+            textfont: extendFlat({}, textFontAttrs, {}),
+            insidetextorientation: {
+              valType: "enumerated",
+              values: ["horizontal", "radial", "tangential", "auto"],
+              dflt: "auto",
+              editType: "plot"
+            },
+            insidetextfont: extendFlat({}, textFontAttrs, {}),
+            outsidetextfont: extendFlat({}, textFontAttrs, {}),
+            automargin: {
+              valType: "boolean",
+              dflt: false,
+              editType: "plot"
+            },
+            showlegend: extendFlat({}, baseAttrs.showlegend, {
+              arrayOk: true
+            }),
+            legend: extendFlat({}, baseAttrs.legend, {
+              arrayOk: true
+            }),
+            title: {
+              text: {
+                valType: "string",
+                dflt: "",
+                editType: "plot"
+              },
+              font: extendFlat({}, textFontAttrs, {}),
+              position: {
+                valType: "enumerated",
+                values: [
+                  "top left",
+                  "top center",
+                  "top right",
+                  "middle center",
+                  "bottom left",
+                  "bottom center",
+                  "bottom right"
+                ],
+                editType: "plot"
+              },
+              editType: "plot"
+            },
+            // position and shape
+            domain: domainAttrs({ name: "pie", trace: true, editType: "calc" }),
+            hole: {
+              valType: "number",
+              min: 0,
+              max: 1,
+              dflt: 0,
+              editType: "calc"
+            },
+            // ordering and direction
+            sort: {
+              valType: "boolean",
+              dflt: true,
+              editType: "calc"
+            },
+            direction: {
+              /**
+               * there are two common conventions, both of which place the first
+               * (largest, if sorted) slice with its left edge at 12 o'clock but
+               * succeeding slices follow either cw or ccw from there.
+               *
+               * see http://visage.co/data-visualization-101-pie-charts/
+               */
+              valType: "enumerated",
+              values: ["clockwise", "counterclockwise"],
+              dflt: "counterclockwise",
+              editType: "calc"
+            },
+            rotation: {
+              valType: "angle",
+              dflt: 0,
+              editType: "calc"
+            },
+            pull: {
+              valType: "number",
+              min: 0,
+              max: 1,
+              dflt: 0,
+              arrayOk: true,
+              editType: "calc"
+            }
+          };
+        }
+      });
+      var require_defaults31 = __commonJS({
+        "src/traces/pie/defaults.js"(exports, module2) {
+          var isNumeric = require_fast_isnumeric();
+          var Lib = require_lib();
+          var attributes = require_attributes35();
+          var handleDomainDefaults = require_domain().defaults;
+          var handleText = require_defaults19().handleText;
+          var coercePattern = require_lib().coercePattern;
+          function handleLabelsAndValues(labels, values) {
+            var hasLabels = Lib.isArrayOrTypedArray(labels);
+            var hasValues = Lib.isArrayOrTypedArray(values);
+            var len2 = Math.min(hasLabels ? labels.length : Infinity, hasValues ? values.length : Infinity);
+            if (!isFinite(len2)) len2 = 0;
+            if (len2 && hasValues) {
+              var hasPositive;
+              for (var i2 = 0; i2 < len2; i2++) {
+                var v2 = values[i2];
+                if (isNumeric(v2) && v2 > 0) {
+                  hasPositive = true;
+                  break;
+                }
+              }
+              if (!hasPositive) len2 = 0;
+            }
+            return {
+              hasLabels,
+              hasValues,
+              len: len2
+            };
+          }
+          function handleMarkerDefaults(traceIn, traceOut, layout, coerce, isPie) {
+            var lineWidth = coerce("marker.line.width");
+            if (lineWidth) {
+              coerce(
+                "marker.line.color",
+                isPie ? void 0 : layout.paper_bgcolor
+                // case of funnelarea, sunburst, icicle, treemap
+              );
+            }
+            var markerColors = coerce("marker.colors");
+            coercePattern(coerce, "marker.pattern", markerColors);
+            if (traceIn.marker && !traceOut.marker.pattern.fgcolor) traceOut.marker.pattern.fgcolor = traceIn.marker.colors;
+            if (!traceOut.marker.pattern.bgcolor) traceOut.marker.pattern.bgcolor = layout.paper_bgcolor;
+          }
+          function supplyDefaults(traceIn, traceOut, defaultColor, layout) {
+            function coerce(attr, dflt) {
+              return Lib.coerce(traceIn, traceOut, attributes, attr, dflt);
+            }
+            var labels = coerce("labels");
+            var values = coerce("values");
+            var res = handleLabelsAndValues(labels, values);
+            var len2 = res.len;
+            traceOut._hasLabels = res.hasLabels;
+            traceOut._hasValues = res.hasValues;
+            if (!traceOut._hasLabels && traceOut._hasValues) {
+              coerce("label0");
+              coerce("dlabel");
+            }
+            if (!len2) {
+              traceOut.visible = false;
+              return;
+            }
+            traceOut._length = len2;
+            handleMarkerDefaults(traceIn, traceOut, layout, coerce, true);
+            coerce("scalegroup");
+            var textData = coerce("text");
+            var textTemplate = coerce("texttemplate");
+            coerce("texttemplatefallback");
+            var textInfo;
+            if (!textTemplate) textInfo = coerce("textinfo", Lib.isArrayOrTypedArray(textData) ? "text+percent" : "percent");
+            coerce("hovertext");
+            coerce("hovertemplate");
+            coerce("hovertemplatefallback");
+            if (textTemplate || textInfo && textInfo !== "none") {
+              var textposition = coerce("textposition");
+              handleText(traceIn, traceOut, layout, coerce, textposition, {
+                moduleHasSelected: false,
+                moduleHasUnselected: false,
+                moduleHasConstrain: false,
+                moduleHasCliponaxis: false,
+                moduleHasTextangle: false,
+                moduleHasInsideanchor: false
+              });
+              var hasBoth = Array.isArray(textposition) || textposition === "auto";
+              var hasOutside = hasBoth || textposition === "outside";
+              if (hasOutside) {
+                coerce("automargin");
+              }
+              if (textposition === "inside" || textposition === "auto" || Array.isArray(textposition)) {
+                coerce("insidetextorientation");
+              }
+            } else if (textInfo === "none") {
+              coerce("textposition", "none");
+            }
+            handleDomainDefaults(traceOut, layout, coerce);
+            var hole = coerce("hole");
+            var title = coerce("title.text");
+            if (title) {
+              var titlePosition = coerce("title.position", hole ? "middle center" : "top center");
+              if (!hole && titlePosition === "middle center") traceOut.title.position = "top center";
+              Lib.coerceFont(coerce, "title.font", layout.font);
+            }
+            coerce("sort");
+            coerce("direction");
+            coerce("rotation");
+            coerce("pull");
+          }
+          module2.exports = {
+            handleLabelsAndValues,
+            handleMarkerDefaults,
+            supplyDefaults
+          };
+        }
+      });
+      var require_layout_attributes12 = __commonJS({
+        "src/traces/pie/layout_attributes.js"(exports, module2) {
+          module2.exports = {
+            hiddenlabels: {
+              valType: "data_array",
+              editType: "calc"
+            },
+            piecolorway: {
+              valType: "colorlist",
+              editType: "calc"
+            },
+            extendpiecolors: {
+              valType: "boolean",
+              dflt: true,
+              editType: "calc"
+            }
+          };
+        }
+      });
+      var require_layout_defaults11 = __commonJS({
+        "src/traces/pie/layout_defaults.js"(exports, module2) {
+          var Lib = require_lib();
+          var layoutAttributes = require_layout_attributes12();
+          module2.exports = function supplyLayoutDefaults(layoutIn, layoutOut) {
+            function coerce(attr, dflt) {
+              return Lib.coerce(layoutIn, layoutOut, layoutAttributes, attr, dflt);
+            }
+            coerce("hiddenlabels");
+            coerce("piecolorway", layoutOut.colorway);
+            coerce("extendpiecolors");
+          };
+        }
+      });
+      var require_calc16 = __commonJS({
+        "src/traces/pie/calc.js"(exports, module2) {
+          var isNumeric = require_fast_isnumeric();
+          var tinycolor = require_tinycolor();
+          var Color2 = require_color();
+          var extendedColorWayList = {};
+          function calc(gd2, trace) {
+            var cd2 = [];
+            var fullLayout = gd2._fullLayout;
+            var hiddenLabels = fullLayout.hiddenlabels || [];
+            var labels = trace.labels;
+            var colors = trace.marker.colors || [];
+            var vals = trace.values;
+            var len2 = trace._length;
+            var hasValues = trace._hasValues && len2;
+            var i2, pt2;
+            if (trace.dlabel) {
+              labels = new Array(len2);
+              for (i2 = 0; i2 < len2; i2++) {
+                labels[i2] = String(trace.label0 + i2 * trace.dlabel);
+              }
+            }
+            var allThisTraceLabels = {};
+            var pullColor = makePullColorFn(fullLayout["_" + trace.type + "colormap"]);
+            var vTotal = 0;
+            var isAggregated = false;
+            for (i2 = 0; i2 < len2; i2++) {
+              var v2, label, hidden;
+              if (hasValues) {
+                v2 = vals[i2];
+                if (!isNumeric(v2)) continue;
+                v2 = +v2;
+              } else v2 = 1;
+              label = labels[i2];
+              if (label === void 0 || label === "") label = i2;
+              label = String(label);
+              var thisLabelIndex = allThisTraceLabels[label];
+              if (thisLabelIndex === void 0) {
+                allThisTraceLabels[label] = cd2.length;
+                hidden = hiddenLabels.indexOf(label) !== -1;
+                if (!hidden) vTotal += v2;
+                cd2.push({
+                  v: v2,
+                  label,
+                  color: pullColor(colors[i2], label),
+                  i: i2,
+                  pts: [i2],
+                  hidden
+                });
+              } else {
+                isAggregated = true;
+                pt2 = cd2[thisLabelIndex];
+                pt2.v += v2;
+                pt2.pts.push(i2);
+                if (!pt2.hidden) vTotal += v2;
+                if (pt2.color === false && colors[i2]) {
+                  pt2.color = pullColor(colors[i2], label);
+                }
+              }
+            }
+            cd2 = cd2.filter(function(elem) {
+              return elem.v >= 0;
+            });
+            var shouldSort = trace.type === "funnelarea" ? isAggregated : trace.sort;
+            if (shouldSort) cd2.sort(function(a2, b2) {
+              return b2.v - a2.v;
+            });
+            if (cd2[0]) cd2[0].vTotal = vTotal;
+            return cd2;
+          }
+          function makePullColorFn(colorMap) {
+            return function pullColor(color22, id2) {
+              if (!color22) return false;
+              color22 = tinycolor(color22);
+              if (!color22.isValid()) return false;
+              color22 = Color2.addOpacity(color22, color22.getAlpha());
+              if (!colorMap[id2]) colorMap[id2] = color22;
+              return color22;
+            };
+          }
+          function crossTraceCalc(gd2, plotinfo) {
+            var desiredType = (plotinfo || {}).type;
+            if (!desiredType) desiredType = "pie";
+            var fullLayout = gd2._fullLayout;
+            var calcdata = gd2.calcdata;
+            var colorWay = fullLayout[desiredType + "colorway"];
+            var colorMap = fullLayout["_" + desiredType + "colormap"];
+            if (fullLayout["extend" + desiredType + "colors"]) {
+              colorWay = generateExtendedColors(colorWay, extendedColorWayList);
+            }
+            var dfltColorCount = 0;
+            for (var i2 = 0; i2 < calcdata.length; i2++) {
+              var cd2 = calcdata[i2];
+              var traceType = cd2[0].trace.type;
+              if (traceType !== desiredType) continue;
+              for (var j2 = 0; j2 < cd2.length; j2++) {
+                var pt2 = cd2[j2];
+                if (pt2.color === false) {
+                  if (colorMap[pt2.label]) {
+                    pt2.color = colorMap[pt2.label];
+                  } else {
+                    colorMap[pt2.label] = pt2.color = colorWay[dfltColorCount % colorWay.length];
+                    dfltColorCount++;
+                  }
+                }
+              }
+            }
+          }
+          function generateExtendedColors(colorList, extendedColorWays) {
+            var i2;
+            var colorString = JSON.stringify(colorList);
+            var colors = extendedColorWays[colorString];
+            if (!colors) {
+              colors = colorList.slice();
+              for (i2 = 0; i2 < colorList.length; i2++) {
+                colors.push(tinycolor(colorList[i2]).lighten(20).toHexString());
+              }
+              for (i2 = 0; i2 < colorList.length; i2++) {
+                colors.push(tinycolor(colorList[i2]).darken(20).toHexString());
+              }
+              extendedColorWays[colorString] = colors;
+            }
+            return colors;
+          }
+          module2.exports = {
+            calc,
+            crossTraceCalc,
+            makePullColorFn,
+            generateExtendedColors
+          };
+        }
+      });
+      var require_event_data8 = __commonJS({
+        "src/traces/pie/event_data.js"(exports, module2) {
+          var appendArrayMultiPointValues = require_helpers2().appendArrayMultiPointValues;
+          module2.exports = function eventData(pt2, trace) {
+            var out = {
+              curveNumber: trace.index,
+              pointNumbers: pt2.pts,
+              data: trace._input,
+              fullData: trace,
+              label: pt2.label,
+              color: pt2.color,
+              value: pt2.v,
+              percent: pt2.percent,
+              text: pt2.text,
+              bbox: pt2.bbox,
+              // pt.v (and pt.i below) for backward compatibility
+              v: pt2.v
+            };
+            if (pt2.pts.length === 1) out.pointNumber = out.i = pt2.pts[0];
+            appendArrayMultiPointValues(out, trace, pt2.pts);
+            if (trace.type === "funnelarea") {
+              delete out.v;
+              delete out.i;
+            }
+            return out;
+          };
+        }
+      });
+      var require_plot12 = __commonJS({
+        "src/traces/pie/plot.js"(exports, module2) {
+          var d3 = require_d3();
+          var Plots = require_plots();
+          var Fx = require_fx();
+          var Color2 = require_color();
+          var Drawing = require_drawing();
+          var Lib = require_lib();
+          var strScale = Lib.strScale;
+          var strTranslate = Lib.strTranslate;
+          var svgTextUtils = require_svg_text_utils();
+          var uniformText = require_uniform_text();
+          var recordMinTextSize = uniformText.recordMinTextSize;
+          var clearMinTextSize = uniformText.clearMinTextSize;
+          var TEXTPAD = require_constants9().TEXTPAD;
+          var helpers = require_helpers4();
+          var eventData = require_event_data8();
+          var isValidTextValue = require_lib().isValidTextValue;
+          function plot(gd2, cdModule) {
+            var isStatic = gd2._context.staticPlot;
+            var fullLayout = gd2._fullLayout;
+            var gs = fullLayout._size;
+            clearMinTextSize("pie", fullLayout);
+            prerenderTitles(cdModule, gd2);
+            layoutAreas(cdModule, gs);
+            var plotGroups = Lib.makeTraceGroups(fullLayout._pielayer, cdModule, "trace").each(function(cd2) {
+              var plotGroup = d3.select(this);
+              var cd0 = cd2[0];
+              var trace = cd0.trace;
+              setCoords(cd2);
+              plotGroup.attr("stroke-linejoin", "round");
+              plotGroup.each(function() {
+                var slices = d3.select(this).selectAll("g.slice").data(cd2);
+                slices.enter().append("g").classed("slice", true);
+                slices.exit().remove();
+                var quadrants = [
+                  [[], []],
+                  // y<0: x<0, x>=0
+                  [[], []]
+                  // y>=0: x<0, x>=0
+                ];
+                var hasOutsideText = false;
+                slices.each(function(pt2, i2) {
+                  if (pt2.hidden) {
+                    d3.select(this).selectAll("path,g").remove();
+                    return;
+                  }
+                  pt2.pointNumber = pt2.i;
+                  pt2.curveNumber = trace.index;
+                  quadrants[pt2.pxmid[1] < 0 ? 0 : 1][pt2.pxmid[0] < 0 ? 0 : 1].push(pt2);
+                  var cx = cd0.cx;
+                  var cy = cd0.cy;
+                  var sliceTop = d3.select(this);
+                  var slicePath = sliceTop.selectAll("path.surface").data([pt2]);
+                  slicePath.enter().append("path").classed("surface", true).style({ "pointer-events": isStatic ? "none" : "all" });
+                  sliceTop.call(attachFxHandlers, gd2, cd2);
+                  if (trace.pull) {
+                    var pull = +helpers.castOption(trace.pull, pt2.pts) || 0;
+                    if (pull > 0) {
+                      cx += pull * pt2.pxmid[0];
+                      cy += pull * pt2.pxmid[1];
+                    }
+                  }
+                  pt2.cxFinal = cx;
+                  pt2.cyFinal = cy;
+                  function arc(start, finish, cw, scale2) {
+                    var dx = scale2 * (finish[0] - start[0]);
+                    var dy = scale2 * (finish[1] - start[1]);
+                    return "a" + scale2 * cd0.r + "," + scale2 * cd0.r + " 0 " + pt2.largeArc + (cw ? " 1 " : " 0 ") + dx + "," + dy;
+                  }
+                  var hole = trace.hole;
+                  if (pt2.v === cd0.vTotal) {
+                    var outerCircle = "M" + (cx + pt2.px0[0]) + "," + (cy + pt2.px0[1]) + arc(pt2.px0, pt2.pxmid, true, 1) + arc(pt2.pxmid, pt2.px0, true, 1) + "Z";
+                    if (hole) {
+                      slicePath.attr(
+                        "d",
+                        "M" + (cx + hole * pt2.px0[0]) + "," + (cy + hole * pt2.px0[1]) + arc(pt2.px0, pt2.pxmid, false, hole) + arc(pt2.pxmid, pt2.px0, false, hole) + "Z" + outerCircle
+                      );
+                    } else slicePath.attr("d", outerCircle);
+                  } else {
+                    var outerArc = arc(pt2.px0, pt2.px1, true, 1);
+                    if (hole) {
+                      var rim = 1 - hole;
+                      slicePath.attr(
+                        "d",
+                        "M" + (cx + hole * pt2.px1[0]) + "," + (cy + hole * pt2.px1[1]) + arc(pt2.px1, pt2.px0, false, hole) + "l" + rim * pt2.px0[0] + "," + rim * pt2.px0[1] + outerArc + "Z"
+                      );
+                    } else {
+                      slicePath.attr("d", "M" + cx + "," + cy + "l" + pt2.px0[0] + "," + pt2.px0[1] + outerArc + "Z");
+                    }
+                  }
+                  formatSliceLabel(gd2, pt2, cd0);
+                  var textPosition = helpers.castOption(trace.textposition, pt2.pts);
+                  var sliceTextGroup = sliceTop.selectAll("g.slicetext").data(pt2.text && textPosition !== "none" ? [0] : []);
+                  sliceTextGroup.enter().append("g").classed("slicetext", true);
+                  sliceTextGroup.exit().remove();
+                  sliceTextGroup.each(function() {
+                    var sliceText = Lib.ensureSingle(d3.select(this), "text", "", function(s2) {
+                      s2.attr("data-notex", 1);
+                    });
+                    var font = Lib.ensureUniformFontSize(
+                      gd2,
+                      textPosition === "outside" ? determineOutsideTextFont(trace, pt2, fullLayout.font) : determineInsideTextFont(trace, pt2, fullLayout.font)
+                    );
+                    sliceText.text(pt2.text).attr({
+                      class: "slicetext",
+                      transform: "",
+                      "text-anchor": "middle"
+                    }).call(Drawing.font, font).call(svgTextUtils.convertToTspans, gd2);
+                    var textBB = Drawing.bBox(sliceText.node());
+                    var transform;
+                    if (textPosition === "outside") {
+                      transform = transformOutsideText(textBB, pt2);
+                    } else {
+                      transform = transformInsideText(textBB, pt2, cd0);
+                      if (textPosition === "auto" && transform.scale < 1) {
+                        var newFont = Lib.ensureUniformFontSize(gd2, trace.outsidetextfont);
+                        sliceText.call(Drawing.font, newFont);
+                        textBB = Drawing.bBox(sliceText.node());
+                        transform = transformOutsideText(textBB, pt2);
+                      }
+                    }
+                    var textPosAngle = transform.textPosAngle;
+                    var textXY = textPosAngle === void 0 ? pt2.pxmid : getCoords(cd0.r, textPosAngle);
+                    transform.targetX = cx + textXY[0] * transform.rCenter + (transform.x || 0);
+                    transform.targetY = cy + textXY[1] * transform.rCenter + (transform.y || 0);
+                    computeTransform(transform, textBB);
+                    if (transform.outside) {
+                      var targetY = transform.targetY;
+                      pt2.yLabelMin = targetY - textBB.height / 2;
+                      pt2.yLabelMid = targetY;
+                      pt2.yLabelMax = targetY + textBB.height / 2;
+                      pt2.labelExtraX = 0;
+                      pt2.labelExtraY = 0;
+                      hasOutsideText = true;
+                    }
+                    transform.fontSize = font.size;
+                    recordMinTextSize(trace.type, transform, fullLayout);
+                    cd2[i2].transform = transform;
+                    Lib.setTransormAndDisplay(sliceText, transform);
+                  });
+                });
+                var titleTextGroup = d3.select(this).selectAll("g.titletext").data(trace.title.text ? [0] : []);
+                titleTextGroup.enter().append("g").classed("titletext", true);
+                titleTextGroup.exit().remove();
+                titleTextGroup.each(function() {
+                  var titleText = Lib.ensureSingle(d3.select(this), "text", "", function(s2) {
+                    s2.attr("data-notex", 1);
+                  });
+                  var txt = trace.title.text;
+                  if (trace._meta) {
+                    txt = Lib.templateString(txt, trace._meta);
+                  }
+                  titleText.text(txt).attr({
+                    class: "titletext",
+                    transform: "",
+                    "text-anchor": "middle"
+                  }).call(Drawing.font, trace.title.font).call(svgTextUtils.convertToTspans, gd2);
+                  var transform;
+                  if (trace.title.position === "middle center") {
+                    transform = positionTitleInside(cd0);
+                  } else {
+                    transform = positionTitleOutside(cd0, gs);
+                  }
+                  titleText.attr(
+                    "transform",
+                    strTranslate(transform.x, transform.y) + strScale(Math.min(1, transform.scale)) + strTranslate(transform.tx, transform.ty)
+                  );
+                });
+                if (hasOutsideText) scootLabels(quadrants, trace);
+                plotTextLines(slices, trace);
+                if (hasOutsideText && trace.automargin) {
+                  var traceBbox = Drawing.bBox(plotGroup.node());
+                  var domain = trace.domain;
+                  var vpw = gs.w * (domain.x[1] - domain.x[0]);
+                  var vph = gs.h * (domain.y[1] - domain.y[0]);
+                  var xgap = (0.5 * vpw - cd0.r) / gs.w;
+                  var ygap = (0.5 * vph - cd0.r) / gs.h;
+                  Plots.autoMargin(gd2, "pie." + trace.uid + ".automargin", {
+                    xl: domain.x[0] - xgap,
+                    xr: domain.x[1] + xgap,
+                    yb: domain.y[0] - ygap,
+                    yt: domain.y[1] + ygap,
+                    l: Math.max(cd0.cx - cd0.r - traceBbox.left, 0),
+                    r: Math.max(traceBbox.right - (cd0.cx + cd0.r), 0),
+                    b: Math.max(traceBbox.bottom - (cd0.cy + cd0.r), 0),
+                    t: Math.max(cd0.cy - cd0.r - traceBbox.top, 0),
+                    pad: 5
+                  });
+                }
+              });
+            });
+            setTimeout(function() {
+              plotGroups.selectAll("tspan").each(function() {
+                var s2 = d3.select(this);
+                if (s2.attr("dy")) s2.attr("dy", s2.attr("dy"));
+              });
+            }, 0);
+          }
+          function plotTextLines(slices, trace) {
+            slices.each(function(pt2) {
+              var sliceTop = d3.select(this);
+              if (!pt2.labelExtraX && !pt2.labelExtraY) {
+                sliceTop.select("path.textline").remove();
+                return;
+              }
+              var sliceText = sliceTop.select("g.slicetext text");
+              pt2.transform.targetX += pt2.labelExtraX;
+              pt2.transform.targetY += pt2.labelExtraY;
+              Lib.setTransormAndDisplay(sliceText, pt2.transform);
+              var lineStartX = pt2.cxFinal + pt2.pxmid[0];
+              var lineStartY = pt2.cyFinal + pt2.pxmid[1];
+              var textLinePath = "M" + lineStartX + "," + lineStartY;
+              var finalX = (pt2.yLabelMax - pt2.yLabelMin) * (pt2.pxmid[0] < 0 ? -1 : 1) / 4;
+              if (pt2.labelExtraX) {
+                var yFromX = pt2.labelExtraX * pt2.pxmid[1] / pt2.pxmid[0];
+                var yNet = pt2.yLabelMid + pt2.labelExtraY - (pt2.cyFinal + pt2.pxmid[1]);
+                if (Math.abs(yFromX) > Math.abs(yNet)) {
+                  textLinePath += "l" + yNet * pt2.pxmid[0] / pt2.pxmid[1] + "," + yNet + "H" + (lineStartX + pt2.labelExtraX + finalX);
+                } else {
+                  textLinePath += "l" + pt2.labelExtraX + "," + yFromX + "v" + (yNet - yFromX) + "h" + finalX;
+                }
+              } else {
+                textLinePath += "V" + (pt2.yLabelMid + pt2.labelExtraY) + "h" + finalX;
+              }
+              Lib.ensureSingle(sliceTop, "path", "textline").call(Color2.stroke, trace.outsidetextfont.color).attr({
+                "stroke-width": Math.min(2, trace.outsidetextfont.size / 8),
+                d: textLinePath,
+                fill: "none"
+              });
+            });
+          }
+          function attachFxHandlers(sliceTop, gd2, cd2) {
+            var cd0 = cd2[0];
+            var cx = cd0.cx;
+            var cy = cd0.cy;
+            var trace = cd0.trace;
+            var isFunnelArea = trace.type === "funnelarea";
+            if (!("_hasHoverLabel" in trace)) trace._hasHoverLabel = false;
+            if (!("_hasHoverEvent" in trace)) trace._hasHoverEvent = false;
+            sliceTop.on("mouseover", function(pt2) {
+              var fullLayout2 = gd2._fullLayout;
+              var trace2 = gd2._fullData[trace.index];
+              if (gd2._dragging || fullLayout2.hovermode === false) return;
+              var hoverinfo = trace2.hoverinfo;
+              if (Array.isArray(hoverinfo)) {
+                hoverinfo = Fx.castHoverinfo(
+                  {
+                    hoverinfo: [helpers.castOption(hoverinfo, pt2.pts)],
+                    _module: trace._module
+                  },
+                  fullLayout2,
+                  0
+                );
+              }
+              if (hoverinfo === "all") hoverinfo = "label+text+value+percent+name";
+              if (trace2.hovertemplate || hoverinfo !== "none" && hoverinfo !== "skip" && hoverinfo) {
+                var rInscribed = pt2.rInscribed || 0;
+                var hoverCenterX = cx + pt2.pxmid[0] * (1 - rInscribed);
+                var hoverCenterY = cy + pt2.pxmid[1] * (1 - rInscribed);
+                var separators = fullLayout2.separators;
+                var text = [];
+                if (hoverinfo && hoverinfo.indexOf("label") !== -1) text.push(pt2.label);
+                pt2.text = helpers.castOption(trace2.hovertext || trace2.text, pt2.pts);
+                if (hoverinfo && hoverinfo.indexOf("text") !== -1) {
+                  var tx = pt2.text;
+                  if (Lib.isValidTextValue(tx)) text.push(tx);
+                }
+                pt2.value = pt2.v;
+                pt2.valueLabel = helpers.formatPieValue(pt2.v, separators);
+                if (hoverinfo && hoverinfo.indexOf("value") !== -1) text.push(pt2.valueLabel);
+                pt2.percent = pt2.v / cd0.vTotal;
+                pt2.percentLabel = helpers.formatPiePercent(pt2.percent, separators);
+                if (hoverinfo && hoverinfo.indexOf("percent") !== -1) text.push(pt2.percentLabel);
+                var hoverLabel = trace2.hoverlabel;
+                var hoverFont = hoverLabel.font;
+                var bbox = [];
+                Fx.loneHover(
+                  {
+                    trace,
+                    x0: hoverCenterX - rInscribed * cd0.r,
+                    x1: hoverCenterX + rInscribed * cd0.r,
+                    y: hoverCenterY,
+                    _x0: isFunnelArea ? cx + pt2.TL[0] : hoverCenterX - rInscribed * cd0.r,
+                    _x1: isFunnelArea ? cx + pt2.TR[0] : hoverCenterX + rInscribed * cd0.r,
+                    _y0: isFunnelArea ? cy + pt2.TL[1] : hoverCenterY - rInscribed * cd0.r,
+                    _y1: isFunnelArea ? cy + pt2.BL[1] : hoverCenterY + rInscribed * cd0.r,
+                    text: text.join("<br>"),
+                    name: trace2.hovertemplate || hoverinfo.indexOf("name") !== -1 ? trace2.name : void 0,
+                    idealAlign: pt2.pxmid[0] < 0 ? "left" : "right",
+                    color: helpers.castOption(hoverLabel.bgcolor, pt2.pts) || pt2.color,
+                    borderColor: helpers.castOption(hoverLabel.bordercolor, pt2.pts),
+                    fontFamily: helpers.castOption(hoverFont.family, pt2.pts),
+                    fontSize: helpers.castOption(hoverFont.size, pt2.pts),
+                    fontColor: helpers.castOption(hoverFont.color, pt2.pts),
+                    nameLength: helpers.castOption(hoverLabel.namelength, pt2.pts),
+                    textAlign: helpers.castOption(hoverLabel.align, pt2.pts),
+                    hovertemplate: helpers.castOption(trace2.hovertemplate, pt2.pts),
+                    hovertemplateLabels: pt2,
+                    eventData: [eventData(pt2, trace2)]
+                  },
+                  {
+                    container: fullLayout2._hoverlayer.node(),
+                    outerContainer: fullLayout2._paper.node(),
+                    gd: gd2,
+                    inOut_bbox: bbox
+                  }
+                );
+                pt2.bbox = bbox[0];
+                trace._hasHoverLabel = true;
+              }
+              trace._hasHoverEvent = true;
+              gd2.emit("plotly_hover", {
+                points: [eventData(pt2, trace2)],
+                event: d3.event
+              });
+            });
+            sliceTop.on("mouseout", function(evt) {
+              var fullLayout2 = gd2._fullLayout;
+              var trace2 = gd2._fullData[trace.index];
+              var pt2 = d3.select(this).datum();
+              if (trace._hasHoverEvent) {
+                evt.originalEvent = d3.event;
+                gd2.emit("plotly_unhover", {
+                  points: [eventData(pt2, trace2)],
+                  event: d3.event
+                });
+                trace._hasHoverEvent = false;
+              }
+              if (trace._hasHoverLabel) {
+                Fx.loneUnhover(fullLayout2._hoverlayer.node());
+                trace._hasHoverLabel = false;
+              }
+            });
+            sliceTop.on("click", function(pt2) {
+              var fullLayout2 = gd2._fullLayout;
+              var trace2 = gd2._fullData[trace.index];
+              if (gd2._dragging || fullLayout2.hovermode === false) return;
+              gd2._hoverdata = [eventData(pt2, trace2)];
+              Fx.click(gd2, d3.event);
+            });
+          }
+          function determineOutsideTextFont(trace, pt2, layoutFont) {
+            var color22 = helpers.castOption(trace.outsidetextfont.color, pt2.pts) || helpers.castOption(trace.textfont.color, pt2.pts) || layoutFont.color;
+            var family = helpers.castOption(trace.outsidetextfont.family, pt2.pts) || helpers.castOption(trace.textfont.family, pt2.pts) || layoutFont.family;
+            var size = helpers.castOption(trace.outsidetextfont.size, pt2.pts) || helpers.castOption(trace.textfont.size, pt2.pts) || layoutFont.size;
+            var weight = helpers.castOption(trace.outsidetextfont.weight, pt2.pts) || helpers.castOption(trace.textfont.weight, pt2.pts) || layoutFont.weight;
+            var style = helpers.castOption(trace.outsidetextfont.style, pt2.pts) || helpers.castOption(trace.textfont.style, pt2.pts) || layoutFont.style;
+            var variant = helpers.castOption(trace.outsidetextfont.variant, pt2.pts) || helpers.castOption(trace.textfont.variant, pt2.pts) || layoutFont.variant;
+            var textcase = helpers.castOption(trace.outsidetextfont.textcase, pt2.pts) || helpers.castOption(trace.textfont.textcase, pt2.pts) || layoutFont.textcase;
+            var lineposition = helpers.castOption(trace.outsidetextfont.lineposition, pt2.pts) || helpers.castOption(trace.textfont.lineposition, pt2.pts) || layoutFont.lineposition;
+            var shadow2 = helpers.castOption(trace.outsidetextfont.shadow, pt2.pts) || helpers.castOption(trace.textfont.shadow, pt2.pts) || layoutFont.shadow;
+            return {
+              color: color22,
+              family,
+              size,
+              weight,
+              style,
+              variant,
+              textcase,
+              lineposition,
+              shadow: shadow2
+            };
+          }
+          function determineInsideTextFont(trace, pt2, layoutFont) {
+            var customColor = helpers.castOption(trace.insidetextfont.color, pt2.pts);
+            if (!customColor && trace._input.textfont) {
+              customColor = helpers.castOption(trace._input.textfont.color, pt2.pts);
+            }
+            var family = helpers.castOption(trace.insidetextfont.family, pt2.pts) || helpers.castOption(trace.textfont.family, pt2.pts) || layoutFont.family;
+            var size = helpers.castOption(trace.insidetextfont.size, pt2.pts) || helpers.castOption(trace.textfont.size, pt2.pts) || layoutFont.size;
+            var weight = helpers.castOption(trace.insidetextfont.weight, pt2.pts) || helpers.castOption(trace.textfont.weight, pt2.pts) || layoutFont.weight;
+            var style = helpers.castOption(trace.insidetextfont.style, pt2.pts) || helpers.castOption(trace.textfont.style, pt2.pts) || layoutFont.style;
+            var variant = helpers.castOption(trace.insidetextfont.variant, pt2.pts) || helpers.castOption(trace.textfont.variant, pt2.pts) || layoutFont.variant;
+            var textcase = helpers.castOption(trace.insidetextfont.textcase, pt2.pts) || helpers.castOption(trace.textfont.textcase, pt2.pts) || layoutFont.textcase;
+            var lineposition = helpers.castOption(trace.insidetextfont.lineposition, pt2.pts) || helpers.castOption(trace.textfont.lineposition, pt2.pts) || layoutFont.lineposition;
+            var shadow2 = helpers.castOption(trace.insidetextfont.shadow, pt2.pts) || helpers.castOption(trace.textfont.shadow, pt2.pts) || layoutFont.shadow;
+            return {
+              color: customColor || Color2.contrast(pt2.color),
+              family,
+              size,
+              weight,
+              style,
+              variant,
+              textcase,
+              lineposition,
+              shadow: shadow2
+            };
+          }
+          function prerenderTitles(cdModule, gd2) {
+            var cd0, trace;
+            for (var i2 = 0; i2 < cdModule.length; i2++) {
+              cd0 = cdModule[i2][0];
+              trace = cd0.trace;
+              if (trace.title.text) {
+                var txt = trace.title.text;
+                if (trace._meta) {
+                  txt = Lib.templateString(txt, trace._meta);
+                }
+                var dummyTitle = Drawing.tester.append("text").attr("data-notex", 1).text(txt).call(Drawing.font, trace.title.font).call(svgTextUtils.convertToTspans, gd2);
+                var bBox = Drawing.bBox(dummyTitle.node(), true);
+                cd0.titleBox = {
+                  width: bBox.width,
+                  height: bBox.height
+                };
+                dummyTitle.remove();
+              }
+            }
+          }
+          function transformInsideText(textBB, pt2, cd0) {
+            var r2 = cd0.r || pt2.rpx1;
+            var rInscribed = pt2.rInscribed;
+            var isEmpty = pt2.startangle === pt2.stopangle;
+            if (isEmpty) {
+              return {
+                rCenter: 1 - rInscribed,
+                scale: 0,
+                rotate: 0,
+                textPosAngle: 0
+              };
+            }
+            var ring = pt2.ring;
+            var isCircle = ring === 1 && Math.abs(pt2.startangle - pt2.stopangle) === Math.PI * 2;
+            var halfAngle = pt2.halfangle;
+            var midAngle = pt2.midangle;
+            var orientation = cd0.trace.insidetextorientation;
+            var isHorizontal = orientation === "horizontal";
+            var isTangential = orientation === "tangential";
+            var isRadial = orientation === "radial";
+            var isAuto = orientation === "auto";
+            var allTransforms = [];
+            var newT;
+            if (!isAuto) {
+              var considerCrossing = function(angle2, key) {
+                if (isCrossing(pt2, angle2)) {
+                  var dStart = Math.abs(angle2 - pt2.startangle);
+                  var dStop = Math.abs(angle2 - pt2.stopangle);
+                  var closestEdge = dStart < dStop ? dStart : dStop;
+                  if (key === "tan") {
+                    newT = calcTanTransform(textBB, r2, ring, closestEdge, 0);
+                  } else {
+                    newT = calcRadTransform(textBB, r2, ring, closestEdge, Math.PI / 2);
+                  }
+                  newT.textPosAngle = angle2;
+                  allTransforms.push(newT);
+                }
+              };
+              var i2;
+              if (isHorizontal || isTangential) {
+                for (i2 = 4; i2 >= -4; i2 -= 2) considerCrossing(Math.PI * i2, "tan");
+                for (i2 = 4; i2 >= -4; i2 -= 2) considerCrossing(Math.PI * (i2 + 1), "tan");
+              }
+              if (isHorizontal || isRadial) {
+                for (i2 = 4; i2 >= -4; i2 -= 2) considerCrossing(Math.PI * (i2 + 1.5), "rad");
+                for (i2 = 4; i2 >= -4; i2 -= 2) considerCrossing(Math.PI * (i2 + 0.5), "rad");
+              }
+            }
+            if (isCircle || isAuto || isHorizontal) {
+              var textDiameter = Math.sqrt(textBB.width * textBB.width + textBB.height * textBB.height);
+              newT = {
+                scale: rInscribed * r2 * 2 / textDiameter,
+                // and the center position and rotation in this case
+                rCenter: 1 - rInscribed,
+                rotate: 0
+              };
+              newT.textPosAngle = (pt2.startangle + pt2.stopangle) / 2;
+              if (newT.scale >= 1) return newT;
+              allTransforms.push(newT);
+            }
+            if (isAuto || isRadial) {
+              newT = calcRadTransform(textBB, r2, ring, halfAngle, midAngle);
+              newT.textPosAngle = (pt2.startangle + pt2.stopangle) / 2;
+              allTransforms.push(newT);
+            }
+            if (isAuto || isTangential) {
+              newT = calcTanTransform(textBB, r2, ring, halfAngle, midAngle);
+              newT.textPosAngle = (pt2.startangle + pt2.stopangle) / 2;
+              allTransforms.push(newT);
+            }
+            var id2 = 0;
+            var maxScale = 0;
+            for (var k2 = 0; k2 < allTransforms.length; k2++) {
+              var s2 = allTransforms[k2].scale;
+              if (maxScale < s2) {
+                maxScale = s2;
+                id2 = k2;
+              }
+              if (!isAuto && maxScale >= 1) {
+                break;
+              }
+            }
+            return allTransforms[id2];
+          }
+          function isCrossing(pt2, angle2) {
+            var start = pt2.startangle;
+            var stop = pt2.stopangle;
+            return start > angle2 && angle2 > stop || start < angle2 && angle2 < stop;
+          }
+          function calcRadTransform(textBB, r2, ring, halfAngle, midAngle) {
+            r2 = Math.max(0, r2 - 2 * TEXTPAD);
+            var a2 = textBB.width / textBB.height;
+            var s2 = calcMaxHalfSize(a2, halfAngle, r2, ring);
+            return {
+              scale: s2 * 2 / textBB.height,
+              rCenter: calcRCenter(a2, s2 / r2),
+              rotate: calcRotate(midAngle)
+            };
+          }
+          function calcTanTransform(textBB, r2, ring, halfAngle, midAngle) {
+            r2 = Math.max(0, r2 - 2 * TEXTPAD);
+            var a2 = textBB.height / textBB.width;
+            var s2 = calcMaxHalfSize(a2, halfAngle, r2, ring);
+            return {
+              scale: s2 * 2 / textBB.width,
+              rCenter: calcRCenter(a2, s2 / r2),
+              rotate: calcRotate(midAngle + Math.PI / 2)
+            };
+          }
+          function calcRCenter(a2, b2) {
+            return Math.cos(b2) - a2 * b2;
+          }
+          function calcRotate(t4) {
+            return (180 / Math.PI * t4 + 720) % 180 - 90;
+          }
+          function calcMaxHalfSize(a2, halfAngle, r2, ring) {
+            var q2 = a2 + 1 / (2 * Math.tan(halfAngle));
+            return r2 * Math.min(1 / (Math.sqrt(q2 * q2 + 0.5) + q2), ring / (Math.sqrt(a2 * a2 + ring / 2) + a2));
+          }
+          function getInscribedRadiusFraction(pt2, cd0) {
+            if (pt2.v === cd0.vTotal && !cd0.trace.hole) return 1;
+            return Math.min(1 / (1 + 1 / Math.sin(pt2.halfangle)), pt2.ring / 2);
+          }
+          function transformOutsideText(textBB, pt2) {
+            var x2 = pt2.pxmid[0];
+            var y2 = pt2.pxmid[1];
+            var dx = textBB.width / 2;
+            var dy = textBB.height / 2;
+            if (x2 < 0) dx *= -1;
+            if (y2 < 0) dy *= -1;
+            return {
+              scale: 1,
+              rCenter: 1,
+              rotate: 0,
+              x: dx + Math.abs(dy) * (dx > 0 ? 1 : -1) / 2,
+              y: dy / (1 + x2 * x2 / (y2 * y2)),
+              outside: true
+            };
+          }
+          function positionTitleInside(cd0) {
+            var textDiameter = Math.sqrt(cd0.titleBox.width * cd0.titleBox.width + cd0.titleBox.height * cd0.titleBox.height);
+            return {
+              x: cd0.cx,
+              y: cd0.cy,
+              scale: cd0.trace.hole * cd0.r * 2 / textDiameter,
+              tx: 0,
+              ty: -cd0.titleBox.height / 2 + cd0.trace.title.font.size
+            };
+          }
+          function positionTitleOutside(cd0, plotSize) {
+            var scaleX2 = 1;
+            var scaleY2 = 1;
+            var maxPull;
+            var trace = cd0.trace;
+            var topMiddle = {
+              x: cd0.cx,
+              y: cd0.cy
+            };
+            var translate2 = {
+              tx: 0,
+              ty: 0
+            };
+            translate2.ty += trace.title.font.size;
+            maxPull = getMaxPull(trace);
+            if (trace.title.position.indexOf("top") !== -1) {
+              topMiddle.y -= (1 + maxPull) * cd0.r;
+              translate2.ty -= cd0.titleBox.height;
+            } else if (trace.title.position.indexOf("bottom") !== -1) {
+              topMiddle.y += (1 + maxPull) * cd0.r;
+            }
+            var rx = applyAspectRatio(cd0.r, cd0.trace.aspectratio);
+            var maxWidth = plotSize.w * (trace.domain.x[1] - trace.domain.x[0]) / 2;
+            if (trace.title.position.indexOf("left") !== -1) {
+              maxWidth = maxWidth + rx;
+              topMiddle.x -= (1 + maxPull) * rx;
+              translate2.tx += cd0.titleBox.width / 2;
+            } else if (trace.title.position.indexOf("center") !== -1) {
+              maxWidth *= 2;
+            } else if (trace.title.position.indexOf("right") !== -1) {
+              maxWidth = maxWidth + rx;
+              topMiddle.x += (1 + maxPull) * rx;
+              translate2.tx -= cd0.titleBox.width / 2;
+            }
+            scaleX2 = maxWidth / cd0.titleBox.width;
+            scaleY2 = getTitleSpace(cd0, plotSize) / cd0.titleBox.height;
+            return {
+              x: topMiddle.x,
+              y: topMiddle.y,
+              scale: Math.min(scaleX2, scaleY2),
+              tx: translate2.tx,
+              ty: translate2.ty
+            };
+          }
+          function applyAspectRatio(x2, aspectratio) {
+            return x2 / (aspectratio === void 0 ? 1 : aspectratio);
+          }
+          function getTitleSpace(cd0, plotSize) {
+            var trace = cd0.trace;
+            var pieBoxHeight = plotSize.h * (trace.domain.y[1] - trace.domain.y[0]);
+            return Math.min(cd0.titleBox.height, pieBoxHeight / 2);
+          }
+          function getMaxPull(trace) {
+            var maxPull = trace.pull;
+            if (!maxPull) return 0;
+            var j2;
+            if (Lib.isArrayOrTypedArray(maxPull)) {
+              maxPull = 0;
+              for (j2 = 0; j2 < trace.pull.length; j2++) {
+                if (trace.pull[j2] > maxPull) maxPull = trace.pull[j2];
+              }
+            }
+            return maxPull;
+          }
+          function scootLabels(quadrants, trace) {
+            var xHalf, yHalf, equatorFirst, farthestX, farthestY, xDiffSign, yDiffSign, thisQuad, oppositeQuad, wholeSide, i2, thisQuadOutside, firstOppositeOutsidePt;
+            function topFirst(a2, b2) {
+              return a2.pxmid[1] - b2.pxmid[1];
+            }
+            function bottomFirst(a2, b2) {
+              return b2.pxmid[1] - a2.pxmid[1];
+            }
+            function scootOneLabel(thisPt, prevPt2) {
+              if (!prevPt2) prevPt2 = {};
+              var prevOuterY = prevPt2.labelExtraY + (yHalf ? prevPt2.yLabelMax : prevPt2.yLabelMin);
+              var thisInnerY = yHalf ? thisPt.yLabelMin : thisPt.yLabelMax;
+              var thisOuterY = yHalf ? thisPt.yLabelMax : thisPt.yLabelMin;
+              var thisSliceOuterY = thisPt.cyFinal + farthestY(thisPt.px0[1], thisPt.px1[1]);
+              var newExtraY = prevOuterY - thisInnerY;
+              var xBuffer, i22, otherPt, otherOuterY, otherOuterX, newExtraX;
+              if (newExtraY * yDiffSign > 0) thisPt.labelExtraY = newExtraY;
+              if (!Lib.isArrayOrTypedArray(trace.pull)) return;
+              for (i22 = 0; i22 < wholeSide.length; i22++) {
+                otherPt = wholeSide[i22];
+                if (otherPt === thisPt || (helpers.castOption(trace.pull, thisPt.pts) || 0) >= (helpers.castOption(trace.pull, otherPt.pts) || 0)) {
+                  continue;
+                }
+                if ((thisPt.pxmid[1] - otherPt.pxmid[1]) * yDiffSign > 0) {
+                  otherOuterY = otherPt.cyFinal + farthestY(otherPt.px0[1], otherPt.px1[1]);
+                  newExtraY = otherOuterY - thisInnerY - thisPt.labelExtraY;
+                  if (newExtraY * yDiffSign > 0) thisPt.labelExtraY += newExtraY;
+                } else if ((thisOuterY + thisPt.labelExtraY - thisSliceOuterY) * yDiffSign > 0) {
+                  xBuffer = 3 * xDiffSign * Math.abs(i22 - wholeSide.indexOf(thisPt));
+                  otherOuterX = otherPt.cxFinal + farthestX(otherPt.px0[0], otherPt.px1[0]);
+                  newExtraX = otherOuterX + xBuffer - (thisPt.cxFinal + thisPt.pxmid[0]) - thisPt.labelExtraX;
+                  if (newExtraX * xDiffSign > 0) thisPt.labelExtraX += newExtraX;
+                }
+              }
+            }
+            for (yHalf = 0; yHalf < 2; yHalf++) {
+              equatorFirst = yHalf ? topFirst : bottomFirst;
+              farthestY = yHalf ? Math.max : Math.min;
+              yDiffSign = yHalf ? 1 : -1;
+              for (xHalf = 0; xHalf < 2; xHalf++) {
+                farthestX = xHalf ? Math.max : Math.min;
+                xDiffSign = xHalf ? 1 : -1;
+                thisQuad = quadrants[yHalf][xHalf];
+                thisQuad.sort(equatorFirst);
+                oppositeQuad = quadrants[1 - yHalf][xHalf];
+                wholeSide = oppositeQuad.concat(thisQuad);
+                thisQuadOutside = [];
+                for (i2 = 0; i2 < thisQuad.length; i2++) {
+                  if (thisQuad[i2].yLabelMid !== void 0) thisQuadOutside.push(thisQuad[i2]);
+                }
+                firstOppositeOutsidePt = false;
+                for (i2 = 0; yHalf && i2 < oppositeQuad.length; i2++) {
+                  if (oppositeQuad[i2].yLabelMid !== void 0) {
+                    firstOppositeOutsidePt = oppositeQuad[i2];
+                    break;
+                  }
+                }
+                for (i2 = 0; i2 < thisQuadOutside.length; i2++) {
+                  var prevPt = i2 && thisQuadOutside[i2 - 1];
+                  if (firstOppositeOutsidePt && !i2) prevPt = firstOppositeOutsidePt;
+                  scootOneLabel(thisQuadOutside[i2], prevPt);
+                }
+              }
+            }
+          }
+          function layoutAreas(cdModule, plotSize) {
+            var scaleGroups = [];
+            for (var i2 = 0; i2 < cdModule.length; i2++) {
+              var cd0 = cdModule[i2][0];
+              var trace = cd0.trace;
+              var domain = trace.domain;
+              var width = plotSize.w * (domain.x[1] - domain.x[0]);
+              var height = plotSize.h * (domain.y[1] - domain.y[0]);
+              if (trace.title.text && trace.title.position !== "middle center") {
+                height -= getTitleSpace(cd0, plotSize);
+              }
+              var rx = width / 2;
+              var ry = height / 2;
+              if (trace.type === "funnelarea" && !trace.scalegroup) {
+                ry /= trace.aspectratio;
+              }
+              cd0.r = Math.min(rx, ry) / (1 + getMaxPull(trace));
+              cd0.cx = plotSize.l + plotSize.w * (trace.domain.x[1] + trace.domain.x[0]) / 2;
+              cd0.cy = plotSize.t + plotSize.h * (1 - trace.domain.y[0]) - height / 2;
+              if (trace.title.text && trace.title.position.indexOf("bottom") !== -1) {
+                cd0.cy -= getTitleSpace(cd0, plotSize);
+              }
+              if (trace.scalegroup && scaleGroups.indexOf(trace.scalegroup) === -1) {
+                scaleGroups.push(trace.scalegroup);
+              }
+            }
+            groupScale(cdModule, scaleGroups);
+          }
+          function groupScale(cdModule, scaleGroups) {
+            var cd0, i2, trace;
+            for (var k2 = 0; k2 < scaleGroups.length; k2++) {
+              var min = Infinity;
+              var g2 = scaleGroups[k2];
+              for (i2 = 0; i2 < cdModule.length; i2++) {
+                cd0 = cdModule[i2][0];
+                trace = cd0.trace;
+                if (trace.scalegroup === g2) {
+                  var area;
+                  if (trace.type === "pie") {
+                    area = cd0.r * cd0.r;
+                  } else if (trace.type === "funnelarea") {
+                    var rx, ry;
+                    if (trace.aspectratio > 1) {
+                      rx = cd0.r;
+                      ry = rx / trace.aspectratio;
+                    } else {
+                      ry = cd0.r;
+                      rx = ry * trace.aspectratio;
+                    }
+                    rx *= (1 + trace.baseratio) / 2;
+                    area = rx * ry;
+                  }
+                  min = Math.min(min, area / cd0.vTotal);
+                }
+              }
+              for (i2 = 0; i2 < cdModule.length; i2++) {
+                cd0 = cdModule[i2][0];
+                trace = cd0.trace;
+                if (trace.scalegroup === g2) {
+                  var v2 = min * cd0.vTotal;
+                  if (trace.type === "funnelarea") {
+                    v2 /= (1 + trace.baseratio) / 2;
+                    v2 /= trace.aspectratio;
+                  }
+                  cd0.r = Math.sqrt(v2);
+                }
+              }
+            }
+          }
+          function setCoords(cd2) {
+            var cd0 = cd2[0];
+            var r2 = cd0.r;
+            var trace = cd0.trace;
+            var currentAngle = helpers.getRotationAngle(trace.rotation);
+            var angleFactor = 2 * Math.PI / cd0.vTotal;
+            var firstPt = "px0";
+            var lastPt = "px1";
+            var i2, cdi, currentCoords;
+            if (trace.direction === "counterclockwise") {
+              for (i2 = 0; i2 < cd2.length; i2++) {
+                if (!cd2[i2].hidden) break;
+              }
+              if (i2 === cd2.length) return;
+              currentAngle += angleFactor * cd2[i2].v;
+              angleFactor *= -1;
+              firstPt = "px1";
+              lastPt = "px0";
+            }
+            currentCoords = getCoords(r2, currentAngle);
+            for (i2 = 0; i2 < cd2.length; i2++) {
+              cdi = cd2[i2];
+              if (cdi.hidden) continue;
+              cdi[firstPt] = currentCoords;
+              cdi.startangle = currentAngle;
+              currentAngle += angleFactor * cdi.v / 2;
+              cdi.pxmid = getCoords(r2, currentAngle);
+              cdi.midangle = currentAngle;
+              currentAngle += angleFactor * cdi.v / 2;
+              currentCoords = getCoords(r2, currentAngle);
+              cdi.stopangle = currentAngle;
+              cdi[lastPt] = currentCoords;
+              cdi.largeArc = cdi.v > cd0.vTotal / 2 ? 1 : 0;
+              cdi.halfangle = Math.PI * Math.min(cdi.v / cd0.vTotal, 0.5);
+              cdi.ring = 1 - trace.hole;
+              cdi.rInscribed = getInscribedRadiusFraction(cdi, cd0);
+            }
+          }
+          function getCoords(r2, angle2) {
+            return [r2 * Math.sin(angle2), -r2 * Math.cos(angle2)];
+          }
+          function formatSliceLabel(gd2, pt2, cd0) {
+            var fullLayout = gd2._fullLayout;
+            var trace = cd0.trace;
+            var texttemplate = trace.texttemplate;
+            var textinfo = trace.textinfo;
+            if (!texttemplate && textinfo && textinfo !== "none") {
+              var parts = textinfo.split("+");
+              var hasFlag = function(flag) {
+                return parts.indexOf(flag) !== -1;
+              };
+              var hasLabel = hasFlag("label");
+              var hasText = hasFlag("text");
+              var hasValue = hasFlag("value");
+              var hasPercent = hasFlag("percent");
+              var separators = fullLayout.separators;
+              var text;
+              text = hasLabel ? [pt2.label] : [];
+              if (hasText) {
+                var tx = helpers.getFirstFilled(trace.text, pt2.pts);
+                if (isValidTextValue(tx)) text.push(tx);
+              }
+              if (hasValue) text.push(helpers.formatPieValue(pt2.v, separators));
+              if (hasPercent) text.push(helpers.formatPiePercent(pt2.v / cd0.vTotal, separators));
+              pt2.text = text.join("<br>");
+            }
+            function makeTemplateVariables(pt22) {
+              return {
+                label: pt22.label,
+                value: pt22.v,
+                valueLabel: helpers.formatPieValue(pt22.v, fullLayout.separators),
+                percent: pt22.v / cd0.vTotal,
+                percentLabel: helpers.formatPiePercent(pt22.v / cd0.vTotal, fullLayout.separators),
+                color: pt22.color,
+                text: pt22.text,
+                customdata: Lib.castOption(trace, pt22.i, "customdata")
+              };
+            }
+            if (texttemplate) {
+              var txt = Lib.castOption(trace, pt2.i, "texttemplate");
+              if (!txt) {
+                pt2.text = "";
+              } else {
+                var obj = makeTemplateVariables(pt2);
+                var ptTx = helpers.getFirstFilled(trace.text, pt2.pts);
+                if (isValidTextValue(ptTx) || ptTx === "") obj.text = ptTx;
+                pt2.text = Lib.texttemplateString({
+                  data: [obj, trace._meta],
+                  fallback: trace.texttemplatefallback,
+                  labels: obj,
+                  locale: gd2._fullLayout._d3locale,
+                  template: txt
+                });
+              }
+            }
+          }
+          function computeTransform(transform, textBB) {
+            var a2 = transform.rotate * Math.PI / 180;
+            var cosA = Math.cos(a2);
+            var sinA = Math.sin(a2);
+            var midX = (textBB.left + textBB.right) / 2;
+            var midY = (textBB.top + textBB.bottom) / 2;
+            transform.textX = midX * cosA - midY * sinA;
+            transform.textY = midX * sinA + midY * cosA;
+            transform.noCenter = true;
+          }
+          module2.exports = {
+            plot,
+            formatSliceLabel,
+            transformInsideText,
+            determineInsideTextFont,
+            positionTitleOutside,
+            prerenderTitles,
+            layoutAreas,
+            attachFxHandlers,
+            computeTransform
+          };
+        }
+      });
+      var require_style12 = __commonJS({
+        "src/traces/pie/style.js"(exports, module2) {
+          var d3 = require_d3();
+          var styleOne = require_style_one();
+          var resizeText = require_uniform_text().resizeText;
+          module2.exports = function style(gd2) {
+            var s2 = gd2._fullLayout._pielayer.selectAll(".trace");
+            resizeText(gd2, s2, "pie");
+            s2.each(function(cd2) {
+              var cd0 = cd2[0];
+              var trace = cd0.trace;
+              var traceSelection = d3.select(this);
+              traceSelection.style({ opacity: trace.opacity });
+              traceSelection.selectAll("path.surface").each(function(pt2) {
+                d3.select(this).call(styleOne, pt2, trace, gd2);
+              });
+            });
+          };
+        }
+      });
+      var require_base_plot = __commonJS({
+        "src/traces/pie/base_plot.js"(exports) {
+          var plots = require_plots();
+          exports.name = "pie";
+          exports.plot = function(gd2, traces, transitionOpts, makeOnCompleteCallback) {
+            plots.plotBasePlot(exports.name, gd2, traces, transitionOpts, makeOnCompleteCallback);
+          };
+          exports.clean = function(newFullData, newFullLayout, oldFullData, oldFullLayout) {
+            plots.cleanBasePlot(exports.name, newFullData, newFullLayout, oldFullData, oldFullLayout);
+          };
+        }
+      });
+      var require_pie = __commonJS({
+        "src/traces/pie/index.js"(exports, module2) {
+          module2.exports = {
+            attributes: require_attributes35(),
+            supplyDefaults: require_defaults31().supplyDefaults,
+            supplyLayoutDefaults: require_layout_defaults11(),
+            layoutAttributes: require_layout_attributes12(),
+            calc: require_calc16().calc,
+            crossTraceCalc: require_calc16().crossTraceCalc,
+            plot: require_plot12().plot,
+            style: require_style12(),
+            styleOne: require_style_one(),
+            moduleType: "trace",
+            name: "pie",
+            basePlotModule: require_base_plot(),
+            categories: ["pie-like", "pie", "showLegend"],
+            meta: {}
+          };
+        }
+      });
+      var require_pie2 = __commonJS({
+        "lib/pie.js"(exports, module2) {
+          module2.exports = require_pie();
+        }
+      });
+      var require_base_plot2 = __commonJS({
+        "src/traces/sunburst/base_plot.js"(exports) {
+          var plots = require_plots();
+          exports.name = "sunburst";
+          exports.plot = function(gd2, traces, transitionOpts, makeOnCompleteCallback) {
+            plots.plotBasePlot(exports.name, gd2, traces, transitionOpts, makeOnCompleteCallback);
+          };
+          exports.clean = function(newFullData, newFullLayout, oldFullData, oldFullLayout) {
+            plots.cleanBasePlot(exports.name, newFullData, newFullLayout, oldFullData, oldFullLayout);
+          };
+        }
+      });
+      var require_constants20 = __commonJS({
+        "src/traces/sunburst/constants.js"(exports, module2) {
+          module2.exports = {
+            CLICK_TRANSITION_TIME: 750,
+            CLICK_TRANSITION_EASING: "linear",
+            eventDataKeys: [
+              // string
+              "currentPath",
+              "root",
+              "entry",
+              // no need to add 'parent' here
+              // percentages i.e. ratios
+              "percentRoot",
+              "percentEntry",
+              "percentParent"
+            ]
+          };
+        }
+      });
+      var require_attributes36 = __commonJS({
+        "src/traces/sunburst/attributes.js"(exports, module2) {
+          var baseAttrs = require_attributes2();
+          var { hovertemplateAttrs, texttemplateAttrs, templatefallbackAttrs } = require_template_attributes();
+          var colorScaleAttrs = require_attributes8();
+          var domainAttrs = require_domain().attributes;
+          var pieAttrs = require_attributes35();
+          var constants = require_constants20();
+          var extendFlat = require_extend().extendFlat;
+          var pattern = require_attributes4().pattern;
+          module2.exports = {
+            labels: {
+              valType: "data_array",
+              editType: "calc"
+            },
+            parents: {
+              valType: "data_array",
+              editType: "calc"
+            },
+            values: {
+              valType: "data_array",
+              editType: "calc"
+            },
+            branchvalues: {
+              valType: "enumerated",
+              values: ["remainder", "total"],
+              dflt: "remainder",
+              editType: "calc"
+            },
+            count: {
+              valType: "flaglist",
+              flags: ["branches", "leaves"],
+              dflt: "leaves",
+              editType: "calc"
+            },
+            level: {
+              valType: "any",
+              editType: "plot",
+              anim: true
+            },
+            maxdepth: {
+              valType: "integer",
+              editType: "plot",
+              dflt: -1
+            },
+            marker: extendFlat(
+              {
+                colors: {
+                  valType: "data_array",
+                  editType: "calc"
+                },
+                // colorinheritance: {
+                //     valType: 'enumerated',
+                //     values: ['per-branch', 'per-label', false]
+                // },
+                line: {
+                  color: extendFlat({}, pieAttrs.marker.line.color, {
+                    dflt: null
+                  }),
+                  width: extendFlat({}, pieAttrs.marker.line.width, { dflt: 1 }),
+                  editType: "calc"
+                },
+                pattern,
+                editType: "calc"
+              },
+              colorScaleAttrs("marker", {
+                colorAttr: "colors",
+                anim: false
+                // TODO: set to anim: true?
+              })
+            ),
+            leaf: {
+              opacity: {
+                valType: "number",
+                editType: "style",
+                min: 0,
+                max: 1
+              },
+              editType: "plot"
+            },
+            text: pieAttrs.text,
+            textinfo: {
+              valType: "flaglist",
+              flags: ["label", "text", "value", "current path", "percent root", "percent entry", "percent parent"],
+              extras: ["none"],
+              editType: "plot"
+            },
+            // TODO: incorporate `label` and `value` in the eventData
+            texttemplate: texttemplateAttrs({ editType: "plot" }, { keys: constants.eventDataKeys.concat(["label", "value"]) }),
+            texttemplatefallback: templatefallbackAttrs({ editType: "plot" }),
+            hovertext: pieAttrs.hovertext,
+            hoverinfo: extendFlat({}, baseAttrs.hoverinfo, {
+              flags: ["label", "text", "value", "name", "current path", "percent root", "percent entry", "percent parent"],
+              dflt: "label+text+value+name"
+            }),
+            hovertemplate: hovertemplateAttrs({}, { keys: constants.eventDataKeys }),
+            hovertemplatefallback: templatefallbackAttrs(),
+            textfont: pieAttrs.textfont,
+            insidetextorientation: pieAttrs.insidetextorientation,
+            insidetextfont: pieAttrs.insidetextfont,
+            outsidetextfont: extendFlat({}, pieAttrs.outsidetextfont, {}),
+            rotation: {
+              valType: "angle",
+              dflt: 0,
+              editType: "plot"
+            },
+            sort: pieAttrs.sort,
+            root: {
+              color: {
+                valType: "color",
+                editType: "calc",
+                dflt: "rgba(0,0,0,0)"
+              },
+              editType: "calc"
+            },
+            domain: domainAttrs({ name: "sunburst", trace: true, editType: "calc" })
+          };
+        }
+      });
+      var require_layout_attributes13 = __commonJS({
+        "src/traces/sunburst/layout_attributes.js"(exports, module2) {
+          module2.exports = {
+            sunburstcolorway: {
+              valType: "colorlist",
+              editType: "calc"
+            },
+            extendsunburstcolors: {
+              valType: "boolean",
+              dflt: true,
+              editType: "calc"
+            }
+          };
+        }
+      });
+      var require_defaults32 = __commonJS({
+        "src/traces/sunburst/defaults.js"(exports, module2) {
+          var Lib = require_lib();
+          var attributes = require_attributes36();
+          var handleDomainDefaults = require_domain().defaults;
+          var handleText = require_defaults19().handleText;
+          var handleMarkerDefaults = require_defaults31().handleMarkerDefaults;
+          var Colorscale = require_colorscale();
+          var hasColorscale = Colorscale.hasColorscale;
+          var colorscaleDefaults = Colorscale.handleDefaults;
+          module2.exports = function supplyDefaults(traceIn, traceOut, defaultColor, layout) {
+            function coerce(attr, dflt) {
+              return Lib.coerce(traceIn, traceOut, attributes, attr, dflt);
+            }
+            var labels = coerce("labels");
+            var parents = coerce("parents");
+            if (!labels || !labels.length || !parents || !parents.length) {
+              traceOut.visible = false;
+              return;
+            }
+            var vals = coerce("values");
+            if (vals && vals.length) {
+              coerce("branchvalues");
+            } else {
+              coerce("count");
+            }
+            coerce("level");
+            coerce("maxdepth");
+            handleMarkerDefaults(traceIn, traceOut, layout, coerce);
+            var withColorscale = traceOut._hasColorscale = hasColorscale(traceIn, "marker", "colors") || (traceIn.marker || {}).coloraxis;
+            if (withColorscale) {
+              colorscaleDefaults(traceIn, traceOut, layout, coerce, { prefix: "marker.", cLetter: "c" });
+            }
+            coerce("leaf.opacity", withColorscale ? 1 : 0.7);
+            var text = coerce("text");
+            coerce("texttemplate");
+            coerce("texttemplatefallback");
+            if (!traceOut.texttemplate) coerce("textinfo", Lib.isArrayOrTypedArray(text) ? "text+label" : "label");
+            coerce("hovertext");
+            coerce("hovertemplate");
+            coerce("hovertemplatefallback");
+            var textposition = "auto";
+            handleText(traceIn, traceOut, layout, coerce, textposition, {
+              moduleHasSelected: false,
+              moduleHasUnselected: false,
+              moduleHasConstrain: false,
+              moduleHasCliponaxis: false,
+              moduleHasTextangle: false,
+              moduleHasInsideanchor: false
+            });
+            coerce("insidetextorientation");
+            coerce("sort");
+            coerce("rotation");
+            coerce("root.color");
+            handleDomainDefaults(traceOut, layout, coerce);
+            traceOut._length = null;
+          };
+        }
+      });
+      var require_layout_defaults12 = __commonJS({
+        "src/traces/sunburst/layout_defaults.js"(exports, module2) {
+          var Lib = require_lib();
+          var layoutAttributes = require_layout_attributes13();
+          module2.exports = function supplyLayoutDefaults(layoutIn, layoutOut) {
+            function coerce(attr, dflt) {
+              return Lib.coerce(layoutIn, layoutOut, layoutAttributes, attr, dflt);
+            }
+            coerce("sunburstcolorway", layoutOut.colorway);
+            coerce("extendsunburstcolors");
+          };
+        }
+      });
+      var require_d3_hierarchy = __commonJS({
+        "node_modules/d3-hierarchy/dist/d3-hierarchy.js"(exports, module2) {
+          (function(global2, factory2) {
+            typeof exports === "object" && typeof module2 !== "undefined" ? factory2(exports) : (global2 = global2 || self, factory2(global2.d3 = global2.d3 || {}));
+          })(exports, function(exports2) {
+            function defaultSeparation(a2, b2) {
+              return a2.parent === b2.parent ? 1 : 2;
+            }
+            function meanX(children) {
+              return children.reduce(meanXReduce, 0) / children.length;
+            }
+            function meanXReduce(x2, c2) {
+              return x2 + c2.x;
+            }
+            function maxY(children) {
+              return 1 + children.reduce(maxYReduce, 0);
+            }
+            function maxYReduce(y2, c2) {
+              return Math.max(y2, c2.y);
+            }
+            function leafLeft(node) {
+              var children;
+              while (children = node.children) node = children[0];
+              return node;
+            }
+            function leafRight(node) {
+              var children;
+              while (children = node.children) node = children[children.length - 1];
+              return node;
+            }
+            function cluster() {
+              var separation = defaultSeparation, dx = 1, dy = 1, nodeSize = false;
+              function cluster2(root) {
+                var previousNode, x2 = 0;
+                root.eachAfter(function(node) {
+                  var children = node.children;
+                  if (children) {
+                    node.x = meanX(children);
+                    node.y = maxY(children);
+                  } else {
+                    node.x = previousNode ? x2 += separation(node, previousNode) : 0;
+                    node.y = 0;
+                    previousNode = node;
+                  }
+                });
+                var left = leafLeft(root), right = leafRight(root), x0 = left.x - separation(left, right) / 2, x1 = right.x + separation(right, left) / 2;
+                return root.eachAfter(nodeSize ? function(node) {
+                  node.x = (node.x - root.x) * dx;
+                  node.y = (root.y - node.y) * dy;
+                } : function(node) {
+                  node.x = (node.x - x0) / (x1 - x0) * dx;
+                  node.y = (1 - (root.y ? node.y / root.y : 1)) * dy;
+                });
+              }
+              cluster2.separation = function(x2) {
+                return arguments.length ? (separation = x2, cluster2) : separation;
+              };
+              cluster2.size = function(x2) {
+                return arguments.length ? (nodeSize = false, dx = +x2[0], dy = +x2[1], cluster2) : nodeSize ? null : [dx, dy];
+              };
+              cluster2.nodeSize = function(x2) {
+                return arguments.length ? (nodeSize = true, dx = +x2[0], dy = +x2[1], cluster2) : nodeSize ? [dx, dy] : null;
+              };
+              return cluster2;
+            }
+            function count2(node) {
+              var sum = 0, children = node.children, i2 = children && children.length;
+              if (!i2) sum = 1;
+              else while (--i2 >= 0) sum += children[i2].value;
+              node.value = sum;
+            }
+            function node_count() {
+              return this.eachAfter(count2);
+            }
+            function node_each(callback) {
+              var node = this, current, next = [node], children, i2, n2;
+              do {
+                current = next.reverse(), next = [];
+                while (node = current.pop()) {
+                  callback(node), children = node.children;
+                  if (children) for (i2 = 0, n2 = children.length; i2 < n2; ++i2) {
+                    next.push(children[i2]);
+                  }
+                }
+              } while (next.length);
+              return this;
+            }
+            function node_eachBefore(callback) {
+              var node = this, nodes = [node], children, i2;
+              while (node = nodes.pop()) {
+                callback(node), children = node.children;
+                if (children) for (i2 = children.length - 1; i2 >= 0; --i2) {
+                  nodes.push(children[i2]);
+                }
+              }
+              return this;
+            }
+            function node_eachAfter(callback) {
+              var node = this, nodes = [node], next = [], children, i2, n2;
+              while (node = nodes.pop()) {
+                next.push(node), children = node.children;
+                if (children) for (i2 = 0, n2 = children.length; i2 < n2; ++i2) {
+                  nodes.push(children[i2]);
+                }
+              }
+              while (node = next.pop()) {
+                callback(node);
+              }
+              return this;
+            }
+            function node_sum(value) {
+              return this.eachAfter(function(node) {
+                var sum = +value(node.data) || 0, children = node.children, i2 = children && children.length;
+                while (--i2 >= 0) sum += children[i2].value;
+                node.value = sum;
+              });
+            }
+            function node_sort(compare) {
+              return this.eachBefore(function(node) {
+                if (node.children) {
+                  node.children.sort(compare);
+                }
+              });
+            }
+            function node_path(end) {
+              var start = this, ancestor = leastCommonAncestor(start, end), nodes = [start];
+              while (start !== ancestor) {
+                start = start.parent;
+                nodes.push(start);
+              }
+              var k2 = nodes.length;
+              while (end !== ancestor) {
+                nodes.splice(k2, 0, end);
+                end = end.parent;
+              }
+              return nodes;
+            }
+            function leastCommonAncestor(a2, b2) {
+              if (a2 === b2) return a2;
+              var aNodes = a2.ancestors(), bNodes = b2.ancestors(), c2 = null;
+              a2 = aNodes.pop();
+              b2 = bNodes.pop();
+              while (a2 === b2) {
+                c2 = a2;
+                a2 = aNodes.pop();
+                b2 = bNodes.pop();
+              }
+              return c2;
+            }
+            function node_ancestors() {
+              var node = this, nodes = [node];
+              while (node = node.parent) {
+                nodes.push(node);
+              }
+              return nodes;
+            }
+            function node_descendants() {
+              var nodes = [];
+              this.each(function(node) {
+                nodes.push(node);
+              });
+              return nodes;
+            }
+            function node_leaves() {
+              var leaves = [];
+              this.eachBefore(function(node) {
+                if (!node.children) {
+                  leaves.push(node);
+                }
+              });
+              return leaves;
+            }
+            function node_links() {
+              var root = this, links = [];
+              root.each(function(node) {
+                if (node !== root) {
+                  links.push({ source: node.parent, target: node });
+                }
+              });
+              return links;
+            }
+            function hierarchy(data, children) {
+              var root = new Node(data), valued = +data.value && (root.value = data.value), node, nodes = [root], child, childs, i2, n2;
+              if (children == null) children = defaultChildren;
+              while (node = nodes.pop()) {
+                if (valued) node.value = +node.data.value;
+                if ((childs = children(node.data)) && (n2 = childs.length)) {
+                  node.children = new Array(n2);
+                  for (i2 = n2 - 1; i2 >= 0; --i2) {
+                    nodes.push(child = node.children[i2] = new Node(childs[i2]));
+                    child.parent = node;
+                    child.depth = node.depth + 1;
+                  }
+                }
+              }
+              return root.eachBefore(computeHeight);
+            }
+            function node_copy() {
+              return hierarchy(this).eachBefore(copyData);
+            }
+            function defaultChildren(d2) {
+              return d2.children;
+            }
+            function copyData(node) {
+              node.data = node.data.data;
+            }
+            function computeHeight(node) {
+              var height = 0;
+              do
+                node.height = height;
+              while ((node = node.parent) && node.height < ++height);
+            }
+            function Node(data) {
+              this.data = data;
+              this.depth = this.height = 0;
+              this.parent = null;
+            }
+            Node.prototype = hierarchy.prototype = {
+              constructor: Node,
+              count: node_count,
+              each: node_each,
+              eachAfter: node_eachAfter,
+              eachBefore: node_eachBefore,
+              sum: node_sum,
+              sort: node_sort,
+              path: node_path,
+              ancestors: node_ancestors,
+              descendants: node_descendants,
+              leaves: node_leaves,
+              links: node_links,
+              copy: node_copy
+            };
+            var slice = Array.prototype.slice;
+            function shuffle(array) {
+              var m2 = array.length, t4, i2;
+              while (m2) {
+                i2 = Math.random() * m2-- | 0;
+                t4 = array[m2];
+                array[m2] = array[i2];
+                array[i2] = t4;
+              }
+              return array;
+            }
+            function enclose(circles) {
+              var i2 = 0, n2 = (circles = shuffle(slice.call(circles))).length, B22 = [], p2, e2;
+              while (i2 < n2) {
+                p2 = circles[i2];
+                if (e2 && enclosesWeak(e2, p2)) ++i2;
+                else e2 = encloseBasis(B22 = extendBasis(B22, p2)), i2 = 0;
+              }
+              return e2;
+            }
+            function extendBasis(B22, p2) {
+              var i2, j2;
+              if (enclosesWeakAll(p2, B22)) return [p2];
+              for (i2 = 0; i2 < B22.length; ++i2) {
+                if (enclosesNot(p2, B22[i2]) && enclosesWeakAll(encloseBasis2(B22[i2], p2), B22)) {
+                  return [B22[i2], p2];
+                }
+              }
+              for (i2 = 0; i2 < B22.length - 1; ++i2) {
+                for (j2 = i2 + 1; j2 < B22.length; ++j2) {
+                  if (enclosesNot(encloseBasis2(B22[i2], B22[j2]), p2) && enclosesNot(encloseBasis2(B22[i2], p2), B22[j2]) && enclosesNot(encloseBasis2(B22[j2], p2), B22[i2]) && enclosesWeakAll(encloseBasis3(B22[i2], B22[j2], p2), B22)) {
+                    return [B22[i2], B22[j2], p2];
+                  }
+                }
+              }
+              throw new Error();
+            }
+            function enclosesNot(a2, b2) {
+              var dr = a2.r - b2.r, dx = b2.x - a2.x, dy = b2.y - a2.y;
+              return dr < 0 || dr * dr < dx * dx + dy * dy;
+            }
+            function enclosesWeak(a2, b2) {
+              var dr = a2.r - b2.r + 1e-6, dx = b2.x - a2.x, dy = b2.y - a2.y;
+              return dr > 0 && dr * dr > dx * dx + dy * dy;
+            }
+            function enclosesWeakAll(a2, B22) {
+              for (var i2 = 0; i2 < B22.length; ++i2) {
+                if (!enclosesWeak(a2, B22[i2])) {
+                  return false;
+                }
+              }
+              return true;
+            }
+            function encloseBasis(B22) {
+              switch (B22.length) {
+                case 1:
+                  return encloseBasis1(B22[0]);
+                case 2:
+                  return encloseBasis2(B22[0], B22[1]);
+                case 3:
+                  return encloseBasis3(B22[0], B22[1], B22[2]);
+              }
+            }
+            function encloseBasis1(a2) {
+              return {
+                x: a2.x,
+                y: a2.y,
+                r: a2.r
+              };
+            }
+            function encloseBasis2(a2, b2) {
+              var x1 = a2.x, y1 = a2.y, r1 = a2.r, x2 = b2.x, y2 = b2.y, r2 = b2.r, x21 = x2 - x1, y21 = y2 - y1, r21 = r2 - r1, l2 = Math.sqrt(x21 * x21 + y21 * y21);
+              return {
+                x: (x1 + x2 + x21 / l2 * r21) / 2,
+                y: (y1 + y2 + y21 / l2 * r21) / 2,
+                r: (l2 + r1 + r2) / 2
+              };
+            }
+            function encloseBasis3(a2, b2, c2) {
+              var x1 = a2.x, y1 = a2.y, r1 = a2.r, x2 = b2.x, y2 = b2.y, r2 = b2.r, x3 = c2.x, y3 = c2.y, r3 = c2.r, a22 = x1 - x2, a3 = x1 - x3, b22 = y1 - y2, b3 = y1 - y3, c22 = r2 - r1, c3 = r3 - r1, d1 = x1 * x1 + y1 * y1 - r1 * r1, d2 = d1 - x2 * x2 - y2 * y2 + r2 * r2, d3 = d1 - x3 * x3 - y3 * y3 + r3 * r3, ab2 = a3 * b22 - a22 * b3, xa = (b22 * d3 - b3 * d2) / (ab2 * 2) - x1, xb2 = (b3 * c22 - b22 * c3) / ab2, ya2 = (a3 * d2 - a22 * d3) / (ab2 * 2) - y1, yb2 = (a22 * c3 - a3 * c22) / ab2, A22 = xb2 * xb2 + yb2 * yb2 - 1, B22 = 2 * (r1 + xa * xb2 + ya2 * yb2), C22 = xa * xa + ya2 * ya2 - r1 * r1, r4 = -(A22 ? (B22 + Math.sqrt(B22 * B22 - 4 * A22 * C22)) / (2 * A22) : C22 / B22);
+              return {
+                x: x1 + xa + xb2 * r4,
+                y: y1 + ya2 + yb2 * r4,
+                r: r4
+              };
+            }
+            function place(b2, a2, c2) {
+              var dx = b2.x - a2.x, x2, a22, dy = b2.y - a2.y, y2, b22, d2 = dx * dx + dy * dy;
+              if (d2) {
+                a22 = a2.r + c2.r, a22 *= a22;
+                b22 = b2.r + c2.r, b22 *= b22;
+                if (a22 > b22) {
+                  x2 = (d2 + b22 - a22) / (2 * d2);
+                  y2 = Math.sqrt(Math.max(0, b22 / d2 - x2 * x2));
+                  c2.x = b2.x - x2 * dx - y2 * dy;
+                  c2.y = b2.y - x2 * dy + y2 * dx;
+                } else {
+                  x2 = (d2 + a22 - b22) / (2 * d2);
+                  y2 = Math.sqrt(Math.max(0, a22 / d2 - x2 * x2));
+                  c2.x = a2.x + x2 * dx - y2 * dy;
+                  c2.y = a2.y + x2 * dy + y2 * dx;
+                }
+              } else {
+                c2.x = a2.x + c2.r;
+                c2.y = a2.y;
+              }
+            }
+            function intersects(a2, b2) {
+              var dr = a2.r + b2.r - 1e-6, dx = b2.x - a2.x, dy = b2.y - a2.y;
+              return dr > 0 && dr * dr > dx * dx + dy * dy;
+            }
+            function score(node) {
+              var a2 = node._, b2 = node.next._, ab2 = a2.r + b2.r, dx = (a2.x * b2.r + b2.x * a2.r) / ab2, dy = (a2.y * b2.r + b2.y * a2.r) / ab2;
+              return dx * dx + dy * dy;
+            }
+            function Node$1(circle) {
+              this._ = circle;
+              this.next = null;
+              this.previous = null;
+            }
+            function packEnclose(circles) {
+              if (!(n2 = circles.length)) return 0;
+              var a2, b2, c2, n2, aa2, ca2, i2, j2, k2, sj2, sk2;
+              a2 = circles[0], a2.x = 0, a2.y = 0;
+              if (!(n2 > 1)) return a2.r;
+              b2 = circles[1], a2.x = -b2.r, b2.x = a2.r, b2.y = 0;
+              if (!(n2 > 2)) return a2.r + b2.r;
+              place(b2, a2, c2 = circles[2]);
+              a2 = new Node$1(a2), b2 = new Node$1(b2), c2 = new Node$1(c2);
+              a2.next = c2.previous = b2;
+              b2.next = a2.previous = c2;
+              c2.next = b2.previous = a2;
+              pack: for (i2 = 3; i2 < n2; ++i2) {
+                place(a2._, b2._, c2 = circles[i2]), c2 = new Node$1(c2);
+                j2 = b2.next, k2 = a2.previous, sj2 = b2._.r, sk2 = a2._.r;
+                do {
+                  if (sj2 <= sk2) {
+                    if (intersects(j2._, c2._)) {
+                      b2 = j2, a2.next = b2, b2.previous = a2, --i2;
+                      continue pack;
+                    }
+                    sj2 += j2._.r, j2 = j2.next;
+                  } else {
+                    if (intersects(k2._, c2._)) {
+                      a2 = k2, a2.next = b2, b2.previous = a2, --i2;
+                      continue pack;
+                    }
+                    sk2 += k2._.r, k2 = k2.previous;
+                  }
+                } while (j2 !== k2.next);
+                c2.previous = a2, c2.next = b2, a2.next = b2.previous = b2 = c2;
+                aa2 = score(a2);
+                while ((c2 = c2.next) !== b2) {
+                  if ((ca2 = score(c2)) < aa2) {
+                    a2 = c2, aa2 = ca2;
+                  }
+                }
+                b2 = a2.next;
+              }
+              a2 = [b2._], c2 = b2;
+              while ((c2 = c2.next) !== b2) a2.push(c2._);
+              c2 = enclose(a2);
+              for (i2 = 0; i2 < n2; ++i2) a2 = circles[i2], a2.x -= c2.x, a2.y -= c2.y;
+              return c2.r;
+            }
+            function siblings(circles) {
+              packEnclose(circles);
+              return circles;
+            }
+            function optional(f2) {
+              return f2 == null ? null : required(f2);
+            }
+            function required(f2) {
+              if (typeof f2 !== "function") throw new Error();
+              return f2;
+            }
+            function constantZero() {
+              return 0;
+            }
+            function constant(x2) {
+              return function() {
+                return x2;
+              };
+            }
+            function defaultRadius(d2) {
+              return Math.sqrt(d2.value);
+            }
+            function index() {
+              var radius = null, dx = 1, dy = 1, padding = constantZero;
+              function pack(root) {
+                root.x = dx / 2, root.y = dy / 2;
+                if (radius) {
+                  root.eachBefore(radiusLeaf(radius)).eachAfter(packChildren(padding, 0.5)).eachBefore(translateChild(1));
+                } else {
+                  root.eachBefore(radiusLeaf(defaultRadius)).eachAfter(packChildren(constantZero, 1)).eachAfter(packChildren(padding, root.r / Math.min(dx, dy))).eachBefore(translateChild(Math.min(dx, dy) / (2 * root.r)));
+                }
+                return root;
+              }
+              pack.radius = function(x2) {
+                return arguments.length ? (radius = optional(x2), pack) : radius;
+              };
+              pack.size = function(x2) {
+                return arguments.length ? (dx = +x2[0], dy = +x2[1], pack) : [dx, dy];
+              };
+              pack.padding = function(x2) {
+                return arguments.length ? (padding = typeof x2 === "function" ? x2 : constant(+x2), pack) : padding;
+              };
+              return pack;
+            }
+            function radiusLeaf(radius) {
+              return function(node) {
+                if (!node.children) {
+                  node.r = Math.max(0, +radius(node) || 0);
+                }
+              };
+            }
+            function packChildren(padding, k2) {
+              return function(node) {
+                if (children = node.children) {
+                  var children, i2, n2 = children.length, r2 = padding(node) * k2 || 0, e2;
+                  if (r2) for (i2 = 0; i2 < n2; ++i2) children[i2].r += r2;
+                  e2 = packEnclose(children);
+                  if (r2) for (i2 = 0; i2 < n2; ++i2) children[i2].r -= r2;
+                  node.r = e2 + r2;
+                }
+              };
+            }
+            function translateChild(k2) {
+              return function(node) {
+                var parent = node.parent;
+                node.r *= k2;
+                if (parent) {
+                  node.x = parent.x + k2 * node.x;
+                  node.y = parent.y + k2 * node.y;
+                }
+              };
+            }
+            function roundNode(node) {
+              node.x0 = Math.round(node.x0);
+              node.y0 = Math.round(node.y0);
+              node.x1 = Math.round(node.x1);
+              node.y1 = Math.round(node.y1);
+            }
+            function treemapDice(parent, x0, y0, x1, y1) {
+              var nodes = parent.children, node, i2 = -1, n2 = nodes.length, k2 = parent.value && (x1 - x0) / parent.value;
+              while (++i2 < n2) {
+                node = nodes[i2], node.y0 = y0, node.y1 = y1;
+                node.x0 = x0, node.x1 = x0 += node.value * k2;
+              }
+            }
+            function partition() {
+              var dx = 1, dy = 1, padding = 0, round2 = false;
+              function partition2(root) {
+                var n2 = root.height + 1;
+                root.x0 = root.y0 = padding;
+                root.x1 = dx;
+                root.y1 = dy / n2;
+                root.eachBefore(positionNode(dy, n2));
+                if (round2) root.eachBefore(roundNode);
+                return root;
+              }
+              function positionNode(dy2, n2) {
+                return function(node) {
+                  if (node.children) {
+                    treemapDice(node, node.x0, dy2 * (node.depth + 1) / n2, node.x1, dy2 * (node.depth + 2) / n2);
+                  }
+                  var x0 = node.x0, y0 = node.y0, x1 = node.x1 - padding, y1 = node.y1 - padding;
+                  if (x1 < x0) x0 = x1 = (x0 + x1) / 2;
+                  if (y1 < y0) y0 = y1 = (y0 + y1) / 2;
+                  node.x0 = x0;
+                  node.y0 = y0;
+                  node.x1 = x1;
+                  node.y1 = y1;
+                };
+              }
+              partition2.round = function(x2) {
+                return arguments.length ? (round2 = !!x2, partition2) : round2;
+              };
+              partition2.size = function(x2) {
+                return arguments.length ? (dx = +x2[0], dy = +x2[1], partition2) : [dx, dy];
+              };
+              partition2.padding = function(x2) {
+                return arguments.length ? (padding = +x2, partition2) : padding;
+              };
+              return partition2;
+            }
+            var keyPrefix = "$", preroot = { depth: -1 }, ambiguous = {};
+            function defaultId(d2) {
+              return d2.id;
+            }
+            function defaultParentId(d2) {
+              return d2.parentId;
+            }
+            function stratify() {
+              var id2 = defaultId, parentId = defaultParentId;
+              function stratify2(data) {
+                var d2, i2, n2 = data.length, root, parent, node, nodes = new Array(n2), nodeId, nodeKey, nodeByKey = {};
+                for (i2 = 0; i2 < n2; ++i2) {
+                  d2 = data[i2], node = nodes[i2] = new Node(d2);
+                  if ((nodeId = id2(d2, i2, data)) != null && (nodeId += "")) {
+                    nodeKey = keyPrefix + (node.id = nodeId);
+                    nodeByKey[nodeKey] = nodeKey in nodeByKey ? ambiguous : node;
+                  }
+                }
+                for (i2 = 0; i2 < n2; ++i2) {
+                  node = nodes[i2], nodeId = parentId(data[i2], i2, data);
+                  if (nodeId == null || !(nodeId += "")) {
+                    if (root) throw new Error("multiple roots");
+                    root = node;
+                  } else {
+                    parent = nodeByKey[keyPrefix + nodeId];
+                    if (!parent) throw new Error("missing: " + nodeId);
+                    if (parent === ambiguous) throw new Error("ambiguous: " + nodeId);
+                    if (parent.children) parent.children.push(node);
+                    else parent.children = [node];
+                    node.parent = parent;
+                  }
+                }
+                if (!root) throw new Error("no root");
+                root.parent = preroot;
+                root.eachBefore(function(node2) {
+                  node2.depth = node2.parent.depth + 1;
+                  --n2;
+                }).eachBefore(computeHeight);
+                root.parent = null;
+                if (n2 > 0) throw new Error("cycle");
+                return root;
+              }
+              stratify2.id = function(x2) {
+                return arguments.length ? (id2 = required(x2), stratify2) : id2;
+              };
+              stratify2.parentId = function(x2) {
+                return arguments.length ? (parentId = required(x2), stratify2) : parentId;
+              };
+              return stratify2;
+            }
+            function defaultSeparation$1(a2, b2) {
+              return a2.parent === b2.parent ? 1 : 2;
+            }
+            function nextLeft(v2) {
+              var children = v2.children;
+              return children ? children[0] : v2.t;
+            }
+            function nextRight(v2) {
+              var children = v2.children;
+              return children ? children[children.length - 1] : v2.t;
+            }
+            function moveSubtree(wm, wp, shift) {
+              var change = shift / (wp.i - wm.i);
+              wp.c -= change;
+              wp.s += shift;
+              wm.c += change;
+              wp.z += shift;
+              wp.m += shift;
+            }
+            function executeShifts(v2) {
+              var shift = 0, change = 0, children = v2.children, i2 = children.length, w2;
+              while (--i2 >= 0) {
+                w2 = children[i2];
+                w2.z += shift;
+                w2.m += shift;
+                shift += w2.s + (change += w2.c);
+              }
+            }
+            function nextAncestor(vim, v2, ancestor) {
+              return vim.a.parent === v2.parent ? vim.a : ancestor;
+            }
+            function TreeNode(node, i2) {
+              this._ = node;
+              this.parent = null;
+              this.children = null;
+              this.A = null;
+              this.a = this;
+              this.z = 0;
+              this.m = 0;
+              this.c = 0;
+              this.s = 0;
+              this.t = null;
+              this.i = i2;
+            }
+            TreeNode.prototype = Object.create(Node.prototype);
+            function treeRoot(root) {
+              var tree2 = new TreeNode(root, 0), node, nodes = [tree2], child, children, i2, n2;
+              while (node = nodes.pop()) {
+                if (children = node._.children) {
+                  node.children = new Array(n2 = children.length);
+                  for (i2 = n2 - 1; i2 >= 0; --i2) {
+                    nodes.push(child = node.children[i2] = new TreeNode(children[i2], i2));
+                    child.parent = node;
+                  }
+                }
+              }
+              (tree2.parent = new TreeNode(null, 0)).children = [tree2];
+              return tree2;
+            }
+            function tree() {
+              var separation = defaultSeparation$1, dx = 1, dy = 1, nodeSize = null;
+              function tree2(root) {
+                var t4 = treeRoot(root);
+                t4.eachAfter(firstWalk), t4.parent.m = -t4.z;
+                t4.eachBefore(secondWalk);
+                if (nodeSize) root.eachBefore(sizeNode);
+                else {
+                  var left = root, right = root, bottom = root;
+                  root.eachBefore(function(node) {
+                    if (node.x < left.x) left = node;
+                    if (node.x > right.x) right = node;
+                    if (node.depth > bottom.depth) bottom = node;
+                  });
+                  var s2 = left === right ? 1 : separation(left, right) / 2, tx = s2 - left.x, kx = dx / (right.x + s2 + tx), ky = dy / (bottom.depth || 1);
+                  root.eachBefore(function(node) {
+                    node.x = (node.x + tx) * kx;
+                    node.y = node.depth * ky;
+                  });
+                }
+                return root;
+              }
+              function firstWalk(v2) {
+                var children = v2.children, siblings2 = v2.parent.children, w2 = v2.i ? siblings2[v2.i - 1] : null;
+                if (children) {
+                  executeShifts(v2);
+                  var midpoint = (children[0].z + children[children.length - 1].z) / 2;
+                  if (w2) {
+                    v2.z = w2.z + separation(v2._, w2._);
+                    v2.m = v2.z - midpoint;
+                  } else {
+                    v2.z = midpoint;
+                  }
+                } else if (w2) {
+                  v2.z = w2.z + separation(v2._, w2._);
+                }
+                v2.parent.A = apportion(v2, w2, v2.parent.A || siblings2[0]);
+              }
+              function secondWalk(v2) {
+                v2._.x = v2.z + v2.parent.m;
+                v2.m += v2.parent.m;
+              }
+              function apportion(v2, w2, ancestor) {
+                if (w2) {
+                  var vip = v2, vop = v2, vim = w2, vom = vip.parent.children[0], sip = vip.m, sop = vop.m, sim = vim.m, som = vom.m, shift;
+                  while (vim = nextRight(vim), vip = nextLeft(vip), vim && vip) {
+                    vom = nextLeft(vom);
+                    vop = nextRight(vop);
+                    vop.a = v2;
+                    shift = vim.z + sim - vip.z - sip + separation(vim._, vip._);
+                    if (shift > 0) {
+                      moveSubtree(nextAncestor(vim, v2, ancestor), v2, shift);
+                      sip += shift;
+                      sop += shift;
+                    }
+                    sim += vim.m;
+                    sip += vip.m;
+                    som += vom.m;
+                    sop += vop.m;
+                  }
+                  if (vim && !nextRight(vop)) {
+                    vop.t = vim;
+                    vop.m += sim - sop;
+                  }
+                  if (vip && !nextLeft(vom)) {
+                    vom.t = vip;
+                    vom.m += sip - som;
+                    ancestor = v2;
+                  }
+                }
+                return ancestor;
+              }
+              function sizeNode(node) {
+                node.x *= dx;
+                node.y = node.depth * dy;
+              }
+              tree2.separation = function(x2) {
+                return arguments.length ? (separation = x2, tree2) : separation;
+              };
+              tree2.size = function(x2) {
+                return arguments.length ? (nodeSize = false, dx = +x2[0], dy = +x2[1], tree2) : nodeSize ? null : [dx, dy];
+              };
+              tree2.nodeSize = function(x2) {
+                return arguments.length ? (nodeSize = true, dx = +x2[0], dy = +x2[1], tree2) : nodeSize ? [dx, dy] : null;
+              };
+              return tree2;
+            }
+            function treemapSlice(parent, x0, y0, x1, y1) {
+              var nodes = parent.children, node, i2 = -1, n2 = nodes.length, k2 = parent.value && (y1 - y0) / parent.value;
+              while (++i2 < n2) {
+                node = nodes[i2], node.x0 = x0, node.x1 = x1;
+                node.y0 = y0, node.y1 = y0 += node.value * k2;
+              }
+            }
+            var phi = (1 + Math.sqrt(5)) / 2;
+            function squarifyRatio(ratio, parent, x0, y0, x1, y1) {
+              var rows = [], nodes = parent.children, row, nodeValue, i0 = 0, i1 = 0, n2 = nodes.length, dx, dy, value = parent.value, sumValue, minValue, maxValue, newRatio, minRatio, alpha, beta;
+              while (i0 < n2) {
+                dx = x1 - x0, dy = y1 - y0;
+                do
+                  sumValue = nodes[i1++].value;
+                while (!sumValue && i1 < n2);
+                minValue = maxValue = sumValue;
+                alpha = Math.max(dy / dx, dx / dy) / (value * ratio);
+                beta = sumValue * sumValue * alpha;
+                minRatio = Math.max(maxValue / beta, beta / minValue);
+                for (; i1 < n2; ++i1) {
+                  sumValue += nodeValue = nodes[i1].value;
+                  if (nodeValue < minValue) minValue = nodeValue;
+                  if (nodeValue > maxValue) maxValue = nodeValue;
+                  beta = sumValue * sumValue * alpha;
+                  newRatio = Math.max(maxValue / beta, beta / minValue);
+                  if (newRatio > minRatio) {
+                    sumValue -= nodeValue;
+                    break;
+                  }
+                  minRatio = newRatio;
+                }
+                rows.push(row = { value: sumValue, dice: dx < dy, children: nodes.slice(i0, i1) });
+                if (row.dice) treemapDice(row, x0, y0, x1, value ? y0 += dy * sumValue / value : y1);
+                else treemapSlice(row, x0, y0, value ? x0 += dx * sumValue / value : x1, y1);
+                value -= sumValue, i0 = i1;
+              }
+              return rows;
+            }
+            var squarify = function custom(ratio) {
+              function squarify2(parent, x0, y0, x1, y1) {
+                squarifyRatio(ratio, parent, x0, y0, x1, y1);
+              }
+              squarify2.ratio = function(x2) {
+                return custom((x2 = +x2) > 1 ? x2 : 1);
+              };
+              return squarify2;
+            }(phi);
+            function index$1() {
+              var tile = squarify, round2 = false, dx = 1, dy = 1, paddingStack = [0], paddingInner = constantZero, paddingTop = constantZero, paddingRight = constantZero, paddingBottom = constantZero, paddingLeft = constantZero;
+              function treemap(root) {
+                root.x0 = root.y0 = 0;
+                root.x1 = dx;
+                root.y1 = dy;
+                root.eachBefore(positionNode);
+                paddingStack = [0];
+                if (round2) root.eachBefore(roundNode);
+                return root;
+              }
+              function positionNode(node) {
+                var p2 = paddingStack[node.depth], x0 = node.x0 + p2, y0 = node.y0 + p2, x1 = node.x1 - p2, y1 = node.y1 - p2;
+                if (x1 < x0) x0 = x1 = (x0 + x1) / 2;
+                if (y1 < y0) y0 = y1 = (y0 + y1) / 2;
+                node.x0 = x0;
+                node.y0 = y0;
+                node.x1 = x1;
+                node.y1 = y1;
+                if (node.children) {
+                  p2 = paddingStack[node.depth + 1] = paddingInner(node) / 2;
+                  x0 += paddingLeft(node) - p2;
+                  y0 += paddingTop(node) - p2;
+                  x1 -= paddingRight(node) - p2;
+                  y1 -= paddingBottom(node) - p2;
+                  if (x1 < x0) x0 = x1 = (x0 + x1) / 2;
+                  if (y1 < y0) y0 = y1 = (y0 + y1) / 2;
+                  tile(node, x0, y0, x1, y1);
+                }
+              }
+              treemap.round = function(x2) {
+                return arguments.length ? (round2 = !!x2, treemap) : round2;
+              };
+              treemap.size = function(x2) {
+                return arguments.length ? (dx = +x2[0], dy = +x2[1], treemap) : [dx, dy];
+              };
+              treemap.tile = function(x2) {
+                return arguments.length ? (tile = required(x2), treemap) : tile;
+              };
+              treemap.padding = function(x2) {
+                return arguments.length ? treemap.paddingInner(x2).paddingOuter(x2) : treemap.paddingInner();
+              };
+              treemap.paddingInner = function(x2) {
+                return arguments.length ? (paddingInner = typeof x2 === "function" ? x2 : constant(+x2), treemap) : paddingInner;
+              };
+              treemap.paddingOuter = function(x2) {
+                return arguments.length ? treemap.paddingTop(x2).paddingRight(x2).paddingBottom(x2).paddingLeft(x2) : treemap.paddingTop();
+              };
+              treemap.paddingTop = function(x2) {
+                return arguments.length ? (paddingTop = typeof x2 === "function" ? x2 : constant(+x2), treemap) : paddingTop;
+              };
+              treemap.paddingRight = function(x2) {
+                return arguments.length ? (paddingRight = typeof x2 === "function" ? x2 : constant(+x2), treemap) : paddingRight;
+              };
+              treemap.paddingBottom = function(x2) {
+                return arguments.length ? (paddingBottom = typeof x2 === "function" ? x2 : constant(+x2), treemap) : paddingBottom;
+              };
+              treemap.paddingLeft = function(x2) {
+                return arguments.length ? (paddingLeft = typeof x2 === "function" ? x2 : constant(+x2), treemap) : paddingLeft;
+              };
+              return treemap;
+            }
+            function binary(parent, x0, y0, x1, y1) {
+              var nodes = parent.children, i2, n2 = nodes.length, sum, sums = new Array(n2 + 1);
+              for (sums[0] = sum = i2 = 0; i2 < n2; ++i2) {
+                sums[i2 + 1] = sum += nodes[i2].value;
+              }
+              partition2(0, n2, parent.value, x0, y0, x1, y1);
+              function partition2(i22, j2, value, x02, y02, x12, y12) {
+                if (i22 >= j2 - 1) {
+                  var node = nodes[i22];
+                  node.x0 = x02, node.y0 = y02;
+                  node.x1 = x12, node.y1 = y12;
+                  return;
+                }
+                var valueOffset = sums[i22], valueTarget = value / 2 + valueOffset, k2 = i22 + 1, hi2 = j2 - 1;
+                while (k2 < hi2) {
+                  var mid = k2 + hi2 >>> 1;
+                  if (sums[mid] < valueTarget) k2 = mid + 1;
+                  else hi2 = mid;
+                }
+                if (valueTarget - sums[k2 - 1] < sums[k2] - valueTarget && i22 + 1 < k2) --k2;
+                var valueLeft = sums[k2] - valueOffset, valueRight = value - valueLeft;
+                if (x12 - x02 > y12 - y02) {
+                  var xk2 = (x02 * valueRight + x12 * valueLeft) / value;
+                  partition2(i22, k2, valueLeft, x02, y02, xk2, y12);
+                  partition2(k2, j2, valueRight, xk2, y02, x12, y12);
+                } else {
+                  var yk2 = (y02 * valueRight + y12 * valueLeft) / value;
+                  partition2(i22, k2, valueLeft, x02, y02, x12, yk2);
+                  partition2(k2, j2, valueRight, x02, yk2, x12, y12);
+                }
+              }
+            }
+            function sliceDice(parent, x0, y0, x1, y1) {
+              (parent.depth & 1 ? treemapSlice : treemapDice)(parent, x0, y0, x1, y1);
+            }
+            var resquarify = function custom(ratio) {
+              function resquarify2(parent, x0, y0, x1, y1) {
+                if ((rows = parent._squarify) && rows.ratio === ratio) {
+                  var rows, row, nodes, i2, j2 = -1, n2, m2 = rows.length, value = parent.value;
+                  while (++j2 < m2) {
+                    row = rows[j2], nodes = row.children;
+                    for (i2 = row.value = 0, n2 = nodes.length; i2 < n2; ++i2) row.value += nodes[i2].value;
+                    if (row.dice) treemapDice(row, x0, y0, x1, y0 += (y1 - y0) * row.value / value);
+                    else treemapSlice(row, x0, y0, x0 += (x1 - x0) * row.value / value, y1);
+                    value -= row.value;
+                  }
+                } else {
+                  parent._squarify = rows = squarifyRatio(ratio, parent, x0, y0, x1, y1);
+                  rows.ratio = ratio;
+                }
+              }
+              resquarify2.ratio = function(x2) {
+                return custom((x2 = +x2) > 1 ? x2 : 1);
+              };
+              return resquarify2;
+            }(phi);
+            exports2.cluster = cluster;
+            exports2.hierarchy = hierarchy;
+            exports2.pack = index;
+            exports2.packEnclose = enclose;
+            exports2.packSiblings = siblings;
+            exports2.partition = partition;
+            exports2.stratify = stratify;
+            exports2.tree = tree;
+            exports2.treemap = index$1;
+            exports2.treemapBinary = binary;
+            exports2.treemapDice = treemapDice;
+            exports2.treemapResquarify = resquarify;
+            exports2.treemapSlice = treemapSlice;
+            exports2.treemapSliceDice = sliceDice;
+            exports2.treemapSquarify = squarify;
+            Object.defineProperty(exports2, "__esModule", { value: true });
+          });
+        }
+      });
+      var require_calc17 = __commonJS({
+        "src/traces/sunburst/calc.js"(exports) {
+          var d3Hierarchy = require_d3_hierarchy();
+          var isNumeric = require_fast_isnumeric();
+          var Lib = require_lib();
+          var makeColorScaleFn = require_colorscale().makeColorScaleFuncFromTrace;
+          var makePullColorFn = require_calc16().makePullColorFn;
+          var generateExtendedColors = require_calc16().generateExtendedColors;
+          var colorscaleCalc = require_colorscale().calc;
+          var ALMOST_EQUAL = require_numerical().ALMOST_EQUAL;
+          var sunburstExtendedColorWays = {};
+          var treemapExtendedColorWays = {};
+          var icicleExtendedColorWays = {};
+          exports.calc = function(gd2, trace) {
+            var fullLayout = gd2._fullLayout;
+            var ids = trace.ids;
+            var hasIds = Lib.isArrayOrTypedArray(ids);
+            var labels = trace.labels;
+            var parents = trace.parents;
+            var values = trace.values;
+            var hasValues = Lib.isArrayOrTypedArray(values);
+            var cd2 = [];
+            var parent2children = {};
+            var refs = {};
+            var addToLookup = function(parent, v2) {
+              if (parent2children[parent]) parent2children[parent].push(v2);
+              else parent2children[parent] = [v2];
+              refs[v2] = 1;
+            };
+            var isValidKey = function(k22) {
+              return k22 || typeof k22 === "number";
+            };
+            var isValidVal = function(i22) {
+              return !hasValues || isNumeric(values[i22]) && values[i22] >= 0;
+            };
+            var len2;
+            var isValid;
+            var getId2;
+            if (hasIds) {
+              len2 = Math.min(ids.length, parents.length);
+              isValid = function(i22) {
+                return isValidKey(ids[i22]) && isValidVal(i22);
+              };
+              getId2 = function(i22) {
+                return String(ids[i22]);
+              };
+            } else {
+              len2 = Math.min(labels.length, parents.length);
+              isValid = function(i22) {
+                return isValidKey(labels[i22]) && isValidVal(i22);
+              };
+              getId2 = function(i22) {
+                return String(labels[i22]);
+              };
+            }
+            if (hasValues) len2 = Math.min(len2, values.length);
+            for (var i2 = 0; i2 < len2; i2++) {
+              if (isValid(i2)) {
+                var id2 = getId2(i2);
+                var pid = isValidKey(parents[i2]) ? String(parents[i2]) : "";
+                var cdi = {
+                  i: i2,
+                  id: id2,
+                  pid,
+                  label: isValidKey(labels[i2]) ? String(labels[i2]) : ""
+                };
+                if (hasValues) cdi.v = +values[i2];
+                cd2.push(cdi);
+                addToLookup(pid, id2);
+              }
+            }
+            if (!parent2children[""]) {
+              var impliedRoots = [];
+              var k2;
+              for (k2 in parent2children) {
+                if (!refs[k2]) {
+                  impliedRoots.push(k2);
+                }
+              }
+              if (impliedRoots.length === 1) {
+                k2 = impliedRoots[0];
+                cd2.unshift({
+                  hasImpliedRoot: true,
+                  id: k2,
+                  pid: "",
+                  label: k2
+                });
+              } else {
+                return Lib.warn([
+                  "Multiple implied roots, cannot build",
+                  trace.type,
+                  "hierarchy of",
+                  trace.name + ".",
+                  "These roots include:",
+                  impliedRoots.join(", ")
+                ].join(" "));
+              }
+            } else if (parent2children[""].length > 1) {
+              var dummyId = Lib.randstr();
+              for (var j2 = 0; j2 < cd2.length; j2++) {
+                if (cd2[j2].pid === "") {
+                  cd2[j2].pid = dummyId;
+                }
+              }
+              cd2.unshift({
+                hasMultipleRoots: true,
+                id: dummyId,
+                pid: "",
+                label: ""
+              });
+            }
+            var root;
+            try {
+              root = d3Hierarchy.stratify().id(function(d2) {
+                return d2.id;
+              }).parentId(function(d2) {
+                return d2.pid;
+              })(cd2);
+            } catch (e2) {
+              return Lib.warn([
+                "Failed to build",
+                trace.type,
+                "hierarchy of",
+                trace.name + ".",
+                "Error:",
+                e2.message
+              ].join(" "));
+            }
+            var hierarchy = d3Hierarchy.hierarchy(root);
+            var failed = false;
+            if (hasValues) {
+              switch (trace.branchvalues) {
+                case "remainder":
+                  hierarchy.sum(function(d2) {
+                    return d2.data.v;
+                  });
+                  break;
+                case "total":
+                  hierarchy.each(function(d2) {
+                    var cdi2 = d2.data.data;
+                    var v2 = cdi2.v;
+                    if (d2.children) {
+                      var partialSum = d2.children.reduce(function(a2, c2) {
+                        return a2 + c2.data.data.v;
+                      }, 0);
+                      if (cdi2.hasImpliedRoot || cdi2.hasMultipleRoots) {
+                        v2 = partialSum;
+                      }
+                      if (v2 < partialSum * ALMOST_EQUAL) {
+                        failed = true;
+                        return Lib.warn([
+                          "Total value for node",
+                          d2.data.data.id,
+                          "of",
+                          trace.name,
+                          "is smaller than the sum of its children.",
+                          "\nparent value =",
+                          v2,
+                          "\nchildren sum =",
+                          partialSum
+                        ].join(" "));
+                      }
+                    }
+                    d2.value = v2;
+                  });
+                  break;
+              }
+            } else {
+              countDescendants(hierarchy, trace, {
+                branches: trace.count.indexOf("branches") !== -1,
+                leaves: trace.count.indexOf("leaves") !== -1
+              });
+            }
+            if (failed) return;
+            if (trace.sort) {
+              hierarchy.sort(function(a2, b2) {
+                return b2.value - a2.value;
+              });
+            }
+            var pullColor;
+            var scaleColor;
+            var colors = trace.marker.colors || [];
+            var hasColors = !!colors.length;
+            if (trace._hasColorscale) {
+              if (!hasColors) {
+                colors = hasValues ? trace.values : trace._values;
+              }
+              colorscaleCalc(gd2, trace, {
+                vals: colors,
+                containerStr: "marker",
+                cLetter: "c"
+              });
+              scaleColor = makeColorScaleFn(trace.marker);
+            } else {
+              pullColor = makePullColorFn(fullLayout["_" + trace.type + "colormap"]);
+            }
+            hierarchy.each(function(d2) {
+              var cdi2 = d2.data.data;
+              cdi2.color = trace._hasColorscale ? scaleColor(colors[cdi2.i]) : pullColor(colors[cdi2.i], cdi2.id);
+            });
+            cd2[0].hierarchy = hierarchy;
+            return cd2;
+          };
+          exports._runCrossTraceCalc = function(desiredType, gd2) {
+            var fullLayout = gd2._fullLayout;
+            var calcdata = gd2.calcdata;
+            var colorWay = fullLayout[desiredType + "colorway"];
+            var colorMap = fullLayout["_" + desiredType + "colormap"];
+            if (fullLayout["extend" + desiredType + "colors"]) {
+              colorWay = generateExtendedColors(
+                colorWay,
+                desiredType === "icicle" ? icicleExtendedColorWays : desiredType === "treemap" ? treemapExtendedColorWays : sunburstExtendedColorWays
+              );
+            }
+            var dfltColorCount = 0;
+            var rootColor;
+            function pickColor(d2) {
+              var cdi = d2.data.data;
+              var id2 = cdi.id;
+              if (cdi.color === false) {
+                if (colorMap[id2]) {
+                  cdi.color = colorMap[id2];
+                } else if (d2.parent) {
+                  if (d2.parent.parent) {
+                    cdi.color = d2.parent.data.data.color;
+                  } else {
+                    colorMap[id2] = cdi.color = colorWay[dfltColorCount % colorWay.length];
+                    dfltColorCount++;
+                  }
+                } else {
+                  cdi.color = rootColor;
+                }
+              }
+            }
+            for (var i2 = 0; i2 < calcdata.length; i2++) {
+              var cd2 = calcdata[i2];
+              var cd0 = cd2[0];
+              if (cd0.trace.type === desiredType && cd0.hierarchy) {
+                rootColor = cd0.trace.root.color;
+                cd0.hierarchy.each(pickColor);
+              }
+            }
+          };
+          exports.crossTraceCalc = function(gd2) {
+            return exports._runCrossTraceCalc("sunburst", gd2);
+          };
+          function countDescendants(node, trace, opts) {
+            var nChild = 0;
+            var children = node.children;
+            if (children) {
+              var len2 = children.length;
+              for (var i2 = 0; i2 < len2; i2++) {
+                nChild += countDescendants(children[i2], trace, opts);
+              }
+              if (opts.branches) nChild++;
+            } else {
+              if (opts.leaves) nChild++;
+            }
+            node.value = node.data.data.value = nChild;
+            if (!trace._values) trace._values = [];
+            trace._values[node.data.data.i] = nChild;
+            return nChild;
+          }
+        }
+      });
+      function define_default(constructor, factory2, prototype) {
+        constructor.prototype = factory2.prototype = prototype;
+        prototype.constructor = constructor;
+      }
+      function extend(parent, definition) {
+        var prototype = Object.create(parent.prototype);
+        for (var key in definition) prototype[key] = definition[key];
+        return prototype;
+      }
+      var init_define = __esm({
+        "node_modules/d3-color/src/define.js"() {
+        }
+      });
+      function Color() {
+      }
+      function color_formatHex() {
+        return this.rgb().formatHex();
+      }
+      function color_formatHex8() {
+        return this.rgb().formatHex8();
+      }
+      function color_formatHsl() {
+        return hslConvert(this).formatHsl();
+      }
+      function color_formatRgb() {
+        return this.rgb().formatRgb();
+      }
+      function color2(format) {
+        var m2, l2;
+        format = (format + "").trim().toLowerCase();
+        return (m2 = reHex.exec(format)) ? (l2 = m2[1].length, m2 = parseInt(m2[1], 16), l2 === 6 ? rgbn(m2) : l2 === 3 ? new Rgb(m2 >> 8 & 15 | m2 >> 4 & 240, m2 >> 4 & 15 | m2 & 240, (m2 & 15) << 4 | m2 & 15, 1) : l2 === 8 ? rgba(m2 >> 24 & 255, m2 >> 16 & 255, m2 >> 8 & 255, (m2 & 255) / 255) : l2 === 4 ? rgba(m2 >> 12 & 15 | m2 >> 8 & 240, m2 >> 8 & 15 | m2 >> 4 & 240, m2 >> 4 & 15 | m2 & 240, ((m2 & 15) << 4 | m2 & 15) / 255) : null) : (m2 = reRgbInteger.exec(format)) ? new Rgb(m2[1], m2[2], m2[3], 1) : (m2 = reRgbPercent.exec(format)) ? new Rgb(m2[1] * 255 / 100, m2[2] * 255 / 100, m2[3] * 255 / 100, 1) : (m2 = reRgbaInteger.exec(format)) ? rgba(m2[1], m2[2], m2[3], m2[4]) : (m2 = reRgbaPercent.exec(format)) ? rgba(m2[1] * 255 / 100, m2[2] * 255 / 100, m2[3] * 255 / 100, m2[4]) : (m2 = reHslPercent.exec(format)) ? hsla(m2[1], m2[2] / 100, m2[3] / 100, 1) : (m2 = reHslaPercent.exec(format)) ? hsla(m2[1], m2[2] / 100, m2[3] / 100, m2[4]) : named.hasOwnProperty(format) ? rgbn(named[format]) : format === "transparent" ? new Rgb(NaN, NaN, NaN, 0) : null;
+      }
+      function rgbn(n2) {
+        return new Rgb(n2 >> 16 & 255, n2 >> 8 & 255, n2 & 255, 1);
+      }
+      function rgba(r2, g2, b2, a2) {
+        if (a2 <= 0) r2 = g2 = b2 = NaN;
+        return new Rgb(r2, g2, b2, a2);
+      }
+      function rgbConvert(o2) {
+        if (!(o2 instanceof Color)) o2 = color2(o2);
+        if (!o2) return new Rgb();
+        o2 = o2.rgb();
+        return new Rgb(o2.r, o2.g, o2.b, o2.opacity);
+      }
+      function rgb(r2, g2, b2, opacity) {
+        return arguments.length === 1 ? rgbConvert(r2) : new Rgb(r2, g2, b2, opacity == null ? 1 : opacity);
+      }
+      function Rgb(r2, g2, b2, opacity) {
+        this.r = +r2;
+        this.g = +g2;
+        this.b = +b2;
+        this.opacity = +opacity;
+      }
+      function rgb_formatHex() {
+        return `#${hex(this.r)}${hex(this.g)}${hex(this.b)}`;
+      }
+      function rgb_formatHex8() {
+        return `#${hex(this.r)}${hex(this.g)}${hex(this.b)}${hex((isNaN(this.opacity) ? 1 : this.opacity) * 255)}`;
+      }
+      function rgb_formatRgb() {
+        const a2 = clampa(this.opacity);
+        return `${a2 === 1 ? "rgb(" : "rgba("}${clampi(this.r)}, ${clampi(this.g)}, ${clampi(this.b)}${a2 === 1 ? ")" : `, ${a2})`}`;
+      }
+      function clampa(opacity) {
+        return isNaN(opacity) ? 1 : Math.max(0, Math.min(1, opacity));
+      }
+      function clampi(value) {
+        return Math.max(0, Math.min(255, Math.round(value) || 0));
+      }
+      function hex(value) {
+        value = clampi(value);
+        return (value < 16 ? "0" : "") + value.toString(16);
+      }
+      function hsla(h2, s2, l2, a2) {
+        if (a2 <= 0) h2 = s2 = l2 = NaN;
+        else if (l2 <= 0 || l2 >= 1) h2 = s2 = NaN;
+        else if (s2 <= 0) h2 = NaN;
+        return new Hsl(h2, s2, l2, a2);
+      }
+      function hslConvert(o2) {
+        if (o2 instanceof Hsl) return new Hsl(o2.h, o2.s, o2.l, o2.opacity);
+        if (!(o2 instanceof Color)) o2 = color2(o2);
+        if (!o2) return new Hsl();
+        if (o2 instanceof Hsl) return o2;
+        o2 = o2.rgb();
+        var r2 = o2.r / 255, g2 = o2.g / 255, b2 = o2.b / 255, min = Math.min(r2, g2, b2), max = Math.max(r2, g2, b2), h2 = NaN, s2 = max - min, l2 = (max + min) / 2;
+        if (s2) {
+          if (r2 === max) h2 = (g2 - b2) / s2 + (g2 < b2) * 6;
+          else if (g2 === max) h2 = (b2 - r2) / s2 + 2;
+          else h2 = (r2 - g2) / s2 + 4;
+          s2 /= l2 < 0.5 ? max + min : 2 - max - min;
+          h2 *= 60;
+        } else {
+          s2 = l2 > 0 && l2 < 1 ? 0 : h2;
+        }
+        return new Hsl(h2, s2, l2, o2.opacity);
+      }
+      function hsl(h2, s2, l2, opacity) {
+        return arguments.length === 1 ? hslConvert(h2) : new Hsl(h2, s2, l2, opacity == null ? 1 : opacity);
+      }
+      function Hsl(h2, s2, l2, opacity) {
+        this.h = +h2;
+        this.s = +s2;
+        this.l = +l2;
+        this.opacity = +opacity;
+      }
+      function clamph(value) {
+        value = (value || 0) % 360;
+        return value < 0 ? value + 360 : value;
+      }
+      function clampt(value) {
+        return Math.max(0, Math.min(1, value || 0));
+      }
+      function hsl2rgb(h2, m1, m2) {
+        return (h2 < 60 ? m1 + (m2 - m1) * h2 / 60 : h2 < 180 ? m2 : h2 < 240 ? m1 + (m2 - m1) * (240 - h2) / 60 : m1) * 255;
+      }
+      var darker, brighter, reI, reN, reP, reHex, reRgbInteger, reRgbPercent, reRgbaInteger, reRgbaPercent, reHslPercent, reHslaPercent, named;
+      var init_color = __esm({
+        "node_modules/d3-color/src/color.js"() {
+          init_define();
+          darker = 0.7;
+          brighter = 1 / darker;
+          reI = "\\s*([+-]?\\d+)\\s*";
+          reN = "\\s*([+-]?(?:\\d*\\.)?\\d+(?:[eE][+-]?\\d+)?)\\s*";
+          reP = "\\s*([+-]?(?:\\d*\\.)?\\d+(?:[eE][+-]?\\d+)?)%\\s*";
+          reHex = /^#([0-9a-f]{3,8})$/;
+          reRgbInteger = new RegExp(`^rgb\\(${reI},${reI},${reI}\\)$`);
+          reRgbPercent = new RegExp(`^rgb\\(${reP},${reP},${reP}\\)$`);
+          reRgbaInteger = new RegExp(`^rgba\\(${reI},${reI},${reI},${reN}\\)$`);
+          reRgbaPercent = new RegExp(`^rgba\\(${reP},${reP},${reP},${reN}\\)$`);
+          reHslPercent = new RegExp(`^hsl\\(${reN},${reP},${reP}\\)$`);
+          reHslaPercent = new RegExp(`^hsla\\(${reN},${reP},${reP},${reN}\\)$`);
+          named = {
+            aliceblue: 15792383,
+            antiquewhite: 16444375,
+            aqua: 65535,
+            aquamarine: 8388564,
+            azure: 15794175,
+            beige: 16119260,
+            bisque: 16770244,
+            black: 0,
+            blanchedalmond: 16772045,
+            blue: 255,
+            blueviolet: 9055202,
+            brown: 10824234,
+            burlywood: 14596231,
+            cadetblue: 6266528,
+            chartreuse: 8388352,
+            chocolate: 13789470,
+            coral: 16744272,
+            cornflowerblue: 6591981,
+            cornsilk: 16775388,
+            crimson: 14423100,
+            cyan: 65535,
+            darkblue: 139,
+            darkcyan: 35723,
+            darkgoldenrod: 12092939,
+            darkgray: 11119017,
+            darkgreen: 25600,
+            darkgrey: 11119017,
+            darkkhaki: 12433259,
+            darkmagenta: 9109643,
+            darkolivegreen: 5597999,
+            darkorange: 16747520,
+            darkorchid: 10040012,
+            darkred: 9109504,
+            darksalmon: 15308410,
+            darkseagreen: 9419919,
+            darkslateblue: 4734347,
+            darkslategray: 3100495,
+            darkslategrey: 3100495,
+            darkturquoise: 52945,
+            darkviolet: 9699539,
+            deeppink: 16716947,
+            deepskyblue: 49151,
+            dimgray: 6908265,
+            dimgrey: 6908265,
+            dodgerblue: 2003199,
+            firebrick: 11674146,
+            floralwhite: 16775920,
+            forestgreen: 2263842,
+            fuchsia: 16711935,
+            gainsboro: 14474460,
+            ghostwhite: 16316671,
+            gold: 16766720,
+            goldenrod: 14329120,
+            gray: 8421504,
+            green: 32768,
+            greenyellow: 11403055,
+            grey: 8421504,
+            honeydew: 15794160,
+            hotpink: 16738740,
+            indianred: 13458524,
+            indigo: 4915330,
+            ivory: 16777200,
+            khaki: 15787660,
+            lavender: 15132410,
+            lavenderblush: 16773365,
+            lawngreen: 8190976,
+            lemonchiffon: 16775885,
+            lightblue: 11393254,
+            lightcoral: 15761536,
+            lightcyan: 14745599,
+            lightgoldenrodyellow: 16448210,
+            lightgray: 13882323,
+            lightgreen: 9498256,
+            lightgrey: 13882323,
+            lightpink: 16758465,
+            lightsalmon: 16752762,
+            lightseagreen: 2142890,
+            lightskyblue: 8900346,
+            lightslategray: 7833753,
+            lightslategrey: 7833753,
+            lightsteelblue: 11584734,
+            lightyellow: 16777184,
+            lime: 65280,
+            limegreen: 3329330,
+            linen: 16445670,
+            magenta: 16711935,
+            maroon: 8388608,
+            mediumaquamarine: 6737322,
+            mediumblue: 205,
+            mediumorchid: 12211667,
+            mediumpurple: 9662683,
+            mediumseagreen: 3978097,
+            mediumslateblue: 8087790,
+            mediumspringgreen: 64154,
+            mediumturquoise: 4772300,
+            mediumvioletred: 13047173,
+            midnightblue: 1644912,
+            mintcream: 16121850,
+            mistyrose: 16770273,
+            moccasin: 16770229,
+            navajowhite: 16768685,
+            navy: 128,
+            oldlace: 16643558,
+            olive: 8421376,
+            olivedrab: 7048739,
+            orange: 16753920,
+            orangered: 16729344,
+            orchid: 14315734,
+            palegoldenrod: 15657130,
+            palegreen: 10025880,
+            paleturquoise: 11529966,
+            palevioletred: 14381203,
+            papayawhip: 16773077,
+            peachpuff: 16767673,
+            peru: 13468991,
+            pink: 16761035,
+            plum: 14524637,
+            powderblue: 11591910,
+            purple: 8388736,
+            rebeccapurple: 6697881,
+            red: 16711680,
+            rosybrown: 12357519,
+            royalblue: 4286945,
+            saddlebrown: 9127187,
+            salmon: 16416882,
+            sandybrown: 16032864,
+            seagreen: 3050327,
+            seashell: 16774638,
+            sienna: 10506797,
+            silver: 12632256,
+            skyblue: 8900331,
+            slateblue: 6970061,
+            slategray: 7372944,
+            slategrey: 7372944,
+            snow: 16775930,
+            springgreen: 65407,
+            steelblue: 4620980,
+            tan: 13808780,
+            teal: 32896,
+            thistle: 14204888,
+            tomato: 16737095,
+            turquoise: 4251856,
+            violet: 15631086,
+            wheat: 16113331,
+            white: 16777215,
+            whitesmoke: 16119285,
+            yellow: 16776960,
+            yellowgreen: 10145074
+          };
+          define_default(Color, color2, {
+            copy(channels) {
+              return Object.assign(new this.constructor(), this, channels);
+            },
+            displayable() {
+              return this.rgb().displayable();
+            },
+            hex: color_formatHex,
+            // Deprecated! Use color.formatHex.
+            formatHex: color_formatHex,
+            formatHex8: color_formatHex8,
+            formatHsl: color_formatHsl,
+            formatRgb: color_formatRgb,
+            toString: color_formatRgb
+          });
+          define_default(Rgb, rgb, extend(Color, {
+            brighter(k2) {
+              k2 = k2 == null ? brighter : Math.pow(brighter, k2);
+              return new Rgb(this.r * k2, this.g * k2, this.b * k2, this.opacity);
+            },
+            darker(k2) {
+              k2 = k2 == null ? darker : Math.pow(darker, k2);
+              return new Rgb(this.r * k2, this.g * k2, this.b * k2, this.opacity);
+            },
+            rgb() {
+              return this;
+            },
+            clamp() {
+              return new Rgb(clampi(this.r), clampi(this.g), clampi(this.b), clampa(this.opacity));
+            },
+            displayable() {
+              return -0.5 <= this.r && this.r < 255.5 && (-0.5 <= this.g && this.g < 255.5) && (-0.5 <= this.b && this.b < 255.5) && (0 <= this.opacity && this.opacity <= 1);
+            },
+            hex: rgb_formatHex,
+            // Deprecated! Use color.formatHex.
+            formatHex: rgb_formatHex,
+            formatHex8: rgb_formatHex8,
+            formatRgb: rgb_formatRgb,
+            toString: rgb_formatRgb
+          }));
+          define_default(Hsl, hsl, extend(Color, {
+            brighter(k2) {
+              k2 = k2 == null ? brighter : Math.pow(brighter, k2);
+              return new Hsl(this.h, this.s, this.l * k2, this.opacity);
+            },
+            darker(k2) {
+              k2 = k2 == null ? darker : Math.pow(darker, k2);
+              return new Hsl(this.h, this.s, this.l * k2, this.opacity);
+            },
+            rgb() {
+              var h2 = this.h % 360 + (this.h < 0) * 360, s2 = isNaN(h2) || isNaN(this.s) ? 0 : this.s, l2 = this.l, m2 = l2 + (l2 < 0.5 ? l2 : 1 - l2) * s2, m1 = 2 * l2 - m2;
+              return new Rgb(
+                hsl2rgb(h2 >= 240 ? h2 - 240 : h2 + 120, m1, m2),
+                hsl2rgb(h2, m1, m2),
+                hsl2rgb(h2 < 120 ? h2 + 240 : h2 - 120, m1, m2),
+                this.opacity
+              );
+            },
+            clamp() {
+              return new Hsl(clamph(this.h), clampt(this.s), clampt(this.l), clampa(this.opacity));
+            },
+            displayable() {
+              return (0 <= this.s && this.s <= 1 || isNaN(this.s)) && (0 <= this.l && this.l <= 1) && (0 <= this.opacity && this.opacity <= 1);
+            },
+            formatHsl() {
+              const a2 = clampa(this.opacity);
+              return `${a2 === 1 ? "hsl(" : "hsla("}${clamph(this.h)}, ${clampt(this.s) * 100}%, ${clampt(this.l) * 100}%${a2 === 1 ? ")" : `, ${a2})`}`;
+            }
+          }));
+        }
+      });
+      var radians, degrees;
+      var init_math = __esm({
+        "node_modules/d3-color/src/math.js"() {
+          radians = Math.PI / 180;
+          degrees = 180 / Math.PI;
+        }
+      });
+      function labConvert(o2) {
+        if (o2 instanceof Lab) return new Lab(o2.l, o2.a, o2.b, o2.opacity);
+        if (o2 instanceof Hcl) return hcl2lab(o2);
+        if (!(o2 instanceof Rgb)) o2 = rgbConvert(o2);
+        var r2 = rgb2lrgb(o2.r), g2 = rgb2lrgb(o2.g), b2 = rgb2lrgb(o2.b), y2 = xyz2lab((0.2225045 * r2 + 0.7168786 * g2 + 0.0606169 * b2) / Yn), x2, z2;
+        if (r2 === g2 && g2 === b2) x2 = z2 = y2;
+        else {
+          x2 = xyz2lab((0.4360747 * r2 + 0.3850649 * g2 + 0.1430804 * b2) / Xn);
+          z2 = xyz2lab((0.0139322 * r2 + 0.0971045 * g2 + 0.7141733 * b2) / Zn);
+        }
+        return new Lab(116 * y2 - 16, 500 * (x2 - y2), 200 * (y2 - z2), o2.opacity);
+      }
+      function lab(l2, a2, b2, opacity) {
+        return arguments.length === 1 ? labConvert(l2) : new Lab(l2, a2, b2, opacity == null ? 1 : opacity);
+      }
+      function Lab(l2, a2, b2, opacity) {
+        this.l = +l2;
+        this.a = +a2;
+        this.b = +b2;
+        this.opacity = +opacity;
+      }
+      function xyz2lab(t4) {
+        return t4 > t3 ? Math.pow(t4, 1 / 3) : t4 / t2 + t0;
+      }
+      function lab2xyz(t4) {
+        return t4 > t1 ? t4 * t4 * t4 : t2 * (t4 - t0);
+      }
+      function lrgb2rgb(x2) {
+        return 255 * (x2 <= 31308e-7 ? 12.92 * x2 : 1.055 * Math.pow(x2, 1 / 2.4) - 0.055);
+      }
+      function rgb2lrgb(x2) {
+        return (x2 /= 255) <= 0.04045 ? x2 / 12.92 : Math.pow((x2 + 0.055) / 1.055, 2.4);
+      }
+      function hclConvert(o2) {
+        if (o2 instanceof Hcl) return new Hcl(o2.h, o2.c, o2.l, o2.opacity);
+        if (!(o2 instanceof Lab)) o2 = labConvert(o2);
+        if (o2.a === 0 && o2.b === 0) return new Hcl(NaN, 0 < o2.l && o2.l < 100 ? 0 : NaN, o2.l, o2.opacity);
+        var h2 = Math.atan2(o2.b, o2.a) * degrees;
+        return new Hcl(h2 < 0 ? h2 + 360 : h2, Math.sqrt(o2.a * o2.a + o2.b * o2.b), o2.l, o2.opacity);
+      }
+      function hcl(h2, c2, l2, opacity) {
+        return arguments.length === 1 ? hclConvert(h2) : new Hcl(h2, c2, l2, opacity == null ? 1 : opacity);
+      }
+      function Hcl(h2, c2, l2, opacity) {
+        this.h = +h2;
+        this.c = +c2;
+        this.l = +l2;
+        this.opacity = +opacity;
+      }
+      function hcl2lab(o2) {
+        if (isNaN(o2.h)) return new Lab(o2.l, 0, 0, o2.opacity);
+        var h2 = o2.h * radians;
+        return new Lab(o2.l, Math.cos(h2) * o2.c, Math.sin(h2) * o2.c, o2.opacity);
+      }
+      var K2, Xn, Yn, Zn, t0, t1, t2, t3;
+      var init_lab = __esm({
+        "node_modules/d3-color/src/lab.js"() {
+          init_define();
+          init_color();
+          init_math();
+          K2 = 18;
+          Xn = 0.96422;
+          Yn = 1;
+          Zn = 0.82521;
+          t0 = 4 / 29;
+          t1 = 6 / 29;
+          t2 = 3 * t1 * t1;
+          t3 = t1 * t1 * t1;
+          define_default(Lab, lab, extend(Color, {
+            brighter(k2) {
+              return new Lab(this.l + K2 * (k2 == null ? 1 : k2), this.a, this.b, this.opacity);
+            },
+            darker(k2) {
+              return new Lab(this.l - K2 * (k2 == null ? 1 : k2), this.a, this.b, this.opacity);
+            },
+            rgb() {
+              var y2 = (this.l + 16) / 116, x2 = isNaN(this.a) ? y2 : y2 + this.a / 500, z2 = isNaN(this.b) ? y2 : y2 - this.b / 200;
+              x2 = Xn * lab2xyz(x2);
+              y2 = Yn * lab2xyz(y2);
+              z2 = Zn * lab2xyz(z2);
+              return new Rgb(
+                lrgb2rgb(3.1338561 * x2 - 1.6168667 * y2 - 0.4906146 * z2),
+                lrgb2rgb(-0.9787684 * x2 + 1.9161415 * y2 + 0.033454 * z2),
+                lrgb2rgb(0.0719453 * x2 - 0.2289914 * y2 + 1.4052427 * z2),
+                this.opacity
+              );
+            }
+          }));
+          define_default(Hcl, hcl, extend(Color, {
+            brighter(k2) {
+              return new Hcl(this.h, this.c, this.l + K2 * (k2 == null ? 1 : k2), this.opacity);
+            },
+            darker(k2) {
+              return new Hcl(this.h, this.c, this.l - K2 * (k2 == null ? 1 : k2), this.opacity);
+            },
+            rgb() {
+              return hcl2lab(this).rgb();
+            }
+          }));
+        }
+      });
+      function cubehelixConvert(o2) {
+        if (o2 instanceof Cubehelix) return new Cubehelix(o2.h, o2.s, o2.l, o2.opacity);
+        if (!(o2 instanceof Rgb)) o2 = rgbConvert(o2);
+        var r2 = o2.r / 255, g2 = o2.g / 255, b2 = o2.b / 255, l2 = (BC_DA * b2 + ED * r2 - EB * g2) / (BC_DA + ED - EB), bl2 = b2 - l2, k2 = (E2 * (g2 - l2) - C2 * bl2) / D2, s2 = Math.sqrt(k2 * k2 + bl2 * bl2) / (E2 * l2 * (1 - l2)), h2 = s2 ? Math.atan2(k2, bl2) * degrees - 120 : NaN;
+        return new Cubehelix(h2 < 0 ? h2 + 360 : h2, s2, l2, o2.opacity);
+      }
+      function cubehelix(h2, s2, l2, opacity) {
+        return arguments.length === 1 ? cubehelixConvert(h2) : new Cubehelix(h2, s2, l2, opacity == null ? 1 : opacity);
+      }
+      function Cubehelix(h2, s2, l2, opacity) {
+        this.h = +h2;
+        this.s = +s2;
+        this.l = +l2;
+        this.opacity = +opacity;
+      }
+      var A2, B2, C2, D2, E2, ED, EB, BC_DA;
+      var init_cubehelix = __esm({
+        "node_modules/d3-color/src/cubehelix.js"() {
+          init_define();
+          init_color();
+          init_math();
+          A2 = -0.14861;
+          B2 = 1.78277;
+          C2 = -0.29227;
+          D2 = -0.90649;
+          E2 = 1.97294;
+          ED = E2 * D2;
+          EB = E2 * B2;
+          BC_DA = B2 * C2 - D2 * A2;
+          define_default(Cubehelix, cubehelix, extend(Color, {
+            brighter(k2) {
+              k2 = k2 == null ? brighter : Math.pow(brighter, k2);
+              return new Cubehelix(this.h, this.s, this.l * k2, this.opacity);
+            },
+            darker(k2) {
+              k2 = k2 == null ? darker : Math.pow(darker, k2);
+              return new Cubehelix(this.h, this.s, this.l * k2, this.opacity);
+            },
+            rgb() {
+              var h2 = isNaN(this.h) ? 0 : (this.h + 120) * radians, l2 = +this.l, a2 = isNaN(this.s) ? 0 : this.s * l2 * (1 - l2), cosh2 = Math.cos(h2), sinh2 = Math.sin(h2);
+              return new Rgb(
+                255 * (l2 + a2 * (A2 * cosh2 + B2 * sinh2)),
+                255 * (l2 + a2 * (C2 * cosh2 + D2 * sinh2)),
+                255 * (l2 + a2 * (E2 * cosh2)),
+                this.opacity
+              );
+            }
+          }));
+        }
+      });
+      var init_src = __esm({
+        "node_modules/d3-color/src/index.js"() {
+          init_color();
+          init_lab();
+          init_cubehelix();
+        }
+      });
+      function basis(t12, v0, v1, v2, v3) {
+        var t22 = t12 * t12, t32 = t22 * t12;
+        return ((1 - 3 * t12 + 3 * t22 - t32) * v0 + (4 - 6 * t22 + 3 * t32) * v1 + (1 + 3 * t12 + 3 * t22 - 3 * t32) * v2 + t32 * v3) / 6;
+      }
+      function basis_default(values) {
+        var n2 = values.length - 1;
+        return function(t4) {
+          var i2 = t4 <= 0 ? t4 = 0 : t4 >= 1 ? (t4 = 1, n2 - 1) : Math.floor(t4 * n2), v1 = values[i2], v2 = values[i2 + 1], v0 = i2 > 0 ? values[i2 - 1] : 2 * v1 - v2, v3 = i2 < n2 - 1 ? values[i2 + 2] : 2 * v2 - v1;
+          return basis((t4 - i2 / n2) * n2, v0, v1, v2, v3);
+        };
+      }
+      var init_basis = __esm({
+        "node_modules/d3-interpolate/src/basis.js"() {
+        }
+      });
+      function basisClosed_default(values) {
+        var n2 = values.length;
+        return function(t4) {
+          var i2 = Math.floor(((t4 %= 1) < 0 ? ++t4 : t4) * n2), v0 = values[(i2 + n2 - 1) % n2], v1 = values[i2 % n2], v2 = values[(i2 + 1) % n2], v3 = values[(i2 + 2) % n2];
+          return basis((t4 - i2 / n2) * n2, v0, v1, v2, v3);
+        };
+      }
+      var init_basisClosed = __esm({
+        "node_modules/d3-interpolate/src/basisClosed.js"() {
+          init_basis();
+        }
+      });
+      var constant_default;
+      var init_constant = __esm({
+        "node_modules/d3-interpolate/src/constant.js"() {
+          constant_default = (x2) => () => x2;
+        }
+      });
+      function linear(a2, d2) {
+        return function(t4) {
+          return a2 + t4 * d2;
+        };
+      }
+      function exponential(a2, b2, y2) {
+        return a2 = Math.pow(a2, y2), b2 = Math.pow(b2, y2) - a2, y2 = 1 / y2, function(t4) {
+          return Math.pow(a2 + t4 * b2, y2);
+        };
+      }
+      function hue(a2, b2) {
+        var d2 = b2 - a2;
+        return d2 ? linear(a2, d2 > 180 || d2 < -180 ? d2 - 360 * Math.round(d2 / 360) : d2) : constant_default(isNaN(a2) ? b2 : a2);
+      }
+      function gamma(y2) {
+        return (y2 = +y2) === 1 ? nogamma : function(a2, b2) {
+          return b2 - a2 ? exponential(a2, b2, y2) : constant_default(isNaN(a2) ? b2 : a2);
+        };
+      }
+      function nogamma(a2, b2) {
+        var d2 = b2 - a2;
+        return d2 ? linear(a2, d2) : constant_default(isNaN(a2) ? b2 : a2);
+      }
+      var init_color2 = __esm({
+        "node_modules/d3-interpolate/src/color.js"() {
+          init_constant();
+        }
+      });
+      function rgbSpline(spline) {
+        return function(colors) {
+          var n2 = colors.length, r2 = new Array(n2), g2 = new Array(n2), b2 = new Array(n2), i2, color22;
+          for (i2 = 0; i2 < n2; ++i2) {
+            color22 = rgb(colors[i2]);
+            r2[i2] = color22.r || 0;
+            g2[i2] = color22.g || 0;
+            b2[i2] = color22.b || 0;
+          }
+          r2 = spline(r2);
+          g2 = spline(g2);
+          b2 = spline(b2);
+          color22.opacity = 1;
+          return function(t4) {
+            color22.r = r2(t4);
+            color22.g = g2(t4);
+            color22.b = b2(t4);
+            return color22 + "";
+          };
+        };
+      }
+      var rgb_default, rgbBasis, rgbBasisClosed;
+      var init_rgb = __esm({
+        "node_modules/d3-interpolate/src/rgb.js"() {
+          init_src();
+          init_basis();
+          init_basisClosed();
+          init_color2();
+          rgb_default = function rgbGamma(y2) {
+            var color22 = gamma(y2);
+            function rgb2(start, end) {
+              var r2 = color22((start = rgb(start)).r, (end = rgb(end)).r), g2 = color22(start.g, end.g), b2 = color22(start.b, end.b), opacity = nogamma(start.opacity, end.opacity);
+              return function(t4) {
+                start.r = r2(t4);
+                start.g = g2(t4);
+                start.b = b2(t4);
+                start.opacity = opacity(t4);
+                return start + "";
+              };
+            }
+            rgb2.gamma = rgbGamma;
+            return rgb2;
+          }(1);
+          rgbBasis = rgbSpline(basis_default);
+          rgbBasisClosed = rgbSpline(basisClosed_default);
+        }
+      });
+      function numberArray_default(a2, b2) {
+        if (!b2) b2 = [];
+        var n2 = a2 ? Math.min(b2.length, a2.length) : 0, c2 = b2.slice(), i2;
+        return function(t4) {
+          for (i2 = 0; i2 < n2; ++i2) c2[i2] = a2[i2] * (1 - t4) + b2[i2] * t4;
+          return c2;
+        };
+      }
+      function isNumberArray2(x2) {
+        return ArrayBuffer.isView(x2) && !(x2 instanceof DataView);
+      }
+      var init_numberArray = __esm({
+        "node_modules/d3-interpolate/src/numberArray.js"() {
+        }
+      });
+      function array_default(a2, b2) {
+        return (isNumberArray2(b2) ? numberArray_default : genericArray)(a2, b2);
+      }
+      function genericArray(a2, b2) {
+        var nb2 = b2 ? b2.length : 0, na = a2 ? Math.min(nb2, a2.length) : 0, x2 = new Array(na), c2 = new Array(nb2), i2;
+        for (i2 = 0; i2 < na; ++i2) x2[i2] = value_default(a2[i2], b2[i2]);
+        for (; i2 < nb2; ++i2) c2[i2] = b2[i2];
+        return function(t4) {
+          for (i2 = 0; i2 < na; ++i2) c2[i2] = x2[i2](t4);
+          return c2;
+        };
+      }
+      var init_array = __esm({
+        "node_modules/d3-interpolate/src/array.js"() {
+          init_value();
+          init_numberArray();
+        }
+      });
+      function date_default(a2, b2) {
+        var d2 = /* @__PURE__ */ new Date();
+        return a2 = +a2, b2 = +b2, function(t4) {
+          return d2.setTime(a2 * (1 - t4) + b2 * t4), d2;
+        };
+      }
+      var init_date = __esm({
+        "node_modules/d3-interpolate/src/date.js"() {
+        }
+      });
+      function number_default(a2, b2) {
+        return a2 = +a2, b2 = +b2, function(t4) {
+          return a2 * (1 - t4) + b2 * t4;
+        };
+      }
+      var init_number = __esm({
+        "node_modules/d3-interpolate/src/number.js"() {
+        }
+      });
+      function object_default(a2, b2) {
+        var i2 = {}, c2 = {}, k2;
+        if (a2 === null || typeof a2 !== "object") a2 = {};
+        if (b2 === null || typeof b2 !== "object") b2 = {};
+        for (k2 in b2) {
+          if (k2 in a2) {
+            i2[k2] = value_default(a2[k2], b2[k2]);
+          } else {
+            c2[k2] = b2[k2];
+          }
+        }
+        return function(t4) {
+          for (k2 in i2) c2[k2] = i2[k2](t4);
+          return c2;
+        };
+      }
+      var init_object = __esm({
+        "node_modules/d3-interpolate/src/object.js"() {
+          init_value();
+        }
+      });
+      function zero(b2) {
+        return function() {
+          return b2;
+        };
+      }
+      function one(b2) {
+        return function(t4) {
+          return b2(t4) + "";
+        };
+      }
+      function string_default(a2, b2) {
+        var bi2 = reA.lastIndex = reB.lastIndex = 0, am, bm, bs, i2 = -1, s2 = [], q2 = [];
+        a2 = a2 + "", b2 = b2 + "";
+        while ((am = reA.exec(a2)) && (bm = reB.exec(b2))) {
+          if ((bs = bm.index) > bi2) {
+            bs = b2.slice(bi2, bs);
+            if (s2[i2]) s2[i2] += bs;
+            else s2[++i2] = bs;
+          }
+          if ((am = am[0]) === (bm = bm[0])) {
+            if (s2[i2]) s2[i2] += bm;
+            else s2[++i2] = bm;
+          } else {
+            s2[++i2] = null;
+            q2.push({ i: i2, x: number_default(am, bm) });
+          }
+          bi2 = reB.lastIndex;
+        }
+        if (bi2 < b2.length) {
+          bs = b2.slice(bi2);
+          if (s2[i2]) s2[i2] += bs;
+          else s2[++i2] = bs;
+        }
+        return s2.length < 2 ? q2[0] ? one(q2[0].x) : zero(b2) : (b2 = q2.length, function(t4) {
+          for (var i22 = 0, o2; i22 < b2; ++i22) s2[(o2 = q2[i22]).i] = o2.x(t4);
+          return s2.join("");
+        });
+      }
+      var reA, reB;
+      var init_string = __esm({
+        "node_modules/d3-interpolate/src/string.js"() {
+          init_number();
+          reA = /[-+]?(?:\d+\.?\d*|\.?\d+)(?:[eE][-+]?\d+)?/g;
+          reB = new RegExp(reA.source, "g");
+        }
+      });
+      function value_default(a2, b2) {
+        var t4 = typeof b2, c2;
+        return b2 == null || t4 === "boolean" ? constant_default(b2) : (t4 === "number" ? number_default : t4 === "string" ? (c2 = color2(b2)) ? (b2 = c2, rgb_default) : string_default : b2 instanceof color2 ? rgb_default : b2 instanceof Date ? date_default : isNumberArray2(b2) ? numberArray_default : Array.isArray(b2) ? genericArray : typeof b2.valueOf !== "function" && typeof b2.toString !== "function" || isNaN(b2) ? object_default : number_default)(a2, b2);
+      }
+      var init_value = __esm({
+        "node_modules/d3-interpolate/src/value.js"() {
+          init_src();
+          init_rgb();
+          init_array();
+          init_date();
+          init_number();
+          init_object();
+          init_string();
+          init_constant();
+          init_numberArray();
+        }
+      });
+      function discrete_default(range) {
+        var n2 = range.length;
+        return function(t4) {
+          return range[Math.max(0, Math.min(n2 - 1, Math.floor(t4 * n2)))];
+        };
+      }
+      var init_discrete = __esm({
+        "node_modules/d3-interpolate/src/discrete.js"() {
+        }
+      });
+      function hue_default(a2, b2) {
+        var i2 = hue(+a2, +b2);
+        return function(t4) {
+          var x2 = i2(t4);
+          return x2 - 360 * Math.floor(x2 / 360);
+        };
+      }
+      var init_hue = __esm({
+        "node_modules/d3-interpolate/src/hue.js"() {
+          init_color2();
+        }
+      });
+      function round_default(a2, b2) {
+        return a2 = +a2, b2 = +b2, function(t4) {
+          return Math.round(a2 * (1 - t4) + b2 * t4);
+        };
+      }
+      var init_round = __esm({
+        "node_modules/d3-interpolate/src/round.js"() {
+        }
+      });
+      function decompose_default(a2, b2, c2, d2, e2, f2) {
+        var scaleX2, scaleY2, skewX;
+        if (scaleX2 = Math.sqrt(a2 * a2 + b2 * b2)) a2 /= scaleX2, b2 /= scaleX2;
+        if (skewX = a2 * c2 + b2 * d2) c2 -= a2 * skewX, d2 -= b2 * skewX;
+        if (scaleY2 = Math.sqrt(c2 * c2 + d2 * d2)) c2 /= scaleY2, d2 /= scaleY2, skewX /= scaleY2;
+        if (a2 * d2 < b2 * c2) a2 = -a2, b2 = -b2, skewX = -skewX, scaleX2 = -scaleX2;
+        return {
+          translateX: e2,
+          translateY: f2,
+          rotate: Math.atan2(b2, a2) * degrees2,
+          skewX: Math.atan(skewX) * degrees2,
+          scaleX: scaleX2,
+          scaleY: scaleY2
+        };
+      }
+      var degrees2, identity2;
+      var init_decompose = __esm({
+        "node_modules/d3-interpolate/src/transform/decompose.js"() {
+          degrees2 = 180 / Math.PI;
+          identity2 = {
+            translateX: 0,
+            translateY: 0,
+            rotate: 0,
+            skewX: 0,
+            scaleX: 1,
+            scaleY: 1
+          };
+        }
+      });
+      function parseCss(value) {
+        const m2 = new (typeof DOMMatrix === "function" ? DOMMatrix : WebKitCSSMatrix)(value + "");
+        return m2.isIdentity ? identity2 : decompose_default(m2.a, m2.b, m2.c, m2.d, m2.e, m2.f);
+      }
+      function parseSvg(value) {
+        if (value == null) return identity2;
+        if (!svgNode) svgNode = document.createElementNS("http://www.w3.org/2000/svg", "g");
+        svgNode.setAttribute("transform", value);
+        if (!(value = svgNode.transform.baseVal.consolidate())) return identity2;
+        value = value.matrix;
+        return decompose_default(value.a, value.b, value.c, value.d, value.e, value.f);
+      }
+      var svgNode;
+      var init_parse = __esm({
+        "node_modules/d3-interpolate/src/transform/parse.js"() {
+          init_decompose();
+        }
+      });
+      function interpolateTransform(parse22, pxComma, pxParen, degParen) {
+        function pop(s2) {
+          return s2.length ? s2.pop() + " " : "";
+        }
+        function translate2(xa, ya2, xb2, yb2, s2, q2) {
+          if (xa !== xb2 || ya2 !== yb2) {
+            var i2 = s2.push("translate(", null, pxComma, null, pxParen);
+            q2.push({ i: i2 - 4, x: number_default(xa, xb2) }, { i: i2 - 2, x: number_default(ya2, yb2) });
+          } else if (xb2 || yb2) {
+            s2.push("translate(" + xb2 + pxComma + yb2 + pxParen);
+          }
+        }
+        function rotate2(a2, b2, s2, q2) {
+          if (a2 !== b2) {
+            if (a2 - b2 > 180) b2 += 360;
+            else if (b2 - a2 > 180) a2 += 360;
+            q2.push({ i: s2.push(pop(s2) + "rotate(", null, degParen) - 2, x: number_default(a2, b2) });
+          } else if (b2) {
+            s2.push(pop(s2) + "rotate(" + b2 + degParen);
+          }
+        }
+        function skewX(a2, b2, s2, q2) {
+          if (a2 !== b2) {
+            q2.push({ i: s2.push(pop(s2) + "skewX(", null, degParen) - 2, x: number_default(a2, b2) });
+          } else if (b2) {
+            s2.push(pop(s2) + "skewX(" + b2 + degParen);
+          }
+        }
+        function scale2(xa, ya2, xb2, yb2, s2, q2) {
+          if (xa !== xb2 || ya2 !== yb2) {
+            var i2 = s2.push(pop(s2) + "scale(", null, ",", null, ")");
+            q2.push({ i: i2 - 4, x: number_default(xa, xb2) }, { i: i2 - 2, x: number_default(ya2, yb2) });
+          } else if (xb2 !== 1 || yb2 !== 1) {
+            s2.push(pop(s2) + "scale(" + xb2 + "," + yb2 + ")");
+          }
+        }
+        return function(a2, b2) {
+          var s2 = [], q2 = [];
+          a2 = parse22(a2), b2 = parse22(b2);
+          translate2(a2.translateX, a2.translateY, b2.translateX, b2.translateY, s2, q2);
+          rotate2(a2.rotate, b2.rotate, s2, q2);
+          skewX(a2.skewX, b2.skewX, s2, q2);
+          scale2(a2.scaleX, a2.scaleY, b2.scaleX, b2.scaleY, s2, q2);
+          a2 = b2 = null;
+          return function(t4) {
+            var i2 = -1, n2 = q2.length, o2;
+            while (++i2 < n2) s2[(o2 = q2[i2]).i] = o2.x(t4);
+            return s2.join("");
+          };
+        };
+      }
+      var interpolateTransformCss, interpolateTransformSvg;
+      var init_transform = __esm({
+        "node_modules/d3-interpolate/src/transform/index.js"() {
+          init_number();
+          init_parse();
+          interpolateTransformCss = interpolateTransform(parseCss, "px, ", "px)", "deg)");
+          interpolateTransformSvg = interpolateTransform(parseSvg, ", ", ")", ")");
+        }
+      });
+      function cosh(x2) {
+        return ((x2 = Math.exp(x2)) + 1 / x2) / 2;
+      }
+      function sinh(x2) {
+        return ((x2 = Math.exp(x2)) - 1 / x2) / 2;
+      }
+      function tanh(x2) {
+        return ((x2 = Math.exp(2 * x2)) - 1) / (x2 + 1);
+      }
+      var epsilon2, zoom_default;
+      var init_zoom = __esm({
+        "node_modules/d3-interpolate/src/zoom.js"() {
+          epsilon2 = 1e-12;
+          zoom_default = function zoomRho(rho, rho2, rho4) {
+            function zoom(p0, p1) {
+              var ux0 = p0[0], uy0 = p0[1], w0 = p0[2], ux1 = p1[0], uy1 = p1[1], w1 = p1[2], dx = ux1 - ux0, dy = uy1 - uy0, d2 = dx * dx + dy * dy, i2, S2;
+              if (d2 < epsilon2) {
+                S2 = Math.log(w1 / w0) / rho;
+                i2 = function(t4) {
+                  return [
+                    ux0 + t4 * dx,
+                    uy0 + t4 * dy,
+                    w0 * Math.exp(rho * t4 * S2)
+                  ];
+                };
+              } else {
+                var d1 = Math.sqrt(d2), b0 = (w1 * w1 - w0 * w0 + rho4 * d2) / (2 * w0 * rho2 * d1), b1 = (w1 * w1 - w0 * w0 - rho4 * d2) / (2 * w1 * rho2 * d1), r0 = Math.log(Math.sqrt(b0 * b0 + 1) - b0), r1 = Math.log(Math.sqrt(b1 * b1 + 1) - b1);
+                S2 = (r1 - r0) / rho;
+                i2 = function(t4) {
+                  var s2 = t4 * S2, coshr0 = cosh(r0), u2 = w0 / (rho2 * d1) * (coshr0 * tanh(rho * s2 + r0) - sinh(r0));
+                  return [
+                    ux0 + u2 * dx,
+                    uy0 + u2 * dy,
+                    w0 * coshr0 / cosh(rho * s2 + r0)
+                  ];
+                };
+              }
+              i2.duration = S2 * 1e3 * rho / Math.SQRT2;
+              return i2;
+            }
+            zoom.rho = function(_2) {
+              var _1 = Math.max(1e-3, +_2), _22 = _1 * _1, _4 = _22 * _22;
+              return zoomRho(_1, _22, _4);
+            };
+            return zoom;
+          }(Math.SQRT2, 2, 4);
+        }
+      });
+      function hsl2(hue2) {
+        return function(start, end) {
+          var h2 = hue2((start = hsl(start)).h, (end = hsl(end)).h), s2 = nogamma(start.s, end.s), l2 = nogamma(start.l, end.l), opacity = nogamma(start.opacity, end.opacity);
+          return function(t4) {
+            start.h = h2(t4);
+            start.s = s2(t4);
+            start.l = l2(t4);
+            start.opacity = opacity(t4);
+            return start + "";
+          };
+        };
+      }
+      var hsl_default, hslLong;
+      var init_hsl = __esm({
+        "node_modules/d3-interpolate/src/hsl.js"() {
+          init_src();
+          init_color2();
+          hsl_default = hsl2(hue);
+          hslLong = hsl2(nogamma);
+        }
+      });
+      function lab2(start, end) {
+        var l2 = nogamma((start = lab(start)).l, (end = lab(end)).l), a2 = nogamma(start.a, end.a), b2 = nogamma(start.b, end.b), opacity = nogamma(start.opacity, end.opacity);
+        return function(t4) {
+          start.l = l2(t4);
+          start.a = a2(t4);
+          start.b = b2(t4);
+          start.opacity = opacity(t4);
+          return start + "";
+        };
+      }
+      var init_lab2 = __esm({
+        "node_modules/d3-interpolate/src/lab.js"() {
+          init_src();
+          init_color2();
+        }
+      });
+      function hcl2(hue2) {
+        return function(start, end) {
+          var h2 = hue2((start = hcl(start)).h, (end = hcl(end)).h), c2 = nogamma(start.c, end.c), l2 = nogamma(start.l, end.l), opacity = nogamma(start.opacity, end.opacity);
+          return function(t4) {
+            start.h = h2(t4);
+            start.c = c2(t4);
+            start.l = l2(t4);
+            start.opacity = opacity(t4);
+            return start + "";
+          };
+        };
+      }
+      var hcl_default, hclLong;
+      var init_hcl = __esm({
+        "node_modules/d3-interpolate/src/hcl.js"() {
+          init_src();
+          init_color2();
+          hcl_default = hcl2(hue);
+          hclLong = hcl2(nogamma);
+        }
+      });
+      function cubehelix2(hue2) {
+        return function cubehelixGamma(y2) {
+          y2 = +y2;
+          function cubehelix3(start, end) {
+            var h2 = hue2((start = cubehelix(start)).h, (end = cubehelix(end)).h), s2 = nogamma(start.s, end.s), l2 = nogamma(start.l, end.l), opacity = nogamma(start.opacity, end.opacity);
+            return function(t4) {
+              start.h = h2(t4);
+              start.s = s2(t4);
+              start.l = l2(Math.pow(t4, y2));
+              start.opacity = opacity(t4);
+              return start + "";
+            };
+          }
+          cubehelix3.gamma = cubehelixGamma;
+          return cubehelix3;
+        }(1);
+      }
+      var cubehelix_default, cubehelixLong;
+      var init_cubehelix2 = __esm({
+        "node_modules/d3-interpolate/src/cubehelix.js"() {
+          init_src();
+          init_color2();
+          cubehelix_default = cubehelix2(hue);
+          cubehelixLong = cubehelix2(nogamma);
+        }
+      });
+      function piecewise(interpolate, values) {
+        if (values === void 0) values = interpolate, interpolate = value_default;
+        var i2 = 0, n2 = values.length - 1, v2 = values[0], I2 = new Array(n2 < 0 ? 0 : n2);
+        while (i2 < n2) I2[i2] = interpolate(v2, v2 = values[++i2]);
+        return function(t4) {
+          var i22 = Math.max(0, Math.min(n2 - 1, Math.floor(t4 *= n2)));
+          return I2[i22](t4 - i22);
+        };
+      }
+      var init_piecewise = __esm({
+        "node_modules/d3-interpolate/src/piecewise.js"() {
+          init_value();
+        }
+      });
+      function quantize_default(interpolator, n2) {
+        var samples = new Array(n2);
+        for (var i2 = 0; i2 < n2; ++i2) samples[i2] = interpolator(i2 / (n2 - 1));
+        return samples;
+      }
+      var init_quantize = __esm({
+        "node_modules/d3-interpolate/src/quantize.js"() {
+        }
+      });
+      var src_exports = {};
+      __export(src_exports, {
+        interpolate: () => value_default,
+        interpolateArray: () => array_default,
+        interpolateBasis: () => basis_default,
+        interpolateBasisClosed: () => basisClosed_default,
+        interpolateCubehelix: () => cubehelix_default,
+        interpolateCubehelixLong: () => cubehelixLong,
+        interpolateDate: () => date_default,
+        interpolateDiscrete: () => discrete_default,
+        interpolateHcl: () => hcl_default,
+        interpolateHclLong: () => hclLong,
+        interpolateHsl: () => hsl_default,
+        interpolateHslLong: () => hslLong,
+        interpolateHue: () => hue_default,
+        interpolateLab: () => lab2,
+        interpolateNumber: () => number_default,
+        interpolateNumberArray: () => numberArray_default,
+        interpolateObject: () => object_default,
+        interpolateRgb: () => rgb_default,
+        interpolateRgbBasis: () => rgbBasis,
+        interpolateRgbBasisClosed: () => rgbBasisClosed,
+        interpolateRound: () => round_default,
+        interpolateString: () => string_default,
+        interpolateTransformCss: () => interpolateTransformCss,
+        interpolateTransformSvg: () => interpolateTransformSvg,
+        interpolateZoom: () => zoom_default,
+        piecewise: () => piecewise,
+        quantize: () => quantize_default
+      });
+      var init_src2 = __esm({
+        "node_modules/d3-interpolate/src/index.js"() {
+          init_value();
+          init_array();
+          init_basis();
+          init_basisClosed();
+          init_date();
+          init_discrete();
+          init_hue();
+          init_number();
+          init_numberArray();
+          init_object();
+          init_round();
+          init_string();
+          init_transform();
+          init_zoom();
+          init_rgb();
+          init_hsl();
+          init_lab2();
+          init_hcl();
+          init_cubehelix2();
+          init_piecewise();
+          init_quantize();
+        }
+      });
+      var require_fill_one2 = __commonJS({
+        "src/traces/sunburst/fill_one.js"(exports, module2) {
+          var Drawing = require_drawing();
+          var Color2 = require_color();
+          module2.exports = function fillOne(s2, pt2, trace, gd2, fadedColor) {
+            var cdi = pt2.data.data;
+            var ptNumber = cdi.i;
+            var color22 = fadedColor || cdi.color;
+            if (ptNumber >= 0) {
+              pt2.i = cdi.i;
+              var marker = trace.marker;
+              if (marker.pattern) {
+                if (!marker.colors || !marker.pattern.shape) {
+                  marker.color = color22;
+                  pt2.color = color22;
+                }
+              } else {
+                marker.color = color22;
+                pt2.color = color22;
+              }
+              Drawing.pointStyle(s2, trace, gd2, pt2);
+            } else {
+              Color2.fill(s2, color22);
+            }
+          };
+        }
+      });
+      var require_style13 = __commonJS({
+        "src/traces/sunburst/style.js"(exports, module2) {
+          var d3 = require_d3();
+          var Color2 = require_color();
+          var Lib = require_lib();
+          var resizeText = require_uniform_text().resizeText;
+          var fillOne = require_fill_one2();
+          function style(gd2) {
+            var s2 = gd2._fullLayout._sunburstlayer.selectAll(".trace");
+            resizeText(gd2, s2, "sunburst");
+            s2.each(function(cd2) {
+              var gTrace = d3.select(this);
+              var cd0 = cd2[0];
+              var trace = cd0.trace;
+              gTrace.style("opacity", trace.opacity);
+              gTrace.selectAll("path.surface").each(function(pt2) {
+                d3.select(this).call(styleOne, pt2, trace, gd2);
+              });
+            });
+          }
+          function styleOne(s2, pt2, trace, gd2) {
+            var cdi = pt2.data.data;
+            var isLeaf = !pt2.children;
+            var ptNumber = cdi.i;
+            var lineColor = Lib.castOption(trace, ptNumber, "marker.line.color") || Color2.defaultLine;
+            var lineWidth = Lib.castOption(trace, ptNumber, "marker.line.width") || 0;
+            s2.call(fillOne, pt2, trace, gd2).style("stroke-width", lineWidth).call(Color2.stroke, lineColor).style("opacity", isLeaf ? trace.leaf.opacity : null);
+          }
+          module2.exports = {
+            style,
+            styleOne
+          };
+        }
+      });
+      var require_helpers15 = __commonJS({
+        "src/traces/sunburst/helpers.js"(exports) {
+          var Lib = require_lib();
+          var Color2 = require_color();
+          var setCursor = require_setcursor();
+          var pieHelpers = require_helpers4();
+          exports.findEntryWithLevel = function(hierarchy, level) {
+            var out;
+            if (level) {
+              hierarchy.eachAfter(function(pt2) {
+                if (exports.getPtId(pt2) === level) {
+                  return out = pt2.copy();
+                }
+              });
+            }
+            return out || hierarchy;
+          };
+          exports.findEntryWithChild = function(hierarchy, childId) {
+            var out;
+            hierarchy.eachAfter(function(pt2) {
+              var children = pt2.children || [];
+              for (var i2 = 0; i2 < children.length; i2++) {
+                var child = children[i2];
+                if (exports.getPtId(child) === childId) {
+                  return out = pt2.copy();
+                }
+              }
+            });
+            return out || hierarchy;
+          };
+          exports.isEntry = function(pt2) {
+            return !pt2.parent;
+          };
+          exports.isLeaf = function(pt2) {
+            return !pt2.children;
+          };
+          exports.getPtId = function(pt2) {
+            return pt2.data.data.id;
+          };
+          exports.getPtLabel = function(pt2) {
+            return pt2.data.data.label;
+          };
+          exports.getValue = function(d2) {
+            return d2.value;
+          };
+          exports.isHierarchyRoot = function(pt2) {
+            return getParentId(pt2) === "";
+          };
+          exports.setSliceCursor = function(sliceTop, gd2, opts) {
+            var hide = opts.isTransitioning;
+            if (!hide) {
+              var pt2 = sliceTop.datum();
+              hide = opts.hideOnRoot && exports.isHierarchyRoot(pt2) || opts.hideOnLeaves && exports.isLeaf(pt2);
+            }
+            setCursor(sliceTop, hide ? null : "pointer");
+          };
+          function determineOutsideTextFont(trace, pt2, layoutFont) {
+            return {
+              color: exports.getOutsideTextFontKey("color", trace, pt2, layoutFont),
+              family: exports.getOutsideTextFontKey("family", trace, pt2, layoutFont),
+              size: exports.getOutsideTextFontKey("size", trace, pt2, layoutFont),
+              weight: exports.getOutsideTextFontKey("weight", trace, pt2, layoutFont),
+              style: exports.getOutsideTextFontKey("style", trace, pt2, layoutFont),
+              variant: exports.getOutsideTextFontKey("variant", trace, pt2, layoutFont),
+              textcase: exports.getOutsideTextFontKey("textcase", trace, pt2, layoutFont),
+              lineposition: exports.getOutsideTextFontKey("lineposition", trace, pt2, layoutFont),
+              shadow: exports.getOutsideTextFontKey("shadow", trace, pt2, layoutFont)
+            };
+          }
+          function determineInsideTextFont(trace, pt2, layoutFont, opts) {
+            var onPathbar = (opts || {}).onPathbar;
+            var cdi = pt2.data.data;
+            var ptNumber = cdi.i;
+            var customColor = Lib.castOption(
+              trace,
+              ptNumber,
+              (onPathbar ? "pathbar.textfont" : "insidetextfont") + ".color"
+            );
+            if (!customColor && trace._input.textfont) {
+              customColor = Lib.castOption(trace._input, ptNumber, "textfont.color");
+            }
+            return {
+              color: customColor || Color2.contrast(cdi.color),
+              family: exports.getInsideTextFontKey("family", trace, pt2, layoutFont, opts),
+              size: exports.getInsideTextFontKey("size", trace, pt2, layoutFont, opts),
+              weight: exports.getInsideTextFontKey("weight", trace, pt2, layoutFont, opts),
+              style: exports.getInsideTextFontKey("style", trace, pt2, layoutFont, opts),
+              variant: exports.getInsideTextFontKey("variant", trace, pt2, layoutFont, opts),
+              textcase: exports.getInsideTextFontKey("textcase", trace, pt2, layoutFont, opts),
+              lineposition: exports.getInsideTextFontKey("lineposition", trace, pt2, layoutFont, opts),
+              shadow: exports.getInsideTextFontKey("shadow", trace, pt2, layoutFont, opts)
+            };
+          }
+          exports.getInsideTextFontKey = function(keyStr, trace, pt2, layoutFont, opts) {
+            var onPathbar = (opts || {}).onPathbar;
+            var cont = onPathbar ? "pathbar.textfont" : "insidetextfont";
+            var ptNumber = pt2.data.data.i;
+            return Lib.castOption(trace, ptNumber, cont + "." + keyStr) || Lib.castOption(trace, ptNumber, "textfont." + keyStr) || layoutFont.size;
+          };
+          exports.getOutsideTextFontKey = function(keyStr, trace, pt2, layoutFont) {
+            var ptNumber = pt2.data.data.i;
+            return Lib.castOption(trace, ptNumber, "outsidetextfont." + keyStr) || Lib.castOption(trace, ptNumber, "textfont." + keyStr) || layoutFont.size;
+          };
+          exports.isOutsideText = function(trace, pt2) {
+            return !trace._hasColorscale && exports.isHierarchyRoot(pt2);
+          };
+          exports.determineTextFont = function(trace, pt2, layoutFont, opts) {
+            return exports.isOutsideText(trace, pt2) ? determineOutsideTextFont(trace, pt2, layoutFont) : determineInsideTextFont(trace, pt2, layoutFont, opts);
+          };
+          exports.hasTransition = function(transitionOpts) {
+            return !!(transitionOpts && transitionOpts.duration > 0);
+          };
+          exports.getMaxDepth = function(trace) {
+            return trace.maxdepth >= 0 ? trace.maxdepth : Infinity;
+          };
+          exports.isHeader = function(pt2, trace) {
+            return !(exports.isLeaf(pt2) || pt2.depth === trace._maxDepth - 1);
+          };
+          function getParentId(pt2) {
+            return pt2.data.data.pid;
+          }
+          exports.getParent = function(hierarchy, pt2) {
+            return exports.findEntryWithLevel(hierarchy, getParentId(pt2));
+          };
+          exports.listPath = function(d2, keyStr) {
+            var parent = d2.parent;
+            if (!parent) return [];
+            var list = keyStr ? [parent.data[keyStr]] : [parent];
+            return exports.listPath(parent, keyStr).concat(list);
+          };
+          exports.getPath = function(d2) {
+            return exports.listPath(d2, "label").join("/") + "/";
+          };
+          exports.formatValue = pieHelpers.formatPieValue;
+          exports.formatPercent = function(v2, separators) {
+            var tx = Lib.formatPercent(v2, 0);
+            if (tx === "0%") tx = pieHelpers.formatPiePercent(v2, separators);
+            return tx;
+          };
+        }
+      });
+      var require_fx2 = __commonJS({
+        "src/traces/sunburst/fx.js"(exports, module2) {
+          var d3 = require_d3();
+          var Registry = require_registry();
+          var appendArrayPointValue = require_helpers2().appendArrayPointValue;
+          var Fx = require_fx();
+          var Lib = require_lib();
+          var Events = require_events2();
+          var helpers = require_helpers15();
+          var pieHelpers = require_helpers4();
+          var formatValue2 = pieHelpers.formatPieValue;
+          module2.exports = function attachFxHandlers(sliceTop, entry, gd2, cd2, opts) {
+            var cd0 = cd2[0];
+            var trace = cd0.trace;
+            var hierarchy = cd0.hierarchy;
+            var isSunburst = trace.type === "sunburst";
+            var isTreemapOrIcicle = trace.type === "treemap" || trace.type === "icicle";
+            if (!("_hasHoverLabel" in trace)) trace._hasHoverLabel = false;
+            if (!("_hasHoverEvent" in trace)) trace._hasHoverEvent = false;
+            var onMouseOver = function(pt2) {
+              var fullLayoutNow = gd2._fullLayout;
+              if (gd2._dragging || fullLayoutNow.hovermode === false) return;
+              var traceNow = gd2._fullData[trace.index];
+              var cdi = pt2.data.data;
+              var ptNumber = cdi.i;
+              var isRoot = helpers.isHierarchyRoot(pt2);
+              var parent = helpers.getParent(hierarchy, pt2);
+              var val = helpers.getValue(pt2);
+              var _cast = function(astr) {
+                return Lib.castOption(traceNow, ptNumber, astr);
+              };
+              var hovertemplate = _cast("hovertemplate");
+              var hoverinfo = Fx.castHoverinfo(traceNow, fullLayoutNow, ptNumber);
+              var separators = fullLayoutNow.separators;
+              var eventData;
+              if (hovertemplate || hoverinfo && hoverinfo !== "none" && hoverinfo !== "skip") {
+                var hoverCenterX;
+                var hoverCenterY;
+                if (isSunburst) {
+                  hoverCenterX = cd0.cx + pt2.pxmid[0] * (1 - pt2.rInscribed);
+                  hoverCenterY = cd0.cy + pt2.pxmid[1] * (1 - pt2.rInscribed);
+                }
+                if (isTreemapOrIcicle) {
+                  hoverCenterX = pt2._hoverX;
+                  hoverCenterY = pt2._hoverY;
+                }
+                var hoverPt = {};
+                var parts = [];
+                var thisText = [];
+                var hasFlag = function(flag) {
+                  return parts.indexOf(flag) !== -1;
+                };
+                if (hoverinfo) {
+                  parts = hoverinfo === "all" ? traceNow._module.attributes.hoverinfo.flags : hoverinfo.split("+");
+                }
+                hoverPt.label = cdi.label;
+                if (hasFlag("label") && hoverPt.label) thisText.push(hoverPt.label);
+                if (cdi.hasOwnProperty("v")) {
+                  hoverPt.value = cdi.v;
+                  hoverPt.valueLabel = formatValue2(hoverPt.value, separators);
+                  if (hasFlag("value")) thisText.push(hoverPt.valueLabel);
+                }
+                hoverPt.currentPath = pt2.currentPath = helpers.getPath(pt2.data);
+                if (hasFlag("current path") && !isRoot) {
+                  thisText.push(hoverPt.currentPath);
+                }
+                var tx;
+                var allPercents = [];
+                var insertPercent = function() {
+                  if (allPercents.indexOf(tx) === -1) {
+                    thisText.push(tx);
+                    allPercents.push(tx);
+                  }
+                };
+                hoverPt.percentParent = pt2.percentParent = val / helpers.getValue(parent);
+                hoverPt.parent = pt2.parentString = helpers.getPtLabel(parent);
+                if (hasFlag("percent parent")) {
+                  tx = helpers.formatPercent(hoverPt.percentParent, separators) + " of " + hoverPt.parent;
+                  insertPercent();
+                }
+                hoverPt.percentEntry = pt2.percentEntry = val / helpers.getValue(entry);
+                hoverPt.entry = pt2.entry = helpers.getPtLabel(entry);
+                if (hasFlag("percent entry") && !isRoot && !pt2.onPathbar) {
+                  tx = helpers.formatPercent(hoverPt.percentEntry, separators) + " of " + hoverPt.entry;
+                  insertPercent();
+                }
+                hoverPt.percentRoot = pt2.percentRoot = val / helpers.getValue(hierarchy);
+                hoverPt.root = pt2.root = helpers.getPtLabel(hierarchy);
+                if (hasFlag("percent root") && !isRoot) {
+                  tx = helpers.formatPercent(hoverPt.percentRoot, separators) + " of " + hoverPt.root;
+                  insertPercent();
+                }
+                hoverPt.text = _cast("hovertext") || _cast("text");
+                if (hasFlag("text")) {
+                  tx = hoverPt.text;
+                  if (Lib.isValidTextValue(tx)) thisText.push(tx);
+                }
+                eventData = [makeEventData(pt2, traceNow, opts.eventDataKeys)];
+                var hoverItems = {
+                  trace: traceNow,
+                  y: hoverCenterY,
+                  _x0: pt2._x0,
+                  _x1: pt2._x1,
+                  _y0: pt2._y0,
+                  _y1: pt2._y1,
+                  text: thisText.join("<br>"),
+                  name: hovertemplate || hasFlag("name") ? traceNow.name : void 0,
+                  color: _cast("hoverlabel.bgcolor") || cdi.color,
+                  borderColor: _cast("hoverlabel.bordercolor"),
+                  fontFamily: _cast("hoverlabel.font.family"),
+                  fontSize: _cast("hoverlabel.font.size"),
+                  fontColor: _cast("hoverlabel.font.color"),
+                  fontWeight: _cast("hoverlabel.font.weight"),
+                  fontStyle: _cast("hoverlabel.font.style"),
+                  fontVariant: _cast("hoverlabel.font.variant"),
+                  nameLength: _cast("hoverlabel.namelength"),
+                  textAlign: _cast("hoverlabel.align"),
+                  hovertemplate,
+                  hovertemplateLabels: hoverPt,
+                  eventData
+                };
+                if (isSunburst) {
+                  hoverItems.x0 = hoverCenterX - pt2.rInscribed * pt2.rpx1;
+                  hoverItems.x1 = hoverCenterX + pt2.rInscribed * pt2.rpx1;
+                  hoverItems.idealAlign = pt2.pxmid[0] < 0 ? "left" : "right";
+                }
+                if (isTreemapOrIcicle) {
+                  hoverItems.x = hoverCenterX;
+                  hoverItems.idealAlign = hoverCenterX < 0 ? "left" : "right";
+                }
+                var bbox = [];
+                Fx.loneHover(hoverItems, {
+                  container: fullLayoutNow._hoverlayer.node(),
+                  outerContainer: fullLayoutNow._paper.node(),
+                  gd: gd2,
+                  inOut_bbox: bbox
+                });
+                eventData[0].bbox = bbox[0];
+                trace._hasHoverLabel = true;
+              }
+              if (isTreemapOrIcicle) {
+                var slice = sliceTop.select("path.surface");
+                opts.styleOne(slice, pt2, traceNow, gd2, {
+                  hovered: true
+                });
+              }
+              trace._hasHoverEvent = true;
+              gd2.emit("plotly_hover", {
+                points: eventData || [makeEventData(pt2, traceNow, opts.eventDataKeys)],
+                event: d3.event
+              });
+            };
+            var onMouseOut = function(evt) {
+              var fullLayoutNow = gd2._fullLayout;
+              var traceNow = gd2._fullData[trace.index];
+              var pt2 = d3.select(this).datum();
+              if (trace._hasHoverEvent) {
+                evt.originalEvent = d3.event;
+                gd2.emit("plotly_unhover", {
+                  points: [makeEventData(pt2, traceNow, opts.eventDataKeys)],
+                  event: d3.event
+                });
+                trace._hasHoverEvent = false;
+              }
+              if (trace._hasHoverLabel) {
+                Fx.loneUnhover(fullLayoutNow._hoverlayer.node());
+                trace._hasHoverLabel = false;
+              }
+              if (isTreemapOrIcicle) {
+                var slice = sliceTop.select("path.surface");
+                opts.styleOne(slice, pt2, traceNow, gd2, {
+                  hovered: false
+                });
+              }
+            };
+            var onClick = function(pt2) {
+              var fullLayoutNow = gd2._fullLayout;
+              var traceNow = gd2._fullData[trace.index];
+              var noTransition = isSunburst && (helpers.isHierarchyRoot(pt2) || helpers.isLeaf(pt2));
+              var id2 = helpers.getPtId(pt2);
+              var nextEntry = helpers.isEntry(pt2) ? helpers.findEntryWithChild(hierarchy, id2) : helpers.findEntryWithLevel(hierarchy, id2);
+              var nextLevel = helpers.getPtId(nextEntry);
+              var typeClickEvtData = {
+                points: [makeEventData(pt2, traceNow, opts.eventDataKeys)],
+                event: d3.event
+              };
+              if (!noTransition) typeClickEvtData.nextLevel = nextLevel;
+              var clickVal = Events.triggerHandler(gd2, "plotly_" + trace.type + "click", typeClickEvtData);
+              if (clickVal !== false && fullLayoutNow.hovermode) {
+                gd2._hoverdata = [makeEventData(pt2, traceNow, opts.eventDataKeys)];
+                Fx.click(gd2, d3.event);
+              }
+              if (noTransition) return;
+              if (clickVal === false) return;
+              if (gd2._dragging) return;
+              if (gd2._transitioning) return;
+              Registry.call("_storeDirectGUIEdit", traceNow, fullLayoutNow._tracePreGUI[traceNow.uid], {
+                level: traceNow.level
+              });
+              var frame = {
+                data: [{ level: nextLevel }],
+                traces: [trace.index]
+              };
+              var animOpts = {
+                frame: {
+                  redraw: false,
+                  duration: opts.transitionTime
+                },
+                transition: {
+                  duration: opts.transitionTime,
+                  easing: opts.transitionEasing
+                },
+                mode: "immediate",
+                fromcurrent: true
+              };
+              Fx.loneUnhover(fullLayoutNow._hoverlayer.node());
+              Registry.call("animate", gd2, frame, animOpts);
+            };
+            sliceTop.on("mouseover", onMouseOver);
+            sliceTop.on("mouseout", onMouseOut);
+            sliceTop.on("click", onClick);
+          };
+          function makeEventData(pt2, trace, keys) {
+            var cdi = pt2.data.data;
+            var out = {
+              curveNumber: trace.index,
+              pointNumber: cdi.i,
+              data: trace._input,
+              fullData: trace
+              // TODO more things like 'children', 'siblings', 'hierarchy?
+            };
+            for (var i2 = 0; i2 < keys.length; i2++) {
+              var key = keys[i2];
+              if (key in pt2) out[key] = pt2[key];
+            }
+            if ("parentString" in pt2 && !helpers.isHierarchyRoot(pt2)) out.parent = pt2.parentString;
+            appendArrayPointValue(out, trace, cdi.i);
+            return out;
+          }
+        }
+      });
+      var require_plot13 = __commonJS({
+        "src/traces/sunburst/plot.js"(exports) {
+          var d3 = require_d3();
+          var d3Hierarchy = require_d3_hierarchy();
+          var interpolate = (init_src2(), __toCommonJS(src_exports)).interpolate;
+          var Drawing = require_drawing();
+          var Lib = require_lib();
+          var svgTextUtils = require_svg_text_utils();
+          var uniformText = require_uniform_text();
+          var recordMinTextSize = uniformText.recordMinTextSize;
+          var clearMinTextSize = uniformText.clearMinTextSize;
+          var piePlot = require_plot12();
+          var getRotationAngle = require_helpers4().getRotationAngle;
+          var computeTransform = piePlot.computeTransform;
+          var transformInsideText = piePlot.transformInsideText;
+          var styleOne = require_style13().styleOne;
+          var resizeText = require_style4().resizeText;
+          var attachFxHandlers = require_fx2();
+          var constants = require_constants20();
+          var helpers = require_helpers15();
+          exports.plot = function(gd2, cdmodule, transitionOpts, makeOnCompleteCallback) {
+            var fullLayout = gd2._fullLayout;
+            var layer = fullLayout._sunburstlayer;
+            var join, onComplete;
+            var isFullReplot = !transitionOpts;
+            var hasTransition = !fullLayout.uniformtext.mode && helpers.hasTransition(transitionOpts);
+            clearMinTextSize("sunburst", fullLayout);
+            join = layer.selectAll("g.trace.sunburst").data(cdmodule, function(cd2) {
+              return cd2[0].trace.uid;
+            });
+            join.enter().append("g").classed("trace", true).classed("sunburst", true).attr("stroke-linejoin", "round");
+            join.order();
+            if (hasTransition) {
+              if (makeOnCompleteCallback) {
+                onComplete = makeOnCompleteCallback();
+              }
+              var transition = d3.transition().duration(transitionOpts.duration).ease(transitionOpts.easing).each("end", function() {
+                onComplete && onComplete();
+              }).each("interrupt", function() {
+                onComplete && onComplete();
+              });
+              transition.each(function() {
+                layer.selectAll("g.trace").each(function(cd2) {
+                  plotOne(gd2, cd2, this, transitionOpts);
+                });
+              });
+            } else {
+              join.each(function(cd2) {
+                plotOne(gd2, cd2, this, transitionOpts);
+              });
+              if (fullLayout.uniformtext.mode) {
+                resizeText(gd2, fullLayout._sunburstlayer.selectAll(".trace"), "sunburst");
+              }
+            }
+            if (isFullReplot) {
+              join.exit().remove();
+            }
+          };
+          function plotOne(gd2, cd2, element, transitionOpts) {
+            var isStatic = gd2._context.staticPlot;
+            var fullLayout = gd2._fullLayout;
+            var hasTransition = !fullLayout.uniformtext.mode && helpers.hasTransition(transitionOpts);
+            var gTrace = d3.select(element);
+            var slices = gTrace.selectAll("g.slice");
+            var cd0 = cd2[0];
+            var trace = cd0.trace;
+            var hierarchy = cd0.hierarchy;
+            var entry = helpers.findEntryWithLevel(hierarchy, trace.level);
+            var maxDepth = helpers.getMaxDepth(trace);
+            var gs = fullLayout._size;
+            var domain = trace.domain;
+            var vpw = gs.w * (domain.x[1] - domain.x[0]);
+            var vph = gs.h * (domain.y[1] - domain.y[0]);
+            var rMax = 0.5 * Math.min(vpw, vph);
+            var cx = cd0.cx = gs.l + gs.w * (domain.x[1] + domain.x[0]) / 2;
+            var cy = cd0.cy = gs.t + gs.h * (1 - domain.y[0]) - vph / 2;
+            if (!entry) {
+              return slices.remove();
+            }
+            var prevEntry = null;
+            var prevLookup = {};
+            if (hasTransition) {
+              slices.each(function(pt2) {
+                prevLookup[helpers.getPtId(pt2)] = {
+                  rpx0: pt2.rpx0,
+                  rpx1: pt2.rpx1,
+                  x0: pt2.x0,
+                  x1: pt2.x1,
+                  transform: pt2.transform
+                };
+                if (!prevEntry && helpers.isEntry(pt2)) {
+                  prevEntry = pt2;
+                }
+              });
+            }
+            var sliceData = partition(entry).descendants();
+            var maxHeight = entry.height + 1;
+            var yOffset = 0;
+            var cutoff = maxDepth;
+            if (cd0.hasMultipleRoots && helpers.isHierarchyRoot(entry)) {
+              sliceData = sliceData.slice(1);
+              maxHeight -= 1;
+              yOffset = 1;
+              cutoff += 1;
+            }
+            sliceData = sliceData.filter(function(pt2) {
+              return pt2.y1 <= cutoff;
+            });
+            var baseX = getRotationAngle(trace.rotation);
+            if (baseX) {
+              sliceData.forEach(function(pt2) {
+                pt2.x0 += baseX;
+                pt2.x1 += baseX;
+              });
+            }
+            var maxY = Math.min(maxHeight, maxDepth);
+            var y2rpx = function(y2) {
+              return (y2 - yOffset) / maxY * rMax;
+            };
+            var rx2px = function(r2, x2) {
+              return [r2 * Math.cos(x2), -r2 * Math.sin(x2)];
+            };
+            var pathSlice = function(d2) {
+              return Lib.pathAnnulus(d2.rpx0, d2.rpx1, d2.x0, d2.x1, cx, cy);
+            };
+            var getTargetX = function(d2) {
+              return cx + getTextXY(d2)[0] * (d2.transform.rCenter || 0) + (d2.transform.x || 0);
+            };
+            var getTargetY = function(d2) {
+              return cy + getTextXY(d2)[1] * (d2.transform.rCenter || 0) + (d2.transform.y || 0);
+            };
+            slices = slices.data(sliceData, helpers.getPtId);
+            slices.enter().append("g").classed("slice", true);
+            if (hasTransition) {
+              slices.exit().transition().each(function() {
+                var sliceTop = d3.select(this);
+                var slicePath = sliceTop.select("path.surface");
+                slicePath.transition().attrTween("d", function(pt2) {
+                  var interp = makeExitSliceInterpolator(pt2);
+                  return function(t4) {
+                    return pathSlice(interp(t4));
+                  };
+                });
+                var sliceTextGroup = sliceTop.select("g.slicetext");
+                sliceTextGroup.attr("opacity", 0);
+              }).remove();
+            } else {
+              slices.exit().remove();
+            }
+            slices.order();
+            var nextX1ofPrevEntry = null;
+            if (hasTransition && prevEntry) {
+              var prevEntryId = helpers.getPtId(prevEntry);
+              slices.each(function(pt2) {
+                if (nextX1ofPrevEntry === null && helpers.getPtId(pt2) === prevEntryId) {
+                  nextX1ofPrevEntry = pt2.x1;
+                }
+              });
+            }
+            var updateSlices = slices;
+            if (hasTransition) {
+              updateSlices = updateSlices.transition().each("end", function() {
+                var sliceTop = d3.select(this);
+                helpers.setSliceCursor(sliceTop, gd2, {
+                  hideOnRoot: true,
+                  hideOnLeaves: true,
+                  isTransitioning: false
+                });
+              });
+            }
+            updateSlices.each(function(pt2) {
+              var sliceTop = d3.select(this);
+              var slicePath = Lib.ensureSingle(sliceTop, "path", "surface", function(s2) {
+                s2.style("pointer-events", isStatic ? "none" : "all");
+              });
+              pt2.rpx0 = y2rpx(pt2.y0);
+              pt2.rpx1 = y2rpx(pt2.y1);
+              pt2.xmid = (pt2.x0 + pt2.x1) / 2;
+              pt2.pxmid = rx2px(pt2.rpx1, pt2.xmid);
+              pt2.midangle = -(pt2.xmid - Math.PI / 2);
+              pt2.startangle = -(pt2.x0 - Math.PI / 2);
+              pt2.stopangle = -(pt2.x1 - Math.PI / 2);
+              pt2.halfangle = 0.5 * Math.min(Lib.angleDelta(pt2.x0, pt2.x1) || Math.PI, Math.PI);
+              pt2.ring = 1 - pt2.rpx0 / pt2.rpx1;
+              pt2.rInscribed = getInscribedRadiusFraction(pt2);
+              if (hasTransition) {
+                slicePath.transition().attrTween("d", function(pt22) {
+                  var interp = makeUpdateSliceInterpolator(pt22);
+                  return function(t4) {
+                    return pathSlice(interp(t4));
+                  };
+                });
+              } else {
+                slicePath.attr("d", pathSlice);
+              }
+              sliceTop.call(attachFxHandlers, entry, gd2, cd2, {
+                eventDataKeys: constants.eventDataKeys,
+                transitionTime: constants.CLICK_TRANSITION_TIME,
+                transitionEasing: constants.CLICK_TRANSITION_EASING
+              }).call(helpers.setSliceCursor, gd2, {
+                hideOnRoot: true,
+                hideOnLeaves: true,
+                isTransitioning: gd2._transitioning
+              });
+              slicePath.call(styleOne, pt2, trace, gd2);
+              var sliceTextGroup = Lib.ensureSingle(sliceTop, "g", "slicetext");
+              var sliceText = Lib.ensureSingle(sliceTextGroup, "text", "", function(s2) {
+                s2.attr("data-notex", 1);
+              });
+              var font = Lib.ensureUniformFontSize(gd2, helpers.determineTextFont(trace, pt2, fullLayout.font));
+              sliceText.text(exports.formatSliceLabel(pt2, entry, trace, cd2, fullLayout)).classed("slicetext", true).attr("text-anchor", "middle").call(Drawing.font, font).call(svgTextUtils.convertToTspans, gd2);
+              var textBB = Drawing.bBox(sliceText.node());
+              pt2.transform = transformInsideText(textBB, pt2, cd0);
+              pt2.transform.targetX = getTargetX(pt2);
+              pt2.transform.targetY = getTargetY(pt2);
+              var strTransform = function(d2, textBB2) {
+                var transform = d2.transform;
+                computeTransform(transform, textBB2);
+                transform.fontSize = font.size;
+                recordMinTextSize(trace.type, transform, fullLayout);
+                return Lib.getTextTransform(transform);
+              };
+              if (hasTransition) {
+                sliceText.transition().attrTween("transform", function(pt22) {
+                  var interp = makeUpdateTextInterpolator(pt22);
+                  return function(t4) {
+                    return strTransform(interp(t4), textBB);
+                  };
+                });
+              } else {
+                sliceText.attr("transform", strTransform(pt2, textBB));
+              }
+            });
+            function makeExitSliceInterpolator(pt2) {
+              var id2 = helpers.getPtId(pt2);
+              var prev = prevLookup[id2];
+              var entryPrev = prevLookup[helpers.getPtId(entry)];
+              var next;
+              if (entryPrev) {
+                var a2 = (pt2.x1 > entryPrev.x1 ? 2 * Math.PI : 0) + baseX;
+                next = pt2.rpx1 < entryPrev.rpx1 ? { x0: pt2.x0, x1: pt2.x1, rpx0: 0, rpx1: 0 } : { x0: a2, x1: a2, rpx0: pt2.rpx0, rpx1: pt2.rpx1 };
+              } else {
+                var parent;
+                var parentId = helpers.getPtId(pt2.parent);
+                slices.each(function(pt22) {
+                  if (helpers.getPtId(pt22) === parentId) {
+                    return parent = pt22;
+                  }
+                });
+                var parentChildren = parent.children;
+                var ci2;
+                parentChildren.forEach(function(pt22, i2) {
+                  if (helpers.getPtId(pt22) === id2) {
+                    return ci2 = i2;
+                  }
+                });
+                var n2 = parentChildren.length;
+                var interp = interpolate(parent.x0, parent.x1);
+                next = {
+                  rpx0: rMax,
+                  rpx1: rMax,
+                  x0: interp(ci2 / n2),
+                  x1: interp((ci2 + 1) / n2)
+                };
+              }
+              return interpolate(prev, next);
+            }
+            function makeUpdateSliceInterpolator(pt2) {
+              var prev0 = prevLookup[helpers.getPtId(pt2)];
+              var prev;
+              var next = { x0: pt2.x0, x1: pt2.x1, rpx0: pt2.rpx0, rpx1: pt2.rpx1 };
+              if (prev0) {
+                prev = prev0;
+              } else {
+                if (prevEntry) {
+                  if (pt2.parent) {
+                    if (nextX1ofPrevEntry) {
+                      var a2 = (pt2.x1 > nextX1ofPrevEntry ? 2 * Math.PI : 0) + baseX;
+                      prev = { x0: a2, x1: a2 };
+                    } else {
+                      prev = { rpx0: rMax, rpx1: rMax };
+                      Lib.extendFlat(prev, interpX0X1FromParent(pt2));
+                    }
+                  } else {
+                    prev = { rpx0: 0, rpx1: 0 };
+                  }
+                } else {
+                  prev = { x0: baseX, x1: baseX };
+                }
+              }
+              return interpolate(prev, next);
+            }
+            function makeUpdateTextInterpolator(pt2) {
+              var prev0 = prevLookup[helpers.getPtId(pt2)];
+              var prev;
+              var transform = pt2.transform;
+              if (prev0) {
+                prev = prev0;
+              } else {
+                prev = {
+                  rpx1: pt2.rpx1,
+                  transform: {
+                    textPosAngle: transform.textPosAngle,
+                    scale: 0,
+                    rotate: transform.rotate,
+                    rCenter: transform.rCenter,
+                    x: transform.x,
+                    y: transform.y
+                  }
+                };
+                if (prevEntry) {
+                  if (pt2.parent) {
+                    if (nextX1ofPrevEntry) {
+                      var a2 = pt2.x1 > nextX1ofPrevEntry ? 2 * Math.PI : 0;
+                      prev.x0 = prev.x1 = a2;
+                    } else {
+                      Lib.extendFlat(prev, interpX0X1FromParent(pt2));
+                    }
+                  } else {
+                    prev.x0 = prev.x1 = baseX;
+                  }
+                } else {
+                  prev.x0 = prev.x1 = baseX;
+                }
+              }
+              var textPosAngleFn = interpolate(prev.transform.textPosAngle, pt2.transform.textPosAngle);
+              var rpx1Fn = interpolate(prev.rpx1, pt2.rpx1);
+              var x0Fn = interpolate(prev.x0, pt2.x0);
+              var x1Fn = interpolate(prev.x1, pt2.x1);
+              var scaleFn = interpolate(prev.transform.scale, transform.scale);
+              var rotateFn = interpolate(prev.transform.rotate, transform.rotate);
+              var pow = transform.rCenter === 0 ? 3 : prev.transform.rCenter === 0 ? 1 / 3 : 1;
+              var _rCenterFn = interpolate(prev.transform.rCenter, transform.rCenter);
+              var rCenterFn = function(t4) {
+                return _rCenterFn(Math.pow(t4, pow));
+              };
+              return function(t4) {
+                var rpx1 = rpx1Fn(t4);
+                x0Fn(t4);
+                x1Fn(t4);
+                var rCenter = rCenterFn(t4);
+                var textPosAngle = textPosAngleFn(t4);
+                var d2 = {
+                  rpx1,
+                  transform: {
+                    textPosAngle,
+                    rCenter,
+                    x: transform.x,
+                    y: transform.y
+                  }
+                };
+                recordMinTextSize(trace.type, transform, fullLayout);
+                return {
+                  transform: {
+                    targetX: getTargetX(d2),
+                    targetY: getTargetY(d2),
+                    scale: scaleFn(t4),
+                    rotate: rotateFn(t4),
+                    rCenter
+                  }
+                };
+              };
+            }
+            function interpX0X1FromParent(pt2) {
+              var parent = pt2.parent;
+              var parentPrev = prevLookup[helpers.getPtId(parent)];
+              var out = {};
+              if (parentPrev) {
+                var parentChildren = parent.children;
+                var ci2 = parentChildren.indexOf(pt2);
+                var n2 = parentChildren.length;
+                var interp = interpolate(parentPrev.x0, parentPrev.x1);
+                out.x0 = interp(ci2 / n2);
+                out.x1 = interp(ci2 / n2);
+              } else {
+                out.x0 = out.x1 = 0;
+              }
+              return out;
+            }
+          }
+          function partition(entry) {
+            return d3Hierarchy.partition().size([2 * Math.PI, entry.height + 1])(entry);
+          }
+          exports.formatSliceLabel = function(pt2, entry, trace, cd2, fullLayout) {
+            var texttemplate = trace.texttemplate;
+            var textinfo = trace.textinfo;
+            if (!texttemplate && (!textinfo || textinfo === "none")) {
+              return "";
+            }
+            var separators = fullLayout.separators;
+            var cd0 = cd2[0];
+            var cdi = pt2.data.data;
+            var hierarchy = cd0.hierarchy;
+            var isRoot = helpers.isHierarchyRoot(pt2);
+            var parent = helpers.getParent(hierarchy, pt2);
+            var val = helpers.getValue(pt2);
+            if (!texttemplate) {
+              var parts = textinfo.split("+");
+              var hasFlag = function(flag) {
+                return parts.indexOf(flag) !== -1;
+              };
+              var thisText = [];
+              var tx;
+              if (hasFlag("label") && cdi.label) {
+                thisText.push(cdi.label);
+              }
+              if (cdi.hasOwnProperty("v") && hasFlag("value")) {
+                thisText.push(helpers.formatValue(cdi.v, separators));
+              }
+              if (!isRoot) {
+                if (hasFlag("current path")) {
+                  thisText.push(helpers.getPath(pt2.data));
+                }
+                var nPercent = 0;
+                if (hasFlag("percent parent")) nPercent++;
+                if (hasFlag("percent entry")) nPercent++;
+                if (hasFlag("percent root")) nPercent++;
+                var hasMultiplePercents = nPercent > 1;
+                if (nPercent) {
+                  var percent;
+                  var addPercent = function(key) {
+                    tx = helpers.formatPercent(percent, separators);
+                    if (hasMultiplePercents) tx += " of " + key;
+                    thisText.push(tx);
+                  };
+                  if (hasFlag("percent parent") && !isRoot) {
+                    percent = val / helpers.getValue(parent);
+                    addPercent("parent");
+                  }
+                  if (hasFlag("percent entry")) {
+                    percent = val / helpers.getValue(entry);
+                    addPercent("entry");
+                  }
+                  if (hasFlag("percent root")) {
+                    percent = val / helpers.getValue(hierarchy);
+                    addPercent("root");
+                  }
+                }
+              }
+              if (hasFlag("text")) {
+                tx = Lib.castOption(trace, cdi.i, "text");
+                if (Lib.isValidTextValue(tx)) thisText.push(tx);
+              }
+              return thisText.join("<br>");
+            }
+            var txt = Lib.castOption(trace, cdi.i, "texttemplate");
+            if (!txt) return "";
+            var obj = {};
+            if (cdi.label) obj.label = cdi.label;
+            if (cdi.hasOwnProperty("v")) {
+              obj.value = cdi.v;
+              obj.valueLabel = helpers.formatValue(cdi.v, separators);
+            }
+            obj.currentPath = helpers.getPath(pt2.data);
+            if (!isRoot) {
+              obj.percentParent = val / helpers.getValue(parent);
+              obj.percentParentLabel = helpers.formatPercent(obj.percentParent, separators);
+              obj.parent = helpers.getPtLabel(parent);
+            }
+            obj.percentEntry = val / helpers.getValue(entry);
+            obj.percentEntryLabel = helpers.formatPercent(obj.percentEntry, separators);
+            obj.entry = helpers.getPtLabel(entry);
+            obj.percentRoot = val / helpers.getValue(hierarchy);
+            obj.percentRootLabel = helpers.formatPercent(obj.percentRoot, separators);
+            obj.root = helpers.getPtLabel(hierarchy);
+            if (cdi.hasOwnProperty("color")) {
+              obj.color = cdi.color;
+            }
+            var ptTx = Lib.castOption(trace, cdi.i, "text");
+            if (Lib.isValidTextValue(ptTx) || ptTx === "") obj.text = ptTx;
+            obj.customdata = Lib.castOption(trace, cdi.i, "customdata");
+            return Lib.texttemplateString({
+              data: [obj, trace._meta],
+              fallback: trace.texttemplatefallback,
+              labels: obj,
+              locale: fullLayout._d3locale,
+              template: txt
+            });
+          };
+          function getInscribedRadiusFraction(pt2) {
+            if (pt2.rpx0 === 0 && Lib.isFullCircle([pt2.x0, pt2.x1])) {
+              return 1;
+            } else {
+              return Math.max(0, Math.min(1 / (1 + 1 / Math.sin(pt2.halfangle)), pt2.ring / 2));
+            }
+          }
+          function getTextXY(d2) {
+            return getCoords(d2.rpx1, d2.transform.textPosAngle);
+          }
+          function getCoords(r2, angle2) {
+            return [r2 * Math.sin(angle2), -r2 * Math.cos(angle2)];
+          }
+        }
+      });
+      var require_sunburst = __commonJS({
+        "src/traces/sunburst/index.js"(exports, module2) {
+          module2.exports = {
+            moduleType: "trace",
+            name: "sunburst",
+            basePlotModule: require_base_plot2(),
+            categories: [],
+            animatable: true,
+            attributes: require_attributes36(),
+            layoutAttributes: require_layout_attributes13(),
+            supplyDefaults: require_defaults32(),
+            supplyLayoutDefaults: require_layout_defaults12(),
+            calc: require_calc17().calc,
+            crossTraceCalc: require_calc17().crossTraceCalc,
+            plot: require_plot13().plot,
+            style: require_style13().style,
+            colorbar: require_marker_colorbar(),
+            meta: {}
+          };
+        }
+      });
+      var require_sunburst2 = __commonJS({
+        "lib/sunburst.js"(exports, module2) {
+          module2.exports = require_sunburst();
+        }
+      });
+      var require_base_plot3 = __commonJS({
+        "src/traces/treemap/base_plot.js"(exports) {
+          var plots = require_plots();
+          exports.name = "treemap";
+          exports.plot = function(gd2, traces, transitionOpts, makeOnCompleteCallback) {
+            plots.plotBasePlot(exports.name, gd2, traces, transitionOpts, makeOnCompleteCallback);
+          };
+          exports.clean = function(newFullData, newFullLayout, oldFullData, oldFullLayout) {
+            plots.cleanBasePlot(exports.name, newFullData, newFullLayout, oldFullData, oldFullLayout);
+          };
+        }
+      });
+      var require_constants21 = __commonJS({
+        "src/traces/treemap/constants.js"(exports, module2) {
+          module2.exports = {
+            CLICK_TRANSITION_TIME: 750,
+            CLICK_TRANSITION_EASING: "poly",
+            eventDataKeys: [
+              // string
+              "currentPath",
+              "root",
+              "entry",
+              // no need to add 'parent' here
+              // percentages i.e. ratios
+              "percentRoot",
+              "percentEntry",
+              "percentParent"
+            ],
+            gapWithPathbar: 1
+            // i.e. one pixel
+          };
+        }
+      });
+      var require_attributes37 = __commonJS({
+        "src/traces/treemap/attributes.js"(exports, module2) {
+          var { hovertemplateAttrs, texttemplateAttrs, templatefallbackAttrs } = require_template_attributes();
+          var colorScaleAttrs = require_attributes8();
+          var domainAttrs = require_domain().attributes;
+          var pieAttrs = require_attributes35();
+          var sunburstAttrs = require_attributes36();
+          var constants = require_constants21();
+          var extendFlat = require_extend().extendFlat;
+          var pattern = require_attributes4().pattern;
+          module2.exports = {
+            labels: sunburstAttrs.labels,
+            parents: sunburstAttrs.parents,
+            values: sunburstAttrs.values,
+            branchvalues: sunburstAttrs.branchvalues,
+            count: sunburstAttrs.count,
+            level: sunburstAttrs.level,
+            maxdepth: sunburstAttrs.maxdepth,
+            tiling: {
+              packing: {
+                valType: "enumerated",
+                values: ["squarify", "binary", "dice", "slice", "slice-dice", "dice-slice"],
+                dflt: "squarify",
+                editType: "plot"
+              },
+              squarifyratio: {
+                valType: "number",
+                min: 1,
+                dflt: 1,
+                editType: "plot"
+              },
+              flip: {
+                valType: "flaglist",
+                flags: ["x", "y"],
+                dflt: "",
+                editType: "plot"
+              },
+              pad: {
+                valType: "number",
+                min: 0,
+                dflt: 3,
+                editType: "plot"
+              },
+              editType: "calc"
+            },
+            marker: extendFlat(
+              {
+                pad: {
+                  t: {
+                    valType: "number",
+                    min: 0,
+                    editType: "plot"
+                  },
+                  l: {
+                    valType: "number",
+                    min: 0,
+                    editType: "plot"
+                  },
+                  r: {
+                    valType: "number",
+                    min: 0,
+                    editType: "plot"
+                  },
+                  b: {
+                    valType: "number",
+                    min: 0,
+                    editType: "plot"
+                  },
+                  editType: "calc"
+                },
+                colors: sunburstAttrs.marker.colors,
+                pattern,
+                depthfade: {
+                  valType: "enumerated",
+                  values: [true, false, "reversed"],
+                  editType: "style"
+                },
+                line: sunburstAttrs.marker.line,
+                cornerradius: {
+                  valType: "number",
+                  min: 0,
+                  dflt: 0,
+                  editType: "plot"
+                },
+                editType: "calc"
+              },
+              colorScaleAttrs("marker", {
+                colorAttr: "colors",
+                anim: false
+                // TODO: set to anim: true?
+              })
+            ),
+            pathbar: {
+              visible: {
+                valType: "boolean",
+                dflt: true,
+                editType: "plot"
+              },
+              side: {
+                valType: "enumerated",
+                values: ["top", "bottom"],
+                dflt: "top",
+                editType: "plot"
+              },
+              edgeshape: {
+                valType: "enumerated",
+                values: [">", "<", "|", "/", "\\"],
+                dflt: ">",
+                editType: "plot"
+              },
+              thickness: {
+                valType: "number",
+                min: 12,
+                editType: "plot"
+              },
+              textfont: extendFlat({}, pieAttrs.textfont, {}),
+              editType: "calc"
+            },
+            text: pieAttrs.text,
+            textinfo: sunburstAttrs.textinfo,
+            // TODO: incorporate `label` and `value` in the eventData
+            texttemplate: texttemplateAttrs({ editType: "plot" }, { keys: constants.eventDataKeys.concat(["label", "value"]) }),
+            texttemplatefallback: templatefallbackAttrs({ editType: "plot" }),
+            hovertext: pieAttrs.hovertext,
+            hoverinfo: sunburstAttrs.hoverinfo,
+            hovertemplate: hovertemplateAttrs({}, { keys: constants.eventDataKeys }),
+            hovertemplatefallback: templatefallbackAttrs(),
+            textfont: pieAttrs.textfont,
+            insidetextfont: pieAttrs.insidetextfont,
+            outsidetextfont: extendFlat({}, pieAttrs.outsidetextfont, {}),
+            textposition: {
+              valType: "enumerated",
+              values: [
+                "top left",
+                "top center",
+                "top right",
+                "middle left",
+                "middle center",
+                "middle right",
+                "bottom left",
+                "bottom center",
+                "bottom right"
+              ],
+              dflt: "top left",
+              editType: "plot"
+            },
+            sort: pieAttrs.sort,
+            root: sunburstAttrs.root,
+            domain: domainAttrs({ name: "treemap", trace: true, editType: "calc" })
+          };
+        }
+      });
+      var require_layout_attributes14 = __commonJS({
+        "src/traces/treemap/layout_attributes.js"(exports, module2) {
+          module2.exports = {
+            treemapcolorway: {
+              valType: "colorlist",
+              editType: "calc"
+            },
+            extendtreemapcolors: {
+              valType: "boolean",
+              dflt: true,
+              editType: "calc"
+            }
+          };
+        }
+      });
+      var require_defaults33 = __commonJS({
+        "src/traces/treemap/defaults.js"(exports, module2) {
+          var Lib = require_lib();
+          var attributes = require_attributes37();
+          var Color2 = require_color();
+          var handleDomainDefaults = require_domain().defaults;
+          var handleText = require_defaults19().handleText;
+          var TEXTPAD = require_constants9().TEXTPAD;
+          var handleMarkerDefaults = require_defaults31().handleMarkerDefaults;
+          var Colorscale = require_colorscale();
+          var hasColorscale = Colorscale.hasColorscale;
+          var colorscaleDefaults = Colorscale.handleDefaults;
+          module2.exports = function supplyDefaults(traceIn, traceOut, defaultColor, layout) {
+            function coerce(attr, dflt) {
+              return Lib.coerce(traceIn, traceOut, attributes, attr, dflt);
+            }
+            var labels = coerce("labels");
+            var parents = coerce("parents");
+            if (!labels || !labels.length || !parents || !parents.length) {
+              traceOut.visible = false;
+              return;
+            }
+            var vals = coerce("values");
+            if (vals && vals.length) {
+              coerce("branchvalues");
+            } else {
+              coerce("count");
+            }
+            coerce("level");
+            coerce("maxdepth");
+            var packing = coerce("tiling.packing");
+            if (packing === "squarify") {
+              coerce("tiling.squarifyratio");
+            }
+            coerce("tiling.flip");
+            coerce("tiling.pad");
+            var text = coerce("text");
+            coerce("texttemplate");
+            coerce("texttemplatefallback");
+            if (!traceOut.texttemplate) coerce("textinfo", Lib.isArrayOrTypedArray(text) ? "text+label" : "label");
+            coerce("hovertext");
+            coerce("hovertemplate");
+            coerce("hovertemplatefallback");
+            var hasPathbar = coerce("pathbar.visible");
+            var textposition = "auto";
+            handleText(traceIn, traceOut, layout, coerce, textposition, {
+              hasPathbar,
+              moduleHasSelected: false,
+              moduleHasUnselected: false,
+              moduleHasConstrain: false,
+              moduleHasCliponaxis: false,
+              moduleHasTextangle: false,
+              moduleHasInsideanchor: false
+            });
+            coerce("textposition");
+            var bottomText = traceOut.textposition.indexOf("bottom") !== -1;
+            handleMarkerDefaults(traceIn, traceOut, layout, coerce);
+            var withColorscale = traceOut._hasColorscale = hasColorscale(traceIn, "marker", "colors") || (traceIn.marker || {}).coloraxis;
+            if (withColorscale) {
+              colorscaleDefaults(traceIn, traceOut, layout, coerce, { prefix: "marker.", cLetter: "c" });
+            } else {
+              coerce("marker.depthfade", !(traceOut.marker.colors || []).length);
+            }
+            var headerSize = traceOut.textfont.size * 2;
+            coerce("marker.pad.t", bottomText ? headerSize / 4 : headerSize);
+            coerce("marker.pad.l", headerSize / 4);
+            coerce("marker.pad.r", headerSize / 4);
+            coerce("marker.pad.b", bottomText ? headerSize : headerSize / 4);
+            coerce("marker.cornerradius");
+            traceOut._hovered = {
+              marker: {
+                line: {
+                  width: 2,
+                  color: Color2.contrast(layout.paper_bgcolor)
+                }
+              }
+            };
+            if (hasPathbar) {
+              coerce("pathbar.thickness", traceOut.pathbar.textfont.size + 2 * TEXTPAD);
+              coerce("pathbar.side");
+              coerce("pathbar.edgeshape");
+            }
+            coerce("sort");
+            coerce("root.color");
+            handleDomainDefaults(traceOut, layout, coerce);
+            traceOut._length = null;
+          };
+        }
+      });
+      var require_layout_defaults13 = __commonJS({
+        "src/traces/treemap/layout_defaults.js"(exports, module2) {
+          var Lib = require_lib();
+          var layoutAttributes = require_layout_attributes14();
+          module2.exports = function supplyLayoutDefaults(layoutIn, layoutOut) {
+            function coerce(attr, dflt) {
+              return Lib.coerce(layoutIn, layoutOut, layoutAttributes, attr, dflt);
+            }
+            coerce("treemapcolorway", layoutOut.colorway);
+            coerce("extendtreemapcolors");
+          };
+        }
+      });
+      var require_calc18 = __commonJS({
+        "src/traces/treemap/calc.js"(exports) {
+          var calc = require_calc17();
+          exports.calc = function(gd2, trace) {
+            return calc.calc(gd2, trace);
+          };
+          exports.crossTraceCalc = function(gd2) {
+            return calc._runCrossTraceCalc("treemap", gd2);
+          };
+        }
+      });
+      var require_flip_tree = __commonJS({
+        "src/traces/treemap/flip_tree.js"(exports, module2) {
+          module2.exports = function flipTree(node, size, opts) {
+            var tmp2;
+            if (opts.swapXY) {
+              tmp2 = node.x0;
+              node.x0 = node.y0;
+              node.y0 = tmp2;
+              tmp2 = node.x1;
+              node.x1 = node.y1;
+              node.y1 = tmp2;
+            }
+            if (opts.flipX) {
+              tmp2 = node.x0;
+              node.x0 = size[0] - node.x1;
+              node.x1 = size[0] - tmp2;
+            }
+            if (opts.flipY) {
+              tmp2 = node.y0;
+              node.y0 = size[1] - node.y1;
+              node.y1 = size[1] - tmp2;
+            }
+            var children = node.children;
+            if (children) {
+              for (var i2 = 0; i2 < children.length; i2++) {
+                flipTree(children[i2], size, opts);
+              }
+            }
+          };
+        }
+      });
+      var require_partition = __commonJS({
+        "src/traces/treemap/partition.js"(exports, module2) {
+          var d3Hierarchy = require_d3_hierarchy();
+          var flipTree = require_flip_tree();
+          module2.exports = function partition(entry, size, opts) {
+            var flipX = opts.flipX;
+            var flipY = opts.flipY;
+            var swapXY = opts.packing === "dice-slice";
+            var top = opts.pad[flipY ? "bottom" : "top"];
+            var left = opts.pad[flipX ? "right" : "left"];
+            var right = opts.pad[flipX ? "left" : "right"];
+            var bottom = opts.pad[flipY ? "top" : "bottom"];
+            var tmp2;
+            if (swapXY) {
+              tmp2 = left;
+              left = top;
+              top = tmp2;
+              tmp2 = right;
+              right = bottom;
+              bottom = tmp2;
+            }
+            var result = d3Hierarchy.treemap().tile(getTilingMethod(opts.packing, opts.squarifyratio)).paddingInner(opts.pad.inner).paddingLeft(left).paddingRight(right).paddingTop(top).paddingBottom(bottom).size(
+              swapXY ? [size[1], size[0]] : size
+            )(entry);
+            if (swapXY || flipX || flipY) {
+              flipTree(result, size, {
+                swapXY,
+                flipX,
+                flipY
+              });
+            }
+            return result;
+          };
+          function getTilingMethod(key, squarifyratio) {
+            switch (key) {
+              case "squarify":
+                return d3Hierarchy.treemapSquarify.ratio(squarifyratio);
+              case "binary":
+                return d3Hierarchy.treemapBinary;
+              case "dice":
+                return d3Hierarchy.treemapDice;
+              case "slice":
+                return d3Hierarchy.treemapSlice;
+              default:
+                return d3Hierarchy.treemapSliceDice;
+            }
+          }
+        }
+      });
+      var require_style14 = __commonJS({
+        "src/traces/treemap/style.js"(exports, module2) {
+          var d3 = require_d3();
+          var Color2 = require_color();
+          var Lib = require_lib();
+          var helpers = require_helpers15();
+          var resizeText = require_uniform_text().resizeText;
+          var fillOne = require_fill_one2();
+          function style(gd2) {
+            var s2 = gd2._fullLayout._treemaplayer.selectAll(".trace");
+            resizeText(gd2, s2, "treemap");
+            s2.each(function(cd2) {
+              var gTrace = d3.select(this);
+              var cd0 = cd2[0];
+              var trace = cd0.trace;
+              gTrace.style("opacity", trace.opacity);
+              gTrace.selectAll("path.surface").each(function(pt2) {
+                d3.select(this).call(styleOne, pt2, trace, gd2, {
+                  hovered: false
+                });
+              });
+            });
+          }
+          function styleOne(s2, pt2, trace, gd2, opts) {
+            var hovered = (opts || {}).hovered;
+            var cdi = pt2.data.data;
+            var ptNumber = cdi.i;
+            var lineColor;
+            var lineWidth;
+            var fillColor = cdi.color;
+            var isRoot = helpers.isHierarchyRoot(pt2);
+            var opacity = 1;
+            if (hovered) {
+              lineColor = trace._hovered.marker.line.color;
+              lineWidth = trace._hovered.marker.line.width;
+            } else {
+              if (isRoot && fillColor === trace.root.color) {
+                opacity = 100;
+                lineColor = "rgba(0,0,0,0)";
+                lineWidth = 0;
+              } else {
+                lineColor = Lib.castOption(trace, ptNumber, "marker.line.color") || Color2.defaultLine;
+                lineWidth = Lib.castOption(trace, ptNumber, "marker.line.width") || 0;
+                if (!trace._hasColorscale && !pt2.onPathbar) {
+                  var depthfade = trace.marker.depthfade;
+                  if (depthfade) {
+                    var fadedColor = Color2.combine(Color2.addOpacity(trace._backgroundColor, 0.75), fillColor);
+                    var n2;
+                    if (depthfade === true) {
+                      var maxDepth = helpers.getMaxDepth(trace);
+                      if (isFinite(maxDepth)) {
+                        if (helpers.isLeaf(pt2)) {
+                          n2 = 0;
+                        } else {
+                          n2 = trace._maxVisibleLayers - (pt2.data.depth - trace._entryDepth);
+                        }
+                      } else {
+                        n2 = pt2.data.height + 1;
+                      }
+                    } else {
+                      n2 = pt2.data.depth - trace._entryDepth;
+                      if (!trace._atRootLevel) n2++;
+                    }
+                    if (n2 > 0) {
+                      for (var i2 = 0; i2 < n2; i2++) {
+                        var ratio = 0.5 * i2 / n2;
+                        fillColor = Color2.combine(Color2.addOpacity(fadedColor, ratio), fillColor);
+                      }
+                    }
+                  }
+                }
+              }
+            }
+            s2.call(fillOne, pt2, trace, gd2, fillColor).style("stroke-width", lineWidth).call(Color2.stroke, lineColor).style("opacity", opacity);
+          }
+          module2.exports = {
+            style,
+            styleOne
+          };
+        }
+      });
+      var require_draw_ancestors = __commonJS({
+        "src/traces/treemap/draw_ancestors.js"(exports, module2) {
+          var d3 = require_d3();
+          var Lib = require_lib();
+          var Drawing = require_drawing();
+          var svgTextUtils = require_svg_text_utils();
+          var partition = require_partition();
+          var styleOne = require_style14().styleOne;
+          var constants = require_constants21();
+          var helpers = require_helpers15();
+          var attachFxHandlers = require_fx2();
+          var onPathbar = true;
+          module2.exports = function drawAncestors(gd2, cd2, entry, slices, opts) {
+            var barDifY = opts.barDifY;
+            var width = opts.width;
+            var height = opts.height;
+            var viewX = opts.viewX;
+            var viewY = opts.viewY;
+            var pathSlice = opts.pathSlice;
+            var toMoveInsideSlice = opts.toMoveInsideSlice;
+            var strTransform = opts.strTransform;
+            var hasTransition = opts.hasTransition;
+            var handleSlicesExit = opts.handleSlicesExit;
+            var makeUpdateSliceInterpolator = opts.makeUpdateSliceInterpolator;
+            var makeUpdateTextInterpolator = opts.makeUpdateTextInterpolator;
+            var refRect = {};
+            var isStatic = gd2._context.staticPlot;
+            var fullLayout = gd2._fullLayout;
+            var cd0 = cd2[0];
+            var trace = cd0.trace;
+            var hierarchy = cd0.hierarchy;
+            var eachWidth = width / trace._entryDepth;
+            var pathIds = helpers.listPath(entry.data, "id");
+            var sliceData = partition(hierarchy.copy(), [width, height], {
+              packing: "dice",
+              pad: {
+                inner: 0,
+                top: 0,
+                left: 0,
+                right: 0,
+                bottom: 0
+              }
+            }).descendants();
+            sliceData = sliceData.filter(function(pt2) {
+              var level = pathIds.indexOf(pt2.data.id);
+              if (level === -1) return false;
+              pt2.x0 = eachWidth * level;
+              pt2.x1 = eachWidth * (level + 1);
+              pt2.y0 = barDifY;
+              pt2.y1 = barDifY + height;
+              pt2.onPathbar = true;
+              return true;
+            });
+            sliceData.reverse();
+            slices = slices.data(sliceData, helpers.getPtId);
+            slices.enter().append("g").classed("pathbar", true);
+            handleSlicesExit(slices, onPathbar, refRect, [width, height], pathSlice);
+            slices.order();
+            var updateSlices = slices;
+            if (hasTransition) {
+              updateSlices = updateSlices.transition().each("end", function() {
+                var sliceTop = d3.select(this);
+                helpers.setSliceCursor(sliceTop, gd2, {
+                  hideOnRoot: false,
+                  hideOnLeaves: false,
+                  isTransitioning: false
+                });
+              });
+            }
+            updateSlices.each(function(pt2) {
+              pt2._x0 = viewX(pt2.x0);
+              pt2._x1 = viewX(pt2.x1);
+              pt2._y0 = viewY(pt2.y0);
+              pt2._y1 = viewY(pt2.y1);
+              pt2._hoverX = viewX(pt2.x1 - Math.min(width, height) / 2);
+              pt2._hoverY = viewY(pt2.y1 - height / 2);
+              var sliceTop = d3.select(this);
+              var slicePath = Lib.ensureSingle(sliceTop, "path", "surface", function(s2) {
+                s2.style("pointer-events", isStatic ? "none" : "all");
+              });
+              if (hasTransition) {
+                slicePath.transition().attrTween("d", function(pt22) {
+                  var interp = makeUpdateSliceInterpolator(pt22, onPathbar, refRect, [width, height]);
+                  return function(t4) {
+                    return pathSlice(interp(t4));
+                  };
+                });
+              } else {
+                slicePath.attr("d", pathSlice);
+              }
+              sliceTop.call(attachFxHandlers, entry, gd2, cd2, {
+                styleOne,
+                eventDataKeys: constants.eventDataKeys,
+                transitionTime: constants.CLICK_TRANSITION_TIME,
+                transitionEasing: constants.CLICK_TRANSITION_EASING
+              }).call(helpers.setSliceCursor, gd2, {
+                hideOnRoot: false,
+                hideOnLeaves: false,
+                isTransitioning: gd2._transitioning
+              });
+              slicePath.call(styleOne, pt2, trace, gd2, {
+                hovered: false
+              });
+              pt2._text = (helpers.getPtLabel(pt2) || "").split("<br>").join(" ") || "";
+              var sliceTextGroup = Lib.ensureSingle(sliceTop, "g", "slicetext");
+              var sliceText = Lib.ensureSingle(sliceTextGroup, "text", "", function(s2) {
+                s2.attr("data-notex", 1);
+              });
+              var font = Lib.ensureUniformFontSize(gd2, helpers.determineTextFont(trace, pt2, fullLayout.font, {
+                onPathbar: true
+              }));
+              sliceText.text(pt2._text || " ").classed("slicetext", true).attr("text-anchor", "start").call(Drawing.font, font).call(svgTextUtils.convertToTspans, gd2);
+              pt2.textBB = Drawing.bBox(sliceText.node());
+              pt2.transform = toMoveInsideSlice(pt2, {
+                fontSize: font.size,
+                onPathbar: true
+              });
+              pt2.transform.fontSize = font.size;
+              if (hasTransition) {
+                sliceText.transition().attrTween("transform", function(pt22) {
+                  var interp = makeUpdateTextInterpolator(pt22, onPathbar, refRect, [width, height]);
+                  return function(t4) {
+                    return strTransform(interp(t4));
+                  };
+                });
+              } else {
+                sliceText.attr("transform", strTransform(pt2));
+              }
+            });
+          };
+        }
+      });
+      var require_plot_one = __commonJS({
+        "src/traces/treemap/plot_one.js"(exports, module2) {
+          var d3 = require_d3();
+          var interpolate = (init_src2(), __toCommonJS(src_exports)).interpolate;
+          var helpers = require_helpers15();
+          var Lib = require_lib();
+          var TEXTPAD = require_constants9().TEXTPAD;
+          var barPlot = require_plot3();
+          var toMoveInsideBar = barPlot.toMoveInsideBar;
+          var uniformText = require_uniform_text();
+          var recordMinTextSize = uniformText.recordMinTextSize;
+          var constants = require_constants21();
+          var drawAncestors = require_draw_ancestors();
+          function getKey(pt2) {
+            return helpers.isHierarchyRoot(pt2) ? "" : (
+              // don't use the dummyId
+              helpers.getPtId(pt2)
+            );
+          }
+          module2.exports = function plotOne(gd2, cd2, element, transitionOpts, drawDescendants) {
+            var fullLayout = gd2._fullLayout;
+            var cd0 = cd2[0];
+            var trace = cd0.trace;
+            var type = trace.type;
+            var isIcicle = type === "icicle";
+            var hierarchy = cd0.hierarchy;
+            var entry = helpers.findEntryWithLevel(hierarchy, trace.level);
+            var gTrace = d3.select(element);
+            var selAncestors = gTrace.selectAll("g.pathbar");
+            var selDescendants = gTrace.selectAll("g.slice");
+            if (!entry) {
+              selAncestors.remove();
+              selDescendants.remove();
+              return;
+            }
+            var isRoot = helpers.isHierarchyRoot(entry);
+            var hasTransition = !fullLayout.uniformtext.mode && helpers.hasTransition(transitionOpts);
+            var maxDepth = helpers.getMaxDepth(trace);
+            var hasVisibleDepth = function(pt2) {
+              return pt2.data.depth - entry.data.depth < maxDepth;
+            };
+            var gs = fullLayout._size;
+            var domain = trace.domain;
+            var vpw = gs.w * (domain.x[1] - domain.x[0]);
+            var vph = gs.h * (domain.y[1] - domain.y[0]);
+            var barW = vpw;
+            var barH = trace.pathbar.thickness;
+            var barPad = trace.marker.line.width + constants.gapWithPathbar;
+            var barDifY = !trace.pathbar.visible ? 0 : trace.pathbar.side.indexOf("bottom") > -1 ? vph + barPad : -(barH + barPad);
+            var pathbarOrigin = {
+              x0: barW,
+              // slide to the right
+              x1: barW,
+              y0: barDifY,
+              y1: barDifY + barH
+            };
+            var findClosestEdge = function(pt2, ref, size) {
+              var e2 = trace.tiling.pad;
+              var isLeftOfRect = function(x2) {
+                return x2 - e2 <= ref.x0;
+              };
+              var isRightOfRect = function(x2) {
+                return x2 + e2 >= ref.x1;
+              };
+              var isBottomOfRect = function(y2) {
+                return y2 - e2 <= ref.y0;
+              };
+              var isTopOfRect = function(y2) {
+                return y2 + e2 >= ref.y1;
+              };
+              if (pt2.x0 === ref.x0 && pt2.x1 === ref.x1 && pt2.y0 === ref.y0 && pt2.y1 === ref.y1) {
+                return {
+                  x0: pt2.x0,
+                  x1: pt2.x1,
+                  y0: pt2.y0,
+                  y1: pt2.y1
+                };
+              }
+              return {
+                x0: isLeftOfRect(pt2.x0 - e2) ? 0 : isRightOfRect(pt2.x0 - e2) ? size[0] : pt2.x0,
+                x1: isLeftOfRect(pt2.x1 + e2) ? 0 : isRightOfRect(pt2.x1 + e2) ? size[0] : pt2.x1,
+                y0: isBottomOfRect(pt2.y0 - e2) ? 0 : isTopOfRect(pt2.y0 - e2) ? size[1] : pt2.y0,
+                y1: isBottomOfRect(pt2.y1 + e2) ? 0 : isTopOfRect(pt2.y1 + e2) ? size[1] : pt2.y1
+              };
+            };
+            var prevEntry = null;
+            var prevLookupPathbar = {};
+            var prevLookupSlices = {};
+            var nextOfPrevEntry = null;
+            var getPrev = function(pt2, onPathbar) {
+              return onPathbar ? prevLookupPathbar[getKey(pt2)] : prevLookupSlices[getKey(pt2)];
+            };
+            var getOrigin = function(pt2, onPathbar, refRect, size) {
+              if (onPathbar) {
+                return prevLookupPathbar[getKey(hierarchy)] || pathbarOrigin;
+              } else {
+                var ref = prevLookupSlices[trace.level] || refRect;
+                if (hasVisibleDepth(pt2)) {
+                  return findClosestEdge(pt2, ref, size);
+                }
+              }
+              return {};
+            };
+            if (cd0.hasMultipleRoots && isRoot) {
+              maxDepth++;
+            }
+            trace._maxDepth = maxDepth;
+            trace._backgroundColor = fullLayout.paper_bgcolor;
+            trace._entryDepth = entry.data.depth;
+            trace._atRootLevel = isRoot;
+            var cenX = -vpw / 2 + gs.l + gs.w * (domain.x[1] + domain.x[0]) / 2;
+            var cenY = -vph / 2 + gs.t + gs.h * (1 - (domain.y[1] + domain.y[0]) / 2);
+            var viewMapX = function(x2) {
+              return cenX + x2;
+            };
+            var viewMapY = function(y2) {
+              return cenY + y2;
+            };
+            var barY0 = viewMapY(0);
+            var barX0 = viewMapX(0);
+            var viewBarX = function(x2) {
+              return barX0 + x2;
+            };
+            var viewBarY = function(y2) {
+              return barY0 + y2;
+            };
+            function pos(x2, y2) {
+              return x2 + "," + y2;
+            }
+            var xStart = viewBarX(0);
+            var limitX0 = function(p2) {
+              p2.x = Math.max(xStart, p2.x);
+            };
+            var edgeshape = trace.pathbar.edgeshape;
+            var pathAncestor = function(d2) {
+              var _x0 = viewBarX(Math.max(Math.min(d2.x0, d2.x0), 0));
+              var _x1 = viewBarX(Math.min(Math.max(d2.x1, d2.x1), barW));
+              var _y0 = viewBarY(d2.y0);
+              var _y1 = viewBarY(d2.y1);
+              var halfH = barH / 2;
+              var pL = {};
+              var pR = {};
+              pL.x = _x0;
+              pR.x = _x1;
+              pL.y = pR.y = (_y0 + _y1) / 2;
+              var pA = { x: _x0, y: _y0 };
+              var pB = { x: _x1, y: _y0 };
+              var pC = { x: _x1, y: _y1 };
+              var pD = { x: _x0, y: _y1 };
+              if (edgeshape === ">") {
+                pA.x -= halfH;
+                pB.x -= halfH;
+                pC.x -= halfH;
+                pD.x -= halfH;
+              } else if (edgeshape === "/") {
+                pC.x -= halfH;
+                pD.x -= halfH;
+                pL.x -= halfH / 2;
+                pR.x -= halfH / 2;
+              } else if (edgeshape === "\\") {
+                pA.x -= halfH;
+                pB.x -= halfH;
+                pL.x -= halfH / 2;
+                pR.x -= halfH / 2;
+              } else if (edgeshape === "<") {
+                pL.x -= halfH;
+                pR.x -= halfH;
+              }
+              limitX0(pA);
+              limitX0(pD);
+              limitX0(pL);
+              limitX0(pB);
+              limitX0(pC);
+              limitX0(pR);
+              return "M" + pos(pA.x, pA.y) + "L" + pos(pB.x, pB.y) + "L" + pos(pR.x, pR.y) + "L" + pos(pC.x, pC.y) + "L" + pos(pD.x, pD.y) + "L" + pos(pL.x, pL.y) + "Z";
+            };
+            var pad = trace[isIcicle ? "tiling" : "marker"].pad;
+            var hasFlag = function(f2) {
+              return trace.textposition.indexOf(f2) !== -1;
+            };
+            var hasTop = hasFlag("top");
+            var hasLeft = hasFlag("left");
+            var hasRight = hasFlag("right");
+            var hasBottom = hasFlag("bottom");
+            var pathDescendant = function(d2) {
+              var _x0 = viewMapX(d2.x0);
+              var _x1 = viewMapX(d2.x1);
+              var _y0 = viewMapY(d2.y0);
+              var _y1 = viewMapY(d2.y1);
+              var dx = _x1 - _x0;
+              var dy = _y1 - _y0;
+              if (!dx || !dy) return "";
+              var cornerradius = trace.marker.cornerradius || 0;
+              var r2 = Math.min(cornerradius, dx / 2, dy / 2);
+              if (r2 && d2.data && d2.data.data && d2.data.data.label) {
+                if (hasTop) r2 = Math.min(r2, pad.t);
+                if (hasLeft) r2 = Math.min(r2, pad.l);
+                if (hasRight) r2 = Math.min(r2, pad.r);
+                if (hasBottom) r2 = Math.min(r2, pad.b);
+              }
+              var arc = function(rx, ry) {
+                return r2 ? "a" + pos(r2, r2) + " 0 0 1 " + pos(rx, ry) : "";
+              };
+              return "M" + pos(_x0, _y0 + r2) + arc(r2, -r2) + "L" + pos(_x1 - r2, _y0) + arc(r2, r2) + "L" + pos(_x1, _y1 - r2) + arc(-r2, r2) + "L" + pos(_x0 + r2, _y1) + arc(-r2, -r2) + "Z";
+            };
+            var toMoveInsideSlice = function(pt2, opts) {
+              var x0 = pt2.x0;
+              var x1 = pt2.x1;
+              var y0 = pt2.y0;
+              var y1 = pt2.y1;
+              var textBB = pt2.textBB;
+              var _hasTop = hasTop || opts.isHeader && !hasBottom;
+              var anchor = _hasTop ? "start" : hasBottom ? "end" : "middle";
+              var _hasRight = hasFlag("right");
+              var _hasLeft = hasFlag("left") || opts.onPathbar;
+              var leftToRight = _hasLeft ? -1 : _hasRight ? 1 : 0;
+              if (opts.isHeader) {
+                x0 += (isIcicle ? pad : pad.l) - TEXTPAD;
+                x1 -= (isIcicle ? pad : pad.r) - TEXTPAD;
+                if (x0 >= x1) {
+                  var mid = (x0 + x1) / 2;
+                  x0 = mid;
+                  x1 = mid;
+                }
+                var limY;
+                if (hasBottom) {
+                  limY = y1 - (isIcicle ? pad : pad.b);
+                  if (y0 < limY && limY < y1) y0 = limY;
+                } else {
+                  limY = y0 + (isIcicle ? pad : pad.t);
+                  if (y0 < limY && limY < y1) y1 = limY;
+                }
+              }
+              var transform = toMoveInsideBar(x0, x1, y0, y1, textBB, {
+                isHorizontal: false,
+                constrained: true,
+                angle: 0,
+                anchor,
+                leftToRight
+              });
+              transform.fontSize = opts.fontSize;
+              transform.targetX = viewMapX(transform.targetX);
+              transform.targetY = viewMapY(transform.targetY);
+              if (isNaN(transform.targetX) || isNaN(transform.targetY)) {
+                return {};
+              }
+              if (x0 !== x1 && y0 !== y1) {
+                recordMinTextSize(trace.type, transform, fullLayout);
+              }
+              return {
+                scale: transform.scale,
+                rotate: transform.rotate,
+                textX: transform.textX,
+                textY: transform.textY,
+                anchorX: transform.anchorX,
+                anchorY: transform.anchorY,
+                targetX: transform.targetX,
+                targetY: transform.targetY
+              };
+            };
+            var interpFromParent = function(pt2, onPathbar) {
+              var parentPrev;
+              var i2 = 0;
+              var Q2 = pt2;
+              while (!parentPrev && i2 < maxDepth) {
+                i2++;
+                Q2 = Q2.parent;
+                if (Q2) {
+                  parentPrev = getPrev(Q2, onPathbar);
+                } else i2 = maxDepth;
+              }
+              return parentPrev || {};
+            };
+            var makeExitSliceInterpolator = function(pt2, onPathbar, refRect, size) {
+              var prev = getPrev(pt2, onPathbar);
+              var next;
+              if (onPathbar) {
+                next = pathbarOrigin;
+              } else {
+                var entryPrev = getPrev(entry, onPathbar);
+                if (entryPrev) {
+                  next = findClosestEdge(pt2, entryPrev, size);
+                } else {
+                  next = {};
+                }
+              }
+              return interpolate(prev, next);
+            };
+            var makeUpdateSliceInterpolator = function(pt2, onPathbar, refRect, size, opts) {
+              var prev0 = getPrev(pt2, onPathbar);
+              var prev;
+              if (prev0) {
+                prev = prev0;
+              } else {
+                if (onPathbar) {
+                  prev = pathbarOrigin;
+                } else {
+                  if (prevEntry) {
+                    if (pt2.parent) {
+                      var ref = nextOfPrevEntry || refRect;
+                      if (ref && !onPathbar) {
+                        prev = findClosestEdge(pt2, ref, size);
+                      } else {
+                        prev = {};
+                        Lib.extendFlat(prev, interpFromParent(pt2, onPathbar));
+                      }
+                    } else {
+                      prev = Lib.extendFlat({}, pt2);
+                      if (isIcicle) {
+                        if (opts.orientation === "h") {
+                          if (opts.flipX) prev.x0 = pt2.x1;
+                          else prev.x1 = 0;
+                        } else {
+                          if (opts.flipY) prev.y0 = pt2.y1;
+                          else prev.y1 = 0;
+                        }
+                      }
+                    }
+                  } else {
+                    prev = {};
+                  }
+                }
+              }
+              return interpolate(prev, {
+                x0: pt2.x0,
+                x1: pt2.x1,
+                y0: pt2.y0,
+                y1: pt2.y1
+              });
+            };
+            var makeUpdateTextInterpolator = function(pt2, onPathbar, refRect, size) {
+              var prev0 = getPrev(pt2, onPathbar);
+              var prev = {};
+              var origin = getOrigin(pt2, onPathbar, refRect, size);
+              Lib.extendFlat(prev, {
+                transform: toMoveInsideSlice({
+                  x0: origin.x0,
+                  x1: origin.x1,
+                  y0: origin.y0,
+                  y1: origin.y1,
+                  textBB: pt2.textBB,
+                  _text: pt2._text
+                }, {
+                  isHeader: helpers.isHeader(pt2, trace)
+                })
+              });
+              if (prev0) {
+                prev = prev0;
+              } else {
+                if (pt2.parent) {
+                  Lib.extendFlat(prev, interpFromParent(pt2, onPathbar));
+                }
+              }
+              var transform = pt2.transform;
+              if (pt2.x0 !== pt2.x1 && pt2.y0 !== pt2.y1) {
+                recordMinTextSize(trace.type, transform, fullLayout);
+              }
+              return interpolate(prev, {
+                transform: {
+                  scale: transform.scale,
+                  rotate: transform.rotate,
+                  textX: transform.textX,
+                  textY: transform.textY,
+                  anchorX: transform.anchorX,
+                  anchorY: transform.anchorY,
+                  targetX: transform.targetX,
+                  targetY: transform.targetY
+                }
+              });
+            };
+            var handleSlicesExit = function(slices, onPathbar, refRect, size, pathSlice) {
+              var width = size[0];
+              var height = size[1];
+              if (hasTransition) {
+                slices.exit().transition().each(function() {
+                  var sliceTop = d3.select(this);
+                  var slicePath = sliceTop.select("path.surface");
+                  slicePath.transition().attrTween("d", function(pt2) {
+                    var interp = makeExitSliceInterpolator(pt2, onPathbar, refRect, [width, height]);
+                    return function(t4) {
+                      return pathSlice(interp(t4));
+                    };
+                  });
+                  var sliceTextGroup = sliceTop.select("g.slicetext");
+                  sliceTextGroup.attr("opacity", 0);
+                }).remove();
+              } else {
+                slices.exit().remove();
+              }
+            };
+            var strTransform = function(d2) {
+              var transform = d2.transform;
+              if (d2.x0 !== d2.x1 && d2.y0 !== d2.y1) {
+                recordMinTextSize(trace.type, transform, fullLayout);
+              }
+              return Lib.getTextTransform({
+                textX: transform.textX,
+                textY: transform.textY,
+                anchorX: transform.anchorX,
+                anchorY: transform.anchorY,
+                targetX: transform.targetX,
+                targetY: transform.targetY,
+                scale: transform.scale,
+                rotate: transform.rotate
+              });
+            };
+            if (hasTransition) {
+              selAncestors.each(function(pt2) {
+                prevLookupPathbar[getKey(pt2)] = {
+                  x0: pt2.x0,
+                  x1: pt2.x1,
+                  y0: pt2.y0,
+                  y1: pt2.y1
+                };
+                if (pt2.transform) {
+                  prevLookupPathbar[getKey(pt2)].transform = {
+                    textX: pt2.transform.textX,
+                    textY: pt2.transform.textY,
+                    anchorX: pt2.transform.anchorX,
+                    anchorY: pt2.transform.anchorY,
+                    targetX: pt2.transform.targetX,
+                    targetY: pt2.transform.targetY,
+                    scale: pt2.transform.scale,
+                    rotate: pt2.transform.rotate
+                  };
+                }
+              });
+              selDescendants.each(function(pt2) {
+                prevLookupSlices[getKey(pt2)] = {
+                  x0: pt2.x0,
+                  x1: pt2.x1,
+                  y0: pt2.y0,
+                  y1: pt2.y1
+                };
+                if (pt2.transform) {
+                  prevLookupSlices[getKey(pt2)].transform = {
+                    textX: pt2.transform.textX,
+                    textY: pt2.transform.textY,
+                    anchorX: pt2.transform.anchorX,
+                    anchorY: pt2.transform.anchorY,
+                    targetX: pt2.transform.targetX,
+                    targetY: pt2.transform.targetY,
+                    scale: pt2.transform.scale,
+                    rotate: pt2.transform.rotate
+                  };
+                }
+                if (!prevEntry && helpers.isEntry(pt2)) {
+                  prevEntry = pt2;
+                }
+              });
+            }
+            nextOfPrevEntry = drawDescendants(gd2, cd2, entry, selDescendants, {
+              width: vpw,
+              height: vph,
+              viewX: viewMapX,
+              viewY: viewMapY,
+              pathSlice: pathDescendant,
+              toMoveInsideSlice,
+              prevEntry,
+              makeUpdateSliceInterpolator,
+              makeUpdateTextInterpolator,
+              handleSlicesExit,
+              hasTransition,
+              strTransform
+            });
+            if (trace.pathbar.visible) {
+              drawAncestors(gd2, cd2, entry, selAncestors, {
+                barDifY,
+                width: barW,
+                height: barH,
+                viewX: viewBarX,
+                viewY: viewBarY,
+                pathSlice: pathAncestor,
+                toMoveInsideSlice,
+                makeUpdateSliceInterpolator,
+                makeUpdateTextInterpolator,
+                handleSlicesExit,
+                hasTransition,
+                strTransform
+              });
+            } else {
+              selAncestors.remove();
+            }
+          };
+        }
+      });
+      var require_draw12 = __commonJS({
+        "src/traces/treemap/draw.js"(exports, module2) {
+          var d3 = require_d3();
+          var helpers = require_helpers15();
+          var uniformText = require_uniform_text();
+          var clearMinTextSize = uniformText.clearMinTextSize;
+          var resizeText = require_style4().resizeText;
+          var plotOne = require_plot_one();
+          module2.exports = function _plot(gd2, cdmodule, transitionOpts, makeOnCompleteCallback, opts) {
+            var type = opts.type;
+            var drawDescendants = opts.drawDescendants;
+            var fullLayout = gd2._fullLayout;
+            var layer = fullLayout["_" + type + "layer"];
+            var join, onComplete;
+            var isFullReplot = !transitionOpts;
+            clearMinTextSize(type, fullLayout);
+            join = layer.selectAll("g.trace." + type).data(cdmodule, function(cd2) {
+              return cd2[0].trace.uid;
+            });
+            join.enter().append("g").classed("trace", true).classed(type, true);
+            join.order();
+            if (!fullLayout.uniformtext.mode && helpers.hasTransition(transitionOpts)) {
+              if (makeOnCompleteCallback) {
+                onComplete = makeOnCompleteCallback();
+              }
+              var transition = d3.transition().duration(transitionOpts.duration).ease(transitionOpts.easing).each("end", function() {
+                onComplete && onComplete();
+              }).each("interrupt", function() {
+                onComplete && onComplete();
+              });
+              transition.each(function() {
+                layer.selectAll("g.trace").each(function(cd2) {
+                  plotOne(gd2, cd2, this, transitionOpts, drawDescendants);
+                });
+              });
+            } else {
+              join.each(function(cd2) {
+                plotOne(gd2, cd2, this, transitionOpts, drawDescendants);
+              });
+              if (fullLayout.uniformtext.mode) {
+                resizeText(gd2, layer.selectAll(".trace"), type);
+              }
+            }
+            if (isFullReplot) {
+              join.exit().remove();
+            }
+          };
+        }
+      });
+      var require_draw_descendants = __commonJS({
+        "src/traces/treemap/draw_descendants.js"(exports, module2) {
+          var d3 = require_d3();
+          var Lib = require_lib();
+          var Drawing = require_drawing();
+          var svgTextUtils = require_svg_text_utils();
+          var partition = require_partition();
+          var styleOne = require_style14().styleOne;
+          var constants = require_constants21();
+          var helpers = require_helpers15();
+          var attachFxHandlers = require_fx2();
+          var formatSliceLabel = require_plot13().formatSliceLabel;
+          var onPathbar = false;
+          module2.exports = function drawDescendants(gd2, cd2, entry, slices, opts) {
+            var width = opts.width;
+            var height = opts.height;
+            var viewX = opts.viewX;
+            var viewY = opts.viewY;
+            var pathSlice = opts.pathSlice;
+            var toMoveInsideSlice = opts.toMoveInsideSlice;
+            var strTransform = opts.strTransform;
+            var hasTransition = opts.hasTransition;
+            var handleSlicesExit = opts.handleSlicesExit;
+            var makeUpdateSliceInterpolator = opts.makeUpdateSliceInterpolator;
+            var makeUpdateTextInterpolator = opts.makeUpdateTextInterpolator;
+            var prevEntry = opts.prevEntry;
+            var refRect = {};
+            var isStatic = gd2._context.staticPlot;
+            var fullLayout = gd2._fullLayout;
+            var cd0 = cd2[0];
+            var trace = cd0.trace;
+            var hasLeft = trace.textposition.indexOf("left") !== -1;
+            var hasRight = trace.textposition.indexOf("right") !== -1;
+            var hasBottom = trace.textposition.indexOf("bottom") !== -1;
+            var noRoomForHeader = !hasBottom && !trace.marker.pad.t || hasBottom && !trace.marker.pad.b;
+            var allData = partition(entry, [width, height], {
+              packing: trace.tiling.packing,
+              squarifyratio: trace.tiling.squarifyratio,
+              flipX: trace.tiling.flip.indexOf("x") > -1,
+              flipY: trace.tiling.flip.indexOf("y") > -1,
+              pad: {
+                inner: trace.tiling.pad,
+                top: trace.marker.pad.t,
+                left: trace.marker.pad.l,
+                right: trace.marker.pad.r,
+                bottom: trace.marker.pad.b
+              }
+            });
+            var sliceData = allData.descendants();
+            var minVisibleDepth = Infinity;
+            var maxVisibleDepth = -Infinity;
+            sliceData.forEach(function(pt2) {
+              var depth = pt2.depth;
+              if (depth >= trace._maxDepth) {
+                pt2.x0 = pt2.x1 = (pt2.x0 + pt2.x1) / 2;
+                pt2.y0 = pt2.y1 = (pt2.y0 + pt2.y1) / 2;
+              } else {
+                minVisibleDepth = Math.min(minVisibleDepth, depth);
+                maxVisibleDepth = Math.max(maxVisibleDepth, depth);
+              }
+            });
+            slices = slices.data(sliceData, helpers.getPtId);
+            trace._maxVisibleLayers = isFinite(maxVisibleDepth) ? maxVisibleDepth - minVisibleDepth + 1 : 0;
+            slices.enter().append("g").classed("slice", true);
+            handleSlicesExit(slices, onPathbar, refRect, [width, height], pathSlice);
+            slices.order();
+            var nextOfPrevEntry = null;
+            if (hasTransition && prevEntry) {
+              var prevEntryId = helpers.getPtId(prevEntry);
+              slices.each(function(pt2) {
+                if (nextOfPrevEntry === null && helpers.getPtId(pt2) === prevEntryId) {
+                  nextOfPrevEntry = {
+                    x0: pt2.x0,
+                    x1: pt2.x1,
+                    y0: pt2.y0,
+                    y1: pt2.y1
+                  };
+                }
+              });
+            }
+            var getRefRect = function() {
+              return nextOfPrevEntry || {
+                x0: 0,
+                x1: width,
+                y0: 0,
+                y1: height
+              };
+            };
+            var updateSlices = slices;
+            if (hasTransition) {
+              updateSlices = updateSlices.transition().each("end", function() {
+                var sliceTop = d3.select(this);
+                helpers.setSliceCursor(sliceTop, gd2, {
+                  hideOnRoot: true,
+                  hideOnLeaves: false,
+                  isTransitioning: false
+                });
+              });
+            }
+            updateSlices.each(function(pt2) {
+              var isHeader = helpers.isHeader(pt2, trace);
+              pt2._x0 = viewX(pt2.x0);
+              pt2._x1 = viewX(pt2.x1);
+              pt2._y0 = viewY(pt2.y0);
+              pt2._y1 = viewY(pt2.y1);
+              pt2._hoverX = viewX(pt2.x1 - trace.marker.pad.r), pt2._hoverY = hasBottom ? viewY(pt2.y1 - trace.marker.pad.b / 2) : viewY(pt2.y0 + trace.marker.pad.t / 2);
+              var sliceTop = d3.select(this);
+              var slicePath = Lib.ensureSingle(sliceTop, "path", "surface", function(s2) {
+                s2.style("pointer-events", isStatic ? "none" : "all");
+              });
+              if (hasTransition) {
+                slicePath.transition().attrTween("d", function(pt22) {
+                  var interp = makeUpdateSliceInterpolator(pt22, onPathbar, getRefRect(), [width, height]);
+                  return function(t4) {
+                    return pathSlice(interp(t4));
+                  };
+                });
+              } else {
+                slicePath.attr("d", pathSlice);
+              }
+              sliceTop.call(attachFxHandlers, entry, gd2, cd2, {
+                styleOne,
+                eventDataKeys: constants.eventDataKeys,
+                transitionTime: constants.CLICK_TRANSITION_TIME,
+                transitionEasing: constants.CLICK_TRANSITION_EASING
+              }).call(helpers.setSliceCursor, gd2, { isTransitioning: gd2._transitioning });
+              slicePath.call(styleOne, pt2, trace, gd2, {
+                hovered: false
+              });
+              if (pt2.x0 === pt2.x1 || pt2.y0 === pt2.y1) {
+                pt2._text = "";
+              } else {
+                if (isHeader) {
+                  pt2._text = noRoomForHeader ? "" : helpers.getPtLabel(pt2) || "";
+                } else {
+                  pt2._text = formatSliceLabel(pt2, entry, trace, cd2, fullLayout) || "";
+                }
+              }
+              var sliceTextGroup = Lib.ensureSingle(sliceTop, "g", "slicetext");
+              var sliceText = Lib.ensureSingle(sliceTextGroup, "text", "", function(s2) {
+                s2.attr("data-notex", 1);
+              });
+              var font = Lib.ensureUniformFontSize(gd2, helpers.determineTextFont(trace, pt2, fullLayout.font));
+              var text = pt2._text || " ";
+              var singleLineHeader = isHeader && text.indexOf("<br>") === -1;
+              sliceText.text(text).classed("slicetext", true).attr("text-anchor", hasRight ? "end" : hasLeft || singleLineHeader ? "start" : "middle").call(Drawing.font, font).call(svgTextUtils.convertToTspans, gd2);
+              pt2.textBB = Drawing.bBox(sliceText.node());
+              pt2.transform = toMoveInsideSlice(pt2, {
+                fontSize: font.size,
+                isHeader
+              });
+              pt2.transform.fontSize = font.size;
+              if (hasTransition) {
+                sliceText.transition().attrTween("transform", function(pt22) {
+                  var interp = makeUpdateTextInterpolator(pt22, onPathbar, getRefRect(), [width, height]);
+                  return function(t4) {
+                    return strTransform(interp(t4));
+                  };
+                });
+              } else {
+                sliceText.attr("transform", strTransform(pt2));
+              }
+            });
+            return nextOfPrevEntry;
+          };
+        }
+      });
+      var require_plot14 = __commonJS({
+        "src/traces/treemap/plot.js"(exports, module2) {
+          var draw = require_draw12();
+          var drawDescendants = require_draw_descendants();
+          module2.exports = function _plot(gd2, cdmodule, transitionOpts, makeOnCompleteCallback) {
+            return draw(gd2, cdmodule, transitionOpts, makeOnCompleteCallback, {
+              type: "treemap",
+              drawDescendants
+            });
+          };
+        }
+      });
+      var require_treemap = __commonJS({
+        "src/traces/treemap/index.js"(exports, module2) {
+          module2.exports = {
+            moduleType: "trace",
+            name: "treemap",
+            basePlotModule: require_base_plot3(),
+            categories: [],
+            animatable: true,
+            attributes: require_attributes37(),
+            layoutAttributes: require_layout_attributes14(),
+            supplyDefaults: require_defaults33(),
+            supplyLayoutDefaults: require_layout_defaults13(),
+            calc: require_calc18().calc,
+            crossTraceCalc: require_calc18().crossTraceCalc,
+            plot: require_plot14(),
+            style: require_style14().style,
+            colorbar: require_marker_colorbar(),
+            meta: {}
+          };
+        }
+      });
+      var require_treemap2 = __commonJS({
+        "lib/treemap.js"(exports, module2) {
+          module2.exports = require_treemap();
+        }
+      });
+      var require_base_plot4 = __commonJS({
+        "src/traces/icicle/base_plot.js"(exports) {
+          var plots = require_plots();
+          exports.name = "icicle";
+          exports.plot = function(gd2, traces, transitionOpts, makeOnCompleteCallback) {
+            plots.plotBasePlot(exports.name, gd2, traces, transitionOpts, makeOnCompleteCallback);
+          };
+          exports.clean = function(newFullData, newFullLayout, oldFullData, oldFullLayout) {
+            plots.cleanBasePlot(exports.name, newFullData, newFullLayout, oldFullData, oldFullLayout);
+          };
+        }
+      });
+      var require_attributes38 = __commonJS({
+        "src/traces/icicle/attributes.js"(exports, module2) {
+          var { hovertemplateAttrs, texttemplateAttrs, templatefallbackAttrs } = require_template_attributes();
+          var colorScaleAttrs = require_attributes8();
+          var domainAttrs = require_domain().attributes;
+          var pieAttrs = require_attributes35();
+          var sunburstAttrs = require_attributes36();
+          var treemapAttrs = require_attributes37();
+          var constants = require_constants21();
+          var extendFlat = require_extend().extendFlat;
+          var pattern = require_attributes4().pattern;
+          module2.exports = {
+            labels: sunburstAttrs.labels,
+            parents: sunburstAttrs.parents,
+            values: sunburstAttrs.values,
+            branchvalues: sunburstAttrs.branchvalues,
+            count: sunburstAttrs.count,
+            level: sunburstAttrs.level,
+            maxdepth: sunburstAttrs.maxdepth,
+            tiling: {
+              orientation: {
+                valType: "enumerated",
+                values: ["v", "h"],
+                dflt: "h",
+                editType: "plot"
+              },
+              flip: treemapAttrs.tiling.flip,
+              pad: {
+                valType: "number",
+                min: 0,
+                dflt: 0,
+                editType: "plot"
+              },
+              editType: "calc"
+            },
+            marker: extendFlat(
+              {
+                colors: sunburstAttrs.marker.colors,
+                line: sunburstAttrs.marker.line,
+                pattern,
+                editType: "calc"
+              },
+              colorScaleAttrs("marker", {
+                colorAttr: "colors",
+                anim: false
+                // TODO: set to anim: true?
+              })
+            ),
+            leaf: sunburstAttrs.leaf,
+            pathbar: treemapAttrs.pathbar,
+            text: pieAttrs.text,
+            textinfo: sunburstAttrs.textinfo,
+            // TODO: incorporate `label` and `value` in the eventData
+            texttemplate: texttemplateAttrs({ editType: "plot" }, { keys: constants.eventDataKeys.concat(["label", "value"]) }),
+            texttemplatefallback: templatefallbackAttrs({ editType: "plot" }),
+            hovertext: pieAttrs.hovertext,
+            hoverinfo: sunburstAttrs.hoverinfo,
+            hovertemplate: hovertemplateAttrs({}, { keys: constants.eventDataKeys }),
+            hovertemplatefallback: templatefallbackAttrs(),
+            textfont: pieAttrs.textfont,
+            insidetextfont: pieAttrs.insidetextfont,
+            outsidetextfont: treemapAttrs.outsidetextfont,
+            textposition: treemapAttrs.textposition,
+            sort: pieAttrs.sort,
+            root: sunburstAttrs.root,
+            domain: domainAttrs({ name: "icicle", trace: true, editType: "calc" })
+          };
+        }
+      });
+      var require_layout_attributes15 = __commonJS({
+        "src/traces/icicle/layout_attributes.js"(exports, module2) {
+          module2.exports = {
+            iciclecolorway: {
+              valType: "colorlist",
+              editType: "calc"
+            },
+            extendiciclecolors: {
+              valType: "boolean",
+              dflt: true,
+              editType: "calc"
+            }
+          };
+        }
+      });
+      var require_defaults34 = __commonJS({
+        "src/traces/icicle/defaults.js"(exports, module2) {
+          var Lib = require_lib();
+          var attributes = require_attributes38();
+          var Color2 = require_color();
+          var handleDomainDefaults = require_domain().defaults;
+          var handleText = require_defaults19().handleText;
+          var TEXTPAD = require_constants9().TEXTPAD;
+          var handleMarkerDefaults = require_defaults31().handleMarkerDefaults;
+          var Colorscale = require_colorscale();
+          var hasColorscale = Colorscale.hasColorscale;
+          var colorscaleDefaults = Colorscale.handleDefaults;
+          module2.exports = function supplyDefaults(traceIn, traceOut, defaultColor, layout) {
+            function coerce(attr, dflt) {
+              return Lib.coerce(traceIn, traceOut, attributes, attr, dflt);
+            }
+            var labels = coerce("labels");
+            var parents = coerce("parents");
+            if (!labels || !labels.length || !parents || !parents.length) {
+              traceOut.visible = false;
+              return;
+            }
+            var vals = coerce("values");
+            if (vals && vals.length) {
+              coerce("branchvalues");
+            } else {
+              coerce("count");
+            }
+            coerce("level");
+            coerce("maxdepth");
+            coerce("tiling.orientation");
+            coerce("tiling.flip");
+            coerce("tiling.pad");
+            var text = coerce("text");
+            coerce("texttemplate");
+            coerce("texttemplatefallback");
+            if (!traceOut.texttemplate) coerce("textinfo", Lib.isArrayOrTypedArray(text) ? "text+label" : "label");
+            coerce("hovertext");
+            coerce("hovertemplate");
+            coerce("hovertemplatefallback");
+            var hasPathbar = coerce("pathbar.visible");
+            var textposition = "auto";
+            handleText(traceIn, traceOut, layout, coerce, textposition, {
+              hasPathbar,
+              moduleHasSelected: false,
+              moduleHasUnselected: false,
+              moduleHasConstrain: false,
+              moduleHasCliponaxis: false,
+              moduleHasTextangle: false,
+              moduleHasInsideanchor: false
+            });
+            coerce("textposition");
+            handleMarkerDefaults(traceIn, traceOut, layout, coerce);
+            var withColorscale = traceOut._hasColorscale = hasColorscale(traceIn, "marker", "colors") || (traceIn.marker || {}).coloraxis;
+            if (withColorscale) {
+              colorscaleDefaults(traceIn, traceOut, layout, coerce, { prefix: "marker.", cLetter: "c" });
+            }
+            coerce("leaf.opacity", withColorscale ? 1 : 0.7);
+            traceOut._hovered = {
+              marker: {
+                line: {
+                  width: 2,
+                  color: Color2.contrast(layout.paper_bgcolor)
+                }
+              }
+            };
+            if (hasPathbar) {
+              coerce("pathbar.thickness", traceOut.pathbar.textfont.size + 2 * TEXTPAD);
+              coerce("pathbar.side");
+              coerce("pathbar.edgeshape");
+            }
+            coerce("sort");
+            coerce("root.color");
+            handleDomainDefaults(traceOut, layout, coerce);
+            traceOut._length = null;
+          };
+        }
+      });
+      var require_layout_defaults14 = __commonJS({
+        "src/traces/icicle/layout_defaults.js"(exports, module2) {
+          var Lib = require_lib();
+          var layoutAttributes = require_layout_attributes15();
+          module2.exports = function supplyLayoutDefaults(layoutIn, layoutOut) {
+            function coerce(attr, dflt) {
+              return Lib.coerce(layoutIn, layoutOut, layoutAttributes, attr, dflt);
+            }
+            coerce("iciclecolorway", layoutOut.colorway);
+            coerce("extendiciclecolors");
+          };
+        }
+      });
+      var require_calc19 = __commonJS({
+        "src/traces/icicle/calc.js"(exports) {
+          var calc = require_calc17();
+          exports.calc = function(gd2, trace) {
+            return calc.calc(gd2, trace);
+          };
+          exports.crossTraceCalc = function(gd2) {
+            return calc._runCrossTraceCalc("icicle", gd2);
+          };
+        }
+      });
+      var require_partition2 = __commonJS({
+        "src/traces/icicle/partition.js"(exports, module2) {
+          var d3Hierarchy = require_d3_hierarchy();
+          var flipTree = require_flip_tree();
+          module2.exports = function partition(entry, size, opts) {
+            var flipX = opts.flipX;
+            var flipY = opts.flipY;
+            var swapXY = opts.orientation === "h";
+            var maxDepth = opts.maxDepth;
+            var newWidth = size[0];
+            var newHeight = size[1];
+            if (maxDepth) {
+              newWidth = (entry.height + 1) * size[0] / Math.min(entry.height + 1, maxDepth);
+              newHeight = (entry.height + 1) * size[1] / Math.min(entry.height + 1, maxDepth);
+            }
+            var result = d3Hierarchy.partition().padding(opts.pad.inner).size(
+              swapXY ? [size[1], newWidth] : [size[0], newHeight]
+            )(entry);
+            if (swapXY || flipX || flipY) {
+              flipTree(result, size, {
+                swapXY,
+                flipX,
+                flipY
+              });
+            }
+            return result;
+          };
+        }
+      });
+      var require_style15 = __commonJS({
+        "src/traces/icicle/style.js"(exports, module2) {
+          var d3 = require_d3();
+          var Color2 = require_color();
+          var Lib = require_lib();
+          var resizeText = require_uniform_text().resizeText;
+          var fillOne = require_fill_one2();
+          function style(gd2) {
+            var s2 = gd2._fullLayout._iciclelayer.selectAll(".trace");
+            resizeText(gd2, s2, "icicle");
+            s2.each(function(cd2) {
+              var gTrace = d3.select(this);
+              var cd0 = cd2[0];
+              var trace = cd0.trace;
+              gTrace.style("opacity", trace.opacity);
+              gTrace.selectAll("path.surface").each(function(pt2) {
+                d3.select(this).call(styleOne, pt2, trace, gd2);
+              });
+            });
+          }
+          function styleOne(s2, pt2, trace, gd2) {
+            var cdi = pt2.data.data;
+            var isLeaf = !pt2.children;
+            var ptNumber = cdi.i;
+            var lineColor = Lib.castOption(trace, ptNumber, "marker.line.color") || Color2.defaultLine;
+            var lineWidth = Lib.castOption(trace, ptNumber, "marker.line.width") || 0;
+            s2.call(fillOne, pt2, trace, gd2).style("stroke-width", lineWidth).call(Color2.stroke, lineColor).style("opacity", isLeaf ? trace.leaf.opacity : null);
+          }
+          module2.exports = {
+            style,
+            styleOne
+          };
+        }
+      });
+      var require_draw_descendants2 = __commonJS({
+        "src/traces/icicle/draw_descendants.js"(exports, module2) {
+          var d3 = require_d3();
+          var Lib = require_lib();
+          var Drawing = require_drawing();
+          var svgTextUtils = require_svg_text_utils();
+          var partition = require_partition2();
+          var styleOne = require_style15().styleOne;
+          var constants = require_constants21();
+          var helpers = require_helpers15();
+          var attachFxHandlers = require_fx2();
+          var formatSliceLabel = require_plot13().formatSliceLabel;
+          var onPathbar = false;
+          module2.exports = function drawDescendants(gd2, cd2, entry, slices, opts) {
+            var width = opts.width;
+            var height = opts.height;
+            var viewX = opts.viewX;
+            var viewY = opts.viewY;
+            var pathSlice = opts.pathSlice;
+            var toMoveInsideSlice = opts.toMoveInsideSlice;
+            var strTransform = opts.strTransform;
+            var hasTransition = opts.hasTransition;
+            var handleSlicesExit = opts.handleSlicesExit;
+            var makeUpdateSliceInterpolator = opts.makeUpdateSliceInterpolator;
+            var makeUpdateTextInterpolator = opts.makeUpdateTextInterpolator;
+            var prevEntry = opts.prevEntry;
+            var refRect = {};
+            var isStatic = gd2._context.staticPlot;
+            var fullLayout = gd2._fullLayout;
+            var cd0 = cd2[0];
+            var trace = cd0.trace;
+            var hasLeft = trace.textposition.indexOf("left") !== -1;
+            var hasRight = trace.textposition.indexOf("right") !== -1;
+            var hasBottom = trace.textposition.indexOf("bottom") !== -1;
+            var allData = partition(entry, [width, height], {
+              flipX: trace.tiling.flip.indexOf("x") > -1,
+              flipY: trace.tiling.flip.indexOf("y") > -1,
+              orientation: trace.tiling.orientation,
+              pad: {
+                inner: trace.tiling.pad
+              },
+              maxDepth: trace._maxDepth
+            });
+            var sliceData = allData.descendants();
+            var minVisibleDepth = Infinity;
+            var maxVisibleDepth = -Infinity;
+            sliceData.forEach(function(pt2) {
+              var depth = pt2.depth;
+              if (depth >= trace._maxDepth) {
+                pt2.x0 = pt2.x1 = (pt2.x0 + pt2.x1) / 2;
+                pt2.y0 = pt2.y1 = (pt2.y0 + pt2.y1) / 2;
+              } else {
+                minVisibleDepth = Math.min(minVisibleDepth, depth);
+                maxVisibleDepth = Math.max(maxVisibleDepth, depth);
+              }
+            });
+            slices = slices.data(sliceData, helpers.getPtId);
+            trace._maxVisibleLayers = isFinite(maxVisibleDepth) ? maxVisibleDepth - minVisibleDepth + 1 : 0;
+            slices.enter().append("g").classed("slice", true);
+            handleSlicesExit(slices, onPathbar, refRect, [width, height], pathSlice);
+            slices.order();
+            var nextOfPrevEntry = null;
+            if (hasTransition && prevEntry) {
+              var prevEntryId = helpers.getPtId(prevEntry);
+              slices.each(function(pt2) {
+                if (nextOfPrevEntry === null && helpers.getPtId(pt2) === prevEntryId) {
+                  nextOfPrevEntry = {
+                    x0: pt2.x0,
+                    x1: pt2.x1,
+                    y0: pt2.y0,
+                    y1: pt2.y1
+                  };
+                }
+              });
+            }
+            var getRefRect = function() {
+              return nextOfPrevEntry || {
+                x0: 0,
+                x1: width,
+                y0: 0,
+                y1: height
+              };
+            };
+            var updateSlices = slices;
+            if (hasTransition) {
+              updateSlices = updateSlices.transition().each("end", function() {
+                var sliceTop = d3.select(this);
+                helpers.setSliceCursor(sliceTop, gd2, {
+                  hideOnRoot: true,
+                  hideOnLeaves: false,
+                  isTransitioning: false
+                });
+              });
+            }
+            updateSlices.each(function(pt2) {
+              pt2._x0 = viewX(pt2.x0);
+              pt2._x1 = viewX(pt2.x1);
+              pt2._y0 = viewY(pt2.y0);
+              pt2._y1 = viewY(pt2.y1);
+              pt2._hoverX = viewX(pt2.x1 - trace.tiling.pad), pt2._hoverY = hasBottom ? viewY(pt2.y1 - trace.tiling.pad / 2) : viewY(pt2.y0 + trace.tiling.pad / 2);
+              var sliceTop = d3.select(this);
+              var slicePath = Lib.ensureSingle(sliceTop, "path", "surface", function(s2) {
+                s2.style("pointer-events", isStatic ? "none" : "all");
+              });
+              if (hasTransition) {
+                slicePath.transition().attrTween("d", function(pt22) {
+                  var interp = makeUpdateSliceInterpolator(
+                    pt22,
+                    onPathbar,
+                    getRefRect(),
+                    [width, height],
+                    {
+                      orientation: trace.tiling.orientation,
+                      flipX: trace.tiling.flip.indexOf("x") > -1,
+                      flipY: trace.tiling.flip.indexOf("y") > -1
+                    }
+                  );
+                  return function(t4) {
+                    return pathSlice(interp(t4));
+                  };
+                });
+              } else {
+                slicePath.attr("d", pathSlice);
+              }
+              sliceTop.call(attachFxHandlers, entry, gd2, cd2, {
+                styleOne,
+                eventDataKeys: constants.eventDataKeys,
+                transitionTime: constants.CLICK_TRANSITION_TIME,
+                transitionEasing: constants.CLICK_TRANSITION_EASING
+              }).call(helpers.setSliceCursor, gd2, { isTransitioning: gd2._transitioning });
+              slicePath.call(styleOne, pt2, trace, gd2, {
+                hovered: false
+              });
+              if (pt2.x0 === pt2.x1 || pt2.y0 === pt2.y1) {
+                pt2._text = "";
+              } else {
+                pt2._text = formatSliceLabel(pt2, entry, trace, cd2, fullLayout) || "";
+              }
+              var sliceTextGroup = Lib.ensureSingle(sliceTop, "g", "slicetext");
+              var sliceText = Lib.ensureSingle(sliceTextGroup, "text", "", function(s2) {
+                s2.attr("data-notex", 1);
+              });
+              var font = Lib.ensureUniformFontSize(gd2, helpers.determineTextFont(trace, pt2, fullLayout.font));
+              sliceText.text(pt2._text || " ").classed("slicetext", true).attr("text-anchor", hasRight ? "end" : hasLeft ? "start" : "middle").call(Drawing.font, font).call(svgTextUtils.convertToTspans, gd2);
+              pt2.textBB = Drawing.bBox(sliceText.node());
+              pt2.transform = toMoveInsideSlice(pt2, {
+                fontSize: font.size
+              });
+              pt2.transform.fontSize = font.size;
+              if (hasTransition) {
+                sliceText.transition().attrTween("transform", function(pt22) {
+                  var interp = makeUpdateTextInterpolator(pt22, onPathbar, getRefRect(), [width, height]);
+                  return function(t4) {
+                    return strTransform(interp(t4));
+                  };
+                });
+              } else {
+                sliceText.attr("transform", strTransform(pt2));
+              }
+            });
+            return nextOfPrevEntry;
+          };
+        }
+      });
+      var require_plot15 = __commonJS({
+        "src/traces/icicle/plot.js"(exports, module2) {
+          var draw = require_draw12();
+          var drawDescendants = require_draw_descendants2();
+          module2.exports = function _plot(gd2, cdmodule, transitionOpts, makeOnCompleteCallback) {
+            return draw(gd2, cdmodule, transitionOpts, makeOnCompleteCallback, {
+              type: "icicle",
+              drawDescendants
+            });
+          };
+        }
+      });
+      var require_icicle = __commonJS({
+        "src/traces/icicle/index.js"(exports, module2) {
+          module2.exports = {
+            moduleType: "trace",
+            name: "icicle",
+            basePlotModule: require_base_plot4(),
+            categories: [],
+            animatable: true,
+            attributes: require_attributes38(),
+            layoutAttributes: require_layout_attributes15(),
+            supplyDefaults: require_defaults34(),
+            supplyLayoutDefaults: require_layout_defaults14(),
+            calc: require_calc19().calc,
+            crossTraceCalc: require_calc19().crossTraceCalc,
+            plot: require_plot15(),
+            style: require_style15().style,
+            colorbar: require_marker_colorbar(),
+            meta: {}
+          };
+        }
+      });
+      var require_icicle2 = __commonJS({
+        "lib/icicle.js"(exports, module2) {
+          module2.exports = require_icicle();
+        }
+      });
+      var require_base_plot5 = __commonJS({
+        "src/traces/funnelarea/base_plot.js"(exports) {
+          var plots = require_plots();
+          exports.name = "funnelarea";
+          exports.plot = function(gd2, traces, transitionOpts, makeOnCompleteCallback) {
+            plots.plotBasePlot(exports.name, gd2, traces, transitionOpts, makeOnCompleteCallback);
+          };
+          exports.clean = function(newFullData, newFullLayout, oldFullData, oldFullLayout) {
+            plots.cleanBasePlot(exports.name, newFullData, newFullLayout, oldFullData, oldFullLayout);
+          };
+        }
+      });
+      var require_attributes39 = __commonJS({
+        "src/traces/funnelarea/attributes.js"(exports, module2) {
+          var pieAttrs = require_attributes35();
+          var baseAttrs = require_attributes2();
+          var domainAttrs = require_domain().attributes;
+          var { hovertemplateAttrs, texttemplateAttrs, templatefallbackAttrs } = require_template_attributes();
+          var extendFlat = require_extend().extendFlat;
+          module2.exports = {
+            labels: pieAttrs.labels,
+            // equivalent of x0 and dx, if label is missing
+            label0: pieAttrs.label0,
+            dlabel: pieAttrs.dlabel,
+            values: pieAttrs.values,
+            marker: {
+              colors: pieAttrs.marker.colors,
+              line: {
+                color: extendFlat({}, pieAttrs.marker.line.color, {
+                  dflt: null
+                }),
+                width: extendFlat({}, pieAttrs.marker.line.width, { dflt: 1 }),
+                editType: "calc"
+              },
+              pattern: pieAttrs.marker.pattern,
+              editType: "calc"
+            },
+            text: pieAttrs.text,
+            hovertext: pieAttrs.hovertext,
+            scalegroup: extendFlat({}, pieAttrs.scalegroup, {}),
+            textinfo: extendFlat({}, pieAttrs.textinfo, {
+              flags: ["label", "text", "value", "percent"]
+            }),
+            texttemplate: texttemplateAttrs({ editType: "plot" }, { keys: ["label", "color", "value", "text", "percent"] }),
+            texttemplatefallback: templatefallbackAttrs({ editType: "plot" }),
+            hoverinfo: extendFlat({}, baseAttrs.hoverinfo, {
+              flags: ["label", "text", "value", "percent", "name"]
+            }),
+            hovertemplate: hovertemplateAttrs({}, { keys: ["label", "color", "value", "text", "percent"] }),
+            hovertemplatefallback: templatefallbackAttrs(),
+            textposition: extendFlat({}, pieAttrs.textposition, {
+              values: ["inside", "none"],
+              dflt: "inside"
+            }),
+            textfont: pieAttrs.textfont,
+            insidetextfont: pieAttrs.insidetextfont,
+            title: {
+              text: pieAttrs.title.text,
+              font: pieAttrs.title.font,
+              position: extendFlat({}, pieAttrs.title.position, {
+                values: ["top left", "top center", "top right"],
+                dflt: "top center"
+              }),
+              editType: "plot"
+            },
+            domain: domainAttrs({ name: "funnelarea", trace: true, editType: "calc" }),
+            aspectratio: {
+              valType: "number",
+              min: 0,
+              dflt: 1,
+              editType: "plot"
+            },
+            baseratio: {
+              valType: "number",
+              min: 0,
+              max: 1,
+              dflt: 0.333,
+              editType: "plot"
+            }
+          };
+        }
+      });
+      var require_layout_attributes16 = __commonJS({
+        "src/traces/funnelarea/layout_attributes.js"(exports, module2) {
+          var hiddenlabels = require_layout_attributes12().hiddenlabels;
+          module2.exports = {
+            hiddenlabels,
+            funnelareacolorway: {
+              valType: "colorlist",
+              editType: "calc"
+            },
+            extendfunnelareacolors: {
+              valType: "boolean",
+              dflt: true,
+              editType: "calc"
+            }
+          };
+        }
+      });
+      var require_defaults35 = __commonJS({
+        "src/traces/funnelarea/defaults.js"(exports, module2) {
+          var Lib = require_lib();
+          var attributes = require_attributes39();
+          var handleDomainDefaults = require_domain().defaults;
+          var handleText = require_defaults19().handleText;
+          var handleLabelsAndValues = require_defaults31().handleLabelsAndValues;
+          var handleMarkerDefaults = require_defaults31().handleMarkerDefaults;
+          module2.exports = function supplyDefaults(traceIn, traceOut, defaultColor, layout) {
+            function coerce(attr, dflt) {
+              return Lib.coerce(traceIn, traceOut, attributes, attr, dflt);
+            }
+            var labels = coerce("labels");
+            var values = coerce("values");
+            var res = handleLabelsAndValues(labels, values);
+            var len2 = res.len;
+            traceOut._hasLabels = res.hasLabels;
+            traceOut._hasValues = res.hasValues;
+            if (!traceOut._hasLabels && traceOut._hasValues) {
+              coerce("label0");
+              coerce("dlabel");
+            }
+            if (!len2) {
+              traceOut.visible = false;
+              return;
+            }
+            traceOut._length = len2;
+            handleMarkerDefaults(traceIn, traceOut, layout, coerce);
+            coerce("scalegroup");
+            var textData = coerce("text");
+            var textTemplate = coerce("texttemplate");
+            coerce("texttemplatefallback");
+            var textInfo;
+            if (!textTemplate) textInfo = coerce("textinfo", Array.isArray(textData) ? "text+percent" : "percent");
+            coerce("hovertext");
+            coerce("hovertemplate");
+            coerce("hovertemplatefallback");
+            if (textTemplate || textInfo && textInfo !== "none") {
+              var textposition = coerce("textposition");
+              handleText(traceIn, traceOut, layout, coerce, textposition, {
+                moduleHasSelected: false,
+                moduleHasUnselected: false,
+                moduleHasConstrain: false,
+                moduleHasCliponaxis: false,
+                moduleHasTextangle: false,
+                moduleHasInsideanchor: false
+              });
+            } else if (textInfo === "none") {
+              coerce("textposition", "none");
+            }
+            handleDomainDefaults(traceOut, layout, coerce);
+            var title = coerce("title.text");
+            if (title) {
+              coerce("title.position");
+              Lib.coerceFont(coerce, "title.font", layout.font);
+            }
+            coerce("aspectratio");
+            coerce("baseratio");
+          };
+        }
+      });
+      var require_layout_defaults15 = __commonJS({
+        "src/traces/funnelarea/layout_defaults.js"(exports, module2) {
+          var Lib = require_lib();
+          var layoutAttributes = require_layout_attributes16();
+          module2.exports = function supplyLayoutDefaults(layoutIn, layoutOut) {
+            function coerce(attr, dflt) {
+              return Lib.coerce(layoutIn, layoutOut, layoutAttributes, attr, dflt);
+            }
+            coerce("hiddenlabels");
+            coerce("funnelareacolorway", layoutOut.colorway);
+            coerce("extendfunnelareacolors");
+          };
+        }
+      });
+      var require_calc20 = __commonJS({
+        "src/traces/funnelarea/calc.js"(exports, module2) {
+          var pieCalc = require_calc16();
+          function calc(gd2, trace) {
+            return pieCalc.calc(gd2, trace);
+          }
+          function crossTraceCalc(gd2) {
+            pieCalc.crossTraceCalc(gd2, { type: "funnelarea" });
+          }
+          module2.exports = {
+            calc,
+            crossTraceCalc
+          };
+        }
+      });
+      var require_plot16 = __commonJS({
+        "src/traces/funnelarea/plot.js"(exports, module2) {
+          var d3 = require_d3();
+          var Drawing = require_drawing();
+          var Lib = require_lib();
+          var strScale = Lib.strScale;
+          var strTranslate = Lib.strTranslate;
+          var svgTextUtils = require_svg_text_utils();
+          var barPlot = require_plot3();
+          var toMoveInsideBar = barPlot.toMoveInsideBar;
+          var uniformText = require_uniform_text();
+          var recordMinTextSize = uniformText.recordMinTextSize;
+          var clearMinTextSize = uniformText.clearMinTextSize;
+          var pieHelpers = require_helpers4();
+          var piePlot = require_plot12();
+          var attachFxHandlers = piePlot.attachFxHandlers;
+          var determineInsideTextFont = piePlot.determineInsideTextFont;
+          var layoutAreas = piePlot.layoutAreas;
+          var prerenderTitles = piePlot.prerenderTitles;
+          var positionTitleOutside = piePlot.positionTitleOutside;
+          var formatSliceLabel = piePlot.formatSliceLabel;
+          module2.exports = function plot(gd2, cdModule) {
+            var isStatic = gd2._context.staticPlot;
+            var fullLayout = gd2._fullLayout;
+            clearMinTextSize("funnelarea", fullLayout);
+            prerenderTitles(cdModule, gd2);
+            layoutAreas(cdModule, fullLayout._size);
+            Lib.makeTraceGroups(fullLayout._funnelarealayer, cdModule, "trace").each(function(cd2) {
+              var plotGroup = d3.select(this);
+              var cd0 = cd2[0];
+              var trace = cd0.trace;
+              setCoords(cd2);
+              plotGroup.each(function() {
+                var slices = d3.select(this).selectAll("g.slice").data(cd2);
+                slices.enter().append("g").classed("slice", true);
+                slices.exit().remove();
+                slices.each(function(pt2, i2) {
+                  if (pt2.hidden) {
+                    d3.select(this).selectAll("path,g").remove();
+                    return;
+                  }
+                  pt2.pointNumber = pt2.i;
+                  pt2.curveNumber = trace.index;
+                  var cx = cd0.cx;
+                  var cy = cd0.cy;
+                  var sliceTop = d3.select(this);
+                  var slicePath = sliceTop.selectAll("path.surface").data([pt2]);
+                  slicePath.enter().append("path").classed("surface", true).style({ "pointer-events": isStatic ? "none" : "all" });
+                  sliceTop.call(attachFxHandlers, gd2, cd2);
+                  var shape = "M" + (cx + pt2.TR[0]) + "," + (cy + pt2.TR[1]) + line(pt2.TR, pt2.BR) + line(pt2.BR, pt2.BL) + line(pt2.BL, pt2.TL) + "Z";
+                  slicePath.attr("d", shape);
+                  formatSliceLabel(gd2, pt2, cd0);
+                  var textPosition = pieHelpers.castOption(trace.textposition, pt2.pts);
+                  var sliceTextGroup = sliceTop.selectAll("g.slicetext").data(pt2.text && textPosition !== "none" ? [0] : []);
+                  sliceTextGroup.enter().append("g").classed("slicetext", true);
+                  sliceTextGroup.exit().remove();
+                  sliceTextGroup.each(function() {
+                    var sliceText = Lib.ensureSingle(d3.select(this), "text", "", function(s2) {
+                      s2.attr("data-notex", 1);
+                    });
+                    var font = Lib.ensureUniformFontSize(gd2, determineInsideTextFont(trace, pt2, fullLayout.font));
+                    sliceText.text(pt2.text).attr({
+                      class: "slicetext",
+                      transform: "",
+                      "text-anchor": "middle"
+                    }).call(Drawing.font, font).call(svgTextUtils.convertToTspans, gd2);
+                    var textBB = Drawing.bBox(sliceText.node());
+                    var transform;
+                    var x0, x1;
+                    var y0 = Math.min(pt2.BL[1], pt2.BR[1]) + cy;
+                    var y1 = Math.max(pt2.TL[1], pt2.TR[1]) + cy;
+                    x0 = Math.max(pt2.TL[0], pt2.BL[0]) + cx;
+                    x1 = Math.min(pt2.TR[0], pt2.BR[0]) + cx;
+                    transform = toMoveInsideBar(x0, x1, y0, y1, textBB, {
+                      isHorizontal: true,
+                      constrained: true,
+                      angle: 0,
+                      anchor: "middle"
+                    });
+                    transform.fontSize = font.size;
+                    recordMinTextSize(trace.type, transform, fullLayout);
+                    cd2[i2].transform = transform;
+                    Lib.setTransormAndDisplay(sliceText, transform);
+                  });
+                });
+                var titleTextGroup = d3.select(this).selectAll("g.titletext").data(trace.title.text ? [0] : []);
+                titleTextGroup.enter().append("g").classed("titletext", true);
+                titleTextGroup.exit().remove();
+                titleTextGroup.each(function() {
+                  var titleText = Lib.ensureSingle(d3.select(this), "text", "", function(s2) {
+                    s2.attr("data-notex", 1);
+                  });
+                  var txt = trace.title.text;
+                  if (trace._meta) {
+                    txt = Lib.templateString(txt, trace._meta);
+                  }
+                  titleText.text(txt).attr({
+                    class: "titletext",
+                    transform: "",
+                    "text-anchor": "middle"
+                  }).call(Drawing.font, trace.title.font).call(svgTextUtils.convertToTspans, gd2);
+                  var transform = positionTitleOutside(cd0, fullLayout._size);
+                  titleText.attr(
+                    "transform",
+                    strTranslate(transform.x, transform.y) + strScale(Math.min(1, transform.scale)) + strTranslate(transform.tx, transform.ty)
+                  );
+                });
+              });
+            });
+          };
+          function line(a2, b2) {
+            var dx = b2[0] - a2[0];
+            var dy = b2[1] - a2[1];
+            return "l" + dx + "," + dy;
+          }
+          function getBetween(a2, b2) {
+            return [
+              0.5 * (a2[0] + b2[0]),
+              0.5 * (a2[1] + b2[1])
+            ];
+          }
+          function setCoords(cd2) {
+            if (!cd2.length) return;
+            var cd0 = cd2[0];
+            var trace = cd0.trace;
+            var aspectratio = trace.aspectratio;
+            var h2 = trace.baseratio;
+            if (h2 > 0.999) h2 = 0.999;
+            var h22 = Math.pow(h2, 2);
+            var v1 = cd0.vTotal;
+            var v0 = v1 * h22 / (1 - h22);
+            var totalValues = v1;
+            var sumSteps = v0 / v1;
+            function calcPos() {
+              var q2 = Math.sqrt(sumSteps);
+              return {
+                x: q2,
+                y: -q2
+              };
+            }
+            function getPoint() {
+              var pos = calcPos();
+              return [pos.x, pos.y];
+            }
+            var p2;
+            var allPoints = [];
+            allPoints.push(getPoint());
+            var i2, cdi;
+            for (i2 = cd2.length - 1; i2 > -1; i2--) {
+              cdi = cd2[i2];
+              if (cdi.hidden) continue;
+              var step = cdi.v / totalValues;
+              sumSteps += step;
+              allPoints.push(getPoint());
+            }
+            var minY = Infinity;
+            var maxY = -Infinity;
+            for (i2 = 0; i2 < allPoints.length; i2++) {
+              p2 = allPoints[i2];
+              minY = Math.min(minY, p2[1]);
+              maxY = Math.max(maxY, p2[1]);
+            }
+            for (i2 = 0; i2 < allPoints.length; i2++) {
+              allPoints[i2][1] -= (maxY + minY) / 2;
+            }
+            var lastX = allPoints[allPoints.length - 1][0];
+            var r2 = cd0.r;
+            var rY = (maxY - minY) / 2;
+            var scaleX2 = r2 / lastX;
+            var scaleY2 = r2 / rY * aspectratio;
+            cd0.r = scaleY2 * rY;
+            for (i2 = 0; i2 < allPoints.length; i2++) {
+              allPoints[i2][0] *= scaleX2;
+              allPoints[i2][1] *= scaleY2;
+            }
+            p2 = allPoints[0];
+            var prevLeft = [-p2[0], p2[1]];
+            var prevRight = [p2[0], p2[1]];
+            var n2 = 0;
+            for (i2 = cd2.length - 1; i2 > -1; i2--) {
+              cdi = cd2[i2];
+              if (cdi.hidden) continue;
+              n2 += 1;
+              var x2 = allPoints[n2][0];
+              var y2 = allPoints[n2][1];
+              cdi.TL = [-x2, y2];
+              cdi.TR = [x2, y2];
+              cdi.BL = prevLeft;
+              cdi.BR = prevRight;
+              cdi.pxmid = getBetween(cdi.TR, cdi.BR);
+              prevLeft = cdi.TL;
+              prevRight = cdi.TR;
+            }
+          }
+        }
+      });
+      var require_style16 = __commonJS({
+        "src/traces/funnelarea/style.js"(exports, module2) {
+          var d3 = require_d3();
+          var styleOne = require_style_one();
+          var resizeText = require_uniform_text().resizeText;
+          module2.exports = function style(gd2) {
+            var s2 = gd2._fullLayout._funnelarealayer.selectAll(".trace");
+            resizeText(gd2, s2, "funnelarea");
+            s2.each(function(cd2) {
+              var cd0 = cd2[0];
+              var trace = cd0.trace;
+              var traceSelection = d3.select(this);
+              traceSelection.style({ opacity: trace.opacity });
+              traceSelection.selectAll("path.surface").each(function(pt2) {
+                d3.select(this).call(styleOne, pt2, trace, gd2);
+              });
+            });
+          };
+        }
+      });
+      var require_funnelarea = __commonJS({
+        "src/traces/funnelarea/index.js"(exports, module2) {
+          module2.exports = {
+            moduleType: "trace",
+            name: "funnelarea",
+            basePlotModule: require_base_plot5(),
+            categories: ["pie-like", "funnelarea", "showLegend"],
+            attributes: require_attributes39(),
+            layoutAttributes: require_layout_attributes16(),
+            supplyDefaults: require_defaults35(),
+            supplyLayoutDefaults: require_layout_defaults15(),
+            calc: require_calc20().calc,
+            crossTraceCalc: require_calc20().crossTraceCalc,
+            plot: require_plot16(),
+            style: require_style16(),
+            styleOne: require_style_one(),
+            meta: {}
+          };
+        }
+      });
+      var require_funnelarea2 = __commonJS({
+        "lib/funnelarea.js"(exports, module2) {
+          module2.exports = require_funnelarea();
+        }
+      });
+      var require_stackgl_modules = __commonJS({
+        "stackgl_modules/index.js"(exports, module2) {
+          (function() {
+            var __webpack_modules__ = {
+              /***/
+              24: (
+                /***/
+                function(module22) {
+                  var rootPosition = { left: 0, top: 0 };
+                  module22.exports = mouseEventOffset;
+                  function mouseEventOffset(ev, target, out) {
+                    target = target || ev.currentTarget || ev.srcElement;
+                    if (!Array.isArray(out)) {
+                      out = [0, 0];
+                    }
+                    var cx = ev.clientX || 0;
+                    var cy = ev.clientY || 0;
+                    var rect = getBoundingClientOffset(target);
+                    out[0] = cx - rect.left;
+                    out[1] = cy - rect.top;
+                    return out;
+                  }
+                  function getBoundingClientOffset(element) {
+                    if (element === window || element === document || element === document.body) {
+                      return rootPosition;
+                    } else {
+                      return element.getBoundingClientRect();
+                    }
+                  }
+                }
+              ),
+              /***/
+              109: (
+                /***/
+                function(module22) {
+                  module22.exports = rotateY2;
+                  function rotateY2(out, a2, b2, c2) {
+                    var bx = b2[0];
+                    var bz = b2[2];
+                    var px = a2[0] - bx;
+                    var pz = a2[2] - bz;
+                    var sc2 = Math.sin(c2);
+                    var cc2 = Math.cos(c2);
+                    out[0] = bx + pz * sc2 + px * cc2;
+                    out[1] = a2[1];
+                    out[2] = bz + pz * cc2 - px * sc2;
+                    return out;
+                  }
+                }
+              ),
+              /***/
+              160: (
+                /***/
+                function(module22) {
+                  module22.exports = max;
+                  function max(out, a2, b2) {
+                    out[0] = Math.max(a2[0], b2[0]);
+                    out[1] = Math.max(a2[1], b2[1]);
+                    out[2] = Math.max(a2[2], b2[2]);
+                    out[3] = Math.max(a2[3], b2[3]);
+                    return out;
+                  }
+                }
+              ),
+              /***/
+              216: (
+                /***/
+                function(module22) {
+                  module22.exports = makeReflectTypes;
+                  function makeReflectTypes(uniforms, useIndex) {
+                    var obj = {};
+                    for (var i2 = 0; i2 < uniforms.length; ++i2) {
+                      var n2 = uniforms[i2].name;
+                      var parts = n2.split(".");
+                      var o2 = obj;
+                      for (var j2 = 0; j2 < parts.length; ++j2) {
+                        var x2 = parts[j2].split("[");
+                        if (x2.length > 1) {
+                          if (!(x2[0] in o2)) {
+                            o2[x2[0]] = [];
+                          }
+                          o2 = o2[x2[0]];
+                          for (var k2 = 1; k2 < x2.length; ++k2) {
+                            var y2 = parseInt(x2[k2]);
+                            if (k2 < x2.length - 1 || j2 < parts.length - 1) {
+                              if (!(y2 in o2)) {
+                                if (k2 < x2.length - 1) {
+                                  o2[y2] = [];
+                                } else {
+                                  o2[y2] = {};
+                                }
+                              }
+                              o2 = o2[y2];
+                            } else {
+                              if (useIndex) {
+                                o2[y2] = i2;
+                              } else {
+                                o2[y2] = uniforms[i2].type;
+                              }
+                            }
+                          }
+                        } else if (j2 < parts.length - 1) {
+                          if (!(x2[0] in o2)) {
+                            o2[x2[0]] = {};
+                          }
+                          o2 = o2[x2[0]];
+                        } else {
+                          if (useIndex) {
+                            o2[x2[0]] = i2;
+                          } else {
+                            o2[x2[0]] = uniforms[i2].type;
+                          }
+                        }
+                      }
+                    }
+                    return obj;
+                  }
+                }
+              ),
+              /***/
+              236: (
+                /***/
+                function(module22, __unused_webpack_exports, __webpack_require__2) {
+                  var hiddenStore = __webpack_require__2(8284);
+                  module22.exports = createStore;
+                  function createStore() {
+                    var key = {};
+                    return function(obj) {
+                      if ((typeof obj !== "object" || obj === null) && typeof obj !== "function") {
+                        throw new Error("Weakmap-shim: Key must be object");
+                      }
+                      var store = obj.valueOf(key);
+                      return store && store.identity === key ? store : hiddenStore(obj, key);
+                    };
+                  }
+                }
+              ),
+              /***/
+              244: (
+                /***/
+                function(module22) {
+                  module22.exports = dot2;
+                  function dot2(a2, b2) {
+                    return a2[0] * b2[0] + a2[1] * b2[1] + a2[2] * b2[2];
+                  }
+                }
+              ),
+              /***/
+              264: (
+                /***/
+                function(module22) {
+                  module22.exports = transformQuat2;
+                  function transformQuat2(out, a2, q2) {
+                    var x2 = a2[0], y2 = a2[1], z2 = a2[2], qx = q2[0], qy = q2[1], qz = q2[2], qw = q2[3], ix = qw * x2 + qy * z2 - qz * y2, iy = qw * y2 + qz * x2 - qx * z2, iz = qw * z2 + qx * y2 - qy * x2, iw = -qx * x2 - qy * y2 - qz * z2;
+                    out[0] = ix * qw + iw * -qx + iy * -qz - iz * -qy;
+                    out[1] = iy * qw + iw * -qy + iz * -qx - ix * -qz;
+                    out[2] = iz * qw + iw * -qz + ix * -qy - iy * -qx;
+                    return out;
+                  }
+                }
+              ),
+              /***/
+              332: (
+                /***/
+                function(module22, __unused_webpack_exports, __webpack_require__2) {
+                  module22.exports = cleanPSLG;
+                  var UnionFind = __webpack_require__2(1755);
+                  var boxIntersect = __webpack_require__2(6867);
+                  var segseg = __webpack_require__2(1125);
+                  var rat = __webpack_require__2(7842);
+                  var ratCmp = __webpack_require__2(1318);
+                  var ratToFloat = __webpack_require__2(946);
+                  var ratVec = __webpack_require__2(5838);
+                  var nextafter = __webpack_require__2(1278);
+                  var solveIntersection = __webpack_require__2(3637);
+                  function boundRat(r2) {
+                    var f2 = ratToFloat(r2);
+                    return [
+                      nextafter(f2, -Infinity),
+                      nextafter(f2, Infinity)
+                    ];
+                  }
+                  function boundEdges(points, edges) {
+                    var bounds = new Array(edges.length);
+                    for (var i2 = 0; i2 < edges.length; ++i2) {
+                      var e2 = edges[i2];
+                      var a2 = points[e2[0]];
+                      var b2 = points[e2[1]];
+                      bounds[i2] = [
+                        nextafter(Math.min(a2[0], b2[0]), -Infinity),
+                        nextafter(Math.min(a2[1], b2[1]), -Infinity),
+                        nextafter(Math.max(a2[0], b2[0]), Infinity),
+                        nextafter(Math.max(a2[1], b2[1]), Infinity)
+                      ];
+                    }
+                    return bounds;
+                  }
+                  function boundPoints(points) {
+                    var bounds = new Array(points.length);
+                    for (var i2 = 0; i2 < points.length; ++i2) {
+                      var p2 = points[i2];
+                      bounds[i2] = [
+                        nextafter(p2[0], -Infinity),
+                        nextafter(p2[1], -Infinity),
+                        nextafter(p2[0], Infinity),
+                        nextafter(p2[1], Infinity)
+                      ];
+                    }
+                    return bounds;
+                  }
+                  function getCrossings(points, edges, edgeBounds) {
+                    var result = [];
+                    boxIntersect(edgeBounds, function(i2, j2) {
+                      var e2 = edges[i2];
+                      var f2 = edges[j2];
+                      if (e2[0] === f2[0] || e2[0] === f2[1] || e2[1] === f2[0] || e2[1] === f2[1]) {
+                        return;
+                      }
+                      var a2 = points[e2[0]];
+                      var b2 = points[e2[1]];
+                      var c2 = points[f2[0]];
+                      var d2 = points[f2[1]];
+                      if (segseg(a2, b2, c2, d2)) {
+                        result.push([i2, j2]);
+                      }
+                    });
+                    return result;
+                  }
+                  function getTJunctions(points, edges, edgeBounds, vertBounds) {
+                    var result = [];
+                    boxIntersect(edgeBounds, vertBounds, function(i2, v2) {
+                      var e2 = edges[i2];
+                      if (e2[0] === v2 || e2[1] === v2) {
+                        return;
+                      }
+                      var p2 = points[v2];
+                      var a2 = points[e2[0]];
+                      var b2 = points[e2[1]];
+                      if (segseg(a2, b2, p2, p2)) {
+                        result.push([i2, v2]);
+                      }
+                    });
+                    return result;
+                  }
+                  function cutEdges(floatPoints, edges, crossings, junctions, useColor) {
+                    var i2, e2;
+                    var ratPoints = floatPoints.map(function(p2) {
+                      return [
+                        rat(p2[0]),
+                        rat(p2[1])
+                      ];
+                    });
+                    for (i2 = 0; i2 < crossings.length; ++i2) {
+                      var crossing = crossings[i2];
+                      e2 = crossing[0];
+                      var f2 = crossing[1];
+                      var ee2 = edges[e2];
+                      var ef2 = edges[f2];
+                      var x2 = solveIntersection(
+                        ratVec(floatPoints[ee2[0]]),
+                        ratVec(floatPoints[ee2[1]]),
+                        ratVec(floatPoints[ef2[0]]),
+                        ratVec(floatPoints[ef2[1]])
+                      );
+                      if (!x2) {
+                        continue;
+                      }
+                      var idx = floatPoints.length;
+                      floatPoints.push([ratToFloat(x2[0]), ratToFloat(x2[1])]);
+                      ratPoints.push(x2);
+                      junctions.push([e2, idx], [f2, idx]);
+                    }
+                    junctions.sort(function(a22, b22) {
+                      if (a22[0] !== b22[0]) {
+                        return a22[0] - b22[0];
+                      }
+                      var u2 = ratPoints[a22[1]];
+                      var v2 = ratPoints[b22[1]];
+                      return ratCmp(u2[0], v2[0]) || ratCmp(u2[1], v2[1]);
+                    });
+                    for (i2 = junctions.length - 1; i2 >= 0; --i2) {
+                      var junction = junctions[i2];
+                      e2 = junction[0];
+                      var edge = edges[e2];
+                      var s2 = edge[0];
+                      var t4 = edge[1];
+                      var a2 = floatPoints[s2];
+                      var b2 = floatPoints[t4];
+                      if ((a2[0] - b2[0] || a2[1] - b2[1]) < 0) {
+                        var tmp2 = s2;
+                        s2 = t4;
+                        t4 = tmp2;
+                      }
+                      edge[0] = s2;
+                      var last = edge[1] = junction[1];
+                      var color22;
+                      if (useColor) {
+                        color22 = edge[2];
+                      }
+                      while (i2 > 0 && junctions[i2 - 1][0] === e2) {
+                        var junction = junctions[--i2];
+                        var next = junction[1];
+                        if (useColor) {
+                          edges.push([last, next, color22]);
+                        } else {
+                          edges.push([last, next]);
+                        }
+                        last = next;
+                      }
+                      if (useColor) {
+                        edges.push([last, t4, color22]);
+                      } else {
+                        edges.push([last, t4]);
+                      }
+                    }
+                    return ratPoints;
+                  }
+                  function dedupPoints(floatPoints, ratPoints, floatBounds) {
+                    var numPoints = ratPoints.length;
+                    var uf2 = new UnionFind(numPoints);
+                    var bounds = [];
+                    for (var i2 = 0; i2 < ratPoints.length; ++i2) {
+                      var p2 = ratPoints[i2];
+                      var xb2 = boundRat(p2[0]);
+                      var yb2 = boundRat(p2[1]);
+                      bounds.push([
+                        nextafter(xb2[0], -Infinity),
+                        nextafter(yb2[0], -Infinity),
+                        nextafter(xb2[1], Infinity),
+                        nextafter(yb2[1], Infinity)
+                      ]);
+                    }
+                    boxIntersect(bounds, function(i22, j22) {
+                      uf2.link(i22, j22);
+                    });
+                    var noDupes = true;
+                    var labels = new Array(numPoints);
+                    for (var i2 = 0; i2 < numPoints; ++i2) {
+                      var j2 = uf2.find(i2);
+                      if (j2 !== i2) {
+                        noDupes = false;
+                        floatPoints[j2] = [
+                          Math.min(floatPoints[i2][0], floatPoints[j2][0]),
+                          Math.min(floatPoints[i2][1], floatPoints[j2][1])
+                        ];
+                      }
+                    }
+                    if (noDupes) {
+                      return null;
+                    }
+                    var ptr = 0;
+                    for (var i2 = 0; i2 < numPoints; ++i2) {
+                      var j2 = uf2.find(i2);
+                      if (j2 === i2) {
+                        labels[i2] = ptr;
+                        floatPoints[ptr++] = floatPoints[i2];
+                      } else {
+                        labels[i2] = -1;
+                      }
+                    }
+                    floatPoints.length = ptr;
+                    for (var i2 = 0; i2 < numPoints; ++i2) {
+                      if (labels[i2] < 0) {
+                        labels[i2] = labels[uf2.find(i2)];
+                      }
+                    }
+                    return labels;
+                  }
+                  function compareLex2(a2, b2) {
+                    return a2[0] - b2[0] || a2[1] - b2[1];
+                  }
+                  function compareLex3(a2, b2) {
+                    var d2 = a2[0] - b2[0] || a2[1] - b2[1];
+                    if (d2) {
+                      return d2;
+                    }
+                    if (a2[2] < b2[2]) {
+                      return -1;
+                    } else if (a2[2] > b2[2]) {
+                      return 1;
+                    }
+                    return 0;
+                  }
+                  function dedupEdges(edges, labels, useColor) {
+                    if (edges.length === 0) {
+                      return;
+                    }
+                    if (labels) {
+                      for (var i2 = 0; i2 < edges.length; ++i2) {
+                        var e2 = edges[i2];
+                        var a2 = labels[e2[0]];
+                        var b2 = labels[e2[1]];
+                        e2[0] = Math.min(a2, b2);
+                        e2[1] = Math.max(a2, b2);
+                      }
+                    } else {
+                      for (var i2 = 0; i2 < edges.length; ++i2) {
+                        var e2 = edges[i2];
+                        var a2 = e2[0];
+                        var b2 = e2[1];
+                        e2[0] = Math.min(a2, b2);
+                        e2[1] = Math.max(a2, b2);
+                      }
+                    }
+                    if (useColor) {
+                      edges.sort(compareLex3);
+                    } else {
+                      edges.sort(compareLex2);
+                    }
+                    var ptr = 1;
+                    for (var i2 = 1; i2 < edges.length; ++i2) {
+                      var prev = edges[i2 - 1];
+                      var next = edges[i2];
+                      if (next[0] === prev[0] && next[1] === prev[1] && (!useColor || next[2] === prev[2])) {
+                        continue;
+                      }
+                      edges[ptr++] = next;
+                    }
+                    edges.length = ptr;
+                  }
+                  function preRound(points, edges, useColor) {
+                    var labels = dedupPoints(points, [], boundPoints(points));
+                    dedupEdges(edges, labels, useColor);
+                    return !!labels;
+                  }
+                  function snapRound(points, edges, useColor) {
+                    var edgeBounds = boundEdges(points, edges);
+                    var crossings = getCrossings(points, edges, edgeBounds);
+                    var vertBounds = boundPoints(points);
+                    var tjunctions = getTJunctions(points, edges, edgeBounds, vertBounds);
+                    var ratPoints = cutEdges(points, edges, crossings, tjunctions, useColor);
+                    var labels = dedupPoints(points, ratPoints);
+                    dedupEdges(edges, labels, useColor);
+                    if (!labels) {
+                      return crossings.length > 0 || tjunctions.length > 0;
+                    }
+                    return true;
+                  }
+                  function cleanPSLG(points, edges, colors) {
+                    var prevEdges;
+                    if (colors) {
+                      prevEdges = edges;
+                      var augEdges = new Array(edges.length);
+                      for (var i2 = 0; i2 < edges.length; ++i2) {
+                        var e2 = edges[i2];
+                        augEdges[i2] = [e2[0], e2[1], colors[i2]];
+                      }
+                      edges = augEdges;
+                    }
+                    var modified = preRound(points, edges, !!colors);
+                    while (snapRound(points, edges, !!colors)) {
+                      modified = true;
+                    }
+                    if (!!colors && modified) {
+                      prevEdges.length = 0;
+                      colors.length = 0;
+                      for (var i2 = 0; i2 < edges.length; ++i2) {
+                        var e2 = edges[i2];
+                        prevEdges.push([e2[0], e2[1]]);
+                        colors.push(e2[2]);
+                      }
+                    }
+                    return modified;
+                  }
+                }
+              ),
+              /***/
+              351: (
+                /***/
+                function(module22, __unused_webpack_exports, __webpack_require__2) {
+                  module22.exports = mouseListen;
+                  var mouse = __webpack_require__2(4687);
+                  function mouseListen(element, callback) {
+                    if (!callback) {
+                      callback = element;
+                      element = window;
+                    }
+                    var buttonState = 0;
+                    var x2 = 0;
+                    var y2 = 0;
+                    var mods = {
+                      shift: false,
+                      alt: false,
+                      control: false,
+                      meta: false
+                    };
+                    var attached = false;
+                    function updateMods(ev) {
+                      var changed = false;
+                      if ("altKey" in ev) {
+                        changed = changed || ev.altKey !== mods.alt;
+                        mods.alt = !!ev.altKey;
+                      }
+                      if ("shiftKey" in ev) {
+                        changed = changed || ev.shiftKey !== mods.shift;
+                        mods.shift = !!ev.shiftKey;
+                      }
+                      if ("ctrlKey" in ev) {
+                        changed = changed || ev.ctrlKey !== mods.control;
+                        mods.control = !!ev.ctrlKey;
+                      }
+                      if ("metaKey" in ev) {
+                        changed = changed || ev.metaKey !== mods.meta;
+                        mods.meta = !!ev.metaKey;
+                      }
+                      return changed;
+                    }
+                    function handleEvent(nextButtons, ev) {
+                      var nextX = mouse.x(ev);
+                      var nextY = mouse.y(ev);
+                      if ("buttons" in ev) {
+                        nextButtons = ev.buttons | 0;
+                      }
+                      if (nextButtons !== buttonState || nextX !== x2 || nextY !== y2 || updateMods(ev)) {
+                        buttonState = nextButtons | 0;
+                        x2 = nextX || 0;
+                        y2 = nextY || 0;
+                        callback && callback(buttonState, x2, y2, mods);
+                      }
+                    }
+                    function clearState(ev) {
+                      handleEvent(0, ev);
+                    }
+                    function handleBlur() {
+                      if (buttonState || x2 || y2 || mods.shift || mods.alt || mods.meta || mods.control) {
+                        x2 = y2 = 0;
+                        buttonState = 0;
+                        mods.shift = mods.alt = mods.control = mods.meta = false;
+                        callback && callback(0, 0, 0, mods);
+                      }
+                    }
+                    function handleMods(ev) {
+                      if (updateMods(ev)) {
+                        callback && callback(buttonState, x2, y2, mods);
+                      }
+                    }
+                    function handleMouseMove(ev) {
+                      if (mouse.buttons(ev) === 0) {
+                        handleEvent(0, ev);
+                      } else {
+                        handleEvent(buttonState, ev);
+                      }
+                    }
+                    function handleMouseDown(ev) {
+                      handleEvent(buttonState | mouse.buttons(ev), ev);
+                    }
+                    function handleMouseUp(ev) {
+                      handleEvent(buttonState & ~mouse.buttons(ev), ev);
+                    }
+                    function attachListeners() {
+                      if (attached) {
+                        return;
+                      }
+                      attached = true;
+                      element.addEventListener("mousemove", handleMouseMove);
+                      element.addEventListener("mousedown", handleMouseDown);
+                      element.addEventListener("mouseup", handleMouseUp);
+                      element.addEventListener("mouseleave", clearState);
+                      element.addEventListener("mouseenter", clearState);
+                      element.addEventListener("mouseout", clearState);
+                      element.addEventListener("mouseover", clearState);
+                      element.addEventListener("blur", handleBlur);
+                      element.addEventListener("keyup", handleMods);
+                      element.addEventListener("keydown", handleMods);
+                      element.addEventListener("keypress", handleMods);
+                      if (element !== window) {
+                        window.addEventListener("blur", handleBlur);
+                        window.addEventListener("keyup", handleMods);
+                        window.addEventListener("keydown", handleMods);
+                        window.addEventListener("keypress", handleMods);
+                      }
+                    }
+                    function detachListeners() {
+                      if (!attached) {
+                        return;
+                      }
+                      attached = false;
+                      element.removeEventListener("mousemove", handleMouseMove);
+                      element.removeEventListener("mousedown", handleMouseDown);
+                      element.removeEventListener("mouseup", handleMouseUp);
+                      element.removeEventListener("mouseleave", clearState);
+                      element.removeEventListener("mouseenter", clearState);
+                      element.removeEventListener("mouseout", clearState);
+                      element.removeEventListener("mouseover", clearState);
+                      element.removeEventListener("blur", handleBlur);
+                      element.removeEventListener("keyup", handleMods);
+                      element.removeEventListener("keydown", handleMods);
+                      element.removeEventListener("keypress", handleMods);
+                      if (element !== window) {
+                        window.removeEventListener("blur", handleBlur);
+                        window.removeEventListener("keyup", handleMods);
+                        window.removeEventListener("keydown", handleMods);
+                        window.removeEventListener("keypress", handleMods);
+                      }
+                    }
+                    attachListeners();
+                    var result = {
+                      element
+                    };
+                    Object.defineProperties(result, {
+                      enabled: {
+                        get: function() {
+                          return attached;
+                        },
+                        set: function(f2) {
+                          if (f2) {
+                            attachListeners();
+                          } else {
+                            detachListeners();
+                          }
+                        },
+                        enumerable: true
+                      },
+                      buttons: {
+                        get: function() {
+                          return buttonState;
+                        },
+                        enumerable: true
+                      },
+                      x: {
+                        get: function() {
+                          return x2;
+                        },
+                        enumerable: true
+                      },
+                      y: {
+                        get: function() {
+                          return y2;
+                        },
+                        enumerable: true
+                      },
+                      mods: {
+                        get: function() {
+                          return mods;
+                        },
+                        enumerable: true
+                      }
+                    });
+                    return result;
+                  }
+                }
+              ),
+              /***/
+              395: (
+                /***/
+                function(module22) {
+                  function lerp2(v0, v1, t4) {
+                    return v0 * (1 - t4) + v1 * t4;
+                  }
+                  module22.exports = lerp2;
+                }
+              ),
+              /***/
+              446: (
+                /***/
+                function(module22, __unused_webpack_exports, __webpack_require__2) {
+                  var compile = __webpack_require__2(7640);
+                  var CACHE = {};
+                  function sort(array) {
+                    var order = array.order;
+                    var dtype = array.dtype;
+                    var typeSig = [order, dtype];
+                    var typeName = typeSig.join(":");
+                    var compiled = CACHE[typeName];
+                    if (!compiled) {
+                      CACHE[typeName] = compiled = compile(order, dtype);
+                    }
+                    compiled(array);
+                    return array;
+                  }
+                  module22.exports = sort;
+                }
+              ),
+              /***/
+              483: (
+                /***/
+                function(module22) {
+                  module22.exports = squaredLength2;
+                  function squaredLength2(a2) {
+                    var x2 = a2[0], y2 = a2[1], z2 = a2[2], w2 = a2[3];
+                    return x2 * x2 + y2 * y2 + z2 * z2 + w2 * w2;
+                  }
+                }
+              ),
+              /***/
+              492: (
+                /***/
+                function(module22) {
+                  module22.exports = transformMat32;
+                  function transformMat32(out, a2, m2) {
+                    var x2 = a2[0], y2 = a2[1], z2 = a2[2];
+                    out[0] = x2 * m2[0] + y2 * m2[3] + z2 * m2[6];
+                    out[1] = x2 * m2[1] + y2 * m2[4] + z2 * m2[7];
+                    out[2] = x2 * m2[2] + y2 * m2[5] + z2 * m2[8];
+                    return out;
+                  }
+                }
+              ),
+              /***/
+              501: (
+                /***/
+                function(module22, __unused_webpack_exports, __webpack_require__2) {
+                  module22.exports = createLines;
+                  var createBuffer = __webpack_require__2(2762);
+                  var createVAO = __webpack_require__2(8116);
+                  var createShader = __webpack_require__2(1879).n;
+                  var MAJOR_AXIS = [0, 0, 0];
+                  var MINOR_AXIS = [0, 0, 0];
+                  var SCREEN_AXIS = [0, 0, 0];
+                  var OFFSET_VEC = [0, 0, 0];
+                  var SHAPE = [1, 1];
+                  function zeroVec(a2) {
+                    a2[0] = a2[1] = a2[2] = 0;
+                    return a2;
+                  }
+                  function copyVec(a2, b2) {
+                    a2[0] = b2[0];
+                    a2[1] = b2[1];
+                    a2[2] = b2[2];
+                    return a2;
+                  }
+                  function Lines(gl2, vertBuffer, vao, shader, tickCount, tickOffset, gridCount, gridOffset) {
+                    this.gl = gl2;
+                    this.vertBuffer = vertBuffer;
+                    this.vao = vao;
+                    this.shader = shader;
+                    this.tickCount = tickCount;
+                    this.tickOffset = tickOffset;
+                    this.gridCount = gridCount;
+                    this.gridOffset = gridOffset;
+                  }
+                  var proto = Lines.prototype;
+                  proto.bind = function(model, view, projection) {
+                    this.shader.bind();
+                    this.shader.uniforms.model = model;
+                    this.shader.uniforms.view = view;
+                    this.shader.uniforms.projection = projection;
+                    SHAPE[0] = this.gl.drawingBufferWidth;
+                    SHAPE[1] = this.gl.drawingBufferHeight;
+                    this.shader.uniforms.screenShape = SHAPE;
+                    this.vao.bind();
+                  };
+                  proto.unbind = function() {
+                    this.vao.unbind();
+                  };
+                  proto.drawAxisLine = function(j2, bounds, offset, color22, lineWidth) {
+                    var minorAxis = zeroVec(MINOR_AXIS);
+                    this.shader.uniforms.majorAxis = MINOR_AXIS;
+                    minorAxis[j2] = bounds[1][j2] - bounds[0][j2];
+                    this.shader.uniforms.minorAxis = minorAxis;
+                    var noffset = copyVec(OFFSET_VEC, offset);
+                    noffset[j2] += bounds[0][j2];
+                    this.shader.uniforms.offset = noffset;
+                    this.shader.uniforms.lineWidth = lineWidth;
+                    this.shader.uniforms.color = color22;
+                    var screenAxis = zeroVec(SCREEN_AXIS);
+                    screenAxis[(j2 + 2) % 3] = 1;
+                    this.shader.uniforms.screenAxis = screenAxis;
+                    this.vao.draw(this.gl.TRIANGLES, 6);
+                    var screenAxis = zeroVec(SCREEN_AXIS);
+                    screenAxis[(j2 + 1) % 3] = 1;
+                    this.shader.uniforms.screenAxis = screenAxis;
+                    this.vao.draw(this.gl.TRIANGLES, 6);
+                  };
+                  proto.drawAxisTicks = function(j2, offset, minorAxis, color22, lineWidth) {
+                    if (!this.tickCount[j2]) {
+                      return;
+                    }
+                    var majorAxis = zeroVec(MAJOR_AXIS);
+                    majorAxis[j2] = 1;
+                    this.shader.uniforms.majorAxis = majorAxis;
+                    this.shader.uniforms.offset = offset;
+                    this.shader.uniforms.minorAxis = minorAxis;
+                    this.shader.uniforms.color = color22;
+                    this.shader.uniforms.lineWidth = lineWidth;
+                    var screenAxis = zeroVec(SCREEN_AXIS);
+                    screenAxis[j2] = 1;
+                    this.shader.uniforms.screenAxis = screenAxis;
+                    this.vao.draw(this.gl.TRIANGLES, this.tickCount[j2], this.tickOffset[j2]);
+                  };
+                  proto.drawGrid = function(i2, j2, bounds, offset, color22, lineWidth) {
+                    if (!this.gridCount[i2]) {
+                      return;
+                    }
+                    var minorAxis = zeroVec(MINOR_AXIS);
+                    minorAxis[j2] = bounds[1][j2] - bounds[0][j2];
+                    this.shader.uniforms.minorAxis = minorAxis;
+                    var noffset = copyVec(OFFSET_VEC, offset);
+                    noffset[j2] += bounds[0][j2];
+                    this.shader.uniforms.offset = noffset;
+                    var majorAxis = zeroVec(MAJOR_AXIS);
+                    majorAxis[i2] = 1;
+                    this.shader.uniforms.majorAxis = majorAxis;
+                    var screenAxis = zeroVec(SCREEN_AXIS);
+                    screenAxis[i2] = 1;
+                    this.shader.uniforms.screenAxis = screenAxis;
+                    this.shader.uniforms.lineWidth = lineWidth;
+                    this.shader.uniforms.color = color22;
+                    this.vao.draw(this.gl.TRIANGLES, this.gridCount[i2], this.gridOffset[i2]);
+                  };
+                  proto.drawZero = function(j2, i2, bounds, offset, color22, lineWidth) {
+                    var minorAxis = zeroVec(MINOR_AXIS);
+                    this.shader.uniforms.majorAxis = minorAxis;
+                    minorAxis[j2] = bounds[1][j2] - bounds[0][j2];
+                    this.shader.uniforms.minorAxis = minorAxis;
+                    var noffset = copyVec(OFFSET_VEC, offset);
+                    noffset[j2] += bounds[0][j2];
+                    this.shader.uniforms.offset = noffset;
+                    var screenAxis = zeroVec(SCREEN_AXIS);
+                    screenAxis[i2] = 1;
+                    this.shader.uniforms.screenAxis = screenAxis;
+                    this.shader.uniforms.lineWidth = lineWidth;
+                    this.shader.uniforms.color = color22;
+                    this.vao.draw(this.gl.TRIANGLES, 6);
+                  };
+                  proto.dispose = function() {
+                    this.vao.dispose();
+                    this.vertBuffer.dispose();
+                    this.shader.dispose();
+                  };
+                  function createLines(gl2, bounds, ticks) {
+                    var vertices = [];
+                    var tickOffset = [0, 0, 0];
+                    var tickCount = [0, 0, 0];
+                    var gridOffset = [0, 0, 0];
+                    var gridCount = [0, 0, 0];
+                    vertices.push(
+                      0,
+                      0,
+                      1,
+                      0,
+                      1,
+                      1,
+                      0,
+                      0,
+                      -1,
+                      0,
+                      0,
+                      -1,
+                      0,
+                      1,
+                      1,
+                      0,
+                      1,
+                      -1
+                    );
+                    for (var i2 = 0; i2 < 3; ++i2) {
+                      var start = vertices.length / 3 | 0;
+                      for (var j2 = 0; j2 < ticks[i2].length; ++j2) {
+                        var x2 = +ticks[i2][j2].x;
+                        vertices.push(
+                          x2,
+                          0,
+                          1,
+                          x2,
+                          1,
+                          1,
+                          x2,
+                          0,
+                          -1,
+                          x2,
+                          0,
+                          -1,
+                          x2,
+                          1,
+                          1,
+                          x2,
+                          1,
+                          -1
+                        );
+                      }
+                      var end = vertices.length / 3 | 0;
+                      tickOffset[i2] = start;
+                      tickCount[i2] = end - start;
+                      var start = vertices.length / 3 | 0;
+                      for (var k2 = 0; k2 < ticks[i2].length; ++k2) {
+                        var x2 = +ticks[i2][k2].x;
+                        vertices.push(
+                          x2,
+                          0,
+                          1,
+                          x2,
+                          1,
+                          1,
+                          x2,
+                          0,
+                          -1,
+                          x2,
+                          0,
+                          -1,
+                          x2,
+                          1,
+                          1,
+                          x2,
+                          1,
+                          -1
+                        );
+                      }
+                      var end = vertices.length / 3 | 0;
+                      gridOffset[i2] = start;
+                      gridCount[i2] = end - start;
+                    }
+                    var vertBuf = createBuffer(gl2, new Float32Array(vertices));
+                    var vao = createVAO(gl2, [
+                      {
+                        "buffer": vertBuf,
+                        "type": gl2.FLOAT,
+                        "size": 3,
+                        "stride": 0,
+                        "offset": 0
+                      }
+                    ]);
+                    var shader = createShader(gl2);
+                    shader.attributes.position.location = 0;
+                    return new Lines(gl2, vertBuf, vao, shader, tickCount, tickOffset, gridCount, gridOffset);
+                  }
+                }
+              ),
+              /***/
+              544: (
+                /***/
+                function(module22, __unused_webpack_exports, __webpack_require__2) {
+                  var bnsub = __webpack_require__2(5572);
+                  module22.exports = sub2;
+                  function sub2(a2, b2) {
+                    var n2 = a2.length;
+                    var r2 = new Array(n2);
+                    for (var i2 = 0; i2 < n2; ++i2) {
+                      r2[i2] = bnsub(a2[i2], b2[i2]);
+                    }
+                    return r2;
+                  }
+                }
+              ),
+              /***/
+              606: (
+                /***/
+                function(module22, __unused_webpack_exports, __webpack_require__2) {
+                  var createStore = __webpack_require__2(236);
+                  module22.exports = weakMap;
+                  function weakMap() {
+                    var privates = createStore();
+                    return {
+                      "get": function(key, fallback) {
+                        var store = privates(key);
+                        return store.hasOwnProperty("value") ? store.value : fallback;
+                      },
+                      "set": function(key, value) {
+                        privates(key).value = value;
+                        return this;
+                      },
+                      "has": function(key) {
+                        return "value" in privates(key);
+                      },
+                      "delete": function(key) {
+                        return delete privates(key).value;
+                      }
+                    };
+                  }
+                }
+              ),
+              /***/
+              614: (
+                /***/
+                function(__unused_webpack_module, exports2, __webpack_require__2) {
+                  var glslify = __webpack_require__2(3236);
+                  var triVertSrc = glslify(["precision highp float;\n\nprecision highp float;\n#define GLSLIFY 1\n\nvec3 getOrthogonalVector(vec3 v) {\n  // Return up-vector for only-z vector.\n  // Return ax + by + cz = 0, a point that lies on the plane that has v as a normal and that isn't (0,0,0).\n  // From the above if-statement we have ||a|| > 0  U  ||b|| > 0.\n  // Assign z = 0, x = -b, y = a:\n  // a*-b + b*a + c*0 = -ba + ba + 0 = 0\n  if (v.x*v.x > v.z*v.z || v.y*v.y > v.z*v.z) {\n    return normalize(vec3(-v.y, v.x, 0.0));\n  } else {\n    return normalize(vec3(0.0, v.z, -v.y));\n  }\n}\n\n// Calculate the cone vertex and normal at the given index.\n//\n// The returned vertex is for a cone with its top at origin and height of 1.0,\n// pointing in the direction of the vector attribute.\n//\n// Each cone is made up of a top vertex, a center base vertex and base perimeter vertices.\n// These vertices are used to make up the triangles of the cone by the following:\n//   segment + 0 top vertex\n//   segment + 1 perimeter vertex a+1\n//   segment + 2 perimeter vertex a\n//   segment + 3 center base vertex\n//   segment + 4 perimeter vertex a\n//   segment + 5 perimeter vertex a+1\n// Where segment is the number of the radial segment * 6 and a is the angle at that radial segment.\n// To go from index to segment, floor(index / 6)\n// To go from segment to angle, 2*pi * (segment/segmentCount)\n// To go from index to segment index, index - (segment*6)\n//\nvec3 getConePosition(vec3 d, float rawIndex, float coneOffset, out vec3 normal) {\n\n  const float segmentCount = 8.0;\n\n  float index = rawIndex - floor(rawIndex /\n    (segmentCount * 6.0)) *\n    (segmentCount * 6.0);\n\n  float segment = floor(0.001 + index/6.0);\n  float segmentIndex = index - (segment*6.0);\n\n  normal = -normalize(d);\n\n  if (segmentIndex > 2.99 && segmentIndex < 3.01) {\n    return mix(vec3(0.0), -d, coneOffset);\n  }\n\n  float nextAngle = (\n    (segmentIndex > 0.99 &&  segmentIndex < 1.01) ||\n    (segmentIndex > 4.99 &&  segmentIndex < 5.01)\n  ) ? 1.0 : 0.0;\n  float angle = 2.0 * 3.14159 * ((segment + nextAngle) / segmentCount);\n\n  vec3 v1 = mix(d, vec3(0.0), coneOffset);\n  vec3 v2 = v1 - d;\n\n  vec3 u = getOrthogonalVector(d);\n  vec3 v = normalize(cross(u, d));\n\n  vec3 x = u * cos(angle) * length(d)*0.25;\n  vec3 y = v * sin(angle) * length(d)*0.25;\n  vec3 v3 = v2 + x + y;\n  if (segmentIndex < 3.0) {\n    vec3 tx = u * sin(angle);\n    vec3 ty = v * -cos(angle);\n    vec3 tangent = tx + ty;\n    normal = normalize(cross(v3 - v1, tangent));\n  }\n\n  if (segmentIndex == 0.0) {\n    return mix(d, vec3(0.0), coneOffset);\n  }\n  return v3;\n}\n\nattribute vec3 vector;\nattribute vec4 color, position;\nattribute vec2 uv;\n\nuniform float vectorScale, coneScale, coneOffset;\nuniform mat4 model, view, projection, inverseModel;\nuniform vec3 eyePosition, lightPosition;\n\nvarying vec3 f_normal, f_lightDirection, f_eyeDirection, f_data, f_position;\nvarying vec4 f_color;\nvarying vec2 f_uv;\n\nvoid main() {\n  // Scale the vector magnitude to stay constant with\n  // model & view changes.\n  vec3 normal;\n  vec3 XYZ = getConePosition(mat3(model) * ((vectorScale * coneScale) * vector), position.w, coneOffset, normal);\n  vec4 conePosition = model * vec4(position.xyz, 1.0) + vec4(XYZ, 0.0);\n\n  //Lighting geometry parameters\n  vec4 cameraCoordinate = view * conePosition;\n  cameraCoordinate.xyz /= cameraCoordinate.w;\n  f_lightDirection = lightPosition - cameraCoordinate.xyz;\n  f_eyeDirection   = eyePosition - cameraCoordinate.xyz;\n  f_normal = normalize((vec4(normal, 0.0) * inverseModel).xyz);\n\n  // vec4 m_position  = model * vec4(conePosition, 1.0);\n  vec4 t_position  = view * conePosition;\n  gl_Position      = projection * t_position;\n\n  f_color          = color;\n  f_data           = conePosition.xyz;\n  f_position       = position.xyz;\n  f_uv             = uv;\n}\n"]);
+                  var triFragSrc = glslify(["#extension GL_OES_standard_derivatives : enable\n\nprecision highp float;\n#define GLSLIFY 1\n\nfloat beckmannDistribution(float x, float roughness) {\n  float NdotH = max(x, 0.0001);\n  float cos2Alpha = NdotH * NdotH;\n  float tan2Alpha = (cos2Alpha - 1.0) / cos2Alpha;\n  float roughness2 = roughness * roughness;\n  float denom = 3.141592653589793 * roughness2 * cos2Alpha * cos2Alpha;\n  return exp(tan2Alpha / roughness2) / denom;\n}\n\nfloat cookTorranceSpecular(\n  vec3 lightDirection,\n  vec3 viewDirection,\n  vec3 surfaceNormal,\n  float roughness,\n  float fresnel) {\n\n  float VdotN = max(dot(viewDirection, surfaceNormal), 0.0);\n  float LdotN = max(dot(lightDirection, surfaceNormal), 0.0);\n\n  //Half angle vector\n  vec3 H = normalize(lightDirection + viewDirection);\n\n  //Geometric term\n  float NdotH = max(dot(surfaceNormal, H), 0.0);\n  float VdotH = max(dot(viewDirection, H), 0.000001);\n  float LdotH = max(dot(lightDirection, H), 0.000001);\n  float G1 = (2.0 * NdotH * VdotN) / VdotH;\n  float G2 = (2.0 * NdotH * LdotN) / LdotH;\n  float G = min(1.0, min(G1, G2));\n  \n  //Distribution term\n  float D = beckmannDistribution(NdotH, roughness);\n\n  //Fresnel term\n  float F = pow(1.0 - VdotN, fresnel);\n\n  //Multiply terms and done\n  return  G * F * D / max(3.14159265 * VdotN, 0.000001);\n}\n\nbool outOfRange(float a, float b, float p) {\n  return ((p > max(a, b)) || \n          (p < min(a, b)));\n}\n\nbool outOfRange(vec2 a, vec2 b, vec2 p) {\n  return (outOfRange(a.x, b.x, p.x) ||\n          outOfRange(a.y, b.y, p.y));\n}\n\nbool outOfRange(vec3 a, vec3 b, vec3 p) {\n  return (outOfRange(a.x, b.x, p.x) ||\n          outOfRange(a.y, b.y, p.y) ||\n          outOfRange(a.z, b.z, p.z));\n}\n\nbool outOfRange(vec4 a, vec4 b, vec4 p) {\n  return outOfRange(a.xyz, b.xyz, p.xyz);\n}\n\nuniform vec3 clipBounds[2];\nuniform float roughness, fresnel, kambient, kdiffuse, kspecular, opacity;\nuniform sampler2D texture;\n\nvarying vec3 f_normal, f_lightDirection, f_eyeDirection, f_data, f_position;\nvarying vec4 f_color;\nvarying vec2 f_uv;\n\nvoid main() {\n  if (outOfRange(clipBounds[0], clipBounds[1], f_position)) discard;\n  vec3 N = normalize(f_normal);\n  vec3 L = normalize(f_lightDirection);\n  vec3 V = normalize(f_eyeDirection);\n\n  if(gl_FrontFacing) {\n    N = -N;\n  }\n\n  float specular = min(1.0, max(0.0, cookTorranceSpecular(L, V, N, roughness, fresnel)));\n  float diffuse  = min(kambient + kdiffuse * max(dot(N, L), 0.0), 1.0);\n\n  vec4 surfaceColor = f_color * texture2D(texture, f_uv);\n  vec4 litColor = surfaceColor.a * vec4(diffuse * surfaceColor.rgb + kspecular * vec3(1,1,1) * specular,  1.0);\n\n  gl_FragColor = litColor * opacity;\n}\n"]);
+                  var pickVertSrc = glslify(["precision highp float;\n\nprecision highp float;\n#define GLSLIFY 1\n\nvec3 getOrthogonalVector(vec3 v) {\n  // Return up-vector for only-z vector.\n  // Return ax + by + cz = 0, a point that lies on the plane that has v as a normal and that isn't (0,0,0).\n  // From the above if-statement we have ||a|| > 0  U  ||b|| > 0.\n  // Assign z = 0, x = -b, y = a:\n  // a*-b + b*a + c*0 = -ba + ba + 0 = 0\n  if (v.x*v.x > v.z*v.z || v.y*v.y > v.z*v.z) {\n    return normalize(vec3(-v.y, v.x, 0.0));\n  } else {\n    return normalize(vec3(0.0, v.z, -v.y));\n  }\n}\n\n// Calculate the cone vertex and normal at the given index.\n//\n// The returned vertex is for a cone with its top at origin and height of 1.0,\n// pointing in the direction of the vector attribute.\n//\n// Each cone is made up of a top vertex, a center base vertex and base perimeter vertices.\n// These vertices are used to make up the triangles of the cone by the following:\n//   segment + 0 top vertex\n//   segment + 1 perimeter vertex a+1\n//   segment + 2 perimeter vertex a\n//   segment + 3 center base vertex\n//   segment + 4 perimeter vertex a\n//   segment + 5 perimeter vertex a+1\n// Where segment is the number of the radial segment * 6 and a is the angle at that radial segment.\n// To go from index to segment, floor(index / 6)\n// To go from segment to angle, 2*pi * (segment/segmentCount)\n// To go from index to segment index, index - (segment*6)\n//\nvec3 getConePosition(vec3 d, float rawIndex, float coneOffset, out vec3 normal) {\n\n  const float segmentCount = 8.0;\n\n  float index = rawIndex - floor(rawIndex /\n    (segmentCount * 6.0)) *\n    (segmentCount * 6.0);\n\n  float segment = floor(0.001 + index/6.0);\n  float segmentIndex = index - (segment*6.0);\n\n  normal = -normalize(d);\n\n  if (segmentIndex > 2.99 && segmentIndex < 3.01) {\n    return mix(vec3(0.0), -d, coneOffset);\n  }\n\n  float nextAngle = (\n    (segmentIndex > 0.99 &&  segmentIndex < 1.01) ||\n    (segmentIndex > 4.99 &&  segmentIndex < 5.01)\n  ) ? 1.0 : 0.0;\n  float angle = 2.0 * 3.14159 * ((segment + nextAngle) / segmentCount);\n\n  vec3 v1 = mix(d, vec3(0.0), coneOffset);\n  vec3 v2 = v1 - d;\n\n  vec3 u = getOrthogonalVector(d);\n  vec3 v = normalize(cross(u, d));\n\n  vec3 x = u * cos(angle) * length(d)*0.25;\n  vec3 y = v * sin(angle) * length(d)*0.25;\n  vec3 v3 = v2 + x + y;\n  if (segmentIndex < 3.0) {\n    vec3 tx = u * sin(angle);\n    vec3 ty = v * -cos(angle);\n    vec3 tangent = tx + ty;\n    normal = normalize(cross(v3 - v1, tangent));\n  }\n\n  if (segmentIndex == 0.0) {\n    return mix(d, vec3(0.0), coneOffset);\n  }\n  return v3;\n}\n\nattribute vec4 vector;\nattribute vec4 position;\nattribute vec4 id;\n\nuniform mat4 model, view, projection;\nuniform float vectorScale, coneScale, coneOffset;\n\nvarying vec3 f_position;\nvarying vec4 f_id;\n\nvoid main() {\n  vec3 normal;\n  vec3 XYZ = getConePosition(mat3(model) * ((vectorScale * coneScale) * vector.xyz), position.w, coneOffset, normal);\n  vec4 conePosition = model * vec4(position.xyz, 1.0) + vec4(XYZ, 0.0);\n  gl_Position = projection * (view * conePosition);\n  f_id        = id;\n  f_position  = position.xyz;\n}\n"]);
+                  var pickFragSrc = glslify(["precision highp float;\n#define GLSLIFY 1\n\nbool outOfRange(float a, float b, float p) {\n  return ((p > max(a, b)) || \n          (p < min(a, b)));\n}\n\nbool outOfRange(vec2 a, vec2 b, vec2 p) {\n  return (outOfRange(a.x, b.x, p.x) ||\n          outOfRange(a.y, b.y, p.y));\n}\n\nbool outOfRange(vec3 a, vec3 b, vec3 p) {\n  return (outOfRange(a.x, b.x, p.x) ||\n          outOfRange(a.y, b.y, p.y) ||\n          outOfRange(a.z, b.z, p.z));\n}\n\nbool outOfRange(vec4 a, vec4 b, vec4 p) {\n  return outOfRange(a.xyz, b.xyz, p.xyz);\n}\n\nuniform vec3  clipBounds[2];\nuniform float pickId;\n\nvarying vec3 f_position;\nvarying vec4 f_id;\n\nvoid main() {\n  if (outOfRange(clipBounds[0], clipBounds[1], f_position)) discard;\n\n  gl_FragColor = vec4(pickId, f_id.xyz);\n}"]);
+                  exports2.meshShader = {
+                    vertex: triVertSrc,
+                    fragment: triFragSrc,
+                    attributes: [
+                      { name: "position", type: "vec4" },
+                      { name: "color", type: "vec4" },
+                      { name: "uv", type: "vec2" },
+                      { name: "vector", type: "vec3" }
+                    ]
+                  };
+                  exports2.pickShader = {
+                    vertex: pickVertSrc,
+                    fragment: pickFragSrc,
+                    attributes: [
+                      { name: "position", type: "vec4" },
+                      { name: "id", type: "vec4" },
+                      { name: "vector", type: "vec3" }
+                    ]
+                  };
+                }
+              ),
+              /***/
+              620: (
+                /***/
+                function(module22) {
+                  module22.exports = [
+                    // current
+                    "precision",
+                    "highp",
+                    "mediump",
+                    "lowp",
+                    "attribute",
+                    "const",
+                    "uniform",
+                    "varying",
+                    "break",
+                    "continue",
+                    "do",
+                    "for",
+                    "while",
+                    "if",
+                    "else",
+                    "in",
+                    "out",
+                    "inout",
+                    "float",
+                    "int",
+                    "uint",
+                    "void",
+                    "bool",
+                    "true",
+                    "false",
+                    "discard",
+                    "return",
+                    "mat2",
+                    "mat3",
+                    "mat4",
+                    "vec2",
+                    "vec3",
+                    "vec4",
+                    "ivec2",
+                    "ivec3",
+                    "ivec4",
+                    "bvec2",
+                    "bvec3",
+                    "bvec4",
+                    "sampler1D",
+                    "sampler2D",
+                    "sampler3D",
+                    "samplerCube",
+                    "sampler1DShadow",
+                    "sampler2DShadow",
+                    "struct",
+                    "asm",
+                    "class",
+                    "union",
+                    "enum",
+                    "typedef",
+                    "template",
+                    "this",
+                    "packed",
+                    "goto",
+                    "switch",
+                    "default",
+                    "inline",
+                    "noinline",
+                    "volatile",
+                    "public",
+                    "static",
+                    "extern",
+                    "external",
+                    "interface",
+                    "long",
+                    "short",
+                    "double",
+                    "half",
+                    "fixed",
+                    "unsigned",
+                    "input",
+                    "output",
+                    "hvec2",
+                    "hvec3",
+                    "hvec4",
+                    "dvec2",
+                    "dvec3",
+                    "dvec4",
+                    "fvec2",
+                    "fvec3",
+                    "fvec4",
+                    "sampler2DRect",
+                    "sampler3DRect",
+                    "sampler2DRectShadow",
+                    "sizeof",
+                    "cast",
+                    "namespace",
+                    "using"
+                  ];
+                }
+              ),
+              /***/
+              665: (
+                /***/
+                function(module22, __unused_webpack_exports, __webpack_require__2) {
+                  var parseUnit = __webpack_require__2(3202);
+                  module22.exports = toPX;
+                  var PIXELS_PER_INCH = 96;
+                  function getPropertyInPX(element, prop) {
+                    var parts = parseUnit(getComputedStyle(element).getPropertyValue(prop));
+                    return parts[0] * toPX(parts[1], element);
+                  }
+                  function getSizeBrutal(unit, element) {
+                    var testDIV = document.createElement("div");
+                    testDIV.style["font-size"] = "128" + unit;
+                    element.appendChild(testDIV);
+                    var size = getPropertyInPX(testDIV, "font-size") / 128;
+                    element.removeChild(testDIV);
+                    return size;
+                  }
+                  function toPX(str, element) {
+                    element = element || document.body;
+                    str = (str || "px").trim().toLowerCase();
+                    if (element === window || element === document) {
+                      element = document.body;
+                    }
+                    switch (str) {
+                      case "%":
+                        return element.clientHeight / 100;
+                      case "ch":
+                      case "ex":
+                        return getSizeBrutal(str, element);
+                      case "em":
+                        return getPropertyInPX(element, "font-size");
+                      case "rem":
+                        return getPropertyInPX(document.body, "font-size");
+                      case "vw":
+                        return window.innerWidth / 100;
+                      case "vh":
+                        return window.innerHeight / 100;
+                      case "vmin":
+                        return Math.min(window.innerWidth, window.innerHeight) / 100;
+                      case "vmax":
+                        return Math.max(window.innerWidth, window.innerHeight) / 100;
+                      case "in":
+                        return PIXELS_PER_INCH;
+                      case "cm":
+                        return PIXELS_PER_INCH / 2.54;
+                      case "mm":
+                        return PIXELS_PER_INCH / 25.4;
+                      case "pt":
+                        return PIXELS_PER_INCH / 72;
+                      case "pc":
+                        return PIXELS_PER_INCH / 6;
+                    }
+                    return 1;
+                  }
+                }
+              ),
+              /***/
+              727: (
+                /***/
+                function(module22, __unused_webpack_exports, __webpack_require__2) {
+                  var determinant2 = __webpack_require__2(2962);
+                  var NUM_EXPAND = 6;
+                  function generateSolver(n2) {
+                    var fn = n2 === 2 ? solve2d : n2 === 3 ? solve3d : n2 === 4 ? solve4d : n2 === 5 ? solve5d : solve6d;
+                    if (n2 < 6) {
+                      return fn(determinant2[n2]);
+                    }
+                    return fn(determinant2);
+                  }
+                  function robustLinearSolve0d() {
+                    return [[0]];
+                  }
+                  function robustLinearSolve1d(A22, b2) {
+                    return [[b2[0]], [A22[0][0]]];
+                  }
+                  function solve2d(det) {
+                    return function robustLinearSolve2d(A22, b2) {
+                      return [det([[+b2[0], +A22[0][1]], [+b2[1], +A22[1][1]]]), det([[+A22[0][0], +b2[0]], [+A22[1][0], +b2[1]]]), det(A22)];
+                    };
+                  }
+                  function solve3d(det) {
+                    return function robustLinearSolve3d(A22, b2) {
+                      return [det([[+b2[0], +A22[0][1], +A22[0][2]], [+b2[1], +A22[1][1], +A22[1][2]], [+b2[2], +A22[2][1], +A22[2][2]]]), det([[+A22[0][0], +b2[0], +A22[0][2]], [+A22[1][0], +b2[1], +A22[1][2]], [+A22[2][0], +b2[2], +A22[2][2]]]), det([[+A22[0][0], +A22[0][1], +b2[0]], [+A22[1][0], +A22[1][1], +b2[1]], [+A22[2][0], +A22[2][1], +b2[2]]]), det(A22)];
+                    };
+                  }
+                  function solve4d(det) {
+                    return function robustLinearSolve4d(A22, b2) {
+                      return [det([[+b2[0], +A22[0][1], +A22[0][2], +A22[0][3]], [+b2[1], +A22[1][1], +A22[1][2], +A22[1][3]], [+b2[2], +A22[2][1], +A22[2][2], +A22[2][3]], [+b2[3], +A22[3][1], +A22[3][2], +A22[3][3]]]), det([[+A22[0][0], +b2[0], +A22[0][2], +A22[0][3]], [+A22[1][0], +b2[1], +A22[1][2], +A22[1][3]], [+A22[2][0], +b2[2], +A22[2][2], +A22[2][3]], [+A22[3][0], +b2[3], +A22[3][2], +A22[3][3]]]), det([[+A22[0][0], +A22[0][1], +b2[0], +A22[0][3]], [+A22[1][0], +A22[1][1], +b2[1], +A22[1][3]], [+A22[2][0], +A22[2][1], +b2[2], +A22[2][3]], [+A22[3][0], +A22[3][1], +b2[3], +A22[3][3]]]), det([[+A22[0][0], +A22[0][1], +A22[0][2], +b2[0]], [+A22[1][0], +A22[1][1], +A22[1][2], +b2[1]], [+A22[2][0], +A22[2][1], +A22[2][2], +b2[2]], [+A22[3][0], +A22[3][1], +A22[3][2], +b2[3]]]), det(A22)];
+                    };
+                  }
+                  function solve5d(det) {
+                    return function robustLinearSolve5d(A22, b2) {
+                      return [det([[+b2[0], +A22[0][1], +A22[0][2], +A22[0][3], +A22[0][4]], [+b2[1], +A22[1][1], +A22[1][2], +A22[1][3], +A22[1][4]], [+b2[2], +A22[2][1], +A22[2][2], +A22[2][3], +A22[2][4]], [+b2[3], +A22[3][1], +A22[3][2], +A22[3][3], +A22[3][4]], [+b2[4], +A22[4][1], +A22[4][2], +A22[4][3], +A22[4][4]]]), det([[+A22[0][0], +b2[0], +A22[0][2], +A22[0][3], +A22[0][4]], [+A22[1][0], +b2[1], +A22[1][2], +A22[1][3], +A22[1][4]], [+A22[2][0], +b2[2], +A22[2][2], +A22[2][3], +A22[2][4]], [+A22[3][0], +b2[3], +A22[3][2], +A22[3][3], +A22[3][4]], [+A22[4][0], +b2[4], +A22[4][2], +A22[4][3], +A22[4][4]]]), det([[+A22[0][0], +A22[0][1], +b2[0], +A22[0][3], +A22[0][4]], [+A22[1][0], +A22[1][1], +b2[1], +A22[1][3], +A22[1][4]], [+A22[2][0], +A22[2][1], +b2[2], +A22[2][3], +A22[2][4]], [+A22[3][0], +A22[3][1], +b2[3], +A22[3][3], +A22[3][4]], [+A22[4][0], +A22[4][1], +b2[4], +A22[4][3], +A22[4][4]]]), det([[+A22[0][0], +A22[0][1], +A22[0][2], +b2[0], +A22[0][4]], [+A22[1][0], +A22[1][1], +A22[1][2], +b2[1], +A22[1][4]], [+A22[2][0], +A22[2][1], +A22[2][2], +b2[2], +A22[2][4]], [+A22[3][0], +A22[3][1], +A22[3][2], +b2[3], +A22[3][4]], [+A22[4][0], +A22[4][1], +A22[4][2], +b2[4], +A22[4][4]]]), det([[+A22[0][0], +A22[0][1], +A22[0][2], +A22[0][3], +b2[0]], [+A22[1][0], +A22[1][1], +A22[1][2], +A22[1][3], +b2[1]], [+A22[2][0], +A22[2][1], +A22[2][2], +A22[2][3], +b2[2]], [+A22[3][0], +A22[3][1], +A22[3][2], +A22[3][3], +b2[3]], [+A22[4][0], +A22[4][1], +A22[4][2], +A22[4][3], +b2[4]]]), det(A22)];
+                    };
+                  }
+                  function solve6d(det) {
+                    return function robustLinearSolve6d(A22, b2) {
+                      return [det([[+b2[0], +A22[0][1], +A22[0][2], +A22[0][3], +A22[0][4], +A22[0][5]], [+b2[1], +A22[1][1], +A22[1][2], +A22[1][3], +A22[1][4], +A22[1][5]], [+b2[2], +A22[2][1], +A22[2][2], +A22[2][3], +A22[2][4], +A22[2][5]], [+b2[3], +A22[3][1], +A22[3][2], +A22[3][3], +A22[3][4], +A22[3][5]], [+b2[4], +A22[4][1], +A22[4][2], +A22[4][3], +A22[4][4], +A22[4][5]], [+b2[5], +A22[5][1], +A22[5][2], +A22[5][3], +A22[5][4], +A22[5][5]]]), det([[+A22[0][0], +b2[0], +A22[0][2], +A22[0][3], +A22[0][4], +A22[0][5]], [+A22[1][0], +b2[1], +A22[1][2], +A22[1][3], +A22[1][4], +A22[1][5]], [+A22[2][0], +b2[2], +A22[2][2], +A22[2][3], +A22[2][4], +A22[2][5]], [+A22[3][0], +b2[3], +A22[3][2], +A22[3][3], +A22[3][4], +A22[3][5]], [+A22[4][0], +b2[4], +A22[4][2], +A22[4][3], +A22[4][4], +A22[4][5]], [+A22[5][0], +b2[5], +A22[5][2], +A22[5][3], +A22[5][4], +A22[5][5]]]), det([[+A22[0][0], +A22[0][1], +b2[0], +A22[0][3], +A22[0][4], +A22[0][5]], [+A22[1][0], +A22[1][1], +b2[1], +A22[1][3], +A22[1][4], +A22[1][5]], [+A22[2][0], +A22[2][1], +b2[2], +A22[2][3], +A22[2][4], +A22[2][5]], [+A22[3][0], +A22[3][1], +b2[3], +A22[3][3], +A22[3][4], +A22[3][5]], [+A22[4][0], +A22[4][1], +b2[4], +A22[4][3], +A22[4][4], +A22[4][5]], [+A22[5][0], +A22[5][1], +b2[5], +A22[5][3], +A22[5][4], +A22[5][5]]]), det([[+A22[0][0], +A22[0][1], +A22[0][2], +b2[0], +A22[0][4], +A22[0][5]], [+A22[1][0], +A22[1][1], +A22[1][2], +b2[1], +A22[1][4], +A22[1][5]], [+A22[2][0], +A22[2][1], +A22[2][2], +b2[2], +A22[2][4], +A22[2][5]], [+A22[3][0], +A22[3][1], +A22[3][2], +b2[3], +A22[3][4], +A22[3][5]], [+A22[4][0], +A22[4][1], +A22[4][2], +b2[4], +A22[4][4], +A22[4][5]], [+A22[5][0], +A22[5][1], +A22[5][2], +b2[5], +A22[5][4], +A22[5][5]]]), det([[+A22[0][0], +A22[0][1], +A22[0][2], +A22[0][3], +b2[0], +A22[0][5]], [+A22[1][0], +A22[1][1], +A22[1][2], +A22[1][3], +b2[1], +A22[1][5]], [+A22[2][0], +A22[2][1], +A22[2][2], +A22[2][3], +b2[2], +A22[2][5]], [+A22[3][0], +A22[3][1], +A22[3][2], +A22[3][3], +b2[3], +A22[3][5]], [+A22[4][0], +A22[4][1], +A22[4][2], +A22[4][3], +b2[4], +A22[4][5]], [+A22[5][0], +A22[5][1], +A22[5][2], +A22[5][3], +b2[5], +A22[5][5]]]), det([[+A22[0][0], +A22[0][1], +A22[0][2], +A22[0][3], +A22[0][4], +b2[0]], [+A22[1][0], +A22[1][1], +A22[1][2], +A22[1][3], +A22[1][4], +b2[1]], [+A22[2][0], +A22[2][1], +A22[2][2], +A22[2][3], +A22[2][4], +b2[2]], [+A22[3][0], +A22[3][1], +A22[3][2], +A22[3][3], +A22[3][4], +b2[3]], [+A22[4][0], +A22[4][1], +A22[4][2], +A22[4][3], +A22[4][4], +b2[4]], [+A22[5][0], +A22[5][1], +A22[5][2], +A22[5][3], +A22[5][4], +b2[5]]]), det(A22)];
+                    };
+                  }
+                  var CACHE = [
+                    robustLinearSolve0d,
+                    robustLinearSolve1d
+                  ];
+                  function proc(s0, s1, s2, s3, s4, s5, CACHE2, g2) {
+                    return function dispatchLinearSolve(A22, b2) {
+                      switch (A22.length) {
+                        case 0:
+                          return s0(A22, b2);
+                        case 1:
+                          return s1(A22, b2);
+                        case 2:
+                          return s2(A22, b2);
+                        case 3:
+                          return s3(A22, b2);
+                        case 4:
+                          return s4(A22, b2);
+                        case 5:
+                          return s5(A22, b2);
+                      }
+                      var s6 = CACHE2[A22.length];
+                      if (!s6) s6 = CACHE2[A22.length] = g2(A22.length);
+                      return s6(A22, b2);
+                    };
+                  }
+                  function generateDispatch() {
+                    while (CACHE.length < NUM_EXPAND) {
+                      CACHE.push(generateSolver(CACHE.length));
+                    }
+                    module22.exports = proc.apply(void 0, CACHE.concat([CACHE, generateSolver]));
+                    for (var i2 = 0; i2 < NUM_EXPAND; ++i2) {
+                      module22.exports[i2] = CACHE[i2];
+                    }
+                  }
+                  generateDispatch();
+                }
+              ),
+              /***/
+              737: (
+                /***/
+                function(module22) {
+                  module22.exports = {
+                    0: "NONE",
+                    1: "ONE",
+                    2: "LINE_LOOP",
+                    3: "LINE_STRIP",
+                    4: "TRIANGLES",
+                    5: "TRIANGLE_STRIP",
+                    6: "TRIANGLE_FAN",
+                    256: "DEPTH_BUFFER_BIT",
+                    512: "NEVER",
+                    513: "LESS",
+                    514: "EQUAL",
+                    515: "LEQUAL",
+                    516: "GREATER",
+                    517: "NOTEQUAL",
+                    518: "GEQUAL",
+                    519: "ALWAYS",
+                    768: "SRC_COLOR",
+                    769: "ONE_MINUS_SRC_COLOR",
+                    770: "SRC_ALPHA",
+                    771: "ONE_MINUS_SRC_ALPHA",
+                    772: "DST_ALPHA",
+                    773: "ONE_MINUS_DST_ALPHA",
+                    774: "DST_COLOR",
+                    775: "ONE_MINUS_DST_COLOR",
+                    776: "SRC_ALPHA_SATURATE",
+                    1024: "STENCIL_BUFFER_BIT",
+                    1028: "FRONT",
+                    1029: "BACK",
+                    1032: "FRONT_AND_BACK",
+                    1280: "INVALID_ENUM",
+                    1281: "INVALID_VALUE",
+                    1282: "INVALID_OPERATION",
+                    1285: "OUT_OF_MEMORY",
+                    1286: "INVALID_FRAMEBUFFER_OPERATION",
+                    2304: "CW",
+                    2305: "CCW",
+                    2849: "LINE_WIDTH",
+                    2884: "CULL_FACE",
+                    2885: "CULL_FACE_MODE",
+                    2886: "FRONT_FACE",
+                    2928: "DEPTH_RANGE",
+                    2929: "DEPTH_TEST",
+                    2930: "DEPTH_WRITEMASK",
+                    2931: "DEPTH_CLEAR_VALUE",
+                    2932: "DEPTH_FUNC",
+                    2960: "STENCIL_TEST",
+                    2961: "STENCIL_CLEAR_VALUE",
+                    2962: "STENCIL_FUNC",
+                    2963: "STENCIL_VALUE_MASK",
+                    2964: "STENCIL_FAIL",
+                    2965: "STENCIL_PASS_DEPTH_FAIL",
+                    2966: "STENCIL_PASS_DEPTH_PASS",
+                    2967: "STENCIL_REF",
+                    2968: "STENCIL_WRITEMASK",
+                    2978: "VIEWPORT",
+                    3024: "DITHER",
+                    3042: "BLEND",
+                    3088: "SCISSOR_BOX",
+                    3089: "SCISSOR_TEST",
+                    3106: "COLOR_CLEAR_VALUE",
+                    3107: "COLOR_WRITEMASK",
+                    3317: "UNPACK_ALIGNMENT",
+                    3333: "PACK_ALIGNMENT",
+                    3379: "MAX_TEXTURE_SIZE",
+                    3386: "MAX_VIEWPORT_DIMS",
+                    3408: "SUBPIXEL_BITS",
+                    3410: "RED_BITS",
+                    3411: "GREEN_BITS",
+                    3412: "BLUE_BITS",
+                    3413: "ALPHA_BITS",
+                    3414: "DEPTH_BITS",
+                    3415: "STENCIL_BITS",
+                    3553: "TEXTURE_2D",
+                    4352: "DONT_CARE",
+                    4353: "FASTEST",
+                    4354: "NICEST",
+                    5120: "BYTE",
+                    5121: "UNSIGNED_BYTE",
+                    5122: "SHORT",
+                    5123: "UNSIGNED_SHORT",
+                    5124: "INT",
+                    5125: "UNSIGNED_INT",
+                    5126: "FLOAT",
+                    5386: "INVERT",
+                    5890: "TEXTURE",
+                    6401: "STENCIL_INDEX",
+                    6402: "DEPTH_COMPONENT",
+                    6406: "ALPHA",
+                    6407: "RGB",
+                    6408: "RGBA",
+                    6409: "LUMINANCE",
+                    6410: "LUMINANCE_ALPHA",
+                    7680: "KEEP",
+                    7681: "REPLACE",
+                    7682: "INCR",
+                    7683: "DECR",
+                    7936: "VENDOR",
+                    7937: "RENDERER",
+                    7938: "VERSION",
+                    9728: "NEAREST",
+                    9729: "LINEAR",
+                    9984: "NEAREST_MIPMAP_NEAREST",
+                    9985: "LINEAR_MIPMAP_NEAREST",
+                    9986: "NEAREST_MIPMAP_LINEAR",
+                    9987: "LINEAR_MIPMAP_LINEAR",
+                    10240: "TEXTURE_MAG_FILTER",
+                    10241: "TEXTURE_MIN_FILTER",
+                    10242: "TEXTURE_WRAP_S",
+                    10243: "TEXTURE_WRAP_T",
+                    10497: "REPEAT",
+                    10752: "POLYGON_OFFSET_UNITS",
+                    16384: "COLOR_BUFFER_BIT",
+                    32769: "CONSTANT_COLOR",
+                    32770: "ONE_MINUS_CONSTANT_COLOR",
+                    32771: "CONSTANT_ALPHA",
+                    32772: "ONE_MINUS_CONSTANT_ALPHA",
+                    32773: "BLEND_COLOR",
+                    32774: "FUNC_ADD",
+                    32777: "BLEND_EQUATION_RGB",
+                    32778: "FUNC_SUBTRACT",
+                    32779: "FUNC_REVERSE_SUBTRACT",
+                    32819: "UNSIGNED_SHORT_4_4_4_4",
+                    32820: "UNSIGNED_SHORT_5_5_5_1",
+                    32823: "POLYGON_OFFSET_FILL",
+                    32824: "POLYGON_OFFSET_FACTOR",
+                    32854: "RGBA4",
+                    32855: "RGB5_A1",
+                    32873: "TEXTURE_BINDING_2D",
+                    32926: "SAMPLE_ALPHA_TO_COVERAGE",
+                    32928: "SAMPLE_COVERAGE",
+                    32936: "SAMPLE_BUFFERS",
+                    32937: "SAMPLES",
+                    32938: "SAMPLE_COVERAGE_VALUE",
+                    32939: "SAMPLE_COVERAGE_INVERT",
+                    32968: "BLEND_DST_RGB",
+                    32969: "BLEND_SRC_RGB",
+                    32970: "BLEND_DST_ALPHA",
+                    32971: "BLEND_SRC_ALPHA",
+                    33071: "CLAMP_TO_EDGE",
+                    33170: "GENERATE_MIPMAP_HINT",
+                    33189: "DEPTH_COMPONENT16",
+                    33306: "DEPTH_STENCIL_ATTACHMENT",
+                    33635: "UNSIGNED_SHORT_5_6_5",
+                    33648: "MIRRORED_REPEAT",
+                    33901: "ALIASED_POINT_SIZE_RANGE",
+                    33902: "ALIASED_LINE_WIDTH_RANGE",
+                    33984: "TEXTURE0",
+                    33985: "TEXTURE1",
+                    33986: "TEXTURE2",
+                    33987: "TEXTURE3",
+                    33988: "TEXTURE4",
+                    33989: "TEXTURE5",
+                    33990: "TEXTURE6",
+                    33991: "TEXTURE7",
+                    33992: "TEXTURE8",
+                    33993: "TEXTURE9",
+                    33994: "TEXTURE10",
+                    33995: "TEXTURE11",
+                    33996: "TEXTURE12",
+                    33997: "TEXTURE13",
+                    33998: "TEXTURE14",
+                    33999: "TEXTURE15",
+                    34e3: "TEXTURE16",
+                    34001: "TEXTURE17",
+                    34002: "TEXTURE18",
+                    34003: "TEXTURE19",
+                    34004: "TEXTURE20",
+                    34005: "TEXTURE21",
+                    34006: "TEXTURE22",
+                    34007: "TEXTURE23",
+                    34008: "TEXTURE24",
+                    34009: "TEXTURE25",
+                    34010: "TEXTURE26",
+                    34011: "TEXTURE27",
+                    34012: "TEXTURE28",
+                    34013: "TEXTURE29",
+                    34014: "TEXTURE30",
+                    34015: "TEXTURE31",
+                    34016: "ACTIVE_TEXTURE",
+                    34024: "MAX_RENDERBUFFER_SIZE",
+                    34041: "DEPTH_STENCIL",
+                    34055: "INCR_WRAP",
+                    34056: "DECR_WRAP",
+                    34067: "TEXTURE_CUBE_MAP",
+                    34068: "TEXTURE_BINDING_CUBE_MAP",
+                    34069: "TEXTURE_CUBE_MAP_POSITIVE_X",
+                    34070: "TEXTURE_CUBE_MAP_NEGATIVE_X",
+                    34071: "TEXTURE_CUBE_MAP_POSITIVE_Y",
+                    34072: "TEXTURE_CUBE_MAP_NEGATIVE_Y",
+                    34073: "TEXTURE_CUBE_MAP_POSITIVE_Z",
+                    34074: "TEXTURE_CUBE_MAP_NEGATIVE_Z",
+                    34076: "MAX_CUBE_MAP_TEXTURE_SIZE",
+                    34338: "VERTEX_ATTRIB_ARRAY_ENABLED",
+                    34339: "VERTEX_ATTRIB_ARRAY_SIZE",
+                    34340: "VERTEX_ATTRIB_ARRAY_STRIDE",
+                    34341: "VERTEX_ATTRIB_ARRAY_TYPE",
+                    34342: "CURRENT_VERTEX_ATTRIB",
+                    34373: "VERTEX_ATTRIB_ARRAY_POINTER",
+                    34466: "NUM_COMPRESSED_TEXTURE_FORMATS",
+                    34467: "COMPRESSED_TEXTURE_FORMATS",
+                    34660: "BUFFER_SIZE",
+                    34661: "BUFFER_USAGE",
+                    34816: "STENCIL_BACK_FUNC",
+                    34817: "STENCIL_BACK_FAIL",
+                    34818: "STENCIL_BACK_PASS_DEPTH_FAIL",
+                    34819: "STENCIL_BACK_PASS_DEPTH_PASS",
+                    34877: "BLEND_EQUATION_ALPHA",
+                    34921: "MAX_VERTEX_ATTRIBS",
+                    34922: "VERTEX_ATTRIB_ARRAY_NORMALIZED",
+                    34930: "MAX_TEXTURE_IMAGE_UNITS",
+                    34962: "ARRAY_BUFFER",
+                    34963: "ELEMENT_ARRAY_BUFFER",
+                    34964: "ARRAY_BUFFER_BINDING",
+                    34965: "ELEMENT_ARRAY_BUFFER_BINDING",
+                    34975: "VERTEX_ATTRIB_ARRAY_BUFFER_BINDING",
+                    35040: "STREAM_DRAW",
+                    35044: "STATIC_DRAW",
+                    35048: "DYNAMIC_DRAW",
+                    35632: "FRAGMENT_SHADER",
+                    35633: "VERTEX_SHADER",
+                    35660: "MAX_VERTEX_TEXTURE_IMAGE_UNITS",
+                    35661: "MAX_COMBINED_TEXTURE_IMAGE_UNITS",
+                    35663: "SHADER_TYPE",
+                    35664: "FLOAT_VEC2",
+                    35665: "FLOAT_VEC3",
+                    35666: "FLOAT_VEC4",
+                    35667: "INT_VEC2",
+                    35668: "INT_VEC3",
+                    35669: "INT_VEC4",
+                    35670: "BOOL",
+                    35671: "BOOL_VEC2",
+                    35672: "BOOL_VEC3",
+                    35673: "BOOL_VEC4",
+                    35674: "FLOAT_MAT2",
+                    35675: "FLOAT_MAT3",
+                    35676: "FLOAT_MAT4",
+                    35678: "SAMPLER_2D",
+                    35680: "SAMPLER_CUBE",
+                    35712: "DELETE_STATUS",
+                    35713: "COMPILE_STATUS",
+                    35714: "LINK_STATUS",
+                    35715: "VALIDATE_STATUS",
+                    35716: "INFO_LOG_LENGTH",
+                    35717: "ATTACHED_SHADERS",
+                    35718: "ACTIVE_UNIFORMS",
+                    35719: "ACTIVE_UNIFORM_MAX_LENGTH",
+                    35720: "SHADER_SOURCE_LENGTH",
+                    35721: "ACTIVE_ATTRIBUTES",
+                    35722: "ACTIVE_ATTRIBUTE_MAX_LENGTH",
+                    35724: "SHADING_LANGUAGE_VERSION",
+                    35725: "CURRENT_PROGRAM",
+                    36003: "STENCIL_BACK_REF",
+                    36004: "STENCIL_BACK_VALUE_MASK",
+                    36005: "STENCIL_BACK_WRITEMASK",
+                    36006: "FRAMEBUFFER_BINDING",
+                    36007: "RENDERBUFFER_BINDING",
+                    36048: "FRAMEBUFFER_ATTACHMENT_OBJECT_TYPE",
+                    36049: "FRAMEBUFFER_ATTACHMENT_OBJECT_NAME",
+                    36050: "FRAMEBUFFER_ATTACHMENT_TEXTURE_LEVEL",
+                    36051: "FRAMEBUFFER_ATTACHMENT_TEXTURE_CUBE_MAP_FACE",
+                    36053: "FRAMEBUFFER_COMPLETE",
+                    36054: "FRAMEBUFFER_INCOMPLETE_ATTACHMENT",
+                    36055: "FRAMEBUFFER_INCOMPLETE_MISSING_ATTACHMENT",
+                    36057: "FRAMEBUFFER_INCOMPLETE_DIMENSIONS",
+                    36061: "FRAMEBUFFER_UNSUPPORTED",
+                    36064: "COLOR_ATTACHMENT0",
+                    36096: "DEPTH_ATTACHMENT",
+                    36128: "STENCIL_ATTACHMENT",
+                    36160: "FRAMEBUFFER",
+                    36161: "RENDERBUFFER",
+                    36162: "RENDERBUFFER_WIDTH",
+                    36163: "RENDERBUFFER_HEIGHT",
+                    36164: "RENDERBUFFER_INTERNAL_FORMAT",
+                    36168: "STENCIL_INDEX8",
+                    36176: "RENDERBUFFER_RED_SIZE",
+                    36177: "RENDERBUFFER_GREEN_SIZE",
+                    36178: "RENDERBUFFER_BLUE_SIZE",
+                    36179: "RENDERBUFFER_ALPHA_SIZE",
+                    36180: "RENDERBUFFER_DEPTH_SIZE",
+                    36181: "RENDERBUFFER_STENCIL_SIZE",
+                    36194: "RGB565",
+                    36336: "LOW_FLOAT",
+                    36337: "MEDIUM_FLOAT",
+                    36338: "HIGH_FLOAT",
+                    36339: "LOW_INT",
+                    36340: "MEDIUM_INT",
+                    36341: "HIGH_INT",
+                    36346: "SHADER_COMPILER",
+                    36347: "MAX_VERTEX_UNIFORM_VECTORS",
+                    36348: "MAX_VARYING_VECTORS",
+                    36349: "MAX_FRAGMENT_UNIFORM_VECTORS",
+                    37440: "UNPACK_FLIP_Y_WEBGL",
+                    37441: "UNPACK_PREMULTIPLY_ALPHA_WEBGL",
+                    37442: "CONTEXT_LOST_WEBGL",
+                    37443: "UNPACK_COLORSPACE_CONVERSION_WEBGL",
+                    37444: "BROWSER_DEFAULT_WEBGL"
+                  };
+                }
+              ),
+              /***/
+              781: (
+                /***/
+                function(module22, __unused_webpack_exports, __webpack_require__2) {
+                  module22.exports = findZeroCrossings;
+                  var core = __webpack_require__2(3349);
+                  function findZeroCrossings(array, level) {
+                    var cross2 = [];
+                    level = +level || 0;
+                    core(array.hi(array.shape[0] - 1), cross2, level);
+                    return cross2;
+                  }
+                }
+              ),
+              /***/
+              783: (
+                /***/
+                function(module22) {
+                  module22.exports = slerp;
+                  function slerp(out, a2, b2, t4) {
+                    var ax = a2[0], ay = a2[1], az = a2[2], aw = a2[3], bx = b2[0], by = b2[1], bz = b2[2], bw = b2[3];
+                    var omega, cosom, sinom, scale0, scale1;
+                    cosom = ax * bx + ay * by + az * bz + aw * bw;
+                    if (cosom < 0) {
+                      cosom = -cosom;
+                      bx = -bx;
+                      by = -by;
+                      bz = -bz;
+                      bw = -bw;
+                    }
+                    if (1 - cosom > 1e-6) {
+                      omega = Math.acos(cosom);
+                      sinom = Math.sin(omega);
+                      scale0 = Math.sin((1 - t4) * omega) / sinom;
+                      scale1 = Math.sin(t4 * omega) / sinom;
+                    } else {
+                      scale0 = 1 - t4;
+                      scale1 = t4;
+                    }
+                    out[0] = scale0 * ax + scale1 * bx;
+                    out[1] = scale0 * ay + scale1 * by;
+                    out[2] = scale0 * az + scale1 * bz;
+                    out[3] = scale0 * aw + scale1 * bw;
+                    return out;
+                  }
+                }
+              ),
+              /***/
+              799: (
+                /***/
+                function(module22, __unused_webpack_exports, __webpack_require__2) {
+                  var glslify = __webpack_require__2(3236);
+                  var createShader = __webpack_require__2(9405);
+                  var vertSrc = glslify(["precision mediump float;\n#define GLSLIFY 1\nattribute vec2 position;\nvarying vec2 uv;\nvoid main() {\n  uv = position;\n  gl_Position = vec4(position, 0, 1);\n}"]);
+                  var fragSrc = glslify(["precision mediump float;\n#define GLSLIFY 1\n\nuniform sampler2D accumBuffer;\nvarying vec2 uv;\n\nvoid main() {\n  vec4 accum = texture2D(accumBuffer, 0.5 * (uv + 1.0));\n  gl_FragColor = min(vec4(1,1,1,1), accum);\n}"]);
+                  module22.exports = function(gl2) {
+                    return createShader(gl2, vertSrc, fragSrc, null, [{ name: "position", type: "vec2" }]);
+                  };
+                }
+              ),
+              /***/
+              811: (
+                /***/
+                function(module22) {
+                  module22.exports = inverse;
+                  function inverse(out, a2) {
+                    out[0] = 1 / a2[0];
+                    out[1] = 1 / a2[1];
+                    out[2] = 1 / a2[2];
+                    return out;
+                  }
+                }
+              ),
+              /***/
+              840: (
+                /***/
+                function(__unused_webpack_module, exports2, __webpack_require__2) {
+                  var glslify = __webpack_require__2(3236);
+                  var triVertSrc = glslify(["precision highp float;\n#define GLSLIFY 1\n\nattribute vec3 position, normal;\nattribute vec4 color;\nattribute vec2 uv;\n\nuniform mat4 model\n           , view\n           , projection\n           , inverseModel;\nuniform vec3 eyePosition\n           , lightPosition;\n\nvarying vec3 f_normal\n           , f_lightDirection\n           , f_eyeDirection\n           , f_data;\nvarying vec4 f_color;\nvarying vec2 f_uv;\n\nvec4 project(vec3 p) {\n  return projection * (view * (model * vec4(p, 1.0)));\n}\n\nvoid main() {\n  gl_Position      = project(position);\n\n  //Lighting geometry parameters\n  vec4 cameraCoordinate = view * vec4(position , 1.0);\n  cameraCoordinate.xyz /= cameraCoordinate.w;\n  f_lightDirection = lightPosition - cameraCoordinate.xyz;\n  f_eyeDirection   = eyePosition - cameraCoordinate.xyz;\n  f_normal  = normalize((vec4(normal, 0.0) * inverseModel).xyz);\n\n  f_color          = color;\n  f_data           = position;\n  f_uv             = uv;\n}\n"]);
+                  var triFragSrc = glslify(["#extension GL_OES_standard_derivatives : enable\n\nprecision highp float;\n#define GLSLIFY 1\n\nfloat beckmannDistribution(float x, float roughness) {\n  float NdotH = max(x, 0.0001);\n  float cos2Alpha = NdotH * NdotH;\n  float tan2Alpha = (cos2Alpha - 1.0) / cos2Alpha;\n  float roughness2 = roughness * roughness;\n  float denom = 3.141592653589793 * roughness2 * cos2Alpha * cos2Alpha;\n  return exp(tan2Alpha / roughness2) / denom;\n}\n\nfloat cookTorranceSpecular(\n  vec3 lightDirection,\n  vec3 viewDirection,\n  vec3 surfaceNormal,\n  float roughness,\n  float fresnel) {\n\n  float VdotN = max(dot(viewDirection, surfaceNormal), 0.0);\n  float LdotN = max(dot(lightDirection, surfaceNormal), 0.0);\n\n  //Half angle vector\n  vec3 H = normalize(lightDirection + viewDirection);\n\n  //Geometric term\n  float NdotH = max(dot(surfaceNormal, H), 0.0);\n  float VdotH = max(dot(viewDirection, H), 0.000001);\n  float LdotH = max(dot(lightDirection, H), 0.000001);\n  float G1 = (2.0 * NdotH * VdotN) / VdotH;\n  float G2 = (2.0 * NdotH * LdotN) / LdotH;\n  float G = min(1.0, min(G1, G2));\n  \n  //Distribution term\n  float D = beckmannDistribution(NdotH, roughness);\n\n  //Fresnel term\n  float F = pow(1.0 - VdotN, fresnel);\n\n  //Multiply terms and done\n  return  G * F * D / max(3.14159265 * VdotN, 0.000001);\n}\n\n//#pragma glslify: beckmann = require(glsl-specular-beckmann) // used in gl-surface3d\n\nbool outOfRange(float a, float b, float p) {\n  return ((p > max(a, b)) || \n          (p < min(a, b)));\n}\n\nbool outOfRange(vec2 a, vec2 b, vec2 p) {\n  return (outOfRange(a.x, b.x, p.x) ||\n          outOfRange(a.y, b.y, p.y));\n}\n\nbool outOfRange(vec3 a, vec3 b, vec3 p) {\n  return (outOfRange(a.x, b.x, p.x) ||\n          outOfRange(a.y, b.y, p.y) ||\n          outOfRange(a.z, b.z, p.z));\n}\n\nbool outOfRange(vec4 a, vec4 b, vec4 p) {\n  return outOfRange(a.xyz, b.xyz, p.xyz);\n}\n\nuniform vec3 clipBounds[2];\nuniform float roughness\n            , fresnel\n            , kambient\n            , kdiffuse\n            , kspecular;\nuniform sampler2D texture;\n\nvarying vec3 f_normal\n           , f_lightDirection\n           , f_eyeDirection\n           , f_data;\nvarying vec4 f_color;\nvarying vec2 f_uv;\n\nvoid main() {\n  if (f_color.a == 0.0 ||\n    outOfRange(clipBounds[0], clipBounds[1], f_data)\n  ) discard;\n\n  vec3 N = normalize(f_normal);\n  vec3 L = normalize(f_lightDirection);\n  vec3 V = normalize(f_eyeDirection);\n\n  if(gl_FrontFacing) {\n    N = -N;\n  }\n\n  float specular = min(1.0, max(0.0, cookTorranceSpecular(L, V, N, roughness, fresnel)));\n  //float specular = max(0.0, beckmann(L, V, N, roughness)); // used in gl-surface3d\n\n  float diffuse  = min(kambient + kdiffuse * max(dot(N, L), 0.0), 1.0);\n\n  vec4 surfaceColor = vec4(f_color.rgb, 1.0) * texture2D(texture, f_uv);\n  vec4 litColor = surfaceColor.a * vec4(diffuse * surfaceColor.rgb + kspecular * vec3(1,1,1) * specular,  1.0);\n\n  gl_FragColor = litColor * f_color.a;\n}\n"]);
+                  var edgeVertSrc = glslify(["precision highp float;\n#define GLSLIFY 1\n\nattribute vec3 position;\nattribute vec4 color;\nattribute vec2 uv;\n\nuniform mat4 model, view, projection;\n\nvarying vec4 f_color;\nvarying vec3 f_data;\nvarying vec2 f_uv;\n\nvoid main() {\n  gl_Position = projection * (view * (model * vec4(position, 1.0)));\n  f_color = color;\n  f_data  = position;\n  f_uv    = uv;\n}"]);
+                  var edgeFragSrc = glslify(["precision highp float;\n#define GLSLIFY 1\n\nbool outOfRange(float a, float b, float p) {\n  return ((p > max(a, b)) || \n          (p < min(a, b)));\n}\n\nbool outOfRange(vec2 a, vec2 b, vec2 p) {\n  return (outOfRange(a.x, b.x, p.x) ||\n          outOfRange(a.y, b.y, p.y));\n}\n\nbool outOfRange(vec3 a, vec3 b, vec3 p) {\n  return (outOfRange(a.x, b.x, p.x) ||\n          outOfRange(a.y, b.y, p.y) ||\n          outOfRange(a.z, b.z, p.z));\n}\n\nbool outOfRange(vec4 a, vec4 b, vec4 p) {\n  return outOfRange(a.xyz, b.xyz, p.xyz);\n}\n\nuniform vec3 clipBounds[2];\nuniform sampler2D texture;\nuniform float opacity;\n\nvarying vec4 f_color;\nvarying vec3 f_data;\nvarying vec2 f_uv;\n\nvoid main() {\n  if (outOfRange(clipBounds[0], clipBounds[1], f_data)) discard;\n\n  gl_FragColor = f_color * texture2D(texture, f_uv) * opacity;\n}"]);
+                  var pointVertSrc = glslify(["precision highp float;\n#define GLSLIFY 1\n\nbool outOfRange(float a, float b, float p) {\n  return ((p > max(a, b)) || \n          (p < min(a, b)));\n}\n\nbool outOfRange(vec2 a, vec2 b, vec2 p) {\n  return (outOfRange(a.x, b.x, p.x) ||\n          outOfRange(a.y, b.y, p.y));\n}\n\nbool outOfRange(vec3 a, vec3 b, vec3 p) {\n  return (outOfRange(a.x, b.x, p.x) ||\n          outOfRange(a.y, b.y, p.y) ||\n          outOfRange(a.z, b.z, p.z));\n}\n\nbool outOfRange(vec4 a, vec4 b, vec4 p) {\n  return outOfRange(a.xyz, b.xyz, p.xyz);\n}\n\nattribute vec3 position;\nattribute vec4 color;\nattribute vec2 uv;\nattribute float pointSize;\n\nuniform mat4 model, view, projection;\nuniform vec3 clipBounds[2];\n\nvarying vec4 f_color;\nvarying vec2 f_uv;\n\nvoid main() {\n  if (outOfRange(clipBounds[0], clipBounds[1], position)) {\n\n    gl_Position = vec4(0.0, 0.0 ,0.0 ,0.0);\n  } else {\n    gl_Position = projection * (view * (model * vec4(position, 1.0)));\n  }\n  gl_PointSize = pointSize;\n  f_color = color;\n  f_uv = uv;\n}"]);
+                  var pointFragSrc = glslify(["precision highp float;\n#define GLSLIFY 1\n\nuniform sampler2D texture;\nuniform float opacity;\n\nvarying vec4 f_color;\nvarying vec2 f_uv;\n\nvoid main() {\n  vec2 pointR = gl_PointCoord.xy - vec2(0.5, 0.5);\n  if(dot(pointR, pointR) > 0.25) {\n    discard;\n  }\n  gl_FragColor = f_color * texture2D(texture, f_uv) * opacity;\n}"]);
+                  var pickVertSrc = glslify(["precision highp float;\n#define GLSLIFY 1\n\nattribute vec3 position;\nattribute vec4 id;\n\nuniform mat4 model, view, projection;\n\nvarying vec3 f_position;\nvarying vec4 f_id;\n\nvoid main() {\n  gl_Position = projection * (view * (model * vec4(position, 1.0)));\n  f_id        = id;\n  f_position  = position;\n}"]);
+                  var pickFragSrc = glslify(["precision highp float;\n#define GLSLIFY 1\n\nbool outOfRange(float a, float b, float p) {\n  return ((p > max(a, b)) || \n          (p < min(a, b)));\n}\n\nbool outOfRange(vec2 a, vec2 b, vec2 p) {\n  return (outOfRange(a.x, b.x, p.x) ||\n          outOfRange(a.y, b.y, p.y));\n}\n\nbool outOfRange(vec3 a, vec3 b, vec3 p) {\n  return (outOfRange(a.x, b.x, p.x) ||\n          outOfRange(a.y, b.y, p.y) ||\n          outOfRange(a.z, b.z, p.z));\n}\n\nbool outOfRange(vec4 a, vec4 b, vec4 p) {\n  return outOfRange(a.xyz, b.xyz, p.xyz);\n}\n\nuniform vec3  clipBounds[2];\nuniform float pickId;\n\nvarying vec3 f_position;\nvarying vec4 f_id;\n\nvoid main() {\n  if (outOfRange(clipBounds[0], clipBounds[1], f_position)) discard;\n\n  gl_FragColor = vec4(pickId, f_id.xyz);\n}"]);
+                  var pickPointVertSrc = glslify(["precision highp float;\n#define GLSLIFY 1\n\nbool outOfRange(float a, float b, float p) {\n  return ((p > max(a, b)) || \n          (p < min(a, b)));\n}\n\nbool outOfRange(vec2 a, vec2 b, vec2 p) {\n  return (outOfRange(a.x, b.x, p.x) ||\n          outOfRange(a.y, b.y, p.y));\n}\n\nbool outOfRange(vec3 a, vec3 b, vec3 p) {\n  return (outOfRange(a.x, b.x, p.x) ||\n          outOfRange(a.y, b.y, p.y) ||\n          outOfRange(a.z, b.z, p.z));\n}\n\nbool outOfRange(vec4 a, vec4 b, vec4 p) {\n  return outOfRange(a.xyz, b.xyz, p.xyz);\n}\n\nattribute vec3  position;\nattribute float pointSize;\nattribute vec4  id;\n\nuniform mat4 model, view, projection;\nuniform vec3 clipBounds[2];\n\nvarying vec3 f_position;\nvarying vec4 f_id;\n\nvoid main() {\n  if (outOfRange(clipBounds[0], clipBounds[1], position)) {\n\n    gl_Position = vec4(0.0, 0.0, 0.0, 0.0);\n  } else {\n    gl_Position  = projection * (view * (model * vec4(position, 1.0)));\n    gl_PointSize = pointSize;\n  }\n  f_id         = id;\n  f_position   = position;\n}"]);
+                  var contourVertSrc = glslify(["precision highp float;\n#define GLSLIFY 1\n\nattribute vec3 position;\n\nuniform mat4 model, view, projection;\n\nvoid main() {\n  gl_Position = projection * (view * (model * vec4(position, 1.0)));\n}"]);
+                  var contourFragSrc = glslify(["precision highp float;\n#define GLSLIFY 1\n\nuniform vec3 contourColor;\n\nvoid main() {\n  gl_FragColor = vec4(contourColor, 1.0);\n}\n"]);
+                  exports2.meshShader = {
+                    vertex: triVertSrc,
+                    fragment: triFragSrc,
+                    attributes: [
+                      { name: "position", type: "vec3" },
+                      { name: "normal", type: "vec3" },
+                      { name: "color", type: "vec4" },
+                      { name: "uv", type: "vec2" }
+                    ]
+                  };
+                  exports2.wireShader = {
+                    vertex: edgeVertSrc,
+                    fragment: edgeFragSrc,
+                    attributes: [
+                      { name: "position", type: "vec3" },
+                      { name: "color", type: "vec4" },
+                      { name: "uv", type: "vec2" }
+                    ]
+                  };
+                  exports2.pointShader = {
+                    vertex: pointVertSrc,
+                    fragment: pointFragSrc,
+                    attributes: [
+                      { name: "position", type: "vec3" },
+                      { name: "color", type: "vec4" },
+                      { name: "uv", type: "vec2" },
+                      { name: "pointSize", type: "float" }
+                    ]
+                  };
+                  exports2.pickShader = {
+                    vertex: pickVertSrc,
+                    fragment: pickFragSrc,
+                    attributes: [
+                      { name: "position", type: "vec3" },
+                      { name: "id", type: "vec4" }
+                    ]
+                  };
+                  exports2.pointPickShader = {
+                    vertex: pickPointVertSrc,
+                    fragment: pickFragSrc,
+                    attributes: [
+                      { name: "position", type: "vec3" },
+                      { name: "pointSize", type: "float" },
+                      { name: "id", type: "vec4" }
+                    ]
+                  };
+                  exports2.contourShader = {
+                    vertex: contourVertSrc,
+                    fragment: contourFragSrc,
+                    attributes: [
+                      { name: "position", type: "vec3" }
+                    ]
+                  };
+                }
+              ),
+              /***/
+              855: (
+                /***/
+                function(module22, __unused_webpack_exports, __webpack_require__2) {
+                  module22.exports = {
+                    init: sqInit,
+                    sweepBipartite,
+                    sweepComplete,
+                    scanBipartite,
+                    scanComplete
+                  };
+                  var pool = __webpack_require__2(1888);
+                  var bits = __webpack_require__2(8828);
+                  var isort = __webpack_require__2(4192);
+                  var BLUE_FLAG = 1 << 28;
+                  var INIT_CAPACITY = 1024;
+                  var RED_SWEEP_QUEUE = pool.mallocInt32(INIT_CAPACITY);
+                  var RED_SWEEP_INDEX = pool.mallocInt32(INIT_CAPACITY);
+                  var BLUE_SWEEP_QUEUE = pool.mallocInt32(INIT_CAPACITY);
+                  var BLUE_SWEEP_INDEX = pool.mallocInt32(INIT_CAPACITY);
+                  var COMMON_SWEEP_QUEUE = pool.mallocInt32(INIT_CAPACITY);
+                  var COMMON_SWEEP_INDEX = pool.mallocInt32(INIT_CAPACITY);
+                  var SWEEP_EVENTS = pool.mallocDouble(INIT_CAPACITY * 8);
+                  function sqInit(count2) {
+                    var rcount = bits.nextPow2(count2);
+                    if (RED_SWEEP_QUEUE.length < rcount) {
+                      pool.free(RED_SWEEP_QUEUE);
+                      RED_SWEEP_QUEUE = pool.mallocInt32(rcount);
+                    }
+                    if (RED_SWEEP_INDEX.length < rcount) {
+                      pool.free(RED_SWEEP_INDEX);
+                      RED_SWEEP_INDEX = pool.mallocInt32(rcount);
+                    }
+                    if (BLUE_SWEEP_QUEUE.length < rcount) {
+                      pool.free(BLUE_SWEEP_QUEUE);
+                      BLUE_SWEEP_QUEUE = pool.mallocInt32(rcount);
+                    }
+                    if (BLUE_SWEEP_INDEX.length < rcount) {
+                      pool.free(BLUE_SWEEP_INDEX);
+                      BLUE_SWEEP_INDEX = pool.mallocInt32(rcount);
+                    }
+                    if (COMMON_SWEEP_QUEUE.length < rcount) {
+                      pool.free(COMMON_SWEEP_QUEUE);
+                      COMMON_SWEEP_QUEUE = pool.mallocInt32(rcount);
+                    }
+                    if (COMMON_SWEEP_INDEX.length < rcount) {
+                      pool.free(COMMON_SWEEP_INDEX);
+                      COMMON_SWEEP_INDEX = pool.mallocInt32(rcount);
+                    }
+                    var eventLength = 8 * rcount;
+                    if (SWEEP_EVENTS.length < eventLength) {
+                      pool.free(SWEEP_EVENTS);
+                      SWEEP_EVENTS = pool.mallocDouble(eventLength);
+                    }
+                  }
+                  function sqPop(queue, index, count2, item) {
+                    var idx = index[item];
+                    var top = queue[count2 - 1];
+                    queue[idx] = top;
+                    index[top] = idx;
+                  }
+                  function sqPush(queue, index, count2, item) {
+                    queue[count2] = item;
+                    index[item] = count2;
+                  }
+                  function sweepBipartite(d2, visit, redStart, redEnd, red, redIndex, blueStart, blueEnd, blue, blueIndex) {
+                    var ptr = 0;
+                    var elemSize = 2 * d2;
+                    var istart = d2 - 1;
+                    var iend = elemSize - 1;
+                    for (var i2 = redStart; i2 < redEnd; ++i2) {
+                      var idx = redIndex[i2];
+                      var redOffset = elemSize * i2;
+                      SWEEP_EVENTS[ptr++] = red[redOffset + istart];
+                      SWEEP_EVENTS[ptr++] = -(idx + 1);
+                      SWEEP_EVENTS[ptr++] = red[redOffset + iend];
+                      SWEEP_EVENTS[ptr++] = idx;
+                    }
+                    for (var i2 = blueStart; i2 < blueEnd; ++i2) {
+                      var idx = blueIndex[i2] + BLUE_FLAG;
+                      var blueOffset = elemSize * i2;
+                      SWEEP_EVENTS[ptr++] = blue[blueOffset + istart];
+                      SWEEP_EVENTS[ptr++] = -idx;
+                      SWEEP_EVENTS[ptr++] = blue[blueOffset + iend];
+                      SWEEP_EVENTS[ptr++] = idx;
+                    }
+                    var n2 = ptr >>> 1;
+                    isort(SWEEP_EVENTS, n2);
+                    var redActive = 0;
+                    var blueActive = 0;
+                    for (var i2 = 0; i2 < n2; ++i2) {
+                      var e2 = SWEEP_EVENTS[2 * i2 + 1] | 0;
+                      if (e2 >= BLUE_FLAG) {
+                        e2 = e2 - BLUE_FLAG | 0;
+                        sqPop(BLUE_SWEEP_QUEUE, BLUE_SWEEP_INDEX, blueActive--, e2);
+                      } else if (e2 >= 0) {
+                        sqPop(RED_SWEEP_QUEUE, RED_SWEEP_INDEX, redActive--, e2);
+                      } else if (e2 <= -268435456) {
+                        e2 = -e2 - BLUE_FLAG | 0;
+                        for (var j2 = 0; j2 < redActive; ++j2) {
+                          var retval = visit(RED_SWEEP_QUEUE[j2], e2);
+                          if (retval !== void 0) {
+                            return retval;
+                          }
+                        }
+                        sqPush(BLUE_SWEEP_QUEUE, BLUE_SWEEP_INDEX, blueActive++, e2);
+                      } else {
+                        e2 = -e2 - 1 | 0;
+                        for (var j2 = 0; j2 < blueActive; ++j2) {
+                          var retval = visit(e2, BLUE_SWEEP_QUEUE[j2]);
+                          if (retval !== void 0) {
+                            return retval;
+                          }
+                        }
+                        sqPush(RED_SWEEP_QUEUE, RED_SWEEP_INDEX, redActive++, e2);
+                      }
+                    }
+                  }
+                  function sweepComplete(d2, visit, redStart, redEnd, red, redIndex, blueStart, blueEnd, blue, blueIndex) {
+                    var ptr = 0;
+                    var elemSize = 2 * d2;
+                    var istart = d2 - 1;
+                    var iend = elemSize - 1;
+                    for (var i2 = redStart; i2 < redEnd; ++i2) {
+                      var idx = redIndex[i2] + 1 << 1;
+                      var redOffset = elemSize * i2;
+                      SWEEP_EVENTS[ptr++] = red[redOffset + istart];
+                      SWEEP_EVENTS[ptr++] = -idx;
+                      SWEEP_EVENTS[ptr++] = red[redOffset + iend];
+                      SWEEP_EVENTS[ptr++] = idx;
+                    }
+                    for (var i2 = blueStart; i2 < blueEnd; ++i2) {
+                      var idx = blueIndex[i2] + 1 << 1;
+                      var blueOffset = elemSize * i2;
+                      SWEEP_EVENTS[ptr++] = blue[blueOffset + istart];
+                      SWEEP_EVENTS[ptr++] = -idx | 1;
+                      SWEEP_EVENTS[ptr++] = blue[blueOffset + iend];
+                      SWEEP_EVENTS[ptr++] = idx | 1;
+                    }
+                    var n2 = ptr >>> 1;
+                    isort(SWEEP_EVENTS, n2);
+                    var redActive = 0;
+                    var blueActive = 0;
+                    var commonActive = 0;
+                    for (var i2 = 0; i2 < n2; ++i2) {
+                      var e2 = SWEEP_EVENTS[2 * i2 + 1] | 0;
+                      var color22 = e2 & 1;
+                      if (i2 < n2 - 1 && e2 >> 1 === SWEEP_EVENTS[2 * i2 + 3] >> 1) {
+                        color22 = 2;
+                        i2 += 1;
+                      }
+                      if (e2 < 0) {
+                        var id2 = -(e2 >> 1) - 1;
+                        for (var j2 = 0; j2 < commonActive; ++j2) {
+                          var retval = visit(COMMON_SWEEP_QUEUE[j2], id2);
+                          if (retval !== void 0) {
+                            return retval;
+                          }
+                        }
+                        if (color22 !== 0) {
+                          for (var j2 = 0; j2 < redActive; ++j2) {
+                            var retval = visit(RED_SWEEP_QUEUE[j2], id2);
+                            if (retval !== void 0) {
+                              return retval;
+                            }
+                          }
+                        }
+                        if (color22 !== 1) {
+                          for (var j2 = 0; j2 < blueActive; ++j2) {
+                            var retval = visit(BLUE_SWEEP_QUEUE[j2], id2);
+                            if (retval !== void 0) {
+                              return retval;
+                            }
+                          }
+                        }
+                        if (color22 === 0) {
+                          sqPush(RED_SWEEP_QUEUE, RED_SWEEP_INDEX, redActive++, id2);
+                        } else if (color22 === 1) {
+                          sqPush(BLUE_SWEEP_QUEUE, BLUE_SWEEP_INDEX, blueActive++, id2);
+                        } else if (color22 === 2) {
+                          sqPush(COMMON_SWEEP_QUEUE, COMMON_SWEEP_INDEX, commonActive++, id2);
+                        }
+                      } else {
+                        var id2 = (e2 >> 1) - 1;
+                        if (color22 === 0) {
+                          sqPop(RED_SWEEP_QUEUE, RED_SWEEP_INDEX, redActive--, id2);
+                        } else if (color22 === 1) {
+                          sqPop(BLUE_SWEEP_QUEUE, BLUE_SWEEP_INDEX, blueActive--, id2);
+                        } else if (color22 === 2) {
+                          sqPop(COMMON_SWEEP_QUEUE, COMMON_SWEEP_INDEX, commonActive--, id2);
+                        }
+                      }
+                    }
+                  }
+                  function scanBipartite(d2, axis, visit, flip, redStart, redEnd, red, redIndex, blueStart, blueEnd, blue, blueIndex) {
+                    var ptr = 0;
+                    var elemSize = 2 * d2;
+                    var istart = axis;
+                    var iend = axis + d2;
+                    var redShift = 1;
+                    var blueShift = 1;
+                    if (flip) {
+                      blueShift = BLUE_FLAG;
+                    } else {
+                      redShift = BLUE_FLAG;
+                    }
+                    for (var i2 = redStart; i2 < redEnd; ++i2) {
+                      var idx = i2 + redShift;
+                      var redOffset = elemSize * i2;
+                      SWEEP_EVENTS[ptr++] = red[redOffset + istart];
+                      SWEEP_EVENTS[ptr++] = -idx;
+                      SWEEP_EVENTS[ptr++] = red[redOffset + iend];
+                      SWEEP_EVENTS[ptr++] = idx;
+                    }
+                    for (var i2 = blueStart; i2 < blueEnd; ++i2) {
+                      var idx = i2 + blueShift;
+                      var blueOffset = elemSize * i2;
+                      SWEEP_EVENTS[ptr++] = blue[blueOffset + istart];
+                      SWEEP_EVENTS[ptr++] = -idx;
+                    }
+                    var n2 = ptr >>> 1;
+                    isort(SWEEP_EVENTS, n2);
+                    var redActive = 0;
+                    for (var i2 = 0; i2 < n2; ++i2) {
+                      var e2 = SWEEP_EVENTS[2 * i2 + 1] | 0;
+                      if (e2 < 0) {
+                        var idx = -e2;
+                        var isRed = false;
+                        if (idx >= BLUE_FLAG) {
+                          isRed = !flip;
+                          idx -= BLUE_FLAG;
+                        } else {
+                          isRed = !!flip;
+                          idx -= 1;
+                        }
+                        if (isRed) {
+                          sqPush(RED_SWEEP_QUEUE, RED_SWEEP_INDEX, redActive++, idx);
+                        } else {
+                          var blueId = blueIndex[idx];
+                          var bluePtr = elemSize * idx;
+                          var b0 = blue[bluePtr + axis + 1];
+                          var b1 = blue[bluePtr + axis + 1 + d2];
+                          red_loop:
+                            for (var j2 = 0; j2 < redActive; ++j2) {
+                              var oidx = RED_SWEEP_QUEUE[j2];
+                              var redPtr = elemSize * oidx;
+                              if (b1 < red[redPtr + axis + 1] || red[redPtr + axis + 1 + d2] < b0) {
+                                continue;
+                              }
+                              for (var k2 = axis + 2; k2 < d2; ++k2) {
+                                if (blue[bluePtr + k2 + d2] < red[redPtr + k2] || red[redPtr + k2 + d2] < blue[bluePtr + k2]) {
+                                  continue red_loop;
+                                }
+                              }
+                              var redId = redIndex[oidx];
+                              var retval;
+                              if (flip) {
+                                retval = visit(blueId, redId);
+                              } else {
+                                retval = visit(redId, blueId);
+                              }
+                              if (retval !== void 0) {
+                                return retval;
+                              }
+                            }
+                        }
+                      } else {
+                        sqPop(RED_SWEEP_QUEUE, RED_SWEEP_INDEX, redActive--, e2 - redShift);
+                      }
+                    }
+                  }
+                  function scanComplete(d2, axis, visit, redStart, redEnd, red, redIndex, blueStart, blueEnd, blue, blueIndex) {
+                    var ptr = 0;
+                    var elemSize = 2 * d2;
+                    var istart = axis;
+                    var iend = axis + d2;
+                    for (var i2 = redStart; i2 < redEnd; ++i2) {
+                      var idx = i2 + BLUE_FLAG;
+                      var redOffset = elemSize * i2;
+                      SWEEP_EVENTS[ptr++] = red[redOffset + istart];
+                      SWEEP_EVENTS[ptr++] = -idx;
+                      SWEEP_EVENTS[ptr++] = red[redOffset + iend];
+                      SWEEP_EVENTS[ptr++] = idx;
+                    }
+                    for (var i2 = blueStart; i2 < blueEnd; ++i2) {
+                      var idx = i2 + 1;
+                      var blueOffset = elemSize * i2;
+                      SWEEP_EVENTS[ptr++] = blue[blueOffset + istart];
+                      SWEEP_EVENTS[ptr++] = -idx;
+                    }
+                    var n2 = ptr >>> 1;
+                    isort(SWEEP_EVENTS, n2);
+                    var redActive = 0;
+                    for (var i2 = 0; i2 < n2; ++i2) {
+                      var e2 = SWEEP_EVENTS[2 * i2 + 1] | 0;
+                      if (e2 < 0) {
+                        var idx = -e2;
+                        if (idx >= BLUE_FLAG) {
+                          RED_SWEEP_QUEUE[redActive++] = idx - BLUE_FLAG;
+                        } else {
+                          idx -= 1;
+                          var blueId = blueIndex[idx];
+                          var bluePtr = elemSize * idx;
+                          var b0 = blue[bluePtr + axis + 1];
+                          var b1 = blue[bluePtr + axis + 1 + d2];
+                          red_loop:
+                            for (var j2 = 0; j2 < redActive; ++j2) {
+                              var oidx = RED_SWEEP_QUEUE[j2];
+                              var redId = redIndex[oidx];
+                              if (redId === blueId) {
+                                break;
+                              }
+                              var redPtr = elemSize * oidx;
+                              if (b1 < red[redPtr + axis + 1] || red[redPtr + axis + 1 + d2] < b0) {
+                                continue;
+                              }
+                              for (var k2 = axis + 2; k2 < d2; ++k2) {
+                                if (blue[bluePtr + k2 + d2] < red[redPtr + k2] || red[redPtr + k2 + d2] < blue[bluePtr + k2]) {
+                                  continue red_loop;
+                                }
+                              }
+                              var retval = visit(redId, blueId);
+                              if (retval !== void 0) {
+                                return retval;
+                              }
+                            }
+                        }
+                      } else {
+                        var idx = e2 - BLUE_FLAG;
+                        for (var j2 = redActive - 1; j2 >= 0; --j2) {
+                          if (RED_SWEEP_QUEUE[j2] === idx) {
+                            for (var k2 = j2 + 1; k2 < redActive; ++k2) {
+                              RED_SWEEP_QUEUE[k2 - 1] = RED_SWEEP_QUEUE[k2];
+                            }
+                            break;
+                          }
+                        }
+                        --redActive;
+                      }
+                    }
+                  }
+                }
+              ),
+              /***/
+              868: (
+                /***/
+                function(module22, __unused_webpack_exports, __webpack_require__2) {
+                  module22.exports = __webpack_require__2(1387);
+                }
+              ),
+              /***/
+              869: (
+                /***/
+                function(module22, __unused_webpack_exports, __webpack_require__2) {
+                  var num2bn = __webpack_require__2(2651);
+                  var sign = __webpack_require__2(5716);
+                  module22.exports = rationalize;
+                  function rationalize(numer, denom) {
+                    var snumer = sign(numer);
+                    var sdenom = sign(denom);
+                    if (snumer === 0) {
+                      return [num2bn(0), num2bn(1)];
+                    }
+                    if (sdenom === 0) {
+                      return [num2bn(0), num2bn(0)];
+                    }
+                    if (sdenom < 0) {
+                      numer = numer.neg();
+                      denom = denom.neg();
+                    }
+                    var d2 = numer.gcd(denom);
+                    if (d2.cmpn(1)) {
+                      return [numer.div(d2), denom.div(d2)];
+                    }
+                    return [numer, denom];
+                  }
+                }
+              ),
+              /***/
+              870: (
+                /***/
+                function(module22, __unused_webpack_exports, __webpack_require__2) {
+                  var bindAttribs = __webpack_require__2(1433);
+                  function VAOEmulated(gl2) {
+                    this.gl = gl2;
+                    this._elements = null;
+                    this._attributes = null;
+                    this._elementsType = gl2.UNSIGNED_SHORT;
+                  }
+                  VAOEmulated.prototype.bind = function() {
+                    bindAttribs(this.gl, this._elements, this._attributes);
+                  };
+                  VAOEmulated.prototype.update = function(attributes, elements, elementsType) {
+                    this._elements = elements;
+                    this._attributes = attributes;
+                    this._elementsType = elementsType || this.gl.UNSIGNED_SHORT;
+                  };
+                  VAOEmulated.prototype.dispose = function() {
+                  };
+                  VAOEmulated.prototype.unbind = function() {
+                  };
+                  VAOEmulated.prototype.draw = function(mode, count2, offset) {
+                    offset = offset || 0;
+                    var gl2 = this.gl;
+                    if (this._elements) {
+                      gl2.drawElements(mode, count2, this._elementsType, offset);
+                    } else {
+                      gl2.drawArrays(mode, offset, count2);
+                    }
+                  };
+                  function createVAOEmulated(gl2) {
+                    return new VAOEmulated(gl2);
+                  }
+                  module22.exports = createVAOEmulated;
+                }
+              ),
+              /***/
+              946: (
+                /***/
+                function(module22, __unused_webpack_exports, __webpack_require__2) {
+                  var bn2num = __webpack_require__2(1369);
+                  var ctz = __webpack_require__2(4025);
+                  module22.exports = roundRat;
+                  function roundRat(f2) {
+                    var a2 = f2[0];
+                    var b2 = f2[1];
+                    if (a2.cmpn(0) === 0) {
+                      return 0;
+                    }
+                    var h2 = a2.abs().divmod(b2.abs());
+                    var iv = h2.div;
+                    var x2 = bn2num(iv);
+                    var ir = h2.mod;
+                    var sgn = a2.negative !== b2.negative ? -1 : 1;
+                    if (ir.cmpn(0) === 0) {
+                      return sgn * x2;
+                    }
+                    if (x2) {
+                      var s2 = ctz(x2) + 4;
+                      var y2 = bn2num(ir.ushln(s2).divRound(b2));
+                      return sgn * (x2 + y2 * Math.pow(2, -s2));
+                    } else {
+                      var ybits = b2.bitLength() - ir.bitLength() + 53;
+                      var y2 = bn2num(ir.ushln(ybits).divRound(b2));
+                      if (ybits < 1023) {
+                        return sgn * y2 * Math.pow(2, -ybits);
+                      }
+                      y2 *= Math.pow(2, -1023);
+                      return sgn * y2 * Math.pow(2, 1023 - ybits);
+                    }
+                  }
+                }
+              ),
+              /***/
+              990: (
+                /***/
+                function(__unused_webpack_module, exports2, __webpack_require__2) {
+                  var createShader = __webpack_require__2(9405);
+                  var glslify = __webpack_require__2(3236);
+                  var vertSrc = glslify(["precision highp float;\n#define GLSLIFY 1\n\nattribute vec4 uv;\nattribute vec3 f;\nattribute vec3 normal;\n\nuniform vec3 objectOffset;\nuniform mat4 model, view, projection, inverseModel;\nuniform vec3 lightPosition, eyePosition;\nuniform sampler2D colormap;\n\nvarying float value, kill;\nvarying vec3 worldCoordinate;\nvarying vec2 planeCoordinate;\nvarying vec3 lightDirection, eyeDirection, surfaceNormal;\nvarying vec4 vColor;\n\nvoid main() {\n  vec3 localCoordinate = vec3(uv.zw, f.x);\n  worldCoordinate = objectOffset + localCoordinate;\n  mat4 objectOffsetTranslation = mat4(1.0) + mat4(vec4(0), vec4(0), vec4(0), vec4(objectOffset, 0));\n  vec4 worldPosition = (model * objectOffsetTranslation) * vec4(localCoordinate, 1.0);\n  vec4 clipPosition = projection * (view * worldPosition);\n  gl_Position = clipPosition;\n  kill = f.y;\n  value = f.z;\n  planeCoordinate = uv.xy;\n\n  vColor = texture2D(colormap, vec2(value, value));\n\n  //Lighting geometry parameters\n  vec4 cameraCoordinate = view * worldPosition;\n  cameraCoordinate.xyz /= cameraCoordinate.w;\n  lightDirection = lightPosition - cameraCoordinate.xyz;\n  eyeDirection   = eyePosition - cameraCoordinate.xyz;\n  surfaceNormal  = normalize((vec4(normal,0) * inverseModel).xyz);\n}\n"]);
+                  var fragSrc = glslify(["precision highp float;\n#define GLSLIFY 1\n\nfloat beckmannDistribution(float x, float roughness) {\n  float NdotH = max(x, 0.0001);\n  float cos2Alpha = NdotH * NdotH;\n  float tan2Alpha = (cos2Alpha - 1.0) / cos2Alpha;\n  float roughness2 = roughness * roughness;\n  float denom = 3.141592653589793 * roughness2 * cos2Alpha * cos2Alpha;\n  return exp(tan2Alpha / roughness2) / denom;\n}\n\nfloat beckmannSpecular(\n  vec3 lightDirection,\n  vec3 viewDirection,\n  vec3 surfaceNormal,\n  float roughness) {\n  return beckmannDistribution(dot(surfaceNormal, normalize(lightDirection + viewDirection)), roughness);\n}\n\nbool outOfRange(float a, float b, float p) {\n  return ((p > max(a, b)) || \n          (p < min(a, b)));\n}\n\nbool outOfRange(vec2 a, vec2 b, vec2 p) {\n  return (outOfRange(a.x, b.x, p.x) ||\n          outOfRange(a.y, b.y, p.y));\n}\n\nbool outOfRange(vec3 a, vec3 b, vec3 p) {\n  return (outOfRange(a.x, b.x, p.x) ||\n          outOfRange(a.y, b.y, p.y) ||\n          outOfRange(a.z, b.z, p.z));\n}\n\nbool outOfRange(vec4 a, vec4 b, vec4 p) {\n  return outOfRange(a.xyz, b.xyz, p.xyz);\n}\n\nuniform vec3 lowerBound, upperBound;\nuniform float contourTint;\nuniform vec4 contourColor;\nuniform sampler2D colormap;\nuniform vec3 clipBounds[2];\nuniform float roughness, fresnel, kambient, kdiffuse, kspecular, opacity;\nuniform float vertexColor;\n\nvarying float value, kill;\nvarying vec3 worldCoordinate;\nvarying vec3 lightDirection, eyeDirection, surfaceNormal;\nvarying vec4 vColor;\n\nvoid main() {\n  if (\n    kill > 0.0 ||\n    vColor.a == 0.0 ||\n    outOfRange(clipBounds[0], clipBounds[1], worldCoordinate)\n  ) discard;\n\n  vec3 N = normalize(surfaceNormal);\n  vec3 V = normalize(eyeDirection);\n  vec3 L = normalize(lightDirection);\n\n  if(gl_FrontFacing) {\n    N = -N;\n  }\n\n  float specular = max(beckmannSpecular(L, V, N, roughness), 0.);\n  float diffuse  = min(kambient + kdiffuse * max(dot(N, L), 0.0), 1.0);\n\n  //decide how to interpolate color — in vertex or in fragment\n  vec4 surfaceColor =\n    step(vertexColor, .5) * texture2D(colormap, vec2(value, value)) +\n    step(.5, vertexColor) * vColor;\n\n  vec4 litColor = surfaceColor.a * vec4(diffuse * surfaceColor.rgb + kspecular * vec3(1,1,1) * specular,  1.0);\n\n  gl_FragColor = mix(litColor, contourColor, contourTint) * opacity;\n}\n"]);
+                  var contourVertSrc = glslify(["precision highp float;\n#define GLSLIFY 1\n\nattribute vec4 uv;\nattribute float f;\n\nuniform vec3 objectOffset;\nuniform mat3 permutation;\nuniform mat4 model, view, projection;\nuniform float height, zOffset;\nuniform sampler2D colormap;\n\nvarying float value, kill;\nvarying vec3 worldCoordinate;\nvarying vec2 planeCoordinate;\nvarying vec3 lightDirection, eyeDirection, surfaceNormal;\nvarying vec4 vColor;\n\nvoid main() {\n  vec3 dataCoordinate = permutation * vec3(uv.xy, height);\n  worldCoordinate = objectOffset + dataCoordinate;\n  mat4 objectOffsetTranslation = mat4(1.0) + mat4(vec4(0), vec4(0), vec4(0), vec4(objectOffset, 0));\n  vec4 worldPosition = (model * objectOffsetTranslation) * vec4(dataCoordinate, 1.0);\n\n  vec4 clipPosition = projection * (view * worldPosition);\n  clipPosition.z += zOffset;\n\n  gl_Position = clipPosition;\n  value = f + objectOffset.z;\n  kill = -1.0;\n  planeCoordinate = uv.zw;\n\n  vColor = texture2D(colormap, vec2(value, value));\n\n  //Don't do lighting for contours\n  surfaceNormal   = vec3(1,0,0);\n  eyeDirection    = vec3(0,1,0);\n  lightDirection  = vec3(0,0,1);\n}\n"]);
+                  var pickSrc = glslify(["precision highp float;\n#define GLSLIFY 1\n\nbool outOfRange(float a, float b, float p) {\n  return ((p > max(a, b)) || \n          (p < min(a, b)));\n}\n\nbool outOfRange(vec2 a, vec2 b, vec2 p) {\n  return (outOfRange(a.x, b.x, p.x) ||\n          outOfRange(a.y, b.y, p.y));\n}\n\nbool outOfRange(vec3 a, vec3 b, vec3 p) {\n  return (outOfRange(a.x, b.x, p.x) ||\n          outOfRange(a.y, b.y, p.y) ||\n          outOfRange(a.z, b.z, p.z));\n}\n\nbool outOfRange(vec4 a, vec4 b, vec4 p) {\n  return outOfRange(a.xyz, b.xyz, p.xyz);\n}\n\nuniform vec2 shape;\nuniform vec3 clipBounds[2];\nuniform float pickId;\n\nvarying float value, kill;\nvarying vec3 worldCoordinate;\nvarying vec2 planeCoordinate;\nvarying vec3 surfaceNormal;\n\nvec2 splitFloat(float v) {\n  float vh = 255.0 * v;\n  float upper = floor(vh);\n  float lower = fract(vh);\n  return vec2(upper / 255.0, floor(lower * 16.0) / 16.0);\n}\n\nvoid main() {\n  if ((kill > 0.0) ||\n      (outOfRange(clipBounds[0], clipBounds[1], worldCoordinate))) discard;\n\n  vec2 ux = splitFloat(planeCoordinate.x / shape.x);\n  vec2 uy = splitFloat(planeCoordinate.y / shape.y);\n  gl_FragColor = vec4(pickId, ux.x, uy.x, ux.y + (uy.y/16.0));\n}\n"]);
+                  exports2.createShader = function(gl2) {
+                    var shader = createShader(gl2, vertSrc, fragSrc, null, [
+                      { name: "uv", type: "vec4" },
+                      { name: "f", type: "vec3" },
+                      { name: "normal", type: "vec3" }
+                    ]);
+                    shader.attributes.uv.location = 0;
+                    shader.attributes.f.location = 1;
+                    shader.attributes.normal.location = 2;
+                    return shader;
+                  };
+                  exports2.createPickShader = function(gl2) {
+                    var shader = createShader(gl2, vertSrc, pickSrc, null, [
+                      { name: "uv", type: "vec4" },
+                      { name: "f", type: "vec3" },
+                      { name: "normal", type: "vec3" }
+                    ]);
+                    shader.attributes.uv.location = 0;
+                    shader.attributes.f.location = 1;
+                    shader.attributes.normal.location = 2;
+                    return shader;
+                  };
+                  exports2.createContourShader = function(gl2) {
+                    var shader = createShader(gl2, contourVertSrc, fragSrc, null, [
+                      { name: "uv", type: "vec4" },
+                      { name: "f", type: "float" }
+                    ]);
+                    shader.attributes.uv.location = 0;
+                    shader.attributes.f.location = 1;
+                    return shader;
+                  };
+                  exports2.createPickContourShader = function(gl2) {
+                    var shader = createShader(gl2, contourVertSrc, pickSrc, null, [
+                      { name: "uv", type: "vec4" },
+                      { name: "f", type: "float" }
+                    ]);
+                    shader.attributes.uv.location = 0;
+                    shader.attributes.f.location = 1;
+                    return shader;
+                  };
+                }
+              ),
+              /***/
+              1085: (
+                /***/
+                function(module22, __unused_webpack_exports, __webpack_require__2) {
+                  var padLeft2 = __webpack_require__2(1371);
+                  module22.exports = addLineNumbers;
+                  function addLineNumbers(string, start, delim) {
+                    start = typeof start === "number" ? start : 1;
+                    delim = delim || ": ";
+                    var lines = string.split(/\r?\n/);
+                    var totalDigits = String(lines.length + start - 1).length;
+                    return lines.map(function(line, i2) {
+                      var c2 = i2 + start;
+                      var digits = String(c2).length;
+                      var prefix = padLeft2(c2, totalDigits - digits);
+                      return prefix + delim + line;
+                    }).join("\n");
+                  }
+                }
+              ),
+              /***/
+              1091: (
+                /***/
+                function(module22) {
+                  module22.exports = create2;
+                  function create2() {
+                    var out = new Float32Array(3);
+                    out[0] = 0;
+                    out[1] = 0;
+                    out[2] = 0;
+                    return out;
+                  }
+                }
+              ),
+              /***/
+              1125: (
+                /***/
+                function(module22, __unused_webpack_exports, __webpack_require__2) {
+                  module22.exports = segmentsIntersect;
+                  var orient = __webpack_require__2(3250)[3];
+                  function checkCollinear(a0, a1, b0, b1) {
+                    for (var d2 = 0; d2 < 2; ++d2) {
+                      var x0 = a0[d2];
+                      var y0 = a1[d2];
+                      var l0 = Math.min(x0, y0);
+                      var h0 = Math.max(x0, y0);
+                      var x1 = b0[d2];
+                      var y1 = b1[d2];
+                      var l1 = Math.min(x1, y1);
+                      var h1 = Math.max(x1, y1);
+                      if (h1 < l0 || h0 < l1) {
+                        return false;
+                      }
+                    }
+                    return true;
+                  }
+                  function segmentsIntersect(a0, a1, b0, b1) {
+                    var x0 = orient(a0, b0, b1);
+                    var y0 = orient(a1, b0, b1);
+                    if (x0 > 0 && y0 > 0 || x0 < 0 && y0 < 0) {
+                      return false;
+                    }
+                    var x1 = orient(b0, a0, a1);
+                    var y1 = orient(b1, a0, a1);
+                    if (x1 > 0 && y1 > 0 || x1 < 0 && y1 < 0) {
+                      return false;
+                    }
+                    if (x0 === 0 && y0 === 0 && x1 === 0 && y1 === 0) {
+                      return checkCollinear(a0, a1, b0, b1);
+                    }
+                    return true;
+                  }
+                }
+              ),
+              /***/
+              1278: (
+                /***/
+                function(module22, __unused_webpack_exports, __webpack_require__2) {
+                  var doubleBits = __webpack_require__2(2361);
+                  var SMALLEST_DENORM = Math.pow(2, -1074);
+                  var UINT_MAX = -1 >>> 0;
+                  module22.exports = nextafter;
+                  function nextafter(x2, y2) {
+                    if (isNaN(x2) || isNaN(y2)) {
+                      return NaN;
+                    }
+                    if (x2 === y2) {
+                      return x2;
+                    }
+                    if (x2 === 0) {
+                      if (y2 < 0) {
+                        return -SMALLEST_DENORM;
+                      } else {
+                        return SMALLEST_DENORM;
+                      }
+                    }
+                    var hi2 = doubleBits.hi(x2);
+                    var lo = doubleBits.lo(x2);
+                    if (y2 > x2 === x2 > 0) {
+                      if (lo === UINT_MAX) {
+                        hi2 += 1;
+                        lo = 0;
+                      } else {
+                        lo += 1;
+                      }
+                    } else {
+                      if (lo === 0) {
+                        lo = UINT_MAX;
+                        hi2 -= 1;
+                      } else {
+                        lo -= 1;
+                      }
+                    }
+                    return doubleBits.pack(lo, hi2);
+                  }
+                }
+              ),
+              /***/
+              1283: (
+                /***/
+                function(__unused_webpack_module, exports2, __webpack_require__2) {
+                  var createShaderWrapper = __webpack_require__2(9405);
+                  var glslify = __webpack_require__2(3236);
+                  var perspectiveVertSrc = glslify(["precision highp float;\n#define GLSLIFY 1\n\nbool outOfRange(float a, float b, float p) {\n  return ((p > max(a, b)) || \n          (p < min(a, b)));\n}\n\nbool outOfRange(vec2 a, vec2 b, vec2 p) {\n  return (outOfRange(a.x, b.x, p.x) ||\n          outOfRange(a.y, b.y, p.y));\n}\n\nbool outOfRange(vec3 a, vec3 b, vec3 p) {\n  return (outOfRange(a.x, b.x, p.x) ||\n          outOfRange(a.y, b.y, p.y) ||\n          outOfRange(a.z, b.z, p.z));\n}\n\nbool outOfRange(vec4 a, vec4 b, vec4 p) {\n  return outOfRange(a.xyz, b.xyz, p.xyz);\n}\n\nattribute vec3 position;\nattribute vec4 color;\nattribute vec2 glyph;\nattribute vec4 id;\n\nuniform vec4 highlightId;\nuniform float highlightScale;\nuniform mat4 model, view, projection;\nuniform vec3 clipBounds[2];\n\nvarying vec4 interpColor;\nvarying vec4 pickId;\nvarying vec3 dataCoordinate;\n\nvoid main() {\n  if (outOfRange(clipBounds[0], clipBounds[1], position)) {\n\n    gl_Position = vec4(0,0,0,0);\n  } else {\n    float scale = 1.0;\n    if(distance(highlightId, id) < 0.0001) {\n      scale = highlightScale;\n    }\n\n    vec4 worldPosition = model * vec4(position, 1);\n    vec4 viewPosition = view * worldPosition;\n    viewPosition = viewPosition / viewPosition.w;\n    vec4 clipPosition = projection * (viewPosition + scale * vec4(glyph.x, -glyph.y, 0, 0));\n\n    gl_Position = clipPosition;\n    interpColor = color;\n    pickId = id;\n    dataCoordinate = position;\n  }\n}"]);
+                  var orthographicVertSrc = glslify(["precision highp float;\n#define GLSLIFY 1\n\nbool outOfRange(float a, float b, float p) {\n  return ((p > max(a, b)) || \n          (p < min(a, b)));\n}\n\nbool outOfRange(vec2 a, vec2 b, vec2 p) {\n  return (outOfRange(a.x, b.x, p.x) ||\n          outOfRange(a.y, b.y, p.y));\n}\n\nbool outOfRange(vec3 a, vec3 b, vec3 p) {\n  return (outOfRange(a.x, b.x, p.x) ||\n          outOfRange(a.y, b.y, p.y) ||\n          outOfRange(a.z, b.z, p.z));\n}\n\nbool outOfRange(vec4 a, vec4 b, vec4 p) {\n  return outOfRange(a.xyz, b.xyz, p.xyz);\n}\n\nattribute vec3 position;\nattribute vec4 color;\nattribute vec2 glyph;\nattribute vec4 id;\n\nuniform mat4 model, view, projection;\nuniform vec2 screenSize;\nuniform vec3 clipBounds[2];\nuniform float highlightScale, pixelRatio;\nuniform vec4 highlightId;\n\nvarying vec4 interpColor;\nvarying vec4 pickId;\nvarying vec3 dataCoordinate;\n\nvoid main() {\n  if (outOfRange(clipBounds[0], clipBounds[1], position)) {\n\n    gl_Position = vec4(0,0,0,0);\n  } else {\n    float scale = pixelRatio;\n    if(distance(highlightId.bgr, id.bgr) < 0.001) {\n      scale *= highlightScale;\n    }\n\n    vec4 worldPosition = model * vec4(position, 1.0);\n    vec4 viewPosition = view * worldPosition;\n    vec4 clipPosition = projection * viewPosition;\n    clipPosition /= clipPosition.w;\n\n    gl_Position = clipPosition + vec4(screenSize * scale * vec2(glyph.x, -glyph.y), 0.0, 0.0);\n    interpColor = color;\n    pickId = id;\n    dataCoordinate = position;\n  }\n}"]);
+                  var projectionVertSrc = glslify(["precision highp float;\n#define GLSLIFY 1\n\nbool outOfRange(float a, float b, float p) {\n  return ((p > max(a, b)) || \n          (p < min(a, b)));\n}\n\nbool outOfRange(vec2 a, vec2 b, vec2 p) {\n  return (outOfRange(a.x, b.x, p.x) ||\n          outOfRange(a.y, b.y, p.y));\n}\n\nbool outOfRange(vec3 a, vec3 b, vec3 p) {\n  return (outOfRange(a.x, b.x, p.x) ||\n          outOfRange(a.y, b.y, p.y) ||\n          outOfRange(a.z, b.z, p.z));\n}\n\nbool outOfRange(vec4 a, vec4 b, vec4 p) {\n  return outOfRange(a.xyz, b.xyz, p.xyz);\n}\n\nattribute vec3 position;\nattribute vec4 color;\nattribute vec2 glyph;\nattribute vec4 id;\n\nuniform float highlightScale;\nuniform vec4 highlightId;\nuniform vec3 axes[2];\nuniform mat4 model, view, projection;\nuniform vec2 screenSize;\nuniform vec3 clipBounds[2];\nuniform float scale, pixelRatio;\n\nvarying vec4 interpColor;\nvarying vec4 pickId;\nvarying vec3 dataCoordinate;\n\nvoid main() {\n  if (outOfRange(clipBounds[0], clipBounds[1], position)) {\n\n    gl_Position = vec4(0,0,0,0);\n  } else {\n    float lscale = pixelRatio * scale;\n    if(distance(highlightId, id) < 0.0001) {\n      lscale *= highlightScale;\n    }\n\n    vec4 clipCenter   = projection * (view * (model * vec4(position, 1)));\n    vec3 dataPosition = position + 0.5*lscale*(axes[0] * glyph.x + axes[1] * glyph.y) * clipCenter.w * screenSize.y;\n    vec4 clipPosition = projection * (view * (model * vec4(dataPosition, 1)));\n\n    gl_Position = clipPosition;\n    interpColor = color;\n    pickId = id;\n    dataCoordinate = dataPosition;\n  }\n}\n"]);
+                  var drawFragSrc = glslify(["precision highp float;\n#define GLSLIFY 1\n\nbool outOfRange(float a, float b, float p) {\n  return ((p > max(a, b)) || \n          (p < min(a, b)));\n}\n\nbool outOfRange(vec2 a, vec2 b, vec2 p) {\n  return (outOfRange(a.x, b.x, p.x) ||\n          outOfRange(a.y, b.y, p.y));\n}\n\nbool outOfRange(vec3 a, vec3 b, vec3 p) {\n  return (outOfRange(a.x, b.x, p.x) ||\n          outOfRange(a.y, b.y, p.y) ||\n          outOfRange(a.z, b.z, p.z));\n}\n\nbool outOfRange(vec4 a, vec4 b, vec4 p) {\n  return outOfRange(a.xyz, b.xyz, p.xyz);\n}\n\nuniform vec3 fragClipBounds[2];\nuniform float opacity;\n\nvarying vec4 interpColor;\nvarying vec3 dataCoordinate;\n\nvoid main() {\n  if (\n    outOfRange(fragClipBounds[0], fragClipBounds[1], dataCoordinate) ||\n    interpColor.a * opacity == 0.\n  ) discard;\n  gl_FragColor = interpColor * opacity;\n}\n"]);
+                  var pickFragSrc = glslify(["precision highp float;\n#define GLSLIFY 1\n\nbool outOfRange(float a, float b, float p) {\n  return ((p > max(a, b)) || \n          (p < min(a, b)));\n}\n\nbool outOfRange(vec2 a, vec2 b, vec2 p) {\n  return (outOfRange(a.x, b.x, p.x) ||\n          outOfRange(a.y, b.y, p.y));\n}\n\nbool outOfRange(vec3 a, vec3 b, vec3 p) {\n  return (outOfRange(a.x, b.x, p.x) ||\n          outOfRange(a.y, b.y, p.y) ||\n          outOfRange(a.z, b.z, p.z));\n}\n\nbool outOfRange(vec4 a, vec4 b, vec4 p) {\n  return outOfRange(a.xyz, b.xyz, p.xyz);\n}\n\nuniform vec3 fragClipBounds[2];\nuniform float pickGroup;\n\nvarying vec4 pickId;\nvarying vec3 dataCoordinate;\n\nvoid main() {\n  if (outOfRange(fragClipBounds[0], fragClipBounds[1], dataCoordinate)) discard;\n\n  gl_FragColor = vec4(pickGroup, pickId.bgr);\n}"]);
+                  var ATTRIBUTES = [
+                    { name: "position", type: "vec3" },
+                    { name: "color", type: "vec4" },
+                    { name: "glyph", type: "vec2" },
+                    { name: "id", type: "vec4" }
+                  ];
+                  var perspective2 = {
+                    vertex: perspectiveVertSrc,
+                    fragment: drawFragSrc,
+                    attributes: ATTRIBUTES
+                  }, ortho2 = {
+                    vertex: orthographicVertSrc,
+                    fragment: drawFragSrc,
+                    attributes: ATTRIBUTES
+                  }, project2 = {
+                    vertex: projectionVertSrc,
+                    fragment: drawFragSrc,
+                    attributes: ATTRIBUTES
+                  }, pickPerspective = {
+                    vertex: perspectiveVertSrc,
+                    fragment: pickFragSrc,
+                    attributes: ATTRIBUTES
+                  }, pickOrtho = {
+                    vertex: orthographicVertSrc,
+                    fragment: pickFragSrc,
+                    attributes: ATTRIBUTES
+                  }, pickProject = {
+                    vertex: projectionVertSrc,
+                    fragment: pickFragSrc,
+                    attributes: ATTRIBUTES
+                  };
+                  function createShader(gl2, src) {
+                    var shader = createShaderWrapper(gl2, src);
+                    var attr = shader.attributes;
+                    attr.position.location = 0;
+                    attr.color.location = 1;
+                    attr.glyph.location = 2;
+                    attr.id.location = 3;
+                    return shader;
+                  }
+                  exports2.createPerspective = function(gl2) {
+                    return createShader(gl2, perspective2);
+                  };
+                  exports2.createOrtho = function(gl2) {
+                    return createShader(gl2, ortho2);
+                  };
+                  exports2.createProject = function(gl2) {
+                    return createShader(gl2, project2);
+                  };
+                  exports2.createPickPerspective = function(gl2) {
+                    return createShader(gl2, pickPerspective);
+                  };
+                  exports2.createPickOrtho = function(gl2) {
+                    return createShader(gl2, pickOrtho);
+                  };
+                  exports2.createPickProject = function(gl2) {
+                    return createShader(gl2, pickProject);
+                  };
+                }
+              ),
+              /***/
+              1303: (
+                /***/
+                function(module22, __unused_webpack_exports, __webpack_require__2) {
+                  module22.exports = orderSegments;
+                  var orient = __webpack_require__2(3250);
+                  function horizontalOrder(a2, b2) {
+                    var bl2, br;
+                    if (b2[0][0] < b2[1][0]) {
+                      bl2 = b2[0];
+                      br = b2[1];
+                    } else if (b2[0][0] > b2[1][0]) {
+                      bl2 = b2[1];
+                      br = b2[0];
+                    } else {
+                      var alo = Math.min(a2[0][1], a2[1][1]);
+                      var ahi = Math.max(a2[0][1], a2[1][1]);
+                      var blo = Math.min(b2[0][1], b2[1][1]);
+                      var bhi = Math.max(b2[0][1], b2[1][1]);
+                      if (ahi < blo) {
+                        return ahi - blo;
+                      }
+                      if (alo > bhi) {
+                        return alo - bhi;
+                      }
+                      return ahi - bhi;
+                    }
+                    var al2, ar;
+                    if (a2[0][1] < a2[1][1]) {
+                      al2 = a2[0];
+                      ar = a2[1];
+                    } else {
+                      al2 = a2[1];
+                      ar = a2[0];
+                    }
+                    var d2 = orient(br, bl2, al2);
+                    if (d2) {
+                      return d2;
+                    }
+                    d2 = orient(br, bl2, ar);
+                    if (d2) {
+                      return d2;
+                    }
+                    return ar - br;
+                  }
+                  function orderSegments(b2, a2) {
+                    var al2, ar;
+                    if (a2[0][0] < a2[1][0]) {
+                      al2 = a2[0];
+                      ar = a2[1];
+                    } else if (a2[0][0] > a2[1][0]) {
+                      al2 = a2[1];
+                      ar = a2[0];
+                    } else {
+                      return horizontalOrder(a2, b2);
+                    }
+                    var bl2, br;
+                    if (b2[0][0] < b2[1][0]) {
+                      bl2 = b2[0];
+                      br = b2[1];
+                    } else if (b2[0][0] > b2[1][0]) {
+                      bl2 = b2[1];
+                      br = b2[0];
+                    } else {
+                      return -horizontalOrder(b2, a2);
+                    }
+                    var d1 = orient(al2, ar, br);
+                    var d2 = orient(al2, ar, bl2);
+                    if (d1 < 0) {
+                      if (d2 <= 0) {
+                        return d1;
+                      }
+                    } else if (d1 > 0) {
+                      if (d2 >= 0) {
+                        return d1;
+                      }
+                    } else if (d2) {
+                      return d2;
+                    }
+                    d1 = orient(br, bl2, ar);
+                    d2 = orient(br, bl2, al2);
+                    if (d1 < 0) {
+                      if (d2 <= 0) {
+                        return d1;
+                      }
+                    } else if (d1 > 0) {
+                      if (d2 >= 0) {
+                        return d1;
+                      }
+                    } else if (d2) {
+                      return d2;
+                    }
+                    return ar[0] - br[0];
+                  }
+                }
+              ),
+              /***/
+              1318: (
+                /***/
+                function(module22) {
+                  module22.exports = cmp;
+                  function cmp(a2, b2) {
+                    return a2[0].mul(b2[1]).cmp(b2[0].mul(a2[1]));
+                  }
+                }
+              ),
+              /***/
+              1338: (
+                /***/
+                function(module22) {
+                  function dupe_array(count2, value, i2) {
+                    var c2 = count2[i2] | 0;
+                    if (c2 <= 0) {
+                      return [];
+                    }
+                    var result = new Array(c2), j2;
+                    if (i2 === count2.length - 1) {
+                      for (j2 = 0; j2 < c2; ++j2) {
+                        result[j2] = value;
+                      }
+                    } else {
+                      for (j2 = 0; j2 < c2; ++j2) {
+                        result[j2] = dupe_array(count2, value, i2 + 1);
+                      }
+                    }
+                    return result;
+                  }
+                  function dupe_number(count2, value) {
+                    var result, i2;
+                    result = new Array(count2);
+                    for (i2 = 0; i2 < count2; ++i2) {
+                      result[i2] = value;
+                    }
+                    return result;
+                  }
+                  function dupe(count2, value) {
+                    if (typeof value === "undefined") {
+                      value = 0;
+                    }
+                    switch (typeof count2) {
+                      case "number":
+                        if (count2 > 0) {
+                          return dupe_number(count2 | 0, value);
+                        }
+                        break;
+                      case "object":
+                        if (typeof count2.length === "number") {
+                          return dupe_array(count2, value, 0);
+                        }
+                        break;
+                    }
+                    return [];
+                  }
+                  module22.exports = dupe;
+                }
+              ),
+              /***/
+              1369: (
+                /***/
+                function(module22, __unused_webpack_exports, __webpack_require__2) {
+                  var sign = __webpack_require__2(5716);
+                  module22.exports = bn2num;
+                  function bn2num(b2) {
+                    var l2 = b2.length;
+                    var words = b2.words;
+                    var out = 0;
+                    if (l2 === 1) {
+                      out = words[0];
+                    } else if (l2 === 2) {
+                      out = words[0] + words[1] * 67108864;
+                    } else {
+                      for (var i2 = 0; i2 < l2; i2++) {
+                        var w2 = words[i2];
+                        out += w2 * Math.pow(67108864, i2);
+                      }
+                    }
+                    return sign(b2) * out;
+                  }
+                }
+              ),
+              /***/
+              1371: (
+                /***/
+                function(module22, __unused_webpack_exports, __webpack_require__2) {
+                  var repeat = __webpack_require__2(3233);
+                  module22.exports = function padLeft2(str, num, ch2) {
+                    ch2 = typeof ch2 !== "undefined" ? ch2 + "" : " ";
+                    return repeat(ch2, num) + str;
+                  };
+                }
+              ),
+              /***/
+              1373: (
+                /***/
+                function(module22) {
+                  module22.exports = divide;
+                  function divide(out, a2, b2) {
+                    out[0] = a2[0] / b2[0];
+                    out[1] = a2[1] / b2[1];
+                    out[2] = a2[2] / b2[2];
+                    out[3] = a2[3] / b2[3];
+                    return out;
+                  }
+                }
+              ),
+              /***/
+              1387: (
+                /***/
+                function(module22) {
+                  module22.exports = length2;
+                  function length2(a2) {
+                    var x2 = a2[0], y2 = a2[1], z2 = a2[2];
+                    return Math.sqrt(x2 * x2 + y2 * y2 + z2 * z2);
+                  }
+                }
+              ),
+              /***/
+              1433: (
+                /***/
+                function(module22) {
+                  function doBind(gl2, elements, attributes) {
+                    if (elements) {
+                      elements.bind();
+                    } else {
+                      gl2.bindBuffer(gl2.ELEMENT_ARRAY_BUFFER, null);
+                    }
+                    var nattribs = gl2.getParameter(gl2.MAX_VERTEX_ATTRIBS) | 0;
+                    if (attributes) {
+                      if (attributes.length > nattribs) {
+                        throw new Error("gl-vao: Too many vertex attributes");
+                      }
+                      for (var i2 = 0; i2 < attributes.length; ++i2) {
+                        var attrib = attributes[i2];
+                        if (attrib.buffer) {
+                          var buffer = attrib.buffer;
+                          var size = attrib.size || 4;
+                          var type = attrib.type || gl2.FLOAT;
+                          var normalized = !!attrib.normalized;
+                          var stride = attrib.stride || 0;
+                          var offset = attrib.offset || 0;
+                          buffer.bind();
+                          gl2.enableVertexAttribArray(i2);
+                          gl2.vertexAttribPointer(i2, size, type, normalized, stride, offset);
+                        } else {
+                          if (typeof attrib === "number") {
+                            gl2.vertexAttrib1f(i2, attrib);
+                          } else if (attrib.length === 1) {
+                            gl2.vertexAttrib1f(i2, attrib[0]);
+                          } else if (attrib.length === 2) {
+                            gl2.vertexAttrib2f(i2, attrib[0], attrib[1]);
+                          } else if (attrib.length === 3) {
+                            gl2.vertexAttrib3f(i2, attrib[0], attrib[1], attrib[2]);
+                          } else if (attrib.length === 4) {
+                            gl2.vertexAttrib4f(i2, attrib[0], attrib[1], attrib[2], attrib[3]);
+                          } else {
+                            throw new Error("gl-vao: Invalid vertex attribute");
+                          }
+                          gl2.disableVertexAttribArray(i2);
+                        }
+                      }
+                      for (; i2 < nattribs; ++i2) {
+                        gl2.disableVertexAttribArray(i2);
+                      }
+                    } else {
+                      gl2.bindBuffer(gl2.ARRAY_BUFFER, null);
+                      for (var i2 = 0; i2 < nattribs; ++i2) {
+                        gl2.disableVertexAttribArray(i2);
+                      }
+                    }
+                  }
+                  module22.exports = doBind;
+                }
+              ),
+              /***/
+              1463: (
+                /***/
+                function(module22) {
+                  module22.exports = set;
+                  function set(out, x2, y2, z2) {
+                    out[0] = x2;
+                    out[1] = y2;
+                    out[2] = z2;
+                    return out;
+                  }
+                }
+              ),
+              /***/
+              1493: (
+                /***/
+                function(module22, __unused_webpack_exports, __webpack_require__2) {
+                  var glslify = __webpack_require__2(3236);
+                  var createShader = __webpack_require__2(9405);
+                  var vertSrc = glslify(["precision mediump float;\n#define GLSLIFY 1\n\nattribute vec3 position, color;\nattribute float weight;\n\nuniform mat4 model, view, projection;\nuniform vec3 coordinates[3];\nuniform vec4 colors[3];\nuniform vec2 screenShape;\nuniform float lineWidth;\n\nvarying vec4 fragColor;\n\nvoid main() {\n  vec3 vertexPosition = mix(coordinates[0],\n    mix(coordinates[2], coordinates[1], 0.5 * (position + 1.0)), abs(position));\n\n  vec4 clipPos = projection * (view * (model * vec4(vertexPosition, 1.0)));\n  vec2 clipOffset = (projection * (view * (model * vec4(color, 0.0)))).xy;\n  vec2 delta = weight * clipOffset * screenShape;\n  vec2 lineOffset = normalize(vec2(delta.y, -delta.x)) / screenShape;\n\n  gl_Position   = vec4(clipPos.xy + clipPos.w * 0.5 * lineWidth * lineOffset, clipPos.z, clipPos.w);\n  fragColor     = color.x * colors[0] + color.y * colors[1] + color.z * colors[2];\n}\n"]);
+                  var fragSrc = glslify(["precision mediump float;\n#define GLSLIFY 1\n\nvarying vec4 fragColor;\n\nvoid main() {\n  gl_FragColor = fragColor;\n}"]);
+                  module22.exports = function(gl2) {
+                    return createShader(gl2, vertSrc, fragSrc, null, [
+                      { name: "position", type: "vec3" },
+                      { name: "color", type: "vec3" },
+                      { name: "weight", type: "float" }
+                    ]);
+                  };
+                }
+              ),
+              /***/
+              1498: (
+                /***/
+                function(module22) {
+                  module22.exports = negate2;
+                  function negate2(out, a2) {
+                    out[0] = -a2[0];
+                    out[1] = -a2[1];
+                    out[2] = -a2[2];
+                    out[3] = -a2[3];
+                    return out;
+                  }
+                }
+              ),
+              /***/
+              1533: (
+                /***/
+                function(module22, __unused_webpack_exports, __webpack_require__2) {
+                  __webpack_require__2(6859);
+                  module22.exports = isBN;
+                  function isBN(x2) {
+                    return x2 && typeof x2 === "object" && Boolean(x2.words);
+                  }
+                }
+              ),
+              /***/
+              1538: (
+                /***/
+                function(module22) {
+                  (function WeakMapModule() {
+                    if (typeof ses !== "undefined" && ses.ok && !ses.ok()) {
+                      return;
+                    }
+                    function weakMapPermitHostObjects(map2) {
+                      if (map2.permitHostObjects___) {
+                        map2.permitHostObjects___(weakMapPermitHostObjects);
+                      }
+                    }
+                    if (typeof ses !== "undefined") {
+                      ses.weakMapPermitHostObjects = weakMapPermitHostObjects;
+                    }
+                    var doubleWeakMapCheckSilentFailure = false;
+                    if (typeof WeakMap === "function") {
+                      var HostWeakMap = WeakMap;
+                      if (typeof navigator !== "undefined" && /Firefox/.test(navigator.userAgent)) ;
+                      else {
+                        var testMap = new HostWeakMap();
+                        var testObject = Object.freeze({});
+                        testMap.set(testObject, 1);
+                        if (testMap.get(testObject) !== 1) {
+                          doubleWeakMapCheckSilentFailure = true;
+                        } else {
+                          module22.exports = WeakMap;
+                          return;
+                        }
+                      }
+                    }
+                    var gopn = Object.getOwnPropertyNames;
+                    var defProp = Object.defineProperty;
+                    var isExtensible = Object.isExtensible;
+                    var HIDDEN_NAME_PREFIX = "weakmap:";
+                    var HIDDEN_NAME = HIDDEN_NAME_PREFIX + "ident:" + Math.random() + "___";
+                    if (typeof crypto !== "undefined" && typeof crypto.getRandomValues === "function" && typeof ArrayBuffer === "function" && typeof Uint8Array === "function") {
+                      var ab2 = new ArrayBuffer(25);
+                      var u8s = new Uint8Array(ab2);
+                      crypto.getRandomValues(u8s);
+                      HIDDEN_NAME = HIDDEN_NAME_PREFIX + "rand:" + Array.prototype.map.call(u8s, function(u8) {
+                        return (u8 % 36).toString(36);
+                      }).join("") + "___";
+                    }
+                    function isNotHiddenName(name2) {
+                      return !(name2.substr(0, HIDDEN_NAME_PREFIX.length) == HIDDEN_NAME_PREFIX && name2.substr(name2.length - 3) === "___");
+                    }
+                    defProp(Object, "getOwnPropertyNames", {
+                      value: function fakeGetOwnPropertyNames(obj) {
+                        return gopn(obj).filter(isNotHiddenName);
+                      }
+                    });
+                    if ("getPropertyNames" in Object) {
+                      var originalGetPropertyNames = Object.getPropertyNames;
+                      defProp(Object, "getPropertyNames", {
+                        value: function fakeGetPropertyNames(obj) {
+                          return originalGetPropertyNames(obj).filter(isNotHiddenName);
+                        }
+                      });
+                    }
+                    function getHiddenRecord(key) {
+                      if (key !== Object(key)) {
+                        throw new TypeError("Not an object: " + key);
+                      }
+                      var hiddenRecord = key[HIDDEN_NAME];
+                      if (hiddenRecord && hiddenRecord.key === key) {
+                        return hiddenRecord;
+                      }
+                      if (!isExtensible(key)) {
+                        return void 0;
+                      }
+                      hiddenRecord = { key };
+                      try {
+                        defProp(key, HIDDEN_NAME, {
+                          value: hiddenRecord,
+                          writable: false,
+                          enumerable: false,
+                          configurable: false
+                        });
+                        return hiddenRecord;
+                      } catch (error) {
+                        return void 0;
+                      }
+                    }
+                    (function() {
+                      var oldFreeze = Object.freeze;
+                      defProp(Object, "freeze", {
+                        value: function identifyingFreeze(obj) {
+                          getHiddenRecord(obj);
+                          return oldFreeze(obj);
+                        }
+                      });
+                      var oldSeal = Object.seal;
+                      defProp(Object, "seal", {
+                        value: function identifyingSeal(obj) {
+                          getHiddenRecord(obj);
+                          return oldSeal(obj);
+                        }
+                      });
+                      var oldPreventExtensions = Object.preventExtensions;
+                      defProp(Object, "preventExtensions", {
+                        value: function identifyingPreventExtensions(obj) {
+                          getHiddenRecord(obj);
+                          return oldPreventExtensions(obj);
+                        }
+                      });
+                    })();
+                    function constFunc(func) {
+                      func.prototype = null;
+                      return Object.freeze(func);
+                    }
+                    var calledAsFunctionWarningDone = false;
+                    function calledAsFunctionWarning() {
+                      if (!calledAsFunctionWarningDone && typeof console !== "undefined") {
+                        calledAsFunctionWarningDone = true;
+                        console.warn("WeakMap should be invoked as new WeakMap(), not WeakMap(). This will be an error in the future.");
+                      }
+                    }
+                    var nextId = 0;
+                    var OurWeakMap = function() {
+                      if (!(this instanceof OurWeakMap)) {
+                        calledAsFunctionWarning();
+                      }
+                      var keys = [];
+                      var values = [];
+                      var id2 = nextId++;
+                      function get___(key, opt_default) {
+                        var index;
+                        var hiddenRecord = getHiddenRecord(key);
+                        if (hiddenRecord) {
+                          return id2 in hiddenRecord ? hiddenRecord[id2] : opt_default;
+                        } else {
+                          index = keys.indexOf(key);
+                          return index >= 0 ? values[index] : opt_default;
+                        }
+                      }
+                      function has___(key) {
+                        var hiddenRecord = getHiddenRecord(key);
+                        if (hiddenRecord) {
+                          return id2 in hiddenRecord;
+                        } else {
+                          return keys.indexOf(key) >= 0;
+                        }
+                      }
+                      function set___(key, value) {
+                        var index;
+                        var hiddenRecord = getHiddenRecord(key);
+                        if (hiddenRecord) {
+                          hiddenRecord[id2] = value;
+                        } else {
+                          index = keys.indexOf(key);
+                          if (index >= 0) {
+                            values[index] = value;
+                          } else {
+                            index = keys.length;
+                            values[index] = value;
+                            keys[index] = key;
+                          }
+                        }
+                        return this;
+                      }
+                      function delete___(key) {
+                        var hiddenRecord = getHiddenRecord(key);
+                        var index, lastIndex;
+                        if (hiddenRecord) {
+                          return id2 in hiddenRecord && delete hiddenRecord[id2];
+                        } else {
+                          index = keys.indexOf(key);
+                          if (index < 0) {
+                            return false;
+                          }
+                          lastIndex = keys.length - 1;
+                          keys[index] = void 0;
+                          values[index] = values[lastIndex];
+                          keys[index] = keys[lastIndex];
+                          keys.length = lastIndex;
+                          values.length = lastIndex;
+                          return true;
+                        }
+                      }
+                      return Object.create(OurWeakMap.prototype, {
+                        get___: { value: constFunc(get___) },
+                        has___: { value: constFunc(has___) },
+                        set___: { value: constFunc(set___) },
+                        delete___: { value: constFunc(delete___) }
+                      });
+                    };
+                    OurWeakMap.prototype = Object.create(Object.prototype, {
+                      get: {
+                        /**
+                         * Return the value most recently associated with key, or
+                         * opt_default if none.
+                         */
+                        value: function get(key, opt_default) {
+                          return this.get___(key, opt_default);
+                        },
+                        writable: true,
+                        configurable: true
+                      },
+                      has: {
+                        /**
+                         * Is there a value associated with key in this WeakMap?
+                         */
+                        value: function has(key) {
+                          return this.has___(key);
+                        },
+                        writable: true,
+                        configurable: true
+                      },
+                      set: {
+                        /**
+                         * Associate value with key in this WeakMap, overwriting any
+                         * previous association if present.
+                         */
+                        value: function set(key, value) {
+                          return this.set___(key, value);
+                        },
+                        writable: true,
+                        configurable: true
+                      },
+                      "delete": {
+                        /**
+                         * Remove any association for key in this WeakMap, returning
+                         * whether there was one.
+                         *
+                         * <p>Note that the boolean return here does not work like the
+                         * {@code delete} operator. The {@code delete} operator returns
+                         * whether the deletion succeeds at bringing about a state in
+                         * which the deleted property is absent. The {@code delete}
+                         * operator therefore returns true if the property was already
+                         * absent, whereas this {@code delete} method returns false if
+                         * the association was already absent.
+                         */
+                        value: function remove(key) {
+                          return this.delete___(key);
+                        },
+                        writable: true,
+                        configurable: true
+                      }
+                    });
+                    if (typeof HostWeakMap === "function") {
+                      (function() {
+                        if (doubleWeakMapCheckSilentFailure && typeof Proxy !== "undefined") {
+                          Proxy = void 0;
+                        }
+                        function DoubleWeakMap() {
+                          if (!(this instanceof OurWeakMap)) {
+                            calledAsFunctionWarning();
+                          }
+                          var hmap = new HostWeakMap();
+                          var omap = void 0;
+                          var enableSwitching = false;
+                          function dget(key, opt_default) {
+                            if (omap) {
+                              return hmap.has(key) ? hmap.get(key) : omap.get___(key, opt_default);
+                            } else {
+                              return hmap.get(key, opt_default);
+                            }
+                          }
+                          function dhas(key) {
+                            return hmap.has(key) || (omap ? omap.has___(key) : false);
+                          }
+                          var dset;
+                          if (doubleWeakMapCheckSilentFailure) {
+                            dset = function(key, value) {
+                              hmap.set(key, value);
+                              if (!hmap.has(key)) {
+                                if (!omap) {
+                                  omap = new OurWeakMap();
+                                }
+                                omap.set(key, value);
+                              }
+                              return this;
+                            };
+                          } else {
+                            dset = function(key, value) {
+                              if (enableSwitching) {
+                                try {
+                                  hmap.set(key, value);
+                                } catch (e2) {
+                                  if (!omap) {
+                                    omap = new OurWeakMap();
+                                  }
+                                  omap.set___(key, value);
+                                }
+                              } else {
+                                hmap.set(key, value);
+                              }
+                              return this;
+                            };
+                          }
+                          function ddelete(key) {
+                            var result = !!hmap["delete"](key);
+                            if (omap) {
+                              return omap.delete___(key) || result;
+                            }
+                            return result;
+                          }
+                          return Object.create(OurWeakMap.prototype, {
+                            get___: { value: constFunc(dget) },
+                            has___: { value: constFunc(dhas) },
+                            set___: { value: constFunc(dset) },
+                            delete___: { value: constFunc(ddelete) },
+                            permitHostObjects___: { value: constFunc(function(token) {
+                              if (token === weakMapPermitHostObjects) {
+                                enableSwitching = true;
+                              } else {
+                                throw new Error("bogus call to permitHostObjects___");
+                              }
+                            }) }
+                          });
+                        }
+                        DoubleWeakMap.prototype = OurWeakMap.prototype;
+                        module22.exports = DoubleWeakMap;
+                        Object.defineProperty(WeakMap.prototype, "constructor", {
+                          value: WeakMap,
+                          enumerable: false,
+                          // as default .constructor is
+                          configurable: true,
+                          writable: true
+                        });
+                      })();
+                    } else {
+                      if (typeof Proxy !== "undefined") {
+                        Proxy = void 0;
+                      }
+                      module22.exports = OurWeakMap;
+                    }
+                  })();
+                }
+              ),
+              /***/
+              1570: (
+                /***/
+                function(module22) {
+                  module22.exports = getPolygonizer;
+                  var allFns = [
+                    function cellPolygonizer_0() {
+                      function getContour0d(F2, E22, C22, S2) {
+                        var n2 = F2.length, R2 = [];
+                        for (var i2 = 0; i2 < n2; ++i2) {
+                          var c2 = F2[i2];
+                          c2.length;
+                        }
+                        return R2;
+                      }
+                      return getContour0d;
+                    },
+                    function cellPolygonizer_1() {
+                      function B22(C22, E22, i2, j2) {
+                        var a2 = Math.min(i2, j2) | 0, b2 = Math.max(i2, j2) | 0, l2 = C22[2 * a2], h2 = C22[2 * a2 + 1];
+                        while (l2 < h2) {
+                          var m2 = l2 + h2 >> 1, v2 = E22[2 * m2 + 1];
+                          if (v2 === b2) {
+                            return m2;
+                          }
+                          if (b2 < v2) {
+                            h2 = m2;
+                          } else {
+                            l2 = m2 + 1;
+                          }
+                        }
+                        return l2;
+                      }
+                      function getContour1d(F2, E22, C22, S2) {
+                        var n2 = F2.length, R2 = [];
+                        for (var i2 = 0; i2 < n2; ++i2) {
+                          var c2 = F2[i2], l2 = c2.length;
+                          if (l2 === 2) {
+                            var M2 = (S2[c2[0]] << 0) + (S2[c2[1]] << 1);
+                            if (M2 === 0 || M2 === 3) {
+                              continue;
+                            }
+                            switch (M2) {
+                              case 0:
+                                break;
+                              case 1:
+                                R2.push([B22(C22, E22, c2[0], c2[1])]);
+                                break;
+                              case 2:
+                                R2.push([B22(C22, E22, c2[1], c2[0])]);
+                                break;
+                            }
+                          }
+                        }
+                        return R2;
+                      }
+                      return getContour1d;
+                    },
+                    function cellPolygonizer_2() {
+                      function B22(C22, E22, i2, j2) {
+                        var a2 = Math.min(i2, j2) | 0, b2 = Math.max(i2, j2) | 0, l2 = C22[2 * a2], h2 = C22[2 * a2 + 1];
+                        while (l2 < h2) {
+                          var m2 = l2 + h2 >> 1, v2 = E22[2 * m2 + 1];
+                          if (v2 === b2) {
+                            return m2;
+                          }
+                          if (b2 < v2) {
+                            h2 = m2;
+                          } else {
+                            l2 = m2 + 1;
+                          }
+                        }
+                        return l2;
+                      }
+                      function getContour2d(F2, E22, C22, S2) {
+                        var n2 = F2.length, R2 = [];
+                        for (var i2 = 0; i2 < n2; ++i2) {
+                          var c2 = F2[i2], l2 = c2.length;
+                          if (l2 === 3) {
+                            var M2 = (S2[c2[0]] << 0) + (S2[c2[1]] << 1) + (S2[c2[2]] << 2);
+                            if (M2 === 0 || M2 === 7) {
+                              continue;
+                            }
+                            switch (M2) {
+                              case 0:
+                                break;
+                              case 1:
+                                R2.push([B22(C22, E22, c2[0], c2[2]), B22(C22, E22, c2[0], c2[1])]);
+                                break;
+                              case 2:
+                                R2.push([B22(C22, E22, c2[1], c2[0]), B22(C22, E22, c2[1], c2[2])]);
+                                break;
+                              case 3:
+                                R2.push([B22(C22, E22, c2[0], c2[2]), B22(C22, E22, c2[1], c2[2])]);
+                                break;
+                              case 4:
+                                R2.push([B22(C22, E22, c2[2], c2[1]), B22(C22, E22, c2[2], c2[0])]);
+                                break;
+                              case 5:
+                                R2.push([B22(C22, E22, c2[2], c2[1]), B22(C22, E22, c2[0], c2[1])]);
+                                break;
+                              case 6:
+                                R2.push([B22(C22, E22, c2[1], c2[0]), B22(C22, E22, c2[2], c2[0])]);
+                                break;
+                            }
+                          } else if (l2 === 2) {
+                            var M2 = (S2[c2[0]] << 0) + (S2[c2[1]] << 1);
+                            if (M2 === 0 || M2 === 3) {
+                              continue;
+                            }
+                            switch (M2) {
+                              case 0:
+                                break;
+                              case 1:
+                                R2.push([B22(C22, E22, c2[0], c2[1])]);
+                                break;
+                              case 2:
+                                R2.push([B22(C22, E22, c2[1], c2[0])]);
+                                break;
+                            }
+                          }
+                        }
+                        return R2;
+                      }
+                      return getContour2d;
+                    },
+                    function cellPolygonizer_3() {
+                      function B22(C22, E22, i2, j2) {
+                        var a2 = Math.min(i2, j2) | 0, b2 = Math.max(i2, j2) | 0, l2 = C22[2 * a2], h2 = C22[2 * a2 + 1];
+                        while (l2 < h2) {
+                          var m2 = l2 + h2 >> 1, v2 = E22[2 * m2 + 1];
+                          if (v2 === b2) {
+                            return m2;
+                          }
+                          if (b2 < v2) {
+                            h2 = m2;
+                          } else {
+                            l2 = m2 + 1;
+                          }
+                        }
+                        return l2;
+                      }
+                      function getContour3d(F2, E22, C22, S2) {
+                        var n2 = F2.length, R2 = [];
+                        for (var i2 = 0; i2 < n2; ++i2) {
+                          var c2 = F2[i2], l2 = c2.length;
+                          if (l2 === 4) {
+                            var M2 = (S2[c2[0]] << 0) + (S2[c2[1]] << 1) + (S2[c2[2]] << 2) + (S2[c2[3]] << 3);
+                            if (M2 === 0 || M2 === 15) {
+                              continue;
+                            }
+                            switch (M2) {
+                              case 0:
+                                break;
+                              case 1:
+                                R2.push([B22(C22, E22, c2[0], c2[1]), B22(C22, E22, c2[0], c2[2]), B22(C22, E22, c2[0], c2[3])]);
+                                break;
+                              case 2:
+                                R2.push([B22(C22, E22, c2[1], c2[2]), B22(C22, E22, c2[1], c2[0]), B22(C22, E22, c2[1], c2[3])]);
+                                break;
+                              case 3:
+                                R2.push([B22(C22, E22, c2[1], c2[2]), B22(C22, E22, c2[0], c2[2]), B22(C22, E22, c2[0], c2[3])], [B22(C22, E22, c2[1], c2[3]), B22(C22, E22, c2[1], c2[2]), B22(C22, E22, c2[0], c2[3])]);
+                                break;
+                              case 4:
+                                R2.push([B22(C22, E22, c2[2], c2[0]), B22(C22, E22, c2[2], c2[1]), B22(C22, E22, c2[2], c2[3])]);
+                                break;
+                              case 5:
+                                R2.push([B22(C22, E22, c2[0], c2[1]), B22(C22, E22, c2[2], c2[1]), B22(C22, E22, c2[0], c2[3])], [B22(C22, E22, c2[2], c2[1]), B22(C22, E22, c2[2], c2[3]), B22(C22, E22, c2[0], c2[3])]);
+                                break;
+                              case 6:
+                                R2.push([B22(C22, E22, c2[2], c2[0]), B22(C22, E22, c2[1], c2[0]), B22(C22, E22, c2[1], c2[3])], [B22(C22, E22, c2[2], c2[3]), B22(C22, E22, c2[2], c2[0]), B22(C22, E22, c2[1], c2[3])]);
+                                break;
+                              case 7:
+                                R2.push([B22(C22, E22, c2[0], c2[3]), B22(C22, E22, c2[1], c2[3]), B22(C22, E22, c2[2], c2[3])]);
+                                break;
+                              case 8:
+                                R2.push([B22(C22, E22, c2[3], c2[1]), B22(C22, E22, c2[3], c2[0]), B22(C22, E22, c2[3], c2[2])]);
+                                break;
+                              case 9:
+                                R2.push([B22(C22, E22, c2[3], c2[1]), B22(C22, E22, c2[0], c2[1]), B22(C22, E22, c2[0], c2[2])], [B22(C22, E22, c2[3], c2[2]), B22(C22, E22, c2[3], c2[1]), B22(C22, E22, c2[0], c2[2])]);
+                                break;
+                              case 10:
+                                R2.push([B22(C22, E22, c2[1], c2[0]), B22(C22, E22, c2[3], c2[0]), B22(C22, E22, c2[1], c2[2])], [B22(C22, E22, c2[3], c2[0]), B22(C22, E22, c2[3], c2[2]), B22(C22, E22, c2[1], c2[2])]);
+                                break;
+                              case 11:
+                                R2.push([B22(C22, E22, c2[1], c2[2]), B22(C22, E22, c2[0], c2[2]), B22(C22, E22, c2[3], c2[2])]);
+                                break;
+                              case 12:
+                                R2.push([B22(C22, E22, c2[3], c2[0]), B22(C22, E22, c2[2], c2[0]), B22(C22, E22, c2[2], c2[1])], [B22(C22, E22, c2[3], c2[1]), B22(C22, E22, c2[3], c2[0]), B22(C22, E22, c2[2], c2[1])]);
+                                break;
+                              case 13:
+                                R2.push([B22(C22, E22, c2[0], c2[1]), B22(C22, E22, c2[2], c2[1]), B22(C22, E22, c2[3], c2[1])]);
+                                break;
+                              case 14:
+                                R2.push([B22(C22, E22, c2[2], c2[0]), B22(C22, E22, c2[1], c2[0]), B22(C22, E22, c2[3], c2[0])]);
+                                break;
+                            }
+                          } else if (l2 === 3) {
+                            var M2 = (S2[c2[0]] << 0) + (S2[c2[1]] << 1) + (S2[c2[2]] << 2);
+                            if (M2 === 0 || M2 === 7) {
+                              continue;
+                            }
+                            switch (M2) {
+                              case 0:
+                                break;
+                              case 1:
+                                R2.push([B22(C22, E22, c2[0], c2[2]), B22(C22, E22, c2[0], c2[1])]);
+                                break;
+                              case 2:
+                                R2.push([B22(C22, E22, c2[1], c2[0]), B22(C22, E22, c2[1], c2[2])]);
+                                break;
+                              case 3:
+                                R2.push([B22(C22, E22, c2[0], c2[2]), B22(C22, E22, c2[1], c2[2])]);
+                                break;
+                              case 4:
+                                R2.push([B22(C22, E22, c2[2], c2[1]), B22(C22, E22, c2[2], c2[0])]);
+                                break;
+                              case 5:
+                                R2.push([B22(C22, E22, c2[2], c2[1]), B22(C22, E22, c2[0], c2[1])]);
+                                break;
+                              case 6:
+                                R2.push([B22(C22, E22, c2[1], c2[0]), B22(C22, E22, c2[2], c2[0])]);
+                                break;
+                            }
+                          } else if (l2 === 2) {
+                            var M2 = (S2[c2[0]] << 0) + (S2[c2[1]] << 1);
+                            if (M2 === 0 || M2 === 3) {
+                              continue;
+                            }
+                            switch (M2) {
+                              case 0:
+                                break;
+                              case 1:
+                                R2.push([B22(C22, E22, c2[0], c2[1])]);
+                                break;
+                              case 2:
+                                R2.push([B22(C22, E22, c2[1], c2[0])]);
+                                break;
+                            }
+                          }
+                        }
+                        return R2;
+                      }
+                      return getContour3d;
+                    }
+                  ];
+                  function getPolygonizer(d2) {
+                    return allFns[d2]();
+                  }
+                }
+              ),
+              /***/
+              1682: (
+                /***/
+                function(module22) {
+                  function unique_pred(list, compare) {
+                    var ptr = 1, len2 = list.length, a2 = list[0], b2 = list[0];
+                    for (var i2 = 1; i2 < len2; ++i2) {
+                      b2 = a2;
+                      a2 = list[i2];
+                      if (compare(a2, b2)) {
+                        if (i2 === ptr) {
+                          ptr++;
+                          continue;
+                        }
+                        list[ptr++] = a2;
+                      }
+                    }
+                    list.length = ptr;
+                    return list;
+                  }
+                  function unique_eq(list) {
+                    var ptr = 1, len2 = list.length, a2 = list[0], b2 = list[0];
+                    for (var i2 = 1; i2 < len2; ++i2, b2 = a2) {
+                      b2 = a2;
+                      a2 = list[i2];
+                      if (a2 !== b2) {
+                        if (i2 === ptr) {
+                          ptr++;
+                          continue;
+                        }
+                        list[ptr++] = a2;
+                      }
+                    }
+                    list.length = ptr;
+                    return list;
+                  }
+                  function unique(list, compare, sorted) {
+                    if (list.length === 0) {
+                      return list;
+                    }
+                    if (compare) {
+                      if (!sorted) {
+                        list.sort(compare);
+                      }
+                      return unique_pred(list, compare);
+                    }
+                    if (!sorted) {
+                      list.sort();
+                    }
+                    return unique_eq(list);
+                  }
+                  module22.exports = unique;
+                }
+              ),
+              /***/
+              1755: (
+                /***/
+                function(module22) {
+                  "use restrict";
+                  module22.exports = UnionFind;
+                  function UnionFind(count2) {
+                    this.roots = new Array(count2);
+                    this.ranks = new Array(count2);
+                    for (var i2 = 0; i2 < count2; ++i2) {
+                      this.roots[i2] = i2;
+                      this.ranks[i2] = 0;
+                    }
+                  }
+                  var proto = UnionFind.prototype;
+                  Object.defineProperty(proto, "length", {
+                    "get": function() {
+                      return this.roots.length;
+                    }
+                  });
+                  proto.makeSet = function() {
+                    var n2 = this.roots.length;
+                    this.roots.push(n2);
+                    this.ranks.push(0);
+                    return n2;
+                  };
+                  proto.find = function(x2) {
+                    var x0 = x2;
+                    var roots = this.roots;
+                    while (roots[x2] !== x2) {
+                      x2 = roots[x2];
+                    }
+                    while (roots[x0] !== x2) {
+                      var y2 = roots[x0];
+                      roots[x0] = x2;
+                      x0 = y2;
+                    }
+                    return x2;
+                  };
+                  proto.link = function(x2, y2) {
+                    var xr = this.find(x2), yr = this.find(y2);
+                    if (xr === yr) {
+                      return;
+                    }
+                    var ranks = this.ranks, roots = this.roots, xd2 = ranks[xr], yd2 = ranks[yr];
+                    if (xd2 < yd2) {
+                      roots[xr] = yr;
+                    } else if (yd2 < xd2) {
+                      roots[yr] = xr;
+                    } else {
+                      roots[yr] = xr;
+                      ++ranks[xr];
+                    }
+                  };
+                }
+              ),
+              /***/
+              1811: (
+                /***/
+                function(module22, __unused_webpack_exports, __webpack_require__2) {
+                  var bsearch = __webpack_require__2(2478);
+                  var m4interp = __webpack_require__2(7442);
+                  var invert44 = __webpack_require__2(7608);
+                  var rotateX2 = __webpack_require__2(5567);
+                  var rotateY2 = __webpack_require__2(2408);
+                  var rotateZ2 = __webpack_require__2(7089);
+                  var lookAt2 = __webpack_require__2(6582);
+                  var translate2 = __webpack_require__2(7656);
+                  __webpack_require__2(2504);
+                  var normalize = __webpack_require__2(3536);
+                  var DEFAULT_CENTER = [0, 0, 0];
+                  module22.exports = createMatrixCameraController;
+                  function MatrixCameraController(initialMatrix) {
+                    this._components = initialMatrix.slice();
+                    this._time = [0];
+                    this.prevMatrix = initialMatrix.slice();
+                    this.nextMatrix = initialMatrix.slice();
+                    this.computedMatrix = initialMatrix.slice();
+                    this.computedInverse = initialMatrix.slice();
+                    this.computedEye = [0, 0, 0];
+                    this.computedUp = [0, 0, 0];
+                    this.computedCenter = [0, 0, 0];
+                    this.computedRadius = [0];
+                    this._limits = [-Infinity, Infinity];
+                  }
+                  var proto = MatrixCameraController.prototype;
+                  proto.recalcMatrix = function(t4) {
+                    var time = this._time;
+                    var tidx = bsearch.le(time, t4);
+                    var mat = this.computedMatrix;
+                    if (tidx < 0) {
+                      return;
+                    }
+                    var comps = this._components;
+                    if (tidx === time.length - 1) {
+                      var ptr = 16 * tidx;
+                      for (var i2 = 0; i2 < 16; ++i2) {
+                        mat[i2] = comps[ptr++];
+                      }
+                    } else {
+                      var dt2 = time[tidx + 1] - time[tidx];
+                      var ptr = 16 * tidx;
+                      var prev = this.prevMatrix;
+                      var allEqual = true;
+                      for (var i2 = 0; i2 < 16; ++i2) {
+                        prev[i2] = comps[ptr++];
+                      }
+                      var next = this.nextMatrix;
+                      for (var i2 = 0; i2 < 16; ++i2) {
+                        next[i2] = comps[ptr++];
+                        allEqual = allEqual && prev[i2] === next[i2];
+                      }
+                      if (dt2 < 1e-6 || allEqual) {
+                        for (var i2 = 0; i2 < 16; ++i2) {
+                          mat[i2] = prev[i2];
+                        }
+                      } else {
+                        m4interp(mat, prev, next, (t4 - time[tidx]) / dt2);
+                      }
+                    }
+                    var up = this.computedUp;
+                    up[0] = mat[1];
+                    up[1] = mat[5];
+                    up[2] = mat[9];
+                    normalize(up, up);
+                    var imat = this.computedInverse;
+                    invert44(imat, mat);
+                    var eye = this.computedEye;
+                    var w2 = imat[15];
+                    eye[0] = imat[12] / w2;
+                    eye[1] = imat[13] / w2;
+                    eye[2] = imat[14] / w2;
+                    var center = this.computedCenter;
+                    var radius = Math.exp(this.computedRadius[0]);
+                    for (var i2 = 0; i2 < 3; ++i2) {
+                      center[i2] = eye[i2] - mat[2 + 4 * i2] * radius;
+                    }
+                  };
+                  proto.idle = function(t4) {
+                    if (t4 < this.lastT()) {
+                      return;
+                    }
+                    var mc2 = this._components;
+                    var ptr = mc2.length - 16;
+                    for (var i2 = 0; i2 < 16; ++i2) {
+                      mc2.push(mc2[ptr++]);
+                    }
+                    this._time.push(t4);
+                  };
+                  proto.flush = function(t4) {
+                    var idx = bsearch.gt(this._time, t4) - 2;
+                    if (idx < 0) {
+                      return;
+                    }
+                    this._time.splice(0, idx);
+                    this._components.splice(0, 16 * idx);
+                  };
+                  proto.lastT = function() {
+                    return this._time[this._time.length - 1];
+                  };
+                  proto.lookAt = function(t4, eye, center, up) {
+                    this.recalcMatrix(t4);
+                    eye = eye || this.computedEye;
+                    center = center || DEFAULT_CENTER;
+                    up = up || this.computedUp;
+                    this.setMatrix(t4, lookAt2(this.computedMatrix, eye, center, up));
+                    var d2 = 0;
+                    for (var i2 = 0; i2 < 3; ++i2) {
+                      d2 += Math.pow(center[i2] - eye[i2], 2);
+                    }
+                    d2 = Math.log(Math.sqrt(d2));
+                    this.computedRadius[0] = d2;
+                  };
+                  proto.rotate = function(t4, yaw, pitch, roll) {
+                    this.recalcMatrix(t4);
+                    var mat = this.computedInverse;
+                    if (yaw) rotateY2(mat, mat, yaw);
+                    if (pitch) rotateX2(mat, mat, pitch);
+                    if (roll) rotateZ2(mat, mat, roll);
+                    this.setMatrix(t4, invert44(this.computedMatrix, mat));
+                  };
+                  var tvec = [0, 0, 0];
+                  proto.pan = function(t4, dx, dy, dz) {
+                    tvec[0] = -(dx || 0);
+                    tvec[1] = -(dy || 0);
+                    tvec[2] = -(dz || 0);
+                    this.recalcMatrix(t4);
+                    var mat = this.computedInverse;
+                    translate2(mat, mat, tvec);
+                    this.setMatrix(t4, invert44(mat, mat));
+                  };
+                  proto.translate = function(t4, dx, dy, dz) {
+                    tvec[0] = dx || 0;
+                    tvec[1] = dy || 0;
+                    tvec[2] = dz || 0;
+                    this.recalcMatrix(t4);
+                    var mat = this.computedMatrix;
+                    translate2(mat, mat, tvec);
+                    this.setMatrix(t4, mat);
+                  };
+                  proto.setMatrix = function(t4, mat) {
+                    if (t4 < this.lastT()) {
+                      return;
+                    }
+                    this._time.push(t4);
+                    for (var i2 = 0; i2 < 16; ++i2) {
+                      this._components.push(mat[i2]);
+                    }
+                  };
+                  proto.setDistance = function(t4, d2) {
+                    this.computedRadius[0] = d2;
+                  };
+                  proto.setDistanceLimits = function(a2, b2) {
+                    var lim = this._limits;
+                    lim[0] = a2;
+                    lim[1] = b2;
+                  };
+                  proto.getDistanceLimits = function(out) {
+                    var lim = this._limits;
+                    if (out) {
+                      out[0] = lim[0];
+                      out[1] = lim[1];
+                      return out;
+                    }
+                    return lim;
+                  };
+                  function createMatrixCameraController(options) {
+                    options = options || {};
+                    var matrix = options.matrix || [
+                      1,
+                      0,
+                      0,
+                      0,
+                      0,
+                      1,
+                      0,
+                      0,
+                      0,
+                      0,
+                      1,
+                      0,
+                      0,
+                      0,
+                      0,
+                      1
+                    ];
+                    return new MatrixCameraController(matrix);
+                  }
+                }
+              ),
+              /***/
+              1848: (
+                /***/
+                function(module22, __unused_webpack_exports, __webpack_require__2) {
+                  var tokenize2 = __webpack_require__2(4905);
+                  var atob2 = __webpack_require__2(6468);
+                  module22.exports = getName;
+                  function getName(src) {
+                    var tokens = Array.isArray(src) ? src : tokenize2(src);
+                    for (var i2 = 0; i2 < tokens.length; i2++) {
+                      var token = tokens[i2];
+                      if (token.type !== "preprocessor") continue;
+                      var match = token.data.match(/\#define\s+SHADER_NAME(_B64)?\s+(.+)$/);
+                      if (!match) continue;
+                      if (!match[2]) continue;
+                      var b64 = match[1];
+                      var name2 = match[2];
+                      return (b64 ? atob2(name2) : name2).trim();
+                    }
+                  }
+                }
+              ),
+              /***/
+              1879: (
+                /***/
+                function(__unused_webpack_module, exports2, __webpack_require__2) {
+                  var glslify = __webpack_require__2(3236);
+                  var createShader = __webpack_require__2(9405);
+                  var lineVert = glslify(["precision highp float;\n#define GLSLIFY 1\n\nattribute vec3 position;\n\nuniform mat4 model, view, projection;\nuniform vec3 offset, majorAxis, minorAxis, screenAxis;\nuniform float lineWidth;\nuniform vec2 screenShape;\n\nvec3 project(vec3 p) {\n  vec4 pp = projection * (view * (model * vec4(p, 1.0)));\n  return pp.xyz / max(pp.w, 0.0001);\n}\n\nvoid main() {\n  vec3 major = position.x * majorAxis;\n  vec3 minor = position.y * minorAxis;\n\n  vec3 vPosition = major + minor + offset;\n  vec3 pPosition = project(vPosition);\n  vec3 offset = project(vPosition + screenAxis * position.z);\n\n  vec2 screen = normalize((offset - pPosition).xy * screenShape) / screenShape;\n\n  gl_Position = vec4(pPosition + vec3(0.5 * screen * lineWidth, 0), 1.0);\n}\n"]);
+                  var lineFrag = glslify(["precision highp float;\n#define GLSLIFY 1\n\nuniform vec4 color;\nvoid main() {\n  gl_FragColor = color;\n}"]);
+                  exports2.n = function(gl2) {
+                    return createShader(gl2, lineVert, lineFrag, null, [
+                      { name: "position", type: "vec3" }
+                    ]);
+                  };
+                  var textVert = glslify(["precision highp float;\n#define GLSLIFY 1\n\nattribute vec3 position;\n\nuniform mat4 model, view, projection;\nuniform vec3 offset, axis, alignDir, alignOpt;\nuniform float scale, angle, pixelScale;\nuniform vec2 resolution;\n\nvec3 project(vec3 p) {\n  vec4 pp = projection * (view * (model * vec4(p, 1.0)));\n  return pp.xyz / max(pp.w, 0.0001);\n}\n\nfloat computeViewAngle(vec3 a, vec3 b) {\n  vec3 A = project(a);\n  vec3 B = project(b);\n\n  return atan(\n    (B.y - A.y) * resolution.y,\n    (B.x - A.x) * resolution.x\n  );\n}\n\nconst float PI = 3.141592;\nconst float TWO_PI = 2.0 * PI;\nconst float HALF_PI = 0.5 * PI;\nconst float ONE_AND_HALF_PI = 1.5 * PI;\n\nint option = int(floor(alignOpt.x + 0.001));\nfloat hv_ratio =       alignOpt.y;\nbool enableAlign =    (alignOpt.z != 0.0);\n\nfloat mod_angle(float a) {\n  return mod(a, PI);\n}\n\nfloat positive_angle(float a) {\n  return mod_angle((a < 0.0) ?\n    a + TWO_PI :\n    a\n  );\n}\n\nfloat look_upwards(float a) {\n  float b = positive_angle(a);\n  return ((b > HALF_PI) && (b <= ONE_AND_HALF_PI)) ?\n    b - PI :\n    b;\n}\n\nfloat look_horizontal_or_vertical(float a, float ratio) {\n  // ratio controls the ratio between being horizontal to (vertical + horizontal)\n  // if ratio is set to 0.5 then it is 50%, 50%.\n  // when using a higher ratio e.g. 0.75 the result would\n  // likely be more horizontal than vertical.\n\n  float b = positive_angle(a);\n\n  return\n    (b < (      ratio) * HALF_PI) ? 0.0 :\n    (b < (2.0 - ratio) * HALF_PI) ? -HALF_PI :\n    (b < (2.0 + ratio) * HALF_PI) ? 0.0 :\n    (b < (4.0 - ratio) * HALF_PI) ? HALF_PI :\n                                    0.0;\n}\n\nfloat roundTo(float a, float b) {\n  return float(b * floor((a + 0.5 * b) / b));\n}\n\nfloat look_round_n_directions(float a, int n) {\n  float b = positive_angle(a);\n  float div = TWO_PI / float(n);\n  float c = roundTo(b, div);\n  return look_upwards(c);\n}\n\nfloat applyAlignOption(float rawAngle, float delta) {\n  return\n    (option >  2) ? look_round_n_directions(rawAngle + delta, option) :       // option 3-n: round to n directions\n    (option == 2) ? look_horizontal_or_vertical(rawAngle + delta, hv_ratio) : // horizontal or vertical\n    (option == 1) ? rawAngle + delta :       // use free angle, and flip to align with one direction of the axis\n    (option == 0) ? look_upwards(rawAngle) : // use free angle, and stay upwards\n    (option ==-1) ? 0.0 :                    // useful for backward compatibility, all texts remains horizontal\n                    rawAngle;                // otherwise return back raw input angle\n}\n\nbool isAxisTitle = (axis.x == 0.0) &&\n                   (axis.y == 0.0) &&\n                   (axis.z == 0.0);\n\nvoid main() {\n  //Compute world offset\n  float axisDistance = position.z;\n  vec3 dataPosition = axisDistance * axis + offset;\n\n  float beta = angle; // i.e. user defined attributes for each tick\n\n  float axisAngle;\n  float clipAngle;\n  float flip;\n\n  if (enableAlign) {\n    axisAngle = (isAxisTitle) ? HALF_PI :\n                      computeViewAngle(dataPosition, dataPosition + axis);\n    clipAngle = computeViewAngle(dataPosition, dataPosition + alignDir);\n\n    axisAngle += (sin(axisAngle) < 0.0) ? PI : 0.0;\n    clipAngle += (sin(clipAngle) < 0.0) ? PI : 0.0;\n\n    flip = (dot(vec2(cos(axisAngle), sin(axisAngle)),\n                vec2(sin(clipAngle),-cos(clipAngle))) > 0.0) ? 1.0 : 0.0;\n\n    beta += applyAlignOption(clipAngle, flip * PI);\n  }\n\n  //Compute plane offset\n  vec2 planeCoord = position.xy * pixelScale;\n\n  mat2 planeXform = scale * mat2(\n     cos(beta), sin(beta),\n    -sin(beta), cos(beta)\n  );\n\n  vec2 viewOffset = 2.0 * planeXform * planeCoord / resolution;\n\n  //Compute clip position\n  vec3 clipPosition = project(dataPosition);\n\n  //Apply text offset in clip coordinates\n  clipPosition += vec3(viewOffset, 0.0);\n\n  //Done\n  gl_Position = vec4(clipPosition, 1.0);\n}\n"]);
+                  var textFrag = glslify(["precision highp float;\n#define GLSLIFY 1\n\nuniform vec4 color;\nvoid main() {\n  gl_FragColor = color;\n}"]);
+                  exports2.Q = function(gl2) {
+                    return createShader(gl2, textVert, textFrag, null, [
+                      { name: "position", type: "vec3" }
+                    ]);
+                  };
+                  var bgVert = glslify(["precision highp float;\n#define GLSLIFY 1\n\nattribute vec3 position;\nattribute vec3 normal;\n\nuniform mat4 model, view, projection;\nuniform vec3 enable;\nuniform vec3 bounds[2];\n\nvarying vec3 colorChannel;\n\nvoid main() {\n\n  vec3 signAxis = sign(bounds[1] - bounds[0]);\n\n  vec3 realNormal = signAxis * normal;\n\n  if(dot(realNormal, enable) > 0.0) {\n    vec3 minRange = min(bounds[0], bounds[1]);\n    vec3 maxRange = max(bounds[0], bounds[1]);\n    vec3 nPosition = mix(minRange, maxRange, 0.5 * (position + 1.0));\n    gl_Position = projection * (view * (model * vec4(nPosition, 1.0)));\n  } else {\n    gl_Position = vec4(0,0,0,0);\n  }\n\n  colorChannel = abs(realNormal);\n}\n"]);
+                  var bgFrag = glslify(["precision highp float;\n#define GLSLIFY 1\n\nuniform vec4 colors[3];\n\nvarying vec3 colorChannel;\n\nvoid main() {\n  gl_FragColor = colorChannel.x * colors[0] +\n                 colorChannel.y * colors[1] +\n                 colorChannel.z * colors[2];\n}"]);
+                  exports2.bg = function(gl2) {
+                    return createShader(gl2, bgVert, bgFrag, null, [
+                      { name: "position", type: "vec3" },
+                      { name: "normal", type: "vec3" }
+                    ]);
+                  };
+                }
+              ),
+              /***/
+              1888: (
+                /***/
+                function(__unused_webpack_module, exports2, __webpack_require__2) {
+                  var bits = __webpack_require__2(8828);
+                  var dup = __webpack_require__2(1338);
+                  var Buffer22 = __webpack_require__2(4793).hp;
+                  if (!__webpack_require__2.g.__TYPEDARRAY_POOL) {
+                    __webpack_require__2.g.__TYPEDARRAY_POOL = {
+                      UINT8: dup([32, 0]),
+                      UINT16: dup([32, 0]),
+                      UINT32: dup([32, 0]),
+                      BIGUINT64: dup([32, 0]),
+                      INT8: dup([32, 0]),
+                      INT16: dup([32, 0]),
+                      INT32: dup([32, 0]),
+                      BIGINT64: dup([32, 0]),
+                      FLOAT: dup([32, 0]),
+                      DOUBLE: dup([32, 0]),
+                      DATA: dup([32, 0]),
+                      UINT8C: dup([32, 0]),
+                      BUFFER: dup([32, 0])
+                    };
+                  }
+                  var hasUint8C = typeof Uint8ClampedArray !== "undefined";
+                  var hasBigUint64 = typeof BigUint64Array !== "undefined";
+                  var hasBigInt64 = typeof BigInt64Array !== "undefined";
+                  var POOL = __webpack_require__2.g.__TYPEDARRAY_POOL;
+                  if (!POOL.UINT8C) {
+                    POOL.UINT8C = dup([32, 0]);
+                  }
+                  if (!POOL.BIGUINT64) {
+                    POOL.BIGUINT64 = dup([32, 0]);
+                  }
+                  if (!POOL.BIGINT64) {
+                    POOL.BIGINT64 = dup([32, 0]);
+                  }
+                  if (!POOL.BUFFER) {
+                    POOL.BUFFER = dup([32, 0]);
+                  }
+                  var DATA = POOL.DATA, BUFFER = POOL.BUFFER;
+                  exports2.free = function free(array) {
+                    if (Buffer22.isBuffer(array)) {
+                      BUFFER[bits.log2(array.length)].push(array);
+                    } else {
+                      if (Object.prototype.toString.call(array) !== "[object ArrayBuffer]") {
+                        array = array.buffer;
+                      }
+                      if (!array) {
+                        return;
+                      }
+                      var n2 = array.length || array.byteLength;
+                      var log_n = bits.log2(n2) | 0;
+                      DATA[log_n].push(array);
+                    }
+                  };
+                  function freeArrayBuffer(buffer) {
+                    if (!buffer) {
+                      return;
+                    }
+                    var n2 = buffer.length || buffer.byteLength;
+                    var log_n = bits.log2(n2);
+                    DATA[log_n].push(buffer);
+                  }
+                  function freeTypedArray(array) {
+                    freeArrayBuffer(array.buffer);
+                  }
+                  exports2.freeUint8 = exports2.freeUint16 = exports2.freeUint32 = exports2.freeBigUint64 = exports2.freeInt8 = exports2.freeInt16 = exports2.freeInt32 = exports2.freeBigInt64 = exports2.freeFloat32 = exports2.freeFloat = exports2.freeFloat64 = exports2.freeDouble = exports2.freeUint8Clamped = exports2.freeDataView = freeTypedArray;
+                  exports2.freeArrayBuffer = freeArrayBuffer;
+                  exports2.freeBuffer = function freeBuffer(array) {
+                    BUFFER[bits.log2(array.length)].push(array);
+                  };
+                  exports2.malloc = function malloc(n2, dtype) {
+                    if (dtype === void 0 || dtype === "arraybuffer") {
+                      return mallocArrayBuffer(n2);
+                    } else {
+                      switch (dtype) {
+                        case "uint8":
+                          return mallocUint8(n2);
+                        case "uint16":
+                          return mallocUint16(n2);
+                        case "uint32":
+                          return mallocUint32(n2);
+                        case "int8":
+                          return mallocInt8(n2);
+                        case "int16":
+                          return mallocInt16(n2);
+                        case "int32":
+                          return mallocInt32(n2);
+                        case "float":
+                        case "float32":
+                          return mallocFloat(n2);
+                        case "double":
+                        case "float64":
+                          return mallocDouble(n2);
+                        case "uint8_clamped":
+                          return mallocUint8Clamped(n2);
+                        case "bigint64":
+                          return mallocBigInt64(n2);
+                        case "biguint64":
+                          return mallocBigUint64(n2);
+                        case "buffer":
+                          return mallocBuffer(n2);
+                        case "data":
+                        case "dataview":
+                          return mallocDataView(n2);
+                        default:
+                          return null;
+                      }
+                    }
+                    return null;
+                  };
+                  function mallocArrayBuffer(n2) {
+                    var n2 = bits.nextPow2(n2);
+                    var log_n = bits.log2(n2);
+                    var d2 = DATA[log_n];
+                    if (d2.length > 0) {
+                      return d2.pop();
+                    }
+                    return new ArrayBuffer(n2);
+                  }
+                  exports2.mallocArrayBuffer = mallocArrayBuffer;
+                  function mallocUint8(n2) {
+                    return new Uint8Array(mallocArrayBuffer(n2), 0, n2);
+                  }
+                  exports2.mallocUint8 = mallocUint8;
+                  function mallocUint16(n2) {
+                    return new Uint16Array(mallocArrayBuffer(2 * n2), 0, n2);
+                  }
+                  exports2.mallocUint16 = mallocUint16;
+                  function mallocUint32(n2) {
+                    return new Uint32Array(mallocArrayBuffer(4 * n2), 0, n2);
+                  }
+                  exports2.mallocUint32 = mallocUint32;
+                  function mallocInt8(n2) {
+                    return new Int8Array(mallocArrayBuffer(n2), 0, n2);
+                  }
+                  exports2.mallocInt8 = mallocInt8;
+                  function mallocInt16(n2) {
+                    return new Int16Array(mallocArrayBuffer(2 * n2), 0, n2);
+                  }
+                  exports2.mallocInt16 = mallocInt16;
+                  function mallocInt32(n2) {
+                    return new Int32Array(mallocArrayBuffer(4 * n2), 0, n2);
+                  }
+                  exports2.mallocInt32 = mallocInt32;
+                  function mallocFloat(n2) {
+                    return new Float32Array(mallocArrayBuffer(4 * n2), 0, n2);
+                  }
+                  exports2.mallocFloat32 = exports2.mallocFloat = mallocFloat;
+                  function mallocDouble(n2) {
+                    return new Float64Array(mallocArrayBuffer(8 * n2), 0, n2);
+                  }
+                  exports2.mallocFloat64 = exports2.mallocDouble = mallocDouble;
+                  function mallocUint8Clamped(n2) {
+                    if (hasUint8C) {
+                      return new Uint8ClampedArray(mallocArrayBuffer(n2), 0, n2);
+                    } else {
+                      return mallocUint8(n2);
+                    }
+                  }
+                  exports2.mallocUint8Clamped = mallocUint8Clamped;
+                  function mallocBigUint64(n2) {
+                    if (hasBigUint64) {
+                      return new BigUint64Array(mallocArrayBuffer(8 * n2), 0, n2);
+                    } else {
+                      return null;
+                    }
+                  }
+                  exports2.mallocBigUint64 = mallocBigUint64;
+                  function mallocBigInt64(n2) {
+                    if (hasBigInt64) {
+                      return new BigInt64Array(mallocArrayBuffer(8 * n2), 0, n2);
+                    } else {
+                      return null;
+                    }
+                  }
+                  exports2.mallocBigInt64 = mallocBigInt64;
+                  function mallocDataView(n2) {
+                    return new DataView(mallocArrayBuffer(n2), 0, n2);
+                  }
+                  exports2.mallocDataView = mallocDataView;
+                  function mallocBuffer(n2) {
+                    n2 = bits.nextPow2(n2);
+                    var log_n = bits.log2(n2);
+                    var cache = BUFFER[log_n];
+                    if (cache.length > 0) {
+                      return cache.pop();
+                    }
+                    return new Buffer22(n2);
+                  }
+                  exports2.mallocBuffer = mallocBuffer;
+                  exports2.clearCache = function clearCache() {
+                    for (var i2 = 0; i2 < 32; ++i2) {
+                      POOL.UINT8[i2].length = 0;
+                      POOL.UINT16[i2].length = 0;
+                      POOL.UINT32[i2].length = 0;
+                      POOL.INT8[i2].length = 0;
+                      POOL.INT16[i2].length = 0;
+                      POOL.INT32[i2].length = 0;
+                      POOL.FLOAT[i2].length = 0;
+                      POOL.DOUBLE[i2].length = 0;
+                      POOL.BIGUINT64[i2].length = 0;
+                      POOL.BIGINT64[i2].length = 0;
+                      POOL.UINT8C[i2].length = 0;
+                      DATA[i2].length = 0;
+                      BUFFER[i2].length = 0;
+                    }
+                  };
+                }
+              ),
+              /***/
+              1903: (
+                /***/
+                function(module22) {
+                  module22.exports = clone;
+                  function clone(a2) {
+                    var out = new Float32Array(16);
+                    out[0] = a2[0];
+                    out[1] = a2[1];
+                    out[2] = a2[2];
+                    out[3] = a2[3];
+                    out[4] = a2[4];
+                    out[5] = a2[5];
+                    out[6] = a2[6];
+                    out[7] = a2[7];
+                    out[8] = a2[8];
+                    out[9] = a2[9];
+                    out[10] = a2[10];
+                    out[11] = a2[11];
+                    out[12] = a2[12];
+                    out[13] = a2[13];
+                    out[14] = a2[14];
+                    out[15] = a2[15];
+                    return out;
+                  }
+                }
+              ),
+              /***/
+              1944: (
+                /***/
+                function(module22, __unused_webpack_exports, __webpack_require__2) {
+                  var twoProduct = __webpack_require__2(5250);
+                  var robustSum = __webpack_require__2(8210);
+                  module22.exports = robustDotProduct;
+                  function robustDotProduct(a2, b2) {
+                    var r2 = twoProduct(a2[0], b2[0]);
+                    for (var i2 = 1; i2 < a2.length; ++i2) {
+                      r2 = robustSum(r2, twoProduct(a2[i2], b2[i2]));
+                    }
+                    return r2;
+                  }
+                }
+              ),
+              /***/
+              1964: (
+                /***/
+                function(module22, __unused_webpack_exports, __webpack_require__2) {
+                  module22.exports = {
+                    alpha_shape: __webpack_require__2(3502),
+                    convex_hull: __webpack_require__2(7352),
+                    delaunay_triangulate: __webpack_require__2(7642),
+                    gl_cone3d: __webpack_require__2(6405),
+                    gl_error3d: __webpack_require__2(9165),
+                    gl_line3d: __webpack_require__2(5714),
+                    gl_mesh3d: __webpack_require__2(7201),
+                    gl_plot3d: __webpack_require__2(4100),
+                    gl_scatter3d: __webpack_require__2(8418),
+                    gl_streamtube3d: __webpack_require__2(7815),
+                    gl_surface3d: __webpack_require__2(9499),
+                    ndarray: __webpack_require__2(9618),
+                    ndarray_linear_interpolate: __webpack_require__2(4317)
+                  };
+                }
+              ),
+              /***/
+              2014: (
+                /***/
+                function(__unused_webpack_module, exports2, __webpack_require__2) {
+                  "use restrict";
+                  var bits = __webpack_require__2(3105), UnionFind = __webpack_require__2(4623);
+                  function dimension(cells) {
+                    var d2 = 0, max = Math.max;
+                    for (var i2 = 0, il2 = cells.length; i2 < il2; ++i2) {
+                      d2 = max(d2, cells[i2].length);
+                    }
+                    return d2 - 1;
+                  }
+                  exports2.dimension = dimension;
+                  function countVertices(cells) {
+                    var vc2 = -1, max = Math.max;
+                    for (var i2 = 0, il2 = cells.length; i2 < il2; ++i2) {
+                      var c2 = cells[i2];
+                      for (var j2 = 0, jl2 = c2.length; j2 < jl2; ++j2) {
+                        vc2 = max(vc2, c2[j2]);
+                      }
+                    }
+                    return vc2 + 1;
+                  }
+                  exports2.countVertices = countVertices;
+                  function cloneCells(cells) {
+                    var ncells = new Array(cells.length);
+                    for (var i2 = 0, il2 = cells.length; i2 < il2; ++i2) {
+                      ncells[i2] = cells[i2].slice(0);
+                    }
+                    return ncells;
+                  }
+                  exports2.cloneCells = cloneCells;
+                  function compareCells(a2, b2) {
+                    var n2 = a2.length, t4 = a2.length - b2.length, min = Math.min;
+                    if (t4) {
+                      return t4;
+                    }
+                    switch (n2) {
+                      case 0:
+                        return 0;
+                      case 1:
+                        return a2[0] - b2[0];
+                      case 2:
+                        var d2 = a2[0] + a2[1] - b2[0] - b2[1];
+                        if (d2) {
+                          return d2;
+                        }
+                        return min(a2[0], a2[1]) - min(b2[0], b2[1]);
+                      case 3:
+                        var l1 = a2[0] + a2[1], m1 = b2[0] + b2[1];
+                        d2 = l1 + a2[2] - (m1 + b2[2]);
+                        if (d2) {
+                          return d2;
+                        }
+                        var l0 = min(a2[0], a2[1]), m0 = min(b2[0], b2[1]), d2 = min(l0, a2[2]) - min(m0, b2[2]);
+                        if (d2) {
+                          return d2;
+                        }
+                        return min(l0 + a2[2], l1) - min(m0 + b2[2], m1);
+                      default:
+                        var as = a2.slice(0);
+                        as.sort();
+                        var bs = b2.slice(0);
+                        bs.sort();
+                        for (var i2 = 0; i2 < n2; ++i2) {
+                          t4 = as[i2] - bs[i2];
+                          if (t4) {
+                            return t4;
+                          }
+                        }
+                        return 0;
+                    }
+                  }
+                  exports2.compareCells = compareCells;
+                  function compareZipped(a2, b2) {
+                    return compareCells(a2[0], b2[0]);
+                  }
+                  function normalize(cells, attr) {
+                    if (attr) {
+                      var len2 = cells.length;
+                      var zipped = new Array(len2);
+                      for (var i2 = 0; i2 < len2; ++i2) {
+                        zipped[i2] = [cells[i2], attr[i2]];
+                      }
+                      zipped.sort(compareZipped);
+                      for (var i2 = 0; i2 < len2; ++i2) {
+                        cells[i2] = zipped[i2][0];
+                        attr[i2] = zipped[i2][1];
+                      }
+                      return cells;
+                    } else {
+                      cells.sort(compareCells);
+                      return cells;
+                    }
+                  }
+                  exports2.normalize = normalize;
+                  function unique(cells) {
+                    if (cells.length === 0) {
+                      return [];
+                    }
+                    var ptr = 1, len2 = cells.length;
+                    for (var i2 = 1; i2 < len2; ++i2) {
+                      var a2 = cells[i2];
+                      if (compareCells(a2, cells[i2 - 1])) {
+                        if (i2 === ptr) {
+                          ptr++;
+                          continue;
+                        }
+                        cells[ptr++] = a2;
+                      }
+                    }
+                    cells.length = ptr;
+                    return cells;
+                  }
+                  exports2.unique = unique;
+                  function findCell(cells, c2) {
+                    var lo = 0, hi2 = cells.length - 1, r2 = -1;
+                    while (lo <= hi2) {
+                      var mid = lo + hi2 >> 1, s2 = compareCells(cells[mid], c2);
+                      if (s2 <= 0) {
+                        if (s2 === 0) {
+                          r2 = mid;
+                        }
+                        lo = mid + 1;
+                      } else if (s2 > 0) {
+                        hi2 = mid - 1;
+                      }
+                    }
+                    return r2;
+                  }
+                  exports2.findCell = findCell;
+                  function incidence(from_cells, to_cells) {
+                    var index = new Array(from_cells.length);
+                    for (var i2 = 0, il2 = index.length; i2 < il2; ++i2) {
+                      index[i2] = [];
+                    }
+                    var b2 = [];
+                    for (var i2 = 0, n2 = to_cells.length; i2 < n2; ++i2) {
+                      var c2 = to_cells[i2];
+                      var cl2 = c2.length;
+                      for (var k2 = 1, kn = 1 << cl2; k2 < kn; ++k2) {
+                        b2.length = bits.popCount(k2);
+                        var l2 = 0;
+                        for (var j2 = 0; j2 < cl2; ++j2) {
+                          if (k2 & 1 << j2) {
+                            b2[l2++] = c2[j2];
+                          }
+                        }
+                        var idx = findCell(from_cells, b2);
+                        if (idx < 0) {
+                          continue;
+                        }
+                        while (true) {
+                          index[idx++].push(i2);
+                          if (idx >= from_cells.length || compareCells(from_cells[idx], b2) !== 0) {
+                            break;
+                          }
+                        }
+                      }
+                    }
+                    return index;
+                  }
+                  exports2.incidence = incidence;
+                  function dual(cells, vertex_count) {
+                    if (!vertex_count) {
+                      return incidence(unique(skeleton(cells, 0)), cells);
+                    }
+                    var res = new Array(vertex_count);
+                    for (var i2 = 0; i2 < vertex_count; ++i2) {
+                      res[i2] = [];
+                    }
+                    for (var i2 = 0, len2 = cells.length; i2 < len2; ++i2) {
+                      var c2 = cells[i2];
+                      for (var j2 = 0, cl2 = c2.length; j2 < cl2; ++j2) {
+                        res[c2[j2]].push(i2);
+                      }
+                    }
+                    return res;
+                  }
+                  exports2.dual = dual;
+                  function explode(cells) {
+                    var result = [];
+                    for (var i2 = 0, il2 = cells.length; i2 < il2; ++i2) {
+                      var c2 = cells[i2], cl2 = c2.length | 0;
+                      for (var j2 = 1, jl2 = 1 << cl2; j2 < jl2; ++j2) {
+                        var b2 = [];
+                        for (var k2 = 0; k2 < cl2; ++k2) {
+                          if (j2 >>> k2 & 1) {
+                            b2.push(c2[k2]);
+                          }
+                        }
+                        result.push(b2);
+                      }
+                    }
+                    return normalize(result);
+                  }
+                  exports2.explode = explode;
+                  function skeleton(cells, n2) {
+                    if (n2 < 0) {
+                      return [];
+                    }
+                    var result = [], k0 = (1 << n2 + 1) - 1;
+                    for (var i2 = 0; i2 < cells.length; ++i2) {
+                      var c2 = cells[i2];
+                      for (var k2 = k0; k2 < 1 << c2.length; k2 = bits.nextCombination(k2)) {
+                        var b2 = new Array(n2 + 1), l2 = 0;
+                        for (var j2 = 0; j2 < c2.length; ++j2) {
+                          if (k2 & 1 << j2) {
+                            b2[l2++] = c2[j2];
+                          }
+                        }
+                        result.push(b2);
+                      }
+                    }
+                    return normalize(result);
+                  }
+                  exports2.skeleton = skeleton;
+                  function boundary(cells) {
+                    var res = [];
+                    for (var i2 = 0, il2 = cells.length; i2 < il2; ++i2) {
+                      var c2 = cells[i2];
+                      for (var j2 = 0, cl2 = c2.length; j2 < cl2; ++j2) {
+                        var b2 = new Array(c2.length - 1);
+                        for (var k2 = 0, l2 = 0; k2 < cl2; ++k2) {
+                          if (k2 !== j2) {
+                            b2[l2++] = c2[k2];
+                          }
+                        }
+                        res.push(b2);
+                      }
+                    }
+                    return normalize(res);
+                  }
+                  exports2.boundary = boundary;
+                  function connectedComponents_dense(cells, vertex_count) {
+                    var labels = new UnionFind(vertex_count);
+                    for (var i2 = 0; i2 < cells.length; ++i2) {
+                      var c2 = cells[i2];
+                      for (var j2 = 0; j2 < c2.length; ++j2) {
+                        for (var k2 = j2 + 1; k2 < c2.length; ++k2) {
+                          labels.link(c2[j2], c2[k2]);
+                        }
+                      }
+                    }
+                    var components = [], component_labels = labels.ranks;
+                    for (var i2 = 0; i2 < component_labels.length; ++i2) {
+                      component_labels[i2] = -1;
+                    }
+                    for (var i2 = 0; i2 < cells.length; ++i2) {
+                      var l2 = labels.find(cells[i2][0]);
+                      if (component_labels[l2] < 0) {
+                        component_labels[l2] = components.length;
+                        components.push([cells[i2].slice(0)]);
+                      } else {
+                        components[component_labels[l2]].push(cells[i2].slice(0));
+                      }
+                    }
+                    return components;
+                  }
+                  function connectedComponents_sparse(cells) {
+                    var vertices = unique(normalize(skeleton(cells, 0))), labels = new UnionFind(vertices.length);
+                    for (var i2 = 0; i2 < cells.length; ++i2) {
+                      var c2 = cells[i2];
+                      for (var j2 = 0; j2 < c2.length; ++j2) {
+                        var vj2 = findCell(vertices, [c2[j2]]);
+                        for (var k2 = j2 + 1; k2 < c2.length; ++k2) {
+                          labels.link(vj2, findCell(vertices, [c2[k2]]));
+                        }
+                      }
+                    }
+                    var components = [], component_labels = labels.ranks;
+                    for (var i2 = 0; i2 < component_labels.length; ++i2) {
+                      component_labels[i2] = -1;
+                    }
+                    for (var i2 = 0; i2 < cells.length; ++i2) {
+                      var l2 = labels.find(findCell(vertices, [cells[i2][0]]));
+                      if (component_labels[l2] < 0) {
+                        component_labels[l2] = components.length;
+                        components.push([cells[i2].slice(0)]);
+                      } else {
+                        components[component_labels[l2]].push(cells[i2].slice(0));
+                      }
+                    }
+                    return components;
+                  }
+                  function connectedComponents(cells, vertex_count) {
+                    if (vertex_count) {
+                      return connectedComponents_dense(cells, vertex_count);
+                    }
+                    return connectedComponents_sparse(cells);
+                  }
+                  exports2.connectedComponents = connectedComponents;
+                }
+              ),
+              /***/
+              2095: (
+                /***/
+                function(module22, __unused_webpack_exports, __webpack_require__2) {
+                  module22.exports = planarGraphToPolyline;
+                  var e2a = __webpack_require__2(3134);
+                  var planarDual = __webpack_require__2(3088);
+                  var preprocessPolygon = __webpack_require__2(5085);
+                  var twoProduct = __webpack_require__2(5250);
+                  var robustSum = __webpack_require__2(8210);
+                  var uniq = __webpack_require__2(1682);
+                  var trimLeaves = __webpack_require__2(5609);
+                  function makeArray(length2, fill) {
+                    var result = new Array(length2);
+                    for (var i2 = 0; i2 < length2; ++i2) {
+                      result[i2] = fill;
+                    }
+                    return result;
+                  }
+                  function makeArrayOfArrays(length2) {
+                    var result = new Array(length2);
+                    for (var i2 = 0; i2 < length2; ++i2) {
+                      result[i2] = [];
+                    }
+                    return result;
+                  }
+                  function planarGraphToPolyline(edges, positions) {
+                    var result = trimLeaves(edges, positions);
+                    edges = result[0];
+                    positions = result[1];
+                    var numVertices = positions.length;
+                    edges.length;
+                    var adj = e2a(edges, positions.length);
+                    for (var i2 = 0; i2 < numVertices; ++i2) {
+                      if (adj[i2].length % 2 === 1) {
+                        throw new Error("planar-graph-to-polyline: graph must be manifold");
+                      }
+                    }
+                    var faces = planarDual(edges, positions);
+                    function ccw(c22) {
+                      var n22 = c22.length;
+                      var area = [0];
+                      for (var j22 = 0; j22 < n22; ++j22) {
+                        var a22 = positions[c22[j22]];
+                        var b22 = positions[c22[(j22 + 1) % n22]];
+                        var t00 = twoProduct(-a22[0], a22[1]);
+                        var t01 = twoProduct(-a22[0], b22[1]);
+                        var t10 = twoProduct(b22[0], a22[1]);
+                        var t11 = twoProduct(b22[0], b22[1]);
+                        area = robustSum(area, robustSum(robustSum(t00, t01), robustSum(t10, t11)));
+                      }
+                      return area[area.length - 1] > 0;
+                    }
+                    faces = faces.filter(ccw);
+                    var numFaces = faces.length;
+                    var parent = new Array(numFaces);
+                    var containment = new Array(numFaces);
+                    for (var i2 = 0; i2 < numFaces; ++i2) {
+                      parent[i2] = i2;
+                      var row = new Array(numFaces);
+                      var loopVertices = faces[i2].map(function(v2) {
+                        return positions[v2];
+                      });
+                      var pmc = preprocessPolygon([loopVertices]);
+                      var count2 = 0;
+                      outer:
+                        for (var j2 = 0; j2 < numFaces; ++j2) {
+                          row[j2] = 0;
+                          if (i2 === j2) {
+                            continue;
+                          }
+                          var c2 = faces[j2];
+                          var n2 = c2.length;
+                          for (var k2 = 0; k2 < n2; ++k2) {
+                            var d2 = pmc(positions[c2[k2]]);
+                            if (d2 !== 0) {
+                              if (d2 < 0) {
+                                row[j2] = 1;
+                                count2 += 1;
+                              }
+                              continue outer;
+                            }
+                          }
+                          row[j2] = 1;
+                          count2 += 1;
+                        }
+                      containment[i2] = [count2, i2, row];
+                    }
+                    containment.sort(function(a22, b22) {
+                      return b22[0] - a22[0];
+                    });
+                    for (var i2 = 0; i2 < numFaces; ++i2) {
+                      var row = containment[i2];
+                      var idx = row[1];
+                      var children = row[2];
+                      for (var j2 = 0; j2 < numFaces; ++j2) {
+                        if (children[j2]) {
+                          parent[j2] = idx;
+                        }
+                      }
+                    }
+                    var fadj = makeArrayOfArrays(numFaces);
+                    for (var i2 = 0; i2 < numFaces; ++i2) {
+                      fadj[i2].push(parent[i2]);
+                      fadj[parent[i2]].push(i2);
+                    }
+                    var edgeAdjacency = {};
+                    var internalVertices = makeArray(numVertices, false);
+                    for (var i2 = 0; i2 < numFaces; ++i2) {
+                      var c2 = faces[i2];
+                      var n2 = c2.length;
+                      for (var j2 = 0; j2 < n2; ++j2) {
+                        var a2 = c2[j2];
+                        var b2 = c2[(j2 + 1) % n2];
+                        var key = Math.min(a2, b2) + ":" + Math.max(a2, b2);
+                        if (key in edgeAdjacency) {
+                          var neighbor = edgeAdjacency[key];
+                          fadj[neighbor].push(i2);
+                          fadj[i2].push(neighbor);
+                          internalVertices[a2] = internalVertices[b2] = true;
+                        } else {
+                          edgeAdjacency[key] = i2;
+                        }
+                      }
+                    }
+                    function sharedBoundary(c22) {
+                      var n22 = c22.length;
+                      for (var i22 = 0; i22 < n22; ++i22) {
+                        if (!internalVertices[c22[i22]]) {
+                          return false;
+                        }
+                      }
+                      return true;
+                    }
+                    var toVisit = [];
+                    var parity = makeArray(numFaces, -1);
+                    for (var i2 = 0; i2 < numFaces; ++i2) {
+                      if (parent[i2] === i2 && !sharedBoundary(faces[i2])) {
+                        toVisit.push(i2);
+                        parity[i2] = 0;
+                      } else {
+                        parity[i2] = -1;
+                      }
+                    }
+                    var result = [];
+                    while (toVisit.length > 0) {
+                      var top = toVisit.pop();
+                      var nbhd = fadj[top];
+                      uniq(nbhd, function(a22, b22) {
+                        return a22 - b22;
+                      });
+                      var nnbhr = nbhd.length;
+                      var p2 = parity[top];
+                      var polyline;
+                      if (p2 === 0) {
+                        var c2 = faces[top];
+                        polyline = [c2];
+                      }
+                      for (var i2 = 0; i2 < nnbhr; ++i2) {
+                        var f2 = nbhd[i2];
+                        if (parity[f2] >= 0) {
+                          continue;
+                        }
+                        parity[f2] = p2 ^ 1;
+                        toVisit.push(f2);
+                        if (p2 === 0) {
+                          var c2 = faces[f2];
+                          if (!sharedBoundary(c2)) {
+                            c2.reverse();
+                            polyline.push(c2);
+                          }
+                        }
+                      }
+                      if (p2 === 0) {
+                        result.push(polyline);
+                      }
+                    }
+                    return result;
+                  }
+                }
+              ),
+              /***/
+              2145: (
+                /***/
+                function(__unused_webpack_module, exports2) {
+                  exports2.uniforms = runtimeUniforms;
+                  exports2.attributes = runtimeAttributes;
+                  var GL_TO_GLSL_TYPES = {
+                    "FLOAT": "float",
+                    "FLOAT_VEC2": "vec2",
+                    "FLOAT_VEC3": "vec3",
+                    "FLOAT_VEC4": "vec4",
+                    "INT": "int",
+                    "INT_VEC2": "ivec2",
+                    "INT_VEC3": "ivec3",
+                    "INT_VEC4": "ivec4",
+                    "BOOL": "bool",
+                    "BOOL_VEC2": "bvec2",
+                    "BOOL_VEC3": "bvec3",
+                    "BOOL_VEC4": "bvec4",
+                    "FLOAT_MAT2": "mat2",
+                    "FLOAT_MAT3": "mat3",
+                    "FLOAT_MAT4": "mat4",
+                    "SAMPLER_2D": "sampler2D",
+                    "SAMPLER_CUBE": "samplerCube"
+                  };
+                  var GL_TABLE = null;
+                  function getType2(gl2, type) {
+                    if (!GL_TABLE) {
+                      var typeNames = Object.keys(GL_TO_GLSL_TYPES);
+                      GL_TABLE = {};
+                      for (var i2 = 0; i2 < typeNames.length; ++i2) {
+                        var tn = typeNames[i2];
+                        GL_TABLE[gl2[tn]] = GL_TO_GLSL_TYPES[tn];
+                      }
+                    }
+                    return GL_TABLE[type];
+                  }
+                  function runtimeUniforms(gl2, program) {
+                    var numUniforms = gl2.getProgramParameter(program, gl2.ACTIVE_UNIFORMS);
+                    var result = [];
+                    for (var i2 = 0; i2 < numUniforms; ++i2) {
+                      var info = gl2.getActiveUniform(program, i2);
+                      if (info) {
+                        var type = getType2(gl2, info.type);
+                        if (info.size > 1) {
+                          for (var j2 = 0; j2 < info.size; ++j2) {
+                            result.push({
+                              name: info.name.replace("[0]", "[" + j2 + "]"),
+                              type
+                            });
+                          }
+                        } else {
+                          result.push({
+                            name: info.name,
+                            type
+                          });
+                        }
+                      }
+                    }
+                    return result;
+                  }
+                  function runtimeAttributes(gl2, program) {
+                    var numAttributes = gl2.getProgramParameter(program, gl2.ACTIVE_ATTRIBUTES);
+                    var result = [];
+                    for (var i2 = 0; i2 < numAttributes; ++i2) {
+                      var info = gl2.getActiveAttrib(program, i2);
+                      if (info) {
+                        result.push({
+                          name: info.name,
+                          type: getType2(gl2, info.type)
+                        });
+                      }
+                    }
+                    return result;
+                  }
+                }
+              ),
+              /***/
+              2229: (
+                /***/
+                function(module22, __unused_webpack_exports, __webpack_require__2) {
+                  module22.exports = __webpack_require__2(6843);
+                }
+              ),
+              /***/
+              2260: (
+                /***/
+                function(module22, __unused_webpack_exports, __webpack_require__2) {
+                  var createTexture2 = __webpack_require__2(7766);
+                  module22.exports = createFBO;
+                  var colorAttachmentArrays = null;
+                  var FRAMEBUFFER_UNSUPPORTED;
+                  var FRAMEBUFFER_INCOMPLETE_ATTACHMENT;
+                  var FRAMEBUFFER_INCOMPLETE_DIMENSIONS;
+                  var FRAMEBUFFER_INCOMPLETE_MISSING_ATTACHMENT;
+                  function saveFBOState(gl2) {
+                    var fbo = gl2.getParameter(gl2.FRAMEBUFFER_BINDING);
+                    var rbo = gl2.getParameter(gl2.RENDERBUFFER_BINDING);
+                    var tex = gl2.getParameter(gl2.TEXTURE_BINDING_2D);
+                    return [fbo, rbo, tex];
+                  }
+                  function restoreFBOState(gl2, data) {
+                    gl2.bindFramebuffer(gl2.FRAMEBUFFER, data[0]);
+                    gl2.bindRenderbuffer(gl2.RENDERBUFFER, data[1]);
+                    gl2.bindTexture(gl2.TEXTURE_2D, data[2]);
+                  }
+                  function lazyInitColorAttachments(gl2, ext) {
+                    var maxColorAttachments = gl2.getParameter(ext.MAX_COLOR_ATTACHMENTS_WEBGL);
+                    colorAttachmentArrays = new Array(maxColorAttachments + 1);
+                    for (var i2 = 0; i2 <= maxColorAttachments; ++i2) {
+                      var x2 = new Array(maxColorAttachments);
+                      for (var j2 = 0; j2 < i2; ++j2) {
+                        x2[j2] = gl2.COLOR_ATTACHMENT0 + j2;
+                      }
+                      for (var j2 = i2; j2 < maxColorAttachments; ++j2) {
+                        x2[j2] = gl2.NONE;
+                      }
+                      colorAttachmentArrays[i2] = x2;
+                    }
+                  }
+                  function throwFBOError(status) {
+                    switch (status) {
+                      case FRAMEBUFFER_UNSUPPORTED:
+                        throw new Error("gl-fbo: Framebuffer unsupported");
+                      case FRAMEBUFFER_INCOMPLETE_ATTACHMENT:
+                        throw new Error("gl-fbo: Framebuffer incomplete attachment");
+                      case FRAMEBUFFER_INCOMPLETE_DIMENSIONS:
+                        throw new Error("gl-fbo: Framebuffer incomplete dimensions");
+                      case FRAMEBUFFER_INCOMPLETE_MISSING_ATTACHMENT:
+                        throw new Error("gl-fbo: Framebuffer incomplete missing attachment");
+                      default:
+                        throw new Error("gl-fbo: Framebuffer failed for unspecified reason");
+                    }
+                  }
+                  function initTexture(gl2, width, height, type, format, attachment) {
+                    if (!type) {
+                      return null;
+                    }
+                    var result = createTexture2(gl2, width, height, format, type);
+                    result.magFilter = gl2.NEAREST;
+                    result.minFilter = gl2.NEAREST;
+                    result.mipSamples = 1;
+                    result.bind();
+                    gl2.framebufferTexture2D(gl2.FRAMEBUFFER, attachment, gl2.TEXTURE_2D, result.handle, 0);
+                    return result;
+                  }
+                  function initRenderBuffer(gl2, width, height, component, attachment) {
+                    var result = gl2.createRenderbuffer();
+                    gl2.bindRenderbuffer(gl2.RENDERBUFFER, result);
+                    gl2.renderbufferStorage(gl2.RENDERBUFFER, component, width, height);
+                    gl2.framebufferRenderbuffer(gl2.FRAMEBUFFER, attachment, gl2.RENDERBUFFER, result);
+                    return result;
+                  }
+                  function rebuildFBO(fbo) {
+                    var state = saveFBOState(fbo.gl);
+                    var gl2 = fbo.gl;
+                    var handle = fbo.handle = gl2.createFramebuffer();
+                    var width = fbo._shape[0];
+                    var height = fbo._shape[1];
+                    var numColors = fbo.color.length;
+                    var ext = fbo._ext;
+                    var useStencil = fbo._useStencil;
+                    var useDepth = fbo._useDepth;
+                    var colorType = fbo._colorType;
+                    gl2.bindFramebuffer(gl2.FRAMEBUFFER, handle);
+                    for (var i2 = 0; i2 < numColors; ++i2) {
+                      fbo.color[i2] = initTexture(gl2, width, height, colorType, gl2.RGBA, gl2.COLOR_ATTACHMENT0 + i2);
+                    }
+                    if (numColors === 0) {
+                      fbo._color_rb = initRenderBuffer(gl2, width, height, gl2.RGBA4, gl2.COLOR_ATTACHMENT0);
+                      if (ext) {
+                        ext.drawBuffersWEBGL(colorAttachmentArrays[0]);
+                      }
+                    } else if (numColors > 1) {
+                      ext.drawBuffersWEBGL(colorAttachmentArrays[numColors]);
+                    }
+                    var WEBGL_depth_texture = gl2.getExtension("WEBGL_depth_texture");
+                    if (WEBGL_depth_texture) {
+                      if (useStencil) {
+                        fbo.depth = initTexture(
+                          gl2,
+                          width,
+                          height,
+                          WEBGL_depth_texture.UNSIGNED_INT_24_8_WEBGL,
+                          gl2.DEPTH_STENCIL,
+                          gl2.DEPTH_STENCIL_ATTACHMENT
+                        );
+                      } else if (useDepth) {
+                        fbo.depth = initTexture(
+                          gl2,
+                          width,
+                          height,
+                          gl2.UNSIGNED_SHORT,
+                          gl2.DEPTH_COMPONENT,
+                          gl2.DEPTH_ATTACHMENT
+                        );
+                      }
+                    } else {
+                      if (useDepth && useStencil) {
+                        fbo._depth_rb = initRenderBuffer(gl2, width, height, gl2.DEPTH_STENCIL, gl2.DEPTH_STENCIL_ATTACHMENT);
+                      } else if (useDepth) {
+                        fbo._depth_rb = initRenderBuffer(gl2, width, height, gl2.DEPTH_COMPONENT16, gl2.DEPTH_ATTACHMENT);
+                      } else if (useStencil) {
+                        fbo._depth_rb = initRenderBuffer(gl2, width, height, gl2.STENCIL_INDEX, gl2.STENCIL_ATTACHMENT);
+                      }
+                    }
+                    var status = gl2.checkFramebufferStatus(gl2.FRAMEBUFFER);
+                    if (status !== gl2.FRAMEBUFFER_COMPLETE) {
+                      fbo._destroyed = true;
+                      gl2.bindFramebuffer(gl2.FRAMEBUFFER, null);
+                      gl2.deleteFramebuffer(fbo.handle);
+                      fbo.handle = null;
+                      if (fbo.depth) {
+                        fbo.depth.dispose();
+                        fbo.depth = null;
+                      }
+                      if (fbo._depth_rb) {
+                        gl2.deleteRenderbuffer(fbo._depth_rb);
+                        fbo._depth_rb = null;
+                      }
+                      for (var i2 = 0; i2 < fbo.color.length; ++i2) {
+                        fbo.color[i2].dispose();
+                        fbo.color[i2] = null;
+                      }
+                      if (fbo._color_rb) {
+                        gl2.deleteRenderbuffer(fbo._color_rb);
+                        fbo._color_rb = null;
+                      }
+                      restoreFBOState(gl2, state);
+                      throwFBOError(status);
+                    }
+                    restoreFBOState(gl2, state);
+                  }
+                  function Framebuffer2(gl2, width, height, colorType, numColors, useDepth, useStencil, ext) {
+                    this.gl = gl2;
+                    this._shape = [width | 0, height | 0];
+                    this._destroyed = false;
+                    this._ext = ext;
+                    this.color = new Array(numColors);
+                    for (var i2 = 0; i2 < numColors; ++i2) {
+                      this.color[i2] = null;
+                    }
+                    this._color_rb = null;
+                    this.depth = null;
+                    this._depth_rb = null;
+                    this._colorType = colorType;
+                    this._useDepth = useDepth;
+                    this._useStencil = useStencil;
+                    var parent = this;
+                    var shapeVector = [width | 0, height | 0];
+                    Object.defineProperties(shapeVector, {
+                      0: {
+                        get: function() {
+                          return parent._shape[0];
+                        },
+                        set: function(w2) {
+                          return parent.width = w2;
+                        }
+                      },
+                      1: {
+                        get: function() {
+                          return parent._shape[1];
+                        },
+                        set: function(h2) {
+                          return parent.height = h2;
+                        }
+                      }
+                    });
+                    this._shapeVector = shapeVector;
+                    rebuildFBO(this);
+                  }
+                  var proto = Framebuffer2.prototype;
+                  function reshapeFBO(fbo, w2, h2) {
+                    if (fbo._destroyed) {
+                      throw new Error("gl-fbo: Can't resize destroyed FBO");
+                    }
+                    if (fbo._shape[0] === w2 && fbo._shape[1] === h2) {
+                      return;
+                    }
+                    var gl2 = fbo.gl;
+                    var maxFBOSize = gl2.getParameter(gl2.MAX_RENDERBUFFER_SIZE);
+                    if (w2 < 0 || w2 > maxFBOSize || h2 < 0 || h2 > maxFBOSize) {
+                      throw new Error("gl-fbo: Can't resize FBO, invalid dimensions");
+                    }
+                    fbo._shape[0] = w2;
+                    fbo._shape[1] = h2;
+                    var state = saveFBOState(gl2);
+                    for (var i2 = 0; i2 < fbo.color.length; ++i2) {
+                      fbo.color[i2].shape = fbo._shape;
+                    }
+                    if (fbo._color_rb) {
+                      gl2.bindRenderbuffer(gl2.RENDERBUFFER, fbo._color_rb);
+                      gl2.renderbufferStorage(gl2.RENDERBUFFER, gl2.RGBA4, fbo._shape[0], fbo._shape[1]);
+                    }
+                    if (fbo.depth) {
+                      fbo.depth.shape = fbo._shape;
+                    }
+                    if (fbo._depth_rb) {
+                      gl2.bindRenderbuffer(gl2.RENDERBUFFER, fbo._depth_rb);
+                      if (fbo._useDepth && fbo._useStencil) {
+                        gl2.renderbufferStorage(gl2.RENDERBUFFER, gl2.DEPTH_STENCIL, fbo._shape[0], fbo._shape[1]);
+                      } else if (fbo._useDepth) {
+                        gl2.renderbufferStorage(gl2.RENDERBUFFER, gl2.DEPTH_COMPONENT16, fbo._shape[0], fbo._shape[1]);
+                      } else if (fbo._useStencil) {
+                        gl2.renderbufferStorage(gl2.RENDERBUFFER, gl2.STENCIL_INDEX, fbo._shape[0], fbo._shape[1]);
+                      }
+                    }
+                    gl2.bindFramebuffer(gl2.FRAMEBUFFER, fbo.handle);
+                    var status = gl2.checkFramebufferStatus(gl2.FRAMEBUFFER);
+                    if (status !== gl2.FRAMEBUFFER_COMPLETE) {
+                      fbo.dispose();
+                      restoreFBOState(gl2, state);
+                      throwFBOError(status);
+                    }
+                    restoreFBOState(gl2, state);
+                  }
+                  Object.defineProperties(proto, {
+                    "shape": {
+                      get: function() {
+                        if (this._destroyed) {
+                          return [0, 0];
+                        }
+                        return this._shapeVector;
+                      },
+                      set: function(x2) {
+                        if (!Array.isArray(x2)) {
+                          x2 = [x2 | 0, x2 | 0];
+                        }
+                        if (x2.length !== 2) {
+                          throw new Error("gl-fbo: Shape vector must be length 2");
+                        }
+                        var w2 = x2[0] | 0;
+                        var h2 = x2[1] | 0;
+                        reshapeFBO(this, w2, h2);
+                        return [w2, h2];
+                      },
+                      enumerable: false
+                    },
+                    "width": {
+                      get: function() {
+                        if (this._destroyed) {
+                          return 0;
+                        }
+                        return this._shape[0];
+                      },
+                      set: function(w2) {
+                        w2 = w2 | 0;
+                        reshapeFBO(this, w2, this._shape[1]);
+                        return w2;
+                      },
+                      enumerable: false
+                    },
+                    "height": {
+                      get: function() {
+                        if (this._destroyed) {
+                          return 0;
+                        }
+                        return this._shape[1];
+                      },
+                      set: function(h2) {
+                        h2 = h2 | 0;
+                        reshapeFBO(this, this._shape[0], h2);
+                        return h2;
+                      },
+                      enumerable: false
+                    }
+                  });
+                  proto.bind = function() {
+                    if (this._destroyed) {
+                      return;
+                    }
+                    var gl2 = this.gl;
+                    gl2.bindFramebuffer(gl2.FRAMEBUFFER, this.handle);
+                    gl2.viewport(0, 0, this._shape[0], this._shape[1]);
+                  };
+                  proto.dispose = function() {
+                    if (this._destroyed) {
+                      return;
+                    }
+                    this._destroyed = true;
+                    var gl2 = this.gl;
+                    gl2.deleteFramebuffer(this.handle);
+                    this.handle = null;
+                    if (this.depth) {
+                      this.depth.dispose();
+                      this.depth = null;
+                    }
+                    if (this._depth_rb) {
+                      gl2.deleteRenderbuffer(this._depth_rb);
+                      this._depth_rb = null;
+                    }
+                    for (var i2 = 0; i2 < this.color.length; ++i2) {
+                      this.color[i2].dispose();
+                      this.color[i2] = null;
+                    }
+                    if (this._color_rb) {
+                      gl2.deleteRenderbuffer(this._color_rb);
+                      this._color_rb = null;
+                    }
+                  };
+                  function createFBO(gl2, width, height, options) {
+                    if (!FRAMEBUFFER_UNSUPPORTED) {
+                      FRAMEBUFFER_UNSUPPORTED = gl2.FRAMEBUFFER_UNSUPPORTED;
+                      FRAMEBUFFER_INCOMPLETE_ATTACHMENT = gl2.FRAMEBUFFER_INCOMPLETE_ATTACHMENT;
+                      FRAMEBUFFER_INCOMPLETE_DIMENSIONS = gl2.FRAMEBUFFER_INCOMPLETE_DIMENSIONS;
+                      FRAMEBUFFER_INCOMPLETE_MISSING_ATTACHMENT = gl2.FRAMEBUFFER_INCOMPLETE_MISSING_ATTACHMENT;
+                    }
+                    var WEBGL_draw_buffers = gl2.getExtension("WEBGL_draw_buffers");
+                    if (!colorAttachmentArrays && WEBGL_draw_buffers) {
+                      lazyInitColorAttachments(gl2, WEBGL_draw_buffers);
+                    }
+                    if (Array.isArray(width)) {
+                      options = height;
+                      height = width[1] | 0;
+                      width = width[0] | 0;
+                    }
+                    if (typeof width !== "number") {
+                      throw new Error("gl-fbo: Missing shape parameter");
+                    }
+                    var maxFBOSize = gl2.getParameter(gl2.MAX_RENDERBUFFER_SIZE);
+                    if (width < 0 || width > maxFBOSize || height < 0 || height > maxFBOSize) {
+                      throw new Error("gl-fbo: Parameters are too large for FBO");
+                    }
+                    options = options || {};
+                    var numColors = 1;
+                    if ("color" in options) {
+                      numColors = Math.max(options.color | 0, 0);
+                      if (numColors < 0) {
+                        throw new Error("gl-fbo: Must specify a nonnegative number of colors");
+                      }
+                      if (numColors > 1) {
+                        if (!WEBGL_draw_buffers) {
+                          throw new Error("gl-fbo: Multiple draw buffer extension not supported");
+                        } else if (numColors > gl2.getParameter(WEBGL_draw_buffers.MAX_COLOR_ATTACHMENTS_WEBGL)) {
+                          throw new Error("gl-fbo: Context does not support " + numColors + " draw buffers");
+                        }
+                      }
+                    }
+                    var colorType = gl2.UNSIGNED_BYTE;
+                    var OES_texture_float = gl2.getExtension("OES_texture_float");
+                    if (options.float && numColors > 0) {
+                      if (!OES_texture_float) {
+                        throw new Error("gl-fbo: Context does not support floating point textures");
+                      }
+                      colorType = gl2.FLOAT;
+                    } else if (options.preferFloat && numColors > 0) {
+                      if (OES_texture_float) {
+                        colorType = gl2.FLOAT;
+                      }
+                    }
+                    var useDepth = true;
+                    if ("depth" in options) {
+                      useDepth = !!options.depth;
+                    }
+                    var useStencil = false;
+                    if ("stencil" in options) {
+                      useStencil = !!options.stencil;
+                    }
+                    return new Framebuffer2(
+                      gl2,
+                      width,
+                      height,
+                      colorType,
+                      numColors,
+                      useDepth,
+                      useStencil,
+                      WEBGL_draw_buffers
+                    );
+                  }
+                }
+              ),
+              /***/
+              2272: (
+                /***/
+                function(module22, __unused_webpack_exports, __webpack_require__2) {
+                  var inCircle = __webpack_require__2(2646)[4];
+                  __webpack_require__2(2478);
+                  module22.exports = delaunayRefine;
+                  function testFlip(points, triangulation, stack, a2, b2, x2) {
+                    var y2 = triangulation.opposite(a2, b2);
+                    if (y2 < 0) {
+                      return;
+                    }
+                    if (b2 < a2) {
+                      var tmp2 = a2;
+                      a2 = b2;
+                      b2 = tmp2;
+                      tmp2 = x2;
+                      x2 = y2;
+                      y2 = tmp2;
+                    }
+                    if (triangulation.isConstraint(a2, b2)) {
+                      return;
+                    }
+                    if (inCircle(points[a2], points[b2], points[x2], points[y2]) < 0) {
+                      stack.push(a2, b2);
+                    }
+                  }
+                  function delaunayRefine(points, triangulation) {
+                    var stack = [];
+                    var numPoints = points.length;
+                    var stars = triangulation.stars;
+                    for (var a2 = 0; a2 < numPoints; ++a2) {
+                      var star = stars[a2];
+                      for (var j2 = 1; j2 < star.length; j2 += 2) {
+                        var b2 = star[j2];
+                        if (b2 < a2) {
+                          continue;
+                        }
+                        if (triangulation.isConstraint(a2, b2)) {
+                          continue;
+                        }
+                        var x2 = star[j2 - 1], y2 = -1;
+                        for (var k2 = 1; k2 < star.length; k2 += 2) {
+                          if (star[k2 - 1] === b2) {
+                            y2 = star[k2];
+                            break;
+                          }
+                        }
+                        if (y2 < 0) {
+                          continue;
+                        }
+                        if (inCircle(points[a2], points[b2], points[x2], points[y2]) < 0) {
+                          stack.push(a2, b2);
+                        }
+                      }
+                    }
+                    while (stack.length > 0) {
+                      var b2 = stack.pop();
+                      var a2 = stack.pop();
+                      var x2 = -1, y2 = -1;
+                      var star = stars[a2];
+                      for (var i2 = 1; i2 < star.length; i2 += 2) {
+                        var s2 = star[i2 - 1];
+                        var t4 = star[i2];
+                        if (s2 === b2) {
+                          y2 = t4;
+                        } else if (t4 === b2) {
+                          x2 = s2;
+                        }
+                      }
+                      if (x2 < 0 || y2 < 0) {
+                        continue;
+                      }
+                      if (inCircle(points[a2], points[b2], points[x2], points[y2]) >= 0) {
+                        continue;
+                      }
+                      triangulation.flip(a2, b2);
+                      testFlip(points, triangulation, stack, x2, a2, y2);
+                      testFlip(points, triangulation, stack, a2, y2, x2);
+                      testFlip(points, triangulation, stack, y2, b2, x2);
+                      testFlip(points, triangulation, stack, b2, x2, y2);
+                    }
+                  }
+                }
+              ),
+              /***/
+              2334: (
+                /***/
+                function(module22) {
+                  module22.exports = min;
+                  function min(out, a2, b2) {
+                    out[0] = Math.min(a2[0], b2[0]);
+                    out[1] = Math.min(a2[1], b2[1]);
+                    out[2] = Math.min(a2[2], b2[2]);
+                    out[3] = Math.min(a2[3], b2[3]);
+                    return out;
+                  }
+                }
+              ),
+              /***/
+              2335: (
+                /***/
+                function(module22) {
+                  module22.exports = clone;
+                  function clone(a2) {
+                    var out = new Float32Array(4);
+                    out[0] = a2[0];
+                    out[1] = a2[1];
+                    out[2] = a2[2];
+                    out[3] = a2[3];
+                    return out;
+                  }
+                }
+              ),
+              /***/
+              2361: (
+                /***/
+                function(module22) {
+                  var hasTypedArrays = false;
+                  if (typeof Float64Array !== "undefined") {
+                    var DOUBLE_VIEW = new Float64Array(1), UINT_VIEW = new Uint32Array(DOUBLE_VIEW.buffer);
+                    DOUBLE_VIEW[0] = 1;
+                    hasTypedArrays = true;
+                    if (UINT_VIEW[1] === 1072693248) {
+                      let toDoubleLE2 = function(lo, hi2) {
+                        UINT_VIEW[0] = lo;
+                        UINT_VIEW[1] = hi2;
+                        return DOUBLE_VIEW[0];
+                      }, lowUintLE2 = function(n2) {
+                        DOUBLE_VIEW[0] = n2;
+                        return UINT_VIEW[0];
+                      }, highUintLE2 = function(n2) {
+                        DOUBLE_VIEW[0] = n2;
+                        return UINT_VIEW[1];
+                      };
+                      module22.exports = function doubleBitsLE(n2) {
+                        DOUBLE_VIEW[0] = n2;
+                        return [UINT_VIEW[0], UINT_VIEW[1]];
+                      };
+                      module22.exports.pack = toDoubleLE2;
+                      module22.exports.lo = lowUintLE2;
+                      module22.exports.hi = highUintLE2;
+                    } else if (UINT_VIEW[0] === 1072693248) {
+                      let toDoubleBE2 = function(lo, hi2) {
+                        UINT_VIEW[1] = lo;
+                        UINT_VIEW[0] = hi2;
+                        return DOUBLE_VIEW[0];
+                      }, lowUintBE2 = function(n2) {
+                        DOUBLE_VIEW[0] = n2;
+                        return UINT_VIEW[1];
+                      }, highUintBE2 = function(n2) {
+                        DOUBLE_VIEW[0] = n2;
+                        return UINT_VIEW[0];
+                      };
+                      module22.exports = function doubleBitsBE(n2) {
+                        DOUBLE_VIEW[0] = n2;
+                        return [UINT_VIEW[1], UINT_VIEW[0]];
+                      };
+                      module22.exports.pack = toDoubleBE2;
+                      module22.exports.lo = lowUintBE2;
+                      module22.exports.hi = highUintBE2;
+                    } else {
+                      hasTypedArrays = false;
+                    }
+                  }
+                  if (!hasTypedArrays) {
+                    let toDouble2 = function(lo, hi2) {
+                      buffer.writeUInt32LE(lo, 0, true);
+                      buffer.writeUInt32LE(hi2, 4, true);
+                      return buffer.readDoubleLE(0, true);
+                    }, lowUint2 = function(n2) {
+                      buffer.writeDoubleLE(n2, 0, true);
+                      return buffer.readUInt32LE(0, true);
+                    }, highUint2 = function(n2) {
+                      buffer.writeDoubleLE(n2, 0, true);
+                      return buffer.readUInt32LE(4, true);
+                    };
+                    var buffer = new Buffer(8);
+                    module22.exports = function doubleBits(n2) {
+                      buffer.writeDoubleLE(n2, 0, true);
+                      return [buffer.readUInt32LE(0, true), buffer.readUInt32LE(4, true)];
+                    };
+                    module22.exports.pack = toDouble2;
+                    module22.exports.lo = lowUint2;
+                    module22.exports.hi = highUint2;
+                  }
+                  module22.exports.sign = function(n2) {
+                    return module22.exports.hi(n2) >>> 31;
+                  };
+                  module22.exports.exponent = function(n2) {
+                    var b2 = module22.exports.hi(n2);
+                    return (b2 << 1 >>> 21) - 1023;
+                  };
+                  module22.exports.fraction = function(n2) {
+                    var lo = module22.exports.lo(n2);
+                    var hi2 = module22.exports.hi(n2);
+                    var b2 = hi2 & (1 << 20) - 1;
+                    if (hi2 & 2146435072) {
+                      b2 += 1 << 20;
+                    }
+                    return [lo, b2];
+                  };
+                  module22.exports.denormalized = function(n2) {
+                    var hi2 = module22.exports.hi(n2);
+                    return !(hi2 & 2146435072);
+                  };
+                }
+              ),
+              /***/
+              2408: (
+                /***/
+                function(module22) {
+                  module22.exports = rotateY2;
+                  function rotateY2(out, a2, rad) {
+                    var s2 = Math.sin(rad), c2 = Math.cos(rad), a00 = a2[0], a01 = a2[1], a02 = a2[2], a03 = a2[3], a20 = a2[8], a21 = a2[9], a22 = a2[10], a23 = a2[11];
+                    if (a2 !== out) {
+                      out[4] = a2[4];
+                      out[5] = a2[5];
+                      out[6] = a2[6];
+                      out[7] = a2[7];
+                      out[12] = a2[12];
+                      out[13] = a2[13];
+                      out[14] = a2[14];
+                      out[15] = a2[15];
+                    }
+                    out[0] = a00 * c2 - a20 * s2;
+                    out[1] = a01 * c2 - a21 * s2;
+                    out[2] = a02 * c2 - a22 * s2;
+                    out[3] = a03 * c2 - a23 * s2;
+                    out[8] = a00 * s2 + a20 * c2;
+                    out[9] = a01 * s2 + a21 * c2;
+                    out[10] = a02 * s2 + a22 * c2;
+                    out[11] = a03 * s2 + a23 * c2;
+                    return out;
+                  }
+                }
+              ),
+              /***/
+              2419: (
+                /***/
+                function(module22) {
+                  module22.exports = orientation;
+                  function orientation(s2) {
+                    var p2 = 1;
+                    for (var i2 = 1; i2 < s2.length; ++i2) {
+                      for (var j2 = 0; j2 < i2; ++j2) {
+                        if (s2[i2] < s2[j2]) {
+                          p2 = -p2;
+                        } else if (s2[j2] === s2[i2]) {
+                          return 0;
+                        }
+                      }
+                    }
+                    return p2;
+                  }
+                }
+              ),
+              /***/
+              2447: (
+                /***/
+                function(module22) {
+                  module22.exports = round2;
+                  function round2(out, a2) {
+                    out[0] = Math.round(a2[0]);
+                    out[1] = Math.round(a2[1]);
+                    out[2] = Math.round(a2[2]);
+                    return out;
+                  }
+                }
+              ),
+              /***/
+              2455: (
+                /***/
+                function(__unused_webpack_module, exports2) {
+                  function full() {
+                    function bruteForceRedFull(d2, ax, vv, rs, re2, rb2, ri2, bs, be2, bb2, bi2) {
+                      var es = 2 * d2;
+                      for (var i2 = rs, rp = es * rs; i2 < re2; ++i2, rp += es) {
+                        var x0 = rb2[ax + rp], x1 = rb2[ax + rp + d2], xi2 = ri2[i2];
+                        Q: for (var j2 = bs, bp = es * bs; j2 < be2; ++j2, bp += es) {
+                          var y0 = bb2[ax + bp], y1 = bb2[ax + bp + d2], yi2 = bi2[j2];
+                          if (y1 < x0 || x1 < y0) continue;
+                          for (var k2 = ax + 1; k2 < d2; ++k2) {
+                            var r0 = rb2[k2 + rp], r1 = rb2[k2 + d2 + rp], b0 = bb2[k2 + bp], b1 = bb2[k2 + d2 + bp];
+                            if (r1 < b0 || b1 < r0) continue Q;
+                          }
+                          var rv = vv(xi2, yi2);
+                          if (rv !== void 0) return rv;
+                        }
+                      }
+                    }
+                    function bruteForceBlueFull(d2, ax, vv, rs, re2, rb2, ri2, bs, be2, bb2, bi2) {
+                      var es = 2 * d2;
+                      for (var j2 = bs, bp = es * bs; j2 < be2; ++j2, bp += es) {
+                        var y0 = bb2[ax + bp], y1 = bb2[ax + bp + d2], yi2 = bi2[j2];
+                        Q: for (var i2 = rs, rp = es * rs; i2 < re2; ++i2, rp += es) {
+                          var x0 = rb2[ax + rp], x1 = rb2[ax + rp + d2], xi2 = ri2[i2];
+                          if (y1 < x0 || x1 < y0) continue;
+                          for (var k2 = ax + 1; k2 < d2; ++k2) {
+                            var r0 = rb2[k2 + rp], r1 = rb2[k2 + d2 + rp], b0 = bb2[k2 + bp], b1 = bb2[k2 + d2 + bp];
+                            if (r1 < b0 || b1 < r0) continue Q;
+                          }
+                          var rv = vv(xi2, yi2);
+                          if (rv !== void 0) return rv;
+                        }
+                      }
+                    }
+                    function bruteForceFull(d2, ax, vv, rs, re2, rb2, ri2, bs, be2, bb2, bi2) {
+                      if (re2 - rs > be2 - bs) {
+                        return bruteForceRedFull(d2, ax, vv, rs, re2, rb2, ri2, bs, be2, bb2, bi2);
+                      } else {
+                        return bruteForceBlueFull(d2, ax, vv, rs, re2, rb2, ri2, bs, be2, bb2, bi2);
+                      }
+                    }
+                    return bruteForceFull;
+                  }
+                  function partial() {
+                    function bruteForceRedFlip(d2, ax, vv, rs, re2, rb2, ri2, bs, be2, bb2, bi2) {
+                      var es = 2 * d2;
+                      for (var i2 = rs, rp = es * rs; i2 < re2; ++i2, rp += es) {
+                        var x0 = rb2[ax + rp], x1 = rb2[ax + rp + d2], xi2 = ri2[i2];
+                        Q: for (var j2 = bs, bp = es * bs; j2 < be2; ++j2, bp += es) {
+                          var y0 = bb2[ax + bp], yi2 = bi2[j2];
+                          if (y0 <= x0 || x1 < y0) continue;
+                          for (var k2 = ax + 1; k2 < d2; ++k2) {
+                            var r0 = rb2[k2 + rp], r1 = rb2[k2 + d2 + rp], b0 = bb2[k2 + bp], b1 = bb2[k2 + d2 + bp];
+                            if (r1 < b0 || b1 < r0) continue Q;
+                          }
+                          var rv = vv(yi2, xi2);
+                          if (rv !== void 0) return rv;
+                        }
+                      }
+                    }
+                    function bruteForceRed(d2, ax, vv, rs, re2, rb2, ri2, bs, be2, bb2, bi2) {
+                      var es = 2 * d2;
+                      for (var i2 = rs, rp = es * rs; i2 < re2; ++i2, rp += es) {
+                        var x0 = rb2[ax + rp], x1 = rb2[ax + rp + d2], xi2 = ri2[i2];
+                        Q: for (var j2 = bs, bp = es * bs; j2 < be2; ++j2, bp += es) {
+                          var y0 = bb2[ax + bp], yi2 = bi2[j2];
+                          if (y0 < x0 || x1 < y0) continue;
+                          for (var k2 = ax + 1; k2 < d2; ++k2) {
+                            var r0 = rb2[k2 + rp], r1 = rb2[k2 + d2 + rp], b0 = bb2[k2 + bp], b1 = bb2[k2 + d2 + bp];
+                            if (r1 < b0 || b1 < r0) continue Q;
+                          }
+                          var rv = vv(xi2, yi2);
+                          if (rv !== void 0) return rv;
+                        }
+                      }
+                    }
+                    function bruteForceBlueFlip(d2, ax, vv, rs, re2, rb2, ri2, bs, be2, bb2, bi2) {
+                      var es = 2 * d2;
+                      for (var j2 = bs, bp = es * bs; j2 < be2; ++j2, bp += es) {
+                        var y0 = bb2[ax + bp], yi2 = bi2[j2];
+                        Q: for (var i2 = rs, rp = es * rs; i2 < re2; ++i2, rp += es) {
+                          var x0 = rb2[ax + rp], x1 = rb2[ax + rp + d2], xi2 = ri2[i2];
+                          if (y0 <= x0 || x1 < y0) continue;
+                          for (var k2 = ax + 1; k2 < d2; ++k2) {
+                            var r0 = rb2[k2 + rp], r1 = rb2[k2 + d2 + rp], b0 = bb2[k2 + bp], b1 = bb2[k2 + d2 + bp];
+                            if (r1 < b0 || b1 < r0) continue Q;
+                          }
+                          var rv = vv(yi2, xi2);
+                          if (rv !== void 0) return rv;
+                        }
+                      }
+                    }
+                    function bruteForceBlue(d2, ax, vv, rs, re2, rb2, ri2, bs, be2, bb2, bi2) {
+                      var es = 2 * d2;
+                      for (var j2 = bs, bp = es * bs; j2 < be2; ++j2, bp += es) {
+                        var y0 = bb2[ax + bp], yi2 = bi2[j2];
+                        Q: for (var i2 = rs, rp = es * rs; i2 < re2; ++i2, rp += es) {
+                          var x0 = rb2[ax + rp], x1 = rb2[ax + rp + d2], xi2 = ri2[i2];
+                          if (y0 < x0 || x1 < y0) continue;
+                          for (var k2 = ax + 1; k2 < d2; ++k2) {
+                            var r0 = rb2[k2 + rp], r1 = rb2[k2 + d2 + rp], b0 = bb2[k2 + bp], b1 = bb2[k2 + d2 + bp];
+                            if (r1 < b0 || b1 < r0) continue Q;
+                          }
+                          var rv = vv(xi2, yi2);
+                          if (rv !== void 0) return rv;
+                        }
+                      }
+                    }
+                    function bruteForcePartial(d2, ax, vv, fp, rs, re2, rb2, ri2, bs, be2, bb2, bi2) {
+                      if (re2 - rs > be2 - bs) {
+                        if (fp) {
+                          return bruteForceRedFlip(d2, ax, vv, rs, re2, rb2, ri2, bs, be2, bb2, bi2);
+                        } else {
+                          return bruteForceRed(d2, ax, vv, rs, re2, rb2, ri2, bs, be2, bb2, bi2);
+                        }
+                      } else {
+                        if (fp) {
+                          return bruteForceBlueFlip(d2, ax, vv, rs, re2, rb2, ri2, bs, be2, bb2, bi2);
+                        } else {
+                          return bruteForceBlue(d2, ax, vv, rs, re2, rb2, ri2, bs, be2, bb2, bi2);
+                        }
+                      }
+                    }
+                    return bruteForcePartial;
+                  }
+                  function bruteForcePlanner(isFull) {
+                    return isFull ? full() : partial();
+                  }
+                  exports2.partial = bruteForcePlanner(false);
+                  exports2.full = bruteForcePlanner(true);
+                }
+              ),
+              /***/
+              2478: (
+                /***/
+                function(module22) {
+                  function ge2(a2, y2, c2, l2, h2) {
+                    var i2 = h2 + 1;
+                    while (l2 <= h2) {
+                      var m2 = l2 + h2 >>> 1, x2 = a2[m2];
+                      var p2 = c2 !== void 0 ? c2(x2, y2) : x2 - y2;
+                      if (p2 >= 0) {
+                        i2 = m2;
+                        h2 = m2 - 1;
+                      } else {
+                        l2 = m2 + 1;
+                      }
+                    }
+                    return i2;
+                  }
+                  function gt2(a2, y2, c2, l2, h2) {
+                    var i2 = h2 + 1;
+                    while (l2 <= h2) {
+                      var m2 = l2 + h2 >>> 1, x2 = a2[m2];
+                      var p2 = c2 !== void 0 ? c2(x2, y2) : x2 - y2;
+                      if (p2 > 0) {
+                        i2 = m2;
+                        h2 = m2 - 1;
+                      } else {
+                        l2 = m2 + 1;
+                      }
+                    }
+                    return i2;
+                  }
+                  function lt2(a2, y2, c2, l2, h2) {
+                    var i2 = l2 - 1;
+                    while (l2 <= h2) {
+                      var m2 = l2 + h2 >>> 1, x2 = a2[m2];
+                      var p2 = c2 !== void 0 ? c2(x2, y2) : x2 - y2;
+                      if (p2 < 0) {
+                        i2 = m2;
+                        l2 = m2 + 1;
+                      } else {
+                        h2 = m2 - 1;
+                      }
+                    }
+                    return i2;
+                  }
+                  function le2(a2, y2, c2, l2, h2) {
+                    var i2 = l2 - 1;
+                    while (l2 <= h2) {
+                      var m2 = l2 + h2 >>> 1, x2 = a2[m2];
+                      var p2 = c2 !== void 0 ? c2(x2, y2) : x2 - y2;
+                      if (p2 <= 0) {
+                        i2 = m2;
+                        l2 = m2 + 1;
+                      } else {
+                        h2 = m2 - 1;
+                      }
+                    }
+                    return i2;
+                  }
+                  function eq(a2, y2, c2, l2, h2) {
+                    while (l2 <= h2) {
+                      var m2 = l2 + h2 >>> 1, x2 = a2[m2];
+                      var p2 = c2 !== void 0 ? c2(x2, y2) : x2 - y2;
+                      if (p2 === 0) {
+                        return m2;
+                      }
+                      if (p2 <= 0) {
+                        l2 = m2 + 1;
+                      } else {
+                        h2 = m2 - 1;
+                      }
+                    }
+                    return -1;
+                  }
+                  function norm(a2, y2, c2, l2, h2, f2) {
+                    if (typeof c2 === "function") {
+                      return f2(a2, y2, c2, l2 === void 0 ? 0 : l2 | 0, h2 === void 0 ? a2.length - 1 : h2 | 0);
+                    }
+                    return f2(a2, y2, void 0, c2 === void 0 ? 0 : c2 | 0, l2 === void 0 ? a2.length - 1 : l2 | 0);
+                  }
+                  module22.exports = {
+                    ge: function(a2, y2, c2, l2, h2) {
+                      return norm(a2, y2, c2, l2, h2, ge2);
+                    },
+                    gt: function(a2, y2, c2, l2, h2) {
+                      return norm(a2, y2, c2, l2, h2, gt2);
+                    },
+                    lt: function(a2, y2, c2, l2, h2) {
+                      return norm(a2, y2, c2, l2, h2, lt2);
+                    },
+                    le: function(a2, y2, c2, l2, h2) {
+                      return norm(a2, y2, c2, l2, h2, le2);
+                    },
+                    eq: function(a2, y2, c2, l2, h2) {
+                      return norm(a2, y2, c2, l2, h2, eq);
+                    }
+                  };
+                }
+              ),
+              /***/
+              2504: (
+                /***/
+                function(module22) {
+                  module22.exports = scale2;
+                  function scale2(out, a2, v2) {
+                    var x2 = v2[0], y2 = v2[1], z2 = v2[2];
+                    out[0] = a2[0] * x2;
+                    out[1] = a2[1] * x2;
+                    out[2] = a2[2] * x2;
+                    out[3] = a2[3] * x2;
+                    out[4] = a2[4] * y2;
+                    out[5] = a2[5] * y2;
+                    out[6] = a2[6] * y2;
+                    out[7] = a2[7] * y2;
+                    out[8] = a2[8] * z2;
+                    out[9] = a2[9] * z2;
+                    out[10] = a2[10] * z2;
+                    out[11] = a2[11] * z2;
+                    out[12] = a2[12];
+                    out[13] = a2[13];
+                    out[14] = a2[14];
+                    out[15] = a2[15];
+                    return out;
+                  }
+                }
+              ),
+              /***/
+              2538: (
+                /***/
+                function(module22, __unused_webpack_exports, __webpack_require__2) {
+                  var monotoneTriangulate = __webpack_require__2(8902);
+                  var makeIndex = __webpack_require__2(5542);
+                  var delaunayFlip = __webpack_require__2(2272);
+                  var filterTriangulation = __webpack_require__2(5023);
+                  module22.exports = cdt2d;
+                  function canonicalizeEdge(e2) {
+                    return [Math.min(e2[0], e2[1]), Math.max(e2[0], e2[1])];
+                  }
+                  function compareEdge(a2, b2) {
+                    return a2[0] - b2[0] || a2[1] - b2[1];
+                  }
+                  function canonicalizeEdges(edges) {
+                    return edges.map(canonicalizeEdge).sort(compareEdge);
+                  }
+                  function getDefault(options, property, dflt) {
+                    if (property in options) {
+                      return options[property];
+                    }
+                    return dflt;
+                  }
+                  function cdt2d(points, edges, options) {
+                    if (!Array.isArray(edges)) {
+                      options = edges || {};
+                      edges = [];
+                    } else {
+                      options = options || {};
+                      edges = edges || [];
+                    }
+                    var delaunay = !!getDefault(options, "delaunay", true);
+                    var interior = !!getDefault(options, "interior", true);
+                    var exterior = !!getDefault(options, "exterior", true);
+                    var infinity = !!getDefault(options, "infinity", false);
+                    if (!interior && !exterior || points.length === 0) {
+                      return [];
+                    }
+                    var cells = monotoneTriangulate(points, edges);
+                    if (delaunay || interior !== exterior || infinity) {
+                      var triangulation = makeIndex(points.length, canonicalizeEdges(edges));
+                      for (var i2 = 0; i2 < cells.length; ++i2) {
+                        var f2 = cells[i2];
+                        triangulation.addTriangle(f2[0], f2[1], f2[2]);
+                      }
+                      if (delaunay) {
+                        delaunayFlip(points, triangulation);
+                      }
+                      if (!exterior) {
+                        return filterTriangulation(triangulation, -1);
+                      } else if (!interior) {
+                        return filterTriangulation(triangulation, 1, infinity);
+                      } else if (infinity) {
+                        return filterTriangulation(triangulation, 0, infinity);
+                      } else {
+                        return triangulation.cells();
+                      }
+                    } else {
+                      return cells;
+                    }
+                  }
+                }
+              ),
+              /***/
+              2573: (
+                /***/
+                function(module22) {
+                  module22.exports = lerp2;
+                  function lerp2(out, a2, b2, t4) {
+                    var ax = a2[0], ay = a2[1], az = a2[2], aw = a2[3];
+                    out[0] = ax + t4 * (b2[0] - ax);
+                    out[1] = ay + t4 * (b2[1] - ay);
+                    out[2] = az + t4 * (b2[2] - az);
+                    out[3] = aw + t4 * (b2[3] - aw);
+                    return out;
+                  }
+                }
+              ),
+              /***/
+              2613: (
+                /***/
+                function(module22) {
+                  module22.exports = 1e-6;
+                }
+              ),
+              /***/
+              2640: (
+                /***/
+                function(module22, __unused_webpack_exports, __webpack_require__2) {
+                  var pool = __webpack_require__2(1888);
+                  module22.exports = createSurfaceExtractor;
+                  var allFns = {
+                    "false,0,1": function surfaceProcedure(vertex2, face, phase, mallocUint32, freeUint32) {
+                      return function extractContour0_1(a0, x0, x1, x2) {
+                        var s0 = a0.shape[0] | 0, s1 = a0.shape[1] | 0, d0 = a0.data, o0 = a0.offset | 0, t0_0 = a0.stride[0] | 0, t0_1 = a0.stride[1] | 0, p0 = o0, c0_0, d0_1 = -t0_0 | 0, c0_1 = 0, d0_2 = -t0_1 | 0, c0_2 = 0, d0_3 = -t0_0 - t0_1 | 0, c0_3 = 0, u0_0 = t0_0 | 0, u0_1 = t0_1 - t0_0 * s0 | 0, i0 = 0, i1 = 0, N2 = 0, Q2 = 2 * s0 | 0, P2 = mallocUint32(Q2), V2 = mallocUint32(Q2), X2 = 0, b0 = 0, e1 = -1 | 0, y1 = -1 | 0, b1 = 0, e2 = -s0 | 0, y2 = s0 | 0, b2 = 0, e3 = -s0 - 1 | 0, y3 = s0 - 1 | 0, b3 = 0, v0 = 0, T2 = 0;
+                        for (i0 = 0; i0 < s0; ++i0) {
+                          P2[X2++] = phase(d0[p0], x0, x1, x2);
+                          p0 += u0_0;
+                        }
+                        p0 += u0_1;
+                        if (s1 > 0) {
+                          i1 = 1;
+                          P2[X2++] = phase(d0[p0], x0, x1, x2);
+                          p0 += u0_0;
+                          if (s0 > 0) {
+                            i0 = 1;
+                            c0_0 = d0[p0];
+                            b0 = P2[X2] = phase(c0_0, x0, x1, x2);
+                            b1 = P2[X2 + e1];
+                            b2 = P2[X2 + e2];
+                            b3 = P2[X2 + e3];
+                            if (b0 !== b1 || b0 !== b2 || b0 !== b3) {
+                              c0_1 = d0[p0 + d0_1];
+                              c0_2 = d0[p0 + d0_2];
+                              c0_3 = d0[p0 + d0_3];
+                              vertex2(i0, i1, c0_0, c0_1, c0_2, c0_3, b0, b1, b2, b3, x0, x1, x2);
+                              v0 = V2[X2] = N2++;
+                            }
+                            X2 += 1;
+                            p0 += u0_0;
+                            for (i0 = 2; i0 < s0; ++i0) {
+                              c0_0 = d0[p0];
+                              b0 = P2[X2] = phase(c0_0, x0, x1, x2);
+                              b1 = P2[X2 + e1];
+                              b2 = P2[X2 + e2];
+                              b3 = P2[X2 + e3];
+                              if (b0 !== b1 || b0 !== b2 || b0 !== b3) {
+                                c0_1 = d0[p0 + d0_1];
+                                c0_2 = d0[p0 + d0_2];
+                                c0_3 = d0[p0 + d0_3];
+                                vertex2(i0, i1, c0_0, c0_1, c0_2, c0_3, b0, b1, b2, b3, x0, x1, x2);
+                                v0 = V2[X2] = N2++;
+                                if (b3 !== b1) {
+                                  face(V2[X2 + e1], v0, c0_3, c0_1, b3, b1, x0, x1, x2);
+                                }
+                              }
+                              X2 += 1;
+                              p0 += u0_0;
+                            }
+                          }
+                          p0 += u0_1;
+                          X2 = 0;
+                          T2 = e1;
+                          e1 = y1;
+                          y1 = T2;
+                          T2 = e2;
+                          e2 = y2;
+                          y2 = T2;
+                          T2 = e3;
+                          e3 = y3;
+                          y3 = T2;
+                          for (i1 = 2; i1 < s1; ++i1) {
+                            P2[X2++] = phase(d0[p0], x0, x1, x2);
+                            p0 += u0_0;
+                            if (s0 > 0) {
+                              i0 = 1;
+                              c0_0 = d0[p0];
+                              b0 = P2[X2] = phase(c0_0, x0, x1, x2);
+                              b1 = P2[X2 + e1];
+                              b2 = P2[X2 + e2];
+                              b3 = P2[X2 + e3];
+                              if (b0 !== b1 || b0 !== b2 || b0 !== b3) {
+                                c0_1 = d0[p0 + d0_1];
+                                c0_2 = d0[p0 + d0_2];
+                                c0_3 = d0[p0 + d0_3];
+                                vertex2(i0, i1, c0_0, c0_1, c0_2, c0_3, b0, b1, b2, b3, x0, x1, x2);
+                                v0 = V2[X2] = N2++;
+                                if (b3 !== b2) {
+                                  face(V2[X2 + e2], v0, c0_2, c0_3, b2, b3, x0, x1, x2);
+                                }
+                              }
+                              X2 += 1;
+                              p0 += u0_0;
+                              for (i0 = 2; i0 < s0; ++i0) {
+                                c0_0 = d0[p0];
+                                b0 = P2[X2] = phase(c0_0, x0, x1, x2);
+                                b1 = P2[X2 + e1];
+                                b2 = P2[X2 + e2];
+                                b3 = P2[X2 + e3];
+                                if (b0 !== b1 || b0 !== b2 || b0 !== b3) {
+                                  c0_1 = d0[p0 + d0_1];
+                                  c0_2 = d0[p0 + d0_2];
+                                  c0_3 = d0[p0 + d0_3];
+                                  vertex2(i0, i1, c0_0, c0_1, c0_2, c0_3, b0, b1, b2, b3, x0, x1, x2);
+                                  v0 = V2[X2] = N2++;
+                                  if (b3 !== b2) {
+                                    face(V2[X2 + e2], v0, c0_2, c0_3, b2, b3, x0, x1, x2);
+                                  }
+                                  if (b3 !== b1) {
+                                    face(V2[X2 + e1], v0, c0_3, c0_1, b3, b1, x0, x1, x2);
+                                  }
+                                }
+                                X2 += 1;
+                                p0 += u0_0;
+                              }
+                            }
+                            if (i1 & 1) {
+                              X2 = 0;
+                            }
+                            T2 = e1;
+                            e1 = y1;
+                            y1 = T2;
+                            T2 = e2;
+                            e2 = y2;
+                            y2 = T2;
+                            T2 = e3;
+                            e3 = y3;
+                            y3 = T2;
+                            p0 += u0_1;
+                          }
+                        }
+                        freeUint32(V2);
+                        freeUint32(P2);
+                      };
+                    },
+                    "false,1,0": function anonymous(vertex2, face, phase, mallocUint32, freeUint32) {
+                      return function extractContour1_0(a0, x0, x1, x2) {
+                        var s0 = a0.shape[0] | 0, s1 = a0.shape[1] | 0, d0 = a0.data, o0 = a0.offset | 0, t0_0 = a0.stride[0] | 0, t0_1 = a0.stride[1] | 0, p0 = o0, c0_0, d0_1 = -t0_0 | 0, c0_1 = 0, d0_2 = -t0_1 | 0, c0_2 = 0, d0_3 = -t0_0 - t0_1 | 0, c0_3 = 0, u0_1 = t0_1 | 0, u0_0 = t0_0 - t0_1 * s1 | 0, i0 = 0, i1 = 0, N2 = 0, Q2 = 2 * s1 | 0, P2 = mallocUint32(Q2), V2 = mallocUint32(Q2), X2 = 0, b0 = 0, e2 = -1 | 0, y2 = -1 | 0, b2 = 0, e1 = -s1 | 0, y1 = s1 | 0, b1 = 0, e3 = -s1 - 1 | 0, y3 = s1 - 1 | 0, b3 = 0, v0 = 0, T2 = 0;
+                        for (i1 = 0; i1 < s1; ++i1) {
+                          P2[X2++] = phase(d0[p0], x0, x1, x2);
+                          p0 += u0_1;
+                        }
+                        p0 += u0_0;
+                        if (s0 > 0) {
+                          i0 = 1;
+                          P2[X2++] = phase(d0[p0], x0, x1, x2);
+                          p0 += u0_1;
+                          if (s1 > 0) {
+                            i1 = 1;
+                            c0_0 = d0[p0];
+                            b0 = P2[X2] = phase(c0_0, x0, x1, x2);
+                            b1 = P2[X2 + e1];
+                            b2 = P2[X2 + e2];
+                            b3 = P2[X2 + e3];
+                            if (b0 !== b1 || b0 !== b2 || b0 !== b3) {
+                              c0_1 = d0[p0 + d0_1];
+                              c0_2 = d0[p0 + d0_2];
+                              c0_3 = d0[p0 + d0_3];
+                              vertex2(i0, i1, c0_0, c0_1, c0_2, c0_3, b0, b1, b2, b3, x0, x1, x2);
+                              v0 = V2[X2] = N2++;
+                            }
+                            X2 += 1;
+                            p0 += u0_1;
+                            for (i1 = 2; i1 < s1; ++i1) {
+                              c0_0 = d0[p0];
+                              b0 = P2[X2] = phase(c0_0, x0, x1, x2);
+                              b1 = P2[X2 + e1];
+                              b2 = P2[X2 + e2];
+                              b3 = P2[X2 + e3];
+                              if (b0 !== b1 || b0 !== b2 || b0 !== b3) {
+                                c0_1 = d0[p0 + d0_1];
+                                c0_2 = d0[p0 + d0_2];
+                                c0_3 = d0[p0 + d0_3];
+                                vertex2(i0, i1, c0_0, c0_1, c0_2, c0_3, b0, b1, b2, b3, x0, x1, x2);
+                                v0 = V2[X2] = N2++;
+                                if (b3 !== b2) {
+                                  face(V2[X2 + e2], v0, c0_2, c0_3, b2, b3, x0, x1, x2);
+                                }
+                              }
+                              X2 += 1;
+                              p0 += u0_1;
+                            }
+                          }
+                          p0 += u0_0;
+                          X2 = 0;
+                          T2 = e1;
+                          e1 = y1;
+                          y1 = T2;
+                          T2 = e2;
+                          e2 = y2;
+                          y2 = T2;
+                          T2 = e3;
+                          e3 = y3;
+                          y3 = T2;
+                          for (i0 = 2; i0 < s0; ++i0) {
+                            P2[X2++] = phase(d0[p0], x0, x1, x2);
+                            p0 += u0_1;
+                            if (s1 > 0) {
+                              i1 = 1;
+                              c0_0 = d0[p0];
+                              b0 = P2[X2] = phase(c0_0, x0, x1, x2);
+                              b1 = P2[X2 + e1];
+                              b2 = P2[X2 + e2];
+                              b3 = P2[X2 + e3];
+                              if (b0 !== b1 || b0 !== b2 || b0 !== b3) {
+                                c0_1 = d0[p0 + d0_1];
+                                c0_2 = d0[p0 + d0_2];
+                                c0_3 = d0[p0 + d0_3];
+                                vertex2(i0, i1, c0_0, c0_1, c0_2, c0_3, b0, b1, b2, b3, x0, x1, x2);
+                                v0 = V2[X2] = N2++;
+                                if (b3 !== b1) {
+                                  face(V2[X2 + e1], v0, c0_3, c0_1, b3, b1, x0, x1, x2);
+                                }
+                              }
+                              X2 += 1;
+                              p0 += u0_1;
+                              for (i1 = 2; i1 < s1; ++i1) {
+                                c0_0 = d0[p0];
+                                b0 = P2[X2] = phase(c0_0, x0, x1, x2);
+                                b1 = P2[X2 + e1];
+                                b2 = P2[X2 + e2];
+                                b3 = P2[X2 + e3];
+                                if (b0 !== b1 || b0 !== b2 || b0 !== b3) {
+                                  c0_1 = d0[p0 + d0_1];
+                                  c0_2 = d0[p0 + d0_2];
+                                  c0_3 = d0[p0 + d0_3];
+                                  vertex2(i0, i1, c0_0, c0_1, c0_2, c0_3, b0, b1, b2, b3, x0, x1, x2);
+                                  v0 = V2[X2] = N2++;
+                                  if (b3 !== b2) {
+                                    face(V2[X2 + e2], v0, c0_2, c0_3, b2, b3, x0, x1, x2);
+                                  }
+                                  if (b3 !== b1) {
+                                    face(V2[X2 + e1], v0, c0_3, c0_1, b3, b1, x0, x1, x2);
+                                  }
+                                }
+                                X2 += 1;
+                                p0 += u0_1;
+                              }
+                            }
+                            if (i0 & 1) {
+                              X2 = 0;
+                            }
+                            T2 = e1;
+                            e1 = y1;
+                            y1 = T2;
+                            T2 = e2;
+                            e2 = y2;
+                            y2 = T2;
+                            T2 = e3;
+                            e3 = y3;
+                            y3 = T2;
+                            p0 += u0_0;
+                          }
+                        }
+                        freeUint32(V2);
+                        freeUint32(P2);
+                      };
+                    }
+                  };
+                  function compileSurfaceProcedure(vertexFunc, faceFunc, phaseFunc, scalarArgs, order, typesig) {
+                    var key = [typesig, order].join(",");
+                    var proc = allFns[key];
+                    return proc(
+                      vertexFunc,
+                      faceFunc,
+                      phaseFunc,
+                      pool.mallocUint32,
+                      pool.freeUint32
+                    );
+                  }
+                  function createSurfaceExtractor(args) {
+                    function error(msg) {
+                      throw new Error("ndarray-extract-contour: " + msg);
+                    }
+                    if (typeof args !== "object") {
+                      error("Must specify arguments");
+                    }
+                    var order = args.order;
+                    if (!Array.isArray(order)) {
+                      error("Must specify order");
+                    }
+                    var arrays = args.arrayArguments || 1;
+                    if (arrays < 1) {
+                      error("Must have at least one array argument");
+                    }
+                    var scalars = args.scalarArguments || 0;
+                    if (scalars < 0) {
+                      error("Scalar arg count must be > 0");
+                    }
+                    if (typeof args.vertex !== "function") {
+                      error("Must specify vertex creation function");
+                    }
+                    if (typeof args.cell !== "function") {
+                      error("Must specify cell creation function");
+                    }
+                    if (typeof args.phase !== "function") {
+                      error("Must specify phase function");
+                    }
+                    var getters = args.getters || [];
+                    var typesig = new Array(arrays);
+                    for (var i2 = 0; i2 < arrays; ++i2) {
+                      if (getters.indexOf(i2) >= 0) {
+                        typesig[i2] = true;
+                      } else {
+                        typesig[i2] = false;
+                      }
+                    }
+                    return compileSurfaceProcedure(
+                      args.vertex,
+                      args.cell,
+                      args.phase,
+                      scalars,
+                      order,
+                      typesig
+                    );
+                  }
+                }
+              ),
+              /***/
+              2642: (
+                /***/
+                function(module22, __unused_webpack_exports, __webpack_require__2) {
+                  module22.exports = barycentric;
+                  var solve = __webpack_require__2(727);
+                  function reduce(x2) {
+                    var r2 = 0;
+                    for (var i2 = 0; i2 < x2.length; ++i2) {
+                      r2 += x2[i2];
+                    }
+                    return r2;
+                  }
+                  function barycentric(simplex, point) {
+                    var d2 = point.length;
+                    var A22 = new Array(d2 + 1);
+                    for (var i2 = 0; i2 < d2; ++i2) {
+                      var row = new Array(d2 + 1);
+                      for (var j2 = 0; j2 <= d2; ++j2) {
+                        row[j2] = simplex[j2][i2];
+                      }
+                      A22[i2] = row;
+                    }
+                    A22[d2] = new Array(d2 + 1);
+                    for (var i2 = 0; i2 <= d2; ++i2) {
+                      A22[d2][i2] = 1;
+                    }
+                    var b2 = new Array(d2 + 1);
+                    for (var i2 = 0; i2 < d2; ++i2) {
+                      b2[i2] = point[i2];
+                    }
+                    b2[d2] = 1;
+                    var x2 = solve(A22, b2);
+                    var w2 = reduce(x2[d2 + 1]);
+                    if (w2 === 0) {
+                      w2 = 1;
+                    }
+                    var y2 = new Array(d2 + 1);
+                    for (var i2 = 0; i2 <= d2; ++i2) {
+                      y2[i2] = reduce(x2[i2]) / w2;
+                    }
+                    return y2;
+                  }
+                }
+              ),
+              /***/
+              2646: (
+                /***/
+                function(module22, __unused_webpack_exports, __webpack_require__2) {
+                  var twoProduct = __webpack_require__2(5250);
+                  var robustSum = __webpack_require__2(8210);
+                  var robustDiff = __webpack_require__2(8545);
+                  var robustScale = __webpack_require__2(3012);
+                  var NUM_EXPAND = 6;
+                  function orientation(n2) {
+                    var fn = n2 === 3 ? inSphere3 : n2 === 4 ? inSphere4 : n2 === 5 ? inSphere5 : inSphere6;
+                    return fn(robustSum, robustDiff, twoProduct, robustScale);
+                  }
+                  function inSphere0() {
+                    return 0;
+                  }
+                  function inSphere1() {
+                    return 0;
+                  }
+                  function inSphere2() {
+                    return 0;
+                  }
+                  function inSphere3(sum, diff, prod, scale2) {
+                    function exactInSphere3(m0, m1, m2) {
+                      var w0 = prod(m0[0], m0[0]);
+                      var w0m1 = scale2(w0, m1[0]);
+                      var w0m2 = scale2(w0, m2[0]);
+                      var w1 = prod(m1[0], m1[0]);
+                      var w1m0 = scale2(w1, m0[0]);
+                      var w1m2 = scale2(w1, m2[0]);
+                      var w2 = prod(m2[0], m2[0]);
+                      var w2m0 = scale2(w2, m0[0]);
+                      var w2m1 = scale2(w2, m1[0]);
+                      var p2 = sum(diff(w2m1, w1m2), diff(w1m0, w0m1));
+                      var n2 = diff(w2m0, w0m2);
+                      var d2 = diff(p2, n2);
+                      return d2[d2.length - 1];
+                    }
+                    return exactInSphere3;
+                  }
+                  function inSphere4(sum, diff, prod, scale2) {
+                    function exactInSphere4(m0, m1, m2, m3) {
+                      var w0 = sum(prod(m0[0], m0[0]), prod(m0[1], m0[1]));
+                      var w0m1 = scale2(w0, m1[0]);
+                      var w0m2 = scale2(w0, m2[0]);
+                      var w0m3 = scale2(w0, m3[0]);
+                      var w1 = sum(prod(m1[0], m1[0]), prod(m1[1], m1[1]));
+                      var w1m0 = scale2(w1, m0[0]);
+                      var w1m2 = scale2(w1, m2[0]);
+                      var w1m3 = scale2(w1, m3[0]);
+                      var w2 = sum(prod(m2[0], m2[0]), prod(m2[1], m2[1]));
+                      var w2m0 = scale2(w2, m0[0]);
+                      var w2m1 = scale2(w2, m1[0]);
+                      var w2m3 = scale2(w2, m3[0]);
+                      var w3 = sum(prod(m3[0], m3[0]), prod(m3[1], m3[1]));
+                      var w3m0 = scale2(w3, m0[0]);
+                      var w3m1 = scale2(w3, m1[0]);
+                      var w3m2 = scale2(w3, m2[0]);
+                      var p2 = sum(sum(scale2(diff(w3m2, w2m3), m1[1]), sum(scale2(diff(w3m1, w1m3), -m2[1]), scale2(diff(w2m1, w1m2), m3[1]))), sum(scale2(diff(w3m1, w1m3), m0[1]), sum(scale2(diff(w3m0, w0m3), -m1[1]), scale2(diff(w1m0, w0m1), m3[1]))));
+                      var n2 = sum(sum(scale2(diff(w3m2, w2m3), m0[1]), sum(scale2(diff(w3m0, w0m3), -m2[1]), scale2(diff(w2m0, w0m2), m3[1]))), sum(scale2(diff(w2m1, w1m2), m0[1]), sum(scale2(diff(w2m0, w0m2), -m1[1]), scale2(diff(w1m0, w0m1), m2[1]))));
+                      var d2 = diff(p2, n2);
+                      return d2[d2.length - 1];
+                    }
+                    return exactInSphere4;
+                  }
+                  function inSphere5(sum, diff, prod, scale2) {
+                    function exactInSphere5(m0, m1, m2, m3, m4) {
+                      var w0 = sum(prod(m0[0], m0[0]), sum(prod(m0[1], m0[1]), prod(m0[2], m0[2])));
+                      var w0m1 = scale2(w0, m1[0]);
+                      var w0m2 = scale2(w0, m2[0]);
+                      var w0m3 = scale2(w0, m3[0]);
+                      var w0m4 = scale2(w0, m4[0]);
+                      var w1 = sum(prod(m1[0], m1[0]), sum(prod(m1[1], m1[1]), prod(m1[2], m1[2])));
+                      var w1m0 = scale2(w1, m0[0]);
+                      var w1m2 = scale2(w1, m2[0]);
+                      var w1m3 = scale2(w1, m3[0]);
+                      var w1m4 = scale2(w1, m4[0]);
+                      var w2 = sum(prod(m2[0], m2[0]), sum(prod(m2[1], m2[1]), prod(m2[2], m2[2])));
+                      var w2m0 = scale2(w2, m0[0]);
+                      var w2m1 = scale2(w2, m1[0]);
+                      var w2m3 = scale2(w2, m3[0]);
+                      var w2m4 = scale2(w2, m4[0]);
+                      var w3 = sum(prod(m3[0], m3[0]), sum(prod(m3[1], m3[1]), prod(m3[2], m3[2])));
+                      var w3m0 = scale2(w3, m0[0]);
+                      var w3m1 = scale2(w3, m1[0]);
+                      var w3m2 = scale2(w3, m2[0]);
+                      var w3m4 = scale2(w3, m4[0]);
+                      var w4 = sum(prod(m4[0], m4[0]), sum(prod(m4[1], m4[1]), prod(m4[2], m4[2])));
+                      var w4m0 = scale2(w4, m0[0]);
+                      var w4m1 = scale2(w4, m1[0]);
+                      var w4m2 = scale2(w4, m2[0]);
+                      var w4m3 = scale2(w4, m3[0]);
+                      var p2 = sum(sum(sum(scale2(sum(scale2(diff(w4m3, w3m4), m2[1]), sum(scale2(diff(w4m2, w2m4), -m3[1]), scale2(diff(w3m2, w2m3), m4[1]))), m1[2]), sum(scale2(sum(scale2(diff(w4m3, w3m4), m1[1]), sum(scale2(diff(w4m1, w1m4), -m3[1]), scale2(diff(w3m1, w1m3), m4[1]))), -m2[2]), scale2(sum(scale2(diff(w4m2, w2m4), m1[1]), sum(scale2(diff(w4m1, w1m4), -m2[1]), scale2(diff(w2m1, w1m2), m4[1]))), m3[2]))), sum(scale2(sum(scale2(diff(w3m2, w2m3), m1[1]), sum(scale2(diff(w3m1, w1m3), -m2[1]), scale2(diff(w2m1, w1m2), m3[1]))), -m4[2]), sum(scale2(sum(scale2(diff(w4m3, w3m4), m1[1]), sum(scale2(diff(w4m1, w1m4), -m3[1]), scale2(diff(w3m1, w1m3), m4[1]))), m0[2]), scale2(sum(scale2(diff(w4m3, w3m4), m0[1]), sum(scale2(diff(w4m0, w0m4), -m3[1]), scale2(diff(w3m0, w0m3), m4[1]))), -m1[2])))), sum(sum(scale2(sum(scale2(diff(w4m1, w1m4), m0[1]), sum(scale2(diff(w4m0, w0m4), -m1[1]), scale2(diff(w1m0, w0m1), m4[1]))), m3[2]), sum(scale2(sum(scale2(diff(w3m1, w1m3), m0[1]), sum(scale2(diff(w3m0, w0m3), -m1[1]), scale2(diff(w1m0, w0m1), m3[1]))), -m4[2]), scale2(sum(scale2(diff(w3m2, w2m3), m1[1]), sum(scale2(diff(w3m1, w1m3), -m2[1]), scale2(diff(w2m1, w1m2), m3[1]))), m0[2]))), sum(scale2(sum(scale2(diff(w3m2, w2m3), m0[1]), sum(scale2(diff(w3m0, w0m3), -m2[1]), scale2(diff(w2m0, w0m2), m3[1]))), -m1[2]), sum(scale2(sum(scale2(diff(w3m1, w1m3), m0[1]), sum(scale2(diff(w3m0, w0m3), -m1[1]), scale2(diff(w1m0, w0m1), m3[1]))), m2[2]), scale2(sum(scale2(diff(w2m1, w1m2), m0[1]), sum(scale2(diff(w2m0, w0m2), -m1[1]), scale2(diff(w1m0, w0m1), m2[1]))), -m3[2])))));
+                      var n2 = sum(sum(sum(scale2(sum(scale2(diff(w4m3, w3m4), m2[1]), sum(scale2(diff(w4m2, w2m4), -m3[1]), scale2(diff(w3m2, w2m3), m4[1]))), m0[2]), scale2(sum(scale2(diff(w4m3, w3m4), m0[1]), sum(scale2(diff(w4m0, w0m4), -m3[1]), scale2(diff(w3m0, w0m3), m4[1]))), -m2[2])), sum(scale2(sum(scale2(diff(w4m2, w2m4), m0[1]), sum(scale2(diff(w4m0, w0m4), -m2[1]), scale2(diff(w2m0, w0m2), m4[1]))), m3[2]), scale2(sum(scale2(diff(w3m2, w2m3), m0[1]), sum(scale2(diff(w3m0, w0m3), -m2[1]), scale2(diff(w2m0, w0m2), m3[1]))), -m4[2]))), sum(sum(scale2(sum(scale2(diff(w4m2, w2m4), m1[1]), sum(scale2(diff(w4m1, w1m4), -m2[1]), scale2(diff(w2m1, w1m2), m4[1]))), m0[2]), scale2(sum(scale2(diff(w4m2, w2m4), m0[1]), sum(scale2(diff(w4m0, w0m4), -m2[1]), scale2(diff(w2m0, w0m2), m4[1]))), -m1[2])), sum(scale2(sum(scale2(diff(w4m1, w1m4), m0[1]), sum(scale2(diff(w4m0, w0m4), -m1[1]), scale2(diff(w1m0, w0m1), m4[1]))), m2[2]), scale2(sum(scale2(diff(w2m1, w1m2), m0[1]), sum(scale2(diff(w2m0, w0m2), -m1[1]), scale2(diff(w1m0, w0m1), m2[1]))), -m4[2]))));
+                      var d2 = diff(p2, n2);
+                      return d2[d2.length - 1];
+                    }
+                    return exactInSphere5;
+                  }
+                  function inSphere6(sum, diff, prod, scale2) {
+                    function exactInSphere6(m0, m1, m2, m3, m4, m5) {
+                      var w0 = sum(sum(prod(m0[0], m0[0]), prod(m0[1], m0[1])), sum(prod(m0[2], m0[2]), prod(m0[3], m0[3])));
+                      var w0m1 = scale2(w0, m1[0]);
+                      var w0m2 = scale2(w0, m2[0]);
+                      var w0m3 = scale2(w0, m3[0]);
+                      var w0m4 = scale2(w0, m4[0]);
+                      var w0m5 = scale2(w0, m5[0]);
+                      var w1 = sum(sum(prod(m1[0], m1[0]), prod(m1[1], m1[1])), sum(prod(m1[2], m1[2]), prod(m1[3], m1[3])));
+                      var w1m0 = scale2(w1, m0[0]);
+                      var w1m2 = scale2(w1, m2[0]);
+                      var w1m3 = scale2(w1, m3[0]);
+                      var w1m4 = scale2(w1, m4[0]);
+                      var w1m5 = scale2(w1, m5[0]);
+                      var w2 = sum(sum(prod(m2[0], m2[0]), prod(m2[1], m2[1])), sum(prod(m2[2], m2[2]), prod(m2[3], m2[3])));
+                      var w2m0 = scale2(w2, m0[0]);
+                      var w2m1 = scale2(w2, m1[0]);
+                      var w2m3 = scale2(w2, m3[0]);
+                      var w2m4 = scale2(w2, m4[0]);
+                      var w2m5 = scale2(w2, m5[0]);
+                      var w3 = sum(sum(prod(m3[0], m3[0]), prod(m3[1], m3[1])), sum(prod(m3[2], m3[2]), prod(m3[3], m3[3])));
+                      var w3m0 = scale2(w3, m0[0]);
+                      var w3m1 = scale2(w3, m1[0]);
+                      var w3m2 = scale2(w3, m2[0]);
+                      var w3m4 = scale2(w3, m4[0]);
+                      var w3m5 = scale2(w3, m5[0]);
+                      var w4 = sum(sum(prod(m4[0], m4[0]), prod(m4[1], m4[1])), sum(prod(m4[2], m4[2]), prod(m4[3], m4[3])));
+                      var w4m0 = scale2(w4, m0[0]);
+                      var w4m1 = scale2(w4, m1[0]);
+                      var w4m2 = scale2(w4, m2[0]);
+                      var w4m3 = scale2(w4, m3[0]);
+                      var w4m5 = scale2(w4, m5[0]);
+                      var w5 = sum(sum(prod(m5[0], m5[0]), prod(m5[1], m5[1])), sum(prod(m5[2], m5[2]), prod(m5[3], m5[3])));
+                      var w5m0 = scale2(w5, m0[0]);
+                      var w5m1 = scale2(w5, m1[0]);
+                      var w5m2 = scale2(w5, m2[0]);
+                      var w5m3 = scale2(w5, m3[0]);
+                      var w5m4 = scale2(w5, m4[0]);
+                      var p2 = sum(sum(sum(scale2(sum(sum(scale2(sum(scale2(diff(w5m4, w4m5), m3[1]), sum(scale2(diff(w5m3, w3m5), -m4[1]), scale2(diff(w4m3, w3m4), m5[1]))), m2[2]), scale2(sum(scale2(diff(w5m4, w4m5), m2[1]), sum(scale2(diff(w5m2, w2m5), -m4[1]), scale2(diff(w4m2, w2m4), m5[1]))), -m3[2])), sum(scale2(sum(scale2(diff(w5m3, w3m5), m2[1]), sum(scale2(diff(w5m2, w2m5), -m3[1]), scale2(diff(w3m2, w2m3), m5[1]))), m4[2]), scale2(sum(scale2(diff(w4m3, w3m4), m2[1]), sum(scale2(diff(w4m2, w2m4), -m3[1]), scale2(diff(w3m2, w2m3), m4[1]))), -m5[2]))), m1[3]), sum(scale2(sum(sum(scale2(sum(scale2(diff(w5m4, w4m5), m3[1]), sum(scale2(diff(w5m3, w3m5), -m4[1]), scale2(diff(w4m3, w3m4), m5[1]))), m1[2]), scale2(sum(scale2(diff(w5m4, w4m5), m1[1]), sum(scale2(diff(w5m1, w1m5), -m4[1]), scale2(diff(w4m1, w1m4), m5[1]))), -m3[2])), sum(scale2(sum(scale2(diff(w5m3, w3m5), m1[1]), sum(scale2(diff(w5m1, w1m5), -m3[1]), scale2(diff(w3m1, w1m3), m5[1]))), m4[2]), scale2(sum(scale2(diff(w4m3, w3m4), m1[1]), sum(scale2(diff(w4m1, w1m4), -m3[1]), scale2(diff(w3m1, w1m3), m4[1]))), -m5[2]))), -m2[3]), scale2(sum(sum(scale2(sum(scale2(diff(w5m4, w4m5), m2[1]), sum(scale2(diff(w5m2, w2m5), -m4[1]), scale2(diff(w4m2, w2m4), m5[1]))), m1[2]), scale2(sum(scale2(diff(w5m4, w4m5), m1[1]), sum(scale2(diff(w5m1, w1m5), -m4[1]), scale2(diff(w4m1, w1m4), m5[1]))), -m2[2])), sum(scale2(sum(scale2(diff(w5m2, w2m5), m1[1]), sum(scale2(diff(w5m1, w1m5), -m2[1]), scale2(diff(w2m1, w1m2), m5[1]))), m4[2]), scale2(sum(scale2(diff(w4m2, w2m4), m1[1]), sum(scale2(diff(w4m1, w1m4), -m2[1]), scale2(diff(w2m1, w1m2), m4[1]))), -m5[2]))), m3[3]))), sum(sum(scale2(sum(sum(scale2(sum(scale2(diff(w5m3, w3m5), m2[1]), sum(scale2(diff(w5m2, w2m5), -m3[1]), scale2(diff(w3m2, w2m3), m5[1]))), m1[2]), scale2(sum(scale2(diff(w5m3, w3m5), m1[1]), sum(scale2(diff(w5m1, w1m5), -m3[1]), scale2(diff(w3m1, w1m3), m5[1]))), -m2[2])), sum(scale2(sum(scale2(diff(w5m2, w2m5), m1[1]), sum(scale2(diff(w5m1, w1m5), -m2[1]), scale2(diff(w2m1, w1m2), m5[1]))), m3[2]), scale2(sum(scale2(diff(w3m2, w2m3), m1[1]), sum(scale2(diff(w3m1, w1m3), -m2[1]), scale2(diff(w2m1, w1m2), m3[1]))), -m5[2]))), -m4[3]), scale2(sum(sum(scale2(sum(scale2(diff(w4m3, w3m4), m2[1]), sum(scale2(diff(w4m2, w2m4), -m3[1]), scale2(diff(w3m2, w2m3), m4[1]))), m1[2]), scale2(sum(scale2(diff(w4m3, w3m4), m1[1]), sum(scale2(diff(w4m1, w1m4), -m3[1]), scale2(diff(w3m1, w1m3), m4[1]))), -m2[2])), sum(scale2(sum(scale2(diff(w4m2, w2m4), m1[1]), sum(scale2(diff(w4m1, w1m4), -m2[1]), scale2(diff(w2m1, w1m2), m4[1]))), m3[2]), scale2(sum(scale2(diff(w3m2, w2m3), m1[1]), sum(scale2(diff(w3m1, w1m3), -m2[1]), scale2(diff(w2m1, w1m2), m3[1]))), -m4[2]))), m5[3])), sum(scale2(sum(sum(scale2(sum(scale2(diff(w5m4, w4m5), m3[1]), sum(scale2(diff(w5m3, w3m5), -m4[1]), scale2(diff(w4m3, w3m4), m5[1]))), m1[2]), scale2(sum(scale2(diff(w5m4, w4m5), m1[1]), sum(scale2(diff(w5m1, w1m5), -m4[1]), scale2(diff(w4m1, w1m4), m5[1]))), -m3[2])), sum(scale2(sum(scale2(diff(w5m3, w3m5), m1[1]), sum(scale2(diff(w5m1, w1m5), -m3[1]), scale2(diff(w3m1, w1m3), m5[1]))), m4[2]), scale2(sum(scale2(diff(w4m3, w3m4), m1[1]), sum(scale2(diff(w4m1, w1m4), -m3[1]), scale2(diff(w3m1, w1m3), m4[1]))), -m5[2]))), m0[3]), scale2(sum(sum(scale2(sum(scale2(diff(w5m4, w4m5), m3[1]), sum(scale2(diff(w5m3, w3m5), -m4[1]), scale2(diff(w4m3, w3m4), m5[1]))), m0[2]), scale2(sum(scale2(diff(w5m4, w4m5), m0[1]), sum(scale2(diff(w5m0, w0m5), -m4[1]), scale2(diff(w4m0, w0m4), m5[1]))), -m3[2])), sum(scale2(sum(scale2(diff(w5m3, w3m5), m0[1]), sum(scale2(diff(w5m0, w0m5), -m3[1]), scale2(diff(w3m0, w0m3), m5[1]))), m4[2]), scale2(sum(scale2(diff(w4m3, w3m4), m0[1]), sum(scale2(diff(w4m0, w0m4), -m3[1]), scale2(diff(w3m0, w0m3), m4[1]))), -m5[2]))), -m1[3])))), sum(sum(sum(scale2(sum(sum(scale2(sum(scale2(diff(w5m4, w4m5), m1[1]), sum(scale2(diff(w5m1, w1m5), -m4[1]), scale2(diff(w4m1, w1m4), m5[1]))), m0[2]), scale2(sum(scale2(diff(w5m4, w4m5), m0[1]), sum(scale2(diff(w5m0, w0m5), -m4[1]), scale2(diff(w4m0, w0m4), m5[1]))), -m1[2])), sum(scale2(sum(scale2(diff(w5m1, w1m5), m0[1]), sum(scale2(diff(w5m0, w0m5), -m1[1]), scale2(diff(w1m0, w0m1), m5[1]))), m4[2]), scale2(sum(scale2(diff(w4m1, w1m4), m0[1]), sum(scale2(diff(w4m0, w0m4), -m1[1]), scale2(diff(w1m0, w0m1), m4[1]))), -m5[2]))), m3[3]), scale2(sum(sum(scale2(sum(scale2(diff(w5m3, w3m5), m1[1]), sum(scale2(diff(w5m1, w1m5), -m3[1]), scale2(diff(w3m1, w1m3), m5[1]))), m0[2]), scale2(sum(scale2(diff(w5m3, w3m5), m0[1]), sum(scale2(diff(w5m0, w0m5), -m3[1]), scale2(diff(w3m0, w0m3), m5[1]))), -m1[2])), sum(scale2(sum(scale2(diff(w5m1, w1m5), m0[1]), sum(scale2(diff(w5m0, w0m5), -m1[1]), scale2(diff(w1m0, w0m1), m5[1]))), m3[2]), scale2(sum(scale2(diff(w3m1, w1m3), m0[1]), sum(scale2(diff(w3m0, w0m3), -m1[1]), scale2(diff(w1m0, w0m1), m3[1]))), -m5[2]))), -m4[3])), sum(scale2(sum(sum(scale2(sum(scale2(diff(w4m3, w3m4), m1[1]), sum(scale2(diff(w4m1, w1m4), -m3[1]), scale2(diff(w3m1, w1m3), m4[1]))), m0[2]), scale2(sum(scale2(diff(w4m3, w3m4), m0[1]), sum(scale2(diff(w4m0, w0m4), -m3[1]), scale2(diff(w3m0, w0m3), m4[1]))), -m1[2])), sum(scale2(sum(scale2(diff(w4m1, w1m4), m0[1]), sum(scale2(diff(w4m0, w0m4), -m1[1]), scale2(diff(w1m0, w0m1), m4[1]))), m3[2]), scale2(sum(scale2(diff(w3m1, w1m3), m0[1]), sum(scale2(diff(w3m0, w0m3), -m1[1]), scale2(diff(w1m0, w0m1), m3[1]))), -m4[2]))), m5[3]), scale2(sum(sum(scale2(sum(scale2(diff(w5m3, w3m5), m2[1]), sum(scale2(diff(w5m2, w2m5), -m3[1]), scale2(diff(w3m2, w2m3), m5[1]))), m1[2]), scale2(sum(scale2(diff(w5m3, w3m5), m1[1]), sum(scale2(diff(w5m1, w1m5), -m3[1]), scale2(diff(w3m1, w1m3), m5[1]))), -m2[2])), sum(scale2(sum(scale2(diff(w5m2, w2m5), m1[1]), sum(scale2(diff(w5m1, w1m5), -m2[1]), scale2(diff(w2m1, w1m2), m5[1]))), m3[2]), scale2(sum(scale2(diff(w3m2, w2m3), m1[1]), sum(scale2(diff(w3m1, w1m3), -m2[1]), scale2(diff(w2m1, w1m2), m3[1]))), -m5[2]))), m0[3]))), sum(sum(scale2(sum(sum(scale2(sum(scale2(diff(w5m3, w3m5), m2[1]), sum(scale2(diff(w5m2, w2m5), -m3[1]), scale2(diff(w3m2, w2m3), m5[1]))), m0[2]), scale2(sum(scale2(diff(w5m3, w3m5), m0[1]), sum(scale2(diff(w5m0, w0m5), -m3[1]), scale2(diff(w3m0, w0m3), m5[1]))), -m2[2])), sum(scale2(sum(scale2(diff(w5m2, w2m5), m0[1]), sum(scale2(diff(w5m0, w0m5), -m2[1]), scale2(diff(w2m0, w0m2), m5[1]))), m3[2]), scale2(sum(scale2(diff(w3m2, w2m3), m0[1]), sum(scale2(diff(w3m0, w0m3), -m2[1]), scale2(diff(w2m0, w0m2), m3[1]))), -m5[2]))), -m1[3]), scale2(sum(sum(scale2(sum(scale2(diff(w5m3, w3m5), m1[1]), sum(scale2(diff(w5m1, w1m5), -m3[1]), scale2(diff(w3m1, w1m3), m5[1]))), m0[2]), scale2(sum(scale2(diff(w5m3, w3m5), m0[1]), sum(scale2(diff(w5m0, w0m5), -m3[1]), scale2(diff(w3m0, w0m3), m5[1]))), -m1[2])), sum(scale2(sum(scale2(diff(w5m1, w1m5), m0[1]), sum(scale2(diff(w5m0, w0m5), -m1[1]), scale2(diff(w1m0, w0m1), m5[1]))), m3[2]), scale2(sum(scale2(diff(w3m1, w1m3), m0[1]), sum(scale2(diff(w3m0, w0m3), -m1[1]), scale2(diff(w1m0, w0m1), m3[1]))), -m5[2]))), m2[3])), sum(scale2(sum(sum(scale2(sum(scale2(diff(w5m2, w2m5), m1[1]), sum(scale2(diff(w5m1, w1m5), -m2[1]), scale2(diff(w2m1, w1m2), m5[1]))), m0[2]), scale2(sum(scale2(diff(w5m2, w2m5), m0[1]), sum(scale2(diff(w5m0, w0m5), -m2[1]), scale2(diff(w2m0, w0m2), m5[1]))), -m1[2])), sum(scale2(sum(scale2(diff(w5m1, w1m5), m0[1]), sum(scale2(diff(w5m0, w0m5), -m1[1]), scale2(diff(w1m0, w0m1), m5[1]))), m2[2]), scale2(sum(scale2(diff(w2m1, w1m2), m0[1]), sum(scale2(diff(w2m0, w0m2), -m1[1]), scale2(diff(w1m0, w0m1), m2[1]))), -m5[2]))), -m3[3]), scale2(sum(sum(scale2(sum(scale2(diff(w3m2, w2m3), m1[1]), sum(scale2(diff(w3m1, w1m3), -m2[1]), scale2(diff(w2m1, w1m2), m3[1]))), m0[2]), scale2(sum(scale2(diff(w3m2, w2m3), m0[1]), sum(scale2(diff(w3m0, w0m3), -m2[1]), scale2(diff(w2m0, w0m2), m3[1]))), -m1[2])), sum(scale2(sum(scale2(diff(w3m1, w1m3), m0[1]), sum(scale2(diff(w3m0, w0m3), -m1[1]), scale2(diff(w1m0, w0m1), m3[1]))), m2[2]), scale2(sum(scale2(diff(w2m1, w1m2), m0[1]), sum(scale2(diff(w2m0, w0m2), -m1[1]), scale2(diff(w1m0, w0m1), m2[1]))), -m3[2]))), m5[3])))));
+                      var n2 = sum(sum(sum(scale2(sum(sum(scale2(sum(scale2(diff(w5m4, w4m5), m3[1]), sum(scale2(diff(w5m3, w3m5), -m4[1]), scale2(diff(w4m3, w3m4), m5[1]))), m2[2]), scale2(sum(scale2(diff(w5m4, w4m5), m2[1]), sum(scale2(diff(w5m2, w2m5), -m4[1]), scale2(diff(w4m2, w2m4), m5[1]))), -m3[2])), sum(scale2(sum(scale2(diff(w5m3, w3m5), m2[1]), sum(scale2(diff(w5m2, w2m5), -m3[1]), scale2(diff(w3m2, w2m3), m5[1]))), m4[2]), scale2(sum(scale2(diff(w4m3, w3m4), m2[1]), sum(scale2(diff(w4m2, w2m4), -m3[1]), scale2(diff(w3m2, w2m3), m4[1]))), -m5[2]))), m0[3]), sum(scale2(sum(sum(scale2(sum(scale2(diff(w5m4, w4m5), m3[1]), sum(scale2(diff(w5m3, w3m5), -m4[1]), scale2(diff(w4m3, w3m4), m5[1]))), m0[2]), scale2(sum(scale2(diff(w5m4, w4m5), m0[1]), sum(scale2(diff(w5m0, w0m5), -m4[1]), scale2(diff(w4m0, w0m4), m5[1]))), -m3[2])), sum(scale2(sum(scale2(diff(w5m3, w3m5), m0[1]), sum(scale2(diff(w5m0, w0m5), -m3[1]), scale2(diff(w3m0, w0m3), m5[1]))), m4[2]), scale2(sum(scale2(diff(w4m3, w3m4), m0[1]), sum(scale2(diff(w4m0, w0m4), -m3[1]), scale2(diff(w3m0, w0m3), m4[1]))), -m5[2]))), -m2[3]), scale2(sum(sum(scale2(sum(scale2(diff(w5m4, w4m5), m2[1]), sum(scale2(diff(w5m2, w2m5), -m4[1]), scale2(diff(w4m2, w2m4), m5[1]))), m0[2]), scale2(sum(scale2(diff(w5m4, w4m5), m0[1]), sum(scale2(diff(w5m0, w0m5), -m4[1]), scale2(diff(w4m0, w0m4), m5[1]))), -m2[2])), sum(scale2(sum(scale2(diff(w5m2, w2m5), m0[1]), sum(scale2(diff(w5m0, w0m5), -m2[1]), scale2(diff(w2m0, w0m2), m5[1]))), m4[2]), scale2(sum(scale2(diff(w4m2, w2m4), m0[1]), sum(scale2(diff(w4m0, w0m4), -m2[1]), scale2(diff(w2m0, w0m2), m4[1]))), -m5[2]))), m3[3]))), sum(sum(scale2(sum(sum(scale2(sum(scale2(diff(w5m3, w3m5), m2[1]), sum(scale2(diff(w5m2, w2m5), -m3[1]), scale2(diff(w3m2, w2m3), m5[1]))), m0[2]), scale2(sum(scale2(diff(w5m3, w3m5), m0[1]), sum(scale2(diff(w5m0, w0m5), -m3[1]), scale2(diff(w3m0, w0m3), m5[1]))), -m2[2])), sum(scale2(sum(scale2(diff(w5m2, w2m5), m0[1]), sum(scale2(diff(w5m0, w0m5), -m2[1]), scale2(diff(w2m0, w0m2), m5[1]))), m3[2]), scale2(sum(scale2(diff(w3m2, w2m3), m0[1]), sum(scale2(diff(w3m0, w0m3), -m2[1]), scale2(diff(w2m0, w0m2), m3[1]))), -m5[2]))), -m4[3]), scale2(sum(sum(scale2(sum(scale2(diff(w4m3, w3m4), m2[1]), sum(scale2(diff(w4m2, w2m4), -m3[1]), scale2(diff(w3m2, w2m3), m4[1]))), m0[2]), scale2(sum(scale2(diff(w4m3, w3m4), m0[1]), sum(scale2(diff(w4m0, w0m4), -m3[1]), scale2(diff(w3m0, w0m3), m4[1]))), -m2[2])), sum(scale2(sum(scale2(diff(w4m2, w2m4), m0[1]), sum(scale2(diff(w4m0, w0m4), -m2[1]), scale2(diff(w2m0, w0m2), m4[1]))), m3[2]), scale2(sum(scale2(diff(w3m2, w2m3), m0[1]), sum(scale2(diff(w3m0, w0m3), -m2[1]), scale2(diff(w2m0, w0m2), m3[1]))), -m4[2]))), m5[3])), sum(scale2(sum(sum(scale2(sum(scale2(diff(w5m4, w4m5), m2[1]), sum(scale2(diff(w5m2, w2m5), -m4[1]), scale2(diff(w4m2, w2m4), m5[1]))), m1[2]), scale2(sum(scale2(diff(w5m4, w4m5), m1[1]), sum(scale2(diff(w5m1, w1m5), -m4[1]), scale2(diff(w4m1, w1m4), m5[1]))), -m2[2])), sum(scale2(sum(scale2(diff(w5m2, w2m5), m1[1]), sum(scale2(diff(w5m1, w1m5), -m2[1]), scale2(diff(w2m1, w1m2), m5[1]))), m4[2]), scale2(sum(scale2(diff(w4m2, w2m4), m1[1]), sum(scale2(diff(w4m1, w1m4), -m2[1]), scale2(diff(w2m1, w1m2), m4[1]))), -m5[2]))), m0[3]), scale2(sum(sum(scale2(sum(scale2(diff(w5m4, w4m5), m2[1]), sum(scale2(diff(w5m2, w2m5), -m4[1]), scale2(diff(w4m2, w2m4), m5[1]))), m0[2]), scale2(sum(scale2(diff(w5m4, w4m5), m0[1]), sum(scale2(diff(w5m0, w0m5), -m4[1]), scale2(diff(w4m0, w0m4), m5[1]))), -m2[2])), sum(scale2(sum(scale2(diff(w5m2, w2m5), m0[1]), sum(scale2(diff(w5m0, w0m5), -m2[1]), scale2(diff(w2m0, w0m2), m5[1]))), m4[2]), scale2(sum(scale2(diff(w4m2, w2m4), m0[1]), sum(scale2(diff(w4m0, w0m4), -m2[1]), scale2(diff(w2m0, w0m2), m4[1]))), -m5[2]))), -m1[3])))), sum(sum(sum(scale2(sum(sum(scale2(sum(scale2(diff(w5m4, w4m5), m1[1]), sum(scale2(diff(w5m1, w1m5), -m4[1]), scale2(diff(w4m1, w1m4), m5[1]))), m0[2]), scale2(sum(scale2(diff(w5m4, w4m5), m0[1]), sum(scale2(diff(w5m0, w0m5), -m4[1]), scale2(diff(w4m0, w0m4), m5[1]))), -m1[2])), sum(scale2(sum(scale2(diff(w5m1, w1m5), m0[1]), sum(scale2(diff(w5m0, w0m5), -m1[1]), scale2(diff(w1m0, w0m1), m5[1]))), m4[2]), scale2(sum(scale2(diff(w4m1, w1m4), m0[1]), sum(scale2(diff(w4m0, w0m4), -m1[1]), scale2(diff(w1m0, w0m1), m4[1]))), -m5[2]))), m2[3]), scale2(sum(sum(scale2(sum(scale2(diff(w5m2, w2m5), m1[1]), sum(scale2(diff(w5m1, w1m5), -m2[1]), scale2(diff(w2m1, w1m2), m5[1]))), m0[2]), scale2(sum(scale2(diff(w5m2, w2m5), m0[1]), sum(scale2(diff(w5m0, w0m5), -m2[1]), scale2(diff(w2m0, w0m2), m5[1]))), -m1[2])), sum(scale2(sum(scale2(diff(w5m1, w1m5), m0[1]), sum(scale2(diff(w5m0, w0m5), -m1[1]), scale2(diff(w1m0, w0m1), m5[1]))), m2[2]), scale2(sum(scale2(diff(w2m1, w1m2), m0[1]), sum(scale2(diff(w2m0, w0m2), -m1[1]), scale2(diff(w1m0, w0m1), m2[1]))), -m5[2]))), -m4[3])), sum(scale2(sum(sum(scale2(sum(scale2(diff(w4m2, w2m4), m1[1]), sum(scale2(diff(w4m1, w1m4), -m2[1]), scale2(diff(w2m1, w1m2), m4[1]))), m0[2]), scale2(sum(scale2(diff(w4m2, w2m4), m0[1]), sum(scale2(diff(w4m0, w0m4), -m2[1]), scale2(diff(w2m0, w0m2), m4[1]))), -m1[2])), sum(scale2(sum(scale2(diff(w4m1, w1m4), m0[1]), sum(scale2(diff(w4m0, w0m4), -m1[1]), scale2(diff(w1m0, w0m1), m4[1]))), m2[2]), scale2(sum(scale2(diff(w2m1, w1m2), m0[1]), sum(scale2(diff(w2m0, w0m2), -m1[1]), scale2(diff(w1m0, w0m1), m2[1]))), -m4[2]))), m5[3]), scale2(sum(sum(scale2(sum(scale2(diff(w4m3, w3m4), m2[1]), sum(scale2(diff(w4m2, w2m4), -m3[1]), scale2(diff(w3m2, w2m3), m4[1]))), m1[2]), scale2(sum(scale2(diff(w4m3, w3m4), m1[1]), sum(scale2(diff(w4m1, w1m4), -m3[1]), scale2(diff(w3m1, w1m3), m4[1]))), -m2[2])), sum(scale2(sum(scale2(diff(w4m2, w2m4), m1[1]), sum(scale2(diff(w4m1, w1m4), -m2[1]), scale2(diff(w2m1, w1m2), m4[1]))), m3[2]), scale2(sum(scale2(diff(w3m2, w2m3), m1[1]), sum(scale2(diff(w3m1, w1m3), -m2[1]), scale2(diff(w2m1, w1m2), m3[1]))), -m4[2]))), m0[3]))), sum(sum(scale2(sum(sum(scale2(sum(scale2(diff(w4m3, w3m4), m2[1]), sum(scale2(diff(w4m2, w2m4), -m3[1]), scale2(diff(w3m2, w2m3), m4[1]))), m0[2]), scale2(sum(scale2(diff(w4m3, w3m4), m0[1]), sum(scale2(diff(w4m0, w0m4), -m3[1]), scale2(diff(w3m0, w0m3), m4[1]))), -m2[2])), sum(scale2(sum(scale2(diff(w4m2, w2m4), m0[1]), sum(scale2(diff(w4m0, w0m4), -m2[1]), scale2(diff(w2m0, w0m2), m4[1]))), m3[2]), scale2(sum(scale2(diff(w3m2, w2m3), m0[1]), sum(scale2(diff(w3m0, w0m3), -m2[1]), scale2(diff(w2m0, w0m2), m3[1]))), -m4[2]))), -m1[3]), scale2(sum(sum(scale2(sum(scale2(diff(w4m3, w3m4), m1[1]), sum(scale2(diff(w4m1, w1m4), -m3[1]), scale2(diff(w3m1, w1m3), m4[1]))), m0[2]), scale2(sum(scale2(diff(w4m3, w3m4), m0[1]), sum(scale2(diff(w4m0, w0m4), -m3[1]), scale2(diff(w3m0, w0m3), m4[1]))), -m1[2])), sum(scale2(sum(scale2(diff(w4m1, w1m4), m0[1]), sum(scale2(diff(w4m0, w0m4), -m1[1]), scale2(diff(w1m0, w0m1), m4[1]))), m3[2]), scale2(sum(scale2(diff(w3m1, w1m3), m0[1]), sum(scale2(diff(w3m0, w0m3), -m1[1]), scale2(diff(w1m0, w0m1), m3[1]))), -m4[2]))), m2[3])), sum(scale2(sum(sum(scale2(sum(scale2(diff(w4m2, w2m4), m1[1]), sum(scale2(diff(w4m1, w1m4), -m2[1]), scale2(diff(w2m1, w1m2), m4[1]))), m0[2]), scale2(sum(scale2(diff(w4m2, w2m4), m0[1]), sum(scale2(diff(w4m0, w0m4), -m2[1]), scale2(diff(w2m0, w0m2), m4[1]))), -m1[2])), sum(scale2(sum(scale2(diff(w4m1, w1m4), m0[1]), sum(scale2(diff(w4m0, w0m4), -m1[1]), scale2(diff(w1m0, w0m1), m4[1]))), m2[2]), scale2(sum(scale2(diff(w2m1, w1m2), m0[1]), sum(scale2(diff(w2m0, w0m2), -m1[1]), scale2(diff(w1m0, w0m1), m2[1]))), -m4[2]))), -m3[3]), scale2(sum(sum(scale2(sum(scale2(diff(w3m2, w2m3), m1[1]), sum(scale2(diff(w3m1, w1m3), -m2[1]), scale2(diff(w2m1, w1m2), m3[1]))), m0[2]), scale2(sum(scale2(diff(w3m2, w2m3), m0[1]), sum(scale2(diff(w3m0, w0m3), -m2[1]), scale2(diff(w2m0, w0m2), m3[1]))), -m1[2])), sum(scale2(sum(scale2(diff(w3m1, w1m3), m0[1]), sum(scale2(diff(w3m0, w0m3), -m1[1]), scale2(diff(w1m0, w0m1), m3[1]))), m2[2]), scale2(sum(scale2(diff(w2m1, w1m2), m0[1]), sum(scale2(diff(w2m0, w0m2), -m1[1]), scale2(diff(w1m0, w0m1), m2[1]))), -m3[2]))), m4[3])))));
+                      var d2 = diff(p2, n2);
+                      return d2[d2.length - 1];
+                    }
+                    return exactInSphere6;
+                  }
+                  var CACHED = [
+                    inSphere0,
+                    inSphere1,
+                    inSphere2
+                  ];
+                  function slowInSphere(args) {
+                    var proc2 = CACHED[args.length];
+                    if (!proc2) {
+                      proc2 = CACHED[args.length] = orientation(args.length);
+                    }
+                    return proc2.apply(void 0, args);
+                  }
+                  function proc(slow, o0, o1, o2, o3, o4, o5, o6) {
+                    function testInSphere(a0, a1, a2, a3, a4, a5) {
+                      switch (arguments.length) {
+                        case 0:
+                        case 1:
+                          return 0;
+                        case 2:
+                          return o2(a0, a1);
+                        case 3:
+                          return o3(a0, a1, a2);
+                        case 4:
+                          return o4(a0, a1, a2, a3);
+                        case 5:
+                          return o5(a0, a1, a2, a3, a4);
+                        case 6:
+                          return o6(a0, a1, a2, a3, a4, a5);
+                      }
+                      var s2 = new Array(arguments.length);
+                      for (var i2 = 0; i2 < arguments.length; ++i2) {
+                        s2[i2] = arguments[i2];
+                      }
+                      return slow(s2);
+                    }
+                    return testInSphere;
+                  }
+                  function generateInSphereTest() {
+                    while (CACHED.length <= NUM_EXPAND) {
+                      CACHED.push(orientation(CACHED.length));
+                    }
+                    module22.exports = proc.apply(void 0, [slowInSphere].concat(CACHED));
+                    for (var i2 = 0; i2 <= NUM_EXPAND; ++i2) {
+                      module22.exports[i2] = CACHED[i2];
+                    }
+                  }
+                  generateInSphereTest();
+                }
+              ),
+              /***/
+              2651: (
+                /***/
+                function(module22, __unused_webpack_exports, __webpack_require__2) {
+                  var BN2 = __webpack_require__2(6859);
+                  var db2 = __webpack_require__2(2361);
+                  module22.exports = num2bn;
+                  function num2bn(x2) {
+                    var e2 = db2.exponent(x2);
+                    if (e2 < 52) {
+                      return new BN2(x2);
+                    } else {
+                      return new BN2(x2 * Math.pow(2, 52 - e2)).ushln(e2 - 52);
+                    }
+                  }
+                }
+              ),
+              /***/
+              2652: (
+                /***/
+                function(module22, __unused_webpack_exports, __webpack_require__2) {
+                  var normalize = __webpack_require__2(4335);
+                  var create2 = __webpack_require__2(6864);
+                  var clone = __webpack_require__2(1903);
+                  var determinant2 = __webpack_require__2(9921);
+                  var invert2 = __webpack_require__2(7608);
+                  var transpose2 = __webpack_require__2(5665);
+                  var vec3 = {
+                    length: __webpack_require__2(1387),
+                    normalize: __webpack_require__2(3536),
+                    dot: __webpack_require__2(244),
+                    cross: __webpack_require__2(5911)
+                  };
+                  var tmp2 = create2();
+                  var perspectiveMatrix = create2();
+                  var tmpVec4 = [0, 0, 0, 0];
+                  var row = [[0, 0, 0], [0, 0, 0], [0, 0, 0]];
+                  var pdum3 = [0, 0, 0];
+                  module22.exports = function decomposeMat4(matrix, translation, scale2, skew, perspective2, quaternion) {
+                    if (!translation) translation = [0, 0, 0];
+                    if (!scale2) scale2 = [0, 0, 0];
+                    if (!skew) skew = [0, 0, 0];
+                    if (!perspective2) perspective2 = [0, 0, 0, 1];
+                    if (!quaternion) quaternion = [0, 0, 0, 1];
+                    if (!normalize(tmp2, matrix))
+                      return false;
+                    clone(perspectiveMatrix, tmp2);
+                    perspectiveMatrix[3] = 0;
+                    perspectiveMatrix[7] = 0;
+                    perspectiveMatrix[11] = 0;
+                    perspectiveMatrix[15] = 1;
+                    if (Math.abs(determinant2(perspectiveMatrix) < 1e-8))
+                      return false;
+                    var a03 = tmp2[3], a13 = tmp2[7], a23 = tmp2[11], a30 = tmp2[12], a31 = tmp2[13], a32 = tmp2[14], a33 = tmp2[15];
+                    if (a03 !== 0 || a13 !== 0 || a23 !== 0) {
+                      tmpVec4[0] = a03;
+                      tmpVec4[1] = a13;
+                      tmpVec4[2] = a23;
+                      tmpVec4[3] = a33;
+                      var ret = invert2(perspectiveMatrix, perspectiveMatrix);
+                      if (!ret) return false;
+                      transpose2(perspectiveMatrix, perspectiveMatrix);
+                      vec4multMat4(perspective2, tmpVec4, perspectiveMatrix);
+                    } else {
+                      perspective2[0] = perspective2[1] = perspective2[2] = 0;
+                      perspective2[3] = 1;
+                    }
+                    translation[0] = a30;
+                    translation[1] = a31;
+                    translation[2] = a32;
+                    mat3from4(row, tmp2);
+                    scale2[0] = vec3.length(row[0]);
+                    vec3.normalize(row[0], row[0]);
+                    skew[0] = vec3.dot(row[0], row[1]);
+                    combine(row[1], row[1], row[0], 1, -skew[0]);
+                    scale2[1] = vec3.length(row[1]);
+                    vec3.normalize(row[1], row[1]);
+                    skew[0] /= scale2[1];
+                    skew[1] = vec3.dot(row[0], row[2]);
+                    combine(row[2], row[2], row[0], 1, -skew[1]);
+                    skew[2] = vec3.dot(row[1], row[2]);
+                    combine(row[2], row[2], row[1], 1, -skew[2]);
+                    scale2[2] = vec3.length(row[2]);
+                    vec3.normalize(row[2], row[2]);
+                    skew[1] /= scale2[2];
+                    skew[2] /= scale2[2];
+                    vec3.cross(pdum3, row[1], row[2]);
+                    if (vec3.dot(row[0], pdum3) < 0) {
+                      for (var i2 = 0; i2 < 3; i2++) {
+                        scale2[i2] *= -1;
+                        row[i2][0] *= -1;
+                        row[i2][1] *= -1;
+                        row[i2][2] *= -1;
+                      }
+                    }
+                    quaternion[0] = 0.5 * Math.sqrt(Math.max(1 + row[0][0] - row[1][1] - row[2][2], 0));
+                    quaternion[1] = 0.5 * Math.sqrt(Math.max(1 - row[0][0] + row[1][1] - row[2][2], 0));
+                    quaternion[2] = 0.5 * Math.sqrt(Math.max(1 - row[0][0] - row[1][1] + row[2][2], 0));
+                    quaternion[3] = 0.5 * Math.sqrt(Math.max(1 + row[0][0] + row[1][1] + row[2][2], 0));
+                    if (row[2][1] > row[1][2])
+                      quaternion[0] = -quaternion[0];
+                    if (row[0][2] > row[2][0])
+                      quaternion[1] = -quaternion[1];
+                    if (row[1][0] > row[0][1])
+                      quaternion[2] = -quaternion[2];
+                    return true;
+                  };
+                  function vec4multMat4(out, a2, m2) {
+                    var x2 = a2[0], y2 = a2[1], z2 = a2[2], w2 = a2[3];
+                    out[0] = m2[0] * x2 + m2[4] * y2 + m2[8] * z2 + m2[12] * w2;
+                    out[1] = m2[1] * x2 + m2[5] * y2 + m2[9] * z2 + m2[13] * w2;
+                    out[2] = m2[2] * x2 + m2[6] * y2 + m2[10] * z2 + m2[14] * w2;
+                    out[3] = m2[3] * x2 + m2[7] * y2 + m2[11] * z2 + m2[15] * w2;
+                    return out;
+                  }
+                  function mat3from4(out, mat4x4) {
+                    out[0][0] = mat4x4[0];
+                    out[0][1] = mat4x4[1];
+                    out[0][2] = mat4x4[2];
+                    out[1][0] = mat4x4[4];
+                    out[1][1] = mat4x4[5];
+                    out[1][2] = mat4x4[6];
+                    out[2][0] = mat4x4[8];
+                    out[2][1] = mat4x4[9];
+                    out[2][2] = mat4x4[10];
+                  }
+                  function combine(out, a2, b2, scale1, scale2) {
+                    out[0] = a2[0] * scale1 + b2[0] * scale2;
+                    out[1] = a2[1] * scale1 + b2[1] * scale2;
+                    out[2] = a2[2] * scale1 + b2[2] * scale2;
+                  }
+                }
+              ),
+              /***/
+              2653: (
+                /***/
+                function(module22, __unused_webpack_exports, __webpack_require__2) {
+                  var bnadd = __webpack_require__2(3865);
+                  module22.exports = add2;
+                  function add2(a2, b2) {
+                    var n2 = a2.length;
+                    var r2 = new Array(n2);
+                    for (var i2 = 0; i2 < n2; ++i2) {
+                      r2[i2] = bnadd(a2[i2], b2[i2]);
+                    }
+                    return r2;
+                  }
+                }
+              ),
+              /***/
+              2681: (
+                /***/
+                function(module22) {
+                  module22.exports = floor;
+                  function floor(out, a2) {
+                    out[0] = Math.floor(a2[0]);
+                    out[1] = Math.floor(a2[1]);
+                    out[2] = Math.floor(a2[2]);
+                    return out;
+                  }
+                }
+              ),
+              /***/
+              2690: (
+                /***/
+                function(module22, __unused_webpack_exports, __webpack_require__2) {
+                  module22.exports = convexHullnD;
+                  var ich = __webpack_require__2(8954);
+                  var aff = __webpack_require__2(3952);
+                  function permute(points, front) {
+                    var n2 = points.length;
+                    var npoints = new Array(n2);
+                    for (var i2 = 0; i2 < front.length; ++i2) {
+                      npoints[i2] = points[front[i2]];
+                    }
+                    var ptr = front.length;
+                    for (var i2 = 0; i2 < n2; ++i2) {
+                      if (front.indexOf(i2) < 0) {
+                        npoints[ptr++] = points[i2];
+                      }
+                    }
+                    return npoints;
+                  }
+                  function invPermute(cells, front) {
+                    var nc2 = cells.length;
+                    var nf2 = front.length;
+                    for (var i2 = 0; i2 < nc2; ++i2) {
+                      var c2 = cells[i2];
+                      for (var j2 = 0; j2 < c2.length; ++j2) {
+                        var x2 = c2[j2];
+                        if (x2 < nf2) {
+                          c2[j2] = front[x2];
+                        } else {
+                          x2 = x2 - nf2;
+                          for (var k2 = 0; k2 < nf2; ++k2) {
+                            if (x2 >= front[k2]) {
+                              x2 += 1;
+                            }
+                          }
+                          c2[j2] = x2;
+                        }
+                      }
+                    }
+                    return cells;
+                  }
+                  function convexHullnD(points, d2) {
+                    try {
+                      return ich(points, true);
+                    } catch (e2) {
+                      var ah2 = aff(points);
+                      if (ah2.length <= d2) {
+                        return [];
+                      }
+                      var npoints = permute(points, ah2);
+                      var nhull = ich(npoints, true);
+                      return invPermute(nhull, ah2);
+                    }
+                  }
+                }
+              ),
+              /***/
+              2762: (
+                /***/
+                function(module22, __unused_webpack_exports, __webpack_require__2) {
+                  var pool = __webpack_require__2(1888);
+                  var ops = __webpack_require__2(5298);
+                  var ndarray = __webpack_require__2(9618);
+                  var SUPPORTED_TYPES = [
+                    "uint8",
+                    "uint8_clamped",
+                    "uint16",
+                    "uint32",
+                    "int8",
+                    "int16",
+                    "int32",
+                    "float32"
+                  ];
+                  function GLBuffer(gl2, type, handle, length2, usage) {
+                    this.gl = gl2;
+                    this.type = type;
+                    this.handle = handle;
+                    this.length = length2;
+                    this.usage = usage;
+                  }
+                  var proto = GLBuffer.prototype;
+                  proto.bind = function() {
+                    this.gl.bindBuffer(this.type, this.handle);
+                  };
+                  proto.unbind = function() {
+                    this.gl.bindBuffer(this.type, null);
+                  };
+                  proto.dispose = function() {
+                    this.gl.deleteBuffer(this.handle);
+                  };
+                  function updateTypeArray(gl2, type, len2, usage, data, offset) {
+                    var dataLen = data.length * data.BYTES_PER_ELEMENT;
+                    if (offset < 0) {
+                      gl2.bufferData(type, data, usage);
+                      return dataLen;
+                    }
+                    if (dataLen + offset > len2) {
+                      throw new Error("gl-buffer: If resizing buffer, must not specify offset");
+                    }
+                    gl2.bufferSubData(type, offset, data);
+                    return len2;
+                  }
+                  function makeScratchTypeArray(array, dtype) {
+                    var res = pool.malloc(array.length, dtype);
+                    var n2 = array.length;
+                    for (var i2 = 0; i2 < n2; ++i2) {
+                      res[i2] = array[i2];
+                    }
+                    return res;
+                  }
+                  function isPacked(shape, stride) {
+                    var n2 = 1;
+                    for (var i2 = stride.length - 1; i2 >= 0; --i2) {
+                      if (stride[i2] !== n2) {
+                        return false;
+                      }
+                      n2 *= shape[i2];
+                    }
+                    return true;
+                  }
+                  proto.update = function(array, offset) {
+                    if (typeof offset !== "number") {
+                      offset = -1;
+                    }
+                    this.bind();
+                    if (typeof array === "object" && typeof array.shape !== "undefined") {
+                      var dtype = array.dtype;
+                      if (SUPPORTED_TYPES.indexOf(dtype) < 0) {
+                        dtype = "float32";
+                      }
+                      if (this.type === this.gl.ELEMENT_ARRAY_BUFFER) {
+                        var ext = gl.getExtension("OES_element_index_uint");
+                        if (ext && dtype !== "uint16") {
+                          dtype = "uint32";
+                        } else {
+                          dtype = "uint16";
+                        }
+                      }
+                      if (dtype === array.dtype && isPacked(array.shape, array.stride)) {
+                        if (array.offset === 0 && array.data.length === array.shape[0]) {
+                          this.length = updateTypeArray(this.gl, this.type, this.length, this.usage, array.data, offset);
+                        } else {
+                          this.length = updateTypeArray(this.gl, this.type, this.length, this.usage, array.data.subarray(array.offset, array.shape[0]), offset);
+                        }
+                      } else {
+                        var tmp2 = pool.malloc(array.size, dtype);
+                        var ndt = ndarray(tmp2, array.shape);
+                        ops.assign(ndt, array);
+                        if (offset < 0) {
+                          this.length = updateTypeArray(this.gl, this.type, this.length, this.usage, tmp2, offset);
+                        } else {
+                          this.length = updateTypeArray(this.gl, this.type, this.length, this.usage, tmp2.subarray(0, array.size), offset);
+                        }
+                        pool.free(tmp2);
+                      }
+                    } else if (Array.isArray(array)) {
+                      var t4;
+                      if (this.type === this.gl.ELEMENT_ARRAY_BUFFER) {
+                        t4 = makeScratchTypeArray(array, "uint16");
+                      } else {
+                        t4 = makeScratchTypeArray(array, "float32");
+                      }
+                      if (offset < 0) {
+                        this.length = updateTypeArray(this.gl, this.type, this.length, this.usage, t4, offset);
+                      } else {
+                        this.length = updateTypeArray(this.gl, this.type, this.length, this.usage, t4.subarray(0, array.length), offset);
+                      }
+                      pool.free(t4);
+                    } else if (typeof array === "object" && typeof array.length === "number") {
+                      this.length = updateTypeArray(this.gl, this.type, this.length, this.usage, array, offset);
+                    } else if (typeof array === "number" || array === void 0) {
+                      if (offset >= 0) {
+                        throw new Error("gl-buffer: Cannot specify offset when resizing buffer");
+                      }
+                      array = array | 0;
+                      if (array <= 0) {
+                        array = 1;
+                      }
+                      this.gl.bufferData(this.type, array | 0, this.usage);
+                      this.length = array;
+                    } else {
+                      throw new Error("gl-buffer: Invalid data type");
+                    }
+                  };
+                  function createBuffer(gl2, data, type, usage) {
+                    type = type || gl2.ARRAY_BUFFER;
+                    usage = usage || gl2.DYNAMIC_DRAW;
+                    if (type !== gl2.ARRAY_BUFFER && type !== gl2.ELEMENT_ARRAY_BUFFER) {
+                      throw new Error("gl-buffer: Invalid type for webgl buffer, must be either gl.ARRAY_BUFFER or gl.ELEMENT_ARRAY_BUFFER");
+                    }
+                    if (usage !== gl2.DYNAMIC_DRAW && usage !== gl2.STATIC_DRAW && usage !== gl2.STREAM_DRAW) {
+                      throw new Error("gl-buffer: Invalid usage for buffer, must be either gl.DYNAMIC_DRAW, gl.STATIC_DRAW or gl.STREAM_DRAW");
+                    }
+                    var handle = gl2.createBuffer();
+                    var result = new GLBuffer(gl2, type, handle, 0, usage);
+                    result.update(data);
+                    return result;
+                  }
+                  module22.exports = createBuffer;
+                }
+              ),
+              /***/
+              2825: (
+                /***/
+                function(module22) {
+                  module22.exports = fromValues;
+                  function fromValues(x2, y2, z2) {
+                    var out = new Float32Array(3);
+                    out[0] = x2;
+                    out[1] = y2;
+                    out[2] = z2;
+                    return out;
+                  }
+                }
+              ),
+              /***/
+              2931: (
+                /***/
+                function(module22, __unused_webpack_exports, __webpack_require__2) {
+                  module22.exports = {
+                    EPSILON: __webpack_require__2(2613),
+                    create: __webpack_require__2(1091),
+                    clone: __webpack_require__2(3126),
+                    angle: __webpack_require__2(8192),
+                    fromValues: __webpack_require__2(2825),
+                    copy: __webpack_require__2(3990),
+                    set: __webpack_require__2(1463),
+                    equals: __webpack_require__2(9922),
+                    exactEquals: __webpack_require__2(9265),
+                    add: __webpack_require__2(5632),
+                    subtract: __webpack_require__2(6843),
+                    sub: __webpack_require__2(2229),
+                    multiply: __webpack_require__2(5847),
+                    mul: __webpack_require__2(4505),
+                    divide: __webpack_require__2(6690),
+                    div: __webpack_require__2(4008),
+                    min: __webpack_require__2(8107),
+                    max: __webpack_require__2(7417),
+                    floor: __webpack_require__2(2681),
+                    ceil: __webpack_require__2(9226),
+                    round: __webpack_require__2(2447),
+                    scale: __webpack_require__2(6621),
+                    scaleAndAdd: __webpack_require__2(8489),
+                    distance: __webpack_require__2(7056),
+                    dist: __webpack_require__2(5455),
+                    squaredDistance: __webpack_require__2(2953),
+                    sqrDist: __webpack_require__2(6141),
+                    length: __webpack_require__2(1387),
+                    len: __webpack_require__2(868),
+                    squaredLength: __webpack_require__2(3066),
+                    sqrLen: __webpack_require__2(5486),
+                    negate: __webpack_require__2(5093),
+                    inverse: __webpack_require__2(811),
+                    normalize: __webpack_require__2(3536),
+                    dot: __webpack_require__2(244),
+                    cross: __webpack_require__2(5911),
+                    lerp: __webpack_require__2(6658),
+                    random: __webpack_require__2(7636),
+                    transformMat4: __webpack_require__2(5673),
+                    transformMat3: __webpack_require__2(492),
+                    transformQuat: __webpack_require__2(264),
+                    rotateX: __webpack_require__2(6894),
+                    rotateY: __webpack_require__2(109),
+                    rotateZ: __webpack_require__2(8692),
+                    forEach: __webpack_require__2(5137)
+                  };
+                }
+              ),
+              /***/
+              2933: (
+                /***/
+                function(module22) {
+                  module22.exports = copy;
+                  function copy(out, a2) {
+                    out[0] = a2[0];
+                    out[1] = a2[1];
+                    out[2] = a2[2];
+                    out[3] = a2[3];
+                    return out;
+                  }
+                }
+              ),
+              /***/
+              2953: (
+                /***/
+                function(module22) {
+                  module22.exports = squaredDistance;
+                  function squaredDistance(a2, b2) {
+                    var x2 = b2[0] - a2[0], y2 = b2[1] - a2[1], z2 = b2[2] - a2[2];
+                    return x2 * x2 + y2 * y2 + z2 * z2;
+                  }
+                }
+              ),
+              /***/
+              2962: (
+                /***/
+                function(module22, __unused_webpack_exports, __webpack_require__2) {
+                  var twoProduct = __webpack_require__2(5250);
+                  var robustSum = __webpack_require__2(8210);
+                  var robustScale = __webpack_require__2(3012);
+                  var compress = __webpack_require__2(7004);
+                  var NUM_EXPANDED = 6;
+                  function determinant_2(sum, scale2, prod, compress2) {
+                    return function robustDeterminant2(m2) {
+                      return compress2(sum(prod(m2[0][0], m2[1][1]), prod(-m2[0][1], m2[1][0])));
+                    };
+                  }
+                  function determinant_3(sum, scale2, prod, compress2) {
+                    return function robustDeterminant3(m2) {
+                      return compress2(sum(scale2(sum(prod(m2[1][1], m2[2][2]), prod(-m2[1][2], m2[2][1])), m2[0][0]), sum(scale2(sum(prod(m2[1][0], m2[2][2]), prod(-m2[1][2], m2[2][0])), -m2[0][1]), scale2(sum(prod(m2[1][0], m2[2][1]), prod(-m2[1][1], m2[2][0])), m2[0][2]))));
+                    };
+                  }
+                  function determinant_4(sum, scale2, prod, compress2) {
+                    return function robustDeterminant4(m2) {
+                      return compress2(sum(sum(scale2(sum(scale2(sum(prod(m2[2][2], m2[3][3]), prod(-m2[2][3], m2[3][2])), m2[1][1]), sum(scale2(sum(prod(m2[2][1], m2[3][3]), prod(-m2[2][3], m2[3][1])), -m2[1][2]), scale2(sum(prod(m2[2][1], m2[3][2]), prod(-m2[2][2], m2[3][1])), m2[1][3]))), m2[0][0]), scale2(sum(scale2(sum(prod(m2[2][2], m2[3][3]), prod(-m2[2][3], m2[3][2])), m2[1][0]), sum(scale2(sum(prod(m2[2][0], m2[3][3]), prod(-m2[2][3], m2[3][0])), -m2[1][2]), scale2(sum(prod(m2[2][0], m2[3][2]), prod(-m2[2][2], m2[3][0])), m2[1][3]))), -m2[0][1])), sum(scale2(sum(scale2(sum(prod(m2[2][1], m2[3][3]), prod(-m2[2][3], m2[3][1])), m2[1][0]), sum(scale2(sum(prod(m2[2][0], m2[3][3]), prod(-m2[2][3], m2[3][0])), -m2[1][1]), scale2(sum(prod(m2[2][0], m2[3][1]), prod(-m2[2][1], m2[3][0])), m2[1][3]))), m2[0][2]), scale2(sum(scale2(sum(prod(m2[2][1], m2[3][2]), prod(-m2[2][2], m2[3][1])), m2[1][0]), sum(scale2(sum(prod(m2[2][0], m2[3][2]), prod(-m2[2][2], m2[3][0])), -m2[1][1]), scale2(sum(prod(m2[2][0], m2[3][1]), prod(-m2[2][1], m2[3][0])), m2[1][2]))), -m2[0][3]))));
+                    };
+                  }
+                  function determinant_5(sum, scale2, prod, compress2) {
+                    return function robustDeterminant5(m2) {
+                      return compress2(sum(sum(scale2(sum(sum(scale2(sum(scale2(sum(prod(m2[3][3], m2[4][4]), prod(-m2[3][4], m2[4][3])), m2[2][2]), sum(scale2(sum(prod(m2[3][2], m2[4][4]), prod(-m2[3][4], m2[4][2])), -m2[2][3]), scale2(sum(prod(m2[3][2], m2[4][3]), prod(-m2[3][3], m2[4][2])), m2[2][4]))), m2[1][1]), scale2(sum(scale2(sum(prod(m2[3][3], m2[4][4]), prod(-m2[3][4], m2[4][3])), m2[2][1]), sum(scale2(sum(prod(m2[3][1], m2[4][4]), prod(-m2[3][4], m2[4][1])), -m2[2][3]), scale2(sum(prod(m2[3][1], m2[4][3]), prod(-m2[3][3], m2[4][1])), m2[2][4]))), -m2[1][2])), sum(scale2(sum(scale2(sum(prod(m2[3][2], m2[4][4]), prod(-m2[3][4], m2[4][2])), m2[2][1]), sum(scale2(sum(prod(m2[3][1], m2[4][4]), prod(-m2[3][4], m2[4][1])), -m2[2][2]), scale2(sum(prod(m2[3][1], m2[4][2]), prod(-m2[3][2], m2[4][1])), m2[2][4]))), m2[1][3]), scale2(sum(scale2(sum(prod(m2[3][2], m2[4][3]), prod(-m2[3][3], m2[4][2])), m2[2][1]), sum(scale2(sum(prod(m2[3][1], m2[4][3]), prod(-m2[3][3], m2[4][1])), -m2[2][2]), scale2(sum(prod(m2[3][1], m2[4][2]), prod(-m2[3][2], m2[4][1])), m2[2][3]))), -m2[1][4]))), m2[0][0]), scale2(sum(sum(scale2(sum(scale2(sum(prod(m2[3][3], m2[4][4]), prod(-m2[3][4], m2[4][3])), m2[2][2]), sum(scale2(sum(prod(m2[3][2], m2[4][4]), prod(-m2[3][4], m2[4][2])), -m2[2][3]), scale2(sum(prod(m2[3][2], m2[4][3]), prod(-m2[3][3], m2[4][2])), m2[2][4]))), m2[1][0]), scale2(sum(scale2(sum(prod(m2[3][3], m2[4][4]), prod(-m2[3][4], m2[4][3])), m2[2][0]), sum(scale2(sum(prod(m2[3][0], m2[4][4]), prod(-m2[3][4], m2[4][0])), -m2[2][3]), scale2(sum(prod(m2[3][0], m2[4][3]), prod(-m2[3][3], m2[4][0])), m2[2][4]))), -m2[1][2])), sum(scale2(sum(scale2(sum(prod(m2[3][2], m2[4][4]), prod(-m2[3][4], m2[4][2])), m2[2][0]), sum(scale2(sum(prod(m2[3][0], m2[4][4]), prod(-m2[3][4], m2[4][0])), -m2[2][2]), scale2(sum(prod(m2[3][0], m2[4][2]), prod(-m2[3][2], m2[4][0])), m2[2][4]))), m2[1][3]), scale2(sum(scale2(sum(prod(m2[3][2], m2[4][3]), prod(-m2[3][3], m2[4][2])), m2[2][0]), sum(scale2(sum(prod(m2[3][0], m2[4][3]), prod(-m2[3][3], m2[4][0])), -m2[2][2]), scale2(sum(prod(m2[3][0], m2[4][2]), prod(-m2[3][2], m2[4][0])), m2[2][3]))), -m2[1][4]))), -m2[0][1])), sum(scale2(sum(sum(scale2(sum(scale2(sum(prod(m2[3][3], m2[4][4]), prod(-m2[3][4], m2[4][3])), m2[2][1]), sum(scale2(sum(prod(m2[3][1], m2[4][4]), prod(-m2[3][4], m2[4][1])), -m2[2][3]), scale2(sum(prod(m2[3][1], m2[4][3]), prod(-m2[3][3], m2[4][1])), m2[2][4]))), m2[1][0]), scale2(sum(scale2(sum(prod(m2[3][3], m2[4][4]), prod(-m2[3][4], m2[4][3])), m2[2][0]), sum(scale2(sum(prod(m2[3][0], m2[4][4]), prod(-m2[3][4], m2[4][0])), -m2[2][3]), scale2(sum(prod(m2[3][0], m2[4][3]), prod(-m2[3][3], m2[4][0])), m2[2][4]))), -m2[1][1])), sum(scale2(sum(scale2(sum(prod(m2[3][1], m2[4][4]), prod(-m2[3][4], m2[4][1])), m2[2][0]), sum(scale2(sum(prod(m2[3][0], m2[4][4]), prod(-m2[3][4], m2[4][0])), -m2[2][1]), scale2(sum(prod(m2[3][0], m2[4][1]), prod(-m2[3][1], m2[4][0])), m2[2][4]))), m2[1][3]), scale2(sum(scale2(sum(prod(m2[3][1], m2[4][3]), prod(-m2[3][3], m2[4][1])), m2[2][0]), sum(scale2(sum(prod(m2[3][0], m2[4][3]), prod(-m2[3][3], m2[4][0])), -m2[2][1]), scale2(sum(prod(m2[3][0], m2[4][1]), prod(-m2[3][1], m2[4][0])), m2[2][3]))), -m2[1][4]))), m2[0][2]), sum(scale2(sum(sum(scale2(sum(scale2(sum(prod(m2[3][2], m2[4][4]), prod(-m2[3][4], m2[4][2])), m2[2][1]), sum(scale2(sum(prod(m2[3][1], m2[4][4]), prod(-m2[3][4], m2[4][1])), -m2[2][2]), scale2(sum(prod(m2[3][1], m2[4][2]), prod(-m2[3][2], m2[4][1])), m2[2][4]))), m2[1][0]), scale2(sum(scale2(sum(prod(m2[3][2], m2[4][4]), prod(-m2[3][4], m2[4][2])), m2[2][0]), sum(scale2(sum(prod(m2[3][0], m2[4][4]), prod(-m2[3][4], m2[4][0])), -m2[2][2]), scale2(sum(prod(m2[3][0], m2[4][2]), prod(-m2[3][2], m2[4][0])), m2[2][4]))), -m2[1][1])), sum(scale2(sum(scale2(sum(prod(m2[3][1], m2[4][4]), prod(-m2[3][4], m2[4][1])), m2[2][0]), sum(scale2(sum(prod(m2[3][0], m2[4][4]), prod(-m2[3][4], m2[4][0])), -m2[2][1]), scale2(sum(prod(m2[3][0], m2[4][1]), prod(-m2[3][1], m2[4][0])), m2[2][4]))), m2[1][2]), scale2(sum(scale2(sum(prod(m2[3][1], m2[4][2]), prod(-m2[3][2], m2[4][1])), m2[2][0]), sum(scale2(sum(prod(m2[3][0], m2[4][2]), prod(-m2[3][2], m2[4][0])), -m2[2][1]), scale2(sum(prod(m2[3][0], m2[4][1]), prod(-m2[3][1], m2[4][0])), m2[2][2]))), -m2[1][4]))), -m2[0][3]), scale2(sum(sum(scale2(sum(scale2(sum(prod(m2[3][2], m2[4][3]), prod(-m2[3][3], m2[4][2])), m2[2][1]), sum(scale2(sum(prod(m2[3][1], m2[4][3]), prod(-m2[3][3], m2[4][1])), -m2[2][2]), scale2(sum(prod(m2[3][1], m2[4][2]), prod(-m2[3][2], m2[4][1])), m2[2][3]))), m2[1][0]), scale2(sum(scale2(sum(prod(m2[3][2], m2[4][3]), prod(-m2[3][3], m2[4][2])), m2[2][0]), sum(scale2(sum(prod(m2[3][0], m2[4][3]), prod(-m2[3][3], m2[4][0])), -m2[2][2]), scale2(sum(prod(m2[3][0], m2[4][2]), prod(-m2[3][2], m2[4][0])), m2[2][3]))), -m2[1][1])), sum(scale2(sum(scale2(sum(prod(m2[3][1], m2[4][3]), prod(-m2[3][3], m2[4][1])), m2[2][0]), sum(scale2(sum(prod(m2[3][0], m2[4][3]), prod(-m2[3][3], m2[4][0])), -m2[2][1]), scale2(sum(prod(m2[3][0], m2[4][1]), prod(-m2[3][1], m2[4][0])), m2[2][3]))), m2[1][2]), scale2(sum(scale2(sum(prod(m2[3][1], m2[4][2]), prod(-m2[3][2], m2[4][1])), m2[2][0]), sum(scale2(sum(prod(m2[3][0], m2[4][2]), prod(-m2[3][2], m2[4][0])), -m2[2][1]), scale2(sum(prod(m2[3][0], m2[4][1]), prod(-m2[3][1], m2[4][0])), m2[2][2]))), -m2[1][3]))), m2[0][4])))));
+                    };
+                  }
+                  function compileDeterminant(n2) {
+                    var fn = n2 === 2 ? determinant_2 : n2 === 3 ? determinant_3 : n2 === 4 ? determinant_4 : n2 === 5 ? determinant_5 : void 0;
+                    return fn(robustSum, robustScale, twoProduct, compress);
+                  }
+                  var CACHE = [
+                    function robustDeterminant0() {
+                      return [0];
+                    },
+                    function robustDeterminant1(m2) {
+                      return [m2[0][0]];
+                    }
+                  ];
+                  function proc(det0, det1, det2, det3, det4, det5, CACHE2, gen) {
+                    return function robustDeterminant(m2) {
+                      switch (m2.length) {
+                        case 0:
+                          return det0(m2);
+                        case 1:
+                          return det1(m2);
+                        case 2:
+                          return det2(m2);
+                        case 3:
+                          return det3(m2);
+                        case 4:
+                          return det4(m2);
+                        case 5:
+                          return det5(m2);
+                      }
+                      var det = CACHE2[m2.length];
+                      if (!det) det = CACHE2[m2.length] = gen(m2.length);
+                      return det(m2);
+                    };
+                  }
+                  function generateDispatch() {
+                    while (CACHE.length < NUM_EXPANDED) {
+                      CACHE.push(compileDeterminant(CACHE.length));
+                    }
+                    module22.exports = proc.apply(void 0, CACHE.concat([CACHE, compileDeterminant]));
+                    for (var i2 = 0; i2 < CACHE.length; ++i2) {
+                      module22.exports[i2] = CACHE[i2];
+                    }
+                  }
+                  generateDispatch();
+                }
+              ),
+              /***/
+              2992: (
+                /***/
+                function(module22, __unused_webpack_exports, __webpack_require__2) {
+                  var sprintf = __webpack_require__2(3387).sprintf;
+                  var glConstants = __webpack_require__2(5171);
+                  var shaderName = __webpack_require__2(1848);
+                  var addLineNumbers = __webpack_require__2(1085);
+                  module22.exports = formatCompilerError;
+                  function formatCompilerError(errLog, src, type) {
+                    var name2 = shaderName(src) || "of unknown name (see npm glsl-shader-name)";
+                    var typeName = "unknown type";
+                    if (type !== void 0) {
+                      typeName = type === glConstants.FRAGMENT_SHADER ? "fragment" : "vertex";
+                    }
+                    var longForm = sprintf("Error compiling %s shader %s:\n", typeName, name2);
+                    var shortForm = sprintf("%s%s", longForm, errLog);
+                    var errorStrings = errLog.split("\n");
+                    var errors = {};
+                    for (var i2 = 0; i2 < errorStrings.length; i2++) {
+                      var errorString = errorStrings[i2];
+                      if (errorString === "" || errorString === "\0") continue;
+                      var lineNo = parseInt(errorString.split(":")[2]);
+                      if (isNaN(lineNo)) {
+                        throw new Error(sprintf("Could not parse error: %s", errorString));
+                      }
+                      errors[lineNo] = errorString;
+                    }
+                    var lines = addLineNumbers(src).split("\n");
+                    for (var i2 = 0; i2 < lines.length; i2++) {
+                      if (!errors[i2 + 3] && !errors[i2 + 2] && !errors[i2 + 1]) continue;
+                      var line = lines[i2];
+                      longForm += line + "\n";
+                      if (errors[i2 + 1]) {
+                        var e2 = errors[i2 + 1];
+                        e2 = e2.substr(e2.split(":", 3).join(":").length + 1).trim();
+                        longForm += sprintf("^^^ %s\n\n", e2);
+                      }
+                    }
+                    return {
+                      long: longForm.trim(),
+                      short: shortForm.trim()
+                    };
+                  }
+                }
+              ),
+              /***/
+              3012: (
+                /***/
+                function(module22, __unused_webpack_exports, __webpack_require__2) {
+                  var twoProduct = __webpack_require__2(5250);
+                  var twoSum = __webpack_require__2(9362);
+                  module22.exports = scaleLinearExpansion;
+                  function scaleLinearExpansion(e2, scale2) {
+                    var n2 = e2.length;
+                    if (n2 === 1) {
+                      var ts = twoProduct(e2[0], scale2);
+                      if (ts[0]) {
+                        return ts;
+                      }
+                      return [ts[1]];
+                    }
+                    var g2 = new Array(2 * n2);
+                    var q2 = [0.1, 0.1];
+                    var t4 = [0.1, 0.1];
+                    var count2 = 0;
+                    twoProduct(e2[0], scale2, q2);
+                    if (q2[0]) {
+                      g2[count2++] = q2[0];
+                    }
+                    for (var i2 = 1; i2 < n2; ++i2) {
+                      twoProduct(e2[i2], scale2, t4);
+                      var pq = q2[1];
+                      twoSum(pq, t4[0], q2);
+                      if (q2[0]) {
+                        g2[count2++] = q2[0];
+                      }
+                      var a2 = t4[1];
+                      var b2 = q2[1];
+                      var x2 = a2 + b2;
+                      var bv = x2 - a2;
+                      var y2 = b2 - bv;
+                      q2[1] = x2;
+                      if (y2) {
+                        g2[count2++] = y2;
+                      }
+                    }
+                    if (q2[1]) {
+                      g2[count2++] = q2[1];
+                    }
+                    if (count2 === 0) {
+                      g2[count2++] = 0;
+                    }
+                    g2.length = count2;
+                    return g2;
+                  }
+                }
+              ),
+              /***/
+              3025: (
+                /***/
+                function(module22, __unused_webpack_exports, __webpack_require__2) {
+                  module22.exports = __webpack_require__2.g.performance && __webpack_require__2.g.performance.now ? function now() {
+                    return performance.now();
+                  } : Date.now || function now() {
+                    return +/* @__PURE__ */ new Date();
+                  };
+                }
+              ),
+              /***/
+              3066: (
+                /***/
+                function(module22) {
+                  module22.exports = squaredLength2;
+                  function squaredLength2(a2) {
+                    var x2 = a2[0], y2 = a2[1], z2 = a2[2];
+                    return x2 * x2 + y2 * y2 + z2 * z2;
+                  }
+                }
+              ),
+              /***/
+              3088: (
+                /***/
+                function(module22, __unused_webpack_exports, __webpack_require__2) {
+                  module22.exports = planarDual;
+                  var compareAngle = __webpack_require__2(3140);
+                  function planarDual(cells, positions) {
+                    var numVertices = positions.length | 0;
+                    var numEdges = cells.length;
+                    var adj = [new Array(numVertices), new Array(numVertices)];
+                    for (var i2 = 0; i2 < numVertices; ++i2) {
+                      adj[0][i2] = [];
+                      adj[1][i2] = [];
+                    }
+                    for (var i2 = 0; i2 < numEdges; ++i2) {
+                      var c2 = cells[i2];
+                      adj[0][c2[0]].push(c2);
+                      adj[1][c2[1]].push(c2);
+                    }
+                    var cycles = [];
+                    for (var i2 = 0; i2 < numVertices; ++i2) {
+                      if (adj[0][i2].length + adj[1][i2].length === 0) {
+                        cycles.push([i2]);
+                      }
+                    }
+                    function cut(c22, i22) {
+                      var a2 = adj[i22][c22[i22]];
+                      a2.splice(a2.indexOf(c22), 1);
+                    }
+                    function next(a2, b2, noCut) {
+                      var nextCell, nextVertex, nextDir;
+                      for (var i22 = 0; i22 < 2; ++i22) {
+                        if (adj[i22][b2].length > 0) {
+                          nextCell = adj[i22][b2][0];
+                          nextDir = i22;
+                          break;
+                        }
+                      }
+                      nextVertex = nextCell[nextDir ^ 1];
+                      for (var dir = 0; dir < 2; ++dir) {
+                        var nbhd = adj[dir][b2];
+                        for (var k2 = 0; k2 < nbhd.length; ++k2) {
+                          var e2 = nbhd[k2];
+                          var p2 = e2[dir ^ 1];
+                          var cmp = compareAngle(
+                            positions[a2],
+                            positions[b2],
+                            positions[nextVertex],
+                            positions[p2]
+                          );
+                          if (cmp > 0) {
+                            nextCell = e2;
+                            nextVertex = p2;
+                            nextDir = dir;
+                          }
+                        }
+                      }
+                      if (noCut) {
+                        return nextVertex;
+                      }
+                      if (nextCell) {
+                        cut(nextCell, nextDir);
+                      }
+                      return nextVertex;
+                    }
+                    function extractCycle(v2, dir) {
+                      var e0 = adj[dir][v2][0];
+                      var cycle = [v2];
+                      cut(e0, dir);
+                      var u2 = e0[dir ^ 1];
+                      while (true) {
+                        while (u2 !== v2) {
+                          cycle.push(u2);
+                          u2 = next(cycle[cycle.length - 2], u2, false);
+                        }
+                        if (adj[0][v2].length + adj[1][v2].length === 0) {
+                          break;
+                        }
+                        var a2 = cycle[cycle.length - 1];
+                        var b2 = v2;
+                        var c22 = cycle[1];
+                        var d2 = next(a2, b2, true);
+                        if (compareAngle(positions[a2], positions[b2], positions[c22], positions[d2]) < 0) {
+                          break;
+                        }
+                        cycle.push(v2);
+                        u2 = next(a2, b2);
+                      }
+                      return cycle;
+                    }
+                    function shouldGlue(pcycle2, ncycle2) {
+                      return ncycle2[1] === ncycle2[ncycle2.length - 1];
+                    }
+                    for (var i2 = 0; i2 < numVertices; ++i2) {
+                      for (var j2 = 0; j2 < 2; ++j2) {
+                        var pcycle = [];
+                        while (adj[j2][i2].length > 0) {
+                          adj[0][i2].length;
+                          var ncycle = extractCycle(i2, j2);
+                          if (shouldGlue(pcycle, ncycle)) {
+                            pcycle.push.apply(pcycle, ncycle);
+                          } else {
+                            if (pcycle.length > 0) {
+                              cycles.push(pcycle);
+                            }
+                            pcycle = ncycle;
+                          }
+                        }
+                        if (pcycle.length > 0) {
+                          cycles.push(pcycle);
+                        }
+                      }
+                    }
+                    return cycles;
+                  }
+                }
+              ),
+              /***/
+              3090: (
+                /***/
+                function(module22, __unused_webpack_exports, __webpack_require__2) {
+                  module22.exports = monotoneConvexHull2D;
+                  var orient = __webpack_require__2(3250)[3];
+                  function monotoneConvexHull2D(points) {
+                    var n2 = points.length;
+                    if (n2 < 3) {
+                      var result = new Array(n2);
+                      for (var i2 = 0; i2 < n2; ++i2) {
+                        result[i2] = i2;
+                      }
+                      if (n2 === 2 && points[0][0] === points[1][0] && points[0][1] === points[1][1]) {
+                        return [0];
+                      }
+                      return result;
+                    }
+                    var sorted = new Array(n2);
+                    for (var i2 = 0; i2 < n2; ++i2) {
+                      sorted[i2] = i2;
+                    }
+                    sorted.sort(function(a2, b2) {
+                      var d2 = points[a2][0] - points[b2][0];
+                      if (d2) {
+                        return d2;
+                      }
+                      return points[a2][1] - points[b2][1];
+                    });
+                    var lower = [sorted[0], sorted[1]];
+                    var upper = [sorted[0], sorted[1]];
+                    for (var i2 = 2; i2 < n2; ++i2) {
+                      var idx = sorted[i2];
+                      var p2 = points[idx];
+                      var m2 = lower.length;
+                      while (m2 > 1 && orient(
+                        points[lower[m2 - 2]],
+                        points[lower[m2 - 1]],
+                        p2
+                      ) <= 0) {
+                        m2 -= 1;
+                        lower.pop();
+                      }
+                      lower.push(idx);
+                      m2 = upper.length;
+                      while (m2 > 1 && orient(
+                        points[upper[m2 - 2]],
+                        points[upper[m2 - 1]],
+                        p2
+                      ) >= 0) {
+                        m2 -= 1;
+                        upper.pop();
+                      }
+                      upper.push(idx);
+                    }
+                    var result = new Array(upper.length + lower.length - 2);
+                    var ptr = 0;
+                    for (var i2 = 0, nl2 = lower.length; i2 < nl2; ++i2) {
+                      result[ptr++] = lower[i2];
+                    }
+                    for (var j2 = upper.length - 2; j2 > 0; --j2) {
+                      result[ptr++] = upper[j2];
+                    }
+                    return result;
+                  }
+                }
+              ),
+              /***/
+              3105: (
+                /***/
+                function(__unused_webpack_module, exports2) {
+                  "use restrict";
+                  var INT_BITS = 32;
+                  exports2.INT_BITS = INT_BITS;
+                  exports2.INT_MAX = 2147483647;
+                  exports2.INT_MIN = -1 << INT_BITS - 1;
+                  exports2.sign = function(v2) {
+                    return (v2 > 0) - (v2 < 0);
+                  };
+                  exports2.abs = function(v2) {
+                    var mask = v2 >> INT_BITS - 1;
+                    return (v2 ^ mask) - mask;
+                  };
+                  exports2.min = function(x2, y2) {
+                    return y2 ^ (x2 ^ y2) & -(x2 < y2);
+                  };
+                  exports2.max = function(x2, y2) {
+                    return x2 ^ (x2 ^ y2) & -(x2 < y2);
+                  };
+                  exports2.isPow2 = function(v2) {
+                    return !(v2 & v2 - 1) && !!v2;
+                  };
+                  exports2.log2 = function(v2) {
+                    var r2, shift;
+                    r2 = (v2 > 65535) << 4;
+                    v2 >>>= r2;
+                    shift = (v2 > 255) << 3;
+                    v2 >>>= shift;
+                    r2 |= shift;
+                    shift = (v2 > 15) << 2;
+                    v2 >>>= shift;
+                    r2 |= shift;
+                    shift = (v2 > 3) << 1;
+                    v2 >>>= shift;
+                    r2 |= shift;
+                    return r2 | v2 >> 1;
+                  };
+                  exports2.log10 = function(v2) {
+                    return v2 >= 1e9 ? 9 : v2 >= 1e8 ? 8 : v2 >= 1e7 ? 7 : v2 >= 1e6 ? 6 : v2 >= 1e5 ? 5 : v2 >= 1e4 ? 4 : v2 >= 1e3 ? 3 : v2 >= 100 ? 2 : v2 >= 10 ? 1 : 0;
+                  };
+                  exports2.popCount = function(v2) {
+                    v2 = v2 - (v2 >>> 1 & 1431655765);
+                    v2 = (v2 & 858993459) + (v2 >>> 2 & 858993459);
+                    return (v2 + (v2 >>> 4) & 252645135) * 16843009 >>> 24;
+                  };
+                  function countTrailingZeros(v2) {
+                    var c2 = 32;
+                    v2 &= -v2;
+                    if (v2) c2--;
+                    if (v2 & 65535) c2 -= 16;
+                    if (v2 & 16711935) c2 -= 8;
+                    if (v2 & 252645135) c2 -= 4;
+                    if (v2 & 858993459) c2 -= 2;
+                    if (v2 & 1431655765) c2 -= 1;
+                    return c2;
+                  }
+                  exports2.countTrailingZeros = countTrailingZeros;
+                  exports2.nextPow2 = function(v2) {
+                    v2 += v2 === 0;
+                    --v2;
+                    v2 |= v2 >>> 1;
+                    v2 |= v2 >>> 2;
+                    v2 |= v2 >>> 4;
+                    v2 |= v2 >>> 8;
+                    v2 |= v2 >>> 16;
+                    return v2 + 1;
+                  };
+                  exports2.prevPow2 = function(v2) {
+                    v2 |= v2 >>> 1;
+                    v2 |= v2 >>> 2;
+                    v2 |= v2 >>> 4;
+                    v2 |= v2 >>> 8;
+                    v2 |= v2 >>> 16;
+                    return v2 - (v2 >>> 1);
+                  };
+                  exports2.parity = function(v2) {
+                    v2 ^= v2 >>> 16;
+                    v2 ^= v2 >>> 8;
+                    v2 ^= v2 >>> 4;
+                    v2 &= 15;
+                    return 27030 >>> v2 & 1;
+                  };
+                  var REVERSE_TABLE = new Array(256);
+                  (function(tab) {
+                    for (var i2 = 0; i2 < 256; ++i2) {
+                      var v2 = i2, r2 = i2, s2 = 7;
+                      for (v2 >>>= 1; v2; v2 >>>= 1) {
+                        r2 <<= 1;
+                        r2 |= v2 & 1;
+                        --s2;
+                      }
+                      tab[i2] = r2 << s2 & 255;
+                    }
+                  })(REVERSE_TABLE);
+                  exports2.reverse = function(v2) {
+                    return REVERSE_TABLE[v2 & 255] << 24 | REVERSE_TABLE[v2 >>> 8 & 255] << 16 | REVERSE_TABLE[v2 >>> 16 & 255] << 8 | REVERSE_TABLE[v2 >>> 24 & 255];
+                  };
+                  exports2.interleave2 = function(x2, y2) {
+                    x2 &= 65535;
+                    x2 = (x2 | x2 << 8) & 16711935;
+                    x2 = (x2 | x2 << 4) & 252645135;
+                    x2 = (x2 | x2 << 2) & 858993459;
+                    x2 = (x2 | x2 << 1) & 1431655765;
+                    y2 &= 65535;
+                    y2 = (y2 | y2 << 8) & 16711935;
+                    y2 = (y2 | y2 << 4) & 252645135;
+                    y2 = (y2 | y2 << 2) & 858993459;
+                    y2 = (y2 | y2 << 1) & 1431655765;
+                    return x2 | y2 << 1;
+                  };
+                  exports2.deinterleave2 = function(v2, n2) {
+                    v2 = v2 >>> n2 & 1431655765;
+                    v2 = (v2 | v2 >>> 1) & 858993459;
+                    v2 = (v2 | v2 >>> 2) & 252645135;
+                    v2 = (v2 | v2 >>> 4) & 16711935;
+                    v2 = (v2 | v2 >>> 16) & 65535;
+                    return v2 << 16 >> 16;
+                  };
+                  exports2.interleave3 = function(x2, y2, z2) {
+                    x2 &= 1023;
+                    x2 = (x2 | x2 << 16) & 4278190335;
+                    x2 = (x2 | x2 << 8) & 251719695;
+                    x2 = (x2 | x2 << 4) & 3272356035;
+                    x2 = (x2 | x2 << 2) & 1227133513;
+                    y2 &= 1023;
+                    y2 = (y2 | y2 << 16) & 4278190335;
+                    y2 = (y2 | y2 << 8) & 251719695;
+                    y2 = (y2 | y2 << 4) & 3272356035;
+                    y2 = (y2 | y2 << 2) & 1227133513;
+                    x2 |= y2 << 1;
+                    z2 &= 1023;
+                    z2 = (z2 | z2 << 16) & 4278190335;
+                    z2 = (z2 | z2 << 8) & 251719695;
+                    z2 = (z2 | z2 << 4) & 3272356035;
+                    z2 = (z2 | z2 << 2) & 1227133513;
+                    return x2 | z2 << 2;
+                  };
+                  exports2.deinterleave3 = function(v2, n2) {
+                    v2 = v2 >>> n2 & 1227133513;
+                    v2 = (v2 | v2 >>> 2) & 3272356035;
+                    v2 = (v2 | v2 >>> 4) & 251719695;
+                    v2 = (v2 | v2 >>> 8) & 4278190335;
+                    v2 = (v2 | v2 >>> 16) & 1023;
+                    return v2 << 22 >> 22;
+                  };
+                  exports2.nextCombination = function(v2) {
+                    var t4 = v2 | v2 - 1;
+                    return t4 + 1 | (~t4 & -~t4) - 1 >>> countTrailingZeros(v2) + 1;
+                  };
+                }
+              ),
+              /***/
+              3126: (
+                /***/
+                function(module22) {
+                  module22.exports = clone;
+                  function clone(a2) {
+                    var out = new Float32Array(3);
+                    out[0] = a2[0];
+                    out[1] = a2[1];
+                    out[2] = a2[2];
+                    return out;
+                  }
+                }
+              ),
+              /***/
+              3134: (
+                /***/
+                function(module22, __unused_webpack_exports, __webpack_require__2) {
+                  module22.exports = edgeToAdjacency;
+                  var uniq = __webpack_require__2(1682);
+                  function edgeToAdjacency(edges, numVertices) {
+                    var numEdges = edges.length;
+                    if (typeof numVertices !== "number") {
+                      numVertices = 0;
+                      for (var i2 = 0; i2 < numEdges; ++i2) {
+                        var e2 = edges[i2];
+                        numVertices = Math.max(numVertices, e2[0], e2[1]);
+                      }
+                      numVertices = (numVertices | 0) + 1;
+                    }
+                    numVertices = numVertices | 0;
+                    var adj = new Array(numVertices);
+                    for (var i2 = 0; i2 < numVertices; ++i2) {
+                      adj[i2] = [];
+                    }
+                    for (var i2 = 0; i2 < numEdges; ++i2) {
+                      var e2 = edges[i2];
+                      adj[e2[0]].push(e2[1]);
+                      adj[e2[1]].push(e2[0]);
+                    }
+                    for (var j2 = 0; j2 < numVertices; ++j2) {
+                      uniq(adj[j2], function(a2, b2) {
+                        return a2 - b2;
+                      });
+                    }
+                    return adj;
+                  }
+                }
+              ),
+              /***/
+              3140: (
+                /***/
+                function(module22, __unused_webpack_exports, __webpack_require__2) {
+                  module22.exports = compareAngle;
+                  var orient = __webpack_require__2(3250);
+                  var sgn = __webpack_require__2(8572);
+                  var twoSum = __webpack_require__2(9362);
+                  var robustProduct = __webpack_require__2(5382);
+                  var robustSum = __webpack_require__2(8210);
+                  function testInterior(a2, b2, c2) {
+                    var x0 = twoSum(a2[0], -b2[0]);
+                    var y0 = twoSum(a2[1], -b2[1]);
+                    var x1 = twoSum(c2[0], -b2[0]);
+                    var y1 = twoSum(c2[1], -b2[1]);
+                    var d2 = robustSum(
+                      robustProduct(x0, x1),
+                      robustProduct(y0, y1)
+                    );
+                    return d2[d2.length - 1] >= 0;
+                  }
+                  function compareAngle(a2, b2, c2, d2) {
+                    var bcd = orient(b2, c2, d2);
+                    if (bcd === 0) {
+                      var sabc = sgn(orient(a2, b2, c2));
+                      var sabd = sgn(orient(a2, b2, d2));
+                      if (sabc === sabd) {
+                        if (sabc === 0) {
+                          var ic2 = testInterior(a2, b2, c2);
+                          var id2 = testInterior(a2, b2, d2);
+                          if (ic2 === id2) {
+                            return 0;
+                          } else if (ic2) {
+                            return 1;
+                          } else {
+                            return -1;
+                          }
+                        }
+                        return 0;
+                      } else if (sabd === 0) {
+                        if (sabc > 0) {
+                          return -1;
+                        } else if (testInterior(a2, b2, d2)) {
+                          return -1;
+                        } else {
+                          return 1;
+                        }
+                      } else if (sabc === 0) {
+                        if (sabd > 0) {
+                          return 1;
+                        } else if (testInterior(a2, b2, c2)) {
+                          return 1;
+                        } else {
+                          return -1;
+                        }
+                      }
+                      return sgn(sabd - sabc);
+                    }
+                    var abc = orient(a2, b2, c2);
+                    if (abc > 0) {
+                      if (bcd > 0 && orient(a2, b2, d2) > 0) {
+                        return 1;
+                      }
+                      return -1;
+                    } else if (abc < 0) {
+                      if (bcd > 0 || orient(a2, b2, d2) > 0) {
+                        return 1;
+                      }
+                      return -1;
+                    } else {
+                      var abd = orient(a2, b2, d2);
+                      if (abd > 0) {
+                        return 1;
+                      } else {
+                        if (testInterior(a2, b2, c2)) {
+                          return 1;
+                        } else {
+                          return -1;
+                        }
+                      }
+                    }
+                  }
+                }
+              ),
+              /***/
+              3202: (
+                /***/
+                function(module22) {
+                  module22.exports = function parseUnit(str, out) {
+                    if (!out)
+                      out = [0, ""];
+                    str = String(str);
+                    var num = parseFloat(str, 10);
+                    out[0] = num;
+                    out[1] = str.match(/[\d.\-\+]*\s*(.*)/)[1] || "";
+                    return out;
+                  };
+                }
+              ),
+              /***/
+              3233: (
+                /***/
+                function(module22) {
+                  var res = "";
+                  var cache;
+                  module22.exports = repeat;
+                  function repeat(str, num) {
+                    if (typeof str !== "string") {
+                      throw new TypeError("expected a string");
+                    }
+                    if (num === 1) return str;
+                    if (num === 2) return str + str;
+                    var max = str.length * num;
+                    if (cache !== str || typeof cache === "undefined") {
+                      cache = str;
+                      res = "";
+                    } else if (res.length >= max) {
+                      return res.substr(0, max);
+                    }
+                    while (max > res.length && num > 1) {
+                      if (num & 1) {
+                        res += str;
+                      }
+                      num >>= 1;
+                      str += str;
+                    }
+                    res += str;
+                    res = res.substr(0, max);
+                    return res;
+                  }
+                }
+              ),
+              /***/
+              3236: (
+                /***/
+                function(module22) {
+                  module22.exports = function(strings) {
+                    if (typeof strings === "string") strings = [strings];
+                    var exprs = [].slice.call(arguments, 1);
+                    var parts = [];
+                    for (var i2 = 0; i2 < strings.length - 1; i2++) {
+                      parts.push(strings[i2], exprs[i2] || "");
+                    }
+                    parts.push(strings[i2]);
+                    return parts.join("");
+                  };
+                }
+              ),
+              /***/
+              3250: (
+                /***/
+                function(module22, __unused_webpack_exports, __webpack_require__2) {
+                  var twoProduct = __webpack_require__2(5250);
+                  var robustSum = __webpack_require__2(8210);
+                  var robustScale = __webpack_require__2(3012);
+                  var robustSubtract = __webpack_require__2(8545);
+                  var NUM_EXPAND = 5;
+                  var EPSILON2 = 11102230246251565e-32;
+                  var ERRBOUND3 = (3 + 16 * EPSILON2) * EPSILON2;
+                  var ERRBOUND4 = (7 + 56 * EPSILON2) * EPSILON2;
+                  function orientation_3(sum, prod, scale2, sub2) {
+                    return function orientation3Exact2(m0, m1, m2) {
+                      var p2 = sum(sum(prod(m1[1], m2[0]), prod(-m2[1], m1[0])), sum(prod(m0[1], m1[0]), prod(-m1[1], m0[0])));
+                      var n2 = sum(prod(m0[1], m2[0]), prod(-m2[1], m0[0]));
+                      var d2 = sub2(p2, n2);
+                      return d2[d2.length - 1];
+                    };
+                  }
+                  function orientation_4(sum, prod, scale2, sub2) {
+                    return function orientation4Exact2(m0, m1, m2, m3) {
+                      var p2 = sum(sum(scale2(sum(prod(m2[1], m3[0]), prod(-m3[1], m2[0])), m1[2]), sum(scale2(sum(prod(m1[1], m3[0]), prod(-m3[1], m1[0])), -m2[2]), scale2(sum(prod(m1[1], m2[0]), prod(-m2[1], m1[0])), m3[2]))), sum(scale2(sum(prod(m1[1], m3[0]), prod(-m3[1], m1[0])), m0[2]), sum(scale2(sum(prod(m0[1], m3[0]), prod(-m3[1], m0[0])), -m1[2]), scale2(sum(prod(m0[1], m1[0]), prod(-m1[1], m0[0])), m3[2]))));
+                      var n2 = sum(sum(scale2(sum(prod(m2[1], m3[0]), prod(-m3[1], m2[0])), m0[2]), sum(scale2(sum(prod(m0[1], m3[0]), prod(-m3[1], m0[0])), -m2[2]), scale2(sum(prod(m0[1], m2[0]), prod(-m2[1], m0[0])), m3[2]))), sum(scale2(sum(prod(m1[1], m2[0]), prod(-m2[1], m1[0])), m0[2]), sum(scale2(sum(prod(m0[1], m2[0]), prod(-m2[1], m0[0])), -m1[2]), scale2(sum(prod(m0[1], m1[0]), prod(-m1[1], m0[0])), m2[2]))));
+                      var d2 = sub2(p2, n2);
+                      return d2[d2.length - 1];
+                    };
+                  }
+                  function orientation_5(sum, prod, scale2, sub2) {
+                    return function orientation5Exact(m0, m1, m2, m3, m4) {
+                      var p2 = sum(sum(sum(scale2(sum(scale2(sum(prod(m3[1], m4[0]), prod(-m4[1], m3[0])), m2[2]), sum(scale2(sum(prod(m2[1], m4[0]), prod(-m4[1], m2[0])), -m3[2]), scale2(sum(prod(m2[1], m3[0]), prod(-m3[1], m2[0])), m4[2]))), m1[3]), sum(scale2(sum(scale2(sum(prod(m3[1], m4[0]), prod(-m4[1], m3[0])), m1[2]), sum(scale2(sum(prod(m1[1], m4[0]), prod(-m4[1], m1[0])), -m3[2]), scale2(sum(prod(m1[1], m3[0]), prod(-m3[1], m1[0])), m4[2]))), -m2[3]), scale2(sum(scale2(sum(prod(m2[1], m4[0]), prod(-m4[1], m2[0])), m1[2]), sum(scale2(sum(prod(m1[1], m4[0]), prod(-m4[1], m1[0])), -m2[2]), scale2(sum(prod(m1[1], m2[0]), prod(-m2[1], m1[0])), m4[2]))), m3[3]))), sum(scale2(sum(scale2(sum(prod(m2[1], m3[0]), prod(-m3[1], m2[0])), m1[2]), sum(scale2(sum(prod(m1[1], m3[0]), prod(-m3[1], m1[0])), -m2[2]), scale2(sum(prod(m1[1], m2[0]), prod(-m2[1], m1[0])), m3[2]))), -m4[3]), sum(scale2(sum(scale2(sum(prod(m3[1], m4[0]), prod(-m4[1], m3[0])), m1[2]), sum(scale2(sum(prod(m1[1], m4[0]), prod(-m4[1], m1[0])), -m3[2]), scale2(sum(prod(m1[1], m3[0]), prod(-m3[1], m1[0])), m4[2]))), m0[3]), scale2(sum(scale2(sum(prod(m3[1], m4[0]), prod(-m4[1], m3[0])), m0[2]), sum(scale2(sum(prod(m0[1], m4[0]), prod(-m4[1], m0[0])), -m3[2]), scale2(sum(prod(m0[1], m3[0]), prod(-m3[1], m0[0])), m4[2]))), -m1[3])))), sum(sum(scale2(sum(scale2(sum(prod(m1[1], m4[0]), prod(-m4[1], m1[0])), m0[2]), sum(scale2(sum(prod(m0[1], m4[0]), prod(-m4[1], m0[0])), -m1[2]), scale2(sum(prod(m0[1], m1[0]), prod(-m1[1], m0[0])), m4[2]))), m3[3]), sum(scale2(sum(scale2(sum(prod(m1[1], m3[0]), prod(-m3[1], m1[0])), m0[2]), sum(scale2(sum(prod(m0[1], m3[0]), prod(-m3[1], m0[0])), -m1[2]), scale2(sum(prod(m0[1], m1[0]), prod(-m1[1], m0[0])), m3[2]))), -m4[3]), scale2(sum(scale2(sum(prod(m2[1], m3[0]), prod(-m3[1], m2[0])), m1[2]), sum(scale2(sum(prod(m1[1], m3[0]), prod(-m3[1], m1[0])), -m2[2]), scale2(sum(prod(m1[1], m2[0]), prod(-m2[1], m1[0])), m3[2]))), m0[3]))), sum(scale2(sum(scale2(sum(prod(m2[1], m3[0]), prod(-m3[1], m2[0])), m0[2]), sum(scale2(sum(prod(m0[1], m3[0]), prod(-m3[1], m0[0])), -m2[2]), scale2(sum(prod(m0[1], m2[0]), prod(-m2[1], m0[0])), m3[2]))), -m1[3]), sum(scale2(sum(scale2(sum(prod(m1[1], m3[0]), prod(-m3[1], m1[0])), m0[2]), sum(scale2(sum(prod(m0[1], m3[0]), prod(-m3[1], m0[0])), -m1[2]), scale2(sum(prod(m0[1], m1[0]), prod(-m1[1], m0[0])), m3[2]))), m2[3]), scale2(sum(scale2(sum(prod(m1[1], m2[0]), prod(-m2[1], m1[0])), m0[2]), sum(scale2(sum(prod(m0[1], m2[0]), prod(-m2[1], m0[0])), -m1[2]), scale2(sum(prod(m0[1], m1[0]), prod(-m1[1], m0[0])), m2[2]))), -m3[3])))));
+                      var n2 = sum(sum(sum(scale2(sum(scale2(sum(prod(m3[1], m4[0]), prod(-m4[1], m3[0])), m2[2]), sum(scale2(sum(prod(m2[1], m4[0]), prod(-m4[1], m2[0])), -m3[2]), scale2(sum(prod(m2[1], m3[0]), prod(-m3[1], m2[0])), m4[2]))), m0[3]), scale2(sum(scale2(sum(prod(m3[1], m4[0]), prod(-m4[1], m3[0])), m0[2]), sum(scale2(sum(prod(m0[1], m4[0]), prod(-m4[1], m0[0])), -m3[2]), scale2(sum(prod(m0[1], m3[0]), prod(-m3[1], m0[0])), m4[2]))), -m2[3])), sum(scale2(sum(scale2(sum(prod(m2[1], m4[0]), prod(-m4[1], m2[0])), m0[2]), sum(scale2(sum(prod(m0[1], m4[0]), prod(-m4[1], m0[0])), -m2[2]), scale2(sum(prod(m0[1], m2[0]), prod(-m2[1], m0[0])), m4[2]))), m3[3]), scale2(sum(scale2(sum(prod(m2[1], m3[0]), prod(-m3[1], m2[0])), m0[2]), sum(scale2(sum(prod(m0[1], m3[0]), prod(-m3[1], m0[0])), -m2[2]), scale2(sum(prod(m0[1], m2[0]), prod(-m2[1], m0[0])), m3[2]))), -m4[3]))), sum(sum(scale2(sum(scale2(sum(prod(m2[1], m4[0]), prod(-m4[1], m2[0])), m1[2]), sum(scale2(sum(prod(m1[1], m4[0]), prod(-m4[1], m1[0])), -m2[2]), scale2(sum(prod(m1[1], m2[0]), prod(-m2[1], m1[0])), m4[2]))), m0[3]), scale2(sum(scale2(sum(prod(m2[1], m4[0]), prod(-m4[1], m2[0])), m0[2]), sum(scale2(sum(prod(m0[1], m4[0]), prod(-m4[1], m0[0])), -m2[2]), scale2(sum(prod(m0[1], m2[0]), prod(-m2[1], m0[0])), m4[2]))), -m1[3])), sum(scale2(sum(scale2(sum(prod(m1[1], m4[0]), prod(-m4[1], m1[0])), m0[2]), sum(scale2(sum(prod(m0[1], m4[0]), prod(-m4[1], m0[0])), -m1[2]), scale2(sum(prod(m0[1], m1[0]), prod(-m1[1], m0[0])), m4[2]))), m2[3]), scale2(sum(scale2(sum(prod(m1[1], m2[0]), prod(-m2[1], m1[0])), m0[2]), sum(scale2(sum(prod(m0[1], m2[0]), prod(-m2[1], m0[0])), -m1[2]), scale2(sum(prod(m0[1], m1[0]), prod(-m1[1], m0[0])), m2[2]))), -m4[3]))));
+                      var d2 = sub2(p2, n2);
+                      return d2[d2.length - 1];
+                    };
+                  }
+                  function orientation(n2) {
+                    var fn = n2 === 3 ? orientation_3 : n2 === 4 ? orientation_4 : orientation_5;
+                    return fn(robustSum, twoProduct, robustScale, robustSubtract);
+                  }
+                  var orientation3Exact = orientation(3);
+                  var orientation4Exact = orientation(4);
+                  var CACHED = [
+                    function orientation0() {
+                      return 0;
+                    },
+                    function orientation1() {
+                      return 0;
+                    },
+                    function orientation2(a2, b2) {
+                      return b2[0] - a2[0];
+                    },
+                    function orientation3(a2, b2, c2) {
+                      var l2 = (a2[1] - c2[1]) * (b2[0] - c2[0]);
+                      var r2 = (a2[0] - c2[0]) * (b2[1] - c2[1]);
+                      var det = l2 - r2;
+                      var s2;
+                      if (l2 > 0) {
+                        if (r2 <= 0) {
+                          return det;
+                        } else {
+                          s2 = l2 + r2;
+                        }
+                      } else if (l2 < 0) {
+                        if (r2 >= 0) {
+                          return det;
+                        } else {
+                          s2 = -(l2 + r2);
+                        }
+                      } else {
+                        return det;
+                      }
+                      var tol = ERRBOUND3 * s2;
+                      if (det >= tol || det <= -tol) {
+                        return det;
+                      }
+                      return orientation3Exact(a2, b2, c2);
+                    },
+                    function orientation4(a2, b2, c2, d2) {
+                      var adx = a2[0] - d2[0];
+                      var bdx = b2[0] - d2[0];
+                      var cdx = c2[0] - d2[0];
+                      var ady = a2[1] - d2[1];
+                      var bdy = b2[1] - d2[1];
+                      var cdy = c2[1] - d2[1];
+                      var adz = a2[2] - d2[2];
+                      var bdz = b2[2] - d2[2];
+                      var cdz = c2[2] - d2[2];
+                      var bdxcdy = bdx * cdy;
+                      var cdxbdy = cdx * bdy;
+                      var cdxady = cdx * ady;
+                      var adxcdy = adx * cdy;
+                      var adxbdy = adx * bdy;
+                      var bdxady = bdx * ady;
+                      var det = adz * (bdxcdy - cdxbdy) + bdz * (cdxady - adxcdy) + cdz * (adxbdy - bdxady);
+                      var permanent = (Math.abs(bdxcdy) + Math.abs(cdxbdy)) * Math.abs(adz) + (Math.abs(cdxady) + Math.abs(adxcdy)) * Math.abs(bdz) + (Math.abs(adxbdy) + Math.abs(bdxady)) * Math.abs(cdz);
+                      var tol = ERRBOUND4 * permanent;
+                      if (det > tol || -det > tol) {
+                        return det;
+                      }
+                      return orientation4Exact(a2, b2, c2, d2);
+                    }
+                  ];
+                  function slowOrient(args) {
+                    var proc2 = CACHED[args.length];
+                    if (!proc2) {
+                      proc2 = CACHED[args.length] = orientation(args.length);
+                    }
+                    return proc2.apply(void 0, args);
+                  }
+                  function proc(slow, o0, o1, o2, o3, o4, o5) {
+                    return function getOrientation(a0, a1, a2, a3, a4) {
+                      switch (arguments.length) {
+                        case 0:
+                        case 1:
+                          return 0;
+                        case 2:
+                          return o2(a0, a1);
+                        case 3:
+                          return o3(a0, a1, a2);
+                        case 4:
+                          return o4(a0, a1, a2, a3);
+                        case 5:
+                          return o5(a0, a1, a2, a3, a4);
+                      }
+                      var s2 = new Array(arguments.length);
+                      for (var i2 = 0; i2 < arguments.length; ++i2) {
+                        s2[i2] = arguments[i2];
+                      }
+                      return slow(s2);
+                    };
+                  }
+                  function generateOrientationProc() {
+                    while (CACHED.length <= NUM_EXPAND) {
+                      CACHED.push(orientation(CACHED.length));
+                    }
+                    module22.exports = proc.apply(void 0, [slowOrient].concat(CACHED));
+                    for (var i2 = 0; i2 <= NUM_EXPAND; ++i2) {
+                      module22.exports[i2] = CACHED[i2];
+                    }
+                  }
+                  generateOrientationProc();
+                }
+              ),
+              /***/
+              3327: (
+                /***/
+                function(module22, __unused_webpack_exports, __webpack_require__2) {
+                  var coallesceUniforms = __webpack_require__2(216);
+                  var GLError = __webpack_require__2(8866);
+                  module22.exports = createUniformWrapper;
+                  function identity22(x2) {
+                    return function() {
+                      return x2;
+                    };
+                  }
+                  function makeVector(length2, fill) {
+                    var result = new Array(length2);
+                    for (var i2 = 0; i2 < length2; ++i2) {
+                      result[i2] = fill;
+                    }
+                    return result;
+                  }
+                  function createUniformWrapper(gl2, wrapper, uniforms, locations) {
+                    function makeGetter(idx) {
+                      return function(gl3, wrapper2, locations2) {
+                        return gl3.getUniform(wrapper2.program, locations2[idx]);
+                      };
+                    }
+                    function makeSetter(type) {
+                      return function updateProperty(obj) {
+                        var indices = enumerateIndices("", type);
+                        for (var i2 = 0; i2 < indices.length; ++i2) {
+                          var item = indices[i2];
+                          var path = item[0];
+                          var idx = item[1];
+                          if (locations[idx]) {
+                            var objPath = obj;
+                            if (typeof path === "string" && (path.indexOf(".") === 0 || path.indexOf("[") === 0)) {
+                              var key = path;
+                              if (path.indexOf(".") === 0) {
+                                key = path.slice(1);
+                              }
+                              if (key.indexOf("]") === key.length - 1) {
+                                var j2 = key.indexOf("[");
+                                var k1 = key.slice(0, j2);
+                                var k2 = key.slice(j2 + 1, key.length - 1);
+                                objPath = k1 ? obj[k1][k2] : obj[k2];
+                              } else {
+                                objPath = obj[key];
+                              }
+                            }
+                            var t4 = uniforms[idx].type;
+                            var d2;
+                            switch (t4) {
+                              case "bool":
+                              case "int":
+                              case "sampler2D":
+                              case "samplerCube":
+                                gl2.uniform1i(locations[idx], objPath);
+                                break;
+                              case "float":
+                                gl2.uniform1f(locations[idx], objPath);
+                                break;
+                              default:
+                                var vidx = t4.indexOf("vec");
+                                if (0 <= vidx && vidx <= 1 && t4.length === 4 + vidx) {
+                                  d2 = t4.charCodeAt(t4.length - 1) - 48;
+                                  if (d2 < 2 || d2 > 4) {
+                                    throw new GLError("", "Invalid data type");
+                                  }
+                                  switch (t4.charAt(0)) {
+                                    case "b":
+                                    case "i":
+                                      gl2["uniform" + d2 + "iv"](locations[idx], objPath);
+                                      break;
+                                    case "v":
+                                      gl2["uniform" + d2 + "fv"](locations[idx], objPath);
+                                      break;
+                                    default:
+                                      throw new GLError("", "Unrecognized data type for vector " + name + ": " + t4);
+                                  }
+                                } else if (t4.indexOf("mat") === 0 && t4.length === 4) {
+                                  d2 = t4.charCodeAt(t4.length - 1) - 48;
+                                  if (d2 < 2 || d2 > 4) {
+                                    throw new GLError("", "Invalid uniform dimension type for matrix " + name + ": " + t4);
+                                  }
+                                  gl2["uniformMatrix" + d2 + "fv"](locations[idx], false, objPath);
+                                  break;
+                                } else {
+                                  throw new GLError("", "Unknown uniform data type for " + name + ": " + t4);
+                                }
+                            }
+                          }
+                        }
+                      };
+                    }
+                    function enumerateIndices(prefix, type) {
+                      if (typeof type !== "object") {
+                        return [[prefix, type]];
+                      }
+                      var indices = [];
+                      for (var id2 in type) {
+                        var prop = type[id2];
+                        var tprefix = prefix;
+                        if (parseInt(id2) + "" === id2) {
+                          tprefix += "[" + id2 + "]";
+                        } else {
+                          tprefix += "." + id2;
+                        }
+                        if (typeof prop === "object") {
+                          indices.push.apply(indices, enumerateIndices(tprefix, prop));
+                        } else {
+                          indices.push([tprefix, prop]);
+                        }
+                      }
+                      return indices;
+                    }
+                    function defaultValue(type) {
+                      switch (type) {
+                        case "bool":
+                          return false;
+                        case "int":
+                        case "sampler2D":
+                        case "samplerCube":
+                          return 0;
+                        case "float":
+                          return 0;
+                        default:
+                          var vidx = type.indexOf("vec");
+                          if (0 <= vidx && vidx <= 1 && type.length === 4 + vidx) {
+                            var d2 = type.charCodeAt(type.length - 1) - 48;
+                            if (d2 < 2 || d2 > 4) {
+                              throw new GLError("", "Invalid data type");
+                            }
+                            if (type.charAt(0) === "b") {
+                              return makeVector(d2, false);
+                            }
+                            return makeVector(d2, 0);
+                          } else if (type.indexOf("mat") === 0 && type.length === 4) {
+                            var d2 = type.charCodeAt(type.length - 1) - 48;
+                            if (d2 < 2 || d2 > 4) {
+                              throw new GLError("", "Invalid uniform dimension type for matrix " + name + ": " + type);
+                            }
+                            return makeVector(d2 * d2, 0);
+                          } else {
+                            throw new GLError("", "Unknown uniform data type for " + name + ": " + type);
+                          }
+                      }
+                    }
+                    function storeProperty(obj, prop, type) {
+                      if (typeof type === "object") {
+                        var child = processObject(type);
+                        Object.defineProperty(obj, prop, {
+                          get: identity22(child),
+                          set: makeSetter(type),
+                          enumerable: true,
+                          configurable: false
+                        });
+                      } else {
+                        if (locations[type]) {
+                          Object.defineProperty(obj, prop, {
+                            get: makeGetter(type),
+                            set: makeSetter(type),
+                            enumerable: true,
+                            configurable: false
+                          });
+                        } else {
+                          obj[prop] = defaultValue(uniforms[type].type);
+                        }
+                      }
+                    }
+                    function processObject(obj) {
+                      var result;
+                      if (Array.isArray(obj)) {
+                        result = new Array(obj.length);
+                        for (var i2 = 0; i2 < obj.length; ++i2) {
+                          storeProperty(result, i2, obj[i2]);
+                        }
+                      } else {
+                        result = {};
+                        for (var id2 in obj) {
+                          storeProperty(result, id2, obj[id2]);
+                        }
+                      }
+                      return result;
+                    }
+                    var coallesced = coallesceUniforms(uniforms, true);
+                    return {
+                      get: identity22(processObject(coallesced)),
+                      set: makeSetter(coallesced),
+                      enumerable: true,
+                      configurable: true
+                    };
+                  }
+                }
+              ),
+              /***/
+              3349: (
+                /***/
+                function(module22) {
+                  function CWiseOp() {
+                    return function(SS, a0, t02, p0, Y0, Y1) {
+                      var s0 = SS[0], t0p0 = t02[0], index = [0], q0 = t0p0;
+                      p0 |= 0;
+                      var i0 = 0, d0s0 = t0p0;
+                      for (i0 = 0; i0 < s0; ++i0) {
+                        {
+                          var da2 = a0[p0] - Y1;
+                          var db2 = a0[p0 + q0] - Y1;
+                          if (da2 >= 0 !== db2 >= 0) {
+                            Y0.push(index[0] + 0.5 + 0.5 * (da2 + db2) / (da2 - db2));
+                          }
+                        }
+                        p0 += d0s0;
+                        ++index[0];
+                      }
+                    };
+                  }
+                  function generateCWiseOp() {
+                    return CWiseOp();
+                  }
+                  var compile = generateCWiseOp;
+                  function thunk(compile2) {
+                    var CACHED = {};
+                    return function zeroCrossings_cwise_thunk(array0, scalar2, scalar3) {
+                      var t02 = array0.dtype, r0 = array0.order, type = [t02, r0.join()].join(), proc = CACHED[type];
+                      if (!proc) {
+                        CACHED[type] = proc = compile2([t02, r0]);
+                      }
+                      return proc(array0.shape.slice(0), array0.data, array0.stride, array0.offset | 0, scalar2, scalar3);
+                    };
+                  }
+                  function createThunk(proc) {
+                    return thunk(compile.bind(void 0, proc));
+                  }
+                  function compileCwise(user_args) {
+                    return createThunk({
+                      funcName: user_args.funcName
+                    });
+                  }
+                  module22.exports = compileCwise({
+                    funcName: "zeroCrossings"
+                  });
+                }
+              ),
+              /***/
+              3352: (
+                /***/
+                function(module22, __unused_webpack_exports, __webpack_require__2) {
+                  var bounds = __webpack_require__2(2478);
+                  var NOT_FOUND = 0;
+                  var SUCCESS = 1;
+                  var EMPTY2 = 2;
+                  module22.exports = createWrapper;
+                  function IntervalTreeNode(mid, left, right, leftPoints, rightPoints) {
+                    this.mid = mid;
+                    this.left = left;
+                    this.right = right;
+                    this.leftPoints = leftPoints;
+                    this.rightPoints = rightPoints;
+                    this.count = (left ? left.count : 0) + (right ? right.count : 0) + leftPoints.length;
+                  }
+                  var proto = IntervalTreeNode.prototype;
+                  function copy(a2, b2) {
+                    a2.mid = b2.mid;
+                    a2.left = b2.left;
+                    a2.right = b2.right;
+                    a2.leftPoints = b2.leftPoints;
+                    a2.rightPoints = b2.rightPoints;
+                    a2.count = b2.count;
+                  }
+                  function rebuild(node, intervals) {
+                    var ntree = createIntervalTree(intervals);
+                    node.mid = ntree.mid;
+                    node.left = ntree.left;
+                    node.right = ntree.right;
+                    node.leftPoints = ntree.leftPoints;
+                    node.rightPoints = ntree.rightPoints;
+                    node.count = ntree.count;
+                  }
+                  function rebuildWithInterval(node, interval) {
+                    var intervals = node.intervals([]);
+                    intervals.push(interval);
+                    rebuild(node, intervals);
+                  }
+                  function rebuildWithoutInterval(node, interval) {
+                    var intervals = node.intervals([]);
+                    var idx = intervals.indexOf(interval);
+                    if (idx < 0) {
+                      return NOT_FOUND;
+                    }
+                    intervals.splice(idx, 1);
+                    rebuild(node, intervals);
+                    return SUCCESS;
+                  }
+                  proto.intervals = function(result) {
+                    result.push.apply(result, this.leftPoints);
+                    if (this.left) {
+                      this.left.intervals(result);
+                    }
+                    if (this.right) {
+                      this.right.intervals(result);
+                    }
+                    return result;
+                  };
+                  proto.insert = function(interval) {
+                    var weight = this.count - this.leftPoints.length;
+                    this.count += 1;
+                    if (interval[1] < this.mid) {
+                      if (this.left) {
+                        if (4 * (this.left.count + 1) > 3 * (weight + 1)) {
+                          rebuildWithInterval(this, interval);
+                        } else {
+                          this.left.insert(interval);
+                        }
+                      } else {
+                        this.left = createIntervalTree([interval]);
+                      }
+                    } else if (interval[0] > this.mid) {
+                      if (this.right) {
+                        if (4 * (this.right.count + 1) > 3 * (weight + 1)) {
+                          rebuildWithInterval(this, interval);
+                        } else {
+                          this.right.insert(interval);
+                        }
+                      } else {
+                        this.right = createIntervalTree([interval]);
+                      }
+                    } else {
+                      var l2 = bounds.ge(this.leftPoints, interval, compareBegin);
+                      var r2 = bounds.ge(this.rightPoints, interval, compareEnd);
+                      this.leftPoints.splice(l2, 0, interval);
+                      this.rightPoints.splice(r2, 0, interval);
+                    }
+                  };
+                  proto.remove = function(interval) {
+                    var weight = this.count - this.leftPoints;
+                    if (interval[1] < this.mid) {
+                      if (!this.left) {
+                        return NOT_FOUND;
+                      }
+                      var rw = this.right ? this.right.count : 0;
+                      if (4 * rw > 3 * (weight - 1)) {
+                        return rebuildWithoutInterval(this, interval);
+                      }
+                      var r2 = this.left.remove(interval);
+                      if (r2 === EMPTY2) {
+                        this.left = null;
+                        this.count -= 1;
+                        return SUCCESS;
+                      } else if (r2 === SUCCESS) {
+                        this.count -= 1;
+                      }
+                      return r2;
+                    } else if (interval[0] > this.mid) {
+                      if (!this.right) {
+                        return NOT_FOUND;
+                      }
+                      var lw = this.left ? this.left.count : 0;
+                      if (4 * lw > 3 * (weight - 1)) {
+                        return rebuildWithoutInterval(this, interval);
+                      }
+                      var r2 = this.right.remove(interval);
+                      if (r2 === EMPTY2) {
+                        this.right = null;
+                        this.count -= 1;
+                        return SUCCESS;
+                      } else if (r2 === SUCCESS) {
+                        this.count -= 1;
+                      }
+                      return r2;
+                    } else {
+                      if (this.count === 1) {
+                        if (this.leftPoints[0] === interval) {
+                          return EMPTY2;
+                        } else {
+                          return NOT_FOUND;
+                        }
+                      }
+                      if (this.leftPoints.length === 1 && this.leftPoints[0] === interval) {
+                        if (this.left && this.right) {
+                          var p2 = this;
+                          var n2 = this.left;
+                          while (n2.right) {
+                            p2 = n2;
+                            n2 = n2.right;
+                          }
+                          if (p2 === this) {
+                            n2.right = this.right;
+                          } else {
+                            var l2 = this.left;
+                            var r2 = this.right;
+                            p2.count -= n2.count;
+                            p2.right = n2.left;
+                            n2.left = l2;
+                            n2.right = r2;
+                          }
+                          copy(this, n2);
+                          this.count = (this.left ? this.left.count : 0) + (this.right ? this.right.count : 0) + this.leftPoints.length;
+                        } else if (this.left) {
+                          copy(this, this.left);
+                        } else {
+                          copy(this, this.right);
+                        }
+                        return SUCCESS;
+                      }
+                      for (var l2 = bounds.ge(this.leftPoints, interval, compareBegin); l2 < this.leftPoints.length; ++l2) {
+                        if (this.leftPoints[l2][0] !== interval[0]) {
+                          break;
+                        }
+                        if (this.leftPoints[l2] === interval) {
+                          this.count -= 1;
+                          this.leftPoints.splice(l2, 1);
+                          for (var r2 = bounds.ge(this.rightPoints, interval, compareEnd); r2 < this.rightPoints.length; ++r2) {
+                            if (this.rightPoints[r2][1] !== interval[1]) {
+                              break;
+                            } else if (this.rightPoints[r2] === interval) {
+                              this.rightPoints.splice(r2, 1);
+                              return SUCCESS;
+                            }
+                          }
+                        }
+                      }
+                      return NOT_FOUND;
+                    }
+                  };
+                  function reportLeftRange(arr, hi2, cb2) {
+                    for (var i2 = 0; i2 < arr.length && arr[i2][0] <= hi2; ++i2) {
+                      var r2 = cb2(arr[i2]);
+                      if (r2) {
+                        return r2;
+                      }
+                    }
+                  }
+                  function reportRightRange(arr, lo, cb2) {
+                    for (var i2 = arr.length - 1; i2 >= 0 && arr[i2][1] >= lo; --i2) {
+                      var r2 = cb2(arr[i2]);
+                      if (r2) {
+                        return r2;
+                      }
+                    }
+                  }
+                  function reportRange(arr, cb2) {
+                    for (var i2 = 0; i2 < arr.length; ++i2) {
+                      var r2 = cb2(arr[i2]);
+                      if (r2) {
+                        return r2;
+                      }
+                    }
+                  }
+                  proto.queryPoint = function(x2, cb2) {
+                    if (x2 < this.mid) {
+                      if (this.left) {
+                        var r2 = this.left.queryPoint(x2, cb2);
+                        if (r2) {
+                          return r2;
+                        }
+                      }
+                      return reportLeftRange(this.leftPoints, x2, cb2);
+                    } else if (x2 > this.mid) {
+                      if (this.right) {
+                        var r2 = this.right.queryPoint(x2, cb2);
+                        if (r2) {
+                          return r2;
+                        }
+                      }
+                      return reportRightRange(this.rightPoints, x2, cb2);
+                    } else {
+                      return reportRange(this.leftPoints, cb2);
+                    }
+                  };
+                  proto.queryInterval = function(lo, hi2, cb2) {
+                    if (lo < this.mid && this.left) {
+                      var r2 = this.left.queryInterval(lo, hi2, cb2);
+                      if (r2) {
+                        return r2;
+                      }
+                    }
+                    if (hi2 > this.mid && this.right) {
+                      var r2 = this.right.queryInterval(lo, hi2, cb2);
+                      if (r2) {
+                        return r2;
+                      }
+                    }
+                    if (hi2 < this.mid) {
+                      return reportLeftRange(this.leftPoints, hi2, cb2);
+                    } else if (lo > this.mid) {
+                      return reportRightRange(this.rightPoints, lo, cb2);
+                    } else {
+                      return reportRange(this.leftPoints, cb2);
+                    }
+                  };
+                  function compareNumbers(a2, b2) {
+                    return a2 - b2;
+                  }
+                  function compareBegin(a2, b2) {
+                    var d2 = a2[0] - b2[0];
+                    if (d2) {
+                      return d2;
+                    }
+                    return a2[1] - b2[1];
+                  }
+                  function compareEnd(a2, b2) {
+                    var d2 = a2[1] - b2[1];
+                    if (d2) {
+                      return d2;
+                    }
+                    return a2[0] - b2[0];
+                  }
+                  function createIntervalTree(intervals) {
+                    if (intervals.length === 0) {
+                      return null;
+                    }
+                    var pts = [];
+                    for (var i2 = 0; i2 < intervals.length; ++i2) {
+                      pts.push(intervals[i2][0], intervals[i2][1]);
+                    }
+                    pts.sort(compareNumbers);
+                    var mid = pts[pts.length >> 1];
+                    var leftIntervals = [];
+                    var rightIntervals = [];
+                    var centerIntervals = [];
+                    for (var i2 = 0; i2 < intervals.length; ++i2) {
+                      var s2 = intervals[i2];
+                      if (s2[1] < mid) {
+                        leftIntervals.push(s2);
+                      } else if (mid < s2[0]) {
+                        rightIntervals.push(s2);
+                      } else {
+                        centerIntervals.push(s2);
+                      }
+                    }
+                    var leftPoints = centerIntervals;
+                    var rightPoints = centerIntervals.slice();
+                    leftPoints.sort(compareBegin);
+                    rightPoints.sort(compareEnd);
+                    return new IntervalTreeNode(
+                      mid,
+                      createIntervalTree(leftIntervals),
+                      createIntervalTree(rightIntervals),
+                      leftPoints,
+                      rightPoints
+                    );
+                  }
+                  function IntervalTree(root) {
+                    this.root = root;
+                  }
+                  var tproto = IntervalTree.prototype;
+                  tproto.insert = function(interval) {
+                    if (this.root) {
+                      this.root.insert(interval);
+                    } else {
+                      this.root = new IntervalTreeNode(interval[0], null, null, [interval], [interval]);
+                    }
+                  };
+                  tproto.remove = function(interval) {
+                    if (this.root) {
+                      var r2 = this.root.remove(interval);
+                      if (r2 === EMPTY2) {
+                        this.root = null;
+                      }
+                      return r2 !== NOT_FOUND;
+                    }
+                    return false;
+                  };
+                  tproto.queryPoint = function(p2, cb2) {
+                    if (this.root) {
+                      return this.root.queryPoint(p2, cb2);
+                    }
+                  };
+                  tproto.queryInterval = function(lo, hi2, cb2) {
+                    if (lo <= hi2 && this.root) {
+                      return this.root.queryInterval(lo, hi2, cb2);
+                    }
+                  };
+                  Object.defineProperty(tproto, "count", {
+                    get: function() {
+                      if (this.root) {
+                        return this.root.count;
+                      }
+                      return 0;
+                    }
+                  });
+                  Object.defineProperty(tproto, "intervals", {
+                    get: function() {
+                      if (this.root) {
+                        return this.root.intervals([]);
+                      }
+                      return [];
+                    }
+                  });
+                  function createWrapper(intervals) {
+                    if (!intervals || intervals.length === 0) {
+                      return new IntervalTree(null);
+                    }
+                    return new IntervalTree(createIntervalTree(intervals));
+                  }
+                }
+              ),
+              /***/
+              3387: (
+                /***/
+                function(module22, exports2, __webpack_require__2) {
+                  var __WEBPACK_AMD_DEFINE_RESULT__;
+                  !function() {
+                    var re2 = {
+                      not_type: /[^T]/,
+                      not_primitive: /[^v]/,
+                      number: /[diefg]/,
+                      numeric_arg: /[bcdiefguxX]/,
+                      json: /[j]/,
+                      text: /^[^\x25]+/,
+                      modulo: /^\x25{2}/,
+                      placeholder: /^\x25(?:([1-9]\d*)\$|\(([^)]+)\))?(\+)?(0|'[^$])?(-)?(\d+)?(?:\.(\d+))?([b-gijostTuvxX])/,
+                      key: /^([a-z_][a-z_\d]*)/i,
+                      key_access: /^\.([a-z_][a-z_\d]*)/i,
+                      index_access: /^\[(\d+)\]/,
+                      sign: /^[+-]/
+                    };
+                    function sprintf(key) {
+                      return sprintf_format(sprintf_parse(key), arguments);
+                    }
+                    function vsprintf(fmt, argv) {
+                      return sprintf.apply(null, [fmt].concat(argv || []));
+                    }
+                    function sprintf_format(parse_tree, argv) {
+                      var cursor = 1, tree_length = parse_tree.length, arg, output = "", i2, k2, ph2, pad, pad_character, pad_length, is_positive, sign;
+                      for (i2 = 0; i2 < tree_length; i2++) {
+                        if (typeof parse_tree[i2] === "string") {
+                          output += parse_tree[i2];
+                        } else if (typeof parse_tree[i2] === "object") {
+                          ph2 = parse_tree[i2];
+                          if (ph2.keys) {
+                            arg = argv[cursor];
+                            for (k2 = 0; k2 < ph2.keys.length; k2++) {
+                              if (arg == void 0) {
+                                throw new Error(sprintf('[sprintf] Cannot access property "%s" of undefined value "%s"', ph2.keys[k2], ph2.keys[k2 - 1]));
+                              }
+                              arg = arg[ph2.keys[k2]];
+                            }
+                          } else if (ph2.param_no) {
+                            arg = argv[ph2.param_no];
+                          } else {
+                            arg = argv[cursor++];
+                          }
+                          if (re2.not_type.test(ph2.type) && re2.not_primitive.test(ph2.type) && arg instanceof Function) {
+                            arg = arg();
+                          }
+                          if (re2.numeric_arg.test(ph2.type) && (typeof arg !== "number" && isNaN(arg))) {
+                            throw new TypeError(sprintf("[sprintf] expecting number but found %T", arg));
+                          }
+                          if (re2.number.test(ph2.type)) {
+                            is_positive = arg >= 0;
+                          }
+                          switch (ph2.type) {
+                            case "b":
+                              arg = parseInt(arg, 10).toString(2);
+                              break;
+                            case "c":
+                              arg = String.fromCharCode(parseInt(arg, 10));
+                              break;
+                            case "d":
+                            case "i":
+                              arg = parseInt(arg, 10);
+                              break;
+                            case "j":
+                              arg = JSON.stringify(arg, null, ph2.width ? parseInt(ph2.width) : 0);
+                              break;
+                            case "e":
+                              arg = ph2.precision ? parseFloat(arg).toExponential(ph2.precision) : parseFloat(arg).toExponential();
+                              break;
+                            case "f":
+                              arg = ph2.precision ? parseFloat(arg).toFixed(ph2.precision) : parseFloat(arg);
+                              break;
+                            case "g":
+                              arg = ph2.precision ? String(Number(arg.toPrecision(ph2.precision))) : parseFloat(arg);
+                              break;
+                            case "o":
+                              arg = (parseInt(arg, 10) >>> 0).toString(8);
+                              break;
+                            case "s":
+                              arg = String(arg);
+                              arg = ph2.precision ? arg.substring(0, ph2.precision) : arg;
+                              break;
+                            case "t":
+                              arg = String(!!arg);
+                              arg = ph2.precision ? arg.substring(0, ph2.precision) : arg;
+                              break;
+                            case "T":
+                              arg = Object.prototype.toString.call(arg).slice(8, -1).toLowerCase();
+                              arg = ph2.precision ? arg.substring(0, ph2.precision) : arg;
+                              break;
+                            case "u":
+                              arg = parseInt(arg, 10) >>> 0;
+                              break;
+                            case "v":
+                              arg = arg.valueOf();
+                              arg = ph2.precision ? arg.substring(0, ph2.precision) : arg;
+                              break;
+                            case "x":
+                              arg = (parseInt(arg, 10) >>> 0).toString(16);
+                              break;
+                            case "X":
+                              arg = (parseInt(arg, 10) >>> 0).toString(16).toUpperCase();
+                              break;
+                          }
+                          if (re2.json.test(ph2.type)) {
+                            output += arg;
+                          } else {
+                            if (re2.number.test(ph2.type) && (!is_positive || ph2.sign)) {
+                              sign = is_positive ? "+" : "-";
+                              arg = arg.toString().replace(re2.sign, "");
+                            } else {
+                              sign = "";
+                            }
+                            pad_character = ph2.pad_char ? ph2.pad_char === "0" ? "0" : ph2.pad_char.charAt(1) : " ";
+                            pad_length = ph2.width - (sign + arg).length;
+                            pad = ph2.width ? pad_length > 0 ? pad_character.repeat(pad_length) : "" : "";
+                            output += ph2.align ? sign + arg + pad : pad_character === "0" ? sign + pad + arg : pad + sign + arg;
+                          }
+                        }
+                      }
+                      return output;
+                    }
+                    var sprintf_cache = /* @__PURE__ */ Object.create(null);
+                    function sprintf_parse(fmt) {
+                      if (sprintf_cache[fmt]) {
+                        return sprintf_cache[fmt];
+                      }
+                      var _fmt = fmt, match, parse_tree = [], arg_names = 0;
+                      while (_fmt) {
+                        if ((match = re2.text.exec(_fmt)) !== null) {
+                          parse_tree.push(match[0]);
+                        } else if ((match = re2.modulo.exec(_fmt)) !== null) {
+                          parse_tree.push("%");
+                        } else if ((match = re2.placeholder.exec(_fmt)) !== null) {
+                          if (match[2]) {
+                            arg_names |= 1;
+                            var field_list = [], replacement_field = match[2], field_match = [];
+                            if ((field_match = re2.key.exec(replacement_field)) !== null) {
+                              field_list.push(field_match[1]);
+                              while ((replacement_field = replacement_field.substring(field_match[0].length)) !== "") {
+                                if ((field_match = re2.key_access.exec(replacement_field)) !== null) {
+                                  field_list.push(field_match[1]);
+                                } else if ((field_match = re2.index_access.exec(replacement_field)) !== null) {
+                                  field_list.push(field_match[1]);
+                                } else {
+                                  throw new SyntaxError("[sprintf] failed to parse named argument key");
+                                }
+                              }
+                            } else {
+                              throw new SyntaxError("[sprintf] failed to parse named argument key");
+                            }
+                            match[2] = field_list;
+                          } else {
+                            arg_names |= 2;
+                          }
+                          if (arg_names === 3) {
+                            throw new Error("[sprintf] mixing positional and named placeholders is not (yet) supported");
+                          }
+                          parse_tree.push(
+                            {
+                              placeholder: match[0],
+                              param_no: match[1],
+                              keys: match[2],
+                              sign: match[3],
+                              pad_char: match[4],
+                              align: match[5],
+                              width: match[6],
+                              precision: match[7],
+                              type: match[8]
+                            }
+                          );
+                        } else {
+                          throw new SyntaxError("[sprintf] unexpected placeholder");
+                        }
+                        _fmt = _fmt.substring(match[0].length);
+                      }
+                      return sprintf_cache[fmt] = parse_tree;
+                    }
+                    {
+                      exports2.sprintf = sprintf;
+                      exports2.vsprintf = vsprintf;
+                    }
+                    if (typeof window !== "undefined") {
+                      window["sprintf"] = sprintf;
+                      window["vsprintf"] = vsprintf;
+                      {
+                        !(__WEBPACK_AMD_DEFINE_RESULT__ = (function() {
+                          return {
+                            "sprintf": sprintf,
+                            "vsprintf": vsprintf
+                          };
+                        }).call(exports2, __webpack_require__2, exports2, module22), __WEBPACK_AMD_DEFINE_RESULT__ !== void 0 && (module22.exports = __WEBPACK_AMD_DEFINE_RESULT__));
+                      }
+                    }
+                  }();
+                }
+              ),
+              /***/
+              3390: (
+                /***/
+                function(module22) {
+                  module22.exports = fromValues;
+                  function fromValues(x2, y2, z2, w2) {
+                    var out = new Float32Array(4);
+                    out[0] = x2;
+                    out[1] = y2;
+                    out[2] = z2;
+                    out[3] = w2;
+                    return out;
+                  }
+                }
+              ),
+              /***/
+              3436: (
+                /***/
+                function(module22, __unused_webpack_exports, __webpack_require__2) {
+                  var glslify = __webpack_require__2(3236);
+                  var createShader = __webpack_require__2(9405);
+                  var vertSrc = glslify(["precision highp float;\n#define GLSLIFY 1\n\nattribute vec3 position, offset;\nattribute vec4 color;\nuniform mat4 model, view, projection;\nuniform float capSize;\nvarying vec4 fragColor;\nvarying vec3 fragPosition;\n\nvoid main() {\n  vec4 worldPosition  = model * vec4(position, 1.0);\n  worldPosition       = (worldPosition / worldPosition.w) + vec4(capSize * offset, 0.0);\n  gl_Position         = projection * (view * worldPosition);\n  fragColor           = color;\n  fragPosition        = position;\n}"]);
+                  var fragSrc = glslify(["precision highp float;\n#define GLSLIFY 1\n\nbool outOfRange(float a, float b, float p) {\n  return ((p > max(a, b)) || \n          (p < min(a, b)));\n}\n\nbool outOfRange(vec2 a, vec2 b, vec2 p) {\n  return (outOfRange(a.x, b.x, p.x) ||\n          outOfRange(a.y, b.y, p.y));\n}\n\nbool outOfRange(vec3 a, vec3 b, vec3 p) {\n  return (outOfRange(a.x, b.x, p.x) ||\n          outOfRange(a.y, b.y, p.y) ||\n          outOfRange(a.z, b.z, p.z));\n}\n\nbool outOfRange(vec4 a, vec4 b, vec4 p) {\n  return outOfRange(a.xyz, b.xyz, p.xyz);\n}\n\nuniform vec3 clipBounds[2];\nuniform float opacity;\nvarying vec3 fragPosition;\nvarying vec4 fragColor;\n\nvoid main() {\n  if (\n    outOfRange(clipBounds[0], clipBounds[1], fragPosition) ||\n    fragColor.a * opacity == 0.\n  ) discard;\n\n  gl_FragColor = opacity * fragColor;\n}"]);
+                  module22.exports = function(gl2) {
+                    return createShader(gl2, vertSrc, fragSrc, null, [
+                      { name: "position", type: "vec3" },
+                      { name: "color", type: "vec4" },
+                      { name: "offset", type: "vec3" }
+                    ]);
+                  };
+                }
+              ),
+              /***/
+              3502: (
+                /***/
+                function(module22, __unused_webpack_exports, __webpack_require__2) {
+                  module22.exports = alphaShape;
+                  var ac2 = __webpack_require__2(5995);
+                  var bnd = __webpack_require__2(9127);
+                  function alphaShape(alpha, points) {
+                    return bnd(ac2(alpha, points));
+                  }
+                }
+              ),
+              /***/
+              3508: (
+                /***/
+                function(module22, __unused_webpack_exports, __webpack_require__2) {
+                  var v100 = __webpack_require__2(6852);
+                  v100 = v100.slice().filter(function(b2) {
+                    return !/^(gl\_|texture)/.test(b2);
+                  });
+                  module22.exports = v100.concat([
+                    // the updated gl_ constants
+                    "gl_VertexID",
+                    "gl_InstanceID",
+                    "gl_Position",
+                    "gl_PointSize",
+                    "gl_FragCoord",
+                    "gl_FrontFacing",
+                    "gl_FragDepth",
+                    "gl_PointCoord",
+                    "gl_MaxVertexAttribs",
+                    "gl_MaxVertexUniformVectors",
+                    "gl_MaxVertexOutputVectors",
+                    "gl_MaxFragmentInputVectors",
+                    "gl_MaxVertexTextureImageUnits",
+                    "gl_MaxCombinedTextureImageUnits",
+                    "gl_MaxTextureImageUnits",
+                    "gl_MaxFragmentUniformVectors",
+                    "gl_MaxDrawBuffers",
+                    "gl_MinProgramTexelOffset",
+                    "gl_MaxProgramTexelOffset",
+                    "gl_DepthRangeParameters",
+                    "gl_DepthRange",
+                    "trunc",
+                    "round",
+                    "roundEven",
+                    "isnan",
+                    "isinf",
+                    "floatBitsToInt",
+                    "floatBitsToUint",
+                    "intBitsToFloat",
+                    "uintBitsToFloat",
+                    "packSnorm2x16",
+                    "unpackSnorm2x16",
+                    "packUnorm2x16",
+                    "unpackUnorm2x16",
+                    "packHalf2x16",
+                    "unpackHalf2x16",
+                    "outerProduct",
+                    "transpose",
+                    "determinant",
+                    "inverse",
+                    "texture",
+                    "textureSize",
+                    "textureProj",
+                    "textureLod",
+                    "textureOffset",
+                    "texelFetch",
+                    "texelFetchOffset",
+                    "textureProjOffset",
+                    "textureLodOffset",
+                    "textureProjLod",
+                    "textureProjLodOffset",
+                    "textureGrad",
+                    "textureGradOffset",
+                    "textureProjGrad",
+                    "textureProjGradOffset"
+                  ]);
+                }
+              ),
+              /***/
+              3536: (
+                /***/
+                function(module22) {
+                  module22.exports = normalize;
+                  function normalize(out, a2) {
+                    var x2 = a2[0], y2 = a2[1], z2 = a2[2];
+                    var len2 = x2 * x2 + y2 * y2 + z2 * z2;
+                    if (len2 > 0) {
+                      len2 = 1 / Math.sqrt(len2);
+                      out[0] = a2[0] * len2;
+                      out[1] = a2[1] * len2;
+                      out[2] = a2[2] * len2;
+                    }
+                    return out;
+                  }
+                }
+              ),
+              /***/
+              3545: (
+                /***/
+                function(module22, __unused_webpack_exports, __webpack_require__2) {
+                  module22.exports = findMedian;
+                  var genPartition = __webpack_require__2(8105);
+                  var partitionStartLessThan = genPartition("lo<p0");
+                  var PARTITION_THRESHOLD = 8;
+                  function insertionSort(d2, axis, start, end, boxes, ids) {
+                    var elemSize = 2 * d2;
+                    var boxPtr = elemSize * (start + 1) + axis;
+                    for (var i2 = start + 1; i2 < end; ++i2, boxPtr += elemSize) {
+                      var x2 = boxes[boxPtr];
+                      for (var j2 = i2, ptr = elemSize * (i2 - 1); j2 > start && boxes[ptr + axis] > x2; --j2, ptr -= elemSize) {
+                        var aPtr = ptr;
+                        var bPtr = ptr + elemSize;
+                        for (var k2 = 0; k2 < elemSize; ++k2, ++aPtr, ++bPtr) {
+                          var y2 = boxes[aPtr];
+                          boxes[aPtr] = boxes[bPtr];
+                          boxes[bPtr] = y2;
+                        }
+                        var tmp2 = ids[j2];
+                        ids[j2] = ids[j2 - 1];
+                        ids[j2 - 1] = tmp2;
+                      }
+                    }
+                  }
+                  function findMedian(d2, axis, start, end, boxes, ids) {
+                    if (end <= start + 1) {
+                      return start;
+                    }
+                    var lo = start;
+                    var hi2 = end;
+                    var mid = end + start >>> 1;
+                    var elemSize = 2 * d2;
+                    var pivot = mid;
+                    var value = boxes[elemSize * mid + axis];
+                    while (lo < hi2) {
+                      if (hi2 - lo < PARTITION_THRESHOLD) {
+                        insertionSort(d2, axis, lo, hi2, boxes, ids);
+                        value = boxes[elemSize * mid + axis];
+                        break;
+                      }
+                      var count2 = hi2 - lo;
+                      var pivot0 = Math.random() * count2 + lo | 0;
+                      var value0 = boxes[elemSize * pivot0 + axis];
+                      var pivot1 = Math.random() * count2 + lo | 0;
+                      var value1 = boxes[elemSize * pivot1 + axis];
+                      var pivot2 = Math.random() * count2 + lo | 0;
+                      var value2 = boxes[elemSize * pivot2 + axis];
+                      if (value0 <= value1) {
+                        if (value2 >= value1) {
+                          pivot = pivot1;
+                          value = value1;
+                        } else if (value0 >= value2) {
+                          pivot = pivot0;
+                          value = value0;
+                        } else {
+                          pivot = pivot2;
+                          value = value2;
+                        }
+                      } else {
+                        if (value1 >= value2) {
+                          pivot = pivot1;
+                          value = value1;
+                        } else if (value2 >= value0) {
+                          pivot = pivot0;
+                          value = value0;
+                        } else {
+                          pivot = pivot2;
+                          value = value2;
+                        }
+                      }
+                      var aPtr = elemSize * (hi2 - 1);
+                      var bPtr = elemSize * pivot;
+                      for (var i2 = 0; i2 < elemSize; ++i2, ++aPtr, ++bPtr) {
+                        var x2 = boxes[aPtr];
+                        boxes[aPtr] = boxes[bPtr];
+                        boxes[bPtr] = x2;
+                      }
+                      var y2 = ids[hi2 - 1];
+                      ids[hi2 - 1] = ids[pivot];
+                      ids[pivot] = y2;
+                      pivot = partitionStartLessThan(
+                        d2,
+                        axis,
+                        lo,
+                        hi2 - 1,
+                        boxes,
+                        ids,
+                        value
+                      );
+                      var aPtr = elemSize * (hi2 - 1);
+                      var bPtr = elemSize * pivot;
+                      for (var i2 = 0; i2 < elemSize; ++i2, ++aPtr, ++bPtr) {
+                        var x2 = boxes[aPtr];
+                        boxes[aPtr] = boxes[bPtr];
+                        boxes[bPtr] = x2;
+                      }
+                      var y2 = ids[hi2 - 1];
+                      ids[hi2 - 1] = ids[pivot];
+                      ids[pivot] = y2;
+                      if (mid < pivot) {
+                        hi2 = pivot - 1;
+                        while (lo < hi2 && boxes[elemSize * (hi2 - 1) + axis] === value) {
+                          hi2 -= 1;
+                        }
+                        hi2 += 1;
+                      } else if (pivot < mid) {
+                        lo = pivot + 1;
+                        while (lo < hi2 && boxes[elemSize * lo + axis] === value) {
+                          lo += 1;
+                        }
+                      } else {
+                        break;
+                      }
+                    }
+                    return partitionStartLessThan(
+                      d2,
+                      axis,
+                      start,
+                      mid,
+                      boxes,
+                      ids,
+                      boxes[elemSize * mid + axis]
+                    );
+                  }
+                }
+              ),
+              /***/
+              3576: (
+                /***/
+                function(module22) {
+                  module22.exports = multiply2;
+                  function multiply2(out, a2, b2) {
+                    out[0] = a2[0] * b2[0];
+                    out[1] = a2[1] * b2[1];
+                    out[2] = a2[2] * b2[2];
+                    out[3] = a2[3] * b2[3];
+                    return out;
+                  }
+                }
+              ),
+              /***/
+              3589: (
+                /***/
+                function(module22, __unused_webpack_exports, __webpack_require__2) {
+                  module22.exports = createSelectBuffer;
+                  var createFBO = __webpack_require__2(2260);
+                  var pool = __webpack_require__2(1888);
+                  var ndarray = __webpack_require__2(9618);
+                  var nextPow2 = __webpack_require__2(8828).nextPow2;
+                  var selectRange = function(arr, x2, y2) {
+                    var closestD2 = 1e8;
+                    var closestX = -1;
+                    var closestY = -1;
+                    var ni2 = arr.shape[0];
+                    var nj2 = arr.shape[1];
+                    for (var i2 = 0; i2 < ni2; i2++) {
+                      for (var j2 = 0; j2 < nj2; j2++) {
+                        var r2 = arr.get(i2, j2, 0);
+                        var g2 = arr.get(i2, j2, 1);
+                        var b2 = arr.get(i2, j2, 2);
+                        var a2 = arr.get(i2, j2, 3);
+                        if (r2 < 255 || g2 < 255 || b2 < 255 || a2 < 255) {
+                          var dx = x2 - i2;
+                          var dy = y2 - j2;
+                          var d2 = dx * dx + dy * dy;
+                          if (d2 < closestD2) {
+                            closestD2 = d2;
+                            closestX = i2;
+                            closestY = j2;
+                          }
+                        }
+                      }
+                    }
+                    return [closestX, closestY, closestD2];
+                  };
+                  function SelectResult(x2, y2, id2, value, distance2) {
+                    this.coord = [x2, y2];
+                    this.id = id2;
+                    this.value = value;
+                    this.distance = distance2;
+                  }
+                  function SelectBuffer(gl2, fbo, buffer) {
+                    this.gl = gl2;
+                    this.fbo = fbo;
+                    this.buffer = buffer;
+                    this._readTimeout = null;
+                    var self2 = this;
+                    this._readCallback = function() {
+                      if (!self2.gl) {
+                        return;
+                      }
+                      fbo.bind();
+                      gl2.readPixels(0, 0, fbo.shape[0], fbo.shape[1], gl2.RGBA, gl2.UNSIGNED_BYTE, self2.buffer);
+                      self2._readTimeout = null;
+                    };
+                  }
+                  var proto = SelectBuffer.prototype;
+                  Object.defineProperty(proto, "shape", {
+                    get: function() {
+                      if (!this.gl) {
+                        return [0, 0];
+                      }
+                      return this.fbo.shape.slice();
+                    },
+                    set: function(v2) {
+                      if (!this.gl) {
+                        return;
+                      }
+                      this.fbo.shape = v2;
+                      var c2 = this.fbo.shape[0];
+                      var r2 = this.fbo.shape[1];
+                      if (r2 * c2 * 4 > this.buffer.length) {
+                        pool.free(this.buffer);
+                        var buffer = this.buffer = pool.mallocUint8(nextPow2(r2 * c2 * 4));
+                        for (var i2 = 0; i2 < r2 * c2 * 4; ++i2) {
+                          buffer[i2] = 255;
+                        }
+                      }
+                      return v2;
+                    }
+                  });
+                  proto.begin = function() {
+                    var gl2 = this.gl;
+                    this.shape;
+                    if (!gl2) {
+                      return;
+                    }
+                    this.fbo.bind();
+                    gl2.clearColor(1, 1, 1, 1);
+                    gl2.clear(gl2.COLOR_BUFFER_BIT | gl2.DEPTH_BUFFER_BIT);
+                  };
+                  proto.end = function() {
+                    var gl2 = this.gl;
+                    if (!gl2) {
+                      return;
+                    }
+                    gl2.bindFramebuffer(gl2.FRAMEBUFFER, null);
+                    if (!this._readTimeout) {
+                      clearTimeout(this._readTimeout);
+                    }
+                    this._readTimeout = setTimeout(this._readCallback, 1);
+                  };
+                  proto.query = function(x2, y2, radius) {
+                    if (!this.gl) {
+                      return null;
+                    }
+                    var shape = this.fbo.shape.slice();
+                    x2 = x2 | 0;
+                    y2 = y2 | 0;
+                    if (typeof radius !== "number") {
+                      radius = 1;
+                    }
+                    var x0 = Math.min(Math.max(x2 - radius, 0), shape[0]) | 0;
+                    var x1 = Math.min(Math.max(x2 + radius, 0), shape[0]) | 0;
+                    var y0 = Math.min(Math.max(y2 - radius, 0), shape[1]) | 0;
+                    var y1 = Math.min(Math.max(y2 + radius, 0), shape[1]) | 0;
+                    if (x1 <= x0 || y1 <= y0) {
+                      return null;
+                    }
+                    var dims = [x1 - x0, y1 - y0];
+                    var region = ndarray(
+                      this.buffer,
+                      [dims[0], dims[1], 4],
+                      [4, shape[0] * 4, 1],
+                      4 * (x0 + shape[0] * y0)
+                    );
+                    var closest = selectRange(region.hi(dims[0], dims[1], 1), radius, radius);
+                    var dx = closest[0];
+                    var dy = closest[1];
+                    if (dx < 0 || Math.pow(this.radius, 2) < closest[2]) {
+                      return null;
+                    }
+                    var c0 = region.get(dx, dy, 0);
+                    var c1 = region.get(dx, dy, 1);
+                    var c2 = region.get(dx, dy, 2);
+                    var c3 = region.get(dx, dy, 3);
+                    return new SelectResult(
+                      dx + x0 | 0,
+                      dy + y0 | 0,
+                      c0,
+                      [c1, c2, c3],
+                      Math.sqrt(closest[2])
+                    );
+                  };
+                  proto.dispose = function() {
+                    if (!this.gl) {
+                      return;
+                    }
+                    this.fbo.dispose();
+                    pool.free(this.buffer);
+                    this.gl = null;
+                    if (this._readTimeout) {
+                      clearTimeout(this._readTimeout);
+                    }
+                  };
+                  function createSelectBuffer(gl2, shape) {
+                    var width = shape[0];
+                    var height = shape[1];
+                    var options = {};
+                    var fbo = createFBO(gl2, width, height, options);
+                    var buffer = pool.mallocUint8(width * height * 4);
+                    return new SelectBuffer(gl2, fbo, buffer);
+                  }
+                }
+              ),
+              /***/
+              3628: (
+                /***/
+                function(module22, __unused_webpack_exports, __webpack_require__2) {
+                  var dup = __webpack_require__2(1338);
+                  var solve = __webpack_require__2(727);
+                  function dot2(a2, b2) {
+                    var s2 = 0;
+                    var d2 = a2.length;
+                    for (var i2 = 0; i2 < d2; ++i2) {
+                      s2 += a2[i2] * b2[i2];
+                    }
+                    return s2;
+                  }
+                  function barycentricCircumcenter(points) {
+                    var N2 = points.length;
+                    if (N2 === 0) {
+                      return [];
+                    }
+                    points[0].length;
+                    var A22 = dup([points.length + 1, points.length + 1], 1);
+                    var b2 = dup([points.length + 1], 1);
+                    A22[N2][N2] = 0;
+                    for (var i2 = 0; i2 < N2; ++i2) {
+                      for (var j2 = 0; j2 <= i2; ++j2) {
+                        A22[j2][i2] = A22[i2][j2] = 2 * dot2(points[i2], points[j2]);
+                      }
+                      b2[i2] = dot2(points[i2], points[i2]);
+                    }
+                    var x2 = solve(A22, b2);
+                    var denom = 0;
+                    var h2 = x2[N2 + 1];
+                    for (var i2 = 0; i2 < h2.length; ++i2) {
+                      denom += h2[i2];
+                    }
+                    var y2 = new Array(N2);
+                    for (var i2 = 0; i2 < N2; ++i2) {
+                      var h2 = x2[i2];
+                      var numer = 0;
+                      for (var j2 = 0; j2 < h2.length; ++j2) {
+                        numer += h2[j2];
+                      }
+                      y2[i2] = numer / denom;
+                    }
+                    return y2;
+                  }
+                  function circumcenter(points) {
+                    if (points.length === 0) {
+                      return [];
+                    }
+                    var D22 = points[0].length;
+                    var result = dup([D22]);
+                    var weights = barycentricCircumcenter(points);
+                    for (var i2 = 0; i2 < points.length; ++i2) {
+                      for (var j2 = 0; j2 < D22; ++j2) {
+                        result[j2] += points[i2][j2] * weights[i2];
+                      }
+                    }
+                    return result;
+                  }
+                  circumcenter.barycenetric = barycentricCircumcenter;
+                  module22.exports = circumcenter;
+                }
+              ),
+              /***/
+              3637: (
+                /***/
+                function(module22, __unused_webpack_exports, __webpack_require__2) {
+                  module22.exports = solveIntersection;
+                  var ratMul = __webpack_require__2(6504);
+                  var ratDiv = __webpack_require__2(8697);
+                  var ratSub = __webpack_require__2(5572);
+                  var ratSign = __webpack_require__2(7721);
+                  var rvSub = __webpack_require__2(544);
+                  var rvAdd = __webpack_require__2(2653);
+                  var rvMuls = __webpack_require__2(8987);
+                  function ratPerp(a2, b2) {
+                    return ratSub(ratMul(a2[0], b2[1]), ratMul(a2[1], b2[0]));
+                  }
+                  function solveIntersection(a2, b2, c2, d2) {
+                    var ba = rvSub(b2, a2);
+                    var dc2 = rvSub(d2, c2);
+                    var baXdc = ratPerp(ba, dc2);
+                    if (ratSign(baXdc) === 0) {
+                      return null;
+                    }
+                    var ac2 = rvSub(a2, c2);
+                    var dcXac = ratPerp(dc2, ac2);
+                    var t4 = ratDiv(dcXac, baXdc);
+                    var s2 = rvMuls(ba, t4);
+                    var r2 = rvAdd(a2, s2);
+                    return r2;
+                  }
+                }
+              ),
+              /***/
+              3642: (
+                /***/
+                function(module22) {
+                  module22.exports = {
+                    "jet": [{ "index": 0, "rgb": [0, 0, 131] }, { "index": 0.125, "rgb": [0, 60, 170] }, { "index": 0.375, "rgb": [5, 255, 255] }, { "index": 0.625, "rgb": [255, 255, 0] }, { "index": 0.875, "rgb": [250, 0, 0] }, { "index": 1, "rgb": [128, 0, 0] }],
+                    "hsv": [{ "index": 0, "rgb": [255, 0, 0] }, { "index": 0.169, "rgb": [253, 255, 2] }, { "index": 0.173, "rgb": [247, 255, 2] }, { "index": 0.337, "rgb": [0, 252, 4] }, { "index": 0.341, "rgb": [0, 252, 10] }, { "index": 0.506, "rgb": [1, 249, 255] }, { "index": 0.671, "rgb": [2, 0, 253] }, { "index": 0.675, "rgb": [8, 0, 253] }, { "index": 0.839, "rgb": [255, 0, 251] }, { "index": 0.843, "rgb": [255, 0, 245] }, { "index": 1, "rgb": [255, 0, 6] }],
+                    "hot": [{ "index": 0, "rgb": [0, 0, 0] }, { "index": 0.3, "rgb": [230, 0, 0] }, { "index": 0.6, "rgb": [255, 210, 0] }, { "index": 1, "rgb": [255, 255, 255] }],
+                    "spring": [{ "index": 0, "rgb": [255, 0, 255] }, { "index": 1, "rgb": [255, 255, 0] }],
+                    "summer": [{ "index": 0, "rgb": [0, 128, 102] }, { "index": 1, "rgb": [255, 255, 102] }],
+                    "autumn": [{ "index": 0, "rgb": [255, 0, 0] }, { "index": 1, "rgb": [255, 255, 0] }],
+                    "winter": [{ "index": 0, "rgb": [0, 0, 255] }, { "index": 1, "rgb": [0, 255, 128] }],
+                    "bone": [{ "index": 0, "rgb": [0, 0, 0] }, { "index": 0.376, "rgb": [84, 84, 116] }, { "index": 0.753, "rgb": [169, 200, 200] }, { "index": 1, "rgb": [255, 255, 255] }],
+                    "copper": [{ "index": 0, "rgb": [0, 0, 0] }, { "index": 0.804, "rgb": [255, 160, 102] }, { "index": 1, "rgb": [255, 199, 127] }],
+                    "greys": [{ "index": 0, "rgb": [0, 0, 0] }, { "index": 1, "rgb": [255, 255, 255] }],
+                    "yignbu": [{ "index": 0, "rgb": [8, 29, 88] }, { "index": 0.125, "rgb": [37, 52, 148] }, { "index": 0.25, "rgb": [34, 94, 168] }, { "index": 0.375, "rgb": [29, 145, 192] }, { "index": 0.5, "rgb": [65, 182, 196] }, { "index": 0.625, "rgb": [127, 205, 187] }, { "index": 0.75, "rgb": [199, 233, 180] }, { "index": 0.875, "rgb": [237, 248, 217] }, { "index": 1, "rgb": [255, 255, 217] }],
+                    "greens": [{ "index": 0, "rgb": [0, 68, 27] }, { "index": 0.125, "rgb": [0, 109, 44] }, { "index": 0.25, "rgb": [35, 139, 69] }, { "index": 0.375, "rgb": [65, 171, 93] }, { "index": 0.5, "rgb": [116, 196, 118] }, { "index": 0.625, "rgb": [161, 217, 155] }, { "index": 0.75, "rgb": [199, 233, 192] }, { "index": 0.875, "rgb": [229, 245, 224] }, { "index": 1, "rgb": [247, 252, 245] }],
+                    "yiorrd": [{ "index": 0, "rgb": [128, 0, 38] }, { "index": 0.125, "rgb": [189, 0, 38] }, { "index": 0.25, "rgb": [227, 26, 28] }, { "index": 0.375, "rgb": [252, 78, 42] }, { "index": 0.5, "rgb": [253, 141, 60] }, { "index": 0.625, "rgb": [254, 178, 76] }, { "index": 0.75, "rgb": [254, 217, 118] }, { "index": 0.875, "rgb": [255, 237, 160] }, { "index": 1, "rgb": [255, 255, 204] }],
+                    "bluered": [{ "index": 0, "rgb": [0, 0, 255] }, { "index": 1, "rgb": [255, 0, 0] }],
+                    "rdbu": [{ "index": 0, "rgb": [5, 10, 172] }, { "index": 0.35, "rgb": [106, 137, 247] }, { "index": 0.5, "rgb": [190, 190, 190] }, { "index": 0.6, "rgb": [220, 170, 132] }, { "index": 0.7, "rgb": [230, 145, 90] }, { "index": 1, "rgb": [178, 10, 28] }],
+                    "picnic": [{ "index": 0, "rgb": [0, 0, 255] }, { "index": 0.1, "rgb": [51, 153, 255] }, { "index": 0.2, "rgb": [102, 204, 255] }, { "index": 0.3, "rgb": [153, 204, 255] }, { "index": 0.4, "rgb": [204, 204, 255] }, { "index": 0.5, "rgb": [255, 255, 255] }, { "index": 0.6, "rgb": [255, 204, 255] }, { "index": 0.7, "rgb": [255, 153, 255] }, { "index": 0.8, "rgb": [255, 102, 204] }, { "index": 0.9, "rgb": [255, 102, 102] }, { "index": 1, "rgb": [255, 0, 0] }],
+                    "rainbow": [{ "index": 0, "rgb": [150, 0, 90] }, { "index": 0.125, "rgb": [0, 0, 200] }, { "index": 0.25, "rgb": [0, 25, 255] }, { "index": 0.375, "rgb": [0, 152, 255] }, { "index": 0.5, "rgb": [44, 255, 150] }, { "index": 0.625, "rgb": [151, 255, 0] }, { "index": 0.75, "rgb": [255, 234, 0] }, { "index": 0.875, "rgb": [255, 111, 0] }, { "index": 1, "rgb": [255, 0, 0] }],
+                    "portland": [{ "index": 0, "rgb": [12, 51, 131] }, { "index": 0.25, "rgb": [10, 136, 186] }, { "index": 0.5, "rgb": [242, 211, 56] }, { "index": 0.75, "rgb": [242, 143, 56] }, { "index": 1, "rgb": [217, 30, 30] }],
+                    "blackbody": [{ "index": 0, "rgb": [0, 0, 0] }, { "index": 0.2, "rgb": [230, 0, 0] }, { "index": 0.4, "rgb": [230, 210, 0] }, { "index": 0.7, "rgb": [255, 255, 255] }, { "index": 1, "rgb": [160, 200, 255] }],
+                    "earth": [{ "index": 0, "rgb": [0, 0, 130] }, { "index": 0.1, "rgb": [0, 180, 180] }, { "index": 0.2, "rgb": [40, 210, 40] }, { "index": 0.4, "rgb": [230, 230, 50] }, { "index": 0.6, "rgb": [120, 70, 20] }, { "index": 1, "rgb": [255, 255, 255] }],
+                    "electric": [{ "index": 0, "rgb": [0, 0, 0] }, { "index": 0.15, "rgb": [30, 0, 100] }, { "index": 0.4, "rgb": [120, 0, 100] }, { "index": 0.6, "rgb": [160, 90, 0] }, { "index": 0.8, "rgb": [230, 200, 0] }, { "index": 1, "rgb": [255, 250, 220] }],
+                    "alpha": [{ "index": 0, "rgb": [255, 255, 255, 0] }, { "index": 1, "rgb": [255, 255, 255, 1] }],
+                    "viridis": [{ "index": 0, "rgb": [68, 1, 84] }, { "index": 0.13, "rgb": [71, 44, 122] }, { "index": 0.25, "rgb": [59, 81, 139] }, { "index": 0.38, "rgb": [44, 113, 142] }, { "index": 0.5, "rgb": [33, 144, 141] }, { "index": 0.63, "rgb": [39, 173, 129] }, { "index": 0.75, "rgb": [92, 200, 99] }, { "index": 0.88, "rgb": [170, 220, 50] }, { "index": 1, "rgb": [253, 231, 37] }],
+                    "inferno": [{ "index": 0, "rgb": [0, 0, 4] }, { "index": 0.13, "rgb": [31, 12, 72] }, { "index": 0.25, "rgb": [85, 15, 109] }, { "index": 0.38, "rgb": [136, 34, 106] }, { "index": 0.5, "rgb": [186, 54, 85] }, { "index": 0.63, "rgb": [227, 89, 51] }, { "index": 0.75, "rgb": [249, 140, 10] }, { "index": 0.88, "rgb": [249, 201, 50] }, { "index": 1, "rgb": [252, 255, 164] }],
+                    "magma": [{ "index": 0, "rgb": [0, 0, 4] }, { "index": 0.13, "rgb": [28, 16, 68] }, { "index": 0.25, "rgb": [79, 18, 123] }, { "index": 0.38, "rgb": [129, 37, 129] }, { "index": 0.5, "rgb": [181, 54, 122] }, { "index": 0.63, "rgb": [229, 80, 100] }, { "index": 0.75, "rgb": [251, 135, 97] }, { "index": 0.88, "rgb": [254, 194, 135] }, { "index": 1, "rgb": [252, 253, 191] }],
+                    "plasma": [{ "index": 0, "rgb": [13, 8, 135] }, { "index": 0.13, "rgb": [75, 3, 161] }, { "index": 0.25, "rgb": [125, 3, 168] }, { "index": 0.38, "rgb": [168, 34, 150] }, { "index": 0.5, "rgb": [203, 70, 121] }, { "index": 0.63, "rgb": [229, 107, 93] }, { "index": 0.75, "rgb": [248, 148, 65] }, { "index": 0.88, "rgb": [253, 195, 40] }, { "index": 1, "rgb": [240, 249, 33] }],
+                    "warm": [{ "index": 0, "rgb": [125, 0, 179] }, { "index": 0.13, "rgb": [172, 0, 187] }, { "index": 0.25, "rgb": [219, 0, 170] }, { "index": 0.38, "rgb": [255, 0, 130] }, { "index": 0.5, "rgb": [255, 63, 74] }, { "index": 0.63, "rgb": [255, 123, 0] }, { "index": 0.75, "rgb": [234, 176, 0] }, { "index": 0.88, "rgb": [190, 228, 0] }, { "index": 1, "rgb": [147, 255, 0] }],
+                    "cool": [{ "index": 0, "rgb": [125, 0, 179] }, { "index": 0.13, "rgb": [116, 0, 218] }, { "index": 0.25, "rgb": [98, 74, 237] }, { "index": 0.38, "rgb": [68, 146, 231] }, { "index": 0.5, "rgb": [0, 204, 197] }, { "index": 0.63, "rgb": [0, 247, 146] }, { "index": 0.75, "rgb": [0, 255, 88] }, { "index": 0.88, "rgb": [40, 255, 8] }, { "index": 1, "rgb": [147, 255, 0] }],
+                    "rainbow-soft": [{ "index": 0, "rgb": [125, 0, 179] }, { "index": 0.1, "rgb": [199, 0, 180] }, { "index": 0.2, "rgb": [255, 0, 121] }, { "index": 0.3, "rgb": [255, 108, 0] }, { "index": 0.4, "rgb": [222, 194, 0] }, { "index": 0.5, "rgb": [150, 255, 0] }, { "index": 0.6, "rgb": [0, 255, 55] }, { "index": 0.7, "rgb": [0, 246, 150] }, { "index": 0.8, "rgb": [50, 167, 222] }, { "index": 0.9, "rgb": [103, 51, 235] }, { "index": 1, "rgb": [124, 0, 186] }],
+                    "bathymetry": [{ "index": 0, "rgb": [40, 26, 44] }, { "index": 0.13, "rgb": [59, 49, 90] }, { "index": 0.25, "rgb": [64, 76, 139] }, { "index": 0.38, "rgb": [63, 110, 151] }, { "index": 0.5, "rgb": [72, 142, 158] }, { "index": 0.63, "rgb": [85, 174, 163] }, { "index": 0.75, "rgb": [120, 206, 163] }, { "index": 0.88, "rgb": [187, 230, 172] }, { "index": 1, "rgb": [253, 254, 204] }],
+                    "cdom": [{ "index": 0, "rgb": [47, 15, 62] }, { "index": 0.13, "rgb": [87, 23, 86] }, { "index": 0.25, "rgb": [130, 28, 99] }, { "index": 0.38, "rgb": [171, 41, 96] }, { "index": 0.5, "rgb": [206, 67, 86] }, { "index": 0.63, "rgb": [230, 106, 84] }, { "index": 0.75, "rgb": [242, 149, 103] }, { "index": 0.88, "rgb": [249, 193, 135] }, { "index": 1, "rgb": [254, 237, 176] }],
+                    "chlorophyll": [{ "index": 0, "rgb": [18, 36, 20] }, { "index": 0.13, "rgb": [25, 63, 41] }, { "index": 0.25, "rgb": [24, 91, 59] }, { "index": 0.38, "rgb": [13, 119, 72] }, { "index": 0.5, "rgb": [18, 148, 80] }, { "index": 0.63, "rgb": [80, 173, 89] }, { "index": 0.75, "rgb": [132, 196, 122] }, { "index": 0.88, "rgb": [175, 221, 162] }, { "index": 1, "rgb": [215, 249, 208] }],
+                    "density": [{ "index": 0, "rgb": [54, 14, 36] }, { "index": 0.13, "rgb": [89, 23, 80] }, { "index": 0.25, "rgb": [110, 45, 132] }, { "index": 0.38, "rgb": [120, 77, 178] }, { "index": 0.5, "rgb": [120, 113, 213] }, { "index": 0.63, "rgb": [115, 151, 228] }, { "index": 0.75, "rgb": [134, 185, 227] }, { "index": 0.88, "rgb": [177, 214, 227] }, { "index": 1, "rgb": [230, 241, 241] }],
+                    "freesurface-blue": [{ "index": 0, "rgb": [30, 4, 110] }, { "index": 0.13, "rgb": [47, 14, 176] }, { "index": 0.25, "rgb": [41, 45, 236] }, { "index": 0.38, "rgb": [25, 99, 212] }, { "index": 0.5, "rgb": [68, 131, 200] }, { "index": 0.63, "rgb": [114, 156, 197] }, { "index": 0.75, "rgb": [157, 181, 203] }, { "index": 0.88, "rgb": [200, 208, 216] }, { "index": 1, "rgb": [241, 237, 236] }],
+                    "freesurface-red": [{ "index": 0, "rgb": [60, 9, 18] }, { "index": 0.13, "rgb": [100, 17, 27] }, { "index": 0.25, "rgb": [142, 20, 29] }, { "index": 0.38, "rgb": [177, 43, 27] }, { "index": 0.5, "rgb": [192, 87, 63] }, { "index": 0.63, "rgb": [205, 125, 105] }, { "index": 0.75, "rgb": [216, 162, 148] }, { "index": 0.88, "rgb": [227, 199, 193] }, { "index": 1, "rgb": [241, 237, 236] }],
+                    "oxygen": [{ "index": 0, "rgb": [64, 5, 5] }, { "index": 0.13, "rgb": [106, 6, 15] }, { "index": 0.25, "rgb": [144, 26, 7] }, { "index": 0.38, "rgb": [168, 64, 3] }, { "index": 0.5, "rgb": [188, 100, 4] }, { "index": 0.63, "rgb": [206, 136, 11] }, { "index": 0.75, "rgb": [220, 174, 25] }, { "index": 0.88, "rgb": [231, 215, 44] }, { "index": 1, "rgb": [248, 254, 105] }],
+                    "par": [{ "index": 0, "rgb": [51, 20, 24] }, { "index": 0.13, "rgb": [90, 32, 35] }, { "index": 0.25, "rgb": [129, 44, 34] }, { "index": 0.38, "rgb": [159, 68, 25] }, { "index": 0.5, "rgb": [182, 99, 19] }, { "index": 0.63, "rgb": [199, 134, 22] }, { "index": 0.75, "rgb": [212, 171, 35] }, { "index": 0.88, "rgb": [221, 210, 54] }, { "index": 1, "rgb": [225, 253, 75] }],
+                    "phase": [{ "index": 0, "rgb": [145, 105, 18] }, { "index": 0.13, "rgb": [184, 71, 38] }, { "index": 0.25, "rgb": [186, 58, 115] }, { "index": 0.38, "rgb": [160, 71, 185] }, { "index": 0.5, "rgb": [110, 97, 218] }, { "index": 0.63, "rgb": [50, 123, 164] }, { "index": 0.75, "rgb": [31, 131, 110] }, { "index": 0.88, "rgb": [77, 129, 34] }, { "index": 1, "rgb": [145, 105, 18] }],
+                    "salinity": [{ "index": 0, "rgb": [42, 24, 108] }, { "index": 0.13, "rgb": [33, 50, 162] }, { "index": 0.25, "rgb": [15, 90, 145] }, { "index": 0.38, "rgb": [40, 118, 137] }, { "index": 0.5, "rgb": [59, 146, 135] }, { "index": 0.63, "rgb": [79, 175, 126] }, { "index": 0.75, "rgb": [120, 203, 104] }, { "index": 0.88, "rgb": [193, 221, 100] }, { "index": 1, "rgb": [253, 239, 154] }],
+                    "temperature": [{ "index": 0, "rgb": [4, 35, 51] }, { "index": 0.13, "rgb": [23, 51, 122] }, { "index": 0.25, "rgb": [85, 59, 157] }, { "index": 0.38, "rgb": [129, 79, 143] }, { "index": 0.5, "rgb": [175, 95, 130] }, { "index": 0.63, "rgb": [222, 112, 101] }, { "index": 0.75, "rgb": [249, 146, 66] }, { "index": 0.88, "rgb": [249, 196, 65] }, { "index": 1, "rgb": [232, 250, 91] }],
+                    "turbidity": [{ "index": 0, "rgb": [34, 31, 27] }, { "index": 0.13, "rgb": [65, 50, 41] }, { "index": 0.25, "rgb": [98, 69, 52] }, { "index": 0.38, "rgb": [131, 89, 57] }, { "index": 0.5, "rgb": [161, 112, 59] }, { "index": 0.63, "rgb": [185, 140, 66] }, { "index": 0.75, "rgb": [202, 174, 88] }, { "index": 0.88, "rgb": [216, 209, 126] }, { "index": 1, "rgb": [233, 246, 171] }],
+                    "velocity-blue": [{ "index": 0, "rgb": [17, 32, 64] }, { "index": 0.13, "rgb": [35, 52, 116] }, { "index": 0.25, "rgb": [29, 81, 156] }, { "index": 0.38, "rgb": [31, 113, 162] }, { "index": 0.5, "rgb": [50, 144, 169] }, { "index": 0.63, "rgb": [87, 173, 176] }, { "index": 0.75, "rgb": [149, 196, 189] }, { "index": 0.88, "rgb": [203, 221, 211] }, { "index": 1, "rgb": [254, 251, 230] }],
+                    "velocity-green": [{ "index": 0, "rgb": [23, 35, 19] }, { "index": 0.13, "rgb": [24, 64, 38] }, { "index": 0.25, "rgb": [11, 95, 45] }, { "index": 0.38, "rgb": [39, 123, 35] }, { "index": 0.5, "rgb": [95, 146, 12] }, { "index": 0.63, "rgb": [152, 165, 18] }, { "index": 0.75, "rgb": [201, 186, 69] }, { "index": 0.88, "rgb": [233, 216, 137] }, { "index": 1, "rgb": [255, 253, 205] }],
+                    "cubehelix": [{ "index": 0, "rgb": [0, 0, 0] }, { "index": 0.07, "rgb": [22, 5, 59] }, { "index": 0.13, "rgb": [60, 4, 105] }, { "index": 0.2, "rgb": [109, 1, 135] }, { "index": 0.27, "rgb": [161, 0, 147] }, { "index": 0.33, "rgb": [210, 2, 142] }, { "index": 0.4, "rgb": [251, 11, 123] }, { "index": 0.47, "rgb": [255, 29, 97] }, { "index": 0.53, "rgb": [255, 54, 69] }, { "index": 0.6, "rgb": [255, 85, 46] }, { "index": 0.67, "rgb": [255, 120, 34] }, { "index": 0.73, "rgb": [255, 157, 37] }, { "index": 0.8, "rgb": [241, 191, 57] }, { "index": 0.87, "rgb": [224, 220, 93] }, { "index": 0.93, "rgb": [218, 241, 142] }, { "index": 1, "rgb": [227, 253, 198] }]
+                  };
+                }
+              ),
+              /***/
+              3711: (
+                /***/
+                function(module22, __unused_webpack_exports, __webpack_require__2) {
+                  module22.exports = surfaceNets;
+                  var generateContourExtractor = __webpack_require__2(2640);
+                  var zeroCrossings = __webpack_require__2(781);
+                  var allFns = {
+                    "2d": function(genContour, order, dtype) {
+                      var contour = genContour({
+                        order,
+                        scalarArguments: 3,
+                        getters: dtype === "generic" ? [0] : void 0,
+                        phase: function phaseFunc(p2, a2, b2, c2) {
+                          return p2 > c2 | 0;
+                        },
+                        vertex: function vertexFunc(d0, d1, v0, v1, v2, v3, p0, p1, p2, p3, a2, b2, c2) {
+                          var m2 = (p0 << 0) + (p1 << 1) + (p2 << 2) + (p3 << 3) | 0;
+                          if (m2 === 0 || m2 === 15) {
+                            return;
+                          }
+                          switch (m2) {
+                            case 0:
+                              a2.push([d0 - 0.5, d1 - 0.5]);
+                              break;
+                            case 1:
+                              a2.push([d0 - 0.25 - 0.25 * (v1 + v0 - 2 * c2) / (v0 - v1), d1 - 0.25 - 0.25 * (v2 + v0 - 2 * c2) / (v0 - v2)]);
+                              break;
+                            case 2:
+                              a2.push([d0 - 0.75 - 0.25 * (-v1 - v0 + 2 * c2) / (v1 - v0), d1 - 0.25 - 0.25 * (v3 + v1 - 2 * c2) / (v1 - v3)]);
+                              break;
+                            case 3:
+                              a2.push([d0 - 0.5, d1 - 0.5 - 0.5 * (v2 + v0 + v3 + v1 - 4 * c2) / (v0 - v2 + v1 - v3)]);
+                              break;
+                            case 4:
+                              a2.push([d0 - 0.25 - 0.25 * (v3 + v2 - 2 * c2) / (v2 - v3), d1 - 0.75 - 0.25 * (-v2 - v0 + 2 * c2) / (v2 - v0)]);
+                              break;
+                            case 5:
+                              a2.push([d0 - 0.5 - 0.5 * (v1 + v0 + v3 + v2 - 4 * c2) / (v0 - v1 + v2 - v3), d1 - 0.5]);
+                              break;
+                            case 6:
+                              a2.push([d0 - 0.5 - 0.25 * (-v1 - v0 + v3 + v2) / (v1 - v0 + v2 - v3), d1 - 0.5 - 0.25 * (-v2 - v0 + v3 + v1) / (v2 - v0 + v1 - v3)]);
+                              break;
+                            case 7:
+                              a2.push([d0 - 0.75 - 0.25 * (v3 + v2 - 2 * c2) / (v2 - v3), d1 - 0.75 - 0.25 * (v3 + v1 - 2 * c2) / (v1 - v3)]);
+                              break;
+                            case 8:
+                              a2.push([d0 - 0.75 - 0.25 * (-v3 - v2 + 2 * c2) / (v3 - v2), d1 - 0.75 - 0.25 * (-v3 - v1 + 2 * c2) / (v3 - v1)]);
+                              break;
+                            case 9:
+                              a2.push([d0 - 0.5 - 0.25 * (v1 + v0 + -v3 - v2) / (v0 - v1 + v3 - v2), d1 - 0.5 - 0.25 * (v2 + v0 + -v3 - v1) / (v0 - v2 + v3 - v1)]);
+                              break;
+                            case 10:
+                              a2.push([d0 - 0.5 - 0.5 * (-v1 - v0 + -v3 - v2 + 4 * c2) / (v1 - v0 + v3 - v2), d1 - 0.5]);
+                              break;
+                            case 11:
+                              a2.push([d0 - 0.25 - 0.25 * (-v3 - v2 + 2 * c2) / (v3 - v2), d1 - 0.75 - 0.25 * (v2 + v0 - 2 * c2) / (v0 - v2)]);
+                              break;
+                            case 12:
+                              a2.push([d0 - 0.5, d1 - 0.5 - 0.5 * (-v2 - v0 + -v3 - v1 + 4 * c2) / (v2 - v0 + v3 - v1)]);
+                              break;
+                            case 13:
+                              a2.push([d0 - 0.75 - 0.25 * (v1 + v0 - 2 * c2) / (v0 - v1), d1 - 0.25 - 0.25 * (-v3 - v1 + 2 * c2) / (v3 - v1)]);
+                              break;
+                            case 14:
+                              a2.push([d0 - 0.25 - 0.25 * (-v1 - v0 + 2 * c2) / (v1 - v0), d1 - 0.25 - 0.25 * (-v2 - v0 + 2 * c2) / (v2 - v0)]);
+                              break;
+                            case 15:
+                              a2.push([d0 - 0.5, d1 - 0.5]);
+                              break;
+                          }
+                        },
+                        cell: function cellFunc(v0, v1, c0, c1, p0, p1, a2, b2, c2) {
+                          if (p0) {
+                            b2.push([v0, v1]);
+                          } else {
+                            b2.push([v1, v0]);
+                          }
+                        }
+                      });
+                      return function(array, level) {
+                        var verts = [], cells = [];
+                        contour(array, verts, cells, level);
+                        return { positions: verts, cells };
+                      };
+                    }
+                  };
+                  function buildSurfaceNets(order, dtype) {
+                    var inKey = order.length + "d";
+                    var fn = allFns[inKey];
+                    if (fn) return fn(generateContourExtractor, order, dtype);
+                  }
+                  function mesh1D(array, level) {
+                    var zc2 = zeroCrossings(array, level);
+                    var n2 = zc2.length;
+                    var npos = new Array(n2);
+                    var ncel = new Array(n2);
+                    for (var i2 = 0; i2 < n2; ++i2) {
+                      npos[i2] = [zc2[i2]];
+                      ncel[i2] = [i2];
+                    }
+                    return {
+                      positions: npos,
+                      cells: ncel
+                    };
+                  }
+                  var CACHE = {};
+                  function surfaceNets(array, level) {
+                    if (array.dimension <= 0) {
+                      return { positions: [], cells: [] };
+                    } else if (array.dimension === 1) {
+                      return mesh1D(array, level);
+                    }
+                    var typesig = array.order.join() + "-" + array.dtype;
+                    var proc = CACHE[typesig];
+                    var level = +level || 0;
+                    if (!proc) {
+                      proc = CACHE[typesig] = buildSurfaceNets(array.order, array.dtype);
+                    }
+                    return proc(array, level);
+                  }
+                }
+              ),
+              /***/
+              3750: (
+                /***/
+                function(module22) {
+                  module22.exports = dot2;
+                  function dot2(a2, b2) {
+                    return a2[0] * b2[0] + a2[1] * b2[1] + a2[2] * b2[2] + a2[3] * b2[3];
+                  }
+                }
+              ),
+              /***/
+              3778: (
+                /***/
+                function(__unused_webpack_module, exports2) {
+                  exports2.read = function(buffer, offset, isLE, mLen, nBytes) {
+                    var e2, m2;
+                    var eLen = nBytes * 8 - mLen - 1;
+                    var eMax = (1 << eLen) - 1;
+                    var eBias = eMax >> 1;
+                    var nBits = -7;
+                    var i2 = isLE ? nBytes - 1 : 0;
+                    var d2 = isLE ? -1 : 1;
+                    var s2 = buffer[offset + i2];
+                    i2 += d2;
+                    e2 = s2 & (1 << -nBits) - 1;
+                    s2 >>= -nBits;
+                    nBits += eLen;
+                    for (; nBits > 0; e2 = e2 * 256 + buffer[offset + i2], i2 += d2, nBits -= 8) {
+                    }
+                    m2 = e2 & (1 << -nBits) - 1;
+                    e2 >>= -nBits;
+                    nBits += mLen;
+                    for (; nBits > 0; m2 = m2 * 256 + buffer[offset + i2], i2 += d2, nBits -= 8) {
+                    }
+                    if (e2 === 0) {
+                      e2 = 1 - eBias;
+                    } else if (e2 === eMax) {
+                      return m2 ? NaN : (s2 ? -1 : 1) * Infinity;
+                    } else {
+                      m2 = m2 + Math.pow(2, mLen);
+                      e2 = e2 - eBias;
+                    }
+                    return (s2 ? -1 : 1) * m2 * Math.pow(2, e2 - mLen);
+                  };
+                  exports2.write = function(buffer, value, offset, isLE, mLen, nBytes) {
+                    var e2, m2, c2;
+                    var eLen = nBytes * 8 - mLen - 1;
+                    var eMax = (1 << eLen) - 1;
+                    var eBias = eMax >> 1;
+                    var rt2 = mLen === 23 ? Math.pow(2, -24) - Math.pow(2, -77) : 0;
+                    var i2 = isLE ? 0 : nBytes - 1;
+                    var d2 = isLE ? 1 : -1;
+                    var s2 = value < 0 || value === 0 && 1 / value < 0 ? 1 : 0;
+                    value = Math.abs(value);
+                    if (isNaN(value) || value === Infinity) {
+                      m2 = isNaN(value) ? 1 : 0;
+                      e2 = eMax;
+                    } else {
+                      e2 = Math.floor(Math.log(value) / Math.LN2);
+                      if (value * (c2 = Math.pow(2, -e2)) < 1) {
+                        e2--;
+                        c2 *= 2;
+                      }
+                      if (e2 + eBias >= 1) {
+                        value += rt2 / c2;
+                      } else {
+                        value += rt2 * Math.pow(2, 1 - eBias);
+                      }
+                      if (value * c2 >= 2) {
+                        e2++;
+                        c2 /= 2;
+                      }
+                      if (e2 + eBias >= eMax) {
+                        m2 = 0;
+                        e2 = eMax;
+                      } else if (e2 + eBias >= 1) {
+                        m2 = (value * c2 - 1) * Math.pow(2, mLen);
+                        e2 = e2 + eBias;
+                      } else {
+                        m2 = value * Math.pow(2, eBias - 1) * Math.pow(2, mLen);
+                        e2 = 0;
+                      }
+                    }
+                    for (; mLen >= 8; buffer[offset + i2] = m2 & 255, i2 += d2, m2 /= 256, mLen -= 8) {
+                    }
+                    e2 = e2 << mLen | m2;
+                    eLen += mLen;
+                    for (; eLen > 0; buffer[offset + i2] = e2 & 255, i2 += d2, e2 /= 256, eLen -= 8) {
+                    }
+                    buffer[offset + i2 - d2] |= s2 * 128;
+                  };
+                }
+              ),
+              /***/
+              3788: (
+                /***/
+                function(module22, __unused_webpack_exports, __webpack_require__2) {
+                  var compareCells = __webpack_require__2(8507);
+                  var parity = __webpack_require__2(2419);
+                  module22.exports = compareOrientedCells;
+                  function compareOrientedCells(a2, b2) {
+                    return compareCells(a2, b2) || parity(a2) - parity(b2);
+                  }
+                }
+              ),
+              /***/
+              3837: (
+                /***/
+                function(module22, __unused_webpack_exports, __webpack_require__2) {
+                  module22.exports = createAxes;
+                  var createText = __webpack_require__2(4935);
+                  var createLines = __webpack_require__2(501);
+                  var createBackground = __webpack_require__2(5304);
+                  var getCubeProperties = __webpack_require__2(6429);
+                  var Ticks = __webpack_require__2(6444);
+                  var identity22 = new Float32Array([
+                    1,
+                    0,
+                    0,
+                    0,
+                    0,
+                    1,
+                    0,
+                    0,
+                    0,
+                    0,
+                    1,
+                    0,
+                    0,
+                    0,
+                    0,
+                    1
+                  ]);
+                  var ab2 = ArrayBuffer;
+                  var dv = DataView;
+                  function isTypedArray2(a2) {
+                    return ab2.isView(a2) && !(a2 instanceof dv);
+                  }
+                  function isArrayOrTypedArray(a2) {
+                    return Array.isArray(a2) || isTypedArray2(a2);
+                  }
+                  function copyVec3(a2, b2) {
+                    a2[0] = b2[0];
+                    a2[1] = b2[1];
+                    a2[2] = b2[2];
+                    return a2;
+                  }
+                  function Axes(gl2) {
+                    this.gl = gl2;
+                    this.pixelRatio = 1;
+                    this.bounds = [
+                      [-10, -10, -10],
+                      [10, 10, 10]
+                    ];
+                    this.ticks = [[], [], []];
+                    this.autoTicks = true;
+                    this.tickSpacing = [1, 1, 1];
+                    this.tickEnable = [true, true, true];
+                    this.tickFont = ["sans-serif", "sans-serif", "sans-serif"];
+                    this.tickFontStyle = ["normal", "normal", "normal"];
+                    this.tickFontWeight = ["normal", "normal", "normal"];
+                    this.tickFontVariant = ["normal", "normal", "normal"];
+                    this.tickSize = [12, 12, 12];
+                    this.tickAngle = [0, 0, 0];
+                    this.tickAlign = ["auto", "auto", "auto"];
+                    this.tickColor = [[0, 0, 0, 1], [0, 0, 0, 1], [0, 0, 0, 1]];
+                    this.tickPad = [10, 10, 10];
+                    this.lastCubeProps = {
+                      cubeEdges: [0, 0, 0],
+                      axis: [0, 0, 0]
+                    };
+                    this.labels = ["x", "y", "z"];
+                    this.labelEnable = [true, true, true];
+                    this.labelFont = ["sans-serif", "sans-serif", "sans-serif"];
+                    this.labelFontStyle = ["normal", "normal", "normal"];
+                    this.labelFontWeight = ["normal", "normal", "normal"];
+                    this.labelFontVariant = ["normal", "normal", "normal"];
+                    this.labelSize = [20, 20, 20];
+                    this.labelAngle = [0, 0, 0];
+                    this.labelAlign = ["auto", "auto", "auto"];
+                    this.labelColor = [[0, 0, 0, 1], [0, 0, 0, 1], [0, 0, 0, 1]];
+                    this.labelPad = [10, 10, 10];
+                    this.lineEnable = [true, true, true];
+                    this.lineMirror = [false, false, false];
+                    this.lineWidth = [1, 1, 1];
+                    this.lineColor = [[0, 0, 0, 1], [0, 0, 0, 1], [0, 0, 0, 1]];
+                    this.lineTickEnable = [true, true, true];
+                    this.lineTickMirror = [false, false, false];
+                    this.lineTickLength = [0, 0, 0];
+                    this.lineTickWidth = [1, 1, 1];
+                    this.lineTickColor = [[0, 0, 0, 1], [0, 0, 0, 1], [0, 0, 0, 1]];
+                    this.gridEnable = [true, true, true];
+                    this.gridWidth = [1, 1, 1];
+                    this.gridColor = [[0, 0, 0, 1], [0, 0, 0, 1], [0, 0, 0, 1]];
+                    this.zeroEnable = [true, true, true];
+                    this.zeroLineColor = [[0, 0, 0, 1], [0, 0, 0, 1], [0, 0, 0, 1]];
+                    this.zeroLineWidth = [2, 2, 2];
+                    this.backgroundEnable = [false, false, false];
+                    this.backgroundColor = [
+                      [0.8, 0.8, 0.8, 0.5],
+                      [0.8, 0.8, 0.8, 0.5],
+                      [0.8, 0.8, 0.8, 0.5]
+                    ];
+                    this._firstInit = true;
+                    this._text = null;
+                    this._lines = null;
+                    this._background = createBackground(gl2);
+                  }
+                  var proto = Axes.prototype;
+                  proto.update = function(options) {
+                    options = options || {};
+                    function parseOption(nest, cons, name2) {
+                      if (name2 in options) {
+                        var opt = options[name2];
+                        var prev = this[name2];
+                        var next;
+                        if (nest ? isArrayOrTypedArray(opt) && isArrayOrTypedArray(opt[0]) : isArrayOrTypedArray(opt)) {
+                          this[name2] = next = [cons(opt[0]), cons(opt[1]), cons(opt[2])];
+                        } else {
+                          this[name2] = next = [cons(opt), cons(opt), cons(opt)];
+                        }
+                        for (var i22 = 0; i22 < 3; ++i22) {
+                          if (next[i22] !== prev[i22]) {
+                            return true;
+                          }
+                        }
+                      }
+                      return false;
+                    }
+                    var NUMBER = parseOption.bind(this, false, Number);
+                    var BOOLEAN = parseOption.bind(this, false, Boolean);
+                    var STRING = parseOption.bind(this, false, String);
+                    var COLOR2 = parseOption.bind(this, true, function(v2) {
+                      if (isArrayOrTypedArray(v2)) {
+                        if (v2.length === 3) {
+                          return [+v2[0], +v2[1], +v2[2], 1];
+                        } else if (v2.length === 4) {
+                          return [+v2[0], +v2[1], +v2[2], +v2[3]];
+                        }
+                      }
+                      return [0, 0, 0, 1];
+                    });
+                    var nextTicks;
+                    var ticksUpdate = false;
+                    var boundsChanged = false;
+                    if ("bounds" in options) {
+                      var bounds = options.bounds;
+                      for (var i2 = 0; i2 < 2; ++i2) {
+                        for (var j2 = 0; j2 < 3; ++j2) {
+                          if (bounds[i2][j2] !== this.bounds[i2][j2]) {
+                            boundsChanged = true;
+                          }
+                          this.bounds[i2][j2] = bounds[i2][j2];
+                        }
+                      }
+                    }
+                    if ("ticks" in options) {
+                      nextTicks = options.ticks;
+                      ticksUpdate = true;
+                      this.autoTicks = false;
+                      for (var i2 = 0; i2 < 3; ++i2) {
+                        this.tickSpacing[i2] = 0;
+                      }
+                    } else if (NUMBER("tickSpacing")) {
+                      this.autoTicks = true;
+                      boundsChanged = true;
+                    }
+                    if (this._firstInit) {
+                      if (!("ticks" in options || "tickSpacing" in options)) {
+                        this.autoTicks = true;
+                      }
+                      boundsChanged = true;
+                      ticksUpdate = true;
+                      this._firstInit = false;
+                    }
+                    if (boundsChanged && this.autoTicks) {
+                      nextTicks = Ticks.create(this.bounds, this.tickSpacing);
+                      ticksUpdate = true;
+                    }
+                    if (ticksUpdate) {
+                      for (var i2 = 0; i2 < 3; ++i2) {
+                        nextTicks[i2].sort(function(a2, b2) {
+                          return a2.x - b2.x;
+                        });
+                      }
+                      if (Ticks.equal(nextTicks, this.ticks)) {
+                        ticksUpdate = false;
+                      } else {
+                        this.ticks = nextTicks;
+                      }
+                    }
+                    BOOLEAN("tickEnable");
+                    if (STRING("tickFont")) ticksUpdate = true;
+                    if (STRING("tickFontStyle")) ticksUpdate = true;
+                    if (STRING("tickFontWeight")) ticksUpdate = true;
+                    if (STRING("tickFontVariant")) ticksUpdate = true;
+                    NUMBER("tickSize");
+                    NUMBER("tickAngle");
+                    NUMBER("tickPad");
+                    COLOR2("tickColor");
+                    var labelUpdate = STRING("labels");
+                    if (STRING("labelFont")) labelUpdate = true;
+                    if (STRING("labelFontStyle")) labelUpdate = true;
+                    if (STRING("labelFontWeight")) labelUpdate = true;
+                    if (STRING("labelFontVariant")) labelUpdate = true;
+                    BOOLEAN("labelEnable");
+                    NUMBER("labelSize");
+                    NUMBER("labelPad");
+                    COLOR2("labelColor");
+                    BOOLEAN("lineEnable");
+                    BOOLEAN("lineMirror");
+                    NUMBER("lineWidth");
+                    COLOR2("lineColor");
+                    BOOLEAN("lineTickEnable");
+                    BOOLEAN("lineTickMirror");
+                    NUMBER("lineTickLength");
+                    NUMBER("lineTickWidth");
+                    COLOR2("lineTickColor");
+                    BOOLEAN("gridEnable");
+                    NUMBER("gridWidth");
+                    COLOR2("gridColor");
+                    BOOLEAN("zeroEnable");
+                    COLOR2("zeroLineColor");
+                    NUMBER("zeroLineWidth");
+                    BOOLEAN("backgroundEnable");
+                    COLOR2("backgroundColor");
+                    var labelFontOpts = [
+                      {
+                        family: this.labelFont[0],
+                        style: this.labelFontStyle[0],
+                        weight: this.labelFontWeight[0],
+                        variant: this.labelFontVariant[0]
+                      },
+                      {
+                        family: this.labelFont[1],
+                        style: this.labelFontStyle[1],
+                        weight: this.labelFontWeight[1],
+                        variant: this.labelFontVariant[1]
+                      },
+                      {
+                        family: this.labelFont[2],
+                        style: this.labelFontStyle[2],
+                        weight: this.labelFontWeight[2],
+                        variant: this.labelFontVariant[2]
+                      }
+                    ];
+                    var tickFontOpts = [
+                      {
+                        family: this.tickFont[0],
+                        style: this.tickFontStyle[0],
+                        weight: this.tickFontWeight[0],
+                        variant: this.tickFontVariant[0]
+                      },
+                      {
+                        family: this.tickFont[1],
+                        style: this.tickFontStyle[1],
+                        weight: this.tickFontWeight[1],
+                        variant: this.tickFontVariant[1]
+                      },
+                      {
+                        family: this.tickFont[2],
+                        style: this.tickFontStyle[2],
+                        weight: this.tickFontWeight[2],
+                        variant: this.tickFontVariant[2]
+                      }
+                    ];
+                    if (!this._text) {
+                      this._text = createText(
+                        this.gl,
+                        this.bounds,
+                        this.labels,
+                        labelFontOpts,
+                        this.ticks,
+                        tickFontOpts
+                      );
+                    } else if (this._text && (labelUpdate || ticksUpdate)) {
+                      this._text.update(
+                        this.bounds,
+                        this.labels,
+                        labelFontOpts,
+                        this.ticks,
+                        tickFontOpts
+                      );
+                    }
+                    if (this._lines && ticksUpdate) {
+                      this._lines.dispose();
+                      this._lines = null;
+                    }
+                    if (!this._lines) {
+                      this._lines = createLines(this.gl, this.bounds, this.ticks);
+                    }
+                  };
+                  function OffsetInfo() {
+                    this.primalOffset = [0, 0, 0];
+                    this.primalMinor = [0, 0, 0];
+                    this.mirrorOffset = [0, 0, 0];
+                    this.mirrorMinor = [0, 0, 0];
+                  }
+                  var LINE_OFFSET = [new OffsetInfo(), new OffsetInfo(), new OffsetInfo()];
+                  function computeLineOffset(result, i2, bounds, cubeEdges, cubeAxis) {
+                    var primalOffset = result.primalOffset;
+                    var primalMinor = result.primalMinor;
+                    var dualOffset = result.mirrorOffset;
+                    var dualMinor = result.mirrorMinor;
+                    var e2 = cubeEdges[i2];
+                    for (var j2 = 0; j2 < 3; ++j2) {
+                      if (i2 === j2) {
+                        continue;
+                      }
+                      var a2 = primalOffset, b2 = dualOffset, c2 = primalMinor, d2 = dualMinor;
+                      if (e2 & 1 << j2) {
+                        a2 = dualOffset;
+                        b2 = primalOffset;
+                        c2 = dualMinor;
+                        d2 = primalMinor;
+                      }
+                      a2[j2] = bounds[0][j2];
+                      b2[j2] = bounds[1][j2];
+                      if (cubeAxis[j2] > 0) {
+                        c2[j2] = -1;
+                        d2[j2] = 0;
+                      } else {
+                        c2[j2] = 0;
+                        d2[j2] = 1;
+                      }
+                    }
+                  }
+                  var CUBE_ENABLE = [0, 0, 0];
+                  var DEFAULT_PARAMS = {
+                    model: identity22,
+                    view: identity22,
+                    projection: identity22,
+                    _ortho: false
+                  };
+                  proto.isOpaque = function() {
+                    return true;
+                  };
+                  proto.isTransparent = function() {
+                    return false;
+                  };
+                  proto.drawTransparent = function(params) {
+                  };
+                  var ALIGN_OPTION_AUTO = 0;
+                  var PRIMAL_MINOR = [0, 0, 0];
+                  var MIRROR_MINOR = [0, 0, 0];
+                  var PRIMAL_OFFSET = [0, 0, 0];
+                  proto.draw = function(params) {
+                    params = params || DEFAULT_PARAMS;
+                    var gl2 = this.gl;
+                    var model = params.model || identity22;
+                    var view = params.view || identity22;
+                    var projection = params.projection || identity22;
+                    var bounds = this.bounds;
+                    var isOrtho = params._ortho || false;
+                    var cubeParams = getCubeProperties(model, view, projection, bounds, isOrtho);
+                    var cubeEdges = cubeParams.cubeEdges;
+                    var cubeAxis = cubeParams.axis;
+                    var cx = view[12];
+                    var cy = view[13];
+                    var cz = view[14];
+                    var cw = view[15];
+                    var orthoFix = isOrtho ? 2 : 1;
+                    var pixelScaleF = orthoFix * this.pixelRatio * (projection[3] * cx + projection[7] * cy + projection[11] * cz + projection[15] * cw) / gl2.drawingBufferHeight;
+                    for (var i2 = 0; i2 < 3; ++i2) {
+                      this.lastCubeProps.cubeEdges[i2] = cubeEdges[i2];
+                      this.lastCubeProps.axis[i2] = cubeAxis[i2];
+                    }
+                    var lineOffset = LINE_OFFSET;
+                    for (var i2 = 0; i2 < 3; ++i2) {
+                      computeLineOffset(
+                        LINE_OFFSET[i2],
+                        i2,
+                        this.bounds,
+                        cubeEdges,
+                        cubeAxis
+                      );
+                    }
+                    var gl2 = this.gl;
+                    var cubeEnable = CUBE_ENABLE;
+                    for (var i2 = 0; i2 < 3; ++i2) {
+                      if (this.backgroundEnable[i2]) {
+                        cubeEnable[i2] = cubeAxis[i2];
+                      } else {
+                        cubeEnable[i2] = 0;
+                      }
+                    }
+                    this._background.draw(
+                      model,
+                      view,
+                      projection,
+                      bounds,
+                      cubeEnable,
+                      this.backgroundColor
+                    );
+                    this._lines.bind(
+                      model,
+                      view,
+                      projection,
+                      this
+                    );
+                    for (var i2 = 0; i2 < 3; ++i2) {
+                      var x2 = [0, 0, 0];
+                      if (cubeAxis[i2] > 0) {
+                        x2[i2] = bounds[1][i2];
+                      } else {
+                        x2[i2] = bounds[0][i2];
+                      }
+                      for (var j2 = 0; j2 < 2; ++j2) {
+                        var u2 = (i2 + 1 + j2) % 3;
+                        var v2 = (i2 + 1 + (j2 ^ 1)) % 3;
+                        if (this.gridEnable[u2]) {
+                          this._lines.drawGrid(u2, v2, this.bounds, x2, this.gridColor[u2], this.gridWidth[u2] * this.pixelRatio);
+                        }
+                      }
+                      for (var j2 = 0; j2 < 2; ++j2) {
+                        var u2 = (i2 + 1 + j2) % 3;
+                        var v2 = (i2 + 1 + (j2 ^ 1)) % 3;
+                        if (this.zeroEnable[v2]) {
+                          if (Math.min(bounds[0][v2], bounds[1][v2]) <= 0 && Math.max(bounds[0][v2], bounds[1][v2]) >= 0) {
+                            this._lines.drawZero(u2, v2, this.bounds, x2, this.zeroLineColor[v2], this.zeroLineWidth[v2] * this.pixelRatio);
+                          }
+                        }
+                      }
+                    }
+                    for (var i2 = 0; i2 < 3; ++i2) {
+                      if (this.lineEnable[i2]) {
+                        this._lines.drawAxisLine(i2, this.bounds, lineOffset[i2].primalOffset, this.lineColor[i2], this.lineWidth[i2] * this.pixelRatio);
+                      }
+                      if (this.lineMirror[i2]) {
+                        this._lines.drawAxisLine(i2, this.bounds, lineOffset[i2].mirrorOffset, this.lineColor[i2], this.lineWidth[i2] * this.pixelRatio);
+                      }
+                      var primalMinor = copyVec3(PRIMAL_MINOR, lineOffset[i2].primalMinor);
+                      var mirrorMinor = copyVec3(MIRROR_MINOR, lineOffset[i2].mirrorMinor);
+                      var tickLength = this.lineTickLength;
+                      for (var j2 = 0; j2 < 3; ++j2) {
+                        var scaleFactor = pixelScaleF / model[5 * j2];
+                        primalMinor[j2] *= tickLength[j2] * scaleFactor;
+                        mirrorMinor[j2] *= tickLength[j2] * scaleFactor;
+                      }
+                      if (this.lineTickEnable[i2]) {
+                        this._lines.drawAxisTicks(i2, lineOffset[i2].primalOffset, primalMinor, this.lineTickColor[i2], this.lineTickWidth[i2] * this.pixelRatio);
+                      }
+                      if (this.lineTickMirror[i2]) {
+                        this._lines.drawAxisTicks(i2, lineOffset[i2].mirrorOffset, mirrorMinor, this.lineTickColor[i2], this.lineTickWidth[i2] * this.pixelRatio);
+                      }
+                    }
+                    this._lines.unbind();
+                    this._text.bind(
+                      model,
+                      view,
+                      projection,
+                      this.pixelRatio
+                    );
+                    var alignOpt;
+                    var hv_ratio = 0.5;
+                    var enableAlign;
+                    var alignDir;
+                    function alignTo2(i22) {
+                      alignDir = [0, 0, 0];
+                      alignDir[i22] = 1;
+                    }
+                    function solveTickAlignments(i22, minor2, major2) {
+                      var i1 = (i22 + 1) % 3;
+                      var i222 = (i22 + 2) % 3;
+                      var A22 = minor2[i1];
+                      var B22 = minor2[i222];
+                      var C22 = major2[i1];
+                      var D22 = major2[i222];
+                      if (A22 > 0 && D22 > 0) {
+                        alignTo2(i1);
+                        return;
+                      } else if (A22 > 0 && D22 < 0) {
+                        alignTo2(i1);
+                        return;
+                      } else if (A22 < 0 && D22 > 0) {
+                        alignTo2(i1);
+                        return;
+                      } else if (A22 < 0 && D22 < 0) {
+                        alignTo2(i1);
+                        return;
+                      } else if (B22 > 0 && C22 > 0) {
+                        alignTo2(i222);
+                        return;
+                      } else if (B22 > 0 && C22 < 0) {
+                        alignTo2(i222);
+                        return;
+                      } else if (B22 < 0 && C22 > 0) {
+                        alignTo2(i222);
+                        return;
+                      } else if (B22 < 0 && C22 < 0) {
+                        alignTo2(i222);
+                        return;
+                      }
+                    }
+                    for (var i2 = 0; i2 < 3; ++i2) {
+                      var minor = lineOffset[i2].primalMinor;
+                      var major = lineOffset[i2].mirrorMinor;
+                      var offset = copyVec3(PRIMAL_OFFSET, lineOffset[i2].primalOffset);
+                      for (var j2 = 0; j2 < 3; ++j2) {
+                        if (this.lineTickEnable[i2]) {
+                          offset[j2] += pixelScaleF * minor[j2] * Math.max(this.lineTickLength[j2], 0) / model[5 * j2];
+                        }
+                      }
+                      var axis = [0, 0, 0];
+                      axis[i2] = 1;
+                      if (this.tickEnable[i2]) {
+                        if (this.tickAngle[i2] === -3600) {
+                          this.tickAngle[i2] = 0;
+                          this.tickAlign[i2] = "auto";
+                        } else {
+                          this.tickAlign[i2] = -1;
+                        }
+                        enableAlign = 1;
+                        alignOpt = [this.tickAlign[i2], hv_ratio, enableAlign];
+                        if (alignOpt[0] === "auto") alignOpt[0] = ALIGN_OPTION_AUTO;
+                        else alignOpt[0] = parseInt("" + alignOpt[0]);
+                        alignDir = [0, 0, 0];
+                        solveTickAlignments(i2, minor, major);
+                        for (var j2 = 0; j2 < 3; ++j2) {
+                          offset[j2] += pixelScaleF * minor[j2] * this.tickPad[j2] / model[5 * j2];
+                        }
+                        this._text.drawTicks(
+                          i2,
+                          this.tickSize[i2],
+                          this.tickAngle[i2],
+                          offset,
+                          this.tickColor[i2],
+                          axis,
+                          alignDir,
+                          alignOpt
+                        );
+                      }
+                      if (this.labelEnable[i2]) {
+                        enableAlign = 0;
+                        alignDir = [0, 0, 0];
+                        if (this.labels[i2].length > 4) {
+                          alignTo2(i2);
+                          enableAlign = 1;
+                        }
+                        alignOpt = [this.labelAlign[i2], hv_ratio, enableAlign];
+                        if (alignOpt[0] === "auto") alignOpt[0] = ALIGN_OPTION_AUTO;
+                        else alignOpt[0] = parseInt("" + alignOpt[0]);
+                        for (var j2 = 0; j2 < 3; ++j2) {
+                          offset[j2] += pixelScaleF * minor[j2] * this.labelPad[j2] / model[5 * j2];
+                        }
+                        offset[i2] += 0.5 * (bounds[0][i2] + bounds[1][i2]);
+                        this._text.drawLabel(
+                          i2,
+                          this.labelSize[i2],
+                          this.labelAngle[i2],
+                          offset,
+                          this.labelColor[i2],
+                          [0, 0, 0],
+                          alignDir,
+                          alignOpt
+                        );
+                      }
+                    }
+                    this._text.unbind();
+                  };
+                  proto.dispose = function() {
+                    this._text.dispose();
+                    this._lines.dispose();
+                    this._background.dispose();
+                    this._lines = null;
+                    this._text = null;
+                    this._background = null;
+                    this.gl = null;
+                  };
+                  function createAxes(gl2, options) {
+                    var axes = new Axes(gl2);
+                    axes.update(options);
+                    return axes;
+                  }
+                }
+              ),
+              /***/
+              3840: (
+                /***/
+                function(module22) {
+                  module22.exports = createRBTree;
+                  var RED = 0;
+                  var BLACK = 1;
+                  function RBNode(color22, key, value, left, right, count2) {
+                    this._color = color22;
+                    this.key = key;
+                    this.value = value;
+                    this.left = left;
+                    this.right = right;
+                    this._count = count2;
+                  }
+                  function cloneNode(node) {
+                    return new RBNode(node._color, node.key, node.value, node.left, node.right, node._count);
+                  }
+                  function repaint(color22, node) {
+                    return new RBNode(color22, node.key, node.value, node.left, node.right, node._count);
+                  }
+                  function recount(node) {
+                    node._count = 1 + (node.left ? node.left._count : 0) + (node.right ? node.right._count : 0);
+                  }
+                  function RedBlackTree(compare, root) {
+                    this._compare = compare;
+                    this.root = root;
+                  }
+                  var proto = RedBlackTree.prototype;
+                  Object.defineProperty(proto, "keys", {
+                    get: function() {
+                      var result = [];
+                      this.forEach(function(k2, v2) {
+                        result.push(k2);
+                      });
+                      return result;
+                    }
+                  });
+                  Object.defineProperty(proto, "values", {
+                    get: function() {
+                      var result = [];
+                      this.forEach(function(k2, v2) {
+                        result.push(v2);
+                      });
+                      return result;
+                    }
+                  });
+                  Object.defineProperty(proto, "length", {
+                    get: function() {
+                      if (this.root) {
+                        return this.root._count;
+                      }
+                      return 0;
+                    }
+                  });
+                  proto.insert = function(key, value) {
+                    var cmp = this._compare;
+                    var n2 = this.root;
+                    var n_stack = [];
+                    var d_stack = [];
+                    while (n2) {
+                      var d2 = cmp(key, n2.key);
+                      n_stack.push(n2);
+                      d_stack.push(d2);
+                      if (d2 <= 0) {
+                        n2 = n2.left;
+                      } else {
+                        n2 = n2.right;
+                      }
+                    }
+                    n_stack.push(new RBNode(RED, key, value, null, null, 1));
+                    for (var s2 = n_stack.length - 2; s2 >= 0; --s2) {
+                      var n2 = n_stack[s2];
+                      if (d_stack[s2] <= 0) {
+                        n_stack[s2] = new RBNode(n2._color, n2.key, n2.value, n_stack[s2 + 1], n2.right, n2._count + 1);
+                      } else {
+                        n_stack[s2] = new RBNode(n2._color, n2.key, n2.value, n2.left, n_stack[s2 + 1], n2._count + 1);
+                      }
+                    }
+                    for (var s2 = n_stack.length - 1; s2 > 1; --s2) {
+                      var p2 = n_stack[s2 - 1];
+                      var n2 = n_stack[s2];
+                      if (p2._color === BLACK || n2._color === BLACK) {
+                        break;
+                      }
+                      var pp = n_stack[s2 - 2];
+                      if (pp.left === p2) {
+                        if (p2.left === n2) {
+                          var y2 = pp.right;
+                          if (y2 && y2._color === RED) {
+                            p2._color = BLACK;
+                            pp.right = repaint(BLACK, y2);
+                            pp._color = RED;
+                            s2 -= 1;
+                          } else {
+                            pp._color = RED;
+                            pp.left = p2.right;
+                            p2._color = BLACK;
+                            p2.right = pp;
+                            n_stack[s2 - 2] = p2;
+                            n_stack[s2 - 1] = n2;
+                            recount(pp);
+                            recount(p2);
+                            if (s2 >= 3) {
+                              var ppp = n_stack[s2 - 3];
+                              if (ppp.left === pp) {
+                                ppp.left = p2;
+                              } else {
+                                ppp.right = p2;
+                              }
+                            }
+                            break;
+                          }
+                        } else {
+                          var y2 = pp.right;
+                          if (y2 && y2._color === RED) {
+                            p2._color = BLACK;
+                            pp.right = repaint(BLACK, y2);
+                            pp._color = RED;
+                            s2 -= 1;
+                          } else {
+                            p2.right = n2.left;
+                            pp._color = RED;
+                            pp.left = n2.right;
+                            n2._color = BLACK;
+                            n2.left = p2;
+                            n2.right = pp;
+                            n_stack[s2 - 2] = n2;
+                            n_stack[s2 - 1] = p2;
+                            recount(pp);
+                            recount(p2);
+                            recount(n2);
+                            if (s2 >= 3) {
+                              var ppp = n_stack[s2 - 3];
+                              if (ppp.left === pp) {
+                                ppp.left = n2;
+                              } else {
+                                ppp.right = n2;
+                              }
+                            }
+                            break;
+                          }
+                        }
+                      } else {
+                        if (p2.right === n2) {
+                          var y2 = pp.left;
+                          if (y2 && y2._color === RED) {
+                            p2._color = BLACK;
+                            pp.left = repaint(BLACK, y2);
+                            pp._color = RED;
+                            s2 -= 1;
+                          } else {
+                            pp._color = RED;
+                            pp.right = p2.left;
+                            p2._color = BLACK;
+                            p2.left = pp;
+                            n_stack[s2 - 2] = p2;
+                            n_stack[s2 - 1] = n2;
+                            recount(pp);
+                            recount(p2);
+                            if (s2 >= 3) {
+                              var ppp = n_stack[s2 - 3];
+                              if (ppp.right === pp) {
+                                ppp.right = p2;
+                              } else {
+                                ppp.left = p2;
+                              }
+                            }
+                            break;
+                          }
+                        } else {
+                          var y2 = pp.left;
+                          if (y2 && y2._color === RED) {
+                            p2._color = BLACK;
+                            pp.left = repaint(BLACK, y2);
+                            pp._color = RED;
+                            s2 -= 1;
+                          } else {
+                            p2.left = n2.right;
+                            pp._color = RED;
+                            pp.right = n2.left;
+                            n2._color = BLACK;
+                            n2.right = p2;
+                            n2.left = pp;
+                            n_stack[s2 - 2] = n2;
+                            n_stack[s2 - 1] = p2;
+                            recount(pp);
+                            recount(p2);
+                            recount(n2);
+                            if (s2 >= 3) {
+                              var ppp = n_stack[s2 - 3];
+                              if (ppp.right === pp) {
+                                ppp.right = n2;
+                              } else {
+                                ppp.left = n2;
+                              }
+                            }
+                            break;
+                          }
+                        }
+                      }
+                    }
+                    n_stack[0]._color = BLACK;
+                    return new RedBlackTree(cmp, n_stack[0]);
+                  };
+                  function doVisitFull(visit, node) {
+                    if (node.left) {
+                      var v2 = doVisitFull(visit, node.left);
+                      if (v2) {
+                        return v2;
+                      }
+                    }
+                    var v2 = visit(node.key, node.value);
+                    if (v2) {
+                      return v2;
+                    }
+                    if (node.right) {
+                      return doVisitFull(visit, node.right);
+                    }
+                  }
+                  function doVisitHalf(lo, compare, visit, node) {
+                    var l2 = compare(lo, node.key);
+                    if (l2 <= 0) {
+                      if (node.left) {
+                        var v2 = doVisitHalf(lo, compare, visit, node.left);
+                        if (v2) {
+                          return v2;
+                        }
+                      }
+                      var v2 = visit(node.key, node.value);
+                      if (v2) {
+                        return v2;
+                      }
+                    }
+                    if (node.right) {
+                      return doVisitHalf(lo, compare, visit, node.right);
+                    }
+                  }
+                  function doVisit(lo, hi2, compare, visit, node) {
+                    var l2 = compare(lo, node.key);
+                    var h2 = compare(hi2, node.key);
+                    var v2;
+                    if (l2 <= 0) {
+                      if (node.left) {
+                        v2 = doVisit(lo, hi2, compare, visit, node.left);
+                        if (v2) {
+                          return v2;
+                        }
+                      }
+                      if (h2 > 0) {
+                        v2 = visit(node.key, node.value);
+                        if (v2) {
+                          return v2;
+                        }
+                      }
+                    }
+                    if (h2 > 0 && node.right) {
+                      return doVisit(lo, hi2, compare, visit, node.right);
+                    }
+                  }
+                  proto.forEach = function rbTreeForEach(visit, lo, hi2) {
+                    if (!this.root) {
+                      return;
+                    }
+                    switch (arguments.length) {
+                      case 1:
+                        return doVisitFull(visit, this.root);
+                      case 2:
+                        return doVisitHalf(lo, this._compare, visit, this.root);
+                      case 3:
+                        if (this._compare(lo, hi2) >= 0) {
+                          return;
+                        }
+                        return doVisit(lo, hi2, this._compare, visit, this.root);
+                    }
+                  };
+                  Object.defineProperty(proto, "begin", {
+                    get: function() {
+                      var stack = [];
+                      var n2 = this.root;
+                      while (n2) {
+                        stack.push(n2);
+                        n2 = n2.left;
+                      }
+                      return new RedBlackTreeIterator(this, stack);
+                    }
+                  });
+                  Object.defineProperty(proto, "end", {
+                    get: function() {
+                      var stack = [];
+                      var n2 = this.root;
+                      while (n2) {
+                        stack.push(n2);
+                        n2 = n2.right;
+                      }
+                      return new RedBlackTreeIterator(this, stack);
+                    }
+                  });
+                  proto.at = function(idx) {
+                    if (idx < 0) {
+                      return new RedBlackTreeIterator(this, []);
+                    }
+                    var n2 = this.root;
+                    var stack = [];
+                    while (true) {
+                      stack.push(n2);
+                      if (n2.left) {
+                        if (idx < n2.left._count) {
+                          n2 = n2.left;
+                          continue;
+                        }
+                        idx -= n2.left._count;
+                      }
+                      if (!idx) {
+                        return new RedBlackTreeIterator(this, stack);
+                      }
+                      idx -= 1;
+                      if (n2.right) {
+                        if (idx >= n2.right._count) {
+                          break;
+                        }
+                        n2 = n2.right;
+                      } else {
+                        break;
+                      }
+                    }
+                    return new RedBlackTreeIterator(this, []);
+                  };
+                  proto.ge = function(key) {
+                    var cmp = this._compare;
+                    var n2 = this.root;
+                    var stack = [];
+                    var last_ptr = 0;
+                    while (n2) {
+                      var d2 = cmp(key, n2.key);
+                      stack.push(n2);
+                      if (d2 <= 0) {
+                        last_ptr = stack.length;
+                      }
+                      if (d2 <= 0) {
+                        n2 = n2.left;
+                      } else {
+                        n2 = n2.right;
+                      }
+                    }
+                    stack.length = last_ptr;
+                    return new RedBlackTreeIterator(this, stack);
+                  };
+                  proto.gt = function(key) {
+                    var cmp = this._compare;
+                    var n2 = this.root;
+                    var stack = [];
+                    var last_ptr = 0;
+                    while (n2) {
+                      var d2 = cmp(key, n2.key);
+                      stack.push(n2);
+                      if (d2 < 0) {
+                        last_ptr = stack.length;
+                      }
+                      if (d2 < 0) {
+                        n2 = n2.left;
+                      } else {
+                        n2 = n2.right;
+                      }
+                    }
+                    stack.length = last_ptr;
+                    return new RedBlackTreeIterator(this, stack);
+                  };
+                  proto.lt = function(key) {
+                    var cmp = this._compare;
+                    var n2 = this.root;
+                    var stack = [];
+                    var last_ptr = 0;
+                    while (n2) {
+                      var d2 = cmp(key, n2.key);
+                      stack.push(n2);
+                      if (d2 > 0) {
+                        last_ptr = stack.length;
+                      }
+                      if (d2 <= 0) {
+                        n2 = n2.left;
+                      } else {
+                        n2 = n2.right;
+                      }
+                    }
+                    stack.length = last_ptr;
+                    return new RedBlackTreeIterator(this, stack);
+                  };
+                  proto.le = function(key) {
+                    var cmp = this._compare;
+                    var n2 = this.root;
+                    var stack = [];
+                    var last_ptr = 0;
+                    while (n2) {
+                      var d2 = cmp(key, n2.key);
+                      stack.push(n2);
+                      if (d2 >= 0) {
+                        last_ptr = stack.length;
+                      }
+                      if (d2 < 0) {
+                        n2 = n2.left;
+                      } else {
+                        n2 = n2.right;
+                      }
+                    }
+                    stack.length = last_ptr;
+                    return new RedBlackTreeIterator(this, stack);
+                  };
+                  proto.find = function(key) {
+                    var cmp = this._compare;
+                    var n2 = this.root;
+                    var stack = [];
+                    while (n2) {
+                      var d2 = cmp(key, n2.key);
+                      stack.push(n2);
+                      if (d2 === 0) {
+                        return new RedBlackTreeIterator(this, stack);
+                      }
+                      if (d2 <= 0) {
+                        n2 = n2.left;
+                      } else {
+                        n2 = n2.right;
+                      }
+                    }
+                    return new RedBlackTreeIterator(this, []);
+                  };
+                  proto.remove = function(key) {
+                    var iter = this.find(key);
+                    if (iter) {
+                      return iter.remove();
+                    }
+                    return this;
+                  };
+                  proto.get = function(key) {
+                    var cmp = this._compare;
+                    var n2 = this.root;
+                    while (n2) {
+                      var d2 = cmp(key, n2.key);
+                      if (d2 === 0) {
+                        return n2.value;
+                      }
+                      if (d2 <= 0) {
+                        n2 = n2.left;
+                      } else {
+                        n2 = n2.right;
+                      }
+                    }
+                    return;
+                  };
+                  function RedBlackTreeIterator(tree, stack) {
+                    this.tree = tree;
+                    this._stack = stack;
+                  }
+                  var iproto = RedBlackTreeIterator.prototype;
+                  Object.defineProperty(iproto, "valid", {
+                    get: function() {
+                      return this._stack.length > 0;
+                    }
+                  });
+                  Object.defineProperty(iproto, "node", {
+                    get: function() {
+                      if (this._stack.length > 0) {
+                        return this._stack[this._stack.length - 1];
+                      }
+                      return null;
+                    },
+                    enumerable: true
+                  });
+                  iproto.clone = function() {
+                    return new RedBlackTreeIterator(this.tree, this._stack.slice());
+                  };
+                  function swapNode(n2, v2) {
+                    n2.key = v2.key;
+                    n2.value = v2.value;
+                    n2.left = v2.left;
+                    n2.right = v2.right;
+                    n2._color = v2._color;
+                    n2._count = v2._count;
+                  }
+                  function fixDoubleBlack(stack) {
+                    var n2, p2, s2, z2;
+                    for (var i2 = stack.length - 1; i2 >= 0; --i2) {
+                      n2 = stack[i2];
+                      if (i2 === 0) {
+                        n2._color = BLACK;
+                        return;
+                      }
+                      p2 = stack[i2 - 1];
+                      if (p2.left === n2) {
+                        s2 = p2.right;
+                        if (s2.right && s2.right._color === RED) {
+                          s2 = p2.right = cloneNode(s2);
+                          z2 = s2.right = cloneNode(s2.right);
+                          p2.right = s2.left;
+                          s2.left = p2;
+                          s2.right = z2;
+                          s2._color = p2._color;
+                          n2._color = BLACK;
+                          p2._color = BLACK;
+                          z2._color = BLACK;
+                          recount(p2);
+                          recount(s2);
+                          if (i2 > 1) {
+                            var pp = stack[i2 - 2];
+                            if (pp.left === p2) {
+                              pp.left = s2;
+                            } else {
+                              pp.right = s2;
+                            }
+                          }
+                          stack[i2 - 1] = s2;
+                          return;
+                        } else if (s2.left && s2.left._color === RED) {
+                          s2 = p2.right = cloneNode(s2);
+                          z2 = s2.left = cloneNode(s2.left);
+                          p2.right = z2.left;
+                          s2.left = z2.right;
+                          z2.left = p2;
+                          z2.right = s2;
+                          z2._color = p2._color;
+                          p2._color = BLACK;
+                          s2._color = BLACK;
+                          n2._color = BLACK;
+                          recount(p2);
+                          recount(s2);
+                          recount(z2);
+                          if (i2 > 1) {
+                            var pp = stack[i2 - 2];
+                            if (pp.left === p2) {
+                              pp.left = z2;
+                            } else {
+                              pp.right = z2;
+                            }
+                          }
+                          stack[i2 - 1] = z2;
+                          return;
+                        }
+                        if (s2._color === BLACK) {
+                          if (p2._color === RED) {
+                            p2._color = BLACK;
+                            p2.right = repaint(RED, s2);
+                            return;
+                          } else {
+                            p2.right = repaint(RED, s2);
+                            continue;
+                          }
+                        } else {
+                          s2 = cloneNode(s2);
+                          p2.right = s2.left;
+                          s2.left = p2;
+                          s2._color = p2._color;
+                          p2._color = RED;
+                          recount(p2);
+                          recount(s2);
+                          if (i2 > 1) {
+                            var pp = stack[i2 - 2];
+                            if (pp.left === p2) {
+                              pp.left = s2;
+                            } else {
+                              pp.right = s2;
+                            }
+                          }
+                          stack[i2 - 1] = s2;
+                          stack[i2] = p2;
+                          if (i2 + 1 < stack.length) {
+                            stack[i2 + 1] = n2;
+                          } else {
+                            stack.push(n2);
+                          }
+                          i2 = i2 + 2;
+                        }
+                      } else {
+                        s2 = p2.left;
+                        if (s2.left && s2.left._color === RED) {
+                          s2 = p2.left = cloneNode(s2);
+                          z2 = s2.left = cloneNode(s2.left);
+                          p2.left = s2.right;
+                          s2.right = p2;
+                          s2.left = z2;
+                          s2._color = p2._color;
+                          n2._color = BLACK;
+                          p2._color = BLACK;
+                          z2._color = BLACK;
+                          recount(p2);
+                          recount(s2);
+                          if (i2 > 1) {
+                            var pp = stack[i2 - 2];
+                            if (pp.right === p2) {
+                              pp.right = s2;
+                            } else {
+                              pp.left = s2;
+                            }
+                          }
+                          stack[i2 - 1] = s2;
+                          return;
+                        } else if (s2.right && s2.right._color === RED) {
+                          s2 = p2.left = cloneNode(s2);
+                          z2 = s2.right = cloneNode(s2.right);
+                          p2.left = z2.right;
+                          s2.right = z2.left;
+                          z2.right = p2;
+                          z2.left = s2;
+                          z2._color = p2._color;
+                          p2._color = BLACK;
+                          s2._color = BLACK;
+                          n2._color = BLACK;
+                          recount(p2);
+                          recount(s2);
+                          recount(z2);
+                          if (i2 > 1) {
+                            var pp = stack[i2 - 2];
+                            if (pp.right === p2) {
+                              pp.right = z2;
+                            } else {
+                              pp.left = z2;
+                            }
+                          }
+                          stack[i2 - 1] = z2;
+                          return;
+                        }
+                        if (s2._color === BLACK) {
+                          if (p2._color === RED) {
+                            p2._color = BLACK;
+                            p2.left = repaint(RED, s2);
+                            return;
+                          } else {
+                            p2.left = repaint(RED, s2);
+                            continue;
+                          }
+                        } else {
+                          s2 = cloneNode(s2);
+                          p2.left = s2.right;
+                          s2.right = p2;
+                          s2._color = p2._color;
+                          p2._color = RED;
+                          recount(p2);
+                          recount(s2);
+                          if (i2 > 1) {
+                            var pp = stack[i2 - 2];
+                            if (pp.right === p2) {
+                              pp.right = s2;
+                            } else {
+                              pp.left = s2;
+                            }
+                          }
+                          stack[i2 - 1] = s2;
+                          stack[i2] = p2;
+                          if (i2 + 1 < stack.length) {
+                            stack[i2 + 1] = n2;
+                          } else {
+                            stack.push(n2);
+                          }
+                          i2 = i2 + 2;
+                        }
+                      }
+                    }
+                  }
+                  iproto.remove = function() {
+                    var stack = this._stack;
+                    if (stack.length === 0) {
+                      return this.tree;
+                    }
+                    var cstack = new Array(stack.length);
+                    var n2 = stack[stack.length - 1];
+                    cstack[cstack.length - 1] = new RBNode(n2._color, n2.key, n2.value, n2.left, n2.right, n2._count);
+                    for (var i2 = stack.length - 2; i2 >= 0; --i2) {
+                      var n2 = stack[i2];
+                      if (n2.left === stack[i2 + 1]) {
+                        cstack[i2] = new RBNode(n2._color, n2.key, n2.value, cstack[i2 + 1], n2.right, n2._count);
+                      } else {
+                        cstack[i2] = new RBNode(n2._color, n2.key, n2.value, n2.left, cstack[i2 + 1], n2._count);
+                      }
+                    }
+                    n2 = cstack[cstack.length - 1];
+                    if (n2.left && n2.right) {
+                      var split = cstack.length;
+                      n2 = n2.left;
+                      while (n2.right) {
+                        cstack.push(n2);
+                        n2 = n2.right;
+                      }
+                      var v2 = cstack[split - 1];
+                      cstack.push(new RBNode(n2._color, v2.key, v2.value, n2.left, n2.right, n2._count));
+                      cstack[split - 1].key = n2.key;
+                      cstack[split - 1].value = n2.value;
+                      for (var i2 = cstack.length - 2; i2 >= split; --i2) {
+                        n2 = cstack[i2];
+                        cstack[i2] = new RBNode(n2._color, n2.key, n2.value, n2.left, cstack[i2 + 1], n2._count);
+                      }
+                      cstack[split - 1].left = cstack[split];
+                    }
+                    n2 = cstack[cstack.length - 1];
+                    if (n2._color === RED) {
+                      var p2 = cstack[cstack.length - 2];
+                      if (p2.left === n2) {
+                        p2.left = null;
+                      } else if (p2.right === n2) {
+                        p2.right = null;
+                      }
+                      cstack.pop();
+                      for (var i2 = 0; i2 < cstack.length; ++i2) {
+                        cstack[i2]._count--;
+                      }
+                      return new RedBlackTree(this.tree._compare, cstack[0]);
+                    } else {
+                      if (n2.left || n2.right) {
+                        if (n2.left) {
+                          swapNode(n2, n2.left);
+                        } else if (n2.right) {
+                          swapNode(n2, n2.right);
+                        }
+                        n2._color = BLACK;
+                        for (var i2 = 0; i2 < cstack.length - 1; ++i2) {
+                          cstack[i2]._count--;
+                        }
+                        return new RedBlackTree(this.tree._compare, cstack[0]);
+                      } else if (cstack.length === 1) {
+                        return new RedBlackTree(this.tree._compare, null);
+                      } else {
+                        for (var i2 = 0; i2 < cstack.length; ++i2) {
+                          cstack[i2]._count--;
+                        }
+                        var parent = cstack[cstack.length - 2];
+                        fixDoubleBlack(cstack);
+                        if (parent.left === n2) {
+                          parent.left = null;
+                        } else {
+                          parent.right = null;
+                        }
+                      }
+                    }
+                    return new RedBlackTree(this.tree._compare, cstack[0]);
+                  };
+                  Object.defineProperty(iproto, "key", {
+                    get: function() {
+                      if (this._stack.length > 0) {
+                        return this._stack[this._stack.length - 1].key;
+                      }
+                      return;
+                    },
+                    enumerable: true
+                  });
+                  Object.defineProperty(iproto, "value", {
+                    get: function() {
+                      if (this._stack.length > 0) {
+                        return this._stack[this._stack.length - 1].value;
+                      }
+                      return;
+                    },
+                    enumerable: true
+                  });
+                  Object.defineProperty(iproto, "index", {
+                    get: function() {
+                      var idx = 0;
+                      var stack = this._stack;
+                      if (stack.length === 0) {
+                        var r2 = this.tree.root;
+                        if (r2) {
+                          return r2._count;
+                        }
+                        return 0;
+                      } else if (stack[stack.length - 1].left) {
+                        idx = stack[stack.length - 1].left._count;
+                      }
+                      for (var s2 = stack.length - 2; s2 >= 0; --s2) {
+                        if (stack[s2 + 1] === stack[s2].right) {
+                          ++idx;
+                          if (stack[s2].left) {
+                            idx += stack[s2].left._count;
+                          }
+                        }
+                      }
+                      return idx;
+                    },
+                    enumerable: true
+                  });
+                  iproto.next = function() {
+                    var stack = this._stack;
+                    if (stack.length === 0) {
+                      return;
+                    }
+                    var n2 = stack[stack.length - 1];
+                    if (n2.right) {
+                      n2 = n2.right;
+                      while (n2) {
+                        stack.push(n2);
+                        n2 = n2.left;
+                      }
+                    } else {
+                      stack.pop();
+                      while (stack.length > 0 && stack[stack.length - 1].right === n2) {
+                        n2 = stack[stack.length - 1];
+                        stack.pop();
+                      }
+                    }
+                  };
+                  Object.defineProperty(iproto, "hasNext", {
+                    get: function() {
+                      var stack = this._stack;
+                      if (stack.length === 0) {
+                        return false;
+                      }
+                      if (stack[stack.length - 1].right) {
+                        return true;
+                      }
+                      for (var s2 = stack.length - 1; s2 > 0; --s2) {
+                        if (stack[s2 - 1].left === stack[s2]) {
+                          return true;
+                        }
+                      }
+                      return false;
+                    }
+                  });
+                  iproto.update = function(value) {
+                    var stack = this._stack;
+                    if (stack.length === 0) {
+                      throw new Error("Can't update empty node!");
+                    }
+                    var cstack = new Array(stack.length);
+                    var n2 = stack[stack.length - 1];
+                    cstack[cstack.length - 1] = new RBNode(n2._color, n2.key, value, n2.left, n2.right, n2._count);
+                    for (var i2 = stack.length - 2; i2 >= 0; --i2) {
+                      n2 = stack[i2];
+                      if (n2.left === stack[i2 + 1]) {
+                        cstack[i2] = new RBNode(n2._color, n2.key, n2.value, cstack[i2 + 1], n2.right, n2._count);
+                      } else {
+                        cstack[i2] = new RBNode(n2._color, n2.key, n2.value, n2.left, cstack[i2 + 1], n2._count);
+                      }
+                    }
+                    return new RedBlackTree(this.tree._compare, cstack[0]);
+                  };
+                  iproto.prev = function() {
+                    var stack = this._stack;
+                    if (stack.length === 0) {
+                      return;
+                    }
+                    var n2 = stack[stack.length - 1];
+                    if (n2.left) {
+                      n2 = n2.left;
+                      while (n2) {
+                        stack.push(n2);
+                        n2 = n2.right;
+                      }
+                    } else {
+                      stack.pop();
+                      while (stack.length > 0 && stack[stack.length - 1].left === n2) {
+                        n2 = stack[stack.length - 1];
+                        stack.pop();
+                      }
+                    }
+                  };
+                  Object.defineProperty(iproto, "hasPrev", {
+                    get: function() {
+                      var stack = this._stack;
+                      if (stack.length === 0) {
+                        return false;
+                      }
+                      if (stack[stack.length - 1].left) {
+                        return true;
+                      }
+                      for (var s2 = stack.length - 1; s2 > 0; --s2) {
+                        if (stack[s2 - 1].right === stack[s2]) {
+                          return true;
+                        }
+                      }
+                      return false;
+                    }
+                  });
+                  function defaultCompare(a2, b2) {
+                    if (a2 < b2) {
+                      return -1;
+                    }
+                    if (a2 > b2) {
+                      return 1;
+                    }
+                    return 0;
+                  }
+                  function createRBTree(compare) {
+                    return new RedBlackTree(compare || defaultCompare, null);
+                  }
+                }
+              ),
+              /***/
+              3865: (
+                /***/
+                function(module22, __unused_webpack_exports, __webpack_require__2) {
+                  var rationalize = __webpack_require__2(869);
+                  module22.exports = add2;
+                  function add2(a2, b2) {
+                    return rationalize(
+                      a2[0].mul(b2[1]).add(b2[0].mul(a2[1])),
+                      a2[1].mul(b2[1])
+                    );
+                  }
+                }
+              ),
+              /***/
+              3952: (
+                /***/
+                function(module22, __unused_webpack_exports, __webpack_require__2) {
+                  module22.exports = affineHull;
+                  var orient = __webpack_require__2(3250);
+                  function linearlyIndependent(points, d2) {
+                    var nhull = new Array(d2 + 1);
+                    for (var i2 = 0; i2 < points.length; ++i2) {
+                      nhull[i2] = points[i2];
+                    }
+                    for (var i2 = 0; i2 <= points.length; ++i2) {
+                      for (var j2 = points.length; j2 <= d2; ++j2) {
+                        var x2 = new Array(d2);
+                        for (var k2 = 0; k2 < d2; ++k2) {
+                          x2[k2] = Math.pow(j2 + 1 - i2, k2);
+                        }
+                        nhull[j2] = x2;
+                      }
+                      var o2 = orient.apply(void 0, nhull);
+                      if (o2) {
+                        return true;
+                      }
+                    }
+                    return false;
+                  }
+                  function affineHull(points) {
+                    var n2 = points.length;
+                    if (n2 === 0) {
+                      return [];
+                    }
+                    if (n2 === 1) {
+                      return [0];
+                    }
+                    var d2 = points[0].length;
+                    var frame = [points[0]];
+                    var index = [0];
+                    for (var i2 = 1; i2 < n2; ++i2) {
+                      frame.push(points[i2]);
+                      if (!linearlyIndependent(frame, d2)) {
+                        frame.pop();
+                        continue;
+                      }
+                      index.push(i2);
+                      if (index.length === d2 + 1) {
+                        return index;
+                      }
+                    }
+                    return index;
+                  }
+                }
+              ),
+              /***/
+              3990: (
+                /***/
+                function(module22) {
+                  module22.exports = copy;
+                  function copy(out, a2) {
+                    out[0] = a2[0];
+                    out[1] = a2[1];
+                    out[2] = a2[2];
+                    return out;
+                  }
+                }
+              ),
+              /***/
+              4008: (
+                /***/
+                function(module22, __unused_webpack_exports, __webpack_require__2) {
+                  module22.exports = __webpack_require__2(6690);
+                }
+              ),
+              /***/
+              4025: (
+                /***/
+                function(module22, __unused_webpack_exports, __webpack_require__2) {
+                  var db2 = __webpack_require__2(2361);
+                  var ctz = __webpack_require__2(8828).countTrailingZeros;
+                  module22.exports = ctzNumber;
+                  function ctzNumber(x2) {
+                    var l2 = ctz(db2.lo(x2));
+                    if (l2 < 32) {
+                      return l2;
+                    }
+                    var h2 = ctz(db2.hi(x2));
+                    if (h2 > 20) {
+                      return 52;
+                    }
+                    return h2 + 32;
+                  }
+                }
+              ),
+              /***/
+              4040: (
+                /***/
+                function(module22) {
+                  module22.exports = ortho2;
+                  function ortho2(out, left, right, bottom, top, near, far) {
+                    var lr = 1 / (left - right), bt = 1 / (bottom - top), nf2 = 1 / (near - far);
+                    out[0] = -2 * lr;
+                    out[1] = 0;
+                    out[2] = 0;
+                    out[3] = 0;
+                    out[4] = 0;
+                    out[5] = -2 * bt;
+                    out[6] = 0;
+                    out[7] = 0;
+                    out[8] = 0;
+                    out[9] = 0;
+                    out[10] = 2 * nf2;
+                    out[11] = 0;
+                    out[12] = (left + right) * lr;
+                    out[13] = (top + bottom) * bt;
+                    out[14] = (far + near) * nf2;
+                    out[15] = 1;
+                    return out;
+                  }
+                }
+              ),
+              /***/
+              4041: (
+                /***/
+                function(module22) {
+                  module22.exports = transformQuat2;
+                  function transformQuat2(out, a2, q2) {
+                    var x2 = a2[0], y2 = a2[1], z2 = a2[2], qx = q2[0], qy = q2[1], qz = q2[2], qw = q2[3], ix = qw * x2 + qy * z2 - qz * y2, iy = qw * y2 + qz * x2 - qx * z2, iz = qw * z2 + qx * y2 - qy * x2, iw = -qx * x2 - qy * y2 - qz * z2;
+                    out[0] = ix * qw + iw * -qx + iy * -qz - iz * -qy;
+                    out[1] = iy * qw + iw * -qy + iz * -qx - ix * -qz;
+                    out[2] = iz * qw + iw * -qz + ix * -qy - iy * -qx;
+                    out[3] = a2[3];
+                    return out;
+                  }
+                }
+              ),
+              /***/
+              4081: (
+                /***/
+                function(module22) {
+                  module22.exports = quatFromFrame;
+                  function quatFromFrame(out, rx, ry, rz, ux, uy, uz, fx, fy, fz) {
+                    var tr = rx + uy + fz;
+                    if (l2 > 0) {
+                      var l2 = Math.sqrt(tr + 1);
+                      out[0] = 0.5 * (uz - fy) / l2;
+                      out[1] = 0.5 * (fx - rz) / l2;
+                      out[2] = 0.5 * (ry - uy) / l2;
+                      out[3] = 0.5 * l2;
+                    } else {
+                      var tf2 = Math.max(rx, uy, fz);
+                      var l2 = Math.sqrt(2 * tf2 - tr + 1);
+                      if (rx >= tf2) {
+                        out[0] = 0.5 * l2;
+                        out[1] = 0.5 * (ux + ry) / l2;
+                        out[2] = 0.5 * (fx + rz) / l2;
+                        out[3] = 0.5 * (uz - fy) / l2;
+                      } else if (uy >= tf2) {
+                        out[0] = 0.5 * (ry + ux) / l2;
+                        out[1] = 0.5 * l2;
+                        out[2] = 0.5 * (fy + uz) / l2;
+                        out[3] = 0.5 * (fx - rz) / l2;
+                      } else {
+                        out[0] = 0.5 * (rz + fx) / l2;
+                        out[1] = 0.5 * (uz + fy) / l2;
+                        out[2] = 0.5 * l2;
+                        out[3] = 0.5 * (ry - ux) / l2;
+                      }
+                    }
+                    return out;
+                  }
+                }
+              ),
+              /***/
+              4100: (
+                /***/
+                function(module22, __unused_webpack_exports, __webpack_require__2) {
+                  var createCamera = __webpack_require__2(4437);
+                  var createAxes = __webpack_require__2(3837);
+                  var axesRanges = __webpack_require__2(5445);
+                  var createSpikes = __webpack_require__2(4449);
+                  var createSelect = __webpack_require__2(3589);
+                  var createFBO = __webpack_require__2(2260);
+                  var drawTriangle = __webpack_require__2(7169);
+                  var mouseChange = __webpack_require__2(351);
+                  var perspective2 = __webpack_require__2(4772);
+                  var ortho2 = __webpack_require__2(4040);
+                  var createShader = __webpack_require__2(799);
+                  var isMobile2 = __webpack_require__2(9216)({ tablet: true, featureDetect: true });
+                  module22.exports = {
+                    createScene,
+                    createCamera
+                  };
+                  function MouseSelect() {
+                    this.mouse = [-1, -1];
+                    this.screen = null;
+                    this.distance = Infinity;
+                    this.index = null;
+                    this.dataCoordinate = null;
+                    this.dataPosition = null;
+                    this.object = null;
+                    this.data = null;
+                  }
+                  function getContext(canvas2, options) {
+                    var gl2 = null;
+                    try {
+                      gl2 = canvas2.getContext("webgl", options);
+                      if (!gl2) {
+                        gl2 = canvas2.getContext("experimental-webgl", options);
+                      }
+                    } catch (e2) {
+                      return null;
+                    }
+                    return gl2;
+                  }
+                  function roundUpPow10(x2) {
+                    var y2 = Math.round(Math.log(Math.abs(x2)) / Math.log(10));
+                    if (y2 < 0) {
+                      var base = Math.round(Math.pow(10, -y2));
+                      return Math.ceil(x2 * base) / base;
+                    } else if (y2 > 0) {
+                      var base = Math.round(Math.pow(10, y2));
+                      return Math.ceil(x2 / base) * base;
+                    }
+                    return Math.ceil(x2);
+                  }
+                  function defaultBool(x2) {
+                    if (typeof x2 === "boolean") {
+                      return x2;
+                    }
+                    return true;
+                  }
+                  function createScene(options) {
+                    options = options || {};
+                    options.camera = options.camera || {};
+                    var canvas2 = options.canvas;
+                    if (!canvas2) {
+                      canvas2 = document.createElement("canvas");
+                      if (options.container) {
+                        var container = options.container;
+                        container.appendChild(canvas2);
+                      } else {
+                        document.body.appendChild(canvas2);
+                      }
+                    }
+                    var gl2 = options.gl;
+                    if (!gl2) {
+                      if (options.glOptions) {
+                        isMobile2 = !!options.glOptions.preserveDrawingBuffer;
+                      }
+                      gl2 = getContext(
+                        canvas2,
+                        options.glOptions || {
+                          premultipliedAlpha: true,
+                          antialias: true,
+                          preserveDrawingBuffer: isMobile2
+                        }
+                      );
+                    }
+                    if (!gl2) {
+                      throw new Error("webgl not supported");
+                    }
+                    var bounds = options.bounds || [[-10, -10, -10], [10, 10, 10]];
+                    var selection = new MouseSelect();
+                    var accumBuffer = createFBO(
+                      gl2,
+                      gl2.drawingBufferWidth,
+                      gl2.drawingBufferHeight,
+                      {
+                        preferFloat: !isMobile2
+                      }
+                    );
+                    var accumShader = createShader(gl2);
+                    var isOrtho = options.cameraObject && options.cameraObject._ortho === true || options.camera.projection && options.camera.projection.type === "orthographic" || false;
+                    var cameraOptions = {
+                      eye: options.camera.eye || [2, 0, 0],
+                      center: options.camera.center || [0, 0, 0],
+                      up: options.camera.up || [0, 1, 0],
+                      zoomMin: options.camera.zoomMax || 0.1,
+                      zoomMax: options.camera.zoomMin || 100,
+                      mode: options.camera.mode || "turntable",
+                      _ortho: isOrtho
+                    };
+                    var axesOptions = options.axes || {};
+                    var axes = createAxes(gl2, axesOptions);
+                    axes.enable = !axesOptions.disable;
+                    var spikeOptions = options.spikes || {};
+                    var spikes = createSpikes(gl2, spikeOptions);
+                    var objects = [];
+                    var pickBufferIds = [];
+                    var pickBufferCount = [];
+                    var pickBuffers = [];
+                    var dirty = true;
+                    var pickDirty = true;
+                    var projection = new Array(16);
+                    var model = new Array(16);
+                    var cameraParams = {
+                      view: null,
+                      projection,
+                      model,
+                      _ortho: false
+                    };
+                    var pickDirty = true;
+                    var viewShape = [gl2.drawingBufferWidth, gl2.drawingBufferHeight];
+                    var camera = options.cameraObject || createCamera(canvas2, cameraOptions);
+                    var scene = {
+                      gl: gl2,
+                      contextLost: false,
+                      pixelRatio: options.pixelRatio || 1,
+                      canvas: canvas2,
+                      selection,
+                      camera,
+                      axes,
+                      axesPixels: null,
+                      spikes,
+                      bounds,
+                      objects,
+                      shape: viewShape,
+                      aspect: options.aspectRatio || [1, 1, 1],
+                      pickRadius: options.pickRadius || 10,
+                      zNear: options.zNear || 0.01,
+                      zFar: options.zFar || 1e3,
+                      fovy: options.fovy || Math.PI / 4,
+                      clearColor: options.clearColor || [0, 0, 0, 0],
+                      autoResize: defaultBool(options.autoResize),
+                      autoBounds: defaultBool(options.autoBounds),
+                      autoScale: !!options.autoScale,
+                      autoCenter: defaultBool(options.autoCenter),
+                      clipToBounds: defaultBool(options.clipToBounds),
+                      snapToData: !!options.snapToData,
+                      onselect: options.onselect || null,
+                      onrender: options.onrender || null,
+                      onclick: options.onclick || null,
+                      cameraParams,
+                      oncontextloss: null,
+                      mouseListener: null,
+                      _stopped: false,
+                      getAspectratio: function() {
+                        return {
+                          x: this.aspect[0],
+                          y: this.aspect[1],
+                          z: this.aspect[2]
+                        };
+                      },
+                      setAspectratio: function(aspectratio) {
+                        this.aspect[0] = aspectratio.x;
+                        this.aspect[1] = aspectratio.y;
+                        this.aspect[2] = aspectratio.z;
+                        pickDirty = true;
+                      },
+                      setBounds: function(axisIndex, range) {
+                        this.bounds[0][axisIndex] = range.min;
+                        this.bounds[1][axisIndex] = range.max;
+                      },
+                      setClearColor: function(clearColor) {
+                        this.clearColor = clearColor;
+                      },
+                      clearRGBA: function() {
+                        this.gl.clearColor(
+                          this.clearColor[0],
+                          this.clearColor[1],
+                          this.clearColor[2],
+                          this.clearColor[3]
+                        );
+                        this.gl.clear(
+                          this.gl.COLOR_BUFFER_BIT | this.gl.DEPTH_BUFFER_BIT
+                        );
+                      }
+                    };
+                    var pickShape = [gl2.drawingBufferWidth / scene.pixelRatio | 0, gl2.drawingBufferHeight / scene.pixelRatio | 0];
+                    function resizeListener() {
+                      if (scene._stopped) {
+                        return;
+                      }
+                      if (!scene.autoResize) {
+                        return;
+                      }
+                      var parent = canvas2.parentNode;
+                      var width = 1;
+                      var height = 1;
+                      if (parent && parent !== document.body) {
+                        width = parent.clientWidth;
+                        height = parent.clientHeight;
+                      } else {
+                        width = window.innerWidth;
+                        height = window.innerHeight;
+                      }
+                      var nextWidth = Math.ceil(width * scene.pixelRatio) | 0;
+                      var nextHeight = Math.ceil(height * scene.pixelRatio) | 0;
+                      if (nextWidth !== canvas2.width || nextHeight !== canvas2.height) {
+                        canvas2.width = nextWidth;
+                        canvas2.height = nextHeight;
+                        var style = canvas2.style;
+                        style.position = style.position || "absolute";
+                        style.left = "0px";
+                        style.top = "0px";
+                        style.width = width + "px";
+                        style.height = height + "px";
+                        dirty = true;
+                      }
+                    }
+                    if (scene.autoResize) {
+                      resizeListener();
+                    }
+                    window.addEventListener("resize", resizeListener);
+                    function reallocPickIds() {
+                      var numObjs = objects.length;
+                      var numPick = pickBuffers.length;
+                      for (var i2 = 0; i2 < numPick; ++i2) {
+                        pickBufferCount[i2] = 0;
+                      }
+                      obj_loop:
+                        for (var i2 = 0; i2 < numObjs; ++i2) {
+                          var obj = objects[i2];
+                          var pickCount = obj.pickSlots;
+                          if (!pickCount) {
+                            pickBufferIds[i2] = -1;
+                            continue;
+                          }
+                          for (var j2 = 0; j2 < numPick; ++j2) {
+                            if (pickBufferCount[j2] + pickCount < 255) {
+                              pickBufferIds[i2] = j2;
+                              obj.setPickBase(pickBufferCount[j2] + 1);
+                              pickBufferCount[j2] += pickCount;
+                              continue obj_loop;
+                            }
+                          }
+                          var nbuffer = createSelect(gl2, viewShape);
+                          pickBufferIds[i2] = numPick;
+                          pickBuffers.push(nbuffer);
+                          pickBufferCount.push(pickCount);
+                          obj.setPickBase(1);
+                          numPick += 1;
+                        }
+                      while (numPick > 0 && pickBufferCount[numPick - 1] === 0) {
+                        pickBufferCount.pop();
+                        pickBuffers.pop().dispose();
+                      }
+                    }
+                    scene.update = function(options2) {
+                      if (scene._stopped) {
+                        return;
+                      }
+                      dirty = true;
+                      pickDirty = true;
+                    };
+                    scene.add = function(obj) {
+                      if (scene._stopped) {
+                        return;
+                      }
+                      obj.axes = axes;
+                      objects.push(obj);
+                      pickBufferIds.push(-1);
+                      dirty = true;
+                      pickDirty = true;
+                      reallocPickIds();
+                    };
+                    scene.remove = function(obj) {
+                      if (scene._stopped) {
+                        return;
+                      }
+                      var idx = objects.indexOf(obj);
+                      if (idx < 0) {
+                        return;
+                      }
+                      objects.splice(idx, 1);
+                      pickBufferIds.pop();
+                      dirty = true;
+                      pickDirty = true;
+                      reallocPickIds();
+                    };
+                    scene.dispose = function() {
+                      if (scene._stopped) {
+                        return;
+                      }
+                      scene._stopped = true;
+                      window.removeEventListener("resize", resizeListener);
+                      canvas2.removeEventListener("webglcontextlost", checkContextLoss);
+                      scene.mouseListener.enabled = false;
+                      if (scene.contextLost) {
+                        return;
+                      }
+                      axes.dispose();
+                      spikes.dispose();
+                      for (var i2 = 0; i2 < objects.length; ++i2) {
+                        objects[i2].dispose();
+                      }
+                      accumBuffer.dispose();
+                      for (var i2 = 0; i2 < pickBuffers.length; ++i2) {
+                        pickBuffers[i2].dispose();
+                      }
+                      accumShader.dispose();
+                      gl2 = null;
+                      axes = null;
+                      spikes = null;
+                      objects = [];
+                    };
+                    scene._mouseRotating = false;
+                    scene._prevButtons = 0;
+                    scene.enableMouseListeners = function() {
+                      scene.mouseListener = mouseChange(canvas2, function(buttons, x2, y2) {
+                        if (scene._stopped) {
+                          return;
+                        }
+                        var numPick = pickBuffers.length;
+                        var numObjs = objects.length;
+                        var prevObj = selection.object;
+                        selection.distance = Infinity;
+                        selection.mouse[0] = x2;
+                        selection.mouse[1] = y2;
+                        selection.object = null;
+                        selection.screen = null;
+                        selection.dataCoordinate = selection.dataPosition = null;
+                        var change = false;
+                        if (buttons && scene._prevButtons) {
+                          scene._mouseRotating = true;
+                        } else {
+                          if (scene._mouseRotating) {
+                            pickDirty = true;
+                          }
+                          scene._mouseRotating = false;
+                          for (var i2 = 0; i2 < numPick; ++i2) {
+                            var result = pickBuffers[i2].query(x2, pickShape[1] - y2 - 1, scene.pickRadius);
+                            if (result) {
+                              if (result.distance > selection.distance) {
+                                continue;
+                              }
+                              for (var j2 = 0; j2 < numObjs; ++j2) {
+                                var obj = objects[j2];
+                                if (pickBufferIds[j2] !== i2) {
+                                  continue;
+                                }
+                                var objPick = obj.pick(result);
+                                if (objPick) {
+                                  selection.buttons = buttons;
+                                  selection.screen = result.coord;
+                                  selection.distance = result.distance;
+                                  selection.object = obj;
+                                  selection.index = objPick.distance;
+                                  selection.dataPosition = objPick.position;
+                                  selection.dataCoordinate = objPick.dataCoordinate;
+                                  selection.data = objPick;
+                                  change = true;
+                                }
+                              }
+                            }
+                          }
+                        }
+                        if (prevObj && prevObj !== selection.object) {
+                          if (prevObj.highlight) {
+                            prevObj.highlight(null);
+                          }
+                          dirty = true;
+                        }
+                        if (selection.object) {
+                          if (selection.object.highlight) {
+                            selection.object.highlight(selection.data);
+                          }
+                          dirty = true;
+                        }
+                        change = change || selection.object !== prevObj;
+                        if (change && scene.onselect) {
+                          scene.onselect(selection);
+                        }
+                        if (buttons & 1 && !(scene._prevButtons & 1) && scene.onclick) {
+                          scene.onclick(selection);
+                        }
+                        scene._prevButtons = buttons;
+                      });
+                    };
+                    function checkContextLoss() {
+                      if (scene.contextLost) {
+                        return true;
+                      }
+                      if (gl2.isContextLost()) {
+                        scene.contextLost = true;
+                        scene.mouseListener.enabled = false;
+                        scene.selection.object = null;
+                        if (scene.oncontextloss) {
+                          scene.oncontextloss();
+                        }
+                      }
+                    }
+                    canvas2.addEventListener("webglcontextlost", checkContextLoss);
+                    function renderPick() {
+                      if (checkContextLoss()) {
+                        return;
+                      }
+                      gl2.colorMask(true, true, true, true);
+                      gl2.depthMask(true);
+                      gl2.disable(gl2.BLEND);
+                      gl2.enable(gl2.DEPTH_TEST);
+                      gl2.depthFunc(gl2.LEQUAL);
+                      var numObjs = objects.length;
+                      var numPick = pickBuffers.length;
+                      for (var j2 = 0; j2 < numPick; ++j2) {
+                        var buf = pickBuffers[j2];
+                        buf.shape = pickShape;
+                        buf.begin();
+                        for (var i2 = 0; i2 < numObjs; ++i2) {
+                          if (pickBufferIds[i2] !== j2) {
+                            continue;
+                          }
+                          var obj = objects[i2];
+                          if (obj.drawPick) {
+                            obj.pixelRatio = 1;
+                            obj.drawPick(cameraParams);
+                          }
+                        }
+                        buf.end();
+                      }
+                    }
+                    var nBounds = [
+                      [Infinity, Infinity, Infinity],
+                      [-Infinity, -Infinity, -Infinity]
+                    ];
+                    var prevBounds = [nBounds[0].slice(), nBounds[1].slice()];
+                    function redraw() {
+                      if (checkContextLoss()) {
+                        return;
+                      }
+                      resizeListener();
+                      var cameraMoved = scene.camera.tick();
+                      cameraParams.view = scene.camera.matrix;
+                      dirty = dirty || cameraMoved;
+                      pickDirty = pickDirty || cameraMoved;
+                      axes.pixelRatio = scene.pixelRatio;
+                      spikes.pixelRatio = scene.pixelRatio;
+                      var numObjs = objects.length;
+                      var lo = nBounds[0];
+                      var hi2 = nBounds[1];
+                      lo[0] = lo[1] = lo[2] = Infinity;
+                      hi2[0] = hi2[1] = hi2[2] = -Infinity;
+                      for (var i2 = 0; i2 < numObjs; ++i2) {
+                        var obj = objects[i2];
+                        obj.pixelRatio = scene.pixelRatio;
+                        obj.axes = scene.axes;
+                        dirty = dirty || !!obj.dirty;
+                        pickDirty = pickDirty || !!obj.dirty;
+                        var obb = obj.bounds;
+                        if (obb) {
+                          var olo = obb[0];
+                          var ohi = obb[1];
+                          for (var j2 = 0; j2 < 3; ++j2) {
+                            lo[j2] = Math.min(lo[j2], olo[j2]);
+                            hi2[j2] = Math.max(hi2[j2], ohi[j2]);
+                          }
+                        }
+                      }
+                      var bounds2 = scene.bounds;
+                      if (scene.autoBounds) {
+                        for (var j2 = 0; j2 < 3; ++j2) {
+                          if (hi2[j2] < lo[j2]) {
+                            lo[j2] = -1;
+                            hi2[j2] = 1;
+                          } else {
+                            if (lo[j2] === hi2[j2]) {
+                              lo[j2] -= 1;
+                              hi2[j2] += 1;
+                            }
+                            var padding = 0.05 * (hi2[j2] - lo[j2]);
+                            lo[j2] = lo[j2] - padding;
+                            hi2[j2] = hi2[j2] + padding;
+                          }
+                          bounds2[0][j2] = lo[j2];
+                          bounds2[1][j2] = hi2[j2];
+                        }
+                      }
+                      var boundsChanged = false;
+                      for (var j2 = 0; j2 < 3; ++j2) {
+                        boundsChanged = boundsChanged || prevBounds[0][j2] !== bounds2[0][j2] || prevBounds[1][j2] !== bounds2[1][j2];
+                        prevBounds[0][j2] = bounds2[0][j2];
+                        prevBounds[1][j2] = bounds2[1][j2];
+                      }
+                      pickDirty = pickDirty || boundsChanged;
+                      dirty = dirty || boundsChanged;
+                      if (!dirty) {
+                        return;
+                      }
+                      if (boundsChanged) {
+                        var tickSpacing = [0, 0, 0];
+                        for (var i2 = 0; i2 < 3; ++i2) {
+                          tickSpacing[i2] = roundUpPow10((bounds2[1][i2] - bounds2[0][i2]) / 10);
+                        }
+                        if (axes.autoTicks) {
+                          axes.update({
+                            bounds: bounds2,
+                            tickSpacing
+                          });
+                        } else {
+                          axes.update({
+                            bounds: bounds2
+                          });
+                        }
+                      }
+                      var width = gl2.drawingBufferWidth;
+                      var height = gl2.drawingBufferHeight;
+                      viewShape[0] = width;
+                      viewShape[1] = height;
+                      pickShape[0] = Math.max(width / scene.pixelRatio, 1) | 0;
+                      pickShape[1] = Math.max(height / scene.pixelRatio, 1) | 0;
+                      calcCameraParams(scene, isOrtho);
+                      for (var i2 = 0; i2 < numObjs; ++i2) {
+                        var obj = objects[i2];
+                        obj.axesBounds = bounds2;
+                        if (scene.clipToBounds) {
+                          obj.clipBounds = bounds2;
+                        }
+                      }
+                      if (selection.object) {
+                        if (scene.snapToData) {
+                          spikes.position = selection.dataCoordinate;
+                        } else {
+                          spikes.position = selection.dataPosition;
+                        }
+                        spikes.bounds = bounds2;
+                      }
+                      if (pickDirty) {
+                        pickDirty = false;
+                        renderPick();
+                      }
+                      scene.axesPixels = axesRanges(scene.axes, cameraParams, width, height);
+                      if (scene.onrender) {
+                        scene.onrender();
+                      }
+                      gl2.bindFramebuffer(gl2.FRAMEBUFFER, null);
+                      gl2.viewport(0, 0, width, height);
+                      scene.clearRGBA();
+                      gl2.depthMask(true);
+                      gl2.colorMask(true, true, true, true);
+                      gl2.enable(gl2.DEPTH_TEST);
+                      gl2.depthFunc(gl2.LEQUAL);
+                      gl2.disable(gl2.BLEND);
+                      gl2.disable(gl2.CULL_FACE);
+                      var hasTransparent = false;
+                      if (axes.enable) {
+                        hasTransparent = hasTransparent || axes.isTransparent();
+                        axes.draw(cameraParams);
+                      }
+                      spikes.axes = axes;
+                      if (selection.object) {
+                        spikes.draw(cameraParams);
+                      }
+                      gl2.disable(gl2.CULL_FACE);
+                      for (var i2 = 0; i2 < numObjs; ++i2) {
+                        var obj = objects[i2];
+                        obj.axes = axes;
+                        obj.pixelRatio = scene.pixelRatio;
+                        if (obj.isOpaque && obj.isOpaque()) {
+                          obj.draw(cameraParams);
+                        }
+                        if (obj.isTransparent && obj.isTransparent()) {
+                          hasTransparent = true;
+                        }
+                      }
+                      if (hasTransparent) {
+                        accumBuffer.shape = viewShape;
+                        accumBuffer.bind();
+                        gl2.clear(gl2.DEPTH_BUFFER_BIT);
+                        gl2.colorMask(false, false, false, false);
+                        gl2.depthMask(true);
+                        gl2.depthFunc(gl2.LESS);
+                        if (axes.enable && axes.isTransparent()) {
+                          axes.drawTransparent(cameraParams);
+                        }
+                        for (var i2 = 0; i2 < numObjs; ++i2) {
+                          var obj = objects[i2];
+                          if (obj.isOpaque && obj.isOpaque()) {
+                            obj.draw(cameraParams);
+                          }
+                        }
+                        gl2.enable(gl2.BLEND);
+                        gl2.blendEquation(gl2.FUNC_ADD);
+                        gl2.blendFunc(gl2.ONE, gl2.ONE_MINUS_SRC_ALPHA);
+                        gl2.colorMask(true, true, true, true);
+                        gl2.depthMask(false);
+                        gl2.clearColor(0, 0, 0, 0);
+                        gl2.clear(gl2.COLOR_BUFFER_BIT);
+                        if (axes.isTransparent()) {
+                          axes.drawTransparent(cameraParams);
+                        }
+                        for (var i2 = 0; i2 < numObjs; ++i2) {
+                          var obj = objects[i2];
+                          if (obj.isTransparent && obj.isTransparent()) {
+                            obj.drawTransparent(cameraParams);
+                          }
+                        }
+                        gl2.bindFramebuffer(gl2.FRAMEBUFFER, null);
+                        gl2.blendFunc(gl2.ONE, gl2.ONE_MINUS_SRC_ALPHA);
+                        gl2.disable(gl2.DEPTH_TEST);
+                        accumShader.bind();
+                        accumBuffer.color[0].bind(0);
+                        accumShader.uniforms.accumBuffer = 0;
+                        drawTriangle(gl2);
+                        gl2.disable(gl2.BLEND);
+                      }
+                      dirty = false;
+                      for (var i2 = 0; i2 < numObjs; ++i2) {
+                        objects[i2].dirty = false;
+                      }
+                    }
+                    function render() {
+                      if (scene._stopped || scene.contextLost) {
+                        return;
+                      }
+                      redraw();
+                      requestAnimationFrame(render);
+                    }
+                    scene.enableMouseListeners();
+                    render();
+                    scene.redraw = function() {
+                      if (scene._stopped) {
+                        return;
+                      }
+                      dirty = true;
+                      redraw();
+                    };
+                    return scene;
+                  }
+                  function calcCameraParams(scene, isOrtho) {
+                    var bounds = scene.bounds;
+                    var cameraParams = scene.cameraParams;
+                    var projection = cameraParams.projection;
+                    var model = cameraParams.model;
+                    var width = scene.gl.drawingBufferWidth;
+                    var height = scene.gl.drawingBufferHeight;
+                    var zNear = scene.zNear;
+                    var zFar = scene.zFar;
+                    var fovy = scene.fovy;
+                    var r2 = width / height;
+                    if (isOrtho) {
+                      ortho2(
+                        projection,
+                        -r2,
+                        r2,
+                        -1,
+                        1,
+                        zNear,
+                        zFar
+                      );
+                      cameraParams._ortho = true;
+                    } else {
+                      perspective2(
+                        projection,
+                        fovy,
+                        r2,
+                        zNear,
+                        zFar
+                      );
+                      cameraParams._ortho = false;
+                    }
+                    for (var i2 = 0; i2 < 16; ++i2) {
+                      model[i2] = 0;
+                    }
+                    model[15] = 1;
+                    var maxS = 0;
+                    for (var i2 = 0; i2 < 3; ++i2) {
+                      maxS = Math.max(maxS, bounds[1][i2] - bounds[0][i2]);
+                    }
+                    for (var i2 = 0; i2 < 3; ++i2) {
+                      if (scene.autoScale) {
+                        model[5 * i2] = scene.aspect[i2] / (bounds[1][i2] - bounds[0][i2]);
+                      } else {
+                        model[5 * i2] = 1 / maxS;
+                      }
+                      if (scene.autoCenter) {
+                        model[12 + i2] = -model[5 * i2] * 0.5 * (bounds[0][i2] + bounds[1][i2]);
+                      }
+                    }
+                  }
+                }
+              ),
+              /***/
+              4192: (
+                /***/
+                function(module22) {
+                  module22.exports = wrapper;
+                  var INSERT_SORT_CUTOFF = 32;
+                  function wrapper(data, n0) {
+                    if (n0 <= 4 * INSERT_SORT_CUTOFF) {
+                      insertionSort(0, n0 - 1, data);
+                    } else {
+                      quickSort(0, n0 - 1, data);
+                    }
+                  }
+                  function insertionSort(left, right, data) {
+                    var ptr = 2 * (left + 1);
+                    for (var i2 = left + 1; i2 <= right; ++i2) {
+                      var a2 = data[ptr++];
+                      var b2 = data[ptr++];
+                      var j2 = i2;
+                      var jptr = ptr - 2;
+                      while (j2-- > left) {
+                        var x2 = data[jptr - 2];
+                        var y2 = data[jptr - 1];
+                        if (x2 < a2) {
+                          break;
+                        } else if (x2 === a2 && y2 < b2) {
+                          break;
+                        }
+                        data[jptr] = x2;
+                        data[jptr + 1] = y2;
+                        jptr -= 2;
+                      }
+                      data[jptr] = a2;
+                      data[jptr + 1] = b2;
+                    }
+                  }
+                  function swap(i2, j2, data) {
+                    i2 *= 2;
+                    j2 *= 2;
+                    var x2 = data[i2];
+                    var y2 = data[i2 + 1];
+                    data[i2] = data[j2];
+                    data[i2 + 1] = data[j2 + 1];
+                    data[j2] = x2;
+                    data[j2 + 1] = y2;
+                  }
+                  function move(i2, j2, data) {
+                    i2 *= 2;
+                    j2 *= 2;
+                    data[i2] = data[j2];
+                    data[i2 + 1] = data[j2 + 1];
+                  }
+                  function rotate2(i2, j2, k2, data) {
+                    i2 *= 2;
+                    j2 *= 2;
+                    k2 *= 2;
+                    var x2 = data[i2];
+                    var y2 = data[i2 + 1];
+                    data[i2] = data[j2];
+                    data[i2 + 1] = data[j2 + 1];
+                    data[j2] = data[k2];
+                    data[j2 + 1] = data[k2 + 1];
+                    data[k2] = x2;
+                    data[k2 + 1] = y2;
+                  }
+                  function shufflePivot(i2, j2, px, py, data) {
+                    i2 *= 2;
+                    j2 *= 2;
+                    data[i2] = data[j2];
+                    data[j2] = px;
+                    data[i2 + 1] = data[j2 + 1];
+                    data[j2 + 1] = py;
+                  }
+                  function compare(i2, j2, data) {
+                    i2 *= 2;
+                    j2 *= 2;
+                    var x2 = data[i2], y2 = data[j2];
+                    if (x2 < y2) {
+                      return false;
+                    } else if (x2 === y2) {
+                      return data[i2 + 1] > data[j2 + 1];
+                    }
+                    return true;
+                  }
+                  function comparePivot(i2, y2, b2, data) {
+                    i2 *= 2;
+                    var x2 = data[i2];
+                    if (x2 < y2) {
+                      return true;
+                    } else if (x2 === y2) {
+                      return data[i2 + 1] < b2;
+                    }
+                    return false;
+                  }
+                  function quickSort(left, right, data) {
+                    var sixth = (right - left + 1) / 6 | 0, index1 = left + sixth, index5 = right - sixth, index3 = left + right >> 1, index2 = index3 - sixth, index4 = index3 + sixth, el1 = index1, el2 = index2, el3 = index3, el4 = index4, el5 = index5, less = left + 1, great = right - 1, tmp2 = 0;
+                    if (compare(el1, el2, data)) {
+                      tmp2 = el1;
+                      el1 = el2;
+                      el2 = tmp2;
+                    }
+                    if (compare(el4, el5, data)) {
+                      tmp2 = el4;
+                      el4 = el5;
+                      el5 = tmp2;
+                    }
+                    if (compare(el1, el3, data)) {
+                      tmp2 = el1;
+                      el1 = el3;
+                      el3 = tmp2;
+                    }
+                    if (compare(el2, el3, data)) {
+                      tmp2 = el2;
+                      el2 = el3;
+                      el3 = tmp2;
+                    }
+                    if (compare(el1, el4, data)) {
+                      tmp2 = el1;
+                      el1 = el4;
+                      el4 = tmp2;
+                    }
+                    if (compare(el3, el4, data)) {
+                      tmp2 = el3;
+                      el3 = el4;
+                      el4 = tmp2;
+                    }
+                    if (compare(el2, el5, data)) {
+                      tmp2 = el2;
+                      el2 = el5;
+                      el5 = tmp2;
+                    }
+                    if (compare(el2, el3, data)) {
+                      tmp2 = el2;
+                      el2 = el3;
+                      el3 = tmp2;
+                    }
+                    if (compare(el4, el5, data)) {
+                      tmp2 = el4;
+                      el4 = el5;
+                      el5 = tmp2;
+                    }
+                    var pivot1X = data[2 * el2];
+                    var pivot1Y = data[2 * el2 + 1];
+                    var pivot2X = data[2 * el4];
+                    var pivot2Y = data[2 * el4 + 1];
+                    var ptr0 = 2 * el1;
+                    var ptr2 = 2 * el3;
+                    var ptr4 = 2 * el5;
+                    var ptr5 = 2 * index1;
+                    var ptr6 = 2 * index3;
+                    var ptr7 = 2 * index5;
+                    for (var i1 = 0; i1 < 2; ++i1) {
+                      var x2 = data[ptr0 + i1];
+                      var y2 = data[ptr2 + i1];
+                      var z2 = data[ptr4 + i1];
+                      data[ptr5 + i1] = x2;
+                      data[ptr6 + i1] = y2;
+                      data[ptr7 + i1] = z2;
+                    }
+                    move(index2, left, data);
+                    move(index4, right, data);
+                    for (var k2 = less; k2 <= great; ++k2) {
+                      if (comparePivot(k2, pivot1X, pivot1Y, data)) {
+                        if (k2 !== less) {
+                          swap(k2, less, data);
+                        }
+                        ++less;
+                      } else {
+                        if (!comparePivot(k2, pivot2X, pivot2Y, data)) {
+                          while (true) {
+                            if (!comparePivot(great, pivot2X, pivot2Y, data)) {
+                              if (--great < k2) {
+                                break;
+                              }
+                              continue;
+                            } else {
+                              if (comparePivot(great, pivot1X, pivot1Y, data)) {
+                                rotate2(k2, less, great, data);
+                                ++less;
+                                --great;
+                              } else {
+                                swap(k2, great, data);
+                                --great;
+                              }
+                              break;
+                            }
+                          }
+                        }
+                      }
+                    }
+                    shufflePivot(left, less - 1, pivot1X, pivot1Y, data);
+                    shufflePivot(right, great + 1, pivot2X, pivot2Y, data);
+                    if (less - 2 - left <= INSERT_SORT_CUTOFF) {
+                      insertionSort(left, less - 2, data);
+                    } else {
+                      quickSort(left, less - 2, data);
+                    }
+                    if (right - (great + 2) <= INSERT_SORT_CUTOFF) {
+                      insertionSort(great + 2, right, data);
+                    } else {
+                      quickSort(great + 2, right, data);
+                    }
+                    if (great - less <= INSERT_SORT_CUTOFF) {
+                      insertionSort(less, great, data);
+                    } else {
+                      quickSort(less, great, data);
+                    }
+                  }
+                }
+              ),
+              /***/
+              4209: (
+                /***/
+                function(module22, __unused_webpack_exports, __webpack_require__2) {
+                  module22.exports = createSlabDecomposition;
+                  var bounds = __webpack_require__2(2478);
+                  var createRBTree = __webpack_require__2(3840);
+                  var orient = __webpack_require__2(3250);
+                  var orderSegments = __webpack_require__2(1303);
+                  function SlabDecomposition(slabs, coordinates, horizontal) {
+                    this.slabs = slabs;
+                    this.coordinates = coordinates;
+                    this.horizontal = horizontal;
+                  }
+                  var proto = SlabDecomposition.prototype;
+                  function compareHorizontal(e2, y2) {
+                    return e2.y - y2;
+                  }
+                  function searchBucket(root, p2) {
+                    var lastNode = null;
+                    while (root) {
+                      var seg = root.key;
+                      var l2, r2;
+                      if (seg[0][0] < seg[1][0]) {
+                        l2 = seg[0];
+                        r2 = seg[1];
+                      } else {
+                        l2 = seg[1];
+                        r2 = seg[0];
+                      }
+                      var o2 = orient(l2, r2, p2);
+                      if (o2 < 0) {
+                        root = root.left;
+                      } else if (o2 > 0) {
+                        if (p2[0] !== seg[1][0]) {
+                          lastNode = root;
+                          root = root.right;
+                        } else {
+                          var val = searchBucket(root.right, p2);
+                          if (val) {
+                            return val;
+                          }
+                          root = root.left;
+                        }
+                      } else {
+                        if (p2[0] !== seg[1][0]) {
+                          return root;
+                        } else {
+                          var val = searchBucket(root.right, p2);
+                          if (val) {
+                            return val;
+                          }
+                          root = root.left;
+                        }
+                      }
+                    }
+                    return lastNode;
+                  }
+                  proto.castUp = function(p2) {
+                    var bucket = bounds.le(this.coordinates, p2[0]);
+                    if (bucket < 0) {
+                      return -1;
+                    }
+                    this.slabs[bucket];
+                    var hitNode = searchBucket(this.slabs[bucket], p2);
+                    var lastHit = -1;
+                    if (hitNode) {
+                      lastHit = hitNode.value;
+                    }
+                    if (this.coordinates[bucket] === p2[0]) {
+                      var lastSegment = null;
+                      if (hitNode) {
+                        lastSegment = hitNode.key;
+                      }
+                      if (bucket > 0) {
+                        var otherHitNode = searchBucket(this.slabs[bucket - 1], p2);
+                        if (otherHitNode) {
+                          if (lastSegment) {
+                            if (orderSegments(otherHitNode.key, lastSegment) > 0) {
+                              lastSegment = otherHitNode.key;
+                              lastHit = otherHitNode.value;
+                            }
+                          } else {
+                            lastHit = otherHitNode.value;
+                            lastSegment = otherHitNode.key;
+                          }
+                        }
+                      }
+                      var horiz = this.horizontal[bucket];
+                      if (horiz.length > 0) {
+                        var hbucket = bounds.ge(horiz, p2[1], compareHorizontal);
+                        if (hbucket < horiz.length) {
+                          var e2 = horiz[hbucket];
+                          if (p2[1] === e2.y) {
+                            if (e2.closed) {
+                              return e2.index;
+                            } else {
+                              while (hbucket < horiz.length - 1 && horiz[hbucket + 1].y === p2[1]) {
+                                hbucket = hbucket + 1;
+                                e2 = horiz[hbucket];
+                                if (e2.closed) {
+                                  return e2.index;
+                                }
+                              }
+                              if (e2.y === p2[1] && !e2.start) {
+                                hbucket = hbucket + 1;
+                                if (hbucket >= horiz.length) {
+                                  return lastHit;
+                                }
+                                e2 = horiz[hbucket];
+                              }
+                            }
+                          }
+                          if (e2.start) {
+                            if (lastSegment) {
+                              var o2 = orient(lastSegment[0], lastSegment[1], [p2[0], e2.y]);
+                              if (lastSegment[0][0] > lastSegment[1][0]) {
+                                o2 = -o2;
+                              }
+                              if (o2 > 0) {
+                                lastHit = e2.index;
+                              }
+                            } else {
+                              lastHit = e2.index;
+                            }
+                          } else if (e2.y !== p2[1]) {
+                            lastHit = e2.index;
+                          }
+                        }
+                      }
+                    }
+                    return lastHit;
+                  };
+                  function IntervalSegment(y2, index, start, closed) {
+                    this.y = y2;
+                    this.index = index;
+                    this.start = start;
+                    this.closed = closed;
+                  }
+                  function Event2(x2, segment, create2, index) {
+                    this.x = x2;
+                    this.segment = segment;
+                    this.create = create2;
+                    this.index = index;
+                  }
+                  function createSlabDecomposition(segments) {
+                    var numSegments = segments.length;
+                    var numEvents = 2 * numSegments;
+                    var events = new Array(numEvents);
+                    for (var i2 = 0; i2 < numSegments; ++i2) {
+                      var s2 = segments[i2];
+                      var f2 = s2[0][0] < s2[1][0];
+                      events[2 * i2] = new Event2(s2[0][0], s2, f2, i2);
+                      events[2 * i2 + 1] = new Event2(s2[1][0], s2, !f2, i2);
+                    }
+                    events.sort(function(a2, b2) {
+                      var d2 = a2.x - b2.x;
+                      if (d2) {
+                        return d2;
+                      }
+                      d2 = a2.create - b2.create;
+                      if (d2) {
+                        return d2;
+                      }
+                      return Math.min(a2.segment[0][1], a2.segment[1][1]) - Math.min(b2.segment[0][1], b2.segment[1][1]);
+                    });
+                    var tree = createRBTree(orderSegments);
+                    var slabs = [];
+                    var lines = [];
+                    var horizontal = [];
+                    for (var i2 = 0; i2 < numEvents; ) {
+                      var x2 = events[i2].x;
+                      var horiz = [];
+                      while (i2 < numEvents) {
+                        var e2 = events[i2];
+                        if (e2.x !== x2) {
+                          break;
+                        }
+                        i2 += 1;
+                        if (e2.segment[0][0] === e2.x && e2.segment[1][0] === e2.x) {
+                          if (e2.create) {
+                            if (e2.segment[0][1] < e2.segment[1][1]) {
+                              horiz.push(new IntervalSegment(
+                                e2.segment[0][1],
+                                e2.index,
+                                true,
+                                true
+                              ));
+                              horiz.push(new IntervalSegment(
+                                e2.segment[1][1],
+                                e2.index,
+                                false,
+                                false
+                              ));
+                            } else {
+                              horiz.push(new IntervalSegment(
+                                e2.segment[1][1],
+                                e2.index,
+                                true,
+                                false
+                              ));
+                              horiz.push(new IntervalSegment(
+                                e2.segment[0][1],
+                                e2.index,
+                                false,
+                                true
+                              ));
+                            }
+                          }
+                        } else {
+                          if (e2.create) {
+                            tree = tree.insert(e2.segment, e2.index);
+                          } else {
+                            tree = tree.remove(e2.segment);
+                          }
+                        }
+                      }
+                      slabs.push(tree.root);
+                      lines.push(x2);
+                      horizontal.push(horiz);
+                    }
+                    return new SlabDecomposition(slabs, lines, horizontal);
+                  }
+                }
+              ),
+              /***/
+              4317: (
+                /***/
+                function(module22) {
+                  function interp1d(arr, x2) {
+                    var ix = Math.floor(x2), fx = x2 - ix, s0 = 0 <= ix && ix < arr.shape[0], s1 = 0 <= ix + 1 && ix + 1 < arr.shape[0], w0 = s0 ? +arr.get(ix) : 0, w1 = s1 ? +arr.get(ix + 1) : 0;
+                    return (1 - fx) * w0 + fx * w1;
+                  }
+                  function interp2d(arr, x2, y2) {
+                    var ix = Math.floor(x2), fx = x2 - ix, s0 = 0 <= ix && ix < arr.shape[0], s1 = 0 <= ix + 1 && ix + 1 < arr.shape[0], iy = Math.floor(y2), fy = y2 - iy, t02 = 0 <= iy && iy < arr.shape[1], t12 = 0 <= iy + 1 && iy + 1 < arr.shape[1], w00 = s0 && t02 ? arr.get(ix, iy) : 0, w01 = s0 && t12 ? arr.get(ix, iy + 1) : 0, w10 = s1 && t02 ? arr.get(ix + 1, iy) : 0, w11 = s1 && t12 ? arr.get(ix + 1, iy + 1) : 0;
+                    return (1 - fy) * ((1 - fx) * w00 + fx * w10) + fy * ((1 - fx) * w01 + fx * w11);
+                  }
+                  function interp3d(arr, x2, y2, z2) {
+                    var ix = Math.floor(x2), fx = x2 - ix, s0 = 0 <= ix && ix < arr.shape[0], s1 = 0 <= ix + 1 && ix + 1 < arr.shape[0], iy = Math.floor(y2), fy = y2 - iy, t02 = 0 <= iy && iy < arr.shape[1], t12 = 0 <= iy + 1 && iy + 1 < arr.shape[1], iz = Math.floor(z2), fz = z2 - iz, u0 = 0 <= iz && iz < arr.shape[2], u1 = 0 <= iz + 1 && iz + 1 < arr.shape[2], w000 = s0 && t02 && u0 ? arr.get(ix, iy, iz) : 0, w010 = s0 && t12 && u0 ? arr.get(ix, iy + 1, iz) : 0, w100 = s1 && t02 && u0 ? arr.get(ix + 1, iy, iz) : 0, w110 = s1 && t12 && u0 ? arr.get(ix + 1, iy + 1, iz) : 0, w001 = s0 && t02 && u1 ? arr.get(ix, iy, iz + 1) : 0, w011 = s0 && t12 && u1 ? arr.get(ix, iy + 1, iz + 1) : 0, w101 = s1 && t02 && u1 ? arr.get(ix + 1, iy, iz + 1) : 0, w111 = s1 && t12 && u1 ? arr.get(ix + 1, iy + 1, iz + 1) : 0;
+                    return (1 - fz) * ((1 - fy) * ((1 - fx) * w000 + fx * w100) + fy * ((1 - fx) * w010 + fx * w110)) + fz * ((1 - fy) * ((1 - fx) * w001 + fx * w101) + fy * ((1 - fx) * w011 + fx * w111));
+                  }
+                  function interpNd(arr) {
+                    var d2 = arr.shape.length | 0, ix = new Array(d2), fx = new Array(d2), s0 = new Array(d2), s1 = new Array(d2), i2, t4;
+                    for (i2 = 0; i2 < d2; ++i2) {
+                      t4 = +arguments[i2 + 1];
+                      ix[i2] = Math.floor(t4);
+                      fx[i2] = t4 - ix[i2];
+                      s0[i2] = 0 <= ix[i2] && ix[i2] < arr.shape[i2];
+                      s1[i2] = 0 <= ix[i2] + 1 && ix[i2] + 1 < arr.shape[i2];
+                    }
+                    var r2 = 0, j2, w2, idx;
+                    i_loop:
+                      for (i2 = 0; i2 < 1 << d2; ++i2) {
+                        w2 = 1;
+                        idx = arr.offset;
+                        for (j2 = 0; j2 < d2; ++j2) {
+                          if (i2 & 1 << j2) {
+                            if (!s1[j2]) {
+                              continue i_loop;
+                            }
+                            w2 *= fx[j2];
+                            idx += arr.stride[j2] * (ix[j2] + 1);
+                          } else {
+                            if (!s0[j2]) {
+                              continue i_loop;
+                            }
+                            w2 *= 1 - fx[j2];
+                            idx += arr.stride[j2] * ix[j2];
+                          }
+                        }
+                        r2 += w2 * arr.data[idx];
+                      }
+                    return r2;
+                  }
+                  function interpolate(arr, x2, y2, z2) {
+                    switch (arr.shape.length) {
+                      case 0:
+                        return 0;
+                      case 1:
+                        return interp1d(arr, x2);
+                      case 2:
+                        return interp2d(arr, x2, y2);
+                      case 3:
+                        return interp3d(arr, x2, y2, z2);
+                      default:
+                        return interpNd.apply(void 0, arguments);
+                    }
+                  }
+                  module22.exports = interpolate;
+                  module22.exports.d1 = interp1d;
+                  module22.exports.d2 = interp2d;
+                  module22.exports.d3 = interp3d;
+                }
+              ),
+              /***/
+              4335: (
+                /***/
+                function(module22) {
+                  module22.exports = function normalize(out, mat) {
+                    var m44 = mat[15];
+                    if (m44 === 0)
+                      return false;
+                    var scale2 = 1 / m44;
+                    for (var i2 = 0; i2 < 16; i2++)
+                      out[i2] = mat[i2] * scale2;
+                    return true;
+                  };
+                }
+              ),
+              /***/
+              4359: (
+                /***/
+                function(module22, __unused_webpack_exports, __webpack_require__2) {
+                  module22.exports = createText;
+                  var vectorizeText = __webpack_require__2(7718);
+                  var defaultCanvas = null;
+                  var defaultContext = null;
+                  if (typeof document !== "undefined") {
+                    defaultCanvas = document.createElement("canvas");
+                    defaultCanvas.width = 8192;
+                    defaultCanvas.height = 1024;
+                    defaultContext = defaultCanvas.getContext("2d");
+                  }
+                  function createText(str, options) {
+                    if (typeof options !== "object" || options === null) {
+                      options = {};
+                    }
+                    return vectorizeText(
+                      str,
+                      options.canvas || defaultCanvas,
+                      options.context || defaultContext,
+                      options
+                    );
+                  }
+                }
+              ),
+              /***/
+              4361: (
+                /***/
+                function(module22) {
+                  module22.exports = add2;
+                  function add2(out, a2, b2) {
+                    out[0] = a2[0] + b2[0];
+                    out[1] = a2[1] + b2[1];
+                    out[2] = a2[2] + b2[2];
+                    out[3] = a2[3] + b2[3];
+                    return out;
+                  }
+                }
+              ),
+              /***/
+              4437: (
+                /***/
+                function(module22, __unused_webpack_exports, __webpack_require__2) {
+                  module22.exports = createCamera;
+                  var now = __webpack_require__2(3025);
+                  var createView = __webpack_require__2(6296);
+                  var mouseChange = __webpack_require__2(351);
+                  var mouseWheel = __webpack_require__2(8512);
+                  var mouseOffset = __webpack_require__2(24);
+                  var hasPassive = __webpack_require__2(7520);
+                  function createCamera(element, options) {
+                    element = element || document.body;
+                    options = options || {};
+                    var limits = [0.01, Infinity];
+                    if ("distanceLimits" in options) {
+                      limits[0] = options.distanceLimits[0];
+                      limits[1] = options.distanceLimits[1];
+                    }
+                    if ("zoomMin" in options) {
+                      limits[0] = options.zoomMin;
+                    }
+                    if ("zoomMax" in options) {
+                      limits[1] = options.zoomMax;
+                    }
+                    var view = createView({
+                      center: options.center || [0, 0, 0],
+                      up: options.up || [0, 1, 0],
+                      eye: options.eye || [0, 0, 10],
+                      mode: options.mode || "orbit",
+                      distanceLimits: limits
+                    });
+                    var pmatrix = [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0];
+                    var distance2 = 0;
+                    var width = element.clientWidth;
+                    var height = element.clientHeight;
+                    var camera = {
+                      keyBindingMode: "rotate",
+                      enableWheel: true,
+                      view,
+                      element,
+                      delay: options.delay || 16,
+                      rotateSpeed: options.rotateSpeed || 1,
+                      zoomSpeed: options.zoomSpeed || 1,
+                      translateSpeed: options.translateSpeed || 1,
+                      flipX: !!options.flipX,
+                      flipY: !!options.flipY,
+                      modes: view.modes,
+                      _ortho: options._ortho || options.projection && options.projection.type === "orthographic" || false,
+                      tick: function() {
+                        var t4 = now();
+                        var delay = this.delay;
+                        var ctime = t4 - 2 * delay;
+                        view.idle(t4 - delay);
+                        view.recalcMatrix(ctime);
+                        view.flush(t4 - (100 + delay * 2));
+                        var allEqual = true;
+                        var matrix = view.computedMatrix;
+                        for (var i2 = 0; i2 < 16; ++i2) {
+                          allEqual = allEqual && pmatrix[i2] === matrix[i2];
+                          pmatrix[i2] = matrix[i2];
+                        }
+                        var sizeChanged = element.clientWidth === width && element.clientHeight === height;
+                        width = element.clientWidth;
+                        height = element.clientHeight;
+                        if (allEqual) {
+                          return !sizeChanged;
+                        }
+                        distance2 = Math.exp(view.computedRadius[0]);
+                        return true;
+                      },
+                      lookAt: function(eye, center, up) {
+                        view.lookAt(view.lastT(), eye, center, up);
+                      },
+                      rotate: function(pitch, yaw, roll) {
+                        view.rotate(view.lastT(), pitch, yaw, roll);
+                      },
+                      pan: function(dx, dy, dz) {
+                        view.pan(view.lastT(), dx, dy, dz);
+                      },
+                      translate: function(dx, dy, dz) {
+                        view.translate(view.lastT(), dx, dy, dz);
+                      }
+                    };
+                    Object.defineProperties(camera, {
+                      matrix: {
+                        get: function() {
+                          return view.computedMatrix;
+                        },
+                        set: function(mat) {
+                          view.setMatrix(view.lastT(), mat);
+                          return view.computedMatrix;
+                        },
+                        enumerable: true
+                      },
+                      mode: {
+                        get: function() {
+                          return view.getMode();
+                        },
+                        set: function(mode) {
+                          var curUp = view.computedUp.slice();
+                          var curEye = view.computedEye.slice();
+                          var curCenter = view.computedCenter.slice();
+                          view.setMode(mode);
+                          if (mode === "turntable") {
+                            var t02 = now();
+                            view._active.lookAt(t02, curEye, curCenter, curUp);
+                            view._active.lookAt(t02 + 500, curEye, curCenter, [0, 0, 1]);
+                            view._active.flush(t02);
+                          }
+                          return view.getMode();
+                        },
+                        enumerable: true
+                      },
+                      center: {
+                        get: function() {
+                          return view.computedCenter;
+                        },
+                        set: function(ncenter) {
+                          view.lookAt(view.lastT(), null, ncenter);
+                          return view.computedCenter;
+                        },
+                        enumerable: true
+                      },
+                      eye: {
+                        get: function() {
+                          return view.computedEye;
+                        },
+                        set: function(neye) {
+                          view.lookAt(view.lastT(), neye);
+                          return view.computedEye;
+                        },
+                        enumerable: true
+                      },
+                      up: {
+                        get: function() {
+                          return view.computedUp;
+                        },
+                        set: function(nup) {
+                          view.lookAt(view.lastT(), null, null, nup);
+                          return view.computedUp;
+                        },
+                        enumerable: true
+                      },
+                      distance: {
+                        get: function() {
+                          return distance2;
+                        },
+                        set: function(d2) {
+                          view.setDistance(view.lastT(), d2);
+                          return d2;
+                        },
+                        enumerable: true
+                      },
+                      distanceLimits: {
+                        get: function() {
+                          return view.getDistanceLimits(limits);
+                        },
+                        set: function(v2) {
+                          view.setDistanceLimits(v2);
+                          return v2;
+                        },
+                        enumerable: true
+                      }
+                    });
+                    element.addEventListener("contextmenu", function(ev) {
+                      ev.preventDefault();
+                      return false;
+                    });
+                    camera._lastX = -1;
+                    camera._lastY = -1;
+                    camera._lastMods = { shift: false, control: false, alt: false, meta: false };
+                    camera.enableMouseListeners = function() {
+                      camera.mouseListener = mouseChange(element, handleInteraction);
+                      element.addEventListener("touchstart", function(ev) {
+                        var xy = mouseOffset(ev.changedTouches[0], element);
+                        handleInteraction(0, xy[0], xy[1], camera._lastMods);
+                        handleInteraction(1, xy[0], xy[1], camera._lastMods);
+                      }, hasPassive ? { passive: true } : false);
+                      element.addEventListener("touchmove", function(ev) {
+                        var xy = mouseOffset(ev.changedTouches[0], element);
+                        handleInteraction(1, xy[0], xy[1], camera._lastMods);
+                        ev.preventDefault();
+                      }, hasPassive ? { passive: false } : false);
+                      element.addEventListener("touchend", function(ev) {
+                        handleInteraction(0, camera._lastX, camera._lastY, camera._lastMods);
+                      }, hasPassive ? { passive: true } : false);
+                      function handleInteraction(buttons, x2, y2, mods) {
+                        var keyBindingMode = camera.keyBindingMode;
+                        if (keyBindingMode === false) return;
+                        var rotate2 = keyBindingMode === "rotate";
+                        var pan = keyBindingMode === "pan";
+                        var zoom = keyBindingMode === "zoom";
+                        var ctrl = !!mods.control;
+                        var alt = !!mods.alt;
+                        var shift = !!mods.shift;
+                        var left = !!(buttons & 1);
+                        var right = !!(buttons & 2);
+                        var middle = !!(buttons & 4);
+                        var scale2 = 1 / element.clientHeight;
+                        var dx = scale2 * (x2 - camera._lastX);
+                        var dy = scale2 * (y2 - camera._lastY);
+                        var flipX = camera.flipX ? 1 : -1;
+                        var flipY = camera.flipY ? 1 : -1;
+                        var drot = Math.PI * camera.rotateSpeed;
+                        var t4 = now();
+                        if (camera._lastX !== -1 && camera._lastY !== -1) {
+                          if (rotate2 && left && !ctrl && !alt && !shift || left && !ctrl && !alt && shift) {
+                            view.rotate(t4, flipX * drot * dx, -flipY * drot * dy, 0);
+                          }
+                          if (pan && left && !ctrl && !alt && !shift || right || left && ctrl && !alt && !shift) {
+                            view.pan(t4, -camera.translateSpeed * dx * distance2, camera.translateSpeed * dy * distance2, 0);
+                          }
+                          if (zoom && left && !ctrl && !alt && !shift || middle || left && !ctrl && alt && !shift) {
+                            var kzoom = -camera.zoomSpeed * dy / window.innerHeight * (t4 - view.lastT()) * 100;
+                            view.pan(t4, 0, 0, distance2 * (Math.exp(kzoom) - 1));
+                          }
+                        }
+                        camera._lastX = x2;
+                        camera._lastY = y2;
+                        camera._lastMods = mods;
+                        return true;
+                      }
+                      camera.wheelListener = mouseWheel(element, function(dx, dy) {
+                        if (camera.keyBindingMode === false) return;
+                        if (!camera.enableWheel) return;
+                        var flipX = camera.flipX ? 1 : -1;
+                        var flipY = camera.flipY ? 1 : -1;
+                        var t4 = now();
+                        if (Math.abs(dx) > Math.abs(dy)) {
+                          view.rotate(t4, 0, 0, -dx * flipX * Math.PI * camera.rotateSpeed / window.innerWidth);
+                        } else {
+                          if (!camera._ortho) {
+                            var kzoom = -camera.zoomSpeed * flipY * dy / window.innerHeight * (t4 - view.lastT()) / 20;
+                            view.pan(t4, 0, 0, distance2 * (Math.exp(kzoom) - 1));
+                          }
+                        }
+                      }, true);
+                    };
+                    camera.enableMouseListeners();
+                    return camera;
+                  }
+                }
+              ),
+              /***/
+              4449: (
+                /***/
+                function(module22, __unused_webpack_exports, __webpack_require__2) {
+                  var createBuffer = __webpack_require__2(2762);
+                  var createVAO = __webpack_require__2(8116);
+                  var createShader = __webpack_require__2(1493);
+                  module22.exports = createSpikes;
+                  var identity22 = [
+                    1,
+                    0,
+                    0,
+                    0,
+                    0,
+                    1,
+                    0,
+                    0,
+                    0,
+                    0,
+                    1,
+                    0,
+                    0,
+                    0,
+                    0,
+                    1
+                  ];
+                  function AxisSpikes(gl2, buffer, vao, shader) {
+                    this.gl = gl2;
+                    this.buffer = buffer;
+                    this.vao = vao;
+                    this.shader = shader;
+                    this.pixelRatio = 1;
+                    this.bounds = [[-1e3, -1e3, -1e3], [1e3, 1e3, 1e3]];
+                    this.position = [0, 0, 0];
+                    this.lineWidth = [2, 2, 2];
+                    this.colors = [[0, 0, 0, 1], [0, 0, 0, 1], [0, 0, 0, 1]];
+                    this.enabled = [true, true, true];
+                    this.drawSides = [true, true, true];
+                    this.axes = null;
+                  }
+                  var proto = AxisSpikes.prototype;
+                  var OUTER_FACE = [0, 0, 0];
+                  var INNER_FACE = [0, 0, 0];
+                  var SHAPE = [0, 0];
+                  proto.isTransparent = function() {
+                    return false;
+                  };
+                  proto.drawTransparent = function(camera) {
+                  };
+                  proto.draw = function(camera) {
+                    var gl2 = this.gl;
+                    var vao = this.vao;
+                    var shader = this.shader;
+                    vao.bind();
+                    shader.bind();
+                    var model = camera.model || identity22;
+                    var view = camera.view || identity22;
+                    var projection = camera.projection || identity22;
+                    var axis;
+                    if (this.axes) {
+                      axis = this.axes.lastCubeProps.axis;
+                    }
+                    var outerFace = OUTER_FACE;
+                    var innerFace = INNER_FACE;
+                    for (var i2 = 0; i2 < 3; ++i2) {
+                      if (axis && axis[i2] < 0) {
+                        outerFace[i2] = this.bounds[0][i2];
+                        innerFace[i2] = this.bounds[1][i2];
+                      } else {
+                        outerFace[i2] = this.bounds[1][i2];
+                        innerFace[i2] = this.bounds[0][i2];
+                      }
+                    }
+                    SHAPE[0] = gl2.drawingBufferWidth;
+                    SHAPE[1] = gl2.drawingBufferHeight;
+                    shader.uniforms.model = model;
+                    shader.uniforms.view = view;
+                    shader.uniforms.projection = projection;
+                    shader.uniforms.coordinates = [this.position, outerFace, innerFace];
+                    shader.uniforms.colors = this.colors;
+                    shader.uniforms.screenShape = SHAPE;
+                    for (var i2 = 0; i2 < 3; ++i2) {
+                      shader.uniforms.lineWidth = this.lineWidth[i2] * this.pixelRatio;
+                      if (this.enabled[i2]) {
+                        vao.draw(gl2.TRIANGLES, 6, 6 * i2);
+                        if (this.drawSides[i2]) {
+                          vao.draw(gl2.TRIANGLES, 12, 18 + 12 * i2);
+                        }
+                      }
+                    }
+                    vao.unbind();
+                  };
+                  proto.update = function(options) {
+                    if (!options) {
+                      return;
+                    }
+                    if ("bounds" in options) {
+                      this.bounds = options.bounds;
+                    }
+                    if ("position" in options) {
+                      this.position = options.position;
+                    }
+                    if ("lineWidth" in options) {
+                      this.lineWidth = options.lineWidth;
+                    }
+                    if ("colors" in options) {
+                      this.colors = options.colors;
+                    }
+                    if ("enabled" in options) {
+                      this.enabled = options.enabled;
+                    }
+                    if ("drawSides" in options) {
+                      this.drawSides = options.drawSides;
+                    }
+                  };
+                  proto.dispose = function() {
+                    this.vao.dispose();
+                    this.buffer.dispose();
+                    this.shader.dispose();
+                  };
+                  function createSpikes(gl2, options) {
+                    var data = [];
+                    function line(x2, y2, z2, i2, l2, h2) {
+                      var row = [x2, y2, z2, 0, 0, 0, 1];
+                      row[i2 + 3] = 1;
+                      row[i2] = l2;
+                      data.push.apply(data, row);
+                      row[6] = -1;
+                      data.push.apply(data, row);
+                      row[i2] = h2;
+                      data.push.apply(data, row);
+                      data.push.apply(data, row);
+                      row[6] = 1;
+                      data.push.apply(data, row);
+                      row[i2] = l2;
+                      data.push.apply(data, row);
+                    }
+                    line(0, 0, 0, 0, 0, 1);
+                    line(0, 0, 0, 1, 0, 1);
+                    line(0, 0, 0, 2, 0, 1);
+                    line(1, 0, 0, 1, -1, 1);
+                    line(1, 0, 0, 2, -1, 1);
+                    line(0, 1, 0, 0, -1, 1);
+                    line(0, 1, 0, 2, -1, 1);
+                    line(0, 0, 1, 0, -1, 1);
+                    line(0, 0, 1, 1, -1, 1);
+                    var buffer = createBuffer(gl2, data);
+                    var vao = createVAO(gl2, [{
+                      type: gl2.FLOAT,
+                      buffer,
+                      size: 3,
+                      offset: 0,
+                      stride: 28
+                    }, {
+                      type: gl2.FLOAT,
+                      buffer,
+                      size: 3,
+                      offset: 12,
+                      stride: 28
+                    }, {
+                      type: gl2.FLOAT,
+                      buffer,
+                      size: 1,
+                      offset: 24,
+                      stride: 28
+                    }]);
+                    var shader = createShader(gl2);
+                    shader.attributes.position.location = 0;
+                    shader.attributes.color.location = 1;
+                    shader.attributes.weight.location = 2;
+                    var spikes = new AxisSpikes(gl2, buffer, vao, shader);
+                    spikes.update(options);
+                    return spikes;
+                  }
+                }
+              ),
+              /***/
+              4494: (
+                /***/
+                function(module22) {
+                  module22.exports = inverse;
+                  function inverse(out, a2) {
+                    out[0] = 1 / a2[0];
+                    out[1] = 1 / a2[1];
+                    out[2] = 1 / a2[2];
+                    out[3] = 1 / a2[3];
+                    return out;
+                  }
+                }
+              ),
+              /***/
+              4505: (
+                /***/
+                function(module22, __unused_webpack_exports, __webpack_require__2) {
+                  module22.exports = __webpack_require__2(5847);
+                }
+              ),
+              /***/
+              4578: (
+                /***/
+                function(module22) {
+                  module22.exports = set;
+                  function set(out, x2, y2, z2, w2) {
+                    out[0] = x2;
+                    out[1] = y2;
+                    out[2] = z2;
+                    out[3] = w2;
+                    return out;
+                  }
+                }
+              ),
+              /***/
+              4623: (
+                /***/
+                function(module22) {
+                  "use restrict";
+                  module22.exports = UnionFind;
+                  function UnionFind(count2) {
+                    this.roots = new Array(count2);
+                    this.ranks = new Array(count2);
+                    for (var i2 = 0; i2 < count2; ++i2) {
+                      this.roots[i2] = i2;
+                      this.ranks[i2] = 0;
+                    }
+                  }
+                  UnionFind.prototype.length = function() {
+                    return this.roots.length;
+                  };
+                  UnionFind.prototype.makeSet = function() {
+                    var n2 = this.roots.length;
+                    this.roots.push(n2);
+                    this.ranks.push(0);
+                    return n2;
+                  };
+                  UnionFind.prototype.find = function(x2) {
+                    var roots = this.roots;
+                    while (roots[x2] !== x2) {
+                      var y2 = roots[x2];
+                      roots[x2] = roots[y2];
+                      x2 = y2;
+                    }
+                    return x2;
+                  };
+                  UnionFind.prototype.link = function(x2, y2) {
+                    var xr = this.find(x2), yr = this.find(y2);
+                    if (xr === yr) {
+                      return;
+                    }
+                    var ranks = this.ranks, roots = this.roots, xd2 = ranks[xr], yd2 = ranks[yr];
+                    if (xd2 < yd2) {
+                      roots[xr] = yr;
+                    } else if (yd2 < xd2) {
+                      roots[yr] = xr;
+                    } else {
+                      roots[yr] = xr;
+                      ++ranks[xr];
+                    }
+                  };
+                }
+              ),
+              /***/
+              4687: (
+                /***/
+                function(__unused_webpack_module, exports2) {
+                  function mouseButtons(ev) {
+                    if (typeof ev === "object") {
+                      if ("buttons" in ev) {
+                        return ev.buttons;
+                      } else if ("which" in ev) {
+                        var b2 = ev.which;
+                        if (b2 === 2) {
+                          return 4;
+                        } else if (b2 === 3) {
+                          return 2;
+                        } else if (b2 > 0) {
+                          return 1 << b2 - 1;
+                        }
+                      } else if ("button" in ev) {
+                        var b2 = ev.button;
+                        if (b2 === 1) {
+                          return 4;
+                        } else if (b2 === 2) {
+                          return 2;
+                        } else if (b2 >= 0) {
+                          return 1 << b2;
+                        }
+                      }
+                    }
+                    return 0;
+                  }
+                  exports2.buttons = mouseButtons;
+                  function mouseElement(ev) {
+                    return ev.target || ev.srcElement || window;
+                  }
+                  exports2.element = mouseElement;
+                  function mouseRelativeX(ev) {
+                    if (typeof ev === "object") {
+                      if ("offsetX" in ev) {
+                        return ev.offsetX;
+                      }
+                      var target = mouseElement(ev);
+                      var bounds = target.getBoundingClientRect();
+                      return ev.clientX - bounds.left;
+                    }
+                    return 0;
+                  }
+                  exports2.x = mouseRelativeX;
+                  function mouseRelativeY(ev) {
+                    if (typeof ev === "object") {
+                      if ("offsetY" in ev) {
+                        return ev.offsetY;
+                      }
+                      var target = mouseElement(ev);
+                      var bounds = target.getBoundingClientRect();
+                      return ev.clientY - bounds.top;
+                    }
+                    return 0;
+                  }
+                  exports2.y = mouseRelativeY;
+                }
+              ),
+              /***/
+              4691: (
+                /***/
+                function(module22) {
+                  module22.exports = distance2;
+                  function distance2(a2, b2) {
+                    var x2 = b2[0] - a2[0], y2 = b2[1] - a2[1], z2 = b2[2] - a2[2], w2 = b2[3] - a2[3];
+                    return Math.sqrt(x2 * x2 + y2 * y2 + z2 * z2 + w2 * w2);
+                  }
+                }
+              ),
+              /***/
+              4750: (
+                /***/
+                function(module22, __unused_webpack_exports, __webpack_require__2) {
+                  module22.exports = convexHull2D;
+                  var monotoneHull = __webpack_require__2(3090);
+                  function convexHull2D(points) {
+                    var hull = monotoneHull(points);
+                    var h2 = hull.length;
+                    if (h2 <= 2) {
+                      return [];
+                    }
+                    var edges = new Array(h2);
+                    var a2 = hull[h2 - 1];
+                    for (var i2 = 0; i2 < h2; ++i2) {
+                      var b2 = hull[i2];
+                      edges[i2] = [a2, b2];
+                      a2 = b2;
+                    }
+                    return edges;
+                  }
+                }
+              ),
+              /***/
+              4769: (
+                /***/
+                function(module22) {
+                  function dcubicHermite(p0, v0, p1, v1, t4, f2) {
+                    var dh00 = 6 * t4 * t4 - 6 * t4, dh10 = 3 * t4 * t4 - 4 * t4 + 1, dh01 = -6 * t4 * t4 + 6 * t4, dh11 = 3 * t4 * t4 - 2 * t4;
+                    if (p0.length) {
+                      if (!f2) {
+                        f2 = new Array(p0.length);
+                      }
+                      for (var i2 = p0.length - 1; i2 >= 0; --i2) {
+                        f2[i2] = dh00 * p0[i2] + dh10 * v0[i2] + dh01 * p1[i2] + dh11 * v1[i2];
+                      }
+                      return f2;
+                    }
+                    return dh00 * p0 + dh10 * v0 + dh01 * p1[i2] + dh11 * v1;
+                  }
+                  function cubicHermite(p0, v0, p1, v1, t4, f2) {
+                    var ti2 = t4 - 1, t22 = t4 * t4, ti22 = ti2 * ti2, h00 = (1 + 2 * t4) * ti22, h10 = t4 * ti22, h01 = t22 * (3 - 2 * t4), h11 = t22 * ti2;
+                    if (p0.length) {
+                      if (!f2) {
+                        f2 = new Array(p0.length);
+                      }
+                      for (var i2 = p0.length - 1; i2 >= 0; --i2) {
+                        f2[i2] = h00 * p0[i2] + h10 * v0[i2] + h01 * p1[i2] + h11 * v1[i2];
+                      }
+                      return f2;
+                    }
+                    return h00 * p0 + h10 * v0 + h01 * p1 + h11 * v1;
+                  }
+                  module22.exports = cubicHermite;
+                  module22.exports.derivative = dcubicHermite;
+                }
+              ),
+              /***/
+              4772: (
+                /***/
+                function(module22) {
+                  module22.exports = perspective2;
+                  function perspective2(out, fovy, aspect, near, far) {
+                    var f2 = 1 / Math.tan(fovy / 2), nf2 = 1 / (near - far);
+                    out[0] = f2 / aspect;
+                    out[1] = 0;
+                    out[2] = 0;
+                    out[3] = 0;
+                    out[4] = 0;
+                    out[5] = f2;
+                    out[6] = 0;
+                    out[7] = 0;
+                    out[8] = 0;
+                    out[9] = 0;
+                    out[10] = (far + near) * nf2;
+                    out[11] = -1;
+                    out[12] = 0;
+                    out[13] = 0;
+                    out[14] = 2 * far * near * nf2;
+                    out[15] = 0;
+                    return out;
+                  }
+                }
+              ),
+              /***/
+              4793: (
+                /***/
+                function(__unused_webpack_module, exports2, __webpack_require__2) {
+                  function _classCallCheck(a2, n2) {
+                    if (!(a2 instanceof n2)) throw new TypeError("Cannot call a class as a function");
+                  }
+                  function _defineProperties(e2, r2) {
+                    for (var t4 = 0; t4 < r2.length; t4++) {
+                      var o2 = r2[t4];
+                      o2.enumerable = o2.enumerable || false, o2.configurable = true, "value" in o2 && (o2.writable = true), Object.defineProperty(e2, _toPropertyKey(o2.key), o2);
+                    }
+                  }
+                  function _createClass(e2, r2, t4) {
+                    return r2 && _defineProperties(e2.prototype, r2), Object.defineProperty(e2, "prototype", { writable: false }), e2;
+                  }
+                  function _toPropertyKey(t4) {
+                    var i2 = _toPrimitive(t4, "string");
+                    return "symbol" == _typeof(i2) ? i2 : i2 + "";
+                  }
+                  function _toPrimitive(t4, r2) {
+                    if ("object" != _typeof(t4) || !t4) return t4;
+                    var e2 = t4[Symbol.toPrimitive];
+                    if (void 0 !== e2) {
+                      var i2 = e2.call(t4, r2);
+                      if ("object" != _typeof(i2)) return i2;
+                      throw new TypeError("@@toPrimitive must return a primitive value.");
+                    }
+                    return String(t4);
+                  }
+                  function _callSuper(t4, o2, e2) {
+                    return o2 = _getPrototypeOf(o2), _possibleConstructorReturn(t4, _isNativeReflectConstruct() ? Reflect.construct(o2, [], _getPrototypeOf(t4).constructor) : o2.apply(t4, e2));
+                  }
+                  function _possibleConstructorReturn(t4, e2) {
+                    if (e2 && ("object" == _typeof(e2) || "function" == typeof e2)) return e2;
+                    if (void 0 !== e2) throw new TypeError("Derived constructors may only return object or undefined");
+                    return _assertThisInitialized(t4);
+                  }
+                  function _assertThisInitialized(e2) {
+                    if (void 0 === e2) throw new ReferenceError("this hasn't been initialised - super() hasn't been called");
+                    return e2;
+                  }
+                  function _isNativeReflectConstruct() {
+                    try {
+                      var t4 = !Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function() {
+                      }));
+                    } catch (t42) {
+                    }
+                    return (_isNativeReflectConstruct = function _isNativeReflectConstruct2() {
+                      return !!t4;
+                    })();
+                  }
+                  function _getPrototypeOf(t4) {
+                    return _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf.bind() : function(t42) {
+                      return t42.__proto__ || Object.getPrototypeOf(t42);
+                    }, _getPrototypeOf(t4);
+                  }
+                  function _inherits(t4, e2) {
+                    if ("function" != typeof e2 && null !== e2) throw new TypeError("Super expression must either be null or a function");
+                    t4.prototype = Object.create(e2 && e2.prototype, { constructor: { value: t4, writable: true, configurable: true } }), Object.defineProperty(t4, "prototype", { writable: false }), e2 && _setPrototypeOf(t4, e2);
+                  }
+                  function _setPrototypeOf(t4, e2) {
+                    return _setPrototypeOf = Object.setPrototypeOf ? Object.setPrototypeOf.bind() : function(t42, e22) {
+                      return t42.__proto__ = e22, t42;
+                    }, _setPrototypeOf(t4, e2);
+                  }
+                  function _typeof(o2) {
+                    "@babel/helpers - typeof";
+                    return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function(o22) {
+                      return typeof o22;
+                    } : function(o22) {
+                      return o22 && "function" == typeof Symbol && o22.constructor === Symbol && o22 !== Symbol.prototype ? "symbol" : typeof o22;
+                    }, _typeof(o2);
+                  }
+                  var base64 = __webpack_require__2(7507);
+                  var ieee754 = __webpack_require__2(3778);
+                  var customInspectSymbol = typeof Symbol === "function" && typeof Symbol["for"] === "function" ? Symbol["for"]("nodejs.util.inspect.custom") : null;
+                  exports2.hp = Buffer22;
+                  exports2.IS = 50;
+                  var K_MAX_LENGTH = 2147483647;
+                  Buffer22.TYPED_ARRAY_SUPPORT = typedArraySupport();
+                  if (!Buffer22.TYPED_ARRAY_SUPPORT && typeof console !== "undefined" && typeof console.error === "function") {
+                    console.error("This browser lacks typed array (Uint8Array) support which is required by `buffer` v5.x. Use `buffer` v4.x if you require old browser support.");
+                  }
+                  function typedArraySupport() {
+                    try {
+                      var arr = new Uint8Array(1);
+                      var proto = {
+                        foo: function foo() {
+                          return 42;
+                        }
+                      };
+                      Object.setPrototypeOf(proto, Uint8Array.prototype);
+                      Object.setPrototypeOf(arr, proto);
+                      return arr.foo() === 42;
+                    } catch (e2) {
+                      return false;
+                    }
+                  }
+                  Object.defineProperty(Buffer22.prototype, "parent", {
+                    enumerable: true,
+                    get: function get() {
+                      if (!Buffer22.isBuffer(this)) return void 0;
+                      return this.buffer;
+                    }
+                  });
+                  Object.defineProperty(Buffer22.prototype, "offset", {
+                    enumerable: true,
+                    get: function get() {
+                      if (!Buffer22.isBuffer(this)) return void 0;
+                      return this.byteOffset;
+                    }
+                  });
+                  function createBuffer(length2) {
+                    if (length2 > K_MAX_LENGTH) {
+                      throw new RangeError('The value "' + length2 + '" is invalid for option "size"');
+                    }
+                    var buf = new Uint8Array(length2);
+                    Object.setPrototypeOf(buf, Buffer22.prototype);
+                    return buf;
+                  }
+                  function Buffer22(arg, encodingOrOffset, length2) {
+                    if (typeof arg === "number") {
+                      if (typeof encodingOrOffset === "string") {
+                        throw new TypeError('The "string" argument must be of type string. Received type number');
+                      }
+                      return allocUnsafe(arg);
+                    }
+                    return from(arg, encodingOrOffset, length2);
+                  }
+                  Buffer22.poolSize = 8192;
+                  function from(value, encodingOrOffset, length2) {
+                    if (typeof value === "string") {
+                      return fromString(value, encodingOrOffset);
+                    }
+                    if (ArrayBuffer.isView(value)) {
+                      return fromArrayView(value);
+                    }
+                    if (value == null) {
+                      throw new TypeError("The first argument must be one of type string, Buffer, ArrayBuffer, Array, or Array-like Object. Received type " + _typeof(value));
+                    }
+                    if (isInstance(value, ArrayBuffer) || value && isInstance(value.buffer, ArrayBuffer)) {
+                      return fromArrayBuffer(value, encodingOrOffset, length2);
+                    }
+                    if (typeof SharedArrayBuffer !== "undefined" && (isInstance(value, SharedArrayBuffer) || value && isInstance(value.buffer, SharedArrayBuffer))) {
+                      return fromArrayBuffer(value, encodingOrOffset, length2);
+                    }
+                    if (typeof value === "number") {
+                      throw new TypeError('The "value" argument must not be of type number. Received type number');
+                    }
+                    var valueOf = value.valueOf && value.valueOf();
+                    if (valueOf != null && valueOf !== value) {
+                      return Buffer22.from(valueOf, encodingOrOffset, length2);
+                    }
+                    var b2 = fromObject(value);
+                    if (b2) return b2;
+                    if (typeof Symbol !== "undefined" && Symbol.toPrimitive != null && typeof value[Symbol.toPrimitive] === "function") {
+                      return Buffer22.from(value[Symbol.toPrimitive]("string"), encodingOrOffset, length2);
+                    }
+                    throw new TypeError("The first argument must be one of type string, Buffer, ArrayBuffer, Array, or Array-like Object. Received type " + _typeof(value));
+                  }
+                  Buffer22.from = function(value, encodingOrOffset, length2) {
+                    return from(value, encodingOrOffset, length2);
+                  };
+                  Object.setPrototypeOf(Buffer22.prototype, Uint8Array.prototype);
+                  Object.setPrototypeOf(Buffer22, Uint8Array);
+                  function assertSize(size) {
+                    if (typeof size !== "number") {
+                      throw new TypeError('"size" argument must be of type number');
+                    } else if (size < 0) {
+                      throw new RangeError('The value "' + size + '" is invalid for option "size"');
+                    }
+                  }
+                  function alloc(size, fill, encoding) {
+                    assertSize(size);
+                    if (size <= 0) {
+                      return createBuffer(size);
+                    }
+                    if (fill !== void 0) {
+                      return typeof encoding === "string" ? createBuffer(size).fill(fill, encoding) : createBuffer(size).fill(fill);
+                    }
+                    return createBuffer(size);
+                  }
+                  Buffer22.alloc = function(size, fill, encoding) {
+                    return alloc(size, fill, encoding);
+                  };
+                  function allocUnsafe(size) {
+                    assertSize(size);
+                    return createBuffer(size < 0 ? 0 : checked(size) | 0);
+                  }
+                  Buffer22.allocUnsafe = function(size) {
+                    return allocUnsafe(size);
+                  };
+                  Buffer22.allocUnsafeSlow = function(size) {
+                    return allocUnsafe(size);
+                  };
+                  function fromString(string, encoding) {
+                    if (typeof encoding !== "string" || encoding === "") {
+                      encoding = "utf8";
+                    }
+                    if (!Buffer22.isEncoding(encoding)) {
+                      throw new TypeError("Unknown encoding: " + encoding);
+                    }
+                    var length2 = byteLength(string, encoding) | 0;
+                    var buf = createBuffer(length2);
+                    var actual = buf.write(string, encoding);
+                    if (actual !== length2) {
+                      buf = buf.slice(0, actual);
+                    }
+                    return buf;
+                  }
+                  function fromArrayLike(array) {
+                    var length2 = array.length < 0 ? 0 : checked(array.length) | 0;
+                    var buf = createBuffer(length2);
+                    for (var i2 = 0; i2 < length2; i2 += 1) {
+                      buf[i2] = array[i2] & 255;
+                    }
+                    return buf;
+                  }
+                  function fromArrayView(arrayView) {
+                    if (isInstance(arrayView, Uint8Array)) {
+                      var copy = new Uint8Array(arrayView);
+                      return fromArrayBuffer(copy.buffer, copy.byteOffset, copy.byteLength);
+                    }
+                    return fromArrayLike(arrayView);
+                  }
+                  function fromArrayBuffer(array, byteOffset, length2) {
+                    if (byteOffset < 0 || array.byteLength < byteOffset) {
+                      throw new RangeError('"offset" is outside of buffer bounds');
+                    }
+                    if (array.byteLength < byteOffset + (length2 || 0)) {
+                      throw new RangeError('"length" is outside of buffer bounds');
+                    }
+                    var buf;
+                    if (byteOffset === void 0 && length2 === void 0) {
+                      buf = new Uint8Array(array);
+                    } else if (length2 === void 0) {
+                      buf = new Uint8Array(array, byteOffset);
+                    } else {
+                      buf = new Uint8Array(array, byteOffset, length2);
+                    }
+                    Object.setPrototypeOf(buf, Buffer22.prototype);
+                    return buf;
+                  }
+                  function fromObject(obj) {
+                    if (Buffer22.isBuffer(obj)) {
+                      var len2 = checked(obj.length) | 0;
+                      var buf = createBuffer(len2);
+                      if (buf.length === 0) {
+                        return buf;
+                      }
+                      obj.copy(buf, 0, 0, len2);
+                      return buf;
+                    }
+                    if (obj.length !== void 0) {
+                      if (typeof obj.length !== "number" || numberIsNaN(obj.length)) {
+                        return createBuffer(0);
+                      }
+                      return fromArrayLike(obj);
+                    }
+                    if (obj.type === "Buffer" && Array.isArray(obj.data)) {
+                      return fromArrayLike(obj.data);
+                    }
+                  }
+                  function checked(length2) {
+                    if (length2 >= K_MAX_LENGTH) {
+                      throw new RangeError("Attempt to allocate Buffer larger than maximum size: 0x" + K_MAX_LENGTH.toString(16) + " bytes");
+                    }
+                    return length2 | 0;
+                  }
+                  Buffer22.isBuffer = function isBuffer2(b2) {
+                    return b2 != null && b2._isBuffer === true && b2 !== Buffer22.prototype;
+                  };
+                  Buffer22.compare = function compare(a2, b2) {
+                    if (isInstance(a2, Uint8Array)) a2 = Buffer22.from(a2, a2.offset, a2.byteLength);
+                    if (isInstance(b2, Uint8Array)) b2 = Buffer22.from(b2, b2.offset, b2.byteLength);
+                    if (!Buffer22.isBuffer(a2) || !Buffer22.isBuffer(b2)) {
+                      throw new TypeError('The "buf1", "buf2" arguments must be one of type Buffer or Uint8Array');
+                    }
+                    if (a2 === b2) return 0;
+                    var x2 = a2.length;
+                    var y2 = b2.length;
+                    for (var i2 = 0, len2 = Math.min(x2, y2); i2 < len2; ++i2) {
+                      if (a2[i2] !== b2[i2]) {
+                        x2 = a2[i2];
+                        y2 = b2[i2];
+                        break;
+                      }
+                    }
+                    if (x2 < y2) return -1;
+                    if (y2 < x2) return 1;
+                    return 0;
+                  };
+                  Buffer22.isEncoding = function isEncoding(encoding) {
+                    switch (String(encoding).toLowerCase()) {
+                      case "hex":
+                      case "utf8":
+                      case "utf-8":
+                      case "ascii":
+                      case "latin1":
+                      case "binary":
+                      case "base64":
+                      case "ucs2":
+                      case "ucs-2":
+                      case "utf16le":
+                      case "utf-16le":
+                        return true;
+                      default:
+                        return false;
+                    }
+                  };
+                  Buffer22.concat = function concat(list, length2) {
+                    if (!Array.isArray(list)) {
+                      throw new TypeError('"list" argument must be an Array of Buffers');
+                    }
+                    if (list.length === 0) {
+                      return Buffer22.alloc(0);
+                    }
+                    var i2;
+                    if (length2 === void 0) {
+                      length2 = 0;
+                      for (i2 = 0; i2 < list.length; ++i2) {
+                        length2 += list[i2].length;
+                      }
+                    }
+                    var buffer = Buffer22.allocUnsafe(length2);
+                    var pos = 0;
+                    for (i2 = 0; i2 < list.length; ++i2) {
+                      var buf = list[i2];
+                      if (isInstance(buf, Uint8Array)) {
+                        if (pos + buf.length > buffer.length) {
+                          if (!Buffer22.isBuffer(buf)) buf = Buffer22.from(buf);
+                          buf.copy(buffer, pos);
+                        } else {
+                          Uint8Array.prototype.set.call(buffer, buf, pos);
+                        }
+                      } else if (!Buffer22.isBuffer(buf)) {
+                        throw new TypeError('"list" argument must be an Array of Buffers');
+                      } else {
+                        buf.copy(buffer, pos);
+                      }
+                      pos += buf.length;
+                    }
+                    return buffer;
+                  };
+                  function byteLength(string, encoding) {
+                    if (Buffer22.isBuffer(string)) {
+                      return string.length;
+                    }
+                    if (ArrayBuffer.isView(string) || isInstance(string, ArrayBuffer)) {
+                      return string.byteLength;
+                    }
+                    if (typeof string !== "string") {
+                      throw new TypeError('The "string" argument must be one of type string, Buffer, or ArrayBuffer. Received type ' + _typeof(string));
+                    }
+                    var len2 = string.length;
+                    var mustMatch = arguments.length > 2 && arguments[2] === true;
+                    if (!mustMatch && len2 === 0) return 0;
+                    var loweredCase = false;
+                    for (; ; ) {
+                      switch (encoding) {
+                        case "ascii":
+                        case "latin1":
+                        case "binary":
+                          return len2;
+                        case "utf8":
+                        case "utf-8":
+                          return utf8ToBytes(string).length;
+                        case "ucs2":
+                        case "ucs-2":
+                        case "utf16le":
+                        case "utf-16le":
+                          return len2 * 2;
+                        case "hex":
+                          return len2 >>> 1;
+                        case "base64":
+                          return base64ToBytes(string).length;
+                        default:
+                          if (loweredCase) {
+                            return mustMatch ? -1 : utf8ToBytes(string).length;
+                          }
+                          encoding = ("" + encoding).toLowerCase();
+                          loweredCase = true;
+                      }
+                    }
+                  }
+                  Buffer22.byteLength = byteLength;
+                  function slowToString(encoding, start, end) {
+                    var loweredCase = false;
+                    if (start === void 0 || start < 0) {
+                      start = 0;
+                    }
+                    if (start > this.length) {
+                      return "";
+                    }
+                    if (end === void 0 || end > this.length) {
+                      end = this.length;
+                    }
+                    if (end <= 0) {
+                      return "";
+                    }
+                    end >>>= 0;
+                    start >>>= 0;
+                    if (end <= start) {
+                      return "";
+                    }
+                    if (!encoding) encoding = "utf8";
+                    while (true) {
+                      switch (encoding) {
+                        case "hex":
+                          return hexSlice(this, start, end);
+                        case "utf8":
+                        case "utf-8":
+                          return utf8Slice(this, start, end);
+                        case "ascii":
+                          return asciiSlice(this, start, end);
+                        case "latin1":
+                        case "binary":
+                          return latin1Slice(this, start, end);
+                        case "base64":
+                          return base64Slice(this, start, end);
+                        case "ucs2":
+                        case "ucs-2":
+                        case "utf16le":
+                        case "utf-16le":
+                          return utf16leSlice(this, start, end);
+                        default:
+                          if (loweredCase) throw new TypeError("Unknown encoding: " + encoding);
+                          encoding = (encoding + "").toLowerCase();
+                          loweredCase = true;
+                      }
+                    }
+                  }
+                  Buffer22.prototype._isBuffer = true;
+                  function swap(b2, n2, m2) {
+                    var i2 = b2[n2];
+                    b2[n2] = b2[m2];
+                    b2[m2] = i2;
+                  }
+                  Buffer22.prototype.swap16 = function swap16() {
+                    var len2 = this.length;
+                    if (len2 % 2 !== 0) {
+                      throw new RangeError("Buffer size must be a multiple of 16-bits");
+                    }
+                    for (var i2 = 0; i2 < len2; i2 += 2) {
+                      swap(this, i2, i2 + 1);
+                    }
+                    return this;
+                  };
+                  Buffer22.prototype.swap32 = function swap32() {
+                    var len2 = this.length;
+                    if (len2 % 4 !== 0) {
+                      throw new RangeError("Buffer size must be a multiple of 32-bits");
+                    }
+                    for (var i2 = 0; i2 < len2; i2 += 4) {
+                      swap(this, i2, i2 + 3);
+                      swap(this, i2 + 1, i2 + 2);
+                    }
+                    return this;
+                  };
+                  Buffer22.prototype.swap64 = function swap64() {
+                    var len2 = this.length;
+                    if (len2 % 8 !== 0) {
+                      throw new RangeError("Buffer size must be a multiple of 64-bits");
+                    }
+                    for (var i2 = 0; i2 < len2; i2 += 8) {
+                      swap(this, i2, i2 + 7);
+                      swap(this, i2 + 1, i2 + 6);
+                      swap(this, i2 + 2, i2 + 5);
+                      swap(this, i2 + 3, i2 + 4);
+                    }
+                    return this;
+                  };
+                  Buffer22.prototype.toString = function toString() {
+                    var length2 = this.length;
+                    if (length2 === 0) return "";
+                    if (arguments.length === 0) return utf8Slice(this, 0, length2);
+                    return slowToString.apply(this, arguments);
+                  };
+                  Buffer22.prototype.toLocaleString = Buffer22.prototype.toString;
+                  Buffer22.prototype.equals = function equals2(b2) {
+                    if (!Buffer22.isBuffer(b2)) throw new TypeError("Argument must be a Buffer");
+                    if (this === b2) return true;
+                    return Buffer22.compare(this, b2) === 0;
+                  };
+                  Buffer22.prototype.inspect = function inspect() {
+                    var str = "";
+                    var max = exports2.IS;
+                    str = this.toString("hex", 0, max).replace(/(.{2})/g, "$1 ").trim();
+                    if (this.length > max) str += " ... ";
+                    return "<Buffer " + str + ">";
+                  };
+                  if (customInspectSymbol) {
+                    Buffer22.prototype[customInspectSymbol] = Buffer22.prototype.inspect;
+                  }
+                  Buffer22.prototype.compare = function compare(target, start, end, thisStart, thisEnd) {
+                    if (isInstance(target, Uint8Array)) {
+                      target = Buffer22.from(target, target.offset, target.byteLength);
+                    }
+                    if (!Buffer22.isBuffer(target)) {
+                      throw new TypeError('The "target" argument must be one of type Buffer or Uint8Array. Received type ' + _typeof(target));
+                    }
+                    if (start === void 0) {
+                      start = 0;
+                    }
+                    if (end === void 0) {
+                      end = target ? target.length : 0;
+                    }
+                    if (thisStart === void 0) {
+                      thisStart = 0;
+                    }
+                    if (thisEnd === void 0) {
+                      thisEnd = this.length;
+                    }
+                    if (start < 0 || end > target.length || thisStart < 0 || thisEnd > this.length) {
+                      throw new RangeError("out of range index");
+                    }
+                    if (thisStart >= thisEnd && start >= end) {
+                      return 0;
+                    }
+                    if (thisStart >= thisEnd) {
+                      return -1;
+                    }
+                    if (start >= end) {
+                      return 1;
+                    }
+                    start >>>= 0;
+                    end >>>= 0;
+                    thisStart >>>= 0;
+                    thisEnd >>>= 0;
+                    if (this === target) return 0;
+                    var x2 = thisEnd - thisStart;
+                    var y2 = end - start;
+                    var len2 = Math.min(x2, y2);
+                    var thisCopy = this.slice(thisStart, thisEnd);
+                    var targetCopy = target.slice(start, end);
+                    for (var i2 = 0; i2 < len2; ++i2) {
+                      if (thisCopy[i2] !== targetCopy[i2]) {
+                        x2 = thisCopy[i2];
+                        y2 = targetCopy[i2];
+                        break;
+                      }
+                    }
+                    if (x2 < y2) return -1;
+                    if (y2 < x2) return 1;
+                    return 0;
+                  };
+                  function bidirectionalIndexOf(buffer, val, byteOffset, encoding, dir) {
+                    if (buffer.length === 0) return -1;
+                    if (typeof byteOffset === "string") {
+                      encoding = byteOffset;
+                      byteOffset = 0;
+                    } else if (byteOffset > 2147483647) {
+                      byteOffset = 2147483647;
+                    } else if (byteOffset < -2147483648) {
+                      byteOffset = -2147483648;
+                    }
+                    byteOffset = +byteOffset;
+                    if (numberIsNaN(byteOffset)) {
+                      byteOffset = dir ? 0 : buffer.length - 1;
+                    }
+                    if (byteOffset < 0) byteOffset = buffer.length + byteOffset;
+                    if (byteOffset >= buffer.length) {
+                      if (dir) return -1;
+                      else byteOffset = buffer.length - 1;
+                    } else if (byteOffset < 0) {
+                      if (dir) byteOffset = 0;
+                      else return -1;
+                    }
+                    if (typeof val === "string") {
+                      val = Buffer22.from(val, encoding);
+                    }
+                    if (Buffer22.isBuffer(val)) {
+                      if (val.length === 0) {
+                        return -1;
+                      }
+                      return arrayIndexOf(buffer, val, byteOffset, encoding, dir);
+                    } else if (typeof val === "number") {
+                      val = val & 255;
+                      if (typeof Uint8Array.prototype.indexOf === "function") {
+                        if (dir) {
+                          return Uint8Array.prototype.indexOf.call(buffer, val, byteOffset);
+                        } else {
+                          return Uint8Array.prototype.lastIndexOf.call(buffer, val, byteOffset);
+                        }
+                      }
+                      return arrayIndexOf(buffer, [val], byteOffset, encoding, dir);
+                    }
+                    throw new TypeError("val must be string, number or Buffer");
+                  }
+                  function arrayIndexOf(arr, val, byteOffset, encoding, dir) {
+                    var indexSize = 1;
+                    var arrLength = arr.length;
+                    var valLength = val.length;
+                    if (encoding !== void 0) {
+                      encoding = String(encoding).toLowerCase();
+                      if (encoding === "ucs2" || encoding === "ucs-2" || encoding === "utf16le" || encoding === "utf-16le") {
+                        if (arr.length < 2 || val.length < 2) {
+                          return -1;
+                        }
+                        indexSize = 2;
+                        arrLength /= 2;
+                        valLength /= 2;
+                        byteOffset /= 2;
+                      }
+                    }
+                    function read(buf, i22) {
+                      if (indexSize === 1) {
+                        return buf[i22];
+                      } else {
+                        return buf.readUInt16BE(i22 * indexSize);
+                      }
+                    }
+                    var i2;
+                    if (dir) {
+                      var foundIndex = -1;
+                      for (i2 = byteOffset; i2 < arrLength; i2++) {
+                        if (read(arr, i2) === read(val, foundIndex === -1 ? 0 : i2 - foundIndex)) {
+                          if (foundIndex === -1) foundIndex = i2;
+                          if (i2 - foundIndex + 1 === valLength) return foundIndex * indexSize;
+                        } else {
+                          if (foundIndex !== -1) i2 -= i2 - foundIndex;
+                          foundIndex = -1;
+                        }
+                      }
+                    } else {
+                      if (byteOffset + valLength > arrLength) byteOffset = arrLength - valLength;
+                      for (i2 = byteOffset; i2 >= 0; i2--) {
+                        var found = true;
+                        for (var j2 = 0; j2 < valLength; j2++) {
+                          if (read(arr, i2 + j2) !== read(val, j2)) {
+                            found = false;
+                            break;
+                          }
+                        }
+                        if (found) return i2;
+                      }
+                    }
+                    return -1;
+                  }
+                  Buffer22.prototype.includes = function includes(val, byteOffset, encoding) {
+                    return this.indexOf(val, byteOffset, encoding) !== -1;
+                  };
+                  Buffer22.prototype.indexOf = function indexOf(val, byteOffset, encoding) {
+                    return bidirectionalIndexOf(this, val, byteOffset, encoding, true);
+                  };
+                  Buffer22.prototype.lastIndexOf = function lastIndexOf(val, byteOffset, encoding) {
+                    return bidirectionalIndexOf(this, val, byteOffset, encoding, false);
+                  };
+                  function hexWrite(buf, string, offset, length2) {
+                    offset = Number(offset) || 0;
+                    var remaining = buf.length - offset;
+                    if (!length2) {
+                      length2 = remaining;
+                    } else {
+                      length2 = Number(length2);
+                      if (length2 > remaining) {
+                        length2 = remaining;
+                      }
+                    }
+                    var strLen = string.length;
+                    if (length2 > strLen / 2) {
+                      length2 = strLen / 2;
+                    }
+                    var i2;
+                    for (i2 = 0; i2 < length2; ++i2) {
+                      var parsed = parseInt(string.substr(i2 * 2, 2), 16);
+                      if (numberIsNaN(parsed)) return i2;
+                      buf[offset + i2] = parsed;
+                    }
+                    return i2;
+                  }
+                  function utf8Write(buf, string, offset, length2) {
+                    return blitBuffer(utf8ToBytes(string, buf.length - offset), buf, offset, length2);
+                  }
+                  function asciiWrite(buf, string, offset, length2) {
+                    return blitBuffer(asciiToBytes(string), buf, offset, length2);
+                  }
+                  function base64Write(buf, string, offset, length2) {
+                    return blitBuffer(base64ToBytes(string), buf, offset, length2);
+                  }
+                  function ucs2Write(buf, string, offset, length2) {
+                    return blitBuffer(utf16leToBytes(string, buf.length - offset), buf, offset, length2);
+                  }
+                  Buffer22.prototype.write = function write(string, offset, length2, encoding) {
+                    if (offset === void 0) {
+                      encoding = "utf8";
+                      length2 = this.length;
+                      offset = 0;
+                    } else if (length2 === void 0 && typeof offset === "string") {
+                      encoding = offset;
+                      length2 = this.length;
+                      offset = 0;
+                    } else if (isFinite(offset)) {
+                      offset = offset >>> 0;
+                      if (isFinite(length2)) {
+                        length2 = length2 >>> 0;
+                        if (encoding === void 0) encoding = "utf8";
+                      } else {
+                        encoding = length2;
+                        length2 = void 0;
+                      }
+                    } else {
+                      throw new Error("Buffer.write(string, encoding, offset[, length]) is no longer supported");
+                    }
+                    var remaining = this.length - offset;
+                    if (length2 === void 0 || length2 > remaining) length2 = remaining;
+                    if (string.length > 0 && (length2 < 0 || offset < 0) || offset > this.length) {
+                      throw new RangeError("Attempt to write outside buffer bounds");
+                    }
+                    if (!encoding) encoding = "utf8";
+                    var loweredCase = false;
+                    for (; ; ) {
+                      switch (encoding) {
+                        case "hex":
+                          return hexWrite(this, string, offset, length2);
+                        case "utf8":
+                        case "utf-8":
+                          return utf8Write(this, string, offset, length2);
+                        case "ascii":
+                        case "latin1":
+                        case "binary":
+                          return asciiWrite(this, string, offset, length2);
+                        case "base64":
+                          return base64Write(this, string, offset, length2);
+                        case "ucs2":
+                        case "ucs-2":
+                        case "utf16le":
+                        case "utf-16le":
+                          return ucs2Write(this, string, offset, length2);
+                        default:
+                          if (loweredCase) throw new TypeError("Unknown encoding: " + encoding);
+                          encoding = ("" + encoding).toLowerCase();
+                          loweredCase = true;
+                      }
+                    }
+                  };
+                  Buffer22.prototype.toJSON = function toJSON() {
+                    return {
+                      type: "Buffer",
+                      data: Array.prototype.slice.call(this._arr || this, 0)
+                    };
+                  };
+                  function base64Slice(buf, start, end) {
+                    if (start === 0 && end === buf.length) {
+                      return base64.fromByteArray(buf);
+                    } else {
+                      return base64.fromByteArray(buf.slice(start, end));
+                    }
+                  }
+                  function utf8Slice(buf, start, end) {
+                    end = Math.min(buf.length, end);
+                    var res = [];
+                    var i2 = start;
+                    while (i2 < end) {
+                      var firstByte = buf[i2];
+                      var codePoint = null;
+                      var bytesPerSequence = firstByte > 239 ? 4 : firstByte > 223 ? 3 : firstByte > 191 ? 2 : 1;
+                      if (i2 + bytesPerSequence <= end) {
+                        var secondByte = void 0, thirdByte = void 0, fourthByte = void 0, tempCodePoint = void 0;
+                        switch (bytesPerSequence) {
+                          case 1:
+                            if (firstByte < 128) {
+                              codePoint = firstByte;
+                            }
+                            break;
+                          case 2:
+                            secondByte = buf[i2 + 1];
+                            if ((secondByte & 192) === 128) {
+                              tempCodePoint = (firstByte & 31) << 6 | secondByte & 63;
+                              if (tempCodePoint > 127) {
+                                codePoint = tempCodePoint;
+                              }
+                            }
+                            break;
+                          case 3:
+                            secondByte = buf[i2 + 1];
+                            thirdByte = buf[i2 + 2];
+                            if ((secondByte & 192) === 128 && (thirdByte & 192) === 128) {
+                              tempCodePoint = (firstByte & 15) << 12 | (secondByte & 63) << 6 | thirdByte & 63;
+                              if (tempCodePoint > 2047 && (tempCodePoint < 55296 || tempCodePoint > 57343)) {
+                                codePoint = tempCodePoint;
+                              }
+                            }
+                            break;
+                          case 4:
+                            secondByte = buf[i2 + 1];
+                            thirdByte = buf[i2 + 2];
+                            fourthByte = buf[i2 + 3];
+                            if ((secondByte & 192) === 128 && (thirdByte & 192) === 128 && (fourthByte & 192) === 128) {
+                              tempCodePoint = (firstByte & 15) << 18 | (secondByte & 63) << 12 | (thirdByte & 63) << 6 | fourthByte & 63;
+                              if (tempCodePoint > 65535 && tempCodePoint < 1114112) {
+                                codePoint = tempCodePoint;
+                              }
+                            }
+                        }
+                      }
+                      if (codePoint === null) {
+                        codePoint = 65533;
+                        bytesPerSequence = 1;
+                      } else if (codePoint > 65535) {
+                        codePoint -= 65536;
+                        res.push(codePoint >>> 10 & 1023 | 55296);
+                        codePoint = 56320 | codePoint & 1023;
+                      }
+                      res.push(codePoint);
+                      i2 += bytesPerSequence;
+                    }
+                    return decodeCodePointsArray(res);
+                  }
+                  var MAX_ARGUMENTS_LENGTH = 4096;
+                  function decodeCodePointsArray(codePoints) {
+                    var len2 = codePoints.length;
+                    if (len2 <= MAX_ARGUMENTS_LENGTH) {
+                      return String.fromCharCode.apply(String, codePoints);
+                    }
+                    var res = "";
+                    var i2 = 0;
+                    while (i2 < len2) {
+                      res += String.fromCharCode.apply(String, codePoints.slice(i2, i2 += MAX_ARGUMENTS_LENGTH));
+                    }
+                    return res;
+                  }
+                  function asciiSlice(buf, start, end) {
+                    var ret = "";
+                    end = Math.min(buf.length, end);
+                    for (var i2 = start; i2 < end; ++i2) {
+                      ret += String.fromCharCode(buf[i2] & 127);
+                    }
+                    return ret;
+                  }
+                  function latin1Slice(buf, start, end) {
+                    var ret = "";
+                    end = Math.min(buf.length, end);
+                    for (var i2 = start; i2 < end; ++i2) {
+                      ret += String.fromCharCode(buf[i2]);
+                    }
+                    return ret;
+                  }
+                  function hexSlice(buf, start, end) {
+                    var len2 = buf.length;
+                    if (!start || start < 0) start = 0;
+                    if (!end || end < 0 || end > len2) end = len2;
+                    var out = "";
+                    for (var i2 = start; i2 < end; ++i2) {
+                      out += hexSliceLookupTable[buf[i2]];
+                    }
+                    return out;
+                  }
+                  function utf16leSlice(buf, start, end) {
+                    var bytes = buf.slice(start, end);
+                    var res = "";
+                    for (var i2 = 0; i2 < bytes.length - 1; i2 += 2) {
+                      res += String.fromCharCode(bytes[i2] + bytes[i2 + 1] * 256);
+                    }
+                    return res;
+                  }
+                  Buffer22.prototype.slice = function slice(start, end) {
+                    var len2 = this.length;
+                    start = ~~start;
+                    end = end === void 0 ? len2 : ~~end;
+                    if (start < 0) {
+                      start += len2;
+                      if (start < 0) start = 0;
+                    } else if (start > len2) {
+                      start = len2;
+                    }
+                    if (end < 0) {
+                      end += len2;
+                      if (end < 0) end = 0;
+                    } else if (end > len2) {
+                      end = len2;
+                    }
+                    if (end < start) end = start;
+                    var newBuf = this.subarray(start, end);
+                    Object.setPrototypeOf(newBuf, Buffer22.prototype);
+                    return newBuf;
+                  };
+                  function checkOffset(offset, ext, length2) {
+                    if (offset % 1 !== 0 || offset < 0) throw new RangeError("offset is not uint");
+                    if (offset + ext > length2) throw new RangeError("Trying to access beyond buffer length");
+                  }
+                  Buffer22.prototype.readUintLE = Buffer22.prototype.readUIntLE = function readUIntLE(offset, byteLength2, noAssert) {
+                    offset = offset >>> 0;
+                    byteLength2 = byteLength2 >>> 0;
+                    if (!noAssert) checkOffset(offset, byteLength2, this.length);
+                    var val = this[offset];
+                    var mul = 1;
+                    var i2 = 0;
+                    while (++i2 < byteLength2 && (mul *= 256)) {
+                      val += this[offset + i2] * mul;
+                    }
+                    return val;
+                  };
+                  Buffer22.prototype.readUintBE = Buffer22.prototype.readUIntBE = function readUIntBE(offset, byteLength2, noAssert) {
+                    offset = offset >>> 0;
+                    byteLength2 = byteLength2 >>> 0;
+                    if (!noAssert) {
+                      checkOffset(offset, byteLength2, this.length);
+                    }
+                    var val = this[offset + --byteLength2];
+                    var mul = 1;
+                    while (byteLength2 > 0 && (mul *= 256)) {
+                      val += this[offset + --byteLength2] * mul;
+                    }
+                    return val;
+                  };
+                  Buffer22.prototype.readUint8 = Buffer22.prototype.readUInt8 = function readUInt8(offset, noAssert) {
+                    offset = offset >>> 0;
+                    if (!noAssert) checkOffset(offset, 1, this.length);
+                    return this[offset];
+                  };
+                  Buffer22.prototype.readUint16LE = Buffer22.prototype.readUInt16LE = function readUInt16LE(offset, noAssert) {
+                    offset = offset >>> 0;
+                    if (!noAssert) checkOffset(offset, 2, this.length);
+                    return this[offset] | this[offset + 1] << 8;
+                  };
+                  Buffer22.prototype.readUint16BE = Buffer22.prototype.readUInt16BE = function readUInt16BE(offset, noAssert) {
+                    offset = offset >>> 0;
+                    if (!noAssert) checkOffset(offset, 2, this.length);
+                    return this[offset] << 8 | this[offset + 1];
+                  };
+                  Buffer22.prototype.readUint32LE = Buffer22.prototype.readUInt32LE = function readUInt32LE(offset, noAssert) {
+                    offset = offset >>> 0;
+                    if (!noAssert) checkOffset(offset, 4, this.length);
+                    return (this[offset] | this[offset + 1] << 8 | this[offset + 2] << 16) + this[offset + 3] * 16777216;
+                  };
+                  Buffer22.prototype.readUint32BE = Buffer22.prototype.readUInt32BE = function readUInt32BE(offset, noAssert) {
+                    offset = offset >>> 0;
+                    if (!noAssert) checkOffset(offset, 4, this.length);
+                    return this[offset] * 16777216 + (this[offset + 1] << 16 | this[offset + 2] << 8 | this[offset + 3]);
+                  };
+                  Buffer22.prototype.readBigUInt64LE = defineBigIntMethod(function readBigUInt64LE(offset) {
+                    offset = offset >>> 0;
+                    validateNumber(offset, "offset");
+                    var first = this[offset];
+                    var last = this[offset + 7];
+                    if (first === void 0 || last === void 0) {
+                      boundsError(offset, this.length - 8);
+                    }
+                    var lo = first + this[++offset] * Math.pow(2, 8) + this[++offset] * Math.pow(2, 16) + this[++offset] * Math.pow(2, 24);
+                    var hi2 = this[++offset] + this[++offset] * Math.pow(2, 8) + this[++offset] * Math.pow(2, 16) + last * Math.pow(2, 24);
+                    return BigInt(lo) + (BigInt(hi2) << BigInt(32));
+                  });
+                  Buffer22.prototype.readBigUInt64BE = defineBigIntMethod(function readBigUInt64BE(offset) {
+                    offset = offset >>> 0;
+                    validateNumber(offset, "offset");
+                    var first = this[offset];
+                    var last = this[offset + 7];
+                    if (first === void 0 || last === void 0) {
+                      boundsError(offset, this.length - 8);
+                    }
+                    var hi2 = first * Math.pow(2, 24) + this[++offset] * Math.pow(2, 16) + this[++offset] * Math.pow(2, 8) + this[++offset];
+                    var lo = this[++offset] * Math.pow(2, 24) + this[++offset] * Math.pow(2, 16) + this[++offset] * Math.pow(2, 8) + last;
+                    return (BigInt(hi2) << BigInt(32)) + BigInt(lo);
+                  });
+                  Buffer22.prototype.readIntLE = function readIntLE(offset, byteLength2, noAssert) {
+                    offset = offset >>> 0;
+                    byteLength2 = byteLength2 >>> 0;
+                    if (!noAssert) checkOffset(offset, byteLength2, this.length);
+                    var val = this[offset];
+                    var mul = 1;
+                    var i2 = 0;
+                    while (++i2 < byteLength2 && (mul *= 256)) {
+                      val += this[offset + i2] * mul;
+                    }
+                    mul *= 128;
+                    if (val >= mul) val -= Math.pow(2, 8 * byteLength2);
+                    return val;
+                  };
+                  Buffer22.prototype.readIntBE = function readIntBE(offset, byteLength2, noAssert) {
+                    offset = offset >>> 0;
+                    byteLength2 = byteLength2 >>> 0;
+                    if (!noAssert) checkOffset(offset, byteLength2, this.length);
+                    var i2 = byteLength2;
+                    var mul = 1;
+                    var val = this[offset + --i2];
+                    while (i2 > 0 && (mul *= 256)) {
+                      val += this[offset + --i2] * mul;
+                    }
+                    mul *= 128;
+                    if (val >= mul) val -= Math.pow(2, 8 * byteLength2);
+                    return val;
+                  };
+                  Buffer22.prototype.readInt8 = function readInt8(offset, noAssert) {
+                    offset = offset >>> 0;
+                    if (!noAssert) checkOffset(offset, 1, this.length);
+                    if (!(this[offset] & 128)) return this[offset];
+                    return (255 - this[offset] + 1) * -1;
+                  };
+                  Buffer22.prototype.readInt16LE = function readInt16LE(offset, noAssert) {
+                    offset = offset >>> 0;
+                    if (!noAssert) checkOffset(offset, 2, this.length);
+                    var val = this[offset] | this[offset + 1] << 8;
+                    return val & 32768 ? val | 4294901760 : val;
+                  };
+                  Buffer22.prototype.readInt16BE = function readInt16BE(offset, noAssert) {
+                    offset = offset >>> 0;
+                    if (!noAssert) checkOffset(offset, 2, this.length);
+                    var val = this[offset + 1] | this[offset] << 8;
+                    return val & 32768 ? val | 4294901760 : val;
+                  };
+                  Buffer22.prototype.readInt32LE = function readInt32LE(offset, noAssert) {
+                    offset = offset >>> 0;
+                    if (!noAssert) checkOffset(offset, 4, this.length);
+                    return this[offset] | this[offset + 1] << 8 | this[offset + 2] << 16 | this[offset + 3] << 24;
+                  };
+                  Buffer22.prototype.readInt32BE = function readInt32BE(offset, noAssert) {
+                    offset = offset >>> 0;
+                    if (!noAssert) checkOffset(offset, 4, this.length);
+                    return this[offset] << 24 | this[offset + 1] << 16 | this[offset + 2] << 8 | this[offset + 3];
+                  };
+                  Buffer22.prototype.readBigInt64LE = defineBigIntMethod(function readBigInt64LE(offset) {
+                    offset = offset >>> 0;
+                    validateNumber(offset, "offset");
+                    var first = this[offset];
+                    var last = this[offset + 7];
+                    if (first === void 0 || last === void 0) {
+                      boundsError(offset, this.length - 8);
+                    }
+                    var val = this[offset + 4] + this[offset + 5] * Math.pow(2, 8) + this[offset + 6] * Math.pow(2, 16) + (last << 24);
+                    return (BigInt(val) << BigInt(32)) + BigInt(first + this[++offset] * Math.pow(2, 8) + this[++offset] * Math.pow(2, 16) + this[++offset] * Math.pow(2, 24));
+                  });
+                  Buffer22.prototype.readBigInt64BE = defineBigIntMethod(function readBigInt64BE(offset) {
+                    offset = offset >>> 0;
+                    validateNumber(offset, "offset");
+                    var first = this[offset];
+                    var last = this[offset + 7];
+                    if (first === void 0 || last === void 0) {
+                      boundsError(offset, this.length - 8);
+                    }
+                    var val = (first << 24) + // Overflow
+                    this[++offset] * Math.pow(2, 16) + this[++offset] * Math.pow(2, 8) + this[++offset];
+                    return (BigInt(val) << BigInt(32)) + BigInt(this[++offset] * Math.pow(2, 24) + this[++offset] * Math.pow(2, 16) + this[++offset] * Math.pow(2, 8) + last);
+                  });
+                  Buffer22.prototype.readFloatLE = function readFloatLE(offset, noAssert) {
+                    offset = offset >>> 0;
+                    if (!noAssert) checkOffset(offset, 4, this.length);
+                    return ieee754.read(this, offset, true, 23, 4);
+                  };
+                  Buffer22.prototype.readFloatBE = function readFloatBE(offset, noAssert) {
+                    offset = offset >>> 0;
+                    if (!noAssert) checkOffset(offset, 4, this.length);
+                    return ieee754.read(this, offset, false, 23, 4);
+                  };
+                  Buffer22.prototype.readDoubleLE = function readDoubleLE(offset, noAssert) {
+                    offset = offset >>> 0;
+                    if (!noAssert) checkOffset(offset, 8, this.length);
+                    return ieee754.read(this, offset, true, 52, 8);
+                  };
+                  Buffer22.prototype.readDoubleBE = function readDoubleBE(offset, noAssert) {
+                    offset = offset >>> 0;
+                    if (!noAssert) checkOffset(offset, 8, this.length);
+                    return ieee754.read(this, offset, false, 52, 8);
+                  };
+                  function checkInt(buf, value, offset, ext, max, min) {
+                    if (!Buffer22.isBuffer(buf)) throw new TypeError('"buffer" argument must be a Buffer instance');
+                    if (value > max || value < min) throw new RangeError('"value" argument is out of bounds');
+                    if (offset + ext > buf.length) throw new RangeError("Index out of range");
+                  }
+                  Buffer22.prototype.writeUintLE = Buffer22.prototype.writeUIntLE = function writeUIntLE(value, offset, byteLength2, noAssert) {
+                    value = +value;
+                    offset = offset >>> 0;
+                    byteLength2 = byteLength2 >>> 0;
+                    if (!noAssert) {
+                      var maxBytes = Math.pow(2, 8 * byteLength2) - 1;
+                      checkInt(this, value, offset, byteLength2, maxBytes, 0);
+                    }
+                    var mul = 1;
+                    var i2 = 0;
+                    this[offset] = value & 255;
+                    while (++i2 < byteLength2 && (mul *= 256)) {
+                      this[offset + i2] = value / mul & 255;
+                    }
+                    return offset + byteLength2;
+                  };
+                  Buffer22.prototype.writeUintBE = Buffer22.prototype.writeUIntBE = function writeUIntBE(value, offset, byteLength2, noAssert) {
+                    value = +value;
+                    offset = offset >>> 0;
+                    byteLength2 = byteLength2 >>> 0;
+                    if (!noAssert) {
+                      var maxBytes = Math.pow(2, 8 * byteLength2) - 1;
+                      checkInt(this, value, offset, byteLength2, maxBytes, 0);
+                    }
+                    var i2 = byteLength2 - 1;
+                    var mul = 1;
+                    this[offset + i2] = value & 255;
+                    while (--i2 >= 0 && (mul *= 256)) {
+                      this[offset + i2] = value / mul & 255;
+                    }
+                    return offset + byteLength2;
+                  };
+                  Buffer22.prototype.writeUint8 = Buffer22.prototype.writeUInt8 = function writeUInt8(value, offset, noAssert) {
+                    value = +value;
+                    offset = offset >>> 0;
+                    if (!noAssert) checkInt(this, value, offset, 1, 255, 0);
+                    this[offset] = value & 255;
+                    return offset + 1;
+                  };
+                  Buffer22.prototype.writeUint16LE = Buffer22.prototype.writeUInt16LE = function writeUInt16LE(value, offset, noAssert) {
+                    value = +value;
+                    offset = offset >>> 0;
+                    if (!noAssert) checkInt(this, value, offset, 2, 65535, 0);
+                    this[offset] = value & 255;
+                    this[offset + 1] = value >>> 8;
+                    return offset + 2;
+                  };
+                  Buffer22.prototype.writeUint16BE = Buffer22.prototype.writeUInt16BE = function writeUInt16BE(value, offset, noAssert) {
+                    value = +value;
+                    offset = offset >>> 0;
+                    if (!noAssert) checkInt(this, value, offset, 2, 65535, 0);
+                    this[offset] = value >>> 8;
+                    this[offset + 1] = value & 255;
+                    return offset + 2;
+                  };
+                  Buffer22.prototype.writeUint32LE = Buffer22.prototype.writeUInt32LE = function writeUInt32LE(value, offset, noAssert) {
+                    value = +value;
+                    offset = offset >>> 0;
+                    if (!noAssert) checkInt(this, value, offset, 4, 4294967295, 0);
+                    this[offset + 3] = value >>> 24;
+                    this[offset + 2] = value >>> 16;
+                    this[offset + 1] = value >>> 8;
+                    this[offset] = value & 255;
+                    return offset + 4;
+                  };
+                  Buffer22.prototype.writeUint32BE = Buffer22.prototype.writeUInt32BE = function writeUInt32BE(value, offset, noAssert) {
+                    value = +value;
+                    offset = offset >>> 0;
+                    if (!noAssert) checkInt(this, value, offset, 4, 4294967295, 0);
+                    this[offset] = value >>> 24;
+                    this[offset + 1] = value >>> 16;
+                    this[offset + 2] = value >>> 8;
+                    this[offset + 3] = value & 255;
+                    return offset + 4;
+                  };
+                  function wrtBigUInt64LE(buf, value, offset, min, max) {
+                    checkIntBI(value, min, max, buf, offset, 7);
+                    var lo = Number(value & BigInt(4294967295));
+                    buf[offset++] = lo;
+                    lo = lo >> 8;
+                    buf[offset++] = lo;
+                    lo = lo >> 8;
+                    buf[offset++] = lo;
+                    lo = lo >> 8;
+                    buf[offset++] = lo;
+                    var hi2 = Number(value >> BigInt(32) & BigInt(4294967295));
+                    buf[offset++] = hi2;
+                    hi2 = hi2 >> 8;
+                    buf[offset++] = hi2;
+                    hi2 = hi2 >> 8;
+                    buf[offset++] = hi2;
+                    hi2 = hi2 >> 8;
+                    buf[offset++] = hi2;
+                    return offset;
+                  }
+                  function wrtBigUInt64BE(buf, value, offset, min, max) {
+                    checkIntBI(value, min, max, buf, offset, 7);
+                    var lo = Number(value & BigInt(4294967295));
+                    buf[offset + 7] = lo;
+                    lo = lo >> 8;
+                    buf[offset + 6] = lo;
+                    lo = lo >> 8;
+                    buf[offset + 5] = lo;
+                    lo = lo >> 8;
+                    buf[offset + 4] = lo;
+                    var hi2 = Number(value >> BigInt(32) & BigInt(4294967295));
+                    buf[offset + 3] = hi2;
+                    hi2 = hi2 >> 8;
+                    buf[offset + 2] = hi2;
+                    hi2 = hi2 >> 8;
+                    buf[offset + 1] = hi2;
+                    hi2 = hi2 >> 8;
+                    buf[offset] = hi2;
+                    return offset + 8;
+                  }
+                  Buffer22.prototype.writeBigUInt64LE = defineBigIntMethod(function writeBigUInt64LE(value) {
+                    var offset = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : 0;
+                    return wrtBigUInt64LE(this, value, offset, BigInt(0), BigInt("0xffffffffffffffff"));
+                  });
+                  Buffer22.prototype.writeBigUInt64BE = defineBigIntMethod(function writeBigUInt64BE(value) {
+                    var offset = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : 0;
+                    return wrtBigUInt64BE(this, value, offset, BigInt(0), BigInt("0xffffffffffffffff"));
+                  });
+                  Buffer22.prototype.writeIntLE = function writeIntLE(value, offset, byteLength2, noAssert) {
+                    value = +value;
+                    offset = offset >>> 0;
+                    if (!noAssert) {
+                      var limit = Math.pow(2, 8 * byteLength2 - 1);
+                      checkInt(this, value, offset, byteLength2, limit - 1, -limit);
+                    }
+                    var i2 = 0;
+                    var mul = 1;
+                    var sub2 = 0;
+                    this[offset] = value & 255;
+                    while (++i2 < byteLength2 && (mul *= 256)) {
+                      if (value < 0 && sub2 === 0 && this[offset + i2 - 1] !== 0) {
+                        sub2 = 1;
+                      }
+                      this[offset + i2] = (value / mul >> 0) - sub2 & 255;
+                    }
+                    return offset + byteLength2;
+                  };
+                  Buffer22.prototype.writeIntBE = function writeIntBE(value, offset, byteLength2, noAssert) {
+                    value = +value;
+                    offset = offset >>> 0;
+                    if (!noAssert) {
+                      var limit = Math.pow(2, 8 * byteLength2 - 1);
+                      checkInt(this, value, offset, byteLength2, limit - 1, -limit);
+                    }
+                    var i2 = byteLength2 - 1;
+                    var mul = 1;
+                    var sub2 = 0;
+                    this[offset + i2] = value & 255;
+                    while (--i2 >= 0 && (mul *= 256)) {
+                      if (value < 0 && sub2 === 0 && this[offset + i2 + 1] !== 0) {
+                        sub2 = 1;
+                      }
+                      this[offset + i2] = (value / mul >> 0) - sub2 & 255;
+                    }
+                    return offset + byteLength2;
+                  };
+                  Buffer22.prototype.writeInt8 = function writeInt8(value, offset, noAssert) {
+                    value = +value;
+                    offset = offset >>> 0;
+                    if (!noAssert) checkInt(this, value, offset, 1, 127, -128);
+                    if (value < 0) value = 255 + value + 1;
+                    this[offset] = value & 255;
+                    return offset + 1;
+                  };
+                  Buffer22.prototype.writeInt16LE = function writeInt16LE(value, offset, noAssert) {
+                    value = +value;
+                    offset = offset >>> 0;
+                    if (!noAssert) checkInt(this, value, offset, 2, 32767, -32768);
+                    this[offset] = value & 255;
+                    this[offset + 1] = value >>> 8;
+                    return offset + 2;
+                  };
+                  Buffer22.prototype.writeInt16BE = function writeInt16BE(value, offset, noAssert) {
+                    value = +value;
+                    offset = offset >>> 0;
+                    if (!noAssert) checkInt(this, value, offset, 2, 32767, -32768);
+                    this[offset] = value >>> 8;
+                    this[offset + 1] = value & 255;
+                    return offset + 2;
+                  };
+                  Buffer22.prototype.writeInt32LE = function writeInt32LE(value, offset, noAssert) {
+                    value = +value;
+                    offset = offset >>> 0;
+                    if (!noAssert) checkInt(this, value, offset, 4, 2147483647, -2147483648);
+                    this[offset] = value & 255;
+                    this[offset + 1] = value >>> 8;
+                    this[offset + 2] = value >>> 16;
+                    this[offset + 3] = value >>> 24;
+                    return offset + 4;
+                  };
+                  Buffer22.prototype.writeInt32BE = function writeInt32BE(value, offset, noAssert) {
+                    value = +value;
+                    offset = offset >>> 0;
+                    if (!noAssert) checkInt(this, value, offset, 4, 2147483647, -2147483648);
+                    if (value < 0) value = 4294967295 + value + 1;
+                    this[offset] = value >>> 24;
+                    this[offset + 1] = value >>> 16;
+                    this[offset + 2] = value >>> 8;
+                    this[offset + 3] = value & 255;
+                    return offset + 4;
+                  };
+                  Buffer22.prototype.writeBigInt64LE = defineBigIntMethod(function writeBigInt64LE(value) {
+                    var offset = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : 0;
+                    return wrtBigUInt64LE(this, value, offset, -BigInt("0x8000000000000000"), BigInt("0x7fffffffffffffff"));
+                  });
+                  Buffer22.prototype.writeBigInt64BE = defineBigIntMethod(function writeBigInt64BE(value) {
+                    var offset = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : 0;
+                    return wrtBigUInt64BE(this, value, offset, -BigInt("0x8000000000000000"), BigInt("0x7fffffffffffffff"));
+                  });
+                  function checkIEEE754(buf, value, offset, ext, max, min) {
+                    if (offset + ext > buf.length) throw new RangeError("Index out of range");
+                    if (offset < 0) throw new RangeError("Index out of range");
+                  }
+                  function writeFloat(buf, value, offset, littleEndian, noAssert) {
+                    value = +value;
+                    offset = offset >>> 0;
+                    if (!noAssert) {
+                      checkIEEE754(buf, value, offset, 4);
+                    }
+                    ieee754.write(buf, value, offset, littleEndian, 23, 4);
+                    return offset + 4;
+                  }
+                  Buffer22.prototype.writeFloatLE = function writeFloatLE(value, offset, noAssert) {
+                    return writeFloat(this, value, offset, true, noAssert);
+                  };
+                  Buffer22.prototype.writeFloatBE = function writeFloatBE(value, offset, noAssert) {
+                    return writeFloat(this, value, offset, false, noAssert);
+                  };
+                  function writeDouble(buf, value, offset, littleEndian, noAssert) {
+                    value = +value;
+                    offset = offset >>> 0;
+                    if (!noAssert) {
+                      checkIEEE754(buf, value, offset, 8);
+                    }
+                    ieee754.write(buf, value, offset, littleEndian, 52, 8);
+                    return offset + 8;
+                  }
+                  Buffer22.prototype.writeDoubleLE = function writeDoubleLE(value, offset, noAssert) {
+                    return writeDouble(this, value, offset, true, noAssert);
+                  };
+                  Buffer22.prototype.writeDoubleBE = function writeDoubleBE(value, offset, noAssert) {
+                    return writeDouble(this, value, offset, false, noAssert);
+                  };
+                  Buffer22.prototype.copy = function copy(target, targetStart, start, end) {
+                    if (!Buffer22.isBuffer(target)) throw new TypeError("argument should be a Buffer");
+                    if (!start) start = 0;
+                    if (!end && end !== 0) end = this.length;
+                    if (targetStart >= target.length) targetStart = target.length;
+                    if (!targetStart) targetStart = 0;
+                    if (end > 0 && end < start) end = start;
+                    if (end === start) return 0;
+                    if (target.length === 0 || this.length === 0) return 0;
+                    if (targetStart < 0) {
+                      throw new RangeError("targetStart out of bounds");
+                    }
+                    if (start < 0 || start >= this.length) throw new RangeError("Index out of range");
+                    if (end < 0) throw new RangeError("sourceEnd out of bounds");
+                    if (end > this.length) end = this.length;
+                    if (target.length - targetStart < end - start) {
+                      end = target.length - targetStart + start;
+                    }
+                    var len2 = end - start;
+                    if (this === target && typeof Uint8Array.prototype.copyWithin === "function") {
+                      this.copyWithin(targetStart, start, end);
+                    } else {
+                      Uint8Array.prototype.set.call(target, this.subarray(start, end), targetStart);
+                    }
+                    return len2;
+                  };
+                  Buffer22.prototype.fill = function fill(val, start, end, encoding) {
+                    if (typeof val === "string") {
+                      if (typeof start === "string") {
+                        encoding = start;
+                        start = 0;
+                        end = this.length;
+                      } else if (typeof end === "string") {
+                        encoding = end;
+                        end = this.length;
+                      }
+                      if (encoding !== void 0 && typeof encoding !== "string") {
+                        throw new TypeError("encoding must be a string");
+                      }
+                      if (typeof encoding === "string" && !Buffer22.isEncoding(encoding)) {
+                        throw new TypeError("Unknown encoding: " + encoding);
+                      }
+                      if (val.length === 1) {
+                        var code = val.charCodeAt(0);
+                        if (encoding === "utf8" && code < 128 || encoding === "latin1") {
+                          val = code;
+                        }
+                      }
+                    } else if (typeof val === "number") {
+                      val = val & 255;
+                    } else if (typeof val === "boolean") {
+                      val = Number(val);
+                    }
+                    if (start < 0 || this.length < start || this.length < end) {
+                      throw new RangeError("Out of range index");
+                    }
+                    if (end <= start) {
+                      return this;
+                    }
+                    start = start >>> 0;
+                    end = end === void 0 ? this.length : end >>> 0;
+                    if (!val) val = 0;
+                    var i2;
+                    if (typeof val === "number") {
+                      for (i2 = start; i2 < end; ++i2) {
+                        this[i2] = val;
+                      }
+                    } else {
+                      var bytes = Buffer22.isBuffer(val) ? val : Buffer22.from(val, encoding);
+                      var len2 = bytes.length;
+                      if (len2 === 0) {
+                        throw new TypeError('The value "' + val + '" is invalid for argument "value"');
+                      }
+                      for (i2 = 0; i2 < end - start; ++i2) {
+                        this[i2 + start] = bytes[i2 % len2];
+                      }
+                    }
+                    return this;
+                  };
+                  var errors = {};
+                  function E22(sym, getMessage, Base) {
+                    errors[sym] = /* @__PURE__ */ function(_Base) {
+                      function NodeError() {
+                        var _this;
+                        _classCallCheck(this, NodeError);
+                        _this = _callSuper(this, NodeError);
+                        Object.defineProperty(_this, "message", {
+                          value: getMessage.apply(_this, arguments),
+                          writable: true,
+                          configurable: true
+                        });
+                        _this.name = "".concat(_this.name, " [").concat(sym, "]");
+                        _this.stack;
+                        delete _this.name;
+                        return _this;
+                      }
+                      _inherits(NodeError, _Base);
+                      return _createClass(NodeError, [{
+                        key: "code",
+                        get: function get() {
+                          return sym;
+                        },
+                        set: function set(value) {
+                          Object.defineProperty(this, "code", {
+                            configurable: true,
+                            enumerable: true,
+                            value,
+                            writable: true
+                          });
+                        }
+                      }, {
+                        key: "toString",
+                        value: function toString() {
+                          return "".concat(this.name, " [").concat(sym, "]: ").concat(this.message);
+                        }
+                      }]);
+                    }(Base);
+                  }
+                  E22("ERR_BUFFER_OUT_OF_BOUNDS", function(name2) {
+                    if (name2) {
+                      return "".concat(name2, " is outside of buffer bounds");
+                    }
+                    return "Attempt to access memory outside buffer bounds";
+                  }, RangeError);
+                  E22("ERR_INVALID_ARG_TYPE", function(name2, actual) {
+                    return 'The "'.concat(name2, '" argument must be of type number. Received type ').concat(_typeof(actual));
+                  }, TypeError);
+                  E22("ERR_OUT_OF_RANGE", function(str, range, input) {
+                    var msg = 'The value of "'.concat(str, '" is out of range.');
+                    var received = input;
+                    if (Number.isInteger(input) && Math.abs(input) > Math.pow(2, 32)) {
+                      received = addNumericalSeparator(String(input));
+                    } else if (typeof input === "bigint") {
+                      received = String(input);
+                      if (input > Math.pow(BigInt(2), BigInt(32)) || input < -Math.pow(BigInt(2), BigInt(32))) {
+                        received = addNumericalSeparator(received);
+                      }
+                      received += "n";
+                    }
+                    msg += " It must be ".concat(range, ". Received ").concat(received);
+                    return msg;
+                  }, RangeError);
+                  function addNumericalSeparator(val) {
+                    var res = "";
+                    var i2 = val.length;
+                    var start = val[0] === "-" ? 1 : 0;
+                    for (; i2 >= start + 4; i2 -= 3) {
+                      res = "_".concat(val.slice(i2 - 3, i2)).concat(res);
+                    }
+                    return "".concat(val.slice(0, i2)).concat(res);
+                  }
+                  function checkBounds(buf, offset, byteLength2) {
+                    validateNumber(offset, "offset");
+                    if (buf[offset] === void 0 || buf[offset + byteLength2] === void 0) {
+                      boundsError(offset, buf.length - (byteLength2 + 1));
+                    }
+                  }
+                  function checkIntBI(value, min, max, buf, offset, byteLength2) {
+                    if (value > max || value < min) {
+                      var n2 = typeof min === "bigint" ? "n" : "";
+                      var range;
+                      {
+                        if (min === 0 || min === BigInt(0)) {
+                          range = ">= 0".concat(n2, " and < 2").concat(n2, " ** ").concat((byteLength2 + 1) * 8).concat(n2);
+                        } else {
+                          range = ">= -(2".concat(n2, " ** ").concat((byteLength2 + 1) * 8 - 1).concat(n2, ") and < 2 ** ") + "".concat((byteLength2 + 1) * 8 - 1).concat(n2);
+                        }
+                      }
+                      throw new errors.ERR_OUT_OF_RANGE("value", range, value);
+                    }
+                    checkBounds(buf, offset, byteLength2);
+                  }
+                  function validateNumber(value, name2) {
+                    if (typeof value !== "number") {
+                      throw new errors.ERR_INVALID_ARG_TYPE(name2, "number", value);
+                    }
+                  }
+                  function boundsError(value, length2, type) {
+                    if (Math.floor(value) !== value) {
+                      validateNumber(value, type);
+                      throw new errors.ERR_OUT_OF_RANGE("offset", "an integer", value);
+                    }
+                    if (length2 < 0) {
+                      throw new errors.ERR_BUFFER_OUT_OF_BOUNDS();
+                    }
+                    throw new errors.ERR_OUT_OF_RANGE("offset", ">= ".concat(0, " and <= ").concat(length2), value);
+                  }
+                  var INVALID_BASE64_RE = /[^+/0-9A-Za-z-_]/g;
+                  function base64clean(str) {
+                    str = str.split("=")[0];
+                    str = str.trim().replace(INVALID_BASE64_RE, "");
+                    if (str.length < 2) return "";
+                    while (str.length % 4 !== 0) {
+                      str = str + "=";
+                    }
+                    return str;
+                  }
+                  function utf8ToBytes(string, units) {
+                    units = units || Infinity;
+                    var codePoint;
+                    var length2 = string.length;
+                    var leadSurrogate = null;
+                    var bytes = [];
+                    for (var i2 = 0; i2 < length2; ++i2) {
+                      codePoint = string.charCodeAt(i2);
+                      if (codePoint > 55295 && codePoint < 57344) {
+                        if (!leadSurrogate) {
+                          if (codePoint > 56319) {
+                            if ((units -= 3) > -1) bytes.push(239, 191, 189);
+                            continue;
+                          } else if (i2 + 1 === length2) {
+                            if ((units -= 3) > -1) bytes.push(239, 191, 189);
+                            continue;
+                          }
+                          leadSurrogate = codePoint;
+                          continue;
+                        }
+                        if (codePoint < 56320) {
+                          if ((units -= 3) > -1) bytes.push(239, 191, 189);
+                          leadSurrogate = codePoint;
+                          continue;
+                        }
+                        codePoint = (leadSurrogate - 55296 << 10 | codePoint - 56320) + 65536;
+                      } else if (leadSurrogate) {
+                        if ((units -= 3) > -1) bytes.push(239, 191, 189);
+                      }
+                      leadSurrogate = null;
+                      if (codePoint < 128) {
+                        if ((units -= 1) < 0) break;
+                        bytes.push(codePoint);
+                      } else if (codePoint < 2048) {
+                        if ((units -= 2) < 0) break;
+                        bytes.push(codePoint >> 6 | 192, codePoint & 63 | 128);
+                      } else if (codePoint < 65536) {
+                        if ((units -= 3) < 0) break;
+                        bytes.push(codePoint >> 12 | 224, codePoint >> 6 & 63 | 128, codePoint & 63 | 128);
+                      } else if (codePoint < 1114112) {
+                        if ((units -= 4) < 0) break;
+                        bytes.push(codePoint >> 18 | 240, codePoint >> 12 & 63 | 128, codePoint >> 6 & 63 | 128, codePoint & 63 | 128);
+                      } else {
+                        throw new Error("Invalid code point");
+                      }
+                    }
+                    return bytes;
+                  }
+                  function asciiToBytes(str) {
+                    var byteArray = [];
+                    for (var i2 = 0; i2 < str.length; ++i2) {
+                      byteArray.push(str.charCodeAt(i2) & 255);
+                    }
+                    return byteArray;
+                  }
+                  function utf16leToBytes(str, units) {
+                    var c2, hi2, lo;
+                    var byteArray = [];
+                    for (var i2 = 0; i2 < str.length; ++i2) {
+                      if ((units -= 2) < 0) break;
+                      c2 = str.charCodeAt(i2);
+                      hi2 = c2 >> 8;
+                      lo = c2 % 256;
+                      byteArray.push(lo);
+                      byteArray.push(hi2);
+                    }
+                    return byteArray;
+                  }
+                  function base64ToBytes(str) {
+                    return base64.toByteArray(base64clean(str));
+                  }
+                  function blitBuffer(src, dst, offset, length2) {
+                    var i2;
+                    for (i2 = 0; i2 < length2; ++i2) {
+                      if (i2 + offset >= dst.length || i2 >= src.length) break;
+                      dst[i2 + offset] = src[i2];
+                    }
+                    return i2;
+                  }
+                  function isInstance(obj, type) {
+                    return obj instanceof type || obj != null && obj.constructor != null && obj.constructor.name != null && obj.constructor.name === type.name;
+                  }
+                  function numberIsNaN(obj) {
+                    return obj !== obj;
+                  }
+                  var hexSliceLookupTable = function() {
+                    var alphabet = "0123456789abcdef";
+                    var table = new Array(256);
+                    for (var i2 = 0; i2 < 16; ++i2) {
+                      var i16 = i2 * 16;
+                      for (var j2 = 0; j2 < 16; ++j2) {
+                        table[i16 + j2] = alphabet[i2] + alphabet[j2];
+                      }
+                    }
+                    return table;
+                  }();
+                  function defineBigIntMethod(fn) {
+                    return typeof BigInt === "undefined" ? BufferBigIntNotDefined : fn;
+                  }
+                  function BufferBigIntNotDefined() {
+                    throw new Error("BigInt not supported");
+                  }
+                }
+              ),
+              /***/
+              4844: (
+                /***/
+                function(module22) {
+                  module22.exports = scaleAndAdd;
+                  function scaleAndAdd(out, a2, b2, scale2) {
+                    out[0] = a2[0] + b2[0] * scale2;
+                    out[1] = a2[1] + b2[1] * scale2;
+                    out[2] = a2[2] + b2[2] * scale2;
+                    out[3] = a2[3] + b2[3] * scale2;
+                    return out;
+                  }
+                }
+              ),
+              /***/
+              4905: (
+                /***/
+                function(module22, __unused_webpack_exports, __webpack_require__2) {
+                  var tokenize2 = __webpack_require__2(5874);
+                  module22.exports = tokenizeString;
+                  function tokenizeString(str, opt) {
+                    var generator = tokenize2(opt);
+                    var tokens = [];
+                    tokens = tokens.concat(generator(str));
+                    tokens = tokens.concat(generator(null));
+                    return tokens;
+                  }
+                }
+              ),
+              /***/
+              4935: (
+                /***/
+                function(module22, __unused_webpack_exports, __webpack_require__2) {
+                  module22.exports = createTextSprites;
+                  var createBuffer = __webpack_require__2(2762);
+                  var createVAO = __webpack_require__2(8116);
+                  var vectorizeText = __webpack_require__2(4359);
+                  var createShader = __webpack_require__2(1879).Q;
+                  var globals = window || process.global || {};
+                  var __TEXT_CACHE = globals.__TEXT_CACHE || {};
+                  globals.__TEXT_CACHE = {};
+                  var VERTEX_SIZE = 3;
+                  function TextSprites(gl2, shader, buffer, vao) {
+                    this.gl = gl2;
+                    this.shader = shader;
+                    this.buffer = buffer;
+                    this.vao = vao;
+                    this.tickOffset = this.tickCount = this.labelOffset = this.labelCount = null;
+                  }
+                  var proto = TextSprites.prototype;
+                  var SHAPE = [0, 0];
+                  proto.bind = function(model, view, projection, pixelScale) {
+                    this.vao.bind();
+                    this.shader.bind();
+                    var uniforms = this.shader.uniforms;
+                    uniforms.model = model;
+                    uniforms.view = view;
+                    uniforms.projection = projection;
+                    uniforms.pixelScale = pixelScale;
+                    SHAPE[0] = this.gl.drawingBufferWidth;
+                    SHAPE[1] = this.gl.drawingBufferHeight;
+                    this.shader.uniforms.resolution = SHAPE;
+                  };
+                  proto.unbind = function() {
+                    this.vao.unbind();
+                  };
+                  proto.update = function(bounds, labels, labelFont, ticks, tickFont) {
+                    var data = [];
+                    function addItem(t4, text, font2, size, lineSpacing2, styletags2) {
+                      var fontKey = [
+                        font2.style,
+                        font2.weight,
+                        font2.variant,
+                        font2.family
+                      ].join("_");
+                      var fontcache = __TEXT_CACHE[fontKey];
+                      if (!fontcache) {
+                        fontcache = __TEXT_CACHE[fontKey] = {};
+                      }
+                      var mesh = fontcache[text];
+                      if (!mesh) {
+                        mesh = fontcache[text] = tryVectorizeText(text, {
+                          triangles: true,
+                          font: font2.family,
+                          fontStyle: font2.style,
+                          fontWeight: font2.weight,
+                          fontVariant: font2.variant,
+                          textAlign: "center",
+                          textBaseline: "middle",
+                          lineSpacing: lineSpacing2,
+                          styletags: styletags2
+                        });
+                      }
+                      var scale2 = (size || 12) / 12;
+                      var positions = mesh.positions;
+                      var cells = mesh.cells;
+                      for (var i22 = 0, nc2 = cells.length; i22 < nc2; ++i22) {
+                        var c2 = cells[i22];
+                        for (var j2 = 2; j2 >= 0; --j2) {
+                          var p2 = positions[c2[j2]];
+                          data.push(scale2 * p2[0], -scale2 * p2[1], t4);
+                        }
+                      }
+                    }
+                    var tickOffset = [0, 0, 0];
+                    var tickCount = [0, 0, 0];
+                    var labelOffset = [0, 0, 0];
+                    var labelCount = [0, 0, 0];
+                    var lineSpacing = 1.25;
+                    var styletags = {
+                      breaklines: true,
+                      bolds: true,
+                      italics: true,
+                      subscripts: true,
+                      superscripts: true
+                    };
+                    for (var d2 = 0; d2 < 3; ++d2) {
+                      labelOffset[d2] = data.length / VERTEX_SIZE | 0;
+                      addItem(
+                        0.5 * (bounds[0][d2] + bounds[1][d2]),
+                        labels[d2],
+                        labelFont[d2],
+                        12,
+                        // labelFontSize
+                        lineSpacing,
+                        styletags
+                      );
+                      labelCount[d2] = (data.length / VERTEX_SIZE | 0) - labelOffset[d2];
+                      tickOffset[d2] = data.length / VERTEX_SIZE | 0;
+                      for (var i2 = 0; i2 < ticks[d2].length; ++i2) {
+                        if (!ticks[d2][i2].text) {
+                          continue;
+                        }
+                        var font = {
+                          family: ticks[d2][i2].font || tickFont[d2].family,
+                          style: tickFont[d2].fontStyle || tickFont[d2].style,
+                          weight: tickFont[d2].fontWeight || tickFont[d2].weight,
+                          variant: tickFont[d2].fontVariant || tickFont[d2].variant
+                        };
+                        addItem(
+                          ticks[d2][i2].x,
+                          ticks[d2][i2].text,
+                          font,
+                          ticks[d2][i2].fontSize || 12,
+                          lineSpacing,
+                          styletags
+                        );
+                      }
+                      tickCount[d2] = (data.length / VERTEX_SIZE | 0) - tickOffset[d2];
+                    }
+                    this.buffer.update(data);
+                    this.tickOffset = tickOffset;
+                    this.tickCount = tickCount;
+                    this.labelOffset = labelOffset;
+                    this.labelCount = labelCount;
+                  };
+                  proto.drawTicks = function(d2, scale2, angle2, offset, color22, axis, alignDir, alignOpt) {
+                    if (!this.tickCount[d2]) {
+                      return;
+                    }
+                    this.shader.uniforms.axis = axis;
+                    this.shader.uniforms.color = color22;
+                    this.shader.uniforms.angle = angle2;
+                    this.shader.uniforms.scale = scale2;
+                    this.shader.uniforms.offset = offset;
+                    this.shader.uniforms.alignDir = alignDir;
+                    this.shader.uniforms.alignOpt = alignOpt;
+                    this.vao.draw(this.gl.TRIANGLES, this.tickCount[d2], this.tickOffset[d2]);
+                  };
+                  proto.drawLabel = function(d2, scale2, angle2, offset, color22, axis, alignDir, alignOpt) {
+                    if (!this.labelCount[d2]) {
+                      return;
+                    }
+                    this.shader.uniforms.axis = axis;
+                    this.shader.uniforms.color = color22;
+                    this.shader.uniforms.angle = angle2;
+                    this.shader.uniforms.scale = scale2;
+                    this.shader.uniforms.offset = offset;
+                    this.shader.uniforms.alignDir = alignDir;
+                    this.shader.uniforms.alignOpt = alignOpt;
+                    this.vao.draw(this.gl.TRIANGLES, this.labelCount[d2], this.labelOffset[d2]);
+                  };
+                  proto.dispose = function() {
+                    this.shader.dispose();
+                    this.vao.dispose();
+                    this.buffer.dispose();
+                  };
+                  function tryVectorizeText(text, options) {
+                    try {
+                      return vectorizeText(text, options);
+                    } catch (e2) {
+                      console.warn('error vectorizing text:"' + text + '" error:', e2);
+                      return {
+                        cells: [],
+                        positions: []
+                      };
+                    }
+                  }
+                  function createTextSprites(gl2, bounds, labels, labelFont, ticks, tickFont) {
+                    var buffer = createBuffer(gl2);
+                    var vao = createVAO(gl2, [
+                      {
+                        "buffer": buffer,
+                        "size": 3
+                      }
+                    ]);
+                    var shader = createShader(gl2);
+                    shader.attributes.position.location = 0;
+                    var result = new TextSprites(
+                      gl2,
+                      shader,
+                      buffer,
+                      vao
+                    );
+                    result.update(bounds, labels, labelFont, ticks, tickFont);
+                    return result;
+                  }
+                }
+              ),
+              /***/
+              5023: (
+                /***/
+                function(module22, __unused_webpack_exports, __webpack_require__2) {
+                  var bsearch = __webpack_require__2(2478);
+                  module22.exports = classifyFaces;
+                  function FaceIndex(cells, neighbor, constraint, flags, active, next, boundary) {
+                    this.cells = cells;
+                    this.neighbor = neighbor;
+                    this.flags = flags;
+                    this.constraint = constraint;
+                    this.active = active;
+                    this.next = next;
+                    this.boundary = boundary;
+                  }
+                  var proto = FaceIndex.prototype;
+                  function compareCell(a2, b2) {
+                    return a2[0] - b2[0] || a2[1] - b2[1] || a2[2] - b2[2];
+                  }
+                  proto.locate = /* @__PURE__ */ function() {
+                    var key = [0, 0, 0];
+                    return function(a2, b2, c2) {
+                      var x2 = a2, y2 = b2, z2 = c2;
+                      if (b2 < c2) {
+                        if (b2 < a2) {
+                          x2 = b2;
+                          y2 = c2;
+                          z2 = a2;
+                        }
+                      } else if (c2 < a2) {
+                        x2 = c2;
+                        y2 = a2;
+                        z2 = b2;
+                      }
+                      if (x2 < 0) {
+                        return -1;
+                      }
+                      key[0] = x2;
+                      key[1] = y2;
+                      key[2] = z2;
+                      return bsearch.eq(this.cells, key, compareCell);
+                    };
+                  }();
+                  function indexCells(triangulation, infinity) {
+                    var cells = triangulation.cells();
+                    var nc2 = cells.length;
+                    for (var i2 = 0; i2 < nc2; ++i2) {
+                      var c2 = cells[i2];
+                      var x2 = c2[0], y2 = c2[1], z2 = c2[2];
+                      if (y2 < z2) {
+                        if (y2 < x2) {
+                          c2[0] = y2;
+                          c2[1] = z2;
+                          c2[2] = x2;
+                        }
+                      } else if (z2 < x2) {
+                        c2[0] = z2;
+                        c2[1] = x2;
+                        c2[2] = y2;
+                      }
+                    }
+                    cells.sort(compareCell);
+                    var flags = new Array(nc2);
+                    for (var i2 = 0; i2 < flags.length; ++i2) {
+                      flags[i2] = 0;
+                    }
+                    var active = [];
+                    var next = [];
+                    var neighbor = new Array(3 * nc2);
+                    var constraint = new Array(3 * nc2);
+                    var boundary = null;
+                    if (infinity) {
+                      boundary = [];
+                    }
+                    var index = new FaceIndex(
+                      cells,
+                      neighbor,
+                      constraint,
+                      flags,
+                      active,
+                      next,
+                      boundary
+                    );
+                    for (var i2 = 0; i2 < nc2; ++i2) {
+                      var c2 = cells[i2];
+                      for (var j2 = 0; j2 < 3; ++j2) {
+                        var x2 = c2[j2], y2 = c2[(j2 + 1) % 3];
+                        var a2 = neighbor[3 * i2 + j2] = index.locate(y2, x2, triangulation.opposite(y2, x2));
+                        var b2 = constraint[3 * i2 + j2] = triangulation.isConstraint(x2, y2);
+                        if (a2 < 0) {
+                          if (b2) {
+                            next.push(i2);
+                          } else {
+                            active.push(i2);
+                            flags[i2] = 1;
+                          }
+                          if (infinity) {
+                            boundary.push([y2, x2, -1]);
+                          }
+                        }
+                      }
+                    }
+                    return index;
+                  }
+                  function filterCells(cells, flags, target) {
+                    var ptr = 0;
+                    for (var i2 = 0; i2 < cells.length; ++i2) {
+                      if (flags[i2] === target) {
+                        cells[ptr++] = cells[i2];
+                      }
+                    }
+                    cells.length = ptr;
+                    return cells;
+                  }
+                  function classifyFaces(triangulation, target, infinity) {
+                    var index = indexCells(triangulation, infinity);
+                    if (target === 0) {
+                      if (infinity) {
+                        return index.cells.concat(index.boundary);
+                      } else {
+                        return index.cells;
+                      }
+                    }
+                    var side = 1;
+                    var active = index.active;
+                    var next = index.next;
+                    var flags = index.flags;
+                    var cells = index.cells;
+                    var constraint = index.constraint;
+                    var neighbor = index.neighbor;
+                    while (active.length > 0 || next.length > 0) {
+                      while (active.length > 0) {
+                        var t4 = active.pop();
+                        if (flags[t4] === -side) {
+                          continue;
+                        }
+                        flags[t4] = side;
+                        cells[t4];
+                        for (var j2 = 0; j2 < 3; ++j2) {
+                          var f2 = neighbor[3 * t4 + j2];
+                          if (f2 >= 0 && flags[f2] === 0) {
+                            if (constraint[3 * t4 + j2]) {
+                              next.push(f2);
+                            } else {
+                              active.push(f2);
+                              flags[f2] = side;
+                            }
+                          }
+                        }
+                      }
+                      var tmp2 = next;
+                      next = active;
+                      active = tmp2;
+                      next.length = 0;
+                      side = -side;
+                    }
+                    var result = filterCells(cells, flags, target);
+                    if (infinity) {
+                      return result.concat(index.boundary);
+                    }
+                    return result;
+                  }
+                }
+              ),
+              /***/
+              5033: (
+                /***/
+                function(module22) {
+                  module22.exports = extractPlanes;
+                  function extractPlanes(M2, zNear, zFar) {
+                    var z2 = zNear || 0;
+                    var zf2 = zFar || 1;
+                    return [
+                      [M2[12] + M2[0], M2[13] + M2[1], M2[14] + M2[2], M2[15] + M2[3]],
+                      [M2[12] - M2[0], M2[13] - M2[1], M2[14] - M2[2], M2[15] - M2[3]],
+                      [M2[12] + M2[4], M2[13] + M2[5], M2[14] + M2[6], M2[15] + M2[7]],
+                      [M2[12] - M2[4], M2[13] - M2[5], M2[14] - M2[6], M2[15] - M2[7]],
+                      [z2 * M2[12] + M2[8], z2 * M2[13] + M2[9], z2 * M2[14] + M2[10], z2 * M2[15] + M2[11]],
+                      [zf2 * M2[12] - M2[8], zf2 * M2[13] - M2[9], zf2 * M2[14] - M2[10], zf2 * M2[15] - M2[11]]
+                    ];
+                  }
+                }
+              ),
+              /***/
+              5085: (
+                /***/
+                function(module22, __unused_webpack_exports, __webpack_require__2) {
+                  module22.exports = preprocessPolygon;
+                  var orient = __webpack_require__2(3250)[3];
+                  var makeSlabs = __webpack_require__2(4209);
+                  var makeIntervalTree = __webpack_require__2(3352);
+                  var bsearch = __webpack_require__2(2478);
+                  function visitInterval() {
+                    return true;
+                  }
+                  function intervalSearch(table) {
+                    return function(x2, y2) {
+                      var tree = table[x2];
+                      if (tree) {
+                        return !!tree.queryPoint(y2, visitInterval);
+                      }
+                      return false;
+                    };
+                  }
+                  function buildVerticalIndex(segments) {
+                    var table = {};
+                    for (var i2 = 0; i2 < segments.length; ++i2) {
+                      var s2 = segments[i2];
+                      var x2 = s2[0][0];
+                      var y0 = s2[0][1];
+                      var y1 = s2[1][1];
+                      var p2 = [Math.min(y0, y1), Math.max(y0, y1)];
+                      if (x2 in table) {
+                        table[x2].push(p2);
+                      } else {
+                        table[x2] = [p2];
+                      }
+                    }
+                    var intervalTable = {};
+                    var keys = Object.keys(table);
+                    for (var i2 = 0; i2 < keys.length; ++i2) {
+                      var segs = table[keys[i2]];
+                      intervalTable[keys[i2]] = makeIntervalTree(segs);
+                    }
+                    return intervalSearch(intervalTable);
+                  }
+                  function buildSlabSearch(slabs, coordinates) {
+                    return function(p2) {
+                      var bucket = bsearch.le(coordinates, p2[0]);
+                      if (bucket < 0) {
+                        return 1;
+                      }
+                      var root = slabs[bucket];
+                      if (!root) {
+                        if (bucket > 0 && coordinates[bucket] === p2[0]) {
+                          root = slabs[bucket - 1];
+                        } else {
+                          return 1;
+                        }
+                      }
+                      var lastOrientation = 1;
+                      while (root) {
+                        var s2 = root.key;
+                        var o2 = orient(p2, s2[0], s2[1]);
+                        if (s2[0][0] < s2[1][0]) {
+                          if (o2 < 0) {
+                            root = root.left;
+                          } else if (o2 > 0) {
+                            lastOrientation = -1;
+                            root = root.right;
+                          } else {
+                            return 0;
+                          }
+                        } else {
+                          if (o2 > 0) {
+                            root = root.left;
+                          } else if (o2 < 0) {
+                            lastOrientation = 1;
+                            root = root.right;
+                          } else {
+                            return 0;
+                          }
+                        }
+                      }
+                      return lastOrientation;
+                    };
+                  }
+                  function classifyEmpty(p2) {
+                    return 1;
+                  }
+                  function createClassifyVertical(testVertical) {
+                    return function classify(p2) {
+                      if (testVertical(p2[0], p2[1])) {
+                        return 0;
+                      }
+                      return 1;
+                    };
+                  }
+                  function createClassifyPointDegen(testVertical, testNormal) {
+                    return function classify(p2) {
+                      if (testVertical(p2[0], p2[1])) {
+                        return 0;
+                      }
+                      return testNormal(p2);
+                    };
+                  }
+                  function preprocessPolygon(loops) {
+                    var numLoops = loops.length;
+                    var segments = [];
+                    var vsegments = [];
+                    for (var i2 = 0; i2 < numLoops; ++i2) {
+                      var loop = loops[i2];
+                      var numVertices = loop.length;
+                      for (var s2 = numVertices - 1, t4 = 0; t4 < numVertices; s2 = t4++) {
+                        var a2 = loop[s2];
+                        var b2 = loop[t4];
+                        if (a2[0] === b2[0]) {
+                          vsegments.push([a2, b2]);
+                        } else {
+                          segments.push([a2, b2]);
+                        }
+                      }
+                    }
+                    if (segments.length === 0) {
+                      if (vsegments.length === 0) {
+                        return classifyEmpty;
+                      } else {
+                        return createClassifyVertical(buildVerticalIndex(vsegments));
+                      }
+                    }
+                    var slabs = makeSlabs(segments);
+                    var testSlab = buildSlabSearch(slabs.slabs, slabs.coordinates);
+                    if (vsegments.length === 0) {
+                      return testSlab;
+                    } else {
+                      return createClassifyPointDegen(
+                        buildVerticalIndex(vsegments),
+                        testSlab
+                      );
+                    }
+                  }
+                }
+              ),
+              /***/
+              5091: (
+                /***/
+                function(__unused_webpack_module, exports2, __webpack_require__2) {
+                  exports2.shader = getShaderReference;
+                  exports2.program = createProgram;
+                  var GLError = __webpack_require__2(8866);
+                  var formatCompilerError = __webpack_require__2(2992);
+                  var weakMap = typeof WeakMap === "undefined" ? __webpack_require__2(606) : WeakMap;
+                  var CACHE = new weakMap();
+                  var SHADER_COUNTER = 0;
+                  function ShaderReference(id2, src, type, shader, programs, count2, cache) {
+                    this.id = id2;
+                    this.src = src;
+                    this.type = type;
+                    this.shader = shader;
+                    this.count = count2;
+                    this.programs = [];
+                    this.cache = cache;
+                  }
+                  ShaderReference.prototype.dispose = function() {
+                    if (--this.count === 0) {
+                      var cache = this.cache;
+                      var gl2 = cache.gl;
+                      var programs = this.programs;
+                      for (var i2 = 0, n2 = programs.length; i2 < n2; ++i2) {
+                        var p2 = cache.programs[programs[i2]];
+                        if (p2) {
+                          delete cache.programs[i2];
+                          gl2.deleteProgram(p2);
+                        }
+                      }
+                      gl2.deleteShader(this.shader);
+                      delete cache.shaders[this.type === gl2.FRAGMENT_SHADER | 0][this.src];
+                    }
+                  };
+                  function ContextCache(gl2) {
+                    this.gl = gl2;
+                    this.shaders = [{}, {}];
+                    this.programs = {};
+                  }
+                  var proto = ContextCache.prototype;
+                  function compileShader(gl2, type, src) {
+                    var shader = gl2.createShader(type);
+                    gl2.shaderSource(shader, src);
+                    gl2.compileShader(shader);
+                    if (!gl2.getShaderParameter(shader, gl2.COMPILE_STATUS)) {
+                      var errLog = gl2.getShaderInfoLog(shader);
+                      try {
+                        var fmt = formatCompilerError(errLog, src, type);
+                      } catch (e2) {
+                        console.warn("Failed to format compiler error: " + e2);
+                        throw new GLError(errLog, "Error compiling shader:\n" + errLog);
+                      }
+                      throw new GLError(errLog, fmt.short, fmt.long);
+                    }
+                    return shader;
+                  }
+                  proto.getShaderReference = function(type, src) {
+                    var gl2 = this.gl;
+                    var shaders = this.shaders[type === gl2.FRAGMENT_SHADER | 0];
+                    var shader = shaders[src];
+                    if (!shader || !gl2.isShader(shader.shader)) {
+                      var shaderObj = compileShader(gl2, type, src);
+                      shader = shaders[src] = new ShaderReference(
+                        SHADER_COUNTER++,
+                        src,
+                        type,
+                        shaderObj,
+                        [],
+                        1,
+                        this
+                      );
+                    } else {
+                      shader.count += 1;
+                    }
+                    return shader;
+                  };
+                  function linkProgram(gl2, vshader, fshader, attribs, locations) {
+                    var program = gl2.createProgram();
+                    gl2.attachShader(program, vshader);
+                    gl2.attachShader(program, fshader);
+                    for (var i2 = 0; i2 < attribs.length; ++i2) {
+                      gl2.bindAttribLocation(program, locations[i2], attribs[i2]);
+                    }
+                    gl2.linkProgram(program);
+                    if (!gl2.getProgramParameter(program, gl2.LINK_STATUS)) {
+                      var errLog = gl2.getProgramInfoLog(program);
+                      throw new GLError(errLog, "Error linking program: " + errLog);
+                    }
+                    return program;
+                  }
+                  proto.getProgram = function(vref, fref, attribs, locations) {
+                    var token = [vref.id, fref.id, attribs.join(":"), locations.join(":")].join("@");
+                    var prog = this.programs[token];
+                    if (!prog || !this.gl.isProgram(prog)) {
+                      this.programs[token] = prog = linkProgram(
+                        this.gl,
+                        vref.shader,
+                        fref.shader,
+                        attribs,
+                        locations
+                      );
+                      vref.programs.push(token);
+                      fref.programs.push(token);
+                    }
+                    return prog;
+                  };
+                  function getCache(gl2) {
+                    var ctxCache = CACHE.get(gl2);
+                    if (!ctxCache) {
+                      ctxCache = new ContextCache(gl2);
+                      CACHE.set(gl2, ctxCache);
+                    }
+                    return ctxCache;
+                  }
+                  function getShaderReference(gl2, type, src) {
+                    return getCache(gl2).getShaderReference(type, src);
+                  }
+                  function createProgram(gl2, vref, fref, attribs, locations) {
+                    return getCache(gl2).getProgram(vref, fref, attribs, locations);
+                  }
+                }
+              ),
+              /***/
+              5093: (
+                /***/
+                function(module22) {
+                  module22.exports = negate2;
+                  function negate2(out, a2) {
+                    out[0] = -a2[0];
+                    out[1] = -a2[1];
+                    out[2] = -a2[2];
+                    return out;
+                  }
+                }
+              ),
+              /***/
+              5137: (
+                /***/
+                function(module22, __unused_webpack_exports, __webpack_require__2) {
+                  module22.exports = forEach;
+                  var vec = __webpack_require__2(1091)();
+                  function forEach(a2, stride, offset, count2, fn, arg) {
+                    var i2, l2;
+                    if (!stride) {
+                      stride = 3;
+                    }
+                    if (!offset) {
+                      offset = 0;
+                    }
+                    if (count2) {
+                      l2 = Math.min(count2 * stride + offset, a2.length);
+                    } else {
+                      l2 = a2.length;
+                    }
+                    for (i2 = offset; i2 < l2; i2 += stride) {
+                      vec[0] = a2[i2];
+                      vec[1] = a2[i2 + 1];
+                      vec[2] = a2[i2 + 2];
+                      fn(vec, vec, arg);
+                      a2[i2] = vec[0];
+                      a2[i2 + 1] = vec[1];
+                      a2[i2 + 2] = vec[2];
+                    }
+                    return a2;
+                  }
+                }
+              ),
+              /***/
+              5171: (
+                /***/
+                function(module22, __unused_webpack_exports, __webpack_require__2) {
+                  var gl10 = __webpack_require__2(737);
+                  module22.exports = function lookupConstant(number) {
+                    return gl10[number];
+                  };
+                }
+              ),
+              /***/
+              5177: (
+                /***/
+                function(module22) {
+                  module22.exports = normalize;
+                  function normalize(out, a2) {
+                    var x2 = a2[0], y2 = a2[1], z2 = a2[2], w2 = a2[3];
+                    var len2 = x2 * x2 + y2 * y2 + z2 * z2 + w2 * w2;
+                    if (len2 > 0) {
+                      len2 = 1 / Math.sqrt(len2);
+                      out[0] = x2 * len2;
+                      out[1] = y2 * len2;
+                      out[2] = z2 * len2;
+                      out[3] = w2 * len2;
+                    }
+                    return out;
+                  }
+                }
+              ),
+              /***/
+              5202: (
+                /***/
+                function(module22, __unused_webpack_exports, __webpack_require__2) {
+                  var robustDot = __webpack_require__2(1944);
+                  var robustSum = __webpack_require__2(8210);
+                  module22.exports = splitPolygon;
+                  module22.exports.positive = positive;
+                  module22.exports.negative = negative;
+                  function planeT(p2, plane) {
+                    var r2 = robustSum(robustDot(p2, plane), [plane[plane.length - 1]]);
+                    return r2[r2.length - 1];
+                  }
+                  function lerpW(a2, wa2, b2, wb2) {
+                    var d2 = wb2 - wa2;
+                    var t4 = -wa2 / d2;
+                    if (t4 < 0) {
+                      t4 = 0;
+                    } else if (t4 > 1) {
+                      t4 = 1;
+                    }
+                    var ti2 = 1 - t4;
+                    var n2 = a2.length;
+                    var r2 = new Array(n2);
+                    for (var i2 = 0; i2 < n2; ++i2) {
+                      r2[i2] = t4 * a2[i2] + ti2 * b2[i2];
+                    }
+                    return r2;
+                  }
+                  function splitPolygon(points, plane) {
+                    var pos = [];
+                    var neg = [];
+                    var a2 = planeT(points[points.length - 1], plane);
+                    for (var s2 = points[points.length - 1], t4 = points[0], i2 = 0; i2 < points.length; ++i2, s2 = t4) {
+                      t4 = points[i2];
+                      var b2 = planeT(t4, plane);
+                      if (a2 < 0 && b2 > 0 || a2 > 0 && b2 < 0) {
+                        var p2 = lerpW(s2, b2, t4, a2);
+                        pos.push(p2);
+                        neg.push(p2.slice());
+                      }
+                      if (b2 < 0) {
+                        neg.push(t4.slice());
+                      } else if (b2 > 0) {
+                        pos.push(t4.slice());
+                      } else {
+                        pos.push(t4.slice());
+                        neg.push(t4.slice());
+                      }
+                      a2 = b2;
+                    }
+                    return { positive: pos, negative: neg };
+                  }
+                  function positive(points, plane) {
+                    var pos = [];
+                    var a2 = planeT(points[points.length - 1], plane);
+                    for (var s2 = points[points.length - 1], t4 = points[0], i2 = 0; i2 < points.length; ++i2, s2 = t4) {
+                      t4 = points[i2];
+                      var b2 = planeT(t4, plane);
+                      if (a2 < 0 && b2 > 0 || a2 > 0 && b2 < 0) {
+                        pos.push(lerpW(s2, b2, t4, a2));
+                      }
+                      if (b2 >= 0) {
+                        pos.push(t4.slice());
+                      }
+                      a2 = b2;
+                    }
+                    return pos;
+                  }
+                  function negative(points, plane) {
+                    var neg = [];
+                    var a2 = planeT(points[points.length - 1], plane);
+                    for (var s2 = points[points.length - 1], t4 = points[0], i2 = 0; i2 < points.length; ++i2, s2 = t4) {
+                      t4 = points[i2];
+                      var b2 = planeT(t4, plane);
+                      if (a2 < 0 && b2 > 0 || a2 > 0 && b2 < 0) {
+                        neg.push(lerpW(s2, b2, t4, a2));
+                      }
+                      if (b2 <= 0) {
+                        neg.push(t4.slice());
+                      }
+                      a2 = b2;
+                    }
+                    return neg;
+                  }
+                }
+              ),
+              /***/
+              5219: (
+                /***/
+                function(module22) {
+                  module22.exports = function(str) {
+                    var l2 = str.length, a2;
+                    for (var i2 = 0; i2 < l2; i2++) {
+                      a2 = str.charCodeAt(i2);
+                      if ((a2 < 9 || a2 > 13) && a2 !== 32 && a2 !== 133 && a2 !== 160 && a2 !== 5760 && a2 !== 6158 && (a2 < 8192 || a2 > 8205) && a2 !== 8232 && a2 !== 8233 && a2 !== 8239 && a2 !== 8287 && a2 !== 8288 && a2 !== 12288 && a2 !== 65279) {
+                        return false;
+                      }
+                    }
+                    return true;
+                  };
+                }
+              ),
+              /***/
+              5250: (
+                /***/
+                function(module22) {
+                  module22.exports = twoProduct;
+                  var SPLITTER = +(Math.pow(2, 27) + 1);
+                  function twoProduct(a2, b2, result) {
+                    var x2 = a2 * b2;
+                    var c2 = SPLITTER * a2;
+                    var abig = c2 - a2;
+                    var ahi = c2 - abig;
+                    var alo = a2 - ahi;
+                    var d2 = SPLITTER * b2;
+                    var bbig = d2 - b2;
+                    var bhi = d2 - bbig;
+                    var blo = b2 - bhi;
+                    var err1 = x2 - ahi * bhi;
+                    var err2 = err1 - alo * bhi;
+                    var err3 = err2 - ahi * blo;
+                    var y2 = alo * blo - err3;
+                    if (result) {
+                      result[0] = y2;
+                      result[1] = x2;
+                      return result;
+                    }
+                    return [y2, x2];
+                  }
+                }
+              ),
+              /***/
+              5298: (
+                /***/
+                function(__unused_webpack_module, exports2) {
+                  var CACHED_CWiseOp = {
+                    "float64,2,1,0": function() {
+                      return function divseq_cwise_loop_2s1s0m3f64(SS, a0, t02, p0, Y0) {
+                        var s0 = SS[0], s1 = SS[1], s2 = SS[2], t0p0 = t02[0], t0p1 = t02[1], t0p2 = t02[2];
+                        p0 |= 0;
+                        var i0 = 0, i1 = 0, i2 = 0, d0s0 = t0p2, d0s1 = t0p1 - s2 * t0p2, d0s2 = t0p0 - s1 * t0p1;
+                        for (i2 = 0; i2 < s0; ++i2) {
+                          for (i1 = 0; i1 < s1; ++i1) {
+                            for (i0 = 0; i0 < s2; ++i0) {
+                              a0[p0] /= Y0;
+                              p0 += d0s0;
+                            }
+                            p0 += d0s1;
+                          }
+                          p0 += d0s2;
+                        }
+                      };
+                    },
+                    "uint8,2,0,1,float64,2,1,0": function() {
+                      return function muls_cwise_loop_2s0s1m1u8f64(SS, a0, t02, p0, a1, t12, p1, Y0) {
+                        var s0 = SS[0], s1 = SS[1], s2 = SS[2], t0p0 = t02[0], t0p1 = t02[1], t0p2 = t02[2], t1p0 = t12[0], t1p1 = t12[1], t1p2 = t12[2];
+                        p0 |= 0;
+                        p1 |= 0;
+                        var offset0 = p0;
+                        var offset1 = p1;
+                        for (var j1 = SS[0] | 0; j1 > 0; ) {
+                          if (j1 < 64) {
+                            s0 = j1;
+                            j1 = 0;
+                          } else {
+                            s0 = 64;
+                            j1 -= 64;
+                          }
+                          for (var j2 = SS[1] | 0; j2 > 0; ) {
+                            if (j2 < 64) {
+                              s1 = j2;
+                              j2 = 0;
+                            } else {
+                              s1 = 64;
+                              j2 -= 64;
+                            }
+                            p0 = offset0 + j1 * t0p0 + j2 * t0p1;
+                            p1 = offset1 + j1 * t1p0 + j2 * t1p1;
+                            var i0 = 0, i1 = 0, i2 = 0, d0s0 = t0p2, d0s1 = t0p0 - s2 * t0p2, d0s2 = t0p1 - s0 * t0p0, d1s0 = t1p2, d1s1 = t1p0 - s2 * t1p2, d1s2 = t1p1 - s0 * t1p0;
+                            for (i2 = 0; i2 < s1; ++i2) {
+                              for (i1 = 0; i1 < s0; ++i1) {
+                                for (i0 = 0; i0 < s2; ++i0) {
+                                  a0[p0] = a1[p1] * Y0;
+                                  p0 += d0s0;
+                                  p1 += d1s0;
+                                }
+                                p0 += d0s1;
+                                p1 += d1s1;
+                              }
+                              p0 += d0s2;
+                              p1 += d1s2;
+                            }
+                          }
+                        }
+                      };
+                    },
+                    "float32,1,0,float32,1,0": function() {
+                      return function assign_cwise_loop_1s0m2f32(SS, a0, t02, p0, a1, t12, p1) {
+                        var s0 = SS[0], s1 = SS[1], t0p0 = t02[0], t0p1 = t02[1], t1p0 = t12[0], t1p1 = t12[1];
+                        p0 |= 0;
+                        p1 |= 0;
+                        var i0 = 0, i1 = 0, d0s0 = t0p1, d0s1 = t0p0 - s1 * t0p1, d1s0 = t1p1, d1s1 = t1p0 - s1 * t1p1;
+                        for (i1 = 0; i1 < s0; ++i1) {
+                          for (i0 = 0; i0 < s1; ++i0) {
+                            a0[p0] = a1[p1];
+                            p0 += d0s0;
+                            p1 += d1s0;
+                          }
+                          p0 += d0s1;
+                          p1 += d1s1;
+                        }
+                      };
+                    },
+                    "float32,1,0,float32,0,1": function() {
+                      return function assign_cwise_loop_1s0m0f32(SS, a0, t02, p0, a1, t12, p1) {
+                        var s0 = SS[0], s1 = SS[1], t0p0 = t02[0], t0p1 = t02[1], t1p0 = t12[0], t1p1 = t12[1];
+                        p0 |= 0;
+                        p1 |= 0;
+                        var offset0 = p0;
+                        var offset1 = p1;
+                        for (var j0 = SS[1] | 0; j0 > 0; ) {
+                          if (j0 < 64) {
+                            s1 = j0;
+                            j0 = 0;
+                          } else {
+                            s1 = 64;
+                            j0 -= 64;
+                          }
+                          for (var j1 = SS[0] | 0; j1 > 0; ) {
+                            if (j1 < 64) {
+                              s0 = j1;
+                              j1 = 0;
+                            } else {
+                              s0 = 64;
+                              j1 -= 64;
+                            }
+                            p0 = offset0 + j0 * t0p1 + j1 * t0p0;
+                            p1 = offset1 + j0 * t1p1 + j1 * t1p0;
+                            var i0 = 0, i1 = 0, d0s0 = t0p1, d0s1 = t0p0 - s1 * t0p1, d1s0 = t1p1, d1s1 = t1p0 - s1 * t1p1;
+                            for (i1 = 0; i1 < s0; ++i1) {
+                              for (i0 = 0; i0 < s1; ++i0) {
+                                a0[p0] = a1[p1];
+                                p0 += d0s0;
+                                p1 += d1s0;
+                              }
+                              p0 += d0s1;
+                              p1 += d1s1;
+                            }
+                          }
+                        }
+                      };
+                    },
+                    "uint8,2,0,1,uint8,1,2,0": function() {
+                      return function assign_cwise_loop_2s0s1m0u8(SS, a0, t02, p0, a1, t12, p1) {
+                        var s0 = SS[0], s1 = SS[1], s2 = SS[2], t0p0 = t02[0], t0p1 = t02[1], t0p2 = t02[2], t1p0 = t12[0], t1p1 = t12[1], t1p2 = t12[2];
+                        p0 |= 0;
+                        p1 |= 0;
+                        var offset0 = p0;
+                        var offset1 = p1;
+                        for (var j0 = SS[2] | 0; j0 > 0; ) {
+                          if (j0 < 64) {
+                            s2 = j0;
+                            j0 = 0;
+                          } else {
+                            s2 = 64;
+                            j0 -= 64;
+                          }
+                          for (var j1 = SS[0] | 0; j1 > 0; ) {
+                            if (j1 < 64) {
+                              s0 = j1;
+                              j1 = 0;
+                            } else {
+                              s0 = 64;
+                              j1 -= 64;
+                            }
+                            for (var j2 = SS[1] | 0; j2 > 0; ) {
+                              if (j2 < 64) {
+                                s1 = j2;
+                                j2 = 0;
+                              } else {
+                                s1 = 64;
+                                j2 -= 64;
+                              }
+                              p0 = offset0 + j0 * t0p2 + j1 * t0p0 + j2 * t0p1;
+                              p1 = offset1 + j0 * t1p2 + j1 * t1p0 + j2 * t1p1;
+                              var i0 = 0, i1 = 0, i2 = 0, d0s0 = t0p2, d0s1 = t0p0 - s2 * t0p2, d0s2 = t0p1 - s0 * t0p0, d1s0 = t1p2, d1s1 = t1p0 - s2 * t1p2, d1s2 = t1p1 - s0 * t1p0;
+                              for (i2 = 0; i2 < s1; ++i2) {
+                                for (i1 = 0; i1 < s0; ++i1) {
+                                  for (i0 = 0; i0 < s2; ++i0) {
+                                    a0[p0] = a1[p1];
+                                    p0 += d0s0;
+                                    p1 += d1s0;
+                                  }
+                                  p0 += d0s1;
+                                  p1 += d1s1;
+                                }
+                                p0 += d0s2;
+                                p1 += d1s2;
+                              }
+                            }
+                          }
+                        }
+                      };
+                    },
+                    "uint8,2,0,1,array,2,0,1": function() {
+                      return function assign_cwise_loop_2s0s1m3u8a(SS, a0, t02, p0, a1, t12, p1) {
+                        var s0 = SS[0], s1 = SS[1], s2 = SS[2], t0p0 = t02[0], t0p1 = t02[1], t0p2 = t02[2], t1p0 = t12[0], t1p1 = t12[1], t1p2 = t12[2];
+                        p0 |= 0;
+                        p1 |= 0;
+                        var i0 = 0, i1 = 0, i2 = 0, d0s0 = t0p2, d0s1 = t0p0 - s2 * t0p2, d0s2 = t0p1 - s0 * t0p0, d1s0 = t1p2, d1s1 = t1p0 - s2 * t1p2, d1s2 = t1p1 - s0 * t1p0;
+                        for (i2 = 0; i2 < s1; ++i2) {
+                          for (i1 = 0; i1 < s0; ++i1) {
+                            for (i0 = 0; i0 < s2; ++i0) {
+                              a0[p0] = a1[p1];
+                              p0 += d0s0;
+                              p1 += d1s0;
+                            }
+                            p0 += d0s1;
+                            p1 += d1s1;
+                          }
+                          p0 += d0s2;
+                          p1 += d1s2;
+                        }
+                      };
+                    }
+                  };
+                  function generateCWiseOp(proc, typesig) {
+                    var key = typesig.join(",");
+                    var f2 = CACHED_CWiseOp[key];
+                    return f2();
+                  }
+                  var compile = generateCWiseOp;
+                  var CACHED_thunk = {
+                    mul: function(compile2) {
+                      var CACHED = {};
+                      return function mul_cwise_thunk(array0, array1, array2) {
+                        var t02 = array0.dtype, r0 = array0.order, t12 = array1.dtype, r1 = array1.order, t22 = array2.dtype, r2 = array2.order, type = [t02, r0.join(), t12, r1.join(), t22, r2.join()].join(), proc = CACHED[type];
+                        if (!proc) {
+                          CACHED[type] = proc = compile2([t02, r0, t12, r1, t22, r2]);
+                        }
+                        return proc(
+                          array0.shape.slice(0),
+                          array0.data,
+                          array0.stride,
+                          array0.offset | 0,
+                          array1.data,
+                          array1.stride,
+                          array1.offset | 0,
+                          array2.data,
+                          array2.stride,
+                          array2.offset | 0
+                        );
+                      };
+                    },
+                    muls: function(compile2) {
+                      var CACHED = {};
+                      return function muls_cwise_thunk(array0, array1, scalar2) {
+                        var t02 = array0.dtype, r0 = array0.order, t12 = array1.dtype, r1 = array1.order, type = [t02, r0.join(), t12, r1.join()].join(), proc = CACHED[type];
+                        if (!proc) {
+                          CACHED[type] = proc = compile2([t02, r0, t12, r1]);
+                        }
+                        return proc(
+                          array0.shape.slice(0),
+                          array0.data,
+                          array0.stride,
+                          array0.offset | 0,
+                          array1.data,
+                          array1.stride,
+                          array1.offset | 0,
+                          scalar2
+                        );
+                      };
+                    },
+                    mulseq: function(compile2) {
+                      var CACHED = {};
+                      return function mulseq_cwise_thunk(array0, scalar1) {
+                        var t02 = array0.dtype, r0 = array0.order, type = [t02, r0.join()].join(), proc = CACHED[type];
+                        if (!proc) {
+                          CACHED[type] = proc = compile2([t02, r0]);
+                        }
+                        return proc(array0.shape.slice(0), array0.data, array0.stride, array0.offset | 0, scalar1);
+                      };
+                    },
+                    div: function(compile2) {
+                      var CACHED = {};
+                      return function div_cwise_thunk(array0, array1, array2) {
+                        var t02 = array0.dtype, r0 = array0.order, t12 = array1.dtype, r1 = array1.order, t22 = array2.dtype, r2 = array2.order, type = [t02, r0.join(), t12, r1.join(), t22, r2.join()].join(), proc = CACHED[type];
+                        if (!proc) {
+                          CACHED[type] = proc = compile2([t02, r0, t12, r1, t22, r2]);
+                        }
+                        return proc(
+                          array0.shape.slice(0),
+                          array0.data,
+                          array0.stride,
+                          array0.offset | 0,
+                          array1.data,
+                          array1.stride,
+                          array1.offset | 0,
+                          array2.data,
+                          array2.stride,
+                          array2.offset | 0
+                        );
+                      };
+                    },
+                    divs: function(compile2) {
+                      var CACHED = {};
+                      return function divs_cwise_thunk(array0, array1, scalar2) {
+                        var t02 = array0.dtype, r0 = array0.order, t12 = array1.dtype, r1 = array1.order, type = [t02, r0.join(), t12, r1.join()].join(), proc = CACHED[type];
+                        if (!proc) {
+                          CACHED[type] = proc = compile2([t02, r0, t12, r1]);
+                        }
+                        return proc(
+                          array0.shape.slice(0),
+                          array0.data,
+                          array0.stride,
+                          array0.offset | 0,
+                          array1.data,
+                          array1.stride,
+                          array1.offset | 0,
+                          scalar2
+                        );
+                      };
+                    },
+                    divseq: function(compile2) {
+                      var CACHED = {};
+                      return function divseq_cwise_thunk(array0, scalar1) {
+                        var t02 = array0.dtype, r0 = array0.order, type = [t02, r0.join()].join(), proc = CACHED[type];
+                        if (!proc) {
+                          CACHED[type] = proc = compile2([t02, r0]);
+                        }
+                        return proc(array0.shape.slice(0), array0.data, array0.stride, array0.offset | 0, scalar1);
+                      };
+                    },
+                    assign: function(compile2) {
+                      var CACHED = {};
+                      return function assign_cwise_thunk(array0, array1) {
+                        var t02 = array0.dtype, r0 = array0.order, t12 = array1.dtype, r1 = array1.order, type = [t02, r0.join(), t12, r1.join()].join(), proc = CACHED[type];
+                        if (!proc) {
+                          CACHED[type] = proc = compile2([t02, r0, t12, r1]);
+                        }
+                        return proc(
+                          array0.shape.slice(0),
+                          array0.data,
+                          array0.stride,
+                          array0.offset | 0,
+                          array1.data,
+                          array1.stride,
+                          array1.offset | 0
+                        );
+                      };
+                    }
+                  };
+                  function createThunk(proc) {
+                    var thunk = CACHED_thunk[proc.funcName];
+                    return thunk(compile.bind(void 0, proc));
+                  }
+                  function makeOp(user_args) {
+                    return createThunk({
+                      funcName: user_args.funcName
+                    });
+                  }
+                  var assign_ops = {
+                    mul: "*",
+                    div: "/"
+                  };
+                  (function() {
+                    for (var id2 in assign_ops) {
+                      exports2[id2] = makeOp({
+                        funcName: id2
+                      });
+                      exports2[id2 + "s"] = makeOp({
+                        funcName: id2 + "s"
+                      });
+                      exports2[id2 + "seq"] = makeOp({
+                        funcName: id2 + "seq"
+                      });
+                    }
+                  })();
+                  exports2.assign = makeOp({
+                    funcName: "assign"
+                  });
+                }
+              ),
+              /***/
+              5304: (
+                /***/
+                function(module22, __unused_webpack_exports, __webpack_require__2) {
+                  module22.exports = createBackgroundCube;
+                  var createBuffer = __webpack_require__2(2762);
+                  var createVAO = __webpack_require__2(8116);
+                  var createShader = __webpack_require__2(1879).bg;
+                  function BackgroundCube(gl2, buffer, vao, shader) {
+                    this.gl = gl2;
+                    this.buffer = buffer;
+                    this.vao = vao;
+                    this.shader = shader;
+                  }
+                  var proto = BackgroundCube.prototype;
+                  proto.draw = function(model, view, projection, bounds, enable2, colors) {
+                    var needsBG = false;
+                    for (var i2 = 0; i2 < 3; ++i2) {
+                      needsBG = needsBG || enable2[i2];
+                    }
+                    if (!needsBG) {
+                      return;
+                    }
+                    var gl2 = this.gl;
+                    gl2.enable(gl2.POLYGON_OFFSET_FILL);
+                    gl2.polygonOffset(1, 2);
+                    this.shader.bind();
+                    this.shader.uniforms = {
+                      model,
+                      view,
+                      projection,
+                      bounds,
+                      enable: enable2,
+                      colors
+                    };
+                    this.vao.bind();
+                    this.vao.draw(this.gl.TRIANGLES, 36);
+                    this.vao.unbind();
+                    gl2.disable(gl2.POLYGON_OFFSET_FILL);
+                  };
+                  proto.dispose = function() {
+                    this.vao.dispose();
+                    this.buffer.dispose();
+                    this.shader.dispose();
+                  };
+                  function createBackgroundCube(gl2) {
+                    var vertices = [];
+                    var indices = [];
+                    var ptr = 0;
+                    for (var d2 = 0; d2 < 3; ++d2) {
+                      var u2 = (d2 + 1) % 3;
+                      var v2 = (d2 + 2) % 3;
+                      var x2 = [0, 0, 0];
+                      var c2 = [0, 0, 0];
+                      for (var s2 = -1; s2 <= 1; s2 += 2) {
+                        indices.push(
+                          ptr,
+                          ptr + 2,
+                          ptr + 1,
+                          ptr + 1,
+                          ptr + 2,
+                          ptr + 3
+                        );
+                        x2[d2] = s2;
+                        c2[d2] = s2;
+                        for (var i2 = -1; i2 <= 1; i2 += 2) {
+                          x2[u2] = i2;
+                          for (var j2 = -1; j2 <= 1; j2 += 2) {
+                            x2[v2] = j2;
+                            vertices.push(
+                              x2[0],
+                              x2[1],
+                              x2[2],
+                              c2[0],
+                              c2[1],
+                              c2[2]
+                            );
+                            ptr += 1;
+                          }
+                        }
+                        var tt2 = u2;
+                        u2 = v2;
+                        v2 = tt2;
+                      }
+                    }
+                    var buffer = createBuffer(gl2, new Float32Array(vertices));
+                    var elements = createBuffer(gl2, new Uint16Array(indices), gl2.ELEMENT_ARRAY_BUFFER);
+                    var vao = createVAO(gl2, [
+                      {
+                        buffer,
+                        type: gl2.FLOAT,
+                        size: 3,
+                        offset: 0,
+                        stride: 24
+                      },
+                      {
+                        buffer,
+                        type: gl2.FLOAT,
+                        size: 3,
+                        offset: 12,
+                        stride: 24
+                      }
+                    ], elements);
+                    var shader = createShader(gl2);
+                    shader.attributes.position.location = 0;
+                    shader.attributes.normal.location = 1;
+                    return new BackgroundCube(gl2, buffer, vao, shader);
+                  }
+                }
+              ),
+              /***/
+              5352: (
+                /***/
+                function(module22) {
+                  module22.exports = transformMat42;
+                  function transformMat42(out, a2, m2) {
+                    var x2 = a2[0], y2 = a2[1], z2 = a2[2], w2 = a2[3];
+                    out[0] = m2[0] * x2 + m2[4] * y2 + m2[8] * z2 + m2[12] * w2;
+                    out[1] = m2[1] * x2 + m2[5] * y2 + m2[9] * z2 + m2[13] * w2;
+                    out[2] = m2[2] * x2 + m2[6] * y2 + m2[10] * z2 + m2[14] * w2;
+                    out[3] = m2[3] * x2 + m2[7] * y2 + m2[11] * z2 + m2[15] * w2;
+                    return out;
+                  }
+                }
+              ),
+              /***/
+              5382: (
+                /***/
+                function(module22, __unused_webpack_exports, __webpack_require__2) {
+                  var robustSum = __webpack_require__2(8210);
+                  var robustScale = __webpack_require__2(3012);
+                  module22.exports = robustProduct;
+                  function robustProduct(a2, b2) {
+                    if (a2.length === 1) {
+                      return robustScale(b2, a2[0]);
+                    }
+                    if (b2.length === 1) {
+                      return robustScale(a2, b2[0]);
+                    }
+                    if (a2.length === 0 || b2.length === 0) {
+                      return [0];
+                    }
+                    var r2 = [0];
+                    if (a2.length < b2.length) {
+                      for (var i2 = 0; i2 < a2.length; ++i2) {
+                        r2 = robustSum(r2, robustScale(b2, a2[i2]));
+                      }
+                    } else {
+                      for (var i2 = 0; i2 < b2.length; ++i2) {
+                        r2 = robustSum(r2, robustScale(a2, b2[i2]));
+                      }
+                    }
+                    return r2;
+                  }
+                }
+              ),
+              /***/
+              5445: (
+                /***/
+                function(module22, __unused_webpack_exports, __webpack_require__2) {
+                  module22.exports = axesProperties;
+                  var getPlanes = __webpack_require__2(5033);
+                  var splitPoly = __webpack_require__2(5202);
+                  var cubeParams = __webpack_require__2(6429);
+                  var m4mul = __webpack_require__2(6760);
+                  var m4transpose = __webpack_require__2(5665);
+                  var v4transformMat4 = __webpack_require__2(5352);
+                  var identity22 = new Float32Array([
+                    1,
+                    0,
+                    0,
+                    0,
+                    0,
+                    1,
+                    0,
+                    0,
+                    0,
+                    0,
+                    1,
+                    0,
+                    0,
+                    0,
+                    0,
+                    1
+                  ]);
+                  var mvp = new Float32Array(16);
+                  function AxesRange3D(lo, hi2, pixelsPerDataUnit) {
+                    this.lo = lo;
+                    this.hi = hi2;
+                    this.pixelsPerDataUnit = pixelsPerDataUnit;
+                  }
+                  var SCRATCH_P = [0, 0, 0, 1];
+                  var SCRATCH_Q = [0, 0, 0, 1];
+                  function gradient(result, M2, v2, width, height) {
+                    for (var i2 = 0; i2 < 3; ++i2) {
+                      var p2 = SCRATCH_P;
+                      var q2 = SCRATCH_Q;
+                      for (var j2 = 0; j2 < 3; ++j2) {
+                        q2[j2] = p2[j2] = v2[j2];
+                      }
+                      q2[3] = p2[3] = 1;
+                      q2[i2] += 1;
+                      v4transformMat4(q2, q2, M2);
+                      if (q2[3] < 0) {
+                        result[i2] = Infinity;
+                      }
+                      p2[i2] -= 1;
+                      v4transformMat4(p2, p2, M2);
+                      if (p2[3] < 0) {
+                        result[i2] = Infinity;
+                      }
+                      var dx = (p2[0] / p2[3] - q2[0] / q2[3]) * width;
+                      var dy = (p2[1] / p2[3] - q2[1] / q2[3]) * height;
+                      result[i2] = 0.25 * Math.sqrt(dx * dx + dy * dy);
+                    }
+                    return result;
+                  }
+                  var RANGES = [
+                    new AxesRange3D(Infinity, -Infinity, Infinity),
+                    new AxesRange3D(Infinity, -Infinity, Infinity),
+                    new AxesRange3D(Infinity, -Infinity, Infinity)
+                  ];
+                  var SCRATCH_X = [0, 0, 0];
+                  function axesProperties(axes, camera, width, height, params) {
+                    var model = camera.model || identity22;
+                    var view = camera.view || identity22;
+                    var projection = camera.projection || identity22;
+                    var isOrtho = camera._ortho || false;
+                    var bounds = axes.bounds;
+                    var params = params || cubeParams(model, view, projection, bounds, isOrtho);
+                    var axis = params.axis;
+                    m4mul(mvp, view, model);
+                    m4mul(mvp, projection, mvp);
+                    var ranges = RANGES;
+                    for (var i2 = 0; i2 < 3; ++i2) {
+                      ranges[i2].lo = Infinity;
+                      ranges[i2].hi = -Infinity;
+                      ranges[i2].pixelsPerDataUnit = Infinity;
+                    }
+                    var frustum2 = getPlanes(m4transpose(mvp, mvp));
+                    m4transpose(mvp, mvp);
+                    for (var d2 = 0; d2 < 3; ++d2) {
+                      var u2 = (d2 + 1) % 3;
+                      var v2 = (d2 + 2) % 3;
+                      var x2 = SCRATCH_X;
+                      i_loop:
+                        for (var i2 = 0; i2 < 2; ++i2) {
+                          var poly = [];
+                          if (axis[d2] < 0 === !!i2) {
+                            continue;
+                          }
+                          x2[d2] = bounds[i2][d2];
+                          for (var j2 = 0; j2 < 2; ++j2) {
+                            x2[u2] = bounds[j2 ^ i2][u2];
+                            for (var k2 = 0; k2 < 2; ++k2) {
+                              x2[v2] = bounds[k2 ^ j2 ^ i2][v2];
+                              poly.push(x2.slice());
+                            }
+                          }
+                          var Q2 = isOrtho ? 5 : 4;
+                          for (var j2 = Q2; j2 === Q2; ++j2) {
+                            if (poly.length === 0) {
+                              continue i_loop;
+                            }
+                            poly = splitPoly.positive(poly, frustum2[j2]);
+                          }
+                          for (var j2 = 0; j2 < poly.length; ++j2) {
+                            var v2 = poly[j2];
+                            var grad = gradient(SCRATCH_X, mvp, v2, width, height);
+                            for (var k2 = 0; k2 < 3; ++k2) {
+                              ranges[k2].lo = Math.min(ranges[k2].lo, v2[k2]);
+                              ranges[k2].hi = Math.max(ranges[k2].hi, v2[k2]);
+                              if (k2 !== d2) {
+                                ranges[k2].pixelsPerDataUnit = Math.min(ranges[k2].pixelsPerDataUnit, Math.abs(grad[k2]));
+                              }
+                            }
+                          }
+                        }
+                    }
+                    return ranges;
+                  }
+                }
+              ),
+              /***/
+              5455: (
+                /***/
+                function(module22, __unused_webpack_exports, __webpack_require__2) {
+                  module22.exports = __webpack_require__2(7056);
+                }
+              ),
+              /***/
+              5486: (
+                /***/
+                function(module22, __unused_webpack_exports, __webpack_require__2) {
+                  module22.exports = __webpack_require__2(3066);
+                }
+              ),
+              /***/
+              5542: (
+                /***/
+                function(module22, __unused_webpack_exports, __webpack_require__2) {
+                  var bsearch = __webpack_require__2(2478);
+                  module22.exports = createTriangulation;
+                  function Triangulation(stars, edges) {
+                    this.stars = stars;
+                    this.edges = edges;
+                  }
+                  var proto = Triangulation.prototype;
+                  function removePair(list, j2, k2) {
+                    for (var i2 = 1, n2 = list.length; i2 < n2; i2 += 2) {
+                      if (list[i2 - 1] === j2 && list[i2] === k2) {
+                        list[i2 - 1] = list[n2 - 2];
+                        list[i2] = list[n2 - 1];
+                        list.length = n2 - 2;
+                        return;
+                      }
+                    }
+                  }
+                  proto.isConstraint = /* @__PURE__ */ function() {
+                    var e2 = [0, 0];
+                    function compareLex(a2, b2) {
+                      return a2[0] - b2[0] || a2[1] - b2[1];
+                    }
+                    return function(i2, j2) {
+                      e2[0] = Math.min(i2, j2);
+                      e2[1] = Math.max(i2, j2);
+                      return bsearch.eq(this.edges, e2, compareLex) >= 0;
+                    };
+                  }();
+                  proto.removeTriangle = function(i2, j2, k2) {
+                    var stars = this.stars;
+                    removePair(stars[i2], j2, k2);
+                    removePair(stars[j2], k2, i2);
+                    removePair(stars[k2], i2, j2);
+                  };
+                  proto.addTriangle = function(i2, j2, k2) {
+                    var stars = this.stars;
+                    stars[i2].push(j2, k2);
+                    stars[j2].push(k2, i2);
+                    stars[k2].push(i2, j2);
+                  };
+                  proto.opposite = function(j2, i2) {
+                    var list = this.stars[i2];
+                    for (var k2 = 1, n2 = list.length; k2 < n2; k2 += 2) {
+                      if (list[k2] === j2) {
+                        return list[k2 - 1];
+                      }
+                    }
+                    return -1;
+                  };
+                  proto.flip = function(i2, j2) {
+                    var a2 = this.opposite(i2, j2);
+                    var b2 = this.opposite(j2, i2);
+                    this.removeTriangle(i2, j2, a2);
+                    this.removeTriangle(j2, i2, b2);
+                    this.addTriangle(i2, b2, a2);
+                    this.addTriangle(j2, a2, b2);
+                  };
+                  proto.edges = function() {
+                    var stars = this.stars;
+                    var result = [];
+                    for (var i2 = 0, n2 = stars.length; i2 < n2; ++i2) {
+                      var list = stars[i2];
+                      for (var j2 = 0, m2 = list.length; j2 < m2; j2 += 2) {
+                        result.push([list[j2], list[j2 + 1]]);
+                      }
+                    }
+                    return result;
+                  };
+                  proto.cells = function() {
+                    var stars = this.stars;
+                    var result = [];
+                    for (var i2 = 0, n2 = stars.length; i2 < n2; ++i2) {
+                      var list = stars[i2];
+                      for (var j2 = 0, m2 = list.length; j2 < m2; j2 += 2) {
+                        var s2 = list[j2];
+                        var t4 = list[j2 + 1];
+                        if (i2 < Math.min(s2, t4)) {
+                          result.push([i2, s2, t4]);
+                        }
+                      }
+                    }
+                    return result;
+                  };
+                  function createTriangulation(numVerts, edges) {
+                    var stars = new Array(numVerts);
+                    for (var i2 = 0; i2 < numVerts; ++i2) {
+                      stars[i2] = [];
+                    }
+                    return new Triangulation(stars, edges);
+                  }
+                }
+              ),
+              /***/
+              5567: (
+                /***/
+                function(module22) {
+                  module22.exports = rotateX2;
+                  function rotateX2(out, a2, rad) {
+                    var s2 = Math.sin(rad), c2 = Math.cos(rad), a10 = a2[4], a11 = a2[5], a12 = a2[6], a13 = a2[7], a20 = a2[8], a21 = a2[9], a22 = a2[10], a23 = a2[11];
+                    if (a2 !== out) {
+                      out[0] = a2[0];
+                      out[1] = a2[1];
+                      out[2] = a2[2];
+                      out[3] = a2[3];
+                      out[12] = a2[12];
+                      out[13] = a2[13];
+                      out[14] = a2[14];
+                      out[15] = a2[15];
+                    }
+                    out[4] = a10 * c2 + a20 * s2;
+                    out[5] = a11 * c2 + a21 * s2;
+                    out[6] = a12 * c2 + a22 * s2;
+                    out[7] = a13 * c2 + a23 * s2;
+                    out[8] = a20 * c2 - a10 * s2;
+                    out[9] = a21 * c2 - a11 * s2;
+                    out[10] = a22 * c2 - a12 * s2;
+                    out[11] = a23 * c2 - a13 * s2;
+                    return out;
+                  }
+                }
+              ),
+              /***/
+              5572: (
+                /***/
+                function(module22, __unused_webpack_exports, __webpack_require__2) {
+                  var rationalize = __webpack_require__2(869);
+                  module22.exports = sub2;
+                  function sub2(a2, b2) {
+                    return rationalize(a2[0].mul(b2[1]).sub(a2[1].mul(b2[0])), a2[1].mul(b2[1]));
+                  }
+                }
+              ),
+              /***/
+              5609: (
+                /***/
+                function(module22, __unused_webpack_exports, __webpack_require__2) {
+                  module22.exports = trimLeaves;
+                  var e2a = __webpack_require__2(3134);
+                  function trimLeaves(edges, positions) {
+                    var adj = e2a(edges, positions.length);
+                    var live = new Array(positions.length);
+                    var nbhd = new Array(positions.length);
+                    var dead = [];
+                    for (var i2 = 0; i2 < positions.length; ++i2) {
+                      var count2 = adj[i2].length;
+                      nbhd[i2] = count2;
+                      live[i2] = true;
+                      if (count2 <= 1) {
+                        dead.push(i2);
+                      }
+                    }
+                    while (dead.length > 0) {
+                      var v2 = dead.pop();
+                      live[v2] = false;
+                      var n2 = adj[v2];
+                      for (var i2 = 0; i2 < n2.length; ++i2) {
+                        var u2 = n2[i2];
+                        if (--nbhd[u2] === 0) {
+                          dead.push(u2);
+                        }
+                      }
+                    }
+                    var newIndex = new Array(positions.length);
+                    var npositions = [];
+                    for (var i2 = 0; i2 < positions.length; ++i2) {
+                      if (live[i2]) {
+                        var v2 = npositions.length;
+                        newIndex[i2] = v2;
+                        npositions.push(positions[i2]);
+                      } else {
+                        newIndex[i2] = -1;
+                      }
+                    }
+                    var nedges = [];
+                    for (var i2 = 0; i2 < edges.length; ++i2) {
+                      var e2 = edges[i2];
+                      if (live[e2[0]] && live[e2[1]]) {
+                        nedges.push([newIndex[e2[0]], newIndex[e2[1]]]);
+                      }
+                    }
+                    return [nedges, npositions];
+                  }
+                }
+              ),
+              /***/
+              5632: (
+                /***/
+                function(module22) {
+                  module22.exports = add2;
+                  function add2(out, a2, b2) {
+                    out[0] = a2[0] + b2[0];
+                    out[1] = a2[1] + b2[1];
+                    out[2] = a2[2] + b2[2];
+                    return out;
+                  }
+                }
+              ),
+              /***/
+              5665: (
+                /***/
+                function(module22) {
+                  module22.exports = transpose2;
+                  function transpose2(out, a2) {
+                    if (out === a2) {
+                      var a01 = a2[1], a02 = a2[2], a03 = a2[3], a12 = a2[6], a13 = a2[7], a23 = a2[11];
+                      out[1] = a2[4];
+                      out[2] = a2[8];
+                      out[3] = a2[12];
+                      out[4] = a01;
+                      out[6] = a2[9];
+                      out[7] = a2[13];
+                      out[8] = a02;
+                      out[9] = a12;
+                      out[11] = a2[14];
+                      out[12] = a03;
+                      out[13] = a13;
+                      out[14] = a23;
+                    } else {
+                      out[0] = a2[0];
+                      out[1] = a2[4];
+                      out[2] = a2[8];
+                      out[3] = a2[12];
+                      out[4] = a2[1];
+                      out[5] = a2[5];
+                      out[6] = a2[9];
+                      out[7] = a2[13];
+                      out[8] = a2[2];
+                      out[9] = a2[6];
+                      out[10] = a2[10];
+                      out[11] = a2[14];
+                      out[12] = a2[3];
+                      out[13] = a2[7];
+                      out[14] = a2[11];
+                      out[15] = a2[15];
+                    }
+                    return out;
+                  }
+                }
+              ),
+              /***/
+              5673: (
+                /***/
+                function(module22) {
+                  module22.exports = transformMat42;
+                  function transformMat42(out, a2, m2) {
+                    var x2 = a2[0], y2 = a2[1], z2 = a2[2], w2 = m2[3] * x2 + m2[7] * y2 + m2[11] * z2 + m2[15];
+                    w2 = w2 || 1;
+                    out[0] = (m2[0] * x2 + m2[4] * y2 + m2[8] * z2 + m2[12]) / w2;
+                    out[1] = (m2[1] * x2 + m2[5] * y2 + m2[9] * z2 + m2[13]) / w2;
+                    out[2] = (m2[2] * x2 + m2[6] * y2 + m2[10] * z2 + m2[14]) / w2;
+                    return out;
+                  }
+                }
+              ),
+              /***/
+              5714: (
+                /***/
+                function(module22, __unused_webpack_exports, __webpack_require__2) {
+                  module22.exports = createLinePlot;
+                  var createBuffer = __webpack_require__2(2762);
+                  var createVAO = __webpack_require__2(8116);
+                  var createTexture2 = __webpack_require__2(7766);
+                  var UINT8_VIEW = new Uint8Array(4);
+                  var FLOAT_VIEW = new Float32Array(UINT8_VIEW.buffer);
+                  function unpackFloat(x2, y2, z2, w2) {
+                    UINT8_VIEW[0] = w2;
+                    UINT8_VIEW[1] = z2;
+                    UINT8_VIEW[2] = y2;
+                    UINT8_VIEW[3] = x2;
+                    return FLOAT_VIEW[0];
+                  }
+                  var bsearch = __webpack_require__2(2478);
+                  var ndarray = __webpack_require__2(9618);
+                  var shaders = __webpack_require__2(7319);
+                  var createShader = shaders.createShader;
+                  var createPickShader = shaders.createPickShader;
+                  var identity22 = [
+                    1,
+                    0,
+                    0,
+                    0,
+                    0,
+                    1,
+                    0,
+                    0,
+                    0,
+                    0,
+                    1,
+                    0,
+                    0,
+                    0,
+                    0,
+                    1
+                  ];
+                  function distance2(a2, b2) {
+                    var s2 = 0;
+                    for (var i2 = 0; i2 < 3; ++i2) {
+                      var d2 = a2[i2] - b2[i2];
+                      s2 += d2 * d2;
+                    }
+                    return Math.sqrt(s2);
+                  }
+                  function filterClipBounds(bounds) {
+                    var result = [[-1e6, -1e6, -1e6], [1e6, 1e6, 1e6]];
+                    for (var i2 = 0; i2 < 3; ++i2) {
+                      result[0][i2] = Math.max(bounds[0][i2], result[0][i2]);
+                      result[1][i2] = Math.min(bounds[1][i2], result[1][i2]);
+                    }
+                    return result;
+                  }
+                  function PickResult(tau, position, index, dataCoordinate) {
+                    this.arcLength = tau;
+                    this.position = position;
+                    this.index = index;
+                    this.dataCoordinate = dataCoordinate;
+                  }
+                  function LinePlot(gl2, shader, pickShader, buffer, vao, texture) {
+                    this.gl = gl2;
+                    this.shader = shader;
+                    this.pickShader = pickShader;
+                    this.buffer = buffer;
+                    this.vao = vao;
+                    this.clipBounds = [
+                      [-Infinity, -Infinity, -Infinity],
+                      [Infinity, Infinity, Infinity]
+                    ];
+                    this.points = [];
+                    this.arcLength = [];
+                    this.vertexCount = 0;
+                    this.bounds = [[0, 0, 0], [0, 0, 0]];
+                    this.pickId = 0;
+                    this.lineWidth = 1;
+                    this.texture = texture;
+                    this.dashScale = 1;
+                    this.opacity = 1;
+                    this.hasAlpha = false;
+                    this.dirty = true;
+                    this.pixelRatio = 1;
+                  }
+                  var proto = LinePlot.prototype;
+                  proto.isTransparent = function() {
+                    return this.hasAlpha;
+                  };
+                  proto.isOpaque = function() {
+                    return !this.hasAlpha;
+                  };
+                  proto.pickSlots = 1;
+                  proto.setPickBase = function(id2) {
+                    this.pickId = id2;
+                  };
+                  proto.drawTransparent = proto.draw = function(camera) {
+                    if (!this.vertexCount) return;
+                    var gl2 = this.gl;
+                    var shader = this.shader;
+                    var vao = this.vao;
+                    shader.bind();
+                    shader.uniforms = {
+                      model: camera.model || identity22,
+                      view: camera.view || identity22,
+                      projection: camera.projection || identity22,
+                      clipBounds: filterClipBounds(this.clipBounds),
+                      dashTexture: this.texture.bind(),
+                      dashScale: this.dashScale / this.arcLength[this.arcLength.length - 1],
+                      opacity: this.opacity,
+                      screenShape: [gl2.drawingBufferWidth, gl2.drawingBufferHeight],
+                      pixelRatio: this.pixelRatio
+                    };
+                    vao.bind();
+                    vao.draw(gl2.TRIANGLE_STRIP, this.vertexCount);
+                    vao.unbind();
+                  };
+                  proto.drawPick = function(camera) {
+                    if (!this.vertexCount) return;
+                    var gl2 = this.gl;
+                    var shader = this.pickShader;
+                    var vao = this.vao;
+                    shader.bind();
+                    shader.uniforms = {
+                      model: camera.model || identity22,
+                      view: camera.view || identity22,
+                      projection: camera.projection || identity22,
+                      pickId: this.pickId,
+                      clipBounds: filterClipBounds(this.clipBounds),
+                      screenShape: [gl2.drawingBufferWidth, gl2.drawingBufferHeight],
+                      pixelRatio: this.pixelRatio
+                    };
+                    vao.bind();
+                    vao.draw(gl2.TRIANGLE_STRIP, this.vertexCount);
+                    vao.unbind();
+                  };
+                  proto.update = function(options) {
+                    var i2, j2;
+                    this.dirty = true;
+                    var connectGaps = !!options.connectGaps;
+                    if ("dashScale" in options) {
+                      this.dashScale = options.dashScale;
+                    }
+                    this.hasAlpha = false;
+                    if ("opacity" in options) {
+                      this.opacity = +options.opacity;
+                      if (this.opacity < 1) {
+                        this.hasAlpha = true;
+                      }
+                    }
+                    var buffer = [];
+                    var arcLengthArray = [];
+                    var pointArray = [];
+                    var arcLength = 0;
+                    var vertexCount = 0;
+                    var bounds = [
+                      [Infinity, Infinity, Infinity],
+                      [-Infinity, -Infinity, -Infinity]
+                    ];
+                    var positions = options.position || options.positions;
+                    if (positions) {
+                      var colors = options.color || options.colors || [0, 0, 0, 1];
+                      var lineWidth = options.lineWidth || 1;
+                      var hadGap = false;
+                      fill_loop:
+                        for (i2 = 1; i2 < positions.length; ++i2) {
+                          var a2 = positions[i2 - 1];
+                          var b2 = positions[i2];
+                          arcLengthArray.push(arcLength);
+                          pointArray.push(a2.slice());
+                          for (j2 = 0; j2 < 3; ++j2) {
+                            if (isNaN(a2[j2]) || isNaN(b2[j2]) || !isFinite(a2[j2]) || !isFinite(b2[j2])) {
+                              if (!connectGaps && buffer.length > 0) {
+                                for (var k2 = 0; k2 < 24; ++k2) {
+                                  buffer.push(buffer[buffer.length - 12]);
+                                }
+                                vertexCount += 2;
+                                hadGap = true;
+                              }
+                              continue fill_loop;
+                            }
+                            bounds[0][j2] = Math.min(bounds[0][j2], a2[j2], b2[j2]);
+                            bounds[1][j2] = Math.max(bounds[1][j2], a2[j2], b2[j2]);
+                          }
+                          var acolor, bcolor;
+                          if (Array.isArray(colors[0])) {
+                            acolor = colors.length > i2 - 1 ? colors[i2 - 1] : (
+                              // using index value
+                              colors.length > 0 ? colors[colors.length - 1] : (
+                                // using last item
+                                [0, 0, 0, 1]
+                              )
+                            );
+                            bcolor = colors.length > i2 ? colors[i2] : (
+                              // using index value
+                              colors.length > 0 ? colors[colors.length - 1] : (
+                                // using last item
+                                [0, 0, 0, 1]
+                              )
+                            );
+                          } else {
+                            acolor = bcolor = colors;
+                          }
+                          if (acolor.length === 3) {
+                            acolor = [acolor[0], acolor[1], acolor[2], 1];
+                          }
+                          if (bcolor.length === 3) {
+                            bcolor = [bcolor[0], bcolor[1], bcolor[2], 1];
+                          }
+                          if (!this.hasAlpha && acolor[3] < 1) this.hasAlpha = true;
+                          var w0;
+                          if (Array.isArray(lineWidth)) {
+                            w0 = lineWidth.length > i2 - 1 ? lineWidth[i2 - 1] : (
+                              // using index value
+                              lineWidth.length > 0 ? lineWidth[lineWidth.length - 1] : (
+                                // using last item
+                                [0, 0, 0, 1]
+                              )
+                            );
+                          } else {
+                            w0 = lineWidth;
+                          }
+                          var t02 = arcLength;
+                          arcLength += distance2(a2, b2);
+                          if (hadGap) {
+                            for (j2 = 0; j2 < 2; ++j2) {
+                              buffer.push(
+                                a2[0],
+                                a2[1],
+                                a2[2],
+                                b2[0],
+                                b2[1],
+                                b2[2],
+                                t02,
+                                w0,
+                                acolor[0],
+                                acolor[1],
+                                acolor[2],
+                                acolor[3]
+                              );
+                            }
+                            vertexCount += 2;
+                            hadGap = false;
+                          }
+                          buffer.push(
+                            a2[0],
+                            a2[1],
+                            a2[2],
+                            b2[0],
+                            b2[1],
+                            b2[2],
+                            t02,
+                            w0,
+                            acolor[0],
+                            acolor[1],
+                            acolor[2],
+                            acolor[3],
+                            a2[0],
+                            a2[1],
+                            a2[2],
+                            b2[0],
+                            b2[1],
+                            b2[2],
+                            t02,
+                            -w0,
+                            acolor[0],
+                            acolor[1],
+                            acolor[2],
+                            acolor[3],
+                            b2[0],
+                            b2[1],
+                            b2[2],
+                            a2[0],
+                            a2[1],
+                            a2[2],
+                            arcLength,
+                            -w0,
+                            bcolor[0],
+                            bcolor[1],
+                            bcolor[2],
+                            bcolor[3],
+                            b2[0],
+                            b2[1],
+                            b2[2],
+                            a2[0],
+                            a2[1],
+                            a2[2],
+                            arcLength,
+                            w0,
+                            bcolor[0],
+                            bcolor[1],
+                            bcolor[2],
+                            bcolor[3]
+                          );
+                          vertexCount += 4;
+                        }
+                    }
+                    this.buffer.update(buffer);
+                    arcLengthArray.push(arcLength);
+                    pointArray.push(positions[positions.length - 1].slice());
+                    this.bounds = bounds;
+                    this.vertexCount = vertexCount;
+                    this.points = pointArray;
+                    this.arcLength = arcLengthArray;
+                    if ("dashes" in options) {
+                      var dashArray = options.dashes;
+                      var prefixSum = dashArray.slice();
+                      prefixSum.unshift(0);
+                      for (i2 = 1; i2 < prefixSum.length; ++i2) {
+                        prefixSum[i2] = prefixSum[i2 - 1] + prefixSum[i2];
+                      }
+                      var dashTexture = ndarray(new Array(256 * 4), [256, 1, 4]);
+                      for (i2 = 0; i2 < 256; ++i2) {
+                        for (j2 = 0; j2 < 4; ++j2) {
+                          dashTexture.set(i2, 0, j2, 0);
+                        }
+                        if (bsearch.le(prefixSum, prefixSum[prefixSum.length - 1] * i2 / 255) & 1) {
+                          dashTexture.set(i2, 0, 0, 0);
+                        } else {
+                          dashTexture.set(i2, 0, 0, 255);
+                        }
+                      }
+                      this.texture.setPixels(dashTexture);
+                    }
+                  };
+                  proto.dispose = function() {
+                    this.shader.dispose();
+                    this.vao.dispose();
+                    this.buffer.dispose();
+                  };
+                  proto.pick = function(selection) {
+                    if (!selection) {
+                      return null;
+                    }
+                    if (selection.id !== this.pickId) {
+                      return null;
+                    }
+                    var tau = unpackFloat(
+                      selection.value[0],
+                      selection.value[1],
+                      selection.value[2],
+                      0
+                    );
+                    var index = bsearch.le(this.arcLength, tau);
+                    if (index < 0) {
+                      return null;
+                    }
+                    if (index === this.arcLength.length - 1) {
+                      return new PickResult(
+                        this.arcLength[this.arcLength.length - 1],
+                        this.points[this.points.length - 1].slice(),
+                        index
+                      );
+                    }
+                    var a2 = this.points[index];
+                    var b2 = this.points[Math.min(index + 1, this.points.length - 1)];
+                    var t4 = (tau - this.arcLength[index]) / (this.arcLength[index + 1] - this.arcLength[index]);
+                    var ti2 = 1 - t4;
+                    var x2 = [0, 0, 0];
+                    for (var i2 = 0; i2 < 3; ++i2) {
+                      x2[i2] = ti2 * a2[i2] + t4 * b2[i2];
+                    }
+                    var dataIndex = Math.min(t4 < 0.5 ? index : index + 1, this.points.length - 1);
+                    return new PickResult(
+                      tau,
+                      x2,
+                      dataIndex,
+                      this.points[dataIndex]
+                    );
+                  };
+                  function createLinePlot(options) {
+                    var gl2 = options.gl || options.scene && options.scene.gl;
+                    var shader = createShader(gl2);
+                    shader.attributes.position.location = 0;
+                    shader.attributes.nextPosition.location = 1;
+                    shader.attributes.arcLength.location = 2;
+                    shader.attributes.lineWidth.location = 3;
+                    shader.attributes.color.location = 4;
+                    var pickShader = createPickShader(gl2);
+                    pickShader.attributes.position.location = 0;
+                    pickShader.attributes.nextPosition.location = 1;
+                    pickShader.attributes.arcLength.location = 2;
+                    pickShader.attributes.lineWidth.location = 3;
+                    pickShader.attributes.color.location = 4;
+                    var buffer = createBuffer(gl2);
+                    var vao = createVAO(gl2, [
+                      {
+                        "buffer": buffer,
+                        "size": 3,
+                        "offset": 0,
+                        "stride": 48
+                      },
+                      {
+                        "buffer": buffer,
+                        "size": 3,
+                        "offset": 12,
+                        "stride": 48
+                      },
+                      {
+                        "buffer": buffer,
+                        "size": 1,
+                        "offset": 24,
+                        "stride": 48
+                      },
+                      {
+                        "buffer": buffer,
+                        "size": 1,
+                        "offset": 28,
+                        "stride": 48
+                      },
+                      {
+                        "buffer": buffer,
+                        "size": 4,
+                        "offset": 32,
+                        "stride": 48
+                      }
+                    ]);
+                    var defaultTexture = ndarray(new Array(256 * 4), [256, 1, 4]);
+                    for (var i2 = 0; i2 < 256 * 4; ++i2) {
+                      defaultTexture.data[i2] = 255;
+                    }
+                    var texture = createTexture2(gl2, defaultTexture);
+                    texture.wrap = gl2.REPEAT;
+                    var linePlot = new LinePlot(gl2, shader, pickShader, buffer, vao, texture);
+                    linePlot.update(options);
+                    return linePlot;
+                  }
+                }
+              ),
+              /***/
+              5716: (
+                /***/
+                function(module22, __unused_webpack_exports, __webpack_require__2) {
+                  var BN2 = __webpack_require__2(6859);
+                  module22.exports = sign;
+                  function sign(x2) {
+                    return x2.cmp(new BN2(0));
+                  }
+                }
+              ),
+              /***/
+              5721: (
+                /***/
+                function(module22) {
+                  module22.exports = convexHull1d;
+                  function convexHull1d(points) {
+                    var lo = 0;
+                    var hi2 = 0;
+                    for (var i2 = 1; i2 < points.length; ++i2) {
+                      if (points[i2][0] < points[lo][0]) {
+                        lo = i2;
+                      }
+                      if (points[i2][0] > points[hi2][0]) {
+                        hi2 = i2;
+                      }
+                    }
+                    if (lo < hi2) {
+                      return [[lo], [hi2]];
+                    } else if (lo > hi2) {
+                      return [[hi2], [lo]];
+                    } else {
+                      return [[lo]];
+                    }
+                  }
+                }
+              ),
+              /***/
+              5771: (
+                /***/
+                function(module22, __unused_webpack_exports, __webpack_require__2) {
+                  var compareCell = __webpack_require__2(8507);
+                  var compareOrientedCell = __webpack_require__2(3788);
+                  var orientation = __webpack_require__2(2419);
+                  module22.exports = reduceCellComplex;
+                  function reduceCellComplex(cells) {
+                    cells.sort(compareOrientedCell);
+                    var n2 = cells.length;
+                    var ptr = 0;
+                    for (var i2 = 0; i2 < n2; ++i2) {
+                      var c2 = cells[i2];
+                      var o2 = orientation(c2);
+                      if (o2 === 0) {
+                        continue;
+                      }
+                      if (ptr > 0) {
+                        var f2 = cells[ptr - 1];
+                        if (compareCell(c2, f2) === 0 && orientation(f2) !== o2) {
+                          ptr -= 1;
+                          continue;
+                        }
+                      }
+                      cells[ptr++] = c2;
+                    }
+                    cells.length = ptr;
+                    return cells;
+                  }
+                }
+              ),
+              /***/
+              5838: (
+                /***/
+                function(module22, __unused_webpack_exports, __webpack_require__2) {
+                  module22.exports = float2rat;
+                  var rat = __webpack_require__2(7842);
+                  function float2rat(v2) {
+                    var result = new Array(v2.length);
+                    for (var i2 = 0; i2 < v2.length; ++i2) {
+                      result[i2] = rat(v2[i2]);
+                    }
+                    return result;
+                  }
+                }
+              ),
+              /***/
+              5847: (
+                /***/
+                function(module22) {
+                  module22.exports = multiply2;
+                  function multiply2(out, a2, b2) {
+                    out[0] = a2[0] * b2[0];
+                    out[1] = a2[1] * b2[1];
+                    out[2] = a2[2] * b2[2];
+                    return out;
+                  }
+                }
+              ),
+              /***/
+              5874: (
+                /***/
+                function(module22, __unused_webpack_exports, __webpack_require__2) {
+                  module22.exports = tokenize2;
+                  var literals100 = __webpack_require__2(620), operators = __webpack_require__2(7827), builtins100 = __webpack_require__2(6852), literals300es = __webpack_require__2(7932), builtins300es = __webpack_require__2(3508);
+                  var NORMAL = 999, TOKEN = 9999, BLOCK_COMMENT = 0, LINE_COMMENT = 1, PREPROCESSOR = 2, OPERATOR = 3, INTEGER = 4, FLOAT = 5, IDENT = 6, BUILTIN = 7, KEYWORD = 8, WHITESPACE = 9, EOF = 10, HEX = 11;
+                  var map2 = [
+                    "block-comment",
+                    "line-comment",
+                    "preprocessor",
+                    "operator",
+                    "integer",
+                    "float",
+                    "ident",
+                    "builtin",
+                    "keyword",
+                    "whitespace",
+                    "eof",
+                    "integer"
+                  ];
+                  function tokenize2(opt) {
+                    var i2 = 0, total = 0, mode = NORMAL, c2, last, content = [], tokens = [], line = 1, col = 0, start = 0, isnum = false, isoperator = false, input = "", len2;
+                    opt = opt || {};
+                    var allBuiltins = builtins100;
+                    var allLiterals = literals100;
+                    if (opt.version === "300 es") {
+                      allBuiltins = builtins300es;
+                      allLiterals = literals300es;
+                    }
+                    var builtinsDict = {}, literalsDict = {};
+                    for (var i2 = 0; i2 < allBuiltins.length; i2++) {
+                      builtinsDict[allBuiltins[i2]] = true;
+                    }
+                    for (var i2 = 0; i2 < allLiterals.length; i2++) {
+                      literalsDict[allLiterals[i2]] = true;
+                    }
+                    return function(data) {
+                      tokens = [];
+                      if (data !== null) return write(data);
+                      return end();
+                    };
+                    function token(data) {
+                      if (data.length) {
+                        tokens.push({
+                          type: map2[mode],
+                          data,
+                          position: start,
+                          line,
+                          column: col
+                        });
+                      }
+                    }
+                    function write(chunk) {
+                      i2 = 0;
+                      if (chunk.toString) chunk = chunk.toString();
+                      input += chunk.replace(/\r\n/g, "\n");
+                      len2 = input.length;
+                      var last2;
+                      while (c2 = input[i2], i2 < len2) {
+                        last2 = i2;
+                        switch (mode) {
+                          case BLOCK_COMMENT:
+                            i2 = block_comment();
+                            break;
+                          case LINE_COMMENT:
+                            i2 = line_comment();
+                            break;
+                          case PREPROCESSOR:
+                            i2 = preprocessor();
+                            break;
+                          case OPERATOR:
+                            i2 = operator();
+                            break;
+                          case INTEGER:
+                            i2 = integer();
+                            break;
+                          case HEX:
+                            i2 = hex2();
+                            break;
+                          case FLOAT:
+                            i2 = decimal();
+                            break;
+                          case TOKEN:
+                            i2 = readtoken();
+                            break;
+                          case WHITESPACE:
+                            i2 = whitespace();
+                            break;
+                          case NORMAL:
+                            i2 = normal();
+                            break;
+                        }
+                        if (last2 !== i2) {
+                          switch (input[last2]) {
+                            case "\n":
+                              col = 0;
+                              ++line;
+                              break;
+                            default:
+                              ++col;
+                              break;
+                          }
+                        }
+                      }
+                      total += i2;
+                      input = input.slice(i2);
+                      return tokens;
+                    }
+                    function end(chunk) {
+                      if (content.length) {
+                        token(content.join(""));
+                      }
+                      mode = EOF;
+                      token("(eof)");
+                      return tokens;
+                    }
+                    function normal() {
+                      content = content.length ? [] : content;
+                      if (last === "/" && c2 === "*") {
+                        start = total + i2 - 1;
+                        mode = BLOCK_COMMENT;
+                        last = c2;
+                        return i2 + 1;
+                      }
+                      if (last === "/" && c2 === "/") {
+                        start = total + i2 - 1;
+                        mode = LINE_COMMENT;
+                        last = c2;
+                        return i2 + 1;
+                      }
+                      if (c2 === "#") {
+                        mode = PREPROCESSOR;
+                        start = total + i2;
+                        return i2;
+                      }
+                      if (/\s/.test(c2)) {
+                        mode = WHITESPACE;
+                        start = total + i2;
+                        return i2;
+                      }
+                      isnum = /\d/.test(c2);
+                      isoperator = /[^\w_]/.test(c2);
+                      start = total + i2;
+                      mode = isnum ? INTEGER : isoperator ? OPERATOR : TOKEN;
+                      return i2;
+                    }
+                    function whitespace() {
+                      if (/[^\s]/g.test(c2)) {
+                        token(content.join(""));
+                        mode = NORMAL;
+                        return i2;
+                      }
+                      content.push(c2);
+                      last = c2;
+                      return i2 + 1;
+                    }
+                    function preprocessor() {
+                      if ((c2 === "\r" || c2 === "\n") && last !== "\\") {
+                        token(content.join(""));
+                        mode = NORMAL;
+                        return i2;
+                      }
+                      content.push(c2);
+                      last = c2;
+                      return i2 + 1;
+                    }
+                    function line_comment() {
+                      return preprocessor();
+                    }
+                    function block_comment() {
+                      if (c2 === "/" && last === "*") {
+                        content.push(c2);
+                        token(content.join(""));
+                        mode = NORMAL;
+                        return i2 + 1;
+                      }
+                      content.push(c2);
+                      last = c2;
+                      return i2 + 1;
+                    }
+                    function operator() {
+                      if (last === "." && /\d/.test(c2)) {
+                        mode = FLOAT;
+                        return i2;
+                      }
+                      if (last === "/" && c2 === "*") {
+                        mode = BLOCK_COMMENT;
+                        return i2;
+                      }
+                      if (last === "/" && c2 === "/") {
+                        mode = LINE_COMMENT;
+                        return i2;
+                      }
+                      if (c2 === "." && content.length) {
+                        while (determine_operator(content)) ;
+                        mode = FLOAT;
+                        return i2;
+                      }
+                      if (c2 === ";" || c2 === ")" || c2 === "(") {
+                        if (content.length) while (determine_operator(content)) ;
+                        token(c2);
+                        mode = NORMAL;
+                        return i2 + 1;
+                      }
+                      var is_composite_operator = content.length === 2 && c2 !== "=";
+                      if (/[\w_\d\s]/.test(c2) || is_composite_operator) {
+                        while (determine_operator(content)) ;
+                        mode = NORMAL;
+                        return i2;
+                      }
+                      content.push(c2);
+                      last = c2;
+                      return i2 + 1;
+                    }
+                    function determine_operator(buf) {
+                      var j2 = 0, idx, res;
+                      do {
+                        idx = operators.indexOf(buf.slice(0, buf.length + j2).join(""));
+                        res = operators[idx];
+                        if (idx === -1) {
+                          if (j2-- + buf.length > 0) continue;
+                          res = buf.slice(0, 1).join("");
+                        }
+                        token(res);
+                        start += res.length;
+                        content = content.slice(res.length);
+                        return content.length;
+                      } while (1);
+                    }
+                    function hex2() {
+                      if (/[^a-fA-F0-9]/.test(c2)) {
+                        token(content.join(""));
+                        mode = NORMAL;
+                        return i2;
+                      }
+                      content.push(c2);
+                      last = c2;
+                      return i2 + 1;
+                    }
+                    function integer() {
+                      if (c2 === ".") {
+                        content.push(c2);
+                        mode = FLOAT;
+                        last = c2;
+                        return i2 + 1;
+                      }
+                      if (/[eE]/.test(c2)) {
+                        content.push(c2);
+                        mode = FLOAT;
+                        last = c2;
+                        return i2 + 1;
+                      }
+                      if (c2 === "x" && content.length === 1 && content[0] === "0") {
+                        mode = HEX;
+                        content.push(c2);
+                        last = c2;
+                        return i2 + 1;
+                      }
+                      if (/[^\d]/.test(c2)) {
+                        token(content.join(""));
+                        mode = NORMAL;
+                        return i2;
+                      }
+                      content.push(c2);
+                      last = c2;
+                      return i2 + 1;
+                    }
+                    function decimal() {
+                      if (c2 === "f") {
+                        content.push(c2);
+                        last = c2;
+                        i2 += 1;
+                      }
+                      if (/[eE]/.test(c2)) {
+                        content.push(c2);
+                        last = c2;
+                        return i2 + 1;
+                      }
+                      if ((c2 === "-" || c2 === "+") && /[eE]/.test(last)) {
+                        content.push(c2);
+                        last = c2;
+                        return i2 + 1;
+                      }
+                      if (/[^\d]/.test(c2)) {
+                        token(content.join(""));
+                        mode = NORMAL;
+                        return i2;
+                      }
+                      content.push(c2);
+                      last = c2;
+                      return i2 + 1;
+                    }
+                    function readtoken() {
+                      if (/[^\d\w_]/.test(c2)) {
+                        var contentstr = content.join("");
+                        if (literalsDict[contentstr]) {
+                          mode = KEYWORD;
+                        } else if (builtinsDict[contentstr]) {
+                          mode = BUILTIN;
+                        } else {
+                          mode = IDENT;
+                        }
+                        token(content.join(""));
+                        mode = NORMAL;
+                        return i2;
+                      }
+                      content.push(c2);
+                      last = c2;
+                      return i2 + 1;
+                    }
+                  }
+                }
+              ),
+              /***/
+              5878: (
+                /***/
+                function(module22, __unused_webpack_exports, __webpack_require__2) {
+                  module22.exports = simplifyPolygon;
+                  var orient = __webpack_require__2(3250);
+                  var sc2 = __webpack_require__2(2014);
+                  function errorWeight(base, a2, b2) {
+                    var area = Math.abs(orient(base, a2, b2));
+                    var perim = Math.sqrt(Math.pow(a2[0] - b2[0], 2) + Math.pow(a2[1] - b2[1], 2));
+                    return area / perim;
+                  }
+                  function simplifyPolygon(cells, positions, minArea) {
+                    var n2 = positions.length;
+                    var nc2 = cells.length;
+                    var inv = new Array(n2);
+                    var outv = new Array(n2);
+                    var weights = new Array(n2);
+                    var dead = new Array(n2);
+                    for (var i2 = 0; i2 < n2; ++i2) {
+                      inv[i2] = outv[i2] = -1;
+                      weights[i2] = Infinity;
+                      dead[i2] = false;
+                    }
+                    for (var i2 = 0; i2 < nc2; ++i2) {
+                      var c2 = cells[i2];
+                      if (c2.length !== 2) {
+                        throw new Error("Input must be a graph");
+                      }
+                      var s2 = c2[1];
+                      var t4 = c2[0];
+                      if (outv[t4] !== -1) {
+                        outv[t4] = -2;
+                      } else {
+                        outv[t4] = s2;
+                      }
+                      if (inv[s2] !== -1) {
+                        inv[s2] = -2;
+                      } else {
+                        inv[s2] = t4;
+                      }
+                    }
+                    function computeWeight(i22) {
+                      if (dead[i22]) {
+                        return Infinity;
+                      }
+                      var s22 = inv[i22];
+                      var t42 = outv[i22];
+                      if (s22 < 0 || t42 < 0) {
+                        return Infinity;
+                      } else {
+                        return errorWeight(positions[i22], positions[s22], positions[t42]);
+                      }
+                    }
+                    function heapSwap(i22, j2) {
+                      var a2 = heap[i22];
+                      var b2 = heap[j2];
+                      heap[i22] = b2;
+                      heap[j2] = a2;
+                      index[a2] = j2;
+                      index[b2] = i22;
+                    }
+                    function heapWeight(i22) {
+                      return weights[heap[i22]];
+                    }
+                    function heapParent(i22) {
+                      if (i22 & 1) {
+                        return i22 - 1 >> 1;
+                      }
+                      return (i22 >> 1) - 1;
+                    }
+                    function heapDown(i22) {
+                      var w22 = heapWeight(i22);
+                      while (true) {
+                        var tw = w22;
+                        var left = 2 * i22 + 1;
+                        var right = 2 * (i22 + 1);
+                        var next = i22;
+                        if (left < heapCount) {
+                          var lw = heapWeight(left);
+                          if (lw < tw) {
+                            next = left;
+                            tw = lw;
+                          }
+                        }
+                        if (right < heapCount) {
+                          var rw = heapWeight(right);
+                          if (rw < tw) {
+                            next = right;
+                          }
+                        }
+                        if (next === i22) {
+                          return i22;
+                        }
+                        heapSwap(i22, next);
+                        i22 = next;
+                      }
+                    }
+                    function heapUp(i22) {
+                      var w22 = heapWeight(i22);
+                      while (i22 > 0) {
+                        var parent = heapParent(i22);
+                        if (parent >= 0) {
+                          var pw = heapWeight(parent);
+                          if (w22 < pw) {
+                            heapSwap(i22, parent);
+                            i22 = parent;
+                            continue;
+                          }
+                        }
+                        return i22;
+                      }
+                    }
+                    function heapPop() {
+                      if (heapCount > 0) {
+                        var head = heap[0];
+                        heapSwap(0, heapCount - 1);
+                        heapCount -= 1;
+                        heapDown(0);
+                        return head;
+                      }
+                      return -1;
+                    }
+                    function heapUpdate(i22, w22) {
+                      var a2 = heap[i22];
+                      if (weights[a2] === w22) {
+                        return i22;
+                      }
+                      weights[a2] = -Infinity;
+                      heapUp(i22);
+                      heapPop();
+                      weights[a2] = w22;
+                      heapCount += 1;
+                      return heapUp(heapCount - 1);
+                    }
+                    function kill(i22) {
+                      if (dead[i22]) {
+                        return;
+                      }
+                      dead[i22] = true;
+                      var s22 = inv[i22];
+                      var t42 = outv[i22];
+                      if (inv[t42] >= 0) {
+                        inv[t42] = s22;
+                      }
+                      if (outv[s22] >= 0) {
+                        outv[s22] = t42;
+                      }
+                      if (index[s22] >= 0) {
+                        heapUpdate(index[s22], computeWeight(s22));
+                      }
+                      if (index[t42] >= 0) {
+                        heapUpdate(index[t42], computeWeight(t42));
+                      }
+                    }
+                    var heap = [];
+                    var index = new Array(n2);
+                    for (var i2 = 0; i2 < n2; ++i2) {
+                      var w2 = weights[i2] = computeWeight(i2);
+                      if (w2 < Infinity) {
+                        index[i2] = heap.length;
+                        heap.push(i2);
+                      } else {
+                        index[i2] = -1;
+                      }
+                    }
+                    var heapCount = heap.length;
+                    for (var i2 = heapCount >> 1; i2 >= 0; --i2) {
+                      heapDown(i2);
+                    }
+                    while (true) {
+                      var hmin = heapPop();
+                      if (hmin < 0 || weights[hmin] > minArea) {
+                        break;
+                      }
+                      kill(hmin);
+                    }
+                    var npositions = [];
+                    for (var i2 = 0; i2 < n2; ++i2) {
+                      if (!dead[i2]) {
+                        index[i2] = npositions.length;
+                        npositions.push(positions[i2].slice());
+                      }
+                    }
+                    npositions.length;
+                    function tortoiseHare(seq, start) {
+                      if (seq[start] < 0) {
+                        return start;
+                      }
+                      var t42 = start;
+                      var h2 = start;
+                      do {
+                        var nh2 = seq[h2];
+                        if (!dead[h2] || nh2 < 0 || nh2 === h2) {
+                          break;
+                        }
+                        h2 = nh2;
+                        nh2 = seq[h2];
+                        if (!dead[h2] || nh2 < 0 || nh2 === h2) {
+                          break;
+                        }
+                        h2 = nh2;
+                        t42 = seq[t42];
+                      } while (t42 !== h2);
+                      for (var v2 = start; v2 !== h2; v2 = seq[v2]) {
+                        seq[v2] = h2;
+                      }
+                      return h2;
+                    }
+                    var ncells = [];
+                    cells.forEach(function(c22) {
+                      var tin = tortoiseHare(inv, c22[0]);
+                      var tout = tortoiseHare(outv, c22[1]);
+                      if (tin >= 0 && tout >= 0 && tin !== tout) {
+                        var cin = index[tin];
+                        var cout = index[tout];
+                        if (cin !== cout) {
+                          ncells.push([cin, cout]);
+                        }
+                      }
+                    });
+                    sc2.unique(sc2.normalize(ncells));
+                    return {
+                      positions: npositions,
+                      edges: ncells
+                    };
+                  }
+                }
+              ),
+              /***/
+              5911: (
+                /***/
+                function(module22) {
+                  module22.exports = cross2;
+                  function cross2(out, a2, b2) {
+                    var ax = a2[0], ay = a2[1], az = a2[2], bx = b2[0], by = b2[1], bz = b2[2];
+                    out[0] = ay * bz - az * by;
+                    out[1] = az * bx - ax * bz;
+                    out[2] = ax * by - ay * bx;
+                    return out;
+                  }
+                }
+              ),
+              /***/
+              5964: (
+                /***/
+                function(module22) {
+                  module22.exports = function(a2) {
+                    return !a2 && a2 !== 0 ? "" : a2.toString();
+                  };
+                }
+              ),
+              /***/
+              5995: (
+                /***/
+                function(module22, __unused_webpack_exports, __webpack_require__2) {
+                  module22.exports = alphaComplex;
+                  var delaunay = __webpack_require__2(7642);
+                  var circumradius = __webpack_require__2(6037);
+                  function alphaComplex(alpha, points) {
+                    return delaunay(points).filter(function(cell) {
+                      var simplex = new Array(cell.length);
+                      for (var i2 = 0; i2 < cell.length; ++i2) {
+                        simplex[i2] = points[cell[i2]];
+                      }
+                      return circumradius(simplex) * alpha < 1;
+                    });
+                  }
+                }
+              ),
+              /***/
+              6037: (
+                /***/
+                function(module22, __unused_webpack_exports, __webpack_require__2) {
+                  module22.exports = circumradius;
+                  var circumcenter = __webpack_require__2(3628);
+                  function circumradius(points) {
+                    var center = circumcenter(points);
+                    var avgDist = 0;
+                    for (var i2 = 0; i2 < points.length; ++i2) {
+                      var p2 = points[i2];
+                      for (var j2 = 0; j2 < center.length; ++j2) {
+                        avgDist += Math.pow(p2[j2] - center[j2], 2);
+                      }
+                    }
+                    return Math.sqrt(avgDist / points.length);
+                  }
+                }
+              ),
+              /***/
+              6079: (
+                /***/
+                function(module22) {
+                  module22.exports = rotate2;
+                  function rotate2(out, a2, rad, axis) {
+                    var x2 = axis[0], y2 = axis[1], z2 = axis[2], len2 = Math.sqrt(x2 * x2 + y2 * y2 + z2 * z2), s2, c2, t4, a00, a01, a02, a03, a10, a11, a12, a13, a20, a21, a22, a23, b00, b01, b02, b10, b11, b12, b20, b21, b22;
+                    if (Math.abs(len2) < 1e-6) {
+                      return null;
+                    }
+                    len2 = 1 / len2;
+                    x2 *= len2;
+                    y2 *= len2;
+                    z2 *= len2;
+                    s2 = Math.sin(rad);
+                    c2 = Math.cos(rad);
+                    t4 = 1 - c2;
+                    a00 = a2[0];
+                    a01 = a2[1];
+                    a02 = a2[2];
+                    a03 = a2[3];
+                    a10 = a2[4];
+                    a11 = a2[5];
+                    a12 = a2[6];
+                    a13 = a2[7];
+                    a20 = a2[8];
+                    a21 = a2[9];
+                    a22 = a2[10];
+                    a23 = a2[11];
+                    b00 = x2 * x2 * t4 + c2;
+                    b01 = y2 * x2 * t4 + z2 * s2;
+                    b02 = z2 * x2 * t4 - y2 * s2;
+                    b10 = x2 * y2 * t4 - z2 * s2;
+                    b11 = y2 * y2 * t4 + c2;
+                    b12 = z2 * y2 * t4 + x2 * s2;
+                    b20 = x2 * z2 * t4 + y2 * s2;
+                    b21 = y2 * z2 * t4 - x2 * s2;
+                    b22 = z2 * z2 * t4 + c2;
+                    out[0] = a00 * b00 + a10 * b01 + a20 * b02;
+                    out[1] = a01 * b00 + a11 * b01 + a21 * b02;
+                    out[2] = a02 * b00 + a12 * b01 + a22 * b02;
+                    out[3] = a03 * b00 + a13 * b01 + a23 * b02;
+                    out[4] = a00 * b10 + a10 * b11 + a20 * b12;
+                    out[5] = a01 * b10 + a11 * b11 + a21 * b12;
+                    out[6] = a02 * b10 + a12 * b11 + a22 * b12;
+                    out[7] = a03 * b10 + a13 * b11 + a23 * b12;
+                    out[8] = a00 * b20 + a10 * b21 + a20 * b22;
+                    out[9] = a01 * b20 + a11 * b21 + a21 * b22;
+                    out[10] = a02 * b20 + a12 * b21 + a22 * b22;
+                    out[11] = a03 * b20 + a13 * b21 + a23 * b22;
+                    if (a2 !== out) {
+                      out[12] = a2[12];
+                      out[13] = a2[13];
+                      out[14] = a2[14];
+                      out[15] = a2[15];
+                    }
+                    return out;
+                  }
+                }
+              ),
+              /***/
+              6141: (
+                /***/
+                function(module22, __unused_webpack_exports, __webpack_require__2) {
+                  module22.exports = __webpack_require__2(2953);
+                }
+              ),
+              /***/
+              6199: (
+                /***/
+                function(module22, __unused_webpack_exports, __webpack_require__2) {
+                  var dup = __webpack_require__2(1338);
+                  var CACHED_CWiseOp = {
+                    zero: function(SS, a0, t02, p0) {
+                      var s0 = SS[0], t0p0 = t02[0];
+                      p0 |= 0;
+                      var i0 = 0, d0s0 = t0p0;
+                      for (i0 = 0; i0 < s0; ++i0) {
+                        a0[p0] = 0;
+                        p0 += d0s0;
+                      }
+                    },
+                    fdTemplate1: function(SS, a0, t02, p0, a1, t12, p1) {
+                      var s0 = SS[0], t0p0 = t02[0], t1p0 = t12[0], q0 = -1 * t0p0, q1 = t0p0;
+                      p0 |= 0;
+                      p1 |= 0;
+                      var i0 = 0, d0s0 = t0p0, d1s0 = t1p0;
+                      for (i0 = 0; i0 < s0; ++i0) {
+                        a1[p1] = 0.5 * (a0[p0 + q0] - a0[p0 + q1]);
+                        p0 += d0s0;
+                        p1 += d1s0;
+                      }
+                    },
+                    fdTemplate2: function(SS, a0, t02, p0, a1, t12, p1, a2, t22, p2) {
+                      var s0 = SS[0], s1 = SS[1], t0p0 = t02[0], t0p1 = t02[1], t1p0 = t12[0], t1p1 = t12[1], t2p0 = t22[0], t2p1 = t22[1], q0 = -1 * t0p0, q1 = t0p0, q2 = -1 * t0p1, q3 = t0p1;
+                      p0 |= 0;
+                      p1 |= 0;
+                      p2 |= 0;
+                      var i0 = 0, i1 = 0, d0s0 = t0p1, d0s1 = t0p0 - s1 * t0p1, d1s0 = t1p1, d1s1 = t1p0 - s1 * t1p1, d2s0 = t2p1, d2s1 = t2p0 - s1 * t2p1;
+                      for (i1 = 0; i1 < s0; ++i1) {
+                        for (i0 = 0; i0 < s1; ++i0) {
+                          a1[p1] = 0.5 * (a0[p0 + q0] - a0[p0 + q1]);
+                          a2[p2] = 0.5 * (a0[p0 + q2] - a0[p0 + q3]);
+                          p0 += d0s0;
+                          p1 += d1s0;
+                          p2 += d2s0;
+                        }
+                        p0 += d0s1;
+                        p1 += d1s1;
+                        p2 += d2s1;
+                      }
+                    }
+                  };
+                  var CACHED_thunk = {
+                    cdiff: function(compile2) {
+                      var CACHED = {};
+                      return function cdiff_cwise_thunk(array0, array1, array2) {
+                        var t02 = array0.dtype, r0 = array0.order, t12 = array1.dtype, r1 = array1.order, t22 = array2.dtype, r2 = array2.order, type = [t02, r0.join(), t12, r1.join(), t22, r2.join()].join(), proc = CACHED[type];
+                        if (!proc) {
+                          CACHED[type] = proc = compile2([t02, r0, t12, r1, t22, r2]);
+                        }
+                        return proc(array0.shape.slice(0), array0.data, array0.stride, array0.offset | 0, array1.data, array1.stride, array1.offset | 0, array2.data, array2.stride, array2.offset | 0);
+                      };
+                    },
+                    zero: function(compile2) {
+                      var CACHED = {};
+                      return function zero_cwise_thunk(array0) {
+                        var t02 = array0.dtype, r0 = array0.order, type = [t02, r0.join()].join(), proc = CACHED[type];
+                        if (!proc) {
+                          CACHED[type] = proc = compile2([t02, r0]);
+                        }
+                        return proc(array0.shape.slice(0), array0.data, array0.stride, array0.offset | 0);
+                      };
+                    },
+                    fdTemplate1: function(compile2) {
+                      var CACHED = {};
+                      return function fdTemplate1_cwise_thunk(array0, array1) {
+                        var t02 = array0.dtype, r0 = array0.order, t12 = array1.dtype, r1 = array1.order, type = [t02, r0.join(), t12, r1.join()].join(), proc = CACHED[type];
+                        if (!proc) {
+                          CACHED[type] = proc = compile2([t02, r0, t12, r1]);
+                        }
+                        return proc(array0.shape.slice(0), array0.data, array0.stride, array0.offset | 0, array1.data, array1.stride, array1.offset | 0);
+                      };
+                    },
+                    fdTemplate2: function(compile2) {
+                      var CACHED = {};
+                      return function fdTemplate2_cwise_thunk(array0, array1, array4) {
+                        var t02 = array0.dtype, r0 = array0.order, t12 = array1.dtype, r1 = array1.order, t4 = array4.dtype, r4 = array4.order, type = [t02, r0.join(), t12, r1.join(), t4, r4.join()].join(), proc = CACHED[type];
+                        if (!proc) {
+                          CACHED[type] = proc = compile2([t02, r0, t12, r1, t4, r4]);
+                        }
+                        return proc(array0.shape.slice(0), array0.data, array0.stride, array0.offset | 0, array1.data, array1.stride, array1.offset | 0, array4.data, array4.stride, array4.offset | 0);
+                      };
+                    }
+                  };
+                  function createThunk(proc) {
+                    var thunk = CACHED_thunk[proc.funcName];
+                    return thunk(compile.bind(void 0, proc));
+                  }
+                  function compile(proc) {
+                    return CACHED_CWiseOp[proc.funcName];
+                  }
+                  function cwiseCompiler(user_args) {
+                    return createThunk({
+                      funcName: user_args.funcName
+                    });
+                  }
+                  var TEMPLATE_CACHE = {};
+                  var GRADIENT_CACHE = {};
+                  var centralDiff = cwiseCompiler({
+                    funcName: "cdiff"
+                  });
+                  var zeroOut = cwiseCompiler({
+                    funcName: "zero"
+                  });
+                  function generateTemplate(d2) {
+                    if (d2 in TEMPLATE_CACHE) {
+                      return TEMPLATE_CACHE[d2];
+                    }
+                    return TEMPLATE_CACHE[d2] = cwiseCompiler({
+                      funcName: "fdTemplate" + d2
+                    });
+                  }
+                  function CACHED_link(diff, zero2, grad1, grad2) {
+                    return function(dst, src) {
+                      var s2 = src.shape.slice();
+                      if (s2[0] > 2 && s2[1] > 2) {
+                        grad2(
+                          src.pick(-1, -1).lo(1, 1).hi(s2[0] - 2, s2[1] - 2),
+                          dst.pick(-1, -1, 0).lo(1, 1).hi(s2[0] - 2, s2[1] - 2),
+                          dst.pick(-1, -1, 1).lo(1, 1).hi(s2[0] - 2, s2[1] - 2)
+                        );
+                      }
+                      if (s2[1] > 2) {
+                        grad1(
+                          src.pick(0, -1).lo(1).hi(s2[1] - 2),
+                          dst.pick(0, -1, 1).lo(1).hi(s2[1] - 2)
+                        );
+                        zero2(
+                          dst.pick(0, -1, 0).lo(1).hi(s2[1] - 2)
+                        );
+                      }
+                      if (s2[1] > 2) {
+                        grad1(
+                          src.pick(s2[0] - 1, -1).lo(1).hi(s2[1] - 2),
+                          dst.pick(s2[0] - 1, -1, 1).lo(1).hi(s2[1] - 2)
+                        );
+                        zero2(
+                          dst.pick(s2[0] - 1, -1, 0).lo(1).hi(s2[1] - 2)
+                        );
+                      }
+                      if (s2[0] > 2) {
+                        grad1(
+                          src.pick(-1, 0).lo(1).hi(s2[0] - 2),
+                          dst.pick(-1, 0, 0).lo(1).hi(s2[0] - 2)
+                        );
+                        zero2(
+                          dst.pick(-1, 0, 1).lo(1).hi(s2[0] - 2)
+                        );
+                      }
+                      if (s2[0] > 2) {
+                        grad1(
+                          src.pick(-1, s2[1] - 1).lo(1).hi(s2[0] - 2),
+                          dst.pick(-1, s2[1] - 1, 0).lo(1).hi(s2[0] - 2)
+                        );
+                        zero2(
+                          dst.pick(-1, s2[1] - 1, 1).lo(1).hi(s2[0] - 2)
+                        );
+                      }
+                      dst.set(0, 0, 0, 0);
+                      dst.set(0, 0, 1, 0);
+                      dst.set(s2[0] - 1, 0, 0, 0);
+                      dst.set(s2[0] - 1, 0, 1, 0);
+                      dst.set(0, s2[1] - 1, 0, 0);
+                      dst.set(0, s2[1] - 1, 1, 0);
+                      dst.set(s2[0] - 1, s2[1] - 1, 0, 0);
+                      dst.set(s2[0] - 1, s2[1] - 1, 1, 0);
+                      return dst;
+                    };
+                  }
+                  function generateGradient(boundaryConditions) {
+                    var token = boundaryConditions.join();
+                    var proc = GRADIENT_CACHE[token];
+                    if (proc) {
+                      return proc;
+                    }
+                    var d2 = boundaryConditions.length;
+                    var linkArgs = [centralDiff, zeroOut];
+                    for (var i2 = 1; i2 <= d2; ++i2) {
+                      linkArgs.push(generateTemplate(i2));
+                    }
+                    var link = CACHED_link;
+                    var proc = link.apply(void 0, linkArgs);
+                    GRADIENT_CACHE[token] = proc;
+                    return proc;
+                  }
+                  module22.exports = function gradient(out, inp, bc2) {
+                    if (!Array.isArray(bc2)) {
+                      if (typeof bc2 === "string") {
+                        bc2 = dup(inp.dimension, bc2);
+                      } else {
+                        bc2 = dup(inp.dimension, "clamp");
+                      }
+                    }
+                    if (inp.size === 0) {
+                      return out;
+                    }
+                    if (inp.dimension === 0) {
+                      out.set(0);
+                      return out;
+                    }
+                    var cached = generateGradient(bc2);
+                    return cached(out, inp);
+                  };
+                }
+              ),
+              /***/
+              6204: (
+                /***/
+                function(module22) {
+                  module22.exports = boundary;
+                  function boundary(cells) {
+                    var i2, j2, k2;
+                    var n2 = cells.length;
+                    var sz = 0;
+                    for (i2 = 0; i2 < n2; ++i2) {
+                      sz += cells[i2].length;
+                    }
+                    var result = new Array(sz);
+                    var ptr = 0;
+                    for (i2 = 0; i2 < n2; ++i2) {
+                      var c2 = cells[i2];
+                      var d2 = c2.length;
+                      for (j2 = 0; j2 < d2; ++j2) {
+                        var b2 = result[ptr++] = new Array(d2 - 1);
+                        var p2 = 0;
+                        for (k2 = 0; k2 < d2; ++k2) {
+                          if (k2 === j2) {
+                            continue;
+                          }
+                          b2[p2++] = c2[k2];
+                        }
+                        if (j2 & 1) {
+                          var tmp2 = b2[1];
+                          b2[1] = b2[0];
+                          b2[0] = tmp2;
+                        }
+                      }
+                    }
+                    return result;
+                  }
+                }
+              ),
+              /***/
+              6296: (
+                /***/
+                function(module22, __unused_webpack_exports, __webpack_require__2) {
+                  module22.exports = createViewController;
+                  var createTurntable = __webpack_require__2(7261);
+                  var createOrbit = __webpack_require__2(9977);
+                  var createMatrix = __webpack_require__2(1811);
+                  function ViewController(controllers, mode) {
+                    this._controllerNames = Object.keys(controllers);
+                    this._controllerList = this._controllerNames.map(function(n2) {
+                      return controllers[n2];
+                    });
+                    this._mode = mode;
+                    this._active = controllers[mode];
+                    if (!this._active) {
+                      this._mode = "turntable";
+                      this._active = controllers.turntable;
+                    }
+                    this.modes = this._controllerNames;
+                    this.computedMatrix = this._active.computedMatrix;
+                    this.computedEye = this._active.computedEye;
+                    this.computedUp = this._active.computedUp;
+                    this.computedCenter = this._active.computedCenter;
+                    this.computedRadius = this._active.computedRadius;
+                  }
+                  var proto = ViewController.prototype;
+                  proto.flush = function(a0) {
+                    var cc2 = this._controllerList;
+                    for (var i2 = 0; i2 < cc2.length; ++i2) {
+                      cc2[i2].flush(a0);
+                    }
+                  };
+                  proto.idle = function(a0) {
+                    var cc2 = this._controllerList;
+                    for (var i2 = 0; i2 < cc2.length; ++i2) {
+                      cc2[i2].idle(a0);
+                    }
+                  };
+                  proto.lookAt = function(a0, a1, a2, a3) {
+                    var cc2 = this._controllerList;
+                    for (var i2 = 0; i2 < cc2.length; ++i2) {
+                      cc2[i2].lookAt(a0, a1, a2, a3);
+                    }
+                  };
+                  proto.rotate = function(a0, a1, a2, a3) {
+                    var cc2 = this._controllerList;
+                    for (var i2 = 0; i2 < cc2.length; ++i2) {
+                      cc2[i2].rotate(a0, a1, a2, a3);
+                    }
+                  };
+                  proto.pan = function(a0, a1, a2, a3) {
+                    var cc2 = this._controllerList;
+                    for (var i2 = 0; i2 < cc2.length; ++i2) {
+                      cc2[i2].pan(a0, a1, a2, a3);
+                    }
+                  };
+                  proto.translate = function(a0, a1, a2, a3) {
+                    var cc2 = this._controllerList;
+                    for (var i2 = 0; i2 < cc2.length; ++i2) {
+                      cc2[i2].translate(a0, a1, a2, a3);
+                    }
+                  };
+                  proto.setMatrix = function(a0, a1) {
+                    var cc2 = this._controllerList;
+                    for (var i2 = 0; i2 < cc2.length; ++i2) {
+                      cc2[i2].setMatrix(a0, a1);
+                    }
+                  };
+                  proto.setDistanceLimits = function(a0, a1) {
+                    var cc2 = this._controllerList;
+                    for (var i2 = 0; i2 < cc2.length; ++i2) {
+                      cc2[i2].setDistanceLimits(a0, a1);
+                    }
+                  };
+                  proto.setDistance = function(a0, a1) {
+                    var cc2 = this._controllerList;
+                    for (var i2 = 0; i2 < cc2.length; ++i2) {
+                      cc2[i2].setDistance(a0, a1);
+                    }
+                  };
+                  proto.recalcMatrix = function(t4) {
+                    this._active.recalcMatrix(t4);
+                  };
+                  proto.getDistance = function(t4) {
+                    return this._active.getDistance(t4);
+                  };
+                  proto.getDistanceLimits = function(out) {
+                    return this._active.getDistanceLimits(out);
+                  };
+                  proto.lastT = function() {
+                    return this._active.lastT();
+                  };
+                  proto.setMode = function(mode) {
+                    if (mode === this._mode) {
+                      return;
+                    }
+                    var idx = this._controllerNames.indexOf(mode);
+                    if (idx < 0) {
+                      return;
+                    }
+                    var prev = this._active;
+                    var next = this._controllerList[idx];
+                    var lastT = Math.max(prev.lastT(), next.lastT());
+                    prev.recalcMatrix(lastT);
+                    next.setMatrix(lastT, prev.computedMatrix);
+                    this._active = next;
+                    this._mode = mode;
+                    this.computedMatrix = this._active.computedMatrix;
+                    this.computedEye = this._active.computedEye;
+                    this.computedUp = this._active.computedUp;
+                    this.computedCenter = this._active.computedCenter;
+                    this.computedRadius = this._active.computedRadius;
+                  };
+                  proto.getMode = function() {
+                    return this._mode;
+                  };
+                  function createViewController(options) {
+                    options = options || {};
+                    var eye = options.eye || [0, 0, 1];
+                    var center = options.center || [0, 0, 0];
+                    var up = options.up || [0, 1, 0];
+                    var limits = options.distanceLimits || [0, Infinity];
+                    var mode = options.mode || "turntable";
+                    var turntable = createTurntable();
+                    var orbit = createOrbit();
+                    var matrix = createMatrix();
+                    turntable.setDistanceLimits(limits[0], limits[1]);
+                    turntable.lookAt(0, eye, center, up);
+                    orbit.setDistanceLimits(limits[0], limits[1]);
+                    orbit.lookAt(0, eye, center, up);
+                    matrix.setDistanceLimits(limits[0], limits[1]);
+                    matrix.lookAt(0, eye, center, up);
+                    return new ViewController({
+                      turntable,
+                      orbit,
+                      matrix
+                    }, mode);
+                  }
+                }
+              ),
+              /***/
+              6330: (
+                /***/
+                function(module22, __unused_webpack_exports, __webpack_require__2) {
+                  var isBN = __webpack_require__2(1533);
+                  module22.exports = isRat;
+                  function isRat(x2) {
+                    return Array.isArray(x2) && x2.length === 2 && isBN(x2[0]) && isBN(x2[1]);
+                  }
+                }
+              ),
+              /***/
+              6405: (
+                /***/
+                function(module22, __unused_webpack_exports, __webpack_require__2) {
+                  var vec3 = __webpack_require__2(2931);
+                  module22.exports = function(vectorfield, bounds) {
+                    var positions = vectorfield.positions;
+                    var vectors = vectorfield.vectors;
+                    var geo = {
+                      positions: [],
+                      vertexIntensity: [],
+                      vertexIntensityBounds: vectorfield.vertexIntensityBounds,
+                      vectors: [],
+                      cells: [],
+                      coneOffset: vectorfield.coneOffset,
+                      colormap: vectorfield.colormap
+                    };
+                    if (vectorfield.positions.length === 0) {
+                      if (bounds) {
+                        bounds[0] = [0, 0, 0];
+                        bounds[1] = [0, 0, 0];
+                      }
+                      return geo;
+                    }
+                    var maxNorm = 0;
+                    var minX = Infinity, maxX = -Infinity;
+                    var minY = Infinity, maxY = -Infinity;
+                    var minZ = Infinity, maxZ = -Infinity;
+                    var p2 = null;
+                    var u2 = null;
+                    var positionVectors = [];
+                    var vectorScale = Infinity;
+                    var skipIt = false;
+                    var rawSizemodemode = vectorfield.coneSizemode === "raw";
+                    for (var i2 = 0; i2 < positions.length; i2++) {
+                      var p3 = positions[i2];
+                      minX = Math.min(p3[0], minX);
+                      maxX = Math.max(p3[0], maxX);
+                      minY = Math.min(p3[1], minY);
+                      maxY = Math.max(p3[1], maxY);
+                      minZ = Math.min(p3[2], minZ);
+                      maxZ = Math.max(p3[2], maxZ);
+                      var u3 = vectors[i2];
+                      if (vec3.length(u3) > maxNorm) {
+                        maxNorm = vec3.length(u3);
+                      }
+                      if (i2 && !rawSizemodemode) {
+                        var q2 = 2 * vec3.distance(p2, p3) / (vec3.length(u2) + vec3.length(u3));
+                        if (q2) {
+                          vectorScale = Math.min(vectorScale, q2);
+                          skipIt = false;
+                        } else {
+                          skipIt = true;
+                        }
+                      }
+                      if (!skipIt) {
+                        p2 = p3;
+                        u2 = u3;
+                      }
+                      positionVectors.push(u3);
+                    }
+                    var minV = [minX, minY, minZ];
+                    var maxV = [maxX, maxY, maxZ];
+                    if (bounds) {
+                      bounds[0] = minV;
+                      bounds[1] = maxV;
+                    }
+                    if (maxNorm === 0) {
+                      maxNorm = 1;
+                    }
+                    var invertedMaxNorm = 1 / maxNorm;
+                    if (!isFinite(vectorScale)) {
+                      vectorScale = 1;
+                    }
+                    geo.vectorScale = vectorScale;
+                    var coneScale = vectorfield.coneSize || (rawSizemodemode ? 1 : 0.5);
+                    if (vectorfield.absoluteConeSize) {
+                      coneScale = vectorfield.absoluteConeSize * invertedMaxNorm;
+                    }
+                    geo.coneScale = coneScale;
+                    for (var i2 = 0, j2 = 0; i2 < positions.length; i2++) {
+                      var p3 = positions[i2];
+                      var x2 = p3[0], y2 = p3[1], z2 = p3[2];
+                      var d2 = positionVectors[i2];
+                      var intensity = vec3.length(d2) * invertedMaxNorm;
+                      for (var k2 = 0, l2 = 8; k2 < l2; k2++) {
+                        geo.positions.push([x2, y2, z2, j2++]);
+                        geo.positions.push([x2, y2, z2, j2++]);
+                        geo.positions.push([x2, y2, z2, j2++]);
+                        geo.positions.push([x2, y2, z2, j2++]);
+                        geo.positions.push([x2, y2, z2, j2++]);
+                        geo.positions.push([x2, y2, z2, j2++]);
+                        geo.vectors.push(d2);
+                        geo.vectors.push(d2);
+                        geo.vectors.push(d2);
+                        geo.vectors.push(d2);
+                        geo.vectors.push(d2);
+                        geo.vectors.push(d2);
+                        geo.vertexIntensity.push(intensity, intensity, intensity);
+                        geo.vertexIntensity.push(intensity, intensity, intensity);
+                        var m2 = geo.positions.length;
+                        geo.cells.push([m2 - 6, m2 - 5, m2 - 4], [m2 - 3, m2 - 2, m2 - 1]);
+                      }
+                    }
+                    return geo;
+                  };
+                  var shaders = __webpack_require__2(614);
+                  module22.exports.createMesh = __webpack_require__2(9060);
+                  module22.exports.createConeMesh = function(gl2, params) {
+                    return module22.exports.createMesh(gl2, params, {
+                      shaders,
+                      traceType: "cone"
+                    });
+                  };
+                }
+              ),
+              /***/
+              6429: (
+                /***/
+                function(module22, __unused_webpack_exports, __webpack_require__2) {
+                  module22.exports = getCubeEdges;
+                  var bits = __webpack_require__2(8828);
+                  var multiply2 = __webpack_require__2(6760);
+                  var splitPoly = __webpack_require__2(5202);
+                  var orient = __webpack_require__2(3250);
+                  var mvp = new Array(16);
+                  var pCubeVerts = new Array(8);
+                  var cubeVerts = new Array(8);
+                  var x2 = new Array(3);
+                  var zero3 = [0, 0, 0];
+                  (function() {
+                    for (var i2 = 0; i2 < 8; ++i2) {
+                      pCubeVerts[i2] = [1, 1, 1, 1];
+                      cubeVerts[i2] = [1, 1, 1];
+                    }
+                  })();
+                  function transformHg(result, x22, mat) {
+                    for (var i2 = 0; i2 < 4; ++i2) {
+                      result[i2] = mat[12 + i2];
+                      for (var j2 = 0; j2 < 3; ++j2) {
+                        result[i2] += x22[j2] * mat[4 * j2 + i2];
+                      }
+                    }
+                  }
+                  var FRUSTUM_PLANES = [
+                    [0, 0, 1, 0, 0],
+                    [0, 0, -1, 1, 0],
+                    [0, -1, 0, 1, 0],
+                    [0, 1, 0, 1, 0],
+                    [-1, 0, 0, 1, 0],
+                    [1, 0, 0, 1, 0]
+                  ];
+                  function polygonArea(p2) {
+                    for (var i2 = 0; i2 < FRUSTUM_PLANES.length; ++i2) {
+                      p2 = splitPoly.positive(p2, FRUSTUM_PLANES[i2]);
+                      if (p2.length < 3) {
+                        return 0;
+                      }
+                    }
+                    var base = p2[0];
+                    var ax = base[0] / base[3];
+                    var ay = base[1] / base[3];
+                    var area = 0;
+                    for (var i2 = 1; i2 + 1 < p2.length; ++i2) {
+                      var b2 = p2[i2];
+                      var c2 = p2[i2 + 1];
+                      var bx = b2[0] / b2[3];
+                      var by = b2[1] / b2[3];
+                      var cx = c2[0] / c2[3];
+                      var cy = c2[1] / c2[3];
+                      var ux = bx - ax;
+                      var uy = by - ay;
+                      var vx = cx - ax;
+                      var vy = cy - ay;
+                      area += Math.abs(ux * vy - uy * vx);
+                    }
+                    return area;
+                  }
+                  var CUBE_EDGES = [1, 1, 1];
+                  var CUBE_AXIS = [0, 0, 0];
+                  var CUBE_RESULT = {
+                    cubeEdges: CUBE_EDGES,
+                    axis: CUBE_AXIS
+                  };
+                  function getCubeEdges(model, view, projection, bounds, ortho2) {
+                    multiply2(mvp, view, model);
+                    multiply2(mvp, projection, mvp);
+                    var ptr = 0;
+                    for (var i2 = 0; i2 < 2; ++i2) {
+                      x2[2] = bounds[i2][2];
+                      for (var j2 = 0; j2 < 2; ++j2) {
+                        x2[1] = bounds[j2][1];
+                        for (var k2 = 0; k2 < 2; ++k2) {
+                          x2[0] = bounds[k2][0];
+                          transformHg(pCubeVerts[ptr], x2, mvp);
+                          ptr += 1;
+                        }
+                      }
+                    }
+                    var closest = -1;
+                    for (var i2 = 0; i2 < 8; ++i2) {
+                      var w2 = pCubeVerts[i2][3];
+                      for (var l2 = 0; l2 < 3; ++l2) {
+                        cubeVerts[i2][l2] = pCubeVerts[i2][l2] / w2;
+                      }
+                      if (ortho2) cubeVerts[i2][2] *= -1;
+                      if (w2 < 0) {
+                        if (closest < 0) {
+                          closest = i2;
+                        } else if (cubeVerts[i2][2] < cubeVerts[closest][2]) {
+                          closest = i2;
+                        }
+                      }
+                    }
+                    if (closest < 0) {
+                      closest = 0;
+                      for (var d2 = 0; d2 < 3; ++d2) {
+                        var u2 = (d2 + 2) % 3;
+                        var v2 = (d2 + 1) % 3;
+                        var o0 = -1;
+                        var o1 = -1;
+                        for (var s2 = 0; s2 < 2; ++s2) {
+                          var f0 = s2 << d2;
+                          var f1 = f0 + (s2 << u2) + (1 - s2 << v2);
+                          var f2 = f0 + (1 - s2 << u2) + (s2 << v2);
+                          if (orient(cubeVerts[f0], cubeVerts[f1], cubeVerts[f2], zero3) < 0) {
+                            continue;
+                          }
+                          if (s2) {
+                            o0 = 1;
+                          } else {
+                            o1 = 1;
+                          }
+                        }
+                        if (o0 < 0 || o1 < 0) {
+                          if (o1 > o0) {
+                            closest |= 1 << d2;
+                          }
+                          continue;
+                        }
+                        for (var s2 = 0; s2 < 2; ++s2) {
+                          var f0 = s2 << d2;
+                          var f1 = f0 + (s2 << u2) + (1 - s2 << v2);
+                          var f2 = f0 + (1 - s2 << u2) + (s2 << v2);
+                          var o2 = polygonArea([
+                            pCubeVerts[f0],
+                            pCubeVerts[f1],
+                            pCubeVerts[f2],
+                            pCubeVerts[f0 + (1 << u2) + (1 << v2)]
+                          ]);
+                          if (s2) {
+                            o0 = o2;
+                          } else {
+                            o1 = o2;
+                          }
+                        }
+                        if (o1 > o0) {
+                          closest |= 1 << d2;
+                          continue;
+                        }
+                      }
+                    }
+                    var farthest = 7 ^ closest;
+                    var bottom = -1;
+                    for (var i2 = 0; i2 < 8; ++i2) {
+                      if (i2 === closest || i2 === farthest) {
+                        continue;
+                      }
+                      if (bottom < 0) {
+                        bottom = i2;
+                      } else if (cubeVerts[bottom][1] > cubeVerts[i2][1]) {
+                        bottom = i2;
+                      }
+                    }
+                    var left = -1;
+                    for (var i2 = 0; i2 < 3; ++i2) {
+                      var idx = bottom ^ 1 << i2;
+                      if (idx === closest || idx === farthest) {
+                        continue;
+                      }
+                      if (left < 0) {
+                        left = idx;
+                      }
+                      var v2 = cubeVerts[idx];
+                      if (v2[0] < cubeVerts[left][0]) {
+                        left = idx;
+                      }
+                    }
+                    var right = -1;
+                    for (var i2 = 0; i2 < 3; ++i2) {
+                      var idx = bottom ^ 1 << i2;
+                      if (idx === closest || idx === farthest || idx === left) {
+                        continue;
+                      }
+                      if (right < 0) {
+                        right = idx;
+                      }
+                      var v2 = cubeVerts[idx];
+                      if (v2[0] > cubeVerts[right][0]) {
+                        right = idx;
+                      }
+                    }
+                    var cubeEdges = CUBE_EDGES;
+                    cubeEdges[0] = cubeEdges[1] = cubeEdges[2] = 0;
+                    cubeEdges[bits.log2(left ^ bottom)] = bottom & left;
+                    cubeEdges[bits.log2(bottom ^ right)] = bottom & right;
+                    var top = right ^ 7;
+                    if (top === closest || top === farthest) {
+                      top = left ^ 7;
+                      cubeEdges[bits.log2(right ^ top)] = top & right;
+                    } else {
+                      cubeEdges[bits.log2(left ^ top)] = top & left;
+                    }
+                    var axis = CUBE_AXIS;
+                    var cutCorner = closest;
+                    for (var d2 = 0; d2 < 3; ++d2) {
+                      if (cutCorner & 1 << d2) {
+                        axis[d2] = -1;
+                      } else {
+                        axis[d2] = 1;
+                      }
+                    }
+                    return CUBE_RESULT;
+                  }
+                }
+              ),
+              /***/
+              6444: (
+                /***/
+                function(__unused_webpack_module, exports2) {
+                  exports2.create = defaultTicks;
+                  exports2.equal = ticksEqual;
+                  function prettyPrint(spacing, i2) {
+                    var stepStr = spacing + "";
+                    var u2 = stepStr.indexOf(".");
+                    var sigFigs = 0;
+                    if (u2 >= 0) {
+                      sigFigs = stepStr.length - u2 - 1;
+                    }
+                    var shift = Math.pow(10, sigFigs);
+                    var x2 = Math.round(spacing * i2 * shift);
+                    var xstr = x2 + "";
+                    if (xstr.indexOf("e") >= 0) {
+                      return xstr;
+                    }
+                    var xi2 = x2 / shift, xf2 = x2 % shift;
+                    if (x2 < 0) {
+                      xi2 = -Math.ceil(xi2) | 0;
+                      xf2 = -xf2 | 0;
+                    } else {
+                      xi2 = Math.floor(xi2) | 0;
+                      xf2 = xf2 | 0;
+                    }
+                    var xis = "" + xi2;
+                    if (x2 < 0) {
+                      xis = "-" + xis;
+                    }
+                    if (sigFigs) {
+                      var xs = "" + xf2;
+                      while (xs.length < sigFigs) {
+                        xs = "0" + xs;
+                      }
+                      return xis + "." + xs;
+                    } else {
+                      return xis;
+                    }
+                  }
+                  function defaultTicks(bounds, tickSpacing) {
+                    var array = [];
+                    for (var d2 = 0; d2 < 3; ++d2) {
+                      var ticks = [];
+                      0.5 * (bounds[0][d2] + bounds[1][d2]);
+                      for (var t4 = 0; t4 * tickSpacing[d2] <= bounds[1][d2]; ++t4) {
+                        ticks.push({ x: t4 * tickSpacing[d2], text: prettyPrint(tickSpacing[d2], t4) });
+                      }
+                      for (var t4 = -1; t4 * tickSpacing[d2] >= bounds[0][d2]; --t4) {
+                        ticks.push({ x: t4 * tickSpacing[d2], text: prettyPrint(tickSpacing[d2], t4) });
+                      }
+                      array.push(ticks);
+                    }
+                    return array;
+                  }
+                  function ticksEqual(ticksA, ticksB) {
+                    for (var i2 = 0; i2 < 3; ++i2) {
+                      if (ticksA[i2].length !== ticksB[i2].length) {
+                        return false;
+                      }
+                      for (var j2 = 0; j2 < ticksA[i2].length; ++j2) {
+                        var a2 = ticksA[i2][j2];
+                        var b2 = ticksB[i2][j2];
+                        if (a2.x !== b2.x || a2.text !== b2.text || a2.font !== b2.font || a2.fontColor !== b2.fontColor || a2.fontSize !== b2.fontSize || a2.dx !== b2.dx || a2.dy !== b2.dy) {
+                          return false;
+                        }
+                      }
+                    }
+                    return true;
+                  }
+                }
+              ),
+              /***/
+              6468: (
+                /***/
+                function(module22) {
+                  module22.exports = function _atob(str) {
+                    return atob(str);
+                  };
+                }
+              ),
+              /***/
+              6504: (
+                /***/
+                function(module22, __unused_webpack_exports, __webpack_require__2) {
+                  var rationalize = __webpack_require__2(869);
+                  module22.exports = mul;
+                  function mul(a2, b2) {
+                    return rationalize(a2[0].mul(b2[0]), a2[1].mul(b2[1]));
+                  }
+                }
+              ),
+              /***/
+              6582: (
+                /***/
+                function(module22, __unused_webpack_exports, __webpack_require__2) {
+                  var identity22 = __webpack_require__2(7894);
+                  module22.exports = lookAt2;
+                  function lookAt2(out, eye, center, up) {
+                    var x0, x1, x2, y0, y1, y2, z0, z1, z2, len2, eyex = eye[0], eyey = eye[1], eyez = eye[2], upx = up[0], upy = up[1], upz = up[2], centerx = center[0], centery = center[1], centerz = center[2];
+                    if (Math.abs(eyex - centerx) < 1e-6 && Math.abs(eyey - centery) < 1e-6 && Math.abs(eyez - centerz) < 1e-6) {
+                      return identity22(out);
+                    }
+                    z0 = eyex - centerx;
+                    z1 = eyey - centery;
+                    z2 = eyez - centerz;
+                    len2 = 1 / Math.sqrt(z0 * z0 + z1 * z1 + z2 * z2);
+                    z0 *= len2;
+                    z1 *= len2;
+                    z2 *= len2;
+                    x0 = upy * z2 - upz * z1;
+                    x1 = upz * z0 - upx * z2;
+                    x2 = upx * z1 - upy * z0;
+                    len2 = Math.sqrt(x0 * x0 + x1 * x1 + x2 * x2);
+                    if (!len2) {
+                      x0 = 0;
+                      x1 = 0;
+                      x2 = 0;
+                    } else {
+                      len2 = 1 / len2;
+                      x0 *= len2;
+                      x1 *= len2;
+                      x2 *= len2;
+                    }
+                    y0 = z1 * x2 - z2 * x1;
+                    y1 = z2 * x0 - z0 * x2;
+                    y2 = z0 * x1 - z1 * x0;
+                    len2 = Math.sqrt(y0 * y0 + y1 * y1 + y2 * y2);
+                    if (!len2) {
+                      y0 = 0;
+                      y1 = 0;
+                      y2 = 0;
+                    } else {
+                      len2 = 1 / len2;
+                      y0 *= len2;
+                      y1 *= len2;
+                      y2 *= len2;
+                    }
+                    out[0] = x0;
+                    out[1] = y0;
+                    out[2] = z0;
+                    out[3] = 0;
+                    out[4] = x1;
+                    out[5] = y1;
+                    out[6] = z1;
+                    out[7] = 0;
+                    out[8] = x2;
+                    out[9] = y2;
+                    out[10] = z2;
+                    out[11] = 0;
+                    out[12] = -(x0 * eyex + x1 * eyey + x2 * eyez);
+                    out[13] = -(y0 * eyex + y1 * eyey + y2 * eyez);
+                    out[14] = -(z0 * eyex + z1 * eyey + z2 * eyez);
+                    out[15] = 1;
+                    return out;
+                  }
+                }
+              ),
+              /***/
+              6621: (
+                /***/
+                function(module22) {
+                  module22.exports = scale2;
+                  function scale2(out, a2, b2) {
+                    out[0] = a2[0] * b2;
+                    out[1] = a2[1] * b2;
+                    out[2] = a2[2] * b2;
+                    return out;
+                  }
+                }
+              ),
+              /***/
+              6658: (
+                /***/
+                function(module22) {
+                  module22.exports = lerp2;
+                  function lerp2(out, a2, b2, t4) {
+                    var ax = a2[0], ay = a2[1], az = a2[2];
+                    out[0] = ax + t4 * (b2[0] - ax);
+                    out[1] = ay + t4 * (b2[1] - ay);
+                    out[2] = az + t4 * (b2[2] - az);
+                    return out;
+                  }
+                }
+              ),
+              /***/
+              6690: (
+                /***/
+                function(module22) {
+                  module22.exports = divide;
+                  function divide(out, a2, b2) {
+                    out[0] = a2[0] / b2[0];
+                    out[1] = a2[1] / b2[1];
+                    out[2] = a2[2] / b2[2];
+                    return out;
+                  }
+                }
+              ),
+              /***/
+              6729: (
+                /***/
+                function(module22, __unused_webpack_exports, __webpack_require__2) {
+                  var colorScale = __webpack_require__2(3642);
+                  var lerp2 = __webpack_require__2(395);
+                  module22.exports = createColormap;
+                  function createColormap(spec) {
+                    var indicies, fromrgba, torgba, nsteps, cmap, colormap, format, nshades, colors, alpha, i2;
+                    if (!spec) spec = {};
+                    nshades = (spec.nshades || 72) - 1;
+                    format = spec.format || "hex";
+                    colormap = spec.colormap;
+                    if (!colormap) colormap = "jet";
+                    if (typeof colormap === "string") {
+                      colormap = colormap.toLowerCase();
+                      if (!colorScale[colormap]) {
+                        throw Error(colormap + " not a supported colorscale");
+                      }
+                      cmap = colorScale[colormap];
+                    } else if (Array.isArray(colormap)) {
+                      cmap = colormap.slice();
+                    } else {
+                      throw Error("unsupported colormap option", colormap);
+                    }
+                    if (cmap.length > nshades + 1) {
+                      throw new Error(
+                        colormap + " map requires nshades to be at least size " + cmap.length
+                      );
+                    }
+                    if (!Array.isArray(spec.alpha)) {
+                      if (typeof spec.alpha === "number") {
+                        alpha = [spec.alpha, spec.alpha];
+                      } else {
+                        alpha = [1, 1];
+                      }
+                    } else if (spec.alpha.length !== 2) {
+                      alpha = [1, 1];
+                    } else {
+                      alpha = spec.alpha.slice();
+                    }
+                    indicies = cmap.map(function(c2) {
+                      return Math.round(c2.index * nshades);
+                    });
+                    alpha[0] = Math.min(Math.max(alpha[0], 0), 1);
+                    alpha[1] = Math.min(Math.max(alpha[1], 0), 1);
+                    var steps = cmap.map(function(c2, i22) {
+                      var index = cmap[i22].index;
+                      var rgba3 = cmap[i22].rgb.slice();
+                      if (rgba3.length === 4 && rgba3[3] >= 0 && rgba3[3] <= 1) {
+                        return rgba3;
+                      }
+                      rgba3[3] = alpha[0] + (alpha[1] - alpha[0]) * index;
+                      return rgba3;
+                    });
+                    var colors = [];
+                    for (i2 = 0; i2 < indicies.length - 1; ++i2) {
+                      nsteps = indicies[i2 + 1] - indicies[i2];
+                      fromrgba = steps[i2];
+                      torgba = steps[i2 + 1];
+                      for (var j2 = 0; j2 < nsteps; j2++) {
+                        var amt = j2 / nsteps;
+                        colors.push([
+                          Math.round(lerp2(fromrgba[0], torgba[0], amt)),
+                          Math.round(lerp2(fromrgba[1], torgba[1], amt)),
+                          Math.round(lerp2(fromrgba[2], torgba[2], amt)),
+                          lerp2(fromrgba[3], torgba[3], amt)
+                        ]);
+                      }
+                    }
+                    colors.push(cmap[cmap.length - 1].rgb.concat(alpha[1]));
+                    if (format === "hex") colors = colors.map(rgb2hex);
+                    else if (format === "rgbaString") colors = colors.map(rgbaStr);
+                    else if (format === "float") colors = colors.map(rgb2float);
+                    return colors;
+                  }
+                  function rgb2float(rgba3) {
+                    return [
+                      rgba3[0] / 255,
+                      rgba3[1] / 255,
+                      rgba3[2] / 255,
+                      rgba3[3]
+                    ];
+                  }
+                  function rgb2hex(rgba3) {
+                    var dig, hex2 = "#";
+                    for (var i2 = 0; i2 < 3; ++i2) {
+                      dig = rgba3[i2];
+                      dig = dig.toString(16);
+                      hex2 += ("00" + dig).substr(dig.length);
+                    }
+                    return hex2;
+                  }
+                  function rgbaStr(rgba3) {
+                    return "rgba(" + rgba3.join(",") + ")";
+                  }
+                }
+              ),
+              /***/
+              6740: (
+                /***/
+                function(__unused_webpack_module, exports2, __webpack_require__2) {
+                  var glslify = __webpack_require__2(3236);
+                  var triVertSrc = glslify(["precision highp float;\n\nprecision highp float;\n#define GLSLIFY 1\n\nvec3 getOrthogonalVector(vec3 v) {\n  // Return up-vector for only-z vector.\n  // Return ax + by + cz = 0, a point that lies on the plane that has v as a normal and that isn't (0,0,0).\n  // From the above if-statement we have ||a|| > 0  U  ||b|| > 0.\n  // Assign z = 0, x = -b, y = a:\n  // a*-b + b*a + c*0 = -ba + ba + 0 = 0\n  if (v.x*v.x > v.z*v.z || v.y*v.y > v.z*v.z) {\n    return normalize(vec3(-v.y, v.x, 0.0));\n  } else {\n    return normalize(vec3(0.0, v.z, -v.y));\n  }\n}\n\n// Calculate the tube vertex and normal at the given index.\n//\n// The returned vertex is for a tube ring with its center at origin, radius of length(d), pointing in the direction of d.\n//\n// Each tube segment is made up of a ring of vertices.\n// These vertices are used to make up the triangles of the tube by connecting them together in the vertex array.\n// The indexes of tube segments run from 0 to 8.\n//\nvec3 getTubePosition(vec3 d, float index, out vec3 normal) {\n  float segmentCount = 8.0;\n\n  float angle = 2.0 * 3.14159 * (index / segmentCount);\n\n  vec3 u = getOrthogonalVector(d);\n  vec3 v = normalize(cross(u, d));\n\n  vec3 x = u * cos(angle) * length(d);\n  vec3 y = v * sin(angle) * length(d);\n  vec3 v3 = x + y;\n\n  normal = normalize(v3);\n\n  return v3;\n}\n\nattribute vec4 vector;\nattribute vec4 color, position;\nattribute vec2 uv;\n\nuniform float vectorScale, tubeScale;\nuniform mat4 model, view, projection, inverseModel;\nuniform vec3 eyePosition, lightPosition;\n\nvarying vec3 f_normal, f_lightDirection, f_eyeDirection, f_data, f_position;\nvarying vec4 f_color;\nvarying vec2 f_uv;\n\nvoid main() {\n  // Scale the vector magnitude to stay constant with\n  // model & view changes.\n  vec3 normal;\n  vec3 XYZ = getTubePosition(mat3(model) * (tubeScale * vector.w * normalize(vector.xyz)), position.w, normal);\n  vec4 tubePosition = model * vec4(position.xyz, 1.0) + vec4(XYZ, 0.0);\n\n  //Lighting geometry parameters\n  vec4 cameraCoordinate = view * tubePosition;\n  cameraCoordinate.xyz /= cameraCoordinate.w;\n  f_lightDirection = lightPosition - cameraCoordinate.xyz;\n  f_eyeDirection   = eyePosition - cameraCoordinate.xyz;\n  f_normal = normalize((vec4(normal, 0.0) * inverseModel).xyz);\n\n  // vec4 m_position  = model * vec4(tubePosition, 1.0);\n  vec4 t_position  = view * tubePosition;\n  gl_Position      = projection * t_position;\n\n  f_color          = color;\n  f_data           = tubePosition.xyz;\n  f_position       = position.xyz;\n  f_uv             = uv;\n}\n"]);
+                  var triFragSrc = glslify(["#extension GL_OES_standard_derivatives : enable\n\nprecision highp float;\n#define GLSLIFY 1\n\nfloat beckmannDistribution(float x, float roughness) {\n  float NdotH = max(x, 0.0001);\n  float cos2Alpha = NdotH * NdotH;\n  float tan2Alpha = (cos2Alpha - 1.0) / cos2Alpha;\n  float roughness2 = roughness * roughness;\n  float denom = 3.141592653589793 * roughness2 * cos2Alpha * cos2Alpha;\n  return exp(tan2Alpha / roughness2) / denom;\n}\n\nfloat cookTorranceSpecular(\n  vec3 lightDirection,\n  vec3 viewDirection,\n  vec3 surfaceNormal,\n  float roughness,\n  float fresnel) {\n\n  float VdotN = max(dot(viewDirection, surfaceNormal), 0.0);\n  float LdotN = max(dot(lightDirection, surfaceNormal), 0.0);\n\n  //Half angle vector\n  vec3 H = normalize(lightDirection + viewDirection);\n\n  //Geometric term\n  float NdotH = max(dot(surfaceNormal, H), 0.0);\n  float VdotH = max(dot(viewDirection, H), 0.000001);\n  float LdotH = max(dot(lightDirection, H), 0.000001);\n  float G1 = (2.0 * NdotH * VdotN) / VdotH;\n  float G2 = (2.0 * NdotH * LdotN) / LdotH;\n  float G = min(1.0, min(G1, G2));\n  \n  //Distribution term\n  float D = beckmannDistribution(NdotH, roughness);\n\n  //Fresnel term\n  float F = pow(1.0 - VdotN, fresnel);\n\n  //Multiply terms and done\n  return  G * F * D / max(3.14159265 * VdotN, 0.000001);\n}\n\nbool outOfRange(float a, float b, float p) {\n  return ((p > max(a, b)) || \n          (p < min(a, b)));\n}\n\nbool outOfRange(vec2 a, vec2 b, vec2 p) {\n  return (outOfRange(a.x, b.x, p.x) ||\n          outOfRange(a.y, b.y, p.y));\n}\n\nbool outOfRange(vec3 a, vec3 b, vec3 p) {\n  return (outOfRange(a.x, b.x, p.x) ||\n          outOfRange(a.y, b.y, p.y) ||\n          outOfRange(a.z, b.z, p.z));\n}\n\nbool outOfRange(vec4 a, vec4 b, vec4 p) {\n  return outOfRange(a.xyz, b.xyz, p.xyz);\n}\n\nuniform vec3 clipBounds[2];\nuniform float roughness, fresnel, kambient, kdiffuse, kspecular, opacity;\nuniform sampler2D texture;\n\nvarying vec3 f_normal, f_lightDirection, f_eyeDirection, f_data, f_position;\nvarying vec4 f_color;\nvarying vec2 f_uv;\n\nvoid main() {\n  if (outOfRange(clipBounds[0], clipBounds[1], f_position)) discard;\n  vec3 N = normalize(f_normal);\n  vec3 L = normalize(f_lightDirection);\n  vec3 V = normalize(f_eyeDirection);\n\n  if(gl_FrontFacing) {\n    N = -N;\n  }\n\n  float specular = min(1.0, max(0.0, cookTorranceSpecular(L, V, N, roughness, fresnel)));\n  float diffuse  = min(kambient + kdiffuse * max(dot(N, L), 0.0), 1.0);\n\n  vec4 surfaceColor = f_color * texture2D(texture, f_uv);\n  vec4 litColor = surfaceColor.a * vec4(diffuse * surfaceColor.rgb + kspecular * vec3(1,1,1) * specular,  1.0);\n\n  gl_FragColor = litColor * opacity;\n}\n"]);
+                  var pickVertSrc = glslify(["precision highp float;\n\nprecision highp float;\n#define GLSLIFY 1\n\nvec3 getOrthogonalVector(vec3 v) {\n  // Return up-vector for only-z vector.\n  // Return ax + by + cz = 0, a point that lies on the plane that has v as a normal and that isn't (0,0,0).\n  // From the above if-statement we have ||a|| > 0  U  ||b|| > 0.\n  // Assign z = 0, x = -b, y = a:\n  // a*-b + b*a + c*0 = -ba + ba + 0 = 0\n  if (v.x*v.x > v.z*v.z || v.y*v.y > v.z*v.z) {\n    return normalize(vec3(-v.y, v.x, 0.0));\n  } else {\n    return normalize(vec3(0.0, v.z, -v.y));\n  }\n}\n\n// Calculate the tube vertex and normal at the given index.\n//\n// The returned vertex is for a tube ring with its center at origin, radius of length(d), pointing in the direction of d.\n//\n// Each tube segment is made up of a ring of vertices.\n// These vertices are used to make up the triangles of the tube by connecting them together in the vertex array.\n// The indexes of tube segments run from 0 to 8.\n//\nvec3 getTubePosition(vec3 d, float index, out vec3 normal) {\n  float segmentCount = 8.0;\n\n  float angle = 2.0 * 3.14159 * (index / segmentCount);\n\n  vec3 u = getOrthogonalVector(d);\n  vec3 v = normalize(cross(u, d));\n\n  vec3 x = u * cos(angle) * length(d);\n  vec3 y = v * sin(angle) * length(d);\n  vec3 v3 = x + y;\n\n  normal = normalize(v3);\n\n  return v3;\n}\n\nattribute vec4 vector;\nattribute vec4 position;\nattribute vec4 id;\n\nuniform mat4 model, view, projection;\nuniform float tubeScale;\n\nvarying vec3 f_position;\nvarying vec4 f_id;\n\nvoid main() {\n  vec3 normal;\n  vec3 XYZ = getTubePosition(mat3(model) * (tubeScale * vector.w * normalize(vector.xyz)), position.w, normal);\n  vec4 tubePosition = model * vec4(position.xyz, 1.0) + vec4(XYZ, 0.0);\n\n  gl_Position = projection * (view * tubePosition);\n  f_id        = id;\n  f_position  = position.xyz;\n}\n"]);
+                  var pickFragSrc = glslify(["precision highp float;\n#define GLSLIFY 1\n\nbool outOfRange(float a, float b, float p) {\n  return ((p > max(a, b)) || \n          (p < min(a, b)));\n}\n\nbool outOfRange(vec2 a, vec2 b, vec2 p) {\n  return (outOfRange(a.x, b.x, p.x) ||\n          outOfRange(a.y, b.y, p.y));\n}\n\nbool outOfRange(vec3 a, vec3 b, vec3 p) {\n  return (outOfRange(a.x, b.x, p.x) ||\n          outOfRange(a.y, b.y, p.y) ||\n          outOfRange(a.z, b.z, p.z));\n}\n\nbool outOfRange(vec4 a, vec4 b, vec4 p) {\n  return outOfRange(a.xyz, b.xyz, p.xyz);\n}\n\nuniform vec3  clipBounds[2];\nuniform float pickId;\n\nvarying vec3 f_position;\nvarying vec4 f_id;\n\nvoid main() {\n  if (outOfRange(clipBounds[0], clipBounds[1], f_position)) discard;\n\n  gl_FragColor = vec4(pickId, f_id.xyz);\n}"]);
+                  exports2.meshShader = {
+                    vertex: triVertSrc,
+                    fragment: triFragSrc,
+                    attributes: [
+                      { name: "position", type: "vec4" },
+                      { name: "color", type: "vec4" },
+                      { name: "uv", type: "vec2" },
+                      { name: "vector", type: "vec4" }
+                    ]
+                  };
+                  exports2.pickShader = {
+                    vertex: pickVertSrc,
+                    fragment: pickFragSrc,
+                    attributes: [
+                      { name: "position", type: "vec4" },
+                      { name: "id", type: "vec4" },
+                      { name: "vector", type: "vec4" }
+                    ]
+                  };
+                }
+              ),
+              /***/
+              6743: (
+                /***/
+                function(module22) {
+                  module22.exports = fromRotationTranslation;
+                  function fromRotationTranslation(out, q2, v2) {
+                    var x2 = q2[0], y2 = q2[1], z2 = q2[2], w2 = q2[3], x22 = x2 + x2, y22 = y2 + y2, z22 = z2 + z2, xx = x2 * x22, xy = x2 * y22, xz = x2 * z22, yy = y2 * y22, yz = y2 * z22, zz = z2 * z22, wx = w2 * x22, wy = w2 * y22, wz = w2 * z22;
+                    out[0] = 1 - (yy + zz);
+                    out[1] = xy + wz;
+                    out[2] = xz - wy;
+                    out[3] = 0;
+                    out[4] = xy - wz;
+                    out[5] = 1 - (xx + zz);
+                    out[6] = yz + wx;
+                    out[7] = 0;
+                    out[8] = xz + wy;
+                    out[9] = yz - wx;
+                    out[10] = 1 - (xx + yy);
+                    out[11] = 0;
+                    out[12] = v2[0];
+                    out[13] = v2[1];
+                    out[14] = v2[2];
+                    out[15] = 1;
+                    return out;
+                  }
+                }
+              ),
+              /***/
+              6760: (
+                /***/
+                function(module22) {
+                  module22.exports = multiply2;
+                  function multiply2(out, a2, b2) {
+                    var a00 = a2[0], a01 = a2[1], a02 = a2[2], a03 = a2[3], a10 = a2[4], a11 = a2[5], a12 = a2[6], a13 = a2[7], a20 = a2[8], a21 = a2[9], a22 = a2[10], a23 = a2[11], a30 = a2[12], a31 = a2[13], a32 = a2[14], a33 = a2[15];
+                    var b0 = b2[0], b1 = b2[1], b22 = b2[2], b3 = b2[3];
+                    out[0] = b0 * a00 + b1 * a10 + b22 * a20 + b3 * a30;
+                    out[1] = b0 * a01 + b1 * a11 + b22 * a21 + b3 * a31;
+                    out[2] = b0 * a02 + b1 * a12 + b22 * a22 + b3 * a32;
+                    out[3] = b0 * a03 + b1 * a13 + b22 * a23 + b3 * a33;
+                    b0 = b2[4];
+                    b1 = b2[5];
+                    b22 = b2[6];
+                    b3 = b2[7];
+                    out[4] = b0 * a00 + b1 * a10 + b22 * a20 + b3 * a30;
+                    out[5] = b0 * a01 + b1 * a11 + b22 * a21 + b3 * a31;
+                    out[6] = b0 * a02 + b1 * a12 + b22 * a22 + b3 * a32;
+                    out[7] = b0 * a03 + b1 * a13 + b22 * a23 + b3 * a33;
+                    b0 = b2[8];
+                    b1 = b2[9];
+                    b22 = b2[10];
+                    b3 = b2[11];
+                    out[8] = b0 * a00 + b1 * a10 + b22 * a20 + b3 * a30;
+                    out[9] = b0 * a01 + b1 * a11 + b22 * a21 + b3 * a31;
+                    out[10] = b0 * a02 + b1 * a12 + b22 * a22 + b3 * a32;
+                    out[11] = b0 * a03 + b1 * a13 + b22 * a23 + b3 * a33;
+                    b0 = b2[12];
+                    b1 = b2[13];
+                    b22 = b2[14];
+                    b3 = b2[15];
+                    out[12] = b0 * a00 + b1 * a10 + b22 * a20 + b3 * a30;
+                    out[13] = b0 * a01 + b1 * a11 + b22 * a21 + b3 * a31;
+                    out[14] = b0 * a02 + b1 * a12 + b22 * a22 + b3 * a32;
+                    out[15] = b0 * a03 + b1 * a13 + b22 * a23 + b3 * a33;
+                    return out;
+                  }
+                }
+              ),
+              /***/
+              6768: (
+                /***/
+                function(module22, __unused_webpack_exports, __webpack_require__2) {
+                  var BN2 = __webpack_require__2(6859);
+                  module22.exports = str2BN;
+                  function str2BN(x2) {
+                    return new BN2(x2);
+                  }
+                }
+              ),
+              /***/
+              6803: (
+                /***/
+                function(__unused_webpack_module, exports2, __webpack_require__2) {
+                  __webpack_require__2(8828);
+                  __webpack_require__2(1755);
+                  function compareCells(a2, b2) {
+                    var n2 = a2.length, t4 = a2.length - b2.length, min = Math.min;
+                    if (t4) {
+                      return t4;
+                    }
+                    switch (n2) {
+                      case 0:
+                        return 0;
+                      case 1:
+                        return a2[0] - b2[0];
+                      case 2:
+                        var d2 = a2[0] + a2[1] - b2[0] - b2[1];
+                        if (d2) {
+                          return d2;
+                        }
+                        return min(a2[0], a2[1]) - min(b2[0], b2[1]);
+                      case 3:
+                        var l1 = a2[0] + a2[1], m1 = b2[0] + b2[1];
+                        d2 = l1 + a2[2] - (m1 + b2[2]);
+                        if (d2) {
+                          return d2;
+                        }
+                        var l0 = min(a2[0], a2[1]), m0 = min(b2[0], b2[1]), d2 = min(l0, a2[2]) - min(m0, b2[2]);
+                        if (d2) {
+                          return d2;
+                        }
+                        return min(l0 + a2[2], l1) - min(m0 + b2[2], m1);
+                      default:
+                        var as = a2.slice(0);
+                        as.sort();
+                        var bs = b2.slice(0);
+                        bs.sort();
+                        for (var i2 = 0; i2 < n2; ++i2) {
+                          t4 = as[i2] - bs[i2];
+                          if (t4) {
+                            return t4;
+                          }
+                        }
+                        return 0;
+                    }
+                  }
+                  exports2.Fw = compareCells;
+                }
+              ),
+              /***/
+              6808: (
+                /***/
+                function(module22) {
+                  module22.exports = length2;
+                  function length2(a2) {
+                    var x2 = a2[0], y2 = a2[1], z2 = a2[2], w2 = a2[3];
+                    return Math.sqrt(x2 * x2 + y2 * y2 + z2 * z2 + w2 * w2);
+                  }
+                }
+              ),
+              /***/
+              6843: (
+                /***/
+                function(module22) {
+                  module22.exports = subtract2;
+                  function subtract2(out, a2, b2) {
+                    out[0] = a2[0] - b2[0];
+                    out[1] = a2[1] - b2[1];
+                    out[2] = a2[2] - b2[2];
+                    return out;
+                  }
+                }
+              ),
+              /***/
+              6852: (
+                /***/
+                function(module22) {
+                  module22.exports = [
+                    // Keep this list sorted
+                    "abs",
+                    "acos",
+                    "all",
+                    "any",
+                    "asin",
+                    "atan",
+                    "ceil",
+                    "clamp",
+                    "cos",
+                    "cross",
+                    "dFdx",
+                    "dFdy",
+                    "degrees",
+                    "distance",
+                    "dot",
+                    "equal",
+                    "exp",
+                    "exp2",
+                    "faceforward",
+                    "floor",
+                    "fract",
+                    "gl_BackColor",
+                    "gl_BackLightModelProduct",
+                    "gl_BackLightProduct",
+                    "gl_BackMaterial",
+                    "gl_BackSecondaryColor",
+                    "gl_ClipPlane",
+                    "gl_ClipVertex",
+                    "gl_Color",
+                    "gl_DepthRange",
+                    "gl_DepthRangeParameters",
+                    "gl_EyePlaneQ",
+                    "gl_EyePlaneR",
+                    "gl_EyePlaneS",
+                    "gl_EyePlaneT",
+                    "gl_Fog",
+                    "gl_FogCoord",
+                    "gl_FogFragCoord",
+                    "gl_FogParameters",
+                    "gl_FragColor",
+                    "gl_FragCoord",
+                    "gl_FragData",
+                    "gl_FragDepth",
+                    "gl_FragDepthEXT",
+                    "gl_FrontColor",
+                    "gl_FrontFacing",
+                    "gl_FrontLightModelProduct",
+                    "gl_FrontLightProduct",
+                    "gl_FrontMaterial",
+                    "gl_FrontSecondaryColor",
+                    "gl_LightModel",
+                    "gl_LightModelParameters",
+                    "gl_LightModelProducts",
+                    "gl_LightProducts",
+                    "gl_LightSource",
+                    "gl_LightSourceParameters",
+                    "gl_MaterialParameters",
+                    "gl_MaxClipPlanes",
+                    "gl_MaxCombinedTextureImageUnits",
+                    "gl_MaxDrawBuffers",
+                    "gl_MaxFragmentUniformComponents",
+                    "gl_MaxLights",
+                    "gl_MaxTextureCoords",
+                    "gl_MaxTextureImageUnits",
+                    "gl_MaxTextureUnits",
+                    "gl_MaxVaryingFloats",
+                    "gl_MaxVertexAttribs",
+                    "gl_MaxVertexTextureImageUnits",
+                    "gl_MaxVertexUniformComponents",
+                    "gl_ModelViewMatrix",
+                    "gl_ModelViewMatrixInverse",
+                    "gl_ModelViewMatrixInverseTranspose",
+                    "gl_ModelViewMatrixTranspose",
+                    "gl_ModelViewProjectionMatrix",
+                    "gl_ModelViewProjectionMatrixInverse",
+                    "gl_ModelViewProjectionMatrixInverseTranspose",
+                    "gl_ModelViewProjectionMatrixTranspose",
+                    "gl_MultiTexCoord0",
+                    "gl_MultiTexCoord1",
+                    "gl_MultiTexCoord2",
+                    "gl_MultiTexCoord3",
+                    "gl_MultiTexCoord4",
+                    "gl_MultiTexCoord5",
+                    "gl_MultiTexCoord6",
+                    "gl_MultiTexCoord7",
+                    "gl_Normal",
+                    "gl_NormalMatrix",
+                    "gl_NormalScale",
+                    "gl_ObjectPlaneQ",
+                    "gl_ObjectPlaneR",
+                    "gl_ObjectPlaneS",
+                    "gl_ObjectPlaneT",
+                    "gl_Point",
+                    "gl_PointCoord",
+                    "gl_PointParameters",
+                    "gl_PointSize",
+                    "gl_Position",
+                    "gl_ProjectionMatrix",
+                    "gl_ProjectionMatrixInverse",
+                    "gl_ProjectionMatrixInverseTranspose",
+                    "gl_ProjectionMatrixTranspose",
+                    "gl_SecondaryColor",
+                    "gl_TexCoord",
+                    "gl_TextureEnvColor",
+                    "gl_TextureMatrix",
+                    "gl_TextureMatrixInverse",
+                    "gl_TextureMatrixInverseTranspose",
+                    "gl_TextureMatrixTranspose",
+                    "gl_Vertex",
+                    "greaterThan",
+                    "greaterThanEqual",
+                    "inversesqrt",
+                    "length",
+                    "lessThan",
+                    "lessThanEqual",
+                    "log",
+                    "log2",
+                    "matrixCompMult",
+                    "max",
+                    "min",
+                    "mix",
+                    "mod",
+                    "normalize",
+                    "not",
+                    "notEqual",
+                    "pow",
+                    "radians",
+                    "reflect",
+                    "refract",
+                    "sign",
+                    "sin",
+                    "smoothstep",
+                    "sqrt",
+                    "step",
+                    "tan",
+                    "texture2D",
+                    "texture2DLod",
+                    "texture2DProj",
+                    "texture2DProjLod",
+                    "textureCube",
+                    "textureCubeLod",
+                    "texture2DLodEXT",
+                    "texture2DProjLodEXT",
+                    "textureCubeLodEXT",
+                    "texture2DGradEXT",
+                    "texture2DProjGradEXT",
+                    "textureCubeGradEXT"
+                  ];
+                }
+              ),
+              /***/
+              6859: (
+                /***/
+                function(module22, __unused_webpack_exports, __webpack_require__2) {
+                  module22 = __webpack_require__2.nmd(module22);
+                  (function(module3, exports2) {
+                    function assert2(val, msg) {
+                      if (!val) throw new Error(msg || "Assertion failed");
+                    }
+                    function inherits(ctor, superCtor) {
+                      ctor.super_ = superCtor;
+                      var TempCtor = function() {
+                      };
+                      TempCtor.prototype = superCtor.prototype;
+                      ctor.prototype = new TempCtor();
+                      ctor.prototype.constructor = ctor;
+                    }
+                    function BN2(number, base, endian) {
+                      if (BN2.isBN(number)) {
+                        return number;
+                      }
+                      this.negative = 0;
+                      this.words = null;
+                      this.length = 0;
+                      this.red = null;
+                      if (number !== null) {
+                        if (base === "le" || base === "be") {
+                          endian = base;
+                          base = 10;
+                        }
+                        this._init(number || 0, base || 10, endian || "be");
+                      }
+                    }
+                    if (typeof module3 === "object") {
+                      module3.exports = BN2;
+                    } else {
+                      exports2.BN = BN2;
+                    }
+                    BN2.BN = BN2;
+                    BN2.wordSize = 26;
+                    var Buffer22;
+                    try {
+                      if (typeof window !== "undefined" && typeof window.Buffer !== "undefined") {
+                        Buffer22 = window.Buffer;
+                      } else {
+                        Buffer22 = __webpack_require__2(7790).Buffer;
+                      }
+                    } catch (e2) {
+                    }
+                    BN2.isBN = function isBN(num) {
+                      if (num instanceof BN2) {
+                        return true;
+                      }
+                      return num !== null && typeof num === "object" && num.constructor.wordSize === BN2.wordSize && Array.isArray(num.words);
+                    };
+                    BN2.max = function max(left, right) {
+                      if (left.cmp(right) > 0) return left;
+                      return right;
+                    };
+                    BN2.min = function min(left, right) {
+                      if (left.cmp(right) < 0) return left;
+                      return right;
+                    };
+                    BN2.prototype._init = function init(number, base, endian) {
+                      if (typeof number === "number") {
+                        return this._initNumber(number, base, endian);
+                      }
+                      if (typeof number === "object") {
+                        return this._initArray(number, base, endian);
+                      }
+                      if (base === "hex") {
+                        base = 16;
+                      }
+                      assert2(base === (base | 0) && base >= 2 && base <= 36);
+                      number = number.toString().replace(/\s+/g, "");
+                      var start = 0;
+                      if (number[0] === "-") {
+                        start++;
+                        this.negative = 1;
+                      }
+                      if (start < number.length) {
+                        if (base === 16) {
+                          this._parseHex(number, start, endian);
+                        } else {
+                          this._parseBase(number, base, start);
+                          if (endian === "le") {
+                            this._initArray(this.toArray(), base, endian);
+                          }
+                        }
+                      }
+                    };
+                    BN2.prototype._initNumber = function _initNumber(number, base, endian) {
+                      if (number < 0) {
+                        this.negative = 1;
+                        number = -number;
+                      }
+                      if (number < 67108864) {
+                        this.words = [number & 67108863];
+                        this.length = 1;
+                      } else if (number < 4503599627370496) {
+                        this.words = [
+                          number & 67108863,
+                          number / 67108864 & 67108863
+                        ];
+                        this.length = 2;
+                      } else {
+                        assert2(number < 9007199254740992);
+                        this.words = [
+                          number & 67108863,
+                          number / 67108864 & 67108863,
+                          1
+                        ];
+                        this.length = 3;
+                      }
+                      if (endian !== "le") return;
+                      this._initArray(this.toArray(), base, endian);
+                    };
+                    BN2.prototype._initArray = function _initArray(number, base, endian) {
+                      assert2(typeof number.length === "number");
+                      if (number.length <= 0) {
+                        this.words = [0];
+                        this.length = 1;
+                        return this;
+                      }
+                      this.length = Math.ceil(number.length / 3);
+                      this.words = new Array(this.length);
+                      for (var i2 = 0; i2 < this.length; i2++) {
+                        this.words[i2] = 0;
+                      }
+                      var j2, w2;
+                      var off = 0;
+                      if (endian === "be") {
+                        for (i2 = number.length - 1, j2 = 0; i2 >= 0; i2 -= 3) {
+                          w2 = number[i2] | number[i2 - 1] << 8 | number[i2 - 2] << 16;
+                          this.words[j2] |= w2 << off & 67108863;
+                          this.words[j2 + 1] = w2 >>> 26 - off & 67108863;
+                          off += 24;
+                          if (off >= 26) {
+                            off -= 26;
+                            j2++;
+                          }
+                        }
+                      } else if (endian === "le") {
+                        for (i2 = 0, j2 = 0; i2 < number.length; i2 += 3) {
+                          w2 = number[i2] | number[i2 + 1] << 8 | number[i2 + 2] << 16;
+                          this.words[j2] |= w2 << off & 67108863;
+                          this.words[j2 + 1] = w2 >>> 26 - off & 67108863;
+                          off += 24;
+                          if (off >= 26) {
+                            off -= 26;
+                            j2++;
+                          }
+                        }
+                      }
+                      return this.strip();
+                    };
+                    function parseHex4Bits(string, index) {
+                      var c2 = string.charCodeAt(index);
+                      if (c2 >= 65 && c2 <= 70) {
+                        return c2 - 55;
+                      } else if (c2 >= 97 && c2 <= 102) {
+                        return c2 - 87;
+                      } else {
+                        return c2 - 48 & 15;
+                      }
+                    }
+                    function parseHexByte(string, lowerBound, index) {
+                      var r2 = parseHex4Bits(string, index);
+                      if (index - 1 >= lowerBound) {
+                        r2 |= parseHex4Bits(string, index - 1) << 4;
+                      }
+                      return r2;
+                    }
+                    BN2.prototype._parseHex = function _parseHex(number, start, endian) {
+                      this.length = Math.ceil((number.length - start) / 6);
+                      this.words = new Array(this.length);
+                      for (var i2 = 0; i2 < this.length; i2++) {
+                        this.words[i2] = 0;
+                      }
+                      var off = 0;
+                      var j2 = 0;
+                      var w2;
+                      if (endian === "be") {
+                        for (i2 = number.length - 1; i2 >= start; i2 -= 2) {
+                          w2 = parseHexByte(number, start, i2) << off;
+                          this.words[j2] |= w2 & 67108863;
+                          if (off >= 18) {
+                            off -= 18;
+                            j2 += 1;
+                            this.words[j2] |= w2 >>> 26;
+                          } else {
+                            off += 8;
+                          }
+                        }
+                      } else {
+                        var parseLength = number.length - start;
+                        for (i2 = parseLength % 2 === 0 ? start + 1 : start; i2 < number.length; i2 += 2) {
+                          w2 = parseHexByte(number, start, i2) << off;
+                          this.words[j2] |= w2 & 67108863;
+                          if (off >= 18) {
+                            off -= 18;
+                            j2 += 1;
+                            this.words[j2] |= w2 >>> 26;
+                          } else {
+                            off += 8;
+                          }
+                        }
+                      }
+                      this.strip();
+                    };
+                    function parseBase(str, start, end, mul) {
+                      var r2 = 0;
+                      var len2 = Math.min(str.length, end);
+                      for (var i2 = start; i2 < len2; i2++) {
+                        var c2 = str.charCodeAt(i2) - 48;
+                        r2 *= mul;
+                        if (c2 >= 49) {
+                          r2 += c2 - 49 + 10;
+                        } else if (c2 >= 17) {
+                          r2 += c2 - 17 + 10;
+                        } else {
+                          r2 += c2;
+                        }
+                      }
+                      return r2;
+                    }
+                    BN2.prototype._parseBase = function _parseBase(number, base, start) {
+                      this.words = [0];
+                      this.length = 1;
+                      for (var limbLen = 0, limbPow = 1; limbPow <= 67108863; limbPow *= base) {
+                        limbLen++;
+                      }
+                      limbLen--;
+                      limbPow = limbPow / base | 0;
+                      var total = number.length - start;
+                      var mod2 = total % limbLen;
+                      var end = Math.min(total, total - mod2) + start;
+                      var word = 0;
+                      for (var i2 = start; i2 < end; i2 += limbLen) {
+                        word = parseBase(number, i2, i2 + limbLen, base);
+                        this.imuln(limbPow);
+                        if (this.words[0] + word < 67108864) {
+                          this.words[0] += word;
+                        } else {
+                          this._iaddn(word);
+                        }
+                      }
+                      if (mod2 !== 0) {
+                        var pow = 1;
+                        word = parseBase(number, i2, number.length, base);
+                        for (i2 = 0; i2 < mod2; i2++) {
+                          pow *= base;
+                        }
+                        this.imuln(pow);
+                        if (this.words[0] + word < 67108864) {
+                          this.words[0] += word;
+                        } else {
+                          this._iaddn(word);
+                        }
+                      }
+                      this.strip();
+                    };
+                    BN2.prototype.copy = function copy(dest) {
+                      dest.words = new Array(this.length);
+                      for (var i2 = 0; i2 < this.length; i2++) {
+                        dest.words[i2] = this.words[i2];
+                      }
+                      dest.length = this.length;
+                      dest.negative = this.negative;
+                      dest.red = this.red;
+                    };
+                    BN2.prototype.clone = function clone() {
+                      var r2 = new BN2(null);
+                      this.copy(r2);
+                      return r2;
+                    };
+                    BN2.prototype._expand = function _expand(size) {
+                      while (this.length < size) {
+                        this.words[this.length++] = 0;
+                      }
+                      return this;
+                    };
+                    BN2.prototype.strip = function strip() {
+                      while (this.length > 1 && this.words[this.length - 1] === 0) {
+                        this.length--;
+                      }
+                      return this._normSign();
+                    };
+                    BN2.prototype._normSign = function _normSign() {
+                      if (this.length === 1 && this.words[0] === 0) {
+                        this.negative = 0;
+                      }
+                      return this;
+                    };
+                    BN2.prototype.inspect = function inspect() {
+                      return (this.red ? "<BN-R: " : "<BN: ") + this.toString(16) + ">";
+                    };
+                    var zeros = [
+                      "",
+                      "0",
+                      "00",
+                      "000",
+                      "0000",
+                      "00000",
+                      "000000",
+                      "0000000",
+                      "00000000",
+                      "000000000",
+                      "0000000000",
+                      "00000000000",
+                      "000000000000",
+                      "0000000000000",
+                      "00000000000000",
+                      "000000000000000",
+                      "0000000000000000",
+                      "00000000000000000",
+                      "000000000000000000",
+                      "0000000000000000000",
+                      "00000000000000000000",
+                      "000000000000000000000",
+                      "0000000000000000000000",
+                      "00000000000000000000000",
+                      "000000000000000000000000",
+                      "0000000000000000000000000"
+                    ];
+                    var groupSizes = [
+                      0,
+                      0,
+                      25,
+                      16,
+                      12,
+                      11,
+                      10,
+                      9,
+                      8,
+                      8,
+                      7,
+                      7,
+                      7,
+                      7,
+                      6,
+                      6,
+                      6,
+                      6,
+                      6,
+                      6,
+                      6,
+                      5,
+                      5,
+                      5,
+                      5,
+                      5,
+                      5,
+                      5,
+                      5,
+                      5,
+                      5,
+                      5,
+                      5,
+                      5,
+                      5,
+                      5,
+                      5
+                    ];
+                    var groupBases = [
+                      0,
+                      0,
+                      33554432,
+                      43046721,
+                      16777216,
+                      48828125,
+                      60466176,
+                      40353607,
+                      16777216,
+                      43046721,
+                      1e7,
+                      19487171,
+                      35831808,
+                      62748517,
+                      7529536,
+                      11390625,
+                      16777216,
+                      24137569,
+                      34012224,
+                      47045881,
+                      64e6,
+                      4084101,
+                      5153632,
+                      6436343,
+                      7962624,
+                      9765625,
+                      11881376,
+                      14348907,
+                      17210368,
+                      20511149,
+                      243e5,
+                      28629151,
+                      33554432,
+                      39135393,
+                      45435424,
+                      52521875,
+                      60466176
+                    ];
+                    BN2.prototype.toString = function toString(base, padding) {
+                      base = base || 10;
+                      padding = padding | 0 || 1;
+                      var out;
+                      if (base === 16 || base === "hex") {
+                        out = "";
+                        var off = 0;
+                        var carry = 0;
+                        for (var i2 = 0; i2 < this.length; i2++) {
+                          var w2 = this.words[i2];
+                          var word = ((w2 << off | carry) & 16777215).toString(16);
+                          carry = w2 >>> 24 - off & 16777215;
+                          if (carry !== 0 || i2 !== this.length - 1) {
+                            out = zeros[6 - word.length] + word + out;
+                          } else {
+                            out = word + out;
+                          }
+                          off += 2;
+                          if (off >= 26) {
+                            off -= 26;
+                            i2--;
+                          }
+                        }
+                        if (carry !== 0) {
+                          out = carry.toString(16) + out;
+                        }
+                        while (out.length % padding !== 0) {
+                          out = "0" + out;
+                        }
+                        if (this.negative !== 0) {
+                          out = "-" + out;
+                        }
+                        return out;
+                      }
+                      if (base === (base | 0) && base >= 2 && base <= 36) {
+                        var groupSize = groupSizes[base];
+                        var groupBase = groupBases[base];
+                        out = "";
+                        var c2 = this.clone();
+                        c2.negative = 0;
+                        while (!c2.isZero()) {
+                          var r2 = c2.modn(groupBase).toString(base);
+                          c2 = c2.idivn(groupBase);
+                          if (!c2.isZero()) {
+                            out = zeros[groupSize - r2.length] + r2 + out;
+                          } else {
+                            out = r2 + out;
+                          }
+                        }
+                        if (this.isZero()) {
+                          out = "0" + out;
+                        }
+                        while (out.length % padding !== 0) {
+                          out = "0" + out;
+                        }
+                        if (this.negative !== 0) {
+                          out = "-" + out;
+                        }
+                        return out;
+                      }
+                      assert2(false, "Base should be between 2 and 36");
+                    };
+                    BN2.prototype.toNumber = function toNumber() {
+                      var ret = this.words[0];
+                      if (this.length === 2) {
+                        ret += this.words[1] * 67108864;
+                      } else if (this.length === 3 && this.words[2] === 1) {
+                        ret += 4503599627370496 + this.words[1] * 67108864;
+                      } else if (this.length > 2) {
+                        assert2(false, "Number can only safely store up to 53 bits");
+                      }
+                      return this.negative !== 0 ? -ret : ret;
+                    };
+                    BN2.prototype.toJSON = function toJSON() {
+                      return this.toString(16);
+                    };
+                    BN2.prototype.toBuffer = function toBuffer(endian, length2) {
+                      assert2(typeof Buffer22 !== "undefined");
+                      return this.toArrayLike(Buffer22, endian, length2);
+                    };
+                    BN2.prototype.toArray = function toArray(endian, length2) {
+                      return this.toArrayLike(Array, endian, length2);
+                    };
+                    BN2.prototype.toArrayLike = function toArrayLike(ArrayType, endian, length2) {
+                      var byteLength = this.byteLength();
+                      var reqLength = length2 || Math.max(1, byteLength);
+                      assert2(byteLength <= reqLength, "byte array longer than desired length");
+                      assert2(reqLength > 0, "Requested array length <= 0");
+                      this.strip();
+                      var littleEndian = endian === "le";
+                      var res = new ArrayType(reqLength);
+                      var b2, i2;
+                      var q2 = this.clone();
+                      if (!littleEndian) {
+                        for (i2 = 0; i2 < reqLength - byteLength; i2++) {
+                          res[i2] = 0;
+                        }
+                        for (i2 = 0; !q2.isZero(); i2++) {
+                          b2 = q2.andln(255);
+                          q2.iushrn(8);
+                          res[reqLength - i2 - 1] = b2;
+                        }
+                      } else {
+                        for (i2 = 0; !q2.isZero(); i2++) {
+                          b2 = q2.andln(255);
+                          q2.iushrn(8);
+                          res[i2] = b2;
+                        }
+                        for (; i2 < reqLength; i2++) {
+                          res[i2] = 0;
+                        }
+                      }
+                      return res;
+                    };
+                    if (Math.clz32) {
+                      BN2.prototype._countBits = function _countBits(w2) {
+                        return 32 - Math.clz32(w2);
+                      };
+                    } else {
+                      BN2.prototype._countBits = function _countBits(w2) {
+                        var t4 = w2;
+                        var r2 = 0;
+                        if (t4 >= 4096) {
+                          r2 += 13;
+                          t4 >>>= 13;
+                        }
+                        if (t4 >= 64) {
+                          r2 += 7;
+                          t4 >>>= 7;
+                        }
+                        if (t4 >= 8) {
+                          r2 += 4;
+                          t4 >>>= 4;
+                        }
+                        if (t4 >= 2) {
+                          r2 += 2;
+                          t4 >>>= 2;
+                        }
+                        return r2 + t4;
+                      };
+                    }
+                    BN2.prototype._zeroBits = function _zeroBits(w2) {
+                      if (w2 === 0) return 26;
+                      var t4 = w2;
+                      var r2 = 0;
+                      if ((t4 & 8191) === 0) {
+                        r2 += 13;
+                        t4 >>>= 13;
+                      }
+                      if ((t4 & 127) === 0) {
+                        r2 += 7;
+                        t4 >>>= 7;
+                      }
+                      if ((t4 & 15) === 0) {
+                        r2 += 4;
+                        t4 >>>= 4;
+                      }
+                      if ((t4 & 3) === 0) {
+                        r2 += 2;
+                        t4 >>>= 2;
+                      }
+                      if ((t4 & 1) === 0) {
+                        r2++;
+                      }
+                      return r2;
+                    };
+                    BN2.prototype.bitLength = function bitLength() {
+                      var w2 = this.words[this.length - 1];
+                      var hi2 = this._countBits(w2);
+                      return (this.length - 1) * 26 + hi2;
+                    };
+                    function toBitArray(num) {
+                      var w2 = new Array(num.bitLength());
+                      for (var bit = 0; bit < w2.length; bit++) {
+                        var off = bit / 26 | 0;
+                        var wbit = bit % 26;
+                        w2[bit] = (num.words[off] & 1 << wbit) >>> wbit;
+                      }
+                      return w2;
+                    }
+                    BN2.prototype.zeroBits = function zeroBits() {
+                      if (this.isZero()) return 0;
+                      var r2 = 0;
+                      for (var i2 = 0; i2 < this.length; i2++) {
+                        var b2 = this._zeroBits(this.words[i2]);
+                        r2 += b2;
+                        if (b2 !== 26) break;
+                      }
+                      return r2;
+                    };
+                    BN2.prototype.byteLength = function byteLength() {
+                      return Math.ceil(this.bitLength() / 8);
+                    };
+                    BN2.prototype.toTwos = function toTwos(width) {
+                      if (this.negative !== 0) {
+                        return this.abs().inotn(width).iaddn(1);
+                      }
+                      return this.clone();
+                    };
+                    BN2.prototype.fromTwos = function fromTwos(width) {
+                      if (this.testn(width - 1)) {
+                        return this.notn(width).iaddn(1).ineg();
+                      }
+                      return this.clone();
+                    };
+                    BN2.prototype.isNeg = function isNeg() {
+                      return this.negative !== 0;
+                    };
+                    BN2.prototype.neg = function neg() {
+                      return this.clone().ineg();
+                    };
+                    BN2.prototype.ineg = function ineg() {
+                      if (!this.isZero()) {
+                        this.negative ^= 1;
+                      }
+                      return this;
+                    };
+                    BN2.prototype.iuor = function iuor(num) {
+                      while (this.length < num.length) {
+                        this.words[this.length++] = 0;
+                      }
+                      for (var i2 = 0; i2 < num.length; i2++) {
+                        this.words[i2] = this.words[i2] | num.words[i2];
+                      }
+                      return this.strip();
+                    };
+                    BN2.prototype.ior = function ior(num) {
+                      assert2((this.negative | num.negative) === 0);
+                      return this.iuor(num);
+                    };
+                    BN2.prototype.or = function or(num) {
+                      if (this.length > num.length) return this.clone().ior(num);
+                      return num.clone().ior(this);
+                    };
+                    BN2.prototype.uor = function uor(num) {
+                      if (this.length > num.length) return this.clone().iuor(num);
+                      return num.clone().iuor(this);
+                    };
+                    BN2.prototype.iuand = function iuand(num) {
+                      var b2;
+                      if (this.length > num.length) {
+                        b2 = num;
+                      } else {
+                        b2 = this;
+                      }
+                      for (var i2 = 0; i2 < b2.length; i2++) {
+                        this.words[i2] = this.words[i2] & num.words[i2];
+                      }
+                      this.length = b2.length;
+                      return this.strip();
+                    };
+                    BN2.prototype.iand = function iand(num) {
+                      assert2((this.negative | num.negative) === 0);
+                      return this.iuand(num);
+                    };
+                    BN2.prototype.and = function and(num) {
+                      if (this.length > num.length) return this.clone().iand(num);
+                      return num.clone().iand(this);
+                    };
+                    BN2.prototype.uand = function uand(num) {
+                      if (this.length > num.length) return this.clone().iuand(num);
+                      return num.clone().iuand(this);
+                    };
+                    BN2.prototype.iuxor = function iuxor(num) {
+                      var a2;
+                      var b2;
+                      if (this.length > num.length) {
+                        a2 = this;
+                        b2 = num;
+                      } else {
+                        a2 = num;
+                        b2 = this;
+                      }
+                      for (var i2 = 0; i2 < b2.length; i2++) {
+                        this.words[i2] = a2.words[i2] ^ b2.words[i2];
+                      }
+                      if (this !== a2) {
+                        for (; i2 < a2.length; i2++) {
+                          this.words[i2] = a2.words[i2];
+                        }
+                      }
+                      this.length = a2.length;
+                      return this.strip();
+                    };
+                    BN2.prototype.ixor = function ixor(num) {
+                      assert2((this.negative | num.negative) === 0);
+                      return this.iuxor(num);
+                    };
+                    BN2.prototype.xor = function xor(num) {
+                      if (this.length > num.length) return this.clone().ixor(num);
+                      return num.clone().ixor(this);
+                    };
+                    BN2.prototype.uxor = function uxor(num) {
+                      if (this.length > num.length) return this.clone().iuxor(num);
+                      return num.clone().iuxor(this);
+                    };
+                    BN2.prototype.inotn = function inotn(width) {
+                      assert2(typeof width === "number" && width >= 0);
+                      var bytesNeeded = Math.ceil(width / 26) | 0;
+                      var bitsLeft = width % 26;
+                      this._expand(bytesNeeded);
+                      if (bitsLeft > 0) {
+                        bytesNeeded--;
+                      }
+                      for (var i2 = 0; i2 < bytesNeeded; i2++) {
+                        this.words[i2] = ~this.words[i2] & 67108863;
+                      }
+                      if (bitsLeft > 0) {
+                        this.words[i2] = ~this.words[i2] & 67108863 >> 26 - bitsLeft;
+                      }
+                      return this.strip();
+                    };
+                    BN2.prototype.notn = function notn(width) {
+                      return this.clone().inotn(width);
+                    };
+                    BN2.prototype.setn = function setn(bit, val) {
+                      assert2(typeof bit === "number" && bit >= 0);
+                      var off = bit / 26 | 0;
+                      var wbit = bit % 26;
+                      this._expand(off + 1);
+                      if (val) {
+                        this.words[off] = this.words[off] | 1 << wbit;
+                      } else {
+                        this.words[off] = this.words[off] & ~(1 << wbit);
+                      }
+                      return this.strip();
+                    };
+                    BN2.prototype.iadd = function iadd(num) {
+                      var r2;
+                      if (this.negative !== 0 && num.negative === 0) {
+                        this.negative = 0;
+                        r2 = this.isub(num);
+                        this.negative ^= 1;
+                        return this._normSign();
+                      } else if (this.negative === 0 && num.negative !== 0) {
+                        num.negative = 0;
+                        r2 = this.isub(num);
+                        num.negative = 1;
+                        return r2._normSign();
+                      }
+                      var a2, b2;
+                      if (this.length > num.length) {
+                        a2 = this;
+                        b2 = num;
+                      } else {
+                        a2 = num;
+                        b2 = this;
+                      }
+                      var carry = 0;
+                      for (var i2 = 0; i2 < b2.length; i2++) {
+                        r2 = (a2.words[i2] | 0) + (b2.words[i2] | 0) + carry;
+                        this.words[i2] = r2 & 67108863;
+                        carry = r2 >>> 26;
+                      }
+                      for (; carry !== 0 && i2 < a2.length; i2++) {
+                        r2 = (a2.words[i2] | 0) + carry;
+                        this.words[i2] = r2 & 67108863;
+                        carry = r2 >>> 26;
+                      }
+                      this.length = a2.length;
+                      if (carry !== 0) {
+                        this.words[this.length] = carry;
+                        this.length++;
+                      } else if (a2 !== this) {
+                        for (; i2 < a2.length; i2++) {
+                          this.words[i2] = a2.words[i2];
+                        }
+                      }
+                      return this;
+                    };
+                    BN2.prototype.add = function add2(num) {
+                      var res;
+                      if (num.negative !== 0 && this.negative === 0) {
+                        num.negative = 0;
+                        res = this.sub(num);
+                        num.negative ^= 1;
+                        return res;
+                      } else if (num.negative === 0 && this.negative !== 0) {
+                        this.negative = 0;
+                        res = num.sub(this);
+                        this.negative = 1;
+                        return res;
+                      }
+                      if (this.length > num.length) return this.clone().iadd(num);
+                      return num.clone().iadd(this);
+                    };
+                    BN2.prototype.isub = function isub(num) {
+                      if (num.negative !== 0) {
+                        num.negative = 0;
+                        var r2 = this.iadd(num);
+                        num.negative = 1;
+                        return r2._normSign();
+                      } else if (this.negative !== 0) {
+                        this.negative = 0;
+                        this.iadd(num);
+                        this.negative = 1;
+                        return this._normSign();
+                      }
+                      var cmp = this.cmp(num);
+                      if (cmp === 0) {
+                        this.negative = 0;
+                        this.length = 1;
+                        this.words[0] = 0;
+                        return this;
+                      }
+                      var a2, b2;
+                      if (cmp > 0) {
+                        a2 = this;
+                        b2 = num;
+                      } else {
+                        a2 = num;
+                        b2 = this;
+                      }
+                      var carry = 0;
+                      for (var i2 = 0; i2 < b2.length; i2++) {
+                        r2 = (a2.words[i2] | 0) - (b2.words[i2] | 0) + carry;
+                        carry = r2 >> 26;
+                        this.words[i2] = r2 & 67108863;
+                      }
+                      for (; carry !== 0 && i2 < a2.length; i2++) {
+                        r2 = (a2.words[i2] | 0) + carry;
+                        carry = r2 >> 26;
+                        this.words[i2] = r2 & 67108863;
+                      }
+                      if (carry === 0 && i2 < a2.length && a2 !== this) {
+                        for (; i2 < a2.length; i2++) {
+                          this.words[i2] = a2.words[i2];
+                        }
+                      }
+                      this.length = Math.max(this.length, i2);
+                      if (a2 !== this) {
+                        this.negative = 1;
+                      }
+                      return this.strip();
+                    };
+                    BN2.prototype.sub = function sub2(num) {
+                      return this.clone().isub(num);
+                    };
+                    function smallMulTo(self2, num, out) {
+                      out.negative = num.negative ^ self2.negative;
+                      var len2 = self2.length + num.length | 0;
+                      out.length = len2;
+                      len2 = len2 - 1 | 0;
+                      var a2 = self2.words[0] | 0;
+                      var b2 = num.words[0] | 0;
+                      var r2 = a2 * b2;
+                      var lo = r2 & 67108863;
+                      var carry = r2 / 67108864 | 0;
+                      out.words[0] = lo;
+                      for (var k2 = 1; k2 < len2; k2++) {
+                        var ncarry = carry >>> 26;
+                        var rword = carry & 67108863;
+                        var maxJ = Math.min(k2, num.length - 1);
+                        for (var j2 = Math.max(0, k2 - self2.length + 1); j2 <= maxJ; j2++) {
+                          var i2 = k2 - j2 | 0;
+                          a2 = self2.words[i2] | 0;
+                          b2 = num.words[j2] | 0;
+                          r2 = a2 * b2 + rword;
+                          ncarry += r2 / 67108864 | 0;
+                          rword = r2 & 67108863;
+                        }
+                        out.words[k2] = rword | 0;
+                        carry = ncarry | 0;
+                      }
+                      if (carry !== 0) {
+                        out.words[k2] = carry | 0;
+                      } else {
+                        out.length--;
+                      }
+                      return out.strip();
+                    }
+                    var comb10MulTo = function comb10MulTo2(self2, num, out) {
+                      var a2 = self2.words;
+                      var b2 = num.words;
+                      var o2 = out.words;
+                      var c2 = 0;
+                      var lo;
+                      var mid;
+                      var hi2;
+                      var a0 = a2[0] | 0;
+                      var al0 = a0 & 8191;
+                      var ah0 = a0 >>> 13;
+                      var a1 = a2[1] | 0;
+                      var al1 = a1 & 8191;
+                      var ah1 = a1 >>> 13;
+                      var a22 = a2[2] | 0;
+                      var al2 = a22 & 8191;
+                      var ah2 = a22 >>> 13;
+                      var a3 = a2[3] | 0;
+                      var al3 = a3 & 8191;
+                      var ah3 = a3 >>> 13;
+                      var a4 = a2[4] | 0;
+                      var al4 = a4 & 8191;
+                      var ah4 = a4 >>> 13;
+                      var a5 = a2[5] | 0;
+                      var al5 = a5 & 8191;
+                      var ah5 = a5 >>> 13;
+                      var a6 = a2[6] | 0;
+                      var al6 = a6 & 8191;
+                      var ah6 = a6 >>> 13;
+                      var a7 = a2[7] | 0;
+                      var al7 = a7 & 8191;
+                      var ah7 = a7 >>> 13;
+                      var a8 = a2[8] | 0;
+                      var al8 = a8 & 8191;
+                      var ah8 = a8 >>> 13;
+                      var a9 = a2[9] | 0;
+                      var al9 = a9 & 8191;
+                      var ah9 = a9 >>> 13;
+                      var b0 = b2[0] | 0;
+                      var bl0 = b0 & 8191;
+                      var bh0 = b0 >>> 13;
+                      var b1 = b2[1] | 0;
+                      var bl1 = b1 & 8191;
+                      var bh1 = b1 >>> 13;
+                      var b22 = b2[2] | 0;
+                      var bl2 = b22 & 8191;
+                      var bh2 = b22 >>> 13;
+                      var b3 = b2[3] | 0;
+                      var bl3 = b3 & 8191;
+                      var bh3 = b3 >>> 13;
+                      var b4 = b2[4] | 0;
+                      var bl4 = b4 & 8191;
+                      var bh4 = b4 >>> 13;
+                      var b5 = b2[5] | 0;
+                      var bl5 = b5 & 8191;
+                      var bh5 = b5 >>> 13;
+                      var b6 = b2[6] | 0;
+                      var bl6 = b6 & 8191;
+                      var bh6 = b6 >>> 13;
+                      var b7 = b2[7] | 0;
+                      var bl7 = b7 & 8191;
+                      var bh7 = b7 >>> 13;
+                      var b8 = b2[8] | 0;
+                      var bl8 = b8 & 8191;
+                      var bh8 = b8 >>> 13;
+                      var b9 = b2[9] | 0;
+                      var bl9 = b9 & 8191;
+                      var bh9 = b9 >>> 13;
+                      out.negative = self2.negative ^ num.negative;
+                      out.length = 19;
+                      lo = Math.imul(al0, bl0);
+                      mid = Math.imul(al0, bh0);
+                      mid = mid + Math.imul(ah0, bl0) | 0;
+                      hi2 = Math.imul(ah0, bh0);
+                      var w0 = (c2 + lo | 0) + ((mid & 8191) << 13) | 0;
+                      c2 = (hi2 + (mid >>> 13) | 0) + (w0 >>> 26) | 0;
+                      w0 &= 67108863;
+                      lo = Math.imul(al1, bl0);
+                      mid = Math.imul(al1, bh0);
+                      mid = mid + Math.imul(ah1, bl0) | 0;
+                      hi2 = Math.imul(ah1, bh0);
+                      lo = lo + Math.imul(al0, bl1) | 0;
+                      mid = mid + Math.imul(al0, bh1) | 0;
+                      mid = mid + Math.imul(ah0, bl1) | 0;
+                      hi2 = hi2 + Math.imul(ah0, bh1) | 0;
+                      var w1 = (c2 + lo | 0) + ((mid & 8191) << 13) | 0;
+                      c2 = (hi2 + (mid >>> 13) | 0) + (w1 >>> 26) | 0;
+                      w1 &= 67108863;
+                      lo = Math.imul(al2, bl0);
+                      mid = Math.imul(al2, bh0);
+                      mid = mid + Math.imul(ah2, bl0) | 0;
+                      hi2 = Math.imul(ah2, bh0);
+                      lo = lo + Math.imul(al1, bl1) | 0;
+                      mid = mid + Math.imul(al1, bh1) | 0;
+                      mid = mid + Math.imul(ah1, bl1) | 0;
+                      hi2 = hi2 + Math.imul(ah1, bh1) | 0;
+                      lo = lo + Math.imul(al0, bl2) | 0;
+                      mid = mid + Math.imul(al0, bh2) | 0;
+                      mid = mid + Math.imul(ah0, bl2) | 0;
+                      hi2 = hi2 + Math.imul(ah0, bh2) | 0;
+                      var w2 = (c2 + lo | 0) + ((mid & 8191) << 13) | 0;
+                      c2 = (hi2 + (mid >>> 13) | 0) + (w2 >>> 26) | 0;
+                      w2 &= 67108863;
+                      lo = Math.imul(al3, bl0);
+                      mid = Math.imul(al3, bh0);
+                      mid = mid + Math.imul(ah3, bl0) | 0;
+                      hi2 = Math.imul(ah3, bh0);
+                      lo = lo + Math.imul(al2, bl1) | 0;
+                      mid = mid + Math.imul(al2, bh1) | 0;
+                      mid = mid + Math.imul(ah2, bl1) | 0;
+                      hi2 = hi2 + Math.imul(ah2, bh1) | 0;
+                      lo = lo + Math.imul(al1, bl2) | 0;
+                      mid = mid + Math.imul(al1, bh2) | 0;
+                      mid = mid + Math.imul(ah1, bl2) | 0;
+                      hi2 = hi2 + Math.imul(ah1, bh2) | 0;
+                      lo = lo + Math.imul(al0, bl3) | 0;
+                      mid = mid + Math.imul(al0, bh3) | 0;
+                      mid = mid + Math.imul(ah0, bl3) | 0;
+                      hi2 = hi2 + Math.imul(ah0, bh3) | 0;
+                      var w3 = (c2 + lo | 0) + ((mid & 8191) << 13) | 0;
+                      c2 = (hi2 + (mid >>> 13) | 0) + (w3 >>> 26) | 0;
+                      w3 &= 67108863;
+                      lo = Math.imul(al4, bl0);
+                      mid = Math.imul(al4, bh0);
+                      mid = mid + Math.imul(ah4, bl0) | 0;
+                      hi2 = Math.imul(ah4, bh0);
+                      lo = lo + Math.imul(al3, bl1) | 0;
+                      mid = mid + Math.imul(al3, bh1) | 0;
+                      mid = mid + Math.imul(ah3, bl1) | 0;
+                      hi2 = hi2 + Math.imul(ah3, bh1) | 0;
+                      lo = lo + Math.imul(al2, bl2) | 0;
+                      mid = mid + Math.imul(al2, bh2) | 0;
+                      mid = mid + Math.imul(ah2, bl2) | 0;
+                      hi2 = hi2 + Math.imul(ah2, bh2) | 0;
+                      lo = lo + Math.imul(al1, bl3) | 0;
+                      mid = mid + Math.imul(al1, bh3) | 0;
+                      mid = mid + Math.imul(ah1, bl3) | 0;
+                      hi2 = hi2 + Math.imul(ah1, bh3) | 0;
+                      lo = lo + Math.imul(al0, bl4) | 0;
+                      mid = mid + Math.imul(al0, bh4) | 0;
+                      mid = mid + Math.imul(ah0, bl4) | 0;
+                      hi2 = hi2 + Math.imul(ah0, bh4) | 0;
+                      var w4 = (c2 + lo | 0) + ((mid & 8191) << 13) | 0;
+                      c2 = (hi2 + (mid >>> 13) | 0) + (w4 >>> 26) | 0;
+                      w4 &= 67108863;
+                      lo = Math.imul(al5, bl0);
+                      mid = Math.imul(al5, bh0);
+                      mid = mid + Math.imul(ah5, bl0) | 0;
+                      hi2 = Math.imul(ah5, bh0);
+                      lo = lo + Math.imul(al4, bl1) | 0;
+                      mid = mid + Math.imul(al4, bh1) | 0;
+                      mid = mid + Math.imul(ah4, bl1) | 0;
+                      hi2 = hi2 + Math.imul(ah4, bh1) | 0;
+                      lo = lo + Math.imul(al3, bl2) | 0;
+                      mid = mid + Math.imul(al3, bh2) | 0;
+                      mid = mid + Math.imul(ah3, bl2) | 0;
+                      hi2 = hi2 + Math.imul(ah3, bh2) | 0;
+                      lo = lo + Math.imul(al2, bl3) | 0;
+                      mid = mid + Math.imul(al2, bh3) | 0;
+                      mid = mid + Math.imul(ah2, bl3) | 0;
+                      hi2 = hi2 + Math.imul(ah2, bh3) | 0;
+                      lo = lo + Math.imul(al1, bl4) | 0;
+                      mid = mid + Math.imul(al1, bh4) | 0;
+                      mid = mid + Math.imul(ah1, bl4) | 0;
+                      hi2 = hi2 + Math.imul(ah1, bh4) | 0;
+                      lo = lo + Math.imul(al0, bl5) | 0;
+                      mid = mid + Math.imul(al0, bh5) | 0;
+                      mid = mid + Math.imul(ah0, bl5) | 0;
+                      hi2 = hi2 + Math.imul(ah0, bh5) | 0;
+                      var w5 = (c2 + lo | 0) + ((mid & 8191) << 13) | 0;
+                      c2 = (hi2 + (mid >>> 13) | 0) + (w5 >>> 26) | 0;
+                      w5 &= 67108863;
+                      lo = Math.imul(al6, bl0);
+                      mid = Math.imul(al6, bh0);
+                      mid = mid + Math.imul(ah6, bl0) | 0;
+                      hi2 = Math.imul(ah6, bh0);
+                      lo = lo + Math.imul(al5, bl1) | 0;
+                      mid = mid + Math.imul(al5, bh1) | 0;
+                      mid = mid + Math.imul(ah5, bl1) | 0;
+                      hi2 = hi2 + Math.imul(ah5, bh1) | 0;
+                      lo = lo + Math.imul(al4, bl2) | 0;
+                      mid = mid + Math.imul(al4, bh2) | 0;
+                      mid = mid + Math.imul(ah4, bl2) | 0;
+                      hi2 = hi2 + Math.imul(ah4, bh2) | 0;
+                      lo = lo + Math.imul(al3, bl3) | 0;
+                      mid = mid + Math.imul(al3, bh3) | 0;
+                      mid = mid + Math.imul(ah3, bl3) | 0;
+                      hi2 = hi2 + Math.imul(ah3, bh3) | 0;
+                      lo = lo + Math.imul(al2, bl4) | 0;
+                      mid = mid + Math.imul(al2, bh4) | 0;
+                      mid = mid + Math.imul(ah2, bl4) | 0;
+                      hi2 = hi2 + Math.imul(ah2, bh4) | 0;
+                      lo = lo + Math.imul(al1, bl5) | 0;
+                      mid = mid + Math.imul(al1, bh5) | 0;
+                      mid = mid + Math.imul(ah1, bl5) | 0;
+                      hi2 = hi2 + Math.imul(ah1, bh5) | 0;
+                      lo = lo + Math.imul(al0, bl6) | 0;
+                      mid = mid + Math.imul(al0, bh6) | 0;
+                      mid = mid + Math.imul(ah0, bl6) | 0;
+                      hi2 = hi2 + Math.imul(ah0, bh6) | 0;
+                      var w6 = (c2 + lo | 0) + ((mid & 8191) << 13) | 0;
+                      c2 = (hi2 + (mid >>> 13) | 0) + (w6 >>> 26) | 0;
+                      w6 &= 67108863;
+                      lo = Math.imul(al7, bl0);
+                      mid = Math.imul(al7, bh0);
+                      mid = mid + Math.imul(ah7, bl0) | 0;
+                      hi2 = Math.imul(ah7, bh0);
+                      lo = lo + Math.imul(al6, bl1) | 0;
+                      mid = mid + Math.imul(al6, bh1) | 0;
+                      mid = mid + Math.imul(ah6, bl1) | 0;
+                      hi2 = hi2 + Math.imul(ah6, bh1) | 0;
+                      lo = lo + Math.imul(al5, bl2) | 0;
+                      mid = mid + Math.imul(al5, bh2) | 0;
+                      mid = mid + Math.imul(ah5, bl2) | 0;
+                      hi2 = hi2 + Math.imul(ah5, bh2) | 0;
+                      lo = lo + Math.imul(al4, bl3) | 0;
+                      mid = mid + Math.imul(al4, bh3) | 0;
+                      mid = mid + Math.imul(ah4, bl3) | 0;
+                      hi2 = hi2 + Math.imul(ah4, bh3) | 0;
+                      lo = lo + Math.imul(al3, bl4) | 0;
+                      mid = mid + Math.imul(al3, bh4) | 0;
+                      mid = mid + Math.imul(ah3, bl4) | 0;
+                      hi2 = hi2 + Math.imul(ah3, bh4) | 0;
+                      lo = lo + Math.imul(al2, bl5) | 0;
+                      mid = mid + Math.imul(al2, bh5) | 0;
+                      mid = mid + Math.imul(ah2, bl5) | 0;
+                      hi2 = hi2 + Math.imul(ah2, bh5) | 0;
+                      lo = lo + Math.imul(al1, bl6) | 0;
+                      mid = mid + Math.imul(al1, bh6) | 0;
+                      mid = mid + Math.imul(ah1, bl6) | 0;
+                      hi2 = hi2 + Math.imul(ah1, bh6) | 0;
+                      lo = lo + Math.imul(al0, bl7) | 0;
+                      mid = mid + Math.imul(al0, bh7) | 0;
+                      mid = mid + Math.imul(ah0, bl7) | 0;
+                      hi2 = hi2 + Math.imul(ah0, bh7) | 0;
+                      var w7 = (c2 + lo | 0) + ((mid & 8191) << 13) | 0;
+                      c2 = (hi2 + (mid >>> 13) | 0) + (w7 >>> 26) | 0;
+                      w7 &= 67108863;
+                      lo = Math.imul(al8, bl0);
+                      mid = Math.imul(al8, bh0);
+                      mid = mid + Math.imul(ah8, bl0) | 0;
+                      hi2 = Math.imul(ah8, bh0);
+                      lo = lo + Math.imul(al7, bl1) | 0;
+                      mid = mid + Math.imul(al7, bh1) | 0;
+                      mid = mid + Math.imul(ah7, bl1) | 0;
+                      hi2 = hi2 + Math.imul(ah7, bh1) | 0;
+                      lo = lo + Math.imul(al6, bl2) | 0;
+                      mid = mid + Math.imul(al6, bh2) | 0;
+                      mid = mid + Math.imul(ah6, bl2) | 0;
+                      hi2 = hi2 + Math.imul(ah6, bh2) | 0;
+                      lo = lo + Math.imul(al5, bl3) | 0;
+                      mid = mid + Math.imul(al5, bh3) | 0;
+                      mid = mid + Math.imul(ah5, bl3) | 0;
+                      hi2 = hi2 + Math.imul(ah5, bh3) | 0;
+                      lo = lo + Math.imul(al4, bl4) | 0;
+                      mid = mid + Math.imul(al4, bh4) | 0;
+                      mid = mid + Math.imul(ah4, bl4) | 0;
+                      hi2 = hi2 + Math.imul(ah4, bh4) | 0;
+                      lo = lo + Math.imul(al3, bl5) | 0;
+                      mid = mid + Math.imul(al3, bh5) | 0;
+                      mid = mid + Math.imul(ah3, bl5) | 0;
+                      hi2 = hi2 + Math.imul(ah3, bh5) | 0;
+                      lo = lo + Math.imul(al2, bl6) | 0;
+                      mid = mid + Math.imul(al2, bh6) | 0;
+                      mid = mid + Math.imul(ah2, bl6) | 0;
+                      hi2 = hi2 + Math.imul(ah2, bh6) | 0;
+                      lo = lo + Math.imul(al1, bl7) | 0;
+                      mid = mid + Math.imul(al1, bh7) | 0;
+                      mid = mid + Math.imul(ah1, bl7) | 0;
+                      hi2 = hi2 + Math.imul(ah1, bh7) | 0;
+                      lo = lo + Math.imul(al0, bl8) | 0;
+                      mid = mid + Math.imul(al0, bh8) | 0;
+                      mid = mid + Math.imul(ah0, bl8) | 0;
+                      hi2 = hi2 + Math.imul(ah0, bh8) | 0;
+                      var w8 = (c2 + lo | 0) + ((mid & 8191) << 13) | 0;
+                      c2 = (hi2 + (mid >>> 13) | 0) + (w8 >>> 26) | 0;
+                      w8 &= 67108863;
+                      lo = Math.imul(al9, bl0);
+                      mid = Math.imul(al9, bh0);
+                      mid = mid + Math.imul(ah9, bl0) | 0;
+                      hi2 = Math.imul(ah9, bh0);
+                      lo = lo + Math.imul(al8, bl1) | 0;
+                      mid = mid + Math.imul(al8, bh1) | 0;
+                      mid = mid + Math.imul(ah8, bl1) | 0;
+                      hi2 = hi2 + Math.imul(ah8, bh1) | 0;
+                      lo = lo + Math.imul(al7, bl2) | 0;
+                      mid = mid + Math.imul(al7, bh2) | 0;
+                      mid = mid + Math.imul(ah7, bl2) | 0;
+                      hi2 = hi2 + Math.imul(ah7, bh2) | 0;
+                      lo = lo + Math.imul(al6, bl3) | 0;
+                      mid = mid + Math.imul(al6, bh3) | 0;
+                      mid = mid + Math.imul(ah6, bl3) | 0;
+                      hi2 = hi2 + Math.imul(ah6, bh3) | 0;
+                      lo = lo + Math.imul(al5, bl4) | 0;
+                      mid = mid + Math.imul(al5, bh4) | 0;
+                      mid = mid + Math.imul(ah5, bl4) | 0;
+                      hi2 = hi2 + Math.imul(ah5, bh4) | 0;
+                      lo = lo + Math.imul(al4, bl5) | 0;
+                      mid = mid + Math.imul(al4, bh5) | 0;
+                      mid = mid + Math.imul(ah4, bl5) | 0;
+                      hi2 = hi2 + Math.imul(ah4, bh5) | 0;
+                      lo = lo + Math.imul(al3, bl6) | 0;
+                      mid = mid + Math.imul(al3, bh6) | 0;
+                      mid = mid + Math.imul(ah3, bl6) | 0;
+                      hi2 = hi2 + Math.imul(ah3, bh6) | 0;
+                      lo = lo + Math.imul(al2, bl7) | 0;
+                      mid = mid + Math.imul(al2, bh7) | 0;
+                      mid = mid + Math.imul(ah2, bl7) | 0;
+                      hi2 = hi2 + Math.imul(ah2, bh7) | 0;
+                      lo = lo + Math.imul(al1, bl8) | 0;
+                      mid = mid + Math.imul(al1, bh8) | 0;
+                      mid = mid + Math.imul(ah1, bl8) | 0;
+                      hi2 = hi2 + Math.imul(ah1, bh8) | 0;
+                      lo = lo + Math.imul(al0, bl9) | 0;
+                      mid = mid + Math.imul(al0, bh9) | 0;
+                      mid = mid + Math.imul(ah0, bl9) | 0;
+                      hi2 = hi2 + Math.imul(ah0, bh9) | 0;
+                      var w9 = (c2 + lo | 0) + ((mid & 8191) << 13) | 0;
+                      c2 = (hi2 + (mid >>> 13) | 0) + (w9 >>> 26) | 0;
+                      w9 &= 67108863;
+                      lo = Math.imul(al9, bl1);
+                      mid = Math.imul(al9, bh1);
+                      mid = mid + Math.imul(ah9, bl1) | 0;
+                      hi2 = Math.imul(ah9, bh1);
+                      lo = lo + Math.imul(al8, bl2) | 0;
+                      mid = mid + Math.imul(al8, bh2) | 0;
+                      mid = mid + Math.imul(ah8, bl2) | 0;
+                      hi2 = hi2 + Math.imul(ah8, bh2) | 0;
+                      lo = lo + Math.imul(al7, bl3) | 0;
+                      mid = mid + Math.imul(al7, bh3) | 0;
+                      mid = mid + Math.imul(ah7, bl3) | 0;
+                      hi2 = hi2 + Math.imul(ah7, bh3) | 0;
+                      lo = lo + Math.imul(al6, bl4) | 0;
+                      mid = mid + Math.imul(al6, bh4) | 0;
+                      mid = mid + Math.imul(ah6, bl4) | 0;
+                      hi2 = hi2 + Math.imul(ah6, bh4) | 0;
+                      lo = lo + Math.imul(al5, bl5) | 0;
+                      mid = mid + Math.imul(al5, bh5) | 0;
+                      mid = mid + Math.imul(ah5, bl5) | 0;
+                      hi2 = hi2 + Math.imul(ah5, bh5) | 0;
+                      lo = lo + Math.imul(al4, bl6) | 0;
+                      mid = mid + Math.imul(al4, bh6) | 0;
+                      mid = mid + Math.imul(ah4, bl6) | 0;
+                      hi2 = hi2 + Math.imul(ah4, bh6) | 0;
+                      lo = lo + Math.imul(al3, bl7) | 0;
+                      mid = mid + Math.imul(al3, bh7) | 0;
+                      mid = mid + Math.imul(ah3, bl7) | 0;
+                      hi2 = hi2 + Math.imul(ah3, bh7) | 0;
+                      lo = lo + Math.imul(al2, bl8) | 0;
+                      mid = mid + Math.imul(al2, bh8) | 0;
+                      mid = mid + Math.imul(ah2, bl8) | 0;
+                      hi2 = hi2 + Math.imul(ah2, bh8) | 0;
+                      lo = lo + Math.imul(al1, bl9) | 0;
+                      mid = mid + Math.imul(al1, bh9) | 0;
+                      mid = mid + Math.imul(ah1, bl9) | 0;
+                      hi2 = hi2 + Math.imul(ah1, bh9) | 0;
+                      var w10 = (c2 + lo | 0) + ((mid & 8191) << 13) | 0;
+                      c2 = (hi2 + (mid >>> 13) | 0) + (w10 >>> 26) | 0;
+                      w10 &= 67108863;
+                      lo = Math.imul(al9, bl2);
+                      mid = Math.imul(al9, bh2);
+                      mid = mid + Math.imul(ah9, bl2) | 0;
+                      hi2 = Math.imul(ah9, bh2);
+                      lo = lo + Math.imul(al8, bl3) | 0;
+                      mid = mid + Math.imul(al8, bh3) | 0;
+                      mid = mid + Math.imul(ah8, bl3) | 0;
+                      hi2 = hi2 + Math.imul(ah8, bh3) | 0;
+                      lo = lo + Math.imul(al7, bl4) | 0;
+                      mid = mid + Math.imul(al7, bh4) | 0;
+                      mid = mid + Math.imul(ah7, bl4) | 0;
+                      hi2 = hi2 + Math.imul(ah7, bh4) | 0;
+                      lo = lo + Math.imul(al6, bl5) | 0;
+                      mid = mid + Math.imul(al6, bh5) | 0;
+                      mid = mid + Math.imul(ah6, bl5) | 0;
+                      hi2 = hi2 + Math.imul(ah6, bh5) | 0;
+                      lo = lo + Math.imul(al5, bl6) | 0;
+                      mid = mid + Math.imul(al5, bh6) | 0;
+                      mid = mid + Math.imul(ah5, bl6) | 0;
+                      hi2 = hi2 + Math.imul(ah5, bh6) | 0;
+                      lo = lo + Math.imul(al4, bl7) | 0;
+                      mid = mid + Math.imul(al4, bh7) | 0;
+                      mid = mid + Math.imul(ah4, bl7) | 0;
+                      hi2 = hi2 + Math.imul(ah4, bh7) | 0;
+                      lo = lo + Math.imul(al3, bl8) | 0;
+                      mid = mid + Math.imul(al3, bh8) | 0;
+                      mid = mid + Math.imul(ah3, bl8) | 0;
+                      hi2 = hi2 + Math.imul(ah3, bh8) | 0;
+                      lo = lo + Math.imul(al2, bl9) | 0;
+                      mid = mid + Math.imul(al2, bh9) | 0;
+                      mid = mid + Math.imul(ah2, bl9) | 0;
+                      hi2 = hi2 + Math.imul(ah2, bh9) | 0;
+                      var w11 = (c2 + lo | 0) + ((mid & 8191) << 13) | 0;
+                      c2 = (hi2 + (mid >>> 13) | 0) + (w11 >>> 26) | 0;
+                      w11 &= 67108863;
+                      lo = Math.imul(al9, bl3);
+                      mid = Math.imul(al9, bh3);
+                      mid = mid + Math.imul(ah9, bl3) | 0;
+                      hi2 = Math.imul(ah9, bh3);
+                      lo = lo + Math.imul(al8, bl4) | 0;
+                      mid = mid + Math.imul(al8, bh4) | 0;
+                      mid = mid + Math.imul(ah8, bl4) | 0;
+                      hi2 = hi2 + Math.imul(ah8, bh4) | 0;
+                      lo = lo + Math.imul(al7, bl5) | 0;
+                      mid = mid + Math.imul(al7, bh5) | 0;
+                      mid = mid + Math.imul(ah7, bl5) | 0;
+                      hi2 = hi2 + Math.imul(ah7, bh5) | 0;
+                      lo = lo + Math.imul(al6, bl6) | 0;
+                      mid = mid + Math.imul(al6, bh6) | 0;
+                      mid = mid + Math.imul(ah6, bl6) | 0;
+                      hi2 = hi2 + Math.imul(ah6, bh6) | 0;
+                      lo = lo + Math.imul(al5, bl7) | 0;
+                      mid = mid + Math.imul(al5, bh7) | 0;
+                      mid = mid + Math.imul(ah5, bl7) | 0;
+                      hi2 = hi2 + Math.imul(ah5, bh7) | 0;
+                      lo = lo + Math.imul(al4, bl8) | 0;
+                      mid = mid + Math.imul(al4, bh8) | 0;
+                      mid = mid + Math.imul(ah4, bl8) | 0;
+                      hi2 = hi2 + Math.imul(ah4, bh8) | 0;
+                      lo = lo + Math.imul(al3, bl9) | 0;
+                      mid = mid + Math.imul(al3, bh9) | 0;
+                      mid = mid + Math.imul(ah3, bl9) | 0;
+                      hi2 = hi2 + Math.imul(ah3, bh9) | 0;
+                      var w12 = (c2 + lo | 0) + ((mid & 8191) << 13) | 0;
+                      c2 = (hi2 + (mid >>> 13) | 0) + (w12 >>> 26) | 0;
+                      w12 &= 67108863;
+                      lo = Math.imul(al9, bl4);
+                      mid = Math.imul(al9, bh4);
+                      mid = mid + Math.imul(ah9, bl4) | 0;
+                      hi2 = Math.imul(ah9, bh4);
+                      lo = lo + Math.imul(al8, bl5) | 0;
+                      mid = mid + Math.imul(al8, bh5) | 0;
+                      mid = mid + Math.imul(ah8, bl5) | 0;
+                      hi2 = hi2 + Math.imul(ah8, bh5) | 0;
+                      lo = lo + Math.imul(al7, bl6) | 0;
+                      mid = mid + Math.imul(al7, bh6) | 0;
+                      mid = mid + Math.imul(ah7, bl6) | 0;
+                      hi2 = hi2 + Math.imul(ah7, bh6) | 0;
+                      lo = lo + Math.imul(al6, bl7) | 0;
+                      mid = mid + Math.imul(al6, bh7) | 0;
+                      mid = mid + Math.imul(ah6, bl7) | 0;
+                      hi2 = hi2 + Math.imul(ah6, bh7) | 0;
+                      lo = lo + Math.imul(al5, bl8) | 0;
+                      mid = mid + Math.imul(al5, bh8) | 0;
+                      mid = mid + Math.imul(ah5, bl8) | 0;
+                      hi2 = hi2 + Math.imul(ah5, bh8) | 0;
+                      lo = lo + Math.imul(al4, bl9) | 0;
+                      mid = mid + Math.imul(al4, bh9) | 0;
+                      mid = mid + Math.imul(ah4, bl9) | 0;
+                      hi2 = hi2 + Math.imul(ah4, bh9) | 0;
+                      var w13 = (c2 + lo | 0) + ((mid & 8191) << 13) | 0;
+                      c2 = (hi2 + (mid >>> 13) | 0) + (w13 >>> 26) | 0;
+                      w13 &= 67108863;
+                      lo = Math.imul(al9, bl5);
+                      mid = Math.imul(al9, bh5);
+                      mid = mid + Math.imul(ah9, bl5) | 0;
+                      hi2 = Math.imul(ah9, bh5);
+                      lo = lo + Math.imul(al8, bl6) | 0;
+                      mid = mid + Math.imul(al8, bh6) | 0;
+                      mid = mid + Math.imul(ah8, bl6) | 0;
+                      hi2 = hi2 + Math.imul(ah8, bh6) | 0;
+                      lo = lo + Math.imul(al7, bl7) | 0;
+                      mid = mid + Math.imul(al7, bh7) | 0;
+                      mid = mid + Math.imul(ah7, bl7) | 0;
+                      hi2 = hi2 + Math.imul(ah7, bh7) | 0;
+                      lo = lo + Math.imul(al6, bl8) | 0;
+                      mid = mid + Math.imul(al6, bh8) | 0;
+                      mid = mid + Math.imul(ah6, bl8) | 0;
+                      hi2 = hi2 + Math.imul(ah6, bh8) | 0;
+                      lo = lo + Math.imul(al5, bl9) | 0;
+                      mid = mid + Math.imul(al5, bh9) | 0;
+                      mid = mid + Math.imul(ah5, bl9) | 0;
+                      hi2 = hi2 + Math.imul(ah5, bh9) | 0;
+                      var w14 = (c2 + lo | 0) + ((mid & 8191) << 13) | 0;
+                      c2 = (hi2 + (mid >>> 13) | 0) + (w14 >>> 26) | 0;
+                      w14 &= 67108863;
+                      lo = Math.imul(al9, bl6);
+                      mid = Math.imul(al9, bh6);
+                      mid = mid + Math.imul(ah9, bl6) | 0;
+                      hi2 = Math.imul(ah9, bh6);
+                      lo = lo + Math.imul(al8, bl7) | 0;
+                      mid = mid + Math.imul(al8, bh7) | 0;
+                      mid = mid + Math.imul(ah8, bl7) | 0;
+                      hi2 = hi2 + Math.imul(ah8, bh7) | 0;
+                      lo = lo + Math.imul(al7, bl8) | 0;
+                      mid = mid + Math.imul(al7, bh8) | 0;
+                      mid = mid + Math.imul(ah7, bl8) | 0;
+                      hi2 = hi2 + Math.imul(ah7, bh8) | 0;
+                      lo = lo + Math.imul(al6, bl9) | 0;
+                      mid = mid + Math.imul(al6, bh9) | 0;
+                      mid = mid + Math.imul(ah6, bl9) | 0;
+                      hi2 = hi2 + Math.imul(ah6, bh9) | 0;
+                      var w15 = (c2 + lo | 0) + ((mid & 8191) << 13) | 0;
+                      c2 = (hi2 + (mid >>> 13) | 0) + (w15 >>> 26) | 0;
+                      w15 &= 67108863;
+                      lo = Math.imul(al9, bl7);
+                      mid = Math.imul(al9, bh7);
+                      mid = mid + Math.imul(ah9, bl7) | 0;
+                      hi2 = Math.imul(ah9, bh7);
+                      lo = lo + Math.imul(al8, bl8) | 0;
+                      mid = mid + Math.imul(al8, bh8) | 0;
+                      mid = mid + Math.imul(ah8, bl8) | 0;
+                      hi2 = hi2 + Math.imul(ah8, bh8) | 0;
+                      lo = lo + Math.imul(al7, bl9) | 0;
+                      mid = mid + Math.imul(al7, bh9) | 0;
+                      mid = mid + Math.imul(ah7, bl9) | 0;
+                      hi2 = hi2 + Math.imul(ah7, bh9) | 0;
+                      var w16 = (c2 + lo | 0) + ((mid & 8191) << 13) | 0;
+                      c2 = (hi2 + (mid >>> 13) | 0) + (w16 >>> 26) | 0;
+                      w16 &= 67108863;
+                      lo = Math.imul(al9, bl8);
+                      mid = Math.imul(al9, bh8);
+                      mid = mid + Math.imul(ah9, bl8) | 0;
+                      hi2 = Math.imul(ah9, bh8);
+                      lo = lo + Math.imul(al8, bl9) | 0;
+                      mid = mid + Math.imul(al8, bh9) | 0;
+                      mid = mid + Math.imul(ah8, bl9) | 0;
+                      hi2 = hi2 + Math.imul(ah8, bh9) | 0;
+                      var w17 = (c2 + lo | 0) + ((mid & 8191) << 13) | 0;
+                      c2 = (hi2 + (mid >>> 13) | 0) + (w17 >>> 26) | 0;
+                      w17 &= 67108863;
+                      lo = Math.imul(al9, bl9);
+                      mid = Math.imul(al9, bh9);
+                      mid = mid + Math.imul(ah9, bl9) | 0;
+                      hi2 = Math.imul(ah9, bh9);
+                      var w18 = (c2 + lo | 0) + ((mid & 8191) << 13) | 0;
+                      c2 = (hi2 + (mid >>> 13) | 0) + (w18 >>> 26) | 0;
+                      w18 &= 67108863;
+                      o2[0] = w0;
+                      o2[1] = w1;
+                      o2[2] = w2;
+                      o2[3] = w3;
+                      o2[4] = w4;
+                      o2[5] = w5;
+                      o2[6] = w6;
+                      o2[7] = w7;
+                      o2[8] = w8;
+                      o2[9] = w9;
+                      o2[10] = w10;
+                      o2[11] = w11;
+                      o2[12] = w12;
+                      o2[13] = w13;
+                      o2[14] = w14;
+                      o2[15] = w15;
+                      o2[16] = w16;
+                      o2[17] = w17;
+                      o2[18] = w18;
+                      if (c2 !== 0) {
+                        o2[19] = c2;
+                        out.length++;
+                      }
+                      return out;
+                    };
+                    if (!Math.imul) {
+                      comb10MulTo = smallMulTo;
+                    }
+                    function bigMulTo(self2, num, out) {
+                      out.negative = num.negative ^ self2.negative;
+                      out.length = self2.length + num.length;
+                      var carry = 0;
+                      var hncarry = 0;
+                      for (var k2 = 0; k2 < out.length - 1; k2++) {
+                        var ncarry = hncarry;
+                        hncarry = 0;
+                        var rword = carry & 67108863;
+                        var maxJ = Math.min(k2, num.length - 1);
+                        for (var j2 = Math.max(0, k2 - self2.length + 1); j2 <= maxJ; j2++) {
+                          var i2 = k2 - j2;
+                          var a2 = self2.words[i2] | 0;
+                          var b2 = num.words[j2] | 0;
+                          var r2 = a2 * b2;
+                          var lo = r2 & 67108863;
+                          ncarry = ncarry + (r2 / 67108864 | 0) | 0;
+                          lo = lo + rword | 0;
+                          rword = lo & 67108863;
+                          ncarry = ncarry + (lo >>> 26) | 0;
+                          hncarry += ncarry >>> 26;
+                          ncarry &= 67108863;
+                        }
+                        out.words[k2] = rword;
+                        carry = ncarry;
+                        ncarry = hncarry;
+                      }
+                      if (carry !== 0) {
+                        out.words[k2] = carry;
+                      } else {
+                        out.length--;
+                      }
+                      return out.strip();
+                    }
+                    function jumboMulTo(self2, num, out) {
+                      var fftm = new FFTM();
+                      return fftm.mulp(self2, num, out);
+                    }
+                    BN2.prototype.mulTo = function mulTo(num, out) {
+                      var res;
+                      var len2 = this.length + num.length;
+                      if (this.length === 10 && num.length === 10) {
+                        res = comb10MulTo(this, num, out);
+                      } else if (len2 < 63) {
+                        res = smallMulTo(this, num, out);
+                      } else if (len2 < 1024) {
+                        res = bigMulTo(this, num, out);
+                      } else {
+                        res = jumboMulTo(this, num, out);
+                      }
+                      return res;
+                    };
+                    function FFTM(x2, y2) {
+                      this.x = x2;
+                      this.y = y2;
+                    }
+                    FFTM.prototype.makeRBT = function makeRBT(N2) {
+                      var t4 = new Array(N2);
+                      var l2 = BN2.prototype._countBits(N2) - 1;
+                      for (var i2 = 0; i2 < N2; i2++) {
+                        t4[i2] = this.revBin(i2, l2, N2);
+                      }
+                      return t4;
+                    };
+                    FFTM.prototype.revBin = function revBin(x2, l2, N2) {
+                      if (x2 === 0 || x2 === N2 - 1) return x2;
+                      var rb2 = 0;
+                      for (var i2 = 0; i2 < l2; i2++) {
+                        rb2 |= (x2 & 1) << l2 - i2 - 1;
+                        x2 >>= 1;
+                      }
+                      return rb2;
+                    };
+                    FFTM.prototype.permute = function permute(rbt, rws, iws, rtws, itws, N2) {
+                      for (var i2 = 0; i2 < N2; i2++) {
+                        rtws[i2] = rws[rbt[i2]];
+                        itws[i2] = iws[rbt[i2]];
+                      }
+                    };
+                    FFTM.prototype.transform = function transform(rws, iws, rtws, itws, N2, rbt) {
+                      this.permute(rbt, rws, iws, rtws, itws, N2);
+                      for (var s2 = 1; s2 < N2; s2 <<= 1) {
+                        var l2 = s2 << 1;
+                        var rtwdf = Math.cos(2 * Math.PI / l2);
+                        var itwdf = Math.sin(2 * Math.PI / l2);
+                        for (var p2 = 0; p2 < N2; p2 += l2) {
+                          var rtwdf_ = rtwdf;
+                          var itwdf_ = itwdf;
+                          for (var j2 = 0; j2 < s2; j2++) {
+                            var re2 = rtws[p2 + j2];
+                            var ie2 = itws[p2 + j2];
+                            var ro = rtws[p2 + j2 + s2];
+                            var io = itws[p2 + j2 + s2];
+                            var rx = rtwdf_ * ro - itwdf_ * io;
+                            io = rtwdf_ * io + itwdf_ * ro;
+                            ro = rx;
+                            rtws[p2 + j2] = re2 + ro;
+                            itws[p2 + j2] = ie2 + io;
+                            rtws[p2 + j2 + s2] = re2 - ro;
+                            itws[p2 + j2 + s2] = ie2 - io;
+                            if (j2 !== l2) {
+                              rx = rtwdf * rtwdf_ - itwdf * itwdf_;
+                              itwdf_ = rtwdf * itwdf_ + itwdf * rtwdf_;
+                              rtwdf_ = rx;
+                            }
+                          }
+                        }
+                      }
+                    };
+                    FFTM.prototype.guessLen13b = function guessLen13b(n2, m2) {
+                      var N2 = Math.max(m2, n2) | 1;
+                      var odd = N2 & 1;
+                      var i2 = 0;
+                      for (N2 = N2 / 2 | 0; N2; N2 = N2 >>> 1) {
+                        i2++;
+                      }
+                      return 1 << i2 + 1 + odd;
+                    };
+                    FFTM.prototype.conjugate = function conjugate(rws, iws, N2) {
+                      if (N2 <= 1) return;
+                      for (var i2 = 0; i2 < N2 / 2; i2++) {
+                        var t4 = rws[i2];
+                        rws[i2] = rws[N2 - i2 - 1];
+                        rws[N2 - i2 - 1] = t4;
+                        t4 = iws[i2];
+                        iws[i2] = -iws[N2 - i2 - 1];
+                        iws[N2 - i2 - 1] = -t4;
+                      }
+                    };
+                    FFTM.prototype.normalize13b = function normalize13b(ws, N2) {
+                      var carry = 0;
+                      for (var i2 = 0; i2 < N2 / 2; i2++) {
+                        var w2 = Math.round(ws[2 * i2 + 1] / N2) * 8192 + Math.round(ws[2 * i2] / N2) + carry;
+                        ws[i2] = w2 & 67108863;
+                        if (w2 < 67108864) {
+                          carry = 0;
+                        } else {
+                          carry = w2 / 67108864 | 0;
+                        }
+                      }
+                      return ws;
+                    };
+                    FFTM.prototype.convert13b = function convert13b(ws, len2, rws, N2) {
+                      var carry = 0;
+                      for (var i2 = 0; i2 < len2; i2++) {
+                        carry = carry + (ws[i2] | 0);
+                        rws[2 * i2] = carry & 8191;
+                        carry = carry >>> 13;
+                        rws[2 * i2 + 1] = carry & 8191;
+                        carry = carry >>> 13;
+                      }
+                      for (i2 = 2 * len2; i2 < N2; ++i2) {
+                        rws[i2] = 0;
+                      }
+                      assert2(carry === 0);
+                      assert2((carry & -8192) === 0);
+                    };
+                    FFTM.prototype.stub = function stub(N2) {
+                      var ph2 = new Array(N2);
+                      for (var i2 = 0; i2 < N2; i2++) {
+                        ph2[i2] = 0;
+                      }
+                      return ph2;
+                    };
+                    FFTM.prototype.mulp = function mulp(x2, y2, out) {
+                      var N2 = 2 * this.guessLen13b(x2.length, y2.length);
+                      var rbt = this.makeRBT(N2);
+                      var _2 = this.stub(N2);
+                      var rws = new Array(N2);
+                      var rwst = new Array(N2);
+                      var iwst = new Array(N2);
+                      var nrws = new Array(N2);
+                      var nrwst = new Array(N2);
+                      var niwst = new Array(N2);
+                      var rmws = out.words;
+                      rmws.length = N2;
+                      this.convert13b(x2.words, x2.length, rws, N2);
+                      this.convert13b(y2.words, y2.length, nrws, N2);
+                      this.transform(rws, _2, rwst, iwst, N2, rbt);
+                      this.transform(nrws, _2, nrwst, niwst, N2, rbt);
+                      for (var i2 = 0; i2 < N2; i2++) {
+                        var rx = rwst[i2] * nrwst[i2] - iwst[i2] * niwst[i2];
+                        iwst[i2] = rwst[i2] * niwst[i2] + iwst[i2] * nrwst[i2];
+                        rwst[i2] = rx;
+                      }
+                      this.conjugate(rwst, iwst, N2);
+                      this.transform(rwst, iwst, rmws, _2, N2, rbt);
+                      this.conjugate(rmws, _2, N2);
+                      this.normalize13b(rmws, N2);
+                      out.negative = x2.negative ^ y2.negative;
+                      out.length = x2.length + y2.length;
+                      return out.strip();
+                    };
+                    BN2.prototype.mul = function mul(num) {
+                      var out = new BN2(null);
+                      out.words = new Array(this.length + num.length);
+                      return this.mulTo(num, out);
+                    };
+                    BN2.prototype.mulf = function mulf(num) {
+                      var out = new BN2(null);
+                      out.words = new Array(this.length + num.length);
+                      return jumboMulTo(this, num, out);
+                    };
+                    BN2.prototype.imul = function imul(num) {
+                      return this.clone().mulTo(num, this);
+                    };
+                    BN2.prototype.imuln = function imuln(num) {
+                      assert2(typeof num === "number");
+                      assert2(num < 67108864);
+                      var carry = 0;
+                      for (var i2 = 0; i2 < this.length; i2++) {
+                        var w2 = (this.words[i2] | 0) * num;
+                        var lo = (w2 & 67108863) + (carry & 67108863);
+                        carry >>= 26;
+                        carry += w2 / 67108864 | 0;
+                        carry += lo >>> 26;
+                        this.words[i2] = lo & 67108863;
+                      }
+                      if (carry !== 0) {
+                        this.words[i2] = carry;
+                        this.length++;
+                      }
+                      return this;
+                    };
+                    BN2.prototype.muln = function muln(num) {
+                      return this.clone().imuln(num);
+                    };
+                    BN2.prototype.sqr = function sqr() {
+                      return this.mul(this);
+                    };
+                    BN2.prototype.isqr = function isqr() {
+                      return this.imul(this.clone());
+                    };
+                    BN2.prototype.pow = function pow(num) {
+                      var w2 = toBitArray(num);
+                      if (w2.length === 0) return new BN2(1);
+                      var res = this;
+                      for (var i2 = 0; i2 < w2.length; i2++, res = res.sqr()) {
+                        if (w2[i2] !== 0) break;
+                      }
+                      if (++i2 < w2.length) {
+                        for (var q2 = res.sqr(); i2 < w2.length; i2++, q2 = q2.sqr()) {
+                          if (w2[i2] === 0) continue;
+                          res = res.mul(q2);
+                        }
+                      }
+                      return res;
+                    };
+                    BN2.prototype.iushln = function iushln(bits) {
+                      assert2(typeof bits === "number" && bits >= 0);
+                      var r2 = bits % 26;
+                      var s2 = (bits - r2) / 26;
+                      var carryMask = 67108863 >>> 26 - r2 << 26 - r2;
+                      var i2;
+                      if (r2 !== 0) {
+                        var carry = 0;
+                        for (i2 = 0; i2 < this.length; i2++) {
+                          var newCarry = this.words[i2] & carryMask;
+                          var c2 = (this.words[i2] | 0) - newCarry << r2;
+                          this.words[i2] = c2 | carry;
+                          carry = newCarry >>> 26 - r2;
+                        }
+                        if (carry) {
+                          this.words[i2] = carry;
+                          this.length++;
+                        }
+                      }
+                      if (s2 !== 0) {
+                        for (i2 = this.length - 1; i2 >= 0; i2--) {
+                          this.words[i2 + s2] = this.words[i2];
+                        }
+                        for (i2 = 0; i2 < s2; i2++) {
+                          this.words[i2] = 0;
+                        }
+                        this.length += s2;
+                      }
+                      return this.strip();
+                    };
+                    BN2.prototype.ishln = function ishln(bits) {
+                      assert2(this.negative === 0);
+                      return this.iushln(bits);
+                    };
+                    BN2.prototype.iushrn = function iushrn(bits, hint2, extended) {
+                      assert2(typeof bits === "number" && bits >= 0);
+                      var h2;
+                      if (hint2) {
+                        h2 = (hint2 - hint2 % 26) / 26;
+                      } else {
+                        h2 = 0;
+                      }
+                      var r2 = bits % 26;
+                      var s2 = Math.min((bits - r2) / 26, this.length);
+                      var mask = 67108863 ^ 67108863 >>> r2 << r2;
+                      var maskedWords = extended;
+                      h2 -= s2;
+                      h2 = Math.max(0, h2);
+                      if (maskedWords) {
+                        for (var i2 = 0; i2 < s2; i2++) {
+                          maskedWords.words[i2] = this.words[i2];
+                        }
+                        maskedWords.length = s2;
+                      }
+                      if (s2 === 0) ;
+                      else if (this.length > s2) {
+                        this.length -= s2;
+                        for (i2 = 0; i2 < this.length; i2++) {
+                          this.words[i2] = this.words[i2 + s2];
+                        }
+                      } else {
+                        this.words[0] = 0;
+                        this.length = 1;
+                      }
+                      var carry = 0;
+                      for (i2 = this.length - 1; i2 >= 0 && (carry !== 0 || i2 >= h2); i2--) {
+                        var word = this.words[i2] | 0;
+                        this.words[i2] = carry << 26 - r2 | word >>> r2;
+                        carry = word & mask;
+                      }
+                      if (maskedWords && carry !== 0) {
+                        maskedWords.words[maskedWords.length++] = carry;
+                      }
+                      if (this.length === 0) {
+                        this.words[0] = 0;
+                        this.length = 1;
+                      }
+                      return this.strip();
+                    };
+                    BN2.prototype.ishrn = function ishrn(bits, hint2, extended) {
+                      assert2(this.negative === 0);
+                      return this.iushrn(bits, hint2, extended);
+                    };
+                    BN2.prototype.shln = function shln(bits) {
+                      return this.clone().ishln(bits);
+                    };
+                    BN2.prototype.ushln = function ushln(bits) {
+                      return this.clone().iushln(bits);
+                    };
+                    BN2.prototype.shrn = function shrn(bits) {
+                      return this.clone().ishrn(bits);
+                    };
+                    BN2.prototype.ushrn = function ushrn(bits) {
+                      return this.clone().iushrn(bits);
+                    };
+                    BN2.prototype.testn = function testn(bit) {
+                      assert2(typeof bit === "number" && bit >= 0);
+                      var r2 = bit % 26;
+                      var s2 = (bit - r2) / 26;
+                      var q2 = 1 << r2;
+                      if (this.length <= s2) return false;
+                      var w2 = this.words[s2];
+                      return !!(w2 & q2);
+                    };
+                    BN2.prototype.imaskn = function imaskn(bits) {
+                      assert2(typeof bits === "number" && bits >= 0);
+                      var r2 = bits % 26;
+                      var s2 = (bits - r2) / 26;
+                      assert2(this.negative === 0, "imaskn works only with positive numbers");
+                      if (this.length <= s2) {
+                        return this;
+                      }
+                      if (r2 !== 0) {
+                        s2++;
+                      }
+                      this.length = Math.min(s2, this.length);
+                      if (r2 !== 0) {
+                        var mask = 67108863 ^ 67108863 >>> r2 << r2;
+                        this.words[this.length - 1] &= mask;
+                      }
+                      return this.strip();
+                    };
+                    BN2.prototype.maskn = function maskn(bits) {
+                      return this.clone().imaskn(bits);
+                    };
+                    BN2.prototype.iaddn = function iaddn(num) {
+                      assert2(typeof num === "number");
+                      assert2(num < 67108864);
+                      if (num < 0) return this.isubn(-num);
+                      if (this.negative !== 0) {
+                        if (this.length === 1 && (this.words[0] | 0) < num) {
+                          this.words[0] = num - (this.words[0] | 0);
+                          this.negative = 0;
+                          return this;
+                        }
+                        this.negative = 0;
+                        this.isubn(num);
+                        this.negative = 1;
+                        return this;
+                      }
+                      return this._iaddn(num);
+                    };
+                    BN2.prototype._iaddn = function _iaddn(num) {
+                      this.words[0] += num;
+                      for (var i2 = 0; i2 < this.length && this.words[i2] >= 67108864; i2++) {
+                        this.words[i2] -= 67108864;
+                        if (i2 === this.length - 1) {
+                          this.words[i2 + 1] = 1;
+                        } else {
+                          this.words[i2 + 1]++;
+                        }
+                      }
+                      this.length = Math.max(this.length, i2 + 1);
+                      return this;
+                    };
+                    BN2.prototype.isubn = function isubn(num) {
+                      assert2(typeof num === "number");
+                      assert2(num < 67108864);
+                      if (num < 0) return this.iaddn(-num);
+                      if (this.negative !== 0) {
+                        this.negative = 0;
+                        this.iaddn(num);
+                        this.negative = 1;
+                        return this;
+                      }
+                      this.words[0] -= num;
+                      if (this.length === 1 && this.words[0] < 0) {
+                        this.words[0] = -this.words[0];
+                        this.negative = 1;
+                      } else {
+                        for (var i2 = 0; i2 < this.length && this.words[i2] < 0; i2++) {
+                          this.words[i2] += 67108864;
+                          this.words[i2 + 1] -= 1;
+                        }
+                      }
+                      return this.strip();
+                    };
+                    BN2.prototype.addn = function addn(num) {
+                      return this.clone().iaddn(num);
+                    };
+                    BN2.prototype.subn = function subn(num) {
+                      return this.clone().isubn(num);
+                    };
+                    BN2.prototype.iabs = function iabs() {
+                      this.negative = 0;
+                      return this;
+                    };
+                    BN2.prototype.abs = function abs() {
+                      return this.clone().iabs();
+                    };
+                    BN2.prototype._ishlnsubmul = function _ishlnsubmul(num, mul, shift) {
+                      var len2 = num.length + shift;
+                      var i2;
+                      this._expand(len2);
+                      var w2;
+                      var carry = 0;
+                      for (i2 = 0; i2 < num.length; i2++) {
+                        w2 = (this.words[i2 + shift] | 0) + carry;
+                        var right = (num.words[i2] | 0) * mul;
+                        w2 -= right & 67108863;
+                        carry = (w2 >> 26) - (right / 67108864 | 0);
+                        this.words[i2 + shift] = w2 & 67108863;
+                      }
+                      for (; i2 < this.length - shift; i2++) {
+                        w2 = (this.words[i2 + shift] | 0) + carry;
+                        carry = w2 >> 26;
+                        this.words[i2 + shift] = w2 & 67108863;
+                      }
+                      if (carry === 0) return this.strip();
+                      assert2(carry === -1);
+                      carry = 0;
+                      for (i2 = 0; i2 < this.length; i2++) {
+                        w2 = -(this.words[i2] | 0) + carry;
+                        carry = w2 >> 26;
+                        this.words[i2] = w2 & 67108863;
+                      }
+                      this.negative = 1;
+                      return this.strip();
+                    };
+                    BN2.prototype._wordDiv = function _wordDiv(num, mode) {
+                      var shift = this.length - num.length;
+                      var a2 = this.clone();
+                      var b2 = num;
+                      var bhi = b2.words[b2.length - 1] | 0;
+                      var bhiBits = this._countBits(bhi);
+                      shift = 26 - bhiBits;
+                      if (shift !== 0) {
+                        b2 = b2.ushln(shift);
+                        a2.iushln(shift);
+                        bhi = b2.words[b2.length - 1] | 0;
+                      }
+                      var m2 = a2.length - b2.length;
+                      var q2;
+                      if (mode !== "mod") {
+                        q2 = new BN2(null);
+                        q2.length = m2 + 1;
+                        q2.words = new Array(q2.length);
+                        for (var i2 = 0; i2 < q2.length; i2++) {
+                          q2.words[i2] = 0;
+                        }
+                      }
+                      var diff = a2.clone()._ishlnsubmul(b2, 1, m2);
+                      if (diff.negative === 0) {
+                        a2 = diff;
+                        if (q2) {
+                          q2.words[m2] = 1;
+                        }
+                      }
+                      for (var j2 = m2 - 1; j2 >= 0; j2--) {
+                        var qj2 = (a2.words[b2.length + j2] | 0) * 67108864 + (a2.words[b2.length + j2 - 1] | 0);
+                        qj2 = Math.min(qj2 / bhi | 0, 67108863);
+                        a2._ishlnsubmul(b2, qj2, j2);
+                        while (a2.negative !== 0) {
+                          qj2--;
+                          a2.negative = 0;
+                          a2._ishlnsubmul(b2, 1, j2);
+                          if (!a2.isZero()) {
+                            a2.negative ^= 1;
+                          }
+                        }
+                        if (q2) {
+                          q2.words[j2] = qj2;
+                        }
+                      }
+                      if (q2) {
+                        q2.strip();
+                      }
+                      a2.strip();
+                      if (mode !== "div" && shift !== 0) {
+                        a2.iushrn(shift);
+                      }
+                      return {
+                        div: q2 || null,
+                        mod: a2
+                      };
+                    };
+                    BN2.prototype.divmod = function divmod(num, mode, positive) {
+                      assert2(!num.isZero());
+                      if (this.isZero()) {
+                        return {
+                          div: new BN2(0),
+                          mod: new BN2(0)
+                        };
+                      }
+                      var div, mod2, res;
+                      if (this.negative !== 0 && num.negative === 0) {
+                        res = this.neg().divmod(num, mode);
+                        if (mode !== "mod") {
+                          div = res.div.neg();
+                        }
+                        if (mode !== "div") {
+                          mod2 = res.mod.neg();
+                          if (positive && mod2.negative !== 0) {
+                            mod2.iadd(num);
+                          }
+                        }
+                        return {
+                          div,
+                          mod: mod2
+                        };
+                      }
+                      if (this.negative === 0 && num.negative !== 0) {
+                        res = this.divmod(num.neg(), mode);
+                        if (mode !== "mod") {
+                          div = res.div.neg();
+                        }
+                        return {
+                          div,
+                          mod: res.mod
+                        };
+                      }
+                      if ((this.negative & num.negative) !== 0) {
+                        res = this.neg().divmod(num.neg(), mode);
+                        if (mode !== "div") {
+                          mod2 = res.mod.neg();
+                          if (positive && mod2.negative !== 0) {
+                            mod2.isub(num);
+                          }
+                        }
+                        return {
+                          div: res.div,
+                          mod: mod2
+                        };
+                      }
+                      if (num.length > this.length || this.cmp(num) < 0) {
+                        return {
+                          div: new BN2(0),
+                          mod: this
+                        };
+                      }
+                      if (num.length === 1) {
+                        if (mode === "div") {
+                          return {
+                            div: this.divn(num.words[0]),
+                            mod: null
+                          };
+                        }
+                        if (mode === "mod") {
+                          return {
+                            div: null,
+                            mod: new BN2(this.modn(num.words[0]))
+                          };
+                        }
+                        return {
+                          div: this.divn(num.words[0]),
+                          mod: new BN2(this.modn(num.words[0]))
+                        };
+                      }
+                      return this._wordDiv(num, mode);
+                    };
+                    BN2.prototype.div = function div(num) {
+                      return this.divmod(num, "div", false).div;
+                    };
+                    BN2.prototype.mod = function mod2(num) {
+                      return this.divmod(num, "mod", false).mod;
+                    };
+                    BN2.prototype.umod = function umod(num) {
+                      return this.divmod(num, "mod", true).mod;
+                    };
+                    BN2.prototype.divRound = function divRound(num) {
+                      var dm = this.divmod(num);
+                      if (dm.mod.isZero()) return dm.div;
+                      var mod2 = dm.div.negative !== 0 ? dm.mod.isub(num) : dm.mod;
+                      var half = num.ushrn(1);
+                      var r2 = num.andln(1);
+                      var cmp = mod2.cmp(half);
+                      if (cmp < 0 || r2 === 1 && cmp === 0) return dm.div;
+                      return dm.div.negative !== 0 ? dm.div.isubn(1) : dm.div.iaddn(1);
+                    };
+                    BN2.prototype.modn = function modn(num) {
+                      assert2(num <= 67108863);
+                      var p2 = (1 << 26) % num;
+                      var acc = 0;
+                      for (var i2 = this.length - 1; i2 >= 0; i2--) {
+                        acc = (p2 * acc + (this.words[i2] | 0)) % num;
+                      }
+                      return acc;
+                    };
+                    BN2.prototype.idivn = function idivn(num) {
+                      assert2(num <= 67108863);
+                      var carry = 0;
+                      for (var i2 = this.length - 1; i2 >= 0; i2--) {
+                        var w2 = (this.words[i2] | 0) + carry * 67108864;
+                        this.words[i2] = w2 / num | 0;
+                        carry = w2 % num;
+                      }
+                      return this.strip();
+                    };
+                    BN2.prototype.divn = function divn(num) {
+                      return this.clone().idivn(num);
+                    };
+                    BN2.prototype.egcd = function egcd(p2) {
+                      assert2(p2.negative === 0);
+                      assert2(!p2.isZero());
+                      var x2 = this;
+                      var y2 = p2.clone();
+                      if (x2.negative !== 0) {
+                        x2 = x2.umod(p2);
+                      } else {
+                        x2 = x2.clone();
+                      }
+                      var A22 = new BN2(1);
+                      var B22 = new BN2(0);
+                      var C22 = new BN2(0);
+                      var D22 = new BN2(1);
+                      var g2 = 0;
+                      while (x2.isEven() && y2.isEven()) {
+                        x2.iushrn(1);
+                        y2.iushrn(1);
+                        ++g2;
+                      }
+                      var yp = y2.clone();
+                      var xp = x2.clone();
+                      while (!x2.isZero()) {
+                        for (var i2 = 0, im = 1; (x2.words[0] & im) === 0 && i2 < 26; ++i2, im <<= 1) ;
+                        if (i2 > 0) {
+                          x2.iushrn(i2);
+                          while (i2-- > 0) {
+                            if (A22.isOdd() || B22.isOdd()) {
+                              A22.iadd(yp);
+                              B22.isub(xp);
+                            }
+                            A22.iushrn(1);
+                            B22.iushrn(1);
+                          }
+                        }
+                        for (var j2 = 0, jm = 1; (y2.words[0] & jm) === 0 && j2 < 26; ++j2, jm <<= 1) ;
+                        if (j2 > 0) {
+                          y2.iushrn(j2);
+                          while (j2-- > 0) {
+                            if (C22.isOdd() || D22.isOdd()) {
+                              C22.iadd(yp);
+                              D22.isub(xp);
+                            }
+                            C22.iushrn(1);
+                            D22.iushrn(1);
+                          }
+                        }
+                        if (x2.cmp(y2) >= 0) {
+                          x2.isub(y2);
+                          A22.isub(C22);
+                          B22.isub(D22);
+                        } else {
+                          y2.isub(x2);
+                          C22.isub(A22);
+                          D22.isub(B22);
+                        }
+                      }
+                      return {
+                        a: C22,
+                        b: D22,
+                        gcd: y2.iushln(g2)
+                      };
+                    };
+                    BN2.prototype._invmp = function _invmp(p2) {
+                      assert2(p2.negative === 0);
+                      assert2(!p2.isZero());
+                      var a2 = this;
+                      var b2 = p2.clone();
+                      if (a2.negative !== 0) {
+                        a2 = a2.umod(p2);
+                      } else {
+                        a2 = a2.clone();
+                      }
+                      var x1 = new BN2(1);
+                      var x2 = new BN2(0);
+                      var delta = b2.clone();
+                      while (a2.cmpn(1) > 0 && b2.cmpn(1) > 0) {
+                        for (var i2 = 0, im = 1; (a2.words[0] & im) === 0 && i2 < 26; ++i2, im <<= 1) ;
+                        if (i2 > 0) {
+                          a2.iushrn(i2);
+                          while (i2-- > 0) {
+                            if (x1.isOdd()) {
+                              x1.iadd(delta);
+                            }
+                            x1.iushrn(1);
+                          }
+                        }
+                        for (var j2 = 0, jm = 1; (b2.words[0] & jm) === 0 && j2 < 26; ++j2, jm <<= 1) ;
+                        if (j2 > 0) {
+                          b2.iushrn(j2);
+                          while (j2-- > 0) {
+                            if (x2.isOdd()) {
+                              x2.iadd(delta);
+                            }
+                            x2.iushrn(1);
+                          }
+                        }
+                        if (a2.cmp(b2) >= 0) {
+                          a2.isub(b2);
+                          x1.isub(x2);
+                        } else {
+                          b2.isub(a2);
+                          x2.isub(x1);
+                        }
+                      }
+                      var res;
+                      if (a2.cmpn(1) === 0) {
+                        res = x1;
+                      } else {
+                        res = x2;
+                      }
+                      if (res.cmpn(0) < 0) {
+                        res.iadd(p2);
+                      }
+                      return res;
+                    };
+                    BN2.prototype.gcd = function gcd(num) {
+                      if (this.isZero()) return num.abs();
+                      if (num.isZero()) return this.abs();
+                      var a2 = this.clone();
+                      var b2 = num.clone();
+                      a2.negative = 0;
+                      b2.negative = 0;
+                      for (var shift = 0; a2.isEven() && b2.isEven(); shift++) {
+                        a2.iushrn(1);
+                        b2.iushrn(1);
+                      }
+                      do {
+                        while (a2.isEven()) {
+                          a2.iushrn(1);
+                        }
+                        while (b2.isEven()) {
+                          b2.iushrn(1);
+                        }
+                        var r2 = a2.cmp(b2);
+                        if (r2 < 0) {
+                          var t4 = a2;
+                          a2 = b2;
+                          b2 = t4;
+                        } else if (r2 === 0 || b2.cmpn(1) === 0) {
+                          break;
+                        }
+                        a2.isub(b2);
+                      } while (true);
+                      return b2.iushln(shift);
+                    };
+                    BN2.prototype.invm = function invm(num) {
+                      return this.egcd(num).a.umod(num);
+                    };
+                    BN2.prototype.isEven = function isEven() {
+                      return (this.words[0] & 1) === 0;
+                    };
+                    BN2.prototype.isOdd = function isOdd() {
+                      return (this.words[0] & 1) === 1;
+                    };
+                    BN2.prototype.andln = function andln(num) {
+                      return this.words[0] & num;
+                    };
+                    BN2.prototype.bincn = function bincn(bit) {
+                      assert2(typeof bit === "number");
+                      var r2 = bit % 26;
+                      var s2 = (bit - r2) / 26;
+                      var q2 = 1 << r2;
+                      if (this.length <= s2) {
+                        this._expand(s2 + 1);
+                        this.words[s2] |= q2;
+                        return this;
+                      }
+                      var carry = q2;
+                      for (var i2 = s2; carry !== 0 && i2 < this.length; i2++) {
+                        var w2 = this.words[i2] | 0;
+                        w2 += carry;
+                        carry = w2 >>> 26;
+                        w2 &= 67108863;
+                        this.words[i2] = w2;
+                      }
+                      if (carry !== 0) {
+                        this.words[i2] = carry;
+                        this.length++;
+                      }
+                      return this;
+                    };
+                    BN2.prototype.isZero = function isZero() {
+                      return this.length === 1 && this.words[0] === 0;
+                    };
+                    BN2.prototype.cmpn = function cmpn(num) {
+                      var negative = num < 0;
+                      if (this.negative !== 0 && !negative) return -1;
+                      if (this.negative === 0 && negative) return 1;
+                      this.strip();
+                      var res;
+                      if (this.length > 1) {
+                        res = 1;
+                      } else {
+                        if (negative) {
+                          num = -num;
+                        }
+                        assert2(num <= 67108863, "Number is too big");
+                        var w2 = this.words[0] | 0;
+                        res = w2 === num ? 0 : w2 < num ? -1 : 1;
+                      }
+                      if (this.negative !== 0) return -res | 0;
+                      return res;
+                    };
+                    BN2.prototype.cmp = function cmp(num) {
+                      if (this.negative !== 0 && num.negative === 0) return -1;
+                      if (this.negative === 0 && num.negative !== 0) return 1;
+                      var res = this.ucmp(num);
+                      if (this.negative !== 0) return -res | 0;
+                      return res;
+                    };
+                    BN2.prototype.ucmp = function ucmp(num) {
+                      if (this.length > num.length) return 1;
+                      if (this.length < num.length) return -1;
+                      var res = 0;
+                      for (var i2 = this.length - 1; i2 >= 0; i2--) {
+                        var a2 = this.words[i2] | 0;
+                        var b2 = num.words[i2] | 0;
+                        if (a2 === b2) continue;
+                        if (a2 < b2) {
+                          res = -1;
+                        } else if (a2 > b2) {
+                          res = 1;
+                        }
+                        break;
+                      }
+                      return res;
+                    };
+                    BN2.prototype.gtn = function gtn(num) {
+                      return this.cmpn(num) === 1;
+                    };
+                    BN2.prototype.gt = function gt2(num) {
+                      return this.cmp(num) === 1;
+                    };
+                    BN2.prototype.gten = function gten(num) {
+                      return this.cmpn(num) >= 0;
+                    };
+                    BN2.prototype.gte = function gte(num) {
+                      return this.cmp(num) >= 0;
+                    };
+                    BN2.prototype.ltn = function ltn(num) {
+                      return this.cmpn(num) === -1;
+                    };
+                    BN2.prototype.lt = function lt2(num) {
+                      return this.cmp(num) === -1;
+                    };
+                    BN2.prototype.lten = function lten(num) {
+                      return this.cmpn(num) <= 0;
+                    };
+                    BN2.prototype.lte = function lte(num) {
+                      return this.cmp(num) <= 0;
+                    };
+                    BN2.prototype.eqn = function eqn(num) {
+                      return this.cmpn(num) === 0;
+                    };
+                    BN2.prototype.eq = function eq(num) {
+                      return this.cmp(num) === 0;
+                    };
+                    BN2.red = function red(num) {
+                      return new Red(num);
+                    };
+                    BN2.prototype.toRed = function toRed(ctx2) {
+                      assert2(!this.red, "Already a number in reduction context");
+                      assert2(this.negative === 0, "red works only with positives");
+                      return ctx2.convertTo(this)._forceRed(ctx2);
+                    };
+                    BN2.prototype.fromRed = function fromRed() {
+                      assert2(this.red, "fromRed works only with numbers in reduction context");
+                      return this.red.convertFrom(this);
+                    };
+                    BN2.prototype._forceRed = function _forceRed(ctx2) {
+                      this.red = ctx2;
+                      return this;
+                    };
+                    BN2.prototype.forceRed = function forceRed(ctx2) {
+                      assert2(!this.red, "Already a number in reduction context");
+                      return this._forceRed(ctx2);
+                    };
+                    BN2.prototype.redAdd = function redAdd(num) {
+                      assert2(this.red, "redAdd works only with red numbers");
+                      return this.red.add(this, num);
+                    };
+                    BN2.prototype.redIAdd = function redIAdd(num) {
+                      assert2(this.red, "redIAdd works only with red numbers");
+                      return this.red.iadd(this, num);
+                    };
+                    BN2.prototype.redSub = function redSub(num) {
+                      assert2(this.red, "redSub works only with red numbers");
+                      return this.red.sub(this, num);
+                    };
+                    BN2.prototype.redISub = function redISub(num) {
+                      assert2(this.red, "redISub works only with red numbers");
+                      return this.red.isub(this, num);
+                    };
+                    BN2.prototype.redShl = function redShl(num) {
+                      assert2(this.red, "redShl works only with red numbers");
+                      return this.red.shl(this, num);
+                    };
+                    BN2.prototype.redMul = function redMul(num) {
+                      assert2(this.red, "redMul works only with red numbers");
+                      this.red._verify2(this, num);
+                      return this.red.mul(this, num);
+                    };
+                    BN2.prototype.redIMul = function redIMul(num) {
+                      assert2(this.red, "redMul works only with red numbers");
+                      this.red._verify2(this, num);
+                      return this.red.imul(this, num);
+                    };
+                    BN2.prototype.redSqr = function redSqr() {
+                      assert2(this.red, "redSqr works only with red numbers");
+                      this.red._verify1(this);
+                      return this.red.sqr(this);
+                    };
+                    BN2.prototype.redISqr = function redISqr() {
+                      assert2(this.red, "redISqr works only with red numbers");
+                      this.red._verify1(this);
+                      return this.red.isqr(this);
+                    };
+                    BN2.prototype.redSqrt = function redSqrt() {
+                      assert2(this.red, "redSqrt works only with red numbers");
+                      this.red._verify1(this);
+                      return this.red.sqrt(this);
+                    };
+                    BN2.prototype.redInvm = function redInvm() {
+                      assert2(this.red, "redInvm works only with red numbers");
+                      this.red._verify1(this);
+                      return this.red.invm(this);
+                    };
+                    BN2.prototype.redNeg = function redNeg() {
+                      assert2(this.red, "redNeg works only with red numbers");
+                      this.red._verify1(this);
+                      return this.red.neg(this);
+                    };
+                    BN2.prototype.redPow = function redPow(num) {
+                      assert2(this.red && !num.red, "redPow(normalNum)");
+                      this.red._verify1(this);
+                      return this.red.pow(this, num);
+                    };
+                    var primes = {
+                      k256: null,
+                      p224: null,
+                      p192: null,
+                      p25519: null
+                    };
+                    function MPrime(name2, p2) {
+                      this.name = name2;
+                      this.p = new BN2(p2, 16);
+                      this.n = this.p.bitLength();
+                      this.k = new BN2(1).iushln(this.n).isub(this.p);
+                      this.tmp = this._tmp();
+                    }
+                    MPrime.prototype._tmp = function _tmp() {
+                      var tmp2 = new BN2(null);
+                      tmp2.words = new Array(Math.ceil(this.n / 13));
+                      return tmp2;
+                    };
+                    MPrime.prototype.ireduce = function ireduce(num) {
+                      var r2 = num;
+                      var rlen;
+                      do {
+                        this.split(r2, this.tmp);
+                        r2 = this.imulK(r2);
+                        r2 = r2.iadd(this.tmp);
+                        rlen = r2.bitLength();
+                      } while (rlen > this.n);
+                      var cmp = rlen < this.n ? -1 : r2.ucmp(this.p);
+                      if (cmp === 0) {
+                        r2.words[0] = 0;
+                        r2.length = 1;
+                      } else if (cmp > 0) {
+                        r2.isub(this.p);
+                      } else {
+                        if (r2.strip !== void 0) {
+                          r2.strip();
+                        } else {
+                          r2._strip();
+                        }
+                      }
+                      return r2;
+                    };
+                    MPrime.prototype.split = function split(input, out) {
+                      input.iushrn(this.n, 0, out);
+                    };
+                    MPrime.prototype.imulK = function imulK(num) {
+                      return num.imul(this.k);
+                    };
+                    function K256() {
+                      MPrime.call(
+                        this,
+                        "k256",
+                        "ffffffff ffffffff ffffffff ffffffff ffffffff ffffffff fffffffe fffffc2f"
+                      );
+                    }
+                    inherits(K256, MPrime);
+                    K256.prototype.split = function split(input, output) {
+                      var mask = 4194303;
+                      var outLen = Math.min(input.length, 9);
+                      for (var i2 = 0; i2 < outLen; i2++) {
+                        output.words[i2] = input.words[i2];
+                      }
+                      output.length = outLen;
+                      if (input.length <= 9) {
+                        input.words[0] = 0;
+                        input.length = 1;
+                        return;
+                      }
+                      var prev = input.words[9];
+                      output.words[output.length++] = prev & mask;
+                      for (i2 = 10; i2 < input.length; i2++) {
+                        var next = input.words[i2] | 0;
+                        input.words[i2 - 10] = (next & mask) << 4 | prev >>> 22;
+                        prev = next;
+                      }
+                      prev >>>= 22;
+                      input.words[i2 - 10] = prev;
+                      if (prev === 0 && input.length > 10) {
+                        input.length -= 10;
+                      } else {
+                        input.length -= 9;
+                      }
+                    };
+                    K256.prototype.imulK = function imulK(num) {
+                      num.words[num.length] = 0;
+                      num.words[num.length + 1] = 0;
+                      num.length += 2;
+                      var lo = 0;
+                      for (var i2 = 0; i2 < num.length; i2++) {
+                        var w2 = num.words[i2] | 0;
+                        lo += w2 * 977;
+                        num.words[i2] = lo & 67108863;
+                        lo = w2 * 64 + (lo / 67108864 | 0);
+                      }
+                      if (num.words[num.length - 1] === 0) {
+                        num.length--;
+                        if (num.words[num.length - 1] === 0) {
+                          num.length--;
+                        }
+                      }
+                      return num;
+                    };
+                    function P224() {
+                      MPrime.call(
+                        this,
+                        "p224",
+                        "ffffffff ffffffff ffffffff ffffffff 00000000 00000000 00000001"
+                      );
+                    }
+                    inherits(P224, MPrime);
+                    function P192() {
+                      MPrime.call(
+                        this,
+                        "p192",
+                        "ffffffff ffffffff ffffffff fffffffe ffffffff ffffffff"
+                      );
+                    }
+                    inherits(P192, MPrime);
+                    function P25519() {
+                      MPrime.call(
+                        this,
+                        "25519",
+                        "7fffffffffffffff ffffffffffffffff ffffffffffffffff ffffffffffffffed"
+                      );
+                    }
+                    inherits(P25519, MPrime);
+                    P25519.prototype.imulK = function imulK(num) {
+                      var carry = 0;
+                      for (var i2 = 0; i2 < num.length; i2++) {
+                        var hi2 = (num.words[i2] | 0) * 19 + carry;
+                        var lo = hi2 & 67108863;
+                        hi2 >>>= 26;
+                        num.words[i2] = lo;
+                        carry = hi2;
+                      }
+                      if (carry !== 0) {
+                        num.words[num.length++] = carry;
+                      }
+                      return num;
+                    };
+                    BN2._prime = function prime(name2) {
+                      if (primes[name2]) return primes[name2];
+                      var prime2;
+                      if (name2 === "k256") {
+                        prime2 = new K256();
+                      } else if (name2 === "p224") {
+                        prime2 = new P224();
+                      } else if (name2 === "p192") {
+                        prime2 = new P192();
+                      } else if (name2 === "p25519") {
+                        prime2 = new P25519();
+                      } else {
+                        throw new Error("Unknown prime " + name2);
+                      }
+                      primes[name2] = prime2;
+                      return prime2;
+                    };
+                    function Red(m2) {
+                      if (typeof m2 === "string") {
+                        var prime = BN2._prime(m2);
+                        this.m = prime.p;
+                        this.prime = prime;
+                      } else {
+                        assert2(m2.gtn(1), "modulus must be greater than 1");
+                        this.m = m2;
+                        this.prime = null;
+                      }
+                    }
+                    Red.prototype._verify1 = function _verify1(a2) {
+                      assert2(a2.negative === 0, "red works only with positives");
+                      assert2(a2.red, "red works only with red numbers");
+                    };
+                    Red.prototype._verify2 = function _verify2(a2, b2) {
+                      assert2((a2.negative | b2.negative) === 0, "red works only with positives");
+                      assert2(
+                        a2.red && a2.red === b2.red,
+                        "red works only with red numbers"
+                      );
+                    };
+                    Red.prototype.imod = function imod(a2) {
+                      if (this.prime) return this.prime.ireduce(a2)._forceRed(this);
+                      return a2.umod(this.m)._forceRed(this);
+                    };
+                    Red.prototype.neg = function neg(a2) {
+                      if (a2.isZero()) {
+                        return a2.clone();
+                      }
+                      return this.m.sub(a2)._forceRed(this);
+                    };
+                    Red.prototype.add = function add2(a2, b2) {
+                      this._verify2(a2, b2);
+                      var res = a2.add(b2);
+                      if (res.cmp(this.m) >= 0) {
+                        res.isub(this.m);
+                      }
+                      return res._forceRed(this);
+                    };
+                    Red.prototype.iadd = function iadd(a2, b2) {
+                      this._verify2(a2, b2);
+                      var res = a2.iadd(b2);
+                      if (res.cmp(this.m) >= 0) {
+                        res.isub(this.m);
+                      }
+                      return res;
+                    };
+                    Red.prototype.sub = function sub2(a2, b2) {
+                      this._verify2(a2, b2);
+                      var res = a2.sub(b2);
+                      if (res.cmpn(0) < 0) {
+                        res.iadd(this.m);
+                      }
+                      return res._forceRed(this);
+                    };
+                    Red.prototype.isub = function isub(a2, b2) {
+                      this._verify2(a2, b2);
+                      var res = a2.isub(b2);
+                      if (res.cmpn(0) < 0) {
+                        res.iadd(this.m);
+                      }
+                      return res;
+                    };
+                    Red.prototype.shl = function shl(a2, num) {
+                      this._verify1(a2);
+                      return this.imod(a2.ushln(num));
+                    };
+                    Red.prototype.imul = function imul(a2, b2) {
+                      this._verify2(a2, b2);
+                      return this.imod(a2.imul(b2));
+                    };
+                    Red.prototype.mul = function mul(a2, b2) {
+                      this._verify2(a2, b2);
+                      return this.imod(a2.mul(b2));
+                    };
+                    Red.prototype.isqr = function isqr(a2) {
+                      return this.imul(a2, a2.clone());
+                    };
+                    Red.prototype.sqr = function sqr(a2) {
+                      return this.mul(a2, a2);
+                    };
+                    Red.prototype.sqrt = function sqrt(a2) {
+                      if (a2.isZero()) return a2.clone();
+                      var mod3 = this.m.andln(3);
+                      assert2(mod3 % 2 === 1);
+                      if (mod3 === 3) {
+                        var pow = this.m.add(new BN2(1)).iushrn(2);
+                        return this.pow(a2, pow);
+                      }
+                      var q2 = this.m.subn(1);
+                      var s2 = 0;
+                      while (!q2.isZero() && q2.andln(1) === 0) {
+                        s2++;
+                        q2.iushrn(1);
+                      }
+                      assert2(!q2.isZero());
+                      var one2 = new BN2(1).toRed(this);
+                      var nOne = one2.redNeg();
+                      var lpow = this.m.subn(1).iushrn(1);
+                      var z2 = this.m.bitLength();
+                      z2 = new BN2(2 * z2 * z2).toRed(this);
+                      while (this.pow(z2, lpow).cmp(nOne) !== 0) {
+                        z2.redIAdd(nOne);
+                      }
+                      var c2 = this.pow(z2, q2);
+                      var r2 = this.pow(a2, q2.addn(1).iushrn(1));
+                      var t4 = this.pow(a2, q2);
+                      var m2 = s2;
+                      while (t4.cmp(one2) !== 0) {
+                        var tmp2 = t4;
+                        for (var i2 = 0; tmp2.cmp(one2) !== 0; i2++) {
+                          tmp2 = tmp2.redSqr();
+                        }
+                        assert2(i2 < m2);
+                        var b2 = this.pow(c2, new BN2(1).iushln(m2 - i2 - 1));
+                        r2 = r2.redMul(b2);
+                        c2 = b2.redSqr();
+                        t4 = t4.redMul(c2);
+                        m2 = i2;
+                      }
+                      return r2;
+                    };
+                    Red.prototype.invm = function invm(a2) {
+                      var inv = a2._invmp(this.m);
+                      if (inv.negative !== 0) {
+                        inv.negative = 0;
+                        return this.imod(inv).redNeg();
+                      } else {
+                        return this.imod(inv);
+                      }
+                    };
+                    Red.prototype.pow = function pow(a2, num) {
+                      if (num.isZero()) return new BN2(1).toRed(this);
+                      if (num.cmpn(1) === 0) return a2.clone();
+                      var windowSize = 4;
+                      var wnd = new Array(1 << windowSize);
+                      wnd[0] = new BN2(1).toRed(this);
+                      wnd[1] = a2;
+                      for (var i2 = 2; i2 < wnd.length; i2++) {
+                        wnd[i2] = this.mul(wnd[i2 - 1], a2);
+                      }
+                      var res = wnd[0];
+                      var current = 0;
+                      var currentLen = 0;
+                      var start = num.bitLength() % 26;
+                      if (start === 0) {
+                        start = 26;
+                      }
+                      for (i2 = num.length - 1; i2 >= 0; i2--) {
+                        var word = num.words[i2];
+                        for (var j2 = start - 1; j2 >= 0; j2--) {
+                          var bit = word >> j2 & 1;
+                          if (res !== wnd[0]) {
+                            res = this.sqr(res);
+                          }
+                          if (bit === 0 && current === 0) {
+                            currentLen = 0;
+                            continue;
+                          }
+                          current <<= 1;
+                          current |= bit;
+                          currentLen++;
+                          if (currentLen !== windowSize && (i2 !== 0 || j2 !== 0)) continue;
+                          res = this.mul(res, wnd[current]);
+                          currentLen = 0;
+                          current = 0;
+                        }
+                        start = 26;
+                      }
+                      return res;
+                    };
+                    Red.prototype.convertTo = function convertTo(num) {
+                      var r2 = num.umod(this.m);
+                      return r2 === num ? r2.clone() : r2;
+                    };
+                    Red.prototype.convertFrom = function convertFrom(num) {
+                      var res = num.clone();
+                      res.red = null;
+                      return res;
+                    };
+                    BN2.mont = function mont(num) {
+                      return new Mont(num);
+                    };
+                    function Mont(m2) {
+                      Red.call(this, m2);
+                      this.shift = this.m.bitLength();
+                      if (this.shift % 26 !== 0) {
+                        this.shift += 26 - this.shift % 26;
+                      }
+                      this.r = new BN2(1).iushln(this.shift);
+                      this.r2 = this.imod(this.r.sqr());
+                      this.rinv = this.r._invmp(this.m);
+                      this.minv = this.rinv.mul(this.r).isubn(1).div(this.m);
+                      this.minv = this.minv.umod(this.r);
+                      this.minv = this.r.sub(this.minv);
+                    }
+                    inherits(Mont, Red);
+                    Mont.prototype.convertTo = function convertTo(num) {
+                      return this.imod(num.ushln(this.shift));
+                    };
+                    Mont.prototype.convertFrom = function convertFrom(num) {
+                      var r2 = this.imod(num.mul(this.rinv));
+                      r2.red = null;
+                      return r2;
+                    };
+                    Mont.prototype.imul = function imul(a2, b2) {
+                      if (a2.isZero() || b2.isZero()) {
+                        a2.words[0] = 0;
+                        a2.length = 1;
+                        return a2;
+                      }
+                      var t4 = a2.imul(b2);
+                      var c2 = t4.maskn(this.shift).mul(this.minv).imaskn(this.shift).mul(this.m);
+                      var u2 = t4.isub(c2).iushrn(this.shift);
+                      var res = u2;
+                      if (u2.cmp(this.m) >= 0) {
+                        res = u2.isub(this.m);
+                      } else if (u2.cmpn(0) < 0) {
+                        res = u2.iadd(this.m);
+                      }
+                      return res._forceRed(this);
+                    };
+                    Mont.prototype.mul = function mul(a2, b2) {
+                      if (a2.isZero() || b2.isZero()) return new BN2(0)._forceRed(this);
+                      var t4 = a2.mul(b2);
+                      var c2 = t4.maskn(this.shift).mul(this.minv).imaskn(this.shift).mul(this.m);
+                      var u2 = t4.isub(c2).iushrn(this.shift);
+                      var res = u2;
+                      if (u2.cmp(this.m) >= 0) {
+                        res = u2.isub(this.m);
+                      } else if (u2.cmpn(0) < 0) {
+                        res = u2.iadd(this.m);
+                      }
+                      return res._forceRed(this);
+                    };
+                    Mont.prototype.invm = function invm(a2) {
+                      var res = this.imod(a2._invmp(this.m).mul(this.r2));
+                      return res._forceRed(this);
+                    };
+                  })(module22, this);
+                }
+              ),
+              /***/
+              6860: (
+                /***/
+                function(module22) {
+                  module22.exports = subtract2;
+                  function subtract2(out, a2, b2) {
+                    out[0] = a2[0] - b2[0];
+                    out[1] = a2[1] - b2[1];
+                    out[2] = a2[2] - b2[2];
+                    out[3] = a2[3] - b2[3];
+                    return out;
+                  }
+                }
+              ),
+              /***/
+              6864: (
+                /***/
+                function(module22) {
+                  module22.exports = create2;
+                  function create2() {
+                    var out = new Float32Array(16);
+                    out[0] = 1;
+                    out[1] = 0;
+                    out[2] = 0;
+                    out[3] = 0;
+                    out[4] = 0;
+                    out[5] = 1;
+                    out[6] = 0;
+                    out[7] = 0;
+                    out[8] = 0;
+                    out[9] = 0;
+                    out[10] = 1;
+                    out[11] = 0;
+                    out[12] = 0;
+                    out[13] = 0;
+                    out[14] = 0;
+                    out[15] = 1;
+                    return out;
+                  }
+                }
+              ),
+              /***/
+              6867: (
+                /***/
+                function(module22, __unused_webpack_exports, __webpack_require__2) {
+                  module22.exports = boxIntersectWrapper;
+                  var pool = __webpack_require__2(1888);
+                  var sweep = __webpack_require__2(855);
+                  var boxIntersectIter = __webpack_require__2(7150);
+                  function boxEmpty(d2, box) {
+                    for (var j2 = 0; j2 < d2; ++j2) {
+                      if (!(box[j2] <= box[j2 + d2])) {
+                        return true;
+                      }
+                    }
+                    return false;
+                  }
+                  function convertBoxes(boxes, d2, data, ids) {
+                    var ptr = 0;
+                    var count2 = 0;
+                    for (var i2 = 0, n2 = boxes.length; i2 < n2; ++i2) {
+                      var b2 = boxes[i2];
+                      if (boxEmpty(d2, b2)) {
+                        continue;
+                      }
+                      for (var j2 = 0; j2 < 2 * d2; ++j2) {
+                        data[ptr++] = b2[j2];
+                      }
+                      ids[count2++] = i2;
+                    }
+                    return count2;
+                  }
+                  function boxIntersect(red, blue, visit, full) {
+                    var n2 = red.length;
+                    var m2 = blue.length;
+                    if (n2 <= 0 || m2 <= 0) {
+                      return;
+                    }
+                    var d2 = red[0].length >>> 1;
+                    if (d2 <= 0) {
+                      return;
+                    }
+                    var retval;
+                    var redList = pool.mallocDouble(2 * d2 * n2);
+                    var redIds = pool.mallocInt32(n2);
+                    n2 = convertBoxes(red, d2, redList, redIds);
+                    if (n2 > 0) {
+                      if (d2 === 1 && full) {
+                        sweep.init(n2);
+                        retval = sweep.sweepComplete(
+                          d2,
+                          visit,
+                          0,
+                          n2,
+                          redList,
+                          redIds,
+                          0,
+                          n2,
+                          redList,
+                          redIds
+                        );
+                      } else {
+                        var blueList = pool.mallocDouble(2 * d2 * m2);
+                        var blueIds = pool.mallocInt32(m2);
+                        m2 = convertBoxes(blue, d2, blueList, blueIds);
+                        if (m2 > 0) {
+                          sweep.init(n2 + m2);
+                          if (d2 === 1) {
+                            retval = sweep.sweepBipartite(
+                              d2,
+                              visit,
+                              0,
+                              n2,
+                              redList,
+                              redIds,
+                              0,
+                              m2,
+                              blueList,
+                              blueIds
+                            );
+                          } else {
+                            retval = boxIntersectIter(
+                              d2,
+                              visit,
+                              full,
+                              n2,
+                              redList,
+                              redIds,
+                              m2,
+                              blueList,
+                              blueIds
+                            );
+                          }
+                          pool.free(blueList);
+                          pool.free(blueIds);
+                        }
+                      }
+                      pool.free(redList);
+                      pool.free(redIds);
+                    }
+                    return retval;
+                  }
+                  var RESULT;
+                  function appendItem(i2, j2) {
+                    RESULT.push([i2, j2]);
+                  }
+                  function intersectFullArray(x2) {
+                    RESULT = [];
+                    boxIntersect(x2, x2, appendItem, true);
+                    return RESULT;
+                  }
+                  function intersectBipartiteArray(x2, y2) {
+                    RESULT = [];
+                    boxIntersect(x2, y2, appendItem, false);
+                    return RESULT;
+                  }
+                  function boxIntersectWrapper(arg0, arg1, arg2) {
+                    switch (arguments.length) {
+                      case 1:
+                        return intersectFullArray(arg0);
+                      case 2:
+                        if (typeof arg1 === "function") {
+                          return boxIntersect(arg0, arg0, arg1, true);
+                        } else {
+                          return intersectBipartiteArray(arg0, arg1);
+                        }
+                      case 3:
+                        return boxIntersect(arg0, arg1, arg2, false);
+                      default:
+                        throw new Error("box-intersect: Invalid arguments");
+                    }
+                  }
+                }
+              ),
+              /***/
+              6894: (
+                /***/
+                function(module22) {
+                  module22.exports = rotateX2;
+                  function rotateX2(out, a2, b2, c2) {
+                    var by = b2[1];
+                    var bz = b2[2];
+                    var py = a2[1] - by;
+                    var pz = a2[2] - bz;
+                    var sc2 = Math.sin(c2);
+                    var cc2 = Math.cos(c2);
+                    out[0] = a2[0];
+                    out[1] = by + py * cc2 - pz * sc2;
+                    out[2] = bz + py * sc2 + pz * cc2;
+                    return out;
+                  }
+                }
+              ),
+              /***/
+              7004: (
+                /***/
+                function(module22) {
+                  module22.exports = compressExpansion;
+                  function compressExpansion(e2) {
+                    var m2 = e2.length;
+                    var Q2 = e2[e2.length - 1];
+                    var bottom = m2;
+                    for (var i2 = m2 - 2; i2 >= 0; --i2) {
+                      var a2 = Q2;
+                      var b2 = e2[i2];
+                      Q2 = a2 + b2;
+                      var bv = Q2 - a2;
+                      var q2 = b2 - bv;
+                      if (q2) {
+                        e2[--bottom] = Q2;
+                        Q2 = q2;
+                      }
+                    }
+                    var top = 0;
+                    for (var i2 = bottom; i2 < m2; ++i2) {
+                      var a2 = e2[i2];
+                      var b2 = Q2;
+                      Q2 = a2 + b2;
+                      var bv = Q2 - a2;
+                      var q2 = b2 - bv;
+                      if (q2) {
+                        e2[top++] = q2;
+                      }
+                    }
+                    e2[top++] = Q2;
+                    e2.length = top;
+                    return e2;
+                  }
+                }
+              ),
+              /***/
+              7056: (
+                /***/
+                function(module22) {
+                  module22.exports = distance2;
+                  function distance2(a2, b2) {
+                    var x2 = b2[0] - a2[0], y2 = b2[1] - a2[1], z2 = b2[2] - a2[2];
+                    return Math.sqrt(x2 * x2 + y2 * y2 + z2 * z2);
+                  }
+                }
+              ),
+              /***/
+              7089: (
+                /***/
+                function(module22) {
+                  module22.exports = rotateZ2;
+                  function rotateZ2(out, a2, rad) {
+                    var s2 = Math.sin(rad), c2 = Math.cos(rad), a00 = a2[0], a01 = a2[1], a02 = a2[2], a03 = a2[3], a10 = a2[4], a11 = a2[5], a12 = a2[6], a13 = a2[7];
+                    if (a2 !== out) {
+                      out[8] = a2[8];
+                      out[9] = a2[9];
+                      out[10] = a2[10];
+                      out[11] = a2[11];
+                      out[12] = a2[12];
+                      out[13] = a2[13];
+                      out[14] = a2[14];
+                      out[15] = a2[15];
+                    }
+                    out[0] = a00 * c2 + a10 * s2;
+                    out[1] = a01 * c2 + a11 * s2;
+                    out[2] = a02 * c2 + a12 * s2;
+                    out[3] = a03 * c2 + a13 * s2;
+                    out[4] = a10 * c2 - a00 * s2;
+                    out[5] = a11 * c2 - a01 * s2;
+                    out[6] = a12 * c2 - a02 * s2;
+                    out[7] = a13 * c2 - a03 * s2;
+                    return out;
+                  }
+                }
+              ),
+              /***/
+              7150: (
+                /***/
+                function(module22, __unused_webpack_exports, __webpack_require__2) {
+                  module22.exports = boxIntersectIter;
+                  var pool = __webpack_require__2(1888);
+                  var bits = __webpack_require__2(8828);
+                  var bruteForce = __webpack_require__2(2455);
+                  var bruteForcePartial = bruteForce.partial;
+                  var bruteForceFull = bruteForce.full;
+                  var sweep = __webpack_require__2(855);
+                  var findMedian = __webpack_require__2(3545);
+                  var genPartition = __webpack_require__2(8105);
+                  var BRUTE_FORCE_CUTOFF = 128;
+                  var SCAN_CUTOFF = 1 << 22;
+                  var SCAN_COMPLETE_CUTOFF = 1 << 22;
+                  var partitionInteriorContainsInterval = genPartition(
+                    "!(lo>=p0)&&!(p1>=hi)"
+                  );
+                  var partitionStartEqual = genPartition(
+                    "lo===p0"
+                  );
+                  var partitionStartLessThan = genPartition(
+                    "lo<p0"
+                  );
+                  var partitionEndLessThanEqual = genPartition(
+                    "hi<=p0"
+                  );
+                  var partitionContainsPoint = genPartition(
+                    "lo<=p0&&p0<=hi"
+                  );
+                  var partitionContainsPointProper = genPartition(
+                    "lo<p0&&p0<=hi"
+                  );
+                  var IFRAME_SIZE = 6;
+                  var DFRAME_SIZE = 2;
+                  var INIT_CAPACITY = 1024;
+                  var BOX_ISTACK = pool.mallocInt32(INIT_CAPACITY);
+                  var BOX_DSTACK = pool.mallocDouble(INIT_CAPACITY);
+                  function iterInit(d2, count2) {
+                    var levels = 8 * bits.log2(count2 + 1) * (d2 + 1) | 0;
+                    var maxInts = bits.nextPow2(IFRAME_SIZE * levels);
+                    if (BOX_ISTACK.length < maxInts) {
+                      pool.free(BOX_ISTACK);
+                      BOX_ISTACK = pool.mallocInt32(maxInts);
+                    }
+                    var maxDoubles = bits.nextPow2(DFRAME_SIZE * levels);
+                    if (BOX_DSTACK.length < maxDoubles) {
+                      pool.free(BOX_DSTACK);
+                      BOX_DSTACK = pool.mallocDouble(maxDoubles);
+                    }
+                  }
+                  function iterPush(ptr, axis, redStart, redEnd, blueStart, blueEnd, state, lo, hi2) {
+                    var iptr = IFRAME_SIZE * ptr;
+                    BOX_ISTACK[iptr] = axis;
+                    BOX_ISTACK[iptr + 1] = redStart;
+                    BOX_ISTACK[iptr + 2] = redEnd;
+                    BOX_ISTACK[iptr + 3] = blueStart;
+                    BOX_ISTACK[iptr + 4] = blueEnd;
+                    BOX_ISTACK[iptr + 5] = state;
+                    var dptr = DFRAME_SIZE * ptr;
+                    BOX_DSTACK[dptr] = lo;
+                    BOX_DSTACK[dptr + 1] = hi2;
+                  }
+                  function onePointPartial(d2, axis, visit, flip, redStart, redEnd, red, redIndex, blueOffset, blue, blueId) {
+                    var elemSize = 2 * d2;
+                    var bluePtr = blueOffset * elemSize;
+                    var blueX = blue[bluePtr + axis];
+                    red_loop:
+                      for (var i2 = redStart, redPtr = redStart * elemSize; i2 < redEnd; ++i2, redPtr += elemSize) {
+                        var r0 = red[redPtr + axis];
+                        var r1 = red[redPtr + axis + d2];
+                        if (blueX < r0 || r1 < blueX) {
+                          continue;
+                        }
+                        if (flip && blueX === r0) {
+                          continue;
+                        }
+                        var redId = redIndex[i2];
+                        for (var j2 = axis + 1; j2 < d2; ++j2) {
+                          var r0 = red[redPtr + j2];
+                          var r1 = red[redPtr + j2 + d2];
+                          var b0 = blue[bluePtr + j2];
+                          var b1 = blue[bluePtr + j2 + d2];
+                          if (r1 < b0 || b1 < r0) {
+                            continue red_loop;
+                          }
+                        }
+                        var retval;
+                        if (flip) {
+                          retval = visit(blueId, redId);
+                        } else {
+                          retval = visit(redId, blueId);
+                        }
+                        if (retval !== void 0) {
+                          return retval;
+                        }
+                      }
+                  }
+                  function onePointFull(d2, axis, visit, redStart, redEnd, red, redIndex, blueOffset, blue, blueId) {
+                    var elemSize = 2 * d2;
+                    var bluePtr = blueOffset * elemSize;
+                    var blueX = blue[bluePtr + axis];
+                    red_loop:
+                      for (var i2 = redStart, redPtr = redStart * elemSize; i2 < redEnd; ++i2, redPtr += elemSize) {
+                        var redId = redIndex[i2];
+                        if (redId === blueId) {
+                          continue;
+                        }
+                        var r0 = red[redPtr + axis];
+                        var r1 = red[redPtr + axis + d2];
+                        if (blueX < r0 || r1 < blueX) {
+                          continue;
+                        }
+                        for (var j2 = axis + 1; j2 < d2; ++j2) {
+                          var r0 = red[redPtr + j2];
+                          var r1 = red[redPtr + j2 + d2];
+                          var b0 = blue[bluePtr + j2];
+                          var b1 = blue[bluePtr + j2 + d2];
+                          if (r1 < b0 || b1 < r0) {
+                            continue red_loop;
+                          }
+                        }
+                        var retval = visit(redId, blueId);
+                        if (retval !== void 0) {
+                          return retval;
+                        }
+                      }
+                  }
+                  function boxIntersectIter(d2, visit, initFull, xSize, xBoxes, xIndex, ySize, yBoxes, yIndex) {
+                    iterInit(d2, xSize + ySize);
+                    var top = 0;
+                    var elemSize = 2 * d2;
+                    var retval;
+                    iterPush(
+                      top++,
+                      0,
+                      0,
+                      xSize,
+                      0,
+                      ySize,
+                      initFull ? 16 : 0,
+                      -Infinity,
+                      Infinity
+                    );
+                    if (!initFull) {
+                      iterPush(
+                        top++,
+                        0,
+                        0,
+                        ySize,
+                        0,
+                        xSize,
+                        1,
+                        -Infinity,
+                        Infinity
+                      );
+                    }
+                    while (top > 0) {
+                      top -= 1;
+                      var iptr = top * IFRAME_SIZE;
+                      var axis = BOX_ISTACK[iptr];
+                      var redStart = BOX_ISTACK[iptr + 1];
+                      var redEnd = BOX_ISTACK[iptr + 2];
+                      var blueStart = BOX_ISTACK[iptr + 3];
+                      var blueEnd = BOX_ISTACK[iptr + 4];
+                      var state = BOX_ISTACK[iptr + 5];
+                      var dptr = top * DFRAME_SIZE;
+                      var lo = BOX_DSTACK[dptr];
+                      var hi2 = BOX_DSTACK[dptr + 1];
+                      var flip = state & 1;
+                      var full = !!(state & 16);
+                      var red = xBoxes;
+                      var redIndex = xIndex;
+                      var blue = yBoxes;
+                      var blueIndex = yIndex;
+                      if (flip) {
+                        red = yBoxes;
+                        redIndex = yIndex;
+                        blue = xBoxes;
+                        blueIndex = xIndex;
+                      }
+                      if (state & 2) {
+                        redEnd = partitionStartLessThan(
+                          d2,
+                          axis,
+                          redStart,
+                          redEnd,
+                          red,
+                          redIndex,
+                          hi2
+                        );
+                        if (redStart >= redEnd) {
+                          continue;
+                        }
+                      }
+                      if (state & 4) {
+                        redStart = partitionEndLessThanEqual(
+                          d2,
+                          axis,
+                          redStart,
+                          redEnd,
+                          red,
+                          redIndex,
+                          lo
+                        );
+                        if (redStart >= redEnd) {
+                          continue;
+                        }
+                      }
+                      var redCount = redEnd - redStart;
+                      var blueCount = blueEnd - blueStart;
+                      if (full) {
+                        if (d2 * redCount * (redCount + blueCount) < SCAN_COMPLETE_CUTOFF) {
+                          retval = sweep.scanComplete(
+                            d2,
+                            axis,
+                            visit,
+                            redStart,
+                            redEnd,
+                            red,
+                            redIndex,
+                            blueStart,
+                            blueEnd,
+                            blue,
+                            blueIndex
+                          );
+                          if (retval !== void 0) {
+                            return retval;
+                          }
+                          continue;
+                        }
+                      } else {
+                        if (d2 * Math.min(redCount, blueCount) < BRUTE_FORCE_CUTOFF) {
+                          retval = bruteForcePartial(
+                            d2,
+                            axis,
+                            visit,
+                            flip,
+                            redStart,
+                            redEnd,
+                            red,
+                            redIndex,
+                            blueStart,
+                            blueEnd,
+                            blue,
+                            blueIndex
+                          );
+                          if (retval !== void 0) {
+                            return retval;
+                          }
+                          continue;
+                        } else if (d2 * redCount * blueCount < SCAN_CUTOFF) {
+                          retval = sweep.scanBipartite(
+                            d2,
+                            axis,
+                            visit,
+                            flip,
+                            redStart,
+                            redEnd,
+                            red,
+                            redIndex,
+                            blueStart,
+                            blueEnd,
+                            blue,
+                            blueIndex
+                          );
+                          if (retval !== void 0) {
+                            return retval;
+                          }
+                          continue;
+                        }
+                      }
+                      var red0 = partitionInteriorContainsInterval(
+                        d2,
+                        axis,
+                        redStart,
+                        redEnd,
+                        red,
+                        redIndex,
+                        lo,
+                        hi2
+                      );
+                      if (redStart < red0) {
+                        if (d2 * (red0 - redStart) < BRUTE_FORCE_CUTOFF) {
+                          retval = bruteForceFull(
+                            d2,
+                            axis + 1,
+                            visit,
+                            redStart,
+                            red0,
+                            red,
+                            redIndex,
+                            blueStart,
+                            blueEnd,
+                            blue,
+                            blueIndex
+                          );
+                          if (retval !== void 0) {
+                            return retval;
+                          }
+                        } else if (axis === d2 - 2) {
+                          if (flip) {
+                            retval = sweep.sweepBipartite(
+                              d2,
+                              visit,
+                              blueStart,
+                              blueEnd,
+                              blue,
+                              blueIndex,
+                              redStart,
+                              red0,
+                              red,
+                              redIndex
+                            );
+                          } else {
+                            retval = sweep.sweepBipartite(
+                              d2,
+                              visit,
+                              redStart,
+                              red0,
+                              red,
+                              redIndex,
+                              blueStart,
+                              blueEnd,
+                              blue,
+                              blueIndex
+                            );
+                          }
+                          if (retval !== void 0) {
+                            return retval;
+                          }
+                        } else {
+                          iterPush(
+                            top++,
+                            axis + 1,
+                            redStart,
+                            red0,
+                            blueStart,
+                            blueEnd,
+                            flip,
+                            -Infinity,
+                            Infinity
+                          );
+                          iterPush(
+                            top++,
+                            axis + 1,
+                            blueStart,
+                            blueEnd,
+                            redStart,
+                            red0,
+                            flip ^ 1,
+                            -Infinity,
+                            Infinity
+                          );
+                        }
+                      }
+                      if (red0 < redEnd) {
+                        var blue0 = findMedian(
+                          d2,
+                          axis,
+                          blueStart,
+                          blueEnd,
+                          blue,
+                          blueIndex
+                        );
+                        var mid = blue[elemSize * blue0 + axis];
+                        var blue1 = partitionStartEqual(
+                          d2,
+                          axis,
+                          blue0,
+                          blueEnd,
+                          blue,
+                          blueIndex,
+                          mid
+                        );
+                        if (blue1 < blueEnd) {
+                          iterPush(
+                            top++,
+                            axis,
+                            red0,
+                            redEnd,
+                            blue1,
+                            blueEnd,
+                            (flip | 4) + (full ? 16 : 0),
+                            mid,
+                            hi2
+                          );
+                        }
+                        if (blueStart < blue0) {
+                          iterPush(
+                            top++,
+                            axis,
+                            red0,
+                            redEnd,
+                            blueStart,
+                            blue0,
+                            (flip | 2) + (full ? 16 : 0),
+                            lo,
+                            mid
+                          );
+                        }
+                        if (blue0 + 1 === blue1) {
+                          if (full) {
+                            retval = onePointFull(
+                              d2,
+                              axis,
+                              visit,
+                              red0,
+                              redEnd,
+                              red,
+                              redIndex,
+                              blue0,
+                              blue,
+                              blueIndex[blue0]
+                            );
+                          } else {
+                            retval = onePointPartial(
+                              d2,
+                              axis,
+                              visit,
+                              flip,
+                              red0,
+                              redEnd,
+                              red,
+                              redIndex,
+                              blue0,
+                              blue,
+                              blueIndex[blue0]
+                            );
+                          }
+                          if (retval !== void 0) {
+                            return retval;
+                          }
+                        } else if (blue0 < blue1) {
+                          var red1;
+                          if (full) {
+                            red1 = partitionContainsPoint(
+                              d2,
+                              axis,
+                              red0,
+                              redEnd,
+                              red,
+                              redIndex,
+                              mid
+                            );
+                            if (red0 < red1) {
+                              var redX = partitionStartEqual(
+                                d2,
+                                axis,
+                                red0,
+                                red1,
+                                red,
+                                redIndex,
+                                mid
+                              );
+                              if (axis === d2 - 2) {
+                                if (red0 < redX) {
+                                  retval = sweep.sweepComplete(
+                                    d2,
+                                    visit,
+                                    red0,
+                                    redX,
+                                    red,
+                                    redIndex,
+                                    blue0,
+                                    blue1,
+                                    blue,
+                                    blueIndex
+                                  );
+                                  if (retval !== void 0) {
+                                    return retval;
+                                  }
+                                }
+                                if (redX < red1) {
+                                  retval = sweep.sweepBipartite(
+                                    d2,
+                                    visit,
+                                    redX,
+                                    red1,
+                                    red,
+                                    redIndex,
+                                    blue0,
+                                    blue1,
+                                    blue,
+                                    blueIndex
+                                  );
+                                  if (retval !== void 0) {
+                                    return retval;
+                                  }
+                                }
+                              } else {
+                                if (red0 < redX) {
+                                  iterPush(
+                                    top++,
+                                    axis + 1,
+                                    red0,
+                                    redX,
+                                    blue0,
+                                    blue1,
+                                    16,
+                                    -Infinity,
+                                    Infinity
+                                  );
+                                }
+                                if (redX < red1) {
+                                  iterPush(
+                                    top++,
+                                    axis + 1,
+                                    redX,
+                                    red1,
+                                    blue0,
+                                    blue1,
+                                    0,
+                                    -Infinity,
+                                    Infinity
+                                  );
+                                  iterPush(
+                                    top++,
+                                    axis + 1,
+                                    blue0,
+                                    blue1,
+                                    redX,
+                                    red1,
+                                    1,
+                                    -Infinity,
+                                    Infinity
+                                  );
+                                }
+                              }
+                            }
+                          } else {
+                            if (flip) {
+                              red1 = partitionContainsPointProper(
+                                d2,
+                                axis,
+                                red0,
+                                redEnd,
+                                red,
+                                redIndex,
+                                mid
+                              );
+                            } else {
+                              red1 = partitionContainsPoint(
+                                d2,
+                                axis,
+                                red0,
+                                redEnd,
+                                red,
+                                redIndex,
+                                mid
+                              );
+                            }
+                            if (red0 < red1) {
+                              if (axis === d2 - 2) {
+                                if (flip) {
+                                  retval = sweep.sweepBipartite(
+                                    d2,
+                                    visit,
+                                    blue0,
+                                    blue1,
+                                    blue,
+                                    blueIndex,
+                                    red0,
+                                    red1,
+                                    red,
+                                    redIndex
+                                  );
+                                } else {
+                                  retval = sweep.sweepBipartite(
+                                    d2,
+                                    visit,
+                                    red0,
+                                    red1,
+                                    red,
+                                    redIndex,
+                                    blue0,
+                                    blue1,
+                                    blue,
+                                    blueIndex
+                                  );
+                                }
+                              } else {
+                                iterPush(
+                                  top++,
+                                  axis + 1,
+                                  red0,
+                                  red1,
+                                  blue0,
+                                  blue1,
+                                  flip,
+                                  -Infinity,
+                                  Infinity
+                                );
+                                iterPush(
+                                  top++,
+                                  axis + 1,
+                                  blue0,
+                                  blue1,
+                                  red0,
+                                  red1,
+                                  flip ^ 1,
+                                  -Infinity,
+                                  Infinity
+                                );
+                              }
+                            }
+                          }
+                        }
+                      }
+                    }
+                  }
+                }
+              ),
+              /***/
+              7163: (
+                /***/
+                function(module22) {
+                  module22.exports = function(obj) {
+                    return obj != null && (isBuffer2(obj) || isSlowBuffer(obj) || !!obj._isBuffer);
+                  };
+                  function isBuffer2(obj) {
+                    return !!obj.constructor && typeof obj.constructor.isBuffer === "function" && obj.constructor.isBuffer(obj);
+                  }
+                  function isSlowBuffer(obj) {
+                    return typeof obj.readFloatLE === "function" && typeof obj.slice === "function" && isBuffer2(obj.slice(0, 0));
+                  }
+                }
+              ),
+              /***/
+              7169: (
+                /***/
+                function(module22, __unused_webpack_exports, __webpack_require__2) {
+                  var weakMap = typeof WeakMap === "undefined" ? __webpack_require__2(1538) : WeakMap;
+                  var createBuffer = __webpack_require__2(2762);
+                  var createVAO = __webpack_require__2(8116);
+                  var TriangleCache = new weakMap();
+                  function createABigTriangle(gl2) {
+                    var triangleVAO = TriangleCache.get(gl2);
+                    var handle = triangleVAO && (triangleVAO._triangleBuffer.handle || triangleVAO._triangleBuffer.buffer);
+                    if (!handle || !gl2.isBuffer(handle)) {
+                      var buf = createBuffer(gl2, new Float32Array([-1, -1, -1, 4, 4, -1]));
+                      triangleVAO = createVAO(gl2, [
+                        {
+                          buffer: buf,
+                          type: gl2.FLOAT,
+                          size: 2
+                        }
+                      ]);
+                      triangleVAO._triangleBuffer = buf;
+                      TriangleCache.set(gl2, triangleVAO);
+                    }
+                    triangleVAO.bind();
+                    gl2.drawArrays(gl2.TRIANGLES, 0, 3);
+                    triangleVAO.unbind();
+                  }
+                  module22.exports = createABigTriangle;
+                }
+              ),
+              /***/
+              7182: (
+                /***/
+                function(module22, __unused_webpack_exports, __webpack_require__2) {
+                  var mat4 = {
+                    identity: __webpack_require__2(7894),
+                    translate: __webpack_require__2(7656),
+                    multiply: __webpack_require__2(6760),
+                    create: __webpack_require__2(6864),
+                    scale: __webpack_require__2(2504),
+                    fromRotationTranslation: __webpack_require__2(6743)
+                  };
+                  mat4.create();
+                  var temp = mat4.create();
+                  module22.exports = function recomposeMat4(matrix, translation, scale2, skew, perspective2, quaternion) {
+                    mat4.identity(matrix);
+                    mat4.fromRotationTranslation(matrix, quaternion, translation);
+                    matrix[3] = perspective2[0];
+                    matrix[7] = perspective2[1];
+                    matrix[11] = perspective2[2];
+                    matrix[15] = perspective2[3];
+                    mat4.identity(temp);
+                    if (skew[2] !== 0) {
+                      temp[9] = skew[2];
+                      mat4.multiply(matrix, matrix, temp);
+                    }
+                    if (skew[1] !== 0) {
+                      temp[9] = 0;
+                      temp[8] = skew[1];
+                      mat4.multiply(matrix, matrix, temp);
+                    }
+                    if (skew[0] !== 0) {
+                      temp[8] = 0;
+                      temp[4] = skew[0];
+                      mat4.multiply(matrix, matrix, temp);
+                    }
+                    mat4.scale(matrix, matrix, scale2);
+                    return matrix;
+                  };
+                }
+              ),
+              /***/
+              7201: (
+                /***/
+                function(module22, __unused_webpack_exports, __webpack_require__2) {
+                  var DEFAULT_VERTEX_NORMALS_EPSILON = 1e-6;
+                  var DEFAULT_FACE_NORMALS_EPSILON = 1e-6;
+                  var createShader = __webpack_require__2(9405);
+                  var createBuffer = __webpack_require__2(2762);
+                  var createVAO = __webpack_require__2(8116);
+                  var createTexture2 = __webpack_require__2(7766);
+                  var normals = __webpack_require__2(8406);
+                  var multiply2 = __webpack_require__2(6760);
+                  var invert2 = __webpack_require__2(7608);
+                  var ndarray = __webpack_require__2(9618);
+                  var colormap = __webpack_require__2(6729);
+                  var getContour = __webpack_require__2(7765);
+                  var pool = __webpack_require__2(1888);
+                  var shaders = __webpack_require__2(840);
+                  var closestPoint = __webpack_require__2(7626);
+                  var meshShader = shaders.meshShader;
+                  var wireShader = shaders.wireShader;
+                  var pointShader = shaders.pointShader;
+                  var pickShader = shaders.pickShader;
+                  var pointPickShader = shaders.pointPickShader;
+                  var contourShader = shaders.contourShader;
+                  var IDENTITY2 = [
+                    1,
+                    0,
+                    0,
+                    0,
+                    0,
+                    1,
+                    0,
+                    0,
+                    0,
+                    0,
+                    1,
+                    0,
+                    0,
+                    0,
+                    0,
+                    1
+                  ];
+                  function SimplicialMesh(gl2, texture, triShader, lineShader, pointShader2, pickShader2, pointPickShader2, contourShader2, trianglePositions, triangleIds, triangleColors, triangleUVs, triangleNormals, triangleVAO, edgePositions, edgeIds, edgeColors, edgeUVs, edgeVAO, pointPositions, pointIds, pointColors, pointUVs, pointSizes, pointVAO, contourPositions, contourVAO) {
+                    this.gl = gl2;
+                    this.pixelRatio = 1;
+                    this.cells = [];
+                    this.positions = [];
+                    this.intensity = [];
+                    this.texture = texture;
+                    this.dirty = true;
+                    this.triShader = triShader;
+                    this.lineShader = lineShader;
+                    this.pointShader = pointShader2;
+                    this.pickShader = pickShader2;
+                    this.pointPickShader = pointPickShader2;
+                    this.contourShader = contourShader2;
+                    this.trianglePositions = trianglePositions;
+                    this.triangleColors = triangleColors;
+                    this.triangleNormals = triangleNormals;
+                    this.triangleUVs = triangleUVs;
+                    this.triangleIds = triangleIds;
+                    this.triangleVAO = triangleVAO;
+                    this.triangleCount = 0;
+                    this.lineWidth = 1;
+                    this.edgePositions = edgePositions;
+                    this.edgeColors = edgeColors;
+                    this.edgeUVs = edgeUVs;
+                    this.edgeIds = edgeIds;
+                    this.edgeVAO = edgeVAO;
+                    this.edgeCount = 0;
+                    this.pointPositions = pointPositions;
+                    this.pointColors = pointColors;
+                    this.pointUVs = pointUVs;
+                    this.pointSizes = pointSizes;
+                    this.pointIds = pointIds;
+                    this.pointVAO = pointVAO;
+                    this.pointCount = 0;
+                    this.contourLineWidth = 1;
+                    this.contourPositions = contourPositions;
+                    this.contourVAO = contourVAO;
+                    this.contourCount = 0;
+                    this.contourColor = [0, 0, 0];
+                    this.contourEnable = true;
+                    this.pickVertex = true;
+                    this.pickId = 1;
+                    this.bounds = [
+                      [Infinity, Infinity, Infinity],
+                      [-Infinity, -Infinity, -Infinity]
+                    ];
+                    this.clipBounds = [
+                      [-Infinity, -Infinity, -Infinity],
+                      [Infinity, Infinity, Infinity]
+                    ];
+                    this.lightPosition = [1e5, 1e5, 0];
+                    this.ambientLight = 0.8;
+                    this.diffuseLight = 0.8;
+                    this.specularLight = 2;
+                    this.roughness = 0.5;
+                    this.fresnel = 1.5;
+                    this.opacity = 1;
+                    this.hasAlpha = false;
+                    this.opacityscale = false;
+                    this._model = IDENTITY2;
+                    this._view = IDENTITY2;
+                    this._projection = IDENTITY2;
+                    this._resolution = [1, 1];
+                  }
+                  var proto = SimplicialMesh.prototype;
+                  proto.isOpaque = function() {
+                    return !this.hasAlpha;
+                  };
+                  proto.isTransparent = function() {
+                    return this.hasAlpha;
+                  };
+                  proto.pickSlots = 1;
+                  proto.setPickBase = function(id2) {
+                    this.pickId = id2;
+                  };
+                  function getOpacityFromScale(ratio, opacityscale) {
+                    if (!opacityscale) return 1;
+                    if (!opacityscale.length) return 1;
+                    for (var i2 = 0; i2 < opacityscale.length; ++i2) {
+                      if (opacityscale.length < 2) return 1;
+                      if (opacityscale[i2][0] === ratio) return opacityscale[i2][1];
+                      if (opacityscale[i2][0] > ratio && i2 > 0) {
+                        var d2 = (opacityscale[i2][0] - ratio) / (opacityscale[i2][0] - opacityscale[i2 - 1][0]);
+                        return opacityscale[i2][1] * (1 - d2) + d2 * opacityscale[i2 - 1][1];
+                      }
+                    }
+                    return 1;
+                  }
+                  function genColormap(param, opacityscale) {
+                    var colors = colormap({
+                      colormap: param,
+                      nshades: 256,
+                      format: "rgba"
+                    });
+                    var result = new Uint8Array(256 * 4);
+                    for (var i2 = 0; i2 < 256; ++i2) {
+                      var c2 = colors[i2];
+                      for (var j2 = 0; j2 < 3; ++j2) {
+                        result[4 * i2 + j2] = c2[j2];
+                      }
+                      if (!opacityscale) {
+                        result[4 * i2 + 3] = 255 * c2[3];
+                      } else {
+                        result[4 * i2 + 3] = 255 * getOpacityFromScale(i2 / 255, opacityscale);
+                      }
+                    }
+                    return ndarray(result, [256, 256, 4], [4, 0, 1]);
+                  }
+                  function takeZComponent(array) {
+                    var n2 = array.length;
+                    var result = new Array(n2);
+                    for (var i2 = 0; i2 < n2; ++i2) {
+                      result[i2] = array[i2][2];
+                    }
+                    return result;
+                  }
+                  proto.highlight = function(selection) {
+                    if (!selection || !this.contourEnable) {
+                      this.contourCount = 0;
+                      return;
+                    }
+                    var level = getContour(this.cells, this.intensity, selection.intensity);
+                    var cells = level.cells;
+                    var vertexIds = level.vertexIds;
+                    var vertexWeights = level.vertexWeights;
+                    var numCells = cells.length;
+                    var result = pool.mallocFloat32(2 * 3 * numCells);
+                    var ptr = 0;
+                    for (var i2 = 0; i2 < numCells; ++i2) {
+                      var c2 = cells[i2];
+                      for (var j2 = 0; j2 < 2; ++j2) {
+                        var v2 = c2[0];
+                        if (c2.length === 2) {
+                          v2 = c2[j2];
+                        }
+                        var a2 = vertexIds[v2][0];
+                        var b2 = vertexIds[v2][1];
+                        var w2 = vertexWeights[v2];
+                        var wi2 = 1 - w2;
+                        var pa2 = this.positions[a2];
+                        var pb2 = this.positions[b2];
+                        for (var k2 = 0; k2 < 3; ++k2) {
+                          result[ptr++] = w2 * pa2[k2] + wi2 * pb2[k2];
+                        }
+                      }
+                    }
+                    this.contourCount = ptr / 3 | 0;
+                    this.contourPositions.update(result.subarray(0, ptr));
+                    pool.free(result);
+                  };
+                  proto.update = function(params) {
+                    params = params || {};
+                    var gl2 = this.gl;
+                    this.dirty = true;
+                    if ("contourEnable" in params) {
+                      this.contourEnable = params.contourEnable;
+                    }
+                    if ("contourColor" in params) {
+                      this.contourColor = params.contourColor;
+                    }
+                    if ("lineWidth" in params) {
+                      this.lineWidth = params.lineWidth;
+                    }
+                    if ("lightPosition" in params) {
+                      this.lightPosition = params.lightPosition;
+                    }
+                    this.hasAlpha = false;
+                    if ("opacity" in params) {
+                      this.opacity = params.opacity;
+                      if (this.opacity < 1) {
+                        this.hasAlpha = true;
+                      }
+                    }
+                    if ("opacityscale" in params) {
+                      this.opacityscale = params.opacityscale;
+                      this.hasAlpha = true;
+                    }
+                    if ("ambient" in params) {
+                      this.ambientLight = params.ambient;
+                    }
+                    if ("diffuse" in params) {
+                      this.diffuseLight = params.diffuse;
+                    }
+                    if ("specular" in params) {
+                      this.specularLight = params.specular;
+                    }
+                    if ("roughness" in params) {
+                      this.roughness = params.roughness;
+                    }
+                    if ("fresnel" in params) {
+                      this.fresnel = params.fresnel;
+                    }
+                    if (params.texture) {
+                      this.texture.dispose();
+                      this.texture = createTexture2(gl2, params.texture);
+                    } else if (params.colormap) {
+                      this.texture.shape = [256, 256];
+                      this.texture.minFilter = gl2.LINEAR_MIPMAP_LINEAR;
+                      this.texture.magFilter = gl2.LINEAR;
+                      this.texture.setPixels(genColormap(params.colormap, this.opacityscale));
+                      this.texture.generateMipmap();
+                    }
+                    var cells = params.cells;
+                    var positions = params.positions;
+                    if (!positions || !cells) {
+                      return;
+                    }
+                    var tPos = [];
+                    var tCol = [];
+                    var tNor = [];
+                    var tUVs = [];
+                    var tIds = [];
+                    var ePos = [];
+                    var eCol = [];
+                    var eUVs = [];
+                    var eIds = [];
+                    var pPos = [];
+                    var pCol = [];
+                    var pUVs = [];
+                    var pSiz = [];
+                    var pIds = [];
+                    this.cells = cells;
+                    this.positions = positions;
+                    var vertexNormals = params.vertexNormals;
+                    var cellNormals = params.cellNormals;
+                    var vertexNormalsEpsilon = params.vertexNormalsEpsilon === void 0 ? DEFAULT_VERTEX_NORMALS_EPSILON : params.vertexNormalsEpsilon;
+                    var faceNormalsEpsilon = params.faceNormalsEpsilon === void 0 ? DEFAULT_FACE_NORMALS_EPSILON : params.faceNormalsEpsilon;
+                    if (params.useFacetNormals && !cellNormals) {
+                      cellNormals = normals.faceNormals(cells, positions, faceNormalsEpsilon);
+                    }
+                    if (!cellNormals && !vertexNormals) {
+                      vertexNormals = normals.vertexNormals(cells, positions, vertexNormalsEpsilon);
+                    }
+                    var vertexColors = params.vertexColors;
+                    var cellColors = params.cellColors;
+                    var meshColor = params.meshColor || [1, 1, 1, 1];
+                    var vertexUVs = params.vertexUVs;
+                    var vertexIntensity = params.vertexIntensity;
+                    var cellUVs = params.cellUVs;
+                    var cellIntensity = params.cellIntensity;
+                    var intensityLo = Infinity;
+                    var intensityHi = -Infinity;
+                    if (!vertexUVs && !cellUVs) {
+                      if (vertexIntensity) {
+                        if (params.vertexIntensityBounds) {
+                          intensityLo = +params.vertexIntensityBounds[0];
+                          intensityHi = +params.vertexIntensityBounds[1];
+                        } else {
+                          for (var i2 = 0; i2 < vertexIntensity.length; ++i2) {
+                            var f2 = vertexIntensity[i2];
+                            intensityLo = Math.min(intensityLo, f2);
+                            intensityHi = Math.max(intensityHi, f2);
+                          }
+                        }
+                      } else if (cellIntensity) {
+                        if (params.cellIntensityBounds) {
+                          intensityLo = +params.cellIntensityBounds[0];
+                          intensityHi = +params.cellIntensityBounds[1];
+                        } else {
+                          for (var i2 = 0; i2 < cellIntensity.length; ++i2) {
+                            var f2 = cellIntensity[i2];
+                            intensityLo = Math.min(intensityLo, f2);
+                            intensityHi = Math.max(intensityHi, f2);
+                          }
+                        }
+                      } else {
+                        for (var i2 = 0; i2 < positions.length; ++i2) {
+                          var f2 = positions[i2][2];
+                          intensityLo = Math.min(intensityLo, f2);
+                          intensityHi = Math.max(intensityHi, f2);
+                        }
+                      }
+                    }
+                    if (vertexIntensity) {
+                      this.intensity = vertexIntensity;
+                    } else if (cellIntensity) {
+                      this.intensity = cellIntensity;
+                    } else {
+                      this.intensity = takeZComponent(positions);
+                    }
+                    this.pickVertex = !(cellIntensity || cellColors);
+                    var pointSizes = params.pointSizes;
+                    var meshPointSize = params.pointSize || 1;
+                    this.bounds = [[Infinity, Infinity, Infinity], [-Infinity, -Infinity, -Infinity]];
+                    for (var i2 = 0; i2 < positions.length; ++i2) {
+                      var p2 = positions[i2];
+                      for (var j2 = 0; j2 < 3; ++j2) {
+                        if (isNaN(p2[j2]) || !isFinite(p2[j2])) {
+                          continue;
+                        }
+                        this.bounds[0][j2] = Math.min(this.bounds[0][j2], p2[j2]);
+                        this.bounds[1][j2] = Math.max(this.bounds[1][j2], p2[j2]);
+                      }
+                    }
+                    var triangleCount = 0;
+                    var edgeCount = 0;
+                    var pointCount = 0;
+                    fill_loop:
+                      for (var i2 = 0; i2 < cells.length; ++i2) {
+                        var cell = cells[i2];
+                        switch (cell.length) {
+                          case 1:
+                            var v2 = cell[0];
+                            var p2 = positions[v2];
+                            for (var j2 = 0; j2 < 3; ++j2) {
+                              if (isNaN(p2[j2]) || !isFinite(p2[j2])) {
+                                continue fill_loop;
+                              }
+                            }
+                            pPos.push(p2[0], p2[1], p2[2]);
+                            var c2;
+                            if (vertexColors) {
+                              c2 = vertexColors[v2];
+                            } else if (cellColors) {
+                              c2 = cellColors[i2];
+                            } else {
+                              c2 = meshColor;
+                            }
+                            if (this.opacityscale && vertexIntensity) {
+                              tCol.push(
+                                c2[0],
+                                c2[1],
+                                c2[2],
+                                this.opacity * getOpacityFromScale(
+                                  (vertexIntensity[v2] - intensityLo) / (intensityHi - intensityLo),
+                                  this.opacityscale
+                                )
+                              );
+                            } else if (c2.length === 3) {
+                              pCol.push(c2[0], c2[1], c2[2], this.opacity);
+                            } else {
+                              pCol.push(c2[0], c2[1], c2[2], c2[3] * this.opacity);
+                              if (c2[3] < 1) this.hasAlpha = true;
+                            }
+                            var uv;
+                            if (vertexUVs) {
+                              uv = vertexUVs[v2];
+                            } else if (vertexIntensity) {
+                              uv = [
+                                (vertexIntensity[v2] - intensityLo) / (intensityHi - intensityLo),
+                                0
+                              ];
+                            } else if (cellUVs) {
+                              uv = cellUVs[i2];
+                            } else if (cellIntensity) {
+                              uv = [
+                                (cellIntensity[i2] - intensityLo) / (intensityHi - intensityLo),
+                                0
+                              ];
+                            } else {
+                              uv = [
+                                (p2[2] - intensityLo) / (intensityHi - intensityLo),
+                                0
+                              ];
+                            }
+                            pUVs.push(uv[0], uv[1]);
+                            if (pointSizes) {
+                              pSiz.push(pointSizes[v2]);
+                            } else {
+                              pSiz.push(meshPointSize);
+                            }
+                            pIds.push(i2);
+                            pointCount += 1;
+                            break;
+                          case 2:
+                            for (var j2 = 0; j2 < 2; ++j2) {
+                              var v2 = cell[j2];
+                              var p2 = positions[v2];
+                              for (var k2 = 0; k2 < 3; ++k2) {
+                                if (isNaN(p2[k2]) || !isFinite(p2[k2])) {
+                                  continue fill_loop;
+                                }
+                              }
+                            }
+                            for (var j2 = 0; j2 < 2; ++j2) {
+                              var v2 = cell[j2];
+                              var p2 = positions[v2];
+                              ePos.push(p2[0], p2[1], p2[2]);
+                              var c2;
+                              if (vertexColors) {
+                                c2 = vertexColors[v2];
+                              } else if (cellColors) {
+                                c2 = cellColors[i2];
+                              } else {
+                                c2 = meshColor;
+                              }
+                              if (this.opacityscale && vertexIntensity) {
+                                tCol.push(
+                                  c2[0],
+                                  c2[1],
+                                  c2[2],
+                                  this.opacity * getOpacityFromScale(
+                                    (vertexIntensity[v2] - intensityLo) / (intensityHi - intensityLo),
+                                    this.opacityscale
+                                  )
+                                );
+                              } else if (c2.length === 3) {
+                                eCol.push(c2[0], c2[1], c2[2], this.opacity);
+                              } else {
+                                eCol.push(c2[0], c2[1], c2[2], c2[3] * this.opacity);
+                                if (c2[3] < 1) this.hasAlpha = true;
+                              }
+                              var uv;
+                              if (vertexUVs) {
+                                uv = vertexUVs[v2];
+                              } else if (vertexIntensity) {
+                                uv = [
+                                  (vertexIntensity[v2] - intensityLo) / (intensityHi - intensityLo),
+                                  0
+                                ];
+                              } else if (cellUVs) {
+                                uv = cellUVs[i2];
+                              } else if (cellIntensity) {
+                                uv = [
+                                  (cellIntensity[i2] - intensityLo) / (intensityHi - intensityLo),
+                                  0
+                                ];
+                              } else {
+                                uv = [
+                                  (p2[2] - intensityLo) / (intensityHi - intensityLo),
+                                  0
+                                ];
+                              }
+                              eUVs.push(uv[0], uv[1]);
+                              eIds.push(i2);
+                            }
+                            edgeCount += 1;
+                            break;
+                          case 3:
+                            for (var j2 = 0; j2 < 3; ++j2) {
+                              var v2 = cell[j2];
+                              var p2 = positions[v2];
+                              for (var k2 = 0; k2 < 3; ++k2) {
+                                if (isNaN(p2[k2]) || !isFinite(p2[k2])) {
+                                  continue fill_loop;
+                                }
+                              }
+                            }
+                            for (var j2 = 0; j2 < 3; ++j2) {
+                              var v2 = cell[2 - j2];
+                              var p2 = positions[v2];
+                              tPos.push(p2[0], p2[1], p2[2]);
+                              var c2;
+                              if (vertexColors) {
+                                c2 = vertexColors[v2];
+                              } else if (cellColors) {
+                                c2 = cellColors[i2];
+                              } else {
+                                c2 = meshColor;
+                              }
+                              if (!c2) {
+                                tCol.push(0.5, 0.5, 0.5, 1);
+                              } else if (this.opacityscale && vertexIntensity) {
+                                tCol.push(
+                                  c2[0],
+                                  c2[1],
+                                  c2[2],
+                                  this.opacity * getOpacityFromScale(
+                                    (vertexIntensity[v2] - intensityLo) / (intensityHi - intensityLo),
+                                    this.opacityscale
+                                  )
+                                );
+                              } else if (c2.length === 3) {
+                                tCol.push(c2[0], c2[1], c2[2], this.opacity);
+                              } else {
+                                tCol.push(c2[0], c2[1], c2[2], c2[3] * this.opacity);
+                                if (c2[3] < 1) this.hasAlpha = true;
+                              }
+                              var uv;
+                              if (vertexUVs) {
+                                uv = vertexUVs[v2];
+                              } else if (vertexIntensity) {
+                                uv = [
+                                  (vertexIntensity[v2] - intensityLo) / (intensityHi - intensityLo),
+                                  0
+                                ];
+                              } else if (cellUVs) {
+                                uv = cellUVs[i2];
+                              } else if (cellIntensity) {
+                                uv = [
+                                  (cellIntensity[i2] - intensityLo) / (intensityHi - intensityLo),
+                                  0
+                                ];
+                              } else {
+                                uv = [
+                                  (p2[2] - intensityLo) / (intensityHi - intensityLo),
+                                  0
+                                ];
+                              }
+                              tUVs.push(uv[0], uv[1]);
+                              var q2;
+                              if (vertexNormals) {
+                                q2 = vertexNormals[v2];
+                              } else {
+                                q2 = cellNormals[i2];
+                              }
+                              tNor.push(q2[0], q2[1], q2[2]);
+                              tIds.push(i2);
+                            }
+                            triangleCount += 1;
+                            break;
+                        }
+                      }
+                    this.pointCount = pointCount;
+                    this.edgeCount = edgeCount;
+                    this.triangleCount = triangleCount;
+                    this.pointPositions.update(pPos);
+                    this.pointColors.update(pCol);
+                    this.pointUVs.update(pUVs);
+                    this.pointSizes.update(pSiz);
+                    this.pointIds.update(new Uint32Array(pIds));
+                    this.edgePositions.update(ePos);
+                    this.edgeColors.update(eCol);
+                    this.edgeUVs.update(eUVs);
+                    this.edgeIds.update(new Uint32Array(eIds));
+                    this.trianglePositions.update(tPos);
+                    this.triangleColors.update(tCol);
+                    this.triangleUVs.update(tUVs);
+                    this.triangleNormals.update(tNor);
+                    this.triangleIds.update(new Uint32Array(tIds));
+                  };
+                  proto.drawTransparent = proto.draw = function(params) {
+                    params = params || {};
+                    var gl2 = this.gl;
+                    var model = params.model || IDENTITY2;
+                    var view = params.view || IDENTITY2;
+                    var projection = params.projection || IDENTITY2;
+                    var clipBounds = [[-1e6, -1e6, -1e6], [1e6, 1e6, 1e6]];
+                    for (var i2 = 0; i2 < 3; ++i2) {
+                      clipBounds[0][i2] = Math.max(clipBounds[0][i2], this.clipBounds[0][i2]);
+                      clipBounds[1][i2] = Math.min(clipBounds[1][i2], this.clipBounds[1][i2]);
+                    }
+                    var uniforms = {
+                      model,
+                      view,
+                      projection,
+                      inverseModel: IDENTITY2.slice(),
+                      clipBounds,
+                      kambient: this.ambientLight,
+                      kdiffuse: this.diffuseLight,
+                      kspecular: this.specularLight,
+                      roughness: this.roughness,
+                      fresnel: this.fresnel,
+                      eyePosition: [0, 0, 0],
+                      lightPosition: [0, 0, 0],
+                      contourColor: this.contourColor,
+                      texture: 0
+                    };
+                    uniforms.inverseModel = invert2(uniforms.inverseModel, uniforms.model);
+                    gl2.disable(gl2.CULL_FACE);
+                    this.texture.bind(0);
+                    var invCameraMatrix = new Array(16);
+                    multiply2(invCameraMatrix, uniforms.view, uniforms.model);
+                    multiply2(invCameraMatrix, uniforms.projection, invCameraMatrix);
+                    invert2(invCameraMatrix, invCameraMatrix);
+                    for (var i2 = 0; i2 < 3; ++i2) {
+                      uniforms.eyePosition[i2] = invCameraMatrix[12 + i2] / invCameraMatrix[15];
+                    }
+                    var w2 = invCameraMatrix[15];
+                    for (var i2 = 0; i2 < 3; ++i2) {
+                      w2 += this.lightPosition[i2] * invCameraMatrix[4 * i2 + 3];
+                    }
+                    for (var i2 = 0; i2 < 3; ++i2) {
+                      var s2 = invCameraMatrix[12 + i2];
+                      for (var j2 = 0; j2 < 3; ++j2) {
+                        s2 += invCameraMatrix[4 * j2 + i2] * this.lightPosition[j2];
+                      }
+                      uniforms.lightPosition[i2] = s2 / w2;
+                    }
+                    if (this.triangleCount > 0) {
+                      var shader = this.triShader;
+                      shader.bind();
+                      shader.uniforms = uniforms;
+                      this.triangleVAO.bind();
+                      gl2.drawArrays(gl2.TRIANGLES, 0, this.triangleCount * 3);
+                      this.triangleVAO.unbind();
+                    }
+                    if (this.edgeCount > 0 && this.lineWidth > 0) {
+                      var shader = this.lineShader;
+                      shader.bind();
+                      shader.uniforms = uniforms;
+                      this.edgeVAO.bind();
+                      gl2.lineWidth(this.lineWidth * this.pixelRatio);
+                      gl2.drawArrays(gl2.LINES, 0, this.edgeCount * 2);
+                      this.edgeVAO.unbind();
+                    }
+                    if (this.pointCount > 0) {
+                      var shader = this.pointShader;
+                      shader.bind();
+                      shader.uniforms = uniforms;
+                      this.pointVAO.bind();
+                      gl2.drawArrays(gl2.POINTS, 0, this.pointCount);
+                      this.pointVAO.unbind();
+                    }
+                    if (this.contourEnable && this.contourCount > 0 && this.contourLineWidth > 0) {
+                      var shader = this.contourShader;
+                      shader.bind();
+                      shader.uniforms = uniforms;
+                      this.contourVAO.bind();
+                      gl2.drawArrays(gl2.LINES, 0, this.contourCount);
+                      this.contourVAO.unbind();
+                    }
+                  };
+                  proto.drawPick = function(params) {
+                    params = params || {};
+                    var gl2 = this.gl;
+                    var model = params.model || IDENTITY2;
+                    var view = params.view || IDENTITY2;
+                    var projection = params.projection || IDENTITY2;
+                    var clipBounds = [[-1e6, -1e6, -1e6], [1e6, 1e6, 1e6]];
+                    for (var i2 = 0; i2 < 3; ++i2) {
+                      clipBounds[0][i2] = Math.max(clipBounds[0][i2], this.clipBounds[0][i2]);
+                      clipBounds[1][i2] = Math.min(clipBounds[1][i2], this.clipBounds[1][i2]);
+                    }
+                    this._model = [].slice.call(model);
+                    this._view = [].slice.call(view);
+                    this._projection = [].slice.call(projection);
+                    this._resolution = [gl2.drawingBufferWidth, gl2.drawingBufferHeight];
+                    var uniforms = {
+                      model,
+                      view,
+                      projection,
+                      clipBounds,
+                      pickId: this.pickId / 255
+                    };
+                    var shader = this.pickShader;
+                    shader.bind();
+                    shader.uniforms = uniforms;
+                    if (this.triangleCount > 0) {
+                      this.triangleVAO.bind();
+                      gl2.drawArrays(gl2.TRIANGLES, 0, this.triangleCount * 3);
+                      this.triangleVAO.unbind();
+                    }
+                    if (this.edgeCount > 0) {
+                      this.edgeVAO.bind();
+                      gl2.lineWidth(this.lineWidth * this.pixelRatio);
+                      gl2.drawArrays(gl2.LINES, 0, this.edgeCount * 2);
+                      this.edgeVAO.unbind();
+                    }
+                    if (this.pointCount > 0) {
+                      var shader = this.pointPickShader;
+                      shader.bind();
+                      shader.uniforms = uniforms;
+                      this.pointVAO.bind();
+                      gl2.drawArrays(gl2.POINTS, 0, this.pointCount);
+                      this.pointVAO.unbind();
+                    }
+                  };
+                  proto.pick = function(pickData) {
+                    if (!pickData) {
+                      return null;
+                    }
+                    if (pickData.id !== this.pickId) {
+                      return null;
+                    }
+                    var cellId = pickData.value[0] + 256 * pickData.value[1] + 65536 * pickData.value[2];
+                    var cell = this.cells[cellId];
+                    var positions = this.positions;
+                    var simplex = new Array(cell.length);
+                    for (var i2 = 0; i2 < cell.length; ++i2) {
+                      simplex[i2] = positions[cell[i2]];
+                    }
+                    var x2 = pickData.coord[0];
+                    var y2 = pickData.coord[1];
+                    if (!this.pickVertex) {
+                      var A22 = this.positions[cell[0]];
+                      var B22 = this.positions[cell[1]];
+                      var C22 = this.positions[cell[2]];
+                      var dataCoordinate = [
+                        (A22[0] + B22[0] + C22[0]) / 3,
+                        (A22[1] + B22[1] + C22[1]) / 3,
+                        (A22[2] + B22[2] + C22[2]) / 3
+                      ];
+                      return {
+                        _cellCenter: true,
+                        position: [x2, y2],
+                        index: cellId,
+                        cell,
+                        cellId,
+                        intensity: this.intensity[cellId],
+                        dataCoordinate
+                      };
+                    }
+                    var data = closestPoint(
+                      simplex,
+                      [x2 * this.pixelRatio, this._resolution[1] - y2 * this.pixelRatio],
+                      this._model,
+                      this._view,
+                      this._projection,
+                      this._resolution
+                    );
+                    if (!data) {
+                      return null;
+                    }
+                    var weights = data[2];
+                    var interpIntensity = 0;
+                    for (var i2 = 0; i2 < cell.length; ++i2) {
+                      interpIntensity += weights[i2] * this.intensity[cell[i2]];
+                    }
+                    return {
+                      position: data[1],
+                      index: cell[data[0]],
+                      cell,
+                      cellId,
+                      intensity: interpIntensity,
+                      dataCoordinate: this.positions[cell[data[0]]]
+                    };
+                  };
+                  proto.dispose = function() {
+                    this.texture.dispose();
+                    this.triShader.dispose();
+                    this.lineShader.dispose();
+                    this.pointShader.dispose();
+                    this.pickShader.dispose();
+                    this.pointPickShader.dispose();
+                    this.triangleVAO.dispose();
+                    this.trianglePositions.dispose();
+                    this.triangleColors.dispose();
+                    this.triangleUVs.dispose();
+                    this.triangleNormals.dispose();
+                    this.triangleIds.dispose();
+                    this.edgeVAO.dispose();
+                    this.edgePositions.dispose();
+                    this.edgeColors.dispose();
+                    this.edgeUVs.dispose();
+                    this.edgeIds.dispose();
+                    this.pointVAO.dispose();
+                    this.pointPositions.dispose();
+                    this.pointColors.dispose();
+                    this.pointUVs.dispose();
+                    this.pointSizes.dispose();
+                    this.pointIds.dispose();
+                    this.contourVAO.dispose();
+                    this.contourPositions.dispose();
+                    this.contourShader.dispose();
+                  };
+                  function createMeshShader(gl2) {
+                    var shader = createShader(gl2, meshShader.vertex, meshShader.fragment);
+                    shader.attributes.position.location = 0;
+                    shader.attributes.color.location = 2;
+                    shader.attributes.uv.location = 3;
+                    shader.attributes.normal.location = 4;
+                    return shader;
+                  }
+                  function createWireShader(gl2) {
+                    var shader = createShader(gl2, wireShader.vertex, wireShader.fragment);
+                    shader.attributes.position.location = 0;
+                    shader.attributes.color.location = 2;
+                    shader.attributes.uv.location = 3;
+                    return shader;
+                  }
+                  function createPointShader(gl2) {
+                    var shader = createShader(gl2, pointShader.vertex, pointShader.fragment);
+                    shader.attributes.position.location = 0;
+                    shader.attributes.color.location = 2;
+                    shader.attributes.uv.location = 3;
+                    shader.attributes.pointSize.location = 4;
+                    return shader;
+                  }
+                  function createPickShader(gl2) {
+                    var shader = createShader(gl2, pickShader.vertex, pickShader.fragment);
+                    shader.attributes.position.location = 0;
+                    shader.attributes.id.location = 1;
+                    return shader;
+                  }
+                  function createPointPickShader(gl2) {
+                    var shader = createShader(gl2, pointPickShader.vertex, pointPickShader.fragment);
+                    shader.attributes.position.location = 0;
+                    shader.attributes.id.location = 1;
+                    shader.attributes.pointSize.location = 4;
+                    return shader;
+                  }
+                  function createContourShader(gl2) {
+                    var shader = createShader(gl2, contourShader.vertex, contourShader.fragment);
+                    shader.attributes.position.location = 0;
+                    return shader;
+                  }
+                  function createSimplicialMesh(gl2, params) {
+                    if (arguments.length === 1) {
+                      params = gl2;
+                      gl2 = params.gl;
+                    }
+                    var ext = gl2.getExtension("OES_standard_derivatives") || gl2.getExtension("MOZ_OES_standard_derivatives") || gl2.getExtension("WEBKIT_OES_standard_derivatives");
+                    if (!ext)
+                      throw new Error("derivatives not supported");
+                    var triShader = createMeshShader(gl2);
+                    var lineShader = createWireShader(gl2);
+                    var pointShader2 = createPointShader(gl2);
+                    var pickShader2 = createPickShader(gl2);
+                    var pointPickShader2 = createPointPickShader(gl2);
+                    var contourShader2 = createContourShader(gl2);
+                    var meshTexture = createTexture2(
+                      gl2,
+                      ndarray(new Uint8Array([255, 255, 255, 255]), [1, 1, 4])
+                    );
+                    meshTexture.generateMipmap();
+                    meshTexture.minFilter = gl2.LINEAR_MIPMAP_LINEAR;
+                    meshTexture.magFilter = gl2.LINEAR;
+                    var trianglePositions = createBuffer(gl2);
+                    var triangleColors = createBuffer(gl2);
+                    var triangleUVs = createBuffer(gl2);
+                    var triangleNormals = createBuffer(gl2);
+                    var triangleIds = createBuffer(gl2);
+                    var triangleVAO = createVAO(gl2, [
+                      {
+                        buffer: trianglePositions,
+                        type: gl2.FLOAT,
+                        size: 3
+                      },
+                      {
+                        buffer: triangleIds,
+                        type: gl2.UNSIGNED_BYTE,
+                        size: 4,
+                        normalized: true
+                      },
+                      {
+                        buffer: triangleColors,
+                        type: gl2.FLOAT,
+                        size: 4
+                      },
+                      {
+                        buffer: triangleUVs,
+                        type: gl2.FLOAT,
+                        size: 2
+                      },
+                      {
+                        buffer: triangleNormals,
+                        type: gl2.FLOAT,
+                        size: 3
+                      }
+                    ]);
+                    var edgePositions = createBuffer(gl2);
+                    var edgeColors = createBuffer(gl2);
+                    var edgeUVs = createBuffer(gl2);
+                    var edgeIds = createBuffer(gl2);
+                    var edgeVAO = createVAO(gl2, [
+                      {
+                        buffer: edgePositions,
+                        type: gl2.FLOAT,
+                        size: 3
+                      },
+                      {
+                        buffer: edgeIds,
+                        type: gl2.UNSIGNED_BYTE,
+                        size: 4,
+                        normalized: true
+                      },
+                      {
+                        buffer: edgeColors,
+                        type: gl2.FLOAT,
+                        size: 4
+                      },
+                      {
+                        buffer: edgeUVs,
+                        type: gl2.FLOAT,
+                        size: 2
+                      }
+                    ]);
+                    var pointPositions = createBuffer(gl2);
+                    var pointColors = createBuffer(gl2);
+                    var pointUVs = createBuffer(gl2);
+                    var pointSizes = createBuffer(gl2);
+                    var pointIds = createBuffer(gl2);
+                    var pointVAO = createVAO(gl2, [
+                      {
+                        buffer: pointPositions,
+                        type: gl2.FLOAT,
+                        size: 3
+                      },
+                      {
+                        buffer: pointIds,
+                        type: gl2.UNSIGNED_BYTE,
+                        size: 4,
+                        normalized: true
+                      },
+                      {
+                        buffer: pointColors,
+                        type: gl2.FLOAT,
+                        size: 4
+                      },
+                      {
+                        buffer: pointUVs,
+                        type: gl2.FLOAT,
+                        size: 2
+                      },
+                      {
+                        buffer: pointSizes,
+                        type: gl2.FLOAT,
+                        size: 1
+                      }
+                    ]);
+                    var contourPositions = createBuffer(gl2);
+                    var contourVAO = createVAO(gl2, [
+                      {
+                        buffer: contourPositions,
+                        type: gl2.FLOAT,
+                        size: 3
+                      }
+                    ]);
+                    var mesh = new SimplicialMesh(
+                      gl2,
+                      meshTexture,
+                      triShader,
+                      lineShader,
+                      pointShader2,
+                      pickShader2,
+                      pointPickShader2,
+                      contourShader2,
+                      trianglePositions,
+                      triangleIds,
+                      triangleColors,
+                      triangleUVs,
+                      triangleNormals,
+                      triangleVAO,
+                      edgePositions,
+                      edgeIds,
+                      edgeColors,
+                      edgeUVs,
+                      edgeVAO,
+                      pointPositions,
+                      pointIds,
+                      pointColors,
+                      pointUVs,
+                      pointSizes,
+                      pointVAO,
+                      contourPositions,
+                      contourVAO
+                    );
+                    mesh.update(params);
+                    return mesh;
+                  }
+                  module22.exports = createSimplicialMesh;
+                }
+              ),
+              /***/
+              7261: (
+                /***/
+                function(module22, __unused_webpack_exports, __webpack_require__2) {
+                  module22.exports = createTurntableController;
+                  var filterVector = __webpack_require__2(9215);
+                  var invert44 = __webpack_require__2(7608);
+                  var rotateM = __webpack_require__2(6079);
+                  var cross2 = __webpack_require__2(5911);
+                  var normalize3 = __webpack_require__2(3536);
+                  var dot3 = __webpack_require__2(244);
+                  function len3(x2, y2, z2) {
+                    return Math.sqrt(Math.pow(x2, 2) + Math.pow(y2, 2) + Math.pow(z2, 2));
+                  }
+                  function clamp1(x2) {
+                    return Math.min(1, Math.max(-1, x2));
+                  }
+                  function findOrthoPair(v2) {
+                    var vx = Math.abs(v2[0]);
+                    var vy = Math.abs(v2[1]);
+                    var vz = Math.abs(v2[2]);
+                    var u2 = [0, 0, 0];
+                    if (vx > Math.max(vy, vz)) {
+                      u2[2] = 1;
+                    } else if (vy > Math.max(vx, vz)) {
+                      u2[0] = 1;
+                    } else {
+                      u2[1] = 1;
+                    }
+                    var vv = 0;
+                    var uv = 0;
+                    for (var i2 = 0; i2 < 3; ++i2) {
+                      vv += v2[i2] * v2[i2];
+                      uv += u2[i2] * v2[i2];
+                    }
+                    for (var i2 = 0; i2 < 3; ++i2) {
+                      u2[i2] -= uv / vv * v2[i2];
+                    }
+                    normalize3(u2, u2);
+                    return u2;
+                  }
+                  function TurntableController(zoomMin, zoomMax, center, up, right, radius, theta, phi) {
+                    this.center = filterVector(center);
+                    this.up = filterVector(up);
+                    this.right = filterVector(right);
+                    this.radius = filterVector([radius]);
+                    this.angle = filterVector([theta, phi]);
+                    this.angle.bounds = [[-Infinity, -Math.PI / 2], [Infinity, Math.PI / 2]];
+                    this.setDistanceLimits(zoomMin, zoomMax);
+                    this.computedCenter = this.center.curve(0);
+                    this.computedUp = this.up.curve(0);
+                    this.computedRight = this.right.curve(0);
+                    this.computedRadius = this.radius.curve(0);
+                    this.computedAngle = this.angle.curve(0);
+                    this.computedToward = [0, 0, 0];
+                    this.computedEye = [0, 0, 0];
+                    this.computedMatrix = new Array(16);
+                    for (var i2 = 0; i2 < 16; ++i2) {
+                      this.computedMatrix[i2] = 0.5;
+                    }
+                    this.recalcMatrix(0);
+                  }
+                  var proto = TurntableController.prototype;
+                  proto.setDistanceLimits = function(minDist, maxDist) {
+                    if (minDist > 0) {
+                      minDist = Math.log(minDist);
+                    } else {
+                      minDist = -Infinity;
+                    }
+                    if (maxDist > 0) {
+                      maxDist = Math.log(maxDist);
+                    } else {
+                      maxDist = Infinity;
+                    }
+                    maxDist = Math.max(maxDist, minDist);
+                    this.radius.bounds[0][0] = minDist;
+                    this.radius.bounds[1][0] = maxDist;
+                  };
+                  proto.getDistanceLimits = function(out) {
+                    var bounds = this.radius.bounds[0];
+                    if (out) {
+                      out[0] = Math.exp(bounds[0][0]);
+                      out[1] = Math.exp(bounds[1][0]);
+                      return out;
+                    }
+                    return [Math.exp(bounds[0][0]), Math.exp(bounds[1][0])];
+                  };
+                  proto.recalcMatrix = function(t4) {
+                    this.center.curve(t4);
+                    this.up.curve(t4);
+                    this.right.curve(t4);
+                    this.radius.curve(t4);
+                    this.angle.curve(t4);
+                    var up = this.computedUp;
+                    var right = this.computedRight;
+                    var uu = 0;
+                    var ur = 0;
+                    for (var i2 = 0; i2 < 3; ++i2) {
+                      ur += up[i2] * right[i2];
+                      uu += up[i2] * up[i2];
+                    }
+                    var ul2 = Math.sqrt(uu);
+                    var rr = 0;
+                    for (var i2 = 0; i2 < 3; ++i2) {
+                      right[i2] -= up[i2] * ur / uu;
+                      rr += right[i2] * right[i2];
+                      up[i2] /= ul2;
+                    }
+                    var rl2 = Math.sqrt(rr);
+                    for (var i2 = 0; i2 < 3; ++i2) {
+                      right[i2] /= rl2;
+                    }
+                    var toward = this.computedToward;
+                    cross2(toward, up, right);
+                    normalize3(toward, toward);
+                    var radius = Math.exp(this.computedRadius[0]);
+                    var theta = this.computedAngle[0];
+                    var phi = this.computedAngle[1];
+                    var ctheta = Math.cos(theta);
+                    var stheta = Math.sin(theta);
+                    var cphi = Math.cos(phi);
+                    var sphi = Math.sin(phi);
+                    var center = this.computedCenter;
+                    var wx = ctheta * cphi;
+                    var wy = stheta * cphi;
+                    var wz = sphi;
+                    var sx = -ctheta * sphi;
+                    var sy = -stheta * sphi;
+                    var sz = cphi;
+                    var eye = this.computedEye;
+                    var mat = this.computedMatrix;
+                    for (var i2 = 0; i2 < 3; ++i2) {
+                      var x2 = wx * right[i2] + wy * toward[i2] + wz * up[i2];
+                      mat[4 * i2 + 1] = sx * right[i2] + sy * toward[i2] + sz * up[i2];
+                      mat[4 * i2 + 2] = x2;
+                      mat[4 * i2 + 3] = 0;
+                    }
+                    var ax = mat[1];
+                    var ay = mat[5];
+                    var az = mat[9];
+                    var bx = mat[2];
+                    var by = mat[6];
+                    var bz = mat[10];
+                    var cx = ay * bz - az * by;
+                    var cy = az * bx - ax * bz;
+                    var cz = ax * by - ay * bx;
+                    var cl2 = len3(cx, cy, cz);
+                    cx /= cl2;
+                    cy /= cl2;
+                    cz /= cl2;
+                    mat[0] = cx;
+                    mat[4] = cy;
+                    mat[8] = cz;
+                    for (var i2 = 0; i2 < 3; ++i2) {
+                      eye[i2] = center[i2] + mat[2 + 4 * i2] * radius;
+                    }
+                    for (var i2 = 0; i2 < 3; ++i2) {
+                      var rr = 0;
+                      for (var j2 = 0; j2 < 3; ++j2) {
+                        rr += mat[i2 + 4 * j2] * eye[j2];
+                      }
+                      mat[12 + i2] = -rr;
+                    }
+                    mat[15] = 1;
+                  };
+                  proto.getMatrix = function(t4, result) {
+                    this.recalcMatrix(t4);
+                    var mat = this.computedMatrix;
+                    if (result) {
+                      for (var i2 = 0; i2 < 16; ++i2) {
+                        result[i2] = mat[i2];
+                      }
+                      return result;
+                    }
+                    return mat;
+                  };
+                  var zAxis = [0, 0, 0];
+                  proto.rotate = function(t4, dtheta, dphi, droll) {
+                    this.angle.move(t4, dtheta, dphi);
+                    if (droll) {
+                      this.recalcMatrix(t4);
+                      var mat = this.computedMatrix;
+                      zAxis[0] = mat[2];
+                      zAxis[1] = mat[6];
+                      zAxis[2] = mat[10];
+                      var up = this.computedUp;
+                      var right = this.computedRight;
+                      var toward = this.computedToward;
+                      for (var i2 = 0; i2 < 3; ++i2) {
+                        mat[4 * i2] = up[i2];
+                        mat[4 * i2 + 1] = right[i2];
+                        mat[4 * i2 + 2] = toward[i2];
+                      }
+                      rotateM(mat, mat, droll, zAxis);
+                      for (var i2 = 0; i2 < 3; ++i2) {
+                        up[i2] = mat[4 * i2];
+                        right[i2] = mat[4 * i2 + 1];
+                      }
+                      this.up.set(t4, up[0], up[1], up[2]);
+                      this.right.set(t4, right[0], right[1], right[2]);
+                    }
+                  };
+                  proto.pan = function(t4, dx, dy, dz) {
+                    dx = dx || 0;
+                    dy = dy || 0;
+                    dz = dz || 0;
+                    this.recalcMatrix(t4);
+                    var mat = this.computedMatrix;
+                    Math.exp(this.computedRadius[0]);
+                    var ux = mat[1];
+                    var uy = mat[5];
+                    var uz = mat[9];
+                    var ul2 = len3(ux, uy, uz);
+                    ux /= ul2;
+                    uy /= ul2;
+                    uz /= ul2;
+                    var rx = mat[0];
+                    var ry = mat[4];
+                    var rz = mat[8];
+                    var ru = rx * ux + ry * uy + rz * uz;
+                    rx -= ux * ru;
+                    ry -= uy * ru;
+                    rz -= uz * ru;
+                    var rl2 = len3(rx, ry, rz);
+                    rx /= rl2;
+                    ry /= rl2;
+                    rz /= rl2;
+                    var vx = rx * dx + ux * dy;
+                    var vy = ry * dx + uy * dy;
+                    var vz = rz * dx + uz * dy;
+                    this.center.move(t4, vx, vy, vz);
+                    var radius = Math.exp(this.computedRadius[0]);
+                    radius = Math.max(1e-4, radius + dz);
+                    this.radius.set(t4, Math.log(radius));
+                  };
+                  proto.translate = function(t4, dx, dy, dz) {
+                    this.center.move(
+                      t4,
+                      dx || 0,
+                      dy || 0,
+                      dz || 0
+                    );
+                  };
+                  proto.setMatrix = function(t4, mat, axes, noSnap) {
+                    var ushift = 1;
+                    if (typeof axes === "number") {
+                      ushift = axes | 0;
+                    }
+                    if (ushift < 0 || ushift > 3) {
+                      ushift = 1;
+                    }
+                    var vshift = (ushift + 2) % 3;
+                    if (!mat) {
+                      this.recalcMatrix(t4);
+                      mat = this.computedMatrix;
+                    }
+                    var ux = mat[ushift];
+                    var uy = mat[ushift + 4];
+                    var uz = mat[ushift + 8];
+                    if (!noSnap) {
+                      var ul2 = len3(ux, uy, uz);
+                      ux /= ul2;
+                      uy /= ul2;
+                      uz /= ul2;
+                    } else {
+                      var ax = Math.abs(ux);
+                      var ay = Math.abs(uy);
+                      var az = Math.abs(uz);
+                      var am = Math.max(ax, ay, az);
+                      if (ax === am) {
+                        ux = ux < 0 ? -1 : 1;
+                        uy = uz = 0;
+                      } else if (az === am) {
+                        uz = uz < 0 ? -1 : 1;
+                        ux = uy = 0;
+                      } else {
+                        uy = uy < 0 ? -1 : 1;
+                        ux = uz = 0;
+                      }
+                    }
+                    var rx = mat[vshift];
+                    var ry = mat[vshift + 4];
+                    var rz = mat[vshift + 8];
+                    var ru = rx * ux + ry * uy + rz * uz;
+                    rx -= ux * ru;
+                    ry -= uy * ru;
+                    rz -= uz * ru;
+                    var rl2 = len3(rx, ry, rz);
+                    rx /= rl2;
+                    ry /= rl2;
+                    rz /= rl2;
+                    var fx = uy * rz - uz * ry;
+                    var fy = uz * rx - ux * rz;
+                    var fz = ux * ry - uy * rx;
+                    var fl2 = len3(fx, fy, fz);
+                    fx /= fl2;
+                    fy /= fl2;
+                    fz /= fl2;
+                    this.center.jump(t4, ex, ey, ez);
+                    this.radius.idle(t4);
+                    this.up.jump(t4, ux, uy, uz);
+                    this.right.jump(t4, rx, ry, rz);
+                    var phi, theta;
+                    if (ushift === 2) {
+                      var cx = mat[1];
+                      var cy = mat[5];
+                      var cz = mat[9];
+                      var cr = cx * rx + cy * ry + cz * rz;
+                      var cf2 = cx * fx + cy * fy + cz * fz;
+                      if (tu < 0) {
+                        phi = -Math.PI / 2;
+                      } else {
+                        phi = Math.PI / 2;
+                      }
+                      theta = Math.atan2(cf2, cr);
+                    } else {
+                      var tx = mat[2];
+                      var ty = mat[6];
+                      var tz = mat[10];
+                      var tu = tx * ux + ty * uy + tz * uz;
+                      var tr = tx * rx + ty * ry + tz * rz;
+                      var tf2 = tx * fx + ty * fy + tz * fz;
+                      phi = Math.asin(clamp1(tu));
+                      theta = Math.atan2(tf2, tr);
+                    }
+                    this.angle.jump(t4, theta, phi);
+                    this.recalcMatrix(t4);
+                    var dx = mat[2];
+                    var dy = mat[6];
+                    var dz = mat[10];
+                    var imat = this.computedMatrix;
+                    invert44(imat, mat);
+                    var w2 = imat[15];
+                    var ex = imat[12] / w2;
+                    var ey = imat[13] / w2;
+                    var ez = imat[14] / w2;
+                    var gs = Math.exp(this.computedRadius[0]);
+                    this.center.jump(t4, ex - dx * gs, ey - dy * gs, ez - dz * gs);
+                  };
+                  proto.lastT = function() {
+                    return Math.max(
+                      this.center.lastT(),
+                      this.up.lastT(),
+                      this.right.lastT(),
+                      this.radius.lastT(),
+                      this.angle.lastT()
+                    );
+                  };
+                  proto.idle = function(t4) {
+                    this.center.idle(t4);
+                    this.up.idle(t4);
+                    this.right.idle(t4);
+                    this.radius.idle(t4);
+                    this.angle.idle(t4);
+                  };
+                  proto.flush = function(t4) {
+                    this.center.flush(t4);
+                    this.up.flush(t4);
+                    this.right.flush(t4);
+                    this.radius.flush(t4);
+                    this.angle.flush(t4);
+                  };
+                  proto.setDistance = function(t4, d2) {
+                    if (d2 > 0) {
+                      this.radius.set(t4, Math.log(d2));
+                    }
+                  };
+                  proto.lookAt = function(t4, eye, center, up) {
+                    this.recalcMatrix(t4);
+                    eye = eye || this.computedEye;
+                    center = center || this.computedCenter;
+                    up = up || this.computedUp;
+                    var ux = up[0];
+                    var uy = up[1];
+                    var uz = up[2];
+                    var ul2 = len3(ux, uy, uz);
+                    if (ul2 < 1e-6) {
+                      return;
+                    }
+                    ux /= ul2;
+                    uy /= ul2;
+                    uz /= ul2;
+                    var tx = eye[0] - center[0];
+                    var ty = eye[1] - center[1];
+                    var tz = eye[2] - center[2];
+                    var tl2 = len3(tx, ty, tz);
+                    if (tl2 < 1e-6) {
+                      return;
+                    }
+                    tx /= tl2;
+                    ty /= tl2;
+                    tz /= tl2;
+                    var right = this.computedRight;
+                    var rx = right[0];
+                    var ry = right[1];
+                    var rz = right[2];
+                    var ru = ux * rx + uy * ry + uz * rz;
+                    rx -= ru * ux;
+                    ry -= ru * uy;
+                    rz -= ru * uz;
+                    var rl2 = len3(rx, ry, rz);
+                    if (rl2 < 0.01) {
+                      rx = uy * tz - uz * ty;
+                      ry = uz * tx - ux * tz;
+                      rz = ux * ty - uy * tx;
+                      rl2 = len3(rx, ry, rz);
+                      if (rl2 < 1e-6) {
+                        return;
+                      }
+                    }
+                    rx /= rl2;
+                    ry /= rl2;
+                    rz /= rl2;
+                    this.up.set(t4, ux, uy, uz);
+                    this.right.set(t4, rx, ry, rz);
+                    this.center.set(t4, center[0], center[1], center[2]);
+                    this.radius.set(t4, Math.log(tl2));
+                    var fx = uy * rz - uz * ry;
+                    var fy = uz * rx - ux * rz;
+                    var fz = ux * ry - uy * rx;
+                    var fl2 = len3(fx, fy, fz);
+                    fx /= fl2;
+                    fy /= fl2;
+                    fz /= fl2;
+                    var tu = ux * tx + uy * ty + uz * tz;
+                    var tr = rx * tx + ry * ty + rz * tz;
+                    var tf2 = fx * tx + fy * ty + fz * tz;
+                    var phi = Math.asin(clamp1(tu));
+                    var theta = Math.atan2(tf2, tr);
+                    var angleState = this.angle._state;
+                    var lastTheta = angleState[angleState.length - 1];
+                    var lastPhi = angleState[angleState.length - 2];
+                    lastTheta = lastTheta % (2 * Math.PI);
+                    var dp = Math.abs(lastTheta + 2 * Math.PI - theta);
+                    var d0 = Math.abs(lastTheta - theta);
+                    var dn = Math.abs(lastTheta - 2 * Math.PI - theta);
+                    if (dp < d0) {
+                      lastTheta += 2 * Math.PI;
+                    }
+                    if (dn < d0) {
+                      lastTheta -= 2 * Math.PI;
+                    }
+                    this.angle.jump(this.angle.lastT(), lastTheta, lastPhi);
+                    this.angle.set(t4, theta, phi);
+                  };
+                  function createTurntableController(options) {
+                    options = options || {};
+                    var center = options.center || [0, 0, 0];
+                    var up = options.up || [0, 1, 0];
+                    var right = options.right || findOrthoPair(up);
+                    var radius = options.radius || 1;
+                    var theta = options.theta || 0;
+                    var phi = options.phi || 0;
+                    center = [].slice.call(center, 0, 3);
+                    up = [].slice.call(up, 0, 3);
+                    normalize3(up, up);
+                    right = [].slice.call(right, 0, 3);
+                    normalize3(right, right);
+                    if ("eye" in options) {
+                      var eye = options.eye;
+                      var toward = [
+                        eye[0] - center[0],
+                        eye[1] - center[1],
+                        eye[2] - center[2]
+                      ];
+                      cross2(right, toward, up);
+                      if (len3(right[0], right[1], right[2]) < 1e-6) {
+                        right = findOrthoPair(up);
+                      } else {
+                        normalize3(right, right);
+                      }
+                      radius = len3(toward[0], toward[1], toward[2]);
+                      var ut2 = dot3(up, toward) / radius;
+                      var rt2 = dot3(right, toward) / radius;
+                      phi = Math.acos(ut2);
+                      theta = Math.acos(rt2);
+                    }
+                    radius = Math.log(radius);
+                    return new TurntableController(
+                      options.zoomMin,
+                      options.zoomMax,
+                      center,
+                      up,
+                      right,
+                      radius,
+                      theta,
+                      phi
+                    );
+                  }
+                }
+              ),
+              /***/
+              7319: (
+                /***/
+                function(__unused_webpack_module, exports2, __webpack_require__2) {
+                  var glslify = __webpack_require__2(3236);
+                  var createShader = __webpack_require__2(9405);
+                  var vertSrc = glslify(["precision highp float;\n#define GLSLIFY 1\n\nattribute vec3 position, nextPosition;\nattribute float arcLength, lineWidth;\nattribute vec4 color;\n\nuniform vec2 screenShape;\nuniform float pixelRatio;\nuniform mat4 model, view, projection;\n\nvarying vec4 fragColor;\nvarying vec3 worldPosition;\nvarying float pixelArcLength;\n\nvec4 project(vec3 p) {\n  return projection * (view * (model * vec4(p, 1.0)));\n}\n\nvoid main() {\n  vec4 startPoint = project(position);\n  vec4 endPoint   = project(nextPosition);\n\n  vec2 A = startPoint.xy / startPoint.w;\n  vec2 B =   endPoint.xy /   endPoint.w;\n\n  float clipAngle = atan(\n    (B.y - A.y) * screenShape.y,\n    (B.x - A.x) * screenShape.x\n  );\n\n  vec2 offset = 0.5 * pixelRatio * lineWidth * vec2(\n    sin(clipAngle),\n    -cos(clipAngle)\n  ) / screenShape;\n\n  gl_Position = vec4(startPoint.xy + startPoint.w * offset, startPoint.zw);\n\n  worldPosition = position;\n  pixelArcLength = arcLength;\n  fragColor = color;\n}\n"]);
+                  var forwardFrag = glslify(["precision highp float;\n#define GLSLIFY 1\n\nbool outOfRange(float a, float b, float p) {\n  return ((p > max(a, b)) || \n          (p < min(a, b)));\n}\n\nbool outOfRange(vec2 a, vec2 b, vec2 p) {\n  return (outOfRange(a.x, b.x, p.x) ||\n          outOfRange(a.y, b.y, p.y));\n}\n\nbool outOfRange(vec3 a, vec3 b, vec3 p) {\n  return (outOfRange(a.x, b.x, p.x) ||\n          outOfRange(a.y, b.y, p.y) ||\n          outOfRange(a.z, b.z, p.z));\n}\n\nbool outOfRange(vec4 a, vec4 b, vec4 p) {\n  return outOfRange(a.xyz, b.xyz, p.xyz);\n}\n\nuniform vec3      clipBounds[2];\nuniform sampler2D dashTexture;\nuniform float     dashScale;\nuniform float     opacity;\n\nvarying vec3    worldPosition;\nvarying float   pixelArcLength;\nvarying vec4    fragColor;\n\nvoid main() {\n  if (\n    outOfRange(clipBounds[0], clipBounds[1], worldPosition) ||\n    fragColor.a * opacity == 0.\n  ) discard;\n\n  float dashWeight = texture2D(dashTexture, vec2(dashScale * pixelArcLength, 0)).r;\n  if(dashWeight < 0.5) {\n    discard;\n  }\n  gl_FragColor = fragColor * opacity;\n}\n"]);
+                  var pickFrag = glslify(["precision highp float;\n#define GLSLIFY 1\n\n#define FLOAT_MAX  1.70141184e38\n#define FLOAT_MIN  1.17549435e-38\n\n// https://github.com/mikolalysenko/glsl-read-float/blob/master/index.glsl\nvec4 packFloat(float v) {\n  float av = abs(v);\n\n  //Handle special cases\n  if(av < FLOAT_MIN) {\n    return vec4(0.0, 0.0, 0.0, 0.0);\n  } else if(v > FLOAT_MAX) {\n    return vec4(127.0, 128.0, 0.0, 0.0) / 255.0;\n  } else if(v < -FLOAT_MAX) {\n    return vec4(255.0, 128.0, 0.0, 0.0) / 255.0;\n  }\n\n  vec4 c = vec4(0,0,0,0);\n\n  //Compute exponent and mantissa\n  float e = floor(log2(av));\n  float m = av * pow(2.0, -e) - 1.0;\n\n  //Unpack mantissa\n  c[1] = floor(128.0 * m);\n  m -= c[1] / 128.0;\n  c[2] = floor(32768.0 * m);\n  m -= c[2] / 32768.0;\n  c[3] = floor(8388608.0 * m);\n\n  //Unpack exponent\n  float ebias = e + 127.0;\n  c[0] = floor(ebias / 2.0);\n  ebias -= c[0] * 2.0;\n  c[1] += floor(ebias) * 128.0;\n\n  //Unpack sign bit\n  c[0] += 128.0 * step(0.0, -v);\n\n  //Scale back to range\n  return c / 255.0;\n}\n\nbool outOfRange(float a, float b, float p) {\n  return ((p > max(a, b)) || \n          (p < min(a, b)));\n}\n\nbool outOfRange(vec2 a, vec2 b, vec2 p) {\n  return (outOfRange(a.x, b.x, p.x) ||\n          outOfRange(a.y, b.y, p.y));\n}\n\nbool outOfRange(vec3 a, vec3 b, vec3 p) {\n  return (outOfRange(a.x, b.x, p.x) ||\n          outOfRange(a.y, b.y, p.y) ||\n          outOfRange(a.z, b.z, p.z));\n}\n\nbool outOfRange(vec4 a, vec4 b, vec4 p) {\n  return outOfRange(a.xyz, b.xyz, p.xyz);\n}\n\nuniform float pickId;\nuniform vec3 clipBounds[2];\n\nvarying vec3 worldPosition;\nvarying float pixelArcLength;\nvarying vec4 fragColor;\n\nvoid main() {\n  if (outOfRange(clipBounds[0], clipBounds[1], worldPosition)) discard;\n\n  gl_FragColor = vec4(pickId/255.0, packFloat(pixelArcLength).xyz);\n}"]);
+                  var ATTRIBUTES = [
+                    { name: "position", type: "vec3" },
+                    { name: "nextPosition", type: "vec3" },
+                    { name: "arcLength", type: "float" },
+                    { name: "lineWidth", type: "float" },
+                    { name: "color", type: "vec4" }
+                  ];
+                  exports2.createShader = function(gl2) {
+                    return createShader(gl2, vertSrc, forwardFrag, null, ATTRIBUTES);
+                  };
+                  exports2.createPickShader = function(gl2) {
+                    return createShader(gl2, vertSrc, pickFrag, null, ATTRIBUTES);
+                  };
+                }
+              ),
+              /***/
+              7352: (
+                /***/
+                function(module22, __unused_webpack_exports, __webpack_require__2) {
+                  var convexHull1d = __webpack_require__2(5721);
+                  var convexHull2d = __webpack_require__2(4750);
+                  var convexHullnd = __webpack_require__2(2690);
+                  module22.exports = convexHull;
+                  function convexHull(points) {
+                    var n2 = points.length;
+                    if (n2 === 0) {
+                      return [];
+                    } else if (n2 === 1) {
+                      return [[0]];
+                    }
+                    var d2 = points[0].length;
+                    if (d2 === 0) {
+                      return [];
+                    } else if (d2 === 1) {
+                      return convexHull1d(points);
+                    } else if (d2 === 2) {
+                      return convexHull2d(points);
+                    }
+                    return convexHullnd(points, d2);
+                  }
+                }
+              ),
+              /***/
+              7399: (
+                /***/
+                function(module22) {
+                  module22.exports = fromQuat2;
+                  function fromQuat2(out, q2) {
+                    var x2 = q2[0], y2 = q2[1], z2 = q2[2], w2 = q2[3], x22 = x2 + x2, y22 = y2 + y2, z22 = z2 + z2, xx = x2 * x22, yx = y2 * x22, yy = y2 * y22, zx = z2 * x22, zy = z2 * y22, zz = z2 * z22, wx = w2 * x22, wy = w2 * y22, wz = w2 * z22;
+                    out[0] = 1 - yy - zz;
+                    out[1] = yx + wz;
+                    out[2] = zx - wy;
+                    out[3] = 0;
+                    out[4] = yx - wz;
+                    out[5] = 1 - xx - zz;
+                    out[6] = zy + wx;
+                    out[7] = 0;
+                    out[8] = zx + wy;
+                    out[9] = zy - wx;
+                    out[10] = 1 - xx - yy;
+                    out[11] = 0;
+                    out[12] = 0;
+                    out[13] = 0;
+                    out[14] = 0;
+                    out[15] = 1;
+                    return out;
+                  }
+                }
+              ),
+              /***/
+              7417: (
+                /***/
+                function(module22) {
+                  module22.exports = max;
+                  function max(out, a2, b2) {
+                    out[0] = Math.max(a2[0], b2[0]);
+                    out[1] = Math.max(a2[1], b2[1]);
+                    out[2] = Math.max(a2[2], b2[2]);
+                    return out;
+                  }
+                }
+              ),
+              /***/
+              7442: (
+                /***/
+                function(module22, __unused_webpack_exports, __webpack_require__2) {
+                  var lerp2 = __webpack_require__2(6658);
+                  var recompose = __webpack_require__2(7182);
+                  var decompose = __webpack_require__2(2652);
+                  var determinant2 = __webpack_require__2(9921);
+                  var slerp = __webpack_require__2(8648);
+                  var state0 = state();
+                  var state1 = state();
+                  var tmp2 = state();
+                  module22.exports = interpolate;
+                  function interpolate(out, start, end, alpha) {
+                    if (determinant2(start) === 0 || determinant2(end) === 0)
+                      return false;
+                    var r0 = decompose(start, state0.translate, state0.scale, state0.skew, state0.perspective, state0.quaternion);
+                    var r1 = decompose(end, state1.translate, state1.scale, state1.skew, state1.perspective, state1.quaternion);
+                    if (!r0 || !r1)
+                      return false;
+                    lerp2(tmp2.translate, state0.translate, state1.translate, alpha);
+                    lerp2(tmp2.skew, state0.skew, state1.skew, alpha);
+                    lerp2(tmp2.scale, state0.scale, state1.scale, alpha);
+                    lerp2(tmp2.perspective, state0.perspective, state1.perspective, alpha);
+                    slerp(tmp2.quaternion, state0.quaternion, state1.quaternion, alpha);
+                    recompose(out, tmp2.translate, tmp2.scale, tmp2.skew, tmp2.perspective, tmp2.quaternion);
+                    return true;
+                  }
+                  function state() {
+                    return {
+                      translate: vec3(),
+                      scale: vec3(1),
+                      skew: vec3(),
+                      perspective: vec4(),
+                      quaternion: vec4()
+                    };
+                  }
+                  function vec3(n2) {
+                    return [n2 || 0, n2 || 0, n2 || 0];
+                  }
+                  function vec4() {
+                    return [0, 0, 0, 1];
+                  }
+                }
+              ),
+              /***/
+              7507: (
+                /***/
+                function(__unused_webpack_module, exports2) {
+                  exports2.byteLength = byteLength;
+                  exports2.toByteArray = toByteArray;
+                  exports2.fromByteArray = fromByteArray;
+                  var lookup = [];
+                  var revLookup = [];
+                  var Arr = typeof Uint8Array !== "undefined" ? Uint8Array : Array;
+                  var code = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
+                  for (var i2 = 0, len2 = code.length; i2 < len2; ++i2) {
+                    lookup[i2] = code[i2];
+                    revLookup[code.charCodeAt(i2)] = i2;
+                  }
+                  revLookup["-".charCodeAt(0)] = 62;
+                  revLookup["_".charCodeAt(0)] = 63;
+                  function getLens(b64) {
+                    var len22 = b64.length;
+                    if (len22 % 4 > 0) {
+                      throw new Error("Invalid string. Length must be a multiple of 4");
+                    }
+                    var validLen = b64.indexOf("=");
+                    if (validLen === -1) validLen = len22;
+                    var placeHoldersLen = validLen === len22 ? 0 : 4 - validLen % 4;
+                    return [validLen, placeHoldersLen];
+                  }
+                  function byteLength(b64) {
+                    var lens = getLens(b64);
+                    var validLen = lens[0];
+                    var placeHoldersLen = lens[1];
+                    return (validLen + placeHoldersLen) * 3 / 4 - placeHoldersLen;
+                  }
+                  function _byteLength(b64, validLen, placeHoldersLen) {
+                    return (validLen + placeHoldersLen) * 3 / 4 - placeHoldersLen;
+                  }
+                  function toByteArray(b64) {
+                    var tmp2;
+                    var lens = getLens(b64);
+                    var validLen = lens[0];
+                    var placeHoldersLen = lens[1];
+                    var arr = new Arr(_byteLength(b64, validLen, placeHoldersLen));
+                    var curByte = 0;
+                    var len22 = placeHoldersLen > 0 ? validLen - 4 : validLen;
+                    var i22;
+                    for (i22 = 0; i22 < len22; i22 += 4) {
+                      tmp2 = revLookup[b64.charCodeAt(i22)] << 18 | revLookup[b64.charCodeAt(i22 + 1)] << 12 | revLookup[b64.charCodeAt(i22 + 2)] << 6 | revLookup[b64.charCodeAt(i22 + 3)];
+                      arr[curByte++] = tmp2 >> 16 & 255;
+                      arr[curByte++] = tmp2 >> 8 & 255;
+                      arr[curByte++] = tmp2 & 255;
+                    }
+                    if (placeHoldersLen === 2) {
+                      tmp2 = revLookup[b64.charCodeAt(i22)] << 2 | revLookup[b64.charCodeAt(i22 + 1)] >> 4;
+                      arr[curByte++] = tmp2 & 255;
+                    }
+                    if (placeHoldersLen === 1) {
+                      tmp2 = revLookup[b64.charCodeAt(i22)] << 10 | revLookup[b64.charCodeAt(i22 + 1)] << 4 | revLookup[b64.charCodeAt(i22 + 2)] >> 2;
+                      arr[curByte++] = tmp2 >> 8 & 255;
+                      arr[curByte++] = tmp2 & 255;
+                    }
+                    return arr;
+                  }
+                  function tripletToBase64(num) {
+                    return lookup[num >> 18 & 63] + lookup[num >> 12 & 63] + lookup[num >> 6 & 63] + lookup[num & 63];
+                  }
+                  function encodeChunk(uint8, start, end) {
+                    var tmp2;
+                    var output = [];
+                    for (var i22 = start; i22 < end; i22 += 3) {
+                      tmp2 = (uint8[i22] << 16 & 16711680) + (uint8[i22 + 1] << 8 & 65280) + (uint8[i22 + 2] & 255);
+                      output.push(tripletToBase64(tmp2));
+                    }
+                    return output.join("");
+                  }
+                  function fromByteArray(uint8) {
+                    var tmp2;
+                    var len22 = uint8.length;
+                    var extraBytes = len22 % 3;
+                    var parts = [];
+                    var maxChunkLength = 16383;
+                    for (var i22 = 0, len222 = len22 - extraBytes; i22 < len222; i22 += maxChunkLength) {
+                      parts.push(encodeChunk(uint8, i22, i22 + maxChunkLength > len222 ? len222 : i22 + maxChunkLength));
+                    }
+                    if (extraBytes === 1) {
+                      tmp2 = uint8[len22 - 1];
+                      parts.push(
+                        lookup[tmp2 >> 2] + lookup[tmp2 << 4 & 63] + "=="
+                      );
+                    } else if (extraBytes === 2) {
+                      tmp2 = (uint8[len22 - 2] << 8) + uint8[len22 - 1];
+                      parts.push(
+                        lookup[tmp2 >> 10] + lookup[tmp2 >> 4 & 63] + lookup[tmp2 << 2 & 63] + "="
+                      );
+                    }
+                    return parts.join("");
+                  }
+                }
+              ),
+              /***/
+              7518: (
+                /***/
+                function(module22, __unused_webpack_exports, __webpack_require__2) {
+                  var bindAttribs = __webpack_require__2(1433);
+                  function VertexAttribute(location2, dimension, a2, b2, c2, d2) {
+                    this.location = location2;
+                    this.dimension = dimension;
+                    this.a = a2;
+                    this.b = b2;
+                    this.c = c2;
+                    this.d = d2;
+                  }
+                  VertexAttribute.prototype.bind = function(gl2) {
+                    switch (this.dimension) {
+                      case 1:
+                        gl2.vertexAttrib1f(this.location, this.a);
+                        break;
+                      case 2:
+                        gl2.vertexAttrib2f(this.location, this.a, this.b);
+                        break;
+                      case 3:
+                        gl2.vertexAttrib3f(this.location, this.a, this.b, this.c);
+                        break;
+                      case 4:
+                        gl2.vertexAttrib4f(this.location, this.a, this.b, this.c, this.d);
+                        break;
+                    }
+                  };
+                  function VAONative(gl2, ext, handle) {
+                    this.gl = gl2;
+                    this._ext = ext;
+                    this.handle = handle;
+                    this._attribs = [];
+                    this._useElements = false;
+                    this._elementsType = gl2.UNSIGNED_SHORT;
+                  }
+                  VAONative.prototype.bind = function() {
+                    this._ext.bindVertexArrayOES(this.handle);
+                    for (var i2 = 0; i2 < this._attribs.length; ++i2) {
+                      this._attribs[i2].bind(this.gl);
+                    }
+                  };
+                  VAONative.prototype.unbind = function() {
+                    this._ext.bindVertexArrayOES(null);
+                  };
+                  VAONative.prototype.dispose = function() {
+                    this._ext.deleteVertexArrayOES(this.handle);
+                  };
+                  VAONative.prototype.update = function(attributes, elements, elementsType) {
+                    this.bind();
+                    bindAttribs(this.gl, elements, attributes);
+                    this.unbind();
+                    this._attribs.length = 0;
+                    if (attributes)
+                      for (var i2 = 0; i2 < attributes.length; ++i2) {
+                        var a2 = attributes[i2];
+                        if (typeof a2 === "number") {
+                          this._attribs.push(new VertexAttribute(i2, 1, a2));
+                        } else if (Array.isArray(a2)) {
+                          this._attribs.push(new VertexAttribute(i2, a2.length, a2[0], a2[1], a2[2], a2[3]));
+                        }
+                      }
+                    this._useElements = !!elements;
+                    this._elementsType = elementsType || this.gl.UNSIGNED_SHORT;
+                  };
+                  VAONative.prototype.draw = function(mode, count2, offset) {
+                    offset = offset || 0;
+                    var gl2 = this.gl;
+                    if (this._useElements) {
+                      gl2.drawElements(mode, count2, this._elementsType, offset);
+                    } else {
+                      gl2.drawArrays(mode, offset, count2);
+                    }
+                  };
+                  function createVAONative(gl2, ext) {
+                    return new VAONative(gl2, ext, ext.createVertexArrayOES());
+                  }
+                  module22.exports = createVAONative;
+                }
+              ),
+              /***/
+              7520: (
+                /***/
+                function(module22, __unused_webpack_exports, __webpack_require__2) {
+                  var isBrowser2 = __webpack_require__2(9507);
+                  function detect() {
+                    var supported = false;
+                    try {
+                      var opts = Object.defineProperty({}, "passive", {
+                        get: function() {
+                          supported = true;
+                        }
+                      });
+                      window.addEventListener("test", null, opts);
+                      window.removeEventListener("test", null, opts);
+                    } catch (e2) {
+                      supported = false;
+                    }
+                    return supported;
+                  }
+                  module22.exports = isBrowser2 && detect();
+                }
+              ),
+              /***/
+              7536: (
+                /***/
+                function(module22) {
+                  module22.exports = create2;
+                  function create2() {
+                    var out = new Float32Array(4);
+                    out[0] = 0;
+                    out[1] = 0;
+                    out[2] = 0;
+                    out[3] = 0;
+                    return out;
+                  }
+                }
+              ),
+              /***/
+              7608: (
+                /***/
+                function(module22) {
+                  module22.exports = invert2;
+                  function invert2(out, a2) {
+                    var a00 = a2[0], a01 = a2[1], a02 = a2[2], a03 = a2[3], a10 = a2[4], a11 = a2[5], a12 = a2[6], a13 = a2[7], a20 = a2[8], a21 = a2[9], a22 = a2[10], a23 = a2[11], a30 = a2[12], a31 = a2[13], a32 = a2[14], a33 = a2[15], b00 = a00 * a11 - a01 * a10, b01 = a00 * a12 - a02 * a10, b02 = a00 * a13 - a03 * a10, b03 = a01 * a12 - a02 * a11, b04 = a01 * a13 - a03 * a11, b05 = a02 * a13 - a03 * a12, b06 = a20 * a31 - a21 * a30, b07 = a20 * a32 - a22 * a30, b08 = a20 * a33 - a23 * a30, b09 = a21 * a32 - a22 * a31, b10 = a21 * a33 - a23 * a31, b11 = a22 * a33 - a23 * a32, det = b00 * b11 - b01 * b10 + b02 * b09 + b03 * b08 - b04 * b07 + b05 * b06;
+                    if (!det) {
+                      return null;
+                    }
+                    det = 1 / det;
+                    out[0] = (a11 * b11 - a12 * b10 + a13 * b09) * det;
+                    out[1] = (a02 * b10 - a01 * b11 - a03 * b09) * det;
+                    out[2] = (a31 * b05 - a32 * b04 + a33 * b03) * det;
+                    out[3] = (a22 * b04 - a21 * b05 - a23 * b03) * det;
+                    out[4] = (a12 * b08 - a10 * b11 - a13 * b07) * det;
+                    out[5] = (a00 * b11 - a02 * b08 + a03 * b07) * det;
+                    out[6] = (a32 * b02 - a30 * b05 - a33 * b01) * det;
+                    out[7] = (a20 * b05 - a22 * b02 + a23 * b01) * det;
+                    out[8] = (a10 * b10 - a11 * b08 + a13 * b06) * det;
+                    out[9] = (a01 * b08 - a00 * b10 - a03 * b06) * det;
+                    out[10] = (a30 * b04 - a31 * b02 + a33 * b00) * det;
+                    out[11] = (a21 * b02 - a20 * b04 - a23 * b00) * det;
+                    out[12] = (a11 * b07 - a10 * b09 - a12 * b06) * det;
+                    out[13] = (a00 * b09 - a01 * b07 + a02 * b06) * det;
+                    out[14] = (a31 * b01 - a30 * b03 - a32 * b00) * det;
+                    out[15] = (a20 * b03 - a21 * b01 + a22 * b00) * det;
+                    return out;
+                  }
+                }
+              ),
+              /***/
+              7626: (
+                /***/
+                function(module22, __unused_webpack_exports, __webpack_require__2) {
+                  var barycentric = __webpack_require__2(2642);
+                  var closestPointToTriangle = __webpack_require__2(9346);
+                  module22.exports = closestPointToPickLocation;
+                  function xformMatrix(m2, v2) {
+                    var out = [0, 0, 0, 0];
+                    for (var i2 = 0; i2 < 4; ++i2) {
+                      for (var j2 = 0; j2 < 4; ++j2) {
+                        out[j2] += m2[4 * i2 + j2] * v2[i2];
+                      }
+                    }
+                    return out;
+                  }
+                  function projectVertex(v2, model, view, projection, resolution) {
+                    var p2 = xformMatrix(
+                      projection,
+                      xformMatrix(
+                        view,
+                        xformMatrix(model, [v2[0], v2[1], v2[2], 1])
+                      )
+                    );
+                    for (var i2 = 0; i2 < 3; ++i2) {
+                      p2[i2] /= p2[3];
+                    }
+                    return [0.5 * resolution[0] * (1 + p2[0]), 0.5 * resolution[1] * (1 - p2[1])];
+                  }
+                  function barycentricCoord(simplex, point) {
+                    if (simplex.length === 2) {
+                      var d0 = 0;
+                      var d1 = 0;
+                      for (var i2 = 0; i2 < 2; ++i2) {
+                        d0 += Math.pow(point[i2] - simplex[0][i2], 2);
+                        d1 += Math.pow(point[i2] - simplex[1][i2], 2);
+                      }
+                      d0 = Math.sqrt(d0);
+                      d1 = Math.sqrt(d1);
+                      if (d0 + d1 < 1e-6) {
+                        return [1, 0];
+                      }
+                      return [d1 / (d0 + d1), d0 / (d1 + d0)];
+                    } else if (simplex.length === 3) {
+                      var closestPoint = [0, 0];
+                      closestPointToTriangle(simplex[0], simplex[1], simplex[2], point, closestPoint);
+                      return barycentric(simplex, closestPoint);
+                    }
+                    return [];
+                  }
+                  function interpolate(simplex, weights) {
+                    var result = [0, 0, 0];
+                    for (var i2 = 0; i2 < simplex.length; ++i2) {
+                      var p2 = simplex[i2];
+                      var w2 = weights[i2];
+                      for (var j2 = 0; j2 < 3; ++j2) {
+                        result[j2] += w2 * p2[j2];
+                      }
+                    }
+                    return result;
+                  }
+                  function closestPointToPickLocation(simplex, pixelCoord, model, view, projection, resolution) {
+                    if (simplex.length === 1) {
+                      return [0, simplex[0].slice()];
+                    }
+                    var simplex2D = new Array(simplex.length);
+                    for (var i2 = 0; i2 < simplex.length; ++i2) {
+                      simplex2D[i2] = projectVertex(simplex[i2], model, view, projection, resolution);
+                    }
+                    var closestIndex = 0;
+                    var closestDist = Infinity;
+                    for (var i2 = 0; i2 < simplex2D.length; ++i2) {
+                      var d2 = 0;
+                      for (var j2 = 0; j2 < 2; ++j2) {
+                        d2 += Math.pow(simplex2D[i2][j2] - pixelCoord[j2], 2);
+                      }
+                      if (d2 < closestDist) {
+                        closestDist = d2;
+                        closestIndex = i2;
+                      }
+                    }
+                    var weights = barycentricCoord(simplex2D, pixelCoord);
+                    var s2 = 0;
+                    for (var i2 = 0; i2 < 3; ++i2) {
+                      if (weights[i2] < -1e-3 || weights[i2] > 1.0001) {
+                        return null;
+                      }
+                      s2 += weights[i2];
+                    }
+                    if (Math.abs(s2 - 1) > 1e-3) {
+                      return null;
+                    }
+                    return [closestIndex, interpolate(simplex, weights), weights];
+                  }
+                }
+              ),
+              /***/
+              7636: (
+                /***/
+                function(module22) {
+                  module22.exports = random;
+                  function random(out, scale2) {
+                    scale2 = scale2 || 1;
+                    var r2 = Math.random() * 2 * Math.PI;
+                    var z2 = Math.random() * 2 - 1;
+                    var zScale = Math.sqrt(1 - z2 * z2) * scale2;
+                    out[0] = Math.cos(r2) * zScale;
+                    out[1] = Math.sin(r2) * zScale;
+                    out[2] = z2 * scale2;
+                    return out;
+                  }
+                }
+              ),
+              /***/
+              7640: (
+                /***/
+                function(module22, __unused_webpack_exports, __webpack_require__2) {
+                  var pool = __webpack_require__2(1888);
+                  function getMallocFree(dtype) {
+                    switch (dtype) {
+                      case "uint32":
+                        return [pool.mallocUint32, pool.freeUint32];
+                      default:
+                        return null;
+                    }
+                  }
+                  var CACHED_insertionSort = {
+                    "uint32,1,0": function(malloc, free) {
+                      return function ndarrayInsertionSort1d0uint32(left, right, data, offset, s0, s1, n0, n1, d1, e1, f1) {
+                        var i2, j2, cptr, ptr = left * s0 + offset, i1, scratch = malloc(n1), dptr, sptr, a2, b2;
+                        for (i2 = left + 1; i2 <= right; ++i2) {
+                          j2 = i2;
+                          ptr += s0;
+                          cptr = ptr;
+                          dptr = 0;
+                          sptr = ptr;
+                          for (i1 = 0; i1 < n1; ++i1) {
+                            scratch[dptr++] = data[sptr];
+                            sptr += d1;
+                          }
+                          __g: while (j2-- > left) {
+                            dptr = 0;
+                            sptr = cptr - s0;
+                            __l: for (i1 = 0; i1 < n1; ++i1) {
+                              a2 = data[sptr];
+                              b2 = scratch[dptr];
+                              if (a2 < b2) {
+                                break __g;
+                              }
+                              if (a2 > b2) {
+                                break __l;
+                              }
+                              sptr += e1;
+                              dptr += f1;
+                            }
+                            dptr = cptr;
+                            sptr = cptr - s0;
+                            for (i1 = 0; i1 < n1; ++i1) {
+                              data[dptr] = data[sptr];
+                              dptr += d1;
+                              sptr += d1;
+                            }
+                            cptr -= s0;
+                          }
+                          dptr = cptr;
+                          sptr = 0;
+                          for (i1 = 0; i1 < n1; ++i1) {
+                            data[dptr] = scratch[sptr++];
+                            dptr += d1;
+                          }
+                        }
+                        free(scratch);
+                      };
+                    }
+                  };
+                  function createInsertionSort(order, dtype) {
+                    var allocator = getMallocFree(dtype);
+                    var key = [dtype, order].join(",");
+                    var result = CACHED_insertionSort[key];
+                    if (allocator) {
+                      return result(allocator[0], allocator[1]);
+                    } else {
+                      return result();
+                    }
+                  }
+                  var CACHED_quickSort = {
+                    "uint32,1,0": function(insertionSort, malloc, free) {
+                      return function ndarrayQuickSort1d0uint32(left, right, data, offset, s0, s1, n0, n1, d1, e1, f1) {
+                        var sixth = (right - left + 1) / 6 | 0, index1 = left + sixth, index5 = right - sixth, index3 = left + right >> 1, index2 = index3 - sixth, index4 = index3 + sixth, el1 = index1, el2 = index2, el3 = index3, el4 = index4, el5 = index5, less = left + 1, great = right - 1, pivots_are_equal = true, tmp2, tmp0, x2, y2, z2, k2, ptr0, ptr1, ptr2, comp_pivot1 = 0, comp_pivot2 = 0, comp = 0, i1, b_ptr0, b_ptr1, b_ptr2, b_ptr3, b_ptr4, b_ptr5, b_ptr6, b_ptr7, ptr3, ptr4, ptr5, ptr6, ptr7, pivot_ptr, ptr_shift, elementSize = n1, pivot1 = malloc(elementSize), pivot2 = malloc(elementSize);
+                        b_ptr0 = s0 * el1;
+                        b_ptr1 = s0 * el2;
+                        ptr_shift = offset;
+                        __l1: for (i1 = 0; i1 < n1; ++i1) {
+                          ptr0 = b_ptr0 + ptr_shift;
+                          ptr1 = b_ptr1 + ptr_shift;
+                          comp = data[ptr0] - data[ptr1];
+                          if (comp > 0) {
+                            tmp0 = el1;
+                            el1 = el2;
+                            el2 = tmp0;
+                            break __l1;
+                          }
+                          if (comp < 0) {
+                            break __l1;
+                          }
+                          ptr_shift += e1;
+                        }
+                        b_ptr0 = s0 * el4;
+                        b_ptr1 = s0 * el5;
+                        ptr_shift = offset;
+                        __l2: for (i1 = 0; i1 < n1; ++i1) {
+                          ptr0 = b_ptr0 + ptr_shift;
+                          ptr1 = b_ptr1 + ptr_shift;
+                          comp = data[ptr0] - data[ptr1];
+                          if (comp > 0) {
+                            tmp0 = el4;
+                            el4 = el5;
+                            el5 = tmp0;
+                            break __l2;
+                          }
+                          if (comp < 0) {
+                            break __l2;
+                          }
+                          ptr_shift += e1;
+                        }
+                        b_ptr0 = s0 * el1;
+                        b_ptr1 = s0 * el3;
+                        ptr_shift = offset;
+                        __l3: for (i1 = 0; i1 < n1; ++i1) {
+                          ptr0 = b_ptr0 + ptr_shift;
+                          ptr1 = b_ptr1 + ptr_shift;
+                          comp = data[ptr0] - data[ptr1];
+                          if (comp > 0) {
+                            tmp0 = el1;
+                            el1 = el3;
+                            el3 = tmp0;
+                            break __l3;
+                          }
+                          if (comp < 0) {
+                            break __l3;
+                          }
+                          ptr_shift += e1;
+                        }
+                        b_ptr0 = s0 * el2;
+                        b_ptr1 = s0 * el3;
+                        ptr_shift = offset;
+                        __l4: for (i1 = 0; i1 < n1; ++i1) {
+                          ptr0 = b_ptr0 + ptr_shift;
+                          ptr1 = b_ptr1 + ptr_shift;
+                          comp = data[ptr0] - data[ptr1];
+                          if (comp > 0) {
+                            tmp0 = el2;
+                            el2 = el3;
+                            el3 = tmp0;
+                            break __l4;
+                          }
+                          if (comp < 0) {
+                            break __l4;
+                          }
+                          ptr_shift += e1;
+                        }
+                        b_ptr0 = s0 * el1;
+                        b_ptr1 = s0 * el4;
+                        ptr_shift = offset;
+                        __l5: for (i1 = 0; i1 < n1; ++i1) {
+                          ptr0 = b_ptr0 + ptr_shift;
+                          ptr1 = b_ptr1 + ptr_shift;
+                          comp = data[ptr0] - data[ptr1];
+                          if (comp > 0) {
+                            tmp0 = el1;
+                            el1 = el4;
+                            el4 = tmp0;
+                            break __l5;
+                          }
+                          if (comp < 0) {
+                            break __l5;
+                          }
+                          ptr_shift += e1;
+                        }
+                        b_ptr0 = s0 * el3;
+                        b_ptr1 = s0 * el4;
+                        ptr_shift = offset;
+                        __l6: for (i1 = 0; i1 < n1; ++i1) {
+                          ptr0 = b_ptr0 + ptr_shift;
+                          ptr1 = b_ptr1 + ptr_shift;
+                          comp = data[ptr0] - data[ptr1];
+                          if (comp > 0) {
+                            tmp0 = el3;
+                            el3 = el4;
+                            el4 = tmp0;
+                            break __l6;
+                          }
+                          if (comp < 0) {
+                            break __l6;
+                          }
+                          ptr_shift += e1;
+                        }
+                        b_ptr0 = s0 * el2;
+                        b_ptr1 = s0 * el5;
+                        ptr_shift = offset;
+                        __l7: for (i1 = 0; i1 < n1; ++i1) {
+                          ptr0 = b_ptr0 + ptr_shift;
+                          ptr1 = b_ptr1 + ptr_shift;
+                          comp = data[ptr0] - data[ptr1];
+                          if (comp > 0) {
+                            tmp0 = el2;
+                            el2 = el5;
+                            el5 = tmp0;
+                            break __l7;
+                          }
+                          if (comp < 0) {
+                            break __l7;
+                          }
+                          ptr_shift += e1;
+                        }
+                        b_ptr0 = s0 * el2;
+                        b_ptr1 = s0 * el3;
+                        ptr_shift = offset;
+                        __l8: for (i1 = 0; i1 < n1; ++i1) {
+                          ptr0 = b_ptr0 + ptr_shift;
+                          ptr1 = b_ptr1 + ptr_shift;
+                          comp = data[ptr0] - data[ptr1];
+                          if (comp > 0) {
+                            tmp0 = el2;
+                            el2 = el3;
+                            el3 = tmp0;
+                            break __l8;
+                          }
+                          if (comp < 0) {
+                            break __l8;
+                          }
+                          ptr_shift += e1;
+                        }
+                        b_ptr0 = s0 * el4;
+                        b_ptr1 = s0 * el5;
+                        ptr_shift = offset;
+                        __l9: for (i1 = 0; i1 < n1; ++i1) {
+                          ptr0 = b_ptr0 + ptr_shift;
+                          ptr1 = b_ptr1 + ptr_shift;
+                          comp = data[ptr0] - data[ptr1];
+                          if (comp > 0) {
+                            tmp0 = el4;
+                            el4 = el5;
+                            el5 = tmp0;
+                            break __l9;
+                          }
+                          if (comp < 0) {
+                            break __l9;
+                          }
+                          ptr_shift += e1;
+                        }
+                        b_ptr0 = s0 * el1;
+                        b_ptr1 = s0 * el2;
+                        b_ptr2 = s0 * el3;
+                        b_ptr3 = s0 * el4;
+                        b_ptr4 = s0 * el5;
+                        b_ptr5 = s0 * index1;
+                        b_ptr6 = s0 * index3;
+                        b_ptr7 = s0 * index5;
+                        pivot_ptr = 0;
+                        ptr_shift = offset;
+                        for (i1 = 0; i1 < n1; ++i1) {
+                          ptr0 = b_ptr0 + ptr_shift;
+                          ptr1 = b_ptr1 + ptr_shift;
+                          ptr2 = b_ptr2 + ptr_shift;
+                          ptr3 = b_ptr3 + ptr_shift;
+                          ptr4 = b_ptr4 + ptr_shift;
+                          ptr5 = b_ptr5 + ptr_shift;
+                          ptr6 = b_ptr6 + ptr_shift;
+                          ptr7 = b_ptr7 + ptr_shift;
+                          pivot1[pivot_ptr] = data[ptr1];
+                          pivot2[pivot_ptr] = data[ptr3];
+                          pivots_are_equal = pivots_are_equal && pivot1[pivot_ptr] === pivot2[pivot_ptr];
+                          x2 = data[ptr0];
+                          y2 = data[ptr2];
+                          z2 = data[ptr4];
+                          data[ptr5] = x2;
+                          data[ptr6] = y2;
+                          data[ptr7] = z2;
+                          ++pivot_ptr;
+                          ptr_shift += d1;
+                        }
+                        b_ptr0 = s0 * index2;
+                        b_ptr1 = s0 * left;
+                        ptr_shift = offset;
+                        for (i1 = 0; i1 < n1; ++i1) {
+                          ptr0 = b_ptr0 + ptr_shift;
+                          ptr1 = b_ptr1 + ptr_shift;
+                          data[ptr0] = data[ptr1];
+                          ptr_shift += d1;
+                        }
+                        b_ptr0 = s0 * index4;
+                        b_ptr1 = s0 * right;
+                        ptr_shift = offset;
+                        for (i1 = 0; i1 < n1; ++i1) {
+                          ptr0 = b_ptr0 + ptr_shift;
+                          ptr1 = b_ptr1 + ptr_shift;
+                          data[ptr0] = data[ptr1];
+                          ptr_shift += d1;
+                        }
+                        if (pivots_are_equal) {
+                          for (k2 = less; k2 <= great; ++k2) {
+                            ptr0 = offset + k2 * s0;
+                            pivot_ptr = 0;
+                            __l10: for (i1 = 0; i1 < n1; ++i1) {
+                              comp = data[ptr0] - pivot1[pivot_ptr];
+                              if (comp !== 0) {
+                                break __l10;
+                              }
+                              pivot_ptr += f1;
+                              ptr0 += e1;
+                            }
+                            if (comp === 0) {
+                              continue;
+                            }
+                            if (comp < 0) {
+                              if (k2 !== less) {
+                                b_ptr0 = s0 * k2;
+                                b_ptr1 = s0 * less;
+                                ptr_shift = offset;
+                                for (i1 = 0; i1 < n1; ++i1) {
+                                  ptr0 = b_ptr0 + ptr_shift;
+                                  ptr1 = b_ptr1 + ptr_shift;
+                                  tmp2 = data[ptr0];
+                                  data[ptr0] = data[ptr1];
+                                  data[ptr1] = tmp2;
+                                  ptr_shift += d1;
+                                }
+                              }
+                              ++less;
+                            } else {
+                              while (true) {
+                                ptr0 = offset + great * s0;
+                                pivot_ptr = 0;
+                                __l11: for (i1 = 0; i1 < n1; ++i1) {
+                                  comp = data[ptr0] - pivot1[pivot_ptr];
+                                  if (comp !== 0) {
+                                    break __l11;
+                                  }
+                                  pivot_ptr += f1;
+                                  ptr0 += e1;
+                                }
+                                if (comp > 0) {
+                                  great--;
+                                } else if (comp < 0) {
+                                  b_ptr0 = s0 * k2;
+                                  b_ptr1 = s0 * less;
+                                  b_ptr2 = s0 * great;
+                                  ptr_shift = offset;
+                                  for (i1 = 0; i1 < n1; ++i1) {
+                                    ptr0 = b_ptr0 + ptr_shift;
+                                    ptr1 = b_ptr1 + ptr_shift;
+                                    ptr2 = b_ptr2 + ptr_shift;
+                                    tmp2 = data[ptr0];
+                                    data[ptr0] = data[ptr1];
+                                    data[ptr1] = data[ptr2];
+                                    data[ptr2] = tmp2;
+                                    ptr_shift += d1;
+                                  }
+                                  ++less;
+                                  --great;
+                                  break;
+                                } else {
+                                  b_ptr0 = s0 * k2;
+                                  b_ptr1 = s0 * great;
+                                  ptr_shift = offset;
+                                  for (i1 = 0; i1 < n1; ++i1) {
+                                    ptr0 = b_ptr0 + ptr_shift;
+                                    ptr1 = b_ptr1 + ptr_shift;
+                                    tmp2 = data[ptr0];
+                                    data[ptr0] = data[ptr1];
+                                    data[ptr1] = tmp2;
+                                    ptr_shift += d1;
+                                  }
+                                  --great;
+                                  break;
+                                }
+                              }
+                            }
+                          }
+                        } else {
+                          for (k2 = less; k2 <= great; ++k2) {
+                            ptr0 = offset + k2 * s0;
+                            pivot_ptr = 0;
+                            __l12: for (i1 = 0; i1 < n1; ++i1) {
+                              comp_pivot1 = data[ptr0] - pivot1[pivot_ptr];
+                              if (comp_pivot1 !== 0) {
+                                break __l12;
+                              }
+                              pivot_ptr += f1;
+                              ptr0 += e1;
+                            }
+                            if (comp_pivot1 < 0) {
+                              if (k2 !== less) {
+                                b_ptr0 = s0 * k2;
+                                b_ptr1 = s0 * less;
+                                ptr_shift = offset;
+                                for (i1 = 0; i1 < n1; ++i1) {
+                                  ptr0 = b_ptr0 + ptr_shift;
+                                  ptr1 = b_ptr1 + ptr_shift;
+                                  tmp2 = data[ptr0];
+                                  data[ptr0] = data[ptr1];
+                                  data[ptr1] = tmp2;
+                                  ptr_shift += d1;
+                                }
+                              }
+                              ++less;
+                            } else {
+                              ptr0 = offset + k2 * s0;
+                              pivot_ptr = 0;
+                              __l13: for (i1 = 0; i1 < n1; ++i1) {
+                                comp_pivot2 = data[ptr0] - pivot2[pivot_ptr];
+                                if (comp_pivot2 !== 0) {
+                                  break __l13;
+                                }
+                                pivot_ptr += f1;
+                                ptr0 += e1;
+                              }
+                              if (comp_pivot2 > 0) {
+                                while (true) {
+                                  ptr0 = offset + great * s0;
+                                  pivot_ptr = 0;
+                                  __l14: for (i1 = 0; i1 < n1; ++i1) {
+                                    comp = data[ptr0] - pivot2[pivot_ptr];
+                                    if (comp !== 0) {
+                                      break __l14;
+                                    }
+                                    pivot_ptr += f1;
+                                    ptr0 += e1;
+                                  }
+                                  if (comp > 0) {
+                                    if (--great < k2) {
+                                      break;
+                                    }
+                                    continue;
+                                  } else {
+                                    ptr0 = offset + great * s0;
+                                    pivot_ptr = 0;
+                                    __l15: for (i1 = 0; i1 < n1; ++i1) {
+                                      comp = data[ptr0] - pivot1[pivot_ptr];
+                                      if (comp !== 0) {
+                                        break __l15;
+                                      }
+                                      pivot_ptr += f1;
+                                      ptr0 += e1;
+                                    }
+                                    if (comp < 0) {
+                                      b_ptr0 = s0 * k2;
+                                      b_ptr1 = s0 * less;
+                                      b_ptr2 = s0 * great;
+                                      ptr_shift = offset;
+                                      for (i1 = 0; i1 < n1; ++i1) {
+                                        ptr0 = b_ptr0 + ptr_shift;
+                                        ptr1 = b_ptr1 + ptr_shift;
+                                        ptr2 = b_ptr2 + ptr_shift;
+                                        tmp2 = data[ptr0];
+                                        data[ptr0] = data[ptr1];
+                                        data[ptr1] = data[ptr2];
+                                        data[ptr2] = tmp2;
+                                        ptr_shift += d1;
+                                      }
+                                      ++less;
+                                      --great;
+                                    } else {
+                                      b_ptr0 = s0 * k2;
+                                      b_ptr1 = s0 * great;
+                                      ptr_shift = offset;
+                                      for (i1 = 0; i1 < n1; ++i1) {
+                                        ptr0 = b_ptr0 + ptr_shift;
+                                        ptr1 = b_ptr1 + ptr_shift;
+                                        tmp2 = data[ptr0];
+                                        data[ptr0] = data[ptr1];
+                                        data[ptr1] = tmp2;
+                                        ptr_shift += d1;
+                                      }
+                                      --great;
+                                    }
+                                    break;
+                                  }
+                                }
+                              }
+                            }
+                          }
+                        }
+                        b_ptr0 = s0 * left;
+                        b_ptr1 = s0 * (less - 1);
+                        pivot_ptr = 0;
+                        ptr_shift = offset;
+                        for (i1 = 0; i1 < n1; ++i1) {
+                          ptr0 = b_ptr0 + ptr_shift;
+                          ptr1 = b_ptr1 + ptr_shift;
+                          data[ptr0] = data[ptr1];
+                          data[ptr1] = pivot1[pivot_ptr];
+                          ++pivot_ptr;
+                          ptr_shift += d1;
+                        }
+                        b_ptr0 = s0 * right;
+                        b_ptr1 = s0 * (great + 1);
+                        pivot_ptr = 0;
+                        ptr_shift = offset;
+                        for (i1 = 0; i1 < n1; ++i1) {
+                          ptr0 = b_ptr0 + ptr_shift;
+                          ptr1 = b_ptr1 + ptr_shift;
+                          data[ptr0] = data[ptr1];
+                          data[ptr1] = pivot2[pivot_ptr];
+                          ++pivot_ptr;
+                          ptr_shift += d1;
+                        }
+                        if (less - 2 - left <= 32) {
+                          insertionSort(left, less - 2, data, offset, s0, s1, n0, n1, d1, e1, f1);
+                        } else {
+                          ndarrayQuickSort1d0uint32(left, less - 2, data, offset, s0, s1, n0, n1, d1, e1, f1);
+                        }
+                        if (right - (great + 2) <= 32) {
+                          insertionSort(great + 2, right, data, offset, s0, s1, n0, n1, d1, e1, f1);
+                        } else {
+                          ndarrayQuickSort1d0uint32(great + 2, right, data, offset, s0, s1, n0, n1, d1, e1, f1);
+                        }
+                        if (pivots_are_equal) {
+                          free(pivot1);
+                          free(pivot2);
+                          return;
+                        }
+                        if (less < index1 && great > index5) {
+                          __l16: while (true) {
+                            ptr0 = offset + less * s0;
+                            pivot_ptr = 0;
+                            ptr_shift = offset;
+                            for (i1 = 0; i1 < n1; ++i1) {
+                              if (data[ptr0] !== pivot1[pivot_ptr]) {
+                                break __l16;
+                              }
+                              ++pivot_ptr;
+                              ptr0 += d1;
+                            }
+                            ++less;
+                          }
+                          __l17: while (true) {
+                            ptr0 = offset + great * s0;
+                            pivot_ptr = 0;
+                            ptr_shift = offset;
+                            for (i1 = 0; i1 < n1; ++i1) {
+                              if (data[ptr0] !== pivot2[pivot_ptr]) {
+                                break __l17;
+                              }
+                              ++pivot_ptr;
+                              ptr0 += d1;
+                            }
+                            --great;
+                          }
+                          for (k2 = less; k2 <= great; ++k2) {
+                            ptr0 = offset + k2 * s0;
+                            pivot_ptr = 0;
+                            __l18: for (i1 = 0; i1 < n1; ++i1) {
+                              comp_pivot1 = data[ptr0] - pivot1[pivot_ptr];
+                              if (comp_pivot1 !== 0) {
+                                break __l18;
+                              }
+                              pivot_ptr += f1;
+                              ptr0 += e1;
+                            }
+                            if (comp_pivot1 === 0) {
+                              if (k2 !== less) {
+                                b_ptr0 = s0 * k2;
+                                b_ptr1 = s0 * less;
+                                ptr_shift = offset;
+                                for (i1 = 0; i1 < n1; ++i1) {
+                                  ptr0 = b_ptr0 + ptr_shift;
+                                  ptr1 = b_ptr1 + ptr_shift;
+                                  tmp2 = data[ptr0];
+                                  data[ptr0] = data[ptr1];
+                                  data[ptr1] = tmp2;
+                                  ptr_shift += d1;
+                                }
+                              }
+                              ++less;
+                            } else {
+                              ptr0 = offset + k2 * s0;
+                              pivot_ptr = 0;
+                              __l19: for (i1 = 0; i1 < n1; ++i1) {
+                                comp_pivot2 = data[ptr0] - pivot2[pivot_ptr];
+                                if (comp_pivot2 !== 0) {
+                                  break __l19;
+                                }
+                                pivot_ptr += f1;
+                                ptr0 += e1;
+                              }
+                              if (comp_pivot2 === 0) {
+                                while (true) {
+                                  ptr0 = offset + great * s0;
+                                  pivot_ptr = 0;
+                                  __l20: for (i1 = 0; i1 < n1; ++i1) {
+                                    comp = data[ptr0] - pivot2[pivot_ptr];
+                                    if (comp !== 0) {
+                                      break __l20;
+                                    }
+                                    pivot_ptr += f1;
+                                    ptr0 += e1;
+                                  }
+                                  if (comp === 0) {
+                                    if (--great < k2) {
+                                      break;
+                                    }
+                                    continue;
+                                  } else {
+                                    ptr0 = offset + great * s0;
+                                    pivot_ptr = 0;
+                                    __l21: for (i1 = 0; i1 < n1; ++i1) {
+                                      comp = data[ptr0] - pivot1[pivot_ptr];
+                                      if (comp !== 0) {
+                                        break __l21;
+                                      }
+                                      pivot_ptr += f1;
+                                      ptr0 += e1;
+                                    }
+                                    if (comp < 0) {
+                                      b_ptr0 = s0 * k2;
+                                      b_ptr1 = s0 * less;
+                                      b_ptr2 = s0 * great;
+                                      ptr_shift = offset;
+                                      for (i1 = 0; i1 < n1; ++i1) {
+                                        ptr0 = b_ptr0 + ptr_shift;
+                                        ptr1 = b_ptr1 + ptr_shift;
+                                        ptr2 = b_ptr2 + ptr_shift;
+                                        tmp2 = data[ptr0];
+                                        data[ptr0] = data[ptr1];
+                                        data[ptr1] = data[ptr2];
+                                        data[ptr2] = tmp2;
+                                        ptr_shift += d1;
+                                      }
+                                      ++less;
+                                      --great;
+                                    } else {
+                                      b_ptr0 = s0 * k2;
+                                      b_ptr1 = s0 * great;
+                                      ptr_shift = offset;
+                                      for (i1 = 0; i1 < n1; ++i1) {
+                                        ptr0 = b_ptr0 + ptr_shift;
+                                        ptr1 = b_ptr1 + ptr_shift;
+                                        tmp2 = data[ptr0];
+                                        data[ptr0] = data[ptr1];
+                                        data[ptr1] = tmp2;
+                                        ptr_shift += d1;
+                                      }
+                                      --great;
+                                    }
+                                    break;
+                                  }
+                                }
+                              }
+                            }
+                          }
+                        }
+                        free(pivot1);
+                        free(pivot2);
+                        if (great - less <= 32) {
+                          insertionSort(less, great, data, offset, s0, s1, n0, n1, d1, e1, f1);
+                        } else {
+                          ndarrayQuickSort1d0uint32(less, great, data, offset, s0, s1, n0, n1, d1, e1, f1);
+                        }
+                      };
+                    }
+                  };
+                  function createQuickSort(order, dtype, insertionSort) {
+                    var allocator = getMallocFree(dtype);
+                    var key = [dtype, order].join(",");
+                    var result = CACHED_quickSort[key];
+                    if (order.length > 1 && allocator) {
+                      return result(insertionSort, allocator[0], allocator[1]);
+                    } else {
+                      return result(insertionSort);
+                    }
+                  }
+                  var CACHED_sort = {
+                    "uint32,1,0": function(insertionSort, quickSort) {
+                      return function(array) {
+                        var data = array.data, offset = array.offset | 0, shape = array.shape, stride = array.stride, s0 = stride[0] | 0, n0 = shape[0] | 0, s1 = stride[1] | 0, n1 = shape[1] | 0, d1 = s1, e1 = s1, f1 = 1;
+                        if (n0 <= 32) {
+                          insertionSort(0, n0 - 1, data, offset, s0, s1, n0, n1, d1, e1, f1);
+                        } else {
+                          quickSort(0, n0 - 1, data, offset, s0, s1, n0, n1, d1, e1, f1);
+                        }
+                      };
+                    }
+                  };
+                  function compileSort(order, dtype) {
+                    var key = [dtype, order].join(",");
+                    var result = CACHED_sort[key];
+                    var insertionSort = createInsertionSort(order, dtype);
+                    var quickSort = createQuickSort(order, dtype, insertionSort);
+                    return result(insertionSort, quickSort);
+                  }
+                  module22.exports = compileSort;
+                }
+              ),
+              /***/
+              7642: (
+                /***/
+                function(module22, __unused_webpack_exports, __webpack_require__2) {
+                  var ch2 = __webpack_require__2(8954);
+                  var uniq = __webpack_require__2(1682);
+                  module22.exports = triangulate;
+                  function LiftedPoint(p2, i2) {
+                    this.point = p2;
+                    this.index = i2;
+                  }
+                  function compareLifted(a2, b2) {
+                    var ap = a2.point;
+                    var bp = b2.point;
+                    var d2 = ap.length;
+                    for (var i2 = 0; i2 < d2; ++i2) {
+                      var s2 = bp[i2] - ap[i2];
+                      if (s2) {
+                        return s2;
+                      }
+                    }
+                    return 0;
+                  }
+                  function triangulate1D(n2, points, includePointAtInfinity) {
+                    if (n2 === 1) {
+                      if (includePointAtInfinity) {
+                        return [[-1, 0]];
+                      } else {
+                        return [];
+                      }
+                    }
+                    var lifted = points.map(function(p2, i22) {
+                      return [p2[0], i22];
+                    });
+                    lifted.sort(function(a22, b22) {
+                      return a22[0] - b22[0];
+                    });
+                    var cells = new Array(n2 - 1);
+                    for (var i2 = 1; i2 < n2; ++i2) {
+                      var a2 = lifted[i2 - 1];
+                      var b2 = lifted[i2];
+                      cells[i2 - 1] = [a2[1], b2[1]];
+                    }
+                    if (includePointAtInfinity) {
+                      cells.push(
+                        [-1, cells[0][1]],
+                        [cells[n2 - 1][1], -1]
+                      );
+                    }
+                    return cells;
+                  }
+                  function triangulate(points, includePointAtInfinity) {
+                    var n2 = points.length;
+                    if (n2 === 0) {
+                      return [];
+                    }
+                    var d2 = points[0].length;
+                    if (d2 < 1) {
+                      return [];
+                    }
+                    if (d2 === 1) {
+                      return triangulate1D(n2, points, includePointAtInfinity);
+                    }
+                    var lifted = new Array(n2);
+                    var upper = 1;
+                    for (var i2 = 0; i2 < n2; ++i2) {
+                      var p2 = points[i2];
+                      var x2 = new Array(d2 + 1);
+                      var l2 = 0;
+                      for (var j2 = 0; j2 < d2; ++j2) {
+                        var v2 = p2[j2];
+                        x2[j2] = v2;
+                        l2 += v2 * v2;
+                      }
+                      x2[d2] = l2;
+                      lifted[i2] = new LiftedPoint(x2, i2);
+                      upper = Math.max(l2, upper);
+                    }
+                    uniq(lifted, compareLifted);
+                    n2 = lifted.length;
+                    var dpoints = new Array(n2 + d2 + 1);
+                    var dindex = new Array(n2 + d2 + 1);
+                    var u2 = (d2 + 1) * (d2 + 1) * upper;
+                    var y2 = new Array(d2 + 1);
+                    for (var i2 = 0; i2 <= d2; ++i2) {
+                      y2[i2] = 0;
+                    }
+                    y2[d2] = u2;
+                    dpoints[0] = y2.slice();
+                    dindex[0] = -1;
+                    for (var i2 = 0; i2 <= d2; ++i2) {
+                      var x2 = y2.slice();
+                      x2[i2] = 1;
+                      dpoints[i2 + 1] = x2;
+                      dindex[i2 + 1] = -1;
+                    }
+                    for (var i2 = 0; i2 < n2; ++i2) {
+                      var h2 = lifted[i2];
+                      dpoints[i2 + d2 + 1] = h2.point;
+                      dindex[i2 + d2 + 1] = h2.index;
+                    }
+                    var hull = ch2(dpoints, false);
+                    if (includePointAtInfinity) {
+                      hull = hull.filter(function(cell) {
+                        var count2 = 0;
+                        for (var j22 = 0; j22 <= d2; ++j22) {
+                          var v22 = dindex[cell[j22]];
+                          if (v22 < 0) {
+                            if (++count2 >= 2) {
+                              return false;
+                            }
+                          }
+                          cell[j22] = v22;
+                        }
+                        return true;
+                      });
+                    } else {
+                      hull = hull.filter(function(cell) {
+                        for (var i22 = 0; i22 <= d2; ++i22) {
+                          var v22 = dindex[cell[i22]];
+                          if (v22 < 0) {
+                            return false;
+                          }
+                          cell[i22] = v22;
+                        }
+                        return true;
+                      });
+                    }
+                    if (d2 & 1) {
+                      for (var i2 = 0; i2 < hull.length; ++i2) {
+                        var h2 = hull[i2];
+                        var x2 = h2[0];
+                        h2[0] = h2[1];
+                        h2[1] = x2;
+                      }
+                    }
+                    return hull;
+                  }
+                }
+              ),
+              /***/
+              7656: (
+                /***/
+                function(module22) {
+                  module22.exports = translate2;
+                  function translate2(out, a2, v2) {
+                    var x2 = v2[0], y2 = v2[1], z2 = v2[2], a00, a01, a02, a03, a10, a11, a12, a13, a20, a21, a22, a23;
+                    if (a2 === out) {
+                      out[12] = a2[0] * x2 + a2[4] * y2 + a2[8] * z2 + a2[12];
+                      out[13] = a2[1] * x2 + a2[5] * y2 + a2[9] * z2 + a2[13];
+                      out[14] = a2[2] * x2 + a2[6] * y2 + a2[10] * z2 + a2[14];
+                      out[15] = a2[3] * x2 + a2[7] * y2 + a2[11] * z2 + a2[15];
+                    } else {
+                      a00 = a2[0];
+                      a01 = a2[1];
+                      a02 = a2[2];
+                      a03 = a2[3];
+                      a10 = a2[4];
+                      a11 = a2[5];
+                      a12 = a2[6];
+                      a13 = a2[7];
+                      a20 = a2[8];
+                      a21 = a2[9];
+                      a22 = a2[10];
+                      a23 = a2[11];
+                      out[0] = a00;
+                      out[1] = a01;
+                      out[2] = a02;
+                      out[3] = a03;
+                      out[4] = a10;
+                      out[5] = a11;
+                      out[6] = a12;
+                      out[7] = a13;
+                      out[8] = a20;
+                      out[9] = a21;
+                      out[10] = a22;
+                      out[11] = a23;
+                      out[12] = a00 * x2 + a10 * y2 + a20 * z2 + a2[12];
+                      out[13] = a01 * x2 + a11 * y2 + a21 * z2 + a2[13];
+                      out[14] = a02 * x2 + a12 * y2 + a22 * z2 + a2[14];
+                      out[15] = a03 * x2 + a13 * y2 + a23 * z2 + a2[15];
+                    }
+                    return out;
+                  }
+                }
+              ),
+              /***/
+              7718: (
+                /***/
+                function(module22, __unused_webpack_exports, __webpack_require__2) {
+                  module22.exports = vectorizeText;
+                  module22.exports.processPixels = processPixels;
+                  var surfaceNets = __webpack_require__2(3711);
+                  var ndarray = __webpack_require__2(9618);
+                  var simplify = __webpack_require__2(5878);
+                  var cleanPSLG = __webpack_require__2(332);
+                  var cdt2d = __webpack_require__2(2538);
+                  var toPolygonCrappy = __webpack_require__2(2095);
+                  var TAG_bold = "b";
+                  var CHR_bold = "b|";
+                  var TAG_italic = "i";
+                  var CHR_italic = "i|";
+                  var TAG_super = "sup";
+                  var CHR_super0 = "+";
+                  var CHR_super = "+1";
+                  var TAG_sub = "sub";
+                  var CHR_sub0 = "-";
+                  var CHR_sub = "-1";
+                  function parseTag(tag, TAG_CHR, str, map2) {
+                    var opnTag = "<" + tag + ">";
+                    var clsTag = "</" + tag + ">";
+                    var nOPN = opnTag.length;
+                    var nCLS = clsTag.length;
+                    var isRecursive = TAG_CHR[0] === CHR_super0 || TAG_CHR[0] === CHR_sub0;
+                    var a2 = 0;
+                    var b2 = -nCLS;
+                    while (a2 > -1) {
+                      a2 = str.indexOf(opnTag, a2);
+                      if (a2 === -1) break;
+                      b2 = str.indexOf(clsTag, a2 + nOPN);
+                      if (b2 === -1) break;
+                      if (b2 <= a2) break;
+                      for (var i2 = a2; i2 < b2 + nCLS; ++i2) {
+                        if (i2 < a2 + nOPN || i2 >= b2) {
+                          map2[i2] = null;
+                          str = str.substr(0, i2) + " " + str.substr(i2 + 1);
+                        } else {
+                          if (map2[i2] !== null) {
+                            var pos = map2[i2].indexOf(TAG_CHR[0]);
+                            if (pos === -1) {
+                              map2[i2] += TAG_CHR;
+                            } else {
+                              if (isRecursive) {
+                                map2[i2] = map2[i2].substr(0, pos + 1) + (1 + parseInt(map2[i2][pos + 1])) + map2[i2].substr(pos + 2);
+                              }
+                            }
+                          }
+                        }
+                      }
+                      var start = a2 + nOPN;
+                      var remainingStr = str.substr(start, b2 - start);
+                      var c2 = remainingStr.indexOf(opnTag);
+                      if (c2 !== -1) a2 = c2;
+                      else a2 = b2 + nCLS;
+                    }
+                    return map2;
+                  }
+                  function transformPositions(positions, options, size) {
+                    var align = options.textAlign || "start";
+                    var baseline = options.textBaseline || "alphabetic";
+                    var lo = [1 << 30, 1 << 30];
+                    var hi2 = [0, 0];
+                    var n2 = positions.length;
+                    for (var i2 = 0; i2 < n2; ++i2) {
+                      var p2 = positions[i2];
+                      for (var j2 = 0; j2 < 2; ++j2) {
+                        lo[j2] = Math.min(lo[j2], p2[j2]) | 0;
+                        hi2[j2] = Math.max(hi2[j2], p2[j2]) | 0;
+                      }
+                    }
+                    var xShift = 0;
+                    switch (align) {
+                      case "center":
+                        xShift = -0.5 * (lo[0] + hi2[0]);
+                        break;
+                      case "right":
+                      case "end":
+                        xShift = -hi2[0];
+                        break;
+                      case "left":
+                      case "start":
+                        xShift = -lo[0];
+                        break;
+                      default:
+                        throw new Error("vectorize-text: Unrecognized textAlign: '" + align + "'");
+                    }
+                    var yShift = 0;
+                    switch (baseline) {
+                      case "hanging":
+                      case "top":
+                        yShift = -lo[1];
+                        break;
+                      case "middle":
+                        yShift = -0.5 * (lo[1] + hi2[1]);
+                        break;
+                      case "alphabetic":
+                      case "ideographic":
+                        yShift = -3 * size;
+                        break;
+                      case "bottom":
+                        yShift = -hi2[1];
+                        break;
+                      default:
+                        throw new Error("vectorize-text: Unrecoginized textBaseline: '" + baseline + "'");
+                    }
+                    var scale2 = 1 / size;
+                    if ("lineHeight" in options) {
+                      scale2 *= +options.lineHeight;
+                    } else if ("width" in options) {
+                      scale2 = options.width / (hi2[0] - lo[0]);
+                    } else if ("height" in options) {
+                      scale2 = options.height / (hi2[1] - lo[1]);
+                    }
+                    return positions.map(function(p22) {
+                      return [scale2 * (p22[0] + xShift), scale2 * (p22[1] + yShift)];
+                    });
+                  }
+                  function getPixels(canvas2, context, rawString, fontSize, lineSpacing, styletags) {
+                    rawString = rawString.replace(/\n/g, "");
+                    if (styletags.breaklines === true) {
+                      rawString = rawString.replace(/\<br\>/g, "\n");
+                    } else {
+                      rawString = rawString.replace(/\<br\>/g, " ");
+                    }
+                    var activeStyle = "";
+                    var map2 = [];
+                    for (j2 = 0; j2 < rawString.length; ++j2) {
+                      map2[j2] = activeStyle;
+                    }
+                    if (styletags.bolds === true) map2 = parseTag(TAG_bold, CHR_bold, rawString, map2);
+                    if (styletags.italics === true) map2 = parseTag(TAG_italic, CHR_italic, rawString, map2);
+                    if (styletags.superscripts === true) map2 = parseTag(TAG_super, CHR_super, rawString, map2);
+                    if (styletags.subscripts === true) map2 = parseTag(TAG_sub, CHR_sub, rawString, map2);
+                    var allStyles = [];
+                    var plainText = "";
+                    for (j2 = 0; j2 < rawString.length; ++j2) {
+                      if (map2[j2] !== null) {
+                        plainText += rawString[j2];
+                        allStyles.push(map2[j2]);
+                      }
+                    }
+                    var allTexts = plainText.split("\n");
+                    var numberOfLines = allTexts.length;
+                    var lineHeight = Math.round(lineSpacing * fontSize);
+                    var offsetX = fontSize;
+                    var offsetY = fontSize * 2;
+                    var maxWidth = 0;
+                    var minHeight = numberOfLines * lineHeight + offsetY;
+                    if (canvas2.height < minHeight) {
+                      canvas2.height = minHeight;
+                    }
+                    context.fillStyle = "#000";
+                    context.fillRect(0, 0, canvas2.width, canvas2.height);
+                    context.fillStyle = "#fff";
+                    var i2, j2, xPos, yPos, zPos;
+                    var nDone = 0;
+                    var buffer = "";
+                    function writeBuffer() {
+                      if (buffer !== "") {
+                        var delta = context.measureText(buffer).width;
+                        context.fillText(buffer, offsetX + xPos, offsetY + yPos);
+                        xPos += delta;
+                      }
+                    }
+                    function getTextFontSize() {
+                      return "" + Math.round(zPos) + "px ";
+                    }
+                    function changeStyle(oldStyle, newStyle) {
+                      var ctxFont = "" + context.font;
+                      if (styletags.subscripts === true) {
+                        var oldIndex_Sub = oldStyle.indexOf(CHR_sub0);
+                        var newIndex_Sub = newStyle.indexOf(CHR_sub0);
+                        var oldSub = oldIndex_Sub > -1 ? parseInt(oldStyle[1 + oldIndex_Sub]) : 0;
+                        var newSub = newIndex_Sub > -1 ? parseInt(newStyle[1 + newIndex_Sub]) : 0;
+                        if (oldSub !== newSub) {
+                          ctxFont = ctxFont.replace(getTextFontSize(), "?px ");
+                          zPos *= Math.pow(0.75, newSub - oldSub);
+                          ctxFont = ctxFont.replace("?px ", getTextFontSize());
+                        }
+                        yPos += 0.25 * lineHeight * (newSub - oldSub);
+                      }
+                      if (styletags.superscripts === true) {
+                        var oldIndex_Super = oldStyle.indexOf(CHR_super0);
+                        var newIndex_Super = newStyle.indexOf(CHR_super0);
+                        var oldSuper = oldIndex_Super > -1 ? parseInt(oldStyle[1 + oldIndex_Super]) : 0;
+                        var newSuper = newIndex_Super > -1 ? parseInt(newStyle[1 + newIndex_Super]) : 0;
+                        if (oldSuper !== newSuper) {
+                          ctxFont = ctxFont.replace(getTextFontSize(), "?px ");
+                          zPos *= Math.pow(0.75, newSuper - oldSuper);
+                          ctxFont = ctxFont.replace("?px ", getTextFontSize());
+                        }
+                        yPos -= 0.25 * lineHeight * (newSuper - oldSuper);
+                      }
+                      if (styletags.bolds === true) {
+                        var wasBold = oldStyle.indexOf(CHR_bold) > -1;
+                        var is_Bold = newStyle.indexOf(CHR_bold) > -1;
+                        if (!wasBold && is_Bold) {
+                          if (wasItalic) {
+                            ctxFont = ctxFont.replace("italic ", "italic bold ");
+                          } else {
+                            ctxFont = "bold " + ctxFont;
+                          }
+                        }
+                        if (wasBold && !is_Bold) {
+                          ctxFont = ctxFont.replace("bold ", "");
+                        }
+                      }
+                      if (styletags.italics === true) {
+                        var wasItalic = oldStyle.indexOf(CHR_italic) > -1;
+                        var is_Italic = newStyle.indexOf(CHR_italic) > -1;
+                        if (!wasItalic && is_Italic) {
+                          ctxFont = "italic " + ctxFont;
+                        }
+                        if (wasItalic && !is_Italic) {
+                          ctxFont = ctxFont.replace("italic ", "");
+                        }
+                      }
+                      context.font = ctxFont;
+                    }
+                    for (i2 = 0; i2 < numberOfLines; ++i2) {
+                      var txt = allTexts[i2] + "\n";
+                      xPos = 0;
+                      yPos = i2 * lineHeight;
+                      zPos = fontSize;
+                      buffer = "";
+                      for (j2 = 0; j2 < txt.length; ++j2) {
+                        var style = j2 + nDone < allStyles.length ? allStyles[j2 + nDone] : allStyles[allStyles.length - 1];
+                        if (activeStyle === style) {
+                          buffer += txt[j2];
+                        } else {
+                          writeBuffer();
+                          buffer = txt[j2];
+                          if (style !== void 0) {
+                            changeStyle(activeStyle, style);
+                            activeStyle = style;
+                          }
+                        }
+                      }
+                      writeBuffer();
+                      nDone += txt.length;
+                      var width = Math.round(xPos + 2 * offsetX) | 0;
+                      if (maxWidth < width) maxWidth = width;
+                    }
+                    var xCut = maxWidth;
+                    var yCut = offsetY + lineHeight * numberOfLines;
+                    var pixels = ndarray(context.getImageData(0, 0, xCut, yCut).data, [yCut, xCut, 4]);
+                    return pixels.pick(-1, -1, 0).transpose(1, 0);
+                  }
+                  function getContour(pixels, doSimplify) {
+                    var contour = surfaceNets(pixels, 128);
+                    if (doSimplify) {
+                      return simplify(contour.cells, contour.positions, 0.25);
+                    }
+                    return {
+                      edges: contour.cells,
+                      positions: contour.positions
+                    };
+                  }
+                  function processPixelsImpl(pixels, options, size, simplify2) {
+                    var contour = getContour(pixels, simplify2);
+                    var positions = transformPositions(contour.positions, options, size);
+                    var edges = contour.edges;
+                    var flip = "ccw" === options.orientation;
+                    cleanPSLG(positions, edges);
+                    if (options.polygons || options.polygon || options.polyline) {
+                      var result = toPolygonCrappy(edges, positions);
+                      var nresult = new Array(result.length);
+                      for (var i2 = 0; i2 < result.length; ++i2) {
+                        var loops = result[i2];
+                        var nloops = new Array(loops.length);
+                        for (var j2 = 0; j2 < loops.length; ++j2) {
+                          var loop = loops[j2];
+                          var nloop = new Array(loop.length);
+                          for (var k2 = 0; k2 < loop.length; ++k2) {
+                            nloop[k2] = positions[loop[k2]].slice();
+                          }
+                          if (flip) {
+                            nloop.reverse();
+                          }
+                          nloops[j2] = nloop;
+                        }
+                        nresult[i2] = nloops;
+                      }
+                      return nresult;
+                    } else if (options.triangles || options.triangulate || options.triangle) {
+                      return {
+                        cells: cdt2d(positions, edges, {
+                          delaunay: false,
+                          exterior: false,
+                          interior: true
+                        }),
+                        positions
+                      };
+                    } else {
+                      return {
+                        edges,
+                        positions
+                      };
+                    }
+                  }
+                  function processPixels(pixels, options, size) {
+                    try {
+                      return processPixelsImpl(pixels, options, size, true);
+                    } catch (e2) {
+                    }
+                    try {
+                      return processPixelsImpl(pixels, options, size, false);
+                    } catch (e2) {
+                    }
+                    if (options.polygons || options.polyline || options.polygon) {
+                      return [];
+                    }
+                    if (options.triangles || options.triangulate || options.triangle) {
+                      return {
+                        cells: [],
+                        positions: []
+                      };
+                    }
+                    return {
+                      edges: [],
+                      positions: []
+                    };
+                  }
+                  function vectorizeText(str, canvas2, context, options) {
+                    var size = 64;
+                    var lineSpacing = 1.25;
+                    var styletags = {
+                      breaklines: false,
+                      bolds: false,
+                      italics: false,
+                      subscripts: false,
+                      superscripts: false
+                    };
+                    if (options) {
+                      if (options.size && options.size > 0) size = options.size;
+                      if (options.lineSpacing && options.lineSpacing > 0) lineSpacing = options.lineSpacing;
+                      if (options.styletags && options.styletags.breaklines) styletags.breaklines = options.styletags.breaklines ? true : false;
+                      if (options.styletags && options.styletags.bolds) styletags.bolds = options.styletags.bolds ? true : false;
+                      if (options.styletags && options.styletags.italics) styletags.italics = options.styletags.italics ? true : false;
+                      if (options.styletags && options.styletags.subscripts) styletags.subscripts = options.styletags.subscripts ? true : false;
+                      if (options.styletags && options.styletags.superscripts) styletags.superscripts = options.styletags.superscripts ? true : false;
+                    }
+                    context.font = [
+                      options.fontStyle,
+                      options.fontVariant,
+                      options.fontWeight,
+                      size + "px",
+                      options.font
+                    ].filter(function(d2) {
+                      return d2;
+                    }).join(" ");
+                    context.textAlign = "start";
+                    context.textBaseline = "alphabetic";
+                    context.direction = "ltr";
+                    var pixels = getPixels(canvas2, context, str, size, lineSpacing, styletags);
+                    return processPixels(pixels, options, size);
+                  }
+                }
+              ),
+              /***/
+              7721: (
+                /***/
+                function(module22, __unused_webpack_exports, __webpack_require__2) {
+                  var bnsign = __webpack_require__2(5716);
+                  module22.exports = sign;
+                  function sign(x2) {
+                    return bnsign(x2[0]) * bnsign(x2[1]);
+                  }
+                }
+              ),
+              /***/
+              7765: (
+                /***/
+                function(module22, __unused_webpack_exports, __webpack_require__2) {
+                  module22.exports = extractContour;
+                  var ndarray = __webpack_require__2(9618);
+                  var pool = __webpack_require__2(1888);
+                  var ndsort = __webpack_require__2(446);
+                  var contourAlgorithm = __webpack_require__2(1570);
+                  function getDimension(cells) {
+                    var numCells = cells.length;
+                    var d2 = 0;
+                    for (var i2 = 0; i2 < numCells; ++i2) {
+                      d2 = Math.max(d2, cells[i2].length) | 0;
+                    }
+                    return d2 - 1;
+                  }
+                  function getSigns(values, level) {
+                    var numVerts = values.length;
+                    var vertexSigns = pool.mallocUint8(numVerts);
+                    for (var i2 = 0; i2 < numVerts; ++i2) {
+                      vertexSigns[i2] = values[i2] < level | 0;
+                    }
+                    return vertexSigns;
+                  }
+                  function getEdges(cells, d2) {
+                    var numCells = cells.length;
+                    var maxEdges = d2 * (d2 + 1) / 2 * numCells | 0;
+                    var edges = pool.mallocUint32(maxEdges * 2);
+                    var ePtr = 0;
+                    for (var i2 = 0; i2 < numCells; ++i2) {
+                      var c2 = cells[i2];
+                      var d2 = c2.length;
+                      for (var j2 = 0; j2 < d2; ++j2) {
+                        for (var k2 = 0; k2 < j2; ++k2) {
+                          var a2 = c2[k2];
+                          var b2 = c2[j2];
+                          edges[ePtr++] = Math.min(a2, b2) | 0;
+                          edges[ePtr++] = Math.max(a2, b2) | 0;
+                        }
+                      }
+                    }
+                    var nedges = ePtr / 2 | 0;
+                    ndsort(ndarray(edges, [nedges, 2]));
+                    var ptr = 2;
+                    for (var i2 = 2; i2 < ePtr; i2 += 2) {
+                      if (edges[i2 - 2] === edges[i2] && edges[i2 - 1] === edges[i2 + 1]) {
+                        continue;
+                      }
+                      edges[ptr++] = edges[i2];
+                      edges[ptr++] = edges[i2 + 1];
+                    }
+                    return ndarray(edges, [ptr / 2 | 0, 2]);
+                  }
+                  function getCrossingWeights(edges, values, signs, level) {
+                    var edata = edges.data;
+                    var numEdges = edges.shape[0];
+                    var weights = pool.mallocDouble(numEdges);
+                    var ptr = 0;
+                    for (var i2 = 0; i2 < numEdges; ++i2) {
+                      var a2 = edata[2 * i2];
+                      var b2 = edata[2 * i2 + 1];
+                      if (signs[a2] === signs[b2]) {
+                        continue;
+                      }
+                      var va2 = values[a2];
+                      var vb2 = values[b2];
+                      edata[2 * ptr] = a2;
+                      edata[2 * ptr + 1] = b2;
+                      weights[ptr++] = (vb2 - level) / (vb2 - va2);
+                    }
+                    edges.shape[0] = ptr;
+                    return ndarray(weights, [ptr]);
+                  }
+                  function getCascade(edges, numVerts) {
+                    var result = pool.mallocInt32(numVerts * 2);
+                    var numEdges = edges.shape[0];
+                    var edata = edges.data;
+                    result[0] = 0;
+                    var lastV = 0;
+                    for (var i2 = 0; i2 < numEdges; ++i2) {
+                      var a2 = edata[2 * i2];
+                      if (a2 !== lastV) {
+                        result[2 * lastV + 1] = i2;
+                        while (++lastV < a2) {
+                          result[2 * lastV] = i2;
+                          result[2 * lastV + 1] = i2;
+                        }
+                        result[2 * lastV] = i2;
+                      }
+                    }
+                    result[2 * lastV + 1] = numEdges;
+                    while (++lastV < numVerts) {
+                      result[2 * lastV] = result[2 * lastV + 1] = numEdges;
+                    }
+                    return result;
+                  }
+                  function unpackEdges(edges) {
+                    var ne2 = edges.shape[0] | 0;
+                    var edata = edges.data;
+                    var result = new Array(ne2);
+                    for (var i2 = 0; i2 < ne2; ++i2) {
+                      result[i2] = [edata[2 * i2], edata[2 * i2 + 1]];
+                    }
+                    return result;
+                  }
+                  function extractContour(cells, values, level, d2) {
+                    level = level || 0;
+                    if (typeof d2 === "undefined") {
+                      d2 = getDimension(cells);
+                    }
+                    var numCells = cells.length;
+                    if (numCells === 0 || d2 < 1) {
+                      return {
+                        cells: [],
+                        vertexIds: [],
+                        vertexWeights: []
+                      };
+                    }
+                    var vertexSigns = getSigns(values, +level);
+                    var edges = getEdges(cells, d2);
+                    var weights = getCrossingWeights(edges, values, vertexSigns, +level);
+                    var vcascade = getCascade(edges, values.length | 0);
+                    var faces = contourAlgorithm(d2)(cells, edges.data, vcascade, vertexSigns);
+                    var uedges = unpackEdges(edges);
+                    var uweights = [].slice.call(weights.data, 0, weights.shape[0]);
+                    pool.free(vertexSigns);
+                    pool.free(edges.data);
+                    pool.free(weights.data);
+                    pool.free(vcascade);
+                    return {
+                      cells: faces,
+                      vertexIds: uedges,
+                      vertexWeights: uweights
+                    };
+                  }
+                }
+              ),
+              /***/
+              7766: (
+                /***/
+                function(module22, __unused_webpack_exports, __webpack_require__2) {
+                  var ndarray = __webpack_require__2(9618);
+                  var ops = __webpack_require__2(5298);
+                  var pool = __webpack_require__2(1888);
+                  module22.exports = createTexture2D;
+                  var linearTypes = null;
+                  var filterTypes = null;
+                  var wrapTypes = null;
+                  function lazyInitLinearTypes(gl2) {
+                    linearTypes = [
+                      gl2.LINEAR,
+                      gl2.NEAREST_MIPMAP_LINEAR,
+                      gl2.LINEAR_MIPMAP_NEAREST,
+                      gl2.LINEAR_MIPMAP_NEAREST
+                    ];
+                    filterTypes = [
+                      gl2.NEAREST,
+                      gl2.LINEAR,
+                      gl2.NEAREST_MIPMAP_NEAREST,
+                      gl2.NEAREST_MIPMAP_LINEAR,
+                      gl2.LINEAR_MIPMAP_NEAREST,
+                      gl2.LINEAR_MIPMAP_LINEAR
+                    ];
+                    wrapTypes = [
+                      gl2.REPEAT,
+                      gl2.CLAMP_TO_EDGE,
+                      gl2.MIRRORED_REPEAT
+                    ];
+                  }
+                  function acceptTextureDOM(obj) {
+                    return "undefined" != typeof HTMLCanvasElement && obj instanceof HTMLCanvasElement || "undefined" != typeof HTMLImageElement && obj instanceof HTMLImageElement || "undefined" != typeof HTMLVideoElement && obj instanceof HTMLVideoElement || "undefined" != typeof ImageData && obj instanceof ImageData;
+                  }
+                  var convertFloatToUint8 = function(out, inp) {
+                    ops.muls(out, inp, 255);
+                  };
+                  function reshapeTexture(tex, w2, h2) {
+                    var gl2 = tex.gl;
+                    var maxSize = gl2.getParameter(gl2.MAX_TEXTURE_SIZE);
+                    if (w2 < 0 || w2 > maxSize || h2 < 0 || h2 > maxSize) {
+                      throw new Error("gl-texture2d: Invalid texture size");
+                    }
+                    tex._shape = [w2, h2];
+                    tex.bind();
+                    gl2.texImage2D(gl2.TEXTURE_2D, 0, tex.format, w2, h2, 0, tex.format, tex.type, null);
+                    tex._mipLevels = [0];
+                    return tex;
+                  }
+                  function Texture2D(gl2, handle, width, height, format, type) {
+                    this.gl = gl2;
+                    this.handle = handle;
+                    this.format = format;
+                    this.type = type;
+                    this._shape = [width, height];
+                    this._mipLevels = [0];
+                    this._magFilter = gl2.NEAREST;
+                    this._minFilter = gl2.NEAREST;
+                    this._wrapS = gl2.CLAMP_TO_EDGE;
+                    this._wrapT = gl2.CLAMP_TO_EDGE;
+                    this._anisoSamples = 1;
+                    var parent = this;
+                    var wrapVector = [this._wrapS, this._wrapT];
+                    Object.defineProperties(wrapVector, [
+                      {
+                        get: function() {
+                          return parent._wrapS;
+                        },
+                        set: function(v2) {
+                          return parent.wrapS = v2;
+                        }
+                      },
+                      {
+                        get: function() {
+                          return parent._wrapT;
+                        },
+                        set: function(v2) {
+                          return parent.wrapT = v2;
+                        }
+                      }
+                    ]);
+                    this._wrapVector = wrapVector;
+                    var shapeVector = [this._shape[0], this._shape[1]];
+                    Object.defineProperties(shapeVector, [
+                      {
+                        get: function() {
+                          return parent._shape[0];
+                        },
+                        set: function(v2) {
+                          return parent.width = v2;
+                        }
+                      },
+                      {
+                        get: function() {
+                          return parent._shape[1];
+                        },
+                        set: function(v2) {
+                          return parent.height = v2;
+                        }
+                      }
+                    ]);
+                    this._shapeVector = shapeVector;
+                  }
+                  var proto = Texture2D.prototype;
+                  Object.defineProperties(proto, {
+                    minFilter: {
+                      get: function() {
+                        return this._minFilter;
+                      },
+                      set: function(v2) {
+                        this.bind();
+                        var gl2 = this.gl;
+                        if (this.type === gl2.FLOAT && linearTypes.indexOf(v2) >= 0) {
+                          if (!gl2.getExtension("OES_texture_float_linear")) {
+                            v2 = gl2.NEAREST;
+                          }
+                        }
+                        if (filterTypes.indexOf(v2) < 0) {
+                          throw new Error("gl-texture2d: Unknown filter mode " + v2);
+                        }
+                        gl2.texParameteri(gl2.TEXTURE_2D, gl2.TEXTURE_MIN_FILTER, v2);
+                        return this._minFilter = v2;
+                      }
+                    },
+                    magFilter: {
+                      get: function() {
+                        return this._magFilter;
+                      },
+                      set: function(v2) {
+                        this.bind();
+                        var gl2 = this.gl;
+                        if (this.type === gl2.FLOAT && linearTypes.indexOf(v2) >= 0) {
+                          if (!gl2.getExtension("OES_texture_float_linear")) {
+                            v2 = gl2.NEAREST;
+                          }
+                        }
+                        if (filterTypes.indexOf(v2) < 0) {
+                          throw new Error("gl-texture2d: Unknown filter mode " + v2);
+                        }
+                        gl2.texParameteri(gl2.TEXTURE_2D, gl2.TEXTURE_MAG_FILTER, v2);
+                        return this._magFilter = v2;
+                      }
+                    },
+                    mipSamples: {
+                      get: function() {
+                        return this._anisoSamples;
+                      },
+                      set: function(i2) {
+                        var psamples = this._anisoSamples;
+                        this._anisoSamples = Math.max(i2, 1) | 0;
+                        if (psamples !== this._anisoSamples) {
+                          var ext = this.gl.getExtension("EXT_texture_filter_anisotropic");
+                          if (ext) {
+                            this.gl.texParameterf(this.gl.TEXTURE_2D, ext.TEXTURE_MAX_ANISOTROPY_EXT, this._anisoSamples);
+                          }
+                        }
+                        return this._anisoSamples;
+                      }
+                    },
+                    wrapS: {
+                      get: function() {
+                        return this._wrapS;
+                      },
+                      set: function(v2) {
+                        this.bind();
+                        if (wrapTypes.indexOf(v2) < 0) {
+                          throw new Error("gl-texture2d: Unknown wrap mode " + v2);
+                        }
+                        this.gl.texParameteri(this.gl.TEXTURE_2D, this.gl.TEXTURE_WRAP_S, v2);
+                        return this._wrapS = v2;
+                      }
+                    },
+                    wrapT: {
+                      get: function() {
+                        return this._wrapT;
+                      },
+                      set: function(v2) {
+                        this.bind();
+                        if (wrapTypes.indexOf(v2) < 0) {
+                          throw new Error("gl-texture2d: Unknown wrap mode " + v2);
+                        }
+                        this.gl.texParameteri(this.gl.TEXTURE_2D, this.gl.TEXTURE_WRAP_T, v2);
+                        return this._wrapT = v2;
+                      }
+                    },
+                    wrap: {
+                      get: function() {
+                        return this._wrapVector;
+                      },
+                      set: function(v2) {
+                        if (!Array.isArray(v2)) {
+                          v2 = [v2, v2];
+                        }
+                        if (v2.length !== 2) {
+                          throw new Error("gl-texture2d: Must specify wrap mode for rows and columns");
+                        }
+                        for (var i2 = 0; i2 < 2; ++i2) {
+                          if (wrapTypes.indexOf(v2[i2]) < 0) {
+                            throw new Error("gl-texture2d: Unknown wrap mode " + v2);
+                          }
+                        }
+                        this._wrapS = v2[0];
+                        this._wrapT = v2[1];
+                        var gl2 = this.gl;
+                        this.bind();
+                        gl2.texParameteri(gl2.TEXTURE_2D, gl2.TEXTURE_WRAP_S, this._wrapS);
+                        gl2.texParameteri(gl2.TEXTURE_2D, gl2.TEXTURE_WRAP_T, this._wrapT);
+                        return v2;
+                      }
+                    },
+                    shape: {
+                      get: function() {
+                        return this._shapeVector;
+                      },
+                      set: function(x2) {
+                        if (!Array.isArray(x2)) {
+                          x2 = [x2 | 0, x2 | 0];
+                        } else {
+                          if (x2.length !== 2) {
+                            throw new Error("gl-texture2d: Invalid texture shape");
+                          }
+                        }
+                        reshapeTexture(this, x2[0] | 0, x2[1] | 0);
+                        return [x2[0] | 0, x2[1] | 0];
+                      }
+                    },
+                    width: {
+                      get: function() {
+                        return this._shape[0];
+                      },
+                      set: function(w2) {
+                        w2 = w2 | 0;
+                        reshapeTexture(this, w2, this._shape[1]);
+                        return w2;
+                      }
+                    },
+                    height: {
+                      get: function() {
+                        return this._shape[1];
+                      },
+                      set: function(h2) {
+                        h2 = h2 | 0;
+                        reshapeTexture(this, this._shape[0], h2);
+                        return h2;
+                      }
+                    }
+                  });
+                  proto.bind = function(unit) {
+                    var gl2 = this.gl;
+                    if (unit !== void 0) {
+                      gl2.activeTexture(gl2.TEXTURE0 + (unit | 0));
+                    }
+                    gl2.bindTexture(gl2.TEXTURE_2D, this.handle);
+                    if (unit !== void 0) {
+                      return unit | 0;
+                    }
+                    return gl2.getParameter(gl2.ACTIVE_TEXTURE) - gl2.TEXTURE0;
+                  };
+                  proto.dispose = function() {
+                    this.gl.deleteTexture(this.handle);
+                  };
+                  proto.generateMipmap = function() {
+                    this.bind();
+                    this.gl.generateMipmap(this.gl.TEXTURE_2D);
+                    var l2 = Math.min(this._shape[0], this._shape[1]);
+                    for (var i2 = 0; l2 > 0; ++i2, l2 >>>= 1) {
+                      if (this._mipLevels.indexOf(i2) < 0) {
+                        this._mipLevels.push(i2);
+                      }
+                    }
+                  };
+                  proto.setPixels = function(data, x_off, y_off, mip_level) {
+                    var gl2 = this.gl;
+                    this.bind();
+                    if (Array.isArray(x_off)) {
+                      mip_level = y_off;
+                      y_off = x_off[1] | 0;
+                      x_off = x_off[0] | 0;
+                    } else {
+                      x_off = x_off || 0;
+                      y_off = y_off || 0;
+                    }
+                    mip_level = mip_level || 0;
+                    var directData = acceptTextureDOM(data) ? data : data.raw;
+                    if (directData) {
+                      var needsMip = this._mipLevels.indexOf(mip_level) < 0;
+                      if (needsMip) {
+                        gl2.texImage2D(gl2.TEXTURE_2D, 0, this.format, this.format, this.type, directData);
+                        this._mipLevels.push(mip_level);
+                      } else {
+                        gl2.texSubImage2D(gl2.TEXTURE_2D, mip_level, x_off, y_off, this.format, this.type, directData);
+                      }
+                    } else if (data.shape && data.stride && data.data) {
+                      if (data.shape.length < 2 || x_off + data.shape[1] > this._shape[1] >>> mip_level || y_off + data.shape[0] > this._shape[0] >>> mip_level || x_off < 0 || y_off < 0) {
+                        throw new Error("gl-texture2d: Texture dimensions are out of bounds");
+                      }
+                      texSubImageArray(gl2, x_off, y_off, mip_level, this.format, this.type, this._mipLevels, data);
+                    } else {
+                      throw new Error("gl-texture2d: Unsupported data type");
+                    }
+                  };
+                  function isPacked(shape, stride) {
+                    if (shape.length === 3) {
+                      return stride[2] === 1 && stride[1] === shape[0] * shape[2] && stride[0] === shape[2];
+                    }
+                    return stride[0] === 1 && stride[1] === shape[0];
+                  }
+                  function texSubImageArray(gl2, x_off, y_off, mip_level, cformat, ctype, mipLevels, array) {
+                    var dtype = array.dtype;
+                    var shape = array.shape.slice();
+                    if (shape.length < 2 || shape.length > 3) {
+                      throw new Error("gl-texture2d: Invalid ndarray, must be 2d or 3d");
+                    }
+                    var type = 0, format = 0;
+                    var packed = isPacked(shape, array.stride.slice());
+                    if (dtype === "float32") {
+                      type = gl2.FLOAT;
+                    } else if (dtype === "float64") {
+                      type = gl2.FLOAT;
+                      packed = false;
+                      dtype = "float32";
+                    } else if (dtype === "uint8") {
+                      type = gl2.UNSIGNED_BYTE;
+                    } else {
+                      type = gl2.UNSIGNED_BYTE;
+                      packed = false;
+                      dtype = "uint8";
+                    }
+                    if (shape.length === 2) {
+                      format = gl2.LUMINANCE;
+                      shape = [shape[0], shape[1], 1];
+                      array = ndarray(array.data, shape, [array.stride[0], array.stride[1], 1], array.offset);
+                    } else if (shape.length === 3) {
+                      if (shape[2] === 1) {
+                        format = gl2.ALPHA;
+                      } else if (shape[2] === 2) {
+                        format = gl2.LUMINANCE_ALPHA;
+                      } else if (shape[2] === 3) {
+                        format = gl2.RGB;
+                      } else if (shape[2] === 4) {
+                        format = gl2.RGBA;
+                      } else {
+                        throw new Error("gl-texture2d: Invalid shape for pixel coords");
+                      }
+                      shape[2];
+                    } else {
+                      throw new Error("gl-texture2d: Invalid shape for texture");
+                    }
+                    if ((format === gl2.LUMINANCE || format === gl2.ALPHA) && (cformat === gl2.LUMINANCE || cformat === gl2.ALPHA)) {
+                      format = cformat;
+                    }
+                    if (format !== cformat) {
+                      throw new Error("gl-texture2d: Incompatible texture format for setPixels");
+                    }
+                    var size = array.size;
+                    var needsMip = mipLevels.indexOf(mip_level) < 0;
+                    if (needsMip) {
+                      mipLevels.push(mip_level);
+                    }
+                    if (type === ctype && packed) {
+                      if (array.offset === 0 && array.data.length === size) {
+                        if (needsMip) {
+                          gl2.texImage2D(gl2.TEXTURE_2D, mip_level, cformat, shape[0], shape[1], 0, cformat, ctype, array.data);
+                        } else {
+                          gl2.texSubImage2D(gl2.TEXTURE_2D, mip_level, x_off, y_off, shape[0], shape[1], cformat, ctype, array.data);
+                        }
+                      } else {
+                        if (needsMip) {
+                          gl2.texImage2D(gl2.TEXTURE_2D, mip_level, cformat, shape[0], shape[1], 0, cformat, ctype, array.data.subarray(array.offset, array.offset + size));
+                        } else {
+                          gl2.texSubImage2D(gl2.TEXTURE_2D, mip_level, x_off, y_off, shape[0], shape[1], cformat, ctype, array.data.subarray(array.offset, array.offset + size));
+                        }
+                      }
+                    } else {
+                      var pack_buffer;
+                      if (ctype === gl2.FLOAT) {
+                        pack_buffer = pool.mallocFloat32(size);
+                      } else {
+                        pack_buffer = pool.mallocUint8(size);
+                      }
+                      var pack_view = ndarray(pack_buffer, shape, [shape[2], shape[2] * shape[0], 1]);
+                      if (type === gl2.FLOAT && ctype === gl2.UNSIGNED_BYTE) {
+                        convertFloatToUint8(pack_view, array);
+                      } else {
+                        ops.assign(pack_view, array);
+                      }
+                      if (needsMip) {
+                        gl2.texImage2D(gl2.TEXTURE_2D, mip_level, cformat, shape[0], shape[1], 0, cformat, ctype, pack_buffer.subarray(0, size));
+                      } else {
+                        gl2.texSubImage2D(gl2.TEXTURE_2D, mip_level, x_off, y_off, shape[0], shape[1], cformat, ctype, pack_buffer.subarray(0, size));
+                      }
+                      if (ctype === gl2.FLOAT) {
+                        pool.freeFloat32(pack_buffer);
+                      } else {
+                        pool.freeUint8(pack_buffer);
+                      }
+                    }
+                  }
+                  function initTexture(gl2) {
+                    var tex = gl2.createTexture();
+                    gl2.bindTexture(gl2.TEXTURE_2D, tex);
+                    gl2.texParameteri(gl2.TEXTURE_2D, gl2.TEXTURE_MIN_FILTER, gl2.NEAREST);
+                    gl2.texParameteri(gl2.TEXTURE_2D, gl2.TEXTURE_MAG_FILTER, gl2.NEAREST);
+                    gl2.texParameteri(gl2.TEXTURE_2D, gl2.TEXTURE_WRAP_S, gl2.CLAMP_TO_EDGE);
+                    gl2.texParameteri(gl2.TEXTURE_2D, gl2.TEXTURE_WRAP_T, gl2.CLAMP_TO_EDGE);
+                    return tex;
+                  }
+                  function createTextureShape(gl2, width, height, format, type) {
+                    var maxTextureSize = gl2.getParameter(gl2.MAX_TEXTURE_SIZE);
+                    if (width < 0 || width > maxTextureSize || height < 0 || height > maxTextureSize) {
+                      throw new Error("gl-texture2d: Invalid texture shape");
+                    }
+                    if (type === gl2.FLOAT && !gl2.getExtension("OES_texture_float")) {
+                      throw new Error("gl-texture2d: Floating point textures not supported on this platform");
+                    }
+                    var tex = initTexture(gl2);
+                    gl2.texImage2D(gl2.TEXTURE_2D, 0, format, width, height, 0, format, type, null);
+                    return new Texture2D(gl2, tex, width, height, format, type);
+                  }
+                  function createTextureDOM(gl2, directData, width, height, format, type) {
+                    var tex = initTexture(gl2);
+                    gl2.texImage2D(gl2.TEXTURE_2D, 0, format, format, type, directData);
+                    return new Texture2D(gl2, tex, width, height, format, type);
+                  }
+                  function createTextureArray(gl2, array) {
+                    var dtype = array.dtype;
+                    var shape = array.shape.slice();
+                    var maxSize = gl2.getParameter(gl2.MAX_TEXTURE_SIZE);
+                    if (shape[0] < 0 || shape[0] > maxSize || shape[1] < 0 || shape[1] > maxSize) {
+                      throw new Error("gl-texture2d: Invalid texture size");
+                    }
+                    var packed = isPacked(shape, array.stride.slice());
+                    var type = 0;
+                    if (dtype === "float32") {
+                      type = gl2.FLOAT;
+                    } else if (dtype === "float64") {
+                      type = gl2.FLOAT;
+                      packed = false;
+                      dtype = "float32";
+                    } else if (dtype === "uint8") {
+                      type = gl2.UNSIGNED_BYTE;
+                    } else {
+                      type = gl2.UNSIGNED_BYTE;
+                      packed = false;
+                      dtype = "uint8";
+                    }
+                    var format = 0;
+                    if (shape.length === 2) {
+                      format = gl2.LUMINANCE;
+                      shape = [shape[0], shape[1], 1];
+                      array = ndarray(array.data, shape, [array.stride[0], array.stride[1], 1], array.offset);
+                    } else if (shape.length === 3) {
+                      if (shape[2] === 1) {
+                        format = gl2.ALPHA;
+                      } else if (shape[2] === 2) {
+                        format = gl2.LUMINANCE_ALPHA;
+                      } else if (shape[2] === 3) {
+                        format = gl2.RGB;
+                      } else if (shape[2] === 4) {
+                        format = gl2.RGBA;
+                      } else {
+                        throw new Error("gl-texture2d: Invalid shape for pixel coords");
+                      }
+                    } else {
+                      throw new Error("gl-texture2d: Invalid shape for texture");
+                    }
+                    if (type === gl2.FLOAT && !gl2.getExtension("OES_texture_float")) {
+                      type = gl2.UNSIGNED_BYTE;
+                      packed = false;
+                    }
+                    var buffer, buf_store;
+                    var size = array.size;
+                    if (!packed) {
+                      var stride = [shape[2], shape[2] * shape[0], 1];
+                      buf_store = pool.malloc(size, dtype);
+                      var buf_array = ndarray(buf_store, shape, stride, 0);
+                      if ((dtype === "float32" || dtype === "float64") && type === gl2.UNSIGNED_BYTE) {
+                        convertFloatToUint8(buf_array, array);
+                      } else {
+                        ops.assign(buf_array, array);
+                      }
+                      buffer = buf_store.subarray(0, size);
+                    } else if (array.offset === 0 && array.data.length === size) {
+                      buffer = array.data;
+                    } else {
+                      buffer = array.data.subarray(array.offset, array.offset + size);
+                    }
+                    var tex = initTexture(gl2);
+                    gl2.texImage2D(gl2.TEXTURE_2D, 0, format, shape[0], shape[1], 0, format, type, buffer);
+                    if (!packed) {
+                      pool.free(buf_store);
+                    }
+                    return new Texture2D(gl2, tex, shape[0], shape[1], format, type);
+                  }
+                  function createTexture2D(gl2) {
+                    if (arguments.length <= 1) {
+                      throw new Error("gl-texture2d: Missing arguments for texture2d constructor");
+                    }
+                    if (!linearTypes) {
+                      lazyInitLinearTypes(gl2);
+                    }
+                    if (typeof arguments[1] === "number") {
+                      return createTextureShape(gl2, arguments[1], arguments[2], arguments[3] || gl2.RGBA, arguments[4] || gl2.UNSIGNED_BYTE);
+                    }
+                    if (Array.isArray(arguments[1])) {
+                      return createTextureShape(gl2, arguments[1][0] | 0, arguments[1][1] | 0, arguments[2] || gl2.RGBA, arguments[3] || gl2.UNSIGNED_BYTE);
+                    }
+                    if (typeof arguments[1] === "object") {
+                      var obj = arguments[1];
+                      var directData = acceptTextureDOM(obj) ? obj : obj.raw;
+                      if (directData) {
+                        return createTextureDOM(gl2, directData, obj.width | 0, obj.height | 0, arguments[2] || gl2.RGBA, arguments[3] || gl2.UNSIGNED_BYTE);
+                      } else if (obj.shape && obj.data && obj.stride) {
+                        return createTextureArray(gl2, obj);
+                      }
+                    }
+                    throw new Error("gl-texture2d: Invalid arguments for texture2d constructor");
+                  }
+                }
+              ),
+              /***/
+              7790: (
+                /***/
+                function() {
+                }
+              ),
+              /***/
+              7815: (
+                /***/
+                function(module22, __unused_webpack_exports, __webpack_require__2) {
+                  var vec3 = __webpack_require__2(2931);
+                  var vec4 = __webpack_require__2(9970);
+                  var GRID_TYPES = ["xyz", "xzy", "yxz", "yzx", "zxy", "zyx"];
+                  var streamToTube = function(stream, maxDivergence, minDistance, maxNorm) {
+                    var points = stream.points;
+                    var velocities = stream.velocities;
+                    var divergences = stream.divergences;
+                    var verts = [];
+                    var faces = [];
+                    var vectors = [];
+                    var previousVerts = [];
+                    var currentVerts = [];
+                    var intensities = [];
+                    var previousIntensity = 0;
+                    var currentIntensity = 0;
+                    var currentVector = vec4.create();
+                    var previousVector = vec4.create();
+                    var facets = 8;
+                    for (var i2 = 0; i2 < points.length; i2++) {
+                      var p2 = points[i2];
+                      var fwd = velocities[i2];
+                      var r2 = divergences[i2];
+                      if (maxDivergence === 0) {
+                        r2 = minDistance * 0.05;
+                      }
+                      currentIntensity = vec3.length(fwd) / maxNorm;
+                      currentVector = vec4.create();
+                      vec3.copy(currentVector, fwd);
+                      currentVector[3] = r2;
+                      for (var a2 = 0; a2 < facets; a2++) {
+                        currentVerts[a2] = [p2[0], p2[1], p2[2], a2];
+                      }
+                      if (previousVerts.length > 0) {
+                        for (var a2 = 0; a2 < facets; a2++) {
+                          var a1 = (a2 + 1) % facets;
+                          verts.push(
+                            previousVerts[a2],
+                            currentVerts[a2],
+                            currentVerts[a1],
+                            currentVerts[a1],
+                            previousVerts[a1],
+                            previousVerts[a2]
+                          );
+                          vectors.push(
+                            previousVector,
+                            currentVector,
+                            currentVector,
+                            currentVector,
+                            previousVector,
+                            previousVector
+                          );
+                          intensities.push(
+                            previousIntensity,
+                            currentIntensity,
+                            currentIntensity,
+                            currentIntensity,
+                            previousIntensity,
+                            previousIntensity
+                          );
+                          var len2 = verts.length;
+                          faces.push(
+                            [len2 - 6, len2 - 5, len2 - 4],
+                            [len2 - 3, len2 - 2, len2 - 1]
+                          );
+                        }
+                      }
+                      var tmp1 = previousVerts;
+                      previousVerts = currentVerts;
+                      currentVerts = tmp1;
+                      var tmp2 = previousVector;
+                      previousVector = currentVector;
+                      currentVector = tmp2;
+                      var tmp3 = previousIntensity;
+                      previousIntensity = currentIntensity;
+                      currentIntensity = tmp3;
+                    }
+                    return {
+                      positions: verts,
+                      cells: faces,
+                      vectors,
+                      vertexIntensity: intensities
+                    };
+                  };
+                  var createTubes = function(streams, colormap, maxDivergence, minDistance) {
+                    var maxNorm = 0;
+                    for (var i2 = 0; i2 < streams.length; i2++) {
+                      var velocities = streams[i2].velocities;
+                      for (var j2 = 0; j2 < velocities.length; j2++) {
+                        maxNorm = Math.max(
+                          maxNorm,
+                          vec3.length(velocities[j2])
+                        );
+                      }
+                    }
+                    var tubes = streams.map(function(s2) {
+                      return streamToTube(s2, maxDivergence, minDistance, maxNorm);
+                    });
+                    var positions = [];
+                    var cells = [];
+                    var vectors = [];
+                    var vertexIntensity = [];
+                    for (var i2 = 0; i2 < tubes.length; i2++) {
+                      var tube = tubes[i2];
+                      var offset = positions.length;
+                      positions = positions.concat(tube.positions);
+                      vectors = vectors.concat(tube.vectors);
+                      vertexIntensity = vertexIntensity.concat(tube.vertexIntensity);
+                      for (var j2 = 0; j2 < tube.cells.length; j2++) {
+                        var cell = tube.cells[j2];
+                        var newCell = [];
+                        cells.push(newCell);
+                        for (var k2 = 0; k2 < cell.length; k2++) {
+                          newCell.push(cell[k2] + offset);
+                        }
+                      }
+                    }
+                    return {
+                      positions,
+                      cells,
+                      vectors,
+                      vertexIntensity,
+                      colormap
+                    };
+                  };
+                  var findLastSmallerIndex = function(points, v2) {
+                    var len2 = points.length;
+                    var i2;
+                    for (i2 = 0; i2 < len2; i2++) {
+                      var p2 = points[i2];
+                      if (p2 === v2) return i2;
+                      else if (p2 > v2) return i2 - 1;
+                    }
+                    return i2;
+                  };
+                  var clamp2 = function(v2, min, max) {
+                    return v2 < min ? min : v2 > max ? max : v2;
+                  };
+                  var sampleMeshgrid = function(point, vectorField, gridInfo) {
+                    var vectors = vectorField.vectors;
+                    var meshgrid = vectorField.meshgrid;
+                    var x2 = point[0];
+                    var y2 = point[1];
+                    var z2 = point[2];
+                    var w2 = meshgrid[0].length;
+                    var h2 = meshgrid[1].length;
+                    var d2 = meshgrid[2].length;
+                    var x0 = findLastSmallerIndex(meshgrid[0], x2);
+                    var y0 = findLastSmallerIndex(meshgrid[1], y2);
+                    var z0 = findLastSmallerIndex(meshgrid[2], z2);
+                    var x1 = x0 + 1;
+                    var y1 = y0 + 1;
+                    var z1 = z0 + 1;
+                    x0 = clamp2(x0, 0, w2 - 1);
+                    x1 = clamp2(x1, 0, w2 - 1);
+                    y0 = clamp2(y0, 0, h2 - 1);
+                    y1 = clamp2(y1, 0, h2 - 1);
+                    z0 = clamp2(z0, 0, d2 - 1);
+                    z1 = clamp2(z1, 0, d2 - 1);
+                    if (x0 < 0 || y0 < 0 || z0 < 0 || x1 > w2 - 1 || y1 > h2 - 1 || z1 > d2 - 1) {
+                      return vec3.create();
+                    }
+                    var mX0 = meshgrid[0][x0];
+                    var mX1 = meshgrid[0][x1];
+                    var mY0 = meshgrid[1][y0];
+                    var mY1 = meshgrid[1][y1];
+                    var mZ0 = meshgrid[2][z0];
+                    var mZ1 = meshgrid[2][z1];
+                    var xf2 = (x2 - mX0) / (mX1 - mX0);
+                    var yf2 = (y2 - mY0) / (mY1 - mY0);
+                    var zf2 = (z2 - mZ0) / (mZ1 - mZ0);
+                    if (!isFinite(xf2)) xf2 = 0.5;
+                    if (!isFinite(yf2)) yf2 = 0.5;
+                    if (!isFinite(zf2)) zf2 = 0.5;
+                    var x0off;
+                    var x1off;
+                    var y0off;
+                    var y1off;
+                    var z0off;
+                    var z1off;
+                    if (gridInfo.reversedX) {
+                      x0 = w2 - 1 - x0;
+                      x1 = w2 - 1 - x1;
+                    }
+                    if (gridInfo.reversedY) {
+                      y0 = h2 - 1 - y0;
+                      y1 = h2 - 1 - y1;
+                    }
+                    if (gridInfo.reversedZ) {
+                      z0 = d2 - 1 - z0;
+                      z1 = d2 - 1 - z1;
+                    }
+                    switch (gridInfo.filled) {
+                      case 5:
+                        z0off = z0;
+                        z1off = z1;
+                        y0off = y0 * d2;
+                        y1off = y1 * d2;
+                        x0off = x0 * d2 * h2;
+                        x1off = x1 * d2 * h2;
+                        break;
+                      case 4:
+                        z0off = z0;
+                        z1off = z1;
+                        x0off = x0 * d2;
+                        x1off = x1 * d2;
+                        y0off = y0 * d2 * w2;
+                        y1off = y1 * d2 * w2;
+                        break;
+                      case 3:
+                        y0off = y0;
+                        y1off = y1;
+                        z0off = z0 * h2;
+                        z1off = z1 * h2;
+                        x0off = x0 * h2 * d2;
+                        x1off = x1 * h2 * d2;
+                        break;
+                      case 2:
+                        y0off = y0;
+                        y1off = y1;
+                        x0off = x0 * h2;
+                        x1off = x1 * h2;
+                        z0off = z0 * h2 * w2;
+                        z1off = z1 * h2 * w2;
+                        break;
+                      case 1:
+                        x0off = x0;
+                        x1off = x1;
+                        z0off = z0 * w2;
+                        z1off = z1 * w2;
+                        y0off = y0 * w2 * d2;
+                        y1off = y1 * w2 * d2;
+                        break;
+                      default:
+                        x0off = x0;
+                        x1off = x1;
+                        y0off = y0 * w2;
+                        y1off = y1 * w2;
+                        z0off = z0 * w2 * h2;
+                        z1off = z1 * w2 * h2;
+                        break;
+                    }
+                    var v000 = vectors[x0off + y0off + z0off];
+                    var v001 = vectors[x0off + y0off + z1off];
+                    var v010 = vectors[x0off + y1off + z0off];
+                    var v011 = vectors[x0off + y1off + z1off];
+                    var v100 = vectors[x1off + y0off + z0off];
+                    var v101 = vectors[x1off + y0off + z1off];
+                    var v110 = vectors[x1off + y1off + z0off];
+                    var v111 = vectors[x1off + y1off + z1off];
+                    var c00 = vec3.create();
+                    var c01 = vec3.create();
+                    var c10 = vec3.create();
+                    var c11 = vec3.create();
+                    vec3.lerp(c00, v000, v100, xf2);
+                    vec3.lerp(c01, v001, v101, xf2);
+                    vec3.lerp(c10, v010, v110, xf2);
+                    vec3.lerp(c11, v011, v111, xf2);
+                    var c0 = vec3.create();
+                    var c1 = vec3.create();
+                    vec3.lerp(c0, c00, c10, yf2);
+                    vec3.lerp(c1, c01, c11, yf2);
+                    var c2 = vec3.create();
+                    vec3.lerp(c2, c0, c1, zf2);
+                    return c2;
+                  };
+                  var findMinSeparation = function(xs) {
+                    var minSeparation = Infinity;
+                    xs.sort(function(a2, b2) {
+                      return a2 - b2;
+                    });
+                    var len2 = xs.length;
+                    for (var i2 = 1; i2 < len2; i2++) {
+                      var d2 = Math.abs(xs[i2] - xs[i2 - 1]);
+                      if (d2 < minSeparation) {
+                        minSeparation = d2;
+                      }
+                    }
+                    return minSeparation;
+                  };
+                  var calculateMinPositionDistance = function(positions) {
+                    var xs = [], ys = [], zs = [];
+                    var xi2 = {}, yi2 = {}, zi2 = {};
+                    var len2 = positions.length;
+                    for (var i2 = 0; i2 < len2; i2++) {
+                      var p2 = positions[i2];
+                      var x2 = p2[0], y2 = p2[1], z2 = p2[2];
+                      if (!xi2[x2]) {
+                        xs.push(x2);
+                        xi2[x2] = true;
+                      }
+                      if (!yi2[y2]) {
+                        ys.push(y2);
+                        yi2[y2] = true;
+                      }
+                      if (!zi2[z2]) {
+                        zs.push(z2);
+                        zi2[z2] = true;
+                      }
+                    }
+                    var xSep = findMinSeparation(xs);
+                    var ySep = findMinSeparation(ys);
+                    var zSep = findMinSeparation(zs);
+                    var minSeparation = Math.min(xSep, ySep, zSep);
+                    return isFinite(minSeparation) ? minSeparation : 1;
+                  };
+                  module22.exports = function(vectorField, bounds) {
+                    var positions = vectorField.startingPositions;
+                    var maxLength = vectorField.maxLength || 1e3;
+                    var tubeSize = vectorField.tubeSize || 1;
+                    var absoluteTubeSize = vectorField.absoluteTubeSize;
+                    var gridFill = vectorField.gridFill || "+x+y+z";
+                    var gridInfo = {};
+                    if (gridFill.indexOf("-x") !== -1) {
+                      gridInfo.reversedX = true;
+                    }
+                    if (gridFill.indexOf("-y") !== -1) {
+                      gridInfo.reversedY = true;
+                    }
+                    if (gridFill.indexOf("-z") !== -1) {
+                      gridInfo.reversedZ = true;
+                    }
+                    gridInfo.filled = GRID_TYPES.indexOf(gridFill.replace(/-/g, "").replace(/\+/g, ""));
+                    var getVelocity2 = vectorField.getVelocity || function(p22) {
+                      return sampleMeshgrid(p22, vectorField, gridInfo);
+                    };
+                    var getDivergence = vectorField.getDivergence || function(p22, v0) {
+                      var dp = vec3.create();
+                      var e2 = 1e-4;
+                      vec3.add(dp, p22, [e2, 0, 0]);
+                      var vx = getVelocity2(dp);
+                      vec3.subtract(vx, vx, v0);
+                      vec3.scale(vx, vx, 1 / e2);
+                      vec3.add(dp, p22, [0, e2, 0]);
+                      var vy = getVelocity2(dp);
+                      vec3.subtract(vy, vy, v0);
+                      vec3.scale(vy, vy, 1 / e2);
+                      vec3.add(dp, p22, [0, 0, e2]);
+                      var vz = getVelocity2(dp);
+                      vec3.subtract(vz, vz, v0);
+                      vec3.scale(vz, vz, 1 / e2);
+                      vec3.add(dp, vx, vy);
+                      vec3.add(dp, dp, vz);
+                      return dp;
+                    };
+                    var streams = [];
+                    var minX = bounds[0][0], minY = bounds[0][1], minZ = bounds[0][2];
+                    var maxX = bounds[1][0], maxY = bounds[1][1], maxZ = bounds[1][2];
+                    var inBounds = function(p22) {
+                      var x2 = p22[0];
+                      var y2 = p22[1];
+                      var z2 = p22[2];
+                      return !(x2 < minX || x2 > maxX || y2 < minY || y2 > maxY || z2 < minZ || z2 > maxZ);
+                    };
+                    var boundsSize = vec3.distance(bounds[0], bounds[1]);
+                    var maxStepSize = 10 * boundsSize / maxLength;
+                    var maxStepSizeSq = maxStepSize * maxStepSize;
+                    var minDistance = 1;
+                    var maxDivergence = 0;
+                    var len2 = positions.length;
+                    if (len2 > 1) {
+                      minDistance = calculateMinPositionDistance(positions);
+                    }
+                    for (var i2 = 0; i2 < len2; i2++) {
+                      var p2 = vec3.create();
+                      vec3.copy(p2, positions[i2]);
+                      var stream = [p2];
+                      var velocities = [];
+                      var v2 = getVelocity2(p2);
+                      var op = p2;
+                      velocities.push(v2);
+                      var divergences = [];
+                      var dv = getDivergence(p2, v2);
+                      var dvLength = vec3.length(dv);
+                      if (isFinite(dvLength) && dvLength > maxDivergence) {
+                        maxDivergence = dvLength;
+                      }
+                      divergences.push(dvLength);
+                      streams.push({ points: stream, velocities, divergences });
+                      var j2 = 0;
+                      while (j2 < maxLength * 100 && stream.length < maxLength && inBounds(p2)) {
+                        j2++;
+                        var np = vec3.clone(v2);
+                        var sqLen = vec3.squaredLength(np);
+                        if (sqLen === 0) {
+                          break;
+                        } else if (sqLen > maxStepSizeSq) {
+                          vec3.scale(np, np, maxStepSize / Math.sqrt(sqLen));
+                        }
+                        vec3.add(np, np, p2);
+                        v2 = getVelocity2(np);
+                        if (vec3.squaredDistance(op, np) - maxStepSizeSq > -1e-4 * maxStepSizeSq) {
+                          stream.push(np);
+                          op = np;
+                          velocities.push(v2);
+                          var dv = getDivergence(np, v2);
+                          var dvLength = vec3.length(dv);
+                          if (isFinite(dvLength) && dvLength > maxDivergence) {
+                            maxDivergence = dvLength;
+                          }
+                          divergences.push(dvLength);
+                        }
+                        p2 = np;
+                      }
+                    }
+                    var tubes = createTubes(streams, vectorField.colormap, maxDivergence, minDistance);
+                    if (absoluteTubeSize) {
+                      tubes.tubeScale = absoluteTubeSize;
+                    } else {
+                      if (maxDivergence === 0) {
+                        maxDivergence = 1;
+                      }
+                      tubes.tubeScale = tubeSize * 0.5 * minDistance / maxDivergence;
+                    }
+                    return tubes;
+                  };
+                  var shaders = __webpack_require__2(6740);
+                  var createMesh = __webpack_require__2(6405).createMesh;
+                  module22.exports.createTubeMesh = function(gl2, params) {
+                    return createMesh(gl2, params, {
+                      shaders,
+                      traceType: "streamtube"
+                    });
+                  };
+                }
+              ),
+              /***/
+              7827: (
+                /***/
+                function(module22) {
+                  module22.exports = [
+                    "<<=",
+                    ">>=",
+                    "++",
+                    "--",
+                    "<<",
+                    ">>",
+                    "<=",
+                    ">=",
+                    "==",
+                    "!=",
+                    "&&",
+                    "||",
+                    "+=",
+                    "-=",
+                    "*=",
+                    "/=",
+                    "%=",
+                    "&=",
+                    "^^",
+                    "^=",
+                    "|=",
+                    "(",
+                    ")",
+                    "[",
+                    "]",
+                    ".",
+                    "!",
+                    "~",
+                    "*",
+                    "/",
+                    "%",
+                    "+",
+                    "-",
+                    "<",
+                    ">",
+                    "&",
+                    "^",
+                    "|",
+                    "?",
+                    ":",
+                    "=",
+                    ",",
+                    ";",
+                    "{",
+                    "}"
+                  ];
+                }
+              ),
+              /***/
+              7842: (
+                /***/
+                function(module22, __unused_webpack_exports, __webpack_require__2) {
+                  var isRat = __webpack_require__2(6330);
+                  var isBN = __webpack_require__2(1533);
+                  var num2bn = __webpack_require__2(2651);
+                  var str2bn = __webpack_require__2(6768);
+                  var rationalize = __webpack_require__2(869);
+                  var div = __webpack_require__2(8697);
+                  module22.exports = makeRational;
+                  function makeRational(numer, denom) {
+                    if (isRat(numer)) {
+                      if (denom) {
+                        return div(numer, makeRational(denom));
+                      }
+                      return [numer[0].clone(), numer[1].clone()];
+                    }
+                    var shift = 0;
+                    var a2, b2;
+                    if (isBN(numer)) {
+                      a2 = numer.clone();
+                    } else if (typeof numer === "string") {
+                      a2 = str2bn(numer);
+                    } else if (numer === 0) {
+                      return [num2bn(0), num2bn(1)];
+                    } else if (numer === Math.floor(numer)) {
+                      a2 = num2bn(numer);
+                    } else {
+                      while (numer !== Math.floor(numer)) {
+                        numer = numer * Math.pow(2, 256);
+                        shift -= 256;
+                      }
+                      a2 = num2bn(numer);
+                    }
+                    if (isRat(denom)) {
+                      a2.mul(denom[1]);
+                      b2 = denom[0].clone();
+                    } else if (isBN(denom)) {
+                      b2 = denom.clone();
+                    } else if (typeof denom === "string") {
+                      b2 = str2bn(denom);
+                    } else if (!denom) {
+                      b2 = num2bn(1);
+                    } else if (denom === Math.floor(denom)) {
+                      b2 = num2bn(denom);
+                    } else {
+                      while (denom !== Math.floor(denom)) {
+                        denom = denom * Math.pow(2, 256);
+                        shift += 256;
+                      }
+                      b2 = num2bn(denom);
+                    }
+                    if (shift > 0) {
+                      a2 = a2.ushln(shift);
+                    } else if (shift < 0) {
+                      b2 = b2.ushln(-shift);
+                    }
+                    return rationalize(a2, b2);
+                  }
+                }
+              ),
+              /***/
+              7894: (
+                /***/
+                function(module22) {
+                  module22.exports = identity22;
+                  function identity22(out) {
+                    out[0] = 1;
+                    out[1] = 0;
+                    out[2] = 0;
+                    out[3] = 0;
+                    out[4] = 0;
+                    out[5] = 1;
+                    out[6] = 0;
+                    out[7] = 0;
+                    out[8] = 0;
+                    out[9] = 0;
+                    out[10] = 1;
+                    out[11] = 0;
+                    out[12] = 0;
+                    out[13] = 0;
+                    out[14] = 0;
+                    out[15] = 1;
+                    return out;
+                  }
+                }
+              ),
+              /***/
+              7932: (
+                /***/
+                function(module22, __unused_webpack_exports, __webpack_require__2) {
+                  var v100 = __webpack_require__2(620);
+                  module22.exports = v100.slice().concat([
+                    "layout",
+                    "centroid",
+                    "smooth",
+                    "case",
+                    "mat2x2",
+                    "mat2x3",
+                    "mat2x4",
+                    "mat3x2",
+                    "mat3x3",
+                    "mat3x4",
+                    "mat4x2",
+                    "mat4x3",
+                    "mat4x4",
+                    "uvec2",
+                    "uvec3",
+                    "uvec4",
+                    "samplerCubeShadow",
+                    "sampler2DArray",
+                    "sampler2DArrayShadow",
+                    "isampler2D",
+                    "isampler3D",
+                    "isamplerCube",
+                    "isampler2DArray",
+                    "usampler2D",
+                    "usampler3D",
+                    "usamplerCube",
+                    "usampler2DArray",
+                    "coherent",
+                    "restrict",
+                    "readonly",
+                    "writeonly",
+                    "resource",
+                    "atomic_uint",
+                    "noperspective",
+                    "patch",
+                    "sample",
+                    "subroutine",
+                    "common",
+                    "partition",
+                    "active",
+                    "filter",
+                    "image1D",
+                    "image2D",
+                    "image3D",
+                    "imageCube",
+                    "iimage1D",
+                    "iimage2D",
+                    "iimage3D",
+                    "iimageCube",
+                    "uimage1D",
+                    "uimage2D",
+                    "uimage3D",
+                    "uimageCube",
+                    "image1DArray",
+                    "image2DArray",
+                    "iimage1DArray",
+                    "iimage2DArray",
+                    "uimage1DArray",
+                    "uimage2DArray",
+                    "image1DShadow",
+                    "image2DShadow",
+                    "image1DArrayShadow",
+                    "image2DArrayShadow",
+                    "imageBuffer",
+                    "iimageBuffer",
+                    "uimageBuffer",
+                    "sampler1DArray",
+                    "sampler1DArrayShadow",
+                    "isampler1D",
+                    "isampler1DArray",
+                    "usampler1D",
+                    "usampler1DArray",
+                    "isampler2DRect",
+                    "usampler2DRect",
+                    "samplerBuffer",
+                    "isamplerBuffer",
+                    "usamplerBuffer",
+                    "sampler2DMS",
+                    "isampler2DMS",
+                    "usampler2DMS",
+                    "sampler2DMSArray",
+                    "isampler2DMSArray",
+                    "usampler2DMSArray"
+                  ]);
+                }
+              ),
+              /***/
+              7960: (
+                /***/
+                function(module22) {
+                  module22.exports = squaredDistance;
+                  function squaredDistance(a2, b2) {
+                    var x2 = b2[0] - a2[0], y2 = b2[1] - a2[1], z2 = b2[2] - a2[2], w2 = b2[3] - a2[3];
+                    return x2 * x2 + y2 * y2 + z2 * z2 + w2 * w2;
+                  }
+                }
+              ),
+              /***/
+              8105: (
+                /***/
+                function(module22) {
+                  module22.exports = genPartition;
+                  var P2F = {
+                    "lo===p0": lo_equal_p0,
+                    "lo<p0": lo_lessThan_p0,
+                    "lo<=p0": lo_lessOrEqual_p0,
+                    "hi<=p0": hi_lessOrEqual_p0,
+                    "lo<p0&&p0<=hi": lo_lessThan_p0_and_p0_lessOrEqual_hi,
+                    "lo<=p0&&p0<=hi": lo_lassOrEqual_p0_and_p0_lessOrEqual_hi,
+                    "!(lo>=p0)&&!(p1>=hi)": lo_lessThan_p0_and_p1_lessThan_hi
+                  };
+                  function genPartition(predicate) {
+                    return P2F[predicate];
+                  }
+                  function lo_equal_p0(a2, b2, c2, d2, e2, f2, p0) {
+                    for (var j2 = 2 * a2, k2 = j2 * c2, l2 = k2, m2 = c2, n2 = b2, o2 = a2 + b2, p2 = c2; d2 > p2; ++p2, k2 += j2) {
+                      var lo = e2[k2 + n2];
+                      if (lo === p0) if (m2 === p2) m2 += 1, l2 += j2;
+                      else {
+                        for (var s2 = 0; j2 > s2; ++s2) {
+                          var t4 = e2[k2 + s2];
+                          e2[k2 + s2] = e2[l2], e2[l2++] = t4;
+                        }
+                        var u2 = f2[p2];
+                        f2[p2] = f2[m2], f2[m2++] = u2;
+                      }
+                    }
+                    return m2;
+                  }
+                  function lo_lessThan_p0(a2, b2, c2, d2, e2, f2, p0) {
+                    for (var j2 = 2 * a2, k2 = j2 * c2, l2 = k2, m2 = c2, n2 = b2, o2 = a2 + b2, p2 = c2; d2 > p2; ++p2, k2 += j2) {
+                      var lo = e2[k2 + n2];
+                      if (lo < p0) if (m2 === p2) m2 += 1, l2 += j2;
+                      else {
+                        for (var s2 = 0; j2 > s2; ++s2) {
+                          var t4 = e2[k2 + s2];
+                          e2[k2 + s2] = e2[l2], e2[l2++] = t4;
+                        }
+                        var u2 = f2[p2];
+                        f2[p2] = f2[m2], f2[m2++] = u2;
+                      }
+                    }
+                    return m2;
+                  }
+                  function lo_lessOrEqual_p0(a2, b2, c2, d2, e2, f2, p0) {
+                    for (var j2 = 2 * a2, k2 = j2 * c2, l2 = k2, m2 = c2, n2 = b2, o2 = a2 + b2, p2 = c2; d2 > p2; ++p2, k2 += j2) {
+                      var hi2 = e2[k2 + o2];
+                      if (hi2 <= p0) if (m2 === p2) m2 += 1, l2 += j2;
+                      else {
+                        for (var s2 = 0; j2 > s2; ++s2) {
+                          var t4 = e2[k2 + s2];
+                          e2[k2 + s2] = e2[l2], e2[l2++] = t4;
+                        }
+                        var u2 = f2[p2];
+                        f2[p2] = f2[m2], f2[m2++] = u2;
+                      }
+                    }
+                    return m2;
+                  }
+                  function hi_lessOrEqual_p0(a2, b2, c2, d2, e2, f2, p0) {
+                    for (var j2 = 2 * a2, k2 = j2 * c2, l2 = k2, m2 = c2, n2 = b2, o2 = a2 + b2, p2 = c2; d2 > p2; ++p2, k2 += j2) {
+                      var hi2 = e2[k2 + o2];
+                      if (hi2 <= p0) if (m2 === p2) m2 += 1, l2 += j2;
+                      else {
+                        for (var s2 = 0; j2 > s2; ++s2) {
+                          var t4 = e2[k2 + s2];
+                          e2[k2 + s2] = e2[l2], e2[l2++] = t4;
+                        }
+                        var u2 = f2[p2];
+                        f2[p2] = f2[m2], f2[m2++] = u2;
+                      }
+                    }
+                    return m2;
+                  }
+                  function lo_lassOrEqual_p0_and_p0_lessOrEqual_hi(a2, b2, c2, d2, e2, f2, p0) {
+                    for (var j2 = 2 * a2, k2 = j2 * c2, l2 = k2, m2 = c2, n2 = b2, o2 = a2 + b2, p2 = c2; d2 > p2; ++p2, k2 += j2) {
+                      var lo = e2[k2 + n2], hi2 = e2[k2 + o2];
+                      if (lo <= p0 && p0 <= hi2) if (m2 === p2) m2 += 1, l2 += j2;
+                      else {
+                        for (var s2 = 0; j2 > s2; ++s2) {
+                          var t4 = e2[k2 + s2];
+                          e2[k2 + s2] = e2[l2], e2[l2++] = t4;
+                        }
+                        var u2 = f2[p2];
+                        f2[p2] = f2[m2], f2[m2++] = u2;
+                      }
+                    }
+                    return m2;
+                  }
+                  function lo_lessThan_p0_and_p0_lessOrEqual_hi(a2, b2, c2, d2, e2, f2, p0) {
+                    for (var j2 = 2 * a2, k2 = j2 * c2, l2 = k2, m2 = c2, n2 = b2, o2 = a2 + b2, p2 = c2; d2 > p2; ++p2, k2 += j2) {
+                      var lo = e2[k2 + n2], hi2 = e2[k2 + o2];
+                      if (lo < p0 && p0 <= hi2) if (m2 === p2) m2 += 1, l2 += j2;
+                      else {
+                        for (var s2 = 0; j2 > s2; ++s2) {
+                          var t4 = e2[k2 + s2];
+                          e2[k2 + s2] = e2[l2], e2[l2++] = t4;
+                        }
+                        var u2 = f2[p2];
+                        f2[p2] = f2[m2], f2[m2++] = u2;
+                      }
+                    }
+                    return m2;
+                  }
+                  function lo_lessThan_p0_and_p1_lessThan_hi(a2, b2, c2, d2, e2, f2, p0, p1) {
+                    for (var j2 = 2 * a2, k2 = j2 * c2, l2 = k2, m2 = c2, n2 = b2, o2 = a2 + b2, p2 = c2; d2 > p2; ++p2, k2 += j2) {
+                      var lo = e2[k2 + n2], hi2 = e2[k2 + o2];
+                      if (!(lo >= p0) && !(p1 >= hi2)) if (m2 === p2) m2 += 1, l2 += j2;
+                      else {
+                        for (var s2 = 0; j2 > s2; ++s2) {
+                          var t4 = e2[k2 + s2];
+                          e2[k2 + s2] = e2[l2], e2[l2++] = t4;
+                        }
+                        var u2 = f2[p2];
+                        f2[p2] = f2[m2], f2[m2++] = u2;
+                      }
+                    }
+                    return m2;
+                  }
+                }
+              ),
+              /***/
+              8107: (
+                /***/
+                function(module22) {
+                  module22.exports = min;
+                  function min(out, a2, b2) {
+                    out[0] = Math.min(a2[0], b2[0]);
+                    out[1] = Math.min(a2[1], b2[1]);
+                    out[2] = Math.min(a2[2], b2[2]);
+                    return out;
+                  }
+                }
+              ),
+              /***/
+              8116: (
+                /***/
+                function(module22, __unused_webpack_exports, __webpack_require__2) {
+                  var createVAONative = __webpack_require__2(7518);
+                  var createVAOEmulated = __webpack_require__2(870);
+                  function ExtensionShim(gl2) {
+                    this.bindVertexArrayOES = gl2.bindVertexArray.bind(gl2);
+                    this.createVertexArrayOES = gl2.createVertexArray.bind(gl2);
+                    this.deleteVertexArrayOES = gl2.deleteVertexArray.bind(gl2);
+                  }
+                  function createVAO(gl2, attributes, elements, elementsType) {
+                    var ext = gl2.createVertexArray ? new ExtensionShim(gl2) : gl2.getExtension("OES_vertex_array_object");
+                    var vao;
+                    if (ext) {
+                      vao = createVAONative(gl2, ext);
+                    } else {
+                      vao = createVAOEmulated(gl2);
+                    }
+                    vao.update(attributes, elements, elementsType);
+                    return vao;
+                  }
+                  module22.exports = createVAO;
+                }
+              ),
+              /***/
+              8192: (
+                /***/
+                function(module22, __unused_webpack_exports, __webpack_require__2) {
+                  module22.exports = angle2;
+                  var fromValues = __webpack_require__2(2825);
+                  var normalize = __webpack_require__2(3536);
+                  var dot2 = __webpack_require__2(244);
+                  function angle2(a2, b2) {
+                    var tempA = fromValues(a2[0], a2[1], a2[2]);
+                    var tempB = fromValues(b2[0], b2[1], b2[2]);
+                    normalize(tempA, tempA);
+                    normalize(tempB, tempB);
+                    var cosine = dot2(tempA, tempB);
+                    if (cosine > 1) {
+                      return 0;
+                    } else {
+                      return Math.acos(cosine);
+                    }
+                  }
+                }
+              ),
+              /***/
+              8210: (
+                /***/
+                function(module22) {
+                  module22.exports = linearExpansionSum;
+                  function scalarScalar(a2, b2) {
+                    var x2 = a2 + b2;
+                    var bv = x2 - a2;
+                    var av = x2 - bv;
+                    var br = b2 - bv;
+                    var ar = a2 - av;
+                    var y2 = ar + br;
+                    if (y2) {
+                      return [y2, x2];
+                    }
+                    return [x2];
+                  }
+                  function linearExpansionSum(e2, f2) {
+                    var ne2 = e2.length | 0;
+                    var nf2 = f2.length | 0;
+                    if (ne2 === 1 && nf2 === 1) {
+                      return scalarScalar(e2[0], f2[0]);
+                    }
+                    var n2 = ne2 + nf2;
+                    var g2 = new Array(n2);
+                    var count2 = 0;
+                    var eptr = 0;
+                    var fptr = 0;
+                    var abs = Math.abs;
+                    var ei2 = e2[eptr];
+                    var ea2 = abs(ei2);
+                    var fi2 = f2[fptr];
+                    var fa2 = abs(fi2);
+                    var a2, b2;
+                    if (ea2 < fa2) {
+                      b2 = ei2;
+                      eptr += 1;
+                      if (eptr < ne2) {
+                        ei2 = e2[eptr];
+                        ea2 = abs(ei2);
+                      }
+                    } else {
+                      b2 = fi2;
+                      fptr += 1;
+                      if (fptr < nf2) {
+                        fi2 = f2[fptr];
+                        fa2 = abs(fi2);
+                      }
+                    }
+                    if (eptr < ne2 && ea2 < fa2 || fptr >= nf2) {
+                      a2 = ei2;
+                      eptr += 1;
+                      if (eptr < ne2) {
+                        ei2 = e2[eptr];
+                        ea2 = abs(ei2);
+                      }
+                    } else {
+                      a2 = fi2;
+                      fptr += 1;
+                      if (fptr < nf2) {
+                        fi2 = f2[fptr];
+                        fa2 = abs(fi2);
+                      }
+                    }
+                    var x2 = a2 + b2;
+                    var bv = x2 - a2;
+                    var y2 = b2 - bv;
+                    var q0 = y2;
+                    var q1 = x2;
+                    var _x2, _bv, _av, _br, _ar;
+                    while (eptr < ne2 && fptr < nf2) {
+                      if (ea2 < fa2) {
+                        a2 = ei2;
+                        eptr += 1;
+                        if (eptr < ne2) {
+                          ei2 = e2[eptr];
+                          ea2 = abs(ei2);
+                        }
+                      } else {
+                        a2 = fi2;
+                        fptr += 1;
+                        if (fptr < nf2) {
+                          fi2 = f2[fptr];
+                          fa2 = abs(fi2);
+                        }
+                      }
+                      b2 = q0;
+                      x2 = a2 + b2;
+                      bv = x2 - a2;
+                      y2 = b2 - bv;
+                      if (y2) {
+                        g2[count2++] = y2;
+                      }
+                      _x2 = q1 + x2;
+                      _bv = _x2 - q1;
+                      _av = _x2 - _bv;
+                      _br = x2 - _bv;
+                      _ar = q1 - _av;
+                      q0 = _ar + _br;
+                      q1 = _x2;
+                    }
+                    while (eptr < ne2) {
+                      a2 = ei2;
+                      b2 = q0;
+                      x2 = a2 + b2;
+                      bv = x2 - a2;
+                      y2 = b2 - bv;
+                      if (y2) {
+                        g2[count2++] = y2;
+                      }
+                      _x2 = q1 + x2;
+                      _bv = _x2 - q1;
+                      _av = _x2 - _bv;
+                      _br = x2 - _bv;
+                      _ar = q1 - _av;
+                      q0 = _ar + _br;
+                      q1 = _x2;
+                      eptr += 1;
+                      if (eptr < ne2) {
+                        ei2 = e2[eptr];
+                      }
+                    }
+                    while (fptr < nf2) {
+                      a2 = fi2;
+                      b2 = q0;
+                      x2 = a2 + b2;
+                      bv = x2 - a2;
+                      y2 = b2 - bv;
+                      if (y2) {
+                        g2[count2++] = y2;
+                      }
+                      _x2 = q1 + x2;
+                      _bv = _x2 - q1;
+                      _av = _x2 - _bv;
+                      _br = x2 - _bv;
+                      _ar = q1 - _av;
+                      q0 = _ar + _br;
+                      q1 = _x2;
+                      fptr += 1;
+                      if (fptr < nf2) {
+                        fi2 = f2[fptr];
+                      }
+                    }
+                    if (q0) {
+                      g2[count2++] = q0;
+                    }
+                    if (q1) {
+                      g2[count2++] = q1;
+                    }
+                    if (!count2) {
+                      g2[count2++] = 0;
+                    }
+                    g2.length = count2;
+                    return g2;
+                  }
+                }
+              ),
+              /***/
+              8277: (
+                /***/
+                function(module22) {
+                  function CwiseOp() {
+                    return function(SS, a0, t02, p0, Y0) {
+                      var s0 = SS[0], s1 = SS[1], s2 = SS[2], t0p0 = t02[0], t0p1 = t02[1], t0p2 = t02[2], index = [0, 0, 0];
+                      p0 |= 0;
+                      var i0 = 0, i1 = 0, i2 = 0, d0s0 = t0p2, d0s1 = t0p1 - s2 * t0p2, d0s2 = t0p0 - s1 * t0p1;
+                      for (i2 = 0; i2 < s0; ++i2) {
+                        for (i1 = 0; i1 < s1; ++i1) {
+                          for (i0 = 0; i0 < s2; ++i0) {
+                            {
+                              var _inline_1_v = Y0, _inline_1_i;
+                              for (_inline_1_i = 0; _inline_1_i < index.length - 1; ++_inline_1_i) {
+                                _inline_1_v = _inline_1_v[index[_inline_1_i]];
+                              }
+                              a0[p0] = _inline_1_v[index[index.length - 1]];
+                            }
+                            p0 += d0s0;
+                            ++index[2];
+                          }
+                          p0 += d0s1;
+                          index[2] -= s2;
+                          ++index[1];
+                        }
+                        p0 += d0s2;
+                        index[1] -= s1;
+                        ++index[0];
+                      }
+                    };
+                  }
+                  function generateCWiseOp() {
+                    return CwiseOp();
+                  }
+                  var compile = generateCWiseOp;
+                  function thunk(compile2) {
+                    var CACHED = {};
+                    return function convert_cwise_thunk(array0, scalar1) {
+                      var t02 = array0.dtype, r0 = array0.order, type = [t02, r0.join()].join(), proc = CACHED[type];
+                      if (!proc) {
+                        CACHED[type] = proc = compile2([t02, r0]);
+                      }
+                      return proc(
+                        array0.shape.slice(0),
+                        array0.data,
+                        array0.stride,
+                        array0.offset | 0,
+                        scalar1
+                      );
+                    };
+                  }
+                  function createThunk(proc) {
+                    return thunk(compile.bind(void 0, proc));
+                  }
+                  function compileCwise(user_args) {
+                    return createThunk({
+                      funcName: user_args.funcName
+                    });
+                  }
+                  module22.exports = compileCwise({
+                    funcName: "convert"
+                  });
+                }
+              ),
+              /***/
+              8284: (
+                /***/
+                function(module22) {
+                  module22.exports = hiddenStore;
+                  function hiddenStore(obj, key) {
+                    var store = { identity: key };
+                    var valueOf = obj.valueOf;
+                    Object.defineProperty(obj, "valueOf", {
+                      value: function(value) {
+                        return value !== key ? valueOf.apply(this, arguments) : store;
+                      },
+                      writable: true
+                    });
+                    return store;
+                  }
+                }
+              ),
+              /***/
+              8406: (
+                /***/
+                function(__unused_webpack_module, exports2) {
+                  var DEFAULT_NORMALS_EPSILON = 1e-6;
+                  var DEFAULT_FACE_EPSILON = 1e-6;
+                  exports2.vertexNormals = function(faces, positions, specifiedEpsilon) {
+                    var N2 = positions.length;
+                    var normals = new Array(N2);
+                    var epsilon = specifiedEpsilon === void 0 ? DEFAULT_NORMALS_EPSILON : specifiedEpsilon;
+                    for (var i2 = 0; i2 < N2; ++i2) {
+                      normals[i2] = [0, 0, 0];
+                    }
+                    for (var i2 = 0; i2 < faces.length; ++i2) {
+                      var f2 = faces[i2];
+                      var p2 = 0;
+                      var c2 = f2[f2.length - 1];
+                      var n2 = f2[0];
+                      for (var j2 = 0; j2 < f2.length; ++j2) {
+                        p2 = c2;
+                        c2 = n2;
+                        n2 = f2[(j2 + 1) % f2.length];
+                        var v0 = positions[p2];
+                        var v1 = positions[c2];
+                        var v2 = positions[n2];
+                        var d01 = new Array(3);
+                        var m01 = 0;
+                        var d21 = new Array(3);
+                        var m21 = 0;
+                        for (var k2 = 0; k2 < 3; ++k2) {
+                          d01[k2] = v0[k2] - v1[k2];
+                          m01 += d01[k2] * d01[k2];
+                          d21[k2] = v2[k2] - v1[k2];
+                          m21 += d21[k2] * d21[k2];
+                        }
+                        if (m01 * m21 > epsilon) {
+                          var norm = normals[c2];
+                          var w2 = 1 / Math.sqrt(m01 * m21);
+                          for (var k2 = 0; k2 < 3; ++k2) {
+                            var u2 = (k2 + 1) % 3;
+                            var v3 = (k2 + 2) % 3;
+                            norm[k2] += w2 * (d21[u2] * d01[v3] - d21[v3] * d01[u2]);
+                          }
+                        }
+                      }
+                    }
+                    for (var i2 = 0; i2 < N2; ++i2) {
+                      var norm = normals[i2];
+                      var m2 = 0;
+                      for (var k2 = 0; k2 < 3; ++k2) {
+                        m2 += norm[k2] * norm[k2];
+                      }
+                      if (m2 > epsilon) {
+                        var w2 = 1 / Math.sqrt(m2);
+                        for (var k2 = 0; k2 < 3; ++k2) {
+                          norm[k2] *= w2;
+                        }
+                      } else {
+                        for (var k2 = 0; k2 < 3; ++k2) {
+                          norm[k2] = 0;
+                        }
+                      }
+                    }
+                    return normals;
+                  };
+                  exports2.faceNormals = function(faces, positions, specifiedEpsilon) {
+                    var N2 = faces.length;
+                    var normals = new Array(N2);
+                    var epsilon = specifiedEpsilon === void 0 ? DEFAULT_FACE_EPSILON : specifiedEpsilon;
+                    for (var i2 = 0; i2 < N2; ++i2) {
+                      var f2 = faces[i2];
+                      var pos = new Array(3);
+                      for (var j2 = 0; j2 < 3; ++j2) {
+                        pos[j2] = positions[f2[j2]];
+                      }
+                      var d01 = new Array(3);
+                      var d21 = new Array(3);
+                      for (var j2 = 0; j2 < 3; ++j2) {
+                        d01[j2] = pos[1][j2] - pos[0][j2];
+                        d21[j2] = pos[2][j2] - pos[0][j2];
+                      }
+                      var n2 = new Array(3);
+                      var l2 = 0;
+                      for (var j2 = 0; j2 < 3; ++j2) {
+                        var u2 = (j2 + 1) % 3;
+                        var v2 = (j2 + 2) % 3;
+                        n2[j2] = d01[u2] * d21[v2] - d01[v2] * d21[u2];
+                        l2 += n2[j2] * n2[j2];
+                      }
+                      if (l2 > epsilon) {
+                        l2 = 1 / Math.sqrt(l2);
+                      } else {
+                        l2 = 0;
+                      }
+                      for (var j2 = 0; j2 < 3; ++j2) {
+                        n2[j2] *= l2;
+                      }
+                      normals[i2] = n2;
+                    }
+                    return normals;
+                  };
+                }
+              ),
+              /***/
+              8418: (
+                /***/
+                function(module22, __unused_webpack_exports, __webpack_require__2) {
+                  var isAllBlank = __webpack_require__2(5219);
+                  var createBuffer = __webpack_require__2(2762);
+                  var createVAO = __webpack_require__2(8116);
+                  var pool = __webpack_require__2(1888);
+                  var mat4mult = __webpack_require__2(6760);
+                  var shaders = __webpack_require__2(1283);
+                  var getGlyph = __webpack_require__2(9366);
+                  var getSimpleString = __webpack_require__2(5964);
+                  var IDENTITY2 = [
+                    1,
+                    0,
+                    0,
+                    0,
+                    0,
+                    1,
+                    0,
+                    0,
+                    0,
+                    0,
+                    1,
+                    0,
+                    0,
+                    0,
+                    0,
+                    1
+                  ];
+                  var ab2 = ArrayBuffer;
+                  var dv = DataView;
+                  function isTypedArray2(a2) {
+                    return ab2.isView(a2) && !(a2 instanceof dv);
+                  }
+                  function isArrayOrTypedArray(a2) {
+                    return Array.isArray(a2) || isTypedArray2(a2);
+                  }
+                  module22.exports = createPointCloud;
+                  function transformMat42(x2, m2) {
+                    var x0 = x2[0];
+                    var x1 = x2[1];
+                    var x22 = x2[2];
+                    var x3 = x2[3];
+                    x2[0] = m2[0] * x0 + m2[4] * x1 + m2[8] * x22 + m2[12] * x3;
+                    x2[1] = m2[1] * x0 + m2[5] * x1 + m2[9] * x22 + m2[13] * x3;
+                    x2[2] = m2[2] * x0 + m2[6] * x1 + m2[10] * x22 + m2[14] * x3;
+                    x2[3] = m2[3] * x0 + m2[7] * x1 + m2[11] * x22 + m2[15] * x3;
+                    return x2;
+                  }
+                  function project2(p2, v2, m2, x2) {
+                    transformMat42(x2, x2);
+                    transformMat42(x2, x2);
+                    return transformMat42(x2, x2);
+                  }
+                  function ScatterPlotPickResult(index, position) {
+                    this.index = index;
+                    this.dataCoordinate = this.position = position;
+                  }
+                  function fixOpacity(a2) {
+                    if (a2 === true) return 1;
+                    if (a2 > 1) return 1;
+                    return a2;
+                  }
+                  function PointCloud(gl2, shader, orthoShader, projectShader, pointBuffer, colorBuffer, glyphBuffer, idBuffer, vao, pickPerspectiveShader, pickOrthoShader, pickProjectShader) {
+                    this.gl = gl2;
+                    this.pixelRatio = 1;
+                    this.shader = shader;
+                    this.orthoShader = orthoShader;
+                    this.projectShader = projectShader;
+                    this.pointBuffer = pointBuffer;
+                    this.colorBuffer = colorBuffer;
+                    this.glyphBuffer = glyphBuffer;
+                    this.idBuffer = idBuffer;
+                    this.vao = vao;
+                    this.vertexCount = 0;
+                    this.lineVertexCount = 0;
+                    this.opacity = 1;
+                    this.hasAlpha = false;
+                    this.lineWidth = 0;
+                    this.projectScale = [2 / 3, 2 / 3, 2 / 3];
+                    this.projectOpacity = [1, 1, 1];
+                    this.projectHasAlpha = false;
+                    this.pickId = 0;
+                    this.pickPerspectiveShader = pickPerspectiveShader;
+                    this.pickOrthoShader = pickOrthoShader;
+                    this.pickProjectShader = pickProjectShader;
+                    this.points = [];
+                    this._selectResult = new ScatterPlotPickResult(0, [0, 0, 0]);
+                    this.useOrtho = true;
+                    this.bounds = [
+                      [Infinity, Infinity, Infinity],
+                      [-Infinity, -Infinity, -Infinity]
+                    ];
+                    this.axesProject = [true, true, true];
+                    this.axesBounds = [
+                      [-Infinity, -Infinity, -Infinity],
+                      [Infinity, Infinity, Infinity]
+                    ];
+                    this.highlightId = [1, 1, 1, 1];
+                    this.highlightScale = 2;
+                    this.clipBounds = [
+                      [-Infinity, -Infinity, -Infinity],
+                      [Infinity, Infinity, Infinity]
+                    ];
+                    this.dirty = true;
+                  }
+                  var proto = PointCloud.prototype;
+                  proto.pickSlots = 1;
+                  proto.setPickBase = function(pickBase) {
+                    this.pickId = pickBase;
+                  };
+                  proto.isTransparent = function() {
+                    if (this.hasAlpha) {
+                      return true;
+                    }
+                    for (var i2 = 0; i2 < 3; ++i2) {
+                      if (this.axesProject[i2] && this.projectHasAlpha) {
+                        return true;
+                      }
+                    }
+                    return false;
+                  };
+                  proto.isOpaque = function() {
+                    if (!this.hasAlpha) {
+                      return true;
+                    }
+                    for (var i2 = 0; i2 < 3; ++i2) {
+                      if (this.axesProject[i2] && !this.projectHasAlpha) {
+                        return true;
+                      }
+                    }
+                    return false;
+                  };
+                  var VIEW_SHAPE = [0, 0];
+                  var U_VEC = [0, 0, 0];
+                  var V_VEC = [0, 0, 0];
+                  var MU_VEC = [0, 0, 0, 1];
+                  var MV_VEC = [0, 0, 0, 1];
+                  var SCRATCH_MATRIX = IDENTITY2.slice();
+                  var SCRATCH_VEC = [0, 0, 0];
+                  var CLIP_BOUNDS = [[0, 0, 0], [0, 0, 0]];
+                  function zeroVec(a2) {
+                    a2[0] = a2[1] = a2[2] = 0;
+                    return a2;
+                  }
+                  function augment(hg2, af2) {
+                    hg2[0] = af2[0];
+                    hg2[1] = af2[1];
+                    hg2[2] = af2[2];
+                    hg2[3] = 1;
+                    return hg2;
+                  }
+                  function setComponent(out, v2, i2, x2) {
+                    out[0] = v2[0];
+                    out[1] = v2[1];
+                    out[2] = v2[2];
+                    out[i2] = x2;
+                    return out;
+                  }
+                  function getClipBounds(bounds) {
+                    var result = CLIP_BOUNDS;
+                    for (var i2 = 0; i2 < 2; ++i2) {
+                      for (var j2 = 0; j2 < 3; ++j2) {
+                        result[i2][j2] = Math.max(Math.min(bounds[i2][j2], 1e8), -1e8);
+                      }
+                    }
+                    return result;
+                  }
+                  function drawProject(shader, points, camera, pixelRatio) {
+                    var axesProject = points.axesProject;
+                    var gl2 = points.gl;
+                    var uniforms = shader.uniforms;
+                    var model = camera.model || IDENTITY2;
+                    var view = camera.view || IDENTITY2;
+                    var projection = camera.projection || IDENTITY2;
+                    var bounds = points.axesBounds;
+                    var clipBounds = getClipBounds(points.clipBounds);
+                    var cubeAxis;
+                    if (points.axes && points.axes.lastCubeProps) {
+                      cubeAxis = points.axes.lastCubeProps.axis;
+                    } else {
+                      cubeAxis = [1, 1, 1];
+                    }
+                    VIEW_SHAPE[0] = 2 / gl2.drawingBufferWidth;
+                    VIEW_SHAPE[1] = 2 / gl2.drawingBufferHeight;
+                    shader.bind();
+                    uniforms.view = view;
+                    uniforms.projection = projection;
+                    uniforms.screenSize = VIEW_SHAPE;
+                    uniforms.highlightId = points.highlightId;
+                    uniforms.highlightScale = points.highlightScale;
+                    uniforms.clipBounds = clipBounds;
+                    uniforms.pickGroup = points.pickId / 255;
+                    uniforms.pixelRatio = pixelRatio;
+                    for (var i2 = 0; i2 < 3; ++i2) {
+                      if (!axesProject[i2]) {
+                        continue;
+                      }
+                      uniforms.scale = points.projectScale[i2];
+                      uniforms.opacity = points.projectOpacity[i2];
+                      var pmodel = SCRATCH_MATRIX;
+                      for (var j2 = 0; j2 < 16; ++j2) {
+                        pmodel[j2] = 0;
+                      }
+                      for (var j2 = 0; j2 < 4; ++j2) {
+                        pmodel[5 * j2] = 1;
+                      }
+                      pmodel[5 * i2] = 0;
+                      if (cubeAxis[i2] < 0) {
+                        pmodel[12 + i2] = bounds[0][i2];
+                      } else {
+                        pmodel[12 + i2] = bounds[1][i2];
+                      }
+                      mat4mult(pmodel, model, pmodel);
+                      uniforms.model = pmodel;
+                      var u2 = (i2 + 1) % 3;
+                      var v2 = (i2 + 2) % 3;
+                      var du = zeroVec(U_VEC);
+                      var dv2 = zeroVec(V_VEC);
+                      du[u2] = 1;
+                      dv2[v2] = 1;
+                      var mdu = project2(projection, view, model, augment(MU_VEC, du));
+                      var mdv = project2(projection, view, model, augment(MV_VEC, dv2));
+                      if (Math.abs(mdu[1]) > Math.abs(mdv[1])) {
+                        var tmp2 = mdu;
+                        mdu = mdv;
+                        mdv = tmp2;
+                        tmp2 = du;
+                        du = dv2;
+                        dv2 = tmp2;
+                        var t4 = u2;
+                        u2 = v2;
+                        v2 = t4;
+                      }
+                      if (mdu[0] < 0) {
+                        du[u2] = -1;
+                      }
+                      if (mdv[1] > 0) {
+                        dv2[v2] = -1;
+                      }
+                      var su = 0;
+                      var sv = 0;
+                      for (var j2 = 0; j2 < 4; ++j2) {
+                        su += Math.pow(model[4 * u2 + j2], 2);
+                        sv += Math.pow(model[4 * v2 + j2], 2);
+                      }
+                      du[u2] /= Math.sqrt(su);
+                      dv2[v2] /= Math.sqrt(sv);
+                      uniforms.axes[0] = du;
+                      uniforms.axes[1] = dv2;
+                      uniforms.fragClipBounds[0] = setComponent(SCRATCH_VEC, clipBounds[0], i2, -1e8);
+                      uniforms.fragClipBounds[1] = setComponent(SCRATCH_VEC, clipBounds[1], i2, 1e8);
+                      points.vao.bind();
+                      points.vao.draw(gl2.TRIANGLES, points.vertexCount);
+                      if (points.lineWidth > 0) {
+                        gl2.lineWidth(points.lineWidth * pixelRatio);
+                        points.vao.draw(gl2.LINES, points.lineVertexCount, points.vertexCount);
+                      }
+                      points.vao.unbind();
+                    }
+                  }
+                  var NEG_INFINITY3 = [-1e8, -1e8, -1e8];
+                  var POS_INFINITY3 = [1e8, 1e8, 1e8];
+                  var CLIP_GROUP = [NEG_INFINITY3, POS_INFINITY3];
+                  function drawFull(shader, pshader, points, camera, pixelRatio, transparent, forceDraw) {
+                    var gl2 = points.gl;
+                    if (transparent === points.projectHasAlpha || forceDraw) {
+                      drawProject(pshader, points, camera, pixelRatio);
+                    }
+                    if (transparent === points.hasAlpha || forceDraw) {
+                      shader.bind();
+                      var uniforms = shader.uniforms;
+                      uniforms.model = camera.model || IDENTITY2;
+                      uniforms.view = camera.view || IDENTITY2;
+                      uniforms.projection = camera.projection || IDENTITY2;
+                      VIEW_SHAPE[0] = 2 / gl2.drawingBufferWidth;
+                      VIEW_SHAPE[1] = 2 / gl2.drawingBufferHeight;
+                      uniforms.screenSize = VIEW_SHAPE;
+                      uniforms.highlightId = points.highlightId;
+                      uniforms.highlightScale = points.highlightScale;
+                      uniforms.fragClipBounds = CLIP_GROUP;
+                      uniforms.clipBounds = points.axes.bounds;
+                      uniforms.opacity = points.opacity;
+                      uniforms.pickGroup = points.pickId / 255;
+                      uniforms.pixelRatio = pixelRatio;
+                      points.vao.bind();
+                      points.vao.draw(gl2.TRIANGLES, points.vertexCount);
+                      if (points.lineWidth > 0) {
+                        gl2.lineWidth(points.lineWidth * pixelRatio);
+                        points.vao.draw(gl2.LINES, points.lineVertexCount, points.vertexCount);
+                      }
+                      points.vao.unbind();
+                    }
+                  }
+                  proto.draw = function(camera) {
+                    var shader = this.useOrtho ? this.orthoShader : this.shader;
+                    drawFull(shader, this.projectShader, this, camera, this.pixelRatio, false, false);
+                  };
+                  proto.drawTransparent = function(camera) {
+                    var shader = this.useOrtho ? this.orthoShader : this.shader;
+                    drawFull(shader, this.projectShader, this, camera, this.pixelRatio, true, false);
+                  };
+                  proto.drawPick = function(camera) {
+                    var shader = this.useOrtho ? this.pickOrthoShader : this.pickPerspectiveShader;
+                    drawFull(shader, this.pickProjectShader, this, camera, 1, true, true);
+                  };
+                  proto.pick = function(selected) {
+                    if (!selected) {
+                      return null;
+                    }
+                    if (selected.id !== this.pickId) {
+                      return null;
+                    }
+                    var x2 = selected.value[2] + (selected.value[1] << 8) + (selected.value[0] << 16);
+                    if (x2 >= this.pointCount || x2 < 0) {
+                      return null;
+                    }
+                    var coord = this.points[x2];
+                    var result = this._selectResult;
+                    result.index = x2;
+                    for (var i2 = 0; i2 < 3; ++i2) {
+                      result.position[i2] = result.dataCoordinate[i2] = coord[i2];
+                    }
+                    return result;
+                  };
+                  proto.highlight = function(selection) {
+                    if (!selection) {
+                      this.highlightId = [1, 1, 1, 1];
+                    } else {
+                      var pointId = selection.index;
+                      var a0 = pointId & 255;
+                      var a1 = pointId >> 8 & 255;
+                      var a2 = pointId >> 16 & 255;
+                      this.highlightId = [a0 / 255, a1 / 255, a2 / 255, 0];
+                    }
+                  };
+                  function get_glyphData(glyphs, index, font, pixelRatio) {
+                    var str;
+                    if (isArrayOrTypedArray(glyphs)) {
+                      if (index < glyphs.length) {
+                        str = glyphs[index];
+                      } else {
+                        str = void 0;
+                      }
+                    } else {
+                      str = glyphs;
+                    }
+                    str = getSimpleString(str);
+                    var visible = true;
+                    if (isAllBlank(str)) {
+                      str = "▼";
+                      visible = false;
+                    }
+                    if (!font) font = {};
+                    var family = font.family;
+                    if (isArrayOrTypedArray(family)) family = family[index];
+                    if (!family) family = "normal";
+                    var weight = font.weight;
+                    if (isArrayOrTypedArray(weight)) weight = weight[index];
+                    if (!weight) weight = "normal";
+                    var style = font.style;
+                    if (isArrayOrTypedArray(style)) style = style[index];
+                    if (!style) style = "normal";
+                    var variant = font.variant;
+                    if (isArrayOrTypedArray(variant)) variant = variant[index];
+                    if (!variant) variant = "normal";
+                    var glyph = getGlyph(str, {
+                      family,
+                      weight,
+                      style,
+                      variant
+                    }, pixelRatio);
+                    var glyph = getGlyph(str, font, pixelRatio);
+                    return {
+                      mesh: glyph[0],
+                      lines: glyph[1],
+                      bounds: glyph[2],
+                      visible
+                    };
+                  }
+                  proto.update = function(options) {
+                    options = options || {};
+                    if ("perspective" in options) {
+                      this.useOrtho = !options.perspective;
+                    }
+                    if ("orthographic" in options) {
+                      this.useOrtho = !!options.orthographic;
+                    }
+                    if ("lineWidth" in options) {
+                      this.lineWidth = options.lineWidth;
+                    }
+                    if ("project" in options) {
+                      if (isArrayOrTypedArray(options.project)) {
+                        this.axesProject = options.project;
+                      } else {
+                        var v2 = !!options.project;
+                        this.axesProject = [v2, v2, v2];
+                      }
+                    }
+                    if ("projectScale" in options) {
+                      if (isArrayOrTypedArray(options.projectScale)) {
+                        this.projectScale = options.projectScale.slice();
+                      } else {
+                        var s2 = +options.projectScale;
+                        this.projectScale = [s2, s2, s2];
+                      }
+                    }
+                    this.projectHasAlpha = false;
+                    if ("projectOpacity" in options) {
+                      if (isArrayOrTypedArray(options.projectOpacity)) {
+                        this.projectOpacity = options.projectOpacity.slice();
+                      } else {
+                        var s2 = +options.projectOpacity;
+                        this.projectOpacity = [s2, s2, s2];
+                      }
+                      for (var i2 = 0; i2 < 3; ++i2) {
+                        this.projectOpacity[i2] = fixOpacity(this.projectOpacity[i2]);
+                        if (this.projectOpacity[i2] < 1) {
+                          this.projectHasAlpha = true;
+                        }
+                      }
+                    }
+                    this.hasAlpha = false;
+                    if ("opacity" in options) {
+                      this.opacity = fixOpacity(options.opacity);
+                      if (this.opacity < 1) {
+                        this.hasAlpha = true;
+                      }
+                    }
+                    this.dirty = true;
+                    var points = options.position;
+                    var font = {
+                      family: options.font || "normal",
+                      style: options.fontStyle || "normal",
+                      weight: options.fontWeight || "normal",
+                      variant: options.fontVariant || "normal"
+                    };
+                    var alignment = options.alignment || [0, 0];
+                    var alignmentX;
+                    var alignmentY;
+                    if (alignment.length === 2) {
+                      alignmentX = alignment[0];
+                      alignmentY = alignment[1];
+                    } else {
+                      alignmentX = [];
+                      alignmentY = [];
+                      for (var i2 = 0; i2 < alignment.length; ++i2) {
+                        alignmentX[i2] = alignment[i2][0];
+                        alignmentY[i2] = alignment[i2][1];
+                      }
+                    }
+                    var lowerBound = [Infinity, Infinity, Infinity];
+                    var upperBound = [-Infinity, -Infinity, -Infinity];
+                    var glyphs = options.glyph;
+                    var colors = options.color;
+                    var sizes = options.size;
+                    var angles = options.angle;
+                    var lineColors = options.lineColor;
+                    var pickCounter = -1;
+                    var triVertexCount = 0;
+                    var lineVertexCount = 0;
+                    var numPoints = 0;
+                    if (points.length) {
+                      numPoints = points.length;
+                      count_loop:
+                        for (var i2 = 0; i2 < numPoints; ++i2) {
+                          var x2 = points[i2];
+                          for (var j2 = 0; j2 < 3; ++j2) {
+                            if (isNaN(x2[j2]) || !isFinite(x2[j2])) {
+                              continue count_loop;
+                            }
+                          }
+                          var glyphData = get_glyphData(glyphs, i2, font, this.pixelRatio);
+                          var glyphMesh = glyphData.mesh;
+                          var glyphLines = glyphData.lines;
+                          var glyphBounds = glyphData.bounds;
+                          triVertexCount += glyphMesh.cells.length * 3;
+                          lineVertexCount += glyphLines.edges.length * 2;
+                        }
+                    }
+                    var vertexCount = triVertexCount + lineVertexCount;
+                    var positionArray = pool.mallocFloat(3 * vertexCount);
+                    var colorArray = pool.mallocFloat(4 * vertexCount);
+                    var glyphArray = pool.mallocFloat(2 * vertexCount);
+                    var idArray = pool.mallocUint32(vertexCount);
+                    if (vertexCount > 0) {
+                      var triOffset = 0;
+                      var lineOffset = triVertexCount;
+                      var color22 = [0, 0, 0, 1];
+                      var lineColor = [0, 0, 0, 1];
+                      var isColorArray = isArrayOrTypedArray(colors) && isArrayOrTypedArray(colors[0]);
+                      var isLineColorArray = isArrayOrTypedArray(lineColors) && isArrayOrTypedArray(lineColors[0]);
+                      fill_loop:
+                        for (var i2 = 0; i2 < numPoints; ++i2) {
+                          pickCounter += 1;
+                          var x2 = points[i2];
+                          for (var j2 = 0; j2 < 3; ++j2) {
+                            if (isNaN(x2[j2]) || !isFinite(x2[j2])) {
+                              continue fill_loop;
+                            }
+                            upperBound[j2] = Math.max(upperBound[j2], x2[j2]);
+                            lowerBound[j2] = Math.min(lowerBound[j2], x2[j2]);
+                          }
+                          var glyphData = get_glyphData(glyphs, i2, font, this.pixelRatio);
+                          var glyphMesh = glyphData.mesh;
+                          var glyphLines = glyphData.lines;
+                          var glyphBounds = glyphData.bounds;
+                          var glyphVisible = glyphData.visible;
+                          if (!glyphVisible) color22 = [1, 1, 1, 0];
+                          else if (isArrayOrTypedArray(colors)) {
+                            var c2;
+                            if (isColorArray) {
+                              if (i2 < colors.length) {
+                                c2 = colors[i2];
+                              } else {
+                                c2 = [0, 0, 0, 0];
+                              }
+                            } else {
+                              c2 = colors;
+                            }
+                            if (c2.length === 3) {
+                              for (var j2 = 0; j2 < 3; ++j2) {
+                                color22[j2] = c2[j2];
+                              }
+                              color22[3] = 1;
+                            } else if (c2.length === 4) {
+                              for (var j2 = 0; j2 < 4; ++j2) {
+                                color22[j2] = c2[j2];
+                              }
+                              if (!this.hasAlpha && c2[3] < 1) this.hasAlpha = true;
+                            }
+                          } else {
+                            color22[0] = color22[1] = color22[2] = 0;
+                            color22[3] = 1;
+                          }
+                          if (!glyphVisible) lineColor = [1, 1, 1, 0];
+                          else if (isArrayOrTypedArray(lineColors)) {
+                            var c2;
+                            if (isLineColorArray) {
+                              if (i2 < lineColors.length) {
+                                c2 = lineColors[i2];
+                              } else {
+                                c2 = [0, 0, 0, 0];
+                              }
+                            } else {
+                              c2 = lineColors;
+                            }
+                            if (c2.length === 3) {
+                              for (var j2 = 0; j2 < 3; ++j2) {
+                                lineColor[j2] = c2[j2];
+                              }
+                              lineColor[j2] = 1;
+                            } else if (c2.length === 4) {
+                              for (var j2 = 0; j2 < 4; ++j2) {
+                                lineColor[j2] = c2[j2];
+                              }
+                              if (!this.hasAlpha && c2[3] < 1) this.hasAlpha = true;
+                            }
+                          } else {
+                            lineColor[0] = lineColor[1] = lineColor[2] = 0;
+                            lineColor[3] = 1;
+                          }
+                          var size = 0.5;
+                          if (!glyphVisible) size = 0;
+                          else if (isArrayOrTypedArray(sizes)) {
+                            if (i2 < sizes.length) {
+                              size = +sizes[i2];
+                            } else {
+                              size = 12;
+                            }
+                          } else if (sizes) {
+                            size = +sizes;
+                          } else if (this.useOrtho) {
+                            size = 12;
+                          }
+                          var angle2 = 0;
+                          if (isArrayOrTypedArray(angles)) {
+                            if (i2 < angles.length) {
+                              angle2 = +angles[i2];
+                            } else {
+                              angle2 = 0;
+                            }
+                          } else if (angles) {
+                            angle2 = +angles;
+                          }
+                          var cos = Math.cos(angle2);
+                          var sin = Math.sin(angle2);
+                          var x2 = points[i2];
+                          for (var j2 = 0; j2 < 3; ++j2) {
+                            upperBound[j2] = Math.max(upperBound[j2], x2[j2]);
+                            lowerBound[j2] = Math.min(lowerBound[j2], x2[j2]);
+                          }
+                          var textOffsetX = alignmentX;
+                          var textOffsetY = alignmentY;
+                          var textOffsetX = 0;
+                          if (isArrayOrTypedArray(alignmentX)) {
+                            if (i2 < alignmentX.length) {
+                              textOffsetX = alignmentX[i2];
+                            } else {
+                              textOffsetX = 0;
+                            }
+                          } else if (alignmentX) {
+                            textOffsetX = alignmentX;
+                          }
+                          var textOffsetY = 0;
+                          if (isArrayOrTypedArray(alignmentY)) {
+                            if (i2 < alignmentY.length) {
+                              textOffsetY = alignmentY[i2];
+                            } else {
+                              textOffsetY = 0;
+                            }
+                          } else if (alignmentY) {
+                            textOffsetY = alignmentY;
+                          }
+                          textOffsetX *= textOffsetX > 0 ? 1 - glyphBounds[0][0] : textOffsetX < 0 ? 1 + glyphBounds[1][0] : 1;
+                          textOffsetY *= textOffsetY > 0 ? 1 - glyphBounds[0][1] : textOffsetY < 0 ? 1 + glyphBounds[1][1] : 1;
+                          var textOffset = [textOffsetX, textOffsetY];
+                          var cells = glyphMesh.cells || [];
+                          var verts = glyphMesh.positions || [];
+                          for (var j2 = 0; j2 < cells.length; ++j2) {
+                            var cell = cells[j2];
+                            for (var k2 = 0; k2 < 3; ++k2) {
+                              for (var l2 = 0; l2 < 3; ++l2) {
+                                positionArray[3 * triOffset + l2] = x2[l2];
+                              }
+                              for (var l2 = 0; l2 < 4; ++l2) {
+                                colorArray[4 * triOffset + l2] = color22[l2];
+                              }
+                              idArray[triOffset] = pickCounter;
+                              var p2 = verts[cell[k2]];
+                              glyphArray[2 * triOffset] = size * (cos * p2[0] - sin * p2[1] + textOffset[0]);
+                              glyphArray[2 * triOffset + 1] = size * (sin * p2[0] + cos * p2[1] + textOffset[1]);
+                              triOffset += 1;
+                            }
+                          }
+                          var cells = glyphLines.edges;
+                          var verts = glyphLines.positions;
+                          for (var j2 = 0; j2 < cells.length; ++j2) {
+                            var cell = cells[j2];
+                            for (var k2 = 0; k2 < 2; ++k2) {
+                              for (var l2 = 0; l2 < 3; ++l2) {
+                                positionArray[3 * lineOffset + l2] = x2[l2];
+                              }
+                              for (var l2 = 0; l2 < 4; ++l2) {
+                                colorArray[4 * lineOffset + l2] = lineColor[l2];
+                              }
+                              idArray[lineOffset] = pickCounter;
+                              var p2 = verts[cell[k2]];
+                              glyphArray[2 * lineOffset] = size * (cos * p2[0] - sin * p2[1] + textOffset[0]);
+                              glyphArray[2 * lineOffset + 1] = size * (sin * p2[0] + cos * p2[1] + textOffset[1]);
+                              lineOffset += 1;
+                            }
+                          }
+                        }
+                    }
+                    this.bounds = [lowerBound, upperBound];
+                    this.points = points;
+                    this.pointCount = points.length;
+                    this.vertexCount = triVertexCount;
+                    this.lineVertexCount = lineVertexCount;
+                    this.pointBuffer.update(positionArray);
+                    this.colorBuffer.update(colorArray);
+                    this.glyphBuffer.update(glyphArray);
+                    this.idBuffer.update(idArray);
+                    pool.free(positionArray);
+                    pool.free(colorArray);
+                    pool.free(glyphArray);
+                    pool.free(idArray);
+                  };
+                  proto.dispose = function() {
+                    this.shader.dispose();
+                    this.orthoShader.dispose();
+                    this.pickPerspectiveShader.dispose();
+                    this.pickOrthoShader.dispose();
+                    this.vao.dispose();
+                    this.pointBuffer.dispose();
+                    this.colorBuffer.dispose();
+                    this.glyphBuffer.dispose();
+                    this.idBuffer.dispose();
+                  };
+                  function createPointCloud(options) {
+                    var gl2 = options.gl;
+                    var shader = shaders.createPerspective(gl2);
+                    var orthoShader = shaders.createOrtho(gl2);
+                    var projectShader = shaders.createProject(gl2);
+                    var pickPerspectiveShader = shaders.createPickPerspective(gl2);
+                    var pickOrthoShader = shaders.createPickOrtho(gl2);
+                    var pickProjectShader = shaders.createPickProject(gl2);
+                    var pointBuffer = createBuffer(gl2);
+                    var colorBuffer = createBuffer(gl2);
+                    var glyphBuffer = createBuffer(gl2);
+                    var idBuffer = createBuffer(gl2);
+                    var vao = createVAO(gl2, [
+                      {
+                        buffer: pointBuffer,
+                        size: 3,
+                        type: gl2.FLOAT
+                      },
+                      {
+                        buffer: colorBuffer,
+                        size: 4,
+                        type: gl2.FLOAT
+                      },
+                      {
+                        buffer: glyphBuffer,
+                        size: 2,
+                        type: gl2.FLOAT
+                      },
+                      {
+                        buffer: idBuffer,
+                        size: 4,
+                        type: gl2.UNSIGNED_BYTE,
+                        normalized: true
+                      }
+                    ]);
+                    var pointCloud = new PointCloud(
+                      gl2,
+                      shader,
+                      orthoShader,
+                      projectShader,
+                      pointBuffer,
+                      colorBuffer,
+                      glyphBuffer,
+                      idBuffer,
+                      vao,
+                      pickPerspectiveShader,
+                      pickOrthoShader,
+                      pickProjectShader
+                    );
+                    pointCloud.update(options);
+                    return pointCloud;
+                  }
+                }
+              ),
+              /***/
+              8489: (
+                /***/
+                function(module22) {
+                  module22.exports = scaleAndAdd;
+                  function scaleAndAdd(out, a2, b2, scale2) {
+                    out[0] = a2[0] + b2[0] * scale2;
+                    out[1] = a2[1] + b2[1] * scale2;
+                    out[2] = a2[2] + b2[2] * scale2;
+                    return out;
+                  }
+                }
+              ),
+              /***/
+              8507: (
+                /***/
+                function(module22) {
+                  module22.exports = compareCells;
+                  var min = Math.min;
+                  function compareInt2(a2, b2) {
+                    return a2 - b2;
+                  }
+                  function compareCells(a2, b2) {
+                    var n2 = a2.length, t4 = a2.length - b2.length;
+                    if (t4) {
+                      return t4;
+                    }
+                    switch (n2) {
+                      case 0:
+                        return 0;
+                      case 1:
+                        return a2[0] - b2[0];
+                      case 2:
+                        return a2[0] + a2[1] - b2[0] - b2[1] || min(a2[0], a2[1]) - min(b2[0], b2[1]);
+                      case 3:
+                        var l1 = a2[0] + a2[1], m1 = b2[0] + b2[1];
+                        t4 = l1 + a2[2] - (m1 + b2[2]);
+                        if (t4) {
+                          return t4;
+                        }
+                        var l0 = min(a2[0], a2[1]), m0 = min(b2[0], b2[1]);
+                        return min(l0, a2[2]) - min(m0, b2[2]) || min(l0 + a2[2], l1) - min(m0 + b2[2], m1);
+                      case 4:
+                        var aw = a2[0], ax = a2[1], ay = a2[2], az = a2[3], bw = b2[0], bx = b2[1], by = b2[2], bz = b2[3];
+                        return aw + ax + ay + az - (bw + bx + by + bz) || min(aw, ax, ay, az) - min(bw, bx, by, bz, bw) || min(aw + ax, aw + ay, aw + az, ax + ay, ax + az, ay + az) - min(bw + bx, bw + by, bw + bz, bx + by, bx + bz, by + bz) || min(aw + ax + ay, aw + ax + az, aw + ay + az, ax + ay + az) - min(bw + bx + by, bw + bx + bz, bw + by + bz, bx + by + bz);
+                      default:
+                        var as = a2.slice().sort(compareInt2);
+                        var bs = b2.slice().sort(compareInt2);
+                        for (var i2 = 0; i2 < n2; ++i2) {
+                          t4 = as[i2] - bs[i2];
+                          if (t4) {
+                            return t4;
+                          }
+                        }
+                        return 0;
+                    }
+                  }
+                }
+              ),
+              /***/
+              8512: (
+                /***/
+                function(module22, __unused_webpack_exports, __webpack_require__2) {
+                  var toPX = __webpack_require__2(665);
+                  module22.exports = mouseWheelListen;
+                  function mouseWheelListen(element, callback, noScroll) {
+                    if (typeof element === "function") {
+                      noScroll = !!callback;
+                      callback = element;
+                      element = window;
+                    }
+                    var lineHeight = toPX("ex", element);
+                    var listener = function(ev) {
+                      if (noScroll) {
+                        ev.preventDefault();
+                      }
+                      var dx = ev.deltaX || 0;
+                      var dy = ev.deltaY || 0;
+                      var dz = ev.deltaZ || 0;
+                      var mode = ev.deltaMode;
+                      var scale2 = 1;
+                      switch (mode) {
+                        case 1:
+                          scale2 = lineHeight;
+                          break;
+                        case 2:
+                          scale2 = window.innerHeight;
+                          break;
+                      }
+                      dx *= scale2;
+                      dy *= scale2;
+                      dz *= scale2;
+                      if (dx || dy || dz) {
+                        return callback(dx, dy, dz, ev);
+                      }
+                    };
+                    element.addEventListener("wheel", listener);
+                    return listener;
+                  }
+                }
+              ),
+              /***/
+              8545: (
+                /***/
+                function(module22) {
+                  module22.exports = robustSubtract;
+                  function scalarScalar(a2, b2) {
+                    var x2 = a2 + b2;
+                    var bv = x2 - a2;
+                    var av = x2 - bv;
+                    var br = b2 - bv;
+                    var ar = a2 - av;
+                    var y2 = ar + br;
+                    if (y2) {
+                      return [y2, x2];
+                    }
+                    return [x2];
+                  }
+                  function robustSubtract(e2, f2) {
+                    var ne2 = e2.length | 0;
+                    var nf2 = f2.length | 0;
+                    if (ne2 === 1 && nf2 === 1) {
+                      return scalarScalar(e2[0], -f2[0]);
+                    }
+                    var n2 = ne2 + nf2;
+                    var g2 = new Array(n2);
+                    var count2 = 0;
+                    var eptr = 0;
+                    var fptr = 0;
+                    var abs = Math.abs;
+                    var ei2 = e2[eptr];
+                    var ea2 = abs(ei2);
+                    var fi2 = -f2[fptr];
+                    var fa2 = abs(fi2);
+                    var a2, b2;
+                    if (ea2 < fa2) {
+                      b2 = ei2;
+                      eptr += 1;
+                      if (eptr < ne2) {
+                        ei2 = e2[eptr];
+                        ea2 = abs(ei2);
+                      }
+                    } else {
+                      b2 = fi2;
+                      fptr += 1;
+                      if (fptr < nf2) {
+                        fi2 = -f2[fptr];
+                        fa2 = abs(fi2);
+                      }
+                    }
+                    if (eptr < ne2 && ea2 < fa2 || fptr >= nf2) {
+                      a2 = ei2;
+                      eptr += 1;
+                      if (eptr < ne2) {
+                        ei2 = e2[eptr];
+                        ea2 = abs(ei2);
+                      }
+                    } else {
+                      a2 = fi2;
+                      fptr += 1;
+                      if (fptr < nf2) {
+                        fi2 = -f2[fptr];
+                        fa2 = abs(fi2);
+                      }
+                    }
+                    var x2 = a2 + b2;
+                    var bv = x2 - a2;
+                    var y2 = b2 - bv;
+                    var q0 = y2;
+                    var q1 = x2;
+                    var _x2, _bv, _av, _br, _ar;
+                    while (eptr < ne2 && fptr < nf2) {
+                      if (ea2 < fa2) {
+                        a2 = ei2;
+                        eptr += 1;
+                        if (eptr < ne2) {
+                          ei2 = e2[eptr];
+                          ea2 = abs(ei2);
+                        }
+                      } else {
+                        a2 = fi2;
+                        fptr += 1;
+                        if (fptr < nf2) {
+                          fi2 = -f2[fptr];
+                          fa2 = abs(fi2);
+                        }
+                      }
+                      b2 = q0;
+                      x2 = a2 + b2;
+                      bv = x2 - a2;
+                      y2 = b2 - bv;
+                      if (y2) {
+                        g2[count2++] = y2;
+                      }
+                      _x2 = q1 + x2;
+                      _bv = _x2 - q1;
+                      _av = _x2 - _bv;
+                      _br = x2 - _bv;
+                      _ar = q1 - _av;
+                      q0 = _ar + _br;
+                      q1 = _x2;
+                    }
+                    while (eptr < ne2) {
+                      a2 = ei2;
+                      b2 = q0;
+                      x2 = a2 + b2;
+                      bv = x2 - a2;
+                      y2 = b2 - bv;
+                      if (y2) {
+                        g2[count2++] = y2;
+                      }
+                      _x2 = q1 + x2;
+                      _bv = _x2 - q1;
+                      _av = _x2 - _bv;
+                      _br = x2 - _bv;
+                      _ar = q1 - _av;
+                      q0 = _ar + _br;
+                      q1 = _x2;
+                      eptr += 1;
+                      if (eptr < ne2) {
+                        ei2 = e2[eptr];
+                      }
+                    }
+                    while (fptr < nf2) {
+                      a2 = fi2;
+                      b2 = q0;
+                      x2 = a2 + b2;
+                      bv = x2 - a2;
+                      y2 = b2 - bv;
+                      if (y2) {
+                        g2[count2++] = y2;
+                      }
+                      _x2 = q1 + x2;
+                      _bv = _x2 - q1;
+                      _av = _x2 - _bv;
+                      _br = x2 - _bv;
+                      _ar = q1 - _av;
+                      q0 = _ar + _br;
+                      q1 = _x2;
+                      fptr += 1;
+                      if (fptr < nf2) {
+                        fi2 = -f2[fptr];
+                      }
+                    }
+                    if (q0) {
+                      g2[count2++] = q0;
+                    }
+                    if (q1) {
+                      g2[count2++] = q1;
+                    }
+                    if (!count2) {
+                      g2[count2++] = 0;
+                    }
+                    g2.length = count2;
+                    return g2;
+                  }
+                }
+              ),
+              /***/
+              8572: (
+                /***/
+                function(module22) {
+                  module22.exports = function signum(x2) {
+                    if (x2 < 0) {
+                      return -1;
+                    }
+                    if (x2 > 0) {
+                      return 1;
+                    }
+                    return 0;
+                  };
+                }
+              ),
+              /***/
+              8648: (
+                /***/
+                function(module22, __unused_webpack_exports, __webpack_require__2) {
+                  module22.exports = __webpack_require__2(783);
+                }
+              ),
+              /***/
+              8692: (
+                /***/
+                function(module22) {
+                  module22.exports = rotateZ2;
+                  function rotateZ2(out, a2, b2, c2) {
+                    var bx = b2[0];
+                    var by = b2[1];
+                    var px = a2[0] - bx;
+                    var py = a2[1] - by;
+                    var sc2 = Math.sin(c2);
+                    var cc2 = Math.cos(c2);
+                    out[0] = bx + px * cc2 - py * sc2;
+                    out[1] = by + px * sc2 + py * cc2;
+                    out[2] = a2[2];
+                    return out;
+                  }
+                }
+              ),
+              /***/
+              8697: (
+                /***/
+                function(module22, __unused_webpack_exports, __webpack_require__2) {
+                  var rationalize = __webpack_require__2(869);
+                  module22.exports = div;
+                  function div(a2, b2) {
+                    return rationalize(a2[0].mul(b2[1]), a2[1].mul(b2[0]));
+                  }
+                }
+              ),
+              /***/
+              8731: (
+                /***/
+                function(module22, __unused_webpack_exports, __webpack_require__2) {
+                  module22.exports = createAttributeWrapper;
+                  var GLError = __webpack_require__2(8866);
+                  function ShaderAttribute(gl2, wrapper, index, locations, dimension, constFunc) {
+                    this._gl = gl2;
+                    this._wrapper = wrapper;
+                    this._index = index;
+                    this._locations = locations;
+                    this._dimension = dimension;
+                    this._constFunc = constFunc;
+                  }
+                  var proto = ShaderAttribute.prototype;
+                  proto.pointer = function setAttribPointer(type, normalized, stride, offset) {
+                    var self2 = this;
+                    var gl2 = self2._gl;
+                    var location2 = self2._locations[self2._index];
+                    gl2.vertexAttribPointer(
+                      location2,
+                      self2._dimension,
+                      type || gl2.FLOAT,
+                      !!normalized,
+                      stride || 0,
+                      offset || 0
+                    );
+                    gl2.enableVertexAttribArray(location2);
+                  };
+                  proto.set = function(x0, x1, x2, x3) {
+                    return this._constFunc(this._locations[this._index], x0, x1, x2, x3);
+                  };
+                  Object.defineProperty(proto, "location", {
+                    get: function() {
+                      return this._locations[this._index];
+                    },
+                    set: function(v2) {
+                      if (v2 !== this._locations[this._index]) {
+                        this._locations[this._index] = v2 | 0;
+                        this._wrapper.program = null;
+                      }
+                      return v2 | 0;
+                    }
+                  });
+                  var allFns = [
+                    function(gl2, v2, x0) {
+                      if (x0.length === void 0) {
+                        return gl2.vertexAttrib1f(v2, x0);
+                      } else {
+                        return gl2.vertexAttrib1fv(v2, x0);
+                      }
+                    },
+                    function(gl2, v2, x0, x1) {
+                      if (x0.length === void 0) {
+                        return gl2.vertexAttrib2f(v2, x0, x1);
+                      } else {
+                        return gl2.vertexAttrib2fv(v2, x0);
+                      }
+                    },
+                    function(gl2, v2, x0, x1, x2) {
+                      if (x0.length === void 0) {
+                        return gl2.vertexAttrib3f(v2, x0, x1, x2);
+                      } else {
+                        return gl2.vertexAttrib3fv(v2, x0);
+                      }
+                    },
+                    function(gl2, v2, x0, x1, x2, x3) {
+                      if (x0.length === void 0) {
+                        return gl2.vertexAttrib4f(v2, x0, x1, x2, x3);
+                      } else {
+                        return gl2.vertexAttrib4fv(v2, x0);
+                      }
+                    }
+                  ];
+                  function addVectorAttribute(gl2, wrapper, index, locations, dimension, obj, name2) {
+                    var constFunc = allFns[dimension];
+                    var attr = new ShaderAttribute(
+                      gl2,
+                      wrapper,
+                      index,
+                      locations,
+                      dimension,
+                      constFunc
+                    );
+                    Object.defineProperty(obj, name2, {
+                      set: function(x2) {
+                        gl2.disableVertexAttribArray(locations[index]);
+                        constFunc(gl2, locations[index], x2);
+                        return x2;
+                      },
+                      get: function() {
+                        return attr;
+                      },
+                      enumerable: true
+                    });
+                  }
+                  function addMatrixAttribute(gl2, wrapper, index, locations, dimension, obj, name2) {
+                    var parts = new Array(dimension);
+                    var attrs = new Array(dimension);
+                    for (var i2 = 0; i2 < dimension; ++i2) {
+                      addVectorAttribute(
+                        gl2,
+                        wrapper,
+                        index[i2],
+                        locations,
+                        dimension,
+                        parts,
+                        i2
+                      );
+                      attrs[i2] = parts[i2];
+                    }
+                    Object.defineProperty(parts, "location", {
+                      set: function(v2) {
+                        if (Array.isArray(v2)) {
+                          for (var i22 = 0; i22 < dimension; ++i22) {
+                            attrs[i22].location = v2[i22];
+                          }
+                        } else {
+                          for (var i22 = 0; i22 < dimension; ++i22) {
+                            attrs[i22].location = v2 + i22;
+                          }
+                        }
+                        return v2;
+                      },
+                      get: function() {
+                        var result = new Array(dimension);
+                        for (var i22 = 0; i22 < dimension; ++i22) {
+                          result[i22] = locations[index[i22]];
+                        }
+                        return result;
+                      },
+                      enumerable: true
+                    });
+                    parts.pointer = function(type, normalized, stride, offset) {
+                      type = type || gl2.FLOAT;
+                      normalized = !!normalized;
+                      stride = stride || dimension * dimension;
+                      offset = offset || 0;
+                      for (var i22 = 0; i22 < dimension; ++i22) {
+                        var location2 = locations[index[i22]];
+                        gl2.vertexAttribPointer(
+                          location2,
+                          dimension,
+                          type,
+                          normalized,
+                          stride,
+                          offset + i22 * dimension
+                        );
+                        gl2.enableVertexAttribArray(location2);
+                      }
+                    };
+                    var scratch = new Array(dimension);
+                    var vertexAttrib = gl2["vertexAttrib" + dimension + "fv"];
+                    Object.defineProperty(obj, name2, {
+                      set: function(x2) {
+                        for (var i22 = 0; i22 < dimension; ++i22) {
+                          var loc = locations[index[i22]];
+                          gl2.disableVertexAttribArray(loc);
+                          if (Array.isArray(x2[0])) {
+                            vertexAttrib.call(gl2, loc, x2[i22]);
+                          } else {
+                            for (var j2 = 0; j2 < dimension; ++j2) {
+                              scratch[j2] = x2[dimension * i22 + j2];
+                            }
+                            vertexAttrib.call(gl2, loc, scratch);
+                          }
+                        }
+                        return x2;
+                      },
+                      get: function() {
+                        return parts;
+                      },
+                      enumerable: true
+                    });
+                  }
+                  function createAttributeWrapper(gl2, wrapper, attributes, locations) {
+                    var obj = {};
+                    for (var i2 = 0, n2 = attributes.length; i2 < n2; ++i2) {
+                      var a2 = attributes[i2];
+                      var name2 = a2.name;
+                      var type = a2.type;
+                      var locs = a2.locations;
+                      switch (type) {
+                        case "bool":
+                        case "int":
+                        case "float":
+                          addVectorAttribute(
+                            gl2,
+                            wrapper,
+                            locs[0],
+                            locations,
+                            1,
+                            obj,
+                            name2
+                          );
+                          break;
+                        default:
+                          if (type.indexOf("vec") >= 0) {
+                            var d2 = type.charCodeAt(type.length - 1) - 48;
+                            if (d2 < 2 || d2 > 4) {
+                              throw new GLError("", "Invalid data type for attribute " + name2 + ": " + type);
+                            }
+                            addVectorAttribute(
+                              gl2,
+                              wrapper,
+                              locs[0],
+                              locations,
+                              d2,
+                              obj,
+                              name2
+                            );
+                          } else if (type.indexOf("mat") >= 0) {
+                            var d2 = type.charCodeAt(type.length - 1) - 48;
+                            if (d2 < 2 || d2 > 4) {
+                              throw new GLError("", "Invalid data type for attribute " + name2 + ": " + type);
+                            }
+                            addMatrixAttribute(
+                              gl2,
+                              wrapper,
+                              locs,
+                              locations,
+                              d2,
+                              obj,
+                              name2
+                            );
+                          } else {
+                            throw new GLError("", "Unknown data type for attribute " + name2 + ": " + type);
+                          }
+                          break;
+                      }
+                    }
+                    return obj;
+                  }
+                }
+              ),
+              /***/
+              8828: (
+                /***/
+                function(__unused_webpack_module, exports2) {
+                  "use restrict";
+                  var INT_BITS = 32;
+                  exports2.INT_BITS = INT_BITS;
+                  exports2.INT_MAX = 2147483647;
+                  exports2.INT_MIN = -1 << INT_BITS - 1;
+                  exports2.sign = function(v2) {
+                    return (v2 > 0) - (v2 < 0);
+                  };
+                  exports2.abs = function(v2) {
+                    var mask = v2 >> INT_BITS - 1;
+                    return (v2 ^ mask) - mask;
+                  };
+                  exports2.min = function(x2, y2) {
+                    return y2 ^ (x2 ^ y2) & -(x2 < y2);
+                  };
+                  exports2.max = function(x2, y2) {
+                    return x2 ^ (x2 ^ y2) & -(x2 < y2);
+                  };
+                  exports2.isPow2 = function(v2) {
+                    return !(v2 & v2 - 1) && !!v2;
+                  };
+                  exports2.log2 = function(v2) {
+                    var r2, shift;
+                    r2 = (v2 > 65535) << 4;
+                    v2 >>>= r2;
+                    shift = (v2 > 255) << 3;
+                    v2 >>>= shift;
+                    r2 |= shift;
+                    shift = (v2 > 15) << 2;
+                    v2 >>>= shift;
+                    r2 |= shift;
+                    shift = (v2 > 3) << 1;
+                    v2 >>>= shift;
+                    r2 |= shift;
+                    return r2 | v2 >> 1;
+                  };
+                  exports2.log10 = function(v2) {
+                    return v2 >= 1e9 ? 9 : v2 >= 1e8 ? 8 : v2 >= 1e7 ? 7 : v2 >= 1e6 ? 6 : v2 >= 1e5 ? 5 : v2 >= 1e4 ? 4 : v2 >= 1e3 ? 3 : v2 >= 100 ? 2 : v2 >= 10 ? 1 : 0;
+                  };
+                  exports2.popCount = function(v2) {
+                    v2 = v2 - (v2 >>> 1 & 1431655765);
+                    v2 = (v2 & 858993459) + (v2 >>> 2 & 858993459);
+                    return (v2 + (v2 >>> 4) & 252645135) * 16843009 >>> 24;
+                  };
+                  function countTrailingZeros(v2) {
+                    var c2 = 32;
+                    v2 &= -v2;
+                    if (v2) c2--;
+                    if (v2 & 65535) c2 -= 16;
+                    if (v2 & 16711935) c2 -= 8;
+                    if (v2 & 252645135) c2 -= 4;
+                    if (v2 & 858993459) c2 -= 2;
+                    if (v2 & 1431655765) c2 -= 1;
+                    return c2;
+                  }
+                  exports2.countTrailingZeros = countTrailingZeros;
+                  exports2.nextPow2 = function(v2) {
+                    v2 += v2 === 0;
+                    --v2;
+                    v2 |= v2 >>> 1;
+                    v2 |= v2 >>> 2;
+                    v2 |= v2 >>> 4;
+                    v2 |= v2 >>> 8;
+                    v2 |= v2 >>> 16;
+                    return v2 + 1;
+                  };
+                  exports2.prevPow2 = function(v2) {
+                    v2 |= v2 >>> 1;
+                    v2 |= v2 >>> 2;
+                    v2 |= v2 >>> 4;
+                    v2 |= v2 >>> 8;
+                    v2 |= v2 >>> 16;
+                    return v2 - (v2 >>> 1);
+                  };
+                  exports2.parity = function(v2) {
+                    v2 ^= v2 >>> 16;
+                    v2 ^= v2 >>> 8;
+                    v2 ^= v2 >>> 4;
+                    v2 &= 15;
+                    return 27030 >>> v2 & 1;
+                  };
+                  var REVERSE_TABLE = new Array(256);
+                  (function(tab) {
+                    for (var i2 = 0; i2 < 256; ++i2) {
+                      var v2 = i2, r2 = i2, s2 = 7;
+                      for (v2 >>>= 1; v2; v2 >>>= 1) {
+                        r2 <<= 1;
+                        r2 |= v2 & 1;
+                        --s2;
+                      }
+                      tab[i2] = r2 << s2 & 255;
+                    }
+                  })(REVERSE_TABLE);
+                  exports2.reverse = function(v2) {
+                    return REVERSE_TABLE[v2 & 255] << 24 | REVERSE_TABLE[v2 >>> 8 & 255] << 16 | REVERSE_TABLE[v2 >>> 16 & 255] << 8 | REVERSE_TABLE[v2 >>> 24 & 255];
+                  };
+                  exports2.interleave2 = function(x2, y2) {
+                    x2 &= 65535;
+                    x2 = (x2 | x2 << 8) & 16711935;
+                    x2 = (x2 | x2 << 4) & 252645135;
+                    x2 = (x2 | x2 << 2) & 858993459;
+                    x2 = (x2 | x2 << 1) & 1431655765;
+                    y2 &= 65535;
+                    y2 = (y2 | y2 << 8) & 16711935;
+                    y2 = (y2 | y2 << 4) & 252645135;
+                    y2 = (y2 | y2 << 2) & 858993459;
+                    y2 = (y2 | y2 << 1) & 1431655765;
+                    return x2 | y2 << 1;
+                  };
+                  exports2.deinterleave2 = function(v2, n2) {
+                    v2 = v2 >>> n2 & 1431655765;
+                    v2 = (v2 | v2 >>> 1) & 858993459;
+                    v2 = (v2 | v2 >>> 2) & 252645135;
+                    v2 = (v2 | v2 >>> 4) & 16711935;
+                    v2 = (v2 | v2 >>> 16) & 65535;
+                    return v2 << 16 >> 16;
+                  };
+                  exports2.interleave3 = function(x2, y2, z2) {
+                    x2 &= 1023;
+                    x2 = (x2 | x2 << 16) & 4278190335;
+                    x2 = (x2 | x2 << 8) & 251719695;
+                    x2 = (x2 | x2 << 4) & 3272356035;
+                    x2 = (x2 | x2 << 2) & 1227133513;
+                    y2 &= 1023;
+                    y2 = (y2 | y2 << 16) & 4278190335;
+                    y2 = (y2 | y2 << 8) & 251719695;
+                    y2 = (y2 | y2 << 4) & 3272356035;
+                    y2 = (y2 | y2 << 2) & 1227133513;
+                    x2 |= y2 << 1;
+                    z2 &= 1023;
+                    z2 = (z2 | z2 << 16) & 4278190335;
+                    z2 = (z2 | z2 << 8) & 251719695;
+                    z2 = (z2 | z2 << 4) & 3272356035;
+                    z2 = (z2 | z2 << 2) & 1227133513;
+                    return x2 | z2 << 2;
+                  };
+                  exports2.deinterleave3 = function(v2, n2) {
+                    v2 = v2 >>> n2 & 1227133513;
+                    v2 = (v2 | v2 >>> 2) & 3272356035;
+                    v2 = (v2 | v2 >>> 4) & 251719695;
+                    v2 = (v2 | v2 >>> 8) & 4278190335;
+                    v2 = (v2 | v2 >>> 16) & 1023;
+                    return v2 << 22 >> 22;
+                  };
+                  exports2.nextCombination = function(v2) {
+                    var t4 = v2 | v2 - 1;
+                    return t4 + 1 | (~t4 & -~t4) - 1 >>> countTrailingZeros(v2) + 1;
+                  };
+                }
+              ),
+              /***/
+              8866: (
+                /***/
+                function(module22) {
+                  function GLError(rawError, shortMessage, longMessage) {
+                    this.shortMessage = shortMessage || "";
+                    this.longMessage = longMessage || "";
+                    this.rawError = rawError || "";
+                    this.message = "gl-shader: " + (shortMessage || rawError || "") + (longMessage ? "\n" + longMessage : "");
+                    this.stack = new Error().stack;
+                  }
+                  GLError.prototype = new Error();
+                  GLError.prototype.name = "GLError";
+                  GLError.prototype.constructor = GLError;
+                  module22.exports = GLError;
+                }
+              ),
+              /***/
+              8902: (
+                /***/
+                function(module22, __unused_webpack_exports, __webpack_require__2) {
+                  var bsearch = __webpack_require__2(2478);
+                  var orient = __webpack_require__2(3250)[3];
+                  var EVENT_POINT = 0;
+                  var EVENT_END = 1;
+                  var EVENT_START = 2;
+                  module22.exports = monotoneTriangulate;
+                  function PartialHull(a2, b2, idx, lowerIds, upperIds) {
+                    this.a = a2;
+                    this.b = b2;
+                    this.idx = idx;
+                    this.lowerIds = lowerIds;
+                    this.upperIds = upperIds;
+                  }
+                  function Event2(a2, b2, type, idx) {
+                    this.a = a2;
+                    this.b = b2;
+                    this.type = type;
+                    this.idx = idx;
+                  }
+                  function compareEvent(a2, b2) {
+                    var d2 = a2.a[0] - b2.a[0] || a2.a[1] - b2.a[1] || a2.type - b2.type;
+                    if (d2) {
+                      return d2;
+                    }
+                    if (a2.type !== EVENT_POINT) {
+                      d2 = orient(a2.a, a2.b, b2.b);
+                      if (d2) {
+                        return d2;
+                      }
+                    }
+                    return a2.idx - b2.idx;
+                  }
+                  function testPoint(hull, p2) {
+                    return orient(hull.a, hull.b, p2);
+                  }
+                  function addPoint(cells, hulls, points, p2, idx) {
+                    var lo = bsearch.lt(hulls, p2, testPoint);
+                    var hi2 = bsearch.gt(hulls, p2, testPoint);
+                    for (var i2 = lo; i2 < hi2; ++i2) {
+                      var hull = hulls[i2];
+                      var lowerIds = hull.lowerIds;
+                      var m2 = lowerIds.length;
+                      while (m2 > 1 && orient(
+                        points[lowerIds[m2 - 2]],
+                        points[lowerIds[m2 - 1]],
+                        p2
+                      ) > 0) {
+                        cells.push(
+                          [
+                            lowerIds[m2 - 1],
+                            lowerIds[m2 - 2],
+                            idx
+                          ]
+                        );
+                        m2 -= 1;
+                      }
+                      lowerIds.length = m2;
+                      lowerIds.push(idx);
+                      var upperIds = hull.upperIds;
+                      var m2 = upperIds.length;
+                      while (m2 > 1 && orient(
+                        points[upperIds[m2 - 2]],
+                        points[upperIds[m2 - 1]],
+                        p2
+                      ) < 0) {
+                        cells.push(
+                          [
+                            upperIds[m2 - 2],
+                            upperIds[m2 - 1],
+                            idx
+                          ]
+                        );
+                        m2 -= 1;
+                      }
+                      upperIds.length = m2;
+                      upperIds.push(idx);
+                    }
+                  }
+                  function findSplit(hull, edge) {
+                    var d2;
+                    if (hull.a[0] < edge.a[0]) {
+                      d2 = orient(hull.a, hull.b, edge.a);
+                    } else {
+                      d2 = orient(edge.b, edge.a, hull.a);
+                    }
+                    if (d2) {
+                      return d2;
+                    }
+                    if (edge.b[0] < hull.b[0]) {
+                      d2 = orient(hull.a, hull.b, edge.b);
+                    } else {
+                      d2 = orient(edge.b, edge.a, hull.b);
+                    }
+                    return d2 || hull.idx - edge.idx;
+                  }
+                  function splitHulls(hulls, points, event) {
+                    var splitIdx = bsearch.le(hulls, event, findSplit);
+                    var hull = hulls[splitIdx];
+                    var upperIds = hull.upperIds;
+                    var x2 = upperIds[upperIds.length - 1];
+                    hull.upperIds = [x2];
+                    hulls.splice(
+                      splitIdx + 1,
+                      0,
+                      new PartialHull(event.a, event.b, event.idx, [x2], upperIds)
+                    );
+                  }
+                  function mergeHulls(hulls, points, event) {
+                    var tmp2 = event.a;
+                    event.a = event.b;
+                    event.b = tmp2;
+                    var mergeIdx = bsearch.eq(hulls, event, findSplit);
+                    var upper = hulls[mergeIdx];
+                    var lower = hulls[mergeIdx - 1];
+                    lower.upperIds = upper.upperIds;
+                    hulls.splice(mergeIdx, 1);
+                  }
+                  function monotoneTriangulate(points, edges) {
+                    var numPoints = points.length;
+                    var numEdges = edges.length;
+                    var events = [];
+                    for (var i2 = 0; i2 < numPoints; ++i2) {
+                      events.push(new Event2(
+                        points[i2],
+                        null,
+                        EVENT_POINT,
+                        i2
+                      ));
+                    }
+                    for (var i2 = 0; i2 < numEdges; ++i2) {
+                      var e2 = edges[i2];
+                      var a2 = points[e2[0]];
+                      var b2 = points[e2[1]];
+                      if (a2[0] < b2[0]) {
+                        events.push(
+                          new Event2(a2, b2, EVENT_START, i2),
+                          new Event2(b2, a2, EVENT_END, i2)
+                        );
+                      } else if (a2[0] > b2[0]) {
+                        events.push(
+                          new Event2(b2, a2, EVENT_START, i2),
+                          new Event2(a2, b2, EVENT_END, i2)
+                        );
+                      }
+                    }
+                    events.sort(compareEvent);
+                    var minX = events[0].a[0] - (1 + Math.abs(events[0].a[0])) * Math.pow(2, -52);
+                    var hull = [new PartialHull([minX, 1], [minX, 0], -1, [], [])];
+                    var cells = [];
+                    for (var i2 = 0, numEvents = events.length; i2 < numEvents; ++i2) {
+                      var event = events[i2];
+                      var type = event.type;
+                      if (type === EVENT_POINT) {
+                        addPoint(cells, hull, points, event.a, event.idx);
+                      } else if (type === EVENT_START) {
+                        splitHulls(hull, points, event);
+                      } else {
+                        mergeHulls(hull, points, event);
+                      }
+                    }
+                    return cells;
+                  }
+                }
+              ),
+              /***/
+              8954: (
+                /***/
+                function(module22, __unused_webpack_exports, __webpack_require__2) {
+                  module22.exports = incrementalConvexHull;
+                  var orient = __webpack_require__2(3250);
+                  var compareCell = __webpack_require__2(6803).Fw;
+                  function Simplex(vertices, adjacent, boundary) {
+                    this.vertices = vertices;
+                    this.adjacent = adjacent;
+                    this.boundary = boundary;
+                    this.lastVisited = -1;
+                  }
+                  Simplex.prototype.flip = function() {
+                    var t4 = this.vertices[0];
+                    this.vertices[0] = this.vertices[1];
+                    this.vertices[1] = t4;
+                    var u2 = this.adjacent[0];
+                    this.adjacent[0] = this.adjacent[1];
+                    this.adjacent[1] = u2;
+                  };
+                  function GlueFacet(vertices, cell, index) {
+                    this.vertices = vertices;
+                    this.cell = cell;
+                    this.index = index;
+                  }
+                  function compareGlue(a2, b2) {
+                    return compareCell(a2.vertices, b2.vertices);
+                  }
+                  function wrapper(test) {
+                    return function() {
+                      var tuple = this.tuple;
+                      return test.apply(this, tuple);
+                    };
+                  }
+                  function bakeOrient(d2) {
+                    var test = orient[d2 + 1];
+                    if (!test) {
+                      test = orient;
+                    }
+                    return wrapper(test);
+                  }
+                  var BAKED = [];
+                  function Triangulation(dimension, vertices, simplices) {
+                    this.dimension = dimension;
+                    this.vertices = vertices;
+                    this.simplices = simplices;
+                    this.interior = simplices.filter(function(c2) {
+                      return !c2.boundary;
+                    });
+                    this.tuple = new Array(dimension + 1);
+                    for (var i2 = 0; i2 <= dimension; ++i2) {
+                      this.tuple[i2] = this.vertices[i2];
+                    }
+                    var o2 = BAKED[dimension];
+                    if (!o2) {
+                      o2 = BAKED[dimension] = bakeOrient(dimension);
+                    }
+                    this.orient = o2;
+                  }
+                  var proto = Triangulation.prototype;
+                  proto.handleBoundaryDegeneracy = function(cell, point) {
+                    var d2 = this.dimension;
+                    var n2 = this.vertices.length - 1;
+                    var tuple = this.tuple;
+                    var verts = this.vertices;
+                    var toVisit = [cell];
+                    cell.lastVisited = -n2;
+                    while (toVisit.length > 0) {
+                      cell = toVisit.pop();
+                      var cellAdj = cell.adjacent;
+                      for (var i2 = 0; i2 <= d2; ++i2) {
+                        var neighbor = cellAdj[i2];
+                        if (!neighbor.boundary || neighbor.lastVisited <= -n2) {
+                          continue;
+                        }
+                        var nv = neighbor.vertices;
+                        for (var j2 = 0; j2 <= d2; ++j2) {
+                          var vv = nv[j2];
+                          if (vv < 0) {
+                            tuple[j2] = point;
+                          } else {
+                            tuple[j2] = verts[vv];
+                          }
+                        }
+                        var o2 = this.orient();
+                        if (o2 > 0) {
+                          return neighbor;
+                        }
+                        neighbor.lastVisited = -n2;
+                        if (o2 === 0) {
+                          toVisit.push(neighbor);
+                        }
+                      }
+                    }
+                    return null;
+                  };
+                  proto.walk = function(point, random) {
+                    var n2 = this.vertices.length - 1;
+                    var d2 = this.dimension;
+                    var verts = this.vertices;
+                    var tuple = this.tuple;
+                    var initIndex = random ? this.interior.length * Math.random() | 0 : this.interior.length - 1;
+                    var cell = this.interior[initIndex];
+                    outerLoop:
+                      while (!cell.boundary) {
+                        var cellVerts = cell.vertices;
+                        var cellAdj = cell.adjacent;
+                        for (var i2 = 0; i2 <= d2; ++i2) {
+                          tuple[i2] = verts[cellVerts[i2]];
+                        }
+                        cell.lastVisited = n2;
+                        for (var i2 = 0; i2 <= d2; ++i2) {
+                          var neighbor = cellAdj[i2];
+                          if (neighbor.lastVisited >= n2) {
+                            continue;
+                          }
+                          var prev = tuple[i2];
+                          tuple[i2] = point;
+                          var o2 = this.orient();
+                          tuple[i2] = prev;
+                          if (o2 < 0) {
+                            cell = neighbor;
+                            continue outerLoop;
+                          } else {
+                            if (!neighbor.boundary) {
+                              neighbor.lastVisited = n2;
+                            } else {
+                              neighbor.lastVisited = -n2;
+                            }
+                          }
+                        }
+                        return;
+                      }
+                    return cell;
+                  };
+                  proto.addPeaks = function(point, cell) {
+                    var n2 = this.vertices.length - 1;
+                    var d2 = this.dimension;
+                    var verts = this.vertices;
+                    var tuple = this.tuple;
+                    var interior = this.interior;
+                    var simplices = this.simplices;
+                    var tovisit = [cell];
+                    cell.lastVisited = n2;
+                    cell.vertices[cell.vertices.indexOf(-1)] = n2;
+                    cell.boundary = false;
+                    interior.push(cell);
+                    var glueFacets = [];
+                    while (tovisit.length > 0) {
+                      var cell = tovisit.pop();
+                      var cellVerts = cell.vertices;
+                      var cellAdj = cell.adjacent;
+                      var indexOfN = cellVerts.indexOf(n2);
+                      if (indexOfN < 0) {
+                        continue;
+                      }
+                      for (var i2 = 0; i2 <= d2; ++i2) {
+                        if (i2 === indexOfN) {
+                          continue;
+                        }
+                        var neighbor = cellAdj[i2];
+                        if (!neighbor.boundary || neighbor.lastVisited >= n2) {
+                          continue;
+                        }
+                        var nv = neighbor.vertices;
+                        if (neighbor.lastVisited !== -n2) {
+                          var indexOfNeg1 = 0;
+                          for (var j2 = 0; j2 <= d2; ++j2) {
+                            if (nv[j2] < 0) {
+                              indexOfNeg1 = j2;
+                              tuple[j2] = point;
+                            } else {
+                              tuple[j2] = verts[nv[j2]];
+                            }
+                          }
+                          var o2 = this.orient();
+                          if (o2 > 0) {
+                            nv[indexOfNeg1] = n2;
+                            neighbor.boundary = false;
+                            interior.push(neighbor);
+                            tovisit.push(neighbor);
+                            neighbor.lastVisited = n2;
+                            continue;
+                          } else {
+                            neighbor.lastVisited = -n2;
+                          }
+                        }
+                        var na = neighbor.adjacent;
+                        var vverts = cellVerts.slice();
+                        var vadj = cellAdj.slice();
+                        var ncell = new Simplex(vverts, vadj, true);
+                        simplices.push(ncell);
+                        var opposite = na.indexOf(cell);
+                        if (opposite < 0) {
+                          continue;
+                        }
+                        na[opposite] = ncell;
+                        vadj[indexOfN] = neighbor;
+                        vverts[i2] = -1;
+                        vadj[i2] = cell;
+                        cellAdj[i2] = ncell;
+                        ncell.flip();
+                        for (var j2 = 0; j2 <= d2; ++j2) {
+                          var uu = vverts[j2];
+                          if (uu < 0 || uu === n2) {
+                            continue;
+                          }
+                          var nface = new Array(d2 - 1);
+                          var nptr = 0;
+                          for (var k2 = 0; k2 <= d2; ++k2) {
+                            var vv = vverts[k2];
+                            if (vv < 0 || k2 === j2) {
+                              continue;
+                            }
+                            nface[nptr++] = vv;
+                          }
+                          glueFacets.push(new GlueFacet(nface, ncell, j2));
+                        }
+                      }
+                    }
+                    glueFacets.sort(compareGlue);
+                    for (var i2 = 0; i2 + 1 < glueFacets.length; i2 += 2) {
+                      var a2 = glueFacets[i2];
+                      var b2 = glueFacets[i2 + 1];
+                      var ai2 = a2.index;
+                      var bi2 = b2.index;
+                      if (ai2 < 0 || bi2 < 0) {
+                        continue;
+                      }
+                      a2.cell.adjacent[a2.index] = b2.cell;
+                      b2.cell.adjacent[b2.index] = a2.cell;
+                    }
+                  };
+                  proto.insert = function(point, random) {
+                    var verts = this.vertices;
+                    verts.push(point);
+                    var cell = this.walk(point, random);
+                    if (!cell) {
+                      return;
+                    }
+                    var d2 = this.dimension;
+                    var tuple = this.tuple;
+                    for (var i2 = 0; i2 <= d2; ++i2) {
+                      var vv = cell.vertices[i2];
+                      if (vv < 0) {
+                        tuple[i2] = point;
+                      } else {
+                        tuple[i2] = verts[vv];
+                      }
+                    }
+                    var o2 = this.orient(tuple);
+                    if (o2 < 0) {
+                      return;
+                    } else if (o2 === 0) {
+                      cell = this.handleBoundaryDegeneracy(cell, point);
+                      if (!cell) {
+                        return;
+                      }
+                    }
+                    this.addPeaks(point, cell);
+                  };
+                  proto.boundary = function() {
+                    var d2 = this.dimension;
+                    var boundary = [];
+                    var cells = this.simplices;
+                    var nc2 = cells.length;
+                    for (var i2 = 0; i2 < nc2; ++i2) {
+                      var c2 = cells[i2];
+                      if (c2.boundary) {
+                        var bcell = new Array(d2);
+                        var cv = c2.vertices;
+                        var ptr = 0;
+                        var parity = 0;
+                        for (var j2 = 0; j2 <= d2; ++j2) {
+                          if (cv[j2] >= 0) {
+                            bcell[ptr++] = cv[j2];
+                          } else {
+                            parity = j2 & 1;
+                          }
+                        }
+                        if (parity === (d2 & 1)) {
+                          var t4 = bcell[0];
+                          bcell[0] = bcell[1];
+                          bcell[1] = t4;
+                        }
+                        boundary.push(bcell);
+                      }
+                    }
+                    return boundary;
+                  };
+                  function incrementalConvexHull(points, randomSearch) {
+                    var n2 = points.length;
+                    if (n2 === 0) {
+                      throw new Error("Must have at least d+1 points");
+                    }
+                    var d2 = points[0].length;
+                    if (n2 <= d2) {
+                      throw new Error("Must input at least d+1 points");
+                    }
+                    var initialSimplex = points.slice(0, d2 + 1);
+                    var o2 = orient.apply(void 0, initialSimplex);
+                    if (o2 === 0) {
+                      throw new Error("Input not in general position");
+                    }
+                    var initialCoords = new Array(d2 + 1);
+                    for (var i2 = 0; i2 <= d2; ++i2) {
+                      initialCoords[i2] = i2;
+                    }
+                    if (o2 < 0) {
+                      initialCoords[0] = 1;
+                      initialCoords[1] = 0;
+                    }
+                    var initialCell = new Simplex(initialCoords, new Array(d2 + 1), false);
+                    var boundary = initialCell.adjacent;
+                    var list = new Array(d2 + 2);
+                    for (var i2 = 0; i2 <= d2; ++i2) {
+                      var verts = initialCoords.slice();
+                      for (var j2 = 0; j2 <= d2; ++j2) {
+                        if (j2 === i2) {
+                          verts[j2] = -1;
+                        }
+                      }
+                      var t4 = verts[0];
+                      verts[0] = verts[1];
+                      verts[1] = t4;
+                      var cell = new Simplex(verts, new Array(d2 + 1), true);
+                      boundary[i2] = cell;
+                      list[i2] = cell;
+                    }
+                    list[d2 + 1] = initialCell;
+                    for (var i2 = 0; i2 <= d2; ++i2) {
+                      var verts = boundary[i2].vertices;
+                      var adj = boundary[i2].adjacent;
+                      for (var j2 = 0; j2 <= d2; ++j2) {
+                        var v2 = verts[j2];
+                        if (v2 < 0) {
+                          adj[j2] = initialCell;
+                          continue;
+                        }
+                        for (var k2 = 0; k2 <= d2; ++k2) {
+                          if (boundary[k2].vertices.indexOf(v2) < 0) {
+                            adj[j2] = boundary[k2];
+                          }
+                        }
+                      }
+                    }
+                    var triangles = new Triangulation(d2, initialSimplex, list);
+                    var useRandom = !!randomSearch;
+                    for (var i2 = d2 + 1; i2 < n2; ++i2) {
+                      triangles.insert(points[i2], useRandom);
+                    }
+                    return triangles.boundary();
+                  }
+                }
+              ),
+              /***/
+              8987: (
+                /***/
+                function(module22, __unused_webpack_exports, __webpack_require__2) {
+                  var rat = __webpack_require__2(7842);
+                  var mul = __webpack_require__2(6504);
+                  module22.exports = muls;
+                  function muls(a2, x2) {
+                    var s2 = rat(x2);
+                    var n2 = a2.length;
+                    var r2 = new Array(n2);
+                    for (var i2 = 0; i2 < n2; ++i2) {
+                      r2[i2] = mul(a2[i2], s2);
+                    }
+                    return r2;
+                  }
+                }
+              ),
+              /***/
+              9060: (
+                /***/
+                function(module22, __unused_webpack_exports, __webpack_require__2) {
+                  var createShader = __webpack_require__2(9405);
+                  var createBuffer = __webpack_require__2(2762);
+                  var createVAO = __webpack_require__2(8116);
+                  var createTexture2 = __webpack_require__2(7766);
+                  var multiply2 = __webpack_require__2(6760);
+                  var invert2 = __webpack_require__2(7608);
+                  var ndarray = __webpack_require__2(9618);
+                  var colormap = __webpack_require__2(6729);
+                  var IDENTITY2 = [
+                    1,
+                    0,
+                    0,
+                    0,
+                    0,
+                    1,
+                    0,
+                    0,
+                    0,
+                    0,
+                    1,
+                    0,
+                    0,
+                    0,
+                    0,
+                    1
+                  ];
+                  function VectorMesh(gl2, texture, triShader, pickShader, trianglePositions, triangleVectors, triangleIds, triangleColors, triangleUVs, triangleVAO, traceType) {
+                    this.gl = gl2;
+                    this.pixelRatio = 1;
+                    this.cells = [];
+                    this.positions = [];
+                    this.intensity = [];
+                    this.texture = texture;
+                    this.dirty = true;
+                    this.triShader = triShader;
+                    this.pickShader = pickShader;
+                    this.trianglePositions = trianglePositions;
+                    this.triangleVectors = triangleVectors;
+                    this.triangleColors = triangleColors;
+                    this.triangleUVs = triangleUVs;
+                    this.triangleIds = triangleIds;
+                    this.triangleVAO = triangleVAO;
+                    this.triangleCount = 0;
+                    this.pickId = 1;
+                    this.bounds = [
+                      [Infinity, Infinity, Infinity],
+                      [-Infinity, -Infinity, -Infinity]
+                    ];
+                    this.clipBounds = [
+                      [-Infinity, -Infinity, -Infinity],
+                      [Infinity, Infinity, Infinity]
+                    ];
+                    this.lightPosition = [1e5, 1e5, 0];
+                    this.ambientLight = 0.8;
+                    this.diffuseLight = 0.8;
+                    this.specularLight = 2;
+                    this.roughness = 0.5;
+                    this.fresnel = 1.5;
+                    this.opacity = 1;
+                    this.traceType = traceType;
+                    this.tubeScale = 1;
+                    this.coneScale = 2;
+                    this.vectorScale = 1;
+                    this.coneOffset = 0.25;
+                    this._model = IDENTITY2;
+                    this._view = IDENTITY2;
+                    this._projection = IDENTITY2;
+                    this._resolution = [1, 1];
+                  }
+                  var proto = VectorMesh.prototype;
+                  proto.isOpaque = function() {
+                    return this.opacity >= 1;
+                  };
+                  proto.isTransparent = function() {
+                    return this.opacity < 1;
+                  };
+                  proto.pickSlots = 1;
+                  proto.setPickBase = function(id2) {
+                    this.pickId = id2;
+                  };
+                  function genColormap(param) {
+                    var colors = colormap({
+                      colormap: param,
+                      nshades: 256,
+                      format: "rgba"
+                    });
+                    var result = new Uint8Array(256 * 4);
+                    for (var i2 = 0; i2 < 256; ++i2) {
+                      var c2 = colors[i2];
+                      for (var j2 = 0; j2 < 3; ++j2) {
+                        result[4 * i2 + j2] = c2[j2];
+                      }
+                      result[4 * i2 + 3] = c2[3] * 255;
+                    }
+                    return ndarray(result, [256, 256, 4], [4, 0, 1]);
+                  }
+                  function takeZComponent(array) {
+                    var n2 = array.length;
+                    var result = new Array(n2);
+                    for (var i2 = 0; i2 < n2; ++i2) {
+                      result[i2] = array[i2][2];
+                    }
+                    return result;
+                  }
+                  proto.update = function(params) {
+                    params = params || {};
+                    var gl2 = this.gl;
+                    this.dirty = true;
+                    if ("lightPosition" in params) {
+                      this.lightPosition = params.lightPosition;
+                    }
+                    if ("opacity" in params) {
+                      this.opacity = params.opacity;
+                    }
+                    if ("ambient" in params) {
+                      this.ambientLight = params.ambient;
+                    }
+                    if ("diffuse" in params) {
+                      this.diffuseLight = params.diffuse;
+                    }
+                    if ("specular" in params) {
+                      this.specularLight = params.specular;
+                    }
+                    if ("roughness" in params) {
+                      this.roughness = params.roughness;
+                    }
+                    if ("fresnel" in params) {
+                      this.fresnel = params.fresnel;
+                    }
+                    if (params.tubeScale !== void 0) {
+                      this.tubeScale = params.tubeScale;
+                    }
+                    if (params.vectorScale !== void 0) {
+                      this.vectorScale = params.vectorScale;
+                    }
+                    if (params.coneScale !== void 0) {
+                      this.coneScale = params.coneScale;
+                    }
+                    if (params.coneOffset !== void 0) {
+                      this.coneOffset = params.coneOffset;
+                    }
+                    if (params.colormap) {
+                      this.texture.shape = [256, 256];
+                      this.texture.minFilter = gl2.LINEAR_MIPMAP_LINEAR;
+                      this.texture.magFilter = gl2.LINEAR;
+                      this.texture.setPixels(genColormap(params.colormap));
+                      this.texture.generateMipmap();
+                    }
+                    var cells = params.cells;
+                    var positions = params.positions;
+                    var vectors = params.vectors;
+                    if (!positions || !cells || !vectors) {
+                      return;
+                    }
+                    var tPos = [];
+                    var tVec = [];
+                    var tCol = [];
+                    var tUVs = [];
+                    var tIds = [];
+                    this.cells = cells;
+                    this.positions = positions;
+                    this.vectors = vectors;
+                    var meshColor = params.meshColor || [1, 1, 1, 1];
+                    var vertexIntensity = params.vertexIntensity;
+                    var intensityLo = Infinity;
+                    var intensityHi = -Infinity;
+                    if (vertexIntensity) {
+                      if (params.vertexIntensityBounds) {
+                        intensityLo = +params.vertexIntensityBounds[0];
+                        intensityHi = +params.vertexIntensityBounds[1];
+                      } else {
+                        for (var i2 = 0; i2 < vertexIntensity.length; ++i2) {
+                          var f2 = vertexIntensity[i2];
+                          intensityLo = Math.min(intensityLo, f2);
+                          intensityHi = Math.max(intensityHi, f2);
+                        }
+                      }
+                    } else {
+                      for (var i2 = 0; i2 < positions.length; ++i2) {
+                        var f2 = positions[i2][2];
+                        intensityLo = Math.min(intensityLo, f2);
+                        intensityHi = Math.max(intensityHi, f2);
+                      }
+                    }
+                    if (vertexIntensity) {
+                      this.intensity = vertexIntensity;
+                    } else {
+                      this.intensity = takeZComponent(positions);
+                    }
+                    this.bounds = [[Infinity, Infinity, Infinity], [-Infinity, -Infinity, -Infinity]];
+                    for (var i2 = 0; i2 < positions.length; ++i2) {
+                      var p2 = positions[i2];
+                      for (var j2 = 0; j2 < 3; ++j2) {
+                        if (isNaN(p2[j2]) || !isFinite(p2[j2])) {
+                          continue;
+                        }
+                        this.bounds[0][j2] = Math.min(this.bounds[0][j2], p2[j2]);
+                        this.bounds[1][j2] = Math.max(this.bounds[1][j2], p2[j2]);
+                      }
+                    }
+                    var triangleCount = 0;
+                    fill_loop:
+                      for (var i2 = 0; i2 < cells.length; ++i2) {
+                        var cell = cells[i2];
+                        switch (cell.length) {
+                          case 3:
+                            for (var j2 = 0; j2 < 3; ++j2) {
+                              var v2 = cell[j2];
+                              var p2 = positions[v2];
+                              for (var k2 = 0; k2 < 3; ++k2) {
+                                if (isNaN(p2[k2]) || !isFinite(p2[k2])) {
+                                  continue fill_loop;
+                                }
+                              }
+                            }
+                            for (var j2 = 0; j2 < 3; ++j2) {
+                              var v2 = cell[2 - j2];
+                              var p2 = positions[v2];
+                              tPos.push(p2[0], p2[1], p2[2], p2[3]);
+                              var w2 = vectors[v2];
+                              tVec.push(w2[0], w2[1], w2[2], w2[3] || 0);
+                              var c2 = meshColor;
+                              if (c2.length === 3) {
+                                tCol.push(c2[0], c2[1], c2[2], 1);
+                              } else {
+                                tCol.push(c2[0], c2[1], c2[2], c2[3]);
+                              }
+                              var uv;
+                              if (vertexIntensity) {
+                                uv = [
+                                  (vertexIntensity[v2] - intensityLo) / (intensityHi - intensityLo),
+                                  0
+                                ];
+                              } else {
+                                uv = [
+                                  (p2[2] - intensityLo) / (intensityHi - intensityLo),
+                                  0
+                                ];
+                              }
+                              tUVs.push(uv[0], uv[1]);
+                              tIds.push(i2);
+                            }
+                            triangleCount += 1;
+                            break;
+                        }
+                      }
+                    this.triangleCount = triangleCount;
+                    this.trianglePositions.update(tPos);
+                    this.triangleVectors.update(tVec);
+                    this.triangleColors.update(tCol);
+                    this.triangleUVs.update(tUVs);
+                    this.triangleIds.update(new Uint32Array(tIds));
+                  };
+                  proto.drawTransparent = proto.draw = function(params) {
+                    params = params || {};
+                    var gl2 = this.gl;
+                    var model = params.model || IDENTITY2;
+                    var view = params.view || IDENTITY2;
+                    var projection = params.projection || IDENTITY2;
+                    var clipBounds = [[-1e6, -1e6, -1e6], [1e6, 1e6, 1e6]];
+                    for (var i2 = 0; i2 < 3; ++i2) {
+                      clipBounds[0][i2] = Math.max(clipBounds[0][i2], this.clipBounds[0][i2]);
+                      clipBounds[1][i2] = Math.min(clipBounds[1][i2], this.clipBounds[1][i2]);
+                    }
+                    var uniforms = {
+                      model,
+                      view,
+                      projection,
+                      inverseModel: IDENTITY2.slice(),
+                      clipBounds,
+                      kambient: this.ambientLight,
+                      kdiffuse: this.diffuseLight,
+                      kspecular: this.specularLight,
+                      roughness: this.roughness,
+                      fresnel: this.fresnel,
+                      eyePosition: [0, 0, 0],
+                      lightPosition: [0, 0, 0],
+                      opacity: this.opacity,
+                      tubeScale: this.tubeScale,
+                      vectorScale: this.vectorScale,
+                      coneScale: this.coneScale,
+                      coneOffset: this.coneOffset,
+                      texture: 0
+                    };
+                    uniforms.inverseModel = invert2(uniforms.inverseModel, uniforms.model);
+                    gl2.disable(gl2.CULL_FACE);
+                    this.texture.bind(0);
+                    var invCameraMatrix = new Array(16);
+                    multiply2(invCameraMatrix, uniforms.view, uniforms.model);
+                    multiply2(invCameraMatrix, uniforms.projection, invCameraMatrix);
+                    invert2(invCameraMatrix, invCameraMatrix);
+                    for (var i2 = 0; i2 < 3; ++i2) {
+                      uniforms.eyePosition[i2] = invCameraMatrix[12 + i2] / invCameraMatrix[15];
+                    }
+                    var w2 = invCameraMatrix[15];
+                    for (var i2 = 0; i2 < 3; ++i2) {
+                      w2 += this.lightPosition[i2] * invCameraMatrix[4 * i2 + 3];
+                    }
+                    for (var i2 = 0; i2 < 3; ++i2) {
+                      var s2 = invCameraMatrix[12 + i2];
+                      for (var j2 = 0; j2 < 3; ++j2) {
+                        s2 += invCameraMatrix[4 * j2 + i2] * this.lightPosition[j2];
+                      }
+                      uniforms.lightPosition[i2] = s2 / w2;
+                    }
+                    if (this.triangleCount > 0) {
+                      var shader = this.triShader;
+                      shader.bind();
+                      shader.uniforms = uniforms;
+                      this.triangleVAO.bind();
+                      gl2.drawArrays(gl2.TRIANGLES, 0, this.triangleCount * 3);
+                      this.triangleVAO.unbind();
+                    }
+                  };
+                  proto.drawPick = function(params) {
+                    params = params || {};
+                    var gl2 = this.gl;
+                    var model = params.model || IDENTITY2;
+                    var view = params.view || IDENTITY2;
+                    var projection = params.projection || IDENTITY2;
+                    var clipBounds = [[-1e6, -1e6, -1e6], [1e6, 1e6, 1e6]];
+                    for (var i2 = 0; i2 < 3; ++i2) {
+                      clipBounds[0][i2] = Math.max(clipBounds[0][i2], this.clipBounds[0][i2]);
+                      clipBounds[1][i2] = Math.min(clipBounds[1][i2], this.clipBounds[1][i2]);
+                    }
+                    this._model = [].slice.call(model);
+                    this._view = [].slice.call(view);
+                    this._projection = [].slice.call(projection);
+                    this._resolution = [gl2.drawingBufferWidth, gl2.drawingBufferHeight];
+                    var uniforms = {
+                      model,
+                      view,
+                      projection,
+                      clipBounds,
+                      tubeScale: this.tubeScale,
+                      vectorScale: this.vectorScale,
+                      coneScale: this.coneScale,
+                      coneOffset: this.coneOffset,
+                      pickId: this.pickId / 255
+                    };
+                    var shader = this.pickShader;
+                    shader.bind();
+                    shader.uniforms = uniforms;
+                    if (this.triangleCount > 0) {
+                      this.triangleVAO.bind();
+                      gl2.drawArrays(gl2.TRIANGLES, 0, this.triangleCount * 3);
+                      this.triangleVAO.unbind();
+                    }
+                  };
+                  proto.pick = function(pickData) {
+                    if (!pickData) {
+                      return null;
+                    }
+                    if (pickData.id !== this.pickId) {
+                      return null;
+                    }
+                    var cellId = pickData.value[0] + 256 * pickData.value[1] + 65536 * pickData.value[2];
+                    var cell = this.cells[cellId];
+                    var pos = this.positions[cell[1]].slice(0, 3);
+                    var result = {
+                      position: pos,
+                      dataCoordinate: pos,
+                      index: Math.floor(cell[1] / 48)
+                    };
+                    if (this.traceType === "cone") {
+                      result.index = Math.floor(cell[1] / 48);
+                    } else if (this.traceType === "streamtube") {
+                      result.intensity = this.intensity[cell[1]];
+                      result.velocity = this.vectors[cell[1]].slice(0, 3);
+                      result.divergence = this.vectors[cell[1]][3];
+                      result.index = cellId;
+                    }
+                    return result;
+                  };
+                  proto.dispose = function() {
+                    this.texture.dispose();
+                    this.triShader.dispose();
+                    this.pickShader.dispose();
+                    this.triangleVAO.dispose();
+                    this.trianglePositions.dispose();
+                    this.triangleVectors.dispose();
+                    this.triangleColors.dispose();
+                    this.triangleUVs.dispose();
+                    this.triangleIds.dispose();
+                  };
+                  function createMeshShader(gl2, shaders) {
+                    var shader = createShader(
+                      gl2,
+                      shaders.meshShader.vertex,
+                      shaders.meshShader.fragment,
+                      null,
+                      shaders.meshShader.attributes
+                    );
+                    shader.attributes.position.location = 0;
+                    shader.attributes.color.location = 2;
+                    shader.attributes.uv.location = 3;
+                    shader.attributes.vector.location = 4;
+                    return shader;
+                  }
+                  function createPickShader(gl2, shaders) {
+                    var shader = createShader(
+                      gl2,
+                      shaders.pickShader.vertex,
+                      shaders.pickShader.fragment,
+                      null,
+                      shaders.pickShader.attributes
+                    );
+                    shader.attributes.position.location = 0;
+                    shader.attributes.id.location = 1;
+                    shader.attributes.vector.location = 4;
+                    return shader;
+                  }
+                  function createVectorMesh(gl2, params, opts) {
+                    var shaders = opts.shaders;
+                    if (arguments.length === 1) {
+                      params = gl2;
+                      gl2 = params.gl;
+                    }
+                    var triShader = createMeshShader(gl2, shaders);
+                    var pickShader = createPickShader(gl2, shaders);
+                    var meshTexture = createTexture2(
+                      gl2,
+                      ndarray(new Uint8Array([255, 255, 255, 255]), [1, 1, 4])
+                    );
+                    meshTexture.generateMipmap();
+                    meshTexture.minFilter = gl2.LINEAR_MIPMAP_LINEAR;
+                    meshTexture.magFilter = gl2.LINEAR;
+                    var trianglePositions = createBuffer(gl2);
+                    var triangleVectors = createBuffer(gl2);
+                    var triangleColors = createBuffer(gl2);
+                    var triangleUVs = createBuffer(gl2);
+                    var triangleIds = createBuffer(gl2);
+                    var triangleVAO = createVAO(gl2, [
+                      {
+                        buffer: trianglePositions,
+                        type: gl2.FLOAT,
+                        size: 4
+                      },
+                      {
+                        buffer: triangleIds,
+                        type: gl2.UNSIGNED_BYTE,
+                        size: 4,
+                        normalized: true
+                      },
+                      {
+                        buffer: triangleColors,
+                        type: gl2.FLOAT,
+                        size: 4
+                      },
+                      {
+                        buffer: triangleUVs,
+                        type: gl2.FLOAT,
+                        size: 2
+                      },
+                      {
+                        buffer: triangleVectors,
+                        type: gl2.FLOAT,
+                        size: 4
+                      }
+                    ]);
+                    var mesh = new VectorMesh(
+                      gl2,
+                      meshTexture,
+                      triShader,
+                      pickShader,
+                      trianglePositions,
+                      triangleVectors,
+                      triangleIds,
+                      triangleColors,
+                      triangleUVs,
+                      triangleVAO,
+                      opts.traceType || "cone"
+                    );
+                    mesh.update(params);
+                    return mesh;
+                  }
+                  module22.exports = createVectorMesh;
+                }
+              ),
+              /***/
+              9127: (
+                /***/
+                function(module22, __unused_webpack_exports, __webpack_require__2) {
+                  module22.exports = boundary;
+                  var bnd = __webpack_require__2(6204);
+                  var reduce = __webpack_require__2(5771);
+                  function boundary(cells) {
+                    return reduce(bnd(cells));
+                  }
+                }
+              ),
+              /***/
+              9131: (
+                /***/
+                function(module22, __unused_webpack_exports, __webpack_require__2) {
+                  var vecNormalize = __webpack_require__2(5177);
+                  var vecScale = __webpack_require__2(9288);
+                  module22.exports = random;
+                  function random(out, scale2) {
+                    scale2 = scale2 || 1;
+                    out[0] = Math.random();
+                    out[1] = Math.random();
+                    out[2] = Math.random();
+                    out[3] = Math.random();
+                    vecNormalize(out, out);
+                    vecScale(out, out, scale2);
+                    return out;
+                  }
+                }
+              ),
+              /***/
+              9165: (
+                /***/
+                function(module22, __unused_webpack_exports, __webpack_require__2) {
+                  module22.exports = createErrorBars;
+                  var createBuffer = __webpack_require__2(2762);
+                  var createVAO = __webpack_require__2(8116);
+                  var createShader = __webpack_require__2(3436);
+                  var IDENTITY2 = [
+                    1,
+                    0,
+                    0,
+                    0,
+                    0,
+                    1,
+                    0,
+                    0,
+                    0,
+                    0,
+                    1,
+                    0,
+                    0,
+                    0,
+                    0,
+                    1
+                  ];
+                  function ErrorBars(gl2, buffer, vao, shader) {
+                    this.gl = gl2;
+                    this.shader = shader;
+                    this.buffer = buffer;
+                    this.vao = vao;
+                    this.pixelRatio = 1;
+                    this.bounds = [[Infinity, Infinity, Infinity], [-Infinity, -Infinity, -Infinity]];
+                    this.clipBounds = [[-Infinity, -Infinity, -Infinity], [Infinity, Infinity, Infinity]];
+                    this.lineWidth = [1, 1, 1];
+                    this.capSize = [10, 10, 10];
+                    this.lineCount = [0, 0, 0];
+                    this.lineOffset = [0, 0, 0];
+                    this.opacity = 1;
+                    this.hasAlpha = false;
+                  }
+                  var proto = ErrorBars.prototype;
+                  proto.isOpaque = function() {
+                    return !this.hasAlpha;
+                  };
+                  proto.isTransparent = function() {
+                    return this.hasAlpha;
+                  };
+                  proto.drawTransparent = proto.draw = function(cameraParams) {
+                    var gl2 = this.gl;
+                    var uniforms = this.shader.uniforms;
+                    this.shader.bind();
+                    var view = uniforms.view = cameraParams.view || IDENTITY2;
+                    var projection = uniforms.projection = cameraParams.projection || IDENTITY2;
+                    uniforms.model = cameraParams.model || IDENTITY2;
+                    uniforms.clipBounds = this.clipBounds;
+                    uniforms.opacity = this.opacity;
+                    var cx = view[12];
+                    var cy = view[13];
+                    var cz = view[14];
+                    var cw = view[15];
+                    var isOrtho = cameraParams._ortho || false;
+                    var orthoFix = isOrtho ? 2 : 1;
+                    var pixelScaleF = orthoFix * this.pixelRatio * (projection[3] * cx + projection[7] * cy + projection[11] * cz + projection[15] * cw) / gl2.drawingBufferHeight;
+                    this.vao.bind();
+                    for (var i2 = 0; i2 < 3; ++i2) {
+                      gl2.lineWidth(this.lineWidth[i2] * this.pixelRatio);
+                      uniforms.capSize = this.capSize[i2] * pixelScaleF;
+                      if (this.lineCount[i2]) {
+                        gl2.drawArrays(gl2.LINES, this.lineOffset[i2], this.lineCount[i2]);
+                      }
+                    }
+                    this.vao.unbind();
+                  };
+                  function updateBounds(bounds, point) {
+                    for (var i2 = 0; i2 < 3; ++i2) {
+                      bounds[0][i2] = Math.min(bounds[0][i2], point[i2]);
+                      bounds[1][i2] = Math.max(bounds[1][i2], point[i2]);
+                    }
+                  }
+                  var FACE_TABLE = function() {
+                    var table = new Array(3);
+                    for (var d2 = 0; d2 < 3; ++d2) {
+                      var row = [];
+                      for (var j2 = 1; j2 <= 2; ++j2) {
+                        for (var s2 = -1; s2 <= 1; s2 += 2) {
+                          var u2 = (j2 + d2) % 3;
+                          var y2 = [0, 0, 0];
+                          y2[u2] = s2;
+                          row.push(y2);
+                        }
+                      }
+                      table[d2] = row;
+                    }
+                    return table;
+                  }();
+                  function emitFace(verts, x2, c2, d2) {
+                    var offsets = FACE_TABLE[d2];
+                    for (var i2 = 0; i2 < offsets.length; ++i2) {
+                      var o2 = offsets[i2];
+                      verts.push(
+                        x2[0],
+                        x2[1],
+                        x2[2],
+                        c2[0],
+                        c2[1],
+                        c2[2],
+                        c2[3],
+                        o2[0],
+                        o2[1],
+                        o2[2]
+                      );
+                    }
+                    return offsets.length;
+                  }
+                  proto.update = function(options) {
+                    options = options || {};
+                    if ("lineWidth" in options) {
+                      this.lineWidth = options.lineWidth;
+                      if (!Array.isArray(this.lineWidth)) {
+                        this.lineWidth = [this.lineWidth, this.lineWidth, this.lineWidth];
+                      }
+                    }
+                    if ("capSize" in options) {
+                      this.capSize = options.capSize;
+                      if (!Array.isArray(this.capSize)) {
+                        this.capSize = [this.capSize, this.capSize, this.capSize];
+                      }
+                    }
+                    this.hasAlpha = false;
+                    if ("opacity" in options) {
+                      this.opacity = +options.opacity;
+                      if (this.opacity < 1) {
+                        this.hasAlpha = true;
+                      }
+                    }
+                    var color22 = options.color || [[0, 0, 0], [0, 0, 0], [0, 0, 0]];
+                    var position = options.position;
+                    var error = options.error;
+                    if (!Array.isArray(color22[0])) {
+                      color22 = [color22, color22, color22];
+                    }
+                    if (position && error) {
+                      var verts = [];
+                      var n2 = position.length;
+                      var vertexCount = 0;
+                      this.bounds = [
+                        [Infinity, Infinity, Infinity],
+                        [-Infinity, -Infinity, -Infinity]
+                      ];
+                      this.lineCount = [0, 0, 0];
+                      for (var j2 = 0; j2 < 3; ++j2) {
+                        this.lineOffset[j2] = vertexCount;
+                        i_loop:
+                          for (var i2 = 0; i2 < n2; ++i2) {
+                            var p2 = position[i2];
+                            for (var k2 = 0; k2 < 3; ++k2) {
+                              if (isNaN(p2[k2]) || !isFinite(p2[k2])) {
+                                continue i_loop;
+                              }
+                            }
+                            var e2 = error[i2];
+                            var c2 = color22[j2];
+                            if (Array.isArray(c2[0])) {
+                              c2 = color22[i2];
+                            }
+                            if (c2.length === 3) {
+                              c2 = [c2[0], c2[1], c2[2], 1];
+                            } else if (c2.length === 4) {
+                              c2 = [c2[0], c2[1], c2[2], c2[3]];
+                              if (!this.hasAlpha && c2[3] < 1) this.hasAlpha = true;
+                            }
+                            if (isNaN(e2[0][j2]) || isNaN(e2[1][j2])) {
+                              continue;
+                            }
+                            if (e2[0][j2] < 0) {
+                              var x2 = p2.slice();
+                              x2[j2] += e2[0][j2];
+                              verts.push(
+                                p2[0],
+                                p2[1],
+                                p2[2],
+                                c2[0],
+                                c2[1],
+                                c2[2],
+                                c2[3],
+                                0,
+                                0,
+                                0,
+                                x2[0],
+                                x2[1],
+                                x2[2],
+                                c2[0],
+                                c2[1],
+                                c2[2],
+                                c2[3],
+                                0,
+                                0,
+                                0
+                              );
+                              updateBounds(this.bounds, x2);
+                              vertexCount += 2 + emitFace(verts, x2, c2, j2);
+                            }
+                            if (e2[1][j2] > 0) {
+                              var x2 = p2.slice();
+                              x2[j2] += e2[1][j2];
+                              verts.push(
+                                p2[0],
+                                p2[1],
+                                p2[2],
+                                c2[0],
+                                c2[1],
+                                c2[2],
+                                c2[3],
+                                0,
+                                0,
+                                0,
+                                x2[0],
+                                x2[1],
+                                x2[2],
+                                c2[0],
+                                c2[1],
+                                c2[2],
+                                c2[3],
+                                0,
+                                0,
+                                0
+                              );
+                              updateBounds(this.bounds, x2);
+                              vertexCount += 2 + emitFace(verts, x2, c2, j2);
+                            }
+                          }
+                        this.lineCount[j2] = vertexCount - this.lineOffset[j2];
+                      }
+                      this.buffer.update(verts);
+                    }
+                  };
+                  proto.dispose = function() {
+                    this.shader.dispose();
+                    this.buffer.dispose();
+                    this.vao.dispose();
+                  };
+                  function createErrorBars(options) {
+                    var gl2 = options.gl;
+                    var buffer = createBuffer(gl2);
+                    var vao = createVAO(gl2, [
+                      {
+                        buffer,
+                        type: gl2.FLOAT,
+                        size: 3,
+                        offset: 0,
+                        stride: 40
+                      },
+                      {
+                        buffer,
+                        type: gl2.FLOAT,
+                        size: 4,
+                        offset: 12,
+                        stride: 40
+                      },
+                      {
+                        buffer,
+                        type: gl2.FLOAT,
+                        size: 3,
+                        offset: 28,
+                        stride: 40
+                      }
+                    ]);
+                    var shader = createShader(gl2);
+                    shader.attributes.position.location = 0;
+                    shader.attributes.color.location = 1;
+                    shader.attributes.offset.location = 2;
+                    var result = new ErrorBars(gl2, buffer, vao, shader);
+                    result.update(options);
+                    return result;
+                  }
+                }
+              ),
+              /***/
+              9215: (
+                /***/
+                function(module22, __unused_webpack_exports, __webpack_require__2) {
+                  module22.exports = createFilteredVector;
+                  var cubicHermite = __webpack_require__2(4769);
+                  var bsearch = __webpack_require__2(2478);
+                  function clamp2(lo, hi2, x2) {
+                    return Math.min(hi2, Math.max(lo, x2));
+                  }
+                  function FilteredVector(state0, velocity0, t02) {
+                    this.dimension = state0.length;
+                    this.bounds = [new Array(this.dimension), new Array(this.dimension)];
+                    for (var i2 = 0; i2 < this.dimension; ++i2) {
+                      this.bounds[0][i2] = -Infinity;
+                      this.bounds[1][i2] = Infinity;
+                    }
+                    this._state = state0.slice().reverse();
+                    this._velocity = velocity0.slice().reverse();
+                    this._time = [t02];
+                    this._scratch = [state0.slice(), state0.slice(), state0.slice(), state0.slice(), state0.slice()];
+                  }
+                  var proto = FilteredVector.prototype;
+                  proto.flush = function(t4) {
+                    var idx = bsearch.gt(this._time, t4) - 1;
+                    if (idx <= 0) {
+                      return;
+                    }
+                    this._time.splice(0, idx);
+                    this._state.splice(0, idx * this.dimension);
+                    this._velocity.splice(0, idx * this.dimension);
+                  };
+                  proto.curve = function(t4) {
+                    var time = this._time;
+                    var n2 = time.length;
+                    var idx = bsearch.le(time, t4);
+                    var result = this._scratch[0];
+                    var state = this._state;
+                    var velocity = this._velocity;
+                    var d2 = this.dimension;
+                    var bounds = this.bounds;
+                    if (idx < 0) {
+                      var ptr = d2 - 1;
+                      for (var i2 = 0; i2 < d2; ++i2, --ptr) {
+                        result[i2] = state[ptr];
+                      }
+                    } else if (idx >= n2 - 1) {
+                      var ptr = state.length - 1;
+                      var tf2 = t4 - time[n2 - 1];
+                      for (var i2 = 0; i2 < d2; ++i2, --ptr) {
+                        result[i2] = state[ptr] + tf2 * velocity[ptr];
+                      }
+                    } else {
+                      var ptr = d2 * (idx + 1) - 1;
+                      var t02 = time[idx];
+                      var t12 = time[idx + 1];
+                      var dt2 = t12 - t02 || 1;
+                      var x0 = this._scratch[1];
+                      var x1 = this._scratch[2];
+                      var v0 = this._scratch[3];
+                      var v1 = this._scratch[4];
+                      var steady = true;
+                      for (var i2 = 0; i2 < d2; ++i2, --ptr) {
+                        x0[i2] = state[ptr];
+                        v0[i2] = velocity[ptr] * dt2;
+                        x1[i2] = state[ptr + d2];
+                        v1[i2] = velocity[ptr + d2] * dt2;
+                        steady = steady && (x0[i2] === x1[i2] && v0[i2] === v1[i2] && v0[i2] === 0);
+                      }
+                      if (steady) {
+                        for (var i2 = 0; i2 < d2; ++i2) {
+                          result[i2] = x0[i2];
+                        }
+                      } else {
+                        cubicHermite(x0, v0, x1, v1, (t4 - t02) / dt2, result);
+                      }
+                    }
+                    var lo = bounds[0];
+                    var hi2 = bounds[1];
+                    for (var i2 = 0; i2 < d2; ++i2) {
+                      result[i2] = clamp2(lo[i2], hi2[i2], result[i2]);
+                    }
+                    return result;
+                  };
+                  proto.dcurve = function(t4) {
+                    var time = this._time;
+                    var n2 = time.length;
+                    var idx = bsearch.le(time, t4);
+                    var result = this._scratch[0];
+                    var state = this._state;
+                    var velocity = this._velocity;
+                    var d2 = this.dimension;
+                    if (idx >= n2 - 1) {
+                      var ptr = state.length - 1;
+                      t4 - time[n2 - 1];
+                      for (var i2 = 0; i2 < d2; ++i2, --ptr) {
+                        result[i2] = velocity[ptr];
+                      }
+                    } else {
+                      var ptr = d2 * (idx + 1) - 1;
+                      var t02 = time[idx];
+                      var t12 = time[idx + 1];
+                      var dt2 = t12 - t02 || 1;
+                      var x0 = this._scratch[1];
+                      var x1 = this._scratch[2];
+                      var v0 = this._scratch[3];
+                      var v1 = this._scratch[4];
+                      var steady = true;
+                      for (var i2 = 0; i2 < d2; ++i2, --ptr) {
+                        x0[i2] = state[ptr];
+                        v0[i2] = velocity[ptr] * dt2;
+                        x1[i2] = state[ptr + d2];
+                        v1[i2] = velocity[ptr + d2] * dt2;
+                        steady = steady && (x0[i2] === x1[i2] && v0[i2] === v1[i2] && v0[i2] === 0);
+                      }
+                      if (steady) {
+                        for (var i2 = 0; i2 < d2; ++i2) {
+                          result[i2] = 0;
+                        }
+                      } else {
+                        cubicHermite.derivative(x0, v0, x1, v1, (t4 - t02) / dt2, result);
+                        for (var i2 = 0; i2 < d2; ++i2) {
+                          result[i2] /= dt2;
+                        }
+                      }
+                    }
+                    return result;
+                  };
+                  proto.lastT = function() {
+                    var time = this._time;
+                    return time[time.length - 1];
+                  };
+                  proto.stable = function() {
+                    var velocity = this._velocity;
+                    var ptr = velocity.length;
+                    for (var i2 = this.dimension - 1; i2 >= 0; --i2) {
+                      if (velocity[--ptr]) {
+                        return false;
+                      }
+                    }
+                    return true;
+                  };
+                  proto.jump = function(t4) {
+                    var t02 = this.lastT();
+                    var d2 = this.dimension;
+                    if (t4 < t02 || arguments.length !== d2 + 1) {
+                      return;
+                    }
+                    var state = this._state;
+                    var velocity = this._velocity;
+                    var ptr = state.length - this.dimension;
+                    var bounds = this.bounds;
+                    var lo = bounds[0];
+                    var hi2 = bounds[1];
+                    this._time.push(t02, t4);
+                    for (var j2 = 0; j2 < 2; ++j2) {
+                      for (var i2 = 0; i2 < d2; ++i2) {
+                        state.push(state[ptr++]);
+                        velocity.push(0);
+                      }
+                    }
+                    this._time.push(t4);
+                    for (var i2 = d2; i2 > 0; --i2) {
+                      state.push(clamp2(lo[i2 - 1], hi2[i2 - 1], arguments[i2]));
+                      velocity.push(0);
+                    }
+                  };
+                  proto.push = function(t4) {
+                    var t02 = this.lastT();
+                    var d2 = this.dimension;
+                    if (t4 < t02 || arguments.length !== d2 + 1) {
+                      return;
+                    }
+                    var state = this._state;
+                    var velocity = this._velocity;
+                    var ptr = state.length - this.dimension;
+                    var dt2 = t4 - t02;
+                    var bounds = this.bounds;
+                    var lo = bounds[0];
+                    var hi2 = bounds[1];
+                    var sf2 = dt2 > 1e-6 ? 1 / dt2 : 0;
+                    this._time.push(t4);
+                    for (var i2 = d2; i2 > 0; --i2) {
+                      var xc2 = clamp2(lo[i2 - 1], hi2[i2 - 1], arguments[i2]);
+                      state.push(xc2);
+                      velocity.push((xc2 - state[ptr++]) * sf2);
+                    }
+                  };
+                  proto.set = function(t4) {
+                    var d2 = this.dimension;
+                    if (t4 < this.lastT() || arguments.length !== d2 + 1) {
+                      return;
+                    }
+                    var state = this._state;
+                    var velocity = this._velocity;
+                    var bounds = this.bounds;
+                    var lo = bounds[0];
+                    var hi2 = bounds[1];
+                    this._time.push(t4);
+                    for (var i2 = d2; i2 > 0; --i2) {
+                      state.push(clamp2(lo[i2 - 1], hi2[i2 - 1], arguments[i2]));
+                      velocity.push(0);
+                    }
+                  };
+                  proto.move = function(t4) {
+                    var t02 = this.lastT();
+                    var d2 = this.dimension;
+                    if (t4 <= t02 || arguments.length !== d2 + 1) {
+                      return;
+                    }
+                    var state = this._state;
+                    var velocity = this._velocity;
+                    var statePtr = state.length - this.dimension;
+                    var bounds = this.bounds;
+                    var lo = bounds[0];
+                    var hi2 = bounds[1];
+                    var dt2 = t4 - t02;
+                    var sf2 = dt2 > 1e-6 ? 1 / dt2 : 0;
+                    this._time.push(t4);
+                    for (var i2 = d2; i2 > 0; --i2) {
+                      var dx = arguments[i2];
+                      state.push(clamp2(lo[i2 - 1], hi2[i2 - 1], state[statePtr++] + dx));
+                      velocity.push(dx * sf2);
+                    }
+                  };
+                  proto.idle = function(t4) {
+                    var t02 = this.lastT();
+                    if (t4 < t02) {
+                      return;
+                    }
+                    var d2 = this.dimension;
+                    var state = this._state;
+                    var velocity = this._velocity;
+                    var statePtr = state.length - d2;
+                    var bounds = this.bounds;
+                    var lo = bounds[0];
+                    var hi2 = bounds[1];
+                    var dt2 = t4 - t02;
+                    this._time.push(t4);
+                    for (var i2 = d2 - 1; i2 >= 0; --i2) {
+                      state.push(clamp2(lo[i2], hi2[i2], state[statePtr] + dt2 * velocity[statePtr]));
+                      velocity.push(0);
+                      statePtr += 1;
+                    }
+                  };
+                  function getZero(d2) {
+                    var result = new Array(d2);
+                    for (var i2 = 0; i2 < d2; ++i2) {
+                      result[i2] = 0;
+                    }
+                    return result;
+                  }
+                  function createFilteredVector(initState, initVelocity, initTime) {
+                    switch (arguments.length) {
+                      case 0:
+                        return new FilteredVector([0], [0], 0);
+                      case 1:
+                        if (typeof initState === "number") {
+                          var zero2 = getZero(initState);
+                          return new FilteredVector(zero2, zero2, 0);
+                        } else {
+                          return new FilteredVector(initState, getZero(initState.length), 0);
+                        }
+                      case 2:
+                        if (typeof initVelocity === "number") {
+                          var zero2 = getZero(initState.length);
+                          return new FilteredVector(initState, zero2, +initVelocity);
+                        } else {
+                          initTime = 0;
+                        }
+                      case 3:
+                        if (initState.length !== initVelocity.length) {
+                          throw new Error("state and velocity lengths must match");
+                        }
+                        return new FilteredVector(initState, initVelocity, initTime);
+                    }
+                  }
+                }
+              ),
+              /***/
+              9216: (
+                /***/
+                function(module22) {
+                  module22.exports = isMobile2;
+                  module22.exports.isMobile = isMobile2;
+                  module22.exports["default"] = isMobile2;
+                  var mobileRE = /(android|bb\d+|meego).+mobile|armv7l|avantgo|bada\/|blackberry|blazer|compal|elaine|fennec|hiptop|iemobile|ip(hone|od)|iris|kindle|lge |maemo|midp|mmp|mobile.+firefox|netfront|opera m(ob|in)i|palm( os)?|phone|p(ixi|re)\/|plucker|pocket|psp|series[46]0|samsungbrowser.*mobile|symbian|treo|up\.(browser|link)|vodafone|wap|windows (ce|phone)|xda|xiino/i;
+                  var notMobileRE = /CrOS/;
+                  var tabletRE = /android|ipad|playbook|silk/i;
+                  function isMobile2(opts) {
+                    if (!opts) opts = {};
+                    var ua2 = opts.ua;
+                    if (!ua2 && typeof navigator !== "undefined") ua2 = navigator.userAgent;
+                    if (ua2 && ua2.headers && typeof ua2.headers["user-agent"] === "string") {
+                      ua2 = ua2.headers["user-agent"];
+                    }
+                    if (typeof ua2 !== "string") return false;
+                    var result = mobileRE.test(ua2) && !notMobileRE.test(ua2) || !!opts.tablet && tabletRE.test(ua2);
+                    if (!result && opts.tablet && opts.featureDetect && navigator && navigator.maxTouchPoints > 1 && ua2.indexOf("Macintosh") !== -1 && ua2.indexOf("Safari") !== -1) {
+                      result = true;
+                    }
+                    return result;
+                  }
+                }
+              ),
+              /***/
+              9226: (
+                /***/
+                function(module22) {
+                  module22.exports = ceil;
+                  function ceil(out, a2) {
+                    out[0] = Math.ceil(a2[0]);
+                    out[1] = Math.ceil(a2[1]);
+                    out[2] = Math.ceil(a2[2]);
+                    return out;
+                  }
+                }
+              ),
+              /***/
+              9265: (
+                /***/
+                function(module22) {
+                  module22.exports = exactEquals;
+                  function exactEquals(a2, b2) {
+                    return a2[0] === b2[0] && a2[1] === b2[1] && a2[2] === b2[2];
+                  }
+                }
+              ),
+              /***/
+              9288: (
+                /***/
+                function(module22) {
+                  module22.exports = scale2;
+                  function scale2(out, a2, b2) {
+                    out[0] = a2[0] * b2;
+                    out[1] = a2[1] * b2;
+                    out[2] = a2[2] * b2;
+                    out[3] = a2[3] * b2;
+                    return out;
+                  }
+                }
+              ),
+              /***/
+              9346: (
+                /***/
+                function(module22) {
+                  var diff = new Float64Array(4);
+                  var edge0 = new Float64Array(4);
+                  var edge1 = new Float64Array(4);
+                  function closestPoint2d(V0, V1, V2, point, result) {
+                    if (diff.length < point.length) {
+                      diff = new Float64Array(point.length);
+                      edge0 = new Float64Array(point.length);
+                      edge1 = new Float64Array(point.length);
+                    }
+                    for (var i2 = 0; i2 < point.length; ++i2) {
+                      diff[i2] = V0[i2] - point[i2];
+                      edge0[i2] = V1[i2] - V0[i2];
+                      edge1[i2] = V2[i2] - V0[i2];
+                    }
+                    var a00 = 0, a01 = 0, a11 = 0, b0 = 0, b1 = 0, c2 = 0;
+                    for (var i2 = 0; i2 < point.length; ++i2) {
+                      var e0 = edge0[i2], e1 = edge1[i2], d2 = diff[i2];
+                      a00 += e0 * e0;
+                      a01 += e0 * e1;
+                      a11 += e1 * e1;
+                      b0 += d2 * e0;
+                      b1 += d2 * e1;
+                      c2 += d2 * d2;
+                    }
+                    var det = Math.abs(a00 * a11 - a01 * a01);
+                    var s2 = a01 * b1 - a11 * b0;
+                    var t4 = a01 * b0 - a00 * b1;
+                    var sqrDistance;
+                    if (s2 + t4 <= det) {
+                      if (s2 < 0) {
+                        if (t4 < 0) {
+                          if (b0 < 0) {
+                            t4 = 0;
+                            if (-b0 >= a00) {
+                              s2 = 1;
+                              sqrDistance = a00 + 2 * b0 + c2;
+                            } else {
+                              s2 = -b0 / a00;
+                              sqrDistance = b0 * s2 + c2;
+                            }
+                          } else {
+                            s2 = 0;
+                            if (b1 >= 0) {
+                              t4 = 0;
+                              sqrDistance = c2;
+                            } else if (-b1 >= a11) {
+                              t4 = 1;
+                              sqrDistance = a11 + 2 * b1 + c2;
+                            } else {
+                              t4 = -b1 / a11;
+                              sqrDistance = b1 * t4 + c2;
+                            }
+                          }
+                        } else {
+                          s2 = 0;
+                          if (b1 >= 0) {
+                            t4 = 0;
+                            sqrDistance = c2;
+                          } else if (-b1 >= a11) {
+                            t4 = 1;
+                            sqrDistance = a11 + 2 * b1 + c2;
+                          } else {
+                            t4 = -b1 / a11;
+                            sqrDistance = b1 * t4 + c2;
+                          }
+                        }
+                      } else if (t4 < 0) {
+                        t4 = 0;
+                        if (b0 >= 0) {
+                          s2 = 0;
+                          sqrDistance = c2;
+                        } else if (-b0 >= a00) {
+                          s2 = 1;
+                          sqrDistance = a00 + 2 * b0 + c2;
+                        } else {
+                          s2 = -b0 / a00;
+                          sqrDistance = b0 * s2 + c2;
+                        }
+                      } else {
+                        var invDet = 1 / det;
+                        s2 *= invDet;
+                        t4 *= invDet;
+                        sqrDistance = s2 * (a00 * s2 + a01 * t4 + 2 * b0) + t4 * (a01 * s2 + a11 * t4 + 2 * b1) + c2;
+                      }
+                    } else {
+                      var tmp0, tmp1, numer, denom;
+                      if (s2 < 0) {
+                        tmp0 = a01 + b0;
+                        tmp1 = a11 + b1;
+                        if (tmp1 > tmp0) {
+                          numer = tmp1 - tmp0;
+                          denom = a00 - 2 * a01 + a11;
+                          if (numer >= denom) {
+                            s2 = 1;
+                            t4 = 0;
+                            sqrDistance = a00 + 2 * b0 + c2;
+                          } else {
+                            s2 = numer / denom;
+                            t4 = 1 - s2;
+                            sqrDistance = s2 * (a00 * s2 + a01 * t4 + 2 * b0) + t4 * (a01 * s2 + a11 * t4 + 2 * b1) + c2;
+                          }
+                        } else {
+                          s2 = 0;
+                          if (tmp1 <= 0) {
+                            t4 = 1;
+                            sqrDistance = a11 + 2 * b1 + c2;
+                          } else if (b1 >= 0) {
+                            t4 = 0;
+                            sqrDistance = c2;
+                          } else {
+                            t4 = -b1 / a11;
+                            sqrDistance = b1 * t4 + c2;
+                          }
+                        }
+                      } else if (t4 < 0) {
+                        tmp0 = a01 + b1;
+                        tmp1 = a00 + b0;
+                        if (tmp1 > tmp0) {
+                          numer = tmp1 - tmp0;
+                          denom = a00 - 2 * a01 + a11;
+                          if (numer >= denom) {
+                            t4 = 1;
+                            s2 = 0;
+                            sqrDistance = a11 + 2 * b1 + c2;
+                          } else {
+                            t4 = numer / denom;
+                            s2 = 1 - t4;
+                            sqrDistance = s2 * (a00 * s2 + a01 * t4 + 2 * b0) + t4 * (a01 * s2 + a11 * t4 + 2 * b1) + c2;
+                          }
+                        } else {
+                          t4 = 0;
+                          if (tmp1 <= 0) {
+                            s2 = 1;
+                            sqrDistance = a00 + 2 * b0 + c2;
+                          } else if (b0 >= 0) {
+                            s2 = 0;
+                            sqrDistance = c2;
+                          } else {
+                            s2 = -b0 / a00;
+                            sqrDistance = b0 * s2 + c2;
+                          }
+                        }
+                      } else {
+                        numer = a11 + b1 - a01 - b0;
+                        if (numer <= 0) {
+                          s2 = 0;
+                          t4 = 1;
+                          sqrDistance = a11 + 2 * b1 + c2;
+                        } else {
+                          denom = a00 - 2 * a01 + a11;
+                          if (numer >= denom) {
+                            s2 = 1;
+                            t4 = 0;
+                            sqrDistance = a00 + 2 * b0 + c2;
+                          } else {
+                            s2 = numer / denom;
+                            t4 = 1 - s2;
+                            sqrDistance = s2 * (a00 * s2 + a01 * t4 + 2 * b0) + t4 * (a01 * s2 + a11 * t4 + 2 * b1) + c2;
+                          }
+                        }
+                      }
+                    }
+                    var u2 = 1 - s2 - t4;
+                    for (var i2 = 0; i2 < point.length; ++i2) {
+                      result[i2] = u2 * V0[i2] + s2 * V1[i2] + t4 * V2[i2];
+                    }
+                    if (sqrDistance < 0) {
+                      return 0;
+                    }
+                    return sqrDistance;
+                  }
+                  module22.exports = closestPoint2d;
+                }
+              ),
+              /***/
+              9362: (
+                /***/
+                function(module22) {
+                  module22.exports = fastTwoSum;
+                  function fastTwoSum(a2, b2, result) {
+                    var x2 = a2 + b2;
+                    var bv = x2 - a2;
+                    var av = x2 - bv;
+                    var br = b2 - bv;
+                    var ar = a2 - av;
+                    if (result) {
+                      result[0] = ar + br;
+                      result[1] = x2;
+                      return result;
+                    }
+                    return [ar + br, x2];
+                  }
+                }
+              ),
+              /***/
+              9366: (
+                /***/
+                function(module22, __unused_webpack_exports, __webpack_require__2) {
+                  var vectorizeText = __webpack_require__2(4359);
+                  module22.exports = getGlyph;
+                  var GLYPH_CACHE = {};
+                  function getGlyph(symbol, font, pixelRatio) {
+                    var fontKey = [
+                      font.style,
+                      font.weight,
+                      font.variant,
+                      font.family
+                    ].join("_");
+                    var fontCache = GLYPH_CACHE[fontKey];
+                    if (!fontCache) {
+                      fontCache = GLYPH_CACHE[fontKey] = {};
+                    }
+                    if (symbol in fontCache) {
+                      return fontCache[symbol];
+                    }
+                    var config2 = {
+                      textAlign: "center",
+                      textBaseline: "middle",
+                      lineHeight: 1,
+                      font: font.family,
+                      fontStyle: font.style,
+                      fontWeight: font.weight,
+                      fontVariant: font.variant,
+                      lineSpacing: 1.25,
+                      styletags: {
+                        breaklines: true,
+                        bolds: true,
+                        italics: true,
+                        subscripts: true,
+                        superscripts: true
+                      }
+                    };
+                    config2.triangles = true;
+                    var triSymbol = vectorizeText(symbol, config2);
+                    config2.triangles = false;
+                    var lineSymbol = vectorizeText(symbol, config2);
+                    var i2, j2;
+                    if (pixelRatio && pixelRatio !== 1) {
+                      for (i2 = 0; i2 < triSymbol.positions.length; ++i2) {
+                        for (j2 = 0; j2 < triSymbol.positions[i2].length; ++j2) {
+                          triSymbol.positions[i2][j2] /= pixelRatio;
+                        }
+                      }
+                      for (i2 = 0; i2 < lineSymbol.positions.length; ++i2) {
+                        for (j2 = 0; j2 < lineSymbol.positions[i2].length; ++j2) {
+                          lineSymbol.positions[i2][j2] /= pixelRatio;
+                        }
+                      }
+                    }
+                    var bounds = [[Infinity, Infinity], [-Infinity, -Infinity]];
+                    var n2 = lineSymbol.positions.length;
+                    for (i2 = 0; i2 < n2; ++i2) {
+                      var p2 = lineSymbol.positions[i2];
+                      for (j2 = 0; j2 < 2; ++j2) {
+                        bounds[0][j2] = Math.min(bounds[0][j2], p2[j2]);
+                        bounds[1][j2] = Math.max(bounds[1][j2], p2[j2]);
+                      }
+                    }
+                    return fontCache[symbol] = [triSymbol, lineSymbol, bounds];
+                  }
+                }
+              ),
+              /***/
+              9405: (
+                /***/
+                function(module22, __unused_webpack_exports, __webpack_require__2) {
+                  var createUniformWrapper = __webpack_require__2(3327);
+                  var createAttributeWrapper = __webpack_require__2(8731);
+                  var makeReflect = __webpack_require__2(216);
+                  var shaderCache = __webpack_require__2(5091);
+                  var runtime = __webpack_require__2(2145);
+                  var GLError = __webpack_require__2(8866);
+                  function Shader2(gl2) {
+                    this.gl = gl2;
+                    this.gl.lastAttribCount = 0;
+                    this._vref = this._fref = this._relink = this.vertShader = this.fragShader = this.program = this.attributes = this.uniforms = this.types = null;
+                  }
+                  var proto = Shader2.prototype;
+                  proto.bind = function() {
+                    if (!this.program) {
+                      this._relink();
+                    }
+                    var i2;
+                    var newAttribCount = this.gl.getProgramParameter(this.program, this.gl.ACTIVE_ATTRIBUTES);
+                    var oldAttribCount = this.gl.lastAttribCount;
+                    if (newAttribCount > oldAttribCount) {
+                      for (i2 = oldAttribCount; i2 < newAttribCount; i2++) {
+                        this.gl.enableVertexAttribArray(i2);
+                      }
+                    } else if (oldAttribCount > newAttribCount) {
+                      for (i2 = newAttribCount; i2 < oldAttribCount; i2++) {
+                        this.gl.disableVertexAttribArray(i2);
+                      }
+                    }
+                    this.gl.lastAttribCount = newAttribCount;
+                    this.gl.useProgram(this.program);
+                  };
+                  proto.dispose = function() {
+                    var oldAttribCount = this.gl.lastAttribCount;
+                    for (var i2 = 0; i2 < oldAttribCount; i2++) {
+                      this.gl.disableVertexAttribArray(i2);
+                    }
+                    this.gl.lastAttribCount = 0;
+                    if (this._fref) {
+                      this._fref.dispose();
+                    }
+                    if (this._vref) {
+                      this._vref.dispose();
+                    }
+                    this.attributes = this.types = this.vertShader = this.fragShader = this.program = this._relink = this._fref = this._vref = null;
+                  };
+                  function compareAttributes(a2, b2) {
+                    if (a2.name < b2.name) {
+                      return -1;
+                    }
+                    return 1;
+                  }
+                  proto.update = function(vertSource, fragSource, uniforms, attributes) {
+                    if (!fragSource || arguments.length === 1) {
+                      var obj = vertSource;
+                      vertSource = obj.vertex;
+                      fragSource = obj.fragment;
+                      uniforms = obj.uniforms;
+                      attributes = obj.attributes;
+                    }
+                    var wrapper = this;
+                    var gl2 = wrapper.gl;
+                    var pvref = wrapper._vref;
+                    wrapper._vref = shaderCache.shader(gl2, gl2.VERTEX_SHADER, vertSource);
+                    if (pvref) {
+                      pvref.dispose();
+                    }
+                    wrapper.vertShader = wrapper._vref.shader;
+                    var pfref = this._fref;
+                    wrapper._fref = shaderCache.shader(gl2, gl2.FRAGMENT_SHADER, fragSource);
+                    if (pfref) {
+                      pfref.dispose();
+                    }
+                    wrapper.fragShader = wrapper._fref.shader;
+                    if (!uniforms || !attributes) {
+                      var testProgram = gl2.createProgram();
+                      gl2.attachShader(testProgram, wrapper.fragShader);
+                      gl2.attachShader(testProgram, wrapper.vertShader);
+                      gl2.linkProgram(testProgram);
+                      if (!gl2.getProgramParameter(testProgram, gl2.LINK_STATUS)) {
+                        var errLog = gl2.getProgramInfoLog(testProgram);
+                        throw new GLError(errLog, "Error linking program:" + errLog);
+                      }
+                      uniforms = uniforms || runtime.uniforms(gl2, testProgram);
+                      attributes = attributes || runtime.attributes(gl2, testProgram);
+                      gl2.deleteProgram(testProgram);
+                    }
+                    attributes = attributes.slice();
+                    attributes.sort(compareAttributes);
+                    var attributeUnpacked = [];
+                    var attributeNames = [];
+                    var attributeLocations = [];
+                    var i2;
+                    for (i2 = 0; i2 < attributes.length; ++i2) {
+                      var attr = attributes[i2];
+                      if (attr.type.indexOf("mat") >= 0) {
+                        var size = attr.type.charAt(attr.type.length - 1) | 0;
+                        var locVector = new Array(size);
+                        for (var j2 = 0; j2 < size; ++j2) {
+                          locVector[j2] = attributeLocations.length;
+                          attributeNames.push(attr.name + "[" + j2 + "]");
+                          if (typeof attr.location === "number") {
+                            attributeLocations.push(attr.location + j2);
+                          } else if (Array.isArray(attr.location) && attr.location.length === size && typeof attr.location[j2] === "number") {
+                            attributeLocations.push(attr.location[j2] | 0);
+                          } else {
+                            attributeLocations.push(-1);
+                          }
+                        }
+                        attributeUnpacked.push({
+                          name: attr.name,
+                          type: attr.type,
+                          locations: locVector
+                        });
+                      } else {
+                        attributeUnpacked.push({
+                          name: attr.name,
+                          type: attr.type,
+                          locations: [attributeLocations.length]
+                        });
+                        attributeNames.push(attr.name);
+                        if (typeof attr.location === "number") {
+                          attributeLocations.push(attr.location | 0);
+                        } else {
+                          attributeLocations.push(-1);
+                        }
+                      }
+                    }
+                    var curLocation = 0;
+                    for (i2 = 0; i2 < attributeLocations.length; ++i2) {
+                      if (attributeLocations[i2] < 0) {
+                        while (attributeLocations.indexOf(curLocation) >= 0) {
+                          curLocation += 1;
+                        }
+                        attributeLocations[i2] = curLocation;
+                      }
+                    }
+                    var uniformLocations = new Array(uniforms.length);
+                    function relink() {
+                      wrapper.program = shaderCache.program(
+                        gl2,
+                        wrapper._vref,
+                        wrapper._fref,
+                        attributeNames,
+                        attributeLocations
+                      );
+                      for (var i22 = 0; i22 < uniforms.length; ++i22) {
+                        uniformLocations[i22] = gl2.getUniformLocation(
+                          wrapper.program,
+                          uniforms[i22].name
+                        );
+                      }
+                    }
+                    relink();
+                    wrapper._relink = relink;
+                    wrapper.types = {
+                      uniforms: makeReflect(uniforms),
+                      attributes: makeReflect(attributes)
+                    };
+                    wrapper.attributes = createAttributeWrapper(
+                      gl2,
+                      wrapper,
+                      attributeUnpacked,
+                      attributeLocations
+                    );
+                    Object.defineProperty(wrapper, "uniforms", createUniformWrapper(
+                      gl2,
+                      wrapper,
+                      uniforms,
+                      uniformLocations
+                    ));
+                  };
+                  function createShader(gl2, vertSource, fragSource, uniforms, attributes) {
+                    var shader = new Shader2(gl2);
+                    shader.update(
+                      vertSource,
+                      fragSource,
+                      uniforms,
+                      attributes
+                    );
+                    return shader;
+                  }
+                  module22.exports = createShader;
+                }
+              ),
+              /***/
+              9499: (
+                /***/
+                function(module22, __unused_webpack_exports, __webpack_require__2) {
+                  module22.exports = createSurfacePlot;
+                  var bits = __webpack_require__2(8828);
+                  var createBuffer = __webpack_require__2(2762);
+                  var createVAO = __webpack_require__2(8116);
+                  var createTexture2 = __webpack_require__2(7766);
+                  var pool = __webpack_require__2(1888);
+                  var colormap = __webpack_require__2(6729);
+                  var ops = __webpack_require__2(5298);
+                  var pack = __webpack_require__2(9994);
+                  var ndarray = __webpack_require__2(9618);
+                  var surfaceNets = __webpack_require__2(3711);
+                  var multiply2 = __webpack_require__2(6760);
+                  var invert2 = __webpack_require__2(7608);
+                  var bsearch = __webpack_require__2(2478);
+                  var gradient = __webpack_require__2(6199);
+                  var shaders = __webpack_require__2(990);
+                  var createShader = shaders.createShader;
+                  var createContourShader = shaders.createContourShader;
+                  var createPickShader = shaders.createPickShader;
+                  var createPickContourShader = shaders.createPickContourShader;
+                  var SURFACE_VERTEX_SIZE = 4 * (4 + 3 + 3);
+                  var IDENTITY2 = [
+                    1,
+                    0,
+                    0,
+                    0,
+                    0,
+                    1,
+                    0,
+                    0,
+                    0,
+                    0,
+                    1,
+                    0,
+                    0,
+                    0,
+                    0,
+                    1
+                  ];
+                  var QUAD = [
+                    [0, 0],
+                    [0, 1],
+                    [1, 0],
+                    [1, 1],
+                    [1, 0],
+                    [0, 1]
+                  ];
+                  var PERMUTATIONS = [
+                    [0, 0, 0, 0, 0, 0, 0, 0, 0],
+                    [0, 0, 0, 0, 0, 0, 0, 0, 0],
+                    [0, 0, 0, 0, 0, 0, 0, 0, 0]
+                  ];
+                  (function() {
+                    for (var i2 = 0; i2 < 3; ++i2) {
+                      var p2 = PERMUTATIONS[i2];
+                      var u2 = (i2 + 1) % 3;
+                      var v2 = (i2 + 2) % 3;
+                      p2[u2 + 0] = 1;
+                      p2[v2 + 3] = 1;
+                      p2[i2 + 6] = 1;
+                    }
+                  })();
+                  function SurfacePickResult(position, index, uv, level, dataCoordinate) {
+                    this.position = position;
+                    this.index = index;
+                    this.uv = uv;
+                    this.level = level;
+                    this.dataCoordinate = dataCoordinate;
+                  }
+                  var N_COLORS = 256;
+                  function SurfacePlot(gl2, shape, bounds, shader, pickShader, coordinates, vao, colorMap, contourShader, contourPickShader, contourBuffer, contourVAO, dynamicBuffer, dynamicVAO, objectOffset) {
+                    this.gl = gl2;
+                    this.shape = shape;
+                    this.bounds = bounds;
+                    this.objectOffset = objectOffset;
+                    this.intensityBounds = [];
+                    this._shader = shader;
+                    this._pickShader = pickShader;
+                    this._coordinateBuffer = coordinates;
+                    this._vao = vao;
+                    this._colorMap = colorMap;
+                    this._contourShader = contourShader;
+                    this._contourPickShader = contourPickShader;
+                    this._contourBuffer = contourBuffer;
+                    this._contourVAO = contourVAO;
+                    this._contourOffsets = [[], [], []];
+                    this._contourCounts = [[], [], []];
+                    this._vertexCount = 0;
+                    this._pickResult = new SurfacePickResult([0, 0, 0], [0, 0], [0, 0], [0, 0, 0], [0, 0, 0]);
+                    this._dynamicBuffer = dynamicBuffer;
+                    this._dynamicVAO = dynamicVAO;
+                    this._dynamicOffsets = [0, 0, 0];
+                    this._dynamicCounts = [0, 0, 0];
+                    this.contourWidth = [1, 1, 1];
+                    this.contourLevels = [[1], [1], [1]];
+                    this.contourTint = [0, 0, 0];
+                    this.contourColor = [[0.5, 0.5, 0.5, 1], [0.5, 0.5, 0.5, 1], [0.5, 0.5, 0.5, 1]];
+                    this.showContour = true;
+                    this.showSurface = true;
+                    this.enableHighlight = [true, true, true];
+                    this.highlightColor = [[0, 0, 0, 1], [0, 0, 0, 1], [0, 0, 0, 1]];
+                    this.highlightTint = [1, 1, 1];
+                    this.highlightLevel = [-1, -1, -1];
+                    this.enableDynamic = [true, true, true];
+                    this.dynamicLevel = [NaN, NaN, NaN];
+                    this.dynamicColor = [[0, 0, 0, 1], [0, 0, 0, 1], [0, 0, 0, 1]];
+                    this.dynamicTint = [1, 1, 1];
+                    this.dynamicWidth = [1, 1, 1];
+                    this.axesBounds = [[Infinity, Infinity, Infinity], [-Infinity, -Infinity, -Infinity]];
+                    this.surfaceProject = [false, false, false];
+                    this.contourProject = [
+                      [false, false, false],
+                      [false, false, false],
+                      [false, false, false]
+                    ];
+                    this.colorBounds = [false, false];
+                    this._field = [
+                      ndarray(pool.mallocFloat(1024), [0, 0]),
+                      ndarray(pool.mallocFloat(1024), [0, 0]),
+                      ndarray(pool.mallocFloat(1024), [0, 0])
+                    ];
+                    this.pickId = 1;
+                    this.clipBounds = [[-Infinity, -Infinity, -Infinity], [Infinity, Infinity, Infinity]];
+                    this.snapToData = false;
+                    this.pixelRatio = 1;
+                    this.opacity = 1;
+                    this.lightPosition = [10, 1e4, 0];
+                    this.ambientLight = 0.8;
+                    this.diffuseLight = 0.8;
+                    this.specularLight = 2;
+                    this.roughness = 0.5;
+                    this.fresnel = 1.5;
+                    this.vertexColor = 0;
+                    this.dirty = true;
+                  }
+                  var proto = SurfacePlot.prototype;
+                  proto.genColormap = function(name2, opacityscale) {
+                    var hasAlpha = false;
+                    var x2 = pack([colormap({
+                      colormap: name2,
+                      nshades: N_COLORS,
+                      format: "rgba"
+                    }).map(function(c2, i2) {
+                      var a2 = opacityscale ? getOpacityFromScale(i2 / 255, opacityscale) : c2[3];
+                      if (a2 < 1) hasAlpha = true;
+                      return [c2[0], c2[1], c2[2], 255 * a2];
+                    })]);
+                    ops.divseq(x2, 255);
+                    this.hasAlphaScale = hasAlpha;
+                    return x2;
+                  };
+                  proto.isTransparent = function() {
+                    return this.opacity < 1 || this.hasAlphaScale;
+                  };
+                  proto.isOpaque = function() {
+                    return !this.isTransparent();
+                  };
+                  proto.pickSlots = 1;
+                  proto.setPickBase = function(id2) {
+                    this.pickId = id2;
+                  };
+                  function getOpacityFromScale(ratio, opacityscale) {
+                    if (!opacityscale) return 1;
+                    if (!opacityscale.length) return 1;
+                    for (var i2 = 0; i2 < opacityscale.length; ++i2) {
+                      if (opacityscale.length < 2) return 1;
+                      if (opacityscale[i2][0] === ratio) return opacityscale[i2][1];
+                      if (opacityscale[i2][0] > ratio && i2 > 0) {
+                        var d2 = (opacityscale[i2][0] - ratio) / (opacityscale[i2][0] - opacityscale[i2 - 1][0]);
+                        return opacityscale[i2][1] * (1 - d2) + d2 * opacityscale[i2 - 1][1];
+                      }
+                    }
+                    return 1;
+                  }
+                  var ZERO_VEC = [0, 0, 0];
+                  var PROJECT_DATA = {
+                    showSurface: false,
+                    showContour: false,
+                    projections: [IDENTITY2.slice(), IDENTITY2.slice(), IDENTITY2.slice()],
+                    clipBounds: [
+                      [[0, 0, 0], [0, 0, 0]],
+                      [[0, 0, 0], [0, 0, 0]],
+                      [[0, 0, 0], [0, 0, 0]]
+                    ]
+                  };
+                  function computeProjectionData(camera, obj) {
+                    var i2, j2, k2;
+                    var cubeAxis = obj.axes && obj.axes.lastCubeProps.axis || ZERO_VEC;
+                    var showSurface = obj.showSurface;
+                    var showContour = obj.showContour;
+                    for (i2 = 0; i2 < 3; ++i2) {
+                      showSurface = showSurface || obj.surfaceProject[i2];
+                      for (j2 = 0; j2 < 3; ++j2) {
+                        showContour = showContour || obj.contourProject[i2][j2];
+                      }
+                    }
+                    for (i2 = 0; i2 < 3; ++i2) {
+                      var axisSquish = PROJECT_DATA.projections[i2];
+                      for (j2 = 0; j2 < 16; ++j2) {
+                        axisSquish[j2] = 0;
+                      }
+                      for (j2 = 0; j2 < 4; ++j2) {
+                        axisSquish[5 * j2] = 1;
+                      }
+                      axisSquish[5 * i2] = 0;
+                      axisSquish[12 + i2] = obj.axesBounds[+(cubeAxis[i2] > 0)][i2];
+                      multiply2(axisSquish, camera.model, axisSquish);
+                      var nclipBounds = PROJECT_DATA.clipBounds[i2];
+                      for (k2 = 0; k2 < 2; ++k2) {
+                        for (j2 = 0; j2 < 3; ++j2) {
+                          nclipBounds[k2][j2] = camera.clipBounds[k2][j2];
+                        }
+                      }
+                      nclipBounds[0][i2] = -1e8;
+                      nclipBounds[1][i2] = 1e8;
+                    }
+                    PROJECT_DATA.showSurface = showSurface;
+                    PROJECT_DATA.showContour = showContour;
+                    return PROJECT_DATA;
+                  }
+                  var UNIFORMS = {
+                    model: IDENTITY2,
+                    view: IDENTITY2,
+                    projection: IDENTITY2,
+                    inverseModel: IDENTITY2.slice(),
+                    lowerBound: [0, 0, 0],
+                    upperBound: [0, 0, 0],
+                    colorMap: 0,
+                    clipBounds: [[0, 0, 0], [0, 0, 0]],
+                    height: 0,
+                    contourTint: 0,
+                    contourColor: [0, 0, 0, 1],
+                    permutation: [1, 0, 0, 0, 1, 0, 0, 0, 1],
+                    zOffset: -1e-4,
+                    objectOffset: [0, 0, 0],
+                    kambient: 1,
+                    kdiffuse: 1,
+                    kspecular: 1,
+                    lightPosition: [1e3, 1e3, 1e3],
+                    eyePosition: [0, 0, 0],
+                    roughness: 1,
+                    fresnel: 1,
+                    opacity: 1,
+                    vertexColor: 0
+                  };
+                  var MATRIX_INVERSE = IDENTITY2.slice();
+                  var DEFAULT_PERM = [1, 0, 0, 0, 1, 0, 0, 0, 1];
+                  function drawCore(params, transparent) {
+                    params = params || {};
+                    var gl2 = this.gl;
+                    gl2.disable(gl2.CULL_FACE);
+                    this._colorMap.bind(0);
+                    var uniforms = UNIFORMS;
+                    uniforms.model = params.model || IDENTITY2;
+                    uniforms.view = params.view || IDENTITY2;
+                    uniforms.projection = params.projection || IDENTITY2;
+                    uniforms.lowerBound = [this.bounds[0][0], this.bounds[0][1], this.colorBounds[0] || this.bounds[0][2]];
+                    uniforms.upperBound = [this.bounds[1][0], this.bounds[1][1], this.colorBounds[1] || this.bounds[1][2]];
+                    uniforms.objectOffset = this.objectOffset;
+                    uniforms.contourColor = this.contourColor[0];
+                    uniforms.inverseModel = invert2(uniforms.inverseModel, uniforms.model);
+                    for (var i2 = 0; i2 < 2; ++i2) {
+                      var clipClamped = uniforms.clipBounds[i2];
+                      for (var j2 = 0; j2 < 3; ++j2) {
+                        clipClamped[j2] = Math.min(Math.max(this.clipBounds[i2][j2], -1e8), 1e8);
+                      }
+                    }
+                    uniforms.kambient = this.ambientLight;
+                    uniforms.kdiffuse = this.diffuseLight;
+                    uniforms.kspecular = this.specularLight;
+                    uniforms.roughness = this.roughness;
+                    uniforms.fresnel = this.fresnel;
+                    uniforms.opacity = this.opacity;
+                    uniforms.height = 0;
+                    uniforms.permutation = DEFAULT_PERM;
+                    uniforms.vertexColor = this.vertexColor;
+                    var invCameraMatrix = MATRIX_INVERSE;
+                    multiply2(invCameraMatrix, uniforms.view, uniforms.model);
+                    multiply2(invCameraMatrix, uniforms.projection, invCameraMatrix);
+                    invert2(invCameraMatrix, invCameraMatrix);
+                    for (i2 = 0; i2 < 3; ++i2) {
+                      uniforms.eyePosition[i2] = invCameraMatrix[12 + i2] / invCameraMatrix[15];
+                    }
+                    var w2 = invCameraMatrix[15];
+                    for (i2 = 0; i2 < 3; ++i2) {
+                      w2 += this.lightPosition[i2] * invCameraMatrix[4 * i2 + 3];
+                    }
+                    for (i2 = 0; i2 < 3; ++i2) {
+                      var s2 = invCameraMatrix[12 + i2];
+                      for (j2 = 0; j2 < 3; ++j2) {
+                        s2 += invCameraMatrix[4 * j2 + i2] * this.lightPosition[j2];
+                      }
+                      uniforms.lightPosition[i2] = s2 / w2;
+                    }
+                    var projectData = computeProjectionData(uniforms, this);
+                    if (projectData.showSurface) {
+                      this._shader.bind();
+                      this._shader.uniforms = uniforms;
+                      this._vao.bind();
+                      if (this.showSurface && this._vertexCount) {
+                        this._vao.draw(gl2.TRIANGLES, this._vertexCount);
+                      }
+                      for (i2 = 0; i2 < 3; ++i2) {
+                        if (!this.surfaceProject[i2] || !this.vertexCount) {
+                          continue;
+                        }
+                        this._shader.uniforms.model = projectData.projections[i2];
+                        this._shader.uniforms.clipBounds = projectData.clipBounds[i2];
+                        this._vao.draw(gl2.TRIANGLES, this._vertexCount);
+                      }
+                      this._vao.unbind();
+                    }
+                    if (projectData.showContour) {
+                      var shader = this._contourShader;
+                      uniforms.kambient = 1;
+                      uniforms.kdiffuse = 0;
+                      uniforms.kspecular = 0;
+                      uniforms.opacity = 1;
+                      shader.bind();
+                      shader.uniforms = uniforms;
+                      var vao = this._contourVAO;
+                      vao.bind();
+                      for (i2 = 0; i2 < 3; ++i2) {
+                        shader.uniforms.permutation = PERMUTATIONS[i2];
+                        gl2.lineWidth(this.contourWidth[i2] * this.pixelRatio);
+                        for (j2 = 0; j2 < this.contourLevels[i2].length; ++j2) {
+                          if (j2 === this.highlightLevel[i2]) {
+                            shader.uniforms.contourColor = this.highlightColor[i2];
+                            shader.uniforms.contourTint = this.highlightTint[i2];
+                          } else if (j2 === 0 || j2 - 1 === this.highlightLevel[i2]) {
+                            shader.uniforms.contourColor = this.contourColor[i2];
+                            shader.uniforms.contourTint = this.contourTint[i2];
+                          }
+                          if (!this._contourCounts[i2][j2]) {
+                            continue;
+                          }
+                          shader.uniforms.height = this.contourLevels[i2][j2];
+                          vao.draw(gl2.LINES, this._contourCounts[i2][j2], this._contourOffsets[i2][j2]);
+                        }
+                      }
+                      for (i2 = 0; i2 < 3; ++i2) {
+                        shader.uniforms.model = projectData.projections[i2];
+                        shader.uniforms.clipBounds = projectData.clipBounds[i2];
+                        for (j2 = 0; j2 < 3; ++j2) {
+                          if (!this.contourProject[i2][j2]) {
+                            continue;
+                          }
+                          shader.uniforms.permutation = PERMUTATIONS[j2];
+                          gl2.lineWidth(this.contourWidth[j2] * this.pixelRatio);
+                          for (var k2 = 0; k2 < this.contourLevels[j2].length; ++k2) {
+                            if (k2 === this.highlightLevel[j2]) {
+                              shader.uniforms.contourColor = this.highlightColor[j2];
+                              shader.uniforms.contourTint = this.highlightTint[j2];
+                            } else if (k2 === 0 || k2 - 1 === this.highlightLevel[j2]) {
+                              shader.uniforms.contourColor = this.contourColor[j2];
+                              shader.uniforms.contourTint = this.contourTint[j2];
+                            }
+                            if (!this._contourCounts[j2][k2]) {
+                              continue;
+                            }
+                            shader.uniforms.height = this.contourLevels[j2][k2];
+                            vao.draw(gl2.LINES, this._contourCounts[j2][k2], this._contourOffsets[j2][k2]);
+                          }
+                        }
+                      }
+                      vao.unbind();
+                      vao = this._dynamicVAO;
+                      vao.bind();
+                      for (i2 = 0; i2 < 3; ++i2) {
+                        if (this._dynamicCounts[i2] === 0) {
+                          continue;
+                        }
+                        shader.uniforms.model = uniforms.model;
+                        shader.uniforms.clipBounds = uniforms.clipBounds;
+                        shader.uniforms.permutation = PERMUTATIONS[i2];
+                        gl2.lineWidth(this.dynamicWidth[i2] * this.pixelRatio);
+                        shader.uniforms.contourColor = this.dynamicColor[i2];
+                        shader.uniforms.contourTint = this.dynamicTint[i2];
+                        shader.uniforms.height = this.dynamicLevel[i2];
+                        vao.draw(gl2.LINES, this._dynamicCounts[i2], this._dynamicOffsets[i2]);
+                        for (j2 = 0; j2 < 3; ++j2) {
+                          if (!this.contourProject[j2][i2]) {
+                            continue;
+                          }
+                          shader.uniforms.model = projectData.projections[j2];
+                          shader.uniforms.clipBounds = projectData.clipBounds[j2];
+                          vao.draw(gl2.LINES, this._dynamicCounts[i2], this._dynamicOffsets[i2]);
+                        }
+                      }
+                      vao.unbind();
+                    }
+                  }
+                  proto.draw = function(params) {
+                    return drawCore.call(this, params, false);
+                  };
+                  proto.drawTransparent = function(params) {
+                    return drawCore.call(this, params, true);
+                  };
+                  var PICK_UNIFORMS = {
+                    model: IDENTITY2,
+                    view: IDENTITY2,
+                    projection: IDENTITY2,
+                    inverseModel: IDENTITY2,
+                    clipBounds: [[0, 0, 0], [0, 0, 0]],
+                    height: 0,
+                    shape: [0, 0],
+                    pickId: 0,
+                    lowerBound: [0, 0, 0],
+                    upperBound: [0, 0, 0],
+                    zOffset: 0,
+                    objectOffset: [0, 0, 0],
+                    permutation: [1, 0, 0, 0, 1, 0, 0, 0, 1],
+                    lightPosition: [0, 0, 0],
+                    eyePosition: [0, 0, 0]
+                  };
+                  proto.drawPick = function(params) {
+                    params = params || {};
+                    var gl2 = this.gl;
+                    gl2.disable(gl2.CULL_FACE);
+                    var uniforms = PICK_UNIFORMS;
+                    uniforms.model = params.model || IDENTITY2;
+                    uniforms.view = params.view || IDENTITY2;
+                    uniforms.projection = params.projection || IDENTITY2;
+                    uniforms.shape = this._field[2].shape;
+                    uniforms.pickId = this.pickId / 255;
+                    uniforms.lowerBound = this.bounds[0];
+                    uniforms.upperBound = this.bounds[1];
+                    uniforms.objectOffset = this.objectOffset;
+                    uniforms.permutation = DEFAULT_PERM;
+                    for (var i2 = 0; i2 < 2; ++i2) {
+                      var clipClamped = uniforms.clipBounds[i2];
+                      for (var j2 = 0; j2 < 3; ++j2) {
+                        clipClamped[j2] = Math.min(Math.max(this.clipBounds[i2][j2], -1e8), 1e8);
+                      }
+                    }
+                    var projectData = computeProjectionData(uniforms, this);
+                    if (projectData.showSurface) {
+                      this._pickShader.bind();
+                      this._pickShader.uniforms = uniforms;
+                      this._vao.bind();
+                      this._vao.draw(gl2.TRIANGLES, this._vertexCount);
+                      for (i2 = 0; i2 < 3; ++i2) {
+                        if (!this.surfaceProject[i2]) {
+                          continue;
+                        }
+                        this._pickShader.uniforms.model = projectData.projections[i2];
+                        this._pickShader.uniforms.clipBounds = projectData.clipBounds[i2];
+                        this._vao.draw(gl2.TRIANGLES, this._vertexCount);
+                      }
+                      this._vao.unbind();
+                    }
+                    if (projectData.showContour) {
+                      var shader = this._contourPickShader;
+                      shader.bind();
+                      shader.uniforms = uniforms;
+                      var vao = this._contourVAO;
+                      vao.bind();
+                      for (j2 = 0; j2 < 3; ++j2) {
+                        gl2.lineWidth(this.contourWidth[j2] * this.pixelRatio);
+                        shader.uniforms.permutation = PERMUTATIONS[j2];
+                        for (i2 = 0; i2 < this.contourLevels[j2].length; ++i2) {
+                          if (this._contourCounts[j2][i2]) {
+                            shader.uniforms.height = this.contourLevels[j2][i2];
+                            vao.draw(gl2.LINES, this._contourCounts[j2][i2], this._contourOffsets[j2][i2]);
+                          }
+                        }
+                      }
+                      for (i2 = 0; i2 < 3; ++i2) {
+                        shader.uniforms.model = projectData.projections[i2];
+                        shader.uniforms.clipBounds = projectData.clipBounds[i2];
+                        for (j2 = 0; j2 < 3; ++j2) {
+                          if (!this.contourProject[i2][j2]) {
+                            continue;
+                          }
+                          shader.uniforms.permutation = PERMUTATIONS[j2];
+                          gl2.lineWidth(this.contourWidth[j2] * this.pixelRatio);
+                          for (var k2 = 0; k2 < this.contourLevels[j2].length; ++k2) {
+                            if (this._contourCounts[j2][k2]) {
+                              shader.uniforms.height = this.contourLevels[j2][k2];
+                              vao.draw(gl2.LINES, this._contourCounts[j2][k2], this._contourOffsets[j2][k2]);
+                            }
+                          }
+                        }
+                      }
+                      vao.unbind();
+                    }
+                  };
+                  proto.pick = function(selection) {
+                    if (!selection) {
+                      return null;
+                    }
+                    if (selection.id !== this.pickId) {
+                      return null;
+                    }
+                    var shape = this._field[2].shape;
+                    var result = this._pickResult;
+                    var x2 = shape[0] * (selection.value[0] + (selection.value[2] >> 4) / 16) / 255;
+                    var ix = Math.floor(x2);
+                    var fx = x2 - ix;
+                    var y2 = shape[1] * (selection.value[1] + (selection.value[2] & 15) / 16) / 255;
+                    var iy = Math.floor(y2);
+                    var fy = y2 - iy;
+                    ix += 1;
+                    iy += 1;
+                    var pos = result.position;
+                    pos[0] = pos[1] = pos[2] = 0;
+                    for (var dx = 0; dx < 2; ++dx) {
+                      var s2 = dx ? fx : 1 - fx;
+                      for (var dy = 0; dy < 2; ++dy) {
+                        var t4 = dy ? fy : 1 - fy;
+                        var r2 = ix + dx;
+                        var c2 = iy + dy;
+                        var w2 = s2 * t4;
+                        for (var i2 = 0; i2 < 3; ++i2) {
+                          pos[i2] += this._field[i2].get(r2, c2) * w2;
+                        }
+                      }
+                    }
+                    var levelIndex = this._pickResult.level;
+                    for (var j2 = 0; j2 < 3; ++j2) {
+                      levelIndex[j2] = bsearch.le(this.contourLevels[j2], pos[j2]);
+                      if (levelIndex[j2] < 0) {
+                        if (this.contourLevels[j2].length > 0) {
+                          levelIndex[j2] = 0;
+                        }
+                      } else if (levelIndex[j2] < this.contourLevels[j2].length - 1) {
+                        var a2 = this.contourLevels[j2][levelIndex[j2]];
+                        var b2 = this.contourLevels[j2][levelIndex[j2] + 1];
+                        if (Math.abs(a2 - pos[j2]) > Math.abs(b2 - pos[j2])) {
+                          levelIndex[j2] += 1;
+                        }
+                      }
+                    }
+                    result.index[0] = fx < 0.5 ? ix : ix + 1;
+                    result.index[1] = fy < 0.5 ? iy : iy + 1;
+                    result.uv[0] = x2 / shape[0];
+                    result.uv[1] = y2 / shape[1];
+                    for (i2 = 0; i2 < 3; ++i2) {
+                      result.dataCoordinate[i2] = this._field[i2].get(result.index[0], result.index[1]);
+                    }
+                    return result;
+                  };
+                  proto.padField = function(dstField, srcField) {
+                    var srcShape = srcField.shape.slice();
+                    var dstShape = dstField.shape.slice();
+                    ops.assign(dstField.lo(1, 1).hi(srcShape[0], srcShape[1]), srcField);
+                    ops.assign(
+                      dstField.lo(1).hi(srcShape[0], 1),
+                      srcField.hi(srcShape[0], 1)
+                    );
+                    ops.assign(
+                      dstField.lo(1, dstShape[1] - 1).hi(srcShape[0], 1),
+                      srcField.lo(0, srcShape[1] - 1).hi(srcShape[0], 1)
+                    );
+                    ops.assign(
+                      dstField.lo(0, 1).hi(1, srcShape[1]),
+                      srcField.hi(1)
+                    );
+                    ops.assign(
+                      dstField.lo(dstShape[0] - 1, 1).hi(1, srcShape[1]),
+                      srcField.lo(srcShape[0] - 1)
+                    );
+                    dstField.set(0, 0, srcField.get(0, 0));
+                    dstField.set(0, dstShape[1] - 1, srcField.get(0, srcShape[1] - 1));
+                    dstField.set(dstShape[0] - 1, 0, srcField.get(srcShape[0] - 1, 0));
+                    dstField.set(dstShape[0] - 1, dstShape[1] - 1, srcField.get(srcShape[0] - 1, srcShape[1] - 1));
+                  };
+                  function handleArray(param, ctor) {
+                    if (Array.isArray(param)) {
+                      return [ctor(param[0]), ctor(param[1]), ctor(param[2])];
+                    }
+                    return [ctor(param), ctor(param), ctor(param)];
+                  }
+                  function toColor(x2) {
+                    if (Array.isArray(x2)) {
+                      if (x2.length === 3) {
+                        return [x2[0], x2[1], x2[2], 1];
+                      }
+                      return [x2[0], x2[1], x2[2], x2[3]];
+                    }
+                    return [0, 0, 0, 1];
+                  }
+                  function handleColor(param) {
+                    if (Array.isArray(param)) {
+                      if (Array.isArray(param)) {
+                        return [
+                          toColor(param[0]),
+                          toColor(param[1]),
+                          toColor(param[2])
+                        ];
+                      } else {
+                        var c2 = toColor(param);
+                        return [
+                          c2.slice(),
+                          c2.slice(),
+                          c2.slice()
+                        ];
+                      }
+                    }
+                  }
+                  proto.update = function(params) {
+                    params = params || {};
+                    this.objectOffset = params.objectOffset || this.objectOffset;
+                    this.dirty = true;
+                    if ("contourWidth" in params) {
+                      this.contourWidth = handleArray(params.contourWidth, Number);
+                    }
+                    if ("showContour" in params) {
+                      this.showContour = handleArray(params.showContour, Boolean);
+                    }
+                    if ("showSurface" in params) {
+                      this.showSurface = !!params.showSurface;
+                    }
+                    if ("contourTint" in params) {
+                      this.contourTint = handleArray(params.contourTint, Boolean);
+                    }
+                    if ("contourColor" in params) {
+                      this.contourColor = handleColor(params.contourColor);
+                    }
+                    if ("contourProject" in params) {
+                      this.contourProject = handleArray(params.contourProject, function(x22) {
+                        return handleArray(x22, Boolean);
+                      });
+                    }
+                    if ("surfaceProject" in params) {
+                      this.surfaceProject = params.surfaceProject;
+                    }
+                    if ("dynamicColor" in params) {
+                      this.dynamicColor = handleColor(params.dynamicColor);
+                    }
+                    if ("dynamicTint" in params) {
+                      this.dynamicTint = handleArray(params.dynamicTint, Number);
+                    }
+                    if ("dynamicWidth" in params) {
+                      this.dynamicWidth = handleArray(params.dynamicWidth, Number);
+                    }
+                    if ("opacity" in params) {
+                      this.opacity = params.opacity;
+                    }
+                    if ("opacityscale" in params) {
+                      this.opacityscale = params.opacityscale;
+                    }
+                    if ("colorBounds" in params) {
+                      this.colorBounds = params.colorBounds;
+                    }
+                    if ("vertexColor" in params) {
+                      this.vertexColor = params.vertexColor ? 1 : 0;
+                    }
+                    if ("colormap" in params) {
+                      this._colorMap.setPixels(this.genColormap(params.colormap, this.opacityscale));
+                    }
+                    var field = params.field || params.coords && params.coords[2] || null;
+                    var levelsChanged = false;
+                    if (!field) {
+                      if (this._field[2].shape[0] || this._field[2].shape[2]) {
+                        field = this._field[2].lo(1, 1).hi(this._field[2].shape[0] - 2, this._field[2].shape[1] - 2);
+                      } else {
+                        field = this._field[2].hi(0, 0);
+                      }
+                    }
+                    if ("field" in params || "coords" in params) {
+                      var fsize = (field.shape[0] + 2) * (field.shape[1] + 2);
+                      if (fsize > this._field[2].data.length) {
+                        pool.freeFloat(this._field[2].data);
+                        this._field[2].data = pool.mallocFloat(bits.nextPow2(fsize));
+                      }
+                      this._field[2] = ndarray(this._field[2].data, [field.shape[0] + 2, field.shape[1] + 2]);
+                      this.padField(this._field[2], field);
+                      this.shape = field.shape.slice();
+                      var shape = this.shape;
+                      for (var i2 = 0; i2 < 2; ++i2) {
+                        if (this._field[2].size > this._field[i2].data.length) {
+                          pool.freeFloat(this._field[i2].data);
+                          this._field[i2].data = pool.mallocFloat(this._field[2].size);
+                        }
+                        this._field[i2] = ndarray(this._field[i2].data, [shape[0] + 2, shape[1] + 2]);
+                      }
+                      if (params.coords) {
+                        var coords = params.coords;
+                        if (!Array.isArray(coords) || coords.length !== 3) {
+                          throw new Error("gl-surface: invalid coordinates for x/y");
+                        }
+                        for (i2 = 0; i2 < 2; ++i2) {
+                          var coord = coords[i2];
+                          for (j2 = 0; j2 < 2; ++j2) {
+                            if (coord.shape[j2] !== shape[j2]) {
+                              throw new Error("gl-surface: coords have incorrect shape");
+                            }
+                          }
+                          this.padField(this._field[i2], coord);
+                        }
+                      } else if (params.ticks) {
+                        var ticks = params.ticks;
+                        if (!Array.isArray(ticks) || ticks.length !== 2) {
+                          throw new Error("gl-surface: invalid ticks");
+                        }
+                        for (i2 = 0; i2 < 2; ++i2) {
+                          var tick = ticks[i2];
+                          if (Array.isArray(tick) || tick.length) {
+                            tick = ndarray(tick);
+                          }
+                          if (tick.shape[0] !== shape[i2]) {
+                            throw new Error("gl-surface: invalid tick length");
+                          }
+                          var tick2 = ndarray(tick.data, shape);
+                          tick2.stride[i2] = tick.stride[0];
+                          tick2.stride[i2 ^ 1] = 0;
+                          this.padField(this._field[i2], tick2);
+                        }
+                      } else {
+                        for (i2 = 0; i2 < 2; ++i2) {
+                          var offset = [0, 0];
+                          offset[i2] = 1;
+                          this._field[i2] = ndarray(this._field[i2].data, [shape[0] + 2, shape[1] + 2], offset, 0);
+                        }
+                        this._field[0].set(0, 0, 0);
+                        for (var j2 = 0; j2 < shape[0]; ++j2) {
+                          this._field[0].set(j2 + 1, 0, j2);
+                        }
+                        this._field[0].set(shape[0] + 1, 0, shape[0] - 1);
+                        this._field[1].set(0, 0, 0);
+                        for (j2 = 0; j2 < shape[1]; ++j2) {
+                          this._field[1].set(0, j2 + 1, j2);
+                        }
+                        this._field[1].set(0, shape[1] + 1, shape[1] - 1);
+                      }
+                      var fields = this._field;
+                      var dfields = ndarray(pool.mallocFloat(fields[2].size * 3 * 2), [3, shape[0] + 2, shape[1] + 2, 2]);
+                      for (i2 = 0; i2 < 3; ++i2) {
+                        gradient(dfields.pick(i2), fields[i2], "mirror");
+                      }
+                      var normals = ndarray(pool.mallocFloat(fields[2].size * 3), [shape[0] + 2, shape[1] + 2, 3]);
+                      for (i2 = 0; i2 < shape[0] + 2; ++i2) {
+                        for (j2 = 0; j2 < shape[1] + 2; ++j2) {
+                          var dxdu = dfields.get(0, i2, j2, 0);
+                          var dxdv = dfields.get(0, i2, j2, 1);
+                          var dydu = dfields.get(1, i2, j2, 0);
+                          var dydv = dfields.get(1, i2, j2, 1);
+                          var dzdu = dfields.get(2, i2, j2, 0);
+                          var dzdv = dfields.get(2, i2, j2, 1);
+                          var nx = dydu * dzdv - dydv * dzdu;
+                          var ny = dzdu * dxdv - dzdv * dxdu;
+                          var nz = dxdu * dydv - dxdv * dydu;
+                          var nl2 = Math.sqrt(nx * nx + ny * ny + nz * nz);
+                          if (nl2 < 1e-8) {
+                            nl2 = Math.max(Math.abs(nx), Math.abs(ny), Math.abs(nz));
+                            if (nl2 < 1e-8) {
+                              nz = 1;
+                              ny = nx = 0;
+                              nl2 = 1;
+                            } else {
+                              nl2 = 1 / nl2;
+                            }
+                          } else {
+                            nl2 = 1 / Math.sqrt(nl2);
+                          }
+                          normals.set(i2, j2, 0, nx * nl2);
+                          normals.set(i2, j2, 1, ny * nl2);
+                          normals.set(i2, j2, 2, nz * nl2);
+                        }
+                      }
+                      pool.free(dfields.data);
+                      var lo = [Infinity, Infinity, Infinity];
+                      var hi2 = [-Infinity, -Infinity, -Infinity];
+                      var lo_intensity = Infinity;
+                      var hi_intensity = -Infinity;
+                      var count2 = (shape[0] - 1) * (shape[1] - 1) * 6;
+                      var tverts = pool.mallocFloat(bits.nextPow2(10 * count2));
+                      var tptr = 0;
+                      var vertexCount = 0;
+                      for (i2 = 0; i2 < shape[0] - 1; ++i2) {
+                        j_loop:
+                          for (j2 = 0; j2 < shape[1] - 1; ++j2) {
+                            for (var dx = 0; dx < 2; ++dx) {
+                              for (var dy = 0; dy < 2; ++dy) {
+                                for (var k2 = 0; k2 < 3; ++k2) {
+                                  var f2 = this._field[k2].get(1 + i2 + dx, 1 + j2 + dy);
+                                  if (isNaN(f2) || !isFinite(f2)) {
+                                    continue j_loop;
+                                  }
+                                }
+                              }
+                            }
+                            for (k2 = 0; k2 < 6; ++k2) {
+                              var r2 = i2 + QUAD[k2][0];
+                              var c2 = j2 + QUAD[k2][1];
+                              var tx = this._field[0].get(r2 + 1, c2 + 1);
+                              var ty = this._field[1].get(r2 + 1, c2 + 1);
+                              f2 = this._field[2].get(r2 + 1, c2 + 1);
+                              nx = normals.get(r2 + 1, c2 + 1, 0);
+                              ny = normals.get(r2 + 1, c2 + 1, 1);
+                              nz = normals.get(r2 + 1, c2 + 1, 2);
+                              if (params.intensity) {
+                                vf2 = params.intensity.get(r2, c2);
+                              }
+                              var vf2 = params.intensity ? params.intensity.get(r2, c2) : f2 + this.objectOffset[2];
+                              tverts[tptr++] = r2;
+                              tverts[tptr++] = c2;
+                              tverts[tptr++] = tx;
+                              tverts[tptr++] = ty;
+                              tverts[tptr++] = f2;
+                              tverts[tptr++] = 0;
+                              tverts[tptr++] = vf2;
+                              tverts[tptr++] = nx;
+                              tverts[tptr++] = ny;
+                              tverts[tptr++] = nz;
+                              lo[0] = Math.min(lo[0], tx + this.objectOffset[0]);
+                              lo[1] = Math.min(lo[1], ty + this.objectOffset[1]);
+                              lo[2] = Math.min(lo[2], f2 + this.objectOffset[2]);
+                              lo_intensity = Math.min(lo_intensity, vf2);
+                              hi2[0] = Math.max(hi2[0], tx + this.objectOffset[0]);
+                              hi2[1] = Math.max(hi2[1], ty + this.objectOffset[1]);
+                              hi2[2] = Math.max(hi2[2], f2 + this.objectOffset[2]);
+                              hi_intensity = Math.max(hi_intensity, vf2);
+                              vertexCount += 1;
+                            }
+                          }
+                      }
+                      if (params.intensityBounds) {
+                        lo_intensity = +params.intensityBounds[0];
+                        hi_intensity = +params.intensityBounds[1];
+                      }
+                      for (i2 = 6; i2 < tptr; i2 += 10) {
+                        tverts[i2] = (tverts[i2] - lo_intensity) / (hi_intensity - lo_intensity);
+                      }
+                      this._vertexCount = vertexCount;
+                      this._coordinateBuffer.update(tverts.subarray(0, tptr));
+                      pool.freeFloat(tverts);
+                      pool.free(normals.data);
+                      this.bounds = [lo, hi2];
+                      this.intensity = params.intensity || this._field[2];
+                      if (this.intensityBounds[0] !== lo_intensity || this.intensityBounds[1] !== hi_intensity) {
+                        levelsChanged = true;
+                      }
+                      this.intensityBounds = [lo_intensity, hi_intensity];
+                    }
+                    if ("levels" in params) {
+                      var levels = params.levels;
+                      if (!Array.isArray(levels[0])) {
+                        levels = [[], [], levels];
+                      } else {
+                        levels = levels.slice();
+                      }
+                      for (i2 = 0; i2 < 3; ++i2) {
+                        levels[i2] = levels[i2].slice();
+                        levels[i2].sort(function(a2, b2) {
+                          return a2 - b2;
+                        });
+                      }
+                      for (i2 = 0; i2 < 3; ++i2) {
+                        for (j2 = 0; j2 < levels[i2].length; ++j2) {
+                          levels[i2][j2] -= this.objectOffset[i2];
+                        }
+                      }
+                      change_test:
+                        for (i2 = 0; i2 < 3; ++i2) {
+                          if (levels[i2].length !== this.contourLevels[i2].length) {
+                            levelsChanged = true;
+                            break;
+                          }
+                          for (j2 = 0; j2 < levels[i2].length; ++j2) {
+                            if (levels[i2][j2] !== this.contourLevels[i2][j2]) {
+                              levelsChanged = true;
+                              break change_test;
+                            }
+                          }
+                        }
+                      this.contourLevels = levels;
+                    }
+                    if (levelsChanged) {
+                      fields = this._field;
+                      shape = this.shape;
+                      var contourVerts = [];
+                      for (var dim = 0; dim < 3; ++dim) {
+                        var contourLevel = this.contourLevels[dim];
+                        var levelOffsets = [];
+                        var levelCounts = [];
+                        var parts = [0, 0, 0];
+                        for (i2 = 0; i2 < contourLevel.length; ++i2) {
+                          var graph = surfaceNets(this._field[dim], contourLevel[i2]);
+                          levelOffsets.push(contourVerts.length / 5 | 0);
+                          vertexCount = 0;
+                          edge_loop:
+                            for (j2 = 0; j2 < graph.cells.length; ++j2) {
+                              var e2 = graph.cells[j2];
+                              for (k2 = 0; k2 < 2; ++k2) {
+                                var p2 = graph.positions[e2[k2]];
+                                var x2 = p2[0];
+                                var ix = Math.floor(x2) | 0;
+                                var fx = x2 - ix;
+                                var y2 = p2[1];
+                                var iy = Math.floor(y2) | 0;
+                                var fy = y2 - iy;
+                                var hole = false;
+                                axis_loop:
+                                  for (var axis = 0; axis < 3; ++axis) {
+                                    parts[axis] = 0;
+                                    var iu = (dim + axis + 1) % 3;
+                                    for (dx = 0; dx < 2; ++dx) {
+                                      var s2 = dx ? fx : 1 - fx;
+                                      r2 = Math.min(Math.max(ix + dx, 0), shape[0]) | 0;
+                                      for (dy = 0; dy < 2; ++dy) {
+                                        var t4 = dy ? fy : 1 - fy;
+                                        c2 = Math.min(Math.max(iy + dy, 0), shape[1]) | 0;
+                                        if (axis < 2) {
+                                          f2 = this._field[iu].get(r2, c2);
+                                        } else {
+                                          f2 = (this.intensity.get(r2, c2) - this.intensityBounds[0]) / (this.intensityBounds[1] - this.intensityBounds[0]);
+                                        }
+                                        if (!isFinite(f2) || isNaN(f2)) {
+                                          hole = true;
+                                          break axis_loop;
+                                        }
+                                        var w2 = s2 * t4;
+                                        parts[axis] += w2 * f2;
+                                      }
+                                    }
+                                  }
+                                if (!hole) {
+                                  contourVerts.push(
+                                    parts[0],
+                                    parts[1],
+                                    p2[0],
+                                    p2[1],
+                                    parts[2]
+                                  );
+                                  vertexCount += 1;
+                                } else {
+                                  if (k2 > 0) {
+                                    for (var l2 = 0; l2 < 5; ++l2) {
+                                      contourVerts.pop();
+                                    }
+                                    vertexCount -= 1;
+                                  }
+                                  continue edge_loop;
+                                }
+                              }
+                            }
+                          levelCounts.push(vertexCount);
+                        }
+                        this._contourOffsets[dim] = levelOffsets;
+                        this._contourCounts[dim] = levelCounts;
+                      }
+                      var floatBuffer = pool.mallocFloat(contourVerts.length);
+                      for (i2 = 0; i2 < contourVerts.length; ++i2) {
+                        floatBuffer[i2] = contourVerts[i2];
+                      }
+                      this._contourBuffer.update(floatBuffer);
+                      pool.freeFloat(floatBuffer);
+                    }
+                  };
+                  proto.dispose = function() {
+                    this._shader.dispose();
+                    this._vao.dispose();
+                    this._coordinateBuffer.dispose();
+                    this._colorMap.dispose();
+                    this._contourBuffer.dispose();
+                    this._contourVAO.dispose();
+                    this._contourShader.dispose();
+                    this._contourPickShader.dispose();
+                    this._dynamicBuffer.dispose();
+                    this._dynamicVAO.dispose();
+                    for (var i2 = 0; i2 < 3; ++i2) {
+                      pool.freeFloat(this._field[i2].data);
+                    }
+                  };
+                  proto.highlight = function(selection) {
+                    var i2;
+                    if (!selection) {
+                      this._dynamicCounts = [0, 0, 0];
+                      this.dyanamicLevel = [NaN, NaN, NaN];
+                      this.highlightLevel = [-1, -1, -1];
+                      return;
+                    }
+                    for (i2 = 0; i2 < 3; ++i2) {
+                      if (this.enableHighlight[i2]) {
+                        this.highlightLevel[i2] = selection.level[i2];
+                      } else {
+                        this.highlightLevel[i2] = -1;
+                      }
+                    }
+                    var levels;
+                    if (this.snapToData) {
+                      levels = selection.dataCoordinate;
+                    } else {
+                      levels = selection.position;
+                    }
+                    for (i2 = 0; i2 < 3; ++i2) {
+                      levels[i2] -= this.objectOffset[i2];
+                    }
+                    if ((!this.enableDynamic[0] || levels[0] === this.dynamicLevel[0]) && (!this.enableDynamic[1] || levels[1] === this.dynamicLevel[1]) && (!this.enableDynamic[2] || levels[2] === this.dynamicLevel[2])) {
+                      return;
+                    }
+                    var vertexCount = 0;
+                    var shape = this.shape;
+                    var scratchBuffer = pool.mallocFloat(12 * shape[0] * shape[1]);
+                    for (var d2 = 0; d2 < 3; ++d2) {
+                      if (!this.enableDynamic[d2]) {
+                        this.dynamicLevel[d2] = NaN;
+                        this._dynamicCounts[d2] = 0;
+                        continue;
+                      }
+                      this.dynamicLevel[d2] = levels[d2];
+                      var u2 = (d2 + 1) % 3;
+                      var v2 = (d2 + 2) % 3;
+                      var f2 = this._field[d2];
+                      var g2 = this._field[u2];
+                      var h2 = this._field[v2];
+                      var graph = surfaceNets(f2, levels[d2]);
+                      var edges = graph.cells;
+                      var positions = graph.positions;
+                      this._dynamicOffsets[d2] = vertexCount;
+                      for (i2 = 0; i2 < edges.length; ++i2) {
+                        var e2 = edges[i2];
+                        for (var j2 = 0; j2 < 2; ++j2) {
+                          var p2 = positions[e2[j2]];
+                          var x2 = +p2[0];
+                          var ix = x2 | 0;
+                          var jx = Math.min(ix + 1, shape[0]) | 0;
+                          var fx = x2 - ix;
+                          var hx = 1 - fx;
+                          var y2 = +p2[1];
+                          var iy = y2 | 0;
+                          var jy = Math.min(iy + 1, shape[1]) | 0;
+                          var fy = y2 - iy;
+                          var hy = 1 - fy;
+                          var w00 = hx * hy;
+                          var w01 = hx * fy;
+                          var w10 = fx * hy;
+                          var w11 = fx * fy;
+                          var cu = w00 * g2.get(ix, iy) + w01 * g2.get(ix, jy) + w10 * g2.get(jx, iy) + w11 * g2.get(jx, jy);
+                          var cv = w00 * h2.get(ix, iy) + w01 * h2.get(ix, jy) + w10 * h2.get(jx, iy) + w11 * h2.get(jx, jy);
+                          if (isNaN(cu) || isNaN(cv)) {
+                            if (j2) {
+                              vertexCount -= 1;
+                            }
+                            break;
+                          }
+                          scratchBuffer[2 * vertexCount + 0] = cu;
+                          scratchBuffer[2 * vertexCount + 1] = cv;
+                          vertexCount += 1;
+                        }
+                      }
+                      this._dynamicCounts[d2] = vertexCount - this._dynamicOffsets[d2];
+                    }
+                    this._dynamicBuffer.update(scratchBuffer.subarray(0, 2 * vertexCount));
+                    pool.freeFloat(scratchBuffer);
+                  };
+                  function createSurfacePlot(params) {
+                    var gl2 = params.gl;
+                    var shader = createShader(gl2);
+                    var pickShader = createPickShader(gl2);
+                    var contourShader = createContourShader(gl2);
+                    var contourPickShader = createPickContourShader(gl2);
+                    var coordinateBuffer = createBuffer(gl2);
+                    var vao = createVAO(gl2, [
+                      {
+                        buffer: coordinateBuffer,
+                        size: 4,
+                        stride: SURFACE_VERTEX_SIZE,
+                        offset: 0
+                      },
+                      {
+                        buffer: coordinateBuffer,
+                        size: 3,
+                        stride: SURFACE_VERTEX_SIZE,
+                        offset: 16
+                      },
+                      {
+                        buffer: coordinateBuffer,
+                        size: 3,
+                        stride: SURFACE_VERTEX_SIZE,
+                        offset: 28
+                      }
+                    ]);
+                    var contourBuffer = createBuffer(gl2);
+                    var contourVAO = createVAO(gl2, [
+                      {
+                        buffer: contourBuffer,
+                        size: 4,
+                        stride: 20,
+                        offset: 0
+                      },
+                      {
+                        buffer: contourBuffer,
+                        size: 1,
+                        stride: 20,
+                        offset: 16
+                      }
+                    ]);
+                    var dynamicBuffer = createBuffer(gl2);
+                    var dynamicVAO = createVAO(gl2, [
+                      {
+                        buffer: dynamicBuffer,
+                        size: 2,
+                        type: gl2.FLOAT
+                      }
+                    ]);
+                    var cmap = createTexture2(gl2, 1, N_COLORS, gl2.RGBA, gl2.UNSIGNED_BYTE);
+                    cmap.minFilter = gl2.LINEAR;
+                    cmap.magFilter = gl2.LINEAR;
+                    var surface = new SurfacePlot(
+                      gl2,
+                      [0, 0],
+                      // shape
+                      [[0, 0, 0], [0, 0, 0]],
+                      // bounds
+                      shader,
+                      pickShader,
+                      coordinateBuffer,
+                      vao,
+                      cmap,
+                      contourShader,
+                      contourPickShader,
+                      contourBuffer,
+                      contourVAO,
+                      dynamicBuffer,
+                      dynamicVAO,
+                      [0, 0, 0]
+                      // objectOffset
+                    );
+                    var nparams = {
+                      levels: [[], [], []]
+                    };
+                    for (var id2 in params) {
+                      nparams[id2] = params[id2];
+                    }
+                    nparams.colormap = nparams.colormap || "jet";
+                    surface.update(nparams);
+                    return surface;
+                  }
+                }
+              ),
+              /***/
+              9507: (
+                /***/
+                function(module22) {
+                  module22.exports = true;
+                }
+              ),
+              /***/
+              9618: (
+                /***/
+                function(module22, __unused_webpack_exports, __webpack_require__2) {
+                  var isBuffer2 = __webpack_require__2(7163);
+                  var hasTypedArrays = typeof Float64Array !== "undefined";
+                  function compare1st(a2, b2) {
+                    return a2[0] - b2[0];
+                  }
+                  function order() {
+                    var stride = this.stride;
+                    var terms = new Array(stride.length);
+                    var i2;
+                    for (i2 = 0; i2 < terms.length; ++i2) {
+                      terms[i2] = [Math.abs(stride[i2]), i2];
+                    }
+                    terms.sort(compare1st);
+                    var result = new Array(terms.length);
+                    for (i2 = 0; i2 < result.length; ++i2) {
+                      result[i2] = terms[i2][1];
+                    }
+                    return result;
+                  }
+                  var allFns = {
+                    // Special case for trivial arrays
+                    T: function(dtype) {
+                      function View2(a2) {
+                        this.data = a2;
+                      }
+                      var proto = View2.prototype;
+                      proto.dtype = dtype;
+                      proto.index = function() {
+                        return -1;
+                      };
+                      proto.size = 0;
+                      proto.dimension = -1;
+                      proto.shape = proto.stride = proto.order = [];
+                      proto.lo = proto.hi = proto.transpose = proto.step = function() {
+                        return new View2(this.data);
+                      };
+                      proto.get = proto.set = function() {
+                      };
+                      proto.pick = function() {
+                        return null;
+                      };
+                      return function construct(a2) {
+                        return new View2(a2);
+                      };
+                    },
+                    // Special case for 0d arrays
+                    0: function(dtype, TrivialArray) {
+                      function View2(a2, d2) {
+                        this.data = a2;
+                        this.offset = d2;
+                      }
+                      var proto = View2.prototype;
+                      proto.dtype = dtype;
+                      proto.index = function() {
+                        return this.offset;
+                      };
+                      proto.dimension = 0;
+                      proto.size = 1;
+                      proto.shape = proto.stride = proto.order = [];
+                      proto.lo = proto.hi = proto.transpose = proto.step = function copy() {
+                        return new View2(this.data, this.offset);
+                      };
+                      proto.pick = function pick() {
+                        return TrivialArray(this.data);
+                      };
+                      proto.valueOf = proto.get = function get() {
+                        return dtype === "generic" ? this.data.get(this.offset) : this.data[this.offset];
+                      };
+                      proto.set = function set(v2) {
+                        return dtype === "generic" ? this.data.set(this.offset, v2) : this.data[this.offset] = v2;
+                      };
+                      return function construct(a2, b2, c2, d2) {
+                        return new View2(a2, d2);
+                      };
+                    },
+                    1: function(dtype, CTOR_LIST, ORDER) {
+                      function View2(a2, b0, c0, d2) {
+                        this.data = a2;
+                        this.shape = [b0];
+                        this.stride = [c0];
+                        this.offset = d2 | 0;
+                      }
+                      var proto = View2.prototype;
+                      proto.dtype = dtype;
+                      proto.dimension = 1;
+                      Object.defineProperty(proto, "size", {
+                        get: function size() {
+                          return this.shape[0];
+                        }
+                      });
+                      proto.order = [0];
+                      proto.set = function set(i0, v2) {
+                        return dtype === "generic" ? this.data.set(this.offset + this.stride[0] * i0, v2) : this.data[this.offset + this.stride[0] * i0] = v2;
+                      };
+                      proto.get = function get(i0) {
+                        return dtype === "generic" ? this.data.get(this.offset + this.stride[0] * i0) : this.data[this.offset + this.stride[0] * i0];
+                      };
+                      proto.index = function index(i0) {
+                        return this.offset + this.stride[0] * i0;
+                      };
+                      proto.hi = function hi2(i0) {
+                        return new View2(this.data, typeof i0 !== "number" || i0 < 0 ? this.shape[0] : i0 | 0, this.stride[0], this.offset);
+                      };
+                      proto.lo = function lo(i0) {
+                        var b2 = this.offset, d2 = 0, a0 = this.shape[0], c0 = this.stride[0];
+                        if (typeof i0 === "number" && i0 >= 0) {
+                          d2 = i0 | 0;
+                          b2 += c0 * d2;
+                          a0 -= d2;
+                        }
+                        return new View2(this.data, a0, c0, b2);
+                      };
+                      proto.step = function step(i0) {
+                        var a0 = this.shape[0], b0 = this.stride[0], c2 = this.offset, d2 = 0, ceil = Math.ceil;
+                        if (typeof i0 === "number") {
+                          d2 = i0 | 0;
+                          if (d2 < 0) {
+                            c2 += b0 * (a0 - 1);
+                            a0 = ceil(-a0 / d2);
+                          } else {
+                            a0 = ceil(a0 / d2);
+                          }
+                          b0 *= d2;
+                        }
+                        return new View2(this.data, a0, b0, c2);
+                      };
+                      proto.transpose = function transpose2(i0) {
+                        i0 = i0 === void 0 ? 0 : i0 | 0;
+                        var a2 = this.shape, b2 = this.stride;
+                        return new View2(this.data, a2[i0], b2[i0], this.offset);
+                      };
+                      proto.pick = function pick(i0) {
+                        var a2 = [], b2 = [], c2 = this.offset;
+                        if (typeof i0 === "number" && i0 >= 0) {
+                          c2 = c2 + this.stride[0] * i0 | 0;
+                        } else {
+                          a2.push(this.shape[0]);
+                          b2.push(this.stride[0]);
+                        }
+                        var ctor = CTOR_LIST[a2.length + 1];
+                        return ctor(this.data, a2, b2, c2);
+                      };
+                      return function construct(data, shape, stride, offset) {
+                        return new View2(data, shape[0], stride[0], offset);
+                      };
+                    },
+                    2: function(dtype, CTOR_LIST, ORDER) {
+                      function View2(a2, b0, b1, c0, c1, d2) {
+                        this.data = a2;
+                        this.shape = [b0, b1];
+                        this.stride = [c0, c1];
+                        this.offset = d2 | 0;
+                      }
+                      var proto = View2.prototype;
+                      proto.dtype = dtype;
+                      proto.dimension = 2;
+                      Object.defineProperty(proto, "size", {
+                        get: function size() {
+                          return this.shape[0] * this.shape[1];
+                        }
+                      });
+                      Object.defineProperty(proto, "order", {
+                        get: function order2() {
+                          return Math.abs(this.stride[0]) > Math.abs(this.stride[1]) ? [1, 0] : [0, 1];
+                        }
+                      });
+                      proto.set = function set(i0, i1, v2) {
+                        return dtype === "generic" ? this.data.set(this.offset + this.stride[0] * i0 + this.stride[1] * i1, v2) : this.data[this.offset + this.stride[0] * i0 + this.stride[1] * i1] = v2;
+                      };
+                      proto.get = function get(i0, i1) {
+                        return dtype === "generic" ? this.data.get(this.offset + this.stride[0] * i0 + this.stride[1] * i1) : this.data[this.offset + this.stride[0] * i0 + this.stride[1] * i1];
+                      };
+                      proto.index = function index(i0, i1) {
+                        return this.offset + this.stride[0] * i0 + this.stride[1] * i1;
+                      };
+                      proto.hi = function hi2(i0, i1) {
+                        return new View2(
+                          this.data,
+                          typeof i0 !== "number" || i0 < 0 ? this.shape[0] : i0 | 0,
+                          typeof i1 !== "number" || i1 < 0 ? this.shape[1] : i1 | 0,
+                          this.stride[0],
+                          this.stride[1],
+                          this.offset
+                        );
+                      };
+                      proto.lo = function lo(i0, i1) {
+                        var b2 = this.offset, d2 = 0, a0 = this.shape[0], a1 = this.shape[1], c0 = this.stride[0], c1 = this.stride[1];
+                        if (typeof i0 === "number" && i0 >= 0) {
+                          d2 = i0 | 0;
+                          b2 += c0 * d2;
+                          a0 -= d2;
+                        }
+                        if (typeof i1 === "number" && i1 >= 0) {
+                          d2 = i1 | 0;
+                          b2 += c1 * d2;
+                          a1 -= d2;
+                        }
+                        return new View2(this.data, a0, a1, c0, c1, b2);
+                      };
+                      proto.step = function step(i0, i1) {
+                        var a0 = this.shape[0], a1 = this.shape[1], b0 = this.stride[0], b1 = this.stride[1], c2 = this.offset, d2 = 0, ceil = Math.ceil;
+                        if (typeof i0 === "number") {
+                          d2 = i0 | 0;
+                          if (d2 < 0) {
+                            c2 += b0 * (a0 - 1);
+                            a0 = ceil(-a0 / d2);
+                          } else {
+                            a0 = ceil(a0 / d2);
+                          }
+                          b0 *= d2;
+                        }
+                        if (typeof i1 === "number") {
+                          d2 = i1 | 0;
+                          if (d2 < 0) {
+                            c2 += b1 * (a1 - 1);
+                            a1 = ceil(-a1 / d2);
+                          } else {
+                            a1 = ceil(a1 / d2);
+                          }
+                          b1 *= d2;
+                        }
+                        return new View2(this.data, a0, a1, b0, b1, c2);
+                      };
+                      proto.transpose = function transpose2(i0, i1) {
+                        i0 = i0 === void 0 ? 0 : i0 | 0;
+                        i1 = i1 === void 0 ? 1 : i1 | 0;
+                        var a2 = this.shape, b2 = this.stride;
+                        return new View2(this.data, a2[i0], a2[i1], b2[i0], b2[i1], this.offset);
+                      };
+                      proto.pick = function pick(i0, i1) {
+                        var a2 = [], b2 = [], c2 = this.offset;
+                        if (typeof i0 === "number" && i0 >= 0) {
+                          c2 = c2 + this.stride[0] * i0 | 0;
+                        } else {
+                          a2.push(this.shape[0]);
+                          b2.push(this.stride[0]);
+                        }
+                        if (typeof i1 === "number" && i1 >= 0) {
+                          c2 = c2 + this.stride[1] * i1 | 0;
+                        } else {
+                          a2.push(this.shape[1]);
+                          b2.push(this.stride[1]);
+                        }
+                        var ctor = CTOR_LIST[a2.length + 1];
+                        return ctor(this.data, a2, b2, c2);
+                      };
+                      return function construct(data, shape, stride, offset) {
+                        return new View2(data, shape[0], shape[1], stride[0], stride[1], offset);
+                      };
+                    },
+                    3: function(dtype, CTOR_LIST, ORDER) {
+                      function View2(a2, b0, b1, b2, c0, c1, c2, d2) {
+                        this.data = a2;
+                        this.shape = [b0, b1, b2];
+                        this.stride = [c0, c1, c2];
+                        this.offset = d2 | 0;
+                      }
+                      var proto = View2.prototype;
+                      proto.dtype = dtype;
+                      proto.dimension = 3;
+                      Object.defineProperty(proto, "size", {
+                        get: function size() {
+                          return this.shape[0] * this.shape[1] * this.shape[2];
+                        }
+                      });
+                      Object.defineProperty(proto, "order", {
+                        get: function order2() {
+                          var s0 = Math.abs(this.stride[0]), s1 = Math.abs(this.stride[1]), s2 = Math.abs(this.stride[2]);
+                          if (s0 > s1) {
+                            if (s1 > s2) {
+                              return [2, 1, 0];
+                            } else if (s0 > s2) {
+                              return [1, 2, 0];
+                            } else {
+                              return [1, 0, 2];
+                            }
+                          } else if (s0 > s2) {
+                            return [2, 0, 1];
+                          } else if (s2 > s1) {
+                            return [0, 1, 2];
+                          } else {
+                            return [0, 2, 1];
+                          }
+                        }
+                      });
+                      proto.set = function set(i0, i1, i2, v2) {
+                        return dtype === "generic" ? this.data.set(this.offset + this.stride[0] * i0 + this.stride[1] * i1 + this.stride[2] * i2, v2) : this.data[this.offset + this.stride[0] * i0 + this.stride[1] * i1 + this.stride[2] * i2] = v2;
+                      };
+                      proto.get = function get(i0, i1, i2) {
+                        return dtype === "generic" ? this.data.get(this.offset + this.stride[0] * i0 + this.stride[1] * i1 + this.stride[2] * i2) : this.data[this.offset + this.stride[0] * i0 + this.stride[1] * i1 + this.stride[2] * i2];
+                      };
+                      proto.index = function index(i0, i1, i2) {
+                        return this.offset + this.stride[0] * i0 + this.stride[1] * i1 + this.stride[2] * i2;
+                      };
+                      proto.hi = function hi2(i0, i1, i2) {
+                        return new View2(
+                          this.data,
+                          typeof i0 !== "number" || i0 < 0 ? this.shape[0] : i0 | 0,
+                          typeof i1 !== "number" || i1 < 0 ? this.shape[1] : i1 | 0,
+                          typeof i2 !== "number" || i2 < 0 ? this.shape[2] : i2 | 0,
+                          this.stride[0],
+                          this.stride[1],
+                          this.stride[2],
+                          this.offset
+                        );
+                      };
+                      proto.lo = function lo(i0, i1, i2) {
+                        var b2 = this.offset, d2 = 0, a0 = this.shape[0], a1 = this.shape[1], a2 = this.shape[2], c0 = this.stride[0], c1 = this.stride[1], c2 = this.stride[2];
+                        if (typeof i0 === "number" && i0 >= 0) {
+                          d2 = i0 | 0;
+                          b2 += c0 * d2;
+                          a0 -= d2;
+                        }
+                        if (typeof i1 === "number" && i1 >= 0) {
+                          d2 = i1 | 0;
+                          b2 += c1 * d2;
+                          a1 -= d2;
+                        }
+                        if (typeof i2 === "number" && i2 >= 0) {
+                          d2 = i2 | 0;
+                          b2 += c2 * d2;
+                          a2 -= d2;
+                        }
+                        return new View2(this.data, a0, a1, a2, c0, c1, c2, b2);
+                      };
+                      proto.step = function step(i0, i1, i2) {
+                        var a0 = this.shape[0], a1 = this.shape[1], a2 = this.shape[2], b0 = this.stride[0], b1 = this.stride[1], b2 = this.stride[2], c2 = this.offset, d2 = 0, ceil = Math.ceil;
+                        if (typeof i0 === "number") {
+                          d2 = i0 | 0;
+                          if (d2 < 0) {
+                            c2 += b0 * (a0 - 1);
+                            a0 = ceil(-a0 / d2);
+                          } else {
+                            a0 = ceil(a0 / d2);
+                          }
+                          b0 *= d2;
+                        }
+                        if (typeof i1 === "number") {
+                          d2 = i1 | 0;
+                          if (d2 < 0) {
+                            c2 += b1 * (a1 - 1);
+                            a1 = ceil(-a1 / d2);
+                          } else {
+                            a1 = ceil(a1 / d2);
+                          }
+                          b1 *= d2;
+                        }
+                        if (typeof i2 === "number") {
+                          d2 = i2 | 0;
+                          if (d2 < 0) {
+                            c2 += b2 * (a2 - 1);
+                            a2 = ceil(-a2 / d2);
+                          } else {
+                            a2 = ceil(a2 / d2);
+                          }
+                          b2 *= d2;
+                        }
+                        return new View2(this.data, a0, a1, a2, b0, b1, b2, c2);
+                      };
+                      proto.transpose = function transpose2(i0, i1, i2) {
+                        i0 = i0 === void 0 ? 0 : i0 | 0;
+                        i1 = i1 === void 0 ? 1 : i1 | 0;
+                        i2 = i2 === void 0 ? 2 : i2 | 0;
+                        var a2 = this.shape, b2 = this.stride;
+                        return new View2(this.data, a2[i0], a2[i1], a2[i2], b2[i0], b2[i1], b2[i2], this.offset);
+                      };
+                      proto.pick = function pick(i0, i1, i2) {
+                        var a2 = [], b2 = [], c2 = this.offset;
+                        if (typeof i0 === "number" && i0 >= 0) {
+                          c2 = c2 + this.stride[0] * i0 | 0;
+                        } else {
+                          a2.push(this.shape[0]);
+                          b2.push(this.stride[0]);
+                        }
+                        if (typeof i1 === "number" && i1 >= 0) {
+                          c2 = c2 + this.stride[1] * i1 | 0;
+                        } else {
+                          a2.push(this.shape[1]);
+                          b2.push(this.stride[1]);
+                        }
+                        if (typeof i2 === "number" && i2 >= 0) {
+                          c2 = c2 + this.stride[2] * i2 | 0;
+                        } else {
+                          a2.push(this.shape[2]);
+                          b2.push(this.stride[2]);
+                        }
+                        var ctor = CTOR_LIST[a2.length + 1];
+                        return ctor(this.data, a2, b2, c2);
+                      };
+                      return function construct(data, shape, stride, offset) {
+                        return new View2(data, shape[0], shape[1], shape[2], stride[0], stride[1], stride[2], offset);
+                      };
+                    },
+                    4: function(dtype, CTOR_LIST, ORDER) {
+                      function View2(a2, b0, b1, b2, b3, c0, c1, c2, c3, d2) {
+                        this.data = a2;
+                        this.shape = [b0, b1, b2, b3];
+                        this.stride = [c0, c1, c2, c3];
+                        this.offset = d2 | 0;
+                      }
+                      var proto = View2.prototype;
+                      proto.dtype = dtype;
+                      proto.dimension = 4;
+                      Object.defineProperty(proto, "size", {
+                        get: function size() {
+                          return this.shape[0] * this.shape[1] * this.shape[2] * this.shape[3];
+                        }
+                      });
+                      Object.defineProperty(proto, "order", { get: ORDER });
+                      proto.set = function set(i0, i1, i2, i3, v2) {
+                        return dtype === "generic" ? this.data.set(this.offset + this.stride[0] * i0 + this.stride[1] * i1 + this.stride[2] * i2 + this.stride[3] * i3, v2) : this.data[this.offset + this.stride[0] * i0 + this.stride[1] * i1 + this.stride[2] * i2 + this.stride[3] * i3] = v2;
+                      };
+                      proto.get = function get(i0, i1, i2, i3) {
+                        return dtype === "generic" ? this.data.get(this.offset + this.stride[0] * i0 + this.stride[1] * i1 + this.stride[2] * i2 + this.stride[3] * i3) : this.data[this.offset + this.stride[0] * i0 + this.stride[1] * i1 + this.stride[2] * i2 + this.stride[3] * i3];
+                      };
+                      proto.index = function index(i0, i1, i2, i3) {
+                        return this.offset + this.stride[0] * i0 + this.stride[1] * i1 + this.stride[2] * i2 + this.stride[3] * i3;
+                      };
+                      proto.hi = function hi2(i0, i1, i2, i3) {
+                        return new View2(
+                          this.data,
+                          typeof i0 !== "number" || i0 < 0 ? this.shape[0] : i0 | 0,
+                          typeof i1 !== "number" || i1 < 0 ? this.shape[1] : i1 | 0,
+                          typeof i2 !== "number" || i2 < 0 ? this.shape[2] : i2 | 0,
+                          typeof i3 !== "number" || i3 < 0 ? this.shape[3] : i3 | 0,
+                          this.stride[0],
+                          this.stride[1],
+                          this.stride[2],
+                          this.stride[3],
+                          this.offset
+                        );
+                      };
+                      proto.lo = function lo(i0, i1, i2, i3) {
+                        var b2 = this.offset, d2 = 0, a0 = this.shape[0], a1 = this.shape[1], a2 = this.shape[2], a3 = this.shape[3], c0 = this.stride[0], c1 = this.stride[1], c2 = this.stride[2], c3 = this.stride[3];
+                        if (typeof i0 === "number" && i0 >= 0) {
+                          d2 = i0 | 0;
+                          b2 += c0 * d2;
+                          a0 -= d2;
+                        }
+                        if (typeof i1 === "number" && i1 >= 0) {
+                          d2 = i1 | 0;
+                          b2 += c1 * d2;
+                          a1 -= d2;
+                        }
+                        if (typeof i2 === "number" && i2 >= 0) {
+                          d2 = i2 | 0;
+                          b2 += c2 * d2;
+                          a2 -= d2;
+                        }
+                        if (typeof i3 === "number" && i3 >= 0) {
+                          d2 = i3 | 0;
+                          b2 += c3 * d2;
+                          a3 -= d2;
+                        }
+                        return new View2(this.data, a0, a1, a2, a3, c0, c1, c2, c3, b2);
+                      };
+                      proto.step = function step(i0, i1, i2, i3) {
+                        var a0 = this.shape[0], a1 = this.shape[1], a2 = this.shape[2], a3 = this.shape[3], b0 = this.stride[0], b1 = this.stride[1], b2 = this.stride[2], b3 = this.stride[3], c2 = this.offset, d2 = 0, ceil = Math.ceil;
+                        if (typeof i0 === "number") {
+                          d2 = i0 | 0;
+                          if (d2 < 0) {
+                            c2 += b0 * (a0 - 1);
+                            a0 = ceil(-a0 / d2);
+                          } else {
+                            a0 = ceil(a0 / d2);
+                          }
+                          b0 *= d2;
+                        }
+                        if (typeof i1 === "number") {
+                          d2 = i1 | 0;
+                          if (d2 < 0) {
+                            c2 += b1 * (a1 - 1);
+                            a1 = ceil(-a1 / d2);
+                          } else {
+                            a1 = ceil(a1 / d2);
+                          }
+                          b1 *= d2;
+                        }
+                        if (typeof i2 === "number") {
+                          d2 = i2 | 0;
+                          if (d2 < 0) {
+                            c2 += b2 * (a2 - 1);
+                            a2 = ceil(-a2 / d2);
+                          } else {
+                            a2 = ceil(a2 / d2);
+                          }
+                          b2 *= d2;
+                        }
+                        if (typeof i3 === "number") {
+                          d2 = i3 | 0;
+                          if (d2 < 0) {
+                            c2 += b3 * (a3 - 1);
+                            a3 = ceil(-a3 / d2);
+                          } else {
+                            a3 = ceil(a3 / d2);
+                          }
+                          b3 *= d2;
+                        }
+                        return new View2(this.data, a0, a1, a2, a3, b0, b1, b2, b3, c2);
+                      };
+                      proto.transpose = function transpose2(i0, i1, i2, i3) {
+                        i0 = i0 === void 0 ? 0 : i0 | 0;
+                        i1 = i1 === void 0 ? 1 : i1 | 0;
+                        i2 = i2 === void 0 ? 2 : i2 | 0;
+                        i3 = i3 === void 0 ? 3 : i3 | 0;
+                        var a2 = this.shape, b2 = this.stride;
+                        return new View2(this.data, a2[i0], a2[i1], a2[i2], a2[i3], b2[i0], b2[i1], b2[i2], b2[i3], this.offset);
+                      };
+                      proto.pick = function pick(i0, i1, i2, i3) {
+                        var a2 = [], b2 = [], c2 = this.offset;
+                        if (typeof i0 === "number" && i0 >= 0) {
+                          c2 = c2 + this.stride[0] * i0 | 0;
+                        } else {
+                          a2.push(this.shape[0]);
+                          b2.push(this.stride[0]);
+                        }
+                        if (typeof i1 === "number" && i1 >= 0) {
+                          c2 = c2 + this.stride[1] * i1 | 0;
+                        } else {
+                          a2.push(this.shape[1]);
+                          b2.push(this.stride[1]);
+                        }
+                        if (typeof i2 === "number" && i2 >= 0) {
+                          c2 = c2 + this.stride[2] * i2 | 0;
+                        } else {
+                          a2.push(this.shape[2]);
+                          b2.push(this.stride[2]);
+                        }
+                        if (typeof i3 === "number" && i3 >= 0) {
+                          c2 = c2 + this.stride[3] * i3 | 0;
+                        } else {
+                          a2.push(this.shape[3]);
+                          b2.push(this.stride[3]);
+                        }
+                        var ctor = CTOR_LIST[a2.length + 1];
+                        return ctor(this.data, a2, b2, c2);
+                      };
+                      return function construct(data, shape, stride, offset) {
+                        return new View2(data, shape[0], shape[1], shape[2], shape[3], stride[0], stride[1], stride[2], stride[3], offset);
+                      };
+                    },
+                    5: function anonymous(dtype, CTOR_LIST, ORDER) {
+                      function View2(a2, b0, b1, b2, b3, b4, c0, c1, c2, c3, c4, d2) {
+                        this.data = a2;
+                        this.shape = [b0, b1, b2, b3, b4];
+                        this.stride = [c0, c1, c2, c3, c4];
+                        this.offset = d2 | 0;
+                      }
+                      var proto = View2.prototype;
+                      proto.dtype = dtype;
+                      proto.dimension = 5;
+                      Object.defineProperty(proto, "size", {
+                        get: function size() {
+                          return this.shape[0] * this.shape[1] * this.shape[2] * this.shape[3] * this.shape[4];
+                        }
+                      });
+                      Object.defineProperty(proto, "order", { get: ORDER });
+                      proto.set = function set(i0, i1, i2, i3, i4, v2) {
+                        return dtype === "generic" ? this.data.set(
+                          this.offset + this.stride[0] * i0 + this.stride[1] * i1 + this.stride[2] * i2 + this.stride[3] * i3 + this.stride[4] * i4,
+                          v2
+                        ) : this.data[this.offset + this.stride[0] * i0 + this.stride[1] * i1 + this.stride[2] * i2 + this.stride[3] * i3 + this.stride[4] * i4] = v2;
+                      };
+                      proto.get = function get(i0, i1, i2, i3, i4) {
+                        return dtype === "generic" ? this.data.get(
+                          this.offset + this.stride[0] * i0 + this.stride[1] * i1 + this.stride[2] * i2 + this.stride[3] * i3 + this.stride[4] * i4
+                        ) : this.data[this.offset + this.stride[0] * i0 + this.stride[1] * i1 + this.stride[2] * i2 + this.stride[3] * i3 + this.stride[4] * i4];
+                      };
+                      proto.index = function index(i0, i1, i2, i3, i4) {
+                        return this.offset + this.stride[0] * i0 + this.stride[1] * i1 + this.stride[2] * i2 + this.stride[3] * i3 + this.stride[4] * i4;
+                      };
+                      proto.hi = function hi2(i0, i1, i2, i3, i4) {
+                        return new View2(
+                          this.data,
+                          typeof i0 !== "number" || i0 < 0 ? this.shape[0] : i0 | 0,
+                          typeof i1 !== "number" || i1 < 0 ? this.shape[1] : i1 | 0,
+                          typeof i2 !== "number" || i2 < 0 ? this.shape[2] : i2 | 0,
+                          typeof i3 !== "number" || i3 < 0 ? this.shape[3] : i3 | 0,
+                          typeof i4 !== "number" || i4 < 0 ? this.shape[4] : i4 | 0,
+                          this.stride[0],
+                          this.stride[1],
+                          this.stride[2],
+                          this.stride[3],
+                          this.stride[4],
+                          this.offset
+                        );
+                      };
+                      proto.lo = function lo(i0, i1, i2, i3, i4) {
+                        var b2 = this.offset, d2 = 0, a0 = this.shape[0], a1 = this.shape[1], a2 = this.shape[2], a3 = this.shape[3], a4 = this.shape[4], c0 = this.stride[0], c1 = this.stride[1], c2 = this.stride[2], c3 = this.stride[3], c4 = this.stride[4];
+                        if (typeof i0 === "number" && i0 >= 0) {
+                          d2 = i0 | 0;
+                          b2 += c0 * d2;
+                          a0 -= d2;
+                        }
+                        if (typeof i1 === "number" && i1 >= 0) {
+                          d2 = i1 | 0;
+                          b2 += c1 * d2;
+                          a1 -= d2;
+                        }
+                        if (typeof i2 === "number" && i2 >= 0) {
+                          d2 = i2 | 0;
+                          b2 += c2 * d2;
+                          a2 -= d2;
+                        }
+                        if (typeof i3 === "number" && i3 >= 0) {
+                          d2 = i3 | 0;
+                          b2 += c3 * d2;
+                          a3 -= d2;
+                        }
+                        if (typeof i4 === "number" && i4 >= 0) {
+                          d2 = i4 | 0;
+                          b2 += c4 * d2;
+                          a4 -= d2;
+                        }
+                        return new View2(this.data, a0, a1, a2, a3, a4, c0, c1, c2, c3, c4, b2);
+                      };
+                      proto.step = function step(i0, i1, i2, i3, i4) {
+                        var a0 = this.shape[0], a1 = this.shape[1], a2 = this.shape[2], a3 = this.shape[3], a4 = this.shape[4], b0 = this.stride[0], b1 = this.stride[1], b2 = this.stride[2], b3 = this.stride[3], b4 = this.stride[4], c2 = this.offset, d2 = 0, ceil = Math.ceil;
+                        if (typeof i0 === "number") {
+                          d2 = i0 | 0;
+                          if (d2 < 0) {
+                            c2 += b0 * (a0 - 1);
+                            a0 = ceil(-a0 / d2);
+                          } else {
+                            a0 = ceil(a0 / d2);
+                          }
+                          b0 *= d2;
+                        }
+                        if (typeof i1 === "number") {
+                          d2 = i1 | 0;
+                          if (d2 < 0) {
+                            c2 += b1 * (a1 - 1);
+                            a1 = ceil(-a1 / d2);
+                          } else {
+                            a1 = ceil(a1 / d2);
+                          }
+                          b1 *= d2;
+                        }
+                        if (typeof i2 === "number") {
+                          d2 = i2 | 0;
+                          if (d2 < 0) {
+                            c2 += b2 * (a2 - 1);
+                            a2 = ceil(-a2 / d2);
+                          } else {
+                            a2 = ceil(a2 / d2);
+                          }
+                          b2 *= d2;
+                        }
+                        if (typeof i3 === "number") {
+                          d2 = i3 | 0;
+                          if (d2 < 0) {
+                            c2 += b3 * (a3 - 1);
+                            a3 = ceil(-a3 / d2);
+                          } else {
+                            a3 = ceil(a3 / d2);
+                          }
+                          b3 *= d2;
+                        }
+                        if (typeof i4 === "number") {
+                          d2 = i4 | 0;
+                          if (d2 < 0) {
+                            c2 += b4 * (a4 - 1);
+                            a4 = ceil(-a4 / d2);
+                          } else {
+                            a4 = ceil(a4 / d2);
+                          }
+                          b4 *= d2;
+                        }
+                        return new View2(this.data, a0, a1, a2, a3, a4, b0, b1, b2, b3, b4, c2);
+                      };
+                      proto.transpose = function transpose2(i0, i1, i2, i3, i4) {
+                        i0 = i0 === void 0 ? 0 : i0 | 0;
+                        i1 = i1 === void 0 ? 1 : i1 | 0;
+                        i2 = i2 === void 0 ? 2 : i2 | 0;
+                        i3 = i3 === void 0 ? 3 : i3 | 0;
+                        i4 = i4 === void 0 ? 4 : i4 | 0;
+                        var a2 = this.shape, b2 = this.stride;
+                        return new View2(this.data, a2[i0], a2[i1], a2[i2], a2[i3], a2[i4], b2[i0], b2[i1], b2[i2], b2[i3], b2[i4], this.offset);
+                      };
+                      proto.pick = function pick(i0, i1, i2, i3, i4) {
+                        var a2 = [], b2 = [], c2 = this.offset;
+                        if (typeof i0 === "number" && i0 >= 0) {
+                          c2 = c2 + this.stride[0] * i0 | 0;
+                        } else {
+                          a2.push(this.shape[0]);
+                          b2.push(this.stride[0]);
+                        }
+                        if (typeof i1 === "number" && i1 >= 0) {
+                          c2 = c2 + this.stride[1] * i1 | 0;
+                        } else {
+                          a2.push(this.shape[1]);
+                          b2.push(this.stride[1]);
+                        }
+                        if (typeof i2 === "number" && i2 >= 0) {
+                          c2 = c2 + this.stride[2] * i2 | 0;
+                        } else {
+                          a2.push(this.shape[2]);
+                          b2.push(this.stride[2]);
+                        }
+                        if (typeof i3 === "number" && i3 >= 0) {
+                          c2 = c2 + this.stride[3] * i3 | 0;
+                        } else {
+                          a2.push(this.shape[3]);
+                          b2.push(this.stride[3]);
+                        }
+                        if (typeof i4 === "number" && i4 >= 0) {
+                          c2 = c2 + this.stride[4] * i4 | 0;
+                        } else {
+                          a2.push(this.shape[4]);
+                          b2.push(this.stride[4]);
+                        }
+                        var ctor = CTOR_LIST[a2.length + 1];
+                        return ctor(this.data, a2, b2, c2);
+                      };
+                      return function construct(data, shape, stride, offset) {
+                        return new View2(
+                          data,
+                          shape[0],
+                          shape[1],
+                          shape[2],
+                          shape[3],
+                          shape[4],
+                          stride[0],
+                          stride[1],
+                          stride[2],
+                          stride[3],
+                          stride[4],
+                          offset
+                        );
+                      };
+                    }
+                  };
+                  function compileConstructor(inType, inDimension) {
+                    var dKey = inDimension === -1 ? "T" : String(inDimension);
+                    var procedure = allFns[dKey];
+                    if (inDimension === -1) {
+                      return procedure(inType);
+                    } else if (inDimension === 0) {
+                      return procedure(inType, CACHED_CONSTRUCTORS[inType][0]);
+                    }
+                    return procedure(inType, CACHED_CONSTRUCTORS[inType], order);
+                  }
+                  function arrayDType(data) {
+                    if (isBuffer2(data)) {
+                      return "buffer";
+                    }
+                    if (hasTypedArrays) {
+                      switch (Object.prototype.toString.call(data)) {
+                        case "[object Float64Array]":
+                          return "float64";
+                        case "[object Float32Array]":
+                          return "float32";
+                        case "[object Int8Array]":
+                          return "int8";
+                        case "[object Int16Array]":
+                          return "int16";
+                        case "[object Int32Array]":
+                          return "int32";
+                        case "[object Uint8ClampedArray]":
+                          return "uint8_clamped";
+                        case "[object Uint8Array]":
+                          return "uint8";
+                        case "[object Uint16Array]":
+                          return "uint16";
+                        case "[object Uint32Array]":
+                          return "uint32";
+                        case "[object BigInt64Array]":
+                          return "bigint64";
+                        case "[object BigUint64Array]":
+                          return "biguint64";
+                      }
+                    }
+                    if (Array.isArray(data)) {
+                      return "array";
+                    }
+                    return "generic";
+                  }
+                  var CACHED_CONSTRUCTORS = {
+                    "generic": [],
+                    "buffer": [],
+                    "array": [],
+                    // typed arrays
+                    "float32": [],
+                    "float64": [],
+                    "int8": [],
+                    "int16": [],
+                    "int32": [],
+                    "uint8_clamped": [],
+                    "uint8": [],
+                    "uint16": [],
+                    "uint32": [],
+                    "bigint64": [],
+                    "biguint64": []
+                  };
+                  function wrappedNDArrayCtor(data, shape, stride, offset) {
+                    if (data === void 0) {
+                      var ctor = CACHED_CONSTRUCTORS.array[0];
+                      return ctor([]);
+                    } else if (typeof data === "number") {
+                      data = [data];
+                    }
+                    if (shape === void 0) {
+                      shape = [data.length];
+                    }
+                    var d2 = shape.length;
+                    if (stride === void 0) {
+                      stride = new Array(d2);
+                      for (var i2 = d2 - 1, sz = 1; i2 >= 0; --i2) {
+                        stride[i2] = sz;
+                        sz *= shape[i2];
+                      }
+                    }
+                    if (offset === void 0) {
+                      offset = 0;
+                      for (var i2 = 0; i2 < d2; ++i2) {
+                        if (stride[i2] < 0) {
+                          offset -= (shape[i2] - 1) * stride[i2];
+                        }
+                      }
+                    }
+                    var inType = arrayDType(data);
+                    var ctor_list = CACHED_CONSTRUCTORS[inType];
+                    while (ctor_list.length <= d2 + 1) {
+                      ctor_list.push(compileConstructor(inType, ctor_list.length - 1));
+                    }
+                    var ctor = ctor_list[d2 + 1];
+                    return ctor(data, shape, stride, offset);
+                  }
+                  module22.exports = wrappedNDArrayCtor;
+                }
+              ),
+              /***/
+              9921: (
+                /***/
+                function(module22) {
+                  module22.exports = determinant2;
+                  function determinant2(a2) {
+                    var a00 = a2[0], a01 = a2[1], a02 = a2[2], a03 = a2[3], a10 = a2[4], a11 = a2[5], a12 = a2[6], a13 = a2[7], a20 = a2[8], a21 = a2[9], a22 = a2[10], a23 = a2[11], a30 = a2[12], a31 = a2[13], a32 = a2[14], a33 = a2[15], b00 = a00 * a11 - a01 * a10, b01 = a00 * a12 - a02 * a10, b02 = a00 * a13 - a03 * a10, b03 = a01 * a12 - a02 * a11, b04 = a01 * a13 - a03 * a11, b05 = a02 * a13 - a03 * a12, b06 = a20 * a31 - a21 * a30, b07 = a20 * a32 - a22 * a30, b08 = a20 * a33 - a23 * a30, b09 = a21 * a32 - a22 * a31, b10 = a21 * a33 - a23 * a31, b11 = a22 * a33 - a23 * a32;
+                    return b00 * b11 - b01 * b10 + b02 * b09 + b03 * b08 - b04 * b07 + b05 * b06;
+                  }
+                }
+              ),
+              /***/
+              9922: (
+                /***/
+                function(module22, __unused_webpack_exports, __webpack_require__2) {
+                  module22.exports = equals2;
+                  var EPSILON2 = __webpack_require__2(2613);
+                  function equals2(a2, b2) {
+                    var a0 = a2[0];
+                    var a1 = a2[1];
+                    var a22 = a2[2];
+                    var b0 = b2[0];
+                    var b1 = b2[1];
+                    var b22 = b2[2];
+                    return Math.abs(a0 - b0) <= EPSILON2 * Math.max(1, Math.abs(a0), Math.abs(b0)) && Math.abs(a1 - b1) <= EPSILON2 * Math.max(1, Math.abs(a1), Math.abs(b1)) && Math.abs(a22 - b22) <= EPSILON2 * Math.max(1, Math.abs(a22), Math.abs(b22));
+                  }
+                }
+              ),
+              /***/
+              9970: (
+                /***/
+                function(module22, __unused_webpack_exports, __webpack_require__2) {
+                  module22.exports = {
+                    create: __webpack_require__2(7536),
+                    clone: __webpack_require__2(2335),
+                    fromValues: __webpack_require__2(3390),
+                    copy: __webpack_require__2(2933),
+                    set: __webpack_require__2(4578),
+                    add: __webpack_require__2(4361),
+                    subtract: __webpack_require__2(6860),
+                    multiply: __webpack_require__2(3576),
+                    divide: __webpack_require__2(1373),
+                    min: __webpack_require__2(2334),
+                    max: __webpack_require__2(160),
+                    scale: __webpack_require__2(9288),
+                    scaleAndAdd: __webpack_require__2(4844),
+                    distance: __webpack_require__2(4691),
+                    squaredDistance: __webpack_require__2(7960),
+                    length: __webpack_require__2(6808),
+                    squaredLength: __webpack_require__2(483),
+                    negate: __webpack_require__2(1498),
+                    inverse: __webpack_require__2(4494),
+                    normalize: __webpack_require__2(5177),
+                    dot: __webpack_require__2(3750),
+                    lerp: __webpack_require__2(2573),
+                    random: __webpack_require__2(9131),
+                    transformMat4: __webpack_require__2(5352),
+                    transformQuat: __webpack_require__2(4041)
+                  };
+                }
+              ),
+              /***/
+              9977: (
+                /***/
+                function(module22, __unused_webpack_exports, __webpack_require__2) {
+                  module22.exports = createOrbitController;
+                  var filterVector = __webpack_require__2(9215);
+                  var lookAt2 = __webpack_require__2(6582);
+                  var mat4FromQuat = __webpack_require__2(7399);
+                  var invert44 = __webpack_require__2(7608);
+                  var quatFromFrame = __webpack_require__2(4081);
+                  function len3(x2, y2, z2) {
+                    return Math.sqrt(Math.pow(x2, 2) + Math.pow(y2, 2) + Math.pow(z2, 2));
+                  }
+                  function len4(w2, x2, y2, z2) {
+                    return Math.sqrt(Math.pow(w2, 2) + Math.pow(x2, 2) + Math.pow(y2, 2) + Math.pow(z2, 2));
+                  }
+                  function normalize4(out, a2) {
+                    var ax = a2[0];
+                    var ay = a2[1];
+                    var az = a2[2];
+                    var aw = a2[3];
+                    var al2 = len4(ax, ay, az, aw);
+                    if (al2 > 1e-6) {
+                      out[0] = ax / al2;
+                      out[1] = ay / al2;
+                      out[2] = az / al2;
+                      out[3] = aw / al2;
+                    } else {
+                      out[0] = out[1] = out[2] = 0;
+                      out[3] = 1;
+                    }
+                  }
+                  function OrbitCameraController(initQuat, initCenter, initRadius) {
+                    this.radius = filterVector([initRadius]);
+                    this.center = filterVector(initCenter);
+                    this.rotation = filterVector(initQuat);
+                    this.computedRadius = this.radius.curve(0);
+                    this.computedCenter = this.center.curve(0);
+                    this.computedRotation = this.rotation.curve(0);
+                    this.computedUp = [0.1, 0, 0];
+                    this.computedEye = [0.1, 0, 0];
+                    this.computedMatrix = [0.1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0];
+                    this.recalcMatrix(0);
+                  }
+                  var proto = OrbitCameraController.prototype;
+                  proto.lastT = function() {
+                    return Math.max(
+                      this.radius.lastT(),
+                      this.center.lastT(),
+                      this.rotation.lastT()
+                    );
+                  };
+                  proto.recalcMatrix = function(t4) {
+                    this.radius.curve(t4);
+                    this.center.curve(t4);
+                    this.rotation.curve(t4);
+                    var quat = this.computedRotation;
+                    normalize4(quat, quat);
+                    var mat = this.computedMatrix;
+                    mat4FromQuat(mat, quat);
+                    var center = this.computedCenter;
+                    var eye = this.computedEye;
+                    var up = this.computedUp;
+                    var radius = Math.exp(this.computedRadius[0]);
+                    eye[0] = center[0] + radius * mat[2];
+                    eye[1] = center[1] + radius * mat[6];
+                    eye[2] = center[2] + radius * mat[10];
+                    up[0] = mat[1];
+                    up[1] = mat[5];
+                    up[2] = mat[9];
+                    for (var i2 = 0; i2 < 3; ++i2) {
+                      var rr = 0;
+                      for (var j2 = 0; j2 < 3; ++j2) {
+                        rr += mat[i2 + 4 * j2] * eye[j2];
+                      }
+                      mat[12 + i2] = -rr;
+                    }
+                  };
+                  proto.getMatrix = function(t4, result) {
+                    this.recalcMatrix(t4);
+                    var m2 = this.computedMatrix;
+                    if (result) {
+                      for (var i2 = 0; i2 < 16; ++i2) {
+                        result[i2] = m2[i2];
+                      }
+                      return result;
+                    }
+                    return m2;
+                  };
+                  proto.idle = function(t4) {
+                    this.center.idle(t4);
+                    this.radius.idle(t4);
+                    this.rotation.idle(t4);
+                  };
+                  proto.flush = function(t4) {
+                    this.center.flush(t4);
+                    this.radius.flush(t4);
+                    this.rotation.flush(t4);
+                  };
+                  proto.pan = function(t4, dx, dy, dz) {
+                    dx = dx || 0;
+                    dy = dy || 0;
+                    dz = dz || 0;
+                    this.recalcMatrix(t4);
+                    var mat = this.computedMatrix;
+                    var ux = mat[1];
+                    var uy = mat[5];
+                    var uz = mat[9];
+                    var ul2 = len3(ux, uy, uz);
+                    ux /= ul2;
+                    uy /= ul2;
+                    uz /= ul2;
+                    var rx = mat[0];
+                    var ry = mat[4];
+                    var rz = mat[8];
+                    var ru = rx * ux + ry * uy + rz * uz;
+                    rx -= ux * ru;
+                    ry -= uy * ru;
+                    rz -= uz * ru;
+                    var rl2 = len3(rx, ry, rz);
+                    rx /= rl2;
+                    ry /= rl2;
+                    rz /= rl2;
+                    mat[2];
+                    mat[6];
+                    mat[10];
+                    var vx = rx * dx + ux * dy;
+                    var vy = ry * dx + uy * dy;
+                    var vz = rz * dx + uz * dy;
+                    this.center.move(t4, vx, vy, vz);
+                    var radius = Math.exp(this.computedRadius[0]);
+                    radius = Math.max(1e-4, radius + dz);
+                    this.radius.set(t4, Math.log(radius));
+                  };
+                  proto.rotate = function(t4, dx, dy, dz) {
+                    this.recalcMatrix(t4);
+                    dx = dx || 0;
+                    dy = dy || 0;
+                    var mat = this.computedMatrix;
+                    var rx = mat[0];
+                    var ry = mat[4];
+                    var rz = mat[8];
+                    var ux = mat[1];
+                    var uy = mat[5];
+                    var uz = mat[9];
+                    var fx = mat[2];
+                    var fy = mat[6];
+                    var fz = mat[10];
+                    var qx = dx * rx + dy * ux;
+                    var qy = dx * ry + dy * uy;
+                    var qz = dx * rz + dy * uz;
+                    var bx = -(fy * qz - fz * qy);
+                    var by = -(fz * qx - fx * qz);
+                    var bz = -(fx * qy - fy * qx);
+                    var bw = Math.sqrt(Math.max(0, 1 - Math.pow(bx, 2) - Math.pow(by, 2) - Math.pow(bz, 2)));
+                    var bl2 = len4(bx, by, bz, bw);
+                    if (bl2 > 1e-6) {
+                      bx /= bl2;
+                      by /= bl2;
+                      bz /= bl2;
+                      bw /= bl2;
+                    } else {
+                      bx = by = bz = 0;
+                      bw = 1;
+                    }
+                    var rotation = this.computedRotation;
+                    var ax = rotation[0];
+                    var ay = rotation[1];
+                    var az = rotation[2];
+                    var aw = rotation[3];
+                    var cx = ax * bw + aw * bx + ay * bz - az * by;
+                    var cy = ay * bw + aw * by + az * bx - ax * bz;
+                    var cz = az * bw + aw * bz + ax * by - ay * bx;
+                    var cw = aw * bw - ax * bx - ay * by - az * bz;
+                    if (dz) {
+                      bx = fx;
+                      by = fy;
+                      bz = fz;
+                      var s2 = Math.sin(dz) / len3(bx, by, bz);
+                      bx *= s2;
+                      by *= s2;
+                      bz *= s2;
+                      bw = Math.cos(dx);
+                      cx = cx * bw + cw * bx + cy * bz - cz * by;
+                      cy = cy * bw + cw * by + cz * bx - cx * bz;
+                      cz = cz * bw + cw * bz + cx * by - cy * bx;
+                      cw = cw * bw - cx * bx - cy * by - cz * bz;
+                    }
+                    var cl2 = len4(cx, cy, cz, cw);
+                    if (cl2 > 1e-6) {
+                      cx /= cl2;
+                      cy /= cl2;
+                      cz /= cl2;
+                      cw /= cl2;
+                    } else {
+                      cx = cy = cz = 0;
+                      cw = 1;
+                    }
+                    this.rotation.set(t4, cx, cy, cz, cw);
+                  };
+                  proto.lookAt = function(t4, eye, center, up) {
+                    this.recalcMatrix(t4);
+                    center = center || this.computedCenter;
+                    eye = eye || this.computedEye;
+                    up = up || this.computedUp;
+                    var mat = this.computedMatrix;
+                    lookAt2(mat, eye, center, up);
+                    var rotation = this.computedRotation;
+                    quatFromFrame(
+                      rotation,
+                      mat[0],
+                      mat[1],
+                      mat[2],
+                      mat[4],
+                      mat[5],
+                      mat[6],
+                      mat[8],
+                      mat[9],
+                      mat[10]
+                    );
+                    normalize4(rotation, rotation);
+                    this.rotation.set(t4, rotation[0], rotation[1], rotation[2], rotation[3]);
+                    var fl2 = 0;
+                    for (var i2 = 0; i2 < 3; ++i2) {
+                      fl2 += Math.pow(center[i2] - eye[i2], 2);
+                    }
+                    this.radius.set(t4, 0.5 * Math.log(Math.max(fl2, 1e-6)));
+                    this.center.set(t4, center[0], center[1], center[2]);
+                  };
+                  proto.translate = function(t4, dx, dy, dz) {
+                    this.center.move(
+                      t4,
+                      dx || 0,
+                      dy || 0,
+                      dz || 0
+                    );
+                  };
+                  proto.setMatrix = function(t4, matrix) {
+                    var rotation = this.computedRotation;
+                    quatFromFrame(
+                      rotation,
+                      matrix[0],
+                      matrix[1],
+                      matrix[2],
+                      matrix[4],
+                      matrix[5],
+                      matrix[6],
+                      matrix[8],
+                      matrix[9],
+                      matrix[10]
+                    );
+                    normalize4(rotation, rotation);
+                    this.rotation.set(t4, rotation[0], rotation[1], rotation[2], rotation[3]);
+                    var mat = this.computedMatrix;
+                    invert44(mat, matrix);
+                    var w2 = mat[15];
+                    if (Math.abs(w2) > 1e-6) {
+                      var cx = mat[12] / w2;
+                      var cy = mat[13] / w2;
+                      var cz = mat[14] / w2;
+                      this.recalcMatrix(t4);
+                      var r2 = Math.exp(this.computedRadius[0]);
+                      this.center.set(t4, cx - mat[2] * r2, cy - mat[6] * r2, cz - mat[10] * r2);
+                      this.radius.idle(t4);
+                    } else {
+                      this.center.idle(t4);
+                      this.radius.idle(t4);
+                    }
+                  };
+                  proto.setDistance = function(t4, d2) {
+                    if (d2 > 0) {
+                      this.radius.set(t4, Math.log(d2));
+                    }
+                  };
+                  proto.setDistanceLimits = function(lo, hi2) {
+                    if (lo > 0) {
+                      lo = Math.log(lo);
+                    } else {
+                      lo = -Infinity;
+                    }
+                    if (hi2 > 0) {
+                      hi2 = Math.log(hi2);
+                    } else {
+                      hi2 = Infinity;
+                    }
+                    hi2 = Math.max(hi2, lo);
+                    this.radius.bounds[0][0] = lo;
+                    this.radius.bounds[1][0] = hi2;
+                  };
+                  proto.getDistanceLimits = function(out) {
+                    var bounds = this.radius.bounds;
+                    if (out) {
+                      out[0] = Math.exp(bounds[0][0]);
+                      out[1] = Math.exp(bounds[1][0]);
+                      return out;
+                    }
+                    return [Math.exp(bounds[0][0]), Math.exp(bounds[1][0])];
+                  };
+                  proto.toJSON = function() {
+                    this.recalcMatrix(this.lastT());
+                    return {
+                      center: this.computedCenter.slice(),
+                      rotation: this.computedRotation.slice(),
+                      distance: Math.log(this.computedRadius[0]),
+                      zoomMin: this.radius.bounds[0][0],
+                      zoomMax: this.radius.bounds[1][0]
+                    };
+                  };
+                  proto.fromJSON = function(options) {
+                    var t4 = this.lastT();
+                    var c2 = options.center;
+                    if (c2) {
+                      this.center.set(t4, c2[0], c2[1], c2[2]);
+                    }
+                    var r2 = options.rotation;
+                    if (r2) {
+                      this.rotation.set(t4, r2[0], r2[1], r2[2], r2[3]);
+                    }
+                    var d2 = options.distance;
+                    if (d2 && d2 > 0) {
+                      this.radius.set(t4, Math.log(d2));
+                    }
+                    this.setDistanceLimits(options.zoomMin, options.zoomMax);
+                  };
+                  function createOrbitController(options) {
+                    options = options || {};
+                    var center = options.center || [0, 0, 0];
+                    var rotation = options.rotation || [0, 0, 0, 1];
+                    var radius = options.radius || 1;
+                    center = [].slice.call(center, 0, 3);
+                    rotation = [].slice.call(rotation, 0, 4);
+                    normalize4(rotation, rotation);
+                    var result = new OrbitCameraController(
+                      rotation,
+                      center,
+                      Math.log(radius)
+                    );
+                    result.setDistanceLimits(options.zoomMin, options.zoomMax);
+                    if ("eye" in options || "up" in options) {
+                      result.lookAt(0, options.eye, options.center, options.up);
+                    }
+                    return result;
+                  }
+                }
+              ),
+              /***/
+              9994: (
+                /***/
+                function(module22, __unused_webpack_exports, __webpack_require__2) {
+                  var ndarray = __webpack_require__2(9618);
+                  var do_convert = __webpack_require__2(8277);
+                  module22.exports = function convert(arr, result) {
+                    var shape = [], c2 = arr, sz = 1;
+                    while (Array.isArray(c2)) {
+                      shape.push(c2.length);
+                      sz *= c2.length;
+                      c2 = c2[0];
+                    }
+                    if (shape.length === 0) {
+                      return ndarray();
+                    }
+                    if (!result) {
+                      result = ndarray(new Float64Array(sz), shape);
+                    }
+                    do_convert(result, arr);
+                    return result;
+                  };
+                }
+              )
+              /******/
+            };
+            var __webpack_module_cache__ = {};
+            function __webpack_require__(moduleId) {
+              var cachedModule = __webpack_module_cache__[moduleId];
+              if (cachedModule !== void 0) {
+                return cachedModule.exports;
+              }
+              var module22 = __webpack_module_cache__[moduleId] = {
+                /******/
+                id: moduleId,
+                /******/
+                loaded: false,
+                /******/
+                exports: {}
+                /******/
+              };
+              __webpack_modules__[moduleId].call(module22.exports, module22, module22.exports, __webpack_require__);
+              module22.loaded = true;
+              return module22.exports;
+            }
+            !function() {
+              __webpack_require__.g = function() {
+                if (typeof globalThis === "object") return globalThis;
+                try {
+                  return this || new Function("return this")();
+                } catch (e2) {
+                  if (typeof window === "object") return window;
+                }
+              }();
+            }();
+            !function() {
+              __webpack_require__.nmd = function(module22) {
+                module22.paths = [];
+                if (!module22.children) module22.children = [];
+                return module22;
+              };
+            }();
+            var __webpack_exports__ = __webpack_require__(1964);
+            module2.exports = __webpack_exports__;
+          })();
         }
-      },
-      _initPanes: function() {
-        var panes = this._panes = {};
-        this._paneRenderers = {};
-        this._mapPane = this.createPane("mapPane", this._container);
-        setPosition(this._mapPane, new Point(0, 0));
-        this.createPane("tilePane");
-        this.createPane("overlayPane");
-        this.createPane("shadowPane");
-        this.createPane("markerPane");
-        this.createPane("tooltipPane");
-        this.createPane("popupPane");
-        if (!this.options.markerZoomAnimation) {
-          addClass(panes.markerPane, "leaflet-zoom-hide");
-          addClass(panes.shadowPane, "leaflet-zoom-hide");
+      });
+      var require_color_name = __commonJS({
+        "node_modules/color-name/index.js"(exports, module2) {
+          module2.exports = {
+            "aliceblue": [240, 248, 255],
+            "antiquewhite": [250, 235, 215],
+            "aqua": [0, 255, 255],
+            "aquamarine": [127, 255, 212],
+            "azure": [240, 255, 255],
+            "beige": [245, 245, 220],
+            "bisque": [255, 228, 196],
+            "black": [0, 0, 0],
+            "blanchedalmond": [255, 235, 205],
+            "blue": [0, 0, 255],
+            "blueviolet": [138, 43, 226],
+            "brown": [165, 42, 42],
+            "burlywood": [222, 184, 135],
+            "cadetblue": [95, 158, 160],
+            "chartreuse": [127, 255, 0],
+            "chocolate": [210, 105, 30],
+            "coral": [255, 127, 80],
+            "cornflowerblue": [100, 149, 237],
+            "cornsilk": [255, 248, 220],
+            "crimson": [220, 20, 60],
+            "cyan": [0, 255, 255],
+            "darkblue": [0, 0, 139],
+            "darkcyan": [0, 139, 139],
+            "darkgoldenrod": [184, 134, 11],
+            "darkgray": [169, 169, 169],
+            "darkgreen": [0, 100, 0],
+            "darkgrey": [169, 169, 169],
+            "darkkhaki": [189, 183, 107],
+            "darkmagenta": [139, 0, 139],
+            "darkolivegreen": [85, 107, 47],
+            "darkorange": [255, 140, 0],
+            "darkorchid": [153, 50, 204],
+            "darkred": [139, 0, 0],
+            "darksalmon": [233, 150, 122],
+            "darkseagreen": [143, 188, 143],
+            "darkslateblue": [72, 61, 139],
+            "darkslategray": [47, 79, 79],
+            "darkslategrey": [47, 79, 79],
+            "darkturquoise": [0, 206, 209],
+            "darkviolet": [148, 0, 211],
+            "deeppink": [255, 20, 147],
+            "deepskyblue": [0, 191, 255],
+            "dimgray": [105, 105, 105],
+            "dimgrey": [105, 105, 105],
+            "dodgerblue": [30, 144, 255],
+            "firebrick": [178, 34, 34],
+            "floralwhite": [255, 250, 240],
+            "forestgreen": [34, 139, 34],
+            "fuchsia": [255, 0, 255],
+            "gainsboro": [220, 220, 220],
+            "ghostwhite": [248, 248, 255],
+            "gold": [255, 215, 0],
+            "goldenrod": [218, 165, 32],
+            "gray": [128, 128, 128],
+            "green": [0, 128, 0],
+            "greenyellow": [173, 255, 47],
+            "grey": [128, 128, 128],
+            "honeydew": [240, 255, 240],
+            "hotpink": [255, 105, 180],
+            "indianred": [205, 92, 92],
+            "indigo": [75, 0, 130],
+            "ivory": [255, 255, 240],
+            "khaki": [240, 230, 140],
+            "lavender": [230, 230, 250],
+            "lavenderblush": [255, 240, 245],
+            "lawngreen": [124, 252, 0],
+            "lemonchiffon": [255, 250, 205],
+            "lightblue": [173, 216, 230],
+            "lightcoral": [240, 128, 128],
+            "lightcyan": [224, 255, 255],
+            "lightgoldenrodyellow": [250, 250, 210],
+            "lightgray": [211, 211, 211],
+            "lightgreen": [144, 238, 144],
+            "lightgrey": [211, 211, 211],
+            "lightpink": [255, 182, 193],
+            "lightsalmon": [255, 160, 122],
+            "lightseagreen": [32, 178, 170],
+            "lightskyblue": [135, 206, 250],
+            "lightslategray": [119, 136, 153],
+            "lightslategrey": [119, 136, 153],
+            "lightsteelblue": [176, 196, 222],
+            "lightyellow": [255, 255, 224],
+            "lime": [0, 255, 0],
+            "limegreen": [50, 205, 50],
+            "linen": [250, 240, 230],
+            "magenta": [255, 0, 255],
+            "maroon": [128, 0, 0],
+            "mediumaquamarine": [102, 205, 170],
+            "mediumblue": [0, 0, 205],
+            "mediumorchid": [186, 85, 211],
+            "mediumpurple": [147, 112, 219],
+            "mediumseagreen": [60, 179, 113],
+            "mediumslateblue": [123, 104, 238],
+            "mediumspringgreen": [0, 250, 154],
+            "mediumturquoise": [72, 209, 204],
+            "mediumvioletred": [199, 21, 133],
+            "midnightblue": [25, 25, 112],
+            "mintcream": [245, 255, 250],
+            "mistyrose": [255, 228, 225],
+            "moccasin": [255, 228, 181],
+            "navajowhite": [255, 222, 173],
+            "navy": [0, 0, 128],
+            "oldlace": [253, 245, 230],
+            "olive": [128, 128, 0],
+            "olivedrab": [107, 142, 35],
+            "orange": [255, 165, 0],
+            "orangered": [255, 69, 0],
+            "orchid": [218, 112, 214],
+            "palegoldenrod": [238, 232, 170],
+            "palegreen": [152, 251, 152],
+            "paleturquoise": [175, 238, 238],
+            "palevioletred": [219, 112, 147],
+            "papayawhip": [255, 239, 213],
+            "peachpuff": [255, 218, 185],
+            "peru": [205, 133, 63],
+            "pink": [255, 192, 203],
+            "plum": [221, 160, 221],
+            "powderblue": [176, 224, 230],
+            "purple": [128, 0, 128],
+            "rebeccapurple": [102, 51, 153],
+            "red": [255, 0, 0],
+            "rosybrown": [188, 143, 143],
+            "royalblue": [65, 105, 225],
+            "saddlebrown": [139, 69, 19],
+            "salmon": [250, 128, 114],
+            "sandybrown": [244, 164, 96],
+            "seagreen": [46, 139, 87],
+            "seashell": [255, 245, 238],
+            "sienna": [160, 82, 45],
+            "silver": [192, 192, 192],
+            "skyblue": [135, 206, 235],
+            "slateblue": [106, 90, 205],
+            "slategray": [112, 128, 144],
+            "slategrey": [112, 128, 144],
+            "snow": [255, 250, 250],
+            "springgreen": [0, 255, 127],
+            "steelblue": [70, 130, 180],
+            "tan": [210, 180, 140],
+            "teal": [0, 128, 128],
+            "thistle": [216, 191, 216],
+            "tomato": [255, 99, 71],
+            "turquoise": [64, 224, 208],
+            "violet": [238, 130, 238],
+            "wheat": [245, 222, 179],
+            "white": [255, 255, 255],
+            "whitesmoke": [245, 245, 245],
+            "yellow": [255, 255, 0],
+            "yellowgreen": [154, 205, 50]
+          };
+        }
+      });
+      var require_color_parse = __commonJS({
+        "node_modules/color-normalize/node_modules/color-parse/index.js"(exports, module2) {
+          var names2 = require_color_name();
+          module2.exports = parse22;
+          var baseHues2 = {
+            red: 0,
+            orange: 60,
+            yellow: 120,
+            green: 180,
+            blue: 240,
+            purple: 300
+          };
+          function parse22(cstr) {
+            var m2, parts = [], alpha = 1, space;
+            if (typeof cstr === "string") {
+              cstr = cstr.toLowerCase();
+              if (names2[cstr]) {
+                parts = names2[cstr].slice();
+                space = "rgb";
+              } else if (cstr === "transparent") {
+                alpha = 0;
+                space = "rgb";
+                parts = [0, 0, 0];
+              } else if (/^#[A-Fa-f0-9]+$/.test(cstr)) {
+                var base = cstr.slice(1);
+                var size = base.length;
+                var isShort = size <= 4;
+                alpha = 1;
+                if (isShort) {
+                  parts = [
+                    parseInt(base[0] + base[0], 16),
+                    parseInt(base[1] + base[1], 16),
+                    parseInt(base[2] + base[2], 16)
+                  ];
+                  if (size === 4) {
+                    alpha = parseInt(base[3] + base[3], 16) / 255;
+                  }
+                } else {
+                  parts = [
+                    parseInt(base[0] + base[1], 16),
+                    parseInt(base[2] + base[3], 16),
+                    parseInt(base[4] + base[5], 16)
+                  ];
+                  if (size === 8) {
+                    alpha = parseInt(base[6] + base[7], 16) / 255;
+                  }
+                }
+                if (!parts[0]) parts[0] = 0;
+                if (!parts[1]) parts[1] = 0;
+                if (!parts[2]) parts[2] = 0;
+                space = "rgb";
+              } else if (m2 = /^((?:rgb|hs[lvb]|hwb|cmyk?|xy[zy]|gray|lab|lchu?v?|[ly]uv|lms)a?)\s*\(([^\)]*)\)/.exec(cstr)) {
+                var name2 = m2[1];
+                var isRGB = name2 === "rgb";
+                var base = name2.replace(/a$/, "");
+                space = base;
+                var size = base === "cmyk" ? 4 : base === "gray" ? 1 : 3;
+                parts = m2[2].trim().split(/\s*[,\/]\s*|\s+/).map(function(x2, i2) {
+                  if (/%$/.test(x2)) {
+                    if (i2 === size) return parseFloat(x2) / 100;
+                    if (base === "rgb") return parseFloat(x2) * 255 / 100;
+                    return parseFloat(x2);
+                  } else if (base[i2] === "h") {
+                    if (/deg$/.test(x2)) {
+                      return parseFloat(x2);
+                    } else if (baseHues2[x2] !== void 0) {
+                      return baseHues2[x2];
+                    }
+                  }
+                  return parseFloat(x2);
+                });
+                if (name2 === base) parts.push(1);
+                alpha = isRGB ? 1 : parts[size] === void 0 ? 1 : parts[size];
+                parts = parts.slice(0, size);
+              } else if (cstr.length > 10 && /[0-9](?:\s|\/)/.test(cstr)) {
+                parts = cstr.match(/([0-9]+)/g).map(function(value) {
+                  return parseFloat(value);
+                });
+                space = cstr.match(/([a-z])/ig).join("").toLowerCase();
+              }
+            } else if (!isNaN(cstr)) {
+              space = "rgb";
+              parts = [cstr >>> 16, (cstr & 65280) >>> 8, cstr & 255];
+            } else if (Array.isArray(cstr) || cstr.length) {
+              parts = [cstr[0], cstr[1], cstr[2]];
+              space = "rgb";
+              alpha = cstr.length === 4 ? cstr[3] : 1;
+            } else if (cstr instanceof Object) {
+              if (cstr.r != null || cstr.red != null || cstr.R != null) {
+                space = "rgb";
+                parts = [
+                  cstr.r || cstr.red || cstr.R || 0,
+                  cstr.g || cstr.green || cstr.G || 0,
+                  cstr.b || cstr.blue || cstr.B || 0
+                ];
+              } else {
+                space = "hsl";
+                parts = [
+                  cstr.h || cstr.hue || cstr.H || 0,
+                  cstr.s || cstr.saturation || cstr.S || 0,
+                  cstr.l || cstr.lightness || cstr.L || cstr.b || cstr.brightness
+                ];
+              }
+              alpha = cstr.a || cstr.alpha || cstr.opacity || 1;
+              if (cstr.opacity != null) alpha /= 100;
+            }
+            return {
+              space,
+              values: parts,
+              alpha
+            };
+          }
         }
-      },
-      // private methods that modify map state
-      // @section Map state change events
-      _resetView: function(center, zoom2, noMoveStart) {
-        setPosition(this._mapPane, new Point(0, 0));
-        var loading = !this._loaded;
-        this._loaded = true;
-        zoom2 = this._limitZoom(zoom2);
-        this.fire("viewprereset");
-        var zoomChanged = this._zoom !== zoom2;
-        this._moveStart(zoomChanged, noMoveStart)._move(center, zoom2)._moveEnd(zoomChanged);
-        this.fire("viewreset");
-        if (loading) {
-          this.fire("load");
+      });
+      var require_color_rgba = __commonJS({
+        "node_modules/color-normalize/node_modules/color-rgba/index.js"(exports, module2) {
+          var parse22 = require_color_parse();
+          module2.exports = function rgba3(color22) {
+            if (Array.isArray(color22) && color22.raw) color22 = String.raw.apply(null, arguments);
+            var values;
+            var parsed = parse22(color22);
+            if (!parsed.space) return [];
+            var min = [0, 0, 0], max = parsed.space[0] === "h" ? [360, 100, 100] : [255, 255, 255];
+            values = Array(3);
+            values[0] = Math.min(Math.max(parsed.values[0], min[0]), max[0]);
+            values[1] = Math.min(Math.max(parsed.values[1], min[1]), max[1]);
+            values[2] = Math.min(Math.max(parsed.values[2], min[2]), max[2]);
+            if (parsed.space[0] === "h") values = hsl2rgb2(values);
+            values.push(Math.min(Math.max(parsed.alpha, 0), 1));
+            return values;
+          };
+          function hsl2rgb2(hsl3) {
+            var h2 = hsl3[0] / 360, s2 = hsl3[1] / 100, l2 = hsl3[2] / 100, t12, t22, t32, rgb2, val, i2 = 0;
+            if (s2 === 0) return val = l2 * 255, [val, val, val];
+            t22 = l2 < 0.5 ? l2 * (1 + s2) : l2 + s2 - l2 * s2;
+            t12 = 2 * l2 - t22;
+            rgb2 = [0, 0, 0];
+            for (; i2 < 3; ) {
+              t32 = h2 + 1 / 3 * -(i2 - 1);
+              t32 < 0 ? t32++ : t32 > 1 && t32--;
+              val = 6 * t32 < 1 ? t12 + (t22 - t12) * 6 * t32 : 2 * t32 < 1 ? t22 : 3 * t32 < 2 ? t12 + (t22 - t12) * (2 / 3 - t32) * 6 : t12;
+              rgb2[i2++] = val * 255;
+            }
+            return rgb2;
+          }
         }
-      },
-      _moveStart: function(zoomChanged, noMoveStart) {
-        if (zoomChanged) {
-          this.fire("zoomstart");
+      });
+      var require_clamp = __commonJS({
+        "node_modules/clamp/index.js"(exports, module2) {
+          module2.exports = clamp2;
+          function clamp2(value, min, max) {
+            return min < max ? value < min ? min : value > max ? max : value : value < max ? max : value > min ? min : value;
+          }
         }
-        if (!noMoveStart) {
-          this.fire("movestart");
+      });
+      var require_dtype = __commonJS({
+        "node_modules/dtype/index.js"(exports, module2) {
+          module2.exports = function(dtype) {
+            switch (dtype) {
+              case "int8":
+                return Int8Array;
+              case "int16":
+                return Int16Array;
+              case "int32":
+                return Int32Array;
+              case "uint8":
+                return Uint8Array;
+              case "uint16":
+                return Uint16Array;
+              case "uint32":
+                return Uint32Array;
+              case "float32":
+                return Float32Array;
+              case "float64":
+                return Float64Array;
+              case "array":
+                return Array;
+              case "uint8_clamped":
+                return Uint8ClampedArray;
+            }
+          };
         }
-        return this;
-      },
-      _move: function(center, zoom2, data, supressEvent) {
-        if (zoom2 === void 0) {
-          zoom2 = this._zoom;
-        }
-        var zoomChanged = this._zoom !== zoom2;
-        this._zoom = zoom2;
-        this._lastCenter = center;
-        this._pixelOrigin = this._getNewPixelOrigin(center);
-        if (!supressEvent) {
-          if (zoomChanged || data && data.pinch) {
-            this.fire("zoom", data);
-          }
-          this.fire("move", data);
-        } else if (data && data.pinch) {
-          this.fire("zoom", data);
-        }
-        return this;
-      },
-      _moveEnd: function(zoomChanged) {
-        if (zoomChanged) {
-          this.fire("zoomend");
+      });
+      var require_color_normalize = __commonJS({
+        "node_modules/color-normalize/index.js"(exports, module2) {
+          var rgba3 = require_color_rgba();
+          var clamp2 = require_clamp();
+          var dtype = require_dtype();
+          module2.exports = function normalize(color22, type) {
+            if (type === "float" || !type) type = "array";
+            if (type === "uint") type = "uint8";
+            if (type === "uint_clamped") type = "uint8_clamped";
+            var Ctor = dtype(type);
+            var output = new Ctor(4);
+            var normalize2 = type !== "uint8" && type !== "uint8_clamped";
+            if (!color22.length || typeof color22 === "string") {
+              color22 = rgba3(color22);
+              color22[0] /= 255;
+              color22[1] /= 255;
+              color22[2] /= 255;
+            }
+            if (isInt(color22)) {
+              output[0] = color22[0];
+              output[1] = color22[1];
+              output[2] = color22[2];
+              output[3] = color22[3] != null ? color22[3] : 255;
+              if (normalize2) {
+                output[0] /= 255;
+                output[1] /= 255;
+                output[2] /= 255;
+                output[3] /= 255;
+              }
+              return output;
+            }
+            if (!normalize2) {
+              output[0] = clamp2(Math.floor(color22[0] * 255), 0, 255);
+              output[1] = clamp2(Math.floor(color22[1] * 255), 0, 255);
+              output[2] = clamp2(Math.floor(color22[2] * 255), 0, 255);
+              output[3] = color22[3] == null ? 255 : clamp2(Math.floor(color22[3] * 255), 0, 255);
+            } else {
+              output[0] = color22[0];
+              output[1] = color22[1];
+              output[2] = color22[2];
+              output[3] = color22[3] != null ? color22[3] : 1;
+            }
+            return output;
+          };
+          function isInt(color22) {
+            if (color22 instanceof Uint8Array || color22 instanceof Uint8ClampedArray) return true;
+            if (Array.isArray(color22) && (color22[0] > 1 || color22[0] === 0) && (color22[1] > 1 || color22[1] === 0) && (color22[2] > 1 || color22[2] === 0) && (!color22[3] || color22[3] > 1)) return true;
+            return false;
+          }
         }
-        return this.fire("moveend");
-      },
-      _stop: function() {
-        cancelAnimFrame(this._flyToFrame);
-        if (this._panAnim) {
-          this._panAnim.stop();
+      });
+      var require_str2rgbarray = __commonJS({
+        "src/lib/str2rgbarray.js"(exports, module2) {
+          var rgba3 = require_color_normalize();
+          function str2RgbaArray(color22) {
+            if (!color22) return [0, 0, 0, 1];
+            return rgba3(color22);
+          }
+          module2.exports = str2RgbaArray;
         }
-        return this;
-      },
-      _rawPanBy: function(offset) {
-        setPosition(this._mapPane, this._getMapPanePos().subtract(offset));
-      },
-      _getZoomSpan: function() {
-        return this.getMaxZoom() - this.getMinZoom();
-      },
-      _panInsideMaxBounds: function() {
-        if (!this._enforcingBounds) {
-          this.panInsideBounds(this.options.maxBounds);
+      });
+      var require_gl_format_color = __commonJS({
+        "src/lib/gl_format_color.js"(exports, module2) {
+          var isNumeric = require_fast_isnumeric();
+          var tinycolor = require_tinycolor();
+          var rgba3 = require_color_normalize();
+          var Colorscale = require_colorscale();
+          var colorDflt = require_attributes3().defaultLine;
+          var isArrayOrTypedArray = require_array().isArrayOrTypedArray;
+          var colorDfltRgba = rgba3(colorDflt);
+          var opacityDflt = 1;
+          function calculateColor(colorIn, opacityIn) {
+            var colorOut = colorIn;
+            colorOut[3] *= opacityIn;
+            return colorOut;
+          }
+          function validateColor(colorIn) {
+            if (isNumeric(colorIn)) return colorDfltRgba;
+            var colorOut = rgba3(colorIn);
+            return colorOut.length ? colorOut : colorDfltRgba;
+          }
+          function validateOpacity(opacityIn) {
+            return isNumeric(opacityIn) ? opacityIn : opacityDflt;
+          }
+          function formatColor(containerIn, opacityIn, len2) {
+            var colorIn = containerIn.color;
+            if (colorIn && colorIn._inputArray) colorIn = colorIn._inputArray;
+            var isArrayColorIn = isArrayOrTypedArray(colorIn);
+            var isArrayOpacityIn = isArrayOrTypedArray(opacityIn);
+            var cOpts = Colorscale.extractOpts(containerIn);
+            var colorOut = [];
+            var sclFunc, getColor2, getOpacity, colori, opacityi;
+            if (cOpts.colorscale !== void 0) {
+              sclFunc = Colorscale.makeColorScaleFuncFromTrace(containerIn);
+            } else {
+              sclFunc = validateColor;
+            }
+            if (isArrayColorIn) {
+              getColor2 = function(c2, i22) {
+                return c2[i22] === void 0 ? colorDfltRgba : rgba3(sclFunc(c2[i22]));
+              };
+            } else getColor2 = validateColor;
+            if (isArrayOpacityIn) {
+              getOpacity = function(o2, i22) {
+                return o2[i22] === void 0 ? opacityDflt : validateOpacity(o2[i22]);
+              };
+            } else getOpacity = validateOpacity;
+            if (isArrayColorIn || isArrayOpacityIn) {
+              for (var i2 = 0; i2 < len2; i2++) {
+                colori = getColor2(colorIn, i2);
+                opacityi = getOpacity(opacityIn, i2);
+                colorOut[i2] = calculateColor(colori, opacityi);
+              }
+            } else colorOut = calculateColor(rgba3(colorIn), opacityIn);
+            return colorOut;
+          }
+          function parseColorScale(cont) {
+            var cOpts = Colorscale.extractOpts(cont);
+            var colorscale = cOpts.colorscale;
+            if (cOpts.reversescale) colorscale = Colorscale.flipScale(cOpts.colorscale);
+            return colorscale.map(function(elem) {
+              var index = elem[0];
+              var color22 = tinycolor(elem[1]);
+              var rgb2 = color22.toRgb();
+              return {
+                index,
+                rgb: [rgb2.r, rgb2.g, rgb2.b, rgb2.a]
+              };
+            });
+          }
+          module2.exports = {
+            formatColor,
+            parseColorScale
+          };
         }
-      },
-      _checkIfLoaded: function() {
-        if (!this._loaded) {
-          throw new Error("Set map center and zoom first.");
+      });
+      var require_gl3d_dashes = __commonJS({
+        "src/constants/gl3d_dashes.js"(exports, module2) {
+          module2.exports = {
+            solid: [[], 0],
+            dot: [[0.5, 1], 200],
+            dash: [[0.5, 1], 50],
+            longdash: [[0.5, 1], 10],
+            dashdot: [[0.5, 0.625, 0.875, 1], 50],
+            longdashdot: [[0.5, 0.7, 0.8, 1], 10]
+          };
         }
-      },
-      // DOM event handling
-      // @section Interaction events
-      _initEvents: function(remove2) {
-        this._targets = {};
-        this._targets[stamp(this._container)] = this;
-        var onOff = remove2 ? off : on;
-        onOff(this._container, "click dblclick mousedown mouseup mouseover mouseout mousemove contextmenu keypress keydown keyup", this._handleDOMEvent, this);
-        if (this.options.trackResize) {
-          onOff(window, "resize", this._onResize, this);
-        }
-        if (Browser.any3d && this.options.transform3DLimit) {
-          (remove2 ? this.off : this.on).call(this, "moveend", this._onMoveEnd);
+      });
+      var require_gl3d_markers = __commonJS({
+        "src/constants/gl3d_markers.js"(exports, module2) {
+          module2.exports = {
+            circle: "●",
+            "circle-open": "○",
+            square: "■",
+            "square-open": "□",
+            diamond: "◆",
+            "diamond-open": "◇",
+            cross: "+",
+            x: "❌"
+          };
         }
-      },
-      _onResize: function() {
-        cancelAnimFrame(this._resizeRequest);
-        this._resizeRequest = requestAnimFrame2(
-          function() {
-            this.invalidateSize({ debounceMoveend: true });
-          },
-          this
-        );
-      },
-      _onScroll: function() {
-        this._container.scrollTop = 0;
-        this._container.scrollLeft = 0;
-      },
-      _onMoveEnd: function() {
-        var pos = this._getMapPanePos();
-        if (Math.max(Math.abs(pos.x), Math.abs(pos.y)) >= this.options.transform3DLimit) {
-          this._resetView(this.getCenter(), this.getZoom());
+      });
+      var require_calc_errors = __commonJS({
+        "src/traces/scatter3d/calc_errors.js"(exports, module2) {
+          var Registry = require_registry();
+          function calculateAxisErrors(data, params, scaleFactor, axis) {
+            if (!params || !params.visible) return null;
+            var computeError = Registry.getComponentMethod("errorbars", "makeComputeError")(params);
+            var result = new Array(data.length);
+            for (var i2 = 0; i2 < data.length; i2++) {
+              var errors = computeError(+data[i2], i2);
+              if (axis.type === "log") {
+                var point = axis.c2l(data[i2]);
+                var min = data[i2] - errors[0];
+                var max = data[i2] + errors[1];
+                result[i2] = [
+                  (axis.c2l(min, true) - point) * scaleFactor,
+                  (axis.c2l(max, true) - point) * scaleFactor
+                ];
+                if (min > 0) {
+                  var lower = axis.c2l(min);
+                  if (!axis._lowerLogErrorBound) axis._lowerLogErrorBound = lower;
+                  axis._lowerErrorBound = Math.min(axis._lowerLogErrorBound, lower);
+                }
+              } else {
+                result[i2] = [
+                  -errors[0] * scaleFactor,
+                  errors[1] * scaleFactor
+                ];
+              }
+            }
+            return result;
+          }
+          function dataLength(array) {
+            for (var i2 = 0; i2 < array.length; i2++) {
+              if (array[i2]) return array[i2].length;
+            }
+            return 0;
+          }
+          function calculateErrors(data, scaleFactor, sceneLayout) {
+            var errors = [
+              calculateAxisErrors(data.x, data.error_x, scaleFactor[0], sceneLayout.xaxis),
+              calculateAxisErrors(data.y, data.error_y, scaleFactor[1], sceneLayout.yaxis),
+              calculateAxisErrors(data.z, data.error_z, scaleFactor[2], sceneLayout.zaxis)
+            ];
+            var n2 = dataLength(errors);
+            if (n2 === 0) return null;
+            var errorBounds = new Array(n2);
+            for (var i2 = 0; i2 < n2; i2++) {
+              var bound = [[0, 0, 0], [0, 0, 0]];
+              for (var j2 = 0; j2 < 3; j2++) {
+                if (errors[j2]) {
+                  for (var k2 = 0; k2 < 2; k2++) {
+                    bound[k2][j2] = errors[j2][i2][k2];
+                  }
+                }
+              }
+              errorBounds[i2] = bound;
+            }
+            return errorBounds;
+          }
+          module2.exports = calculateErrors;
         }
-      },
-      _findEventTargets: function(e, type) {
-        var targets = [], target, isHover = type === "mouseout" || type === "mouseover", src = e.target || e.srcElement, dragging = false;
-        while (src) {
-          target = this._targets[stamp(src)];
-          if (target && (type === "click" || type === "preclick") && this._draggableMoved(target)) {
-            dragging = true;
-            break;
+      });
+      var require_convert2 = __commonJS({
+        "src/traces/scatter3d/convert.js"(exports, module2) {
+          var createLinePlot = require_stackgl_modules().gl_line3d;
+          var createScatterPlot = require_stackgl_modules().gl_scatter3d;
+          var createErrorBars = require_stackgl_modules().gl_error3d;
+          var createMesh = require_stackgl_modules().gl_mesh3d;
+          var triangulate = require_stackgl_modules().delaunay_triangulate;
+          var Lib = require_lib();
+          var str2RgbaArray = require_str2rgbarray();
+          var formatColor = require_gl_format_color().formatColor;
+          var makeBubbleSizeFn = require_make_bubble_size_func();
+          var DASH_PATTERNS = require_gl3d_dashes();
+          var MARKER_SYMBOLS = require_gl3d_markers();
+          var Axes = require_axes();
+          var appendArrayPointValue = require_helpers2().appendArrayPointValue;
+          var calculateError = require_calc_errors();
+          function LineWithMarkers(scene, uid2) {
+            this.scene = scene;
+            this.uid = uid2;
+            this.linePlot = null;
+            this.scatterPlot = null;
+            this.errorBars = null;
+            this.textMarkers = null;
+            this.delaunayMesh = null;
+            this.color = null;
+            this.mode = "";
+            this.dataPoints = [];
+            this.axesBounds = [
+              [-Infinity, -Infinity, -Infinity],
+              [Infinity, Infinity, Infinity]
+            ];
+            this.textLabels = null;
+            this.data = null;
           }
-          if (target && target.listens(type, true)) {
-            if (isHover && !isExternalTarget(src, e)) {
-              break;
+          var proto = LineWithMarkers.prototype;
+          proto.handlePick = function(selection) {
+            if (selection.object && (selection.object === this.linePlot || selection.object === this.delaunayMesh || selection.object === this.textMarkers || selection.object === this.scatterPlot)) {
+              var ind = selection.index = selection.data.index;
+              if (selection.object.highlight) {
+                selection.object.highlight(null);
+              }
+              if (this.scatterPlot) {
+                selection.object = this.scatterPlot;
+                this.scatterPlot.highlight(selection.data);
+              }
+              selection.textLabel = "";
+              if (this.textLabels) {
+                if (Lib.isArrayOrTypedArray(this.textLabels)) {
+                  if (this.textLabels[ind] || this.textLabels[ind] === 0) {
+                    selection.textLabel = this.textLabels[ind];
+                  }
+                } else {
+                  selection.textLabel = this.textLabels;
+                }
+              }
+              selection.traceCoordinate = [this.data.x[ind], this.data.y[ind], this.data.z[ind]];
+              return true;
             }
-            targets.push(target);
-            if (isHover) {
-              break;
+          };
+          function constructDelaunay(points, color22, axis) {
+            var u2 = (axis + 1) % 3;
+            var v2 = (axis + 2) % 3;
+            var filteredPoints = [];
+            var filteredIds = [];
+            var i2;
+            for (i2 = 0; i2 < points.length; ++i2) {
+              var p2 = points[i2];
+              if (isNaN(p2[u2]) || !isFinite(p2[u2]) || isNaN(p2[v2]) || !isFinite(p2[v2])) {
+                continue;
+              }
+              filteredPoints.push([p2[u2], p2[v2]]);
+              filteredIds.push(i2);
+            }
+            var cells = triangulate(filteredPoints);
+            for (i2 = 0; i2 < cells.length; ++i2) {
+              var c2 = cells[i2];
+              for (var j2 = 0; j2 < c2.length; ++j2) {
+                c2[j2] = filteredIds[c2[j2]];
+              }
             }
+            return {
+              positions: points,
+              cells,
+              meshColor: color22
+            };
           }
-          if (src === this._container) {
-            break;
+          function calculateErrorParams(errors) {
+            var capSize = [0, 0, 0];
+            var color22 = [
+              [0, 0, 0],
+              [0, 0, 0],
+              [0, 0, 0]
+            ];
+            var lineWidth = [1, 1, 1];
+            for (var i2 = 0; i2 < 3; i2++) {
+              var e2 = errors[i2];
+              if (e2 && e2.copy_zstyle !== false && errors[2].visible !== false) e2 = errors[2];
+              if (!e2 || !e2.visible) continue;
+              capSize[i2] = e2.width / 2;
+              color22[i2] = str2RgbaArray(e2.color);
+              lineWidth[i2] = e2.thickness;
+            }
+            return { capSize, color: color22, lineWidth };
           }
-          src = src.parentNode;
-        }
-        if (!targets.length && !dragging && !isHover && this.listens(type, true)) {
-          targets = [this];
-        }
-        return targets;
-      },
-      _isClickDisabled: function(el2) {
-        while (el2 && el2 !== this._container) {
-          if (el2["_leaflet_disable_click"]) {
-            return true;
+          function parseAlignmentX(a2) {
+            if (a2 === null || a2 === void 0) return 0;
+            return a2.indexOf("left") > -1 ? -1 : a2.indexOf("right") > -1 ? 1 : 0;
           }
-          el2 = el2.parentNode;
-        }
-      },
-      _handleDOMEvent: function(e) {
-        var el2 = e.target || e.srcElement;
-        if (!this._loaded || el2["_leaflet_disable_events"] || e.type === "click" && this._isClickDisabled(el2)) {
-          return;
-        }
-        var type = e.type;
-        if (type === "mousedown") {
-          preventOutline(el2);
-        }
-        this._fireDOMEvent(e, type);
-      },
-      _mouseEvents: ["click", "dblclick", "mouseover", "mouseout", "contextmenu"],
-      _fireDOMEvent: function(e, type, canvasTargets) {
-        if (e.type === "click") {
-          var synth = extend({}, e);
-          synth.type = "preclick";
-          this._fireDOMEvent(synth, synth.type, canvasTargets);
-        }
-        var targets = this._findEventTargets(e, type);
-        if (canvasTargets) {
-          var filtered = [];
-          for (var i = 0; i < canvasTargets.length; i++) {
-            if (canvasTargets[i].listens(type, true)) {
-              filtered.push(canvasTargets[i]);
+          function parseAlignmentY(a2) {
+            if (a2 === null || a2 === void 0) return 0;
+            return a2.indexOf("top") > -1 ? -1 : a2.indexOf("bottom") > -1 ? 1 : 0;
+          }
+          function calculateTextOffset(tp) {
+            var defaultAlignmentX = 0;
+            var defaultAlignmentY = 0;
+            var textOffset = [defaultAlignmentX, defaultAlignmentY];
+            if (Array.isArray(tp)) {
+              for (var i2 = 0; i2 < tp.length; i2++) {
+                textOffset[i2] = [defaultAlignmentX, defaultAlignmentY];
+                if (tp[i2]) {
+                  textOffset[i2][0] = parseAlignmentX(tp[i2]);
+                  textOffset[i2][1] = parseAlignmentY(tp[i2]);
+                }
+              }
+            } else {
+              textOffset[0] = parseAlignmentX(tp);
+              textOffset[1] = parseAlignmentY(tp);
             }
+            return textOffset;
           }
-          targets = filtered.concat(targets);
-        }
-        if (!targets.length) {
-          return;
-        }
-        if (type === "contextmenu") {
-          preventDefault(e);
-        }
-        var target = targets[0];
-        var data = {
-          originalEvent: e
-        };
-        if (e.type !== "keypress" && e.type !== "keydown" && e.type !== "keyup") {
-          var isMarker = target.getLatLng && (!target._radius || target._radius <= 10);
-          data.containerPoint = isMarker ? this.latLngToContainerPoint(target.getLatLng()) : this.mouseEventToContainerPoint(e);
-          data.layerPoint = this.containerPointToLayerPoint(data.containerPoint);
-          data.latlng = isMarker ? target.getLatLng() : this.layerPointToLatLng(data.layerPoint);
-        }
-        for (i = 0; i < targets.length; i++) {
-          targets[i].fire(type, data, true);
-          if (data.originalEvent._stopped || targets[i].options.bubblingMouseEvents === false && indexOf(this._mouseEvents, type) !== -1) {
-            return;
+          function calculateSize(sizeIn, sizeFn) {
+            return sizeFn(sizeIn * 4);
           }
-        }
-      },
-      _draggableMoved: function(obj) {
-        obj = obj.dragging && obj.dragging.enabled() ? obj : this;
-        return obj.dragging && obj.dragging.moved() || this.boxZoom && this.boxZoom.moved();
-      },
-      _clearHandlers: function() {
-        for (var i = 0, len = this._handlers.length; i < len; i++) {
-          this._handlers[i].disable();
-        }
-      },
-      // @section Other Methods
-      // @method whenReady(fn: Function, context?: Object): this
-      // Runs the given function `fn` when the map gets initialized with
-      // a view (center and zoom) and at least one layer, or immediately
-      // if it's already initialized, optionally passing a function context.
-      whenReady: function(callback2, context) {
-        if (this._loaded) {
-          callback2.call(context || this, { target: this });
-        } else {
-          this.on("load", callback2, context);
-        }
-        return this;
-      },
-      // private methods for getting map state
-      _getMapPanePos: function() {
-        return getPosition(this._mapPane) || new Point(0, 0);
-      },
-      _moved: function() {
-        var pos = this._getMapPanePos();
-        return pos && !pos.equals([0, 0]);
-      },
-      _getTopLeftPoint: function(center, zoom2) {
-        var pixelOrigin = center && zoom2 !== void 0 ? this._getNewPixelOrigin(center, zoom2) : this.getPixelOrigin();
-        return pixelOrigin.subtract(this._getMapPanePos());
-      },
-      _getNewPixelOrigin: function(center, zoom2) {
-        var viewHalf = this.getSize()._divideBy(2);
-        return this.project(center, zoom2)._subtract(viewHalf)._add(this._getMapPanePos())._round();
-      },
-      _latLngToNewLayerPoint: function(latlng, zoom2, center) {
-        var topLeft = this._getNewPixelOrigin(center, zoom2);
-        return this.project(latlng, zoom2)._subtract(topLeft);
-      },
-      _latLngBoundsToNewLayerBounds: function(latLngBounds, zoom2, center) {
-        var topLeft = this._getNewPixelOrigin(center, zoom2);
-        return toBounds([
-          this.project(latLngBounds.getSouthWest(), zoom2)._subtract(topLeft),
-          this.project(latLngBounds.getNorthWest(), zoom2)._subtract(topLeft),
-          this.project(latLngBounds.getSouthEast(), zoom2)._subtract(topLeft),
-          this.project(latLngBounds.getNorthEast(), zoom2)._subtract(topLeft)
-        ]);
-      },
-      // layer point of the current center
-      _getCenterLayerPoint: function() {
-        return this.containerPointToLayerPoint(this.getSize()._divideBy(2));
-      },
-      // offset of the specified place to the current center in pixels
-      _getCenterOffset: function(latlng) {
-        return this.latLngToLayerPoint(latlng).subtract(this._getCenterLayerPoint());
-      },
-      // adjust center for view to get inside bounds
-      _limitCenter: function(center, zoom2, bounds) {
-        if (!bounds) {
-          return center;
-        }
-        var centerPoint = this.project(center, zoom2), viewHalf = this.getSize().divideBy(2), viewBounds = new Bounds(centerPoint.subtract(viewHalf), centerPoint.add(viewHalf)), offset = this._getBoundsOffset(viewBounds, bounds, zoom2);
-        if (Math.abs(offset.x) <= 1 && Math.abs(offset.y) <= 1) {
-          return center;
-        }
-        return this.unproject(centerPoint.add(offset), zoom2);
-      },
-      // adjust offset for view to get inside bounds
-      _limitOffset: function(offset, bounds) {
-        if (!bounds) {
-          return offset;
-        }
-        var viewBounds = this.getPixelBounds(), newBounds = new Bounds(viewBounds.min.add(offset), viewBounds.max.add(offset));
-        return offset.add(this._getBoundsOffset(newBounds, bounds));
-      },
-      // returns offset needed for pxBounds to get inside maxBounds at a specified zoom
-      _getBoundsOffset: function(pxBounds, maxBounds, zoom2) {
-        var projectedMaxBounds = toBounds(
-          this.project(maxBounds.getNorthEast(), zoom2),
-          this.project(maxBounds.getSouthWest(), zoom2)
-        ), minOffset = projectedMaxBounds.min.subtract(pxBounds.min), maxOffset = projectedMaxBounds.max.subtract(pxBounds.max), dx = this._rebound(minOffset.x, -maxOffset.x), dy = this._rebound(minOffset.y, -maxOffset.y);
-        return new Point(dx, dy);
-      },
-      _rebound: function(left, right) {
-        return left + right > 0 ? Math.round(left - right) / 2 : Math.max(0, Math.ceil(left)) - Math.max(0, Math.floor(right));
-      },
-      _limitZoom: function(zoom2) {
-        var min = this.getMinZoom(), max = this.getMaxZoom(), snap = Browser.any3d ? this.options.zoomSnap : 1;
-        if (snap) {
-          zoom2 = Math.round(zoom2 / snap) * snap;
-        }
-        return Math.max(min, Math.min(max, zoom2));
-      },
-      _onPanTransitionStep: function() {
-        this.fire("move");
-      },
-      _onPanTransitionEnd: function() {
-        removeClass(this._mapPane, "leaflet-pan-anim");
-        this.fire("moveend");
-      },
-      _tryAnimatedPan: function(center, options) {
-        var offset = this._getCenterOffset(center)._trunc();
-        if ((options && options.animate) !== true && !this.getSize().contains(offset)) {
-          return false;
-        }
-        this.panBy(offset, options);
-        return true;
-      },
-      _createAnimProxy: function() {
-        var proxy = this._proxy = create$1("div", "leaflet-proxy leaflet-zoom-animated");
-        this._panes.mapPane.appendChild(proxy);
-        this.on("zoomanim", function(e) {
-          var prop = TRANSFORM, transform = this._proxy.style[prop];
-          setTransform(this._proxy, this.project(e.center, e.zoom), this.getZoomScale(e.zoom, 1));
-          if (transform === this._proxy.style[prop] && this._animatingZoom) {
-            this._onZoomTransitionEnd();
-          }
-        }, this);
-        this.on("load moveend", this._animMoveEnd, this);
-        this._on("unload", this._destroyAnimProxy, this);
-      },
-      _destroyAnimProxy: function() {
-        remove(this._proxy);
-        this.off("load moveend", this._animMoveEnd, this);
-        delete this._proxy;
-      },
-      _animMoveEnd: function() {
-        var c = this.getCenter(), z2 = this.getZoom();
-        setTransform(this._proxy, this.project(c, z2), this.getZoomScale(z2, 1));
-      },
-      _catchTransitionEnd: function(e) {
-        if (this._animatingZoom && e.propertyName.indexOf("transform") >= 0) {
-          this._onZoomTransitionEnd();
-        }
-      },
-      _nothingToAnimate: function() {
-        return !this._container.getElementsByClassName("leaflet-zoom-animated").length;
-      },
-      _tryAnimatedZoom: function(center, zoom2, options) {
-        if (this._animatingZoom) {
-          return true;
-        }
-        options = options || {};
-        if (!this._zoomAnimated || options.animate === false || this._nothingToAnimate() || Math.abs(zoom2 - this._zoom) > this.options.zoomAnimationThreshold) {
-          return false;
-        }
-        var scale2 = this.getZoomScale(zoom2), offset = this._getCenterOffset(center)._divideBy(1 - 1 / scale2);
-        if (options.animate !== true && !this.getSize().contains(offset)) {
-          return false;
-        }
-        requestAnimFrame2(function() {
-          this._moveStart(true, options.noMoveStart || false)._animateZoom(center, zoom2, true);
-        }, this);
-        return true;
-      },
-      _animateZoom: function(center, zoom2, startAnim, noUpdate) {
-        if (!this._mapPane) {
-          return;
-        }
-        if (startAnim) {
-          this._animatingZoom = true;
-          this._animateToCenter = center;
-          this._animateToZoom = zoom2;
-          addClass(this._mapPane, "leaflet-zoom-anim");
-        }
-        this.fire("zoomanim", {
-          center,
-          zoom: zoom2,
-          noUpdate
-        });
-        if (!this._tempFireZoomEvent) {
-          this._tempFireZoomEvent = this._zoom !== this._animateToZoom;
-        }
-        this._move(this._animateToCenter, this._animateToZoom, void 0, true);
-        setTimeout(bind(this._onZoomTransitionEnd, this), 250);
-      },
-      _onZoomTransitionEnd: function() {
-        if (!this._animatingZoom) {
-          return;
-        }
-        if (this._mapPane) {
-          removeClass(this._mapPane, "leaflet-zoom-anim");
-        }
-        this._animatingZoom = false;
-        this._move(this._animateToCenter, this._animateToZoom, void 0, true);
-        if (this._tempFireZoomEvent) {
-          this.fire("zoom");
-        }
-        delete this._tempFireZoomEvent;
-        this.fire("move");
-        this._moveEnd(true);
-      }
-    });
-    function createMap(id2, options) {
-      return new Map2(id2, options);
-    }
-    var Control = Class.extend({
-      // @section
-      // @aka Control Options
-      options: {
-        // @option position: String = 'topright'
-        // The position of the control (one of the map corners). Possible values are `'topleft'`,
-        // `'topright'`, `'bottomleft'` or `'bottomright'`
-        position: "topright"
-      },
-      initialize: function(options) {
-        setOptions2(this, options);
-      },
-      /* @section
-       * Classes extending L.Control will inherit the following methods:
-       *
-       * @method getPosition: string
-       * Returns the position of the control.
-       */
-      getPosition: function() {
-        return this.options.position;
-      },
-      // @method setPosition(position: string): this
-      // Sets the position of the control.
-      setPosition: function(position) {
-        var map2 = this._map;
-        if (map2) {
-          map2.removeControl(this);
-        }
-        this.options.position = position;
-        if (map2) {
-          map2.addControl(this);
-        }
-        return this;
-      },
-      // @method getContainer: HTMLElement
-      // Returns the HTMLElement that contains the control.
-      getContainer: function() {
-        return this._container;
-      },
-      // @method addTo(map: Map): this
-      // Adds the control to the given map.
-      addTo: function(map2) {
-        this.remove();
-        this._map = map2;
-        var container = this._container = this.onAdd(map2), pos = this.getPosition(), corner = map2._controlCorners[pos];
-        addClass(container, "leaflet-control");
-        if (pos.indexOf("bottom") !== -1) {
-          corner.insertBefore(container, corner.firstChild);
-        } else {
-          corner.appendChild(container);
-        }
-        this._map.on("unload", this.remove, this);
-        return this;
-      },
-      // @method remove: this
-      // Removes the control from the map it is currently active on.
-      remove: function() {
-        if (!this._map) {
-          return this;
-        }
-        remove(this._container);
-        if (this.onRemove) {
-          this.onRemove(this._map);
-        }
-        this._map.off("unload", this.remove, this);
-        this._map = null;
-        return this;
-      },
-      _refocusOnMap: function(e) {
-        if (this._map && e && e.screenX > 0 && e.screenY > 0) {
-          this._map.getContainer().focus();
-        }
-      }
-    });
-    var control = function(options) {
-      return new Control(options);
-    };
-    Map2.include({
-      // @method addControl(control: Control): this
-      // Adds the given control to the map
-      addControl: function(control2) {
-        control2.addTo(this);
-        return this;
-      },
-      // @method removeControl(control: Control): this
-      // Removes the given control from the map
-      removeControl: function(control2) {
-        control2.remove();
-        return this;
-      },
-      _initControlPos: function() {
-        var corners = this._controlCorners = {}, l2 = "leaflet-", container = this._controlContainer = create$1("div", l2 + "control-container", this._container);
-        function createCorner(vSide, hSide) {
-          var className = l2 + vSide + " " + l2 + hSide;
-          corners[vSide + hSide] = create$1("div", className, container);
-        }
-        createCorner("top", "left");
-        createCorner("top", "right");
-        createCorner("bottom", "left");
-        createCorner("bottom", "right");
-      },
-      _clearControlPos: function() {
-        for (var i in this._controlCorners) {
-          remove(this._controlCorners[i]);
-        }
-        remove(this._controlContainer);
-        delete this._controlCorners;
-        delete this._controlContainer;
-      }
-    });
-    var Layers = Control.extend({
-      // @section
-      // @aka Control.Layers options
-      options: {
-        // @option collapsed: Boolean = true
-        // If `true`, the control will be collapsed into an icon and expanded on mouse hover, touch, or keyboard activation.
-        collapsed: true,
-        position: "topright",
-        // @option autoZIndex: Boolean = true
-        // If `true`, the control will assign zIndexes in increasing order to all of its layers so that the order is preserved when switching them on/off.
-        autoZIndex: true,
-        // @option hideSingleBase: Boolean = false
-        // If `true`, the base layers in the control will be hidden when there is only one.
-        hideSingleBase: false,
-        // @option sortLayers: Boolean = false
-        // Whether to sort the layers. When `false`, layers will keep the order
-        // in which they were added to the control.
-        sortLayers: false,
-        // @option sortFunction: Function = *
-        // A [compare function](https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/Array/sort)
-        // that will be used for sorting the layers, when `sortLayers` is `true`.
-        // The function receives both the `L.Layer` instances and their names, as in
-        // `sortFunction(layerA, layerB, nameA, nameB)`.
-        // By default, it sorts layers alphabetically by their name.
-        sortFunction: function(layerA, layerB, nameA, nameB) {
-          return nameA < nameB ? -1 : nameB < nameA ? 1 : 0;
-        }
-      },
-      initialize: function(baseLayers, overlays, options) {
-        setOptions2(this, options);
-        this._layerControlInputs = [];
-        this._layers = [];
-        this._lastZIndex = 0;
-        this._handlingClick = false;
-        this._preventClick = false;
-        for (var i in baseLayers) {
-          this._addLayer(baseLayers[i], i);
-        }
-        for (i in overlays) {
-          this._addLayer(overlays[i], i, true);
-        }
-      },
-      onAdd: function(map2) {
-        this._initLayout();
-        this._update();
-        this._map = map2;
-        map2.on("zoomend", this._checkDisabledLayers, this);
-        for (var i = 0; i < this._layers.length; i++) {
-          this._layers[i].layer.on("add remove", this._onLayerChange, this);
-        }
-        return this._container;
-      },
-      addTo: function(map2) {
-        Control.prototype.addTo.call(this, map2);
-        return this._expandIfNotCollapsed();
-      },
-      onRemove: function() {
-        this._map.off("zoomend", this._checkDisabledLayers, this);
-        for (var i = 0; i < this._layers.length; i++) {
-          this._layers[i].layer.off("add remove", this._onLayerChange, this);
-        }
-      },
-      // @method addBaseLayer(layer: Layer, name: String): this
-      // Adds a base layer (radio button entry) with the given name to the control.
-      addBaseLayer: function(layer, name) {
-        this._addLayer(layer, name);
-        return this._map ? this._update() : this;
-      },
-      // @method addOverlay(layer: Layer, name: String): this
-      // Adds an overlay (checkbox entry) with the given name to the control.
-      addOverlay: function(layer, name) {
-        this._addLayer(layer, name, true);
-        return this._map ? this._update() : this;
-      },
-      // @method removeLayer(layer: Layer): this
-      // Remove the given layer from the control.
-      removeLayer: function(layer) {
-        layer.off("add remove", this._onLayerChange, this);
-        var obj = this._getLayer(stamp(layer));
-        if (obj) {
-          this._layers.splice(this._layers.indexOf(obj), 1);
-        }
-        return this._map ? this._update() : this;
-      },
-      // @method expand(): this
-      // Expand the control container if collapsed.
-      expand: function() {
-        addClass(this._container, "leaflet-control-layers-expanded");
-        this._section.style.height = null;
-        var acceptableHeight = this._map.getSize().y - (this._container.offsetTop + 50);
-        if (acceptableHeight < this._section.clientHeight) {
-          addClass(this._section, "leaflet-control-layers-scrollbar");
-          this._section.style.height = acceptableHeight + "px";
-        } else {
-          removeClass(this._section, "leaflet-control-layers-scrollbar");
-        }
-        this._checkDisabledLayers();
-        return this;
-      },
-      // @method collapse(): this
-      // Collapse the control container if expanded.
-      collapse: function() {
-        removeClass(this._container, "leaflet-control-layers-expanded");
-        return this;
-      },
-      _initLayout: function() {
-        var className = "leaflet-control-layers", container = this._container = create$1("div", className), collapsed = this.options.collapsed;
-        container.setAttribute("aria-haspopup", true);
-        disableClickPropagation(container);
-        disableScrollPropagation(container);
-        var section = this._section = create$1("section", className + "-list");
-        if (collapsed) {
-          this._map.on("click", this.collapse, this);
-          on(container, {
-            mouseenter: this._expandSafely,
-            mouseleave: this.collapse
-          }, this);
-        }
-        var link = this._layersLink = create$1("a", className + "-toggle", container);
-        link.href = "#";
-        link.title = "Layers";
-        link.setAttribute("role", "button");
-        on(link, {
-          keydown: function(e) {
-            if (e.keyCode === 13) {
-              this._expandSafely();
+          function calculateSymbol(symbolIn) {
+            return MARKER_SYMBOLS[symbolIn];
+          }
+          function formatParam(paramIn, len2, calculate, dflt, extraFn) {
+            var paramOut = null;
+            if (Lib.isArrayOrTypedArray(paramIn)) {
+              paramOut = [];
+              for (var i2 = 0; i2 < len2; i2++) {
+                if (paramIn[i2] === void 0) paramOut[i2] = dflt;
+                else paramOut[i2] = calculate(paramIn[i2], extraFn);
+              }
+            } else paramOut = calculate(paramIn, Lib.identity);
+            return paramOut;
+          }
+          function convertPlotlyOptions(scene, data) {
+            var points = [];
+            var sceneLayout = scene.fullSceneLayout;
+            var scaleFactor = scene.dataScale;
+            var xaxis = sceneLayout.xaxis;
+            var yaxis = sceneLayout.yaxis;
+            var zaxis = sceneLayout.zaxis;
+            var marker = data.marker;
+            var line = data.line;
+            var x2 = data.x || [];
+            var y2 = data.y || [];
+            var z2 = data.z || [];
+            var len2 = x2.length;
+            var xcalendar = data.xcalendar;
+            var ycalendar = data.ycalendar;
+            var zcalendar = data.zcalendar;
+            var xc2, yc2, zc2;
+            var params, i2;
+            var text;
+            for (i2 = 0; i2 < len2; i2++) {
+              xc2 = xaxis.d2l(x2[i2], 0, xcalendar) * scaleFactor[0];
+              yc2 = yaxis.d2l(y2[i2], 0, ycalendar) * scaleFactor[1];
+              zc2 = zaxis.d2l(z2[i2], 0, zcalendar) * scaleFactor[2];
+              points[i2] = [xc2, yc2, zc2];
             }
-          },
-          // Certain screen readers intercept the key event and instead send a click event
-          click: function(e) {
-            preventDefault(e);
-            this._expandSafely();
-          }
-        }, this);
-        if (!collapsed) {
-          this.expand();
-        }
-        this._baseLayersList = create$1("div", className + "-base", section);
-        this._separator = create$1("div", className + "-separator", section);
-        this._overlaysList = create$1("div", className + "-overlays", section);
-        container.appendChild(section);
-      },
-      _getLayer: function(id2) {
-        for (var i = 0; i < this._layers.length; i++) {
-          if (this._layers[i] && stamp(this._layers[i].layer) === id2) {
-            return this._layers[i];
+            if (Array.isArray(data.text)) {
+              text = data.text;
+            } else if (Lib.isTypedArray(data.text)) {
+              text = Array.from(data.text);
+            } else if (data.text !== void 0) {
+              text = new Array(len2);
+              for (i2 = 0; i2 < len2; i2++) text[i2] = data.text;
+            }
+            function formatter(axName, val) {
+              var ax = sceneLayout[axName];
+              return Axes.tickText(ax, ax.d2l(val), true).text;
+            }
+            var texttemplate = data.texttemplate;
+            if (texttemplate) {
+              var fullLayout = scene.fullLayout;
+              var d3locale = fullLayout._d3locale;
+              var isArray2 = Array.isArray(texttemplate);
+              var N2 = isArray2 ? Math.min(texttemplate.length, len2) : len2;
+              var txt = isArray2 ? function(i22) {
+                return texttemplate[i22];
+              } : function() {
+                return texttemplate;
+              };
+              text = new Array(N2);
+              for (i2 = 0; i2 < N2; i2++) {
+                var d2 = { x: x2[i2], y: y2[i2], z: z2[i2] };
+                var labels = {
+                  xLabel: formatter("xaxis", x2[i2]),
+                  yLabel: formatter("yaxis", y2[i2]),
+                  zLabel: formatter("zaxis", z2[i2])
+                };
+                var pointValues = {};
+                appendArrayPointValue(pointValues, data, i2);
+                text[i2] = Lib.texttemplateString({
+                  data: [pointValues, d2, data._meta],
+                  fallback: data.texttemplatefallback,
+                  labels,
+                  locale: d3locale,
+                  template: txt(i2)
+                });
+              }
+            }
+            params = {
+              position: points,
+              mode: data.mode,
+              text
+            };
+            if ("line" in data) {
+              params.lineColor = formatColor(line, 1, len2);
+              params.lineWidth = line.width;
+              params.lineDashes = line.dash;
+            }
+            if ("marker" in data) {
+              var sizeFn = makeBubbleSizeFn(data);
+              params.scatterColor = formatColor(marker, 1, len2);
+              params.scatterSize = formatParam(marker.size, len2, calculateSize, 20, sizeFn);
+              params.scatterMarker = formatParam(marker.symbol, len2, calculateSymbol, "●");
+              params.scatterLineWidth = marker.line.width;
+              params.scatterLineColor = formatColor(marker.line, 1, len2);
+              params.scatterAngle = 0;
+            }
+            if ("textposition" in data) {
+              params.textOffset = calculateTextOffset(data.textposition);
+              params.textColor = formatColor(data.textfont, 1, len2);
+              params.textSize = formatParam(data.textfont.size, len2, Lib.identity, 12);
+              params.textFontFamily = data.textfont.family;
+              params.textFontWeight = data.textfont.weight;
+              params.textFontStyle = data.textfont.style;
+              params.textFontVariant = data.textfont.variant;
+              params.textAngle = 0;
+            }
+            var dims = ["x", "y", "z"];
+            params.project = [false, false, false];
+            params.projectScale = [1, 1, 1];
+            params.projectOpacity = [1, 1, 1];
+            for (i2 = 0; i2 < 3; ++i2) {
+              var projection = data.projection[dims[i2]];
+              if (params.project[i2] = projection.show) {
+                params.projectOpacity[i2] = projection.opacity;
+                params.projectScale[i2] = projection.scale;
+              }
+            }
+            params.errorBounds = calculateError(data, scaleFactor, sceneLayout);
+            var errorParams = calculateErrorParams([data.error_x, data.error_y, data.error_z]);
+            params.errorColor = errorParams.color;
+            params.errorLineWidth = errorParams.lineWidth;
+            params.errorCapSize = errorParams.capSize;
+            params.delaunayAxis = data.surfaceaxis;
+            params.delaunayColor = str2RgbaArray(data.surfacecolor);
+            return params;
           }
-        }
-      },
-      _addLayer: function(layer, name, overlay) {
-        if (this._map) {
-          layer.on("add remove", this._onLayerChange, this);
-        }
-        this._layers.push({
-          layer,
-          name,
-          overlay
-        });
-        if (this.options.sortLayers) {
-          this._layers.sort(bind(function(a, b) {
-            return this.options.sortFunction(a.layer, b.layer, a.name, b.name);
-          }, this));
-        }
-        if (this.options.autoZIndex && layer.setZIndex) {
-          this._lastZIndex++;
-          layer.setZIndex(this._lastZIndex);
-        }
-        this._expandIfNotCollapsed();
-      },
-      _update: function() {
-        if (!this._container) {
-          return this;
-        }
-        empty(this._baseLayersList);
-        empty(this._overlaysList);
-        this._layerControlInputs = [];
-        var baseLayersPresent, overlaysPresent, i, obj, baseLayersCount = 0;
-        for (i = 0; i < this._layers.length; i++) {
-          obj = this._layers[i];
-          this._addItem(obj);
-          overlaysPresent = overlaysPresent || obj.overlay;
-          baseLayersPresent = baseLayersPresent || !obj.overlay;
-          baseLayersCount += !obj.overlay ? 1 : 0;
-        }
-        if (this.options.hideSingleBase) {
-          baseLayersPresent = baseLayersPresent && baseLayersCount > 1;
-          this._baseLayersList.style.display = baseLayersPresent ? "" : "none";
-        }
-        this._separator.style.display = overlaysPresent && baseLayersPresent ? "" : "none";
-        return this;
-      },
-      _onLayerChange: function(e) {
-        if (!this._handlingClick) {
-          this._update();
-        }
-        var obj = this._getLayer(stamp(e.target));
-        var type = obj.overlay ? e.type === "add" ? "overlayadd" : "overlayremove" : e.type === "add" ? "baselayerchange" : null;
-        if (type) {
-          this._map.fire(type, obj);
-        }
-      },
-      // IE7 bugs out if you create a radio dynamically, so you have to do it this hacky way (see https://stackoverflow.com/a/119079)
-      _createRadioElement: function(name, checked) {
-        var radioHtml = '<input type="radio" class="leaflet-control-layers-selector" name="' + name + '"' + (checked ? ' checked="checked"' : "") + "/>";
-        var radioFragment = document.createElement("div");
-        radioFragment.innerHTML = radioHtml;
-        return radioFragment.firstChild;
-      },
-      _addItem: function(obj) {
-        var label = document.createElement("label"), checked = this._map.hasLayer(obj.layer), input;
-        if (obj.overlay) {
-          input = document.createElement("input");
-          input.type = "checkbox";
-          input.className = "leaflet-control-layers-selector";
-          input.defaultChecked = checked;
-        } else {
-          input = this._createRadioElement("leaflet-base-layers_" + stamp(this), checked);
-        }
-        this._layerControlInputs.push(input);
-        input.layerId = stamp(obj.layer);
-        on(input, "click", this._onInputClick, this);
-        var name = document.createElement("span");
-        name.innerHTML = " " + obj.name;
-        var holder = document.createElement("span");
-        label.appendChild(holder);
-        holder.appendChild(input);
-        holder.appendChild(name);
-        var container = obj.overlay ? this._overlaysList : this._baseLayersList;
-        container.appendChild(label);
-        this._checkDisabledLayers();
-        return label;
-      },
-      _onInputClick: function() {
-        if (this._preventClick) {
-          return;
-        }
-        var inputs = this._layerControlInputs, input, layer;
-        var addedLayers = [], removedLayers = [];
-        this._handlingClick = true;
-        for (var i = inputs.length - 1; i >= 0; i--) {
-          input = inputs[i];
-          layer = this._getLayer(input.layerId).layer;
-          if (input.checked) {
-            addedLayers.push(layer);
-          } else if (!input.checked) {
-            removedLayers.push(layer);
+          function _arrayToColor(color22) {
+            if (Lib.isArrayOrTypedArray(color22)) {
+              var c2 = color22[0];
+              if (Lib.isArrayOrTypedArray(c2)) color22 = c2;
+              return "rgb(" + color22.slice(0, 3).map(function(x2) {
+                return Math.round(x2 * 255);
+              }) + ")";
+            }
+            return null;
           }
-        }
-        for (i = 0; i < removedLayers.length; i++) {
-          if (this._map.hasLayer(removedLayers[i])) {
-            this._map.removeLayer(removedLayers[i]);
+          function arrayToColor(colors) {
+            if (!Lib.isArrayOrTypedArray(colors)) {
+              return null;
+            }
+            if (colors.length === 4 && typeof colors[0] === "number") {
+              return _arrayToColor(colors);
+            }
+            return colors.map(_arrayToColor);
           }
-        }
-        for (i = 0; i < addedLayers.length; i++) {
-          if (!this._map.hasLayer(addedLayers[i])) {
-            this._map.addLayer(addedLayers[i]);
+          proto.update = function(data) {
+            var gl2 = this.scene.glplot.gl;
+            var lineOptions;
+            var scatterOptions;
+            var errorOptions;
+            var textOptions;
+            var dashPattern = DASH_PATTERNS.solid;
+            this.data = data;
+            var options = convertPlotlyOptions(this.scene, data);
+            if ("mode" in options) {
+              this.mode = options.mode;
+            }
+            if ("lineDashes" in options) {
+              if (options.lineDashes in DASH_PATTERNS) {
+                dashPattern = DASH_PATTERNS[options.lineDashes];
+              }
+            }
+            this.color = arrayToColor(options.scatterColor) || arrayToColor(options.lineColor);
+            this.dataPoints = options.position;
+            lineOptions = {
+              gl: this.scene.glplot.gl,
+              position: options.position,
+              color: options.lineColor,
+              lineWidth: options.lineWidth || 1,
+              dashes: dashPattern[0],
+              dashScale: dashPattern[1],
+              opacity: data.opacity,
+              connectGaps: data.connectgaps
+            };
+            if (this.mode.indexOf("lines") !== -1) {
+              if (this.linePlot) this.linePlot.update(lineOptions);
+              else {
+                this.linePlot = createLinePlot(lineOptions);
+                this.linePlot._trace = this;
+                this.scene.glplot.add(this.linePlot);
+              }
+            } else if (this.linePlot) {
+              this.scene.glplot.remove(this.linePlot);
+              this.linePlot.dispose();
+              this.linePlot = null;
+            }
+            var scatterOpacity = data.opacity;
+            if (data.marker && data.marker.opacity !== void 0) scatterOpacity *= data.marker.opacity;
+            scatterOptions = {
+              gl: this.scene.glplot.gl,
+              position: options.position,
+              color: options.scatterColor,
+              size: options.scatterSize,
+              glyph: options.scatterMarker,
+              opacity: scatterOpacity,
+              orthographic: true,
+              lineWidth: options.scatterLineWidth,
+              lineColor: options.scatterLineColor,
+              project: options.project,
+              projectScale: options.projectScale,
+              projectOpacity: options.projectOpacity
+            };
+            if (this.mode.indexOf("markers") !== -1) {
+              if (this.scatterPlot) this.scatterPlot.update(scatterOptions);
+              else {
+                this.scatterPlot = createScatterPlot(scatterOptions);
+                this.scatterPlot._trace = this;
+                this.scatterPlot.highlightScale = 1;
+                this.scene.glplot.add(this.scatterPlot);
+              }
+            } else if (this.scatterPlot) {
+              this.scene.glplot.remove(this.scatterPlot);
+              this.scatterPlot.dispose();
+              this.scatterPlot = null;
+            }
+            textOptions = {
+              gl: this.scene.glplot.gl,
+              position: options.position,
+              glyph: options.text,
+              color: options.textColor,
+              size: options.textSize,
+              angle: options.textAngle,
+              alignment: options.textOffset,
+              font: options.textFontFamily,
+              fontWeight: options.textFontWeight,
+              fontStyle: options.textFontStyle,
+              fontVariant: options.textFontVariant,
+              orthographic: true,
+              lineWidth: 0,
+              project: false,
+              opacity: data.opacity
+            };
+            this.textLabels = data.hovertext || data.text;
+            if (this.mode.indexOf("text") !== -1) {
+              if (this.textMarkers) this.textMarkers.update(textOptions);
+              else {
+                this.textMarkers = createScatterPlot(textOptions);
+                this.textMarkers._trace = this;
+                this.textMarkers.highlightScale = 1;
+                this.scene.glplot.add(this.textMarkers);
+              }
+            } else if (this.textMarkers) {
+              this.scene.glplot.remove(this.textMarkers);
+              this.textMarkers.dispose();
+              this.textMarkers = null;
+            }
+            errorOptions = {
+              gl: this.scene.glplot.gl,
+              position: options.position,
+              color: options.errorColor,
+              error: options.errorBounds,
+              lineWidth: options.errorLineWidth,
+              capSize: options.errorCapSize,
+              opacity: data.opacity
+            };
+            if (this.errorBars) {
+              if (options.errorBounds) {
+                this.errorBars.update(errorOptions);
+              } else {
+                this.scene.glplot.remove(this.errorBars);
+                this.errorBars.dispose();
+                this.errorBars = null;
+              }
+            } else if (options.errorBounds) {
+              this.errorBars = createErrorBars(errorOptions);
+              this.errorBars._trace = this;
+              this.scene.glplot.add(this.errorBars);
+            }
+            if (options.delaunayAxis >= 0) {
+              var delaunayOptions = constructDelaunay(options.position, options.delaunayColor, options.delaunayAxis);
+              delaunayOptions.opacity = data.opacity;
+              if (this.delaunayMesh) {
+                this.delaunayMesh.update(delaunayOptions);
+              } else {
+                delaunayOptions.gl = gl2;
+                this.delaunayMesh = createMesh(delaunayOptions);
+                this.delaunayMesh._trace = this;
+                this.scene.glplot.add(this.delaunayMesh);
+              }
+            } else if (this.delaunayMesh) {
+              this.scene.glplot.remove(this.delaunayMesh);
+              this.delaunayMesh.dispose();
+              this.delaunayMesh = null;
+            }
+          };
+          proto.dispose = function() {
+            if (this.linePlot) {
+              this.scene.glplot.remove(this.linePlot);
+              this.linePlot.dispose();
+            }
+            if (this.scatterPlot) {
+              this.scene.glplot.remove(this.scatterPlot);
+              this.scatterPlot.dispose();
+            }
+            if (this.errorBars) {
+              this.scene.glplot.remove(this.errorBars);
+              this.errorBars.dispose();
+            }
+            if (this.textMarkers) {
+              this.scene.glplot.remove(this.textMarkers);
+              this.textMarkers.dispose();
+            }
+            if (this.delaunayMesh) {
+              this.scene.glplot.remove(this.delaunayMesh);
+              this.delaunayMesh.dispose();
+            }
+          };
+          function createLineWithMarkers(scene, data) {
+            var plot = new LineWithMarkers(scene, data.uid);
+            plot.update(data);
+            return plot;
           }
+          module2.exports = createLineWithMarkers;
         }
-        this._handlingClick = false;
-        this._refocusOnMap();
-      },
-      _checkDisabledLayers: function() {
-        var inputs = this._layerControlInputs, input, layer, zoom2 = this._map.getZoom();
-        for (var i = inputs.length - 1; i >= 0; i--) {
-          input = inputs[i];
-          layer = this._getLayer(input.layerId).layer;
-          input.disabled = layer.options.minZoom !== void 0 && zoom2 < layer.options.minZoom || layer.options.maxZoom !== void 0 && zoom2 > layer.options.maxZoom;
-        }
-      },
-      _expandIfNotCollapsed: function() {
-        if (this._map && !this.options.collapsed) {
-          this.expand();
-        }
-        return this;
-      },
-      _expandSafely: function() {
-        var section = this._section;
-        this._preventClick = true;
-        on(section, "click", preventDefault);
-        this.expand();
-        var that = this;
-        setTimeout(function() {
-          off(section, "click", preventDefault);
-          that._preventClick = false;
-        });
-      }
-    });
-    var layers = function(baseLayers, overlays, options) {
-      return new Layers(baseLayers, overlays, options);
-    };
-    var Zoom = Control.extend({
-      // @section
-      // @aka Control.Zoom options
-      options: {
-        position: "topleft",
-        // @option zoomInText: String = '<span aria-hidden="true">+</span>'
-        // The text set on the 'zoom in' button.
-        zoomInText: '<span aria-hidden="true">+</span>',
-        // @option zoomInTitle: String = 'Zoom in'
-        // The title set on the 'zoom in' button.
-        zoomInTitle: "Zoom in",
-        // @option zoomOutText: String = '<span aria-hidden="true">&#x2212;</span>'
-        // The text set on the 'zoom out' button.
-        zoomOutText: '<span aria-hidden="true">&#x2212;</span>',
-        // @option zoomOutTitle: String = 'Zoom out'
-        // The title set on the 'zoom out' button.
-        zoomOutTitle: "Zoom out"
-      },
-      onAdd: function(map2) {
-        var zoomName = "leaflet-control-zoom", container = create$1("div", zoomName + " leaflet-bar"), options = this.options;
-        this._zoomInButton = this._createButton(
-          options.zoomInText,
-          options.zoomInTitle,
-          zoomName + "-in",
-          container,
-          this._zoomIn
-        );
-        this._zoomOutButton = this._createButton(
-          options.zoomOutText,
-          options.zoomOutTitle,
-          zoomName + "-out",
-          container,
-          this._zoomOut
-        );
-        this._updateDisabled();
-        map2.on("zoomend zoomlevelschange", this._updateDisabled, this);
-        return container;
-      },
-      onRemove: function(map2) {
-        map2.off("zoomend zoomlevelschange", this._updateDisabled, this);
-      },
-      disable: function() {
-        this._disabled = true;
-        this._updateDisabled();
-        return this;
-      },
-      enable: function() {
-        this._disabled = false;
-        this._updateDisabled();
-        return this;
-      },
-      _zoomIn: function(e) {
-        if (!this._disabled && this._map._zoom < this._map.getMaxZoom()) {
-          this._map.zoomIn(this._map.options.zoomDelta * (e.shiftKey ? 3 : 1));
+      });
+      var require_attributes40 = __commonJS({
+        "src/traces/scatter3d/attributes.js"(exports, module2) {
+          var scatterAttrs = require_attributes12();
+          var fontAttrs = require_font_attributes();
+          var colorAttributes = require_attributes8();
+          var axisHoverFormat = require_axis_format_attributes().axisHoverFormat;
+          var { hovertemplateAttrs, texttemplateAttrs, templatefallbackAttrs } = require_template_attributes();
+          var baseAttrs = require_attributes2();
+          var DASHES = require_gl3d_dashes();
+          var MARKER_SYMBOLS = require_gl3d_markers();
+          var extendFlat = require_extend().extendFlat;
+          var overrideAll = require_edit_types().overrideAll;
+          var sortObjectKeys = require_sort_object_keys();
+          var scatterLineAttrs = scatterAttrs.line;
+          var scatterMarkerAttrs = scatterAttrs.marker;
+          var scatterMarkerLineAttrs = scatterMarkerAttrs.line;
+          var lineAttrs = extendFlat(
+            {
+              width: scatterLineAttrs.width,
+              dash: {
+                valType: "enumerated",
+                values: sortObjectKeys(DASHES),
+                dflt: "solid"
+              }
+            },
+            colorAttributes("line")
+          );
+          function makeProjectionAttr(axLetter) {
+            return {
+              show: {
+                valType: "boolean",
+                dflt: false
+              },
+              opacity: {
+                valType: "number",
+                min: 0,
+                max: 1,
+                dflt: 1
+              },
+              scale: {
+                valType: "number",
+                min: 0,
+                max: 10,
+                dflt: 2 / 3
+              }
+            };
+          }
+          var attrs = module2.exports = overrideAll(
+            {
+              x: scatterAttrs.x,
+              y: scatterAttrs.y,
+              z: {
+                valType: "data_array"
+              },
+              text: extendFlat({}, scatterAttrs.text, {}),
+              texttemplate: texttemplateAttrs(),
+              texttemplatefallback: templatefallbackAttrs({ editType: "calc" }),
+              hovertext: extendFlat({}, scatterAttrs.hovertext, {}),
+              hovertemplate: hovertemplateAttrs(),
+              hovertemplatefallback: templatefallbackAttrs(),
+              xhoverformat: axisHoverFormat("x"),
+              yhoverformat: axisHoverFormat("y"),
+              zhoverformat: axisHoverFormat("z"),
+              mode: extendFlat(
+                {},
+                scatterAttrs.mode,
+                // shouldn't this be on-par with 2D?
+                { dflt: "lines+markers" }
+              ),
+              surfaceaxis: {
+                valType: "enumerated",
+                values: [-1, 0, 1, 2],
+                dflt: -1
+              },
+              surfacecolor: {
+                valType: "color"
+              },
+              projection: {
+                x: makeProjectionAttr(),
+                y: makeProjectionAttr(),
+                z: makeProjectionAttr()
+              },
+              connectgaps: scatterAttrs.connectgaps,
+              line: lineAttrs,
+              marker: extendFlat(
+                {
+                  // Parity with scatter.js?
+                  symbol: {
+                    valType: "enumerated",
+                    values: sortObjectKeys(MARKER_SYMBOLS),
+                    dflt: "circle",
+                    arrayOk: true
+                  },
+                  size: extendFlat({}, scatterMarkerAttrs.size, { dflt: 8 }),
+                  sizeref: scatterMarkerAttrs.sizeref,
+                  sizemin: scatterMarkerAttrs.sizemin,
+                  sizemode: scatterMarkerAttrs.sizemode,
+                  opacity: extendFlat({}, scatterMarkerAttrs.opacity, {
+                    arrayOk: false
+                  }),
+                  colorbar: scatterMarkerAttrs.colorbar,
+                  line: extendFlat(
+                    {
+                      width: extendFlat({}, scatterMarkerLineAttrs.width, { arrayOk: false })
+                    },
+                    colorAttributes("marker.line")
+                  )
+                },
+                colorAttributes("marker")
+              ),
+              textposition: extendFlat({}, scatterAttrs.textposition, { dflt: "top center" }),
+              textfont: fontAttrs({
+                noFontShadow: true,
+                noFontLineposition: true,
+                noFontTextcase: true,
+                editType: "calc",
+                colorEditType: "style",
+                arrayOk: true,
+                variantValues: ["normal", "small-caps"]
+              }),
+              opacity: baseAttrs.opacity,
+              hoverinfo: extendFlat({}, baseAttrs.hoverinfo)
+            },
+            "calc",
+            "nested"
+          );
+          attrs.x.editType = attrs.y.editType = attrs.z.editType = "calc+clearAxisTypes";
         }
-      },
-      _zoomOut: function(e) {
-        if (!this._disabled && this._map._zoom > this._map.getMinZoom()) {
-          this._map.zoomOut(this._map.options.zoomDelta * (e.shiftKey ? 3 : 1));
+      });
+      var require_defaults36 = __commonJS({
+        "src/traces/scatter3d/defaults.js"(exports, module2) {
+          var Registry = require_registry();
+          var Lib = require_lib();
+          var subTypes = require_subtypes();
+          var handleMarkerDefaults = require_marker_defaults();
+          var handleLineDefaults = require_line_defaults();
+          var handleTextDefaults = require_text_defaults();
+          var attributes = require_attributes40();
+          module2.exports = function supplyDefaults(traceIn, traceOut, defaultColor, layout) {
+            function coerce(attr, dflt) {
+              return Lib.coerce(traceIn, traceOut, attributes, attr, dflt);
+            }
+            var len2 = handleXYZDefaults(traceIn, traceOut, coerce, layout);
+            if (!len2) {
+              traceOut.visible = false;
+              return;
+            }
+            coerce("text");
+            coerce("hovertext");
+            coerce("hovertemplate");
+            coerce("hovertemplatefallback");
+            coerce("xhoverformat");
+            coerce("yhoverformat");
+            coerce("zhoverformat");
+            coerce("mode");
+            if (subTypes.hasMarkers(traceOut)) {
+              handleMarkerDefaults(traceIn, traceOut, defaultColor, layout, coerce, {
+                noAngle: true,
+                noLineDash: true,
+                noSelect: true
+              });
+            }
+            if (subTypes.hasLines(traceOut)) {
+              coerce("connectgaps");
+              handleLineDefaults(traceIn, traceOut, defaultColor, layout, coerce);
+            }
+            if (subTypes.hasText(traceOut)) {
+              coerce("texttemplate");
+              coerce("texttemplatefallback");
+              handleTextDefaults(traceIn, traceOut, layout, coerce, {
+                noSelect: true,
+                noFontShadow: true,
+                noFontLineposition: true,
+                noFontTextcase: true
+              });
+            }
+            var lineColor = (traceOut.line || {}).color;
+            var markerColor = (traceOut.marker || {}).color;
+            if (coerce("surfaceaxis") >= 0) coerce("surfacecolor", lineColor || markerColor);
+            var dims = ["x", "y", "z"];
+            for (var i2 = 0; i2 < 3; ++i2) {
+              var projection = "projection." + dims[i2];
+              if (coerce(projection + ".show")) {
+                coerce(projection + ".opacity");
+                coerce(projection + ".scale");
+              }
+            }
+            var errorBarsSupplyDefaults = Registry.getComponentMethod("errorbars", "supplyDefaults");
+            errorBarsSupplyDefaults(traceIn, traceOut, lineColor || markerColor || defaultColor, { axis: "z" });
+            errorBarsSupplyDefaults(traceIn, traceOut, lineColor || markerColor || defaultColor, { axis: "y", inherit: "z" });
+            errorBarsSupplyDefaults(traceIn, traceOut, lineColor || markerColor || defaultColor, { axis: "x", inherit: "z" });
+          };
+          function handleXYZDefaults(traceIn, traceOut, coerce, layout) {
+            var len2 = 0;
+            var x2 = coerce("x");
+            var y2 = coerce("y");
+            var z2 = coerce("z");
+            var handleCalendarDefaults = Registry.getComponentMethod("calendars", "handleTraceDefaults");
+            handleCalendarDefaults(traceIn, traceOut, ["x", "y", "z"], layout);
+            if (x2 && y2 && z2) {
+              len2 = Math.min(x2.length, y2.length, z2.length);
+              traceOut._length = traceOut._xlength = traceOut._ylength = traceOut._zlength = len2;
+            }
+            return len2;
+          }
         }
-      },
-      _createButton: function(html, title, className, container, fn) {
-        var link = create$1("a", className, container);
-        link.innerHTML = html;
-        link.href = "#";
-        link.title = title;
-        link.setAttribute("role", "button");
-        link.setAttribute("aria-label", title);
-        disableClickPropagation(link);
-        on(link, "click", stop);
-        on(link, "click", fn, this);
-        on(link, "click", this._refocusOnMap, this);
-        return link;
-      },
-      _updateDisabled: function() {
-        var map2 = this._map, className = "leaflet-disabled";
-        removeClass(this._zoomInButton, className);
-        removeClass(this._zoomOutButton, className);
-        this._zoomInButton.setAttribute("aria-disabled", "false");
-        this._zoomOutButton.setAttribute("aria-disabled", "false");
-        if (this._disabled || map2._zoom === map2.getMinZoom()) {
-          addClass(this._zoomOutButton, className);
-          this._zoomOutButton.setAttribute("aria-disabled", "true");
+      });
+      var require_calc21 = __commonJS({
+        "src/traces/scatter3d/calc.js"(exports, module2) {
+          var arraysToCalcdata = require_arrays_to_calcdata();
+          var calcColorscale = require_colorscale_calc();
+          module2.exports = function calc(gd2, trace) {
+            var cd2 = [{ x: false, y: false, trace, t: {} }];
+            arraysToCalcdata(cd2, trace);
+            calcColorscale(gd2, trace);
+            return cd2;
+          };
         }
-        if (this._disabled || map2._zoom === map2.getMaxZoom()) {
-          addClass(this._zoomInButton, className);
-          this._zoomInButton.setAttribute("aria-disabled", "true");
+      });
+      var require_get_canvas_context = __commonJS({
+        "node_modules/get-canvas-context/index.js"(exports, module2) {
+          module2.exports = getCanvasContext;
+          function getCanvasContext(type, opts) {
+            if (typeof type !== "string") {
+              throw new TypeError("must specify type string");
+            }
+            opts = opts || {};
+            if (typeof document === "undefined" && !opts.canvas) {
+              return null;
+            }
+            var canvas2 = opts.canvas || document.createElement("canvas");
+            if (typeof opts.width === "number") {
+              canvas2.width = opts.width;
+            }
+            if (typeof opts.height === "number") {
+              canvas2.height = opts.height;
+            }
+            var attribs = opts;
+            var gl2;
+            try {
+              var names2 = [type];
+              if (type.indexOf("webgl") === 0) {
+                names2.push("experimental-" + type);
+              }
+              for (var i2 = 0; i2 < names2.length; i2++) {
+                gl2 = canvas2.getContext(names2[i2], attribs);
+                if (gl2) return gl2;
+              }
+            } catch (e2) {
+              gl2 = null;
+            }
+            return gl2 || null;
+          }
         }
-      }
-    });
-    Map2.mergeOptions({
-      zoomControl: true
-    });
-    Map2.addInitHook(function() {
-      if (this.options.zoomControl) {
-        this.zoomControl = new Zoom();
-        this.addControl(this.zoomControl);
-      }
-    });
-    var zoom = function(options) {
-      return new Zoom(options);
-    };
-    var Scale2 = Control.extend({
-      // @section
-      // @aka Control.Scale options
-      options: {
-        position: "bottomleft",
-        // @option maxWidth: Number = 100
-        // Maximum width of the control in pixels. The width is set dynamically to show round values (e.g. 100, 200, 500).
-        maxWidth: 100,
-        // @option metric: Boolean = True
-        // Whether to show the metric scale line (m/km).
-        metric: true,
-        // @option imperial: Boolean = True
-        // Whether to show the imperial scale line (mi/ft).
-        imperial: true
-        // @option updateWhenIdle: Boolean = false
-        // If `true`, the control is updated on [`moveend`](#map-moveend), otherwise it's always up-to-date (updated on [`move`](#map-move)).
-      },
-      onAdd: function(map2) {
-        var className = "leaflet-control-scale", container = create$1("div", className), options = this.options;
-        this._addScales(options, className + "-line", container);
-        map2.on(options.updateWhenIdle ? "moveend" : "move", this._update, this);
-        map2.whenReady(this._update, this);
-        return container;
-      },
-      onRemove: function(map2) {
-        map2.off(this.options.updateWhenIdle ? "moveend" : "move", this._update, this);
-      },
-      _addScales: function(options, className, container) {
-        if (options.metric) {
-          this._mScale = create$1("div", className, container);
+      });
+      var require_webgl_context = __commonJS({
+        "node_modules/webgl-context/index.js"(exports, module2) {
+          var getContext = require_get_canvas_context();
+          module2.exports = function getWebGLContext(opt) {
+            return getContext("webgl", opt);
+          };
         }
-        if (options.imperial) {
-          this._iScale = create$1("div", className, container);
+      });
+      var require_show_no_webgl_msg = __commonJS({
+        "src/lib/show_no_webgl_msg.js"(exports, module2) {
+          var Color2 = require_color();
+          var noop2 = function() {
+          };
+          module2.exports = function showNoWebGlMsg(scene) {
+            for (var prop in scene) {
+              if (typeof scene[prop] === "function") scene[prop] = noop2;
+            }
+            scene.destroy = function() {
+              scene.container.parentNode.removeChild(scene.container);
+            };
+            var div = document.createElement("div");
+            div.className = "no-webgl";
+            div.style.cursor = "pointer";
+            div.style.fontSize = "24px";
+            div.style.color = Color2.defaults[0];
+            div.style.position = "absolute";
+            div.style.left = div.style.top = "0px";
+            div.style.width = div.style.height = "100%";
+            div.style["background-color"] = Color2.lightLine;
+            div.style["z-index"] = 30;
+            var p2 = document.createElement("p");
+            p2.textContent = "WebGL is not supported by your browser - visit https://get.webgl.org for more info";
+            p2.style.position = "relative";
+            p2.style.top = "50%";
+            p2.style.left = "50%";
+            p2.style.height = "30%";
+            p2.style.width = "50%";
+            p2.style.margin = "-15% 0 0 -25%";
+            div.appendChild(p2);
+            scene.container.appendChild(div);
+            scene.container.style.background = "#FFFFFF";
+            scene.container.onclick = function() {
+              window.open("https://get.webgl.org");
+            };
+            return false;
+          };
         }
-      },
-      _update: function() {
-        var map2 = this._map, y2 = map2.getSize().y / 2;
-        var maxMeters = map2.distance(
-          map2.containerPointToLatLng([0, y2]),
-          map2.containerPointToLatLng([this.options.maxWidth, y2])
-        );
-        this._updateScales(maxMeters);
-      },
-      _updateScales: function(maxMeters) {
-        if (this.options.metric && maxMeters) {
-          this._updateMetric(maxMeters);
+      });
+      var require_convert3 = __commonJS({
+        "src/plots/gl3d/layout/convert.js"(exports, module2) {
+          var str2RgbaArray = require_str2rgbarray();
+          var Lib = require_lib();
+          var AXES_NAMES = ["xaxis", "yaxis", "zaxis"];
+          function AxesOptions() {
+            this.bounds = [
+              [-10, -10, -10],
+              [10, 10, 10]
+            ];
+            this.ticks = [[], [], []];
+            this.tickEnable = [true, true, true];
+            this.tickFont = ["sans-serif", "sans-serif", "sans-serif"];
+            this.tickSize = [12, 12, 12];
+            this.tickFontWeight = ["normal", "normal", "normal", "normal"];
+            this.tickFontStyle = ["normal", "normal", "normal", "normal"];
+            this.tickFontVariant = ["normal", "normal", "normal", "normal"];
+            this.tickAngle = [0, 0, 0];
+            this.tickColor = [[0, 0, 0, 1], [0, 0, 0, 1], [0, 0, 0, 1]];
+            this.tickPad = [18, 18, 18];
+            this.labels = ["x", "y", "z"];
+            this.labelEnable = [true, true, true];
+            this.labelFont = ["Open Sans", "Open Sans", "Open Sans"];
+            this.labelSize = [20, 20, 20];
+            this.labelFontWeight = ["normal", "normal", "normal", "normal"];
+            this.labelFontStyle = ["normal", "normal", "normal", "normal"];
+            this.labelFontVariant = ["normal", "normal", "normal", "normal"];
+            this.labelColor = [[0, 0, 0, 1], [0, 0, 0, 1], [0, 0, 0, 1]];
+            this.labelPad = [30, 30, 30];
+            this.lineEnable = [true, true, true];
+            this.lineMirror = [false, false, false];
+            this.lineWidth = [1, 1, 1];
+            this.lineColor = [[0, 0, 0, 1], [0, 0, 0, 1], [0, 0, 0, 1]];
+            this.lineTickEnable = [true, true, true];
+            this.lineTickMirror = [false, false, false];
+            this.lineTickLength = [10, 10, 10];
+            this.lineTickWidth = [1, 1, 1];
+            this.lineTickColor = [[0, 0, 0, 1], [0, 0, 0, 1], [0, 0, 0, 1]];
+            this.gridEnable = [true, true, true];
+            this.gridWidth = [1, 1, 1];
+            this.gridColor = [[0, 0, 0, 1], [0, 0, 0, 1], [0, 0, 0, 1]];
+            this.zeroEnable = [true, true, true];
+            this.zeroLineColor = [[0, 0, 0, 1], [0, 0, 0, 1], [0, 0, 0, 1]];
+            this.zeroLineWidth = [2, 2, 2];
+            this.backgroundEnable = [true, true, true];
+            this.backgroundColor = [
+              [0.8, 0.8, 0.8, 0.5],
+              [0.8, 0.8, 0.8, 0.5],
+              [0.8, 0.8, 0.8, 0.5]
+            ];
+            this._defaultTickPad = this.tickPad.slice();
+            this._defaultLabelPad = this.labelPad.slice();
+            this._defaultLineTickLength = this.lineTickLength.slice();
+          }
+          var proto = AxesOptions.prototype;
+          proto.merge = function(fullLayout, sceneLayout) {
+            var opts = this;
+            for (var i2 = 0; i2 < 3; ++i2) {
+              var axes = sceneLayout[AXES_NAMES[i2]];
+              if (!axes.visible) {
+                opts.tickEnable[i2] = false;
+                opts.labelEnable[i2] = false;
+                opts.lineEnable[i2] = false;
+                opts.lineTickEnable[i2] = false;
+                opts.gridEnable[i2] = false;
+                opts.zeroEnable[i2] = false;
+                opts.backgroundEnable[i2] = false;
+                continue;
+              }
+              opts.labels[i2] = fullLayout._meta ? Lib.templateString(axes.title.text, fullLayout._meta) : axes.title.text;
+              if ("font" in axes.title) {
+                if (axes.title.font.color) opts.labelColor[i2] = str2RgbaArray(axes.title.font.color);
+                if (axes.title.font.family) opts.labelFont[i2] = axes.title.font.family;
+                if (axes.title.font.size) opts.labelSize[i2] = axes.title.font.size;
+                if (axes.title.font.weight) opts.labelFontWeight[i2] = axes.title.font.weight;
+                if (axes.title.font.style) opts.labelFontStyle[i2] = axes.title.font.style;
+                if (axes.title.font.variant) opts.labelFontVariant[i2] = axes.title.font.variant;
+              }
+              if ("showline" in axes) opts.lineEnable[i2] = axes.showline;
+              if ("linecolor" in axes) opts.lineColor[i2] = str2RgbaArray(axes.linecolor);
+              if ("linewidth" in axes) opts.lineWidth[i2] = axes.linewidth;
+              if ("showgrid" in axes) opts.gridEnable[i2] = axes.showgrid;
+              if ("gridcolor" in axes) opts.gridColor[i2] = str2RgbaArray(axes.gridcolor);
+              if ("gridwidth" in axes) opts.gridWidth[i2] = axes.gridwidth;
+              if (axes.type === "log") opts.zeroEnable[i2] = false;
+              else if ("zeroline" in axes) opts.zeroEnable[i2] = axes.zeroline;
+              if ("zerolinecolor" in axes) opts.zeroLineColor[i2] = str2RgbaArray(axes.zerolinecolor);
+              if ("zerolinewidth" in axes) opts.zeroLineWidth[i2] = axes.zerolinewidth;
+              if ("ticks" in axes && !!axes.ticks) opts.lineTickEnable[i2] = true;
+              else opts.lineTickEnable[i2] = false;
+              if ("ticklen" in axes) {
+                opts.lineTickLength[i2] = opts._defaultLineTickLength[i2] = axes.ticklen;
+              }
+              if ("tickcolor" in axes) opts.lineTickColor[i2] = str2RgbaArray(axes.tickcolor);
+              if ("tickwidth" in axes) opts.lineTickWidth[i2] = axes.tickwidth;
+              if ("tickangle" in axes) {
+                opts.tickAngle[i2] = axes.tickangle === "auto" ? -3600 : (
+                  // i.e. special number to set auto option
+                  Math.PI * -axes.tickangle / 180
+                );
+              }
+              if ("showticklabels" in axes) opts.tickEnable[i2] = axes.showticklabels;
+              if ("tickfont" in axes) {
+                if (axes.tickfont.color) opts.tickColor[i2] = str2RgbaArray(axes.tickfont.color);
+                if (axes.tickfont.family) opts.tickFont[i2] = axes.tickfont.family;
+                if (axes.tickfont.size) opts.tickSize[i2] = axes.tickfont.size;
+                if (axes.tickfont.weight) opts.tickFontWeight[i2] = axes.tickfont.weight;
+                if (axes.tickfont.style) opts.tickFontStyle[i2] = axes.tickfont.style;
+                if (axes.tickfont.variant) opts.tickFontVariant[i2] = axes.tickfont.variant;
+              }
+              if ("mirror" in axes) {
+                if (["ticks", "all", "allticks"].indexOf(axes.mirror) !== -1) {
+                  opts.lineTickMirror[i2] = true;
+                  opts.lineMirror[i2] = true;
+                } else if (axes.mirror === true) {
+                  opts.lineTickMirror[i2] = false;
+                  opts.lineMirror[i2] = true;
+                } else {
+                  opts.lineTickMirror[i2] = false;
+                  opts.lineMirror[i2] = false;
+                }
+              } else opts.lineMirror[i2] = false;
+              if ("showbackground" in axes && axes.showbackground !== false) {
+                opts.backgroundEnable[i2] = true;
+                opts.backgroundColor[i2] = str2RgbaArray(axes.backgroundcolor);
+              } else opts.backgroundEnable[i2] = false;
+            }
+          };
+          function createAxesOptions(fullLayout, sceneLayout) {
+            var result = new AxesOptions();
+            result.merge(fullLayout, sceneLayout);
+            return result;
+          }
+          module2.exports = createAxesOptions;
         }
-        if (this.options.imperial && maxMeters) {
-          this._updateImperial(maxMeters);
+      });
+      var require_spikes = __commonJS({
+        "src/plots/gl3d/layout/spikes.js"(exports, module2) {
+          var str2RGBArray = require_str2rgbarray();
+          var AXES_NAMES = ["xaxis", "yaxis", "zaxis"];
+          function SpikeOptions() {
+            this.enabled = [true, true, true];
+            this.colors = [
+              [0, 0, 0, 1],
+              [0, 0, 0, 1],
+              [0, 0, 0, 1]
+            ];
+            this.drawSides = [true, true, true];
+            this.lineWidth = [1, 1, 1];
+          }
+          var proto = SpikeOptions.prototype;
+          proto.merge = function(sceneLayout) {
+            for (var i2 = 0; i2 < 3; ++i2) {
+              var axes = sceneLayout[AXES_NAMES[i2]];
+              if (!axes.visible) {
+                this.enabled[i2] = false;
+                this.drawSides[i2] = false;
+                continue;
+              }
+              this.enabled[i2] = axes.showspikes;
+              this.colors[i2] = str2RGBArray(axes.spikecolor);
+              this.drawSides[i2] = axes.spikesides;
+              this.lineWidth[i2] = axes.spikethickness;
+            }
+          };
+          function createSpikeOptions(layout) {
+            var result = new SpikeOptions();
+            result.merge(layout);
+            return result;
+          }
+          module2.exports = createSpikeOptions;
         }
-      },
-      _updateMetric: function(maxMeters) {
-        var meters = this._getRoundNum(maxMeters), label = meters < 1e3 ? meters + " m" : meters / 1e3 + " km";
-        this._updateScale(this._mScale, label, meters / maxMeters);
-      },
-      _updateImperial: function(maxMeters) {
-        var maxFeet = maxMeters * 3.2808399, maxMiles, miles, feet;
-        if (maxFeet > 5280) {
-          maxMiles = maxFeet / 5280;
-          miles = this._getRoundNum(maxMiles);
-          this._updateScale(this._iScale, miles + " mi", miles / maxMiles);
-        } else {
-          feet = this._getRoundNum(maxFeet);
-          this._updateScale(this._iScale, feet + " ft", feet / maxFeet);
+      });
+      var require_tick_marks = __commonJS({
+        "src/plots/gl3d/layout/tick_marks.js"(exports, module2) {
+          module2.exports = computeTickMarks;
+          var Axes = require_axes();
+          var Lib = require_lib();
+          var AXES_NAMES = ["xaxis", "yaxis", "zaxis"];
+          function contourLevelsFromTicks(ticks) {
+            var result = new Array(3);
+            for (var i2 = 0; i2 < 3; ++i2) {
+              var tlevel = ticks[i2];
+              var clevel = new Array(tlevel.length);
+              for (var j2 = 0; j2 < tlevel.length; ++j2) {
+                clevel[j2] = tlevel[j2].x;
+              }
+              result[i2] = clevel;
+            }
+            return result;
+          }
+          function computeTickMarks(scene) {
+            var axesOptions = scene.axesOptions;
+            var glRange = scene.glplot.axesPixels;
+            var sceneLayout = scene.fullSceneLayout;
+            var ticks = [[], [], []];
+            for (var i2 = 0; i2 < 3; ++i2) {
+              var axes = sceneLayout[AXES_NAMES[i2]];
+              axes._length = (glRange[i2].hi - glRange[i2].lo) * glRange[i2].pixelsPerDataUnit / scene.dataScale[i2];
+              if (Math.abs(axes._length) === Infinity || isNaN(axes._length)) {
+                ticks[i2] = [];
+              } else {
+                axes._input_range = axes.range.slice();
+                axes.range[0] = glRange[i2].lo / scene.dataScale[i2];
+                axes.range[1] = glRange[i2].hi / scene.dataScale[i2];
+                axes._m = 1 / (scene.dataScale[i2] * glRange[i2].pixelsPerDataUnit);
+                if (axes.range[0] === axes.range[1]) {
+                  axes.range[0] -= 1;
+                  axes.range[1] += 1;
+                }
+                var tickModeCached = axes.tickmode;
+                if (axes.tickmode === "auto") {
+                  axes.tickmode = "linear";
+                  var nticks = axes.nticks || Lib.constrain(axes._length / 40, 4, 9);
+                  Axes.autoTicks(axes, Math.abs(axes.range[1] - axes.range[0]) / nticks);
+                }
+                var dataTicks = Axes.calcTicks(axes, { msUTC: true });
+                for (var j2 = 0; j2 < dataTicks.length; ++j2) {
+                  dataTicks[j2].x = dataTicks[j2].x * scene.dataScale[i2];
+                  if (axes.type === "date") {
+                    dataTicks[j2].text = dataTicks[j2].text.replace(/\<br\>/g, " ");
+                  }
+                }
+                ticks[i2] = dataTicks;
+                axes.tickmode = tickModeCached;
+              }
+            }
+            axesOptions.ticks = ticks;
+            for (var i2 = 0; i2 < 3; ++i2) {
+              0.5 * (scene.glplot.bounds[0][i2] + scene.glplot.bounds[1][i2]);
+              for (var j2 = 0; j2 < 2; ++j2) {
+                axesOptions.bounds[j2][i2] = scene.glplot.bounds[j2][i2];
+              }
+            }
+            scene.contourLevels = contourLevelsFromTicks(ticks);
+          }
         }
-      },
-      _updateScale: function(scale2, text, ratio) {
-        scale2.style.width = Math.round(this.options.maxWidth * ratio) + "px";
-        scale2.innerHTML = text;
-      },
-      _getRoundNum: function(num) {
-        var pow10 = Math.pow(10, (Math.floor(num) + "").length - 1), d = num / pow10;
-        d = d >= 10 ? 10 : d >= 5 ? 5 : d >= 3 ? 3 : d >= 2 ? 2 : 1;
-        return pow10 * d;
-      }
-    });
-    var scale = function(options) {
-      return new Scale2(options);
-    };
-    var ukrainianFlag = '<svg aria-hidden="true" xmlns="http://www.w3.org/2000/svg" width="12" height="8" viewBox="0 0 12 8" class="leaflet-attribution-flag"><path fill="#4C7BE1" d="M0 0h12v4H0z"/><path fill="#FFD500" d="M0 4h12v3H0z"/><path fill="#E0BC00" d="M0 7h12v1H0z"/></svg>';
-    var Attribution = Control.extend({
-      // @section
-      // @aka Control.Attribution options
-      options: {
-        position: "bottomright",
-        // @option prefix: String|false = 'Leaflet'
-        // The HTML text shown before the attributions. Pass `false` to disable.
-        prefix: '<a href="https://leafletjs.com" title="A JavaScript library for interactive maps">' + (Browser.inlineSvg ? ukrainianFlag + " " : "") + "Leaflet</a>"
-      },
-      initialize: function(options) {
-        setOptions2(this, options);
-        this._attributions = {};
-      },
-      onAdd: function(map2) {
-        map2.attributionControl = this;
-        this._container = create$1("div", "leaflet-control-attribution");
-        disableClickPropagation(this._container);
-        for (var i in map2._layers) {
-          if (map2._layers[i].getAttribution) {
-            this.addAttribution(map2._layers[i].getAttribution());
+      });
+      var require_scene = __commonJS({
+        "src/plots/gl3d/scene.js"(exports, module2) {
+          var glPlot3d = require_stackgl_modules().gl_plot3d;
+          var createCamera = glPlot3d.createCamera;
+          var createPlot = glPlot3d.createScene;
+          var getContext = require_webgl_context();
+          var passiveSupported = require_has_passive_events();
+          var Registry = require_registry();
+          var Lib = require_lib();
+          var preserveDrawingBuffer = Lib.preserveDrawingBuffer();
+          var Axes = require_axes();
+          var Fx = require_fx();
+          var str2RGBAarray = require_str2rgbarray();
+          var showNoWebGlMsg = require_show_no_webgl_msg();
+          var project2 = require_project();
+          var createAxesOptions = require_convert3();
+          var createSpikeOptions = require_spikes();
+          var computeTickMarks = require_tick_marks();
+          var applyAutorangeOptions = require_autorange().applyAutorangeOptions;
+          var STATIC_CANVAS;
+          var STATIC_CONTEXT;
+          var tabletmode = false;
+          function Scene(options, fullLayout) {
+            var sceneContainer = document.createElement("div");
+            var plotContainer = options.container;
+            this.graphDiv = options.graphDiv;
+            var svgContainer = document.createElementNS(
+              "http://www.w3.org/2000/svg",
+              "svg"
+            );
+            svgContainer.style.position = "absolute";
+            svgContainer.style.top = svgContainer.style.left = "0px";
+            svgContainer.style.width = svgContainer.style.height = "100%";
+            svgContainer.style["z-index"] = 20;
+            svgContainer.style["pointer-events"] = "none";
+            sceneContainer.appendChild(svgContainer);
+            this.svgContainer = svgContainer;
+            sceneContainer.id = options.id;
+            sceneContainer.style.position = "absolute";
+            sceneContainer.style.top = sceneContainer.style.left = "0px";
+            sceneContainer.style.width = sceneContainer.style.height = "100%";
+            plotContainer.appendChild(sceneContainer);
+            this.fullLayout = fullLayout;
+            this.id = options.id || "scene";
+            this.fullSceneLayout = fullLayout[this.id];
+            this.plotArgs = [[], {}, {}];
+            this.axesOptions = createAxesOptions(fullLayout, fullLayout[this.id]);
+            this.spikeOptions = createSpikeOptions(fullLayout[this.id]);
+            this.container = sceneContainer;
+            this.staticMode = !!options.staticPlot;
+            this.pixelRatio = this.pixelRatio || options.plotGlPixelRatio || 2;
+            this.dataScale = [1, 1, 1];
+            this.contourLevels = [[], [], []];
+            this.convertAnnotations = Registry.getComponentMethod("annotations3d", "convert");
+            this.drawAnnotations = Registry.getComponentMethod("annotations3d", "draw");
+            this.initializeGLPlot();
+          }
+          var proto = Scene.prototype;
+          proto.prepareOptions = function() {
+            var scene = this;
+            var opts = {
+              canvas: scene.canvas,
+              gl: scene.gl,
+              glOptions: {
+                preserveDrawingBuffer,
+                premultipliedAlpha: true,
+                antialias: true
+              },
+              container: scene.container,
+              axes: scene.axesOptions,
+              spikes: scene.spikeOptions,
+              pickRadius: 10,
+              snapToData: true,
+              autoScale: true,
+              autoBounds: false,
+              cameraObject: scene.camera,
+              pixelRatio: scene.pixelRatio
+            };
+            if (scene.staticMode) {
+              if (!STATIC_CONTEXT) {
+                STATIC_CANVAS = document.createElement("canvas");
+                STATIC_CONTEXT = getContext({
+                  canvas: STATIC_CANVAS,
+                  preserveDrawingBuffer: true,
+                  premultipliedAlpha: true,
+                  antialias: true
+                });
+                if (!STATIC_CONTEXT) {
+                  throw new Error("error creating static canvas/context for image server");
+                }
+              }
+              opts.gl = STATIC_CONTEXT;
+              opts.canvas = STATIC_CANVAS;
+            }
+            return opts;
+          };
+          var firstInit = true;
+          proto.tryCreatePlot = function() {
+            var scene = this;
+            var opts = scene.prepareOptions();
+            var success = true;
+            try {
+              scene.glplot = createPlot(opts);
+            } catch (e2) {
+              if (scene.staticMode || !firstInit || preserveDrawingBuffer) {
+                success = false;
+              } else {
+                Lib.warn([
+                  "webgl setup failed possibly due to",
+                  "false preserveDrawingBuffer config.",
+                  "The mobile/tablet device may not be detected by is-mobile module.",
+                  "Enabling preserveDrawingBuffer in second attempt to create webgl scene..."
+                ].join(" "));
+                try {
+                  preserveDrawingBuffer = opts.glOptions.preserveDrawingBuffer = true;
+                  scene.glplot = createPlot(opts);
+                } catch (e22) {
+                  preserveDrawingBuffer = opts.glOptions.preserveDrawingBuffer = false;
+                  success = false;
+                }
+              }
+            }
+            firstInit = false;
+            return success;
+          };
+          proto.initializeGLCamera = function() {
+            var scene = this;
+            var cameraData = scene.fullSceneLayout.camera;
+            var isOrtho = cameraData.projection.type === "orthographic";
+            scene.camera = createCamera(scene.container, {
+              center: [cameraData.center.x, cameraData.center.y, cameraData.center.z],
+              eye: [cameraData.eye.x, cameraData.eye.y, cameraData.eye.z],
+              up: [cameraData.up.x, cameraData.up.y, cameraData.up.z],
+              _ortho: isOrtho,
+              zoomMin: 0.01,
+              zoomMax: 100,
+              mode: "orbit"
+            });
+          };
+          proto.initializeGLPlot = function() {
+            var scene = this;
+            scene.initializeGLCamera();
+            var success = scene.tryCreatePlot();
+            if (!success) return showNoWebGlMsg(scene);
+            scene.traces = {};
+            scene.make4thDimension();
+            var gd2 = scene.graphDiv;
+            var layout = gd2.layout;
+            var makeUpdate = function() {
+              var update = {};
+              if (scene.isCameraChanged(layout)) {
+                update[scene.id + ".camera"] = scene.getCamera();
+              }
+              if (scene.isAspectChanged(layout)) {
+                update[scene.id + ".aspectratio"] = scene.glplot.getAspectratio();
+                if (layout[scene.id].aspectmode !== "manual") {
+                  scene.fullSceneLayout.aspectmode = layout[scene.id].aspectmode = update[scene.id + ".aspectmode"] = "manual";
+                }
+              }
+              return update;
+            };
+            var relayoutCallback = function(scene2) {
+              if (scene2.fullSceneLayout.dragmode === false) return;
+              var update = makeUpdate();
+              scene2.saveLayout(layout);
+              scene2.graphDiv.emit("plotly_relayout", update);
+            };
+            if (scene.glplot.canvas) {
+              scene.glplot.canvas.addEventListener("mouseup", function() {
+                relayoutCallback(scene);
+              });
+              scene.glplot.canvas.addEventListener("touchstart", function() {
+                tabletmode = true;
+              });
+              scene.glplot.canvas.addEventListener("wheel", function(e2) {
+                if (gd2._context._scrollZoom.gl3d) {
+                  if (scene.camera._ortho) {
+                    var s2 = e2.deltaX > e2.deltaY ? 1.1 : 1 / 1.1;
+                    var o2 = scene.glplot.getAspectratio();
+                    scene.glplot.setAspectratio({
+                      x: s2 * o2.x,
+                      y: s2 * o2.y,
+                      z: s2 * o2.z
+                    });
+                  }
+                  relayoutCallback(scene);
+                }
+              }, passiveSupported ? { passive: false } : false);
+              scene.glplot.canvas.addEventListener("mousemove", function() {
+                if (scene.fullSceneLayout.dragmode === false) return;
+                if (scene.camera.mouseListener.buttons === 0) return;
+                var update = makeUpdate();
+                scene.graphDiv.emit("plotly_relayouting", update);
+              });
+              if (!scene.staticMode) {
+                scene.glplot.canvas.addEventListener("webglcontextlost", function(event) {
+                  if (gd2 && gd2.emit) {
+                    gd2.emit("plotly_webglcontextlost", {
+                      event,
+                      layer: scene.id
+                    });
+                  }
+                }, false);
+              }
+            }
+            scene.glplot.oncontextloss = function() {
+              scene.recoverContext();
+            };
+            scene.glplot.onrender = function() {
+              scene.render();
+            };
+            return true;
+          };
+          proto.render = function() {
+            var scene = this;
+            var gd2 = scene.graphDiv;
+            var trace;
+            var svgContainer = scene.svgContainer;
+            var clientRect = scene.container.getBoundingClientRect();
+            gd2._fullLayout._calcInverseTransform(gd2);
+            var scaleX2 = gd2._fullLayout._invScaleX;
+            var scaleY2 = gd2._fullLayout._invScaleY;
+            var width = clientRect.width * scaleX2;
+            var height = clientRect.height * scaleY2;
+            svgContainer.setAttributeNS(null, "viewBox", "0 0 " + width + " " + height);
+            svgContainer.setAttributeNS(null, "width", width);
+            svgContainer.setAttributeNS(null, "height", height);
+            computeTickMarks(scene);
+            scene.glplot.axes.update(scene.axesOptions);
+            var keys = Object.keys(scene.traces);
+            var lastPicked = null;
+            var selection = scene.glplot.selection;
+            for (var i2 = 0; i2 < keys.length; ++i2) {
+              trace = scene.traces[keys[i2]];
+              if (trace.data.hoverinfo !== "skip" && trace.handlePick(selection)) {
+                lastPicked = trace;
+              }
+              if (trace.setContourLevels) trace.setContourLevels();
+            }
+            function formatter(axLetter, val, hoverformat) {
+              var ax = scene.fullSceneLayout[axLetter + "axis"];
+              if (ax.type !== "log") {
+                val = ax.d2l(val);
+              }
+              return Axes.hoverLabelText(ax, val, hoverformat);
+            }
+            if (lastPicked !== null) {
+              var pdata = project2(scene.glplot.cameraParams, selection.dataCoordinate);
+              trace = lastPicked.data;
+              var traceNow = gd2._fullData[trace.index];
+              var ptNumber = selection.index;
+              var labels = {
+                xLabel: formatter("x", selection.traceCoordinate[0], trace.xhoverformat),
+                yLabel: formatter("y", selection.traceCoordinate[1], trace.yhoverformat),
+                zLabel: formatter("z", selection.traceCoordinate[2], trace.zhoverformat)
+              };
+              var hoverinfo = Fx.castHoverinfo(traceNow, scene.fullLayout, ptNumber);
+              var hoverinfoParts = (hoverinfo || "").split("+");
+              var isHoverinfoAll = hoverinfo && hoverinfo === "all";
+              if (!traceNow.hovertemplate && !isHoverinfoAll) {
+                if (hoverinfoParts.indexOf("x") === -1) labels.xLabel = void 0;
+                if (hoverinfoParts.indexOf("y") === -1) labels.yLabel = void 0;
+                if (hoverinfoParts.indexOf("z") === -1) labels.zLabel = void 0;
+                if (hoverinfoParts.indexOf("text") === -1) selection.textLabel = void 0;
+                if (hoverinfoParts.indexOf("name") === -1) lastPicked.name = void 0;
+              }
+              var tx;
+              var vectorTx = [];
+              if (trace.type === "cone" || trace.type === "streamtube") {
+                labels.uLabel = formatter("x", selection.traceCoordinate[3], trace.uhoverformat);
+                if (isHoverinfoAll || hoverinfoParts.indexOf("u") !== -1) {
+                  vectorTx.push("u: " + labels.uLabel);
+                }
+                labels.vLabel = formatter("y", selection.traceCoordinate[4], trace.vhoverformat);
+                if (isHoverinfoAll || hoverinfoParts.indexOf("v") !== -1) {
+                  vectorTx.push("v: " + labels.vLabel);
+                }
+                labels.wLabel = formatter("z", selection.traceCoordinate[5], trace.whoverformat);
+                if (isHoverinfoAll || hoverinfoParts.indexOf("w") !== -1) {
+                  vectorTx.push("w: " + labels.wLabel);
+                }
+                labels.normLabel = selection.traceCoordinate[6].toPrecision(3);
+                if (isHoverinfoAll || hoverinfoParts.indexOf("norm") !== -1) {
+                  vectorTx.push("norm: " + labels.normLabel);
+                }
+                if (trace.type === "streamtube") {
+                  labels.divergenceLabel = selection.traceCoordinate[7].toPrecision(3);
+                  if (isHoverinfoAll || hoverinfoParts.indexOf("divergence") !== -1) {
+                    vectorTx.push("divergence: " + labels.divergenceLabel);
+                  }
+                }
+                if (selection.textLabel) {
+                  vectorTx.push(selection.textLabel);
+                }
+                tx = vectorTx.join("<br>");
+              } else if (trace.type === "isosurface" || trace.type === "volume") {
+                labels.valueLabel = Axes.hoverLabelText(scene._mockAxis, scene._mockAxis.d2l(selection.traceCoordinate[3]), trace.valuehoverformat);
+                vectorTx.push("value: " + labels.valueLabel);
+                if (selection.textLabel) {
+                  vectorTx.push(selection.textLabel);
+                }
+                tx = vectorTx.join("<br>");
+              } else {
+                tx = selection.textLabel;
+              }
+              var pointData = {
+                x: selection.traceCoordinate[0],
+                y: selection.traceCoordinate[1],
+                z: selection.traceCoordinate[2],
+                data: traceNow._input,
+                fullData: traceNow,
+                curveNumber: traceNow.index,
+                pointNumber: ptNumber
+              };
+              Fx.appendArrayPointValue(pointData, traceNow, ptNumber);
+              if (trace._module.eventData) {
+                pointData = traceNow._module.eventData(pointData, selection, traceNow, {}, ptNumber);
+              }
+              var eventData = { points: [pointData] };
+              if (scene.fullSceneLayout.hovermode) {
+                var bbox = [];
+                Fx.loneHover({
+                  trace: traceNow,
+                  x: (0.5 + 0.5 * pdata[0] / pdata[3]) * width,
+                  y: (0.5 - 0.5 * pdata[1] / pdata[3]) * height,
+                  xLabel: labels.xLabel,
+                  yLabel: labels.yLabel,
+                  zLabel: labels.zLabel,
+                  text: tx,
+                  name: lastPicked.name,
+                  color: Fx.castHoverOption(traceNow, ptNumber, "bgcolor") || lastPicked.color,
+                  borderColor: Fx.castHoverOption(traceNow, ptNumber, "bordercolor"),
+                  fontFamily: Fx.castHoverOption(traceNow, ptNumber, "font.family"),
+                  fontSize: Fx.castHoverOption(traceNow, ptNumber, "font.size"),
+                  fontColor: Fx.castHoverOption(traceNow, ptNumber, "font.color"),
+                  nameLength: Fx.castHoverOption(traceNow, ptNumber, "namelength"),
+                  textAlign: Fx.castHoverOption(traceNow, ptNumber, "align"),
+                  hovertemplate: Lib.castOption(traceNow, ptNumber, "hovertemplate"),
+                  hovertemplateLabels: Lib.extendFlat({}, pointData, labels),
+                  eventData: [pointData]
+                }, {
+                  container: svgContainer,
+                  gd: gd2,
+                  inOut_bbox: bbox
+                });
+                pointData.bbox = bbox[0];
+              }
+              if (selection.distance < 5 && (selection.buttons || tabletmode)) {
+                gd2.emit("plotly_click", eventData);
+              } else {
+                gd2.emit("plotly_hover", eventData);
+              }
+              this.oldEventData = eventData;
+            } else {
+              Fx.loneUnhover(svgContainer);
+              if (this.oldEventData) gd2.emit("plotly_unhover", this.oldEventData);
+              this.oldEventData = void 0;
+            }
+            scene.drawAnnotations(scene);
+          };
+          proto.recoverContext = function() {
+            var scene = this;
+            scene.glplot.dispose();
+            var tryRecover = function() {
+              if (scene.glplot.gl.isContextLost()) {
+                requestAnimationFrame(tryRecover);
+                return;
+              }
+              if (!scene.initializeGLPlot()) {
+                Lib.error("Catastrophic and unrecoverable WebGL error. Context lost.");
+                return;
+              }
+              scene.plot.apply(scene, scene.plotArgs);
+            };
+            requestAnimationFrame(tryRecover);
+          };
+          var axisProperties = ["xaxis", "yaxis", "zaxis"];
+          function computeTraceBounds(scene, trace, bounds) {
+            var fullSceneLayout = scene.fullSceneLayout;
+            for (var d2 = 0; d2 < 3; d2++) {
+              var axisName = axisProperties[d2];
+              var axLetter = axisName.charAt(0);
+              var ax = fullSceneLayout[axisName];
+              var coords = trace[axLetter];
+              var calendar = trace[axLetter + "calendar"];
+              var len2 = trace["_" + axLetter + "length"];
+              if (!Lib.isArrayOrTypedArray(coords)) {
+                bounds[0][d2] = Math.min(bounds[0][d2], 0);
+                bounds[1][d2] = Math.max(bounds[1][d2], len2 - 1);
+              } else {
+                var v2;
+                for (var i2 = 0; i2 < (len2 || coords.length); i2++) {
+                  if (Lib.isArrayOrTypedArray(coords[i2])) {
+                    for (var j2 = 0; j2 < coords[i2].length; ++j2) {
+                      v2 = ax.d2l(coords[i2][j2], 0, calendar);
+                      if (!isNaN(v2) && isFinite(v2)) {
+                        bounds[0][d2] = Math.min(bounds[0][d2], v2);
+                        bounds[1][d2] = Math.max(bounds[1][d2], v2);
+                      }
+                    }
+                  } else {
+                    v2 = ax.d2l(coords[i2], 0, calendar);
+                    if (!isNaN(v2) && isFinite(v2)) {
+                      bounds[0][d2] = Math.min(bounds[0][d2], v2);
+                      bounds[1][d2] = Math.max(bounds[1][d2], v2);
+                    }
+                  }
+                }
+              }
+            }
+          }
+          function computeAnnotationBounds(scene, bounds) {
+            var fullSceneLayout = scene.fullSceneLayout;
+            var annotations = fullSceneLayout.annotations || [];
+            for (var d2 = 0; d2 < 3; d2++) {
+              var axisName = axisProperties[d2];
+              var axLetter = axisName.charAt(0);
+              var ax = fullSceneLayout[axisName];
+              for (var j2 = 0; j2 < annotations.length; j2++) {
+                var ann = annotations[j2];
+                if (ann.visible) {
+                  var pos = ax.r2l(ann[axLetter]);
+                  if (!isNaN(pos) && isFinite(pos)) {
+                    bounds[0][d2] = Math.min(bounds[0][d2], pos);
+                    bounds[1][d2] = Math.max(bounds[1][d2], pos);
+                  }
+                }
+              }
+            }
+          }
+          proto.plot = function(sceneData, fullLayout, layout) {
+            var scene = this;
+            scene.plotArgs = [sceneData, fullLayout, layout];
+            if (scene.glplot.contextLost) return;
+            var data, trace;
+            var i2, j2, axis, axisType;
+            var fullSceneLayout = fullLayout[scene.id];
+            var sceneLayout = layout[scene.id];
+            scene.fullLayout = fullLayout;
+            scene.fullSceneLayout = fullSceneLayout;
+            scene.axesOptions.merge(fullLayout, fullSceneLayout);
+            scene.spikeOptions.merge(fullSceneLayout);
+            scene.setViewport(fullSceneLayout);
+            scene.updateFx(fullSceneLayout.dragmode, fullSceneLayout.hovermode);
+            scene.camera.enableWheel = scene.graphDiv._context._scrollZoom.gl3d;
+            scene.glplot.setClearColor(str2RGBAarray(fullSceneLayout.bgcolor));
+            scene.setConvert(axis);
+            if (!sceneData) sceneData = [];
+            else if (!Array.isArray(sceneData)) sceneData = [sceneData];
+            var dataBounds = [
+              [Infinity, Infinity, Infinity],
+              [-Infinity, -Infinity, -Infinity]
+            ];
+            for (i2 = 0; i2 < sceneData.length; ++i2) {
+              data = sceneData[i2];
+              if (data.visible !== true || data._length === 0) continue;
+              computeTraceBounds(this, data, dataBounds);
+            }
+            computeAnnotationBounds(this, dataBounds);
+            var dataScale = [1, 1, 1];
+            for (j2 = 0; j2 < 3; ++j2) {
+              if (dataBounds[1][j2] === dataBounds[0][j2]) {
+                dataScale[j2] = 1;
+              } else {
+                dataScale[j2] = 1 / (dataBounds[1][j2] - dataBounds[0][j2]);
+              }
+            }
+            scene.dataScale = dataScale;
+            scene.convertAnnotations(this);
+            for (i2 = 0; i2 < sceneData.length; ++i2) {
+              data = sceneData[i2];
+              if (data.visible !== true || data._length === 0) {
+                continue;
+              }
+              trace = scene.traces[data.uid];
+              if (trace) {
+                if (trace.data.type === data.type) {
+                  trace.update(data);
+                } else {
+                  trace.dispose();
+                  trace = data._module.plot(this, data);
+                  scene.traces[data.uid] = trace;
+                }
+              } else {
+                trace = data._module.plot(this, data);
+                scene.traces[data.uid] = trace;
+              }
+              trace.name = data.name;
+            }
+            var traceIds = Object.keys(scene.traces);
+            traceIdLoop:
+              for (i2 = 0; i2 < traceIds.length; ++i2) {
+                for (j2 = 0; j2 < sceneData.length; ++j2) {
+                  if (sceneData[j2].uid === traceIds[i2] && (sceneData[j2].visible === true && sceneData[j2]._length !== 0)) {
+                    continue traceIdLoop;
+                  }
+                }
+                trace = scene.traces[traceIds[i2]];
+                trace.dispose();
+                delete scene.traces[traceIds[i2]];
+              }
+            scene.glplot.objects.sort(function(a2, b2) {
+              return a2._trace.data.index - b2._trace.data.index;
+            });
+            var sceneBounds = [[0, 0, 0], [0, 0, 0]];
+            var axisTypeRatios = {};
+            for (i2 = 0; i2 < 3; ++i2) {
+              axis = fullSceneLayout[axisProperties[i2]];
+              axisType = axis.type;
+              if (axisType in axisTypeRatios) {
+                axisTypeRatios[axisType].acc *= dataScale[i2];
+                axisTypeRatios[axisType].count += 1;
+              } else {
+                axisTypeRatios[axisType] = {
+                  acc: dataScale[i2],
+                  count: 1
+                };
+              }
+              var range;
+              if (axis.autorange) {
+                sceneBounds[0][i2] = Infinity;
+                sceneBounds[1][i2] = -Infinity;
+                var objects = scene.glplot.objects;
+                var annotations = scene.fullSceneLayout.annotations || [];
+                var axLetter = axis._name.charAt(0);
+                for (j2 = 0; j2 < objects.length; j2++) {
+                  var obj = objects[j2];
+                  var objBounds = obj.bounds;
+                  var pad = obj._trace.data._pad || 0;
+                  if (obj.constructor.name === "ErrorBars" && axis._lowerLogErrorBound) {
+                    sceneBounds[0][i2] = Math.min(sceneBounds[0][i2], axis._lowerLogErrorBound);
+                  } else {
+                    sceneBounds[0][i2] = Math.min(sceneBounds[0][i2], objBounds[0][i2] / dataScale[i2] - pad);
+                  }
+                  sceneBounds[1][i2] = Math.max(sceneBounds[1][i2], objBounds[1][i2] / dataScale[i2] + pad);
+                }
+                for (j2 = 0; j2 < annotations.length; j2++) {
+                  var ann = annotations[j2];
+                  if (ann.visible) {
+                    var pos = axis.r2l(ann[axLetter]);
+                    sceneBounds[0][i2] = Math.min(sceneBounds[0][i2], pos);
+                    sceneBounds[1][i2] = Math.max(sceneBounds[1][i2], pos);
+                  }
+                }
+                if ("rangemode" in axis && axis.rangemode === "tozero") {
+                  sceneBounds[0][i2] = Math.min(sceneBounds[0][i2], 0);
+                  sceneBounds[1][i2] = Math.max(sceneBounds[1][i2], 0);
+                }
+                if (sceneBounds[0][i2] > sceneBounds[1][i2]) {
+                  sceneBounds[0][i2] = -1;
+                  sceneBounds[1][i2] = 1;
+                } else {
+                  var d2 = sceneBounds[1][i2] - sceneBounds[0][i2];
+                  sceneBounds[0][i2] -= d2 / 32;
+                  sceneBounds[1][i2] += d2 / 32;
+                }
+                range = [
+                  sceneBounds[0][i2],
+                  sceneBounds[1][i2]
+                ];
+                range = applyAutorangeOptions(range, axis);
+                sceneBounds[0][i2] = range[0];
+                sceneBounds[1][i2] = range[1];
+                if (axis.isReversed()) {
+                  var tmp2 = sceneBounds[0][i2];
+                  sceneBounds[0][i2] = sceneBounds[1][i2];
+                  sceneBounds[1][i2] = tmp2;
+                }
+              } else {
+                range = axis.range;
+                sceneBounds[0][i2] = axis.r2l(range[0]);
+                sceneBounds[1][i2] = axis.r2l(range[1]);
+              }
+              if (sceneBounds[0][i2] === sceneBounds[1][i2]) {
+                sceneBounds[0][i2] -= 1;
+                sceneBounds[1][i2] += 1;
+              }
+              axis.range = [
+                sceneBounds[0][i2],
+                sceneBounds[1][i2]
+              ];
+              axis.limitRange();
+              scene.glplot.setBounds(i2, {
+                min: axis.range[0] * dataScale[i2],
+                max: axis.range[1] * dataScale[i2]
+              });
+            }
+            var aspectRatio;
+            var aspectmode = fullSceneLayout.aspectmode;
+            if (aspectmode === "cube") {
+              aspectRatio = [1, 1, 1];
+            } else if (aspectmode === "manual") {
+              var userRatio = fullSceneLayout.aspectratio;
+              aspectRatio = [userRatio.x, userRatio.y, userRatio.z];
+            } else if (aspectmode === "auto" || aspectmode === "data") {
+              var axesScaleRatio = [1, 1, 1];
+              for (i2 = 0; i2 < 3; ++i2) {
+                axis = fullSceneLayout[axisProperties[i2]];
+                axisType = axis.type;
+                var axisRatio = axisTypeRatios[axisType];
+                axesScaleRatio[i2] = Math.pow(axisRatio.acc, 1 / axisRatio.count) / dataScale[i2];
+              }
+              if (aspectmode === "data") {
+                aspectRatio = axesScaleRatio;
+              } else {
+                if (Math.max.apply(null, axesScaleRatio) / Math.min.apply(null, axesScaleRatio) <= 4) {
+                  aspectRatio = axesScaleRatio;
+                } else {
+                  aspectRatio = [1, 1, 1];
+                }
+              }
+            } else {
+              throw new Error("scene.js aspectRatio was not one of the enumerated types");
+            }
+            fullSceneLayout.aspectratio.x = sceneLayout.aspectratio.x = aspectRatio[0];
+            fullSceneLayout.aspectratio.y = sceneLayout.aspectratio.y = aspectRatio[1];
+            fullSceneLayout.aspectratio.z = sceneLayout.aspectratio.z = aspectRatio[2];
+            scene.glplot.setAspectratio(fullSceneLayout.aspectratio);
+            if (!scene.viewInitial.aspectratio) {
+              scene.viewInitial.aspectratio = {
+                x: fullSceneLayout.aspectratio.x,
+                y: fullSceneLayout.aspectratio.y,
+                z: fullSceneLayout.aspectratio.z
+              };
+            }
+            if (!scene.viewInitial.aspectmode) {
+              scene.viewInitial.aspectmode = fullSceneLayout.aspectmode;
+            }
+            var domain = fullSceneLayout.domain || null;
+            var size = fullLayout._size || null;
+            if (domain && size) {
+              var containerStyle = scene.container.style;
+              containerStyle.position = "absolute";
+              containerStyle.left = size.l + domain.x[0] * size.w + "px";
+              containerStyle.top = size.t + (1 - domain.y[1]) * size.h + "px";
+              containerStyle.width = size.w * (domain.x[1] - domain.x[0]) + "px";
+              containerStyle.height = size.h * (domain.y[1] - domain.y[0]) + "px";
+            }
+            scene.glplot.redraw();
+          };
+          proto.destroy = function() {
+            var scene = this;
+            if (!scene.glplot) return;
+            scene.camera.mouseListener.enabled = false;
+            scene.container.removeEventListener("wheel", scene.camera.wheelListener);
+            scene.camera = null;
+            scene.glplot.dispose();
+            scene.container.parentNode.removeChild(scene.container);
+            scene.glplot = null;
+          };
+          function getCameraArrays(camera) {
+            return [
+              [camera.eye.x, camera.eye.y, camera.eye.z],
+              [camera.center.x, camera.center.y, camera.center.z],
+              [camera.up.x, camera.up.y, camera.up.z]
+            ];
+          }
+          function getLayoutCamera(camera) {
+            return {
+              up: { x: camera.up[0], y: camera.up[1], z: camera.up[2] },
+              center: { x: camera.center[0], y: camera.center[1], z: camera.center[2] },
+              eye: { x: camera.eye[0], y: camera.eye[1], z: camera.eye[2] },
+              projection: { type: camera._ortho === true ? "orthographic" : "perspective" }
+            };
+          }
+          proto.getCamera = function() {
+            var scene = this;
+            scene.camera.view.recalcMatrix(scene.camera.view.lastT());
+            return getLayoutCamera(scene.camera);
+          };
+          proto.setViewport = function(sceneLayout) {
+            var scene = this;
+            var cameraData = sceneLayout.camera;
+            scene.camera.lookAt.apply(this, getCameraArrays(cameraData));
+            scene.glplot.setAspectratio(sceneLayout.aspectratio);
+            var newOrtho = cameraData.projection.type === "orthographic";
+            var oldOrtho = scene.camera._ortho;
+            if (newOrtho !== oldOrtho) {
+              scene.glplot.redraw();
+              scene.glplot.clearRGBA();
+              scene.glplot.dispose();
+              scene.initializeGLPlot();
+            }
+          };
+          proto.isCameraChanged = function(layout) {
+            var scene = this;
+            var cameraData = scene.getCamera();
+            var cameraNestedProp = Lib.nestedProperty(layout, scene.id + ".camera");
+            var cameraDataLastSave = cameraNestedProp.get();
+            function same(x2, y2, i22, j22) {
+              var vectors = ["up", "center", "eye"];
+              var components = ["x", "y", "z"];
+              return y2[vectors[i22]] && x2[vectors[i22]][components[j22]] === y2[vectors[i22]][components[j22]];
+            }
+            var changed = false;
+            if (cameraDataLastSave === void 0) {
+              changed = true;
+            } else {
+              for (var i2 = 0; i2 < 3; i2++) {
+                for (var j2 = 0; j2 < 3; j2++) {
+                  if (!same(cameraData, cameraDataLastSave, i2, j2)) {
+                    changed = true;
+                    break;
+                  }
+                }
+              }
+              if (!cameraDataLastSave.projection || cameraData.projection && cameraData.projection.type !== cameraDataLastSave.projection.type) {
+                changed = true;
+              }
+            }
+            return changed;
+          };
+          proto.isAspectChanged = function(layout) {
+            var scene = this;
+            var aspectData = scene.glplot.getAspectratio();
+            var aspectNestedProp = Lib.nestedProperty(layout, scene.id + ".aspectratio");
+            var aspectDataLastSave = aspectNestedProp.get();
+            return aspectDataLastSave === void 0 || (aspectDataLastSave.x !== aspectData.x || aspectDataLastSave.y !== aspectData.y || aspectDataLastSave.z !== aspectData.z);
+          };
+          proto.saveLayout = function(layout) {
+            var scene = this;
+            var fullLayout = scene.fullLayout;
+            var cameraData;
+            var cameraNestedProp;
+            var cameraDataLastSave;
+            var aspectData;
+            var aspectNestedProp;
+            var aspectDataLastSave;
+            var cameraChanged = scene.isCameraChanged(layout);
+            var aspectChanged = scene.isAspectChanged(layout);
+            var hasChanged = cameraChanged || aspectChanged;
+            if (hasChanged) {
+              var preGUI = {};
+              if (cameraChanged) {
+                cameraData = scene.getCamera();
+                cameraNestedProp = Lib.nestedProperty(layout, scene.id + ".camera");
+                cameraDataLastSave = cameraNestedProp.get();
+                preGUI[scene.id + ".camera"] = cameraDataLastSave;
+              }
+              if (aspectChanged) {
+                aspectData = scene.glplot.getAspectratio();
+                aspectNestedProp = Lib.nestedProperty(layout, scene.id + ".aspectratio");
+                aspectDataLastSave = aspectNestedProp.get();
+                preGUI[scene.id + ".aspectratio"] = aspectDataLastSave;
+              }
+              Registry.call("_storeDirectGUIEdit", layout, fullLayout._preGUI, preGUI);
+              if (cameraChanged) {
+                cameraNestedProp.set(cameraData);
+                var cameraFullNP = Lib.nestedProperty(fullLayout, scene.id + ".camera");
+                cameraFullNP.set(cameraData);
+              }
+              if (aspectChanged) {
+                aspectNestedProp.set(aspectData);
+                var aspectFullNP = Lib.nestedProperty(fullLayout, scene.id + ".aspectratio");
+                aspectFullNP.set(aspectData);
+                scene.glplot.redraw();
+              }
+            }
+            return hasChanged;
+          };
+          proto.updateFx = function(dragmode, hovermode) {
+            var scene = this;
+            var camera = scene.camera;
+            if (camera) {
+              if (dragmode === "orbit") {
+                camera.mode = "orbit";
+                camera.keyBindingMode = "rotate";
+              } else if (dragmode === "turntable") {
+                camera.up = [0, 0, 1];
+                camera.mode = "turntable";
+                camera.keyBindingMode = "rotate";
+                var gd2 = scene.graphDiv;
+                var fullLayout = gd2._fullLayout;
+                var fullCamera = scene.fullSceneLayout.camera;
+                var x2 = fullCamera.up.x;
+                var y2 = fullCamera.up.y;
+                var z2 = fullCamera.up.z;
+                if (z2 / Math.sqrt(x2 * x2 + y2 * y2 + z2 * z2) < 0.999) {
+                  var attr = scene.id + ".camera.up";
+                  var zUp = { x: 0, y: 0, z: 1 };
+                  var edits = {};
+                  edits[attr] = zUp;
+                  var layout = gd2.layout;
+                  Registry.call("_storeDirectGUIEdit", layout, fullLayout._preGUI, edits);
+                  fullCamera.up = zUp;
+                  Lib.nestedProperty(layout, attr).set(zUp);
+                }
+              } else {
+                camera.keyBindingMode = dragmode;
+              }
+            }
+            scene.fullSceneLayout.hovermode = hovermode;
+          };
+          function flipPixels(pixels, w2, h2) {
+            for (var i2 = 0, q2 = h2 - 1; i2 < q2; ++i2, --q2) {
+              for (var j2 = 0; j2 < w2; ++j2) {
+                for (var k2 = 0; k2 < 4; ++k2) {
+                  var a2 = 4 * (w2 * i2 + j2) + k2;
+                  var b2 = 4 * (w2 * q2 + j2) + k2;
+                  var tmp2 = pixels[a2];
+                  pixels[a2] = pixels[b2];
+                  pixels[b2] = tmp2;
+                }
+              }
+            }
           }
-        }
-        this._update();
-        map2.on("layeradd", this._addAttribution, this);
-        return this._container;
-      },
-      onRemove: function(map2) {
-        map2.off("layeradd", this._addAttribution, this);
-      },
-      _addAttribution: function(ev) {
-        if (ev.layer.getAttribution) {
-          this.addAttribution(ev.layer.getAttribution());
-          ev.layer.once("remove", function() {
-            this.removeAttribution(ev.layer.getAttribution());
-          }, this);
-        }
-      },
-      // @method setPrefix(prefix: String|false): this
-      // The HTML text shown before the attributions. Pass `false` to disable.
-      setPrefix: function(prefix) {
-        this.options.prefix = prefix;
-        this._update();
-        return this;
-      },
-      // @method addAttribution(text: String): this
-      // Adds an attribution text (e.g. `'&copy; OpenStreetMap contributors'`).
-      addAttribution: function(text) {
-        if (!text) {
-          return this;
-        }
-        if (!this._attributions[text]) {
-          this._attributions[text] = 0;
-        }
-        this._attributions[text]++;
-        this._update();
-        return this;
-      },
-      // @method removeAttribution(text: String): this
-      // Removes an attribution text.
-      removeAttribution: function(text) {
-        if (!text) {
-          return this;
-        }
-        if (this._attributions[text]) {
-          this._attributions[text]--;
-          this._update();
-        }
-        return this;
-      },
-      _update: function() {
-        if (!this._map) {
-          return;
-        }
-        var attribs = [];
-        for (var i in this._attributions) {
-          if (this._attributions[i]) {
-            attribs.push(i);
+          function correctRGB(pixels, w2, h2) {
+            for (var i2 = 0; i2 < h2; ++i2) {
+              for (var j2 = 0; j2 < w2; ++j2) {
+                var k2 = 4 * (w2 * i2 + j2);
+                var a2 = pixels[k2 + 3];
+                if (a2 > 0) {
+                  var q2 = 255 / a2;
+                  for (var l2 = 0; l2 < 3; ++l2) {
+                    pixels[k2 + l2] = Math.min(q2 * pixels[k2 + l2], 255);
+                  }
+                }
+              }
+            }
           }
+          proto.toImage = function(format) {
+            var scene = this;
+            if (!format) format = "png";
+            if (scene.staticMode) scene.container.appendChild(STATIC_CANVAS);
+            scene.glplot.redraw();
+            var gl2 = scene.glplot.gl;
+            var w2 = gl2.drawingBufferWidth;
+            var h2 = gl2.drawingBufferHeight;
+            gl2.bindFramebuffer(gl2.FRAMEBUFFER, null);
+            var pixels = new Uint8Array(w2 * h2 * 4);
+            gl2.readPixels(0, 0, w2, h2, gl2.RGBA, gl2.UNSIGNED_BYTE, pixels);
+            flipPixels(pixels, w2, h2);
+            correctRGB(pixels, w2, h2);
+            var canvas2 = document.createElement("canvas");
+            canvas2.width = w2;
+            canvas2.height = h2;
+            var context = canvas2.getContext("2d", { willReadFrequently: true });
+            var imageData = context.createImageData(w2, h2);
+            imageData.data.set(pixels);
+            context.putImageData(imageData, 0, 0);
+            var dataURL;
+            switch (format) {
+              case "jpeg":
+                dataURL = canvas2.toDataURL("image/jpeg");
+                break;
+              case "webp":
+                dataURL = canvas2.toDataURL("image/webp");
+                break;
+              default:
+                dataURL = canvas2.toDataURL("image/png");
+            }
+            if (scene.staticMode) scene.container.removeChild(STATIC_CANVAS);
+            return dataURL;
+          };
+          proto.setConvert = function() {
+            var scene = this;
+            for (var i2 = 0; i2 < 3; i2++) {
+              var ax = scene.fullSceneLayout[axisProperties[i2]];
+              Axes.setConvert(ax, scene.fullLayout);
+              ax.setScale = Lib.noop;
+            }
+          };
+          proto.make4thDimension = function() {
+            var scene = this;
+            var gd2 = scene.graphDiv;
+            var fullLayout = gd2._fullLayout;
+            scene._mockAxis = {
+              type: "linear",
+              showexponent: "all",
+              exponentformat: "B"
+            };
+            Axes.setConvert(scene._mockAxis, fullLayout);
+          };
+          module2.exports = Scene;
         }
-        var prefixAndAttribs = [];
-        if (this.options.prefix) {
-          prefixAndAttribs.push(this.options.prefix);
-        }
-        if (attribs.length) {
-          prefixAndAttribs.push(attribs.join(", "));
+      });
+      var require_attributes41 = __commonJS({
+        "src/plots/gl3d/layout/attributes.js"(exports, module2) {
+          module2.exports = {
+            scene: {
+              valType: "subplotid",
+              dflt: "scene",
+              editType: "calc+clearAxisTypes"
+            }
+          };
         }
-        this._container.innerHTML = prefixAndAttribs.join(' <span aria-hidden="true">|</span> ');
-      }
-    });
-    Map2.mergeOptions({
-      attributionControl: true
-    });
-    Map2.addInitHook(function() {
-      if (this.options.attributionControl) {
-        new Attribution().addTo(this);
-      }
-    });
-    var attribution = function(options) {
-      return new Attribution(options);
-    };
-    Control.Layers = Layers;
-    Control.Zoom = Zoom;
-    Control.Scale = Scale2;
-    Control.Attribution = Attribution;
-    control.layers = layers;
-    control.zoom = zoom;
-    control.scale = scale;
-    control.attribution = attribution;
-    var Handler = Class.extend({
-      initialize: function(map2) {
-        this._map = map2;
-      },
-      // @method enable(): this
-      // Enables the handler
-      enable: function() {
-        if (this._enabled) {
-          return this;
+      });
+      var require_axis_attributes = __commonJS({
+        "src/plots/gl3d/layout/axis_attributes.js"(exports, module2) {
+          var Color2 = require_color();
+          var axesAttrs = require_layout_attributes4();
+          var extendFlat = require_extend().extendFlat;
+          var overrideAll = require_edit_types().overrideAll;
+          module2.exports = overrideAll({
+            visible: axesAttrs.visible,
+            showspikes: {
+              valType: "boolean",
+              dflt: true
+            },
+            spikesides: {
+              valType: "boolean",
+              dflt: true
+            },
+            spikethickness: {
+              valType: "number",
+              min: 0,
+              dflt: 2
+            },
+            spikecolor: {
+              valType: "color",
+              dflt: Color2.defaultLine
+            },
+            showbackground: {
+              valType: "boolean",
+              dflt: false
+            },
+            backgroundcolor: {
+              valType: "color",
+              dflt: "rgba(204, 204, 204, 0.5)"
+            },
+            showaxeslabels: {
+              valType: "boolean",
+              dflt: true
+            },
+            color: axesAttrs.color,
+            categoryorder: axesAttrs.categoryorder,
+            categoryarray: axesAttrs.categoryarray,
+            title: {
+              text: axesAttrs.title.text,
+              font: axesAttrs.title.font
+            },
+            type: extendFlat({}, axesAttrs.type, {
+              values: ["-", "linear", "log", "date", "category"]
+            }),
+            autotypenumbers: axesAttrs.autotypenumbers,
+            autorange: axesAttrs.autorange,
+            autorangeoptions: {
+              minallowed: axesAttrs.autorangeoptions.minallowed,
+              maxallowed: axesAttrs.autorangeoptions.maxallowed,
+              clipmin: axesAttrs.autorangeoptions.clipmin,
+              clipmax: axesAttrs.autorangeoptions.clipmax,
+              include: axesAttrs.autorangeoptions.include,
+              editType: "plot"
+            },
+            rangemode: axesAttrs.rangemode,
+            minallowed: axesAttrs.minallowed,
+            maxallowed: axesAttrs.maxallowed,
+            range: extendFlat({}, axesAttrs.range, {
+              items: [
+                { valType: "any", editType: "plot", impliedEdits: { "^autorange": false } },
+                { valType: "any", editType: "plot", impliedEdits: { "^autorange": false } }
+              ],
+              anim: false
+            }),
+            // ticks
+            tickmode: axesAttrs.minor.tickmode,
+            nticks: axesAttrs.nticks,
+            tick0: axesAttrs.tick0,
+            dtick: axesAttrs.dtick,
+            tickvals: axesAttrs.tickvals,
+            ticktext: axesAttrs.ticktext,
+            ticks: axesAttrs.ticks,
+            mirror: axesAttrs.mirror,
+            ticklen: axesAttrs.ticklen,
+            tickwidth: axesAttrs.tickwidth,
+            tickcolor: axesAttrs.tickcolor,
+            showticklabels: axesAttrs.showticklabels,
+            labelalias: axesAttrs.labelalias,
+            tickfont: axesAttrs.tickfont,
+            tickangle: axesAttrs.tickangle,
+            tickprefix: axesAttrs.tickprefix,
+            showtickprefix: axesAttrs.showtickprefix,
+            ticksuffix: axesAttrs.ticksuffix,
+            showticksuffix: axesAttrs.showticksuffix,
+            showexponent: axesAttrs.showexponent,
+            exponentformat: axesAttrs.exponentformat,
+            minexponent: axesAttrs.minexponent,
+            separatethousands: axesAttrs.separatethousands,
+            tickformat: axesAttrs.tickformat,
+            tickformatstops: axesAttrs.tickformatstops,
+            hoverformat: axesAttrs.hoverformat,
+            // lines and grids
+            showline: axesAttrs.showline,
+            linecolor: axesAttrs.linecolor,
+            linewidth: axesAttrs.linewidth,
+            showgrid: axesAttrs.showgrid,
+            gridcolor: extendFlat(
+              {},
+              axesAttrs.gridcolor,
+              // shouldn't this be on-par with 2D?
+              { dflt: "rgb(204, 204, 204)" }
+            ),
+            gridwidth: axesAttrs.gridwidth,
+            zeroline: axesAttrs.zeroline,
+            zerolinecolor: axesAttrs.zerolinecolor,
+            zerolinewidth: axesAttrs.zerolinewidth
+          }, "plot", "from-root");
         }
-        this._enabled = true;
-        this.addHooks();
-        return this;
-      },
-      // @method disable(): this
-      // Disables the handler
-      disable: function() {
-        if (!this._enabled) {
-          return this;
+      });
+      var require_layout_attributes17 = __commonJS({
+        "src/plots/gl3d/layout/layout_attributes.js"(exports, module2) {
+          var gl3dAxisAttrs = require_axis_attributes();
+          var domainAttrs = require_domain().attributes;
+          var extendFlat = require_extend().extendFlat;
+          var counterRegex = require_lib().counterRegex;
+          function makeCameraVector(x2, y2, z2) {
+            return {
+              x: {
+                valType: "number",
+                dflt: x2,
+                editType: "camera"
+              },
+              y: {
+                valType: "number",
+                dflt: y2,
+                editType: "camera"
+              },
+              z: {
+                valType: "number",
+                dflt: z2,
+                editType: "camera"
+              },
+              editType: "camera"
+            };
+          }
+          module2.exports = {
+            _arrayAttrRegexps: [counterRegex("scene", ".annotations", true)],
+            bgcolor: {
+              valType: "color",
+              dflt: "rgba(0,0,0,0)",
+              editType: "plot"
+            },
+            camera: {
+              up: extendFlat(makeCameraVector(0, 0, 1), {}),
+              center: extendFlat(makeCameraVector(0, 0, 0), {}),
+              eye: extendFlat(makeCameraVector(1.25, 1.25, 1.25), {}),
+              projection: {
+                type: {
+                  valType: "enumerated",
+                  values: ["perspective", "orthographic"],
+                  dflt: "perspective",
+                  editType: "calc"
+                },
+                editType: "calc"
+              },
+              editType: "camera"
+            },
+            domain: domainAttrs({ name: "scene", editType: "plot" }),
+            aspectmode: {
+              valType: "enumerated",
+              values: ["auto", "cube", "data", "manual"],
+              dflt: "auto",
+              editType: "plot",
+              impliedEdits: {
+                "aspectratio.x": void 0,
+                "aspectratio.y": void 0,
+                "aspectratio.z": void 0
+              }
+            },
+            aspectratio: {
+              // must be positive (0's are coerced to 1)
+              x: {
+                valType: "number",
+                min: 0,
+                editType: "plot",
+                impliedEdits: { "^aspectmode": "manual" }
+              },
+              y: {
+                valType: "number",
+                min: 0,
+                editType: "plot",
+                impliedEdits: { "^aspectmode": "manual" }
+              },
+              z: {
+                valType: "number",
+                min: 0,
+                editType: "plot",
+                impliedEdits: { "^aspectmode": "manual" }
+              },
+              editType: "plot",
+              impliedEdits: { aspectmode: "manual" }
+            },
+            xaxis: gl3dAxisAttrs,
+            yaxis: gl3dAxisAttrs,
+            zaxis: gl3dAxisAttrs,
+            dragmode: {
+              valType: "enumerated",
+              values: ["orbit", "turntable", "zoom", "pan", false],
+              editType: "plot"
+            },
+            hovermode: {
+              valType: "enumerated",
+              values: ["closest", false],
+              dflt: "closest",
+              editType: "modebar"
+            },
+            uirevision: {
+              valType: "any",
+              editType: "none"
+            },
+            editType: "plot"
+          };
         }
-        this._enabled = false;
-        this.removeHooks();
-        return this;
-      },
-      // @method enabled(): Boolean
-      // Returns `true` if the handler is enabled
-      enabled: function() {
-        return !!this._enabled;
-      }
-      // @section Extension methods
-      // Classes inheriting from `Handler` must implement the two following methods:
-      // @method addHooks()
-      // Called when the handler is enabled, should add event hooks.
-      // @method removeHooks()
-      // Called when the handler is disabled, should remove the event hooks added previously.
-    });
-    Handler.addTo = function(map2, name) {
-      map2.addHandler(name, this);
-      return this;
-    };
-    var Mixin = { Events };
-    var START = Browser.touch ? "touchstart mousedown" : "mousedown";
-    var Draggable = Evented.extend({
-      options: {
-        // @section
-        // @aka Draggable options
-        // @option clickTolerance: Number = 3
-        // The max number of pixels a user can shift the mouse pointer during a click
-        // for it to be considered a valid click (as opposed to a mouse drag).
-        clickTolerance: 3
-      },
-      // @constructor L.Draggable(el: HTMLElement, dragHandle?: HTMLElement, preventOutline?: Boolean, options?: Draggable options)
-      // Creates a `Draggable` object for moving `el` when you start dragging the `dragHandle` element (equals `el` itself by default).
-      initialize: function(element, dragStartTarget, preventOutline2, options) {
-        setOptions2(this, options);
-        this._element = element;
-        this._dragStartTarget = dragStartTarget || element;
-        this._preventOutline = preventOutline2;
-      },
-      // @method enable()
-      // Enables the dragging ability
-      enable: function() {
-        if (this._enabled) {
-          return;
+      });
+      var require_axis_defaults2 = __commonJS({
+        "src/plots/gl3d/layout/axis_defaults.js"(exports, module2) {
+          var colorMix = require_tinycolor().mix;
+          var Lib = require_lib();
+          var Template = require_plot_template();
+          var layoutAttributes = require_axis_attributes();
+          var handleTypeDefaults = require_type_defaults();
+          var handleAxisDefaults = require_axis_defaults();
+          var axesNames = ["xaxis", "yaxis", "zaxis"];
+          var gridLightness = 100 * (204 - 68) / (255 - 68);
+          module2.exports = function supplyLayoutDefaults(layoutIn, layoutOut, options) {
+            var containerIn, containerOut;
+            function coerce(attr, dflt) {
+              return Lib.coerce(containerIn, containerOut, layoutAttributes, attr, dflt);
+            }
+            for (var j2 = 0; j2 < axesNames.length; j2++) {
+              var axName = axesNames[j2];
+              containerIn = layoutIn[axName] || {};
+              containerOut = Template.newContainer(layoutOut, axName);
+              containerOut._id = axName[0] + options.scene;
+              containerOut._name = axName;
+              handleTypeDefaults(containerIn, containerOut, coerce, options);
+              handleAxisDefaults(
+                containerIn,
+                containerOut,
+                coerce,
+                {
+                  font: options.font,
+                  letter: axName[0],
+                  data: options.data,
+                  showGrid: true,
+                  noAutotickangles: true,
+                  noMinorloglabels: true,
+                  noTicklabelindex: true,
+                  noTickson: true,
+                  noTicklabelmode: true,
+                  noTicklabelshift: true,
+                  noTicklabelstandoff: true,
+                  noTicklabelstep: true,
+                  noTicklabelposition: true,
+                  noTicklabeloverflow: true,
+                  noInsiderange: true,
+                  noUnifiedhovertitle: true,
+                  bgColor: options.bgColor,
+                  calendar: options.calendar
+                },
+                options.fullLayout
+              );
+              coerce("gridcolor", colorMix(containerOut.color, options.bgColor, gridLightness).toRgbString());
+              coerce("title.text", axName[0]);
+              containerOut.setScale = Lib.noop;
+              if (coerce("showspikes")) {
+                coerce("spikesides");
+                coerce("spikethickness");
+                coerce("spikecolor", containerOut.color);
+              }
+              coerce("showaxeslabels");
+              if (coerce("showbackground")) coerce("backgroundcolor");
+            }
+          };
         }
-        on(this._dragStartTarget, START, this._onDown, this);
-        this._enabled = true;
-      },
-      // @method disable()
-      // Disables the dragging ability
-      disable: function() {
-        if (!this._enabled) {
-          return;
+      });
+      var require_defaults37 = __commonJS({
+        "src/plots/gl3d/layout/defaults.js"(exports, module2) {
+          var Lib = require_lib();
+          var Color2 = require_color();
+          var Registry = require_registry();
+          var handleSubplotDefaults = require_subplot_defaults();
+          var supplyGl3dAxisLayoutDefaults = require_axis_defaults2();
+          var layoutAttributes = require_layout_attributes17();
+          var getSubplotData = require_get_data().getSubplotData;
+          var GL3D = "gl3d";
+          module2.exports = function supplyLayoutDefaults(layoutIn, layoutOut, fullData) {
+            var hasNon3D = layoutOut._basePlotModules.length > 1;
+            function getDfltFromLayout(attr) {
+              if (hasNon3D) return;
+              var isValid = Lib.validate(layoutIn[attr], layoutAttributes[attr]);
+              if (isValid) return layoutIn[attr];
+            }
+            handleSubplotDefaults(layoutIn, layoutOut, fullData, {
+              type: GL3D,
+              attributes: layoutAttributes,
+              handleDefaults: handleGl3dDefaults,
+              fullLayout: layoutOut,
+              font: layoutOut.font,
+              fullData,
+              getDfltFromLayout,
+              autotypenumbersDflt: layoutOut.autotypenumbers,
+              paper_bgcolor: layoutOut.paper_bgcolor,
+              calendar: layoutOut.calendar
+            });
+          };
+          function handleGl3dDefaults(sceneLayoutIn, sceneLayoutOut, coerce, opts) {
+            var bgcolor = coerce("bgcolor");
+            var bgColorCombined = Color2.combine(bgcolor, opts.paper_bgcolor);
+            var cameraKeys = ["up", "center", "eye"];
+            for (var j2 = 0; j2 < cameraKeys.length; j2++) {
+              coerce("camera." + cameraKeys[j2] + ".x");
+              coerce("camera." + cameraKeys[j2] + ".y");
+              coerce("camera." + cameraKeys[j2] + ".z");
+            }
+            coerce("camera.projection.type");
+            var hasAspect = !!coerce("aspectratio.x") && !!coerce("aspectratio.y") && !!coerce("aspectratio.z");
+            var defaultAspectMode = hasAspect ? "manual" : "auto";
+            var aspectMode = coerce("aspectmode", defaultAspectMode);
+            if (!hasAspect) {
+              sceneLayoutIn.aspectratio = sceneLayoutOut.aspectratio = { x: 1, y: 1, z: 1 };
+              if (aspectMode === "manual") sceneLayoutOut.aspectmode = "auto";
+              sceneLayoutIn.aspectmode = sceneLayoutOut.aspectmode;
+            }
+            var fullGl3dData = getSubplotData(opts.fullData, GL3D, opts.id);
+            supplyGl3dAxisLayoutDefaults(sceneLayoutIn, sceneLayoutOut, {
+              font: opts.font,
+              scene: opts.id,
+              data: fullGl3dData,
+              bgColor: bgColorCombined,
+              calendar: opts.calendar,
+              autotypenumbersDflt: opts.autotypenumbersDflt,
+              fullLayout: opts.fullLayout
+            });
+            Registry.getComponentMethod("annotations3d", "handleDefaults")(
+              sceneLayoutIn,
+              sceneLayoutOut,
+              opts
+            );
+            var dragmode = opts.getDfltFromLayout("dragmode");
+            if (dragmode !== false) {
+              if (!dragmode) {
+                dragmode = "orbit";
+                if (sceneLayoutIn.camera && sceneLayoutIn.camera.up) {
+                  var x2 = sceneLayoutIn.camera.up.x;
+                  var y2 = sceneLayoutIn.camera.up.y;
+                  var z2 = sceneLayoutIn.camera.up.z;
+                  if (z2 !== 0) {
+                    if (!x2 || !y2 || !z2) {
+                      dragmode = "turntable";
+                    } else if (z2 / Math.sqrt(x2 * x2 + y2 * y2 + z2 * z2) > 0.999) {
+                      dragmode = "turntable";
+                    }
+                  }
+                } else {
+                  dragmode = "turntable";
+                }
+              }
+            }
+            coerce("dragmode", dragmode);
+            coerce("hovermode", opts.getDfltFromLayout("hovermode"));
+          }
         }
-        if (Draggable._dragging === this) {
-          this.finishDrag(true);
+      });
+      var require_gl3d = __commonJS({
+        "src/plots/gl3d/index.js"(exports) {
+          var overrideAll = require_edit_types().overrideAll;
+          var fxAttrs = require_layout_attributes();
+          var Scene = require_scene();
+          var getSubplotData = require_get_data().getSubplotData;
+          var Lib = require_lib();
+          var xmlnsNamespaces = require_xmlns_namespaces();
+          var GL3D = "gl3d";
+          var SCENE = "scene";
+          exports.name = GL3D;
+          exports.attr = SCENE;
+          exports.idRoot = SCENE;
+          exports.idRegex = exports.attrRegex = Lib.counterRegex("scene");
+          exports.attributes = require_attributes41();
+          exports.layoutAttributes = require_layout_attributes17();
+          exports.baseLayoutAttrOverrides = overrideAll({
+            hoverlabel: fxAttrs.hoverlabel
+          }, "plot", "nested");
+          exports.supplyLayoutDefaults = require_defaults37();
+          exports.plot = function plot(gd2) {
+            var fullLayout = gd2._fullLayout;
+            var fullData = gd2._fullData;
+            var sceneIds = fullLayout._subplots[GL3D];
+            for (var i2 = 0; i2 < sceneIds.length; i2++) {
+              var sceneId = sceneIds[i2];
+              var fullSceneData = getSubplotData(fullData, GL3D, sceneId);
+              var sceneLayout = fullLayout[sceneId];
+              var camera = sceneLayout.camera;
+              var scene = sceneLayout._scene;
+              if (!scene) {
+                scene = new Scene(
+                  {
+                    id: sceneId,
+                    graphDiv: gd2,
+                    container: gd2.querySelector(".gl-container"),
+                    staticPlot: gd2._context.staticPlot,
+                    plotGlPixelRatio: gd2._context.plotGlPixelRatio,
+                    camera
+                  },
+                  fullLayout
+                );
+                sceneLayout._scene = scene;
+              }
+              if (!scene.viewInitial) {
+                scene.viewInitial = {
+                  up: {
+                    x: camera.up.x,
+                    y: camera.up.y,
+                    z: camera.up.z
+                  },
+                  eye: {
+                    x: camera.eye.x,
+                    y: camera.eye.y,
+                    z: camera.eye.z
+                  },
+                  center: {
+                    x: camera.center.x,
+                    y: camera.center.y,
+                    z: camera.center.z
+                  }
+                };
+              }
+              scene.plot(fullSceneData, fullLayout, gd2.layout);
+            }
+          };
+          exports.clean = function(newFullData, newFullLayout, oldFullData, oldFullLayout) {
+            var oldSceneKeys = oldFullLayout._subplots[GL3D] || [];
+            for (var i2 = 0; i2 < oldSceneKeys.length; i2++) {
+              var oldSceneKey = oldSceneKeys[i2];
+              if (!newFullLayout[oldSceneKey] && !!oldFullLayout[oldSceneKey]._scene) {
+                oldFullLayout[oldSceneKey]._scene.destroy();
+                if (oldFullLayout._infolayer) {
+                  oldFullLayout._infolayer.selectAll(".annotation-" + oldSceneKey).remove();
+                }
+              }
+            }
+          };
+          exports.toSVG = function(gd2) {
+            var fullLayout = gd2._fullLayout;
+            var sceneIds = fullLayout._subplots[GL3D];
+            var size = fullLayout._size;
+            for (var i2 = 0; i2 < sceneIds.length; i2++) {
+              var sceneLayout = fullLayout[sceneIds[i2]];
+              var domain = sceneLayout.domain;
+              var scene = sceneLayout._scene;
+              var imageData = scene.toImage("png");
+              var image = fullLayout._glimages.append("svg:image");
+              image.attr({
+                xmlns: xmlnsNamespaces.svg,
+                "xlink:href": imageData,
+                x: size.l + size.w * domain.x[0],
+                y: size.t + size.h * (1 - domain.y[1]),
+                width: size.w * (domain.x[1] - domain.x[0]),
+                height: size.h * (domain.y[1] - domain.y[0]),
+                preserveAspectRatio: "none"
+              });
+              scene.destroy();
+            }
+          };
+          exports.cleanId = function cleanId(id2) {
+            if (!id2.match(/^scene[0-9]*$/)) return;
+            var sceneNum = id2.slice(5);
+            if (sceneNum === "1") sceneNum = "";
+            return SCENE + sceneNum;
+          };
+          exports.updateFx = function(gd2) {
+            var fullLayout = gd2._fullLayout;
+            var subplotIds = fullLayout._subplots[GL3D];
+            for (var i2 = 0; i2 < subplotIds.length; i2++) {
+              var subplotObj = fullLayout[subplotIds[i2]]._scene;
+              subplotObj.updateFx(fullLayout.dragmode, fullLayout.hovermode);
+            }
+          };
         }
-        off(this._dragStartTarget, START, this._onDown, this);
-        this._enabled = false;
-        this._moved = false;
-      },
-      _onDown: function(e) {
-        if (!this._enabled) {
-          return;
+      });
+      var require_scatter3d = __commonJS({
+        "src/traces/scatter3d/index.js"(exports, module2) {
+          module2.exports = {
+            plot: require_convert2(),
+            attributes: require_attributes40(),
+            markerSymbols: require_gl3d_markers(),
+            supplyDefaults: require_defaults36(),
+            colorbar: [
+              {
+                container: "marker",
+                min: "cmin",
+                max: "cmax"
+              },
+              {
+                container: "line",
+                min: "cmin",
+                max: "cmax"
+              }
+            ],
+            calc: require_calc21(),
+            moduleType: "trace",
+            name: "scatter3d",
+            basePlotModule: require_gl3d(),
+            categories: ["gl3d", "symbols", "showLegend", "scatter-like"],
+            meta: {}
+          };
         }
-        this._moved = false;
-        if (hasClass(this._element, "leaflet-zoom-anim")) {
-          return;
+      });
+      var require_scatter3d2 = __commonJS({
+        "lib/scatter3d.js"(exports, module2) {
+          module2.exports = require_scatter3d();
         }
-        if (e.touches && e.touches.length !== 1) {
-          if (Draggable._dragging === this) {
-            this.finishDrag();
+      });
+      var require_attributes42 = __commonJS({
+        "src/traces/surface/attributes.js"(exports, module2) {
+          var Color2 = require_color();
+          var colorScaleAttrs = require_attributes8();
+          var axisHoverFormat = require_axis_format_attributes().axisHoverFormat;
+          var { hovertemplateAttrs, templatefallbackAttrs } = require_template_attributes();
+          var baseAttrs = require_attributes2();
+          var extendFlat = require_extend().extendFlat;
+          var overrideAll = require_edit_types().overrideAll;
+          function makeContourProjAttr(axLetter) {
+            return {
+              valType: "boolean",
+              dflt: false
+            };
           }
-          return;
-        }
-        if (Draggable._dragging || e.shiftKey || e.which !== 1 && e.button !== 1 && !e.touches) {
-          return;
-        }
-        Draggable._dragging = this;
-        if (this._preventOutline) {
-          preventOutline(this._element);
-        }
-        disableImageDrag();
-        disableTextSelection();
-        if (this._moving) {
-          return;
+          function makeContourAttr(axLetter) {
+            return {
+              show: {
+                valType: "boolean",
+                dflt: false
+              },
+              start: {
+                valType: "number",
+                dflt: null,
+                editType: "plot"
+                // impliedEdits: {'^autocontour': false},
+              },
+              end: {
+                valType: "number",
+                dflt: null,
+                editType: "plot"
+                // impliedEdits: {'^autocontour': false},
+              },
+              size: {
+                valType: "number",
+                dflt: null,
+                min: 0,
+                editType: "plot"
+                // impliedEdits: {'^autocontour': false},
+              },
+              project: {
+                x: makeContourProjAttr(),
+                y: makeContourProjAttr(),
+                z: makeContourProjAttr()
+              },
+              color: {
+                valType: "color",
+                dflt: Color2.defaultLine
+              },
+              usecolormap: {
+                valType: "boolean",
+                dflt: false
+              },
+              width: {
+                valType: "number",
+                min: 1,
+                max: 16,
+                dflt: 2
+              },
+              highlight: {
+                valType: "boolean",
+                dflt: true
+              },
+              highlightcolor: {
+                valType: "color",
+                dflt: Color2.defaultLine
+              },
+              highlightwidth: {
+                valType: "number",
+                min: 1,
+                max: 16,
+                dflt: 2
+              }
+            };
+          }
+          var attrs = module2.exports = overrideAll(
+            extendFlat(
+              {
+                z: {
+                  valType: "data_array"
+                },
+                x: {
+                  valType: "data_array"
+                },
+                y: {
+                  valType: "data_array"
+                },
+                text: {
+                  valType: "string",
+                  dflt: "",
+                  arrayOk: true
+                },
+                hovertext: {
+                  valType: "string",
+                  dflt: "",
+                  arrayOk: true
+                },
+                hovertemplate: hovertemplateAttrs(),
+                hovertemplatefallback: templatefallbackAttrs(),
+                xhoverformat: axisHoverFormat("x"),
+                yhoverformat: axisHoverFormat("y"),
+                zhoverformat: axisHoverFormat("z"),
+                connectgaps: {
+                  valType: "boolean",
+                  dflt: false,
+                  editType: "calc"
+                },
+                surfacecolor: {
+                  valType: "data_array"
+                }
+              },
+              colorScaleAttrs("", {
+                colorAttr: "z or surfacecolor",
+                showScaleDflt: true,
+                autoColorDflt: false,
+                editTypeOverride: "calc"
+              }),
+              {
+                contours: {
+                  x: makeContourAttr(),
+                  y: makeContourAttr(),
+                  z: makeContourAttr()
+                },
+                hidesurface: {
+                  valType: "boolean",
+                  dflt: false
+                },
+                lightposition: {
+                  x: {
+                    valType: "number",
+                    min: -1e5,
+                    max: 1e5,
+                    dflt: 10
+                  },
+                  y: {
+                    valType: "number",
+                    min: -1e5,
+                    max: 1e5,
+                    dflt: 1e4
+                  },
+                  z: {
+                    valType: "number",
+                    min: -1e5,
+                    max: 1e5,
+                    dflt: 0
+                  }
+                },
+                lighting: {
+                  ambient: {
+                    valType: "number",
+                    min: 0,
+                    max: 1,
+                    dflt: 0.8
+                  },
+                  diffuse: {
+                    valType: "number",
+                    min: 0,
+                    max: 1,
+                    dflt: 0.8
+                  },
+                  specular: {
+                    valType: "number",
+                    min: 0,
+                    max: 2,
+                    dflt: 0.05,
+                    description: "Represents the level that incident rays are reflected in a single direction, causing shine."
+                  },
+                  roughness: {
+                    valType: "number",
+                    min: 0,
+                    max: 1,
+                    dflt: 0.5,
+                    description: "Alters specular reflection; the rougher the surface, the wider and less contrasty the shine."
+                  },
+                  fresnel: {
+                    valType: "number",
+                    min: 0,
+                    max: 5,
+                    dflt: 0.2
+                  }
+                },
+                opacity: {
+                  valType: "number",
+                  min: 0,
+                  max: 1,
+                  dflt: 1
+                },
+                opacityscale: {
+                  valType: "any",
+                  editType: "calc"
+                },
+                hoverinfo: extendFlat({}, baseAttrs.hoverinfo),
+                showlegend: extendFlat({}, baseAttrs.showlegend, { dflt: false })
+              }
+            ),
+            "calc",
+            "nested"
+          );
+          attrs.x.editType = attrs.y.editType = attrs.z.editType = "calc+clearAxisTypes";
         }
-        this.fire("down");
-        var first = e.touches ? e.touches[0] : e, sizedParent = getSizedParentNode(this._element);
-        this._startPoint = new Point(first.clientX, first.clientY);
-        this._startPos = getPosition(this._element);
-        this._parentScale = getScale(sizedParent);
-        var mouseevent = e.type === "mousedown";
-        on(document, mouseevent ? "mousemove" : "touchmove", this._onMove, this);
-        on(document, mouseevent ? "mouseup" : "touchend touchcancel", this._onUp, this);
-      },
-      _onMove: function(e) {
-        if (!this._enabled) {
-          return;
+      });
+      var require_defaults38 = __commonJS({
+        "src/traces/surface/defaults.js"(exports, module2) {
+          var Registry = require_registry();
+          var Lib = require_lib();
+          var colorscaleDefaults = require_defaults2();
+          var attributes = require_attributes42();
+          var MIN = 0.1;
+          function createWave(n2, minOpacity) {
+            var arr = [];
+            var steps = 32;
+            for (var i2 = 0; i2 < steps; i2++) {
+              var u2 = i2 / (steps - 1);
+              var v2 = minOpacity + (1 - minOpacity) * (1 - Math.pow(Math.sin(n2 * u2 * Math.PI), 2));
+              arr.push([u2, Math.max(0, Math.min(1, v2))]);
+            }
+            return arr;
+          }
+          function isValidScaleArray(scl) {
+            var highestVal = 0;
+            if (!Array.isArray(scl) || scl.length < 2) return false;
+            if (!scl[0] || !scl[scl.length - 1]) return false;
+            if (+scl[0][0] !== 0 || +scl[scl.length - 1][0] !== 1) return false;
+            for (var i2 = 0; i2 < scl.length; i2++) {
+              var si2 = scl[i2];
+              if (si2.length !== 2 || +si2[0] < highestVal) {
+                return false;
+              }
+              highestVal = +si2[0];
+            }
+            return true;
+          }
+          function supplyDefaults(traceIn, traceOut, defaultColor, layout) {
+            var i2, j2;
+            function coerce(attr, dflt) {
+              return Lib.coerce(traceIn, traceOut, attributes, attr, dflt);
+            }
+            var x2 = coerce("x");
+            var y2 = coerce("y");
+            var z2 = coerce("z");
+            if (!z2 || !z2.length || (x2 ? x2.length < 1 : false) || (y2 ? y2.length < 1 : false)) {
+              traceOut.visible = false;
+              return;
+            }
+            traceOut._xlength = Array.isArray(x2) && Lib.isArrayOrTypedArray(x2[0]) ? z2.length : z2[0].length;
+            traceOut._ylength = z2.length;
+            var handleCalendarDefaults = Registry.getComponentMethod("calendars", "handleTraceDefaults");
+            handleCalendarDefaults(traceIn, traceOut, ["x", "y", "z"], layout);
+            coerce("text");
+            coerce("hovertext");
+            coerce("hovertemplate");
+            coerce("hovertemplatefallback");
+            coerce("xhoverformat");
+            coerce("yhoverformat");
+            coerce("zhoverformat");
+            [
+              "lighting.ambient",
+              "lighting.diffuse",
+              "lighting.specular",
+              "lighting.roughness",
+              "lighting.fresnel",
+              "lightposition.x",
+              "lightposition.y",
+              "lightposition.z",
+              "hidesurface",
+              "connectgaps",
+              "opacity"
+            ].forEach(function(x22) {
+              coerce(x22);
+            });
+            coerce("surfacecolor");
+            var dims = ["x", "y", "z"];
+            for (i2 = 0; i2 < 3; ++i2) {
+              var contourDim = "contours." + dims[i2];
+              var show = coerce(contourDim + ".show");
+              var highlight = coerce(contourDim + ".highlight");
+              if (show || highlight) {
+                for (j2 = 0; j2 < 3; ++j2) {
+                  coerce(contourDim + ".project." + dims[j2]);
+                }
+              }
+              if (show) {
+                coerce(contourDim + ".color");
+                coerce(contourDim + ".width");
+                coerce(contourDim + ".usecolormap");
+              }
+              if (highlight) {
+                coerce(contourDim + ".highlightcolor");
+                coerce(contourDim + ".highlightwidth");
+              }
+              coerce(contourDim + ".start");
+              coerce(contourDim + ".end");
+              coerce(contourDim + ".size");
+            }
+            colorscaleDefaults(traceIn, traceOut, layout, coerce, { prefix: "", cLetter: "c" });
+            opacityscaleDefaults(traceIn, traceOut, layout, coerce);
+            traceOut._length = null;
+          }
+          function opacityscaleDefaults(traceIn, traceOut, layout, coerce) {
+            var opacityscale = coerce("opacityscale");
+            if (opacityscale === "max") {
+              traceOut.opacityscale = [
+                [0, MIN],
+                [1, 1]
+              ];
+            } else if (opacityscale === "min") {
+              traceOut.opacityscale = [
+                [0, 1],
+                [1, MIN]
+              ];
+            } else if (opacityscale === "extremes") {
+              traceOut.opacityscale = createWave(1, MIN);
+            } else if (!isValidScaleArray(opacityscale)) {
+              traceOut.opacityscale = void 0;
+            }
+          }
+          module2.exports = {
+            supplyDefaults,
+            opacityscaleDefaults
+          };
         }
-        if (e.touches && e.touches.length > 1) {
-          this._moved = true;
-          return;
+      });
+      var require_calc22 = __commonJS({
+        "src/traces/surface/calc.js"(exports, module2) {
+          var colorscaleCalc = require_calc();
+          module2.exports = function calc(gd2, trace) {
+            if (trace.surfacecolor) {
+              colorscaleCalc(gd2, trace, {
+                vals: trace.surfacecolor,
+                containerStr: "",
+                cLetter: "c"
+              });
+            } else {
+              colorscaleCalc(gd2, trace, {
+                vals: trace.z,
+                containerStr: "",
+                cLetter: "c"
+              });
+            }
+          };
         }
-        var first = e.touches && e.touches.length === 1 ? e.touches[0] : e, offset = new Point(first.clientX, first.clientY)._subtract(this._startPoint);
-        if (!offset.x && !offset.y) {
-          return;
+      });
+      var require_convert4 = __commonJS({
+        "src/traces/surface/convert.js"(exports, module2) {
+          var createSurface = require_stackgl_modules().gl_surface3d;
+          var ndarray = require_stackgl_modules().ndarray;
+          var ndarrayInterp2d = require_stackgl_modules().ndarray_linear_interpolate.d2;
+          var interp2d = require_interp2d();
+          var findEmpties = require_find_empties();
+          var isArrayOrTypedArray = require_lib().isArrayOrTypedArray;
+          var parseColorScale = require_gl_format_color().parseColorScale;
+          var str2RgbaArray = require_str2rgbarray();
+          var extractOpts = require_colorscale().extractOpts;
+          function SurfaceTrace(scene, surface, uid2) {
+            this.scene = scene;
+            this.uid = uid2;
+            this.surface = surface;
+            this.data = null;
+            this.showContour = [false, false, false];
+            this.contourStart = [null, null, null];
+            this.contourEnd = [null, null, null];
+            this.contourSize = [0, 0, 0];
+            this.minValues = [Infinity, Infinity, Infinity];
+            this.maxValues = [-Infinity, -Infinity, -Infinity];
+            this.dataScaleX = 1;
+            this.dataScaleY = 1;
+            this.refineData = true;
+            this.objectOffset = [0, 0, 0];
+          }
+          var proto = SurfaceTrace.prototype;
+          proto.getXat = function(a2, b2, calendar, axis) {
+            var v2 = !isArrayOrTypedArray(this.data.x) ? a2 : isArrayOrTypedArray(this.data.x[0]) ? this.data.x[b2][a2] : this.data.x[a2];
+            return calendar === void 0 ? v2 : axis.d2l(v2, 0, calendar);
+          };
+          proto.getYat = function(a2, b2, calendar, axis) {
+            var v2 = !isArrayOrTypedArray(this.data.y) ? b2 : isArrayOrTypedArray(this.data.y[0]) ? this.data.y[b2][a2] : this.data.y[b2];
+            return calendar === void 0 ? v2 : axis.d2l(v2, 0, calendar);
+          };
+          proto.getZat = function(a2, b2, calendar, axis) {
+            var v2 = this.data.z[b2][a2];
+            if (v2 === null && this.data.connectgaps && this.data._interpolatedZ) {
+              v2 = this.data._interpolatedZ[b2][a2];
+            }
+            return calendar === void 0 ? v2 : axis.d2l(v2, 0, calendar);
+          };
+          proto.handlePick = function(selection) {
+            if (selection.object === this.surface) {
+              var xRatio = (selection.data.index[0] - 1) / this.dataScaleX - 1;
+              var yRatio = (selection.data.index[1] - 1) / this.dataScaleY - 1;
+              var j2 = Math.max(Math.min(Math.round(xRatio), this.data.z[0].length - 1), 0);
+              var k2 = Math.max(Math.min(Math.round(yRatio), this.data._ylength - 1), 0);
+              selection.index = [j2, k2];
+              selection.traceCoordinate = [
+                this.getXat(j2, k2),
+                this.getYat(j2, k2),
+                this.getZat(j2, k2)
+              ];
+              selection.dataCoordinate = [
+                this.getXat(j2, k2, this.data.xcalendar, this.scene.fullSceneLayout.xaxis),
+                this.getYat(j2, k2, this.data.ycalendar, this.scene.fullSceneLayout.yaxis),
+                this.getZat(j2, k2, this.data.zcalendar, this.scene.fullSceneLayout.zaxis)
+              ];
+              for (var i2 = 0; i2 < 3; i2++) {
+                var v2 = selection.dataCoordinate[i2];
+                if (v2 !== null && v2 !== void 0) {
+                  selection.dataCoordinate[i2] *= this.scene.dataScale[i2];
+                }
+              }
+              var text = this.data.hovertext || this.data.text;
+              if (isArrayOrTypedArray(text) && text[k2] && text[k2][j2] !== void 0) {
+                selection.textLabel = text[k2][j2];
+              } else if (text) {
+                selection.textLabel = text;
+              } else {
+                selection.textLabel = "";
+              }
+              selection.data.dataCoordinate = selection.dataCoordinate.slice();
+              this.surface.highlight(selection.data);
+              this.scene.glplot.spikes.position = selection.dataCoordinate;
+              return true;
+            }
+          };
+          function isColormapCircular(colormap) {
+            var first = colormap[0].rgb;
+            var last = colormap[colormap.length - 1].rgb;
+            return first[0] === last[0] && first[1] === last[1] && first[2] === last[2] && first[3] === last[3];
+          }
+          var shortPrimes = [
+            2,
+            3,
+            5,
+            7,
+            11,
+            13,
+            17,
+            19,
+            23,
+            29,
+            31,
+            37,
+            41,
+            43,
+            47,
+            53,
+            59,
+            61,
+            67,
+            71,
+            73,
+            79,
+            83,
+            89,
+            97,
+            101,
+            103,
+            107,
+            109,
+            113,
+            127,
+            131,
+            137,
+            139,
+            149,
+            151,
+            157,
+            163,
+            167,
+            173,
+            179,
+            181,
+            191,
+            193,
+            197,
+            199,
+            211,
+            223,
+            227,
+            229,
+            233,
+            239,
+            241,
+            251,
+            257,
+            263,
+            269,
+            271,
+            277,
+            281,
+            283,
+            293,
+            307,
+            311,
+            313,
+            317,
+            331,
+            337,
+            347,
+            349,
+            353,
+            359,
+            367,
+            373,
+            379,
+            383,
+            389,
+            397,
+            401,
+            409,
+            419,
+            421,
+            431,
+            433,
+            439,
+            443,
+            449,
+            457,
+            461,
+            463,
+            467,
+            479,
+            487,
+            491,
+            499,
+            503,
+            509,
+            521,
+            523,
+            541,
+            547,
+            557,
+            563,
+            569,
+            571,
+            577,
+            587,
+            593,
+            599,
+            601,
+            607,
+            613,
+            617,
+            619,
+            631,
+            641,
+            643,
+            647,
+            653,
+            659,
+            661,
+            673,
+            677,
+            683,
+            691,
+            701,
+            709,
+            719,
+            727,
+            733,
+            739,
+            743,
+            751,
+            757,
+            761,
+            769,
+            773,
+            787,
+            797,
+            809,
+            811,
+            821,
+            823,
+            827,
+            829,
+            839,
+            853,
+            857,
+            859,
+            863,
+            877,
+            881,
+            883,
+            887,
+            907,
+            911,
+            919,
+            929,
+            937,
+            941,
+            947,
+            953,
+            967,
+            971,
+            977,
+            983,
+            991,
+            997,
+            1009,
+            1013,
+            1019,
+            1021,
+            1031,
+            1033,
+            1039,
+            1049,
+            1051,
+            1061,
+            1063,
+            1069,
+            1087,
+            1091,
+            1093,
+            1097,
+            1103,
+            1109,
+            1117,
+            1123,
+            1129,
+            1151,
+            1153,
+            1163,
+            1171,
+            1181,
+            1187,
+            1193,
+            1201,
+            1213,
+            1217,
+            1223,
+            1229,
+            1231,
+            1237,
+            1249,
+            1259,
+            1277,
+            1279,
+            1283,
+            1289,
+            1291,
+            1297,
+            1301,
+            1303,
+            1307,
+            1319,
+            1321,
+            1327,
+            1361,
+            1367,
+            1373,
+            1381,
+            1399,
+            1409,
+            1423,
+            1427,
+            1429,
+            1433,
+            1439,
+            1447,
+            1451,
+            1453,
+            1459,
+            1471,
+            1481,
+            1483,
+            1487,
+            1489,
+            1493,
+            1499,
+            1511,
+            1523,
+            1531,
+            1543,
+            1549,
+            1553,
+            1559,
+            1567,
+            1571,
+            1579,
+            1583,
+            1597,
+            1601,
+            1607,
+            1609,
+            1613,
+            1619,
+            1621,
+            1627,
+            1637,
+            1657,
+            1663,
+            1667,
+            1669,
+            1693,
+            1697,
+            1699,
+            1709,
+            1721,
+            1723,
+            1733,
+            1741,
+            1747,
+            1753,
+            1759,
+            1777,
+            1783,
+            1787,
+            1789,
+            1801,
+            1811,
+            1823,
+            1831,
+            1847,
+            1861,
+            1867,
+            1871,
+            1873,
+            1877,
+            1879,
+            1889,
+            1901,
+            1907,
+            1913,
+            1931,
+            1933,
+            1949,
+            1951,
+            1973,
+            1979,
+            1987,
+            1993,
+            1997,
+            1999,
+            2003,
+            2011,
+            2017,
+            2027,
+            2029,
+            2039,
+            2053,
+            2063,
+            2069,
+            2081,
+            2083,
+            2087,
+            2089,
+            2099,
+            2111,
+            2113,
+            2129,
+            2131,
+            2137,
+            2141,
+            2143,
+            2153,
+            2161,
+            2179,
+            2203,
+            2207,
+            2213,
+            2221,
+            2237,
+            2239,
+            2243,
+            2251,
+            2267,
+            2269,
+            2273,
+            2281,
+            2287,
+            2293,
+            2297,
+            2309,
+            2311,
+            2333,
+            2339,
+            2341,
+            2347,
+            2351,
+            2357,
+            2371,
+            2377,
+            2381,
+            2383,
+            2389,
+            2393,
+            2399,
+            2411,
+            2417,
+            2423,
+            2437,
+            2441,
+            2447,
+            2459,
+            2467,
+            2473,
+            2477,
+            2503,
+            2521,
+            2531,
+            2539,
+            2543,
+            2549,
+            2551,
+            2557,
+            2579,
+            2591,
+            2593,
+            2609,
+            2617,
+            2621,
+            2633,
+            2647,
+            2657,
+            2659,
+            2663,
+            2671,
+            2677,
+            2683,
+            2687,
+            2689,
+            2693,
+            2699,
+            2707,
+            2711,
+            2713,
+            2719,
+            2729,
+            2731,
+            2741,
+            2749,
+            2753,
+            2767,
+            2777,
+            2789,
+            2791,
+            2797,
+            2801,
+            2803,
+            2819,
+            2833,
+            2837,
+            2843,
+            2851,
+            2857,
+            2861,
+            2879,
+            2887,
+            2897,
+            2903,
+            2909,
+            2917,
+            2927,
+            2939,
+            2953,
+            2957,
+            2963,
+            2969,
+            2971,
+            2999
+          ];
+          function getPow(a2, b2) {
+            if (a2 < b2) return 0;
+            var n2 = 0;
+            while (Math.floor(a2 % b2) === 0) {
+              a2 /= b2;
+              n2++;
+            }
+            return n2;
+          }
+          function getFactors(a2) {
+            var powers = [];
+            for (var i2 = 0; i2 < shortPrimes.length; i2++) {
+              var b2 = shortPrimes[i2];
+              powers.push(
+                getPow(a2, b2)
+              );
+            }
+            return powers;
+          }
+          function smallestDivisor(a2) {
+            var A22 = getFactors(a2);
+            var result = a2;
+            for (var i2 = 0; i2 < shortPrimes.length; i2++) {
+              if (A22[i2] > 0) {
+                result = shortPrimes[i2];
+                break;
+              }
+            }
+            return result;
+          }
+          function leastCommonMultiple(a2, b2) {
+            if (a2 < 1 || b2 < 1) return void 0;
+            var A22 = getFactors(a2);
+            var B22 = getFactors(b2);
+            var n2 = 1;
+            for (var i2 = 0; i2 < shortPrimes.length; i2++) {
+              n2 *= Math.pow(
+                shortPrimes[i2],
+                Math.max(A22[i2], B22[i2])
+              );
+            }
+            return n2;
+          }
+          function arrayLCM(A22) {
+            if (A22.length === 0) return void 0;
+            var n2 = 1;
+            for (var i2 = 0; i2 < A22.length; i2++) {
+              n2 = leastCommonMultiple(n2, A22[i2]);
+            }
+            return n2;
+          }
+          proto.calcXnums = function(xlen) {
+            var i2;
+            var nums = [];
+            for (i2 = 1; i2 < xlen; i2++) {
+              var a2 = this.getXat(i2 - 1, 0);
+              var b2 = this.getXat(i2, 0);
+              if (b2 !== a2 && a2 !== void 0 && a2 !== null && b2 !== void 0 && b2 !== null) {
+                nums[i2 - 1] = Math.abs(b2 - a2);
+              } else {
+                nums[i2 - 1] = 0;
+              }
+            }
+            var totalDist = 0;
+            for (i2 = 1; i2 < xlen; i2++) {
+              totalDist += nums[i2 - 1];
+            }
+            for (i2 = 1; i2 < xlen; i2++) {
+              if (nums[i2 - 1] === 0) {
+                nums[i2 - 1] = 1;
+              } else {
+                nums[i2 - 1] = Math.round(totalDist / nums[i2 - 1]);
+              }
+            }
+            return nums;
+          };
+          proto.calcYnums = function(ylen) {
+            var i2;
+            var nums = [];
+            for (i2 = 1; i2 < ylen; i2++) {
+              var a2 = this.getYat(0, i2 - 1);
+              var b2 = this.getYat(0, i2);
+              if (b2 !== a2 && a2 !== void 0 && a2 !== null && b2 !== void 0 && b2 !== null) {
+                nums[i2 - 1] = Math.abs(b2 - a2);
+              } else {
+                nums[i2 - 1] = 0;
+              }
+            }
+            var totalDist = 0;
+            for (i2 = 1; i2 < ylen; i2++) {
+              totalDist += nums[i2 - 1];
+            }
+            for (i2 = 1; i2 < ylen; i2++) {
+              if (nums[i2 - 1] === 0) {
+                nums[i2 - 1] = 1;
+              } else {
+                nums[i2 - 1] = Math.round(totalDist / nums[i2 - 1]);
+              }
+            }
+            return nums;
+          };
+          var highlyComposites = [1, 2, 4, 6, 12, 24, 36, 48, 60, 120, 180, 240, 360, 720, 840, 1260];
+          var MIN_RESOLUTION = highlyComposites[9];
+          var MAX_RESOLUTION = highlyComposites[13];
+          proto.estimateScale = function(resSrc, axis) {
+            var nums = axis === 0 ? this.calcXnums(resSrc) : this.calcYnums(resSrc);
+            var resDst = 1 + arrayLCM(nums);
+            while (resDst < MIN_RESOLUTION) {
+              resDst *= 2;
+            }
+            while (resDst > MAX_RESOLUTION) {
+              resDst--;
+              resDst /= smallestDivisor(resDst);
+              resDst++;
+              if (resDst < MIN_RESOLUTION) {
+                resDst = MAX_RESOLUTION;
+              }
+            }
+            var scale2 = Math.round(resDst / resSrc);
+            return scale2 > 1 ? scale2 : 1;
+          };
+          function fnHomography(out, inp, X2) {
+            var w2 = X2[8] + X2[2] * inp[0] + X2[5] * inp[1];
+            out[0] = (X2[6] + X2[0] * inp[0] + X2[3] * inp[1]) / w2;
+            out[1] = (X2[7] + X2[1] * inp[0] + X2[4] * inp[1]) / w2;
+            return out;
+          }
+          function homography(dest, src, X2) {
+            warp(dest, src, fnHomography, X2);
+            return dest;
+          }
+          function warp(dest, src, func, X2) {
+            var warped = [0, 0];
+            var ni2 = dest.shape[0];
+            var nj2 = dest.shape[1];
+            for (var i2 = 0; i2 < ni2; i2++) {
+              for (var j2 = 0; j2 < nj2; j2++) {
+                func(warped, [i2, j2], X2);
+                dest.set(i2, j2, ndarrayInterp2d(src, warped[0], warped[1]));
+              }
+            }
+            return dest;
+          }
+          proto.refineCoords = function(coords) {
+            var scaleW = this.dataScaleX;
+            var scaleH = this.dataScaleY;
+            var width = coords[0].shape[0];
+            var height = coords[0].shape[1];
+            var newWidth = Math.floor(coords[0].shape[0] * scaleW + 1) | 0;
+            var newHeight = Math.floor(coords[0].shape[1] * scaleH + 1) | 0;
+            var padWidth = 1 + width + 1;
+            var padHeight = 1 + height + 1;
+            var padImg = ndarray(new Float32Array(padWidth * padHeight), [padWidth, padHeight]);
+            var X2 = [
+              1 / scaleW,
+              0,
+              0,
+              0,
+              1 / scaleH,
+              0,
+              0,
+              0,
+              1
+            ];
+            for (var i2 = 0; i2 < coords.length; ++i2) {
+              this.surface.padField(padImg, coords[i2]);
+              var scaledImg = ndarray(new Float32Array(newWidth * newHeight), [newWidth, newHeight]);
+              homography(scaledImg, padImg, X2);
+              coords[i2] = scaledImg;
+            }
+          };
+          function insertIfNewLevel(arr, newValue) {
+            var found = false;
+            for (var k2 = 0; k2 < arr.length; k2++) {
+              if (newValue === arr[k2]) {
+                found = true;
+                break;
+              }
+            }
+            if (found === false) arr.push(newValue);
+          }
+          proto.setContourLevels = function() {
+            var newLevels = [[], [], []];
+            var useNewLevels = [false, false, false];
+            var needsUpdate = false;
+            var i2, j2, value;
+            for (i2 = 0; i2 < 3; ++i2) {
+              if (this.showContour[i2]) {
+                needsUpdate = true;
+                if (this.contourSize[i2] > 0 && this.contourStart[i2] !== null && this.contourEnd[i2] !== null && this.contourEnd[i2] > this.contourStart[i2]) {
+                  useNewLevels[i2] = true;
+                  for (j2 = this.contourStart[i2]; j2 < this.contourEnd[i2]; j2 += this.contourSize[i2]) {
+                    value = j2 * this.scene.dataScale[i2];
+                    insertIfNewLevel(newLevels[i2], value);
+                  }
+                }
+              }
+            }
+            if (needsUpdate) {
+              var allLevels = [[], [], []];
+              for (i2 = 0; i2 < 3; ++i2) {
+                if (this.showContour[i2]) {
+                  allLevels[i2] = useNewLevels[i2] ? newLevels[i2] : this.scene.contourLevels[i2];
+                }
+              }
+              this.surface.update({ levels: allLevels });
+            }
+          };
+          proto.update = function(data) {
+            var scene = this.scene;
+            var sceneLayout = scene.fullSceneLayout;
+            var surface = this.surface;
+            var colormap = parseColorScale(data);
+            var scaleFactor = scene.dataScale;
+            var xlen = data.z[0].length;
+            var ylen = data._ylength;
+            var contourLevels = scene.contourLevels;
+            this.data = data;
+            var i2, j2, k2, v2;
+            var rawCoords = [];
+            for (i2 = 0; i2 < 3; i2++) {
+              rawCoords[i2] = [];
+              for (j2 = 0; j2 < xlen; j2++) {
+                rawCoords[i2][j2] = [];
+              }
+            }
+            for (j2 = 0; j2 < xlen; j2++) {
+              for (k2 = 0; k2 < ylen; k2++) {
+                rawCoords[0][j2][k2] = this.getXat(j2, k2, data.xcalendar, sceneLayout.xaxis);
+                rawCoords[1][j2][k2] = this.getYat(j2, k2, data.ycalendar, sceneLayout.yaxis);
+                rawCoords[2][j2][k2] = this.getZat(j2, k2, data.zcalendar, sceneLayout.zaxis);
+              }
+            }
+            if (data.connectgaps) {
+              data._emptypoints = findEmpties(rawCoords[2]);
+              interp2d(rawCoords[2], data._emptypoints);
+              data._interpolatedZ = [];
+              for (j2 = 0; j2 < xlen; j2++) {
+                data._interpolatedZ[j2] = [];
+                for (k2 = 0; k2 < ylen; k2++) {
+                  data._interpolatedZ[j2][k2] = rawCoords[2][j2][k2];
+                }
+              }
+            }
+            for (i2 = 0; i2 < 3; i2++) {
+              for (j2 = 0; j2 < xlen; j2++) {
+                for (k2 = 0; k2 < ylen; k2++) {
+                  v2 = rawCoords[i2][j2][k2];
+                  if (v2 === null || v2 === void 0) {
+                    rawCoords[i2][j2][k2] = NaN;
+                  } else {
+                    v2 = rawCoords[i2][j2][k2] *= scaleFactor[i2];
+                  }
+                }
+              }
+            }
+            for (i2 = 0; i2 < 3; i2++) {
+              for (j2 = 0; j2 < xlen; j2++) {
+                for (k2 = 0; k2 < ylen; k2++) {
+                  v2 = rawCoords[i2][j2][k2];
+                  if (v2 !== null && v2 !== void 0) {
+                    if (this.minValues[i2] > v2) {
+                      this.minValues[i2] = v2;
+                    }
+                    if (this.maxValues[i2] < v2) {
+                      this.maxValues[i2] = v2;
+                    }
+                  }
+                }
+              }
+            }
+            for (i2 = 0; i2 < 3; i2++) {
+              this.objectOffset[i2] = 0.5 * (this.minValues[i2] + this.maxValues[i2]);
+            }
+            for (i2 = 0; i2 < 3; i2++) {
+              for (j2 = 0; j2 < xlen; j2++) {
+                for (k2 = 0; k2 < ylen; k2++) {
+                  v2 = rawCoords[i2][j2][k2];
+                  if (v2 !== null && v2 !== void 0) {
+                    rawCoords[i2][j2][k2] -= this.objectOffset[i2];
+                  }
+                }
+              }
+            }
+            var coords = [
+              ndarray(new Float32Array(xlen * ylen), [xlen, ylen]),
+              ndarray(new Float32Array(xlen * ylen), [xlen, ylen]),
+              ndarray(new Float32Array(xlen * ylen), [xlen, ylen])
+            ];
+            for (i2 = 0; i2 < 3; i2++) {
+              for (j2 = 0; j2 < xlen; j2++) {
+                for (k2 = 0; k2 < ylen; k2++) {
+                  coords[i2].set(j2, k2, rawCoords[i2][j2][k2]);
+                }
+              }
+            }
+            rawCoords = [];
+            var params = {
+              colormap,
+              levels: [[], [], []],
+              showContour: [true, true, true],
+              showSurface: !data.hidesurface,
+              contourProject: [
+                [false, false, false],
+                [false, false, false],
+                [false, false, false]
+              ],
+              contourWidth: [1, 1, 1],
+              contourColor: [[1, 1, 1, 1], [1, 1, 1, 1], [1, 1, 1, 1]],
+              contourTint: [1, 1, 1],
+              dynamicColor: [[1, 1, 1, 1], [1, 1, 1, 1], [1, 1, 1, 1]],
+              dynamicWidth: [1, 1, 1],
+              dynamicTint: [1, 1, 1],
+              opacityscale: data.opacityscale,
+              opacity: data.opacity
+            };
+            var cOpts = extractOpts(data);
+            params.intensityBounds = [cOpts.min, cOpts.max];
+            if (data.surfacecolor) {
+              var intensity = ndarray(new Float32Array(xlen * ylen), [xlen, ylen]);
+              for (j2 = 0; j2 < xlen; j2++) {
+                for (k2 = 0; k2 < ylen; k2++) {
+                  intensity.set(j2, k2, data.surfacecolor[k2][j2]);
+                }
+              }
+              coords.push(intensity);
+            } else {
+              params.intensityBounds[0] *= scaleFactor[2];
+              params.intensityBounds[1] *= scaleFactor[2];
+            }
+            if (MAX_RESOLUTION < coords[0].shape[0] || MAX_RESOLUTION < coords[0].shape[1]) {
+              this.refineData = false;
+            }
+            if (this.refineData === true) {
+              this.dataScaleX = this.estimateScale(coords[0].shape[0], 0);
+              this.dataScaleY = this.estimateScale(coords[0].shape[1], 1);
+              if (this.dataScaleX !== 1 || this.dataScaleY !== 1) {
+                this.refineCoords(coords);
+              }
+            }
+            if (data.surfacecolor) {
+              params.intensity = coords.pop();
+            }
+            var highlightEnable = [true, true, true];
+            var axis = ["x", "y", "z"];
+            for (i2 = 0; i2 < 3; ++i2) {
+              var contourParams = data.contours[axis[i2]];
+              highlightEnable[i2] = contourParams.highlight;
+              params.showContour[i2] = contourParams.show || contourParams.highlight;
+              if (!params.showContour[i2]) continue;
+              params.contourProject[i2] = [
+                contourParams.project.x,
+                contourParams.project.y,
+                contourParams.project.z
+              ];
+              if (contourParams.show) {
+                this.showContour[i2] = true;
+                params.levels[i2] = contourLevels[i2];
+                surface.highlightColor[i2] = params.contourColor[i2] = str2RgbaArray(contourParams.color);
+                if (contourParams.usecolormap) {
+                  surface.highlightTint[i2] = params.contourTint[i2] = 0;
+                } else {
+                  surface.highlightTint[i2] = params.contourTint[i2] = 1;
+                }
+                params.contourWidth[i2] = contourParams.width;
+                this.contourStart[i2] = contourParams.start;
+                this.contourEnd[i2] = contourParams.end;
+                this.contourSize[i2] = contourParams.size;
+              } else {
+                this.showContour[i2] = false;
+                this.contourStart[i2] = null;
+                this.contourEnd[i2] = null;
+                this.contourSize[i2] = 0;
+              }
+              if (contourParams.highlight) {
+                params.dynamicColor[i2] = str2RgbaArray(contourParams.highlightcolor);
+                params.dynamicWidth[i2] = contourParams.highlightwidth;
+              }
+            }
+            if (isColormapCircular(colormap)) {
+              params.vertexColor = true;
+            }
+            params.objectOffset = this.objectOffset;
+            params.coords = coords;
+            surface.update(params);
+            surface.visible = data.visible;
+            surface.enableDynamic = highlightEnable;
+            surface.enableHighlight = highlightEnable;
+            surface.snapToData = true;
+            if ("lighting" in data) {
+              surface.ambientLight = data.lighting.ambient;
+              surface.diffuseLight = data.lighting.diffuse;
+              surface.specularLight = data.lighting.specular;
+              surface.roughness = data.lighting.roughness;
+              surface.fresnel = data.lighting.fresnel;
+            }
+            if ("lightposition" in data) {
+              surface.lightPosition = [data.lightposition.x, data.lightposition.y, data.lightposition.z];
+            }
+          };
+          proto.dispose = function() {
+            this.scene.glplot.remove(this.surface);
+            this.surface.dispose();
+          };
+          function createSurfaceTrace(scene, data) {
+            var gl2 = scene.glplot.gl;
+            var surface = createSurface({ gl: gl2 });
+            var result = new SurfaceTrace(scene, surface, data.uid);
+            surface._trace = result;
+            result.update(data);
+            scene.glplot.add(surface);
+            return result;
+          }
+          module2.exports = createSurfaceTrace;
         }
-        if (Math.abs(offset.x) + Math.abs(offset.y) < this.options.clickTolerance) {
-          return;
+      });
+      var require_surface = __commonJS({
+        "src/traces/surface/index.js"(exports, module2) {
+          module2.exports = {
+            attributes: require_attributes42(),
+            supplyDefaults: require_defaults38().supplyDefaults,
+            colorbar: {
+              min: "cmin",
+              max: "cmax"
+            },
+            calc: require_calc22(),
+            plot: require_convert4(),
+            moduleType: "trace",
+            name: "surface",
+            basePlotModule: require_gl3d(),
+            categories: ["gl3d", "2dMap", "showLegend"],
+            meta: {}
+          };
         }
-        offset.x /= this._parentScale.x;
-        offset.y /= this._parentScale.y;
-        preventDefault(e);
-        if (!this._moved) {
-          this.fire("dragstart");
-          this._moved = true;
-          addClass(document.body, "leaflet-dragging");
-          this._lastTarget = e.target || e.srcElement;
-          if (window.SVGElementInstance && this._lastTarget instanceof window.SVGElementInstance) {
-            this._lastTarget = this._lastTarget.correspondingUseElement;
-          }
-          addClass(this._lastTarget, "leaflet-drag-target");
-        }
-        this._newPos = this._startPos.add(offset);
-        this._moving = true;
-        this._lastEvent = e;
-        this._updatePosition();
-      },
-      _updatePosition: function() {
-        var e = { originalEvent: this._lastEvent };
-        this.fire("predrag", e);
-        setPosition(this._element, this._newPos);
-        this.fire("drag", e);
-      },
-      _onUp: function() {
-        if (!this._enabled) {
-          return;
+      });
+      var require_surface2 = __commonJS({
+        "lib/surface.js"(exports, module2) {
+          module2.exports = require_surface();
         }
-        this.finishDrag();
-      },
-      finishDrag: function(noInertia) {
-        removeClass(document.body, "leaflet-dragging");
-        if (this._lastTarget) {
-          removeClass(this._lastTarget, "leaflet-drag-target");
-          this._lastTarget = null;
-        }
-        off(document, "mousemove touchmove", this._onMove, this);
-        off(document, "mouseup touchend touchcancel", this._onUp, this);
-        enableImageDrag();
-        enableTextSelection();
-        var fireDragend = this._moved && this._moving;
-        this._moving = false;
-        Draggable._dragging = false;
-        if (fireDragend) {
-          this.fire("dragend", {
-            noInertia,
-            distance: this._newPos.distanceTo(this._startPos)
-          });
+      });
+      var require_attributes43 = __commonJS({
+        "src/traces/mesh3d/attributes.js"(exports, module2) {
+          var colorScaleAttrs = require_attributes8();
+          var axisHoverFormat = require_axis_format_attributes().axisHoverFormat;
+          var { hovertemplateAttrs, templatefallbackAttrs } = require_template_attributes();
+          var surfaceAttrs = require_attributes42();
+          var baseAttrs = require_attributes2();
+          var extendFlat = require_extend().extendFlat;
+          module2.exports = extendFlat(
+            {
+              x: {
+                valType: "data_array",
+                editType: "calc+clearAxisTypes"
+              },
+              y: {
+                valType: "data_array",
+                editType: "calc+clearAxisTypes"
+              },
+              z: {
+                valType: "data_array",
+                editType: "calc+clearAxisTypes"
+              },
+              i: {
+                valType: "data_array",
+                editType: "calc"
+              },
+              j: {
+                valType: "data_array",
+                editType: "calc"
+              },
+              k: {
+                valType: "data_array",
+                editType: "calc"
+              },
+              text: {
+                valType: "string",
+                dflt: "",
+                arrayOk: true,
+                editType: "calc"
+              },
+              hovertext: {
+                valType: "string",
+                dflt: "",
+                arrayOk: true,
+                editType: "calc"
+              },
+              hovertemplate: hovertemplateAttrs({ editType: "calc" }),
+              hovertemplatefallback: templatefallbackAttrs({ editType: "calc" }),
+              xhoverformat: axisHoverFormat("x"),
+              yhoverformat: axisHoverFormat("y"),
+              zhoverformat: axisHoverFormat("z"),
+              delaunayaxis: {
+                valType: "enumerated",
+                values: ["x", "y", "z"],
+                dflt: "z",
+                editType: "calc"
+              },
+              alphahull: {
+                valType: "number",
+                dflt: -1,
+                editType: "calc"
+              },
+              intensity: {
+                valType: "data_array",
+                editType: "calc"
+              },
+              intensitymode: {
+                valType: "enumerated",
+                values: ["vertex", "cell"],
+                dflt: "vertex",
+                editType: "calc"
+              },
+              // Color field
+              color: {
+                valType: "color",
+                editType: "calc"
+              },
+              vertexcolor: {
+                valType: "data_array",
+                editType: "calc"
+              },
+              facecolor: {
+                valType: "data_array",
+                editType: "calc"
+              }
+            },
+            colorScaleAttrs("", {
+              colorAttr: "`intensity`",
+              showScaleDflt: true,
+              editTypeOverride: "calc"
+            }),
+            {
+              opacity: surfaceAttrs.opacity,
+              // Flat shaded mode
+              flatshading: {
+                valType: "boolean",
+                dflt: false,
+                editType: "calc"
+              },
+              contour: {
+                show: extendFlat({}, surfaceAttrs.contours.x.show, {}),
+                color: surfaceAttrs.contours.x.color,
+                width: surfaceAttrs.contours.x.width,
+                editType: "calc"
+              },
+              lightposition: {
+                x: extendFlat({}, surfaceAttrs.lightposition.x, { dflt: 1e5 }),
+                y: extendFlat({}, surfaceAttrs.lightposition.y, { dflt: 1e5 }),
+                z: extendFlat({}, surfaceAttrs.lightposition.z, { dflt: 0 }),
+                editType: "calc"
+              },
+              lighting: extendFlat(
+                {
+                  vertexnormalsepsilon: {
+                    valType: "number",
+                    min: 0,
+                    max: 1,
+                    dflt: 1e-12,
+                    // otherwise finely tessellated things eg. the brain will have no specular light reflection
+                    editType: "calc",
+                    description: "Epsilon for vertex normals calculation avoids math issues arising from degenerate geometry."
+                  },
+                  facenormalsepsilon: {
+                    valType: "number",
+                    min: 0,
+                    max: 1,
+                    dflt: 1e-6,
+                    // even the brain model doesn't appear to need finer than this
+                    editType: "calc",
+                    description: "Epsilon for face normals calculation avoids math issues arising from degenerate geometry."
+                  },
+                  editType: "calc"
+                },
+                surfaceAttrs.lighting
+              ),
+              hoverinfo: extendFlat({}, baseAttrs.hoverinfo, { editType: "calc" }),
+              showlegend: extendFlat({}, baseAttrs.showlegend, { dflt: false })
+            }
+          );
         }
-      }
-    });
-    function clipPolygon(points, bounds, round2) {
-      var clippedPoints, edges = [1, 4, 2, 8], i, j, k2, a, b, len, edge2, p2;
-      for (i = 0, len = points.length; i < len; i++) {
-        points[i]._code = _getBitCode(points[i], bounds);
-      }
-      for (k2 = 0; k2 < 4; k2++) {
-        edge2 = edges[k2];
-        clippedPoints = [];
-        for (i = 0, len = points.length, j = len - 1; i < len; j = i++) {
-          a = points[i];
-          b = points[j];
-          if (!(a._code & edge2)) {
-            if (b._code & edge2) {
-              p2 = _getEdgeIntersection(b, a, edge2, bounds, round2);
-              p2._code = _getBitCode(p2, bounds);
-              clippedPoints.push(p2);
-            }
-            clippedPoints.push(a);
-          } else if (!(b._code & edge2)) {
-            p2 = _getEdgeIntersection(b, a, edge2, bounds, round2);
-            p2._code = _getBitCode(p2, bounds);
-            clippedPoints.push(p2);
-          }
-        }
-        points = clippedPoints;
-      }
-      return points;
-    }
-    function polygonCenter(latlngs, crs) {
-      var i, j, p1, p2, f2, area, x2, y2, center;
-      if (!latlngs || latlngs.length === 0) {
-        throw new Error("latlngs not passed");
-      }
-      if (!isFlat(latlngs)) {
-        console.warn("latlngs are not flat! Only the first ring will be used");
-        latlngs = latlngs[0];
-      }
-      var centroidLatLng = toLatLng([0, 0]);
-      var bounds = toLatLngBounds(latlngs);
-      var areaBounds = bounds.getNorthWest().distanceTo(bounds.getSouthWest()) * bounds.getNorthEast().distanceTo(bounds.getNorthWest());
-      if (areaBounds < 1700) {
-        centroidLatLng = centroid(latlngs);
-      }
-      var len = latlngs.length;
-      var points = [];
-      for (i = 0; i < len; i++) {
-        var latlng = toLatLng(latlngs[i]);
-        points.push(crs.project(toLatLng([latlng.lat - centroidLatLng.lat, latlng.lng - centroidLatLng.lng])));
-      }
-      area = x2 = y2 = 0;
-      for (i = 0, j = len - 1; i < len; j = i++) {
-        p1 = points[i];
-        p2 = points[j];
-        f2 = p1.y * p2.x - p2.y * p1.x;
-        x2 += (p1.x + p2.x) * f2;
-        y2 += (p1.y + p2.y) * f2;
-        area += f2 * 3;
-      }
-      if (area === 0) {
-        center = points[0];
-      } else {
-        center = [x2 / area, y2 / area];
-      }
-      var latlngCenter = crs.unproject(toPoint(center));
-      return toLatLng([latlngCenter.lat + centroidLatLng.lat, latlngCenter.lng + centroidLatLng.lng]);
-    }
-    function centroid(coords) {
-      var latSum = 0;
-      var lngSum = 0;
-      var len = 0;
-      for (var i = 0; i < coords.length; i++) {
-        var latlng = toLatLng(coords[i]);
-        latSum += latlng.lat;
-        lngSum += latlng.lng;
-        len++;
-      }
-      return toLatLng([latSum / len, lngSum / len]);
-    }
-    var PolyUtil = {
-      __proto__: null,
-      clipPolygon,
-      polygonCenter,
-      centroid
-    };
-    function simplify(points, tolerance) {
-      if (!tolerance || !points.length) {
-        return points.slice();
-      }
-      var sqTolerance = tolerance * tolerance;
-      points = _reducePoints(points, sqTolerance);
-      points = _simplifyDP(points, sqTolerance);
-      return points;
-    }
-    function pointToSegmentDistance(p2, p1, p22) {
-      return Math.sqrt(_sqClosestPointOnSegment(p2, p1, p22, true));
-    }
-    function closestPointOnSegment(p2, p1, p22) {
-      return _sqClosestPointOnSegment(p2, p1, p22);
-    }
-    function _simplifyDP(points, sqTolerance) {
-      var len = points.length, ArrayConstructor = typeof Uint8Array !== "undefined" ? Uint8Array : Array, markers = new ArrayConstructor(len);
-      markers[0] = markers[len - 1] = 1;
-      _simplifyDPStep(points, markers, sqTolerance, 0, len - 1);
-      var i, newPoints = [];
-      for (i = 0; i < len; i++) {
-        if (markers[i]) {
-          newPoints.push(points[i]);
+      });
+      var require_attributes44 = __commonJS({
+        "src/traces/isosurface/attributes.js"(exports, module2) {
+          var colorScaleAttrs = require_attributes8();
+          var axisHoverFormat = require_axis_format_attributes().axisHoverFormat;
+          var { hovertemplateAttrs, templatefallbackAttrs } = require_template_attributes();
+          var meshAttrs = require_attributes43();
+          var baseAttrs = require_attributes2();
+          var extendFlat = require_extend().extendFlat;
+          var overrideAll = require_edit_types().overrideAll;
+          function makeSliceAttr(axLetter) {
+            return {
+              show: {
+                valType: "boolean",
+                dflt: false
+              },
+              locations: {
+                valType: "data_array",
+                dflt: []
+              },
+              fill: {
+                valType: "number",
+                min: 0,
+                max: 1,
+                dflt: 1
+              }
+            };
+          }
+          function makeCapAttr(axLetter) {
+            return {
+              show: {
+                valType: "boolean",
+                dflt: true
+              },
+              fill: {
+                valType: "number",
+                min: 0,
+                max: 1,
+                dflt: 1
+              }
+            };
+          }
+          var attrs = module2.exports = overrideAll(
+            extendFlat(
+              {
+                x: {
+                  valType: "data_array"
+                },
+                y: {
+                  valType: "data_array"
+                },
+                z: {
+                  valType: "data_array"
+                },
+                value: {
+                  valType: "data_array"
+                },
+                isomin: {
+                  valType: "number"
+                },
+                isomax: {
+                  valType: "number"
+                },
+                surface: {
+                  show: {
+                    valType: "boolean",
+                    dflt: true
+                  },
+                  count: {
+                    valType: "integer",
+                    dflt: 2,
+                    min: 1
+                  },
+                  fill: {
+                    valType: "number",
+                    min: 0,
+                    max: 1,
+                    dflt: 1
+                  },
+                  pattern: {
+                    valType: "flaglist",
+                    flags: ["A", "B", "C", "D", "E"],
+                    extras: ["all", "odd", "even"],
+                    dflt: "all"
+                  }
+                },
+                spaceframe: {
+                  show: {
+                    valType: "boolean",
+                    dflt: false
+                  },
+                  fill: {
+                    valType: "number",
+                    min: 0,
+                    max: 1,
+                    dflt: 0.15
+                  }
+                },
+                slices: {
+                  x: makeSliceAttr(),
+                  y: makeSliceAttr(),
+                  z: makeSliceAttr()
+                },
+                caps: {
+                  x: makeCapAttr(),
+                  y: makeCapAttr(),
+                  z: makeCapAttr()
+                },
+                text: {
+                  valType: "string",
+                  dflt: "",
+                  arrayOk: true
+                },
+                hovertext: {
+                  valType: "string",
+                  dflt: "",
+                  arrayOk: true
+                },
+                hovertemplate: hovertemplateAttrs(),
+                hovertemplatefallback: templatefallbackAttrs(),
+                xhoverformat: axisHoverFormat("x"),
+                yhoverformat: axisHoverFormat("y"),
+                zhoverformat: axisHoverFormat("z"),
+                valuehoverformat: axisHoverFormat("value", 1),
+                showlegend: extendFlat({}, baseAttrs.showlegend, { dflt: false })
+              },
+              colorScaleAttrs("", {
+                colorAttr: "`value`",
+                showScaleDflt: true,
+                editTypeOverride: "calc"
+              }),
+              {
+                opacity: meshAttrs.opacity,
+                lightposition: meshAttrs.lightposition,
+                lighting: meshAttrs.lighting,
+                flatshading: meshAttrs.flatshading,
+                contour: meshAttrs.contour,
+                hoverinfo: extendFlat({}, baseAttrs.hoverinfo)
+              }
+            ),
+            "calc",
+            "nested"
+          );
+          attrs.flatshading.dflt = true;
+          attrs.lighting.facenormalsepsilon.dflt = 0;
+          attrs.x.editType = attrs.y.editType = attrs.z.editType = attrs.value.editType = "calc+clearAxisTypes";
         }
-      }
-      return newPoints;
-    }
-    function _simplifyDPStep(points, markers, sqTolerance, first, last) {
-      var maxSqDist = 0, index2, i, sqDist;
-      for (i = first + 1; i <= last - 1; i++) {
-        sqDist = _sqClosestPointOnSegment(points[i], points[first], points[last], true);
-        if (sqDist > maxSqDist) {
-          index2 = i;
-          maxSqDist = sqDist;
+      });
+      var require_defaults39 = __commonJS({
+        "src/traces/isosurface/defaults.js"(exports, module2) {
+          var Lib = require_lib();
+          var Registry = require_registry();
+          var attributes = require_attributes44();
+          var colorscaleDefaults = require_defaults2();
+          function supplyDefaults(traceIn, traceOut, defaultColor, layout) {
+            function coerce(attr, dflt) {
+              return Lib.coerce(traceIn, traceOut, attributes, attr, dflt);
+            }
+            supplyIsoDefaults(traceIn, traceOut, defaultColor, layout, coerce);
+          }
+          function supplyIsoDefaults(traceIn, traceOut, defaultColor, layout, coerce) {
+            var isomin = coerce("isomin");
+            var isomax = coerce("isomax");
+            if (isomax !== void 0 && isomax !== null && isomin !== void 0 && isomin !== null && isomin > isomax) {
+              traceOut.isomin = null;
+              traceOut.isomax = null;
+            }
+            var x2 = coerce("x");
+            var y2 = coerce("y");
+            var z2 = coerce("z");
+            var value = coerce("value");
+            if (!x2 || !x2.length || !y2 || !y2.length || !z2 || !z2.length || !value || !value.length) {
+              traceOut.visible = false;
+              return;
+            }
+            var handleCalendarDefaults = Registry.getComponentMethod("calendars", "handleTraceDefaults");
+            handleCalendarDefaults(traceIn, traceOut, ["x", "y", "z"], layout);
+            coerce("valuehoverformat");
+            ["x", "y", "z"].forEach(function(dim) {
+              coerce(dim + "hoverformat");
+              var capDim = "caps." + dim;
+              var showCap = coerce(capDim + ".show");
+              if (showCap) {
+                coerce(capDim + ".fill");
+              }
+              var sliceDim = "slices." + dim;
+              var showSlice = coerce(sliceDim + ".show");
+              if (showSlice) {
+                coerce(sliceDim + ".fill");
+                coerce(sliceDim + ".locations");
+              }
+            });
+            var showSpaceframe = coerce("spaceframe.show");
+            if (showSpaceframe) {
+              coerce("spaceframe.fill");
+            }
+            var showSurface = coerce("surface.show");
+            if (showSurface) {
+              coerce("surface.count");
+              coerce("surface.fill");
+              coerce("surface.pattern");
+            }
+            var showContour = coerce("contour.show");
+            if (showContour) {
+              coerce("contour.color");
+              coerce("contour.width");
+            }
+            [
+              "text",
+              "hovertext",
+              "hovertemplate",
+              "lighting.ambient",
+              "lighting.diffuse",
+              "lighting.specular",
+              "lighting.roughness",
+              "lighting.fresnel",
+              "lighting.vertexnormalsepsilon",
+              "lighting.facenormalsepsilon",
+              "lightposition.x",
+              "lightposition.y",
+              "lightposition.z",
+              "flatshading",
+              "opacity"
+            ].forEach(function(x22) {
+              coerce(x22);
+            });
+            colorscaleDefaults(traceIn, traceOut, layout, coerce, { prefix: "", cLetter: "c" });
+            traceOut._length = null;
+          }
+          module2.exports = {
+            supplyDefaults,
+            supplyIsoDefaults
+          };
         }
-      }
-      if (maxSqDist > sqTolerance) {
-        markers[index2] = 1;
-        _simplifyDPStep(points, markers, sqTolerance, first, index2);
-        _simplifyDPStep(points, markers, sqTolerance, index2, last);
-      }
-    }
-    function _reducePoints(points, sqTolerance) {
-      var reducedPoints = [points[0]];
-      for (var i = 1, prev = 0, len = points.length; i < len; i++) {
-        if (_sqDist(points[i], points[prev]) > sqTolerance) {
-          reducedPoints.push(points[i]);
-          prev = i;
+      });
+      var require_calc23 = __commonJS({
+        "src/traces/streamtube/calc.js"(exports, module2) {
+          var Lib = require_lib();
+          var colorscaleCalc = require_calc();
+          function calc(gd2, trace) {
+            trace._len = Math.min(
+              trace.u.length,
+              trace.v.length,
+              trace.w.length,
+              trace.x.length,
+              trace.y.length,
+              trace.z.length
+            );
+            trace._u = filter(trace.u, trace._len);
+            trace._v = filter(trace.v, trace._len);
+            trace._w = filter(trace.w, trace._len);
+            trace._x = filter(trace.x, trace._len);
+            trace._y = filter(trace.y, trace._len);
+            trace._z = filter(trace.z, trace._len);
+            var grid = processGrid(trace);
+            trace._gridFill = grid.fill;
+            trace._Xs = grid.Xs;
+            trace._Ys = grid.Ys;
+            trace._Zs = grid.Zs;
+            trace._len = grid.len;
+            var slen = 0;
+            var startx, starty, startz;
+            if (trace.starts) {
+              startx = filter(trace.starts.x || []);
+              starty = filter(trace.starts.y || []);
+              startz = filter(trace.starts.z || []);
+              slen = Math.min(startx.length, starty.length, startz.length);
+            }
+            trace._startsX = startx || [];
+            trace._startsY = starty || [];
+            trace._startsZ = startz || [];
+            var normMax = 0;
+            var normMin = Infinity;
+            var i2;
+            for (i2 = 0; i2 < trace._len; i2++) {
+              var u2 = trace._u[i2];
+              var v2 = trace._v[i2];
+              var w2 = trace._w[i2];
+              var norm = Math.sqrt(u2 * u2 + v2 * v2 + w2 * w2);
+              normMax = Math.max(normMax, norm);
+              normMin = Math.min(normMin, norm);
+            }
+            colorscaleCalc(gd2, trace, {
+              vals: [normMin, normMax],
+              containerStr: "",
+              cLetter: "c"
+            });
+            for (i2 = 0; i2 < slen; i2++) {
+              var sx = startx[i2];
+              grid.xMax = Math.max(grid.xMax, sx);
+              grid.xMin = Math.min(grid.xMin, sx);
+              var sy = starty[i2];
+              grid.yMax = Math.max(grid.yMax, sy);
+              grid.yMin = Math.min(grid.yMin, sy);
+              var sz = startz[i2];
+              grid.zMax = Math.max(grid.zMax, sz);
+              grid.zMin = Math.min(grid.zMin, sz);
+            }
+            trace._slen = slen;
+            trace._normMax = normMax;
+            trace._xbnds = [grid.xMin, grid.xMax];
+            trace._ybnds = [grid.yMin, grid.yMax];
+            trace._zbnds = [grid.zMin, grid.zMax];
+          }
+          function processGrid(trace) {
+            var x2 = trace._x;
+            var y2 = trace._y;
+            var z2 = trace._z;
+            var len2 = trace._len;
+            var i2, j2, k2;
+            var xMax = -Infinity;
+            var xMin = Infinity;
+            var yMax = -Infinity;
+            var yMin = Infinity;
+            var zMax = -Infinity;
+            var zMin = Infinity;
+            var gridFill = "";
+            var filledX;
+            var filledY;
+            var filledZ;
+            var firstX, lastX;
+            var firstY, lastY;
+            var firstZ, lastZ;
+            if (len2) {
+              firstX = x2[0];
+              firstY = y2[0];
+              firstZ = z2[0];
+            }
+            if (len2 > 1) {
+              lastX = x2[len2 - 1];
+              lastY = y2[len2 - 1];
+              lastZ = z2[len2 - 1];
+            }
+            for (i2 = 0; i2 < len2; i2++) {
+              xMax = Math.max(xMax, x2[i2]);
+              xMin = Math.min(xMin, x2[i2]);
+              yMax = Math.max(yMax, y2[i2]);
+              yMin = Math.min(yMin, y2[i2]);
+              zMax = Math.max(zMax, z2[i2]);
+              zMin = Math.min(zMin, z2[i2]);
+              if (!filledX && x2[i2] !== firstX) {
+                filledX = true;
+                gridFill += "x";
+              }
+              if (!filledY && y2[i2] !== firstY) {
+                filledY = true;
+                gridFill += "y";
+              }
+              if (!filledZ && z2[i2] !== firstZ) {
+                filledZ = true;
+                gridFill += "z";
+              }
+            }
+            if (!filledX) gridFill += "x";
+            if (!filledY) gridFill += "y";
+            if (!filledZ) gridFill += "z";
+            var Xs = distinctVals(trace._x);
+            var Ys = distinctVals(trace._y);
+            var Zs = distinctVals(trace._z);
+            gridFill = gridFill.replace("x", (firstX > lastX ? "-" : "+") + "x");
+            gridFill = gridFill.replace("y", (firstY > lastY ? "-" : "+") + "y");
+            gridFill = gridFill.replace("z", (firstZ > lastZ ? "-" : "+") + "z");
+            var empty = function() {
+              len2 = 0;
+              Xs = [];
+              Ys = [];
+              Zs = [];
+            };
+            if (!len2 || len2 < Xs.length * Ys.length * Zs.length) empty();
+            var getArray = function(c2) {
+              return c2 === "x" ? x2 : c2 === "y" ? y2 : z2;
+            };
+            var getVals = function(c2) {
+              return c2 === "x" ? Xs : c2 === "y" ? Ys : Zs;
+            };
+            var getDir = function(c2) {
+              return c2[len2 - 1] < c2[0] ? -1 : 1;
+            };
+            var arrK = getArray(gridFill[1]);
+            var arrJ = getArray(gridFill[3]);
+            var arrI = getArray(gridFill[5]);
+            var nk2 = getVals(gridFill[1]).length;
+            var nj2 = getVals(gridFill[3]).length;
+            var ni2 = getVals(gridFill[5]).length;
+            var arbitrary = false;
+            var getIndex = function(_i, _j2, _k2) {
+              return nk2 * (nj2 * _i + _j2) + _k2;
+            };
+            var dirK = getDir(getArray(gridFill[1]));
+            var dirJ = getDir(getArray(gridFill[3]));
+            var dirI = getDir(getArray(gridFill[5]));
+            for (i2 = 0; i2 < ni2 - 1; i2++) {
+              for (j2 = 0; j2 < nj2 - 1; j2++) {
+                for (k2 = 0; k2 < nk2 - 1; k2++) {
+                  var q000 = getIndex(i2, j2, k2);
+                  var q001 = getIndex(i2, j2, k2 + 1);
+                  var q010 = getIndex(i2, j2 + 1, k2);
+                  var q100 = getIndex(i2 + 1, j2, k2);
+                  if (!(arrK[q000] * dirK < arrK[q001] * dirK) || !(arrJ[q000] * dirJ < arrJ[q010] * dirJ) || !(arrI[q000] * dirI < arrI[q100] * dirI)) {
+                    arbitrary = true;
+                  }
+                  if (arbitrary) break;
+                }
+                if (arbitrary) break;
+              }
+              if (arbitrary) break;
+            }
+            if (arbitrary) {
+              Lib.warn("Encountered arbitrary coordinates! Unable to input data grid.");
+              empty();
+            }
+            return {
+              xMin,
+              yMin,
+              zMin,
+              xMax,
+              yMax,
+              zMax,
+              Xs,
+              Ys,
+              Zs,
+              len: len2,
+              fill: gridFill
+            };
+          }
+          function distinctVals(col) {
+            return Lib.distinctVals(col).vals;
+          }
+          function filter(arr, len2) {
+            if (len2 === void 0) len2 = arr.length;
+            if (Lib.isTypedArray(arr)) return arr.subarray(0, len2);
+            var values = [];
+            for (var i2 = 0; i2 < len2; i2++) {
+              values[i2] = +arr[i2];
+            }
+            return values;
+          }
+          module2.exports = {
+            calc,
+            filter,
+            processGrid
+          };
         }
-      }
-      if (prev < len - 1) {
-        reducedPoints.push(points[len - 1]);
-      }
-      return reducedPoints;
-    }
-    var _lastCode;
-    function clipSegment(a, b, bounds, useLastCode, round2) {
-      var codeA = useLastCode ? _lastCode : _getBitCode(a, bounds), codeB = _getBitCode(b, bounds), codeOut, p2, newCode;
-      _lastCode = codeB;
-      while (true) {
-        if (!(codeA | codeB)) {
-          return [a, b];
+      });
+      var require_calc24 = __commonJS({
+        "src/traces/isosurface/calc.js"(exports, module2) {
+          var colorscaleCalc = require_calc();
+          var processGrid = require_calc23().processGrid;
+          var filter = require_calc23().filter;
+          module2.exports = function calc(gd2, trace) {
+            trace._len = Math.min(
+              trace.x.length,
+              trace.y.length,
+              trace.z.length,
+              trace.value.length
+            );
+            trace._x = filter(trace.x, trace._len);
+            trace._y = filter(trace.y, trace._len);
+            trace._z = filter(trace.z, trace._len);
+            trace._value = filter(trace.value, trace._len);
+            var grid = processGrid(trace);
+            trace._gridFill = grid.fill;
+            trace._Xs = grid.Xs;
+            trace._Ys = grid.Ys;
+            trace._Zs = grid.Zs;
+            trace._len = grid.len;
+            var min = Infinity;
+            var max = -Infinity;
+            for (var i2 = 0; i2 < trace._len; i2++) {
+              var v2 = trace._value[i2];
+              min = Math.min(min, v2);
+              max = Math.max(max, v2);
+            }
+            trace._minValues = min;
+            trace._maxValues = max;
+            trace._vMin = trace.isomin === void 0 || trace.isomin === null ? min : trace.isomin;
+            trace._vMax = trace.isomax === void 0 || trace.isomax === null ? max : trace.isomax;
+            colorscaleCalc(gd2, trace, {
+              vals: [trace._vMin, trace._vMax],
+              containerStr: "",
+              cLetter: "c"
+            });
+          };
         }
-        if (codeA & codeB) {
-          return false;
+      });
+      var require_zip3 = __commonJS({
+        "src/plots/gl3d/zip3.js"(exports, module2) {
+          module2.exports = function zip3(x2, y2, z2, len2) {
+            len2 = len2 || x2.length;
+            var result = new Array(len2);
+            for (var i2 = 0; i2 < len2; i2++) {
+              result[i2] = [x2[i2], y2[i2], z2[i2]];
+            }
+            return result;
+          };
         }
-        codeOut = codeA || codeB;
-        p2 = _getEdgeIntersection(a, b, codeOut, bounds, round2);
-        newCode = _getBitCode(p2, bounds);
-        if (codeOut === codeA) {
-          a = p2;
-          codeA = newCode;
-        } else {
-          b = p2;
-          codeB = newCode;
-        }
-      }
-    }
-    function _getEdgeIntersection(a, b, code, bounds, round2) {
-      var dx = b.x - a.x, dy = b.y - a.y, min = bounds.min, max = bounds.max, x2, y2;
-      if (code & 8) {
-        x2 = a.x + dx * (max.y - a.y) / dy;
-        y2 = max.y;
-      } else if (code & 4) {
-        x2 = a.x + dx * (min.y - a.y) / dy;
-        y2 = min.y;
-      } else if (code & 2) {
-        x2 = max.x;
-        y2 = a.y + dy * (max.x - a.x) / dx;
-      } else if (code & 1) {
-        x2 = min.x;
-        y2 = a.y + dy * (min.x - a.x) / dx;
-      }
-      return new Point(x2, y2, round2);
-    }
-    function _getBitCode(p2, bounds) {
-      var code = 0;
-      if (p2.x < bounds.min.x) {
-        code |= 1;
-      } else if (p2.x > bounds.max.x) {
-        code |= 2;
-      }
-      if (p2.y < bounds.min.y) {
-        code |= 4;
-      } else if (p2.y > bounds.max.y) {
-        code |= 8;
-      }
-      return code;
-    }
-    function _sqDist(p1, p2) {
-      var dx = p2.x - p1.x, dy = p2.y - p1.y;
-      return dx * dx + dy * dy;
-    }
-    function _sqClosestPointOnSegment(p2, p1, p22, sqDist) {
-      var x2 = p1.x, y2 = p1.y, dx = p22.x - x2, dy = p22.y - y2, dot = dx * dx + dy * dy, t2;
-      if (dot > 0) {
-        t2 = ((p2.x - x2) * dx + (p2.y - y2) * dy) / dot;
-        if (t2 > 1) {
-          x2 = p22.x;
-          y2 = p22.y;
-        } else if (t2 > 0) {
-          x2 += dx * t2;
-          y2 += dy * t2;
-        }
-      }
-      dx = p2.x - x2;
-      dy = p2.y - y2;
-      return sqDist ? dx * dx + dy * dy : new Point(x2, y2);
-    }
-    function isFlat(latlngs) {
-      return !isArray2(latlngs[0]) || typeof latlngs[0][0] !== "object" && typeof latlngs[0][0] !== "undefined";
-    }
-    function _flat(latlngs) {
-      console.warn("Deprecated use of _flat, please use L.LineUtil.isFlat instead.");
-      return isFlat(latlngs);
-    }
-    function polylineCenter(latlngs, crs) {
-      var i, halfDist, segDist, dist, p1, p2, ratio, center;
-      if (!latlngs || latlngs.length === 0) {
-        throw new Error("latlngs not passed");
-      }
-      if (!isFlat(latlngs)) {
-        console.warn("latlngs are not flat! Only the first ring will be used");
-        latlngs = latlngs[0];
-      }
-      var centroidLatLng = toLatLng([0, 0]);
-      var bounds = toLatLngBounds(latlngs);
-      var areaBounds = bounds.getNorthWest().distanceTo(bounds.getSouthWest()) * bounds.getNorthEast().distanceTo(bounds.getNorthWest());
-      if (areaBounds < 1700) {
-        centroidLatLng = centroid(latlngs);
-      }
-      var len = latlngs.length;
-      var points = [];
-      for (i = 0; i < len; i++) {
-        var latlng = toLatLng(latlngs[i]);
-        points.push(crs.project(toLatLng([latlng.lat - centroidLatLng.lat, latlng.lng - centroidLatLng.lng])));
-      }
-      for (i = 0, halfDist = 0; i < len - 1; i++) {
-        halfDist += points[i].distanceTo(points[i + 1]) / 2;
-      }
-      if (halfDist === 0) {
-        center = points[0];
-      } else {
-        for (i = 0, dist = 0; i < len - 1; i++) {
-          p1 = points[i];
-          p2 = points[i + 1];
-          segDist = p1.distanceTo(p2);
-          dist += segDist;
-          if (dist > halfDist) {
-            ratio = (dist - halfDist) / segDist;
-            center = [
-              p2.x - ratio * (p2.x - p1.x),
-              p2.y - ratio * (p2.y - p1.y)
-            ];
-            break;
+      });
+      var require_convert5 = __commonJS({
+        "src/traces/isosurface/convert.js"(exports, module2) {
+          var createMesh = require_stackgl_modules().gl_mesh3d;
+          var parseColorScale = require_gl_format_color().parseColorScale;
+          var isArrayOrTypedArray = require_lib().isArrayOrTypedArray;
+          var str2RgbaArray = require_str2rgbarray();
+          var extractOpts = require_colorscale().extractOpts;
+          var zip3 = require_zip3();
+          var findNearestOnAxis = function(w2, arr) {
+            for (var q2 = arr.length - 1; q2 > 0; q2--) {
+              var min = Math.min(arr[q2], arr[q2 - 1]);
+              var max = Math.max(arr[q2], arr[q2 - 1]);
+              if (max > min && min < w2 && w2 <= max) {
+                return {
+                  id: q2,
+                  distRatio: (max - w2) / (max - min)
+                };
+              }
+            }
+            return {
+              id: 0,
+              distRatio: 0
+            };
+          };
+          function IsosurfaceTrace(scene, mesh, uid2) {
+            this.scene = scene;
+            this.uid = uid2;
+            this.mesh = mesh;
+            this.name = "";
+            this.data = null;
+            this.showContour = false;
+          }
+          var proto = IsosurfaceTrace.prototype;
+          proto.handlePick = function(selection) {
+            if (selection.object === this.mesh) {
+              var rawId = selection.data.index;
+              var x2 = this.data._meshX[rawId];
+              var y2 = this.data._meshY[rawId];
+              var z2 = this.data._meshZ[rawId];
+              var height = this.data._Ys.length;
+              var depth = this.data._Zs.length;
+              var i2 = findNearestOnAxis(x2, this.data._Xs).id;
+              var j2 = findNearestOnAxis(y2, this.data._Ys).id;
+              var k2 = findNearestOnAxis(z2, this.data._Zs).id;
+              var selectIndex = selection.index = k2 + depth * j2 + depth * height * i2;
+              selection.traceCoordinate = [
+                this.data._meshX[selectIndex],
+                this.data._meshY[selectIndex],
+                this.data._meshZ[selectIndex],
+                this.data._value[selectIndex]
+              ];
+              var text = this.data.hovertext || this.data.text;
+              if (isArrayOrTypedArray(text) && text[selectIndex] !== void 0) {
+                selection.textLabel = text[selectIndex];
+              } else if (text) {
+                selection.textLabel = text;
+              }
+              return true;
+            }
+          };
+          proto.update = function(data) {
+            var scene = this.scene;
+            var layout = scene.fullSceneLayout;
+            this.data = generateIsoMeshes(data);
+            function toDataCoords(axis, coord, scale2, calendar) {
+              return coord.map(function(x2) {
+                return axis.d2l(x2, 0, calendar) * scale2;
+              });
+            }
+            var positions = zip3(
+              toDataCoords(layout.xaxis, data._meshX, scene.dataScale[0], data.xcalendar),
+              toDataCoords(layout.yaxis, data._meshY, scene.dataScale[1], data.ycalendar),
+              toDataCoords(layout.zaxis, data._meshZ, scene.dataScale[2], data.zcalendar)
+            );
+            var cells = zip3(data._meshI, data._meshJ, data._meshK);
+            var config2 = {
+              positions,
+              cells,
+              lightPosition: [data.lightposition.x, data.lightposition.y, data.lightposition.z],
+              ambient: data.lighting.ambient,
+              diffuse: data.lighting.diffuse,
+              specular: data.lighting.specular,
+              roughness: data.lighting.roughness,
+              fresnel: data.lighting.fresnel,
+              vertexNormalsEpsilon: data.lighting.vertexnormalsepsilon,
+              faceNormalsEpsilon: data.lighting.facenormalsepsilon,
+              opacity: data.opacity,
+              contourEnable: data.contour.show,
+              contourColor: str2RgbaArray(data.contour.color).slice(0, 3),
+              contourWidth: data.contour.width,
+              useFacetNormals: data.flatshading
+            };
+            var cOpts = extractOpts(data);
+            config2.vertexIntensity = data._meshIntensity;
+            config2.vertexIntensityBounds = [cOpts.min, cOpts.max];
+            config2.colormap = parseColorScale(data);
+            this.mesh.update(config2);
+          };
+          proto.dispose = function() {
+            this.scene.glplot.remove(this.mesh);
+            this.mesh.dispose();
+          };
+          var GRID_TYPES = ["xyz", "xzy", "yxz", "yzx", "zxy", "zyx"];
+          function generateIsoMeshes(data) {
+            data._meshI = [];
+            data._meshJ = [];
+            data._meshK = [];
+            var showSurface = data.surface.show;
+            var showSpaceframe = data.spaceframe.show;
+            var surfaceFill = data.surface.fill;
+            var spaceframeFill = data.spaceframe.fill;
+            var drawingSurface = false;
+            var drawingSpaceframe = false;
+            var numFaces = 0;
+            var numVertices;
+            var beginVertextLength;
+            var Xs = data._Xs;
+            var Ys = data._Ys;
+            var Zs = data._Zs;
+            var width = Xs.length;
+            var height = Ys.length;
+            var depth = Zs.length;
+            var filled = GRID_TYPES.indexOf(data._gridFill.replace(/-/g, "").replace(/\+/g, ""));
+            var getIndex = function(i2, j2, k2) {
+              switch (filled) {
+                case 5:
+                  return k2 + depth * j2 + depth * height * i2;
+                case 4:
+                  return k2 + depth * i2 + depth * width * j2;
+                case 3:
+                  return j2 + height * k2 + height * depth * i2;
+                case 2:
+                  return j2 + height * i2 + height * width * k2;
+                case 1:
+                  return i2 + width * k2 + width * depth * j2;
+                default:
+                  return i2 + width * j2 + width * height * k2;
+              }
+            };
+            var minValues = data._minValues;
+            var maxValues = data._maxValues;
+            var vMin = data._vMin;
+            var vMax = data._vMax;
+            var allXs;
+            var allYs;
+            var allZs;
+            var allVs;
+            function findVertexId(x2, y2, z2) {
+              var len2 = allVs.length;
+              for (var f2 = beginVertextLength; f2 < len2; f2++) {
+                if (x2 === allXs[f2] && y2 === allYs[f2] && z2 === allZs[f2]) {
+                  return f2;
+                }
+              }
+              return -1;
+            }
+            function beginGroup() {
+              beginVertextLength = numVertices;
+            }
+            function emptyVertices() {
+              allXs = [];
+              allYs = [];
+              allZs = [];
+              allVs = [];
+              numVertices = 0;
+              beginGroup();
+            }
+            function addVertex(x2, y2, z2, v2) {
+              allXs.push(x2);
+              allYs.push(y2);
+              allZs.push(z2);
+              allVs.push(v2);
+              numVertices++;
+              return numVertices - 1;
+            }
+            function addFace(a2, b2, c2) {
+              data._meshI.push(a2);
+              data._meshJ.push(b2);
+              data._meshK.push(c2);
+              numFaces++;
+              return numFaces - 1;
+            }
+            function getCenter2(A22, B22, C22) {
+              var M2 = [];
+              for (var i2 = 0; i2 < A22.length; i2++) {
+                M2[i2] = (A22[i2] + B22[i2] + C22[i2]) / 3;
+              }
+              return M2;
+            }
+            function getBetween(A22, B22, r2) {
+              var M2 = [];
+              for (var i2 = 0; i2 < A22.length; i2++) {
+                M2[i2] = A22[i2] * (1 - r2) + r2 * B22[i2];
+              }
+              return M2;
+            }
+            var activeFill;
+            function setFill(fill) {
+              activeFill = fill;
+            }
+            function createOpenTri(xyzv, abc) {
+              var A22 = xyzv[0];
+              var B22 = xyzv[1];
+              var C22 = xyzv[2];
+              var G2 = getCenter2(A22, B22, C22);
+              var r2 = Math.sqrt(1 - activeFill);
+              var p1 = getBetween(G2, A22, r2);
+              var p2 = getBetween(G2, B22, r2);
+              var p3 = getBetween(G2, C22, r2);
+              var a2 = abc[0];
+              var b2 = abc[1];
+              var c2 = abc[2];
+              return {
+                xyzv: [
+                  [A22, B22, p2],
+                  [p2, p1, A22],
+                  [B22, C22, p3],
+                  [p3, p2, B22],
+                  [C22, A22, p1],
+                  [p1, p3, C22]
+                ],
+                abc: [
+                  [a2, b2, -1],
+                  [-1, -1, a2],
+                  [b2, c2, -1],
+                  [-1, -1, b2],
+                  [c2, a2, -1],
+                  [-1, -1, c2]
+                ]
+              };
+            }
+            function styleIncludes(style, char) {
+              if (style === "all" || style === null) return true;
+              return style.indexOf(char) > -1;
+            }
+            function mapValue(style, value) {
+              if (style === null) return value;
+              return style;
+            }
+            function drawTri(style, xyzv, abc) {
+              beginGroup();
+              var allXYZVs = [xyzv];
+              var allABCs = [abc];
+              if (activeFill >= 1) {
+                allXYZVs = [xyzv];
+                allABCs = [abc];
+              } else if (activeFill > 0) {
+                var openTri = createOpenTri(xyzv, abc);
+                allXYZVs = openTri.xyzv;
+                allABCs = openTri.abc;
+              }
+              for (var f2 = 0; f2 < allXYZVs.length; f2++) {
+                xyzv = allXYZVs[f2];
+                abc = allABCs[f2];
+                var pnts = [];
+                for (var i2 = 0; i2 < 3; i2++) {
+                  var x2 = xyzv[i2][0];
+                  var y2 = xyzv[i2][1];
+                  var z2 = xyzv[i2][2];
+                  var v2 = xyzv[i2][3];
+                  var id2 = abc[i2] > -1 ? abc[i2] : findVertexId(x2, y2, z2);
+                  if (id2 > -1) {
+                    pnts[i2] = id2;
+                  } else {
+                    pnts[i2] = addVertex(x2, y2, z2, mapValue(style, v2));
+                  }
+                }
+                addFace(pnts[0], pnts[1], pnts[2]);
+              }
+            }
+            function drawQuad(style, xyzv, abcd) {
+              var makeTri = function(i2, j2, k2) {
+                drawTri(style, [xyzv[i2], xyzv[j2], xyzv[k2]], [abcd[i2], abcd[j2], abcd[k2]]);
+              };
+              makeTri(0, 1, 2);
+              makeTri(2, 3, 0);
+            }
+            function drawTetra(style, xyzv, abcd) {
+              var makeTri = function(i2, j2, k2) {
+                drawTri(style, [xyzv[i2], xyzv[j2], xyzv[k2]], [abcd[i2], abcd[j2], abcd[k2]]);
+              };
+              makeTri(0, 1, 2);
+              makeTri(3, 0, 1);
+              makeTri(2, 3, 0);
+              makeTri(1, 2, 3);
+            }
+            function calcIntersection(pointOut, pointIn, min, max) {
+              var value = pointOut[3];
+              if (value < min) value = min;
+              if (value > max) value = max;
+              var ratio = (pointOut[3] - value) / (pointOut[3] - pointIn[3] + 1e-9);
+              var result = [];
+              for (var s2 = 0; s2 < 4; s2++) {
+                result[s2] = (1 - ratio) * pointOut[s2] + ratio * pointIn[s2];
+              }
+              return result;
+            }
+            function inRange(value, min, max) {
+              return value >= min && value <= max;
+            }
+            function almostInFinalRange(value) {
+              var vErr = 1e-3 * (vMax - vMin);
+              return value >= vMin - vErr && value <= vMax + vErr;
+            }
+            function getXYZV(indecies) {
+              var xyzv = [];
+              for (var q2 = 0; q2 < 4; q2++) {
+                var index = indecies[q2];
+                xyzv.push(
+                  [
+                    data._x[index],
+                    data._y[index],
+                    data._z[index],
+                    data._value[index]
+                  ]
+                );
+              }
+              return xyzv;
+            }
+            var MAX_PASS = 3;
+            function tryCreateTri(style, xyzv, abc, min, max, nPass) {
+              if (!nPass) nPass = 1;
+              abc = [-1, -1, -1];
+              var result = false;
+              var ok2 = [
+                inRange(xyzv[0][3], min, max),
+                inRange(xyzv[1][3], min, max),
+                inRange(xyzv[2][3], min, max)
+              ];
+              if (!ok2[0] && !ok2[1] && !ok2[2]) {
+                return false;
+              }
+              var tryDrawTri = function(style2, xyzv2, abc2) {
+                if (
+                  // we check here if the points are in `real` iso-min/max range
+                  almostInFinalRange(xyzv2[0][3]) && almostInFinalRange(xyzv2[1][3]) && almostInFinalRange(xyzv2[2][3])
+                ) {
+                  drawTri(style2, xyzv2, abc2);
+                  return true;
+                } else if (nPass < MAX_PASS) {
+                  return tryCreateTri(style2, xyzv2, abc2, vMin, vMax, ++nPass);
+                }
+                return false;
+              };
+              if (ok2[0] && ok2[1] && ok2[2]) {
+                return tryDrawTri(style, xyzv, abc) || result;
+              }
+              var interpolated = false;
+              [
+                [0, 1, 2],
+                [2, 0, 1],
+                [1, 2, 0]
+              ].forEach(function(e2) {
+                if (ok2[e2[0]] && ok2[e2[1]] && !ok2[e2[2]]) {
+                  var A22 = xyzv[e2[0]];
+                  var B22 = xyzv[e2[1]];
+                  var C22 = xyzv[e2[2]];
+                  var p1 = calcIntersection(C22, A22, min, max);
+                  var p2 = calcIntersection(C22, B22, min, max);
+                  result = tryDrawTri(style, [p2, p1, A22], [-1, -1, abc[e2[0]]]) || result;
+                  result = tryDrawTri(style, [A22, B22, p2], [abc[e2[0]], abc[e2[1]], -1]) || result;
+                  interpolated = true;
+                }
+              });
+              if (interpolated) return result;
+              [
+                [0, 1, 2],
+                [1, 2, 0],
+                [2, 0, 1]
+              ].forEach(function(e2) {
+                if (ok2[e2[0]] && !ok2[e2[1]] && !ok2[e2[2]]) {
+                  var A22 = xyzv[e2[0]];
+                  var B22 = xyzv[e2[1]];
+                  var C22 = xyzv[e2[2]];
+                  var p1 = calcIntersection(B22, A22, min, max);
+                  var p2 = calcIntersection(C22, A22, min, max);
+                  result = tryDrawTri(style, [p2, p1, A22], [-1, -1, abc[e2[0]]]) || result;
+                  interpolated = true;
+                }
+              });
+              return result;
+            }
+            function tryCreateTetra(style, abcd, min, max) {
+              var result = false;
+              var xyzv = getXYZV(abcd);
+              var ok2 = [
+                inRange(xyzv[0][3], min, max),
+                inRange(xyzv[1][3], min, max),
+                inRange(xyzv[2][3], min, max),
+                inRange(xyzv[3][3], min, max)
+              ];
+              if (!ok2[0] && !ok2[1] && !ok2[2] && !ok2[3]) {
+                return result;
+              }
+              if (ok2[0] && ok2[1] && ok2[2] && ok2[3]) {
+                if (drawingSpaceframe) {
+                  result = drawTetra(style, xyzv, abcd) || result;
+                }
+                return result;
+              }
+              var interpolated = false;
+              [
+                [0, 1, 2, 3],
+                [3, 0, 1, 2],
+                [2, 3, 0, 1],
+                [1, 2, 3, 0]
+              ].forEach(function(e2) {
+                if (ok2[e2[0]] && ok2[e2[1]] && ok2[e2[2]] && !ok2[e2[3]]) {
+                  var A22 = xyzv[e2[0]];
+                  var B22 = xyzv[e2[1]];
+                  var C22 = xyzv[e2[2]];
+                  var D22 = xyzv[e2[3]];
+                  if (drawingSpaceframe) {
+                    result = drawTri(style, [A22, B22, C22], [abcd[e2[0]], abcd[e2[1]], abcd[e2[2]]]) || result;
+                  } else {
+                    var p1 = calcIntersection(D22, A22, min, max);
+                    var p2 = calcIntersection(D22, B22, min, max);
+                    var p3 = calcIntersection(D22, C22, min, max);
+                    result = drawTri(null, [p1, p2, p3], [-1, -1, -1]) || result;
+                  }
+                  interpolated = true;
+                }
+              });
+              if (interpolated) return result;
+              [
+                [0, 1, 2, 3],
+                [1, 2, 3, 0],
+                [2, 3, 0, 1],
+                [3, 0, 1, 2],
+                [0, 2, 3, 1],
+                [1, 3, 2, 0]
+              ].forEach(function(e2) {
+                if (ok2[e2[0]] && ok2[e2[1]] && !ok2[e2[2]] && !ok2[e2[3]]) {
+                  var A22 = xyzv[e2[0]];
+                  var B22 = xyzv[e2[1]];
+                  var C22 = xyzv[e2[2]];
+                  var D22 = xyzv[e2[3]];
+                  var p1 = calcIntersection(C22, A22, min, max);
+                  var p2 = calcIntersection(C22, B22, min, max);
+                  var p3 = calcIntersection(D22, B22, min, max);
+                  var p4 = calcIntersection(D22, A22, min, max);
+                  if (drawingSpaceframe) {
+                    result = drawTri(style, [A22, p4, p1], [abcd[e2[0]], -1, -1]) || result;
+                    result = drawTri(style, [B22, p2, p3], [abcd[e2[1]], -1, -1]) || result;
+                  } else {
+                    result = drawQuad(null, [p1, p2, p3, p4], [-1, -1, -1, -1]) || result;
+                  }
+                  interpolated = true;
+                }
+              });
+              if (interpolated) return result;
+              [
+                [0, 1, 2, 3],
+                [1, 2, 3, 0],
+                [2, 3, 0, 1],
+                [3, 0, 1, 2]
+              ].forEach(function(e2) {
+                if (ok2[e2[0]] && !ok2[e2[1]] && !ok2[e2[2]] && !ok2[e2[3]]) {
+                  var A22 = xyzv[e2[0]];
+                  var B22 = xyzv[e2[1]];
+                  var C22 = xyzv[e2[2]];
+                  var D22 = xyzv[e2[3]];
+                  var p1 = calcIntersection(B22, A22, min, max);
+                  var p2 = calcIntersection(C22, A22, min, max);
+                  var p3 = calcIntersection(D22, A22, min, max);
+                  if (drawingSpaceframe) {
+                    result = drawTri(style, [A22, p1, p2], [abcd[e2[0]], -1, -1]) || result;
+                    result = drawTri(style, [A22, p2, p3], [abcd[e2[0]], -1, -1]) || result;
+                    result = drawTri(style, [A22, p3, p1], [abcd[e2[0]], -1, -1]) || result;
+                  } else {
+                    result = drawTri(null, [p1, p2, p3], [-1, -1, -1]) || result;
+                  }
+                  interpolated = true;
+                }
+              });
+              return result;
+            }
+            function addCube(style, p000, p001, p010, p011, p100, p101, p110, p111, min, max) {
+              var result = false;
+              if (drawingSurface) {
+                if (styleIncludes(style, "A")) {
+                  result = tryCreateTetra(null, [p000, p001, p010, p100], min, max) || result;
+                }
+                if (styleIncludes(style, "B")) {
+                  result = tryCreateTetra(null, [p001, p010, p011, p111], min, max) || result;
+                }
+                if (styleIncludes(style, "C")) {
+                  result = tryCreateTetra(null, [p001, p100, p101, p111], min, max) || result;
+                }
+                if (styleIncludes(style, "D")) {
+                  result = tryCreateTetra(null, [p010, p100, p110, p111], min, max) || result;
+                }
+                if (styleIncludes(style, "E")) {
+                  result = tryCreateTetra(null, [p001, p010, p100, p111], min, max) || result;
+                }
+              }
+              if (drawingSpaceframe) {
+                result = tryCreateTetra(style, [p001, p010, p100, p111], min, max) || result;
+              }
+              return result;
+            }
+            function addRect(style, a2, b2, c2, d2, min, max, previousResult) {
+              return [
+                previousResult[0] === true ? true : tryCreateTri(style, getXYZV([a2, b2, c2]), [a2, b2, c2], min, max),
+                previousResult[1] === true ? true : tryCreateTri(style, getXYZV([c2, d2, a2]), [c2, d2, a2], min, max)
+              ];
+            }
+            function begin2dCell(style, p00, p01, p10, p11, min, max, isEven, previousResult) {
+              if (isEven) {
+                return addRect(style, p00, p01, p11, p10, min, max, previousResult);
+              } else {
+                return addRect(style, p01, p11, p10, p00, min, max, previousResult);
+              }
+            }
+            function beginSection(style, i2, j2, k2, min, max, distRatios) {
+              var result = false;
+              var A22, B22, C22, D22;
+              var makeSection = function() {
+                result = tryCreateTri(style, [A22, B22, C22], [-1, -1, -1], min, max) || result;
+                result = tryCreateTri(style, [C22, D22, A22], [-1, -1, -1], min, max) || result;
+              };
+              var rX = distRatios[0];
+              var rY = distRatios[1];
+              var rZ = distRatios[2];
+              if (rX) {
+                A22 = getBetween(getXYZV([getIndex(i2, j2 - 0, k2 - 0)])[0], getXYZV([getIndex(i2 - 1, j2 - 0, k2 - 0)])[0], rX);
+                B22 = getBetween(getXYZV([getIndex(i2, j2 - 0, k2 - 1)])[0], getXYZV([getIndex(i2 - 1, j2 - 0, k2 - 1)])[0], rX);
+                C22 = getBetween(getXYZV([getIndex(i2, j2 - 1, k2 - 1)])[0], getXYZV([getIndex(i2 - 1, j2 - 1, k2 - 1)])[0], rX);
+                D22 = getBetween(getXYZV([getIndex(i2, j2 - 1, k2 - 0)])[0], getXYZV([getIndex(i2 - 1, j2 - 1, k2 - 0)])[0], rX);
+                makeSection();
+              }
+              if (rY) {
+                A22 = getBetween(getXYZV([getIndex(i2 - 0, j2, k2 - 0)])[0], getXYZV([getIndex(i2 - 0, j2 - 1, k2 - 0)])[0], rY);
+                B22 = getBetween(getXYZV([getIndex(i2 - 0, j2, k2 - 1)])[0], getXYZV([getIndex(i2 - 0, j2 - 1, k2 - 1)])[0], rY);
+                C22 = getBetween(getXYZV([getIndex(i2 - 1, j2, k2 - 1)])[0], getXYZV([getIndex(i2 - 1, j2 - 1, k2 - 1)])[0], rY);
+                D22 = getBetween(getXYZV([getIndex(i2 - 1, j2, k2 - 0)])[0], getXYZV([getIndex(i2 - 1, j2 - 1, k2 - 0)])[0], rY);
+                makeSection();
+              }
+              if (rZ) {
+                A22 = getBetween(getXYZV([getIndex(i2 - 0, j2 - 0, k2)])[0], getXYZV([getIndex(i2 - 0, j2 - 0, k2 - 1)])[0], rZ);
+                B22 = getBetween(getXYZV([getIndex(i2 - 0, j2 - 1, k2)])[0], getXYZV([getIndex(i2 - 0, j2 - 1, k2 - 1)])[0], rZ);
+                C22 = getBetween(getXYZV([getIndex(i2 - 1, j2 - 1, k2)])[0], getXYZV([getIndex(i2 - 1, j2 - 1, k2 - 1)])[0], rZ);
+                D22 = getBetween(getXYZV([getIndex(i2 - 1, j2 - 0, k2)])[0], getXYZV([getIndex(i2 - 1, j2 - 0, k2 - 1)])[0], rZ);
+                makeSection();
+              }
+              return result;
+            }
+            function begin3dCell(style, p000, p001, p010, p011, p100, p101, p110, p111, min, max, isEven) {
+              var cellStyle = style;
+              if (isEven) {
+                if (drawingSurface && style === "even") cellStyle = null;
+                return addCube(cellStyle, p000, p001, p010, p011, p100, p101, p110, p111, min, max);
+              } else {
+                if (drawingSurface && style === "odd") cellStyle = null;
+                return addCube(cellStyle, p111, p110, p101, p100, p011, p010, p001, p000, min, max);
+              }
+            }
+            function draw2dX(style, items, min, max, previousResult) {
+              var result = [];
+              var n2 = 0;
+              for (var q2 = 0; q2 < items.length; q2++) {
+                var i2 = items[q2];
+                for (var k2 = 1; k2 < depth; k2++) {
+                  for (var j2 = 1; j2 < height; j2++) {
+                    result.push(
+                      begin2dCell(
+                        style,
+                        getIndex(i2, j2 - 1, k2 - 1),
+                        getIndex(i2, j2 - 1, k2),
+                        getIndex(i2, j2, k2 - 1),
+                        getIndex(i2, j2, k2),
+                        min,
+                        max,
+                        (i2 + j2 + k2) % 2,
+                        previousResult && previousResult[n2] ? previousResult[n2] : []
+                      )
+                    );
+                    n2++;
+                  }
+                }
+              }
+              return result;
+            }
+            function draw2dY(style, items, min, max, previousResult) {
+              var result = [];
+              var n2 = 0;
+              for (var q2 = 0; q2 < items.length; q2++) {
+                var j2 = items[q2];
+                for (var i2 = 1; i2 < width; i2++) {
+                  for (var k2 = 1; k2 < depth; k2++) {
+                    result.push(
+                      begin2dCell(
+                        style,
+                        getIndex(i2 - 1, j2, k2 - 1),
+                        getIndex(i2, j2, k2 - 1),
+                        getIndex(i2 - 1, j2, k2),
+                        getIndex(i2, j2, k2),
+                        min,
+                        max,
+                        (i2 + j2 + k2) % 2,
+                        previousResult && previousResult[n2] ? previousResult[n2] : []
+                      )
+                    );
+                    n2++;
+                  }
+                }
+              }
+              return result;
+            }
+            function draw2dZ(style, items, min, max, previousResult) {
+              var result = [];
+              var n2 = 0;
+              for (var q2 = 0; q2 < items.length; q2++) {
+                var k2 = items[q2];
+                for (var j2 = 1; j2 < height; j2++) {
+                  for (var i2 = 1; i2 < width; i2++) {
+                    result.push(
+                      begin2dCell(
+                        style,
+                        getIndex(i2 - 1, j2 - 1, k2),
+                        getIndex(i2 - 1, j2, k2),
+                        getIndex(i2, j2 - 1, k2),
+                        getIndex(i2, j2, k2),
+                        min,
+                        max,
+                        (i2 + j2 + k2) % 2,
+                        previousResult && previousResult[n2] ? previousResult[n2] : []
+                      )
+                    );
+                    n2++;
+                  }
+                }
+              }
+              return result;
+            }
+            function draw3d(style, min, max) {
+              for (var k2 = 1; k2 < depth; k2++) {
+                for (var j2 = 1; j2 < height; j2++) {
+                  for (var i2 = 1; i2 < width; i2++) {
+                    begin3dCell(
+                      style,
+                      getIndex(i2 - 1, j2 - 1, k2 - 1),
+                      getIndex(i2 - 1, j2 - 1, k2),
+                      getIndex(i2 - 1, j2, k2 - 1),
+                      getIndex(i2 - 1, j2, k2),
+                      getIndex(i2, j2 - 1, k2 - 1),
+                      getIndex(i2, j2 - 1, k2),
+                      getIndex(i2, j2, k2 - 1),
+                      getIndex(i2, j2, k2),
+                      min,
+                      max,
+                      (i2 + j2 + k2) % 2
+                    );
+                  }
+                }
+              }
+            }
+            function drawSpaceframe(style, min, max) {
+              drawingSpaceframe = true;
+              draw3d(style, min, max);
+              drawingSpaceframe = false;
+            }
+            function drawSurface(style, min, max) {
+              drawingSurface = true;
+              draw3d(style, min, max);
+              drawingSurface = false;
+            }
+            function drawSectionX(style, items, min, max, distRatios, previousResult) {
+              var result = [];
+              var n2 = 0;
+              for (var q2 = 0; q2 < items.length; q2++) {
+                var i2 = items[q2];
+                for (var k2 = 1; k2 < depth; k2++) {
+                  for (var j2 = 1; j2 < height; j2++) {
+                    result.push(
+                      beginSection(
+                        style,
+                        i2,
+                        j2,
+                        k2,
+                        min,
+                        max,
+                        distRatios[q2],
+                        previousResult && previousResult[n2] ? previousResult[n2] : []
+                      )
+                    );
+                    n2++;
+                  }
+                }
+              }
+              return result;
+            }
+            function drawSectionY(style, items, min, max, distRatios, previousResult) {
+              var result = [];
+              var n2 = 0;
+              for (var q2 = 0; q2 < items.length; q2++) {
+                var j2 = items[q2];
+                for (var i2 = 1; i2 < width; i2++) {
+                  for (var k2 = 1; k2 < depth; k2++) {
+                    result.push(
+                      beginSection(
+                        style,
+                        i2,
+                        j2,
+                        k2,
+                        min,
+                        max,
+                        distRatios[q2],
+                        previousResult && previousResult[n2] ? previousResult[n2] : []
+                      )
+                    );
+                    n2++;
+                  }
+                }
+              }
+              return result;
+            }
+            function drawSectionZ(style, items, min, max, distRatios, previousResult) {
+              var result = [];
+              var n2 = 0;
+              for (var q2 = 0; q2 < items.length; q2++) {
+                var k2 = items[q2];
+                for (var j2 = 1; j2 < height; j2++) {
+                  for (var i2 = 1; i2 < width; i2++) {
+                    result.push(
+                      beginSection(
+                        style,
+                        i2,
+                        j2,
+                        k2,
+                        min,
+                        max,
+                        distRatios[q2],
+                        previousResult && previousResult[n2] ? previousResult[n2] : []
+                      )
+                    );
+                    n2++;
+                  }
+                }
+              }
+              return result;
+            }
+            function createRange(a2, b2) {
+              var range = [];
+              for (var q2 = a2; q2 < b2; q2++) {
+                range.push(q2);
+              }
+              return range;
+            }
+            function insertGridPoints() {
+              for (var i2 = 0; i2 < width; i2++) {
+                for (var j2 = 0; j2 < height; j2++) {
+                  for (var k2 = 0; k2 < depth; k2++) {
+                    var index = getIndex(i2, j2, k2);
+                    addVertex(
+                      data._x[index],
+                      data._y[index],
+                      data._z[index],
+                      data._value[index]
+                    );
+                  }
+                }
+              }
+            }
+            function drawAll() {
+              emptyVertices();
+              insertGridPoints();
+              var activeStyle = null;
+              if (showSpaceframe && spaceframeFill) {
+                setFill(spaceframeFill);
+                drawSpaceframe(activeStyle, vMin, vMax);
+              }
+              if (showSurface && surfaceFill) {
+                setFill(surfaceFill);
+                var surfacePattern = data.surface.pattern;
+                var surfaceCount = data.surface.count;
+                for (var q2 = 0; q2 < surfaceCount; q2++) {
+                  var ratio = surfaceCount === 1 ? 0.5 : q2 / (surfaceCount - 1);
+                  var level = (1 - ratio) * vMin + ratio * vMax;
+                  var d1 = Math.abs(level - minValues);
+                  var d2 = Math.abs(level - maxValues);
+                  var ranges = d1 > d2 ? [minValues, level] : [level, maxValues];
+                  drawSurface(surfacePattern, ranges[0], ranges[1]);
+                }
+              }
+              var setupMinMax = [
+                [Math.min(vMin, maxValues), Math.max(vMin, maxValues)],
+                [Math.min(minValues, vMax), Math.max(minValues, vMax)]
+              ];
+              ["x", "y", "z"].forEach(function(e2) {
+                var preRes = [];
+                for (var s2 = 0; s2 < setupMinMax.length; s2++) {
+                  var count2 = 0;
+                  var activeMin = setupMinMax[s2][0];
+                  var activeMax = setupMinMax[s2][1];
+                  var slice = data.slices[e2];
+                  if (slice.show && slice.fill) {
+                    setFill(slice.fill);
+                    var exactIndices = [];
+                    var ceilIndices = [];
+                    var distRatios = [];
+                    if (slice.locations.length) {
+                      for (var q22 = 0; q22 < slice.locations.length; q22++) {
+                        var near = findNearestOnAxis(
+                          slice.locations[q22],
+                          e2 === "x" ? Xs : e2 === "y" ? Ys : Zs
+                        );
+                        if (near.distRatio === 0) {
+                          exactIndices.push(near.id);
+                        } else if (near.id > 0) {
+                          ceilIndices.push(near.id);
+                          if (e2 === "x") {
+                            distRatios.push([near.distRatio, 0, 0]);
+                          } else if (e2 === "y") {
+                            distRatios.push([0, near.distRatio, 0]);
+                          } else {
+                            distRatios.push([0, 0, near.distRatio]);
+                          }
+                        }
+                      }
+                    } else {
+                      if (e2 === "x") {
+                        exactIndices = createRange(1, width - 1);
+                      } else if (e2 === "y") {
+                        exactIndices = createRange(1, height - 1);
+                      } else {
+                        exactIndices = createRange(1, depth - 1);
+                      }
+                    }
+                    if (ceilIndices.length > 0) {
+                      if (e2 === "x") {
+                        preRes[count2] = drawSectionX(activeStyle, ceilIndices, activeMin, activeMax, distRatios, preRes[count2]);
+                      } else if (e2 === "y") {
+                        preRes[count2] = drawSectionY(activeStyle, ceilIndices, activeMin, activeMax, distRatios, preRes[count2]);
+                      } else {
+                        preRes[count2] = drawSectionZ(activeStyle, ceilIndices, activeMin, activeMax, distRatios, preRes[count2]);
+                      }
+                      count2++;
+                    }
+                    if (exactIndices.length > 0) {
+                      if (e2 === "x") {
+                        preRes[count2] = draw2dX(activeStyle, exactIndices, activeMin, activeMax, preRes[count2]);
+                      } else if (e2 === "y") {
+                        preRes[count2] = draw2dY(activeStyle, exactIndices, activeMin, activeMax, preRes[count2]);
+                      } else {
+                        preRes[count2] = draw2dZ(activeStyle, exactIndices, activeMin, activeMax, preRes[count2]);
+                      }
+                      count2++;
+                    }
+                  }
+                  var cap = data.caps[e2];
+                  if (cap.show && cap.fill) {
+                    setFill(cap.fill);
+                    if (e2 === "x") {
+                      preRes[count2] = draw2dX(activeStyle, [0, width - 1], activeMin, activeMax, preRes[count2]);
+                    } else if (e2 === "y") {
+                      preRes[count2] = draw2dY(activeStyle, [0, height - 1], activeMin, activeMax, preRes[count2]);
+                    } else {
+                      preRes[count2] = draw2dZ(activeStyle, [0, depth - 1], activeMin, activeMax, preRes[count2]);
+                    }
+                    count2++;
+                  }
+                }
+              });
+              if (numFaces === 0) {
+                emptyVertices();
+              }
+              data._meshX = allXs;
+              data._meshY = allYs;
+              data._meshZ = allZs;
+              data._meshIntensity = allVs;
+              data._Xs = Xs;
+              data._Ys = Ys;
+              data._Zs = Zs;
+            }
+            drawAll();
+            return data;
           }
+          function createIsosurfaceTrace(scene, data) {
+            var gl2 = scene.glplot.gl;
+            var mesh = createMesh({ gl: gl2 });
+            var result = new IsosurfaceTrace(scene, mesh, data.uid);
+            mesh._trace = result;
+            result.update(data);
+            scene.glplot.add(mesh);
+            return result;
+          }
+          module2.exports = {
+            findNearestOnAxis,
+            generateIsoMeshes,
+            createIsosurfaceTrace
+          };
         }
-      }
-      var latlngCenter = crs.unproject(toPoint(center));
-      return toLatLng([latlngCenter.lat + centroidLatLng.lat, latlngCenter.lng + centroidLatLng.lng]);
-    }
-    var LineUtil = {
-      __proto__: null,
-      simplify,
-      pointToSegmentDistance,
-      closestPointOnSegment,
-      clipSegment,
-      _getEdgeIntersection,
-      _getBitCode,
-      _sqClosestPointOnSegment,
-      isFlat,
-      _flat,
-      polylineCenter
-    };
-    var LonLat = {
-      project: function(latlng) {
-        return new Point(latlng.lng, latlng.lat);
-      },
-      unproject: function(point) {
-        return new LatLng(point.y, point.x);
-      },
-      bounds: new Bounds([-180, -90], [180, 90])
-    };
-    var Mercator = {
-      R: 6378137,
-      R_MINOR: 6356752314245179e-9,
-      bounds: new Bounds([-2003750834279e-5, -1549657073972e-5], [2003750834279e-5, 1876465623138e-5]),
-      project: function(latlng) {
-        var d = Math.PI / 180, r2 = this.R, y2 = latlng.lat * d, tmp = this.R_MINOR / r2, e = Math.sqrt(1 - tmp * tmp), con = e * Math.sin(y2);
-        var ts = Math.tan(Math.PI / 4 - y2 / 2) / Math.pow((1 - con) / (1 + con), e / 2);
-        y2 = -r2 * Math.log(Math.max(ts, 1e-10));
-        return new Point(latlng.lng * d * r2, y2);
-      },
-      unproject: function(point) {
-        var d = 180 / Math.PI, r2 = this.R, tmp = this.R_MINOR / r2, e = Math.sqrt(1 - tmp * tmp), ts = Math.exp(-point.y / r2), phi = Math.PI / 2 - 2 * Math.atan(ts);
-        for (var i = 0, dphi = 0.1, con; i < 15 && Math.abs(dphi) > 1e-7; i++) {
-          con = e * Math.sin(phi);
-          con = Math.pow((1 - con) / (1 + con), e / 2);
-          dphi = Math.PI / 2 - 2 * Math.atan(ts * con) - phi;
-          phi += dphi;
-        }
-        return new LatLng(phi * d, point.x * d / r2);
-      }
-    };
-    var index = {
-      __proto__: null,
-      LonLat,
-      Mercator,
-      SphericalMercator
-    };
-    var EPSG3395 = extend({}, Earth, {
-      code: "EPSG:3395",
-      projection: Mercator,
-      transformation: function() {
-        var scale2 = 0.5 / (Math.PI * Mercator.R);
-        return toTransformation(scale2, 0.5, -scale2, 0.5);
-      }()
-    });
-    var EPSG4326 = extend({}, Earth, {
-      code: "EPSG:4326",
-      projection: LonLat,
-      transformation: toTransformation(1 / 180, 1, -1 / 180, 0.5)
-    });
-    var Simple = extend({}, CRS, {
-      projection: LonLat,
-      transformation: toTransformation(1, 0, -1, 0),
-      scale: function(zoom2) {
-        return Math.pow(2, zoom2);
-      },
-      zoom: function(scale2) {
-        return Math.log(scale2) / Math.LN2;
-      },
-      distance: function(latlng1, latlng2) {
-        var dx = latlng2.lng - latlng1.lng, dy = latlng2.lat - latlng1.lat;
-        return Math.sqrt(dx * dx + dy * dy);
-      },
-      infinite: true
-    });
-    CRS.Earth = Earth;
-    CRS.EPSG3395 = EPSG3395;
-    CRS.EPSG3857 = EPSG3857;
-    CRS.EPSG900913 = EPSG900913;
-    CRS.EPSG4326 = EPSG4326;
-    CRS.Simple = Simple;
-    var Layer = Evented.extend({
-      // Classes extending `L.Layer` will inherit the following options:
-      options: {
-        // @option pane: String = 'overlayPane'
-        // By default the layer will be added to the map's [overlay pane](#map-overlaypane). Overriding this option will cause the layer to be placed on another pane by default.
-        pane: "overlayPane",
-        // @option attribution: String = null
-        // String to be shown in the attribution control, e.g. "© OpenStreetMap contributors". It describes the layer data and is often a legal obligation towards copyright holders and tile providers.
-        attribution: null,
-        bubblingMouseEvents: true
-      },
-      /* @section
-       * Classes extending `L.Layer` will inherit the following methods:
-       *
-       * @method addTo(map: Map|LayerGroup): this
-       * Adds the layer to the given map or layer group.
-       */
-      addTo: function(map2) {
-        map2.addLayer(this);
-        return this;
-      },
-      // @method remove: this
-      // Removes the layer from the map it is currently active on.
-      remove: function() {
-        return this.removeFrom(this._map || this._mapToAdd);
-      },
-      // @method removeFrom(map: Map): this
-      // Removes the layer from the given map
-      //
-      // @alternative
-      // @method removeFrom(group: LayerGroup): this
-      // Removes the layer from the given `LayerGroup`
-      removeFrom: function(obj) {
-        if (obj) {
-          obj.removeLayer(this);
-        }
-        return this;
-      },
-      // @method getPane(name? : String): HTMLElement
-      // Returns the `HTMLElement` representing the named pane on the map. If `name` is omitted, returns the pane for this layer.
-      getPane: function(name) {
-        return this._map.getPane(name ? this.options[name] || name : this.options.pane);
-      },
-      addInteractiveTarget: function(targetEl) {
-        this._map._targets[stamp(targetEl)] = this;
-        return this;
-      },
-      removeInteractiveTarget: function(targetEl) {
-        delete this._map._targets[stamp(targetEl)];
-        return this;
-      },
-      // @method getAttribution: String
-      // Used by the `attribution control`, returns the [attribution option](#gridlayer-attribution).
-      getAttribution: function() {
-        return this.options.attribution;
-      },
-      _layerAdd: function(e) {
-        var map2 = e.target;
-        if (!map2.hasLayer(this)) {
-          return;
-        }
-        this._map = map2;
-        this._zoomAnimated = map2._zoomAnimated;
-        if (this.getEvents) {
-          var events = this.getEvents();
-          map2.on(events, this);
-          this.once("remove", function() {
-            map2.off(events, this);
-          }, this);
-        }
-        this.onAdd(map2);
-        this.fire("add");
-        map2.fire("layeradd", { layer: this });
-      }
-    });
-    Map2.include({
-      // @method addLayer(layer: Layer): this
-      // Adds the given layer to the map
-      addLayer: function(layer) {
-        if (!layer._layerAdd) {
-          throw new Error("The provided object is not a Layer.");
-        }
-        var id2 = stamp(layer);
-        if (this._layers[id2]) {
-          return this;
-        }
-        this._layers[id2] = layer;
-        layer._mapToAdd = this;
-        if (layer.beforeAdd) {
-          layer.beforeAdd(this);
-        }
-        this.whenReady(layer._layerAdd, layer);
-        return this;
-      },
-      // @method removeLayer(layer: Layer): this
-      // Removes the given layer from the map.
-      removeLayer: function(layer) {
-        var id2 = stamp(layer);
-        if (!this._layers[id2]) {
-          return this;
-        }
-        if (this._loaded) {
-          layer.onRemove(this);
-        }
-        delete this._layers[id2];
-        if (this._loaded) {
-          this.fire("layerremove", { layer });
-          layer.fire("remove");
-        }
-        layer._map = layer._mapToAdd = null;
-        return this;
-      },
-      // @method hasLayer(layer: Layer): Boolean
-      // Returns `true` if the given layer is currently added to the map
-      hasLayer: function(layer) {
-        return stamp(layer) in this._layers;
-      },
-      /* @method eachLayer(fn: Function, context?: Object): this
-       * Iterates over the layers of the map, optionally specifying context of the iterator function.
-       * ```
-       * map.eachLayer(function(layer){
-       *     layer.bindPopup('Hello');
-       * });
-       * ```
-       */
-      eachLayer: function(method, context) {
-        for (var i in this._layers) {
-          method.call(context, this._layers[i]);
-        }
-        return this;
-      },
-      _addLayers: function(layers2) {
-        layers2 = layers2 ? isArray2(layers2) ? layers2 : [layers2] : [];
-        for (var i = 0, len = layers2.length; i < len; i++) {
-          this.addLayer(layers2[i]);
-        }
-      },
-      _addZoomLimit: function(layer) {
-        if (!isNaN(layer.options.maxZoom) || !isNaN(layer.options.minZoom)) {
-          this._zoomBoundLayers[stamp(layer)] = layer;
-          this._updateZoomLevels();
-        }
-      },
-      _removeZoomLimit: function(layer) {
-        var id2 = stamp(layer);
-        if (this._zoomBoundLayers[id2]) {
-          delete this._zoomBoundLayers[id2];
-          this._updateZoomLevels();
-        }
-      },
-      _updateZoomLevels: function() {
-        var minZoom = Infinity, maxZoom = -Infinity, oldZoomSpan = this._getZoomSpan();
-        for (var i in this._zoomBoundLayers) {
-          var options = this._zoomBoundLayers[i].options;
-          minZoom = options.minZoom === void 0 ? minZoom : Math.min(minZoom, options.minZoom);
-          maxZoom = options.maxZoom === void 0 ? maxZoom : Math.max(maxZoom, options.maxZoom);
+      });
+      var require_isosurface = __commonJS({
+        "src/traces/isosurface/index.js"(exports, module2) {
+          module2.exports = {
+            attributes: require_attributes44(),
+            supplyDefaults: require_defaults39().supplyDefaults,
+            calc: require_calc24(),
+            colorbar: {
+              min: "cmin",
+              max: "cmax"
+            },
+            plot: require_convert5().createIsosurfaceTrace,
+            moduleType: "trace",
+            name: "isosurface",
+            basePlotModule: require_gl3d(),
+            categories: ["gl3d", "showLegend"],
+            meta: {}
+          };
         }
-        this._layersMaxZoom = maxZoom === -Infinity ? void 0 : maxZoom;
-        this._layersMinZoom = minZoom === Infinity ? void 0 : minZoom;
-        if (oldZoomSpan !== this._getZoomSpan()) {
-          this.fire("zoomlevelschange");
+      });
+      var require_isosurface2 = __commonJS({
+        "lib/isosurface.js"(exports, module2) {
+          module2.exports = require_isosurface();
         }
-        if (this.options.maxZoom === void 0 && this._layersMaxZoom && this.getZoom() > this._layersMaxZoom) {
-          this.setZoom(this._layersMaxZoom);
+      });
+      var require_attributes45 = __commonJS({
+        "src/traces/volume/attributes.js"(exports, module2) {
+          var colorScaleAttrs = require_attributes8();
+          var isosurfaceAttrs = require_attributes44();
+          var surfaceAttrs = require_attributes42();
+          var baseAttrs = require_attributes2();
+          var extendFlat = require_extend().extendFlat;
+          var overrideAll = require_edit_types().overrideAll;
+          var attrs = module2.exports = overrideAll(
+            extendFlat(
+              {
+                x: isosurfaceAttrs.x,
+                y: isosurfaceAttrs.y,
+                z: isosurfaceAttrs.z,
+                value: isosurfaceAttrs.value,
+                isomin: isosurfaceAttrs.isomin,
+                isomax: isosurfaceAttrs.isomax,
+                surface: isosurfaceAttrs.surface,
+                spaceframe: {
+                  show: {
+                    valType: "boolean",
+                    dflt: false
+                  },
+                  fill: {
+                    valType: "number",
+                    min: 0,
+                    max: 1,
+                    dflt: 1
+                  }
+                },
+                slices: isosurfaceAttrs.slices,
+                caps: isosurfaceAttrs.caps,
+                text: isosurfaceAttrs.text,
+                hovertext: isosurfaceAttrs.hovertext,
+                xhoverformat: isosurfaceAttrs.xhoverformat,
+                yhoverformat: isosurfaceAttrs.yhoverformat,
+                zhoverformat: isosurfaceAttrs.zhoverformat,
+                valuehoverformat: isosurfaceAttrs.valuehoverformat,
+                hovertemplate: isosurfaceAttrs.hovertemplate,
+                hovertemplatefallback: isosurfaceAttrs.hovertemplatefallback
+              },
+              colorScaleAttrs("", {
+                colorAttr: "`value`",
+                showScaleDflt: true,
+                editTypeOverride: "calc"
+              }),
+              {
+                colorbar: isosurfaceAttrs.colorbar,
+                opacity: isosurfaceAttrs.opacity,
+                opacityscale: surfaceAttrs.opacityscale,
+                lightposition: isosurfaceAttrs.lightposition,
+                lighting: isosurfaceAttrs.lighting,
+                flatshading: isosurfaceAttrs.flatshading,
+                contour: isosurfaceAttrs.contour,
+                hoverinfo: extendFlat({}, baseAttrs.hoverinfo),
+                showlegend: extendFlat({}, baseAttrs.showlegend, { dflt: false })
+              }
+            ),
+            "calc",
+            "nested"
+          );
+          attrs.x.editType = attrs.y.editType = attrs.z.editType = attrs.value.editType = "calc+clearAxisTypes";
         }
-        if (this.options.minZoom === void 0 && this._layersMinZoom && this.getZoom() < this._layersMinZoom) {
-          this.setZoom(this._layersMinZoom);
+      });
+      var require_defaults40 = __commonJS({
+        "src/traces/volume/defaults.js"(exports, module2) {
+          var Lib = require_lib();
+          var attributes = require_attributes45();
+          var supplyIsoDefaults = require_defaults39().supplyIsoDefaults;
+          var opacityscaleDefaults = require_defaults38().opacityscaleDefaults;
+          module2.exports = function supplyDefaults(traceIn, traceOut, defaultColor, layout) {
+            function coerce(attr, dflt) {
+              return Lib.coerce(traceIn, traceOut, attributes, attr, dflt);
+            }
+            supplyIsoDefaults(traceIn, traceOut, defaultColor, layout, coerce);
+            opacityscaleDefaults(traceIn, traceOut, layout, coerce);
+          };
         }
-      }
-    });
-    var LayerGroup = Layer.extend({
-      initialize: function(layers2, options) {
-        setOptions2(this, options);
-        this._layers = {};
-        var i, len;
-        if (layers2) {
-          for (i = 0, len = layers2.length; i < len; i++) {
-            this.addLayer(layers2[i]);
+      });
+      var require_convert6 = __commonJS({
+        "src/traces/volume/convert.js"(exports, module2) {
+          var createMesh = require_stackgl_modules().gl_mesh3d;
+          var parseColorScale = require_gl_format_color().parseColorScale;
+          var isArrayOrTypedArray = require_lib().isArrayOrTypedArray;
+          var str2RgbaArray = require_str2rgbarray();
+          var extractOpts = require_colorscale().extractOpts;
+          var zip3 = require_zip3();
+          var findNearestOnAxis = require_convert5().findNearestOnAxis;
+          var generateIsoMeshes = require_convert5().generateIsoMeshes;
+          function VolumeTrace(scene, mesh, uid2) {
+            this.scene = scene;
+            this.uid = uid2;
+            this.mesh = mesh;
+            this.name = "";
+            this.data = null;
+            this.showContour = false;
+          }
+          var proto = VolumeTrace.prototype;
+          proto.handlePick = function(selection) {
+            if (selection.object === this.mesh) {
+              var rawId = selection.data.index;
+              var x2 = this.data._meshX[rawId];
+              var y2 = this.data._meshY[rawId];
+              var z2 = this.data._meshZ[rawId];
+              var height = this.data._Ys.length;
+              var depth = this.data._Zs.length;
+              var i2 = findNearestOnAxis(x2, this.data._Xs).id;
+              var j2 = findNearestOnAxis(y2, this.data._Ys).id;
+              var k2 = findNearestOnAxis(z2, this.data._Zs).id;
+              var selectIndex = selection.index = k2 + depth * j2 + depth * height * i2;
+              selection.traceCoordinate = [
+                this.data._meshX[selectIndex],
+                this.data._meshY[selectIndex],
+                this.data._meshZ[selectIndex],
+                this.data._value[selectIndex]
+              ];
+              var text = this.data.hovertext || this.data.text;
+              if (isArrayOrTypedArray(text) && text[selectIndex] !== void 0) {
+                selection.textLabel = text[selectIndex];
+              } else if (text) {
+                selection.textLabel = text;
+              }
+              return true;
+            }
+          };
+          proto.update = function(data) {
+            var scene = this.scene;
+            var layout = scene.fullSceneLayout;
+            this.data = generateIsoMeshes(data);
+            function toDataCoords(axis, coord, scale2, calendar) {
+              return coord.map(function(x2) {
+                return axis.d2l(x2, 0, calendar) * scale2;
+              });
+            }
+            var positions = zip3(
+              toDataCoords(layout.xaxis, data._meshX, scene.dataScale[0], data.xcalendar),
+              toDataCoords(layout.yaxis, data._meshY, scene.dataScale[1], data.ycalendar),
+              toDataCoords(layout.zaxis, data._meshZ, scene.dataScale[2], data.zcalendar)
+            );
+            var cells = zip3(data._meshI, data._meshJ, data._meshK);
+            var config2 = {
+              positions,
+              cells,
+              lightPosition: [data.lightposition.x, data.lightposition.y, data.lightposition.z],
+              ambient: data.lighting.ambient,
+              diffuse: data.lighting.diffuse,
+              specular: data.lighting.specular,
+              roughness: data.lighting.roughness,
+              fresnel: data.lighting.fresnel,
+              vertexNormalsEpsilon: data.lighting.vertexnormalsepsilon,
+              faceNormalsEpsilon: data.lighting.facenormalsepsilon,
+              opacity: data.opacity,
+              opacityscale: data.opacityscale,
+              contourEnable: data.contour.show,
+              contourColor: str2RgbaArray(data.contour.color).slice(0, 3),
+              contourWidth: data.contour.width,
+              useFacetNormals: data.flatshading
+            };
+            var cOpts = extractOpts(data);
+            config2.vertexIntensity = data._meshIntensity;
+            config2.vertexIntensityBounds = [cOpts.min, cOpts.max];
+            config2.colormap = parseColorScale(data);
+            this.mesh.update(config2);
+          };
+          proto.dispose = function() {
+            this.scene.glplot.remove(this.mesh);
+            this.mesh.dispose();
+          };
+          function createVolumeTrace(scene, data) {
+            var gl2 = scene.glplot.gl;
+            var mesh = createMesh({ gl: gl2 });
+            var result = new VolumeTrace(scene, mesh, data.uid);
+            mesh._trace = result;
+            result.update(data);
+            scene.glplot.add(mesh);
+            return result;
           }
+          module2.exports = createVolumeTrace;
         }
-      },
-      // @method addLayer(layer: Layer): this
-      // Adds the given layer to the group.
-      addLayer: function(layer) {
-        var id2 = this.getLayerId(layer);
-        this._layers[id2] = layer;
-        if (this._map) {
-          this._map.addLayer(layer);
-        }
-        return this;
-      },
-      // @method removeLayer(layer: Layer): this
-      // Removes the given layer from the group.
-      // @alternative
-      // @method removeLayer(id: Number): this
-      // Removes the layer with the given internal ID from the group.
-      removeLayer: function(layer) {
-        var id2 = layer in this._layers ? layer : this.getLayerId(layer);
-        if (this._map && this._layers[id2]) {
-          this._map.removeLayer(this._layers[id2]);
-        }
-        delete this._layers[id2];
-        return this;
-      },
-      // @method hasLayer(layer: Layer): Boolean
-      // Returns `true` if the given layer is currently added to the group.
-      // @alternative
-      // @method hasLayer(id: Number): Boolean
-      // Returns `true` if the given internal ID is currently added to the group.
-      hasLayer: function(layer) {
-        var layerId = typeof layer === "number" ? layer : this.getLayerId(layer);
-        return layerId in this._layers;
-      },
-      // @method clearLayers(): this
-      // Removes all the layers from the group.
-      clearLayers: function() {
-        return this.eachLayer(this.removeLayer, this);
-      },
-      // @method invoke(methodName: String, …): this
-      // Calls `methodName` on every layer contained in this group, passing any
-      // additional parameters. Has no effect if the layers contained do not
-      // implement `methodName`.
-      invoke: function(methodName) {
-        var args = Array.prototype.slice.call(arguments, 1), i, layer;
-        for (i in this._layers) {
-          layer = this._layers[i];
-          if (layer[methodName]) {
-            layer[methodName].apply(layer, args);
-          }
-        }
-        return this;
-      },
-      onAdd: function(map2) {
-        this.eachLayer(map2.addLayer, map2);
-      },
-      onRemove: function(map2) {
-        this.eachLayer(map2.removeLayer, map2);
-      },
-      // @method eachLayer(fn: Function, context?: Object): this
-      // Iterates over the layers of the group, optionally specifying context of the iterator function.
-      // ```js
-      // group.eachLayer(function (layer) {
-      // 	layer.bindPopup('Hello');
-      // });
-      // ```
-      eachLayer: function(method, context) {
-        for (var i in this._layers) {
-          method.call(context, this._layers[i]);
-        }
-        return this;
-      },
-      // @method getLayer(id: Number): Layer
-      // Returns the layer with the given internal ID.
-      getLayer: function(id2) {
-        return this._layers[id2];
-      },
-      // @method getLayers(): Layer[]
-      // Returns an array of all the layers added to the group.
-      getLayers: function() {
-        var layers2 = [];
-        this.eachLayer(layers2.push, layers2);
-        return layers2;
-      },
-      // @method setZIndex(zIndex: Number): this
-      // Calls `setZIndex` on every layer contained in this group, passing the z-index.
-      setZIndex: function(zIndex) {
-        return this.invoke("setZIndex", zIndex);
-      },
-      // @method getLayerId(layer: Layer): Number
-      // Returns the internal ID for a layer
-      getLayerId: function(layer) {
-        return stamp(layer);
-      }
-    });
-    var layerGroup = function(layers2, options) {
-      return new LayerGroup(layers2, options);
-    };
-    var FeatureGroup = LayerGroup.extend({
-      addLayer: function(layer) {
-        if (this.hasLayer(layer)) {
-          return this;
+      });
+      var require_volume = __commonJS({
+        "src/traces/volume/index.js"(exports, module2) {
+          module2.exports = {
+            attributes: require_attributes45(),
+            supplyDefaults: require_defaults40(),
+            calc: require_calc24(),
+            colorbar: {
+              min: "cmin",
+              max: "cmax"
+            },
+            plot: require_convert6(),
+            moduleType: "trace",
+            name: "volume",
+            basePlotModule: require_gl3d(),
+            categories: ["gl3d", "showLegend"],
+            meta: {}
+          };
         }
-        layer.addEventParent(this);
-        LayerGroup.prototype.addLayer.call(this, layer);
-        return this.fire("layeradd", { layer });
-      },
-      removeLayer: function(layer) {
-        if (!this.hasLayer(layer)) {
-          return this;
+      });
+      var require_volume2 = __commonJS({
+        "lib/volume.js"(exports, module2) {
+          module2.exports = require_volume();
         }
-        if (layer in this._layers) {
-          layer = this._layers[layer];
+      });
+      var require_defaults41 = __commonJS({
+        "src/traces/mesh3d/defaults.js"(exports, module2) {
+          var Registry = require_registry();
+          var Lib = require_lib();
+          var colorscaleDefaults = require_defaults2();
+          var attributes = require_attributes43();
+          module2.exports = function supplyDefaults(traceIn, traceOut, defaultColor, layout) {
+            function coerce(attr, dflt) {
+              return Lib.coerce(traceIn, traceOut, attributes, attr, dflt);
+            }
+            function readComponents(array) {
+              var ret = array.map(function(attr) {
+                var result = coerce(attr);
+                if (result && Lib.isArrayOrTypedArray(result)) return result;
+                return null;
+              });
+              return ret.every(function(x2) {
+                return x2 && x2.length === ret[0].length;
+              }) && ret;
+            }
+            var coords = readComponents(["x", "y", "z"]);
+            if (!coords) {
+              traceOut.visible = false;
+              return;
+            }
+            readComponents(["i", "j", "k"]);
+            if (traceOut.i && (!traceOut.j || !traceOut.k) || traceOut.j && (!traceOut.k || !traceOut.i) || traceOut.k && (!traceOut.i || !traceOut.j)) {
+              traceOut.visible = false;
+              return;
+            }
+            var handleCalendarDefaults = Registry.getComponentMethod("calendars", "handleTraceDefaults");
+            handleCalendarDefaults(traceIn, traceOut, ["x", "y", "z"], layout);
+            [
+              "lighting.ambient",
+              "lighting.diffuse",
+              "lighting.specular",
+              "lighting.roughness",
+              "lighting.fresnel",
+              "lighting.vertexnormalsepsilon",
+              "lighting.facenormalsepsilon",
+              "lightposition.x",
+              "lightposition.y",
+              "lightposition.z",
+              "flatshading",
+              "alphahull",
+              "delaunayaxis",
+              "opacity"
+            ].forEach(function(x2) {
+              coerce(x2);
+            });
+            var showContour = coerce("contour.show");
+            if (showContour) {
+              coerce("contour.color");
+              coerce("contour.width");
+            }
+            if ("intensity" in traceIn) {
+              coerce("intensity");
+              coerce("intensitymode");
+              colorscaleDefaults(traceIn, traceOut, layout, coerce, { prefix: "", cLetter: "c" });
+            } else {
+              traceOut.showscale = false;
+              if ("facecolor" in traceIn) coerce("facecolor");
+              else if ("vertexcolor" in traceIn) coerce("vertexcolor");
+              else coerce("color", defaultColor);
+            }
+            coerce("text");
+            coerce("hovertext");
+            coerce("hovertemplate");
+            coerce("hovertemplatefallback");
+            coerce("xhoverformat");
+            coerce("yhoverformat");
+            coerce("zhoverformat");
+            traceOut._length = null;
+          };
         }
-        layer.removeEventParent(this);
-        LayerGroup.prototype.removeLayer.call(this, layer);
-        return this.fire("layerremove", { layer });
-      },
-      // @method setStyle(style: Path options): this
-      // Sets the given path options to each layer of the group that has a `setStyle` method.
-      setStyle: function(style2) {
-        return this.invoke("setStyle", style2);
-      },
-      // @method bringToFront(): this
-      // Brings the layer group to the top of all other layers
-      bringToFront: function() {
-        return this.invoke("bringToFront");
-      },
-      // @method bringToBack(): this
-      // Brings the layer group to the back of all other layers
-      bringToBack: function() {
-        return this.invoke("bringToBack");
-      },
-      // @method getBounds(): LatLngBounds
-      // Returns the LatLngBounds of the Feature Group (created from bounds and coordinates of its children).
-      getBounds: function() {
-        var bounds = new LatLngBounds();
-        for (var id2 in this._layers) {
-          var layer = this._layers[id2];
-          bounds.extend(layer.getBounds ? layer.getBounds() : layer.getLatLng());
+      });
+      var require_calc25 = __commonJS({
+        "src/traces/mesh3d/calc.js"(exports, module2) {
+          var colorscaleCalc = require_calc();
+          module2.exports = function calc(gd2, trace) {
+            if (trace.intensity) {
+              colorscaleCalc(gd2, trace, {
+                vals: trace.intensity,
+                containerStr: "",
+                cLetter: "c"
+              });
+            }
+          };
         }
-        return bounds;
-      }
-    });
-    var featureGroup = function(layers2, options) {
-      return new FeatureGroup(layers2, options);
-    };
-    var Icon = Class.extend({
-      /* @section
-       * @aka Icon options
-       *
-       * @option iconUrl: String = null
-       * **(required)** The URL to the icon image (absolute or relative to your script path).
-       *
-       * @option iconRetinaUrl: String = null
-       * The URL to a retina sized version of the icon image (absolute or relative to your
-       * script path). Used for Retina screen devices.
-       *
-       * @option iconSize: Point = null
-       * Size of the icon image in pixels.
-       *
-       * @option iconAnchor: Point = null
-       * The coordinates of the "tip" of the icon (relative to its top left corner). The icon
-       * will be aligned so that this point is at the marker's geographical location. Centered
-       * by default if size is specified, also can be set in CSS with negative margins.
-       *
-       * @option popupAnchor: Point = [0, 0]
-       * The coordinates of the point from which popups will "open", relative to the icon anchor.
-       *
-       * @option tooltipAnchor: Point = [0, 0]
-       * The coordinates of the point from which tooltips will "open", relative to the icon anchor.
-       *
-       * @option shadowUrl: String = null
-       * The URL to the icon shadow image. If not specified, no shadow image will be created.
-       *
-       * @option shadowRetinaUrl: String = null
-       *
-       * @option shadowSize: Point = null
-       * Size of the shadow image in pixels.
-       *
-       * @option shadowAnchor: Point = null
-       * The coordinates of the "tip" of the shadow (relative to its top left corner) (the same
-       * as iconAnchor if not specified).
-       *
-       * @option className: String = ''
-       * A custom class name to assign to both icon and shadow images. Empty by default.
-       */
-      options: {
-        popupAnchor: [0, 0],
-        tooltipAnchor: [0, 0],
-        // @option crossOrigin: Boolean|String = false
-        // Whether the crossOrigin attribute will be added to the tiles.
-        // If a String is provided, all tiles will have their crossOrigin attribute set to the String provided. This is needed if you want to access tile pixel data.
-        // Refer to [CORS Settings](https://developer.mozilla.org/en-US/docs/Web/HTML/CORS_settings_attributes) for valid String values.
-        crossOrigin: false
-      },
-      initialize: function(options) {
-        setOptions2(this, options);
-      },
-      // @method createIcon(oldIcon?: HTMLElement): HTMLElement
-      // Called internally when the icon has to be shown, returns a `<img>` HTML element
-      // styled according to the options.
-      createIcon: function(oldIcon) {
-        return this._createIcon("icon", oldIcon);
-      },
-      // @method createShadow(oldIcon?: HTMLElement): HTMLElement
-      // As `createIcon`, but for the shadow beneath it.
-      createShadow: function(oldIcon) {
-        return this._createIcon("shadow", oldIcon);
-      },
-      _createIcon: function(name, oldIcon) {
-        var src = this._getIconUrl(name);
-        if (!src) {
-          if (name === "icon") {
-            throw new Error("iconUrl not set in Icon options (see the docs).");
+      });
+      var require_convert7 = __commonJS({
+        "src/traces/mesh3d/convert.js"(exports, module2) {
+          var createMesh = require_stackgl_modules().gl_mesh3d;
+          var triangulate = require_stackgl_modules().delaunay_triangulate;
+          var alphaShape = require_stackgl_modules().alpha_shape;
+          var convexHull = require_stackgl_modules().convex_hull;
+          var parseColorScale = require_gl_format_color().parseColorScale;
+          var isArrayOrTypedArray = require_lib().isArrayOrTypedArray;
+          var str2RgbaArray = require_str2rgbarray();
+          var extractOpts = require_colorscale().extractOpts;
+          var zip3 = require_zip3();
+          function Mesh3DTrace(scene, mesh, uid2) {
+            this.scene = scene;
+            this.uid = uid2;
+            this.mesh = mesh;
+            this.name = "";
+            this.color = "#fff";
+            this.data = null;
+            this.showContour = false;
           }
-          return null;
-        }
-        var img = this._createImg(src, oldIcon && oldIcon.tagName === "IMG" ? oldIcon : null);
-        this._setIconStyles(img, name);
-        if (this.options.crossOrigin || this.options.crossOrigin === "") {
-          img.crossOrigin = this.options.crossOrigin === true ? "" : this.options.crossOrigin;
+          var proto = Mesh3DTrace.prototype;
+          proto.handlePick = function(selection) {
+            if (selection.object === this.mesh) {
+              var selectIndex = selection.index = selection.data.index;
+              if (selection.data._cellCenter) {
+                selection.traceCoordinate = selection.data.dataCoordinate;
+              } else {
+                selection.traceCoordinate = [
+                  this.data.x[selectIndex],
+                  this.data.y[selectIndex],
+                  this.data.z[selectIndex]
+                ];
+              }
+              var text = this.data.hovertext || this.data.text;
+              if (isArrayOrTypedArray(text) && text[selectIndex] !== void 0) {
+                selection.textLabel = text[selectIndex];
+              } else if (text) {
+                selection.textLabel = text;
+              }
+              return true;
+            }
+          };
+          function parseColorArray(colors) {
+            var b2 = [];
+            var len2 = colors.length;
+            for (var i2 = 0; i2 < len2; i2++) {
+              b2[i2] = str2RgbaArray(colors[i2]);
+            }
+            return b2;
+          }
+          function toDataCoords(axis, coord, scale2, calendar) {
+            var b2 = [];
+            var len2 = coord.length;
+            for (var i2 = 0; i2 < len2; i2++) {
+              b2[i2] = axis.d2l(coord[i2], 0, calendar) * scale2;
+            }
+            return b2;
+          }
+          function toRoundIndex(a2) {
+            var b2 = [];
+            var len2 = a2.length;
+            for (var i2 = 0; i2 < len2; i2++) {
+              b2[i2] = Math.round(a2[i2]);
+            }
+            return b2;
+          }
+          function delaunayCells(delaunayaxis, positions) {
+            var d2 = ["x", "y", "z"].indexOf(delaunayaxis);
+            var b2 = [];
+            var len2 = positions.length;
+            for (var i2 = 0; i2 < len2; i2++) {
+              b2[i2] = [positions[i2][(d2 + 1) % 3], positions[i2][(d2 + 2) % 3]];
+            }
+            return triangulate(b2);
+          }
+          function hasValidIndices(list, numVertices) {
+            var len2 = list.length;
+            for (var i2 = 0; i2 < len2; i2++) {
+              if (list[i2] <= -0.5 || list[i2] >= numVertices - 0.5) {
+                return false;
+              }
+            }
+            return true;
+          }
+          proto.update = function(data) {
+            var scene = this.scene;
+            var layout = scene.fullSceneLayout;
+            this.data = data;
+            var numVertices = data.x.length;
+            var positions = zip3(
+              toDataCoords(layout.xaxis, data.x, scene.dataScale[0], data.xcalendar),
+              toDataCoords(layout.yaxis, data.y, scene.dataScale[1], data.ycalendar),
+              toDataCoords(layout.zaxis, data.z, scene.dataScale[2], data.zcalendar)
+            );
+            var cells;
+            if (data.i && data.j && data.k) {
+              if (data.i.length !== data.j.length || data.j.length !== data.k.length || !hasValidIndices(data.i, numVertices) || !hasValidIndices(data.j, numVertices) || !hasValidIndices(data.k, numVertices)) {
+                return;
+              }
+              cells = zip3(
+                toRoundIndex(data.i),
+                toRoundIndex(data.j),
+                toRoundIndex(data.k)
+              );
+            } else if (data.alphahull === 0) {
+              cells = convexHull(positions);
+            } else if (data.alphahull > 0) {
+              cells = alphaShape(data.alphahull, positions);
+            } else {
+              cells = delaunayCells(data.delaunayaxis, positions);
+            }
+            var config2 = {
+              positions,
+              cells,
+              lightPosition: [data.lightposition.x, data.lightposition.y, data.lightposition.z],
+              ambient: data.lighting.ambient,
+              diffuse: data.lighting.diffuse,
+              specular: data.lighting.specular,
+              roughness: data.lighting.roughness,
+              fresnel: data.lighting.fresnel,
+              vertexNormalsEpsilon: data.lighting.vertexnormalsepsilon,
+              faceNormalsEpsilon: data.lighting.facenormalsepsilon,
+              opacity: data.opacity,
+              contourEnable: data.contour.show,
+              contourColor: str2RgbaArray(data.contour.color).slice(0, 3),
+              contourWidth: data.contour.width,
+              useFacetNormals: data.flatshading
+            };
+            if (data.intensity) {
+              var cOpts = extractOpts(data);
+              this.color = "#fff";
+              var mode = data.intensitymode;
+              config2[mode + "Intensity"] = data.intensity;
+              config2[mode + "IntensityBounds"] = [cOpts.min, cOpts.max];
+              config2.colormap = parseColorScale(data);
+            } else if (data.vertexcolor) {
+              this.color = data.vertexcolor[0];
+              config2.vertexColors = parseColorArray(data.vertexcolor);
+            } else if (data.facecolor) {
+              this.color = data.facecolor[0];
+              config2.cellColors = parseColorArray(data.facecolor);
+            } else {
+              this.color = data.color;
+              config2.meshColor = str2RgbaArray(data.color);
+            }
+            this.mesh.update(config2);
+          };
+          proto.dispose = function() {
+            this.scene.glplot.remove(this.mesh);
+            this.mesh.dispose();
+          };
+          function createMesh3DTrace(scene, data) {
+            var gl2 = scene.glplot.gl;
+            var mesh = createMesh({ gl: gl2 });
+            var result = new Mesh3DTrace(scene, mesh, data.uid);
+            mesh._trace = result;
+            result.update(data);
+            scene.glplot.add(mesh);
+            return result;
+          }
+          module2.exports = createMesh3DTrace;
         }
-        return img;
-      },
-      _setIconStyles: function(img, name) {
-        var options = this.options;
-        var sizeOption = options[name + "Size"];
-        if (typeof sizeOption === "number") {
-          sizeOption = [sizeOption, sizeOption];
-        }
-        var size = toPoint(sizeOption), anchor = toPoint(name === "shadow" && options.shadowAnchor || options.iconAnchor || size && size.divideBy(2, true));
-        img.className = "leaflet-marker-" + name + " " + (options.className || "");
-        if (anchor) {
-          img.style.marginLeft = -anchor.x + "px";
-          img.style.marginTop = -anchor.y + "px";
-        }
-        if (size) {
-          img.style.width = size.x + "px";
-          img.style.height = size.y + "px";
+      });
+      var require_mesh3d = __commonJS({
+        "src/traces/mesh3d/index.js"(exports, module2) {
+          module2.exports = {
+            attributes: require_attributes43(),
+            supplyDefaults: require_defaults41(),
+            calc: require_calc25(),
+            colorbar: {
+              min: "cmin",
+              max: "cmax"
+            },
+            plot: require_convert7(),
+            moduleType: "trace",
+            name: "mesh3d",
+            basePlotModule: require_gl3d(),
+            categories: ["gl3d", "showLegend"],
+            meta: {}
+          };
         }
-      },
-      _createImg: function(src, el2) {
-        el2 = el2 || document.createElement("img");
-        el2.src = src;
-        return el2;
-      },
-      _getIconUrl: function(name) {
-        return Browser.retina && this.options[name + "RetinaUrl"] || this.options[name + "Url"];
-      }
-    });
-    function icon(options) {
-      return new Icon(options);
-    }
-    var IconDefault = Icon.extend({
-      options: {
-        iconUrl: "marker-icon.png",
-        iconRetinaUrl: "marker-icon-2x.png",
-        shadowUrl: "marker-shadow.png",
-        iconSize: [25, 41],
-        iconAnchor: [12, 41],
-        popupAnchor: [1, -34],
-        tooltipAnchor: [16, -28],
-        shadowSize: [41, 41]
-      },
-      _getIconUrl: function(name) {
-        if (typeof IconDefault.imagePath !== "string") {
-          IconDefault.imagePath = this._detectIconPath();
+      });
+      var require_mesh3d2 = __commonJS({
+        "lib/mesh3d.js"(exports, module2) {
+          module2.exports = require_mesh3d();
         }
-        return (this.options.imagePath || IconDefault.imagePath) + Icon.prototype._getIconUrl.call(this, name);
-      },
-      _stripUrl: function(path) {
-        var strip = function(str, re2, idx) {
-          var match2 = re2.exec(str);
-          return match2 && match2[idx];
-        };
-        path = strip(path, /^url\((['"])?(.+)\1\)$/, 2);
-        return path && strip(path, /^(.*)marker-icon\.png$/, 1);
-      },
-      _detectIconPath: function() {
-        var el2 = create$1("div", "leaflet-default-icon-path", document.body);
-        var path = getStyle2(el2, "background-image") || getStyle2(el2, "backgroundImage");
-        document.body.removeChild(el2);
-        path = this._stripUrl(path);
-        if (path) {
-          return path;
+      });
+      var require_attributes46 = __commonJS({
+        "src/traces/cone/attributes.js"(exports, module2) {
+          var colorScaleAttrs = require_attributes8();
+          var axisHoverFormat = require_axis_format_attributes().axisHoverFormat;
+          var { hovertemplateAttrs, templatefallbackAttrs } = require_template_attributes();
+          var mesh3dAttrs = require_attributes43();
+          var baseAttrs = require_attributes2();
+          var extendFlat = require_extend().extendFlat;
+          var attrs = {
+            x: {
+              valType: "data_array",
+              editType: "calc+clearAxisTypes"
+            },
+            y: {
+              valType: "data_array",
+              editType: "calc+clearAxisTypes"
+            },
+            z: {
+              valType: "data_array",
+              editType: "calc+clearAxisTypes"
+            },
+            u: {
+              valType: "data_array",
+              editType: "calc"
+            },
+            v: {
+              valType: "data_array",
+              editType: "calc"
+            },
+            w: {
+              valType: "data_array",
+              editType: "calc"
+            },
+            // TODO add way to specify cone positions independently of the vector field
+            // provided, similar to MATLAB's coneplot Cx/Cy/Cz meshgrids,
+            // see https://www.mathworks.com/help/matlab/ref/coneplot.html
+            //
+            // Alternatively, if our goal is only to 'fill in gaps' in the vector data,
+            // we could try to extend the heatmap 'connectgaps' algorithm to 3D.
+            // From AJ: this particular algorithm which amounts to a Poisson equation,
+            // both for interpolation and extrapolation - is the right one to use for
+            // cones too.  It makes a field with zero divergence, which is a good
+            // baseline assumption for vector fields.
+            //
+            // cones: {
+            //     // potential attributes to add:
+            //     //
+            //     // - meshmode: 'cartesian-product', 'pts', 'grid'
+            //     //
+            //     // under `meshmode: 'grid'`
+            //     // - (x|y|z)grid.start
+            //     // - (x|y|z)grid.end
+            //     // - (x|y|z)grid.size
+            //
+            //     x: {
+            //         valType: 'data_array',
+            //         editType: 'calc',
+            //
+            //     },
+            //     y: {
+            //         valType: 'data_array',
+            //         editType: 'calc',
+            //
+            //     },
+            //     z: {
+            //         valType: 'data_array',
+            //         editType: 'calc',
+            //
+            //     },
+            //
+            //     editType: 'calc',
+            //
+            // },
+            sizemode: {
+              valType: "enumerated",
+              values: ["scaled", "absolute", "raw"],
+              editType: "calc",
+              dflt: "scaled"
+            },
+            sizeref: {
+              valType: "number",
+              editType: "calc",
+              min: 0
+            },
+            anchor: {
+              valType: "enumerated",
+              editType: "calc",
+              values: ["tip", "tail", "cm", "center"],
+              dflt: "cm"
+            },
+            text: {
+              valType: "string",
+              dflt: "",
+              arrayOk: true,
+              editType: "calc"
+            },
+            hovertext: {
+              valType: "string",
+              dflt: "",
+              arrayOk: true,
+              editType: "calc"
+            },
+            hovertemplate: hovertemplateAttrs({ editType: "calc" }, { keys: ["norm"] }),
+            hovertemplatefallback: templatefallbackAttrs({ editType: "calc" }),
+            uhoverformat: axisHoverFormat("u", 1),
+            vhoverformat: axisHoverFormat("v", 1),
+            whoverformat: axisHoverFormat("w", 1),
+            xhoverformat: axisHoverFormat("x"),
+            yhoverformat: axisHoverFormat("y"),
+            zhoverformat: axisHoverFormat("z"),
+            showlegend: extendFlat({}, baseAttrs.showlegend, { dflt: false })
+          };
+          extendFlat(
+            attrs,
+            colorScaleAttrs("", {
+              colorAttr: "u/v/w norm",
+              showScaleDflt: true,
+              editTypeOverride: "calc"
+            })
+          );
+          var fromMesh3d = ["opacity", "lightposition", "lighting"];
+          fromMesh3d.forEach(function(k2) {
+            attrs[k2] = mesh3dAttrs[k2];
+          });
+          attrs.hoverinfo = extendFlat({}, baseAttrs.hoverinfo, {
+            editType: "calc",
+            flags: ["x", "y", "z", "u", "v", "w", "norm", "text", "name"],
+            dflt: "x+y+z+norm+text+name"
+          });
+          module2.exports = attrs;
         }
-        var link = document.querySelector('link[href$="leaflet.css"]');
-        if (!link) {
-          return "";
+      });
+      var require_defaults42 = __commonJS({
+        "src/traces/cone/defaults.js"(exports, module2) {
+          var Lib = require_lib();
+          var colorscaleDefaults = require_defaults2();
+          var attributes = require_attributes46();
+          module2.exports = function supplyDefaults(traceIn, traceOut, defaultColor, layout) {
+            function coerce(attr, dflt) {
+              return Lib.coerce(traceIn, traceOut, attributes, attr, dflt);
+            }
+            var u2 = coerce("u");
+            var v2 = coerce("v");
+            var w2 = coerce("w");
+            var x2 = coerce("x");
+            var y2 = coerce("y");
+            var z2 = coerce("z");
+            if (!u2 || !u2.length || !v2 || !v2.length || !w2 || !w2.length || !x2 || !x2.length || !y2 || !y2.length || !z2 || !z2.length) {
+              traceOut.visible = false;
+              return;
+            }
+            var sizemode = coerce("sizemode");
+            coerce("sizeref", sizemode === "raw" ? 1 : 0.5);
+            coerce("anchor");
+            coerce("lighting.ambient");
+            coerce("lighting.diffuse");
+            coerce("lighting.specular");
+            coerce("lighting.roughness");
+            coerce("lighting.fresnel");
+            coerce("lightposition.x");
+            coerce("lightposition.y");
+            coerce("lightposition.z");
+            colorscaleDefaults(traceIn, traceOut, layout, coerce, { prefix: "", cLetter: "c" });
+            coerce("text");
+            coerce("hovertext");
+            coerce("hovertemplate");
+            coerce("hovertemplatefallback");
+            coerce("uhoverformat");
+            coerce("vhoverformat");
+            coerce("whoverformat");
+            coerce("xhoverformat");
+            coerce("yhoverformat");
+            coerce("zhoverformat");
+            traceOut._length = null;
+          };
         }
-        return link.href.substring(0, link.href.length - "leaflet.css".length - 1);
-      }
-    });
-    var MarkerDrag = Handler.extend({
-      initialize: function(marker2) {
-        this._marker = marker2;
-      },
-      addHooks: function() {
-        var icon2 = this._marker._icon;
-        if (!this._draggable) {
-          this._draggable = new Draggable(icon2, icon2, true);
-        }
-        this._draggable.on({
-          dragstart: this._onDragStart,
-          predrag: this._onPreDrag,
-          drag: this._onDrag,
-          dragend: this._onDragEnd
-        }, this).enable();
-        addClass(icon2, "leaflet-marker-draggable");
-      },
-      removeHooks: function() {
-        this._draggable.off({
-          dragstart: this._onDragStart,
-          predrag: this._onPreDrag,
-          drag: this._onDrag,
-          dragend: this._onDragEnd
-        }, this).disable();
-        if (this._marker._icon) {
-          removeClass(this._marker._icon, "leaflet-marker-draggable");
+      });
+      var require_calc26 = __commonJS({
+        "src/traces/cone/calc.js"(exports, module2) {
+          var colorscaleCalc = require_calc();
+          module2.exports = function calc(gd2, trace) {
+            var u2 = trace.u;
+            var v2 = trace.v;
+            var w2 = trace.w;
+            var len2 = Math.min(
+              trace.x.length,
+              trace.y.length,
+              trace.z.length,
+              u2.length,
+              v2.length,
+              w2.length
+            );
+            var normMax = -Infinity;
+            var normMin = Infinity;
+            for (var i2 = 0; i2 < len2; i2++) {
+              var uu = u2[i2];
+              var vv = v2[i2];
+              var ww = w2[i2];
+              var norm = Math.sqrt(uu * uu + vv * vv + ww * ww);
+              normMax = Math.max(normMax, norm);
+              normMin = Math.min(normMin, norm);
+            }
+            trace._len = len2;
+            trace._normMax = normMax;
+            colorscaleCalc(gd2, trace, {
+              vals: [normMin, normMax],
+              containerStr: "",
+              cLetter: "c"
+            });
+          };
         }
-      },
-      moved: function() {
-        return this._draggable && this._draggable._moved;
-      },
-      _adjustPan: function(e) {
-        var marker2 = this._marker, map2 = marker2._map, speed = this._marker.options.autoPanSpeed, padding = this._marker.options.autoPanPadding, iconPos = getPosition(marker2._icon), bounds = map2.getPixelBounds(), origin = map2.getPixelOrigin();
-        var panBounds = toBounds(
-          bounds.min._subtract(origin).add(padding),
-          bounds.max._subtract(origin).subtract(padding)
-        );
-        if (!panBounds.contains(iconPos)) {
-          var movement = toPoint(
-            (Math.max(panBounds.max.x, iconPos.x) - panBounds.max.x) / (bounds.max.x - panBounds.max.x) - (Math.min(panBounds.min.x, iconPos.x) - panBounds.min.x) / (bounds.min.x - panBounds.min.x),
-            (Math.max(panBounds.max.y, iconPos.y) - panBounds.max.y) / (bounds.max.y - panBounds.max.y) - (Math.min(panBounds.min.y, iconPos.y) - panBounds.min.y) / (bounds.min.y - panBounds.min.y)
-          ).multiplyBy(speed);
-          map2.panBy(movement, { animate: false });
-          this._draggable._newPos._add(movement);
-          this._draggable._startPos._add(movement);
-          setPosition(marker2._icon, this._draggable._newPos);
-          this._onDrag(e);
-          this._panRequest = requestAnimFrame2(this._adjustPan.bind(this, e));
+      });
+      var require_convert8 = __commonJS({
+        "src/traces/cone/convert.js"(exports, module2) {
+          var conePlot = require_stackgl_modules().gl_cone3d;
+          var createConeMesh = require_stackgl_modules().gl_cone3d.createConeMesh;
+          var simpleMap = require_lib().simpleMap;
+          var parseColorScale = require_gl_format_color().parseColorScale;
+          var extractOpts = require_colorscale().extractOpts;
+          var isArrayOrTypedArray = require_lib().isArrayOrTypedArray;
+          var zip3 = require_zip3();
+          function Cone(scene, uid2) {
+            this.scene = scene;
+            this.uid = uid2;
+            this.mesh = null;
+            this.data = null;
+          }
+          var proto = Cone.prototype;
+          proto.handlePick = function(selection) {
+            if (selection.object === this.mesh) {
+              var selectIndex = selection.index = selection.data.index;
+              var xx = this.data.x[selectIndex];
+              var yy = this.data.y[selectIndex];
+              var zz = this.data.z[selectIndex];
+              var uu = this.data.u[selectIndex];
+              var vv = this.data.v[selectIndex];
+              var ww = this.data.w[selectIndex];
+              selection.traceCoordinate = [
+                xx,
+                yy,
+                zz,
+                uu,
+                vv,
+                ww,
+                Math.sqrt(uu * uu + vv * vv + ww * ww)
+              ];
+              var text = this.data.hovertext || this.data.text;
+              if (isArrayOrTypedArray(text) && text[selectIndex] !== void 0) {
+                selection.textLabel = text[selectIndex];
+              } else if (text) {
+                selection.textLabel = text;
+              }
+              return true;
+            }
+          };
+          var axisName2scaleIndex = { xaxis: 0, yaxis: 1, zaxis: 2 };
+          var anchor2coneOffset = { tip: 1, tail: 0, cm: 0.25, center: 0.5 };
+          var anchor2coneSpan = { tip: 1, tail: 1, cm: 0.75, center: 0.5 };
+          function convert(scene, trace) {
+            var sceneLayout = scene.fullSceneLayout;
+            var dataScale = scene.dataScale;
+            var coneOpts = {};
+            function toDataCoords(arr, axisName) {
+              var ax = sceneLayout[axisName];
+              var scale2 = dataScale[axisName2scaleIndex[axisName]];
+              return simpleMap(arr, function(v2) {
+                return ax.d2l(v2) * scale2;
+              });
+            }
+            coneOpts.vectors = zip3(
+              toDataCoords(trace.u, "xaxis"),
+              toDataCoords(trace.v, "yaxis"),
+              toDataCoords(trace.w, "zaxis"),
+              trace._len
+            );
+            coneOpts.positions = zip3(
+              toDataCoords(trace.x, "xaxis"),
+              toDataCoords(trace.y, "yaxis"),
+              toDataCoords(trace.z, "zaxis"),
+              trace._len
+            );
+            var cOpts = extractOpts(trace);
+            coneOpts.colormap = parseColorScale(trace);
+            coneOpts.vertexIntensityBounds = [cOpts.min / trace._normMax, cOpts.max / trace._normMax];
+            coneOpts.coneOffset = anchor2coneOffset[trace.anchor];
+            var sizemode = trace.sizemode;
+            if (sizemode === "scaled") {
+              coneOpts.coneSize = trace.sizeref || 0.5;
+            } else if (sizemode === "absolute") {
+              coneOpts.coneSize = trace.sizeref && trace._normMax ? trace.sizeref / trace._normMax : 0.5;
+            } else if (sizemode === "raw") {
+              coneOpts.coneSize = trace.sizeref;
+            }
+            coneOpts.coneSizemode = sizemode;
+            var meshData = conePlot(coneOpts);
+            var lp = trace.lightposition;
+            meshData.lightPosition = [lp.x, lp.y, lp.z];
+            meshData.ambient = trace.lighting.ambient;
+            meshData.diffuse = trace.lighting.diffuse;
+            meshData.specular = trace.lighting.specular;
+            meshData.roughness = trace.lighting.roughness;
+            meshData.fresnel = trace.lighting.fresnel;
+            meshData.opacity = trace.opacity;
+            trace._pad = anchor2coneSpan[trace.anchor] * meshData.vectorScale * meshData.coneScale * trace._normMax;
+            return meshData;
+          }
+          proto.update = function(data) {
+            this.data = data;
+            var meshData = convert(this.scene, data);
+            this.mesh.update(meshData);
+          };
+          proto.dispose = function() {
+            this.scene.glplot.remove(this.mesh);
+            this.mesh.dispose();
+          };
+          function createConeTrace(scene, data) {
+            var gl2 = scene.glplot.gl;
+            var meshData = convert(scene, data);
+            var mesh = createConeMesh(gl2, meshData);
+            var cone = new Cone(scene, data.uid);
+            cone.mesh = mesh;
+            cone.data = data;
+            mesh._trace = cone;
+            scene.glplot.add(mesh);
+            return cone;
+          }
+          module2.exports = createConeTrace;
         }
-      },
-      _onDragStart: function() {
-        this._oldLatLng = this._marker.getLatLng();
-        this._marker.closePopup && this._marker.closePopup();
-        this._marker.fire("movestart").fire("dragstart");
-      },
-      _onPreDrag: function(e) {
-        if (this._marker.options.autoPan) {
-          cancelAnimFrame(this._panRequest);
-          this._panRequest = requestAnimFrame2(this._adjustPan.bind(this, e));
+      });
+      var require_cone = __commonJS({
+        "src/traces/cone/index.js"(exports, module2) {
+          module2.exports = {
+            moduleType: "trace",
+            name: "cone",
+            basePlotModule: require_gl3d(),
+            categories: ["gl3d", "showLegend"],
+            attributes: require_attributes46(),
+            supplyDefaults: require_defaults42(),
+            colorbar: {
+              min: "cmin",
+              max: "cmax"
+            },
+            calc: require_calc26(),
+            plot: require_convert8(),
+            eventData: function(out, pt2) {
+              out.norm = pt2.traceCoordinate[6];
+              return out;
+            },
+            meta: {}
+          };
         }
-      },
-      _onDrag: function(e) {
-        var marker2 = this._marker, shadow = marker2._shadow, iconPos = getPosition(marker2._icon), latlng = marker2._map.layerPointToLatLng(iconPos);
-        if (shadow) {
-          setPosition(shadow, iconPos);
-        }
-        marker2._latlng = latlng;
-        e.latlng = latlng;
-        e.oldLatLng = this._oldLatLng;
-        marker2.fire("move", e).fire("drag", e);
-      },
-      _onDragEnd: function(e) {
-        cancelAnimFrame(this._panRequest);
-        delete this._oldLatLng;
-        this._marker.fire("moveend").fire("dragend", e);
-      }
-    });
-    var Marker2 = Layer.extend({
-      // @section
-      // @aka Marker options
-      options: {
-        // @option icon: Icon = *
-        // Icon instance to use for rendering the marker.
-        // See [Icon documentation](#L.Icon) for details on how to customize the marker icon.
-        // If not specified, a common instance of `L.Icon.Default` is used.
-        icon: new IconDefault(),
-        // Option inherited from "Interactive layer" abstract class
-        interactive: true,
-        // @option keyboard: Boolean = true
-        // Whether the marker can be tabbed to with a keyboard and clicked by pressing enter.
-        keyboard: true,
-        // @option title: String = ''
-        // Text for the browser tooltip that appear on marker hover (no tooltip by default).
-        // [Useful for accessibility](https://leafletjs.com/examples/accessibility/#markers-must-be-labelled).
-        title: "",
-        // @option alt: String = 'Marker'
-        // Text for the `alt` attribute of the icon image.
-        // [Useful for accessibility](https://leafletjs.com/examples/accessibility/#markers-must-be-labelled).
-        alt: "Marker",
-        // @option zIndexOffset: Number = 0
-        // By default, marker images zIndex is set automatically based on its latitude. Use this option if you want to put the marker on top of all others (or below), specifying a high value like `1000` (or high negative value, respectively).
-        zIndexOffset: 0,
-        // @option opacity: Number = 1.0
-        // The opacity of the marker.
-        opacity: 1,
-        // @option riseOnHover: Boolean = false
-        // If `true`, the marker will get on top of others when you hover the mouse over it.
-        riseOnHover: false,
-        // @option riseOffset: Number = 250
-        // The z-index offset used for the `riseOnHover` feature.
-        riseOffset: 250,
-        // @option pane: String = 'markerPane'
-        // `Map pane` where the markers icon will be added.
-        pane: "markerPane",
-        // @option shadowPane: String = 'shadowPane'
-        // `Map pane` where the markers shadow will be added.
-        shadowPane: "shadowPane",
-        // @option bubblingMouseEvents: Boolean = false
-        // When `true`, a mouse event on this marker will trigger the same event on the map
-        // (unless [`L.DomEvent.stopPropagation`](#domevent-stoppropagation) is used).
-        bubblingMouseEvents: false,
-        // @option autoPanOnFocus: Boolean = true
-        // When `true`, the map will pan whenever the marker is focused (via
-        // e.g. pressing `tab` on the keyboard) to ensure the marker is
-        // visible within the map's bounds
-        autoPanOnFocus: true,
-        // @section Draggable marker options
-        // @option draggable: Boolean = false
-        // Whether the marker is draggable with mouse/touch or not.
-        draggable: false,
-        // @option autoPan: Boolean = false
-        // Whether to pan the map when dragging this marker near its edge or not.
-        autoPan: false,
-        // @option autoPanPadding: Point = Point(50, 50)
-        // Distance (in pixels to the left/right and to the top/bottom) of the
-        // map edge to start panning the map.
-        autoPanPadding: [50, 50],
-        // @option autoPanSpeed: Number = 10
-        // Number of pixels the map should pan by.
-        autoPanSpeed: 10
-      },
-      /* @section
-       *
-       * In addition to [shared layer methods](#Layer) like `addTo()` and `remove()` and [popup methods](#Popup) like bindPopup() you can also use the following methods:
-       */
-      initialize: function(latlng, options) {
-        setOptions2(this, options);
-        this._latlng = toLatLng(latlng);
-      },
-      onAdd: function(map2) {
-        this._zoomAnimated = this._zoomAnimated && map2.options.markerZoomAnimation;
-        if (this._zoomAnimated) {
-          map2.on("zoomanim", this._animateZoom, this);
+      });
+      var require_cone2 = __commonJS({
+        "lib/cone.js"(exports, module2) {
+          module2.exports = require_cone();
         }
-        this._initIcon();
-        this.update();
-      },
-      onRemove: function(map2) {
-        if (this.dragging && this.dragging.enabled()) {
-          this.options.draggable = true;
-          this.dragging.removeHooks();
+      });
+      var require_attributes47 = __commonJS({
+        "src/traces/streamtube/attributes.js"(exports, module2) {
+          var colorScaleAttrs = require_attributes8();
+          var axisHoverFormat = require_axis_format_attributes().axisHoverFormat;
+          var { hovertemplateAttrs, templatefallbackAttrs } = require_template_attributes();
+          var mesh3dAttrs = require_attributes43();
+          var baseAttrs = require_attributes2();
+          var extendFlat = require_extend().extendFlat;
+          var attrs = {
+            x: {
+              valType: "data_array",
+              editType: "calc+clearAxisTypes"
+            },
+            y: {
+              valType: "data_array",
+              editType: "calc+clearAxisTypes"
+            },
+            z: {
+              valType: "data_array",
+              editType: "calc+clearAxisTypes"
+            },
+            u: {
+              valType: "data_array",
+              editType: "calc"
+            },
+            v: {
+              valType: "data_array",
+              editType: "calc"
+            },
+            w: {
+              valType: "data_array",
+              editType: "calc"
+            },
+            starts: {
+              x: {
+                valType: "data_array",
+                editType: "calc"
+              },
+              y: {
+                valType: "data_array",
+                editType: "calc"
+              },
+              z: {
+                valType: "data_array",
+                editType: "calc"
+              },
+              editType: "calc"
+            },
+            maxdisplayed: {
+              valType: "integer",
+              min: 0,
+              dflt: 1e3,
+              editType: "calc"
+            },
+            // TODO
+            //
+            // Should add 'absolute' (like cone traces have), but currently gl-streamtube3d's
+            // `absoluteTubeSize` doesn't behave well enough for our needs.
+            //
+            // 'fixed' would be a nice addition to plot stream 'lines', see
+            // https://github.com/plotly/plotly.js/commit/812be20750e21e0a1831975001c248d365850f73#r29129877
+            //
+            // sizemode: {
+            //     valType: 'enumerated',
+            //     values: ['scaled', 'absolute', 'fixed'],
+            //     dflt: 'scaled',
+            //     editType: 'calc',
+            //
+            // },
+            sizeref: {
+              valType: "number",
+              editType: "calc",
+              min: 0,
+              dflt: 1
+            },
+            text: {
+              valType: "string",
+              dflt: "",
+              editType: "calc"
+            },
+            hovertext: {
+              valType: "string",
+              dflt: "",
+              editType: "calc"
+            },
+            hovertemplate: hovertemplateAttrs(
+              { editType: "calc" },
+              { keys: ["tubex", "tubey", "tubez", "tubeu", "tubev", "tubew", "norm", "divergence"] }
+            ),
+            hovertemplatefallback: templatefallbackAttrs({ editType: "calc" }),
+            uhoverformat: axisHoverFormat("u", 1),
+            vhoverformat: axisHoverFormat("v", 1),
+            whoverformat: axisHoverFormat("w", 1),
+            xhoverformat: axisHoverFormat("x"),
+            yhoverformat: axisHoverFormat("y"),
+            zhoverformat: axisHoverFormat("z"),
+            showlegend: extendFlat({}, baseAttrs.showlegend, { dflt: false })
+          };
+          extendFlat(
+            attrs,
+            colorScaleAttrs("", {
+              colorAttr: "u/v/w norm",
+              showScaleDflt: true,
+              editTypeOverride: "calc"
+            })
+          );
+          var fromMesh3d = ["opacity", "lightposition", "lighting"];
+          fromMesh3d.forEach(function(k2) {
+            attrs[k2] = mesh3dAttrs[k2];
+          });
+          attrs.hoverinfo = extendFlat({}, baseAttrs.hoverinfo, {
+            editType: "calc",
+            flags: ["x", "y", "z", "u", "v", "w", "norm", "divergence", "text", "name"],
+            dflt: "x+y+z+norm+text+name"
+          });
+          module2.exports = attrs;
         }
-        delete this.dragging;
-        if (this._zoomAnimated) {
-          map2.off("zoomanim", this._animateZoom, this);
+      });
+      var require_defaults43 = __commonJS({
+        "src/traces/streamtube/defaults.js"(exports, module2) {
+          var Lib = require_lib();
+          var colorscaleDefaults = require_defaults2();
+          var attributes = require_attributes47();
+          module2.exports = function supplyDefaults(traceIn, traceOut, defaultColor, layout) {
+            function coerce(attr, dflt) {
+              return Lib.coerce(traceIn, traceOut, attributes, attr, dflt);
+            }
+            var u2 = coerce("u");
+            var v2 = coerce("v");
+            var w2 = coerce("w");
+            var x2 = coerce("x");
+            var y2 = coerce("y");
+            var z2 = coerce("z");
+            if (!u2 || !u2.length || !v2 || !v2.length || !w2 || !w2.length || !x2 || !x2.length || !y2 || !y2.length || !z2 || !z2.length) {
+              traceOut.visible = false;
+              return;
+            }
+            coerce("starts.x");
+            coerce("starts.y");
+            coerce("starts.z");
+            coerce("maxdisplayed");
+            coerce("sizeref");
+            coerce("lighting.ambient");
+            coerce("lighting.diffuse");
+            coerce("lighting.specular");
+            coerce("lighting.roughness");
+            coerce("lighting.fresnel");
+            coerce("lightposition.x");
+            coerce("lightposition.y");
+            coerce("lightposition.z");
+            colorscaleDefaults(traceIn, traceOut, layout, coerce, { prefix: "", cLetter: "c" });
+            coerce("text");
+            coerce("hovertext");
+            coerce("hovertemplate");
+            coerce("hovertemplatefallback");
+            coerce("uhoverformat");
+            coerce("vhoverformat");
+            coerce("whoverformat");
+            coerce("xhoverformat");
+            coerce("yhoverformat");
+            coerce("zhoverformat");
+            traceOut._length = null;
+          };
         }
-        this._removeIcon();
-        this._removeShadow();
-      },
-      getEvents: function() {
-        return {
-          zoom: this.update,
-          viewreset: this.update
-        };
-      },
-      // @method getLatLng: LatLng
-      // Returns the current geographical position of the marker.
-      getLatLng: function() {
-        return this._latlng;
-      },
-      // @method setLatLng(latlng: LatLng): this
-      // Changes the marker position to the given point.
-      setLatLng: function(latlng) {
-        var oldLatLng = this._latlng;
-        this._latlng = toLatLng(latlng);
-        this.update();
-        return this.fire("move", { oldLatLng, latlng: this._latlng });
-      },
-      // @method setZIndexOffset(offset: Number): this
-      // Changes the [zIndex offset](#marker-zindexoffset) of the marker.
-      setZIndexOffset: function(offset) {
-        this.options.zIndexOffset = offset;
-        return this.update();
-      },
-      // @method getIcon: Icon
-      // Returns the current icon used by the marker
-      getIcon: function() {
-        return this.options.icon;
-      },
-      // @method setIcon(icon: Icon): this
-      // Changes the marker icon.
-      setIcon: function(icon2) {
-        this.options.icon = icon2;
-        if (this._map) {
-          this._initIcon();
-          this.update();
-        }
-        if (this._popup) {
-          this.bindPopup(this._popup, this._popup.options);
-        }
-        return this;
-      },
-      getElement: function() {
-        return this._icon;
-      },
-      update: function() {
-        if (this._icon && this._map) {
-          var pos = this._map.latLngToLayerPoint(this._latlng).round();
-          this._setPos(pos);
+      });
+      var require_convert9 = __commonJS({
+        "src/traces/streamtube/convert.js"(exports, module2) {
+          var tube2mesh = require_stackgl_modules().gl_streamtube3d;
+          var createTubeMesh = tube2mesh.createTubeMesh;
+          var Lib = require_lib();
+          var parseColorScale = require_gl_format_color().parseColorScale;
+          var extractOpts = require_colorscale().extractOpts;
+          var zip3 = require_zip3();
+          var axisName2scaleIndex = { xaxis: 0, yaxis: 1, zaxis: 2 };
+          function Streamtube(scene, uid2) {
+            this.scene = scene;
+            this.uid = uid2;
+            this.mesh = null;
+            this.data = null;
+          }
+          var proto = Streamtube.prototype;
+          proto.handlePick = function(selection) {
+            var sceneLayout = this.scene.fullSceneLayout;
+            var dataScale = this.scene.dataScale;
+            function fromDataScale(v2, axisName) {
+              var ax = sceneLayout[axisName];
+              var scale2 = dataScale[axisName2scaleIndex[axisName]];
+              return ax.l2c(v2) / scale2;
+            }
+            if (selection.object === this.mesh) {
+              var pos = selection.data.position;
+              var uvx = selection.data.velocity;
+              selection.traceCoordinate = [
+                fromDataScale(pos[0], "xaxis"),
+                fromDataScale(pos[1], "yaxis"),
+                fromDataScale(pos[2], "zaxis"),
+                fromDataScale(uvx[0], "xaxis"),
+                fromDataScale(uvx[1], "yaxis"),
+                fromDataScale(uvx[2], "zaxis"),
+                // u/v/w norm
+                selection.data.intensity * this.data._normMax,
+                // divergence
+                selection.data.divergence
+              ];
+              selection.textLabel = this.data.hovertext || this.data.text;
+              return true;
+            }
+          };
+          function getDfltStartingPositions(vec) {
+            var len2 = vec.length;
+            var s2;
+            if (len2 > 2) {
+              s2 = vec.slice(1, len2 - 1);
+            } else if (len2 === 2) {
+              s2 = [(vec[0] + vec[1]) / 2];
+            } else {
+              s2 = vec;
+            }
+            return s2;
+          }
+          function getBoundPads(vec) {
+            var len2 = vec.length;
+            if (len2 === 1) {
+              return [0.5, 0.5];
+            } else {
+              return [vec[1] - vec[0], vec[len2 - 1] - vec[len2 - 2]];
+            }
+          }
+          function convert(scene, trace) {
+            var sceneLayout = scene.fullSceneLayout;
+            var dataScale = scene.dataScale;
+            var len2 = trace._len;
+            var tubeOpts = {};
+            function toDataCoords(arr, axisName) {
+              var ax = sceneLayout[axisName];
+              var scale2 = dataScale[axisName2scaleIndex[axisName]];
+              return Lib.simpleMap(arr, function(v2) {
+                return ax.d2l(v2) * scale2;
+              });
+            }
+            tubeOpts.vectors = zip3(
+              toDataCoords(trace._u, "xaxis"),
+              toDataCoords(trace._v, "yaxis"),
+              toDataCoords(trace._w, "zaxis"),
+              len2
+            );
+            if (!len2) {
+              return {
+                positions: [],
+                cells: []
+              };
+            }
+            var meshx = toDataCoords(trace._Xs, "xaxis");
+            var meshy = toDataCoords(trace._Ys, "yaxis");
+            var meshz = toDataCoords(trace._Zs, "zaxis");
+            tubeOpts.meshgrid = [meshx, meshy, meshz];
+            tubeOpts.gridFill = trace._gridFill;
+            var slen = trace._slen;
+            if (slen) {
+              tubeOpts.startingPositions = zip3(
+                toDataCoords(trace._startsX, "xaxis"),
+                toDataCoords(trace._startsY, "yaxis"),
+                toDataCoords(trace._startsZ, "zaxis")
+              );
+            } else {
+              var sy0 = meshy[0];
+              var sx = getDfltStartingPositions(meshx);
+              var sz = getDfltStartingPositions(meshz);
+              var startingPositions = new Array(sx.length * sz.length);
+              var m2 = 0;
+              for (var i2 = 0; i2 < sx.length; i2++) {
+                for (var k2 = 0; k2 < sz.length; k2++) {
+                  startingPositions[m2++] = [sx[i2], sy0, sz[k2]];
+                }
+              }
+              tubeOpts.startingPositions = startingPositions;
+            }
+            tubeOpts.colormap = parseColorScale(trace);
+            tubeOpts.tubeSize = trace.sizeref;
+            tubeOpts.maxLength = trace.maxdisplayed;
+            var xbnds = toDataCoords(trace._xbnds, "xaxis");
+            var ybnds = toDataCoords(trace._ybnds, "yaxis");
+            var zbnds = toDataCoords(trace._zbnds, "zaxis");
+            var xpads = getBoundPads(meshx);
+            var ypads = getBoundPads(meshy);
+            var zpads = getBoundPads(meshz);
+            var bounds = [
+              [xbnds[0] - xpads[0], ybnds[0] - ypads[0], zbnds[0] - zpads[0]],
+              [xbnds[1] + xpads[1], ybnds[1] + ypads[1], zbnds[1] + zpads[1]]
+            ];
+            var meshData = tube2mesh(tubeOpts, bounds);
+            var cOpts = extractOpts(trace);
+            meshData.vertexIntensityBounds = [cOpts.min / trace._normMax, cOpts.max / trace._normMax];
+            var lp = trace.lightposition;
+            meshData.lightPosition = [lp.x, lp.y, lp.z];
+            meshData.ambient = trace.lighting.ambient;
+            meshData.diffuse = trace.lighting.diffuse;
+            meshData.specular = trace.lighting.specular;
+            meshData.roughness = trace.lighting.roughness;
+            meshData.fresnel = trace.lighting.fresnel;
+            meshData.opacity = trace.opacity;
+            trace._pad = meshData.tubeScale * trace.sizeref * 2;
+            return meshData;
+          }
+          proto.update = function(data) {
+            this.data = data;
+            var meshData = convert(this.scene, data);
+            this.mesh.update(meshData);
+          };
+          proto.dispose = function() {
+            this.scene.glplot.remove(this.mesh);
+            this.mesh.dispose();
+          };
+          function createStreamtubeTrace(scene, data) {
+            var gl2 = scene.glplot.gl;
+            var meshData = convert(scene, data);
+            var mesh = createTubeMesh(gl2, meshData);
+            var streamtube = new Streamtube(scene, data.uid);
+            streamtube.mesh = mesh;
+            streamtube.data = data;
+            mesh._trace = streamtube;
+            scene.glplot.add(mesh);
+            return streamtube;
+          }
+          module2.exports = createStreamtubeTrace;
         }
-        return this;
-      },
-      _initIcon: function() {
-        var options = this.options, classToAdd = "leaflet-zoom-" + (this._zoomAnimated ? "animated" : "hide");
-        var icon2 = options.icon.createIcon(this._icon), addIcon = false;
-        if (icon2 !== this._icon) {
-          if (this._icon) {
-            this._removeIcon();
-          }
-          addIcon = true;
-          if (options.title) {
-            icon2.title = options.title;
-          }
-          if (icon2.tagName === "IMG") {
-            icon2.alt = options.alt || "";
-          }
-        }
-        addClass(icon2, classToAdd);
-        if (options.keyboard) {
-          icon2.tabIndex = "0";
-          icon2.setAttribute("role", "button");
-        }
-        this._icon = icon2;
-        if (options.riseOnHover) {
-          this.on({
-            mouseover: this._bringToFront,
-            mouseout: this._resetZIndex
-          });
+      });
+      var require_streamtube = __commonJS({
+        "src/traces/streamtube/index.js"(exports, module2) {
+          module2.exports = {
+            moduleType: "trace",
+            name: "streamtube",
+            basePlotModule: require_gl3d(),
+            categories: ["gl3d", "showLegend"],
+            attributes: require_attributes47(),
+            supplyDefaults: require_defaults43(),
+            colorbar: {
+              min: "cmin",
+              max: "cmax"
+            },
+            calc: require_calc23().calc,
+            plot: require_convert9(),
+            eventData: function(out, pt2) {
+              out.tubex = out.x;
+              out.tubey = out.y;
+              out.tubez = out.z;
+              out.tubeu = pt2.traceCoordinate[3];
+              out.tubev = pt2.traceCoordinate[4];
+              out.tubew = pt2.traceCoordinate[5];
+              out.norm = pt2.traceCoordinate[6];
+              out.divergence = pt2.traceCoordinate[7];
+              delete out.x;
+              delete out.y;
+              delete out.z;
+              return out;
+            },
+            meta: {}
+          };
         }
-        if (this.options.autoPanOnFocus) {
-          on(icon2, "focus", this._panOnFocus, this);
+      });
+      var require_streamtube2 = __commonJS({
+        "lib/streamtube.js"(exports, module2) {
+          module2.exports = require_streamtube();
         }
-        var newShadow = options.icon.createShadow(this._shadow), addShadow = false;
-        if (newShadow !== this._shadow) {
-          this._removeShadow();
-          addShadow = true;
+      });
+      var require_attributes48 = __commonJS({
+        "src/traces/scattergeo/attributes.js"(exports, module2) {
+          var { hovertemplateAttrs, texttemplateAttrs, templatefallbackAttrs } = require_template_attributes();
+          var makeFillcolorAttr = require_fillcolor_attribute();
+          var scatterAttrs = require_attributes12();
+          var baseAttrs = require_attributes2();
+          var colorAttributes = require_attributes8();
+          var dash = require_attributes4().dash;
+          var extendFlat = require_extend().extendFlat;
+          var overrideAll = require_edit_types().overrideAll;
+          var scatterMarkerAttrs = scatterAttrs.marker;
+          var scatterLineAttrs = scatterAttrs.line;
+          var scatterMarkerLineAttrs = scatterMarkerAttrs.line;
+          module2.exports = overrideAll(
+            {
+              lon: {
+                valType: "data_array"
+              },
+              lat: {
+                valType: "data_array"
+              },
+              locations: {
+                valType: "data_array"
+              },
+              locationmode: {
+                valType: "enumerated",
+                values: ["ISO-3", "USA-states", "country names", "geojson-id"],
+                dflt: "ISO-3"
+              },
+              geojson: {
+                valType: "any",
+                editType: "calc"
+              },
+              featureidkey: {
+                valType: "string",
+                editType: "calc",
+                dflt: "id"
+              },
+              mode: extendFlat({}, scatterAttrs.mode, { dflt: "markers" }),
+              text: extendFlat({}, scatterAttrs.text, {}),
+              texttemplate: texttemplateAttrs({ editType: "plot" }, { keys: ["lat", "lon", "location", "text"] }),
+              texttemplatefallback: templatefallbackAttrs({ editType: "plot" }),
+              hovertext: extendFlat({}, scatterAttrs.hovertext, {}),
+              textfont: scatterAttrs.textfont,
+              textposition: scatterAttrs.textposition,
+              line: {
+                color: scatterLineAttrs.color,
+                width: scatterLineAttrs.width,
+                dash
+              },
+              connectgaps: scatterAttrs.connectgaps,
+              marker: extendFlat(
+                {
+                  symbol: scatterMarkerAttrs.symbol,
+                  opacity: scatterMarkerAttrs.opacity,
+                  angle: scatterMarkerAttrs.angle,
+                  angleref: extendFlat({}, scatterMarkerAttrs.angleref, {
+                    values: ["previous", "up", "north"]
+                  }),
+                  standoff: scatterMarkerAttrs.standoff,
+                  size: scatterMarkerAttrs.size,
+                  sizeref: scatterMarkerAttrs.sizeref,
+                  sizemin: scatterMarkerAttrs.sizemin,
+                  sizemode: scatterMarkerAttrs.sizemode,
+                  colorbar: scatterMarkerAttrs.colorbar,
+                  line: extendFlat(
+                    {
+                      width: scatterMarkerLineAttrs.width,
+                      dash: scatterMarkerLineAttrs.dash
+                    },
+                    colorAttributes("marker.line")
+                  ),
+                  gradient: scatterMarkerAttrs.gradient
+                },
+                colorAttributes("marker")
+              ),
+              fill: {
+                valType: "enumerated",
+                values: ["none", "toself"],
+                dflt: "none"
+              },
+              fillcolor: makeFillcolorAttr(),
+              selected: scatterAttrs.selected,
+              unselected: scatterAttrs.unselected,
+              hoverinfo: extendFlat({}, baseAttrs.hoverinfo, {
+                flags: ["lon", "lat", "location", "text", "name"]
+              }),
+              hovertemplate: hovertemplateAttrs(),
+              hovertemplatefallback: templatefallbackAttrs()
+            },
+            "calc",
+            "nested"
+          );
         }
-        if (newShadow) {
-          addClass(newShadow, classToAdd);
-          newShadow.alt = "";
+      });
+      var require_defaults44 = __commonJS({
+        "src/traces/scattergeo/defaults.js"(exports, module2) {
+          var Lib = require_lib();
+          var subTypes = require_subtypes();
+          var handleMarkerDefaults = require_marker_defaults();
+          var handleLineDefaults = require_line_defaults();
+          var handleTextDefaults = require_text_defaults();
+          var handleFillColorDefaults = require_fillcolor_defaults();
+          var attributes = require_attributes48();
+          var locationmodeBreakingChangeWarning = [
+            "The library used by the *country names* `locationmode` option is changing in the next major version.",
+            "Some country names in existing plots may not work in the new version.",
+            "To ensure consistent behavior, consider setting `locationmode` to *ISO-3*."
+          ].join(" ");
+          module2.exports = function supplyDefaults(traceIn, traceOut, defaultColor, layout) {
+            function coerce(attr, dflt) {
+              return Lib.coerce(traceIn, traceOut, attributes, attr, dflt);
+            }
+            var locations = coerce("locations");
+            var len2;
+            if (locations && locations.length) {
+              var geojson = coerce("geojson");
+              var locationmodeDflt;
+              if (typeof geojson === "string" && geojson !== "" || Lib.isPlainObject(geojson)) {
+                locationmodeDflt = "geojson-id";
+              }
+              var locationMode = coerce("locationmode", locationmodeDflt);
+              if (locationMode === "country names") {
+                Lib.warn(locationmodeBreakingChangeWarning);
+              }
+              if (locationMode === "geojson-id") {
+                coerce("featureidkey");
+              }
+              len2 = locations.length;
+            } else {
+              var lon = coerce("lon") || [];
+              var lat = coerce("lat") || [];
+              len2 = Math.min(lon.length, lat.length);
+            }
+            if (!len2) {
+              traceOut.visible = false;
+              return;
+            }
+            traceOut._length = len2;
+            coerce("text");
+            coerce("hovertext");
+            coerce("hovertemplate");
+            coerce("hovertemplatefallback");
+            coerce("mode");
+            if (subTypes.hasMarkers(traceOut)) {
+              handleMarkerDefaults(traceIn, traceOut, defaultColor, layout, coerce, { gradient: true });
+            }
+            if (subTypes.hasLines(traceOut)) {
+              handleLineDefaults(traceIn, traceOut, defaultColor, layout, coerce);
+              coerce("connectgaps");
+            }
+            if (subTypes.hasText(traceOut)) {
+              coerce("texttemplate");
+              coerce("texttemplatefallback");
+              handleTextDefaults(traceIn, traceOut, layout, coerce);
+            }
+            coerce("fill");
+            if (traceOut.fill !== "none") {
+              handleFillColorDefaults(traceIn, traceOut, defaultColor, coerce);
+            }
+            Lib.coerceSelectionMarkerOpacity(traceOut, coerce);
+          };
         }
-        this._shadow = newShadow;
-        if (options.opacity < 1) {
-          this._updateOpacity();
+      });
+      var require_format_labels3 = __commonJS({
+        "src/traces/scattergeo/format_labels.js"(exports, module2) {
+          var Axes = require_axes();
+          module2.exports = function formatLabels(cdi, trace, fullLayout) {
+            var labels = {};
+            var geo = fullLayout[trace.geo]._subplot;
+            var ax = geo.mockAxis;
+            var lonlat = cdi.lonlat;
+            labels.lonLabel = Axes.tickText(ax, ax.c2l(lonlat[0]), true).text;
+            labels.latLabel = Axes.tickText(ax, ax.c2l(lonlat[1]), true).text;
+            return labels;
+          };
         }
-        if (addIcon) {
-          this.getPane().appendChild(this._icon);
+      });
+      var require_calc27 = __commonJS({
+        "src/traces/scattergeo/calc.js"(exports, module2) {
+          var isNumeric = require_fast_isnumeric();
+          var BADNUM = require_numerical().BADNUM;
+          var calcMarkerColorscale = require_colorscale_calc();
+          var arraysToCalcdata = require_arrays_to_calcdata();
+          var calcSelection = require_calc_selection();
+          var isArrayOrTypedArray = require_lib().isArrayOrTypedArray;
+          var _2 = require_lib()._;
+          function isNonBlankString(v2) {
+            return v2 && typeof v2 === "string";
+          }
+          module2.exports = function calc(gd2, trace) {
+            var hasLocationData = isArrayOrTypedArray(trace.locations);
+            var len2 = hasLocationData ? trace.locations.length : trace._length;
+            var calcTrace = new Array(len2);
+            var isValidLoc;
+            if (trace.geojson) {
+              isValidLoc = function(v2) {
+                return isNonBlankString(v2) || isNumeric(v2);
+              };
+            } else {
+              isValidLoc = isNonBlankString;
+            }
+            for (var i2 = 0; i2 < len2; i2++) {
+              var calcPt = calcTrace[i2] = {};
+              if (hasLocationData) {
+                var loc = trace.locations[i2];
+                calcPt.loc = isValidLoc(loc) ? loc : null;
+              } else {
+                var lon = trace.lon[i2];
+                var lat = trace.lat[i2];
+                if (isNumeric(lon) && isNumeric(lat)) calcPt.lonlat = [+lon, +lat];
+                else calcPt.lonlat = [BADNUM, BADNUM];
+              }
+            }
+            arraysToCalcdata(calcTrace, trace);
+            calcMarkerColorscale(gd2, trace);
+            calcSelection(calcTrace, trace);
+            if (len2) {
+              calcTrace[0].t = {
+                labels: {
+                  lat: _2(gd2, "lat:") + " ",
+                  lon: _2(gd2, "lon:") + " "
+                }
+              };
+            }
+            return calcTrace;
+          };
         }
-        this._initInteraction();
-        if (newShadow && addShadow) {
-          this.getPane(options.shadowPane).appendChild(this._shadow);
+      });
+      var require_constants22 = __commonJS({
+        "src/plots/geo/constants.js"(exports) {
+          exports.projNames = {
+            airy: "airy",
+            aitoff: "aitoff",
+            "albers usa": "albersUsa",
+            albers: "albers",
+            // 'armadillo': 'armadillo',
+            august: "august",
+            "azimuthal equal area": "azimuthalEqualArea",
+            "azimuthal equidistant": "azimuthalEquidistant",
+            baker: "baker",
+            // 'berghaus': 'berghaus',
+            bertin1953: "bertin1953",
+            boggs: "boggs",
+            bonne: "bonne",
+            bottomley: "bottomley",
+            bromley: "bromley",
+            // 'chamberlin africa': 'chamberlinAfrica',
+            // 'chamberlin': 'chamberlin',
+            collignon: "collignon",
+            "conic conformal": "conicConformal",
+            "conic equal area": "conicEqualArea",
+            "conic equidistant": "conicEquidistant",
+            craig: "craig",
+            craster: "craster",
+            "cylindrical equal area": "cylindricalEqualArea",
+            "cylindrical stereographic": "cylindricalStereographic",
+            eckert1: "eckert1",
+            eckert2: "eckert2",
+            eckert3: "eckert3",
+            eckert4: "eckert4",
+            eckert5: "eckert5",
+            eckert6: "eckert6",
+            eisenlohr: "eisenlohr",
+            "equal earth": "equalEarth",
+            equirectangular: "equirectangular",
+            fahey: "fahey",
+            "foucaut sinusoidal": "foucautSinusoidal",
+            foucaut: "foucaut",
+            // 'gilbert': 'gilbert',
+            // 'gingery': 'gingery',
+            ginzburg4: "ginzburg4",
+            ginzburg5: "ginzburg5",
+            ginzburg6: "ginzburg6",
+            ginzburg8: "ginzburg8",
+            ginzburg9: "ginzburg9",
+            gnomonic: "gnomonic",
+            "gringorten quincuncial": "gringortenQuincuncial",
+            gringorten: "gringorten",
+            guyou: "guyou",
+            // 'hammer retroazimuthal': 'hammerRetroazimuthal',
+            hammer: "hammer",
+            // 'healpix': 'healpix',
+            hill: "hill",
+            homolosine: "homolosine",
+            hufnagel: "hufnagel",
+            hyperelliptical: "hyperelliptical",
+            // 'interrupted boggs': 'interruptedBoggs',
+            // 'interrupted homolosine': 'interruptedHomolosine',
+            // 'interrupted mollweide hemispheres': 'interruptedMollweideHemispheres',
+            // 'interrupted mollweide': 'interruptedMollweide',
+            // 'interrupted quartic authalic': 'interruptedQuarticAuthalic',
+            // 'interrupted sinu mollweide': 'interruptedSinuMollweide',
+            // 'interrupted sinusoidal': 'interruptedSinusoidal',
+            kavrayskiy7: "kavrayskiy7",
+            lagrange: "lagrange",
+            larrivee: "larrivee",
+            laskowski: "laskowski",
+            // 'littrow': 'littrow',
+            loximuthal: "loximuthal",
+            mercator: "mercator",
+            miller: "miller",
+            // 'modified stereographic alaska': 'modifiedStereographicAlaska',
+            // 'modified stereographic gs48': 'modifiedStereographicGs48',
+            // 'modified stereographic gs50': 'modifiedStereographicGs50',
+            // 'modified stereographic lee': 'modifiedStereographicLee',
+            // 'modified stereographic miller': 'modifiedStereographicMiller',
+            // 'modified stereographic': 'modifiedStereographic',
+            mollweide: "mollweide",
+            "mt flat polar parabolic": "mtFlatPolarParabolic",
+            "mt flat polar quartic": "mtFlatPolarQuartic",
+            "mt flat polar sinusoidal": "mtFlatPolarSinusoidal",
+            "natural earth": "naturalEarth",
+            "natural earth1": "naturalEarth1",
+            "natural earth2": "naturalEarth2",
+            "nell hammer": "nellHammer",
+            nicolosi: "nicolosi",
+            orthographic: "orthographic",
+            patterson: "patterson",
+            "peirce quincuncial": "peirceQuincuncial",
+            polyconic: "polyconic",
+            // 'polyhedral butterfly': 'polyhedralButterfly',
+            // 'polyhedral collignon': 'polyhedralCollignon',
+            // 'polyhedral waterman': 'polyhedralWaterman',
+            "rectangular polyconic": "rectangularPolyconic",
+            robinson: "robinson",
+            satellite: "satellite",
+            "sinu mollweide": "sinuMollweide",
+            sinusoidal: "sinusoidal",
+            stereographic: "stereographic",
+            times: "times",
+            "transverse mercator": "transverseMercator",
+            // 'two point azimuthalUsa': 'twoPointAzimuthalUsa',
+            // 'two point azimuthal': 'twoPointAzimuthal',
+            // 'two point equidistantUsa': 'twoPointEquidistantUsa',
+            // 'two point equidistant': 'twoPointEquidistant',
+            "van der grinten": "vanDerGrinten",
+            "van der grinten2": "vanDerGrinten2",
+            "van der grinten3": "vanDerGrinten3",
+            "van der grinten4": "vanDerGrinten4",
+            wagner4: "wagner4",
+            wagner6: "wagner6",
+            // 'wagner7': 'wagner7',
+            // 'wagner': 'wagner',
+            wiechel: "wiechel",
+            "winkel tripel": "winkel3",
+            winkel3: "winkel3"
+          };
+          exports.axesNames = ["lonaxis", "lataxis"];
+          exports.lonaxisSpan = {
+            orthographic: 180,
+            "azimuthal equal area": 360,
+            "azimuthal equidistant": 360,
+            "conic conformal": 180,
+            gnomonic: 160,
+            stereographic: 180,
+            "transverse mercator": 180,
+            "*": 360
+          };
+          exports.lataxisSpan = {
+            "conic conformal": 150,
+            stereographic: 179.5,
+            "*": 180
+          };
+          exports.scopeDefaults = {
+            world: {
+              lonaxisRange: [-180, 180],
+              lataxisRange: [-90, 90],
+              projType: "equirectangular",
+              projRotate: [0, 0, 0]
+            },
+            usa: {
+              lonaxisRange: [-180, -50],
+              lataxisRange: [15, 80],
+              projType: "albers usa"
+            },
+            europe: {
+              lonaxisRange: [-30, 60],
+              lataxisRange: [30, 85],
+              projType: "conic conformal",
+              projRotate: [15, 0, 0],
+              projParallels: [0, 60]
+            },
+            asia: {
+              lonaxisRange: [22, 160],
+              lataxisRange: [-15, 55],
+              projType: "mercator",
+              projRotate: [0, 0, 0]
+            },
+            africa: {
+              lonaxisRange: [-30, 60],
+              lataxisRange: [-40, 40],
+              projType: "mercator",
+              projRotate: [0, 0, 0]
+            },
+            "north america": {
+              lonaxisRange: [-180, -45],
+              lataxisRange: [5, 85],
+              projType: "conic conformal",
+              projRotate: [-100, 0, 0],
+              projParallels: [29.5, 45.5]
+            },
+            "south america": {
+              lonaxisRange: [-100, -30],
+              lataxisRange: [-60, 15],
+              projType: "mercator",
+              projRotate: [0, 0, 0]
+            },
+            antarctica: {
+              lonaxisRange: [-180, 180],
+              lataxisRange: [-90, -60],
+              projType: "equirectangular",
+              projRotate: [0, 0, 0]
+            },
+            oceania: {
+              lonaxisRange: [-180, 180],
+              lataxisRange: [-50, 25],
+              projType: "equirectangular",
+              projRotate: [0, 0, 0]
+            }
+          };
+          exports.clipPad = 1e-3;
+          exports.precision = 0.1;
+          exports.landColor = "#F0DC82";
+          exports.waterColor = "#3399FF";
+          exports.locationmodeToLayer = {
+            "ISO-3": "countries",
+            "USA-states": "subunits",
+            "country names": "countries"
+          };
+          exports.sphereSVG = { type: "Sphere" };
+          exports.fillLayers = {
+            ocean: 1,
+            land: 1,
+            lakes: 1
+          };
+          exports.lineLayers = {
+            subunits: 1,
+            countries: 1,
+            coastlines: 1,
+            rivers: 1,
+            frame: 1
+          };
+          exports.layers = [
+            "bg",
+            "ocean",
+            "land",
+            "lakes",
+            "subunits",
+            "countries",
+            "coastlines",
+            "rivers",
+            "lataxis",
+            "lonaxis",
+            "frame",
+            "backplot",
+            "frontplot"
+          ];
+          exports.layersForChoropleth = [
+            "bg",
+            "ocean",
+            "land",
+            "subunits",
+            "countries",
+            "coastlines",
+            "lataxis",
+            "lonaxis",
+            "frame",
+            "backplot",
+            "rivers",
+            "lakes",
+            "frontplot"
+          ];
+          exports.layerNameToAdjective = {
+            ocean: "ocean",
+            land: "land",
+            lakes: "lake",
+            subunits: "subunit",
+            countries: "country",
+            coastlines: "coastline",
+            rivers: "river",
+            frame: "frame"
+          };
         }
-      },
-      _removeIcon: function() {
-        if (this.options.riseOnHover) {
-          this.off({
-            mouseover: this._bringToFront,
-            mouseout: this._resetZIndex
+      });
+      var require_topojson_client = __commonJS({
+        "node_modules/topojson-client/dist/topojson-client.js"(exports, module2) {
+          (function(global2, factory2) {
+            typeof exports === "object" && typeof module2 !== "undefined" ? factory2(exports) : (global2 = global2 || self, factory2(global2.topojson = global2.topojson || {}));
+          })(exports, function(exports2) {
+            function identity22(x2) {
+              return x2;
+            }
+            function transform(transform2) {
+              if (transform2 == null) return identity22;
+              var x0, y0, kx = transform2.scale[0], ky = transform2.scale[1], dx = transform2.translate[0], dy = transform2.translate[1];
+              return function(input, i2) {
+                if (!i2) x0 = y0 = 0;
+                var j2 = 2, n2 = input.length, output = new Array(n2);
+                output[0] = (x0 += input[0]) * kx + dx;
+                output[1] = (y0 += input[1]) * ky + dy;
+                while (j2 < n2) output[j2] = input[j2], ++j2;
+                return output;
+              };
+            }
+            function bbox(topology) {
+              var t4 = transform(topology.transform), key, x0 = Infinity, y0 = x0, x1 = -x0, y1 = -x0;
+              function bboxPoint(p2) {
+                p2 = t4(p2);
+                if (p2[0] < x0) x0 = p2[0];
+                if (p2[0] > x1) x1 = p2[0];
+                if (p2[1] < y0) y0 = p2[1];
+                if (p2[1] > y1) y1 = p2[1];
+              }
+              function bboxGeometry(o2) {
+                switch (o2.type) {
+                  case "GeometryCollection":
+                    o2.geometries.forEach(bboxGeometry);
+                    break;
+                  case "Point":
+                    bboxPoint(o2.coordinates);
+                    break;
+                  case "MultiPoint":
+                    o2.coordinates.forEach(bboxPoint);
+                    break;
+                }
+              }
+              topology.arcs.forEach(function(arc) {
+                var i2 = -1, n2 = arc.length, p2;
+                while (++i2 < n2) {
+                  p2 = t4(arc[i2], i2);
+                  if (p2[0] < x0) x0 = p2[0];
+                  if (p2[0] > x1) x1 = p2[0];
+                  if (p2[1] < y0) y0 = p2[1];
+                  if (p2[1] > y1) y1 = p2[1];
+                }
+              });
+              for (key in topology.objects) {
+                bboxGeometry(topology.objects[key]);
+              }
+              return [x0, y0, x1, y1];
+            }
+            function reverse(array, n2) {
+              var t4, j2 = array.length, i2 = j2 - n2;
+              while (i2 < --j2) t4 = array[i2], array[i2++] = array[j2], array[j2] = t4;
+            }
+            function feature(topology, o2) {
+              if (typeof o2 === "string") o2 = topology.objects[o2];
+              return o2.type === "GeometryCollection" ? { type: "FeatureCollection", features: o2.geometries.map(function(o22) {
+                return feature$1(topology, o22);
+              }) } : feature$1(topology, o2);
+            }
+            function feature$1(topology, o2) {
+              var id2 = o2.id, bbox2 = o2.bbox, properties = o2.properties == null ? {} : o2.properties, geometry2 = object(topology, o2);
+              return id2 == null && bbox2 == null ? { type: "Feature", properties, geometry: geometry2 } : bbox2 == null ? { type: "Feature", id: id2, properties, geometry: geometry2 } : { type: "Feature", id: id2, bbox: bbox2, properties, geometry: geometry2 };
+            }
+            function object(topology, o2) {
+              var transformPoint = transform(topology.transform), arcs = topology.arcs;
+              function arc(i2, points) {
+                if (points.length) points.pop();
+                for (var a2 = arcs[i2 < 0 ? ~i2 : i2], k2 = 0, n2 = a2.length; k2 < n2; ++k2) {
+                  points.push(transformPoint(a2[k2], k2));
+                }
+                if (i2 < 0) reverse(points, n2);
+              }
+              function point(p2) {
+                return transformPoint(p2);
+              }
+              function line(arcs2) {
+                var points = [];
+                for (var i2 = 0, n2 = arcs2.length; i2 < n2; ++i2) arc(arcs2[i2], points);
+                if (points.length < 2) points.push(points[0]);
+                return points;
+              }
+              function ring(arcs2) {
+                var points = line(arcs2);
+                while (points.length < 4) points.push(points[0]);
+                return points;
+              }
+              function polygon(arcs2) {
+                return arcs2.map(ring);
+              }
+              function geometry2(o22) {
+                var type = o22.type, coordinates;
+                switch (type) {
+                  case "GeometryCollection":
+                    return { type, geometries: o22.geometries.map(geometry2) };
+                  case "Point":
+                    coordinates = point(o22.coordinates);
+                    break;
+                  case "MultiPoint":
+                    coordinates = o22.coordinates.map(point);
+                    break;
+                  case "LineString":
+                    coordinates = line(o22.arcs);
+                    break;
+                  case "MultiLineString":
+                    coordinates = o22.arcs.map(line);
+                    break;
+                  case "Polygon":
+                    coordinates = polygon(o22.arcs);
+                    break;
+                  case "MultiPolygon":
+                    coordinates = o22.arcs.map(polygon);
+                    break;
+                  default:
+                    return null;
+                }
+                return { type, coordinates };
+              }
+              return geometry2(o2);
+            }
+            function stitch(topology, arcs) {
+              var stitchedArcs = {}, fragmentByStart = {}, fragmentByEnd = {}, fragments2 = [], emptyIndex = -1;
+              arcs.forEach(function(i2, j2) {
+                var arc = topology.arcs[i2 < 0 ? ~i2 : i2], t4;
+                if (arc.length < 3 && !arc[1][0] && !arc[1][1]) {
+                  t4 = arcs[++emptyIndex], arcs[emptyIndex] = i2, arcs[j2] = t4;
+                }
+              });
+              arcs.forEach(function(i2) {
+                var e2 = ends(i2), start = e2[0], end = e2[1], f2, g2;
+                if (f2 = fragmentByEnd[start]) {
+                  delete fragmentByEnd[f2.end];
+                  f2.push(i2);
+                  f2.end = end;
+                  if (g2 = fragmentByStart[end]) {
+                    delete fragmentByStart[g2.start];
+                    var fg2 = g2 === f2 ? f2 : f2.concat(g2);
+                    fragmentByStart[fg2.start = f2.start] = fragmentByEnd[fg2.end = g2.end] = fg2;
+                  } else {
+                    fragmentByStart[f2.start] = fragmentByEnd[f2.end] = f2;
+                  }
+                } else if (f2 = fragmentByStart[end]) {
+                  delete fragmentByStart[f2.start];
+                  f2.unshift(i2);
+                  f2.start = start;
+                  if (g2 = fragmentByEnd[start]) {
+                    delete fragmentByEnd[g2.end];
+                    var gf = g2 === f2 ? f2 : g2.concat(f2);
+                    fragmentByStart[gf.start = g2.start] = fragmentByEnd[gf.end = f2.end] = gf;
+                  } else {
+                    fragmentByStart[f2.start] = fragmentByEnd[f2.end] = f2;
+                  }
+                } else {
+                  f2 = [i2];
+                  fragmentByStart[f2.start = start] = fragmentByEnd[f2.end = end] = f2;
+                }
+              });
+              function ends(i2) {
+                var arc = topology.arcs[i2 < 0 ? ~i2 : i2], p0 = arc[0], p1;
+                if (topology.transform) p1 = [0, 0], arc.forEach(function(dp) {
+                  p1[0] += dp[0], p1[1] += dp[1];
+                });
+                else p1 = arc[arc.length - 1];
+                return i2 < 0 ? [p1, p0] : [p0, p1];
+              }
+              function flush(fragmentByEnd2, fragmentByStart2) {
+                for (var k2 in fragmentByEnd2) {
+                  var f2 = fragmentByEnd2[k2];
+                  delete fragmentByStart2[f2.start];
+                  delete f2.start;
+                  delete f2.end;
+                  f2.forEach(function(i2) {
+                    stitchedArcs[i2 < 0 ? ~i2 : i2] = 1;
+                  });
+                  fragments2.push(f2);
+                }
+              }
+              flush(fragmentByEnd, fragmentByStart);
+              flush(fragmentByStart, fragmentByEnd);
+              arcs.forEach(function(i2) {
+                if (!stitchedArcs[i2 < 0 ? ~i2 : i2]) fragments2.push([i2]);
+              });
+              return fragments2;
+            }
+            function mesh(topology) {
+              return object(topology, meshArcs.apply(this, arguments));
+            }
+            function meshArcs(topology, object2, filter) {
+              var arcs, i2, n2;
+              if (arguments.length > 1) arcs = extractArcs(topology, object2, filter);
+              else for (i2 = 0, arcs = new Array(n2 = topology.arcs.length); i2 < n2; ++i2) arcs[i2] = i2;
+              return { type: "MultiLineString", arcs: stitch(topology, arcs) };
+            }
+            function extractArcs(topology, object2, filter) {
+              var arcs = [], geomsByArc = [], geom;
+              function extract0(i2) {
+                var j2 = i2 < 0 ? ~i2 : i2;
+                (geomsByArc[j2] || (geomsByArc[j2] = [])).push({ i: i2, g: geom });
+              }
+              function extract1(arcs2) {
+                arcs2.forEach(extract0);
+              }
+              function extract2(arcs2) {
+                arcs2.forEach(extract1);
+              }
+              function extract3(arcs2) {
+                arcs2.forEach(extract2);
+              }
+              function geometry2(o2) {
+                switch (geom = o2, o2.type) {
+                  case "GeometryCollection":
+                    o2.geometries.forEach(geometry2);
+                    break;
+                  case "LineString":
+                    extract1(o2.arcs);
+                    break;
+                  case "MultiLineString":
+                  case "Polygon":
+                    extract2(o2.arcs);
+                    break;
+                  case "MultiPolygon":
+                    extract3(o2.arcs);
+                    break;
+                }
+              }
+              geometry2(object2);
+              geomsByArc.forEach(filter == null ? function(geoms) {
+                arcs.push(geoms[0].i);
+              } : function(geoms) {
+                if (filter(geoms[0].g, geoms[geoms.length - 1].g)) arcs.push(geoms[0].i);
+              });
+              return arcs;
+            }
+            function planarRingArea(ring) {
+              var i2 = -1, n2 = ring.length, a2, b2 = ring[n2 - 1], area = 0;
+              while (++i2 < n2) a2 = b2, b2 = ring[i2], area += a2[0] * b2[1] - a2[1] * b2[0];
+              return Math.abs(area);
+            }
+            function merge(topology) {
+              return object(topology, mergeArcs.apply(this, arguments));
+            }
+            function mergeArcs(topology, objects) {
+              var polygonsByArc = {}, polygons = [], groups = [];
+              objects.forEach(geometry2);
+              function geometry2(o2) {
+                switch (o2.type) {
+                  case "GeometryCollection":
+                    o2.geometries.forEach(geometry2);
+                    break;
+                  case "Polygon":
+                    extract(o2.arcs);
+                    break;
+                  case "MultiPolygon":
+                    o2.arcs.forEach(extract);
+                    break;
+                }
+              }
+              function extract(polygon) {
+                polygon.forEach(function(ring) {
+                  ring.forEach(function(arc) {
+                    (polygonsByArc[arc = arc < 0 ? ~arc : arc] || (polygonsByArc[arc] = [])).push(polygon);
+                  });
+                });
+                polygons.push(polygon);
+              }
+              function area(ring) {
+                return planarRingArea(object(topology, { type: "Polygon", arcs: [ring] }).coordinates[0]);
+              }
+              polygons.forEach(function(polygon) {
+                if (!polygon._) {
+                  var group = [], neighbors2 = [polygon];
+                  polygon._ = 1;
+                  groups.push(group);
+                  while (polygon = neighbors2.pop()) {
+                    group.push(polygon);
+                    polygon.forEach(function(ring) {
+                      ring.forEach(function(arc) {
+                        polygonsByArc[arc < 0 ? ~arc : arc].forEach(function(polygon2) {
+                          if (!polygon2._) {
+                            polygon2._ = 1;
+                            neighbors2.push(polygon2);
+                          }
+                        });
+                      });
+                    });
+                  }
+                }
+              });
+              polygons.forEach(function(polygon) {
+                delete polygon._;
+              });
+              return {
+                type: "MultiPolygon",
+                arcs: groups.map(function(polygons2) {
+                  var arcs = [], n2;
+                  polygons2.forEach(function(polygon) {
+                    polygon.forEach(function(ring) {
+                      ring.forEach(function(arc) {
+                        if (polygonsByArc[arc < 0 ? ~arc : arc].length < 2) {
+                          arcs.push(arc);
+                        }
+                      });
+                    });
+                  });
+                  arcs = stitch(topology, arcs);
+                  if ((n2 = arcs.length) > 1) {
+                    for (var i2 = 1, k2 = area(arcs[0]), ki2, t4; i2 < n2; ++i2) {
+                      if ((ki2 = area(arcs[i2])) > k2) {
+                        t4 = arcs[0], arcs[0] = arcs[i2], arcs[i2] = t4, k2 = ki2;
+                      }
+                    }
+                  }
+                  return arcs;
+                }).filter(function(arcs) {
+                  return arcs.length > 0;
+                })
+              };
+            }
+            function bisect(a2, x2) {
+              var lo = 0, hi2 = a2.length;
+              while (lo < hi2) {
+                var mid = lo + hi2 >>> 1;
+                if (a2[mid] < x2) lo = mid + 1;
+                else hi2 = mid;
+              }
+              return lo;
+            }
+            function neighbors(objects) {
+              var indexesByArc = {}, neighbors2 = objects.map(function() {
+                return [];
+              });
+              function line(arcs, i22) {
+                arcs.forEach(function(a2) {
+                  if (a2 < 0) a2 = ~a2;
+                  var o2 = indexesByArc[a2];
+                  if (o2) o2.push(i22);
+                  else indexesByArc[a2] = [i22];
+                });
+              }
+              function polygon(arcs, i22) {
+                arcs.forEach(function(arc) {
+                  line(arc, i22);
+                });
+              }
+              function geometry2(o2, i22) {
+                if (o2.type === "GeometryCollection") o2.geometries.forEach(function(o22) {
+                  geometry2(o22, i22);
+                });
+                else if (o2.type in geometryType) geometryType[o2.type](o2.arcs, i22);
+              }
+              var geometryType = {
+                LineString: line,
+                MultiLineString: polygon,
+                Polygon: polygon,
+                MultiPolygon: function(arcs, i22) {
+                  arcs.forEach(function(arc) {
+                    polygon(arc, i22);
+                  });
+                }
+              };
+              objects.forEach(geometry2);
+              for (var i2 in indexesByArc) {
+                for (var indexes = indexesByArc[i2], m2 = indexes.length, j2 = 0; j2 < m2; ++j2) {
+                  for (var k2 = j2 + 1; k2 < m2; ++k2) {
+                    var ij2 = indexes[j2], ik2 = indexes[k2], n2;
+                    if ((n2 = neighbors2[ij2])[i2 = bisect(n2, ik2)] !== ik2) n2.splice(i2, 0, ik2);
+                    if ((n2 = neighbors2[ik2])[i2 = bisect(n2, ij2)] !== ij2) n2.splice(i2, 0, ij2);
+                  }
+                }
+              }
+              return neighbors2;
+            }
+            function untransform(transform2) {
+              if (transform2 == null) return identity22;
+              var x0, y0, kx = transform2.scale[0], ky = transform2.scale[1], dx = transform2.translate[0], dy = transform2.translate[1];
+              return function(input, i2) {
+                if (!i2) x0 = y0 = 0;
+                var j2 = 2, n2 = input.length, output = new Array(n2), x1 = Math.round((input[0] - dx) / kx), y1 = Math.round((input[1] - dy) / ky);
+                output[0] = x1 - x0, x0 = x1;
+                output[1] = y1 - y0, y0 = y1;
+                while (j2 < n2) output[j2] = input[j2], ++j2;
+                return output;
+              };
+            }
+            function quantize(topology, transform2) {
+              if (topology.transform) throw new Error("already quantized");
+              if (!transform2 || !transform2.scale) {
+                if (!((n2 = Math.floor(transform2)) >= 2)) throw new Error("n must be ≥2");
+                box = topology.bbox || bbox(topology);
+                var x0 = box[0], y0 = box[1], x1 = box[2], y1 = box[3], n2;
+                transform2 = { scale: [x1 - x0 ? (x1 - x0) / (n2 - 1) : 1, y1 - y0 ? (y1 - y0) / (n2 - 1) : 1], translate: [x0, y0] };
+              } else {
+                box = topology.bbox;
+              }
+              var t4 = untransform(transform2), box, key, inputs = topology.objects, outputs = {};
+              function quantizePoint(point) {
+                return t4(point);
+              }
+              function quantizeGeometry(input) {
+                var output;
+                switch (input.type) {
+                  case "GeometryCollection":
+                    output = { type: "GeometryCollection", geometries: input.geometries.map(quantizeGeometry) };
+                    break;
+                  case "Point":
+                    output = { type: "Point", coordinates: quantizePoint(input.coordinates) };
+                    break;
+                  case "MultiPoint":
+                    output = { type: "MultiPoint", coordinates: input.coordinates.map(quantizePoint) };
+                    break;
+                  default:
+                    return input;
+                }
+                if (input.id != null) output.id = input.id;
+                if (input.bbox != null) output.bbox = input.bbox;
+                if (input.properties != null) output.properties = input.properties;
+                return output;
+              }
+              function quantizeArc(input) {
+                var i2 = 0, j2 = 1, n22 = input.length, p2, output = new Array(n22);
+                output[0] = t4(input[0], 0);
+                while (++i2 < n22) if ((p2 = t4(input[i2], i2))[0] || p2[1]) output[j2++] = p2;
+                if (j2 === 1) output[j2++] = [0, 0];
+                output.length = j2;
+                return output;
+              }
+              for (key in inputs) outputs[key] = quantizeGeometry(inputs[key]);
+              return {
+                type: "Topology",
+                bbox: box,
+                transform: transform2,
+                objects: outputs,
+                arcs: topology.arcs.map(quantizeArc)
+              };
+            }
+            exports2.bbox = bbox;
+            exports2.feature = feature;
+            exports2.merge = merge;
+            exports2.mergeArcs = mergeArcs;
+            exports2.mesh = mesh;
+            exports2.meshArcs = meshArcs;
+            exports2.neighbors = neighbors;
+            exports2.quantize = quantize;
+            exports2.transform = transform;
+            exports2.untransform = untransform;
+            Object.defineProperty(exports2, "__esModule", { value: true });
           });
         }
-        if (this.options.autoPanOnFocus) {
-          off(this._icon, "focus", this._panOnFocus, this);
-        }
-        remove(this._icon);
-        this.removeInteractiveTarget(this._icon);
-        this._icon = null;
-      },
-      _removeShadow: function() {
-        if (this._shadow) {
-          remove(this._shadow);
-        }
-        this._shadow = null;
-      },
-      _setPos: function(pos) {
-        if (this._icon) {
-          setPosition(this._icon, pos);
+      });
+      var require_topojson_utils = __commonJS({
+        "src/lib/topojson_utils.js"(exports, module2) {
+          var topojsonUtils = module2.exports = {};
+          var locationmodeToLayer = require_constants22().locationmodeToLayer;
+          var topojsonFeature = require_topojson_client().feature;
+          topojsonUtils.getTopojsonName = function(geoLayout) {
+            return [
+              geoLayout.scope.replace(/ /g, "-"),
+              "_",
+              geoLayout.resolution.toString(),
+              "m"
+            ].join("");
+          };
+          topojsonUtils.getTopojsonPath = function(topojsonURL, topojsonName) {
+            topojsonURL += topojsonURL.endsWith("/") ? "" : "/";
+            return `${topojsonURL}${topojsonName}.json`;
+          };
+          topojsonUtils.getTopojsonFeatures = function(trace, topojson) {
+            var layer = locationmodeToLayer[trace.locationmode];
+            var obj = topojson.objects[layer];
+            return topojsonFeature(topojson, obj).features;
+          };
         }
-        if (this._shadow) {
-          setPosition(this._shadow, pos);
+      });
+      var require_geojson_utils = __commonJS({
+        "src/lib/geojson_utils.js"(exports) {
+          var BADNUM = require_numerical().BADNUM;
+          exports.calcTraceToLineCoords = function(calcTrace) {
+            var trace = calcTrace[0].trace;
+            var connectgaps = trace.connectgaps;
+            var coords = [];
+            var lineString = [];
+            for (var i2 = 0; i2 < calcTrace.length; i2++) {
+              var calcPt = calcTrace[i2];
+              var lonlat = calcPt.lonlat;
+              if (lonlat[0] !== BADNUM) {
+                lineString.push(lonlat);
+              } else if (!connectgaps && lineString.length > 0) {
+                coords.push(lineString);
+                lineString = [];
+              }
+            }
+            if (lineString.length > 0) {
+              coords.push(lineString);
+            }
+            return coords;
+          };
+          exports.makeLine = function(coords) {
+            if (coords.length === 1) {
+              return {
+                type: "LineString",
+                coordinates: coords[0]
+              };
+            } else {
+              return {
+                type: "MultiLineString",
+                coordinates: coords
+              };
+            }
+          };
+          exports.makePolygon = function(coords) {
+            if (coords.length === 1) {
+              return {
+                type: "Polygon",
+                coordinates: coords
+              };
+            } else {
+              var _coords = new Array(coords.length);
+              for (var i2 = 0; i2 < coords.length; i2++) {
+                _coords[i2] = [coords[i2]];
+              }
+              return {
+                type: "MultiPolygon",
+                coordinates: _coords
+              };
+            }
+          };
+          exports.makeBlank = function() {
+            return {
+              type: "Point",
+              coordinates: []
+            };
+          };
         }
-        this._zIndex = pos.y + this.options.zIndexOffset;
-        this._resetZIndex();
-      },
-      _updateZIndex: function(offset) {
-        if (this._icon) {
-          this._icon.style.zIndex = this._zIndex + offset;
+      });
+      var require_country_regex = __commonJS({
+        "node_modules/country-regex/index.js"(exports, module2) {
+          module2.exports = {
+            AFG: "afghan",
+            ALA: "\\b\\wland",
+            ALB: "albania",
+            DZA: "algeria",
+            ASM: "^(?=.*americ).*samoa",
+            AND: "andorra",
+            AGO: "angola",
+            AIA: "anguill?a",
+            ATA: "antarctica",
+            ATG: "antigua",
+            ARG: "argentin",
+            ARM: "armenia",
+            ABW: "^(?!.*bonaire).*\\baruba",
+            AUS: "australia",
+            AUT: "^(?!.*hungary).*austria|\\baustri.*\\bemp",
+            AZE: "azerbaijan",
+            BHS: "bahamas",
+            BHR: "bahrain",
+            BGD: "bangladesh|^(?=.*east).*paki?stan",
+            BRB: "barbados",
+            BLR: "belarus|byelo",
+            BEL: "^(?!.*luxem).*belgium",
+            BLZ: "belize|^(?=.*british).*honduras",
+            BEN: "benin|dahome",
+            BMU: "bermuda",
+            BTN: "bhutan",
+            BOL: "bolivia",
+            BES: "^(?=.*bonaire).*eustatius|^(?=.*carib).*netherlands|\\bbes.?islands",
+            BIH: "herzegovina|bosnia",
+            BWA: "botswana|bechuana",
+            BVT: "bouvet",
+            BRA: "brazil",
+            IOT: "british.?indian.?ocean",
+            BRN: "brunei",
+            BGR: "bulgaria",
+            BFA: "burkina|\\bfaso|upper.?volta",
+            BDI: "burundi",
+            CPV: "verde",
+            KHM: "cambodia|kampuchea|khmer",
+            CMR: "cameroon",
+            CAN: "canada",
+            CYM: "cayman",
+            CAF: "\\bcentral.african.republic",
+            TCD: "\\bchad",
+            CHL: "\\bchile",
+            CHN: "^(?!.*\\bmac)(?!.*\\bhong)(?!.*\\btai)(?!.*\\brep).*china|^(?=.*peo)(?=.*rep).*china",
+            CXR: "christmas",
+            CCK: "\\bcocos|keeling",
+            COL: "colombia",
+            COM: "comoro",
+            COG: "^(?!.*\\bdem)(?!.*\\bd[\\.]?r)(?!.*kinshasa)(?!.*zaire)(?!.*belg)(?!.*l.opoldville)(?!.*free).*\\bcongo",
+            COK: "\\bcook",
+            CRI: "costa.?rica",
+            CIV: "ivoire|ivory",
+            HRV: "croatia",
+            CUB: "\\bcuba",
+            CUW: "^(?!.*bonaire).*\\bcura(c|ç)ao",
+            CYP: "cyprus",
+            CSK: "czechoslovakia",
+            CZE: "^(?=.*rep).*czech|czechia|bohemia",
+            COD: "\\bdem.*congo|congo.*\\bdem|congo.*\\bd[\\.]?r|\\bd[\\.]?r.*congo|belgian.?congo|congo.?free.?state|kinshasa|zaire|l.opoldville|drc|droc|rdc",
+            DNK: "denmark",
+            DJI: "djibouti",
+            DMA: "dominica(?!n)",
+            DOM: "dominican.rep",
+            ECU: "ecuador",
+            EGY: "egypt",
+            SLV: "el.?salvador",
+            GNQ: "guine.*eq|eq.*guine|^(?=.*span).*guinea",
+            ERI: "eritrea",
+            EST: "estonia",
+            ETH: "ethiopia|abyssinia",
+            FLK: "falkland|malvinas",
+            FRO: "faroe|faeroe",
+            FJI: "fiji",
+            FIN: "finland",
+            FRA: "^(?!.*\\bdep)(?!.*martinique).*france|french.?republic|\\bgaul",
+            GUF: "^(?=.*french).*guiana",
+            PYF: "french.?polynesia|tahiti",
+            ATF: "french.?southern",
+            GAB: "gabon",
+            GMB: "gambia",
+            GEO: "^(?!.*south).*georgia",
+            DDR: "german.?democratic.?republic|democratic.?republic.*germany|east.germany",
+            DEU: "^(?!.*east).*germany|^(?=.*\\bfed.*\\brep).*german",
+            GHA: "ghana|gold.?coast",
+            GIB: "gibraltar",
+            GRC: "greece|hellenic|hellas",
+            GRL: "greenland",
+            GRD: "grenada",
+            GLP: "guadeloupe",
+            GUM: "\\bguam",
+            GTM: "guatemala",
+            GGY: "guernsey",
+            GIN: "^(?!.*eq)(?!.*span)(?!.*bissau)(?!.*portu)(?!.*new).*guinea",
+            GNB: "bissau|^(?=.*portu).*guinea",
+            GUY: "guyana|british.?guiana",
+            HTI: "haiti",
+            HMD: "heard.*mcdonald",
+            VAT: "holy.?see|vatican|papal.?st",
+            HND: "^(?!.*brit).*honduras",
+            HKG: "hong.?kong",
+            HUN: "^(?!.*austr).*hungary",
+            ISL: "iceland",
+            IND: "india(?!.*ocea)",
+            IDN: "indonesia",
+            IRN: "\\biran|persia",
+            IRQ: "\\biraq|mesopotamia",
+            IRL: "(^ireland)|(^republic.*ireland)",
+            IMN: "^(?=.*isle).*\\bman",
+            ISR: "israel",
+            ITA: "italy",
+            JAM: "jamaica",
+            JPN: "japan",
+            JEY: "jersey",
+            JOR: "jordan",
+            KAZ: "kazak",
+            KEN: "kenya|british.?east.?africa|east.?africa.?prot",
+            KIR: "kiribati",
+            PRK: "^(?=.*democrat|people|north|d.*p.*.r).*\\bkorea|dprk|korea.*(d.*p.*r)",
+            KWT: "kuwait",
+            KGZ: "kyrgyz|kirghiz",
+            LAO: "\\blaos?\\b",
+            LVA: "latvia",
+            LBN: "lebanon",
+            LSO: "lesotho|basuto",
+            LBR: "liberia",
+            LBY: "libya",
+            LIE: "liechtenstein",
+            LTU: "lithuania",
+            LUX: "^(?!.*belg).*luxem",
+            MAC: "maca(o|u)",
+            MDG: "madagascar|malagasy",
+            MWI: "malawi|nyasa",
+            MYS: "malaysia",
+            MDV: "maldive",
+            MLI: "\\bmali\\b",
+            MLT: "\\bmalta",
+            MHL: "marshall",
+            MTQ: "martinique",
+            MRT: "mauritania",
+            MUS: "mauritius",
+            MYT: "\\bmayotte",
+            MEX: "\\bmexic",
+            FSM: "fed.*micronesia|micronesia.*fed",
+            MCO: "monaco",
+            MNG: "mongolia",
+            MNE: "^(?!.*serbia).*montenegro",
+            MSR: "montserrat",
+            MAR: "morocco|\\bmaroc",
+            MOZ: "mozambique",
+            MMR: "myanmar|burma",
+            NAM: "namibia",
+            NRU: "nauru",
+            NPL: "nepal",
+            NLD: "^(?!.*\\bant)(?!.*\\bcarib).*netherlands",
+            ANT: "^(?=.*\\bant).*(nether|dutch)",
+            NCL: "new.?caledonia",
+            NZL: "new.?zealand",
+            NIC: "nicaragua",
+            NER: "\\bniger(?!ia)",
+            NGA: "nigeria",
+            NIU: "niue",
+            NFK: "norfolk",
+            MNP: "mariana",
+            NOR: "norway",
+            OMN: "\\boman|trucial",
+            PAK: "^(?!.*east).*paki?stan",
+            PLW: "palau",
+            PSE: "palestin|\\bgaza|west.?bank",
+            PAN: "panama",
+            PNG: "papua|new.?guinea",
+            PRY: "paraguay",
+            PER: "peru",
+            PHL: "philippines",
+            PCN: "pitcairn",
+            POL: "poland",
+            PRT: "portugal",
+            PRI: "puerto.?rico",
+            QAT: "qatar",
+            KOR: "^(?!.*d.*p.*r)(?!.*democrat)(?!.*people)(?!.*north).*\\bkorea(?!.*d.*p.*r)",
+            MDA: "moldov|b(a|e)ssarabia",
+            REU: "r(e|é)union",
+            ROU: "r(o|u|ou)mania",
+            RUS: "\\brussia|soviet.?union|u\\.?s\\.?s\\.?r|socialist.?republics",
+            RWA: "rwanda",
+            BLM: "barth(e|é)lemy",
+            SHN: "helena",
+            KNA: "kitts|\\bnevis",
+            LCA: "\\blucia",
+            MAF: "^(?=.*collectivity).*martin|^(?=.*france).*martin(?!ique)|^(?=.*french).*martin(?!ique)",
+            SPM: "miquelon",
+            VCT: "vincent",
+            WSM: "^(?!.*amer).*samoa",
+            SMR: "san.?marino",
+            STP: "\\bs(a|ã)o.?tom(e|é)",
+            SAU: "\\bsa\\w*.?arabia",
+            SEN: "senegal",
+            SRB: "^(?!.*monte).*serbia",
+            SYC: "seychell",
+            SLE: "sierra",
+            SGP: "singapore",
+            SXM: "^(?!.*martin)(?!.*saba).*maarten",
+            SVK: "^(?!.*cze).*slovak",
+            SVN: "slovenia",
+            SLB: "solomon",
+            SOM: "somali",
+            ZAF: "south.africa|s\\\\..?africa",
+            SGS: "south.?georgia|sandwich",
+            SSD: "\\bs\\w*.?sudan",
+            ESP: "spain",
+            LKA: "sri.?lanka|ceylon",
+            SDN: "^(?!.*\\bs(?!u)).*sudan",
+            SUR: "surinam|dutch.?guiana",
+            SJM: "svalbard",
+            SWZ: "swaziland",
+            SWE: "sweden",
+            CHE: "switz|swiss",
+            SYR: "syria",
+            TWN: "taiwan|taipei|formosa|^(?!.*peo)(?=.*rep).*china",
+            TJK: "tajik",
+            THA: "thailand|\\bsiam",
+            MKD: "macedonia|fyrom",
+            TLS: "^(?=.*leste).*timor|^(?=.*east).*timor",
+            TGO: "togo",
+            TKL: "tokelau",
+            TON: "tonga",
+            TTO: "trinidad|tobago",
+            TUN: "tunisia",
+            TUR: "turkey",
+            TKM: "turkmen",
+            TCA: "turks",
+            TUV: "tuvalu",
+            UGA: "uganda",
+            UKR: "ukrain",
+            ARE: "emirates|^u\\.?a\\.?e\\.?$|united.?arab.?em",
+            GBR: "united.?kingdom|britain|^u\\.?k\\.?$",
+            TZA: "tanzania",
+            USA: "united.?states\\b(?!.*islands)|\\bu\\.?s\\.?a\\.?\\b|^\\s*u\\.?s\\.?\\b(?!.*islands)",
+            UMI: "minor.?outlying.?is",
+            URY: "uruguay",
+            UZB: "uzbek",
+            VUT: "vanuatu|new.?hebrides",
+            VEN: "venezuela",
+            VNM: "^(?!.*republic).*viet.?nam|^(?=.*socialist).*viet.?nam",
+            VGB: "^(?=.*\\bu\\.?\\s?k).*virgin|^(?=.*brit).*virgin|^(?=.*kingdom).*virgin",
+            VIR: "^(?=.*\\bu\\.?\\s?s).*virgin|^(?=.*states).*virgin",
+            WLF: "futuna|wallis",
+            ESH: "western.sahara",
+            YEM: "^(?!.*arab)(?!.*north)(?!.*sana)(?!.*peo)(?!.*dem)(?!.*south)(?!.*aden)(?!.*\\bp\\.?d\\.?r).*yemen",
+            YMD: "^(?=.*peo).*yemen|^(?!.*rep)(?=.*dem).*yemen|^(?=.*south).*yemen|^(?=.*aden).*yemen|^(?=.*\\bp\\.?d\\.?r).*yemen",
+            YUG: "yugoslavia",
+            ZMB: "zambia|northern.?rhodesia",
+            EAZ: "zanzibar",
+            ZWE: "zimbabwe|^(?!.*northern).*rhodesia"
+          };
         }
-      },
-      _animateZoom: function(opt) {
-        var pos = this._map._latLngToNewLayerPoint(this._latlng, opt.zoom, opt.center).round();
-        this._setPos(pos);
-      },
-      _initInteraction: function() {
-        if (!this.options.interactive) {
-          return;
+      });
+      var require_cjs = __commonJS({
+        "node_modules/@turf/helpers/dist/cjs/index.cjs"(exports) {
+          Object.defineProperty(exports, "__esModule", { value: true });
+          var earthRadius = 63710088e-1;
+          var factors = {
+            centimeters: earthRadius * 100,
+            centimetres: earthRadius * 100,
+            degrees: 360 / (2 * Math.PI),
+            feet: earthRadius * 3.28084,
+            inches: earthRadius * 39.37,
+            kilometers: earthRadius / 1e3,
+            kilometres: earthRadius / 1e3,
+            meters: earthRadius,
+            metres: earthRadius,
+            miles: earthRadius / 1609.344,
+            millimeters: earthRadius * 1e3,
+            millimetres: earthRadius * 1e3,
+            nauticalmiles: earthRadius / 1852,
+            radians: 1,
+            yards: earthRadius * 1.0936
+          };
+          var areaFactors = {
+            acres: 247105e-9,
+            centimeters: 1e4,
+            centimetres: 1e4,
+            feet: 10.763910417,
+            hectares: 1e-4,
+            inches: 1550.003100006,
+            kilometers: 1e-6,
+            kilometres: 1e-6,
+            meters: 1,
+            metres: 1,
+            miles: 386e-9,
+            nauticalmiles: 29155334959812285e-23,
+            millimeters: 1e6,
+            millimetres: 1e6,
+            yards: 1.195990046
+          };
+          function feature(geom, properties, options = {}) {
+            const feat = { type: "Feature" };
+            if (options.id === 0 || options.id) {
+              feat.id = options.id;
+            }
+            if (options.bbox) {
+              feat.bbox = options.bbox;
+            }
+            feat.properties = properties || {};
+            feat.geometry = geom;
+            return feat;
+          }
+          function geometry2(type, coordinates, _options = {}) {
+            switch (type) {
+              case "Point":
+                return point(coordinates).geometry;
+              case "LineString":
+                return lineString(coordinates).geometry;
+              case "Polygon":
+                return polygon(coordinates).geometry;
+              case "MultiPoint":
+                return multiPoint(coordinates).geometry;
+              case "MultiLineString":
+                return multiLineString(coordinates).geometry;
+              case "MultiPolygon":
+                return multiPolygon(coordinates).geometry;
+              default:
+                throw new Error(type + " is invalid");
+            }
+          }
+          function point(coordinates, properties, options = {}) {
+            if (!coordinates) {
+              throw new Error("coordinates is required");
+            }
+            if (!Array.isArray(coordinates)) {
+              throw new Error("coordinates must be an Array");
+            }
+            if (coordinates.length < 2) {
+              throw new Error("coordinates must be at least 2 numbers long");
+            }
+            if (!isNumber2(coordinates[0]) || !isNumber2(coordinates[1])) {
+              throw new Error("coordinates must contain numbers");
+            }
+            const geom = {
+              type: "Point",
+              coordinates
+            };
+            return feature(geom, properties, options);
+          }
+          function points(coordinates, properties, options = {}) {
+            return featureCollection(
+              coordinates.map((coords) => {
+                return point(coords, properties);
+              }),
+              options
+            );
+          }
+          function polygon(coordinates, properties, options = {}) {
+            for (const ring of coordinates) {
+              if (ring.length < 4) {
+                throw new Error(
+                  "Each LinearRing of a Polygon must have 4 or more Positions."
+                );
+              }
+              if (ring[ring.length - 1].length !== ring[0].length) {
+                throw new Error("First and last Position are not equivalent.");
+              }
+              for (let j2 = 0; j2 < ring[ring.length - 1].length; j2++) {
+                if (ring[ring.length - 1][j2] !== ring[0][j2]) {
+                  throw new Error("First and last Position are not equivalent.");
+                }
+              }
+            }
+            const geom = {
+              type: "Polygon",
+              coordinates
+            };
+            return feature(geom, properties, options);
+          }
+          function polygons(coordinates, properties, options = {}) {
+            return featureCollection(
+              coordinates.map((coords) => {
+                return polygon(coords, properties);
+              }),
+              options
+            );
+          }
+          function lineString(coordinates, properties, options = {}) {
+            if (coordinates.length < 2) {
+              throw new Error("coordinates must be an array of two or more positions");
+            }
+            const geom = {
+              type: "LineString",
+              coordinates
+            };
+            return feature(geom, properties, options);
+          }
+          function lineStrings(coordinates, properties, options = {}) {
+            return featureCollection(
+              coordinates.map((coords) => {
+                return lineString(coords, properties);
+              }),
+              options
+            );
+          }
+          function featureCollection(features, options = {}) {
+            const fc2 = { type: "FeatureCollection" };
+            if (options.id) {
+              fc2.id = options.id;
+            }
+            if (options.bbox) {
+              fc2.bbox = options.bbox;
+            }
+            fc2.features = features;
+            return fc2;
+          }
+          function multiLineString(coordinates, properties, options = {}) {
+            const geom = {
+              type: "MultiLineString",
+              coordinates
+            };
+            return feature(geom, properties, options);
+          }
+          function multiPoint(coordinates, properties, options = {}) {
+            const geom = {
+              type: "MultiPoint",
+              coordinates
+            };
+            return feature(geom, properties, options);
+          }
+          function multiPolygon(coordinates, properties, options = {}) {
+            const geom = {
+              type: "MultiPolygon",
+              coordinates
+            };
+            return feature(geom, properties, options);
+          }
+          function geometryCollection(geometries, properties, options = {}) {
+            const geom = {
+              type: "GeometryCollection",
+              geometries
+            };
+            return feature(geom, properties, options);
+          }
+          function round2(num, precision = 0) {
+            if (precision && !(precision >= 0)) {
+              throw new Error("precision must be a positive number");
+            }
+            const multiplier = Math.pow(10, precision || 0);
+            return Math.round(num * multiplier) / multiplier;
+          }
+          function radiansToLength(radians2, units = "kilometers") {
+            const factor = factors[units];
+            if (!factor) {
+              throw new Error(units + " units is invalid");
+            }
+            return radians2 * factor;
+          }
+          function lengthToRadians(distance2, units = "kilometers") {
+            const factor = factors[units];
+            if (!factor) {
+              throw new Error(units + " units is invalid");
+            }
+            return distance2 / factor;
+          }
+          function lengthToDegrees(distance2, units) {
+            return radiansToDegrees(lengthToRadians(distance2, units));
+          }
+          function bearingToAzimuth(bearing) {
+            let angle2 = bearing % 360;
+            if (angle2 < 0) {
+              angle2 += 360;
+            }
+            return angle2;
+          }
+          function azimuthToBearing(angle2) {
+            angle2 = angle2 % 360;
+            if (angle2 > 180) {
+              return angle2 - 360;
+            } else if (angle2 < -180) {
+              return angle2 + 360;
+            }
+            return angle2;
+          }
+          function radiansToDegrees(radians2) {
+            const normalisedRadians = radians2 % (2 * Math.PI);
+            return normalisedRadians * 180 / Math.PI;
+          }
+          function degreesToRadians(degrees3) {
+            const normalisedDegrees = degrees3 % 360;
+            return normalisedDegrees * Math.PI / 180;
+          }
+          function convertLength(length2, originalUnit = "kilometers", finalUnit = "kilometers") {
+            if (!(length2 >= 0)) {
+              throw new Error("length must be a positive number");
+            }
+            return radiansToLength(lengthToRadians(length2, originalUnit), finalUnit);
+          }
+          function convertArea(area, originalUnit = "meters", finalUnit = "kilometers") {
+            if (!(area >= 0)) {
+              throw new Error("area must be a positive number");
+            }
+            const startFactor = areaFactors[originalUnit];
+            if (!startFactor) {
+              throw new Error("invalid original units");
+            }
+            const finalFactor = areaFactors[finalUnit];
+            if (!finalFactor) {
+              throw new Error("invalid final units");
+            }
+            return area / startFactor * finalFactor;
+          }
+          function isNumber2(num) {
+            return !isNaN(num) && num !== null && !Array.isArray(num);
+          }
+          function isObject2(input) {
+            return input !== null && typeof input === "object" && !Array.isArray(input);
+          }
+          function validateBBox(bbox) {
+            if (!bbox) {
+              throw new Error("bbox is required");
+            }
+            if (!Array.isArray(bbox)) {
+              throw new Error("bbox must be an Array");
+            }
+            if (bbox.length !== 4 && bbox.length !== 6) {
+              throw new Error("bbox must be an Array of 4 or 6 numbers");
+            }
+            bbox.forEach((num) => {
+              if (!isNumber2(num)) {
+                throw new Error("bbox must only contain numbers");
+              }
+            });
+          }
+          function validateId(id2) {
+            if (!id2) {
+              throw new Error("id is required");
+            }
+            if (["string", "number"].indexOf(typeof id2) === -1) {
+              throw new Error("id must be a number or a string");
+            }
+          }
+          exports.areaFactors = areaFactors;
+          exports.azimuthToBearing = azimuthToBearing;
+          exports.bearingToAzimuth = bearingToAzimuth;
+          exports.convertArea = convertArea;
+          exports.convertLength = convertLength;
+          exports.degreesToRadians = degreesToRadians;
+          exports.earthRadius = earthRadius;
+          exports.factors = factors;
+          exports.feature = feature;
+          exports.featureCollection = featureCollection;
+          exports.geometry = geometry2;
+          exports.geometryCollection = geometryCollection;
+          exports.isNumber = isNumber2;
+          exports.isObject = isObject2;
+          exports.lengthToDegrees = lengthToDegrees;
+          exports.lengthToRadians = lengthToRadians;
+          exports.lineString = lineString;
+          exports.lineStrings = lineStrings;
+          exports.multiLineString = multiLineString;
+          exports.multiPoint = multiPoint;
+          exports.multiPolygon = multiPolygon;
+          exports.point = point;
+          exports.points = points;
+          exports.polygon = polygon;
+          exports.polygons = polygons;
+          exports.radiansToDegrees = radiansToDegrees;
+          exports.radiansToLength = radiansToLength;
+          exports.round = round2;
+          exports.validateBBox = validateBBox;
+          exports.validateId = validateId;
         }
-        addClass(this._icon, "leaflet-interactive");
-        this.addInteractiveTarget(this._icon);
-        if (MarkerDrag) {
-          var draggable = this.options.draggable;
-          if (this.dragging) {
-            draggable = this.dragging.enabled();
-            this.dragging.disable();
+      });
+      var require_cjs2 = __commonJS({
+        "node_modules/@turf/meta/dist/cjs/index.cjs"(exports) {
+          Object.defineProperty(exports, "__esModule", { value: true });
+          var _helpers = require_cjs();
+          function coordEach(geojson, callback, excludeWrapCoord) {
+            if (geojson === null) return;
+            var j2, k2, l2, geometry2, stopG, coords, geometryMaybeCollection, wrapShrink = 0, coordIndex = 0, isGeometryCollection, type = geojson.type, isFeatureCollection = type === "FeatureCollection", isFeature = type === "Feature", stop = isFeatureCollection ? geojson.features.length : 1;
+            for (var featureIndex = 0; featureIndex < stop; featureIndex++) {
+              geometryMaybeCollection = isFeatureCollection ? geojson.features[featureIndex].geometry : isFeature ? geojson.geometry : geojson;
+              isGeometryCollection = geometryMaybeCollection ? geometryMaybeCollection.type === "GeometryCollection" : false;
+              stopG = isGeometryCollection ? geometryMaybeCollection.geometries.length : 1;
+              for (var geomIndex = 0; geomIndex < stopG; geomIndex++) {
+                var multiFeatureIndex = 0;
+                var geometryIndex = 0;
+                geometry2 = isGeometryCollection ? geometryMaybeCollection.geometries[geomIndex] : geometryMaybeCollection;
+                if (geometry2 === null) continue;
+                coords = geometry2.coordinates;
+                var geomType = geometry2.type;
+                wrapShrink = excludeWrapCoord && (geomType === "Polygon" || geomType === "MultiPolygon") ? 1 : 0;
+                switch (geomType) {
+                  case null:
+                    break;
+                  case "Point":
+                    if (callback(
+                      coords,
+                      coordIndex,
+                      featureIndex,
+                      multiFeatureIndex,
+                      geometryIndex
+                    ) === false)
+                      return false;
+                    coordIndex++;
+                    multiFeatureIndex++;
+                    break;
+                  case "LineString":
+                  case "MultiPoint":
+                    for (j2 = 0; j2 < coords.length; j2++) {
+                      if (callback(
+                        coords[j2],
+                        coordIndex,
+                        featureIndex,
+                        multiFeatureIndex,
+                        geometryIndex
+                      ) === false)
+                        return false;
+                      coordIndex++;
+                      if (geomType === "MultiPoint") multiFeatureIndex++;
+                    }
+                    if (geomType === "LineString") multiFeatureIndex++;
+                    break;
+                  case "Polygon":
+                  case "MultiLineString":
+                    for (j2 = 0; j2 < coords.length; j2++) {
+                      for (k2 = 0; k2 < coords[j2].length - wrapShrink; k2++) {
+                        if (callback(
+                          coords[j2][k2],
+                          coordIndex,
+                          featureIndex,
+                          multiFeatureIndex,
+                          geometryIndex
+                        ) === false)
+                          return false;
+                        coordIndex++;
+                      }
+                      if (geomType === "MultiLineString") multiFeatureIndex++;
+                      if (geomType === "Polygon") geometryIndex++;
+                    }
+                    if (geomType === "Polygon") multiFeatureIndex++;
+                    break;
+                  case "MultiPolygon":
+                    for (j2 = 0; j2 < coords.length; j2++) {
+                      geometryIndex = 0;
+                      for (k2 = 0; k2 < coords[j2].length; k2++) {
+                        for (l2 = 0; l2 < coords[j2][k2].length - wrapShrink; l2++) {
+                          if (callback(
+                            coords[j2][k2][l2],
+                            coordIndex,
+                            featureIndex,
+                            multiFeatureIndex,
+                            geometryIndex
+                          ) === false)
+                            return false;
+                          coordIndex++;
+                        }
+                        geometryIndex++;
+                      }
+                      multiFeatureIndex++;
+                    }
+                    break;
+                  case "GeometryCollection":
+                    for (j2 = 0; j2 < geometry2.geometries.length; j2++)
+                      if (coordEach(geometry2.geometries[j2], callback, excludeWrapCoord) === false)
+                        return false;
+                    break;
+                  default:
+                    throw new Error("Unknown Geometry Type");
+                }
+              }
+            }
+          }
+          function coordReduce(geojson, callback, initialValue, excludeWrapCoord) {
+            var previousValue = initialValue;
+            coordEach(
+              geojson,
+              function(currentCoord, coordIndex, featureIndex, multiFeatureIndex, geometryIndex) {
+                if (coordIndex === 0 && initialValue === void 0)
+                  previousValue = currentCoord;
+                else
+                  previousValue = callback(
+                    previousValue,
+                    currentCoord,
+                    coordIndex,
+                    featureIndex,
+                    multiFeatureIndex,
+                    geometryIndex
+                  );
+              },
+              excludeWrapCoord
+            );
+            return previousValue;
+          }
+          function propEach(geojson, callback) {
+            var i2;
+            switch (geojson.type) {
+              case "FeatureCollection":
+                for (i2 = 0; i2 < geojson.features.length; i2++) {
+                  if (callback(geojson.features[i2].properties, i2) === false) break;
+                }
+                break;
+              case "Feature":
+                callback(geojson.properties, 0);
+                break;
+            }
           }
-          this.dragging = new MarkerDrag(this);
-          if (draggable) {
-            this.dragging.enable();
+          function propReduce(geojson, callback, initialValue) {
+            var previousValue = initialValue;
+            propEach(geojson, function(currentProperties, featureIndex) {
+              if (featureIndex === 0 && initialValue === void 0)
+                previousValue = currentProperties;
+              else
+                previousValue = callback(previousValue, currentProperties, featureIndex);
+            });
+            return previousValue;
           }
-        }
-      },
-      // @method setOpacity(opacity: Number): this
-      // Changes the opacity of the marker.
-      setOpacity: function(opacity) {
-        this.options.opacity = opacity;
-        if (this._map) {
-          this._updateOpacity();
-        }
-        return this;
-      },
-      _updateOpacity: function() {
-        var opacity = this.options.opacity;
-        if (this._icon) {
-          setOpacity(this._icon, opacity);
-        }
-        if (this._shadow) {
-          setOpacity(this._shadow, opacity);
-        }
-      },
-      _bringToFront: function() {
-        this._updateZIndex(this.options.riseOffset);
-      },
-      _resetZIndex: function() {
-        this._updateZIndex(0);
-      },
-      _panOnFocus: function() {
-        var map2 = this._map;
-        if (!map2) {
-          return;
-        }
-        var iconOpts = this.options.icon.options;
-        var size = iconOpts.iconSize ? toPoint(iconOpts.iconSize) : toPoint(0, 0);
-        var anchor = iconOpts.iconAnchor ? toPoint(iconOpts.iconAnchor) : toPoint(0, 0);
-        map2.panInside(this._latlng, {
-          paddingTopLeft: anchor,
-          paddingBottomRight: size.subtract(anchor)
-        });
-      },
-      _getPopupAnchor: function() {
-        return this.options.icon.options.popupAnchor;
-      },
-      _getTooltipAnchor: function() {
-        return this.options.icon.options.tooltipAnchor;
-      }
-    });
-    function marker(latlng, options) {
-      return new Marker2(latlng, options);
-    }
-    var Path = Layer.extend({
-      // @section
-      // @aka Path options
-      options: {
-        // @option stroke: Boolean = true
-        // Whether to draw stroke along the path. Set it to `false` to disable borders on polygons or circles.
-        stroke: true,
-        // @option color: String = '#3388ff'
-        // Stroke color
-        color: "#3388ff",
-        // @option weight: Number = 3
-        // Stroke width in pixels
-        weight: 3,
-        // @option opacity: Number = 1.0
-        // Stroke opacity
-        opacity: 1,
-        // @option lineCap: String= 'round'
-        // A string that defines [shape to be used at the end](https://developer.mozilla.org/docs/Web/SVG/Attribute/stroke-linecap) of the stroke.
-        lineCap: "round",
-        // @option lineJoin: String = 'round'
-        // A string that defines [shape to be used at the corners](https://developer.mozilla.org/docs/Web/SVG/Attribute/stroke-linejoin) of the stroke.
-        lineJoin: "round",
-        // @option dashArray: String = null
-        // A string that defines the stroke [dash pattern](https://developer.mozilla.org/docs/Web/SVG/Attribute/stroke-dasharray). Doesn't work on `Canvas`-powered layers in [some old browsers](https://developer.mozilla.org/docs/Web/API/CanvasRenderingContext2D/setLineDash#Browser_compatibility).
-        dashArray: null,
-        // @option dashOffset: String = null
-        // A string that defines the [distance into the dash pattern to start the dash](https://developer.mozilla.org/docs/Web/SVG/Attribute/stroke-dashoffset). Doesn't work on `Canvas`-powered layers in [some old browsers](https://developer.mozilla.org/docs/Web/API/CanvasRenderingContext2D/setLineDash#Browser_compatibility).
-        dashOffset: null,
-        // @option fill: Boolean = depends
-        // Whether to fill the path with color. Set it to `false` to disable filling on polygons or circles.
-        fill: false,
-        // @option fillColor: String = *
-        // Fill color. Defaults to the value of the [`color`](#path-color) option
-        fillColor: null,
-        // @option fillOpacity: Number = 0.2
-        // Fill opacity.
-        fillOpacity: 0.2,
-        // @option fillRule: String = 'evenodd'
-        // A string that defines [how the inside of a shape](https://developer.mozilla.org/docs/Web/SVG/Attribute/fill-rule) is determined.
-        fillRule: "evenodd",
-        // className: '',
-        // Option inherited from "Interactive layer" abstract class
-        interactive: true,
-        // @option bubblingMouseEvents: Boolean = true
-        // When `true`, a mouse event on this path will trigger the same event on the map
-        // (unless [`L.DomEvent.stopPropagation`](#domevent-stoppropagation) is used).
-        bubblingMouseEvents: true
-      },
-      beforeAdd: function(map2) {
-        this._renderer = map2.getRenderer(this);
-      },
-      onAdd: function() {
-        this._renderer._initPath(this);
-        this._reset();
-        this._renderer._addPath(this);
-      },
-      onRemove: function() {
-        this._renderer._removePath(this);
-      },
-      // @method redraw(): this
-      // Redraws the layer. Sometimes useful after you changed the coordinates that the path uses.
-      redraw: function() {
-        if (this._map) {
-          this._renderer._updatePath(this);
-        }
-        return this;
-      },
-      // @method setStyle(style: Path options): this
-      // Changes the appearance of a Path based on the options in the `Path options` object.
-      setStyle: function(style2) {
-        setOptions2(this, style2);
-        if (this._renderer) {
-          this._renderer._updateStyle(this);
-          if (this.options.stroke && style2 && Object.prototype.hasOwnProperty.call(style2, "weight")) {
-            this._updateBounds();
+          function featureEach(geojson, callback) {
+            if (geojson.type === "Feature") {
+              callback(geojson, 0);
+            } else if (geojson.type === "FeatureCollection") {
+              for (var i2 = 0; i2 < geojson.features.length; i2++) {
+                if (callback(geojson.features[i2], i2) === false) break;
+              }
+            }
           }
+          function featureReduce(geojson, callback, initialValue) {
+            var previousValue = initialValue;
+            featureEach(geojson, function(currentFeature, featureIndex) {
+              if (featureIndex === 0 && initialValue === void 0)
+                previousValue = currentFeature;
+              else previousValue = callback(previousValue, currentFeature, featureIndex);
+            });
+            return previousValue;
+          }
+          function coordAll(geojson) {
+            var coords = [];
+            coordEach(geojson, function(coord) {
+              coords.push(coord);
+            });
+            return coords;
+          }
+          function geomEach(geojson, callback) {
+            var i2, j2, g2, geometry2, stopG, geometryMaybeCollection, isGeometryCollection, featureProperties, featureBBox, featureId, featureIndex = 0, isFeatureCollection = geojson.type === "FeatureCollection", isFeature = geojson.type === "Feature", stop = isFeatureCollection ? geojson.features.length : 1;
+            for (i2 = 0; i2 < stop; i2++) {
+              geometryMaybeCollection = isFeatureCollection ? geojson.features[i2].geometry : isFeature ? geojson.geometry : geojson;
+              featureProperties = isFeatureCollection ? geojson.features[i2].properties : isFeature ? geojson.properties : {};
+              featureBBox = isFeatureCollection ? geojson.features[i2].bbox : isFeature ? geojson.bbox : void 0;
+              featureId = isFeatureCollection ? geojson.features[i2].id : isFeature ? geojson.id : void 0;
+              isGeometryCollection = geometryMaybeCollection ? geometryMaybeCollection.type === "GeometryCollection" : false;
+              stopG = isGeometryCollection ? geometryMaybeCollection.geometries.length : 1;
+              for (g2 = 0; g2 < stopG; g2++) {
+                geometry2 = isGeometryCollection ? geometryMaybeCollection.geometries[g2] : geometryMaybeCollection;
+                if (geometry2 === null) {
+                  if (callback(
+                    null,
+                    featureIndex,
+                    featureProperties,
+                    featureBBox,
+                    featureId
+                  ) === false)
+                    return false;
+                  continue;
+                }
+                switch (geometry2.type) {
+                  case "Point":
+                  case "LineString":
+                  case "MultiPoint":
+                  case "Polygon":
+                  case "MultiLineString":
+                  case "MultiPolygon": {
+                    if (callback(
+                      geometry2,
+                      featureIndex,
+                      featureProperties,
+                      featureBBox,
+                      featureId
+                    ) === false)
+                      return false;
+                    break;
+                  }
+                  case "GeometryCollection": {
+                    for (j2 = 0; j2 < geometry2.geometries.length; j2++) {
+                      if (callback(
+                        geometry2.geometries[j2],
+                        featureIndex,
+                        featureProperties,
+                        featureBBox,
+                        featureId
+                      ) === false)
+                        return false;
+                    }
+                    break;
+                  }
+                  default:
+                    throw new Error("Unknown Geometry Type");
+                }
+              }
+              featureIndex++;
+            }
+          }
+          function geomReduce(geojson, callback, initialValue) {
+            var previousValue = initialValue;
+            geomEach(
+              geojson,
+              function(currentGeometry, featureIndex, featureProperties, featureBBox, featureId) {
+                if (featureIndex === 0 && initialValue === void 0)
+                  previousValue = currentGeometry;
+                else
+                  previousValue = callback(
+                    previousValue,
+                    currentGeometry,
+                    featureIndex,
+                    featureProperties,
+                    featureBBox,
+                    featureId
+                  );
+              }
+            );
+            return previousValue;
+          }
+          function flattenEach(geojson, callback) {
+            geomEach(geojson, function(geometry2, featureIndex, properties, bbox, id2) {
+              var type = geometry2 === null ? null : geometry2.type;
+              switch (type) {
+                case null:
+                case "Point":
+                case "LineString":
+                case "Polygon":
+                  if (callback(
+                    _helpers.feature.call(void 0, geometry2, properties, { bbox, id: id2 }),
+                    featureIndex,
+                    0
+                  ) === false)
+                    return false;
+                  return;
+              }
+              var geomType;
+              switch (type) {
+                case "MultiPoint":
+                  geomType = "Point";
+                  break;
+                case "MultiLineString":
+                  geomType = "LineString";
+                  break;
+                case "MultiPolygon":
+                  geomType = "Polygon";
+                  break;
+              }
+              for (var multiFeatureIndex = 0; multiFeatureIndex < geometry2.coordinates.length; multiFeatureIndex++) {
+                var coordinate = geometry2.coordinates[multiFeatureIndex];
+                var geom = {
+                  type: geomType,
+                  coordinates: coordinate
+                };
+                if (callback(_helpers.feature.call(void 0, geom, properties), featureIndex, multiFeatureIndex) === false)
+                  return false;
+              }
+            });
+          }
+          function flattenReduce(geojson, callback, initialValue) {
+            var previousValue = initialValue;
+            flattenEach(
+              geojson,
+              function(currentFeature, featureIndex, multiFeatureIndex) {
+                if (featureIndex === 0 && multiFeatureIndex === 0 && initialValue === void 0)
+                  previousValue = currentFeature;
+                else
+                  previousValue = callback(
+                    previousValue,
+                    currentFeature,
+                    featureIndex,
+                    multiFeatureIndex
+                  );
+              }
+            );
+            return previousValue;
+          }
+          function segmentEach(geojson, callback) {
+            flattenEach(geojson, function(feature2, featureIndex, multiFeatureIndex) {
+              var segmentIndex = 0;
+              if (!feature2.geometry) return;
+              var type = feature2.geometry.type;
+              if (type === "Point" || type === "MultiPoint") return;
+              var previousCoords;
+              var previousFeatureIndex = 0;
+              var previousMultiIndex = 0;
+              var prevGeomIndex = 0;
+              if (coordEach(
+                feature2,
+                function(currentCoord, coordIndex, featureIndexCoord, multiPartIndexCoord, geometryIndex) {
+                  if (previousCoords === void 0 || featureIndex > previousFeatureIndex || multiPartIndexCoord > previousMultiIndex || geometryIndex > prevGeomIndex) {
+                    previousCoords = currentCoord;
+                    previousFeatureIndex = featureIndex;
+                    previousMultiIndex = multiPartIndexCoord;
+                    prevGeomIndex = geometryIndex;
+                    segmentIndex = 0;
+                    return;
+                  }
+                  var currentSegment = _helpers.lineString.call(
+                    void 0,
+                    [previousCoords, currentCoord],
+                    feature2.properties
+                  );
+                  if (callback(
+                    currentSegment,
+                    featureIndex,
+                    multiFeatureIndex,
+                    geometryIndex,
+                    segmentIndex
+                  ) === false)
+                    return false;
+                  segmentIndex++;
+                  previousCoords = currentCoord;
+                }
+              ) === false)
+                return false;
+            });
+          }
+          function segmentReduce(geojson, callback, initialValue) {
+            var previousValue = initialValue;
+            var started = false;
+            segmentEach(
+              geojson,
+              function(currentSegment, featureIndex, multiFeatureIndex, geometryIndex, segmentIndex) {
+                if (started === false && initialValue === void 0)
+                  previousValue = currentSegment;
+                else
+                  previousValue = callback(
+                    previousValue,
+                    currentSegment,
+                    featureIndex,
+                    multiFeatureIndex,
+                    geometryIndex,
+                    segmentIndex
+                  );
+                started = true;
+              }
+            );
+            return previousValue;
+          }
+          function lineEach(geojson, callback) {
+            if (!geojson) throw new Error("geojson is required");
+            flattenEach(geojson, function(feature2, featureIndex, multiFeatureIndex) {
+              if (feature2.geometry === null) return;
+              var type = feature2.geometry.type;
+              var coords = feature2.geometry.coordinates;
+              switch (type) {
+                case "LineString":
+                  if (callback(feature2, featureIndex, multiFeatureIndex, 0, 0) === false)
+                    return false;
+                  break;
+                case "Polygon":
+                  for (var geometryIndex = 0; geometryIndex < coords.length; geometryIndex++) {
+                    if (callback(
+                      _helpers.lineString.call(void 0, coords[geometryIndex], feature2.properties),
+                      featureIndex,
+                      multiFeatureIndex,
+                      geometryIndex
+                    ) === false)
+                      return false;
+                  }
+                  break;
+              }
+            });
+          }
+          function lineReduce(geojson, callback, initialValue) {
+            var previousValue = initialValue;
+            lineEach(
+              geojson,
+              function(currentLine, featureIndex, multiFeatureIndex, geometryIndex) {
+                if (featureIndex === 0 && initialValue === void 0)
+                  previousValue = currentLine;
+                else
+                  previousValue = callback(
+                    previousValue,
+                    currentLine,
+                    featureIndex,
+                    multiFeatureIndex,
+                    geometryIndex
+                  );
+              }
+            );
+            return previousValue;
+          }
+          function findSegment(geojson, options) {
+            options = options || {};
+            if (!_helpers.isObject.call(void 0, options)) throw new Error("options is invalid");
+            var featureIndex = options.featureIndex || 0;
+            var multiFeatureIndex = options.multiFeatureIndex || 0;
+            var geometryIndex = options.geometryIndex || 0;
+            var segmentIndex = options.segmentIndex || 0;
+            var properties = options.properties;
+            var geometry2;
+            switch (geojson.type) {
+              case "FeatureCollection":
+                if (featureIndex < 0)
+                  featureIndex = geojson.features.length + featureIndex;
+                properties = properties || geojson.features[featureIndex].properties;
+                geometry2 = geojson.features[featureIndex].geometry;
+                break;
+              case "Feature":
+                properties = properties || geojson.properties;
+                geometry2 = geojson.geometry;
+                break;
+              case "Point":
+              case "MultiPoint":
+                return null;
+              case "LineString":
+              case "Polygon":
+              case "MultiLineString":
+              case "MultiPolygon":
+                geometry2 = geojson;
+                break;
+              default:
+                throw new Error("geojson is invalid");
+            }
+            if (geometry2 === null) return null;
+            var coords = geometry2.coordinates;
+            switch (geometry2.type) {
+              case "Point":
+              case "MultiPoint":
+                return null;
+              case "LineString":
+                if (segmentIndex < 0) segmentIndex = coords.length + segmentIndex - 1;
+                return _helpers.lineString.call(
+                  void 0,
+                  [coords[segmentIndex], coords[segmentIndex + 1]],
+                  properties,
+                  options
+                );
+              case "Polygon":
+                if (geometryIndex < 0) geometryIndex = coords.length + geometryIndex;
+                if (segmentIndex < 0)
+                  segmentIndex = coords[geometryIndex].length + segmentIndex - 1;
+                return _helpers.lineString.call(
+                  void 0,
+                  [
+                    coords[geometryIndex][segmentIndex],
+                    coords[geometryIndex][segmentIndex + 1]
+                  ],
+                  properties,
+                  options
+                );
+              case "MultiLineString":
+                if (multiFeatureIndex < 0)
+                  multiFeatureIndex = coords.length + multiFeatureIndex;
+                if (segmentIndex < 0)
+                  segmentIndex = coords[multiFeatureIndex].length + segmentIndex - 1;
+                return _helpers.lineString.call(
+                  void 0,
+                  [
+                    coords[multiFeatureIndex][segmentIndex],
+                    coords[multiFeatureIndex][segmentIndex + 1]
+                  ],
+                  properties,
+                  options
+                );
+              case "MultiPolygon":
+                if (multiFeatureIndex < 0)
+                  multiFeatureIndex = coords.length + multiFeatureIndex;
+                if (geometryIndex < 0)
+                  geometryIndex = coords[multiFeatureIndex].length + geometryIndex;
+                if (segmentIndex < 0)
+                  segmentIndex = coords[multiFeatureIndex][geometryIndex].length - segmentIndex - 1;
+                return _helpers.lineString.call(
+                  void 0,
+                  [
+                    coords[multiFeatureIndex][geometryIndex][segmentIndex],
+                    coords[multiFeatureIndex][geometryIndex][segmentIndex + 1]
+                  ],
+                  properties,
+                  options
+                );
+            }
+            throw new Error("geojson is invalid");
+          }
+          function findPoint(geojson, options) {
+            options = options || {};
+            if (!_helpers.isObject.call(void 0, options)) throw new Error("options is invalid");
+            var featureIndex = options.featureIndex || 0;
+            var multiFeatureIndex = options.multiFeatureIndex || 0;
+            var geometryIndex = options.geometryIndex || 0;
+            var coordIndex = options.coordIndex || 0;
+            var properties = options.properties;
+            var geometry2;
+            switch (geojson.type) {
+              case "FeatureCollection":
+                if (featureIndex < 0)
+                  featureIndex = geojson.features.length + featureIndex;
+                properties = properties || geojson.features[featureIndex].properties;
+                geometry2 = geojson.features[featureIndex].geometry;
+                break;
+              case "Feature":
+                properties = properties || geojson.properties;
+                geometry2 = geojson.geometry;
+                break;
+              case "Point":
+              case "MultiPoint":
+                return null;
+              case "LineString":
+              case "Polygon":
+              case "MultiLineString":
+              case "MultiPolygon":
+                geometry2 = geojson;
+                break;
+              default:
+                throw new Error("geojson is invalid");
+            }
+            if (geometry2 === null) return null;
+            var coords = geometry2.coordinates;
+            switch (geometry2.type) {
+              case "Point":
+                return _helpers.point.call(void 0, coords, properties, options);
+              case "MultiPoint":
+                if (multiFeatureIndex < 0)
+                  multiFeatureIndex = coords.length + multiFeatureIndex;
+                return _helpers.point.call(void 0, coords[multiFeatureIndex], properties, options);
+              case "LineString":
+                if (coordIndex < 0) coordIndex = coords.length + coordIndex;
+                return _helpers.point.call(void 0, coords[coordIndex], properties, options);
+              case "Polygon":
+                if (geometryIndex < 0) geometryIndex = coords.length + geometryIndex;
+                if (coordIndex < 0)
+                  coordIndex = coords[geometryIndex].length + coordIndex;
+                return _helpers.point.call(void 0, coords[geometryIndex][coordIndex], properties, options);
+              case "MultiLineString":
+                if (multiFeatureIndex < 0)
+                  multiFeatureIndex = coords.length + multiFeatureIndex;
+                if (coordIndex < 0)
+                  coordIndex = coords[multiFeatureIndex].length + coordIndex;
+                return _helpers.point.call(void 0, coords[multiFeatureIndex][coordIndex], properties, options);
+              case "MultiPolygon":
+                if (multiFeatureIndex < 0)
+                  multiFeatureIndex = coords.length + multiFeatureIndex;
+                if (geometryIndex < 0)
+                  geometryIndex = coords[multiFeatureIndex].length + geometryIndex;
+                if (coordIndex < 0)
+                  coordIndex = coords[multiFeatureIndex][geometryIndex].length - coordIndex;
+                return _helpers.point.call(
+                  void 0,
+                  coords[multiFeatureIndex][geometryIndex][coordIndex],
+                  properties,
+                  options
+                );
+            }
+            throw new Error("geojson is invalid");
+          }
+          exports.coordAll = coordAll;
+          exports.coordEach = coordEach;
+          exports.coordReduce = coordReduce;
+          exports.featureEach = featureEach;
+          exports.featureReduce = featureReduce;
+          exports.findPoint = findPoint;
+          exports.findSegment = findSegment;
+          exports.flattenEach = flattenEach;
+          exports.flattenReduce = flattenReduce;
+          exports.geomEach = geomEach;
+          exports.geomReduce = geomReduce;
+          exports.lineEach = lineEach;
+          exports.lineReduce = lineReduce;
+          exports.propEach = propEach;
+          exports.propReduce = propReduce;
+          exports.segmentEach = segmentEach;
+          exports.segmentReduce = segmentReduce;
         }
-        return this;
-      },
-      // @method bringToFront(): this
-      // Brings the layer to the top of all path layers.
-      bringToFront: function() {
-        if (this._renderer) {
-          this._renderer._bringToFront(this);
-        }
-        return this;
-      },
-      // @method bringToBack(): this
-      // Brings the layer to the bottom of all path layers.
-      bringToBack: function() {
-        if (this._renderer) {
-          this._renderer._bringToBack(this);
-        }
-        return this;
-      },
-      getElement: function() {
-        return this._path;
-      },
-      _reset: function() {
-        this._project();
-        this._update();
-      },
-      _clickTolerance: function() {
-        return (this.options.stroke ? this.options.weight / 2 : 0) + (this._renderer.options.tolerance || 0);
-      }
-    });
-    var CircleMarker = Path.extend({
-      // @section
-      // @aka CircleMarker options
-      options: {
-        fill: true,
-        // @option radius: Number = 10
-        // Radius of the circle marker, in pixels
-        radius: 10
-      },
-      initialize: function(latlng, options) {
-        setOptions2(this, options);
-        this._latlng = toLatLng(latlng);
-        this._radius = this.options.radius;
-      },
-      // @method setLatLng(latLng: LatLng): this
-      // Sets the position of a circle marker to a new location.
-      setLatLng: function(latlng) {
-        var oldLatLng = this._latlng;
-        this._latlng = toLatLng(latlng);
-        this.redraw();
-        return this.fire("move", { oldLatLng, latlng: this._latlng });
-      },
-      // @method getLatLng(): LatLng
-      // Returns the current geographical position of the circle marker
-      getLatLng: function() {
-        return this._latlng;
-      },
-      // @method setRadius(radius: Number): this
-      // Sets the radius of a circle marker. Units are in pixels.
-      setRadius: function(radius) {
-        this.options.radius = this._radius = radius;
-        return this.redraw();
-      },
-      // @method getRadius(): Number
-      // Returns the current radius of the circle
-      getRadius: function() {
-        return this._radius;
-      },
-      setStyle: function(options) {
-        var radius = options && options.radius || this._radius;
-        Path.prototype.setStyle.call(this, options);
-        this.setRadius(radius);
-        return this;
-      },
-      _project: function() {
-        this._point = this._map.latLngToLayerPoint(this._latlng);
-        this._updateBounds();
-      },
-      _updateBounds: function() {
-        var r2 = this._radius, r22 = this._radiusY || r2, w2 = this._clickTolerance(), p2 = [r2 + w2, r22 + w2];
-        this._pxBounds = new Bounds(this._point.subtract(p2), this._point.add(p2));
-      },
-      _update: function() {
-        if (this._map) {
-          this._updatePath();
-        }
-      },
-      _updatePath: function() {
-        this._renderer._updateCircle(this);
-      },
-      _empty: function() {
-        return this._radius && !this._renderer._bounds.intersects(this._pxBounds);
-      },
-      // Needed by the `Canvas` renderer for interactivity
-      _containsPoint: function(p2) {
-        return p2.distanceTo(this._point) <= this._radius + this._clickTolerance();
-      }
-    });
-    function circleMarker(latlng, options) {
-      return new CircleMarker(latlng, options);
-    }
-    var Circle = CircleMarker.extend({
-      initialize: function(latlng, options, legacyOptions) {
-        if (typeof options === "number") {
-          options = extend({}, legacyOptions, { radius: options });
-        }
-        setOptions2(this, options);
-        this._latlng = toLatLng(latlng);
-        if (isNaN(this.options.radius)) {
-          throw new Error("Circle radius cannot be NaN");
+      });
+      var require_cjs3 = __commonJS({
+        "node_modules/@turf/area/dist/cjs/index.cjs"(exports) {
+          Object.defineProperty(exports, "__esModule", { value: true });
+          var _helpers = require_cjs();
+          var _meta = require_cjs2();
+          function area(geojson) {
+            return _meta.geomReduce.call(
+              void 0,
+              geojson,
+              (value, geom) => {
+                return value + calculateArea(geom);
+              },
+              0
+            );
+          }
+          function calculateArea(geom) {
+            let total = 0;
+            let i2;
+            switch (geom.type) {
+              case "Polygon":
+                return polygonArea(geom.coordinates);
+              case "MultiPolygon":
+                for (i2 = 0; i2 < geom.coordinates.length; i2++) {
+                  total += polygonArea(geom.coordinates[i2]);
+                }
+                return total;
+              case "Point":
+              case "MultiPoint":
+              case "LineString":
+              case "MultiLineString":
+                return 0;
+            }
+            return 0;
+          }
+          function polygonArea(coords) {
+            let total = 0;
+            if (coords && coords.length > 0) {
+              total += Math.abs(ringArea(coords[0]));
+              for (let i2 = 1; i2 < coords.length; i2++) {
+                total -= Math.abs(ringArea(coords[i2]));
+              }
+            }
+            return total;
+          }
+          var FACTOR = _helpers.earthRadius * _helpers.earthRadius / 2;
+          var PI_OVER_180 = Math.PI / 180;
+          function ringArea(coords) {
+            const coordsLength = coords.length - 1;
+            if (coordsLength <= 2)
+              return 0;
+            let total = 0;
+            let i2 = 0;
+            while (i2 < coordsLength) {
+              const lower = coords[i2];
+              const middle = coords[i2 + 1 === coordsLength ? 0 : i2 + 1];
+              const upper = coords[i2 + 2 >= coordsLength ? (i2 + 2) % coordsLength : i2 + 2];
+              const lowerX = lower[0] * PI_OVER_180;
+              const middleY = middle[1] * PI_OVER_180;
+              const upperX = upper[0] * PI_OVER_180;
+              total += (upperX - lowerX) * Math.sin(middleY);
+              i2++;
+            }
+            return total * FACTOR;
+          }
+          var turf_area_default = area;
+          exports.area = area;
+          exports.default = turf_area_default;
         }
-        this._mRadius = this.options.radius;
-      },
-      // @method setRadius(radius: Number): this
-      // Sets the radius of a circle. Units are in meters.
-      setRadius: function(radius) {
-        this._mRadius = radius;
-        return this.redraw();
-      },
-      // @method getRadius(): Number
-      // Returns the current radius of a circle. Units are in meters.
-      getRadius: function() {
-        return this._mRadius;
-      },
-      // @method getBounds(): LatLngBounds
-      // Returns the `LatLngBounds` of the path.
-      getBounds: function() {
-        var half = [this._radius, this._radiusY || this._radius];
-        return new LatLngBounds(
-          this._map.layerPointToLatLng(this._point.subtract(half)),
-          this._map.layerPointToLatLng(this._point.add(half))
-        );
-      },
-      setStyle: Path.prototype.setStyle,
-      _project: function() {
-        var lng = this._latlng.lng, lat = this._latlng.lat, map2 = this._map, crs = map2.options.crs;
-        if (crs.distance === Earth.distance) {
-          var d = Math.PI / 180, latR = this._mRadius / Earth.R / d, top = map2.project([lat + latR, lng]), bottom = map2.project([lat - latR, lng]), p2 = top.add(bottom).divideBy(2), lat2 = map2.unproject(p2).lat, lngR = Math.acos((Math.cos(latR * d) - Math.sin(lat * d) * Math.sin(lat2 * d)) / (Math.cos(lat * d) * Math.cos(lat2 * d))) / d;
-          if (isNaN(lngR) || lngR === 0) {
-            lngR = latR / Math.cos(Math.PI / 180 * lat);
-          }
-          this._point = p2.subtract(map2.getPixelOrigin());
-          this._radius = isNaN(lngR) ? 0 : p2.x - map2.project([lat2, lng - lngR]).x;
-          this._radiusY = p2.y - top.y;
-        } else {
-          var latlng2 = crs.unproject(crs.project(this._latlng).subtract([this._mRadius, 0]));
-          this._point = map2.latLngToLayerPoint(this._latlng);
-          this._radius = this._point.x - map2.latLngToLayerPoint(latlng2).x;
+      });
+      var require_cjs4 = __commonJS({
+        "node_modules/@turf/centroid/dist/cjs/index.cjs"(exports) {
+          Object.defineProperty(exports, "__esModule", { value: true });
+          var _helpers = require_cjs();
+          var _meta = require_cjs2();
+          function centroid(geojson, options = {}) {
+            let xSum = 0;
+            let ySum = 0;
+            let len2 = 0;
+            _meta.coordEach.call(
+              void 0,
+              geojson,
+              function(coord) {
+                xSum += coord[0];
+                ySum += coord[1];
+                len2++;
+              },
+              true
+            );
+            return _helpers.point.call(void 0, [xSum / len2, ySum / len2], options.properties);
+          }
+          var turf_centroid_default = centroid;
+          exports.centroid = centroid;
+          exports.default = turf_centroid_default;
         }
-        this._updateBounds();
-      }
-    });
-    function circle(latlng, options, legacyOptions) {
-      return new Circle(latlng, options, legacyOptions);
-    }
-    var Polyline = Path.extend({
-      // @section
-      // @aka Polyline options
-      options: {
-        // @option smoothFactor: Number = 1.0
-        // How much to simplify the polyline on each zoom level. More means
-        // better performance and smoother look, and less means more accurate representation.
-        smoothFactor: 1,
-        // @option noClip: Boolean = false
-        // Disable polyline clipping.
-        noClip: false
-      },
-      initialize: function(latlngs, options) {
-        setOptions2(this, options);
-        this._setLatLngs(latlngs);
-      },
-      // @method getLatLngs(): LatLng[]
-      // Returns an array of the points in the path, or nested arrays of points in case of multi-polyline.
-      getLatLngs: function() {
-        return this._latlngs;
-      },
-      // @method setLatLngs(latlngs: LatLng[]): this
-      // Replaces all the points in the polyline with the given array of geographical points.
-      setLatLngs: function(latlngs) {
-        this._setLatLngs(latlngs);
-        return this.redraw();
-      },
-      // @method isEmpty(): Boolean
-      // Returns `true` if the Polyline has no LatLngs.
-      isEmpty: function() {
-        return !this._latlngs.length;
-      },
-      // @method closestLayerPoint(p: Point): Point
-      // Returns the point closest to `p` on the Polyline.
-      closestLayerPoint: function(p2) {
-        var minDistance = Infinity, minPoint = null, closest = _sqClosestPointOnSegment, p1, p22;
-        for (var j = 0, jLen = this._parts.length; j < jLen; j++) {
-          var points = this._parts[j];
-          for (var i = 1, len = points.length; i < len; i++) {
-            p1 = points[i - 1];
-            p22 = points[i];
-            var sqDist = closest(p2, p1, p22, true);
-            if (sqDist < minDistance) {
-              minDistance = sqDist;
-              minPoint = closest(p2, p1, p22);
-            }
-          }
-        }
-        if (minPoint) {
-          minPoint.distance = Math.sqrt(minDistance);
-        }
-        return minPoint;
-      },
-      // @method getCenter(): LatLng
-      // Returns the center ([centroid](https://en.wikipedia.org/wiki/Centroid)) of the polyline.
-      getCenter: function() {
-        if (!this._map) {
-          throw new Error("Must add layer to map before using getCenter()");
+      });
+      var require_cjs5 = __commonJS({
+        "node_modules/@turf/bbox/dist/cjs/index.cjs"(exports) {
+          Object.defineProperty(exports, "__esModule", { value: true });
+          var _meta = require_cjs2();
+          function bbox(geojson, options = {}) {
+            if (geojson.bbox != null && true !== options.recompute) {
+              return geojson.bbox;
+            }
+            const result = [Infinity, Infinity, -Infinity, -Infinity];
+            _meta.coordEach.call(void 0, geojson, (coord) => {
+              if (result[0] > coord[0]) {
+                result[0] = coord[0];
+              }
+              if (result[1] > coord[1]) {
+                result[1] = coord[1];
+              }
+              if (result[2] < coord[0]) {
+                result[2] = coord[0];
+              }
+              if (result[3] < coord[1]) {
+                result[3] = coord[1];
+              }
+            });
+            return result;
+          }
+          var turf_bbox_default = bbox;
+          exports.bbox = bbox;
+          exports.default = turf_bbox_default;
         }
-        return polylineCenter(this._defaultShape(), this._map.options.crs);
-      },
-      // @method getBounds(): LatLngBounds
-      // Returns the `LatLngBounds` of the path.
-      getBounds: function() {
-        return this._bounds;
-      },
-      // @method addLatLng(latlng: LatLng, latlngs?: LatLng[]): this
-      // Adds a given point to the polyline. By default, adds to the first ring of
-      // the polyline in case of a multi-polyline, but can be overridden by passing
-      // a specific ring as a LatLng array (that you can earlier access with [`getLatLngs`](#polyline-getlatlngs)).
-      addLatLng: function(latlng, latlngs) {
-        latlngs = latlngs || this._defaultShape();
-        latlng = toLatLng(latlng);
-        latlngs.push(latlng);
-        this._bounds.extend(latlng);
-        return this.redraw();
-      },
-      _setLatLngs: function(latlngs) {
-        this._bounds = new LatLngBounds();
-        this._latlngs = this._convertLatLngs(latlngs);
-      },
-      _defaultShape: function() {
-        return isFlat(this._latlngs) ? this._latlngs : this._latlngs[0];
-      },
-      // recursively convert latlngs input into actual LatLng instances; calculate bounds along the way
-      _convertLatLngs: function(latlngs) {
-        var result = [], flat = isFlat(latlngs);
-        for (var i = 0, len = latlngs.length; i < len; i++) {
-          if (flat) {
-            result[i] = toLatLng(latlngs[i]);
-            this._bounds.extend(result[i]);
-          } else {
-            result[i] = this._convertLatLngs(latlngs[i]);
+      });
+      var require_geo_location_utils = __commonJS({
+        "src/lib/geo_location_utils.js"(exports, module2) {
+          var d3 = require_d3();
+          var countryRegex = require_country_regex();
+          var { area: turfArea } = require_cjs3();
+          var { centroid: turfCentroid } = require_cjs4();
+          var { bbox: turfBbox } = require_cjs5();
+          var identity22 = require_identity2();
+          var loggers2 = require_loggers();
+          var isPlainObject2 = require_is_plain_object();
+          var nestedProperty = require_nested_property();
+          var polygon = require_polygon();
+          var countryIds = Object.keys(countryRegex);
+          var locationmodeToIdFinder = {
+            "ISO-3": identity22,
+            "USA-states": identity22,
+            "country names": countryNameToISO3
+          };
+          function countryNameToISO3(countryName) {
+            for (var i2 = 0; i2 < countryIds.length; i2++) {
+              var iso3 = countryIds[i2];
+              var regex = new RegExp(countryRegex[iso3]);
+              if (regex.test(countryName.trim().toLowerCase())) return iso3;
+            }
+            loggers2.log("Unrecognized country name: " + countryName + ".");
+            return false;
+          }
+          function locationToFeature(locationmode, location2, features) {
+            if (!location2 || typeof location2 !== "string") return false;
+            var locationId = locationmodeToIdFinder[locationmode](location2);
+            var filteredFeatures;
+            var f2, i2;
+            if (locationId) {
+              if (locationmode === "USA-states") {
+                filteredFeatures = [];
+                for (i2 = 0; i2 < features.length; i2++) {
+                  f2 = features[i2];
+                  if (f2.properties && f2.properties.gu && f2.properties.gu === "USA") {
+                    filteredFeatures.push(f2);
+                  }
+                }
+              } else {
+                filteredFeatures = features;
+              }
+              for (i2 = 0; i2 < filteredFeatures.length; i2++) {
+                f2 = filteredFeatures[i2];
+                if (f2.id === locationId) return f2;
+              }
+              loggers2.log([
+                "Location with id",
+                locationId,
+                "does not have a matching topojson feature at this resolution."
+              ].join(" "));
+            }
+            return false;
+          }
+          function feature2polygons(feature) {
+            var geometry2 = feature.geometry;
+            var coords = geometry2.coordinates;
+            var loc = feature.id;
+            var polygons = [];
+            var appendPolygon, j2, k2, m2;
+            function doesCrossAntiMerdian(pts) {
+              for (var l2 = 0; l2 < pts.length - 1; l2++) {
+                if (pts[l2][0] > 0 && pts[l2 + 1][0] < 0) return l2;
+              }
+              return null;
+            }
+            if (loc === "RUS" || loc === "FJI") {
+              appendPolygon = function(_pts) {
+                var pts;
+                if (doesCrossAntiMerdian(_pts) === null) {
+                  pts = _pts;
+                } else {
+                  pts = new Array(_pts.length);
+                  for (m2 = 0; m2 < _pts.length; m2++) {
+                    pts[m2] = [
+                      _pts[m2][0] < 0 ? _pts[m2][0] + 360 : _pts[m2][0],
+                      _pts[m2][1]
+                    ];
+                  }
+                }
+                polygons.push(polygon.tester(pts));
+              };
+            } else if (loc === "ATA") {
+              appendPolygon = function(pts) {
+                var crossAntiMeridianIndex = doesCrossAntiMerdian(pts);
+                if (crossAntiMeridianIndex === null) {
+                  return polygons.push(polygon.tester(pts));
+                }
+                var stitch = new Array(pts.length + 1);
+                var si2 = 0;
+                for (m2 = 0; m2 < pts.length; m2++) {
+                  if (m2 > crossAntiMeridianIndex) {
+                    stitch[si2++] = [pts[m2][0] + 360, pts[m2][1]];
+                  } else if (m2 === crossAntiMeridianIndex) {
+                    stitch[si2++] = pts[m2];
+                    stitch[si2++] = [pts[m2][0], -90];
+                  } else {
+                    stitch[si2++] = pts[m2];
+                  }
+                }
+                var tester = polygon.tester(stitch);
+                tester.pts.pop();
+                polygons.push(tester);
+              };
+            } else {
+              appendPolygon = function(pts) {
+                polygons.push(polygon.tester(pts));
+              };
+            }
+            switch (geometry2.type) {
+              case "MultiPolygon":
+                for (j2 = 0; j2 < coords.length; j2++) {
+                  for (k2 = 0; k2 < coords[j2].length; k2++) {
+                    appendPolygon(coords[j2][k2]);
+                  }
+                }
+                break;
+              case "Polygon":
+                for (j2 = 0; j2 < coords.length; j2++) {
+                  appendPolygon(coords[j2]);
+                }
+                break;
+            }
+            return polygons;
+          }
+          function getTraceGeojson(trace) {
+            var g2 = trace.geojson;
+            var PlotlyGeoAssets2 = window.PlotlyGeoAssets || {};
+            var geojsonIn = typeof g2 === "string" ? PlotlyGeoAssets2[g2] : g2;
+            if (!isPlainObject2(geojsonIn)) {
+              loggers2.error("Oops ... something went wrong when fetching " + g2);
+              return false;
+            }
+            return geojsonIn;
+          }
+          function extractTraceFeature(calcTrace) {
+            var trace = calcTrace[0].trace;
+            var geojsonIn = getTraceGeojson(trace);
+            if (!geojsonIn) return false;
+            var lookup = {};
+            var featuresOut = [];
+            var i2;
+            for (i2 = 0; i2 < trace._length; i2++) {
+              var cdi = calcTrace[i2];
+              if (cdi.loc || cdi.loc === 0) {
+                lookup[cdi.loc] = cdi;
+              }
+            }
+            function appendFeature(fIn) {
+              var id2 = nestedProperty(fIn, trace.featureidkey || "id").get();
+              var cdi2 = lookup[id2];
+              if (cdi2) {
+                var geometry2 = fIn.geometry;
+                if (geometry2.type === "Polygon" || geometry2.type === "MultiPolygon") {
+                  var fOut = {
+                    type: "Feature",
+                    id: id2,
+                    geometry: geometry2,
+                    properties: {}
+                  };
+                  if (fOut.geometry.coordinates.length > 0) {
+                    fOut.properties.ct = findCentroid(fOut);
+                  } else {
+                    fOut.properties.ct = [NaN, NaN];
+                  }
+                  cdi2.fIn = fIn;
+                  cdi2.fOut = fOut;
+                  featuresOut.push(fOut);
+                } else {
+                  loggers2.log([
+                    "Location",
+                    cdi2.loc,
+                    "does not have a valid GeoJSON geometry.",
+                    "Traces with locationmode *geojson-id* only support",
+                    "*Polygon* and *MultiPolygon* geometries."
+                  ].join(" "));
+                }
+              }
+              delete lookup[id2];
+            }
+            switch (geojsonIn.type) {
+              case "FeatureCollection":
+                var featuresIn = geojsonIn.features;
+                for (i2 = 0; i2 < featuresIn.length; i2++) {
+                  appendFeature(featuresIn[i2]);
+                }
+                break;
+              case "Feature":
+                appendFeature(geojsonIn);
+                break;
+              default:
+                loggers2.warn([
+                  "Invalid GeoJSON type",
+                  (geojsonIn.type || "none") + ".",
+                  "Traces with locationmode *geojson-id* only support",
+                  "*FeatureCollection* and *Feature* types."
+                ].join(" "));
+                return false;
+            }
+            for (var loc in lookup) {
+              loggers2.log([
+                "Location *" + loc + "*",
+                "does not have a matching feature with id-key",
+                "*" + trace.featureidkey + "*."
+              ].join(" "));
+            }
+            return featuresOut;
+          }
+          function findCentroid(feature) {
+            var geometry2 = feature.geometry;
+            var poly;
+            if (geometry2.type === "MultiPolygon") {
+              var coords = geometry2.coordinates;
+              var maxArea = 0;
+              for (var i2 = 0; i2 < coords.length; i2++) {
+                var polyi = { type: "Polygon", coordinates: coords[i2] };
+                var area = turfArea(polyi);
+                if (area > maxArea) {
+                  maxArea = area;
+                  poly = polyi;
+                }
+              }
+            } else {
+              poly = geometry2;
+            }
+            return turfCentroid(poly).geometry.coordinates;
+          }
+          function fetchTraceGeoData(calcData) {
+            var PlotlyGeoAssets2 = window.PlotlyGeoAssets || {};
+            var promises = [];
+            function fetch2(url2) {
+              return new Promise(function(resolve, reject) {
+                d3.json(url2, function(err, d2) {
+                  if (err) {
+                    delete PlotlyGeoAssets2[url2];
+                    var msg = err.status === 404 ? 'GeoJSON at URL "' + url2 + '" does not exist.' : "Unexpected error while fetching from " + url2;
+                    return reject(new Error(msg));
+                  }
+                  PlotlyGeoAssets2[url2] = d2;
+                  return resolve(d2);
+                });
+              });
+            }
+            function wait(url2) {
+              return new Promise(function(resolve, reject) {
+                var cnt = 0;
+                var interval = setInterval(function() {
+                  if (PlotlyGeoAssets2[url2] && PlotlyGeoAssets2[url2] !== "pending") {
+                    clearInterval(interval);
+                    return resolve(PlotlyGeoAssets2[url2]);
+                  }
+                  if (cnt > 100) {
+                    clearInterval(interval);
+                    return reject("Unexpected error while fetching from " + url2);
+                  }
+                  cnt++;
+                }, 50);
+              });
+            }
+            for (var i2 = 0; i2 < calcData.length; i2++) {
+              var trace = calcData[i2][0].trace;
+              var url = trace.geojson;
+              if (typeof url === "string") {
+                if (!PlotlyGeoAssets2[url]) {
+                  PlotlyGeoAssets2[url] = "pending";
+                  promises.push(fetch2(url));
+                } else if (PlotlyGeoAssets2[url] === "pending") {
+                  promises.push(wait(url));
+                }
+              }
+            }
+            return promises;
+          }
+          function computeBbox(d2) {
+            return turfBbox(d2);
           }
+          module2.exports = {
+            locationToFeature,
+            feature2polygons,
+            getTraceGeojson,
+            extractTraceFeature,
+            fetchTraceGeoData,
+            computeBbox
+          };
         }
-        return result;
-      },
-      _project: function() {
-        var pxBounds = new Bounds();
-        this._rings = [];
-        this._projectLatlngs(this._latlngs, this._rings, pxBounds);
-        if (this._bounds.isValid() && pxBounds.isValid()) {
-          this._rawPxBounds = pxBounds;
-          this._updateBounds();
+      });
+      var require_style17 = __commonJS({
+        "src/traces/scattergeo/style.js"(exports, module2) {
+          var d3 = require_d3();
+          var Drawing = require_drawing();
+          var Color2 = require_color();
+          var scatterStyle = require_style2();
+          var stylePoints = scatterStyle.stylePoints;
+          var styleText = scatterStyle.styleText;
+          module2.exports = function style(gd2, calcTrace) {
+            if (calcTrace) styleTrace(gd2, calcTrace);
+          };
+          function styleTrace(gd2, calcTrace) {
+            var trace = calcTrace[0].trace;
+            var s2 = calcTrace[0].node3;
+            s2.style("opacity", calcTrace[0].trace.opacity);
+            stylePoints(s2, trace, gd2);
+            styleText(s2, trace, gd2);
+            s2.selectAll("path.js-line").style("fill", "none").each(function(d2) {
+              var path = d3.select(this);
+              var trace2 = d2.trace;
+              var line = trace2.line || {};
+              path.call(Color2.stroke, line.color).call(Drawing.dashLine, line.dash || "", line.width || 0);
+              if (trace2.fill !== "none") {
+                path.call(Color2.fill, trace2.fillcolor);
+              }
+            });
+          }
         }
-      },
-      _updateBounds: function() {
-        var w2 = this._clickTolerance(), p2 = new Point(w2, w2);
-        if (!this._rawPxBounds) {
-          return;
+      });
+      var require_plot17 = __commonJS({
+        "src/traces/scattergeo/plot.js"(exports, module2) {
+          var d3 = require_d3();
+          var Lib = require_lib();
+          var getTopojsonFeatures = require_topojson_utils().getTopojsonFeatures;
+          var geoJsonUtils = require_geojson_utils();
+          var geoUtils = require_geo_location_utils();
+          var findExtremes = require_autorange().findExtremes;
+          var BADNUM = require_numerical().BADNUM;
+          var calcMarkerSize = require_calc3().calcMarkerSize;
+          var subTypes = require_subtypes();
+          var style = require_style17();
+          function plot(gd2, geo, calcData) {
+            var scatterLayer = geo.layers.frontplot.select(".scatterlayer");
+            var gTraces = Lib.makeTraceGroups(scatterLayer, calcData, "trace scattergeo");
+            function removeBADNUM(d2, node) {
+              if (d2.lonlat[0] === BADNUM) {
+                d3.select(node).remove();
+              }
+            }
+            gTraces.selectAll("*").remove();
+            gTraces.each(function(calcTrace) {
+              var s2 = d3.select(this);
+              var trace = calcTrace[0].trace;
+              if (subTypes.hasLines(trace) || trace.fill !== "none") {
+                var lineCoords = geoJsonUtils.calcTraceToLineCoords(calcTrace);
+                var lineData = trace.fill !== "none" ? geoJsonUtils.makePolygon(lineCoords) : geoJsonUtils.makeLine(lineCoords);
+                s2.selectAll("path.js-line").data([{ geojson: lineData, trace }]).enter().append("path").classed("js-line", true).style("stroke-miterlimit", 2);
+              }
+              if (subTypes.hasMarkers(trace)) {
+                s2.selectAll("path.point").data(Lib.identity).enter().append("path").classed("point", true).each(function(calcPt) {
+                  removeBADNUM(calcPt, this);
+                });
+              }
+              if (subTypes.hasText(trace)) {
+                s2.selectAll("g").data(Lib.identity).enter().append("g").append("text").each(function(calcPt) {
+                  removeBADNUM(calcPt, this);
+                });
+              }
+              style(gd2, calcTrace);
+            });
+          }
+          function calcGeoJSON(calcTrace, fullLayout) {
+            var trace = calcTrace[0].trace;
+            var geoLayout = fullLayout[trace.geo];
+            var geo = geoLayout._subplot;
+            var len2 = trace._length;
+            var i2, calcPt;
+            if (Lib.isArrayOrTypedArray(trace.locations)) {
+              var locationmode = trace.locationmode;
+              var features = locationmode === "geojson-id" ? geoUtils.extractTraceFeature(calcTrace) : getTopojsonFeatures(trace, geo.topojson);
+              for (i2 = 0; i2 < len2; i2++) {
+                calcPt = calcTrace[i2];
+                var feature = locationmode === "geojson-id" ? calcPt.fOut : geoUtils.locationToFeature(locationmode, calcPt.loc, features);
+                calcPt.lonlat = feature ? feature.properties.ct : [BADNUM, BADNUM];
+              }
+            }
+            var opts = { padded: true };
+            var lonArray;
+            var latArray;
+            if (geoLayout.fitbounds === "geojson" && trace.locationmode === "geojson-id") {
+              var bboxGeojson = geoUtils.computeBbox(geoUtils.getTraceGeojson(trace));
+              lonArray = [bboxGeojson[0], bboxGeojson[2]];
+              latArray = [bboxGeojson[1], bboxGeojson[3]];
+            } else {
+              lonArray = new Array(len2);
+              latArray = new Array(len2);
+              for (i2 = 0; i2 < len2; i2++) {
+                calcPt = calcTrace[i2];
+                lonArray[i2] = calcPt.lonlat[0];
+                latArray[i2] = calcPt.lonlat[1];
+              }
+              opts.ppad = calcMarkerSize(trace, len2);
+            }
+            trace._extremes.lon = findExtremes(geoLayout.lonaxis._ax, lonArray, opts);
+            trace._extremes.lat = findExtremes(geoLayout.lataxis._ax, latArray, opts);
+          }
+          module2.exports = {
+            calcGeoJSON,
+            plot
+          };
         }
-        this._pxBounds = new Bounds([
-          this._rawPxBounds.min.subtract(p2),
-          this._rawPxBounds.max.add(p2)
-        ]);
-      },
-      // recursively turns latlngs into a set of rings with projected coordinates
-      _projectLatlngs: function(latlngs, result, projectedBounds) {
-        var flat = latlngs[0] instanceof LatLng, len = latlngs.length, i, ring;
-        if (flat) {
-          ring = [];
-          for (i = 0; i < len; i++) {
-            ring[i] = this._map.latLngToLayerPoint(latlngs[i]);
-            projectedBounds.extend(ring[i]);
-          }
-          result.push(ring);
-        } else {
-          for (i = 0; i < len; i++) {
-            this._projectLatlngs(latlngs[i], result, projectedBounds);
+      });
+      var require_hover14 = __commonJS({
+        "src/traces/scattergeo/hover.js"(exports, module2) {
+          var Fx = require_fx();
+          var BADNUM = require_numerical().BADNUM;
+          var getTraceColor = require_get_trace_color();
+          var fillText = require_lib().fillText;
+          var attributes = require_attributes48();
+          module2.exports = function hoverPoints(pointData, xval, yval) {
+            var cd2 = pointData.cd;
+            var trace = cd2[0].trace;
+            var xa = pointData.xa;
+            var ya2 = pointData.ya;
+            var geo = pointData.subplot;
+            var isLonLatOverEdges = geo.projection.isLonLatOverEdges;
+            var project2 = geo.project;
+            function distFn(d2) {
+              var lonlat2 = d2.lonlat;
+              if (lonlat2[0] === BADNUM) return Infinity;
+              if (isLonLatOverEdges(lonlat2)) return Infinity;
+              var pt2 = project2(lonlat2);
+              var px = project2([xval, yval]);
+              var dx = Math.abs(pt2[0] - px[0]);
+              var dy = Math.abs(pt2[1] - px[1]);
+              var rad2 = Math.max(3, d2.mrc || 0);
+              return Math.max(Math.sqrt(dx * dx + dy * dy) - rad2, 1 - 3 / rad2);
+            }
+            Fx.getClosest(cd2, distFn, pointData);
+            if (pointData.index === false) return;
+            var di2 = cd2[pointData.index];
+            var lonlat = di2.lonlat;
+            var pos = [xa.c2p(lonlat), ya2.c2p(lonlat)];
+            var rad = di2.mrc || 1;
+            pointData.x0 = pos[0] - rad;
+            pointData.x1 = pos[0] + rad;
+            pointData.y0 = pos[1] - rad;
+            pointData.y1 = pos[1] + rad;
+            pointData.loc = di2.loc;
+            pointData.lon = lonlat[0];
+            pointData.lat = lonlat[1];
+            var fullLayout = {};
+            fullLayout[trace.geo] = { _subplot: geo };
+            var labels = trace._module.formatLabels(di2, trace, fullLayout);
+            pointData.lonLabel = labels.lonLabel;
+            pointData.latLabel = labels.latLabel;
+            pointData.color = getTraceColor(trace, di2);
+            pointData.extraText = getExtraText(trace, di2, pointData, cd2[0].t.labels);
+            pointData.hovertemplate = trace.hovertemplate;
+            return [pointData];
+          };
+          function getExtraText(trace, pt2, pointData, labels) {
+            if (trace.hovertemplate) return;
+            var hoverinfo = pt2.hi || trace.hoverinfo;
+            var parts = hoverinfo === "all" ? attributes.hoverinfo.flags : hoverinfo.split("+");
+            var hasLocation = parts.indexOf("location") !== -1 && Array.isArray(trace.locations);
+            var hasLon = parts.indexOf("lon") !== -1;
+            var hasLat = parts.indexOf("lat") !== -1;
+            var hasText = parts.indexOf("text") !== -1;
+            var text = [];
+            function format(val) {
+              return val + "°";
+            }
+            if (hasLocation) {
+              text.push(pt2.loc);
+            } else if (hasLon && hasLat) {
+              text.push("(" + format(pointData.latLabel) + ", " + format(pointData.lonLabel) + ")");
+            } else if (hasLon) {
+              text.push(labels.lon + format(pointData.lonLabel));
+            } else if (hasLat) {
+              text.push(labels.lat + format(pointData.latLabel));
+            }
+            if (hasText) {
+              fillText(pt2, trace, text);
+            }
+            return text.join("<br>");
           }
         }
-      },
-      // clip polyline by renderer bounds so that we have less to render for performance
-      _clipPoints: function() {
-        var bounds = this._renderer._bounds;
-        this._parts = [];
-        if (!this._pxBounds || !this._pxBounds.intersects(bounds)) {
-          return;
+      });
+      var require_event_data9 = __commonJS({
+        "src/traces/scattergeo/event_data.js"(exports, module2) {
+          module2.exports = function eventData(out, pt2, trace, cd2, pointNumber) {
+            out.lon = pt2.lon;
+            out.lat = pt2.lat;
+            out.location = pt2.loc ? pt2.loc : null;
+            var cdi = cd2[pointNumber];
+            if (cdi.fIn && cdi.fIn.properties) {
+              out.properties = cdi.fIn.properties;
+            }
+            return out;
+          };
         }
-        if (this.options.noClip) {
-          this._parts = this._rings;
-          return;
+      });
+      var require_select5 = __commonJS({
+        "src/traces/scattergeo/select.js"(exports, module2) {
+          var subtypes = require_subtypes();
+          var BADNUM = require_numerical().BADNUM;
+          module2.exports = function selectPoints(searchInfo, selectionTester) {
+            var cd2 = searchInfo.cd;
+            var xa = searchInfo.xaxis;
+            var ya2 = searchInfo.yaxis;
+            var selection = [];
+            var trace = cd2[0].trace;
+            var di2, lonlat, x2, y2, i2;
+            var hasOnlyLines = !subtypes.hasMarkers(trace) && !subtypes.hasText(trace);
+            if (hasOnlyLines) return [];
+            if (selectionTester === false) {
+              for (i2 = 0; i2 < cd2.length; i2++) {
+                cd2[i2].selected = 0;
+              }
+            } else {
+              for (i2 = 0; i2 < cd2.length; i2++) {
+                di2 = cd2[i2];
+                lonlat = di2.lonlat;
+                if (lonlat[0] === BADNUM) continue;
+                x2 = xa.c2p(lonlat);
+                y2 = ya2.c2p(lonlat);
+                if (selectionTester.contains([x2, y2], null, i2, searchInfo)) {
+                  selection.push({
+                    pointNumber: i2,
+                    lon: lonlat[0],
+                    lat: lonlat[1]
+                  });
+                  di2.selected = 1;
+                } else {
+                  di2.selected = 0;
+                }
+              }
+            }
+            return selection;
+          };
         }
-        var parts = this._parts, i, j, k2, len, len2, segment, points;
-        for (i = 0, k2 = 0, len = this._rings.length; i < len; i++) {
-          points = this._rings[i];
-          for (j = 0, len2 = points.length; j < len2 - 1; j++) {
-            segment = clipSegment(points[j], points[j + 1], bounds, j, true);
-            if (!segment) {
-              continue;
+      });
+      var require_d3_array = __commonJS({
+        "node_modules/d3-array/dist/d3-array.js"(exports, module2) {
+          (function(global2, factory2) {
+            typeof exports === "object" && typeof module2 !== "undefined" ? factory2(exports) : factory2(global2.d3 = global2.d3 || {});
+          })(exports, function(exports2) {
+            function ascending(a2, b2) {
+              return a2 < b2 ? -1 : a2 > b2 ? 1 : a2 >= b2 ? 0 : NaN;
+            }
+            function bisector(compare) {
+              if (compare.length === 1) compare = ascendingComparator(compare);
+              return {
+                left: function(a2, x2, lo, hi2) {
+                  if (lo == null) lo = 0;
+                  if (hi2 == null) hi2 = a2.length;
+                  while (lo < hi2) {
+                    var mid = lo + hi2 >>> 1;
+                    if (compare(a2[mid], x2) < 0) lo = mid + 1;
+                    else hi2 = mid;
+                  }
+                  return lo;
+                },
+                right: function(a2, x2, lo, hi2) {
+                  if (lo == null) lo = 0;
+                  if (hi2 == null) hi2 = a2.length;
+                  while (lo < hi2) {
+                    var mid = lo + hi2 >>> 1;
+                    if (compare(a2[mid], x2) > 0) hi2 = mid;
+                    else lo = mid + 1;
+                  }
+                  return lo;
+                }
+              };
+            }
+            function ascendingComparator(f2) {
+              return function(d2, x2) {
+                return ascending(f2(d2), x2);
+              };
+            }
+            var ascendingBisect = bisector(ascending);
+            var bisectRight = ascendingBisect.right;
+            var bisectLeft = ascendingBisect.left;
+            function pairs(array2, f2) {
+              if (f2 == null) f2 = pair;
+              var i2 = 0, n2 = array2.length - 1, p2 = array2[0], pairs2 = new Array(n2 < 0 ? 0 : n2);
+              while (i2 < n2) pairs2[i2] = f2(p2, p2 = array2[++i2]);
+              return pairs2;
+            }
+            function pair(a2, b2) {
+              return [a2, b2];
+            }
+            function cross2(values0, values1, reduce) {
+              var n0 = values0.length, n1 = values1.length, values = new Array(n0 * n1), i0, i1, i2, value0;
+              if (reduce == null) reduce = pair;
+              for (i0 = i2 = 0; i0 < n0; ++i0) {
+                for (value0 = values0[i0], i1 = 0; i1 < n1; ++i1, ++i2) {
+                  values[i2] = reduce(value0, values1[i1]);
+                }
+              }
+              return values;
+            }
+            function descending(a2, b2) {
+              return b2 < a2 ? -1 : b2 > a2 ? 1 : b2 >= a2 ? 0 : NaN;
+            }
+            function number(x2) {
+              return x2 === null ? NaN : +x2;
+            }
+            function variance(values, valueof) {
+              var n2 = values.length, m2 = 0, i2 = -1, mean2 = 0, value, delta, sum2 = 0;
+              if (valueof == null) {
+                while (++i2 < n2) {
+                  if (!isNaN(value = number(values[i2]))) {
+                    delta = value - mean2;
+                    mean2 += delta / ++m2;
+                    sum2 += delta * (value - mean2);
+                  }
+                }
+              } else {
+                while (++i2 < n2) {
+                  if (!isNaN(value = number(valueof(values[i2], i2, values)))) {
+                    delta = value - mean2;
+                    mean2 += delta / ++m2;
+                    sum2 += delta * (value - mean2);
+                  }
+                }
+              }
+              if (m2 > 1) return sum2 / (m2 - 1);
+            }
+            function deviation(array2, f2) {
+              var v2 = variance(array2, f2);
+              return v2 ? Math.sqrt(v2) : v2;
+            }
+            function extent(values, valueof) {
+              var n2 = values.length, i2 = -1, value, min2, max2;
+              if (valueof == null) {
+                while (++i2 < n2) {
+                  if ((value = values[i2]) != null && value >= value) {
+                    min2 = max2 = value;
+                    while (++i2 < n2) {
+                      if ((value = values[i2]) != null) {
+                        if (min2 > value) min2 = value;
+                        if (max2 < value) max2 = value;
+                      }
+                    }
+                  }
+                }
+              } else {
+                while (++i2 < n2) {
+                  if ((value = valueof(values[i2], i2, values)) != null && value >= value) {
+                    min2 = max2 = value;
+                    while (++i2 < n2) {
+                      if ((value = valueof(values[i2], i2, values)) != null) {
+                        if (min2 > value) min2 = value;
+                        if (max2 < value) max2 = value;
+                      }
+                    }
+                  }
+                }
+              }
+              return [min2, max2];
+            }
+            var array = Array.prototype;
+            var slice = array.slice;
+            var map2 = array.map;
+            function constant(x2) {
+              return function() {
+                return x2;
+              };
+            }
+            function identity22(x2) {
+              return x2;
+            }
+            function range(start, stop, step) {
+              start = +start, stop = +stop, step = (n2 = arguments.length) < 2 ? (stop = start, start = 0, 1) : n2 < 3 ? 1 : +step;
+              var i2 = -1, n2 = Math.max(0, Math.ceil((stop - start) / step)) | 0, range2 = new Array(n2);
+              while (++i2 < n2) {
+                range2[i2] = start + i2 * step;
+              }
+              return range2;
+            }
+            var e10 = Math.sqrt(50), e5 = Math.sqrt(10), e2 = Math.sqrt(2);
+            function ticks(start, stop, count2) {
+              var reverse, i2 = -1, n2, ticks2, step;
+              stop = +stop, start = +start, count2 = +count2;
+              if (start === stop && count2 > 0) return [start];
+              if (reverse = stop < start) n2 = start, start = stop, stop = n2;
+              if ((step = tickIncrement(start, stop, count2)) === 0 || !isFinite(step)) return [];
+              if (step > 0) {
+                start = Math.ceil(start / step);
+                stop = Math.floor(stop / step);
+                ticks2 = new Array(n2 = Math.ceil(stop - start + 1));
+                while (++i2 < n2) ticks2[i2] = (start + i2) * step;
+              } else {
+                start = Math.floor(start * step);
+                stop = Math.ceil(stop * step);
+                ticks2 = new Array(n2 = Math.ceil(start - stop + 1));
+                while (++i2 < n2) ticks2[i2] = (start - i2) / step;
+              }
+              if (reverse) ticks2.reverse();
+              return ticks2;
+            }
+            function tickIncrement(start, stop, count2) {
+              var step = (stop - start) / Math.max(0, count2), power = Math.floor(Math.log(step) / Math.LN10), error = step / Math.pow(10, power);
+              return power >= 0 ? (error >= e10 ? 10 : error >= e5 ? 5 : error >= e2 ? 2 : 1) * Math.pow(10, power) : -Math.pow(10, -power) / (error >= e10 ? 10 : error >= e5 ? 5 : error >= e2 ? 2 : 1);
+            }
+            function tickStep(start, stop, count2) {
+              var step0 = Math.abs(stop - start) / Math.max(0, count2), step1 = Math.pow(10, Math.floor(Math.log(step0) / Math.LN10)), error = step0 / step1;
+              if (error >= e10) step1 *= 10;
+              else if (error >= e5) step1 *= 5;
+              else if (error >= e2) step1 *= 2;
+              return stop < start ? -step1 : step1;
+            }
+            function sturges(values) {
+              return Math.ceil(Math.log(values.length) / Math.LN2) + 1;
+            }
+            function histogram() {
+              var value = identity22, domain = extent, threshold = sturges;
+              function histogram2(data) {
+                var i2, n2 = data.length, x2, values = new Array(n2);
+                for (i2 = 0; i2 < n2; ++i2) {
+                  values[i2] = value(data[i2], i2, data);
+                }
+                var xz = domain(values), x0 = xz[0], x1 = xz[1], tz = threshold(values, x0, x1);
+                if (!Array.isArray(tz)) {
+                  tz = tickStep(x0, x1, tz);
+                  tz = range(Math.ceil(x0 / tz) * tz, x1, tz);
+                }
+                var m2 = tz.length;
+                while (tz[0] <= x0) tz.shift(), --m2;
+                while (tz[m2 - 1] > x1) tz.pop(), --m2;
+                var bins = new Array(m2 + 1), bin;
+                for (i2 = 0; i2 <= m2; ++i2) {
+                  bin = bins[i2] = [];
+                  bin.x0 = i2 > 0 ? tz[i2 - 1] : x0;
+                  bin.x1 = i2 < m2 ? tz[i2] : x1;
+                }
+                for (i2 = 0; i2 < n2; ++i2) {
+                  x2 = values[i2];
+                  if (x0 <= x2 && x2 <= x1) {
+                    bins[bisectRight(tz, x2, 0, m2)].push(data[i2]);
+                  }
+                }
+                return bins;
+              }
+              histogram2.value = function(_2) {
+                return arguments.length ? (value = typeof _2 === "function" ? _2 : constant(_2), histogram2) : value;
+              };
+              histogram2.domain = function(_2) {
+                return arguments.length ? (domain = typeof _2 === "function" ? _2 : constant([_2[0], _2[1]]), histogram2) : domain;
+              };
+              histogram2.thresholds = function(_2) {
+                return arguments.length ? (threshold = typeof _2 === "function" ? _2 : Array.isArray(_2) ? constant(slice.call(_2)) : constant(_2), histogram2) : threshold;
+              };
+              return histogram2;
+            }
+            function quantile(values, p2, valueof) {
+              if (valueof == null) valueof = number;
+              if (!(n2 = values.length)) return;
+              if ((p2 = +p2) <= 0 || n2 < 2) return +valueof(values[0], 0, values);
+              if (p2 >= 1) return +valueof(values[n2 - 1], n2 - 1, values);
+              var n2, i2 = (n2 - 1) * p2, i0 = Math.floor(i2), value0 = +valueof(values[i0], i0, values), value1 = +valueof(values[i0 + 1], i0 + 1, values);
+              return value0 + (value1 - value0) * (i2 - i0);
+            }
+            function freedmanDiaconis(values, min2, max2) {
+              values = map2.call(values, number).sort(ascending);
+              return Math.ceil((max2 - min2) / (2 * (quantile(values, 0.75) - quantile(values, 0.25)) * Math.pow(values.length, -1 / 3)));
+            }
+            function scott(values, min2, max2) {
+              return Math.ceil((max2 - min2) / (3.5 * deviation(values) * Math.pow(values.length, -1 / 3)));
+            }
+            function max(values, valueof) {
+              var n2 = values.length, i2 = -1, value, max2;
+              if (valueof == null) {
+                while (++i2 < n2) {
+                  if ((value = values[i2]) != null && value >= value) {
+                    max2 = value;
+                    while (++i2 < n2) {
+                      if ((value = values[i2]) != null && value > max2) {
+                        max2 = value;
+                      }
+                    }
+                  }
+                }
+              } else {
+                while (++i2 < n2) {
+                  if ((value = valueof(values[i2], i2, values)) != null && value >= value) {
+                    max2 = value;
+                    while (++i2 < n2) {
+                      if ((value = valueof(values[i2], i2, values)) != null && value > max2) {
+                        max2 = value;
+                      }
+                    }
+                  }
+                }
+              }
+              return max2;
+            }
+            function mean(values, valueof) {
+              var n2 = values.length, m2 = n2, i2 = -1, value, sum2 = 0;
+              if (valueof == null) {
+                while (++i2 < n2) {
+                  if (!isNaN(value = number(values[i2]))) sum2 += value;
+                  else --m2;
+                }
+              } else {
+                while (++i2 < n2) {
+                  if (!isNaN(value = number(valueof(values[i2], i2, values)))) sum2 += value;
+                  else --m2;
+                }
+              }
+              if (m2) return sum2 / m2;
+            }
+            function median(values, valueof) {
+              var n2 = values.length, i2 = -1, value, numbers = [];
+              if (valueof == null) {
+                while (++i2 < n2) {
+                  if (!isNaN(value = number(values[i2]))) {
+                    numbers.push(value);
+                  }
+                }
+              } else {
+                while (++i2 < n2) {
+                  if (!isNaN(value = number(valueof(values[i2], i2, values)))) {
+                    numbers.push(value);
+                  }
+                }
+              }
+              return quantile(numbers.sort(ascending), 0.5);
+            }
+            function merge(arrays) {
+              var n2 = arrays.length, m2, i2 = -1, j2 = 0, merged, array2;
+              while (++i2 < n2) j2 += arrays[i2].length;
+              merged = new Array(j2);
+              while (--n2 >= 0) {
+                array2 = arrays[n2];
+                m2 = array2.length;
+                while (--m2 >= 0) {
+                  merged[--j2] = array2[m2];
+                }
+              }
+              return merged;
+            }
+            function min(values, valueof) {
+              var n2 = values.length, i2 = -1, value, min2;
+              if (valueof == null) {
+                while (++i2 < n2) {
+                  if ((value = values[i2]) != null && value >= value) {
+                    min2 = value;
+                    while (++i2 < n2) {
+                      if ((value = values[i2]) != null && min2 > value) {
+                        min2 = value;
+                      }
+                    }
+                  }
+                }
+              } else {
+                while (++i2 < n2) {
+                  if ((value = valueof(values[i2], i2, values)) != null && value >= value) {
+                    min2 = value;
+                    while (++i2 < n2) {
+                      if ((value = valueof(values[i2], i2, values)) != null && min2 > value) {
+                        min2 = value;
+                      }
+                    }
+                  }
+                }
+              }
+              return min2;
+            }
+            function permute(array2, indexes) {
+              var i2 = indexes.length, permutes = new Array(i2);
+              while (i2--) permutes[i2] = array2[indexes[i2]];
+              return permutes;
+            }
+            function scan(values, compare) {
+              if (!(n2 = values.length)) return;
+              var n2, i2 = 0, j2 = 0, xi2, xj2 = values[j2];
+              if (compare == null) compare = ascending;
+              while (++i2 < n2) {
+                if (compare(xi2 = values[i2], xj2) < 0 || compare(xj2, xj2) !== 0) {
+                  xj2 = xi2, j2 = i2;
+                }
+              }
+              if (compare(xj2, xj2) === 0) return j2;
+            }
+            function shuffle(array2, i0, i1) {
+              var m2 = (i1 == null ? array2.length : i1) - (i0 = i0 == null ? 0 : +i0), t4, i2;
+              while (m2) {
+                i2 = Math.random() * m2-- | 0;
+                t4 = array2[m2 + i0];
+                array2[m2 + i0] = array2[i2 + i0];
+                array2[i2 + i0] = t4;
+              }
+              return array2;
+            }
+            function sum(values, valueof) {
+              var n2 = values.length, i2 = -1, value, sum2 = 0;
+              if (valueof == null) {
+                while (++i2 < n2) {
+                  if (value = +values[i2]) sum2 += value;
+                }
+              } else {
+                while (++i2 < n2) {
+                  if (value = +valueof(values[i2], i2, values)) sum2 += value;
+                }
+              }
+              return sum2;
+            }
+            function transpose2(matrix) {
+              if (!(n2 = matrix.length)) return [];
+              for (var i2 = -1, m2 = min(matrix, length2), transpose22 = new Array(m2); ++i2 < m2; ) {
+                for (var j2 = -1, n2, row = transpose22[i2] = new Array(n2); ++j2 < n2; ) {
+                  row[j2] = matrix[j2][i2];
+                }
+              }
+              return transpose22;
+            }
+            function length2(d2) {
+              return d2.length;
+            }
+            function zip() {
+              return transpose2(arguments);
+            }
+            exports2.bisect = bisectRight;
+            exports2.bisectRight = bisectRight;
+            exports2.bisectLeft = bisectLeft;
+            exports2.ascending = ascending;
+            exports2.bisector = bisector;
+            exports2.cross = cross2;
+            exports2.descending = descending;
+            exports2.deviation = deviation;
+            exports2.extent = extent;
+            exports2.histogram = histogram;
+            exports2.thresholdFreedmanDiaconis = freedmanDiaconis;
+            exports2.thresholdScott = scott;
+            exports2.thresholdSturges = sturges;
+            exports2.max = max;
+            exports2.mean = mean;
+            exports2.median = median;
+            exports2.merge = merge;
+            exports2.min = min;
+            exports2.pairs = pairs;
+            exports2.permute = permute;
+            exports2.quantile = quantile;
+            exports2.range = range;
+            exports2.scan = scan;
+            exports2.shuffle = shuffle;
+            exports2.sum = sum;
+            exports2.ticks = ticks;
+            exports2.tickIncrement = tickIncrement;
+            exports2.tickStep = tickStep;
+            exports2.transpose = transpose2;
+            exports2.variance = variance;
+            exports2.zip = zip;
+            Object.defineProperty(exports2, "__esModule", { value: true });
+          });
+        }
+      });
+      var require_d3_geo = __commonJS({
+        "node_modules/d3-geo/dist/d3-geo.js"(exports, module2) {
+          (function(global2, factory2) {
+            typeof exports === "object" && typeof module2 !== "undefined" ? factory2(exports, require_d3_array()) : (global2 = global2 || self, factory2(global2.d3 = global2.d3 || {}, global2.d3));
+          })(exports, function(exports2, d3Array) {
+            function adder() {
+              return new Adder();
+            }
+            function Adder() {
+              this.reset();
+            }
+            Adder.prototype = {
+              constructor: Adder,
+              reset: function() {
+                this.s = // rounded value
+                this.t = 0;
+              },
+              add: function(y2) {
+                add2(temp, y2, this.t);
+                add2(this, temp.s, this.s);
+                if (this.s) this.t += temp.t;
+                else this.s = temp.t;
+              },
+              valueOf: function() {
+                return this.s;
+              }
+            };
+            var temp = new Adder();
+            function add2(adder2, a2, b2) {
+              var x2 = adder2.s = a2 + b2, bv = x2 - a2, av = x2 - bv;
+              adder2.t = a2 - av + (b2 - bv);
+            }
+            var epsilon = 1e-6;
+            var epsilon22 = 1e-12;
+            var pi2 = Math.PI;
+            var halfPi = pi2 / 2;
+            var quarterPi = pi2 / 4;
+            var tau = pi2 * 2;
+            var degrees3 = 180 / pi2;
+            var radians2 = pi2 / 180;
+            var abs = Math.abs;
+            var atan = Math.atan;
+            var atan2 = Math.atan2;
+            var cos = Math.cos;
+            var ceil = Math.ceil;
+            var exp = Math.exp;
+            var log3 = Math.log;
+            var pow = Math.pow;
+            var sin = Math.sin;
+            var sign = Math.sign || function(x2) {
+              return x2 > 0 ? 1 : x2 < 0 ? -1 : 0;
+            };
+            var sqrt = Math.sqrt;
+            var tan = Math.tan;
+            function acos(x2) {
+              return x2 > 1 ? 0 : x2 < -1 ? pi2 : Math.acos(x2);
+            }
+            function asin(x2) {
+              return x2 > 1 ? halfPi : x2 < -1 ? -halfPi : Math.asin(x2);
+            }
+            function haversin(x2) {
+              return (x2 = sin(x2 / 2)) * x2;
+            }
+            function noop2() {
+            }
+            function streamGeometry(geometry2, stream) {
+              if (geometry2 && streamGeometryType.hasOwnProperty(geometry2.type)) {
+                streamGeometryType[geometry2.type](geometry2, stream);
+              }
+            }
+            var streamObjectType = {
+              Feature: function(object2, stream) {
+                streamGeometry(object2.geometry, stream);
+              },
+              FeatureCollection: function(object2, stream) {
+                var features = object2.features, i2 = -1, n2 = features.length;
+                while (++i2 < n2) streamGeometry(features[i2].geometry, stream);
+              }
+            };
+            var streamGeometryType = {
+              Sphere: function(object2, stream) {
+                stream.sphere();
+              },
+              Point: function(object2, stream) {
+                object2 = object2.coordinates;
+                stream.point(object2[0], object2[1], object2[2]);
+              },
+              MultiPoint: function(object2, stream) {
+                var coordinates2 = object2.coordinates, i2 = -1, n2 = coordinates2.length;
+                while (++i2 < n2) object2 = coordinates2[i2], stream.point(object2[0], object2[1], object2[2]);
+              },
+              LineString: function(object2, stream) {
+                streamLine(object2.coordinates, stream, 0);
+              },
+              MultiLineString: function(object2, stream) {
+                var coordinates2 = object2.coordinates, i2 = -1, n2 = coordinates2.length;
+                while (++i2 < n2) streamLine(coordinates2[i2], stream, 0);
+              },
+              Polygon: function(object2, stream) {
+                streamPolygon(object2.coordinates, stream);
+              },
+              MultiPolygon: function(object2, stream) {
+                var coordinates2 = object2.coordinates, i2 = -1, n2 = coordinates2.length;
+                while (++i2 < n2) streamPolygon(coordinates2[i2], stream);
+              },
+              GeometryCollection: function(object2, stream) {
+                var geometries = object2.geometries, i2 = -1, n2 = geometries.length;
+                while (++i2 < n2) streamGeometry(geometries[i2], stream);
+              }
+            };
+            function streamLine(coordinates2, stream, closed) {
+              var i2 = -1, n2 = coordinates2.length - closed, coordinate;
+              stream.lineStart();
+              while (++i2 < n2) coordinate = coordinates2[i2], stream.point(coordinate[0], coordinate[1], coordinate[2]);
+              stream.lineEnd();
+            }
+            function streamPolygon(coordinates2, stream) {
+              var i2 = -1, n2 = coordinates2.length;
+              stream.polygonStart();
+              while (++i2 < n2) streamLine(coordinates2[i2], stream, 1);
+              stream.polygonEnd();
+            }
+            function geoStream(object2, stream) {
+              if (object2 && streamObjectType.hasOwnProperty(object2.type)) {
+                streamObjectType[object2.type](object2, stream);
+              } else {
+                streamGeometry(object2, stream);
+              }
+            }
+            var areaRingSum = adder();
+            var areaSum = adder(), lambda00, phi00, lambda0, cosPhi0, sinPhi0;
+            var areaStream = {
+              point: noop2,
+              lineStart: noop2,
+              lineEnd: noop2,
+              polygonStart: function() {
+                areaRingSum.reset();
+                areaStream.lineStart = areaRingStart;
+                areaStream.lineEnd = areaRingEnd;
+              },
+              polygonEnd: function() {
+                var areaRing = +areaRingSum;
+                areaSum.add(areaRing < 0 ? tau + areaRing : areaRing);
+                this.lineStart = this.lineEnd = this.point = noop2;
+              },
+              sphere: function() {
+                areaSum.add(tau);
+              }
+            };
+            function areaRingStart() {
+              areaStream.point = areaPointFirst;
+            }
+            function areaRingEnd() {
+              areaPoint(lambda00, phi00);
+            }
+            function areaPointFirst(lambda, phi) {
+              areaStream.point = areaPoint;
+              lambda00 = lambda, phi00 = phi;
+              lambda *= radians2, phi *= radians2;
+              lambda0 = lambda, cosPhi0 = cos(phi = phi / 2 + quarterPi), sinPhi0 = sin(phi);
+            }
+            function areaPoint(lambda, phi) {
+              lambda *= radians2, phi *= radians2;
+              phi = phi / 2 + quarterPi;
+              var dLambda = lambda - lambda0, sdLambda = dLambda >= 0 ? 1 : -1, adLambda = sdLambda * dLambda, cosPhi = cos(phi), sinPhi = sin(phi), k2 = sinPhi0 * sinPhi, u2 = cosPhi0 * cosPhi + k2 * cos(adLambda), v2 = k2 * sdLambda * sin(adLambda);
+              areaRingSum.add(atan2(v2, u2));
+              lambda0 = lambda, cosPhi0 = cosPhi, sinPhi0 = sinPhi;
+            }
+            function area(object2) {
+              areaSum.reset();
+              geoStream(object2, areaStream);
+              return areaSum * 2;
+            }
+            function spherical(cartesian2) {
+              return [atan2(cartesian2[1], cartesian2[0]), asin(cartesian2[2])];
+            }
+            function cartesian(spherical2) {
+              var lambda = spherical2[0], phi = spherical2[1], cosPhi = cos(phi);
+              return [cosPhi * cos(lambda), cosPhi * sin(lambda), sin(phi)];
+            }
+            function cartesianDot(a2, b2) {
+              return a2[0] * b2[0] + a2[1] * b2[1] + a2[2] * b2[2];
+            }
+            function cartesianCross(a2, b2) {
+              return [a2[1] * b2[2] - a2[2] * b2[1], a2[2] * b2[0] - a2[0] * b2[2], a2[0] * b2[1] - a2[1] * b2[0]];
+            }
+            function cartesianAddInPlace(a2, b2) {
+              a2[0] += b2[0], a2[1] += b2[1], a2[2] += b2[2];
+            }
+            function cartesianScale(vector, k2) {
+              return [vector[0] * k2, vector[1] * k2, vector[2] * k2];
+            }
+            function cartesianNormalizeInPlace(d2) {
+              var l2 = sqrt(d2[0] * d2[0] + d2[1] * d2[1] + d2[2] * d2[2]);
+              d2[0] /= l2, d2[1] /= l2, d2[2] /= l2;
+            }
+            var lambda0$1, phi0, lambda1, phi1, lambda2, lambda00$1, phi00$1, p0, deltaSum = adder(), ranges, range;
+            var boundsStream = {
+              point: boundsPoint,
+              lineStart: boundsLineStart,
+              lineEnd: boundsLineEnd,
+              polygonStart: function() {
+                boundsStream.point = boundsRingPoint;
+                boundsStream.lineStart = boundsRingStart;
+                boundsStream.lineEnd = boundsRingEnd;
+                deltaSum.reset();
+                areaStream.polygonStart();
+              },
+              polygonEnd: function() {
+                areaStream.polygonEnd();
+                boundsStream.point = boundsPoint;
+                boundsStream.lineStart = boundsLineStart;
+                boundsStream.lineEnd = boundsLineEnd;
+                if (areaRingSum < 0) lambda0$1 = -(lambda1 = 180), phi0 = -(phi1 = 90);
+                else if (deltaSum > epsilon) phi1 = 90;
+                else if (deltaSum < -1e-6) phi0 = -90;
+                range[0] = lambda0$1, range[1] = lambda1;
+              },
+              sphere: function() {
+                lambda0$1 = -(lambda1 = 180), phi0 = -(phi1 = 90);
+              }
+            };
+            function boundsPoint(lambda, phi) {
+              ranges.push(range = [lambda0$1 = lambda, lambda1 = lambda]);
+              if (phi < phi0) phi0 = phi;
+              if (phi > phi1) phi1 = phi;
+            }
+            function linePoint(lambda, phi) {
+              var p2 = cartesian([lambda * radians2, phi * radians2]);
+              if (p0) {
+                var normal = cartesianCross(p0, p2), equatorial = [normal[1], -normal[0], 0], inflection = cartesianCross(equatorial, normal);
+                cartesianNormalizeInPlace(inflection);
+                inflection = spherical(inflection);
+                var delta = lambda - lambda2, sign2 = delta > 0 ? 1 : -1, lambdai = inflection[0] * degrees3 * sign2, phii, antimeridian = abs(delta) > 180;
+                if (antimeridian ^ (sign2 * lambda2 < lambdai && lambdai < sign2 * lambda)) {
+                  phii = inflection[1] * degrees3;
+                  if (phii > phi1) phi1 = phii;
+                } else if (lambdai = (lambdai + 360) % 360 - 180, antimeridian ^ (sign2 * lambda2 < lambdai && lambdai < sign2 * lambda)) {
+                  phii = -inflection[1] * degrees3;
+                  if (phii < phi0) phi0 = phii;
+                } else {
+                  if (phi < phi0) phi0 = phi;
+                  if (phi > phi1) phi1 = phi;
+                }
+                if (antimeridian) {
+                  if (lambda < lambda2) {
+                    if (angle2(lambda0$1, lambda) > angle2(lambda0$1, lambda1)) lambda1 = lambda;
+                  } else {
+                    if (angle2(lambda, lambda1) > angle2(lambda0$1, lambda1)) lambda0$1 = lambda;
+                  }
+                } else {
+                  if (lambda1 >= lambda0$1) {
+                    if (lambda < lambda0$1) lambda0$1 = lambda;
+                    if (lambda > lambda1) lambda1 = lambda;
+                  } else {
+                    if (lambda > lambda2) {
+                      if (angle2(lambda0$1, lambda) > angle2(lambda0$1, lambda1)) lambda1 = lambda;
+                    } else {
+                      if (angle2(lambda, lambda1) > angle2(lambda0$1, lambda1)) lambda0$1 = lambda;
+                    }
+                  }
+                }
+              } else {
+                ranges.push(range = [lambda0$1 = lambda, lambda1 = lambda]);
+              }
+              if (phi < phi0) phi0 = phi;
+              if (phi > phi1) phi1 = phi;
+              p0 = p2, lambda2 = lambda;
+            }
+            function boundsLineStart() {
+              boundsStream.point = linePoint;
+            }
+            function boundsLineEnd() {
+              range[0] = lambda0$1, range[1] = lambda1;
+              boundsStream.point = boundsPoint;
+              p0 = null;
+            }
+            function boundsRingPoint(lambda, phi) {
+              if (p0) {
+                var delta = lambda - lambda2;
+                deltaSum.add(abs(delta) > 180 ? delta + (delta > 0 ? 360 : -360) : delta);
+              } else {
+                lambda00$1 = lambda, phi00$1 = phi;
+              }
+              areaStream.point(lambda, phi);
+              linePoint(lambda, phi);
+            }
+            function boundsRingStart() {
+              areaStream.lineStart();
+            }
+            function boundsRingEnd() {
+              boundsRingPoint(lambda00$1, phi00$1);
+              areaStream.lineEnd();
+              if (abs(deltaSum) > epsilon) lambda0$1 = -(lambda1 = 180);
+              range[0] = lambda0$1, range[1] = lambda1;
+              p0 = null;
+            }
+            function angle2(lambda02, lambda12) {
+              return (lambda12 -= lambda02) < 0 ? lambda12 + 360 : lambda12;
+            }
+            function rangeCompare(a2, b2) {
+              return a2[0] - b2[0];
+            }
+            function rangeContains(range2, x2) {
+              return range2[0] <= range2[1] ? range2[0] <= x2 && x2 <= range2[1] : x2 < range2[0] || range2[1] < x2;
+            }
+            function bounds(feature) {
+              var i2, n2, a2, b2, merged, deltaMax, delta;
+              phi1 = lambda1 = -(lambda0$1 = phi0 = Infinity);
+              ranges = [];
+              geoStream(feature, boundsStream);
+              if (n2 = ranges.length) {
+                ranges.sort(rangeCompare);
+                for (i2 = 1, a2 = ranges[0], merged = [a2]; i2 < n2; ++i2) {
+                  b2 = ranges[i2];
+                  if (rangeContains(a2, b2[0]) || rangeContains(a2, b2[1])) {
+                    if (angle2(a2[0], b2[1]) > angle2(a2[0], a2[1])) a2[1] = b2[1];
+                    if (angle2(b2[0], a2[1]) > angle2(a2[0], a2[1])) a2[0] = b2[0];
+                  } else {
+                    merged.push(a2 = b2);
+                  }
+                }
+                for (deltaMax = -Infinity, n2 = merged.length - 1, i2 = 0, a2 = merged[n2]; i2 <= n2; a2 = b2, ++i2) {
+                  b2 = merged[i2];
+                  if ((delta = angle2(a2[1], b2[0])) > deltaMax) deltaMax = delta, lambda0$1 = b2[0], lambda1 = a2[1];
+                }
+              }
+              ranges = range = null;
+              return lambda0$1 === Infinity || phi0 === Infinity ? [[NaN, NaN], [NaN, NaN]] : [[lambda0$1, phi0], [lambda1, phi1]];
+            }
+            var W0, W1, X0, Y0, Z0, X1, Y1, Z1, X2, Y2, Z2, lambda00$2, phi00$2, x0, y0, z0;
+            var centroidStream = {
+              sphere: noop2,
+              point: centroidPoint,
+              lineStart: centroidLineStart,
+              lineEnd: centroidLineEnd,
+              polygonStart: function() {
+                centroidStream.lineStart = centroidRingStart;
+                centroidStream.lineEnd = centroidRingEnd;
+              },
+              polygonEnd: function() {
+                centroidStream.lineStart = centroidLineStart;
+                centroidStream.lineEnd = centroidLineEnd;
+              }
+            };
+            function centroidPoint(lambda, phi) {
+              lambda *= radians2, phi *= radians2;
+              var cosPhi = cos(phi);
+              centroidPointCartesian(cosPhi * cos(lambda), cosPhi * sin(lambda), sin(phi));
+            }
+            function centroidPointCartesian(x2, y2, z2) {
+              ++W0;
+              X0 += (x2 - X0) / W0;
+              Y0 += (y2 - Y0) / W0;
+              Z0 += (z2 - Z0) / W0;
+            }
+            function centroidLineStart() {
+              centroidStream.point = centroidLinePointFirst;
+            }
+            function centroidLinePointFirst(lambda, phi) {
+              lambda *= radians2, phi *= radians2;
+              var cosPhi = cos(phi);
+              x0 = cosPhi * cos(lambda);
+              y0 = cosPhi * sin(lambda);
+              z0 = sin(phi);
+              centroidStream.point = centroidLinePoint;
+              centroidPointCartesian(x0, y0, z0);
+            }
+            function centroidLinePoint(lambda, phi) {
+              lambda *= radians2, phi *= radians2;
+              var cosPhi = cos(phi), x2 = cosPhi * cos(lambda), y2 = cosPhi * sin(lambda), z2 = sin(phi), w2 = atan2(sqrt((w2 = y0 * z2 - z0 * y2) * w2 + (w2 = z0 * x2 - x0 * z2) * w2 + (w2 = x0 * y2 - y0 * x2) * w2), x0 * x2 + y0 * y2 + z0 * z2);
+              W1 += w2;
+              X1 += w2 * (x0 + (x0 = x2));
+              Y1 += w2 * (y0 + (y0 = y2));
+              Z1 += w2 * (z0 + (z0 = z2));
+              centroidPointCartesian(x0, y0, z0);
+            }
+            function centroidLineEnd() {
+              centroidStream.point = centroidPoint;
+            }
+            function centroidRingStart() {
+              centroidStream.point = centroidRingPointFirst;
+            }
+            function centroidRingEnd() {
+              centroidRingPoint(lambda00$2, phi00$2);
+              centroidStream.point = centroidPoint;
+            }
+            function centroidRingPointFirst(lambda, phi) {
+              lambda00$2 = lambda, phi00$2 = phi;
+              lambda *= radians2, phi *= radians2;
+              centroidStream.point = centroidRingPoint;
+              var cosPhi = cos(phi);
+              x0 = cosPhi * cos(lambda);
+              y0 = cosPhi * sin(lambda);
+              z0 = sin(phi);
+              centroidPointCartesian(x0, y0, z0);
+            }
+            function centroidRingPoint(lambda, phi) {
+              lambda *= radians2, phi *= radians2;
+              var cosPhi = cos(phi), x2 = cosPhi * cos(lambda), y2 = cosPhi * sin(lambda), z2 = sin(phi), cx = y0 * z2 - z0 * y2, cy = z0 * x2 - x0 * z2, cz = x0 * y2 - y0 * x2, m2 = sqrt(cx * cx + cy * cy + cz * cz), w2 = asin(m2), v2 = m2 && -w2 / m2;
+              X2 += v2 * cx;
+              Y2 += v2 * cy;
+              Z2 += v2 * cz;
+              W1 += w2;
+              X1 += w2 * (x0 + (x0 = x2));
+              Y1 += w2 * (y0 + (y0 = y2));
+              Z1 += w2 * (z0 + (z0 = z2));
+              centroidPointCartesian(x0, y0, z0);
+            }
+            function centroid(object2) {
+              W0 = W1 = X0 = Y0 = Z0 = X1 = Y1 = Z1 = X2 = Y2 = Z2 = 0;
+              geoStream(object2, centroidStream);
+              var x2 = X2, y2 = Y2, z2 = Z2, m2 = x2 * x2 + y2 * y2 + z2 * z2;
+              if (m2 < epsilon22) {
+                x2 = X1, y2 = Y1, z2 = Z1;
+                if (W1 < epsilon) x2 = X0, y2 = Y0, z2 = Z0;
+                m2 = x2 * x2 + y2 * y2 + z2 * z2;
+                if (m2 < epsilon22) return [NaN, NaN];
+              }
+              return [atan2(y2, x2) * degrees3, asin(z2 / sqrt(m2)) * degrees3];
+            }
+            function constant(x2) {
+              return function() {
+                return x2;
+              };
+            }
+            function compose(a2, b2) {
+              function compose2(x2, y2) {
+                return x2 = a2(x2, y2), b2(x2[0], x2[1]);
+              }
+              if (a2.invert && b2.invert) compose2.invert = function(x2, y2) {
+                return x2 = b2.invert(x2, y2), x2 && a2.invert(x2[0], x2[1]);
+              };
+              return compose2;
+            }
+            function rotationIdentity(lambda, phi) {
+              return [abs(lambda) > pi2 ? lambda + Math.round(-lambda / tau) * tau : lambda, phi];
+            }
+            rotationIdentity.invert = rotationIdentity;
+            function rotateRadians(deltaLambda, deltaPhi, deltaGamma) {
+              return (deltaLambda %= tau) ? deltaPhi || deltaGamma ? compose(rotationLambda(deltaLambda), rotationPhiGamma(deltaPhi, deltaGamma)) : rotationLambda(deltaLambda) : deltaPhi || deltaGamma ? rotationPhiGamma(deltaPhi, deltaGamma) : rotationIdentity;
+            }
+            function forwardRotationLambda(deltaLambda) {
+              return function(lambda, phi) {
+                return lambda += deltaLambda, [lambda > pi2 ? lambda - tau : lambda < -pi2 ? lambda + tau : lambda, phi];
+              };
+            }
+            function rotationLambda(deltaLambda) {
+              var rotation2 = forwardRotationLambda(deltaLambda);
+              rotation2.invert = forwardRotationLambda(-deltaLambda);
+              return rotation2;
+            }
+            function rotationPhiGamma(deltaPhi, deltaGamma) {
+              var cosDeltaPhi = cos(deltaPhi), sinDeltaPhi = sin(deltaPhi), cosDeltaGamma = cos(deltaGamma), sinDeltaGamma = sin(deltaGamma);
+              function rotation2(lambda, phi) {
+                var cosPhi = cos(phi), x2 = cos(lambda) * cosPhi, y2 = sin(lambda) * cosPhi, z2 = sin(phi), k2 = z2 * cosDeltaPhi + x2 * sinDeltaPhi;
+                return [
+                  atan2(y2 * cosDeltaGamma - k2 * sinDeltaGamma, x2 * cosDeltaPhi - z2 * sinDeltaPhi),
+                  asin(k2 * cosDeltaGamma + y2 * sinDeltaGamma)
+                ];
+              }
+              rotation2.invert = function(lambda, phi) {
+                var cosPhi = cos(phi), x2 = cos(lambda) * cosPhi, y2 = sin(lambda) * cosPhi, z2 = sin(phi), k2 = z2 * cosDeltaGamma - y2 * sinDeltaGamma;
+                return [
+                  atan2(y2 * cosDeltaGamma + z2 * sinDeltaGamma, x2 * cosDeltaPhi + k2 * sinDeltaPhi),
+                  asin(k2 * cosDeltaPhi - x2 * sinDeltaPhi)
+                ];
+              };
+              return rotation2;
+            }
+            function rotation(rotate2) {
+              rotate2 = rotateRadians(rotate2[0] * radians2, rotate2[1] * radians2, rotate2.length > 2 ? rotate2[2] * radians2 : 0);
+              function forward(coordinates2) {
+                coordinates2 = rotate2(coordinates2[0] * radians2, coordinates2[1] * radians2);
+                return coordinates2[0] *= degrees3, coordinates2[1] *= degrees3, coordinates2;
+              }
+              forward.invert = function(coordinates2) {
+                coordinates2 = rotate2.invert(coordinates2[0] * radians2, coordinates2[1] * radians2);
+                return coordinates2[0] *= degrees3, coordinates2[1] *= degrees3, coordinates2;
+              };
+              return forward;
+            }
+            function circleStream(stream, radius, delta, direction, t02, t12) {
+              if (!delta) return;
+              var cosRadius = cos(radius), sinRadius = sin(radius), step = direction * delta;
+              if (t02 == null) {
+                t02 = radius + direction * tau;
+                t12 = radius - step / 2;
+              } else {
+                t02 = circleRadius(cosRadius, t02);
+                t12 = circleRadius(cosRadius, t12);
+                if (direction > 0 ? t02 < t12 : t02 > t12) t02 += direction * tau;
+              }
+              for (var point, t4 = t02; direction > 0 ? t4 > t12 : t4 < t12; t4 -= step) {
+                point = spherical([cosRadius, -sinRadius * cos(t4), -sinRadius * sin(t4)]);
+                stream.point(point[0], point[1]);
+              }
+            }
+            function circleRadius(cosRadius, point) {
+              point = cartesian(point), point[0] -= cosRadius;
+              cartesianNormalizeInPlace(point);
+              var radius = acos(-point[1]);
+              return ((-point[2] < 0 ? -radius : radius) + tau - epsilon) % tau;
+            }
+            function circle() {
+              var center = constant([0, 0]), radius = constant(90), precision = constant(6), ring, rotate2, stream = { point };
+              function point(x2, y2) {
+                ring.push(x2 = rotate2(x2, y2));
+                x2[0] *= degrees3, x2[1] *= degrees3;
+              }
+              function circle2() {
+                var c2 = center.apply(this, arguments), r2 = radius.apply(this, arguments) * radians2, p2 = precision.apply(this, arguments) * radians2;
+                ring = [];
+                rotate2 = rotateRadians(-c2[0] * radians2, -c2[1] * radians2, 0).invert;
+                circleStream(stream, r2, p2, 1);
+                c2 = { type: "Polygon", coordinates: [ring] };
+                ring = rotate2 = null;
+                return c2;
+              }
+              circle2.center = function(_2) {
+                return arguments.length ? (center = typeof _2 === "function" ? _2 : constant([+_2[0], +_2[1]]), circle2) : center;
+              };
+              circle2.radius = function(_2) {
+                return arguments.length ? (radius = typeof _2 === "function" ? _2 : constant(+_2), circle2) : radius;
+              };
+              circle2.precision = function(_2) {
+                return arguments.length ? (precision = typeof _2 === "function" ? _2 : constant(+_2), circle2) : precision;
+              };
+              return circle2;
+            }
+            function clipBuffer() {
+              var lines = [], line;
+              return {
+                point: function(x2, y2, m2) {
+                  line.push([x2, y2, m2]);
+                },
+                lineStart: function() {
+                  lines.push(line = []);
+                },
+                lineEnd: noop2,
+                rejoin: function() {
+                  if (lines.length > 1) lines.push(lines.pop().concat(lines.shift()));
+                },
+                result: function() {
+                  var result = lines;
+                  lines = [];
+                  line = null;
+                  return result;
+                }
+              };
+            }
+            function pointEqual(a2, b2) {
+              return abs(a2[0] - b2[0]) < epsilon && abs(a2[1] - b2[1]) < epsilon;
+            }
+            function Intersection(point, points, other, entry) {
+              this.x = point;
+              this.z = points;
+              this.o = other;
+              this.e = entry;
+              this.v = false;
+              this.n = this.p = null;
+            }
+            function clipRejoin(segments, compareIntersection2, startInside, interpolate2, stream) {
+              var subject = [], clip2 = [], i2, n2;
+              segments.forEach(function(segment) {
+                if ((n22 = segment.length - 1) <= 0) return;
+                var n22, p02 = segment[0], p1 = segment[n22], x2;
+                if (pointEqual(p02, p1)) {
+                  if (!p02[2] && !p1[2]) {
+                    stream.lineStart();
+                    for (i2 = 0; i2 < n22; ++i2) stream.point((p02 = segment[i2])[0], p02[1]);
+                    stream.lineEnd();
+                    return;
+                  }
+                  p1[0] += 2 * epsilon;
+                }
+                subject.push(x2 = new Intersection(p02, segment, null, true));
+                clip2.push(x2.o = new Intersection(p02, null, x2, false));
+                subject.push(x2 = new Intersection(p1, segment, null, false));
+                clip2.push(x2.o = new Intersection(p1, null, x2, true));
+              });
+              if (!subject.length) return;
+              clip2.sort(compareIntersection2);
+              link(subject);
+              link(clip2);
+              for (i2 = 0, n2 = clip2.length; i2 < n2; ++i2) {
+                clip2[i2].e = startInside = !startInside;
+              }
+              var start = subject[0], points, point;
+              while (1) {
+                var current = start, isSubject = true;
+                while (current.v) if ((current = current.n) === start) return;
+                points = current.z;
+                stream.lineStart();
+                do {
+                  current.v = current.o.v = true;
+                  if (current.e) {
+                    if (isSubject) {
+                      for (i2 = 0, n2 = points.length; i2 < n2; ++i2) stream.point((point = points[i2])[0], point[1]);
+                    } else {
+                      interpolate2(current.x, current.n.x, 1, stream);
+                    }
+                    current = current.n;
+                  } else {
+                    if (isSubject) {
+                      points = current.p.z;
+                      for (i2 = points.length - 1; i2 >= 0; --i2) stream.point((point = points[i2])[0], point[1]);
+                    } else {
+                      interpolate2(current.x, current.p.x, -1, stream);
+                    }
+                    current = current.p;
+                  }
+                  current = current.o;
+                  points = current.z;
+                  isSubject = !isSubject;
+                } while (!current.v);
+                stream.lineEnd();
+              }
+            }
+            function link(array) {
+              if (!(n2 = array.length)) return;
+              var n2, i2 = 0, a2 = array[0], b2;
+              while (++i2 < n2) {
+                a2.n = b2 = array[i2];
+                b2.p = a2;
+                a2 = b2;
+              }
+              a2.n = b2 = array[0];
+              b2.p = a2;
+            }
+            var sum = adder();
+            function longitude(point) {
+              if (abs(point[0]) <= pi2)
+                return point[0];
+              else
+                return sign(point[0]) * ((abs(point[0]) + pi2) % tau - pi2);
+            }
+            function polygonContains(polygon, point) {
+              var lambda = longitude(point), phi = point[1], sinPhi = sin(phi), normal = [sin(lambda), -cos(lambda), 0], angle22 = 0, winding = 0;
+              sum.reset();
+              if (sinPhi === 1) phi = halfPi + epsilon;
+              else if (sinPhi === -1) phi = -halfPi - epsilon;
+              for (var i2 = 0, n2 = polygon.length; i2 < n2; ++i2) {
+                if (!(m2 = (ring = polygon[i2]).length)) continue;
+                var ring, m2, point0 = ring[m2 - 1], lambda02 = longitude(point0), phi02 = point0[1] / 2 + quarterPi, sinPhi02 = sin(phi02), cosPhi02 = cos(phi02);
+                for (var j2 = 0; j2 < m2; ++j2, lambda02 = lambda12, sinPhi02 = sinPhi1, cosPhi02 = cosPhi1, point0 = point1) {
+                  var point1 = ring[j2], lambda12 = longitude(point1), phi12 = point1[1] / 2 + quarterPi, sinPhi1 = sin(phi12), cosPhi1 = cos(phi12), delta = lambda12 - lambda02, sign2 = delta >= 0 ? 1 : -1, absDelta = sign2 * delta, antimeridian = absDelta > pi2, k2 = sinPhi02 * sinPhi1;
+                  sum.add(atan2(k2 * sign2 * sin(absDelta), cosPhi02 * cosPhi1 + k2 * cos(absDelta)));
+                  angle22 += antimeridian ? delta + sign2 * tau : delta;
+                  if (antimeridian ^ lambda02 >= lambda ^ lambda12 >= lambda) {
+                    var arc = cartesianCross(cartesian(point0), cartesian(point1));
+                    cartesianNormalizeInPlace(arc);
+                    var intersection = cartesianCross(normal, arc);
+                    cartesianNormalizeInPlace(intersection);
+                    var phiArc = (antimeridian ^ delta >= 0 ? -1 : 1) * asin(intersection[2]);
+                    if (phi > phiArc || phi === phiArc && (arc[0] || arc[1])) {
+                      winding += antimeridian ^ delta >= 0 ? 1 : -1;
+                    }
+                  }
+                }
+              }
+              return (angle22 < -1e-6 || angle22 < epsilon && sum < -1e-6) ^ winding & 1;
+            }
+            function clip(pointVisible, clipLine2, interpolate2, start) {
+              return function(sink) {
+                var line = clipLine2(sink), ringBuffer = clipBuffer(), ringSink = clipLine2(ringBuffer), polygonStarted = false, polygon, segments, ring;
+                var clip2 = {
+                  point,
+                  lineStart,
+                  lineEnd,
+                  polygonStart: function() {
+                    clip2.point = pointRing;
+                    clip2.lineStart = ringStart;
+                    clip2.lineEnd = ringEnd;
+                    segments = [];
+                    polygon = [];
+                  },
+                  polygonEnd: function() {
+                    clip2.point = point;
+                    clip2.lineStart = lineStart;
+                    clip2.lineEnd = lineEnd;
+                    segments = d3Array.merge(segments);
+                    var startInside = polygonContains(polygon, start);
+                    if (segments.length) {
+                      if (!polygonStarted) sink.polygonStart(), polygonStarted = true;
+                      clipRejoin(segments, compareIntersection, startInside, interpolate2, sink);
+                    } else if (startInside) {
+                      if (!polygonStarted) sink.polygonStart(), polygonStarted = true;
+                      sink.lineStart();
+                      interpolate2(null, null, 1, sink);
+                      sink.lineEnd();
+                    }
+                    if (polygonStarted) sink.polygonEnd(), polygonStarted = false;
+                    segments = polygon = null;
+                  },
+                  sphere: function() {
+                    sink.polygonStart();
+                    sink.lineStart();
+                    interpolate2(null, null, 1, sink);
+                    sink.lineEnd();
+                    sink.polygonEnd();
+                  }
+                };
+                function point(lambda, phi) {
+                  if (pointVisible(lambda, phi)) sink.point(lambda, phi);
+                }
+                function pointLine(lambda, phi) {
+                  line.point(lambda, phi);
+                }
+                function lineStart() {
+                  clip2.point = pointLine;
+                  line.lineStart();
+                }
+                function lineEnd() {
+                  clip2.point = point;
+                  line.lineEnd();
+                }
+                function pointRing(lambda, phi) {
+                  ring.push([lambda, phi]);
+                  ringSink.point(lambda, phi);
+                }
+                function ringStart() {
+                  ringSink.lineStart();
+                  ring = [];
+                }
+                function ringEnd() {
+                  pointRing(ring[0][0], ring[0][1]);
+                  ringSink.lineEnd();
+                  var clean = ringSink.clean(), ringSegments = ringBuffer.result(), i2, n2 = ringSegments.length, m2, segment, point2;
+                  ring.pop();
+                  polygon.push(ring);
+                  ring = null;
+                  if (!n2) return;
+                  if (clean & 1) {
+                    segment = ringSegments[0];
+                    if ((m2 = segment.length - 1) > 0) {
+                      if (!polygonStarted) sink.polygonStart(), polygonStarted = true;
+                      sink.lineStart();
+                      for (i2 = 0; i2 < m2; ++i2) sink.point((point2 = segment[i2])[0], point2[1]);
+                      sink.lineEnd();
+                    }
+                    return;
+                  }
+                  if (n2 > 1 && clean & 2) ringSegments.push(ringSegments.pop().concat(ringSegments.shift()));
+                  segments.push(ringSegments.filter(validSegment));
+                }
+                return clip2;
+              };
+            }
+            function validSegment(segment) {
+              return segment.length > 1;
+            }
+            function compareIntersection(a2, b2) {
+              return ((a2 = a2.x)[0] < 0 ? a2[1] - halfPi - epsilon : halfPi - a2[1]) - ((b2 = b2.x)[0] < 0 ? b2[1] - halfPi - epsilon : halfPi - b2[1]);
+            }
+            var clipAntimeridian = clip(
+              function() {
+                return true;
+              },
+              clipAntimeridianLine,
+              clipAntimeridianInterpolate,
+              [-pi2, -halfPi]
+            );
+            function clipAntimeridianLine(stream) {
+              var lambda02 = NaN, phi02 = NaN, sign0 = NaN, clean;
+              return {
+                lineStart: function() {
+                  stream.lineStart();
+                  clean = 1;
+                },
+                point: function(lambda12, phi12) {
+                  var sign1 = lambda12 > 0 ? pi2 : -pi2, delta = abs(lambda12 - lambda02);
+                  if (abs(delta - pi2) < epsilon) {
+                    stream.point(lambda02, phi02 = (phi02 + phi12) / 2 > 0 ? halfPi : -halfPi);
+                    stream.point(sign0, phi02);
+                    stream.lineEnd();
+                    stream.lineStart();
+                    stream.point(sign1, phi02);
+                    stream.point(lambda12, phi02);
+                    clean = 0;
+                  } else if (sign0 !== sign1 && delta >= pi2) {
+                    if (abs(lambda02 - sign0) < epsilon) lambda02 -= sign0 * epsilon;
+                    if (abs(lambda12 - sign1) < epsilon) lambda12 -= sign1 * epsilon;
+                    phi02 = clipAntimeridianIntersect(lambda02, phi02, lambda12, phi12);
+                    stream.point(sign0, phi02);
+                    stream.lineEnd();
+                    stream.lineStart();
+                    stream.point(sign1, phi02);
+                    clean = 0;
+                  }
+                  stream.point(lambda02 = lambda12, phi02 = phi12);
+                  sign0 = sign1;
+                },
+                lineEnd: function() {
+                  stream.lineEnd();
+                  lambda02 = phi02 = NaN;
+                },
+                clean: function() {
+                  return 2 - clean;
+                }
+              };
+            }
+            function clipAntimeridianIntersect(lambda02, phi02, lambda12, phi12) {
+              var cosPhi02, cosPhi1, sinLambda0Lambda1 = sin(lambda02 - lambda12);
+              return abs(sinLambda0Lambda1) > epsilon ? atan((sin(phi02) * (cosPhi1 = cos(phi12)) * sin(lambda12) - sin(phi12) * (cosPhi02 = cos(phi02)) * sin(lambda02)) / (cosPhi02 * cosPhi1 * sinLambda0Lambda1)) : (phi02 + phi12) / 2;
+            }
+            function clipAntimeridianInterpolate(from, to, direction, stream) {
+              var phi;
+              if (from == null) {
+                phi = direction * halfPi;
+                stream.point(-pi2, phi);
+                stream.point(0, phi);
+                stream.point(pi2, phi);
+                stream.point(pi2, 0);
+                stream.point(pi2, -phi);
+                stream.point(0, -phi);
+                stream.point(-pi2, -phi);
+                stream.point(-pi2, 0);
+                stream.point(-pi2, phi);
+              } else if (abs(from[0] - to[0]) > epsilon) {
+                var lambda = from[0] < to[0] ? pi2 : -pi2;
+                phi = direction * lambda / 2;
+                stream.point(-lambda, phi);
+                stream.point(0, phi);
+                stream.point(lambda, phi);
+              } else {
+                stream.point(to[0], to[1]);
+              }
+            }
+            function clipCircle(radius) {
+              var cr = cos(radius), delta = 6 * radians2, smallRadius = cr > 0, notHemisphere = abs(cr) > epsilon;
+              function interpolate2(from, to, direction, stream) {
+                circleStream(stream, radius, delta, direction, from, to);
+              }
+              function visible(lambda, phi) {
+                return cos(lambda) * cos(phi) > cr;
+              }
+              function clipLine2(stream) {
+                var point0, c0, v0, v00, clean;
+                return {
+                  lineStart: function() {
+                    v00 = v0 = false;
+                    clean = 1;
+                  },
+                  point: function(lambda, phi) {
+                    var point1 = [lambda, phi], point2, v2 = visible(lambda, phi), c2 = smallRadius ? v2 ? 0 : code(lambda, phi) : v2 ? code(lambda + (lambda < 0 ? pi2 : -pi2), phi) : 0;
+                    if (!point0 && (v00 = v0 = v2)) stream.lineStart();
+                    if (v2 !== v0) {
+                      point2 = intersect(point0, point1);
+                      if (!point2 || pointEqual(point0, point2) || pointEqual(point1, point2))
+                        point1[2] = 1;
+                    }
+                    if (v2 !== v0) {
+                      clean = 0;
+                      if (v2) {
+                        stream.lineStart();
+                        point2 = intersect(point1, point0);
+                        stream.point(point2[0], point2[1]);
+                      } else {
+                        point2 = intersect(point0, point1);
+                        stream.point(point2[0], point2[1], 2);
+                        stream.lineEnd();
+                      }
+                      point0 = point2;
+                    } else if (notHemisphere && point0 && smallRadius ^ v2) {
+                      var t4;
+                      if (!(c2 & c0) && (t4 = intersect(point1, point0, true))) {
+                        clean = 0;
+                        if (smallRadius) {
+                          stream.lineStart();
+                          stream.point(t4[0][0], t4[0][1]);
+                          stream.point(t4[1][0], t4[1][1]);
+                          stream.lineEnd();
+                        } else {
+                          stream.point(t4[1][0], t4[1][1]);
+                          stream.lineEnd();
+                          stream.lineStart();
+                          stream.point(t4[0][0], t4[0][1], 3);
+                        }
+                      }
+                    }
+                    if (v2 && (!point0 || !pointEqual(point0, point1))) {
+                      stream.point(point1[0], point1[1]);
+                    }
+                    point0 = point1, v0 = v2, c0 = c2;
+                  },
+                  lineEnd: function() {
+                    if (v0) stream.lineEnd();
+                    point0 = null;
+                  },
+                  // Rejoin first and last segments if there were intersections and the first
+                  // and last points were visible.
+                  clean: function() {
+                    return clean | (v00 && v0) << 1;
+                  }
+                };
+              }
+              function intersect(a2, b2, two) {
+                var pa2 = cartesian(a2), pb2 = cartesian(b2);
+                var n1 = [1, 0, 0], n2 = cartesianCross(pa2, pb2), n2n2 = cartesianDot(n2, n2), n1n2 = n2[0], determinant2 = n2n2 - n1n2 * n1n2;
+                if (!determinant2) return !two && a2;
+                var c1 = cr * n2n2 / determinant2, c2 = -cr * n1n2 / determinant2, n1xn2 = cartesianCross(n1, n2), A5 = cartesianScale(n1, c1), B22 = cartesianScale(n2, c2);
+                cartesianAddInPlace(A5, B22);
+                var u2 = n1xn2, w2 = cartesianDot(A5, u2), uu = cartesianDot(u2, u2), t22 = w2 * w2 - uu * (cartesianDot(A5, A5) - 1);
+                if (t22 < 0) return;
+                var t4 = sqrt(t22), q2 = cartesianScale(u2, (-w2 - t4) / uu);
+                cartesianAddInPlace(q2, A5);
+                q2 = spherical(q2);
+                if (!two) return q2;
+                var lambda02 = a2[0], lambda12 = b2[0], phi02 = a2[1], phi12 = b2[1], z2;
+                if (lambda12 < lambda02) z2 = lambda02, lambda02 = lambda12, lambda12 = z2;
+                var delta2 = lambda12 - lambda02, polar = abs(delta2 - pi2) < epsilon, meridian = polar || delta2 < epsilon;
+                if (!polar && phi12 < phi02) z2 = phi02, phi02 = phi12, phi12 = z2;
+                if (meridian ? polar ? phi02 + phi12 > 0 ^ q2[1] < (abs(q2[0] - lambda02) < epsilon ? phi02 : phi12) : phi02 <= q2[1] && q2[1] <= phi12 : delta2 > pi2 ^ (lambda02 <= q2[0] && q2[0] <= lambda12)) {
+                  var q1 = cartesianScale(u2, (-w2 + t4) / uu);
+                  cartesianAddInPlace(q1, A5);
+                  return [q2, spherical(q1)];
+                }
+              }
+              function code(lambda, phi) {
+                var r2 = smallRadius ? radius : pi2 - radius, code2 = 0;
+                if (lambda < -r2) code2 |= 1;
+                else if (lambda > r2) code2 |= 2;
+                if (phi < -r2) code2 |= 4;
+                else if (phi > r2) code2 |= 8;
+                return code2;
+              }
+              return clip(visible, clipLine2, interpolate2, smallRadius ? [0, -radius] : [-pi2, radius - pi2]);
             }
-            parts[k2] = parts[k2] || [];
-            parts[k2].push(segment[0]);
-            if (segment[1] !== points[j + 1] || j === len2 - 2) {
-              parts[k2].push(segment[1]);
-              k2++;
+            function clipLine(a2, b2, x02, y02, x12, y12) {
+              var ax = a2[0], ay = a2[1], bx = b2[0], by = b2[1], t02 = 0, t12 = 1, dx = bx - ax, dy = by - ay, r2;
+              r2 = x02 - ax;
+              if (!dx && r2 > 0) return;
+              r2 /= dx;
+              if (dx < 0) {
+                if (r2 < t02) return;
+                if (r2 < t12) t12 = r2;
+              } else if (dx > 0) {
+                if (r2 > t12) return;
+                if (r2 > t02) t02 = r2;
+              }
+              r2 = x12 - ax;
+              if (!dx && r2 < 0) return;
+              r2 /= dx;
+              if (dx < 0) {
+                if (r2 > t12) return;
+                if (r2 > t02) t02 = r2;
+              } else if (dx > 0) {
+                if (r2 < t02) return;
+                if (r2 < t12) t12 = r2;
+              }
+              r2 = y02 - ay;
+              if (!dy && r2 > 0) return;
+              r2 /= dy;
+              if (dy < 0) {
+                if (r2 < t02) return;
+                if (r2 < t12) t12 = r2;
+              } else if (dy > 0) {
+                if (r2 > t12) return;
+                if (r2 > t02) t02 = r2;
+              }
+              r2 = y12 - ay;
+              if (!dy && r2 < 0) return;
+              r2 /= dy;
+              if (dy < 0) {
+                if (r2 > t12) return;
+                if (r2 > t02) t02 = r2;
+              } else if (dy > 0) {
+                if (r2 < t02) return;
+                if (r2 < t12) t12 = r2;
+              }
+              if (t02 > 0) a2[0] = ax + t02 * dx, a2[1] = ay + t02 * dy;
+              if (t12 < 1) b2[0] = ax + t12 * dx, b2[1] = ay + t12 * dy;
+              return true;
             }
-          }
-        }
-      },
-      // simplify each clipped part of the polyline for performance
-      _simplifyPoints: function() {
-        var parts = this._parts, tolerance = this.options.smoothFactor;
-        for (var i = 0, len = parts.length; i < len; i++) {
-          parts[i] = simplify(parts[i], tolerance);
-        }
-      },
-      _update: function() {
-        if (!this._map) {
-          return;
-        }
-        this._clipPoints();
-        this._simplifyPoints();
-        this._updatePath();
-      },
-      _updatePath: function() {
-        this._renderer._updatePoly(this);
-      },
-      // Needed by the `Canvas` renderer for interactivity
-      _containsPoint: function(p2, closed) {
-        var i, j, k2, len, len2, part, w2 = this._clickTolerance();
-        if (!this._pxBounds || !this._pxBounds.contains(p2)) {
-          return false;
-        }
-        for (i = 0, len = this._parts.length; i < len; i++) {
-          part = this._parts[i];
-          for (j = 0, len2 = part.length, k2 = len2 - 1; j < len2; k2 = j++) {
-            if (!closed && j === 0) {
-              continue;
+            var clipMax = 1e9, clipMin = -1e9;
+            function clipRectangle(x02, y02, x12, y12) {
+              function visible(x2, y2) {
+                return x02 <= x2 && x2 <= x12 && y02 <= y2 && y2 <= y12;
+              }
+              function interpolate2(from, to, direction, stream) {
+                var a2 = 0, a1 = 0;
+                if (from == null || (a2 = corner(from, direction)) !== (a1 = corner(to, direction)) || comparePoint(from, to) < 0 ^ direction > 0) {
+                  do
+                    stream.point(a2 === 0 || a2 === 3 ? x02 : x12, a2 > 1 ? y12 : y02);
+                  while ((a2 = (a2 + direction + 4) % 4) !== a1);
+                } else {
+                  stream.point(to[0], to[1]);
+                }
+              }
+              function corner(p2, direction) {
+                return abs(p2[0] - x02) < epsilon ? direction > 0 ? 0 : 3 : abs(p2[0] - x12) < epsilon ? direction > 0 ? 2 : 1 : abs(p2[1] - y02) < epsilon ? direction > 0 ? 1 : 0 : direction > 0 ? 3 : 2;
+              }
+              function compareIntersection2(a2, b2) {
+                return comparePoint(a2.x, b2.x);
+              }
+              function comparePoint(a2, b2) {
+                var ca2 = corner(a2, 1), cb2 = corner(b2, 1);
+                return ca2 !== cb2 ? ca2 - cb2 : ca2 === 0 ? b2[1] - a2[1] : ca2 === 1 ? a2[0] - b2[0] : ca2 === 2 ? a2[1] - b2[1] : b2[0] - a2[0];
+              }
+              return function(stream) {
+                var activeStream = stream, bufferStream = clipBuffer(), segments, polygon, ring, x__, y__, v__, x_, y_, v_, first, clean;
+                var clipStream = {
+                  point,
+                  lineStart,
+                  lineEnd,
+                  polygonStart,
+                  polygonEnd
+                };
+                function point(x2, y2) {
+                  if (visible(x2, y2)) activeStream.point(x2, y2);
+                }
+                function polygonInside() {
+                  var winding = 0;
+                  for (var i2 = 0, n2 = polygon.length; i2 < n2; ++i2) {
+                    for (var ring2 = polygon[i2], j2 = 1, m2 = ring2.length, point2 = ring2[0], a0, a1, b0 = point2[0], b1 = point2[1]; j2 < m2; ++j2) {
+                      a0 = b0, a1 = b1, point2 = ring2[j2], b0 = point2[0], b1 = point2[1];
+                      if (a1 <= y12) {
+                        if (b1 > y12 && (b0 - a0) * (y12 - a1) > (b1 - a1) * (x02 - a0)) ++winding;
+                      } else {
+                        if (b1 <= y12 && (b0 - a0) * (y12 - a1) < (b1 - a1) * (x02 - a0)) --winding;
+                      }
+                    }
+                  }
+                  return winding;
+                }
+                function polygonStart() {
+                  activeStream = bufferStream, segments = [], polygon = [], clean = true;
+                }
+                function polygonEnd() {
+                  var startInside = polygonInside(), cleanInside = clean && startInside, visible2 = (segments = d3Array.merge(segments)).length;
+                  if (cleanInside || visible2) {
+                    stream.polygonStart();
+                    if (cleanInside) {
+                      stream.lineStart();
+                      interpolate2(null, null, 1, stream);
+                      stream.lineEnd();
+                    }
+                    if (visible2) {
+                      clipRejoin(segments, compareIntersection2, startInside, interpolate2, stream);
+                    }
+                    stream.polygonEnd();
+                  }
+                  activeStream = stream, segments = polygon = ring = null;
+                }
+                function lineStart() {
+                  clipStream.point = linePoint2;
+                  if (polygon) polygon.push(ring = []);
+                  first = true;
+                  v_ = false;
+                  x_ = y_ = NaN;
+                }
+                function lineEnd() {
+                  if (segments) {
+                    linePoint2(x__, y__);
+                    if (v__ && v_) bufferStream.rejoin();
+                    segments.push(bufferStream.result());
+                  }
+                  clipStream.point = point;
+                  if (v_) activeStream.lineEnd();
+                }
+                function linePoint2(x2, y2) {
+                  var v2 = visible(x2, y2);
+                  if (polygon) ring.push([x2, y2]);
+                  if (first) {
+                    x__ = x2, y__ = y2, v__ = v2;
+                    first = false;
+                    if (v2) {
+                      activeStream.lineStart();
+                      activeStream.point(x2, y2);
+                    }
+                  } else {
+                    if (v2 && v_) activeStream.point(x2, y2);
+                    else {
+                      var a2 = [x_ = Math.max(clipMin, Math.min(clipMax, x_)), y_ = Math.max(clipMin, Math.min(clipMax, y_))], b2 = [x2 = Math.max(clipMin, Math.min(clipMax, x2)), y2 = Math.max(clipMin, Math.min(clipMax, y2))];
+                      if (clipLine(a2, b2, x02, y02, x12, y12)) {
+                        if (!v_) {
+                          activeStream.lineStart();
+                          activeStream.point(a2[0], a2[1]);
+                        }
+                        activeStream.point(b2[0], b2[1]);
+                        if (!v2) activeStream.lineEnd();
+                        clean = false;
+                      } else if (v2) {
+                        activeStream.lineStart();
+                        activeStream.point(x2, y2);
+                        clean = false;
+                      }
+                    }
+                  }
+                  x_ = x2, y_ = y2, v_ = v2;
+                }
+                return clipStream;
+              };
             }
-            if (pointToSegmentDistance(p2, part[k2], part[j]) <= w2) {
-              return true;
+            function extent() {
+              var x02 = 0, y02 = 0, x12 = 960, y12 = 500, cache, cacheStream, clip2;
+              return clip2 = {
+                stream: function(stream) {
+                  return cache && cacheStream === stream ? cache : cache = clipRectangle(x02, y02, x12, y12)(cacheStream = stream);
+                },
+                extent: function(_2) {
+                  return arguments.length ? (x02 = +_2[0][0], y02 = +_2[0][1], x12 = +_2[1][0], y12 = +_2[1][1], cache = cacheStream = null, clip2) : [[x02, y02], [x12, y12]];
+                }
+              };
             }
-          }
-        }
-        return false;
-      }
-    });
-    function polyline(latlngs, options) {
-      return new Polyline(latlngs, options);
-    }
-    Polyline._flat = _flat;
-    var Polygon = Polyline.extend({
-      options: {
-        fill: true
-      },
-      isEmpty: function() {
-        return !this._latlngs.length || !this._latlngs[0].length;
-      },
-      // @method getCenter(): LatLng
-      // Returns the center ([centroid](http://en.wikipedia.org/wiki/Centroid)) of the Polygon.
-      getCenter: function() {
-        if (!this._map) {
-          throw new Error("Must add layer to map before using getCenter()");
-        }
-        return polygonCenter(this._defaultShape(), this._map.options.crs);
-      },
-      _convertLatLngs: function(latlngs) {
-        var result = Polyline.prototype._convertLatLngs.call(this, latlngs), len = result.length;
-        if (len >= 2 && result[0] instanceof LatLng && result[0].equals(result[len - 1])) {
-          result.pop();
-        }
-        return result;
-      },
-      _setLatLngs: function(latlngs) {
-        Polyline.prototype._setLatLngs.call(this, latlngs);
-        if (isFlat(this._latlngs)) {
-          this._latlngs = [this._latlngs];
-        }
-      },
-      _defaultShape: function() {
-        return isFlat(this._latlngs[0]) ? this._latlngs[0] : this._latlngs[0][0];
-      },
-      _clipPoints: function() {
-        var bounds = this._renderer._bounds, w2 = this.options.weight, p2 = new Point(w2, w2);
-        bounds = new Bounds(bounds.min.subtract(p2), bounds.max.add(p2));
-        this._parts = [];
-        if (!this._pxBounds || !this._pxBounds.intersects(bounds)) {
-          return;
-        }
-        if (this.options.noClip) {
-          this._parts = this._rings;
-          return;
-        }
-        for (var i = 0, len = this._rings.length, clipped; i < len; i++) {
-          clipped = clipPolygon(this._rings[i], bounds, true);
-          if (clipped.length) {
-            this._parts.push(clipped);
-          }
-        }
-      },
-      _updatePath: function() {
-        this._renderer._updatePoly(this, true);
-      },
-      // Needed by the `Canvas` renderer for interactivity
-      _containsPoint: function(p2) {
-        var inside = false, part, p1, p22, i, j, k2, len, len2;
-        if (!this._pxBounds || !this._pxBounds.contains(p2)) {
-          return false;
-        }
-        for (i = 0, len = this._parts.length; i < len; i++) {
-          part = this._parts[i];
-          for (j = 0, len2 = part.length, k2 = len2 - 1; j < len2; k2 = j++) {
-            p1 = part[j];
-            p22 = part[k2];
-            if (p1.y > p2.y !== p22.y > p2.y && p2.x < (p22.x - p1.x) * (p2.y - p1.y) / (p22.y - p1.y) + p1.x) {
-              inside = !inside;
+            var lengthSum = adder(), lambda0$2, sinPhi0$1, cosPhi0$1;
+            var lengthStream = {
+              sphere: noop2,
+              point: noop2,
+              lineStart: lengthLineStart,
+              lineEnd: noop2,
+              polygonStart: noop2,
+              polygonEnd: noop2
+            };
+            function lengthLineStart() {
+              lengthStream.point = lengthPointFirst;
+              lengthStream.lineEnd = lengthLineEnd;
             }
-          }
-        }
-        return inside || Polyline.prototype._containsPoint.call(this, p2, true);
-      }
-    });
-    function polygon(latlngs, options) {
-      return new Polygon(latlngs, options);
-    }
-    var GeoJSON = FeatureGroup.extend({
-      /* @section
-       * @aka GeoJSON options
-       *
-       * @option pointToLayer: Function = *
-       * A `Function` defining how GeoJSON points spawn Leaflet layers. It is internally
-       * called when data is added, passing the GeoJSON point feature and its `LatLng`.
-       * The default is to spawn a default `Marker`:
-       * ```js
-       * function(geoJsonPoint, latlng) {
-       * 	return L.marker(latlng);
-       * }
-       * ```
-       *
-       * @option style: Function = *
-       * A `Function` defining the `Path options` for styling GeoJSON lines and polygons,
-       * called internally when data is added.
-       * The default value is to not override any defaults:
-       * ```js
-       * function (geoJsonFeature) {
-       * 	return {}
-       * }
-       * ```
-       *
-       * @option onEachFeature: Function = *
-       * A `Function` that will be called once for each created `Feature`, after it has
-       * been created and styled. Useful for attaching events and popups to features.
-       * The default is to do nothing with the newly created layers:
-       * ```js
-       * function (feature, layer) {}
-       * ```
-       *
-       * @option filter: Function = *
-       * A `Function` that will be used to decide whether to include a feature or not.
-       * The default is to include all features:
-       * ```js
-       * function (geoJsonFeature) {
-       * 	return true;
-       * }
-       * ```
-       * Note: dynamically changing the `filter` option will have effect only on newly
-       * added data. It will _not_ re-evaluate already included features.
-       *
-       * @option coordsToLatLng: Function = *
-       * A `Function` that will be used for converting GeoJSON coordinates to `LatLng`s.
-       * The default is the `coordsToLatLng` static method.
-       *
-       * @option markersInheritOptions: Boolean = false
-       * Whether default Markers for "Point" type Features inherit from group options.
-       */
-      initialize: function(geojson, options) {
-        setOptions2(this, options);
-        this._layers = {};
-        if (geojson) {
-          this.addData(geojson);
-        }
-      },
-      // @method addData( <GeoJSON> data ): this
-      // Adds a GeoJSON object to the layer.
-      addData: function(geojson) {
-        var features = isArray2(geojson) ? geojson : geojson.features, i, len, feature;
-        if (features) {
-          for (i = 0, len = features.length; i < len; i++) {
-            feature = features[i];
-            if (feature.geometries || feature.geometry || feature.features || feature.coordinates) {
-              this.addData(feature);
+            function lengthLineEnd() {
+              lengthStream.point = lengthStream.lineEnd = noop2;
             }
-          }
-          return this;
-        }
-        var options = this.options;
-        if (options.filter && !options.filter(geojson)) {
-          return this;
-        }
-        var layer = geometryToLayer(geojson, options);
-        if (!layer) {
-          return this;
-        }
-        layer.feature = asFeature(geojson);
-        layer.defaultOptions = layer.options;
-        this.resetStyle(layer);
-        if (options.onEachFeature) {
-          options.onEachFeature(geojson, layer);
-        }
-        return this.addLayer(layer);
-      },
-      // @method resetStyle( <Path> layer? ): this
-      // Resets the given vector layer's style to the original GeoJSON style, useful for resetting style after hover events.
-      // If `layer` is omitted, the style of all features in the current layer is reset.
-      resetStyle: function(layer) {
-        if (layer === void 0) {
-          return this.eachLayer(this.resetStyle, this);
-        }
-        layer.options = extend({}, layer.defaultOptions);
-        this._setLayerStyle(layer, this.options.style);
-        return this;
-      },
-      // @method setStyle( <Function> style ): this
-      // Changes styles of GeoJSON vector layers with the given style function.
-      setStyle: function(style2) {
-        return this.eachLayer(function(layer) {
-          this._setLayerStyle(layer, style2);
-        }, this);
-      },
-      _setLayerStyle: function(layer, style2) {
-        if (layer.setStyle) {
-          if (typeof style2 === "function") {
-            style2 = style2(layer.feature);
-          }
-          layer.setStyle(style2);
-        }
-      }
-    });
-    function geometryToLayer(geojson, options) {
-      var geometry = geojson.type === "Feature" ? geojson.geometry : geojson, coords = geometry ? geometry.coordinates : null, layers2 = [], pointToLayer = options && options.pointToLayer, _coordsToLatLng = options && options.coordsToLatLng || coordsToLatLng, latlng, latlngs, i, len;
-      if (!coords && !geometry) {
-        return null;
-      }
-      switch (geometry.type) {
-        case "Point":
-          latlng = _coordsToLatLng(coords);
-          return _pointToLayer(pointToLayer, geojson, latlng, options);
-        case "MultiPoint":
-          for (i = 0, len = coords.length; i < len; i++) {
-            latlng = _coordsToLatLng(coords[i]);
-            layers2.push(_pointToLayer(pointToLayer, geojson, latlng, options));
-          }
-          return new FeatureGroup(layers2);
-        case "LineString":
-        case "MultiLineString":
-          latlngs = coordsToLatLngs(coords, geometry.type === "LineString" ? 0 : 1, _coordsToLatLng);
-          return new Polyline(latlngs, options);
-        case "Polygon":
-        case "MultiPolygon":
-          latlngs = coordsToLatLngs(coords, geometry.type === "Polygon" ? 1 : 2, _coordsToLatLng);
-          return new Polygon(latlngs, options);
-        case "GeometryCollection":
-          for (i = 0, len = geometry.geometries.length; i < len; i++) {
-            var geoLayer = geometryToLayer({
-              geometry: geometry.geometries[i],
-              type: "Feature",
-              properties: geojson.properties
-            }, options);
-            if (geoLayer) {
-              layers2.push(geoLayer);
-            }
-          }
-          return new FeatureGroup(layers2);
-        case "FeatureCollection":
-          for (i = 0, len = geometry.features.length; i < len; i++) {
-            var featureLayer = geometryToLayer(geometry.features[i], options);
-            if (featureLayer) {
-              layers2.push(featureLayer);
-            }
-          }
-          return new FeatureGroup(layers2);
-        default:
-          throw new Error("Invalid GeoJSON object.");
-      }
-    }
-    function _pointToLayer(pointToLayerFn, geojson, latlng, options) {
-      return pointToLayerFn ? pointToLayerFn(geojson, latlng) : new Marker2(latlng, options && options.markersInheritOptions && options);
-    }
-    function coordsToLatLng(coords) {
-      return new LatLng(coords[1], coords[0], coords[2]);
-    }
-    function coordsToLatLngs(coords, levelsDeep, _coordsToLatLng) {
-      var latlngs = [];
-      for (var i = 0, len = coords.length, latlng; i < len; i++) {
-        latlng = levelsDeep ? coordsToLatLngs(coords[i], levelsDeep - 1, _coordsToLatLng) : (_coordsToLatLng || coordsToLatLng)(coords[i]);
-        latlngs.push(latlng);
-      }
-      return latlngs;
-    }
-    function latLngToCoords(latlng, precision) {
-      latlng = toLatLng(latlng);
-      return latlng.alt !== void 0 ? [formatNum(latlng.lng, precision), formatNum(latlng.lat, precision), formatNum(latlng.alt, precision)] : [formatNum(latlng.lng, precision), formatNum(latlng.lat, precision)];
-    }
-    function latLngsToCoords(latlngs, levelsDeep, closed, precision) {
-      var coords = [];
-      for (var i = 0, len = latlngs.length; i < len; i++) {
-        coords.push(levelsDeep ? latLngsToCoords(latlngs[i], isFlat(latlngs[i]) ? 0 : levelsDeep - 1, closed, precision) : latLngToCoords(latlngs[i], precision));
-      }
-      if (!levelsDeep && closed && coords.length > 0) {
-        coords.push(coords[0].slice());
-      }
-      return coords;
-    }
-    function getFeature(layer, newGeometry) {
-      return layer.feature ? extend({}, layer.feature, { geometry: newGeometry }) : asFeature(newGeometry);
-    }
-    function asFeature(geojson) {
-      if (geojson.type === "Feature" || geojson.type === "FeatureCollection") {
-        return geojson;
-      }
-      return {
-        type: "Feature",
-        properties: {},
-        geometry: geojson
-      };
-    }
-    var PointToGeoJSON = {
-      toGeoJSON: function(precision) {
-        return getFeature(this, {
-          type: "Point",
-          coordinates: latLngToCoords(this.getLatLng(), precision)
-        });
-      }
-    };
-    Marker2.include(PointToGeoJSON);
-    Circle.include(PointToGeoJSON);
-    CircleMarker.include(PointToGeoJSON);
-    Polyline.include({
-      toGeoJSON: function(precision) {
-        var multi = !isFlat(this._latlngs);
-        var coords = latLngsToCoords(this._latlngs, multi ? 1 : 0, false, precision);
-        return getFeature(this, {
-          type: (multi ? "Multi" : "") + "LineString",
-          coordinates: coords
-        });
-      }
-    });
-    Polygon.include({
-      toGeoJSON: function(precision) {
-        var holes = !isFlat(this._latlngs), multi = holes && !isFlat(this._latlngs[0]);
-        var coords = latLngsToCoords(this._latlngs, multi ? 2 : holes ? 1 : 0, true, precision);
-        if (!holes) {
-          coords = [coords];
-        }
-        return getFeature(this, {
-          type: (multi ? "Multi" : "") + "Polygon",
-          coordinates: coords
-        });
-      }
-    });
-    LayerGroup.include({
-      toMultiPoint: function(precision) {
-        var coords = [];
-        this.eachLayer(function(layer) {
-          coords.push(layer.toGeoJSON(precision).geometry.coordinates);
-        });
-        return getFeature(this, {
-          type: "MultiPoint",
-          coordinates: coords
-        });
-      },
-      // @method toGeoJSON(precision?: Number|false): Object
-      // Coordinates values are rounded with [`formatNum`](#util-formatnum) function with given `precision`.
-      // Returns a [`GeoJSON`](https://en.wikipedia.org/wiki/GeoJSON) representation of the layer group (as a GeoJSON `FeatureCollection`, `GeometryCollection`, or `MultiPoint`).
-      toGeoJSON: function(precision) {
-        var type = this.feature && this.feature.geometry && this.feature.geometry.type;
-        if (type === "MultiPoint") {
-          return this.toMultiPoint(precision);
-        }
-        var isGeometryCollection = type === "GeometryCollection", jsons = [];
-        this.eachLayer(function(layer) {
-          if (layer.toGeoJSON) {
-            var json = layer.toGeoJSON(precision);
-            if (isGeometryCollection) {
-              jsons.push(json.geometry);
-            } else {
-              var feature = asFeature(json);
-              if (feature.type === "FeatureCollection") {
-                jsons.push.apply(jsons, feature.features);
-              } else {
-                jsons.push(feature);
+            function lengthPointFirst(lambda, phi) {
+              lambda *= radians2, phi *= radians2;
+              lambda0$2 = lambda, sinPhi0$1 = sin(phi), cosPhi0$1 = cos(phi);
+              lengthStream.point = lengthPoint;
+            }
+            function lengthPoint(lambda, phi) {
+              lambda *= radians2, phi *= radians2;
+              var sinPhi = sin(phi), cosPhi = cos(phi), delta = abs(lambda - lambda0$2), cosDelta = cos(delta), sinDelta = sin(delta), x2 = cosPhi * sinDelta, y2 = cosPhi0$1 * sinPhi - sinPhi0$1 * cosPhi * cosDelta, z2 = sinPhi0$1 * sinPhi + cosPhi0$1 * cosPhi * cosDelta;
+              lengthSum.add(atan2(sqrt(x2 * x2 + y2 * y2), z2));
+              lambda0$2 = lambda, sinPhi0$1 = sinPhi, cosPhi0$1 = cosPhi;
+            }
+            function length2(object2) {
+              lengthSum.reset();
+              geoStream(object2, lengthStream);
+              return +lengthSum;
+            }
+            var coordinates = [null, null], object = { type: "LineString", coordinates };
+            function distance2(a2, b2) {
+              coordinates[0] = a2;
+              coordinates[1] = b2;
+              return length2(object);
+            }
+            var containsObjectType = {
+              Feature: function(object2, point) {
+                return containsGeometry(object2.geometry, point);
+              },
+              FeatureCollection: function(object2, point) {
+                var features = object2.features, i2 = -1, n2 = features.length;
+                while (++i2 < n2) if (containsGeometry(features[i2].geometry, point)) return true;
+                return false;
               }
+            };
+            var containsGeometryType = {
+              Sphere: function() {
+                return true;
+              },
+              Point: function(object2, point) {
+                return containsPoint(object2.coordinates, point);
+              },
+              MultiPoint: function(object2, point) {
+                var coordinates2 = object2.coordinates, i2 = -1, n2 = coordinates2.length;
+                while (++i2 < n2) if (containsPoint(coordinates2[i2], point)) return true;
+                return false;
+              },
+              LineString: function(object2, point) {
+                return containsLine(object2.coordinates, point);
+              },
+              MultiLineString: function(object2, point) {
+                var coordinates2 = object2.coordinates, i2 = -1, n2 = coordinates2.length;
+                while (++i2 < n2) if (containsLine(coordinates2[i2], point)) return true;
+                return false;
+              },
+              Polygon: function(object2, point) {
+                return containsPolygon(object2.coordinates, point);
+              },
+              MultiPolygon: function(object2, point) {
+                var coordinates2 = object2.coordinates, i2 = -1, n2 = coordinates2.length;
+                while (++i2 < n2) if (containsPolygon(coordinates2[i2], point)) return true;
+                return false;
+              },
+              GeometryCollection: function(object2, point) {
+                var geometries = object2.geometries, i2 = -1, n2 = geometries.length;
+                while (++i2 < n2) if (containsGeometry(geometries[i2], point)) return true;
+                return false;
+              }
+            };
+            function containsGeometry(geometry2, point) {
+              return geometry2 && containsGeometryType.hasOwnProperty(geometry2.type) ? containsGeometryType[geometry2.type](geometry2, point) : false;
             }
-          }
-        });
-        if (isGeometryCollection) {
-          return getFeature(this, {
-            geometries: jsons,
-            type: "GeometryCollection"
-          });
-        }
-        return {
-          type: "FeatureCollection",
-          features: jsons
-        };
-      }
-    });
-    function geoJSON(geojson, options) {
-      return new GeoJSON(geojson, options);
-    }
-    var geoJson = geoJSON;
-    var ImageOverlay = Layer.extend({
-      // @section
-      // @aka ImageOverlay options
-      options: {
-        // @option opacity: Number = 1.0
-        // The opacity of the image overlay.
-        opacity: 1,
-        // @option alt: String = ''
-        // Text for the `alt` attribute of the image (useful for accessibility).
-        alt: "",
-        // @option interactive: Boolean = false
-        // If `true`, the image overlay will emit [mouse events](#interactive-layer) when clicked or hovered.
-        interactive: false,
-        // @option crossOrigin: Boolean|String = false
-        // Whether the crossOrigin attribute will be added to the image.
-        // If a String is provided, the image will have its crossOrigin attribute set to the String provided. This is needed if you want to access image pixel data.
-        // Refer to [CORS Settings](https://developer.mozilla.org/en-US/docs/Web/HTML/CORS_settings_attributes) for valid String values.
-        crossOrigin: false,
-        // @option errorOverlayUrl: String = ''
-        // URL to the overlay image to show in place of the overlay that failed to load.
-        errorOverlayUrl: "",
-        // @option zIndex: Number = 1
-        // The explicit [zIndex](https://developer.mozilla.org/docs/Web/CSS/CSS_Positioning/Understanding_z_index) of the overlay layer.
-        zIndex: 1,
-        // @option className: String = ''
-        // A custom class name to assign to the image. Empty by default.
-        className: ""
-      },
-      initialize: function(url, bounds, options) {
-        this._url = url;
-        this._bounds = toLatLngBounds(bounds);
-        setOptions2(this, options);
-      },
-      onAdd: function() {
-        if (!this._image) {
-          this._initImage();
-          if (this.options.opacity < 1) {
-            this._updateOpacity();
-          }
-        }
-        if (this.options.interactive) {
-          addClass(this._image, "leaflet-interactive");
-          this.addInteractiveTarget(this._image);
-        }
-        this.getPane().appendChild(this._image);
-        this._reset();
-      },
-      onRemove: function() {
-        remove(this._image);
-        if (this.options.interactive) {
-          this.removeInteractiveTarget(this._image);
-        }
-      },
-      // @method setOpacity(opacity: Number): this
-      // Sets the opacity of the overlay.
-      setOpacity: function(opacity) {
-        this.options.opacity = opacity;
-        if (this._image) {
-          this._updateOpacity();
-        }
-        return this;
-      },
-      setStyle: function(styleOpts) {
-        if (styleOpts.opacity) {
-          this.setOpacity(styleOpts.opacity);
-        }
-        return this;
-      },
-      // @method bringToFront(): this
-      // Brings the layer to the top of all overlays.
-      bringToFront: function() {
-        if (this._map) {
-          toFront(this._image);
-        }
-        return this;
-      },
-      // @method bringToBack(): this
-      // Brings the layer to the bottom of all overlays.
-      bringToBack: function() {
-        if (this._map) {
-          toBack(this._image);
-        }
-        return this;
-      },
-      // @method setUrl(url: String): this
-      // Changes the URL of the image.
-      setUrl: function(url) {
-        this._url = url;
-        if (this._image) {
-          this._image.src = url;
-        }
-        return this;
-      },
-      // @method setBounds(bounds: LatLngBounds): this
-      // Update the bounds that this ImageOverlay covers
-      setBounds: function(bounds) {
-        this._bounds = toLatLngBounds(bounds);
-        if (this._map) {
-          this._reset();
-        }
-        return this;
-      },
-      getEvents: function() {
-        var events = {
-          zoom: this._reset,
-          viewreset: this._reset
-        };
-        if (this._zoomAnimated) {
-          events.zoomanim = this._animateZoom;
-        }
-        return events;
-      },
-      // @method setZIndex(value: Number): this
-      // Changes the [zIndex](#imageoverlay-zindex) of the image overlay.
-      setZIndex: function(value) {
-        this.options.zIndex = value;
-        this._updateZIndex();
-        return this;
-      },
-      // @method getBounds(): LatLngBounds
-      // Get the bounds that this ImageOverlay covers
-      getBounds: function() {
-        return this._bounds;
-      },
-      // @method getElement(): HTMLElement
-      // Returns the instance of [`HTMLImageElement`](https://developer.mozilla.org/docs/Web/API/HTMLImageElement)
-      // used by this overlay.
-      getElement: function() {
-        return this._image;
-      },
-      _initImage: function() {
-        var wasElementSupplied = this._url.tagName === "IMG";
-        var img = this._image = wasElementSupplied ? this._url : create$1("img");
-        addClass(img, "leaflet-image-layer");
-        if (this._zoomAnimated) {
-          addClass(img, "leaflet-zoom-animated");
-        }
-        if (this.options.className) {
-          addClass(img, this.options.className);
-        }
-        img.onselectstart = falseFn;
-        img.onmousemove = falseFn;
-        img.onload = bind(this.fire, this, "load");
-        img.onerror = bind(this._overlayOnError, this, "error");
-        if (this.options.crossOrigin || this.options.crossOrigin === "") {
-          img.crossOrigin = this.options.crossOrigin === true ? "" : this.options.crossOrigin;
-        }
-        if (this.options.zIndex) {
-          this._updateZIndex();
-        }
-        if (wasElementSupplied) {
-          this._url = img.src;
-          return;
-        }
-        img.src = this._url;
-        img.alt = this.options.alt;
-      },
-      _animateZoom: function(e) {
-        var scale2 = this._map.getZoomScale(e.zoom), offset = this._map._latLngBoundsToNewLayerBounds(this._bounds, e.zoom, e.center).min;
-        setTransform(this._image, offset, scale2);
-      },
-      _reset: function() {
-        var image = this._image, bounds = new Bounds(
-          this._map.latLngToLayerPoint(this._bounds.getNorthWest()),
-          this._map.latLngToLayerPoint(this._bounds.getSouthEast())
-        ), size = bounds.getSize();
-        setPosition(image, bounds.min);
-        image.style.width = size.x + "px";
-        image.style.height = size.y + "px";
-      },
-      _updateOpacity: function() {
-        setOpacity(this._image, this.options.opacity);
-      },
-      _updateZIndex: function() {
-        if (this._image && this.options.zIndex !== void 0 && this.options.zIndex !== null) {
-          this._image.style.zIndex = this.options.zIndex;
-        }
-      },
-      _overlayOnError: function() {
-        this.fire("error");
-        var errorUrl = this.options.errorOverlayUrl;
-        if (errorUrl && this._url !== errorUrl) {
-          this._url = errorUrl;
-          this._image.src = errorUrl;
-        }
-      },
-      // @method getCenter(): LatLng
-      // Returns the center of the ImageOverlay.
-      getCenter: function() {
-        return this._bounds.getCenter();
-      }
-    });
-    var imageOverlay = function(url, bounds, options) {
-      return new ImageOverlay(url, bounds, options);
-    };
-    var VideoOverlay = ImageOverlay.extend({
-      // @section
-      // @aka VideoOverlay options
-      options: {
-        // @option autoplay: Boolean = true
-        // Whether the video starts playing automatically when loaded.
-        // On some browsers autoplay will only work with `muted: true`
-        autoplay: true,
-        // @option loop: Boolean = true
-        // Whether the video will loop back to the beginning when played.
-        loop: true,
-        // @option keepAspectRatio: Boolean = true
-        // Whether the video will save aspect ratio after the projection.
-        // Relevant for supported browsers. See [browser compatibility](https://developer.mozilla.org/en-US/docs/Web/CSS/object-fit)
-        keepAspectRatio: true,
-        // @option muted: Boolean = false
-        // Whether the video starts on mute when loaded.
-        muted: false,
-        // @option playsInline: Boolean = true
-        // Mobile browsers will play the video right where it is instead of open it up in fullscreen mode.
-        playsInline: true
-      },
-      _initImage: function() {
-        var wasElementSupplied = this._url.tagName === "VIDEO";
-        var vid = this._image = wasElementSupplied ? this._url : create$1("video");
-        addClass(vid, "leaflet-image-layer");
-        if (this._zoomAnimated) {
-          addClass(vid, "leaflet-zoom-animated");
-        }
-        if (this.options.className) {
-          addClass(vid, this.options.className);
-        }
-        vid.onselectstart = falseFn;
-        vid.onmousemove = falseFn;
-        vid.onloadeddata = bind(this.fire, this, "load");
-        if (wasElementSupplied) {
-          var sourceElements = vid.getElementsByTagName("source");
-          var sources = [];
-          for (var j = 0; j < sourceElements.length; j++) {
-            sources.push(sourceElements[j].src);
-          }
-          this._url = sourceElements.length > 0 ? sources : [vid.src];
-          return;
-        }
-        if (!isArray2(this._url)) {
-          this._url = [this._url];
-        }
-        if (!this.options.keepAspectRatio && Object.prototype.hasOwnProperty.call(vid.style, "objectFit")) {
-          vid.style["objectFit"] = "fill";
-        }
-        vid.autoplay = !!this.options.autoplay;
-        vid.loop = !!this.options.loop;
-        vid.muted = !!this.options.muted;
-        vid.playsInline = !!this.options.playsInline;
-        for (var i = 0; i < this._url.length; i++) {
-          var source = create$1("source");
-          source.src = this._url[i];
-          vid.appendChild(source);
-        }
-      }
-      // @method getElement(): HTMLVideoElement
-      // Returns the instance of [`HTMLVideoElement`](https://developer.mozilla.org/docs/Web/API/HTMLVideoElement)
-      // used by this overlay.
-    });
-    function videoOverlay(video, bounds, options) {
-      return new VideoOverlay(video, bounds, options);
-    }
-    var SVGOverlay = ImageOverlay.extend({
-      _initImage: function() {
-        var el2 = this._image = this._url;
-        addClass(el2, "leaflet-image-layer");
-        if (this._zoomAnimated) {
-          addClass(el2, "leaflet-zoom-animated");
-        }
-        if (this.options.className) {
-          addClass(el2, this.options.className);
-        }
-        el2.onselectstart = falseFn;
-        el2.onmousemove = falseFn;
-      }
-      // @method getElement(): SVGElement
-      // Returns the instance of [`SVGElement`](https://developer.mozilla.org/docs/Web/API/SVGElement)
-      // used by this overlay.
-    });
-    function svgOverlay(el2, bounds, options) {
-      return new SVGOverlay(el2, bounds, options);
-    }
-    var DivOverlay = Layer.extend({
-      // @section
-      // @aka DivOverlay options
-      options: {
-        // @option interactive: Boolean = false
-        // If true, the popup/tooltip will listen to the mouse events.
-        interactive: false,
-        // @option offset: Point = Point(0, 0)
-        // The offset of the overlay position.
-        offset: [0, 0],
-        // @option className: String = ''
-        // A custom CSS class name to assign to the overlay.
-        className: "",
-        // @option pane: String = undefined
-        // `Map pane` where the overlay will be added.
-        pane: void 0,
-        // @option content: String|HTMLElement|Function = ''
-        // Sets the HTML content of the overlay while initializing. If a function is passed the source layer will be
-        // passed to the function. The function should return a `String` or `HTMLElement` to be used in the overlay.
-        content: ""
-      },
-      initialize: function(options, source) {
-        if (options && (options instanceof LatLng || isArray2(options))) {
-          this._latlng = toLatLng(options);
-          setOptions2(this, source);
-        } else {
-          setOptions2(this, options);
-          this._source = source;
-        }
-        if (this.options.content) {
-          this._content = this.options.content;
-        }
-      },
-      // @method openOn(map: Map): this
-      // Adds the overlay to the map.
-      // Alternative to `map.openPopup(popup)`/`.openTooltip(tooltip)`.
-      openOn: function(map2) {
-        map2 = arguments.length ? map2 : this._source._map;
-        if (!map2.hasLayer(this)) {
-          map2.addLayer(this);
-        }
-        return this;
-      },
-      // @method close(): this
-      // Closes the overlay.
-      // Alternative to `map.closePopup(popup)`/`.closeTooltip(tooltip)`
-      // and `layer.closePopup()`/`.closeTooltip()`.
-      close: function() {
-        if (this._map) {
-          this._map.removeLayer(this);
-        }
-        return this;
-      },
-      // @method toggle(layer?: Layer): this
-      // Opens or closes the overlay bound to layer depending on its current state.
-      // Argument may be omitted only for overlay bound to layer.
-      // Alternative to `layer.togglePopup()`/`.toggleTooltip()`.
-      toggle: function(layer) {
-        if (this._map) {
-          this.close();
-        } else {
-          if (arguments.length) {
-            this._source = layer;
-          } else {
-            layer = this._source;
-          }
-          this._prepareOpen();
-          this.openOn(layer._map);
-        }
-        return this;
-      },
-      onAdd: function(map2) {
-        this._zoomAnimated = map2._zoomAnimated;
-        if (!this._container) {
-          this._initLayout();
-        }
-        if (map2._fadeAnimated) {
-          setOpacity(this._container, 0);
-        }
-        clearTimeout(this._removeTimeout);
-        this.getPane().appendChild(this._container);
-        this.update();
-        if (map2._fadeAnimated) {
-          setOpacity(this._container, 1);
-        }
-        this.bringToFront();
-        if (this.options.interactive) {
-          addClass(this._container, "leaflet-interactive");
-          this.addInteractiveTarget(this._container);
-        }
-      },
-      onRemove: function(map2) {
-        if (map2._fadeAnimated) {
-          setOpacity(this._container, 0);
-          this._removeTimeout = setTimeout(bind(remove, void 0, this._container), 200);
-        } else {
-          remove(this._container);
-        }
-        if (this.options.interactive) {
-          removeClass(this._container, "leaflet-interactive");
-          this.removeInteractiveTarget(this._container);
-        }
-      },
-      // @namespace DivOverlay
-      // @method getLatLng: LatLng
-      // Returns the geographical point of the overlay.
-      getLatLng: function() {
-        return this._latlng;
-      },
-      // @method setLatLng(latlng: LatLng): this
-      // Sets the geographical point where the overlay will open.
-      setLatLng: function(latlng) {
-        this._latlng = toLatLng(latlng);
-        if (this._map) {
-          this._updatePosition();
-          this._adjustPan();
-        }
-        return this;
-      },
-      // @method getContent: String|HTMLElement
-      // Returns the content of the overlay.
-      getContent: function() {
-        return this._content;
-      },
-      // @method setContent(htmlContent: String|HTMLElement|Function): this
-      // Sets the HTML content of the overlay. If a function is passed the source layer will be passed to the function.
-      // The function should return a `String` or `HTMLElement` to be used in the overlay.
-      setContent: function(content) {
-        this._content = content;
-        this.update();
-        return this;
-      },
-      // @method getElement: String|HTMLElement
-      // Returns the HTML container of the overlay.
-      getElement: function() {
-        return this._container;
-      },
-      // @method update: null
-      // Updates the overlay content, layout and position. Useful for updating the overlay after something inside changed, e.g. image loaded.
-      update: function() {
-        if (!this._map) {
-          return;
-        }
-        this._container.style.visibility = "hidden";
-        this._updateContent();
-        this._updateLayout();
-        this._updatePosition();
-        this._container.style.visibility = "";
-        this._adjustPan();
-      },
-      getEvents: function() {
-        var events = {
-          zoom: this._updatePosition,
-          viewreset: this._updatePosition
-        };
-        if (this._zoomAnimated) {
-          events.zoomanim = this._animateZoom;
-        }
-        return events;
-      },
-      // @method isOpen: Boolean
-      // Returns `true` when the overlay is visible on the map.
-      isOpen: function() {
-        return !!this._map && this._map.hasLayer(this);
-      },
-      // @method bringToFront: this
-      // Brings this overlay in front of other overlays (in the same map pane).
-      bringToFront: function() {
-        if (this._map) {
-          toFront(this._container);
-        }
-        return this;
-      },
-      // @method bringToBack: this
-      // Brings this overlay to the back of other overlays (in the same map pane).
-      bringToBack: function() {
-        if (this._map) {
-          toBack(this._container);
-        }
-        return this;
-      },
-      // prepare bound overlay to open: update latlng pos / content source (for FeatureGroup)
-      _prepareOpen: function(latlng) {
-        var source = this._source;
-        if (!source._map) {
-          return false;
-        }
-        if (source instanceof FeatureGroup) {
-          source = null;
-          var layers2 = this._source._layers;
-          for (var id2 in layers2) {
-            if (layers2[id2]._map) {
-              source = layers2[id2];
-              break;
+            function containsPoint(coordinates2, point) {
+              return distance2(coordinates2, point) === 0;
             }
-          }
-          if (!source) {
-            return false;
-          }
-          this._source = source;
-        }
-        if (!latlng) {
-          if (source.getCenter) {
-            latlng = source.getCenter();
-          } else if (source.getLatLng) {
-            latlng = source.getLatLng();
-          } else if (source.getBounds) {
-            latlng = source.getBounds().getCenter();
-          } else {
-            throw new Error("Unable to get source layer LatLng.");
-          }
-        }
-        this.setLatLng(latlng);
-        if (this._map) {
-          this.update();
-        }
-        return true;
-      },
-      _updateContent: function() {
-        if (!this._content) {
-          return;
-        }
-        var node = this._contentNode;
-        var content = typeof this._content === "function" ? this._content(this._source || this) : this._content;
-        if (typeof content === "string") {
-          node.innerHTML = content;
-        } else {
-          while (node.hasChildNodes()) {
-            node.removeChild(node.firstChild);
-          }
-          node.appendChild(content);
-        }
-        this.fire("contentupdate");
-      },
-      _updatePosition: function() {
-        if (!this._map) {
-          return;
-        }
-        var pos = this._map.latLngToLayerPoint(this._latlng), offset = toPoint(this.options.offset), anchor = this._getAnchor();
-        if (this._zoomAnimated) {
-          setPosition(this._container, pos.add(anchor));
-        } else {
-          offset = offset.add(pos).add(anchor);
-        }
-        var bottom = this._containerBottom = -offset.y, left = this._containerLeft = -Math.round(this._containerWidth / 2) + offset.x;
-        this._container.style.bottom = bottom + "px";
-        this._container.style.left = left + "px";
-      },
-      _getAnchor: function() {
-        return [0, 0];
-      }
-    });
-    Map2.include({
-      _initOverlay: function(OverlayClass, content, latlng, options) {
-        var overlay = content;
-        if (!(overlay instanceof OverlayClass)) {
-          overlay = new OverlayClass(options).setContent(content);
-        }
-        if (latlng) {
-          overlay.setLatLng(latlng);
-        }
-        return overlay;
-      }
-    });
-    Layer.include({
-      _initOverlay: function(OverlayClass, old, content, options) {
-        var overlay = content;
-        if (overlay instanceof OverlayClass) {
-          setOptions2(overlay, options);
-          overlay._source = this;
-        } else {
-          overlay = old && !options ? old : new OverlayClass(options, this);
-          overlay.setContent(content);
-        }
-        return overlay;
-      }
-    });
-    var Popup = DivOverlay.extend({
-      // @section
-      // @aka Popup options
-      options: {
-        // @option pane: String = 'popupPane'
-        // `Map pane` where the popup will be added.
-        pane: "popupPane",
-        // @option offset: Point = Point(0, 7)
-        // The offset of the popup position.
-        offset: [0, 7],
-        // @option maxWidth: Number = 300
-        // Max width of the popup, in pixels.
-        maxWidth: 300,
-        // @option minWidth: Number = 50
-        // Min width of the popup, in pixels.
-        minWidth: 50,
-        // @option maxHeight: Number = null
-        // If set, creates a scrollable container of the given height
-        // inside a popup if its content exceeds it.
-        // The scrollable container can be styled using the
-        // `leaflet-popup-scrolled` CSS class selector.
-        maxHeight: null,
-        // @option autoPan: Boolean = true
-        // Set it to `false` if you don't want the map to do panning animation
-        // to fit the opened popup.
-        autoPan: true,
-        // @option autoPanPaddingTopLeft: Point = null
-        // The margin between the popup and the top left corner of the map
-        // view after autopanning was performed.
-        autoPanPaddingTopLeft: null,
-        // @option autoPanPaddingBottomRight: Point = null
-        // The margin between the popup and the bottom right corner of the map
-        // view after autopanning was performed.
-        autoPanPaddingBottomRight: null,
-        // @option autoPanPadding: Point = Point(5, 5)
-        // Equivalent of setting both top left and bottom right autopan padding to the same value.
-        autoPanPadding: [5, 5],
-        // @option keepInView: Boolean = false
-        // Set it to `true` if you want to prevent users from panning the popup
-        // off of the screen while it is open.
-        keepInView: false,
-        // @option closeButton: Boolean = true
-        // Controls the presence of a close button in the popup.
-        closeButton: true,
-        // @option autoClose: Boolean = true
-        // Set it to `false` if you want to override the default behavior of
-        // the popup closing when another popup is opened.
-        autoClose: true,
-        // @option closeOnEscapeKey: Boolean = true
-        // Set it to `false` if you want to override the default behavior of
-        // the ESC key for closing of the popup.
-        closeOnEscapeKey: true,
-        // @option closeOnClick: Boolean = *
-        // Set it if you want to override the default behavior of the popup closing when user clicks
-        // on the map. Defaults to the map's [`closePopupOnClick`](#map-closepopuponclick) option.
-        // @option className: String = ''
-        // A custom CSS class name to assign to the popup.
-        className: ""
-      },
-      // @namespace Popup
-      // @method openOn(map: Map): this
-      // Alternative to `map.openPopup(popup)`.
-      // Adds the popup to the map and closes the previous one.
-      openOn: function(map2) {
-        map2 = arguments.length ? map2 : this._source._map;
-        if (!map2.hasLayer(this) && map2._popup && map2._popup.options.autoClose) {
-          map2.removeLayer(map2._popup);
-        }
-        map2._popup = this;
-        return DivOverlay.prototype.openOn.call(this, map2);
-      },
-      onAdd: function(map2) {
-        DivOverlay.prototype.onAdd.call(this, map2);
-        map2.fire("popupopen", { popup: this });
-        if (this._source) {
-          this._source.fire("popupopen", { popup: this }, true);
-          if (!(this._source instanceof Path)) {
-            this._source.on("preclick", stopPropagation);
-          }
-        }
-      },
-      onRemove: function(map2) {
-        DivOverlay.prototype.onRemove.call(this, map2);
-        map2.fire("popupclose", { popup: this });
-        if (this._source) {
-          this._source.fire("popupclose", { popup: this }, true);
-          if (!(this._source instanceof Path)) {
-            this._source.off("preclick", stopPropagation);
-          }
-        }
-      },
-      getEvents: function() {
-        var events = DivOverlay.prototype.getEvents.call(this);
-        if (this.options.closeOnClick !== void 0 ? this.options.closeOnClick : this._map.options.closePopupOnClick) {
-          events.preclick = this.close;
-        }
-        if (this.options.keepInView) {
-          events.moveend = this._adjustPan;
-        }
-        return events;
-      },
-      _initLayout: function() {
-        var prefix = "leaflet-popup", container = this._container = create$1(
-          "div",
-          prefix + " " + (this.options.className || "") + " leaflet-zoom-animated"
-        );
-        var wrapper = this._wrapper = create$1("div", prefix + "-content-wrapper", container);
-        this._contentNode = create$1("div", prefix + "-content", wrapper);
-        disableClickPropagation(container);
-        disableScrollPropagation(this._contentNode);
-        on(container, "contextmenu", stopPropagation);
-        this._tipContainer = create$1("div", prefix + "-tip-container", container);
-        this._tip = create$1("div", prefix + "-tip", this._tipContainer);
-        if (this.options.closeButton) {
-          var closeButton = this._closeButton = create$1("a", prefix + "-close-button", container);
-          closeButton.setAttribute("role", "button");
-          closeButton.setAttribute("aria-label", "Close popup");
-          closeButton.href = "#close";
-          closeButton.innerHTML = '<span aria-hidden="true">&#215;</span>';
-          on(closeButton, "click", function(ev) {
-            preventDefault(ev);
-            this.close();
-          }, this);
-        }
-      },
-      _updateLayout: function() {
-        var container = this._contentNode, style2 = container.style;
-        style2.width = "";
-        style2.whiteSpace = "nowrap";
-        var width = container.offsetWidth;
-        width = Math.min(width, this.options.maxWidth);
-        width = Math.max(width, this.options.minWidth);
-        style2.width = width + 1 + "px";
-        style2.whiteSpace = "";
-        style2.height = "";
-        var height = container.offsetHeight, maxHeight = this.options.maxHeight, scrolledClass = "leaflet-popup-scrolled";
-        if (maxHeight && height > maxHeight) {
-          style2.height = maxHeight + "px";
-          addClass(container, scrolledClass);
-        } else {
-          removeClass(container, scrolledClass);
-        }
-        this._containerWidth = this._container.offsetWidth;
-      },
-      _animateZoom: function(e) {
-        var pos = this._map._latLngToNewLayerPoint(this._latlng, e.zoom, e.center), anchor = this._getAnchor();
-        setPosition(this._container, pos.add(anchor));
-      },
-      _adjustPan: function() {
-        if (!this.options.autoPan) {
-          return;
-        }
-        if (this._map._panAnim) {
-          this._map._panAnim.stop();
-        }
-        if (this._autopanning) {
-          this._autopanning = false;
-          return;
-        }
-        var map2 = this._map, marginBottom = parseInt(getStyle2(this._container, "marginBottom"), 10) || 0, containerHeight = this._container.offsetHeight + marginBottom, containerWidth = this._containerWidth, layerPos = new Point(this._containerLeft, -containerHeight - this._containerBottom);
-        layerPos._add(getPosition(this._container));
-        var containerPos = map2.layerPointToContainerPoint(layerPos), padding = toPoint(this.options.autoPanPadding), paddingTL = toPoint(this.options.autoPanPaddingTopLeft || padding), paddingBR = toPoint(this.options.autoPanPaddingBottomRight || padding), size = map2.getSize(), dx = 0, dy = 0;
-        if (containerPos.x + containerWidth + paddingBR.x > size.x) {
-          dx = containerPos.x + containerWidth - size.x + paddingBR.x;
-        }
-        if (containerPos.x - dx - paddingTL.x < 0) {
-          dx = containerPos.x - paddingTL.x;
-        }
-        if (containerPos.y + containerHeight + paddingBR.y > size.y) {
-          dy = containerPos.y + containerHeight - size.y + paddingBR.y;
-        }
-        if (containerPos.y - dy - paddingTL.y < 0) {
-          dy = containerPos.y - paddingTL.y;
-        }
-        if (dx || dy) {
-          if (this.options.keepInView) {
-            this._autopanning = true;
-          }
-          map2.fire("autopanstart").panBy([dx, dy]);
-        }
-      },
-      _getAnchor: function() {
-        return toPoint(this._source && this._source._getPopupAnchor ? this._source._getPopupAnchor() : [0, 0]);
-      }
-    });
-    var popup = function(options, source) {
-      return new Popup(options, source);
-    };
-    Map2.mergeOptions({
-      closePopupOnClick: true
-    });
-    Map2.include({
-      // @method openPopup(popup: Popup): this
-      // Opens the specified popup while closing the previously opened (to make sure only one is opened at one time for usability).
-      // @alternative
-      // @method openPopup(content: String|HTMLElement, latlng: LatLng, options?: Popup options): this
-      // Creates a popup with the specified content and options and opens it in the given point on a map.
-      openPopup: function(popup2, latlng, options) {
-        this._initOverlay(Popup, popup2, latlng, options).openOn(this);
-        return this;
-      },
-      // @method closePopup(popup?: Popup): this
-      // Closes the popup previously opened with [openPopup](#map-openpopup) (or the given one).
-      closePopup: function(popup2) {
-        popup2 = arguments.length ? popup2 : this._popup;
-        if (popup2) {
-          popup2.close();
-        }
-        return this;
-      }
-    });
-    Layer.include({
-      // @method bindPopup(content: String|HTMLElement|Function|Popup, options?: Popup options): this
-      // Binds a popup to the layer with the passed `content` and sets up the
-      // necessary event listeners. If a `Function` is passed it will receive
-      // the layer as the first argument and should return a `String` or `HTMLElement`.
-      bindPopup: function(content, options) {
-        this._popup = this._initOverlay(Popup, this._popup, content, options);
-        if (!this._popupHandlersAdded) {
-          this.on({
-            click: this._openPopup,
-            keypress: this._onKeyPress,
-            remove: this.closePopup,
-            move: this._movePopup
-          });
-          this._popupHandlersAdded = true;
-        }
-        return this;
-      },
-      // @method unbindPopup(): this
-      // Removes the popup previously bound with `bindPopup`.
-      unbindPopup: function() {
-        if (this._popup) {
-          this.off({
-            click: this._openPopup,
-            keypress: this._onKeyPress,
-            remove: this.closePopup,
-            move: this._movePopup
-          });
-          this._popupHandlersAdded = false;
-          this._popup = null;
-        }
-        return this;
-      },
-      // @method openPopup(latlng?: LatLng): this
-      // Opens the bound popup at the specified `latlng` or at the default popup anchor if no `latlng` is passed.
-      openPopup: function(latlng) {
-        if (this._popup) {
-          if (!(this instanceof FeatureGroup)) {
-            this._popup._source = this;
-          }
-          if (this._popup._prepareOpen(latlng || this._latlng)) {
-            this._popup.openOn(this._map);
-          }
-        }
-        return this;
-      },
-      // @method closePopup(): this
-      // Closes the popup bound to this layer if it is open.
-      closePopup: function() {
-        if (this._popup) {
-          this._popup.close();
-        }
-        return this;
-      },
-      // @method togglePopup(): this
-      // Opens or closes the popup bound to this layer depending on its current state.
-      togglePopup: function() {
-        if (this._popup) {
-          this._popup.toggle(this);
-        }
-        return this;
-      },
-      // @method isPopupOpen(): boolean
-      // Returns `true` if the popup bound to this layer is currently open.
-      isPopupOpen: function() {
-        return this._popup ? this._popup.isOpen() : false;
-      },
-      // @method setPopupContent(content: String|HTMLElement|Popup): this
-      // Sets the content of the popup bound to this layer.
-      setPopupContent: function(content) {
-        if (this._popup) {
-          this._popup.setContent(content);
-        }
-        return this;
-      },
-      // @method getPopup(): Popup
-      // Returns the popup bound to this layer.
-      getPopup: function() {
-        return this._popup;
-      },
-      _openPopup: function(e) {
-        if (!this._popup || !this._map) {
-          return;
-        }
-        stop(e);
-        var target = e.layer || e.target;
-        if (this._popup._source === target && !(target instanceof Path)) {
-          if (this._map.hasLayer(this._popup)) {
-            this.closePopup();
-          } else {
-            this.openPopup(e.latlng);
-          }
-          return;
-        }
-        this._popup._source = target;
-        this.openPopup(e.latlng);
-      },
-      _movePopup: function(e) {
-        this._popup.setLatLng(e.latlng);
-      },
-      _onKeyPress: function(e) {
-        if (e.originalEvent.keyCode === 13) {
-          this._openPopup(e);
-        }
-      }
-    });
-    var Tooltip2 = DivOverlay.extend({
-      // @section
-      // @aka Tooltip options
-      options: {
-        // @option pane: String = 'tooltipPane'
-        // `Map pane` where the tooltip will be added.
-        pane: "tooltipPane",
-        // @option offset: Point = Point(0, 0)
-        // Optional offset of the tooltip position.
-        offset: [0, 0],
-        // @option direction: String = 'auto'
-        // Direction where to open the tooltip. Possible values are: `right`, `left`,
-        // `top`, `bottom`, `center`, `auto`.
-        // `auto` will dynamically switch between `right` and `left` according to the tooltip
-        // position on the map.
-        direction: "auto",
-        // @option permanent: Boolean = false
-        // Whether to open the tooltip permanently or only on mouseover.
-        permanent: false,
-        // @option sticky: Boolean = false
-        // If true, the tooltip will follow the mouse instead of being fixed at the feature center.
-        sticky: false,
-        // @option opacity: Number = 0.9
-        // Tooltip container opacity.
-        opacity: 0.9
-      },
-      onAdd: function(map2) {
-        DivOverlay.prototype.onAdd.call(this, map2);
-        this.setOpacity(this.options.opacity);
-        map2.fire("tooltipopen", { tooltip: this });
-        if (this._source) {
-          this.addEventParent(this._source);
-          this._source.fire("tooltipopen", { tooltip: this }, true);
-        }
-      },
-      onRemove: function(map2) {
-        DivOverlay.prototype.onRemove.call(this, map2);
-        map2.fire("tooltipclose", { tooltip: this });
-        if (this._source) {
-          this.removeEventParent(this._source);
-          this._source.fire("tooltipclose", { tooltip: this }, true);
-        }
-      },
-      getEvents: function() {
-        var events = DivOverlay.prototype.getEvents.call(this);
-        if (!this.options.permanent) {
-          events.preclick = this.close;
-        }
-        return events;
-      },
-      _initLayout: function() {
-        var prefix = "leaflet-tooltip", className = prefix + " " + (this.options.className || "") + " leaflet-zoom-" + (this._zoomAnimated ? "animated" : "hide");
-        this._contentNode = this._container = create$1("div", className);
-        this._container.setAttribute("role", "tooltip");
-        this._container.setAttribute("id", "leaflet-tooltip-" + stamp(this));
-      },
-      _updateLayout: function() {
-      },
-      _adjustPan: function() {
-      },
-      _setPosition: function(pos) {
-        var subX, subY, map2 = this._map, container = this._container, centerPoint = map2.latLngToContainerPoint(map2.getCenter()), tooltipPoint = map2.layerPointToContainerPoint(pos), direction = this.options.direction, tooltipWidth = container.offsetWidth, tooltipHeight = container.offsetHeight, offset = toPoint(this.options.offset), anchor = this._getAnchor();
-        if (direction === "top") {
-          subX = tooltipWidth / 2;
-          subY = tooltipHeight;
-        } else if (direction === "bottom") {
-          subX = tooltipWidth / 2;
-          subY = 0;
-        } else if (direction === "center") {
-          subX = tooltipWidth / 2;
-          subY = tooltipHeight / 2;
-        } else if (direction === "right") {
-          subX = 0;
-          subY = tooltipHeight / 2;
-        } else if (direction === "left") {
-          subX = tooltipWidth;
-          subY = tooltipHeight / 2;
-        } else if (tooltipPoint.x < centerPoint.x) {
-          direction = "right";
-          subX = 0;
-          subY = tooltipHeight / 2;
-        } else {
-          direction = "left";
-          subX = tooltipWidth + (offset.x + anchor.x) * 2;
-          subY = tooltipHeight / 2;
-        }
-        pos = pos.subtract(toPoint(subX, subY, true)).add(offset).add(anchor);
-        removeClass(container, "leaflet-tooltip-right");
-        removeClass(container, "leaflet-tooltip-left");
-        removeClass(container, "leaflet-tooltip-top");
-        removeClass(container, "leaflet-tooltip-bottom");
-        addClass(container, "leaflet-tooltip-" + direction);
-        setPosition(container, pos);
-      },
-      _updatePosition: function() {
-        var pos = this._map.latLngToLayerPoint(this._latlng);
-        this._setPosition(pos);
-      },
-      setOpacity: function(opacity) {
-        this.options.opacity = opacity;
-        if (this._container) {
-          setOpacity(this._container, opacity);
-        }
-      },
-      _animateZoom: function(e) {
-        var pos = this._map._latLngToNewLayerPoint(this._latlng, e.zoom, e.center);
-        this._setPosition(pos);
-      },
-      _getAnchor: function() {
-        return toPoint(this._source && this._source._getTooltipAnchor && !this.options.sticky ? this._source._getTooltipAnchor() : [0, 0]);
-      }
-    });
-    var tooltip = function(options, source) {
-      return new Tooltip2(options, source);
-    };
-    Map2.include({
-      // @method openTooltip(tooltip: Tooltip): this
-      // Opens the specified tooltip.
-      // @alternative
-      // @method openTooltip(content: String|HTMLElement, latlng: LatLng, options?: Tooltip options): this
-      // Creates a tooltip with the specified content and options and open it.
-      openTooltip: function(tooltip2, latlng, options) {
-        this._initOverlay(Tooltip2, tooltip2, latlng, options).openOn(this);
-        return this;
-      },
-      // @method closeTooltip(tooltip: Tooltip): this
-      // Closes the tooltip given as parameter.
-      closeTooltip: function(tooltip2) {
-        tooltip2.close();
-        return this;
-      }
-    });
-    Layer.include({
-      // @method bindTooltip(content: String|HTMLElement|Function|Tooltip, options?: Tooltip options): this
-      // Binds a tooltip to the layer with the passed `content` and sets up the
-      // necessary event listeners. If a `Function` is passed it will receive
-      // the layer as the first argument and should return a `String` or `HTMLElement`.
-      bindTooltip: function(content, options) {
-        if (this._tooltip && this.isTooltipOpen()) {
-          this.unbindTooltip();
-        }
-        this._tooltip = this._initOverlay(Tooltip2, this._tooltip, content, options);
-        this._initTooltipInteractions();
-        if (this._tooltip.options.permanent && this._map && this._map.hasLayer(this)) {
-          this.openTooltip();
-        }
-        return this;
-      },
-      // @method unbindTooltip(): this
-      // Removes the tooltip previously bound with `bindTooltip`.
-      unbindTooltip: function() {
-        if (this._tooltip) {
-          this._initTooltipInteractions(true);
-          this.closeTooltip();
-          this._tooltip = null;
-        }
-        return this;
-      },
-      _initTooltipInteractions: function(remove2) {
-        if (!remove2 && this._tooltipHandlersAdded) {
-          return;
-        }
-        var onOff = remove2 ? "off" : "on", events = {
-          remove: this.closeTooltip,
-          move: this._moveTooltip
-        };
-        if (!this._tooltip.options.permanent) {
-          events.mouseover = this._openTooltip;
-          events.mouseout = this.closeTooltip;
-          events.click = this._openTooltip;
-          if (this._map) {
-            this._addFocusListeners();
-          } else {
-            events.add = this._addFocusListeners;
-          }
-        } else {
-          events.add = this._openTooltip;
-        }
-        if (this._tooltip.options.sticky) {
-          events.mousemove = this._moveTooltip;
-        }
-        this[onOff](events);
-        this._tooltipHandlersAdded = !remove2;
-      },
-      // @method openTooltip(latlng?: LatLng): this
-      // Opens the bound tooltip at the specified `latlng` or at the default tooltip anchor if no `latlng` is passed.
-      openTooltip: function(latlng) {
-        if (this._tooltip) {
-          if (!(this instanceof FeatureGroup)) {
-            this._tooltip._source = this;
-          }
-          if (this._tooltip._prepareOpen(latlng)) {
-            this._tooltip.openOn(this._map);
-            if (this.getElement) {
-              this._setAriaDescribedByOnLayer(this);
-            } else if (this.eachLayer) {
-              this.eachLayer(this._setAriaDescribedByOnLayer, this);
+            function containsLine(coordinates2, point) {
+              var ao, bo, ab2;
+              for (var i2 = 0, n2 = coordinates2.length; i2 < n2; i2++) {
+                bo = distance2(coordinates2[i2], point);
+                if (bo === 0) return true;
+                if (i2 > 0) {
+                  ab2 = distance2(coordinates2[i2], coordinates2[i2 - 1]);
+                  if (ab2 > 0 && ao <= ab2 && bo <= ab2 && (ao + bo - ab2) * (1 - Math.pow((ao - bo) / ab2, 2)) < epsilon22 * ab2)
+                    return true;
+                }
+                ao = bo;
+              }
+              return false;
+            }
+            function containsPolygon(coordinates2, point) {
+              return !!polygonContains(coordinates2.map(ringRadians), pointRadians(point));
+            }
+            function ringRadians(ring) {
+              return ring = ring.map(pointRadians), ring.pop(), ring;
+            }
+            function pointRadians(point) {
+              return [point[0] * radians2, point[1] * radians2];
+            }
+            function contains(object2, point) {
+              return (object2 && containsObjectType.hasOwnProperty(object2.type) ? containsObjectType[object2.type] : containsGeometry)(object2, point);
+            }
+            function graticuleX(y02, y12, dy) {
+              var y2 = d3Array.range(y02, y12 - epsilon, dy).concat(y12);
+              return function(x2) {
+                return y2.map(function(y22) {
+                  return [x2, y22];
+                });
+              };
+            }
+            function graticuleY(x02, x12, dx) {
+              var x2 = d3Array.range(x02, x12 - epsilon, dx).concat(x12);
+              return function(y2) {
+                return x2.map(function(x22) {
+                  return [x22, y2];
+                });
+              };
+            }
+            function graticule() {
+              var x12, x02, X12, X02, y12, y02, Y12, Y02, dx = 10, dy = dx, DX = 90, DY = 360, x2, y2, X3, Y3, precision = 2.5;
+              function graticule2() {
+                return { type: "MultiLineString", coordinates: lines() };
+              }
+              function lines() {
+                return d3Array.range(ceil(X02 / DX) * DX, X12, DX).map(X3).concat(d3Array.range(ceil(Y02 / DY) * DY, Y12, DY).map(Y3)).concat(d3Array.range(ceil(x02 / dx) * dx, x12, dx).filter(function(x22) {
+                  return abs(x22 % DX) > epsilon;
+                }).map(x2)).concat(d3Array.range(ceil(y02 / dy) * dy, y12, dy).filter(function(y22) {
+                  return abs(y22 % DY) > epsilon;
+                }).map(y2));
+              }
+              graticule2.lines = function() {
+                return lines().map(function(coordinates2) {
+                  return { type: "LineString", coordinates: coordinates2 };
+                });
+              };
+              graticule2.outline = function() {
+                return {
+                  type: "Polygon",
+                  coordinates: [
+                    X3(X02).concat(
+                      Y3(Y12).slice(1),
+                      X3(X12).reverse().slice(1),
+                      Y3(Y02).reverse().slice(1)
+                    )
+                  ]
+                };
+              };
+              graticule2.extent = function(_2) {
+                if (!arguments.length) return graticule2.extentMinor();
+                return graticule2.extentMajor(_2).extentMinor(_2);
+              };
+              graticule2.extentMajor = function(_2) {
+                if (!arguments.length) return [[X02, Y02], [X12, Y12]];
+                X02 = +_2[0][0], X12 = +_2[1][0];
+                Y02 = +_2[0][1], Y12 = +_2[1][1];
+                if (X02 > X12) _2 = X02, X02 = X12, X12 = _2;
+                if (Y02 > Y12) _2 = Y02, Y02 = Y12, Y12 = _2;
+                return graticule2.precision(precision);
+              };
+              graticule2.extentMinor = function(_2) {
+                if (!arguments.length) return [[x02, y02], [x12, y12]];
+                x02 = +_2[0][0], x12 = +_2[1][0];
+                y02 = +_2[0][1], y12 = +_2[1][1];
+                if (x02 > x12) _2 = x02, x02 = x12, x12 = _2;
+                if (y02 > y12) _2 = y02, y02 = y12, y12 = _2;
+                return graticule2.precision(precision);
+              };
+              graticule2.step = function(_2) {
+                if (!arguments.length) return graticule2.stepMinor();
+                return graticule2.stepMajor(_2).stepMinor(_2);
+              };
+              graticule2.stepMajor = function(_2) {
+                if (!arguments.length) return [DX, DY];
+                DX = +_2[0], DY = +_2[1];
+                return graticule2;
+              };
+              graticule2.stepMinor = function(_2) {
+                if (!arguments.length) return [dx, dy];
+                dx = +_2[0], dy = +_2[1];
+                return graticule2;
+              };
+              graticule2.precision = function(_2) {
+                if (!arguments.length) return precision;
+                precision = +_2;
+                x2 = graticuleX(y02, y12, 90);
+                y2 = graticuleY(x02, x12, precision);
+                X3 = graticuleX(Y02, Y12, 90);
+                Y3 = graticuleY(X02, X12, precision);
+                return graticule2;
+              };
+              return graticule2.extentMajor([[-180, -90 + epsilon], [180, 90 - epsilon]]).extentMinor([[-180, -80 - epsilon], [180, 80 + epsilon]]);
+            }
+            function graticule10() {
+              return graticule()();
+            }
+            function interpolate(a2, b2) {
+              var x02 = a2[0] * radians2, y02 = a2[1] * radians2, x12 = b2[0] * radians2, y12 = b2[1] * radians2, cy0 = cos(y02), sy0 = sin(y02), cy1 = cos(y12), sy1 = sin(y12), kx0 = cy0 * cos(x02), ky0 = cy0 * sin(x02), kx1 = cy1 * cos(x12), ky1 = cy1 * sin(x12), d2 = 2 * asin(sqrt(haversin(y12 - y02) + cy0 * cy1 * haversin(x12 - x02))), k2 = sin(d2);
+              var interpolate2 = d2 ? function(t4) {
+                var B22 = sin(t4 *= d2) / k2, A5 = sin(d2 - t4) / k2, x2 = A5 * kx0 + B22 * kx1, y2 = A5 * ky0 + B22 * ky1, z2 = A5 * sy0 + B22 * sy1;
+                return [
+                  atan2(y2, x2) * degrees3,
+                  atan2(z2, sqrt(x2 * x2 + y2 * y2)) * degrees3
+                ];
+              } : function() {
+                return [x02 * degrees3, y02 * degrees3];
+              };
+              interpolate2.distance = d2;
+              return interpolate2;
+            }
+            function identity22(x2) {
+              return x2;
+            }
+            var areaSum$1 = adder(), areaRingSum$1 = adder(), x00, y00, x0$1, y0$1;
+            var areaStream$1 = {
+              point: noop2,
+              lineStart: noop2,
+              lineEnd: noop2,
+              polygonStart: function() {
+                areaStream$1.lineStart = areaRingStart$1;
+                areaStream$1.lineEnd = areaRingEnd$1;
+              },
+              polygonEnd: function() {
+                areaStream$1.lineStart = areaStream$1.lineEnd = areaStream$1.point = noop2;
+                areaSum$1.add(abs(areaRingSum$1));
+                areaRingSum$1.reset();
+              },
+              result: function() {
+                var area2 = areaSum$1 / 2;
+                areaSum$1.reset();
+                return area2;
+              }
+            };
+            function areaRingStart$1() {
+              areaStream$1.point = areaPointFirst$1;
+            }
+            function areaPointFirst$1(x2, y2) {
+              areaStream$1.point = areaPoint$1;
+              x00 = x0$1 = x2, y00 = y0$1 = y2;
+            }
+            function areaPoint$1(x2, y2) {
+              areaRingSum$1.add(y0$1 * x2 - x0$1 * y2);
+              x0$1 = x2, y0$1 = y2;
+            }
+            function areaRingEnd$1() {
+              areaPoint$1(x00, y00);
+            }
+            var x0$2 = Infinity, y0$2 = x0$2, x1 = -x0$2, y1 = x1;
+            var boundsStream$1 = {
+              point: boundsPoint$1,
+              lineStart: noop2,
+              lineEnd: noop2,
+              polygonStart: noop2,
+              polygonEnd: noop2,
+              result: function() {
+                var bounds2 = [[x0$2, y0$2], [x1, y1]];
+                x1 = y1 = -(y0$2 = x0$2 = Infinity);
+                return bounds2;
+              }
+            };
+            function boundsPoint$1(x2, y2) {
+              if (x2 < x0$2) x0$2 = x2;
+              if (x2 > x1) x1 = x2;
+              if (y2 < y0$2) y0$2 = y2;
+              if (y2 > y1) y1 = y2;
+            }
+            var X0$1 = 0, Y0$1 = 0, Z0$1 = 0, X1$1 = 0, Y1$1 = 0, Z1$1 = 0, X2$1 = 0, Y2$1 = 0, Z2$1 = 0, x00$1, y00$1, x0$3, y0$3;
+            var centroidStream$1 = {
+              point: centroidPoint$1,
+              lineStart: centroidLineStart$1,
+              lineEnd: centroidLineEnd$1,
+              polygonStart: function() {
+                centroidStream$1.lineStart = centroidRingStart$1;
+                centroidStream$1.lineEnd = centroidRingEnd$1;
+              },
+              polygonEnd: function() {
+                centroidStream$1.point = centroidPoint$1;
+                centroidStream$1.lineStart = centroidLineStart$1;
+                centroidStream$1.lineEnd = centroidLineEnd$1;
+              },
+              result: function() {
+                var centroid2 = Z2$1 ? [X2$1 / Z2$1, Y2$1 / Z2$1] : Z1$1 ? [X1$1 / Z1$1, Y1$1 / Z1$1] : Z0$1 ? [X0$1 / Z0$1, Y0$1 / Z0$1] : [NaN, NaN];
+                X0$1 = Y0$1 = Z0$1 = X1$1 = Y1$1 = Z1$1 = X2$1 = Y2$1 = Z2$1 = 0;
+                return centroid2;
+              }
+            };
+            function centroidPoint$1(x2, y2) {
+              X0$1 += x2;
+              Y0$1 += y2;
+              ++Z0$1;
+            }
+            function centroidLineStart$1() {
+              centroidStream$1.point = centroidPointFirstLine;
+            }
+            function centroidPointFirstLine(x2, y2) {
+              centroidStream$1.point = centroidPointLine;
+              centroidPoint$1(x0$3 = x2, y0$3 = y2);
+            }
+            function centroidPointLine(x2, y2) {
+              var dx = x2 - x0$3, dy = y2 - y0$3, z2 = sqrt(dx * dx + dy * dy);
+              X1$1 += z2 * (x0$3 + x2) / 2;
+              Y1$1 += z2 * (y0$3 + y2) / 2;
+              Z1$1 += z2;
+              centroidPoint$1(x0$3 = x2, y0$3 = y2);
+            }
+            function centroidLineEnd$1() {
+              centroidStream$1.point = centroidPoint$1;
+            }
+            function centroidRingStart$1() {
+              centroidStream$1.point = centroidPointFirstRing;
+            }
+            function centroidRingEnd$1() {
+              centroidPointRing(x00$1, y00$1);
+            }
+            function centroidPointFirstRing(x2, y2) {
+              centroidStream$1.point = centroidPointRing;
+              centroidPoint$1(x00$1 = x0$3 = x2, y00$1 = y0$3 = y2);
+            }
+            function centroidPointRing(x2, y2) {
+              var dx = x2 - x0$3, dy = y2 - y0$3, z2 = sqrt(dx * dx + dy * dy);
+              X1$1 += z2 * (x0$3 + x2) / 2;
+              Y1$1 += z2 * (y0$3 + y2) / 2;
+              Z1$1 += z2;
+              z2 = y0$3 * x2 - x0$3 * y2;
+              X2$1 += z2 * (x0$3 + x2);
+              Y2$1 += z2 * (y0$3 + y2);
+              Z2$1 += z2 * 3;
+              centroidPoint$1(x0$3 = x2, y0$3 = y2);
+            }
+            function PathContext(context) {
+              this._context = context;
+            }
+            PathContext.prototype = {
+              _radius: 4.5,
+              pointRadius: function(_2) {
+                return this._radius = _2, this;
+              },
+              polygonStart: function() {
+                this._line = 0;
+              },
+              polygonEnd: function() {
+                this._line = NaN;
+              },
+              lineStart: function() {
+                this._point = 0;
+              },
+              lineEnd: function() {
+                if (this._line === 0) this._context.closePath();
+                this._point = NaN;
+              },
+              point: function(x2, y2) {
+                switch (this._point) {
+                  case 0: {
+                    this._context.moveTo(x2, y2);
+                    this._point = 1;
+                    break;
+                  }
+                  case 1: {
+                    this._context.lineTo(x2, y2);
+                    break;
+                  }
+                  default: {
+                    this._context.moveTo(x2 + this._radius, y2);
+                    this._context.arc(x2, y2, this._radius, 0, tau);
+                    break;
+                  }
+                }
+              },
+              result: noop2
+            };
+            var lengthSum$1 = adder(), lengthRing, x00$2, y00$2, x0$4, y0$4;
+            var lengthStream$1 = {
+              point: noop2,
+              lineStart: function() {
+                lengthStream$1.point = lengthPointFirst$1;
+              },
+              lineEnd: function() {
+                if (lengthRing) lengthPoint$1(x00$2, y00$2);
+                lengthStream$1.point = noop2;
+              },
+              polygonStart: function() {
+                lengthRing = true;
+              },
+              polygonEnd: function() {
+                lengthRing = null;
+              },
+              result: function() {
+                var length22 = +lengthSum$1;
+                lengthSum$1.reset();
+                return length22;
+              }
+            };
+            function lengthPointFirst$1(x2, y2) {
+              lengthStream$1.point = lengthPoint$1;
+              x00$2 = x0$4 = x2, y00$2 = y0$4 = y2;
+            }
+            function lengthPoint$1(x2, y2) {
+              x0$4 -= x2, y0$4 -= y2;
+              lengthSum$1.add(sqrt(x0$4 * x0$4 + y0$4 * y0$4));
+              x0$4 = x2, y0$4 = y2;
+            }
+            function PathString() {
+              this._string = [];
+            }
+            PathString.prototype = {
+              _radius: 4.5,
+              _circle: circle$1(4.5),
+              pointRadius: function(_2) {
+                if ((_2 = +_2) !== this._radius) this._radius = _2, this._circle = null;
+                return this;
+              },
+              polygonStart: function() {
+                this._line = 0;
+              },
+              polygonEnd: function() {
+                this._line = NaN;
+              },
+              lineStart: function() {
+                this._point = 0;
+              },
+              lineEnd: function() {
+                if (this._line === 0) this._string.push("Z");
+                this._point = NaN;
+              },
+              point: function(x2, y2) {
+                switch (this._point) {
+                  case 0: {
+                    this._string.push("M", x2, ",", y2);
+                    this._point = 1;
+                    break;
+                  }
+                  case 1: {
+                    this._string.push("L", x2, ",", y2);
+                    break;
+                  }
+                  default: {
+                    if (this._circle == null) this._circle = circle$1(this._radius);
+                    this._string.push("M", x2, ",", y2, this._circle);
+                    break;
+                  }
+                }
+              },
+              result: function() {
+                if (this._string.length) {
+                  var result = this._string.join("");
+                  this._string = [];
+                  return result;
+                } else {
+                  return null;
+                }
+              }
+            };
+            function circle$1(radius) {
+              return "m0," + radius + "a" + radius + "," + radius + " 0 1,1 0," + -2 * radius + "a" + radius + "," + radius + " 0 1,1 0," + 2 * radius + "z";
+            }
+            function index(projection2, context) {
+              var pointRadius = 4.5, projectionStream, contextStream;
+              function path(object2) {
+                if (object2) {
+                  if (typeof pointRadius === "function") contextStream.pointRadius(+pointRadius.apply(this, arguments));
+                  geoStream(object2, projectionStream(contextStream));
+                }
+                return contextStream.result();
+              }
+              path.area = function(object2) {
+                geoStream(object2, projectionStream(areaStream$1));
+                return areaStream$1.result();
+              };
+              path.measure = function(object2) {
+                geoStream(object2, projectionStream(lengthStream$1));
+                return lengthStream$1.result();
+              };
+              path.bounds = function(object2) {
+                geoStream(object2, projectionStream(boundsStream$1));
+                return boundsStream$1.result();
+              };
+              path.centroid = function(object2) {
+                geoStream(object2, projectionStream(centroidStream$1));
+                return centroidStream$1.result();
+              };
+              path.projection = function(_2) {
+                return arguments.length ? (projectionStream = _2 == null ? (projection2 = null, identity22) : (projection2 = _2).stream, path) : projection2;
+              };
+              path.context = function(_2) {
+                if (!arguments.length) return context;
+                contextStream = _2 == null ? (context = null, new PathString()) : new PathContext(context = _2);
+                if (typeof pointRadius !== "function") contextStream.pointRadius(pointRadius);
+                return path;
+              };
+              path.pointRadius = function(_2) {
+                if (!arguments.length) return pointRadius;
+                pointRadius = typeof _2 === "function" ? _2 : (contextStream.pointRadius(+_2), +_2);
+                return path;
+              };
+              return path.projection(projection2).context(context);
+            }
+            function transform(methods) {
+              return {
+                stream: transformer(methods)
+              };
+            }
+            function transformer(methods) {
+              return function(stream) {
+                var s2 = new TransformStream();
+                for (var key in methods) s2[key] = methods[key];
+                s2.stream = stream;
+                return s2;
+              };
+            }
+            function TransformStream() {
+            }
+            TransformStream.prototype = {
+              constructor: TransformStream,
+              point: function(x2, y2) {
+                this.stream.point(x2, y2);
+              },
+              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();
+              }
+            };
+            function fit(projection2, fitBounds2, object2) {
+              var clip2 = projection2.clipExtent && projection2.clipExtent();
+              projection2.scale(150).translate([0, 0]);
+              if (clip2 != null) projection2.clipExtent(null);
+              geoStream(object2, projection2.stream(boundsStream$1));
+              fitBounds2(boundsStream$1.result());
+              if (clip2 != null) projection2.clipExtent(clip2);
+              return projection2;
+            }
+            function fitExtent(projection2, extent2, object2) {
+              return fit(projection2, function(b2) {
+                var w2 = extent2[1][0] - extent2[0][0], h2 = extent2[1][1] - extent2[0][1], k2 = Math.min(w2 / (b2[1][0] - b2[0][0]), h2 / (b2[1][1] - b2[0][1])), x2 = +extent2[0][0] + (w2 - k2 * (b2[1][0] + b2[0][0])) / 2, y2 = +extent2[0][1] + (h2 - k2 * (b2[1][1] + b2[0][1])) / 2;
+                projection2.scale(150 * k2).translate([x2, y2]);
+              }, object2);
+            }
+            function fitSize(projection2, size, object2) {
+              return fitExtent(projection2, [[0, 0], size], object2);
+            }
+            function fitWidth(projection2, width, object2) {
+              return fit(projection2, function(b2) {
+                var w2 = +width, k2 = w2 / (b2[1][0] - b2[0][0]), x2 = (w2 - k2 * (b2[1][0] + b2[0][0])) / 2, y2 = -k2 * b2[0][1];
+                projection2.scale(150 * k2).translate([x2, y2]);
+              }, object2);
+            }
+            function fitHeight(projection2, height, object2) {
+              return fit(projection2, function(b2) {
+                var h2 = +height, k2 = h2 / (b2[1][1] - b2[0][1]), x2 = -k2 * b2[0][0], y2 = (h2 - k2 * (b2[1][1] + b2[0][1])) / 2;
+                projection2.scale(150 * k2).translate([x2, y2]);
+              }, object2);
+            }
+            var maxDepth = 16, cosMinDistance = cos(30 * radians2);
+            function resample(project2, delta2) {
+              return +delta2 ? resample$1(project2, delta2) : resampleNone(project2);
+            }
+            function resampleNone(project2) {
+              return transformer({
+                point: function(x2, y2) {
+                  x2 = project2(x2, y2);
+                  this.stream.point(x2[0], x2[1]);
+                }
+              });
+            }
+            function resample$1(project2, delta2) {
+              function resampleLineTo(x02, y02, lambda02, a0, b0, c0, x12, y12, lambda12, a1, b1, c1, depth, stream) {
+                var dx = x12 - x02, dy = y12 - y02, d2 = dx * dx + dy * dy;
+                if (d2 > 4 * delta2 && depth--) {
+                  var a2 = a0 + a1, b2 = b0 + b1, c2 = c0 + c1, m2 = sqrt(a2 * a2 + b2 * b2 + c2 * c2), phi2 = asin(c2 /= m2), lambda22 = abs(abs(c2) - 1) < epsilon || abs(lambda02 - lambda12) < epsilon ? (lambda02 + lambda12) / 2 : atan2(b2, a2), p2 = project2(lambda22, phi2), x2 = p2[0], y2 = p2[1], dx2 = x2 - x02, dy2 = y2 - y02, dz = dy * dx2 - dx * dy2;
+                  if (dz * dz / d2 > delta2 || abs((dx * dx2 + dy * dy2) / d2 - 0.5) > 0.3 || a0 * a1 + b0 * b1 + c0 * c1 < cosMinDistance) {
+                    resampleLineTo(x02, y02, lambda02, a0, b0, c0, x2, y2, lambda22, a2 /= m2, b2 /= m2, c2, depth, stream);
+                    stream.point(x2, y2);
+                    resampleLineTo(x2, y2, lambda22, a2, b2, c2, x12, y12, lambda12, a1, b1, c1, depth, stream);
+                  }
+                }
+              }
+              return function(stream) {
+                var lambda002, x002, y002, a00, b00, c00, lambda02, x02, y02, a0, b0, c0;
+                var resampleStream = {
+                  point,
+                  lineStart,
+                  lineEnd,
+                  polygonStart: function() {
+                    stream.polygonStart();
+                    resampleStream.lineStart = ringStart;
+                  },
+                  polygonEnd: function() {
+                    stream.polygonEnd();
+                    resampleStream.lineStart = lineStart;
+                  }
+                };
+                function point(x2, y2) {
+                  x2 = project2(x2, y2);
+                  stream.point(x2[0], x2[1]);
+                }
+                function lineStart() {
+                  x02 = NaN;
+                  resampleStream.point = linePoint2;
+                  stream.lineStart();
+                }
+                function linePoint2(lambda, phi) {
+                  var c2 = cartesian([lambda, phi]), p2 = project2(lambda, phi);
+                  resampleLineTo(x02, y02, lambda02, a0, b0, c0, x02 = p2[0], y02 = p2[1], lambda02 = lambda, a0 = c2[0], b0 = c2[1], c0 = c2[2], maxDepth, stream);
+                  stream.point(x02, y02);
+                }
+                function lineEnd() {
+                  resampleStream.point = point;
+                  stream.lineEnd();
+                }
+                function ringStart() {
+                  lineStart();
+                  resampleStream.point = ringPoint;
+                  resampleStream.lineEnd = ringEnd;
+                }
+                function ringPoint(lambda, phi) {
+                  linePoint2(lambda002 = lambda, phi), x002 = x02, y002 = y02, a00 = a0, b00 = b0, c00 = c0;
+                  resampleStream.point = linePoint2;
+                }
+                function ringEnd() {
+                  resampleLineTo(x02, y02, lambda02, a0, b0, c0, x002, y002, lambda002, a00, b00, c00, maxDepth, stream);
+                  resampleStream.lineEnd = lineEnd;
+                  lineEnd();
+                }
+                return resampleStream;
+              };
+            }
+            var transformRadians = transformer({
+              point: function(x2, y2) {
+                this.stream.point(x2 * radians2, y2 * radians2);
+              }
+            });
+            function transformRotate(rotate2) {
+              return transformer({
+                point: function(x2, y2) {
+                  var r2 = rotate2(x2, y2);
+                  return this.stream.point(r2[0], r2[1]);
+                }
+              });
+            }
+            function scaleTranslate(k2, dx, dy, sx, sy) {
+              function transform2(x2, y2) {
+                x2 *= sx;
+                y2 *= sy;
+                return [dx + k2 * x2, dy - k2 * y2];
+              }
+              transform2.invert = function(x2, y2) {
+                return [(x2 - dx) / k2 * sx, (dy - y2) / k2 * sy];
+              };
+              return transform2;
+            }
+            function scaleTranslateRotate(k2, dx, dy, sx, sy, alpha) {
+              var cosAlpha = cos(alpha), sinAlpha = sin(alpha), a2 = cosAlpha * k2, b2 = sinAlpha * k2, ai2 = cosAlpha / k2, bi2 = sinAlpha / k2, ci2 = (sinAlpha * dy - cosAlpha * dx) / k2, fi2 = (sinAlpha * dx + cosAlpha * dy) / k2;
+              function transform2(x2, y2) {
+                x2 *= sx;
+                y2 *= sy;
+                return [a2 * x2 - b2 * y2 + dx, dy - b2 * x2 - a2 * y2];
+              }
+              transform2.invert = function(x2, y2) {
+                return [sx * (ai2 * x2 - bi2 * y2 + ci2), sy * (fi2 - bi2 * x2 - ai2 * y2)];
+              };
+              return transform2;
+            }
+            function projection(project2) {
+              return projectionMutator(function() {
+                return project2;
+              })();
+            }
+            function projectionMutator(projectAt) {
+              var project2, k2 = 150, x2 = 480, y2 = 250, lambda = 0, phi = 0, deltaLambda = 0, deltaPhi = 0, deltaGamma = 0, rotate2, alpha = 0, sx = 1, sy = 1, theta = null, preclip = clipAntimeridian, x02 = null, y02, x12, y12, postclip = identity22, delta2 = 0.5, projectResample, projectTransform, projectRotateTransform, cache, cacheStream;
+              function projection2(point) {
+                return projectRotateTransform(point[0] * radians2, point[1] * radians2);
+              }
+              function invert2(point) {
+                point = projectRotateTransform.invert(point[0], point[1]);
+                return point && [point[0] * degrees3, point[1] * degrees3];
+              }
+              projection2.stream = function(stream) {
+                return cache && cacheStream === stream ? cache : cache = transformRadians(transformRotate(rotate2)(preclip(projectResample(postclip(cacheStream = stream)))));
+              };
+              projection2.preclip = function(_2) {
+                return arguments.length ? (preclip = _2, theta = void 0, reset()) : preclip;
+              };
+              projection2.postclip = function(_2) {
+                return arguments.length ? (postclip = _2, x02 = y02 = x12 = y12 = null, reset()) : postclip;
+              };
+              projection2.clipAngle = function(_2) {
+                return arguments.length ? (preclip = +_2 ? clipCircle(theta = _2 * radians2) : (theta = null, clipAntimeridian), reset()) : theta * degrees3;
+              };
+              projection2.clipExtent = function(_2) {
+                return arguments.length ? (postclip = _2 == null ? (x02 = y02 = x12 = y12 = null, identity22) : clipRectangle(x02 = +_2[0][0], y02 = +_2[0][1], x12 = +_2[1][0], y12 = +_2[1][1]), reset()) : x02 == null ? null : [[x02, y02], [x12, y12]];
+              };
+              projection2.scale = function(_2) {
+                return arguments.length ? (k2 = +_2, recenter()) : k2;
+              };
+              projection2.translate = function(_2) {
+                return arguments.length ? (x2 = +_2[0], y2 = +_2[1], recenter()) : [x2, y2];
+              };
+              projection2.center = function(_2) {
+                return arguments.length ? (lambda = _2[0] % 360 * radians2, phi = _2[1] % 360 * radians2, recenter()) : [lambda * degrees3, phi * degrees3];
+              };
+              projection2.rotate = function(_2) {
+                return arguments.length ? (deltaLambda = _2[0] % 360 * radians2, deltaPhi = _2[1] % 360 * radians2, deltaGamma = _2.length > 2 ? _2[2] % 360 * radians2 : 0, recenter()) : [deltaLambda * degrees3, deltaPhi * degrees3, deltaGamma * degrees3];
+              };
+              projection2.angle = function(_2) {
+                return arguments.length ? (alpha = _2 % 360 * radians2, recenter()) : alpha * degrees3;
+              };
+              projection2.reflectX = function(_2) {
+                return arguments.length ? (sx = _2 ? -1 : 1, recenter()) : sx < 0;
+              };
+              projection2.reflectY = function(_2) {
+                return arguments.length ? (sy = _2 ? -1 : 1, recenter()) : sy < 0;
+              };
+              projection2.precision = function(_2) {
+                return arguments.length ? (projectResample = resample(projectTransform, delta2 = _2 * _2), reset()) : sqrt(delta2);
+              };
+              projection2.fitExtent = function(extent2, object2) {
+                return fitExtent(projection2, extent2, object2);
+              };
+              projection2.fitSize = function(size, object2) {
+                return fitSize(projection2, size, object2);
+              };
+              projection2.fitWidth = function(width, object2) {
+                return fitWidth(projection2, width, object2);
+              };
+              projection2.fitHeight = function(height, object2) {
+                return fitHeight(projection2, height, object2);
+              };
+              function recenter() {
+                var center = scaleTranslateRotate(k2, 0, 0, sx, sy, alpha).apply(null, project2(lambda, phi)), transform2 = (alpha ? scaleTranslateRotate : scaleTranslate)(k2, x2 - center[0], y2 - center[1], sx, sy, alpha);
+                rotate2 = rotateRadians(deltaLambda, deltaPhi, deltaGamma);
+                projectTransform = compose(project2, transform2);
+                projectRotateTransform = compose(rotate2, projectTransform);
+                projectResample = resample(projectTransform, delta2);
+                return reset();
+              }
+              function reset() {
+                cache = cacheStream = null;
+                return projection2;
+              }
+              return function() {
+                project2 = projectAt.apply(this, arguments);
+                projection2.invert = project2.invert && invert2;
+                return recenter();
+              };
+            }
+            function conicProjection(projectAt) {
+              var phi02 = 0, phi12 = pi2 / 3, m2 = projectionMutator(projectAt), p2 = m2(phi02, phi12);
+              p2.parallels = function(_2) {
+                return arguments.length ? m2(phi02 = _2[0] * radians2, phi12 = _2[1] * radians2) : [phi02 * degrees3, phi12 * degrees3];
+              };
+              return p2;
+            }
+            function cylindricalEqualAreaRaw(phi02) {
+              var cosPhi02 = cos(phi02);
+              function forward(lambda, phi) {
+                return [lambda * cosPhi02, sin(phi) / cosPhi02];
+              }
+              forward.invert = function(x2, y2) {
+                return [x2 / cosPhi02, asin(y2 * cosPhi02)];
+              };
+              return forward;
+            }
+            function conicEqualAreaRaw(y02, y12) {
+              var sy0 = sin(y02), n2 = (sy0 + sin(y12)) / 2;
+              if (abs(n2) < epsilon) return cylindricalEqualAreaRaw(y02);
+              var c2 = 1 + sy0 * (2 * n2 - sy0), r0 = sqrt(c2) / n2;
+              function project2(x2, y2) {
+                var r2 = sqrt(c2 - 2 * n2 * sin(y2)) / n2;
+                return [r2 * sin(x2 *= n2), r0 - r2 * cos(x2)];
+              }
+              project2.invert = function(x2, y2) {
+                var r0y = r0 - y2, l2 = atan2(x2, abs(r0y)) * sign(r0y);
+                if (r0y * n2 < 0)
+                  l2 -= pi2 * sign(x2) * sign(r0y);
+                return [l2 / n2, asin((c2 - (x2 * x2 + r0y * r0y) * n2 * n2) / (2 * n2))];
+              };
+              return project2;
+            }
+            function conicEqualArea() {
+              return conicProjection(conicEqualAreaRaw).scale(155.424).center([0, 33.6442]);
+            }
+            function albers() {
+              return conicEqualArea().parallels([29.5, 45.5]).scale(1070).translate([480, 250]).rotate([96, 0]).center([-0.6, 38.7]);
+            }
+            function multiplex(streams) {
+              var n2 = streams.length;
+              return {
+                point: function(x2, y2) {
+                  var i2 = -1;
+                  while (++i2 < n2) streams[i2].point(x2, y2);
+                },
+                sphere: function() {
+                  var i2 = -1;
+                  while (++i2 < n2) streams[i2].sphere();
+                },
+                lineStart: function() {
+                  var i2 = -1;
+                  while (++i2 < n2) streams[i2].lineStart();
+                },
+                lineEnd: function() {
+                  var i2 = -1;
+                  while (++i2 < n2) streams[i2].lineEnd();
+                },
+                polygonStart: function() {
+                  var i2 = -1;
+                  while (++i2 < n2) streams[i2].polygonStart();
+                },
+                polygonEnd: function() {
+                  var i2 = -1;
+                  while (++i2 < n2) streams[i2].polygonEnd();
+                }
+              };
+            }
+            function albersUsa() {
+              var cache, cacheStream, lower48 = albers(), lower48Point, alaska = conicEqualArea().rotate([154, 0]).center([-2, 58.5]).parallels([55, 65]), alaskaPoint, hawaii = conicEqualArea().rotate([157, 0]).center([-3, 19.9]).parallels([8, 18]), hawaiiPoint, point, pointStream = { point: function(x2, y2) {
+                point = [x2, y2];
+              } };
+              function albersUsa2(coordinates2) {
+                var x2 = coordinates2[0], y2 = coordinates2[1];
+                return point = null, (lower48Point.point(x2, y2), point) || (alaskaPoint.point(x2, y2), point) || (hawaiiPoint.point(x2, y2), point);
+              }
+              albersUsa2.invert = function(coordinates2) {
+                var k2 = lower48.scale(), t4 = lower48.translate(), x2 = (coordinates2[0] - t4[0]) / k2, y2 = (coordinates2[1] - t4[1]) / k2;
+                return (y2 >= 0.12 && y2 < 0.234 && x2 >= -0.425 && x2 < -0.214 ? alaska : y2 >= 0.166 && y2 < 0.234 && x2 >= -0.214 && x2 < -0.115 ? hawaii : lower48).invert(coordinates2);
+              };
+              albersUsa2.stream = function(stream) {
+                return cache && cacheStream === stream ? cache : cache = multiplex([lower48.stream(cacheStream = stream), alaska.stream(stream), hawaii.stream(stream)]);
+              };
+              albersUsa2.precision = function(_2) {
+                if (!arguments.length) return lower48.precision();
+                lower48.precision(_2), alaska.precision(_2), hawaii.precision(_2);
+                return reset();
+              };
+              albersUsa2.scale = function(_2) {
+                if (!arguments.length) return lower48.scale();
+                lower48.scale(_2), alaska.scale(_2 * 0.35), hawaii.scale(_2);
+                return albersUsa2.translate(lower48.translate());
+              };
+              albersUsa2.translate = function(_2) {
+                if (!arguments.length) return lower48.translate();
+                var k2 = lower48.scale(), x2 = +_2[0], y2 = +_2[1];
+                lower48Point = lower48.translate(_2).clipExtent([[x2 - 0.455 * k2, y2 - 0.238 * k2], [x2 + 0.455 * k2, y2 + 0.238 * k2]]).stream(pointStream);
+                alaskaPoint = alaska.translate([x2 - 0.307 * k2, y2 + 0.201 * k2]).clipExtent([[x2 - 0.425 * k2 + epsilon, y2 + 0.12 * k2 + epsilon], [x2 - 0.214 * k2 - epsilon, y2 + 0.234 * k2 - epsilon]]).stream(pointStream);
+                hawaiiPoint = hawaii.translate([x2 - 0.205 * k2, y2 + 0.212 * k2]).clipExtent([[x2 - 0.214 * k2 + epsilon, y2 + 0.166 * k2 + epsilon], [x2 - 0.115 * k2 - epsilon, y2 + 0.234 * k2 - epsilon]]).stream(pointStream);
+                return reset();
+              };
+              albersUsa2.fitExtent = function(extent2, object2) {
+                return fitExtent(albersUsa2, extent2, object2);
+              };
+              albersUsa2.fitSize = function(size, object2) {
+                return fitSize(albersUsa2, size, object2);
+              };
+              albersUsa2.fitWidth = function(width, object2) {
+                return fitWidth(albersUsa2, width, object2);
+              };
+              albersUsa2.fitHeight = function(height, object2) {
+                return fitHeight(albersUsa2, height, object2);
+              };
+              function reset() {
+                cache = cacheStream = null;
+                return albersUsa2;
+              }
+              return albersUsa2.scale(1070);
+            }
+            function azimuthalRaw(scale2) {
+              return function(x2, y2) {
+                var cx = cos(x2), cy = cos(y2), k2 = scale2(cx * cy);
+                return [
+                  k2 * cy * sin(x2),
+                  k2 * sin(y2)
+                ];
+              };
+            }
+            function azimuthalInvert(angle22) {
+              return function(x2, y2) {
+                var z2 = sqrt(x2 * x2 + y2 * y2), c2 = angle22(z2), sc2 = sin(c2), cc2 = cos(c2);
+                return [
+                  atan2(x2 * sc2, z2 * cc2),
+                  asin(z2 && y2 * sc2 / z2)
+                ];
+              };
+            }
+            var azimuthalEqualAreaRaw = azimuthalRaw(function(cxcy) {
+              return sqrt(2 / (1 + cxcy));
+            });
+            azimuthalEqualAreaRaw.invert = azimuthalInvert(function(z2) {
+              return 2 * asin(z2 / 2);
+            });
+            function azimuthalEqualArea() {
+              return projection(azimuthalEqualAreaRaw).scale(124.75).clipAngle(180 - 1e-3);
+            }
+            var azimuthalEquidistantRaw = azimuthalRaw(function(c2) {
+              return (c2 = acos(c2)) && c2 / sin(c2);
+            });
+            azimuthalEquidistantRaw.invert = azimuthalInvert(function(z2) {
+              return z2;
+            });
+            function azimuthalEquidistant() {
+              return projection(azimuthalEquidistantRaw).scale(79.4188).clipAngle(180 - 1e-3);
+            }
+            function mercatorRaw(lambda, phi) {
+              return [lambda, log3(tan((halfPi + phi) / 2))];
+            }
+            mercatorRaw.invert = function(x2, y2) {
+              return [x2, 2 * atan(exp(y2)) - halfPi];
+            };
+            function mercator() {
+              return mercatorProjection(mercatorRaw).scale(961 / tau);
+            }
+            function mercatorProjection(project2) {
+              var m2 = projection(project2), center = m2.center, scale2 = m2.scale, translate2 = m2.translate, clipExtent = m2.clipExtent, x02 = null, y02, x12, y12;
+              m2.scale = function(_2) {
+                return arguments.length ? (scale2(_2), reclip()) : scale2();
+              };
+              m2.translate = function(_2) {
+                return arguments.length ? (translate2(_2), reclip()) : translate2();
+              };
+              m2.center = function(_2) {
+                return arguments.length ? (center(_2), reclip()) : center();
+              };
+              m2.clipExtent = function(_2) {
+                return arguments.length ? (_2 == null ? x02 = y02 = x12 = y12 = null : (x02 = +_2[0][0], y02 = +_2[0][1], x12 = +_2[1][0], y12 = +_2[1][1]), reclip()) : x02 == null ? null : [[x02, y02], [x12, y12]];
+              };
+              function reclip() {
+                var k2 = pi2 * scale2(), t4 = m2(rotation(m2.rotate()).invert([0, 0]));
+                return clipExtent(x02 == null ? [[t4[0] - k2, t4[1] - k2], [t4[0] + k2, t4[1] + k2]] : project2 === mercatorRaw ? [[Math.max(t4[0] - k2, x02), y02], [Math.min(t4[0] + k2, x12), y12]] : [[x02, Math.max(t4[1] - k2, y02)], [x12, Math.min(t4[1] + k2, y12)]]);
+              }
+              return reclip();
+            }
+            function tany(y2) {
+              return tan((halfPi + y2) / 2);
+            }
+            function conicConformalRaw(y02, y12) {
+              var cy0 = cos(y02), n2 = y02 === y12 ? sin(y02) : log3(cy0 / cos(y12)) / log3(tany(y12) / tany(y02)), f2 = cy0 * pow(tany(y02), n2) / n2;
+              if (!n2) return mercatorRaw;
+              function project2(x2, y2) {
+                if (f2 > 0) {
+                  if (y2 < -halfPi + epsilon) y2 = -halfPi + epsilon;
+                } else {
+                  if (y2 > halfPi - epsilon) y2 = halfPi - epsilon;
+                }
+                var r2 = f2 / pow(tany(y2), n2);
+                return [r2 * sin(n2 * x2), f2 - r2 * cos(n2 * x2)];
+              }
+              project2.invert = function(x2, y2) {
+                var fy = f2 - y2, r2 = sign(n2) * sqrt(x2 * x2 + fy * fy), l2 = atan2(x2, abs(fy)) * sign(fy);
+                if (fy * n2 < 0)
+                  l2 -= pi2 * sign(x2) * sign(fy);
+                return [l2 / n2, 2 * atan(pow(f2 / r2, 1 / n2)) - halfPi];
+              };
+              return project2;
+            }
+            function conicConformal() {
+              return conicProjection(conicConformalRaw).scale(109.5).parallels([30, 30]);
+            }
+            function equirectangularRaw(lambda, phi) {
+              return [lambda, phi];
+            }
+            equirectangularRaw.invert = equirectangularRaw;
+            function equirectangular() {
+              return projection(equirectangularRaw).scale(152.63);
+            }
+            function conicEquidistantRaw(y02, y12) {
+              var cy0 = cos(y02), n2 = y02 === y12 ? sin(y02) : (cy0 - cos(y12)) / (y12 - y02), g2 = cy0 / n2 + y02;
+              if (abs(n2) < epsilon) return equirectangularRaw;
+              function project2(x2, y2) {
+                var gy = g2 - y2, nx = n2 * x2;
+                return [gy * sin(nx), g2 - gy * cos(nx)];
+              }
+              project2.invert = function(x2, y2) {
+                var gy = g2 - y2, l2 = atan2(x2, abs(gy)) * sign(gy);
+                if (gy * n2 < 0)
+                  l2 -= pi2 * sign(x2) * sign(gy);
+                return [l2 / n2, g2 - sign(n2) * sqrt(x2 * x2 + gy * gy)];
+              };
+              return project2;
+            }
+            function conicEquidistant() {
+              return conicProjection(conicEquidistantRaw).scale(131.154).center([0, 13.9389]);
+            }
+            var A1 = 1.340264, A22 = -0.081106, A3 = 893e-6, A4 = 3796e-6, M2 = sqrt(3) / 2, iterations = 12;
+            function equalEarthRaw(lambda, phi) {
+              var l2 = asin(M2 * sin(phi)), l22 = l2 * l2, l6 = l22 * l22 * l22;
+              return [
+                lambda * cos(l2) / (M2 * (A1 + 3 * A22 * l22 + l6 * (7 * A3 + 9 * A4 * l22))),
+                l2 * (A1 + A22 * l22 + l6 * (A3 + A4 * l22))
+              ];
+            }
+            equalEarthRaw.invert = function(x2, y2) {
+              var l2 = y2, l22 = l2 * l2, l6 = l22 * l22 * l22;
+              for (var i2 = 0, delta, fy, fpy; i2 < iterations; ++i2) {
+                fy = l2 * (A1 + A22 * l22 + l6 * (A3 + A4 * l22)) - y2;
+                fpy = A1 + 3 * A22 * l22 + l6 * (7 * A3 + 9 * A4 * l22);
+                l2 -= delta = fy / fpy, l22 = l2 * l2, l6 = l22 * l22 * l22;
+                if (abs(delta) < epsilon22) break;
+              }
+              return [
+                M2 * x2 * (A1 + 3 * A22 * l22 + l6 * (7 * A3 + 9 * A4 * l22)) / cos(l2),
+                asin(sin(l2) / M2)
+              ];
+            };
+            function equalEarth() {
+              return projection(equalEarthRaw).scale(177.158);
+            }
+            function gnomonicRaw(x2, y2) {
+              var cy = cos(y2), k2 = cos(x2) * cy;
+              return [cy * sin(x2) / k2, sin(y2) / k2];
+            }
+            gnomonicRaw.invert = azimuthalInvert(atan);
+            function gnomonic() {
+              return projection(gnomonicRaw).scale(144.049).clipAngle(60);
+            }
+            function identity$1() {
+              var k2 = 1, tx = 0, ty = 0, sx = 1, sy = 1, alpha = 0, ca2, sa2, x02 = null, y02, x12, y12, kx = 1, ky = 1, transform2 = transformer({
+                point: function(x2, y2) {
+                  var p2 = projection2([x2, y2]);
+                  this.stream.point(p2[0], p2[1]);
+                }
+              }), postclip = identity22, cache, cacheStream;
+              function reset() {
+                kx = k2 * sx;
+                ky = k2 * sy;
+                cache = cacheStream = null;
+                return projection2;
+              }
+              function projection2(p2) {
+                var x2 = p2[0] * kx, y2 = p2[1] * ky;
+                if (alpha) {
+                  var t4 = y2 * ca2 - x2 * sa2;
+                  x2 = x2 * ca2 + y2 * sa2;
+                  y2 = t4;
+                }
+                return [x2 + tx, y2 + ty];
+              }
+              projection2.invert = function(p2) {
+                var x2 = p2[0] - tx, y2 = p2[1] - ty;
+                if (alpha) {
+                  var t4 = y2 * ca2 + x2 * sa2;
+                  x2 = x2 * ca2 - y2 * sa2;
+                  y2 = t4;
+                }
+                return [x2 / kx, y2 / ky];
+              };
+              projection2.stream = function(stream) {
+                return cache && cacheStream === stream ? cache : cache = transform2(postclip(cacheStream = stream));
+              };
+              projection2.postclip = function(_2) {
+                return arguments.length ? (postclip = _2, x02 = y02 = x12 = y12 = null, reset()) : postclip;
+              };
+              projection2.clipExtent = function(_2) {
+                return arguments.length ? (postclip = _2 == null ? (x02 = y02 = x12 = y12 = null, identity22) : clipRectangle(x02 = +_2[0][0], y02 = +_2[0][1], x12 = +_2[1][0], y12 = +_2[1][1]), reset()) : x02 == null ? null : [[x02, y02], [x12, y12]];
+              };
+              projection2.scale = function(_2) {
+                return arguments.length ? (k2 = +_2, reset()) : k2;
+              };
+              projection2.translate = function(_2) {
+                return arguments.length ? (tx = +_2[0], ty = +_2[1], reset()) : [tx, ty];
+              };
+              projection2.angle = function(_2) {
+                return arguments.length ? (alpha = _2 % 360 * radians2, sa2 = sin(alpha), ca2 = cos(alpha), reset()) : alpha * degrees3;
+              };
+              projection2.reflectX = function(_2) {
+                return arguments.length ? (sx = _2 ? -1 : 1, reset()) : sx < 0;
+              };
+              projection2.reflectY = function(_2) {
+                return arguments.length ? (sy = _2 ? -1 : 1, reset()) : sy < 0;
+              };
+              projection2.fitExtent = function(extent2, object2) {
+                return fitExtent(projection2, extent2, object2);
+              };
+              projection2.fitSize = function(size, object2) {
+                return fitSize(projection2, size, object2);
+              };
+              projection2.fitWidth = function(width, object2) {
+                return fitWidth(projection2, width, object2);
+              };
+              projection2.fitHeight = function(height, object2) {
+                return fitHeight(projection2, height, object2);
+              };
+              return projection2;
+            }
+            function naturalEarth1Raw(lambda, phi) {
+              var phi2 = phi * phi, phi4 = phi2 * phi2;
+              return [
+                lambda * (0.8707 - 0.131979 * phi2 + phi4 * (-0.013791 + phi4 * (3971e-6 * phi2 - 1529e-6 * phi4))),
+                phi * (1.007226 + phi2 * (0.015085 + phi4 * (-0.044475 + 0.028874 * phi2 - 5916e-6 * phi4)))
+              ];
+            }
+            naturalEarth1Raw.invert = function(x2, y2) {
+              var phi = y2, i2 = 25, delta;
+              do {
+                var phi2 = phi * phi, phi4 = phi2 * phi2;
+                phi -= delta = (phi * (1.007226 + phi2 * (0.015085 + phi4 * (-0.044475 + 0.028874 * phi2 - 5916e-6 * phi4))) - y2) / (1.007226 + phi2 * (0.015085 * 3 + phi4 * (-0.044475 * 7 + 0.028874 * 9 * phi2 - 5916e-6 * 11 * phi4)));
+              } while (abs(delta) > epsilon && --i2 > 0);
+              return [
+                x2 / (0.8707 + (phi2 = phi * phi) * (-0.131979 + phi2 * (-0.013791 + phi2 * phi2 * phi2 * (3971e-6 - 1529e-6 * phi2)))),
+                phi
+              ];
+            };
+            function naturalEarth1() {
+              return projection(naturalEarth1Raw).scale(175.295);
+            }
+            function orthographicRaw(x2, y2) {
+              return [cos(y2) * sin(x2), sin(y2)];
+            }
+            orthographicRaw.invert = azimuthalInvert(asin);
+            function orthographic() {
+              return projection(orthographicRaw).scale(249.5).clipAngle(90 + epsilon);
             }
-          }
-        }
-        return this;
-      },
-      // @method closeTooltip(): this
-      // Closes the tooltip bound to this layer if it is open.
-      closeTooltip: function() {
-        if (this._tooltip) {
-          return this._tooltip.close();
-        }
-      },
-      // @method toggleTooltip(): this
-      // Opens or closes the tooltip bound to this layer depending on its current state.
-      toggleTooltip: function() {
-        if (this._tooltip) {
-          this._tooltip.toggle(this);
-        }
-        return this;
-      },
-      // @method isTooltipOpen(): boolean
-      // Returns `true` if the tooltip bound to this layer is currently open.
-      isTooltipOpen: function() {
-        return this._tooltip.isOpen();
-      },
-      // @method setTooltipContent(content: String|HTMLElement|Tooltip): this
-      // Sets the content of the tooltip bound to this layer.
-      setTooltipContent: function(content) {
-        if (this._tooltip) {
-          this._tooltip.setContent(content);
-        }
-        return this;
-      },
-      // @method getTooltip(): Tooltip
-      // Returns the tooltip bound to this layer.
-      getTooltip: function() {
-        return this._tooltip;
-      },
-      _addFocusListeners: function() {
-        if (this.getElement) {
-          this._addFocusListenersOnLayer(this);
-        } else if (this.eachLayer) {
-          this.eachLayer(this._addFocusListenersOnLayer, this);
-        }
-      },
-      _addFocusListenersOnLayer: function(layer) {
-        var el2 = typeof layer.getElement === "function" && layer.getElement();
-        if (el2) {
-          on(el2, "focus", function() {
-            this._tooltip._source = layer;
-            this.openTooltip();
-          }, this);
-          on(el2, "blur", this.closeTooltip, this);
-        }
-      },
-      _setAriaDescribedByOnLayer: function(layer) {
-        var el2 = typeof layer.getElement === "function" && layer.getElement();
-        if (el2) {
-          el2.setAttribute("aria-describedby", this._tooltip._container.id);
-        }
-      },
-      _openTooltip: function(e) {
-        if (!this._tooltip || !this._map) {
-          return;
-        }
-        if (this._map.dragging && this._map.dragging.moving() && !this._openOnceFlag) {
-          this._openOnceFlag = true;
-          var that = this;
-          this._map.once("moveend", function() {
-            that._openOnceFlag = false;
-            that._openTooltip(e);
+            function stereographicRaw(x2, y2) {
+              var cy = cos(y2), k2 = 1 + cos(x2) * cy;
+              return [cy * sin(x2) / k2, sin(y2) / k2];
+            }
+            stereographicRaw.invert = azimuthalInvert(function(z2) {
+              return 2 * atan(z2);
+            });
+            function stereographic() {
+              return projection(stereographicRaw).scale(250).clipAngle(142);
+            }
+            function transverseMercatorRaw(lambda, phi) {
+              return [log3(tan((halfPi + phi) / 2)), -lambda];
+            }
+            transverseMercatorRaw.invert = function(x2, y2) {
+              return [-y2, 2 * atan(exp(x2)) - halfPi];
+            };
+            function transverseMercator() {
+              var m2 = mercatorProjection(transverseMercatorRaw), center = m2.center, rotate2 = m2.rotate;
+              m2.center = function(_2) {
+                return arguments.length ? center([-_2[1], _2[0]]) : (_2 = center(), [_2[1], -_2[0]]);
+              };
+              m2.rotate = function(_2) {
+                return arguments.length ? rotate2([_2[0], _2[1], _2.length > 2 ? _2[2] + 90 : 90]) : (_2 = rotate2(), [_2[0], _2[1], _2[2] - 90]);
+              };
+              return rotate2([0, 0, 90]).scale(159.155);
+            }
+            exports2.geoAlbers = albers;
+            exports2.geoAlbersUsa = albersUsa;
+            exports2.geoArea = area;
+            exports2.geoAzimuthalEqualArea = azimuthalEqualArea;
+            exports2.geoAzimuthalEqualAreaRaw = azimuthalEqualAreaRaw;
+            exports2.geoAzimuthalEquidistant = azimuthalEquidistant;
+            exports2.geoAzimuthalEquidistantRaw = azimuthalEquidistantRaw;
+            exports2.geoBounds = bounds;
+            exports2.geoCentroid = centroid;
+            exports2.geoCircle = circle;
+            exports2.geoClipAntimeridian = clipAntimeridian;
+            exports2.geoClipCircle = clipCircle;
+            exports2.geoClipExtent = extent;
+            exports2.geoClipRectangle = clipRectangle;
+            exports2.geoConicConformal = conicConformal;
+            exports2.geoConicConformalRaw = conicConformalRaw;
+            exports2.geoConicEqualArea = conicEqualArea;
+            exports2.geoConicEqualAreaRaw = conicEqualAreaRaw;
+            exports2.geoConicEquidistant = conicEquidistant;
+            exports2.geoConicEquidistantRaw = conicEquidistantRaw;
+            exports2.geoContains = contains;
+            exports2.geoDistance = distance2;
+            exports2.geoEqualEarth = equalEarth;
+            exports2.geoEqualEarthRaw = equalEarthRaw;
+            exports2.geoEquirectangular = equirectangular;
+            exports2.geoEquirectangularRaw = equirectangularRaw;
+            exports2.geoGnomonic = gnomonic;
+            exports2.geoGnomonicRaw = gnomonicRaw;
+            exports2.geoGraticule = graticule;
+            exports2.geoGraticule10 = graticule10;
+            exports2.geoIdentity = identity$1;
+            exports2.geoInterpolate = interpolate;
+            exports2.geoLength = length2;
+            exports2.geoMercator = mercator;
+            exports2.geoMercatorRaw = mercatorRaw;
+            exports2.geoNaturalEarth1 = naturalEarth1;
+            exports2.geoNaturalEarth1Raw = naturalEarth1Raw;
+            exports2.geoOrthographic = orthographic;
+            exports2.geoOrthographicRaw = orthographicRaw;
+            exports2.geoPath = index;
+            exports2.geoProjection = projection;
+            exports2.geoProjectionMutator = projectionMutator;
+            exports2.geoRotation = rotation;
+            exports2.geoStereographic = stereographic;
+            exports2.geoStereographicRaw = stereographicRaw;
+            exports2.geoStream = geoStream;
+            exports2.geoTransform = transform;
+            exports2.geoTransverseMercator = transverseMercator;
+            exports2.geoTransverseMercatorRaw = transverseMercatorRaw;
+            Object.defineProperty(exports2, "__esModule", { value: true });
           });
-          return;
-        }
-        this._tooltip._source = e.layer || e.target;
-        this.openTooltip(this._tooltip.options.sticky ? e.latlng : void 0);
-      },
-      _moveTooltip: function(e) {
-        var latlng = e.latlng, containerPoint, layerPoint;
-        if (this._tooltip.options.sticky && e.originalEvent) {
-          containerPoint = this._map.mouseEventToContainerPoint(e.originalEvent);
-          layerPoint = this._map.containerPointToLayerPoint(containerPoint);
-          latlng = this._map.layerPointToLatLng(layerPoint);
-        }
-        this._tooltip.setLatLng(latlng);
-      }
-    });
-    var DivIcon = Icon.extend({
-      options: {
-        // @section
-        // @aka DivIcon options
-        iconSize: [12, 12],
-        // also can be set through CSS
-        // iconAnchor: (Point),
-        // popupAnchor: (Point),
-        // @option html: String|HTMLElement = ''
-        // Custom HTML code to put inside the div element, empty by default. Alternatively,
-        // an instance of `HTMLElement`.
-        html: false,
-        // @option bgPos: Point = [0, 0]
-        // Optional relative position of the background, in pixels
-        bgPos: null,
-        className: "leaflet-div-icon"
-      },
-      createIcon: function(oldIcon) {
-        var div = oldIcon && oldIcon.tagName === "DIV" ? oldIcon : document.createElement("div"), options = this.options;
-        if (options.html instanceof Element) {
-          empty(div);
-          div.appendChild(options.html);
-        } else {
-          div.innerHTML = options.html !== false ? options.html : "";
-        }
-        if (options.bgPos) {
-          var bgPos = toPoint(options.bgPos);
-          div.style.backgroundPosition = -bgPos.x + "px " + -bgPos.y + "px";
-        }
-        this._setIconStyles(div, "icon");
-        return div;
-      },
-      createShadow: function() {
-        return null;
-      }
-    });
-    function divIcon(options) {
-      return new DivIcon(options);
-    }
-    Icon.Default = IconDefault;
-    var GridLayer = Layer.extend({
-      // @section
-      // @aka GridLayer options
-      options: {
-        // @option tileSize: Number|Point = 256
-        // Width and height of tiles in the grid. Use a number if width and height are equal, or `L.point(width, height)` otherwise.
-        tileSize: 256,
-        // @option opacity: Number = 1.0
-        // Opacity of the tiles. Can be used in the `createTile()` function.
-        opacity: 1,
-        // @option updateWhenIdle: Boolean = (depends)
-        // Load new tiles only when panning ends.
-        // `true` by default on mobile browsers, in order to avoid too many requests and keep smooth navigation.
-        // `false` otherwise in order to display new tiles _during_ panning, since it is easy to pan outside the
-        // [`keepBuffer`](#gridlayer-keepbuffer) option in desktop browsers.
-        updateWhenIdle: Browser.mobile,
-        // @option updateWhenZooming: Boolean = true
-        // By default, a smooth zoom animation (during a [touch zoom](#map-touchzoom) or a [`flyTo()`](#map-flyto)) will update grid layers every integer zoom level. Setting this option to `false` will update the grid layer only when the smooth animation ends.
-        updateWhenZooming: true,
-        // @option updateInterval: Number = 200
-        // Tiles will not update more than once every `updateInterval` milliseconds when panning.
-        updateInterval: 200,
-        // @option zIndex: Number = 1
-        // The explicit zIndex of the tile layer.
-        zIndex: 1,
-        // @option bounds: LatLngBounds = undefined
-        // If set, tiles will only be loaded inside the set `LatLngBounds`.
-        bounds: null,
-        // @option minZoom: Number = 0
-        // The minimum zoom level down to which this layer will be displayed (inclusive).
-        minZoom: 0,
-        // @option maxZoom: Number = undefined
-        // The maximum zoom level up to which this layer will be displayed (inclusive).
-        maxZoom: void 0,
-        // @option maxNativeZoom: Number = undefined
-        // Maximum zoom number the tile source has available. If it is specified,
-        // the tiles on all zoom levels higher than `maxNativeZoom` will be loaded
-        // from `maxNativeZoom` level and auto-scaled.
-        maxNativeZoom: void 0,
-        // @option minNativeZoom: Number = undefined
-        // Minimum zoom number the tile source has available. If it is specified,
-        // the tiles on all zoom levels lower than `minNativeZoom` will be loaded
-        // from `minNativeZoom` level and auto-scaled.
-        minNativeZoom: void 0,
-        // @option noWrap: Boolean = false
-        // Whether the layer is wrapped around the antimeridian. If `true`, the
-        // GridLayer will only be displayed once at low zoom levels. Has no
-        // effect when the [map CRS](#map-crs) doesn't wrap around. Can be used
-        // in combination with [`bounds`](#gridlayer-bounds) to prevent requesting
-        // tiles outside the CRS limits.
-        noWrap: false,
-        // @option pane: String = 'tilePane'
-        // `Map pane` where the grid layer will be added.
-        pane: "tilePane",
-        // @option className: String = ''
-        // A custom class name to assign to the tile layer. Empty by default.
-        className: "",
-        // @option keepBuffer: Number = 2
-        // When panning the map, keep this many rows and columns of tiles before unloading them.
-        keepBuffer: 2
-      },
-      initialize: function(options) {
-        setOptions2(this, options);
-      },
-      onAdd: function() {
-        this._initContainer();
-        this._levels = {};
-        this._tiles = {};
-        this._resetView();
-      },
-      beforeAdd: function(map2) {
-        map2._addZoomLimit(this);
-      },
-      onRemove: function(map2) {
-        this._removeAllTiles();
-        remove(this._container);
-        map2._removeZoomLimit(this);
-        this._container = null;
-        this._tileZoom = void 0;
-      },
-      // @method bringToFront: this
-      // Brings the tile layer to the top of all tile layers.
-      bringToFront: function() {
-        if (this._map) {
-          toFront(this._container);
-          this._setAutoZIndex(Math.max);
-        }
-        return this;
-      },
-      // @method bringToBack: this
-      // Brings the tile layer to the bottom of all tile layers.
-      bringToBack: function() {
-        if (this._map) {
-          toBack(this._container);
-          this._setAutoZIndex(Math.min);
-        }
-        return this;
-      },
-      // @method getContainer: HTMLElement
-      // Returns the HTML element that contains the tiles for this layer.
-      getContainer: function() {
-        return this._container;
-      },
-      // @method setOpacity(opacity: Number): this
-      // Changes the [opacity](#gridlayer-opacity) of the grid layer.
-      setOpacity: function(opacity) {
-        this.options.opacity = opacity;
-        this._updateOpacity();
-        return this;
-      },
-      // @method setZIndex(zIndex: Number): this
-      // Changes the [zIndex](#gridlayer-zindex) of the grid layer.
-      setZIndex: function(zIndex) {
-        this.options.zIndex = zIndex;
-        this._updateZIndex();
-        return this;
-      },
-      // @method isLoading: Boolean
-      // Returns `true` if any tile in the grid layer has not finished loading.
-      isLoading: function() {
-        return this._loading;
-      },
-      // @method redraw: this
-      // Causes the layer to clear all the tiles and request them again.
-      redraw: function() {
-        if (this._map) {
-          this._removeAllTiles();
-          var tileZoom = this._clampZoom(this._map.getZoom());
-          if (tileZoom !== this._tileZoom) {
-            this._tileZoom = tileZoom;
-            this._updateLevels();
-          }
-          this._update();
-        }
-        return this;
-      },
-      getEvents: function() {
-        var events = {
-          viewprereset: this._invalidateAll,
-          viewreset: this._resetView,
-          zoom: this._resetView,
-          moveend: this._onMoveEnd
-        };
-        if (!this.options.updateWhenIdle) {
-          if (!this._onMove) {
-            this._onMove = throttle(this._onMoveEnd, this.options.updateInterval, this);
-          }
-          events.move = this._onMove;
-        }
-        if (this._zoomAnimated) {
-          events.zoomanim = this._animateZoom;
-        }
-        return events;
-      },
-      // @section Extension methods
-      // Layers extending `GridLayer` shall reimplement the following method.
-      // @method createTile(coords: Object, done?: Function): HTMLElement
-      // Called only internally, must be overridden by classes extending `GridLayer`.
-      // Returns the `HTMLElement` corresponding to the given `coords`. If the `done` callback
-      // is specified, it must be called when the tile has finished loading and drawing.
-      createTile: function() {
-        return document.createElement("div");
-      },
-      // @section
-      // @method getTileSize: Point
-      // Normalizes the [tileSize option](#gridlayer-tilesize) into a point. Used by the `createTile()` method.
-      getTileSize: function() {
-        var s = this.options.tileSize;
-        return s instanceof Point ? s : new Point(s, s);
-      },
-      _updateZIndex: function() {
-        if (this._container && this.options.zIndex !== void 0 && this.options.zIndex !== null) {
-          this._container.style.zIndex = this.options.zIndex;
-        }
-      },
-      _setAutoZIndex: function(compare) {
-        var layers2 = this.getPane().children, edgeZIndex = -compare(-Infinity, Infinity);
-        for (var i = 0, len = layers2.length, zIndex; i < len; i++) {
-          zIndex = layers2[i].style.zIndex;
-          if (layers2[i] !== this._container && zIndex) {
-            edgeZIndex = compare(edgeZIndex, +zIndex);
-          }
-        }
-        if (isFinite(edgeZIndex)) {
-          this.options.zIndex = edgeZIndex + compare(-1, 1);
-          this._updateZIndex();
-        }
-      },
-      _updateOpacity: function() {
-        if (!this._map) {
-          return;
         }
-        if (Browser.ielt9) {
-          return;
-        }
-        setOpacity(this._container, this.options.opacity);
-        var now = +/* @__PURE__ */ new Date(), nextFrame = false, willPrune = false;
-        for (var key in this._tiles) {
-          var tile = this._tiles[key];
-          if (!tile.current || !tile.loaded) {
-            continue;
-          }
-          var fade = Math.min(1, (now - tile.loaded) / 200);
-          setOpacity(tile.el, fade);
-          if (fade < 1) {
-            nextFrame = true;
-          } else {
-            if (tile.active) {
-              willPrune = true;
-            } else {
-              this._onOpaqueTile(tile);
+      });
+      var require_d3_geo_projection = __commonJS({
+        "node_modules/d3-geo-projection/dist/d3-geo-projection.js"(exports, module2) {
+          (function(global2, factory2) {
+            typeof exports === "object" && typeof module2 !== "undefined" ? factory2(exports, require_d3_geo(), require_d3_array()) : factory2(global2.d3 = global2.d3 || {}, global2.d3, global2.d3);
+          })(exports, function(exports2, d3Geo, d3Array) {
+            var abs = Math.abs;
+            var atan = Math.atan;
+            var atan2 = Math.atan2;
+            var cos = Math.cos;
+            var exp = Math.exp;
+            var floor = Math.floor;
+            var log3 = Math.log;
+            var max = Math.max;
+            var min = Math.min;
+            var pow = Math.pow;
+            var round2 = Math.round;
+            var sign = Math.sign || function(x2) {
+              return x2 > 0 ? 1 : x2 < 0 ? -1 : 0;
+            };
+            var sin = Math.sin;
+            var tan = Math.tan;
+            var epsilon = 1e-6;
+            var epsilon22 = 1e-12;
+            var pi2 = Math.PI;
+            var halfPi = pi2 / 2;
+            var quarterPi = pi2 / 4;
+            var sqrt1_2 = Math.SQRT1_2;
+            var sqrt2 = sqrt(2);
+            var sqrtPi = sqrt(pi2);
+            var tau = pi2 * 2;
+            var degrees3 = 180 / pi2;
+            var radians2 = pi2 / 180;
+            function sinci(x2) {
+              return x2 ? x2 / Math.sin(x2) : 1;
             }
-            tile.active = true;
-          }
-        }
-        if (willPrune && !this._noPrune) {
-          this._pruneTiles();
-        }
-        if (nextFrame) {
-          cancelAnimFrame(this._fadeFrame);
-          this._fadeFrame = requestAnimFrame2(this._updateOpacity, this);
-        }
-      },
-      _onOpaqueTile: falseFn,
-      _initContainer: function() {
-        if (this._container) {
-          return;
-        }
-        this._container = create$1("div", "leaflet-layer " + (this.options.className || ""));
-        this._updateZIndex();
-        if (this.options.opacity < 1) {
-          this._updateOpacity();
-        }
-        this.getPane().appendChild(this._container);
-      },
-      _updateLevels: function() {
-        var zoom2 = this._tileZoom, maxZoom = this.options.maxZoom;
-        if (zoom2 === void 0) {
-          return void 0;
-        }
-        for (var z2 in this._levels) {
-          z2 = Number(z2);
-          if (this._levels[z2].el.children.length || z2 === zoom2) {
-            this._levels[z2].el.style.zIndex = maxZoom - Math.abs(zoom2 - z2);
-            this._onUpdateLevel(z2);
-          } else {
-            remove(this._levels[z2].el);
-            this._removeTilesAtZoom(z2);
-            this._onRemoveLevel(z2);
-            delete this._levels[z2];
-          }
-        }
-        var level = this._levels[zoom2], map2 = this._map;
-        if (!level) {
-          level = this._levels[zoom2] = {};
-          level.el = create$1("div", "leaflet-tile-container leaflet-zoom-animated", this._container);
-          level.el.style.zIndex = maxZoom;
-          level.origin = map2.project(map2.unproject(map2.getPixelOrigin()), zoom2).round();
-          level.zoom = zoom2;
-          this._setZoomTransform(level, map2.getCenter(), map2.getZoom());
-          falseFn(level.el.offsetWidth);
-          this._onCreateLevel(level);
-        }
-        this._level = level;
-        return level;
-      },
-      _onUpdateLevel: falseFn,
-      _onRemoveLevel: falseFn,
-      _onCreateLevel: falseFn,
-      _pruneTiles: function() {
-        if (!this._map) {
-          return;
-        }
-        var key, tile;
-        var zoom2 = this._map.getZoom();
-        if (zoom2 > this.options.maxZoom || zoom2 < this.options.minZoom) {
-          this._removeAllTiles();
-          return;
-        }
-        for (key in this._tiles) {
-          tile = this._tiles[key];
-          tile.retain = tile.current;
-        }
-        for (key in this._tiles) {
-          tile = this._tiles[key];
-          if (tile.current && !tile.active) {
-            var coords = tile.coords;
-            if (!this._retainParent(coords.x, coords.y, coords.z, coords.z - 5)) {
-              this._retainChildren(coords.x, coords.y, coords.z, coords.z + 2);
+            function asin(x2) {
+              return x2 > 1 ? halfPi : x2 < -1 ? -halfPi : Math.asin(x2);
             }
-          }
-        }
-        for (key in this._tiles) {
-          if (!this._tiles[key].retain) {
-            this._removeTile(key);
-          }
-        }
-      },
-      _removeTilesAtZoom: function(zoom2) {
-        for (var key in this._tiles) {
-          if (this._tiles[key].coords.z !== zoom2) {
-            continue;
-          }
-          this._removeTile(key);
-        }
-      },
-      _removeAllTiles: function() {
-        for (var key in this._tiles) {
-          this._removeTile(key);
-        }
-      },
-      _invalidateAll: function() {
-        for (var z2 in this._levels) {
-          remove(this._levels[z2].el);
-          this._onRemoveLevel(Number(z2));
-          delete this._levels[z2];
-        }
-        this._removeAllTiles();
-        this._tileZoom = void 0;
-      },
-      _retainParent: function(x2, y2, z2, minZoom) {
-        var x22 = Math.floor(x2 / 2), y22 = Math.floor(y2 / 2), z22 = z2 - 1, coords2 = new Point(+x22, +y22);
-        coords2.z = +z22;
-        var key = this._tileCoordsToKey(coords2), tile = this._tiles[key];
-        if (tile && tile.active) {
-          tile.retain = true;
-          return true;
-        } else if (tile && tile.loaded) {
-          tile.retain = true;
-        }
-        if (z22 > minZoom) {
-          return this._retainParent(x22, y22, z22, minZoom);
-        }
-        return false;
-      },
-      _retainChildren: function(x2, y2, z2, maxZoom) {
-        for (var i = 2 * x2; i < 2 * x2 + 2; i++) {
-          for (var j = 2 * y2; j < 2 * y2 + 2; j++) {
-            var coords = new Point(i, j);
-            coords.z = z2 + 1;
-            var key = this._tileCoordsToKey(coords), tile = this._tiles[key];
-            if (tile && tile.active) {
-              tile.retain = true;
-              continue;
-            } else if (tile && tile.loaded) {
-              tile.retain = true;
+            function acos(x2) {
+              return x2 > 1 ? 0 : x2 < -1 ? pi2 : Math.acos(x2);
             }
-            if (z2 + 1 < maxZoom) {
-              this._retainChildren(i, j, z2 + 1, maxZoom);
+            function sqrt(x2) {
+              return x2 > 0 ? Math.sqrt(x2) : 0;
             }
-          }
-        }
-      },
-      _resetView: function(e) {
-        var animating = e && (e.pinch || e.flyTo);
-        this._setView(this._map.getCenter(), this._map.getZoom(), animating, animating);
-      },
-      _animateZoom: function(e) {
-        this._setView(e.center, e.zoom, true, e.noUpdate);
-      },
-      _clampZoom: function(zoom2) {
-        var options = this.options;
-        if (void 0 !== options.minNativeZoom && zoom2 < options.minNativeZoom) {
-          return options.minNativeZoom;
-        }
-        if (void 0 !== options.maxNativeZoom && options.maxNativeZoom < zoom2) {
-          return options.maxNativeZoom;
-        }
-        return zoom2;
-      },
-      _setView: function(center, zoom2, noPrune, noUpdate) {
-        var tileZoom = Math.round(zoom2);
-        if (this.options.maxZoom !== void 0 && tileZoom > this.options.maxZoom || this.options.minZoom !== void 0 && tileZoom < this.options.minZoom) {
-          tileZoom = void 0;
-        } else {
-          tileZoom = this._clampZoom(tileZoom);
-        }
-        var tileZoomChanged = this.options.updateWhenZooming && tileZoom !== this._tileZoom;
-        if (!noUpdate || tileZoomChanged) {
-          this._tileZoom = tileZoom;
-          if (this._abortLoading) {
-            this._abortLoading();
-          }
-          this._updateLevels();
-          this._resetGrid();
-          if (tileZoom !== void 0) {
-            this._update(center);
-          }
-          if (!noPrune) {
-            this._pruneTiles();
-          }
-          this._noPrune = !!noPrune;
-        }
-        this._setZoomTransforms(center, zoom2);
-      },
-      _setZoomTransforms: function(center, zoom2) {
-        for (var i in this._levels) {
-          this._setZoomTransform(this._levels[i], center, zoom2);
-        }
-      },
-      _setZoomTransform: function(level, center, zoom2) {
-        var scale2 = this._map.getZoomScale(zoom2, level.zoom), translate = level.origin.multiplyBy(scale2).subtract(this._map._getNewPixelOrigin(center, zoom2)).round();
-        if (Browser.any3d) {
-          setTransform(level.el, translate, scale2);
-        } else {
-          setPosition(level.el, translate);
-        }
-      },
-      _resetGrid: function() {
-        var map2 = this._map, crs = map2.options.crs, tileSize = this._tileSize = this.getTileSize(), tileZoom = this._tileZoom;
-        var bounds = this._map.getPixelWorldBounds(this._tileZoom);
-        if (bounds) {
-          this._globalTileRange = this._pxBoundsToTileRange(bounds);
-        }
-        this._wrapX = crs.wrapLng && !this.options.noWrap && [
-          Math.floor(map2.project([0, crs.wrapLng[0]], tileZoom).x / tileSize.x),
-          Math.ceil(map2.project([0, crs.wrapLng[1]], tileZoom).x / tileSize.y)
-        ];
-        this._wrapY = crs.wrapLat && !this.options.noWrap && [
-          Math.floor(map2.project([crs.wrapLat[0], 0], tileZoom).y / tileSize.x),
-          Math.ceil(map2.project([crs.wrapLat[1], 0], tileZoom).y / tileSize.y)
-        ];
-      },
-      _onMoveEnd: function() {
-        if (!this._map || this._map._animatingZoom) {
-          return;
-        }
-        this._update();
-      },
-      _getTiledPixelBounds: function(center) {
-        var map2 = this._map, mapZoom = map2._animatingZoom ? Math.max(map2._animateToZoom, map2.getZoom()) : map2.getZoom(), scale2 = map2.getZoomScale(mapZoom, this._tileZoom), pixelCenter = map2.project(center, this._tileZoom).floor(), halfSize = map2.getSize().divideBy(scale2 * 2);
-        return new Bounds(pixelCenter.subtract(halfSize), pixelCenter.add(halfSize));
-      },
-      // Private method to load tiles in the grid's active zoom level according to map bounds
-      _update: function(center) {
-        var map2 = this._map;
-        if (!map2) {
-          return;
-        }
-        var zoom2 = this._clampZoom(map2.getZoom());
-        if (center === void 0) {
-          center = map2.getCenter();
-        }
-        if (this._tileZoom === void 0) {
-          return;
-        }
-        var pixelBounds = this._getTiledPixelBounds(center), tileRange = this._pxBoundsToTileRange(pixelBounds), tileCenter = tileRange.getCenter(), queue = [], margin = this.options.keepBuffer, noPruneRange = new Bounds(
-          tileRange.getBottomLeft().subtract([margin, -margin]),
-          tileRange.getTopRight().add([margin, -margin])
-        );
-        if (!(isFinite(tileRange.min.x) && isFinite(tileRange.min.y) && isFinite(tileRange.max.x) && isFinite(tileRange.max.y))) {
-          throw new Error("Attempted to load an infinite number of tiles");
-        }
-        for (var key in this._tiles) {
-          var c = this._tiles[key].coords;
-          if (c.z !== this._tileZoom || !noPruneRange.contains(new Point(c.x, c.y))) {
-            this._tiles[key].current = false;
-          }
-        }
-        if (Math.abs(zoom2 - this._tileZoom) > 1) {
-          this._setView(center, zoom2);
-          return;
-        }
-        for (var j = tileRange.min.y; j <= tileRange.max.y; j++) {
-          for (var i = tileRange.min.x; i <= tileRange.max.x; i++) {
-            var coords = new Point(i, j);
-            coords.z = this._tileZoom;
-            if (!this._isValidTile(coords)) {
-              continue;
+            function tanh2(x2) {
+              x2 = exp(2 * x2);
+              return (x2 - 1) / (x2 + 1);
             }
-            var tile = this._tiles[this._tileCoordsToKey(coords)];
-            if (tile) {
-              tile.current = true;
-            } else {
-              queue.push(coords);
+            function sinh2(x2) {
+              return (exp(x2) - exp(-x2)) / 2;
             }
-          }
-        }
-        queue.sort(function(a, b) {
-          return a.distanceTo(tileCenter) - b.distanceTo(tileCenter);
-        });
-        if (queue.length !== 0) {
-          if (!this._loading) {
-            this._loading = true;
-            this.fire("loading");
-          }
-          var fragment = document.createDocumentFragment();
-          for (i = 0; i < queue.length; i++) {
-            this._addTile(queue[i], fragment);
-          }
-          this._level.el.appendChild(fragment);
-        }
-      },
-      _isValidTile: function(coords) {
-        var crs = this._map.options.crs;
-        if (!crs.infinite) {
-          var bounds = this._globalTileRange;
-          if (!crs.wrapLng && (coords.x < bounds.min.x || coords.x > bounds.max.x) || !crs.wrapLat && (coords.y < bounds.min.y || coords.y > bounds.max.y)) {
-            return false;
-          }
-        }
-        if (!this.options.bounds) {
-          return true;
-        }
-        var tileBounds = this._tileCoordsToBounds(coords);
-        return toLatLngBounds(this.options.bounds).overlaps(tileBounds);
-      },
-      _keyToBounds: function(key) {
-        return this._tileCoordsToBounds(this._keyToTileCoords(key));
-      },
-      _tileCoordsToNwSe: function(coords) {
-        var map2 = this._map, tileSize = this.getTileSize(), nwPoint = coords.scaleBy(tileSize), sePoint = nwPoint.add(tileSize), nw = map2.unproject(nwPoint, coords.z), se2 = map2.unproject(sePoint, coords.z);
-        return [nw, se2];
-      },
-      // converts tile coordinates to its geographical bounds
-      _tileCoordsToBounds: function(coords) {
-        var bp = this._tileCoordsToNwSe(coords), bounds = new LatLngBounds(bp[0], bp[1]);
-        if (!this.options.noWrap) {
-          bounds = this._map.wrapLatLngBounds(bounds);
-        }
-        return bounds;
-      },
-      // converts tile coordinates to key for the tile cache
-      _tileCoordsToKey: function(coords) {
-        return coords.x + ":" + coords.y + ":" + coords.z;
-      },
-      // converts tile cache key to coordinates
-      _keyToTileCoords: function(key) {
-        var k2 = key.split(":"), coords = new Point(+k2[0], +k2[1]);
-        coords.z = +k2[2];
-        return coords;
-      },
-      _removeTile: function(key) {
-        var tile = this._tiles[key];
-        if (!tile) {
-          return;
-        }
-        remove(tile.el);
-        delete this._tiles[key];
-        this.fire("tileunload", {
-          tile: tile.el,
-          coords: this._keyToTileCoords(key)
-        });
-      },
-      _initTile: function(tile) {
-        addClass(tile, "leaflet-tile");
-        var tileSize = this.getTileSize();
-        tile.style.width = tileSize.x + "px";
-        tile.style.height = tileSize.y + "px";
-        tile.onselectstart = falseFn;
-        tile.onmousemove = falseFn;
-        if (Browser.ielt9 && this.options.opacity < 1) {
-          setOpacity(tile, this.options.opacity);
-        }
-      },
-      _addTile: function(coords, container) {
-        var tilePos = this._getTilePos(coords), key = this._tileCoordsToKey(coords);
-        var tile = this.createTile(this._wrapCoords(coords), bind(this._tileReady, this, coords));
-        this._initTile(tile);
-        if (this.createTile.length < 2) {
-          requestAnimFrame2(bind(this._tileReady, this, coords, null, tile));
-        }
-        setPosition(tile, tilePos);
-        this._tiles[key] = {
-          el: tile,
-          coords,
-          current: true
-        };
-        container.appendChild(tile);
-        this.fire("tileloadstart", {
-          tile,
-          coords
-        });
-      },
-      _tileReady: function(coords, err, tile) {
-        if (err) {
-          this.fire("tileerror", {
-            error: err,
-            tile,
-            coords
-          });
-        }
-        var key = this._tileCoordsToKey(coords);
-        tile = this._tiles[key];
-        if (!tile) {
-          return;
-        }
-        tile.loaded = +/* @__PURE__ */ new Date();
-        if (this._map._fadeAnimated) {
-          setOpacity(tile.el, 0);
-          cancelAnimFrame(this._fadeFrame);
-          this._fadeFrame = requestAnimFrame2(this._updateOpacity, this);
-        } else {
-          tile.active = true;
-          this._pruneTiles();
-        }
-        if (!err) {
-          addClass(tile.el, "leaflet-tile-loaded");
-          this.fire("tileload", {
-            tile: tile.el,
-            coords
-          });
-        }
-        if (this._noTilesToLoad()) {
-          this._loading = false;
-          this.fire("load");
-          if (Browser.ielt9 || !this._map._fadeAnimated) {
-            requestAnimFrame2(this._pruneTiles, this);
-          } else {
-            setTimeout(bind(this._pruneTiles, this), 250);
-          }
-        }
-      },
-      _getTilePos: function(coords) {
-        return coords.scaleBy(this.getTileSize()).subtract(this._level.origin);
-      },
-      _wrapCoords: function(coords) {
-        var newCoords = new Point(
-          this._wrapX ? wrapNum(coords.x, this._wrapX) : coords.x,
-          this._wrapY ? wrapNum(coords.y, this._wrapY) : coords.y
-        );
-        newCoords.z = coords.z;
-        return newCoords;
-      },
-      _pxBoundsToTileRange: function(bounds) {
-        var tileSize = this.getTileSize();
-        return new Bounds(
-          bounds.min.unscaleBy(tileSize).floor(),
-          bounds.max.unscaleBy(tileSize).ceil().subtract([1, 1])
-        );
-      },
-      _noTilesToLoad: function() {
-        for (var key in this._tiles) {
-          if (!this._tiles[key].loaded) {
-            return false;
-          }
-        }
-        return true;
-      }
-    });
-    function gridLayer(options) {
-      return new GridLayer(options);
-    }
-    var TileLayer2 = GridLayer.extend({
-      // @section
-      // @aka TileLayer options
-      options: {
-        // @option minZoom: Number = 0
-        // The minimum zoom level down to which this layer will be displayed (inclusive).
-        minZoom: 0,
-        // @option maxZoom: Number = 18
-        // The maximum zoom level up to which this layer will be displayed (inclusive).
-        maxZoom: 18,
-        // @option subdomains: String|String[] = 'abc'
-        // Subdomains of the tile service. Can be passed in the form of one string (where each letter is a subdomain name) or an array of strings.
-        subdomains: "abc",
-        // @option errorTileUrl: String = ''
-        // URL to the tile image to show in place of the tile that failed to load.
-        errorTileUrl: "",
-        // @option zoomOffset: Number = 0
-        // The zoom number used in tile URLs will be offset with this value.
-        zoomOffset: 0,
-        // @option tms: Boolean = false
-        // If `true`, inverses Y axis numbering for tiles (turn this on for [TMS](https://en.wikipedia.org/wiki/Tile_Map_Service) services).
-        tms: false,
-        // @option zoomReverse: Boolean = false
-        // If set to true, the zoom number used in tile URLs will be reversed (`maxZoom - zoom` instead of `zoom`)
-        zoomReverse: false,
-        // @option detectRetina: Boolean = false
-        // If `true` and user is on a retina display, it will request four tiles of half the specified size and a bigger zoom level in place of one to utilize the high resolution.
-        detectRetina: false,
-        // @option crossOrigin: Boolean|String = false
-        // Whether the crossOrigin attribute will be added to the tiles.
-        // If a String is provided, all tiles will have their crossOrigin attribute set to the String provided. This is needed if you want to access tile pixel data.
-        // Refer to [CORS Settings](https://developer.mozilla.org/en-US/docs/Web/HTML/CORS_settings_attributes) for valid String values.
-        crossOrigin: false,
-        // @option referrerPolicy: Boolean|String = false
-        // Whether the referrerPolicy attribute will be added to the tiles.
-        // If a String is provided, all tiles will have their referrerPolicy attribute set to the String provided.
-        // This may be needed if your map's rendering context has a strict default but your tile provider expects a valid referrer
-        // (e.g. to validate an API token).
-        // Refer to [HTMLImageElement.referrerPolicy](https://developer.mozilla.org/en-US/docs/Web/API/HTMLImageElement/referrerPolicy) for valid String values.
-        referrerPolicy: false
-      },
-      initialize: function(url, options) {
-        this._url = url;
-        options = setOptions2(this, options);
-        if (options.detectRetina && Browser.retina && options.maxZoom > 0) {
-          options.tileSize = Math.floor(options.tileSize / 2);
-          if (!options.zoomReverse) {
-            options.zoomOffset++;
-            options.maxZoom = Math.max(options.minZoom, options.maxZoom - 1);
-          } else {
-            options.zoomOffset--;
-            options.minZoom = Math.min(options.maxZoom, options.minZoom + 1);
-          }
-          options.minZoom = Math.max(0, options.minZoom);
-        } else if (!options.zoomReverse) {
-          options.maxZoom = Math.max(options.minZoom, options.maxZoom);
-        } else {
-          options.minZoom = Math.min(options.maxZoom, options.minZoom);
-        }
-        if (typeof options.subdomains === "string") {
-          options.subdomains = options.subdomains.split("");
-        }
-        this.on("tileunload", this._onTileRemove);
-      },
-      // @method setUrl(url: String, noRedraw?: Boolean): this
-      // Updates the layer's URL template and redraws it (unless `noRedraw` is set to `true`).
-      // If the URL does not change, the layer will not be redrawn unless
-      // the noRedraw parameter is set to false.
-      setUrl: function(url, noRedraw) {
-        if (this._url === url && noRedraw === void 0) {
-          noRedraw = true;
-        }
-        this._url = url;
-        if (!noRedraw) {
-          this.redraw();
-        }
-        return this;
-      },
-      // @method createTile(coords: Object, done?: Function): HTMLElement
-      // Called only internally, overrides GridLayer's [`createTile()`](#gridlayer-createtile)
-      // to return an `<img>` HTML element with the appropriate image URL given `coords`. The `done`
-      // callback is called when the tile has been loaded.
-      createTile: function(coords, done) {
-        var tile = document.createElement("img");
-        on(tile, "load", bind(this._tileOnLoad, this, done, tile));
-        on(tile, "error", bind(this._tileOnError, this, done, tile));
-        if (this.options.crossOrigin || this.options.crossOrigin === "") {
-          tile.crossOrigin = this.options.crossOrigin === true ? "" : this.options.crossOrigin;
-        }
-        if (typeof this.options.referrerPolicy === "string") {
-          tile.referrerPolicy = this.options.referrerPolicy;
-        }
-        tile.alt = "";
-        tile.src = this.getTileUrl(coords);
-        return tile;
-      },
-      // @section Extension methods
-      // @uninheritable
-      // Layers extending `TileLayer` might reimplement the following method.
-      // @method getTileUrl(coords: Object): String
-      // Called only internally, returns the URL for a tile given its coordinates.
-      // Classes extending `TileLayer` can override this function to provide custom tile URL naming schemes.
-      getTileUrl: function(coords) {
-        var data = {
-          r: Browser.retina ? "@2x" : "",
-          s: this._getSubdomain(coords),
-          x: coords.x,
-          y: coords.y,
-          z: this._getZoomForUrl()
-        };
-        if (this._map && !this._map.options.crs.infinite) {
-          var invertedY = this._globalTileRange.max.y - coords.y;
-          if (this.options.tms) {
-            data["y"] = invertedY;
-          }
-          data["-y"] = invertedY;
-        }
-        return template(this._url, extend(data, this.options));
-      },
-      _tileOnLoad: function(done, tile) {
-        if (Browser.ielt9) {
-          setTimeout(bind(done, this, null, tile), 0);
-        } else {
-          done(null, tile);
-        }
-      },
-      _tileOnError: function(done, tile, e) {
-        var errorUrl = this.options.errorTileUrl;
-        if (errorUrl && tile.getAttribute("src") !== errorUrl) {
-          tile.src = errorUrl;
-        }
-        done(e, tile);
-      },
-      _onTileRemove: function(e) {
-        e.tile.onload = null;
-      },
-      _getZoomForUrl: function() {
-        var zoom2 = this._tileZoom, maxZoom = this.options.maxZoom, zoomReverse = this.options.zoomReverse, zoomOffset = this.options.zoomOffset;
-        if (zoomReverse) {
-          zoom2 = maxZoom - zoom2;
-        }
-        return zoom2 + zoomOffset;
-      },
-      _getSubdomain: function(tilePoint) {
-        var index2 = Math.abs(tilePoint.x + tilePoint.y) % this.options.subdomains.length;
-        return this.options.subdomains[index2];
-      },
-      // stops loading all tiles in the background layer
-      _abortLoading: function() {
-        var i, tile;
-        for (i in this._tiles) {
-          if (this._tiles[i].coords.z !== this._tileZoom) {
-            tile = this._tiles[i].el;
-            tile.onload = falseFn;
-            tile.onerror = falseFn;
-            if (!tile.complete) {
-              tile.src = emptyImageUrl;
-              var coords = this._tiles[i].coords;
-              remove(tile);
-              delete this._tiles[i];
-              this.fire("tileabort", {
-                tile,
-                coords
-              });
+            function cosh2(x2) {
+              return (exp(x2) + exp(-x2)) / 2;
             }
-          }
-        }
-      },
-      _removeTile: function(key) {
-        var tile = this._tiles[key];
-        if (!tile) {
-          return;
-        }
-        tile.el.setAttribute("src", emptyImageUrl);
-        return GridLayer.prototype._removeTile.call(this, key);
-      },
-      _tileReady: function(coords, err, tile) {
-        if (!this._map || tile && tile.getAttribute("src") === emptyImageUrl) {
-          return;
-        }
-        return GridLayer.prototype._tileReady.call(this, coords, err, tile);
-      }
-    });
-    function tileLayer(url, options) {
-      return new TileLayer2(url, options);
-    }
-    var TileLayerWMS = TileLayer2.extend({
-      // @section
-      // @aka TileLayer.WMS options
-      // If any custom options not documented here are used, they will be sent to the
-      // WMS server as extra parameters in each request URL. This can be useful for
-      // [non-standard vendor WMS parameters](https://docs.geoserver.org/stable/en/user/services/wms/vendor.html).
-      defaultWmsParams: {
-        service: "WMS",
-        request: "GetMap",
-        // @option layers: String = ''
-        // **(required)** Comma-separated list of WMS layers to show.
-        layers: "",
-        // @option styles: String = ''
-        // Comma-separated list of WMS styles.
-        styles: "",
-        // @option format: String = 'image/jpeg'
-        // WMS image format (use `'image/png'` for layers with transparency).
-        format: "image/jpeg",
-        // @option transparent: Boolean = false
-        // If `true`, the WMS service will return images with transparency.
-        transparent: false,
-        // @option version: String = '1.1.1'
-        // Version of the WMS service to use
-        version: "1.1.1"
-      },
-      options: {
-        // @option crs: CRS = null
-        // Coordinate Reference System to use for the WMS requests, defaults to
-        // map CRS. Don't change this if you're not sure what it means.
-        crs: null,
-        // @option uppercase: Boolean = false
-        // If `true`, WMS request parameter keys will be uppercase.
-        uppercase: false
-      },
-      initialize: function(url, options) {
-        this._url = url;
-        var wmsParams = extend({}, this.defaultWmsParams);
-        for (var i in options) {
-          if (!(i in this.options)) {
-            wmsParams[i] = options[i];
-          }
-        }
-        options = setOptions2(this, options);
-        var realRetina = options.detectRetina && Browser.retina ? 2 : 1;
-        var tileSize = this.getTileSize();
-        wmsParams.width = tileSize.x * realRetina;
-        wmsParams.height = tileSize.y * realRetina;
-        this.wmsParams = wmsParams;
-      },
-      onAdd: function(map2) {
-        this._crs = this.options.crs || map2.options.crs;
-        this._wmsVersion = parseFloat(this.wmsParams.version);
-        var projectionKey = this._wmsVersion >= 1.3 ? "crs" : "srs";
-        this.wmsParams[projectionKey] = this._crs.code;
-        TileLayer2.prototype.onAdd.call(this, map2);
-      },
-      getTileUrl: function(coords) {
-        var tileBounds = this._tileCoordsToNwSe(coords), crs = this._crs, bounds = toBounds(crs.project(tileBounds[0]), crs.project(tileBounds[1])), min = bounds.min, max = bounds.max, bbox = (this._wmsVersion >= 1.3 && this._crs === EPSG4326 ? [min.y, min.x, max.y, max.x] : [min.x, min.y, max.x, max.y]).join(","), url = TileLayer2.prototype.getTileUrl.call(this, coords);
-        return url + getParamString(this.wmsParams, url, this.options.uppercase) + (this.options.uppercase ? "&BBOX=" : "&bbox=") + bbox;
-      },
-      // @method setParams(params: Object, noRedraw?: Boolean): this
-      // Merges an object with the new parameters and re-requests tiles on the current screen (unless `noRedraw` was set to true).
-      setParams: function(params, noRedraw) {
-        extend(this.wmsParams, params);
-        if (!noRedraw) {
-          this.redraw();
-        }
-        return this;
-      }
-    });
-    function tileLayerWMS(url, options) {
-      return new TileLayerWMS(url, options);
-    }
-    TileLayer2.WMS = TileLayerWMS;
-    tileLayer.wms = tileLayerWMS;
-    var Renderer = Layer.extend({
-      // @section
-      // @aka Renderer options
-      options: {
-        // @option padding: Number = 0.1
-        // How much to extend the clip area around the map view (relative to its size)
-        // e.g. 0.1 would be 10% of map view in each direction
-        padding: 0.1
-      },
-      initialize: function(options) {
-        setOptions2(this, options);
-        stamp(this);
-        this._layers = this._layers || {};
-      },
-      onAdd: function() {
-        if (!this._container) {
-          this._initContainer();
-          addClass(this._container, "leaflet-zoom-animated");
-        }
-        this.getPane().appendChild(this._container);
-        this._update();
-        this.on("update", this._updatePaths, this);
-      },
-      onRemove: function() {
-        this.off("update", this._updatePaths, this);
-        this._destroyContainer();
-      },
-      getEvents: function() {
-        var events = {
-          viewreset: this._reset,
-          zoom: this._onZoom,
-          moveend: this._update,
-          zoomend: this._onZoomEnd
-        };
-        if (this._zoomAnimated) {
-          events.zoomanim = this._onAnimZoom;
-        }
-        return events;
-      },
-      _onAnimZoom: function(ev) {
-        this._updateTransform(ev.center, ev.zoom);
-      },
-      _onZoom: function() {
-        this._updateTransform(this._map.getCenter(), this._map.getZoom());
-      },
-      _updateTransform: function(center, zoom2) {
-        var scale2 = this._map.getZoomScale(zoom2, this._zoom), viewHalf = this._map.getSize().multiplyBy(0.5 + this.options.padding), currentCenterPoint = this._map.project(this._center, zoom2), topLeftOffset = viewHalf.multiplyBy(-scale2).add(currentCenterPoint).subtract(this._map._getNewPixelOrigin(center, zoom2));
-        if (Browser.any3d) {
-          setTransform(this._container, topLeftOffset, scale2);
-        } else {
-          setPosition(this._container, topLeftOffset);
-        }
-      },
-      _reset: function() {
-        this._update();
-        this._updateTransform(this._center, this._zoom);
-        for (var id2 in this._layers) {
-          this._layers[id2]._reset();
-        }
-      },
-      _onZoomEnd: function() {
-        for (var id2 in this._layers) {
-          this._layers[id2]._project();
-        }
-      },
-      _updatePaths: function() {
-        for (var id2 in this._layers) {
-          this._layers[id2]._update();
-        }
-      },
-      _update: function() {
-        var p2 = this.options.padding, size = this._map.getSize(), min = this._map.containerPointToLayerPoint(size.multiplyBy(-p2)).round();
-        this._bounds = new Bounds(min, min.add(size.multiplyBy(1 + p2 * 2)).round());
-        this._center = this._map.getCenter();
-        this._zoom = this._map.getZoom();
-      }
-    });
-    var Canvas = Renderer.extend({
-      // @section
-      // @aka Canvas options
-      options: {
-        // @option tolerance: Number = 0
-        // How much to extend the click tolerance around a path/object on the map.
-        tolerance: 0
-      },
-      getEvents: function() {
-        var events = Renderer.prototype.getEvents.call(this);
-        events.viewprereset = this._onViewPreReset;
-        return events;
-      },
-      _onViewPreReset: function() {
-        this._postponeUpdatePaths = true;
-      },
-      onAdd: function() {
-        Renderer.prototype.onAdd.call(this);
-        this._draw();
-      },
-      _initContainer: function() {
-        var container = this._container = document.createElement("canvas");
-        on(container, "mousemove", this._onMouseMove, this);
-        on(container, "click dblclick mousedown mouseup contextmenu", this._onClick, this);
-        on(container, "mouseout", this._handleMouseOut, this);
-        container["_leaflet_disable_events"] = true;
-        this._ctx = container.getContext("2d");
-      },
-      _destroyContainer: function() {
-        cancelAnimFrame(this._redrawRequest);
-        delete this._ctx;
-        remove(this._container);
-        off(this._container);
-        delete this._container;
-      },
-      _updatePaths: function() {
-        if (this._postponeUpdatePaths) {
-          return;
-        }
-        var layer;
-        this._redrawBounds = null;
-        for (var id2 in this._layers) {
-          layer = this._layers[id2];
-          layer._update();
-        }
-        this._redraw();
-      },
-      _update: function() {
-        if (this._map._animatingZoom && this._bounds) {
-          return;
-        }
-        Renderer.prototype._update.call(this);
-        var b = this._bounds, container = this._container, size = b.getSize(), m2 = Browser.retina ? 2 : 1;
-        setPosition(container, b.min);
-        container.width = m2 * size.x;
-        container.height = m2 * size.y;
-        container.style.width = size.x + "px";
-        container.style.height = size.y + "px";
-        if (Browser.retina) {
-          this._ctx.scale(2, 2);
-        }
-        this._ctx.translate(-b.min.x, -b.min.y);
-        this.fire("update");
-      },
-      _reset: function() {
-        Renderer.prototype._reset.call(this);
-        if (this._postponeUpdatePaths) {
-          this._postponeUpdatePaths = false;
-          this._updatePaths();
-        }
-      },
-      _initPath: function(layer) {
-        this._updateDashArray(layer);
-        this._layers[stamp(layer)] = layer;
-        var order = layer._order = {
-          layer,
-          prev: this._drawLast,
-          next: null
-        };
-        if (this._drawLast) {
-          this._drawLast.next = order;
-        }
-        this._drawLast = order;
-        this._drawFirst = this._drawFirst || this._drawLast;
-      },
-      _addPath: function(layer) {
-        this._requestRedraw(layer);
-      },
-      _removePath: function(layer) {
-        var order = layer._order;
-        var next = order.next;
-        var prev = order.prev;
-        if (next) {
-          next.prev = prev;
-        } else {
-          this._drawLast = prev;
-        }
-        if (prev) {
-          prev.next = next;
-        } else {
-          this._drawFirst = next;
-        }
-        delete layer._order;
-        delete this._layers[stamp(layer)];
-        this._requestRedraw(layer);
-      },
-      _updatePath: function(layer) {
-        this._extendRedrawBounds(layer);
-        layer._project();
-        layer._update();
-        this._requestRedraw(layer);
-      },
-      _updateStyle: function(layer) {
-        this._updateDashArray(layer);
-        this._requestRedraw(layer);
-      },
-      _updateDashArray: function(layer) {
-        if (typeof layer.options.dashArray === "string") {
-          var parts = layer.options.dashArray.split(/[, ]+/), dashArray = [], dashValue, i;
-          for (i = 0; i < parts.length; i++) {
-            dashValue = Number(parts[i]);
-            if (isNaN(dashValue)) {
-              return;
+            function arsinh(x2) {
+              return log3(x2 + sqrt(x2 * x2 + 1));
+            }
+            function arcosh(x2) {
+              return log3(x2 + sqrt(x2 * x2 - 1));
+            }
+            function airyRaw(beta) {
+              var tanBeta_2 = tan(beta / 2), b2 = 2 * log3(cos(beta / 2)) / (tanBeta_2 * tanBeta_2);
+              function forward(x2, y2) {
+                var cosx = cos(x2), cosy = cos(y2), siny = sin(y2), cosz = cosy * cosx, k22 = -((1 - cosz ? log3((1 + cosz) / 2) / (1 - cosz) : -0.5) + b2 / (1 + cosz));
+                return [k22 * cosy * sin(x2), k22 * siny];
+              }
+              forward.invert = function(x2, y2) {
+                var r2 = sqrt(x2 * x2 + y2 * y2), z2 = -beta / 2, i2 = 50, delta;
+                if (!r2) return [0, 0];
+                do {
+                  var z_2 = z2 / 2, cosz_2 = cos(z_2), sinz_2 = sin(z_2), tanz_2 = sinz_2 / cosz_2, lnsecz_2 = -log3(abs(cosz_2));
+                  z2 -= delta = (2 / tanz_2 * lnsecz_2 - b2 * tanz_2 - r2) / (-lnsecz_2 / (sinz_2 * sinz_2) + 1 - b2 / (2 * cosz_2 * cosz_2)) * (cosz_2 < 0 ? 0.7 : 1);
+                } while (abs(delta) > epsilon && --i2 > 0);
+                var sinz = sin(z2);
+                return [atan2(x2 * sinz, r2 * cos(z2)), asin(y2 * sinz / r2)];
+              };
+              return forward;
+            }
+            function airy() {
+              var beta = halfPi, m2 = d3Geo.geoProjectionMutator(airyRaw), p2 = m2(beta);
+              p2.radius = function(_2) {
+                return arguments.length ? m2(beta = _2 * radians2) : beta * degrees3;
+              };
+              return p2.scale(179.976).clipAngle(147);
+            }
+            function aitoffRaw(x2, y2) {
+              var cosy = cos(y2), sincia = sinci(acos(cosy * cos(x2 /= 2)));
+              return [2 * cosy * sin(x2) * sincia, sin(y2) * sincia];
+            }
+            aitoffRaw.invert = function(x2, y2) {
+              if (x2 * x2 + 4 * y2 * y2 > pi2 * pi2 + epsilon) return;
+              var x12 = x2, y12 = y2, i2 = 25;
+              do {
+                var sinx = sin(x12), sinx_2 = sin(x12 / 2), cosx_2 = cos(x12 / 2), siny = sin(y12), cosy = cos(y12), sin_2y = sin(2 * y12), sin2y = siny * siny, cos2y = cosy * cosy, sin2x_2 = sinx_2 * sinx_2, c2 = 1 - cos2y * cosx_2 * cosx_2, e2 = c2 ? acos(cosy * cosx_2) * sqrt(f2 = 1 / c2) : f2 = 0, f2, fx = 2 * e2 * cosy * sinx_2 - x2, fy = e2 * siny - y2, dxdx = f2 * (cos2y * sin2x_2 + e2 * cosy * cosx_2 * sin2y), dxdy = f2 * (0.5 * sinx * sin_2y - e2 * 2 * siny * sinx_2), dydx = f2 * 0.25 * (sin_2y * sinx_2 - e2 * siny * cos2y * sinx), dydy = f2 * (sin2y * cosx_2 + e2 * sin2x_2 * cosy), z2 = dxdy * dydx - dydy * dxdx;
+                if (!z2) break;
+                var dx = (fy * dxdy - fx * dydy) / z2, dy = (fx * dydx - fy * dxdx) / z2;
+                x12 -= dx, y12 -= dy;
+              } while ((abs(dx) > epsilon || abs(dy) > epsilon) && --i2 > 0);
+              return [x12, y12];
+            };
+            function aitoff() {
+              return d3Geo.geoProjection(aitoffRaw).scale(152.63);
+            }
+            function armadilloRaw(phi02) {
+              var sinPhi0 = sin(phi02), cosPhi0 = cos(phi02), sPhi0 = phi02 >= 0 ? 1 : -1, tanPhi0 = tan(sPhi0 * phi02), k22 = (1 + sinPhi0 - cosPhi0) / 2;
+              function forward(lambda, phi) {
+                var cosPhi = cos(phi), cosLambda = cos(lambda /= 2);
+                return [
+                  (1 + cosPhi) * sin(lambda),
+                  (sPhi0 * phi > -atan2(cosLambda, tanPhi0) - 1e-3 ? 0 : -sPhi0 * 10) + k22 + sin(phi) * cosPhi0 - (1 + cosPhi) * sinPhi0 * cosLambda
+                  // TODO D3 core should allow null or [NaN, NaN] to be returned.
+                ];
+              }
+              forward.invert = function(x2, y2) {
+                var lambda = 0, phi = 0, i2 = 50;
+                do {
+                  var cosLambda = cos(lambda), sinLambda = sin(lambda), cosPhi = cos(phi), sinPhi = sin(phi), A3 = 1 + cosPhi, fx = A3 * sinLambda - x2, fy = k22 + sinPhi * cosPhi0 - A3 * sinPhi0 * cosLambda - y2, dxdLambda = A3 * cosLambda / 2, dxdPhi = -sinLambda * sinPhi, dydLambda = sinPhi0 * A3 * sinLambda / 2, dydPhi = cosPhi0 * cosPhi + sinPhi0 * cosLambda * sinPhi, denominator = dxdPhi * dydLambda - dydPhi * dxdLambda, dLambda = (fy * dxdPhi - fx * dydPhi) / denominator / 2, dPhi = (fx * dydLambda - fy * dxdLambda) / denominator;
+                  if (abs(dPhi) > 2) dPhi /= 2;
+                  lambda -= dLambda, phi -= dPhi;
+                } while ((abs(dLambda) > epsilon || abs(dPhi) > epsilon) && --i2 > 0);
+                return sPhi0 * phi > -atan2(cos(lambda), tanPhi0) - 1e-3 ? [lambda * 2, phi] : null;
+              };
+              return forward;
+            }
+            function armadillo() {
+              var phi02 = 20 * radians2, sPhi0 = phi02 >= 0 ? 1 : -1, tanPhi0 = tan(sPhi0 * phi02), m2 = d3Geo.geoProjectionMutator(armadilloRaw), p2 = m2(phi02), stream_ = p2.stream;
+              p2.parallel = function(_2) {
+                if (!arguments.length) return phi02 * degrees3;
+                tanPhi0 = tan((sPhi0 = (phi02 = _2 * radians2) >= 0 ? 1 : -1) * phi02);
+                return m2(phi02);
+              };
+              p2.stream = function(stream) {
+                var rotate2 = p2.rotate(), rotateStream = stream_(stream), sphereStream = (p2.rotate([0, 0]), stream_(stream)), precision = p2.precision();
+                p2.rotate(rotate2);
+                rotateStream.sphere = function() {
+                  sphereStream.polygonStart(), sphereStream.lineStart();
+                  for (var lambda = sPhi0 * -180; sPhi0 * lambda < 180; lambda += sPhi0 * 90)
+                    sphereStream.point(lambda, sPhi0 * 90);
+                  if (phi02) while (sPhi0 * (lambda -= 3 * sPhi0 * precision) >= -180) {
+                    sphereStream.point(lambda, sPhi0 * -atan2(cos(lambda * radians2 / 2), tanPhi0) * degrees3);
+                  }
+                  sphereStream.lineEnd(), sphereStream.polygonEnd();
+                };
+                return rotateStream;
+              };
+              return p2.scale(218.695).center([0, 28.0974]);
+            }
+            function augustRaw(lambda, phi) {
+              var tanPhi = tan(phi / 2), k22 = sqrt(1 - tanPhi * tanPhi), c2 = 1 + k22 * cos(lambda /= 2), x2 = sin(lambda) * k22 / c2, y2 = tanPhi / c2, x22 = x2 * x2, y22 = y2 * y2;
+              return [
+                4 / 3 * x2 * (3 + x22 - 3 * y22),
+                4 / 3 * y2 * (3 + 3 * x22 - y22)
+              ];
+            }
+            augustRaw.invert = function(x2, y2) {
+              x2 *= 3 / 8, y2 *= 3 / 8;
+              if (!x2 && abs(y2) > 1) return null;
+              var x22 = x2 * x2, y22 = y2 * y2, s2 = 1 + x22 + y22, sin3Eta = sqrt((s2 - sqrt(s2 * s2 - 4 * y2 * y2)) / 2), eta = asin(sin3Eta) / 3, xi2 = sin3Eta ? arcosh(abs(y2 / sin3Eta)) / 3 : arsinh(abs(x2)) / 3, cosEta = cos(eta), coshXi = cosh2(xi2), d2 = coshXi * coshXi - cosEta * cosEta;
+              return [
+                sign(x2) * 2 * atan2(sinh2(xi2) * cosEta, 0.25 - d2),
+                sign(y2) * 2 * atan2(coshXi * sin(eta), 0.25 + d2)
+              ];
+            };
+            function august() {
+              return d3Geo.geoProjection(augustRaw).scale(66.1603);
+            }
+            var sqrt8 = sqrt(8), phi0 = log3(1 + sqrt2);
+            function bakerRaw(lambda, phi) {
+              var phi02 = abs(phi);
+              return phi02 < quarterPi ? [lambda, log3(tan(quarterPi + phi / 2))] : [lambda * cos(phi02) * (2 * sqrt2 - 1 / sin(phi02)), sign(phi) * (2 * sqrt2 * (phi02 - quarterPi) - log3(tan(phi02 / 2)))];
+            }
+            bakerRaw.invert = function(x2, y2) {
+              if ((y02 = abs(y2)) < phi0) return [x2, 2 * atan(exp(y2)) - halfPi];
+              var phi = quarterPi, i2 = 25, delta, y02;
+              do {
+                var cosPhi_2 = cos(phi / 2), tanPhi_2 = tan(phi / 2);
+                phi -= delta = (sqrt8 * (phi - quarterPi) - log3(tanPhi_2) - y02) / (sqrt8 - cosPhi_2 * cosPhi_2 / (2 * tanPhi_2));
+              } while (abs(delta) > epsilon22 && --i2 > 0);
+              return [x2 / (cos(phi) * (sqrt8 - 1 / sin(phi))), sign(y2) * phi];
+            };
+            function baker() {
+              return d3Geo.geoProjection(bakerRaw).scale(112.314);
+            }
+            function berghausRaw(lobes2) {
+              var k22 = 2 * pi2 / lobes2;
+              function forward(lambda, phi) {
+                var p2 = d3Geo.geoAzimuthalEquidistantRaw(lambda, phi);
+                if (abs(lambda) > halfPi) {
+                  var theta = atan2(p2[1], p2[0]), r2 = sqrt(p2[0] * p2[0] + p2[1] * p2[1]), theta0 = k22 * round2((theta - halfPi) / k22) + halfPi, alpha = atan2(sin(theta -= theta0), 2 - cos(theta));
+                  theta = theta0 + asin(pi2 / r2 * sin(alpha)) - alpha;
+                  p2[0] = r2 * cos(theta);
+                  p2[1] = r2 * sin(theta);
+                }
+                return p2;
+              }
+              forward.invert = function(x2, y2) {
+                var r2 = sqrt(x2 * x2 + y2 * y2);
+                if (r2 > halfPi) {
+                  var theta = atan2(y2, x2), theta0 = k22 * round2((theta - halfPi) / k22) + halfPi, s2 = theta > theta0 ? -1 : 1, A3 = r2 * cos(theta0 - theta), cotAlpha = 1 / tan(s2 * acos((A3 - pi2) / sqrt(pi2 * (pi2 - 2 * A3) + r2 * r2)));
+                  theta = theta0 + 2 * atan((cotAlpha + s2 * sqrt(cotAlpha * cotAlpha - 3)) / 3);
+                  x2 = r2 * cos(theta), y2 = r2 * sin(theta);
+                }
+                return d3Geo.geoAzimuthalEquidistantRaw.invert(x2, y2);
+              };
+              return forward;
+            }
+            function berghaus() {
+              var lobes2 = 5, m2 = d3Geo.geoProjectionMutator(berghausRaw), p2 = m2(lobes2), projectionStream = p2.stream, epsilon$$1 = 0.01, cr = -cos(epsilon$$1 * radians2), sr = sin(epsilon$$1 * radians2);
+              p2.lobes = function(_2) {
+                return arguments.length ? m2(lobes2 = +_2) : lobes2;
+              };
+              p2.stream = function(stream) {
+                var rotate2 = p2.rotate(), rotateStream = projectionStream(stream), sphereStream = (p2.rotate([0, 0]), projectionStream(stream));
+                p2.rotate(rotate2);
+                rotateStream.sphere = function() {
+                  sphereStream.polygonStart(), sphereStream.lineStart();
+                  for (var i2 = 0, delta = 360 / lobes2, delta0 = 2 * pi2 / lobes2, phi = 90 - 180 / lobes2, phi02 = halfPi; i2 < lobes2; ++i2, phi -= delta, phi02 -= delta0) {
+                    sphereStream.point(atan2(sr * cos(phi02), cr) * degrees3, asin(sr * sin(phi02)) * degrees3);
+                    if (phi < -90) {
+                      sphereStream.point(-90, -180 - phi - epsilon$$1);
+                      sphereStream.point(-90, -180 - phi + epsilon$$1);
+                    } else {
+                      sphereStream.point(90, phi + epsilon$$1);
+                      sphereStream.point(90, phi - epsilon$$1);
+                    }
+                  }
+                  sphereStream.lineEnd(), sphereStream.polygonEnd();
+                };
+                return rotateStream;
+              };
+              return p2.scale(87.8076).center([0, 17.1875]).clipAngle(180 - 1e-3);
+            }
+            function hammerRaw(A3, B3) {
+              if (arguments.length < 2) B3 = A3;
+              if (B3 === 1) return d3Geo.geoAzimuthalEqualAreaRaw;
+              if (B3 === Infinity) return hammerQuarticAuthalicRaw;
+              function forward(lambda, phi) {
+                var coordinates = d3Geo.geoAzimuthalEqualAreaRaw(lambda / B3, phi);
+                coordinates[0] *= A3;
+                return coordinates;
+              }
+              forward.invert = function(x2, y2) {
+                var coordinates = d3Geo.geoAzimuthalEqualAreaRaw.invert(x2 / A3, y2);
+                coordinates[0] *= B3;
+                return coordinates;
+              };
+              return forward;
+            }
+            function hammerQuarticAuthalicRaw(lambda, phi) {
+              return [
+                lambda * cos(phi) / cos(phi /= 2),
+                2 * sin(phi)
+              ];
+            }
+            hammerQuarticAuthalicRaw.invert = function(x2, y2) {
+              var phi = 2 * asin(y2 / 2);
+              return [
+                x2 * cos(phi / 2) / cos(phi),
+                phi
+              ];
+            };
+            function hammer() {
+              var B3 = 2, m2 = d3Geo.geoProjectionMutator(hammerRaw), p2 = m2(B3);
+              p2.coefficient = function(_2) {
+                if (!arguments.length) return B3;
+                return m2(B3 = +_2);
+              };
+              return p2.scale(169.529);
+            }
+            function solve(f2, y2, x2) {
+              var steps = 100, delta, f0, f1;
+              x2 = x2 === void 0 ? 0 : +x2;
+              y2 = +y2;
+              do {
+                f0 = f2(x2);
+                f1 = f2(x2 + epsilon);
+                if (f0 === f1) f1 = f0 + epsilon;
+                x2 -= delta = -1 * epsilon * (f0 - y2) / (f0 - f1);
+              } while (steps-- > 0 && abs(delta) > epsilon);
+              return steps < 0 ? NaN : x2;
+            }
+            function solve2d(f2, MAX_ITERATIONS, eps) {
+              if (MAX_ITERATIONS === void 0) MAX_ITERATIONS = 40;
+              if (eps === void 0) eps = epsilon22;
+              return function(x2, y2, a2, b2) {
+                var err2, da2, db2;
+                a2 = a2 === void 0 ? 0 : +a2;
+                b2 = b2 === void 0 ? 0 : +b2;
+                for (var i2 = 0; i2 < MAX_ITERATIONS; i2++) {
+                  var p2 = f2(a2, b2), tx = p2[0] - x2, ty = p2[1] - y2;
+                  if (abs(tx) < eps && abs(ty) < eps) break;
+                  var h2 = tx * tx + ty * ty;
+                  if (h2 > err2) {
+                    a2 -= da2 /= 2;
+                    b2 -= db2 /= 2;
+                    continue;
+                  }
+                  err2 = h2;
+                  var ea2 = (a2 > 0 ? -1 : 1) * eps, eb2 = (b2 > 0 ? -1 : 1) * eps, pa2 = f2(a2 + ea2, b2), pb2 = f2(a2, b2 + eb2), dxa = (pa2[0] - p2[0]) / ea2, dya = (pa2[1] - p2[1]) / ea2, dxb = (pb2[0] - p2[0]) / eb2, dyb = (pb2[1] - p2[1]) / eb2, D22 = dyb * dxa - dya * dxb, l2 = (abs(D22) < 0.5 ? 0.5 : 1) / D22;
+                  da2 = (ty * dxb - tx * dyb) * l2;
+                  db2 = (tx * dya - ty * dxa) * l2;
+                  a2 += da2;
+                  b2 += db2;
+                  if (abs(da2) < eps && abs(db2) < eps) break;
+                }
+                return [a2, b2];
+              };
+            }
+            function bertin1953Raw() {
+              var hammer$$1 = hammerRaw(1.68, 2), fu = 1.4, k22 = 12;
+              function forward(lambda, phi) {
+                if (lambda + phi < -1.4) {
+                  var u2 = (lambda - phi + 1.6) * (lambda + phi + fu) / 8;
+                  lambda += u2;
+                  phi -= 0.8 * u2 * sin(phi + pi2 / 2);
+                }
+                var r2 = hammer$$1(lambda, phi);
+                var d2 = (1 - cos(lambda * phi)) / k22;
+                if (r2[1] < 0) {
+                  r2[0] *= 1 + d2;
+                }
+                if (r2[1] > 0) {
+                  r2[1] *= 1 + d2 / 1.5 * r2[0] * r2[0];
+                }
+                return r2;
+              }
+              forward.invert = solve2d(forward);
+              return forward;
+            }
+            function bertin() {
+              return d3Geo.geoProjection(bertin1953Raw()).rotate([-16.5, -42]).scale(176.57).center([7.93, 0.09]);
+            }
+            function mollweideBromleyTheta(cp, phi) {
+              var cpsinPhi = cp * sin(phi), i2 = 30, delta;
+              do
+                phi -= delta = (phi + sin(phi) - cpsinPhi) / (1 + cos(phi));
+              while (abs(delta) > epsilon && --i2 > 0);
+              return phi / 2;
+            }
+            function mollweideBromleyRaw(cx, cy, cp) {
+              function forward(lambda, phi) {
+                return [cx * lambda * cos(phi = mollweideBromleyTheta(cp, phi)), cy * sin(phi)];
+              }
+              forward.invert = function(x2, y2) {
+                return y2 = asin(y2 / cy), [x2 / (cx * cos(y2)), asin((2 * y2 + sin(2 * y2)) / cp)];
+              };
+              return forward;
+            }
+            var mollweideRaw = mollweideBromleyRaw(sqrt2 / halfPi, sqrt2, pi2);
+            function mollweide() {
+              return d3Geo.geoProjection(mollweideRaw).scale(169.529);
+            }
+            var k2 = 2.00276, w2 = 1.11072;
+            function boggsRaw(lambda, phi) {
+              var theta = mollweideBromleyTheta(pi2, phi);
+              return [k2 * lambda / (1 / cos(phi) + w2 / cos(theta)), (phi + sqrt2 * sin(theta)) / k2];
+            }
+            boggsRaw.invert = function(x2, y2) {
+              var ky = k2 * y2, theta = y2 < 0 ? -quarterPi : quarterPi, i2 = 25, delta, phi;
+              do {
+                phi = ky - sqrt2 * sin(theta);
+                theta -= delta = (sin(2 * theta) + 2 * theta - pi2 * sin(phi)) / (2 * cos(2 * theta) + 2 + pi2 * cos(phi) * sqrt2 * cos(theta));
+              } while (abs(delta) > epsilon && --i2 > 0);
+              phi = ky - sqrt2 * sin(theta);
+              return [x2 * (1 / cos(phi) + w2 / cos(theta)) / k2, phi];
+            };
+            function boggs() {
+              return d3Geo.geoProjection(boggsRaw).scale(160.857);
+            }
+            function parallel1(projectAt) {
+              var phi02 = 0, m2 = d3Geo.geoProjectionMutator(projectAt), p2 = m2(phi02);
+              p2.parallel = function(_2) {
+                return arguments.length ? m2(phi02 = _2 * radians2) : phi02 * degrees3;
+              };
+              return p2;
+            }
+            function sinusoidalRaw(lambda, phi) {
+              return [lambda * cos(phi), phi];
+            }
+            sinusoidalRaw.invert = function(x2, y2) {
+              return [x2 / cos(y2), y2];
+            };
+            function sinusoidal() {
+              return d3Geo.geoProjection(sinusoidalRaw).scale(152.63);
+            }
+            function bonneRaw(phi02) {
+              if (!phi02) return sinusoidalRaw;
+              var cotPhi0 = 1 / tan(phi02);
+              function forward(lambda, phi) {
+                var rho = cotPhi0 + phi02 - phi, e2 = rho ? lambda * cos(phi) / rho : rho;
+                return [rho * sin(e2), cotPhi0 - rho * cos(e2)];
+              }
+              forward.invert = function(x2, y2) {
+                var rho = sqrt(x2 * x2 + (y2 = cotPhi0 - y2) * y2), phi = cotPhi0 + phi02 - rho;
+                return [rho / cos(phi) * atan2(x2, y2), phi];
+              };
+              return forward;
+            }
+            function bonne() {
+              return parallel1(bonneRaw).scale(123.082).center([0, 26.1441]).parallel(45);
+            }
+            function bottomleyRaw(sinPsi) {
+              function forward(lambda, phi) {
+                var rho = halfPi - phi, eta = rho ? lambda * sinPsi * sin(rho) / rho : rho;
+                return [rho * sin(eta) / sinPsi, halfPi - rho * cos(eta)];
+              }
+              forward.invert = function(x2, y2) {
+                var x12 = x2 * sinPsi, y12 = halfPi - y2, rho = sqrt(x12 * x12 + y12 * y12), eta = atan2(x12, y12);
+                return [(rho ? rho / sin(rho) : 1) * eta / sinPsi, halfPi - rho];
+              };
+              return forward;
+            }
+            function bottomley() {
+              var sinPsi = 0.5, m2 = d3Geo.geoProjectionMutator(bottomleyRaw), p2 = m2(sinPsi);
+              p2.fraction = function(_2) {
+                return arguments.length ? m2(sinPsi = +_2) : sinPsi;
+              };
+              return p2.scale(158.837);
+            }
+            var bromleyRaw = mollweideBromleyRaw(1, 4 / pi2, pi2);
+            function bromley() {
+              return d3Geo.geoProjection(bromleyRaw).scale(152.63);
+            }
+            function distance2(dPhi, c1, s1, c2, s2, dLambda) {
+              var cosdLambda = cos(dLambda), r2;
+              if (abs(dPhi) > 1 || abs(dLambda) > 1) {
+                r2 = acos(s1 * s2 + c1 * c2 * cosdLambda);
+              } else {
+                var sindPhi = sin(dPhi / 2), sindLambda = sin(dLambda / 2);
+                r2 = 2 * asin(sqrt(sindPhi * sindPhi + c1 * c2 * sindLambda * sindLambda));
+              }
+              return abs(r2) > epsilon ? [r2, atan2(c2 * sin(dLambda), c1 * s2 - s1 * c2 * cosdLambda)] : [0, 0];
+            }
+            function angle2(b2, c2, a2) {
+              return acos((b2 * b2 + c2 * c2 - a2 * a2) / (2 * b2 * c2));
+            }
+            function longitude(lambda) {
+              return lambda - 2 * pi2 * floor((lambda + pi2) / (2 * pi2));
+            }
+            function chamberlinRaw(p0, p1, p2) {
+              var points2 = [
+                [p0[0], p0[1], sin(p0[1]), cos(p0[1])],
+                [p1[0], p1[1], sin(p1[1]), cos(p1[1])],
+                [p2[0], p2[1], sin(p2[1]), cos(p2[1])]
+              ];
+              for (var a2 = points2[2], b2, i2 = 0; i2 < 3; ++i2, a2 = b2) {
+                b2 = points2[i2];
+                a2.v = distance2(b2[1] - a2[1], a2[3], a2[2], b2[3], b2[2], b2[0] - a2[0]);
+                a2.point = [0, 0];
+              }
+              var beta0 = angle2(points2[0].v[0], points2[2].v[0], points2[1].v[0]), beta1 = angle2(points2[0].v[0], points2[1].v[0], points2[2].v[0]), beta2 = pi2 - beta0;
+              points2[2].point[1] = 0;
+              points2[0].point[0] = -(points2[1].point[0] = points2[0].v[0] / 2);
+              var mean = [
+                points2[2].point[0] = points2[0].point[0] + points2[2].v[0] * cos(beta0),
+                2 * (points2[0].point[1] = points2[1].point[1] = points2[2].v[0] * sin(beta0))
+              ];
+              function forward(lambda, phi) {
+                var sinPhi = sin(phi), cosPhi = cos(phi), v2 = new Array(3), i22;
+                for (i22 = 0; i22 < 3; ++i22) {
+                  var p3 = points2[i22];
+                  v2[i22] = distance2(phi - p3[1], p3[3], p3[2], cosPhi, sinPhi, lambda - p3[0]);
+                  if (!v2[i22][0]) return p3.point;
+                  v2[i22][1] = longitude(v2[i22][1] - p3.v[1]);
+                }
+                var point = mean.slice();
+                for (i22 = 0; i22 < 3; ++i22) {
+                  var j2 = i22 == 2 ? 0 : i22 + 1;
+                  var a22 = angle2(points2[i22].v[0], v2[i22][0], v2[j2][0]);
+                  if (v2[i22][1] < 0) a22 = -a22;
+                  if (!i22) {
+                    point[0] += v2[i22][0] * cos(a22);
+                    point[1] -= v2[i22][0] * sin(a22);
+                  } else if (i22 == 1) {
+                    a22 = beta1 - a22;
+                    point[0] -= v2[i22][0] * cos(a22);
+                    point[1] -= v2[i22][0] * sin(a22);
+                  } else {
+                    a22 = beta2 - a22;
+                    point[0] += v2[i22][0] * cos(a22);
+                    point[1] += v2[i22][0] * sin(a22);
+                  }
+                }
+                point[0] /= 3, point[1] /= 3;
+                return point;
+              }
+              return forward;
+            }
+            function pointRadians(p2) {
+              return p2[0] *= radians2, p2[1] *= radians2, p2;
+            }
+            function chamberlinAfrica() {
+              return chamberlin([0, 22], [45, 22], [22.5, -22]).scale(380).center([22.5, 2]);
+            }
+            function chamberlin(p0, p1, p2) {
+              var c2 = d3Geo.geoCentroid({ type: "MultiPoint", coordinates: [p0, p1, p2] }), R2 = [-c2[0], -c2[1]], r2 = d3Geo.geoRotation(R2), f2 = chamberlinRaw(pointRadians(r2(p0)), pointRadians(r2(p1)), pointRadians(r2(p2)));
+              f2.invert = solve2d(f2);
+              var p3 = d3Geo.geoProjection(f2).rotate(R2), center = p3.center;
+              delete p3.rotate;
+              p3.center = function(_2) {
+                return arguments.length ? center(r2(_2)) : r2.invert(center());
+              };
+              return p3.clipAngle(90);
+            }
+            function collignonRaw(lambda, phi) {
+              var alpha = sqrt(1 - sin(phi));
+              return [2 / sqrtPi * lambda * alpha, sqrtPi * (1 - alpha)];
+            }
+            collignonRaw.invert = function(x2, y2) {
+              var lambda = (lambda = y2 / sqrtPi - 1) * lambda;
+              return [lambda > 0 ? x2 * sqrt(pi2 / lambda) / 2 : 0, asin(1 - lambda)];
+            };
+            function collignon() {
+              return d3Geo.geoProjection(collignonRaw).scale(95.6464).center([0, 30]);
+            }
+            function craigRaw(phi02) {
+              var tanPhi0 = tan(phi02);
+              function forward(lambda, phi) {
+                return [lambda, (lambda ? lambda / sin(lambda) : 1) * (sin(phi) * cos(lambda) - tanPhi0 * cos(phi))];
+              }
+              forward.invert = tanPhi0 ? function(x2, y2) {
+                if (x2) y2 *= sin(x2) / x2;
+                var cosLambda = cos(x2);
+                return [x2, 2 * atan2(sqrt(cosLambda * cosLambda + tanPhi0 * tanPhi0 - y2 * y2) - cosLambda, tanPhi0 - y2)];
+              } : function(x2, y2) {
+                return [x2, asin(x2 ? y2 * tan(x2) / x2 : y2)];
+              };
+              return forward;
+            }
+            function craig() {
+              return parallel1(craigRaw).scale(249.828).clipAngle(90);
+            }
+            var sqrt3 = sqrt(3);
+            function crasterRaw(lambda, phi) {
+              return [sqrt3 * lambda * (2 * cos(2 * phi / 3) - 1) / sqrtPi, sqrt3 * sqrtPi * sin(phi / 3)];
+            }
+            crasterRaw.invert = function(x2, y2) {
+              var phi = 3 * asin(y2 / (sqrt3 * sqrtPi));
+              return [sqrtPi * x2 / (sqrt3 * (2 * cos(2 * phi / 3) - 1)), phi];
+            };
+            function craster() {
+              return d3Geo.geoProjection(crasterRaw).scale(156.19);
+            }
+            function cylindricalEqualAreaRaw(phi02) {
+              var cosPhi0 = cos(phi02);
+              function forward(lambda, phi) {
+                return [lambda * cosPhi0, sin(phi) / cosPhi0];
+              }
+              forward.invert = function(x2, y2) {
+                return [x2 / cosPhi0, asin(y2 * cosPhi0)];
+              };
+              return forward;
+            }
+            function cylindricalEqualArea() {
+              return parallel1(cylindricalEqualAreaRaw).parallel(38.58).scale(195.044);
+            }
+            function cylindricalStereographicRaw(phi02) {
+              var cosPhi0 = cos(phi02);
+              function forward(lambda, phi) {
+                return [lambda * cosPhi0, (1 + cosPhi0) * tan(phi / 2)];
+              }
+              forward.invert = function(x2, y2) {
+                return [x2 / cosPhi0, atan(y2 / (1 + cosPhi0)) * 2];
+              };
+              return forward;
+            }
+            function cylindricalStereographic() {
+              return parallel1(cylindricalStereographicRaw).scale(124.75);
+            }
+            function eckert1Raw(lambda, phi) {
+              var alpha = sqrt(8 / (3 * pi2));
+              return [
+                alpha * lambda * (1 - abs(phi) / pi2),
+                alpha * phi
+              ];
+            }
+            eckert1Raw.invert = function(x2, y2) {
+              var alpha = sqrt(8 / (3 * pi2)), phi = y2 / alpha;
+              return [
+                x2 / (alpha * (1 - abs(phi) / pi2)),
+                phi
+              ];
+            };
+            function eckert1() {
+              return d3Geo.geoProjection(eckert1Raw).scale(165.664);
+            }
+            function eckert2Raw(lambda, phi) {
+              var alpha = sqrt(4 - 3 * sin(abs(phi)));
+              return [
+                2 / sqrt(6 * pi2) * lambda * alpha,
+                sign(phi) * sqrt(2 * pi2 / 3) * (2 - alpha)
+              ];
+            }
+            eckert2Raw.invert = function(x2, y2) {
+              var alpha = 2 - abs(y2) / sqrt(2 * pi2 / 3);
+              return [
+                x2 * sqrt(6 * pi2) / (2 * alpha),
+                sign(y2) * asin((4 - alpha * alpha) / 3)
+              ];
+            };
+            function eckert2() {
+              return d3Geo.geoProjection(eckert2Raw).scale(165.664);
+            }
+            function eckert3Raw(lambda, phi) {
+              var k22 = sqrt(pi2 * (4 + pi2));
+              return [
+                2 / k22 * lambda * (1 + sqrt(1 - 4 * phi * phi / (pi2 * pi2))),
+                4 / k22 * phi
+              ];
+            }
+            eckert3Raw.invert = function(x2, y2) {
+              var k22 = sqrt(pi2 * (4 + pi2)) / 2;
+              return [
+                x2 * k22 / (1 + sqrt(1 - y2 * y2 * (4 + pi2) / (4 * pi2))),
+                y2 * k22 / 2
+              ];
+            };
+            function eckert3() {
+              return d3Geo.geoProjection(eckert3Raw).scale(180.739);
+            }
+            function eckert4Raw(lambda, phi) {
+              var k22 = (2 + halfPi) * sin(phi);
+              phi /= 2;
+              for (var i2 = 0, delta = Infinity; i2 < 10 && abs(delta) > epsilon; i2++) {
+                var cosPhi = cos(phi);
+                phi -= delta = (phi + sin(phi) * (cosPhi + 2) - k22) / (2 * cosPhi * (1 + cosPhi));
+              }
+              return [
+                2 / sqrt(pi2 * (4 + pi2)) * lambda * (1 + cos(phi)),
+                2 * sqrt(pi2 / (4 + pi2)) * sin(phi)
+              ];
+            }
+            eckert4Raw.invert = function(x2, y2) {
+              var A3 = y2 * sqrt((4 + pi2) / pi2) / 2, k22 = asin(A3), c2 = cos(k22);
+              return [
+                x2 / (2 / sqrt(pi2 * (4 + pi2)) * (1 + c2)),
+                asin((k22 + A3 * (c2 + 2)) / (2 + halfPi))
+              ];
+            };
+            function eckert4() {
+              return d3Geo.geoProjection(eckert4Raw).scale(180.739);
+            }
+            function eckert5Raw(lambda, phi) {
+              return [
+                lambda * (1 + cos(phi)) / sqrt(2 + pi2),
+                2 * phi / sqrt(2 + pi2)
+              ];
+            }
+            eckert5Raw.invert = function(x2, y2) {
+              var k22 = sqrt(2 + pi2), phi = y2 * k22 / 2;
+              return [
+                k22 * x2 / (1 + cos(phi)),
+                phi
+              ];
+            };
+            function eckert5() {
+              return d3Geo.geoProjection(eckert5Raw).scale(173.044);
+            }
+            function eckert6Raw(lambda, phi) {
+              var k22 = (1 + halfPi) * sin(phi);
+              for (var i2 = 0, delta = Infinity; i2 < 10 && abs(delta) > epsilon; i2++) {
+                phi -= delta = (phi + sin(phi) - k22) / (1 + cos(phi));
+              }
+              k22 = sqrt(2 + pi2);
+              return [
+                lambda * (1 + cos(phi)) / k22,
+                2 * phi / k22
+              ];
+            }
+            eckert6Raw.invert = function(x2, y2) {
+              var j2 = 1 + halfPi, k22 = sqrt(j2 / 2);
+              return [
+                x2 * 2 * k22 / (1 + cos(y2 *= k22)),
+                asin((y2 + sin(y2)) / j2)
+              ];
+            };
+            function eckert6() {
+              return d3Geo.geoProjection(eckert6Raw).scale(173.044);
+            }
+            var eisenlohrK = 3 + 2 * sqrt2;
+            function eisenlohrRaw(lambda, phi) {
+              var s0 = sin(lambda /= 2), c0 = cos(lambda), k22 = sqrt(cos(phi)), c1 = cos(phi /= 2), t4 = sin(phi) / (c1 + sqrt2 * c0 * k22), c2 = sqrt(2 / (1 + t4 * t4)), v2 = sqrt((sqrt2 * c1 + (c0 + s0) * k22) / (sqrt2 * c1 + (c0 - s0) * k22));
+              return [
+                eisenlohrK * (c2 * (v2 - 1 / v2) - 2 * log3(v2)),
+                eisenlohrK * (c2 * t4 * (v2 + 1 / v2) - 2 * atan(t4))
+              ];
+            }
+            eisenlohrRaw.invert = function(x2, y2) {
+              if (!(p2 = augustRaw.invert(x2 / 1.2, y2 * 1.065))) return null;
+              var lambda = p2[0], phi = p2[1], i2 = 20, p2;
+              x2 /= eisenlohrK, y2 /= eisenlohrK;
+              do {
+                var _0 = lambda / 2, _1 = phi / 2, s0 = sin(_0), c0 = cos(_0), s1 = sin(_1), c1 = cos(_1), cos1 = cos(phi), k22 = sqrt(cos1), t4 = s1 / (c1 + sqrt2 * c0 * k22), t22 = t4 * t4, c2 = sqrt(2 / (1 + t22)), v0 = sqrt2 * c1 + (c0 + s0) * k22, v1 = sqrt2 * c1 + (c0 - s0) * k22, v2 = v0 / v1, v3 = sqrt(v2), vm1v = v3 - 1 / v3, vp1v = v3 + 1 / v3, fx = c2 * vm1v - 2 * log3(v3) - x2, fy = c2 * t4 * vp1v - 2 * atan(t4) - y2, deltatDeltaLambda = s1 && sqrt1_2 * k22 * s0 * t22 / s1, deltatDeltaPhi = (sqrt2 * c0 * c1 + k22) / (2 * (c1 + sqrt2 * c0 * k22) * (c1 + sqrt2 * c0 * k22) * k22), deltacDeltat = -0.5 * t4 * c2 * c2 * c2, deltacDeltaLambda = deltacDeltat * deltatDeltaLambda, deltacDeltaPhi = deltacDeltat * deltatDeltaPhi, A3 = (A3 = 2 * c1 + sqrt2 * k22 * (c0 - s0)) * A3 * v3, deltavDeltaLambda = (sqrt2 * c0 * c1 * k22 + cos1) / A3, deltavDeltaPhi = -(sqrt2 * s0 * s1) / (k22 * A3), deltaxDeltaLambda = vm1v * deltacDeltaLambda - 2 * deltavDeltaLambda / v3 + c2 * (deltavDeltaLambda + deltavDeltaLambda / v2), deltaxDeltaPhi = vm1v * deltacDeltaPhi - 2 * deltavDeltaPhi / v3 + c2 * (deltavDeltaPhi + deltavDeltaPhi / v2), deltayDeltaLambda = t4 * vp1v * deltacDeltaLambda - 2 * deltatDeltaLambda / (1 + t22) + c2 * vp1v * deltatDeltaLambda + c2 * t4 * (deltavDeltaLambda - deltavDeltaLambda / v2), deltayDeltaPhi = t4 * vp1v * deltacDeltaPhi - 2 * deltatDeltaPhi / (1 + t22) + c2 * vp1v * deltatDeltaPhi + c2 * t4 * (deltavDeltaPhi - deltavDeltaPhi / v2), denominator = deltaxDeltaPhi * deltayDeltaLambda - deltayDeltaPhi * deltaxDeltaLambda;
+                if (!denominator) break;
+                var deltaLambda = (fy * deltaxDeltaPhi - fx * deltayDeltaPhi) / denominator, deltaPhi = (fx * deltayDeltaLambda - fy * deltaxDeltaLambda) / denominator;
+                lambda -= deltaLambda;
+                phi = max(-halfPi, min(halfPi, phi - deltaPhi));
+              } while ((abs(deltaLambda) > epsilon || abs(deltaPhi) > epsilon) && --i2 > 0);
+              return abs(abs(phi) - halfPi) < epsilon ? [0, phi] : i2 && [lambda, phi];
+            };
+            function eisenlohr() {
+              return d3Geo.geoProjection(eisenlohrRaw).scale(62.5271);
+            }
+            var faheyK = cos(35 * radians2);
+            function faheyRaw(lambda, phi) {
+              var t4 = tan(phi / 2);
+              return [lambda * faheyK * sqrt(1 - t4 * t4), (1 + faheyK) * t4];
+            }
+            faheyRaw.invert = function(x2, y2) {
+              var t4 = y2 / (1 + faheyK);
+              return [x2 && x2 / (faheyK * sqrt(1 - t4 * t4)), 2 * atan(t4)];
+            };
+            function fahey() {
+              return d3Geo.geoProjection(faheyRaw).scale(137.152);
+            }
+            function foucautRaw(lambda, phi) {
+              var k22 = phi / 2, cosk = cos(k22);
+              return [2 * lambda / sqrtPi * cos(phi) * cosk * cosk, sqrtPi * tan(k22)];
+            }
+            foucautRaw.invert = function(x2, y2) {
+              var k22 = atan(y2 / sqrtPi), cosk = cos(k22), phi = 2 * k22;
+              return [x2 * sqrtPi / 2 / (cos(phi) * cosk * cosk), phi];
+            };
+            function foucaut() {
+              return d3Geo.geoProjection(foucautRaw).scale(135.264);
+            }
+            function foucautSinusoidalRaw(alpha) {
+              var beta = 1 - alpha, equatorial = raw(pi2, 0)[0] - raw(-pi2, 0)[0], polar = raw(0, halfPi)[1] - raw(0, -halfPi)[1], ratio = sqrt(2 * polar / equatorial);
+              function raw(lambda, phi) {
+                var cosphi = cos(phi), sinphi = sin(phi);
+                return [
+                  cosphi / (beta + alpha * cosphi) * lambda,
+                  beta * phi + alpha * sinphi
+                ];
+              }
+              function forward(lambda, phi) {
+                var p2 = raw(lambda, phi);
+                return [p2[0] * ratio, p2[1] / ratio];
+              }
+              function forwardMeridian(phi) {
+                return forward(0, phi)[1];
+              }
+              forward.invert = function(x2, y2) {
+                var phi = solve(forwardMeridian, y2), lambda = x2 / ratio * (alpha + beta / cos(phi));
+                return [lambda, phi];
+              };
+              return forward;
+            }
+            function foucautSinusoidal() {
+              var alpha = 0.5, m2 = d3Geo.geoProjectionMutator(foucautSinusoidalRaw), p2 = m2(alpha);
+              p2.alpha = function(_2) {
+                return arguments.length ? m2(alpha = +_2) : alpha;
+              };
+              return p2.scale(168.725);
+            }
+            function gilbertForward(point) {
+              return [point[0] / 2, asin(tan(point[1] / 2 * radians2)) * degrees3];
+            }
+            function gilbertInvert(point) {
+              return [point[0] * 2, 2 * atan(sin(point[1] * radians2)) * degrees3];
+            }
+            function gilbert(projectionType) {
+              if (projectionType == null) projectionType = d3Geo.geoOrthographic;
+              var projection = projectionType(), equirectangular = d3Geo.geoEquirectangular().scale(degrees3).precision(0).clipAngle(null).translate([0, 0]);
+              function gilbert2(point) {
+                return projection(gilbertForward(point));
+              }
+              if (projection.invert) gilbert2.invert = function(point) {
+                return gilbertInvert(projection.invert(point));
+              };
+              gilbert2.stream = function(stream) {
+                var s1 = projection.stream(stream), s0 = equirectangular.stream({
+                  point: function(lambda, phi) {
+                    s1.point(lambda / 2, asin(tan(-phi / 2 * radians2)) * degrees3);
+                  },
+                  lineStart: function() {
+                    s1.lineStart();
+                  },
+                  lineEnd: function() {
+                    s1.lineEnd();
+                  },
+                  polygonStart: function() {
+                    s1.polygonStart();
+                  },
+                  polygonEnd: function() {
+                    s1.polygonEnd();
+                  }
+                });
+                s0.sphere = s1.sphere;
+                return s0;
+              };
+              function property(name2) {
+                gilbert2[name2] = function() {
+                  return arguments.length ? (projection[name2].apply(projection, arguments), gilbert2) : projection[name2]();
+                };
+              }
+              gilbert2.rotate = function(_2) {
+                return arguments.length ? (equirectangular.rotate(_2), gilbert2) : equirectangular.rotate();
+              };
+              gilbert2.center = function(_2) {
+                return arguments.length ? (projection.center(gilbertForward(_2)), gilbert2) : gilbertInvert(projection.center());
+              };
+              property("angle");
+              property("clipAngle");
+              property("clipExtent");
+              property("fitExtent");
+              property("fitHeight");
+              property("fitSize");
+              property("fitWidth");
+              property("scale");
+              property("translate");
+              property("precision");
+              return gilbert2.scale(249.5);
+            }
+            function gingeryRaw(rho, n2) {
+              var k22 = 2 * pi2 / n2, rho2 = rho * rho;
+              function forward(lambda, phi) {
+                var p2 = d3Geo.geoAzimuthalEquidistantRaw(lambda, phi), x2 = p2[0], y2 = p2[1], r2 = x2 * x2 + y2 * y2;
+                if (r2 > rho2) {
+                  var r3 = sqrt(r2), theta = atan2(y2, x2), theta0 = k22 * round2(theta / k22), alpha = theta - theta0, rhoCosAlpha = rho * cos(alpha), k_ = (rho * sin(alpha) - alpha * sin(rhoCosAlpha)) / (halfPi - rhoCosAlpha), s_ = gingeryLength(alpha, k_), e2 = (pi2 - rho) / gingeryIntegrate(s_, rhoCosAlpha, pi2);
+                  x2 = r3;
+                  var i2 = 50, delta;
+                  do {
+                    x2 -= delta = (rho + gingeryIntegrate(s_, rhoCosAlpha, x2) * e2 - r3) / (s_(x2) * e2);
+                  } while (abs(delta) > epsilon && --i2 > 0);
+                  y2 = alpha * sin(x2);
+                  if (x2 < halfPi) y2 -= k_ * (x2 - halfPi);
+                  var s2 = sin(theta0), c2 = cos(theta0);
+                  p2[0] = x2 * c2 - y2 * s2;
+                  p2[1] = x2 * s2 + y2 * c2;
+                }
+                return p2;
+              }
+              forward.invert = function(x2, y2) {
+                var r2 = x2 * x2 + y2 * y2;
+                if (r2 > rho2) {
+                  var r3 = sqrt(r2), theta = atan2(y2, x2), theta0 = k22 * round2(theta / k22), dTheta = theta - theta0;
+                  x2 = r3 * cos(dTheta);
+                  y2 = r3 * sin(dTheta);
+                  var x_halfPi = x2 - halfPi, sinx = sin(x2), alpha = y2 / sinx, delta = x2 < halfPi ? Infinity : 0, i2 = 10;
+                  while (true) {
+                    var rhosinAlpha = rho * sin(alpha), rhoCosAlpha = rho * cos(alpha), sinRhoCosAlpha = sin(rhoCosAlpha), halfPi_RhoCosAlpha = halfPi - rhoCosAlpha, k_ = (rhosinAlpha - alpha * sinRhoCosAlpha) / halfPi_RhoCosAlpha, s_ = gingeryLength(alpha, k_);
+                    if (abs(delta) < epsilon22 || !--i2) break;
+                    alpha -= delta = (alpha * sinx - k_ * x_halfPi - y2) / (sinx - x_halfPi * 2 * (halfPi_RhoCosAlpha * (rhoCosAlpha + alpha * rhosinAlpha * cos(rhoCosAlpha) - sinRhoCosAlpha) - rhosinAlpha * (rhosinAlpha - alpha * sinRhoCosAlpha)) / (halfPi_RhoCosAlpha * halfPi_RhoCosAlpha));
+                  }
+                  r3 = rho + gingeryIntegrate(s_, rhoCosAlpha, x2) * (pi2 - rho) / gingeryIntegrate(s_, rhoCosAlpha, pi2);
+                  theta = theta0 + alpha;
+                  x2 = r3 * cos(theta);
+                  y2 = r3 * sin(theta);
+                }
+                return d3Geo.geoAzimuthalEquidistantRaw.invert(x2, y2);
+              };
+              return forward;
+            }
+            function gingeryLength(alpha, k22) {
+              return function(x2) {
+                var y_ = alpha * cos(x2);
+                if (x2 < halfPi) y_ -= k22;
+                return sqrt(1 + y_ * y_);
+              };
+            }
+            function gingeryIntegrate(f2, a2, b2) {
+              var n2 = 50, h2 = (b2 - a2) / n2, s2 = f2(a2) + f2(b2);
+              for (var i2 = 1, x2 = a2; i2 < n2; ++i2) s2 += 2 * f2(x2 += h2);
+              return s2 * 0.5 * h2;
+            }
+            function gingery() {
+              var n2 = 6, rho = 30 * radians2, cRho = cos(rho), sRho = sin(rho), m2 = d3Geo.geoProjectionMutator(gingeryRaw), p2 = m2(rho, n2), stream_ = p2.stream, epsilon$$1 = 0.01, cr = -cos(epsilon$$1 * radians2), sr = sin(epsilon$$1 * radians2);
+              p2.radius = function(_2) {
+                if (!arguments.length) return rho * degrees3;
+                cRho = cos(rho = _2 * radians2);
+                sRho = sin(rho);
+                return m2(rho, n2);
+              };
+              p2.lobes = function(_2) {
+                if (!arguments.length) return n2;
+                return m2(rho, n2 = +_2);
+              };
+              p2.stream = function(stream) {
+                var rotate2 = p2.rotate(), rotateStream = stream_(stream), sphereStream = (p2.rotate([0, 0]), stream_(stream));
+                p2.rotate(rotate2);
+                rotateStream.sphere = function() {
+                  sphereStream.polygonStart(), sphereStream.lineStart();
+                  for (var i2 = 0, delta = 2 * pi2 / n2, phi = 0; i2 < n2; ++i2, phi -= delta) {
+                    sphereStream.point(atan2(sr * cos(phi), cr) * degrees3, asin(sr * sin(phi)) * degrees3);
+                    sphereStream.point(atan2(sRho * cos(phi - delta / 2), cRho) * degrees3, asin(sRho * sin(phi - delta / 2)) * degrees3);
+                  }
+                  sphereStream.lineEnd(), sphereStream.polygonEnd();
+                };
+                return rotateStream;
+              };
+              return p2.rotate([90, -40]).scale(91.7095).clipAngle(180 - 1e-3);
+            }
+            function ginzburgPolyconicRaw(a2, b2, c2, d2, e2, f2, g2, h2) {
+              if (arguments.length < 8) h2 = 0;
+              function forward(lambda, phi) {
+                if (!phi) return [a2 * lambda / pi2, 0];
+                var phi2 = phi * phi, xB = a2 + phi2 * (b2 + phi2 * (c2 + phi2 * d2)), yB = phi * (e2 - 1 + phi2 * (f2 - h2 + phi2 * g2)), m2 = (xB * xB + yB * yB) / (2 * yB), alpha = lambda * asin(xB / m2) / pi2;
+                return [m2 * sin(alpha), phi * (1 + phi2 * h2) + m2 * (1 - cos(alpha))];
+              }
+              forward.invert = function(x2, y2) {
+                var lambda = pi2 * x2 / a2, phi = y2, deltaLambda, deltaPhi, i2 = 50;
+                do {
+                  var phi2 = phi * phi, xB = a2 + phi2 * (b2 + phi2 * (c2 + phi2 * d2)), yB = phi * (e2 - 1 + phi2 * (f2 - h2 + phi2 * g2)), p2 = xB * xB + yB * yB, q2 = 2 * yB, m2 = p2 / q2, m22 = m2 * m2, dAlphadLambda = asin(xB / m2) / pi2, alpha = lambda * dAlphadLambda, xB2 = xB * xB, dxBdPhi = (2 * b2 + phi2 * (4 * c2 + phi2 * 6 * d2)) * phi, dyBdPhi = e2 + phi2 * (3 * f2 + phi2 * 5 * g2), dpdPhi = 2 * (xB * dxBdPhi + yB * (dyBdPhi - 1)), dqdPhi = 2 * (dyBdPhi - 1), dmdPhi = (dpdPhi * q2 - p2 * dqdPhi) / (q2 * q2), cosAlpha = cos(alpha), sinAlpha = sin(alpha), mcosAlpha = m2 * cosAlpha, msinAlpha = m2 * sinAlpha, dAlphadPhi = lambda / pi2 * (1 / sqrt(1 - xB2 / m22)) * (dxBdPhi * m2 - xB * dmdPhi) / m22, fx = msinAlpha - x2, fy = phi * (1 + phi2 * h2) + m2 - mcosAlpha - y2, deltaxDeltaPhi = dmdPhi * sinAlpha + mcosAlpha * dAlphadPhi, deltaxDeltaLambda = mcosAlpha * dAlphadLambda, deltayDeltaPhi = 1 + dmdPhi - (dmdPhi * cosAlpha - msinAlpha * dAlphadPhi), deltayDeltaLambda = msinAlpha * dAlphadLambda, denominator = deltaxDeltaPhi * deltayDeltaLambda - deltayDeltaPhi * deltaxDeltaLambda;
+                  if (!denominator) break;
+                  lambda -= deltaLambda = (fy * deltaxDeltaPhi - fx * deltayDeltaPhi) / denominator;
+                  phi -= deltaPhi = (fx * deltayDeltaLambda - fy * deltaxDeltaLambda) / denominator;
+                } while ((abs(deltaLambda) > epsilon || abs(deltaPhi) > epsilon) && --i2 > 0);
+                return [lambda, phi];
+              };
+              return forward;
+            }
+            var ginzburg4Raw = ginzburgPolyconicRaw(2.8284, -1.6988, 0.75432, -0.18071, 1.76003, -0.38914, 0.042555);
+            function ginzburg4() {
+              return d3Geo.geoProjection(ginzburg4Raw).scale(149.995);
+            }
+            var ginzburg5Raw = ginzburgPolyconicRaw(2.583819, -0.835827, 0.170354, -0.038094, 1.543313, -0.411435, 0.082742);
+            function ginzburg5() {
+              return d3Geo.geoProjection(ginzburg5Raw).scale(153.93);
+            }
+            var ginzburg6Raw = ginzburgPolyconicRaw(5 / 6 * pi2, -0.62636, -0.0344, 0, 1.3493, -0.05524, 0, 0.045);
+            function ginzburg6() {
+              return d3Geo.geoProjection(ginzburg6Raw).scale(130.945);
+            }
+            function ginzburg8Raw(lambda, phi) {
+              var lambda2 = lambda * lambda, phi2 = phi * phi;
+              return [
+                lambda * (1 - 0.162388 * phi2) * (0.87 - 952426e-9 * lambda2 * lambda2),
+                phi * (1 + phi2 / 12)
+              ];
+            }
+            ginzburg8Raw.invert = function(x2, y2) {
+              var lambda = x2, phi = y2, i2 = 50, delta;
+              do {
+                var phi2 = phi * phi;
+                phi -= delta = (phi * (1 + phi2 / 12) - y2) / (1 + phi2 / 4);
+              } while (abs(delta) > epsilon && --i2 > 0);
+              i2 = 50;
+              x2 /= 1 - 0.162388 * phi2;
+              do {
+                var lambda4 = (lambda4 = lambda * lambda) * lambda4;
+                lambda -= delta = (lambda * (0.87 - 952426e-9 * lambda4) - x2) / (0.87 - 476213e-8 * lambda4);
+              } while (abs(delta) > epsilon && --i2 > 0);
+              return [lambda, phi];
+            };
+            function ginzburg8() {
+              return d3Geo.geoProjection(ginzburg8Raw).scale(131.747);
+            }
+            var ginzburg9Raw = ginzburgPolyconicRaw(2.6516, -0.76534, 0.19123, -0.047094, 1.36289, -0.13965, 0.031762);
+            function ginzburg9() {
+              return d3Geo.geoProjection(ginzburg9Raw).scale(131.087);
+            }
+            function squareRaw(project2) {
+              var dx = project2(halfPi, 0)[0] - project2(-halfPi, 0)[0];
+              function projectSquare(lambda, phi) {
+                var s2 = lambda > 0 ? -0.5 : 0.5, point = project2(lambda + s2 * pi2, phi);
+                point[0] -= s2 * dx;
+                return point;
+              }
+              if (project2.invert) projectSquare.invert = function(x2, y2) {
+                var s2 = x2 > 0 ? -0.5 : 0.5, location2 = project2.invert(x2 + s2 * dx, y2), lambda = location2[0] - s2 * pi2;
+                if (lambda < -pi2) lambda += 2 * pi2;
+                else if (lambda > pi2) lambda -= 2 * pi2;
+                location2[0] = lambda;
+                return location2;
+              };
+              return projectSquare;
+            }
+            function gringortenRaw(lambda, phi) {
+              var sLambda = sign(lambda), sPhi = sign(phi), cosPhi = cos(phi), x2 = cos(lambda) * cosPhi, y2 = sin(lambda) * cosPhi, z2 = sin(sPhi * phi);
+              lambda = abs(atan2(y2, z2));
+              phi = asin(x2);
+              if (abs(lambda - halfPi) > epsilon) lambda %= halfPi;
+              var point = gringortenHexadecant(lambda > pi2 / 4 ? halfPi - lambda : lambda, phi);
+              if (lambda > pi2 / 4) z2 = point[0], point[0] = -point[1], point[1] = -z2;
+              return point[0] *= sLambda, point[1] *= -sPhi, point;
+            }
+            gringortenRaw.invert = function(x2, y2) {
+              if (abs(x2) > 1) x2 = sign(x2) * 2 - x2;
+              if (abs(y2) > 1) y2 = sign(y2) * 2 - y2;
+              var sx = sign(x2), sy = sign(y2), x02 = -sx * x2, y02 = -sy * y2, t4 = y02 / x02 < 1, p2 = gringortenHexadecantInvert(t4 ? y02 : x02, t4 ? x02 : y02), lambda = p2[0], phi = p2[1], cosPhi = cos(phi);
+              if (t4) lambda = -halfPi - lambda;
+              return [sx * (atan2(sin(lambda) * cosPhi, -sin(phi)) + pi2), sy * asin(cos(lambda) * cosPhi)];
+            };
+            function gringortenHexadecant(lambda, phi) {
+              if (phi === halfPi) return [0, 0];
+              var sinPhi = sin(phi), r2 = sinPhi * sinPhi, r22 = r2 * r2, j2 = 1 + r22, k22 = 1 + 3 * r22, q2 = 1 - r22, z2 = asin(1 / sqrt(j2)), v2 = q2 + r2 * j2 * z2, p2 = (1 - sinPhi) / v2, p3 = sqrt(p2), a2 = p2 * j2, a3 = sqrt(a2), h2 = p3 * q2, x2, i2;
+              if (lambda === 0) return [0, -(h2 + r2 * a3)];
+              var cosPhi = cos(phi), secPhi = 1 / cosPhi, drdPhi = 2 * sinPhi * cosPhi, dvdPhi = (-3 * r2 + z2 * k22) * drdPhi, dp2dPhi = (-v2 * cosPhi - (1 - sinPhi) * dvdPhi) / (v2 * v2), dpdPhi = 0.5 * dp2dPhi / p3, dhdPhi = q2 * dpdPhi - 2 * r2 * p3 * drdPhi, dra2dPhi = r2 * j2 * dp2dPhi + p2 * k22 * drdPhi, mu = -secPhi * drdPhi, nu = -secPhi * dra2dPhi, zeta = -2 * secPhi * dhdPhi, lambda1 = 4 * lambda / pi2, delta;
+              if (lambda > 0.222 * pi2 || phi < pi2 / 4 && lambda > 0.175 * pi2) {
+                x2 = (h2 + r2 * sqrt(a2 * (1 + r22) - h2 * h2)) / (1 + r22);
+                if (lambda > pi2 / 4) return [x2, x2];
+                var x12 = x2, x02 = 0.5 * x2;
+                x2 = 0.5 * (x02 + x12), i2 = 50;
+                do {
+                  var g2 = sqrt(a2 - x2 * x2), f2 = x2 * (zeta + mu * g2) + nu * asin(x2 / a3) - lambda1;
+                  if (!f2) break;
+                  if (f2 < 0) x02 = x2;
+                  else x12 = x2;
+                  x2 = 0.5 * (x02 + x12);
+                } while (abs(x12 - x02) > epsilon && --i2 > 0);
+              } else {
+                x2 = epsilon, i2 = 25;
+                do {
+                  var x22 = x2 * x2, g22 = sqrt(a2 - x22), zetaMug = zeta + mu * g22, f22 = x2 * zetaMug + nu * asin(x2 / a3) - lambda1, df2 = zetaMug + (nu - mu * x22) / g22;
+                  x2 -= delta = g22 ? f22 / df2 : 0;
+                } while (abs(delta) > epsilon && --i2 > 0);
+              }
+              return [x2, -h2 - r2 * sqrt(a2 - x2 * x2)];
+            }
+            function gringortenHexadecantInvert(x2, y2) {
+              var x02 = 0, x12 = 1, r2 = 0.5, i2 = 50;
+              while (true) {
+                var r22 = r2 * r2, sinPhi = sqrt(r2), z2 = asin(1 / sqrt(1 + r22)), v2 = 1 - r22 + r2 * (1 + r22) * z2, p2 = (1 - sinPhi) / v2, p3 = sqrt(p2), a2 = p2 * (1 + r22), h2 = p3 * (1 - r22), g2 = a2 - x2 * x2, g3 = sqrt(g2), y02 = y2 + h2 + r2 * g3;
+                if (abs(x12 - x02) < epsilon22 || --i2 === 0 || y02 === 0) break;
+                if (y02 > 0) x02 = r2;
+                else x12 = r2;
+                r2 = 0.5 * (x02 + x12);
+              }
+              if (!i2) return null;
+              var phi = asin(sinPhi), cosPhi = cos(phi), secPhi = 1 / cosPhi, drdPhi = 2 * sinPhi * cosPhi, dvdPhi = (-3 * r2 + z2 * (1 + 3 * r22)) * drdPhi, dp2dPhi = (-v2 * cosPhi - (1 - sinPhi) * dvdPhi) / (v2 * v2), dpdPhi = 0.5 * dp2dPhi / p3, dhdPhi = (1 - r22) * dpdPhi - 2 * r2 * p3 * drdPhi, zeta = -2 * secPhi * dhdPhi, mu = -secPhi * drdPhi, nu = -secPhi * (r2 * (1 + r22) * dp2dPhi + p2 * (1 + 3 * r22) * drdPhi);
+              return [pi2 / 4 * (x2 * (zeta + mu * g3) + nu * asin(x2 / sqrt(a2))), phi];
+            }
+            function gringorten() {
+              return d3Geo.geoProjection(squareRaw(gringortenRaw)).scale(239.75);
+            }
+            function ellipticJi(u2, v2, m2) {
+              var a2, b2, c2;
+              if (!u2) {
+                b2 = ellipticJ(v2, 1 - m2);
+                return [
+                  [0, b2[0] / b2[1]],
+                  [1 / b2[1], 0],
+                  [b2[2] / b2[1], 0]
+                ];
+              }
+              a2 = ellipticJ(u2, m2);
+              if (!v2) return [[a2[0], 0], [a2[1], 0], [a2[2], 0]];
+              b2 = ellipticJ(v2, 1 - m2);
+              c2 = b2[1] * b2[1] + m2 * a2[0] * a2[0] * b2[0] * b2[0];
+              return [
+                [a2[0] * b2[2] / c2, a2[1] * a2[2] * b2[0] * b2[1] / c2],
+                [a2[1] * b2[1] / c2, -a2[0] * a2[2] * b2[0] * b2[2] / c2],
+                [a2[2] * b2[1] * b2[2] / c2, -m2 * a2[0] * a2[1] * b2[0] / c2]
+              ];
+            }
+            function ellipticJ(u2, m2) {
+              var ai2, b2, phi, t4, twon;
+              if (m2 < epsilon) {
+                t4 = sin(u2);
+                b2 = cos(u2);
+                ai2 = m2 * (u2 - t4 * b2) / 4;
+                return [
+                  t4 - ai2 * b2,
+                  b2 + ai2 * t4,
+                  1 - m2 * t4 * t4 / 2,
+                  u2 - ai2
+                ];
+              }
+              if (m2 >= 1 - epsilon) {
+                ai2 = (1 - m2) / 4;
+                b2 = cosh2(u2);
+                t4 = tanh2(u2);
+                phi = 1 / b2;
+                twon = b2 * sinh2(u2);
+                return [
+                  t4 + ai2 * (twon - u2) / (b2 * b2),
+                  phi - ai2 * t4 * phi * (twon - u2),
+                  phi + ai2 * t4 * phi * (twon + u2),
+                  2 * atan(exp(u2)) - halfPi + ai2 * (twon - u2) / b2
+                ];
+              }
+              var a2 = [1, 0, 0, 0, 0, 0, 0, 0, 0], c2 = [sqrt(m2), 0, 0, 0, 0, 0, 0, 0, 0], i2 = 0;
+              b2 = sqrt(1 - m2);
+              twon = 1;
+              while (abs(c2[i2] / a2[i2]) > epsilon && i2 < 8) {
+                ai2 = a2[i2++];
+                c2[i2] = (ai2 - b2) / 2;
+                a2[i2] = (ai2 + b2) / 2;
+                b2 = sqrt(ai2 * b2);
+                twon *= 2;
+              }
+              phi = twon * a2[i2] * u2;
+              do {
+                t4 = c2[i2] * sin(b2 = phi) / a2[i2];
+                phi = (asin(t4) + phi) / 2;
+              } while (--i2);
+              return [sin(phi), t4 = cos(phi), t4 / cos(phi - b2), phi];
+            }
+            function ellipticFi(phi, psi, m2) {
+              var r2 = abs(phi), i2 = abs(psi), sinhPsi = sinh2(i2);
+              if (r2) {
+                var cscPhi = 1 / sin(r2), cotPhi2 = 1 / (tan(r2) * tan(r2)), b2 = -(cotPhi2 + m2 * (sinhPsi * sinhPsi * cscPhi * cscPhi) - 1 + m2), c2 = (m2 - 1) * cotPhi2, cotLambda2 = (-b2 + sqrt(b2 * b2 - 4 * c2)) / 2;
+                return [
+                  ellipticF(atan(1 / sqrt(cotLambda2)), m2) * sign(phi),
+                  ellipticF(atan(sqrt((cotLambda2 / cotPhi2 - 1) / m2)), 1 - m2) * sign(psi)
+                ];
+              }
+              return [
+                0,
+                ellipticF(atan(sinhPsi), 1 - m2) * sign(psi)
+              ];
+            }
+            function ellipticF(phi, m2) {
+              if (!m2) return phi;
+              if (m2 === 1) return log3(tan(phi / 2 + quarterPi));
+              var a2 = 1, b2 = sqrt(1 - m2), c2 = sqrt(m2);
+              for (var i2 = 0; abs(c2) > epsilon; i2++) {
+                if (phi % pi2) {
+                  var dPhi = atan(b2 * tan(phi) / a2);
+                  if (dPhi < 0) dPhi += pi2;
+                  phi += dPhi + ~~(phi / pi2) * pi2;
+                } else phi += phi;
+                c2 = (a2 + b2) / 2;
+                b2 = sqrt(a2 * b2);
+                c2 = ((a2 = c2) - b2) / 2;
+              }
+              return phi / (pow(2, i2) * a2);
+            }
+            function guyouRaw(lambda, phi) {
+              var k_ = (sqrt2 - 1) / (sqrt2 + 1), k22 = sqrt(1 - k_ * k_), K3 = ellipticF(halfPi, k22 * k22), f2 = -1, psi = log3(tan(pi2 / 4 + abs(phi) / 2)), r2 = exp(f2 * psi) / sqrt(k_), at2 = guyouComplexAtan(r2 * cos(f2 * lambda), r2 * sin(f2 * lambda)), t4 = ellipticFi(at2[0], at2[1], k22 * k22);
+              return [-t4[1], (phi >= 0 ? 1 : -1) * (0.5 * K3 - t4[0])];
+            }
+            function guyouComplexAtan(x2, y2) {
+              var x22 = x2 * x2, y_1 = y2 + 1, t4 = 1 - x22 - y2 * y2;
+              return [
+                0.5 * ((x2 >= 0 ? halfPi : -halfPi) - atan2(t4, 2 * x2)),
+                -0.25 * log3(t4 * t4 + 4 * x22) + 0.5 * log3(y_1 * y_1 + x22)
+              ];
+            }
+            function guyouComplexDivide(a2, b2) {
+              var denominator = b2[0] * b2[0] + b2[1] * b2[1];
+              return [
+                (a2[0] * b2[0] + a2[1] * b2[1]) / denominator,
+                (a2[1] * b2[0] - a2[0] * b2[1]) / denominator
+              ];
+            }
+            guyouRaw.invert = function(x2, y2) {
+              var k_ = (sqrt2 - 1) / (sqrt2 + 1), k22 = sqrt(1 - k_ * k_), K3 = ellipticF(halfPi, k22 * k22), f2 = -1, j2 = ellipticJi(0.5 * K3 - y2, -x2, k22 * k22), tn = guyouComplexDivide(j2[0], j2[1]), lambda = atan2(tn[1], tn[0]) / f2;
+              return [
+                lambda,
+                2 * atan(exp(0.5 / f2 * log3(k_ * tn[0] * tn[0] + k_ * tn[1] * tn[1]))) - halfPi
+              ];
+            };
+            function guyou() {
+              return d3Geo.geoProjection(squareRaw(guyouRaw)).scale(151.496);
+            }
+            function hammerRetroazimuthalRaw(phi02) {
+              var sinPhi0 = sin(phi02), cosPhi0 = cos(phi02), rotate2 = hammerRetroazimuthalRotation(phi02);
+              rotate2.invert = hammerRetroazimuthalRotation(-phi02);
+              function forward(lambda, phi) {
+                var p2 = rotate2(lambda, phi);
+                lambda = p2[0], phi = p2[1];
+                var sinPhi = sin(phi), cosPhi = cos(phi), cosLambda = cos(lambda), z2 = acos(sinPhi0 * sinPhi + cosPhi0 * cosPhi * cosLambda), sinz = sin(z2), K3 = abs(sinz) > epsilon ? z2 / sinz : 1;
+                return [
+                  K3 * cosPhi0 * sin(lambda),
+                  (abs(lambda) > halfPi ? K3 : -K3) * (sinPhi0 * cosPhi - cosPhi0 * sinPhi * cosLambda)
+                ];
+              }
+              forward.invert = function(x2, y2) {
+                var rho = sqrt(x2 * x2 + y2 * y2), sinz = -sin(rho), cosz = cos(rho), a2 = rho * cosz, b2 = -y2 * sinz, c2 = rho * sinPhi0, d2 = sqrt(a2 * a2 + b2 * b2 - c2 * c2), phi = atan2(a2 * c2 + b2 * d2, b2 * c2 - a2 * d2), lambda = (rho > halfPi ? -1 : 1) * atan2(x2 * sinz, rho * cos(phi) * cosz + y2 * sin(phi) * sinz);
+                return rotate2.invert(lambda, phi);
+              };
+              return forward;
+            }
+            function hammerRetroazimuthalRotation(phi02) {
+              var sinPhi0 = sin(phi02), cosPhi0 = cos(phi02);
+              return function(lambda, phi) {
+                var cosPhi = cos(phi), x2 = cos(lambda) * cosPhi, y2 = sin(lambda) * cosPhi, z2 = sin(phi);
+                return [
+                  atan2(y2, x2 * cosPhi0 - z2 * sinPhi0),
+                  asin(z2 * cosPhi0 + x2 * sinPhi0)
+                ];
+              };
+            }
+            function hammerRetroazimuthal() {
+              var phi02 = 0, m2 = d3Geo.geoProjectionMutator(hammerRetroazimuthalRaw), p2 = m2(phi02), rotate_ = p2.rotate, stream_ = p2.stream, circle = d3Geo.geoCircle();
+              p2.parallel = function(_2) {
+                if (!arguments.length) return phi02 * degrees3;
+                var r2 = p2.rotate();
+                return m2(phi02 = _2 * radians2).rotate(r2);
+              };
+              p2.rotate = function(_2) {
+                if (!arguments.length) return _2 = rotate_.call(p2), _2[1] += phi02 * degrees3, _2;
+                rotate_.call(p2, [_2[0], _2[1] - phi02 * degrees3]);
+                circle.center([-_2[0], -_2[1]]);
+                return p2;
+              };
+              p2.stream = function(stream) {
+                stream = stream_(stream);
+                stream.sphere = function() {
+                  stream.polygonStart();
+                  var epsilon$$1 = 0.01, ring = circle.radius(90 - epsilon$$1)().coordinates[0], n2 = ring.length - 1, i2 = -1, p22;
+                  stream.lineStart();
+                  while (++i2 < n2) stream.point((p22 = ring[i2])[0], p22[1]);
+                  stream.lineEnd();
+                  ring = circle.radius(90 + epsilon$$1)().coordinates[0];
+                  n2 = ring.length - 1;
+                  stream.lineStart();
+                  while (--i2 >= 0) stream.point((p22 = ring[i2])[0], p22[1]);
+                  stream.lineEnd();
+                  stream.polygonEnd();
+                };
+                return stream;
+              };
+              return p2.scale(79.4187).parallel(45).clipAngle(180 - 1e-3);
+            }
+            var K22 = 3, healpixParallel = asin(1 - 1 / K22) * degrees3, healpixLambert = cylindricalEqualAreaRaw(0);
+            function healpixRaw(H2) {
+              var phi02 = healpixParallel * radians2, dx = collignonRaw(pi2, phi02)[0] - collignonRaw(-pi2, phi02)[0], y02 = healpixLambert(0, phi02)[1], y12 = collignonRaw(0, phi02)[1], dy1 = sqrtPi - y12, k22 = tau / H2, w22 = 4 / tau, h2 = y02 + dy1 * dy1 * 4 / tau;
+              function forward(lambda, phi) {
+                var point, phi2 = abs(phi);
+                if (phi2 > phi02) {
+                  var i2 = min(H2 - 1, max(0, floor((lambda + pi2) / k22)));
+                  lambda += pi2 * (H2 - 1) / H2 - i2 * k22;
+                  point = collignonRaw(lambda, phi2);
+                  point[0] = point[0] * tau / dx - tau * (H2 - 1) / (2 * H2) + i2 * tau / H2;
+                  point[1] = y02 + (point[1] - y12) * 4 * dy1 / tau;
+                  if (phi < 0) point[1] = -point[1];
+                } else {
+                  point = healpixLambert(lambda, phi);
+                }
+                point[0] *= w22, point[1] /= h2;
+                return point;
+              }
+              forward.invert = function(x2, y2) {
+                x2 /= w22, y2 *= h2;
+                var y22 = abs(y2);
+                if (y22 > y02) {
+                  var i2 = min(H2 - 1, max(0, floor((x2 + pi2) / k22)));
+                  x2 = (x2 + pi2 * (H2 - 1) / H2 - i2 * k22) * dx / tau;
+                  var point = collignonRaw.invert(x2, 0.25 * (y22 - y02) * tau / dy1 + y12);
+                  point[0] -= pi2 * (H2 - 1) / H2 - i2 * k22;
+                  if (y2 < 0) point[1] = -point[1];
+                  return point;
+                }
+                return healpixLambert.invert(x2, y2);
+              };
+              return forward;
+            }
+            function sphereTop(x2, i2) {
+              return [x2, i2 & 1 ? 90 - epsilon : healpixParallel];
+            }
+            function sphereBottom(x2, i2) {
+              return [x2, i2 & 1 ? -90 + epsilon : -healpixParallel];
+            }
+            function sphereNudge(d2) {
+              return [d2[0] * (1 - epsilon), d2[1]];
+            }
+            function sphere(step) {
+              var c2 = [].concat(
+                d3Array.range(-180, 180 + step / 2, step).map(sphereTop),
+                d3Array.range(180, -180 - step / 2, -step).map(sphereBottom)
+              );
+              return {
+                type: "Polygon",
+                coordinates: [step === 180 ? c2.map(sphereNudge) : c2]
+              };
+            }
+            function healpix() {
+              var H2 = 4, m2 = d3Geo.geoProjectionMutator(healpixRaw), p2 = m2(H2), stream_ = p2.stream;
+              p2.lobes = function(_2) {
+                return arguments.length ? m2(H2 = +_2) : H2;
+              };
+              p2.stream = function(stream) {
+                var rotate2 = p2.rotate(), rotateStream = stream_(stream), sphereStream = (p2.rotate([0, 0]), stream_(stream));
+                p2.rotate(rotate2);
+                rotateStream.sphere = function() {
+                  d3Geo.geoStream(sphere(180 / H2), sphereStream);
+                };
+                return rotateStream;
+              };
+              return p2.scale(239.75);
+            }
+            function hillRaw(K3) {
+              var L2 = 1 + K3, sinBt = sin(1 / L2), Bt = asin(sinBt), A3 = 2 * sqrt(pi2 / (B3 = pi2 + 4 * Bt * L2)), B3, rho0 = 0.5 * A3 * (L2 + sqrt(K3 * (2 + K3))), K222 = K3 * K3, L22 = L2 * L2;
+              function forward(lambda, phi) {
+                var t4 = 1 - sin(phi), rho, omega;
+                if (t4 && t4 < 2) {
+                  var theta = halfPi - phi, i2 = 25, delta;
+                  do {
+                    var sinTheta = sin(theta), cosTheta = cos(theta), Bt_Bt1 = Bt + atan2(sinTheta, L2 - cosTheta), C22 = 1 + L22 - 2 * L2 * cosTheta;
+                    theta -= delta = (theta - K222 * Bt - L2 * sinTheta + C22 * Bt_Bt1 - 0.5 * t4 * B3) / (2 * L2 * sinTheta * Bt_Bt1);
+                  } while (abs(delta) > epsilon22 && --i2 > 0);
+                  rho = A3 * sqrt(C22);
+                  omega = lambda * Bt_Bt1 / pi2;
+                } else {
+                  rho = A3 * (K3 + t4);
+                  omega = lambda * Bt / pi2;
+                }
+                return [
+                  rho * sin(omega),
+                  rho0 - rho * cos(omega)
+                ];
+              }
+              forward.invert = function(x2, y2) {
+                var rho2 = x2 * x2 + (y2 -= rho0) * y2, cosTheta = (1 + L22 - rho2 / (A3 * A3)) / (2 * L2), theta = acos(cosTheta), sinTheta = sin(theta), Bt_Bt1 = Bt + atan2(sinTheta, L2 - cosTheta);
+                return [
+                  asin(x2 / sqrt(rho2)) * pi2 / Bt_Bt1,
+                  asin(1 - 2 * (theta - K222 * Bt - L2 * sinTheta + (1 + L22 - 2 * L2 * cosTheta) * Bt_Bt1) / B3)
+                ];
+              };
+              return forward;
+            }
+            function hill() {
+              var K3 = 1, m2 = d3Geo.geoProjectionMutator(hillRaw), p2 = m2(K3);
+              p2.ratio = function(_2) {
+                return arguments.length ? m2(K3 = +_2) : K3;
+              };
+              return p2.scale(167.774).center([0, 18.67]);
+            }
+            var sinuMollweidePhi = 0.7109889596207567;
+            var sinuMollweideY = 0.0528035274542;
+            function sinuMollweideRaw(lambda, phi) {
+              return phi > -0.7109889596207567 ? (lambda = mollweideRaw(lambda, phi), lambda[1] += sinuMollweideY, lambda) : sinusoidalRaw(lambda, phi);
+            }
+            sinuMollweideRaw.invert = function(x2, y2) {
+              return y2 > -0.7109889596207567 ? mollweideRaw.invert(x2, y2 - sinuMollweideY) : sinusoidalRaw.invert(x2, y2);
+            };
+            function sinuMollweide() {
+              return d3Geo.geoProjection(sinuMollweideRaw).rotate([-20, -55]).scale(164.263).center([0, -5.4036]);
+            }
+            function homolosineRaw(lambda, phi) {
+              return abs(phi) > sinuMollweidePhi ? (lambda = mollweideRaw(lambda, phi), lambda[1] -= phi > 0 ? sinuMollweideY : -0.0528035274542, lambda) : sinusoidalRaw(lambda, phi);
+            }
+            homolosineRaw.invert = function(x2, y2) {
+              return abs(y2) > sinuMollweidePhi ? mollweideRaw.invert(x2, y2 + (y2 > 0 ? sinuMollweideY : -0.0528035274542)) : sinusoidalRaw.invert(x2, y2);
+            };
+            function homolosine() {
+              return d3Geo.geoProjection(homolosineRaw).scale(152.63);
+            }
+            function hufnagelRaw(a2, b2, psiMax, ratio) {
+              var k22 = sqrt(
+                4 * pi2 / (2 * psiMax + (1 + a2 - b2 / 2) * sin(2 * psiMax) + (a2 + b2) / 2 * sin(4 * psiMax) + b2 / 2 * sin(6 * psiMax))
+              ), c2 = sqrt(
+                ratio * sin(psiMax) * sqrt((1 + a2 * cos(2 * psiMax) + b2 * cos(4 * psiMax)) / (1 + a2 + b2))
+              ), M2 = psiMax * mapping(1);
+              function radius(psi) {
+                return sqrt(1 + a2 * cos(2 * psi) + b2 * cos(4 * psi));
+              }
+              function mapping(t4) {
+                var psi = t4 * psiMax;
+                return (2 * psi + (1 + a2 - b2 / 2) * sin(2 * psi) + (a2 + b2) / 2 * sin(4 * psi) + b2 / 2 * sin(6 * psi)) / psiMax;
+              }
+              function inversemapping(psi) {
+                return radius(psi) * sin(psi);
+              }
+              var forward = function(lambda, phi) {
+                var psi = psiMax * solve(mapping, M2 * sin(phi) / psiMax, phi / pi2);
+                if (isNaN(psi)) psi = psiMax * sign(phi);
+                var kr = k22 * radius(psi);
+                return [kr * c2 * lambda / pi2 * cos(psi), kr / c2 * sin(psi)];
+              };
+              forward.invert = function(x2, y2) {
+                var psi = solve(inversemapping, y2 * c2 / k22);
+                return [
+                  x2 * pi2 / (cos(psi) * k22 * c2 * radius(psi)),
+                  asin(psiMax * mapping(psi / psiMax) / M2)
+                ];
+              };
+              if (psiMax === 0) {
+                k22 = sqrt(ratio / pi2);
+                forward = function(lambda, phi) {
+                  return [lambda * k22, sin(phi) / k22];
+                };
+                forward.invert = function(x2, y2) {
+                  return [x2 / k22, asin(y2 * k22)];
+                };
+              }
+              return forward;
+            }
+            function hufnagel() {
+              var a2 = 1, b2 = 0, psiMax = 45 * radians2, ratio = 2, mutate = d3Geo.geoProjectionMutator(hufnagelRaw), projection = mutate(a2, b2, psiMax, ratio);
+              projection.a = function(_2) {
+                return arguments.length ? mutate(a2 = +_2, b2, psiMax, ratio) : a2;
+              };
+              projection.b = function(_2) {
+                return arguments.length ? mutate(a2, b2 = +_2, psiMax, ratio) : b2;
+              };
+              projection.psiMax = function(_2) {
+                return arguments.length ? mutate(a2, b2, psiMax = +_2 * radians2, ratio) : psiMax * degrees3;
+              };
+              projection.ratio = function(_2) {
+                return arguments.length ? mutate(a2, b2, psiMax, ratio = +_2) : ratio;
+              };
+              return projection.scale(180.739);
+            }
+            function adsimp(f2, a2, b2, fa2, fm, fb2, V0, tol, maxdepth, depth, state) {
+              if (state.nanEncountered) {
+                return NaN;
+              }
+              var h2, f1, f22, sl2, sr, s2, m2, V1, V2, err;
+              h2 = b2 - a2;
+              f1 = f2(a2 + h2 * 0.25);
+              f22 = f2(b2 - h2 * 0.25);
+              if (isNaN(f1)) {
+                state.nanEncountered = true;
+                return;
+              }
+              if (isNaN(f22)) {
+                state.nanEncountered = true;
+                return;
+              }
+              sl2 = h2 * (fa2 + 4 * f1 + fm) / 12;
+              sr = h2 * (fm + 4 * f22 + fb2) / 12;
+              s2 = sl2 + sr;
+              err = (s2 - V0) / 15;
+              if (depth > maxdepth) {
+                state.maxDepthCount++;
+                return s2 + err;
+              } else if (Math.abs(err) < tol) {
+                return s2 + err;
+              } else {
+                m2 = a2 + h2 * 0.5;
+                V1 = adsimp(f2, a2, m2, fa2, f1, fm, sl2, tol * 0.5, maxdepth, depth + 1, state);
+                if (isNaN(V1)) {
+                  state.nanEncountered = true;
+                  return NaN;
+                }
+                V2 = adsimp(f2, m2, b2, fm, f22, fb2, sr, tol * 0.5, maxdepth, depth + 1, state);
+                if (isNaN(V2)) {
+                  state.nanEncountered = true;
+                  return NaN;
+                }
+                return V1 + V2;
+              }
+            }
+            function integrate(f2, a2, b2, tol, maxdepth) {
+              var state = {
+                maxDepthCount: 0,
+                nanEncountered: false
+              };
+              if (maxdepth === void 0) {
+                maxdepth = 20;
+              }
+              var fa2 = f2(a2);
+              var fm = f2(0.5 * (a2 + b2));
+              var fb2 = f2(b2);
+              var V0 = (fa2 + 4 * fm + fb2) * (b2 - a2) / 6;
+              var result = adsimp(f2, a2, b2, fa2, fm, fb2, V0, tol, maxdepth, 1, state);
+              return result;
+            }
+            function hyperellipticalRaw(alpha, k22, gamma2) {
+              function elliptic(f2) {
+                return alpha + (1 - alpha) * pow(1 - pow(f2, k22), 1 / k22);
+              }
+              function z2(f2) {
+                return integrate(elliptic, 0, f2, 1e-4);
+              }
+              var G2 = 1 / z2(1), n2 = 1e3, m2 = (1 + 1e-8) * G2, approx = [];
+              for (var i2 = 0; i2 <= n2; i2++)
+                approx.push(z2(i2 / n2) * m2);
+              function Y2(sinphi) {
+                var rmin = 0, rmax = n2, r2 = n2 >> 1;
+                do {
+                  if (approx[r2] > sinphi) rmax = r2;
+                  else rmin = r2;
+                  r2 = rmin + rmax >> 1;
+                } while (r2 > rmin);
+                var u2 = approx[r2 + 1] - approx[r2];
+                if (u2) u2 = (sinphi - approx[r2 + 1]) / u2;
+                return (r2 + 1 + u2) / n2;
+              }
+              var ratio = 2 * Y2(1) / pi2 * G2 / gamma2;
+              var forward = function(lambda, phi) {
+                var y2 = Y2(abs(sin(phi))), x2 = elliptic(y2) * lambda;
+                y2 /= ratio;
+                return [x2, phi >= 0 ? y2 : -y2];
+              };
+              forward.invert = function(x2, y2) {
+                var phi;
+                y2 *= ratio;
+                if (abs(y2) < 1) phi = sign(y2) * asin(z2(abs(y2)) * G2);
+                return [x2 / elliptic(abs(y2)), phi];
+              };
+              return forward;
+            }
+            function hyperelliptical() {
+              var alpha = 0, k22 = 2.5, gamma2 = 1.183136, m2 = d3Geo.geoProjectionMutator(hyperellipticalRaw), p2 = m2(alpha, k22, gamma2);
+              p2.alpha = function(_2) {
+                return arguments.length ? m2(alpha = +_2, k22, gamma2) : alpha;
+              };
+              p2.k = function(_2) {
+                return arguments.length ? m2(alpha, k22 = +_2, gamma2) : k22;
+              };
+              p2.gamma = function(_2) {
+                return arguments.length ? m2(alpha, k22, gamma2 = +_2) : gamma2;
+              };
+              return p2.scale(152.63);
+            }
+            function pointEqual(a2, b2) {
+              return abs(a2[0] - b2[0]) < epsilon && abs(a2[1] - b2[1]) < epsilon;
+            }
+            function interpolateLine(coordinates, m2) {
+              var i2 = -1, n2 = coordinates.length, p0 = coordinates[0], p1, dx, dy, resampled = [];
+              while (++i2 < n2) {
+                p1 = coordinates[i2];
+                dx = (p1[0] - p0[0]) / m2;
+                dy = (p1[1] - p0[1]) / m2;
+                for (var j2 = 0; j2 < m2; ++j2) resampled.push([p0[0] + j2 * dx, p0[1] + j2 * dy]);
+                p0 = p1;
+              }
+              resampled.push(p1);
+              return resampled;
+            }
+            function interpolateSphere(lobes2) {
+              var coordinates = [], lobe, lambda0, phi02, phi1, lambda2, phi2, i2, n2 = lobes2[0].length;
+              for (i2 = 0; i2 < n2; ++i2) {
+                lobe = lobes2[0][i2];
+                lambda0 = lobe[0][0], phi02 = lobe[0][1], phi1 = lobe[1][1];
+                lambda2 = lobe[2][0], phi2 = lobe[2][1];
+                coordinates.push(interpolateLine([
+                  [lambda0 + epsilon, phi02 + epsilon],
+                  [lambda0 + epsilon, phi1 - epsilon],
+                  [lambda2 - epsilon, phi1 - epsilon],
+                  [lambda2 - epsilon, phi2 + epsilon]
+                ], 30));
+              }
+              for (i2 = lobes2[1].length - 1; i2 >= 0; --i2) {
+                lobe = lobes2[1][i2];
+                lambda0 = lobe[0][0], phi02 = lobe[0][1], phi1 = lobe[1][1];
+                lambda2 = lobe[2][0], phi2 = lobe[2][1];
+                coordinates.push(interpolateLine([
+                  [lambda2 - epsilon, phi2 - epsilon],
+                  [lambda2 - epsilon, phi1 + epsilon],
+                  [lambda0 + epsilon, phi1 + epsilon],
+                  [lambda0 + epsilon, phi02 - epsilon]
+                ], 30));
+              }
+              return {
+                type: "Polygon",
+                coordinates: [d3Array.merge(coordinates)]
+              };
+            }
+            function interrupt(project2, lobes2, inverse2) {
+              var sphere2, bounds;
+              function forward(lambda, phi) {
+                var sign$$1 = phi < 0 ? -1 : 1, lobe = lobes2[+(phi < 0)];
+                for (var i2 = 0, n2 = lobe.length - 1; i2 < n2 && lambda > lobe[i2][2][0]; ++i2) ;
+                var p22 = project2(lambda - lobe[i2][1][0], phi);
+                p22[0] += project2(lobe[i2][1][0], sign$$1 * phi > sign$$1 * lobe[i2][0][1] ? lobe[i2][0][1] : phi)[0];
+                return p22;
+              }
+              if (inverse2) {
+                forward.invert = inverse2(forward);
+              } else if (project2.invert) {
+                forward.invert = function(x2, y2) {
+                  var bound = bounds[+(y2 < 0)], lobe = lobes2[+(y2 < 0)];
+                  for (var i2 = 0, n2 = bound.length; i2 < n2; ++i2) {
+                    var b2 = bound[i2];
+                    if (b2[0][0] <= x2 && x2 < b2[1][0] && b2[0][1] <= y2 && y2 < b2[1][1]) {
+                      var p22 = project2.invert(x2 - project2(lobe[i2][1][0], 0)[0], y2);
+                      p22[0] += lobe[i2][1][0];
+                      return pointEqual(forward(p22[0], p22[1]), [x2, y2]) ? p22 : null;
+                    }
+                  }
+                };
+              }
+              var p2 = d3Geo.geoProjection(forward), stream_ = p2.stream;
+              p2.stream = function(stream) {
+                var rotate2 = p2.rotate(), rotateStream = stream_(stream), sphereStream = (p2.rotate([0, 0]), stream_(stream));
+                p2.rotate(rotate2);
+                rotateStream.sphere = function() {
+                  d3Geo.geoStream(sphere2, sphereStream);
+                };
+                return rotateStream;
+              };
+              p2.lobes = function(_2) {
+                if (!arguments.length) return lobes2.map(function(lobe) {
+                  return lobe.map(function(l2) {
+                    return [
+                      [l2[0][0] * degrees3, l2[0][1] * degrees3],
+                      [l2[1][0] * degrees3, l2[1][1] * degrees3],
+                      [l2[2][0] * degrees3, l2[2][1] * degrees3]
+                    ];
+                  });
+                });
+                sphere2 = interpolateSphere(_2);
+                lobes2 = _2.map(function(lobe) {
+                  return lobe.map(function(l2) {
+                    return [
+                      [l2[0][0] * radians2, l2[0][1] * radians2],
+                      [l2[1][0] * radians2, l2[1][1] * radians2],
+                      [l2[2][0] * radians2, l2[2][1] * radians2]
+                    ];
+                  });
+                });
+                bounds = lobes2.map(function(lobe) {
+                  return lobe.map(function(l2) {
+                    var x02 = project2(l2[0][0], l2[0][1])[0], x12 = project2(l2[2][0], l2[2][1])[0], y02 = project2(l2[1][0], l2[0][1])[1], y12 = project2(l2[1][0], l2[1][1])[1], t4;
+                    if (y02 > y12) t4 = y02, y02 = y12, y12 = t4;
+                    return [[x02, y02], [x12, y12]];
+                  });
+                });
+                return p2;
+              };
+              if (lobes2 != null) p2.lobes(lobes2);
+              return p2;
+            }
+            var lobes = [[
+              // northern hemisphere
+              [[-180, 0], [-100, 90], [-40, 0]],
+              [[-40, 0], [30, 90], [180, 0]]
+            ], [
+              // southern hemisphere
+              [[-180, 0], [-160, -90], [-100, 0]],
+              [[-100, 0], [-60, -90], [-20, 0]],
+              [[-20, 0], [20, -90], [80, 0]],
+              [[80, 0], [140, -90], [180, 0]]
+            ]];
+            function boggs$1() {
+              return interrupt(boggsRaw, lobes).scale(160.857);
+            }
+            var lobes$1 = [[
+              // northern hemisphere
+              [[-180, 0], [-100, 90], [-40, 0]],
+              [[-40, 0], [30, 90], [180, 0]]
+            ], [
+              // southern hemisphere
+              [[-180, 0], [-160, -90], [-100, 0]],
+              [[-100, 0], [-60, -90], [-20, 0]],
+              [[-20, 0], [20, -90], [80, 0]],
+              [[80, 0], [140, -90], [180, 0]]
+            ]];
+            function homolosine$1() {
+              return interrupt(homolosineRaw, lobes$1).scale(152.63);
+            }
+            var lobes$2 = [[
+              // northern hemisphere
+              [[-180, 0], [-100, 90], [-40, 0]],
+              [[-40, 0], [30, 90], [180, 0]]
+            ], [
+              // southern hemisphere
+              [[-180, 0], [-160, -90], [-100, 0]],
+              [[-100, 0], [-60, -90], [-20, 0]],
+              [[-20, 0], [20, -90], [80, 0]],
+              [[80, 0], [140, -90], [180, 0]]
+            ]];
+            function mollweide$1() {
+              return interrupt(mollweideRaw, lobes$2).scale(169.529);
+            }
+            var lobes$3 = [[
+              // northern hemisphere
+              [[-180, 0], [-90, 90], [0, 0]],
+              [[0, 0], [90, 90], [180, 0]]
+            ], [
+              // southern hemisphere
+              [[-180, 0], [-90, -90], [0, 0]],
+              [[0, 0], [90, -90], [180, 0]]
+            ]];
+            function mollweideHemispheres() {
+              return interrupt(mollweideRaw, lobes$3).scale(169.529).rotate([20, 0]);
+            }
+            var lobes$4 = [[
+              // northern hemisphere
+              [[-180, 35], [-30, 90], [0, 35]],
+              [[0, 35], [30, 90], [180, 35]]
+            ], [
+              // southern hemisphere
+              [[-180, -10], [-102, -90], [-65, -10]],
+              [[-65, -10], [5, -90], [77, -10]],
+              [[77, -10], [103, -90], [180, -10]]
+            ]];
+            function sinuMollweide$1() {
+              return interrupt(sinuMollweideRaw, lobes$4, solve2d).rotate([-20, -55]).scale(164.263).center([0, -5.4036]);
+            }
+            var lobes$5 = [[
+              // northern hemisphere
+              [[-180, 0], [-110, 90], [-40, 0]],
+              [[-40, 0], [0, 90], [40, 0]],
+              [[40, 0], [110, 90], [180, 0]]
+            ], [
+              // southern hemisphere
+              [[-180, 0], [-110, -90], [-40, 0]],
+              [[-40, 0], [0, -90], [40, 0]],
+              [[40, 0], [110, -90], [180, 0]]
+            ]];
+            function sinusoidal$1() {
+              return interrupt(sinusoidalRaw, lobes$5).scale(152.63).rotate([-20, 0]);
+            }
+            function kavrayskiy7Raw(lambda, phi) {
+              return [3 / tau * lambda * sqrt(pi2 * pi2 / 3 - phi * phi), phi];
+            }
+            kavrayskiy7Raw.invert = function(x2, y2) {
+              return [tau / 3 * x2 / sqrt(pi2 * pi2 / 3 - y2 * y2), y2];
+            };
+            function kavrayskiy7() {
+              return d3Geo.geoProjection(kavrayskiy7Raw).scale(158.837);
+            }
+            function lagrangeRaw(n2) {
+              function forward(lambda, phi) {
+                if (abs(abs(phi) - halfPi) < epsilon) return [0, phi < 0 ? -2 : 2];
+                var sinPhi = sin(phi), v2 = pow((1 + sinPhi) / (1 - sinPhi), n2 / 2), c2 = 0.5 * (v2 + 1 / v2) + cos(lambda *= n2);
+                return [
+                  2 * sin(lambda) / c2,
+                  (v2 - 1 / v2) / c2
+                ];
+              }
+              forward.invert = function(x2, y2) {
+                var y02 = abs(y2);
+                if (abs(y02 - 2) < epsilon) return x2 ? null : [0, sign(y2) * halfPi];
+                if (y02 > 2) return null;
+                x2 /= 2, y2 /= 2;
+                var x22 = x2 * x2, y22 = y2 * y2, t4 = 2 * y2 / (1 + x22 + y22);
+                t4 = pow((1 + t4) / (1 - t4), 1 / n2);
+                return [
+                  atan2(2 * x2, 1 - x22 - y22) / n2,
+                  asin((t4 - 1) / (t4 + 1))
+                ];
+              };
+              return forward;
+            }
+            function lagrange() {
+              var n2 = 0.5, m2 = d3Geo.geoProjectionMutator(lagrangeRaw), p2 = m2(n2);
+              p2.spacing = function(_2) {
+                return arguments.length ? m2(n2 = +_2) : n2;
+              };
+              return p2.scale(124.75);
             }
-            dashArray.push(dashValue);
-          }
-          layer.options._dashArray = dashArray;
-        } else {
-          layer.options._dashArray = layer.options.dashArray;
-        }
-      },
-      _requestRedraw: function(layer) {
-        if (!this._map) {
-          return;
-        }
-        this._extendRedrawBounds(layer);
-        this._redrawRequest = this._redrawRequest || requestAnimFrame2(this._redraw, this);
-      },
-      _extendRedrawBounds: function(layer) {
-        if (layer._pxBounds) {
-          var padding = (layer.options.weight || 0) + 1;
-          this._redrawBounds = this._redrawBounds || new Bounds();
-          this._redrawBounds.extend(layer._pxBounds.min.subtract([padding, padding]));
-          this._redrawBounds.extend(layer._pxBounds.max.add([padding, padding]));
-        }
-      },
-      _redraw: function() {
-        this._redrawRequest = null;
-        if (this._redrawBounds) {
-          this._redrawBounds.min._floor();
-          this._redrawBounds.max._ceil();
-        }
-        this._clear();
-        this._draw();
-        this._redrawBounds = null;
-      },
-      _clear: function() {
-        var bounds = this._redrawBounds;
-        if (bounds) {
-          var size = bounds.getSize();
-          this._ctx.clearRect(bounds.min.x, bounds.min.y, size.x, size.y);
-        } else {
-          this._ctx.save();
-          this._ctx.setTransform(1, 0, 0, 1, 0, 0);
-          this._ctx.clearRect(0, 0, this._container.width, this._container.height);
-          this._ctx.restore();
-        }
-      },
-      _draw: function() {
-        var layer, bounds = this._redrawBounds;
-        this._ctx.save();
-        if (bounds) {
-          var size = bounds.getSize();
-          this._ctx.beginPath();
-          this._ctx.rect(bounds.min.x, bounds.min.y, size.x, size.y);
-          this._ctx.clip();
-        }
-        this._drawing = true;
-        for (var order = this._drawFirst; order; order = order.next) {
-          layer = order.layer;
-          if (!bounds || layer._pxBounds && layer._pxBounds.intersects(bounds)) {
-            layer._updatePath();
-          }
-        }
-        this._drawing = false;
-        this._ctx.restore();
-      },
-      _updatePoly: function(layer, closed) {
-        if (!this._drawing) {
-          return;
-        }
-        var i, j, len2, p2, parts = layer._parts, len = parts.length, ctx = this._ctx;
-        if (!len) {
-          return;
-        }
-        ctx.beginPath();
-        for (i = 0; i < len; i++) {
-          for (j = 0, len2 = parts[i].length; j < len2; j++) {
-            p2 = parts[i][j];
-            ctx[j ? "lineTo" : "moveTo"](p2.x, p2.y);
-          }
-          if (closed) {
-            ctx.closePath();
-          }
-        }
-        this._fillStroke(ctx, layer);
-      },
-      _updateCircle: function(layer) {
-        if (!this._drawing || layer._empty()) {
-          return;
-        }
-        var p2 = layer._point, ctx = this._ctx, r2 = Math.max(Math.round(layer._radius), 1), s = (Math.max(Math.round(layer._radiusY), 1) || r2) / r2;
-        if (s !== 1) {
-          ctx.save();
-          ctx.scale(1, s);
-        }
-        ctx.beginPath();
-        ctx.arc(p2.x, p2.y / s, r2, 0, Math.PI * 2, false);
-        if (s !== 1) {
-          ctx.restore();
-        }
-        this._fillStroke(ctx, layer);
-      },
-      _fillStroke: function(ctx, layer) {
-        var options = layer.options;
-        if (options.fill) {
-          ctx.globalAlpha = options.fillOpacity;
-          ctx.fillStyle = options.fillColor || options.color;
-          ctx.fill(options.fillRule || "evenodd");
-        }
-        if (options.stroke && options.weight !== 0) {
-          if (ctx.setLineDash) {
-            ctx.setLineDash(layer.options && layer.options._dashArray || []);
-          }
-          ctx.globalAlpha = options.opacity;
-          ctx.lineWidth = options.weight;
-          ctx.strokeStyle = options.color;
-          ctx.lineCap = options.lineCap;
-          ctx.lineJoin = options.lineJoin;
-          ctx.stroke();
-        }
-      },
-      // Canvas obviously doesn't have mouse events for individual drawn objects,
-      // so we emulate that by calculating what's under the mouse on mousemove/click manually
-      _onClick: function(e) {
-        var point = this._map.mouseEventToLayerPoint(e), layer, clickedLayer;
-        for (var order = this._drawFirst; order; order = order.next) {
-          layer = order.layer;
-          if (layer.options.interactive && layer._containsPoint(point)) {
-            if (!(e.type === "click" || e.type === "preclick") || !this._map._draggableMoved(layer)) {
-              clickedLayer = layer;
+            var pi_sqrt2 = pi2 / sqrt2;
+            function larriveeRaw(lambda, phi) {
+              return [
+                lambda * (1 + sqrt(cos(phi))) / 2,
+                phi / (cos(phi / 2) * cos(lambda / 6))
+              ];
             }
-          }
-        }
-        this._fireEvent(clickedLayer ? [clickedLayer] : false, e);
-      },
-      _onMouseMove: function(e) {
-        if (!this._map || this._map.dragging.moving() || this._map._animatingZoom) {
-          return;
-        }
-        var point = this._map.mouseEventToLayerPoint(e);
-        this._handleMouseHover(e, point);
-      },
-      _handleMouseOut: function(e) {
-        var layer = this._hoveredLayer;
-        if (layer) {
-          removeClass(this._container, "leaflet-interactive");
-          this._fireEvent([layer], e, "mouseout");
-          this._hoveredLayer = null;
-          this._mouseHoverThrottled = false;
-        }
-      },
-      _handleMouseHover: function(e, point) {
-        if (this._mouseHoverThrottled) {
-          return;
-        }
-        var layer, candidateHoveredLayer;
-        for (var order = this._drawFirst; order; order = order.next) {
-          layer = order.layer;
-          if (layer.options.interactive && layer._containsPoint(point)) {
-            candidateHoveredLayer = layer;
-          }
-        }
-        if (candidateHoveredLayer !== this._hoveredLayer) {
-          this._handleMouseOut(e);
-          if (candidateHoveredLayer) {
-            addClass(this._container, "leaflet-interactive");
-            this._fireEvent([candidateHoveredLayer], e, "mouseover");
-            this._hoveredLayer = candidateHoveredLayer;
-          }
-        }
-        this._fireEvent(this._hoveredLayer ? [this._hoveredLayer] : false, e);
-        this._mouseHoverThrottled = true;
-        setTimeout(bind(function() {
-          this._mouseHoverThrottled = false;
-        }, this), 32);
-      },
-      _fireEvent: function(layers2, e, type) {
-        this._map._fireDOMEvent(e, type || e.type, layers2);
-      },
-      _bringToFront: function(layer) {
-        var order = layer._order;
-        if (!order) {
-          return;
-        }
-        var next = order.next;
-        var prev = order.prev;
-        if (next) {
-          next.prev = prev;
-        } else {
-          return;
-        }
-        if (prev) {
-          prev.next = next;
-        } else if (next) {
-          this._drawFirst = next;
-        }
-        order.prev = this._drawLast;
-        this._drawLast.next = order;
-        order.next = null;
-        this._drawLast = order;
-        this._requestRedraw(layer);
-      },
-      _bringToBack: function(layer) {
-        var order = layer._order;
-        if (!order) {
-          return;
-        }
-        var next = order.next;
-        var prev = order.prev;
-        if (prev) {
-          prev.next = next;
-        } else {
-          return;
-        }
-        if (next) {
-          next.prev = prev;
-        } else if (prev) {
-          this._drawLast = prev;
-        }
-        order.prev = null;
-        order.next = this._drawFirst;
-        this._drawFirst.prev = order;
-        this._drawFirst = order;
-        this._requestRedraw(layer);
-      }
-    });
-    function canvas(options) {
-      return Browser.canvas ? new Canvas(options) : null;
-    }
-    var vmlCreate = function() {
-      try {
-        document.namespaces.add("lvml", "urn:schemas-microsoft-com:vml");
-        return function(name) {
-          return document.createElement("<lvml:" + name + ' class="lvml">');
-        };
-      } catch (e) {
-      }
-      return function(name) {
-        return document.createElement("<" + name + ' xmlns="urn:schemas-microsoft.com:vml" class="lvml">');
-      };
-    }();
-    var vmlMixin = {
-      _initContainer: function() {
-        this._container = create$1("div", "leaflet-vml-container");
-      },
-      _update: function() {
-        if (this._map._animatingZoom) {
-          return;
-        }
-        Renderer.prototype._update.call(this);
-        this.fire("update");
-      },
-      _initPath: function(layer) {
-        var container = layer._container = vmlCreate("shape");
-        addClass(container, "leaflet-vml-shape " + (this.options.className || ""));
-        container.coordsize = "1 1";
-        layer._path = vmlCreate("path");
-        container.appendChild(layer._path);
-        this._updateStyle(layer);
-        this._layers[stamp(layer)] = layer;
-      },
-      _addPath: function(layer) {
-        var container = layer._container;
-        this._container.appendChild(container);
-        if (layer.options.interactive) {
-          layer.addInteractiveTarget(container);
-        }
-      },
-      _removePath: function(layer) {
-        var container = layer._container;
-        remove(container);
-        layer.removeInteractiveTarget(container);
-        delete this._layers[stamp(layer)];
-      },
-      _updateStyle: function(layer) {
-        var stroke = layer._stroke, fill = layer._fill, options = layer.options, container = layer._container;
-        container.stroked = !!options.stroke;
-        container.filled = !!options.fill;
-        if (options.stroke) {
-          if (!stroke) {
-            stroke = layer._stroke = vmlCreate("stroke");
-          }
-          container.appendChild(stroke);
-          stroke.weight = options.weight + "px";
-          stroke.color = options.color;
-          stroke.opacity = options.opacity;
-          if (options.dashArray) {
-            stroke.dashStyle = isArray2(options.dashArray) ? options.dashArray.join(" ") : options.dashArray.replace(/( *, *)/g, " ");
-          } else {
-            stroke.dashStyle = "";
-          }
-          stroke.endcap = options.lineCap.replace("butt", "flat");
-          stroke.joinstyle = options.lineJoin;
-        } else if (stroke) {
-          container.removeChild(stroke);
-          layer._stroke = null;
-        }
-        if (options.fill) {
-          if (!fill) {
-            fill = layer._fill = vmlCreate("fill");
-          }
-          container.appendChild(fill);
-          fill.color = options.fillColor || options.color;
-          fill.opacity = options.fillOpacity;
-        } else if (fill) {
-          container.removeChild(fill);
-          layer._fill = null;
-        }
-      },
-      _updateCircle: function(layer) {
-        var p2 = layer._point.round(), r2 = Math.round(layer._radius), r22 = Math.round(layer._radiusY || r2);
-        this._setPath(layer, layer._empty() ? "M0 0" : "AL " + p2.x + "," + p2.y + " " + r2 + "," + r22 + " 0," + 65535 * 360);
-      },
-      _setPath: function(layer, path) {
-        layer._path.v = path;
-      },
-      _bringToFront: function(layer) {
-        toFront(layer._container);
-      },
-      _bringToBack: function(layer) {
-        toBack(layer._container);
-      }
-    };
-    var create = Browser.vml ? vmlCreate : svgCreate;
-    var SVG = Renderer.extend({
-      _initContainer: function() {
-        this._container = create("svg");
-        this._container.setAttribute("pointer-events", "none");
-        this._rootGroup = create("g");
-        this._container.appendChild(this._rootGroup);
-      },
-      _destroyContainer: function() {
-        remove(this._container);
-        off(this._container);
-        delete this._container;
-        delete this._rootGroup;
-        delete this._svgSize;
-      },
-      _update: function() {
-        if (this._map._animatingZoom && this._bounds) {
-          return;
-        }
-        Renderer.prototype._update.call(this);
-        var b = this._bounds, size = b.getSize(), container = this._container;
-        if (!this._svgSize || !this._svgSize.equals(size)) {
-          this._svgSize = size;
-          container.setAttribute("width", size.x);
-          container.setAttribute("height", size.y);
-        }
-        setPosition(container, b.min);
-        container.setAttribute("viewBox", [b.min.x, b.min.y, size.x, size.y].join(" "));
-        this.fire("update");
-      },
-      // methods below are called by vector layers implementations
-      _initPath: function(layer) {
-        var path = layer._path = create("path");
-        if (layer.options.className) {
-          addClass(path, layer.options.className);
-        }
-        if (layer.options.interactive) {
-          addClass(path, "leaflet-interactive");
-        }
-        this._updateStyle(layer);
-        this._layers[stamp(layer)] = layer;
-      },
-      _addPath: function(layer) {
-        if (!this._rootGroup) {
-          this._initContainer();
-        }
-        this._rootGroup.appendChild(layer._path);
-        layer.addInteractiveTarget(layer._path);
-      },
-      _removePath: function(layer) {
-        remove(layer._path);
-        layer.removeInteractiveTarget(layer._path);
-        delete this._layers[stamp(layer)];
-      },
-      _updatePath: function(layer) {
-        layer._project();
-        layer._update();
-      },
-      _updateStyle: function(layer) {
-        var path = layer._path, options = layer.options;
-        if (!path) {
-          return;
-        }
-        if (options.stroke) {
-          path.setAttribute("stroke", options.color);
-          path.setAttribute("stroke-opacity", options.opacity);
-          path.setAttribute("stroke-width", options.weight);
-          path.setAttribute("stroke-linecap", options.lineCap);
-          path.setAttribute("stroke-linejoin", options.lineJoin);
-          if (options.dashArray) {
-            path.setAttribute("stroke-dasharray", options.dashArray);
-          } else {
-            path.removeAttribute("stroke-dasharray");
-          }
-          if (options.dashOffset) {
-            path.setAttribute("stroke-dashoffset", options.dashOffset);
-          } else {
-            path.removeAttribute("stroke-dashoffset");
-          }
-        } else {
-          path.setAttribute("stroke", "none");
-        }
-        if (options.fill) {
-          path.setAttribute("fill", options.fillColor || options.color);
-          path.setAttribute("fill-opacity", options.fillOpacity);
-          path.setAttribute("fill-rule", options.fillRule || "evenodd");
-        } else {
-          path.setAttribute("fill", "none");
-        }
-      },
-      _updatePoly: function(layer, closed) {
-        this._setPath(layer, pointsToPath(layer._parts, closed));
-      },
-      _updateCircle: function(layer) {
-        var p2 = layer._point, r2 = Math.max(Math.round(layer._radius), 1), r22 = Math.max(Math.round(layer._radiusY), 1) || r2, arc = "a" + r2 + "," + r22 + " 0 1,0 ";
-        var d = layer._empty() ? "M0 0" : "M" + (p2.x - r2) + "," + p2.y + arc + r2 * 2 + ",0 " + arc + -r2 * 2 + ",0 ";
-        this._setPath(layer, d);
-      },
-      _setPath: function(layer, path) {
-        layer._path.setAttribute("d", path);
-      },
-      // SVG does not have the concept of zIndex so we resort to changing the DOM order of elements
-      _bringToFront: function(layer) {
-        toFront(layer._path);
-      },
-      _bringToBack: function(layer) {
-        toBack(layer._path);
-      }
-    });
-    if (Browser.vml) {
-      SVG.include(vmlMixin);
-    }
-    function svg(options) {
-      return Browser.svg || Browser.vml ? new SVG(options) : null;
-    }
-    Map2.include({
-      // @namespace Map; @method getRenderer(layer: Path): Renderer
-      // Returns the instance of `Renderer` that should be used to render the given
-      // `Path`. It will ensure that the `renderer` options of the map and paths
-      // are respected, and that the renderers do exist on the map.
-      getRenderer: function(layer) {
-        var renderer = layer.options.renderer || this._getPaneRenderer(layer.options.pane) || this.options.renderer || this._renderer;
-        if (!renderer) {
-          renderer = this._renderer = this._createRenderer();
-        }
-        if (!this.hasLayer(renderer)) {
-          this.addLayer(renderer);
-        }
-        return renderer;
-      },
-      _getPaneRenderer: function(name) {
-        if (name === "overlayPane" || name === void 0) {
-          return false;
-        }
-        var renderer = this._paneRenderers[name];
-        if (renderer === void 0) {
-          renderer = this._createRenderer({ pane: name });
-          this._paneRenderers[name] = renderer;
-        }
-        return renderer;
-      },
-      _createRenderer: function(options) {
-        return this.options.preferCanvas && canvas(options) || svg(options);
-      }
-    });
-    var Rectangle = Polygon.extend({
-      initialize: function(latLngBounds, options) {
-        Polygon.prototype.initialize.call(this, this._boundsToLatLngs(latLngBounds), options);
-      },
-      // @method setBounds(latLngBounds: LatLngBounds): this
-      // Redraws the rectangle with the passed bounds.
-      setBounds: function(latLngBounds) {
-        return this.setLatLngs(this._boundsToLatLngs(latLngBounds));
-      },
-      _boundsToLatLngs: function(latLngBounds) {
-        latLngBounds = toLatLngBounds(latLngBounds);
-        return [
-          latLngBounds.getSouthWest(),
-          latLngBounds.getNorthWest(),
-          latLngBounds.getNorthEast(),
-          latLngBounds.getSouthEast()
-        ];
-      }
-    });
-    function rectangle(latLngBounds, options) {
-      return new Rectangle(latLngBounds, options);
-    }
-    SVG.create = create;
-    SVG.pointsToPath = pointsToPath;
-    GeoJSON.geometryToLayer = geometryToLayer;
-    GeoJSON.coordsToLatLng = coordsToLatLng;
-    GeoJSON.coordsToLatLngs = coordsToLatLngs;
-    GeoJSON.latLngToCoords = latLngToCoords;
-    GeoJSON.latLngsToCoords = latLngsToCoords;
-    GeoJSON.getFeature = getFeature;
-    GeoJSON.asFeature = asFeature;
-    Map2.mergeOptions({
-      // @option boxZoom: Boolean = true
-      // Whether the map can be zoomed to a rectangular area specified by
-      // dragging the mouse while pressing the shift key.
-      boxZoom: true
-    });
-    var BoxZoom = Handler.extend({
-      initialize: function(map2) {
-        this._map = map2;
-        this._container = map2._container;
-        this._pane = map2._panes.overlayPane;
-        this._resetStateTimeout = 0;
-        map2.on("unload", this._destroy, this);
-      },
-      addHooks: function() {
-        on(this._container, "mousedown", this._onMouseDown, this);
-      },
-      removeHooks: function() {
-        off(this._container, "mousedown", this._onMouseDown, this);
-      },
-      moved: function() {
-        return this._moved;
-      },
-      _destroy: function() {
-        remove(this._pane);
-        delete this._pane;
-      },
-      _resetState: function() {
-        this._resetStateTimeout = 0;
-        this._moved = false;
-      },
-      _clearDeferredResetState: function() {
-        if (this._resetStateTimeout !== 0) {
-          clearTimeout(this._resetStateTimeout);
-          this._resetStateTimeout = 0;
-        }
-      },
-      _onMouseDown: function(e) {
-        if (!e.shiftKey || e.which !== 1 && e.button !== 1) {
-          return false;
-        }
-        this._clearDeferredResetState();
-        this._resetState();
-        disableTextSelection();
-        disableImageDrag();
-        this._startPoint = this._map.mouseEventToContainerPoint(e);
-        on(document, {
-          contextmenu: stop,
-          mousemove: this._onMouseMove,
-          mouseup: this._onMouseUp,
-          keydown: this._onKeyDown
-        }, this);
-      },
-      _onMouseMove: function(e) {
-        if (!this._moved) {
-          this._moved = true;
-          this._box = create$1("div", "leaflet-zoom-box", this._container);
-          addClass(this._container, "leaflet-crosshair");
-          this._map.fire("boxzoomstart");
-        }
-        this._point = this._map.mouseEventToContainerPoint(e);
-        var bounds = new Bounds(this._point, this._startPoint), size = bounds.getSize();
-        setPosition(this._box, bounds.min);
-        this._box.style.width = size.x + "px";
-        this._box.style.height = size.y + "px";
-      },
-      _finish: function() {
-        if (this._moved) {
-          remove(this._box);
-          removeClass(this._container, "leaflet-crosshair");
-        }
-        enableTextSelection();
-        enableImageDrag();
-        off(document, {
-          contextmenu: stop,
-          mousemove: this._onMouseMove,
-          mouseup: this._onMouseUp,
-          keydown: this._onKeyDown
-        }, this);
-      },
-      _onMouseUp: function(e) {
-        if (e.which !== 1 && e.button !== 1) {
-          return;
-        }
-        this._finish();
-        if (!this._moved) {
-          return;
-        }
-        this._clearDeferredResetState();
-        this._resetStateTimeout = setTimeout(bind(this._resetState, this), 0);
-        var bounds = new LatLngBounds(
-          this._map.containerPointToLatLng(this._startPoint),
-          this._map.containerPointToLatLng(this._point)
-        );
-        this._map.fitBounds(bounds).fire("boxzoomend", { boxZoomBounds: bounds });
-      },
-      _onKeyDown: function(e) {
-        if (e.keyCode === 27) {
-          this._finish();
-          this._clearDeferredResetState();
-          this._resetState();
-        }
-      }
-    });
-    Map2.addInitHook("addHandler", "boxZoom", BoxZoom);
-    Map2.mergeOptions({
-      // @option doubleClickZoom: Boolean|String = true
-      // Whether the map can be zoomed in by double clicking on it and
-      // zoomed out by double clicking while holding shift. If passed
-      // `'center'`, double-click zoom will zoom to the center of the
-      //  view regardless of where the mouse was.
-      doubleClickZoom: true
-    });
-    var DoubleClickZoom = Handler.extend({
-      addHooks: function() {
-        this._map.on("dblclick", this._onDoubleClick, this);
-      },
-      removeHooks: function() {
-        this._map.off("dblclick", this._onDoubleClick, this);
-      },
-      _onDoubleClick: function(e) {
-        var map2 = this._map, oldZoom = map2.getZoom(), delta = map2.options.zoomDelta, zoom2 = e.originalEvent.shiftKey ? oldZoom - delta : oldZoom + delta;
-        if (map2.options.doubleClickZoom === "center") {
-          map2.setZoom(zoom2);
-        } else {
-          map2.setZoomAround(e.containerPoint, zoom2);
-        }
-      }
-    });
-    Map2.addInitHook("addHandler", "doubleClickZoom", DoubleClickZoom);
-    Map2.mergeOptions({
-      // @option dragging: Boolean = true
-      // Whether the map is draggable with mouse/touch or not.
-      dragging: true,
-      // @section Panning Inertia Options
-      // @option inertia: Boolean = *
-      // If enabled, panning of the map will have an inertia effect where
-      // the map builds momentum while dragging and continues moving in
-      // the same direction for some time. Feels especially nice on touch
-      // devices. Enabled by default.
-      inertia: true,
-      // @option inertiaDeceleration: Number = 3000
-      // The rate with which the inertial movement slows down, in pixels/second².
-      inertiaDeceleration: 3400,
-      // px/s^2
-      // @option inertiaMaxSpeed: Number = Infinity
-      // Max speed of the inertial movement, in pixels/second.
-      inertiaMaxSpeed: Infinity,
-      // px/s
-      // @option easeLinearity: Number = 0.2
-      easeLinearity: 0.2,
-      // TODO refactor, move to CRS
-      // @option worldCopyJump: Boolean = false
-      // With this option enabled, the map tracks when you pan to another "copy"
-      // of the world and seamlessly jumps to the original one so that all overlays
-      // like markers and vector layers are still visible.
-      worldCopyJump: false,
-      // @option maxBoundsViscosity: Number = 0.0
-      // If `maxBounds` is set, this option will control how solid the bounds
-      // are when dragging the map around. The default value of `0.0` allows the
-      // user to drag outside the bounds at normal speed, higher values will
-      // slow down map dragging outside bounds, and `1.0` makes the bounds fully
-      // solid, preventing the user from dragging outside the bounds.
-      maxBoundsViscosity: 0
-    });
-    var Drag = Handler.extend({
-      addHooks: function() {
-        if (!this._draggable) {
-          var map2 = this._map;
-          this._draggable = new Draggable(map2._mapPane, map2._container);
-          this._draggable.on({
-            dragstart: this._onDragStart,
-            drag: this._onDrag,
-            dragend: this._onDragEnd
-          }, this);
-          this._draggable.on("predrag", this._onPreDragLimit, this);
-          if (map2.options.worldCopyJump) {
-            this._draggable.on("predrag", this._onPreDragWrap, this);
-            map2.on("zoomend", this._onZoomEnd, this);
-            map2.whenReady(this._onZoomEnd, this);
-          }
-        }
-        addClass(this._map._container, "leaflet-grab leaflet-touch-drag");
-        this._draggable.enable();
-        this._positions = [];
-        this._times = [];
-      },
-      removeHooks: function() {
-        removeClass(this._map._container, "leaflet-grab");
-        removeClass(this._map._container, "leaflet-touch-drag");
-        this._draggable.disable();
-      },
-      moved: function() {
-        return this._draggable && this._draggable._moved;
-      },
-      moving: function() {
-        return this._draggable && this._draggable._moving;
-      },
-      _onDragStart: function() {
-        var map2 = this._map;
-        map2._stop();
-        if (this._map.options.maxBounds && this._map.options.maxBoundsViscosity) {
-          var bounds = toLatLngBounds(this._map.options.maxBounds);
-          this._offsetLimit = toBounds(
-            this._map.latLngToContainerPoint(bounds.getNorthWest()).multiplyBy(-1),
-            this._map.latLngToContainerPoint(bounds.getSouthEast()).multiplyBy(-1).add(this._map.getSize())
-          );
-          this._viscosity = Math.min(1, Math.max(0, this._map.options.maxBoundsViscosity));
-        } else {
-          this._offsetLimit = null;
-        }
-        map2.fire("movestart").fire("dragstart");
-        if (map2.options.inertia) {
-          this._positions = [];
-          this._times = [];
-        }
-      },
-      _onDrag: function(e) {
-        if (this._map.options.inertia) {
-          var time = this._lastTime = +/* @__PURE__ */ new Date(), pos = this._lastPos = this._draggable._absPos || this._draggable._newPos;
-          this._positions.push(pos);
-          this._times.push(time);
-          this._prunePositions(time);
-        }
-        this._map.fire("move", e).fire("drag", e);
-      },
-      _prunePositions: function(time) {
-        while (this._positions.length > 1 && time - this._times[0] > 50) {
-          this._positions.shift();
-          this._times.shift();
-        }
-      },
-      _onZoomEnd: function() {
-        var pxCenter = this._map.getSize().divideBy(2), pxWorldCenter = this._map.latLngToLayerPoint([0, 0]);
-        this._initialWorldOffset = pxWorldCenter.subtract(pxCenter).x;
-        this._worldWidth = this._map.getPixelWorldBounds().getSize().x;
-      },
-      _viscousLimit: function(value, threshold) {
-        return value - (value - threshold) * this._viscosity;
-      },
-      _onPreDragLimit: function() {
-        if (!this._viscosity || !this._offsetLimit) {
-          return;
-        }
-        var offset = this._draggable._newPos.subtract(this._draggable._startPos);
-        var limit = this._offsetLimit;
-        if (offset.x < limit.min.x) {
-          offset.x = this._viscousLimit(offset.x, limit.min.x);
-        }
-        if (offset.y < limit.min.y) {
-          offset.y = this._viscousLimit(offset.y, limit.min.y);
-        }
-        if (offset.x > limit.max.x) {
-          offset.x = this._viscousLimit(offset.x, limit.max.x);
-        }
-        if (offset.y > limit.max.y) {
-          offset.y = this._viscousLimit(offset.y, limit.max.y);
-        }
-        this._draggable._newPos = this._draggable._startPos.add(offset);
-      },
-      _onPreDragWrap: function() {
-        var worldWidth = this._worldWidth, halfWidth = Math.round(worldWidth / 2), dx = this._initialWorldOffset, x2 = this._draggable._newPos.x, newX1 = (x2 - halfWidth + dx) % worldWidth + halfWidth - dx, newX2 = (x2 + halfWidth + dx) % worldWidth - halfWidth - dx, newX = Math.abs(newX1 + dx) < Math.abs(newX2 + dx) ? newX1 : newX2;
-        this._draggable._absPos = this._draggable._newPos.clone();
-        this._draggable._newPos.x = newX;
-      },
-      _onDragEnd: function(e) {
-        var map2 = this._map, options = map2.options, noInertia = !options.inertia || e.noInertia || this._times.length < 2;
-        map2.fire("dragend", e);
-        if (noInertia) {
-          map2.fire("moveend");
-        } else {
-          this._prunePositions(+/* @__PURE__ */ new Date());
-          var direction = this._lastPos.subtract(this._positions[0]), duration = (this._lastTime - this._times[0]) / 1e3, ease = options.easeLinearity, speedVector = direction.multiplyBy(ease / duration), speed = speedVector.distanceTo([0, 0]), limitedSpeed = Math.min(options.inertiaMaxSpeed, speed), limitedSpeedVector = speedVector.multiplyBy(limitedSpeed / speed), decelerationDuration = limitedSpeed / (options.inertiaDeceleration * ease), offset = limitedSpeedVector.multiplyBy(-decelerationDuration / 2).round();
-          if (!offset.x && !offset.y) {
-            map2.fire("moveend");
-          } else {
-            offset = map2._limitOffset(offset, map2.options.maxBounds);
-            requestAnimFrame2(function() {
-              map2.panBy(offset, {
-                duration: decelerationDuration,
-                easeLinearity: ease,
-                noMoveStart: true,
-                animate: true
-              });
-            });
-          }
-        }
-      }
-    });
-    Map2.addInitHook("addHandler", "dragging", Drag);
-    Map2.mergeOptions({
-      // @option keyboard: Boolean = true
-      // Makes the map focusable and allows users to navigate the map with keyboard
-      // arrows and `+`/`-` keys.
-      keyboard: true,
-      // @option keyboardPanDelta: Number = 80
-      // Amount of pixels to pan when pressing an arrow key.
-      keyboardPanDelta: 80
-    });
-    var Keyboard = Handler.extend({
-      keyCodes: {
-        left: [37],
-        right: [39],
-        down: [40],
-        up: [38],
-        zoomIn: [187, 107, 61, 171],
-        zoomOut: [189, 109, 54, 173]
-      },
-      initialize: function(map2) {
-        this._map = map2;
-        this._setPanDelta(map2.options.keyboardPanDelta);
-        this._setZoomDelta(map2.options.zoomDelta);
-      },
-      addHooks: function() {
-        var container = this._map._container;
-        if (container.tabIndex <= 0) {
-          container.tabIndex = "0";
-        }
-        on(container, {
-          focus: this._onFocus,
-          blur: this._onBlur,
-          mousedown: this._onMouseDown
-        }, this);
-        this._map.on({
-          focus: this._addHooks,
-          blur: this._removeHooks
-        }, this);
-      },
-      removeHooks: function() {
-        this._removeHooks();
-        off(this._map._container, {
-          focus: this._onFocus,
-          blur: this._onBlur,
-          mousedown: this._onMouseDown
-        }, this);
-        this._map.off({
-          focus: this._addHooks,
-          blur: this._removeHooks
-        }, this);
-      },
-      _onMouseDown: function() {
-        if (this._focused) {
-          return;
-        }
-        var body = document.body, docEl = document.documentElement, top = body.scrollTop || docEl.scrollTop, left = body.scrollLeft || docEl.scrollLeft;
-        this._map._container.focus();
-        window.scrollTo(left, top);
-      },
-      _onFocus: function() {
-        this._focused = true;
-        this._map.fire("focus");
-      },
-      _onBlur: function() {
-        this._focused = false;
-        this._map.fire("blur");
-      },
-      _setPanDelta: function(panDelta) {
-        var keys = this._panKeys = {}, codes = this.keyCodes, i, len;
-        for (i = 0, len = codes.left.length; i < len; i++) {
-          keys[codes.left[i]] = [-1 * panDelta, 0];
-        }
-        for (i = 0, len = codes.right.length; i < len; i++) {
-          keys[codes.right[i]] = [panDelta, 0];
-        }
-        for (i = 0, len = codes.down.length; i < len; i++) {
-          keys[codes.down[i]] = [0, panDelta];
-        }
-        for (i = 0, len = codes.up.length; i < len; i++) {
-          keys[codes.up[i]] = [0, -1 * panDelta];
-        }
-      },
-      _setZoomDelta: function(zoomDelta) {
-        var keys = this._zoomKeys = {}, codes = this.keyCodes, i, len;
-        for (i = 0, len = codes.zoomIn.length; i < len; i++) {
-          keys[codes.zoomIn[i]] = zoomDelta;
-        }
-        for (i = 0, len = codes.zoomOut.length; i < len; i++) {
-          keys[codes.zoomOut[i]] = -zoomDelta;
-        }
-      },
-      _addHooks: function() {
-        on(document, "keydown", this._onKeyDown, this);
-      },
-      _removeHooks: function() {
-        off(document, "keydown", this._onKeyDown, this);
-      },
-      _onKeyDown: function(e) {
-        if (e.altKey || e.ctrlKey || e.metaKey) {
-          return;
-        }
-        var key = e.keyCode, map2 = this._map, offset;
-        if (key in this._panKeys) {
-          if (!map2._panAnim || !map2._panAnim._inProgress) {
-            offset = this._panKeys[key];
-            if (e.shiftKey) {
-              offset = toPoint(offset).multiplyBy(3);
+            larriveeRaw.invert = function(x2, y2) {
+              var x02 = abs(x2), y02 = abs(y2), lambda = epsilon, phi = halfPi;
+              if (y02 < pi_sqrt2) phi *= y02 / pi_sqrt2;
+              else lambda += 6 * acos(pi_sqrt2 / y02);
+              for (var i2 = 0; i2 < 25; i2++) {
+                var sinPhi = sin(phi), sqrtcosPhi = sqrt(cos(phi)), sinPhi_2 = sin(phi / 2), cosPhi_2 = cos(phi / 2), sinLambda_6 = sin(lambda / 6), cosLambda_6 = cos(lambda / 6), f0 = 0.5 * lambda * (1 + sqrtcosPhi) - x02, f1 = phi / (cosPhi_2 * cosLambda_6) - y02, df0dPhi = sqrtcosPhi ? -0.25 * lambda * sinPhi / sqrtcosPhi : 0, df0dLambda = 0.5 * (1 + sqrtcosPhi), df1dPhi = (1 + 0.5 * phi * sinPhi_2 / cosPhi_2) / (cosPhi_2 * cosLambda_6), df1dLambda = phi / cosPhi_2 * (sinLambda_6 / 6) / (cosLambda_6 * cosLambda_6), denom = df0dPhi * df1dLambda - df1dPhi * df0dLambda, dPhi = (f0 * df1dLambda - f1 * df0dLambda) / denom, dLambda = (f1 * df0dPhi - f0 * df1dPhi) / denom;
+                phi -= dPhi;
+                lambda -= dLambda;
+                if (abs(dPhi) < epsilon && abs(dLambda) < epsilon) break;
+              }
+              return [x2 < 0 ? -lambda : lambda, y2 < 0 ? -phi : phi];
+            };
+            function larrivee() {
+              return d3Geo.geoProjection(larriveeRaw).scale(97.2672);
             }
-            if (map2.options.maxBounds) {
-              offset = map2._limitOffset(toPoint(offset), map2.options.maxBounds);
+            function laskowskiRaw(lambda, phi) {
+              var lambda2 = lambda * lambda, phi2 = phi * phi;
+              return [
+                lambda * (0.975534 + phi2 * (-0.119161 + lambda2 * -0.0143059 + phi2 * -0.0547009)),
+                phi * (1.00384 + lambda2 * (0.0802894 + phi2 * -0.02855 + lambda2 * 199025e-9) + phi2 * (0.0998909 + phi2 * -0.0491032))
+              ];
             }
-            if (map2.options.worldCopyJump) {
-              var newLatLng = map2.wrapLatLng(map2.unproject(map2.project(map2.getCenter()).add(offset)));
-              map2.panTo(newLatLng);
-            } else {
-              map2.panBy(offset);
+            laskowskiRaw.invert = function(x2, y2) {
+              var lambda = sign(x2) * pi2, phi = y2 / 2, i2 = 50;
+              do {
+                var lambda2 = lambda * lambda, phi2 = phi * phi, lambdaPhi = lambda * phi, fx = lambda * (0.975534 + phi2 * (-0.119161 + lambda2 * -0.0143059 + phi2 * -0.0547009)) - x2, fy = phi * (1.00384 + lambda2 * (0.0802894 + phi2 * -0.02855 + lambda2 * 199025e-9) + phi2 * (0.0998909 + phi2 * -0.0491032)) - y2, deltaxDeltaLambda = 0.975534 - phi2 * (0.119161 + 3 * lambda2 * 0.0143059 + phi2 * 0.0547009), deltaxDeltaPhi = -lambdaPhi * (2 * 0.119161 + 4 * 0.0547009 * phi2 + 2 * 0.0143059 * lambda2), deltayDeltaLambda = lambdaPhi * (2 * 0.0802894 + 4 * 199025e-9 * lambda2 + 2 * -0.02855 * phi2), deltayDeltaPhi = 1.00384 + lambda2 * (0.0802894 + 199025e-9 * lambda2) + phi2 * (3 * (0.0998909 - 0.02855 * lambda2) - 5 * 0.0491032 * phi2), denominator = deltaxDeltaPhi * deltayDeltaLambda - deltayDeltaPhi * deltaxDeltaLambda, deltaLambda = (fy * deltaxDeltaPhi - fx * deltayDeltaPhi) / denominator, deltaPhi = (fx * deltayDeltaLambda - fy * deltaxDeltaLambda) / denominator;
+                lambda -= deltaLambda, phi -= deltaPhi;
+              } while ((abs(deltaLambda) > epsilon || abs(deltaPhi) > epsilon) && --i2 > 0);
+              return i2 && [lambda, phi];
+            };
+            function laskowski() {
+              return d3Geo.geoProjection(laskowskiRaw).scale(139.98);
             }
-          }
-        } else if (key in this._zoomKeys) {
-          map2.setZoom(map2.getZoom() + (e.shiftKey ? 3 : 1) * this._zoomKeys[key]);
-        } else if (key === 27 && map2._popup && map2._popup.options.closeOnEscapeKey) {
-          map2.closePopup();
-        } else {
-          return;
-        }
-        stop(e);
-      }
-    });
-    Map2.addInitHook("addHandler", "keyboard", Keyboard);
-    Map2.mergeOptions({
-      // @section Mouse wheel options
-      // @option scrollWheelZoom: Boolean|String = true
-      // Whether the map can be zoomed by using the mouse wheel. If passed `'center'`,
-      // it will zoom to the center of the view regardless of where the mouse was.
-      scrollWheelZoom: true,
-      // @option wheelDebounceTime: Number = 40
-      // Limits the rate at which a wheel can fire (in milliseconds). By default
-      // user can't zoom via wheel more often than once per 40 ms.
-      wheelDebounceTime: 40,
-      // @option wheelPxPerZoomLevel: Number = 60
-      // How many scroll pixels (as reported by [L.DomEvent.getWheelDelta](#domevent-getwheeldelta))
-      // mean a change of one full zoom level. Smaller values will make wheel-zooming
-      // faster (and vice versa).
-      wheelPxPerZoomLevel: 60
-    });
-    var ScrollWheelZoom = Handler.extend({
-      addHooks: function() {
-        on(this._map._container, "wheel", this._onWheelScroll, this);
-        this._delta = 0;
-      },
-      removeHooks: function() {
-        off(this._map._container, "wheel", this._onWheelScroll, this);
-      },
-      _onWheelScroll: function(e) {
-        var delta = getWheelDelta(e);
-        var debounce2 = this._map.options.wheelDebounceTime;
-        this._delta += delta;
-        this._lastMousePos = this._map.mouseEventToContainerPoint(e);
-        if (!this._startTime) {
-          this._startTime = +/* @__PURE__ */ new Date();
-        }
-        var left = Math.max(debounce2 - (+/* @__PURE__ */ new Date() - this._startTime), 0);
-        clearTimeout(this._timer);
-        this._timer = setTimeout(bind(this._performZoom, this), left);
-        stop(e);
-      },
-      _performZoom: function() {
-        var map2 = this._map, zoom2 = map2.getZoom(), snap = this._map.options.zoomSnap || 0;
-        map2._stop();
-        var d2 = this._delta / (this._map.options.wheelPxPerZoomLevel * 4), d3 = 4 * Math.log(2 / (1 + Math.exp(-Math.abs(d2)))) / Math.LN2, d4 = snap ? Math.ceil(d3 / snap) * snap : d3, delta = map2._limitZoom(zoom2 + (this._delta > 0 ? d4 : -d4)) - zoom2;
-        this._delta = 0;
-        this._startTime = null;
-        if (!delta) {
-          return;
-        }
-        if (map2.options.scrollWheelZoom === "center") {
-          map2.setZoom(zoom2 + delta);
-        } else {
-          map2.setZoomAround(this._lastMousePos, zoom2 + delta);
-        }
-      }
-    });
-    Map2.addInitHook("addHandler", "scrollWheelZoom", ScrollWheelZoom);
-    var tapHoldDelay = 600;
-    Map2.mergeOptions({
-      // @section Touch interaction options
-      // @option tapHold: Boolean
-      // Enables simulation of `contextmenu` event, default is `true` for mobile Safari.
-      tapHold: Browser.touchNative && Browser.safari && Browser.mobile,
-      // @option tapTolerance: Number = 15
-      // The max number of pixels a user can shift his finger during touch
-      // for it to be considered a valid tap.
-      tapTolerance: 15
-    });
-    var TapHold = Handler.extend({
-      addHooks: function() {
-        on(this._map._container, "touchstart", this._onDown, this);
-      },
-      removeHooks: function() {
-        off(this._map._container, "touchstart", this._onDown, this);
-      },
-      _onDown: function(e) {
-        clearTimeout(this._holdTimeout);
-        if (e.touches.length !== 1) {
-          return;
-        }
-        var first = e.touches[0];
-        this._startPos = this._newPos = new Point(first.clientX, first.clientY);
-        this._holdTimeout = setTimeout(bind(function() {
-          this._cancel();
-          if (!this._isTapValid()) {
-            return;
-          }
-          on(document, "touchend", preventDefault);
-          on(document, "touchend touchcancel", this._cancelClickPrevent);
-          this._simulateEvent("contextmenu", first);
-        }, this), tapHoldDelay);
-        on(document, "touchend touchcancel contextmenu", this._cancel, this);
-        on(document, "touchmove", this._onMove, this);
-      },
-      _cancelClickPrevent: function cancelClickPrevent() {
-        off(document, "touchend", preventDefault);
-        off(document, "touchend touchcancel", cancelClickPrevent);
-      },
-      _cancel: function() {
-        clearTimeout(this._holdTimeout);
-        off(document, "touchend touchcancel contextmenu", this._cancel, this);
-        off(document, "touchmove", this._onMove, this);
-      },
-      _onMove: function(e) {
-        var first = e.touches[0];
-        this._newPos = new Point(first.clientX, first.clientY);
-      },
-      _isTapValid: function() {
-        return this._newPos.distanceTo(this._startPos) <= this._map.options.tapTolerance;
-      },
-      _simulateEvent: function(type, e) {
-        var simulatedEvent = new MouseEvent(type, {
-          bubbles: true,
-          cancelable: true,
-          view: window,
-          // detail: 1,
-          screenX: e.screenX,
-          screenY: e.screenY,
-          clientX: e.clientX,
-          clientY: e.clientY
-          // button: 2,
-          // buttons: 2
-        });
-        simulatedEvent._simulated = true;
-        e.target.dispatchEvent(simulatedEvent);
-      }
-    });
-    Map2.addInitHook("addHandler", "tapHold", TapHold);
-    Map2.mergeOptions({
-      // @section Touch interaction options
-      // @option touchZoom: Boolean|String = *
-      // Whether the map can be zoomed by touch-dragging with two fingers. If
-      // passed `'center'`, it will zoom to the center of the view regardless of
-      // where the touch events (fingers) were. Enabled for touch-capable web
-      // browsers.
-      touchZoom: Browser.touch,
-      // @option bounceAtZoomLimits: Boolean = true
-      // Set it to false if you don't want the map to zoom beyond min/max zoom
-      // and then bounce back when pinch-zooming.
-      bounceAtZoomLimits: true
-    });
-    var TouchZoom = Handler.extend({
-      addHooks: function() {
-        addClass(this._map._container, "leaflet-touch-zoom");
-        on(this._map._container, "touchstart", this._onTouchStart, this);
-      },
-      removeHooks: function() {
-        removeClass(this._map._container, "leaflet-touch-zoom");
-        off(this._map._container, "touchstart", this._onTouchStart, this);
-      },
-      _onTouchStart: function(e) {
-        var map2 = this._map;
-        if (!e.touches || e.touches.length !== 2 || map2._animatingZoom || this._zooming) {
-          return;
-        }
-        var p1 = map2.mouseEventToContainerPoint(e.touches[0]), p2 = map2.mouseEventToContainerPoint(e.touches[1]);
-        this._centerPoint = map2.getSize()._divideBy(2);
-        this._startLatLng = map2.containerPointToLatLng(this._centerPoint);
-        if (map2.options.touchZoom !== "center") {
-          this._pinchStartLatLng = map2.containerPointToLatLng(p1.add(p2)._divideBy(2));
-        }
-        this._startDist = p1.distanceTo(p2);
-        this._startZoom = map2.getZoom();
-        this._moved = false;
-        this._zooming = true;
-        map2._stop();
-        on(document, "touchmove", this._onTouchMove, this);
-        on(document, "touchend touchcancel", this._onTouchEnd, this);
-        preventDefault(e);
-      },
-      _onTouchMove: function(e) {
-        if (!e.touches || e.touches.length !== 2 || !this._zooming) {
-          return;
-        }
-        var map2 = this._map, p1 = map2.mouseEventToContainerPoint(e.touches[0]), p2 = map2.mouseEventToContainerPoint(e.touches[1]), scale2 = p1.distanceTo(p2) / this._startDist;
-        this._zoom = map2.getScaleZoom(scale2, this._startZoom);
-        if (!map2.options.bounceAtZoomLimits && (this._zoom < map2.getMinZoom() && scale2 < 1 || this._zoom > map2.getMaxZoom() && scale2 > 1)) {
-          this._zoom = map2._limitZoom(this._zoom);
-        }
-        if (map2.options.touchZoom === "center") {
-          this._center = this._startLatLng;
-          if (scale2 === 1) {
-            return;
-          }
-        } else {
-          var delta = p1._add(p2)._divideBy(2)._subtract(this._centerPoint);
-          if (scale2 === 1 && delta.x === 0 && delta.y === 0) {
-            return;
-          }
-          this._center = map2.unproject(map2.project(this._pinchStartLatLng, this._zoom).subtract(delta), this._zoom);
-        }
-        if (!this._moved) {
-          map2._moveStart(true, false);
-          this._moved = true;
-        }
-        cancelAnimFrame(this._animRequest);
-        var moveFn = bind(map2._move, map2, this._center, this._zoom, { pinch: true, round: false }, void 0);
-        this._animRequest = requestAnimFrame2(moveFn, this, true);
-        preventDefault(e);
-      },
-      _onTouchEnd: function() {
-        if (!this._moved || !this._zooming) {
-          this._zooming = false;
-          return;
-        }
-        this._zooming = false;
-        cancelAnimFrame(this._animRequest);
-        off(document, "touchmove", this._onTouchMove, this);
-        off(document, "touchend touchcancel", this._onTouchEnd, this);
-        if (this._map.options.zoomAnimation) {
-          this._map._animateZoom(this._center, this._map._limitZoom(this._zoom), true, this._map.options.zoomSnap);
-        } else {
-          this._map._resetView(this._center, this._map._limitZoom(this._zoom));
-        }
-      }
-    });
-    Map2.addInitHook("addHandler", "touchZoom", TouchZoom);
-    Map2.BoxZoom = BoxZoom;
-    Map2.DoubleClickZoom = DoubleClickZoom;
-    Map2.Drag = Drag;
-    Map2.Keyboard = Keyboard;
-    Map2.ScrollWheelZoom = ScrollWheelZoom;
-    Map2.TapHold = TapHold;
-    Map2.TouchZoom = TouchZoom;
-    exports2.Bounds = Bounds;
-    exports2.Browser = Browser;
-    exports2.CRS = CRS;
-    exports2.Canvas = Canvas;
-    exports2.Circle = Circle;
-    exports2.CircleMarker = CircleMarker;
-    exports2.Class = Class;
-    exports2.Control = Control;
-    exports2.DivIcon = DivIcon;
-    exports2.DivOverlay = DivOverlay;
-    exports2.DomEvent = DomEvent;
-    exports2.DomUtil = DomUtil;
-    exports2.Draggable = Draggable;
-    exports2.Evented = Evented;
-    exports2.FeatureGroup = FeatureGroup;
-    exports2.GeoJSON = GeoJSON;
-    exports2.GridLayer = GridLayer;
-    exports2.Handler = Handler;
-    exports2.Icon = Icon;
-    exports2.ImageOverlay = ImageOverlay;
-    exports2.LatLng = LatLng;
-    exports2.LatLngBounds = LatLngBounds;
-    exports2.Layer = Layer;
-    exports2.LayerGroup = LayerGroup;
-    exports2.LineUtil = LineUtil;
-    exports2.Map = Map2;
-    exports2.Marker = Marker2;
-    exports2.Mixin = Mixin;
-    exports2.Path = Path;
-    exports2.Point = Point;
-    exports2.PolyUtil = PolyUtil;
-    exports2.Polygon = Polygon;
-    exports2.Polyline = Polyline;
-    exports2.Popup = Popup;
-    exports2.PosAnimation = PosAnimation;
-    exports2.Projection = index;
-    exports2.Rectangle = Rectangle;
-    exports2.Renderer = Renderer;
-    exports2.SVG = SVG;
-    exports2.SVGOverlay = SVGOverlay;
-    exports2.TileLayer = TileLayer2;
-    exports2.Tooltip = Tooltip2;
-    exports2.Transformation = Transformation;
-    exports2.Util = Util;
-    exports2.VideoOverlay = VideoOverlay;
-    exports2.bind = bind;
-    exports2.bounds = toBounds;
-    exports2.canvas = canvas;
-    exports2.circle = circle;
-    exports2.circleMarker = circleMarker;
-    exports2.control = control;
-    exports2.divIcon = divIcon;
-    exports2.extend = extend;
-    exports2.featureGroup = featureGroup;
-    exports2.geoJSON = geoJSON;
-    exports2.geoJson = geoJson;
-    exports2.gridLayer = gridLayer;
-    exports2.icon = icon;
-    exports2.imageOverlay = imageOverlay;
-    exports2.latLng = toLatLng;
-    exports2.latLngBounds = toLatLngBounds;
-    exports2.layerGroup = layerGroup;
-    exports2.map = createMap;
-    exports2.marker = marker;
-    exports2.point = toPoint;
-    exports2.polygon = polygon;
-    exports2.polyline = polyline;
-    exports2.popup = popup;
-    exports2.rectangle = rectangle;
-    exports2.setOptions = setOptions2;
-    exports2.stamp = stamp;
-    exports2.svg = svg;
-    exports2.svgOverlay = svgOverlay;
-    exports2.tileLayer = tileLayer;
-    exports2.tooltip = tooltip;
-    exports2.transformation = toTransformation;
-    exports2.version = version2;
-    exports2.videoOverlay = videoOverlay;
-    var oldL = window.L;
-    exports2.noConflict = function() {
-      window.L = oldL;
-      return this;
-    };
-    window.L = exports2;
-  });
-})(leafletSrc, leafletSrc.exports);
-var leafletSrcExports = leafletSrc.exports;
-const L$1 = /* @__PURE__ */ getDefaultExportFromCjs(leafletSrcExports);
-function createElementObject(instance, context, container) {
-  return Object.freeze({
-    instance,
-    context,
-    container
-  });
-}
-function createElementHook(createElement, updateElement) {
-  if (updateElement == null) {
-    return function useImmutableLeafletElement(props, context) {
-      const elementRef = reactExports.useRef();
-      if (!elementRef.current) elementRef.current = createElement(props, context);
-      return elementRef;
-    };
-  }
-  return function useMutableLeafletElement(props, context) {
-    const elementRef = reactExports.useRef();
-    if (!elementRef.current) elementRef.current = createElement(props, context);
-    const propsRef = reactExports.useRef(props);
-    const { instance } = elementRef.current;
-    reactExports.useEffect(function updateElementProps() {
-      if (propsRef.current !== props) {
-        updateElement(instance, props, propsRef.current);
-        propsRef.current = props;
-      }
-    }, [
-      instance,
-      props,
-      context
-    ]);
-    return elementRef;
-  };
-}
-function useLayerLifecycle(element, context) {
-  reactExports.useEffect(function addLayer() {
-    const container = context.layerContainer ?? context.map;
-    container.addLayer(element.instance);
-    return function removeLayer() {
-      var _a2;
-      (_a2 = context.layerContainer) == null ? void 0 : _a2.removeLayer(element.instance);
-      context.map.removeLayer(element.instance);
-    };
-  }, [
-    context,
-    element
-  ]);
-}
-function createLayerHook(useElement) {
-  return function useLayer(props) {
-    const context = useLeafletContext();
-    const elementRef = useElement(withPane(props, context), context);
-    useAttribution(context.map, props.attribution);
-    useEventHandlers(elementRef.current, props.eventHandlers);
-    useLayerLifecycle(elementRef.current, context);
-    return elementRef;
-  };
-}
-function createLayerComponent(createElement, updateElement) {
-  const useElement = createElementHook(createElement, updateElement);
-  const useLayer = createLayerHook(useElement);
-  return createContainerComponent(useLayer);
-}
-function createTileLayerComponent(createElement, updateElement) {
-  const useElement = createElementHook(createElement, updateElement);
-  const useLayer = createLayerHook(useElement);
-  return createLeafComponent(useLayer);
-}
-function updateGridLayer(layer, props, prevProps) {
-  const { opacity, zIndex } = props;
-  if (opacity != null && opacity !== prevProps.opacity) {
-    layer.setOpacity(opacity);
-  }
-  if (zIndex != null && zIndex !== prevProps.zIndex) {
-    layer.setZIndex(zIndex);
-  }
-}
-function useMap() {
-  return useLeafletContext().map;
-}
-function useMapEvents(handlers) {
-  const map2 = useMap();
-  reactExports.useEffect(function addMapEventHandlers() {
-    map2.on(handlers);
-    return function removeMapEventHandlers() {
-      map2.off(handlers);
-    };
-  }, [
-    map2,
-    handlers
-  ]);
-  return map2;
-}
-function _extends() {
-  _extends = Object.assign || function(target) {
-    for (var i = 1; i < arguments.length; i++) {
-      var source = arguments[i];
-      for (var key in source) {
-        if (Object.prototype.hasOwnProperty.call(source, key)) {
-          target[key] = source[key];
-        }
-      }
-    }
-    return target;
-  };
-  return _extends.apply(this, arguments);
-}
-function MapContainerComponent({ bounds, boundsOptions, center, children, className, id: id2, placeholder, style, whenReady, zoom, ...options }, forwardedRef) {
-  const [props] = reactExports.useState({
-    className,
-    id: id2,
-    style
-  });
-  const [context, setContext] = reactExports.useState(null);
-  reactExports.useImperativeHandle(forwardedRef, () => (context == null ? void 0 : context.map) ?? null, [
-    context
-  ]);
-  const mapRef = reactExports.useCallback((node) => {
-    if (node !== null && context === null) {
-      const map2 = new leafletSrcExports.Map(node, options);
-      if (center != null && zoom != null) {
-        map2.setView(center, zoom);
-      } else if (bounds != null) {
-        map2.fitBounds(bounds, boundsOptions);
-      }
-      if (whenReady != null) {
-        map2.whenReady(whenReady);
-      }
-      setContext(createLeafletContext(map2));
-    }
-  }, []);
-  reactExports.useEffect(() => {
-    return () => {
-      context == null ? void 0 : context.map.remove();
-    };
-  }, [
-    context
-  ]);
-  const contents = context ? /* @__PURE__ */ React.createElement(LeafletProvider, {
-    value: context
-  }, children) : placeholder ?? null;
-  return /* @__PURE__ */ React.createElement("div", _extends({}, props, {
-    ref: mapRef
-  }), contents);
-}
-const MapContainer$1 = /* @__PURE__ */ reactExports.forwardRef(MapContainerComponent);
-const Marker = createLayerComponent(function createMarker({ position, ...options }, ctx) {
-  const marker = new leafletSrcExports.Marker(position, options);
-  return createElementObject(marker, extendContext(ctx, {
-    overlayContainer: marker
-  }));
-}, function updateMarker(marker, props, prevProps) {
-  if (props.position !== prevProps.position) {
-    marker.setLatLng(props.position);
-  }
-  if (props.icon != null && props.icon !== prevProps.icon) {
-    marker.setIcon(props.icon);
-  }
-  if (props.zIndexOffset != null && props.zIndexOffset !== prevProps.zIndexOffset) {
-    marker.setZIndexOffset(props.zIndexOffset);
-  }
-  if (props.opacity != null && props.opacity !== prevProps.opacity) {
-    marker.setOpacity(props.opacity);
-  }
-  if (marker.dragging != null && props.draggable !== prevProps.draggable) {
-    if (props.draggable === true) {
-      marker.dragging.enable();
-    } else {
-      marker.dragging.disable();
-    }
-  }
-});
-const TileLayer = createTileLayerComponent(function createTileLayer({ url, ...options }, context) {
-  const layer = new leafletSrcExports.TileLayer(url, withPane(options, context));
-  return createElementObject(layer, context);
-}, function updateTileLayer(layer, props, prevProps) {
-  updateGridLayer(layer, props, prevProps);
-  const { url } = props;
-  if (url != null && url !== prevProps.url) {
-    layer.setUrl(url);
-  }
-});
-const baseMaps = {
-  esriSatellite: {
-    url: "https://server.arcgisonline.com/ArcGIS/rest/services/World_Imagery/MapServer/tile/{z}/{y}/{x}",
-    attribution: "Tiles © Esri — Source: Esri, i-cubed, USDA, USGS, AEX, GeoEye, Getmapping, Aerogrid, IGN, IGP, UPR-EGP, and the GIS User Community"
-  },
-  openstreetmap: {
-    url: "https://tile.openstreetmap.org/{z}/{x}/{y}.png",
-    attribution: '&copy; <a href="http://www.openstreetmap.org/copyright">OpenStreetMap</a>'
-  },
-  topography: {
-    url: "https://basemap.nationalmap.gov/arcgis/rest/services/USGSTopo/MapServer/tile/{z}/{y}/{x}",
-    attribution: 'Tiles courtesy of the <a href="https://usgs.gov/">U.S. Geological Survey</a>'
-  },
-  openTopoMap: {
-    url: "https://{s}.tile.opentopomap.org/{z}/{x}/{y}.png",
-    attribution: 'Map data © <a href="https://www.openstreetmap.org/copyright">OpenStreetMap</a> contributors, <a href="http://viewfinderpanoramas.org">SRTM</a> | Map style © <a href="https://opentopomap.org">OpenTopoMap</a> (<a href="https://creativecommons.org/licenses/by-sa/3.0/">CC-BY-SA</a>)'
-  },
-  shadedRelief: {
-    url: "https://server.arcgisonline.com/arcgis/rest/services/Elevation/World_Hillshade/MapServer/tile/{z}/{y}/{x}",
-    attribution: "USGS"
-  }
-};
-class MousePositionControl extends L$1.Control {
-  constructor(options) {
-    super(options);
-    __publicField(this, "_container", null);
-    // Make options public to match L.Control
-    __publicField(this, "options");
-    this.options = {
-      position: "bottomleft",
-      separator: " : ",
-      emptyString: "Unavailable",
-      lngFirst: false,
-      numDigits: 5,
-      lngFormatter: void 0,
-      latFormatter: void 0,
-      prefix: "",
-      ...options
-    };
-  }
-  onAdd(map2) {
-    this._container = L$1.DomUtil.create("div", "leaflet-control-mouseposition");
-    L$1.DomEvent.disableClickPropagation(this._container);
-    map2.on("mousemove", this._onMouseMove, this);
-    this._container.innerHTML = this.options.emptyString || "";
-    return this._container;
-  }
-  onRemove(map2) {
-    map2.off("mousemove", this._onMouseMove, this);
-  }
-  _onMouseMove(e) {
-    if (!this._container) return;
-    const lng = this.options.lngFormatter ? this.options.lngFormatter(e.latlng.lng) : L$1.Util.formatNum(e.latlng.lng, this.options.numDigits || 5);
-    const lat = this.options.latFormatter ? this.options.latFormatter(e.latlng.lat) : L$1.Util.formatNum(e.latlng.lat, this.options.numDigits || 5);
-    const formattedText = `lon ${lng}    lat ${lat}`;
-    const prefixAndValue = this.options.prefix ? this.options.prefix + " " + formattedText : formattedText;
-    this._container.innerHTML = prefixAndValue;
-  }
-}
-L$1.control.mousePosition = function(options) {
-  return new MousePositionControl(options);
-};
-L$1.control.mousePosition;
-delete L$1.Icon.Default.prototype._getIconUrl;
-L$1.Icon.Default.mergeOptions({
-  iconRetinaUrl: "https://cdnjs.cloudflare.com/ajax/libs/leaflet/1.7.1/images/marker-icon-2x.png",
-  iconUrl: "https://cdnjs.cloudflare.com/ajax/libs/leaflet/1.7.1/images/marker-icon.png",
-  shadowUrl: "https://cdnjs.cloudflare.com/ajax/libs/leaflet/1.7.1/images/marker-shadow.png"
-});
-const fontAwesomeIcon = L$1.divIcon({
-  html: '<i class="fa-solid fa-location-dot fa-3x"></i>',
-  iconSize: [20, 20],
-  className: "myDivIcon"
-});
-function MapEvents() {
-  const { dispatch } = useAppContext();
-  useMapEvents({
-    click: (e) => {
-      dispatch({
-        type: "ADD_TIME_SERIES_POINT",
-        payload: {
-          position: [e.latlng.lat, e.latlng.lng],
-          name: `Point ${Date.now().toString().slice(-4)}`
-          // Short unique name
-        }
-      });
-    }
-  });
-  return null;
-}
-function MousePosition() {
-  const map2 = useMap();
-  reactExports.useEffect(() => {
-    const mousePositionControl = new MousePositionControl();
-    mousePositionControl.addTo(map2);
-    return () => {
-      mousePositionControl.remove();
-    };
-  }, [map2]);
-  return null;
-}
-function RasterTileLayer() {
-  const { state } = useAppContext();
-  const [tileUrl, setTileUrl] = reactExports.useState(null);
-  reactExports.useEffect(() => {
-    if (!state.currentDataset || !state.datasetInfo[state.currentDataset]) {
-      return;
-    }
-    const controller = new AbortController();
-    const signal = controller.signal;
-    const updateTileLayer2 = async () => {
-      const currentDatasetInfo = state.datasetInfo[state.currentDataset];
-      const colormap = state.colormap;
-      const vmin = state.vmin;
-      const vmax = state.vmax;
-      const maxIdx = currentDatasetInfo.x_values.length - 1;
-      const timeIdx = Math.max(0, Math.min(state.currentTimeIndex, maxIdx));
-      const params = {
-        variable: state.currentDataset,
-        time_idx: timeIdx.toString(),
-        rescale: `${vmin},${vmax}`,
-        colormap_name: colormap
-      };
-      if (currentDatasetInfo.algorithm) {
-        params.algorithm = currentDatasetInfo.algorithm;
-      }
-      if (state.refValues[state.currentDataset] && currentDatasetInfo.algorithm === "shift") {
-        const shift = state.refValues[state.currentDataset][timeIdx];
-        if (shift !== void 0) {
-          params.algorithm_params = JSON.stringify({ shift });
-        }
-      }
-      if (state.dataMode === "cog") {
-        const url = currentDatasetInfo.file_list[timeIdx];
-        const maskUrl = currentDatasetInfo.mask_file_list[timeIdx];
-        const maskMinValue = currentDatasetInfo.mask_min_value;
-        params.url = url;
-        if (maskUrl) params.mask = encodeURIComponent(maskUrl);
-        if (maskMinValue !== void 0) params.mask_min_value = maskMinValue.toString();
-      }
-      const urlParams = new URLSearchParams(params).toString();
-      const endpoint = state.dataMode === "md" ? `/md/WebMercatorQuad/tilejson.json?${urlParams}` : `/cog/WebMercatorQuad/tilejson.json?${urlParams}`;
-      try {
-        const response = await fetch(endpoint, { signal });
-        if (!response.ok) throw new Error(`HTTP ${response.status}`);
-        const tileInfo = await response.json();
-        if (!signal.aborted) setTileUrl(tileInfo.tiles[0]);
-      } catch (err) {
-        if (err.name !== "AbortError") {
-          console.error("Error fetching tile info:", err);
-        }
-      }
-    };
-    updateTileLayer2();
-    return () => controller.abort();
-  }, [
-    state.currentDataset,
-    state.currentTimeIndex,
-    state.datasetInfo,
-    state.dataMode,
-    state.refValues,
-    state.refMarkerPosition,
-    state.colormap,
-    state.vmin,
-    state.vmax
-  ]);
-  if (!tileUrl) return null;
-  return /* @__PURE__ */ jsxRuntimeExports.jsx(
-    TileLayer,
-    {
-      url: tileUrl,
-      opacity: state.opacity,
-      maxZoom: 19
-    },
-    tileUrl
-  );
-}
-function MarkerEventHandlers() {
-  const { state, dispatch } = useAppContext();
-  const { fetchPointTimeSeries } = useApi();
-  const map2 = useMap();
-  const handleMarkerClick = (position, pointName) => {
-    const [lat, lng] = position;
-    const content = pointName ? `${pointName} (lon, lat):
-(${lng.toFixed(6)}, ${lat.toFixed(6)})` : `Reference (lon, lat):
-(${lng.toFixed(6)}, ${lat.toFixed(6)})`;
-    L$1.popup().setLatLng([lat, lng]).setContent(content).openOn(map2);
-  };
-  const handleTsMarkerDragEnd = (pointId) => (e) => {
-    const marker = e.target;
-    const position = marker.getLatLng();
-    dispatch({
-      type: "UPDATE_TIME_SERIES_POINT",
-      payload: {
-        id: pointId,
-        updates: { position: [position.lat, position.lng] }
-      }
-    });
-  };
-  const handleRefMarkerDragEnd = async (e) => {
-    const marker = e.target;
-    const position = marker.getLatLng();
-    const lat = position.lat;
-    const lng = position.lng;
-    dispatch({ type: "SET_REF_MARKER_POSITION", payload: [lat, lng] });
-    const ds = state.currentDataset;
-    const info = ds ? state.datasetInfo[ds] : null;
-    if (ds && (info == null ? void 0 : info.algorithm) === "shift") {
-      try {
-        const values = await fetchPointTimeSeries(lng, lat, ds);
-        if (values) {
-          dispatch({
-            type: "SET_REF_VALUES",
-            payload: { dataset: ds, values }
-          });
-        }
-      } catch (err) {
-        console.error("Error updating reference values after drag:", err);
-      }
-    }
-  };
-  const handleTsMarkerDoubleClick = (pointId) => () => {
-    dispatch({ type: "REMOVE_TIME_SERIES_POINT", payload: pointId });
-  };
-  const createColoredIcon = (color2, isSelected = false) => {
-    const iconSize = isSelected ? 25 : 20;
-    return L$1.divIcon({
-      html: `<div style="
-        width: ${iconSize}px;
-        height: ${iconSize}px;
-        background-color: ${color2};
-        border: ${isSelected ? "3px solid white" : "2px solid white"};
-        border-radius: 50%;
-        box-shadow: 0 2px 4px rgba(0,0,0,0.3);
-      "></div>`,
-      iconSize: [iconSize, iconSize],
-      className: "custom-colored-marker"
-    });
-  };
-  return /* @__PURE__ */ jsxRuntimeExports.jsxs(jsxRuntimeExports.Fragment, { children: [
-    state.timeSeriesPoints.filter((p2) => p2.visible).map((point) => /* @__PURE__ */ jsxRuntimeExports.jsx(
-      Marker,
-      {
-        position: point.position,
-        icon: createColoredIcon(point.color, state.selectedPointId === point.id),
-        draggable: true,
-        title: `${point.name} - Double-click to remove`,
-        eventHandlers: {
-          click: () => {
-            handleMarkerClick(point.position, point.name);
-            dispatch({ type: "SET_SELECTED_POINT", payload: point.id });
-          },
-          dragend: handleTsMarkerDragEnd(point.id),
-          dblclick: handleTsMarkerDoubleClick(point.id)
-        }
-      },
-      point.id
-    )),
-    /* @__PURE__ */ jsxRuntimeExports.jsx(
-      Marker,
-      {
-        position: state.refMarkerPosition,
-        icon: fontAwesomeIcon,
-        draggable: true,
-        title: "Reference Location",
-        eventHandlers: {
-          click: () => handleMarkerClick(state.refMarkerPosition),
-          dragend: handleRefMarkerDragEnd
-        }
-      }
-    )
-  ] });
-}
-function MapContainer() {
-  const { state } = useAppContext();
-  const getInitialCenter = () => {
-    if (state.currentDataset && state.datasetInfo[state.currentDataset]) {
-      const bounds = state.datasetInfo[state.currentDataset].latlon_bounds;
-      const centerLat = (bounds[1] + bounds[3]) / 2;
-      const centerLng = (bounds[0] + bounds[2]) / 2;
-      return [centerLat, centerLng];
-    }
-    const datasets = Object.values(state.datasetInfo);
-    if (datasets.length > 0) {
-      const bounds = datasets[0].latlon_bounds;
-      const centerLat = (bounds[1] + bounds[3]) / 2;
-      const centerLng = (bounds[0] + bounds[2]) / 2;
-      return [centerLat, centerLng];
-    }
-    return [0, 0];
-  };
-  const selectedBasemap = baseMaps[state.selectedBasemap] || baseMaps.esriSatellite;
-  const center = getInitialCenter();
-  const hasDatasets = Object.keys(state.datasetInfo).length > 0;
-  return /* @__PURE__ */ jsxRuntimeExports.jsxs(
-    MapContainer$1,
-    {
-      center,
-      zoom: 9,
-      style: { height: "100%", width: "100%" },
-      doubleClickZoom: false,
-      children: [
-        /* @__PURE__ */ jsxRuntimeExports.jsx(
-          TileLayer,
-          {
-            url: selectedBasemap.url,
-            attribution: selectedBasemap.attribution,
-            maxZoom: 19
-          }
-        ),
-        /* @__PURE__ */ jsxRuntimeExports.jsx(RasterTileLayer, {}),
-        /* @__PURE__ */ jsxRuntimeExports.jsx(MarkerEventHandlers, {}),
-        /* @__PURE__ */ jsxRuntimeExports.jsx(MapEvents, {}),
-        /* @__PURE__ */ jsxRuntimeExports.jsx(MousePosition, {})
-      ]
-    },
-    hasDatasets ? "with-data" : "no-data"
-  );
-}
-const colormapOptions = [
-  { value: "rdbu_r", label: "Blue-Red" },
-  { value: "twilight", label: "Twilight (cyclic)" },
-  { value: "cfastie", label: "CFastie" },
-  { value: "rplumbo", label: "RPlumbo" },
-  { value: "schwarzwald", label: "Schwarzwald (elevation)" },
-  { value: "viridis", label: "Viridis" },
-  { value: "bugn", label: "Blue-Green" },
-  { value: "ylgn", label: "Yellow-Green" },
-  { value: "magma", label: "Magma" },
-  { value: "gist_earth", label: "Earth" },
-  { value: "ocean", label: "Ocean" },
-  { value: "terrain", label: "Terrain" }
-];
-function ControlPanel() {
-  const { state, dispatch } = useAppContext();
-  const { fetchPointTimeSeries } = useApi();
-  const [draftVmin, setDraftVmin] = reactExports.useState(String(state.vmin));
-  const [draftVmax, setDraftVmax] = reactExports.useState(String(state.vmax));
-  reactExports.useEffect(() => setDraftVmin(String(state.vmin)), [state.vmin]);
-  reactExports.useEffect(() => setDraftVmax(String(state.vmax)), [state.vmax]);
-  reactExports.useEffect(() => {
-    const datasetName = state.currentDataset;
-    if (!datasetName) return;
-    const safeNumToString = (x2) => Object.is(x2, -0) ? "-0" : String(x2);
-    localStorage.setItem(`${datasetName}-colormap_name`, state.colormap);
-    localStorage.setItem(`${datasetName}-vmin`, safeNumToString(state.vmin));
-    localStorage.setItem(`${datasetName}-vmax`, safeNumToString(state.vmax));
-  }, [state.currentDataset, state.colormap, state.vmin, state.vmax]);
-  reactExports.useEffect(() => {
-    const datasetName = state.currentDataset;
-    if (!datasetName) return;
-    const colormap = localStorage.getItem(`${datasetName}-colormap_name`);
-    const vminStr = localStorage.getItem(`${datasetName}-vmin`);
-    const vmaxStr = localStorage.getItem(`${datasetName}-vmax`);
-    if (colormap) dispatch({ type: "SET_COLORMAP", payload: colormap });
-    if (vminStr !== null) {
-      const v2 = Number(vminStr);
-      if (!Number.isNaN(v2)) dispatch({ type: "SET_VMIN", payload: v2 });
-    }
-    if (vmaxStr !== null) {
-      const v2 = Number(vmaxStr);
-      if (!Number.isNaN(v2)) dispatch({ type: "SET_VMAX", payload: v2 });
-    }
-  }, [state.currentDataset, dispatch]);
-  const handleDatasetChange = (datasetName) => {
-    dispatch({ type: "SET_CURRENT_DATASET", payload: datasetName });
-    const currentDatasetInfo2 = state.datasetInfo[datasetName];
-    if ((currentDatasetInfo2 == null ? void 0 : currentDatasetInfo2.uses_spatial_ref) && !state.refValues[datasetName]) {
-      setRefValues(datasetName);
-    }
-  };
-  const handleTimeIndexChange = (newIndex) => {
-    dispatch({ type: "SET_TIME_INDEX", payload: newIndex });
-  };
-  const handleColormapChange = (colormap) => {
-    dispatch({ type: "SET_COLORMAP", payload: colormap });
-  };
-  const commitVmin = reactExports.useCallback(() => {
-    const v2 = Number(draftVmin);
-    if (!Number.isNaN(v2)) {
-      dispatch({ type: "SET_VMIN", payload: v2 });
-    }
-  }, [draftVmin, dispatch]);
-  const commitVmax = reactExports.useCallback(() => {
-    const v2 = Number(draftVmax);
-    if (!Number.isNaN(v2)) {
-      dispatch({ type: "SET_VMAX", payload: v2 });
-    }
-  }, [draftVmax, dispatch]);
-  const handleOpacityChange = (opacity) => {
-    dispatch({ type: "SET_OPACITY", payload: opacity });
-  };
-  const handleBasemapChange = (basemapKey) => {
-    dispatch({ type: "SET_BASEMAP", payload: basemapKey });
-  };
-  const toggleChart = () => {
-    dispatch({ type: "TOGGLE_CHART" });
-  };
-  const setRefValues = async (datasetName) => {
-    const [lat, lng] = state.refMarkerPosition;
-    try {
-      const values = await fetchPointTimeSeries(lng, lat, datasetName);
-      if (values) {
-        dispatch({
-          type: "SET_REF_VALUES",
-          payload: { dataset: datasetName, values }
-        });
-      }
-    } catch (error) {
-      console.error("Error setting reference values:", error);
-    }
-  };
-  const currentDatasetInfo = state.currentDataset ? state.datasetInfo[state.currentDataset] : null;
-  const currentTimeValue = currentDatasetInfo ? currentDatasetInfo.x_values[state.currentTimeIndex] : "";
-  return /* @__PURE__ */ jsxRuntimeExports.jsxs("div", { id: "menu", children: [
-    /* @__PURE__ */ jsxRuntimeExports.jsxs("div", { id: "menu-content", className: "pure-form", children: [
-      /* @__PURE__ */ jsxRuntimeExports.jsxs("div", { className: "menu-group", children: [
-        /* @__PURE__ */ jsxRuntimeExports.jsxs("div", { children: [
-          /* @__PURE__ */ jsxRuntimeExports.jsx("i", { className: "fa-solid fa-layer-group" }),
-          " Layers"
-        ] }),
-        /* @__PURE__ */ jsxRuntimeExports.jsx("div", { className: "select-container", children: /* @__PURE__ */ jsxRuntimeExports.jsx(
-          "select",
-          {
-            value: state.currentDataset,
-            onChange: (e) => handleDatasetChange(e.target.value),
-            children: Object.keys(state.datasetInfo).map((datasetName) => /* @__PURE__ */ jsxRuntimeExports.jsx("option", { value: datasetName, children: datasetName }, datasetName))
-          }
-        ) })
-      ] }),
-      currentDatasetInfo && /* @__PURE__ */ jsxRuntimeExports.jsxs("div", { className: "menu-group", children: [
-        /* @__PURE__ */ jsxRuntimeExports.jsxs("label", { htmlFor: "layer-slider", children: [
-          "Viewing Image: ",
-          /* @__PURE__ */ jsxRuntimeExports.jsx("span", { id: "layer-slider-value", children: currentTimeValue })
-        ] }),
-        /* @__PURE__ */ jsxRuntimeExports.jsx(
-          "input",
-          {
-            id: "layer-slider",
-            className: "input",
-            type: "range",
-            min: "0",
-            max: currentDatasetInfo.x_values.length - 1,
-            step: "1",
-            value: state.currentTimeIndex,
-            onChange: (e) => handleTimeIndexChange(parseInt(e.target.value))
-          }
-        )
-      ] }),
-      /* @__PURE__ */ jsxRuntimeExports.jsxs("div", { className: "menu-group", children: [
-        /* @__PURE__ */ jsxRuntimeExports.jsxs("div", { id: "colormap-section", children: [
-          /* @__PURE__ */ jsxRuntimeExports.jsxs("div", { children: [
-            /* @__PURE__ */ jsxRuntimeExports.jsx("i", { className: "fa-solid fa-palette" }),
-            " Color Map"
-          ] }),
-          /* @__PURE__ */ jsxRuntimeExports.jsx("div", { className: "select-container", children: /* @__PURE__ */ jsxRuntimeExports.jsx(
-            "select",
-            {
-              value: state.colormap,
-              onChange: (e) => handleColormapChange(e.target.value),
-              children: colormapOptions.map((option) => /* @__PURE__ */ jsxRuntimeExports.jsx("option", { value: option.value, children: option.label }, option.value))
+            function littrowRaw(lambda, phi) {
+              return [
+                sin(lambda) / cos(phi),
+                tan(phi) * cos(lambda)
+              ];
+            }
+            littrowRaw.invert = function(x2, y2) {
+              var x22 = x2 * x2, y22 = y2 * y2, y2_1 = y22 + 1, x2_y2_1 = x22 + y2_1, cosPhi = x2 ? sqrt1_2 * sqrt((x2_y2_1 - sqrt(x2_y2_1 * x2_y2_1 - 4 * x22)) / x22) : 1 / sqrt(y2_1);
+              return [
+                asin(x2 * cosPhi),
+                sign(y2) * acos(cosPhi)
+              ];
+            };
+            function littrow() {
+              return d3Geo.geoProjection(littrowRaw).scale(144.049).clipAngle(90 - 1e-3);
+            }
+            function loximuthalRaw(phi02) {
+              var cosPhi0 = cos(phi02), tanPhi0 = tan(quarterPi + phi02 / 2);
+              function forward(lambda, phi) {
+                var y2 = phi - phi02, x2 = abs(y2) < epsilon ? lambda * cosPhi0 : abs(x2 = quarterPi + phi / 2) < epsilon || abs(abs(x2) - halfPi) < epsilon ? 0 : lambda * y2 / log3(tan(x2) / tanPhi0);
+                return [x2, y2];
+              }
+              forward.invert = function(x2, y2) {
+                var lambda, phi = y2 + phi02;
+                return [
+                  abs(y2) < epsilon ? x2 / cosPhi0 : abs(lambda = quarterPi + phi / 2) < epsilon || abs(abs(lambda) - halfPi) < epsilon ? 0 : x2 * log3(tan(lambda) / tanPhi0) / y2,
+                  phi
+                ];
+              };
+              return forward;
+            }
+            function loximuthal() {
+              return parallel1(loximuthalRaw).parallel(40).scale(158.837);
+            }
+            function millerRaw(lambda, phi) {
+              return [lambda, 1.25 * log3(tan(quarterPi + 0.4 * phi))];
+            }
+            millerRaw.invert = function(x2, y2) {
+              return [x2, 2.5 * atan(exp(0.8 * y2)) - 0.625 * pi2];
+            };
+            function miller() {
+              return d3Geo.geoProjection(millerRaw).scale(108.318);
+            }
+            function modifiedStereographicRaw(C22) {
+              var m2 = C22.length - 1;
+              function forward(lambda, phi) {
+                var cosPhi = cos(phi), k22 = 2 / (1 + cosPhi * cos(lambda)), zr = k22 * cosPhi * sin(lambda), zi2 = k22 * sin(phi), i2 = m2, w22 = C22[i2], ar = w22[0], ai2 = w22[1], t4;
+                while (--i2 >= 0) {
+                  w22 = C22[i2];
+                  ar = w22[0] + zr * (t4 = ar) - zi2 * ai2;
+                  ai2 = w22[1] + zr * ai2 + zi2 * t4;
+                }
+                ar = zr * (t4 = ar) - zi2 * ai2;
+                ai2 = zr * ai2 + zi2 * t4;
+                return [ar, ai2];
+              }
+              forward.invert = function(x2, y2) {
+                var i2 = 20, zr = x2, zi2 = y2;
+                do {
+                  var j2 = m2, w22 = C22[j2], ar = w22[0], ai2 = w22[1], br = 0, bi2 = 0, t4;
+                  while (--j2 >= 0) {
+                    w22 = C22[j2];
+                    br = ar + zr * (t4 = br) - zi2 * bi2;
+                    bi2 = ai2 + zr * bi2 + zi2 * t4;
+                    ar = w22[0] + zr * (t4 = ar) - zi2 * ai2;
+                    ai2 = w22[1] + zr * ai2 + zi2 * t4;
+                  }
+                  br = ar + zr * (t4 = br) - zi2 * bi2;
+                  bi2 = ai2 + zr * bi2 + zi2 * t4;
+                  ar = zr * (t4 = ar) - zi2 * ai2 - x2;
+                  ai2 = zr * ai2 + zi2 * t4 - y2;
+                  var denominator = br * br + bi2 * bi2, deltar, deltai;
+                  zr -= deltar = (ar * br + ai2 * bi2) / denominator;
+                  zi2 -= deltai = (ai2 * br - ar * bi2) / denominator;
+                } while (abs(deltar) + abs(deltai) > epsilon * epsilon && --i2 > 0);
+                if (i2) {
+                  var rho = sqrt(zr * zr + zi2 * zi2), c2 = 2 * atan(rho * 0.5), sinc = sin(c2);
+                  return [atan2(zr * sinc, rho * cos(c2)), rho ? asin(zi2 * sinc / rho) : 0];
+                }
+              };
+              return forward;
+            }
+            var alaska = [[0.9972523, 0], [52513e-7, -41175e-7], [74606e-7, 48125e-7], [-0.0153783, -0.1968253], [0.0636871, -0.1408027], [0.3660976, -0.2937382]], gs48 = [[0.98879, 0], [0, 0], [-0.050909, 0], [0, 0], [0.075528, 0]], gs50 = [[0.984299, 0], [0.0211642, 37608e-7], [-0.1036018, -0.0575102], [-0.0329095, -0.0320119], [0.0499471, 0.1223335], [0.026046, 0.0899805], [7388e-7, -0.1435792], [75848e-7, -0.1334108], [-0.0216473, 0.0776645], [-0.0225161, 0.0853673]], miller$1 = [[0.9245, 0], [0, 0], [0.01943, 0]], lee = [[0.721316, 0], [0, 0], [-881625e-8, -617325e-8]];
+            function modifiedStereographicAlaska() {
+              return modifiedStereographic(alaska, [152, -64]).scale(1400).center([-160.908, 62.4864]).clipAngle(30).angle(7.8);
+            }
+            function modifiedStereographicGs48() {
+              return modifiedStereographic(gs48, [95, -38]).scale(1e3).clipAngle(55).center([-96.5563, 38.8675]);
+            }
+            function modifiedStereographicGs50() {
+              return modifiedStereographic(gs50, [120, -45]).scale(359.513).clipAngle(55).center([-117.474, 53.0628]);
+            }
+            function modifiedStereographicMiller() {
+              return modifiedStereographic(miller$1, [-20, -18]).scale(209.091).center([20, 16.7214]).clipAngle(82);
+            }
+            function modifiedStereographicLee() {
+              return modifiedStereographic(lee, [165, 10]).scale(250).clipAngle(130).center([-165, -10]);
+            }
+            function modifiedStereographic(coefficients, rotate2) {
+              var p2 = d3Geo.geoProjection(modifiedStereographicRaw(coefficients)).rotate(rotate2).clipAngle(90), r2 = d3Geo.geoRotation(rotate2), center = p2.center;
+              delete p2.rotate;
+              p2.center = function(_2) {
+                return arguments.length ? center(r2(_2)) : r2.invert(center());
+              };
+              return p2;
+            }
+            var sqrt6 = sqrt(6), sqrt7 = sqrt(7);
+            function mtFlatPolarParabolicRaw(lambda, phi) {
+              var theta = asin(7 * sin(phi) / (3 * sqrt6));
+              return [
+                sqrt6 * lambda * (2 * cos(2 * theta / 3) - 1) / sqrt7,
+                9 * sin(theta / 3) / sqrt7
+              ];
+            }
+            mtFlatPolarParabolicRaw.invert = function(x2, y2) {
+              var theta = 3 * asin(y2 * sqrt7 / 9);
+              return [
+                x2 * sqrt7 / (sqrt6 * (2 * cos(2 * theta / 3) - 1)),
+                asin(sin(theta) * 3 * sqrt6 / 7)
+              ];
+            };
+            function mtFlatPolarParabolic() {
+              return d3Geo.geoProjection(mtFlatPolarParabolicRaw).scale(164.859);
+            }
+            function mtFlatPolarQuarticRaw(lambda, phi) {
+              var k22 = (1 + sqrt1_2) * sin(phi), theta = phi;
+              for (var i2 = 0, delta; i2 < 25; i2++) {
+                theta -= delta = (sin(theta / 2) + sin(theta) - k22) / (0.5 * cos(theta / 2) + cos(theta));
+                if (abs(delta) < epsilon) break;
+              }
+              return [
+                lambda * (1 + 2 * cos(theta) / cos(theta / 2)) / (3 * sqrt2),
+                2 * sqrt(3) * sin(theta / 2) / sqrt(2 + sqrt2)
+              ];
+            }
+            mtFlatPolarQuarticRaw.invert = function(x2, y2) {
+              var sinTheta_2 = y2 * sqrt(2 + sqrt2) / (2 * sqrt(3)), theta = 2 * asin(sinTheta_2);
+              return [
+                3 * sqrt2 * x2 / (1 + 2 * cos(theta) / cos(theta / 2)),
+                asin((sinTheta_2 + sin(theta)) / (1 + sqrt1_2))
+              ];
+            };
+            function mtFlatPolarQuartic() {
+              return d3Geo.geoProjection(mtFlatPolarQuarticRaw).scale(188.209);
+            }
+            function mtFlatPolarSinusoidalRaw(lambda, phi) {
+              var A3 = sqrt(6 / (4 + pi2)), k22 = (1 + pi2 / 4) * sin(phi), theta = phi / 2;
+              for (var i2 = 0, delta; i2 < 25; i2++) {
+                theta -= delta = (theta / 2 + sin(theta) - k22) / (0.5 + cos(theta));
+                if (abs(delta) < epsilon) break;
+              }
+              return [
+                A3 * (0.5 + cos(theta)) * lambda / 1.5,
+                A3 * theta
+              ];
+            }
+            mtFlatPolarSinusoidalRaw.invert = function(x2, y2) {
+              var A3 = sqrt(6 / (4 + pi2)), theta = y2 / A3;
+              if (abs(abs(theta) - halfPi) < epsilon) theta = theta < 0 ? -halfPi : halfPi;
+              return [
+                1.5 * x2 / (A3 * (0.5 + cos(theta))),
+                asin((theta / 2 + sin(theta)) / (1 + pi2 / 4))
+              ];
+            };
+            function mtFlatPolarSinusoidal() {
+              return d3Geo.geoProjection(mtFlatPolarSinusoidalRaw).scale(166.518);
+            }
+            function naturalEarth2Raw(lambda, phi) {
+              var phi2 = phi * phi, phi4 = phi2 * phi2, phi6 = phi2 * phi4;
+              return [
+                lambda * (0.84719 - 0.13063 * phi2 + phi6 * phi6 * (-0.04515 + 0.05494 * phi2 - 0.02326 * phi4 + 331e-5 * phi6)),
+                phi * (1.01183 + phi4 * phi4 * (-0.02625 + 0.01926 * phi2 - 396e-5 * phi4))
+              ];
+            }
+            naturalEarth2Raw.invert = function(x2, y2) {
+              var phi = y2, i2 = 25, delta, phi2, phi4, phi6;
+              do {
+                phi2 = phi * phi;
+                phi4 = phi2 * phi2;
+                phi -= delta = (phi * (1.01183 + phi4 * phi4 * (-0.02625 + 0.01926 * phi2 - 396e-5 * phi4)) - y2) / (1.01183 + phi4 * phi4 * (9 * -0.02625 + 11 * 0.01926 * phi2 + 13 * -396e-5 * phi4));
+              } while (abs(delta) > epsilon22 && --i2 > 0);
+              phi2 = phi * phi;
+              phi4 = phi2 * phi2;
+              phi6 = phi2 * phi4;
+              return [
+                x2 / (0.84719 - 0.13063 * phi2 + phi6 * phi6 * (-0.04515 + 0.05494 * phi2 - 0.02326 * phi4 + 331e-5 * phi6)),
+                phi
+              ];
+            };
+            function naturalEarth2() {
+              return d3Geo.geoProjection(naturalEarth2Raw).scale(175.295);
+            }
+            function nellHammerRaw(lambda, phi) {
+              return [
+                lambda * (1 + cos(phi)) / 2,
+                2 * (phi - tan(phi / 2))
+              ];
+            }
+            nellHammerRaw.invert = function(x2, y2) {
+              var p2 = y2 / 2;
+              for (var i2 = 0, delta = Infinity; i2 < 10 && abs(delta) > epsilon; ++i2) {
+                var c2 = cos(y2 / 2);
+                y2 -= delta = (y2 - tan(y2 / 2) - p2) / (1 - 0.5 / (c2 * c2));
+              }
+              return [
+                2 * x2 / (1 + cos(y2)),
+                y2
+              ];
+            };
+            function nellHammer() {
+              return d3Geo.geoProjection(nellHammerRaw).scale(152.63);
             }
-          ) }),
-          /* @__PURE__ */ jsxRuntimeExports.jsx(
-            "img",
-            {
-              id: "colormap-img",
-              src: `/colorbar/${state.colormap}`,
-              style: { maxWidth: "100%", height: "auto" },
-              alt: "Colormap"
+            var lobes$6 = [[
+              // northern hemisphere
+              [[-180, 0], [-90, 90], [0, 0]],
+              [[0, 0], [90, 90], [180, 0]]
+            ], [
+              // southern hemisphere
+              [[-180, 0], [-90, -90], [0, 0]],
+              [[0, 0], [90, -90], [180, 0]]
+            ]];
+            function quarticAuthalic() {
+              return interrupt(hammerRaw(Infinity), lobes$6).rotate([20, 0]).scale(152.63);
             }
-          )
-        ] }),
-        /* @__PURE__ */ jsxRuntimeExports.jsxs("div", { id: "minmax-data", children: [
-          /* @__PURE__ */ jsxRuntimeExports.jsx("div", { children: "Rescale color limits" }),
-          /* @__PURE__ */ jsxRuntimeExports.jsx("div", { children: /* @__PURE__ */ jsxRuntimeExports.jsx(
-            "input",
-            {
-              className: "input",
-              type: "text",
-              inputMode: "decimal",
-              value: draftVmin,
-              onChange: (e) => setDraftVmin(e.target.value),
-              onBlur: commitVmin,
-              onKeyDown: (e) => e.key === "Enter" && commitVmin()
+            function nicolosiRaw(lambda, phi) {
+              var sinPhi = sin(phi), q2 = cos(phi), s2 = sign(lambda);
+              if (lambda === 0 || abs(phi) === halfPi) return [0, phi];
+              else if (phi === 0) return [lambda, 0];
+              else if (abs(lambda) === halfPi) return [lambda * q2, halfPi * sinPhi];
+              var b2 = pi2 / (2 * lambda) - 2 * lambda / pi2, c2 = 2 * phi / pi2, d2 = (1 - c2 * c2) / (sinPhi - c2);
+              var b22 = b2 * b2, d22 = d2 * d2, b2d2 = 1 + b22 / d22, d2b2 = 1 + d22 / b22;
+              var M2 = (b2 * sinPhi / d2 - b2 / 2) / b2d2, N2 = (d22 * sinPhi / b22 + d2 / 2) / d2b2, m2 = M2 * M2 + q2 * q2 / b2d2, n2 = N2 * N2 - (d22 * sinPhi * sinPhi / b22 + d2 * sinPhi - 1) / d2b2;
+              return [
+                halfPi * (M2 + sqrt(m2) * s2),
+                halfPi * (N2 + sqrt(n2 < 0 ? 0 : n2) * sign(-phi * b2) * s2)
+              ];
             }
-          ) }),
-          /* @__PURE__ */ jsxRuntimeExports.jsx("div", { children: /* @__PURE__ */ jsxRuntimeExports.jsx(
-            "input",
-            {
-              className: "input",
-              type: "text",
-              inputMode: "decimal",
-              value: draftVmax,
-              onChange: (e) => setDraftVmax(e.target.value),
-              onBlur: commitVmax,
-              onKeyDown: (e) => e.key === "Enter" && commitVmax()
+            nicolosiRaw.invert = function(x2, y2) {
+              x2 /= halfPi;
+              y2 /= halfPi;
+              var x22 = x2 * x2, y22 = y2 * y2, x2y2 = x22 + y22, pi22 = pi2 * pi2;
+              return [
+                x2 ? (x2y2 - 1 + sqrt((1 - x2y2) * (1 - x2y2) + 4 * x22)) / (2 * x2) * halfPi : 0,
+                solve(function(phi) {
+                  return x2y2 * (pi2 * sin(phi) - 2 * phi) * pi2 + 4 * phi * phi * (y2 - sin(phi)) + 2 * pi2 * phi - pi22 * y2;
+                }, 0)
+              ];
+            };
+            function nicolosi() {
+              return d3Geo.geoProjection(nicolosiRaw).scale(127.267);
             }
-          ) })
-        ] })
-      ] }),
-      /* @__PURE__ */ jsxRuntimeExports.jsx("div", { className: "menu-group pure-form", children: /* @__PURE__ */ jsxRuntimeExports.jsxs("div", { id: "opacity-slider-container", children: [
-        /* @__PURE__ */ jsxRuntimeExports.jsx("div", { children: /* @__PURE__ */ jsxRuntimeExports.jsxs("label", { htmlFor: "opacity-slider", children: [
-          "Opacity: ",
-          /* @__PURE__ */ jsxRuntimeExports.jsx("span", { id: "opacity-slider-value", children: state.opacity })
-        ] }) }),
-        /* @__PURE__ */ jsxRuntimeExports.jsx(
-          "input",
-          {
-            id: "opacity-slider",
-            className: "input",
-            type: "range",
-            min: "0",
-            max: "1",
-            step: "0.01",
-            value: state.opacity,
-            onChange: (e) => handleOpacityChange(parseFloat(e.target.value))
-          }
-        )
-      ] }) }),
-      /* @__PURE__ */ jsxRuntimeExports.jsxs("div", { className: "select-container", children: [
-        "Basemap:",
-        /* @__PURE__ */ jsxRuntimeExports.jsx(
-          "select",
-          {
-            value: state.selectedBasemap,
-            onChange: (e) => handleBasemapChange(e.target.value),
-            children: Object.entries(baseMaps).map(([key]) => /* @__PURE__ */ jsxRuntimeExports.jsx("option", { value: key, children: key }, key))
-          }
-        )
-      ] })
-    ] }),
-    /* @__PURE__ */ jsxRuntimeExports.jsx("div", { className: "menu-group", children: /* @__PURE__ */ jsxRuntimeExports.jsx("div", { id: "menu-chart", children: /* @__PURE__ */ jsxRuntimeExports.jsx(
-      "button",
-      {
-        className: "pure-button pure-button-primary",
-        onClick: toggleChart,
-        children: state.showChart ? "Hide time series" : "Show time series"
-      }
-    ) }) })
-  ] });
-}
-/*!
- * @kurkle/color v0.3.4
- * https://github.com/kurkle/color#readme
- * (c) 2024 Jukka Kurkela
- * Released under the MIT License
- */
-function round(v2) {
-  return v2 + 0.5 | 0;
-}
-const lim = (v2, l2, h) => Math.max(Math.min(v2, h), l2);
-function p2b(v2) {
-  return lim(round(v2 * 2.55), 0, 255);
-}
-function n2b(v2) {
-  return lim(round(v2 * 255), 0, 255);
-}
-function b2n(v2) {
-  return lim(round(v2 / 2.55) / 100, 0, 1);
-}
-function n2p(v2) {
-  return lim(round(v2 * 100), 0, 100);
-}
-const map$1 = { 0: 0, 1: 1, 2: 2, 3: 3, 4: 4, 5: 5, 6: 6, 7: 7, 8: 8, 9: 9, A: 10, B: 11, C: 12, D: 13, E: 14, F: 15, a: 10, b: 11, c: 12, d: 13, e: 14, f: 15 };
-const hex = [..."0123456789ABCDEF"];
-const h1 = (b) => hex[b & 15];
-const h2 = (b) => hex[(b & 240) >> 4] + hex[b & 15];
-const eq = (b) => (b & 240) >> 4 === (b & 15);
-const isShort = (v2) => eq(v2.r) && eq(v2.g) && eq(v2.b) && eq(v2.a);
-function hexParse(str) {
-  var len = str.length;
-  var ret;
-  if (str[0] === "#") {
-    if (len === 4 || len === 5) {
-      ret = {
-        r: 255 & map$1[str[1]] * 17,
-        g: 255 & map$1[str[2]] * 17,
-        b: 255 & map$1[str[3]] * 17,
-        a: len === 5 ? map$1[str[4]] * 17 : 255
-      };
-    } else if (len === 7 || len === 9) {
-      ret = {
-        r: map$1[str[1]] << 4 | map$1[str[2]],
-        g: map$1[str[3]] << 4 | map$1[str[4]],
-        b: map$1[str[5]] << 4 | map$1[str[6]],
-        a: len === 9 ? map$1[str[7]] << 4 | map$1[str[8]] : 255
-      };
-    }
-  }
-  return ret;
-}
-const alpha = (a, f2) => a < 255 ? f2(a) : "";
-function hexString(v2) {
-  var f2 = isShort(v2) ? h1 : h2;
-  return v2 ? "#" + f2(v2.r) + f2(v2.g) + f2(v2.b) + alpha(v2.a, f2) : void 0;
-}
-const HUE_RE = /^(hsla?|hwb|hsv)\(\s*([-+.e\d]+)(?:deg)?[\s,]+([-+.e\d]+)%[\s,]+([-+.e\d]+)%(?:[\s,]+([-+.e\d]+)(%)?)?\s*\)$/;
-function hsl2rgbn(h, s, l2) {
-  const a = s * Math.min(l2, 1 - l2);
-  const f2 = (n2, k2 = (n2 + h / 30) % 12) => l2 - a * Math.max(Math.min(k2 - 3, 9 - k2, 1), -1);
-  return [f2(0), f2(8), f2(4)];
-}
-function hsv2rgbn(h, s, v2) {
-  const f2 = (n2, k2 = (n2 + h / 60) % 6) => v2 - v2 * s * Math.max(Math.min(k2, 4 - k2, 1), 0);
-  return [f2(5), f2(3), f2(1)];
-}
-function hwb2rgbn(h, w2, b) {
-  const rgb = hsl2rgbn(h, 1, 0.5);
-  let i;
-  if (w2 + b > 1) {
-    i = 1 / (w2 + b);
-    w2 *= i;
-    b *= i;
-  }
-  for (i = 0; i < 3; i++) {
-    rgb[i] *= 1 - w2 - b;
-    rgb[i] += w2;
-  }
-  return rgb;
-}
-function hueValue(r2, g, b, d, max) {
-  if (r2 === max) {
-    return (g - b) / d + (g < b ? 6 : 0);
-  }
-  if (g === max) {
-    return (b - r2) / d + 2;
-  }
-  return (r2 - g) / d + 4;
-}
-function rgb2hsl(v2) {
-  const range = 255;
-  const r2 = v2.r / range;
-  const g = v2.g / range;
-  const b = v2.b / range;
-  const max = Math.max(r2, g, b);
-  const min = Math.min(r2, g, b);
-  const l2 = (max + min) / 2;
-  let h, s, d;
-  if (max !== min) {
-    d = max - min;
-    s = l2 > 0.5 ? d / (2 - max - min) : d / (max + min);
-    h = hueValue(r2, g, b, d, max);
-    h = h * 60 + 0.5;
-  }
-  return [h | 0, s || 0, l2];
-}
-function calln(f2, a, b, c) {
-  return (Array.isArray(a) ? f2(a[0], a[1], a[2]) : f2(a, b, c)).map(n2b);
-}
-function hsl2rgb(h, s, l2) {
-  return calln(hsl2rgbn, h, s, l2);
-}
-function hwb2rgb(h, w2, b) {
-  return calln(hwb2rgbn, h, w2, b);
-}
-function hsv2rgb(h, s, v2) {
-  return calln(hsv2rgbn, h, s, v2);
-}
-function hue(h) {
-  return (h % 360 + 360) % 360;
-}
-function hueParse(str) {
-  const m2 = HUE_RE.exec(str);
-  let a = 255;
-  let v2;
-  if (!m2) {
-    return;
-  }
-  if (m2[5] !== v2) {
-    a = m2[6] ? p2b(+m2[5]) : n2b(+m2[5]);
-  }
-  const h = hue(+m2[2]);
-  const p1 = +m2[3] / 100;
-  const p2 = +m2[4] / 100;
-  if (m2[1] === "hwb") {
-    v2 = hwb2rgb(h, p1, p2);
-  } else if (m2[1] === "hsv") {
-    v2 = hsv2rgb(h, p1, p2);
-  } else {
-    v2 = hsl2rgb(h, p1, p2);
-  }
-  return {
-    r: v2[0],
-    g: v2[1],
-    b: v2[2],
-    a
-  };
-}
-function rotate(v2, deg) {
-  var h = rgb2hsl(v2);
-  h[0] = hue(h[0] + deg);
-  h = hsl2rgb(h);
-  v2.r = h[0];
-  v2.g = h[1];
-  v2.b = h[2];
-}
-function hslString(v2) {
-  if (!v2) {
-    return;
-  }
-  const a = rgb2hsl(v2);
-  const h = a[0];
-  const s = n2p(a[1]);
-  const l2 = n2p(a[2]);
-  return v2.a < 255 ? `hsla(${h}, ${s}%, ${l2}%, ${b2n(v2.a)})` : `hsl(${h}, ${s}%, ${l2}%)`;
-}
-const map = {
-  x: "dark",
-  Z: "light",
-  Y: "re",
-  X: "blu",
-  W: "gr",
-  V: "medium",
-  U: "slate",
-  A: "ee",
-  T: "ol",
-  S: "or",
-  B: "ra",
-  C: "lateg",
-  D: "ights",
-  R: "in",
-  Q: "turquois",
-  E: "hi",
-  P: "ro",
-  O: "al",
-  N: "le",
-  M: "de",
-  L: "yello",
-  F: "en",
-  K: "ch",
-  G: "arks",
-  H: "ea",
-  I: "ightg",
-  J: "wh"
-};
-const names$1 = {
-  OiceXe: "f0f8ff",
-  antiquewEte: "faebd7",
-  aqua: "ffff",
-  aquamarRe: "7fffd4",
-  azuY: "f0ffff",
-  beige: "f5f5dc",
-  bisque: "ffe4c4",
-  black: "0",
-  blanKedOmond: "ffebcd",
-  Xe: "ff",
-  XeviTet: "8a2be2",
-  bPwn: "a52a2a",
-  burlywood: "deb887",
-  caMtXe: "5f9ea0",
-  KartYuse: "7fff00",
-  KocTate: "d2691e",
-  cSO: "ff7f50",
-  cSnflowerXe: "6495ed",
-  cSnsilk: "fff8dc",
-  crimson: "dc143c",
-  cyan: "ffff",
-  xXe: "8b",
-  xcyan: "8b8b",
-  xgTMnPd: "b8860b",
-  xWay: "a9a9a9",
-  xgYF: "6400",
-  xgYy: "a9a9a9",
-  xkhaki: "bdb76b",
-  xmagFta: "8b008b",
-  xTivegYF: "556b2f",
-  xSange: "ff8c00",
-  xScEd: "9932cc",
-  xYd: "8b0000",
-  xsOmon: "e9967a",
-  xsHgYF: "8fbc8f",
-  xUXe: "483d8b",
-  xUWay: "2f4f4f",
-  xUgYy: "2f4f4f",
-  xQe: "ced1",
-  xviTet: "9400d3",
-  dAppRk: "ff1493",
-  dApskyXe: "bfff",
-  dimWay: "696969",
-  dimgYy: "696969",
-  dodgerXe: "1e90ff",
-  fiYbrick: "b22222",
-  flSOwEte: "fffaf0",
-  foYstWAn: "228b22",
-  fuKsia: "ff00ff",
-  gaRsbSo: "dcdcdc",
-  ghostwEte: "f8f8ff",
-  gTd: "ffd700",
-  gTMnPd: "daa520",
-  Way: "808080",
-  gYF: "8000",
-  gYFLw: "adff2f",
-  gYy: "808080",
-  honeyMw: "f0fff0",
-  hotpRk: "ff69b4",
-  RdianYd: "cd5c5c",
-  Rdigo: "4b0082",
-  ivSy: "fffff0",
-  khaki: "f0e68c",
-  lavFMr: "e6e6fa",
-  lavFMrXsh: "fff0f5",
-  lawngYF: "7cfc00",
-  NmoncEffon: "fffacd",
-  ZXe: "add8e6",
-  ZcSO: "f08080",
-  Zcyan: "e0ffff",
-  ZgTMnPdLw: "fafad2",
-  ZWay: "d3d3d3",
-  ZgYF: "90ee90",
-  ZgYy: "d3d3d3",
-  ZpRk: "ffb6c1",
-  ZsOmon: "ffa07a",
-  ZsHgYF: "20b2aa",
-  ZskyXe: "87cefa",
-  ZUWay: "778899",
-  ZUgYy: "778899",
-  ZstAlXe: "b0c4de",
-  ZLw: "ffffe0",
-  lime: "ff00",
-  limegYF: "32cd32",
-  lRF: "faf0e6",
-  magFta: "ff00ff",
-  maPon: "800000",
-  VaquamarRe: "66cdaa",
-  VXe: "cd",
-  VScEd: "ba55d3",
-  VpurpN: "9370db",
-  VsHgYF: "3cb371",
-  VUXe: "7b68ee",
-  VsprRggYF: "fa9a",
-  VQe: "48d1cc",
-  VviTetYd: "c71585",
-  midnightXe: "191970",
-  mRtcYam: "f5fffa",
-  mistyPse: "ffe4e1",
-  moccasR: "ffe4b5",
-  navajowEte: "ffdead",
-  navy: "80",
-  Tdlace: "fdf5e6",
-  Tive: "808000",
-  TivedBb: "6b8e23",
-  Sange: "ffa500",
-  SangeYd: "ff4500",
-  ScEd: "da70d6",
-  pOegTMnPd: "eee8aa",
-  pOegYF: "98fb98",
-  pOeQe: "afeeee",
-  pOeviTetYd: "db7093",
-  papayawEp: "ffefd5",
-  pHKpuff: "ffdab9",
-  peru: "cd853f",
-  pRk: "ffc0cb",
-  plum: "dda0dd",
-  powMrXe: "b0e0e6",
-  purpN: "800080",
-  YbeccapurpN: "663399",
-  Yd: "ff0000",
-  Psybrown: "bc8f8f",
-  PyOXe: "4169e1",
-  saddNbPwn: "8b4513",
-  sOmon: "fa8072",
-  sandybPwn: "f4a460",
-  sHgYF: "2e8b57",
-  sHshell: "fff5ee",
-  siFna: "a0522d",
-  silver: "c0c0c0",
-  skyXe: "87ceeb",
-  UXe: "6a5acd",
-  UWay: "708090",
-  UgYy: "708090",
-  snow: "fffafa",
-  sprRggYF: "ff7f",
-  stAlXe: "4682b4",
-  tan: "d2b48c",
-  teO: "8080",
-  tEstN: "d8bfd8",
-  tomato: "ff6347",
-  Qe: "40e0d0",
-  viTet: "ee82ee",
-  JHt: "f5deb3",
-  wEte: "ffffff",
-  wEtesmoke: "f5f5f5",
-  Lw: "ffff00",
-  LwgYF: "9acd32"
-};
-function unpack() {
-  const unpacked = {};
-  const keys = Object.keys(names$1);
-  const tkeys = Object.keys(map);
-  let i, j, k2, ok2, nk2;
-  for (i = 0; i < keys.length; i++) {
-    ok2 = nk2 = keys[i];
-    for (j = 0; j < tkeys.length; j++) {
-      k2 = tkeys[j];
-      nk2 = nk2.replace(k2, map[k2]);
-    }
-    k2 = parseInt(names$1[ok2], 16);
-    unpacked[nk2] = [k2 >> 16 & 255, k2 >> 8 & 255, k2 & 255];
-  }
-  return unpacked;
-}
-let names;
-function nameParse(str) {
-  if (!names) {
-    names = unpack();
-    names.transparent = [0, 0, 0, 0];
-  }
-  const a = names[str.toLowerCase()];
-  return a && {
-    r: a[0],
-    g: a[1],
-    b: a[2],
-    a: a.length === 4 ? a[3] : 255
-  };
-}
-const RGB_RE = /^rgba?\(\s*([-+.\d]+)(%)?[\s,]+([-+.e\d]+)(%)?[\s,]+([-+.e\d]+)(%)?(?:[\s,/]+([-+.e\d]+)(%)?)?\s*\)$/;
-function rgbParse(str) {
-  const m2 = RGB_RE.exec(str);
-  let a = 255;
-  let r2, g, b;
-  if (!m2) {
-    return;
-  }
-  if (m2[7] !== r2) {
-    const v2 = +m2[7];
-    a = m2[8] ? p2b(v2) : lim(v2 * 255, 0, 255);
-  }
-  r2 = +m2[1];
-  g = +m2[3];
-  b = +m2[5];
-  r2 = 255 & (m2[2] ? p2b(r2) : lim(r2, 0, 255));
-  g = 255 & (m2[4] ? p2b(g) : lim(g, 0, 255));
-  b = 255 & (m2[6] ? p2b(b) : lim(b, 0, 255));
-  return {
-    r: r2,
-    g,
-    b,
-    a
-  };
-}
-function rgbString(v2) {
-  return v2 && (v2.a < 255 ? `rgba(${v2.r}, ${v2.g}, ${v2.b}, ${b2n(v2.a)})` : `rgb(${v2.r}, ${v2.g}, ${v2.b})`);
-}
-const to = (v2) => v2 <= 31308e-7 ? v2 * 12.92 : Math.pow(v2, 1 / 2.4) * 1.055 - 0.055;
-const from = (v2) => v2 <= 0.04045 ? v2 / 12.92 : Math.pow((v2 + 0.055) / 1.055, 2.4);
-function interpolate$1(rgb1, rgb2, t2) {
-  const r2 = from(b2n(rgb1.r));
-  const g = from(b2n(rgb1.g));
-  const b = from(b2n(rgb1.b));
-  return {
-    r: n2b(to(r2 + t2 * (from(b2n(rgb2.r)) - r2))),
-    g: n2b(to(g + t2 * (from(b2n(rgb2.g)) - g))),
-    b: n2b(to(b + t2 * (from(b2n(rgb2.b)) - b))),
-    a: rgb1.a + t2 * (rgb2.a - rgb1.a)
-  };
-}
-function modHSL(v2, i, ratio) {
-  if (v2) {
-    let tmp = rgb2hsl(v2);
-    tmp[i] = Math.max(0, Math.min(tmp[i] + tmp[i] * ratio, i === 0 ? 360 : 1));
-    tmp = hsl2rgb(tmp);
-    v2.r = tmp[0];
-    v2.g = tmp[1];
-    v2.b = tmp[2];
-  }
-}
-function clone$1(v2, proto) {
-  return v2 ? Object.assign(proto || {}, v2) : v2;
-}
-function fromObject(input) {
-  var v2 = { r: 0, g: 0, b: 0, a: 255 };
-  if (Array.isArray(input)) {
-    if (input.length >= 3) {
-      v2 = { r: input[0], g: input[1], b: input[2], a: 255 };
-      if (input.length > 3) {
-        v2.a = n2b(input[3]);
-      }
-    }
-  } else {
-    v2 = clone$1(input, { r: 0, g: 0, b: 0, a: 1 });
-    v2.a = n2b(v2.a);
-  }
-  return v2;
-}
-function functionParse(str) {
-  if (str.charAt(0) === "r") {
-    return rgbParse(str);
-  }
-  return hueParse(str);
-}
-class Color {
-  constructor(input) {
-    if (input instanceof Color) {
-      return input;
-    }
-    const type = typeof input;
-    let v2;
-    if (type === "object") {
-      v2 = fromObject(input);
-    } else if (type === "string") {
-      v2 = hexParse(input) || nameParse(input) || functionParse(input);
-    }
-    this._rgb = v2;
-    this._valid = !!v2;
-  }
-  get valid() {
-    return this._valid;
-  }
-  get rgb() {
-    var v2 = clone$1(this._rgb);
-    if (v2) {
-      v2.a = b2n(v2.a);
-    }
-    return v2;
-  }
-  set rgb(obj) {
-    this._rgb = fromObject(obj);
-  }
-  rgbString() {
-    return this._valid ? rgbString(this._rgb) : void 0;
-  }
-  hexString() {
-    return this._valid ? hexString(this._rgb) : void 0;
-  }
-  hslString() {
-    return this._valid ? hslString(this._rgb) : void 0;
-  }
-  mix(color2, weight) {
-    if (color2) {
-      const c1 = this.rgb;
-      const c2 = color2.rgb;
-      let w2;
-      const p2 = weight === w2 ? 0.5 : weight;
-      const w3 = 2 * p2 - 1;
-      const a = c1.a - c2.a;
-      const w1 = ((w3 * a === -1 ? w3 : (w3 + a) / (1 + w3 * a)) + 1) / 2;
-      w2 = 1 - w1;
-      c1.r = 255 & w1 * c1.r + w2 * c2.r + 0.5;
-      c1.g = 255 & w1 * c1.g + w2 * c2.g + 0.5;
-      c1.b = 255 & w1 * c1.b + w2 * c2.b + 0.5;
-      c1.a = p2 * c1.a + (1 - p2) * c2.a;
-      this.rgb = c1;
-    }
-    return this;
-  }
-  interpolate(color2, t2) {
-    if (color2) {
-      this._rgb = interpolate$1(this._rgb, color2._rgb, t2);
-    }
-    return this;
-  }
-  clone() {
-    return new Color(this.rgb);
-  }
-  alpha(a) {
-    this._rgb.a = n2b(a);
-    return this;
-  }
-  clearer(ratio) {
-    const rgb = this._rgb;
-    rgb.a *= 1 - ratio;
-    return this;
-  }
-  greyscale() {
-    const rgb = this._rgb;
-    const val = round(rgb.r * 0.3 + rgb.g * 0.59 + rgb.b * 0.11);
-    rgb.r = rgb.g = rgb.b = val;
-    return this;
-  }
-  opaquer(ratio) {
-    const rgb = this._rgb;
-    rgb.a *= 1 + ratio;
-    return this;
-  }
-  negate() {
-    const v2 = this._rgb;
-    v2.r = 255 - v2.r;
-    v2.g = 255 - v2.g;
-    v2.b = 255 - v2.b;
-    return this;
-  }
-  lighten(ratio) {
-    modHSL(this._rgb, 2, ratio);
-    return this;
-  }
-  darken(ratio) {
-    modHSL(this._rgb, 2, -ratio);
-    return this;
-  }
-  saturate(ratio) {
-    modHSL(this._rgb, 1, ratio);
-    return this;
-  }
-  desaturate(ratio) {
-    modHSL(this._rgb, 1, -ratio);
-    return this;
-  }
-  rotate(deg) {
-    rotate(this._rgb, deg);
-    return this;
-  }
-}
-/*!
- * Chart.js v4.4.9
- * https://www.chartjs.org
- * (c) 2025 Chart.js Contributors
- * Released under the MIT License
- */
-function noop() {
-}
-const uid = /* @__PURE__ */ (() => {
-  let id2 = 0;
-  return () => id2++;
-})();
-function isNullOrUndef(value) {
-  return value === null || value === void 0;
-}
-function isArray(value) {
-  if (Array.isArray && Array.isArray(value)) {
-    return true;
-  }
-  const type = Object.prototype.toString.call(value);
-  if (type.slice(0, 7) === "[object" && type.slice(-6) === "Array]") {
-    return true;
-  }
-  return false;
-}
-function isObject(value) {
-  return value !== null && Object.prototype.toString.call(value) === "[object Object]";
-}
-function isNumberFinite(value) {
-  return (typeof value === "number" || value instanceof Number) && isFinite(+value);
-}
-function finiteOrDefault(value, defaultValue) {
-  return isNumberFinite(value) ? value : defaultValue;
-}
-function valueOrDefault(value, defaultValue) {
-  return typeof value === "undefined" ? defaultValue : value;
-}
-const toDimension = (value, dimension) => typeof value === "string" && value.endsWith("%") ? parseFloat(value) / 100 * dimension : +value;
-function callback(fn, args, thisArg) {
-  if (fn && typeof fn.call === "function") {
-    return fn.apply(thisArg, args);
-  }
-}
-function each(loopable, fn, thisArg, reverse) {
-  let i, len, keys;
-  if (isArray(loopable)) {
-    len = loopable.length;
-    {
-      for (i = 0; i < len; i++) {
-        fn.call(thisArg, loopable[i], i);
-      }
-    }
-  } else if (isObject(loopable)) {
-    keys = Object.keys(loopable);
-    len = keys.length;
-    for (i = 0; i < len; i++) {
-      fn.call(thisArg, loopable[keys[i]], keys[i]);
-    }
-  }
-}
-function _elementsEqual(a0, a1) {
-  let i, ilen, v0, v1;
-  if (!a0 || !a1 || a0.length !== a1.length) {
-    return false;
-  }
-  for (i = 0, ilen = a0.length; i < ilen; ++i) {
-    v0 = a0[i];
-    v1 = a1[i];
-    if (v0.datasetIndex !== v1.datasetIndex || v0.index !== v1.index) {
-      return false;
-    }
-  }
-  return true;
-}
-function clone(source) {
-  if (isArray(source)) {
-    return source.map(clone);
-  }
-  if (isObject(source)) {
-    const target = /* @__PURE__ */ Object.create(null);
-    const keys = Object.keys(source);
-    const klen = keys.length;
-    let k2 = 0;
-    for (; k2 < klen; ++k2) {
-      target[keys[k2]] = clone(source[keys[k2]]);
-    }
-    return target;
-  }
-  return source;
-}
-function isValidKey(key) {
-  return [
-    "__proto__",
-    "prototype",
-    "constructor"
-  ].indexOf(key) === -1;
-}
-function _merger(key, target, source, options) {
-  if (!isValidKey(key)) {
-    return;
-  }
-  const tval = target[key];
-  const sval = source[key];
-  if (isObject(tval) && isObject(sval)) {
-    merge(tval, sval, options);
-  } else {
-    target[key] = clone(sval);
-  }
-}
-function merge(target, source, options) {
-  const sources = isArray(source) ? source : [
-    source
-  ];
-  const ilen = sources.length;
-  if (!isObject(target)) {
-    return target;
-  }
-  options = options || {};
-  const merger = options.merger || _merger;
-  let current;
-  for (let i = 0; i < ilen; ++i) {
-    current = sources[i];
-    if (!isObject(current)) {
-      continue;
-    }
-    const keys = Object.keys(current);
-    for (let k2 = 0, klen = keys.length; k2 < klen; ++k2) {
-      merger(keys[k2], target, current, options);
-    }
-  }
-  return target;
-}
-function mergeIf(target, source) {
-  return merge(target, source, {
-    merger: _mergerIf
-  });
-}
-function _mergerIf(key, target, source) {
-  if (!isValidKey(key)) {
-    return;
-  }
-  const tval = target[key];
-  const sval = source[key];
-  if (isObject(tval) && isObject(sval)) {
-    mergeIf(tval, sval);
-  } else if (!Object.prototype.hasOwnProperty.call(target, key)) {
-    target[key] = clone(sval);
-  }
-}
-const keyResolvers = {
-  // Chart.helpers.core resolveObjectKey should resolve empty key to root object
-  "": (v2) => v2,
-  // default resolvers
-  x: (o) => o.x,
-  y: (o) => o.y
-};
-function _splitKey(key) {
-  const parts = key.split(".");
-  const keys = [];
-  let tmp = "";
-  for (const part of parts) {
-    tmp += part;
-    if (tmp.endsWith("\\")) {
-      tmp = tmp.slice(0, -1) + ".";
-    } else {
-      keys.push(tmp);
-      tmp = "";
-    }
-  }
-  return keys;
-}
-function _getKeyResolver(key) {
-  const keys = _splitKey(key);
-  return (obj) => {
-    for (const k2 of keys) {
-      if (k2 === "") {
-        break;
-      }
-      obj = obj && obj[k2];
-    }
-    return obj;
-  };
-}
-function resolveObjectKey(obj, key) {
-  const resolver = keyResolvers[key] || (keyResolvers[key] = _getKeyResolver(key));
-  return resolver(obj);
-}
-function _capitalize(str) {
-  return str.charAt(0).toUpperCase() + str.slice(1);
-}
-const defined = (value) => typeof value !== "undefined";
-const isFunction = (value) => typeof value === "function";
-const setsEqual = (a, b) => {
-  if (a.size !== b.size) {
-    return false;
-  }
-  for (const item of a) {
-    if (!b.has(item)) {
-      return false;
-    }
-  }
-  return true;
-};
-function _isClickEvent(e) {
-  return e.type === "mouseup" || e.type === "click" || e.type === "contextmenu";
-}
-const PI = Math.PI;
-const TAU = 2 * PI;
-const PITAU = TAU + PI;
-const INFINITY = Number.POSITIVE_INFINITY;
-const RAD_PER_DEG = PI / 180;
-const HALF_PI = PI / 2;
-const QUARTER_PI = PI / 4;
-const TWO_THIRDS_PI = PI * 2 / 3;
-const log10 = Math.log10;
-const sign = Math.sign;
-function almostEquals(x2, y2, epsilon) {
-  return Math.abs(x2 - y2) < epsilon;
-}
-function niceNum(range) {
-  const roundedRange = Math.round(range);
-  range = almostEquals(range, roundedRange, range / 1e3) ? roundedRange : range;
-  const niceRange = Math.pow(10, Math.floor(log10(range)));
-  const fraction = range / niceRange;
-  const niceFraction = fraction <= 1 ? 1 : fraction <= 2 ? 2 : fraction <= 5 ? 5 : 10;
-  return niceFraction * niceRange;
-}
-function _factorize(value) {
-  const result = [];
-  const sqrt = Math.sqrt(value);
-  let i;
-  for (i = 1; i < sqrt; i++) {
-    if (value % i === 0) {
-      result.push(i);
-      result.push(value / i);
-    }
-  }
-  if (sqrt === (sqrt | 0)) {
-    result.push(sqrt);
-  }
-  result.sort((a, b) => a - b).pop();
-  return result;
-}
-function isNonPrimitive(n2) {
-  return typeof n2 === "symbol" || typeof n2 === "object" && n2 !== null && !(Symbol.toPrimitive in n2 || "toString" in n2 || "valueOf" in n2);
-}
-function isNumber(n2) {
-  return !isNonPrimitive(n2) && !isNaN(parseFloat(n2)) && isFinite(n2);
-}
-function almostWhole(x2, epsilon) {
-  const rounded = Math.round(x2);
-  return rounded - epsilon <= x2 && rounded + epsilon >= x2;
-}
-function _setMinAndMaxByKey(array, target, property) {
-  let i, ilen, value;
-  for (i = 0, ilen = array.length; i < ilen; i++) {
-    value = array[i][property];
-    if (!isNaN(value)) {
-      target.min = Math.min(target.min, value);
-      target.max = Math.max(target.max, value);
-    }
-  }
-}
-function toRadians(degrees) {
-  return degrees * (PI / 180);
-}
-function toDegrees(radians) {
-  return radians * (180 / PI);
-}
-function _decimalPlaces(x2) {
-  if (!isNumberFinite(x2)) {
-    return;
-  }
-  let e = 1;
-  let p2 = 0;
-  while (Math.round(x2 * e) / e !== x2) {
-    e *= 10;
-    p2++;
-  }
-  return p2;
-}
-function getAngleFromPoint(centrePoint, anglePoint) {
-  const distanceFromXCenter = anglePoint.x - centrePoint.x;
-  const distanceFromYCenter = anglePoint.y - centrePoint.y;
-  const radialDistanceFromCenter = Math.sqrt(distanceFromXCenter * distanceFromXCenter + distanceFromYCenter * distanceFromYCenter);
-  let angle = Math.atan2(distanceFromYCenter, distanceFromXCenter);
-  if (angle < -0.5 * PI) {
-    angle += TAU;
-  }
-  return {
-    angle,
-    distance: radialDistanceFromCenter
-  };
-}
-function distanceBetweenPoints(pt1, pt2) {
-  return Math.sqrt(Math.pow(pt2.x - pt1.x, 2) + Math.pow(pt2.y - pt1.y, 2));
-}
-function _angleDiff(a, b) {
-  return (a - b + PITAU) % TAU - PI;
-}
-function _normalizeAngle(a) {
-  return (a % TAU + TAU) % TAU;
-}
-function _angleBetween(angle, start, end, sameAngleIsFullCircle) {
-  const a = _normalizeAngle(angle);
-  const s = _normalizeAngle(start);
-  const e = _normalizeAngle(end);
-  const angleToStart = _normalizeAngle(s - a);
-  const angleToEnd = _normalizeAngle(e - a);
-  const startToAngle = _normalizeAngle(a - s);
-  const endToAngle = _normalizeAngle(a - e);
-  return a === s || a === e || sameAngleIsFullCircle && s === e || angleToStart > angleToEnd && startToAngle < endToAngle;
-}
-function _limitValue(value, min, max) {
-  return Math.max(min, Math.min(max, value));
-}
-function _int16Range(value) {
-  return _limitValue(value, -32768, 32767);
-}
-function _isBetween(value, start, end, epsilon = 1e-6) {
-  return value >= Math.min(start, end) - epsilon && value <= Math.max(start, end) + epsilon;
-}
-function _lookup(table, value, cmp) {
-  cmp = cmp || ((index) => table[index] < value);
-  let hi2 = table.length - 1;
-  let lo = 0;
-  let mid;
-  while (hi2 - lo > 1) {
-    mid = lo + hi2 >> 1;
-    if (cmp(mid)) {
-      lo = mid;
-    } else {
-      hi2 = mid;
-    }
-  }
-  return {
-    lo,
-    hi: hi2
-  };
-}
-const _lookupByKey = (table, key, value, last) => _lookup(table, value, last ? (index) => {
-  const ti2 = table[index][key];
-  return ti2 < value || ti2 === value && table[index + 1][key] === value;
-} : (index) => table[index][key] < value);
-const _rlookupByKey = (table, key, value) => _lookup(table, value, (index) => table[index][key] >= value);
-function _filterBetween(values, min, max) {
-  let start = 0;
-  let end = values.length;
-  while (start < end && values[start] < min) {
-    start++;
-  }
-  while (end > start && values[end - 1] > max) {
-    end--;
-  }
-  return start > 0 || end < values.length ? values.slice(start, end) : values;
-}
-const arrayEvents = [
-  "push",
-  "pop",
-  "shift",
-  "splice",
-  "unshift"
-];
-function listenArrayEvents(array, listener) {
-  if (array._chartjs) {
-    array._chartjs.listeners.push(listener);
-    return;
-  }
-  Object.defineProperty(array, "_chartjs", {
-    configurable: true,
-    enumerable: false,
-    value: {
-      listeners: [
-        listener
-      ]
-    }
-  });
-  arrayEvents.forEach((key) => {
-    const method = "_onData" + _capitalize(key);
-    const base = array[key];
-    Object.defineProperty(array, key, {
-      configurable: true,
-      enumerable: false,
-      value(...args) {
-        const res = base.apply(this, args);
-        array._chartjs.listeners.forEach((object) => {
-          if (typeof object[method] === "function") {
-            object[method](...args);
-          }
-        });
-        return res;
-      }
-    });
-  });
-}
-function unlistenArrayEvents(array, listener) {
-  const stub = array._chartjs;
-  if (!stub) {
-    return;
-  }
-  const listeners = stub.listeners;
-  const index = listeners.indexOf(listener);
-  if (index !== -1) {
-    listeners.splice(index, 1);
-  }
-  if (listeners.length > 0) {
-    return;
-  }
-  arrayEvents.forEach((key) => {
-    delete array[key];
-  });
-  delete array._chartjs;
-}
-function _arrayUnique(items) {
-  const set2 = new Set(items);
-  if (set2.size === items.length) {
-    return items;
-  }
-  return Array.from(set2);
-}
-const requestAnimFrame = function() {
-  if (typeof window === "undefined") {
-    return function(callback2) {
-      return callback2();
-    };
-  }
-  return window.requestAnimationFrame;
-}();
-function throttled(fn, thisArg) {
-  let argsToUse = [];
-  let ticking = false;
-  return function(...args) {
-    argsToUse = args;
-    if (!ticking) {
-      ticking = true;
-      requestAnimFrame.call(window, () => {
-        ticking = false;
-        fn.apply(thisArg, argsToUse);
-      });
-    }
-  };
-}
-function debounce(fn, delay) {
-  let timeout;
-  return function(...args) {
-    if (delay) {
-      clearTimeout(timeout);
-      timeout = setTimeout(fn, delay, args);
-    } else {
-      fn.apply(this, args);
-    }
-    return delay;
-  };
-}
-const _toLeftRightCenter = (align) => align === "start" ? "left" : align === "end" ? "right" : "center";
-const _alignStartEnd = (align, start, end) => align === "start" ? start : align === "end" ? end : (start + end) / 2;
-const _textX = (align, left, right, rtl) => {
-  const check = rtl ? "left" : "right";
-  return align === check ? right : align === "center" ? (left + right) / 2 : left;
-};
-function _getStartAndCountOfVisiblePoints(meta, points, animationsDisabled) {
-  const pointCount = points.length;
-  let start = 0;
-  let count = pointCount;
-  if (meta._sorted) {
-    const { iScale, vScale, _parsed } = meta;
-    const spanGaps = meta.dataset ? meta.dataset.options ? meta.dataset.options.spanGaps : null : null;
-    const axis = iScale.axis;
-    const { min, max, minDefined, maxDefined } = iScale.getUserBounds();
-    if (minDefined) {
-      start = Math.min(
-        // @ts-expect-error Need to type _parsed
-        _lookupByKey(_parsed, axis, min).lo,
-        // @ts-expect-error Need to fix types on _lookupByKey
-        animationsDisabled ? pointCount : _lookupByKey(points, axis, iScale.getPixelForValue(min)).lo
-      );
-      if (spanGaps) {
-        const distanceToDefinedLo = _parsed.slice(0, start + 1).reverse().findIndex((point) => !isNullOrUndef(point[vScale.axis]));
-        start -= Math.max(0, distanceToDefinedLo);
-      }
-      start = _limitValue(start, 0, pointCount - 1);
-    }
-    if (maxDefined) {
-      let end = Math.max(
-        // @ts-expect-error Need to type _parsed
-        _lookupByKey(_parsed, iScale.axis, max, true).hi + 1,
-        // @ts-expect-error Need to fix types on _lookupByKey
-        animationsDisabled ? 0 : _lookupByKey(points, axis, iScale.getPixelForValue(max), true).hi + 1
-      );
-      if (spanGaps) {
-        const distanceToDefinedHi = _parsed.slice(end - 1).findIndex((point) => !isNullOrUndef(point[vScale.axis]));
-        end += Math.max(0, distanceToDefinedHi);
-      }
-      count = _limitValue(end, start, pointCount) - start;
-    } else {
-      count = pointCount - start;
-    }
-  }
-  return {
-    start,
-    count
-  };
-}
-function _scaleRangesChanged(meta) {
-  const { xScale, yScale, _scaleRanges } = meta;
-  const newRanges = {
-    xmin: xScale.min,
-    xmax: xScale.max,
-    ymin: yScale.min,
-    ymax: yScale.max
-  };
-  if (!_scaleRanges) {
-    meta._scaleRanges = newRanges;
-    return true;
-  }
-  const changed = _scaleRanges.xmin !== xScale.min || _scaleRanges.xmax !== xScale.max || _scaleRanges.ymin !== yScale.min || _scaleRanges.ymax !== yScale.max;
-  Object.assign(_scaleRanges, newRanges);
-  return changed;
-}
-const atEdge = (t2) => t2 === 0 || t2 === 1;
-const elasticIn = (t2, s, p2) => -(Math.pow(2, 10 * (t2 -= 1)) * Math.sin((t2 - s) * TAU / p2));
-const elasticOut = (t2, s, p2) => Math.pow(2, -10 * t2) * Math.sin((t2 - s) * TAU / p2) + 1;
-const effects = {
-  linear: (t2) => t2,
-  easeInQuad: (t2) => t2 * t2,
-  easeOutQuad: (t2) => -t2 * (t2 - 2),
-  easeInOutQuad: (t2) => (t2 /= 0.5) < 1 ? 0.5 * t2 * t2 : -0.5 * (--t2 * (t2 - 2) - 1),
-  easeInCubic: (t2) => t2 * t2 * t2,
-  easeOutCubic: (t2) => (t2 -= 1) * t2 * t2 + 1,
-  easeInOutCubic: (t2) => (t2 /= 0.5) < 1 ? 0.5 * t2 * t2 * t2 : 0.5 * ((t2 -= 2) * t2 * t2 + 2),
-  easeInQuart: (t2) => t2 * t2 * t2 * t2,
-  easeOutQuart: (t2) => -((t2 -= 1) * t2 * t2 * t2 - 1),
-  easeInOutQuart: (t2) => (t2 /= 0.5) < 1 ? 0.5 * t2 * t2 * t2 * t2 : -0.5 * ((t2 -= 2) * t2 * t2 * t2 - 2),
-  easeInQuint: (t2) => t2 * t2 * t2 * t2 * t2,
-  easeOutQuint: (t2) => (t2 -= 1) * t2 * t2 * t2 * t2 + 1,
-  easeInOutQuint: (t2) => (t2 /= 0.5) < 1 ? 0.5 * t2 * t2 * t2 * t2 * t2 : 0.5 * ((t2 -= 2) * t2 * t2 * t2 * t2 + 2),
-  easeInSine: (t2) => -Math.cos(t2 * HALF_PI) + 1,
-  easeOutSine: (t2) => Math.sin(t2 * HALF_PI),
-  easeInOutSine: (t2) => -0.5 * (Math.cos(PI * t2) - 1),
-  easeInExpo: (t2) => t2 === 0 ? 0 : Math.pow(2, 10 * (t2 - 1)),
-  easeOutExpo: (t2) => t2 === 1 ? 1 : -Math.pow(2, -10 * t2) + 1,
-  easeInOutExpo: (t2) => atEdge(t2) ? t2 : t2 < 0.5 ? 0.5 * Math.pow(2, 10 * (t2 * 2 - 1)) : 0.5 * (-Math.pow(2, -10 * (t2 * 2 - 1)) + 2),
-  easeInCirc: (t2) => t2 >= 1 ? t2 : -(Math.sqrt(1 - t2 * t2) - 1),
-  easeOutCirc: (t2) => Math.sqrt(1 - (t2 -= 1) * t2),
-  easeInOutCirc: (t2) => (t2 /= 0.5) < 1 ? -0.5 * (Math.sqrt(1 - t2 * t2) - 1) : 0.5 * (Math.sqrt(1 - (t2 -= 2) * t2) + 1),
-  easeInElastic: (t2) => atEdge(t2) ? t2 : elasticIn(t2, 0.075, 0.3),
-  easeOutElastic: (t2) => atEdge(t2) ? t2 : elasticOut(t2, 0.075, 0.3),
-  easeInOutElastic(t2) {
-    const s = 0.1125;
-    const p2 = 0.45;
-    return atEdge(t2) ? t2 : t2 < 0.5 ? 0.5 * elasticIn(t2 * 2, s, p2) : 0.5 + 0.5 * elasticOut(t2 * 2 - 1, s, p2);
-  },
-  easeInBack(t2) {
-    const s = 1.70158;
-    return t2 * t2 * ((s + 1) * t2 - s);
-  },
-  easeOutBack(t2) {
-    const s = 1.70158;
-    return (t2 -= 1) * t2 * ((s + 1) * t2 + s) + 1;
-  },
-  easeInOutBack(t2) {
-    let s = 1.70158;
-    if ((t2 /= 0.5) < 1) {
-      return 0.5 * (t2 * t2 * (((s *= 1.525) + 1) * t2 - s));
-    }
-    return 0.5 * ((t2 -= 2) * t2 * (((s *= 1.525) + 1) * t2 + s) + 2);
-  },
-  easeInBounce: (t2) => 1 - effects.easeOutBounce(1 - t2),
-  easeOutBounce(t2) {
-    const m2 = 7.5625;
-    const d = 2.75;
-    if (t2 < 1 / d) {
-      return m2 * t2 * t2;
-    }
-    if (t2 < 2 / d) {
-      return m2 * (t2 -= 1.5 / d) * t2 + 0.75;
-    }
-    if (t2 < 2.5 / d) {
-      return m2 * (t2 -= 2.25 / d) * t2 + 0.9375;
-    }
-    return m2 * (t2 -= 2.625 / d) * t2 + 0.984375;
-  },
-  easeInOutBounce: (t2) => t2 < 0.5 ? effects.easeInBounce(t2 * 2) * 0.5 : effects.easeOutBounce(t2 * 2 - 1) * 0.5 + 0.5
-};
-function isPatternOrGradient(value) {
-  if (value && typeof value === "object") {
-    const type = value.toString();
-    return type === "[object CanvasPattern]" || type === "[object CanvasGradient]";
-  }
-  return false;
-}
-function color(value) {
-  return isPatternOrGradient(value) ? value : new Color(value);
-}
-function getHoverColor(value) {
-  return isPatternOrGradient(value) ? value : new Color(value).saturate(0.5).darken(0.1).hexString();
-}
-const numbers = [
-  "x",
-  "y",
-  "borderWidth",
-  "radius",
-  "tension"
-];
-const colors = [
-  "color",
-  "borderColor",
-  "backgroundColor"
-];
-function applyAnimationsDefaults(defaults2) {
-  defaults2.set("animation", {
-    delay: void 0,
-    duration: 1e3,
-    easing: "easeOutQuart",
-    fn: void 0,
-    from: void 0,
-    loop: void 0,
-    to: void 0,
-    type: void 0
-  });
-  defaults2.describe("animation", {
-    _fallback: false,
-    _indexable: false,
-    _scriptable: (name) => name !== "onProgress" && name !== "onComplete" && name !== "fn"
-  });
-  defaults2.set("animations", {
-    colors: {
-      type: "color",
-      properties: colors
-    },
-    numbers: {
-      type: "number",
-      properties: numbers
-    }
-  });
-  defaults2.describe("animations", {
-    _fallback: "animation"
-  });
-  defaults2.set("transitions", {
-    active: {
-      animation: {
-        duration: 400
-      }
-    },
-    resize: {
-      animation: {
-        duration: 0
-      }
-    },
-    show: {
-      animations: {
-        colors: {
-          from: "transparent"
-        },
-        visible: {
-          type: "boolean",
-          duration: 0
-        }
-      }
-    },
-    hide: {
-      animations: {
-        colors: {
-          to: "transparent"
-        },
-        visible: {
-          type: "boolean",
-          easing: "linear",
-          fn: (v2) => v2 | 0
-        }
-      }
-    }
-  });
-}
-function applyLayoutsDefaults(defaults2) {
-  defaults2.set("layout", {
-    autoPadding: true,
-    padding: {
-      top: 0,
-      right: 0,
-      bottom: 0,
-      left: 0
-    }
-  });
-}
-const intlCache = /* @__PURE__ */ new Map();
-function getNumberFormat(locale, options) {
-  options = options || {};
-  const cacheKey = locale + JSON.stringify(options);
-  let formatter = intlCache.get(cacheKey);
-  if (!formatter) {
-    formatter = new Intl.NumberFormat(locale, options);
-    intlCache.set(cacheKey, formatter);
-  }
-  return formatter;
-}
-function formatNumber(num, locale, options) {
-  return getNumberFormat(locale, options).format(num);
-}
-const formatters$1 = {
-  values(value) {
-    return isArray(value) ? value : "" + value;
-  },
-  numeric(tickValue, index, ticks) {
-    if (tickValue === 0) {
-      return "0";
-    }
-    const locale = this.chart.options.locale;
-    let notation;
-    let delta = tickValue;
-    if (ticks.length > 1) {
-      const maxTick = Math.max(Math.abs(ticks[0].value), Math.abs(ticks[ticks.length - 1].value));
-      if (maxTick < 1e-4 || maxTick > 1e15) {
-        notation = "scientific";
-      }
-      delta = calculateDelta(tickValue, ticks);
-    }
-    const logDelta = log10(Math.abs(delta));
-    const numDecimal = isNaN(logDelta) ? 1 : Math.max(Math.min(-1 * Math.floor(logDelta), 20), 0);
-    const options = {
-      notation,
-      minimumFractionDigits: numDecimal,
-      maximumFractionDigits: numDecimal
-    };
-    Object.assign(options, this.options.ticks.format);
-    return formatNumber(tickValue, locale, options);
-  }
-};
-function calculateDelta(tickValue, ticks) {
-  let delta = ticks.length > 3 ? ticks[2].value - ticks[1].value : ticks[1].value - ticks[0].value;
-  if (Math.abs(delta) >= 1 && tickValue !== Math.floor(tickValue)) {
-    delta = tickValue - Math.floor(tickValue);
-  }
-  return delta;
-}
-var Ticks = {
-  formatters: formatters$1
-};
-function applyScaleDefaults(defaults2) {
-  defaults2.set("scale", {
-    display: true,
-    offset: false,
-    reverse: false,
-    beginAtZero: false,
-    bounds: "ticks",
-    clip: true,
-    grace: 0,
-    grid: {
-      display: true,
-      lineWidth: 1,
-      drawOnChartArea: true,
-      drawTicks: true,
-      tickLength: 8,
-      tickWidth: (_ctx, options) => options.lineWidth,
-      tickColor: (_ctx, options) => options.color,
-      offset: false
-    },
-    border: {
-      display: true,
-      dash: [],
-      dashOffset: 0,
-      width: 1
-    },
-    title: {
-      display: false,
-      text: "",
-      padding: {
-        top: 4,
-        bottom: 4
-      }
-    },
-    ticks: {
-      minRotation: 0,
-      maxRotation: 50,
-      mirror: false,
-      textStrokeWidth: 0,
-      textStrokeColor: "",
-      padding: 3,
-      display: true,
-      autoSkip: true,
-      autoSkipPadding: 3,
-      labelOffset: 0,
-      callback: Ticks.formatters.values,
-      minor: {},
-      major: {},
-      align: "center",
-      crossAlign: "near",
-      showLabelBackdrop: false,
-      backdropColor: "rgba(255, 255, 255, 0.75)",
-      backdropPadding: 2
-    }
-  });
-  defaults2.route("scale.ticks", "color", "", "color");
-  defaults2.route("scale.grid", "color", "", "borderColor");
-  defaults2.route("scale.border", "color", "", "borderColor");
-  defaults2.route("scale.title", "color", "", "color");
-  defaults2.describe("scale", {
-    _fallback: false,
-    _scriptable: (name) => !name.startsWith("before") && !name.startsWith("after") && name !== "callback" && name !== "parser",
-    _indexable: (name) => name !== "borderDash" && name !== "tickBorderDash" && name !== "dash"
-  });
-  defaults2.describe("scales", {
-    _fallback: "scale"
-  });
-  defaults2.describe("scale.ticks", {
-    _scriptable: (name) => name !== "backdropPadding" && name !== "callback",
-    _indexable: (name) => name !== "backdropPadding"
-  });
-}
-const overrides = /* @__PURE__ */ Object.create(null);
-const descriptors = /* @__PURE__ */ Object.create(null);
-function getScope$1(node, key) {
-  if (!key) {
-    return node;
-  }
-  const keys = key.split(".");
-  for (let i = 0, n2 = keys.length; i < n2; ++i) {
-    const k2 = keys[i];
-    node = node[k2] || (node[k2] = /* @__PURE__ */ Object.create(null));
-  }
-  return node;
-}
-function set(root, scope, values) {
-  if (typeof scope === "string") {
-    return merge(getScope$1(root, scope), values);
-  }
-  return merge(getScope$1(root, ""), scope);
-}
-class Defaults {
-  constructor(_descriptors2, _appliers) {
-    this.animation = void 0;
-    this.backgroundColor = "rgba(0,0,0,0.1)";
-    this.borderColor = "rgba(0,0,0,0.1)";
-    this.color = "#666";
-    this.datasets = {};
-    this.devicePixelRatio = (context) => context.chart.platform.getDevicePixelRatio();
-    this.elements = {};
-    this.events = [
-      "mousemove",
-      "mouseout",
-      "click",
-      "touchstart",
-      "touchmove"
-    ];
-    this.font = {
-      family: "'Helvetica Neue', 'Helvetica', 'Arial', sans-serif",
-      size: 12,
-      style: "normal",
-      lineHeight: 1.2,
-      weight: null
-    };
-    this.hover = {};
-    this.hoverBackgroundColor = (ctx, options) => getHoverColor(options.backgroundColor);
-    this.hoverBorderColor = (ctx, options) => getHoverColor(options.borderColor);
-    this.hoverColor = (ctx, options) => getHoverColor(options.color);
-    this.indexAxis = "x";
-    this.interaction = {
-      mode: "nearest",
-      intersect: true,
-      includeInvisible: false
-    };
-    this.maintainAspectRatio = true;
-    this.onHover = null;
-    this.onClick = null;
-    this.parsing = true;
-    this.plugins = {};
-    this.responsive = true;
-    this.scale = void 0;
-    this.scales = {};
-    this.showLine = true;
-    this.drawActiveElementsOnTop = true;
-    this.describe(_descriptors2);
-    this.apply(_appliers);
-  }
-  set(scope, values) {
-    return set(this, scope, values);
-  }
-  get(scope) {
-    return getScope$1(this, scope);
-  }
-  describe(scope, values) {
-    return set(descriptors, scope, values);
-  }
-  override(scope, values) {
-    return set(overrides, scope, values);
-  }
-  route(scope, name, targetScope, targetName) {
-    const scopeObject = getScope$1(this, scope);
-    const targetScopeObject = getScope$1(this, targetScope);
-    const privateName = "_" + name;
-    Object.defineProperties(scopeObject, {
-      [privateName]: {
-        value: scopeObject[name],
-        writable: true
-      },
-      [name]: {
-        enumerable: true,
-        get() {
-          const local = this[privateName];
-          const target = targetScopeObject[targetName];
-          if (isObject(local)) {
-            return Object.assign({}, target, local);
+            var pattersonK1 = 1.0148, pattersonK2 = 0.23185, pattersonK3 = -0.14499, pattersonK4 = 0.02406, pattersonC1 = pattersonK1, pattersonC2 = 5 * pattersonK2, pattersonC3 = 7 * pattersonK3, pattersonC4 = 9 * pattersonK4, pattersonYmax = 1.790857183;
+            function pattersonRaw(lambda, phi) {
+              var phi2 = phi * phi;
+              return [
+                lambda,
+                phi * (pattersonK1 + phi2 * phi2 * (pattersonK2 + phi2 * (pattersonK3 + pattersonK4 * phi2)))
+              ];
+            }
+            pattersonRaw.invert = function(x2, y2) {
+              if (y2 > pattersonYmax) y2 = pattersonYmax;
+              else if (y2 < -1.790857183) y2 = -1.790857183;
+              var yc2 = y2, delta;
+              do {
+                var y22 = yc2 * yc2;
+                yc2 -= delta = (yc2 * (pattersonK1 + y22 * y22 * (pattersonK2 + y22 * (pattersonK3 + pattersonK4 * y22))) - y2) / (pattersonC1 + y22 * y22 * (pattersonC2 + y22 * (pattersonC3 + pattersonC4 * y22)));
+              } while (abs(delta) > epsilon);
+              return [x2, yc2];
+            };
+            function patterson() {
+              return d3Geo.geoProjection(pattersonRaw).scale(139.319);
+            }
+            function polyconicRaw(lambda, phi) {
+              if (abs(phi) < epsilon) return [lambda, 0];
+              var tanPhi = tan(phi), k22 = lambda * sin(phi);
+              return [
+                sin(k22) / tanPhi,
+                phi + (1 - cos(k22)) / tanPhi
+              ];
+            }
+            polyconicRaw.invert = function(x2, y2) {
+              if (abs(y2) < epsilon) return [x2, 0];
+              var k22 = x2 * x2 + y2 * y2, phi = y2 * 0.5, i2 = 10, delta;
+              do {
+                var tanPhi = tan(phi), secPhi = 1 / cos(phi), j2 = k22 - 2 * y2 * phi + phi * phi;
+                phi -= delta = (tanPhi * j2 + 2 * (phi - y2)) / (2 + j2 * secPhi * secPhi + 2 * (phi - y2) * tanPhi);
+              } while (abs(delta) > epsilon && --i2 > 0);
+              tanPhi = tan(phi);
+              return [
+                (abs(y2) < abs(phi + 1 / tanPhi) ? asin(x2 * tanPhi) : sign(y2) * sign(x2) * (acos(abs(x2 * tanPhi)) + halfPi)) / sin(phi),
+                phi
+              ];
+            };
+            function polyconic() {
+              return d3Geo.geoProjection(polyconicRaw).scale(103.74);
+            }
+            function matrix(a2, b2) {
+              var u2 = subtract2(a2[1], a2[0]), v2 = subtract2(b2[1], b2[0]), phi = angle$1(u2, v2), s2 = length2(u2) / length2(v2);
+              return multiply2([
+                1,
+                0,
+                a2[0][0],
+                0,
+                1,
+                a2[0][1]
+              ], multiply2([
+                s2,
+                0,
+                0,
+                0,
+                s2,
+                0
+              ], multiply2([
+                cos(phi),
+                sin(phi),
+                0,
+                -sin(phi),
+                cos(phi),
+                0
+              ], [
+                1,
+                0,
+                -b2[0][0],
+                0,
+                1,
+                -b2[0][1]
+              ])));
+            }
+            function inverse(m2) {
+              var k22 = 1 / (m2[0] * m2[4] - m2[1] * m2[3]);
+              return [
+                k22 * m2[4],
+                -k22 * m2[1],
+                k22 * (m2[1] * m2[5] - m2[2] * m2[4]),
+                -k22 * m2[3],
+                k22 * m2[0],
+                k22 * (m2[2] * m2[3] - m2[0] * m2[5])
+              ];
+            }
+            function multiply2(a2, b2) {
+              return [
+                a2[0] * b2[0] + a2[1] * b2[3],
+                a2[0] * b2[1] + a2[1] * b2[4],
+                a2[0] * b2[2] + a2[1] * b2[5] + a2[2],
+                a2[3] * b2[0] + a2[4] * b2[3],
+                a2[3] * b2[1] + a2[4] * b2[4],
+                a2[3] * b2[2] + a2[4] * b2[5] + a2[5]
+              ];
+            }
+            function subtract2(a2, b2) {
+              return [a2[0] - b2[0], a2[1] - b2[1]];
+            }
+            function length2(v2) {
+              return sqrt(v2[0] * v2[0] + v2[1] * v2[1]);
+            }
+            function angle$1(a2, b2) {
+              return atan2(a2[0] * b2[1] - a2[1] * b2[0], a2[0] * b2[0] + a2[1] * b2[1]);
+            }
+            function polyhedral(root, face, r2) {
+              recurse(root, { transform: null });
+              function recurse(node, parent) {
+                node.edges = faceEdges(node.face);
+                if (parent.face) {
+                  var shared = node.shared = sharedEdge(node.face, parent.face), m2 = matrix(shared.map(parent.project), shared.map(node.project));
+                  node.transform = parent.transform ? multiply2(parent.transform, m2) : m2;
+                  var edges = parent.edges;
+                  for (var i2 = 0, n2 = edges.length; i2 < n2; ++i2) {
+                    if (pointEqual$1(shared[0], edges[i2][1]) && pointEqual$1(shared[1], edges[i2][0])) edges[i2] = node;
+                    if (pointEqual$1(shared[0], edges[i2][0]) && pointEqual$1(shared[1], edges[i2][1])) edges[i2] = node;
+                  }
+                  edges = node.edges;
+                  for (i2 = 0, n2 = edges.length; i2 < n2; ++i2) {
+                    if (pointEqual$1(shared[0], edges[i2][0]) && pointEqual$1(shared[1], edges[i2][1])) edges[i2] = parent;
+                    if (pointEqual$1(shared[0], edges[i2][1]) && pointEqual$1(shared[1], edges[i2][0])) edges[i2] = parent;
+                  }
+                } else {
+                  node.transform = parent.transform;
+                }
+                if (node.children) {
+                  node.children.forEach(function(child) {
+                    recurse(child, node);
+                  });
+                }
+                return node;
+              }
+              function forward(lambda, phi) {
+                var node = face(lambda, phi), point = node.project([lambda * degrees3, phi * degrees3]), t4;
+                if (t4 = node.transform) {
+                  return [
+                    t4[0] * point[0] + t4[1] * point[1] + t4[2],
+                    -(t4[3] * point[0] + t4[4] * point[1] + t4[5])
+                  ];
+                }
+                point[1] = -point[1];
+                return point;
+              }
+              if (hasInverse(root)) forward.invert = function(x2, y2) {
+                var coordinates = faceInvert(root, [x2, -y2]);
+                return coordinates && (coordinates[0] *= radians2, coordinates[1] *= radians2, coordinates);
+              };
+              function faceInvert(node, coordinates) {
+                var invert2 = node.project.invert, t4 = node.transform, point = coordinates;
+                if (t4) {
+                  t4 = inverse(t4);
+                  point = [
+                    t4[0] * point[0] + t4[1] * point[1] + t4[2],
+                    t4[3] * point[0] + t4[4] * point[1] + t4[5]
+                  ];
+                }
+                if (invert2 && node === faceDegrees(p2 = invert2(point))) return p2;
+                var p2, children = node.children;
+                for (var i2 = 0, n2 = children && children.length; i2 < n2; ++i2) {
+                  if (p2 = faceInvert(children[i2], coordinates)) return p2;
+                }
+              }
+              function faceDegrees(coordinates) {
+                return face(coordinates[0] * radians2, coordinates[1] * radians2);
+              }
+              var proj = d3Geo.geoProjection(forward), stream_ = proj.stream;
+              proj.stream = function(stream) {
+                var rotate2 = proj.rotate(), rotateStream = stream_(stream), sphereStream = (proj.rotate([0, 0]), stream_(stream));
+                proj.rotate(rotate2);
+                rotateStream.sphere = function() {
+                  sphereStream.polygonStart();
+                  sphereStream.lineStart();
+                  outline(sphereStream, root);
+                  sphereStream.lineEnd();
+                  sphereStream.polygonEnd();
+                };
+                return rotateStream;
+              };
+              return proj.angle(r2 == null ? -30 : r2 * degrees3);
+            }
+            function outline(stream, node, parent) {
+              var point, edges = node.edges, n2 = edges.length, edge, multiPoint = { type: "MultiPoint", coordinates: node.face }, notPoles = node.face.filter(function(d2) {
+                return abs(d2[1]) !== 90;
+              }), b2 = d3Geo.geoBounds({ type: "MultiPoint", coordinates: notPoles }), inside = false, j2 = -1, dx = b2[1][0] - b2[0][0];
+              var c2 = dx === 180 || dx === 360 ? [(b2[0][0] + b2[1][0]) / 2, (b2[0][1] + b2[1][1]) / 2] : d3Geo.geoCentroid(multiPoint);
+              if (parent) while (++j2 < n2) {
+                if (edges[j2] === parent) break;
+              }
+              ++j2;
+              for (var i2 = 0; i2 < n2; ++i2) {
+                edge = edges[(i2 + j2) % n2];
+                if (Array.isArray(edge)) {
+                  if (!inside) {
+                    stream.point((point = d3Geo.geoInterpolate(edge[0], c2)(epsilon))[0], point[1]);
+                    inside = true;
+                  }
+                  stream.point((point = d3Geo.geoInterpolate(edge[1], c2)(epsilon))[0], point[1]);
+                } else {
+                  inside = false;
+                  if (edge !== parent) outline(stream, edge, node);
+                }
+              }
+            }
+            function pointEqual$1(a2, b2) {
+              return a2 && b2 && a2[0] === b2[0] && a2[1] === b2[1];
+            }
+            function sharedEdge(a2, b2) {
+              var x2, y2, n2 = a2.length, found = null;
+              for (var i2 = 0; i2 < n2; ++i2) {
+                x2 = a2[i2];
+                for (var j2 = b2.length; --j2 >= 0; ) {
+                  y2 = b2[j2];
+                  if (x2[0] === y2[0] && x2[1] === y2[1]) {
+                    if (found) return [found, x2];
+                    found = x2;
+                  }
+                }
+              }
+            }
+            function faceEdges(face) {
+              var n2 = face.length, edges = [];
+              for (var a2 = face[n2 - 1], i2 = 0; i2 < n2; ++i2) edges.push([a2, a2 = face[i2]]);
+              return edges;
+            }
+            function hasInverse(node) {
+              return node.project.invert || node.children && node.children.some(hasInverse);
+            }
+            var octahedron = [
+              [0, 90],
+              [-90, 0],
+              [0, 0],
+              [90, 0],
+              [180, 0],
+              [0, -90]
+            ];
+            var octahedron$1 = [
+              [0, 2, 1],
+              [0, 3, 2],
+              [5, 1, 2],
+              [5, 2, 3],
+              [0, 1, 4],
+              [0, 4, 3],
+              [5, 4, 1],
+              [5, 3, 4]
+            ].map(function(face) {
+              return face.map(function(i2) {
+                return octahedron[i2];
+              });
+            });
+            function butterfly(faceProjection) {
+              faceProjection = faceProjection || function(face) {
+                var c2 = d3Geo.geoCentroid({ type: "MultiPoint", coordinates: face });
+                return d3Geo.geoGnomonic().scale(1).translate([0, 0]).rotate([-c2[0], -c2[1]]);
+              };
+              var faces = octahedron$1.map(function(face) {
+                return { face, project: faceProjection(face) };
+              });
+              [-1, 0, 0, 1, 0, 1, 4, 5].forEach(function(d2, i2) {
+                var node = faces[d2];
+                node && (node.children || (node.children = [])).push(faces[i2]);
+              });
+              return polyhedral(faces[0], function(lambda, phi) {
+                return faces[lambda < -pi2 / 2 ? phi < 0 ? 6 : 4 : lambda < 0 ? phi < 0 ? 2 : 0 : lambda < pi2 / 2 ? phi < 0 ? 3 : 1 : phi < 0 ? 7 : 5];
+              }).angle(-30).scale(101.858).center([0, 45]);
+            }
+            var kx = 2 / sqrt(3);
+            function collignonK(a2, b2) {
+              var p2 = collignonRaw(a2, b2);
+              return [p2[0] * kx, p2[1]];
+            }
+            collignonK.invert = function(x2, y2) {
+              return collignonRaw.invert(x2 / kx, y2);
+            };
+            function collignon$1(faceProjection) {
+              faceProjection = faceProjection || function(face) {
+                var c2 = d3Geo.geoCentroid({ type: "MultiPoint", coordinates: face });
+                return d3Geo.geoProjection(collignonK).translate([0, 0]).scale(1).rotate(c2[1] > 0 ? [-c2[0], 0] : [180 - c2[0], 180]);
+              };
+              var faces = octahedron$1.map(function(face) {
+                return { face, project: faceProjection(face) };
+              });
+              [-1, 0, 0, 1, 0, 1, 4, 5].forEach(function(d2, i2) {
+                var node = faces[d2];
+                node && (node.children || (node.children = [])).push(faces[i2]);
+              });
+              return polyhedral(faces[0], function(lambda, phi) {
+                return faces[lambda < -pi2 / 2 ? phi < 0 ? 6 : 4 : lambda < 0 ? phi < 0 ? 2 : 0 : lambda < pi2 / 2 ? phi < 0 ? 3 : 1 : phi < 0 ? 7 : 5];
+              }).angle(-30).scale(121.906).center([0, 48.5904]);
+            }
+            function waterman(faceProjection) {
+              faceProjection = faceProjection || function(face2) {
+                var c2 = face2.length === 6 ? d3Geo.geoCentroid({ type: "MultiPoint", coordinates: face2 }) : face2[0];
+                return d3Geo.geoGnomonic().scale(1).translate([0, 0]).rotate([-c2[0], -c2[1]]);
+              };
+              var w5 = octahedron$1.map(function(face2) {
+                var xyz = face2.map(cartesian), n2 = xyz.length, a2 = xyz[n2 - 1], b2, hexagon = [];
+                for (var i2 = 0; i2 < n2; ++i2) {
+                  b2 = xyz[i2];
+                  hexagon.push(spherical([
+                    a2[0] * 0.9486832980505138 + b2[0] * 0.31622776601683794,
+                    a2[1] * 0.9486832980505138 + b2[1] * 0.31622776601683794,
+                    a2[2] * 0.9486832980505138 + b2[2] * 0.31622776601683794
+                  ]), spherical([
+                    b2[0] * 0.9486832980505138 + a2[0] * 0.31622776601683794,
+                    b2[1] * 0.9486832980505138 + a2[1] * 0.31622776601683794,
+                    b2[2] * 0.9486832980505138 + a2[2] * 0.31622776601683794
+                  ]));
+                  a2 = b2;
+                }
+                return hexagon;
+              });
+              var cornerNormals = [];
+              var parents = [-1, 0, 0, 1, 0, 1, 4, 5];
+              w5.forEach(function(hexagon, j2) {
+                var face2 = octahedron$1[j2], n2 = face2.length, normals = cornerNormals[j2] = [];
+                for (var i2 = 0; i2 < n2; ++i2) {
+                  w5.push([
+                    face2[i2],
+                    hexagon[(i2 * 2 + 2) % (2 * n2)],
+                    hexagon[(i2 * 2 + 1) % (2 * n2)]
+                  ]);
+                  parents.push(j2);
+                  normals.push(cross2(
+                    cartesian(hexagon[(i2 * 2 + 2) % (2 * n2)]),
+                    cartesian(hexagon[(i2 * 2 + 1) % (2 * n2)])
+                  ));
+                }
+              });
+              var faces = w5.map(function(face2) {
+                return {
+                  project: faceProjection(face2),
+                  face: face2
+                };
+              });
+              parents.forEach(function(d2, i2) {
+                var parent = faces[d2];
+                parent && (parent.children || (parent.children = [])).push(faces[i2]);
+              });
+              function face(lambda, phi) {
+                var cosphi = cos(phi), p2 = [cosphi * cos(lambda), cosphi * sin(lambda), sin(phi)];
+                var hexagon = lambda < -pi2 / 2 ? phi < 0 ? 6 : 4 : lambda < 0 ? phi < 0 ? 2 : 0 : lambda < pi2 / 2 ? phi < 0 ? 3 : 1 : phi < 0 ? 7 : 5;
+                var n2 = cornerNormals[hexagon];
+                return faces[dot2(n2[0], p2) < 0 ? 8 + 3 * hexagon : dot2(n2[1], p2) < 0 ? 8 + 3 * hexagon + 1 : dot2(n2[2], p2) < 0 ? 8 + 3 * hexagon + 2 : hexagon];
+              }
+              return polyhedral(faces[0], face).angle(-30).scale(110.625).center([0, 45]);
+            }
+            function dot2(a2, b2) {
+              for (var i2 = 0, n2 = a2.length, s2 = 0; i2 < n2; ++i2) s2 += a2[i2] * b2[i2];
+              return s2;
+            }
+            function cross2(a2, b2) {
+              return [
+                a2[1] * b2[2] - a2[2] * b2[1],
+                a2[2] * b2[0] - a2[0] * b2[2],
+                a2[0] * b2[1] - a2[1] * b2[0]
+              ];
+            }
+            function spherical(cartesian2) {
+              return [
+                atan2(cartesian2[1], cartesian2[0]) * degrees3,
+                asin(max(-1, min(1, cartesian2[2]))) * degrees3
+              ];
+            }
+            function cartesian(coordinates) {
+              var lambda = coordinates[0] * radians2, phi = coordinates[1] * radians2, cosphi = cos(phi);
+              return [
+                cosphi * cos(lambda),
+                cosphi * sin(lambda),
+                sin(phi)
+              ];
+            }
+            function noop2() {
+            }
+            function clockwise(ring) {
+              if ((n2 = ring.length) < 4) return false;
+              var i2 = 0, n2, area = ring[n2 - 1][1] * ring[0][0] - ring[n2 - 1][0] * ring[0][1];
+              while (++i2 < n2) area += ring[i2 - 1][1] * ring[i2][0] - ring[i2 - 1][0] * ring[i2][1];
+              return area <= 0;
+            }
+            function contains(ring, point) {
+              var x2 = point[0], y2 = point[1], contains2 = false;
+              for (var i2 = 0, n2 = ring.length, j2 = n2 - 1; i2 < n2; j2 = i2++) {
+                var pi22 = ring[i2], xi2 = pi22[0], yi2 = pi22[1], pj2 = ring[j2], xj2 = pj2[0], yj2 = pj2[1];
+                if (yi2 > y2 ^ yj2 > y2 && x2 < (xj2 - xi2) * (y2 - yi2) / (yj2 - yi2) + xi2) contains2 = !contains2;
+              }
+              return contains2;
+            }
+            function index(object, projection) {
+              var stream = projection.stream, project2;
+              if (!stream) throw new Error("invalid projection");
+              switch (object && object.type) {
+                case "Feature":
+                  project2 = projectFeature;
+                  break;
+                case "FeatureCollection":
+                  project2 = projectFeatureCollection;
+                  break;
+                default:
+                  project2 = projectGeometry;
+                  break;
+              }
+              return project2(object, stream);
+            }
+            function projectFeatureCollection(o2, stream) {
+              return {
+                type: "FeatureCollection",
+                features: o2.features.map(function(f2) {
+                  return projectFeature(f2, stream);
+                })
+              };
+            }
+            function projectFeature(o2, stream) {
+              return {
+                type: "Feature",
+                id: o2.id,
+                properties: o2.properties,
+                geometry: projectGeometry(o2.geometry, stream)
+              };
+            }
+            function projectGeometryCollection(o2, stream) {
+              return {
+                type: "GeometryCollection",
+                geometries: o2.geometries.map(function(o22) {
+                  return projectGeometry(o22, stream);
+                })
+              };
+            }
+            function projectGeometry(o2, stream) {
+              if (!o2) return null;
+              if (o2.type === "GeometryCollection") return projectGeometryCollection(o2, stream);
+              var sink;
+              switch (o2.type) {
+                case "Point":
+                  sink = sinkPoint;
+                  break;
+                case "MultiPoint":
+                  sink = sinkPoint;
+                  break;
+                case "LineString":
+                  sink = sinkLine;
+                  break;
+                case "MultiLineString":
+                  sink = sinkLine;
+                  break;
+                case "Polygon":
+                  sink = sinkPolygon;
+                  break;
+                case "MultiPolygon":
+                  sink = sinkPolygon;
+                  break;
+                case "Sphere":
+                  sink = sinkPolygon;
+                  break;
+                default:
+                  return null;
+              }
+              d3Geo.geoStream(o2, stream(sink));
+              return sink.result();
+            }
+            var points = [], lines = [];
+            var sinkPoint = {
+              point: function(x2, y2) {
+                points.push([x2, y2]);
+              },
+              result: function() {
+                var result = !points.length ? null : points.length < 2 ? { type: "Point", coordinates: points[0] } : { type: "MultiPoint", coordinates: points };
+                points = [];
+                return result;
+              }
+            };
+            var sinkLine = {
+              lineStart: noop2,
+              point: function(x2, y2) {
+                points.push([x2, y2]);
+              },
+              lineEnd: function() {
+                if (points.length) lines.push(points), points = [];
+              },
+              result: function() {
+                var result = !lines.length ? null : lines.length < 2 ? { type: "LineString", coordinates: lines[0] } : { type: "MultiLineString", coordinates: lines };
+                lines = [];
+                return result;
+              }
+            };
+            var sinkPolygon = {
+              polygonStart: noop2,
+              lineStart: noop2,
+              point: function(x2, y2) {
+                points.push([x2, y2]);
+              },
+              lineEnd: function() {
+                var n2 = points.length;
+                if (n2) {
+                  do
+                    points.push(points[0].slice());
+                  while (++n2 < 4);
+                  lines.push(points), points = [];
+                }
+              },
+              polygonEnd: noop2,
+              result: function() {
+                if (!lines.length) return null;
+                var polygons = [], holes = [];
+                lines.forEach(function(ring) {
+                  if (clockwise(ring)) polygons.push([ring]);
+                  else holes.push(ring);
+                });
+                holes.forEach(function(hole) {
+                  var point = hole[0];
+                  polygons.some(function(polygon) {
+                    if (contains(polygon[0], point)) {
+                      polygon.push(hole);
+                      return true;
+                    }
+                  }) || polygons.push([hole]);
+                });
+                lines = [];
+                return !polygons.length ? null : polygons.length > 1 ? { type: "MultiPolygon", coordinates: polygons } : { type: "Polygon", coordinates: polygons[0] };
+              }
+            };
+            function quincuncial(project2) {
+              var dx = project2(halfPi, 0)[0] - project2(-halfPi, 0)[0];
+              function projectQuincuncial(lambda, phi) {
+                var t4 = abs(lambda) < halfPi, p2 = project2(t4 ? lambda : lambda > 0 ? lambda - pi2 : lambda + pi2, phi), x2 = (p2[0] - p2[1]) * sqrt1_2, y2 = (p2[0] + p2[1]) * sqrt1_2;
+                if (t4) return [x2, y2];
+                var d2 = dx * sqrt1_2, s2 = x2 > 0 ^ y2 > 0 ? -1 : 1;
+                return [s2 * x2 - sign(y2) * d2, s2 * y2 - sign(x2) * d2];
+              }
+              if (project2.invert) projectQuincuncial.invert = function(x02, y02) {
+                var x2 = (x02 + y02) * sqrt1_2, y2 = (y02 - x02) * sqrt1_2, t4 = abs(x2) < 0.5 * dx && abs(y2) < 0.5 * dx;
+                if (!t4) {
+                  var d2 = dx * sqrt1_2, s2 = x2 > 0 ^ y2 > 0 ? -1 : 1, x12 = -s2 * x02 + (y2 > 0 ? 1 : -1) * d2, y12 = -s2 * y02 + (x2 > 0 ? 1 : -1) * d2;
+                  x2 = (-x12 - y12) * sqrt1_2;
+                  y2 = (x12 - y12) * sqrt1_2;
+                }
+                var p2 = project2.invert(x2, y2);
+                if (!t4) p2[0] += x2 > 0 ? pi2 : -pi2;
+                return p2;
+              };
+              return d3Geo.geoProjection(projectQuincuncial).rotate([-90, -90, 45]).clipAngle(180 - 1e-3);
+            }
+            function gringorten$1() {
+              return quincuncial(gringortenRaw).scale(176.423);
+            }
+            function peirce() {
+              return quincuncial(guyouRaw).scale(111.48);
+            }
+            function quantize(input, digits) {
+              if (!(0 <= (digits = +digits) && digits <= 20)) throw new Error("invalid digits");
+              function quantizePoint(input2) {
+                var n2 = input2.length, i2 = 2, output2 = new Array(n2);
+                output2[0] = +input2[0].toFixed(digits);
+                output2[1] = +input2[1].toFixed(digits);
+                while (i2 < n2) output2[i2] = input2[i2], ++i2;
+                return output2;
+              }
+              function quantizePoints(input2) {
+                return input2.map(quantizePoint);
+              }
+              function quantizePointsNoDuplicates(input2) {
+                var point0 = quantizePoint(input2[0]);
+                var output2 = [point0];
+                for (var i2 = 1; i2 < input2.length; i2++) {
+                  var point = quantizePoint(input2[i2]);
+                  if (point.length > 2 || point[0] != point0[0] || point[1] != point0[1]) {
+                    output2.push(point);
+                    point0 = point;
+                  }
+                }
+                if (output2.length === 1 && input2.length > 1) {
+                  output2.push(quantizePoint(input2[input2.length - 1]));
+                }
+                return output2;
+              }
+              function quantizePolygon(input2) {
+                return input2.map(quantizePointsNoDuplicates);
+              }
+              function quantizeGeometry(input2) {
+                if (input2 == null) return input2;
+                var output2;
+                switch (input2.type) {
+                  case "GeometryCollection":
+                    output2 = { type: "GeometryCollection", geometries: input2.geometries.map(quantizeGeometry) };
+                    break;
+                  case "Point":
+                    output2 = { type: "Point", coordinates: quantizePoint(input2.coordinates) };
+                    break;
+                  case "MultiPoint":
+                    output2 = { type: input2.type, coordinates: quantizePoints(input2.coordinates) };
+                    break;
+                  case "LineString":
+                    output2 = { type: input2.type, coordinates: quantizePointsNoDuplicates(input2.coordinates) };
+                    break;
+                  case "MultiLineString":
+                  case "Polygon":
+                    output2 = { type: input2.type, coordinates: quantizePolygon(input2.coordinates) };
+                    break;
+                  case "MultiPolygon":
+                    output2 = { type: "MultiPolygon", coordinates: input2.coordinates.map(quantizePolygon) };
+                    break;
+                  default:
+                    return input2;
+                }
+                if (input2.bbox != null) output2.bbox = input2.bbox;
+                return output2;
+              }
+              function quantizeFeature(input2) {
+                var output2 = { type: "Feature", properties: input2.properties, geometry: quantizeGeometry(input2.geometry) };
+                if (input2.id != null) output2.id = input2.id;
+                if (input2.bbox != null) output2.bbox = input2.bbox;
+                return output2;
+              }
+              if (input != null) switch (input.type) {
+                case "Feature":
+                  return quantizeFeature(input);
+                case "FeatureCollection": {
+                  var output = { type: "FeatureCollection", features: input.features.map(quantizeFeature) };
+                  if (input.bbox != null) output.bbox = input.bbox;
+                  return output;
+                }
+                default:
+                  return quantizeGeometry(input);
+              }
+              return input;
+            }
+            function rectangularPolyconicRaw(phi02) {
+              var sinPhi0 = sin(phi02);
+              function forward(lambda, phi) {
+                var A3 = sinPhi0 ? tan(lambda * sinPhi0 / 2) / sinPhi0 : lambda / 2;
+                if (!phi) return [2 * A3, -phi02];
+                var E22 = 2 * atan(A3 * sin(phi)), cotPhi = 1 / tan(phi);
+                return [
+                  sin(E22) * cotPhi,
+                  phi + (1 - cos(E22)) * cotPhi - phi02
+                ];
+              }
+              forward.invert = function(x2, y2) {
+                if (abs(y2 += phi02) < epsilon) return [sinPhi0 ? 2 * atan(sinPhi0 * x2 / 2) / sinPhi0 : x2, 0];
+                var k22 = x2 * x2 + y2 * y2, phi = 0, i2 = 10, delta;
+                do {
+                  var tanPhi = tan(phi), secPhi = 1 / cos(phi), j2 = k22 - 2 * y2 * phi + phi * phi;
+                  phi -= delta = (tanPhi * j2 + 2 * (phi - y2)) / (2 + j2 * secPhi * secPhi + 2 * (phi - y2) * tanPhi);
+                } while (abs(delta) > epsilon && --i2 > 0);
+                var E22 = x2 * (tanPhi = tan(phi)), A3 = tan(abs(y2) < abs(phi + 1 / tanPhi) ? asin(E22) * 0.5 : acos(E22) * 0.5 + pi2 / 4) / sin(phi);
+                return [
+                  sinPhi0 ? 2 * atan(sinPhi0 * A3) / sinPhi0 : 2 * A3,
+                  phi
+                ];
+              };
+              return forward;
+            }
+            function rectangularPolyconic() {
+              return parallel1(rectangularPolyconicRaw).scale(131.215);
+            }
+            var K$12 = [
+              [0.9986, -0.062],
+              [1, 0],
+              [0.9986, 0.062],
+              [0.9954, 0.124],
+              [0.99, 0.186],
+              [0.9822, 0.248],
+              [0.973, 0.31],
+              [0.96, 0.372],
+              [0.9427, 0.434],
+              [0.9216, 0.4958],
+              [0.8962, 0.5571],
+              [0.8679, 0.6176],
+              [0.835, 0.6769],
+              [0.7986, 0.7346],
+              [0.7597, 0.7903],
+              [0.7186, 0.8435],
+              [0.6732, 0.8936],
+              [0.6213, 0.9394],
+              [0.5722, 0.9761],
+              [0.5322, 1]
+            ];
+            K$12.forEach(function(d2) {
+              d2[1] *= 1.0144;
+            });
+            function robinsonRaw(lambda, phi) {
+              var i2 = min(18, abs(phi) * 36 / pi2), i0 = floor(i2), di2 = i2 - i0, ax = (k22 = K$12[i0])[0], ay = k22[1], bx = (k22 = K$12[++i0])[0], by = k22[1], cx = (k22 = K$12[min(19, ++i0)])[0], cy = k22[1], k22;
+              return [
+                lambda * (bx + di2 * (cx - ax) / 2 + di2 * di2 * (cx - 2 * bx + ax) / 2),
+                (phi > 0 ? halfPi : -halfPi) * (by + di2 * (cy - ay) / 2 + di2 * di2 * (cy - 2 * by + ay) / 2)
+              ];
+            }
+            robinsonRaw.invert = function(x2, y2) {
+              var yy = y2 / halfPi, phi = yy * 90, i2 = min(18, abs(phi / 5)), i0 = max(0, floor(i2));
+              do {
+                var ay = K$12[i0][1], by = K$12[i0 + 1][1], cy = K$12[min(19, i0 + 2)][1], u2 = cy - ay, v2 = cy - 2 * by + ay, t4 = 2 * (abs(yy) - by) / u2, c2 = v2 / u2, di2 = t4 * (1 - c2 * t4 * (1 - 2 * c2 * t4));
+                if (di2 >= 0 || i0 === 1) {
+                  phi = (y2 >= 0 ? 5 : -5) * (di2 + i2);
+                  var j2 = 50, delta;
+                  do {
+                    i2 = min(18, abs(phi) / 5);
+                    i0 = floor(i2);
+                    di2 = i2 - i0;
+                    ay = K$12[i0][1];
+                    by = K$12[i0 + 1][1];
+                    cy = K$12[min(19, i0 + 2)][1];
+                    phi -= (delta = (y2 >= 0 ? halfPi : -halfPi) * (by + di2 * (cy - ay) / 2 + di2 * di2 * (cy - 2 * by + ay) / 2) - y2) * degrees3;
+                  } while (abs(delta) > epsilon22 && --j2 > 0);
+                  break;
+                }
+              } while (--i0 >= 0);
+              var ax = K$12[i0][0], bx = K$12[i0 + 1][0], cx = K$12[min(19, i0 + 2)][0];
+              return [
+                x2 / (bx + di2 * (cx - ax) / 2 + di2 * di2 * (cx - 2 * bx + ax) / 2),
+                phi * radians2
+              ];
+            };
+            function robinson() {
+              return d3Geo.geoProjection(robinsonRaw).scale(152.63);
+            }
+            function satelliteVerticalRaw(P2) {
+              function forward(lambda, phi) {
+                var cosPhi = cos(phi), k22 = (P2 - 1) / (P2 - cosPhi * cos(lambda));
+                return [
+                  k22 * cosPhi * sin(lambda),
+                  k22 * sin(phi)
+                ];
+              }
+              forward.invert = function(x2, y2) {
+                var rho2 = x2 * x2 + y2 * y2, rho = sqrt(rho2), sinc = (P2 - sqrt(1 - rho2 * (P2 + 1) / (P2 - 1))) / ((P2 - 1) / rho + rho / (P2 - 1));
+                return [
+                  atan2(x2 * sinc, rho * sqrt(1 - sinc * sinc)),
+                  rho ? asin(y2 * sinc / rho) : 0
+                ];
+              };
+              return forward;
+            }
+            function satelliteRaw(P2, omega) {
+              var vertical = satelliteVerticalRaw(P2);
+              if (!omega) return vertical;
+              var cosOmega = cos(omega), sinOmega = sin(omega);
+              function forward(lambda, phi) {
+                var coordinates = vertical(lambda, phi), y2 = coordinates[1], A3 = y2 * sinOmega / (P2 - 1) + cosOmega;
+                return [
+                  coordinates[0] * cosOmega / A3,
+                  y2 / A3
+                ];
+              }
+              forward.invert = function(x2, y2) {
+                var k22 = (P2 - 1) / (P2 - 1 - y2 * sinOmega);
+                return vertical.invert(k22 * x2, k22 * y2 * cosOmega);
+              };
+              return forward;
+            }
+            function satellite() {
+              var distance22 = 2, omega = 0, m2 = d3Geo.geoProjectionMutator(satelliteRaw), p2 = m2(distance22, omega);
+              p2.distance = function(_2) {
+                if (!arguments.length) return distance22;
+                return m2(distance22 = +_2, omega);
+              };
+              p2.tilt = function(_2) {
+                if (!arguments.length) return omega * degrees3;
+                return m2(distance22, omega = _2 * radians2);
+              };
+              return p2.scale(432.147).clipAngle(acos(1 / distance22) * degrees3 - 1e-6);
+            }
+            var epsilon$1 = 1e-4, epsilonInverse = 1e4, x0 = -180, x0e = x0 + epsilon$1, x1 = 180, x1e = x1 - epsilon$1, y0 = -90, y0e = y0 + epsilon$1, y1 = 90, y1e = y1 - epsilon$1;
+            function nonempty(coordinates) {
+              return coordinates.length > 0;
+            }
+            function quantize$1(x2) {
+              return Math.floor(x2 * epsilonInverse) / epsilonInverse;
+            }
+            function normalizePoint(y2) {
+              return y2 === y0 || y2 === y1 ? [0, y2] : [x0, quantize$1(y2)];
+            }
+            function clampPoint(p2) {
+              var x2 = p2[0], y2 = p2[1], clamped = false;
+              if (x2 <= x0e) x2 = x0, clamped = true;
+              else if (x2 >= x1e) x2 = x1, clamped = true;
+              if (y2 <= y0e) y2 = y0, clamped = true;
+              else if (y2 >= y1e) y2 = y1, clamped = true;
+              return clamped ? [x2, y2] : p2;
+            }
+            function clampPoints(points2) {
+              return points2.map(clampPoint);
+            }
+            function extractFragments(rings, polygon, fragments2) {
+              for (var j2 = 0, m2 = rings.length; j2 < m2; ++j2) {
+                var ring = rings[j2].slice();
+                fragments2.push({ index: -1, polygon, ring });
+                for (var i2 = 0, n2 = ring.length; i2 < n2; ++i2) {
+                  var point = ring[i2], x2 = point[0], y2 = point[1];
+                  if (x2 <= x0e || x2 >= x1e || y2 <= y0e || y2 >= y1e) {
+                    ring[i2] = clampPoint(point);
+                    for (var k22 = i2 + 1; k22 < n2; ++k22) {
+                      var pointk = ring[k22], xk2 = pointk[0], yk2 = pointk[1];
+                      if (xk2 > x0e && xk2 < x1e && yk2 > y0e && yk2 < y1e) break;
+                    }
+                    if (k22 === i2 + 1) continue;
+                    if (i2) {
+                      var fragmentBefore = { index: -1, polygon, ring: ring.slice(0, i2 + 1) };
+                      fragmentBefore.ring[fragmentBefore.ring.length - 1] = normalizePoint(y2);
+                      fragments2[fragments2.length - 1] = fragmentBefore;
+                    } else fragments2.pop();
+                    if (k22 >= n2) break;
+                    fragments2.push({ index: -1, polygon, ring: ring = ring.slice(k22 - 1) });
+                    ring[0] = normalizePoint(ring[0][1]);
+                    i2 = -1;
+                    n2 = ring.length;
+                  }
+                }
+              }
+            }
+            function stitchFragments(fragments2) {
+              var i2, n2 = fragments2.length;
+              var fragmentByStart = {}, fragmentByEnd = {}, fragment2, start, startFragment, end, endFragment;
+              for (i2 = 0; i2 < n2; ++i2) {
+                fragment2 = fragments2[i2];
+                start = fragment2.ring[0];
+                end = fragment2.ring[fragment2.ring.length - 1];
+                if (start[0] === end[0] && start[1] === end[1]) {
+                  fragment2.polygon.push(fragment2.ring);
+                  fragments2[i2] = null;
+                  continue;
+                }
+                fragment2.index = i2;
+                fragmentByStart[start] = fragmentByEnd[end] = fragment2;
+              }
+              for (i2 = 0; i2 < n2; ++i2) {
+                fragment2 = fragments2[i2];
+                if (fragment2) {
+                  start = fragment2.ring[0];
+                  end = fragment2.ring[fragment2.ring.length - 1];
+                  startFragment = fragmentByEnd[start];
+                  endFragment = fragmentByStart[end];
+                  delete fragmentByStart[start];
+                  delete fragmentByEnd[end];
+                  if (start[0] === end[0] && start[1] === end[1]) {
+                    fragment2.polygon.push(fragment2.ring);
+                    continue;
+                  }
+                  if (startFragment) {
+                    delete fragmentByEnd[start];
+                    delete fragmentByStart[startFragment.ring[0]];
+                    startFragment.ring.pop();
+                    fragments2[startFragment.index] = null;
+                    fragment2 = { index: -1, polygon: startFragment.polygon, ring: startFragment.ring.concat(fragment2.ring) };
+                    if (startFragment === endFragment) {
+                      fragment2.polygon.push(fragment2.ring);
+                    } else {
+                      fragment2.index = n2++;
+                      fragments2.push(fragmentByStart[fragment2.ring[0]] = fragmentByEnd[fragment2.ring[fragment2.ring.length - 1]] = fragment2);
+                    }
+                  } else if (endFragment) {
+                    delete fragmentByStart[end];
+                    delete fragmentByEnd[endFragment.ring[endFragment.ring.length - 1]];
+                    fragment2.ring.pop();
+                    fragment2 = { index: n2++, polygon: endFragment.polygon, ring: fragment2.ring.concat(endFragment.ring) };
+                    fragments2[endFragment.index] = null;
+                    fragments2.push(fragmentByStart[fragment2.ring[0]] = fragmentByEnd[fragment2.ring[fragment2.ring.length - 1]] = fragment2);
+                  } else {
+                    fragment2.ring.push(fragment2.ring[0]);
+                    fragment2.polygon.push(fragment2.ring);
+                  }
+                }
+              }
+            }
+            function stitchFeature(input) {
+              var output = { type: "Feature", geometry: stitchGeometry(input.geometry) };
+              if (input.id != null) output.id = input.id;
+              if (input.bbox != null) output.bbox = input.bbox;
+              if (input.properties != null) output.properties = input.properties;
+              return output;
+            }
+            function stitchGeometry(input) {
+              if (input == null) return input;
+              var output, fragments2, i2, n2;
+              switch (input.type) {
+                case "GeometryCollection":
+                  output = { type: "GeometryCollection", geometries: input.geometries.map(stitchGeometry) };
+                  break;
+                case "Point":
+                  output = { type: "Point", coordinates: clampPoint(input.coordinates) };
+                  break;
+                case "MultiPoint":
+                case "LineString":
+                  output = { type: input.type, coordinates: clampPoints(input.coordinates) };
+                  break;
+                case "MultiLineString":
+                  output = { type: "MultiLineString", coordinates: input.coordinates.map(clampPoints) };
+                  break;
+                case "Polygon": {
+                  var polygon = [];
+                  extractFragments(input.coordinates, polygon, fragments2 = []);
+                  stitchFragments(fragments2);
+                  output = { type: "Polygon", coordinates: polygon };
+                  break;
+                }
+                case "MultiPolygon": {
+                  fragments2 = [], i2 = -1, n2 = input.coordinates.length;
+                  var polygons = new Array(n2);
+                  while (++i2 < n2) extractFragments(input.coordinates[i2], polygons[i2] = [], fragments2);
+                  stitchFragments(fragments2);
+                  output = { type: "MultiPolygon", coordinates: polygons.filter(nonempty) };
+                  break;
+                }
+                default:
+                  return input;
+              }
+              if (input.bbox != null) output.bbox = input.bbox;
+              return output;
+            }
+            function stitch(input) {
+              if (input == null) return input;
+              switch (input.type) {
+                case "Feature":
+                  return stitchFeature(input);
+                case "FeatureCollection": {
+                  var output = { type: "FeatureCollection", features: input.features.map(stitchFeature) };
+                  if (input.bbox != null) output.bbox = input.bbox;
+                  return output;
+                }
+                default:
+                  return stitchGeometry(input);
+              }
+            }
+            function timesRaw(lambda, phi) {
+              var t4 = tan(phi / 2), s2 = sin(quarterPi * t4);
+              return [
+                lambda * (0.74482 - 0.34588 * s2 * s2),
+                1.70711 * t4
+              ];
+            }
+            timesRaw.invert = function(x2, y2) {
+              var t4 = y2 / 1.70711, s2 = sin(quarterPi * t4);
+              return [
+                x2 / (0.74482 - 0.34588 * s2 * s2),
+                2 * atan(t4)
+              ];
+            };
+            function times() {
+              return d3Geo.geoProjection(timesRaw).scale(146.153);
+            }
+            function twoPoint(raw, p0, p1) {
+              var i2 = d3Geo.geoInterpolate(p0, p1), o2 = i2(0.5), a2 = d3Geo.geoRotation([-o2[0], -o2[1]])(p0), b2 = i2.distance / 2, y2 = -asin(sin(a2[1] * radians2) / sin(b2)), R2 = [-o2[0], -o2[1], -(a2[0] > 0 ? pi2 - y2 : y2) * degrees3], p2 = d3Geo.geoProjection(raw(b2)).rotate(R2), r2 = d3Geo.geoRotation(R2), center = p2.center;
+              delete p2.rotate;
+              p2.center = function(_2) {
+                return arguments.length ? center(r2(_2)) : r2.invert(center());
+              };
+              return p2.clipAngle(90);
+            }
+            function twoPointAzimuthalRaw(d2) {
+              var cosd = cos(d2);
+              function forward(lambda, phi) {
+                var coordinates = d3Geo.geoGnomonicRaw(lambda, phi);
+                coordinates[0] *= cosd;
+                return coordinates;
+              }
+              forward.invert = function(x2, y2) {
+                return d3Geo.geoGnomonicRaw.invert(x2 / cosd, y2);
+              };
+              return forward;
+            }
+            function twoPointAzimuthalUsa() {
+              return twoPointAzimuthal([-158, 21.5], [-77, 39]).clipAngle(60).scale(400);
+            }
+            function twoPointAzimuthal(p0, p1) {
+              return twoPoint(twoPointAzimuthalRaw, p0, p1);
+            }
+            function twoPointEquidistantRaw(z0) {
+              if (!(z0 *= 2)) return d3Geo.geoAzimuthalEquidistantRaw;
+              var lambdaa = -z0 / 2, lambdab = -lambdaa, z02 = z0 * z0, tanLambda0 = tan(lambdab), S2 = 0.5 / sin(lambdab);
+              function forward(lambda, phi) {
+                var za2 = acos(cos(phi) * cos(lambda - lambdaa)), zb2 = acos(cos(phi) * cos(lambda - lambdab)), ys = phi < 0 ? -1 : 1;
+                za2 *= za2, zb2 *= zb2;
+                return [
+                  (za2 - zb2) / (2 * z0),
+                  ys * sqrt(4 * z02 * zb2 - (z02 - za2 + zb2) * (z02 - za2 + zb2)) / (2 * z0)
+                ];
+              }
+              forward.invert = function(x2, y2) {
+                var y22 = y2 * y2, cosza = cos(sqrt(y22 + (t4 = x2 + lambdaa) * t4)), coszb = cos(sqrt(y22 + (t4 = x2 + lambdab) * t4)), t4, d2;
+                return [
+                  atan2(d2 = cosza - coszb, t4 = (cosza + coszb) * tanLambda0),
+                  (y2 < 0 ? -1 : 1) * acos(sqrt(t4 * t4 + d2 * d2) * S2)
+                ];
+              };
+              return forward;
+            }
+            function twoPointEquidistantUsa() {
+              return twoPointEquidistant([-158, 21.5], [-77, 39]).clipAngle(130).scale(122.571);
+            }
+            function twoPointEquidistant(p0, p1) {
+              return twoPoint(twoPointEquidistantRaw, p0, p1);
+            }
+            function vanDerGrintenRaw(lambda, phi) {
+              if (abs(phi) < epsilon) return [lambda, 0];
+              var sinTheta = abs(phi / halfPi), theta = asin(sinTheta);
+              if (abs(lambda) < epsilon || abs(abs(phi) - halfPi) < epsilon) return [0, sign(phi) * pi2 * tan(theta / 2)];
+              var cosTheta = cos(theta), A3 = abs(pi2 / lambda - lambda / pi2) / 2, A222 = A3 * A3, G2 = cosTheta / (sinTheta + cosTheta - 1), P2 = G2 * (2 / sinTheta - 1), P22 = P2 * P2, P2_A2 = P22 + A222, G_P2 = G2 - P22, Q2 = A222 + G2;
+              return [
+                sign(lambda) * pi2 * (A3 * G_P2 + sqrt(A222 * G_P2 * G_P2 - P2_A2 * (G2 * G2 - P22))) / P2_A2,
+                sign(phi) * pi2 * (P2 * Q2 - A3 * sqrt((A222 + 1) * P2_A2 - Q2 * Q2)) / P2_A2
+              ];
+            }
+            vanDerGrintenRaw.invert = function(x2, y2) {
+              if (abs(y2) < epsilon) return [x2, 0];
+              if (abs(x2) < epsilon) return [0, halfPi * sin(2 * atan(y2 / pi2))];
+              var x22 = (x2 /= pi2) * x2, y22 = (y2 /= pi2) * y2, x2_y2 = x22 + y22, z2 = x2_y2 * x2_y2, c1 = -abs(y2) * (1 + x2_y2), c2 = c1 - 2 * y22 + x22, c3 = -2 * c1 + 1 + 2 * y22 + z2, d2 = y22 / c3 + (2 * c2 * c2 * c2 / (c3 * c3 * c3) - 9 * c1 * c2 / (c3 * c3)) / 27, a1 = (c1 - c2 * c2 / (3 * c3)) / c3, m1 = 2 * sqrt(-a1 / 3), theta1 = acos(3 * d2 / (a1 * m1)) / 3;
+              return [
+                pi2 * (x2_y2 - 1 + sqrt(1 + 2 * (x22 - y22) + z2)) / (2 * x2),
+                sign(y2) * pi2 * (-m1 * cos(theta1 + pi2 / 3) - c2 / (3 * c3))
+              ];
+            };
+            function vanDerGrinten() {
+              return d3Geo.geoProjection(vanDerGrintenRaw).scale(79.4183);
+            }
+            function vanDerGrinten2Raw(lambda, phi) {
+              if (abs(phi) < epsilon) return [lambda, 0];
+              var sinTheta = abs(phi / halfPi), theta = asin(sinTheta);
+              if (abs(lambda) < epsilon || abs(abs(phi) - halfPi) < epsilon) return [0, sign(phi) * pi2 * tan(theta / 2)];
+              var cosTheta = cos(theta), A3 = abs(pi2 / lambda - lambda / pi2) / 2, A222 = A3 * A3, x12 = cosTheta * (sqrt(1 + A222) - A3 * cosTheta) / (1 + A222 * sinTheta * sinTheta);
+              return [
+                sign(lambda) * pi2 * x12,
+                sign(phi) * pi2 * sqrt(1 - x12 * (2 * A3 + x12))
+              ];
+            }
+            vanDerGrinten2Raw.invert = function(x2, y2) {
+              if (!x2) return [0, halfPi * sin(2 * atan(y2 / pi2))];
+              var x12 = abs(x2 / pi2), A3 = (1 - x12 * x12 - (y2 /= pi2) * y2) / (2 * x12), A222 = A3 * A3, B3 = sqrt(A222 + 1);
+              return [
+                sign(x2) * pi2 * (B3 - A3),
+                sign(y2) * halfPi * sin(2 * atan2(sqrt((1 - 2 * A3 * x12) * (A3 + B3) - x12), sqrt(B3 + A3 + x12)))
+              ];
+            };
+            function vanDerGrinten2() {
+              return d3Geo.geoProjection(vanDerGrinten2Raw).scale(79.4183);
+            }
+            function vanDerGrinten3Raw(lambda, phi) {
+              if (abs(phi) < epsilon) return [lambda, 0];
+              var sinTheta = phi / halfPi, theta = asin(sinTheta);
+              if (abs(lambda) < epsilon || abs(abs(phi) - halfPi) < epsilon) return [0, pi2 * tan(theta / 2)];
+              var A3 = (pi2 / lambda - lambda / pi2) / 2, y12 = sinTheta / (1 + cos(theta));
+              return [
+                pi2 * (sign(lambda) * sqrt(A3 * A3 + 1 - y12 * y12) - A3),
+                pi2 * y12
+              ];
+            }
+            vanDerGrinten3Raw.invert = function(x2, y2) {
+              if (!y2) return [x2, 0];
+              var y12 = y2 / pi2, A3 = (pi2 * pi2 * (1 - y12 * y12) - x2 * x2) / (2 * pi2 * x2);
+              return [
+                x2 ? pi2 * (sign(x2) * sqrt(A3 * A3 + 1) - A3) : 0,
+                halfPi * sin(2 * atan(y12))
+              ];
+            };
+            function vanDerGrinten3() {
+              return d3Geo.geoProjection(vanDerGrinten3Raw).scale(79.4183);
+            }
+            function vanDerGrinten4Raw(lambda, phi) {
+              if (!phi) return [lambda, 0];
+              var phi02 = abs(phi);
+              if (!lambda || phi02 === halfPi) return [0, phi];
+              var B3 = phi02 / halfPi, B222 = B3 * B3, C22 = (8 * B3 - B222 * (B222 + 2) - 5) / (2 * B222 * (B3 - 1)), C222 = C22 * C22, BC = B3 * C22, B_C2 = B222 + C222 + 2 * BC, B_3C = B3 + 3 * C22, lambda0 = lambda / halfPi, lambda1 = lambda0 + 1 / lambda0, D22 = sign(abs(lambda) - halfPi) * sqrt(lambda1 * lambda1 - 4), D222 = D22 * D22, F2 = B_C2 * (B222 + C222 * D222 - 1) + (1 - B222) * (B222 * (B_3C * B_3C + 4 * C222) + 12 * BC * C222 + 4 * C222 * C222), x12 = (D22 * (B_C2 + C222 - 1) + 2 * sqrt(F2)) / (4 * B_C2 + D222);
+              return [
+                sign(lambda) * halfPi * x12,
+                sign(phi) * halfPi * sqrt(1 + D22 * abs(x12) - x12 * x12)
+              ];
+            }
+            vanDerGrinten4Raw.invert = function(x2, y2) {
+              var delta;
+              if (!x2 || !y2) return [x2, y2];
+              y2 /= pi2;
+              var x12 = sign(x2) * x2 / halfPi, D22 = (x12 * x12 - 1 + 4 * y2 * y2) / abs(x12), D222 = D22 * D22, B3 = 2 * y2, i2 = 50;
+              do {
+                var B222 = B3 * B3, C22 = (8 * B3 - B222 * (B222 + 2) - 5) / (2 * B222 * (B3 - 1)), C_ = (3 * B3 - B222 * B3 - 10) / (2 * B222 * B3), C222 = C22 * C22, BC = B3 * C22, B_C = B3 + C22, B_C2 = B_C * B_C, B_3C = B3 + 3 * C22, F2 = B_C2 * (B222 + C222 * D222 - 1) + (1 - B222) * (B222 * (B_3C * B_3C + 4 * C222) + C222 * (12 * BC + 4 * C222)), F_ = -2 * B_C * (4 * BC * C222 + (1 - 4 * B222 + 3 * B222 * B222) * (1 + C_) + C222 * (-6 + 14 * B222 - D222 + (-8 + 8 * B222 - 2 * D222) * C_) + BC * (-8 + 12 * B222 + (-10 + 10 * B222 - D222) * C_)), sqrtF = sqrt(F2), f2 = D22 * (B_C2 + C222 - 1) + 2 * sqrtF - x12 * (4 * B_C2 + D222), f_ = D22 * (2 * C22 * C_ + 2 * B_C * (1 + C_)) + F_ / sqrtF - 8 * B_C * (D22 * (-1 + C222 + B_C2) + 2 * sqrtF) * (1 + C_) / (D222 + 4 * B_C2);
+                B3 -= delta = f2 / f_;
+              } while (delta > epsilon && --i2 > 0);
+              return [
+                sign(x2) * (sqrt(D22 * D22 + 4) + D22) * pi2 / 4,
+                halfPi * B3
+              ];
+            };
+            function vanDerGrinten4() {
+              return d3Geo.geoProjection(vanDerGrinten4Raw).scale(127.16);
+            }
+            function wagnerFormula(cx, cy, m1, m2, n2) {
+              function forward(lambda, phi) {
+                var s2 = m1 * sin(m2 * phi), c0 = sqrt(1 - s2 * s2), c1 = sqrt(2 / (1 + c0 * cos(lambda *= n2)));
+                return [
+                  cx * c0 * c1 * sin(lambda),
+                  cy * s2 * c1
+                ];
+              }
+              forward.invert = function(x2, y2) {
+                var t12 = x2 / cx, t22 = y2 / cy, p2 = sqrt(t12 * t12 + t22 * t22), c2 = 2 * asin(p2 / 2);
+                return [
+                  atan2(x2 * tan(c2), cx * p2) / n2,
+                  p2 && asin(y2 * sin(c2) / (cy * m1 * p2)) / m2
+                ];
+              };
+              return forward;
+            }
+            function wagnerRaw(poleline, parallels, inflation, ratio) {
+              var phi1 = pi2 / 3;
+              poleline = max(poleline, epsilon);
+              parallels = max(parallels, epsilon);
+              poleline = min(poleline, halfPi);
+              parallels = min(parallels, pi2 - epsilon);
+              inflation = max(inflation, 0);
+              inflation = min(inflation, 100 - epsilon);
+              ratio = max(ratio, epsilon);
+              var vinflation = inflation / 100 + 1;
+              var vratio = ratio / 100;
+              var m2 = acos(vinflation * cos(phi1)) / phi1, m1 = sin(poleline) / sin(m2 * halfPi), n2 = parallels / pi2, k22 = sqrt(vratio * sin(poleline / 2) / sin(parallels / 2)), cx = k22 / sqrt(n2 * m1 * m2), cy = 1 / (k22 * sqrt(n2 * m1 * m2));
+              return wagnerFormula(cx, cy, m1, m2, n2);
+            }
+            function wagner() {
+              var poleline = 65 * radians2, parallels = 60 * radians2, inflation = 20, ratio = 200, mutate = d3Geo.geoProjectionMutator(wagnerRaw), projection = mutate(poleline, parallels, inflation, ratio);
+              projection.poleline = function(_2) {
+                return arguments.length ? mutate(poleline = +_2 * radians2, parallels, inflation, ratio) : poleline * degrees3;
+              };
+              projection.parallels = function(_2) {
+                return arguments.length ? mutate(poleline, parallels = +_2 * radians2, inflation, ratio) : parallels * degrees3;
+              };
+              projection.inflation = function(_2) {
+                return arguments.length ? mutate(poleline, parallels, inflation = +_2, ratio) : inflation;
+              };
+              projection.ratio = function(_2) {
+                return arguments.length ? mutate(poleline, parallels, inflation, ratio = +_2) : ratio;
+              };
+              return projection.scale(163.775);
+            }
+            function wagner7() {
+              return wagner().poleline(65).parallels(60).inflation(0).ratio(200).scale(172.633);
+            }
+            var A22 = 4 * pi2 + 3 * sqrt(3), B22 = 2 * sqrt(2 * pi2 * sqrt(3) / A22);
+            var wagner4Raw = mollweideBromleyRaw(B22 * sqrt(3) / pi2, B22, A22 / 6);
+            function wagner4() {
+              return d3Geo.geoProjection(wagner4Raw).scale(176.84);
+            }
+            function wagner6Raw(lambda, phi) {
+              return [lambda * sqrt(1 - 3 * phi * phi / (pi2 * pi2)), phi];
+            }
+            wagner6Raw.invert = function(x2, y2) {
+              return [x2 / sqrt(1 - 3 * y2 * y2 / (pi2 * pi2)), y2];
+            };
+            function wagner6() {
+              return d3Geo.geoProjection(wagner6Raw).scale(152.63);
+            }
+            function wiechelRaw(lambda, phi) {
+              var cosPhi = cos(phi), sinPhi = cos(lambda) * cosPhi, sin1_Phi = 1 - sinPhi, cosLambda = cos(lambda = atan2(sin(lambda) * cosPhi, -sin(phi))), sinLambda = sin(lambda);
+              cosPhi = sqrt(1 - sinPhi * sinPhi);
+              return [
+                sinLambda * cosPhi - cosLambda * sin1_Phi,
+                -cosLambda * cosPhi - sinLambda * sin1_Phi
+              ];
+            }
+            wiechelRaw.invert = function(x2, y2) {
+              var w22 = (x2 * x2 + y2 * y2) / -2, k22 = sqrt(-w22 * (2 + w22)), b2 = y2 * w22 + x2 * k22, a2 = x2 * w22 - y2 * k22, D22 = sqrt(a2 * a2 + b2 * b2);
+              return [
+                atan2(k22 * b2, D22 * (1 + w22)),
+                D22 ? -asin(k22 * a2 / D22) : 0
+              ];
+            };
+            function wiechel() {
+              return d3Geo.geoProjection(wiechelRaw).rotate([0, -90, 45]).scale(124.75).clipAngle(180 - 1e-3);
+            }
+            function winkel3Raw(lambda, phi) {
+              var coordinates = aitoffRaw(lambda, phi);
+              return [
+                (coordinates[0] + lambda / halfPi) / 2,
+                (coordinates[1] + phi) / 2
+              ];
+            }
+            winkel3Raw.invert = function(x2, y2) {
+              var lambda = x2, phi = y2, i2 = 25;
+              do {
+                var cosphi = cos(phi), sinphi = sin(phi), sin_2phi = sin(2 * phi), sin2phi = sinphi * sinphi, cos2phi = cosphi * cosphi, sinlambda = sin(lambda), coslambda_2 = cos(lambda / 2), sinlambda_2 = sin(lambda / 2), sin2lambda_2 = sinlambda_2 * sinlambda_2, C22 = 1 - cos2phi * coslambda_2 * coslambda_2, E22 = C22 ? acos(cosphi * coslambda_2) * sqrt(F2 = 1 / C22) : F2 = 0, F2, fx = 0.5 * (2 * E22 * cosphi * sinlambda_2 + lambda / halfPi) - x2, fy = 0.5 * (E22 * sinphi + phi) - y2, dxdlambda = 0.5 * F2 * (cos2phi * sin2lambda_2 + E22 * cosphi * coslambda_2 * sin2phi) + 0.5 / halfPi, dxdphi = F2 * (sinlambda * sin_2phi / 4 - E22 * sinphi * sinlambda_2), dydlambda = 0.125 * F2 * (sin_2phi * sinlambda_2 - E22 * sinphi * cos2phi * sinlambda), dydphi = 0.5 * F2 * (sin2phi * coslambda_2 + E22 * sin2lambda_2 * cosphi) + 0.5, denominator = dxdphi * dydlambda - dydphi * dxdlambda, dlambda = (fy * dxdphi - fx * dydphi) / denominator, dphi = (fx * dydlambda - fy * dxdlambda) / denominator;
+                lambda -= dlambda, phi -= dphi;
+              } while ((abs(dlambda) > epsilon || abs(dphi) > epsilon) && --i2 > 0);
+              return [lambda, phi];
+            };
+            function winkel3() {
+              return d3Geo.geoProjection(winkel3Raw).scale(158.837);
+            }
+            exports2.geoNaturalEarth = d3Geo.geoNaturalEarth1;
+            exports2.geoNaturalEarthRaw = d3Geo.geoNaturalEarth1Raw;
+            exports2.geoAiry = airy;
+            exports2.geoAiryRaw = airyRaw;
+            exports2.geoAitoff = aitoff;
+            exports2.geoAitoffRaw = aitoffRaw;
+            exports2.geoArmadillo = armadillo;
+            exports2.geoArmadilloRaw = armadilloRaw;
+            exports2.geoAugust = august;
+            exports2.geoAugustRaw = augustRaw;
+            exports2.geoBaker = baker;
+            exports2.geoBakerRaw = bakerRaw;
+            exports2.geoBerghaus = berghaus;
+            exports2.geoBerghausRaw = berghausRaw;
+            exports2.geoBertin1953 = bertin;
+            exports2.geoBertin1953Raw = bertin1953Raw;
+            exports2.geoBoggs = boggs;
+            exports2.geoBoggsRaw = boggsRaw;
+            exports2.geoBonne = bonne;
+            exports2.geoBonneRaw = bonneRaw;
+            exports2.geoBottomley = bottomley;
+            exports2.geoBottomleyRaw = bottomleyRaw;
+            exports2.geoBromley = bromley;
+            exports2.geoBromleyRaw = bromleyRaw;
+            exports2.geoChamberlin = chamberlin;
+            exports2.geoChamberlinRaw = chamberlinRaw;
+            exports2.geoChamberlinAfrica = chamberlinAfrica;
+            exports2.geoCollignon = collignon;
+            exports2.geoCollignonRaw = collignonRaw;
+            exports2.geoCraig = craig;
+            exports2.geoCraigRaw = craigRaw;
+            exports2.geoCraster = craster;
+            exports2.geoCrasterRaw = crasterRaw;
+            exports2.geoCylindricalEqualArea = cylindricalEqualArea;
+            exports2.geoCylindricalEqualAreaRaw = cylindricalEqualAreaRaw;
+            exports2.geoCylindricalStereographic = cylindricalStereographic;
+            exports2.geoCylindricalStereographicRaw = cylindricalStereographicRaw;
+            exports2.geoEckert1 = eckert1;
+            exports2.geoEckert1Raw = eckert1Raw;
+            exports2.geoEckert2 = eckert2;
+            exports2.geoEckert2Raw = eckert2Raw;
+            exports2.geoEckert3 = eckert3;
+            exports2.geoEckert3Raw = eckert3Raw;
+            exports2.geoEckert4 = eckert4;
+            exports2.geoEckert4Raw = eckert4Raw;
+            exports2.geoEckert5 = eckert5;
+            exports2.geoEckert5Raw = eckert5Raw;
+            exports2.geoEckert6 = eckert6;
+            exports2.geoEckert6Raw = eckert6Raw;
+            exports2.geoEisenlohr = eisenlohr;
+            exports2.geoEisenlohrRaw = eisenlohrRaw;
+            exports2.geoFahey = fahey;
+            exports2.geoFaheyRaw = faheyRaw;
+            exports2.geoFoucaut = foucaut;
+            exports2.geoFoucautRaw = foucautRaw;
+            exports2.geoFoucautSinusoidal = foucautSinusoidal;
+            exports2.geoFoucautSinusoidalRaw = foucautSinusoidalRaw;
+            exports2.geoGilbert = gilbert;
+            exports2.geoGingery = gingery;
+            exports2.geoGingeryRaw = gingeryRaw;
+            exports2.geoGinzburg4 = ginzburg4;
+            exports2.geoGinzburg4Raw = ginzburg4Raw;
+            exports2.geoGinzburg5 = ginzburg5;
+            exports2.geoGinzburg5Raw = ginzburg5Raw;
+            exports2.geoGinzburg6 = ginzburg6;
+            exports2.geoGinzburg6Raw = ginzburg6Raw;
+            exports2.geoGinzburg8 = ginzburg8;
+            exports2.geoGinzburg8Raw = ginzburg8Raw;
+            exports2.geoGinzburg9 = ginzburg9;
+            exports2.geoGinzburg9Raw = ginzburg9Raw;
+            exports2.geoGringorten = gringorten;
+            exports2.geoGringortenRaw = gringortenRaw;
+            exports2.geoGuyou = guyou;
+            exports2.geoGuyouRaw = guyouRaw;
+            exports2.geoHammer = hammer;
+            exports2.geoHammerRaw = hammerRaw;
+            exports2.geoHammerRetroazimuthal = hammerRetroazimuthal;
+            exports2.geoHammerRetroazimuthalRaw = hammerRetroazimuthalRaw;
+            exports2.geoHealpix = healpix;
+            exports2.geoHealpixRaw = healpixRaw;
+            exports2.geoHill = hill;
+            exports2.geoHillRaw = hillRaw;
+            exports2.geoHomolosine = homolosine;
+            exports2.geoHomolosineRaw = homolosineRaw;
+            exports2.geoHufnagel = hufnagel;
+            exports2.geoHufnagelRaw = hufnagelRaw;
+            exports2.geoHyperelliptical = hyperelliptical;
+            exports2.geoHyperellipticalRaw = hyperellipticalRaw;
+            exports2.geoInterrupt = interrupt;
+            exports2.geoInterruptedBoggs = boggs$1;
+            exports2.geoInterruptedHomolosine = homolosine$1;
+            exports2.geoInterruptedMollweide = mollweide$1;
+            exports2.geoInterruptedMollweideHemispheres = mollweideHemispheres;
+            exports2.geoInterruptedSinuMollweide = sinuMollweide$1;
+            exports2.geoInterruptedSinusoidal = sinusoidal$1;
+            exports2.geoKavrayskiy7 = kavrayskiy7;
+            exports2.geoKavrayskiy7Raw = kavrayskiy7Raw;
+            exports2.geoLagrange = lagrange;
+            exports2.geoLagrangeRaw = lagrangeRaw;
+            exports2.geoLarrivee = larrivee;
+            exports2.geoLarriveeRaw = larriveeRaw;
+            exports2.geoLaskowski = laskowski;
+            exports2.geoLaskowskiRaw = laskowskiRaw;
+            exports2.geoLittrow = littrow;
+            exports2.geoLittrowRaw = littrowRaw;
+            exports2.geoLoximuthal = loximuthal;
+            exports2.geoLoximuthalRaw = loximuthalRaw;
+            exports2.geoMiller = miller;
+            exports2.geoMillerRaw = millerRaw;
+            exports2.geoModifiedStereographic = modifiedStereographic;
+            exports2.geoModifiedStereographicRaw = modifiedStereographicRaw;
+            exports2.geoModifiedStereographicAlaska = modifiedStereographicAlaska;
+            exports2.geoModifiedStereographicGs48 = modifiedStereographicGs48;
+            exports2.geoModifiedStereographicGs50 = modifiedStereographicGs50;
+            exports2.geoModifiedStereographicMiller = modifiedStereographicMiller;
+            exports2.geoModifiedStereographicLee = modifiedStereographicLee;
+            exports2.geoMollweide = mollweide;
+            exports2.geoMollweideRaw = mollweideRaw;
+            exports2.geoMtFlatPolarParabolic = mtFlatPolarParabolic;
+            exports2.geoMtFlatPolarParabolicRaw = mtFlatPolarParabolicRaw;
+            exports2.geoMtFlatPolarQuartic = mtFlatPolarQuartic;
+            exports2.geoMtFlatPolarQuarticRaw = mtFlatPolarQuarticRaw;
+            exports2.geoMtFlatPolarSinusoidal = mtFlatPolarSinusoidal;
+            exports2.geoMtFlatPolarSinusoidalRaw = mtFlatPolarSinusoidalRaw;
+            exports2.geoNaturalEarth2 = naturalEarth2;
+            exports2.geoNaturalEarth2Raw = naturalEarth2Raw;
+            exports2.geoNellHammer = nellHammer;
+            exports2.geoNellHammerRaw = nellHammerRaw;
+            exports2.geoInterruptedQuarticAuthalic = quarticAuthalic;
+            exports2.geoNicolosi = nicolosi;
+            exports2.geoNicolosiRaw = nicolosiRaw;
+            exports2.geoPatterson = patterson;
+            exports2.geoPattersonRaw = pattersonRaw;
+            exports2.geoPolyconic = polyconic;
+            exports2.geoPolyconicRaw = polyconicRaw;
+            exports2.geoPolyhedral = polyhedral;
+            exports2.geoPolyhedralButterfly = butterfly;
+            exports2.geoPolyhedralCollignon = collignon$1;
+            exports2.geoPolyhedralWaterman = waterman;
+            exports2.geoProject = index;
+            exports2.geoGringortenQuincuncial = gringorten$1;
+            exports2.geoPeirceQuincuncial = peirce;
+            exports2.geoPierceQuincuncial = peirce;
+            exports2.geoQuantize = quantize;
+            exports2.geoQuincuncial = quincuncial;
+            exports2.geoRectangularPolyconic = rectangularPolyconic;
+            exports2.geoRectangularPolyconicRaw = rectangularPolyconicRaw;
+            exports2.geoRobinson = robinson;
+            exports2.geoRobinsonRaw = robinsonRaw;
+            exports2.geoSatellite = satellite;
+            exports2.geoSatelliteRaw = satelliteRaw;
+            exports2.geoSinuMollweide = sinuMollweide;
+            exports2.geoSinuMollweideRaw = sinuMollweideRaw;
+            exports2.geoSinusoidal = sinusoidal;
+            exports2.geoSinusoidalRaw = sinusoidalRaw;
+            exports2.geoStitch = stitch;
+            exports2.geoTimes = times;
+            exports2.geoTimesRaw = timesRaw;
+            exports2.geoTwoPointAzimuthal = twoPointAzimuthal;
+            exports2.geoTwoPointAzimuthalRaw = twoPointAzimuthalRaw;
+            exports2.geoTwoPointAzimuthalUsa = twoPointAzimuthalUsa;
+            exports2.geoTwoPointEquidistant = twoPointEquidistant;
+            exports2.geoTwoPointEquidistantRaw = twoPointEquidistantRaw;
+            exports2.geoTwoPointEquidistantUsa = twoPointEquidistantUsa;
+            exports2.geoVanDerGrinten = vanDerGrinten;
+            exports2.geoVanDerGrintenRaw = vanDerGrintenRaw;
+            exports2.geoVanDerGrinten2 = vanDerGrinten2;
+            exports2.geoVanDerGrinten2Raw = vanDerGrinten2Raw;
+            exports2.geoVanDerGrinten3 = vanDerGrinten3;
+            exports2.geoVanDerGrinten3Raw = vanDerGrinten3Raw;
+            exports2.geoVanDerGrinten4 = vanDerGrinten4;
+            exports2.geoVanDerGrinten4Raw = vanDerGrinten4Raw;
+            exports2.geoWagner = wagner;
+            exports2.geoWagner7 = wagner7;
+            exports2.geoWagnerRaw = wagnerRaw;
+            exports2.geoWagner4 = wagner4;
+            exports2.geoWagner4Raw = wagner4Raw;
+            exports2.geoWagner6 = wagner6;
+            exports2.geoWagner6Raw = wagner6Raw;
+            exports2.geoWiechel = wiechel;
+            exports2.geoWiechelRaw = wiechelRaw;
+            exports2.geoWinkel3 = winkel3;
+            exports2.geoWinkel3Raw = winkel3Raw;
+            Object.defineProperty(exports2, "__esModule", { value: true });
+          });
+        }
+      });
+      var require_zoom = __commonJS({
+        "src/plots/geo/zoom.js"(exports, module2) {
+          var d3 = require_d3();
+          var Lib = require_lib();
+          var Registry = require_registry();
+          var radians2 = Math.PI / 180;
+          var degrees3 = 180 / Math.PI;
+          var zoomstartStyle = { cursor: "pointer" };
+          var zoomendStyle = { cursor: "auto" };
+          function createGeoZoom(geo, geoLayout) {
+            var projection = geo.projection;
+            var zoomConstructor;
+            if (geoLayout._isScoped) {
+              zoomConstructor = zoomScoped;
+            } else if (geoLayout._isClipped) {
+              zoomConstructor = zoomClipped;
+            } else {
+              zoomConstructor = zoomNonClipped;
+            }
+            return zoomConstructor(geo, projection);
+          }
+          module2.exports = createGeoZoom;
+          function initZoom(geo, projection) {
+            return d3.behavior.zoom().translate(projection.translate()).scale(projection.scale());
+          }
+          function sync(geo, projection, cb2) {
+            var id2 = geo.id;
+            var gd2 = geo.graphDiv;
+            var layout = gd2.layout;
+            var userOpts = layout[id2];
+            var fullLayout = gd2._fullLayout;
+            var fullOpts = fullLayout[id2];
+            var preGUI = {};
+            var eventData = {};
+            function set(propStr, val) {
+              preGUI[id2 + "." + propStr] = Lib.nestedProperty(userOpts, propStr).get();
+              Registry.call("_storeDirectGUIEdit", layout, fullLayout._preGUI, preGUI);
+              var fullNp = Lib.nestedProperty(fullOpts, propStr);
+              if (fullNp.get() !== val) {
+                fullNp.set(val);
+                Lib.nestedProperty(userOpts, propStr).set(val);
+                eventData[id2 + "." + propStr] = val;
+              }
+            }
+            cb2(set);
+            set("projection.scale", projection.scale() / geo.fitScale);
+            set("fitbounds", false);
+            gd2.emit("plotly_relayout", eventData);
+          }
+          function zoomScoped(geo, projection) {
+            var zoom = initZoom(geo, projection);
+            function handleZoomstart() {
+              d3.select(this).style(zoomstartStyle);
+            }
+            function handleZoom() {
+              projection.scale(d3.event.scale).translate(d3.event.translate);
+              geo.render(true);
+              var center = projection.invert(geo.midPt);
+              geo.graphDiv.emit("plotly_relayouting", {
+                "geo.projection.scale": projection.scale() / geo.fitScale,
+                "geo.center.lon": center[0],
+                "geo.center.lat": center[1]
+              });
+            }
+            function syncCb(set) {
+              var center = projection.invert(geo.midPt);
+              set("center.lon", center[0]);
+              set("center.lat", center[1]);
+            }
+            function handleZoomend() {
+              d3.select(this).style(zoomendStyle);
+              sync(geo, projection, syncCb);
+            }
+            zoom.on("zoomstart", handleZoomstart).on("zoom", handleZoom).on("zoomend", handleZoomend);
+            return zoom;
+          }
+          function zoomNonClipped(geo, projection) {
+            var zoom = initZoom(geo, projection);
+            var INSIDETOLORANCEPXS = 2;
+            var mouse0, rotate0, translate0, lastRotate, zoomPoint, mouse1, rotate1, point1, didZoom;
+            function position2(x2) {
+              return projection.invert(x2);
+            }
+            function outside(x2) {
+              var pos = position2(x2);
+              if (!pos) return true;
+              var pt2 = projection(pos);
+              return Math.abs(pt2[0] - x2[0]) > INSIDETOLORANCEPXS || Math.abs(pt2[1] - x2[1]) > INSIDETOLORANCEPXS;
+            }
+            function handleZoomstart() {
+              d3.select(this).style(zoomstartStyle);
+              mouse0 = d3.mouse(this);
+              rotate0 = projection.rotate();
+              translate0 = projection.translate();
+              lastRotate = rotate0;
+              zoomPoint = position2(mouse0);
+            }
+            function handleZoom() {
+              mouse1 = d3.mouse(this);
+              if (outside(mouse0)) {
+                zoom.scale(projection.scale());
+                zoom.translate(projection.translate());
+                return;
+              }
+              projection.scale(d3.event.scale);
+              projection.translate([translate0[0], d3.event.translate[1]]);
+              if (!zoomPoint) {
+                mouse0 = mouse1;
+                zoomPoint = position2(mouse0);
+              } else if (position2(mouse1)) {
+                point1 = position2(mouse1);
+                rotate1 = [lastRotate[0] + (point1[0] - zoomPoint[0]), rotate0[1], rotate0[2]];
+                projection.rotate(rotate1);
+                lastRotate = rotate1;
+              }
+              didZoom = true;
+              geo.render(true);
+              var rotate2 = projection.rotate();
+              var center = projection.invert(geo.midPt);
+              geo.graphDiv.emit("plotly_relayouting", {
+                "geo.projection.scale": projection.scale() / geo.fitScale,
+                "geo.center.lon": center[0],
+                "geo.center.lat": center[1],
+                "geo.projection.rotation.lon": -rotate2[0]
+              });
+            }
+            function handleZoomend() {
+              d3.select(this).style(zoomendStyle);
+              if (didZoom) sync(geo, projection, syncCb);
+            }
+            function syncCb(set) {
+              var rotate2 = projection.rotate();
+              var center = projection.invert(geo.midPt);
+              set("projection.rotation.lon", -rotate2[0]);
+              set("center.lon", center[0]);
+              set("center.lat", center[1]);
+            }
+            zoom.on("zoomstart", handleZoomstart).on("zoom", handleZoom).on("zoomend", handleZoomend);
+            return zoom;
+          }
+          function zoomClipped(geo, projection) {
+            ({ r: projection.rotate(), k: projection.scale() });
+            var zoom = initZoom(geo, projection);
+            var event = d3eventDispatch(zoom, "zoomstart", "zoom", "zoomend");
+            var zooming = 0;
+            var zoomOn = zoom.on;
+            var zoomPoint;
+            zoom.on("zoomstart", function() {
+              d3.select(this).style(zoomstartStyle);
+              var mouse0 = d3.mouse(this);
+              var rotate0 = projection.rotate();
+              var lastRotate = rotate0;
+              var translate0 = projection.translate();
+              var q2 = quaternionFromEuler(rotate0);
+              zoomPoint = position(projection, mouse0);
+              zoomOn.call(zoom, "zoom", function() {
+                var mouse1 = d3.mouse(this);
+                projection.scale(d3.event.scale);
+                if (!zoomPoint) {
+                  mouse0 = mouse1;
+                  zoomPoint = position(projection, mouse0);
+                } else if (position(projection, mouse1)) {
+                  projection.rotate(rotate0).translate(translate0);
+                  var point1 = position(projection, mouse1);
+                  var between = rotateBetween(zoomPoint, point1);
+                  var newEuler = eulerFromQuaternion(multiply2(q2, between));
+                  var rotateAngles = unRoll(newEuler, zoomPoint, lastRotate);
+                  if (!isFinite(rotateAngles[0]) || !isFinite(rotateAngles[1]) || !isFinite(rotateAngles[2])) {
+                    rotateAngles = lastRotate;
+                  }
+                  projection.rotate(rotateAngles);
+                  lastRotate = rotateAngles;
+                }
+                zoomed(event.of(this, arguments));
+              });
+              zoomstarted(event.of(this, arguments));
+            }).on("zoomend", function() {
+              d3.select(this).style(zoomendStyle);
+              zoomOn.call(zoom, "zoom", null);
+              zoomended(event.of(this, arguments));
+              sync(geo, projection, syncCb);
+            }).on("zoom.redraw", function() {
+              geo.render(true);
+              var _rotate = projection.rotate();
+              geo.graphDiv.emit("plotly_relayouting", {
+                "geo.projection.scale": projection.scale() / geo.fitScale,
+                "geo.projection.rotation.lon": -_rotate[0],
+                "geo.projection.rotation.lat": -_rotate[1]
+              });
+            });
+            function zoomstarted(dispatch) {
+              if (!zooming++) dispatch({ type: "zoomstart" });
+            }
+            function zoomed(dispatch) {
+              dispatch({ type: "zoom" });
+            }
+            function zoomended(dispatch) {
+              if (!--zooming) dispatch({ type: "zoomend" });
+            }
+            function syncCb(set) {
+              var _rotate = projection.rotate();
+              set("projection.rotation.lon", -_rotate[0]);
+              set("projection.rotation.lat", -_rotate[1]);
+            }
+            return d3.rebind(zoom, event, "on");
+          }
+          function position(projection, point) {
+            var spherical = projection.invert(point);
+            return spherical && isFinite(spherical[0]) && isFinite(spherical[1]) && cartesian(spherical);
+          }
+          function quaternionFromEuler(euler) {
+            var lambda = 0.5 * euler[0] * radians2;
+            var phi = 0.5 * euler[1] * radians2;
+            var gamma2 = 0.5 * euler[2] * radians2;
+            var sinLambda = Math.sin(lambda);
+            var cosLambda = Math.cos(lambda);
+            var sinPhi = Math.sin(phi);
+            var cosPhi = Math.cos(phi);
+            var sinGamma = Math.sin(gamma2);
+            var cosGamma = Math.cos(gamma2);
+            return [
+              cosLambda * cosPhi * cosGamma + sinLambda * sinPhi * sinGamma,
+              sinLambda * cosPhi * cosGamma - cosLambda * sinPhi * sinGamma,
+              cosLambda * sinPhi * cosGamma + sinLambda * cosPhi * sinGamma,
+              cosLambda * cosPhi * sinGamma - sinLambda * sinPhi * cosGamma
+            ];
+          }
+          function multiply2(a2, b2) {
+            var a0 = a2[0];
+            var a1 = a2[1];
+            var a22 = a2[2];
+            var a3 = a2[3];
+            var b0 = b2[0];
+            var b1 = b2[1];
+            var b22 = b2[2];
+            var b3 = b2[3];
+            return [
+              a0 * b0 - a1 * b1 - a22 * b22 - a3 * b3,
+              a0 * b1 + a1 * b0 + a22 * b3 - a3 * b22,
+              a0 * b22 - a1 * b3 + a22 * b0 + a3 * b1,
+              a0 * b3 + a1 * b22 - a22 * b1 + a3 * b0
+            ];
+          }
+          function rotateBetween(a2, b2) {
+            if (!a2 || !b2) return;
+            var axis = cross2(a2, b2);
+            var norm = Math.sqrt(dot2(axis, axis));
+            var halfgamma = 0.5 * Math.acos(Math.max(-1, Math.min(1, dot2(a2, b2))));
+            var k2 = Math.sin(halfgamma) / norm;
+            return norm && [Math.cos(halfgamma), axis[2] * k2, -axis[1] * k2, axis[0] * k2];
+          }
+          function unRoll(rotateAngles, pt2, lastRotate) {
+            var ptRotated = rotateCartesian(pt2, 2, rotateAngles[0]);
+            ptRotated = rotateCartesian(ptRotated, 1, rotateAngles[1]);
+            ptRotated = rotateCartesian(ptRotated, 0, rotateAngles[2] - lastRotate[2]);
+            var x2 = pt2[0];
+            var y2 = pt2[1];
+            var z2 = pt2[2];
+            var f2 = ptRotated[0];
+            var g2 = ptRotated[1];
+            var h2 = ptRotated[2];
+            var theta = Math.atan2(y2, x2) * degrees3;
+            var a2 = Math.sqrt(x2 * x2 + y2 * y2);
+            var b2;
+            var newYaw1;
+            if (Math.abs(g2) > a2) {
+              newYaw1 = (g2 > 0 ? 90 : -90) - theta;
+              b2 = 0;
+            } else {
+              newYaw1 = Math.asin(g2 / a2) * degrees3 - theta;
+              b2 = Math.sqrt(a2 * a2 - g2 * g2);
+            }
+            var newYaw2 = 180 - newYaw1 - 2 * theta;
+            var newPitch1 = (Math.atan2(h2, f2) - Math.atan2(z2, b2)) * degrees3;
+            var newPitch2 = (Math.atan2(h2, f2) - Math.atan2(z2, -b2)) * degrees3;
+            var dist1 = angleDistance(lastRotate[0], lastRotate[1], newYaw1, newPitch1);
+            var dist2 = angleDistance(lastRotate[0], lastRotate[1], newYaw2, newPitch2);
+            if (dist1 <= dist2) return [newYaw1, newPitch1, lastRotate[2]];
+            else return [newYaw2, newPitch2, lastRotate[2]];
+          }
+          function angleDistance(yaw0, pitch0, yaw1, pitch1) {
+            var dYaw = angleMod(yaw1 - yaw0);
+            var dPitch = angleMod(pitch1 - pitch0);
+            return Math.sqrt(dYaw * dYaw + dPitch * dPitch);
+          }
+          function angleMod(angle2) {
+            return (angle2 % 360 + 540) % 360 - 180;
+          }
+          function rotateCartesian(vector, axis, angle2) {
+            var angleRads = angle2 * radians2;
+            var vectorOut = vector.slice();
+            var ax1 = axis === 0 ? 1 : 0;
+            var ax2 = axis === 2 ? 1 : 2;
+            var cosa = Math.cos(angleRads);
+            var sina = Math.sin(angleRads);
+            vectorOut[ax1] = vector[ax1] * cosa - vector[ax2] * sina;
+            vectorOut[ax2] = vector[ax2] * cosa + vector[ax1] * sina;
+            return vectorOut;
+          }
+          function eulerFromQuaternion(q2) {
+            return [
+              Math.atan2(2 * (q2[0] * q2[1] + q2[2] * q2[3]), 1 - 2 * (q2[1] * q2[1] + q2[2] * q2[2])) * degrees3,
+              Math.asin(Math.max(-1, Math.min(1, 2 * (q2[0] * q2[2] - q2[3] * q2[1])))) * degrees3,
+              Math.atan2(2 * (q2[0] * q2[3] + q2[1] * q2[2]), 1 - 2 * (q2[2] * q2[2] + q2[3] * q2[3])) * degrees3
+            ];
+          }
+          function cartesian(spherical) {
+            var lambda = spherical[0] * radians2;
+            var phi = spherical[1] * radians2;
+            var cosPhi = Math.cos(phi);
+            return [
+              cosPhi * Math.cos(lambda),
+              cosPhi * Math.sin(lambda),
+              Math.sin(phi)
+            ];
+          }
+          function dot2(a2, b2) {
+            var s2 = 0;
+            for (var i2 = 0, n2 = a2.length; i2 < n2; ++i2) s2 += a2[i2] * b2[i2];
+            return s2;
+          }
+          function cross2(a2, b2) {
+            return [
+              a2[1] * b2[2] - a2[2] * b2[1],
+              a2[2] * b2[0] - a2[0] * b2[2],
+              a2[0] * b2[1] - a2[1] * b2[0]
+            ];
+          }
+          function d3eventDispatch(target) {
+            var i2 = 0;
+            var n2 = arguments.length;
+            var argumentz = [];
+            while (++i2 < n2) argumentz.push(arguments[i2]);
+            var dispatch = d3.dispatch.apply(null, argumentz);
+            dispatch.of = function(thiz, argumentz2) {
+              return function(e1) {
+                var e0;
+                try {
+                  e0 = e1.sourceEvent = d3.event;
+                  e1.target = target;
+                  d3.event = e1;
+                  dispatch[e1.type].apply(thiz, argumentz2);
+                } finally {
+                  d3.event = e0;
+                }
+              };
+            };
+            return dispatch;
           }
-          return valueOrDefault(local, target);
-        },
-        set(value) {
-          this[privateName] = value;
         }
-      }
-    });
-  }
-  apply(appliers) {
-    appliers.forEach((apply) => apply(this));
-  }
-}
-var defaults = /* @__PURE__ */ new Defaults({
-  _scriptable: (name) => !name.startsWith("on"),
-  _indexable: (name) => name !== "events",
-  hover: {
-    _fallback: "interaction"
-  },
-  interaction: {
-    _scriptable: false,
-    _indexable: false
-  }
-}, [
-  applyAnimationsDefaults,
-  applyLayoutsDefaults,
-  applyScaleDefaults
-]);
-function toFontString(font) {
-  if (!font || isNullOrUndef(font.size) || isNullOrUndef(font.family)) {
-    return null;
-  }
-  return (font.style ? font.style + " " : "") + (font.weight ? font.weight + " " : "") + font.size + "px " + font.family;
-}
-function _measureText(ctx, data, gc2, longest, string) {
-  let textWidth = data[string];
-  if (!textWidth) {
-    textWidth = data[string] = ctx.measureText(string).width;
-    gc2.push(string);
-  }
-  if (textWidth > longest) {
-    longest = textWidth;
-  }
-  return longest;
-}
-function _alignPixel(chart, pixel, width) {
-  const devicePixelRatio = chart.currentDevicePixelRatio;
-  const halfWidth = width !== 0 ? Math.max(width / 2, 0.5) : 0;
-  return Math.round((pixel - halfWidth) * devicePixelRatio) / devicePixelRatio + halfWidth;
-}
-function clearCanvas(canvas, ctx) {
-  if (!ctx && !canvas) {
-    return;
-  }
-  ctx = ctx || canvas.getContext("2d");
-  ctx.save();
-  ctx.resetTransform();
-  ctx.clearRect(0, 0, canvas.width, canvas.height);
-  ctx.restore();
-}
-function drawPoint(ctx, options, x2, y2) {
-  drawPointLegend(ctx, options, x2, y2, null);
-}
-function drawPointLegend(ctx, options, x2, y2, w2) {
-  let type, xOffset, yOffset, size, cornerRadius, width, xOffsetW, yOffsetW;
-  const style = options.pointStyle;
-  const rotation = options.rotation;
-  const radius = options.radius;
-  let rad = (rotation || 0) * RAD_PER_DEG;
-  if (style && typeof style === "object") {
-    type = style.toString();
-    if (type === "[object HTMLImageElement]" || type === "[object HTMLCanvasElement]") {
-      ctx.save();
-      ctx.translate(x2, y2);
-      ctx.rotate(rad);
-      ctx.drawImage(style, -style.width / 2, -style.height / 2, style.width, style.height);
-      ctx.restore();
-      return;
-    }
-  }
-  if (isNaN(radius) || radius <= 0) {
-    return;
-  }
-  ctx.beginPath();
-  switch (style) {
-    default:
-      if (w2) {
-        ctx.ellipse(x2, y2, w2 / 2, radius, 0, 0, TAU);
-      } else {
-        ctx.arc(x2, y2, radius, 0, TAU);
-      }
-      ctx.closePath();
-      break;
-    case "triangle":
-      width = w2 ? w2 / 2 : radius;
-      ctx.moveTo(x2 + Math.sin(rad) * width, y2 - Math.cos(rad) * radius);
-      rad += TWO_THIRDS_PI;
-      ctx.lineTo(x2 + Math.sin(rad) * width, y2 - Math.cos(rad) * radius);
-      rad += TWO_THIRDS_PI;
-      ctx.lineTo(x2 + Math.sin(rad) * width, y2 - Math.cos(rad) * radius);
-      ctx.closePath();
-      break;
-    case "rectRounded":
-      cornerRadius = radius * 0.516;
-      size = radius - cornerRadius;
-      xOffset = Math.cos(rad + QUARTER_PI) * size;
-      xOffsetW = Math.cos(rad + QUARTER_PI) * (w2 ? w2 / 2 - cornerRadius : size);
-      yOffset = Math.sin(rad + QUARTER_PI) * size;
-      yOffsetW = Math.sin(rad + QUARTER_PI) * (w2 ? w2 / 2 - cornerRadius : size);
-      ctx.arc(x2 - xOffsetW, y2 - yOffset, cornerRadius, rad - PI, rad - HALF_PI);
-      ctx.arc(x2 + yOffsetW, y2 - xOffset, cornerRadius, rad - HALF_PI, rad);
-      ctx.arc(x2 + xOffsetW, y2 + yOffset, cornerRadius, rad, rad + HALF_PI);
-      ctx.arc(x2 - yOffsetW, y2 + xOffset, cornerRadius, rad + HALF_PI, rad + PI);
-      ctx.closePath();
-      break;
-    case "rect":
-      if (!rotation) {
-        size = Math.SQRT1_2 * radius;
-        width = w2 ? w2 / 2 : size;
-        ctx.rect(x2 - width, y2 - size, 2 * width, 2 * size);
-        break;
-      }
-      rad += QUARTER_PI;
-    case "rectRot":
-      xOffsetW = Math.cos(rad) * (w2 ? w2 / 2 : radius);
-      xOffset = Math.cos(rad) * radius;
-      yOffset = Math.sin(rad) * radius;
-      yOffsetW = Math.sin(rad) * (w2 ? w2 / 2 : radius);
-      ctx.moveTo(x2 - xOffsetW, y2 - yOffset);
-      ctx.lineTo(x2 + yOffsetW, y2 - xOffset);
-      ctx.lineTo(x2 + xOffsetW, y2 + yOffset);
-      ctx.lineTo(x2 - yOffsetW, y2 + xOffset);
-      ctx.closePath();
-      break;
-    case "crossRot":
-      rad += QUARTER_PI;
-    case "cross":
-      xOffsetW = Math.cos(rad) * (w2 ? w2 / 2 : radius);
-      xOffset = Math.cos(rad) * radius;
-      yOffset = Math.sin(rad) * radius;
-      yOffsetW = Math.sin(rad) * (w2 ? w2 / 2 : radius);
-      ctx.moveTo(x2 - xOffsetW, y2 - yOffset);
-      ctx.lineTo(x2 + xOffsetW, y2 + yOffset);
-      ctx.moveTo(x2 + yOffsetW, y2 - xOffset);
-      ctx.lineTo(x2 - yOffsetW, y2 + xOffset);
-      break;
-    case "star":
-      xOffsetW = Math.cos(rad) * (w2 ? w2 / 2 : radius);
-      xOffset = Math.cos(rad) * radius;
-      yOffset = Math.sin(rad) * radius;
-      yOffsetW = Math.sin(rad) * (w2 ? w2 / 2 : radius);
-      ctx.moveTo(x2 - xOffsetW, y2 - yOffset);
-      ctx.lineTo(x2 + xOffsetW, y2 + yOffset);
-      ctx.moveTo(x2 + yOffsetW, y2 - xOffset);
-      ctx.lineTo(x2 - yOffsetW, y2 + xOffset);
-      rad += QUARTER_PI;
-      xOffsetW = Math.cos(rad) * (w2 ? w2 / 2 : radius);
-      xOffset = Math.cos(rad) * radius;
-      yOffset = Math.sin(rad) * radius;
-      yOffsetW = Math.sin(rad) * (w2 ? w2 / 2 : radius);
-      ctx.moveTo(x2 - xOffsetW, y2 - yOffset);
-      ctx.lineTo(x2 + xOffsetW, y2 + yOffset);
-      ctx.moveTo(x2 + yOffsetW, y2 - xOffset);
-      ctx.lineTo(x2 - yOffsetW, y2 + xOffset);
-      break;
-    case "line":
-      xOffset = w2 ? w2 / 2 : Math.cos(rad) * radius;
-      yOffset = Math.sin(rad) * radius;
-      ctx.moveTo(x2 - xOffset, y2 - yOffset);
-      ctx.lineTo(x2 + xOffset, y2 + yOffset);
-      break;
-    case "dash":
-      ctx.moveTo(x2, y2);
-      ctx.lineTo(x2 + Math.cos(rad) * (w2 ? w2 / 2 : radius), y2 + Math.sin(rad) * radius);
-      break;
-    case false:
-      ctx.closePath();
-      break;
-  }
-  ctx.fill();
-  if (options.borderWidth > 0) {
-    ctx.stroke();
-  }
-}
-function _isPointInArea(point, area, margin) {
-  margin = margin || 0.5;
-  return !area || point && point.x > area.left - margin && point.x < area.right + margin && point.y > area.top - margin && point.y < area.bottom + margin;
-}
-function clipArea(ctx, area) {
-  ctx.save();
-  ctx.beginPath();
-  ctx.rect(area.left, area.top, area.right - area.left, area.bottom - area.top);
-  ctx.clip();
-}
-function unclipArea(ctx) {
-  ctx.restore();
-}
-function _steppedLineTo(ctx, previous, target, flip, mode) {
-  if (!previous) {
-    return ctx.lineTo(target.x, target.y);
-  }
-  if (mode === "middle") {
-    const midpoint = (previous.x + target.x) / 2;
-    ctx.lineTo(midpoint, previous.y);
-    ctx.lineTo(midpoint, target.y);
-  } else if (mode === "after" !== !!flip) {
-    ctx.lineTo(previous.x, target.y);
-  } else {
-    ctx.lineTo(target.x, previous.y);
-  }
-  ctx.lineTo(target.x, target.y);
-}
-function _bezierCurveTo(ctx, previous, target, flip) {
-  if (!previous) {
-    return ctx.lineTo(target.x, target.y);
-  }
-  ctx.bezierCurveTo(flip ? previous.cp1x : previous.cp2x, flip ? previous.cp1y : previous.cp2y, flip ? target.cp2x : target.cp1x, flip ? target.cp2y : target.cp1y, target.x, target.y);
-}
-function setRenderOpts(ctx, opts) {
-  if (opts.translation) {
-    ctx.translate(opts.translation[0], opts.translation[1]);
-  }
-  if (!isNullOrUndef(opts.rotation)) {
-    ctx.rotate(opts.rotation);
-  }
-  if (opts.color) {
-    ctx.fillStyle = opts.color;
-  }
-  if (opts.textAlign) {
-    ctx.textAlign = opts.textAlign;
-  }
-  if (opts.textBaseline) {
-    ctx.textBaseline = opts.textBaseline;
-  }
-}
-function decorateText(ctx, x2, y2, line, opts) {
-  if (opts.strikethrough || opts.underline) {
-    const metrics = ctx.measureText(line);
-    const left = x2 - metrics.actualBoundingBoxLeft;
-    const right = x2 + metrics.actualBoundingBoxRight;
-    const top = y2 - metrics.actualBoundingBoxAscent;
-    const bottom = y2 + metrics.actualBoundingBoxDescent;
-    const yDecoration = opts.strikethrough ? (top + bottom) / 2 : bottom;
-    ctx.strokeStyle = ctx.fillStyle;
-    ctx.beginPath();
-    ctx.lineWidth = opts.decorationWidth || 2;
-    ctx.moveTo(left, yDecoration);
-    ctx.lineTo(right, yDecoration);
-    ctx.stroke();
-  }
-}
-function drawBackdrop(ctx, opts) {
-  const oldColor = ctx.fillStyle;
-  ctx.fillStyle = opts.color;
-  ctx.fillRect(opts.left, opts.top, opts.width, opts.height);
-  ctx.fillStyle = oldColor;
-}
-function renderText(ctx, text, x2, y2, font, opts = {}) {
-  const lines = isArray(text) ? text : [
-    text
-  ];
-  const stroke = opts.strokeWidth > 0 && opts.strokeColor !== "";
-  let i, line;
-  ctx.save();
-  ctx.font = font.string;
-  setRenderOpts(ctx, opts);
-  for (i = 0; i < lines.length; ++i) {
-    line = lines[i];
-    if (opts.backdrop) {
-      drawBackdrop(ctx, opts.backdrop);
-    }
-    if (stroke) {
-      if (opts.strokeColor) {
-        ctx.strokeStyle = opts.strokeColor;
-      }
-      if (!isNullOrUndef(opts.strokeWidth)) {
-        ctx.lineWidth = opts.strokeWidth;
-      }
-      ctx.strokeText(line, x2, y2, opts.maxWidth);
-    }
-    ctx.fillText(line, x2, y2, opts.maxWidth);
-    decorateText(ctx, x2, y2, line, opts);
-    y2 += Number(font.lineHeight);
-  }
-  ctx.restore();
-}
-function addRoundedRectPath(ctx, rect) {
-  const { x: x2, y: y2, w: w2, h, radius } = rect;
-  ctx.arc(x2 + radius.topLeft, y2 + radius.topLeft, radius.topLeft, 1.5 * PI, PI, true);
-  ctx.lineTo(x2, y2 + h - radius.bottomLeft);
-  ctx.arc(x2 + radius.bottomLeft, y2 + h - radius.bottomLeft, radius.bottomLeft, PI, HALF_PI, true);
-  ctx.lineTo(x2 + w2 - radius.bottomRight, y2 + h);
-  ctx.arc(x2 + w2 - radius.bottomRight, y2 + h - radius.bottomRight, radius.bottomRight, HALF_PI, 0, true);
-  ctx.lineTo(x2 + w2, y2 + radius.topRight);
-  ctx.arc(x2 + w2 - radius.topRight, y2 + radius.topRight, radius.topRight, 0, -HALF_PI, true);
-  ctx.lineTo(x2 + radius.topLeft, y2);
-}
-const LINE_HEIGHT = /^(normal|(\d+(?:\.\d+)?)(px|em|%)?)$/;
-const FONT_STYLE = /^(normal|italic|initial|inherit|unset|(oblique( -?[0-9]?[0-9]deg)?))$/;
-function toLineHeight(value, size) {
-  const matches = ("" + value).match(LINE_HEIGHT);
-  if (!matches || matches[1] === "normal") {
-    return size * 1.2;
-  }
-  value = +matches[2];
-  switch (matches[3]) {
-    case "px":
-      return value;
-    case "%":
-      value /= 100;
-      break;
-  }
-  return size * value;
-}
-const numberOrZero = (v2) => +v2 || 0;
-function _readValueToProps(value, props) {
-  const ret = {};
-  const objProps = isObject(props);
-  const keys = objProps ? Object.keys(props) : props;
-  const read = isObject(value) ? objProps ? (prop) => valueOrDefault(value[prop], value[props[prop]]) : (prop) => value[prop] : () => value;
-  for (const prop of keys) {
-    ret[prop] = numberOrZero(read(prop));
-  }
-  return ret;
-}
-function toTRBL(value) {
-  return _readValueToProps(value, {
-    top: "y",
-    right: "x",
-    bottom: "y",
-    left: "x"
-  });
-}
-function toTRBLCorners(value) {
-  return _readValueToProps(value, [
-    "topLeft",
-    "topRight",
-    "bottomLeft",
-    "bottomRight"
-  ]);
-}
-function toPadding(value) {
-  const obj = toTRBL(value);
-  obj.width = obj.left + obj.right;
-  obj.height = obj.top + obj.bottom;
-  return obj;
-}
-function toFont(options, fallback) {
-  options = options || {};
-  fallback = fallback || defaults.font;
-  let size = valueOrDefault(options.size, fallback.size);
-  if (typeof size === "string") {
-    size = parseInt(size, 10);
-  }
-  let style = valueOrDefault(options.style, fallback.style);
-  if (style && !("" + style).match(FONT_STYLE)) {
-    console.warn('Invalid font style specified: "' + style + '"');
-    style = void 0;
-  }
-  const font = {
-    family: valueOrDefault(options.family, fallback.family),
-    lineHeight: toLineHeight(valueOrDefault(options.lineHeight, fallback.lineHeight), size),
-    size,
-    style,
-    weight: valueOrDefault(options.weight, fallback.weight),
-    string: ""
-  };
-  font.string = toFontString(font);
-  return font;
-}
-function resolve(inputs, context, index, info) {
-  let i, ilen, value;
-  for (i = 0, ilen = inputs.length; i < ilen; ++i) {
-    value = inputs[i];
-    if (value === void 0) {
-      continue;
-    }
-    if (value !== void 0) {
-      return value;
-    }
-  }
-}
-function _addGrace(minmax, grace, beginAtZero) {
-  const { min, max } = minmax;
-  const change = toDimension(grace, (max - min) / 2);
-  const keepZero = (value, add) => beginAtZero && value === 0 ? 0 : value + add;
-  return {
-    min: keepZero(min, -Math.abs(change)),
-    max: keepZero(max, change)
-  };
-}
-function createContext(parentContext, context) {
-  return Object.assign(Object.create(parentContext), context);
-}
-function _createResolver(scopes, prefixes = [
-  ""
-], rootScopes, fallback, getTarget = () => scopes[0]) {
-  const finalRootScopes = rootScopes || scopes;
-  if (typeof fallback === "undefined") {
-    fallback = _resolve("_fallback", scopes);
-  }
-  const cache = {
-    [Symbol.toStringTag]: "Object",
-    _cacheable: true,
-    _scopes: scopes,
-    _rootScopes: finalRootScopes,
-    _fallback: fallback,
-    _getTarget: getTarget,
-    override: (scope) => _createResolver([
-      scope,
-      ...scopes
-    ], prefixes, finalRootScopes, fallback)
-  };
-  return new Proxy(cache, {
-    /**
-    * A trap for the delete operator.
-    */
-    deleteProperty(target, prop) {
-      delete target[prop];
-      delete target._keys;
-      delete scopes[0][prop];
-      return true;
-    },
-    /**
-    * A trap for getting property values.
-    */
-    get(target, prop) {
-      return _cached(target, prop, () => _resolveWithPrefixes(prop, prefixes, scopes, target));
-    },
-    /**
-    * A trap for Object.getOwnPropertyDescriptor.
-    * Also used by Object.hasOwnProperty.
-    */
-    getOwnPropertyDescriptor(target, prop) {
-      return Reflect.getOwnPropertyDescriptor(target._scopes[0], prop);
-    },
-    /**
-    * A trap for Object.getPrototypeOf.
-    */
-    getPrototypeOf() {
-      return Reflect.getPrototypeOf(scopes[0]);
-    },
-    /**
-    * A trap for the in operator.
-    */
-    has(target, prop) {
-      return getKeysFromAllScopes(target).includes(prop);
-    },
-    /**
-    * A trap for Object.getOwnPropertyNames and Object.getOwnPropertySymbols.
-    */
-    ownKeys(target) {
-      return getKeysFromAllScopes(target);
-    },
-    /**
-    * A trap for setting property values.
-    */
-    set(target, prop, value) {
-      const storage = target._storage || (target._storage = getTarget());
-      target[prop] = storage[prop] = value;
-      delete target._keys;
-      return true;
-    }
-  });
-}
-function _attachContext(proxy, context, subProxy, descriptorDefaults) {
-  const cache = {
-    _cacheable: false,
-    _proxy: proxy,
-    _context: context,
-    _subProxy: subProxy,
-    _stack: /* @__PURE__ */ new Set(),
-    _descriptors: _descriptors(proxy, descriptorDefaults),
-    setContext: (ctx) => _attachContext(proxy, ctx, subProxy, descriptorDefaults),
-    override: (scope) => _attachContext(proxy.override(scope), context, subProxy, descriptorDefaults)
-  };
-  return new Proxy(cache, {
-    /**
-    * A trap for the delete operator.
-    */
-    deleteProperty(target, prop) {
-      delete target[prop];
-      delete proxy[prop];
-      return true;
-    },
-    /**
-    * A trap for getting property values.
-    */
-    get(target, prop, receiver) {
-      return _cached(target, prop, () => _resolveWithContext(target, prop, receiver));
-    },
-    /**
-    * A trap for Object.getOwnPropertyDescriptor.
-    * Also used by Object.hasOwnProperty.
-    */
-    getOwnPropertyDescriptor(target, prop) {
-      return target._descriptors.allKeys ? Reflect.has(proxy, prop) ? {
-        enumerable: true,
-        configurable: true
-      } : void 0 : Reflect.getOwnPropertyDescriptor(proxy, prop);
-    },
-    /**
-    * A trap for Object.getPrototypeOf.
-    */
-    getPrototypeOf() {
-      return Reflect.getPrototypeOf(proxy);
-    },
-    /**
-    * A trap for the in operator.
-    */
-    has(target, prop) {
-      return Reflect.has(proxy, prop);
-    },
-    /**
-    * A trap for Object.getOwnPropertyNames and Object.getOwnPropertySymbols.
-    */
-    ownKeys() {
-      return Reflect.ownKeys(proxy);
-    },
-    /**
-    * A trap for setting property values.
-    */
-    set(target, prop, value) {
-      proxy[prop] = value;
-      delete target[prop];
-      return true;
-    }
-  });
-}
-function _descriptors(proxy, defaults2 = {
-  scriptable: true,
-  indexable: true
-}) {
-  const { _scriptable = defaults2.scriptable, _indexable = defaults2.indexable, _allKeys = defaults2.allKeys } = proxy;
-  return {
-    allKeys: _allKeys,
-    scriptable: _scriptable,
-    indexable: _indexable,
-    isScriptable: isFunction(_scriptable) ? _scriptable : () => _scriptable,
-    isIndexable: isFunction(_indexable) ? _indexable : () => _indexable
-  };
-}
-const readKey = (prefix, name) => prefix ? prefix + _capitalize(name) : name;
-const needsSubResolver = (prop, value) => isObject(value) && prop !== "adapters" && (Object.getPrototypeOf(value) === null || value.constructor === Object);
-function _cached(target, prop, resolve2) {
-  if (Object.prototype.hasOwnProperty.call(target, prop) || prop === "constructor") {
-    return target[prop];
-  }
-  const value = resolve2();
-  target[prop] = value;
-  return value;
-}
-function _resolveWithContext(target, prop, receiver) {
-  const { _proxy, _context, _subProxy, _descriptors: descriptors2 } = target;
-  let value = _proxy[prop];
-  if (isFunction(value) && descriptors2.isScriptable(prop)) {
-    value = _resolveScriptable(prop, value, target, receiver);
-  }
-  if (isArray(value) && value.length) {
-    value = _resolveArray(prop, value, target, descriptors2.isIndexable);
-  }
-  if (needsSubResolver(prop, value)) {
-    value = _attachContext(value, _context, _subProxy && _subProxy[prop], descriptors2);
-  }
-  return value;
-}
-function _resolveScriptable(prop, getValue, target, receiver) {
-  const { _proxy, _context, _subProxy, _stack } = target;
-  if (_stack.has(prop)) {
-    throw new Error("Recursion detected: " + Array.from(_stack).join("->") + "->" + prop);
-  }
-  _stack.add(prop);
-  let value = getValue(_context, _subProxy || receiver);
-  _stack.delete(prop);
-  if (needsSubResolver(prop, value)) {
-    value = createSubResolver(_proxy._scopes, _proxy, prop, value);
-  }
-  return value;
-}
-function _resolveArray(prop, value, target, isIndexable) {
-  const { _proxy, _context, _subProxy, _descriptors: descriptors2 } = target;
-  if (typeof _context.index !== "undefined" && isIndexable(prop)) {
-    return value[_context.index % value.length];
-  } else if (isObject(value[0])) {
-    const arr = value;
-    const scopes = _proxy._scopes.filter((s) => s !== arr);
-    value = [];
-    for (const item of arr) {
-      const resolver = createSubResolver(scopes, _proxy, prop, item);
-      value.push(_attachContext(resolver, _context, _subProxy && _subProxy[prop], descriptors2));
-    }
-  }
-  return value;
-}
-function resolveFallback(fallback, prop, value) {
-  return isFunction(fallback) ? fallback(prop, value) : fallback;
-}
-const getScope = (key, parent) => key === true ? parent : typeof key === "string" ? resolveObjectKey(parent, key) : void 0;
-function addScopes(set2, parentScopes, key, parentFallback, value) {
-  for (const parent of parentScopes) {
-    const scope = getScope(key, parent);
-    if (scope) {
-      set2.add(scope);
-      const fallback = resolveFallback(scope._fallback, key, value);
-      if (typeof fallback !== "undefined" && fallback !== key && fallback !== parentFallback) {
-        return fallback;
-      }
-    } else if (scope === false && typeof parentFallback !== "undefined" && key !== parentFallback) {
-      return null;
-    }
-  }
-  return false;
-}
-function createSubResolver(parentScopes, resolver, prop, value) {
-  const rootScopes = resolver._rootScopes;
-  const fallback = resolveFallback(resolver._fallback, prop, value);
-  const allScopes = [
-    ...parentScopes,
-    ...rootScopes
-  ];
-  const set2 = /* @__PURE__ */ new Set();
-  set2.add(value);
-  let key = addScopesFromKey(set2, allScopes, prop, fallback || prop, value);
-  if (key === null) {
-    return false;
-  }
-  if (typeof fallback !== "undefined" && fallback !== prop) {
-    key = addScopesFromKey(set2, allScopes, fallback, key, value);
-    if (key === null) {
-      return false;
-    }
-  }
-  return _createResolver(Array.from(set2), [
-    ""
-  ], rootScopes, fallback, () => subGetTarget(resolver, prop, value));
-}
-function addScopesFromKey(set2, allScopes, key, fallback, item) {
-  while (key) {
-    key = addScopes(set2, allScopes, key, fallback, item);
-  }
-  return key;
-}
-function subGetTarget(resolver, prop, value) {
-  const parent = resolver._getTarget();
-  if (!(prop in parent)) {
-    parent[prop] = {};
-  }
-  const target = parent[prop];
-  if (isArray(target) && isObject(value)) {
-    return value;
-  }
-  return target || {};
-}
-function _resolveWithPrefixes(prop, prefixes, scopes, proxy) {
-  let value;
-  for (const prefix of prefixes) {
-    value = _resolve(readKey(prefix, prop), scopes);
-    if (typeof value !== "undefined") {
-      return needsSubResolver(prop, value) ? createSubResolver(scopes, proxy, prop, value) : value;
-    }
-  }
-}
-function _resolve(key, scopes) {
-  for (const scope of scopes) {
-    if (!scope) {
-      continue;
-    }
-    const value = scope[key];
-    if (typeof value !== "undefined") {
-      return value;
-    }
-  }
-}
-function getKeysFromAllScopes(target) {
-  let keys = target._keys;
-  if (!keys) {
-    keys = target._keys = resolveKeysFromAllScopes(target._scopes);
-  }
-  return keys;
-}
-function resolveKeysFromAllScopes(scopes) {
-  const set2 = /* @__PURE__ */ new Set();
-  for (const scope of scopes) {
-    for (const key of Object.keys(scope).filter((k2) => !k2.startsWith("_"))) {
-      set2.add(key);
-    }
-  }
-  return Array.from(set2);
-}
-const EPSILON = Number.EPSILON || 1e-14;
-const getPoint = (points, i) => i < points.length && !points[i].skip && points[i];
-const getValueAxis = (indexAxis) => indexAxis === "x" ? "y" : "x";
-function splineCurve(firstPoint, middlePoint, afterPoint, t2) {
-  const previous = firstPoint.skip ? middlePoint : firstPoint;
-  const current = middlePoint;
-  const next = afterPoint.skip ? middlePoint : afterPoint;
-  const d01 = distanceBetweenPoints(current, previous);
-  const d12 = distanceBetweenPoints(next, current);
-  let s01 = d01 / (d01 + d12);
-  let s12 = d12 / (d01 + d12);
-  s01 = isNaN(s01) ? 0 : s01;
-  s12 = isNaN(s12) ? 0 : s12;
-  const fa2 = t2 * s01;
-  const fb2 = t2 * s12;
-  return {
-    previous: {
-      x: current.x - fa2 * (next.x - previous.x),
-      y: current.y - fa2 * (next.y - previous.y)
-    },
-    next: {
-      x: current.x + fb2 * (next.x - previous.x),
-      y: current.y + fb2 * (next.y - previous.y)
-    }
-  };
-}
-function monotoneAdjust(points, deltaK, mK) {
-  const pointsLen = points.length;
-  let alphaK, betaK, tauK, squaredMagnitude, pointCurrent;
-  let pointAfter = getPoint(points, 0);
-  for (let i = 0; i < pointsLen - 1; ++i) {
-    pointCurrent = pointAfter;
-    pointAfter = getPoint(points, i + 1);
-    if (!pointCurrent || !pointAfter) {
-      continue;
-    }
-    if (almostEquals(deltaK[i], 0, EPSILON)) {
-      mK[i] = mK[i + 1] = 0;
-      continue;
-    }
-    alphaK = mK[i] / deltaK[i];
-    betaK = mK[i + 1] / deltaK[i];
-    squaredMagnitude = Math.pow(alphaK, 2) + Math.pow(betaK, 2);
-    if (squaredMagnitude <= 9) {
-      continue;
-    }
-    tauK = 3 / Math.sqrt(squaredMagnitude);
-    mK[i] = alphaK * tauK * deltaK[i];
-    mK[i + 1] = betaK * tauK * deltaK[i];
-  }
-}
-function monotoneCompute(points, mK, indexAxis = "x") {
-  const valueAxis = getValueAxis(indexAxis);
-  const pointsLen = points.length;
-  let delta, pointBefore, pointCurrent;
-  let pointAfter = getPoint(points, 0);
-  for (let i = 0; i < pointsLen; ++i) {
-    pointBefore = pointCurrent;
-    pointCurrent = pointAfter;
-    pointAfter = getPoint(points, i + 1);
-    if (!pointCurrent) {
-      continue;
-    }
-    const iPixel = pointCurrent[indexAxis];
-    const vPixel = pointCurrent[valueAxis];
-    if (pointBefore) {
-      delta = (iPixel - pointBefore[indexAxis]) / 3;
-      pointCurrent[`cp1${indexAxis}`] = iPixel - delta;
-      pointCurrent[`cp1${valueAxis}`] = vPixel - delta * mK[i];
-    }
-    if (pointAfter) {
-      delta = (pointAfter[indexAxis] - iPixel) / 3;
-      pointCurrent[`cp2${indexAxis}`] = iPixel + delta;
-      pointCurrent[`cp2${valueAxis}`] = vPixel + delta * mK[i];
-    }
-  }
-}
-function splineCurveMonotone(points, indexAxis = "x") {
-  const valueAxis = getValueAxis(indexAxis);
-  const pointsLen = points.length;
-  const deltaK = Array(pointsLen).fill(0);
-  const mK = Array(pointsLen);
-  let i, pointBefore, pointCurrent;
-  let pointAfter = getPoint(points, 0);
-  for (i = 0; i < pointsLen; ++i) {
-    pointBefore = pointCurrent;
-    pointCurrent = pointAfter;
-    pointAfter = getPoint(points, i + 1);
-    if (!pointCurrent) {
-      continue;
-    }
-    if (pointAfter) {
-      const slopeDelta = pointAfter[indexAxis] - pointCurrent[indexAxis];
-      deltaK[i] = slopeDelta !== 0 ? (pointAfter[valueAxis] - pointCurrent[valueAxis]) / slopeDelta : 0;
-    }
-    mK[i] = !pointBefore ? deltaK[i] : !pointAfter ? deltaK[i - 1] : sign(deltaK[i - 1]) !== sign(deltaK[i]) ? 0 : (deltaK[i - 1] + deltaK[i]) / 2;
-  }
-  monotoneAdjust(points, deltaK, mK);
-  monotoneCompute(points, mK, indexAxis);
-}
-function capControlPoint(pt, min, max) {
-  return Math.max(Math.min(pt, max), min);
-}
-function capBezierPoints(points, area) {
-  let i, ilen, point, inArea, inAreaPrev;
-  let inAreaNext = _isPointInArea(points[0], area);
-  for (i = 0, ilen = points.length; i < ilen; ++i) {
-    inAreaPrev = inArea;
-    inArea = inAreaNext;
-    inAreaNext = i < ilen - 1 && _isPointInArea(points[i + 1], area);
-    if (!inArea) {
-      continue;
-    }
-    point = points[i];
-    if (inAreaPrev) {
-      point.cp1x = capControlPoint(point.cp1x, area.left, area.right);
-      point.cp1y = capControlPoint(point.cp1y, area.top, area.bottom);
-    }
-    if (inAreaNext) {
-      point.cp2x = capControlPoint(point.cp2x, area.left, area.right);
-      point.cp2y = capControlPoint(point.cp2y, area.top, area.bottom);
-    }
-  }
-}
-function _updateBezierControlPoints(points, options, area, loop, indexAxis) {
-  let i, ilen, point, controlPoints;
-  if (options.spanGaps) {
-    points = points.filter((pt) => !pt.skip);
-  }
-  if (options.cubicInterpolationMode === "monotone") {
-    splineCurveMonotone(points, indexAxis);
-  } else {
-    let prev = loop ? points[points.length - 1] : points[0];
-    for (i = 0, ilen = points.length; i < ilen; ++i) {
-      point = points[i];
-      controlPoints = splineCurve(prev, point, points[Math.min(i + 1, ilen - (loop ? 0 : 1)) % ilen], options.tension);
-      point.cp1x = controlPoints.previous.x;
-      point.cp1y = controlPoints.previous.y;
-      point.cp2x = controlPoints.next.x;
-      point.cp2y = controlPoints.next.y;
-      prev = point;
-    }
-  }
-  if (options.capBezierPoints) {
-    capBezierPoints(points, area);
-  }
-}
-function _isDomSupported() {
-  return typeof window !== "undefined" && typeof document !== "undefined";
-}
-function _getParentNode(domNode) {
-  let parent = domNode.parentNode;
-  if (parent && parent.toString() === "[object ShadowRoot]") {
-    parent = parent.host;
-  }
-  return parent;
-}
-function parseMaxStyle(styleValue, node, parentProperty) {
-  let valueInPixels;
-  if (typeof styleValue === "string") {
-    valueInPixels = parseInt(styleValue, 10);
-    if (styleValue.indexOf("%") !== -1) {
-      valueInPixels = valueInPixels / 100 * node.parentNode[parentProperty];
-    }
-  } else {
-    valueInPixels = styleValue;
-  }
-  return valueInPixels;
-}
-const getComputedStyle = (element) => element.ownerDocument.defaultView.getComputedStyle(element, null);
-function getStyle(el2, property) {
-  return getComputedStyle(el2).getPropertyValue(property);
-}
-const positions = [
-  "top",
-  "right",
-  "bottom",
-  "left"
-];
-function getPositionedStyle(styles, style, suffix) {
-  const result = {};
-  suffix = suffix ? "-" + suffix : "";
-  for (let i = 0; i < 4; i++) {
-    const pos = positions[i];
-    result[pos] = parseFloat(styles[style + "-" + pos + suffix]) || 0;
-  }
-  result.width = result.left + result.right;
-  result.height = result.top + result.bottom;
-  return result;
-}
-const useOffsetPos = (x2, y2, target) => (x2 > 0 || y2 > 0) && (!target || !target.shadowRoot);
-function getCanvasPosition(e, canvas) {
-  const touches = e.touches;
-  const source = touches && touches.length ? touches[0] : e;
-  const { offsetX, offsetY } = source;
-  let box = false;
-  let x2, y2;
-  if (useOffsetPos(offsetX, offsetY, e.target)) {
-    x2 = offsetX;
-    y2 = offsetY;
-  } else {
-    const rect = canvas.getBoundingClientRect();
-    x2 = source.clientX - rect.left;
-    y2 = source.clientY - rect.top;
-    box = true;
-  }
-  return {
-    x: x2,
-    y: y2,
-    box
-  };
-}
-function getRelativePosition(event, chart) {
-  if ("native" in event) {
-    return event;
-  }
-  const { canvas, currentDevicePixelRatio } = chart;
-  const style = getComputedStyle(canvas);
-  const borderBox = style.boxSizing === "border-box";
-  const paddings = getPositionedStyle(style, "padding");
-  const borders = getPositionedStyle(style, "border", "width");
-  const { x: x2, y: y2, box } = getCanvasPosition(event, canvas);
-  const xOffset = paddings.left + (box && borders.left);
-  const yOffset = paddings.top + (box && borders.top);
-  let { width, height } = chart;
-  if (borderBox) {
-    width -= paddings.width + borders.width;
-    height -= paddings.height + borders.height;
-  }
-  return {
-    x: Math.round((x2 - xOffset) / width * canvas.width / currentDevicePixelRatio),
-    y: Math.round((y2 - yOffset) / height * canvas.height / currentDevicePixelRatio)
-  };
-}
-function getContainerSize(canvas, width, height) {
-  let maxWidth, maxHeight;
-  if (width === void 0 || height === void 0) {
-    const container = canvas && _getParentNode(canvas);
-    if (!container) {
-      width = canvas.clientWidth;
-      height = canvas.clientHeight;
-    } else {
-      const rect = container.getBoundingClientRect();
-      const containerStyle = getComputedStyle(container);
-      const containerBorder = getPositionedStyle(containerStyle, "border", "width");
-      const containerPadding = getPositionedStyle(containerStyle, "padding");
-      width = rect.width - containerPadding.width - containerBorder.width;
-      height = rect.height - containerPadding.height - containerBorder.height;
-      maxWidth = parseMaxStyle(containerStyle.maxWidth, container, "clientWidth");
-      maxHeight = parseMaxStyle(containerStyle.maxHeight, container, "clientHeight");
-    }
-  }
-  return {
-    width,
-    height,
-    maxWidth: maxWidth || INFINITY,
-    maxHeight: maxHeight || INFINITY
-  };
-}
-const round1 = (v2) => Math.round(v2 * 10) / 10;
-function getMaximumSize(canvas, bbWidth, bbHeight, aspectRatio) {
-  const style = getComputedStyle(canvas);
-  const margins = getPositionedStyle(style, "margin");
-  const maxWidth = parseMaxStyle(style.maxWidth, canvas, "clientWidth") || INFINITY;
-  const maxHeight = parseMaxStyle(style.maxHeight, canvas, "clientHeight") || INFINITY;
-  const containerSize = getContainerSize(canvas, bbWidth, bbHeight);
-  let { width, height } = containerSize;
-  if (style.boxSizing === "content-box") {
-    const borders = getPositionedStyle(style, "border", "width");
-    const paddings = getPositionedStyle(style, "padding");
-    width -= paddings.width + borders.width;
-    height -= paddings.height + borders.height;
-  }
-  width = Math.max(0, width - margins.width);
-  height = Math.max(0, aspectRatio ? width / aspectRatio : height - margins.height);
-  width = round1(Math.min(width, maxWidth, containerSize.maxWidth));
-  height = round1(Math.min(height, maxHeight, containerSize.maxHeight));
-  if (width && !height) {
-    height = round1(width / 2);
-  }
-  const maintainHeight = bbWidth !== void 0 || bbHeight !== void 0;
-  if (maintainHeight && aspectRatio && containerSize.height && height > containerSize.height) {
-    height = containerSize.height;
-    width = round1(Math.floor(height * aspectRatio));
-  }
-  return {
-    width,
-    height
-  };
-}
-function retinaScale(chart, forceRatio, forceStyle) {
-  const pixelRatio = forceRatio || 1;
-  const deviceHeight = Math.floor(chart.height * pixelRatio);
-  const deviceWidth = Math.floor(chart.width * pixelRatio);
-  chart.height = Math.floor(chart.height);
-  chart.width = Math.floor(chart.width);
-  const canvas = chart.canvas;
-  if (canvas.style && (forceStyle || !canvas.style.height && !canvas.style.width)) {
-    canvas.style.height = `${chart.height}px`;
-    canvas.style.width = `${chart.width}px`;
-  }
-  if (chart.currentDevicePixelRatio !== pixelRatio || canvas.height !== deviceHeight || canvas.width !== deviceWidth) {
-    chart.currentDevicePixelRatio = pixelRatio;
-    canvas.height = deviceHeight;
-    canvas.width = deviceWidth;
-    chart.ctx.setTransform(pixelRatio, 0, 0, pixelRatio, 0, 0);
-    return true;
-  }
-  return false;
-}
-const supportsEventListenerOptions = function() {
-  let passiveSupported = false;
-  try {
-    const options = {
-      get passive() {
-        passiveSupported = true;
-        return false;
-      }
-    };
-    if (_isDomSupported()) {
-      window.addEventListener("test", null, options);
-      window.removeEventListener("test", null, options);
-    }
-  } catch (e) {
-  }
-  return passiveSupported;
-}();
-function readUsedSize(element, property) {
-  const value = getStyle(element, property);
-  const matches = value && value.match(/^(\d+)(\.\d+)?px$/);
-  return matches ? +matches[1] : void 0;
-}
-function _pointInLine(p1, p2, t2, mode) {
-  return {
-    x: p1.x + t2 * (p2.x - p1.x),
-    y: p1.y + t2 * (p2.y - p1.y)
-  };
-}
-function _steppedInterpolation(p1, p2, t2, mode) {
-  return {
-    x: p1.x + t2 * (p2.x - p1.x),
-    y: mode === "middle" ? t2 < 0.5 ? p1.y : p2.y : mode === "after" ? t2 < 1 ? p1.y : p2.y : t2 > 0 ? p2.y : p1.y
-  };
-}
-function _bezierInterpolation(p1, p2, t2, mode) {
-  const cp1 = {
-    x: p1.cp2x,
-    y: p1.cp2y
-  };
-  const cp2 = {
-    x: p2.cp1x,
-    y: p2.cp1y
-  };
-  const a = _pointInLine(p1, cp1, t2);
-  const b = _pointInLine(cp1, cp2, t2);
-  const c = _pointInLine(cp2, p2, t2);
-  const d = _pointInLine(a, b, t2);
-  const e = _pointInLine(b, c, t2);
-  return _pointInLine(d, e, t2);
-}
-const getRightToLeftAdapter = function(rectX, width) {
-  return {
-    x(x2) {
-      return rectX + rectX + width - x2;
-    },
-    setWidth(w2) {
-      width = w2;
-    },
-    textAlign(align) {
-      if (align === "center") {
-        return align;
-      }
-      return align === "right" ? "left" : "right";
-    },
-    xPlus(x2, value) {
-      return x2 - value;
-    },
-    leftForLtr(x2, itemWidth) {
-      return x2 - itemWidth;
-    }
-  };
-};
-const getLeftToRightAdapter = function() {
-  return {
-    x(x2) {
-      return x2;
-    },
-    setWidth(w2) {
-    },
-    textAlign(align) {
-      return align;
-    },
-    xPlus(x2, value) {
-      return x2 + value;
-    },
-    leftForLtr(x2, _itemWidth) {
-      return x2;
-    }
-  };
-};
-function getRtlAdapter(rtl, rectX, width) {
-  return rtl ? getRightToLeftAdapter(rectX, width) : getLeftToRightAdapter();
-}
-function overrideTextDirection(ctx, direction) {
-  let style, original;
-  if (direction === "ltr" || direction === "rtl") {
-    style = ctx.canvas.style;
-    original = [
-      style.getPropertyValue("direction"),
-      style.getPropertyPriority("direction")
-    ];
-    style.setProperty("direction", direction, "important");
-    ctx.prevTextDirection = original;
-  }
-}
-function restoreTextDirection(ctx, original) {
-  if (original !== void 0) {
-    delete ctx.prevTextDirection;
-    ctx.canvas.style.setProperty("direction", original[0], original[1]);
-  }
-}
-function propertyFn(property) {
-  if (property === "angle") {
-    return {
-      between: _angleBetween,
-      compare: _angleDiff,
-      normalize: _normalizeAngle
-    };
-  }
-  return {
-    between: _isBetween,
-    compare: (a, b) => a - b,
-    normalize: (x2) => x2
-  };
-}
-function normalizeSegment({ start, end, count, loop, style }) {
-  return {
-    start: start % count,
-    end: end % count,
-    loop: loop && (end - start + 1) % count === 0,
-    style
-  };
-}
-function getSegment(segment, points, bounds) {
-  const { property, start: startBound, end: endBound } = bounds;
-  const { between, normalize } = propertyFn(property);
-  const count = points.length;
-  let { start, end, loop } = segment;
-  let i, ilen;
-  if (loop) {
-    start += count;
-    end += count;
-    for (i = 0, ilen = count; i < ilen; ++i) {
-      if (!between(normalize(points[start % count][property]), startBound, endBound)) {
-        break;
-      }
-      start--;
-      end--;
-    }
-    start %= count;
-    end %= count;
-  }
-  if (end < start) {
-    end += count;
-  }
-  return {
-    start,
-    end,
-    loop,
-    style: segment.style
-  };
-}
-function _boundSegment(segment, points, bounds) {
-  if (!bounds) {
-    return [
-      segment
-    ];
-  }
-  const { property, start: startBound, end: endBound } = bounds;
-  const count = points.length;
-  const { compare, between, normalize } = propertyFn(property);
-  const { start, end, loop, style } = getSegment(segment, points, bounds);
-  const result = [];
-  let inside = false;
-  let subStart = null;
-  let value, point, prevValue;
-  const startIsBefore = () => between(startBound, prevValue, value) && compare(startBound, prevValue) !== 0;
-  const endIsBefore = () => compare(endBound, value) === 0 || between(endBound, prevValue, value);
-  const shouldStart = () => inside || startIsBefore();
-  const shouldStop = () => !inside || endIsBefore();
-  for (let i = start, prev = start; i <= end; ++i) {
-    point = points[i % count];
-    if (point.skip) {
-      continue;
-    }
-    value = normalize(point[property]);
-    if (value === prevValue) {
-      continue;
-    }
-    inside = between(value, startBound, endBound);
-    if (subStart === null && shouldStart()) {
-      subStart = compare(value, startBound) === 0 ? i : prev;
-    }
-    if (subStart !== null && shouldStop()) {
-      result.push(normalizeSegment({
-        start: subStart,
-        end: i,
-        loop,
-        count,
-        style
-      }));
-      subStart = null;
-    }
-    prev = i;
-    prevValue = value;
-  }
-  if (subStart !== null) {
-    result.push(normalizeSegment({
-      start: subStart,
-      end,
-      loop,
-      count,
-      style
-    }));
-  }
-  return result;
-}
-function _boundSegments(line, bounds) {
-  const result = [];
-  const segments = line.segments;
-  for (let i = 0; i < segments.length; i++) {
-    const sub = _boundSegment(segments[i], line.points, bounds);
-    if (sub.length) {
-      result.push(...sub);
-    }
-  }
-  return result;
-}
-function findStartAndEnd(points, count, loop, spanGaps) {
-  let start = 0;
-  let end = count - 1;
-  if (loop && !spanGaps) {
-    while (start < count && !points[start].skip) {
-      start++;
-    }
-  }
-  while (start < count && points[start].skip) {
-    start++;
-  }
-  start %= count;
-  if (loop) {
-    end += start;
-  }
-  while (end > start && points[end % count].skip) {
-    end--;
-  }
-  end %= count;
-  return {
-    start,
-    end
-  };
-}
-function solidSegments(points, start, max, loop) {
-  const count = points.length;
-  const result = [];
-  let last = start;
-  let prev = points[start];
-  let end;
-  for (end = start + 1; end <= max; ++end) {
-    const cur = points[end % count];
-    if (cur.skip || cur.stop) {
-      if (!prev.skip) {
-        loop = false;
-        result.push({
-          start: start % count,
-          end: (end - 1) % count,
-          loop
-        });
-        start = last = cur.stop ? end : null;
-      }
-    } else {
-      last = end;
-      if (prev.skip) {
-        start = end;
-      }
-    }
-    prev = cur;
-  }
-  if (last !== null) {
-    result.push({
-      start: start % count,
-      end: last % count,
-      loop
-    });
-  }
-  return result;
-}
-function _computeSegments(line, segmentOptions) {
-  const points = line.points;
-  const spanGaps = line.options.spanGaps;
-  const count = points.length;
-  if (!count) {
-    return [];
-  }
-  const loop = !!line._loop;
-  const { start, end } = findStartAndEnd(points, count, loop, spanGaps);
-  if (spanGaps === true) {
-    return splitByStyles(line, [
-      {
-        start,
-        end,
-        loop
-      }
-    ], points, segmentOptions);
-  }
-  const max = end < start ? end + count : end;
-  const completeLoop = !!line._fullLoop && start === 0 && end === count - 1;
-  return splitByStyles(line, solidSegments(points, start, max, completeLoop), points, segmentOptions);
-}
-function splitByStyles(line, segments, points, segmentOptions) {
-  if (!segmentOptions || !segmentOptions.setContext || !points) {
-    return segments;
-  }
-  return doSplitByStyles(line, segments, points, segmentOptions);
-}
-function doSplitByStyles(line, segments, points, segmentOptions) {
-  const chartContext = line._chart.getContext();
-  const baseStyle = readStyle(line.options);
-  const { _datasetIndex: datasetIndex, options: { spanGaps } } = line;
-  const count = points.length;
-  const result = [];
-  let prevStyle = baseStyle;
-  let start = segments[0].start;
-  let i = start;
-  function addStyle(s, e, l2, st) {
-    const dir = spanGaps ? -1 : 1;
-    if (s === e) {
-      return;
-    }
-    s += count;
-    while (points[s % count].skip) {
-      s -= dir;
-    }
-    while (points[e % count].skip) {
-      e += dir;
-    }
-    if (s % count !== e % count) {
-      result.push({
-        start: s % count,
-        end: e % count,
-        loop: l2,
-        style: st
-      });
-      prevStyle = st;
-      start = e % count;
-    }
-  }
-  for (const segment of segments) {
-    start = spanGaps ? start : segment.start;
-    let prev = points[start % count];
-    let style;
-    for (i = start + 1; i <= segment.end; i++) {
-      const pt = points[i % count];
-      style = readStyle(segmentOptions.setContext(createContext(chartContext, {
-        type: "segment",
-        p0: prev,
-        p1: pt,
-        p0DataIndex: (i - 1) % count,
-        p1DataIndex: i % count,
-        datasetIndex
-      })));
-      if (styleChanged(style, prevStyle)) {
-        addStyle(start, i - 1, segment.loop, prevStyle);
-      }
-      prev = pt;
-      prevStyle = style;
-    }
-    if (start < i - 1) {
-      addStyle(start, i - 1, segment.loop, prevStyle);
-    }
-  }
-  return result;
-}
-function readStyle(options) {
-  return {
-    backgroundColor: options.backgroundColor,
-    borderCapStyle: options.borderCapStyle,
-    borderDash: options.borderDash,
-    borderDashOffset: options.borderDashOffset,
-    borderJoinStyle: options.borderJoinStyle,
-    borderWidth: options.borderWidth,
-    borderColor: options.borderColor
-  };
-}
-function styleChanged(style, prevStyle) {
-  if (!prevStyle) {
-    return false;
-  }
-  const cache = [];
-  const replacer = function(key, value) {
-    if (!isPatternOrGradient(value)) {
-      return value;
-    }
-    if (!cache.includes(value)) {
-      cache.push(value);
-    }
-    return cache.indexOf(value);
-  };
-  return JSON.stringify(style, replacer) !== JSON.stringify(prevStyle, replacer);
-}
-function getSizeForArea(scale, chartArea, field) {
-  return scale.options.clip ? scale[field] : chartArea[field];
-}
-function getDatasetArea(meta, chartArea) {
-  const { xScale, yScale } = meta;
-  if (xScale && yScale) {
-    return {
-      left: getSizeForArea(xScale, chartArea, "left"),
-      right: getSizeForArea(xScale, chartArea, "right"),
-      top: getSizeForArea(yScale, chartArea, "top"),
-      bottom: getSizeForArea(yScale, chartArea, "bottom")
-    };
-  }
-  return chartArea;
-}
-function getDatasetClipArea(chart, meta) {
-  const clip = meta._clip;
-  if (clip.disabled) {
-    return false;
-  }
-  const area = getDatasetArea(meta, chart.chartArea);
-  return {
-    left: clip.left === false ? 0 : area.left - (clip.left === true ? 0 : clip.left),
-    right: clip.right === false ? chart.width : area.right + (clip.right === true ? 0 : clip.right),
-    top: clip.top === false ? 0 : area.top - (clip.top === true ? 0 : clip.top),
-    bottom: clip.bottom === false ? chart.height : area.bottom + (clip.bottom === true ? 0 : clip.bottom)
-  };
-}
-/*!
- * Chart.js v4.4.9
- * https://www.chartjs.org
- * (c) 2025 Chart.js Contributors
- * Released under the MIT License
- */
-class Animator {
-  constructor() {
-    this._request = null;
-    this._charts = /* @__PURE__ */ new Map();
-    this._running = false;
-    this._lastDate = void 0;
-  }
-  _notify(chart, anims, date, type) {
-    const callbacks = anims.listeners[type];
-    const numSteps = anims.duration;
-    callbacks.forEach((fn) => fn({
-      chart,
-      initial: anims.initial,
-      numSteps,
-      currentStep: Math.min(date - anims.start, numSteps)
-    }));
-  }
-  _refresh() {
-    if (this._request) {
-      return;
-    }
-    this._running = true;
-    this._request = requestAnimFrame.call(window, () => {
-      this._update();
-      this._request = null;
-      if (this._running) {
-        this._refresh();
-      }
-    });
-  }
-  _update(date = Date.now()) {
-    let remaining = 0;
-    this._charts.forEach((anims, chart) => {
-      if (!anims.running || !anims.items.length) {
-        return;
-      }
-      const items = anims.items;
-      let i = items.length - 1;
-      let draw2 = false;
-      let item;
-      for (; i >= 0; --i) {
-        item = items[i];
-        if (item._active) {
-          if (item._total > anims.duration) {
-            anims.duration = item._total;
-          }
-          item.tick(date);
-          draw2 = true;
-        } else {
-          items[i] = items[items.length - 1];
-          items.pop();
+      });
+      var require_geo = __commonJS({
+        "src/plots/geo/geo.js"(exports, module2) {
+          var d3 = require_d3();
+          var geo = require_d3_geo();
+          var geoPath = geo.geoPath;
+          var geoDistance = geo.geoDistance;
+          var geoProjection = require_d3_geo_projection();
+          var Registry = require_registry();
+          var Lib = require_lib();
+          var strTranslate = Lib.strTranslate;
+          var Color2 = require_color();
+          var Drawing = require_drawing();
+          var Fx = require_fx();
+          var Plots = require_plots();
+          var Axes = require_axes();
+          var getAutoRange = require_autorange().getAutoRange;
+          var dragElement = require_dragelement();
+          var prepSelect = require_selections().prepSelect;
+          var clearOutline = require_selections().clearOutline;
+          var selectOnClick = require_selections().selectOnClick;
+          var createGeoZoom = require_zoom();
+          var constants = require_constants22();
+          var geoUtils = require_geo_location_utils();
+          var topojsonUtils = require_topojson_utils();
+          var topojsonFeature = require_topojson_client().feature;
+          function Geo(opts) {
+            this.id = opts.id;
+            this.graphDiv = opts.graphDiv;
+            this.container = opts.container;
+            this.topojsonURL = opts.topojsonURL;
+            this.isStatic = opts.staticPlot;
+            this.topojsonName = null;
+            this.topojson = null;
+            this.projection = null;
+            this.scope = null;
+            this.viewInitial = null;
+            this.fitScale = null;
+            this.bounds = null;
+            this.midPt = null;
+            this.hasChoropleth = false;
+            this.traceHash = {};
+            this.layers = {};
+            this.basePaths = {};
+            this.dataPaths = {};
+            this.dataPoints = {};
+            this.clipDef = null;
+            this.clipRect = null;
+            this.bgRect = null;
+            this.makeFramework();
+          }
+          var proto = Geo.prototype;
+          module2.exports = function createGeo(opts) {
+            return new Geo(opts);
+          };
+          proto.plot = function(geoCalcData, fullLayout, promises, replot) {
+            var _this = this;
+            if (replot) return _this.update(geoCalcData, fullLayout, true);
+            _this._geoCalcData = geoCalcData;
+            _this._fullLayout = fullLayout;
+            var geoLayout = fullLayout[this.id];
+            var geoPromises = [];
+            var needsTopojson = false;
+            for (var k2 in constants.layerNameToAdjective) {
+              if (k2 !== "frame" && geoLayout["show" + k2]) {
+                needsTopojson = true;
+                break;
+              }
+            }
+            var hasMarkerAngles = false;
+            for (var i2 = 0; i2 < geoCalcData.length; i2++) {
+              var trace = geoCalcData[0][0].trace;
+              trace._geo = _this;
+              if (trace.locationmode) {
+                needsTopojson = true;
+              }
+              var marker = trace.marker;
+              if (marker) {
+                var angle2 = marker.angle;
+                var angleref = marker.angleref;
+                if (angle2 || angleref === "north" || angleref === "previous") hasMarkerAngles = true;
+              }
+            }
+            this._hasMarkerAngles = hasMarkerAngles;
+            if (needsTopojson) {
+              var topojsonNameNew = topojsonUtils.getTopojsonName(geoLayout);
+              if (_this.topojson === null || topojsonNameNew !== _this.topojsonName) {
+                _this.topojsonName = topojsonNameNew;
+                if (PlotlyGeoAssets.topojson[_this.topojsonName] === void 0) {
+                  geoPromises.push(_this.fetchTopojson());
+                }
+              }
+            }
+            geoPromises = geoPromises.concat(geoUtils.fetchTraceGeoData(geoCalcData));
+            promises.push(new Promise(function(resolve, reject) {
+              Promise.all(geoPromises).then(function() {
+                _this.topojson = PlotlyGeoAssets.topojson[_this.topojsonName];
+                _this.update(geoCalcData, fullLayout);
+                resolve();
+              }).catch(reject);
+            }));
+          };
+          proto.fetchTopojson = function() {
+            var _this = this;
+            var topojsonPath = topojsonUtils.getTopojsonPath(_this.topojsonURL, _this.topojsonName);
+            return new Promise(function(resolve, reject) {
+              d3.json(topojsonPath, function(err, topojson) {
+                if (err) {
+                  if (err.status === 404) {
+                    return reject(new Error([
+                      "plotly.js could not find topojson file at",
+                      topojsonPath + ".",
+                      "Make sure the *topojsonURL* plot config option",
+                      "is set properly."
+                    ].join(" ")));
+                  } else {
+                    return reject(new Error([
+                      "unexpected error while fetching topojson file at",
+                      topojsonPath
+                    ].join(" ")));
+                  }
+                }
+                PlotlyGeoAssets.topojson[_this.topojsonName] = topojson;
+                resolve();
+              });
+            });
+          };
+          proto.update = function(geoCalcData, fullLayout, replot) {
+            var geoLayout = fullLayout[this.id];
+            this.hasChoropleth = false;
+            for (var i2 = 0; i2 < geoCalcData.length; i2++) {
+              var calcTrace = geoCalcData[i2];
+              var trace = calcTrace[0].trace;
+              if (trace.type === "choropleth") {
+                this.hasChoropleth = true;
+              }
+              if (trace.visible === true && trace._length > 0) {
+                trace._module.calcGeoJSON(calcTrace, fullLayout);
+              }
+            }
+            if (!replot) {
+              var hasInvalidBounds = this.updateProjection(geoCalcData, fullLayout);
+              if (hasInvalidBounds) return;
+              if (!this.viewInitial || this.scope !== geoLayout.scope) {
+                this.saveViewInitial(geoLayout);
+              }
+            }
+            this.scope = geoLayout.scope;
+            this.updateBaseLayers(fullLayout, geoLayout);
+            this.updateDims(fullLayout, geoLayout);
+            this.updateFx(fullLayout, geoLayout);
+            Plots.generalUpdatePerTraceModule(this.graphDiv, this, geoCalcData, geoLayout);
+            var scatterLayer = this.layers.frontplot.select(".scatterlayer");
+            this.dataPoints.point = scatterLayer.selectAll(".point");
+            this.dataPoints.text = scatterLayer.selectAll("text");
+            this.dataPaths.line = scatterLayer.selectAll(".js-line");
+            var choroplethLayer = this.layers.backplot.select(".choroplethlayer");
+            this.dataPaths.choropleth = choroplethLayer.selectAll("path");
+            this._render();
+          };
+          proto.updateProjection = function(geoCalcData, fullLayout) {
+            var gd2 = this.graphDiv;
+            var geoLayout = fullLayout[this.id];
+            var gs = fullLayout._size;
+            var domain = geoLayout.domain;
+            var projLayout = geoLayout.projection;
+            var lonaxis = geoLayout.lonaxis;
+            var lataxis = geoLayout.lataxis;
+            var axLon = lonaxis._ax;
+            var axLat = lataxis._ax;
+            var projection = this.projection = getProjection2(geoLayout);
+            var extent = [[
+              gs.l + gs.w * domain.x[0],
+              gs.t + gs.h * (1 - domain.y[1])
+            ], [
+              gs.l + gs.w * domain.x[1],
+              gs.t + gs.h * (1 - domain.y[0])
+            ]];
+            var center = geoLayout.center || {};
+            var rotation = projLayout.rotation || {};
+            var lonaxisRange = lonaxis.range || [];
+            var lataxisRange = lataxis.range || [];
+            if (geoLayout.fitbounds) {
+              axLon._length = extent[1][0] - extent[0][0];
+              axLat._length = extent[1][1] - extent[0][1];
+              axLon.range = getAutoRange(gd2, axLon);
+              axLat.range = getAutoRange(gd2, axLat);
+              var midLon = (axLon.range[0] + axLon.range[1]) / 2;
+              var midLat = (axLat.range[0] + axLat.range[1]) / 2;
+              if (geoLayout._isScoped) {
+                center = { lon: midLon, lat: midLat };
+              } else if (geoLayout._isClipped) {
+                center = { lon: midLon, lat: midLat };
+                rotation = { lon: midLon, lat: midLat, roll: rotation.roll };
+                var projType = projLayout.type;
+                var lonHalfSpan = constants.lonaxisSpan[projType] / 2 || 180;
+                var latHalfSpan = constants.lataxisSpan[projType] / 2 || 90;
+                lonaxisRange = [midLon - lonHalfSpan, midLon + lonHalfSpan];
+                lataxisRange = [midLat - latHalfSpan, midLat + latHalfSpan];
+              } else {
+                center = { lon: midLon, lat: midLat };
+                rotation = { lon: midLon, lat: rotation.lat, roll: rotation.roll };
+              }
+            }
+            projection.center([center.lon - rotation.lon, center.lat - rotation.lat]).rotate([-rotation.lon, -rotation.lat, rotation.roll]).parallels(projLayout.parallels);
+            var rangeBox = makeRangeBox(lonaxisRange, lataxisRange);
+            projection.fitExtent(extent, rangeBox);
+            var b2 = this.bounds = projection.getBounds(rangeBox);
+            var s2 = this.fitScale = projection.scale();
+            var t4 = projection.translate();
+            if (geoLayout.fitbounds) {
+              var b22 = projection.getBounds(makeRangeBox(axLon.range, axLat.range));
+              var k2 = Math.min(
+                (b2[1][0] - b2[0][0]) / (b22[1][0] - b22[0][0]),
+                (b2[1][1] - b2[0][1]) / (b22[1][1] - b22[0][1])
+              );
+              if (isFinite(k2)) {
+                projection.scale(k2 * s2);
+              } else {
+                Lib.warn("Something went wrong during" + this.id + "fitbounds computations.");
+              }
+            } else {
+              projection.scale(projLayout.scale * s2);
+            }
+            var midPt = this.midPt = [
+              (b2[0][0] + b2[1][0]) / 2,
+              (b2[0][1] + b2[1][1]) / 2
+            ];
+            projection.translate([t4[0] + (midPt[0] - t4[0]), t4[1] + (midPt[1] - t4[1])]).clipExtent(b2);
+            if (geoLayout._isAlbersUsa) {
+              var centerPx = projection([center.lon, center.lat]);
+              var tt2 = projection.translate();
+              projection.translate([
+                tt2[0] - (centerPx[0] - tt2[0]),
+                tt2[1] - (centerPx[1] - tt2[1])
+              ]);
+            }
+          };
+          proto.updateBaseLayers = function(fullLayout, geoLayout) {
+            var _this = this;
+            var topojson = _this.topojson;
+            var layers = _this.layers;
+            var basePaths = _this.basePaths;
+            function isAxisLayer(d2) {
+              return d2 === "lonaxis" || d2 === "lataxis";
+            }
+            function isLineLayer(d2) {
+              return Boolean(constants.lineLayers[d2]);
+            }
+            function isFillLayer(d2) {
+              return Boolean(constants.fillLayers[d2]);
+            }
+            var allLayers = this.hasChoropleth ? constants.layersForChoropleth : constants.layers;
+            var layerData = allLayers.filter(function(d2) {
+              return isLineLayer(d2) || isFillLayer(d2) ? geoLayout["show" + d2] : isAxisLayer(d2) ? geoLayout[d2].showgrid : true;
+            });
+            var join = _this.framework.selectAll(".layer").data(layerData, String);
+            join.exit().each(function(d2) {
+              delete layers[d2];
+              delete basePaths[d2];
+              d3.select(this).remove();
+            });
+            join.enter().append("g").attr("class", function(d2) {
+              return "layer " + d2;
+            }).each(function(d2) {
+              var layer = layers[d2] = d3.select(this);
+              if (d2 === "bg") {
+                _this.bgRect = layer.append("rect").style("pointer-events", "all");
+              } else if (isAxisLayer(d2)) {
+                basePaths[d2] = layer.append("path").style("fill", "none");
+              } else if (d2 === "backplot") {
+                layer.append("g").classed("choroplethlayer", true);
+              } else if (d2 === "frontplot") {
+                layer.append("g").classed("scatterlayer", true);
+              } else if (isLineLayer(d2)) {
+                basePaths[d2] = layer.append("path").style("fill", "none").style("stroke-miterlimit", 2);
+              } else if (isFillLayer(d2)) {
+                basePaths[d2] = layer.append("path").style("stroke", "none");
+              }
+            });
+            join.order();
+            join.each(function(d2) {
+              var path = basePaths[d2];
+              var adj = constants.layerNameToAdjective[d2];
+              if (d2 === "frame") {
+                path.datum(constants.sphereSVG);
+              } else if (isLineLayer(d2) || isFillLayer(d2)) {
+                path.datum(topojsonFeature(topojson, topojson.objects[d2]));
+              } else if (isAxisLayer(d2)) {
+                path.datum(makeGraticule(d2, geoLayout, fullLayout)).call(Color2.stroke, geoLayout[d2].gridcolor).call(Drawing.dashLine, geoLayout[d2].griddash, geoLayout[d2].gridwidth);
+              }
+              if (isLineLayer(d2)) {
+                path.call(Color2.stroke, geoLayout[adj + "color"]).call(Drawing.dashLine, "", geoLayout[adj + "width"]);
+              } else if (isFillLayer(d2)) {
+                path.call(Color2.fill, geoLayout[adj + "color"]);
+              }
+            });
+          };
+          proto.updateDims = function(fullLayout, geoLayout) {
+            var b2 = this.bounds;
+            var hFrameWidth = (geoLayout.framewidth || 0) / 2;
+            var l2 = b2[0][0] - hFrameWidth;
+            var t4 = b2[0][1] - hFrameWidth;
+            var w2 = b2[1][0] - l2 + hFrameWidth;
+            var h2 = b2[1][1] - t4 + hFrameWidth;
+            Drawing.setRect(this.clipRect, l2, t4, w2, h2);
+            this.bgRect.call(Drawing.setRect, l2, t4, w2, h2).call(Color2.fill, geoLayout.bgcolor);
+            this.xaxis._offset = l2;
+            this.xaxis._length = w2;
+            this.yaxis._offset = t4;
+            this.yaxis._length = h2;
+          };
+          proto.updateFx = function(fullLayout, geoLayout) {
+            var _this = this;
+            var gd2 = _this.graphDiv;
+            var bgRect = _this.bgRect;
+            var dragMode = fullLayout.dragmode;
+            var clickMode = fullLayout.clickmode;
+            if (_this.isStatic) return;
+            function zoomReset() {
+              var viewInitial = _this.viewInitial;
+              var updateObj = {};
+              for (var k2 in viewInitial) {
+                updateObj[_this.id + "." + k2] = viewInitial[k2];
+              }
+              Registry.call("_guiRelayout", gd2, updateObj);
+              gd2.emit("plotly_doubleclick", null);
+            }
+            function invert2(lonlat) {
+              return _this.projection.invert([
+                lonlat[0] + _this.xaxis._offset,
+                lonlat[1] + _this.yaxis._offset
+              ]);
+            }
+            var fillRangeItems = function(eventData, poly) {
+              if (poly.isRect) {
+                var ranges = eventData.range = {};
+                ranges[_this.id] = [
+                  invert2([poly.xmin, poly.ymin]),
+                  invert2([poly.xmax, poly.ymax])
+                ];
+              } else {
+                var dataPts = eventData.lassoPoints = {};
+                dataPts[_this.id] = poly.map(invert2);
+              }
+            };
+            var dragOptions = {
+              element: _this.bgRect.node(),
+              gd: gd2,
+              plotinfo: {
+                id: _this.id,
+                xaxis: _this.xaxis,
+                yaxis: _this.yaxis,
+                fillRangeItems
+              },
+              xaxes: [_this.xaxis],
+              yaxes: [_this.yaxis],
+              subplot: _this.id,
+              clickFn: function(numClicks) {
+                if (numClicks === 2) {
+                  clearOutline(gd2);
+                }
+              }
+            };
+            if (dragMode === "pan") {
+              bgRect.node().onmousedown = null;
+              bgRect.call(createGeoZoom(_this, geoLayout));
+              bgRect.on("dblclick.zoom", zoomReset);
+              if (!gd2._context._scrollZoom.geo) {
+                bgRect.on("wheel.zoom", null);
+              }
+            } else if (dragMode === "select" || dragMode === "lasso") {
+              bgRect.on(".zoom", null);
+              dragOptions.prepFn = function(e2, startX, startY) {
+                prepSelect(e2, startX, startY, dragOptions, dragMode);
+              };
+              dragElement.init(dragOptions);
+            }
+            bgRect.on("mousemove", function() {
+              var lonlat = _this.projection.invert(Lib.getPositionFromD3Event());
+              if (!lonlat) {
+                return dragElement.unhover(gd2, d3.event);
+              }
+              _this.xaxis.p2c = function() {
+                return lonlat[0];
+              };
+              _this.yaxis.p2c = function() {
+                return lonlat[1];
+              };
+              Fx.hover(gd2, d3.event, _this.id);
+            });
+            bgRect.on("mouseout", function() {
+              if (gd2._dragging) return;
+              dragElement.unhover(gd2, d3.event);
+            });
+            bgRect.on("click", function() {
+              if (dragMode !== "select" && dragMode !== "lasso") {
+                if (clickMode.indexOf("select") > -1) {
+                  selectOnClick(
+                    d3.event,
+                    gd2,
+                    [_this.xaxis],
+                    [_this.yaxis],
+                    _this.id,
+                    dragOptions
+                  );
+                }
+                if (clickMode.indexOf("event") > -1) {
+                  Fx.click(gd2, d3.event);
+                }
+              }
+            });
+          };
+          proto.makeFramework = function() {
+            var _this = this;
+            var gd2 = _this.graphDiv;
+            var fullLayout = gd2._fullLayout;
+            var clipId = "clip" + fullLayout._uid + _this.id;
+            _this.clipDef = fullLayout._clips.append("clipPath").attr("id", clipId);
+            _this.clipRect = _this.clipDef.append("rect");
+            _this.framework = d3.select(_this.container).append("g").attr("class", "geo " + _this.id).call(Drawing.setClipUrl, clipId, gd2);
+            _this.project = function(v2) {
+              var px = _this.projection(v2);
+              return px ? [px[0] - _this.xaxis._offset, px[1] - _this.yaxis._offset] : [null, null];
+            };
+            _this.xaxis = {
+              _id: "x",
+              c2p: function(v2) {
+                return _this.project(v2)[0];
+              }
+            };
+            _this.yaxis = {
+              _id: "y",
+              c2p: function(v2) {
+                return _this.project(v2)[1];
+              }
+            };
+            _this.mockAxis = {
+              type: "linear",
+              showexponent: "all",
+              exponentformat: "B"
+            };
+            Axes.setConvert(_this.mockAxis, fullLayout);
+          };
+          proto.saveViewInitial = function(geoLayout) {
+            var center = geoLayout.center || {};
+            var projLayout = geoLayout.projection;
+            var rotation = projLayout.rotation || {};
+            this.viewInitial = {
+              fitbounds: geoLayout.fitbounds,
+              "projection.scale": projLayout.scale
+            };
+            var extra;
+            if (geoLayout._isScoped) {
+              extra = {
+                "center.lon": center.lon,
+                "center.lat": center.lat
+              };
+            } else if (geoLayout._isClipped) {
+              extra = {
+                "projection.rotation.lon": rotation.lon,
+                "projection.rotation.lat": rotation.lat
+              };
+            } else {
+              extra = {
+                "center.lon": center.lon,
+                "center.lat": center.lat,
+                "projection.rotation.lon": rotation.lon
+              };
+            }
+            Lib.extendFlat(this.viewInitial, extra);
+          };
+          proto.render = function(mayRedrawOnUpdates) {
+            if (this._hasMarkerAngles && mayRedrawOnUpdates) {
+              this.plot(this._geoCalcData, this._fullLayout, [], true);
+            } else {
+              this._render();
+            }
+          };
+          proto._render = function() {
+            var projection = this.projection;
+            var pathFn = projection.getPath();
+            var k2;
+            function translatePoints(d2) {
+              var lonlatPx = projection(d2.lonlat);
+              return lonlatPx ? strTranslate(lonlatPx[0], lonlatPx[1]) : null;
+            }
+            function hideShowPoints(d2) {
+              return projection.isLonLatOverEdges(d2.lonlat) ? "none" : null;
+            }
+            for (k2 in this.basePaths) {
+              this.basePaths[k2].attr("d", pathFn);
+            }
+            for (k2 in this.dataPaths) {
+              this.dataPaths[k2].attr("d", function(d2) {
+                return pathFn(d2.geojson);
+              });
+            }
+            for (k2 in this.dataPoints) {
+              this.dataPoints[k2].attr("display", hideShowPoints).attr("transform", translatePoints);
+            }
+          };
+          function getProjection2(geoLayout) {
+            var projLayout = geoLayout.projection;
+            var projType = projLayout.type;
+            var projName = constants.projNames[projType];
+            projName = "geo" + Lib.titleCase(projName);
+            var projFn = geo[projName] || geoProjection[projName];
+            var projection = projFn();
+            var clipAngle = geoLayout._isSatellite ? Math.acos(1 / projLayout.distance) * 180 / Math.PI : geoLayout._isClipped ? constants.lonaxisSpan[projType] / 2 : null;
+            var methods = ["center", "rotate", "parallels", "clipExtent"];
+            var dummyFn = function(_2) {
+              return _2 ? projection : [];
+            };
+            for (var i2 = 0; i2 < methods.length; i2++) {
+              var m2 = methods[i2];
+              if (typeof projection[m2] !== "function") {
+                projection[m2] = dummyFn;
+              }
+            }
+            projection.isLonLatOverEdges = function(lonlat) {
+              if (projection(lonlat) === null) {
+                return true;
+              }
+              if (clipAngle) {
+                var r2 = projection.rotate();
+                var angle2 = geoDistance(lonlat, [-r2[0], -r2[1]]);
+                var maxAngle = clipAngle * Math.PI / 180;
+                return angle2 > maxAngle;
+              } else {
+                return false;
+              }
+            };
+            projection.getPath = function() {
+              return geoPath().projection(projection);
+            };
+            projection.getBounds = function(object) {
+              return projection.getPath().bounds(object);
+            };
+            projection.precision(constants.precision);
+            if (geoLayout._isSatellite) {
+              projection.tilt(projLayout.tilt).distance(projLayout.distance);
+            }
+            if (clipAngle) {
+              projection.clipAngle(clipAngle - constants.clipPad);
+            }
+            return projection;
+          }
+          function makeGraticule(axisName, geoLayout, fullLayout) {
+            var epsilon = 1e-6;
+            var precision = 2.5;
+            var axLayout = geoLayout[axisName];
+            var scopeDefaults = constants.scopeDefaults[geoLayout.scope];
+            var rng;
+            var oppRng;
+            var coordFn;
+            if (axisName === "lonaxis") {
+              rng = scopeDefaults.lonaxisRange;
+              oppRng = scopeDefaults.lataxisRange;
+              coordFn = function(v22, l22) {
+                return [v22, l22];
+              };
+            } else if (axisName === "lataxis") {
+              rng = scopeDefaults.lataxisRange;
+              oppRng = scopeDefaults.lonaxisRange;
+              coordFn = function(v22, l22) {
+                return [l22, v22];
+              };
+            }
+            var dummyAx = {
+              type: "linear",
+              range: [rng[0], rng[1] - epsilon],
+              tick0: axLayout.tick0,
+              dtick: axLayout.dtick
+            };
+            Axes.setConvert(dummyAx, fullLayout);
+            var vals = Axes.calcTicks(dummyAx);
+            if (!geoLayout.isScoped && axisName === "lonaxis") {
+              vals.pop();
+            }
+            var len2 = vals.length;
+            var coords = new Array(len2);
+            for (var i2 = 0; i2 < len2; i2++) {
+              var v2 = vals[i2].x;
+              var line = coords[i2] = [];
+              for (var l2 = oppRng[0]; l2 < oppRng[1] + precision; l2 += precision) {
+                line.push(coordFn(v2, l2));
+              }
+            }
+            return {
+              type: "MultiLineString",
+              coordinates: coords
+            };
+          }
+          function makeRangeBox(lon, lat) {
+            var clipPad = constants.clipPad;
+            var lon0 = lon[0] + clipPad;
+            var lon1 = lon[1] - clipPad;
+            var lat0 = lat[0] + clipPad;
+            var lat1 = lat[1] - clipPad;
+            if (lon0 > 0 && lon1 < 0) lon1 += 360;
+            var dlon4 = (lon1 - lon0) / 4;
+            return {
+              type: "Polygon",
+              coordinates: [[
+                [lon0, lat0],
+                [lon0, lat1],
+                [lon0 + dlon4, lat1],
+                [lon0 + 2 * dlon4, lat1],
+                [lon0 + 3 * dlon4, lat1],
+                [lon1, lat1],
+                [lon1, lat0],
+                [lon1 - dlon4, lat0],
+                [lon1 - 2 * dlon4, lat0],
+                [lon1 - 3 * dlon4, lat0],
+                [lon0, lat0]
+              ]]
+            };
+          }
         }
-      }
-      if (draw2) {
-        chart.draw();
-        this._notify(chart, anims, date, "progress");
-      }
-      if (!items.length) {
-        anims.running = false;
-        this._notify(chart, anims, date, "complete");
-        anims.initial = false;
-      }
-      remaining += items.length;
-    });
-    this._lastDate = date;
-    if (remaining === 0) {
-      this._running = false;
-    }
-  }
-  _getAnims(chart) {
-    const charts = this._charts;
-    let anims = charts.get(chart);
-    if (!anims) {
-      anims = {
-        running: false,
-        initial: true,
-        items: [],
-        listeners: {
-          complete: [],
-          progress: []
+      });
+      var require_layout_attributes18 = __commonJS({
+        "src/plots/geo/layout_attributes.js"(exports, module2) {
+          var colorAttrs = require_attributes3();
+          var domainAttrs = require_domain().attributes;
+          var dash = require_attributes4().dash;
+          var constants = require_constants22();
+          var overrideAll = require_edit_types().overrideAll;
+          var sortObjectKeys = require_sort_object_keys();
+          var geoAxesAttrs = {
+            range: {
+              valType: "info_array",
+              items: [
+                { valType: "number" },
+                { valType: "number" }
+              ]
+            },
+            showgrid: {
+              valType: "boolean",
+              dflt: false
+            },
+            tick0: {
+              valType: "number",
+              dflt: 0
+            },
+            dtick: {
+              valType: "number"
+            },
+            gridcolor: {
+              valType: "color",
+              dflt: colorAttrs.lightLine
+            },
+            gridwidth: {
+              valType: "number",
+              min: 0,
+              dflt: 1
+            },
+            griddash: dash
+          };
+          var attrs = module2.exports = overrideAll({
+            domain: domainAttrs({ name: "geo" }, {}),
+            fitbounds: {
+              valType: "enumerated",
+              values: [false, "locations", "geojson"],
+              dflt: false,
+              editType: "plot"
+            },
+            resolution: {
+              valType: "enumerated",
+              values: [110, 50],
+              dflt: 110,
+              coerceNumber: true
+            },
+            scope: {
+              valType: "enumerated",
+              values: sortObjectKeys(constants.scopeDefaults),
+              dflt: "world"
+            },
+            projection: {
+              type: {
+                valType: "enumerated",
+                values: sortObjectKeys(constants.projNames)
+              },
+              rotation: {
+                lon: {
+                  valType: "number"
+                },
+                lat: {
+                  valType: "number"
+                },
+                roll: {
+                  valType: "number"
+                }
+              },
+              tilt: {
+                valType: "number",
+                dflt: 0
+              },
+              distance: {
+                valType: "number",
+                min: 1.001,
+                dflt: 2
+              },
+              parallels: {
+                valType: "info_array",
+                items: [
+                  { valType: "number" },
+                  { valType: "number" }
+                ]
+              },
+              scale: {
+                valType: "number",
+                min: 0,
+                dflt: 1
+              }
+            },
+            center: {
+              lon: {
+                valType: "number"
+              },
+              lat: {
+                valType: "number"
+              }
+            },
+            visible: {
+              valType: "boolean",
+              dflt: true
+            },
+            showcoastlines: {
+              valType: "boolean"
+            },
+            coastlinecolor: {
+              valType: "color",
+              dflt: colorAttrs.defaultLine
+            },
+            coastlinewidth: {
+              valType: "number",
+              min: 0,
+              dflt: 1
+            },
+            showland: {
+              valType: "boolean",
+              dflt: false
+            },
+            landcolor: {
+              valType: "color",
+              dflt: constants.landColor
+            },
+            showocean: {
+              valType: "boolean",
+              dflt: false
+            },
+            oceancolor: {
+              valType: "color",
+              dflt: constants.waterColor
+            },
+            showlakes: {
+              valType: "boolean",
+              dflt: false
+            },
+            lakecolor: {
+              valType: "color",
+              dflt: constants.waterColor
+            },
+            showrivers: {
+              valType: "boolean",
+              dflt: false
+            },
+            rivercolor: {
+              valType: "color",
+              dflt: constants.waterColor
+            },
+            riverwidth: {
+              valType: "number",
+              min: 0,
+              dflt: 1
+            },
+            showcountries: {
+              valType: "boolean"
+            },
+            countrycolor: {
+              valType: "color",
+              dflt: colorAttrs.defaultLine
+            },
+            countrywidth: {
+              valType: "number",
+              min: 0,
+              dflt: 1
+            },
+            showsubunits: {
+              valType: "boolean"
+            },
+            subunitcolor: {
+              valType: "color",
+              dflt: colorAttrs.defaultLine
+            },
+            subunitwidth: {
+              valType: "number",
+              min: 0,
+              dflt: 1
+            },
+            showframe: {
+              valType: "boolean"
+            },
+            framecolor: {
+              valType: "color",
+              dflt: colorAttrs.defaultLine
+            },
+            framewidth: {
+              valType: "number",
+              min: 0,
+              dflt: 1
+            },
+            bgcolor: {
+              valType: "color",
+              dflt: colorAttrs.background
+            },
+            lonaxis: geoAxesAttrs,
+            lataxis: geoAxesAttrs
+          }, "plot", "from-root");
+          attrs.uirevision = {
+            valType: "any",
+            editType: "none"
+          };
         }
-      };
-      charts.set(chart, anims);
-    }
-    return anims;
-  }
-  listen(chart, event, cb2) {
-    this._getAnims(chart).listeners[event].push(cb2);
-  }
-  add(chart, items) {
-    if (!items || !items.length) {
-      return;
-    }
-    this._getAnims(chart).items.push(...items);
-  }
-  has(chart) {
-    return this._getAnims(chart).items.length > 0;
-  }
-  start(chart) {
-    const anims = this._charts.get(chart);
-    if (!anims) {
-      return;
-    }
-    anims.running = true;
-    anims.start = Date.now();
-    anims.duration = anims.items.reduce((acc, cur) => Math.max(acc, cur._duration), 0);
-    this._refresh();
-  }
-  running(chart) {
-    if (!this._running) {
-      return false;
-    }
-    const anims = this._charts.get(chart);
-    if (!anims || !anims.running || !anims.items.length) {
-      return false;
-    }
-    return true;
-  }
-  stop(chart) {
-    const anims = this._charts.get(chart);
-    if (!anims || !anims.items.length) {
-      return;
-    }
-    const items = anims.items;
-    let i = items.length - 1;
-    for (; i >= 0; --i) {
-      items[i].cancel();
-    }
-    anims.items = [];
-    this._notify(chart, anims, Date.now(), "complete");
-  }
-  remove(chart) {
-    return this._charts.delete(chart);
-  }
-}
-var animator = /* @__PURE__ */ new Animator();
-const transparent = "transparent";
-const interpolators = {
-  boolean(from2, to2, factor) {
-    return factor > 0.5 ? to2 : from2;
-  },
-  color(from2, to2, factor) {
-    const c0 = color(from2 || transparent);
-    const c1 = c0.valid && color(to2 || transparent);
-    return c1 && c1.valid ? c1.mix(c0, factor).hexString() : to2;
-  },
-  number(from2, to2, factor) {
-    return from2 + (to2 - from2) * factor;
-  }
-};
-class Animation {
-  constructor(cfg, target, prop, to2) {
-    const currentValue = target[prop];
-    to2 = resolve([
-      cfg.to,
-      to2,
-      currentValue,
-      cfg.from
-    ]);
-    const from2 = resolve([
-      cfg.from,
-      currentValue,
-      to2
-    ]);
-    this._active = true;
-    this._fn = cfg.fn || interpolators[cfg.type || typeof from2];
-    this._easing = effects[cfg.easing] || effects.linear;
-    this._start = Math.floor(Date.now() + (cfg.delay || 0));
-    this._duration = this._total = Math.floor(cfg.duration);
-    this._loop = !!cfg.loop;
-    this._target = target;
-    this._prop = prop;
-    this._from = from2;
-    this._to = to2;
-    this._promises = void 0;
-  }
-  active() {
-    return this._active;
-  }
-  update(cfg, to2, date) {
-    if (this._active) {
-      this._notify(false);
-      const currentValue = this._target[this._prop];
-      const elapsed = date - this._start;
-      const remain = this._duration - elapsed;
-      this._start = date;
-      this._duration = Math.floor(Math.max(remain, cfg.duration));
-      this._total += elapsed;
-      this._loop = !!cfg.loop;
-      this._to = resolve([
-        cfg.to,
-        to2,
-        currentValue,
-        cfg.from
-      ]);
-      this._from = resolve([
-        cfg.from,
-        currentValue,
-        to2
-      ]);
-    }
-  }
-  cancel() {
-    if (this._active) {
-      this.tick(Date.now());
-      this._active = false;
-      this._notify(false);
-    }
-  }
-  tick(date) {
-    const elapsed = date - this._start;
-    const duration = this._duration;
-    const prop = this._prop;
-    const from2 = this._from;
-    const loop = this._loop;
-    const to2 = this._to;
-    let factor;
-    this._active = from2 !== to2 && (loop || elapsed < duration);
-    if (!this._active) {
-      this._target[prop] = to2;
-      this._notify(true);
-      return;
-    }
-    if (elapsed < 0) {
-      this._target[prop] = from2;
-      return;
-    }
-    factor = elapsed / duration % 2;
-    factor = loop && factor > 1 ? 2 - factor : factor;
-    factor = this._easing(Math.min(1, Math.max(0, factor)));
-    this._target[prop] = this._fn(from2, to2, factor);
-  }
-  wait() {
-    const promises = this._promises || (this._promises = []);
-    return new Promise((res, rej) => {
-      promises.push({
-        res,
-        rej
       });
-    });
-  }
-  _notify(resolved) {
-    const method = resolved ? "res" : "rej";
-    const promises = this._promises || [];
-    for (let i = 0; i < promises.length; i++) {
-      promises[i][method]();
-    }
-  }
-}
-class Animations {
-  constructor(chart, config) {
-    this._chart = chart;
-    this._properties = /* @__PURE__ */ new Map();
-    this.configure(config);
-  }
-  configure(config) {
-    if (!isObject(config)) {
-      return;
-    }
-    const animationOptions = Object.keys(defaults.animation);
-    const animatedProps = this._properties;
-    Object.getOwnPropertyNames(config).forEach((key) => {
-      const cfg = config[key];
-      if (!isObject(cfg)) {
-        return;
-      }
-      const resolved = {};
-      for (const option of animationOptions) {
-        resolved[option] = cfg[option];
-      }
-      (isArray(cfg.properties) && cfg.properties || [
-        key
-      ]).forEach((prop) => {
-        if (prop === key || !animatedProps.has(prop)) {
-          animatedProps.set(prop, resolved);
+      var require_layout_defaults16 = __commonJS({
+        "src/plots/geo/layout_defaults.js"(exports, module2) {
+          var Lib = require_lib();
+          var handleSubplotDefaults = require_subplot_defaults();
+          var getSubplotData = require_get_data().getSubplotData;
+          var constants = require_constants22();
+          var layoutAttributes = require_layout_attributes18();
+          var axesNames = constants.axesNames;
+          module2.exports = function supplyLayoutDefaults(layoutIn, layoutOut, fullData) {
+            handleSubplotDefaults(layoutIn, layoutOut, fullData, {
+              type: "geo",
+              attributes: layoutAttributes,
+              handleDefaults: handleGeoDefaults,
+              fullData,
+              partition: "y"
+            });
+          };
+          function handleGeoDefaults(geoLayoutIn, geoLayoutOut, coerce, opts) {
+            var subplotData = getSubplotData(opts.fullData, "geo", opts.id);
+            var traceIndices = subplotData.map(function(t4) {
+              return t4.index;
+            });
+            var resolution = coerce("resolution");
+            var scope = coerce("scope");
+            var scopeParams = constants.scopeDefaults[scope];
+            var projType = coerce("projection.type", scopeParams.projType);
+            var isAlbersUsa = geoLayoutOut._isAlbersUsa = projType === "albers usa";
+            if (isAlbersUsa) scope = geoLayoutOut.scope = "usa";
+            var isScoped = geoLayoutOut._isScoped = scope !== "world";
+            var isSatellite = geoLayoutOut._isSatellite = projType === "satellite";
+            var isConic = geoLayoutOut._isConic = projType.indexOf("conic") !== -1 || projType === "albers";
+            var isClipped = geoLayoutOut._isClipped = !!constants.lonaxisSpan[projType];
+            if (geoLayoutIn.visible === false) {
+              var newTemplate = Lib.extendDeep({}, geoLayoutOut._template);
+              newTemplate.showcoastlines = false;
+              newTemplate.showcountries = false;
+              newTemplate.showframe = false;
+              newTemplate.showlakes = false;
+              newTemplate.showland = false;
+              newTemplate.showocean = false;
+              newTemplate.showrivers = false;
+              newTemplate.showsubunits = false;
+              if (newTemplate.lonaxis) newTemplate.lonaxis.showgrid = false;
+              if (newTemplate.lataxis) newTemplate.lataxis.showgrid = false;
+              geoLayoutOut._template = newTemplate;
+            }
+            var visible = coerce("visible");
+            var show;
+            for (var i2 = 0; i2 < axesNames.length; i2++) {
+              var axisName = axesNames[i2];
+              var dtickDflt = [30, 10][i2];
+              var rangeDflt;
+              if (isScoped) {
+                rangeDflt = scopeParams[axisName + "Range"];
+              } else {
+                var dfltSpans = constants[axisName + "Span"];
+                var hSpan = (dfltSpans[projType] || dfltSpans["*"]) / 2;
+                var rot = coerce(
+                  "projection.rotation." + axisName.slice(0, 3),
+                  scopeParams.projRotate[i2]
+                );
+                rangeDflt = [rot - hSpan, rot + hSpan];
+              }
+              var range = coerce(axisName + ".range", rangeDflt);
+              coerce(axisName + ".tick0");
+              coerce(axisName + ".dtick", dtickDflt);
+              show = coerce(axisName + ".showgrid", !visible ? false : void 0);
+              if (show) {
+                coerce(axisName + ".gridcolor");
+                coerce(axisName + ".gridwidth");
+                coerce(axisName + ".griddash");
+              }
+              geoLayoutOut[axisName]._ax = {
+                type: "linear",
+                _id: axisName.slice(0, 3),
+                _traceIndices: traceIndices,
+                setScale: Lib.identity,
+                c2l: Lib.identity,
+                r2l: Lib.identity,
+                autorange: true,
+                range: range.slice(),
+                _m: 1,
+                _input: {}
+              };
+            }
+            var lonRange = geoLayoutOut.lonaxis.range;
+            var latRange = geoLayoutOut.lataxis.range;
+            var lon0 = lonRange[0];
+            var lon1 = lonRange[1];
+            if (lon0 > 0 && lon1 < 0) lon1 += 360;
+            var centerLon = (lon0 + lon1) / 2;
+            var projLon;
+            if (!isAlbersUsa) {
+              var dfltProjRotate = isScoped ? scopeParams.projRotate : [centerLon, 0, 0];
+              projLon = coerce("projection.rotation.lon", dfltProjRotate[0]);
+              coerce("projection.rotation.lat", dfltProjRotate[1]);
+              coerce("projection.rotation.roll", dfltProjRotate[2]);
+              show = coerce("showcoastlines", !isScoped && visible);
+              if (show) {
+                coerce("coastlinecolor");
+                coerce("coastlinewidth");
+              }
+              show = coerce("showocean", !visible ? false : void 0);
+              if (show) coerce("oceancolor");
+            }
+            var centerLonDflt;
+            var centerLatDflt;
+            if (isAlbersUsa) {
+              centerLonDflt = -96.6;
+              centerLatDflt = 38.7;
+            } else {
+              centerLonDflt = isScoped ? centerLon : projLon;
+              centerLatDflt = (latRange[0] + latRange[1]) / 2;
+            }
+            coerce("center.lon", centerLonDflt);
+            coerce("center.lat", centerLatDflt);
+            if (isSatellite) {
+              coerce("projection.tilt");
+              coerce("projection.distance");
+            }
+            if (isConic) {
+              var dfltProjParallels = scopeParams.projParallels || [0, 60];
+              coerce("projection.parallels", dfltProjParallels);
+            }
+            coerce("projection.scale");
+            show = coerce("showland", !visible ? false : void 0);
+            if (show) coerce("landcolor");
+            show = coerce("showlakes", !visible ? false : void 0);
+            if (show) coerce("lakecolor");
+            show = coerce("showrivers", !visible ? false : void 0);
+            if (show) {
+              coerce("rivercolor");
+              coerce("riverwidth");
+            }
+            show = coerce("showcountries", isScoped && scope !== "usa" && visible);
+            if (show) {
+              coerce("countrycolor");
+              coerce("countrywidth");
+            }
+            if (scope === "usa" || scope === "north america" && resolution === 50) {
+              coerce("showsubunits", visible);
+              coerce("subunitcolor");
+              coerce("subunitwidth");
+            }
+            if (!isScoped) {
+              show = coerce("showframe", visible);
+              if (show) {
+                coerce("framecolor");
+                coerce("framewidth");
+              }
+            }
+            coerce("bgcolor");
+            var fitBounds2 = coerce("fitbounds");
+            if (fitBounds2) {
+              delete geoLayoutOut.projection.scale;
+              if (isScoped) {
+                delete geoLayoutOut.center.lon;
+                delete geoLayoutOut.center.lat;
+              } else if (isClipped) {
+                delete geoLayoutOut.center.lon;
+                delete geoLayoutOut.center.lat;
+                delete geoLayoutOut.projection.rotation.lon;
+                delete geoLayoutOut.projection.rotation.lat;
+                delete geoLayoutOut.lonaxis.range;
+                delete geoLayoutOut.lataxis.range;
+              } else {
+                delete geoLayoutOut.center.lon;
+                delete geoLayoutOut.center.lat;
+                delete geoLayoutOut.projection.rotation.lon;
+              }
+            }
+          }
         }
       });
-    });
-  }
-  _animateOptions(target, values) {
-    const newOptions = values.options;
-    const options = resolveTargetOptions(target, newOptions);
-    if (!options) {
-      return [];
-    }
-    const animations = this._createAnimations(options, newOptions);
-    if (newOptions.$shared) {
-      awaitAll(target.options.$animations, newOptions).then(() => {
-        target.options = newOptions;
-      }, () => {
-      });
-    }
-    return animations;
-  }
-  _createAnimations(target, values) {
-    const animatedProps = this._properties;
-    const animations = [];
-    const running = target.$animations || (target.$animations = {});
-    const props = Object.keys(values);
-    const date = Date.now();
-    let i;
-    for (i = props.length - 1; i >= 0; --i) {
-      const prop = props[i];
-      if (prop.charAt(0) === "$") {
-        continue;
-      }
-      if (prop === "options") {
-        animations.push(...this._animateOptions(target, values));
-        continue;
-      }
-      const value = values[prop];
-      let animation = running[prop];
-      const cfg = animatedProps.get(prop);
-      if (animation) {
-        if (cfg && animation.active()) {
-          animation.update(cfg, value, date);
-          continue;
-        } else {
-          animation.cancel();
+      var require_geo2 = __commonJS({
+        "src/plots/geo/index.js"(exports, module2) {
+          var getSubplotCalcData = require_get_data().getSubplotCalcData;
+          var counterRegex = require_lib().counterRegex;
+          var createGeo = require_geo();
+          var GEO = "geo";
+          var counter2 = counterRegex(GEO);
+          var attributes = {};
+          attributes[GEO] = {
+            valType: "subplotid",
+            dflt: GEO,
+            editType: "calc"
+          };
+          function plotGeo(gd2) {
+            var fullLayout = gd2._fullLayout;
+            var calcData = gd2.calcdata;
+            var geoIds = fullLayout._subplots[GEO];
+            for (var i2 = 0; i2 < geoIds.length; i2++) {
+              var geoId = geoIds[i2];
+              var geoCalcData = getSubplotCalcData(calcData, GEO, geoId);
+              var geoLayout = fullLayout[geoId];
+              var geo = geoLayout._subplot;
+              if (!geo) {
+                geo = createGeo({
+                  id: geoId,
+                  graphDiv: gd2,
+                  container: fullLayout._geolayer.node(),
+                  topojsonURL: gd2._context.topojsonURL,
+                  staticPlot: gd2._context.staticPlot
+                });
+                fullLayout[geoId]._subplot = geo;
+              }
+              geo.plot(geoCalcData, fullLayout, gd2._promises);
+            }
+          }
+          function clean(newFullData, newFullLayout, oldFullData, oldFullLayout) {
+            var oldGeoKeys = oldFullLayout._subplots[GEO] || [];
+            for (var i2 = 0; i2 < oldGeoKeys.length; i2++) {
+              var oldGeoKey = oldGeoKeys[i2];
+              var oldGeo = oldFullLayout[oldGeoKey]._subplot;
+              if (!newFullLayout[oldGeoKey] && !!oldGeo) {
+                oldGeo.framework.remove();
+                oldGeo.clipDef.remove();
+              }
+            }
+          }
+          function updateFx(gd2) {
+            var fullLayout = gd2._fullLayout;
+            var subplotIds = fullLayout._subplots[GEO];
+            for (var i2 = 0; i2 < subplotIds.length; i2++) {
+              var subplotLayout = fullLayout[subplotIds[i2]];
+              var subplotObj = subplotLayout._subplot;
+              subplotObj.updateFx(fullLayout, subplotLayout);
+            }
+          }
+          module2.exports = {
+            attr: GEO,
+            name: GEO,
+            idRoot: GEO,
+            idRegex: counter2,
+            attrRegex: counter2,
+            attributes,
+            layoutAttributes: require_layout_attributes18(),
+            supplyLayoutDefaults: require_layout_defaults16(),
+            plot: plotGeo,
+            updateFx,
+            clean
+          };
         }
-      }
-      if (!cfg || !cfg.duration) {
-        target[prop] = value;
-        continue;
-      }
-      running[prop] = animation = new Animation(cfg, target, prop, value);
-      animations.push(animation);
-    }
-    return animations;
-  }
-  update(target, values) {
-    if (this._properties.size === 0) {
-      Object.assign(target, values);
-      return;
-    }
-    const animations = this._createAnimations(target, values);
-    if (animations.length) {
-      animator.add(this._chart, animations);
-      return true;
-    }
-  }
-}
-function awaitAll(animations, properties) {
-  const running = [];
-  const keys = Object.keys(properties);
-  for (let i = 0; i < keys.length; i++) {
-    const anim = animations[keys[i]];
-    if (anim && anim.active()) {
-      running.push(anim.wait());
-    }
-  }
-  return Promise.all(running);
-}
-function resolveTargetOptions(target, newOptions) {
-  if (!newOptions) {
-    return;
-  }
-  let options = target.options;
-  if (!options) {
-    target.options = newOptions;
-    return;
-  }
-  if (options.$shared) {
-    target.options = options = Object.assign({}, options, {
-      $shared: false,
-      $animations: {}
-    });
-  }
-  return options;
-}
-function scaleClip(scale, allowedOverflow) {
-  const opts = scale && scale.options || {};
-  const reverse = opts.reverse;
-  const min = opts.min === void 0 ? allowedOverflow : 0;
-  const max = opts.max === void 0 ? allowedOverflow : 0;
-  return {
-    start: reverse ? max : min,
-    end: reverse ? min : max
-  };
-}
-function defaultClip(xScale, yScale, allowedOverflow) {
-  if (allowedOverflow === false) {
-    return false;
-  }
-  const x2 = scaleClip(xScale, allowedOverflow);
-  const y2 = scaleClip(yScale, allowedOverflow);
-  return {
-    top: y2.end,
-    right: x2.end,
-    bottom: y2.start,
-    left: x2.start
-  };
-}
-function toClip(value) {
-  let t2, r2, b, l2;
-  if (isObject(value)) {
-    t2 = value.top;
-    r2 = value.right;
-    b = value.bottom;
-    l2 = value.left;
-  } else {
-    t2 = r2 = b = l2 = value;
-  }
-  return {
-    top: t2,
-    right: r2,
-    bottom: b,
-    left: l2,
-    disabled: value === false
-  };
-}
-function getSortedDatasetIndices(chart, filterVisible) {
-  const keys = [];
-  const metasets = chart._getSortedDatasetMetas(filterVisible);
-  let i, ilen;
-  for (i = 0, ilen = metasets.length; i < ilen; ++i) {
-    keys.push(metasets[i].index);
-  }
-  return keys;
-}
-function applyStack(stack, value, dsIndex, options = {}) {
-  const keys = stack.keys;
-  const singleMode = options.mode === "single";
-  let i, ilen, datasetIndex, otherValue;
-  if (value === null) {
-    return;
-  }
-  let found = false;
-  for (i = 0, ilen = keys.length; i < ilen; ++i) {
-    datasetIndex = +keys[i];
-    if (datasetIndex === dsIndex) {
-      found = true;
-      if (options.all) {
-        continue;
-      }
-      break;
-    }
-    otherValue = stack.values[datasetIndex];
-    if (isNumberFinite(otherValue) && (singleMode || value === 0 || sign(value) === sign(otherValue))) {
-      value += otherValue;
-    }
-  }
-  if (!found && !options.all) {
-    return 0;
-  }
-  return value;
-}
-function convertObjectDataToArray(data, meta) {
-  const { iScale, vScale } = meta;
-  const iAxisKey = iScale.axis === "x" ? "x" : "y";
-  const vAxisKey = vScale.axis === "x" ? "x" : "y";
-  const keys = Object.keys(data);
-  const adata = new Array(keys.length);
-  let i, ilen, key;
-  for (i = 0, ilen = keys.length; i < ilen; ++i) {
-    key = keys[i];
-    adata[i] = {
-      [iAxisKey]: key,
-      [vAxisKey]: data[key]
-    };
-  }
-  return adata;
-}
-function isStacked(scale, meta) {
-  const stacked = scale && scale.options.stacked;
-  return stacked || stacked === void 0 && meta.stack !== void 0;
-}
-function getStackKey(indexScale, valueScale, meta) {
-  return `${indexScale.id}.${valueScale.id}.${meta.stack || meta.type}`;
-}
-function getUserBounds(scale) {
-  const { min, max, minDefined, maxDefined } = scale.getUserBounds();
-  return {
-    min: minDefined ? min : Number.NEGATIVE_INFINITY,
-    max: maxDefined ? max : Number.POSITIVE_INFINITY
-  };
-}
-function getOrCreateStack(stacks, stackKey, indexValue) {
-  const subStack = stacks[stackKey] || (stacks[stackKey] = {});
-  return subStack[indexValue] || (subStack[indexValue] = {});
-}
-function getLastIndexInStack(stack, vScale, positive, type) {
-  for (const meta of vScale.getMatchingVisibleMetas(type).reverse()) {
-    const value = stack[meta.index];
-    if (positive && value > 0 || !positive && value < 0) {
-      return meta.index;
-    }
-  }
-  return null;
-}
-function updateStacks(controller, parsed) {
-  const { chart, _cachedMeta: meta } = controller;
-  const stacks = chart._stacks || (chart._stacks = {});
-  const { iScale, vScale, index: datasetIndex } = meta;
-  const iAxis = iScale.axis;
-  const vAxis = vScale.axis;
-  const key = getStackKey(iScale, vScale, meta);
-  const ilen = parsed.length;
-  let stack;
-  for (let i = 0; i < ilen; ++i) {
-    const item = parsed[i];
-    const { [iAxis]: index, [vAxis]: value } = item;
-    const itemStacks = item._stacks || (item._stacks = {});
-    stack = itemStacks[vAxis] = getOrCreateStack(stacks, key, index);
-    stack[datasetIndex] = value;
-    stack._top = getLastIndexInStack(stack, vScale, true, meta.type);
-    stack._bottom = getLastIndexInStack(stack, vScale, false, meta.type);
-    const visualValues = stack._visualValues || (stack._visualValues = {});
-    visualValues[datasetIndex] = value;
-  }
-}
-function getFirstScaleId(chart, axis) {
-  const scales = chart.scales;
-  return Object.keys(scales).filter((key) => scales[key].axis === axis).shift();
-}
-function createDatasetContext(parent, index) {
-  return createContext(parent, {
-    active: false,
-    dataset: void 0,
-    datasetIndex: index,
-    index,
-    mode: "default",
-    type: "dataset"
-  });
-}
-function createDataContext(parent, index, element) {
-  return createContext(parent, {
-    active: false,
-    dataIndex: index,
-    parsed: void 0,
-    raw: void 0,
-    element,
-    index,
-    mode: "default",
-    type: "data"
-  });
-}
-function clearStacks(meta, items) {
-  const datasetIndex = meta.controller.index;
-  const axis = meta.vScale && meta.vScale.axis;
-  if (!axis) {
-    return;
-  }
-  items = items || meta._parsed;
-  for (const parsed of items) {
-    const stacks = parsed._stacks;
-    if (!stacks || stacks[axis] === void 0 || stacks[axis][datasetIndex] === void 0) {
-      return;
-    }
-    delete stacks[axis][datasetIndex];
-    if (stacks[axis]._visualValues !== void 0 && stacks[axis]._visualValues[datasetIndex] !== void 0) {
-      delete stacks[axis]._visualValues[datasetIndex];
-    }
-  }
-}
-const isDirectUpdateMode = (mode) => mode === "reset" || mode === "none";
-const cloneIfNotShared = (cached, shared) => shared ? cached : Object.assign({}, cached);
-const createStack = (canStack, meta, chart) => canStack && !meta.hidden && meta._stacked && {
-  keys: getSortedDatasetIndices(chart, true),
-  values: null
-};
-class DatasetController {
-  constructor(chart, datasetIndex) {
-    this.chart = chart;
-    this._ctx = chart.ctx;
-    this.index = datasetIndex;
-    this._cachedDataOpts = {};
-    this._cachedMeta = this.getMeta();
-    this._type = this._cachedMeta.type;
-    this.options = void 0;
-    this._parsing = false;
-    this._data = void 0;
-    this._objectData = void 0;
-    this._sharedOptions = void 0;
-    this._drawStart = void 0;
-    this._drawCount = void 0;
-    this.enableOptionSharing = false;
-    this.supportsDecimation = false;
-    this.$context = void 0;
-    this._syncList = [];
-    this.datasetElementType = new.target.datasetElementType;
-    this.dataElementType = new.target.dataElementType;
-    this.initialize();
-  }
-  initialize() {
-    const meta = this._cachedMeta;
-    this.configure();
-    this.linkScales();
-    meta._stacked = isStacked(meta.vScale, meta);
-    this.addElements();
-    if (this.options.fill && !this.chart.isPluginEnabled("filler")) {
-      console.warn("Tried to use the 'fill' option without the 'Filler' plugin enabled. Please import and register the 'Filler' plugin and make sure it is not disabled in the options");
-    }
-  }
-  updateIndex(datasetIndex) {
-    if (this.index !== datasetIndex) {
-      clearStacks(this._cachedMeta);
-    }
-    this.index = datasetIndex;
-  }
-  linkScales() {
-    const chart = this.chart;
-    const meta = this._cachedMeta;
-    const dataset = this.getDataset();
-    const chooseId = (axis, x2, y2, r2) => axis === "x" ? x2 : axis === "r" ? r2 : y2;
-    const xid = meta.xAxisID = valueOrDefault(dataset.xAxisID, getFirstScaleId(chart, "x"));
-    const yid = meta.yAxisID = valueOrDefault(dataset.yAxisID, getFirstScaleId(chart, "y"));
-    const rid = meta.rAxisID = valueOrDefault(dataset.rAxisID, getFirstScaleId(chart, "r"));
-    const indexAxis = meta.indexAxis;
-    const iid = meta.iAxisID = chooseId(indexAxis, xid, yid, rid);
-    const vid = meta.vAxisID = chooseId(indexAxis, yid, xid, rid);
-    meta.xScale = this.getScaleForId(xid);
-    meta.yScale = this.getScaleForId(yid);
-    meta.rScale = this.getScaleForId(rid);
-    meta.iScale = this.getScaleForId(iid);
-    meta.vScale = this.getScaleForId(vid);
-  }
-  getDataset() {
-    return this.chart.data.datasets[this.index];
-  }
-  getMeta() {
-    return this.chart.getDatasetMeta(this.index);
-  }
-  getScaleForId(scaleID) {
-    return this.chart.scales[scaleID];
-  }
-  _getOtherScale(scale) {
-    const meta = this._cachedMeta;
-    return scale === meta.iScale ? meta.vScale : meta.iScale;
-  }
-  reset() {
-    this._update("reset");
-  }
-  _destroy() {
-    const meta = this._cachedMeta;
-    if (this._data) {
-      unlistenArrayEvents(this._data, this);
-    }
-    if (meta._stacked) {
-      clearStacks(meta);
-    }
-  }
-  _dataCheck() {
-    const dataset = this.getDataset();
-    const data = dataset.data || (dataset.data = []);
-    const _data = this._data;
-    if (isObject(data)) {
-      const meta = this._cachedMeta;
-      this._data = convertObjectDataToArray(data, meta);
-    } else if (_data !== data) {
-      if (_data) {
-        unlistenArrayEvents(_data, this);
-        const meta = this._cachedMeta;
-        clearStacks(meta);
-        meta._parsed = [];
-      }
-      if (data && Object.isExtensible(data)) {
-        listenArrayEvents(data, this);
-      }
-      this._syncList = [];
-      this._data = data;
-    }
-  }
-  addElements() {
-    const meta = this._cachedMeta;
-    this._dataCheck();
-    if (this.datasetElementType) {
-      meta.dataset = new this.datasetElementType();
-    }
-  }
-  buildOrUpdateElements(resetNewElements) {
-    const meta = this._cachedMeta;
-    const dataset = this.getDataset();
-    let stackChanged = false;
-    this._dataCheck();
-    const oldStacked = meta._stacked;
-    meta._stacked = isStacked(meta.vScale, meta);
-    if (meta.stack !== dataset.stack) {
-      stackChanged = true;
-      clearStacks(meta);
-      meta.stack = dataset.stack;
-    }
-    this._resyncElements(resetNewElements);
-    if (stackChanged || oldStacked !== meta._stacked) {
-      updateStacks(this, meta._parsed);
-      meta._stacked = isStacked(meta.vScale, meta);
-    }
-  }
-  configure() {
-    const config = this.chart.config;
-    const scopeKeys = config.datasetScopeKeys(this._type);
-    const scopes = config.getOptionScopes(this.getDataset(), scopeKeys, true);
-    this.options = config.createResolver(scopes, this.getContext());
-    this._parsing = this.options.parsing;
-    this._cachedDataOpts = {};
-  }
-  parse(start, count) {
-    const { _cachedMeta: meta, _data: data } = this;
-    const { iScale, _stacked } = meta;
-    const iAxis = iScale.axis;
-    let sorted = start === 0 && count === data.length ? true : meta._sorted;
-    let prev = start > 0 && meta._parsed[start - 1];
-    let i, cur, parsed;
-    if (this._parsing === false) {
-      meta._parsed = data;
-      meta._sorted = true;
-      parsed = data;
-    } else {
-      if (isArray(data[start])) {
-        parsed = this.parseArrayData(meta, data, start, count);
-      } else if (isObject(data[start])) {
-        parsed = this.parseObjectData(meta, data, start, count);
-      } else {
-        parsed = this.parsePrimitiveData(meta, data, start, count);
-      }
-      const isNotInOrderComparedToPrev = () => cur[iAxis] === null || prev && cur[iAxis] < prev[iAxis];
-      for (i = 0; i < count; ++i) {
-        meta._parsed[i + start] = cur = parsed[i];
-        if (sorted) {
-          if (isNotInOrderComparedToPrev()) {
-            sorted = false;
+      });
+      var require_scattergeo = __commonJS({
+        "src/traces/scattergeo/index.js"(exports, module2) {
+          module2.exports = {
+            attributes: require_attributes48(),
+            supplyDefaults: require_defaults44(),
+            colorbar: require_marker_colorbar(),
+            formatLabels: require_format_labels3(),
+            calc: require_calc27(),
+            calcGeoJSON: require_plot17().calcGeoJSON,
+            plot: require_plot17().plot,
+            style: require_style17(),
+            styleOnSelect: require_style2().styleOnSelect,
+            hoverPoints: require_hover14(),
+            eventData: require_event_data9(),
+            selectPoints: require_select5(),
+            moduleType: "trace",
+            name: "scattergeo",
+            basePlotModule: require_geo2(),
+            categories: ["geo", "symbols", "showLegend", "scatter-like"],
+            meta: {}
+          };
+        }
+      });
+      var require_scattergeo2 = __commonJS({
+        "lib/scattergeo.js"(exports, module2) {
+          module2.exports = require_scattergeo();
+        }
+      });
+      var require_attributes49 = __commonJS({
+        "src/traces/choropleth/attributes.js"(exports, module2) {
+          var { hovertemplateAttrs, templatefallbackAttrs } = require_template_attributes();
+          var scatterGeoAttrs = require_attributes48();
+          var colorScaleAttrs = require_attributes8();
+          var baseAttrs = require_attributes2();
+          var defaultLine = require_attributes3().defaultLine;
+          var extendFlat = require_extend().extendFlat;
+          var scatterGeoMarkerLineAttrs = scatterGeoAttrs.marker.line;
+          module2.exports = extendFlat(
+            {
+              locations: {
+                valType: "data_array",
+                editType: "calc"
+              },
+              locationmode: scatterGeoAttrs.locationmode,
+              z: {
+                valType: "data_array",
+                editType: "calc"
+              },
+              geojson: extendFlat({}, scatterGeoAttrs.geojson, {}),
+              featureidkey: scatterGeoAttrs.featureidkey,
+              text: extendFlat({}, scatterGeoAttrs.text, {}),
+              hovertext: extendFlat({}, scatterGeoAttrs.hovertext, {}),
+              marker: {
+                line: {
+                  color: extendFlat({}, scatterGeoMarkerLineAttrs.color, { dflt: defaultLine }),
+                  width: extendFlat({}, scatterGeoMarkerLineAttrs.width, { dflt: 1 }),
+                  editType: "calc"
+                },
+                opacity: {
+                  valType: "number",
+                  arrayOk: true,
+                  min: 0,
+                  max: 1,
+                  dflt: 1,
+                  editType: "style"
+                },
+                editType: "calc"
+              },
+              selected: {
+                marker: {
+                  opacity: scatterGeoAttrs.selected.marker.opacity,
+                  editType: "plot"
+                },
+                editType: "plot"
+              },
+              unselected: {
+                marker: {
+                  opacity: scatterGeoAttrs.unselected.marker.opacity,
+                  editType: "plot"
+                },
+                editType: "plot"
+              },
+              hoverinfo: extendFlat({}, baseAttrs.hoverinfo, {
+                editType: "calc",
+                flags: ["location", "z", "text", "name"]
+              }),
+              hovertemplate: hovertemplateAttrs(),
+              hovertemplatefallback: templatefallbackAttrs(),
+              showlegend: extendFlat({}, baseAttrs.showlegend, { dflt: false })
+            },
+            colorScaleAttrs("", {
+              cLetter: "z",
+              editTypeOverride: "calc"
+            })
+          );
+        }
+      });
+      var require_defaults45 = __commonJS({
+        "src/traces/choropleth/defaults.js"(exports, module2) {
+          var Lib = require_lib();
+          var colorscaleDefaults = require_defaults2();
+          var attributes = require_attributes49();
+          var locationmodeBreakingChangeWarning = [
+            "The library used by the *country names* `locationmode` option is changing in the next major version.",
+            "Some country names in existing plots may not work in the new version.",
+            "To ensure consistent behavior, consider setting `locationmode` to *ISO-3*."
+          ].join(" ");
+          module2.exports = function supplyDefaults(traceIn, traceOut, defaultColor, layout) {
+            function coerce(attr, dflt) {
+              return Lib.coerce(traceIn, traceOut, attributes, attr, dflt);
+            }
+            var locations = coerce("locations");
+            var z2 = coerce("z");
+            if (!(locations && locations.length && Lib.isArrayOrTypedArray(z2) && z2.length)) {
+              traceOut.visible = false;
+              return;
+            }
+            traceOut._length = Math.min(locations.length, z2.length);
+            var geojson = coerce("geojson");
+            var locationmodeDflt;
+            if (typeof geojson === "string" && geojson !== "" || Lib.isPlainObject(geojson)) {
+              locationmodeDflt = "geojson-id";
+            }
+            var locationMode = coerce("locationmode", locationmodeDflt);
+            if (locationMode === "country names") {
+              Lib.warn(locationmodeBreakingChangeWarning);
+            }
+            if (locationMode === "geojson-id") {
+              coerce("featureidkey");
+            }
+            coerce("text");
+            coerce("hovertext");
+            coerce("hovertemplate");
+            coerce("hovertemplatefallback");
+            var mlw = coerce("marker.line.width");
+            if (mlw) coerce("marker.line.color");
+            coerce("marker.opacity");
+            colorscaleDefaults(traceIn, traceOut, layout, coerce, { prefix: "", cLetter: "z" });
+            Lib.coerceSelectionMarkerOpacity(traceOut, coerce);
+          };
+        }
+      });
+      var require_calc28 = __commonJS({
+        "src/traces/choropleth/calc.js"(exports, module2) {
+          var isNumeric = require_fast_isnumeric();
+          var BADNUM = require_numerical().BADNUM;
+          var colorscaleCalc = require_calc();
+          var arraysToCalcdata = require_arrays_to_calcdata();
+          var calcSelection = require_calc_selection();
+          function isNonBlankString(v2) {
+            return v2 && typeof v2 === "string";
           }
-          prev = cur;
+          module2.exports = function calc(gd2, trace) {
+            var len2 = trace._length;
+            var calcTrace = new Array(len2);
+            var isValidLoc;
+            if (trace.geojson) {
+              isValidLoc = function(v2) {
+                return isNonBlankString(v2) || isNumeric(v2);
+              };
+            } else {
+              isValidLoc = isNonBlankString;
+            }
+            for (var i2 = 0; i2 < len2; i2++) {
+              var calcPt = calcTrace[i2] = {};
+              var loc = trace.locations[i2];
+              var z2 = trace.z[i2];
+              if (isValidLoc(loc) && isNumeric(z2)) {
+                calcPt.loc = loc;
+                calcPt.z = z2;
+              } else {
+                calcPt.loc = null;
+                calcPt.z = BADNUM;
+              }
+              calcPt.index = i2;
+            }
+            arraysToCalcdata(calcTrace, trace);
+            colorscaleCalc(gd2, trace, {
+              vals: trace.z,
+              containerStr: "",
+              cLetter: "z"
+            });
+            calcSelection(calcTrace, trace);
+            return calcTrace;
+          };
         }
-      }
-      meta._sorted = sorted;
-    }
-    if (_stacked) {
-      updateStacks(this, parsed);
-    }
-  }
-  parsePrimitiveData(meta, data, start, count) {
-    const { iScale, vScale } = meta;
-    const iAxis = iScale.axis;
-    const vAxis = vScale.axis;
-    const labels = iScale.getLabels();
-    const singleScale = iScale === vScale;
-    const parsed = new Array(count);
-    let i, ilen, index;
-    for (i = 0, ilen = count; i < ilen; ++i) {
-      index = i + start;
-      parsed[i] = {
-        [iAxis]: singleScale || iScale.parse(labels[index], index),
-        [vAxis]: vScale.parse(data[index], index)
-      };
-    }
-    return parsed;
-  }
-  parseArrayData(meta, data, start, count) {
-    const { xScale, yScale } = meta;
-    const parsed = new Array(count);
-    let i, ilen, index, item;
-    for (i = 0, ilen = count; i < ilen; ++i) {
-      index = i + start;
-      item = data[index];
-      parsed[i] = {
-        x: xScale.parse(item[0], index),
-        y: yScale.parse(item[1], index)
-      };
-    }
-    return parsed;
-  }
-  parseObjectData(meta, data, start, count) {
-    const { xScale, yScale } = meta;
-    const { xAxisKey = "x", yAxisKey = "y" } = this._parsing;
-    const parsed = new Array(count);
-    let i, ilen, index, item;
-    for (i = 0, ilen = count; i < ilen; ++i) {
-      index = i + start;
-      item = data[index];
-      parsed[i] = {
-        x: xScale.parse(resolveObjectKey(item, xAxisKey), index),
-        y: yScale.parse(resolveObjectKey(item, yAxisKey), index)
-      };
-    }
-    return parsed;
-  }
-  getParsed(index) {
-    return this._cachedMeta._parsed[index];
-  }
-  getDataElement(index) {
-    return this._cachedMeta.data[index];
-  }
-  applyStack(scale, parsed, mode) {
-    const chart = this.chart;
-    const meta = this._cachedMeta;
-    const value = parsed[scale.axis];
-    const stack = {
-      keys: getSortedDatasetIndices(chart, true),
-      values: parsed._stacks[scale.axis]._visualValues
-    };
-    return applyStack(stack, value, meta.index, {
-      mode
-    });
-  }
-  updateRangeFromParsed(range, scale, parsed, stack) {
-    const parsedValue = parsed[scale.axis];
-    let value = parsedValue === null ? NaN : parsedValue;
-    const values = stack && parsed._stacks[scale.axis];
-    if (stack && values) {
-      stack.values = values;
-      value = applyStack(stack, parsedValue, this._cachedMeta.index);
-    }
-    range.min = Math.min(range.min, value);
-    range.max = Math.max(range.max, value);
-  }
-  getMinMax(scale, canStack) {
-    const meta = this._cachedMeta;
-    const _parsed = meta._parsed;
-    const sorted = meta._sorted && scale === meta.iScale;
-    const ilen = _parsed.length;
-    const otherScale = this._getOtherScale(scale);
-    const stack = createStack(canStack, meta, this.chart);
-    const range = {
-      min: Number.POSITIVE_INFINITY,
-      max: Number.NEGATIVE_INFINITY
-    };
-    const { min: otherMin, max: otherMax } = getUserBounds(otherScale);
-    let i, parsed;
-    function _skip() {
-      parsed = _parsed[i];
-      const otherValue = parsed[otherScale.axis];
-      return !isNumberFinite(parsed[scale.axis]) || otherMin > otherValue || otherMax < otherValue;
-    }
-    for (i = 0; i < ilen; ++i) {
-      if (_skip()) {
-        continue;
-      }
-      this.updateRangeFromParsed(range, scale, parsed, stack);
-      if (sorted) {
-        break;
-      }
-    }
-    if (sorted) {
-      for (i = ilen - 1; i >= 0; --i) {
-        if (_skip()) {
-          continue;
+      });
+      var require_style18 = __commonJS({
+        "src/traces/choropleth/style.js"(exports, module2) {
+          var d3 = require_d3();
+          var Color2 = require_color();
+          var Drawing = require_drawing();
+          var Colorscale = require_colorscale();
+          function style(gd2, calcTrace) {
+            if (calcTrace) styleTrace(gd2, calcTrace);
+          }
+          function styleTrace(gd2, calcTrace) {
+            var trace = calcTrace[0].trace;
+            var s2 = calcTrace[0].node3;
+            var locs = s2.selectAll(".choroplethlocation");
+            var marker = trace.marker || {};
+            var markerLine = marker.line || {};
+            var sclFunc = Colorscale.makeColorScaleFuncFromTrace(trace);
+            locs.each(function(d2) {
+              d3.select(this).attr("fill", sclFunc(d2.z)).call(Color2.stroke, d2.mlc || markerLine.color).call(Drawing.dashLine, "", d2.mlw || markerLine.width || 0).style("opacity", marker.opacity);
+            });
+            Drawing.selectedPointStyle(locs, trace);
+          }
+          function styleOnSelect(gd2, calcTrace) {
+            var s2 = calcTrace[0].node3;
+            var trace = calcTrace[0].trace;
+            if (trace.selectedpoints) {
+              Drawing.selectedPointStyle(s2.selectAll(".choroplethlocation"), trace);
+            } else {
+              styleTrace(gd2, calcTrace);
+            }
+          }
+          module2.exports = {
+            style,
+            styleOnSelect
+          };
+        }
+      });
+      var require_plot18 = __commonJS({
+        "src/traces/choropleth/plot.js"(exports, module2) {
+          var d3 = require_d3();
+          var Lib = require_lib();
+          var geoUtils = require_geo_location_utils();
+          var getTopojsonFeatures = require_topojson_utils().getTopojsonFeatures;
+          var findExtremes = require_autorange().findExtremes;
+          var style = require_style18().style;
+          function plot(gd2, geo, calcData) {
+            var choroplethLayer = geo.layers.backplot.select(".choroplethlayer");
+            Lib.makeTraceGroups(choroplethLayer, calcData, "trace choropleth").each(function(calcTrace) {
+              var sel = d3.select(this);
+              var paths = sel.selectAll("path.choroplethlocation").data(Lib.identity);
+              paths.enter().append("path").classed("choroplethlocation", true);
+              paths.exit().remove();
+              style(gd2, calcTrace);
+            });
+          }
+          function calcGeoJSON(calcTrace, fullLayout) {
+            var trace = calcTrace[0].trace;
+            var geoLayout = fullLayout[trace.geo];
+            var geo = geoLayout._subplot;
+            var locationmode = trace.locationmode;
+            var len2 = trace._length;
+            var features = locationmode === "geojson-id" ? geoUtils.extractTraceFeature(calcTrace) : getTopojsonFeatures(trace, geo.topojson);
+            var lonArray = [];
+            var latArray = [];
+            for (var i2 = 0; i2 < len2; i2++) {
+              var calcPt = calcTrace[i2];
+              var feature = locationmode === "geojson-id" ? calcPt.fOut : geoUtils.locationToFeature(locationmode, calcPt.loc, features);
+              if (feature) {
+                calcPt.geojson = feature;
+                calcPt.ct = feature.properties.ct;
+                calcPt._polygons = geoUtils.feature2polygons(feature);
+                var bboxFeature = geoUtils.computeBbox(feature);
+                lonArray.push(bboxFeature[0], bboxFeature[2]);
+                latArray.push(bboxFeature[1], bboxFeature[3]);
+              } else {
+                calcPt.geojson = null;
+              }
+            }
+            if (geoLayout.fitbounds === "geojson" && locationmode === "geojson-id") {
+              var bboxGeojson = geoUtils.computeBbox(geoUtils.getTraceGeojson(trace));
+              lonArray = [bboxGeojson[0], bboxGeojson[2]];
+              latArray = [bboxGeojson[1], bboxGeojson[3]];
+            }
+            var opts = { padded: true };
+            trace._extremes.lon = findExtremes(geoLayout.lonaxis._ax, lonArray, opts);
+            trace._extremes.lat = findExtremes(geoLayout.lataxis._ax, latArray, opts);
+          }
+          module2.exports = {
+            calcGeoJSON,
+            plot
+          };
+        }
+      });
+      var require_hover15 = __commonJS({
+        "src/traces/choropleth/hover.js"(exports, module2) {
+          var Axes = require_axes();
+          var attributes = require_attributes49();
+          var fillText = require_lib().fillText;
+          module2.exports = function hoverPoints(pointData, xval, yval) {
+            var cd2 = pointData.cd;
+            var trace = cd2[0].trace;
+            var geo = pointData.subplot;
+            var pt2, i2, j2, isInside;
+            var xy = [xval, yval];
+            var altXy = [xval + 360, yval];
+            for (i2 = 0; i2 < cd2.length; i2++) {
+              pt2 = cd2[i2];
+              isInside = false;
+              if (pt2._polygons) {
+                for (j2 = 0; j2 < pt2._polygons.length; j2++) {
+                  if (pt2._polygons[j2].contains(xy)) {
+                    isInside = !isInside;
+                  }
+                  if (pt2._polygons[j2].contains(altXy)) {
+                    isInside = !isInside;
+                  }
+                }
+                if (isInside) break;
+              }
+            }
+            if (!isInside || !pt2) return;
+            pointData.x0 = pointData.x1 = pointData.xa.c2p(pt2.ct);
+            pointData.y0 = pointData.y1 = pointData.ya.c2p(pt2.ct);
+            pointData.index = pt2.index;
+            pointData.location = pt2.loc;
+            pointData.z = pt2.z;
+            pointData.zLabel = Axes.tickText(geo.mockAxis, geo.mockAxis.c2l(pt2.z), "hover").text;
+            pointData.hovertemplate = pt2.hovertemplate;
+            makeHoverInfo(pointData, trace, pt2);
+            return [pointData];
+          };
+          function makeHoverInfo(pointData, trace, pt2) {
+            if (trace.hovertemplate) return;
+            var hoverinfo = pt2.hi || trace.hoverinfo;
+            var loc = String(pt2.loc);
+            var parts = hoverinfo === "all" ? attributes.hoverinfo.flags : hoverinfo.split("+");
+            var hasName = parts.indexOf("name") !== -1;
+            var hasLocation = parts.indexOf("location") !== -1;
+            var hasZ = parts.indexOf("z") !== -1;
+            var hasText = parts.indexOf("text") !== -1;
+            var hasIdAsNameLabel = !hasName && hasLocation;
+            var text = [];
+            if (hasIdAsNameLabel) {
+              pointData.nameOverride = loc;
+            } else {
+              if (hasName) pointData.nameOverride = trace.name;
+              if (hasLocation) text.push(loc);
+            }
+            if (hasZ) {
+              text.push(pointData.zLabel);
+            }
+            if (hasText) {
+              fillText(pt2, trace, text);
+            }
+            pointData.extraText = text.join("<br>");
+          }
+        }
+      });
+      var require_event_data10 = __commonJS({
+        "src/traces/choropleth/event_data.js"(exports, module2) {
+          module2.exports = function eventData(out, pt2, trace, cd2, pointNumber) {
+            out.location = pt2.location;
+            out.z = pt2.z;
+            var cdi = cd2[pointNumber];
+            if (cdi.fIn && cdi.fIn.properties) {
+              out.properties = cdi.fIn.properties;
+            }
+            out.ct = cdi.ct;
+            return out;
+          };
+        }
+      });
+      var require_select6 = __commonJS({
+        "src/traces/choropleth/select.js"(exports, module2) {
+          module2.exports = function selectPoints(searchInfo, selectionTester) {
+            var cd2 = searchInfo.cd;
+            var xa = searchInfo.xaxis;
+            var ya2 = searchInfo.yaxis;
+            var selection = [];
+            var i2, di2, ct2, x2, y2;
+            if (selectionTester === false) {
+              for (i2 = 0; i2 < cd2.length; i2++) {
+                cd2[i2].selected = 0;
+              }
+            } else {
+              for (i2 = 0; i2 < cd2.length; i2++) {
+                di2 = cd2[i2];
+                ct2 = di2.ct;
+                if (!ct2) continue;
+                x2 = xa.c2p(ct2);
+                y2 = ya2.c2p(ct2);
+                if (selectionTester.contains([x2, y2], null, i2, searchInfo)) {
+                  selection.push({
+                    pointNumber: i2,
+                    lon: ct2[0],
+                    lat: ct2[1]
+                  });
+                  di2.selected = 1;
+                } else {
+                  di2.selected = 0;
+                }
+              }
+            }
+            return selection;
+          };
+        }
+      });
+      var require_choropleth = __commonJS({
+        "src/traces/choropleth/index.js"(exports, module2) {
+          module2.exports = {
+            attributes: require_attributes49(),
+            supplyDefaults: require_defaults45(),
+            colorbar: require_colorbar2(),
+            calc: require_calc28(),
+            calcGeoJSON: require_plot18().calcGeoJSON,
+            plot: require_plot18().plot,
+            style: require_style18().style,
+            styleOnSelect: require_style18().styleOnSelect,
+            hoverPoints: require_hover15(),
+            eventData: require_event_data10(),
+            selectPoints: require_select6(),
+            moduleType: "trace",
+            name: "choropleth",
+            basePlotModule: require_geo2(),
+            categories: ["geo", "noOpacity", "showLegend"],
+            meta: {}
+          };
+        }
+      });
+      var require_choropleth2 = __commonJS({
+        "lib/choropleth.js"(exports, module2) {
+          module2.exports = require_choropleth();
+        }
+      });
+      var require_hover16 = __commonJS({
+        "src/traces/scattergl/hover.js"(exports, module2) {
+          var Registry = require_registry();
+          var Lib = require_lib();
+          var getTraceColor = require_get_trace_color();
+          function hoverPoints(pointData, xval, yval, hovermode) {
+            var cd2 = pointData.cd;
+            var stash = cd2[0].t;
+            var trace = cd2[0].trace;
+            var xa = pointData.xa;
+            var ya2 = pointData.ya;
+            var x2 = stash.x;
+            var y2 = stash.y;
+            var xpx = xa.c2p(xval);
+            var ypx = ya2.c2p(yval);
+            var maxDistance = pointData.distance;
+            var ids;
+            if (stash.tree) {
+              var xl = xa.p2c(xpx - maxDistance);
+              var xr = xa.p2c(xpx + maxDistance);
+              var yl = ya2.p2c(ypx - maxDistance);
+              var yr = ya2.p2c(ypx + maxDistance);
+              if (hovermode === "x") {
+                ids = stash.tree.range(
+                  Math.min(xl, xr),
+                  Math.min(ya2._rl[0], ya2._rl[1]),
+                  Math.max(xl, xr),
+                  Math.max(ya2._rl[0], ya2._rl[1])
+                );
+              } else {
+                ids = stash.tree.range(
+                  Math.min(xl, xr),
+                  Math.min(yl, yr),
+                  Math.max(xl, xr),
+                  Math.max(yl, yr)
+                );
+              }
+            } else {
+              ids = stash.ids;
+            }
+            var k2, closestId, ptx, pty, i2, dx, dy, dist, dxy;
+            var minDist = maxDistance;
+            if (hovermode === "x") {
+              var xPeriod = !!trace.xperiodalignment;
+              var yPeriod = !!trace.yperiodalignment;
+              for (i2 = 0; i2 < ids.length; i2++) {
+                k2 = ids[i2];
+                ptx = x2[k2];
+                dx = Math.abs(xa.c2p(ptx) - xpx);
+                if (xPeriod) {
+                  var x0 = xa.c2p(trace._xStarts[k2]);
+                  var x1 = xa.c2p(trace._xEnds[k2]);
+                  dx = xpx >= Math.min(x0, x1) && xpx <= Math.max(x0, x1) ? 0 : Infinity;
+                }
+                if (dx < minDist) {
+                  minDist = dx;
+                  pty = y2[k2];
+                  dy = ya2.c2p(pty) - ypx;
+                  if (yPeriod) {
+                    var y0 = ya2.c2p(trace._yStarts[k2]);
+                    var y1 = ya2.c2p(trace._yEnds[k2]);
+                    dy = ypx >= Math.min(y0, y1) && ypx <= Math.max(y0, y1) ? 0 : Infinity;
+                  }
+                  dxy = Math.sqrt(dx * dx + dy * dy);
+                  closestId = ids[i2];
+                }
+              }
+            } else {
+              for (i2 = ids.length - 1; i2 > -1; i2--) {
+                k2 = ids[i2];
+                ptx = x2[k2];
+                pty = y2[k2];
+                dx = xa.c2p(ptx) - xpx;
+                dy = ya2.c2p(pty) - ypx;
+                dist = Math.sqrt(dx * dx + dy * dy);
+                if (dist < minDist) {
+                  minDist = dxy = dist;
+                  closestId = k2;
+                }
+              }
+            }
+            pointData.index = closestId;
+            pointData.distance = minDist;
+            pointData.dxy = dxy;
+            if (closestId === void 0) return [pointData];
+            return [calcHover(pointData, x2, y2, trace)];
+          }
+          function calcHover(pointData, x2, y2, trace) {
+            var xa = pointData.xa;
+            var ya2 = pointData.ya;
+            var minDist = pointData.distance;
+            var dxy = pointData.dxy;
+            var id2 = pointData.index;
+            var di2 = {
+              pointNumber: id2,
+              x: x2[id2],
+              y: y2[id2]
+            };
+            di2.tx = Lib.isArrayOrTypedArray(trace.text) ? trace.text[id2] : trace.text;
+            di2.htx = Array.isArray(trace.hovertext) ? trace.hovertext[id2] : trace.hovertext;
+            di2.data = Array.isArray(trace.customdata) ? trace.customdata[id2] : trace.customdata;
+            di2.tp = Array.isArray(trace.textposition) ? trace.textposition[id2] : trace.textposition;
+            var font = trace.textfont;
+            if (font) {
+              di2.ts = Lib.isArrayOrTypedArray(font.size) ? font.size[id2] : font.size;
+              di2.tc = Lib.isArrayOrTypedArray(font.color) ? font.color[id2] : font.color;
+              di2.tf = Array.isArray(font.family) ? font.family[id2] : font.family;
+              di2.tw = Array.isArray(font.weight) ? font.weight[id2] : font.weight;
+              di2.ty = Array.isArray(font.style) ? font.style[id2] : font.style;
+              di2.tv = Array.isArray(font.variant) ? font.variant[id2] : font.variant;
+            }
+            var marker = trace.marker;
+            if (marker) {
+              di2.ms = Lib.isArrayOrTypedArray(marker.size) ? marker.size[id2] : marker.size;
+              di2.mo = Lib.isArrayOrTypedArray(marker.opacity) ? marker.opacity[id2] : marker.opacity;
+              di2.mx = Lib.isArrayOrTypedArray(marker.symbol) ? marker.symbol[id2] : marker.symbol;
+              di2.ma = Lib.isArrayOrTypedArray(marker.angle) ? marker.angle[id2] : marker.angle;
+              di2.mc = Lib.isArrayOrTypedArray(marker.color) ? marker.color[id2] : marker.color;
+            }
+            var line = marker && marker.line;
+            if (line) {
+              di2.mlc = Array.isArray(line.color) ? line.color[id2] : line.color;
+              di2.mlw = Lib.isArrayOrTypedArray(line.width) ? line.width[id2] : line.width;
+            }
+            var grad = marker && marker.gradient;
+            if (grad && grad.type !== "none") {
+              di2.mgt = Array.isArray(grad.type) ? grad.type[id2] : grad.type;
+              di2.mgc = Array.isArray(grad.color) ? grad.color[id2] : grad.color;
+            }
+            var xp = xa.c2p(di2.x, true);
+            var yp = ya2.c2p(di2.y, true);
+            var rad = di2.mrc || 1;
+            var hoverlabel = trace.hoverlabel;
+            if (hoverlabel) {
+              di2.hbg = Array.isArray(hoverlabel.bgcolor) ? hoverlabel.bgcolor[id2] : hoverlabel.bgcolor;
+              di2.hbc = Array.isArray(hoverlabel.bordercolor) ? hoverlabel.bordercolor[id2] : hoverlabel.bordercolor;
+              di2.hts = Lib.isArrayOrTypedArray(hoverlabel.font.size) ? hoverlabel.font.size[id2] : hoverlabel.font.size;
+              di2.htc = Array.isArray(hoverlabel.font.color) ? hoverlabel.font.color[id2] : hoverlabel.font.color;
+              di2.htf = Array.isArray(hoverlabel.font.family) ? hoverlabel.font.family[id2] : hoverlabel.font.family;
+              di2.hnl = Lib.isArrayOrTypedArray(hoverlabel.namelength) ? hoverlabel.namelength[id2] : hoverlabel.namelength;
+            }
+            var hoverinfo = trace.hoverinfo;
+            if (hoverinfo) {
+              di2.hi = Array.isArray(hoverinfo) ? hoverinfo[id2] : hoverinfo;
+            }
+            var hovertemplate = trace.hovertemplate;
+            if (hovertemplate) {
+              di2.ht = Array.isArray(hovertemplate) ? hovertemplate[id2] : hovertemplate;
+            }
+            var fakeCd = {};
+            fakeCd[pointData.index] = di2;
+            var origX = trace._origX;
+            var origY = trace._origY;
+            var pointData2 = Lib.extendFlat({}, pointData, {
+              color: getTraceColor(trace, di2),
+              x0: xp - rad,
+              x1: xp + rad,
+              xLabelVal: origX ? origX[id2] : di2.x,
+              y0: yp - rad,
+              y1: yp + rad,
+              yLabelVal: origY ? origY[id2] : di2.y,
+              cd: fakeCd,
+              distance: minDist,
+              spikeDistance: dxy,
+              hovertemplate: di2.ht
+            });
+            if (di2.htx) pointData2.text = di2.htx;
+            else if (di2.tx) pointData2.text = di2.tx;
+            else if (trace.text) pointData2.text = trace.text;
+            Lib.fillText(di2, trace, pointData2);
+            Registry.getComponentMethod("errorbars", "hoverInfo")(di2, trace, pointData2);
+            return pointData2;
+          }
+          module2.exports = {
+            hoverPoints,
+            calcHover
+          };
+        }
+      });
+      var require_constants23 = __commonJS({
+        "src/traces/scattergl/constants.js"(exports, module2) {
+          var SYMBOL_SIZE = 20;
+          module2.exports = {
+            TOO_MANY_POINTS: 1e5,
+            SYMBOL_SDF_SIZE: 200,
+            SYMBOL_SIZE,
+            SYMBOL_STROKE: SYMBOL_SIZE / 20,
+            DOT_RE: /-dot/,
+            OPEN_RE: /-open/,
+            DASHES: {
+              solid: [1],
+              dot: [1, 1],
+              dash: [4, 1],
+              longdash: [8, 1],
+              dashdot: [4, 1, 1, 1],
+              longdashdot: [8, 1, 1, 1]
+            }
+          };
+        }
+      });
+      var require_attributes50 = __commonJS({
+        "src/traces/scattergl/attributes.js"(exports, module2) {
+          var baseAttrs = require_attributes2();
+          var fontAttrs = require_font_attributes();
+          var makeFillcolorAttr = require_fillcolor_attribute();
+          var scatterAttrs = require_attributes12();
+          var axisHoverFormat = require_axis_format_attributes().axisHoverFormat;
+          var colorScaleAttrs = require_attributes8();
+          var sortObjectKeys = require_sort_object_keys();
+          var extendFlat = require_extend().extendFlat;
+          var overrideAll = require_edit_types().overrideAll;
+          var DASHES = require_constants23().DASHES;
+          var scatterLineAttrs = scatterAttrs.line;
+          var scatterMarkerAttrs = scatterAttrs.marker;
+          var scatterMarkerLineAttrs = scatterMarkerAttrs.line;
+          var attrs = module2.exports = overrideAll(
+            {
+              x: scatterAttrs.x,
+              x0: scatterAttrs.x0,
+              dx: scatterAttrs.dx,
+              y: scatterAttrs.y,
+              y0: scatterAttrs.y0,
+              dy: scatterAttrs.dy,
+              xperiod: scatterAttrs.xperiod,
+              yperiod: scatterAttrs.yperiod,
+              xperiod0: scatterAttrs.xperiod0,
+              yperiod0: scatterAttrs.yperiod0,
+              xperiodalignment: scatterAttrs.xperiodalignment,
+              yperiodalignment: scatterAttrs.yperiodalignment,
+              xhoverformat: axisHoverFormat("x"),
+              yhoverformat: axisHoverFormat("y"),
+              text: scatterAttrs.text,
+              hovertext: scatterAttrs.hovertext,
+              textposition: scatterAttrs.textposition,
+              textfont: fontAttrs({
+                noFontShadow: true,
+                noFontLineposition: true,
+                noFontTextcase: true,
+                editType: "calc",
+                colorEditType: "style",
+                arrayOk: true,
+                noNumericWeightValues: true,
+                variantValues: ["normal", "small-caps"]
+              }),
+              mode: {
+                valType: "flaglist",
+                flags: ["lines", "markers", "text"],
+                extras: ["none"]
+              },
+              line: {
+                color: scatterLineAttrs.color,
+                width: scatterLineAttrs.width,
+                shape: {
+                  valType: "enumerated",
+                  values: ["linear", "hv", "vh", "hvh", "vhv"],
+                  dflt: "linear",
+                  editType: "plot"
+                },
+                dash: {
+                  valType: "enumerated",
+                  values: sortObjectKeys(DASHES),
+                  dflt: "solid"
+                }
+              },
+              marker: extendFlat({}, colorScaleAttrs("marker"), {
+                symbol: scatterMarkerAttrs.symbol,
+                angle: scatterMarkerAttrs.angle,
+                size: scatterMarkerAttrs.size,
+                sizeref: scatterMarkerAttrs.sizeref,
+                sizemin: scatterMarkerAttrs.sizemin,
+                sizemode: scatterMarkerAttrs.sizemode,
+                opacity: scatterMarkerAttrs.opacity,
+                colorbar: scatterMarkerAttrs.colorbar,
+                line: extendFlat({}, colorScaleAttrs("marker.line"), {
+                  width: scatterMarkerLineAttrs.width
+                })
+              }),
+              connectgaps: scatterAttrs.connectgaps,
+              fill: extendFlat({}, scatterAttrs.fill, { dflt: "none" }),
+              fillcolor: makeFillcolorAttr(),
+              // no hoveron
+              selected: {
+                marker: scatterAttrs.selected.marker,
+                textfont: scatterAttrs.selected.textfont
+              },
+              unselected: {
+                marker: scatterAttrs.unselected.marker,
+                textfont: scatterAttrs.unselected.textfont
+              },
+              opacity: baseAttrs.opacity
+            },
+            "calc",
+            "nested"
+          );
+          attrs.x.editType = attrs.y.editType = attrs.x0.editType = attrs.y0.editType = "calc+clearAxisTypes";
+          attrs.hovertemplate = scatterAttrs.hovertemplate;
+          attrs.hovertemplatefallback = scatterAttrs.hovertemplatefallback;
+          attrs.texttemplate = scatterAttrs.texttemplate;
+          attrs.texttemplatefallback = scatterAttrs.texttemplatefallback;
+        }
+      });
+      var require_helpers16 = __commonJS({
+        "src/traces/scattergl/helpers.js"(exports) {
+          var constants = require_constants23();
+          exports.isOpenSymbol = function(symbol) {
+            return typeof symbol === "string" ? constants.OPEN_RE.test(symbol) : symbol % 200 > 100;
+          };
+          exports.isDotSymbol = function(symbol) {
+            return typeof symbol === "string" ? constants.DOT_RE.test(symbol) : symbol > 200;
+          };
+        }
+      });
+      var require_defaults46 = __commonJS({
+        "src/traces/scattergl/defaults.js"(exports, module2) {
+          var Lib = require_lib();
+          var Registry = require_registry();
+          var helpers = require_helpers16();
+          var attributes = require_attributes50();
+          var constants = require_constants8();
+          var subTypes = require_subtypes();
+          var handleXYDefaults = require_xy_defaults();
+          var handlePeriodDefaults = require_period_defaults();
+          var handleMarkerDefaults = require_marker_defaults();
+          var handleLineDefaults = require_line_defaults();
+          var handleFillColorDefaults = require_fillcolor_defaults();
+          var handleTextDefaults = require_text_defaults();
+          module2.exports = function supplyDefaults(traceIn, traceOut, defaultColor, layout) {
+            function coerce(attr, dflt) {
+              return Lib.coerce(traceIn, traceOut, attributes, attr, dflt);
+            }
+            var isOpen = traceIn.marker ? helpers.isOpenSymbol(traceIn.marker.symbol) : false;
+            var isBubble = subTypes.isBubble(traceIn);
+            var len2 = handleXYDefaults(traceIn, traceOut, layout, coerce);
+            if (!len2) {
+              traceOut.visible = false;
+              return;
+            }
+            handlePeriodDefaults(traceIn, traceOut, layout, coerce);
+            coerce("xhoverformat");
+            coerce("yhoverformat");
+            var defaultMode = len2 < constants.PTS_LINESONLY ? "lines+markers" : "lines";
+            coerce("text");
+            coerce("hovertext");
+            coerce("hovertemplate");
+            coerce("hovertemplatefallback");
+            coerce("mode", defaultMode);
+            if (subTypes.hasMarkers(traceOut)) {
+              handleMarkerDefaults(traceIn, traceOut, defaultColor, layout, coerce, {
+                noAngleRef: true,
+                noLineDash: true,
+                noStandOff: true
+              });
+              coerce("marker.line.width", isOpen || isBubble ? 1 : 0);
+            }
+            if (subTypes.hasLines(traceOut)) {
+              coerce("connectgaps");
+              handleLineDefaults(traceIn, traceOut, defaultColor, layout, coerce);
+              coerce("line.shape");
+            }
+            if (subTypes.hasText(traceOut)) {
+              coerce("texttemplate");
+              coerce("texttemplatefallback");
+              handleTextDefaults(traceIn, traceOut, layout, coerce, {
+                noFontShadow: true,
+                noFontLineposition: true,
+                noFontTextcase: true
+              });
+            }
+            var lineColor = (traceOut.line || {}).color;
+            var markerColor = (traceOut.marker || {}).color;
+            coerce("fill");
+            if (traceOut.fill !== "none") {
+              handleFillColorDefaults(traceIn, traceOut, defaultColor, coerce);
+            }
+            var errorBarsSupplyDefaults = Registry.getComponentMethod("errorbars", "supplyDefaults");
+            errorBarsSupplyDefaults(traceIn, traceOut, lineColor || markerColor || defaultColor, { axis: "y" });
+            errorBarsSupplyDefaults(traceIn, traceOut, lineColor || markerColor || defaultColor, { axis: "x", inherit: "y" });
+            Lib.coerceSelectionMarkerOpacity(traceOut, coerce);
+          };
+        }
+      });
+      var require_format_labels4 = __commonJS({
+        "src/traces/scattergl/format_labels.js"(exports, module2) {
+          var scatterFormatLabels = require_format_labels();
+          module2.exports = function formatLabels(cdi, trace, fullLayout) {
+            var i2 = cdi.i;
+            if (!("x" in cdi)) cdi.x = trace._x[i2];
+            if (!("y" in cdi)) cdi.y = trace._y[i2];
+            return scatterFormatLabels(cdi, trace, fullLayout);
+          };
+        }
+      });
+      var require_search_bounds = __commonJS({
+        "node_modules/binary-search-bounds/search-bounds.js"(exports, module2) {
+          function ge2(a2, y2, c2, l2, h2) {
+            var i2 = h2 + 1;
+            while (l2 <= h2) {
+              var m2 = l2 + h2 >>> 1, x2 = a2[m2];
+              var p2 = c2 !== void 0 ? c2(x2, y2) : x2 - y2;
+              if (p2 >= 0) {
+                i2 = m2;
+                h2 = m2 - 1;
+              } else {
+                l2 = m2 + 1;
+              }
+            }
+            return i2;
+          }
+          function gt2(a2, y2, c2, l2, h2) {
+            var i2 = h2 + 1;
+            while (l2 <= h2) {
+              var m2 = l2 + h2 >>> 1, x2 = a2[m2];
+              var p2 = c2 !== void 0 ? c2(x2, y2) : x2 - y2;
+              if (p2 > 0) {
+                i2 = m2;
+                h2 = m2 - 1;
+              } else {
+                l2 = m2 + 1;
+              }
+            }
+            return i2;
+          }
+          function lt2(a2, y2, c2, l2, h2) {
+            var i2 = l2 - 1;
+            while (l2 <= h2) {
+              var m2 = l2 + h2 >>> 1, x2 = a2[m2];
+              var p2 = c2 !== void 0 ? c2(x2, y2) : x2 - y2;
+              if (p2 < 0) {
+                i2 = m2;
+                l2 = m2 + 1;
+              } else {
+                h2 = m2 - 1;
+              }
+            }
+            return i2;
+          }
+          function le2(a2, y2, c2, l2, h2) {
+            var i2 = l2 - 1;
+            while (l2 <= h2) {
+              var m2 = l2 + h2 >>> 1, x2 = a2[m2];
+              var p2 = c2 !== void 0 ? c2(x2, y2) : x2 - y2;
+              if (p2 <= 0) {
+                i2 = m2;
+                l2 = m2 + 1;
+              } else {
+                h2 = m2 - 1;
+              }
+            }
+            return i2;
+          }
+          function eq(a2, y2, c2, l2, h2) {
+            while (l2 <= h2) {
+              var m2 = l2 + h2 >>> 1, x2 = a2[m2];
+              var p2 = c2 !== void 0 ? c2(x2, y2) : x2 - y2;
+              if (p2 === 0) {
+                return m2;
+              }
+              if (p2 <= 0) {
+                l2 = m2 + 1;
+              } else {
+                h2 = m2 - 1;
+              }
+            }
+            return -1;
+          }
+          function norm(a2, y2, c2, l2, h2, f2) {
+            if (typeof c2 === "function") {
+              return f2(a2, y2, c2, l2 === void 0 ? 0 : l2 | 0, h2 === void 0 ? a2.length - 1 : h2 | 0);
+            }
+            return f2(a2, y2, void 0, c2 === void 0 ? 0 : c2 | 0, l2 === void 0 ? a2.length - 1 : l2 | 0);
+          }
+          module2.exports = {
+            ge: function(a2, y2, c2, l2, h2) {
+              return norm(a2, y2, c2, l2, h2, ge2);
+            },
+            gt: function(a2, y2, c2, l2, h2) {
+              return norm(a2, y2, c2, l2, h2, gt2);
+            },
+            lt: function(a2, y2, c2, l2, h2) {
+              return norm(a2, y2, c2, l2, h2, lt2);
+            },
+            le: function(a2, y2, c2, l2, h2) {
+              return norm(a2, y2, c2, l2, h2, le2);
+            },
+            eq: function(a2, y2, c2, l2, h2) {
+              return norm(a2, y2, c2, l2, h2, eq);
+            }
+          };
         }
-        this.updateRangeFromParsed(range, scale, parsed, stack);
-        break;
-      }
-    }
-    return range;
-  }
-  getAllParsedValues(scale) {
-    const parsed = this._cachedMeta._parsed;
-    const values = [];
-    let i, ilen, value;
-    for (i = 0, ilen = parsed.length; i < ilen; ++i) {
-      value = parsed[i][scale.axis];
-      if (isNumberFinite(value)) {
-        values.push(value);
-      }
-    }
-    return values;
-  }
-  getMaxOverflow() {
-    return false;
-  }
-  getLabelAndValue(index) {
-    const meta = this._cachedMeta;
-    const iScale = meta.iScale;
-    const vScale = meta.vScale;
-    const parsed = this.getParsed(index);
-    return {
-      label: iScale ? "" + iScale.getLabelForValue(parsed[iScale.axis]) : "",
-      value: vScale ? "" + vScale.getLabelForValue(parsed[vScale.axis]) : ""
-    };
-  }
-  _update(mode) {
-    const meta = this._cachedMeta;
-    this.update(mode || "default");
-    meta._clip = toClip(valueOrDefault(this.options.clip, defaultClip(meta.xScale, meta.yScale, this.getMaxOverflow())));
-  }
-  update(mode) {
-  }
-  draw() {
-    const ctx = this._ctx;
-    const chart = this.chart;
-    const meta = this._cachedMeta;
-    const elements = meta.data || [];
-    const area = chart.chartArea;
-    const active = [];
-    const start = this._drawStart || 0;
-    const count = this._drawCount || elements.length - start;
-    const drawActiveElementsOnTop = this.options.drawActiveElementsOnTop;
-    let i;
-    if (meta.dataset) {
-      meta.dataset.draw(ctx, area, start, count);
-    }
-    for (i = start; i < start + count; ++i) {
-      const element = elements[i];
-      if (element.hidden) {
-        continue;
-      }
-      if (element.active && drawActiveElementsOnTop) {
-        active.push(element);
-      } else {
-        element.draw(ctx, area);
-      }
-    }
-    for (i = 0; i < active.length; ++i) {
-      active[i].draw(ctx, area);
-    }
-  }
-  getStyle(index, active) {
-    const mode = active ? "active" : "default";
-    return index === void 0 && this._cachedMeta.dataset ? this.resolveDatasetElementOptions(mode) : this.resolveDataElementOptions(index || 0, mode);
-  }
-  getContext(index, active, mode) {
-    const dataset = this.getDataset();
-    let context;
-    if (index >= 0 && index < this._cachedMeta.data.length) {
-      const element = this._cachedMeta.data[index];
-      context = element.$context || (element.$context = createDataContext(this.getContext(), index, element));
-      context.parsed = this.getParsed(index);
-      context.raw = dataset.data[index];
-      context.index = context.dataIndex = index;
-    } else {
-      context = this.$context || (this.$context = createDatasetContext(this.chart.getContext(), this.index));
-      context.dataset = dataset;
-      context.index = context.datasetIndex = this.index;
-    }
-    context.active = !!active;
-    context.mode = mode;
-    return context;
-  }
-  resolveDatasetElementOptions(mode) {
-    return this._resolveElementOptions(this.datasetElementType.id, mode);
-  }
-  resolveDataElementOptions(index, mode) {
-    return this._resolveElementOptions(this.dataElementType.id, mode, index);
-  }
-  _resolveElementOptions(elementType, mode = "default", index) {
-    const active = mode === "active";
-    const cache = this._cachedDataOpts;
-    const cacheKey = elementType + "-" + mode;
-    const cached = cache[cacheKey];
-    const sharing = this.enableOptionSharing && defined(index);
-    if (cached) {
-      return cloneIfNotShared(cached, sharing);
-    }
-    const config = this.chart.config;
-    const scopeKeys = config.datasetElementScopeKeys(this._type, elementType);
-    const prefixes = active ? [
-      `${elementType}Hover`,
-      "hover",
-      elementType,
-      ""
-    ] : [
-      elementType,
-      ""
-    ];
-    const scopes = config.getOptionScopes(this.getDataset(), scopeKeys);
-    const names2 = Object.keys(defaults.elements[elementType]);
-    const context = () => this.getContext(index, active, mode);
-    const values = config.resolveNamedOptions(scopes, names2, context, prefixes);
-    if (values.$shared) {
-      values.$shared = sharing;
-      cache[cacheKey] = Object.freeze(cloneIfNotShared(values, sharing));
-    }
-    return values;
-  }
-  _resolveAnimations(index, transition, active) {
-    const chart = this.chart;
-    const cache = this._cachedDataOpts;
-    const cacheKey = `animation-${transition}`;
-    const cached = cache[cacheKey];
-    if (cached) {
-      return cached;
-    }
-    let options;
-    if (chart.options.animation !== false) {
-      const config = this.chart.config;
-      const scopeKeys = config.datasetAnimationScopeKeys(this._type, transition);
-      const scopes = config.getOptionScopes(this.getDataset(), scopeKeys);
-      options = config.createResolver(scopes, this.getContext(index, active, transition));
-    }
-    const animations = new Animations(chart, options && options.animations);
-    if (options && options._cacheable) {
-      cache[cacheKey] = Object.freeze(animations);
-    }
-    return animations;
-  }
-  getSharedOptions(options) {
-    if (!options.$shared) {
-      return;
-    }
-    return this._sharedOptions || (this._sharedOptions = Object.assign({}, options));
-  }
-  includeOptions(mode, sharedOptions) {
-    return !sharedOptions || isDirectUpdateMode(mode) || this.chart._animationsDisabled;
-  }
-  _getSharedOptions(start, mode) {
-    const firstOpts = this.resolveDataElementOptions(start, mode);
-    const previouslySharedOptions = this._sharedOptions;
-    const sharedOptions = this.getSharedOptions(firstOpts);
-    const includeOptions = this.includeOptions(mode, sharedOptions) || sharedOptions !== previouslySharedOptions;
-    this.updateSharedOptions(sharedOptions, mode, firstOpts);
-    return {
-      sharedOptions,
-      includeOptions
-    };
-  }
-  updateElement(element, index, properties, mode) {
-    if (isDirectUpdateMode(mode)) {
-      Object.assign(element, properties);
-    } else {
-      this._resolveAnimations(index, mode).update(element, properties);
-    }
-  }
-  updateSharedOptions(sharedOptions, mode, newOptions) {
-    if (sharedOptions && !isDirectUpdateMode(mode)) {
-      this._resolveAnimations(void 0, mode).update(sharedOptions, newOptions);
-    }
-  }
-  _setStyle(element, index, mode, active) {
-    element.active = active;
-    const options = this.getStyle(index, active);
-    this._resolveAnimations(index, mode, active).update(element, {
-      options: !active && this.getSharedOptions(options) || options
-    });
-  }
-  removeHoverStyle(element, datasetIndex, index) {
-    this._setStyle(element, index, "active", false);
-  }
-  setHoverStyle(element, datasetIndex, index) {
-    this._setStyle(element, index, "active", true);
-  }
-  _removeDatasetHoverStyle() {
-    const element = this._cachedMeta.dataset;
-    if (element) {
-      this._setStyle(element, void 0, "active", false);
-    }
-  }
-  _setDatasetHoverStyle() {
-    const element = this._cachedMeta.dataset;
-    if (element) {
-      this._setStyle(element, void 0, "active", true);
-    }
-  }
-  _resyncElements(resetNewElements) {
-    const data = this._data;
-    const elements = this._cachedMeta.data;
-    for (const [method, arg1, arg2] of this._syncList) {
-      this[method](arg1, arg2);
-    }
-    this._syncList = [];
-    const numMeta = elements.length;
-    const numData = data.length;
-    const count = Math.min(numData, numMeta);
-    if (count) {
-      this.parse(0, count);
-    }
-    if (numData > numMeta) {
-      this._insertElements(numMeta, numData - numMeta, resetNewElements);
-    } else if (numData < numMeta) {
-      this._removeElements(numData, numMeta - numData);
-    }
-  }
-  _insertElements(start, count, resetNewElements = true) {
-    const meta = this._cachedMeta;
-    const data = meta.data;
-    const end = start + count;
-    let i;
-    const move = (arr) => {
-      arr.length += count;
-      for (i = arr.length - 1; i >= end; i--) {
-        arr[i] = arr[i - count];
-      }
-    };
-    move(data);
-    for (i = start; i < end; ++i) {
-      data[i] = new this.dataElementType();
-    }
-    if (this._parsing) {
-      move(meta._parsed);
-    }
-    this.parse(start, count);
-    if (resetNewElements) {
-      this.updateElements(data, start, count, "reset");
-    }
-  }
-  updateElements(element, start, count, mode) {
-  }
-  _removeElements(start, count) {
-    const meta = this._cachedMeta;
-    if (this._parsing) {
-      const removed = meta._parsed.splice(start, count);
-      if (meta._stacked) {
-        clearStacks(meta, removed);
-      }
-    }
-    meta.data.splice(start, count);
-  }
-  _sync(args) {
-    if (this._parsing) {
-      this._syncList.push(args);
-    } else {
-      const [method, arg1, arg2] = args;
-      this[method](arg1, arg2);
-    }
-    this.chart._dataChanges.push([
-      this.index,
-      ...args
-    ]);
-  }
-  _onDataPush() {
-    const count = arguments.length;
-    this._sync([
-      "_insertElements",
-      this.getDataset().data.length - count,
-      count
-    ]);
-  }
-  _onDataPop() {
-    this._sync([
-      "_removeElements",
-      this._cachedMeta.data.length - 1,
-      1
-    ]);
-  }
-  _onDataShift() {
-    this._sync([
-      "_removeElements",
-      0,
-      1
-    ]);
-  }
-  _onDataSplice(start, count) {
-    if (count) {
-      this._sync([
-        "_removeElements",
-        start,
-        count
-      ]);
-    }
-    const newCount = arguments.length - 2;
-    if (newCount) {
-      this._sync([
-        "_insertElements",
-        start,
-        newCount
-      ]);
-    }
-  }
-  _onDataUnshift() {
-    this._sync([
-      "_insertElements",
-      0,
-      arguments.length
-    ]);
-  }
-}
-__publicField(DatasetController, "defaults", {});
-__publicField(DatasetController, "datasetElementType", null);
-__publicField(DatasetController, "dataElementType", null);
-class LineController extends DatasetController {
-  initialize() {
-    this.enableOptionSharing = true;
-    this.supportsDecimation = true;
-    super.initialize();
-  }
-  update(mode) {
-    const meta = this._cachedMeta;
-    const { dataset: line, data: points = [], _dataset } = meta;
-    const animationsDisabled = this.chart._animationsDisabled;
-    let { start, count } = _getStartAndCountOfVisiblePoints(meta, points, animationsDisabled);
-    this._drawStart = start;
-    this._drawCount = count;
-    if (_scaleRangesChanged(meta)) {
-      start = 0;
-      count = points.length;
-    }
-    line._chart = this.chart;
-    line._datasetIndex = this.index;
-    line._decimated = !!_dataset._decimated;
-    line.points = points;
-    const options = this.resolveDatasetElementOptions(mode);
-    if (!this.options.showLine) {
-      options.borderWidth = 0;
-    }
-    options.segment = this.options.segment;
-    this.updateElement(line, void 0, {
-      animated: !animationsDisabled,
-      options
-    }, mode);
-    this.updateElements(points, start, count, mode);
-  }
-  updateElements(points, start, count, mode) {
-    const reset = mode === "reset";
-    const { iScale, vScale, _stacked, _dataset } = this._cachedMeta;
-    const { sharedOptions, includeOptions } = this._getSharedOptions(start, mode);
-    const iAxis = iScale.axis;
-    const vAxis = vScale.axis;
-    const { spanGaps, segment } = this.options;
-    const maxGapLength = isNumber(spanGaps) ? spanGaps : Number.POSITIVE_INFINITY;
-    const directUpdate = this.chart._animationsDisabled || reset || mode === "none";
-    const end = start + count;
-    const pointsCount = points.length;
-    let prevParsed = start > 0 && this.getParsed(start - 1);
-    for (let i = 0; i < pointsCount; ++i) {
-      const point = points[i];
-      const properties = directUpdate ? point : {};
-      if (i < start || i >= end) {
-        properties.skip = true;
-        continue;
-      }
-      const parsed = this.getParsed(i);
-      const nullData = isNullOrUndef(parsed[vAxis]);
-      const iPixel = properties[iAxis] = iScale.getPixelForValue(parsed[iAxis], i);
-      const vPixel = properties[vAxis] = reset || nullData ? vScale.getBasePixel() : vScale.getPixelForValue(_stacked ? this.applyStack(vScale, parsed, _stacked) : parsed[vAxis], i);
-      properties.skip = isNaN(iPixel) || isNaN(vPixel) || nullData;
-      properties.stop = i > 0 && Math.abs(parsed[iAxis] - prevParsed[iAxis]) > maxGapLength;
-      if (segment) {
-        properties.parsed = parsed;
-        properties.raw = _dataset.data[i];
-      }
-      if (includeOptions) {
-        properties.options = sharedOptions || this.resolveDataElementOptions(i, point.active ? "active" : mode);
-      }
-      if (!directUpdate) {
-        this.updateElement(point, i, properties, mode);
-      }
-      prevParsed = parsed;
-    }
-  }
-  getMaxOverflow() {
-    const meta = this._cachedMeta;
-    const dataset = meta.dataset;
-    const border = dataset.options && dataset.options.borderWidth || 0;
-    const data = meta.data || [];
-    if (!data.length) {
-      return border;
-    }
-    const firstPoint = data[0].size(this.resolveDataElementOptions(0));
-    const lastPoint = data[data.length - 1].size(this.resolveDataElementOptions(data.length - 1));
-    return Math.max(border, firstPoint, lastPoint) / 2;
-  }
-  draw() {
-    const meta = this._cachedMeta;
-    meta.dataset.updateControlPoints(this.chart.chartArea, meta.iScale.axis);
-    super.draw();
-  }
-}
-__publicField(LineController, "id", "line");
-__publicField(LineController, "defaults", {
-  datasetElementType: "line",
-  dataElementType: "point",
-  showLine: true,
-  spanGaps: false
-});
-__publicField(LineController, "overrides", {
-  scales: {
-    _index_: {
-      type: "category"
-    },
-    _value_: {
-      type: "linear"
-    }
-  }
-});
-function abstract() {
-  throw new Error("This method is not implemented: Check that a complete date adapter is provided.");
-}
-class DateAdapterBase {
-  constructor(options) {
-    __publicField(this, "options");
-    this.options = options || {};
-  }
-  /**
-  * Override default date adapter methods.
-  * Accepts type parameter to define options type.
-  * @example
-  * Chart._adapters._date.override<{myAdapterOption: string}>({
-  *   init() {
-  *     console.log(this.options.myAdapterOption);
-  *   }
-  * })
-  */
-  static override(members) {
-    Object.assign(DateAdapterBase.prototype, members);
-  }
-  // eslint-disable-next-line @typescript-eslint/no-empty-function
-  init() {
-  }
-  formats() {
-    return abstract();
-  }
-  parse() {
-    return abstract();
-  }
-  format() {
-    return abstract();
-  }
-  add() {
-    return abstract();
-  }
-  diff() {
-    return abstract();
-  }
-  startOf() {
-    return abstract();
-  }
-  endOf() {
-    return abstract();
-  }
-}
-var adapters = {
-  _date: DateAdapterBase
-};
-function binarySearch(metaset, axis, value, intersect) {
-  const { controller, data, _sorted } = metaset;
-  const iScale = controller._cachedMeta.iScale;
-  const spanGaps = metaset.dataset ? metaset.dataset.options ? metaset.dataset.options.spanGaps : null : null;
-  if (iScale && axis === iScale.axis && axis !== "r" && _sorted && data.length) {
-    const lookupMethod = iScale._reversePixels ? _rlookupByKey : _lookupByKey;
-    if (!intersect) {
-      const result = lookupMethod(data, axis, value);
-      if (spanGaps) {
-        const { vScale } = controller._cachedMeta;
-        const { _parsed } = metaset;
-        const distanceToDefinedLo = _parsed.slice(0, result.lo + 1).reverse().findIndex((point) => !isNullOrUndef(point[vScale.axis]));
-        result.lo -= Math.max(0, distanceToDefinedLo);
-        const distanceToDefinedHi = _parsed.slice(result.hi).findIndex((point) => !isNullOrUndef(point[vScale.axis]));
-        result.hi += Math.max(0, distanceToDefinedHi);
-      }
-      return result;
-    } else if (controller._sharedOptions) {
-      const el2 = data[0];
-      const range = typeof el2.getRange === "function" && el2.getRange(axis);
-      if (range) {
-        const start = lookupMethod(data, axis, value - range);
-        const end = lookupMethod(data, axis, value + range);
-        return {
-          lo: start.lo,
-          hi: end.hi
-        };
-      }
-    }
-  }
-  return {
-    lo: 0,
-    hi: data.length - 1
-  };
-}
-function evaluateInteractionItems(chart, axis, position, handler, intersect) {
-  const metasets = chart.getSortedVisibleDatasetMetas();
-  const value = position[axis];
-  for (let i = 0, ilen = metasets.length; i < ilen; ++i) {
-    const { index, data } = metasets[i];
-    const { lo, hi: hi2 } = binarySearch(metasets[i], axis, value, intersect);
-    for (let j = lo; j <= hi2; ++j) {
-      const element = data[j];
-      if (!element.skip) {
-        handler(element, index, j);
-      }
-    }
-  }
-}
-function getDistanceMetricForAxis(axis) {
-  const useX = axis.indexOf("x") !== -1;
-  const useY = axis.indexOf("y") !== -1;
-  return function(pt1, pt2) {
-    const deltaX = useX ? Math.abs(pt1.x - pt2.x) : 0;
-    const deltaY = useY ? Math.abs(pt1.y - pt2.y) : 0;
-    return Math.sqrt(Math.pow(deltaX, 2) + Math.pow(deltaY, 2));
-  };
-}
-function getIntersectItems(chart, position, axis, useFinalPosition, includeInvisible) {
-  const items = [];
-  if (!includeInvisible && !chart.isPointInArea(position)) {
-    return items;
-  }
-  const evaluationFunc = function(element, datasetIndex, index) {
-    if (!includeInvisible && !_isPointInArea(element, chart.chartArea, 0)) {
-      return;
-    }
-    if (element.inRange(position.x, position.y, useFinalPosition)) {
-      items.push({
-        element,
-        datasetIndex,
-        index
       });
-    }
-  };
-  evaluateInteractionItems(chart, axis, position, evaluationFunc, true);
-  return items;
-}
-function getNearestRadialItems(chart, position, axis, useFinalPosition) {
-  let items = [];
-  function evaluationFunc(element, datasetIndex, index) {
-    const { startAngle, endAngle } = element.getProps([
-      "startAngle",
-      "endAngle"
-    ], useFinalPosition);
-    const { angle } = getAngleFromPoint(element, {
-      x: position.x,
-      y: position.y
-    });
-    if (_angleBetween(angle, startAngle, endAngle)) {
-      items.push({
-        element,
-        datasetIndex,
-        index
+      var require_pick_by_alias = __commonJS({
+        "node_modules/pick-by-alias/index.js"(exports, module2) {
+          module2.exports = function pick(src, props, keepRest) {
+            var result = {}, prop, i2;
+            if (typeof props === "string") props = toList(props);
+            if (Array.isArray(props)) {
+              var res = {};
+              for (i2 = 0; i2 < props.length; i2++) {
+                res[props[i2]] = true;
+              }
+              props = res;
+            }
+            for (prop in props) {
+              props[prop] = toList(props[prop]);
+            }
+            var occupied = {};
+            for (prop in props) {
+              var aliases = props[prop];
+              if (Array.isArray(aliases)) {
+                for (i2 = 0; i2 < aliases.length; i2++) {
+                  var alias = aliases[i2];
+                  if (keepRest) {
+                    occupied[alias] = true;
+                  }
+                  if (alias in src) {
+                    result[prop] = src[alias];
+                    if (keepRest) {
+                      for (var j2 = i2; j2 < aliases.length; j2++) {
+                        occupied[aliases[j2]] = true;
+                      }
+                    }
+                    break;
+                  }
+                }
+              } else if (prop in src) {
+                if (props[prop]) {
+                  result[prop] = src[prop];
+                }
+                if (keepRest) {
+                  occupied[prop] = true;
+                }
+              }
+            }
+            if (keepRest) {
+              for (prop in src) {
+                if (occupied[prop]) continue;
+                result[prop] = src[prop];
+              }
+            }
+            return result;
+          };
+          var CACHE = {};
+          function toList(arg) {
+            if (CACHE[arg]) return CACHE[arg];
+            if (typeof arg === "string") {
+              arg = CACHE[arg] = arg.split(/\s*,\s*|\s+/);
+            }
+            return arg;
+          }
+        }
       });
-    }
-  }
-  evaluateInteractionItems(chart, axis, position, evaluationFunc);
-  return items;
-}
-function getNearestCartesianItems(chart, position, axis, intersect, useFinalPosition, includeInvisible) {
-  let items = [];
-  const distanceMetric = getDistanceMetricForAxis(axis);
-  let minDistance = Number.POSITIVE_INFINITY;
-  function evaluationFunc(element, datasetIndex, index) {
-    const inRange = element.inRange(position.x, position.y, useFinalPosition);
-    if (intersect && !inRange) {
-      return;
-    }
-    const center = element.getCenterPoint(useFinalPosition);
-    const pointInArea = !!includeInvisible || chart.isPointInArea(center);
-    if (!pointInArea && !inRange) {
-      return;
-    }
-    const distance = distanceMetric(position, center);
-    if (distance < minDistance) {
-      items = [
-        {
-          element,
-          datasetIndex,
-          index
+      var require_parse_rect = __commonJS({
+        "node_modules/parse-rect/index.js"(exports, module2) {
+          var pick = require_pick_by_alias();
+          module2.exports = parseRect;
+          function parseRect(arg) {
+            var rect;
+            if (arguments.length > 1) {
+              arg = arguments;
+            }
+            if (typeof arg === "string") {
+              arg = arg.split(/\s/).map(parseFloat);
+            } else if (typeof arg === "number") {
+              arg = [arg];
+            }
+            if (arg.length && typeof arg[0] === "number") {
+              if (arg.length === 1) {
+                rect = {
+                  width: arg[0],
+                  height: arg[0],
+                  x: 0,
+                  y: 0
+                };
+              } else if (arg.length === 2) {
+                rect = {
+                  width: arg[0],
+                  height: arg[1],
+                  x: 0,
+                  y: 0
+                };
+              } else {
+                rect = {
+                  x: arg[0],
+                  y: arg[1],
+                  width: arg[2] - arg[0] || 0,
+                  height: arg[3] - arg[1] || 0
+                };
+              }
+            } else if (arg) {
+              arg = pick(arg, {
+                left: "x l left Left",
+                top: "y t top Top",
+                width: "w width W Width",
+                height: "h height W Width",
+                bottom: "b bottom Bottom",
+                right: "r right Right"
+              });
+              rect = {
+                x: arg.left || 0,
+                y: arg.top || 0
+              };
+              if (arg.width == null) {
+                if (arg.right) rect.width = arg.right - rect.x;
+                else rect.width = 0;
+              } else {
+                rect.width = arg.width;
+              }
+              if (arg.height == null) {
+                if (arg.bottom) rect.height = arg.bottom - rect.y;
+                else rect.height = 0;
+              } else {
+                rect.height = arg.height;
+              }
+            }
+            return rect;
+          }
         }
-      ];
-      minDistance = distance;
-    } else if (distance === minDistance) {
-      items.push({
-        element,
-        datasetIndex,
-        index
       });
-    }
-  }
-  evaluateInteractionItems(chart, axis, position, evaluationFunc);
-  return items;
-}
-function getNearestItems(chart, position, axis, intersect, useFinalPosition, includeInvisible) {
-  if (!includeInvisible && !chart.isPointInArea(position)) {
-    return [];
-  }
-  return axis === "r" && !intersect ? getNearestRadialItems(chart, position, axis, useFinalPosition) : getNearestCartesianItems(chart, position, axis, intersect, useFinalPosition, includeInvisible);
-}
-function getAxisItems(chart, position, axis, intersect, useFinalPosition) {
-  const items = [];
-  const rangeMethod = axis === "x" ? "inXRange" : "inYRange";
-  let intersectsItem = false;
-  evaluateInteractionItems(chart, axis, position, (element, datasetIndex, index) => {
-    if (element[rangeMethod] && element[rangeMethod](position[axis], useFinalPosition)) {
-      items.push({
-        element,
-        datasetIndex,
-        index
+      var require_array_bounds = __commonJS({
+        "node_modules/array-bounds/index.js"(exports, module2) {
+          module2.exports = normalize;
+          function normalize(arr, dim) {
+            if (!arr || arr.length == null) throw Error("Argument should be an array");
+            if (dim == null) dim = 1;
+            else dim = Math.floor(dim);
+            var bounds = Array(dim * 2);
+            for (var offset = 0; offset < dim; offset++) {
+              var max = -Infinity, min = Infinity, i2 = offset, l2 = arr.length;
+              for (; i2 < l2; i2 += dim) {
+                if (arr[i2] > max) max = arr[i2];
+                if (arr[i2] < min) min = arr[i2];
+              }
+              bounds[offset] = min;
+              bounds[dim + offset] = max;
+            }
+            return bounds;
+          }
+        }
       });
-      intersectsItem = intersectsItem || element.inRange(position.x, position.y, useFinalPosition);
-    }
-  });
-  if (intersect && !intersectsItem) {
-    return [];
-  }
-  return items;
-}
-var Interaction = {
-  modes: {
-    index(chart, e, options, useFinalPosition) {
-      const position = getRelativePosition(e, chart);
-      const axis = options.axis || "x";
-      const includeInvisible = options.includeInvisible || false;
-      const items = options.intersect ? getIntersectItems(chart, position, axis, useFinalPosition, includeInvisible) : getNearestItems(chart, position, axis, false, useFinalPosition, includeInvisible);
-      const elements = [];
-      if (!items.length) {
-        return [];
-      }
-      chart.getSortedVisibleDatasetMetas().forEach((meta) => {
-        const index = items[0].index;
-        const element = meta.data[index];
-        if (element && !element.skip) {
-          elements.push({
-            element,
-            datasetIndex: meta.index,
-            index
-          });
+      var require_defined = __commonJS({
+        "node_modules/defined/index.js"(exports, module2) {
+          module2.exports = function() {
+            for (var i2 = 0; i2 < arguments.length; i2++) {
+              if (arguments[i2] !== void 0) return arguments[i2];
+            }
+          };
         }
       });
-      return elements;
-    },
-    dataset(chart, e, options, useFinalPosition) {
-      const position = getRelativePosition(e, chart);
-      const axis = options.axis || "xy";
-      const includeInvisible = options.includeInvisible || false;
-      let items = options.intersect ? getIntersectItems(chart, position, axis, useFinalPosition, includeInvisible) : getNearestItems(chart, position, axis, false, useFinalPosition, includeInvisible);
-      if (items.length > 0) {
-        const datasetIndex = items[0].datasetIndex;
-        const data = chart.getDatasetMeta(datasetIndex).data;
-        items = [];
-        for (let i = 0; i < data.length; ++i) {
-          items.push({
-            element: data[i],
-            datasetIndex,
-            index: i
+      var require_flatten_vertex_data = __commonJS({
+        "node_modules/flatten-vertex-data/index.js"(exports, module2) {
+          var dtype = require_dtype();
+          module2.exports = flattenVertexData;
+          function flattenVertexData(data, output, offset) {
+            if (!data) throw new TypeError("must specify data as first parameter");
+            offset = +(offset || 0) | 0;
+            if (Array.isArray(data) && (data[0] && typeof data[0][0] === "number")) {
+              var dim = data[0].length;
+              var length2 = data.length * dim;
+              var i2, j2, k2, l2;
+              if (!output || typeof output === "string") {
+                output = new (dtype(output || "float32"))(length2 + offset);
+              }
+              var dstLength = output.length - offset;
+              if (length2 !== dstLength) {
+                throw new Error("source length " + length2 + " (" + dim + "x" + data.length + ") does not match destination length " + dstLength);
+              }
+              for (i2 = 0, k2 = offset; i2 < data.length; i2++) {
+                for (j2 = 0; j2 < dim; j2++) {
+                  output[k2++] = data[i2][j2] === null ? NaN : data[i2][j2];
+                }
+              }
+            } else {
+              if (!output || typeof output === "string") {
+                var Ctor = dtype(output || "float32");
+                if (Array.isArray(data) || output === "array") {
+                  output = new Ctor(data.length + offset);
+                  for (i2 = 0, k2 = offset, l2 = output.length; k2 < l2; k2++, i2++) {
+                    output[k2] = data[i2] === null ? NaN : data[i2];
+                  }
+                } else {
+                  if (offset === 0) {
+                    output = new Ctor(data);
+                  } else {
+                    output = new Ctor(data.length + offset);
+                    output.set(data, offset);
+                  }
+                }
+              } else {
+                output.set(data, offset);
+              }
+            }
+            return output;
+          }
+        }
+      });
+      var require_is_obj = __commonJS({
+        "node_modules/is-obj/index.js"(exports, module2) {
+          module2.exports = function(x2) {
+            var type = typeof x2;
+            return x2 !== null && (type === "object" || type === "function");
+          };
+        }
+      });
+      var require_math_log2 = __commonJS({
+        "node_modules/math-log2/index.js"(exports, module2) {
+          module2.exports = Math.log2 || function(x2) {
+            return Math.log(x2) * Math.LOG2E;
+          };
+        }
+      });
+      var require_quad = __commonJS({
+        "node_modules/@plotly/point-cluster/quad.js"(exports, module2) {
+          var search = require_search_bounds();
+          var clamp2 = require_clamp();
+          var rect = require_parse_rect();
+          var getBounds2 = require_array_bounds();
+          var pick = require_pick_by_alias();
+          var defined = require_defined();
+          var flatten2 = require_flatten_vertex_data();
+          var isObj = require_is_obj();
+          var dtype = require_dtype();
+          var log22 = require_math_log2();
+          var MAX_GROUP_ID = 1073741824;
+          module2.exports = function cluster(srcPoints, options) {
+            if (!options) options = {};
+            srcPoints = flatten2(srcPoints, "float64");
+            options = pick(options, {
+              bounds: "range bounds dataBox databox",
+              maxDepth: "depth maxDepth maxdepth level maxLevel maxlevel levels",
+              dtype: "type dtype format out dst output destination"
+              // sort: 'sortBy sortby sort',
+              // pick: 'pick levelPoint',
+              // nodeSize: 'node nodeSize minNodeSize minSize size'
+            });
+            let maxDepth = defined(options.maxDepth, 255);
+            let bounds = defined(options.bounds, getBounds2(srcPoints, 2));
+            if (bounds[0] === bounds[2]) bounds[2]++;
+            if (bounds[1] === bounds[3]) bounds[3]++;
+            let points = normalize(srcPoints, bounds);
+            let n2 = srcPoints.length >>> 1;
+            let ids;
+            if (!options.dtype) options.dtype = "array";
+            if (typeof options.dtype === "string") {
+              ids = new (dtype(options.dtype))(n2);
+            } else if (options.dtype) {
+              ids = options.dtype;
+              if (Array.isArray(ids)) ids.length = n2;
+            }
+            for (let i2 = 0; i2 < n2; ++i2) {
+              ids[i2] = i2;
+            }
+            let levels = [];
+            let sublevels = [];
+            let groups = [];
+            let offsets = [];
+            sort(0, 0, 1, ids, 0, 1);
+            let offset = 0;
+            for (let level = 0; level < levels.length; level++) {
+              let levelItems = levels[level];
+              if (ids.set) ids.set(levelItems, offset);
+              else {
+                for (let i2 = 0, l2 = levelItems.length; i2 < l2; i2++) {
+                  ids[i2 + offset] = levelItems[i2];
+                }
+              }
+              let nextOffset = offset + levels[level].length;
+              offsets[level] = [offset, nextOffset];
+              offset = nextOffset;
+            }
+            ids.range = range;
+            return ids;
+            function sort(x2, y2, diam, ids2, level, group2) {
+              if (!ids2.length) return null;
+              let levelItems = levels[level] || (levels[level] = []);
+              let levelGroups = groups[level] || (groups[level] = []);
+              let sublevel = sublevels[level] || (sublevels[level] = []);
+              let offset2 = levelItems.length;
+              level++;
+              if (level > maxDepth || group2 > MAX_GROUP_ID) {
+                for (let i2 = 0; i2 < ids2.length; i2++) {
+                  levelItems.push(ids2[i2]);
+                  levelGroups.push(group2);
+                  sublevel.push(null, null, null, null);
+                }
+                return offset2;
+              }
+              levelItems.push(ids2[0]);
+              levelGroups.push(group2);
+              if (ids2.length <= 1) {
+                sublevel.push(null, null, null, null);
+                return offset2;
+              }
+              let d2 = diam * 0.5;
+              let cx = x2 + d2, cy = y2 + d2;
+              let lolo = [], lohi = [], hilo = [], hihi = [];
+              for (let i2 = 1, l2 = ids2.length; i2 < l2; i2++) {
+                let idx = ids2[i2], x22 = points[idx * 2], y22 = points[idx * 2 + 1];
+                x22 < cx ? y22 < cy ? lolo.push(idx) : lohi.push(idx) : y22 < cy ? hilo.push(idx) : hihi.push(idx);
+              }
+              group2 <<= 2;
+              sublevel.push(
+                sort(x2, y2, d2, lolo, level, group2),
+                sort(x2, cy, d2, lohi, level, group2 + 1),
+                sort(cx, y2, d2, hilo, level, group2 + 2),
+                sort(cx, cy, d2, hihi, level, group2 + 3)
+              );
+              return offset2;
+            }
+            function range(...args) {
+              let options2;
+              if (isObj(args[args.length - 1])) {
+                let arg = args.pop();
+                if (!args.length && (arg.x != null || arg.l != null || arg.left != null)) {
+                  args = [arg];
+                  options2 = {};
+                }
+                options2 = pick(arg, {
+                  level: "level maxLevel",
+                  d: "d diam diameter r radius px pxSize pixel pixelSize maxD size minSize",
+                  lod: "lod details ranges offsets"
+                });
+              } else {
+                options2 = {};
+              }
+              if (!args.length) args = bounds;
+              let box = rect(...args);
+              let [minX, minY, maxX, maxY] = [
+                Math.min(box.x, box.x + box.width),
+                Math.min(box.y, box.y + box.height),
+                Math.max(box.x, box.x + box.width),
+                Math.max(box.y, box.y + box.height)
+              ];
+              let [nminX, nminY, nmaxX, nmaxY] = normalize([minX, minY, maxX, maxY], bounds);
+              let maxLevel = defined(options2.level, levels.length);
+              if (options2.d != null) {
+                let d2;
+                if (typeof options2.d === "number") d2 = [options2.d, options2.d];
+                else if (options2.d.length) d2 = options2.d;
+                maxLevel = Math.min(
+                  Math.max(
+                    Math.ceil(-log22(Math.abs(d2[0]) / (bounds[2] - bounds[0]))),
+                    Math.ceil(-log22(Math.abs(d2[1]) / (bounds[3] - bounds[1])))
+                  ),
+                  maxLevel
+                );
+              }
+              maxLevel = Math.min(maxLevel, levels.length);
+              if (options2.lod) {
+                return lod(nminX, nminY, nmaxX, nmaxY, maxLevel);
+              }
+              let selection = [];
+              select(0, 0, 1, 0, 0, 1);
+              function select(lox, loy, d2, level, from, to) {
+                if (from === null || to === null) return;
+                let hix = lox + d2;
+                let hiy = loy + d2;
+                if (nminX > hix || nminY > hiy || nmaxX < lox || nmaxY < loy) return;
+                if (level >= maxLevel) return;
+                if (from === to) return;
+                let levelItems = levels[level];
+                if (to === void 0) to = levelItems.length;
+                for (let i2 = from; i2 < to; i2++) {
+                  let id2 = levelItems[i2];
+                  let px = srcPoints[id2 * 2];
+                  let py = srcPoints[id2 * 2 + 1];
+                  if (px >= minX && px <= maxX && py >= minY && py <= maxY) {
+                    selection.push(id2);
+                  }
+                }
+                let offsets2 = sublevels[level];
+                let off0 = offsets2[from * 4 + 0];
+                let off1 = offsets2[from * 4 + 1];
+                let off2 = offsets2[from * 4 + 2];
+                let off3 = offsets2[from * 4 + 3];
+                let end = nextOffset(offsets2, from + 1);
+                let d22 = d2 * 0.5;
+                let nextLevel = level + 1;
+                select(lox, loy, d22, nextLevel, off0, off1 || off2 || off3 || end);
+                select(lox, loy + d22, d22, nextLevel, off1, off2 || off3 || end);
+                select(lox + d22, loy, d22, nextLevel, off2, off3 || end);
+                select(lox + d22, loy + d22, d22, nextLevel, off3, end);
+              }
+              function nextOffset(offsets2, from) {
+                let offset2 = null, i2 = 0;
+                while (offset2 === null) {
+                  offset2 = offsets2[from * 4 + i2];
+                  i2++;
+                  if (i2 > offsets2.length) return null;
+                }
+                return offset2;
+              }
+              return selection;
+            }
+            function lod(lox, loy, hix, hiy, maxLevel) {
+              let ranges = [];
+              for (let level = 0; level < maxLevel; level++) {
+                let levelGroups = groups[level];
+                let from = offsets[level][0];
+                let levelGroupStart = group(lox, loy, level);
+                let levelGroupEnd = group(hix, hiy, level);
+                let startOffset = search.ge(levelGroups, levelGroupStart);
+                let endOffset = search.gt(levelGroups, levelGroupEnd, startOffset, levelGroups.length - 1);
+                ranges[level] = [startOffset + from, endOffset + from];
+              }
+              return ranges;
+            }
+            function group(x2, y2, level) {
+              let group2 = 1;
+              let cx = 0.5, cy = 0.5;
+              let diam = 0.5;
+              for (let i2 = 0; i2 < level; i2++) {
+                group2 <<= 2;
+                group2 += x2 < cx ? y2 < cy ? 0 : 1 : y2 < cy ? 2 : 3;
+                diam *= 0.5;
+                cx += x2 < cx ? -diam : diam;
+                cy += y2 < cy ? -diam : diam;
+              }
+              return group2;
+            }
+          };
+          function normalize(pts, bounds) {
+            let [lox, loy, hix, hiy] = bounds;
+            let scaleX2 = 1 / (hix - lox);
+            let scaleY2 = 1 / (hiy - loy);
+            let result = new Array(pts.length);
+            for (let i2 = 0, n2 = pts.length / 2; i2 < n2; i2++) {
+              result[2 * i2] = clamp2((pts[2 * i2] - lox) * scaleX2, 0, 1);
+              result[2 * i2 + 1] = clamp2((pts[2 * i2 + 1] - loy) * scaleY2, 0, 1);
+            }
+            return result;
+          }
+        }
+      });
+      var require_point_cluster = __commonJS({
+        "node_modules/@plotly/point-cluster/index.js"(exports, module2) {
+          module2.exports = require_quad();
+        }
+      });
+      var require_abs_svg_path = __commonJS({
+        "node_modules/abs-svg-path/index.js"(exports, module2) {
+          module2.exports = absolutize;
+          function absolutize(path) {
+            var startX = 0;
+            var startY = 0;
+            var x2 = 0;
+            var y2 = 0;
+            return path.map(function(seg) {
+              seg = seg.slice();
+              var type = seg[0];
+              var command = type.toUpperCase();
+              if (type != command) {
+                seg[0] = command;
+                switch (type) {
+                  case "a":
+                    seg[6] += x2;
+                    seg[7] += y2;
+                    break;
+                  case "v":
+                    seg[1] += y2;
+                    break;
+                  case "h":
+                    seg[1] += x2;
+                    break;
+                  default:
+                    for (var i2 = 1; i2 < seg.length; ) {
+                      seg[i2++] += x2;
+                      seg[i2++] += y2;
+                    }
+                }
+              }
+              switch (command) {
+                case "Z":
+                  x2 = startX;
+                  y2 = startY;
+                  break;
+                case "H":
+                  x2 = seg[1];
+                  break;
+                case "V":
+                  y2 = seg[1];
+                  break;
+                case "M":
+                  x2 = startX = seg[1];
+                  y2 = startY = seg[2];
+                  break;
+                default:
+                  x2 = seg[seg.length - 2];
+                  y2 = seg[seg.length - 1];
+              }
+              return seg;
+            });
+          }
+        }
+      });
+      var require_cjs6 = __commonJS({
+        "node_modules/svg-arc-to-cubic-bezier/cjs/index.js"(exports, module2) {
+          Object.defineProperty(exports, "__esModule", {
+            value: true
           });
+          var _slicedToArray = /* @__PURE__ */ function() {
+            function sliceIterator(arr, i2) {
+              var _arr = [];
+              var _n = true;
+              var _d2 = false;
+              var _e2 = void 0;
+              try {
+                for (var _i = arr[Symbol.iterator](), _s2; !(_n = (_s2 = _i.next()).done); _n = true) {
+                  _arr.push(_s2.value);
+                  if (i2 && _arr.length === i2) break;
+                }
+              } catch (err) {
+                _d2 = true;
+                _e2 = err;
+              } finally {
+                try {
+                  if (!_n && _i["return"]) _i["return"]();
+                } finally {
+                  if (_d2) throw _e2;
+                }
+              }
+              return _arr;
+            }
+            return function(arr, i2) {
+              if (Array.isArray(arr)) {
+                return arr;
+              } else if (Symbol.iterator in Object(arr)) {
+                return sliceIterator(arr, i2);
+              } else {
+                throw new TypeError("Invalid attempt to destructure non-iterable instance");
+              }
+            };
+          }();
+          var TAU = Math.PI * 2;
+          var mapToEllipse = function mapToEllipse2(_ref, rx, ry, cosphi, sinphi, centerx, centery) {
+            var x2 = _ref.x, y2 = _ref.y;
+            x2 *= rx;
+            y2 *= ry;
+            var xp = cosphi * x2 - sinphi * y2;
+            var yp = sinphi * x2 + cosphi * y2;
+            return {
+              x: xp + centerx,
+              y: yp + centery
+            };
+          };
+          var approxUnitArc = function approxUnitArc2(ang1, ang2) {
+            var a2 = ang2 === 1.5707963267948966 ? 0.551915024494 : ang2 === -1.5707963267948966 ? -0.551915024494 : 4 / 3 * Math.tan(ang2 / 4);
+            var x1 = Math.cos(ang1);
+            var y1 = Math.sin(ang1);
+            var x2 = Math.cos(ang1 + ang2);
+            var y2 = Math.sin(ang1 + ang2);
+            return [{
+              x: x1 - y1 * a2,
+              y: y1 + x1 * a2
+            }, {
+              x: x2 + y2 * a2,
+              y: y2 - x2 * a2
+            }, {
+              x: x2,
+              y: y2
+            }];
+          };
+          var vectorAngle = function vectorAngle2(ux, uy, vx, vy) {
+            var sign = ux * vy - uy * vx < 0 ? -1 : 1;
+            var dot2 = ux * vx + uy * vy;
+            if (dot2 > 1) {
+              dot2 = 1;
+            }
+            if (dot2 < -1) {
+              dot2 = -1;
+            }
+            return sign * Math.acos(dot2);
+          };
+          var getArcCenter = function getArcCenter2(px, py, cx, cy, rx, ry, largeArcFlag, sweepFlag, sinphi, cosphi, pxp, pyp) {
+            var rxsq = Math.pow(rx, 2);
+            var rysq = Math.pow(ry, 2);
+            var pxpsq = Math.pow(pxp, 2);
+            var pypsq = Math.pow(pyp, 2);
+            var radicant = rxsq * rysq - rxsq * pypsq - rysq * pxpsq;
+            if (radicant < 0) {
+              radicant = 0;
+            }
+            radicant /= rxsq * pypsq + rysq * pxpsq;
+            radicant = Math.sqrt(radicant) * (largeArcFlag === sweepFlag ? -1 : 1);
+            var centerxp = radicant * rx / ry * pyp;
+            var centeryp = radicant * -ry / rx * pxp;
+            var centerx = cosphi * centerxp - sinphi * centeryp + (px + cx) / 2;
+            var centery = sinphi * centerxp + cosphi * centeryp + (py + cy) / 2;
+            var vx1 = (pxp - centerxp) / rx;
+            var vy1 = (pyp - centeryp) / ry;
+            var vx2 = (-pxp - centerxp) / rx;
+            var vy2 = (-pyp - centeryp) / ry;
+            var ang1 = vectorAngle(1, 0, vx1, vy1);
+            var ang2 = vectorAngle(vx1, vy1, vx2, vy2);
+            if (sweepFlag === 0 && ang2 > 0) {
+              ang2 -= TAU;
+            }
+            if (sweepFlag === 1 && ang2 < 0) {
+              ang2 += TAU;
+            }
+            return [centerx, centery, ang1, ang2];
+          };
+          var arcToBezier = function arcToBezier2(_ref2) {
+            var px = _ref2.px, py = _ref2.py, cx = _ref2.cx, cy = _ref2.cy, rx = _ref2.rx, ry = _ref2.ry, _ref2$xAxisRotation = _ref2.xAxisRotation, xAxisRotation = _ref2$xAxisRotation === void 0 ? 0 : _ref2$xAxisRotation, _ref2$largeArcFlag = _ref2.largeArcFlag, largeArcFlag = _ref2$largeArcFlag === void 0 ? 0 : _ref2$largeArcFlag, _ref2$sweepFlag = _ref2.sweepFlag, sweepFlag = _ref2$sweepFlag === void 0 ? 0 : _ref2$sweepFlag;
+            var curves = [];
+            if (rx === 0 || ry === 0) {
+              return [];
+            }
+            var sinphi = Math.sin(xAxisRotation * TAU / 360);
+            var cosphi = Math.cos(xAxisRotation * TAU / 360);
+            var pxp = cosphi * (px - cx) / 2 + sinphi * (py - cy) / 2;
+            var pyp = -sinphi * (px - cx) / 2 + cosphi * (py - cy) / 2;
+            if (pxp === 0 && pyp === 0) {
+              return [];
+            }
+            rx = Math.abs(rx);
+            ry = Math.abs(ry);
+            var lambda = Math.pow(pxp, 2) / Math.pow(rx, 2) + Math.pow(pyp, 2) / Math.pow(ry, 2);
+            if (lambda > 1) {
+              rx *= Math.sqrt(lambda);
+              ry *= Math.sqrt(lambda);
+            }
+            var _getArcCenter = getArcCenter(px, py, cx, cy, rx, ry, largeArcFlag, sweepFlag, sinphi, cosphi, pxp, pyp), _getArcCenter2 = _slicedToArray(_getArcCenter, 4), centerx = _getArcCenter2[0], centery = _getArcCenter2[1], ang1 = _getArcCenter2[2], ang2 = _getArcCenter2[3];
+            var ratio = Math.abs(ang2) / (TAU / 4);
+            if (Math.abs(1 - ratio) < 1e-7) {
+              ratio = 1;
+            }
+            var segments = Math.max(Math.ceil(ratio), 1);
+            ang2 /= segments;
+            for (var i2 = 0; i2 < segments; i2++) {
+              curves.push(approxUnitArc(ang1, ang2));
+              ang1 += ang2;
+            }
+            return curves.map(function(curve) {
+              var _mapToEllipse = mapToEllipse(curve[0], rx, ry, cosphi, sinphi, centerx, centery), x1 = _mapToEllipse.x, y1 = _mapToEllipse.y;
+              var _mapToEllipse2 = mapToEllipse(curve[1], rx, ry, cosphi, sinphi, centerx, centery), x2 = _mapToEllipse2.x, y2 = _mapToEllipse2.y;
+              var _mapToEllipse3 = mapToEllipse(curve[2], rx, ry, cosphi, sinphi, centerx, centery), x3 = _mapToEllipse3.x, y3 = _mapToEllipse3.y;
+              return { x1, y1, x2, y2, x: x3, y: y3 };
+            });
+          };
+          exports.default = arcToBezier;
+          module2.exports = exports.default;
         }
-      }
-      return items;
-    },
-    point(chart, e, options, useFinalPosition) {
-      const position = getRelativePosition(e, chart);
-      const axis = options.axis || "xy";
-      const includeInvisible = options.includeInvisible || false;
-      return getIntersectItems(chart, position, axis, useFinalPosition, includeInvisible);
-    },
-    nearest(chart, e, options, useFinalPosition) {
-      const position = getRelativePosition(e, chart);
-      const axis = options.axis || "xy";
-      const includeInvisible = options.includeInvisible || false;
-      return getNearestItems(chart, position, axis, options.intersect, useFinalPosition, includeInvisible);
-    },
-    x(chart, e, options, useFinalPosition) {
-      const position = getRelativePosition(e, chart);
-      return getAxisItems(chart, position, "x", options.intersect, useFinalPosition);
-    },
-    y(chart, e, options, useFinalPosition) {
-      const position = getRelativePosition(e, chart);
-      return getAxisItems(chart, position, "y", options.intersect, useFinalPosition);
-    }
-  }
-};
-const STATIC_POSITIONS = [
-  "left",
-  "top",
-  "right",
-  "bottom"
-];
-function filterByPosition(array, position) {
-  return array.filter((v2) => v2.pos === position);
-}
-function filterDynamicPositionByAxis(array, axis) {
-  return array.filter((v2) => STATIC_POSITIONS.indexOf(v2.pos) === -1 && v2.box.axis === axis);
-}
-function sortByWeight(array, reverse) {
-  return array.sort((a, b) => {
-    const v0 = reverse ? b : a;
-    const v1 = reverse ? a : b;
-    return v0.weight === v1.weight ? v0.index - v1.index : v0.weight - v1.weight;
-  });
-}
-function wrapBoxes(boxes) {
-  const layoutBoxes = [];
-  let i, ilen, box, pos, stack, stackWeight;
-  for (i = 0, ilen = (boxes || []).length; i < ilen; ++i) {
-    box = boxes[i];
-    ({ position: pos, options: { stack, stackWeight = 1 } } = box);
-    layoutBoxes.push({
-      index: i,
-      box,
-      pos,
-      horizontal: box.isHorizontal(),
-      weight: box.weight,
-      stack: stack && pos + stack,
-      stackWeight
-    });
-  }
-  return layoutBoxes;
-}
-function buildStacks(layouts2) {
-  const stacks = {};
-  for (const wrap of layouts2) {
-    const { stack, pos, stackWeight } = wrap;
-    if (!stack || !STATIC_POSITIONS.includes(pos)) {
-      continue;
-    }
-    const _stack = stacks[stack] || (stacks[stack] = {
-      count: 0,
-      placed: 0,
-      weight: 0,
-      size: 0
-    });
-    _stack.count++;
-    _stack.weight += stackWeight;
-  }
-  return stacks;
-}
-function setLayoutDims(layouts2, params) {
-  const stacks = buildStacks(layouts2);
-  const { vBoxMaxWidth, hBoxMaxHeight } = params;
-  let i, ilen, layout;
-  for (i = 0, ilen = layouts2.length; i < ilen; ++i) {
-    layout = layouts2[i];
-    const { fullSize } = layout.box;
-    const stack = stacks[layout.stack];
-    const factor = stack && layout.stackWeight / stack.weight;
-    if (layout.horizontal) {
-      layout.width = factor ? factor * vBoxMaxWidth : fullSize && params.availableWidth;
-      layout.height = hBoxMaxHeight;
-    } else {
-      layout.width = vBoxMaxWidth;
-      layout.height = factor ? factor * hBoxMaxHeight : fullSize && params.availableHeight;
-    }
-  }
-  return stacks;
-}
-function buildLayoutBoxes(boxes) {
-  const layoutBoxes = wrapBoxes(boxes);
-  const fullSize = sortByWeight(layoutBoxes.filter((wrap) => wrap.box.fullSize), true);
-  const left = sortByWeight(filterByPosition(layoutBoxes, "left"), true);
-  const right = sortByWeight(filterByPosition(layoutBoxes, "right"));
-  const top = sortByWeight(filterByPosition(layoutBoxes, "top"), true);
-  const bottom = sortByWeight(filterByPosition(layoutBoxes, "bottom"));
-  const centerHorizontal = filterDynamicPositionByAxis(layoutBoxes, "x");
-  const centerVertical = filterDynamicPositionByAxis(layoutBoxes, "y");
-  return {
-    fullSize,
-    leftAndTop: left.concat(top),
-    rightAndBottom: right.concat(centerVertical).concat(bottom).concat(centerHorizontal),
-    chartArea: filterByPosition(layoutBoxes, "chartArea"),
-    vertical: left.concat(right).concat(centerVertical),
-    horizontal: top.concat(bottom).concat(centerHorizontal)
-  };
-}
-function getCombinedMax(maxPadding, chartArea, a, b) {
-  return Math.max(maxPadding[a], chartArea[a]) + Math.max(maxPadding[b], chartArea[b]);
-}
-function updateMaxPadding(maxPadding, boxPadding) {
-  maxPadding.top = Math.max(maxPadding.top, boxPadding.top);
-  maxPadding.left = Math.max(maxPadding.left, boxPadding.left);
-  maxPadding.bottom = Math.max(maxPadding.bottom, boxPadding.bottom);
-  maxPadding.right = Math.max(maxPadding.right, boxPadding.right);
-}
-function updateDims(chartArea, params, layout, stacks) {
-  const { pos, box } = layout;
-  const maxPadding = chartArea.maxPadding;
-  if (!isObject(pos)) {
-    if (layout.size) {
-      chartArea[pos] -= layout.size;
-    }
-    const stack = stacks[layout.stack] || {
-      size: 0,
-      count: 1
-    };
-    stack.size = Math.max(stack.size, layout.horizontal ? box.height : box.width);
-    layout.size = stack.size / stack.count;
-    chartArea[pos] += layout.size;
-  }
-  if (box.getPadding) {
-    updateMaxPadding(maxPadding, box.getPadding());
-  }
-  const newWidth = Math.max(0, params.outerWidth - getCombinedMax(maxPadding, chartArea, "left", "right"));
-  const newHeight = Math.max(0, params.outerHeight - getCombinedMax(maxPadding, chartArea, "top", "bottom"));
-  const widthChanged = newWidth !== chartArea.w;
-  const heightChanged = newHeight !== chartArea.h;
-  chartArea.w = newWidth;
-  chartArea.h = newHeight;
-  return layout.horizontal ? {
-    same: widthChanged,
-    other: heightChanged
-  } : {
-    same: heightChanged,
-    other: widthChanged
-  };
-}
-function handleMaxPadding(chartArea) {
-  const maxPadding = chartArea.maxPadding;
-  function updatePos(pos) {
-    const change = Math.max(maxPadding[pos] - chartArea[pos], 0);
-    chartArea[pos] += change;
-    return change;
-  }
-  chartArea.y += updatePos("top");
-  chartArea.x += updatePos("left");
-  updatePos("right");
-  updatePos("bottom");
-}
-function getMargins(horizontal, chartArea) {
-  const maxPadding = chartArea.maxPadding;
-  function marginForPositions(positions2) {
-    const margin = {
-      left: 0,
-      top: 0,
-      right: 0,
-      bottom: 0
-    };
-    positions2.forEach((pos) => {
-      margin[pos] = Math.max(chartArea[pos], maxPadding[pos]);
-    });
-    return margin;
-  }
-  return horizontal ? marginForPositions([
-    "left",
-    "right"
-  ]) : marginForPositions([
-    "top",
-    "bottom"
-  ]);
-}
-function fitBoxes(boxes, chartArea, params, stacks) {
-  const refitBoxes = [];
-  let i, ilen, layout, box, refit, changed;
-  for (i = 0, ilen = boxes.length, refit = 0; i < ilen; ++i) {
-    layout = boxes[i];
-    box = layout.box;
-    box.update(layout.width || chartArea.w, layout.height || chartArea.h, getMargins(layout.horizontal, chartArea));
-    const { same, other } = updateDims(chartArea, params, layout, stacks);
-    refit |= same && refitBoxes.length;
-    changed = changed || other;
-    if (!box.fullSize) {
-      refitBoxes.push(layout);
-    }
-  }
-  return refit && fitBoxes(refitBoxes, chartArea, params, stacks) || changed;
-}
-function setBoxDims(box, left, top, width, height) {
-  box.top = top;
-  box.left = left;
-  box.right = left + width;
-  box.bottom = top + height;
-  box.width = width;
-  box.height = height;
-}
-function placeBoxes(boxes, chartArea, params, stacks) {
-  const userPadding = params.padding;
-  let { x: x2, y: y2 } = chartArea;
-  for (const layout of boxes) {
-    const box = layout.box;
-    const stack = stacks[layout.stack] || {
-      placed: 0,
-      weight: 1
-    };
-    const weight = layout.stackWeight / stack.weight || 1;
-    if (layout.horizontal) {
-      const width = chartArea.w * weight;
-      const height = stack.size || box.height;
-      if (defined(stack.start)) {
-        y2 = stack.start;
-      }
-      if (box.fullSize) {
-        setBoxDims(box, userPadding.left, y2, params.outerWidth - userPadding.right - userPadding.left, height);
-      } else {
-        setBoxDims(box, chartArea.left + stack.placed, y2, width, height);
-      }
-      stack.start = y2;
-      stack.placed += width;
-      y2 = box.bottom;
-    } else {
-      const height = chartArea.h * weight;
-      const width = stack.size || box.width;
-      if (defined(stack.start)) {
-        x2 = stack.start;
-      }
-      if (box.fullSize) {
-        setBoxDims(box, x2, userPadding.top, width, params.outerHeight - userPadding.bottom - userPadding.top);
-      } else {
-        setBoxDims(box, x2, chartArea.top + stack.placed, width, height);
-      }
-      stack.start = x2;
-      stack.placed += height;
-      x2 = box.right;
-    }
-  }
-  chartArea.x = x2;
-  chartArea.y = y2;
-}
-var layouts = {
-  addBox(chart, item) {
-    if (!chart.boxes) {
-      chart.boxes = [];
-    }
-    item.fullSize = item.fullSize || false;
-    item.position = item.position || "top";
-    item.weight = item.weight || 0;
-    item._layers = item._layers || function() {
-      return [
-        {
-          z: 0,
-          draw(chartArea) {
-            item.draw(chartArea);
+      });
+      var require_normalize_svg_path = __commonJS({
+        "node_modules/svg-path-bounds/node_modules/normalize-svg-path/index.js"(exports, module2) {
+          module2.exports = normalize;
+          var arcToCurve = require_cjs6();
+          function normalize(path) {
+            var prev;
+            var result = [];
+            var bezierX = 0;
+            var bezierY = 0;
+            var startX = 0;
+            var startY = 0;
+            var quadX = null;
+            var quadY = null;
+            var x2 = 0;
+            var y2 = 0;
+            for (var i2 = 0, len2 = path.length; i2 < len2; i2++) {
+              var seg = path[i2];
+              var command = seg[0];
+              switch (command) {
+                case "M":
+                  startX = seg[1];
+                  startY = seg[2];
+                  break;
+                case "A":
+                  var curves = arcToCurve({
+                    px: x2,
+                    py: y2,
+                    cx: seg[6],
+                    cy: seg[7],
+                    rx: seg[1],
+                    ry: seg[2],
+                    xAxisRotation: seg[3],
+                    largeArcFlag: seg[4],
+                    sweepFlag: seg[5]
+                  });
+                  if (!curves.length) continue;
+                  for (var j2 = 0, c2; j2 < curves.length; j2++) {
+                    c2 = curves[j2];
+                    seg = ["C", c2.x1, c2.y1, c2.x2, c2.y2, c2.x, c2.y];
+                    if (j2 < curves.length - 1) result.push(seg);
+                  }
+                  break;
+                case "S":
+                  var cx = x2;
+                  var cy = y2;
+                  if (prev == "C" || prev == "S") {
+                    cx += cx - bezierX;
+                    cy += cy - bezierY;
+                  }
+                  seg = ["C", cx, cy, seg[1], seg[2], seg[3], seg[4]];
+                  break;
+                case "T":
+                  if (prev == "Q" || prev == "T") {
+                    quadX = x2 * 2 - quadX;
+                    quadY = y2 * 2 - quadY;
+                  } else {
+                    quadX = x2;
+                    quadY = y2;
+                  }
+                  seg = quadratic(x2, y2, quadX, quadY, seg[1], seg[2]);
+                  break;
+                case "Q":
+                  quadX = seg[1];
+                  quadY = seg[2];
+                  seg = quadratic(x2, y2, seg[1], seg[2], seg[3], seg[4]);
+                  break;
+                case "L":
+                  seg = line(x2, y2, seg[1], seg[2]);
+                  break;
+                case "H":
+                  seg = line(x2, y2, seg[1], y2);
+                  break;
+                case "V":
+                  seg = line(x2, y2, x2, seg[1]);
+                  break;
+                case "Z":
+                  seg = line(x2, y2, startX, startY);
+                  break;
+              }
+              prev = command;
+              x2 = seg[seg.length - 2];
+              y2 = seg[seg.length - 1];
+              if (seg.length > 4) {
+                bezierX = seg[seg.length - 4];
+                bezierY = seg[seg.length - 3];
+              } else {
+                bezierX = x2;
+                bezierY = y2;
+              }
+              result.push(seg);
+            }
+            return result;
+          }
+          function line(x1, y1, x2, y2) {
+            return ["C", x1, y1, x2, y2, x2, y2];
+          }
+          function quadratic(x1, y1, cx, cy, x2, y2) {
+            return [
+              "C",
+              x1 / 3 + 2 / 3 * cx,
+              y1 / 3 + 2 / 3 * cy,
+              x2 / 3 + 2 / 3 * cx,
+              y2 / 3 + 2 / 3 * cy,
+              x2,
+              y2
+            ];
           }
         }
-      ];
-    };
-    chart.boxes.push(item);
-  },
-  removeBox(chart, layoutItem) {
-    const index = chart.boxes ? chart.boxes.indexOf(layoutItem) : -1;
-    if (index !== -1) {
-      chart.boxes.splice(index, 1);
-    }
-  },
-  configure(chart, item, options) {
-    item.fullSize = options.fullSize;
-    item.position = options.position;
-    item.weight = options.weight;
-  },
-  update(chart, width, height, minPadding) {
-    if (!chart) {
-      return;
-    }
-    const padding = toPadding(chart.options.layout.padding);
-    const availableWidth = Math.max(width - padding.width, 0);
-    const availableHeight = Math.max(height - padding.height, 0);
-    const boxes = buildLayoutBoxes(chart.boxes);
-    const verticalBoxes = boxes.vertical;
-    const horizontalBoxes = boxes.horizontal;
-    each(chart.boxes, (box) => {
-      if (typeof box.beforeLayout === "function") {
-        box.beforeLayout();
-      }
-    });
-    const visibleVerticalBoxCount = verticalBoxes.reduce((total, wrap) => wrap.box.options && wrap.box.options.display === false ? total : total + 1, 0) || 1;
-    const params = Object.freeze({
-      outerWidth: width,
-      outerHeight: height,
-      padding,
-      availableWidth,
-      availableHeight,
-      vBoxMaxWidth: availableWidth / 2 / visibleVerticalBoxCount,
-      hBoxMaxHeight: availableHeight / 2
-    });
-    const maxPadding = Object.assign({}, padding);
-    updateMaxPadding(maxPadding, toPadding(minPadding));
-    const chartArea = Object.assign({
-      maxPadding,
-      w: availableWidth,
-      h: availableHeight,
-      x: padding.left,
-      y: padding.top
-    }, padding);
-    const stacks = setLayoutDims(verticalBoxes.concat(horizontalBoxes), params);
-    fitBoxes(boxes.fullSize, chartArea, params, stacks);
-    fitBoxes(verticalBoxes, chartArea, params, stacks);
-    if (fitBoxes(horizontalBoxes, chartArea, params, stacks)) {
-      fitBoxes(verticalBoxes, chartArea, params, stacks);
-    }
-    handleMaxPadding(chartArea);
-    placeBoxes(boxes.leftAndTop, chartArea, params, stacks);
-    chartArea.x += chartArea.w;
-    chartArea.y += chartArea.h;
-    placeBoxes(boxes.rightAndBottom, chartArea, params, stacks);
-    chart.chartArea = {
-      left: chartArea.left,
-      top: chartArea.top,
-      right: chartArea.left + chartArea.w,
-      bottom: chartArea.top + chartArea.h,
-      height: chartArea.h,
-      width: chartArea.w
-    };
-    each(boxes.chartArea, (layout) => {
-      const box = layout.box;
-      Object.assign(box, chart.chartArea);
-      box.update(chartArea.w, chartArea.h, {
-        left: 0,
-        top: 0,
-        right: 0,
-        bottom: 0
       });
-    });
-  }
-};
-class BasePlatform {
-  acquireContext(canvas, aspectRatio) {
-  }
-  releaseContext(context) {
-    return false;
-  }
-  addEventListener(chart, type, listener) {
-  }
-  removeEventListener(chart, type, listener) {
-  }
-  getDevicePixelRatio() {
-    return 1;
-  }
-  getMaximumSize(element, width, height, aspectRatio) {
-    width = Math.max(0, width || element.width);
-    height = height || element.height;
-    return {
-      width,
-      height: Math.max(0, aspectRatio ? Math.floor(width / aspectRatio) : height)
-    };
-  }
-  isAttached(canvas) {
-    return true;
-  }
-  updateConfig(config) {
-  }
-}
-class BasicPlatform extends BasePlatform {
-  acquireContext(item) {
-    return item && item.getContext && item.getContext("2d") || null;
-  }
-  updateConfig(config) {
-    config.options.animation = false;
-  }
-}
-const EXPANDO_KEY = "$chartjs";
-const EVENT_TYPES = {
-  touchstart: "mousedown",
-  touchmove: "mousemove",
-  touchend: "mouseup",
-  pointerenter: "mouseenter",
-  pointerdown: "mousedown",
-  pointermove: "mousemove",
-  pointerup: "mouseup",
-  pointerleave: "mouseout",
-  pointerout: "mouseout"
-};
-const isNullOrEmpty = (value) => value === null || value === "";
-function initCanvas(canvas, aspectRatio) {
-  const style = canvas.style;
-  const renderHeight = canvas.getAttribute("height");
-  const renderWidth = canvas.getAttribute("width");
-  canvas[EXPANDO_KEY] = {
-    initial: {
-      height: renderHeight,
-      width: renderWidth,
-      style: {
-        display: style.display,
-        height: style.height,
-        width: style.width
-      }
-    }
-  };
-  style.display = style.display || "block";
-  style.boxSizing = style.boxSizing || "border-box";
-  if (isNullOrEmpty(renderWidth)) {
-    const displayWidth = readUsedSize(canvas, "width");
-    if (displayWidth !== void 0) {
-      canvas.width = displayWidth;
-    }
-  }
-  if (isNullOrEmpty(renderHeight)) {
-    if (canvas.style.height === "") {
-      canvas.height = canvas.width / (aspectRatio || 2);
-    } else {
-      const displayHeight = readUsedSize(canvas, "height");
-      if (displayHeight !== void 0) {
-        canvas.height = displayHeight;
-      }
-    }
-  }
-  return canvas;
-}
-const eventListenerOptions = supportsEventListenerOptions ? {
-  passive: true
-} : false;
-function addListener(node, type, listener) {
-  if (node) {
-    node.addEventListener(type, listener, eventListenerOptions);
-  }
-}
-function removeListener(chart, type, listener) {
-  if (chart && chart.canvas) {
-    chart.canvas.removeEventListener(type, listener, eventListenerOptions);
-  }
-}
-function fromNativeEvent(event, chart) {
-  const type = EVENT_TYPES[event.type] || event.type;
-  const { x: x2, y: y2 } = getRelativePosition(event, chart);
-  return {
-    type,
-    chart,
-    native: event,
-    x: x2 !== void 0 ? x2 : null,
-    y: y2 !== void 0 ? y2 : null
-  };
-}
-function nodeListContains(nodeList, canvas) {
-  for (const node of nodeList) {
-    if (node === canvas || node.contains(canvas)) {
-      return true;
-    }
-  }
-}
-function createAttachObserver(chart, type, listener) {
-  const canvas = chart.canvas;
-  const observer = new MutationObserver((entries) => {
-    let trigger = false;
-    for (const entry of entries) {
-      trigger = trigger || nodeListContains(entry.addedNodes, canvas);
-      trigger = trigger && !nodeListContains(entry.removedNodes, canvas);
-    }
-    if (trigger) {
-      listener();
-    }
-  });
-  observer.observe(document, {
-    childList: true,
-    subtree: true
-  });
-  return observer;
-}
-function createDetachObserver(chart, type, listener) {
-  const canvas = chart.canvas;
-  const observer = new MutationObserver((entries) => {
-    let trigger = false;
-    for (const entry of entries) {
-      trigger = trigger || nodeListContains(entry.removedNodes, canvas);
-      trigger = trigger && !nodeListContains(entry.addedNodes, canvas);
-    }
-    if (trigger) {
-      listener();
-    }
-  });
-  observer.observe(document, {
-    childList: true,
-    subtree: true
-  });
-  return observer;
-}
-const drpListeningCharts = /* @__PURE__ */ new Map();
-let oldDevicePixelRatio = 0;
-function onWindowResize() {
-  const dpr = window.devicePixelRatio;
-  if (dpr === oldDevicePixelRatio) {
-    return;
-  }
-  oldDevicePixelRatio = dpr;
-  drpListeningCharts.forEach((resize, chart) => {
-    if (chart.currentDevicePixelRatio !== dpr) {
-      resize();
-    }
-  });
-}
-function listenDevicePixelRatioChanges(chart, resize) {
-  if (!drpListeningCharts.size) {
-    window.addEventListener("resize", onWindowResize);
-  }
-  drpListeningCharts.set(chart, resize);
-}
-function unlistenDevicePixelRatioChanges(chart) {
-  drpListeningCharts.delete(chart);
-  if (!drpListeningCharts.size) {
-    window.removeEventListener("resize", onWindowResize);
-  }
-}
-function createResizeObserver(chart, type, listener) {
-  const canvas = chart.canvas;
-  const container = canvas && _getParentNode(canvas);
-  if (!container) {
-    return;
-  }
-  const resize = throttled((width, height) => {
-    const w2 = container.clientWidth;
-    listener(width, height);
-    if (w2 < container.clientWidth) {
-      listener();
-    }
-  }, window);
-  const observer = new ResizeObserver((entries) => {
-    const entry = entries[0];
-    const width = entry.contentRect.width;
-    const height = entry.contentRect.height;
-    if (width === 0 && height === 0) {
-      return;
-    }
-    resize(width, height);
-  });
-  observer.observe(container);
-  listenDevicePixelRatioChanges(chart, resize);
-  return observer;
-}
-function releaseObserver(chart, type, observer) {
-  if (observer) {
-    observer.disconnect();
-  }
-  if (type === "resize") {
-    unlistenDevicePixelRatioChanges(chart);
-  }
-}
-function createProxyAndListen(chart, type, listener) {
-  const canvas = chart.canvas;
-  const proxy = throttled((event) => {
-    if (chart.ctx !== null) {
-      listener(fromNativeEvent(event, chart));
-    }
-  }, chart);
-  addListener(canvas, type, proxy);
-  return proxy;
-}
-class DomPlatform extends BasePlatform {
-  acquireContext(canvas, aspectRatio) {
-    const context = canvas && canvas.getContext && canvas.getContext("2d");
-    if (context && context.canvas === canvas) {
-      initCanvas(canvas, aspectRatio);
-      return context;
-    }
-    return null;
-  }
-  releaseContext(context) {
-    const canvas = context.canvas;
-    if (!canvas[EXPANDO_KEY]) {
-      return false;
-    }
-    const initial = canvas[EXPANDO_KEY].initial;
-    [
-      "height",
-      "width"
-    ].forEach((prop) => {
-      const value = initial[prop];
-      if (isNullOrUndef(value)) {
-        canvas.removeAttribute(prop);
-      } else {
-        canvas.setAttribute(prop, value);
-      }
-    });
-    const style = initial.style || {};
-    Object.keys(style).forEach((key) => {
-      canvas.style[key] = style[key];
-    });
-    canvas.width = canvas.width;
-    delete canvas[EXPANDO_KEY];
-    return true;
-  }
-  addEventListener(chart, type, listener) {
-    this.removeEventListener(chart, type);
-    const proxies = chart.$proxies || (chart.$proxies = {});
-    const handlers = {
-      attach: createAttachObserver,
-      detach: createDetachObserver,
-      resize: createResizeObserver
-    };
-    const handler = handlers[type] || createProxyAndListen;
-    proxies[type] = handler(chart, type, listener);
-  }
-  removeEventListener(chart, type) {
-    const proxies = chart.$proxies || (chart.$proxies = {});
-    const proxy = proxies[type];
-    if (!proxy) {
-      return;
-    }
-    const handlers = {
-      attach: releaseObserver,
-      detach: releaseObserver,
-      resize: releaseObserver
-    };
-    const handler = handlers[type] || removeListener;
-    handler(chart, type, proxy);
-    proxies[type] = void 0;
-  }
-  getDevicePixelRatio() {
-    return window.devicePixelRatio;
-  }
-  getMaximumSize(canvas, width, height, aspectRatio) {
-    return getMaximumSize(canvas, width, height, aspectRatio);
-  }
-  isAttached(canvas) {
-    const container = canvas && _getParentNode(canvas);
-    return !!(container && container.isConnected);
-  }
-}
-function _detectPlatform(canvas) {
-  if (!_isDomSupported() || typeof OffscreenCanvas !== "undefined" && canvas instanceof OffscreenCanvas) {
-    return BasicPlatform;
-  }
-  return DomPlatform;
-}
-let Element$1 = (_a = class {
-  constructor() {
-    __publicField(this, "x");
-    __publicField(this, "y");
-    __publicField(this, "active", false);
-    __publicField(this, "options");
-    __publicField(this, "$animations");
-  }
-  tooltipPosition(useFinalPosition) {
-    const { x: x2, y: y2 } = this.getProps([
-      "x",
-      "y"
-    ], useFinalPosition);
-    return {
-      x: x2,
-      y: y2
-    };
-  }
-  hasValue() {
-    return isNumber(this.x) && isNumber(this.y);
-  }
-  getProps(props, final) {
-    const anims = this.$animations;
-    if (!final || !anims) {
-      return this;
-    }
-    const ret = {};
-    props.forEach((prop) => {
-      ret[prop] = anims[prop] && anims[prop].active() ? anims[prop]._to : this[prop];
-    });
-    return ret;
-  }
-}, __publicField(_a, "defaults", {}), __publicField(_a, "defaultRoutes"), _a);
-function autoSkip(scale, ticks) {
-  const tickOpts = scale.options.ticks;
-  const determinedMaxTicks = determineMaxTicks(scale);
-  const ticksLimit = Math.min(tickOpts.maxTicksLimit || determinedMaxTicks, determinedMaxTicks);
-  const majorIndices = tickOpts.major.enabled ? getMajorIndices(ticks) : [];
-  const numMajorIndices = majorIndices.length;
-  const first = majorIndices[0];
-  const last = majorIndices[numMajorIndices - 1];
-  const newTicks = [];
-  if (numMajorIndices > ticksLimit) {
-    skipMajors(ticks, newTicks, majorIndices, numMajorIndices / ticksLimit);
-    return newTicks;
-  }
-  const spacing = calculateSpacing(majorIndices, ticks, ticksLimit);
-  if (numMajorIndices > 0) {
-    let i, ilen;
-    const avgMajorSpacing = numMajorIndices > 1 ? Math.round((last - first) / (numMajorIndices - 1)) : null;
-    skip(ticks, newTicks, spacing, isNullOrUndef(avgMajorSpacing) ? 0 : first - avgMajorSpacing, first);
-    for (i = 0, ilen = numMajorIndices - 1; i < ilen; i++) {
-      skip(ticks, newTicks, spacing, majorIndices[i], majorIndices[i + 1]);
-    }
-    skip(ticks, newTicks, spacing, last, isNullOrUndef(avgMajorSpacing) ? ticks.length : last + avgMajorSpacing);
-    return newTicks;
-  }
-  skip(ticks, newTicks, spacing);
-  return newTicks;
-}
-function determineMaxTicks(scale) {
-  const offset = scale.options.offset;
-  const tickLength = scale._tickSize();
-  const maxScale = scale._length / tickLength + (offset ? 0 : 1);
-  const maxChart = scale._maxLength / tickLength;
-  return Math.floor(Math.min(maxScale, maxChart));
-}
-function calculateSpacing(majorIndices, ticks, ticksLimit) {
-  const evenMajorSpacing = getEvenSpacing(majorIndices);
-  const spacing = ticks.length / ticksLimit;
-  if (!evenMajorSpacing) {
-    return Math.max(spacing, 1);
-  }
-  const factors = _factorize(evenMajorSpacing);
-  for (let i = 0, ilen = factors.length - 1; i < ilen; i++) {
-    const factor = factors[i];
-    if (factor > spacing) {
-      return factor;
-    }
-  }
-  return Math.max(spacing, 1);
-}
-function getMajorIndices(ticks) {
-  const result = [];
-  let i, ilen;
-  for (i = 0, ilen = ticks.length; i < ilen; i++) {
-    if (ticks[i].major) {
-      result.push(i);
-    }
-  }
-  return result;
-}
-function skipMajors(ticks, newTicks, majorIndices, spacing) {
-  let count = 0;
-  let next = majorIndices[0];
-  let i;
-  spacing = Math.ceil(spacing);
-  for (i = 0; i < ticks.length; i++) {
-    if (i === next) {
-      newTicks.push(ticks[i]);
-      count++;
-      next = majorIndices[count * spacing];
-    }
-  }
-}
-function skip(ticks, newTicks, spacing, majorStart, majorEnd) {
-  const start = valueOrDefault(majorStart, 0);
-  const end = Math.min(valueOrDefault(majorEnd, ticks.length), ticks.length);
-  let count = 0;
-  let length, i, next;
-  spacing = Math.ceil(spacing);
-  if (majorEnd) {
-    length = majorEnd - majorStart;
-    spacing = length / Math.floor(length / spacing);
-  }
-  next = start;
-  while (next < 0) {
-    count++;
-    next = Math.round(start + count * spacing);
-  }
-  for (i = Math.max(start, 0); i < end; i++) {
-    if (i === next) {
-      newTicks.push(ticks[i]);
-      count++;
-      next = Math.round(start + count * spacing);
-    }
-  }
-}
-function getEvenSpacing(arr) {
-  const len = arr.length;
-  let i, diff;
-  if (len < 2) {
-    return false;
-  }
-  for (diff = arr[0], i = 1; i < len; ++i) {
-    if (arr[i] - arr[i - 1] !== diff) {
-      return false;
-    }
-  }
-  return diff;
-}
-const reverseAlign = (align) => align === "left" ? "right" : align === "right" ? "left" : align;
-const offsetFromEdge = (scale, edge, offset) => edge === "top" || edge === "left" ? scale[edge] + offset : scale[edge] - offset;
-const getTicksLimit = (ticksLength, maxTicksLimit) => Math.min(maxTicksLimit || ticksLength, ticksLength);
-function sample(arr, numItems) {
-  const result = [];
-  const increment = arr.length / numItems;
-  const len = arr.length;
-  let i = 0;
-  for (; i < len; i += increment) {
-    result.push(arr[Math.floor(i)]);
-  }
-  return result;
-}
-function getPixelForGridLine(scale, index, offsetGridLines) {
-  const length = scale.ticks.length;
-  const validIndex = Math.min(index, length - 1);
-  const start = scale._startPixel;
-  const end = scale._endPixel;
-  const epsilon = 1e-6;
-  let lineValue = scale.getPixelForTick(validIndex);
-  let offset;
-  if (offsetGridLines) {
-    if (length === 1) {
-      offset = Math.max(lineValue - start, end - lineValue);
-    } else if (index === 0) {
-      offset = (scale.getPixelForTick(1) - lineValue) / 2;
-    } else {
-      offset = (lineValue - scale.getPixelForTick(validIndex - 1)) / 2;
-    }
-    lineValue += validIndex < index ? offset : -offset;
-    if (lineValue < start - epsilon || lineValue > end + epsilon) {
-      return;
-    }
-  }
-  return lineValue;
-}
-function garbageCollect(caches, length) {
-  each(caches, (cache) => {
-    const gc2 = cache.gc;
-    const gcLen = gc2.length / 2;
-    let i;
-    if (gcLen > length) {
-      for (i = 0; i < gcLen; ++i) {
-        delete cache.data[gc2[i]];
-      }
-      gc2.splice(0, gcLen);
-    }
-  });
-}
-function getTickMarkLength(options) {
-  return options.drawTicks ? options.tickLength : 0;
-}
-function getTitleHeight(options, fallback) {
-  if (!options.display) {
-    return 0;
-  }
-  const font = toFont(options.font, fallback);
-  const padding = toPadding(options.padding);
-  const lines = isArray(options.text) ? options.text.length : 1;
-  return lines * font.lineHeight + padding.height;
-}
-function createScaleContext(parent, scale) {
-  return createContext(parent, {
-    scale,
-    type: "scale"
-  });
-}
-function createTickContext(parent, index, tick) {
-  return createContext(parent, {
-    tick,
-    index,
-    type: "tick"
-  });
-}
-function titleAlign(align, position, reverse) {
-  let ret = _toLeftRightCenter(align);
-  if (reverse && position !== "right" || !reverse && position === "right") {
-    ret = reverseAlign(ret);
-  }
-  return ret;
-}
-function titleArgs(scale, offset, position, align) {
-  const { top, left, bottom, right, chart } = scale;
-  const { chartArea, scales } = chart;
-  let rotation = 0;
-  let maxWidth, titleX, titleY;
-  const height = bottom - top;
-  const width = right - left;
-  if (scale.isHorizontal()) {
-    titleX = _alignStartEnd(align, left, right);
-    if (isObject(position)) {
-      const positionAxisID = Object.keys(position)[0];
-      const value = position[positionAxisID];
-      titleY = scales[positionAxisID].getPixelForValue(value) + height - offset;
-    } else if (position === "center") {
-      titleY = (chartArea.bottom + chartArea.top) / 2 + height - offset;
-    } else {
-      titleY = offsetFromEdge(scale, position, offset);
-    }
-    maxWidth = right - left;
-  } else {
-    if (isObject(position)) {
-      const positionAxisID = Object.keys(position)[0];
-      const value = position[positionAxisID];
-      titleX = scales[positionAxisID].getPixelForValue(value) - width + offset;
-    } else if (position === "center") {
-      titleX = (chartArea.left + chartArea.right) / 2 - width + offset;
-    } else {
-      titleX = offsetFromEdge(scale, position, offset);
-    }
-    titleY = _alignStartEnd(align, bottom, top);
-    rotation = position === "left" ? -HALF_PI : HALF_PI;
-  }
-  return {
-    titleX,
-    titleY,
-    maxWidth,
-    rotation
-  };
-}
-class Scale extends Element$1 {
-  constructor(cfg) {
-    super();
-    this.id = cfg.id;
-    this.type = cfg.type;
-    this.options = void 0;
-    this.ctx = cfg.ctx;
-    this.chart = cfg.chart;
-    this.top = void 0;
-    this.bottom = void 0;
-    this.left = void 0;
-    this.right = void 0;
-    this.width = void 0;
-    this.height = void 0;
-    this._margins = {
-      left: 0,
-      right: 0,
-      top: 0,
-      bottom: 0
-    };
-    this.maxWidth = void 0;
-    this.maxHeight = void 0;
-    this.paddingTop = void 0;
-    this.paddingBottom = void 0;
-    this.paddingLeft = void 0;
-    this.paddingRight = void 0;
-    this.axis = void 0;
-    this.labelRotation = void 0;
-    this.min = void 0;
-    this.max = void 0;
-    this._range = void 0;
-    this.ticks = [];
-    this._gridLineItems = null;
-    this._labelItems = null;
-    this._labelSizes = null;
-    this._length = 0;
-    this._maxLength = 0;
-    this._longestTextCache = {};
-    this._startPixel = void 0;
-    this._endPixel = void 0;
-    this._reversePixels = false;
-    this._userMax = void 0;
-    this._userMin = void 0;
-    this._suggestedMax = void 0;
-    this._suggestedMin = void 0;
-    this._ticksLength = 0;
-    this._borderValue = 0;
-    this._cache = {};
-    this._dataLimitsCached = false;
-    this.$context = void 0;
-  }
-  init(options) {
-    this.options = options.setContext(this.getContext());
-    this.axis = options.axis;
-    this._userMin = this.parse(options.min);
-    this._userMax = this.parse(options.max);
-    this._suggestedMin = this.parse(options.suggestedMin);
-    this._suggestedMax = this.parse(options.suggestedMax);
-  }
-  parse(raw, index) {
-    return raw;
-  }
-  getUserBounds() {
-    let { _userMin, _userMax, _suggestedMin, _suggestedMax } = this;
-    _userMin = finiteOrDefault(_userMin, Number.POSITIVE_INFINITY);
-    _userMax = finiteOrDefault(_userMax, Number.NEGATIVE_INFINITY);
-    _suggestedMin = finiteOrDefault(_suggestedMin, Number.POSITIVE_INFINITY);
-    _suggestedMax = finiteOrDefault(_suggestedMax, Number.NEGATIVE_INFINITY);
-    return {
-      min: finiteOrDefault(_userMin, _suggestedMin),
-      max: finiteOrDefault(_userMax, _suggestedMax),
-      minDefined: isNumberFinite(_userMin),
-      maxDefined: isNumberFinite(_userMax)
-    };
-  }
-  getMinMax(canStack) {
-    let { min, max, minDefined, maxDefined } = this.getUserBounds();
-    let range;
-    if (minDefined && maxDefined) {
-      return {
-        min,
-        max
-      };
-    }
-    const metas = this.getMatchingVisibleMetas();
-    for (let i = 0, ilen = metas.length; i < ilen; ++i) {
-      range = metas[i].controller.getMinMax(this, canStack);
-      if (!minDefined) {
-        min = Math.min(min, range.min);
-      }
-      if (!maxDefined) {
-        max = Math.max(max, range.max);
-      }
-    }
-    min = maxDefined && min > max ? max : min;
-    max = minDefined && min > max ? min : max;
-    return {
-      min: finiteOrDefault(min, finiteOrDefault(max, min)),
-      max: finiteOrDefault(max, finiteOrDefault(min, max))
-    };
-  }
-  getPadding() {
-    return {
-      left: this.paddingLeft || 0,
-      top: this.paddingTop || 0,
-      right: this.paddingRight || 0,
-      bottom: this.paddingBottom || 0
-    };
-  }
-  getTicks() {
-    return this.ticks;
-  }
-  getLabels() {
-    const data = this.chart.data;
-    return this.options.labels || (this.isHorizontal() ? data.xLabels : data.yLabels) || data.labels || [];
-  }
-  getLabelItems(chartArea = this.chart.chartArea) {
-    const items = this._labelItems || (this._labelItems = this._computeLabelItems(chartArea));
-    return items;
-  }
-  beforeLayout() {
-    this._cache = {};
-    this._dataLimitsCached = false;
-  }
-  beforeUpdate() {
-    callback(this.options.beforeUpdate, [
-      this
-    ]);
-  }
-  update(maxWidth, maxHeight, margins) {
-    const { beginAtZero, grace, ticks: tickOpts } = this.options;
-    const sampleSize = tickOpts.sampleSize;
-    this.beforeUpdate();
-    this.maxWidth = maxWidth;
-    this.maxHeight = maxHeight;
-    this._margins = margins = Object.assign({
-      left: 0,
-      right: 0,
-      top: 0,
-      bottom: 0
-    }, margins);
-    this.ticks = null;
-    this._labelSizes = null;
-    this._gridLineItems = null;
-    this._labelItems = null;
-    this.beforeSetDimensions();
-    this.setDimensions();
-    this.afterSetDimensions();
-    this._maxLength = this.isHorizontal() ? this.width + margins.left + margins.right : this.height + margins.top + margins.bottom;
-    if (!this._dataLimitsCached) {
-      this.beforeDataLimits();
-      this.determineDataLimits();
-      this.afterDataLimits();
-      this._range = _addGrace(this, grace, beginAtZero);
-      this._dataLimitsCached = true;
-    }
-    this.beforeBuildTicks();
-    this.ticks = this.buildTicks() || [];
-    this.afterBuildTicks();
-    const samplingEnabled = sampleSize < this.ticks.length;
-    this._convertTicksToLabels(samplingEnabled ? sample(this.ticks, sampleSize) : this.ticks);
-    this.configure();
-    this.beforeCalculateLabelRotation();
-    this.calculateLabelRotation();
-    this.afterCalculateLabelRotation();
-    if (tickOpts.display && (tickOpts.autoSkip || tickOpts.source === "auto")) {
-      this.ticks = autoSkip(this, this.ticks);
-      this._labelSizes = null;
-      this.afterAutoSkip();
-    }
-    if (samplingEnabled) {
-      this._convertTicksToLabels(this.ticks);
-    }
-    this.beforeFit();
-    this.fit();
-    this.afterFit();
-    this.afterUpdate();
-  }
-  configure() {
-    let reversePixels = this.options.reverse;
-    let startPixel, endPixel;
-    if (this.isHorizontal()) {
-      startPixel = this.left;
-      endPixel = this.right;
-    } else {
-      startPixel = this.top;
-      endPixel = this.bottom;
-      reversePixels = !reversePixels;
-    }
-    this._startPixel = startPixel;
-    this._endPixel = endPixel;
-    this._reversePixels = reversePixels;
-    this._length = endPixel - startPixel;
-    this._alignToPixels = this.options.alignToPixels;
-  }
-  afterUpdate() {
-    callback(this.options.afterUpdate, [
-      this
-    ]);
-  }
-  beforeSetDimensions() {
-    callback(this.options.beforeSetDimensions, [
-      this
-    ]);
-  }
-  setDimensions() {
-    if (this.isHorizontal()) {
-      this.width = this.maxWidth;
-      this.left = 0;
-      this.right = this.width;
-    } else {
-      this.height = this.maxHeight;
-      this.top = 0;
-      this.bottom = this.height;
-    }
-    this.paddingLeft = 0;
-    this.paddingTop = 0;
-    this.paddingRight = 0;
-    this.paddingBottom = 0;
-  }
-  afterSetDimensions() {
-    callback(this.options.afterSetDimensions, [
-      this
-    ]);
-  }
-  _callHooks(name) {
-    this.chart.notifyPlugins(name, this.getContext());
-    callback(this.options[name], [
-      this
-    ]);
-  }
-  beforeDataLimits() {
-    this._callHooks("beforeDataLimits");
-  }
-  determineDataLimits() {
-  }
-  afterDataLimits() {
-    this._callHooks("afterDataLimits");
-  }
-  beforeBuildTicks() {
-    this._callHooks("beforeBuildTicks");
-  }
-  buildTicks() {
-    return [];
-  }
-  afterBuildTicks() {
-    this._callHooks("afterBuildTicks");
-  }
-  beforeTickToLabelConversion() {
-    callback(this.options.beforeTickToLabelConversion, [
-      this
-    ]);
-  }
-  generateTickLabels(ticks) {
-    const tickOpts = this.options.ticks;
-    let i, ilen, tick;
-    for (i = 0, ilen = ticks.length; i < ilen; i++) {
-      tick = ticks[i];
-      tick.label = callback(tickOpts.callback, [
-        tick.value,
-        i,
-        ticks
-      ], this);
-    }
-  }
-  afterTickToLabelConversion() {
-    callback(this.options.afterTickToLabelConversion, [
-      this
-    ]);
-  }
-  beforeCalculateLabelRotation() {
-    callback(this.options.beforeCalculateLabelRotation, [
-      this
-    ]);
-  }
-  calculateLabelRotation() {
-    const options = this.options;
-    const tickOpts = options.ticks;
-    const numTicks = getTicksLimit(this.ticks.length, options.ticks.maxTicksLimit);
-    const minRotation = tickOpts.minRotation || 0;
-    const maxRotation = tickOpts.maxRotation;
-    let labelRotation = minRotation;
-    let tickWidth, maxHeight, maxLabelDiagonal;
-    if (!this._isVisible() || !tickOpts.display || minRotation >= maxRotation || numTicks <= 1 || !this.isHorizontal()) {
-      this.labelRotation = minRotation;
-      return;
-    }
-    const labelSizes = this._getLabelSizes();
-    const maxLabelWidth = labelSizes.widest.width;
-    const maxLabelHeight = labelSizes.highest.height;
-    const maxWidth = _limitValue(this.chart.width - maxLabelWidth, 0, this.maxWidth);
-    tickWidth = options.offset ? this.maxWidth / numTicks : maxWidth / (numTicks - 1);
-    if (maxLabelWidth + 6 > tickWidth) {
-      tickWidth = maxWidth / (numTicks - (options.offset ? 0.5 : 1));
-      maxHeight = this.maxHeight - getTickMarkLength(options.grid) - tickOpts.padding - getTitleHeight(options.title, this.chart.options.font);
-      maxLabelDiagonal = Math.sqrt(maxLabelWidth * maxLabelWidth + maxLabelHeight * maxLabelHeight);
-      labelRotation = toDegrees(Math.min(Math.asin(_limitValue((labelSizes.highest.height + 6) / tickWidth, -1, 1)), Math.asin(_limitValue(maxHeight / maxLabelDiagonal, -1, 1)) - Math.asin(_limitValue(maxLabelHeight / maxLabelDiagonal, -1, 1))));
-      labelRotation = Math.max(minRotation, Math.min(maxRotation, labelRotation));
-    }
-    this.labelRotation = labelRotation;
-  }
-  afterCalculateLabelRotation() {
-    callback(this.options.afterCalculateLabelRotation, [
-      this
-    ]);
-  }
-  afterAutoSkip() {
-  }
-  beforeFit() {
-    callback(this.options.beforeFit, [
-      this
-    ]);
-  }
-  fit() {
-    const minSize = {
-      width: 0,
-      height: 0
-    };
-    const { chart, options: { ticks: tickOpts, title: titleOpts, grid: gridOpts } } = this;
-    const display = this._isVisible();
-    const isHorizontal = this.isHorizontal();
-    if (display) {
-      const titleHeight = getTitleHeight(titleOpts, chart.options.font);
-      if (isHorizontal) {
-        minSize.width = this.maxWidth;
-        minSize.height = getTickMarkLength(gridOpts) + titleHeight;
-      } else {
-        minSize.height = this.maxHeight;
-        minSize.width = getTickMarkLength(gridOpts) + titleHeight;
-      }
-      if (tickOpts.display && this.ticks.length) {
-        const { first, last, widest, highest } = this._getLabelSizes();
-        const tickPadding = tickOpts.padding * 2;
-        const angleRadians = toRadians(this.labelRotation);
-        const cos = Math.cos(angleRadians);
-        const sin = Math.sin(angleRadians);
-        if (isHorizontal) {
-          const labelHeight = tickOpts.mirror ? 0 : sin * widest.width + cos * highest.height;
-          minSize.height = Math.min(this.maxHeight, minSize.height + labelHeight + tickPadding);
-        } else {
-          const labelWidth = tickOpts.mirror ? 0 : cos * widest.width + sin * highest.height;
-          minSize.width = Math.min(this.maxWidth, minSize.width + labelWidth + tickPadding);
+      var require_is_svg_path = __commonJS({
+        "node_modules/is-svg-path/index.js"(exports, module2) {
+          module2.exports = function isPath(str) {
+            if (typeof str !== "string") return false;
+            str = str.trim();
+            if (/^[mzlhvcsqta]\s*[-+.0-9][^mlhvzcsqta]+/i.test(str) && /[\dz]$/i.test(str) && str.length > 4) return true;
+            return false;
+          };
         }
-        this._calculatePadding(first, last, sin, cos);
-      }
-    }
-    this._handleMargins();
-    if (isHorizontal) {
-      this.width = this._length = chart.width - this._margins.left - this._margins.right;
-      this.height = minSize.height;
-    } else {
-      this.width = minSize.width;
-      this.height = this._length = chart.height - this._margins.top - this._margins.bottom;
-    }
-  }
-  _calculatePadding(first, last, sin, cos) {
-    const { ticks: { align, padding }, position } = this.options;
-    const isRotated = this.labelRotation !== 0;
-    const labelsBelowTicks = position !== "top" && this.axis === "x";
-    if (this.isHorizontal()) {
-      const offsetLeft = this.getPixelForTick(0) - this.left;
-      const offsetRight = this.right - this.getPixelForTick(this.ticks.length - 1);
-      let paddingLeft = 0;
-      let paddingRight = 0;
-      if (isRotated) {
-        if (labelsBelowTicks) {
-          paddingLeft = cos * first.width;
-          paddingRight = sin * last.height;
-        } else {
-          paddingLeft = sin * first.height;
-          paddingRight = cos * last.width;
-        }
-      } else if (align === "start") {
-        paddingRight = last.width;
-      } else if (align === "end") {
-        paddingLeft = first.width;
-      } else if (align !== "inner") {
-        paddingLeft = first.width / 2;
-        paddingRight = last.width / 2;
-      }
-      this.paddingLeft = Math.max((paddingLeft - offsetLeft + padding) * this.width / (this.width - offsetLeft), 0);
-      this.paddingRight = Math.max((paddingRight - offsetRight + padding) * this.width / (this.width - offsetRight), 0);
-    } else {
-      let paddingTop = last.height / 2;
-      let paddingBottom = first.height / 2;
-      if (align === "start") {
-        paddingTop = 0;
-        paddingBottom = first.height;
-      } else if (align === "end") {
-        paddingTop = last.height;
-        paddingBottom = 0;
-      }
-      this.paddingTop = paddingTop + padding;
-      this.paddingBottom = paddingBottom + padding;
-    }
-  }
-  _handleMargins() {
-    if (this._margins) {
-      this._margins.left = Math.max(this.paddingLeft, this._margins.left);
-      this._margins.top = Math.max(this.paddingTop, this._margins.top);
-      this._margins.right = Math.max(this.paddingRight, this._margins.right);
-      this._margins.bottom = Math.max(this.paddingBottom, this._margins.bottom);
-    }
-  }
-  afterFit() {
-    callback(this.options.afterFit, [
-      this
-    ]);
-  }
-  isHorizontal() {
-    const { axis, position } = this.options;
-    return position === "top" || position === "bottom" || axis === "x";
-  }
-  isFullSize() {
-    return this.options.fullSize;
-  }
-  _convertTicksToLabels(ticks) {
-    this.beforeTickToLabelConversion();
-    this.generateTickLabels(ticks);
-    let i, ilen;
-    for (i = 0, ilen = ticks.length; i < ilen; i++) {
-      if (isNullOrUndef(ticks[i].label)) {
-        ticks.splice(i, 1);
-        ilen--;
-        i--;
-      }
-    }
-    this.afterTickToLabelConversion();
-  }
-  _getLabelSizes() {
-    let labelSizes = this._labelSizes;
-    if (!labelSizes) {
-      const sampleSize = this.options.ticks.sampleSize;
-      let ticks = this.ticks;
-      if (sampleSize < ticks.length) {
-        ticks = sample(ticks, sampleSize);
-      }
-      this._labelSizes = labelSizes = this._computeLabelSizes(ticks, ticks.length, this.options.ticks.maxTicksLimit);
-    }
-    return labelSizes;
-  }
-  _computeLabelSizes(ticks, length, maxTicksLimit) {
-    const { ctx, _longestTextCache: caches } = this;
-    const widths = [];
-    const heights = [];
-    const increment = Math.floor(length / getTicksLimit(length, maxTicksLimit));
-    let widestLabelSize = 0;
-    let highestLabelSize = 0;
-    let i, j, jlen, label, tickFont, fontString, cache, lineHeight, width, height, nestedLabel;
-    for (i = 0; i < length; i += increment) {
-      label = ticks[i].label;
-      tickFont = this._resolveTickFontOptions(i);
-      ctx.font = fontString = tickFont.string;
-      cache = caches[fontString] = caches[fontString] || {
-        data: {},
-        gc: []
-      };
-      lineHeight = tickFont.lineHeight;
-      width = height = 0;
-      if (!isNullOrUndef(label) && !isArray(label)) {
-        width = _measureText(ctx, cache.data, cache.gc, width, label);
-        height = lineHeight;
-      } else if (isArray(label)) {
-        for (j = 0, jlen = label.length; j < jlen; ++j) {
-          nestedLabel = label[j];
-          if (!isNullOrUndef(nestedLabel) && !isArray(nestedLabel)) {
-            width = _measureText(ctx, cache.data, cache.gc, width, nestedLabel);
-            height += lineHeight;
-          }
-        }
-      }
-      widths.push(width);
-      heights.push(height);
-      widestLabelSize = Math.max(width, widestLabelSize);
-      highestLabelSize = Math.max(height, highestLabelSize);
-    }
-    garbageCollect(caches, length);
-    const widest = widths.indexOf(widestLabelSize);
-    const highest = heights.indexOf(highestLabelSize);
-    const valueAt = (idx) => ({
-      width: widths[idx] || 0,
-      height: heights[idx] || 0
-    });
-    return {
-      first: valueAt(0),
-      last: valueAt(length - 1),
-      widest: valueAt(widest),
-      highest: valueAt(highest),
-      widths,
-      heights
-    };
-  }
-  getLabelForValue(value) {
-    return value;
-  }
-  getPixelForValue(value, index) {
-    return NaN;
-  }
-  getValueForPixel(pixel) {
-  }
-  getPixelForTick(index) {
-    const ticks = this.ticks;
-    if (index < 0 || index > ticks.length - 1) {
-      return null;
-    }
-    return this.getPixelForValue(ticks[index].value);
-  }
-  getPixelForDecimal(decimal) {
-    if (this._reversePixels) {
-      decimal = 1 - decimal;
-    }
-    const pixel = this._startPixel + decimal * this._length;
-    return _int16Range(this._alignToPixels ? _alignPixel(this.chart, pixel, 0) : pixel);
-  }
-  getDecimalForPixel(pixel) {
-    const decimal = (pixel - this._startPixel) / this._length;
-    return this._reversePixels ? 1 - decimal : decimal;
-  }
-  getBasePixel() {
-    return this.getPixelForValue(this.getBaseValue());
-  }
-  getBaseValue() {
-    const { min, max } = this;
-    return min < 0 && max < 0 ? max : min > 0 && max > 0 ? min : 0;
-  }
-  getContext(index) {
-    const ticks = this.ticks || [];
-    if (index >= 0 && index < ticks.length) {
-      const tick = ticks[index];
-      return tick.$context || (tick.$context = createTickContext(this.getContext(), index, tick));
-    }
-    return this.$context || (this.$context = createScaleContext(this.chart.getContext(), this));
-  }
-  _tickSize() {
-    const optionTicks = this.options.ticks;
-    const rot = toRadians(this.labelRotation);
-    const cos = Math.abs(Math.cos(rot));
-    const sin = Math.abs(Math.sin(rot));
-    const labelSizes = this._getLabelSizes();
-    const padding = optionTicks.autoSkipPadding || 0;
-    const w2 = labelSizes ? labelSizes.widest.width + padding : 0;
-    const h = labelSizes ? labelSizes.highest.height + padding : 0;
-    return this.isHorizontal() ? h * cos > w2 * sin ? w2 / cos : h / sin : h * sin < w2 * cos ? h / cos : w2 / sin;
-  }
-  _isVisible() {
-    const display = this.options.display;
-    if (display !== "auto") {
-      return !!display;
-    }
-    return this.getMatchingVisibleMetas().length > 0;
-  }
-  _computeGridLineItems(chartArea) {
-    const axis = this.axis;
-    const chart = this.chart;
-    const options = this.options;
-    const { grid, position, border } = options;
-    const offset = grid.offset;
-    const isHorizontal = this.isHorizontal();
-    const ticks = this.ticks;
-    const ticksLength = ticks.length + (offset ? 1 : 0);
-    const tl2 = getTickMarkLength(grid);
-    const items = [];
-    const borderOpts = border.setContext(this.getContext());
-    const axisWidth = borderOpts.display ? borderOpts.width : 0;
-    const axisHalfWidth = axisWidth / 2;
-    const alignBorderValue = function(pixel) {
-      return _alignPixel(chart, pixel, axisWidth);
-    };
-    let borderValue, i, lineValue, alignedLineValue;
-    let tx1, ty1, tx2, ty2, x1, y1, x2, y2;
-    if (position === "top") {
-      borderValue = alignBorderValue(this.bottom);
-      ty1 = this.bottom - tl2;
-      ty2 = borderValue - axisHalfWidth;
-      y1 = alignBorderValue(chartArea.top) + axisHalfWidth;
-      y2 = chartArea.bottom;
-    } else if (position === "bottom") {
-      borderValue = alignBorderValue(this.top);
-      y1 = chartArea.top;
-      y2 = alignBorderValue(chartArea.bottom) - axisHalfWidth;
-      ty1 = borderValue + axisHalfWidth;
-      ty2 = this.top + tl2;
-    } else if (position === "left") {
-      borderValue = alignBorderValue(this.right);
-      tx1 = this.right - tl2;
-      tx2 = borderValue - axisHalfWidth;
-      x1 = alignBorderValue(chartArea.left) + axisHalfWidth;
-      x2 = chartArea.right;
-    } else if (position === "right") {
-      borderValue = alignBorderValue(this.left);
-      x1 = chartArea.left;
-      x2 = alignBorderValue(chartArea.right) - axisHalfWidth;
-      tx1 = borderValue + axisHalfWidth;
-      tx2 = this.left + tl2;
-    } else if (axis === "x") {
-      if (position === "center") {
-        borderValue = alignBorderValue((chartArea.top + chartArea.bottom) / 2 + 0.5);
-      } else if (isObject(position)) {
-        const positionAxisID = Object.keys(position)[0];
-        const value = position[positionAxisID];
-        borderValue = alignBorderValue(this.chart.scales[positionAxisID].getPixelForValue(value));
-      }
-      y1 = chartArea.top;
-      y2 = chartArea.bottom;
-      ty1 = borderValue + axisHalfWidth;
-      ty2 = ty1 + tl2;
-    } else if (axis === "y") {
-      if (position === "center") {
-        borderValue = alignBorderValue((chartArea.left + chartArea.right) / 2);
-      } else if (isObject(position)) {
-        const positionAxisID = Object.keys(position)[0];
-        const value = position[positionAxisID];
-        borderValue = alignBorderValue(this.chart.scales[positionAxisID].getPixelForValue(value));
-      }
-      tx1 = borderValue - axisHalfWidth;
-      tx2 = tx1 - tl2;
-      x1 = chartArea.left;
-      x2 = chartArea.right;
-    }
-    const limit = valueOrDefault(options.ticks.maxTicksLimit, ticksLength);
-    const step = Math.max(1, Math.ceil(ticksLength / limit));
-    for (i = 0; i < ticksLength; i += step) {
-      const context = this.getContext(i);
-      const optsAtIndex = grid.setContext(context);
-      const optsAtIndexBorder = border.setContext(context);
-      const lineWidth = optsAtIndex.lineWidth;
-      const lineColor = optsAtIndex.color;
-      const borderDash = optsAtIndexBorder.dash || [];
-      const borderDashOffset = optsAtIndexBorder.dashOffset;
-      const tickWidth = optsAtIndex.tickWidth;
-      const tickColor = optsAtIndex.tickColor;
-      const tickBorderDash = optsAtIndex.tickBorderDash || [];
-      const tickBorderDashOffset = optsAtIndex.tickBorderDashOffset;
-      lineValue = getPixelForGridLine(this, i, offset);
-      if (lineValue === void 0) {
-        continue;
-      }
-      alignedLineValue = _alignPixel(chart, lineValue, lineWidth);
-      if (isHorizontal) {
-        tx1 = tx2 = x1 = x2 = alignedLineValue;
-      } else {
-        ty1 = ty2 = y1 = y2 = alignedLineValue;
-      }
-      items.push({
-        tx1,
-        ty1,
-        tx2,
-        ty2,
-        x1,
-        y1,
-        x2,
-        y2,
-        width: lineWidth,
-        color: lineColor,
-        borderDash,
-        borderDashOffset,
-        tickWidth,
-        tickColor,
-        tickBorderDash,
-        tickBorderDashOffset
-      });
-    }
-    this._ticksLength = ticksLength;
-    this._borderValue = borderValue;
-    return items;
-  }
-  _computeLabelItems(chartArea) {
-    const axis = this.axis;
-    const options = this.options;
-    const { position, ticks: optionTicks } = options;
-    const isHorizontal = this.isHorizontal();
-    const ticks = this.ticks;
-    const { align, crossAlign, padding, mirror } = optionTicks;
-    const tl2 = getTickMarkLength(options.grid);
-    const tickAndPadding = tl2 + padding;
-    const hTickAndPadding = mirror ? -padding : tickAndPadding;
-    const rotation = -toRadians(this.labelRotation);
-    const items = [];
-    let i, ilen, tick, label, x2, y2, textAlign, pixel, font, lineHeight, lineCount, textOffset;
-    let textBaseline = "middle";
-    if (position === "top") {
-      y2 = this.bottom - hTickAndPadding;
-      textAlign = this._getXAxisLabelAlignment();
-    } else if (position === "bottom") {
-      y2 = this.top + hTickAndPadding;
-      textAlign = this._getXAxisLabelAlignment();
-    } else if (position === "left") {
-      const ret = this._getYAxisLabelAlignment(tl2);
-      textAlign = ret.textAlign;
-      x2 = ret.x;
-    } else if (position === "right") {
-      const ret = this._getYAxisLabelAlignment(tl2);
-      textAlign = ret.textAlign;
-      x2 = ret.x;
-    } else if (axis === "x") {
-      if (position === "center") {
-        y2 = (chartArea.top + chartArea.bottom) / 2 + tickAndPadding;
-      } else if (isObject(position)) {
-        const positionAxisID = Object.keys(position)[0];
-        const value = position[positionAxisID];
-        y2 = this.chart.scales[positionAxisID].getPixelForValue(value) + tickAndPadding;
-      }
-      textAlign = this._getXAxisLabelAlignment();
-    } else if (axis === "y") {
-      if (position === "center") {
-        x2 = (chartArea.left + chartArea.right) / 2 - tickAndPadding;
-      } else if (isObject(position)) {
-        const positionAxisID = Object.keys(position)[0];
-        const value = position[positionAxisID];
-        x2 = this.chart.scales[positionAxisID].getPixelForValue(value);
-      }
-      textAlign = this._getYAxisLabelAlignment(tl2).textAlign;
-    }
-    if (axis === "y") {
-      if (align === "start") {
-        textBaseline = "top";
-      } else if (align === "end") {
-        textBaseline = "bottom";
-      }
-    }
-    const labelSizes = this._getLabelSizes();
-    for (i = 0, ilen = ticks.length; i < ilen; ++i) {
-      tick = ticks[i];
-      label = tick.label;
-      const optsAtIndex = optionTicks.setContext(this.getContext(i));
-      pixel = this.getPixelForTick(i) + optionTicks.labelOffset;
-      font = this._resolveTickFontOptions(i);
-      lineHeight = font.lineHeight;
-      lineCount = isArray(label) ? label.length : 1;
-      const halfCount = lineCount / 2;
-      const color2 = optsAtIndex.color;
-      const strokeColor = optsAtIndex.textStrokeColor;
-      const strokeWidth = optsAtIndex.textStrokeWidth;
-      let tickTextAlign = textAlign;
-      if (isHorizontal) {
-        x2 = pixel;
-        if (textAlign === "inner") {
-          if (i === ilen - 1) {
-            tickTextAlign = !this.options.reverse ? "right" : "left";
-          } else if (i === 0) {
-            tickTextAlign = !this.options.reverse ? "left" : "right";
-          } else {
-            tickTextAlign = "center";
+      });
+      var require_svg_path_bounds = __commonJS({
+        "node_modules/svg-path-bounds/index.js"(exports, module2) {
+          var parse22 = require_parse_svg_path();
+          var abs = require_abs_svg_path();
+          var normalize = require_normalize_svg_path();
+          var isSvgPath = require_is_svg_path();
+          var assert2 = require_assert();
+          module2.exports = pathBounds;
+          function pathBounds(path) {
+            if (Array.isArray(path) && path.length === 1 && typeof path[0] === "string") path = path[0];
+            if (typeof path === "string") {
+              assert2(isSvgPath(path), "String is not an SVG path.");
+              path = parse22(path);
+            }
+            assert2(Array.isArray(path), "Argument should be a string or an array of path segments.");
+            path = abs(path);
+            path = normalize(path);
+            if (!path.length) return [0, 0, 0, 0];
+            var bounds = [Infinity, Infinity, -Infinity, -Infinity];
+            for (var i2 = 0, l2 = path.length; i2 < l2; i2++) {
+              var points = path[i2].slice(1);
+              for (var j2 = 0; j2 < points.length; j2 += 2) {
+                if (points[j2 + 0] < bounds[0]) bounds[0] = points[j2 + 0];
+                if (points[j2 + 1] < bounds[1]) bounds[1] = points[j2 + 1];
+                if (points[j2 + 0] > bounds[2]) bounds[2] = points[j2 + 0];
+                if (points[j2 + 1] > bounds[3]) bounds[3] = points[j2 + 1];
+              }
+            }
+            return bounds;
+          }
+        }
+      });
+      var require_normalize_svg_path2 = __commonJS({
+        "node_modules/normalize-svg-path/index.js"(exports, module2) {
+          var π = Math.PI;
+          var _120 = radians2(120);
+          module2.exports = normalize;
+          function normalize(path) {
+            var prev;
+            var result = [];
+            var bezierX = 0;
+            var bezierY = 0;
+            var startX = 0;
+            var startY = 0;
+            var quadX = null;
+            var quadY = null;
+            var x2 = 0;
+            var y2 = 0;
+            for (var i2 = 0, len2 = path.length; i2 < len2; i2++) {
+              var seg = path[i2];
+              var command = seg[0];
+              switch (command) {
+                case "M":
+                  startX = seg[1];
+                  startY = seg[2];
+                  break;
+                case "A":
+                  seg = arc(x2, y2, seg[1], seg[2], radians2(seg[3]), seg[4], seg[5], seg[6], seg[7]);
+                  seg.unshift("C");
+                  if (seg.length > 7) {
+                    result.push(seg.splice(0, 7));
+                    seg.unshift("C");
+                  }
+                  break;
+                case "S":
+                  var cx = x2;
+                  var cy = y2;
+                  if (prev == "C" || prev == "S") {
+                    cx += cx - bezierX;
+                    cy += cy - bezierY;
+                  }
+                  seg = ["C", cx, cy, seg[1], seg[2], seg[3], seg[4]];
+                  break;
+                case "T":
+                  if (prev == "Q" || prev == "T") {
+                    quadX = x2 * 2 - quadX;
+                    quadY = y2 * 2 - quadY;
+                  } else {
+                    quadX = x2;
+                    quadY = y2;
+                  }
+                  seg = quadratic(x2, y2, quadX, quadY, seg[1], seg[2]);
+                  break;
+                case "Q":
+                  quadX = seg[1];
+                  quadY = seg[2];
+                  seg = quadratic(x2, y2, seg[1], seg[2], seg[3], seg[4]);
+                  break;
+                case "L":
+                  seg = line(x2, y2, seg[1], seg[2]);
+                  break;
+                case "H":
+                  seg = line(x2, y2, seg[1], y2);
+                  break;
+                case "V":
+                  seg = line(x2, y2, x2, seg[1]);
+                  break;
+                case "Z":
+                  seg = line(x2, y2, startX, startY);
+                  break;
+              }
+              prev = command;
+              x2 = seg[seg.length - 2];
+              y2 = seg[seg.length - 1];
+              if (seg.length > 4) {
+                bezierX = seg[seg.length - 4];
+                bezierY = seg[seg.length - 3];
+              } else {
+                bezierX = x2;
+                bezierY = y2;
+              }
+              result.push(seg);
+            }
+            return result;
+          }
+          function line(x1, y1, x2, y2) {
+            return ["C", x1, y1, x2, y2, x2, y2];
           }
+          function quadratic(x1, y1, cx, cy, x2, y2) {
+            return [
+              "C",
+              x1 / 3 + 2 / 3 * cx,
+              y1 / 3 + 2 / 3 * cy,
+              x2 / 3 + 2 / 3 * cx,
+              y2 / 3 + 2 / 3 * cy,
+              x2,
+              y2
+            ];
+          }
+          function arc(x1, y1, rx, ry, angle2, large_arc_flag, sweep_flag, x2, y2, recursive) {
+            if (!recursive) {
+              var xy = rotate2(x1, y1, -angle2);
+              x1 = xy.x;
+              y1 = xy.y;
+              xy = rotate2(x2, y2, -angle2);
+              x2 = xy.x;
+              y2 = xy.y;
+              var x3 = (x1 - x2) / 2;
+              var y3 = (y1 - y2) / 2;
+              var h2 = x3 * x3 / (rx * rx) + y3 * y3 / (ry * ry);
+              if (h2 > 1) {
+                h2 = Math.sqrt(h2);
+                rx = h2 * rx;
+                ry = h2 * ry;
+              }
+              var rx2 = rx * rx;
+              var ry2 = ry * ry;
+              var k2 = (large_arc_flag == sweep_flag ? -1 : 1) * Math.sqrt(Math.abs((rx2 * ry2 - rx2 * y3 * y3 - ry2 * x3 * x3) / (rx2 * y3 * y3 + ry2 * x3 * x3)));
+              if (k2 == Infinity) k2 = 1;
+              var cx = k2 * rx * y3 / ry + (x1 + x2) / 2;
+              var cy = k2 * -ry * x3 / rx + (y1 + y2) / 2;
+              var f1 = Math.asin(((y1 - cy) / ry).toFixed(9));
+              var f2 = Math.asin(((y2 - cy) / ry).toFixed(9));
+              f1 = x1 < cx ? π - f1 : f1;
+              f2 = x2 < cx ? π - f2 : f2;
+              if (f1 < 0) f1 = π * 2 + f1;
+              if (f2 < 0) f2 = π * 2 + f2;
+              if (sweep_flag && f1 > f2) f1 = f1 - π * 2;
+              if (!sweep_flag && f2 > f1) f2 = f2 - π * 2;
+            } else {
+              f1 = recursive[0];
+              f2 = recursive[1];
+              cx = recursive[2];
+              cy = recursive[3];
+            }
+            if (Math.abs(f2 - f1) > _120) {
+              var f2old = f2;
+              var x2old = x2;
+              var y2old = y2;
+              f2 = f1 + _120 * (sweep_flag && f2 > f1 ? 1 : -1);
+              x2 = cx + rx * Math.cos(f2);
+              y2 = cy + ry * Math.sin(f2);
+              var res = arc(x2, y2, rx, ry, angle2, 0, sweep_flag, x2old, y2old, [f2, f2old, cx, cy]);
+            }
+            var t4 = Math.tan((f2 - f1) / 4);
+            var hx = 4 / 3 * rx * t4;
+            var hy = 4 / 3 * ry * t4;
+            var curve = [
+              2 * x1 - (x1 + hx * Math.sin(f1)),
+              2 * y1 - (y1 - hy * Math.cos(f1)),
+              x2 + hx * Math.sin(f2),
+              y2 - hy * Math.cos(f2),
+              x2,
+              y2
+            ];
+            if (recursive) return curve;
+            if (res) curve = curve.concat(res);
+            for (var i2 = 0; i2 < curve.length; ) {
+              var rot = rotate2(curve[i2], curve[i2 + 1], angle2);
+              curve[i2++] = rot.x;
+              curve[i2++] = rot.y;
+            }
+            return curve;
+          }
+          function rotate2(x2, y2, rad) {
+            return {
+              x: x2 * Math.cos(rad) - y2 * Math.sin(rad),
+              y: x2 * Math.sin(rad) + y2 * Math.cos(rad)
+            };
+          }
+          function radians2(degress) {
+            return degress * (π / 180);
+          }
+        }
+      });
+      var require_draw_svg_path = __commonJS({
+        "node_modules/draw-svg-path/index.js"(exports, module2) {
+          var abs = require_abs_svg_path();
+          var normalize = require_normalize_svg_path2();
+          var methods = {
+            "M": "moveTo",
+            "C": "bezierCurveTo"
+          };
+          module2.exports = function(context, segments) {
+            context.beginPath();
+            normalize(abs(segments)).forEach(
+              function(segment) {
+                var command = segment[0];
+                var args = segment.slice(1);
+                context[methods[command]].apply(context, args);
+              }
+            );
+            context.closePath();
+          };
         }
-        if (position === "top") {
-          if (crossAlign === "near" || rotation !== 0) {
-            textOffset = -lineCount * lineHeight + lineHeight / 2;
-          } else if (crossAlign === "center") {
-            textOffset = -labelSizes.highest.height / 2 - halfCount * lineHeight + lineHeight;
-          } else {
-            textOffset = -labelSizes.highest.height + lineHeight / 2;
+      });
+      var require_bitmap_sdf = __commonJS({
+        "node_modules/bitmap-sdf/index.js"(exports, module2) {
+          var clamp2 = require_clamp();
+          module2.exports = calcSDF;
+          var INF = 1e20;
+          function calcSDF(src, options) {
+            if (!options) options = {};
+            var cutoff = options.cutoff == null ? 0.25 : options.cutoff;
+            var radius = options.radius == null ? 8 : options.radius;
+            var channel = options.channel || 0;
+            var w2, h2, size, data, intData, stride, ctx2, canvas2, imgData, i2, l2;
+            if (ArrayBuffer.isView(src) || Array.isArray(src)) {
+              if (!options.width || !options.height) throw Error("For raw data width and height should be provided by options");
+              w2 = options.width, h2 = options.height;
+              data = src;
+              if (!options.stride) stride = Math.floor(src.length / w2 / h2);
+              else stride = options.stride;
+            } else {
+              if (window.HTMLCanvasElement && src instanceof window.HTMLCanvasElement) {
+                canvas2 = src;
+                ctx2 = canvas2.getContext("2d");
+                w2 = canvas2.width, h2 = canvas2.height;
+                imgData = ctx2.getImageData(0, 0, w2, h2);
+                data = imgData.data;
+                stride = 4;
+              } else if (window.CanvasRenderingContext2D && src instanceof window.CanvasRenderingContext2D) {
+                canvas2 = src.canvas;
+                ctx2 = src;
+                w2 = canvas2.width, h2 = canvas2.height;
+                imgData = ctx2.getImageData(0, 0, w2, h2);
+                data = imgData.data;
+                stride = 4;
+              } else if (window.ImageData && src instanceof window.ImageData) {
+                imgData = src;
+                w2 = src.width, h2 = src.height;
+                data = imgData.data;
+                stride = 4;
+              }
+            }
+            size = Math.max(w2, h2);
+            if (window.Uint8ClampedArray && data instanceof window.Uint8ClampedArray || window.Uint8Array && data instanceof window.Uint8Array) {
+              intData = data;
+              data = Array(w2 * h2);
+              for (i2 = 0, l2 = intData.length; i2 < l2; i2++) {
+                data[i2] = intData[i2 * stride + channel] / 255;
+              }
+            } else {
+              if (stride !== 1) throw Error("Raw data can have only 1 value per pixel");
+            }
+            var gridOuter = Array(w2 * h2);
+            var gridInner = Array(w2 * h2);
+            var f2 = Array(size);
+            var d2 = Array(size);
+            var z2 = Array(size + 1);
+            var v2 = Array(size);
+            for (i2 = 0, l2 = w2 * h2; i2 < l2; i2++) {
+              var a2 = data[i2];
+              gridOuter[i2] = a2 === 1 ? 0 : a2 === 0 ? INF : Math.pow(Math.max(0, 0.5 - a2), 2);
+              gridInner[i2] = a2 === 1 ? INF : a2 === 0 ? 0 : Math.pow(Math.max(0, a2 - 0.5), 2);
+            }
+            edt(gridOuter, w2, h2, f2, d2, v2, z2);
+            edt(gridInner, w2, h2, f2, d2, v2, z2);
+            var dist = window.Float32Array ? new Float32Array(w2 * h2) : new Array(w2 * h2);
+            for (i2 = 0, l2 = w2 * h2; i2 < l2; i2++) {
+              dist[i2] = clamp2(1 - ((gridOuter[i2] - gridInner[i2]) / radius + cutoff), 0, 1);
+            }
+            return dist;
           }
-        } else {
-          if (crossAlign === "near" || rotation !== 0) {
-            textOffset = lineHeight / 2;
-          } else if (crossAlign === "center") {
-            textOffset = labelSizes.highest.height / 2 - halfCount * lineHeight;
-          } else {
-            textOffset = labelSizes.highest.height - lineCount * lineHeight;
+          function edt(data, width, height, f2, d2, v2, z2) {
+            for (var x2 = 0; x2 < width; x2++) {
+              for (var y2 = 0; y2 < height; y2++) {
+                f2[y2] = data[y2 * width + x2];
+              }
+              edt1d(f2, d2, v2, z2, height);
+              for (y2 = 0; y2 < height; y2++) {
+                data[y2 * width + x2] = d2[y2];
+              }
+            }
+            for (y2 = 0; y2 < height; y2++) {
+              for (x2 = 0; x2 < width; x2++) {
+                f2[x2] = data[y2 * width + x2];
+              }
+              edt1d(f2, d2, v2, z2, width);
+              for (x2 = 0; x2 < width; x2++) {
+                data[y2 * width + x2] = Math.sqrt(d2[x2]);
+              }
+            }
           }
-        }
-        if (mirror) {
-          textOffset *= -1;
-        }
-        if (rotation !== 0 && !optsAtIndex.showLabelBackdrop) {
-          x2 += lineHeight / 2 * Math.sin(rotation);
-        }
-      } else {
-        y2 = pixel;
-        textOffset = (1 - lineCount) * lineHeight / 2;
-      }
-      let backdrop;
-      if (optsAtIndex.showLabelBackdrop) {
-        const labelPadding = toPadding(optsAtIndex.backdropPadding);
-        const height = labelSizes.heights[i];
-        const width = labelSizes.widths[i];
-        let top = textOffset - labelPadding.top;
-        let left = 0 - labelPadding.left;
-        switch (textBaseline) {
-          case "middle":
-            top -= height / 2;
-            break;
-          case "bottom":
-            top -= height;
-            break;
-        }
-        switch (textAlign) {
-          case "center":
-            left -= width / 2;
-            break;
-          case "right":
-            left -= width;
-            break;
-          case "inner":
-            if (i === ilen - 1) {
-              left -= width;
-            } else if (i > 0) {
-              left -= width / 2;
+          function edt1d(f2, d2, v2, z2, n2) {
+            v2[0] = 0;
+            z2[0] = -1e20;
+            z2[1] = 1e20;
+            for (var q2 = 1, k2 = 0; q2 < n2; q2++) {
+              var s2 = (f2[q2] + q2 * q2 - (f2[v2[k2]] + v2[k2] * v2[k2])) / (2 * q2 - 2 * v2[k2]);
+              while (s2 <= z2[k2]) {
+                k2--;
+                s2 = (f2[q2] + q2 * q2 - (f2[v2[k2]] + v2[k2] * v2[k2])) / (2 * q2 - 2 * v2[k2]);
+              }
+              k2++;
+              v2[k2] = q2;
+              z2[k2] = s2;
+              z2[k2 + 1] = 1e20;
+            }
+            for (q2 = 0, k2 = 0; q2 < n2; q2++) {
+              while (z2[k2 + 1] < q2) k2++;
+              d2[q2] = (q2 - v2[k2]) * (q2 - v2[k2]) + f2[v2[k2]];
             }
-            break;
-        }
-        backdrop = {
-          left,
-          top,
-          width: width + labelPadding.width,
-          height: height + labelPadding.height,
-          color: optsAtIndex.backdropColor
-        };
-      }
-      items.push({
-        label,
-        font,
-        textOffset,
-        options: {
-          rotation,
-          color: color2,
-          strokeColor,
-          strokeWidth,
-          textAlign: tickTextAlign,
-          textBaseline,
-          translation: [
-            x2,
-            y2
-          ],
-          backdrop
-        }
-      });
-    }
-    return items;
-  }
-  _getXAxisLabelAlignment() {
-    const { position, ticks } = this.options;
-    const rotation = -toRadians(this.labelRotation);
-    if (rotation) {
-      return position === "top" ? "left" : "right";
-    }
-    let align = "center";
-    if (ticks.align === "start") {
-      align = "left";
-    } else if (ticks.align === "end") {
-      align = "right";
-    } else if (ticks.align === "inner") {
-      align = "inner";
-    }
-    return align;
-  }
-  _getYAxisLabelAlignment(tl2) {
-    const { position, ticks: { crossAlign, mirror, padding } } = this.options;
-    const labelSizes = this._getLabelSizes();
-    const tickAndPadding = tl2 + padding;
-    const widest = labelSizes.widest.width;
-    let textAlign;
-    let x2;
-    if (position === "left") {
-      if (mirror) {
-        x2 = this.right + padding;
-        if (crossAlign === "near") {
-          textAlign = "left";
-        } else if (crossAlign === "center") {
-          textAlign = "center";
-          x2 += widest / 2;
-        } else {
-          textAlign = "right";
-          x2 += widest;
-        }
-      } else {
-        x2 = this.right - tickAndPadding;
-        if (crossAlign === "near") {
-          textAlign = "right";
-        } else if (crossAlign === "center") {
-          textAlign = "center";
-          x2 -= widest / 2;
-        } else {
-          textAlign = "left";
-          x2 = this.left;
-        }
-      }
-    } else if (position === "right") {
-      if (mirror) {
-        x2 = this.left + padding;
-        if (crossAlign === "near") {
-          textAlign = "right";
-        } else if (crossAlign === "center") {
-          textAlign = "center";
-          x2 -= widest / 2;
-        } else {
-          textAlign = "left";
-          x2 -= widest;
-        }
-      } else {
-        x2 = this.left + tickAndPadding;
-        if (crossAlign === "near") {
-          textAlign = "left";
-        } else if (crossAlign === "center") {
-          textAlign = "center";
-          x2 += widest / 2;
-        } else {
-          textAlign = "right";
-          x2 = this.right;
-        }
-      }
-    } else {
-      textAlign = "right";
-    }
-    return {
-      textAlign,
-      x: x2
-    };
-  }
-  _computeLabelArea() {
-    if (this.options.ticks.mirror) {
-      return;
-    }
-    const chart = this.chart;
-    const position = this.options.position;
-    if (position === "left" || position === "right") {
-      return {
-        top: 0,
-        left: this.left,
-        bottom: chart.height,
-        right: this.right
-      };
-    }
-    if (position === "top" || position === "bottom") {
-      return {
-        top: this.top,
-        left: 0,
-        bottom: this.bottom,
-        right: chart.width
-      };
-    }
-  }
-  drawBackground() {
-    const { ctx, options: { backgroundColor }, left, top, width, height } = this;
-    if (backgroundColor) {
-      ctx.save();
-      ctx.fillStyle = backgroundColor;
-      ctx.fillRect(left, top, width, height);
-      ctx.restore();
-    }
-  }
-  getLineWidthForValue(value) {
-    const grid = this.options.grid;
-    if (!this._isVisible() || !grid.display) {
-      return 0;
-    }
-    const ticks = this.ticks;
-    const index = ticks.findIndex((t2) => t2.value === value);
-    if (index >= 0) {
-      const opts = grid.setContext(this.getContext(index));
-      return opts.lineWidth;
-    }
-    return 0;
-  }
-  drawGrid(chartArea) {
-    const grid = this.options.grid;
-    const ctx = this.ctx;
-    const items = this._gridLineItems || (this._gridLineItems = this._computeGridLineItems(chartArea));
-    let i, ilen;
-    const drawLine = (p1, p2, style) => {
-      if (!style.width || !style.color) {
-        return;
-      }
-      ctx.save();
-      ctx.lineWidth = style.width;
-      ctx.strokeStyle = style.color;
-      ctx.setLineDash(style.borderDash || []);
-      ctx.lineDashOffset = style.borderDashOffset;
-      ctx.beginPath();
-      ctx.moveTo(p1.x, p1.y);
-      ctx.lineTo(p2.x, p2.y);
-      ctx.stroke();
-      ctx.restore();
-    };
-    if (grid.display) {
-      for (i = 0, ilen = items.length; i < ilen; ++i) {
-        const item = items[i];
-        if (grid.drawOnChartArea) {
-          drawLine({
-            x: item.x1,
-            y: item.y1
-          }, {
-            x: item.x2,
-            y: item.y2
-          }, item);
-        }
-        if (grid.drawTicks) {
-          drawLine({
-            x: item.tx1,
-            y: item.ty1
-          }, {
-            x: item.tx2,
-            y: item.ty2
-          }, {
-            color: item.tickColor,
-            width: item.tickWidth,
-            borderDash: item.tickBorderDash,
-            borderDashOffset: item.tickBorderDashOffset
-          });
-        }
-      }
-    }
-  }
-  drawBorder() {
-    const { chart, ctx, options: { border, grid } } = this;
-    const borderOpts = border.setContext(this.getContext());
-    const axisWidth = border.display ? borderOpts.width : 0;
-    if (!axisWidth) {
-      return;
-    }
-    const lastLineWidth = grid.setContext(this.getContext(0)).lineWidth;
-    const borderValue = this._borderValue;
-    let x1, x2, y1, y2;
-    if (this.isHorizontal()) {
-      x1 = _alignPixel(chart, this.left, axisWidth) - axisWidth / 2;
-      x2 = _alignPixel(chart, this.right, lastLineWidth) + lastLineWidth / 2;
-      y1 = y2 = borderValue;
-    } else {
-      y1 = _alignPixel(chart, this.top, axisWidth) - axisWidth / 2;
-      y2 = _alignPixel(chart, this.bottom, lastLineWidth) + lastLineWidth / 2;
-      x1 = x2 = borderValue;
-    }
-    ctx.save();
-    ctx.lineWidth = borderOpts.width;
-    ctx.strokeStyle = borderOpts.color;
-    ctx.beginPath();
-    ctx.moveTo(x1, y1);
-    ctx.lineTo(x2, y2);
-    ctx.stroke();
-    ctx.restore();
-  }
-  drawLabels(chartArea) {
-    const optionTicks = this.options.ticks;
-    if (!optionTicks.display) {
-      return;
-    }
-    const ctx = this.ctx;
-    const area = this._computeLabelArea();
-    if (area) {
-      clipArea(ctx, area);
-    }
-    const items = this.getLabelItems(chartArea);
-    for (const item of items) {
-      const renderTextOptions = item.options;
-      const tickFont = item.font;
-      const label = item.label;
-      const y2 = item.textOffset;
-      renderText(ctx, label, 0, y2, tickFont, renderTextOptions);
-    }
-    if (area) {
-      unclipArea(ctx);
-    }
-  }
-  drawTitle() {
-    const { ctx, options: { position, title, reverse } } = this;
-    if (!title.display) {
-      return;
-    }
-    const font = toFont(title.font);
-    const padding = toPadding(title.padding);
-    const align = title.align;
-    let offset = font.lineHeight / 2;
-    if (position === "bottom" || position === "center" || isObject(position)) {
-      offset += padding.bottom;
-      if (isArray(title.text)) {
-        offset += font.lineHeight * (title.text.length - 1);
-      }
-    } else {
-      offset += padding.top;
-    }
-    const { titleX, titleY, maxWidth, rotation } = titleArgs(this, offset, position, align);
-    renderText(ctx, title.text, 0, 0, font, {
-      color: title.color,
-      maxWidth,
-      rotation,
-      textAlign: titleAlign(align, position, reverse),
-      textBaseline: "middle",
-      translation: [
-        titleX,
-        titleY
-      ]
-    });
-  }
-  draw(chartArea) {
-    if (!this._isVisible()) {
-      return;
-    }
-    this.drawBackground();
-    this.drawGrid(chartArea);
-    this.drawBorder();
-    this.drawTitle();
-    this.drawLabels(chartArea);
-  }
-  _layers() {
-    const opts = this.options;
-    const tz = opts.ticks && opts.ticks.z || 0;
-    const gz = valueOrDefault(opts.grid && opts.grid.z, -1);
-    const bz = valueOrDefault(opts.border && opts.border.z, 0);
-    if (!this._isVisible() || this.draw !== Scale.prototype.draw) {
-      return [
-        {
-          z: tz,
-          draw: (chartArea) => {
-            this.draw(chartArea);
           }
         }
-      ];
-    }
-    return [
-      {
-        z: gz,
-        draw: (chartArea) => {
-          this.drawBackground();
-          this.drawGrid(chartArea);
-          this.drawTitle();
-        }
-      },
-      {
-        z: bz,
-        draw: () => {
-          this.drawBorder();
-        }
-      },
-      {
-        z: tz,
-        draw: (chartArea) => {
-          this.drawLabels(chartArea);
+      });
+      var require_svg_path_sdf = __commonJS({
+        "node_modules/svg-path-sdf/index.js"(exports, module2) {
+          var pathBounds = require_svg_path_bounds();
+          var parsePath = require_parse_svg_path();
+          var drawPath = require_draw_svg_path();
+          var isSvgPath = require_is_svg_path();
+          var bitmapSdf = require_bitmap_sdf();
+          var canvas2 = document.createElement("canvas");
+          var ctx2 = canvas2.getContext("2d");
+          module2.exports = pathSdf;
+          function pathSdf(path, options) {
+            if (!isSvgPath(path)) throw Error("Argument should be valid svg path string");
+            if (!options) options = {};
+            var w2, h2;
+            if (options.shape) {
+              w2 = options.shape[0];
+              h2 = options.shape[1];
+            } else {
+              w2 = canvas2.width = options.w || options.width || 200;
+              h2 = canvas2.height = options.h || options.height || 200;
+            }
+            var size = Math.min(w2, h2);
+            var stroke = options.stroke || 0;
+            var viewbox = options.viewbox || options.viewBox || pathBounds(path);
+            var scale2 = [w2 / (viewbox[2] - viewbox[0]), h2 / (viewbox[3] - viewbox[1])];
+            var maxScale = Math.min(scale2[0] || 0, scale2[1] || 0) / 2;
+            ctx2.fillStyle = "black";
+            ctx2.fillRect(0, 0, w2, h2);
+            ctx2.fillStyle = "white";
+            if (stroke) {
+              if (typeof stroke != "number") stroke = 1;
+              if (stroke > 0) {
+                ctx2.strokeStyle = "white";
+              } else {
+                ctx2.strokeStyle = "black";
+              }
+              ctx2.lineWidth = Math.abs(stroke);
+            }
+            ctx2.translate(w2 * 0.5, h2 * 0.5);
+            ctx2.scale(maxScale, maxScale);
+            if (isPath2DSupported()) {
+              var path2d = new Path2D(path);
+              ctx2.fill(path2d);
+              stroke && ctx2.stroke(path2d);
+            } else {
+              var segments = parsePath(path);
+              drawPath(ctx2, segments);
+              ctx2.fill();
+              stroke && ctx2.stroke();
+            }
+            ctx2.setTransform(1, 0, 0, 1, 0, 0);
+            var data = bitmapSdf(ctx2, {
+              cutoff: options.cutoff != null ? options.cutoff : 0.5,
+              radius: options.radius != null ? options.radius : size * 0.5
+            });
+            return data;
+          }
+          var path2DSupported;
+          function isPath2DSupported() {
+            if (path2DSupported != null) return path2DSupported;
+            var ctx22 = document.createElement("canvas").getContext("2d");
+            ctx22.canvas.width = ctx22.canvas.height = 1;
+            if (!window.Path2D) return path2DSupported = false;
+            var path = new Path2D("M0,0h1v1h-1v-1Z");
+            ctx22.fillStyle = "black";
+            ctx22.fill(path);
+            var idata = ctx22.getImageData(0, 0, 1, 1);
+            return path2DSupported = idata && idata.data && idata.data[3] === 255;
+          }
+        }
+      });
+      var require_convert10 = __commonJS({
+        "src/traces/scattergl/convert.js"(exports, module2) {
+          var isNumeric = require_fast_isnumeric();
+          var svgSdf = require_svg_path_sdf();
+          var rgba3 = require_color_normalize();
+          var Registry = require_registry();
+          var Lib = require_lib();
+          var isArrayOrTypedArray = Lib.isArrayOrTypedArray;
+          var Drawing = require_drawing();
+          var AxisIDs = require_axis_ids();
+          var formatColor = require_gl_format_color().formatColor;
+          var subTypes = require_subtypes();
+          var makeBubbleSizeFn = require_make_bubble_size_func();
+          var helpers = require_helpers16();
+          var constants = require_constants23();
+          var DESELECTDIM = require_interactions().DESELECTDIM;
+          var TEXTOFFSETSIGN = {
+            start: 1,
+            left: 1,
+            end: -1,
+            right: -1,
+            middle: 0,
+            center: 0,
+            bottom: 1,
+            top: -1
+          };
+          var appendArrayPointValue = require_helpers2().appendArrayPointValue;
+          function convertStyle(gd2, trace) {
+            var i2;
+            var opts = {
+              marker: void 0,
+              markerSel: void 0,
+              markerUnsel: void 0,
+              line: void 0,
+              fill: void 0,
+              errorX: void 0,
+              errorY: void 0,
+              text: void 0,
+              textSel: void 0,
+              textUnsel: void 0
+            };
+            var plotGlPixelRatio = gd2._context.plotGlPixelRatio;
+            if (trace.visible !== true) return opts;
+            if (subTypes.hasText(trace)) {
+              opts.text = convertTextStyle(gd2, trace);
+              opts.textSel = convertTextSelection(gd2, trace, trace.selected);
+              opts.textUnsel = convertTextSelection(gd2, trace, trace.unselected);
+            }
+            if (subTypes.hasMarkers(trace)) {
+              opts.marker = convertMarkerStyle(gd2, trace);
+              opts.markerSel = convertMarkerSelection(gd2, trace, trace.selected);
+              opts.markerUnsel = convertMarkerSelection(gd2, trace, trace.unselected);
+              if (!trace.unselected && isArrayOrTypedArray(trace.marker.opacity)) {
+                var mo = trace.marker.opacity;
+                opts.markerUnsel.opacity = new Array(mo.length);
+                for (i2 = 0; i2 < mo.length; i2++) {
+                  opts.markerUnsel.opacity[i2] = DESELECTDIM * mo[i2];
+                }
+              }
+            }
+            if (subTypes.hasLines(trace)) {
+              opts.line = {
+                overlay: true,
+                thickness: trace.line.width * plotGlPixelRatio,
+                color: trace.line.color,
+                opacity: trace.opacity
+              };
+              var dashes = (constants.DASHES[trace.line.dash] || [1]).slice();
+              for (i2 = 0; i2 < dashes.length; ++i2) {
+                dashes[i2] *= trace.line.width * plotGlPixelRatio;
+              }
+              opts.line.dashes = dashes;
+            }
+            if (trace.error_x && trace.error_x.visible) {
+              opts.errorX = convertErrorBarStyle(trace, trace.error_x, plotGlPixelRatio);
+            }
+            if (trace.error_y && trace.error_y.visible) {
+              opts.errorY = convertErrorBarStyle(trace, trace.error_y, plotGlPixelRatio);
+            }
+            if (!!trace.fill && trace.fill !== "none") {
+              opts.fill = {
+                closed: true,
+                fill: trace.fillcolor,
+                thickness: 0
+              };
+            }
+            return opts;
+          }
+          function convertTextStyle(gd2, trace) {
+            var fullLayout = gd2._fullLayout;
+            var count2 = trace._length;
+            var textfontIn = trace.textfont;
+            var textpositionIn = trace.textposition;
+            var textPos = isArrayOrTypedArray(textpositionIn) ? textpositionIn : [textpositionIn];
+            var tfc = textfontIn.color;
+            var tfs = textfontIn.size;
+            var tff = textfontIn.family;
+            var tfw = textfontIn.weight;
+            var tfy = textfontIn.style;
+            var tfv = textfontIn.variant;
+            var optsOut = {};
+            var i2;
+            var plotGlPixelRatio = gd2._context.plotGlPixelRatio;
+            var texttemplate = trace.texttemplate;
+            if (texttemplate) {
+              optsOut.text = [];
+              var d3locale = fullLayout._d3locale;
+              var isArray2 = Array.isArray(texttemplate);
+              var N2 = isArray2 ? Math.min(texttemplate.length, count2) : count2;
+              var txt = isArray2 ? function(i22) {
+                return texttemplate[i22];
+              } : function() {
+                return texttemplate;
+              };
+              for (i2 = 0; i2 < N2; i2++) {
+                var d2 = { i: i2 };
+                var labels = trace._module.formatLabels(d2, trace, fullLayout);
+                var pointValues = {};
+                appendArrayPointValue(pointValues, trace, i2);
+                optsOut.text.push(
+                  Lib.texttemplateString({
+                    data: [pointValues, d2, trace._meta],
+                    fallback: trace.texttemplatefallback,
+                    labels,
+                    locale: d3locale,
+                    template: txt(i2)
+                  })
+                );
+              }
+            } else {
+              if (isArrayOrTypedArray(trace.text) && trace.text.length < count2) {
+                optsOut.text = trace.text.slice();
+              } else {
+                optsOut.text = trace.text;
+              }
+            }
+            if (isArrayOrTypedArray(optsOut.text)) {
+              for (i2 = optsOut.text.length; i2 < count2; i2++) {
+                optsOut.text[i2] = "";
+              }
+            }
+            optsOut.opacity = trace.opacity;
+            optsOut.font = {};
+            optsOut.align = [];
+            optsOut.baseline = [];
+            for (i2 = 0; i2 < textPos.length; i2++) {
+              var tp = textPos[i2].split(/\s+/);
+              switch (tp[1]) {
+                case "left":
+                  optsOut.align.push("right");
+                  break;
+                case "right":
+                  optsOut.align.push("left");
+                  break;
+                default:
+                  optsOut.align.push(tp[1]);
+              }
+              switch (tp[0]) {
+                case "top":
+                  optsOut.baseline.push("bottom");
+                  break;
+                case "bottom":
+                  optsOut.baseline.push("top");
+                  break;
+                default:
+                  optsOut.baseline.push(tp[0]);
+              }
+            }
+            if (isArrayOrTypedArray(tfc)) {
+              optsOut.color = new Array(count2);
+              for (i2 = 0; i2 < count2; i2++) {
+                optsOut.color[i2] = tfc[i2];
+              }
+            } else {
+              optsOut.color = tfc;
+            }
+            if (isArrayOrTypedArray(tfs) || Array.isArray(tff) || isArrayOrTypedArray(tfw) || Array.isArray(tfy) || Array.isArray(tfv)) {
+              optsOut.font = new Array(count2);
+              for (i2 = 0; i2 < count2; i2++) {
+                var fonti = optsOut.font[i2] = {};
+                fonti.size = (Lib.isTypedArray(tfs) ? tfs[i2] : isArrayOrTypedArray(tfs) ? isNumeric(tfs[i2]) ? tfs[i2] : 0 : tfs) * plotGlPixelRatio;
+                fonti.family = Array.isArray(tff) ? tff[i2] : tff;
+                fonti.weight = weightFallBack(isArrayOrTypedArray(tfw) ? tfw[i2] : tfw);
+                fonti.style = Array.isArray(tfy) ? tfy[i2] : tfy;
+                fonti.variant = Array.isArray(tfv) ? tfv[i2] : tfv;
+              }
+            } else {
+              optsOut.font = {
+                size: tfs * plotGlPixelRatio,
+                family: tff,
+                weight: weightFallBack(tfw),
+                style: tfy,
+                variant: tfv
+              };
+            }
+            return optsOut;
+          }
+          function weightFallBack(w2) {
+            if (w2 <= 1e3) {
+              return w2 > 500 ? "bold" : "normal";
+            }
+            return w2;
+          }
+          function convertMarkerStyle(gd2, trace) {
+            var count2 = trace._length;
+            var optsIn = trace.marker;
+            var optsOut = {};
+            var i2;
+            var multiSymbol = isArrayOrTypedArray(optsIn.symbol);
+            var multiAngle = isArrayOrTypedArray(optsIn.angle);
+            var multiColor = isArrayOrTypedArray(optsIn.color);
+            var multiLineColor = isArrayOrTypedArray(optsIn.line.color);
+            var multiOpacity = isArrayOrTypedArray(optsIn.opacity);
+            var multiSize = isArrayOrTypedArray(optsIn.size);
+            var multiLineWidth = isArrayOrTypedArray(optsIn.line.width);
+            var isOpen;
+            if (!multiSymbol) isOpen = helpers.isOpenSymbol(optsIn.symbol);
+            if (multiSymbol || multiColor || multiLineColor || multiOpacity || multiAngle) {
+              optsOut.symbols = new Array(count2);
+              optsOut.angles = new Array(count2);
+              optsOut.colors = new Array(count2);
+              optsOut.borderColors = new Array(count2);
+              var symbols = optsIn.symbol;
+              var angles = optsIn.angle;
+              var colors = formatColor(optsIn, optsIn.opacity, count2);
+              var borderColors = formatColor(optsIn.line, optsIn.opacity, count2);
+              if (!isArrayOrTypedArray(borderColors[0])) {
+                var borderColor = borderColors;
+                borderColors = Array(count2);
+                for (i2 = 0; i2 < count2; i2++) {
+                  borderColors[i2] = borderColor;
+                }
+              }
+              if (!isArrayOrTypedArray(colors[0])) {
+                var color22 = colors;
+                colors = Array(count2);
+                for (i2 = 0; i2 < count2; i2++) {
+                  colors[i2] = color22;
+                }
+              }
+              if (!isArrayOrTypedArray(symbols)) {
+                var symbol = symbols;
+                symbols = Array(count2);
+                for (i2 = 0; i2 < count2; i2++) {
+                  symbols[i2] = symbol;
+                }
+              }
+              if (!isArrayOrTypedArray(angles)) {
+                var angle2 = angles;
+                angles = Array(count2);
+                for (i2 = 0; i2 < count2; i2++) {
+                  angles[i2] = angle2;
+                }
+              }
+              optsOut.symbols = symbols;
+              optsOut.angles = angles;
+              optsOut.colors = colors;
+              optsOut.borderColors = borderColors;
+              for (i2 = 0; i2 < count2; i2++) {
+                if (multiSymbol) {
+                  isOpen = helpers.isOpenSymbol(optsIn.symbol[i2]);
+                }
+                if (isOpen) {
+                  borderColors[i2] = colors[i2].slice();
+                  colors[i2] = colors[i2].slice();
+                  colors[i2][3] = 0;
+                }
+              }
+              optsOut.opacity = trace.opacity;
+              optsOut.markers = new Array(count2);
+              for (i2 = 0; i2 < count2; i2++) {
+                optsOut.markers[i2] = getSymbolSdf(
+                  {
+                    mx: optsOut.symbols[i2],
+                    ma: optsOut.angles[i2]
+                  },
+                  trace
+                );
+              }
+            } else {
+              if (isOpen) {
+                optsOut.color = rgba3(optsIn.color, "uint8");
+                optsOut.color[3] = 0;
+                optsOut.borderColor = rgba3(optsIn.color, "uint8");
+              } else {
+                optsOut.color = rgba3(optsIn.color, "uint8");
+                optsOut.borderColor = rgba3(optsIn.line.color, "uint8");
+              }
+              optsOut.opacity = trace.opacity * optsIn.opacity;
+              optsOut.marker = getSymbolSdf(
+                {
+                  mx: optsIn.symbol,
+                  ma: optsIn.angle
+                },
+                trace
+              );
+            }
+            var sizeFactor = 1;
+            var markerSizeFunc = makeBubbleSizeFn(trace, sizeFactor);
+            var s2;
+            if (multiSize || multiLineWidth) {
+              var sizes = optsOut.sizes = new Array(count2);
+              var borderSizes = optsOut.borderSizes = new Array(count2);
+              var sizeTotal = 0;
+              var sizeAvg;
+              if (multiSize) {
+                for (i2 = 0; i2 < count2; i2++) {
+                  sizes[i2] = markerSizeFunc(optsIn.size[i2]);
+                  sizeTotal += sizes[i2];
+                }
+                sizeAvg = sizeTotal / count2;
+              } else {
+                s2 = markerSizeFunc(optsIn.size);
+                for (i2 = 0; i2 < count2; i2++) {
+                  sizes[i2] = s2;
+                }
+              }
+              if (multiLineWidth) {
+                for (i2 = 0; i2 < count2; i2++) {
+                  borderSizes[i2] = optsIn.line.width[i2];
+                }
+              } else {
+                s2 = optsIn.line.width;
+                for (i2 = 0; i2 < count2; i2++) {
+                  borderSizes[i2] = s2;
+                }
+              }
+              optsOut.sizeAvg = sizeAvg;
+            } else {
+              optsOut.size = markerSizeFunc(optsIn && optsIn.size || 10);
+              optsOut.borderSizes = markerSizeFunc(optsIn.line.width);
+            }
+            return optsOut;
+          }
+          function convertMarkerSelection(gd2, trace, target) {
+            var optsIn = trace.marker;
+            var optsOut = {};
+            if (!target) return optsOut;
+            if (target.marker && target.marker.symbol) {
+              optsOut = convertMarkerStyle(gd2, Lib.extendFlat({}, optsIn, target.marker));
+            } else if (target.marker) {
+              if (target.marker.size) optsOut.size = target.marker.size;
+              if (target.marker.color) optsOut.colors = target.marker.color;
+              if (target.marker.opacity !== void 0) optsOut.opacity = target.marker.opacity;
+            }
+            return optsOut;
+          }
+          function convertTextSelection(gd2, trace, target) {
+            var optsOut = {};
+            if (!target) return optsOut;
+            if (target.textfont) {
+              var optsIn = {
+                opacity: 1,
+                text: trace.text,
+                texttemplate: trace.texttemplate,
+                textposition: trace.textposition,
+                textfont: Lib.extendFlat({}, trace.textfont)
+              };
+              if (target.textfont) {
+                Lib.extendFlat(optsIn.textfont, target.textfont);
+              }
+              optsOut = convertTextStyle(gd2, optsIn);
+            }
+            return optsOut;
+          }
+          function convertErrorBarStyle(trace, target, plotGlPixelRatio) {
+            var optsOut = {
+              capSize: target.width * 2 * plotGlPixelRatio,
+              lineWidth: target.thickness * plotGlPixelRatio,
+              color: target.color
+            };
+            if (target.copy_ystyle) {
+              optsOut = trace.error_y;
+            }
+            return optsOut;
+          }
+          var SYMBOL_SDF_SIZE = constants.SYMBOL_SDF_SIZE;
+          var SYMBOL_SIZE = constants.SYMBOL_SIZE;
+          var SYMBOL_STROKE = constants.SYMBOL_STROKE;
+          var SYMBOL_SDF = {};
+          var SYMBOL_SVG_CIRCLE = Drawing.symbolFuncs[0](SYMBOL_SIZE * 0.05);
+          function getSymbolSdf(d2, trace) {
+            var symbol = d2.mx;
+            if (symbol === "circle") return null;
+            var symbolPath, symbolSdf;
+            var symbolNumber = Drawing.symbolNumber(symbol);
+            var symbolFunc = Drawing.symbolFuncs[symbolNumber % 100];
+            var symbolNoDot = !!Drawing.symbolNoDot[symbolNumber % 100];
+            var symbolNoFill = !!Drawing.symbolNoFill[symbolNumber % 100];
+            var isDot = helpers.isDotSymbol(symbol);
+            if (d2.ma) symbol += "_" + d2.ma;
+            if (SYMBOL_SDF[symbol]) return SYMBOL_SDF[symbol];
+            var angle2 = Drawing.getMarkerAngle(d2, trace);
+            if (isDot && !symbolNoDot) {
+              symbolPath = symbolFunc(SYMBOL_SIZE * 1.1, angle2) + SYMBOL_SVG_CIRCLE;
+            } else {
+              symbolPath = symbolFunc(SYMBOL_SIZE, angle2);
+            }
+            symbolSdf = svgSdf(symbolPath, {
+              w: SYMBOL_SDF_SIZE,
+              h: SYMBOL_SDF_SIZE,
+              viewBox: [-SYMBOL_SIZE, -SYMBOL_SIZE, SYMBOL_SIZE, SYMBOL_SIZE],
+              stroke: symbolNoFill ? SYMBOL_STROKE : -SYMBOL_STROKE
+            });
+            SYMBOL_SDF[symbol] = symbolSdf;
+            return symbolSdf || null;
+          }
+          function convertLinePositions(gd2, trace, positions) {
+            var len2 = positions.length;
+            var count2 = len2 / 2;
+            var linePositions;
+            var i2;
+            if (subTypes.hasLines(trace) && count2) {
+              if (trace.line.shape === "hv") {
+                linePositions = [];
+                for (i2 = 0; i2 < count2 - 1; i2++) {
+                  if (isNaN(positions[i2 * 2]) || isNaN(positions[i2 * 2 + 1])) {
+                    linePositions.push(NaN, NaN, NaN, NaN);
+                  } else {
+                    linePositions.push(positions[i2 * 2], positions[i2 * 2 + 1]);
+                    if (!isNaN(positions[i2 * 2 + 2]) && !isNaN(positions[i2 * 2 + 3])) {
+                      linePositions.push(positions[i2 * 2 + 2], positions[i2 * 2 + 1]);
+                    } else {
+                      linePositions.push(NaN, NaN);
+                    }
+                  }
+                }
+                linePositions.push(positions[len2 - 2], positions[len2 - 1]);
+              } else if (trace.line.shape === "hvh") {
+                linePositions = [];
+                for (i2 = 0; i2 < count2 - 1; i2++) {
+                  if (isNaN(positions[i2 * 2]) || isNaN(positions[i2 * 2 + 1]) || isNaN(positions[i2 * 2 + 2]) || isNaN(positions[i2 * 2 + 3])) {
+                    if (!isNaN(positions[i2 * 2]) && !isNaN(positions[i2 * 2 + 1])) {
+                      linePositions.push(positions[i2 * 2], positions[i2 * 2 + 1]);
+                    } else {
+                      linePositions.push(NaN, NaN);
+                    }
+                    linePositions.push(NaN, NaN);
+                  } else {
+                    var midPtX = (positions[i2 * 2] + positions[i2 * 2 + 2]) / 2;
+                    linePositions.push(
+                      positions[i2 * 2],
+                      positions[i2 * 2 + 1],
+                      midPtX,
+                      positions[i2 * 2 + 1],
+                      midPtX,
+                      positions[i2 * 2 + 3]
+                    );
+                  }
+                }
+                linePositions.push(positions[len2 - 2], positions[len2 - 1]);
+              } else if (trace.line.shape === "vhv") {
+                linePositions = [];
+                for (i2 = 0; i2 < count2 - 1; i2++) {
+                  if (isNaN(positions[i2 * 2]) || isNaN(positions[i2 * 2 + 1]) || isNaN(positions[i2 * 2 + 2]) || isNaN(positions[i2 * 2 + 3])) {
+                    if (!isNaN(positions[i2 * 2]) && !isNaN(positions[i2 * 2 + 1])) {
+                      linePositions.push(positions[i2 * 2], positions[i2 * 2 + 1]);
+                    } else {
+                      linePositions.push(NaN, NaN);
+                    }
+                    linePositions.push(NaN, NaN);
+                  } else {
+                    var midPtY = (positions[i2 * 2 + 1] + positions[i2 * 2 + 3]) / 2;
+                    linePositions.push(
+                      positions[i2 * 2],
+                      positions[i2 * 2 + 1],
+                      positions[i2 * 2],
+                      midPtY,
+                      positions[i2 * 2 + 2],
+                      midPtY
+                    );
+                  }
+                }
+                linePositions.push(positions[len2 - 2], positions[len2 - 1]);
+              } else if (trace.line.shape === "vh") {
+                linePositions = [];
+                for (i2 = 0; i2 < count2 - 1; i2++) {
+                  if (isNaN(positions[i2 * 2]) || isNaN(positions[i2 * 2 + 1])) {
+                    linePositions.push(NaN, NaN, NaN, NaN);
+                  } else {
+                    linePositions.push(positions[i2 * 2], positions[i2 * 2 + 1]);
+                    if (!isNaN(positions[i2 * 2 + 2]) && !isNaN(positions[i2 * 2 + 3])) {
+                      linePositions.push(positions[i2 * 2], positions[i2 * 2 + 3]);
+                    } else {
+                      linePositions.push(NaN, NaN);
+                    }
+                  }
+                }
+                linePositions.push(positions[len2 - 2], positions[len2 - 1]);
+              } else {
+                linePositions = positions;
+              }
+            }
+            var hasNaN = false;
+            for (i2 = 0; i2 < linePositions.length; i2++) {
+              if (isNaN(linePositions[i2])) {
+                hasNaN = true;
+                break;
+              }
+            }
+            var join = hasNaN || linePositions.length > constants.TOO_MANY_POINTS ? "rect" : subTypes.hasMarkers(trace) ? "rect" : "round";
+            if (hasNaN && trace.connectgaps) {
+              var lastX = linePositions[0];
+              var lastY = linePositions[1];
+              for (i2 = 0; i2 < linePositions.length; i2 += 2) {
+                if (isNaN(linePositions[i2]) || isNaN(linePositions[i2 + 1])) {
+                  linePositions[i2] = lastX;
+                  linePositions[i2 + 1] = lastY;
+                } else {
+                  lastX = linePositions[i2];
+                  lastY = linePositions[i2 + 1];
+                }
+              }
+            }
+            return {
+              join,
+              positions: linePositions
+            };
+          }
+          function convertErrorBarPositions(gd2, trace, positions, x2, y2) {
+            var makeComputeError = Registry.getComponentMethod("errorbars", "makeComputeError");
+            var xa = AxisIDs.getFromId(gd2, trace.xaxis, "x");
+            var ya2 = AxisIDs.getFromId(gd2, trace.yaxis, "y");
+            var count2 = positions.length / 2;
+            var out = {};
+            function convertOneAxis(coords, ax) {
+              var axLetter = ax._id.charAt(0);
+              var opts = trace["error_" + axLetter];
+              if (opts && opts.visible && (ax.type === "linear" || ax.type === "log")) {
+                var computeError = makeComputeError(opts);
+                var pOffset = { x: 0, y: 1 }[axLetter];
+                var eOffset = { x: [0, 1, 2, 3], y: [2, 3, 0, 1] }[axLetter];
+                var errors = new Float64Array(4 * count2);
+                var minShoe = Infinity;
+                var maxHat = -Infinity;
+                for (var i2 = 0, j2 = 0; i2 < count2; i2++, j2 += 4) {
+                  var dc2 = coords[i2];
+                  if (isNumeric(dc2)) {
+                    var dl2 = positions[i2 * 2 + pOffset];
+                    var vals = computeError(dc2, i2);
+                    var lv = vals[0];
+                    var hv = vals[1];
+                    if (isNumeric(lv) && isNumeric(hv)) {
+                      var shoe = dc2 - lv;
+                      var hat = dc2 + hv;
+                      errors[j2 + eOffset[0]] = dl2 - ax.c2l(shoe);
+                      errors[j2 + eOffset[1]] = ax.c2l(hat) - dl2;
+                      errors[j2 + eOffset[2]] = 0;
+                      errors[j2 + eOffset[3]] = 0;
+                      minShoe = Math.min(minShoe, dc2 - lv);
+                      maxHat = Math.max(maxHat, dc2 + hv);
+                    }
+                  }
+                }
+                out[axLetter] = {
+                  positions,
+                  errors,
+                  _bnds: [minShoe, maxHat]
+                };
+              }
+            }
+            convertOneAxis(x2, xa);
+            convertOneAxis(y2, ya2);
+            return out;
+          }
+          function convertTextPosition(gd2, trace, textOpts, markerOpts) {
+            var count2 = trace._length;
+            var out = {};
+            var i2;
+            if (subTypes.hasMarkers(trace)) {
+              var fontOpts = textOpts.font;
+              var align = textOpts.align;
+              var baseline = textOpts.baseline;
+              out.offset = new Array(count2);
+              for (i2 = 0; i2 < count2; i2++) {
+                var ms = markerOpts.sizes ? markerOpts.sizes[i2] : markerOpts.size;
+                var fs2 = isArrayOrTypedArray(fontOpts) ? fontOpts[i2].size : fontOpts.size;
+                var a2 = isArrayOrTypedArray(align) ? align.length > 1 ? align[i2] : align[0] : align;
+                var b2 = isArrayOrTypedArray(baseline) ? baseline.length > 1 ? baseline[i2] : baseline[0] : baseline;
+                var hSign = TEXTOFFSETSIGN[a2];
+                var vSign = TEXTOFFSETSIGN[b2];
+                var xPad = ms ? ms / 0.8 + 1 : 0;
+                var yPad = -vSign * xPad - vSign * 0.5;
+                out.offset[i2] = [hSign * xPad / fs2, yPad / fs2];
+              }
+            }
+            return out;
+          }
+          module2.exports = {
+            style: convertStyle,
+            markerStyle: convertMarkerStyle,
+            markerSelection: convertMarkerSelection,
+            linePositions: convertLinePositions,
+            errorBarPositions: convertErrorBarPositions,
+            textPosition: convertTextPosition
+          };
         }
-      }
-    ];
-  }
-  getMatchingVisibleMetas(type) {
-    const metas = this.chart.getSortedVisibleDatasetMetas();
-    const axisID = this.axis + "AxisID";
-    const result = [];
-    let i, ilen;
-    for (i = 0, ilen = metas.length; i < ilen; ++i) {
-      const meta = metas[i];
-      if (meta[axisID] === this.id && (!type || meta.type === type)) {
-        result.push(meta);
-      }
-    }
-    return result;
-  }
-  _resolveTickFontOptions(index) {
-    const opts = this.options.ticks.setContext(this.getContext(index));
-    return toFont(opts.font);
-  }
-  _maxDigits() {
-    const fontSize = this._resolveTickFontOptions(0).lineHeight;
-    return (this.isHorizontal() ? this.width : this.height) / fontSize;
-  }
-}
-class TypedRegistry {
-  constructor(type, scope, override) {
-    this.type = type;
-    this.scope = scope;
-    this.override = override;
-    this.items = /* @__PURE__ */ Object.create(null);
-  }
-  isForType(type) {
-    return Object.prototype.isPrototypeOf.call(this.type.prototype, type.prototype);
-  }
-  register(item) {
-    const proto = Object.getPrototypeOf(item);
-    let parentScope;
-    if (isIChartComponent(proto)) {
-      parentScope = this.register(proto);
-    }
-    const items = this.items;
-    const id2 = item.id;
-    const scope = this.scope + "." + id2;
-    if (!id2) {
-      throw new Error("class does not have id: " + item);
-    }
-    if (id2 in items) {
-      return scope;
-    }
-    items[id2] = item;
-    registerDefaults(item, scope, parentScope);
-    if (this.override) {
-      defaults.override(item.id, item.overrides);
-    }
-    return scope;
-  }
-  get(id2) {
-    return this.items[id2];
-  }
-  unregister(item) {
-    const items = this.items;
-    const id2 = item.id;
-    const scope = this.scope;
-    if (id2 in items) {
-      delete items[id2];
-    }
-    if (scope && id2 in defaults[scope]) {
-      delete defaults[scope][id2];
-      if (this.override) {
-        delete overrides[id2];
-      }
-    }
-  }
-}
-function registerDefaults(item, scope, parentScope) {
-  const itemDefaults = merge(/* @__PURE__ */ Object.create(null), [
-    parentScope ? defaults.get(parentScope) : {},
-    defaults.get(scope),
-    item.defaults
-  ]);
-  defaults.set(scope, itemDefaults);
-  if (item.defaultRoutes) {
-    routeDefaults(scope, item.defaultRoutes);
-  }
-  if (item.descriptors) {
-    defaults.describe(scope, item.descriptors);
-  }
-}
-function routeDefaults(scope, routes) {
-  Object.keys(routes).forEach((property) => {
-    const propertyParts = property.split(".");
-    const sourceName = propertyParts.pop();
-    const sourceScope = [
-      scope
-    ].concat(propertyParts).join(".");
-    const parts = routes[property].split(".");
-    const targetName = parts.pop();
-    const targetScope = parts.join(".");
-    defaults.route(sourceScope, sourceName, targetScope, targetName);
-  });
-}
-function isIChartComponent(proto) {
-  return "id" in proto && "defaults" in proto;
-}
-class Registry {
-  constructor() {
-    this.controllers = new TypedRegistry(DatasetController, "datasets", true);
-    this.elements = new TypedRegistry(Element$1, "elements");
-    this.plugins = new TypedRegistry(Object, "plugins");
-    this.scales = new TypedRegistry(Scale, "scales");
-    this._typedRegistries = [
-      this.controllers,
-      this.scales,
-      this.elements
-    ];
-  }
-  add(...args) {
-    this._each("register", args);
-  }
-  remove(...args) {
-    this._each("unregister", args);
-  }
-  addControllers(...args) {
-    this._each("register", args, this.controllers);
-  }
-  addElements(...args) {
-    this._each("register", args, this.elements);
-  }
-  addPlugins(...args) {
-    this._each("register", args, this.plugins);
-  }
-  addScales(...args) {
-    this._each("register", args, this.scales);
-  }
-  getController(id2) {
-    return this._get(id2, this.controllers, "controller");
-  }
-  getElement(id2) {
-    return this._get(id2, this.elements, "element");
-  }
-  getPlugin(id2) {
-    return this._get(id2, this.plugins, "plugin");
-  }
-  getScale(id2) {
-    return this._get(id2, this.scales, "scale");
-  }
-  removeControllers(...args) {
-    this._each("unregister", args, this.controllers);
-  }
-  removeElements(...args) {
-    this._each("unregister", args, this.elements);
-  }
-  removePlugins(...args) {
-    this._each("unregister", args, this.plugins);
-  }
-  removeScales(...args) {
-    this._each("unregister", args, this.scales);
-  }
-  _each(method, args, typedRegistry) {
-    [
-      ...args
-    ].forEach((arg) => {
-      const reg = typedRegistry || this._getRegistryForType(arg);
-      if (typedRegistry || reg.isForType(arg) || reg === this.plugins && arg.id) {
-        this._exec(method, reg, arg);
-      } else {
-        each(arg, (item) => {
-          const itemReg = typedRegistry || this._getRegistryForType(item);
-          this._exec(method, itemReg, item);
-        });
-      }
-    });
-  }
-  _exec(method, registry2, component) {
-    const camelMethod = _capitalize(method);
-    callback(component["before" + camelMethod], [], component);
-    registry2[method](component);
-    callback(component["after" + camelMethod], [], component);
-  }
-  _getRegistryForType(type) {
-    for (let i = 0; i < this._typedRegistries.length; i++) {
-      const reg = this._typedRegistries[i];
-      if (reg.isForType(type)) {
-        return reg;
-      }
-    }
-    return this.plugins;
-  }
-  _get(id2, typedRegistry, type) {
-    const item = typedRegistry.get(id2);
-    if (item === void 0) {
-      throw new Error('"' + id2 + '" is not a registered ' + type + ".");
-    }
-    return item;
-  }
-}
-var registry = /* @__PURE__ */ new Registry();
-class PluginService {
-  constructor() {
-    this._init = [];
-  }
-  notify(chart, hook, args, filter) {
-    if (hook === "beforeInit") {
-      this._init = this._createDescriptors(chart, true);
-      this._notify(this._init, chart, "install");
-    }
-    const descriptors2 = filter ? this._descriptors(chart).filter(filter) : this._descriptors(chart);
-    const result = this._notify(descriptors2, chart, hook, args);
-    if (hook === "afterDestroy") {
-      this._notify(descriptors2, chart, "stop");
-      this._notify(this._init, chart, "uninstall");
-    }
-    return result;
-  }
-  _notify(descriptors2, chart, hook, args) {
-    args = args || {};
-    for (const descriptor of descriptors2) {
-      const plugin = descriptor.plugin;
-      const method = plugin[hook];
-      const params = [
-        chart,
-        args,
-        descriptor.options
-      ];
-      if (callback(method, params, plugin) === false && args.cancelable) {
-        return false;
-      }
-    }
-    return true;
-  }
-  invalidate() {
-    if (!isNullOrUndef(this._cache)) {
-      this._oldCache = this._cache;
-      this._cache = void 0;
-    }
-  }
-  _descriptors(chart) {
-    if (this._cache) {
-      return this._cache;
-    }
-    const descriptors2 = this._cache = this._createDescriptors(chart);
-    this._notifyStateChanges(chart);
-    return descriptors2;
-  }
-  _createDescriptors(chart, all) {
-    const config = chart && chart.config;
-    const options = valueOrDefault(config.options && config.options.plugins, {});
-    const plugins = allPlugins(config);
-    return options === false && !all ? [] : createDescriptors(chart, plugins, options, all);
-  }
-  _notifyStateChanges(chart) {
-    const previousDescriptors = this._oldCache || [];
-    const descriptors2 = this._cache;
-    const diff = (a, b) => a.filter((x2) => !b.some((y2) => x2.plugin.id === y2.plugin.id));
-    this._notify(diff(previousDescriptors, descriptors2), chart, "stop");
-    this._notify(diff(descriptors2, previousDescriptors), chart, "start");
-  }
-}
-function allPlugins(config) {
-  const localIds = {};
-  const plugins = [];
-  const keys = Object.keys(registry.plugins.items);
-  for (let i = 0; i < keys.length; i++) {
-    plugins.push(registry.getPlugin(keys[i]));
-  }
-  const local = config.plugins || [];
-  for (let i = 0; i < local.length; i++) {
-    const plugin = local[i];
-    if (plugins.indexOf(plugin) === -1) {
-      plugins.push(plugin);
-      localIds[plugin.id] = true;
-    }
-  }
-  return {
-    plugins,
-    localIds
-  };
-}
-function getOpts(options, all) {
-  if (!all && options === false) {
-    return null;
-  }
-  if (options === true) {
-    return {};
-  }
-  return options;
-}
-function createDescriptors(chart, { plugins, localIds }, options, all) {
-  const result = [];
-  const context = chart.getContext();
-  for (const plugin of plugins) {
-    const id2 = plugin.id;
-    const opts = getOpts(options[id2], all);
-    if (opts === null) {
-      continue;
-    }
-    result.push({
-      plugin,
-      options: pluginOpts(chart.config, {
-        plugin,
-        local: localIds[id2]
-      }, opts, context)
-    });
-  }
-  return result;
-}
-function pluginOpts(config, { plugin, local }, opts, context) {
-  const keys = config.pluginScopeKeys(plugin);
-  const scopes = config.getOptionScopes(opts, keys);
-  if (local && plugin.defaults) {
-    scopes.push(plugin.defaults);
-  }
-  return config.createResolver(scopes, context, [
-    ""
-  ], {
-    scriptable: false,
-    indexable: false,
-    allKeys: true
-  });
-}
-function getIndexAxis(type, options) {
-  const datasetDefaults = defaults.datasets[type] || {};
-  const datasetOptions = (options.datasets || {})[type] || {};
-  return datasetOptions.indexAxis || options.indexAxis || datasetDefaults.indexAxis || "x";
-}
-function getAxisFromDefaultScaleID(id2, indexAxis) {
-  let axis = id2;
-  if (id2 === "_index_") {
-    axis = indexAxis;
-  } else if (id2 === "_value_") {
-    axis = indexAxis === "x" ? "y" : "x";
-  }
-  return axis;
-}
-function getDefaultScaleIDFromAxis(axis, indexAxis) {
-  return axis === indexAxis ? "_index_" : "_value_";
-}
-function idMatchesAxis(id2) {
-  if (id2 === "x" || id2 === "y" || id2 === "r") {
-    return id2;
-  }
-}
-function axisFromPosition(position) {
-  if (position === "top" || position === "bottom") {
-    return "x";
-  }
-  if (position === "left" || position === "right") {
-    return "y";
-  }
-}
-function determineAxis(id2, ...scaleOptions) {
-  if (idMatchesAxis(id2)) {
-    return id2;
-  }
-  for (const opts of scaleOptions) {
-    const axis = opts.axis || axisFromPosition(opts.position) || id2.length > 1 && idMatchesAxis(id2[0].toLowerCase());
-    if (axis) {
-      return axis;
-    }
-  }
-  throw new Error(`Cannot determine type of '${id2}' axis. Please provide 'axis' or 'position' option.`);
-}
-function getAxisFromDataset(id2, axis, dataset) {
-  if (dataset[axis + "AxisID"] === id2) {
-    return {
-      axis
-    };
-  }
-}
-function retrieveAxisFromDatasets(id2, config) {
-  if (config.data && config.data.datasets) {
-    const boundDs = config.data.datasets.filter((d) => d.xAxisID === id2 || d.yAxisID === id2);
-    if (boundDs.length) {
-      return getAxisFromDataset(id2, "x", boundDs[0]) || getAxisFromDataset(id2, "y", boundDs[0]);
-    }
-  }
-  return {};
-}
-function mergeScaleConfig(config, options) {
-  const chartDefaults = overrides[config.type] || {
-    scales: {}
-  };
-  const configScales = options.scales || {};
-  const chartIndexAxis = getIndexAxis(config.type, options);
-  const scales = /* @__PURE__ */ Object.create(null);
-  Object.keys(configScales).forEach((id2) => {
-    const scaleConf = configScales[id2];
-    if (!isObject(scaleConf)) {
-      return console.error(`Invalid scale configuration for scale: ${id2}`);
-    }
-    if (scaleConf._proxy) {
-      return console.warn(`Ignoring resolver passed as options for scale: ${id2}`);
-    }
-    const axis = determineAxis(id2, scaleConf, retrieveAxisFromDatasets(id2, config), defaults.scales[scaleConf.type]);
-    const defaultId = getDefaultScaleIDFromAxis(axis, chartIndexAxis);
-    const defaultScaleOptions = chartDefaults.scales || {};
-    scales[id2] = mergeIf(/* @__PURE__ */ Object.create(null), [
-      {
-        axis
-      },
-      scaleConf,
-      defaultScaleOptions[axis],
-      defaultScaleOptions[defaultId]
-    ]);
-  });
-  config.data.datasets.forEach((dataset) => {
-    const type = dataset.type || config.type;
-    const indexAxis = dataset.indexAxis || getIndexAxis(type, options);
-    const datasetDefaults = overrides[type] || {};
-    const defaultScaleOptions = datasetDefaults.scales || {};
-    Object.keys(defaultScaleOptions).forEach((defaultID) => {
-      const axis = getAxisFromDefaultScaleID(defaultID, indexAxis);
-      const id2 = dataset[axis + "AxisID"] || axis;
-      scales[id2] = scales[id2] || /* @__PURE__ */ Object.create(null);
-      mergeIf(scales[id2], [
-        {
-          axis
-        },
-        configScales[id2],
-        defaultScaleOptions[defaultID]
-      ]);
-    });
-  });
-  Object.keys(scales).forEach((key) => {
-    const scale = scales[key];
-    mergeIf(scale, [
-      defaults.scales[scale.type],
-      defaults.scale
-    ]);
-  });
-  return scales;
-}
-function initOptions(config) {
-  const options = config.options || (config.options = {});
-  options.plugins = valueOrDefault(options.plugins, {});
-  options.scales = mergeScaleConfig(config, options);
-}
-function initData(data) {
-  data = data || {};
-  data.datasets = data.datasets || [];
-  data.labels = data.labels || [];
-  return data;
-}
-function initConfig(config) {
-  config = config || {};
-  config.data = initData(config.data);
-  initOptions(config);
-  return config;
-}
-const keyCache = /* @__PURE__ */ new Map();
-const keysCached = /* @__PURE__ */ new Set();
-function cachedKeys(cacheKey, generate) {
-  let keys = keyCache.get(cacheKey);
-  if (!keys) {
-    keys = generate();
-    keyCache.set(cacheKey, keys);
-    keysCached.add(keys);
-  }
-  return keys;
-}
-const addIfFound = (set2, obj, key) => {
-  const opts = resolveObjectKey(obj, key);
-  if (opts !== void 0) {
-    set2.add(opts);
-  }
-};
-class Config {
-  constructor(config) {
-    this._config = initConfig(config);
-    this._scopeCache = /* @__PURE__ */ new Map();
-    this._resolverCache = /* @__PURE__ */ new Map();
-  }
-  get platform() {
-    return this._config.platform;
-  }
-  get type() {
-    return this._config.type;
-  }
-  set type(type) {
-    this._config.type = type;
-  }
-  get data() {
-    return this._config.data;
-  }
-  set data(data) {
-    this._config.data = initData(data);
-  }
-  get options() {
-    return this._config.options;
-  }
-  set options(options) {
-    this._config.options = options;
-  }
-  get plugins() {
-    return this._config.plugins;
-  }
-  update() {
-    const config = this._config;
-    this.clearCache();
-    initOptions(config);
-  }
-  clearCache() {
-    this._scopeCache.clear();
-    this._resolverCache.clear();
-  }
-  datasetScopeKeys(datasetType) {
-    return cachedKeys(datasetType, () => [
-      [
-        `datasets.${datasetType}`,
-        ""
-      ]
-    ]);
-  }
-  datasetAnimationScopeKeys(datasetType, transition) {
-    return cachedKeys(`${datasetType}.transition.${transition}`, () => [
-      [
-        `datasets.${datasetType}.transitions.${transition}`,
-        `transitions.${transition}`
-      ],
-      [
-        `datasets.${datasetType}`,
-        ""
-      ]
-    ]);
-  }
-  datasetElementScopeKeys(datasetType, elementType) {
-    return cachedKeys(`${datasetType}-${elementType}`, () => [
-      [
-        `datasets.${datasetType}.elements.${elementType}`,
-        `datasets.${datasetType}`,
-        `elements.${elementType}`,
-        ""
-      ]
-    ]);
-  }
-  pluginScopeKeys(plugin) {
-    const id2 = plugin.id;
-    const type = this.type;
-    return cachedKeys(`${type}-plugin-${id2}`, () => [
-      [
-        `plugins.${id2}`,
-        ...plugin.additionalOptionScopes || []
-      ]
-    ]);
-  }
-  _cachedScopes(mainScope, resetCache) {
-    const _scopeCache = this._scopeCache;
-    let cache = _scopeCache.get(mainScope);
-    if (!cache || resetCache) {
-      cache = /* @__PURE__ */ new Map();
-      _scopeCache.set(mainScope, cache);
-    }
-    return cache;
-  }
-  getOptionScopes(mainScope, keyLists, resetCache) {
-    const { options, type } = this;
-    const cache = this._cachedScopes(mainScope, resetCache);
-    const cached = cache.get(keyLists);
-    if (cached) {
-      return cached;
-    }
-    const scopes = /* @__PURE__ */ new Set();
-    keyLists.forEach((keys) => {
-      if (mainScope) {
-        scopes.add(mainScope);
-        keys.forEach((key) => addIfFound(scopes, mainScope, key));
-      }
-      keys.forEach((key) => addIfFound(scopes, options, key));
-      keys.forEach((key) => addIfFound(scopes, overrides[type] || {}, key));
-      keys.forEach((key) => addIfFound(scopes, defaults, key));
-      keys.forEach((key) => addIfFound(scopes, descriptors, key));
-    });
-    const array = Array.from(scopes);
-    if (array.length === 0) {
-      array.push(/* @__PURE__ */ Object.create(null));
-    }
-    if (keysCached.has(keyLists)) {
-      cache.set(keyLists, array);
-    }
-    return array;
-  }
-  chartOptionScopes() {
-    const { options, type } = this;
-    return [
-      options,
-      overrides[type] || {},
-      defaults.datasets[type] || {},
-      {
-        type
-      },
-      defaults,
-      descriptors
-    ];
-  }
-  resolveNamedOptions(scopes, names2, context, prefixes = [
-    ""
-  ]) {
-    const result = {
-      $shared: true
-    };
-    const { resolver, subPrefixes } = getResolver(this._resolverCache, scopes, prefixes);
-    let options = resolver;
-    if (needContext(resolver, names2)) {
-      result.$shared = false;
-      context = isFunction(context) ? context() : context;
-      const subResolver = this.createResolver(scopes, context, subPrefixes);
-      options = _attachContext(resolver, context, subResolver);
-    }
-    for (const prop of names2) {
-      result[prop] = options[prop];
-    }
-    return result;
-  }
-  createResolver(scopes, context, prefixes = [
-    ""
-  ], descriptorDefaults) {
-    const { resolver } = getResolver(this._resolverCache, scopes, prefixes);
-    return isObject(context) ? _attachContext(resolver, context, void 0, descriptorDefaults) : resolver;
-  }
-}
-function getResolver(resolverCache, scopes, prefixes) {
-  let cache = resolverCache.get(scopes);
-  if (!cache) {
-    cache = /* @__PURE__ */ new Map();
-    resolverCache.set(scopes, cache);
-  }
-  const cacheKey = prefixes.join();
-  let cached = cache.get(cacheKey);
-  if (!cached) {
-    const resolver = _createResolver(scopes, prefixes);
-    cached = {
-      resolver,
-      subPrefixes: prefixes.filter((p2) => !p2.toLowerCase().includes("hover"))
-    };
-    cache.set(cacheKey, cached);
-  }
-  return cached;
-}
-const hasFunction = (value) => isObject(value) && Object.getOwnPropertyNames(value).some((key) => isFunction(value[key]));
-function needContext(proxy, names2) {
-  const { isScriptable, isIndexable } = _descriptors(proxy);
-  for (const prop of names2) {
-    const scriptable = isScriptable(prop);
-    const indexable = isIndexable(prop);
-    const value = (indexable || scriptable) && proxy[prop];
-    if (scriptable && (isFunction(value) || hasFunction(value)) || indexable && isArray(value)) {
-      return true;
-    }
-  }
-  return false;
-}
-var version = "4.4.9";
-const KNOWN_POSITIONS = [
-  "top",
-  "bottom",
-  "left",
-  "right",
-  "chartArea"
-];
-function positionIsHorizontal(position, axis) {
-  return position === "top" || position === "bottom" || KNOWN_POSITIONS.indexOf(position) === -1 && axis === "x";
-}
-function compare2Level(l1, l2) {
-  return function(a, b) {
-    return a[l1] === b[l1] ? a[l2] - b[l2] : a[l1] - b[l1];
-  };
-}
-function onAnimationsComplete(context) {
-  const chart = context.chart;
-  const animationOptions = chart.options.animation;
-  chart.notifyPlugins("afterRender");
-  callback(animationOptions && animationOptions.onComplete, [
-    context
-  ], chart);
-}
-function onAnimationProgress(context) {
-  const chart = context.chart;
-  const animationOptions = chart.options.animation;
-  callback(animationOptions && animationOptions.onProgress, [
-    context
-  ], chart);
-}
-function getCanvas(item) {
-  if (_isDomSupported() && typeof item === "string") {
-    item = document.getElementById(item);
-  } else if (item && item.length) {
-    item = item[0];
-  }
-  if (item && item.canvas) {
-    item = item.canvas;
-  }
-  return item;
-}
-const instances = {};
-const getChart = (key) => {
-  const canvas = getCanvas(key);
-  return Object.values(instances).filter((c) => c.canvas === canvas).pop();
-};
-function moveNumericKeys(obj, start, move) {
-  const keys = Object.keys(obj);
-  for (const key of keys) {
-    const intKey = +key;
-    if (intKey >= start) {
-      const value = obj[key];
-      delete obj[key];
-      if (move > 0 || intKey > start) {
-        obj[intKey + move] = value;
-      }
-    }
-  }
-}
-function determineLastEvent(e, lastEvent, inChartArea, isClick) {
-  if (!inChartArea || e.type === "mouseout") {
-    return null;
-  }
-  if (isClick) {
-    return lastEvent;
-  }
-  return e;
-}
-let Chart$1 = (_b = class {
-  static register(...items) {
-    registry.add(...items);
-    invalidatePlugins();
-  }
-  static unregister(...items) {
-    registry.remove(...items);
-    invalidatePlugins();
-  }
-  constructor(item, userConfig) {
-    const config = this.config = new Config(userConfig);
-    const initialCanvas = getCanvas(item);
-    const existingChart = getChart(initialCanvas);
-    if (existingChart) {
-      throw new Error("Canvas is already in use. Chart with ID '" + existingChart.id + "' must be destroyed before the canvas with ID '" + existingChart.canvas.id + "' can be reused.");
-    }
-    const options = config.createResolver(config.chartOptionScopes(), this.getContext());
-    this.platform = new (config.platform || _detectPlatform(initialCanvas))();
-    this.platform.updateConfig(config);
-    const context = this.platform.acquireContext(initialCanvas, options.aspectRatio);
-    const canvas = context && context.canvas;
-    const height = canvas && canvas.height;
-    const width = canvas && canvas.width;
-    this.id = uid();
-    this.ctx = context;
-    this.canvas = canvas;
-    this.width = width;
-    this.height = height;
-    this._options = options;
-    this._aspectRatio = this.aspectRatio;
-    this._layers = [];
-    this._metasets = [];
-    this._stacks = void 0;
-    this.boxes = [];
-    this.currentDevicePixelRatio = void 0;
-    this.chartArea = void 0;
-    this._active = [];
-    this._lastEvent = void 0;
-    this._listeners = {};
-    this._responsiveListeners = void 0;
-    this._sortedMetasets = [];
-    this.scales = {};
-    this._plugins = new PluginService();
-    this.$proxies = {};
-    this._hiddenIndices = {};
-    this.attached = false;
-    this._animationsDisabled = void 0;
-    this.$context = void 0;
-    this._doResize = debounce((mode) => this.update(mode), options.resizeDelay || 0);
-    this._dataChanges = [];
-    instances[this.id] = this;
-    if (!context || !canvas) {
-      console.error("Failed to create chart: can't acquire context from the given item");
-      return;
-    }
-    animator.listen(this, "complete", onAnimationsComplete);
-    animator.listen(this, "progress", onAnimationProgress);
-    this._initialize();
-    if (this.attached) {
-      this.update();
-    }
-  }
-  get aspectRatio() {
-    const { options: { aspectRatio, maintainAspectRatio }, width, height, _aspectRatio } = this;
-    if (!isNullOrUndef(aspectRatio)) {
-      return aspectRatio;
-    }
-    if (maintainAspectRatio && _aspectRatio) {
-      return _aspectRatio;
-    }
-    return height ? width / height : null;
-  }
-  get data() {
-    return this.config.data;
-  }
-  set data(data) {
-    this.config.data = data;
-  }
-  get options() {
-    return this._options;
-  }
-  set options(options) {
-    this.config.options = options;
-  }
-  get registry() {
-    return registry;
-  }
-  _initialize() {
-    this.notifyPlugins("beforeInit");
-    if (this.options.responsive) {
-      this.resize();
-    } else {
-      retinaScale(this, this.options.devicePixelRatio);
-    }
-    this.bindEvents();
-    this.notifyPlugins("afterInit");
-    return this;
-  }
-  clear() {
-    clearCanvas(this.canvas, this.ctx);
-    return this;
-  }
-  stop() {
-    animator.stop(this);
-    return this;
-  }
-  resize(width, height) {
-    if (!animator.running(this)) {
-      this._resize(width, height);
-    } else {
-      this._resizeBeforeDraw = {
-        width,
-        height
-      };
-    }
-  }
-  _resize(width, height) {
-    const options = this.options;
-    const canvas = this.canvas;
-    const aspectRatio = options.maintainAspectRatio && this.aspectRatio;
-    const newSize = this.platform.getMaximumSize(canvas, width, height, aspectRatio);
-    const newRatio = options.devicePixelRatio || this.platform.getDevicePixelRatio();
-    const mode = this.width ? "resize" : "attach";
-    this.width = newSize.width;
-    this.height = newSize.height;
-    this._aspectRatio = this.aspectRatio;
-    if (!retinaScale(this, newRatio, true)) {
-      return;
-    }
-    this.notifyPlugins("resize", {
-      size: newSize
-    });
-    callback(options.onResize, [
-      this,
-      newSize
-    ], this);
-    if (this.attached) {
-      if (this._doResize(mode)) {
-        this.render();
-      }
-    }
-  }
-  ensureScalesHaveIDs() {
-    const options = this.options;
-    const scalesOptions = options.scales || {};
-    each(scalesOptions, (axisOptions, axisID) => {
-      axisOptions.id = axisID;
-    });
-  }
-  buildOrUpdateScales() {
-    const options = this.options;
-    const scaleOpts = options.scales;
-    const scales = this.scales;
-    const updated = Object.keys(scales).reduce((obj, id2) => {
-      obj[id2] = false;
-      return obj;
-    }, {});
-    let items = [];
-    if (scaleOpts) {
-      items = items.concat(Object.keys(scaleOpts).map((id2) => {
-        const scaleOptions = scaleOpts[id2];
-        const axis = determineAxis(id2, scaleOptions);
-        const isRadial = axis === "r";
-        const isHorizontal = axis === "x";
-        return {
-          options: scaleOptions,
-          dposition: isRadial ? "chartArea" : isHorizontal ? "bottom" : "left",
-          dtype: isRadial ? "radialLinear" : isHorizontal ? "category" : "linear"
-        };
-      }));
-    }
-    each(items, (item) => {
-      const scaleOptions = item.options;
-      const id2 = scaleOptions.id;
-      const axis = determineAxis(id2, scaleOptions);
-      const scaleType = valueOrDefault(scaleOptions.type, item.dtype);
-      if (scaleOptions.position === void 0 || positionIsHorizontal(scaleOptions.position, axis) !== positionIsHorizontal(item.dposition)) {
-        scaleOptions.position = item.dposition;
-      }
-      updated[id2] = true;
-      let scale = null;
-      if (id2 in scales && scales[id2].type === scaleType) {
-        scale = scales[id2];
-      } else {
-        const scaleClass = registry.getScale(scaleType);
-        scale = new scaleClass({
-          id: id2,
-          type: scaleType,
-          ctx: this.ctx,
-          chart: this
-        });
-        scales[scale.id] = scale;
-      }
-      scale.init(scaleOptions, options);
-    });
-    each(updated, (hasUpdated, id2) => {
-      if (!hasUpdated) {
-        delete scales[id2];
-      }
-    });
-    each(scales, (scale) => {
-      layouts.configure(this, scale, scale.options);
-      layouts.addBox(this, scale);
-    });
-  }
-  _updateMetasets() {
-    const metasets = this._metasets;
-    const numData = this.data.datasets.length;
-    const numMeta = metasets.length;
-    metasets.sort((a, b) => a.index - b.index);
-    if (numMeta > numData) {
-      for (let i = numData; i < numMeta; ++i) {
-        this._destroyDatasetMeta(i);
-      }
-      metasets.splice(numData, numMeta - numData);
-    }
-    this._sortedMetasets = metasets.slice(0).sort(compare2Level("order", "index"));
-  }
-  _removeUnreferencedMetasets() {
-    const { _metasets: metasets, data: { datasets } } = this;
-    if (metasets.length > datasets.length) {
-      delete this._stacks;
-    }
-    metasets.forEach((meta, index) => {
-      if (datasets.filter((x2) => x2 === meta._dataset).length === 0) {
-        this._destroyDatasetMeta(index);
-      }
-    });
-  }
-  buildOrUpdateControllers() {
-    const newControllers = [];
-    const datasets = this.data.datasets;
-    let i, ilen;
-    this._removeUnreferencedMetasets();
-    for (i = 0, ilen = datasets.length; i < ilen; i++) {
-      const dataset = datasets[i];
-      let meta = this.getDatasetMeta(i);
-      const type = dataset.type || this.config.type;
-      if (meta.type && meta.type !== type) {
-        this._destroyDatasetMeta(i);
-        meta = this.getDatasetMeta(i);
-      }
-      meta.type = type;
-      meta.indexAxis = dataset.indexAxis || getIndexAxis(type, this.options);
-      meta.order = dataset.order || 0;
-      meta.index = i;
-      meta.label = "" + dataset.label;
-      meta.visible = this.isDatasetVisible(i);
-      if (meta.controller) {
-        meta.controller.updateIndex(i);
-        meta.controller.linkScales();
-      } else {
-        const ControllerClass = registry.getController(type);
-        const { datasetElementType, dataElementType } = defaults.datasets[type];
-        Object.assign(ControllerClass, {
-          dataElementType: registry.getElement(dataElementType),
-          datasetElementType: datasetElementType && registry.getElement(datasetElementType)
-        });
-        meta.controller = new ControllerClass(this, i);
-        newControllers.push(meta.controller);
-      }
-    }
-    this._updateMetasets();
-    return newControllers;
-  }
-  _resetElements() {
-    each(this.data.datasets, (dataset, datasetIndex) => {
-      this.getDatasetMeta(datasetIndex).controller.reset();
-    }, this);
-  }
-  reset() {
-    this._resetElements();
-    this.notifyPlugins("reset");
-  }
-  update(mode) {
-    const config = this.config;
-    config.update();
-    const options = this._options = config.createResolver(config.chartOptionScopes(), this.getContext());
-    const animsDisabled = this._animationsDisabled = !options.animation;
-    this._updateScales();
-    this._checkEventBindings();
-    this._updateHiddenIndices();
-    this._plugins.invalidate();
-    if (this.notifyPlugins("beforeUpdate", {
-      mode,
-      cancelable: true
-    }) === false) {
-      return;
-    }
-    const newControllers = this.buildOrUpdateControllers();
-    this.notifyPlugins("beforeElementsUpdate");
-    let minPadding = 0;
-    for (let i = 0, ilen = this.data.datasets.length; i < ilen; i++) {
-      const { controller } = this.getDatasetMeta(i);
-      const reset = !animsDisabled && newControllers.indexOf(controller) === -1;
-      controller.buildOrUpdateElements(reset);
-      minPadding = Math.max(+controller.getMaxOverflow(), minPadding);
-    }
-    minPadding = this._minPadding = options.layout.autoPadding ? minPadding : 0;
-    this._updateLayout(minPadding);
-    if (!animsDisabled) {
-      each(newControllers, (controller) => {
-        controller.reset();
-      });
-    }
-    this._updateDatasets(mode);
-    this.notifyPlugins("afterUpdate", {
-      mode
-    });
-    this._layers.sort(compare2Level("z", "_idx"));
-    const { _active, _lastEvent } = this;
-    if (_lastEvent) {
-      this._eventHandler(_lastEvent, true);
-    } else if (_active.length) {
-      this._updateHoverStyles(_active, _active, true);
-    }
-    this.render();
-  }
-  _updateScales() {
-    each(this.scales, (scale) => {
-      layouts.removeBox(this, scale);
-    });
-    this.ensureScalesHaveIDs();
-    this.buildOrUpdateScales();
-  }
-  _checkEventBindings() {
-    const options = this.options;
-    const existingEvents = new Set(Object.keys(this._listeners));
-    const newEvents = new Set(options.events);
-    if (!setsEqual(existingEvents, newEvents) || !!this._responsiveListeners !== options.responsive) {
-      this.unbindEvents();
-      this.bindEvents();
-    }
-  }
-  _updateHiddenIndices() {
-    const { _hiddenIndices } = this;
-    const changes = this._getUniformDataChanges() || [];
-    for (const { method, start, count } of changes) {
-      const move = method === "_removeElements" ? -count : count;
-      moveNumericKeys(_hiddenIndices, start, move);
-    }
-  }
-  _getUniformDataChanges() {
-    const _dataChanges = this._dataChanges;
-    if (!_dataChanges || !_dataChanges.length) {
-      return;
-    }
-    this._dataChanges = [];
-    const datasetCount = this.data.datasets.length;
-    const makeSet = (idx) => new Set(_dataChanges.filter((c) => c[0] === idx).map((c, i) => i + "," + c.splice(1).join(",")));
-    const changeSet = makeSet(0);
-    for (let i = 1; i < datasetCount; i++) {
-      if (!setsEqual(changeSet, makeSet(i))) {
-        return;
-      }
-    }
-    return Array.from(changeSet).map((c) => c.split(",")).map((a) => ({
-      method: a[1],
-      start: +a[2],
-      count: +a[3]
-    }));
-  }
-  _updateLayout(minPadding) {
-    if (this.notifyPlugins("beforeLayout", {
-      cancelable: true
-    }) === false) {
-      return;
-    }
-    layouts.update(this, this.width, this.height, minPadding);
-    const area = this.chartArea;
-    const noArea = area.width <= 0 || area.height <= 0;
-    this._layers = [];
-    each(this.boxes, (box) => {
-      if (noArea && box.position === "chartArea") {
-        return;
-      }
-      if (box.configure) {
-        box.configure();
-      }
-      this._layers.push(...box._layers());
-    }, this);
-    this._layers.forEach((item, index) => {
-      item._idx = index;
-    });
-    this.notifyPlugins("afterLayout");
-  }
-  _updateDatasets(mode) {
-    if (this.notifyPlugins("beforeDatasetsUpdate", {
-      mode,
-      cancelable: true
-    }) === false) {
-      return;
-    }
-    for (let i = 0, ilen = this.data.datasets.length; i < ilen; ++i) {
-      this.getDatasetMeta(i).controller.configure();
-    }
-    for (let i = 0, ilen = this.data.datasets.length; i < ilen; ++i) {
-      this._updateDataset(i, isFunction(mode) ? mode({
-        datasetIndex: i
-      }) : mode);
-    }
-    this.notifyPlugins("afterDatasetsUpdate", {
-      mode
-    });
-  }
-  _updateDataset(index, mode) {
-    const meta = this.getDatasetMeta(index);
-    const args = {
-      meta,
-      index,
-      mode,
-      cancelable: true
-    };
-    if (this.notifyPlugins("beforeDatasetUpdate", args) === false) {
-      return;
-    }
-    meta.controller._update(mode);
-    args.cancelable = false;
-    this.notifyPlugins("afterDatasetUpdate", args);
-  }
-  render() {
-    if (this.notifyPlugins("beforeRender", {
-      cancelable: true
-    }) === false) {
-      return;
-    }
-    if (animator.has(this)) {
-      if (this.attached && !animator.running(this)) {
-        animator.start(this);
-      }
-    } else {
-      this.draw();
-      onAnimationsComplete({
-        chart: this
       });
-    }
-  }
-  draw() {
-    let i;
-    if (this._resizeBeforeDraw) {
-      const { width, height } = this._resizeBeforeDraw;
-      this._resizeBeforeDraw = null;
-      this._resize(width, height);
-    }
-    this.clear();
-    if (this.width <= 0 || this.height <= 0) {
-      return;
-    }
-    if (this.notifyPlugins("beforeDraw", {
-      cancelable: true
-    }) === false) {
-      return;
-    }
-    const layers = this._layers;
-    for (i = 0; i < layers.length && layers[i].z <= 0; ++i) {
-      layers[i].draw(this.chartArea);
-    }
-    this._drawDatasets();
-    for (; i < layers.length; ++i) {
-      layers[i].draw(this.chartArea);
-    }
-    this.notifyPlugins("afterDraw");
-  }
-  _getSortedDatasetMetas(filterVisible) {
-    const metasets = this._sortedMetasets;
-    const result = [];
-    let i, ilen;
-    for (i = 0, ilen = metasets.length; i < ilen; ++i) {
-      const meta = metasets[i];
-      if (!filterVisible || meta.visible) {
-        result.push(meta);
-      }
-    }
-    return result;
-  }
-  getSortedVisibleDatasetMetas() {
-    return this._getSortedDatasetMetas(true);
-  }
-  _drawDatasets() {
-    if (this.notifyPlugins("beforeDatasetsDraw", {
-      cancelable: true
-    }) === false) {
-      return;
-    }
-    const metasets = this.getSortedVisibleDatasetMetas();
-    for (let i = metasets.length - 1; i >= 0; --i) {
-      this._drawDataset(metasets[i]);
-    }
-    this.notifyPlugins("afterDatasetsDraw");
-  }
-  _drawDataset(meta) {
-    const ctx = this.ctx;
-    const args = {
-      meta,
-      index: meta.index,
-      cancelable: true
-    };
-    const clip = getDatasetClipArea(this, meta);
-    if (this.notifyPlugins("beforeDatasetDraw", args) === false) {
-      return;
-    }
-    if (clip) {
-      clipArea(ctx, clip);
-    }
-    meta.controller.draw();
-    if (clip) {
-      unclipArea(ctx);
-    }
-    args.cancelable = false;
-    this.notifyPlugins("afterDatasetDraw", args);
-  }
-  isPointInArea(point) {
-    return _isPointInArea(point, this.chartArea, this._minPadding);
-  }
-  getElementsAtEventForMode(e, mode, options, useFinalPosition) {
-    const method = Interaction.modes[mode];
-    if (typeof method === "function") {
-      return method(this, e, options, useFinalPosition);
-    }
-    return [];
-  }
-  getDatasetMeta(datasetIndex) {
-    const dataset = this.data.datasets[datasetIndex];
-    const metasets = this._metasets;
-    let meta = metasets.filter((x2) => x2 && x2._dataset === dataset).pop();
-    if (!meta) {
-      meta = {
-        type: null,
-        data: [],
-        dataset: null,
-        controller: null,
-        hidden: null,
-        xAxisID: null,
-        yAxisID: null,
-        order: dataset && dataset.order || 0,
-        index: datasetIndex,
-        _dataset: dataset,
-        _parsed: [],
-        _sorted: false
-      };
-      metasets.push(meta);
-    }
-    return meta;
-  }
-  getContext() {
-    return this.$context || (this.$context = createContext(null, {
-      chart: this,
-      type: "chart"
-    }));
-  }
-  getVisibleDatasetCount() {
-    return this.getSortedVisibleDatasetMetas().length;
-  }
-  isDatasetVisible(datasetIndex) {
-    const dataset = this.data.datasets[datasetIndex];
-    if (!dataset) {
-      return false;
-    }
-    const meta = this.getDatasetMeta(datasetIndex);
-    return typeof meta.hidden === "boolean" ? !meta.hidden : !dataset.hidden;
-  }
-  setDatasetVisibility(datasetIndex, visible) {
-    const meta = this.getDatasetMeta(datasetIndex);
-    meta.hidden = !visible;
-  }
-  toggleDataVisibility(index) {
-    this._hiddenIndices[index] = !this._hiddenIndices[index];
-  }
-  getDataVisibility(index) {
-    return !this._hiddenIndices[index];
-  }
-  _updateVisibility(datasetIndex, dataIndex, visible) {
-    const mode = visible ? "show" : "hide";
-    const meta = this.getDatasetMeta(datasetIndex);
-    const anims = meta.controller._resolveAnimations(void 0, mode);
-    if (defined(dataIndex)) {
-      meta.data[dataIndex].hidden = !visible;
-      this.update();
-    } else {
-      this.setDatasetVisibility(datasetIndex, visible);
-      anims.update(meta, {
-        visible
+      var require_scene_update = __commonJS({
+        "src/traces/scattergl/scene_update.js"(exports, module2) {
+          var Lib = require_lib();
+          module2.exports = function sceneUpdate(gd2, subplot) {
+            var scene = subplot._scene;
+            var resetOpts = {
+              // number of traces in subplot, since scene:subplot -> 1:1
+              count: 0,
+              // whether scene requires init hook in plot call (dirty plot call)
+              dirty: true,
+              // last used options
+              lineOptions: [],
+              fillOptions: [],
+              markerOptions: [],
+              markerSelectedOptions: [],
+              markerUnselectedOptions: [],
+              errorXOptions: [],
+              errorYOptions: [],
+              textOptions: [],
+              textSelectedOptions: [],
+              textUnselectedOptions: [],
+              // selection batches
+              selectBatch: [],
+              unselectBatch: []
+            };
+            var initOpts = {
+              fill2d: false,
+              scatter2d: false,
+              error2d: false,
+              line2d: false,
+              glText: false,
+              select2d: false
+            };
+            if (!subplot._scene) {
+              scene = subplot._scene = {};
+              scene.init = function init() {
+                Lib.extendFlat(scene, initOpts, resetOpts);
+              };
+              scene.init();
+              scene.update = function update(opt) {
+                var opts = Lib.repeat(opt, scene.count);
+                if (scene.fill2d) scene.fill2d.update(opts);
+                if (scene.scatter2d) scene.scatter2d.update(opts);
+                if (scene.line2d) scene.line2d.update(opts);
+                if (scene.error2d) scene.error2d.update(opts.concat(opts));
+                if (scene.select2d) scene.select2d.update(opts);
+                if (scene.glText) {
+                  for (var i2 = 0; i2 < scene.count; i2++) {
+                    scene.glText[i2].update(opt);
+                  }
+                }
+              };
+              scene.draw = function draw() {
+                var count2 = scene.count;
+                var fill2d = scene.fill2d;
+                var error2d = scene.error2d;
+                var line2d = scene.line2d;
+                var scatter2d = scene.scatter2d;
+                var glText = scene.glText;
+                var select2d = scene.select2d;
+                var selectBatch = scene.selectBatch;
+                var unselectBatch = scene.unselectBatch;
+                for (var i2 = 0; i2 < count2; i2++) {
+                  if (fill2d && scene.fillOrder[i2]) {
+                    fill2d.draw(scene.fillOrder[i2]);
+                  }
+                  if (line2d && scene.lineOptions[i2]) {
+                    line2d.draw(i2);
+                  }
+                  if (error2d) {
+                    if (scene.errorXOptions[i2]) error2d.draw(i2);
+                    if (scene.errorYOptions[i2]) error2d.draw(i2 + count2);
+                  }
+                  if (scatter2d && scene.markerOptions[i2]) {
+                    if (unselectBatch[i2].length) {
+                      var arg = Lib.repeat([], scene.count);
+                      arg[i2] = unselectBatch[i2];
+                      scatter2d.draw(arg);
+                    } else if (!selectBatch[i2].length) {
+                      scatter2d.draw(i2);
+                    }
+                  }
+                  if (glText[i2] && scene.textOptions[i2]) {
+                    glText[i2].render();
+                  }
+                }
+                if (select2d) {
+                  select2d.draw(selectBatch);
+                }
+                scene.dirty = false;
+              };
+              scene.destroy = function destroy() {
+                if (scene.fill2d && scene.fill2d.destroy) scene.fill2d.destroy();
+                if (scene.scatter2d && scene.scatter2d.destroy) scene.scatter2d.destroy();
+                if (scene.error2d && scene.error2d.destroy) scene.error2d.destroy();
+                if (scene.line2d && scene.line2d.destroy) scene.line2d.destroy();
+                if (scene.select2d && scene.select2d.destroy) scene.select2d.destroy();
+                if (scene.glText) {
+                  scene.glText.forEach(function(text) {
+                    if (text.destroy) text.destroy();
+                  });
+                }
+                scene.lineOptions = null;
+                scene.fillOptions = null;
+                scene.markerOptions = null;
+                scene.markerSelectedOptions = null;
+                scene.markerUnselectedOptions = null;
+                scene.errorXOptions = null;
+                scene.errorYOptions = null;
+                scene.textOptions = null;
+                scene.textSelectedOptions = null;
+                scene.textUnselectedOptions = null;
+                scene.selectBatch = null;
+                scene.unselectBatch = null;
+                subplot._scene = null;
+              };
+            }
+            if (!scene.dirty) {
+              Lib.extendFlat(scene, resetOpts);
+            }
+            return scene;
+          };
+        }
       });
-      this.update((ctx) => ctx.datasetIndex === datasetIndex ? mode : void 0);
-    }
-  }
-  hide(datasetIndex, dataIndex) {
-    this._updateVisibility(datasetIndex, dataIndex, false);
-  }
-  show(datasetIndex, dataIndex) {
-    this._updateVisibility(datasetIndex, dataIndex, true);
-  }
-  _destroyDatasetMeta(datasetIndex) {
-    const meta = this._metasets[datasetIndex];
-    if (meta && meta.controller) {
-      meta.controller._destroy();
-    }
-    delete this._metasets[datasetIndex];
-  }
-  _stop() {
-    let i, ilen;
-    this.stop();
-    animator.remove(this);
-    for (i = 0, ilen = this.data.datasets.length; i < ilen; ++i) {
-      this._destroyDatasetMeta(i);
-    }
-  }
-  destroy() {
-    this.notifyPlugins("beforeDestroy");
-    const { canvas, ctx } = this;
-    this._stop();
-    this.config.clearCache();
-    if (canvas) {
-      this.unbindEvents();
-      clearCanvas(canvas, ctx);
-      this.platform.releaseContext(ctx);
-      this.canvas = null;
-      this.ctx = null;
-    }
-    delete instances[this.id];
-    this.notifyPlugins("afterDestroy");
-  }
-  toBase64Image(...args) {
-    return this.canvas.toDataURL(...args);
-  }
-  bindEvents() {
-    this.bindUserEvents();
-    if (this.options.responsive) {
-      this.bindResponsiveEvents();
-    } else {
-      this.attached = true;
-    }
-  }
-  bindUserEvents() {
-    const listeners = this._listeners;
-    const platform = this.platform;
-    const _add = (type, listener2) => {
-      platform.addEventListener(this, type, listener2);
-      listeners[type] = listener2;
-    };
-    const listener = (e, x2, y2) => {
-      e.offsetX = x2;
-      e.offsetY = y2;
-      this._eventHandler(e);
-    };
-    each(this.options.events, (type) => _add(type, listener));
-  }
-  bindResponsiveEvents() {
-    if (!this._responsiveListeners) {
-      this._responsiveListeners = {};
-    }
-    const listeners = this._responsiveListeners;
-    const platform = this.platform;
-    const _add = (type, listener2) => {
-      platform.addEventListener(this, type, listener2);
-      listeners[type] = listener2;
-    };
-    const _remove = (type, listener2) => {
-      if (listeners[type]) {
-        platform.removeEventListener(this, type, listener2);
-        delete listeners[type];
-      }
-    };
-    const listener = (width, height) => {
-      if (this.canvas) {
-        this.resize(width, height);
-      }
-    };
-    let detached;
-    const attached = () => {
-      _remove("attach", attached);
-      this.attached = true;
-      this.resize();
-      _add("resize", listener);
-      _add("detach", detached);
-    };
-    detached = () => {
-      this.attached = false;
-      _remove("resize", listener);
-      this._stop();
-      this._resize(0, 0);
-      _add("attach", attached);
-    };
-    if (platform.isAttached(this.canvas)) {
-      attached();
-    } else {
-      detached();
-    }
-  }
-  unbindEvents() {
-    each(this._listeners, (listener, type) => {
-      this.platform.removeEventListener(this, type, listener);
-    });
-    this._listeners = {};
-    each(this._responsiveListeners, (listener, type) => {
-      this.platform.removeEventListener(this, type, listener);
-    });
-    this._responsiveListeners = void 0;
-  }
-  updateHoverStyle(items, mode, enabled) {
-    const prefix = enabled ? "set" : "remove";
-    let meta, item, i, ilen;
-    if (mode === "dataset") {
-      meta = this.getDatasetMeta(items[0].datasetIndex);
-      meta.controller["_" + prefix + "DatasetHoverStyle"]();
-    }
-    for (i = 0, ilen = items.length; i < ilen; ++i) {
-      item = items[i];
-      const controller = item && this.getDatasetMeta(item.datasetIndex).controller;
-      if (controller) {
-        controller[prefix + "HoverStyle"](item.element, item.datasetIndex, item.index);
-      }
-    }
-  }
-  getActiveElements() {
-    return this._active || [];
-  }
-  setActiveElements(activeElements) {
-    const lastActive = this._active || [];
-    const active = activeElements.map(({ datasetIndex, index }) => {
-      const meta = this.getDatasetMeta(datasetIndex);
-      if (!meta) {
-        throw new Error("No dataset found at index " + datasetIndex);
-      }
-      return {
-        datasetIndex,
-        element: meta.data[index],
-        index
-      };
-    });
-    const changed = !_elementsEqual(active, lastActive);
-    if (changed) {
-      this._active = active;
-      this._lastEvent = null;
-      this._updateHoverStyles(active, lastActive);
-    }
-  }
-  notifyPlugins(hook, args, filter) {
-    return this._plugins.notify(this, hook, args, filter);
-  }
-  isPluginEnabled(pluginId) {
-    return this._plugins._cache.filter((p2) => p2.plugin.id === pluginId).length === 1;
-  }
-  _updateHoverStyles(active, lastActive, replay) {
-    const hoverOptions = this.options.hover;
-    const diff = (a, b) => a.filter((x2) => !b.some((y2) => x2.datasetIndex === y2.datasetIndex && x2.index === y2.index));
-    const deactivated = diff(lastActive, active);
-    const activated = replay ? active : diff(active, lastActive);
-    if (deactivated.length) {
-      this.updateHoverStyle(deactivated, hoverOptions.mode, false);
-    }
-    if (activated.length && hoverOptions.mode) {
-      this.updateHoverStyle(activated, hoverOptions.mode, true);
-    }
-  }
-  _eventHandler(e, replay) {
-    const args = {
-      event: e,
-      replay,
-      cancelable: true,
-      inChartArea: this.isPointInArea(e)
-    };
-    const eventFilter = (plugin) => (plugin.options.events || this.options.events).includes(e.native.type);
-    if (this.notifyPlugins("beforeEvent", args, eventFilter) === false) {
-      return;
-    }
-    const changed = this._handleEvent(e, replay, args.inChartArea);
-    args.cancelable = false;
-    this.notifyPlugins("afterEvent", args, eventFilter);
-    if (changed || args.changed) {
-      this.render();
-    }
-    return this;
-  }
-  _handleEvent(e, replay, inChartArea) {
-    const { _active: lastActive = [], options } = this;
-    const useFinalPosition = replay;
-    const active = this._getActiveElements(e, lastActive, inChartArea, useFinalPosition);
-    const isClick = _isClickEvent(e);
-    const lastEvent = determineLastEvent(e, this._lastEvent, inChartArea, isClick);
-    if (inChartArea) {
-      this._lastEvent = null;
-      callback(options.onHover, [
-        e,
-        active,
-        this
-      ], this);
-      if (isClick) {
-        callback(options.onClick, [
-          e,
-          active,
-          this
-        ], this);
-      }
-    }
-    const changed = !_elementsEqual(active, lastActive);
-    if (changed || replay) {
-      this._active = active;
-      this._updateHoverStyles(active, lastActive, replay);
-    }
-    this._lastEvent = lastEvent;
-    return changed;
-  }
-  _getActiveElements(e, lastActive, inChartArea, useFinalPosition) {
-    if (e.type === "mouseout") {
-      return [];
-    }
-    if (!inChartArea) {
-      return lastActive;
-    }
-    const hoverOptions = this.options.hover;
-    return this.getElementsAtEventForMode(e, hoverOptions.mode, hoverOptions, useFinalPosition);
-  }
-}, __publicField(_b, "defaults", defaults), __publicField(_b, "instances", instances), __publicField(_b, "overrides", overrides), __publicField(_b, "registry", registry), __publicField(_b, "version", version), __publicField(_b, "getChart", getChart), _b);
-function invalidatePlugins() {
-  return each(Chart$1.instances, (chart) => chart._plugins.invalidate());
-}
-function setStyle(ctx, options, style = options) {
-  ctx.lineCap = valueOrDefault(style.borderCapStyle, options.borderCapStyle);
-  ctx.setLineDash(valueOrDefault(style.borderDash, options.borderDash));
-  ctx.lineDashOffset = valueOrDefault(style.borderDashOffset, options.borderDashOffset);
-  ctx.lineJoin = valueOrDefault(style.borderJoinStyle, options.borderJoinStyle);
-  ctx.lineWidth = valueOrDefault(style.borderWidth, options.borderWidth);
-  ctx.strokeStyle = valueOrDefault(style.borderColor, options.borderColor);
-}
-function lineTo(ctx, previous, target) {
-  ctx.lineTo(target.x, target.y);
-}
-function getLineMethod(options) {
-  if (options.stepped) {
-    return _steppedLineTo;
-  }
-  if (options.tension || options.cubicInterpolationMode === "monotone") {
-    return _bezierCurveTo;
-  }
-  return lineTo;
-}
-function pathVars(points, segment, params = {}) {
-  const count = points.length;
-  const { start: paramsStart = 0, end: paramsEnd = count - 1 } = params;
-  const { start: segmentStart, end: segmentEnd } = segment;
-  const start = Math.max(paramsStart, segmentStart);
-  const end = Math.min(paramsEnd, segmentEnd);
-  const outside = paramsStart < segmentStart && paramsEnd < segmentStart || paramsStart > segmentEnd && paramsEnd > segmentEnd;
-  return {
-    count,
-    start,
-    loop: segment.loop,
-    ilen: end < start && !outside ? count + end - start : end - start
-  };
-}
-function pathSegment(ctx, line, segment, params) {
-  const { points, options } = line;
-  const { count, start, loop, ilen } = pathVars(points, segment, params);
-  const lineMethod = getLineMethod(options);
-  let { move = true, reverse } = params || {};
-  let i, point, prev;
-  for (i = 0; i <= ilen; ++i) {
-    point = points[(start + (reverse ? ilen - i : i)) % count];
-    if (point.skip) {
-      continue;
-    } else if (move) {
-      ctx.moveTo(point.x, point.y);
-      move = false;
-    } else {
-      lineMethod(ctx, prev, point, reverse, options.stepped);
-    }
-    prev = point;
-  }
-  if (loop) {
-    point = points[(start + (reverse ? ilen : 0)) % count];
-    lineMethod(ctx, prev, point, reverse, options.stepped);
-  }
-  return !!loop;
-}
-function fastPathSegment(ctx, line, segment, params) {
-  const points = line.points;
-  const { count, start, ilen } = pathVars(points, segment, params);
-  const { move = true, reverse } = params || {};
-  let avgX = 0;
-  let countX = 0;
-  let i, point, prevX, minY, maxY, lastY;
-  const pointIndex = (index) => (start + (reverse ? ilen - index : index)) % count;
-  const drawX = () => {
-    if (minY !== maxY) {
-      ctx.lineTo(avgX, maxY);
-      ctx.lineTo(avgX, minY);
-      ctx.lineTo(avgX, lastY);
-    }
-  };
-  if (move) {
-    point = points[pointIndex(0)];
-    ctx.moveTo(point.x, point.y);
-  }
-  for (i = 0; i <= ilen; ++i) {
-    point = points[pointIndex(i)];
-    if (point.skip) {
-      continue;
-    }
-    const x2 = point.x;
-    const y2 = point.y;
-    const truncX = x2 | 0;
-    if (truncX === prevX) {
-      if (y2 < minY) {
-        minY = y2;
-      } else if (y2 > maxY) {
-        maxY = y2;
-      }
-      avgX = (countX * avgX + x2) / ++countX;
-    } else {
-      drawX();
-      ctx.lineTo(x2, y2);
-      prevX = truncX;
-      countX = 0;
-      minY = maxY = y2;
-    }
-    lastY = y2;
-  }
-  drawX();
-}
-function _getSegmentMethod(line) {
-  const opts = line.options;
-  const borderDash = opts.borderDash && opts.borderDash.length;
-  const useFastPath = !line._decimated && !line._loop && !opts.tension && opts.cubicInterpolationMode !== "monotone" && !opts.stepped && !borderDash;
-  return useFastPath ? fastPathSegment : pathSegment;
-}
-function _getInterpolationMethod(options) {
-  if (options.stepped) {
-    return _steppedInterpolation;
-  }
-  if (options.tension || options.cubicInterpolationMode === "monotone") {
-    return _bezierInterpolation;
-  }
-  return _pointInLine;
-}
-function strokePathWithCache(ctx, line, start, count) {
-  let path = line._path;
-  if (!path) {
-    path = line._path = new Path2D();
-    if (line.path(path, start, count)) {
-      path.closePath();
-    }
-  }
-  setStyle(ctx, line.options);
-  ctx.stroke(path);
-}
-function strokePathDirect(ctx, line, start, count) {
-  const { segments, options } = line;
-  const segmentMethod = _getSegmentMethod(line);
-  for (const segment of segments) {
-    setStyle(ctx, options, segment.style);
-    ctx.beginPath();
-    if (segmentMethod(ctx, line, segment, {
-      start,
-      end: start + count - 1
-    })) {
-      ctx.closePath();
-    }
-    ctx.stroke();
-  }
-}
-const usePath2D = typeof Path2D === "function";
-function draw(ctx, line, start, count) {
-  if (usePath2D && !line.options.segment) {
-    strokePathWithCache(ctx, line, start, count);
-  } else {
-    strokePathDirect(ctx, line, start, count);
-  }
-}
-class LineElement extends Element$1 {
-  constructor(cfg) {
-    super();
-    this.animated = true;
-    this.options = void 0;
-    this._chart = void 0;
-    this._loop = void 0;
-    this._fullLoop = void 0;
-    this._path = void 0;
-    this._points = void 0;
-    this._segments = void 0;
-    this._decimated = false;
-    this._pointsUpdated = false;
-    this._datasetIndex = void 0;
-    if (cfg) {
-      Object.assign(this, cfg);
-    }
-  }
-  updateControlPoints(chartArea, indexAxis) {
-    const options = this.options;
-    if ((options.tension || options.cubicInterpolationMode === "monotone") && !options.stepped && !this._pointsUpdated) {
-      const loop = options.spanGaps ? this._loop : this._fullLoop;
-      _updateBezierControlPoints(this._points, options, chartArea, loop, indexAxis);
-      this._pointsUpdated = true;
-    }
-  }
-  set points(points) {
-    this._points = points;
-    delete this._segments;
-    delete this._path;
-    this._pointsUpdated = false;
-  }
-  get points() {
-    return this._points;
-  }
-  get segments() {
-    return this._segments || (this._segments = _computeSegments(this, this.options.segment));
-  }
-  first() {
-    const segments = this.segments;
-    const points = this.points;
-    return segments.length && points[segments[0].start];
-  }
-  last() {
-    const segments = this.segments;
-    const points = this.points;
-    const count = segments.length;
-    return count && points[segments[count - 1].end];
-  }
-  interpolate(point, property) {
-    const options = this.options;
-    const value = point[property];
-    const points = this.points;
-    const segments = _boundSegments(this, {
-      property,
-      start: value,
-      end: value
-    });
-    if (!segments.length) {
-      return;
-    }
-    const result = [];
-    const _interpolate = _getInterpolationMethod(options);
-    let i, ilen;
-    for (i = 0, ilen = segments.length; i < ilen; ++i) {
-      const { start, end } = segments[i];
-      const p1 = points[start];
-      const p2 = points[end];
-      if (p1 === p2) {
-        result.push(p1);
-        continue;
-      }
-      const t2 = Math.abs((value - p1[property]) / (p2[property] - p1[property]));
-      const interpolated = _interpolate(p1, p2, t2, options.stepped);
-      interpolated[property] = point[property];
-      result.push(interpolated);
-    }
-    return result.length === 1 ? result[0] : result;
-  }
-  pathSegment(ctx, segment, params) {
-    const segmentMethod = _getSegmentMethod(this);
-    return segmentMethod(ctx, this, segment, params);
-  }
-  path(ctx, start, count) {
-    const segments = this.segments;
-    const segmentMethod = _getSegmentMethod(this);
-    let loop = this._loop;
-    start = start || 0;
-    count = count || this.points.length - start;
-    for (const segment of segments) {
-      loop &= segmentMethod(ctx, this, segment, {
-        start,
-        end: start + count - 1
-      });
-    }
-    return !!loop;
-  }
-  draw(ctx, chartArea, start, count) {
-    const options = this.options || {};
-    const points = this.points || [];
-    if (points.length && options.borderWidth) {
-      ctx.save();
-      draw(ctx, this, start, count);
-      ctx.restore();
-    }
-    if (this.animated) {
-      this._pointsUpdated = false;
-      this._path = void 0;
-    }
-  }
-}
-__publicField(LineElement, "id", "line");
-__publicField(LineElement, "defaults", {
-  borderCapStyle: "butt",
-  borderDash: [],
-  borderDashOffset: 0,
-  borderJoinStyle: "miter",
-  borderWidth: 3,
-  capBezierPoints: true,
-  cubicInterpolationMode: "default",
-  fill: false,
-  spanGaps: false,
-  stepped: false,
-  tension: 0
-});
-__publicField(LineElement, "defaultRoutes", {
-  backgroundColor: "backgroundColor",
-  borderColor: "borderColor"
-});
-__publicField(LineElement, "descriptors", {
-  _scriptable: true,
-  _indexable: (name) => name !== "borderDash" && name !== "fill"
-});
-function inRange$1(el2, pos, axis, useFinalPosition) {
-  const options = el2.options;
-  const { [axis]: value } = el2.getProps([
-    axis
-  ], useFinalPosition);
-  return Math.abs(pos - value) < options.radius + options.hitRadius;
-}
-class PointElement extends Element$1 {
-  constructor(cfg) {
-    super();
-    __publicField(this, "parsed");
-    __publicField(this, "skip");
-    __publicField(this, "stop");
-    this.options = void 0;
-    this.parsed = void 0;
-    this.skip = void 0;
-    this.stop = void 0;
-    if (cfg) {
-      Object.assign(this, cfg);
-    }
-  }
-  inRange(mouseX, mouseY, useFinalPosition) {
-    const options = this.options;
-    const { x: x2, y: y2 } = this.getProps([
-      "x",
-      "y"
-    ], useFinalPosition);
-    return Math.pow(mouseX - x2, 2) + Math.pow(mouseY - y2, 2) < Math.pow(options.hitRadius + options.radius, 2);
-  }
-  inXRange(mouseX, useFinalPosition) {
-    return inRange$1(this, mouseX, "x", useFinalPosition);
-  }
-  inYRange(mouseY, useFinalPosition) {
-    return inRange$1(this, mouseY, "y", useFinalPosition);
-  }
-  getCenterPoint(useFinalPosition) {
-    const { x: x2, y: y2 } = this.getProps([
-      "x",
-      "y"
-    ], useFinalPosition);
-    return {
-      x: x2,
-      y: y2
-    };
-  }
-  size(options) {
-    options = options || this.options || {};
-    let radius = options.radius || 0;
-    radius = Math.max(radius, radius && options.hoverRadius || 0);
-    const borderWidth = radius && options.borderWidth || 0;
-    return (radius + borderWidth) * 2;
-  }
-  draw(ctx, area) {
-    const options = this.options;
-    if (this.skip || options.radius < 0.1 || !_isPointInArea(this, area, this.size(options) / 2)) {
-      return;
-    }
-    ctx.strokeStyle = options.borderColor;
-    ctx.lineWidth = options.borderWidth;
-    ctx.fillStyle = options.backgroundColor;
-    drawPoint(ctx, options, this.x, this.y);
-  }
-  getRange() {
-    const options = this.options || {};
-    return options.radius + options.hitRadius;
-  }
-}
-__publicField(PointElement, "id", "point");
-/**
-* @type {any}
-*/
-__publicField(PointElement, "defaults", {
-  borderWidth: 1,
-  hitRadius: 1,
-  hoverBorderWidth: 1,
-  hoverRadius: 4,
-  pointStyle: "circle",
-  radius: 3,
-  rotation: 0
-});
-/**
-* @type {any}
-*/
-__publicField(PointElement, "defaultRoutes", {
-  backgroundColor: "backgroundColor",
-  borderColor: "borderColor"
-});
-const getBoxSize = (labelOpts, fontSize) => {
-  let { boxHeight = fontSize, boxWidth = fontSize } = labelOpts;
-  if (labelOpts.usePointStyle) {
-    boxHeight = Math.min(boxHeight, fontSize);
-    boxWidth = labelOpts.pointStyleWidth || Math.min(boxWidth, fontSize);
-  }
-  return {
-    boxWidth,
-    boxHeight,
-    itemHeight: Math.max(fontSize, boxHeight)
-  };
-};
-const itemsEqual = (a, b) => a !== null && b !== null && a.datasetIndex === b.datasetIndex && a.index === b.index;
-class Legend extends Element$1 {
-  constructor(config) {
-    super();
-    this._added = false;
-    this.legendHitBoxes = [];
-    this._hoveredItem = null;
-    this.doughnutMode = false;
-    this.chart = config.chart;
-    this.options = config.options;
-    this.ctx = config.ctx;
-    this.legendItems = void 0;
-    this.columnSizes = void 0;
-    this.lineWidths = void 0;
-    this.maxHeight = void 0;
-    this.maxWidth = void 0;
-    this.top = void 0;
-    this.bottom = void 0;
-    this.left = void 0;
-    this.right = void 0;
-    this.height = void 0;
-    this.width = void 0;
-    this._margins = void 0;
-    this.position = void 0;
-    this.weight = void 0;
-    this.fullSize = void 0;
-  }
-  update(maxWidth, maxHeight, margins) {
-    this.maxWidth = maxWidth;
-    this.maxHeight = maxHeight;
-    this._margins = margins;
-    this.setDimensions();
-    this.buildLabels();
-    this.fit();
-  }
-  setDimensions() {
-    if (this.isHorizontal()) {
-      this.width = this.maxWidth;
-      this.left = this._margins.left;
-      this.right = this.width;
-    } else {
-      this.height = this.maxHeight;
-      this.top = this._margins.top;
-      this.bottom = this.height;
-    }
-  }
-  buildLabels() {
-    const labelOpts = this.options.labels || {};
-    let legendItems = callback(labelOpts.generateLabels, [
-      this.chart
-    ], this) || [];
-    if (labelOpts.filter) {
-      legendItems = legendItems.filter((item) => labelOpts.filter(item, this.chart.data));
-    }
-    if (labelOpts.sort) {
-      legendItems = legendItems.sort((a, b) => labelOpts.sort(a, b, this.chart.data));
-    }
-    if (this.options.reverse) {
-      legendItems.reverse();
-    }
-    this.legendItems = legendItems;
-  }
-  fit() {
-    const { options, ctx } = this;
-    if (!options.display) {
-      this.width = this.height = 0;
-      return;
-    }
-    const labelOpts = options.labels;
-    const labelFont = toFont(labelOpts.font);
-    const fontSize = labelFont.size;
-    const titleHeight = this._computeTitleHeight();
-    const { boxWidth, itemHeight } = getBoxSize(labelOpts, fontSize);
-    let width, height;
-    ctx.font = labelFont.string;
-    if (this.isHorizontal()) {
-      width = this.maxWidth;
-      height = this._fitRows(titleHeight, fontSize, boxWidth, itemHeight) + 10;
-    } else {
-      height = this.maxHeight;
-      width = this._fitCols(titleHeight, labelFont, boxWidth, itemHeight) + 10;
-    }
-    this.width = Math.min(width, options.maxWidth || this.maxWidth);
-    this.height = Math.min(height, options.maxHeight || this.maxHeight);
-  }
-  _fitRows(titleHeight, fontSize, boxWidth, itemHeight) {
-    const { ctx, maxWidth, options: { labels: { padding } } } = this;
-    const hitboxes = this.legendHitBoxes = [];
-    const lineWidths = this.lineWidths = [
-      0
-    ];
-    const lineHeight = itemHeight + padding;
-    let totalHeight = titleHeight;
-    ctx.textAlign = "left";
-    ctx.textBaseline = "middle";
-    let row = -1;
-    let top = -lineHeight;
-    this.legendItems.forEach((legendItem, i) => {
-      const itemWidth = boxWidth + fontSize / 2 + ctx.measureText(legendItem.text).width;
-      if (i === 0 || lineWidths[lineWidths.length - 1] + itemWidth + 2 * padding > maxWidth) {
-        totalHeight += lineHeight;
-        lineWidths[lineWidths.length - (i > 0 ? 0 : 1)] = 0;
-        top += lineHeight;
-        row++;
-      }
-      hitboxes[i] = {
-        left: 0,
-        top,
-        row,
-        width: itemWidth,
-        height: itemHeight
-      };
-      lineWidths[lineWidths.length - 1] += itemWidth + padding;
-    });
-    return totalHeight;
-  }
-  _fitCols(titleHeight, labelFont, boxWidth, _itemHeight) {
-    const { ctx, maxHeight, options: { labels: { padding } } } = this;
-    const hitboxes = this.legendHitBoxes = [];
-    const columnSizes = this.columnSizes = [];
-    const heightLimit = maxHeight - titleHeight;
-    let totalWidth = padding;
-    let currentColWidth = 0;
-    let currentColHeight = 0;
-    let left = 0;
-    let col = 0;
-    this.legendItems.forEach((legendItem, i) => {
-      const { itemWidth, itemHeight } = calculateItemSize(boxWidth, labelFont, ctx, legendItem, _itemHeight);
-      if (i > 0 && currentColHeight + itemHeight + 2 * padding > heightLimit) {
-        totalWidth += currentColWidth + padding;
-        columnSizes.push({
-          width: currentColWidth,
-          height: currentColHeight
-        });
-        left += currentColWidth + padding;
-        col++;
-        currentColWidth = currentColHeight = 0;
-      }
-      hitboxes[i] = {
-        left,
-        top: currentColHeight,
-        col,
-        width: itemWidth,
-        height: itemHeight
-      };
-      currentColWidth = Math.max(currentColWidth, itemWidth);
-      currentColHeight += itemHeight + padding;
-    });
-    totalWidth += currentColWidth;
-    columnSizes.push({
-      width: currentColWidth,
-      height: currentColHeight
-    });
-    return totalWidth;
-  }
-  adjustHitBoxes() {
-    if (!this.options.display) {
-      return;
-    }
-    const titleHeight = this._computeTitleHeight();
-    const { legendHitBoxes: hitboxes, options: { align, labels: { padding }, rtl } } = this;
-    const rtlHelper = getRtlAdapter(rtl, this.left, this.width);
-    if (this.isHorizontal()) {
-      let row = 0;
-      let left = _alignStartEnd(align, this.left + padding, this.right - this.lineWidths[row]);
-      for (const hitbox of hitboxes) {
-        if (row !== hitbox.row) {
-          row = hitbox.row;
-          left = _alignStartEnd(align, this.left + padding, this.right - this.lineWidths[row]);
-        }
-        hitbox.top += this.top + titleHeight + padding;
-        hitbox.left = rtlHelper.leftForLtr(rtlHelper.x(left), hitbox.width);
-        left += hitbox.width + padding;
-      }
-    } else {
-      let col = 0;
-      let top = _alignStartEnd(align, this.top + titleHeight + padding, this.bottom - this.columnSizes[col].height);
-      for (const hitbox of hitboxes) {
-        if (hitbox.col !== col) {
-          col = hitbox.col;
-          top = _alignStartEnd(align, this.top + titleHeight + padding, this.bottom - this.columnSizes[col].height);
-        }
-        hitbox.top = top;
-        hitbox.left += this.left + padding;
-        hitbox.left = rtlHelper.leftForLtr(rtlHelper.x(hitbox.left), hitbox.width);
-        top += hitbox.height + padding;
-      }
-    }
-  }
-  isHorizontal() {
-    return this.options.position === "top" || this.options.position === "bottom";
-  }
-  draw() {
-    if (this.options.display) {
-      const ctx = this.ctx;
-      clipArea(ctx, this);
-      this._draw();
-      unclipArea(ctx);
-    }
-  }
-  _draw() {
-    const { options: opts, columnSizes, lineWidths, ctx } = this;
-    const { align, labels: labelOpts } = opts;
-    const defaultColor = defaults.color;
-    const rtlHelper = getRtlAdapter(opts.rtl, this.left, this.width);
-    const labelFont = toFont(labelOpts.font);
-    const { padding } = labelOpts;
-    const fontSize = labelFont.size;
-    const halfFontSize = fontSize / 2;
-    let cursor;
-    this.drawTitle();
-    ctx.textAlign = rtlHelper.textAlign("left");
-    ctx.textBaseline = "middle";
-    ctx.lineWidth = 0.5;
-    ctx.font = labelFont.string;
-    const { boxWidth, boxHeight, itemHeight } = getBoxSize(labelOpts, fontSize);
-    const drawLegendBox = function(x2, y2, legendItem) {
-      if (isNaN(boxWidth) || boxWidth <= 0 || isNaN(boxHeight) || boxHeight < 0) {
-        return;
-      }
-      ctx.save();
-      const lineWidth = valueOrDefault(legendItem.lineWidth, 1);
-      ctx.fillStyle = valueOrDefault(legendItem.fillStyle, defaultColor);
-      ctx.lineCap = valueOrDefault(legendItem.lineCap, "butt");
-      ctx.lineDashOffset = valueOrDefault(legendItem.lineDashOffset, 0);
-      ctx.lineJoin = valueOrDefault(legendItem.lineJoin, "miter");
-      ctx.lineWidth = lineWidth;
-      ctx.strokeStyle = valueOrDefault(legendItem.strokeStyle, defaultColor);
-      ctx.setLineDash(valueOrDefault(legendItem.lineDash, []));
-      if (labelOpts.usePointStyle) {
-        const drawOptions = {
-          radius: boxHeight * Math.SQRT2 / 2,
-          pointStyle: legendItem.pointStyle,
-          rotation: legendItem.rotation,
-          borderWidth: lineWidth
-        };
-        const centerX = rtlHelper.xPlus(x2, boxWidth / 2);
-        const centerY = y2 + halfFontSize;
-        drawPointLegend(ctx, drawOptions, centerX, centerY, labelOpts.pointStyleWidth && boxWidth);
-      } else {
-        const yBoxTop = y2 + Math.max((fontSize - boxHeight) / 2, 0);
-        const xBoxLeft = rtlHelper.leftForLtr(x2, boxWidth);
-        const borderRadius = toTRBLCorners(legendItem.borderRadius);
-        ctx.beginPath();
-        if (Object.values(borderRadius).some((v2) => v2 !== 0)) {
-          addRoundedRectPath(ctx, {
-            x: xBoxLeft,
-            y: yBoxTop,
-            w: boxWidth,
-            h: boxHeight,
-            radius: borderRadius
-          });
-        } else {
-          ctx.rect(xBoxLeft, yBoxTop, boxWidth, boxHeight);
+      var require_calc29 = __commonJS({
+        "src/traces/scattergl/calc.js"(exports, module2) {
+          var cluster = require_point_cluster();
+          var Lib = require_lib();
+          var AxisIDs = require_axis_ids();
+          var findExtremes = require_autorange().findExtremes;
+          var alignPeriod = require_align_period();
+          var scatterCalc = require_calc3();
+          var calcMarkerSize = scatterCalc.calcMarkerSize;
+          var calcAxisExpansion = scatterCalc.calcAxisExpansion;
+          var setFirstScatter = scatterCalc.setFirstScatter;
+          var calcColorscale = require_colorscale_calc();
+          var convert = require_convert10();
+          var sceneUpdate = require_scene_update();
+          var BADNUM = require_numerical().BADNUM;
+          var TOO_MANY_POINTS = require_constants23().TOO_MANY_POINTS;
+          module2.exports = function calc(gd2, trace) {
+            var fullLayout = gd2._fullLayout;
+            var xa = trace._xA = AxisIDs.getFromId(gd2, trace.xaxis, "x");
+            var ya2 = trace._yA = AxisIDs.getFromId(gd2, trace.yaxis, "y");
+            var subplot = fullLayout._plots[trace.xaxis + trace.yaxis];
+            var len2 = trace._length;
+            var hasTooManyPoints = len2 >= TOO_MANY_POINTS;
+            var len22 = len2 * 2;
+            var stash = {};
+            var i2;
+            var origX = xa.makeCalcdata(trace, "x");
+            var origY = ya2.makeCalcdata(trace, "y");
+            var xObj = alignPeriod(trace, xa, "x", origX);
+            var yObj = alignPeriod(trace, ya2, "y", origY);
+            var x2 = xObj.vals;
+            var y2 = yObj.vals;
+            trace._x = x2;
+            trace._y = y2;
+            if (trace.xperiodalignment) {
+              trace._origX = origX;
+              trace._xStarts = xObj.starts;
+              trace._xEnds = xObj.ends;
+            }
+            if (trace.yperiodalignment) {
+              trace._origY = origY;
+              trace._yStarts = yObj.starts;
+              trace._yEnds = yObj.ends;
+            }
+            var positions = new Array(len22);
+            var _ids = new Array(len2);
+            for (i2 = 0; i2 < len2; i2++) {
+              positions[i2 * 2] = x2[i2] === BADNUM ? NaN : x2[i2];
+              positions[i2 * 2 + 1] = y2[i2] === BADNUM ? NaN : y2[i2];
+              _ids[i2] = i2;
+            }
+            if (xa.type === "log") {
+              for (i2 = 0; i2 < len22; i2 += 2) {
+                positions[i2] = xa.c2l(positions[i2]);
+              }
+            }
+            if (ya2.type === "log") {
+              for (i2 = 1; i2 < len22; i2 += 2) {
+                positions[i2] = ya2.c2l(positions[i2]);
+              }
+            }
+            if (hasTooManyPoints && (xa.type !== "log" && ya2.type !== "log")) {
+              stash.tree = cluster(positions);
+            } else {
+              stash.ids = _ids;
+            }
+            calcColorscale(gd2, trace);
+            var opts = sceneOptions(gd2, subplot, trace, positions, x2, y2);
+            var scene = sceneUpdate(gd2, subplot);
+            setFirstScatter(fullLayout, trace);
+            var ppad;
+            if (!hasTooManyPoints) {
+              ppad = calcMarkerSize(trace, len2);
+            } else if (opts.marker) {
+              ppad = opts.marker.sizeAvg || Math.max(opts.marker.size, 3);
+            }
+            calcAxisExpansion(gd2, trace, xa, ya2, x2, y2, ppad);
+            if (opts.errorX) expandForErrorBars(trace, xa, opts.errorX);
+            if (opts.errorY) expandForErrorBars(trace, ya2, opts.errorY);
+            if (opts.fill && !scene.fill2d) scene.fill2d = true;
+            if (opts.marker && !scene.scatter2d) scene.scatter2d = true;
+            if (opts.line && !scene.line2d) scene.line2d = true;
+            if ((opts.errorX || opts.errorY) && !scene.error2d) scene.error2d = true;
+            if (opts.text && !scene.glText) scene.glText = true;
+            if (opts.marker) opts.marker.snap = len2;
+            scene.lineOptions.push(opts.line);
+            scene.errorXOptions.push(opts.errorX);
+            scene.errorYOptions.push(opts.errorY);
+            scene.fillOptions.push(opts.fill);
+            scene.markerOptions.push(opts.marker);
+            scene.markerSelectedOptions.push(opts.markerSel);
+            scene.markerUnselectedOptions.push(opts.markerUnsel);
+            scene.textOptions.push(opts.text);
+            scene.textSelectedOptions.push(opts.textSel);
+            scene.textUnselectedOptions.push(opts.textUnsel);
+            scene.selectBatch.push([]);
+            scene.unselectBatch.push([]);
+            stash._scene = scene;
+            stash.index = scene.count;
+            stash.x = x2;
+            stash.y = y2;
+            stash.positions = positions;
+            scene.count++;
+            return [{ x: false, y: false, t: stash, trace }];
+          };
+          function expandForErrorBars(trace, ax, opts) {
+            var extremes = trace._extremes[ax._id];
+            var errExt = findExtremes(ax, opts._bnds, { padded: true });
+            extremes.min = extremes.min.concat(errExt.min);
+            extremes.max = extremes.max.concat(errExt.max);
+          }
+          function sceneOptions(gd2, subplot, trace, positions, x2, y2) {
+            var opts = convert.style(gd2, trace);
+            if (opts.marker) {
+              opts.marker.positions = positions;
+            }
+            if (opts.line && positions.length > 1) {
+              Lib.extendFlat(
+                opts.line,
+                convert.linePositions(gd2, trace, positions)
+              );
+            }
+            if (opts.errorX || opts.errorY) {
+              var errors = convert.errorBarPositions(gd2, trace, positions, x2, y2);
+              if (opts.errorX) {
+                Lib.extendFlat(opts.errorX, errors.x);
+              }
+              if (opts.errorY) {
+                Lib.extendFlat(opts.errorY, errors.y);
+              }
+            }
+            if (opts.text) {
+              Lib.extendFlat(
+                opts.text,
+                { positions },
+                convert.textPosition(gd2, trace, opts.text, opts.marker)
+              );
+              Lib.extendFlat(
+                opts.textSel,
+                { positions },
+                convert.textPosition(gd2, trace, opts.text, opts.markerSel)
+              );
+              Lib.extendFlat(
+                opts.textUnsel,
+                { positions },
+                convert.textPosition(gd2, trace, opts.text, opts.markerUnsel)
+              );
+            }
+            return opts;
+          }
+        }
+      });
+      var require_edit_style = __commonJS({
+        "src/traces/scattergl/edit_style.js"(exports, module2) {
+          var Lib = require_lib();
+          var Color2 = require_color();
+          var DESELECTDIM = require_interactions().DESELECTDIM;
+          function styleTextSelection(cd2) {
+            var cd0 = cd2[0];
+            var trace = cd0.trace;
+            var stash = cd0.t;
+            var scene = stash._scene;
+            var index = stash.index;
+            var els = scene.selectBatch[index];
+            var unels = scene.unselectBatch[index];
+            var baseOpts = scene.textOptions[index];
+            var selOpts = scene.textSelectedOptions[index] || {};
+            var unselOpts = scene.textUnselectedOptions[index] || {};
+            var opts = Lib.extendFlat({}, baseOpts);
+            var i2, j2;
+            if (els.length || unels.length) {
+              var stc = selOpts.color;
+              var utc = unselOpts.color;
+              var base = baseOpts.color;
+              var hasArrayBase = Lib.isArrayOrTypedArray(base);
+              opts.color = new Array(trace._length);
+              for (i2 = 0; i2 < els.length; i2++) {
+                j2 = els[i2];
+                opts.color[j2] = stc || (hasArrayBase ? base[j2] : base);
+              }
+              for (i2 = 0; i2 < unels.length; i2++) {
+                j2 = unels[i2];
+                var basej = hasArrayBase ? base[j2] : base;
+                opts.color[j2] = utc ? utc : stc ? basej : Color2.addOpacity(basej, DESELECTDIM);
+              }
+            }
+            scene.glText[index].update(opts);
+          }
+          module2.exports = {
+            styleTextSelection
+          };
+        }
+      });
+      var require_select7 = __commonJS({
+        "src/traces/scattergl/select.js"(exports, module2) {
+          var subTypes = require_subtypes();
+          var styleTextSelection = require_edit_style().styleTextSelection;
+          module2.exports = function select(searchInfo, selectionTester) {
+            var cd2 = searchInfo.cd;
+            var xa = searchInfo.xaxis;
+            var ya2 = searchInfo.yaxis;
+            var selection = [];
+            var trace = cd2[0].trace;
+            var stash = cd2[0].t;
+            var len2 = trace._length;
+            var x2 = stash.x;
+            var y2 = stash.y;
+            var scene = stash._scene;
+            var index = stash.index;
+            if (!scene) return selection;
+            var hasText = subTypes.hasText(trace);
+            var hasMarkers = subTypes.hasMarkers(trace);
+            var hasOnlyLines = !hasMarkers && !hasText;
+            if (trace.visible !== true || hasOnlyLines) return selection;
+            var els = [];
+            var unels = [];
+            if (selectionTester !== false && !selectionTester.degenerate) {
+              for (var i2 = 0; i2 < len2; i2++) {
+                if (selectionTester.contains([stash.xpx[i2], stash.ypx[i2]], false, i2, searchInfo)) {
+                  els.push(i2);
+                  selection.push({
+                    pointNumber: i2,
+                    x: xa.c2d(x2[i2]),
+                    y: ya2.c2d(y2[i2])
+                  });
+                } else {
+                  unels.push(i2);
+                }
+              }
+            }
+            if (hasMarkers) {
+              var scatter2d = scene.scatter2d;
+              if (!els.length && !unels.length) {
+                var baseOpts = new Array(scene.count);
+                baseOpts[index] = scene.markerOptions[index];
+                scatter2d.update.apply(scatter2d, baseOpts);
+              } else if (!scene.selectBatch[index].length && !scene.unselectBatch[index].length) {
+                var unselOpts = new Array(scene.count);
+                unselOpts[index] = scene.markerUnselectedOptions[index];
+                scatter2d.update.apply(scatter2d, unselOpts);
+              }
+            }
+            scene.selectBatch[index] = els;
+            scene.unselectBatch[index] = unels;
+            if (hasText) {
+              styleTextSelection(cd2);
+            }
+            return selection;
+          };
+        }
+      });
+      var require_base_index = __commonJS({
+        "src/traces/scattergl/base_index.js"(exports, module2) {
+          var hover = require_hover16();
+          module2.exports = {
+            moduleType: "trace",
+            name: "scattergl",
+            basePlotModule: require_cartesian(),
+            categories: ["gl", "regl", "cartesian", "symbols", "errorBarsOK", "showLegend", "scatter-like"],
+            attributes: require_attributes50(),
+            supplyDefaults: require_defaults46(),
+            crossTraceDefaults: require_cross_trace_defaults2(),
+            colorbar: require_marker_colorbar(),
+            formatLabels: require_format_labels4(),
+            calc: require_calc29(),
+            hoverPoints: hover.hoverPoints,
+            selectPoints: require_select7(),
+            meta: {}
+          };
+        }
+      });
+      var require_color_id = __commonJS({
+        "node_modules/color-id/index.js"(exports, module2) {
+          var clamp2 = require_clamp();
+          module2.exports = toNumber;
+          module2.exports.to = toNumber;
+          module2.exports.from = fromNumber;
+          function toNumber(rgba3, normalized) {
+            if (normalized == null) normalized = true;
+            var r2 = rgba3[0], g2 = rgba3[1], b2 = rgba3[2], a2 = rgba3[3];
+            if (a2 == null) a2 = normalized ? 1 : 255;
+            if (normalized) {
+              r2 *= 255;
+              g2 *= 255;
+              b2 *= 255;
+              a2 *= 255;
+            }
+            r2 = clamp2(r2, 0, 255) & 255;
+            g2 = clamp2(g2, 0, 255) & 255;
+            b2 = clamp2(b2, 0, 255) & 255;
+            a2 = clamp2(a2, 0, 255) & 255;
+            var n2 = r2 * 16777216 + (g2 << 16) + (b2 << 8) + a2;
+            return n2;
+          }
+          function fromNumber(n2, normalized) {
+            n2 = +n2;
+            var r2 = n2 >>> 24;
+            var g2 = (n2 & 16711680) >>> 16;
+            var b2 = (n2 & 65280) >>> 8;
+            var a2 = n2 & 255;
+            if (normalized === false) return [r2, g2, b2, a2];
+            return [r2 / 255, g2 / 255, b2 / 255, a2 / 255];
+          }
+        }
+      });
+      var require_object_assign = __commonJS({
+        "node_modules/object-assign/index.js"(exports, module2) {
+          var getOwnPropertySymbols = Object.getOwnPropertySymbols;
+          var hasOwnProperty2 = Object.prototype.hasOwnProperty;
+          var propIsEnumerable = Object.prototype.propertyIsEnumerable;
+          function toObject(val) {
+            if (val === null || val === void 0) {
+              throw new TypeError("Object.assign cannot be called with null or undefined");
+            }
+            return Object(val);
+          }
+          function shouldUseNative() {
+            try {
+              if (!Object.assign) {
+                return false;
+              }
+              var test1 = new String("abc");
+              test1[5] = "de";
+              if (Object.getOwnPropertyNames(test1)[0] === "5") {
+                return false;
+              }
+              var test2 = {};
+              for (var i2 = 0; i2 < 10; i2++) {
+                test2["_" + String.fromCharCode(i2)] = i2;
+              }
+              var order2 = Object.getOwnPropertyNames(test2).map(function(n2) {
+                return test2[n2];
+              });
+              if (order2.join("") !== "0123456789") {
+                return false;
+              }
+              var test3 = {};
+              "abcdefghijklmnopqrst".split("").forEach(function(letter) {
+                test3[letter] = letter;
+              });
+              if (Object.keys(Object.assign({}, test3)).join("") !== "abcdefghijklmnopqrst") {
+                return false;
+              }
+              return true;
+            } catch (err) {
+              return false;
+            }
+          }
+          module2.exports = shouldUseNative() ? Object.assign : function(target, source2) {
+            var from;
+            var to = toObject(target);
+            var symbols;
+            for (var s2 = 1; s2 < arguments.length; s2++) {
+              from = Object(arguments[s2]);
+              for (var key in from) {
+                if (hasOwnProperty2.call(from, key)) {
+                  to[key] = from[key];
+                }
+              }
+              if (getOwnPropertySymbols) {
+                symbols = getOwnPropertySymbols(from);
+                for (var i2 = 0; i2 < symbols.length; i2++) {
+                  if (propIsEnumerable.call(from, symbols[i2])) {
+                    to[symbols[i2]] = from[symbols[i2]];
+                  }
+                }
+              }
+            }
+            return to;
+          };
+        }
+      });
+      var require_browser3 = __commonJS({
+        "node_modules/glslify/browser.js"(exports, module2) {
+          module2.exports = function(strings) {
+            if (typeof strings === "string") strings = [strings];
+            var exprs = [].slice.call(arguments, 1);
+            var parts = [];
+            for (var i2 = 0; i2 < strings.length - 1; i2++) {
+              parts.push(strings[i2], exprs[i2] || "");
+            }
+            parts.push(strings[i2]);
+            return parts.join("");
+          };
+        }
+      });
+      var require_update_diff = __commonJS({
+        "node_modules/update-diff/index.js"(exports, module2) {
+          module2.exports = function updateDiff(obj, diff, mappers) {
+            if (!Array.isArray(mappers)) mappers = [].slice.call(arguments, 2);
+            for (var i2 = 0, l2 = mappers.length; i2 < l2; i2++) {
+              var dict = mappers[i2];
+              for (var prop in dict) {
+                if (diff[prop] !== void 0 && !Array.isArray(diff[prop]) && obj[prop] === diff[prop]) continue;
+                if (prop in diff) {
+                  var result;
+                  if (dict[prop] === true) result = diff[prop];
+                  else if (dict[prop] === false) continue;
+                  else if (typeof dict[prop] === "function") {
+                    result = dict[prop](diff[prop], obj, diff);
+                    if (result === void 0) continue;
+                  }
+                  obj[prop] = result;
+                }
+              }
+            }
+            return obj;
+          };
+        }
+      });
+      var require_is_iexplorer = __commonJS({
+        "node_modules/is-iexplorer/index.js"(exports, module2) {
+          module2.exports = typeof navigator !== "undefined" && (/MSIE/.test(navigator.userAgent) || /Trident\//.test(navigator.appVersion));
+        }
+      });
+      var require_to_float32 = __commonJS({
+        "node_modules/to-float32/index.js"(exports, module2) {
+          module2.exports = float322;
+          module2.exports.float32 = module2.exports.float = float322;
+          module2.exports.fract32 = module2.exports.fract = fract32;
+          var narr = new Float32Array(1);
+          function fract32(arr, fract) {
+            if (arr.length) {
+              if (arr instanceof Float32Array) return new Float32Array(arr.length);
+              if (!(fract instanceof Float32Array)) fract = float322(arr);
+              for (var i2 = 0, l2 = fract.length; i2 < l2; i2++) {
+                fract[i2] = arr[i2] - fract[i2];
+              }
+              return fract;
+            }
+            return float322(arr - float322(arr));
+          }
+          function float322(arr) {
+            if (arr.length) {
+              if (arr instanceof Float32Array) return arr;
+              return new Float32Array(arr);
+            }
+            narr[0] = arr;
+            return narr[0];
+          }
+        }
+      });
+      var require_bundle = __commonJS({
+        "node_modules/regl-scatter2d/bundle.js"(exports, module2) {
+          function _iterableToArrayLimit(arr, i2) {
+            var _i = null == arr ? null : "undefined" != typeof Symbol && arr[Symbol.iterator] || arr["@@iterator"];
+            if (null != _i) {
+              var _s2, _e2, _x2, _r2, _arr = [], _n = true, _d2 = false;
+              try {
+                if (_x2 = (_i = _i.call(arr)).next, 0 === i2) ;
+                else for (; !(_n = (_s2 = _x2.call(_i)).done) && (_arr.push(_s2.value), _arr.length !== i2); _n = true) ;
+              } catch (err) {
+                _d2 = true, _e2 = err;
+              } finally {
+                try {
+                  if (!_n && null != _i.return && (_r2 = _i.return(), Object(_r2) !== _r2)) return;
+                } finally {
+                  if (_d2) throw _e2;
+                }
+              }
+              return _arr;
+            }
+          }
+          function _slicedToArray(arr, i2) {
+            return _arrayWithHoles(arr) || _iterableToArrayLimit(arr, i2) || _unsupportedIterableToArray(arr, i2) || _nonIterableRest();
+          }
+          function _toConsumableArray(arr) {
+            return _arrayWithoutHoles(arr) || _iterableToArray(arr) || _unsupportedIterableToArray(arr) || _nonIterableSpread();
+          }
+          function _arrayWithoutHoles(arr) {
+            if (Array.isArray(arr)) return _arrayLikeToArray(arr);
+          }
+          function _arrayWithHoles(arr) {
+            if (Array.isArray(arr)) return arr;
+          }
+          function _iterableToArray(iter) {
+            if (typeof Symbol !== "undefined" && iter[Symbol.iterator] != null || iter["@@iterator"] != null) return Array.from(iter);
+          }
+          function _unsupportedIterableToArray(o2, minLen) {
+            if (!o2) return;
+            if (typeof o2 === "string") return _arrayLikeToArray(o2, minLen);
+            var n2 = Object.prototype.toString.call(o2).slice(8, -1);
+            if (n2 === "Object" && o2.constructor) n2 = o2.constructor.name;
+            if (n2 === "Map" || n2 === "Set") return Array.from(o2);
+            if (n2 === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n2)) return _arrayLikeToArray(o2, minLen);
+          }
+          function _arrayLikeToArray(arr, len2) {
+            if (len2 == null || len2 > arr.length) len2 = arr.length;
+            for (var i2 = 0, arr2 = new Array(len2); i2 < len2; i2++) arr2[i2] = arr[i2];
+            return arr2;
+          }
+          function _nonIterableSpread() {
+            throw new TypeError("Invalid attempt to spread non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
+          }
+          function _nonIterableRest() {
+            throw new TypeError("Invalid attempt to destructure non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
+          }
+          var rgba3 = require_color_normalize();
+          var getBounds2 = require_array_bounds();
+          var colorId = require_color_id();
+          var cluster = require_point_cluster();
+          var extend2 = require_object_assign();
+          var glslify = require_browser3();
+          var pick = require_pick_by_alias();
+          var updateDiff = require_update_diff();
+          var flatten2 = require_flatten_vertex_data();
+          var ie2 = require_is_iexplorer();
+          var f32 = require_to_float32();
+          var parseRect = require_parse_rect();
+          var scatter = Scatter;
+          function Scatter(regl, options) {
+            var _this = this;
+            if (!(this instanceof Scatter)) return new Scatter(regl, options);
+            if (typeof regl === "function") {
+              if (!options) options = {};
+              options.regl = regl;
+            } else {
+              options = regl;
+              regl = null;
+            }
+            if (options && options.length) options.positions = options;
+            regl = options.regl;
+            var gl2 = regl._gl, paletteTexture, palette = [], paletteIds = {}, groups = [], markerTextures = [null], markerCache = [null];
+            var maxColors = 255, maxSize = 100;
+            this.tooManyColors = ie2;
+            paletteTexture = regl.texture({
+              data: new Uint8Array(maxColors * 4),
+              width: maxColors,
+              height: 1,
+              type: "uint8",
+              format: "rgba",
+              wrapS: "clamp",
+              wrapT: "clamp",
+              mag: "nearest",
+              min: "nearest"
+            });
+            extend2(this, {
+              regl,
+              gl: gl2,
+              groups,
+              markerCache,
+              markerTextures,
+              palette,
+              paletteIds,
+              paletteTexture,
+              maxColors,
+              maxSize,
+              canvas: gl2.canvas
+            });
+            this.update(options);
+            var shaderOptions = {
+              uniforms: {
+                constPointSize: !!options.constPointSize,
+                opacity: regl.prop("opacity"),
+                paletteSize: function paletteSize(ctx2, prop) {
+                  return [_this.tooManyColors ? 0 : maxColors, paletteTexture.height];
+                },
+                pixelRatio: regl.context("pixelRatio"),
+                scale: regl.prop("scale"),
+                scaleFract: regl.prop("scaleFract"),
+                translate: regl.prop("translate"),
+                translateFract: regl.prop("translateFract"),
+                markerTexture: regl.prop("markerTexture"),
+                paletteTexture
+              },
+              attributes: {
+                // FIXME: optimize these parts
+                x: function x2(ctx2, prop) {
+                  return prop.xAttr || {
+                    buffer: prop.positionBuffer,
+                    stride: 8,
+                    offset: 0
+                  };
+                },
+                y: function y2(ctx2, prop) {
+                  return prop.yAttr || {
+                    buffer: prop.positionBuffer,
+                    stride: 8,
+                    offset: 4
+                  };
+                },
+                xFract: function xFract(ctx2, prop) {
+                  return prop.xAttr ? {
+                    constant: [0, 0]
+                  } : {
+                    buffer: prop.positionFractBuffer,
+                    stride: 8,
+                    offset: 0
+                  };
+                },
+                yFract: function yFract(ctx2, prop) {
+                  return prop.yAttr ? {
+                    constant: [0, 0]
+                  } : {
+                    buffer: prop.positionFractBuffer,
+                    stride: 8,
+                    offset: 4
+                  };
+                },
+                size: function size(ctx2, prop) {
+                  return prop.size.length ? {
+                    buffer: prop.sizeBuffer,
+                    stride: 2,
+                    offset: 0
+                  } : {
+                    constant: [Math.round(prop.size * 255 / _this.maxSize)]
+                  };
+                },
+                borderSize: function borderSize(ctx2, prop) {
+                  return prop.borderSize.length ? {
+                    buffer: prop.sizeBuffer,
+                    stride: 2,
+                    offset: 1
+                  } : {
+                    constant: [Math.round(prop.borderSize * 255 / _this.maxSize)]
+                  };
+                },
+                colorId: function colorId2(ctx2, prop) {
+                  return prop.color.length ? {
+                    buffer: prop.colorBuffer,
+                    stride: _this.tooManyColors ? 8 : 4,
+                    offset: 0
+                  } : {
+                    constant: _this.tooManyColors ? palette.slice(prop.color * 4, prop.color * 4 + 4) : [prop.color]
+                  };
+                },
+                borderColorId: function borderColorId(ctx2, prop) {
+                  return prop.borderColor.length ? {
+                    buffer: prop.colorBuffer,
+                    stride: _this.tooManyColors ? 8 : 4,
+                    offset: _this.tooManyColors ? 4 : 2
+                  } : {
+                    constant: _this.tooManyColors ? palette.slice(prop.borderColor * 4, prop.borderColor * 4 + 4) : [prop.borderColor]
+                  };
+                },
+                isActive: function isActive(ctx2, prop) {
+                  return prop.activation === true ? {
+                    constant: [1]
+                  } : prop.activation ? prop.activation : {
+                    constant: [0]
+                  };
+                }
+              },
+              blend: {
+                enable: true,
+                color: [0, 0, 0, 1],
+                // photoshop blending
+                func: {
+                  srcRGB: "src alpha",
+                  dstRGB: "one minus src alpha",
+                  srcAlpha: "one minus dst alpha",
+                  dstAlpha: "one"
+                }
+              },
+              scissor: {
+                enable: true,
+                box: regl.prop("viewport")
+              },
+              viewport: regl.prop("viewport"),
+              stencil: {
+                enable: false
+              },
+              depth: {
+                enable: false
+              },
+              elements: regl.prop("elements"),
+              count: regl.prop("count"),
+              offset: regl.prop("offset"),
+              primitive: "points"
+            };
+            var markerOptions = extend2({}, shaderOptions);
+            markerOptions.frag = glslify(["precision highp float;\n#define GLSLIFY 1\n\nuniform float opacity;\nuniform sampler2D markerTexture;\n\nvarying vec4 fragColor, fragBorderColor;\nvarying float fragWidth, fragBorderColorLevel, fragColorLevel;\n\nfloat smoothStep(float x, float y) {\n  return 1.0 / (1.0 + exp(50.0*(x - y)));\n}\n\nvoid main() {\n  float dist = texture2D(markerTexture, gl_PointCoord).r, delta = fragWidth;\n\n  // max-distance alpha\n  if (dist < 0.003) discard;\n\n  // null-border case\n  if (fragBorderColorLevel == fragColorLevel || fragBorderColor.a == 0.) {\n    float colorAmt = smoothstep(.5 - delta, .5 + delta, dist);\n    gl_FragColor = vec4(fragColor.rgb, colorAmt * fragColor.a * opacity);\n  }\n  else {\n    float borderColorAmt = smoothstep(fragBorderColorLevel - delta, fragBorderColorLevel + delta, dist);\n    float colorAmt = smoothstep(fragColorLevel - delta, fragColorLevel + delta, dist);\n\n    vec4 color = fragBorderColor;\n    color.a *= borderColorAmt;\n    color = mix(color, fragColor, colorAmt);\n    color.a *= opacity;\n\n    gl_FragColor = color;\n  }\n\n}\n"]);
+            markerOptions.vert = glslify(["precision highp float;\n#define GLSLIFY 1\n\nattribute float x, y, xFract, yFract;\nattribute float size, borderSize;\nattribute vec4 colorId, borderColorId;\nattribute float isActive;\n\n// `invariant` effectively turns off optimizations for the position.\n// We need this because -fast-math on M1 Macs is re-ordering\n// floating point operations in a way that causes floating point\n// precision limits to put points in the wrong locations.\ninvariant gl_Position;\n\nuniform bool constPointSize;\nuniform float pixelRatio;\nuniform vec2 scale, scaleFract, translate, translateFract, paletteSize;\nuniform sampler2D paletteTexture;\n\nconst float maxSize = 100.;\nconst float borderLevel = .5;\n\nvarying vec4 fragColor, fragBorderColor;\nvarying float fragPointSize, fragBorderRadius, fragWidth, fragBorderColorLevel, fragColorLevel;\n\nfloat pointSizeScale = (constPointSize) ? 2. : pixelRatio;\n\nbool isDirect = (paletteSize.x < 1.);\n\nvec4 getColor(vec4 id) {\n  return isDirect ? id / 255. : texture2D(paletteTexture,\n    vec2(\n      (id.x + .5) / paletteSize.x,\n      (id.y + .5) / paletteSize.y\n    )\n  );\n}\n\nvoid main() {\n  // ignore inactive points\n  if (isActive == 0.) return;\n\n  vec2 position = vec2(x, y);\n  vec2 positionFract = vec2(xFract, yFract);\n\n  vec4 color = getColor(colorId);\n  vec4 borderColor = getColor(borderColorId);\n\n  float size = size * maxSize / 255.;\n  float borderSize = borderSize * maxSize / 255.;\n\n  gl_PointSize = 2. * size * pointSizeScale;\n  fragPointSize = size * pixelRatio;\n\n  vec2 pos = (position + translate) * scale\n      + (positionFract + translateFract) * scale\n      + (position + translate) * scaleFract\n      + (positionFract + translateFract) * scaleFract;\n\n  gl_Position = vec4(pos * 2. - 1., 0., 1.);\n\n  fragColor = color;\n  fragBorderColor = borderColor;\n  fragWidth = 1. / gl_PointSize;\n\n  fragBorderColorLevel = clamp(borderLevel - borderLevel * borderSize / size, 0., 1.);\n  fragColorLevel = clamp(borderLevel + (1. - borderLevel) * borderSize / size, 0., 1.);\n}\n"]);
+            this.drawMarker = regl(markerOptions);
+            var circleOptions = extend2({}, shaderOptions);
+            circleOptions.frag = glslify(["precision highp float;\n#define GLSLIFY 1\n\nvarying vec4 fragColor, fragBorderColor;\nvarying float fragBorderRadius, fragWidth;\n\nuniform float opacity;\n\nfloat smoothStep(float edge0, float edge1, float x) {\n	float t;\n	t = clamp((x - edge0) / (edge1 - edge0), 0.0, 1.0);\n	return t * t * (3.0 - 2.0 * t);\n}\n\nvoid main() {\n	float radius, alpha = 1.0, delta = fragWidth;\n\n	radius = length(2.0 * gl_PointCoord.xy - 1.0);\n\n	if (radius > 1.0 + delta) {\n		discard;\n	}\n\n	alpha -= smoothstep(1.0 - delta, 1.0 + delta, radius);\n\n	float borderRadius = fragBorderRadius;\n	float ratio = smoothstep(borderRadius - delta, borderRadius + delta, radius);\n	vec4 color = mix(fragColor, fragBorderColor, ratio);\n	color.a *= alpha * opacity;\n	gl_FragColor = color;\n}\n"]);
+            circleOptions.vert = glslify(["precision highp float;\n#define GLSLIFY 1\n\nattribute float x, y, xFract, yFract;\nattribute float size, borderSize;\nattribute vec4 colorId, borderColorId;\nattribute float isActive;\n\n// `invariant` effectively turns off optimizations for the position.\n// We need this because -fast-math on M1 Macs is re-ordering\n// floating point operations in a way that causes floating point\n// precision limits to put points in the wrong locations.\ninvariant gl_Position;\n\nuniform bool constPointSize;\nuniform float pixelRatio;\nuniform vec2 paletteSize, scale, scaleFract, translate, translateFract;\nuniform sampler2D paletteTexture;\n\nconst float maxSize = 100.;\n\nvarying vec4 fragColor, fragBorderColor;\nvarying float fragBorderRadius, fragWidth;\n\nfloat pointSizeScale = (constPointSize) ? 2. : pixelRatio;\n\nbool isDirect = (paletteSize.x < 1.);\n\nvec4 getColor(vec4 id) {\n  return isDirect ? id / 255. : texture2D(paletteTexture,\n    vec2(\n      (id.x + .5) / paletteSize.x,\n      (id.y + .5) / paletteSize.y\n    )\n  );\n}\n\nvoid main() {\n  // ignore inactive points\n  if (isActive == 0.) return;\n\n  vec2 position = vec2(x, y);\n  vec2 positionFract = vec2(xFract, yFract);\n\n  vec4 color = getColor(colorId);\n  vec4 borderColor = getColor(borderColorId);\n\n  float size = size * maxSize / 255.;\n  float borderSize = borderSize * maxSize / 255.;\n\n  gl_PointSize = (size + borderSize) * pointSizeScale;\n\n  vec2 pos = (position + translate) * scale\n      + (positionFract + translateFract) * scale\n      + (position + translate) * scaleFract\n      + (positionFract + translateFract) * scaleFract;\n\n  gl_Position = vec4(pos * 2. - 1., 0., 1.);\n\n  fragBorderRadius = 1. - 2. * borderSize / (size + borderSize);\n  fragColor = color;\n  fragBorderColor = borderColor.a == 0. || borderSize == 0. ? vec4(color.rgb, 0.) : borderColor;\n  fragWidth = 1. / gl_PointSize;\n}\n"]);
+            if (ie2) {
+              circleOptions.frag = circleOptions.frag.replace("smoothstep", "smoothStep");
+              markerOptions.frag = markerOptions.frag.replace("smoothstep", "smoothStep");
+            }
+            this.drawCircle = regl(circleOptions);
+          }
+          Scatter.defaults = {
+            color: "black",
+            borderColor: "transparent",
+            borderSize: 0,
+            size: 12,
+            opacity: 1,
+            marker: void 0,
+            viewport: null,
+            range: null,
+            pixelSize: null,
+            count: 0,
+            offset: 0,
+            bounds: null,
+            positions: [],
+            snap: 1e4
+          };
+          Scatter.prototype.render = function() {
+            if (arguments.length) {
+              this.update.apply(this, arguments);
+            }
+            this.draw();
+            return this;
+          };
+          Scatter.prototype.draw = function() {
+            var _this2 = this;
+            for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
+              args[_key] = arguments[_key];
+            }
+            var groups = this.groups;
+            if (args.length === 1 && Array.isArray(args[0]) && (args[0][0] === null || Array.isArray(args[0][0]))) {
+              args = args[0];
+            }
+            this.regl._refresh();
+            if (args.length) {
+              for (var i2 = 0; i2 < args.length; i2++) {
+                this.drawItem(i2, args[i2]);
+              }
+            } else {
+              groups.forEach(function(group, i22) {
+                _this2.drawItem(i22);
+              });
+            }
+            return this;
+          };
+          Scatter.prototype.drawItem = function(id2, els) {
+            var groups = this.groups;
+            var group = groups[id2];
+            if (typeof els === "number") {
+              id2 = els;
+              group = groups[els];
+              els = null;
+            }
+            if (!(group && group.count && group.opacity)) return;
+            if (group.activation[0]) {
+              this.drawCircle(this.getMarkerDrawOptions(0, group, els));
+            }
+            var batch = [];
+            for (var i2 = 1; i2 < group.activation.length; i2++) {
+              if (!group.activation[i2] || group.activation[i2] !== true && !group.activation[i2].data.length) continue;
+              batch.push.apply(batch, _toConsumableArray(this.getMarkerDrawOptions(i2, group, els)));
+            }
+            if (batch.length) {
+              this.drawMarker(batch);
+            }
+          };
+          Scatter.prototype.getMarkerDrawOptions = function(markerId, group, elements) {
+            var range = group.range, tree = group.tree, viewport = group.viewport, activation = group.activation, selectionBuffer = group.selectionBuffer, count2 = group.count;
+            this.regl;
+            if (!tree) {
+              if (elements) {
+                return [extend2({}, group, {
+                  markerTexture: this.markerTextures[markerId],
+                  activation: activation[markerId],
+                  count: elements.length,
+                  elements,
+                  offset: 0
+                })];
+              }
+              return [extend2({}, group, {
+                markerTexture: this.markerTextures[markerId],
+                activation: activation[markerId],
+                offset: 0
+              })];
+            }
+            var batch = [];
+            var lod = tree.range(range, {
+              lod: true,
+              px: [(range[2] - range[0]) / viewport.width, (range[3] - range[1]) / viewport.height]
+            });
+            if (elements) {
+              var markerActivation = activation[markerId];
+              var mask = markerActivation.data;
+              var data = new Uint8Array(count2);
+              for (var i2 = 0; i2 < elements.length; i2++) {
+                var id2 = elements[i2];
+                data[id2] = mask ? mask[id2] : 1;
+              }
+              selectionBuffer.subdata(data);
+            }
+            for (var l2 = lod.length; l2--; ) {
+              var _lod$l = _slicedToArray(lod[l2], 2), from = _lod$l[0], to = _lod$l[1];
+              batch.push(extend2({}, group, {
+                markerTexture: this.markerTextures[markerId],
+                activation: elements ? selectionBuffer : activation[markerId],
+                offset: from,
+                count: to - from
+              }));
+            }
+            return batch;
+          };
+          Scatter.prototype.update = function() {
+            var _this3 = this;
+            for (var _len2 = arguments.length, args = new Array(_len2), _key2 = 0; _key2 < _len2; _key2++) {
+              args[_key2] = arguments[_key2];
+            }
+            if (!args.length) return;
+            if (args.length === 1 && Array.isArray(args[0])) args = args[0];
+            var groups = this.groups, gl2 = this.gl, regl = this.regl, maxSize = this.maxSize, maxColors = this.maxColors, palette = this.palette;
+            this.groups = groups = args.map(function(options, i2) {
+              var group = groups[i2];
+              if (options === void 0) return group;
+              if (options === null) options = {
+                positions: null
+              };
+              else if (typeof options === "function") options = {
+                ondraw: options
+              };
+              else if (typeof options[0] === "number") options = {
+                positions: options
+              };
+              options = pick(options, {
+                positions: "positions data points",
+                snap: "snap cluster lod tree",
+                size: "sizes size radius",
+                borderSize: "borderSizes borderSize border-size bordersize borderWidth borderWidths border-width borderwidth stroke-width strokeWidth strokewidth outline",
+                color: "colors color fill fill-color fillColor",
+                borderColor: "borderColors borderColor stroke stroke-color strokeColor",
+                marker: "markers marker shape",
+                range: "range dataBox databox",
+                viewport: "viewport viewPort viewBox viewbox",
+                opacity: "opacity alpha transparency",
+                bounds: "bound bounds boundaries limits",
+                tooManyColors: "tooManyColors palette paletteMode optimizePalette enablePalette"
+              });
+              if (options.positions === null) options.positions = [];
+              if (options.tooManyColors != null) _this3.tooManyColors = options.tooManyColors;
+              if (!group) {
+                groups[i2] = group = {
+                  id: i2,
+                  scale: null,
+                  translate: null,
+                  scaleFract: null,
+                  translateFract: null,
+                  // buffers for active markers
+                  activation: [],
+                  // buffer for filtered markers
+                  selectionBuffer: regl.buffer({
+                    data: new Uint8Array(0),
+                    usage: "stream",
+                    type: "uint8"
+                  }),
+                  // buffers with data: it is faster to switch them per-pass
+                  // than provide one congregate buffer
+                  sizeBuffer: regl.buffer({
+                    data: new Uint8Array(0),
+                    usage: "dynamic",
+                    type: "uint8"
+                  }),
+                  colorBuffer: regl.buffer({
+                    data: new Uint8Array(0),
+                    usage: "dynamic",
+                    type: "uint8"
+                  }),
+                  positionBuffer: regl.buffer({
+                    data: new Uint8Array(0),
+                    usage: "dynamic",
+                    type: "float"
+                  }),
+                  positionFractBuffer: regl.buffer({
+                    data: new Uint8Array(0),
+                    usage: "dynamic",
+                    type: "float"
+                  })
+                };
+                options = extend2({}, Scatter.defaults, options);
+              }
+              if (options.positions && !("marker" in options)) {
+                options.marker = group.marker;
+                delete group.marker;
+              }
+              if (options.marker && !("positions" in options)) {
+                options.positions = group.positions;
+                delete group.positions;
+              }
+              var hasSize = 0, hasColor = 0;
+              updateDiff(group, options, [{
+                snap: true,
+                size: function size2(s2, group2) {
+                  if (s2 == null) s2 = Scatter.defaults.size;
+                  hasSize += s2 && s2.length ? 1 : 0;
+                  return s2;
+                },
+                borderSize: function borderSize2(s2, group2) {
+                  if (s2 == null) s2 = Scatter.defaults.borderSize;
+                  hasSize += s2 && s2.length ? 1 : 0;
+                  return s2;
+                },
+                opacity: parseFloat,
+                // add colors to palette, save references
+                color: function color3(c2, group2) {
+                  if (c2 == null) c2 = Scatter.defaults.color;
+                  c2 = _this3.updateColor(c2);
+                  hasColor++;
+                  return c2;
+                },
+                borderColor: function borderColor2(c2, group2) {
+                  if (c2 == null) c2 = Scatter.defaults.borderColor;
+                  c2 = _this3.updateColor(c2);
+                  hasColor++;
+                  return c2;
+                },
+                bounds: function bounds(_bounds, group2, options2) {
+                  if (!("range" in options2)) options2.range = null;
+                  return _bounds;
+                },
+                positions: function positions(_positions, group2, options2) {
+                  var snap = group2.snap;
+                  var positionBuffer = group2.positionBuffer, positionFractBuffer = group2.positionFractBuffer, selectionBuffer = group2.selectionBuffer;
+                  if (_positions.x || _positions.y) {
+                    if (_positions.x.length) {
+                      group2.xAttr = {
+                        buffer: regl.buffer(_positions.x),
+                        offset: 0,
+                        stride: 4,
+                        count: _positions.x.length
+                      };
+                    } else {
+                      group2.xAttr = {
+                        buffer: _positions.x.buffer,
+                        offset: _positions.x.offset * 4 || 0,
+                        stride: (_positions.x.stride || 1) * 4,
+                        count: _positions.x.count
+                      };
+                    }
+                    if (_positions.y.length) {
+                      group2.yAttr = {
+                        buffer: regl.buffer(_positions.y),
+                        offset: 0,
+                        stride: 4,
+                        count: _positions.y.length
+                      };
+                    } else {
+                      group2.yAttr = {
+                        buffer: _positions.y.buffer,
+                        offset: _positions.y.offset * 4 || 0,
+                        stride: (_positions.y.stride || 1) * 4,
+                        count: _positions.y.count
+                      };
+                    }
+                    group2.count = Math.max(group2.xAttr.count, group2.yAttr.count);
+                    return _positions;
+                  }
+                  _positions = flatten2(_positions, "float64");
+                  var count22 = group2.count = Math.floor(_positions.length / 2);
+                  var bounds = group2.bounds = count22 ? getBounds2(_positions, 2) : null;
+                  if (!options2.range && !group2.range) {
+                    delete group2.range;
+                    options2.range = bounds;
+                  }
+                  if (!options2.marker && !group2.marker) {
+                    delete group2.marker;
+                    options2.marker = null;
+                  }
+                  if (snap && (snap === true || count22 > snap)) {
+                    group2.tree = cluster(_positions, {
+                      bounds
+                    });
+                  } else if (snap && snap.length) {
+                    group2.tree = snap;
+                  }
+                  if (group2.tree) {
+                    var opts = {
+                      primitive: "points",
+                      usage: "static",
+                      data: group2.tree,
+                      type: "uint32"
+                    };
+                    if (group2.elements) group2.elements(opts);
+                    else group2.elements = regl.elements(opts);
+                  }
+                  var float_data = f32.float32(_positions);
+                  positionBuffer({
+                    data: float_data,
+                    usage: "dynamic"
+                  });
+                  var frac_data = f32.fract32(_positions, float_data);
+                  positionFractBuffer({
+                    data: frac_data,
+                    usage: "dynamic"
+                  });
+                  selectionBuffer({
+                    data: new Uint8Array(count22),
+                    type: "uint8",
+                    usage: "stream"
+                  });
+                  return _positions;
+                }
+              }, {
+                // create marker ids corresponding to known marker textures
+                marker: function marker(markers, group2, options2) {
+                  var activation = group2.activation;
+                  activation.forEach(function(buffer) {
+                    return buffer && buffer.destroy && buffer.destroy();
+                  });
+                  activation.length = 0;
+                  if (!markers || typeof markers[0] === "number") {
+                    var id2 = _this3.addMarker(markers);
+                    activation[id2] = true;
+                  } else {
+                    var markerMasks = [];
+                    for (var _i = 0, l2 = Math.min(markers.length, group2.count); _i < l2; _i++) {
+                      var _id = _this3.addMarker(markers[_i]);
+                      if (!markerMasks[_id]) markerMasks[_id] = new Uint8Array(group2.count);
+                      markerMasks[_id][_i] = 1;
+                    }
+                    for (var _id2 = 0; _id2 < markerMasks.length; _id2++) {
+                      if (!markerMasks[_id2]) continue;
+                      var opts = {
+                        data: markerMasks[_id2],
+                        type: "uint8",
+                        usage: "static"
+                      };
+                      if (!activation[_id2]) {
+                        activation[_id2] = regl.buffer(opts);
+                      } else {
+                        activation[_id2](opts);
+                      }
+                      activation[_id2].data = markerMasks[_id2];
+                    }
+                  }
+                  return markers;
+                },
+                range: function range(_range, group2, options2) {
+                  var bounds = group2.bounds;
+                  if (!bounds) return;
+                  if (!_range) _range = bounds;
+                  group2.scale = [1 / (_range[2] - _range[0]), 1 / (_range[3] - _range[1])];
+                  group2.translate = [-_range[0], -_range[1]];
+                  group2.scaleFract = f32.fract(group2.scale);
+                  group2.translateFract = f32.fract(group2.translate);
+                  return _range;
+                },
+                viewport: function viewport(vp) {
+                  var rect = parseRect(vp || [gl2.drawingBufferWidth, gl2.drawingBufferHeight]);
+                  return rect;
+                }
+              }]);
+              if (hasSize) {
+                var _group = group, count2 = _group.count, size = _group.size, borderSize = _group.borderSize, sizeBuffer = _group.sizeBuffer;
+                var sizes = new Uint8Array(count2 * 2);
+                if (size.length || borderSize.length) {
+                  for (var _i2 = 0; _i2 < count2; _i2++) {
+                    sizes[_i2 * 2] = Math.round((size[_i2] == null ? size : size[_i2]) * 255 / maxSize);
+                    sizes[_i2 * 2 + 1] = Math.round((borderSize[_i2] == null ? borderSize : borderSize[_i2]) * 255 / maxSize);
+                  }
+                }
+                sizeBuffer({
+                  data: sizes,
+                  usage: "dynamic"
+                });
+              }
+              if (hasColor) {
+                var _group2 = group, _count = _group2.count, color22 = _group2.color, borderColor = _group2.borderColor, colorBuffer = _group2.colorBuffer;
+                var colors;
+                if (_this3.tooManyColors) {
+                  if (color22.length || borderColor.length) {
+                    colors = new Uint8Array(_count * 8);
+                    for (var _i3 = 0; _i3 < _count; _i3++) {
+                      var _colorId = color22[_i3];
+                      colors[_i3 * 8] = palette[_colorId * 4];
+                      colors[_i3 * 8 + 1] = palette[_colorId * 4 + 1];
+                      colors[_i3 * 8 + 2] = palette[_colorId * 4 + 2];
+                      colors[_i3 * 8 + 3] = palette[_colorId * 4 + 3];
+                      var borderColorId = borderColor[_i3];
+                      colors[_i3 * 8 + 4] = palette[borderColorId * 4];
+                      colors[_i3 * 8 + 5] = palette[borderColorId * 4 + 1];
+                      colors[_i3 * 8 + 6] = palette[borderColorId * 4 + 2];
+                      colors[_i3 * 8 + 7] = palette[borderColorId * 4 + 3];
+                    }
+                  }
+                } else {
+                  if (color22.length || borderColor.length) {
+                    colors = new Uint8Array(_count * 4 + 2);
+                    for (var _i4 = 0; _i4 < _count; _i4++) {
+                      if (color22[_i4] != null) {
+                        colors[_i4 * 4] = color22[_i4] % maxColors;
+                        colors[_i4 * 4 + 1] = Math.floor(color22[_i4] / maxColors);
+                      }
+                      if (borderColor[_i4] != null) {
+                        colors[_i4 * 4 + 2] = borderColor[_i4] % maxColors;
+                        colors[_i4 * 4 + 3] = Math.floor(borderColor[_i4] / maxColors);
+                      }
+                    }
+                  }
+                }
+                colorBuffer({
+                  data: colors || new Uint8Array(0),
+                  type: "uint8",
+                  usage: "dynamic"
+                });
+              }
+              return group;
+            });
+          };
+          Scatter.prototype.addMarker = function(sdf) {
+            var markerTextures = this.markerTextures, regl = this.regl, markerCache = this.markerCache;
+            var pos = sdf == null ? 0 : markerCache.indexOf(sdf);
+            if (pos >= 0) return pos;
+            var distArr;
+            if (sdf instanceof Uint8Array || sdf instanceof Uint8ClampedArray) {
+              distArr = sdf;
+            } else {
+              distArr = new Uint8Array(sdf.length);
+              for (var i2 = 0, l2 = sdf.length; i2 < l2; i2++) {
+                distArr[i2] = sdf[i2] * 255;
+              }
+            }
+            var radius = Math.floor(Math.sqrt(distArr.length));
+            pos = markerTextures.length;
+            markerCache.push(sdf);
+            markerTextures.push(regl.texture({
+              channels: 1,
+              data: distArr,
+              radius,
+              mag: "linear",
+              min: "linear"
+            }));
+            return pos;
+          };
+          Scatter.prototype.updateColor = function(colors) {
+            var paletteIds = this.paletteIds, palette = this.palette, maxColors = this.maxColors;
+            if (!Array.isArray(colors)) {
+              colors = [colors];
+            }
+            var idx = [];
+            if (typeof colors[0] === "number") {
+              var grouped = [];
+              if (Array.isArray(colors)) {
+                for (var i2 = 0; i2 < colors.length; i2 += 4) {
+                  grouped.push(colors.slice(i2, i2 + 4));
+                }
+              } else {
+                for (var _i5 = 0; _i5 < colors.length; _i5 += 4) {
+                  grouped.push(colors.subarray(_i5, _i5 + 4));
+                }
+              }
+              colors = grouped;
+            }
+            for (var _i6 = 0; _i6 < colors.length; _i6++) {
+              var color22 = colors[_i6];
+              color22 = rgba3(color22, "uint8");
+              var id2 = colorId(color22, false);
+              if (paletteIds[id2] == null) {
+                var pos = palette.length;
+                paletteIds[id2] = Math.floor(pos / 4);
+                palette[pos] = color22[0];
+                palette[pos + 1] = color22[1];
+                palette[pos + 2] = color22[2];
+                palette[pos + 3] = color22[3];
+              }
+              idx[_i6] = paletteIds[id2];
+            }
+            if (!this.tooManyColors && palette.length > maxColors * 4) this.tooManyColors = true;
+            this.updatePalette(palette);
+            return idx.length === 1 ? idx[0] : idx;
+          };
+          Scatter.prototype.updatePalette = function(palette) {
+            if (this.tooManyColors) return;
+            var maxColors = this.maxColors, paletteTexture = this.paletteTexture;
+            var requiredHeight = Math.ceil(palette.length * 0.25 / maxColors);
+            if (requiredHeight > 1) {
+              palette = palette.slice();
+              for (var i2 = palette.length * 0.25 % maxColors; i2 < requiredHeight * maxColors; i2++) {
+                palette.push(0, 0, 0, 0);
+              }
+            }
+            if (paletteTexture.height < requiredHeight) {
+              paletteTexture.resize(maxColors, requiredHeight);
+            }
+            paletteTexture.subimage({
+              width: Math.min(palette.length * 0.25, maxColors),
+              height: requiredHeight,
+              data: palette
+            }, 0, 0);
+          };
+          Scatter.prototype.destroy = function() {
+            this.groups.forEach(function(group) {
+              group.sizeBuffer.destroy();
+              group.positionBuffer.destroy();
+              group.positionFractBuffer.destroy();
+              group.colorBuffer.destroy();
+              group.activation.forEach(function(b2) {
+                return b2 && b2.destroy && b2.destroy();
+              });
+              group.selectionBuffer.destroy();
+              if (group.elements) group.elements.destroy();
+            });
+            this.groups.length = 0;
+            this.paletteTexture.destroy();
+            this.markerTextures.forEach(function(txt) {
+              return txt && txt.destroy && txt.destroy();
+            });
+            return this;
+          };
+          var extend$1 = require_object_assign();
+          var reglScatter2d = function reglScatter2d2(regl, options) {
+            var scatter$1 = new scatter(regl, options);
+            var render = scatter$1.render.bind(scatter$1);
+            extend$1(render, {
+              render,
+              update: scatter$1.update.bind(scatter$1),
+              draw: scatter$1.draw.bind(scatter$1),
+              destroy: scatter$1.destroy.bind(scatter$1),
+              regl: scatter$1.regl,
+              gl: scatter$1.gl,
+              canvas: scatter$1.gl.canvas,
+              groups: scatter$1.groups,
+              markers: scatter$1.markerCache,
+              palette: scatter$1.palette
+            });
+            return render;
+          };
+          module2.exports = reglScatter2d;
+        }
+      });
+      var require_earcut = __commonJS({
+        "node_modules/earcut/src/earcut.js"(exports, module2) {
+          module2.exports = earcut;
+          module2.exports.default = earcut;
+          function earcut(data, holeIndices, dim) {
+            dim = dim || 2;
+            var hasHoles = holeIndices && holeIndices.length, outerLen = hasHoles ? holeIndices[0] * dim : data.length, outerNode = linkedList(data, 0, outerLen, dim, true), triangles = [];
+            if (!outerNode || outerNode.next === outerNode.prev) return triangles;
+            var minX, minY, maxX, maxY, x2, y2, invSize;
+            if (hasHoles) outerNode = eliminateHoles(data, holeIndices, outerNode, dim);
+            if (data.length > 80 * dim) {
+              minX = maxX = data[0];
+              minY = maxY = data[1];
+              for (var i2 = dim; i2 < outerLen; i2 += dim) {
+                x2 = data[i2];
+                y2 = data[i2 + 1];
+                if (x2 < minX) minX = x2;
+                if (y2 < minY) minY = y2;
+                if (x2 > maxX) maxX = x2;
+                if (y2 > maxY) maxY = y2;
+              }
+              invSize = Math.max(maxX - minX, maxY - minY);
+              invSize = invSize !== 0 ? 32767 / invSize : 0;
+            }
+            earcutLinked(outerNode, triangles, dim, minX, minY, invSize, 0);
+            return triangles;
+          }
+          function linkedList(data, start, end, dim, clockwise) {
+            var i2, last;
+            if (clockwise === signedArea(data, start, end, dim) > 0) {
+              for (i2 = start; i2 < end; i2 += dim) last = insertNode(i2, data[i2], data[i2 + 1], last);
+            } else {
+              for (i2 = end - dim; i2 >= start; i2 -= dim) last = insertNode(i2, data[i2], data[i2 + 1], last);
+            }
+            if (last && equals2(last, last.next)) {
+              removeNode(last);
+              last = last.next;
+            }
+            return last;
+          }
+          function filterPoints(start, end) {
+            if (!start) return start;
+            if (!end) end = start;
+            var p2 = start, again;
+            do {
+              again = false;
+              if (!p2.steiner && (equals2(p2, p2.next) || area(p2.prev, p2, p2.next) === 0)) {
+                removeNode(p2);
+                p2 = end = p2.prev;
+                if (p2 === p2.next) break;
+                again = true;
+              } else {
+                p2 = p2.next;
+              }
+            } while (again || p2 !== end);
+            return end;
+          }
+          function earcutLinked(ear, triangles, dim, minX, minY, invSize, pass) {
+            if (!ear) return;
+            if (!pass && invSize) indexCurve(ear, minX, minY, invSize);
+            var stop = ear, prev, next;
+            while (ear.prev !== ear.next) {
+              prev = ear.prev;
+              next = ear.next;
+              if (invSize ? isEarHashed(ear, minX, minY, invSize) : isEar(ear)) {
+                triangles.push(prev.i / dim | 0);
+                triangles.push(ear.i / dim | 0);
+                triangles.push(next.i / dim | 0);
+                removeNode(ear);
+                ear = next.next;
+                stop = next.next;
+                continue;
+              }
+              ear = next;
+              if (ear === stop) {
+                if (!pass) {
+                  earcutLinked(filterPoints(ear), triangles, dim, minX, minY, invSize, 1);
+                } else if (pass === 1) {
+                  ear = cureLocalIntersections(filterPoints(ear), triangles, dim);
+                  earcutLinked(ear, triangles, dim, minX, minY, invSize, 2);
+                } else if (pass === 2) {
+                  splitEarcut(ear, triangles, dim, minX, minY, invSize);
+                }
+                break;
+              }
+            }
+          }
+          function isEar(ear) {
+            var a2 = ear.prev, b2 = ear, c2 = ear.next;
+            if (area(a2, b2, c2) >= 0) return false;
+            var ax = a2.x, bx = b2.x, cx = c2.x, ay = a2.y, by = b2.y, cy = c2.y;
+            var x0 = ax < bx ? ax < cx ? ax : cx : bx < cx ? bx : cx, y0 = ay < by ? ay < cy ? ay : cy : by < cy ? by : cy, x1 = ax > bx ? ax > cx ? ax : cx : bx > cx ? bx : cx, y1 = ay > by ? ay > cy ? ay : cy : by > cy ? by : cy;
+            var p2 = c2.next;
+            while (p2 !== a2) {
+              if (p2.x >= x0 && p2.x <= x1 && p2.y >= y0 && p2.y <= y1 && pointInTriangle(ax, ay, bx, by, cx, cy, p2.x, p2.y) && area(p2.prev, p2, p2.next) >= 0) return false;
+              p2 = p2.next;
+            }
+            return true;
+          }
+          function isEarHashed(ear, minX, minY, invSize) {
+            var a2 = ear.prev, b2 = ear, c2 = ear.next;
+            if (area(a2, b2, c2) >= 0) return false;
+            var ax = a2.x, bx = b2.x, cx = c2.x, ay = a2.y, by = b2.y, cy = c2.y;
+            var x0 = ax < bx ? ax < cx ? ax : cx : bx < cx ? bx : cx, y0 = ay < by ? ay < cy ? ay : cy : by < cy ? by : cy, x1 = ax > bx ? ax > cx ? ax : cx : bx > cx ? bx : cx, y1 = ay > by ? ay > cy ? ay : cy : by > cy ? by : cy;
+            var minZ = zOrder(x0, y0, minX, minY, invSize), maxZ = zOrder(x1, y1, minX, minY, invSize);
+            var p2 = ear.prevZ, n2 = ear.nextZ;
+            while (p2 && p2.z >= minZ && n2 && n2.z <= maxZ) {
+              if (p2.x >= x0 && p2.x <= x1 && p2.y >= y0 && p2.y <= y1 && p2 !== a2 && p2 !== c2 && pointInTriangle(ax, ay, bx, by, cx, cy, p2.x, p2.y) && area(p2.prev, p2, p2.next) >= 0) return false;
+              p2 = p2.prevZ;
+              if (n2.x >= x0 && n2.x <= x1 && n2.y >= y0 && n2.y <= y1 && n2 !== a2 && n2 !== c2 && pointInTriangle(ax, ay, bx, by, cx, cy, n2.x, n2.y) && area(n2.prev, n2, n2.next) >= 0) return false;
+              n2 = n2.nextZ;
+            }
+            while (p2 && p2.z >= minZ) {
+              if (p2.x >= x0 && p2.x <= x1 && p2.y >= y0 && p2.y <= y1 && p2 !== a2 && p2 !== c2 && pointInTriangle(ax, ay, bx, by, cx, cy, p2.x, p2.y) && area(p2.prev, p2, p2.next) >= 0) return false;
+              p2 = p2.prevZ;
+            }
+            while (n2 && n2.z <= maxZ) {
+              if (n2.x >= x0 && n2.x <= x1 && n2.y >= y0 && n2.y <= y1 && n2 !== a2 && n2 !== c2 && pointInTriangle(ax, ay, bx, by, cx, cy, n2.x, n2.y) && area(n2.prev, n2, n2.next) >= 0) return false;
+              n2 = n2.nextZ;
+            }
+            return true;
+          }
+          function cureLocalIntersections(start, triangles, dim) {
+            var p2 = start;
+            do {
+              var a2 = p2.prev, b2 = p2.next.next;
+              if (!equals2(a2, b2) && intersects(a2, p2, p2.next, b2) && locallyInside(a2, b2) && locallyInside(b2, a2)) {
+                triangles.push(a2.i / dim | 0);
+                triangles.push(p2.i / dim | 0);
+                triangles.push(b2.i / dim | 0);
+                removeNode(p2);
+                removeNode(p2.next);
+                p2 = start = b2;
+              }
+              p2 = p2.next;
+            } while (p2 !== start);
+            return filterPoints(p2);
+          }
+          function splitEarcut(start, triangles, dim, minX, minY, invSize) {
+            var a2 = start;
+            do {
+              var b2 = a2.next.next;
+              while (b2 !== a2.prev) {
+                if (a2.i !== b2.i && isValidDiagonal(a2, b2)) {
+                  var c2 = splitPolygon(a2, b2);
+                  a2 = filterPoints(a2, a2.next);
+                  c2 = filterPoints(c2, c2.next);
+                  earcutLinked(a2, triangles, dim, minX, minY, invSize, 0);
+                  earcutLinked(c2, triangles, dim, minX, minY, invSize, 0);
+                  return;
+                }
+                b2 = b2.next;
+              }
+              a2 = a2.next;
+            } while (a2 !== start);
+          }
+          function eliminateHoles(data, holeIndices, outerNode, dim) {
+            var queue = [], i2, len2, start, end, list;
+            for (i2 = 0, len2 = holeIndices.length; i2 < len2; i2++) {
+              start = holeIndices[i2] * dim;
+              end = i2 < len2 - 1 ? holeIndices[i2 + 1] * dim : data.length;
+              list = linkedList(data, start, end, dim, false);
+              if (list === list.next) list.steiner = true;
+              queue.push(getLeftmost(list));
+            }
+            queue.sort(compareX);
+            for (i2 = 0; i2 < queue.length; i2++) {
+              outerNode = eliminateHole(queue[i2], outerNode);
+            }
+            return outerNode;
+          }
+          function compareX(a2, b2) {
+            return a2.x - b2.x;
+          }
+          function eliminateHole(hole, outerNode) {
+            var bridge = findHoleBridge(hole, outerNode);
+            if (!bridge) {
+              return outerNode;
+            }
+            var bridgeReverse = splitPolygon(bridge, hole);
+            filterPoints(bridgeReverse, bridgeReverse.next);
+            return filterPoints(bridge, bridge.next);
+          }
+          function findHoleBridge(hole, outerNode) {
+            var p2 = outerNode, hx = hole.x, hy = hole.y, qx = -Infinity, m2;
+            do {
+              if (hy <= p2.y && hy >= p2.next.y && p2.next.y !== p2.y) {
+                var x2 = p2.x + (hy - p2.y) * (p2.next.x - p2.x) / (p2.next.y - p2.y);
+                if (x2 <= hx && x2 > qx) {
+                  qx = x2;
+                  m2 = p2.x < p2.next.x ? p2 : p2.next;
+                  if (x2 === hx) return m2;
+                }
+              }
+              p2 = p2.next;
+            } while (p2 !== outerNode);
+            if (!m2) return null;
+            var stop = m2, mx = m2.x, my = m2.y, tanMin = Infinity, tan;
+            p2 = m2;
+            do {
+              if (hx >= p2.x && p2.x >= mx && hx !== p2.x && pointInTriangle(hy < my ? hx : qx, hy, mx, my, hy < my ? qx : hx, hy, p2.x, p2.y)) {
+                tan = Math.abs(hy - p2.y) / (hx - p2.x);
+                if (locallyInside(p2, hole) && (tan < tanMin || tan === tanMin && (p2.x > m2.x || p2.x === m2.x && sectorContainsSector(m2, p2)))) {
+                  m2 = p2;
+                  tanMin = tan;
+                }
+              }
+              p2 = p2.next;
+            } while (p2 !== stop);
+            return m2;
+          }
+          function sectorContainsSector(m2, p2) {
+            return area(m2.prev, m2, p2.prev) < 0 && area(p2.next, m2, m2.next) < 0;
+          }
+          function indexCurve(start, minX, minY, invSize) {
+            var p2 = start;
+            do {
+              if (p2.z === 0) p2.z = zOrder(p2.x, p2.y, minX, minY, invSize);
+              p2.prevZ = p2.prev;
+              p2.nextZ = p2.next;
+              p2 = p2.next;
+            } while (p2 !== start);
+            p2.prevZ.nextZ = null;
+            p2.prevZ = null;
+            sortLinked(p2);
+          }
+          function sortLinked(list) {
+            var i2, p2, q2, e2, tail, numMerges, pSize, qSize, inSize = 1;
+            do {
+              p2 = list;
+              list = null;
+              tail = null;
+              numMerges = 0;
+              while (p2) {
+                numMerges++;
+                q2 = p2;
+                pSize = 0;
+                for (i2 = 0; i2 < inSize; i2++) {
+                  pSize++;
+                  q2 = q2.nextZ;
+                  if (!q2) break;
+                }
+                qSize = inSize;
+                while (pSize > 0 || qSize > 0 && q2) {
+                  if (pSize !== 0 && (qSize === 0 || !q2 || p2.z <= q2.z)) {
+                    e2 = p2;
+                    p2 = p2.nextZ;
+                    pSize--;
+                  } else {
+                    e2 = q2;
+                    q2 = q2.nextZ;
+                    qSize--;
+                  }
+                  if (tail) tail.nextZ = e2;
+                  else list = e2;
+                  e2.prevZ = tail;
+                  tail = e2;
+                }
+                p2 = q2;
+              }
+              tail.nextZ = null;
+              inSize *= 2;
+            } while (numMerges > 1);
+            return list;
+          }
+          function zOrder(x2, y2, minX, minY, invSize) {
+            x2 = (x2 - minX) * invSize | 0;
+            y2 = (y2 - minY) * invSize | 0;
+            x2 = (x2 | x2 << 8) & 16711935;
+            x2 = (x2 | x2 << 4) & 252645135;
+            x2 = (x2 | x2 << 2) & 858993459;
+            x2 = (x2 | x2 << 1) & 1431655765;
+            y2 = (y2 | y2 << 8) & 16711935;
+            y2 = (y2 | y2 << 4) & 252645135;
+            y2 = (y2 | y2 << 2) & 858993459;
+            y2 = (y2 | y2 << 1) & 1431655765;
+            return x2 | y2 << 1;
+          }
+          function getLeftmost(start) {
+            var p2 = start, leftmost = start;
+            do {
+              if (p2.x < leftmost.x || p2.x === leftmost.x && p2.y < leftmost.y) leftmost = p2;
+              p2 = p2.next;
+            } while (p2 !== start);
+            return leftmost;
+          }
+          function pointInTriangle(ax, ay, bx, by, cx, cy, px, py) {
+            return (cx - px) * (ay - py) >= (ax - px) * (cy - py) && (ax - px) * (by - py) >= (bx - px) * (ay - py) && (bx - px) * (cy - py) >= (cx - px) * (by - py);
+          }
+          function isValidDiagonal(a2, b2) {
+            return a2.next.i !== b2.i && a2.prev.i !== b2.i && !intersectsPolygon(a2, b2) && // dones't intersect other edges
+            (locallyInside(a2, b2) && locallyInside(b2, a2) && middleInside(a2, b2) && // locally visible
+            (area(a2.prev, a2, b2.prev) || area(a2, b2.prev, b2)) || // does not create opposite-facing sectors
+            equals2(a2, b2) && area(a2.prev, a2, a2.next) > 0 && area(b2.prev, b2, b2.next) > 0);
+          }
+          function area(p2, q2, r2) {
+            return (q2.y - p2.y) * (r2.x - q2.x) - (q2.x - p2.x) * (r2.y - q2.y);
+          }
+          function equals2(p1, p2) {
+            return p1.x === p2.x && p1.y === p2.y;
+          }
+          function intersects(p1, q1, p2, q2) {
+            var o1 = sign(area(p1, q1, p2));
+            var o2 = sign(area(p1, q1, q2));
+            var o3 = sign(area(p2, q2, p1));
+            var o4 = sign(area(p2, q2, q1));
+            if (o1 !== o2 && o3 !== o4) return true;
+            if (o1 === 0 && onSegment(p1, p2, q1)) return true;
+            if (o2 === 0 && onSegment(p1, q2, q1)) return true;
+            if (o3 === 0 && onSegment(p2, p1, q2)) return true;
+            if (o4 === 0 && onSegment(p2, q1, q2)) return true;
+            return false;
+          }
+          function onSegment(p2, q2, r2) {
+            return q2.x <= Math.max(p2.x, r2.x) && q2.x >= Math.min(p2.x, r2.x) && q2.y <= Math.max(p2.y, r2.y) && q2.y >= Math.min(p2.y, r2.y);
+          }
+          function sign(num) {
+            return num > 0 ? 1 : num < 0 ? -1 : 0;
+          }
+          function intersectsPolygon(a2, b2) {
+            var p2 = a2;
+            do {
+              if (p2.i !== a2.i && p2.next.i !== a2.i && p2.i !== b2.i && p2.next.i !== b2.i && intersects(p2, p2.next, a2, b2)) return true;
+              p2 = p2.next;
+            } while (p2 !== a2);
+            return false;
+          }
+          function locallyInside(a2, b2) {
+            return area(a2.prev, a2, a2.next) < 0 ? area(a2, b2, a2.next) >= 0 && area(a2, a2.prev, b2) >= 0 : area(a2, b2, a2.prev) < 0 || area(a2, a2.next, b2) < 0;
+          }
+          function middleInside(a2, b2) {
+            var p2 = a2, inside = false, px = (a2.x + b2.x) / 2, py = (a2.y + b2.y) / 2;
+            do {
+              if (p2.y > py !== p2.next.y > py && p2.next.y !== p2.y && px < (p2.next.x - p2.x) * (py - p2.y) / (p2.next.y - p2.y) + p2.x)
+                inside = !inside;
+              p2 = p2.next;
+            } while (p2 !== a2);
+            return inside;
+          }
+          function splitPolygon(a2, b2) {
+            var a22 = new Node(a2.i, a2.x, a2.y), b22 = new Node(b2.i, b2.x, b2.y), an = a2.next, bp = b2.prev;
+            a2.next = b2;
+            b2.prev = a2;
+            a22.next = an;
+            an.prev = a22;
+            b22.next = a22;
+            a22.prev = b22;
+            bp.next = b22;
+            b22.prev = bp;
+            return b22;
+          }
+          function insertNode(i2, x2, y2, last) {
+            var p2 = new Node(i2, x2, y2);
+            if (!last) {
+              p2.prev = p2;
+              p2.next = p2;
+            } else {
+              p2.next = last.next;
+              p2.prev = last;
+              last.next.prev = p2;
+              last.next = p2;
+            }
+            return p2;
+          }
+          function removeNode(p2) {
+            p2.next.prev = p2.prev;
+            p2.prev.next = p2.next;
+            if (p2.prevZ) p2.prevZ.nextZ = p2.nextZ;
+            if (p2.nextZ) p2.nextZ.prevZ = p2.prevZ;
+          }
+          function Node(i2, x2, y2) {
+            this.i = i2;
+            this.x = x2;
+            this.y = y2;
+            this.prev = null;
+            this.next = null;
+            this.z = 0;
+            this.prevZ = null;
+            this.nextZ = null;
+            this.steiner = false;
+          }
+          earcut.deviation = function(data, holeIndices, dim, triangles) {
+            var hasHoles = holeIndices && holeIndices.length;
+            var outerLen = hasHoles ? holeIndices[0] * dim : data.length;
+            var polygonArea = Math.abs(signedArea(data, 0, outerLen, dim));
+            if (hasHoles) {
+              for (var i2 = 0, len2 = holeIndices.length; i2 < len2; i2++) {
+                var start = holeIndices[i2] * dim;
+                var end = i2 < len2 - 1 ? holeIndices[i2 + 1] * dim : data.length;
+                polygonArea -= Math.abs(signedArea(data, start, end, dim));
+              }
+            }
+            var trianglesArea = 0;
+            for (i2 = 0; i2 < triangles.length; i2 += 3) {
+              var a2 = triangles[i2] * dim;
+              var b2 = triangles[i2 + 1] * dim;
+              var c2 = triangles[i2 + 2] * dim;
+              trianglesArea += Math.abs(
+                (data[a2] - data[c2]) * (data[b2 + 1] - data[a2 + 1]) - (data[a2] - data[b2]) * (data[c2 + 1] - data[a2 + 1])
+              );
+            }
+            return polygonArea === 0 && trianglesArea === 0 ? 0 : Math.abs((trianglesArea - polygonArea) / polygonArea);
+          };
+          function signedArea(data, start, end, dim) {
+            var sum = 0;
+            for (var i2 = start, j2 = end - dim; i2 < end; i2 += dim) {
+              sum += (data[j2] - data[i2]) * (data[i2 + 1] + data[j2 + 1]);
+              j2 = i2;
+            }
+            return sum;
+          }
+          earcut.flatten = function(data) {
+            var dim = data[0][0].length, result = { vertices: [], holes: [], dimensions: dim }, holeIndex = 0;
+            for (var i2 = 0; i2 < data.length; i2++) {
+              for (var j2 = 0; j2 < data[i2].length; j2++) {
+                for (var d2 = 0; d2 < dim; d2++) result.vertices.push(data[i2][j2][d2]);
+              }
+              if (i2 > 0) {
+                holeIndex += data[i2 - 1].length;
+                result.holes.push(holeIndex);
+              }
+            }
+            return result;
+          };
         }
-        ctx.fill();
-        if (lineWidth !== 0) {
-          ctx.stroke();
+      });
+      var require_array_normalize = __commonJS({
+        "node_modules/array-normalize/index.js"(exports, module2) {
+          var getBounds2 = require_array_bounds();
+          module2.exports = normalize;
+          function normalize(arr, dim, bounds) {
+            if (!arr || arr.length == null) throw Error("Argument should be an array");
+            if (dim == null) dim = 1;
+            if (bounds == null) bounds = getBounds2(arr, dim);
+            for (var offset = 0; offset < dim; offset++) {
+              var max = bounds[dim + offset], min = bounds[offset], i2 = offset, l2 = arr.length;
+              if (max === Infinity && min === -Infinity) {
+                for (i2 = offset; i2 < l2; i2 += dim) {
+                  arr[i2] = arr[i2] === max ? 1 : arr[i2] === min ? 0 : 0.5;
+                }
+              } else if (max === Infinity) {
+                for (i2 = offset; i2 < l2; i2 += dim) {
+                  arr[i2] = arr[i2] === max ? 1 : 0;
+                }
+              } else if (min === -Infinity) {
+                for (i2 = offset; i2 < l2; i2 += dim) {
+                  arr[i2] = arr[i2] === min ? 0 : 1;
+                }
+              } else {
+                var range = max - min;
+                for (i2 = offset; i2 < l2; i2 += dim) {
+                  if (!isNaN(arr[i2])) {
+                    arr[i2] = range === 0 ? 0.5 : (arr[i2] - min) / range;
+                  }
+                }
+              }
+            }
+            return arr;
+          }
         }
-      }
-      ctx.restore();
-    };
-    const fillText = function(x2, y2, legendItem) {
-      renderText(ctx, legendItem.text, x2, y2 + itemHeight / 2, labelFont, {
-        strikethrough: legendItem.hidden,
-        textAlign: rtlHelper.textAlign(legendItem.textAlign)
       });
-    };
-    const isHorizontal = this.isHorizontal();
-    const titleHeight = this._computeTitleHeight();
-    if (isHorizontal) {
-      cursor = {
-        x: _alignStartEnd(align, this.left + padding, this.right - lineWidths[0]),
-        y: this.top + padding + titleHeight,
-        line: 0
-      };
-    } else {
-      cursor = {
-        x: this.left + padding,
-        y: _alignStartEnd(align, this.top + titleHeight + padding, this.bottom - columnSizes[0].height),
-        line: 0
-      };
-    }
-    overrideTextDirection(this.ctx, opts.textDirection);
-    const lineHeight = itemHeight + padding;
-    this.legendItems.forEach((legendItem, i) => {
-      ctx.strokeStyle = legendItem.fontColor;
-      ctx.fillStyle = legendItem.fontColor;
-      const textWidth = ctx.measureText(legendItem.text).width;
-      const textAlign = rtlHelper.textAlign(legendItem.textAlign || (legendItem.textAlign = labelOpts.textAlign));
-      const width = boxWidth + halfFontSize + textWidth;
-      let x2 = cursor.x;
-      let y2 = cursor.y;
-      rtlHelper.setWidth(this.width);
-      if (isHorizontal) {
-        if (i > 0 && x2 + width + padding > this.right) {
-          y2 = cursor.y += lineHeight;
-          cursor.line++;
-          x2 = cursor.x = _alignStartEnd(align, this.left + padding, this.right - lineWidths[cursor.line]);
-        }
-      } else if (i > 0 && y2 + lineHeight > this.bottom) {
-        x2 = cursor.x = x2 + columnSizes[cursor.line].width + padding;
-        cursor.line++;
-        y2 = cursor.y = _alignStartEnd(align, this.top + titleHeight + padding, this.bottom - columnSizes[cursor.line].height);
-      }
-      const realX = rtlHelper.x(x2);
-      drawLegendBox(realX, y2, legendItem);
-      x2 = _textX(textAlign, x2 + boxWidth + halfFontSize, isHorizontal ? x2 + width : this.right, opts.rtl);
-      fillText(rtlHelper.x(x2), y2, legendItem);
-      if (isHorizontal) {
-        cursor.x += width + padding;
-      } else if (typeof legendItem.text !== "string") {
-        const fontLineHeight = labelFont.lineHeight;
-        cursor.y += calculateLegendItemHeight(legendItem, fontLineHeight) + padding;
-      } else {
-        cursor.y += lineHeight;
-      }
-    });
-    restoreTextDirection(this.ctx, opts.textDirection);
-  }
-  drawTitle() {
-    const opts = this.options;
-    const titleOpts = opts.title;
-    const titleFont = toFont(titleOpts.font);
-    const titlePadding = toPadding(titleOpts.padding);
-    if (!titleOpts.display) {
-      return;
-    }
-    const rtlHelper = getRtlAdapter(opts.rtl, this.left, this.width);
-    const ctx = this.ctx;
-    const position = titleOpts.position;
-    const halfFontSize = titleFont.size / 2;
-    const topPaddingPlusHalfFontSize = titlePadding.top + halfFontSize;
-    let y2;
-    let left = this.left;
-    let maxWidth = this.width;
-    if (this.isHorizontal()) {
-      maxWidth = Math.max(...this.lineWidths);
-      y2 = this.top + topPaddingPlusHalfFontSize;
-      left = _alignStartEnd(opts.align, left, this.right - maxWidth);
-    } else {
-      const maxHeight = this.columnSizes.reduce((acc, size) => Math.max(acc, size.height), 0);
-      y2 = topPaddingPlusHalfFontSize + _alignStartEnd(opts.align, this.top, this.bottom - maxHeight - opts.labels.padding - this._computeTitleHeight());
-    }
-    const x2 = _alignStartEnd(position, left, left + maxWidth);
-    ctx.textAlign = rtlHelper.textAlign(_toLeftRightCenter(position));
-    ctx.textBaseline = "middle";
-    ctx.strokeStyle = titleOpts.color;
-    ctx.fillStyle = titleOpts.color;
-    ctx.font = titleFont.string;
-    renderText(ctx, titleOpts.text, x2, y2, titleFont);
-  }
-  _computeTitleHeight() {
-    const titleOpts = this.options.title;
-    const titleFont = toFont(titleOpts.font);
-    const titlePadding = toPadding(titleOpts.padding);
-    return titleOpts.display ? titleFont.lineHeight + titlePadding.height : 0;
-  }
-  _getLegendItemAt(x2, y2) {
-    let i, hitBox, lh2;
-    if (_isBetween(x2, this.left, this.right) && _isBetween(y2, this.top, this.bottom)) {
-      lh2 = this.legendHitBoxes;
-      for (i = 0; i < lh2.length; ++i) {
-        hitBox = lh2[i];
-        if (_isBetween(x2, hitBox.left, hitBox.left + hitBox.width) && _isBetween(y2, hitBox.top, hitBox.top + hitBox.height)) {
-          return this.legendItems[i];
+      var require_is_implemented = __commonJS({
+        "node_modules/es6-weak-map/is-implemented.js"(exports, module2) {
+          module2.exports = function() {
+            var weakMap, obj;
+            if (typeof WeakMap !== "function") return false;
+            try {
+              weakMap = new WeakMap([[obj = {}, "one"], [{}, "two"], [{}, "three"]]);
+            } catch (e2) {
+              return false;
+            }
+            if (String(weakMap) !== "[object WeakMap]") return false;
+            if (typeof weakMap.set !== "function") return false;
+            if (weakMap.set({}, 1) !== weakMap) return false;
+            if (typeof weakMap.delete !== "function") return false;
+            if (typeof weakMap.has !== "function") return false;
+            if (weakMap.get(obj) !== "one") return false;
+            return true;
+          };
         }
-      }
-    }
-    return null;
-  }
-  handleEvent(e) {
-    const opts = this.options;
-    if (!isListened(e.type, opts)) {
-      return;
-    }
-    const hoveredItem = this._getLegendItemAt(e.x, e.y);
-    if (e.type === "mousemove" || e.type === "mouseout") {
-      const previous = this._hoveredItem;
-      const sameItem = itemsEqual(previous, hoveredItem);
-      if (previous && !sameItem) {
-        callback(opts.onLeave, [
-          e,
-          previous,
-          this
-        ], this);
-      }
-      this._hoveredItem = hoveredItem;
-      if (hoveredItem && !sameItem) {
-        callback(opts.onHover, [
-          e,
-          hoveredItem,
-          this
-        ], this);
-      }
-    } else if (hoveredItem) {
-      callback(opts.onClick, [
-        e,
-        hoveredItem,
-        this
-      ], this);
-    }
-  }
-}
-function calculateItemSize(boxWidth, labelFont, ctx, legendItem, _itemHeight) {
-  const itemWidth = calculateItemWidth(legendItem, boxWidth, labelFont, ctx);
-  const itemHeight = calculateItemHeight(_itemHeight, legendItem, labelFont.lineHeight);
-  return {
-    itemWidth,
-    itemHeight
-  };
-}
-function calculateItemWidth(legendItem, boxWidth, labelFont, ctx) {
-  let legendItemText = legendItem.text;
-  if (legendItemText && typeof legendItemText !== "string") {
-    legendItemText = legendItemText.reduce((a, b) => a.length > b.length ? a : b);
-  }
-  return boxWidth + labelFont.size / 2 + ctx.measureText(legendItemText).width;
-}
-function calculateItemHeight(_itemHeight, legendItem, fontLineHeight) {
-  let itemHeight = _itemHeight;
-  if (typeof legendItem.text !== "string") {
-    itemHeight = calculateLegendItemHeight(legendItem, fontLineHeight);
-  }
-  return itemHeight;
-}
-function calculateLegendItemHeight(legendItem, fontLineHeight) {
-  const labelHeight = legendItem.text ? legendItem.text.length : 0;
-  return fontLineHeight * labelHeight;
-}
-function isListened(type, opts) {
-  if ((type === "mousemove" || type === "mouseout") && (opts.onHover || opts.onLeave)) {
-    return true;
-  }
-  if (opts.onClick && (type === "click" || type === "mouseup")) {
-    return true;
-  }
-  return false;
-}
-var plugin_legend = {
-  id: "legend",
-  _element: Legend,
-  start(chart, _args, options) {
-    const legend = chart.legend = new Legend({
-      ctx: chart.ctx,
-      options,
-      chart
-    });
-    layouts.configure(chart, legend, options);
-    layouts.addBox(chart, legend);
-  },
-  stop(chart) {
-    layouts.removeBox(chart, chart.legend);
-    delete chart.legend;
-  },
-  beforeUpdate(chart, _args, options) {
-    const legend = chart.legend;
-    layouts.configure(chart, legend, options);
-    legend.options = options;
-  },
-  afterUpdate(chart) {
-    const legend = chart.legend;
-    legend.buildLabels();
-    legend.adjustHitBoxes();
-  },
-  afterEvent(chart, args) {
-    if (!args.replay) {
-      chart.legend.handleEvent(args.event);
-    }
-  },
-  defaults: {
-    display: true,
-    position: "top",
-    align: "center",
-    fullSize: true,
-    reverse: false,
-    weight: 1e3,
-    onClick(e, legendItem, legend) {
-      const index = legendItem.datasetIndex;
-      const ci2 = legend.chart;
-      if (ci2.isDatasetVisible(index)) {
-        ci2.hide(index);
-        legendItem.hidden = true;
-      } else {
-        ci2.show(index);
-        legendItem.hidden = false;
-      }
-    },
-    onHover: null,
-    onLeave: null,
-    labels: {
-      color: (ctx) => ctx.chart.options.color,
-      boxWidth: 40,
-      padding: 10,
-      generateLabels(chart) {
-        const datasets = chart.data.datasets;
-        const { labels: { usePointStyle, pointStyle, textAlign, color: color2, useBorderRadius, borderRadius } } = chart.legend.options;
-        return chart._getSortedDatasetMetas().map((meta) => {
-          const style = meta.controller.getStyle(usePointStyle ? 0 : void 0);
-          const borderWidth = toPadding(style.borderWidth);
-          return {
-            text: datasets[meta.index].label,
-            fillStyle: style.backgroundColor,
-            fontColor: color2,
-            hidden: !meta.visible,
-            lineCap: style.borderCapStyle,
-            lineDash: style.borderDash,
-            lineDashOffset: style.borderDashOffset,
-            lineJoin: style.borderJoinStyle,
-            lineWidth: (borderWidth.width + borderWidth.height) / 4,
-            strokeStyle: style.borderColor,
-            pointStyle: pointStyle || style.pointStyle,
-            rotation: style.rotation,
-            textAlign: textAlign || style.textAlign,
-            borderRadius: useBorderRadius && (borderRadius || style.borderRadius),
-            datasetIndex: meta.index
-          };
-        }, this);
-      }
-    },
-    title: {
-      color: (ctx) => ctx.chart.options.color,
-      display: false,
-      position: "center",
-      text: ""
-    }
-  },
-  descriptors: {
-    _scriptable: (name) => !name.startsWith("on"),
-    labels: {
-      _scriptable: (name) => ![
-        "generateLabels",
-        "filter",
-        "sort"
-      ].includes(name)
-    }
-  }
-};
-class Title extends Element$1 {
-  constructor(config) {
-    super();
-    this.chart = config.chart;
-    this.options = config.options;
-    this.ctx = config.ctx;
-    this._padding = void 0;
-    this.top = void 0;
-    this.bottom = void 0;
-    this.left = void 0;
-    this.right = void 0;
-    this.width = void 0;
-    this.height = void 0;
-    this.position = void 0;
-    this.weight = void 0;
-    this.fullSize = void 0;
-  }
-  update(maxWidth, maxHeight) {
-    const opts = this.options;
-    this.left = 0;
-    this.top = 0;
-    if (!opts.display) {
-      this.width = this.height = this.right = this.bottom = 0;
-      return;
-    }
-    this.width = this.right = maxWidth;
-    this.height = this.bottom = maxHeight;
-    const lineCount = isArray(opts.text) ? opts.text.length : 1;
-    this._padding = toPadding(opts.padding);
-    const textSize = lineCount * toFont(opts.font).lineHeight + this._padding.height;
-    if (this.isHorizontal()) {
-      this.height = textSize;
-    } else {
-      this.width = textSize;
-    }
-  }
-  isHorizontal() {
-    const pos = this.options.position;
-    return pos === "top" || pos === "bottom";
-  }
-  _drawArgs(offset) {
-    const { top, left, bottom, right, options } = this;
-    const align = options.align;
-    let rotation = 0;
-    let maxWidth, titleX, titleY;
-    if (this.isHorizontal()) {
-      titleX = _alignStartEnd(align, left, right);
-      titleY = top + offset;
-      maxWidth = right - left;
-    } else {
-      if (options.position === "left") {
-        titleX = left + offset;
-        titleY = _alignStartEnd(align, bottom, top);
-        rotation = PI * -0.5;
-      } else {
-        titleX = right - offset;
-        titleY = _alignStartEnd(align, top, bottom);
-        rotation = PI * 0.5;
-      }
-      maxWidth = bottom - top;
-    }
-    return {
-      titleX,
-      titleY,
-      maxWidth,
-      rotation
-    };
-  }
-  draw() {
-    const ctx = this.ctx;
-    const opts = this.options;
-    if (!opts.display) {
-      return;
-    }
-    const fontOpts = toFont(opts.font);
-    const lineHeight = fontOpts.lineHeight;
-    const offset = lineHeight / 2 + this._padding.top;
-    const { titleX, titleY, maxWidth, rotation } = this._drawArgs(offset);
-    renderText(ctx, opts.text, 0, 0, fontOpts, {
-      color: opts.color,
-      maxWidth,
-      rotation,
-      textAlign: _toLeftRightCenter(opts.align),
-      textBaseline: "middle",
-      translation: [
-        titleX,
-        titleY
-      ]
-    });
-  }
-}
-function createTitle(chart, titleOpts) {
-  const title = new Title({
-    ctx: chart.ctx,
-    options: titleOpts,
-    chart
-  });
-  layouts.configure(chart, title, titleOpts);
-  layouts.addBox(chart, title);
-  chart.titleBlock = title;
-}
-var plugin_title = {
-  id: "title",
-  _element: Title,
-  start(chart, _args, options) {
-    createTitle(chart, options);
-  },
-  stop(chart) {
-    const titleBlock = chart.titleBlock;
-    layouts.removeBox(chart, titleBlock);
-    delete chart.titleBlock;
-  },
-  beforeUpdate(chart, _args, options) {
-    const title = chart.titleBlock;
-    layouts.configure(chart, title, options);
-    title.options = options;
-  },
-  defaults: {
-    align: "center",
-    display: false,
-    font: {
-      weight: "bold"
-    },
-    fullSize: true,
-    padding: 10,
-    position: "top",
-    text: "",
-    weight: 2e3
-  },
-  defaultRoutes: {
-    color: "color"
-  },
-  descriptors: {
-    _scriptable: true,
-    _indexable: false
-  }
-};
-const positioners = {
-  average(items) {
-    if (!items.length) {
-      return false;
-    }
-    let i, len;
-    let xSet = /* @__PURE__ */ new Set();
-    let y2 = 0;
-    let count = 0;
-    for (i = 0, len = items.length; i < len; ++i) {
-      const el2 = items[i].element;
-      if (el2 && el2.hasValue()) {
-        const pos = el2.tooltipPosition();
-        xSet.add(pos.x);
-        y2 += pos.y;
-        ++count;
-      }
-    }
-    if (count === 0 || xSet.size === 0) {
-      return false;
-    }
-    const xAverage = [
-      ...xSet
-    ].reduce((a, b) => a + b) / xSet.size;
-    return {
-      x: xAverage,
-      y: y2 / count
-    };
-  },
-  nearest(items, eventPosition) {
-    if (!items.length) {
-      return false;
-    }
-    let x2 = eventPosition.x;
-    let y2 = eventPosition.y;
-    let minDistance = Number.POSITIVE_INFINITY;
-    let i, len, nearestElement;
-    for (i = 0, len = items.length; i < len; ++i) {
-      const el2 = items[i].element;
-      if (el2 && el2.hasValue()) {
-        const center = el2.getCenterPoint();
-        const d = distanceBetweenPoints(eventPosition, center);
-        if (d < minDistance) {
-          minDistance = d;
-          nearestElement = el2;
+      });
+      var require_noop2 = __commonJS({
+        "node_modules/es5-ext/function/noop.js"(exports, module2) {
+          module2.exports = function() {
+          };
         }
-      }
-    }
-    if (nearestElement) {
-      const tp = nearestElement.tooltipPosition();
-      x2 = tp.x;
-      y2 = tp.y;
-    }
-    return {
-      x: x2,
-      y: y2
-    };
-  }
-};
-function pushOrConcat(base, toPush) {
-  if (toPush) {
-    if (isArray(toPush)) {
-      Array.prototype.push.apply(base, toPush);
-    } else {
-      base.push(toPush);
-    }
-  }
-  return base;
-}
-function splitNewlines(str) {
-  if ((typeof str === "string" || str instanceof String) && str.indexOf("\n") > -1) {
-    return str.split("\n");
-  }
-  return str;
-}
-function createTooltipItem(chart, item) {
-  const { element, datasetIndex, index } = item;
-  const controller = chart.getDatasetMeta(datasetIndex).controller;
-  const { label, value } = controller.getLabelAndValue(index);
-  return {
-    chart,
-    label,
-    parsed: controller.getParsed(index),
-    raw: chart.data.datasets[datasetIndex].data[index],
-    formattedValue: value,
-    dataset: controller.getDataset(),
-    dataIndex: index,
-    datasetIndex,
-    element
-  };
-}
-function getTooltipSize(tooltip, options) {
-  const ctx = tooltip.chart.ctx;
-  const { body, footer, title } = tooltip;
-  const { boxWidth, boxHeight } = options;
-  const bodyFont = toFont(options.bodyFont);
-  const titleFont = toFont(options.titleFont);
-  const footerFont = toFont(options.footerFont);
-  const titleLineCount = title.length;
-  const footerLineCount = footer.length;
-  const bodyLineItemCount = body.length;
-  const padding = toPadding(options.padding);
-  let height = padding.height;
-  let width = 0;
-  let combinedBodyLength = body.reduce((count, bodyItem) => count + bodyItem.before.length + bodyItem.lines.length + bodyItem.after.length, 0);
-  combinedBodyLength += tooltip.beforeBody.length + tooltip.afterBody.length;
-  if (titleLineCount) {
-    height += titleLineCount * titleFont.lineHeight + (titleLineCount - 1) * options.titleSpacing + options.titleMarginBottom;
-  }
-  if (combinedBodyLength) {
-    const bodyLineHeight = options.displayColors ? Math.max(boxHeight, bodyFont.lineHeight) : bodyFont.lineHeight;
-    height += bodyLineItemCount * bodyLineHeight + (combinedBodyLength - bodyLineItemCount) * bodyFont.lineHeight + (combinedBodyLength - 1) * options.bodySpacing;
-  }
-  if (footerLineCount) {
-    height += options.footerMarginTop + footerLineCount * footerFont.lineHeight + (footerLineCount - 1) * options.footerSpacing;
-  }
-  let widthPadding = 0;
-  const maxLineWidth = function(line) {
-    width = Math.max(width, ctx.measureText(line).width + widthPadding);
-  };
-  ctx.save();
-  ctx.font = titleFont.string;
-  each(tooltip.title, maxLineWidth);
-  ctx.font = bodyFont.string;
-  each(tooltip.beforeBody.concat(tooltip.afterBody), maxLineWidth);
-  widthPadding = options.displayColors ? boxWidth + 2 + options.boxPadding : 0;
-  each(body, (bodyItem) => {
-    each(bodyItem.before, maxLineWidth);
-    each(bodyItem.lines, maxLineWidth);
-    each(bodyItem.after, maxLineWidth);
-  });
-  widthPadding = 0;
-  ctx.font = footerFont.string;
-  each(tooltip.footer, maxLineWidth);
-  ctx.restore();
-  width += padding.width;
-  return {
-    width,
-    height
-  };
-}
-function determineYAlign(chart, size) {
-  const { y: y2, height } = size;
-  if (y2 < height / 2) {
-    return "top";
-  } else if (y2 > chart.height - height / 2) {
-    return "bottom";
-  }
-  return "center";
-}
-function doesNotFitWithAlign(xAlign, chart, options, size) {
-  const { x: x2, width } = size;
-  const caret = options.caretSize + options.caretPadding;
-  if (xAlign === "left" && x2 + width + caret > chart.width) {
-    return true;
-  }
-  if (xAlign === "right" && x2 - width - caret < 0) {
-    return true;
-  }
-}
-function determineXAlign(chart, options, size, yAlign) {
-  const { x: x2, width } = size;
-  const { width: chartWidth, chartArea: { left, right } } = chart;
-  let xAlign = "center";
-  if (yAlign === "center") {
-    xAlign = x2 <= (left + right) / 2 ? "left" : "right";
-  } else if (x2 <= width / 2) {
-    xAlign = "left";
-  } else if (x2 >= chartWidth - width / 2) {
-    xAlign = "right";
-  }
-  if (doesNotFitWithAlign(xAlign, chart, options, size)) {
-    xAlign = "center";
-  }
-  return xAlign;
-}
-function determineAlignment(chart, options, size) {
-  const yAlign = size.yAlign || options.yAlign || determineYAlign(chart, size);
-  return {
-    xAlign: size.xAlign || options.xAlign || determineXAlign(chart, options, size, yAlign),
-    yAlign
-  };
-}
-function alignX(size, xAlign) {
-  let { x: x2, width } = size;
-  if (xAlign === "right") {
-    x2 -= width;
-  } else if (xAlign === "center") {
-    x2 -= width / 2;
-  }
-  return x2;
-}
-function alignY(size, yAlign, paddingAndSize) {
-  let { y: y2, height } = size;
-  if (yAlign === "top") {
-    y2 += paddingAndSize;
-  } else if (yAlign === "bottom") {
-    y2 -= height + paddingAndSize;
-  } else {
-    y2 -= height / 2;
-  }
-  return y2;
-}
-function getBackgroundPoint(options, size, alignment, chart) {
-  const { caretSize, caretPadding, cornerRadius } = options;
-  const { xAlign, yAlign } = alignment;
-  const paddingAndSize = caretSize + caretPadding;
-  const { topLeft, topRight, bottomLeft, bottomRight } = toTRBLCorners(cornerRadius);
-  let x2 = alignX(size, xAlign);
-  const y2 = alignY(size, yAlign, paddingAndSize);
-  if (yAlign === "center") {
-    if (xAlign === "left") {
-      x2 += paddingAndSize;
-    } else if (xAlign === "right") {
-      x2 -= paddingAndSize;
-    }
-  } else if (xAlign === "left") {
-    x2 -= Math.max(topLeft, bottomLeft) + caretSize;
-  } else if (xAlign === "right") {
-    x2 += Math.max(topRight, bottomRight) + caretSize;
-  }
-  return {
-    x: _limitValue(x2, 0, chart.width - size.width),
-    y: _limitValue(y2, 0, chart.height - size.height)
-  };
-}
-function getAlignedX(tooltip, align, options) {
-  const padding = toPadding(options.padding);
-  return align === "center" ? tooltip.x + tooltip.width / 2 : align === "right" ? tooltip.x + tooltip.width - padding.right : tooltip.x + padding.left;
-}
-function getBeforeAfterBodyLines(callback2) {
-  return pushOrConcat([], splitNewlines(callback2));
-}
-function createTooltipContext(parent, tooltip, tooltipItems) {
-  return createContext(parent, {
-    tooltip,
-    tooltipItems,
-    type: "tooltip"
-  });
-}
-function overrideCallbacks(callbacks, context) {
-  const override = context && context.dataset && context.dataset.tooltip && context.dataset.tooltip.callbacks;
-  return override ? callbacks.override(override) : callbacks;
-}
-const defaultCallbacks = {
-  beforeTitle: noop,
-  title(tooltipItems) {
-    if (tooltipItems.length > 0) {
-      const item = tooltipItems[0];
-      const labels = item.chart.data.labels;
-      const labelCount = labels ? labels.length : 0;
-      if (this && this.options && this.options.mode === "dataset") {
-        return item.dataset.label || "";
-      } else if (item.label) {
-        return item.label;
-      } else if (labelCount > 0 && item.dataIndex < labelCount) {
-        return labels[item.dataIndex];
-      }
-    }
-    return "";
-  },
-  afterTitle: noop,
-  beforeBody: noop,
-  beforeLabel: noop,
-  label(tooltipItem) {
-    if (this && this.options && this.options.mode === "dataset") {
-      return tooltipItem.label + ": " + tooltipItem.formattedValue || tooltipItem.formattedValue;
-    }
-    let label = tooltipItem.dataset.label || "";
-    if (label) {
-      label += ": ";
-    }
-    const value = tooltipItem.formattedValue;
-    if (!isNullOrUndef(value)) {
-      label += value;
-    }
-    return label;
-  },
-  labelColor(tooltipItem) {
-    const meta = tooltipItem.chart.getDatasetMeta(tooltipItem.datasetIndex);
-    const options = meta.controller.getStyle(tooltipItem.dataIndex);
-    return {
-      borderColor: options.borderColor,
-      backgroundColor: options.backgroundColor,
-      borderWidth: options.borderWidth,
-      borderDash: options.borderDash,
-      borderDashOffset: options.borderDashOffset,
-      borderRadius: 0
-    };
-  },
-  labelTextColor() {
-    return this.options.bodyColor;
-  },
-  labelPointStyle(tooltipItem) {
-    const meta = tooltipItem.chart.getDatasetMeta(tooltipItem.datasetIndex);
-    const options = meta.controller.getStyle(tooltipItem.dataIndex);
-    return {
-      pointStyle: options.pointStyle,
-      rotation: options.rotation
-    };
-  },
-  afterLabel: noop,
-  afterBody: noop,
-  beforeFooter: noop,
-  footer: noop,
-  afterFooter: noop
-};
-function invokeCallbackWithFallback(callbacks, name, ctx, arg) {
-  const result = callbacks[name].call(ctx, arg);
-  if (typeof result === "undefined") {
-    return defaultCallbacks[name].call(ctx, arg);
-  }
-  return result;
-}
-class Tooltip extends Element$1 {
-  constructor(config) {
-    super();
-    this.opacity = 0;
-    this._active = [];
-    this._eventPosition = void 0;
-    this._size = void 0;
-    this._cachedAnimations = void 0;
-    this._tooltipItems = [];
-    this.$animations = void 0;
-    this.$context = void 0;
-    this.chart = config.chart;
-    this.options = config.options;
-    this.dataPoints = void 0;
-    this.title = void 0;
-    this.beforeBody = void 0;
-    this.body = void 0;
-    this.afterBody = void 0;
-    this.footer = void 0;
-    this.xAlign = void 0;
-    this.yAlign = void 0;
-    this.x = void 0;
-    this.y = void 0;
-    this.height = void 0;
-    this.width = void 0;
-    this.caretX = void 0;
-    this.caretY = void 0;
-    this.labelColors = void 0;
-    this.labelPointStyles = void 0;
-    this.labelTextColors = void 0;
-  }
-  initialize(options) {
-    this.options = options;
-    this._cachedAnimations = void 0;
-    this.$context = void 0;
-  }
-  _resolveAnimations() {
-    const cached = this._cachedAnimations;
-    if (cached) {
-      return cached;
-    }
-    const chart = this.chart;
-    const options = this.options.setContext(this.getContext());
-    const opts = options.enabled && chart.options.animation && options.animations;
-    const animations = new Animations(this.chart, opts);
-    if (opts._cacheable) {
-      this._cachedAnimations = Object.freeze(animations);
-    }
-    return animations;
-  }
-  getContext() {
-    return this.$context || (this.$context = createTooltipContext(this.chart.getContext(), this, this._tooltipItems));
-  }
-  getTitle(context, options) {
-    const { callbacks } = options;
-    const beforeTitle = invokeCallbackWithFallback(callbacks, "beforeTitle", this, context);
-    const title = invokeCallbackWithFallback(callbacks, "title", this, context);
-    const afterTitle = invokeCallbackWithFallback(callbacks, "afterTitle", this, context);
-    let lines = [];
-    lines = pushOrConcat(lines, splitNewlines(beforeTitle));
-    lines = pushOrConcat(lines, splitNewlines(title));
-    lines = pushOrConcat(lines, splitNewlines(afterTitle));
-    return lines;
-  }
-  getBeforeBody(tooltipItems, options) {
-    return getBeforeAfterBodyLines(invokeCallbackWithFallback(options.callbacks, "beforeBody", this, tooltipItems));
-  }
-  getBody(tooltipItems, options) {
-    const { callbacks } = options;
-    const bodyItems = [];
-    each(tooltipItems, (context) => {
-      const bodyItem = {
-        before: [],
-        lines: [],
-        after: []
-      };
-      const scoped = overrideCallbacks(callbacks, context);
-      pushOrConcat(bodyItem.before, splitNewlines(invokeCallbackWithFallback(scoped, "beforeLabel", this, context)));
-      pushOrConcat(bodyItem.lines, invokeCallbackWithFallback(scoped, "label", this, context));
-      pushOrConcat(bodyItem.after, splitNewlines(invokeCallbackWithFallback(scoped, "afterLabel", this, context)));
-      bodyItems.push(bodyItem);
-    });
-    return bodyItems;
-  }
-  getAfterBody(tooltipItems, options) {
-    return getBeforeAfterBodyLines(invokeCallbackWithFallback(options.callbacks, "afterBody", this, tooltipItems));
-  }
-  getFooter(tooltipItems, options) {
-    const { callbacks } = options;
-    const beforeFooter = invokeCallbackWithFallback(callbacks, "beforeFooter", this, tooltipItems);
-    const footer = invokeCallbackWithFallback(callbacks, "footer", this, tooltipItems);
-    const afterFooter = invokeCallbackWithFallback(callbacks, "afterFooter", this, tooltipItems);
-    let lines = [];
-    lines = pushOrConcat(lines, splitNewlines(beforeFooter));
-    lines = pushOrConcat(lines, splitNewlines(footer));
-    lines = pushOrConcat(lines, splitNewlines(afterFooter));
-    return lines;
-  }
-  _createItems(options) {
-    const active = this._active;
-    const data = this.chart.data;
-    const labelColors = [];
-    const labelPointStyles = [];
-    const labelTextColors = [];
-    let tooltipItems = [];
-    let i, len;
-    for (i = 0, len = active.length; i < len; ++i) {
-      tooltipItems.push(createTooltipItem(this.chart, active[i]));
-    }
-    if (options.filter) {
-      tooltipItems = tooltipItems.filter((element, index, array) => options.filter(element, index, array, data));
-    }
-    if (options.itemSort) {
-      tooltipItems = tooltipItems.sort((a, b) => options.itemSort(a, b, data));
-    }
-    each(tooltipItems, (context) => {
-      const scoped = overrideCallbacks(options.callbacks, context);
-      labelColors.push(invokeCallbackWithFallback(scoped, "labelColor", this, context));
-      labelPointStyles.push(invokeCallbackWithFallback(scoped, "labelPointStyle", this, context));
-      labelTextColors.push(invokeCallbackWithFallback(scoped, "labelTextColor", this, context));
-    });
-    this.labelColors = labelColors;
-    this.labelPointStyles = labelPointStyles;
-    this.labelTextColors = labelTextColors;
-    this.dataPoints = tooltipItems;
-    return tooltipItems;
-  }
-  update(changed, replay) {
-    const options = this.options.setContext(this.getContext());
-    const active = this._active;
-    let properties;
-    let tooltipItems = [];
-    if (!active.length) {
-      if (this.opacity !== 0) {
-        properties = {
-          opacity: 0
-        };
-      }
-    } else {
-      const position = positioners[options.position].call(this, active, this._eventPosition);
-      tooltipItems = this._createItems(options);
-      this.title = this.getTitle(tooltipItems, options);
-      this.beforeBody = this.getBeforeBody(tooltipItems, options);
-      this.body = this.getBody(tooltipItems, options);
-      this.afterBody = this.getAfterBody(tooltipItems, options);
-      this.footer = this.getFooter(tooltipItems, options);
-      const size = this._size = getTooltipSize(this, options);
-      const positionAndSize = Object.assign({}, position, size);
-      const alignment = determineAlignment(this.chart, options, positionAndSize);
-      const backgroundPoint = getBackgroundPoint(options, positionAndSize, alignment, this.chart);
-      this.xAlign = alignment.xAlign;
-      this.yAlign = alignment.yAlign;
-      properties = {
-        opacity: 1,
-        x: backgroundPoint.x,
-        y: backgroundPoint.y,
-        width: size.width,
-        height: size.height,
-        caretX: position.x,
-        caretY: position.y
-      };
-    }
-    this._tooltipItems = tooltipItems;
-    this.$context = void 0;
-    if (properties) {
-      this._resolveAnimations().update(this, properties);
-    }
-    if (changed && options.external) {
-      options.external.call(this, {
-        chart: this.chart,
-        tooltip: this,
-        replay
-      });
-    }
-  }
-  drawCaret(tooltipPoint, ctx, size, options) {
-    const caretPosition = this.getCaretPosition(tooltipPoint, size, options);
-    ctx.lineTo(caretPosition.x1, caretPosition.y1);
-    ctx.lineTo(caretPosition.x2, caretPosition.y2);
-    ctx.lineTo(caretPosition.x3, caretPosition.y3);
-  }
-  getCaretPosition(tooltipPoint, size, options) {
-    const { xAlign, yAlign } = this;
-    const { caretSize, cornerRadius } = options;
-    const { topLeft, topRight, bottomLeft, bottomRight } = toTRBLCorners(cornerRadius);
-    const { x: ptX, y: ptY } = tooltipPoint;
-    const { width, height } = size;
-    let x1, x2, x3, y1, y2, y3;
-    if (yAlign === "center") {
-      y2 = ptY + height / 2;
-      if (xAlign === "left") {
-        x1 = ptX;
-        x2 = x1 - caretSize;
-        y1 = y2 + caretSize;
-        y3 = y2 - caretSize;
-      } else {
-        x1 = ptX + width;
-        x2 = x1 + caretSize;
-        y1 = y2 - caretSize;
-        y3 = y2 + caretSize;
-      }
-      x3 = x1;
-    } else {
-      if (xAlign === "left") {
-        x2 = ptX + Math.max(topLeft, bottomLeft) + caretSize;
-      } else if (xAlign === "right") {
-        x2 = ptX + width - Math.max(topRight, bottomRight) - caretSize;
-      } else {
-        x2 = this.caretX;
-      }
-      if (yAlign === "top") {
-        y1 = ptY;
-        y2 = y1 - caretSize;
-        x1 = x2 - caretSize;
-        x3 = x2 + caretSize;
-      } else {
-        y1 = ptY + height;
-        y2 = y1 + caretSize;
-        x1 = x2 + caretSize;
-        x3 = x2 - caretSize;
-      }
-      y3 = y1;
-    }
-    return {
-      x1,
-      x2,
-      x3,
-      y1,
-      y2,
-      y3
-    };
-  }
-  drawTitle(pt, ctx, options) {
-    const title = this.title;
-    const length = title.length;
-    let titleFont, titleSpacing, i;
-    if (length) {
-      const rtlHelper = getRtlAdapter(options.rtl, this.x, this.width);
-      pt.x = getAlignedX(this, options.titleAlign, options);
-      ctx.textAlign = rtlHelper.textAlign(options.titleAlign);
-      ctx.textBaseline = "middle";
-      titleFont = toFont(options.titleFont);
-      titleSpacing = options.titleSpacing;
-      ctx.fillStyle = options.titleColor;
-      ctx.font = titleFont.string;
-      for (i = 0; i < length; ++i) {
-        ctx.fillText(title[i], rtlHelper.x(pt.x), pt.y + titleFont.lineHeight / 2);
-        pt.y += titleFont.lineHeight + titleSpacing;
-        if (i + 1 === length) {
-          pt.y += options.titleMarginBottom - titleSpacing;
-        }
-      }
-    }
-  }
-  _drawColorBox(ctx, pt, i, rtlHelper, options) {
-    const labelColor = this.labelColors[i];
-    const labelPointStyle = this.labelPointStyles[i];
-    const { boxHeight, boxWidth } = options;
-    const bodyFont = toFont(options.bodyFont);
-    const colorX = getAlignedX(this, "left", options);
-    const rtlColorX = rtlHelper.x(colorX);
-    const yOffSet = boxHeight < bodyFont.lineHeight ? (bodyFont.lineHeight - boxHeight) / 2 : 0;
-    const colorY = pt.y + yOffSet;
-    if (options.usePointStyle) {
-      const drawOptions = {
-        radius: Math.min(boxWidth, boxHeight) / 2,
-        pointStyle: labelPointStyle.pointStyle,
-        rotation: labelPointStyle.rotation,
-        borderWidth: 1
-      };
-      const centerX = rtlHelper.leftForLtr(rtlColorX, boxWidth) + boxWidth / 2;
-      const centerY = colorY + boxHeight / 2;
-      ctx.strokeStyle = options.multiKeyBackground;
-      ctx.fillStyle = options.multiKeyBackground;
-      drawPoint(ctx, drawOptions, centerX, centerY);
-      ctx.strokeStyle = labelColor.borderColor;
-      ctx.fillStyle = labelColor.backgroundColor;
-      drawPoint(ctx, drawOptions, centerX, centerY);
-    } else {
-      ctx.lineWidth = isObject(labelColor.borderWidth) ? Math.max(...Object.values(labelColor.borderWidth)) : labelColor.borderWidth || 1;
-      ctx.strokeStyle = labelColor.borderColor;
-      ctx.setLineDash(labelColor.borderDash || []);
-      ctx.lineDashOffset = labelColor.borderDashOffset || 0;
-      const outerX = rtlHelper.leftForLtr(rtlColorX, boxWidth);
-      const innerX = rtlHelper.leftForLtr(rtlHelper.xPlus(rtlColorX, 1), boxWidth - 2);
-      const borderRadius = toTRBLCorners(labelColor.borderRadius);
-      if (Object.values(borderRadius).some((v2) => v2 !== 0)) {
-        ctx.beginPath();
-        ctx.fillStyle = options.multiKeyBackground;
-        addRoundedRectPath(ctx, {
-          x: outerX,
-          y: colorY,
-          w: boxWidth,
-          h: boxHeight,
-          radius: borderRadius
-        });
-        ctx.fill();
-        ctx.stroke();
-        ctx.fillStyle = labelColor.backgroundColor;
-        ctx.beginPath();
-        addRoundedRectPath(ctx, {
-          x: innerX,
-          y: colorY + 1,
-          w: boxWidth - 2,
-          h: boxHeight - 2,
-          radius: borderRadius
-        });
-        ctx.fill();
-      } else {
-        ctx.fillStyle = options.multiKeyBackground;
-        ctx.fillRect(outerX, colorY, boxWidth, boxHeight);
-        ctx.strokeRect(outerX, colorY, boxWidth, boxHeight);
-        ctx.fillStyle = labelColor.backgroundColor;
-        ctx.fillRect(innerX, colorY + 1, boxWidth - 2, boxHeight - 2);
-      }
-    }
-    ctx.fillStyle = this.labelTextColors[i];
-  }
-  drawBody(pt, ctx, options) {
-    const { body } = this;
-    const { bodySpacing, bodyAlign, displayColors, boxHeight, boxWidth, boxPadding } = options;
-    const bodyFont = toFont(options.bodyFont);
-    let bodyLineHeight = bodyFont.lineHeight;
-    let xLinePadding = 0;
-    const rtlHelper = getRtlAdapter(options.rtl, this.x, this.width);
-    const fillLineOfText = function(line) {
-      ctx.fillText(line, rtlHelper.x(pt.x + xLinePadding), pt.y + bodyLineHeight / 2);
-      pt.y += bodyLineHeight + bodySpacing;
-    };
-    const bodyAlignForCalculation = rtlHelper.textAlign(bodyAlign);
-    let bodyItem, textColor, lines, i, j, ilen, jlen;
-    ctx.textAlign = bodyAlign;
-    ctx.textBaseline = "middle";
-    ctx.font = bodyFont.string;
-    pt.x = getAlignedX(this, bodyAlignForCalculation, options);
-    ctx.fillStyle = options.bodyColor;
-    each(this.beforeBody, fillLineOfText);
-    xLinePadding = displayColors && bodyAlignForCalculation !== "right" ? bodyAlign === "center" ? boxWidth / 2 + boxPadding : boxWidth + 2 + boxPadding : 0;
-    for (i = 0, ilen = body.length; i < ilen; ++i) {
-      bodyItem = body[i];
-      textColor = this.labelTextColors[i];
-      ctx.fillStyle = textColor;
-      each(bodyItem.before, fillLineOfText);
-      lines = bodyItem.lines;
-      if (displayColors && lines.length) {
-        this._drawColorBox(ctx, pt, i, rtlHelper, options);
-        bodyLineHeight = Math.max(bodyFont.lineHeight, boxHeight);
-      }
-      for (j = 0, jlen = lines.length; j < jlen; ++j) {
-        fillLineOfText(lines[j]);
-        bodyLineHeight = bodyFont.lineHeight;
-      }
-      each(bodyItem.after, fillLineOfText);
-    }
-    xLinePadding = 0;
-    bodyLineHeight = bodyFont.lineHeight;
-    each(this.afterBody, fillLineOfText);
-    pt.y -= bodySpacing;
-  }
-  drawFooter(pt, ctx, options) {
-    const footer = this.footer;
-    const length = footer.length;
-    let footerFont, i;
-    if (length) {
-      const rtlHelper = getRtlAdapter(options.rtl, this.x, this.width);
-      pt.x = getAlignedX(this, options.footerAlign, options);
-      pt.y += options.footerMarginTop;
-      ctx.textAlign = rtlHelper.textAlign(options.footerAlign);
-      ctx.textBaseline = "middle";
-      footerFont = toFont(options.footerFont);
-      ctx.fillStyle = options.footerColor;
-      ctx.font = footerFont.string;
-      for (i = 0; i < length; ++i) {
-        ctx.fillText(footer[i], rtlHelper.x(pt.x), pt.y + footerFont.lineHeight / 2);
-        pt.y += footerFont.lineHeight + options.footerSpacing;
-      }
-    }
-  }
-  drawBackground(pt, ctx, tooltipSize, options) {
-    const { xAlign, yAlign } = this;
-    const { x: x2, y: y2 } = pt;
-    const { width, height } = tooltipSize;
-    const { topLeft, topRight, bottomLeft, bottomRight } = toTRBLCorners(options.cornerRadius);
-    ctx.fillStyle = options.backgroundColor;
-    ctx.strokeStyle = options.borderColor;
-    ctx.lineWidth = options.borderWidth;
-    ctx.beginPath();
-    ctx.moveTo(x2 + topLeft, y2);
-    if (yAlign === "top") {
-      this.drawCaret(pt, ctx, tooltipSize, options);
-    }
-    ctx.lineTo(x2 + width - topRight, y2);
-    ctx.quadraticCurveTo(x2 + width, y2, x2 + width, y2 + topRight);
-    if (yAlign === "center" && xAlign === "right") {
-      this.drawCaret(pt, ctx, tooltipSize, options);
-    }
-    ctx.lineTo(x2 + width, y2 + height - bottomRight);
-    ctx.quadraticCurveTo(x2 + width, y2 + height, x2 + width - bottomRight, y2 + height);
-    if (yAlign === "bottom") {
-      this.drawCaret(pt, ctx, tooltipSize, options);
-    }
-    ctx.lineTo(x2 + bottomLeft, y2 + height);
-    ctx.quadraticCurveTo(x2, y2 + height, x2, y2 + height - bottomLeft);
-    if (yAlign === "center" && xAlign === "left") {
-      this.drawCaret(pt, ctx, tooltipSize, options);
-    }
-    ctx.lineTo(x2, y2 + topLeft);
-    ctx.quadraticCurveTo(x2, y2, x2 + topLeft, y2);
-    ctx.closePath();
-    ctx.fill();
-    if (options.borderWidth > 0) {
-      ctx.stroke();
-    }
-  }
-  _updateAnimationTarget(options) {
-    const chart = this.chart;
-    const anims = this.$animations;
-    const animX = anims && anims.x;
-    const animY = anims && anims.y;
-    if (animX || animY) {
-      const position = positioners[options.position].call(this, this._active, this._eventPosition);
-      if (!position) {
-        return;
-      }
-      const size = this._size = getTooltipSize(this, options);
-      const positionAndSize = Object.assign({}, position, this._size);
-      const alignment = determineAlignment(chart, options, positionAndSize);
-      const point = getBackgroundPoint(options, positionAndSize, alignment, chart);
-      if (animX._to !== point.x || animY._to !== point.y) {
-        this.xAlign = alignment.xAlign;
-        this.yAlign = alignment.yAlign;
-        this.width = size.width;
-        this.height = size.height;
-        this.caretX = position.x;
-        this.caretY = position.y;
-        this._resolveAnimations().update(this, point);
-      }
-    }
-  }
-  _willRender() {
-    return !!this.opacity;
-  }
-  draw(ctx) {
-    const options = this.options.setContext(this.getContext());
-    let opacity = this.opacity;
-    if (!opacity) {
-      return;
-    }
-    this._updateAnimationTarget(options);
-    const tooltipSize = {
-      width: this.width,
-      height: this.height
-    };
-    const pt = {
-      x: this.x,
-      y: this.y
-    };
-    opacity = Math.abs(opacity) < 1e-3 ? 0 : opacity;
-    const padding = toPadding(options.padding);
-    const hasTooltipContent = this.title.length || this.beforeBody.length || this.body.length || this.afterBody.length || this.footer.length;
-    if (options.enabled && hasTooltipContent) {
-      ctx.save();
-      ctx.globalAlpha = opacity;
-      this.drawBackground(pt, ctx, tooltipSize, options);
-      overrideTextDirection(ctx, options.textDirection);
-      pt.y += padding.top;
-      this.drawTitle(pt, ctx, options);
-      this.drawBody(pt, ctx, options);
-      this.drawFooter(pt, ctx, options);
-      restoreTextDirection(ctx, options.textDirection);
-      ctx.restore();
-    }
-  }
-  getActiveElements() {
-    return this._active || [];
-  }
-  setActiveElements(activeElements, eventPosition) {
-    const lastActive = this._active;
-    const active = activeElements.map(({ datasetIndex, index }) => {
-      const meta = this.chart.getDatasetMeta(datasetIndex);
-      if (!meta) {
-        throw new Error("Cannot find a dataset at index " + datasetIndex);
-      }
-      return {
-        datasetIndex,
-        element: meta.data[index],
-        index
-      };
-    });
-    const changed = !_elementsEqual(lastActive, active);
-    const positionChanged = this._positionChanged(active, eventPosition);
-    if (changed || positionChanged) {
-      this._active = active;
-      this._eventPosition = eventPosition;
-      this._ignoreReplayEvents = true;
-      this.update(true);
-    }
-  }
-  handleEvent(e, replay, inChartArea = true) {
-    if (replay && this._ignoreReplayEvents) {
-      return false;
-    }
-    this._ignoreReplayEvents = false;
-    const options = this.options;
-    const lastActive = this._active || [];
-    const active = this._getActiveElements(e, lastActive, replay, inChartArea);
-    const positionChanged = this._positionChanged(active, e);
-    const changed = replay || !_elementsEqual(active, lastActive) || positionChanged;
-    if (changed) {
-      this._active = active;
-      if (options.enabled || options.external) {
-        this._eventPosition = {
-          x: e.x,
-          y: e.y
-        };
-        this.update(true, replay);
-      }
-    }
-    return changed;
-  }
-  _getActiveElements(e, lastActive, replay, inChartArea) {
-    const options = this.options;
-    if (e.type === "mouseout") {
-      return [];
-    }
-    if (!inChartArea) {
-      return lastActive.filter((i) => this.chart.data.datasets[i.datasetIndex] && this.chart.getDatasetMeta(i.datasetIndex).controller.getParsed(i.index) !== void 0);
-    }
-    const active = this.chart.getElementsAtEventForMode(e, options.mode, options, replay);
-    if (options.reverse) {
-      active.reverse();
-    }
-    return active;
-  }
-  _positionChanged(active, e) {
-    const { caretX, caretY, options } = this;
-    const position = positioners[options.position].call(this, active, e);
-    return position !== false && (caretX !== position.x || caretY !== position.y);
-  }
-}
-__publicField(Tooltip, "positioners", positioners);
-var plugin_tooltip = {
-  id: "tooltip",
-  _element: Tooltip,
-  positioners,
-  afterInit(chart, _args, options) {
-    if (options) {
-      chart.tooltip = new Tooltip({
-        chart,
-        options
       });
-    }
-  },
-  beforeUpdate(chart, _args, options) {
-    if (chart.tooltip) {
-      chart.tooltip.initialize(options);
-    }
-  },
-  reset(chart, _args, options) {
-    if (chart.tooltip) {
-      chart.tooltip.initialize(options);
-    }
-  },
-  afterDraw(chart) {
-    const tooltip = chart.tooltip;
-    if (tooltip && tooltip._willRender()) {
-      const args = {
-        tooltip
-      };
-      if (chart.notifyPlugins("beforeTooltipDraw", {
-        ...args,
-        cancelable: true
-      }) === false) {
-        return;
-      }
-      tooltip.draw(chart.ctx);
-      chart.notifyPlugins("afterTooltipDraw", args);
-    }
-  },
-  afterEvent(chart, args) {
-    if (chart.tooltip) {
-      const useFinalPosition = args.replay;
-      if (chart.tooltip.handleEvent(args.event, useFinalPosition, args.inChartArea)) {
-        args.changed = true;
-      }
-    }
-  },
-  defaults: {
-    enabled: true,
-    external: null,
-    position: "average",
-    backgroundColor: "rgba(0,0,0,0.8)",
-    titleColor: "#fff",
-    titleFont: {
-      weight: "bold"
-    },
-    titleSpacing: 2,
-    titleMarginBottom: 6,
-    titleAlign: "left",
-    bodyColor: "#fff",
-    bodySpacing: 2,
-    bodyFont: {},
-    bodyAlign: "left",
-    footerColor: "#fff",
-    footerSpacing: 2,
-    footerMarginTop: 6,
-    footerFont: {
-      weight: "bold"
-    },
-    footerAlign: "left",
-    padding: 6,
-    caretPadding: 2,
-    caretSize: 5,
-    cornerRadius: 6,
-    boxHeight: (ctx, opts) => opts.bodyFont.size,
-    boxWidth: (ctx, opts) => opts.bodyFont.size,
-    multiKeyBackground: "#fff",
-    displayColors: true,
-    boxPadding: 0,
-    borderColor: "rgba(0,0,0,0)",
-    borderWidth: 0,
-    animation: {
-      duration: 400,
-      easing: "easeOutQuart"
-    },
-    animations: {
-      numbers: {
-        type: "number",
-        properties: [
-          "x",
-          "y",
-          "width",
-          "height",
-          "caretX",
-          "caretY"
-        ]
-      },
-      opacity: {
-        easing: "linear",
-        duration: 200
-      }
-    },
-    callbacks: defaultCallbacks
-  },
-  defaultRoutes: {
-    bodyFont: "font",
-    footerFont: "font",
-    titleFont: "font"
-  },
-  descriptors: {
-    _scriptable: (name) => name !== "filter" && name !== "itemSort" && name !== "external",
-    _indexable: false,
-    callbacks: {
-      _scriptable: false,
-      _indexable: false
-    },
-    animation: {
-      _fallback: false
-    },
-    animations: {
-      _fallback: "animation"
-    }
-  },
-  additionalOptionScopes: [
-    "interaction"
-  ]
-};
-function generateTicks$1(generationOptions, dataRange) {
-  const ticks = [];
-  const MIN_SPACING = 1e-14;
-  const { bounds, step, min, max, precision, count, maxTicks, maxDigits, includeBounds } = generationOptions;
-  const unit = step || 1;
-  const maxSpaces = maxTicks - 1;
-  const { min: rmin, max: rmax } = dataRange;
-  const minDefined = !isNullOrUndef(min);
-  const maxDefined = !isNullOrUndef(max);
-  const countDefined = !isNullOrUndef(count);
-  const minSpacing = (rmax - rmin) / (maxDigits + 1);
-  let spacing = niceNum((rmax - rmin) / maxSpaces / unit) * unit;
-  let factor, niceMin, niceMax, numSpaces;
-  if (spacing < MIN_SPACING && !minDefined && !maxDefined) {
-    return [
-      {
-        value: rmin
-      },
-      {
-        value: rmax
-      }
-    ];
-  }
-  numSpaces = Math.ceil(rmax / spacing) - Math.floor(rmin / spacing);
-  if (numSpaces > maxSpaces) {
-    spacing = niceNum(numSpaces * spacing / maxSpaces / unit) * unit;
-  }
-  if (!isNullOrUndef(precision)) {
-    factor = Math.pow(10, precision);
-    spacing = Math.ceil(spacing * factor) / factor;
-  }
-  if (bounds === "ticks") {
-    niceMin = Math.floor(rmin / spacing) * spacing;
-    niceMax = Math.ceil(rmax / spacing) * spacing;
-  } else {
-    niceMin = rmin;
-    niceMax = rmax;
-  }
-  if (minDefined && maxDefined && step && almostWhole((max - min) / step, spacing / 1e3)) {
-    numSpaces = Math.round(Math.min((max - min) / spacing, maxTicks));
-    spacing = (max - min) / numSpaces;
-    niceMin = min;
-    niceMax = max;
-  } else if (countDefined) {
-    niceMin = minDefined ? min : niceMin;
-    niceMax = maxDefined ? max : niceMax;
-    numSpaces = count - 1;
-    spacing = (niceMax - niceMin) / numSpaces;
-  } else {
-    numSpaces = (niceMax - niceMin) / spacing;
-    if (almostEquals(numSpaces, Math.round(numSpaces), spacing / 1e3)) {
-      numSpaces = Math.round(numSpaces);
-    } else {
-      numSpaces = Math.ceil(numSpaces);
-    }
-  }
-  const decimalPlaces = Math.max(_decimalPlaces(spacing), _decimalPlaces(niceMin));
-  factor = Math.pow(10, isNullOrUndef(precision) ? decimalPlaces : precision);
-  niceMin = Math.round(niceMin * factor) / factor;
-  niceMax = Math.round(niceMax * factor) / factor;
-  let j = 0;
-  if (minDefined) {
-    if (includeBounds && niceMin !== min) {
-      ticks.push({
-        value: min
+      var require_is_value = __commonJS({
+        "node_modules/es5-ext/object/is-value.js"(exports, module2) {
+          var _undefined = require_noop2()();
+          module2.exports = function(val) {
+            return val !== _undefined && val !== null;
+          };
+        }
       });
-      if (niceMin < min) {
-        j++;
-      }
-      if (almostEquals(Math.round((niceMin + j * spacing) * factor) / factor, min, relativeLabelSize(min, minSpacing, generationOptions))) {
-        j++;
-      }
-    } else if (niceMin < min) {
-      j++;
-    }
-  }
-  for (; j < numSpaces; ++j) {
-    const tickValue = Math.round((niceMin + j * spacing) * factor) / factor;
-    if (maxDefined && tickValue > max) {
-      break;
-    }
-    ticks.push({
-      value: tickValue
-    });
-  }
-  if (maxDefined && includeBounds && niceMax !== max) {
-    if (ticks.length && almostEquals(ticks[ticks.length - 1].value, max, relativeLabelSize(max, minSpacing, generationOptions))) {
-      ticks[ticks.length - 1].value = max;
-    } else {
-      ticks.push({
-        value: max
+      var require_is_implemented2 = __commonJS({
+        "node_modules/es5-ext/object/set-prototype-of/is-implemented.js"(exports, module2) {
+          var create2 = Object.create;
+          var getPrototypeOf = Object.getPrototypeOf;
+          var plainObject = {};
+          module2.exports = function() {
+            var setPrototypeOf = Object.setPrototypeOf, customCreate = arguments[0] || create2;
+            if (typeof setPrototypeOf !== "function") return false;
+            return getPrototypeOf(setPrototypeOf(customCreate(null), plainObject)) === plainObject;
+          };
+        }
       });
-    }
-  } else if (!maxDefined || niceMax === max) {
-    ticks.push({
-      value: niceMax
-    });
-  }
-  return ticks;
-}
-function relativeLabelSize(value, minSpacing, { horizontal, minRotation }) {
-  const rad = toRadians(minRotation);
-  const ratio = (horizontal ? Math.sin(rad) : Math.cos(rad)) || 1e-3;
-  const length = 0.75 * minSpacing * ("" + value).length;
-  return Math.min(minSpacing / ratio, length);
-}
-class LinearScaleBase extends Scale {
-  constructor(cfg) {
-    super(cfg);
-    this.start = void 0;
-    this.end = void 0;
-    this._startValue = void 0;
-    this._endValue = void 0;
-    this._valueRange = 0;
-  }
-  parse(raw, index) {
-    if (isNullOrUndef(raw)) {
-      return null;
-    }
-    if ((typeof raw === "number" || raw instanceof Number) && !isFinite(+raw)) {
-      return null;
-    }
-    return +raw;
-  }
-  handleTickRangeOptions() {
-    const { beginAtZero } = this.options;
-    const { minDefined, maxDefined } = this.getUserBounds();
-    let { min, max } = this;
-    const setMin = (v2) => min = minDefined ? min : v2;
-    const setMax = (v2) => max = maxDefined ? max : v2;
-    if (beginAtZero) {
-      const minSign = sign(min);
-      const maxSign = sign(max);
-      if (minSign < 0 && maxSign < 0) {
-        setMax(0);
-      } else if (minSign > 0 && maxSign > 0) {
-        setMin(0);
-      }
-    }
-    if (min === max) {
-      let offset = max === 0 ? 1 : Math.abs(max * 0.05);
-      setMax(max + offset);
-      if (!beginAtZero) {
-        setMin(min - offset);
-      }
-    }
-    this.min = min;
-    this.max = max;
-  }
-  getTickLimit() {
-    const tickOpts = this.options.ticks;
-    let { maxTicksLimit, stepSize } = tickOpts;
-    let maxTicks;
-    if (stepSize) {
-      maxTicks = Math.ceil(this.max / stepSize) - Math.floor(this.min / stepSize) + 1;
-      if (maxTicks > 1e3) {
-        console.warn(`scales.${this.id}.ticks.stepSize: ${stepSize} would result generating up to ${maxTicks} ticks. Limiting to 1000.`);
-        maxTicks = 1e3;
-      }
-    } else {
-      maxTicks = this.computeTickLimit();
-      maxTicksLimit = maxTicksLimit || 11;
-    }
-    if (maxTicksLimit) {
-      maxTicks = Math.min(maxTicksLimit, maxTicks);
-    }
-    return maxTicks;
-  }
-  computeTickLimit() {
-    return Number.POSITIVE_INFINITY;
-  }
-  buildTicks() {
-    const opts = this.options;
-    const tickOpts = opts.ticks;
-    let maxTicks = this.getTickLimit();
-    maxTicks = Math.max(2, maxTicks);
-    const numericGeneratorOptions = {
-      maxTicks,
-      bounds: opts.bounds,
-      min: opts.min,
-      max: opts.max,
-      precision: tickOpts.precision,
-      step: tickOpts.stepSize,
-      count: tickOpts.count,
-      maxDigits: this._maxDigits(),
-      horizontal: this.isHorizontal(),
-      minRotation: tickOpts.minRotation || 0,
-      includeBounds: tickOpts.includeBounds !== false
-    };
-    const dataRange = this._range || this;
-    const ticks = generateTicks$1(numericGeneratorOptions, dataRange);
-    if (opts.bounds === "ticks") {
-      _setMinAndMaxByKey(ticks, this, "value");
-    }
-    if (opts.reverse) {
-      ticks.reverse();
-      this.start = this.max;
-      this.end = this.min;
-    } else {
-      this.start = this.min;
-      this.end = this.max;
-    }
-    return ticks;
-  }
-  configure() {
-    const ticks = this.ticks;
-    let start = this.min;
-    let end = this.max;
-    super.configure();
-    if (this.options.offset && ticks.length) {
-      const offset = (end - start) / Math.max(ticks.length - 1, 1) / 2;
-      start -= offset;
-      end += offset;
-    }
-    this._startValue = start;
-    this._endValue = end;
-    this._valueRange = end - start;
-  }
-  getLabelForValue(value) {
-    return formatNumber(value, this.chart.options.locale, this.options.ticks.format);
-  }
-}
-class LinearScale extends LinearScaleBase {
-  determineDataLimits() {
-    const { min, max } = this.getMinMax(true);
-    this.min = isNumberFinite(min) ? min : 0;
-    this.max = isNumberFinite(max) ? max : 1;
-    this.handleTickRangeOptions();
-  }
-  computeTickLimit() {
-    const horizontal = this.isHorizontal();
-    const length = horizontal ? this.width : this.height;
-    const minRotation = toRadians(this.options.ticks.minRotation);
-    const ratio = (horizontal ? Math.sin(minRotation) : Math.cos(minRotation)) || 1e-3;
-    const tickFont = this._resolveTickFontOptions(0);
-    return Math.ceil(length / Math.min(40, tickFont.lineHeight / ratio));
-  }
-  getPixelForValue(value) {
-    return value === null ? NaN : this.getPixelForDecimal((value - this._startValue) / this._valueRange);
-  }
-  getValueForPixel(pixel) {
-    return this._startValue + this.getDecimalForPixel(pixel) * this._valueRange;
-  }
-}
-__publicField(LinearScale, "id", "linear");
-__publicField(LinearScale, "defaults", {
-  ticks: {
-    callback: Ticks.formatters.numeric
-  }
-});
-const INTERVALS = {
-  millisecond: {
-    common: true,
-    size: 1,
-    steps: 1e3
-  },
-  second: {
-    common: true,
-    size: 1e3,
-    steps: 60
-  },
-  minute: {
-    common: true,
-    size: 6e4,
-    steps: 60
-  },
-  hour: {
-    common: true,
-    size: 36e5,
-    steps: 24
-  },
-  day: {
-    common: true,
-    size: 864e5,
-    steps: 30
-  },
-  week: {
-    common: false,
-    size: 6048e5,
-    steps: 4
-  },
-  month: {
-    common: true,
-    size: 2628e6,
-    steps: 12
-  },
-  quarter: {
-    common: false,
-    size: 7884e6,
-    steps: 4
-  },
-  year: {
-    common: true,
-    size: 3154e7
-  }
-};
-const UNITS = /* @__PURE__ */ Object.keys(INTERVALS);
-function sorter(a, b) {
-  return a - b;
-}
-function parse$1(scale, input) {
-  if (isNullOrUndef(input)) {
-    return null;
-  }
-  const adapter = scale._adapter;
-  const { parser, round: round2, isoWeekday } = scale._parseOpts;
-  let value = input;
-  if (typeof parser === "function") {
-    value = parser(value);
-  }
-  if (!isNumberFinite(value)) {
-    value = typeof parser === "string" ? adapter.parse(value, parser) : adapter.parse(value);
-  }
-  if (value === null) {
-    return null;
-  }
-  if (round2) {
-    value = round2 === "week" && (isNumber(isoWeekday) || isoWeekday === true) ? adapter.startOf(value, "isoWeek", isoWeekday) : adapter.startOf(value, round2);
-  }
-  return +value;
-}
-function determineUnitForAutoTicks(minUnit, min, max, capacity) {
-  const ilen = UNITS.length;
-  for (let i = UNITS.indexOf(minUnit); i < ilen - 1; ++i) {
-    const interval = INTERVALS[UNITS[i]];
-    const factor = interval.steps ? interval.steps : Number.MAX_SAFE_INTEGER;
-    if (interval.common && Math.ceil((max - min) / (factor * interval.size)) <= capacity) {
-      return UNITS[i];
-    }
-  }
-  return UNITS[ilen - 1];
-}
-function determineUnitForFormatting(scale, numTicks, minUnit, min, max) {
-  for (let i = UNITS.length - 1; i >= UNITS.indexOf(minUnit); i--) {
-    const unit = UNITS[i];
-    if (INTERVALS[unit].common && scale._adapter.diff(max, min, unit) >= numTicks - 1) {
-      return unit;
-    }
-  }
-  return UNITS[minUnit ? UNITS.indexOf(minUnit) : 0];
-}
-function determineMajorUnit(unit) {
-  for (let i = UNITS.indexOf(unit) + 1, ilen = UNITS.length; i < ilen; ++i) {
-    if (INTERVALS[UNITS[i]].common) {
-      return UNITS[i];
-    }
-  }
-}
-function addTick(ticks, time, timestamps) {
-  if (!timestamps) {
-    ticks[time] = true;
-  } else if (timestamps.length) {
-    const { lo, hi: hi2 } = _lookup(timestamps, time);
-    const timestamp = timestamps[lo] >= time ? timestamps[lo] : timestamps[hi2];
-    ticks[timestamp] = true;
-  }
-}
-function setMajorTicks(scale, ticks, map2, majorUnit) {
-  const adapter = scale._adapter;
-  const first = +adapter.startOf(ticks[0].value, majorUnit);
-  const last = ticks[ticks.length - 1].value;
-  let major, index;
-  for (major = first; major <= last; major = +adapter.add(major, 1, majorUnit)) {
-    index = map2[major];
-    if (index >= 0) {
-      ticks[index].major = true;
-    }
-  }
-  return ticks;
-}
-function ticksFromTimestamps(scale, values, majorUnit) {
-  const ticks = [];
-  const map2 = {};
-  const ilen = values.length;
-  let i, value;
-  for (i = 0; i < ilen; ++i) {
-    value = values[i];
-    map2[value] = i;
-    ticks.push({
-      value,
-      major: false
-    });
-  }
-  return ilen === 0 || !majorUnit ? ticks : setMajorTicks(scale, ticks, map2, majorUnit);
-}
-class TimeScale extends Scale {
-  constructor(props) {
-    super(props);
-    this._cache = {
-      data: [],
-      labels: [],
-      all: []
-    };
-    this._unit = "day";
-    this._majorUnit = void 0;
-    this._offsets = {};
-    this._normalized = false;
-    this._parseOpts = void 0;
-  }
-  init(scaleOpts, opts = {}) {
-    const time = scaleOpts.time || (scaleOpts.time = {});
-    const adapter = this._adapter = new adapters._date(scaleOpts.adapters.date);
-    adapter.init(opts);
-    mergeIf(time.displayFormats, adapter.formats());
-    this._parseOpts = {
-      parser: time.parser,
-      round: time.round,
-      isoWeekday: time.isoWeekday
-    };
-    super.init(scaleOpts);
-    this._normalized = opts.normalized;
-  }
-  parse(raw, index) {
-    if (raw === void 0) {
-      return null;
-    }
-    return parse$1(this, raw);
-  }
-  beforeLayout() {
-    super.beforeLayout();
-    this._cache = {
-      data: [],
-      labels: [],
-      all: []
-    };
-  }
-  determineDataLimits() {
-    const options = this.options;
-    const adapter = this._adapter;
-    const unit = options.time.unit || "day";
-    let { min, max, minDefined, maxDefined } = this.getUserBounds();
-    function _applyBounds(bounds) {
-      if (!minDefined && !isNaN(bounds.min)) {
-        min = Math.min(min, bounds.min);
-      }
-      if (!maxDefined && !isNaN(bounds.max)) {
-        max = Math.max(max, bounds.max);
-      }
-    }
-    if (!minDefined || !maxDefined) {
-      _applyBounds(this._getLabelBounds());
-      if (options.bounds !== "ticks" || options.ticks.source !== "labels") {
-        _applyBounds(this.getMinMax(false));
-      }
-    }
-    min = isNumberFinite(min) && !isNaN(min) ? min : +adapter.startOf(Date.now(), unit);
-    max = isNumberFinite(max) && !isNaN(max) ? max : +adapter.endOf(Date.now(), unit) + 1;
-    this.min = Math.min(min, max - 1);
-    this.max = Math.max(min + 1, max);
-  }
-  _getLabelBounds() {
-    const arr = this.getLabelTimestamps();
-    let min = Number.POSITIVE_INFINITY;
-    let max = Number.NEGATIVE_INFINITY;
-    if (arr.length) {
-      min = arr[0];
-      max = arr[arr.length - 1];
-    }
-    return {
-      min,
-      max
-    };
-  }
-  buildTicks() {
-    const options = this.options;
-    const timeOpts = options.time;
-    const tickOpts = options.ticks;
-    const timestamps = tickOpts.source === "labels" ? this.getLabelTimestamps() : this._generate();
-    if (options.bounds === "ticks" && timestamps.length) {
-      this.min = this._userMin || timestamps[0];
-      this.max = this._userMax || timestamps[timestamps.length - 1];
-    }
-    const min = this.min;
-    const max = this.max;
-    const ticks = _filterBetween(timestamps, min, max);
-    this._unit = timeOpts.unit || (tickOpts.autoSkip ? determineUnitForAutoTicks(timeOpts.minUnit, this.min, this.max, this._getLabelCapacity(min)) : determineUnitForFormatting(this, ticks.length, timeOpts.minUnit, this.min, this.max));
-    this._majorUnit = !tickOpts.major.enabled || this._unit === "year" ? void 0 : determineMajorUnit(this._unit);
-    this.initOffsets(timestamps);
-    if (options.reverse) {
-      ticks.reverse();
-    }
-    return ticksFromTimestamps(this, ticks, this._majorUnit);
-  }
-  afterAutoSkip() {
-    if (this.options.offsetAfterAutoskip) {
-      this.initOffsets(this.ticks.map((tick) => +tick.value));
-    }
-  }
-  initOffsets(timestamps = []) {
-    let start = 0;
-    let end = 0;
-    let first, last;
-    if (this.options.offset && timestamps.length) {
-      first = this.getDecimalForValue(timestamps[0]);
-      if (timestamps.length === 1) {
-        start = 1 - first;
-      } else {
-        start = (this.getDecimalForValue(timestamps[1]) - first) / 2;
-      }
-      last = this.getDecimalForValue(timestamps[timestamps.length - 1]);
-      if (timestamps.length === 1) {
-        end = last;
-      } else {
-        end = (last - this.getDecimalForValue(timestamps[timestamps.length - 2])) / 2;
-      }
-    }
-    const limit = timestamps.length < 3 ? 0.5 : 0.25;
-    start = _limitValue(start, 0, limit);
-    end = _limitValue(end, 0, limit);
-    this._offsets = {
-      start,
-      end,
-      factor: 1 / (start + 1 + end)
-    };
-  }
-  _generate() {
-    const adapter = this._adapter;
-    const min = this.min;
-    const max = this.max;
-    const options = this.options;
-    const timeOpts = options.time;
-    const minor = timeOpts.unit || determineUnitForAutoTicks(timeOpts.minUnit, min, max, this._getLabelCapacity(min));
-    const stepSize = valueOrDefault(options.ticks.stepSize, 1);
-    const weekday = minor === "week" ? timeOpts.isoWeekday : false;
-    const hasWeekday = isNumber(weekday) || weekday === true;
-    const ticks = {};
-    let first = min;
-    let time, count;
-    if (hasWeekday) {
-      first = +adapter.startOf(first, "isoWeek", weekday);
-    }
-    first = +adapter.startOf(first, hasWeekday ? "day" : minor);
-    if (adapter.diff(max, min, minor) > 1e5 * stepSize) {
-      throw new Error(min + " and " + max + " are too far apart with stepSize of " + stepSize + " " + minor);
-    }
-    const timestamps = options.ticks.source === "data" && this.getDataTimestamps();
-    for (time = first, count = 0; time < max; time = +adapter.add(time, stepSize, minor), count++) {
-      addTick(ticks, time, timestamps);
-    }
-    if (time === max || options.bounds === "ticks" || count === 1) {
-      addTick(ticks, time, timestamps);
-    }
-    return Object.keys(ticks).sort(sorter).map((x2) => +x2);
-  }
-  getLabelForValue(value) {
-    const adapter = this._adapter;
-    const timeOpts = this.options.time;
-    if (timeOpts.tooltipFormat) {
-      return adapter.format(value, timeOpts.tooltipFormat);
-    }
-    return adapter.format(value, timeOpts.displayFormats.datetime);
-  }
-  format(value, format2) {
-    const options = this.options;
-    const formats = options.time.displayFormats;
-    const unit = this._unit;
-    const fmt = format2 || formats[unit];
-    return this._adapter.format(value, fmt);
-  }
-  _tickFormatFunction(time, index, ticks, format2) {
-    const options = this.options;
-    const formatter = options.ticks.callback;
-    if (formatter) {
-      return callback(formatter, [
-        time,
-        index,
-        ticks
-      ], this);
-    }
-    const formats = options.time.displayFormats;
-    const unit = this._unit;
-    const majorUnit = this._majorUnit;
-    const minorFormat = unit && formats[unit];
-    const majorFormat = majorUnit && formats[majorUnit];
-    const tick = ticks[index];
-    const major = majorUnit && majorFormat && tick && tick.major;
-    return this._adapter.format(time, format2 || (major ? majorFormat : minorFormat));
-  }
-  generateTickLabels(ticks) {
-    let i, ilen, tick;
-    for (i = 0, ilen = ticks.length; i < ilen; ++i) {
-      tick = ticks[i];
-      tick.label = this._tickFormatFunction(tick.value, i, ticks);
-    }
-  }
-  getDecimalForValue(value) {
-    return value === null ? NaN : (value - this.min) / (this.max - this.min);
-  }
-  getPixelForValue(value) {
-    const offsets = this._offsets;
-    const pos = this.getDecimalForValue(value);
-    return this.getPixelForDecimal((offsets.start + pos) * offsets.factor);
-  }
-  getValueForPixel(pixel) {
-    const offsets = this._offsets;
-    const pos = this.getDecimalForPixel(pixel) / offsets.factor - offsets.end;
-    return this.min + pos * (this.max - this.min);
-  }
-  _getLabelSize(label) {
-    const ticksOpts = this.options.ticks;
-    const tickLabelWidth = this.ctx.measureText(label).width;
-    const angle = toRadians(this.isHorizontal() ? ticksOpts.maxRotation : ticksOpts.minRotation);
-    const cosRotation = Math.cos(angle);
-    const sinRotation = Math.sin(angle);
-    const tickFontSize = this._resolveTickFontOptions(0).size;
-    return {
-      w: tickLabelWidth * cosRotation + tickFontSize * sinRotation,
-      h: tickLabelWidth * sinRotation + tickFontSize * cosRotation
-    };
-  }
-  _getLabelCapacity(exampleTime) {
-    const timeOpts = this.options.time;
-    const displayFormats = timeOpts.displayFormats;
-    const format2 = displayFormats[timeOpts.unit] || displayFormats.millisecond;
-    const exampleLabel = this._tickFormatFunction(exampleTime, 0, ticksFromTimestamps(this, [
-      exampleTime
-    ], this._majorUnit), format2);
-    const size = this._getLabelSize(exampleLabel);
-    const capacity = Math.floor(this.isHorizontal() ? this.width / size.w : this.height / size.h) - 1;
-    return capacity > 0 ? capacity : 1;
-  }
-  getDataTimestamps() {
-    let timestamps = this._cache.data || [];
-    let i, ilen;
-    if (timestamps.length) {
-      return timestamps;
-    }
-    const metas = this.getMatchingVisibleMetas();
-    if (this._normalized && metas.length) {
-      return this._cache.data = metas[0].controller.getAllParsedValues(this);
-    }
-    for (i = 0, ilen = metas.length; i < ilen; ++i) {
-      timestamps = timestamps.concat(metas[i].controller.getAllParsedValues(this));
-    }
-    return this._cache.data = this.normalize(timestamps);
-  }
-  getLabelTimestamps() {
-    const timestamps = this._cache.labels || [];
-    let i, ilen;
-    if (timestamps.length) {
-      return timestamps;
-    }
-    const labels = this.getLabels();
-    for (i = 0, ilen = labels.length; i < ilen; ++i) {
-      timestamps.push(parse$1(this, labels[i]));
-    }
-    return this._cache.labels = this._normalized ? timestamps : this.normalize(timestamps);
-  }
-  normalize(values) {
-    return _arrayUnique(values.sort(sorter));
-  }
-}
-__publicField(TimeScale, "id", "time");
-__publicField(TimeScale, "defaults", {
-  bounds: "data",
-  adapters: {},
-  time: {
-    parser: false,
-    unit: false,
-    round: false,
-    isoWeekday: false,
-    minUnit: "millisecond",
-    displayFormats: {}
-  },
-  ticks: {
-    source: "auto",
-    callback: false,
-    major: {
-      enabled: false
-    }
-  }
-});
-function interpolate(table, val, reverse) {
-  let lo = 0;
-  let hi2 = table.length - 1;
-  let prevSource, nextSource, prevTarget, nextTarget;
-  if (reverse) {
-    if (val >= table[lo].pos && val <= table[hi2].pos) {
-      ({ lo, hi: hi2 } = _lookupByKey(table, "pos", val));
-    }
-    ({ pos: prevSource, time: prevTarget } = table[lo]);
-    ({ pos: nextSource, time: nextTarget } = table[hi2]);
-  } else {
-    if (val >= table[lo].time && val <= table[hi2].time) {
-      ({ lo, hi: hi2 } = _lookupByKey(table, "time", val));
-    }
-    ({ time: prevSource, pos: prevTarget } = table[lo]);
-    ({ time: nextSource, pos: nextTarget } = table[hi2]);
-  }
-  const span = nextSource - prevSource;
-  return span ? prevTarget + (nextTarget - prevTarget) * (val - prevSource) / span : prevTarget;
-}
-class TimeSeriesScale extends TimeScale {
-  constructor(props) {
-    super(props);
-    this._table = [];
-    this._minPos = void 0;
-    this._tableRange = void 0;
-  }
-  initOffsets() {
-    const timestamps = this._getTimestampsForTable();
-    const table = this._table = this.buildLookupTable(timestamps);
-    this._minPos = interpolate(table, this.min);
-    this._tableRange = interpolate(table, this.max) - this._minPos;
-    super.initOffsets(timestamps);
-  }
-  buildLookupTable(timestamps) {
-    const { min, max } = this;
-    const items = [];
-    const table = [];
-    let i, ilen, prev, curr, next;
-    for (i = 0, ilen = timestamps.length; i < ilen; ++i) {
-      curr = timestamps[i];
-      if (curr >= min && curr <= max) {
-        items.push(curr);
-      }
-    }
-    if (items.length < 2) {
-      return [
-        {
-          time: min,
-          pos: 0
-        },
-        {
-          time: max,
-          pos: 1
+      var require_is_object = __commonJS({
+        "node_modules/es5-ext/object/is-object.js"(exports, module2) {
+          var isValue = require_is_value();
+          var map2 = { function: true, object: true };
+          module2.exports = function(value) {
+            return isValue(value) && map2[typeof value] || false;
+          };
+        }
+      });
+      var require_valid_value = __commonJS({
+        "node_modules/es5-ext/object/valid-value.js"(exports, module2) {
+          var isValue = require_is_value();
+          module2.exports = function(value) {
+            if (!isValue(value)) throw new TypeError("Cannot use null or undefined");
+            return value;
+          };
+        }
+      });
+      var require_create2 = __commonJS({
+        "node_modules/es5-ext/object/create.js"(exports, module2) {
+          var create2 = Object.create;
+          var shim;
+          if (!require_is_implemented2()()) {
+            shim = require_shim3();
+          }
+          module2.exports = function() {
+            var nullObject, polyProps, desc;
+            if (!shim) return create2;
+            if (shim.level !== 1) return create2;
+            nullObject = {};
+            polyProps = {};
+            desc = { configurable: false, enumerable: false, writable: true, value: void 0 };
+            Object.getOwnPropertyNames(Object.prototype).forEach(function(name2) {
+              if (name2 === "__proto__") {
+                polyProps[name2] = {
+                  configurable: true,
+                  enumerable: false,
+                  writable: true,
+                  value: void 0
+                };
+                return;
+              }
+              polyProps[name2] = desc;
+            });
+            Object.defineProperties(nullObject, polyProps);
+            Object.defineProperty(shim, "nullPolyfill", {
+              configurable: false,
+              enumerable: false,
+              writable: false,
+              value: nullObject
+            });
+            return function(prototype, props) {
+              return create2(prototype === null ? nullObject : prototype, props);
+            };
+          }();
+        }
+      });
+      var require_shim3 = __commonJS({
+        "node_modules/es5-ext/object/set-prototype-of/shim.js"(exports, module2) {
+          var isObject2 = require_is_object();
+          var value = require_valid_value();
+          var objIsPrototypeOf = Object.prototype.isPrototypeOf;
+          var defineProperty = Object.defineProperty;
+          var nullDesc = { configurable: true, enumerable: false, writable: true, value: void 0 };
+          var validate;
+          validate = function(obj, prototype) {
+            value(obj);
+            if (prototype === null || isObject2(prototype)) return obj;
+            throw new TypeError("Prototype must be null or an object");
+          };
+          module2.exports = function(status) {
+            var fn, set;
+            if (!status) return null;
+            if (status.level === 2) {
+              if (status.set) {
+                set = status.set;
+                fn = function(obj, prototype) {
+                  set.call(validate(obj, prototype), prototype);
+                  return obj;
+                };
+              } else {
+                fn = function(obj, prototype) {
+                  validate(obj, prototype).__proto__ = prototype;
+                  return obj;
+                };
+              }
+            } else {
+              fn = function self2(obj, prototype) {
+                var isNullBase;
+                validate(obj, prototype);
+                isNullBase = objIsPrototypeOf.call(self2.nullPolyfill, obj);
+                if (isNullBase) delete self2.nullPolyfill.__proto__;
+                if (prototype === null) prototype = self2.nullPolyfill;
+                obj.__proto__ = prototype;
+                if (isNullBase) defineProperty(self2.nullPolyfill, "__proto__", nullDesc);
+                return obj;
+              };
+            }
+            return Object.defineProperty(fn, "level", {
+              configurable: false,
+              enumerable: false,
+              writable: false,
+              value: status.level
+            });
+          }(
+            function() {
+              var tmpObj1 = /* @__PURE__ */ Object.create(null), tmpObj2 = {}, set, desc = Object.getOwnPropertyDescriptor(Object.prototype, "__proto__");
+              if (desc) {
+                try {
+                  set = desc.set;
+                  set.call(tmpObj1, tmpObj2);
+                } catch (ignore) {
+                }
+                if (Object.getPrototypeOf(tmpObj1) === tmpObj2) return { set, level: 2 };
+              }
+              tmpObj1.__proto__ = tmpObj2;
+              if (Object.getPrototypeOf(tmpObj1) === tmpObj2) return { level: 2 };
+              tmpObj1 = {};
+              tmpObj1.__proto__ = tmpObj2;
+              if (Object.getPrototypeOf(tmpObj1) === tmpObj2) return { level: 1 };
+              return false;
+            }()
+          );
+          require_create2();
+        }
+      });
+      var require_set_prototype_of = __commonJS({
+        "node_modules/es5-ext/object/set-prototype-of/index.js"(exports, module2) {
+          module2.exports = require_is_implemented2()() ? Object.setPrototypeOf : require_shim3();
+        }
+      });
+      var require_valid_object = __commonJS({
+        "node_modules/es5-ext/object/valid-object.js"(exports, module2) {
+          var isObject2 = require_is_object();
+          module2.exports = function(value) {
+            if (!isObject2(value)) throw new TypeError(value + " is not an Object");
+            return value;
+          };
+        }
+      });
+      var require_random_uniq = __commonJS({
+        "node_modules/es5-ext/string/random-uniq.js"(exports, module2) {
+          var generated = /* @__PURE__ */ Object.create(null);
+          var random = Math.random;
+          module2.exports = function() {
+            var str;
+            do {
+              str = random().toString(36).slice(2);
+            } while (generated[str]);
+            return str;
+          };
+        }
+      });
+      var require_is = __commonJS({
+        "node_modules/type/value/is.js"(exports, module2) {
+          var _undefined = void 0;
+          module2.exports = function(value) {
+            return value !== _undefined && value !== null;
+          };
+        }
+      });
+      var require_is2 = __commonJS({
+        "node_modules/type/object/is.js"(exports, module2) {
+          var isValue = require_is();
+          var possibleTypes = {
+            "object": true,
+            "function": true,
+            "undefined": true
+            /* document.all */
+          };
+          module2.exports = function(value) {
+            if (!isValue(value)) return false;
+            return hasOwnProperty.call(possibleTypes, typeof value);
+          };
+        }
+      });
+      var require_is3 = __commonJS({
+        "node_modules/type/prototype/is.js"(exports, module2) {
+          var isObject2 = require_is2();
+          module2.exports = function(value) {
+            if (!isObject2(value)) return false;
+            try {
+              if (!value.constructor) return false;
+              return value.constructor.prototype === value;
+            } catch (error) {
+              return false;
+            }
+          };
+        }
+      });
+      var require_is4 = __commonJS({
+        "node_modules/type/function/is.js"(exports, module2) {
+          var isPrototype = require_is3();
+          module2.exports = function(value) {
+            if (typeof value !== "function") return false;
+            if (!hasOwnProperty.call(value, "length")) return false;
+            try {
+              if (typeof value.length !== "number") return false;
+              if (typeof value.call !== "function") return false;
+              if (typeof value.apply !== "function") return false;
+            } catch (error) {
+              return false;
+            }
+            return !isPrototype(value);
+          };
+        }
+      });
+      var require_is5 = __commonJS({
+        "node_modules/type/plain-function/is.js"(exports, module2) {
+          var isFunction2 = require_is4();
+          var classRe = /^\s*class[\s{/}]/;
+          var functionToString = Function.prototype.toString;
+          module2.exports = function(value) {
+            if (!isFunction2(value)) return false;
+            if (classRe.test(functionToString.call(value))) return false;
+            return true;
+          };
+        }
+      });
+      var require_is_implemented3 = __commonJS({
+        "node_modules/es5-ext/object/assign/is-implemented.js"(exports, module2) {
+          module2.exports = function() {
+            var assign = Object.assign, obj;
+            if (typeof assign !== "function") return false;
+            obj = { foo: "raz" };
+            assign(obj, { bar: "dwa" }, { trzy: "trzy" });
+            return obj.foo + obj.bar + obj.trzy === "razdwatrzy";
+          };
+        }
+      });
+      var require_is_implemented4 = __commonJS({
+        "node_modules/es5-ext/object/keys/is-implemented.js"(exports, module2) {
+          module2.exports = function() {
+            try {
+              Object.keys("primitive");
+              return true;
+            } catch (e2) {
+              return false;
+            }
+          };
+        }
+      });
+      var require_shim4 = __commonJS({
+        "node_modules/es5-ext/object/keys/shim.js"(exports, module2) {
+          var isValue = require_is_value();
+          var keys = Object.keys;
+          module2.exports = function(object) {
+            return keys(isValue(object) ? Object(object) : object);
+          };
+        }
+      });
+      var require_keys = __commonJS({
+        "node_modules/es5-ext/object/keys/index.js"(exports, module2) {
+          module2.exports = require_is_implemented4()() ? Object.keys : require_shim4();
+        }
+      });
+      var require_shim5 = __commonJS({
+        "node_modules/es5-ext/object/assign/shim.js"(exports, module2) {
+          var keys = require_keys();
+          var value = require_valid_value();
+          var max = Math.max;
+          module2.exports = function(dest, src) {
+            var error, i2, length2 = max(arguments.length, 2), assign;
+            dest = Object(value(dest));
+            assign = function(key) {
+              try {
+                dest[key] = src[key];
+              } catch (e2) {
+                if (!error) error = e2;
+              }
+            };
+            for (i2 = 1; i2 < length2; ++i2) {
+              src = arguments[i2];
+              keys(src).forEach(assign);
+            }
+            if (error !== void 0) throw error;
+            return dest;
+          };
+        }
+      });
+      var require_assign = __commonJS({
+        "node_modules/es5-ext/object/assign/index.js"(exports, module2) {
+          module2.exports = require_is_implemented3()() ? Object.assign : require_shim5();
+        }
+      });
+      var require_normalize_options = __commonJS({
+        "node_modules/es5-ext/object/normalize-options.js"(exports, module2) {
+          var isValue = require_is_value();
+          var forEach = Array.prototype.forEach;
+          var create2 = Object.create;
+          var process2 = function(src, obj) {
+            var key;
+            for (key in src) obj[key] = src[key];
+          };
+          module2.exports = function(opts1) {
+            var result = create2(null);
+            forEach.call(arguments, function(options) {
+              if (!isValue(options)) return;
+              process2(Object(options), result);
+            });
+            return result;
+          };
+        }
+      });
+      var require_is_implemented5 = __commonJS({
+        "node_modules/es5-ext/string/#/contains/is-implemented.js"(exports, module2) {
+          var str = "razdwatrzy";
+          module2.exports = function() {
+            if (typeof str.contains !== "function") return false;
+            return str.contains("dwa") === true && str.contains("foo") === false;
+          };
+        }
+      });
+      var require_shim6 = __commonJS({
+        "node_modules/es5-ext/string/#/contains/shim.js"(exports, module2) {
+          var indexOf = String.prototype.indexOf;
+          module2.exports = function(searchString) {
+            return indexOf.call(this, searchString, arguments[1]) > -1;
+          };
+        }
+      });
+      var require_contains = __commonJS({
+        "node_modules/es5-ext/string/#/contains/index.js"(exports, module2) {
+          module2.exports = require_is_implemented5()() ? String.prototype.contains : require_shim6();
+        }
+      });
+      var require_d = __commonJS({
+        "node_modules/d/index.js"(exports, module2) {
+          var isValue = require_is();
+          var isPlainFunction = require_is5();
+          var assign = require_assign();
+          var normalizeOpts = require_normalize_options();
+          var contains = require_contains();
+          var d2 = module2.exports = function(dscr, value) {
+            var c2, e2, w2, options, desc;
+            if (arguments.length < 2 || typeof dscr !== "string") {
+              options = value;
+              value = dscr;
+              dscr = null;
+            } else {
+              options = arguments[2];
+            }
+            if (isValue(dscr)) {
+              c2 = contains.call(dscr, "c");
+              e2 = contains.call(dscr, "e");
+              w2 = contains.call(dscr, "w");
+            } else {
+              c2 = w2 = true;
+              e2 = false;
+            }
+            desc = { value, configurable: c2, enumerable: e2, writable: w2 };
+            return !options ? desc : assign(normalizeOpts(options), desc);
+          };
+          d2.gs = function(dscr, get, set) {
+            var c2, e2, options, desc;
+            if (typeof dscr !== "string") {
+              options = set;
+              set = get;
+              get = dscr;
+              dscr = null;
+            } else {
+              options = arguments[3];
+            }
+            if (!isValue(get)) {
+              get = void 0;
+            } else if (!isPlainFunction(get)) {
+              options = get;
+              get = set = void 0;
+            } else if (!isValue(set)) {
+              set = void 0;
+            } else if (!isPlainFunction(set)) {
+              options = set;
+              set = void 0;
+            }
+            if (isValue(dscr)) {
+              c2 = contains.call(dscr, "c");
+              e2 = contains.call(dscr, "e");
+            } else {
+              c2 = true;
+              e2 = false;
+            }
+            desc = { get, set, configurable: c2, enumerable: e2 };
+            return !options ? desc : assign(normalizeOpts(options), desc);
+          };
+        }
+      });
+      var require_is_arguments2 = __commonJS({
+        "node_modules/es5-ext/function/is-arguments.js"(exports, module2) {
+          var objToString = Object.prototype.toString;
+          var id2 = objToString.call(/* @__PURE__ */ function() {
+            return arguments;
+          }());
+          module2.exports = function(value) {
+            return objToString.call(value) === id2;
+          };
+        }
+      });
+      var require_is_string = __commonJS({
+        "node_modules/es5-ext/string/is-string.js"(exports, module2) {
+          var objToString = Object.prototype.toString;
+          var id2 = objToString.call("");
+          module2.exports = function(value) {
+            return typeof value === "string" || value && typeof value === "object" && (value instanceof String || objToString.call(value) === id2) || false;
+          };
+        }
+      });
+      var require_is_implemented6 = __commonJS({
+        "node_modules/ext/global-this/is-implemented.js"(exports, module2) {
+          module2.exports = function() {
+            if (typeof globalThis !== "object") return false;
+            if (!globalThis) return false;
+            return globalThis.Array === Array;
+          };
+        }
+      });
+      var require_implementation6 = __commonJS({
+        "node_modules/ext/global-this/implementation.js"(exports, module2) {
+          var naiveFallback = function() {
+            if (typeof self === "object" && self) return self;
+            if (typeof window === "object" && window) return window;
+            throw new Error("Unable to resolve global `this`");
+          };
+          module2.exports = function() {
+            if (this) return this;
+            try {
+              Object.defineProperty(Object.prototype, "__global__", {
+                get: function() {
+                  return this;
+                },
+                configurable: true
+              });
+            } catch (error) {
+              return naiveFallback();
+            }
+            try {
+              if (!__global__) return naiveFallback();
+              return __global__;
+            } finally {
+              delete Object.prototype.__global__;
+            }
+          }();
         }
-      ];
-    }
-    for (i = 0, ilen = items.length; i < ilen; ++i) {
-      next = items[i + 1];
-      prev = items[i - 1];
-      curr = items[i];
-      if (Math.round((next + prev) / 2) !== curr) {
-        table.push({
-          time: curr,
-          pos: i / (ilen - 1)
-        });
-      }
-    }
-    return table;
-  }
-  _generate() {
-    const min = this.min;
-    const max = this.max;
-    let timestamps = super.getDataTimestamps();
-    if (!timestamps.includes(min) || !timestamps.length) {
-      timestamps.splice(0, 0, min);
-    }
-    if (!timestamps.includes(max) || timestamps.length === 1) {
-      timestamps.push(max);
-    }
-    return timestamps.sort((a, b) => a - b);
-  }
-  _getTimestampsForTable() {
-    let timestamps = this._cache.all || [];
-    if (timestamps.length) {
-      return timestamps;
-    }
-    const data = this.getDataTimestamps();
-    const label = this.getLabelTimestamps();
-    if (data.length && label.length) {
-      timestamps = this.normalize(data.concat(label));
-    } else {
-      timestamps = data.length ? data : label;
-    }
-    timestamps = this._cache.all = timestamps;
-    return timestamps;
-  }
-  getDecimalForValue(value) {
-    return (interpolate(this._table, value) - this._minPos) / this._tableRange;
-  }
-  getValueForPixel(pixel) {
-    const offsets = this._offsets;
-    const decimal = this.getDecimalForPixel(pixel) / offsets.factor - offsets.end;
-    return interpolate(this._table, decimal * this._tableRange + this._minPos, true);
-  }
-}
-__publicField(TimeSeriesScale, "id", "timeseries");
-__publicField(TimeSeriesScale, "defaults", TimeScale.defaults);
-const defaultDatasetIdKey = "label";
-function reforwardRef(ref, value) {
-  if (typeof ref === "function") {
-    ref(value);
-  } else if (ref) {
-    ref.current = value;
-  }
-}
-function setOptions(chart, nextOptions) {
-  const options = chart.options;
-  if (options && nextOptions) {
-    Object.assign(options, nextOptions);
-  }
-}
-function setLabels(currentData, nextLabels) {
-  currentData.labels = nextLabels;
-}
-function setDatasets(currentData, nextDatasets) {
-  let datasetIdKey = arguments.length > 2 && arguments[2] !== void 0 ? arguments[2] : defaultDatasetIdKey;
-  const addedDatasets = [];
-  currentData.datasets = nextDatasets.map((nextDataset) => {
-    const currentDataset = currentData.datasets.find((dataset) => dataset[datasetIdKey] === nextDataset[datasetIdKey]);
-    if (!currentDataset || !nextDataset.data || addedDatasets.includes(currentDataset)) {
-      return {
-        ...nextDataset
-      };
-    }
-    addedDatasets.push(currentDataset);
-    Object.assign(currentDataset, nextDataset);
-    return currentDataset;
-  });
-}
-function cloneData(data) {
-  let datasetIdKey = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : defaultDatasetIdKey;
-  const nextData = {
-    labels: [],
-    datasets: []
-  };
-  setLabels(nextData, data.labels);
-  setDatasets(nextData, data.datasets, datasetIdKey);
-  return nextData;
-}
-function ChartComponent(props, ref) {
-  const { height = 150, width = 300, redraw = false, datasetIdKey, type, data, options, plugins = [], fallbackContent, updateMode, ...canvasProps } = props;
-  const canvasRef = reactExports.useRef(null);
-  const chartRef = reactExports.useRef(null);
-  const renderChart = () => {
-    if (!canvasRef.current) return;
-    chartRef.current = new Chart$1(canvasRef.current, {
-      type,
-      data: cloneData(data, datasetIdKey),
-      options: options && {
-        ...options
-      },
-      plugins
-    });
-    reforwardRef(ref, chartRef.current);
-  };
-  const destroyChart = () => {
-    reforwardRef(ref, null);
-    if (chartRef.current) {
-      chartRef.current.destroy();
-      chartRef.current = null;
-    }
-  };
-  reactExports.useEffect(() => {
-    if (!redraw && chartRef.current && options) {
-      setOptions(chartRef.current, options);
-    }
-  }, [
-    redraw,
-    options
-  ]);
-  reactExports.useEffect(() => {
-    if (!redraw && chartRef.current) {
-      setLabels(chartRef.current.config.data, data.labels);
-    }
-  }, [
-    redraw,
-    data.labels
-  ]);
-  reactExports.useEffect(() => {
-    if (!redraw && chartRef.current && data.datasets) {
-      setDatasets(chartRef.current.config.data, data.datasets, datasetIdKey);
-    }
-  }, [
-    redraw,
-    data.datasets
-  ]);
-  reactExports.useEffect(() => {
-    if (!chartRef.current) return;
-    if (redraw) {
-      destroyChart();
-      setTimeout(renderChart);
-    } else {
-      chartRef.current.update(updateMode);
-    }
-  }, [
-    redraw,
-    options,
-    data.labels,
-    data.datasets,
-    updateMode
-  ]);
-  reactExports.useEffect(() => {
-    if (!chartRef.current) return;
-    destroyChart();
-    setTimeout(renderChart);
-  }, [
-    type
-  ]);
-  reactExports.useEffect(() => {
-    renderChart();
-    return () => destroyChart();
-  }, []);
-  return /* @__PURE__ */ React.createElement("canvas", {
-    ref: canvasRef,
-    role: "img",
-    height,
-    width,
-    ...canvasProps
-  }, fallbackContent);
-}
-const Chart = /* @__PURE__ */ reactExports.forwardRef(ChartComponent);
-function createTypedChart(type, registerables) {
-  Chart$1.register(registerables);
-  return /* @__PURE__ */ reactExports.forwardRef((props, ref) => /* @__PURE__ */ React.createElement(Chart, {
-    ...props,
-    ref,
-    type
-  }));
-}
-const Line = /* @__PURE__ */ createTypedChart("line", LineController);
-const millisecondsInWeek = 6048e5;
-const millisecondsInDay = 864e5;
-const millisecondsInMinute = 6e4;
-const millisecondsInHour = 36e5;
-const millisecondsInSecond = 1e3;
-const constructFromSymbol = Symbol.for("constructDateFrom");
-function constructFrom(date, value) {
-  if (typeof date === "function") return date(value);
-  if (date && typeof date === "object" && constructFromSymbol in date)
-    return date[constructFromSymbol](value);
-  if (date instanceof Date) return new date.constructor(value);
-  return new Date(value);
-}
-function toDate(argument, context) {
-  return constructFrom(context || argument, argument);
-}
-function addDays(date, amount, options) {
-  const _date = toDate(date, options == null ? void 0 : options.in);
-  if (isNaN(amount)) return constructFrom((options == null ? void 0 : options.in) || date, NaN);
-  if (!amount) return _date;
-  _date.setDate(_date.getDate() + amount);
-  return _date;
-}
-function addMonths(date, amount, options) {
-  const _date = toDate(date, options == null ? void 0 : options.in);
-  if (isNaN(amount)) return constructFrom(date, NaN);
-  if (!amount) {
-    return _date;
-  }
-  const dayOfMonth = _date.getDate();
-  const endOfDesiredMonth = constructFrom(date, _date.getTime());
-  endOfDesiredMonth.setMonth(_date.getMonth() + amount + 1, 0);
-  const daysInMonth = endOfDesiredMonth.getDate();
-  if (dayOfMonth >= daysInMonth) {
-    return endOfDesiredMonth;
-  } else {
-    _date.setFullYear(
-      endOfDesiredMonth.getFullYear(),
-      endOfDesiredMonth.getMonth(),
-      dayOfMonth
-    );
-    return _date;
-  }
-}
-function addMilliseconds(date, amount, options) {
-  return constructFrom(date, +toDate(date) + amount);
-}
-function addHours(date, amount, options) {
-  return addMilliseconds(date, amount * millisecondsInHour);
-}
-let defaultOptions = {};
-function getDefaultOptions$1() {
-  return defaultOptions;
-}
-function startOfWeek(date, options) {
-  var _a2, _b2, _c, _d;
-  const defaultOptions2 = getDefaultOptions$1();
-  const weekStartsOn = (options == null ? void 0 : options.weekStartsOn) ?? ((_b2 = (_a2 = options == null ? void 0 : options.locale) == null ? void 0 : _a2.options) == null ? void 0 : _b2.weekStartsOn) ?? defaultOptions2.weekStartsOn ?? ((_d = (_c = defaultOptions2.locale) == null ? void 0 : _c.options) == null ? void 0 : _d.weekStartsOn) ?? 0;
-  const _date = toDate(date, options == null ? void 0 : options.in);
-  const day = _date.getDay();
-  const diff = (day < weekStartsOn ? 7 : 0) + day - weekStartsOn;
-  _date.setDate(_date.getDate() - diff);
-  _date.setHours(0, 0, 0, 0);
-  return _date;
-}
-function startOfISOWeek(date, options) {
-  return startOfWeek(date, { ...options, weekStartsOn: 1 });
-}
-function getISOWeekYear(date, options) {
-  const _date = toDate(date, options == null ? void 0 : options.in);
-  const year = _date.getFullYear();
-  const fourthOfJanuaryOfNextYear = constructFrom(_date, 0);
-  fourthOfJanuaryOfNextYear.setFullYear(year + 1, 0, 4);
-  fourthOfJanuaryOfNextYear.setHours(0, 0, 0, 0);
-  const startOfNextYear = startOfISOWeek(fourthOfJanuaryOfNextYear);
-  const fourthOfJanuaryOfThisYear = constructFrom(_date, 0);
-  fourthOfJanuaryOfThisYear.setFullYear(year, 0, 4);
-  fourthOfJanuaryOfThisYear.setHours(0, 0, 0, 0);
-  const startOfThisYear = startOfISOWeek(fourthOfJanuaryOfThisYear);
-  if (_date.getTime() >= startOfNextYear.getTime()) {
-    return year + 1;
-  } else if (_date.getTime() >= startOfThisYear.getTime()) {
-    return year;
-  } else {
-    return year - 1;
-  }
-}
-function getTimezoneOffsetInMilliseconds(date) {
-  const _date = toDate(date);
-  const utcDate = new Date(
-    Date.UTC(
-      _date.getFullYear(),
-      _date.getMonth(),
-      _date.getDate(),
-      _date.getHours(),
-      _date.getMinutes(),
-      _date.getSeconds(),
-      _date.getMilliseconds()
-    )
-  );
-  utcDate.setUTCFullYear(_date.getFullYear());
-  return +date - +utcDate;
-}
-function normalizeDates(context, ...dates) {
-  const normalize = constructFrom.bind(
-    null,
-    dates.find((date) => typeof date === "object")
-  );
-  return dates.map(normalize);
-}
-function startOfDay(date, options) {
-  const _date = toDate(date, options == null ? void 0 : options.in);
-  _date.setHours(0, 0, 0, 0);
-  return _date;
-}
-function differenceInCalendarDays(laterDate, earlierDate, options) {
-  const [laterDate_, earlierDate_] = normalizeDates(
-    options == null ? void 0 : options.in,
-    laterDate,
-    earlierDate
-  );
-  const laterStartOfDay = startOfDay(laterDate_);
-  const earlierStartOfDay = startOfDay(earlierDate_);
-  const laterTimestamp = +laterStartOfDay - getTimezoneOffsetInMilliseconds(laterStartOfDay);
-  const earlierTimestamp = +earlierStartOfDay - getTimezoneOffsetInMilliseconds(earlierStartOfDay);
-  return Math.round((laterTimestamp - earlierTimestamp) / millisecondsInDay);
-}
-function startOfISOWeekYear(date, options) {
-  const year = getISOWeekYear(date, options);
-  const fourthOfJanuary = constructFrom(date, 0);
-  fourthOfJanuary.setFullYear(year, 0, 4);
-  fourthOfJanuary.setHours(0, 0, 0, 0);
-  return startOfISOWeek(fourthOfJanuary);
-}
-function addMinutes(date, amount, options) {
-  const _date = toDate(date, options == null ? void 0 : options.in);
-  _date.setTime(_date.getTime() + amount * millisecondsInMinute);
-  return _date;
-}
-function addQuarters(date, amount, options) {
-  return addMonths(date, amount * 3, options);
-}
-function addSeconds(date, amount, options) {
-  return addMilliseconds(date, amount * 1e3);
-}
-function addWeeks(date, amount, options) {
-  return addDays(date, amount * 7, options);
-}
-function addYears(date, amount, options) {
-  return addMonths(date, amount * 12, options);
-}
-function compareAsc(dateLeft, dateRight) {
-  const diff = +toDate(dateLeft) - +toDate(dateRight);
-  if (diff < 0) return -1;
-  else if (diff > 0) return 1;
-  return diff;
-}
-function isDate(value) {
-  return value instanceof Date || typeof value === "object" && Object.prototype.toString.call(value) === "[object Date]";
-}
-function isValid(date) {
-  return !(!isDate(date) && typeof date !== "number" || isNaN(+toDate(date)));
-}
-function differenceInCalendarMonths(laterDate, earlierDate, options) {
-  const [laterDate_, earlierDate_] = normalizeDates(
-    options == null ? void 0 : options.in,
-    laterDate,
-    earlierDate
-  );
-  const yearsDiff = laterDate_.getFullYear() - earlierDate_.getFullYear();
-  const monthsDiff = laterDate_.getMonth() - earlierDate_.getMonth();
-  return yearsDiff * 12 + monthsDiff;
-}
-function differenceInCalendarYears(laterDate, earlierDate, options) {
-  const [laterDate_, earlierDate_] = normalizeDates(
-    options == null ? void 0 : options.in,
-    laterDate,
-    earlierDate
-  );
-  return laterDate_.getFullYear() - earlierDate_.getFullYear();
-}
-function differenceInDays(laterDate, earlierDate, options) {
-  const [laterDate_, earlierDate_] = normalizeDates(
-    options == null ? void 0 : options.in,
-    laterDate,
-    earlierDate
-  );
-  const sign2 = compareLocalAsc(laterDate_, earlierDate_);
-  const difference = Math.abs(
-    differenceInCalendarDays(laterDate_, earlierDate_)
-  );
-  laterDate_.setDate(laterDate_.getDate() - sign2 * difference);
-  const isLastDayNotFull = Number(
-    compareLocalAsc(laterDate_, earlierDate_) === -sign2
-  );
-  const result = sign2 * (difference - isLastDayNotFull);
-  return result === 0 ? 0 : result;
-}
-function compareLocalAsc(laterDate, earlierDate) {
-  const diff = laterDate.getFullYear() - earlierDate.getFullYear() || laterDate.getMonth() - earlierDate.getMonth() || laterDate.getDate() - earlierDate.getDate() || laterDate.getHours() - earlierDate.getHours() || laterDate.getMinutes() - earlierDate.getMinutes() || laterDate.getSeconds() - earlierDate.getSeconds() || laterDate.getMilliseconds() - earlierDate.getMilliseconds();
-  if (diff < 0) return -1;
-  if (diff > 0) return 1;
-  return diff;
-}
-function getRoundingMethod(method) {
-  return (number) => {
-    const round2 = method ? Math[method] : Math.trunc;
-    const result = round2(number);
-    return result === 0 ? 0 : result;
-  };
-}
-function differenceInHours(laterDate, earlierDate, options) {
-  const [laterDate_, earlierDate_] = normalizeDates(
-    options == null ? void 0 : options.in,
-    laterDate,
-    earlierDate
-  );
-  const diff = (+laterDate_ - +earlierDate_) / millisecondsInHour;
-  return getRoundingMethod(options == null ? void 0 : options.roundingMethod)(diff);
-}
-function differenceInMilliseconds(laterDate, earlierDate) {
-  return +toDate(laterDate) - +toDate(earlierDate);
-}
-function differenceInMinutes(dateLeft, dateRight, options) {
-  const diff = differenceInMilliseconds(dateLeft, dateRight) / millisecondsInMinute;
-  return getRoundingMethod(options == null ? void 0 : options.roundingMethod)(diff);
-}
-function endOfDay(date, options) {
-  const _date = toDate(date, options == null ? void 0 : options.in);
-  _date.setHours(23, 59, 59, 999);
-  return _date;
-}
-function endOfMonth(date, options) {
-  const _date = toDate(date, options == null ? void 0 : options.in);
-  const month = _date.getMonth();
-  _date.setFullYear(_date.getFullYear(), month + 1, 0);
-  _date.setHours(23, 59, 59, 999);
-  return _date;
-}
-function isLastDayOfMonth(date, options) {
-  const _date = toDate(date, options == null ? void 0 : options.in);
-  return +endOfDay(_date, options) === +endOfMonth(_date, options);
-}
-function differenceInMonths(laterDate, earlierDate, options) {
-  const [laterDate_, workingLaterDate, earlierDate_] = normalizeDates(
-    options == null ? void 0 : options.in,
-    laterDate,
-    laterDate,
-    earlierDate
-  );
-  const sign2 = compareAsc(workingLaterDate, earlierDate_);
-  const difference = Math.abs(
-    differenceInCalendarMonths(workingLaterDate, earlierDate_)
-  );
-  if (difference < 1) return 0;
-  if (workingLaterDate.getMonth() === 1 && workingLaterDate.getDate() > 27)
-    workingLaterDate.setDate(30);
-  workingLaterDate.setMonth(workingLaterDate.getMonth() - sign2 * difference);
-  let isLastMonthNotFull = compareAsc(workingLaterDate, earlierDate_) === -sign2;
-  if (isLastDayOfMonth(laterDate_) && difference === 1 && compareAsc(laterDate_, earlierDate_) === 1) {
-    isLastMonthNotFull = false;
-  }
-  const result = sign2 * (difference - +isLastMonthNotFull);
-  return result === 0 ? 0 : result;
-}
-function differenceInQuarters(laterDate, earlierDate, options) {
-  const diff = differenceInMonths(laterDate, earlierDate, options) / 3;
-  return getRoundingMethod(options == null ? void 0 : options.roundingMethod)(diff);
-}
-function differenceInSeconds(laterDate, earlierDate, options) {
-  const diff = differenceInMilliseconds(laterDate, earlierDate) / 1e3;
-  return getRoundingMethod(options == null ? void 0 : options.roundingMethod)(diff);
-}
-function differenceInWeeks(laterDate, earlierDate, options) {
-  const diff = differenceInDays(laterDate, earlierDate, options) / 7;
-  return getRoundingMethod(options == null ? void 0 : options.roundingMethod)(diff);
-}
-function differenceInYears(laterDate, earlierDate, options) {
-  const [laterDate_, earlierDate_] = normalizeDates(
-    options == null ? void 0 : options.in,
-    laterDate,
-    earlierDate
-  );
-  const sign2 = compareAsc(laterDate_, earlierDate_);
-  const diff = Math.abs(differenceInCalendarYears(laterDate_, earlierDate_));
-  laterDate_.setFullYear(1584);
-  earlierDate_.setFullYear(1584);
-  const partial = compareAsc(laterDate_, earlierDate_) === -sign2;
-  const result = sign2 * (diff - +partial);
-  return result === 0 ? 0 : result;
-}
-function startOfQuarter(date, options) {
-  const _date = toDate(date, options == null ? void 0 : options.in);
-  const currentMonth = _date.getMonth();
-  const month = currentMonth - currentMonth % 3;
-  _date.setMonth(month, 1);
-  _date.setHours(0, 0, 0, 0);
-  return _date;
-}
-function startOfMonth(date, options) {
-  const _date = toDate(date, options == null ? void 0 : options.in);
-  _date.setDate(1);
-  _date.setHours(0, 0, 0, 0);
-  return _date;
-}
-function endOfYear(date, options) {
-  const _date = toDate(date, options == null ? void 0 : options.in);
-  const year = _date.getFullYear();
-  _date.setFullYear(year + 1, 0, 0);
-  _date.setHours(23, 59, 59, 999);
-  return _date;
-}
-function startOfYear(date, options) {
-  const date_ = toDate(date, options == null ? void 0 : options.in);
-  date_.setFullYear(date_.getFullYear(), 0, 1);
-  date_.setHours(0, 0, 0, 0);
-  return date_;
-}
-function endOfHour(date, options) {
-  const _date = toDate(date, options == null ? void 0 : options.in);
-  _date.setMinutes(59, 59, 999);
-  return _date;
-}
-function endOfWeek(date, options) {
-  var _a2, _b2;
-  const defaultOptions2 = getDefaultOptions$1();
-  const weekStartsOn = defaultOptions2.weekStartsOn ?? ((_b2 = (_a2 = defaultOptions2.locale) == null ? void 0 : _a2.options) == null ? void 0 : _b2.weekStartsOn) ?? 0;
-  const _date = toDate(date, options == null ? void 0 : options.in);
-  const day = _date.getDay();
-  const diff = (day < weekStartsOn ? -7 : 0) + 6 - (day - weekStartsOn);
-  _date.setDate(_date.getDate() + diff);
-  _date.setHours(23, 59, 59, 999);
-  return _date;
-}
-function endOfMinute(date, options) {
-  const _date = toDate(date, options == null ? void 0 : options.in);
-  _date.setSeconds(59, 999);
-  return _date;
-}
-function endOfQuarter(date, options) {
-  const _date = toDate(date, options == null ? void 0 : options.in);
-  const currentMonth = _date.getMonth();
-  const month = currentMonth - currentMonth % 3 + 3;
-  _date.setMonth(month, 0);
-  _date.setHours(23, 59, 59, 999);
-  return _date;
-}
-function endOfSecond(date, options) {
-  const _date = toDate(date, options == null ? void 0 : options.in);
-  _date.setMilliseconds(999);
-  return _date;
-}
-const formatDistanceLocale = {
-  lessThanXSeconds: {
-    one: "less than a second",
-    other: "less than {{count}} seconds"
-  },
-  xSeconds: {
-    one: "1 second",
-    other: "{{count}} seconds"
-  },
-  halfAMinute: "half a minute",
-  lessThanXMinutes: {
-    one: "less than a minute",
-    other: "less than {{count}} minutes"
-  },
-  xMinutes: {
-    one: "1 minute",
-    other: "{{count}} minutes"
-  },
-  aboutXHours: {
-    one: "about 1 hour",
-    other: "about {{count}} hours"
-  },
-  xHours: {
-    one: "1 hour",
-    other: "{{count}} hours"
-  },
-  xDays: {
-    one: "1 day",
-    other: "{{count}} days"
-  },
-  aboutXWeeks: {
-    one: "about 1 week",
-    other: "about {{count}} weeks"
-  },
-  xWeeks: {
-    one: "1 week",
-    other: "{{count}} weeks"
-  },
-  aboutXMonths: {
-    one: "about 1 month",
-    other: "about {{count}} months"
-  },
-  xMonths: {
-    one: "1 month",
-    other: "{{count}} months"
-  },
-  aboutXYears: {
-    one: "about 1 year",
-    other: "about {{count}} years"
-  },
-  xYears: {
-    one: "1 year",
-    other: "{{count}} years"
-  },
-  overXYears: {
-    one: "over 1 year",
-    other: "over {{count}} years"
-  },
-  almostXYears: {
-    one: "almost 1 year",
-    other: "almost {{count}} years"
-  }
-};
-const formatDistance = (token, count, options) => {
-  let result;
-  const tokenValue = formatDistanceLocale[token];
-  if (typeof tokenValue === "string") {
-    result = tokenValue;
-  } else if (count === 1) {
-    result = tokenValue.one;
-  } else {
-    result = tokenValue.other.replace("{{count}}", count.toString());
-  }
-  if (options == null ? void 0 : options.addSuffix) {
-    if (options.comparison && options.comparison > 0) {
-      return "in " + result;
-    } else {
-      return result + " ago";
-    }
-  }
-  return result;
-};
-function buildFormatLongFn(args) {
-  return (options = {}) => {
-    const width = options.width ? String(options.width) : args.defaultWidth;
-    const format2 = args.formats[width] || args.formats[args.defaultWidth];
-    return format2;
-  };
-}
-const dateFormats = {
-  full: "EEEE, MMMM do, y",
-  long: "MMMM do, y",
-  medium: "MMM d, y",
-  short: "MM/dd/yyyy"
-};
-const timeFormats = {
-  full: "h:mm:ss a zzzz",
-  long: "h:mm:ss a z",
-  medium: "h:mm:ss a",
-  short: "h:mm a"
-};
-const dateTimeFormats = {
-  full: "{{date}} 'at' {{time}}",
-  long: "{{date}} 'at' {{time}}",
-  medium: "{{date}}, {{time}}",
-  short: "{{date}}, {{time}}"
-};
-const formatLong = {
-  date: buildFormatLongFn({
-    formats: dateFormats,
-    defaultWidth: "full"
-  }),
-  time: buildFormatLongFn({
-    formats: timeFormats,
-    defaultWidth: "full"
-  }),
-  dateTime: buildFormatLongFn({
-    formats: dateTimeFormats,
-    defaultWidth: "full"
-  })
-};
-const formatRelativeLocale = {
-  lastWeek: "'last' eeee 'at' p",
-  yesterday: "'yesterday at' p",
-  today: "'today at' p",
-  tomorrow: "'tomorrow at' p",
-  nextWeek: "eeee 'at' p",
-  other: "P"
-};
-const formatRelative = (token, _date, _baseDate, _options) => formatRelativeLocale[token];
-function buildLocalizeFn(args) {
-  return (value, options) => {
-    const context = (options == null ? void 0 : options.context) ? String(options.context) : "standalone";
-    let valuesArray;
-    if (context === "formatting" && args.formattingValues) {
-      const defaultWidth = args.defaultFormattingWidth || args.defaultWidth;
-      const width = (options == null ? void 0 : options.width) ? String(options.width) : defaultWidth;
-      valuesArray = args.formattingValues[width] || args.formattingValues[defaultWidth];
-    } else {
-      const defaultWidth = args.defaultWidth;
-      const width = (options == null ? void 0 : options.width) ? String(options.width) : args.defaultWidth;
-      valuesArray = args.values[width] || args.values[defaultWidth];
-    }
-    const index = args.argumentCallback ? args.argumentCallback(value) : value;
-    return valuesArray[index];
-  };
-}
-const eraValues = {
-  narrow: ["B", "A"],
-  abbreviated: ["BC", "AD"],
-  wide: ["Before Christ", "Anno Domini"]
-};
-const quarterValues = {
-  narrow: ["1", "2", "3", "4"],
-  abbreviated: ["Q1", "Q2", "Q3", "Q4"],
-  wide: ["1st quarter", "2nd quarter", "3rd quarter", "4th quarter"]
-};
-const monthValues = {
-  narrow: ["J", "F", "M", "A", "M", "J", "J", "A", "S", "O", "N", "D"],
-  abbreviated: [
-    "Jan",
-    "Feb",
-    "Mar",
-    "Apr",
-    "May",
-    "Jun",
-    "Jul",
-    "Aug",
-    "Sep",
-    "Oct",
-    "Nov",
-    "Dec"
-  ],
-  wide: [
-    "January",
-    "February",
-    "March",
-    "April",
-    "May",
-    "June",
-    "July",
-    "August",
-    "September",
-    "October",
-    "November",
-    "December"
-  ]
-};
-const dayValues = {
-  narrow: ["S", "M", "T", "W", "T", "F", "S"],
-  short: ["Su", "Mo", "Tu", "We", "Th", "Fr", "Sa"],
-  abbreviated: ["Sun", "Mon", "Tue", "Wed", "Thu", "Fri", "Sat"],
-  wide: [
-    "Sunday",
-    "Monday",
-    "Tuesday",
-    "Wednesday",
-    "Thursday",
-    "Friday",
-    "Saturday"
-  ]
-};
-const dayPeriodValues = {
-  narrow: {
-    am: "a",
-    pm: "p",
-    midnight: "mi",
-    noon: "n",
-    morning: "morning",
-    afternoon: "afternoon",
-    evening: "evening",
-    night: "night"
-  },
-  abbreviated: {
-    am: "AM",
-    pm: "PM",
-    midnight: "midnight",
-    noon: "noon",
-    morning: "morning",
-    afternoon: "afternoon",
-    evening: "evening",
-    night: "night"
-  },
-  wide: {
-    am: "a.m.",
-    pm: "p.m.",
-    midnight: "midnight",
-    noon: "noon",
-    morning: "morning",
-    afternoon: "afternoon",
-    evening: "evening",
-    night: "night"
-  }
-};
-const formattingDayPeriodValues = {
-  narrow: {
-    am: "a",
-    pm: "p",
-    midnight: "mi",
-    noon: "n",
-    morning: "in the morning",
-    afternoon: "in the afternoon",
-    evening: "in the evening",
-    night: "at night"
-  },
-  abbreviated: {
-    am: "AM",
-    pm: "PM",
-    midnight: "midnight",
-    noon: "noon",
-    morning: "in the morning",
-    afternoon: "in the afternoon",
-    evening: "in the evening",
-    night: "at night"
-  },
-  wide: {
-    am: "a.m.",
-    pm: "p.m.",
-    midnight: "midnight",
-    noon: "noon",
-    morning: "in the morning",
-    afternoon: "in the afternoon",
-    evening: "in the evening",
-    night: "at night"
-  }
-};
-const ordinalNumber = (dirtyNumber, _options) => {
-  const number = Number(dirtyNumber);
-  const rem100 = number % 100;
-  if (rem100 > 20 || rem100 < 10) {
-    switch (rem100 % 10) {
-      case 1:
-        return number + "st";
-      case 2:
-        return number + "nd";
-      case 3:
-        return number + "rd";
-    }
-  }
-  return number + "th";
-};
-const localize = {
-  ordinalNumber,
-  era: buildLocalizeFn({
-    values: eraValues,
-    defaultWidth: "wide"
-  }),
-  quarter: buildLocalizeFn({
-    values: quarterValues,
-    defaultWidth: "wide",
-    argumentCallback: (quarter) => quarter - 1
-  }),
-  month: buildLocalizeFn({
-    values: monthValues,
-    defaultWidth: "wide"
-  }),
-  day: buildLocalizeFn({
-    values: dayValues,
-    defaultWidth: "wide"
-  }),
-  dayPeriod: buildLocalizeFn({
-    values: dayPeriodValues,
-    defaultWidth: "wide",
-    formattingValues: formattingDayPeriodValues,
-    defaultFormattingWidth: "wide"
-  })
-};
-function buildMatchFn(args) {
-  return (string, options = {}) => {
-    const width = options.width;
-    const matchPattern = width && args.matchPatterns[width] || args.matchPatterns[args.defaultMatchWidth];
-    const matchResult = string.match(matchPattern);
-    if (!matchResult) {
-      return null;
-    }
-    const matchedString = matchResult[0];
-    const parsePatterns = width && args.parsePatterns[width] || args.parsePatterns[args.defaultParseWidth];
-    const key = Array.isArray(parsePatterns) ? findIndex(parsePatterns, (pattern) => pattern.test(matchedString)) : (
-      // [TODO] -- I challenge you to fix the type
-      findKey(parsePatterns, (pattern) => pattern.test(matchedString))
-    );
-    let value;
-    value = args.valueCallback ? args.valueCallback(key) : key;
-    value = options.valueCallback ? (
-      // [TODO] -- I challenge you to fix the type
-      options.valueCallback(value)
-    ) : value;
-    const rest = string.slice(matchedString.length);
-    return { value, rest };
-  };
-}
-function findKey(object, predicate) {
-  for (const key in object) {
-    if (Object.prototype.hasOwnProperty.call(object, key) && predicate(object[key])) {
-      return key;
-    }
-  }
-  return void 0;
-}
-function findIndex(array, predicate) {
-  for (let key = 0; key < array.length; key++) {
-    if (predicate(array[key])) {
-      return key;
-    }
-  }
-  return void 0;
-}
-function buildMatchPatternFn(args) {
-  return (string, options = {}) => {
-    const matchResult = string.match(args.matchPattern);
-    if (!matchResult) return null;
-    const matchedString = matchResult[0];
-    const parseResult = string.match(args.parsePattern);
-    if (!parseResult) return null;
-    let value = args.valueCallback ? args.valueCallback(parseResult[0]) : parseResult[0];
-    value = options.valueCallback ? options.valueCallback(value) : value;
-    const rest = string.slice(matchedString.length);
-    return { value, rest };
-  };
-}
-const matchOrdinalNumberPattern = /^(\d+)(th|st|nd|rd)?/i;
-const parseOrdinalNumberPattern = /\d+/i;
-const matchEraPatterns = {
-  narrow: /^(b|a)/i,
-  abbreviated: /^(b\.?\s?c\.?|b\.?\s?c\.?\s?e\.?|a\.?\s?d\.?|c\.?\s?e\.?)/i,
-  wide: /^(before christ|before common era|anno domini|common era)/i
-};
-const parseEraPatterns = {
-  any: [/^b/i, /^(a|c)/i]
-};
-const matchQuarterPatterns = {
-  narrow: /^[1234]/i,
-  abbreviated: /^q[1234]/i,
-  wide: /^[1234](th|st|nd|rd)? quarter/i
-};
-const parseQuarterPatterns = {
-  any: [/1/i, /2/i, /3/i, /4/i]
-};
-const matchMonthPatterns = {
-  narrow: /^[jfmasond]/i,
-  abbreviated: /^(jan|feb|mar|apr|may|jun|jul|aug|sep|oct|nov|dec)/i,
-  wide: /^(january|february|march|april|may|june|july|august|september|october|november|december)/i
-};
-const parseMonthPatterns = {
-  narrow: [
-    /^j/i,
-    /^f/i,
-    /^m/i,
-    /^a/i,
-    /^m/i,
-    /^j/i,
-    /^j/i,
-    /^a/i,
-    /^s/i,
-    /^o/i,
-    /^n/i,
-    /^d/i
-  ],
-  any: [
-    /^ja/i,
-    /^f/i,
-    /^mar/i,
-    /^ap/i,
-    /^may/i,
-    /^jun/i,
-    /^jul/i,
-    /^au/i,
-    /^s/i,
-    /^o/i,
-    /^n/i,
-    /^d/i
-  ]
-};
-const matchDayPatterns = {
-  narrow: /^[smtwf]/i,
-  short: /^(su|mo|tu|we|th|fr|sa)/i,
-  abbreviated: /^(sun|mon|tue|wed|thu|fri|sat)/i,
-  wide: /^(sunday|monday|tuesday|wednesday|thursday|friday|saturday)/i
-};
-const parseDayPatterns = {
-  narrow: [/^s/i, /^m/i, /^t/i, /^w/i, /^t/i, /^f/i, /^s/i],
-  any: [/^su/i, /^m/i, /^tu/i, /^w/i, /^th/i, /^f/i, /^sa/i]
-};
-const matchDayPeriodPatterns = {
-  narrow: /^(a|p|mi|n|(in the|at) (morning|afternoon|evening|night))/i,
-  any: /^([ap]\.?\s?m\.?|midnight|noon|(in the|at) (morning|afternoon|evening|night))/i
-};
-const parseDayPeriodPatterns = {
-  any: {
-    am: /^a/i,
-    pm: /^p/i,
-    midnight: /^mi/i,
-    noon: /^no/i,
-    morning: /morning/i,
-    afternoon: /afternoon/i,
-    evening: /evening/i,
-    night: /night/i
-  }
-};
-const match = {
-  ordinalNumber: buildMatchPatternFn({
-    matchPattern: matchOrdinalNumberPattern,
-    parsePattern: parseOrdinalNumberPattern,
-    valueCallback: (value) => parseInt(value, 10)
-  }),
-  era: buildMatchFn({
-    matchPatterns: matchEraPatterns,
-    defaultMatchWidth: "wide",
-    parsePatterns: parseEraPatterns,
-    defaultParseWidth: "any"
-  }),
-  quarter: buildMatchFn({
-    matchPatterns: matchQuarterPatterns,
-    defaultMatchWidth: "wide",
-    parsePatterns: parseQuarterPatterns,
-    defaultParseWidth: "any",
-    valueCallback: (index) => index + 1
-  }),
-  month: buildMatchFn({
-    matchPatterns: matchMonthPatterns,
-    defaultMatchWidth: "wide",
-    parsePatterns: parseMonthPatterns,
-    defaultParseWidth: "any"
-  }),
-  day: buildMatchFn({
-    matchPatterns: matchDayPatterns,
-    defaultMatchWidth: "wide",
-    parsePatterns: parseDayPatterns,
-    defaultParseWidth: "any"
-  }),
-  dayPeriod: buildMatchFn({
-    matchPatterns: matchDayPeriodPatterns,
-    defaultMatchWidth: "any",
-    parsePatterns: parseDayPeriodPatterns,
-    defaultParseWidth: "any"
-  })
-};
-const enUS = {
-  code: "en-US",
-  formatDistance,
-  formatLong,
-  formatRelative,
-  localize,
-  match,
-  options: {
-    weekStartsOn: 0,
-    firstWeekContainsDate: 1
-  }
-};
-function getDayOfYear(date, options) {
-  const _date = toDate(date, options == null ? void 0 : options.in);
-  const diff = differenceInCalendarDays(_date, startOfYear(_date));
-  const dayOfYear = diff + 1;
-  return dayOfYear;
-}
-function getISOWeek(date, options) {
-  const _date = toDate(date, options == null ? void 0 : options.in);
-  const diff = +startOfISOWeek(_date) - +startOfISOWeekYear(_date);
-  return Math.round(diff / millisecondsInWeek) + 1;
-}
-function getWeekYear(date, options) {
-  var _a2, _b2, _c, _d;
-  const _date = toDate(date, options == null ? void 0 : options.in);
-  const year = _date.getFullYear();
-  const defaultOptions2 = getDefaultOptions$1();
-  const firstWeekContainsDate = (options == null ? void 0 : options.firstWeekContainsDate) ?? ((_b2 = (_a2 = options == null ? void 0 : options.locale) == null ? void 0 : _a2.options) == null ? void 0 : _b2.firstWeekContainsDate) ?? defaultOptions2.firstWeekContainsDate ?? ((_d = (_c = defaultOptions2.locale) == null ? void 0 : _c.options) == null ? void 0 : _d.firstWeekContainsDate) ?? 1;
-  const firstWeekOfNextYear = constructFrom((options == null ? void 0 : options.in) || date, 0);
-  firstWeekOfNextYear.setFullYear(year + 1, 0, firstWeekContainsDate);
-  firstWeekOfNextYear.setHours(0, 0, 0, 0);
-  const startOfNextYear = startOfWeek(firstWeekOfNextYear, options);
-  const firstWeekOfThisYear = constructFrom((options == null ? void 0 : options.in) || date, 0);
-  firstWeekOfThisYear.setFullYear(year, 0, firstWeekContainsDate);
-  firstWeekOfThisYear.setHours(0, 0, 0, 0);
-  const startOfThisYear = startOfWeek(firstWeekOfThisYear, options);
-  if (+_date >= +startOfNextYear) {
-    return year + 1;
-  } else if (+_date >= +startOfThisYear) {
-    return year;
-  } else {
-    return year - 1;
-  }
-}
-function startOfWeekYear(date, options) {
-  var _a2, _b2, _c, _d;
-  const defaultOptions2 = getDefaultOptions$1();
-  const firstWeekContainsDate = (options == null ? void 0 : options.firstWeekContainsDate) ?? ((_b2 = (_a2 = options == null ? void 0 : options.locale) == null ? void 0 : _a2.options) == null ? void 0 : _b2.firstWeekContainsDate) ?? defaultOptions2.firstWeekContainsDate ?? ((_d = (_c = defaultOptions2.locale) == null ? void 0 : _c.options) == null ? void 0 : _d.firstWeekContainsDate) ?? 1;
-  const year = getWeekYear(date, options);
-  const firstWeek = constructFrom((options == null ? void 0 : options.in) || date, 0);
-  firstWeek.setFullYear(year, 0, firstWeekContainsDate);
-  firstWeek.setHours(0, 0, 0, 0);
-  const _date = startOfWeek(firstWeek, options);
-  return _date;
-}
-function getWeek(date, options) {
-  const _date = toDate(date, options == null ? void 0 : options.in);
-  const diff = +startOfWeek(_date, options) - +startOfWeekYear(_date, options);
-  return Math.round(diff / millisecondsInWeek) + 1;
-}
-function addLeadingZeros(number, targetLength) {
-  const sign2 = number < 0 ? "-" : "";
-  const output = Math.abs(number).toString().padStart(targetLength, "0");
-  return sign2 + output;
-}
-const lightFormatters = {
-  // Year
-  y(date, token) {
-    const signedYear = date.getFullYear();
-    const year = signedYear > 0 ? signedYear : 1 - signedYear;
-    return addLeadingZeros(token === "yy" ? year % 100 : year, token.length);
-  },
-  // Month
-  M(date, token) {
-    const month = date.getMonth();
-    return token === "M" ? String(month + 1) : addLeadingZeros(month + 1, 2);
-  },
-  // Day of the month
-  d(date, token) {
-    return addLeadingZeros(date.getDate(), token.length);
-  },
-  // AM or PM
-  a(date, token) {
-    const dayPeriodEnumValue = date.getHours() / 12 >= 1 ? "pm" : "am";
-    switch (token) {
-      case "a":
-      case "aa":
-        return dayPeriodEnumValue.toUpperCase();
-      case "aaa":
-        return dayPeriodEnumValue;
-      case "aaaaa":
-        return dayPeriodEnumValue[0];
-      case "aaaa":
-      default:
-        return dayPeriodEnumValue === "am" ? "a.m." : "p.m.";
-    }
-  },
-  // Hour [1-12]
-  h(date, token) {
-    return addLeadingZeros(date.getHours() % 12 || 12, token.length);
-  },
-  // Hour [0-23]
-  H(date, token) {
-    return addLeadingZeros(date.getHours(), token.length);
-  },
-  // Minute
-  m(date, token) {
-    return addLeadingZeros(date.getMinutes(), token.length);
-  },
-  // Second
-  s(date, token) {
-    return addLeadingZeros(date.getSeconds(), token.length);
-  },
-  // Fraction of second
-  S(date, token) {
-    const numberOfDigits = token.length;
-    const milliseconds = date.getMilliseconds();
-    const fractionalSeconds = Math.trunc(
-      milliseconds * Math.pow(10, numberOfDigits - 3)
-    );
-    return addLeadingZeros(fractionalSeconds, token.length);
-  }
-};
-const dayPeriodEnum = {
-  midnight: "midnight",
-  noon: "noon",
-  morning: "morning",
-  afternoon: "afternoon",
-  evening: "evening",
-  night: "night"
-};
-const formatters = {
-  // Era
-  G: function(date, token, localize2) {
-    const era = date.getFullYear() > 0 ? 1 : 0;
-    switch (token) {
-      case "G":
-      case "GG":
-      case "GGG":
-        return localize2.era(era, { width: "abbreviated" });
-      case "GGGGG":
-        return localize2.era(era, { width: "narrow" });
-      case "GGGG":
-      default:
-        return localize2.era(era, { width: "wide" });
-    }
-  },
-  // Year
-  y: function(date, token, localize2) {
-    if (token === "yo") {
-      const signedYear = date.getFullYear();
-      const year = signedYear > 0 ? signedYear : 1 - signedYear;
-      return localize2.ordinalNumber(year, { unit: "year" });
-    }
-    return lightFormatters.y(date, token);
-  },
-  // Local week-numbering year
-  Y: function(date, token, localize2, options) {
-    const signedWeekYear = getWeekYear(date, options);
-    const weekYear = signedWeekYear > 0 ? signedWeekYear : 1 - signedWeekYear;
-    if (token === "YY") {
-      const twoDigitYear = weekYear % 100;
-      return addLeadingZeros(twoDigitYear, 2);
-    }
-    if (token === "Yo") {
-      return localize2.ordinalNumber(weekYear, { unit: "year" });
-    }
-    return addLeadingZeros(weekYear, token.length);
-  },
-  // ISO week-numbering year
-  R: function(date, token) {
-    const isoWeekYear = getISOWeekYear(date);
-    return addLeadingZeros(isoWeekYear, token.length);
-  },
-  // Extended year. This is a single number designating the year of this calendar system.
-  // The main difference between `y` and `u` localizers are B.C. years:
-  // | Year | `y` | `u` |
-  // |------|-----|-----|
-  // | AC 1 |   1 |   1 |
-  // | BC 1 |   1 |   0 |
-  // | BC 2 |   2 |  -1 |
-  // Also `yy` always returns the last two digits of a year,
-  // while `uu` pads single digit years to 2 characters and returns other years unchanged.
-  u: function(date, token) {
-    const year = date.getFullYear();
-    return addLeadingZeros(year, token.length);
-  },
-  // Quarter
-  Q: function(date, token, localize2) {
-    const quarter = Math.ceil((date.getMonth() + 1) / 3);
-    switch (token) {
-      case "Q":
-        return String(quarter);
-      case "QQ":
-        return addLeadingZeros(quarter, 2);
-      case "Qo":
-        return localize2.ordinalNumber(quarter, { unit: "quarter" });
-      case "QQQ":
-        return localize2.quarter(quarter, {
-          width: "abbreviated",
-          context: "formatting"
-        });
-      case "QQQQQ":
-        return localize2.quarter(quarter, {
-          width: "narrow",
-          context: "formatting"
-        });
-      case "QQQQ":
-      default:
-        return localize2.quarter(quarter, {
-          width: "wide",
-          context: "formatting"
-        });
-    }
-  },
-  // Stand-alone quarter
-  q: function(date, token, localize2) {
-    const quarter = Math.ceil((date.getMonth() + 1) / 3);
-    switch (token) {
-      case "q":
-        return String(quarter);
-      case "qq":
-        return addLeadingZeros(quarter, 2);
-      case "qo":
-        return localize2.ordinalNumber(quarter, { unit: "quarter" });
-      case "qqq":
-        return localize2.quarter(quarter, {
-          width: "abbreviated",
-          context: "standalone"
-        });
-      case "qqqqq":
-        return localize2.quarter(quarter, {
-          width: "narrow",
-          context: "standalone"
-        });
-      case "qqqq":
-      default:
-        return localize2.quarter(quarter, {
-          width: "wide",
-          context: "standalone"
-        });
-    }
-  },
-  // Month
-  M: function(date, token, localize2) {
-    const month = date.getMonth();
-    switch (token) {
-      case "M":
-      case "MM":
-        return lightFormatters.M(date, token);
-      case "Mo":
-        return localize2.ordinalNumber(month + 1, { unit: "month" });
-      case "MMM":
-        return localize2.month(month, {
-          width: "abbreviated",
-          context: "formatting"
-        });
-      case "MMMMM":
-        return localize2.month(month, {
-          width: "narrow",
-          context: "formatting"
-        });
-      case "MMMM":
-      default:
-        return localize2.month(month, { width: "wide", context: "formatting" });
-    }
-  },
-  // Stand-alone month
-  L: function(date, token, localize2) {
-    const month = date.getMonth();
-    switch (token) {
-      case "L":
-        return String(month + 1);
-      case "LL":
-        return addLeadingZeros(month + 1, 2);
-      case "Lo":
-        return localize2.ordinalNumber(month + 1, { unit: "month" });
-      case "LLL":
-        return localize2.month(month, {
-          width: "abbreviated",
-          context: "standalone"
-        });
-      case "LLLLL":
-        return localize2.month(month, {
-          width: "narrow",
-          context: "standalone"
-        });
-      case "LLLL":
-      default:
-        return localize2.month(month, { width: "wide", context: "standalone" });
-    }
-  },
-  // Local week of year
-  w: function(date, token, localize2, options) {
-    const week = getWeek(date, options);
-    if (token === "wo") {
-      return localize2.ordinalNumber(week, { unit: "week" });
-    }
-    return addLeadingZeros(week, token.length);
-  },
-  // ISO week of year
-  I: function(date, token, localize2) {
-    const isoWeek = getISOWeek(date);
-    if (token === "Io") {
-      return localize2.ordinalNumber(isoWeek, { unit: "week" });
-    }
-    return addLeadingZeros(isoWeek, token.length);
-  },
-  // Day of the month
-  d: function(date, token, localize2) {
-    if (token === "do") {
-      return localize2.ordinalNumber(date.getDate(), { unit: "date" });
-    }
-    return lightFormatters.d(date, token);
-  },
-  // Day of year
-  D: function(date, token, localize2) {
-    const dayOfYear = getDayOfYear(date);
-    if (token === "Do") {
-      return localize2.ordinalNumber(dayOfYear, { unit: "dayOfYear" });
-    }
-    return addLeadingZeros(dayOfYear, token.length);
-  },
-  // Day of week
-  E: function(date, token, localize2) {
-    const dayOfWeek = date.getDay();
-    switch (token) {
-      case "E":
-      case "EE":
-      case "EEE":
-        return localize2.day(dayOfWeek, {
-          width: "abbreviated",
-          context: "formatting"
-        });
-      case "EEEEE":
-        return localize2.day(dayOfWeek, {
-          width: "narrow",
-          context: "formatting"
-        });
-      case "EEEEEE":
-        return localize2.day(dayOfWeek, {
-          width: "short",
-          context: "formatting"
-        });
-      case "EEEE":
-      default:
-        return localize2.day(dayOfWeek, {
-          width: "wide",
-          context: "formatting"
-        });
-    }
-  },
-  // Local day of week
-  e: function(date, token, localize2, options) {
-    const dayOfWeek = date.getDay();
-    const localDayOfWeek = (dayOfWeek - options.weekStartsOn + 8) % 7 || 7;
-    switch (token) {
-      case "e":
-        return String(localDayOfWeek);
-      case "ee":
-        return addLeadingZeros(localDayOfWeek, 2);
-      case "eo":
-        return localize2.ordinalNumber(localDayOfWeek, { unit: "day" });
-      case "eee":
-        return localize2.day(dayOfWeek, {
-          width: "abbreviated",
-          context: "formatting"
-        });
-      case "eeeee":
-        return localize2.day(dayOfWeek, {
-          width: "narrow",
-          context: "formatting"
-        });
-      case "eeeeee":
-        return localize2.day(dayOfWeek, {
-          width: "short",
-          context: "formatting"
-        });
-      case "eeee":
-      default:
-        return localize2.day(dayOfWeek, {
-          width: "wide",
-          context: "formatting"
-        });
-    }
-  },
-  // Stand-alone local day of week
-  c: function(date, token, localize2, options) {
-    const dayOfWeek = date.getDay();
-    const localDayOfWeek = (dayOfWeek - options.weekStartsOn + 8) % 7 || 7;
-    switch (token) {
-      case "c":
-        return String(localDayOfWeek);
-      case "cc":
-        return addLeadingZeros(localDayOfWeek, token.length);
-      case "co":
-        return localize2.ordinalNumber(localDayOfWeek, { unit: "day" });
-      case "ccc":
-        return localize2.day(dayOfWeek, {
-          width: "abbreviated",
-          context: "standalone"
-        });
-      case "ccccc":
-        return localize2.day(dayOfWeek, {
-          width: "narrow",
-          context: "standalone"
-        });
-      case "cccccc":
-        return localize2.day(dayOfWeek, {
-          width: "short",
-          context: "standalone"
-        });
-      case "cccc":
-      default:
-        return localize2.day(dayOfWeek, {
-          width: "wide",
-          context: "standalone"
-        });
-    }
-  },
-  // ISO day of week
-  i: function(date, token, localize2) {
-    const dayOfWeek = date.getDay();
-    const isoDayOfWeek = dayOfWeek === 0 ? 7 : dayOfWeek;
-    switch (token) {
-      case "i":
-        return String(isoDayOfWeek);
-      case "ii":
-        return addLeadingZeros(isoDayOfWeek, token.length);
-      case "io":
-        return localize2.ordinalNumber(isoDayOfWeek, { unit: "day" });
-      case "iii":
-        return localize2.day(dayOfWeek, {
-          width: "abbreviated",
-          context: "formatting"
-        });
-      case "iiiii":
-        return localize2.day(dayOfWeek, {
-          width: "narrow",
-          context: "formatting"
-        });
-      case "iiiiii":
-        return localize2.day(dayOfWeek, {
-          width: "short",
-          context: "formatting"
-        });
-      case "iiii":
-      default:
-        return localize2.day(dayOfWeek, {
-          width: "wide",
-          context: "formatting"
-        });
-    }
-  },
-  // AM or PM
-  a: function(date, token, localize2) {
-    const hours = date.getHours();
-    const dayPeriodEnumValue = hours / 12 >= 1 ? "pm" : "am";
-    switch (token) {
-      case "a":
-      case "aa":
-        return localize2.dayPeriod(dayPeriodEnumValue, {
-          width: "abbreviated",
-          context: "formatting"
-        });
-      case "aaa":
-        return localize2.dayPeriod(dayPeriodEnumValue, {
-          width: "abbreviated",
-          context: "formatting"
-        }).toLowerCase();
-      case "aaaaa":
-        return localize2.dayPeriod(dayPeriodEnumValue, {
-          width: "narrow",
-          context: "formatting"
-        });
-      case "aaaa":
-      default:
-        return localize2.dayPeriod(dayPeriodEnumValue, {
-          width: "wide",
-          context: "formatting"
-        });
-    }
-  },
-  // AM, PM, midnight, noon
-  b: function(date, token, localize2) {
-    const hours = date.getHours();
-    let dayPeriodEnumValue;
-    if (hours === 12) {
-      dayPeriodEnumValue = dayPeriodEnum.noon;
-    } else if (hours === 0) {
-      dayPeriodEnumValue = dayPeriodEnum.midnight;
-    } else {
-      dayPeriodEnumValue = hours / 12 >= 1 ? "pm" : "am";
-    }
-    switch (token) {
-      case "b":
-      case "bb":
-        return localize2.dayPeriod(dayPeriodEnumValue, {
-          width: "abbreviated",
-          context: "formatting"
-        });
-      case "bbb":
-        return localize2.dayPeriod(dayPeriodEnumValue, {
-          width: "abbreviated",
-          context: "formatting"
-        }).toLowerCase();
-      case "bbbbb":
-        return localize2.dayPeriod(dayPeriodEnumValue, {
-          width: "narrow",
-          context: "formatting"
-        });
-      case "bbbb":
-      default:
-        return localize2.dayPeriod(dayPeriodEnumValue, {
-          width: "wide",
-          context: "formatting"
-        });
-    }
-  },
-  // in the morning, in the afternoon, in the evening, at night
-  B: function(date, token, localize2) {
-    const hours = date.getHours();
-    let dayPeriodEnumValue;
-    if (hours >= 17) {
-      dayPeriodEnumValue = dayPeriodEnum.evening;
-    } else if (hours >= 12) {
-      dayPeriodEnumValue = dayPeriodEnum.afternoon;
-    } else if (hours >= 4) {
-      dayPeriodEnumValue = dayPeriodEnum.morning;
-    } else {
-      dayPeriodEnumValue = dayPeriodEnum.night;
-    }
-    switch (token) {
-      case "B":
-      case "BB":
-      case "BBB":
-        return localize2.dayPeriod(dayPeriodEnumValue, {
-          width: "abbreviated",
-          context: "formatting"
-        });
-      case "BBBBB":
-        return localize2.dayPeriod(dayPeriodEnumValue, {
-          width: "narrow",
-          context: "formatting"
-        });
-      case "BBBB":
-      default:
-        return localize2.dayPeriod(dayPeriodEnumValue, {
-          width: "wide",
-          context: "formatting"
-        });
-    }
-  },
-  // Hour [1-12]
-  h: function(date, token, localize2) {
-    if (token === "ho") {
-      let hours = date.getHours() % 12;
-      if (hours === 0) hours = 12;
-      return localize2.ordinalNumber(hours, { unit: "hour" });
-    }
-    return lightFormatters.h(date, token);
-  },
-  // Hour [0-23]
-  H: function(date, token, localize2) {
-    if (token === "Ho") {
-      return localize2.ordinalNumber(date.getHours(), { unit: "hour" });
-    }
-    return lightFormatters.H(date, token);
-  },
-  // Hour [0-11]
-  K: function(date, token, localize2) {
-    const hours = date.getHours() % 12;
-    if (token === "Ko") {
-      return localize2.ordinalNumber(hours, { unit: "hour" });
-    }
-    return addLeadingZeros(hours, token.length);
-  },
-  // Hour [1-24]
-  k: function(date, token, localize2) {
-    let hours = date.getHours();
-    if (hours === 0) hours = 24;
-    if (token === "ko") {
-      return localize2.ordinalNumber(hours, { unit: "hour" });
-    }
-    return addLeadingZeros(hours, token.length);
-  },
-  // Minute
-  m: function(date, token, localize2) {
-    if (token === "mo") {
-      return localize2.ordinalNumber(date.getMinutes(), { unit: "minute" });
-    }
-    return lightFormatters.m(date, token);
-  },
-  // Second
-  s: function(date, token, localize2) {
-    if (token === "so") {
-      return localize2.ordinalNumber(date.getSeconds(), { unit: "second" });
-    }
-    return lightFormatters.s(date, token);
-  },
-  // Fraction of second
-  S: function(date, token) {
-    return lightFormatters.S(date, token);
-  },
-  // Timezone (ISO-8601. If offset is 0, output is always `'Z'`)
-  X: function(date, token, _localize) {
-    const timezoneOffset = date.getTimezoneOffset();
-    if (timezoneOffset === 0) {
-      return "Z";
-    }
-    switch (token) {
-      case "X":
-        return formatTimezoneWithOptionalMinutes(timezoneOffset);
-      case "XXXX":
-      case "XX":
-        return formatTimezone(timezoneOffset);
-      case "XXXXX":
-      case "XXX":
-      default:
-        return formatTimezone(timezoneOffset, ":");
-    }
-  },
-  // Timezone (ISO-8601. If offset is 0, output is `'+00:00'` or equivalent)
-  x: function(date, token, _localize) {
-    const timezoneOffset = date.getTimezoneOffset();
-    switch (token) {
-      case "x":
-        return formatTimezoneWithOptionalMinutes(timezoneOffset);
-      case "xxxx":
-      case "xx":
-        return formatTimezone(timezoneOffset);
-      case "xxxxx":
-      case "xxx":
-      default:
-        return formatTimezone(timezoneOffset, ":");
-    }
-  },
-  // Timezone (GMT)
-  O: function(date, token, _localize) {
-    const timezoneOffset = date.getTimezoneOffset();
-    switch (token) {
-      case "O":
-      case "OO":
-      case "OOO":
-        return "GMT" + formatTimezoneShort(timezoneOffset, ":");
-      case "OOOO":
-      default:
-        return "GMT" + formatTimezone(timezoneOffset, ":");
-    }
-  },
-  // Timezone (specific non-location)
-  z: function(date, token, _localize) {
-    const timezoneOffset = date.getTimezoneOffset();
-    switch (token) {
-      case "z":
-      case "zz":
-      case "zzz":
-        return "GMT" + formatTimezoneShort(timezoneOffset, ":");
-      case "zzzz":
-      default:
-        return "GMT" + formatTimezone(timezoneOffset, ":");
-    }
-  },
-  // Seconds timestamp
-  t: function(date, token, _localize) {
-    const timestamp = Math.trunc(+date / 1e3);
-    return addLeadingZeros(timestamp, token.length);
-  },
-  // Milliseconds timestamp
-  T: function(date, token, _localize) {
-    return addLeadingZeros(+date, token.length);
-  }
-};
-function formatTimezoneShort(offset, delimiter = "") {
-  const sign2 = offset > 0 ? "-" : "+";
-  const absOffset = Math.abs(offset);
-  const hours = Math.trunc(absOffset / 60);
-  const minutes = absOffset % 60;
-  if (minutes === 0) {
-    return sign2 + String(hours);
-  }
-  return sign2 + String(hours) + delimiter + addLeadingZeros(minutes, 2);
-}
-function formatTimezoneWithOptionalMinutes(offset, delimiter) {
-  if (offset % 60 === 0) {
-    const sign2 = offset > 0 ? "-" : "+";
-    return sign2 + addLeadingZeros(Math.abs(offset) / 60, 2);
-  }
-  return formatTimezone(offset, delimiter);
-}
-function formatTimezone(offset, delimiter = "") {
-  const sign2 = offset > 0 ? "-" : "+";
-  const absOffset = Math.abs(offset);
-  const hours = addLeadingZeros(Math.trunc(absOffset / 60), 2);
-  const minutes = addLeadingZeros(absOffset % 60, 2);
-  return sign2 + hours + delimiter + minutes;
-}
-const dateLongFormatter = (pattern, formatLong2) => {
-  switch (pattern) {
-    case "P":
-      return formatLong2.date({ width: "short" });
-    case "PP":
-      return formatLong2.date({ width: "medium" });
-    case "PPP":
-      return formatLong2.date({ width: "long" });
-    case "PPPP":
-    default:
-      return formatLong2.date({ width: "full" });
-  }
-};
-const timeLongFormatter = (pattern, formatLong2) => {
-  switch (pattern) {
-    case "p":
-      return formatLong2.time({ width: "short" });
-    case "pp":
-      return formatLong2.time({ width: "medium" });
-    case "ppp":
-      return formatLong2.time({ width: "long" });
-    case "pppp":
-    default:
-      return formatLong2.time({ width: "full" });
-  }
-};
-const dateTimeLongFormatter = (pattern, formatLong2) => {
-  const matchResult = pattern.match(/(P+)(p+)?/) || [];
-  const datePattern = matchResult[1];
-  const timePattern = matchResult[2];
-  if (!timePattern) {
-    return dateLongFormatter(pattern, formatLong2);
-  }
-  let dateTimeFormat;
-  switch (datePattern) {
-    case "P":
-      dateTimeFormat = formatLong2.dateTime({ width: "short" });
-      break;
-    case "PP":
-      dateTimeFormat = formatLong2.dateTime({ width: "medium" });
-      break;
-    case "PPP":
-      dateTimeFormat = formatLong2.dateTime({ width: "long" });
-      break;
-    case "PPPP":
-    default:
-      dateTimeFormat = formatLong2.dateTime({ width: "full" });
-      break;
-  }
-  return dateTimeFormat.replace("{{date}}", dateLongFormatter(datePattern, formatLong2)).replace("{{time}}", timeLongFormatter(timePattern, formatLong2));
-};
-const longFormatters = {
-  p: timeLongFormatter,
-  P: dateTimeLongFormatter
-};
-const dayOfYearTokenRE = /^D+$/;
-const weekYearTokenRE = /^Y+$/;
-const throwTokens = ["D", "DD", "YY", "YYYY"];
-function isProtectedDayOfYearToken(token) {
-  return dayOfYearTokenRE.test(token);
-}
-function isProtectedWeekYearToken(token) {
-  return weekYearTokenRE.test(token);
-}
-function warnOrThrowProtectedError(token, format2, input) {
-  const _message = message(token, format2, input);
-  console.warn(_message);
-  if (throwTokens.includes(token)) throw new RangeError(_message);
-}
-function message(token, format2, input) {
-  const subject = token[0] === "Y" ? "years" : "days of the month";
-  return `Use \`${token.toLowerCase()}\` instead of \`${token}\` (in \`${format2}\`) for formatting ${subject} to the input \`${input}\`; see: https://github.com/date-fns/date-fns/blob/master/docs/unicodeTokens.md`;
-}
-const formattingTokensRegExp$1 = /[yYQqMLwIdDecihHKkms]o|(\w)\1*|''|'(''|[^'])+('|$)|./g;
-const longFormattingTokensRegExp$1 = /P+p+|P+|p+|''|'(''|[^'])+('|$)|./g;
-const escapedStringRegExp$1 = /^'([^]*?)'?$/;
-const doubleQuoteRegExp$1 = /''/g;
-const unescapedLatinCharacterRegExp$1 = /[a-zA-Z]/;
-function format(date, formatStr, options) {
-  var _a2, _b2, _c, _d, _e, _f, _g, _h;
-  const defaultOptions2 = getDefaultOptions$1();
-  const locale = (options == null ? void 0 : options.locale) ?? defaultOptions2.locale ?? enUS;
-  const firstWeekContainsDate = (options == null ? void 0 : options.firstWeekContainsDate) ?? ((_b2 = (_a2 = options == null ? void 0 : options.locale) == null ? void 0 : _a2.options) == null ? void 0 : _b2.firstWeekContainsDate) ?? defaultOptions2.firstWeekContainsDate ?? ((_d = (_c = defaultOptions2.locale) == null ? void 0 : _c.options) == null ? void 0 : _d.firstWeekContainsDate) ?? 1;
-  const weekStartsOn = (options == null ? void 0 : options.weekStartsOn) ?? ((_f = (_e = options == null ? void 0 : options.locale) == null ? void 0 : _e.options) == null ? void 0 : _f.weekStartsOn) ?? defaultOptions2.weekStartsOn ?? ((_h = (_g = defaultOptions2.locale) == null ? void 0 : _g.options) == null ? void 0 : _h.weekStartsOn) ?? 0;
-  const originalDate = toDate(date, options == null ? void 0 : options.in);
-  if (!isValid(originalDate)) {
-    throw new RangeError("Invalid time value");
-  }
-  let parts = formatStr.match(longFormattingTokensRegExp$1).map((substring) => {
-    const firstCharacter = substring[0];
-    if (firstCharacter === "p" || firstCharacter === "P") {
-      const longFormatter = longFormatters[firstCharacter];
-      return longFormatter(substring, locale.formatLong);
-    }
-    return substring;
-  }).join("").match(formattingTokensRegExp$1).map((substring) => {
-    if (substring === "''") {
-      return { isToken: false, value: "'" };
-    }
-    const firstCharacter = substring[0];
-    if (firstCharacter === "'") {
-      return { isToken: false, value: cleanEscapedString$1(substring) };
-    }
-    if (formatters[firstCharacter]) {
-      return { isToken: true, value: substring };
-    }
-    if (firstCharacter.match(unescapedLatinCharacterRegExp$1)) {
-      throw new RangeError(
-        "Format string contains an unescaped latin alphabet character `" + firstCharacter + "`"
-      );
-    }
-    return { isToken: false, value: substring };
-  });
-  if (locale.localize.preprocessor) {
-    parts = locale.localize.preprocessor(originalDate, parts);
-  }
-  const formatterOptions = {
-    firstWeekContainsDate,
-    weekStartsOn,
-    locale
-  };
-  return parts.map((part) => {
-    if (!part.isToken) return part.value;
-    const token = part.value;
-    if (!(options == null ? void 0 : options.useAdditionalWeekYearTokens) && isProtectedWeekYearToken(token) || !(options == null ? void 0 : options.useAdditionalDayOfYearTokens) && isProtectedDayOfYearToken(token)) {
-      warnOrThrowProtectedError(token, formatStr, String(date));
-    }
-    const formatter = formatters[token[0]];
-    return formatter(originalDate, token, locale.localize, formatterOptions);
-  }).join("");
-}
-function cleanEscapedString$1(input) {
-  const matched = input.match(escapedStringRegExp$1);
-  if (!matched) {
-    return input;
-  }
-  return matched[1].replace(doubleQuoteRegExp$1, "'");
-}
-function getDefaultOptions() {
-  return Object.assign({}, getDefaultOptions$1());
-}
-function getISODay(date, options) {
-  const day = toDate(date, options == null ? void 0 : options.in).getDay();
-  return day === 0 ? 7 : day;
-}
-function transpose(date, constructor) {
-  const date_ = isConstructor(constructor) ? new constructor(0) : constructFrom(constructor, 0);
-  date_.setFullYear(date.getFullYear(), date.getMonth(), date.getDate());
-  date_.setHours(
-    date.getHours(),
-    date.getMinutes(),
-    date.getSeconds(),
-    date.getMilliseconds()
-  );
-  return date_;
-}
-function isConstructor(constructor) {
-  var _a2;
-  return typeof constructor === "function" && ((_a2 = constructor.prototype) == null ? void 0 : _a2.constructor) === constructor;
-}
-const TIMEZONE_UNIT_PRIORITY = 10;
-class Setter {
-  constructor() {
-    __publicField(this, "subPriority", 0);
-  }
-  validate(_utcDate, _options) {
-    return true;
-  }
-}
-class ValueSetter extends Setter {
-  constructor(value, validateValue, setValue, priority, subPriority) {
-    super();
-    this.value = value;
-    this.validateValue = validateValue;
-    this.setValue = setValue;
-    this.priority = priority;
-    if (subPriority) {
-      this.subPriority = subPriority;
-    }
-  }
-  validate(date, options) {
-    return this.validateValue(date, this.value, options);
-  }
-  set(date, flags, options) {
-    return this.setValue(date, flags, this.value, options);
-  }
-}
-class DateTimezoneSetter extends Setter {
-  constructor(context, reference) {
-    super();
-    __publicField(this, "priority", TIMEZONE_UNIT_PRIORITY);
-    __publicField(this, "subPriority", -1);
-    this.context = context || ((date) => constructFrom(reference, date));
-  }
-  set(date, flags) {
-    if (flags.timestampIsSet) return date;
-    return constructFrom(date, transpose(date, this.context));
-  }
-}
-class Parser {
-  run(dateString, token, match2, options) {
-    const result = this.parse(dateString, token, match2, options);
-    if (!result) {
-      return null;
-    }
-    return {
-      setter: new ValueSetter(
-        result.value,
-        this.validate,
-        this.set,
-        this.priority,
-        this.subPriority
-      ),
-      rest: result.rest
-    };
-  }
-  validate(_utcDate, _value, _options) {
-    return true;
-  }
-}
-class EraParser extends Parser {
-  constructor() {
-    super(...arguments);
-    __publicField(this, "priority", 140);
-    __publicField(this, "incompatibleTokens", ["R", "u", "t", "T"]);
-  }
-  parse(dateString, token, match2) {
-    switch (token) {
-      case "G":
-      case "GG":
-      case "GGG":
-        return match2.era(dateString, { width: "abbreviated" }) || match2.era(dateString, { width: "narrow" });
-      case "GGGGG":
-        return match2.era(dateString, { width: "narrow" });
-      case "GGGG":
-      default:
-        return match2.era(dateString, { width: "wide" }) || match2.era(dateString, { width: "abbreviated" }) || match2.era(dateString, { width: "narrow" });
-    }
-  }
-  set(date, flags, value) {
-    flags.era = value;
-    date.setFullYear(value, 0, 1);
-    date.setHours(0, 0, 0, 0);
-    return date;
-  }
-}
-const numericPatterns = {
-  month: /^(1[0-2]|0?\d)/,
-  // 0 to 12
-  date: /^(3[0-1]|[0-2]?\d)/,
-  // 0 to 31
-  dayOfYear: /^(36[0-6]|3[0-5]\d|[0-2]?\d?\d)/,
-  // 0 to 366
-  week: /^(5[0-3]|[0-4]?\d)/,
-  // 0 to 53
-  hour23h: /^(2[0-3]|[0-1]?\d)/,
-  // 0 to 23
-  hour24h: /^(2[0-4]|[0-1]?\d)/,
-  // 0 to 24
-  hour11h: /^(1[0-1]|0?\d)/,
-  // 0 to 11
-  hour12h: /^(1[0-2]|0?\d)/,
-  // 0 to 12
-  minute: /^[0-5]?\d/,
-  // 0 to 59
-  second: /^[0-5]?\d/,
-  // 0 to 59
-  singleDigit: /^\d/,
-  // 0 to 9
-  twoDigits: /^\d{1,2}/,
-  // 0 to 99
-  threeDigits: /^\d{1,3}/,
-  // 0 to 999
-  fourDigits: /^\d{1,4}/,
-  // 0 to 9999
-  anyDigitsSigned: /^-?\d+/,
-  singleDigitSigned: /^-?\d/,
-  // 0 to 9, -0 to -9
-  twoDigitsSigned: /^-?\d{1,2}/,
-  // 0 to 99, -0 to -99
-  threeDigitsSigned: /^-?\d{1,3}/,
-  // 0 to 999, -0 to -999
-  fourDigitsSigned: /^-?\d{1,4}/
-  // 0 to 9999, -0 to -9999
-};
-const timezonePatterns = {
-  basicOptionalMinutes: /^([+-])(\d{2})(\d{2})?|Z/,
-  basic: /^([+-])(\d{2})(\d{2})|Z/,
-  basicOptionalSeconds: /^([+-])(\d{2})(\d{2})((\d{2}))?|Z/,
-  extended: /^([+-])(\d{2}):(\d{2})|Z/,
-  extendedOptionalSeconds: /^([+-])(\d{2}):(\d{2})(:(\d{2}))?|Z/
-};
-function mapValue(parseFnResult, mapFn) {
-  if (!parseFnResult) {
-    return parseFnResult;
-  }
-  return {
-    value: mapFn(parseFnResult.value),
-    rest: parseFnResult.rest
-  };
-}
-function parseNumericPattern(pattern, dateString) {
-  const matchResult = dateString.match(pattern);
-  if (!matchResult) {
-    return null;
-  }
-  return {
-    value: parseInt(matchResult[0], 10),
-    rest: dateString.slice(matchResult[0].length)
-  };
-}
-function parseTimezonePattern(pattern, dateString) {
-  const matchResult = dateString.match(pattern);
-  if (!matchResult) {
-    return null;
-  }
-  if (matchResult[0] === "Z") {
-    return {
-      value: 0,
-      rest: dateString.slice(1)
-    };
-  }
-  const sign2 = matchResult[1] === "+" ? 1 : -1;
-  const hours = matchResult[2] ? parseInt(matchResult[2], 10) : 0;
-  const minutes = matchResult[3] ? parseInt(matchResult[3], 10) : 0;
-  const seconds = matchResult[5] ? parseInt(matchResult[5], 10) : 0;
-  return {
-    value: sign2 * (hours * millisecondsInHour + minutes * millisecondsInMinute + seconds * millisecondsInSecond),
-    rest: dateString.slice(matchResult[0].length)
-  };
-}
-function parseAnyDigitsSigned(dateString) {
-  return parseNumericPattern(numericPatterns.anyDigitsSigned, dateString);
-}
-function parseNDigits(n2, dateString) {
-  switch (n2) {
-    case 1:
-      return parseNumericPattern(numericPatterns.singleDigit, dateString);
-    case 2:
-      return parseNumericPattern(numericPatterns.twoDigits, dateString);
-    case 3:
-      return parseNumericPattern(numericPatterns.threeDigits, dateString);
-    case 4:
-      return parseNumericPattern(numericPatterns.fourDigits, dateString);
-    default:
-      return parseNumericPattern(new RegExp("^\\d{1," + n2 + "}"), dateString);
-  }
-}
-function parseNDigitsSigned(n2, dateString) {
-  switch (n2) {
-    case 1:
-      return parseNumericPattern(numericPatterns.singleDigitSigned, dateString);
-    case 2:
-      return parseNumericPattern(numericPatterns.twoDigitsSigned, dateString);
-    case 3:
-      return parseNumericPattern(numericPatterns.threeDigitsSigned, dateString);
-    case 4:
-      return parseNumericPattern(numericPatterns.fourDigitsSigned, dateString);
-    default:
-      return parseNumericPattern(new RegExp("^-?\\d{1," + n2 + "}"), dateString);
-  }
-}
-function dayPeriodEnumToHours(dayPeriod) {
-  switch (dayPeriod) {
-    case "morning":
-      return 4;
-    case "evening":
-      return 17;
-    case "pm":
-    case "noon":
-    case "afternoon":
-      return 12;
-    case "am":
-    case "midnight":
-    case "night":
-    default:
-      return 0;
-  }
-}
-function normalizeTwoDigitYear(twoDigitYear, currentYear) {
-  const isCommonEra = currentYear > 0;
-  const absCurrentYear = isCommonEra ? currentYear : 1 - currentYear;
-  let result;
-  if (absCurrentYear <= 50) {
-    result = twoDigitYear || 100;
-  } else {
-    const rangeEnd = absCurrentYear + 50;
-    const rangeEndCentury = Math.trunc(rangeEnd / 100) * 100;
-    const isPreviousCentury = twoDigitYear >= rangeEnd % 100;
-    result = twoDigitYear + rangeEndCentury - (isPreviousCentury ? 100 : 0);
-  }
-  return isCommonEra ? result : 1 - result;
-}
-function isLeapYearIndex$1(year) {
-  return year % 400 === 0 || year % 4 === 0 && year % 100 !== 0;
-}
-class YearParser extends Parser {
-  constructor() {
-    super(...arguments);
-    __publicField(this, "priority", 130);
-    __publicField(this, "incompatibleTokens", ["Y", "R", "u", "w", "I", "i", "e", "c", "t", "T"]);
-  }
-  parse(dateString, token, match2) {
-    const valueCallback = (year) => ({
-      year,
-      isTwoDigitYear: token === "yy"
-    });
-    switch (token) {
-      case "y":
-        return mapValue(parseNDigits(4, dateString), valueCallback);
-      case "yo":
-        return mapValue(
-          match2.ordinalNumber(dateString, {
-            unit: "year"
-          }),
-          valueCallback
-        );
-      default:
-        return mapValue(parseNDigits(token.length, dateString), valueCallback);
-    }
-  }
-  validate(_date, value) {
-    return value.isTwoDigitYear || value.year > 0;
-  }
-  set(date, flags, value) {
-    const currentYear = date.getFullYear();
-    if (value.isTwoDigitYear) {
-      const normalizedTwoDigitYear = normalizeTwoDigitYear(
-        value.year,
-        currentYear
-      );
-      date.setFullYear(normalizedTwoDigitYear, 0, 1);
-      date.setHours(0, 0, 0, 0);
-      return date;
-    }
-    const year = !("era" in flags) || flags.era === 1 ? value.year : 1 - value.year;
-    date.setFullYear(year, 0, 1);
-    date.setHours(0, 0, 0, 0);
-    return date;
-  }
-}
-class LocalWeekYearParser extends Parser {
-  constructor() {
-    super(...arguments);
-    __publicField(this, "priority", 130);
-    __publicField(this, "incompatibleTokens", [
-      "y",
-      "R",
-      "u",
-      "Q",
-      "q",
-      "M",
-      "L",
-      "I",
-      "d",
-      "D",
-      "i",
-      "t",
-      "T"
-    ]);
-  }
-  parse(dateString, token, match2) {
-    const valueCallback = (year) => ({
-      year,
-      isTwoDigitYear: token === "YY"
-    });
-    switch (token) {
-      case "Y":
-        return mapValue(parseNDigits(4, dateString), valueCallback);
-      case "Yo":
-        return mapValue(
-          match2.ordinalNumber(dateString, {
-            unit: "year"
-          }),
-          valueCallback
-        );
-      default:
-        return mapValue(parseNDigits(token.length, dateString), valueCallback);
-    }
-  }
-  validate(_date, value) {
-    return value.isTwoDigitYear || value.year > 0;
-  }
-  set(date, flags, value, options) {
-    const currentYear = getWeekYear(date, options);
-    if (value.isTwoDigitYear) {
-      const normalizedTwoDigitYear = normalizeTwoDigitYear(
-        value.year,
-        currentYear
-      );
-      date.setFullYear(
-        normalizedTwoDigitYear,
-        0,
-        options.firstWeekContainsDate
-      );
-      date.setHours(0, 0, 0, 0);
-      return startOfWeek(date, options);
-    }
-    const year = !("era" in flags) || flags.era === 1 ? value.year : 1 - value.year;
-    date.setFullYear(year, 0, options.firstWeekContainsDate);
-    date.setHours(0, 0, 0, 0);
-    return startOfWeek(date, options);
-  }
-}
-class ISOWeekYearParser extends Parser {
-  constructor() {
-    super(...arguments);
-    __publicField(this, "priority", 130);
-    __publicField(this, "incompatibleTokens", [
-      "G",
-      "y",
-      "Y",
-      "u",
-      "Q",
-      "q",
-      "M",
-      "L",
-      "w",
-      "d",
-      "D",
-      "e",
-      "c",
-      "t",
-      "T"
-    ]);
-  }
-  parse(dateString, token) {
-    if (token === "R") {
-      return parseNDigitsSigned(4, dateString);
-    }
-    return parseNDigitsSigned(token.length, dateString);
-  }
-  set(date, _flags, value) {
-    const firstWeekOfYear = constructFrom(date, 0);
-    firstWeekOfYear.setFullYear(value, 0, 4);
-    firstWeekOfYear.setHours(0, 0, 0, 0);
-    return startOfISOWeek(firstWeekOfYear);
-  }
-}
-class ExtendedYearParser extends Parser {
-  constructor() {
-    super(...arguments);
-    __publicField(this, "priority", 130);
-    __publicField(this, "incompatibleTokens", ["G", "y", "Y", "R", "w", "I", "i", "e", "c", "t", "T"]);
-  }
-  parse(dateString, token) {
-    if (token === "u") {
-      return parseNDigitsSigned(4, dateString);
-    }
-    return parseNDigitsSigned(token.length, dateString);
-  }
-  set(date, _flags, value) {
-    date.setFullYear(value, 0, 1);
-    date.setHours(0, 0, 0, 0);
-    return date;
-  }
-}
-class QuarterParser extends Parser {
-  constructor() {
-    super(...arguments);
-    __publicField(this, "priority", 120);
-    __publicField(this, "incompatibleTokens", [
-      "Y",
-      "R",
-      "q",
-      "M",
-      "L",
-      "w",
-      "I",
-      "d",
-      "D",
-      "i",
-      "e",
-      "c",
-      "t",
-      "T"
-    ]);
-  }
-  parse(dateString, token, match2) {
-    switch (token) {
-      case "Q":
-      case "QQ":
-        return parseNDigits(token.length, dateString);
-      case "Qo":
-        return match2.ordinalNumber(dateString, { unit: "quarter" });
-      case "QQQ":
-        return match2.quarter(dateString, {
-          width: "abbreviated",
-          context: "formatting"
-        }) || match2.quarter(dateString, {
-          width: "narrow",
-          context: "formatting"
-        });
-      case "QQQQQ":
-        return match2.quarter(dateString, {
-          width: "narrow",
-          context: "formatting"
-        });
-      case "QQQQ":
-      default:
-        return match2.quarter(dateString, {
-          width: "wide",
-          context: "formatting"
-        }) || match2.quarter(dateString, {
-          width: "abbreviated",
-          context: "formatting"
-        }) || match2.quarter(dateString, {
-          width: "narrow",
-          context: "formatting"
-        });
-    }
-  }
-  validate(_date, value) {
-    return value >= 1 && value <= 4;
-  }
-  set(date, _flags, value) {
-    date.setMonth((value - 1) * 3, 1);
-    date.setHours(0, 0, 0, 0);
-    return date;
-  }
-}
-class StandAloneQuarterParser extends Parser {
-  constructor() {
-    super(...arguments);
-    __publicField(this, "priority", 120);
-    __publicField(this, "incompatibleTokens", [
-      "Y",
-      "R",
-      "Q",
-      "M",
-      "L",
-      "w",
-      "I",
-      "d",
-      "D",
-      "i",
-      "e",
-      "c",
-      "t",
-      "T"
-    ]);
-  }
-  parse(dateString, token, match2) {
-    switch (token) {
-      case "q":
-      case "qq":
-        return parseNDigits(token.length, dateString);
-      case "qo":
-        return match2.ordinalNumber(dateString, { unit: "quarter" });
-      case "qqq":
-        return match2.quarter(dateString, {
-          width: "abbreviated",
-          context: "standalone"
-        }) || match2.quarter(dateString, {
-          width: "narrow",
-          context: "standalone"
-        });
-      case "qqqqq":
-        return match2.quarter(dateString, {
-          width: "narrow",
-          context: "standalone"
-        });
-      case "qqqq":
-      default:
-        return match2.quarter(dateString, {
-          width: "wide",
-          context: "standalone"
-        }) || match2.quarter(dateString, {
-          width: "abbreviated",
-          context: "standalone"
-        }) || match2.quarter(dateString, {
-          width: "narrow",
-          context: "standalone"
-        });
-    }
-  }
-  validate(_date, value) {
-    return value >= 1 && value <= 4;
-  }
-  set(date, _flags, value) {
-    date.setMonth((value - 1) * 3, 1);
-    date.setHours(0, 0, 0, 0);
-    return date;
-  }
-}
-class MonthParser extends Parser {
-  constructor() {
-    super(...arguments);
-    __publicField(this, "incompatibleTokens", [
-      "Y",
-      "R",
-      "q",
-      "Q",
-      "L",
-      "w",
-      "I",
-      "D",
-      "i",
-      "e",
-      "c",
-      "t",
-      "T"
-    ]);
-    __publicField(this, "priority", 110);
-  }
-  parse(dateString, token, match2) {
-    const valueCallback = (value) => value - 1;
-    switch (token) {
-      case "M":
-        return mapValue(
-          parseNumericPattern(numericPatterns.month, dateString),
-          valueCallback
-        );
-      case "MM":
-        return mapValue(parseNDigits(2, dateString), valueCallback);
-      case "Mo":
-        return mapValue(
-          match2.ordinalNumber(dateString, {
-            unit: "month"
-          }),
-          valueCallback
-        );
-      case "MMM":
-        return match2.month(dateString, {
-          width: "abbreviated",
-          context: "formatting"
-        }) || match2.month(dateString, { width: "narrow", context: "formatting" });
-      case "MMMMM":
-        return match2.month(dateString, {
-          width: "narrow",
-          context: "formatting"
-        });
-      case "MMMM":
-      default:
-        return match2.month(dateString, { width: "wide", context: "formatting" }) || match2.month(dateString, {
-          width: "abbreviated",
-          context: "formatting"
-        }) || match2.month(dateString, { width: "narrow", context: "formatting" });
-    }
-  }
-  validate(_date, value) {
-    return value >= 0 && value <= 11;
-  }
-  set(date, _flags, value) {
-    date.setMonth(value, 1);
-    date.setHours(0, 0, 0, 0);
-    return date;
-  }
-}
-class StandAloneMonthParser extends Parser {
-  constructor() {
-    super(...arguments);
-    __publicField(this, "priority", 110);
-    __publicField(this, "incompatibleTokens", [
-      "Y",
-      "R",
-      "q",
-      "Q",
-      "M",
-      "w",
-      "I",
-      "D",
-      "i",
-      "e",
-      "c",
-      "t",
-      "T"
-    ]);
-  }
-  parse(dateString, token, match2) {
-    const valueCallback = (value) => value - 1;
-    switch (token) {
-      case "L":
-        return mapValue(
-          parseNumericPattern(numericPatterns.month, dateString),
-          valueCallback
-        );
-      case "LL":
-        return mapValue(parseNDigits(2, dateString), valueCallback);
-      case "Lo":
-        return mapValue(
-          match2.ordinalNumber(dateString, {
-            unit: "month"
-          }),
-          valueCallback
-        );
-      case "LLL":
-        return match2.month(dateString, {
-          width: "abbreviated",
-          context: "standalone"
-        }) || match2.month(dateString, { width: "narrow", context: "standalone" });
-      case "LLLLL":
-        return match2.month(dateString, {
-          width: "narrow",
-          context: "standalone"
-        });
-      case "LLLL":
-      default:
-        return match2.month(dateString, { width: "wide", context: "standalone" }) || match2.month(dateString, {
-          width: "abbreviated",
-          context: "standalone"
-        }) || match2.month(dateString, { width: "narrow", context: "standalone" });
-    }
-  }
-  validate(_date, value) {
-    return value >= 0 && value <= 11;
-  }
-  set(date, _flags, value) {
-    date.setMonth(value, 1);
-    date.setHours(0, 0, 0, 0);
-    return date;
-  }
-}
-function setWeek(date, week, options) {
-  const date_ = toDate(date, options == null ? void 0 : options.in);
-  const diff = getWeek(date_, options) - week;
-  date_.setDate(date_.getDate() - diff * 7);
-  return toDate(date_, options == null ? void 0 : options.in);
+      });
+      var require_global_this = __commonJS({
+        "node_modules/ext/global-this/index.js"(exports, module2) {
+          module2.exports = require_is_implemented6()() ? globalThis : require_implementation6();
+        }
+      });
+      var require_is_implemented7 = __commonJS({
+        "node_modules/es6-symbol/is-implemented.js"(exports, module2) {
+          var global2 = require_global_this();
+          var validTypes = { object: true, symbol: true };
+          module2.exports = function() {
+            var Symbol2 = global2.Symbol;
+            var symbol;
+            if (typeof Symbol2 !== "function") return false;
+            symbol = Symbol2("test symbol");
+            try {
+              String(symbol);
+            } catch (e2) {
+              return false;
+            }
+            if (!validTypes[typeof Symbol2.iterator]) return false;
+            if (!validTypes[typeof Symbol2.toPrimitive]) return false;
+            if (!validTypes[typeof Symbol2.toStringTag]) return false;
+            return true;
+          };
+        }
+      });
+      var require_is_symbol = __commonJS({
+        "node_modules/es6-symbol/is-symbol.js"(exports, module2) {
+          module2.exports = function(value) {
+            if (!value) return false;
+            if (typeof value === "symbol") return true;
+            if (!value.constructor) return false;
+            if (value.constructor.name !== "Symbol") return false;
+            return value[value.constructor.toStringTag] === "Symbol";
+          };
+        }
+      });
+      var require_validate_symbol = __commonJS({
+        "node_modules/es6-symbol/validate-symbol.js"(exports, module2) {
+          var isSymbol = require_is_symbol();
+          module2.exports = function(value) {
+            if (!isSymbol(value)) throw new TypeError(value + " is not a symbol");
+            return value;
+          };
+        }
+      });
+      var require_generate_name = __commonJS({
+        "node_modules/es6-symbol/lib/private/generate-name.js"(exports, module2) {
+          var d2 = require_d();
+          var create2 = Object.create;
+          var defineProperty = Object.defineProperty;
+          var objPrototype = Object.prototype;
+          var created = create2(null);
+          module2.exports = function(desc) {
+            var postfix = 0, name2, ie11BugWorkaround;
+            while (created[desc + (postfix || "")]) ++postfix;
+            desc += postfix || "";
+            created[desc] = true;
+            name2 = "@@" + desc;
+            defineProperty(
+              objPrototype,
+              name2,
+              d2.gs(null, function(value) {
+                if (ie11BugWorkaround) return;
+                ie11BugWorkaround = true;
+                defineProperty(this, name2, d2(value));
+                ie11BugWorkaround = false;
+              })
+            );
+            return name2;
+          };
+        }
+      });
+      var require_standard_symbols = __commonJS({
+        "node_modules/es6-symbol/lib/private/setup/standard-symbols.js"(exports, module2) {
+          var d2 = require_d();
+          var NativeSymbol = require_global_this().Symbol;
+          module2.exports = function(SymbolPolyfill) {
+            return Object.defineProperties(SymbolPolyfill, {
+              // To ensure proper interoperability with other native functions (e.g. Array.from)
+              // fallback to eventual native implementation of given symbol
+              hasInstance: d2(
+                "",
+                NativeSymbol && NativeSymbol.hasInstance || SymbolPolyfill("hasInstance")
+              ),
+              isConcatSpreadable: d2(
+                "",
+                NativeSymbol && NativeSymbol.isConcatSpreadable || SymbolPolyfill("isConcatSpreadable")
+              ),
+              iterator: d2("", NativeSymbol && NativeSymbol.iterator || SymbolPolyfill("iterator")),
+              match: d2("", NativeSymbol && NativeSymbol.match || SymbolPolyfill("match")),
+              replace: d2("", NativeSymbol && NativeSymbol.replace || SymbolPolyfill("replace")),
+              search: d2("", NativeSymbol && NativeSymbol.search || SymbolPolyfill("search")),
+              species: d2("", NativeSymbol && NativeSymbol.species || SymbolPolyfill("species")),
+              split: d2("", NativeSymbol && NativeSymbol.split || SymbolPolyfill("split")),
+              toPrimitive: d2(
+                "",
+                NativeSymbol && NativeSymbol.toPrimitive || SymbolPolyfill("toPrimitive")
+              ),
+              toStringTag: d2(
+                "",
+                NativeSymbol && NativeSymbol.toStringTag || SymbolPolyfill("toStringTag")
+              ),
+              unscopables: d2(
+                "",
+                NativeSymbol && NativeSymbol.unscopables || SymbolPolyfill("unscopables")
+              )
+            });
+          };
+        }
+      });
+      var require_symbol_registry = __commonJS({
+        "node_modules/es6-symbol/lib/private/setup/symbol-registry.js"(exports, module2) {
+          var d2 = require_d();
+          var validateSymbol = require_validate_symbol();
+          var registry = /* @__PURE__ */ Object.create(null);
+          module2.exports = function(SymbolPolyfill) {
+            return Object.defineProperties(SymbolPolyfill, {
+              for: d2(function(key) {
+                if (registry[key]) return registry[key];
+                return registry[key] = SymbolPolyfill(String(key));
+              }),
+              keyFor: d2(function(symbol) {
+                var key;
+                validateSymbol(symbol);
+                for (key in registry) {
+                  if (registry[key] === symbol) return key;
+                }
+                return void 0;
+              })
+            });
+          };
+        }
+      });
+      var require_polyfill4 = __commonJS({
+        "node_modules/es6-symbol/polyfill.js"(exports, module2) {
+          var d2 = require_d();
+          var validateSymbol = require_validate_symbol();
+          var NativeSymbol = require_global_this().Symbol;
+          var generateName = require_generate_name();
+          var setupStandardSymbols = require_standard_symbols();
+          var setupSymbolRegistry = require_symbol_registry();
+          var create2 = Object.create;
+          var defineProperties = Object.defineProperties;
+          var defineProperty = Object.defineProperty;
+          var SymbolPolyfill;
+          var HiddenSymbol;
+          var isNativeSafe;
+          if (typeof NativeSymbol === "function") {
+            try {
+              String(NativeSymbol());
+              isNativeSafe = true;
+            } catch (ignore) {
+            }
+          } else {
+            NativeSymbol = null;
+          }
+          HiddenSymbol = function Symbol2(description) {
+            if (this instanceof HiddenSymbol) throw new TypeError("Symbol is not a constructor");
+            return SymbolPolyfill(description);
+          };
+          module2.exports = SymbolPolyfill = function Symbol2(description) {
+            var symbol;
+            if (this instanceof Symbol2) throw new TypeError("Symbol is not a constructor");
+            if (isNativeSafe) return NativeSymbol(description);
+            symbol = create2(HiddenSymbol.prototype);
+            description = description === void 0 ? "" : String(description);
+            return defineProperties(symbol, {
+              __description__: d2("", description),
+              __name__: d2("", generateName(description))
+            });
+          };
+          setupStandardSymbols(SymbolPolyfill);
+          setupSymbolRegistry(SymbolPolyfill);
+          defineProperties(HiddenSymbol.prototype, {
+            constructor: d2(SymbolPolyfill),
+            toString: d2("", function() {
+              return this.__name__;
+            })
+          });
+          defineProperties(SymbolPolyfill.prototype, {
+            toString: d2(function() {
+              return "Symbol (" + validateSymbol(this).__description__ + ")";
+            }),
+            valueOf: d2(function() {
+              return validateSymbol(this);
+            })
+          });
+          defineProperty(
+            SymbolPolyfill.prototype,
+            SymbolPolyfill.toPrimitive,
+            d2("", function() {
+              var symbol = validateSymbol(this);
+              if (typeof symbol === "symbol") return symbol;
+              return symbol.toString();
+            })
+          );
+          defineProperty(SymbolPolyfill.prototype, SymbolPolyfill.toStringTag, d2("c", "Symbol"));
+          defineProperty(
+            HiddenSymbol.prototype,
+            SymbolPolyfill.toStringTag,
+            d2("c", SymbolPolyfill.prototype[SymbolPolyfill.toStringTag])
+          );
+          defineProperty(
+            HiddenSymbol.prototype,
+            SymbolPolyfill.toPrimitive,
+            d2("c", SymbolPolyfill.prototype[SymbolPolyfill.toPrimitive])
+          );
+        }
+      });
+      var require_es6_symbol = __commonJS({
+        "node_modules/es6-symbol/index.js"(exports, module2) {
+          module2.exports = require_is_implemented7()() ? require_global_this().Symbol : require_polyfill4();
+        }
+      });
+      var require_clear = __commonJS({
+        "node_modules/es5-ext/array/#/clear.js"(exports, module2) {
+          var value = require_valid_value();
+          module2.exports = function() {
+            value(this).length = 0;
+            return this;
+          };
+        }
+      });
+      var require_valid_callable = __commonJS({
+        "node_modules/es5-ext/object/valid-callable.js"(exports, module2) {
+          module2.exports = function(fn) {
+            if (typeof fn !== "function") throw new TypeError(fn + " is not a function");
+            return fn;
+          };
+        }
+      });
+      var require_coerce2 = __commonJS({
+        "node_modules/type/string/coerce.js"(exports, module2) {
+          var isValue = require_is();
+          var isObject2 = require_is2();
+          var objectToString = Object.prototype.toString;
+          module2.exports = function(value) {
+            if (!isValue(value)) return null;
+            if (isObject2(value)) {
+              var valueToString2 = value.toString;
+              if (typeof valueToString2 !== "function") return null;
+              if (valueToString2 === objectToString) return null;
+            }
+            try {
+              return "" + value;
+            } catch (error) {
+              return null;
+            }
+          };
+        }
+      });
+      var require_safe_to_string = __commonJS({
+        "node_modules/type/lib/safe-to-string.js"(exports, module2) {
+          module2.exports = function(value) {
+            try {
+              return value.toString();
+            } catch (error) {
+              try {
+                return String(value);
+              } catch (error2) {
+                return null;
+              }
+            }
+          };
+        }
+      });
+      var require_to_short_string = __commonJS({
+        "node_modules/type/lib/to-short-string.js"(exports, module2) {
+          var safeToString = require_safe_to_string();
+          var reNewLine = /[\n\r\u2028\u2029]/g;
+          module2.exports = function(value) {
+            var string = safeToString(value);
+            if (string === null) return "<Non-coercible to string value>";
+            if (string.length > 100) string = string.slice(0, 99) + "…";
+            string = string.replace(reNewLine, function(char) {
+              switch (char) {
+                case "\n":
+                  return "\\n";
+                case "\r":
+                  return "\\r";
+                case "\u2028":
+                  return "\\u2028";
+                case "\u2029":
+                  return "\\u2029";
+                default:
+                  throw new Error("Unexpected character");
+              }
+            });
+            return string;
+          };
+        }
+      });
+      var require_resolve_exception = __commonJS({
+        "node_modules/type/lib/resolve-exception.js"(exports, module2) {
+          var isValue = require_is();
+          var isObject2 = require_is2();
+          var stringCoerce = require_coerce2();
+          var toShortString = require_to_short_string();
+          var resolveMessage = function(message2, value) {
+            return message2.replace("%v", toShortString(value));
+          };
+          module2.exports = function(value, defaultMessage, inputOptions) {
+            if (!isObject2(inputOptions)) throw new TypeError(resolveMessage(defaultMessage, value));
+            if (!isValue(value)) {
+              if ("default" in inputOptions) return inputOptions["default"];
+              if (inputOptions.isOptional) return null;
+            }
+            var errorMessage = stringCoerce(inputOptions.errorMessage);
+            if (!isValue(errorMessage)) errorMessage = defaultMessage;
+            throw new TypeError(resolveMessage(errorMessage, value));
+          };
+        }
+      });
+      var require_ensure = __commonJS({
+        "node_modules/type/value/ensure.js"(exports, module2) {
+          var resolveException = require_resolve_exception();
+          var is = require_is();
+          module2.exports = function(value) {
+            if (is(value)) return value;
+            return resolveException(value, "Cannot use %v", arguments[1]);
+          };
+        }
+      });
+      var require_ensure2 = __commonJS({
+        "node_modules/type/plain-function/ensure.js"(exports, module2) {
+          var resolveException = require_resolve_exception();
+          var is = require_is5();
+          module2.exports = function(value) {
+            if (is(value)) return value;
+            return resolveException(value, "%v is not a plain function", arguments[1]);
+          };
+        }
+      });
+      var require_is_implemented8 = __commonJS({
+        "node_modules/es5-ext/array/from/is-implemented.js"(exports, module2) {
+          module2.exports = function() {
+            var from = Array.from, arr, result;
+            if (typeof from !== "function") return false;
+            arr = ["raz", "dwa"];
+            result = from(arr);
+            return Boolean(result && result !== arr && result[1] === "dwa");
+          };
+        }
+      });
+      var require_is_function = __commonJS({
+        "node_modules/es5-ext/function/is-function.js"(exports, module2) {
+          var objToString = Object.prototype.toString;
+          var isFunctionStringTag = RegExp.prototype.test.bind(/^[object [A-Za-z0-9]*Function]$/);
+          module2.exports = function(value) {
+            return typeof value === "function" && isFunctionStringTag(objToString.call(value));
+          };
+        }
+      });
+      var require_is_implemented9 = __commonJS({
+        "node_modules/es5-ext/math/sign/is-implemented.js"(exports, module2) {
+          module2.exports = function() {
+            var sign = Math.sign;
+            if (typeof sign !== "function") return false;
+            return sign(10) === 1 && sign(-20) === -1;
+          };
+        }
+      });
+      var require_shim7 = __commonJS({
+        "node_modules/es5-ext/math/sign/shim.js"(exports, module2) {
+          module2.exports = function(value) {
+            value = Number(value);
+            if (isNaN(value) || value === 0) return value;
+            return value > 0 ? 1 : -1;
+          };
+        }
+      });
+      var require_sign2 = __commonJS({
+        "node_modules/es5-ext/math/sign/index.js"(exports, module2) {
+          module2.exports = require_is_implemented9()() ? Math.sign : require_shim7();
+        }
+      });
+      var require_to_integer = __commonJS({
+        "node_modules/es5-ext/number/to-integer.js"(exports, module2) {
+          var sign = require_sign2();
+          var abs = Math.abs;
+          var floor = Math.floor;
+          module2.exports = function(value) {
+            if (isNaN(value)) return 0;
+            value = Number(value);
+            if (value === 0 || !isFinite(value)) return value;
+            return sign(value) * floor(abs(value));
+          };
+        }
+      });
+      var require_to_pos_integer = __commonJS({
+        "node_modules/es5-ext/number/to-pos-integer.js"(exports, module2) {
+          var toInteger = require_to_integer();
+          var max = Math.max;
+          module2.exports = function(value) {
+            return max(0, toInteger(value));
+          };
+        }
+      });
+      var require_shim8 = __commonJS({
+        "node_modules/es5-ext/array/from/shim.js"(exports, module2) {
+          var iteratorSymbol = require_es6_symbol().iterator;
+          var isArguments = require_is_arguments2();
+          var isFunction2 = require_is_function();
+          var toPosInt = require_to_pos_integer();
+          var callable = require_valid_callable();
+          var validValue = require_valid_value();
+          var isValue = require_is_value();
+          var isString = require_is_string();
+          var isArray2 = Array.isArray;
+          var call = Function.prototype.call;
+          var desc = { configurable: true, enumerable: true, writable: true, value: null };
+          var defineProperty = Object.defineProperty;
+          module2.exports = function(arrayLike) {
+            var mapFn = arguments[1], thisArg = arguments[2], Context, i2, j2, arr, length2, code, iterator, result, getIterator, value;
+            arrayLike = Object(validValue(arrayLike));
+            if (isValue(mapFn)) callable(mapFn);
+            if (!this || this === Array || !isFunction2(this)) {
+              if (!mapFn) {
+                if (isArguments(arrayLike)) {
+                  length2 = arrayLike.length;
+                  if (length2 !== 1) return Array.apply(null, arrayLike);
+                  arr = new Array(1);
+                  arr[0] = arrayLike[0];
+                  return arr;
+                }
+                if (isArray2(arrayLike)) {
+                  arr = new Array(length2 = arrayLike.length);
+                  for (i2 = 0; i2 < length2; ++i2) arr[i2] = arrayLike[i2];
+                  return arr;
+                }
+              }
+              arr = [];
+            } else {
+              Context = this;
+            }
+            if (!isArray2(arrayLike)) {
+              if ((getIterator = arrayLike[iteratorSymbol]) !== void 0) {
+                iterator = callable(getIterator).call(arrayLike);
+                if (Context) arr = new Context();
+                result = iterator.next();
+                i2 = 0;
+                while (!result.done) {
+                  value = mapFn ? call.call(mapFn, thisArg, result.value, i2) : result.value;
+                  if (Context) {
+                    desc.value = value;
+                    defineProperty(arr, i2, desc);
+                  } else {
+                    arr[i2] = value;
+                  }
+                  result = iterator.next();
+                  ++i2;
+                }
+                length2 = i2;
+              } else if (isString(arrayLike)) {
+                length2 = arrayLike.length;
+                if (Context) arr = new Context();
+                for (i2 = 0, j2 = 0; i2 < length2; ++i2) {
+                  value = arrayLike[i2];
+                  if (i2 + 1 < length2) {
+                    code = value.charCodeAt(0);
+                    if (code >= 55296 && code <= 56319) value += arrayLike[++i2];
+                  }
+                  value = mapFn ? call.call(mapFn, thisArg, value, j2) : value;
+                  if (Context) {
+                    desc.value = value;
+                    defineProperty(arr, j2, desc);
+                  } else {
+                    arr[j2] = value;
+                  }
+                  ++j2;
+                }
+                length2 = j2;
+              }
+            }
+            if (length2 === void 0) {
+              length2 = toPosInt(arrayLike.length);
+              if (Context) arr = new Context(length2);
+              for (i2 = 0; i2 < length2; ++i2) {
+                value = mapFn ? call.call(mapFn, thisArg, arrayLike[i2], i2) : arrayLike[i2];
+                if (Context) {
+                  desc.value = value;
+                  defineProperty(arr, i2, desc);
+                } else {
+                  arr[i2] = value;
+                }
+              }
+            }
+            if (Context) {
+              desc.value = null;
+              arr.length = length2;
+            }
+            return arr;
+          };
+        }
+      });
+      var require_from = __commonJS({
+        "node_modules/es5-ext/array/from/index.js"(exports, module2) {
+          module2.exports = require_is_implemented8()() ? Array.from : require_shim8();
+        }
+      });
+      var require_copy2 = __commonJS({
+        "node_modules/es5-ext/object/copy.js"(exports, module2) {
+          var aFrom = require_from();
+          var assign = require_assign();
+          var value = require_valid_value();
+          module2.exports = function(obj) {
+            var copy = Object(value(obj)), propertyNames = arguments[1], options = Object(arguments[2]);
+            if (copy !== obj && !propertyNames) return copy;
+            var result = {};
+            if (propertyNames) {
+              aFrom(propertyNames, function(propertyName) {
+                if (options.ensure || propertyName in obj) result[propertyName] = obj[propertyName];
+              });
+            } else {
+              assign(result, obj);
+            }
+            return result;
+          };
+        }
+      });
+      var require_iterate = __commonJS({
+        "node_modules/es5-ext/object/_iterate.js"(exports, module2) {
+          var callable = require_valid_callable();
+          var value = require_valid_value();
+          var bind = Function.prototype.bind;
+          var call = Function.prototype.call;
+          var keys = Object.keys;
+          var objPropertyIsEnumerable = Object.prototype.propertyIsEnumerable;
+          module2.exports = function(method, defVal) {
+            return function(obj, cb2) {
+              var list, thisArg = arguments[2], compareFn = arguments[3];
+              obj = Object(value(obj));
+              callable(cb2);
+              list = keys(obj);
+              if (compareFn) {
+                list.sort(typeof compareFn === "function" ? bind.call(compareFn, obj) : void 0);
+              }
+              if (typeof method !== "function") method = list[method];
+              return call.call(method, list, function(key, index) {
+                if (!objPropertyIsEnumerable.call(obj, key)) return defVal;
+                return call.call(cb2, thisArg, obj[key], key, obj, index);
+              });
+            };
+          };
+        }
+      });
+      var require_for_each2 = __commonJS({
+        "node_modules/es5-ext/object/for-each.js"(exports, module2) {
+          module2.exports = require_iterate()("forEach");
+        }
+      });
+      var require_map = __commonJS({
+        "node_modules/es5-ext/object/map.js"(exports, module2) {
+          var callable = require_valid_callable();
+          var forEach = require_for_each2();
+          var call = Function.prototype.call;
+          module2.exports = function(obj, cb2) {
+            var result = {}, thisArg = arguments[2];
+            callable(cb2);
+            forEach(obj, function(value, key, targetObj, index) {
+              result[key] = call.call(cb2, thisArg, value, key, targetObj, index);
+            });
+            return result;
+          };
+        }
+      });
+      var require_auto_bind = __commonJS({
+        "node_modules/d/auto-bind.js"(exports, module2) {
+          var isValue = require_is();
+          var ensureValue = require_ensure();
+          var ensurePlainFunction = require_ensure2();
+          var copy = require_copy2();
+          var normalizeOptions2 = require_normalize_options();
+          var map2 = require_map();
+          var bind = Function.prototype.bind;
+          var defineProperty = Object.defineProperty;
+          var hasOwnProperty2 = Object.prototype.hasOwnProperty;
+          var define2;
+          define2 = function(name2, desc, options) {
+            var value = ensureValue(desc) && ensurePlainFunction(desc.value), dgs;
+            dgs = copy(desc);
+            delete dgs.writable;
+            delete dgs.value;
+            dgs.get = function() {
+              if (!options.overwriteDefinition && hasOwnProperty2.call(this, name2)) return value;
+              desc.value = bind.call(value, options.resolveContext ? options.resolveContext(this) : this);
+              defineProperty(this, name2, desc);
+              return this[name2];
+            };
+            return dgs;
+          };
+          module2.exports = function(props) {
+            var options = normalizeOptions2(arguments[1]);
+            if (isValue(options.resolveContext)) ensurePlainFunction(options.resolveContext);
+            return map2(props, function(desc, name2) {
+              return define2(name2, desc, options);
+            });
+          };
+        }
+      });
+      var require_es6_iterator = __commonJS({
+        "node_modules/es6-iterator/index.js"(exports, module2) {
+          var clear = require_clear();
+          var assign = require_assign();
+          var callable = require_valid_callable();
+          var value = require_valid_value();
+          var d2 = require_d();
+          var autoBind = require_auto_bind();
+          var Symbol2 = require_es6_symbol();
+          var defineProperty = Object.defineProperty;
+          var defineProperties = Object.defineProperties;
+          var Iterator;
+          module2.exports = Iterator = function(list, context) {
+            if (!(this instanceof Iterator)) throw new TypeError("Constructor requires 'new'");
+            defineProperties(this, {
+              __list__: d2("w", value(list)),
+              __context__: d2("w", context),
+              __nextIndex__: d2("w", 0)
+            });
+            if (!context) return;
+            callable(context.on);
+            context.on("_add", this._onAdd);
+            context.on("_delete", this._onDelete);
+            context.on("_clear", this._onClear);
+          };
+          delete Iterator.prototype.constructor;
+          defineProperties(
+            Iterator.prototype,
+            assign(
+              {
+                _next: d2(function() {
+                  var i2;
+                  if (!this.__list__) return void 0;
+                  if (this.__redo__) {
+                    i2 = this.__redo__.shift();
+                    if (i2 !== void 0) return i2;
+                  }
+                  if (this.__nextIndex__ < this.__list__.length) return this.__nextIndex__++;
+                  this._unBind();
+                  return void 0;
+                }),
+                next: d2(function() {
+                  return this._createResult(this._next());
+                }),
+                _createResult: d2(function(i2) {
+                  if (i2 === void 0) return { done: true, value: void 0 };
+                  return { done: false, value: this._resolve(i2) };
+                }),
+                _resolve: d2(function(i2) {
+                  return this.__list__[i2];
+                }),
+                _unBind: d2(function() {
+                  this.__list__ = null;
+                  delete this.__redo__;
+                  if (!this.__context__) return;
+                  this.__context__.off("_add", this._onAdd);
+                  this.__context__.off("_delete", this._onDelete);
+                  this.__context__.off("_clear", this._onClear);
+                  this.__context__ = null;
+                }),
+                toString: d2(function() {
+                  return "[object " + (this[Symbol2.toStringTag] || "Object") + "]";
+                })
+              },
+              autoBind({
+                _onAdd: d2(function(index) {
+                  if (index >= this.__nextIndex__) return;
+                  ++this.__nextIndex__;
+                  if (!this.__redo__) {
+                    defineProperty(this, "__redo__", d2("c", [index]));
+                    return;
+                  }
+                  this.__redo__.forEach(function(redo, i2) {
+                    if (redo >= index) this.__redo__[i2] = ++redo;
+                  }, this);
+                  this.__redo__.push(index);
+                }),
+                _onDelete: d2(function(index) {
+                  var i2;
+                  if (index >= this.__nextIndex__) return;
+                  --this.__nextIndex__;
+                  if (!this.__redo__) return;
+                  i2 = this.__redo__.indexOf(index);
+                  if (i2 !== -1) this.__redo__.splice(i2, 1);
+                  this.__redo__.forEach(function(redo, j2) {
+                    if (redo > index) this.__redo__[j2] = --redo;
+                  }, this);
+                }),
+                _onClear: d2(function() {
+                  if (this.__redo__) clear.call(this.__redo__);
+                  this.__nextIndex__ = 0;
+                })
+              })
+            )
+          );
+          defineProperty(
+            Iterator.prototype,
+            Symbol2.iterator,
+            d2(function() {
+              return this;
+            })
+          );
+        }
+      });
+      var require_array2 = __commonJS({
+        "node_modules/es6-iterator/array.js"(exports, module2) {
+          var setPrototypeOf = require_set_prototype_of();
+          var contains = require_contains();
+          var d2 = require_d();
+          var Symbol2 = require_es6_symbol();
+          var Iterator = require_es6_iterator();
+          var defineProperty = Object.defineProperty;
+          var ArrayIterator;
+          ArrayIterator = module2.exports = function(arr, kind) {
+            if (!(this instanceof ArrayIterator)) throw new TypeError("Constructor requires 'new'");
+            Iterator.call(this, arr);
+            if (!kind) kind = "value";
+            else if (contains.call(kind, "key+value")) kind = "key+value";
+            else if (contains.call(kind, "key")) kind = "key";
+            else kind = "value";
+            defineProperty(this, "__kind__", d2("", kind));
+          };
+          if (setPrototypeOf) setPrototypeOf(ArrayIterator, Iterator);
+          delete ArrayIterator.prototype.constructor;
+          ArrayIterator.prototype = Object.create(Iterator.prototype, {
+            _resolve: d2(function(i2) {
+              if (this.__kind__ === "value") return this.__list__[i2];
+              if (this.__kind__ === "key+value") return [i2, this.__list__[i2]];
+              return i2;
+            })
+          });
+          defineProperty(ArrayIterator.prototype, Symbol2.toStringTag, d2("c", "Array Iterator"));
+        }
+      });
+      var require_string = __commonJS({
+        "node_modules/es6-iterator/string.js"(exports, module2) {
+          var setPrototypeOf = require_set_prototype_of();
+          var d2 = require_d();
+          var Symbol2 = require_es6_symbol();
+          var Iterator = require_es6_iterator();
+          var defineProperty = Object.defineProperty;
+          var StringIterator;
+          StringIterator = module2.exports = function(str) {
+            if (!(this instanceof StringIterator)) throw new TypeError("Constructor requires 'new'");
+            str = String(str);
+            Iterator.call(this, str);
+            defineProperty(this, "__length__", d2("", str.length));
+          };
+          if (setPrototypeOf) setPrototypeOf(StringIterator, Iterator);
+          delete StringIterator.prototype.constructor;
+          StringIterator.prototype = Object.create(Iterator.prototype, {
+            _next: d2(function() {
+              if (!this.__list__) return void 0;
+              if (this.__nextIndex__ < this.__length__) return this.__nextIndex__++;
+              this._unBind();
+              return void 0;
+            }),
+            _resolve: d2(function(i2) {
+              var char = this.__list__[i2], code;
+              if (this.__nextIndex__ === this.__length__) return char;
+              code = char.charCodeAt(0);
+              if (code >= 55296 && code <= 56319) return char + this.__list__[this.__nextIndex__++];
+              return char;
+            })
+          });
+          defineProperty(StringIterator.prototype, Symbol2.toStringTag, d2("c", "String Iterator"));
+        }
+      });
+      var require_is_iterable = __commonJS({
+        "node_modules/es6-iterator/is-iterable.js"(exports, module2) {
+          var isArguments = require_is_arguments2();
+          var isValue = require_is_value();
+          var isString = require_is_string();
+          var iteratorSymbol = require_es6_symbol().iterator;
+          var isArray2 = Array.isArray;
+          module2.exports = function(value) {
+            if (!isValue(value)) return false;
+            if (isArray2(value)) return true;
+            if (isString(value)) return true;
+            if (isArguments(value)) return true;
+            return typeof value[iteratorSymbol] === "function";
+          };
+        }
+      });
+      var require_valid_iterable = __commonJS({
+        "node_modules/es6-iterator/valid-iterable.js"(exports, module2) {
+          var isIterable2 = require_is_iterable();
+          module2.exports = function(value) {
+            if (!isIterable2(value)) throw new TypeError(value + " is not iterable");
+            return value;
+          };
+        }
+      });
+      var require_get2 = __commonJS({
+        "node_modules/es6-iterator/get.js"(exports, module2) {
+          var isArguments = require_is_arguments2();
+          var isString = require_is_string();
+          var ArrayIterator = require_array2();
+          var StringIterator = require_string();
+          var iterable = require_valid_iterable();
+          var iteratorSymbol = require_es6_symbol().iterator;
+          module2.exports = function(obj) {
+            if (typeof iterable(obj)[iteratorSymbol] === "function") return obj[iteratorSymbol]();
+            if (isArguments(obj)) return new ArrayIterator(obj);
+            if (isString(obj)) return new StringIterator(obj);
+            return new ArrayIterator(obj);
+          };
+        }
+      });
+      var require_for_of = __commonJS({
+        "node_modules/es6-iterator/for-of.js"(exports, module2) {
+          var isArguments = require_is_arguments2();
+          var callable = require_valid_callable();
+          var isString = require_is_string();
+          var get = require_get2();
+          var isArray2 = Array.isArray;
+          var call = Function.prototype.call;
+          var some = Array.prototype.some;
+          module2.exports = function(iterable, cb2) {
+            var mode, thisArg = arguments[2], result, doBreak, broken, i2, length2, char, code;
+            if (isArray2(iterable) || isArguments(iterable)) mode = "array";
+            else if (isString(iterable)) mode = "string";
+            else iterable = get(iterable);
+            callable(cb2);
+            doBreak = function() {
+              broken = true;
+            };
+            if (mode === "array") {
+              some.call(iterable, function(value) {
+                call.call(cb2, thisArg, value, doBreak);
+                return broken;
+              });
+              return;
+            }
+            if (mode === "string") {
+              length2 = iterable.length;
+              for (i2 = 0; i2 < length2; ++i2) {
+                char = iterable[i2];
+                if (i2 + 1 < length2) {
+                  code = char.charCodeAt(0);
+                  if (code >= 55296 && code <= 56319) char += iterable[++i2];
+                }
+                call.call(cb2, thisArg, char, doBreak);
+                if (broken) break;
+              }
+              return;
+            }
+            result = iterable.next();
+            while (!result.done) {
+              call.call(cb2, thisArg, result.value, doBreak);
+              if (broken) return;
+              result = iterable.next();
+            }
+          };
+        }
+      });
+      var require_is_native_implemented = __commonJS({
+        "node_modules/es6-weak-map/is-native-implemented.js"(exports, module2) {
+          module2.exports = function() {
+            if (typeof WeakMap !== "function") return false;
+            return Object.prototype.toString.call(/* @__PURE__ */ new WeakMap()) === "[object WeakMap]";
+          }();
+        }
+      });
+      var require_polyfill5 = __commonJS({
+        "node_modules/es6-weak-map/polyfill.js"(exports, module2) {
+          var isValue = require_is_value();
+          var setPrototypeOf = require_set_prototype_of();
+          var object = require_valid_object();
+          var ensureValue = require_valid_value();
+          var randomUniq = require_random_uniq();
+          var d2 = require_d();
+          var getIterator = require_get2();
+          var forOf = require_for_of();
+          var toStringTagSymbol = require_es6_symbol().toStringTag;
+          var isNative = require_is_native_implemented();
+          var isArray2 = Array.isArray;
+          var defineProperty = Object.defineProperty;
+          var objHasOwnProperty = Object.prototype.hasOwnProperty;
+          var getPrototypeOf = Object.getPrototypeOf;
+          var WeakMapPoly;
+          module2.exports = WeakMapPoly = function() {
+            var iterable = arguments[0], self2;
+            if (!(this instanceof WeakMapPoly)) throw new TypeError("Constructor requires 'new'");
+            self2 = isNative && setPrototypeOf && WeakMap !== WeakMapPoly ? setPrototypeOf(/* @__PURE__ */ new WeakMap(), getPrototypeOf(this)) : this;
+            if (isValue(iterable)) {
+              if (!isArray2(iterable)) iterable = getIterator(iterable);
+            }
+            defineProperty(self2, "__weakMapData__", d2("c", "$weakMap$" + randomUniq()));
+            if (!iterable) return self2;
+            forOf(iterable, function(val) {
+              ensureValue(val);
+              self2.set(val[0], val[1]);
+            });
+            return self2;
+          };
+          if (isNative) {
+            if (setPrototypeOf) setPrototypeOf(WeakMapPoly, WeakMap);
+            WeakMapPoly.prototype = Object.create(WeakMap.prototype, { constructor: d2(WeakMapPoly) });
+          }
+          Object.defineProperties(WeakMapPoly.prototype, {
+            delete: d2(function(key) {
+              if (objHasOwnProperty.call(object(key), this.__weakMapData__)) {
+                delete key[this.__weakMapData__];
+                return true;
+              }
+              return false;
+            }),
+            get: d2(function(key) {
+              if (!objHasOwnProperty.call(object(key), this.__weakMapData__)) return void 0;
+              return key[this.__weakMapData__];
+            }),
+            has: d2(function(key) {
+              return objHasOwnProperty.call(object(key), this.__weakMapData__);
+            }),
+            set: d2(function(key, value) {
+              defineProperty(object(key), this.__weakMapData__, d2("c", value));
+              return this;
+            }),
+            toString: d2(function() {
+              return "[object WeakMap]";
+            })
+          });
+          defineProperty(WeakMapPoly.prototype, toStringTagSymbol, d2("c", "WeakMap"));
+        }
+      });
+      var require_es6_weak_map = __commonJS({
+        "node_modules/es6-weak-map/index.js"(exports, module2) {
+          module2.exports = require_is_implemented()() ? WeakMap : require_polyfill5();
+        }
+      });
+      var require_array_find_index = __commonJS({
+        "node_modules/array-find-index/index.js"(exports, module2) {
+          module2.exports = function(arr, predicate, ctx2) {
+            if (typeof Array.prototype.findIndex === "function") {
+              return arr.findIndex(predicate, ctx2);
+            }
+            if (typeof predicate !== "function") {
+              throw new TypeError("predicate must be a function");
+            }
+            var list = Object(arr);
+            var len2 = list.length;
+            if (len2 === 0) {
+              return -1;
+            }
+            for (var i2 = 0; i2 < len2; i2++) {
+              if (predicate.call(ctx2, list[i2], i2, list)) {
+                return i2;
+              }
+            }
+            return -1;
+          };
+        }
+      });
+      var require_regl_line2d = __commonJS({
+        "node_modules/regl-line2d/index.js"(exports, module2) {
+          var rgba3 = require_color_normalize();
+          var getBounds2 = require_array_bounds();
+          var extend2 = require_object_assign();
+          var pick = require_pick_by_alias();
+          var flatten2 = require_flatten_vertex_data();
+          var triangulate = require_earcut();
+          var normalize = require_array_normalize();
+          var { float32: float322, fract32 } = require_to_float32();
+          var WeakMap2 = require_es6_weak_map();
+          var parseRect = require_parse_rect();
+          var findIndex = require_array_find_index();
+          var rectVert = `
+precision highp float;
+
+attribute vec2 aCoord, bCoord, aCoordFract, bCoordFract;
+attribute vec4 color;
+attribute float lineEnd, lineTop;
+
+uniform vec2 scale, scaleFract, translate, translateFract;
+uniform float thickness, pixelRatio, id, depth;
+uniform vec4 viewport;
+
+varying vec4 fragColor;
+varying vec2 tangent;
+
+vec2 project(vec2 position, vec2 positionFract, vec2 scale, vec2 scaleFract, vec2 translate, vec2 translateFract) {
+	// the order is important
+	return position * scale + translate
+       + positionFract * scale + translateFract
+       + position * scaleFract
+       + positionFract * scaleFract;
 }
-class LocalWeekParser extends Parser {
-  constructor() {
-    super(...arguments);
-    __publicField(this, "priority", 100);
-    __publicField(this, "incompatibleTokens", [
-      "y",
-      "R",
-      "u",
-      "q",
-      "Q",
-      "M",
-      "L",
-      "I",
-      "d",
-      "D",
-      "i",
-      "t",
-      "T"
-    ]);
-  }
-  parse(dateString, token, match2) {
-    switch (token) {
-      case "w":
-        return parseNumericPattern(numericPatterns.week, dateString);
-      case "wo":
-        return match2.ordinalNumber(dateString, { unit: "week" });
-      default:
-        return parseNDigits(token.length, dateString);
-    }
-  }
-  validate(_date, value) {
-    return value >= 1 && value <= 53;
-  }
-  set(date, _flags, value, options) {
-    return startOfWeek(setWeek(date, value, options), options);
-  }
+
+void main() {
+	float lineStart = 1. - lineEnd;
+	float lineOffset = lineTop * 2. - 1.;
+
+	vec2 diff = (bCoord + bCoordFract - aCoord - aCoordFract);
+	tangent = normalize(diff * scale * viewport.zw);
+	vec2 normal = vec2(-tangent.y, tangent.x);
+
+	vec2 position = project(aCoord, aCoordFract, scale, scaleFract, translate, translateFract) * lineStart
+		+ project(bCoord, bCoordFract, scale, scaleFract, translate, translateFract) * lineEnd
+
+		+ thickness * normal * .5 * lineOffset / viewport.zw;
+
+	gl_Position = vec4(position * 2.0 - 1.0, depth, 1);
+
+	fragColor = color / 255.;
 }
-function setISOWeek(date, week, options) {
-  const _date = toDate(date, options == null ? void 0 : options.in);
-  const diff = getISOWeek(_date, options) - week;
-  _date.setDate(_date.getDate() - diff * 7);
-  return _date;
+`;
+          var rectFrag = `
+precision highp float;
+
+uniform float dashLength, pixelRatio, thickness, opacity, id;
+uniform sampler2D dashTexture;
+
+varying vec4 fragColor;
+varying vec2 tangent;
+
+void main() {
+	float alpha = 1.;
+
+	float t = fract(dot(tangent, gl_FragCoord.xy) / dashLength) * .5 + .25;
+	float dash = texture2D(dashTexture, vec2(t, .5)).r;
+
+	gl_FragColor = fragColor;
+	gl_FragColor.a *= alpha * opacity * dash;
 }
-class ISOWeekParser extends Parser {
-  constructor() {
-    super(...arguments);
-    __publicField(this, "priority", 100);
-    __publicField(this, "incompatibleTokens", [
-      "y",
-      "Y",
-      "u",
-      "q",
-      "Q",
-      "M",
-      "L",
-      "w",
-      "d",
-      "D",
-      "e",
-      "c",
-      "t",
-      "T"
-    ]);
-  }
-  parse(dateString, token, match2) {
-    switch (token) {
-      case "I":
-        return parseNumericPattern(numericPatterns.week, dateString);
-      case "Io":
-        return match2.ordinalNumber(dateString, { unit: "week" });
-      default:
-        return parseNDigits(token.length, dateString);
-    }
-  }
-  validate(_date, value) {
-    return value >= 1 && value <= 53;
-  }
-  set(date, _flags, value) {
-    return startOfISOWeek(setISOWeek(date, value));
-  }
-}
-const DAYS_IN_MONTH = [31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31];
-const DAYS_IN_MONTH_LEAP_YEAR = [
-  31,
-  29,
-  31,
-  30,
-  31,
-  30,
-  31,
-  31,
-  30,
-  31,
-  30,
-  31
-];
-class DateParser extends Parser {
-  constructor() {
-    super(...arguments);
-    __publicField(this, "priority", 90);
-    __publicField(this, "subPriority", 1);
-    __publicField(this, "incompatibleTokens", [
-      "Y",
-      "R",
-      "q",
-      "Q",
-      "w",
-      "I",
-      "D",
-      "i",
-      "e",
-      "c",
-      "t",
-      "T"
-    ]);
-  }
-  parse(dateString, token, match2) {
-    switch (token) {
-      case "d":
-        return parseNumericPattern(numericPatterns.date, dateString);
-      case "do":
-        return match2.ordinalNumber(dateString, { unit: "date" });
-      default:
-        return parseNDigits(token.length, dateString);
-    }
-  }
-  validate(date, value) {
-    const year = date.getFullYear();
-    const isLeapYear = isLeapYearIndex$1(year);
-    const month = date.getMonth();
-    if (isLeapYear) {
-      return value >= 1 && value <= DAYS_IN_MONTH_LEAP_YEAR[month];
-    } else {
-      return value >= 1 && value <= DAYS_IN_MONTH[month];
-    }
-  }
-  set(date, _flags, value) {
-    date.setDate(value);
-    date.setHours(0, 0, 0, 0);
-    return date;
-  }
+`;
+          var fillVert = `
+precision highp float;
+
+attribute vec2 position, positionFract;
+
+uniform vec4 color;
+uniform vec2 scale, scaleFract, translate, translateFract;
+uniform float pixelRatio, id;
+uniform vec4 viewport;
+uniform float opacity;
+
+varying vec4 fragColor;
+
+const float MAX_LINES = 256.;
+
+void main() {
+	float depth = (MAX_LINES - 4. - id) / (MAX_LINES);
+
+	vec2 position = position * scale + translate
+       + positionFract * scale + translateFract
+       + position * scaleFract
+       + positionFract * scaleFract;
+
+	gl_Position = vec4(position * 2.0 - 1.0, depth, 1);
+
+	fragColor = color / 255.;
+	fragColor.a *= opacity;
 }
-class DayOfYearParser extends Parser {
-  constructor() {
-    super(...arguments);
-    __publicField(this, "priority", 90);
-    __publicField(this, "subpriority", 1);
-    __publicField(this, "incompatibleTokens", [
-      "Y",
-      "R",
-      "q",
-      "Q",
-      "M",
-      "L",
-      "w",
-      "I",
-      "d",
-      "E",
-      "i",
-      "e",
-      "c",
-      "t",
-      "T"
-    ]);
-  }
-  parse(dateString, token, match2) {
-    switch (token) {
-      case "D":
-      case "DD":
-        return parseNumericPattern(numericPatterns.dayOfYear, dateString);
-      case "Do":
-        return match2.ordinalNumber(dateString, { unit: "date" });
-      default:
-        return parseNDigits(token.length, dateString);
-    }
-  }
-  validate(date, value) {
-    const year = date.getFullYear();
-    const isLeapYear = isLeapYearIndex$1(year);
-    if (isLeapYear) {
-      return value >= 1 && value <= 366;
-    } else {
-      return value >= 1 && value <= 365;
-    }
-  }
-  set(date, _flags, value) {
-    date.setMonth(0, value);
-    date.setHours(0, 0, 0, 0);
-    return date;
-  }
+`;
+          var fillFrag = `
+precision highp float;
+varying vec4 fragColor;
+
+void main() {
+	gl_FragColor = fragColor;
 }
-function setDay(date, day, options) {
-  var _a2, _b2, _c, _d;
-  const defaultOptions2 = getDefaultOptions$1();
-  const weekStartsOn = (options == null ? void 0 : options.weekStartsOn) ?? ((_b2 = (_a2 = options == null ? void 0 : options.locale) == null ? void 0 : _a2.options) == null ? void 0 : _b2.weekStartsOn) ?? defaultOptions2.weekStartsOn ?? ((_d = (_c = defaultOptions2.locale) == null ? void 0 : _c.options) == null ? void 0 : _d.weekStartsOn) ?? 0;
-  const date_ = toDate(date, options == null ? void 0 : options.in);
-  const currentDay = date_.getDay();
-  const remainder = day % 7;
-  const dayIndex = (remainder + 7) % 7;
-  const delta = 7 - weekStartsOn;
-  const diff = day < 0 || day > 6 ? day - (currentDay + delta) % 7 : (dayIndex + delta) % 7 - (currentDay + delta) % 7;
-  return addDays(date_, diff, options);
+`;
+          var milterVert = `
+precision highp float;
+
+attribute vec2 aCoord, bCoord, nextCoord, prevCoord;
+attribute vec4 aColor, bColor;
+attribute float lineEnd, lineTop;
+
+uniform vec2 scale, translate;
+uniform float thickness, pixelRatio, id, depth;
+uniform vec4 viewport;
+uniform float miterLimit, miterMode;
+
+varying vec4 fragColor;
+varying vec4 startCutoff, endCutoff;
+varying vec2 tangent;
+varying vec2 startCoord, endCoord;
+varying float enableStartMiter, enableEndMiter;
+
+const float REVERSE_THRESHOLD = -.875;
+const float MIN_DIFF = 1e-6;
+
+// TODO: possible optimizations: avoid overcalculating all for vertices and calc just one instead
+// TODO: precalculate dot products, normalize things beforehead etc.
+// TODO: refactor to rectangular algorithm
+
+float distToLine(vec2 p, vec2 a, vec2 b) {
+	vec2 diff = b - a;
+	vec2 perp = normalize(vec2(-diff.y, diff.x));
+	return dot(p - a, perp);
 }
-class DayParser extends Parser {
-  constructor() {
-    super(...arguments);
-    __publicField(this, "priority", 90);
-    __publicField(this, "incompatibleTokens", ["D", "i", "e", "c", "t", "T"]);
-  }
-  parse(dateString, token, match2) {
-    switch (token) {
-      case "E":
-      case "EE":
-      case "EEE":
-        return match2.day(dateString, {
-          width: "abbreviated",
-          context: "formatting"
-        }) || match2.day(dateString, { width: "short", context: "formatting" }) || match2.day(dateString, { width: "narrow", context: "formatting" });
-      case "EEEEE":
-        return match2.day(dateString, {
-          width: "narrow",
-          context: "formatting"
-        });
-      case "EEEEEE":
-        return match2.day(dateString, { width: "short", context: "formatting" }) || match2.day(dateString, { width: "narrow", context: "formatting" });
-      case "EEEE":
-      default:
-        return match2.day(dateString, { width: "wide", context: "formatting" }) || match2.day(dateString, {
-          width: "abbreviated",
-          context: "formatting"
-        }) || match2.day(dateString, { width: "short", context: "formatting" }) || match2.day(dateString, { width: "narrow", context: "formatting" });
-    }
-  }
-  validate(_date, value) {
-    return value >= 0 && value <= 6;
-  }
-  set(date, _flags, value, options) {
-    date = setDay(date, value, options);
-    date.setHours(0, 0, 0, 0);
-    return date;
-  }
+
+bool isNaN( float val ){
+  return ( val < 0.0 || 0.0 < val || val == 0.0 ) ? false : true;
 }
-class LocalDayParser extends Parser {
-  constructor() {
-    super(...arguments);
-    __publicField(this, "priority", 90);
-    __publicField(this, "incompatibleTokens", [
-      "y",
-      "R",
-      "u",
-      "q",
-      "Q",
-      "M",
-      "L",
-      "I",
-      "d",
-      "D",
-      "E",
-      "i",
-      "c",
-      "t",
-      "T"
-    ]);
-  }
-  parse(dateString, token, match2, options) {
-    const valueCallback = (value) => {
-      const wholeWeekDays = Math.floor((value - 1) / 7) * 7;
-      return (value + options.weekStartsOn + 6) % 7 + wholeWeekDays;
-    };
-    switch (token) {
-      case "e":
-      case "ee":
-        return mapValue(parseNDigits(token.length, dateString), valueCallback);
-      case "eo":
-        return mapValue(
-          match2.ordinalNumber(dateString, {
-            unit: "day"
-          }),
-          valueCallback
-        );
-      case "eee":
-        return match2.day(dateString, {
-          width: "abbreviated",
-          context: "formatting"
-        }) || match2.day(dateString, { width: "short", context: "formatting" }) || match2.day(dateString, { width: "narrow", context: "formatting" });
-      case "eeeee":
-        return match2.day(dateString, {
-          width: "narrow",
-          context: "formatting"
-        });
-      case "eeeeee":
-        return match2.day(dateString, { width: "short", context: "formatting" }) || match2.day(dateString, { width: "narrow", context: "formatting" });
-      case "eeee":
-      default:
-        return match2.day(dateString, { width: "wide", context: "formatting" }) || match2.day(dateString, {
-          width: "abbreviated",
-          context: "formatting"
-        }) || match2.day(dateString, { width: "short", context: "formatting" }) || match2.day(dateString, { width: "narrow", context: "formatting" });
-    }
-  }
-  validate(_date, value) {
-    return value >= 0 && value <= 6;
-  }
-  set(date, _flags, value, options) {
-    date = setDay(date, value, options);
-    date.setHours(0, 0, 0, 0);
-    return date;
-  }
+
+void main() {
+	vec2 aCoord = aCoord, bCoord = bCoord, prevCoord = prevCoord, nextCoord = nextCoord;
+
+  vec2 adjustedScale;
+  adjustedScale.x = (abs(scale.x) < MIN_DIFF) ? MIN_DIFF : scale.x;
+  adjustedScale.y = (abs(scale.y) < MIN_DIFF) ? MIN_DIFF : scale.y;
+
+  vec2 scaleRatio = adjustedScale * viewport.zw;
+	vec2 normalWidth = thickness / scaleRatio;
+
+	float lineStart = 1. - lineEnd;
+	float lineBot = 1. - lineTop;
+
+	fragColor = (lineStart * aColor + lineEnd * bColor) / 255.;
+
+	if (isNaN(aCoord.x) || isNaN(aCoord.y) || isNaN(bCoord.x) || isNaN(bCoord.y)) return;
+
+	if (aCoord == prevCoord) prevCoord = aCoord + normalize(bCoord - aCoord);
+	if (bCoord == nextCoord) nextCoord = bCoord - normalize(bCoord - aCoord);
+
+
+	vec2 prevDiff = aCoord - prevCoord;
+	vec2 currDiff = bCoord - aCoord;
+	vec2 nextDiff = nextCoord - bCoord;
+
+	vec2 prevTangent = normalize(prevDiff * scaleRatio);
+	vec2 currTangent = normalize(currDiff * scaleRatio);
+	vec2 nextTangent = normalize(nextDiff * scaleRatio);
+
+	vec2 prevNormal = vec2(-prevTangent.y, prevTangent.x);
+	vec2 currNormal = vec2(-currTangent.y, currTangent.x);
+	vec2 nextNormal = vec2(-nextTangent.y, nextTangent.x);
+
+	vec2 startJoinDirection = normalize(prevTangent - currTangent);
+	vec2 endJoinDirection = normalize(currTangent - nextTangent);
+
+	// collapsed/unidirectional segment cases
+	// FIXME: there should be more elegant solution
+	vec2 prevTanDiff = abs(prevTangent - currTangent);
+	vec2 nextTanDiff = abs(nextTangent - currTangent);
+	if (max(prevTanDiff.x, prevTanDiff.y) < MIN_DIFF) {
+		startJoinDirection = currNormal;
+	}
+	if (max(nextTanDiff.x, nextTanDiff.y) < MIN_DIFF) {
+		endJoinDirection = currNormal;
+	}
+	if (aCoord == bCoord) {
+		endJoinDirection = startJoinDirection;
+		currNormal = prevNormal;
+		currTangent = prevTangent;
+	}
+
+	tangent = currTangent;
+
+	//calculate join shifts relative to normals
+	float startJoinShift = dot(currNormal, startJoinDirection);
+	float endJoinShift = dot(currNormal, endJoinDirection);
+
+	float startMiterRatio = abs(1. / startJoinShift);
+	float endMiterRatio = abs(1. / endJoinShift);
+
+	vec2 startJoin = startJoinDirection * startMiterRatio;
+	vec2 endJoin = endJoinDirection * endMiterRatio;
+
+	vec2 startTopJoin, startBotJoin, endTopJoin, endBotJoin;
+	startTopJoin = sign(startJoinShift) * startJoin * .5;
+	startBotJoin = -startTopJoin;
+
+	endTopJoin = sign(endJoinShift) * endJoin * .5;
+	endBotJoin = -endTopJoin;
+
+	vec2 aTopCoord = aCoord + normalWidth * startTopJoin;
+	vec2 bTopCoord = bCoord + normalWidth * endTopJoin;
+	vec2 aBotCoord = aCoord + normalWidth * startBotJoin;
+	vec2 bBotCoord = bCoord + normalWidth * endBotJoin;
+
+	//miter anti-clipping
+	float baClipping = distToLine(bCoord, aCoord, aBotCoord) / dot(normalize(normalWidth * endBotJoin), normalize(normalWidth.yx * vec2(-startBotJoin.y, startBotJoin.x)));
+	float abClipping = distToLine(aCoord, bCoord, bTopCoord) / dot(normalize(normalWidth * startBotJoin), normalize(normalWidth.yx * vec2(-endBotJoin.y, endBotJoin.x)));
+
+	//prevent close to reverse direction switch
+	bool prevReverse = dot(currTangent, prevTangent) <= REVERSE_THRESHOLD && abs(dot(currTangent, prevNormal)) * min(length(prevDiff), length(currDiff)) <  length(normalWidth * currNormal);
+	bool nextReverse = dot(currTangent, nextTangent) <= REVERSE_THRESHOLD && abs(dot(currTangent, nextNormal)) * min(length(nextDiff), length(currDiff)) <  length(normalWidth * currNormal);
+
+	if (prevReverse) {
+		//make join rectangular
+		vec2 miterShift = normalWidth * startJoinDirection * miterLimit * .5;
+		float normalAdjust = 1. - min(miterLimit / startMiterRatio, 1.);
+		aBotCoord = aCoord + miterShift - normalAdjust * normalWidth * currNormal * .5;
+		aTopCoord = aCoord + miterShift + normalAdjust * normalWidth * currNormal * .5;
+	}
+	else if (!nextReverse && baClipping > 0. && baClipping < length(normalWidth * endBotJoin)) {
+		//handle miter clipping
+		bTopCoord -= normalWidth * endTopJoin;
+		bTopCoord += normalize(endTopJoin * normalWidth) * baClipping;
+	}
+
+	if (nextReverse) {
+		//make join rectangular
+		vec2 miterShift = normalWidth * endJoinDirection * miterLimit * .5;
+		float normalAdjust = 1. - min(miterLimit / endMiterRatio, 1.);
+		bBotCoord = bCoord + miterShift - normalAdjust * normalWidth * currNormal * .5;
+		bTopCoord = bCoord + miterShift + normalAdjust * normalWidth * currNormal * .5;
+	}
+	else if (!prevReverse && abClipping > 0. && abClipping < length(normalWidth * startBotJoin)) {
+		//handle miter clipping
+		aBotCoord -= normalWidth * startBotJoin;
+		aBotCoord += normalize(startBotJoin * normalWidth) * abClipping;
+	}
+
+	vec2 aTopPosition = (aTopCoord) * adjustedScale + translate;
+	vec2 aBotPosition = (aBotCoord) * adjustedScale + translate;
+
+	vec2 bTopPosition = (bTopCoord) * adjustedScale + translate;
+	vec2 bBotPosition = (bBotCoord) * adjustedScale + translate;
+
+	//position is normalized 0..1 coord on the screen
+	vec2 position = (aTopPosition * lineTop + aBotPosition * lineBot) * lineStart + (bTopPosition * lineTop + bBotPosition * lineBot) * lineEnd;
+
+	startCoord = aCoord * scaleRatio + translate * viewport.zw + viewport.xy;
+	endCoord = bCoord * scaleRatio + translate * viewport.zw + viewport.xy;
+
+	gl_Position = vec4(position  * 2.0 - 1.0, depth, 1);
+
+	enableStartMiter = step(dot(currTangent, prevTangent), .5);
+	enableEndMiter = step(dot(currTangent, nextTangent), .5);
+
+	//bevel miter cutoffs
+	if (miterMode == 1.) {
+		if (enableStartMiter == 1.) {
+			vec2 startMiterWidth = vec2(startJoinDirection) * thickness * miterLimit * .5;
+			startCutoff = vec4(aCoord, aCoord);
+			startCutoff.zw += vec2(-startJoinDirection.y, startJoinDirection.x) / scaleRatio;
+			startCutoff = startCutoff * scaleRatio.xyxy + translate.xyxy * viewport.zwzw;
+			startCutoff += viewport.xyxy;
+			startCutoff += startMiterWidth.xyxy;
+		}
+
+		if (enableEndMiter == 1.) {
+			vec2 endMiterWidth = vec2(endJoinDirection) * thickness * miterLimit * .5;
+			endCutoff = vec4(bCoord, bCoord);
+			endCutoff.zw += vec2(-endJoinDirection.y, endJoinDirection.x)  / scaleRatio;
+			endCutoff = endCutoff * scaleRatio.xyxy + translate.xyxy * viewport.zwzw;
+			endCutoff += viewport.xyxy;
+			endCutoff += endMiterWidth.xyxy;
+		}
+	}
+
+	//round miter cutoffs
+	else if (miterMode == 2.) {
+		if (enableStartMiter == 1.) {
+			vec2 startMiterWidth = vec2(startJoinDirection) * thickness * abs(dot(startJoinDirection, currNormal)) * .5;
+			startCutoff = vec4(aCoord, aCoord);
+			startCutoff.zw += vec2(-startJoinDirection.y, startJoinDirection.x) / scaleRatio;
+			startCutoff = startCutoff * scaleRatio.xyxy + translate.xyxy * viewport.zwzw;
+			startCutoff += viewport.xyxy;
+			startCutoff += startMiterWidth.xyxy;
+		}
+
+		if (enableEndMiter == 1.) {
+			vec2 endMiterWidth = vec2(endJoinDirection) * thickness * abs(dot(endJoinDirection, currNormal)) * .5;
+			endCutoff = vec4(bCoord, bCoord);
+			endCutoff.zw += vec2(-endJoinDirection.y, endJoinDirection.x)  / scaleRatio;
+			endCutoff = endCutoff * scaleRatio.xyxy + translate.xyxy * viewport.zwzw;
+			endCutoff += viewport.xyxy;
+			endCutoff += endMiterWidth.xyxy;
+		}
+	}
 }
-class StandAloneLocalDayParser extends Parser {
-  constructor() {
-    super(...arguments);
-    __publicField(this, "priority", 90);
-    __publicField(this, "incompatibleTokens", [
-      "y",
-      "R",
-      "u",
-      "q",
-      "Q",
-      "M",
-      "L",
-      "I",
-      "d",
-      "D",
-      "E",
-      "i",
-      "e",
-      "t",
-      "T"
-    ]);
-  }
-  parse(dateString, token, match2, options) {
-    const valueCallback = (value) => {
-      const wholeWeekDays = Math.floor((value - 1) / 7) * 7;
-      return (value + options.weekStartsOn + 6) % 7 + wholeWeekDays;
-    };
-    switch (token) {
-      case "c":
-      case "cc":
-        return mapValue(parseNDigits(token.length, dateString), valueCallback);
-      case "co":
-        return mapValue(
-          match2.ordinalNumber(dateString, {
-            unit: "day"
-          }),
-          valueCallback
-        );
-      case "ccc":
-        return match2.day(dateString, {
-          width: "abbreviated",
-          context: "standalone"
-        }) || match2.day(dateString, { width: "short", context: "standalone" }) || match2.day(dateString, { width: "narrow", context: "standalone" });
-      case "ccccc":
-        return match2.day(dateString, {
-          width: "narrow",
-          context: "standalone"
-        });
-      case "cccccc":
-        return match2.day(dateString, { width: "short", context: "standalone" }) || match2.day(dateString, { width: "narrow", context: "standalone" });
-      case "cccc":
-      default:
-        return match2.day(dateString, { width: "wide", context: "standalone" }) || match2.day(dateString, {
-          width: "abbreviated",
-          context: "standalone"
-        }) || match2.day(dateString, { width: "short", context: "standalone" }) || match2.day(dateString, { width: "narrow", context: "standalone" });
-    }
-  }
-  validate(_date, value) {
-    return value >= 0 && value <= 6;
-  }
-  set(date, _flags, value, options) {
-    date = setDay(date, value, options);
-    date.setHours(0, 0, 0, 0);
-    return date;
-  }
+`;
+          var milterFrag = `
+precision highp float;
+
+uniform float dashLength, pixelRatio, thickness, opacity, id, miterMode;
+uniform sampler2D dashTexture;
+
+varying vec4 fragColor;
+varying vec2 tangent;
+varying vec4 startCutoff, endCutoff;
+varying vec2 startCoord, endCoord;
+varying float enableStartMiter, enableEndMiter;
+
+float distToLine(vec2 p, vec2 a, vec2 b) {
+	vec2 diff = b - a;
+	vec2 perp = normalize(vec2(-diff.y, diff.x));
+	return dot(p - a, perp);
 }
-function setISODay(date, day, options) {
-  const date_ = toDate(date, options == null ? void 0 : options.in);
-  const currentDay = getISODay(date_, options);
-  const diff = day - currentDay;
-  return addDays(date_, diff, options);
+
+void main() {
+	float alpha = 1., distToStart, distToEnd;
+	float cutoff = thickness * .5;
+
+	//bevel miter
+	if (miterMode == 1.) {
+		if (enableStartMiter == 1.) {
+			distToStart = distToLine(gl_FragCoord.xy, startCutoff.xy, startCutoff.zw);
+			if (distToStart < -1.) {
+				discard;
+				return;
+			}
+			alpha *= min(max(distToStart + 1., 0.), 1.);
+		}
+
+		if (enableEndMiter == 1.) {
+			distToEnd = distToLine(gl_FragCoord.xy, endCutoff.xy, endCutoff.zw);
+			if (distToEnd < -1.) {
+				discard;
+				return;
+			}
+			alpha *= min(max(distToEnd + 1., 0.), 1.);
+		}
+	}
+
+	// round miter
+	else if (miterMode == 2.) {
+		if (enableStartMiter == 1.) {
+			distToStart = distToLine(gl_FragCoord.xy, startCutoff.xy, startCutoff.zw);
+			if (distToStart < 0.) {
+				float radius = length(gl_FragCoord.xy - startCoord);
+
+				if(radius > cutoff + .5) {
+					discard;
+					return;
+				}
+
+				alpha -= smoothstep(cutoff - .5, cutoff + .5, radius);
+			}
+		}
+
+		if (enableEndMiter == 1.) {
+			distToEnd = distToLine(gl_FragCoord.xy, endCutoff.xy, endCutoff.zw);
+			if (distToEnd < 0.) {
+				float radius = length(gl_FragCoord.xy - endCoord);
+
+				if(radius > cutoff + .5) {
+					discard;
+					return;
+				}
+
+				alpha -= smoothstep(cutoff - .5, cutoff + .5, radius);
+			}
+		}
+	}
+
+	float t = fract(dot(tangent, gl_FragCoord.xy) / dashLength) * .5 + .25;
+	float dash = texture2D(dashTexture, vec2(t, .5)).r;
+
+	gl_FragColor = fragColor;
+	gl_FragColor.a *= alpha * opacity * dash;
 }
-class ISODayParser extends Parser {
-  constructor() {
-    super(...arguments);
-    __publicField(this, "priority", 90);
-    __publicField(this, "incompatibleTokens", [
-      "y",
-      "Y",
-      "u",
-      "q",
-      "Q",
-      "M",
-      "L",
-      "w",
-      "d",
-      "D",
-      "E",
-      "e",
-      "c",
-      "t",
-      "T"
-    ]);
-  }
-  parse(dateString, token, match2) {
-    const valueCallback = (value) => {
-      if (value === 0) {
-        return 7;
+`;
+          module2.exports = Line2D;
+          function Line2D(regl, options) {
+            if (!(this instanceof Line2D)) return new Line2D(regl, options);
+            if (typeof regl === "function") {
+              if (!options) options = {};
+              options.regl = regl;
+            } else {
+              options = regl;
+            }
+            if (options.length) options.positions = options;
+            regl = options.regl;
+            if (!regl.hasExtension("ANGLE_instanced_arrays")) {
+              throw Error("regl-error2d: `ANGLE_instanced_arrays` extension should be enabled");
+            }
+            this.gl = regl._gl;
+            this.regl = regl;
+            this.passes = [];
+            this.shaders = Line2D.shaders.has(regl) ? Line2D.shaders.get(regl) : Line2D.shaders.set(regl, Line2D.createShaders(regl)).get(regl);
+            this.update(options);
+          }
+          Line2D.dashMult = 2;
+          Line2D.maxPatternLength = 256;
+          Line2D.precisionThreshold = 3e6;
+          Line2D.maxPoints = 1e4;
+          Line2D.maxLines = 2048;
+          Line2D.shaders = new WeakMap2();
+          Line2D.createShaders = function(regl) {
+            let offsetBuffer = regl.buffer({
+              usage: "static",
+              type: "float",
+              data: [0, 1, 0, 0, 1, 1, 1, 0]
+            });
+            let shaderOptions = {
+              primitive: "triangle strip",
+              instances: regl.prop("count"),
+              count: 4,
+              offset: 0,
+              uniforms: {
+                miterMode: (ctx2, prop) => prop.join === "round" ? 2 : 1,
+                miterLimit: regl.prop("miterLimit"),
+                scale: regl.prop("scale"),
+                scaleFract: regl.prop("scaleFract"),
+                translateFract: regl.prop("translateFract"),
+                translate: regl.prop("translate"),
+                thickness: regl.prop("thickness"),
+                dashTexture: regl.prop("dashTexture"),
+                opacity: regl.prop("opacity"),
+                pixelRatio: regl.context("pixelRatio"),
+                id: regl.prop("id"),
+                dashLength: regl.prop("dashLength"),
+                viewport: (c2, p2) => [p2.viewport.x, p2.viewport.y, c2.viewportWidth, c2.viewportHeight],
+                depth: regl.prop("depth")
+              },
+              blend: {
+                enable: true,
+                color: [0, 0, 0, 0],
+                equation: {
+                  rgb: "add",
+                  alpha: "add"
+                },
+                func: {
+                  srcRGB: "src alpha",
+                  dstRGB: "one minus src alpha",
+                  srcAlpha: "one minus dst alpha",
+                  dstAlpha: "one"
+                }
+              },
+              depth: {
+                enable: (c2, p2) => {
+                  return !p2.overlay;
+                }
+              },
+              stencil: { enable: false },
+              scissor: {
+                enable: true,
+                box: regl.prop("viewport")
+              },
+              viewport: regl.prop("viewport")
+            };
+            let drawRectLine = regl(extend2({
+              vert: rectVert,
+              frag: rectFrag,
+              attributes: {
+                // if point is at the end of segment
+                lineEnd: {
+                  buffer: offsetBuffer,
+                  divisor: 0,
+                  stride: 8,
+                  offset: 0
+                },
+                // if point is at the top of segment
+                lineTop: {
+                  buffer: offsetBuffer,
+                  divisor: 0,
+                  stride: 8,
+                  offset: 4
+                },
+                // beginning of line coordinate
+                aCoord: {
+                  buffer: regl.prop("positionBuffer"),
+                  stride: 8,
+                  offset: 8,
+                  divisor: 1
+                },
+                // end of line coordinate
+                bCoord: {
+                  buffer: regl.prop("positionBuffer"),
+                  stride: 8,
+                  offset: 16,
+                  divisor: 1
+                },
+                aCoordFract: {
+                  buffer: regl.prop("positionFractBuffer"),
+                  stride: 8,
+                  offset: 8,
+                  divisor: 1
+                },
+                bCoordFract: {
+                  buffer: regl.prop("positionFractBuffer"),
+                  stride: 8,
+                  offset: 16,
+                  divisor: 1
+                },
+                color: {
+                  buffer: regl.prop("colorBuffer"),
+                  stride: 4,
+                  offset: 0,
+                  divisor: 1
+                }
+              }
+            }, shaderOptions));
+            let drawMiterLine;
+            try {
+              drawMiterLine = regl(extend2({
+                // culling removes polygon creasing
+                cull: {
+                  enable: true,
+                  face: "back"
+                },
+                vert: milterVert,
+                frag: milterFrag,
+                attributes: {
+                  // is line end
+                  lineEnd: {
+                    buffer: offsetBuffer,
+                    divisor: 0,
+                    stride: 8,
+                    offset: 0
+                  },
+                  // is line top
+                  lineTop: {
+                    buffer: offsetBuffer,
+                    divisor: 0,
+                    stride: 8,
+                    offset: 4
+                  },
+                  // left color
+                  aColor: {
+                    buffer: regl.prop("colorBuffer"),
+                    stride: 4,
+                    offset: 0,
+                    divisor: 1
+                  },
+                  // right color
+                  bColor: {
+                    buffer: regl.prop("colorBuffer"),
+                    stride: 4,
+                    offset: 4,
+                    divisor: 1
+                  },
+                  prevCoord: {
+                    buffer: regl.prop("positionBuffer"),
+                    stride: 8,
+                    offset: 0,
+                    divisor: 1
+                  },
+                  aCoord: {
+                    buffer: regl.prop("positionBuffer"),
+                    stride: 8,
+                    offset: 8,
+                    divisor: 1
+                  },
+                  bCoord: {
+                    buffer: regl.prop("positionBuffer"),
+                    stride: 8,
+                    offset: 16,
+                    divisor: 1
+                  },
+                  nextCoord: {
+                    buffer: regl.prop("positionBuffer"),
+                    stride: 8,
+                    offset: 24,
+                    divisor: 1
+                  }
+                }
+              }, shaderOptions));
+            } catch (e2) {
+              drawMiterLine = drawRectLine;
+            }
+            let drawFill = regl({
+              primitive: "triangle",
+              elements: (ctx2, prop) => prop.triangles,
+              offset: 0,
+              vert: fillVert,
+              frag: fillFrag,
+              uniforms: {
+                scale: regl.prop("scale"),
+                color: regl.prop("fill"),
+                scaleFract: regl.prop("scaleFract"),
+                translateFract: regl.prop("translateFract"),
+                translate: regl.prop("translate"),
+                opacity: regl.prop("opacity"),
+                pixelRatio: regl.context("pixelRatio"),
+                id: regl.prop("id"),
+                viewport: (ctx2, prop) => [prop.viewport.x, prop.viewport.y, ctx2.viewportWidth, ctx2.viewportHeight]
+              },
+              attributes: {
+                position: {
+                  buffer: regl.prop("positionBuffer"),
+                  stride: 8,
+                  offset: 8
+                },
+                positionFract: {
+                  buffer: regl.prop("positionFractBuffer"),
+                  stride: 8,
+                  offset: 8
+                }
+              },
+              blend: shaderOptions.blend,
+              depth: { enable: false },
+              scissor: shaderOptions.scissor,
+              stencil: shaderOptions.stencil,
+              viewport: shaderOptions.viewport
+            });
+            return {
+              fill: drawFill,
+              rect: drawRectLine,
+              miter: drawMiterLine
+            };
+          };
+          Line2D.defaults = {
+            dashes: null,
+            join: "miter",
+            miterLimit: 1,
+            thickness: 10,
+            cap: "square",
+            color: "black",
+            opacity: 1,
+            overlay: false,
+            viewport: null,
+            range: null,
+            close: false,
+            fill: null
+          };
+          Line2D.prototype.render = function(...args) {
+            if (args.length) {
+              this.update(...args);
+            }
+            this.draw();
+          };
+          Line2D.prototype.draw = function(...args) {
+            (args.length ? args : this.passes).forEach((s2, i2) => {
+              if (s2 && Array.isArray(s2)) return this.draw(...s2);
+              if (typeof s2 === "number") s2 = this.passes[s2];
+              if (!(s2 && s2.count > 1 && s2.opacity)) return;
+              this.regl._refresh();
+              if (s2.fill && s2.triangles && s2.triangles.length > 2) {
+                this.shaders.fill(s2);
+              }
+              if (!s2.thickness) return;
+              if (s2.scale[0] * s2.viewport.width > Line2D.precisionThreshold || s2.scale[1] * s2.viewport.height > Line2D.precisionThreshold) {
+                this.shaders.rect(s2);
+              } else if (s2.join === "rect" || !s2.join && (s2.thickness <= 2 || s2.count >= Line2D.maxPoints)) {
+                this.shaders.rect(s2);
+              } else {
+                this.shaders.miter(s2);
+              }
+            });
+            return this;
+          };
+          Line2D.prototype.update = function(options) {
+            if (!options) return;
+            if (options.length != null) {
+              if (typeof options[0] === "number") options = [{ positions: options }];
+            } else if (!Array.isArray(options)) options = [options];
+            let { regl, gl: gl2 } = this;
+            options.forEach((o2, i2) => {
+              let state = this.passes[i2];
+              if (o2 === void 0) return;
+              if (o2 === null) {
+                this.passes[i2] = null;
+                return;
+              }
+              if (typeof o2[0] === "number") o2 = { positions: o2 };
+              o2 = pick(o2, {
+                positions: "positions points data coords",
+                thickness: "thickness lineWidth lineWidths line-width linewidth width stroke-width strokewidth strokeWidth",
+                join: "lineJoin linejoin join type mode",
+                miterLimit: "miterlimit miterLimit",
+                dashes: "dash dashes dasharray dash-array dashArray",
+                color: "color colour stroke colors colours stroke-color strokeColor",
+                fill: "fill fill-color fillColor",
+                opacity: "alpha opacity",
+                overlay: "overlay crease overlap intersect",
+                close: "closed close closed-path closePath",
+                range: "range dataBox",
+                viewport: "viewport viewBox",
+                hole: "holes hole hollow",
+                splitNull: "splitNull"
+              });
+              if (!state) {
+                this.passes[i2] = state = {
+                  id: i2,
+                  scale: null,
+                  scaleFract: null,
+                  translate: null,
+                  translateFract: null,
+                  count: 0,
+                  hole: [],
+                  depth: 0,
+                  dashLength: 1,
+                  dashTexture: regl.texture({
+                    channels: 1,
+                    data: new Uint8Array([255]),
+                    width: 1,
+                    height: 1,
+                    mag: "linear",
+                    min: "linear"
+                  }),
+                  colorBuffer: regl.buffer({
+                    usage: "dynamic",
+                    type: "uint8",
+                    data: new Uint8Array()
+                  }),
+                  positionBuffer: regl.buffer({
+                    usage: "dynamic",
+                    type: "float",
+                    data: new Uint8Array()
+                  }),
+                  positionFractBuffer: regl.buffer({
+                    usage: "dynamic",
+                    type: "float",
+                    data: new Uint8Array()
+                  })
+                };
+                o2 = extend2({}, Line2D.defaults, o2);
+              }
+              if (o2.thickness != null) state.thickness = parseFloat(o2.thickness);
+              if (o2.opacity != null) state.opacity = parseFloat(o2.opacity);
+              if (o2.miterLimit != null) state.miterLimit = parseFloat(o2.miterLimit);
+              if (o2.overlay != null) {
+                state.overlay = !!o2.overlay;
+                if (i2 < Line2D.maxLines) {
+                  state.depth = 2 * (Line2D.maxLines - 1 - i2 % Line2D.maxLines) / Line2D.maxLines - 1;
+                }
+              }
+              if (o2.join != null) state.join = o2.join;
+              if (o2.hole != null) state.hole = o2.hole;
+              if (o2.fill != null) state.fill = !o2.fill ? null : rgba3(o2.fill, "uint8");
+              if (o2.viewport != null) state.viewport = parseRect(o2.viewport);
+              if (!state.viewport) {
+                state.viewport = parseRect([
+                  gl2.drawingBufferWidth,
+                  gl2.drawingBufferHeight
+                ]);
+              }
+              if (o2.close != null) state.close = o2.close;
+              if (o2.positions === null) o2.positions = [];
+              if (o2.positions) {
+                let positions, count2;
+                if (o2.positions.x && o2.positions.y) {
+                  let xPos = o2.positions.x;
+                  let yPos = o2.positions.y;
+                  count2 = state.count = Math.max(
+                    xPos.length,
+                    yPos.length
+                  );
+                  positions = new Float64Array(count2 * 2);
+                  for (let i22 = 0; i22 < count2; i22++) {
+                    positions[i22 * 2] = xPos[i22];
+                    positions[i22 * 2 + 1] = yPos[i22];
+                  }
+                } else {
+                  positions = flatten2(o2.positions, "float64");
+                  count2 = state.count = Math.floor(positions.length / 2);
+                }
+                let bounds = state.bounds = getBounds2(positions, 2);
+                if (state.fill) {
+                  let pos = [];
+                  let ids = {};
+                  let lastId = 0;
+                  for (let i22 = 0, ptr = 0, l2 = state.count; i22 < l2; i22++) {
+                    let x2 = positions[i22 * 2];
+                    let y2 = positions[i22 * 2 + 1];
+                    if (isNaN(x2) || isNaN(y2) || x2 == null || y2 == null) {
+                      x2 = positions[lastId * 2];
+                      y2 = positions[lastId * 2 + 1];
+                      ids[i22] = lastId;
+                    } else {
+                      lastId = i22;
+                    }
+                    pos[ptr++] = x2;
+                    pos[ptr++] = y2;
+                  }
+                  if (o2.splitNull) {
+                    if (!(state.count - 1 in ids)) ids[state.count] = state.count - 1;
+                    let splits = Object.keys(ids).map(Number).sort((a2, b2) => a2 - b2);
+                    let split_triangles = [];
+                    let base = 0;
+                    let hole_base = state.hole != null ? state.hole[0] : null;
+                    if (hole_base != null) {
+                      let last_id = findIndex(splits, (e2) => e2 >= hole_base);
+                      splits = splits.slice(0, last_id);
+                      splits.push(hole_base);
+                    }
+                    for (let i22 = 0; i22 < splits.length; i22++) {
+                      let seg_pos = pos.slice(base * 2, splits[i22] * 2).concat(
+                        hole_base ? pos.slice(hole_base * 2) : []
+                      );
+                      let hole = (state.hole || []).map((e2) => e2 - hole_base + (splits[i22] - base));
+                      let triangles = triangulate(seg_pos, hole);
+                      triangles = triangles.map(
+                        (e2) => e2 + base + (e2 + base < splits[i22] ? 0 : hole_base - splits[i22])
+                      );
+                      split_triangles.push(...triangles);
+                      base = splits[i22] + 1;
+                    }
+                    for (let i22 = 0, l2 = split_triangles.length; i22 < l2; i22++) {
+                      if (ids[split_triangles[i22]] != null) split_triangles[i22] = ids[split_triangles[i22]];
+                    }
+                    state.triangles = split_triangles;
+                  } else {
+                    let triangles = triangulate(pos, state.hole || []);
+                    for (let i22 = 0, l2 = triangles.length; i22 < l2; i22++) {
+                      if (ids[triangles[i22]] != null) triangles[i22] = ids[triangles[i22]];
+                    }
+                    state.triangles = triangles;
+                  }
+                }
+                let npos = new Float64Array(positions);
+                normalize(npos, 2, bounds);
+                let positionData = new Float64Array(count2 * 2 + 6);
+                if (state.close) {
+                  if (positions[0] === positions[count2 * 2 - 2] && positions[1] === positions[count2 * 2 - 1]) {
+                    positionData[0] = npos[count2 * 2 - 4];
+                    positionData[1] = npos[count2 * 2 - 3];
+                  } else {
+                    positionData[0] = npos[count2 * 2 - 2];
+                    positionData[1] = npos[count2 * 2 - 1];
+                  }
+                } else {
+                  positionData[0] = npos[0];
+                  positionData[1] = npos[1];
+                }
+                positionData.set(npos, 2);
+                if (state.close) {
+                  if (positions[0] === positions[count2 * 2 - 2] && positions[1] === positions[count2 * 2 - 1]) {
+                    positionData[count2 * 2 + 2] = npos[2];
+                    positionData[count2 * 2 + 3] = npos[3];
+                    state.count -= 1;
+                  } else {
+                    positionData[count2 * 2 + 2] = npos[0];
+                    positionData[count2 * 2 + 3] = npos[1];
+                    positionData[count2 * 2 + 4] = npos[2];
+                    positionData[count2 * 2 + 5] = npos[3];
+                  }
+                } else {
+                  positionData[count2 * 2 + 2] = npos[count2 * 2 - 2];
+                  positionData[count2 * 2 + 3] = npos[count2 * 2 - 1];
+                  positionData[count2 * 2 + 4] = npos[count2 * 2 - 2];
+                  positionData[count2 * 2 + 5] = npos[count2 * 2 - 1];
+                }
+                var float_data = float322(positionData);
+                state.positionBuffer(float_data);
+                var frac_data = fract32(positionData, float_data);
+                state.positionFractBuffer(frac_data);
+              }
+              if (o2.range) {
+                state.range = o2.range;
+              } else if (!state.range) {
+                state.range = state.bounds;
+              }
+              if ((o2.range || o2.positions) && state.count) {
+                let bounds = state.bounds;
+                let boundsW = bounds[2] - bounds[0], boundsH = bounds[3] - bounds[1];
+                let rangeW = state.range[2] - state.range[0], rangeH = state.range[3] - state.range[1];
+                state.scale = [
+                  boundsW / rangeW,
+                  boundsH / rangeH
+                ];
+                state.translate = [
+                  -state.range[0] / rangeW + bounds[0] / rangeW || 0,
+                  -state.range[1] / rangeH + bounds[1] / rangeH || 0
+                ];
+                state.scaleFract = fract32(state.scale);
+                state.translateFract = fract32(state.translate);
+              }
+              if (o2.dashes) {
+                let dashLength = 0, dashData;
+                if (!o2.dashes || o2.dashes.length < 2) {
+                  dashLength = 1;
+                  dashData = new Uint8Array([255, 255, 255, 255, 255, 255, 255, 255]);
+                } else {
+                  dashLength = 0;
+                  for (let i22 = 0; i22 < o2.dashes.length; ++i22) {
+                    dashLength += o2.dashes[i22];
+                  }
+                  dashData = new Uint8Array(dashLength * Line2D.dashMult);
+                  let ptr = 0;
+                  let fillColor = 255;
+                  for (let k2 = 0; k2 < 2; k2++) {
+                    for (let i22 = 0; i22 < o2.dashes.length; ++i22) {
+                      for (let j2 = 0, l2 = o2.dashes[i22] * Line2D.dashMult * 0.5; j2 < l2; ++j2) {
+                        dashData[ptr++] = fillColor;
+                      }
+                      fillColor ^= 255;
+                    }
+                  }
+                }
+                state.dashLength = dashLength;
+                state.dashTexture({
+                  channels: 1,
+                  data: dashData,
+                  width: dashData.length,
+                  height: 1,
+                  mag: "linear",
+                  min: "linear"
+                }, 0, 0);
+              }
+              if (o2.color) {
+                let count2 = state.count;
+                let colors = o2.color;
+                if (!colors) colors = "transparent";
+                let colorData = new Uint8Array(count2 * 4 + 4);
+                if (!Array.isArray(colors) || typeof colors[0] === "number") {
+                  let c2 = rgba3(colors, "uint8");
+                  for (let i22 = 0; i22 < count2 + 1; i22++) {
+                    colorData.set(c2, i22 * 4);
+                  }
+                } else {
+                  for (let i22 = 0; i22 < count2; i22++) {
+                    let c2 = rgba3(colors[i22], "uint8");
+                    colorData.set(c2, i22 * 4);
+                  }
+                  colorData.set(rgba3(colors[0], "uint8"), count2 * 4);
+                }
+                state.colorBuffer({
+                  usage: "dynamic",
+                  type: "uint8",
+                  data: colorData
+                });
+              }
+            });
+            if (options.length < this.passes.length) {
+              for (let i2 = options.length; i2 < this.passes.length; i2++) {
+                let pass = this.passes[i2];
+                if (!pass) continue;
+                pass.colorBuffer.destroy();
+                pass.positionBuffer.destroy();
+                pass.dashTexture.destroy();
+              }
+              this.passes.length = options.length;
+            }
+            let passes = [];
+            for (let i2 = 0; i2 < this.passes.length; i2++) {
+              if (this.passes[i2] !== null) passes.push(this.passes[i2]);
+            }
+            this.passes = passes;
+            return this;
+          };
+          Line2D.prototype.destroy = function() {
+            this.passes.forEach((pass) => {
+              pass.colorBuffer.destroy();
+              pass.positionBuffer.destroy();
+              pass.dashTexture.destroy();
+            });
+            this.passes.length = 0;
+            return this;
+          };
+        }
+      });
+      var require_regl_error2d = __commonJS({
+        "node_modules/regl-error2d/index.js"(exports, module2) {
+          var getBounds2 = require_array_bounds();
+          var rgba3 = require_color_normalize();
+          var updateDiff = require_update_diff();
+          var pick = require_pick_by_alias();
+          var extend2 = require_object_assign();
+          var flatten2 = require_flatten_vertex_data();
+          var { float32: float322, fract32 } = require_to_float32();
+          module2.exports = Error2D;
+          var WEIGHTS = [
+            //direction, lineWidth shift, capSize shift
+            // x-error bar
+            [1, 0, 0, 1, 0, 0],
+            [1, 0, 0, -1, 0, 0],
+            [-1, 0, 0, -1, 0, 0],
+            [-1, 0, 0, -1, 0, 0],
+            [-1, 0, 0, 1, 0, 0],
+            [1, 0, 0, 1, 0, 0],
+            // x-error right cap
+            [1, 0, -1, 0, 0, 1],
+            [1, 0, -1, 0, 0, -1],
+            [1, 0, 1, 0, 0, -1],
+            [1, 0, 1, 0, 0, -1],
+            [1, 0, 1, 0, 0, 1],
+            [1, 0, -1, 0, 0, 1],
+            // x-error left cap
+            [-1, 0, -1, 0, 0, 1],
+            [-1, 0, -1, 0, 0, -1],
+            [-1, 0, 1, 0, 0, -1],
+            [-1, 0, 1, 0, 0, -1],
+            [-1, 0, 1, 0, 0, 1],
+            [-1, 0, -1, 0, 0, 1],
+            // y-error bar
+            [0, 1, 1, 0, 0, 0],
+            [0, 1, -1, 0, 0, 0],
+            [0, -1, -1, 0, 0, 0],
+            [0, -1, -1, 0, 0, 0],
+            [0, 1, 1, 0, 0, 0],
+            [0, -1, 1, 0, 0, 0],
+            // y-error top cap
+            [0, 1, 0, -1, 1, 0],
+            [0, 1, 0, -1, -1, 0],
+            [0, 1, 0, 1, -1, 0],
+            [0, 1, 0, 1, 1, 0],
+            [0, 1, 0, -1, 1, 0],
+            [0, 1, 0, 1, -1, 0],
+            // y-error bottom cap
+            [0, -1, 0, -1, 1, 0],
+            [0, -1, 0, -1, -1, 0],
+            [0, -1, 0, 1, -1, 0],
+            [0, -1, 0, 1, 1, 0],
+            [0, -1, 0, -1, 1, 0],
+            [0, -1, 0, 1, -1, 0]
+          ];
+          function Error2D(regl, options) {
+            if (typeof regl === "function") {
+              if (!options) options = {};
+              options.regl = regl;
+            } else {
+              options = regl;
+            }
+            if (options.length) options.positions = options;
+            regl = options.regl;
+            if (!regl.hasExtension("ANGLE_instanced_arrays")) {
+              throw Error("regl-error2d: `ANGLE_instanced_arrays` extension should be enabled");
+            }
+            let gl2 = regl._gl, drawErrors, positionBuffer, positionFractBuffer, colorBuffer, errorBuffer, meshBuffer, defaults = {
+              color: "black",
+              capSize: 5,
+              lineWidth: 1,
+              opacity: 1,
+              viewport: null,
+              range: null,
+              offset: 0,
+              count: 0,
+              bounds: null,
+              positions: [],
+              errors: []
+            }, groups = [];
+            colorBuffer = regl.buffer({
+              usage: "dynamic",
+              type: "uint8",
+              data: new Uint8Array(0)
+            });
+            positionBuffer = regl.buffer({
+              usage: "dynamic",
+              type: "float",
+              data: new Uint8Array(0)
+            });
+            positionFractBuffer = regl.buffer({
+              usage: "dynamic",
+              type: "float",
+              data: new Uint8Array(0)
+            });
+            errorBuffer = regl.buffer({
+              usage: "dynamic",
+              type: "float",
+              data: new Uint8Array(0)
+            });
+            meshBuffer = regl.buffer({
+              usage: "static",
+              type: "float",
+              data: WEIGHTS
+            });
+            update(options);
+            drawErrors = regl({
+              vert: `
+		precision highp float;
+
+		attribute vec2 position, positionFract;
+		attribute vec4 error;
+		attribute vec4 color;
+
+		attribute vec2 direction, lineOffset, capOffset;
+
+		uniform vec4 viewport;
+		uniform float lineWidth, capSize;
+		uniform vec2 scale, scaleFract, translate, translateFract;
+
+		varying vec4 fragColor;
+
+		void main() {
+			fragColor = color / 255.;
+
+			vec2 pixelOffset = lineWidth * lineOffset + (capSize + lineWidth) * capOffset;
+
+			vec2 dxy = -step(.5, direction.xy) * error.xz + step(direction.xy, vec2(-.5)) * error.yw;
+
+			vec2 position = position + dxy;
+
+			vec2 pos = (position + translate) * scale
+				+ (positionFract + translateFract) * scale
+				+ (position + translate) * scaleFract
+				+ (positionFract + translateFract) * scaleFract;
+
+			pos += pixelOffset / viewport.zw;
+
+			gl_Position = vec4(pos * 2. - 1., 0, 1);
+		}
+		`,
+              frag: `
+		precision highp float;
+
+		varying vec4 fragColor;
+
+		uniform float opacity;
+
+		void main() {
+			gl_FragColor = fragColor;
+			gl_FragColor.a *= opacity;
+		}
+		`,
+              uniforms: {
+                range: regl.prop("range"),
+                lineWidth: regl.prop("lineWidth"),
+                capSize: regl.prop("capSize"),
+                opacity: regl.prop("opacity"),
+                scale: regl.prop("scale"),
+                translate: regl.prop("translate"),
+                scaleFract: regl.prop("scaleFract"),
+                translateFract: regl.prop("translateFract"),
+                viewport: (ctx2, prop) => [prop.viewport.x, prop.viewport.y, ctx2.viewportWidth, ctx2.viewportHeight]
+              },
+              attributes: {
+                //dynamic attributes
+                color: {
+                  buffer: colorBuffer,
+                  offset: (ctx2, prop) => prop.offset * 4,
+                  divisor: 1
+                },
+                position: {
+                  buffer: positionBuffer,
+                  offset: (ctx2, prop) => prop.offset * 8,
+                  divisor: 1
+                },
+                positionFract: {
+                  buffer: positionFractBuffer,
+                  offset: (ctx2, prop) => prop.offset * 8,
+                  divisor: 1
+                },
+                error: {
+                  buffer: errorBuffer,
+                  offset: (ctx2, prop) => prop.offset * 16,
+                  divisor: 1
+                },
+                //static attributes
+                direction: {
+                  buffer: meshBuffer,
+                  stride: 24,
+                  offset: 0
+                },
+                lineOffset: {
+                  buffer: meshBuffer,
+                  stride: 24,
+                  offset: 8
+                },
+                capOffset: {
+                  buffer: meshBuffer,
+                  stride: 24,
+                  offset: 16
+                }
+              },
+              primitive: "triangles",
+              blend: {
+                enable: true,
+                color: [0, 0, 0, 0],
+                equation: {
+                  rgb: "add",
+                  alpha: "add"
+                },
+                func: {
+                  srcRGB: "src alpha",
+                  dstRGB: "one minus src alpha",
+                  srcAlpha: "one minus dst alpha",
+                  dstAlpha: "one"
+                }
+              },
+              depth: {
+                enable: false
+              },
+              scissor: {
+                enable: true,
+                box: regl.prop("viewport")
+              },
+              viewport: regl.prop("viewport"),
+              stencil: false,
+              instances: regl.prop("count"),
+              count: WEIGHTS.length
+            });
+            extend2(error2d, {
+              update,
+              draw,
+              destroy,
+              regl,
+              gl: gl2,
+              canvas: gl2.canvas,
+              groups
+            });
+            return error2d;
+            function error2d(opts) {
+              if (opts) {
+                update(opts);
+              } else if (opts === null) {
+                destroy();
+              }
+              draw();
+            }
+            function draw(options2) {
+              if (typeof options2 === "number") return drawGroup(options2);
+              if (options2 && !Array.isArray(options2)) options2 = [options2];
+              regl._refresh();
+              groups.forEach((s2, i2) => {
+                if (!s2) return;
+                if (options2) {
+                  if (!options2[i2]) s2.draw = false;
+                  else s2.draw = true;
+                }
+                if (!s2.draw) {
+                  s2.draw = true;
+                  return;
+                }
+                drawGroup(i2);
+              });
+            }
+            function drawGroup(s2) {
+              if (typeof s2 === "number") s2 = groups[s2];
+              if (s2 == null) return;
+              if (!(s2 && s2.count && s2.color && s2.opacity && s2.positions && s2.positions.length > 1)) return;
+              s2.scaleRatio = [
+                s2.scale[0] * s2.viewport.width,
+                s2.scale[1] * s2.viewport.height
+              ];
+              drawErrors(s2);
+              if (s2.after) s2.after(s2);
+            }
+            function update(options2) {
+              if (!options2) return;
+              if (options2.length != null) {
+                if (typeof options2[0] === "number") options2 = [{ positions: options2 }];
+              } else if (!Array.isArray(options2)) options2 = [options2];
+              let pointCount = 0, errorCount = 0;
+              error2d.groups = groups = options2.map((options3, i2) => {
+                let group = groups[i2];
+                if (!options3) return group;
+                else if (typeof options3 === "function") options3 = { after: options3 };
+                else if (typeof options3[0] === "number") options3 = { positions: options3 };
+                options3 = pick(options3, {
+                  color: "color colors fill",
+                  capSize: "capSize cap capsize cap-size",
+                  lineWidth: "lineWidth line-width width line thickness",
+                  opacity: "opacity alpha",
+                  range: "range dataBox",
+                  viewport: "viewport viewBox",
+                  errors: "errors error",
+                  positions: "positions position data points"
+                });
+                if (!group) {
+                  groups[i2] = group = {
+                    id: i2,
+                    scale: null,
+                    translate: null,
+                    scaleFract: null,
+                    translateFract: null,
+                    draw: true
+                  };
+                  options3 = extend2({}, defaults, options3);
+                }
+                updateDiff(group, options3, [{
+                  lineWidth: (v2) => +v2 * 0.5,
+                  capSize: (v2) => +v2 * 0.5,
+                  opacity: parseFloat,
+                  errors: (errors) => {
+                    errors = flatten2(errors);
+                    errorCount += errors.length;
+                    return errors;
+                  },
+                  positions: (positions, state) => {
+                    positions = flatten2(positions, "float64");
+                    state.count = Math.floor(positions.length / 2);
+                    state.bounds = getBounds2(positions, 2);
+                    state.offset = pointCount;
+                    pointCount += state.count;
+                    return positions;
+                  }
+                }, {
+                  color: (colors, state) => {
+                    let count2 = state.count;
+                    if (!colors) colors = "transparent";
+                    if (!Array.isArray(colors) || typeof colors[0] === "number") {
+                      let color22 = colors;
+                      colors = Array(count2);
+                      for (let i22 = 0; i22 < count2; i22++) {
+                        colors[i22] = color22;
+                      }
+                    }
+                    if (colors.length < count2) throw Error("Not enough colors");
+                    let colorData = new Uint8Array(count2 * 4);
+                    for (let i22 = 0; i22 < count2; i22++) {
+                      let c2 = rgba3(colors[i22], "uint8");
+                      colorData.set(c2, i22 * 4);
+                    }
+                    return colorData;
+                  },
+                  range: (range, state, options4) => {
+                    let bounds = state.bounds;
+                    if (!range) range = bounds;
+                    state.scale = [1 / (range[2] - range[0]), 1 / (range[3] - range[1])];
+                    state.translate = [-range[0], -range[1]];
+                    state.scaleFract = fract32(state.scale);
+                    state.translateFract = fract32(state.translate);
+                    return range;
+                  },
+                  viewport: (vp) => {
+                    let viewport;
+                    if (Array.isArray(vp)) {
+                      viewport = {
+                        x: vp[0],
+                        y: vp[1],
+                        width: vp[2] - vp[0],
+                        height: vp[3] - vp[1]
+                      };
+                    } else if (vp) {
+                      viewport = {
+                        x: vp.x || vp.left || 0,
+                        y: vp.y || vp.top || 0
+                      };
+                      if (vp.right) viewport.width = vp.right - viewport.x;
+                      else viewport.width = vp.w || vp.width || 0;
+                      if (vp.bottom) viewport.height = vp.bottom - viewport.y;
+                      else viewport.height = vp.h || vp.height || 0;
+                    } else {
+                      viewport = {
+                        x: 0,
+                        y: 0,
+                        width: gl2.drawingBufferWidth,
+                        height: gl2.drawingBufferHeight
+                      };
+                    }
+                    return viewport;
+                  }
+                }]);
+                return group;
+              });
+              if (pointCount || errorCount) {
+                let len2 = groups.reduce((acc, group, i2) => {
+                  return acc + (group ? group.count : 0);
+                }, 0);
+                let positionData = new Float64Array(len2 * 2);
+                let colorData = new Uint8Array(len2 * 4);
+                let errorData = new Float32Array(len2 * 4);
+                groups.forEach((group, i2) => {
+                  if (!group) return;
+                  let { positions, count: count2, offset, color: color22, errors } = group;
+                  if (!count2) return;
+                  colorData.set(color22, offset * 4);
+                  errorData.set(errors, offset * 4);
+                  positionData.set(positions, offset * 2);
+                });
+                var float_data = float322(positionData);
+                positionBuffer(float_data);
+                var frac_data = fract32(positionData, float_data);
+                positionFractBuffer(frac_data);
+                colorBuffer(colorData);
+                errorBuffer(errorData);
+              }
+            }
+            function destroy() {
+              positionBuffer.destroy();
+              positionFractBuffer.destroy();
+              colorBuffer.destroy();
+              errorBuffer.destroy();
+              meshBuffer.destroy();
+            }
+          }
+        }
+      });
+      var require_unquote = __commonJS({
+        "node_modules/unquote/index.js"(exports, module2) {
+          var reg = /[\'\"]/;
+          module2.exports = function unquote(str) {
+            if (!str) {
+              return "";
+            }
+            if (reg.test(str.charAt(0))) {
+              str = str.substr(1);
+            }
+            if (reg.test(str.charAt(str.length - 1))) {
+              str = str.substr(0, str.length - 1);
+            }
+            return str;
+          };
+        }
+      });
+      var require_css_global_keywords = __commonJS({
+        "node_modules/css-global-keywords/index.json"(exports, module2) {
+          module2.exports = [
+            "inherit",
+            "initial",
+            "unset"
+          ];
+        }
+      });
+      var require_css_system_font_keywords = __commonJS({
+        "node_modules/css-system-font-keywords/index.json"(exports, module2) {
+          module2.exports = [
+            "caption",
+            "icon",
+            "menu",
+            "message-box",
+            "small-caption",
+            "status-bar"
+          ];
+        }
+      });
+      var require_css_font_weight_keywords = __commonJS({
+        "node_modules/css-font-weight-keywords/index.json"(exports, module2) {
+          module2.exports = [
+            "normal",
+            "bold",
+            "bolder",
+            "lighter",
+            "100",
+            "200",
+            "300",
+            "400",
+            "500",
+            "600",
+            "700",
+            "800",
+            "900"
+          ];
+        }
+      });
+      var require_css_font_style_keywords = __commonJS({
+        "node_modules/css-font-style-keywords/index.json"(exports, module2) {
+          module2.exports = [
+            "normal",
+            "italic",
+            "oblique"
+          ];
+        }
+      });
+      var require_css_font_stretch_keywords = __commonJS({
+        "node_modules/css-font-stretch-keywords/index.json"(exports, module2) {
+          module2.exports = [
+            "normal",
+            "condensed",
+            "semi-condensed",
+            "extra-condensed",
+            "ultra-condensed",
+            "expanded",
+            "semi-expanded",
+            "extra-expanded",
+            "ultra-expanded"
+          ];
+        }
+      });
+      var require_parenthesis = __commonJS({
+        "node_modules/parenthesis/index.js"(exports, module2) {
+          function parse22(str, opts) {
+            if (typeof str !== "string") return [str];
+            var res = [str];
+            if (typeof opts === "string" || Array.isArray(opts)) {
+              opts = { brackets: opts };
+            } else if (!opts) opts = {};
+            var brackets = opts.brackets ? Array.isArray(opts.brackets) ? opts.brackets : [opts.brackets] : ["{}", "[]", "()"];
+            var escape2 = opts.escape || "___";
+            var flat = !!opts.flat;
+            brackets.forEach(function(bracket) {
+              var pRE = new RegExp(["\\", bracket[0], "[^\\", bracket[0], "\\", bracket[1], "]*\\", bracket[1]].join(""));
+              var ids = [];
+              function replaceToken(token, idx, str2) {
+                var refId = res.push(token.slice(bracket[0].length, -bracket[1].length)) - 1;
+                ids.push(refId);
+                return escape2 + refId + escape2;
+              }
+              res.forEach(function(str2, i2) {
+                var prevStr;
+                var a2 = 0;
+                while (str2 != prevStr) {
+                  prevStr = str2;
+                  str2 = str2.replace(pRE, replaceToken);
+                  if (a2++ > 1e4) throw Error("References have circular dependency. Please, check them.");
+                }
+                res[i2] = str2;
+              });
+              ids = ids.reverse();
+              res = res.map(function(str2) {
+                ids.forEach(function(id2) {
+                  str2 = str2.replace(new RegExp("(\\" + escape2 + id2 + "\\" + escape2 + ")", "g"), bracket[0] + "$1" + bracket[1]);
+                });
+                return str2;
+              });
+            });
+            var re2 = new RegExp("\\" + escape2 + "([0-9]+)\\" + escape2);
+            function nest(str2, refs, escape3) {
+              var res2 = [], match;
+              var a2 = 0;
+              while (match = re2.exec(str2)) {
+                if (a2++ > 1e4) throw Error("Circular references in parenthesis");
+                res2.push(str2.slice(0, match.index));
+                res2.push(nest(refs[match[1]], refs));
+                str2 = str2.slice(match.index + match[0].length);
+              }
+              res2.push(str2);
+              return res2;
+            }
+            return flat ? res : nest(res[0], res);
+          }
+          function stringify(arg, opts) {
+            if (opts && opts.flat) {
+              var escape2 = opts && opts.escape || "___";
+              var str = arg[0], prevStr;
+              if (!str) return "";
+              var re2 = new RegExp("\\" + escape2 + "([0-9]+)\\" + escape2);
+              var a2 = 0;
+              while (str != prevStr) {
+                if (a2++ > 1e4) throw Error("Circular references in " + arg);
+                prevStr = str;
+                str = str.replace(re2, replaceRef);
+              }
+              return str;
+            }
+            return arg.reduce(function f2(prev, curr) {
+              if (Array.isArray(curr)) {
+                curr = curr.reduce(f2, "");
+              }
+              return prev + curr;
+            }, "");
+            function replaceRef(match, idx) {
+              if (arg[idx] == null) throw Error("Reference " + idx + "is undefined");
+              return arg[idx];
+            }
+          }
+          function parenthesis(arg, opts) {
+            if (Array.isArray(arg)) {
+              return stringify(arg, opts);
+            } else {
+              return parse22(arg, opts);
+            }
+          }
+          parenthesis.parse = parse22;
+          parenthesis.stringify = stringify;
+          module2.exports = parenthesis;
+        }
+      });
+      var require_string_split_by = __commonJS({
+        "node_modules/string-split-by/index.js"(exports, module2) {
+          var paren = require_parenthesis();
+          module2.exports = function splitBy(string, separator, o2) {
+            if (string == null) throw Error("First argument should be a string");
+            if (separator == null) throw Error("Separator should be a string or a RegExp");
+            if (!o2) o2 = {};
+            else if (typeof o2 === "string" || Array.isArray(o2)) {
+              o2 = { ignore: o2 };
+            }
+            if (o2.escape == null) o2.escape = true;
+            if (o2.ignore == null) o2.ignore = ["[]", "()", "{}", "<>", '""', "''", "``", "“”", "«»"];
+            else {
+              if (typeof o2.ignore === "string") {
+                o2.ignore = [o2.ignore];
+              }
+              o2.ignore = o2.ignore.map(function(pair) {
+                if (pair.length === 1) pair = pair + pair;
+                return pair;
+              });
+            }
+            var tokens = paren.parse(string, { flat: true, brackets: o2.ignore });
+            var str = tokens[0];
+            var parts = str.split(separator);
+            if (o2.escape) {
+              var cleanParts = [];
+              for (var i2 = 0; i2 < parts.length; i2++) {
+                var prev = parts[i2];
+                var part = parts[i2 + 1];
+                if (prev[prev.length - 1] === "\\" && prev[prev.length - 2] !== "\\") {
+                  cleanParts.push(prev + separator + part);
+                  i2++;
+                } else {
+                  cleanParts.push(prev);
+                }
+              }
+              parts = cleanParts;
+            }
+            for (var i2 = 0; i2 < parts.length; i2++) {
+              tokens[0] = parts[i2];
+              parts[i2] = paren.stringify(tokens, { flat: true });
+            }
+            return parts;
+          };
+        }
+      });
+      var require_css_font_size_keywords = __commonJS({
+        "node_modules/css-font-size-keywords/index.json"(exports, module2) {
+          module2.exports = [
+            "xx-small",
+            "x-small",
+            "small",
+            "medium",
+            "large",
+            "x-large",
+            "xx-large",
+            "larger",
+            "smaller"
+          ];
+        }
+      });
+      var require_util3 = __commonJS({
+        "node_modules/css-font/lib/util.js"(exports, module2) {
+          var sizes = require_css_font_size_keywords();
+          module2.exports = {
+            isSize: function isSize(value) {
+              return /^[\d\.]/.test(value) || value.indexOf("/") !== -1 || sizes.indexOf(value) !== -1;
+            }
+          };
+        }
+      });
+      var require_parse = __commonJS({
+        "node_modules/css-font/parse.js"(exports, module2) {
+          var unquote = require_unquote();
+          var globalKeywords = require_css_global_keywords();
+          var systemFontKeywords = require_css_system_font_keywords();
+          var fontWeightKeywords = require_css_font_weight_keywords();
+          var fontStyleKeywords = require_css_font_style_keywords();
+          var fontStretchKeywords = require_css_font_stretch_keywords();
+          var splitBy = require_string_split_by();
+          var isSize = require_util3().isSize;
+          module2.exports = parseFont;
+          var cache = parseFont.cache = {};
+          function parseFont(value) {
+            if (typeof value !== "string") throw new Error("Font argument must be a string.");
+            if (cache[value]) return cache[value];
+            if (value === "") {
+              throw new Error("Cannot parse an empty string.");
+            }
+            if (systemFontKeywords.indexOf(value) !== -1) {
+              return cache[value] = { system: value };
+            }
+            var font = {
+              style: "normal",
+              variant: "normal",
+              weight: "normal",
+              stretch: "normal",
+              lineHeight: "normal",
+              size: "1rem",
+              family: ["serif"]
+            };
+            var tokens = splitBy(value, /\s+/);
+            var token;
+            while (token = tokens.shift()) {
+              if (globalKeywords.indexOf(token) !== -1) {
+                ["style", "variant", "weight", "stretch"].forEach(function(prop) {
+                  font[prop] = token;
+                });
+                return cache[value] = font;
+              }
+              if (fontStyleKeywords.indexOf(token) !== -1) {
+                font.style = token;
+                continue;
+              }
+              if (token === "normal" || token === "small-caps") {
+                font.variant = token;
+                continue;
+              }
+              if (fontStretchKeywords.indexOf(token) !== -1) {
+                font.stretch = token;
+                continue;
+              }
+              if (fontWeightKeywords.indexOf(token) !== -1) {
+                font.weight = token;
+                continue;
+              }
+              if (isSize(token)) {
+                var parts = splitBy(token, "/");
+                font.size = parts[0];
+                if (parts[1] != null) {
+                  font.lineHeight = parseLineHeight(parts[1]);
+                } else if (tokens[0] === "/") {
+                  tokens.shift();
+                  font.lineHeight = parseLineHeight(tokens.shift());
+                }
+                if (!tokens.length) {
+                  throw new Error("Missing required font-family.");
+                }
+                font.family = splitBy(tokens.join(" "), /\s*,\s*/).map(unquote);
+                return cache[value] = font;
+              }
+              throw new Error("Unknown or unsupported font token: " + token);
+            }
+            throw new Error("Missing required font-size.");
+          }
+          function parseLineHeight(value) {
+            var parsed = parseFloat(value);
+            if (parsed.toString() === value) {
+              return parsed;
+            }
+            return value;
+          }
+        }
+      });
+      var require_stringify = __commonJS({
+        "node_modules/css-font/stringify.js"(exports, module2) {
+          var pick = require_pick_by_alias();
+          var isSize = require_util3().isSize;
+          var globals = a2o(require_css_global_keywords());
+          var systems = a2o(require_css_system_font_keywords());
+          var weights = a2o(require_css_font_weight_keywords());
+          var styles = a2o(require_css_font_style_keywords());
+          var stretches = a2o(require_css_font_stretch_keywords());
+          var variants = { "normal": 1, "small-caps": 1 };
+          var fams = {
+            "serif": 1,
+            "sans-serif": 1,
+            "monospace": 1,
+            "cursive": 1,
+            "fantasy": 1,
+            "system-ui": 1
+          };
+          var defaults = {
+            size: "1rem",
+            family: "serif"
+          };
+          module2.exports = function stringifyFont(o2) {
+            o2 = pick(o2, {
+              style: "style fontstyle fontStyle font-style slope distinction",
+              variant: "variant font-variant fontVariant fontvariant var capitalization",
+              weight: "weight w font-weight fontWeight fontweight",
+              stretch: "stretch font-stretch fontStretch fontstretch width",
+              size: "size s font-size fontSize fontsize height em emSize",
+              lineHeight: "lh line-height lineHeight lineheight leading",
+              family: "font family fontFamily font-family fontfamily type typeface face",
+              system: "system reserved default global"
+            });
+            if (o2.system) {
+              if (o2.system) verify(o2.system, systems);
+              return o2.system;
+            }
+            verify(o2.style, styles);
+            verify(o2.variant, variants);
+            verify(o2.weight, weights);
+            verify(o2.stretch, stretches);
+            if (o2.size == null) o2.size = defaults.size;
+            if (typeof o2.size === "number") o2.size += "px";
+            if (!isSize) throw Error("Bad size value `" + o2.size + "`");
+            if (!o2.family) o2.family = defaults.family;
+            if (Array.isArray(o2.family)) {
+              if (!o2.family.length) o2.family = [defaults.family];
+              o2.family = o2.family.map(function(f2) {
+                return fams[f2] ? f2 : '"' + f2 + '"';
+              }).join(", ");
+            }
+            var result = [];
+            result.push(o2.style);
+            if (o2.variant !== o2.style) result.push(o2.variant);
+            if (o2.weight !== o2.variant && o2.weight !== o2.style) result.push(o2.weight);
+            if (o2.stretch !== o2.weight && o2.stretch !== o2.variant && o2.stretch !== o2.style) result.push(o2.stretch);
+            result.push(o2.size + (o2.lineHeight == null || o2.lineHeight === "normal" || o2.lineHeight + "" === "1" ? "" : "/" + o2.lineHeight));
+            result.push(o2.family);
+            return result.filter(Boolean).join(" ");
+          };
+          function verify(value, values) {
+            if (value && !values[value] && !globals[value]) throw Error("Unknown keyword `" + value + "`");
+            return value;
+          }
+          function a2o(a2) {
+            var o2 = {};
+            for (var i2 = 0; i2 < a2.length; i2++) {
+              o2[a2[i2]] = 1;
+            }
+            return o2;
+          }
+        }
+      });
+      var require_css_font = __commonJS({
+        "node_modules/css-font/index.js"(exports, module2) {
+          module2.exports = {
+            parse: require_parse(),
+            stringify: require_stringify()
+          };
+        }
+      });
+      var require_regl_unchecked = __commonJS({
+        "node_modules/regl/dist/regl.unchecked.js"(exports, module2) {
+          (function(global2, factory2) {
+            typeof exports === "object" && typeof module2 !== "undefined" ? module2.exports = factory2() : global2.createREGL = factory2();
+          })(exports, function() {
+            var extend2 = function(base, opts) {
+              var keys = Object.keys(opts);
+              for (var i2 = 0; i2 < keys.length; ++i2) {
+                base[keys[i2]] = opts[keys[i2]];
+              }
+              return base;
+            };
+            var VARIABLE_COUNTER = 0;
+            var DYN_FUNC = 0;
+            var DYN_CONSTANT = 5;
+            var DYN_ARRAY = 6;
+            function DynamicVariable(type, data) {
+              this.id = VARIABLE_COUNTER++;
+              this.type = type;
+              this.data = data;
+            }
+            function escapeStr(str) {
+              return str.replace(/\\/g, "\\\\").replace(/"/g, '\\"');
+            }
+            function splitParts(str) {
+              if (str.length === 0) {
+                return [];
+              }
+              var firstChar = str.charAt(0);
+              var lastChar = str.charAt(str.length - 1);
+              if (str.length > 1 && firstChar === lastChar && (firstChar === '"' || firstChar === "'")) {
+                return ['"' + escapeStr(str.substr(1, str.length - 2)) + '"'];
+              }
+              var parts = /\[(false|true|null|\d+|'[^']*'|"[^"]*")\]/.exec(str);
+              if (parts) {
+                return splitParts(str.substr(0, parts.index)).concat(splitParts(parts[1])).concat(splitParts(str.substr(parts.index + parts[0].length)));
+              }
+              var subparts = str.split(".");
+              if (subparts.length === 1) {
+                return ['"' + escapeStr(str) + '"'];
+              }
+              var result = [];
+              for (var i2 = 0; i2 < subparts.length; ++i2) {
+                result = result.concat(splitParts(subparts[i2]));
+              }
+              return result;
+            }
+            function toAccessorString(str) {
+              return "[" + splitParts(str).join("][") + "]";
+            }
+            function defineDynamic(type, data) {
+              return new DynamicVariable(type, toAccessorString(data + ""));
+            }
+            function isDynamic(x2) {
+              return typeof x2 === "function" && !x2._reglType || x2 instanceof DynamicVariable;
+            }
+            function unbox(x2, path) {
+              if (typeof x2 === "function") {
+                return new DynamicVariable(DYN_FUNC, x2);
+              } else if (typeof x2 === "number" || typeof x2 === "boolean") {
+                return new DynamicVariable(DYN_CONSTANT, x2);
+              } else if (Array.isArray(x2)) {
+                return new DynamicVariable(DYN_ARRAY, x2.map(function(y2, i2) {
+                  return unbox(y2);
+                }));
+              } else if (x2 instanceof DynamicVariable) {
+                return x2;
+              }
+            }
+            var dynamic = {
+              DynamicVariable,
+              define: defineDynamic,
+              isDynamic,
+              unbox,
+              accessor: toAccessorString
+            };
+            var raf = {
+              next: typeof requestAnimationFrame === "function" ? function(cb2) {
+                return requestAnimationFrame(cb2);
+              } : function(cb2) {
+                return setTimeout(cb2, 16);
+              },
+              cancel: typeof cancelAnimationFrame === "function" ? function(raf2) {
+                return cancelAnimationFrame(raf2);
+              } : clearTimeout
+            };
+            var clock = typeof performance !== "undefined" && performance.now ? function() {
+              return performance.now();
+            } : function() {
+              return +/* @__PURE__ */ new Date();
+            };
+            function createStringStore() {
+              var stringIds = { "": 0 };
+              var stringValues = [""];
+              return {
+                id: function(str) {
+                  var result = stringIds[str];
+                  if (result) {
+                    return result;
+                  }
+                  result = stringIds[str] = stringValues.length;
+                  stringValues.push(str);
+                  return result;
+                },
+                str: function(id2) {
+                  return stringValues[id2];
+                }
+              };
+            }
+            function createCanvas(element, onDone, pixelRatio) {
+              var canvas2 = document.createElement("canvas");
+              extend2(canvas2.style, {
+                border: 0,
+                margin: 0,
+                padding: 0,
+                top: 0,
+                left: 0,
+                width: "100%",
+                height: "100%"
+              });
+              element.appendChild(canvas2);
+              if (element === document.body) {
+                canvas2.style.position = "absolute";
+                extend2(element.style, {
+                  margin: 0,
+                  padding: 0
+                });
+              }
+              function resize() {
+                var w2 = window.innerWidth;
+                var h2 = window.innerHeight;
+                if (element !== document.body) {
+                  var bounds = canvas2.getBoundingClientRect();
+                  w2 = bounds.right - bounds.left;
+                  h2 = bounds.bottom - bounds.top;
+                }
+                canvas2.width = pixelRatio * w2;
+                canvas2.height = pixelRatio * h2;
+              }
+              var resizeObserver;
+              if (element !== document.body && typeof ResizeObserver === "function") {
+                resizeObserver = new ResizeObserver(function() {
+                  setTimeout(resize);
+                });
+                resizeObserver.observe(element);
+              } else {
+                window.addEventListener("resize", resize, false);
+              }
+              function onDestroy() {
+                if (resizeObserver) {
+                  resizeObserver.disconnect();
+                } else {
+                  window.removeEventListener("resize", resize);
+                }
+                element.removeChild(canvas2);
+              }
+              resize();
+              return {
+                canvas: canvas2,
+                onDestroy
+              };
+            }
+            function createContext(canvas2, contextAttributes) {
+              function get(name2) {
+                try {
+                  return canvas2.getContext(name2, contextAttributes);
+                } catch (e2) {
+                  return null;
+                }
+              }
+              return get("webgl") || get("experimental-webgl") || get("webgl-experimental");
+            }
+            function isHTMLElement(obj) {
+              return typeof obj.nodeName === "string" && typeof obj.appendChild === "function" && typeof obj.getBoundingClientRect === "function";
+            }
+            function isWebGLContext(obj) {
+              return typeof obj.drawArrays === "function" || typeof obj.drawElements === "function";
+            }
+            function parseExtensions(input) {
+              if (typeof input === "string") {
+                return input.split();
+              }
+              return input;
+            }
+            function getElement(desc) {
+              if (typeof desc === "string") {
+                return document.querySelector(desc);
+              }
+              return desc;
+            }
+            function parseArgs(args_) {
+              var args = args_ || {};
+              var element, container, canvas2, gl2;
+              var contextAttributes = {};
+              var extensions = [];
+              var optionalExtensions = [];
+              var pixelRatio = typeof window === "undefined" ? 1 : window.devicePixelRatio;
+              var profile = false;
+              var cachedCode = {};
+              var onDone = function(err) {
+              };
+              var onDestroy = function() {
+              };
+              if (typeof args === "string") {
+                element = document.querySelector(args);
+              } else if (typeof args === "object") {
+                if (isHTMLElement(args)) {
+                  element = args;
+                } else if (isWebGLContext(args)) {
+                  gl2 = args;
+                  canvas2 = gl2.canvas;
+                } else {
+                  if ("gl" in args) {
+                    gl2 = args.gl;
+                  } else if ("canvas" in args) {
+                    canvas2 = getElement(args.canvas);
+                  } else if ("container" in args) {
+                    container = getElement(args.container);
+                  }
+                  if ("attributes" in args) {
+                    contextAttributes = args.attributes;
+                  }
+                  if ("extensions" in args) {
+                    extensions = parseExtensions(args.extensions);
+                  }
+                  if ("optionalExtensions" in args) {
+                    optionalExtensions = parseExtensions(args.optionalExtensions);
+                  }
+                  if ("onDone" in args) {
+                    onDone = args.onDone;
+                  }
+                  if ("profile" in args) {
+                    profile = !!args.profile;
+                  }
+                  if ("pixelRatio" in args) {
+                    pixelRatio = +args.pixelRatio;
+                  }
+                  if ("cachedCode" in args) {
+                    cachedCode = args.cachedCode;
+                  }
+                }
+              } else ;
+              if (element) {
+                if (element.nodeName.toLowerCase() === "canvas") {
+                  canvas2 = element;
+                } else {
+                  container = element;
+                }
+              }
+              if (!gl2) {
+                if (!canvas2) {
+                  var result = createCanvas(container || document.body, onDone, pixelRatio);
+                  if (!result) {
+                    return null;
+                  }
+                  canvas2 = result.canvas;
+                  onDestroy = result.onDestroy;
+                }
+                if (contextAttributes.premultipliedAlpha === void 0) contextAttributes.premultipliedAlpha = true;
+                gl2 = createContext(canvas2, contextAttributes);
+              }
+              if (!gl2) {
+                onDestroy();
+                onDone("webgl not supported, try upgrading your browser or graphics drivers http://get.webgl.org");
+                return null;
+              }
+              return {
+                gl: gl2,
+                canvas: canvas2,
+                container,
+                extensions,
+                optionalExtensions,
+                pixelRatio,
+                profile,
+                cachedCode,
+                onDone,
+                onDestroy
+              };
+            }
+            function createExtensionCache(gl2, config2) {
+              var extensions = {};
+              function tryLoadExtension(name_) {
+                var name3 = name_.toLowerCase();
+                var ext;
+                try {
+                  ext = extensions[name3] = gl2.getExtension(name3);
+                } catch (e2) {
+                }
+                return !!ext;
+              }
+              for (var i2 = 0; i2 < config2.extensions.length; ++i2) {
+                var name2 = config2.extensions[i2];
+                if (!tryLoadExtension(name2)) {
+                  config2.onDestroy();
+                  config2.onDone('"' + name2 + '" extension is not supported by the current WebGL context, try upgrading your system or a different browser');
+                  return null;
+                }
+              }
+              config2.optionalExtensions.forEach(tryLoadExtension);
+              return {
+                extensions,
+                restore: function() {
+                  Object.keys(extensions).forEach(function(name3) {
+                    if (extensions[name3] && !tryLoadExtension(name3)) {
+                      throw new Error("(regl): error restoring extension " + name3);
+                    }
+                  });
+                }
+              };
+            }
+            function loop(n2, f2) {
+              var result = Array(n2);
+              for (var i2 = 0; i2 < n2; ++i2) {
+                result[i2] = f2(i2);
+              }
+              return result;
+            }
+            var GL_BYTE = 5120;
+            var GL_UNSIGNED_BYTE$1 = 5121;
+            var GL_SHORT = 5122;
+            var GL_UNSIGNED_SHORT = 5123;
+            var GL_INT = 5124;
+            var GL_UNSIGNED_INT = 5125;
+            var GL_FLOAT$1 = 5126;
+            function nextPow16(v2) {
+              for (var i2 = 16; i2 <= 1 << 28; i2 *= 16) {
+                if (v2 <= i2) {
+                  return i2;
+                }
+              }
+              return 0;
+            }
+            function log22(v2) {
+              var r2, shift;
+              r2 = (v2 > 65535) << 4;
+              v2 >>>= r2;
+              shift = (v2 > 255) << 3;
+              v2 >>>= shift;
+              r2 |= shift;
+              shift = (v2 > 15) << 2;
+              v2 >>>= shift;
+              r2 |= shift;
+              shift = (v2 > 3) << 1;
+              v2 >>>= shift;
+              r2 |= shift;
+              return r2 | v2 >> 1;
+            }
+            function createPool() {
+              var bufferPool = loop(8, function() {
+                return [];
+              });
+              function alloc(n2) {
+                var sz = nextPow16(n2);
+                var bin = bufferPool[log22(sz) >> 2];
+                if (bin.length > 0) {
+                  return bin.pop();
+                }
+                return new ArrayBuffer(sz);
+              }
+              function free(buf) {
+                bufferPool[log22(buf.byteLength) >> 2].push(buf);
+              }
+              function allocType(type, n2) {
+                var result = null;
+                switch (type) {
+                  case GL_BYTE:
+                    result = new Int8Array(alloc(n2), 0, n2);
+                    break;
+                  case GL_UNSIGNED_BYTE$1:
+                    result = new Uint8Array(alloc(n2), 0, n2);
+                    break;
+                  case GL_SHORT:
+                    result = new Int16Array(alloc(2 * n2), 0, n2);
+                    break;
+                  case GL_UNSIGNED_SHORT:
+                    result = new Uint16Array(alloc(2 * n2), 0, n2);
+                    break;
+                  case GL_INT:
+                    result = new Int32Array(alloc(4 * n2), 0, n2);
+                    break;
+                  case GL_UNSIGNED_INT:
+                    result = new Uint32Array(alloc(4 * n2), 0, n2);
+                    break;
+                  case GL_FLOAT$1:
+                    result = new Float32Array(alloc(4 * n2), 0, n2);
+                    break;
+                  default:
+                    return null;
+                }
+                if (result.length !== n2) {
+                  return result.subarray(0, n2);
+                }
+                return result;
+              }
+              function freeType(array) {
+                free(array.buffer);
+              }
+              return {
+                alloc,
+                free,
+                allocType,
+                freeType
+              };
+            }
+            var pool = createPool();
+            pool.zero = createPool();
+            var GL_SUBPIXEL_BITS = 3408;
+            var GL_RED_BITS = 3410;
+            var GL_GREEN_BITS = 3411;
+            var GL_BLUE_BITS = 3412;
+            var GL_ALPHA_BITS = 3413;
+            var GL_DEPTH_BITS = 3414;
+            var GL_STENCIL_BITS = 3415;
+            var GL_ALIASED_POINT_SIZE_RANGE = 33901;
+            var GL_ALIASED_LINE_WIDTH_RANGE = 33902;
+            var GL_MAX_TEXTURE_SIZE = 3379;
+            var GL_MAX_VIEWPORT_DIMS = 3386;
+            var GL_MAX_VERTEX_ATTRIBS = 34921;
+            var GL_MAX_VERTEX_UNIFORM_VECTORS = 36347;
+            var GL_MAX_VARYING_VECTORS = 36348;
+            var GL_MAX_COMBINED_TEXTURE_IMAGE_UNITS = 35661;
+            var GL_MAX_VERTEX_TEXTURE_IMAGE_UNITS = 35660;
+            var GL_MAX_TEXTURE_IMAGE_UNITS = 34930;
+            var GL_MAX_FRAGMENT_UNIFORM_VECTORS = 36349;
+            var GL_MAX_CUBE_MAP_TEXTURE_SIZE = 34076;
+            var GL_MAX_RENDERBUFFER_SIZE = 34024;
+            var GL_VENDOR = 7936;
+            var GL_RENDERER = 7937;
+            var GL_VERSION = 7938;
+            var GL_SHADING_LANGUAGE_VERSION = 35724;
+            var GL_MAX_TEXTURE_MAX_ANISOTROPY_EXT = 34047;
+            var GL_MAX_COLOR_ATTACHMENTS_WEBGL = 36063;
+            var GL_MAX_DRAW_BUFFERS_WEBGL = 34852;
+            var GL_TEXTURE_2D = 3553;
+            var GL_TEXTURE_CUBE_MAP = 34067;
+            var GL_TEXTURE_CUBE_MAP_POSITIVE_X = 34069;
+            var GL_TEXTURE0 = 33984;
+            var GL_RGBA = 6408;
+            var GL_FLOAT = 5126;
+            var GL_UNSIGNED_BYTE = 5121;
+            var GL_FRAMEBUFFER = 36160;
+            var GL_FRAMEBUFFER_COMPLETE = 36053;
+            var GL_COLOR_ATTACHMENT0 = 36064;
+            var GL_COLOR_BUFFER_BIT$1 = 16384;
+            var wrapLimits = function(gl2, extensions) {
+              var maxAnisotropic = 1;
+              if (extensions.ext_texture_filter_anisotropic) {
+                maxAnisotropic = gl2.getParameter(GL_MAX_TEXTURE_MAX_ANISOTROPY_EXT);
+              }
+              var maxDrawbuffers = 1;
+              var maxColorAttachments = 1;
+              if (extensions.webgl_draw_buffers) {
+                maxDrawbuffers = gl2.getParameter(GL_MAX_DRAW_BUFFERS_WEBGL);
+                maxColorAttachments = gl2.getParameter(GL_MAX_COLOR_ATTACHMENTS_WEBGL);
+              }
+              var readFloat = !!extensions.oes_texture_float;
+              if (readFloat) {
+                var readFloatTexture = gl2.createTexture();
+                gl2.bindTexture(GL_TEXTURE_2D, readFloatTexture);
+                gl2.texImage2D(GL_TEXTURE_2D, 0, GL_RGBA, 1, 1, 0, GL_RGBA, GL_FLOAT, null);
+                var fbo = gl2.createFramebuffer();
+                gl2.bindFramebuffer(GL_FRAMEBUFFER, fbo);
+                gl2.framebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, readFloatTexture, 0);
+                gl2.bindTexture(GL_TEXTURE_2D, null);
+                if (gl2.checkFramebufferStatus(GL_FRAMEBUFFER) !== GL_FRAMEBUFFER_COMPLETE) readFloat = false;
+                else {
+                  gl2.viewport(0, 0, 1, 1);
+                  gl2.clearColor(1, 0, 0, 1);
+                  gl2.clear(GL_COLOR_BUFFER_BIT$1);
+                  var pixels = pool.allocType(GL_FLOAT, 4);
+                  gl2.readPixels(0, 0, 1, 1, GL_RGBA, GL_FLOAT, pixels);
+                  if (gl2.getError()) readFloat = false;
+                  else {
+                    gl2.deleteFramebuffer(fbo);
+                    gl2.deleteTexture(readFloatTexture);
+                    readFloat = pixels[0] === 1;
+                  }
+                  pool.freeType(pixels);
+                }
+              }
+              var isIE = typeof navigator !== "undefined" && (/MSIE/.test(navigator.userAgent) || /Trident\//.test(navigator.appVersion) || /Edge/.test(navigator.userAgent));
+              var npotTextureCube = true;
+              if (!isIE) {
+                var cubeTexture = gl2.createTexture();
+                var data = pool.allocType(GL_UNSIGNED_BYTE, 36);
+                gl2.activeTexture(GL_TEXTURE0);
+                gl2.bindTexture(GL_TEXTURE_CUBE_MAP, cubeTexture);
+                gl2.texImage2D(GL_TEXTURE_CUBE_MAP_POSITIVE_X, 0, GL_RGBA, 3, 3, 0, GL_RGBA, GL_UNSIGNED_BYTE, data);
+                pool.freeType(data);
+                gl2.bindTexture(GL_TEXTURE_CUBE_MAP, null);
+                gl2.deleteTexture(cubeTexture);
+                npotTextureCube = !gl2.getError();
+              }
+              return {
+                // drawing buffer bit depth
+                colorBits: [
+                  gl2.getParameter(GL_RED_BITS),
+                  gl2.getParameter(GL_GREEN_BITS),
+                  gl2.getParameter(GL_BLUE_BITS),
+                  gl2.getParameter(GL_ALPHA_BITS)
+                ],
+                depthBits: gl2.getParameter(GL_DEPTH_BITS),
+                stencilBits: gl2.getParameter(GL_STENCIL_BITS),
+                subpixelBits: gl2.getParameter(GL_SUBPIXEL_BITS),
+                // supported extensions
+                extensions: Object.keys(extensions).filter(function(ext) {
+                  return !!extensions[ext];
+                }),
+                // max aniso samples
+                maxAnisotropic,
+                // max draw buffers
+                maxDrawbuffers,
+                maxColorAttachments,
+                // point and line size ranges
+                pointSizeDims: gl2.getParameter(GL_ALIASED_POINT_SIZE_RANGE),
+                lineWidthDims: gl2.getParameter(GL_ALIASED_LINE_WIDTH_RANGE),
+                maxViewportDims: gl2.getParameter(GL_MAX_VIEWPORT_DIMS),
+                maxCombinedTextureUnits: gl2.getParameter(GL_MAX_COMBINED_TEXTURE_IMAGE_UNITS),
+                maxCubeMapSize: gl2.getParameter(GL_MAX_CUBE_MAP_TEXTURE_SIZE),
+                maxRenderbufferSize: gl2.getParameter(GL_MAX_RENDERBUFFER_SIZE),
+                maxTextureUnits: gl2.getParameter(GL_MAX_TEXTURE_IMAGE_UNITS),
+                maxTextureSize: gl2.getParameter(GL_MAX_TEXTURE_SIZE),
+                maxAttributes: gl2.getParameter(GL_MAX_VERTEX_ATTRIBS),
+                maxVertexUniforms: gl2.getParameter(GL_MAX_VERTEX_UNIFORM_VECTORS),
+                maxVertexTextureUnits: gl2.getParameter(GL_MAX_VERTEX_TEXTURE_IMAGE_UNITS),
+                maxVaryingVectors: gl2.getParameter(GL_MAX_VARYING_VECTORS),
+                maxFragmentUniforms: gl2.getParameter(GL_MAX_FRAGMENT_UNIFORM_VECTORS),
+                // vendor info
+                glsl: gl2.getParameter(GL_SHADING_LANGUAGE_VERSION),
+                renderer: gl2.getParameter(GL_RENDERER),
+                vendor: gl2.getParameter(GL_VENDOR),
+                version: gl2.getParameter(GL_VERSION),
+                // quirks
+                readFloat,
+                npotTextureCube
+              };
+            };
+            var isTypedArray2 = function(x2) {
+              return x2 instanceof Uint8Array || x2 instanceof Uint16Array || x2 instanceof Uint32Array || x2 instanceof Int8Array || x2 instanceof Int16Array || x2 instanceof Int32Array || x2 instanceof Float32Array || x2 instanceof Float64Array || x2 instanceof Uint8ClampedArray;
+            };
+            function isNDArrayLike(obj) {
+              return !!obj && typeof obj === "object" && Array.isArray(obj.shape) && Array.isArray(obj.stride) && typeof obj.offset === "number" && obj.shape.length === obj.stride.length && (Array.isArray(obj.data) || isTypedArray2(obj.data));
+            }
+            var values = function(obj) {
+              return Object.keys(obj).map(function(key) {
+                return obj[key];
+              });
+            };
+            var flattenUtils = {
+              shape: arrayShape$1,
+              flatten: flattenArray2
+            };
+            function flatten1D(array, nx, out) {
+              for (var i2 = 0; i2 < nx; ++i2) {
+                out[i2] = array[i2];
+              }
+            }
+            function flatten2D(array, nx, ny, out) {
+              var ptr = 0;
+              for (var i2 = 0; i2 < nx; ++i2) {
+                var row = array[i2];
+                for (var j2 = 0; j2 < ny; ++j2) {
+                  out[ptr++] = row[j2];
+                }
+              }
+            }
+            function flatten3D(array, nx, ny, nz, out, ptr_) {
+              var ptr = ptr_;
+              for (var i2 = 0; i2 < nx; ++i2) {
+                var row = array[i2];
+                for (var j2 = 0; j2 < ny; ++j2) {
+                  var col = row[j2];
+                  for (var k2 = 0; k2 < nz; ++k2) {
+                    out[ptr++] = col[k2];
+                  }
+                }
+              }
+            }
+            function flattenRec(array, shape, level, out, ptr) {
+              var stride = 1;
+              for (var i2 = level + 1; i2 < shape.length; ++i2) {
+                stride *= shape[i2];
+              }
+              var n2 = shape[level];
+              if (shape.length - level === 4) {
+                var nx = shape[level + 1];
+                var ny = shape[level + 2];
+                var nz = shape[level + 3];
+                for (i2 = 0; i2 < n2; ++i2) {
+                  flatten3D(array[i2], nx, ny, nz, out, ptr);
+                  ptr += stride;
+                }
+              } else {
+                for (i2 = 0; i2 < n2; ++i2) {
+                  flattenRec(array[i2], shape, level + 1, out, ptr);
+                  ptr += stride;
+                }
+              }
+            }
+            function flattenArray2(array, shape, type, out_) {
+              var sz = 1;
+              if (shape.length) {
+                for (var i2 = 0; i2 < shape.length; ++i2) {
+                  sz *= shape[i2];
+                }
+              } else {
+                sz = 0;
+              }
+              var out = out_ || pool.allocType(type, sz);
+              switch (shape.length) {
+                case 0:
+                  break;
+                case 1:
+                  flatten1D(array, shape[0], out);
+                  break;
+                case 2:
+                  flatten2D(array, shape[0], shape[1], out);
+                  break;
+                case 3:
+                  flatten3D(array, shape[0], shape[1], shape[2], out, 0);
+                  break;
+                default:
+                  flattenRec(array, shape, 0, out, 0);
+              }
+              return out;
+            }
+            function arrayShape$1(array_) {
+              var shape = [];
+              for (var array = array_; array.length; array = array[0]) {
+                shape.push(array.length);
+              }
+              return shape;
+            }
+            var arrayTypes = {
+              "[object Int8Array]": 5120,
+              "[object Int16Array]": 5122,
+              "[object Int32Array]": 5124,
+              "[object Uint8Array]": 5121,
+              "[object Uint8ClampedArray]": 5121,
+              "[object Uint16Array]": 5123,
+              "[object Uint32Array]": 5125,
+              "[object Float32Array]": 5126,
+              "[object Float64Array]": 5121,
+              "[object ArrayBuffer]": 5121
+            };
+            var int8 = 5120;
+            var int16 = 5122;
+            var int322 = 5124;
+            var uint8 = 5121;
+            var uint16 = 5123;
+            var uint32 = 5125;
+            var float = 5126;
+            var float322 = 5126;
+            var glTypes = {
+              int8,
+              int16,
+              int32: int322,
+              uint8,
+              uint16,
+              uint32,
+              float,
+              float32: float322
+            };
+            var dynamic$1 = 35048;
+            var stream = 35040;
+            var usageTypes = {
+              dynamic: dynamic$1,
+              stream,
+              "static": 35044
+            };
+            var arrayFlatten = flattenUtils.flatten;
+            var arrayShape = flattenUtils.shape;
+            var GL_STATIC_DRAW = 35044;
+            var GL_STREAM_DRAW = 35040;
+            var GL_UNSIGNED_BYTE$2 = 5121;
+            var GL_FLOAT$2 = 5126;
+            var DTYPES_SIZES = [];
+            DTYPES_SIZES[5120] = 1;
+            DTYPES_SIZES[5122] = 2;
+            DTYPES_SIZES[5124] = 4;
+            DTYPES_SIZES[5121] = 1;
+            DTYPES_SIZES[5123] = 2;
+            DTYPES_SIZES[5125] = 4;
+            DTYPES_SIZES[5126] = 4;
+            function typedArrayCode(data) {
+              return arrayTypes[Object.prototype.toString.call(data)] | 0;
+            }
+            function copyArray(out, inp) {
+              for (var i2 = 0; i2 < inp.length; ++i2) {
+                out[i2] = inp[i2];
+              }
+            }
+            function transpose2(result, data, shapeX, shapeY, strideX, strideY, offset) {
+              var ptr = 0;
+              for (var i2 = 0; i2 < shapeX; ++i2) {
+                for (var j2 = 0; j2 < shapeY; ++j2) {
+                  result[ptr++] = data[strideX * i2 + strideY * j2 + offset];
+                }
+              }
+            }
+            function wrapBufferState(gl2, stats2, config2, destroyBuffer) {
+              var bufferCount = 0;
+              var bufferSet = {};
+              function REGLBuffer(type) {
+                this.id = bufferCount++;
+                this.buffer = gl2.createBuffer();
+                this.type = type;
+                this.usage = GL_STATIC_DRAW;
+                this.byteLength = 0;
+                this.dimension = 1;
+                this.dtype = GL_UNSIGNED_BYTE$2;
+                this.persistentData = null;
+                if (config2.profile) {
+                  this.stats = { size: 0 };
+                }
+              }
+              REGLBuffer.prototype.bind = function() {
+                gl2.bindBuffer(this.type, this.buffer);
+              };
+              REGLBuffer.prototype.destroy = function() {
+                destroy(this);
+              };
+              var streamPool = [];
+              function createStream(type, data) {
+                var buffer = streamPool.pop();
+                if (!buffer) {
+                  buffer = new REGLBuffer(type);
+                }
+                buffer.bind();
+                initBufferFromData(buffer, data, GL_STREAM_DRAW, 0, 1, false);
+                return buffer;
+              }
+              function destroyStream(stream$$1) {
+                streamPool.push(stream$$1);
+              }
+              function initBufferFromTypedArray(buffer, data, usage) {
+                buffer.byteLength = data.byteLength;
+                gl2.bufferData(buffer.type, data, usage);
+              }
+              function initBufferFromData(buffer, data, usage, dtype, dimension, persist) {
+                var shape;
+                buffer.usage = usage;
+                if (Array.isArray(data)) {
+                  buffer.dtype = dtype || GL_FLOAT$2;
+                  if (data.length > 0) {
+                    var flatData;
+                    if (Array.isArray(data[0])) {
+                      shape = arrayShape(data);
+                      var dim = 1;
+                      for (var i2 = 1; i2 < shape.length; ++i2) {
+                        dim *= shape[i2];
+                      }
+                      buffer.dimension = dim;
+                      flatData = arrayFlatten(data, shape, buffer.dtype);
+                      initBufferFromTypedArray(buffer, flatData, usage);
+                      if (persist) {
+                        buffer.persistentData = flatData;
+                      } else {
+                        pool.freeType(flatData);
+                      }
+                    } else if (typeof data[0] === "number") {
+                      buffer.dimension = dimension;
+                      var typedData = pool.allocType(buffer.dtype, data.length);
+                      copyArray(typedData, data);
+                      initBufferFromTypedArray(buffer, typedData, usage);
+                      if (persist) {
+                        buffer.persistentData = typedData;
+                      } else {
+                        pool.freeType(typedData);
+                      }
+                    } else if (isTypedArray2(data[0])) {
+                      buffer.dimension = data[0].length;
+                      buffer.dtype = dtype || typedArrayCode(data[0]) || GL_FLOAT$2;
+                      flatData = arrayFlatten(
+                        data,
+                        [data.length, data[0].length],
+                        buffer.dtype
+                      );
+                      initBufferFromTypedArray(buffer, flatData, usage);
+                      if (persist) {
+                        buffer.persistentData = flatData;
+                      } else {
+                        pool.freeType(flatData);
+                      }
+                    } else ;
+                  }
+                } else if (isTypedArray2(data)) {
+                  buffer.dtype = dtype || typedArrayCode(data);
+                  buffer.dimension = dimension;
+                  initBufferFromTypedArray(buffer, data, usage);
+                  if (persist) {
+                    buffer.persistentData = new Uint8Array(new Uint8Array(data.buffer));
+                  }
+                } else if (isNDArrayLike(data)) {
+                  shape = data.shape;
+                  var stride = data.stride;
+                  var offset = data.offset;
+                  var shapeX = 0;
+                  var shapeY = 0;
+                  var strideX = 0;
+                  var strideY = 0;
+                  if (shape.length === 1) {
+                    shapeX = shape[0];
+                    shapeY = 1;
+                    strideX = stride[0];
+                    strideY = 0;
+                  } else if (shape.length === 2) {
+                    shapeX = shape[0];
+                    shapeY = shape[1];
+                    strideX = stride[0];
+                    strideY = stride[1];
+                  } else ;
+                  buffer.dtype = dtype || typedArrayCode(data.data) || GL_FLOAT$2;
+                  buffer.dimension = shapeY;
+                  var transposeData2 = pool.allocType(buffer.dtype, shapeX * shapeY);
+                  transpose2(
+                    transposeData2,
+                    data.data,
+                    shapeX,
+                    shapeY,
+                    strideX,
+                    strideY,
+                    offset
+                  );
+                  initBufferFromTypedArray(buffer, transposeData2, usage);
+                  if (persist) {
+                    buffer.persistentData = transposeData2;
+                  } else {
+                    pool.freeType(transposeData2);
+                  }
+                } else if (data instanceof ArrayBuffer) {
+                  buffer.dtype = GL_UNSIGNED_BYTE$2;
+                  buffer.dimension = dimension;
+                  initBufferFromTypedArray(buffer, data, usage);
+                  if (persist) {
+                    buffer.persistentData = new Uint8Array(new Uint8Array(data));
+                  }
+                } else ;
+              }
+              function destroy(buffer) {
+                stats2.bufferCount--;
+                destroyBuffer(buffer);
+                var handle = buffer.buffer;
+                gl2.deleteBuffer(handle);
+                buffer.buffer = null;
+                delete bufferSet[buffer.id];
+              }
+              function createBuffer(options, type, deferInit, persistent) {
+                stats2.bufferCount++;
+                var buffer = new REGLBuffer(type);
+                bufferSet[buffer.id] = buffer;
+                function reglBuffer(options2) {
+                  var usage = GL_STATIC_DRAW;
+                  var data = null;
+                  var byteLength = 0;
+                  var dtype = 0;
+                  var dimension = 1;
+                  if (Array.isArray(options2) || isTypedArray2(options2) || isNDArrayLike(options2) || options2 instanceof ArrayBuffer) {
+                    data = options2;
+                  } else if (typeof options2 === "number") {
+                    byteLength = options2 | 0;
+                  } else if (options2) {
+                    if ("data" in options2) {
+                      data = options2.data;
+                    }
+                    if ("usage" in options2) {
+                      usage = usageTypes[options2.usage];
+                    }
+                    if ("type" in options2) {
+                      dtype = glTypes[options2.type];
+                    }
+                    if ("dimension" in options2) {
+                      dimension = options2.dimension | 0;
+                    }
+                    if ("length" in options2) {
+                      byteLength = options2.length | 0;
+                    }
+                  }
+                  buffer.bind();
+                  if (!data) {
+                    if (byteLength) gl2.bufferData(buffer.type, byteLength, usage);
+                    buffer.dtype = dtype || GL_UNSIGNED_BYTE$2;
+                    buffer.usage = usage;
+                    buffer.dimension = dimension;
+                    buffer.byteLength = byteLength;
+                  } else {
+                    initBufferFromData(buffer, data, usage, dtype, dimension, persistent);
+                  }
+                  if (config2.profile) {
+                    buffer.stats.size = buffer.byteLength * DTYPES_SIZES[buffer.dtype];
+                  }
+                  return reglBuffer;
+                }
+                function setSubData(data, offset) {
+                  gl2.bufferSubData(buffer.type, offset, data);
+                }
+                function subdata(data, offset_) {
+                  var offset = (offset_ || 0) | 0;
+                  var shape;
+                  buffer.bind();
+                  if (isTypedArray2(data) || data instanceof ArrayBuffer) {
+                    setSubData(data, offset);
+                  } else if (Array.isArray(data)) {
+                    if (data.length > 0) {
+                      if (typeof data[0] === "number") {
+                        var converted = pool.allocType(buffer.dtype, data.length);
+                        copyArray(converted, data);
+                        setSubData(converted, offset);
+                        pool.freeType(converted);
+                      } else if (Array.isArray(data[0]) || isTypedArray2(data[0])) {
+                        shape = arrayShape(data);
+                        var flatData = arrayFlatten(data, shape, buffer.dtype);
+                        setSubData(flatData, offset);
+                        pool.freeType(flatData);
+                      } else ;
+                    }
+                  } else if (isNDArrayLike(data)) {
+                    shape = data.shape;
+                    var stride = data.stride;
+                    var shapeX = 0;
+                    var shapeY = 0;
+                    var strideX = 0;
+                    var strideY = 0;
+                    if (shape.length === 1) {
+                      shapeX = shape[0];
+                      shapeY = 1;
+                      strideX = stride[0];
+                      strideY = 0;
+                    } else if (shape.length === 2) {
+                      shapeX = shape[0];
+                      shapeY = shape[1];
+                      strideX = stride[0];
+                      strideY = stride[1];
+                    } else ;
+                    var dtype = Array.isArray(data.data) ? buffer.dtype : typedArrayCode(data.data);
+                    var transposeData2 = pool.allocType(dtype, shapeX * shapeY);
+                    transpose2(
+                      transposeData2,
+                      data.data,
+                      shapeX,
+                      shapeY,
+                      strideX,
+                      strideY,
+                      data.offset
+                    );
+                    setSubData(transposeData2, offset);
+                    pool.freeType(transposeData2);
+                  } else ;
+                  return reglBuffer;
+                }
+                if (!deferInit) {
+                  reglBuffer(options);
+                }
+                reglBuffer._reglType = "buffer";
+                reglBuffer._buffer = buffer;
+                reglBuffer.subdata = subdata;
+                if (config2.profile) {
+                  reglBuffer.stats = buffer.stats;
+                }
+                reglBuffer.destroy = function() {
+                  destroy(buffer);
+                };
+                return reglBuffer;
+              }
+              function restoreBuffers() {
+                values(bufferSet).forEach(function(buffer) {
+                  buffer.buffer = gl2.createBuffer();
+                  gl2.bindBuffer(buffer.type, buffer.buffer);
+                  gl2.bufferData(
+                    buffer.type,
+                    buffer.persistentData || buffer.byteLength,
+                    buffer.usage
+                  );
+                });
+              }
+              if (config2.profile) {
+                stats2.getTotalBufferSize = function() {
+                  var total = 0;
+                  Object.keys(bufferSet).forEach(function(key) {
+                    total += bufferSet[key].stats.size;
+                  });
+                  return total;
+                };
+              }
+              return {
+                create: createBuffer,
+                createStream,
+                destroyStream,
+                clear: function() {
+                  values(bufferSet).forEach(destroy);
+                  streamPool.forEach(destroy);
+                },
+                getBuffer: function(wrapper) {
+                  if (wrapper && wrapper._buffer instanceof REGLBuffer) {
+                    return wrapper._buffer;
+                  }
+                  return null;
+                },
+                restore: restoreBuffers,
+                _initBuffer: initBufferFromData
+              };
+            }
+            var points = 0;
+            var point = 0;
+            var lines = 1;
+            var line = 1;
+            var triangles = 4;
+            var triangle = 4;
+            var primTypes = {
+              points,
+              point,
+              lines,
+              line,
+              triangles,
+              triangle,
+              "line loop": 2,
+              "line strip": 3,
+              "triangle strip": 5,
+              "triangle fan": 6
+            };
+            var GL_POINTS = 0;
+            var GL_LINES = 1;
+            var GL_TRIANGLES = 4;
+            var GL_BYTE$1 = 5120;
+            var GL_UNSIGNED_BYTE$3 = 5121;
+            var GL_SHORT$1 = 5122;
+            var GL_UNSIGNED_SHORT$1 = 5123;
+            var GL_INT$1 = 5124;
+            var GL_UNSIGNED_INT$1 = 5125;
+            var GL_ELEMENT_ARRAY_BUFFER = 34963;
+            var GL_STREAM_DRAW$1 = 35040;
+            var GL_STATIC_DRAW$1 = 35044;
+            function wrapElementsState(gl2, extensions, bufferState, stats2) {
+              var elementSet = {};
+              var elementCount = 0;
+              var elementTypes = {
+                "uint8": GL_UNSIGNED_BYTE$3,
+                "uint16": GL_UNSIGNED_SHORT$1
+              };
+              if (extensions.oes_element_index_uint) {
+                elementTypes.uint32 = GL_UNSIGNED_INT$1;
+              }
+              function REGLElementBuffer(buffer) {
+                this.id = elementCount++;
+                elementSet[this.id] = this;
+                this.buffer = buffer;
+                this.primType = GL_TRIANGLES;
+                this.vertCount = 0;
+                this.type = 0;
+              }
+              REGLElementBuffer.prototype.bind = function() {
+                this.buffer.bind();
+              };
+              var bufferPool = [];
+              function createElementStream(data) {
+                var result = bufferPool.pop();
+                if (!result) {
+                  result = new REGLElementBuffer(bufferState.create(
+                    null,
+                    GL_ELEMENT_ARRAY_BUFFER,
+                    true,
+                    false
+                  )._buffer);
+                }
+                initElements(result, data, GL_STREAM_DRAW$1, -1, -1, 0, 0);
+                return result;
+              }
+              function destroyElementStream(elements) {
+                bufferPool.push(elements);
+              }
+              function initElements(elements, data, usage, prim, count2, byteLength, type) {
+                elements.buffer.bind();
+                var dtype;
+                if (data) {
+                  var predictedType = type;
+                  if (!type && (!isTypedArray2(data) || isNDArrayLike(data) && !isTypedArray2(data.data))) {
+                    predictedType = extensions.oes_element_index_uint ? GL_UNSIGNED_INT$1 : GL_UNSIGNED_SHORT$1;
+                  }
+                  bufferState._initBuffer(
+                    elements.buffer,
+                    data,
+                    usage,
+                    predictedType,
+                    3
+                  );
+                } else {
+                  gl2.bufferData(GL_ELEMENT_ARRAY_BUFFER, byteLength, usage);
+                  elements.buffer.dtype = dtype || GL_UNSIGNED_BYTE$3;
+                  elements.buffer.usage = usage;
+                  elements.buffer.dimension = 3;
+                  elements.buffer.byteLength = byteLength;
+                }
+                dtype = type;
+                if (!type) {
+                  switch (elements.buffer.dtype) {
+                    case GL_UNSIGNED_BYTE$3:
+                    case GL_BYTE$1:
+                      dtype = GL_UNSIGNED_BYTE$3;
+                      break;
+                    case GL_UNSIGNED_SHORT$1:
+                    case GL_SHORT$1:
+                      dtype = GL_UNSIGNED_SHORT$1;
+                      break;
+                    case GL_UNSIGNED_INT$1:
+                    case GL_INT$1:
+                      dtype = GL_UNSIGNED_INT$1;
+                      break;
+                  }
+                  elements.buffer.dtype = dtype;
+                }
+                elements.type = dtype;
+                var vertCount = count2;
+                if (vertCount < 0) {
+                  vertCount = elements.buffer.byteLength;
+                  if (dtype === GL_UNSIGNED_SHORT$1) {
+                    vertCount >>= 1;
+                  } else if (dtype === GL_UNSIGNED_INT$1) {
+                    vertCount >>= 2;
+                  }
+                }
+                elements.vertCount = vertCount;
+                var primType = prim;
+                if (prim < 0) {
+                  primType = GL_TRIANGLES;
+                  var dimension = elements.buffer.dimension;
+                  if (dimension === 1) primType = GL_POINTS;
+                  if (dimension === 2) primType = GL_LINES;
+                  if (dimension === 3) primType = GL_TRIANGLES;
+                }
+                elements.primType = primType;
+              }
+              function destroyElements(elements) {
+                stats2.elementsCount--;
+                delete elementSet[elements.id];
+                elements.buffer.destroy();
+                elements.buffer = null;
+              }
+              function createElements(options, persistent) {
+                var buffer = bufferState.create(null, GL_ELEMENT_ARRAY_BUFFER, true);
+                var elements = new REGLElementBuffer(buffer._buffer);
+                stats2.elementsCount++;
+                function reglElements(options2) {
+                  if (!options2) {
+                    buffer();
+                    elements.primType = GL_TRIANGLES;
+                    elements.vertCount = 0;
+                    elements.type = GL_UNSIGNED_BYTE$3;
+                  } else if (typeof options2 === "number") {
+                    buffer(options2);
+                    elements.primType = GL_TRIANGLES;
+                    elements.vertCount = options2 | 0;
+                    elements.type = GL_UNSIGNED_BYTE$3;
+                  } else {
+                    var data = null;
+                    var usage = GL_STATIC_DRAW$1;
+                    var primType = -1;
+                    var vertCount = -1;
+                    var byteLength = 0;
+                    var dtype = 0;
+                    if (Array.isArray(options2) || isTypedArray2(options2) || isNDArrayLike(options2)) {
+                      data = options2;
+                    } else {
+                      if ("data" in options2) {
+                        data = options2.data;
+                      }
+                      if ("usage" in options2) {
+                        usage = usageTypes[options2.usage];
+                      }
+                      if ("primitive" in options2) {
+                        primType = primTypes[options2.primitive];
+                      }
+                      if ("count" in options2) {
+                        vertCount = options2.count | 0;
+                      }
+                      if ("type" in options2) {
+                        dtype = elementTypes[options2.type];
+                      }
+                      if ("length" in options2) {
+                        byteLength = options2.length | 0;
+                      } else {
+                        byteLength = vertCount;
+                        if (dtype === GL_UNSIGNED_SHORT$1 || dtype === GL_SHORT$1) {
+                          byteLength *= 2;
+                        } else if (dtype === GL_UNSIGNED_INT$1 || dtype === GL_INT$1) {
+                          byteLength *= 4;
+                        }
+                      }
+                    }
+                    initElements(
+                      elements,
+                      data,
+                      usage,
+                      primType,
+                      vertCount,
+                      byteLength,
+                      dtype
+                    );
+                  }
+                  return reglElements;
+                }
+                reglElements(options);
+                reglElements._reglType = "elements";
+                reglElements._elements = elements;
+                reglElements.subdata = function(data, offset) {
+                  buffer.subdata(data, offset);
+                  return reglElements;
+                };
+                reglElements.destroy = function() {
+                  destroyElements(elements);
+                };
+                return reglElements;
+              }
+              return {
+                create: createElements,
+                createStream: createElementStream,
+                destroyStream: destroyElementStream,
+                getElements: function(elements) {
+                  if (typeof elements === "function" && elements._elements instanceof REGLElementBuffer) {
+                    return elements._elements;
+                  }
+                  return null;
+                },
+                clear: function() {
+                  values(elementSet).forEach(destroyElements);
+                }
+              };
+            }
+            var FLOAT = new Float32Array(1);
+            var INT = new Uint32Array(FLOAT.buffer);
+            var GL_UNSIGNED_SHORT$3 = 5123;
+            function convertToHalfFloat(array) {
+              var ushorts = pool.allocType(GL_UNSIGNED_SHORT$3, array.length);
+              for (var i2 = 0; i2 < array.length; ++i2) {
+                if (isNaN(array[i2])) {
+                  ushorts[i2] = 65535;
+                } else if (array[i2] === Infinity) {
+                  ushorts[i2] = 31744;
+                } else if (array[i2] === -Infinity) {
+                  ushorts[i2] = 64512;
+                } else {
+                  FLOAT[0] = array[i2];
+                  var x2 = INT[0];
+                  var sgn = x2 >>> 31 << 15;
+                  var exp = (x2 << 1 >>> 24) - 127;
+                  var frac = x2 >> 13 & (1 << 10) - 1;
+                  if (exp < -24) {
+                    ushorts[i2] = sgn;
+                  } else if (exp < -14) {
+                    var s2 = -14 - exp;
+                    ushorts[i2] = sgn + (frac + (1 << 10) >> s2);
+                  } else if (exp > 15) {
+                    ushorts[i2] = sgn + 31744;
+                  } else {
+                    ushorts[i2] = sgn + (exp + 15 << 10) + frac;
+                  }
+                }
+              }
+              return ushorts;
+            }
+            function isArrayLike(s2) {
+              return Array.isArray(s2) || isTypedArray2(s2);
+            }
+            var GL_COMPRESSED_TEXTURE_FORMATS = 34467;
+            var GL_TEXTURE_2D$1 = 3553;
+            var GL_TEXTURE_CUBE_MAP$1 = 34067;
+            var GL_TEXTURE_CUBE_MAP_POSITIVE_X$1 = 34069;
+            var GL_RGBA$1 = 6408;
+            var GL_ALPHA = 6406;
+            var GL_RGB = 6407;
+            var GL_LUMINANCE = 6409;
+            var GL_LUMINANCE_ALPHA = 6410;
+            var GL_RGBA4 = 32854;
+            var GL_RGB5_A1 = 32855;
+            var GL_RGB565 = 36194;
+            var GL_UNSIGNED_SHORT_4_4_4_4 = 32819;
+            var GL_UNSIGNED_SHORT_5_5_5_1 = 32820;
+            var GL_UNSIGNED_SHORT_5_6_5 = 33635;
+            var GL_UNSIGNED_INT_24_8_WEBGL = 34042;
+            var GL_DEPTH_COMPONENT = 6402;
+            var GL_DEPTH_STENCIL = 34041;
+            var GL_SRGB_EXT = 35904;
+            var GL_SRGB_ALPHA_EXT = 35906;
+            var GL_HALF_FLOAT_OES = 36193;
+            var GL_COMPRESSED_RGB_S3TC_DXT1_EXT = 33776;
+            var GL_COMPRESSED_RGBA_S3TC_DXT1_EXT = 33777;
+            var GL_COMPRESSED_RGBA_S3TC_DXT3_EXT = 33778;
+            var GL_COMPRESSED_RGBA_S3TC_DXT5_EXT = 33779;
+            var GL_COMPRESSED_RGB_ATC_WEBGL = 35986;
+            var GL_COMPRESSED_RGBA_ATC_EXPLICIT_ALPHA_WEBGL = 35987;
+            var GL_COMPRESSED_RGBA_ATC_INTERPOLATED_ALPHA_WEBGL = 34798;
+            var GL_COMPRESSED_RGB_PVRTC_4BPPV1_IMG = 35840;
+            var GL_COMPRESSED_RGB_PVRTC_2BPPV1_IMG = 35841;
+            var GL_COMPRESSED_RGBA_PVRTC_4BPPV1_IMG = 35842;
+            var GL_COMPRESSED_RGBA_PVRTC_2BPPV1_IMG = 35843;
+            var GL_COMPRESSED_RGB_ETC1_WEBGL = 36196;
+            var GL_UNSIGNED_BYTE$4 = 5121;
+            var GL_UNSIGNED_SHORT$2 = 5123;
+            var GL_UNSIGNED_INT$2 = 5125;
+            var GL_FLOAT$3 = 5126;
+            var GL_TEXTURE_WRAP_S = 10242;
+            var GL_TEXTURE_WRAP_T = 10243;
+            var GL_REPEAT = 10497;
+            var GL_CLAMP_TO_EDGE = 33071;
+            var GL_MIRRORED_REPEAT = 33648;
+            var GL_TEXTURE_MAG_FILTER = 10240;
+            var GL_TEXTURE_MIN_FILTER = 10241;
+            var GL_NEAREST = 9728;
+            var GL_LINEAR = 9729;
+            var GL_NEAREST_MIPMAP_NEAREST = 9984;
+            var GL_LINEAR_MIPMAP_NEAREST = 9985;
+            var GL_NEAREST_MIPMAP_LINEAR = 9986;
+            var GL_LINEAR_MIPMAP_LINEAR = 9987;
+            var GL_GENERATE_MIPMAP_HINT = 33170;
+            var GL_DONT_CARE = 4352;
+            var GL_FASTEST = 4353;
+            var GL_NICEST = 4354;
+            var GL_TEXTURE_MAX_ANISOTROPY_EXT = 34046;
+            var GL_UNPACK_ALIGNMENT = 3317;
+            var GL_UNPACK_FLIP_Y_WEBGL = 37440;
+            var GL_UNPACK_PREMULTIPLY_ALPHA_WEBGL = 37441;
+            var GL_UNPACK_COLORSPACE_CONVERSION_WEBGL = 37443;
+            var GL_BROWSER_DEFAULT_WEBGL = 37444;
+            var GL_TEXTURE0$1 = 33984;
+            var MIPMAP_FILTERS = [
+              GL_NEAREST_MIPMAP_NEAREST,
+              GL_NEAREST_MIPMAP_LINEAR,
+              GL_LINEAR_MIPMAP_NEAREST,
+              GL_LINEAR_MIPMAP_LINEAR
+            ];
+            var CHANNELS_FORMAT = [
+              0,
+              GL_LUMINANCE,
+              GL_LUMINANCE_ALPHA,
+              GL_RGB,
+              GL_RGBA$1
+            ];
+            var FORMAT_CHANNELS = {};
+            FORMAT_CHANNELS[GL_LUMINANCE] = FORMAT_CHANNELS[GL_ALPHA] = FORMAT_CHANNELS[GL_DEPTH_COMPONENT] = 1;
+            FORMAT_CHANNELS[GL_DEPTH_STENCIL] = FORMAT_CHANNELS[GL_LUMINANCE_ALPHA] = 2;
+            FORMAT_CHANNELS[GL_RGB] = FORMAT_CHANNELS[GL_SRGB_EXT] = 3;
+            FORMAT_CHANNELS[GL_RGBA$1] = FORMAT_CHANNELS[GL_SRGB_ALPHA_EXT] = 4;
+            function objectName(str) {
+              return "[object " + str + "]";
+            }
+            var CANVAS_CLASS = objectName("HTMLCanvasElement");
+            var OFFSCREENCANVAS_CLASS = objectName("OffscreenCanvas");
+            var CONTEXT2D_CLASS = objectName("CanvasRenderingContext2D");
+            var BITMAP_CLASS = objectName("ImageBitmap");
+            var IMAGE_CLASS = objectName("HTMLImageElement");
+            var VIDEO_CLASS = objectName("HTMLVideoElement");
+            var PIXEL_CLASSES = Object.keys(arrayTypes).concat([
+              CANVAS_CLASS,
+              OFFSCREENCANVAS_CLASS,
+              CONTEXT2D_CLASS,
+              BITMAP_CLASS,
+              IMAGE_CLASS,
+              VIDEO_CLASS
+            ]);
+            var TYPE_SIZES = [];
+            TYPE_SIZES[GL_UNSIGNED_BYTE$4] = 1;
+            TYPE_SIZES[GL_FLOAT$3] = 4;
+            TYPE_SIZES[GL_HALF_FLOAT_OES] = 2;
+            TYPE_SIZES[GL_UNSIGNED_SHORT$2] = 2;
+            TYPE_SIZES[GL_UNSIGNED_INT$2] = 4;
+            var FORMAT_SIZES_SPECIAL = [];
+            FORMAT_SIZES_SPECIAL[GL_RGBA4] = 2;
+            FORMAT_SIZES_SPECIAL[GL_RGB5_A1] = 2;
+            FORMAT_SIZES_SPECIAL[GL_RGB565] = 2;
+            FORMAT_SIZES_SPECIAL[GL_DEPTH_STENCIL] = 4;
+            FORMAT_SIZES_SPECIAL[GL_COMPRESSED_RGB_S3TC_DXT1_EXT] = 0.5;
+            FORMAT_SIZES_SPECIAL[GL_COMPRESSED_RGBA_S3TC_DXT1_EXT] = 0.5;
+            FORMAT_SIZES_SPECIAL[GL_COMPRESSED_RGBA_S3TC_DXT3_EXT] = 1;
+            FORMAT_SIZES_SPECIAL[GL_COMPRESSED_RGBA_S3TC_DXT5_EXT] = 1;
+            FORMAT_SIZES_SPECIAL[GL_COMPRESSED_RGB_ATC_WEBGL] = 0.5;
+            FORMAT_SIZES_SPECIAL[GL_COMPRESSED_RGBA_ATC_EXPLICIT_ALPHA_WEBGL] = 1;
+            FORMAT_SIZES_SPECIAL[GL_COMPRESSED_RGBA_ATC_INTERPOLATED_ALPHA_WEBGL] = 1;
+            FORMAT_SIZES_SPECIAL[GL_COMPRESSED_RGB_PVRTC_4BPPV1_IMG] = 0.5;
+            FORMAT_SIZES_SPECIAL[GL_COMPRESSED_RGB_PVRTC_2BPPV1_IMG] = 0.25;
+            FORMAT_SIZES_SPECIAL[GL_COMPRESSED_RGBA_PVRTC_4BPPV1_IMG] = 0.5;
+            FORMAT_SIZES_SPECIAL[GL_COMPRESSED_RGBA_PVRTC_2BPPV1_IMG] = 0.25;
+            FORMAT_SIZES_SPECIAL[GL_COMPRESSED_RGB_ETC1_WEBGL] = 0.5;
+            function isNumericArray2(arr) {
+              return Array.isArray(arr) && (arr.length === 0 || typeof arr[0] === "number");
+            }
+            function isRectArray(arr) {
+              if (!Array.isArray(arr)) {
+                return false;
+              }
+              var width = arr.length;
+              if (width === 0 || !isArrayLike(arr[0])) {
+                return false;
+              }
+              return true;
+            }
+            function classString(x2) {
+              return Object.prototype.toString.call(x2);
+            }
+            function isCanvasElement(object) {
+              return classString(object) === CANVAS_CLASS;
+            }
+            function isOffscreenCanvas(object) {
+              return classString(object) === OFFSCREENCANVAS_CLASS;
+            }
+            function isContext2D(object) {
+              return classString(object) === CONTEXT2D_CLASS;
+            }
+            function isBitmap(object) {
+              return classString(object) === BITMAP_CLASS;
+            }
+            function isImageElement(object) {
+              return classString(object) === IMAGE_CLASS;
+            }
+            function isVideoElement(object) {
+              return classString(object) === VIDEO_CLASS;
+            }
+            function isPixelData(object) {
+              if (!object) {
+                return false;
+              }
+              var className = classString(object);
+              if (PIXEL_CLASSES.indexOf(className) >= 0) {
+                return true;
+              }
+              return isNumericArray2(object) || isRectArray(object) || isNDArrayLike(object);
+            }
+            function typedArrayCode$1(data) {
+              return arrayTypes[Object.prototype.toString.call(data)] | 0;
+            }
+            function convertData(result, data) {
+              var n2 = data.length;
+              switch (result.type) {
+                case GL_UNSIGNED_BYTE$4:
+                case GL_UNSIGNED_SHORT$2:
+                case GL_UNSIGNED_INT$2:
+                case GL_FLOAT$3:
+                  var converted = pool.allocType(result.type, n2);
+                  converted.set(data);
+                  result.data = converted;
+                  break;
+                case GL_HALF_FLOAT_OES:
+                  result.data = convertToHalfFloat(data);
+                  break;
+              }
+            }
+            function preConvert(image, n2) {
+              return pool.allocType(
+                image.type === GL_HALF_FLOAT_OES ? GL_FLOAT$3 : image.type,
+                n2
+              );
+            }
+            function postConvert(image, data) {
+              if (image.type === GL_HALF_FLOAT_OES) {
+                image.data = convertToHalfFloat(data);
+                pool.freeType(data);
+              } else {
+                image.data = data;
+              }
+            }
+            function transposeData(image, array, strideX, strideY, strideC, offset) {
+              var w2 = image.width;
+              var h2 = image.height;
+              var c2 = image.channels;
+              var n2 = w2 * h2 * c2;
+              var data = preConvert(image, n2);
+              var p2 = 0;
+              for (var i2 = 0; i2 < h2; ++i2) {
+                for (var j2 = 0; j2 < w2; ++j2) {
+                  for (var k2 = 0; k2 < c2; ++k2) {
+                    data[p2++] = array[strideX * j2 + strideY * i2 + strideC * k2 + offset];
+                  }
+                }
+              }
+              postConvert(image, data);
+            }
+            function getTextureSize(format, type, width, height, isMipmap, isCube) {
+              var s2;
+              if (typeof FORMAT_SIZES_SPECIAL[format] !== "undefined") {
+                s2 = FORMAT_SIZES_SPECIAL[format];
+              } else {
+                s2 = FORMAT_CHANNELS[format] * TYPE_SIZES[type];
+              }
+              if (isCube) {
+                s2 *= 6;
+              }
+              if (isMipmap) {
+                var total = 0;
+                var w2 = width;
+                while (w2 >= 1) {
+                  total += s2 * w2 * w2;
+                  w2 /= 2;
+                }
+                return total;
+              } else {
+                return s2 * width * height;
+              }
+            }
+            function createTextureSet(gl2, extensions, limits, reglPoll, contextState, stats2, config2) {
+              var mipmapHint = {
+                "don't care": GL_DONT_CARE,
+                "dont care": GL_DONT_CARE,
+                "nice": GL_NICEST,
+                "fast": GL_FASTEST
+              };
+              var wrapModes = {
+                "repeat": GL_REPEAT,
+                "clamp": GL_CLAMP_TO_EDGE,
+                "mirror": GL_MIRRORED_REPEAT
+              };
+              var magFilters = {
+                "nearest": GL_NEAREST,
+                "linear": GL_LINEAR
+              };
+              var minFilters = extend2({
+                "mipmap": GL_LINEAR_MIPMAP_LINEAR,
+                "nearest mipmap nearest": GL_NEAREST_MIPMAP_NEAREST,
+                "linear mipmap nearest": GL_LINEAR_MIPMAP_NEAREST,
+                "nearest mipmap linear": GL_NEAREST_MIPMAP_LINEAR,
+                "linear mipmap linear": GL_LINEAR_MIPMAP_LINEAR
+              }, magFilters);
+              var colorSpace = {
+                "none": 0,
+                "browser": GL_BROWSER_DEFAULT_WEBGL
+              };
+              var textureTypes = {
+                "uint8": GL_UNSIGNED_BYTE$4,
+                "rgba4": GL_UNSIGNED_SHORT_4_4_4_4,
+                "rgb565": GL_UNSIGNED_SHORT_5_6_5,
+                "rgb5 a1": GL_UNSIGNED_SHORT_5_5_5_1
+              };
+              var textureFormats = {
+                "alpha": GL_ALPHA,
+                "luminance": GL_LUMINANCE,
+                "luminance alpha": GL_LUMINANCE_ALPHA,
+                "rgb": GL_RGB,
+                "rgba": GL_RGBA$1,
+                "rgba4": GL_RGBA4,
+                "rgb5 a1": GL_RGB5_A1,
+                "rgb565": GL_RGB565
+              };
+              var compressedTextureFormats = {};
+              if (extensions.ext_srgb) {
+                textureFormats.srgb = GL_SRGB_EXT;
+                textureFormats.srgba = GL_SRGB_ALPHA_EXT;
+              }
+              if (extensions.oes_texture_float) {
+                textureTypes.float32 = textureTypes.float = GL_FLOAT$3;
+              }
+              if (extensions.oes_texture_half_float) {
+                textureTypes["float16"] = textureTypes["half float"] = GL_HALF_FLOAT_OES;
+              }
+              if (extensions.webgl_depth_texture) {
+                extend2(textureFormats, {
+                  "depth": GL_DEPTH_COMPONENT,
+                  "depth stencil": GL_DEPTH_STENCIL
+                });
+                extend2(textureTypes, {
+                  "uint16": GL_UNSIGNED_SHORT$2,
+                  "uint32": GL_UNSIGNED_INT$2,
+                  "depth stencil": GL_UNSIGNED_INT_24_8_WEBGL
+                });
+              }
+              if (extensions.webgl_compressed_texture_s3tc) {
+                extend2(compressedTextureFormats, {
+                  "rgb s3tc dxt1": GL_COMPRESSED_RGB_S3TC_DXT1_EXT,
+                  "rgba s3tc dxt1": GL_COMPRESSED_RGBA_S3TC_DXT1_EXT,
+                  "rgba s3tc dxt3": GL_COMPRESSED_RGBA_S3TC_DXT3_EXT,
+                  "rgba s3tc dxt5": GL_COMPRESSED_RGBA_S3TC_DXT5_EXT
+                });
+              }
+              if (extensions.webgl_compressed_texture_atc) {
+                extend2(compressedTextureFormats, {
+                  "rgb atc": GL_COMPRESSED_RGB_ATC_WEBGL,
+                  "rgba atc explicit alpha": GL_COMPRESSED_RGBA_ATC_EXPLICIT_ALPHA_WEBGL,
+                  "rgba atc interpolated alpha": GL_COMPRESSED_RGBA_ATC_INTERPOLATED_ALPHA_WEBGL
+                });
+              }
+              if (extensions.webgl_compressed_texture_pvrtc) {
+                extend2(compressedTextureFormats, {
+                  "rgb pvrtc 4bppv1": GL_COMPRESSED_RGB_PVRTC_4BPPV1_IMG,
+                  "rgb pvrtc 2bppv1": GL_COMPRESSED_RGB_PVRTC_2BPPV1_IMG,
+                  "rgba pvrtc 4bppv1": GL_COMPRESSED_RGBA_PVRTC_4BPPV1_IMG,
+                  "rgba pvrtc 2bppv1": GL_COMPRESSED_RGBA_PVRTC_2BPPV1_IMG
+                });
+              }
+              if (extensions.webgl_compressed_texture_etc1) {
+                compressedTextureFormats["rgb etc1"] = GL_COMPRESSED_RGB_ETC1_WEBGL;
+              }
+              var supportedCompressedFormats = Array.prototype.slice.call(
+                gl2.getParameter(GL_COMPRESSED_TEXTURE_FORMATS)
+              );
+              Object.keys(compressedTextureFormats).forEach(function(name2) {
+                var format = compressedTextureFormats[name2];
+                if (supportedCompressedFormats.indexOf(format) >= 0) {
+                  textureFormats[name2] = format;
+                }
+              });
+              var supportedFormats = Object.keys(textureFormats);
+              limits.textureFormats = supportedFormats;
+              var textureFormatsInvert = [];
+              Object.keys(textureFormats).forEach(function(key) {
+                var val = textureFormats[key];
+                textureFormatsInvert[val] = key;
+              });
+              var textureTypesInvert = [];
+              Object.keys(textureTypes).forEach(function(key) {
+                var val = textureTypes[key];
+                textureTypesInvert[val] = key;
+              });
+              var magFiltersInvert = [];
+              Object.keys(magFilters).forEach(function(key) {
+                var val = magFilters[key];
+                magFiltersInvert[val] = key;
+              });
+              var minFiltersInvert = [];
+              Object.keys(minFilters).forEach(function(key) {
+                var val = minFilters[key];
+                minFiltersInvert[val] = key;
+              });
+              var wrapModesInvert = [];
+              Object.keys(wrapModes).forEach(function(key) {
+                var val = wrapModes[key];
+                wrapModesInvert[val] = key;
+              });
+              var colorFormats = supportedFormats.reduce(function(color22, key) {
+                var glenum = textureFormats[key];
+                if (glenum === GL_LUMINANCE || glenum === GL_ALPHA || glenum === GL_LUMINANCE || glenum === GL_LUMINANCE_ALPHA || glenum === GL_DEPTH_COMPONENT || glenum === GL_DEPTH_STENCIL || extensions.ext_srgb && (glenum === GL_SRGB_EXT || glenum === GL_SRGB_ALPHA_EXT)) {
+                  color22[glenum] = glenum;
+                } else if (glenum === GL_RGB5_A1 || key.indexOf("rgba") >= 0) {
+                  color22[glenum] = GL_RGBA$1;
+                } else {
+                  color22[glenum] = GL_RGB;
+                }
+                return color22;
+              }, {});
+              function TexFlags() {
+                this.internalformat = GL_RGBA$1;
+                this.format = GL_RGBA$1;
+                this.type = GL_UNSIGNED_BYTE$4;
+                this.compressed = false;
+                this.premultiplyAlpha = false;
+                this.flipY = false;
+                this.unpackAlignment = 1;
+                this.colorSpace = GL_BROWSER_DEFAULT_WEBGL;
+                this.width = 0;
+                this.height = 0;
+                this.channels = 0;
+              }
+              function copyFlags(result, other) {
+                result.internalformat = other.internalformat;
+                result.format = other.format;
+                result.type = other.type;
+                result.compressed = other.compressed;
+                result.premultiplyAlpha = other.premultiplyAlpha;
+                result.flipY = other.flipY;
+                result.unpackAlignment = other.unpackAlignment;
+                result.colorSpace = other.colorSpace;
+                result.width = other.width;
+                result.height = other.height;
+                result.channels = other.channels;
+              }
+              function parseFlags(flags, options) {
+                if (typeof options !== "object" || !options) {
+                  return;
+                }
+                if ("premultiplyAlpha" in options) {
+                  flags.premultiplyAlpha = options.premultiplyAlpha;
+                }
+                if ("flipY" in options) {
+                  flags.flipY = options.flipY;
+                }
+                if ("alignment" in options) {
+                  flags.unpackAlignment = options.alignment;
+                }
+                if ("colorSpace" in options) {
+                  flags.colorSpace = colorSpace[options.colorSpace];
+                }
+                if ("type" in options) {
+                  var type = options.type;
+                  flags.type = textureTypes[type];
+                }
+                var w2 = flags.width;
+                var h2 = flags.height;
+                var c2 = flags.channels;
+                var hasChannels = false;
+                if ("shape" in options) {
+                  w2 = options.shape[0];
+                  h2 = options.shape[1];
+                  if (options.shape.length === 3) {
+                    c2 = options.shape[2];
+                    hasChannels = true;
+                  }
+                } else {
+                  if ("radius" in options) {
+                    w2 = h2 = options.radius;
+                  }
+                  if ("width" in options) {
+                    w2 = options.width;
+                  }
+                  if ("height" in options) {
+                    h2 = options.height;
+                  }
+                  if ("channels" in options) {
+                    c2 = options.channels;
+                    hasChannels = true;
+                  }
+                }
+                flags.width = w2 | 0;
+                flags.height = h2 | 0;
+                flags.channels = c2 | 0;
+                var hasFormat = false;
+                if ("format" in options) {
+                  var formatStr = options.format;
+                  var internalformat = flags.internalformat = textureFormats[formatStr];
+                  flags.format = colorFormats[internalformat];
+                  if (formatStr in textureTypes) {
+                    if (!("type" in options)) {
+                      flags.type = textureTypes[formatStr];
+                    }
+                  }
+                  if (formatStr in compressedTextureFormats) {
+                    flags.compressed = true;
+                  }
+                  hasFormat = true;
+                }
+                if (!hasChannels && hasFormat) {
+                  flags.channels = FORMAT_CHANNELS[flags.format];
+                } else if (hasChannels && !hasFormat) {
+                  if (flags.channels !== CHANNELS_FORMAT[flags.format]) {
+                    flags.format = flags.internalformat = CHANNELS_FORMAT[flags.channels];
+                  }
+                } else ;
+              }
+              function setFlags(flags) {
+                gl2.pixelStorei(GL_UNPACK_FLIP_Y_WEBGL, flags.flipY);
+                gl2.pixelStorei(GL_UNPACK_PREMULTIPLY_ALPHA_WEBGL, flags.premultiplyAlpha);
+                gl2.pixelStorei(GL_UNPACK_COLORSPACE_CONVERSION_WEBGL, flags.colorSpace);
+                gl2.pixelStorei(GL_UNPACK_ALIGNMENT, flags.unpackAlignment);
+              }
+              function TexImage() {
+                TexFlags.call(this);
+                this.xOffset = 0;
+                this.yOffset = 0;
+                this.data = null;
+                this.needsFree = false;
+                this.element = null;
+                this.needsCopy = false;
+              }
+              function parseImage2(image, options) {
+                var data = null;
+                if (isPixelData(options)) {
+                  data = options;
+                } else if (options) {
+                  parseFlags(image, options);
+                  if ("x" in options) {
+                    image.xOffset = options.x | 0;
+                  }
+                  if ("y" in options) {
+                    image.yOffset = options.y | 0;
+                  }
+                  if (isPixelData(options.data)) {
+                    data = options.data;
+                  }
+                }
+                if (options.copy) {
+                  var viewW = contextState.viewportWidth;
+                  var viewH = contextState.viewportHeight;
+                  image.width = image.width || viewW - image.xOffset;
+                  image.height = image.height || viewH - image.yOffset;
+                  image.needsCopy = true;
+                } else if (!data) {
+                  image.width = image.width || 1;
+                  image.height = image.height || 1;
+                  image.channels = image.channels || 4;
+                } else if (isTypedArray2(data)) {
+                  image.channels = image.channels || 4;
+                  image.data = data;
+                  if (!("type" in options) && image.type === GL_UNSIGNED_BYTE$4) {
+                    image.type = typedArrayCode$1(data);
+                  }
+                } else if (isNumericArray2(data)) {
+                  image.channels = image.channels || 4;
+                  convertData(image, data);
+                  image.alignment = 1;
+                  image.needsFree = true;
+                } else if (isNDArrayLike(data)) {
+                  var array = data.data;
+                  if (!Array.isArray(array) && image.type === GL_UNSIGNED_BYTE$4) {
+                    image.type = typedArrayCode$1(array);
+                  }
+                  var shape = data.shape;
+                  var stride = data.stride;
+                  var shapeX, shapeY, shapeC, strideX, strideY, strideC;
+                  if (shape.length === 3) {
+                    shapeC = shape[2];
+                    strideC = stride[2];
+                  } else {
+                    shapeC = 1;
+                    strideC = 1;
+                  }
+                  shapeX = shape[0];
+                  shapeY = shape[1];
+                  strideX = stride[0];
+                  strideY = stride[1];
+                  image.alignment = 1;
+                  image.width = shapeX;
+                  image.height = shapeY;
+                  image.channels = shapeC;
+                  image.format = image.internalformat = CHANNELS_FORMAT[shapeC];
+                  image.needsFree = true;
+                  transposeData(image, array, strideX, strideY, strideC, data.offset);
+                } else if (isCanvasElement(data) || isOffscreenCanvas(data) || isContext2D(data)) {
+                  if (isCanvasElement(data) || isOffscreenCanvas(data)) {
+                    image.element = data;
+                  } else {
+                    image.element = data.canvas;
+                  }
+                  image.width = image.element.width;
+                  image.height = image.element.height;
+                  image.channels = 4;
+                } else if (isBitmap(data)) {
+                  image.element = data;
+                  image.width = data.width;
+                  image.height = data.height;
+                  image.channels = 4;
+                } else if (isImageElement(data)) {
+                  image.element = data;
+                  image.width = data.naturalWidth;
+                  image.height = data.naturalHeight;
+                  image.channels = 4;
+                } else if (isVideoElement(data)) {
+                  image.element = data;
+                  image.width = data.videoWidth;
+                  image.height = data.videoHeight;
+                  image.channels = 4;
+                } else if (isRectArray(data)) {
+                  var w2 = image.width || data[0].length;
+                  var h2 = image.height || data.length;
+                  var c2 = image.channels;
+                  if (isArrayLike(data[0][0])) {
+                    c2 = c2 || data[0][0].length;
+                  } else {
+                    c2 = c2 || 1;
+                  }
+                  var arrayShape2 = flattenUtils.shape(data);
+                  var n2 = 1;
+                  for (var dd2 = 0; dd2 < arrayShape2.length; ++dd2) {
+                    n2 *= arrayShape2[dd2];
+                  }
+                  var allocData = preConvert(image, n2);
+                  flattenUtils.flatten(data, arrayShape2, "", allocData);
+                  postConvert(image, allocData);
+                  image.alignment = 1;
+                  image.width = w2;
+                  image.height = h2;
+                  image.channels = c2;
+                  image.format = image.internalformat = CHANNELS_FORMAT[c2];
+                  image.needsFree = true;
+                }
+                if (image.type === GL_FLOAT$3) ;
+                else if (image.type === GL_HALF_FLOAT_OES) ;
+              }
+              function setImage(info, target, miplevel) {
+                var element = info.element;
+                var data = info.data;
+                var internalformat = info.internalformat;
+                var format = info.format;
+                var type = info.type;
+                var width = info.width;
+                var height = info.height;
+                setFlags(info);
+                if (element) {
+                  gl2.texImage2D(target, miplevel, format, format, type, element);
+                } else if (info.compressed) {
+                  gl2.compressedTexImage2D(target, miplevel, internalformat, width, height, 0, data);
+                } else if (info.needsCopy) {
+                  reglPoll();
+                  gl2.copyTexImage2D(
+                    target,
+                    miplevel,
+                    format,
+                    info.xOffset,
+                    info.yOffset,
+                    width,
+                    height,
+                    0
+                  );
+                } else {
+                  gl2.texImage2D(target, miplevel, format, width, height, 0, format, type, data || null);
+                }
+              }
+              function setSubImage(info, target, x2, y2, miplevel) {
+                var element = info.element;
+                var data = info.data;
+                var internalformat = info.internalformat;
+                var format = info.format;
+                var type = info.type;
+                var width = info.width;
+                var height = info.height;
+                setFlags(info);
+                if (element) {
+                  gl2.texSubImage2D(
+                    target,
+                    miplevel,
+                    x2,
+                    y2,
+                    format,
+                    type,
+                    element
+                  );
+                } else if (info.compressed) {
+                  gl2.compressedTexSubImage2D(
+                    target,
+                    miplevel,
+                    x2,
+                    y2,
+                    internalformat,
+                    width,
+                    height,
+                    data
+                  );
+                } else if (info.needsCopy) {
+                  reglPoll();
+                  gl2.copyTexSubImage2D(
+                    target,
+                    miplevel,
+                    x2,
+                    y2,
+                    info.xOffset,
+                    info.yOffset,
+                    width,
+                    height
+                  );
+                } else {
+                  gl2.texSubImage2D(
+                    target,
+                    miplevel,
+                    x2,
+                    y2,
+                    width,
+                    height,
+                    format,
+                    type,
+                    data
+                  );
+                }
+              }
+              var imagePool = [];
+              function allocImage() {
+                return imagePool.pop() || new TexImage();
+              }
+              function freeImage(image) {
+                if (image.needsFree) {
+                  pool.freeType(image.data);
+                }
+                TexImage.call(image);
+                imagePool.push(image);
+              }
+              function MipMap() {
+                TexFlags.call(this);
+                this.genMipmaps = false;
+                this.mipmapHint = GL_DONT_CARE;
+                this.mipmask = 0;
+                this.images = Array(16);
+              }
+              function parseMipMapFromShape(mipmap, width, height) {
+                var img = mipmap.images[0] = allocImage();
+                mipmap.mipmask = 1;
+                img.width = mipmap.width = width;
+                img.height = mipmap.height = height;
+                img.channels = mipmap.channels = 4;
+              }
+              function parseMipMapFromObject(mipmap, options) {
+                var imgData = null;
+                if (isPixelData(options)) {
+                  imgData = mipmap.images[0] = allocImage();
+                  copyFlags(imgData, mipmap);
+                  parseImage2(imgData, options);
+                  mipmap.mipmask = 1;
+                } else {
+                  parseFlags(mipmap, options);
+                  if (Array.isArray(options.mipmap)) {
+                    var mipData = options.mipmap;
+                    for (var i2 = 0; i2 < mipData.length; ++i2) {
+                      imgData = mipmap.images[i2] = allocImage();
+                      copyFlags(imgData, mipmap);
+                      imgData.width >>= i2;
+                      imgData.height >>= i2;
+                      parseImage2(imgData, mipData[i2]);
+                      mipmap.mipmask |= 1 << i2;
+                    }
+                  } else {
+                    imgData = mipmap.images[0] = allocImage();
+                    copyFlags(imgData, mipmap);
+                    parseImage2(imgData, options);
+                    mipmap.mipmask = 1;
+                  }
+                }
+                copyFlags(mipmap, mipmap.images[0]);
+                if (mipmap.compressed && (mipmap.internalformat === GL_COMPRESSED_RGB_S3TC_DXT1_EXT || mipmap.internalformat === GL_COMPRESSED_RGBA_S3TC_DXT1_EXT || mipmap.internalformat === GL_COMPRESSED_RGBA_S3TC_DXT3_EXT || mipmap.internalformat === GL_COMPRESSED_RGBA_S3TC_DXT5_EXT)) ;
+              }
+              function setMipMap(mipmap, target) {
+                var images = mipmap.images;
+                for (var i2 = 0; i2 < images.length; ++i2) {
+                  if (!images[i2]) {
+                    return;
+                  }
+                  setImage(images[i2], target, i2);
+                }
+              }
+              var mipPool = [];
+              function allocMipMap() {
+                var result = mipPool.pop() || new MipMap();
+                TexFlags.call(result);
+                result.mipmask = 0;
+                for (var i2 = 0; i2 < 16; ++i2) {
+                  result.images[i2] = null;
+                }
+                return result;
+              }
+              function freeMipMap(mipmap) {
+                var images = mipmap.images;
+                for (var i2 = 0; i2 < images.length; ++i2) {
+                  if (images[i2]) {
+                    freeImage(images[i2]);
+                  }
+                  images[i2] = null;
+                }
+                mipPool.push(mipmap);
+              }
+              function TexInfo() {
+                this.minFilter = GL_NEAREST;
+                this.magFilter = GL_NEAREST;
+                this.wrapS = GL_CLAMP_TO_EDGE;
+                this.wrapT = GL_CLAMP_TO_EDGE;
+                this.anisotropic = 1;
+                this.genMipmaps = false;
+                this.mipmapHint = GL_DONT_CARE;
+              }
+              function parseTexInfo(info, options) {
+                if ("min" in options) {
+                  var minFilter = options.min;
+                  info.minFilter = minFilters[minFilter];
+                  if (MIPMAP_FILTERS.indexOf(info.minFilter) >= 0 && !("faces" in options)) {
+                    info.genMipmaps = true;
+                  }
+                }
+                if ("mag" in options) {
+                  var magFilter = options.mag;
+                  info.magFilter = magFilters[magFilter];
+                }
+                var wrapS = info.wrapS;
+                var wrapT = info.wrapT;
+                if ("wrap" in options) {
+                  var wrap = options.wrap;
+                  if (typeof wrap === "string") {
+                    wrapS = wrapT = wrapModes[wrap];
+                  } else if (Array.isArray(wrap)) {
+                    wrapS = wrapModes[wrap[0]];
+                    wrapT = wrapModes[wrap[1]];
+                  }
+                } else {
+                  if ("wrapS" in options) {
+                    var optWrapS = options.wrapS;
+                    wrapS = wrapModes[optWrapS];
+                  }
+                  if ("wrapT" in options) {
+                    var optWrapT = options.wrapT;
+                    wrapT = wrapModes[optWrapT];
+                  }
+                }
+                info.wrapS = wrapS;
+                info.wrapT = wrapT;
+                if ("anisotropic" in options) {
+                  options.anisotropic;
+                  info.anisotropic = options.anisotropic;
+                }
+                if ("mipmap" in options) {
+                  var hasMipMap = false;
+                  switch (typeof options.mipmap) {
+                    case "string":
+                      info.mipmapHint = mipmapHint[options.mipmap];
+                      info.genMipmaps = true;
+                      hasMipMap = true;
+                      break;
+                    case "boolean":
+                      hasMipMap = info.genMipmaps = options.mipmap;
+                      break;
+                    case "object":
+                      info.genMipmaps = false;
+                      hasMipMap = true;
+                      break;
+                  }
+                  if (hasMipMap && !("min" in options)) {
+                    info.minFilter = GL_NEAREST_MIPMAP_NEAREST;
+                  }
+                }
+              }
+              function setTexInfo(info, target) {
+                gl2.texParameteri(target, GL_TEXTURE_MIN_FILTER, info.minFilter);
+                gl2.texParameteri(target, GL_TEXTURE_MAG_FILTER, info.magFilter);
+                gl2.texParameteri(target, GL_TEXTURE_WRAP_S, info.wrapS);
+                gl2.texParameteri(target, GL_TEXTURE_WRAP_T, info.wrapT);
+                if (extensions.ext_texture_filter_anisotropic) {
+                  gl2.texParameteri(target, GL_TEXTURE_MAX_ANISOTROPY_EXT, info.anisotropic);
+                }
+                if (info.genMipmaps) {
+                  gl2.hint(GL_GENERATE_MIPMAP_HINT, info.mipmapHint);
+                  gl2.generateMipmap(target);
+                }
+              }
+              var textureCount = 0;
+              var textureSet = {};
+              var numTexUnits = limits.maxTextureUnits;
+              var textureUnits = Array(numTexUnits).map(function() {
+                return null;
+              });
+              function REGLTexture(target) {
+                TexFlags.call(this);
+                this.mipmask = 0;
+                this.internalformat = GL_RGBA$1;
+                this.id = textureCount++;
+                this.refCount = 1;
+                this.target = target;
+                this.texture = gl2.createTexture();
+                this.unit = -1;
+                this.bindCount = 0;
+                this.texInfo = new TexInfo();
+                if (config2.profile) {
+                  this.stats = { size: 0 };
+                }
+              }
+              function tempBind(texture) {
+                gl2.activeTexture(GL_TEXTURE0$1);
+                gl2.bindTexture(texture.target, texture.texture);
+              }
+              function tempRestore() {
+                var prev = textureUnits[0];
+                if (prev) {
+                  gl2.bindTexture(prev.target, prev.texture);
+                } else {
+                  gl2.bindTexture(GL_TEXTURE_2D$1, null);
+                }
+              }
+              function destroy(texture) {
+                var handle = texture.texture;
+                var unit = texture.unit;
+                var target = texture.target;
+                if (unit >= 0) {
+                  gl2.activeTexture(GL_TEXTURE0$1 + unit);
+                  gl2.bindTexture(target, null);
+                  textureUnits[unit] = null;
+                }
+                gl2.deleteTexture(handle);
+                texture.texture = null;
+                texture.params = null;
+                texture.pixels = null;
+                texture.refCount = 0;
+                delete textureSet[texture.id];
+                stats2.textureCount--;
+              }
+              extend2(REGLTexture.prototype, {
+                bind: function() {
+                  var texture = this;
+                  texture.bindCount += 1;
+                  var unit = texture.unit;
+                  if (unit < 0) {
+                    for (var i2 = 0; i2 < numTexUnits; ++i2) {
+                      var other = textureUnits[i2];
+                      if (other) {
+                        if (other.bindCount > 0) {
+                          continue;
+                        }
+                        other.unit = -1;
+                      }
+                      textureUnits[i2] = texture;
+                      unit = i2;
+                      break;
+                    }
+                    if (config2.profile && stats2.maxTextureUnits < unit + 1) {
+                      stats2.maxTextureUnits = unit + 1;
+                    }
+                    texture.unit = unit;
+                    gl2.activeTexture(GL_TEXTURE0$1 + unit);
+                    gl2.bindTexture(texture.target, texture.texture);
+                  }
+                  return unit;
+                },
+                unbind: function() {
+                  this.bindCount -= 1;
+                },
+                decRef: function() {
+                  if (--this.refCount <= 0) {
+                    destroy(this);
+                  }
+                }
+              });
+              function createTexture2D(a2, b2) {
+                var texture = new REGLTexture(GL_TEXTURE_2D$1);
+                textureSet[texture.id] = texture;
+                stats2.textureCount++;
+                function reglTexture2D(a22, b22) {
+                  var texInfo = texture.texInfo;
+                  TexInfo.call(texInfo);
+                  var mipData = allocMipMap();
+                  if (typeof a22 === "number") {
+                    if (typeof b22 === "number") {
+                      parseMipMapFromShape(mipData, a22 | 0, b22 | 0);
+                    } else {
+                      parseMipMapFromShape(mipData, a22 | 0, a22 | 0);
+                    }
+                  } else if (a22) {
+                    parseTexInfo(texInfo, a22);
+                    parseMipMapFromObject(mipData, a22);
+                  } else {
+                    parseMipMapFromShape(mipData, 1, 1);
+                  }
+                  if (texInfo.genMipmaps) {
+                    mipData.mipmask = (mipData.width << 1) - 1;
+                  }
+                  texture.mipmask = mipData.mipmask;
+                  copyFlags(texture, mipData);
+                  texture.internalformat = mipData.internalformat;
+                  reglTexture2D.width = mipData.width;
+                  reglTexture2D.height = mipData.height;
+                  tempBind(texture);
+                  setMipMap(mipData, GL_TEXTURE_2D$1);
+                  setTexInfo(texInfo, GL_TEXTURE_2D$1);
+                  tempRestore();
+                  freeMipMap(mipData);
+                  if (config2.profile) {
+                    texture.stats.size = getTextureSize(
+                      texture.internalformat,
+                      texture.type,
+                      mipData.width,
+                      mipData.height,
+                      texInfo.genMipmaps,
+                      false
+                    );
+                  }
+                  reglTexture2D.format = textureFormatsInvert[texture.internalformat];
+                  reglTexture2D.type = textureTypesInvert[texture.type];
+                  reglTexture2D.mag = magFiltersInvert[texInfo.magFilter];
+                  reglTexture2D.min = minFiltersInvert[texInfo.minFilter];
+                  reglTexture2D.wrapS = wrapModesInvert[texInfo.wrapS];
+                  reglTexture2D.wrapT = wrapModesInvert[texInfo.wrapT];
+                  return reglTexture2D;
+                }
+                function subimage(image, x_, y_, level_) {
+                  var x2 = x_ | 0;
+                  var y2 = y_ | 0;
+                  var level = level_ | 0;
+                  var imageData = allocImage();
+                  copyFlags(imageData, texture);
+                  imageData.width = 0;
+                  imageData.height = 0;
+                  parseImage2(imageData, image);
+                  imageData.width = imageData.width || (texture.width >> level) - x2;
+                  imageData.height = imageData.height || (texture.height >> level) - y2;
+                  tempBind(texture);
+                  setSubImage(imageData, GL_TEXTURE_2D$1, x2, y2, level);
+                  tempRestore();
+                  freeImage(imageData);
+                  return reglTexture2D;
+                }
+                function resize(w_, h_) {
+                  var w2 = w_ | 0;
+                  var h2 = h_ | 0 || w2;
+                  if (w2 === texture.width && h2 === texture.height) {
+                    return reglTexture2D;
+                  }
+                  reglTexture2D.width = texture.width = w2;
+                  reglTexture2D.height = texture.height = h2;
+                  tempBind(texture);
+                  for (var i2 = 0; texture.mipmask >> i2; ++i2) {
+                    var _w2 = w2 >> i2;
+                    var _h2 = h2 >> i2;
+                    if (!_w2 || !_h2) break;
+                    gl2.texImage2D(
+                      GL_TEXTURE_2D$1,
+                      i2,
+                      texture.format,
+                      _w2,
+                      _h2,
+                      0,
+                      texture.format,
+                      texture.type,
+                      null
+                    );
+                  }
+                  tempRestore();
+                  if (config2.profile) {
+                    texture.stats.size = getTextureSize(
+                      texture.internalformat,
+                      texture.type,
+                      w2,
+                      h2,
+                      false,
+                      false
+                    );
+                  }
+                  return reglTexture2D;
+                }
+                reglTexture2D(a2, b2);
+                reglTexture2D.subimage = subimage;
+                reglTexture2D.resize = resize;
+                reglTexture2D._reglType = "texture2d";
+                reglTexture2D._texture = texture;
+                if (config2.profile) {
+                  reglTexture2D.stats = texture.stats;
+                }
+                reglTexture2D.destroy = function() {
+                  texture.decRef();
+                };
+                return reglTexture2D;
+              }
+              function createTextureCube(a0, a1, a2, a3, a4, a5) {
+                var texture = new REGLTexture(GL_TEXTURE_CUBE_MAP$1);
+                textureSet[texture.id] = texture;
+                stats2.cubeCount++;
+                var faces = new Array(6);
+                function reglTextureCube(a02, a12, a22, a32, a42, a52) {
+                  var i2;
+                  var texInfo = texture.texInfo;
+                  TexInfo.call(texInfo);
+                  for (i2 = 0; i2 < 6; ++i2) {
+                    faces[i2] = allocMipMap();
+                  }
+                  if (typeof a02 === "number" || !a02) {
+                    var s2 = a02 | 0 || 1;
+                    for (i2 = 0; i2 < 6; ++i2) {
+                      parseMipMapFromShape(faces[i2], s2, s2);
+                    }
+                  } else if (typeof a02 === "object") {
+                    if (a12) {
+                      parseMipMapFromObject(faces[0], a02);
+                      parseMipMapFromObject(faces[1], a12);
+                      parseMipMapFromObject(faces[2], a22);
+                      parseMipMapFromObject(faces[3], a32);
+                      parseMipMapFromObject(faces[4], a42);
+                      parseMipMapFromObject(faces[5], a52);
+                    } else {
+                      parseTexInfo(texInfo, a02);
+                      parseFlags(texture, a02);
+                      if ("faces" in a02) {
+                        var faceInput = a02.faces;
+                        for (i2 = 0; i2 < 6; ++i2) {
+                          copyFlags(faces[i2], texture);
+                          parseMipMapFromObject(faces[i2], faceInput[i2]);
+                        }
+                      } else {
+                        for (i2 = 0; i2 < 6; ++i2) {
+                          parseMipMapFromObject(faces[i2], a02);
+                        }
+                      }
+                    }
+                  } else ;
+                  copyFlags(texture, faces[0]);
+                  if (texInfo.genMipmaps) {
+                    texture.mipmask = (faces[0].width << 1) - 1;
+                  } else {
+                    texture.mipmask = faces[0].mipmask;
+                  }
+                  texture.internalformat = faces[0].internalformat;
+                  reglTextureCube.width = faces[0].width;
+                  reglTextureCube.height = faces[0].height;
+                  tempBind(texture);
+                  for (i2 = 0; i2 < 6; ++i2) {
+                    setMipMap(faces[i2], GL_TEXTURE_CUBE_MAP_POSITIVE_X$1 + i2);
+                  }
+                  setTexInfo(texInfo, GL_TEXTURE_CUBE_MAP$1);
+                  tempRestore();
+                  if (config2.profile) {
+                    texture.stats.size = getTextureSize(
+                      texture.internalformat,
+                      texture.type,
+                      reglTextureCube.width,
+                      reglTextureCube.height,
+                      texInfo.genMipmaps,
+                      true
+                    );
+                  }
+                  reglTextureCube.format = textureFormatsInvert[texture.internalformat];
+                  reglTextureCube.type = textureTypesInvert[texture.type];
+                  reglTextureCube.mag = magFiltersInvert[texInfo.magFilter];
+                  reglTextureCube.min = minFiltersInvert[texInfo.minFilter];
+                  reglTextureCube.wrapS = wrapModesInvert[texInfo.wrapS];
+                  reglTextureCube.wrapT = wrapModesInvert[texInfo.wrapT];
+                  for (i2 = 0; i2 < 6; ++i2) {
+                    freeMipMap(faces[i2]);
+                  }
+                  return reglTextureCube;
+                }
+                function subimage(face, image, x_, y_, level_) {
+                  var x2 = x_ | 0;
+                  var y2 = y_ | 0;
+                  var level = level_ | 0;
+                  var imageData = allocImage();
+                  copyFlags(imageData, texture);
+                  imageData.width = 0;
+                  imageData.height = 0;
+                  parseImage2(imageData, image);
+                  imageData.width = imageData.width || (texture.width >> level) - x2;
+                  imageData.height = imageData.height || (texture.height >> level) - y2;
+                  tempBind(texture);
+                  setSubImage(imageData, GL_TEXTURE_CUBE_MAP_POSITIVE_X$1 + face, x2, y2, level);
+                  tempRestore();
+                  freeImage(imageData);
+                  return reglTextureCube;
+                }
+                function resize(radius_) {
+                  var radius = radius_ | 0;
+                  if (radius === texture.width) {
+                    return;
+                  }
+                  reglTextureCube.width = texture.width = radius;
+                  reglTextureCube.height = texture.height = radius;
+                  tempBind(texture);
+                  for (var i2 = 0; i2 < 6; ++i2) {
+                    for (var j2 = 0; texture.mipmask >> j2; ++j2) {
+                      gl2.texImage2D(
+                        GL_TEXTURE_CUBE_MAP_POSITIVE_X$1 + i2,
+                        j2,
+                        texture.format,
+                        radius >> j2,
+                        radius >> j2,
+                        0,
+                        texture.format,
+                        texture.type,
+                        null
+                      );
+                    }
+                  }
+                  tempRestore();
+                  if (config2.profile) {
+                    texture.stats.size = getTextureSize(
+                      texture.internalformat,
+                      texture.type,
+                      reglTextureCube.width,
+                      reglTextureCube.height,
+                      false,
+                      true
+                    );
+                  }
+                  return reglTextureCube;
+                }
+                reglTextureCube(a0, a1, a2, a3, a4, a5);
+                reglTextureCube.subimage = subimage;
+                reglTextureCube.resize = resize;
+                reglTextureCube._reglType = "textureCube";
+                reglTextureCube._texture = texture;
+                if (config2.profile) {
+                  reglTextureCube.stats = texture.stats;
+                }
+                reglTextureCube.destroy = function() {
+                  texture.decRef();
+                };
+                return reglTextureCube;
+              }
+              function destroyTextures() {
+                for (var i2 = 0; i2 < numTexUnits; ++i2) {
+                  gl2.activeTexture(GL_TEXTURE0$1 + i2);
+                  gl2.bindTexture(GL_TEXTURE_2D$1, null);
+                  textureUnits[i2] = null;
+                }
+                values(textureSet).forEach(destroy);
+                stats2.cubeCount = 0;
+                stats2.textureCount = 0;
+              }
+              if (config2.profile) {
+                stats2.getTotalTextureSize = function() {
+                  var total = 0;
+                  Object.keys(textureSet).forEach(function(key) {
+                    total += textureSet[key].stats.size;
+                  });
+                  return total;
+                };
+              }
+              function restoreTextures() {
+                for (var i2 = 0; i2 < numTexUnits; ++i2) {
+                  var tex = textureUnits[i2];
+                  if (tex) {
+                    tex.bindCount = 0;
+                    tex.unit = -1;
+                    textureUnits[i2] = null;
+                  }
+                }
+                values(textureSet).forEach(function(texture) {
+                  texture.texture = gl2.createTexture();
+                  gl2.bindTexture(texture.target, texture.texture);
+                  for (var i22 = 0; i22 < 32; ++i22) {
+                    if ((texture.mipmask & 1 << i22) === 0) {
+                      continue;
+                    }
+                    if (texture.target === GL_TEXTURE_2D$1) {
+                      gl2.texImage2D(
+                        GL_TEXTURE_2D$1,
+                        i22,
+                        texture.internalformat,
+                        texture.width >> i22,
+                        texture.height >> i22,
+                        0,
+                        texture.internalformat,
+                        texture.type,
+                        null
+                      );
+                    } else {
+                      for (var j2 = 0; j2 < 6; ++j2) {
+                        gl2.texImage2D(
+                          GL_TEXTURE_CUBE_MAP_POSITIVE_X$1 + j2,
+                          i22,
+                          texture.internalformat,
+                          texture.width >> i22,
+                          texture.height >> i22,
+                          0,
+                          texture.internalformat,
+                          texture.type,
+                          null
+                        );
+                      }
+                    }
+                  }
+                  setTexInfo(texture.texInfo, texture.target);
+                });
+              }
+              function refreshTextures() {
+                for (var i2 = 0; i2 < numTexUnits; ++i2) {
+                  var tex = textureUnits[i2];
+                  if (tex) {
+                    tex.bindCount = 0;
+                    tex.unit = -1;
+                    textureUnits[i2] = null;
+                  }
+                  gl2.activeTexture(GL_TEXTURE0$1 + i2);
+                  gl2.bindTexture(GL_TEXTURE_2D$1, null);
+                  gl2.bindTexture(GL_TEXTURE_CUBE_MAP$1, null);
+                }
+              }
+              return {
+                create2D: createTexture2D,
+                createCube: createTextureCube,
+                clear: destroyTextures,
+                getTexture: function(wrapper) {
+                  return null;
+                },
+                restore: restoreTextures,
+                refresh: refreshTextures
+              };
+            }
+            var GL_RENDERBUFFER = 36161;
+            var GL_RGBA4$1 = 32854;
+            var GL_RGB5_A1$1 = 32855;
+            var GL_RGB565$1 = 36194;
+            var GL_DEPTH_COMPONENT16 = 33189;
+            var GL_STENCIL_INDEX8 = 36168;
+            var GL_DEPTH_STENCIL$1 = 34041;
+            var GL_SRGB8_ALPHA8_EXT = 35907;
+            var GL_RGBA32F_EXT = 34836;
+            var GL_RGBA16F_EXT = 34842;
+            var GL_RGB16F_EXT = 34843;
+            var FORMAT_SIZES = [];
+            FORMAT_SIZES[GL_RGBA4$1] = 2;
+            FORMAT_SIZES[GL_RGB5_A1$1] = 2;
+            FORMAT_SIZES[GL_RGB565$1] = 2;
+            FORMAT_SIZES[GL_DEPTH_COMPONENT16] = 2;
+            FORMAT_SIZES[GL_STENCIL_INDEX8] = 1;
+            FORMAT_SIZES[GL_DEPTH_STENCIL$1] = 4;
+            FORMAT_SIZES[GL_SRGB8_ALPHA8_EXT] = 4;
+            FORMAT_SIZES[GL_RGBA32F_EXT] = 16;
+            FORMAT_SIZES[GL_RGBA16F_EXT] = 8;
+            FORMAT_SIZES[GL_RGB16F_EXT] = 6;
+            function getRenderbufferSize(format, width, height) {
+              return FORMAT_SIZES[format] * width * height;
+            }
+            var wrapRenderbuffers = function(gl2, extensions, limits, stats2, config2) {
+              var formatTypes = {
+                "rgba4": GL_RGBA4$1,
+                "rgb565": GL_RGB565$1,
+                "rgb5 a1": GL_RGB5_A1$1,
+                "depth": GL_DEPTH_COMPONENT16,
+                "stencil": GL_STENCIL_INDEX8,
+                "depth stencil": GL_DEPTH_STENCIL$1
+              };
+              if (extensions.ext_srgb) {
+                formatTypes["srgba"] = GL_SRGB8_ALPHA8_EXT;
+              }
+              if (extensions.ext_color_buffer_half_float) {
+                formatTypes["rgba16f"] = GL_RGBA16F_EXT;
+                formatTypes["rgb16f"] = GL_RGB16F_EXT;
+              }
+              if (extensions.webgl_color_buffer_float) {
+                formatTypes["rgba32f"] = GL_RGBA32F_EXT;
+              }
+              var formatTypesInvert = [];
+              Object.keys(formatTypes).forEach(function(key) {
+                var val = formatTypes[key];
+                formatTypesInvert[val] = key;
+              });
+              var renderbufferCount = 0;
+              var renderbufferSet = {};
+              function REGLRenderbuffer(renderbuffer) {
+                this.id = renderbufferCount++;
+                this.refCount = 1;
+                this.renderbuffer = renderbuffer;
+                this.format = GL_RGBA4$1;
+                this.width = 0;
+                this.height = 0;
+                if (config2.profile) {
+                  this.stats = { size: 0 };
+                }
+              }
+              REGLRenderbuffer.prototype.decRef = function() {
+                if (--this.refCount <= 0) {
+                  destroy(this);
+                }
+              };
+              function destroy(rb2) {
+                var handle = rb2.renderbuffer;
+                gl2.bindRenderbuffer(GL_RENDERBUFFER, null);
+                gl2.deleteRenderbuffer(handle);
+                rb2.renderbuffer = null;
+                rb2.refCount = 0;
+                delete renderbufferSet[rb2.id];
+                stats2.renderbufferCount--;
+              }
+              function createRenderbuffer(a2, b2) {
+                var renderbuffer = new REGLRenderbuffer(gl2.createRenderbuffer());
+                renderbufferSet[renderbuffer.id] = renderbuffer;
+                stats2.renderbufferCount++;
+                function reglRenderbuffer(a22, b22) {
+                  var w2 = 0;
+                  var h2 = 0;
+                  var format = GL_RGBA4$1;
+                  if (typeof a22 === "object" && a22) {
+                    var options = a22;
+                    if ("shape" in options) {
+                      var shape = options.shape;
+                      w2 = shape[0] | 0;
+                      h2 = shape[1] | 0;
+                    } else {
+                      if ("radius" in options) {
+                        w2 = h2 = options.radius | 0;
+                      }
+                      if ("width" in options) {
+                        w2 = options.width | 0;
+                      }
+                      if ("height" in options) {
+                        h2 = options.height | 0;
+                      }
+                    }
+                    if ("format" in options) {
+                      format = formatTypes[options.format];
+                    }
+                  } else if (typeof a22 === "number") {
+                    w2 = a22 | 0;
+                    if (typeof b22 === "number") {
+                      h2 = b22 | 0;
+                    } else {
+                      h2 = w2;
+                    }
+                  } else if (!a22) {
+                    w2 = h2 = 1;
+                  } else ;
+                  if (w2 === renderbuffer.width && h2 === renderbuffer.height && format === renderbuffer.format) {
+                    return;
+                  }
+                  reglRenderbuffer.width = renderbuffer.width = w2;
+                  reglRenderbuffer.height = renderbuffer.height = h2;
+                  renderbuffer.format = format;
+                  gl2.bindRenderbuffer(GL_RENDERBUFFER, renderbuffer.renderbuffer);
+                  gl2.renderbufferStorage(GL_RENDERBUFFER, format, w2, h2);
+                  if (config2.profile) {
+                    renderbuffer.stats.size = getRenderbufferSize(renderbuffer.format, renderbuffer.width, renderbuffer.height);
+                  }
+                  reglRenderbuffer.format = formatTypesInvert[renderbuffer.format];
+                  return reglRenderbuffer;
+                }
+                function resize(w_, h_) {
+                  var w2 = w_ | 0;
+                  var h2 = h_ | 0 || w2;
+                  if (w2 === renderbuffer.width && h2 === renderbuffer.height) {
+                    return reglRenderbuffer;
+                  }
+                  reglRenderbuffer.width = renderbuffer.width = w2;
+                  reglRenderbuffer.height = renderbuffer.height = h2;
+                  gl2.bindRenderbuffer(GL_RENDERBUFFER, renderbuffer.renderbuffer);
+                  gl2.renderbufferStorage(GL_RENDERBUFFER, renderbuffer.format, w2, h2);
+                  if (config2.profile) {
+                    renderbuffer.stats.size = getRenderbufferSize(
+                      renderbuffer.format,
+                      renderbuffer.width,
+                      renderbuffer.height
+                    );
+                  }
+                  return reglRenderbuffer;
+                }
+                reglRenderbuffer(a2, b2);
+                reglRenderbuffer.resize = resize;
+                reglRenderbuffer._reglType = "renderbuffer";
+                reglRenderbuffer._renderbuffer = renderbuffer;
+                if (config2.profile) {
+                  reglRenderbuffer.stats = renderbuffer.stats;
+                }
+                reglRenderbuffer.destroy = function() {
+                  renderbuffer.decRef();
+                };
+                return reglRenderbuffer;
+              }
+              if (config2.profile) {
+                stats2.getTotalRenderbufferSize = function() {
+                  var total = 0;
+                  Object.keys(renderbufferSet).forEach(function(key) {
+                    total += renderbufferSet[key].stats.size;
+                  });
+                  return total;
+                };
+              }
+              function restoreRenderbuffers() {
+                values(renderbufferSet).forEach(function(rb2) {
+                  rb2.renderbuffer = gl2.createRenderbuffer();
+                  gl2.bindRenderbuffer(GL_RENDERBUFFER, rb2.renderbuffer);
+                  gl2.renderbufferStorage(GL_RENDERBUFFER, rb2.format, rb2.width, rb2.height);
+                });
+                gl2.bindRenderbuffer(GL_RENDERBUFFER, null);
+              }
+              return {
+                create: createRenderbuffer,
+                clear: function() {
+                  values(renderbufferSet).forEach(destroy);
+                },
+                restore: restoreRenderbuffers
+              };
+            };
+            var GL_FRAMEBUFFER$1 = 36160;
+            var GL_RENDERBUFFER$1 = 36161;
+            var GL_TEXTURE_2D$2 = 3553;
+            var GL_TEXTURE_CUBE_MAP_POSITIVE_X$2 = 34069;
+            var GL_COLOR_ATTACHMENT0$1 = 36064;
+            var GL_DEPTH_ATTACHMENT = 36096;
+            var GL_STENCIL_ATTACHMENT = 36128;
+            var GL_DEPTH_STENCIL_ATTACHMENT = 33306;
+            var GL_FRAMEBUFFER_COMPLETE$1 = 36053;
+            var GL_HALF_FLOAT_OES$1 = 36193;
+            var GL_UNSIGNED_BYTE$5 = 5121;
+            var GL_FLOAT$4 = 5126;
+            var GL_RGB$1 = 6407;
+            var GL_RGBA$2 = 6408;
+            var textureFormatChannels = [];
+            textureFormatChannels[GL_RGBA$2] = 4;
+            textureFormatChannels[GL_RGB$1] = 3;
+            var textureTypeSizes = [];
+            textureTypeSizes[GL_UNSIGNED_BYTE$5] = 1;
+            textureTypeSizes[GL_FLOAT$4] = 4;
+            textureTypeSizes[GL_HALF_FLOAT_OES$1] = 2;
+            function wrapFBOState(gl2, extensions, limits, textureState, renderbufferState, stats2) {
+              var framebufferState = {
+                cur: null,
+                next: null,
+                dirty: false,
+                setFBO: null
+              };
+              var colorTextureFormats = ["rgba"];
+              var colorRenderbufferFormats = ["rgba4", "rgb565", "rgb5 a1"];
+              if (extensions.ext_srgb) {
+                colorRenderbufferFormats.push("srgba");
+              }
+              if (extensions.ext_color_buffer_half_float) {
+                colorRenderbufferFormats.push("rgba16f", "rgb16f");
+              }
+              if (extensions.webgl_color_buffer_float) {
+                colorRenderbufferFormats.push("rgba32f");
+              }
+              if (extensions.oes_texture_half_float) ;
+              if (extensions.oes_texture_float) ;
+              function FramebufferAttachment(target, texture, renderbuffer) {
+                this.target = target;
+                this.texture = texture;
+                this.renderbuffer = renderbuffer;
+                var w2 = 0;
+                var h2 = 0;
+                if (texture) {
+                  w2 = texture.width;
+                  h2 = texture.height;
+                } else if (renderbuffer) {
+                  w2 = renderbuffer.width;
+                  h2 = renderbuffer.height;
+                }
+                this.width = w2;
+                this.height = h2;
+              }
+              function decRef(attachment) {
+                if (attachment) {
+                  if (attachment.texture) {
+                    attachment.texture._texture.decRef();
+                  }
+                  if (attachment.renderbuffer) {
+                    attachment.renderbuffer._renderbuffer.decRef();
+                  }
+                }
+              }
+              function incRefAndCheckShape(attachment, width, height) {
+                if (!attachment) {
+                  return;
+                }
+                if (attachment.texture) {
+                  var texture = attachment.texture._texture;
+                  Math.max(1, texture.width);
+                  Math.max(1, texture.height);
+                  texture.refCount += 1;
+                } else {
+                  var renderbuffer = attachment.renderbuffer._renderbuffer;
+                  renderbuffer.refCount += 1;
+                }
+              }
+              function attach(location2, attachment) {
+                if (attachment) {
+                  if (attachment.texture) {
+                    gl2.framebufferTexture2D(
+                      GL_FRAMEBUFFER$1,
+                      location2,
+                      attachment.target,
+                      attachment.texture._texture.texture,
+                      0
+                    );
+                  } else {
+                    gl2.framebufferRenderbuffer(
+                      GL_FRAMEBUFFER$1,
+                      location2,
+                      GL_RENDERBUFFER$1,
+                      attachment.renderbuffer._renderbuffer.renderbuffer
+                    );
+                  }
+                }
+              }
+              function parseAttachment(attachment) {
+                var target = GL_TEXTURE_2D$2;
+                var texture = null;
+                var renderbuffer = null;
+                var data = attachment;
+                if (typeof attachment === "object") {
+                  data = attachment.data;
+                  if ("target" in attachment) {
+                    target = attachment.target | 0;
+                  }
+                }
+                var type = data._reglType;
+                if (type === "texture2d") {
+                  texture = data;
+                } else if (type === "textureCube") {
+                  texture = data;
+                } else if (type === "renderbuffer") {
+                  renderbuffer = data;
+                  target = GL_RENDERBUFFER$1;
+                } else ;
+                return new FramebufferAttachment(target, texture, renderbuffer);
+              }
+              function allocAttachment(width, height, isTexture, format, type) {
+                if (isTexture) {
+                  var texture = textureState.create2D({
+                    width,
+                    height,
+                    format,
+                    type
+                  });
+                  texture._texture.refCount = 0;
+                  return new FramebufferAttachment(GL_TEXTURE_2D$2, texture, null);
+                } else {
+                  var rb2 = renderbufferState.create({
+                    width,
+                    height,
+                    format
+                  });
+                  rb2._renderbuffer.refCount = 0;
+                  return new FramebufferAttachment(GL_RENDERBUFFER$1, null, rb2);
+                }
+              }
+              function unwrapAttachment(attachment) {
+                return attachment && (attachment.texture || attachment.renderbuffer);
+              }
+              function resizeAttachment(attachment, w2, h2) {
+                if (attachment) {
+                  if (attachment.texture) {
+                    attachment.texture.resize(w2, h2);
+                  } else if (attachment.renderbuffer) {
+                    attachment.renderbuffer.resize(w2, h2);
+                  }
+                  attachment.width = w2;
+                  attachment.height = h2;
+                }
+              }
+              var framebufferCount = 0;
+              var framebufferSet = {};
+              function REGLFramebuffer() {
+                this.id = framebufferCount++;
+                framebufferSet[this.id] = this;
+                this.framebuffer = gl2.createFramebuffer();
+                this.width = 0;
+                this.height = 0;
+                this.colorAttachments = [];
+                this.depthAttachment = null;
+                this.stencilAttachment = null;
+                this.depthStencilAttachment = null;
+              }
+              function decFBORefs(framebuffer) {
+                framebuffer.colorAttachments.forEach(decRef);
+                decRef(framebuffer.depthAttachment);
+                decRef(framebuffer.stencilAttachment);
+                decRef(framebuffer.depthStencilAttachment);
+              }
+              function destroy(framebuffer) {
+                var handle = framebuffer.framebuffer;
+                gl2.deleteFramebuffer(handle);
+                framebuffer.framebuffer = null;
+                stats2.framebufferCount--;
+                delete framebufferSet[framebuffer.id];
+              }
+              function updateFramebuffer(framebuffer) {
+                var i2;
+                gl2.bindFramebuffer(GL_FRAMEBUFFER$1, framebuffer.framebuffer);
+                var colorAttachments = framebuffer.colorAttachments;
+                for (i2 = 0; i2 < colorAttachments.length; ++i2) {
+                  attach(GL_COLOR_ATTACHMENT0$1 + i2, colorAttachments[i2]);
+                }
+                for (i2 = colorAttachments.length; i2 < limits.maxColorAttachments; ++i2) {
+                  gl2.framebufferTexture2D(
+                    GL_FRAMEBUFFER$1,
+                    GL_COLOR_ATTACHMENT0$1 + i2,
+                    GL_TEXTURE_2D$2,
+                    null,
+                    0
+                  );
+                }
+                gl2.framebufferTexture2D(
+                  GL_FRAMEBUFFER$1,
+                  GL_DEPTH_STENCIL_ATTACHMENT,
+                  GL_TEXTURE_2D$2,
+                  null,
+                  0
+                );
+                gl2.framebufferTexture2D(
+                  GL_FRAMEBUFFER$1,
+                  GL_DEPTH_ATTACHMENT,
+                  GL_TEXTURE_2D$2,
+                  null,
+                  0
+                );
+                gl2.framebufferTexture2D(
+                  GL_FRAMEBUFFER$1,
+                  GL_STENCIL_ATTACHMENT,
+                  GL_TEXTURE_2D$2,
+                  null,
+                  0
+                );
+                attach(GL_DEPTH_ATTACHMENT, framebuffer.depthAttachment);
+                attach(GL_STENCIL_ATTACHMENT, framebuffer.stencilAttachment);
+                attach(GL_DEPTH_STENCIL_ATTACHMENT, framebuffer.depthStencilAttachment);
+                var status = gl2.checkFramebufferStatus(GL_FRAMEBUFFER$1);
+                if (!gl2.isContextLost() && status !== GL_FRAMEBUFFER_COMPLETE$1) ;
+                gl2.bindFramebuffer(GL_FRAMEBUFFER$1, framebufferState.next ? framebufferState.next.framebuffer : null);
+                framebufferState.cur = framebufferState.next;
+                gl2.getError();
+              }
+              function createFBO(a0, a1) {
+                var framebuffer = new REGLFramebuffer();
+                stats2.framebufferCount++;
+                function reglFramebuffer(a2, b2) {
+                  var i2;
+                  var width = 0;
+                  var height = 0;
+                  var needsDepth = true;
+                  var needsStencil = true;
+                  var colorBuffer = null;
+                  var colorTexture = true;
+                  var colorFormat = "rgba";
+                  var colorType = "uint8";
+                  var colorCount = 1;
+                  var depthBuffer = null;
+                  var stencilBuffer = null;
+                  var depthStencilBuffer = null;
+                  var depthStencilTexture = false;
+                  if (typeof a2 === "number") {
+                    width = a2 | 0;
+                    height = b2 | 0 || width;
+                  } else if (!a2) {
+                    width = height = 1;
+                  } else {
+                    var options = a2;
+                    if ("shape" in options) {
+                      var shape = options.shape;
+                      width = shape[0];
+                      height = shape[1];
+                    } else {
+                      if ("radius" in options) {
+                        width = height = options.radius;
+                      }
+                      if ("width" in options) {
+                        width = options.width;
+                      }
+                      if ("height" in options) {
+                        height = options.height;
+                      }
+                    }
+                    if ("color" in options || "colors" in options) {
+                      colorBuffer = options.color || options.colors;
+                    }
+                    if (!colorBuffer) {
+                      if ("colorCount" in options) {
+                        colorCount = options.colorCount | 0;
+                      }
+                      if ("colorTexture" in options) {
+                        colorTexture = !!options.colorTexture;
+                        colorFormat = "rgba4";
+                      }
+                      if ("colorType" in options) {
+                        colorType = options.colorType;
+                        if (!colorTexture) {
+                          if (colorType === "half float" || colorType === "float16") {
+                            colorFormat = "rgba16f";
+                          } else if (colorType === "float" || colorType === "float32") {
+                            colorFormat = "rgba32f";
+                          }
+                        }
+                      }
+                      if ("colorFormat" in options) {
+                        colorFormat = options.colorFormat;
+                        if (colorTextureFormats.indexOf(colorFormat) >= 0) {
+                          colorTexture = true;
+                        } else if (colorRenderbufferFormats.indexOf(colorFormat) >= 0) {
+                          colorTexture = false;
+                        } else ;
+                      }
+                    }
+                    if ("depthTexture" in options || "depthStencilTexture" in options) {
+                      depthStencilTexture = !!(options.depthTexture || options.depthStencilTexture);
+                    }
+                    if ("depth" in options) {
+                      if (typeof options.depth === "boolean") {
+                        needsDepth = options.depth;
+                      } else {
+                        depthBuffer = options.depth;
+                        needsStencil = false;
+                      }
+                    }
+                    if ("stencil" in options) {
+                      if (typeof options.stencil === "boolean") {
+                        needsStencil = options.stencil;
+                      } else {
+                        stencilBuffer = options.stencil;
+                        needsDepth = false;
+                      }
+                    }
+                    if ("depthStencil" in options) {
+                      if (typeof options.depthStencil === "boolean") {
+                        needsDepth = needsStencil = options.depthStencil;
+                      } else {
+                        depthStencilBuffer = options.depthStencil;
+                        needsDepth = false;
+                        needsStencil = false;
+                      }
+                    }
+                  }
+                  var colorAttachments = null;
+                  var depthAttachment = null;
+                  var stencilAttachment = null;
+                  var depthStencilAttachment = null;
+                  if (Array.isArray(colorBuffer)) {
+                    colorAttachments = colorBuffer.map(parseAttachment);
+                  } else if (colorBuffer) {
+                    colorAttachments = [parseAttachment(colorBuffer)];
+                  } else {
+                    colorAttachments = new Array(colorCount);
+                    for (i2 = 0; i2 < colorCount; ++i2) {
+                      colorAttachments[i2] = allocAttachment(
+                        width,
+                        height,
+                        colorTexture,
+                        colorFormat,
+                        colorType
+                      );
+                    }
+                  }
+                  width = width || colorAttachments[0].width;
+                  height = height || colorAttachments[0].height;
+                  if (depthBuffer) {
+                    depthAttachment = parseAttachment(depthBuffer);
+                  } else if (needsDepth && !needsStencil) {
+                    depthAttachment = allocAttachment(
+                      width,
+                      height,
+                      depthStencilTexture,
+                      "depth",
+                      "uint32"
+                    );
+                  }
+                  if (stencilBuffer) {
+                    stencilAttachment = parseAttachment(stencilBuffer);
+                  } else if (needsStencil && !needsDepth) {
+                    stencilAttachment = allocAttachment(
+                      width,
+                      height,
+                      false,
+                      "stencil",
+                      "uint8"
+                    );
+                  }
+                  if (depthStencilBuffer) {
+                    depthStencilAttachment = parseAttachment(depthStencilBuffer);
+                  } else if (!depthBuffer && !stencilBuffer && needsStencil && needsDepth) {
+                    depthStencilAttachment = allocAttachment(
+                      width,
+                      height,
+                      depthStencilTexture,
+                      "depth stencil",
+                      "depth stencil"
+                    );
+                  }
+                  for (i2 = 0; i2 < colorAttachments.length; ++i2) {
+                    incRefAndCheckShape(colorAttachments[i2]);
+                    if (colorAttachments[i2] && colorAttachments[i2].texture) {
+                      textureFormatChannels[colorAttachments[i2].texture._texture.format] * textureTypeSizes[colorAttachments[i2].texture._texture.type];
+                    }
+                  }
+                  incRefAndCheckShape(depthAttachment);
+                  incRefAndCheckShape(stencilAttachment);
+                  incRefAndCheckShape(depthStencilAttachment);
+                  decFBORefs(framebuffer);
+                  framebuffer.width = width;
+                  framebuffer.height = height;
+                  framebuffer.colorAttachments = colorAttachments;
+                  framebuffer.depthAttachment = depthAttachment;
+                  framebuffer.stencilAttachment = stencilAttachment;
+                  framebuffer.depthStencilAttachment = depthStencilAttachment;
+                  reglFramebuffer.color = colorAttachments.map(unwrapAttachment);
+                  reglFramebuffer.depth = unwrapAttachment(depthAttachment);
+                  reglFramebuffer.stencil = unwrapAttachment(stencilAttachment);
+                  reglFramebuffer.depthStencil = unwrapAttachment(depthStencilAttachment);
+                  reglFramebuffer.width = framebuffer.width;
+                  reglFramebuffer.height = framebuffer.height;
+                  updateFramebuffer(framebuffer);
+                  return reglFramebuffer;
+                }
+                function resize(w_, h_) {
+                  var w2 = Math.max(w_ | 0, 1);
+                  var h2 = Math.max(h_ | 0 || w2, 1);
+                  if (w2 === framebuffer.width && h2 === framebuffer.height) {
+                    return reglFramebuffer;
+                  }
+                  var colorAttachments = framebuffer.colorAttachments;
+                  for (var i2 = 0; i2 < colorAttachments.length; ++i2) {
+                    resizeAttachment(colorAttachments[i2], w2, h2);
+                  }
+                  resizeAttachment(framebuffer.depthAttachment, w2, h2);
+                  resizeAttachment(framebuffer.stencilAttachment, w2, h2);
+                  resizeAttachment(framebuffer.depthStencilAttachment, w2, h2);
+                  framebuffer.width = reglFramebuffer.width = w2;
+                  framebuffer.height = reglFramebuffer.height = h2;
+                  updateFramebuffer(framebuffer);
+                  return reglFramebuffer;
+                }
+                reglFramebuffer(a0, a1);
+                return extend2(reglFramebuffer, {
+                  resize,
+                  _reglType: "framebuffer",
+                  _framebuffer: framebuffer,
+                  destroy: function() {
+                    destroy(framebuffer);
+                    decFBORefs(framebuffer);
+                  },
+                  use: function(block) {
+                    framebufferState.setFBO({
+                      framebuffer: reglFramebuffer
+                    }, block);
+                  }
+                });
+              }
+              function createCubeFBO(options) {
+                var faces = Array(6);
+                function reglFramebufferCube(a2) {
+                  var i2;
+                  var params = {
+                    color: null
+                  };
+                  var radius = 0;
+                  var colorBuffer = null;
+                  var colorFormat = "rgba";
+                  var colorType = "uint8";
+                  var colorCount = 1;
+                  if (typeof a2 === "number") {
+                    radius = a2 | 0;
+                  } else if (!a2) {
+                    radius = 1;
+                  } else {
+                    var options2 = a2;
+                    if ("shape" in options2) {
+                      var shape = options2.shape;
+                      radius = shape[0];
+                    } else {
+                      if ("radius" in options2) {
+                        radius = options2.radius | 0;
+                      }
+                      if ("width" in options2) {
+                        radius = options2.width | 0;
+                      } else if ("height" in options2) {
+                        radius = options2.height | 0;
+                      }
+                    }
+                    if ("color" in options2 || "colors" in options2) {
+                      colorBuffer = options2.color || options2.colors;
+                    }
+                    if (!colorBuffer) {
+                      if ("colorCount" in options2) {
+                        colorCount = options2.colorCount | 0;
+                      }
+                      if ("colorType" in options2) {
+                        colorType = options2.colorType;
+                      }
+                      if ("colorFormat" in options2) {
+                        colorFormat = options2.colorFormat;
+                      }
+                    }
+                    if ("depth" in options2) {
+                      params.depth = options2.depth;
+                    }
+                    if ("stencil" in options2) {
+                      params.stencil = options2.stencil;
+                    }
+                    if ("depthStencil" in options2) {
+                      params.depthStencil = options2.depthStencil;
+                    }
+                  }
+                  var colorCubes;
+                  if (colorBuffer) {
+                    if (Array.isArray(colorBuffer)) {
+                      colorCubes = [];
+                      for (i2 = 0; i2 < colorBuffer.length; ++i2) {
+                        colorCubes[i2] = colorBuffer[i2];
+                      }
+                    } else {
+                      colorCubes = [colorBuffer];
+                    }
+                  } else {
+                    colorCubes = Array(colorCount);
+                    var cubeMapParams = {
+                      radius,
+                      format: colorFormat,
+                      type: colorType
+                    };
+                    for (i2 = 0; i2 < colorCount; ++i2) {
+                      colorCubes[i2] = textureState.createCube(cubeMapParams);
+                    }
+                  }
+                  params.color = Array(colorCubes.length);
+                  for (i2 = 0; i2 < colorCubes.length; ++i2) {
+                    var cube = colorCubes[i2];
+                    radius = radius || cube.width;
+                    params.color[i2] = {
+                      target: GL_TEXTURE_CUBE_MAP_POSITIVE_X$2,
+                      data: colorCubes[i2]
+                    };
+                  }
+                  for (i2 = 0; i2 < 6; ++i2) {
+                    for (var j2 = 0; j2 < colorCubes.length; ++j2) {
+                      params.color[j2].target = GL_TEXTURE_CUBE_MAP_POSITIVE_X$2 + i2;
+                    }
+                    if (i2 > 0) {
+                      params.depth = faces[0].depth;
+                      params.stencil = faces[0].stencil;
+                      params.depthStencil = faces[0].depthStencil;
+                    }
+                    if (faces[i2]) {
+                      faces[i2](params);
+                    } else {
+                      faces[i2] = createFBO(params);
+                    }
+                  }
+                  return extend2(reglFramebufferCube, {
+                    width: radius,
+                    height: radius,
+                    color: colorCubes
+                  });
+                }
+                function resize(radius_) {
+                  var i2;
+                  var radius = radius_ | 0;
+                  if (radius === reglFramebufferCube.width) {
+                    return reglFramebufferCube;
+                  }
+                  var colors = reglFramebufferCube.color;
+                  for (i2 = 0; i2 < colors.length; ++i2) {
+                    colors[i2].resize(radius);
+                  }
+                  for (i2 = 0; i2 < 6; ++i2) {
+                    faces[i2].resize(radius);
+                  }
+                  reglFramebufferCube.width = reglFramebufferCube.height = radius;
+                  return reglFramebufferCube;
+                }
+                reglFramebufferCube(options);
+                return extend2(reglFramebufferCube, {
+                  faces,
+                  resize,
+                  _reglType: "framebufferCube",
+                  destroy: function() {
+                    faces.forEach(function(f2) {
+                      f2.destroy();
+                    });
+                  }
+                });
+              }
+              function restoreFramebuffers() {
+                framebufferState.cur = null;
+                framebufferState.next = null;
+                framebufferState.dirty = true;
+                values(framebufferSet).forEach(function(fb2) {
+                  fb2.framebuffer = gl2.createFramebuffer();
+                  updateFramebuffer(fb2);
+                });
+              }
+              return extend2(framebufferState, {
+                getFramebuffer: function(object) {
+                  if (typeof object === "function" && object._reglType === "framebuffer") {
+                    var fbo = object._framebuffer;
+                    if (fbo instanceof REGLFramebuffer) {
+                      return fbo;
+                    }
+                  }
+                  return null;
+                },
+                create: createFBO,
+                createCube: createCubeFBO,
+                clear: function() {
+                  values(framebufferSet).forEach(destroy);
+                },
+                restore: restoreFramebuffers
+              });
+            }
+            var GL_FLOAT$5 = 5126;
+            var GL_ARRAY_BUFFER$1 = 34962;
+            var GL_ELEMENT_ARRAY_BUFFER$1 = 34963;
+            function AttributeRecord() {
+              this.state = 0;
+              this.x = 0;
+              this.y = 0;
+              this.z = 0;
+              this.w = 0;
+              this.buffer = null;
+              this.size = 0;
+              this.normalized = false;
+              this.type = GL_FLOAT$5;
+              this.offset = 0;
+              this.stride = 0;
+              this.divisor = 0;
+            }
+            function wrapAttributeState(gl2, extensions, limits, stats2, bufferState, elementState, drawState) {
+              var NUM_ATTRIBUTES = limits.maxAttributes;
+              var attributeBindings = new Array(NUM_ATTRIBUTES);
+              for (var i2 = 0; i2 < NUM_ATTRIBUTES; ++i2) {
+                attributeBindings[i2] = new AttributeRecord();
+              }
+              var vaoCount = 0;
+              var vaoSet = {};
+              var state = {
+                Record: AttributeRecord,
+                scope: {},
+                state: attributeBindings,
+                currentVAO: null,
+                targetVAO: null,
+                restore: extVAO() ? restoreVAO : function() {
+                },
+                createVAO,
+                getVAO,
+                destroyBuffer,
+                setVAO: extVAO() ? setVAOEXT : setVAOEmulated,
+                clear: extVAO() ? destroyVAOEXT : function() {
+                }
+              };
+              function destroyBuffer(buffer) {
+                for (var i22 = 0; i22 < attributeBindings.length; ++i22) {
+                  var record = attributeBindings[i22];
+                  if (record.buffer === buffer) {
+                    gl2.disableVertexAttribArray(i22);
+                    record.buffer = null;
+                  }
+                }
+              }
+              function extVAO() {
+                return extensions.oes_vertex_array_object;
+              }
+              function extInstanced() {
+                return extensions.angle_instanced_arrays;
+              }
+              function getVAO(vao) {
+                if (typeof vao === "function" && vao._vao) {
+                  return vao._vao;
+                }
+                return null;
+              }
+              function setVAOEXT(vao) {
+                if (vao === state.currentVAO) {
+                  return;
+                }
+                var ext = extVAO();
+                if (vao) {
+                  ext.bindVertexArrayOES(vao.vao);
+                } else {
+                  ext.bindVertexArrayOES(null);
+                }
+                state.currentVAO = vao;
+              }
+              function setVAOEmulated(vao) {
+                if (vao === state.currentVAO) {
+                  return;
+                }
+                if (vao) {
+                  vao.bindAttrs();
+                } else {
+                  var exti = extInstanced();
+                  for (var i22 = 0; i22 < attributeBindings.length; ++i22) {
+                    var binding = attributeBindings[i22];
+                    if (binding.buffer) {
+                      gl2.enableVertexAttribArray(i22);
+                      binding.buffer.bind();
+                      gl2.vertexAttribPointer(i22, binding.size, binding.type, binding.normalized, binding.stride, binding.offfset);
+                      if (exti && binding.divisor) {
+                        exti.vertexAttribDivisorANGLE(i22, binding.divisor);
+                      }
+                    } else {
+                      gl2.disableVertexAttribArray(i22);
+                      gl2.vertexAttrib4f(i22, binding.x, binding.y, binding.z, binding.w);
+                    }
+                  }
+                  if (drawState.elements) {
+                    gl2.bindBuffer(GL_ELEMENT_ARRAY_BUFFER$1, drawState.elements.buffer.buffer);
+                  } else {
+                    gl2.bindBuffer(GL_ELEMENT_ARRAY_BUFFER$1, null);
+                  }
+                }
+                state.currentVAO = vao;
+              }
+              function destroyVAOEXT() {
+                values(vaoSet).forEach(function(vao) {
+                  vao.destroy();
+                });
+              }
+              function REGLVAO() {
+                this.id = ++vaoCount;
+                this.attributes = [];
+                this.elements = null;
+                this.ownsElements = false;
+                this.count = 0;
+                this.offset = 0;
+                this.instances = -1;
+                this.primitive = 4;
+                var extension = extVAO();
+                if (extension) {
+                  this.vao = extension.createVertexArrayOES();
+                } else {
+                  this.vao = null;
+                }
+                vaoSet[this.id] = this;
+                this.buffers = [];
+              }
+              REGLVAO.prototype.bindAttrs = function() {
+                var exti = extInstanced();
+                var attributes = this.attributes;
+                for (var i22 = 0; i22 < attributes.length; ++i22) {
+                  var attr = attributes[i22];
+                  if (attr.buffer) {
+                    gl2.enableVertexAttribArray(i22);
+                    gl2.bindBuffer(GL_ARRAY_BUFFER$1, attr.buffer.buffer);
+                    gl2.vertexAttribPointer(i22, attr.size, attr.type, attr.normalized, attr.stride, attr.offset);
+                    if (exti && attr.divisor) {
+                      exti.vertexAttribDivisorANGLE(i22, attr.divisor);
+                    }
+                  } else {
+                    gl2.disableVertexAttribArray(i22);
+                    gl2.vertexAttrib4f(i22, attr.x, attr.y, attr.z, attr.w);
+                  }
+                }
+                for (var j2 = attributes.length; j2 < NUM_ATTRIBUTES; ++j2) {
+                  gl2.disableVertexAttribArray(j2);
+                }
+                var elements = elementState.getElements(this.elements);
+                if (elements) {
+                  gl2.bindBuffer(GL_ELEMENT_ARRAY_BUFFER$1, elements.buffer.buffer);
+                } else {
+                  gl2.bindBuffer(GL_ELEMENT_ARRAY_BUFFER$1, null);
+                }
+              };
+              REGLVAO.prototype.refresh = function() {
+                var ext = extVAO();
+                if (ext) {
+                  ext.bindVertexArrayOES(this.vao);
+                  this.bindAttrs();
+                  state.currentVAO = null;
+                  ext.bindVertexArrayOES(null);
+                }
+              };
+              REGLVAO.prototype.destroy = function() {
+                if (this.vao) {
+                  var extension = extVAO();
+                  if (this === state.currentVAO) {
+                    state.currentVAO = null;
+                    extension.bindVertexArrayOES(null);
+                  }
+                  extension.deleteVertexArrayOES(this.vao);
+                  this.vao = null;
+                }
+                if (this.ownsElements) {
+                  this.elements.destroy();
+                  this.elements = null;
+                  this.ownsElements = false;
+                }
+                if (vaoSet[this.id]) {
+                  delete vaoSet[this.id];
+                  stats2.vaoCount -= 1;
+                }
+              };
+              function restoreVAO() {
+                var ext = extVAO();
+                if (ext) {
+                  values(vaoSet).forEach(function(vao) {
+                    vao.refresh();
+                  });
+                }
+              }
+              function createVAO(_attr) {
+                var vao = new REGLVAO();
+                stats2.vaoCount += 1;
+                function updateVAO(options) {
+                  var attributes;
+                  if (Array.isArray(options)) {
+                    attributes = options;
+                    if (vao.elements && vao.ownsElements) {
+                      vao.elements.destroy();
+                    }
+                    vao.elements = null;
+                    vao.ownsElements = false;
+                    vao.offset = 0;
+                    vao.count = 0;
+                    vao.instances = -1;
+                    vao.primitive = 4;
+                  } else {
+                    if (options.elements) {
+                      var elements = options.elements;
+                      if (vao.ownsElements) {
+                        if (typeof elements === "function" && elements._reglType === "elements") {
+                          vao.elements.destroy();
+                          vao.ownsElements = false;
+                        } else {
+                          vao.elements(elements);
+                          vao.ownsElements = false;
+                        }
+                      } else if (elementState.getElements(options.elements)) {
+                        vao.elements = options.elements;
+                        vao.ownsElements = false;
+                      } else {
+                        vao.elements = elementState.create(options.elements);
+                        vao.ownsElements = true;
+                      }
+                    } else {
+                      vao.elements = null;
+                      vao.ownsElements = false;
+                    }
+                    attributes = options.attributes;
+                    vao.offset = 0;
+                    vao.count = -1;
+                    vao.instances = -1;
+                    vao.primitive = 4;
+                    if (vao.elements) {
+                      vao.count = vao.elements._elements.vertCount;
+                      vao.primitive = vao.elements._elements.primType;
+                    }
+                    if ("offset" in options) {
+                      vao.offset = options.offset | 0;
+                    }
+                    if ("count" in options) {
+                      vao.count = options.count | 0;
+                    }
+                    if ("instances" in options) {
+                      vao.instances = options.instances | 0;
+                    }
+                    if ("primitive" in options) {
+                      vao.primitive = primTypes[options.primitive];
+                    }
+                  }
+                  var bufUpdated = {};
+                  var nattributes = vao.attributes;
+                  nattributes.length = attributes.length;
+                  for (var i22 = 0; i22 < attributes.length; ++i22) {
+                    var spec = attributes[i22];
+                    var rec = nattributes[i22] = new AttributeRecord();
+                    var data = spec.data || spec;
+                    if (Array.isArray(data) || isTypedArray2(data) || isNDArrayLike(data)) {
+                      var buf;
+                      if (vao.buffers[i22]) {
+                        buf = vao.buffers[i22];
+                        if (isTypedArray2(data) && buf._buffer.byteLength >= data.byteLength) {
+                          buf.subdata(data);
+                        } else {
+                          buf.destroy();
+                          vao.buffers[i22] = null;
+                        }
+                      }
+                      if (!vao.buffers[i22]) {
+                        buf = vao.buffers[i22] = bufferState.create(spec, GL_ARRAY_BUFFER$1, false, true);
+                      }
+                      rec.buffer = bufferState.getBuffer(buf);
+                      rec.size = rec.buffer.dimension | 0;
+                      rec.normalized = false;
+                      rec.type = rec.buffer.dtype;
+                      rec.offset = 0;
+                      rec.stride = 0;
+                      rec.divisor = 0;
+                      rec.state = 1;
+                      bufUpdated[i22] = 1;
+                    } else if (bufferState.getBuffer(spec)) {
+                      rec.buffer = bufferState.getBuffer(spec);
+                      rec.size = rec.buffer.dimension | 0;
+                      rec.normalized = false;
+                      rec.type = rec.buffer.dtype;
+                      rec.offset = 0;
+                      rec.stride = 0;
+                      rec.divisor = 0;
+                      rec.state = 1;
+                    } else if (bufferState.getBuffer(spec.buffer)) {
+                      rec.buffer = bufferState.getBuffer(spec.buffer);
+                      rec.size = (+spec.size || rec.buffer.dimension) | 0;
+                      rec.normalized = !!spec.normalized || false;
+                      if ("type" in spec) {
+                        rec.type = glTypes[spec.type];
+                      } else {
+                        rec.type = rec.buffer.dtype;
+                      }
+                      rec.offset = (spec.offset || 0) | 0;
+                      rec.stride = (spec.stride || 0) | 0;
+                      rec.divisor = (spec.divisor || 0) | 0;
+                      rec.state = 1;
+                    } else if ("x" in spec) {
+                      rec.x = +spec.x || 0;
+                      rec.y = +spec.y || 0;
+                      rec.z = +spec.z || 0;
+                      rec.w = +spec.w || 0;
+                      rec.state = 2;
+                    } else ;
+                  }
+                  for (var j2 = 0; j2 < vao.buffers.length; ++j2) {
+                    if (!bufUpdated[j2] && vao.buffers[j2]) {
+                      vao.buffers[j2].destroy();
+                      vao.buffers[j2] = null;
+                    }
+                  }
+                  vao.refresh();
+                  return updateVAO;
+                }
+                updateVAO.destroy = function() {
+                  for (var j2 = 0; j2 < vao.buffers.length; ++j2) {
+                    if (vao.buffers[j2]) {
+                      vao.buffers[j2].destroy();
+                    }
+                  }
+                  vao.buffers.length = 0;
+                  if (vao.ownsElements) {
+                    vao.elements.destroy();
+                    vao.elements = null;
+                    vao.ownsElements = false;
+                  }
+                  vao.destroy();
+                };
+                updateVAO._vao = vao;
+                updateVAO._reglType = "vao";
+                return updateVAO(_attr);
+              }
+              return state;
+            }
+            var GL_FRAGMENT_SHADER = 35632;
+            var GL_VERTEX_SHADER = 35633;
+            var GL_ACTIVE_UNIFORMS = 35718;
+            var GL_ACTIVE_ATTRIBUTES = 35721;
+            function wrapShaderState(gl2, stringStore, stats2, config2) {
+              var fragShaders = {};
+              var vertShaders = {};
+              function ActiveInfo(name2, id2, location2, info) {
+                this.name = name2;
+                this.id = id2;
+                this.location = location2;
+                this.info = info;
+              }
+              function insertActiveInfo(list, info) {
+                for (var i2 = 0; i2 < list.length; ++i2) {
+                  if (list[i2].id === info.id) {
+                    list[i2].location = info.location;
+                    return;
+                  }
+                }
+                list.push(info);
+              }
+              function getShader(type, id2, command) {
+                var cache = type === GL_FRAGMENT_SHADER ? fragShaders : vertShaders;
+                var shader = cache[id2];
+                if (!shader) {
+                  var source2 = stringStore.str(id2);
+                  shader = gl2.createShader(type);
+                  gl2.shaderSource(shader, source2);
+                  gl2.compileShader(shader);
+                  cache[id2] = shader;
+                }
+                return shader;
+              }
+              var programCache = {};
+              var programList = [];
+              var PROGRAM_COUNTER = 0;
+              function REGLProgram(fragId, vertId) {
+                this.id = PROGRAM_COUNTER++;
+                this.fragId = fragId;
+                this.vertId = vertId;
+                this.program = null;
+                this.uniforms = [];
+                this.attributes = [];
+                this.refCount = 1;
+                if (config2.profile) {
+                  this.stats = {
+                    uniformsCount: 0,
+                    attributesCount: 0
+                  };
+                }
+              }
+              function linkProgram(desc, command, attributeLocations) {
+                var i2, info;
+                var fragShader = getShader(GL_FRAGMENT_SHADER, desc.fragId);
+                var vertShader = getShader(GL_VERTEX_SHADER, desc.vertId);
+                var program = desc.program = gl2.createProgram();
+                gl2.attachShader(program, fragShader);
+                gl2.attachShader(program, vertShader);
+                if (attributeLocations) {
+                  for (i2 = 0; i2 < attributeLocations.length; ++i2) {
+                    var binding = attributeLocations[i2];
+                    gl2.bindAttribLocation(program, binding[0], binding[1]);
+                  }
+                }
+                gl2.linkProgram(program);
+                var numUniforms = gl2.getProgramParameter(program, GL_ACTIVE_UNIFORMS);
+                if (config2.profile) {
+                  desc.stats.uniformsCount = numUniforms;
+                }
+                var uniforms = desc.uniforms;
+                for (i2 = 0; i2 < numUniforms; ++i2) {
+                  info = gl2.getActiveUniform(program, i2);
+                  if (info) {
+                    if (info.size > 1) {
+                      for (var j2 = 0; j2 < info.size; ++j2) {
+                        var name2 = info.name.replace("[0]", "[" + j2 + "]");
+                        insertActiveInfo(uniforms, new ActiveInfo(
+                          name2,
+                          stringStore.id(name2),
+                          gl2.getUniformLocation(program, name2),
+                          info
+                        ));
+                      }
+                    } else {
+                      insertActiveInfo(uniforms, new ActiveInfo(
+                        info.name,
+                        stringStore.id(info.name),
+                        gl2.getUniformLocation(program, info.name),
+                        info
+                      ));
+                    }
+                  }
+                }
+                var numAttributes = gl2.getProgramParameter(program, GL_ACTIVE_ATTRIBUTES);
+                if (config2.profile) {
+                  desc.stats.attributesCount = numAttributes;
+                }
+                var attributes = desc.attributes;
+                for (i2 = 0; i2 < numAttributes; ++i2) {
+                  info = gl2.getActiveAttrib(program, i2);
+                  if (info) {
+                    insertActiveInfo(attributes, new ActiveInfo(
+                      info.name,
+                      stringStore.id(info.name),
+                      gl2.getAttribLocation(program, info.name),
+                      info
+                    ));
+                  }
+                }
+              }
+              if (config2.profile) {
+                stats2.getMaxUniformsCount = function() {
+                  var m2 = 0;
+                  programList.forEach(function(desc) {
+                    if (desc.stats.uniformsCount > m2) {
+                      m2 = desc.stats.uniformsCount;
+                    }
+                  });
+                  return m2;
+                };
+                stats2.getMaxAttributesCount = function() {
+                  var m2 = 0;
+                  programList.forEach(function(desc) {
+                    if (desc.stats.attributesCount > m2) {
+                      m2 = desc.stats.attributesCount;
+                    }
+                  });
+                  return m2;
+                };
+              }
+              function restoreShaders() {
+                fragShaders = {};
+                vertShaders = {};
+                for (var i2 = 0; i2 < programList.length; ++i2) {
+                  linkProgram(programList[i2], null, programList[i2].attributes.map(function(info) {
+                    return [info.location, info.name];
+                  }));
+                }
+              }
+              return {
+                clear: function() {
+                  var deleteShader = gl2.deleteShader.bind(gl2);
+                  values(fragShaders).forEach(deleteShader);
+                  fragShaders = {};
+                  values(vertShaders).forEach(deleteShader);
+                  vertShaders = {};
+                  programList.forEach(function(desc) {
+                    gl2.deleteProgram(desc.program);
+                  });
+                  programList.length = 0;
+                  programCache = {};
+                  stats2.shaderCount = 0;
+                },
+                program: function(vertId, fragId, command, attribLocations) {
+                  var cache = programCache[fragId];
+                  if (!cache) {
+                    cache = programCache[fragId] = {};
+                  }
+                  var prevProgram = cache[vertId];
+                  if (prevProgram) {
+                    prevProgram.refCount++;
+                    if (!attribLocations) {
+                      return prevProgram;
+                    }
+                  }
+                  var program = new REGLProgram(fragId, vertId);
+                  stats2.shaderCount++;
+                  linkProgram(program, command, attribLocations);
+                  if (!prevProgram) {
+                    cache[vertId] = program;
+                  }
+                  programList.push(program);
+                  return extend2(program, {
+                    destroy: function() {
+                      program.refCount--;
+                      if (program.refCount <= 0) {
+                        gl2.deleteProgram(program.program);
+                        var idx = programList.indexOf(program);
+                        programList.splice(idx, 1);
+                        stats2.shaderCount--;
+                      }
+                      if (cache[program.vertId].refCount <= 0) {
+                        gl2.deleteShader(vertShaders[program.vertId]);
+                        delete vertShaders[program.vertId];
+                        delete programCache[program.fragId][program.vertId];
+                      }
+                      if (!Object.keys(programCache[program.fragId]).length) {
+                        gl2.deleteShader(fragShaders[program.fragId]);
+                        delete fragShaders[program.fragId];
+                        delete programCache[program.fragId];
+                      }
+                    }
+                  });
+                },
+                restore: restoreShaders,
+                shader: getShader,
+                frag: -1,
+                vert: -1
+              };
+            }
+            var GL_RGBA$3 = 6408;
+            var GL_UNSIGNED_BYTE$6 = 5121;
+            var GL_PACK_ALIGNMENT = 3333;
+            var GL_FLOAT$6 = 5126;
+            function wrapReadPixels(gl2, framebufferState, reglPoll, context, glAttributes, extensions, limits) {
+              function readPixelsImpl(input) {
+                var type;
+                if (framebufferState.next === null) {
+                  type = GL_UNSIGNED_BYTE$6;
+                } else {
+                  type = framebufferState.next.colorAttachments[0].texture._texture.type;
+                }
+                var x2 = 0;
+                var y2 = 0;
+                var width = context.framebufferWidth;
+                var height = context.framebufferHeight;
+                var data = null;
+                if (isTypedArray2(input)) {
+                  data = input;
+                } else if (input) {
+                  x2 = input.x | 0;
+                  y2 = input.y | 0;
+                  width = (input.width || context.framebufferWidth - x2) | 0;
+                  height = (input.height || context.framebufferHeight - y2) | 0;
+                  data = input.data || null;
+                }
+                reglPoll();
+                var size = width * height * 4;
+                if (!data) {
+                  if (type === GL_UNSIGNED_BYTE$6) {
+                    data = new Uint8Array(size);
+                  } else if (type === GL_FLOAT$6) {
+                    data = data || new Float32Array(size);
+                  }
+                }
+                gl2.pixelStorei(GL_PACK_ALIGNMENT, 4);
+                gl2.readPixels(
+                  x2,
+                  y2,
+                  width,
+                  height,
+                  GL_RGBA$3,
+                  type,
+                  data
+                );
+                return data;
+              }
+              function readPixelsFBO(options) {
+                var result;
+                framebufferState.setFBO({
+                  framebuffer: options.framebuffer
+                }, function() {
+                  result = readPixelsImpl(options);
+                });
+                return result;
+              }
+              function readPixels(options) {
+                if (!options || !("framebuffer" in options)) {
+                  return readPixelsImpl(options);
+                } else {
+                  return readPixelsFBO(options);
+                }
+              }
+              return readPixels;
+            }
+            function hex_sha256(s2) {
+              return rstr2hex(rstr_sha256(str2rstr_utf8(s2)));
+            }
+            function rstr_sha256(s2) {
+              return binb2rstr(binb_sha256(rstr2binb(s2), s2.length * 8));
+            }
+            function rstr2hex(input) {
+              var hex_tab = "0123456789abcdef";
+              var output = "";
+              var x2;
+              for (var i2 = 0; i2 < input.length; i2++) {
+                x2 = input.charCodeAt(i2);
+                output += hex_tab.charAt(x2 >>> 4 & 15) + hex_tab.charAt(x2 & 15);
+              }
+              return output;
+            }
+            function str2rstr_utf8(input) {
+              var output = "";
+              var i2 = -1;
+              var x2, y2;
+              while (++i2 < input.length) {
+                x2 = input.charCodeAt(i2);
+                y2 = i2 + 1 < input.length ? input.charCodeAt(i2 + 1) : 0;
+                if (55296 <= x2 && x2 <= 56319 && 56320 <= y2 && y2 <= 57343) {
+                  x2 = 65536 + ((x2 & 1023) << 10) + (y2 & 1023);
+                  i2++;
+                }
+                if (x2 <= 127)
+                  output += String.fromCharCode(x2);
+                else if (x2 <= 2047)
+                  output += String.fromCharCode(
+                    192 | x2 >>> 6 & 31,
+                    128 | x2 & 63
+                  );
+                else if (x2 <= 65535)
+                  output += String.fromCharCode(
+                    224 | x2 >>> 12 & 15,
+                    128 | x2 >>> 6 & 63,
+                    128 | x2 & 63
+                  );
+                else if (x2 <= 2097151)
+                  output += String.fromCharCode(
+                    240 | x2 >>> 18 & 7,
+                    128 | x2 >>> 12 & 63,
+                    128 | x2 >>> 6 & 63,
+                    128 | x2 & 63
+                  );
+              }
+              return output;
+            }
+            function rstr2binb(input) {
+              var output = Array(input.length >> 2);
+              for (var i2 = 0; i2 < output.length; i2++)
+                output[i2] = 0;
+              for (var i2 = 0; i2 < input.length * 8; i2 += 8)
+                output[i2 >> 5] |= (input.charCodeAt(i2 / 8) & 255) << 24 - i2 % 32;
+              return output;
+            }
+            function binb2rstr(input) {
+              var output = "";
+              for (var i2 = 0; i2 < input.length * 32; i2 += 8)
+                output += String.fromCharCode(input[i2 >> 5] >>> 24 - i2 % 32 & 255);
+              return output;
+            }
+            function sha256_S(X2, n2) {
+              return X2 >>> n2 | X2 << 32 - n2;
+            }
+            function sha256_R(X2, n2) {
+              return X2 >>> n2;
+            }
+            function sha256_Ch(x2, y2, z2) {
+              return x2 & y2 ^ ~x2 & z2;
+            }
+            function sha256_Maj(x2, y2, z2) {
+              return x2 & y2 ^ x2 & z2 ^ y2 & z2;
+            }
+            function sha256_Sigma0256(x2) {
+              return sha256_S(x2, 2) ^ sha256_S(x2, 13) ^ sha256_S(x2, 22);
+            }
+            function sha256_Sigma1256(x2) {
+              return sha256_S(x2, 6) ^ sha256_S(x2, 11) ^ sha256_S(x2, 25);
+            }
+            function sha256_Gamma0256(x2) {
+              return sha256_S(x2, 7) ^ sha256_S(x2, 18) ^ sha256_R(x2, 3);
+            }
+            function sha256_Gamma1256(x2) {
+              return sha256_S(x2, 17) ^ sha256_S(x2, 19) ^ sha256_R(x2, 10);
+            }
+            var sha256_K = new Array(
+              1116352408,
+              1899447441,
+              -1245643825,
+              -373957723,
+              961987163,
+              1508970993,
+              -1841331548,
+              -1424204075,
+              -670586216,
+              310598401,
+              607225278,
+              1426881987,
+              1925078388,
+              -2132889090,
+              -1680079193,
+              -1046744716,
+              -459576895,
+              -272742522,
+              264347078,
+              604807628,
+              770255983,
+              1249150122,
+              1555081692,
+              1996064986,
+              -1740746414,
+              -1473132947,
+              -1341970488,
+              -1084653625,
+              -958395405,
+              -710438585,
+              113926993,
+              338241895,
+              666307205,
+              773529912,
+              1294757372,
+              1396182291,
+              1695183700,
+              1986661051,
+              -2117940946,
+              -1838011259,
+              -1564481375,
+              -1474664885,
+              -1035236496,
+              -949202525,
+              -778901479,
+              -694614492,
+              -200395387,
+              275423344,
+              430227734,
+              506948616,
+              659060556,
+              883997877,
+              958139571,
+              1322822218,
+              1537002063,
+              1747873779,
+              1955562222,
+              2024104815,
+              -2067236844,
+              -1933114872,
+              -1866530822,
+              -1538233109,
+              -1090935817,
+              -965641998
+            );
+            function binb_sha256(m2, l2) {
+              var HASH = new Array(
+                1779033703,
+                -1150833019,
+                1013904242,
+                -1521486534,
+                1359893119,
+                -1694144372,
+                528734635,
+                1541459225
+              );
+              var W2 = new Array(64);
+              var a2, b2, c2, d2, e2, f2, g2, h2;
+              var i2, j2, T1, T2;
+              m2[l2 >> 5] |= 128 << 24 - l2 % 32;
+              m2[(l2 + 64 >> 9 << 4) + 15] = l2;
+              for (i2 = 0; i2 < m2.length; i2 += 16) {
+                a2 = HASH[0];
+                b2 = HASH[1];
+                c2 = HASH[2];
+                d2 = HASH[3];
+                e2 = HASH[4];
+                f2 = HASH[5];
+                g2 = HASH[6];
+                h2 = HASH[7];
+                for (j2 = 0; j2 < 64; j2++) {
+                  if (j2 < 16) W2[j2] = m2[j2 + i2];
+                  else W2[j2] = safe_add(safe_add(
+                    safe_add(sha256_Gamma1256(W2[j2 - 2]), W2[j2 - 7]),
+                    sha256_Gamma0256(W2[j2 - 15])
+                  ), W2[j2 - 16]);
+                  T1 = safe_add(safe_add(
+                    safe_add(safe_add(h2, sha256_Sigma1256(e2)), sha256_Ch(e2, f2, g2)),
+                    sha256_K[j2]
+                  ), W2[j2]);
+                  T2 = safe_add(sha256_Sigma0256(a2), sha256_Maj(a2, b2, c2));
+                  h2 = g2;
+                  g2 = f2;
+                  f2 = e2;
+                  e2 = safe_add(d2, T1);
+                  d2 = c2;
+                  c2 = b2;
+                  b2 = a2;
+                  a2 = safe_add(T1, T2);
+                }
+                HASH[0] = safe_add(a2, HASH[0]);
+                HASH[1] = safe_add(b2, HASH[1]);
+                HASH[2] = safe_add(c2, HASH[2]);
+                HASH[3] = safe_add(d2, HASH[3]);
+                HASH[4] = safe_add(e2, HASH[4]);
+                HASH[5] = safe_add(f2, HASH[5]);
+                HASH[6] = safe_add(g2, HASH[6]);
+                HASH[7] = safe_add(h2, HASH[7]);
+              }
+              return HASH;
+            }
+            function safe_add(x2, y2) {
+              var lsw = (x2 & 65535) + (y2 & 65535);
+              var msw = (x2 >> 16) + (y2 >> 16) + (lsw >> 16);
+              return msw << 16 | lsw & 65535;
+            }
+            function slice(x2) {
+              return Array.prototype.slice.call(x2);
+            }
+            function join(x2) {
+              return slice(x2).join("");
+            }
+            function createEnvironment(options) {
+              var cache = options && options.cache;
+              var varCounter = 0;
+              var linkedNames = [];
+              var linkedValues = [];
+              var isStable = [];
+              function link(value, options2) {
+                var stable = options2 && options2.stable;
+                if (!stable) {
+                  for (var i2 = 0; i2 < linkedValues.length; ++i2) {
+                    if (linkedValues[i2] === value && !isStable[i2]) {
+                      return linkedNames[i2];
+                    }
+                  }
+                }
+                var name2 = "g" + varCounter++;
+                linkedNames.push(name2);
+                linkedValues.push(value);
+                isStable.push(stable);
+                return name2;
+              }
+              function block() {
+                var code = [];
+                function push() {
+                  code.push.apply(code, slice(arguments));
+                }
+                var vars = [];
+                function def() {
+                  var name2 = "v" + varCounter++;
+                  vars.push(name2);
+                  if (arguments.length > 0) {
+                    code.push(name2, "=");
+                    code.push.apply(code, slice(arguments));
+                    code.push(";");
+                  }
+                  return name2;
+                }
+                return extend2(push, {
+                  def,
+                  toString: function() {
+                    return join([
+                      vars.length > 0 ? "var " + vars.join(",") + ";" : "",
+                      join(code)
+                    ]);
+                  }
+                });
+              }
+              function scope() {
+                var entry = block();
+                var exit = block();
+                var entryToString = entry.toString;
+                var exitToString = exit.toString;
+                function save(object, prop) {
+                  exit(object, prop, "=", entry.def(object, prop), ";");
+                }
+                return extend2(function() {
+                  entry.apply(entry, slice(arguments));
+                }, {
+                  def: entry.def,
+                  entry,
+                  exit,
+                  save,
+                  set: function(object, prop, value) {
+                    save(object, prop);
+                    entry(object, prop, "=", value, ";");
+                  },
+                  toString: function() {
+                    return entryToString() + exitToString();
+                  }
+                });
+              }
+              function conditional() {
+                var pred = join(arguments);
+                var thenBlock = scope();
+                var elseBlock = scope();
+                var thenToString = thenBlock.toString;
+                var elseToString = elseBlock.toString;
+                return extend2(thenBlock, {
+                  then: function() {
+                    thenBlock.apply(thenBlock, slice(arguments));
+                    return this;
+                  },
+                  else: function() {
+                    elseBlock.apply(elseBlock, slice(arguments));
+                    return this;
+                  },
+                  toString: function() {
+                    var elseClause = elseToString();
+                    if (elseClause) {
+                      elseClause = "else{" + elseClause + "}";
+                    }
+                    return join([
+                      "if(",
+                      pred,
+                      "){",
+                      thenToString(),
+                      "}",
+                      elseClause
+                    ]);
+                  }
+                });
+              }
+              var globalBlock = block();
+              var procedures = {};
+              function proc(name2, count2) {
+                var args = [];
+                function arg() {
+                  var name3 = "a" + args.length;
+                  args.push(name3);
+                  return name3;
+                }
+                count2 = count2 || 0;
+                for (var i2 = 0; i2 < count2; ++i2) {
+                  arg();
+                }
+                var body = scope();
+                var bodyToString = body.toString;
+                var result = procedures[name2] = extend2(body, {
+                  arg,
+                  toString: function() {
+                    return join([
+                      "function(",
+                      args.join(),
+                      "){",
+                      bodyToString(),
+                      "}"
+                    ]);
+                  }
+                });
+                return result;
+              }
+              function compile() {
+                var code = [
+                  '"use strict";',
+                  globalBlock,
+                  "return {"
+                ];
+                Object.keys(procedures).forEach(function(name2) {
+                  code.push('"', name2, '":', procedures[name2].toString(), ",");
+                });
+                code.push("}");
+                var src = join(code).replace(/;/g, ";\n").replace(/}/g, "}\n").replace(/{/g, "{\n");
+                var key;
+                if (cache) {
+                  key = hex_sha256(src);
+                  if (cache[key]) {
+                    return cache[key].apply(null, linkedValues);
+                  }
+                }
+                var proc2 = Function.apply(null, linkedNames.concat(src));
+                if (cache) {
+                  cache[key] = proc2;
+                }
+                return proc2.apply(null, linkedValues);
+              }
+              return {
+                global: globalBlock,
+                link,
+                block,
+                proc,
+                scope,
+                cond: conditional,
+                compile
+              };
+            }
+            var CUTE_COMPONENTS = "xyzw".split("");
+            var GL_UNSIGNED_BYTE$7 = 5121;
+            var ATTRIB_STATE_POINTER = 1;
+            var ATTRIB_STATE_CONSTANT = 2;
+            var DYN_FUNC$1 = 0;
+            var DYN_PROP$1 = 1;
+            var DYN_CONTEXT$1 = 2;
+            var DYN_STATE$1 = 3;
+            var DYN_THUNK = 4;
+            var DYN_CONSTANT$1 = 5;
+            var DYN_ARRAY$1 = 6;
+            var S_DITHER = "dither";
+            var S_BLEND_ENABLE = "blend.enable";
+            var S_BLEND_COLOR = "blend.color";
+            var S_BLEND_EQUATION = "blend.equation";
+            var S_BLEND_FUNC = "blend.func";
+            var S_DEPTH_ENABLE = "depth.enable";
+            var S_DEPTH_FUNC = "depth.func";
+            var S_DEPTH_RANGE = "depth.range";
+            var S_DEPTH_MASK = "depth.mask";
+            var S_COLOR_MASK = "colorMask";
+            var S_CULL_ENABLE = "cull.enable";
+            var S_CULL_FACE = "cull.face";
+            var S_FRONT_FACE = "frontFace";
+            var S_LINE_WIDTH = "lineWidth";
+            var S_POLYGON_OFFSET_ENABLE = "polygonOffset.enable";
+            var S_POLYGON_OFFSET_OFFSET = "polygonOffset.offset";
+            var S_SAMPLE_ALPHA = "sample.alpha";
+            var S_SAMPLE_ENABLE = "sample.enable";
+            var S_SAMPLE_COVERAGE = "sample.coverage";
+            var S_STENCIL_ENABLE = "stencil.enable";
+            var S_STENCIL_MASK = "stencil.mask";
+            var S_STENCIL_FUNC = "stencil.func";
+            var S_STENCIL_OPFRONT = "stencil.opFront";
+            var S_STENCIL_OPBACK = "stencil.opBack";
+            var S_SCISSOR_ENABLE = "scissor.enable";
+            var S_SCISSOR_BOX = "scissor.box";
+            var S_VIEWPORT = "viewport";
+            var S_PROFILE = "profile";
+            var S_FRAMEBUFFER = "framebuffer";
+            var S_VERT = "vert";
+            var S_FRAG = "frag";
+            var S_ELEMENTS = "elements";
+            var S_PRIMITIVE = "primitive";
+            var S_COUNT = "count";
+            var S_OFFSET = "offset";
+            var S_INSTANCES = "instances";
+            var S_VAO = "vao";
+            var SUFFIX_WIDTH = "Width";
+            var SUFFIX_HEIGHT = "Height";
+            var S_FRAMEBUFFER_WIDTH = S_FRAMEBUFFER + SUFFIX_WIDTH;
+            var S_FRAMEBUFFER_HEIGHT = S_FRAMEBUFFER + SUFFIX_HEIGHT;
+            var S_VIEWPORT_WIDTH = S_VIEWPORT + SUFFIX_WIDTH;
+            var S_VIEWPORT_HEIGHT = S_VIEWPORT + SUFFIX_HEIGHT;
+            var S_DRAWINGBUFFER = "drawingBuffer";
+            var S_DRAWINGBUFFER_WIDTH = S_DRAWINGBUFFER + SUFFIX_WIDTH;
+            var S_DRAWINGBUFFER_HEIGHT = S_DRAWINGBUFFER + SUFFIX_HEIGHT;
+            var NESTED_OPTIONS = [
+              S_BLEND_FUNC,
+              S_BLEND_EQUATION,
+              S_STENCIL_FUNC,
+              S_STENCIL_OPFRONT,
+              S_STENCIL_OPBACK,
+              S_SAMPLE_COVERAGE,
+              S_VIEWPORT,
+              S_SCISSOR_BOX,
+              S_POLYGON_OFFSET_OFFSET
+            ];
+            var GL_ARRAY_BUFFER$2 = 34962;
+            var GL_ELEMENT_ARRAY_BUFFER$2 = 34963;
+            var GL_CULL_FACE = 2884;
+            var GL_BLEND = 3042;
+            var GL_DITHER = 3024;
+            var GL_STENCIL_TEST = 2960;
+            var GL_DEPTH_TEST = 2929;
+            var GL_SCISSOR_TEST = 3089;
+            var GL_POLYGON_OFFSET_FILL = 32823;
+            var GL_SAMPLE_ALPHA_TO_COVERAGE = 32926;
+            var GL_SAMPLE_COVERAGE = 32928;
+            var GL_FLOAT$7 = 5126;
+            var GL_FLOAT_VEC2 = 35664;
+            var GL_FLOAT_VEC3 = 35665;
+            var GL_FLOAT_VEC4 = 35666;
+            var GL_INT$2 = 5124;
+            var GL_INT_VEC2 = 35667;
+            var GL_INT_VEC3 = 35668;
+            var GL_INT_VEC4 = 35669;
+            var GL_BOOL = 35670;
+            var GL_BOOL_VEC2 = 35671;
+            var GL_BOOL_VEC3 = 35672;
+            var GL_BOOL_VEC4 = 35673;
+            var GL_FLOAT_MAT2 = 35674;
+            var GL_FLOAT_MAT3 = 35675;
+            var GL_FLOAT_MAT4 = 35676;
+            var GL_SAMPLER_2D = 35678;
+            var GL_SAMPLER_CUBE = 35680;
+            var GL_TRIANGLES$1 = 4;
+            var GL_FRONT = 1028;
+            var GL_BACK = 1029;
+            var GL_CW = 2304;
+            var GL_CCW = 2305;
+            var GL_MIN_EXT = 32775;
+            var GL_MAX_EXT = 32776;
+            var GL_ALWAYS = 519;
+            var GL_KEEP = 7680;
+            var GL_ZERO = 0;
+            var GL_ONE = 1;
+            var GL_FUNC_ADD = 32774;
+            var GL_LESS = 513;
+            var GL_FRAMEBUFFER$2 = 36160;
+            var GL_COLOR_ATTACHMENT0$2 = 36064;
+            var blendFuncs = {
+              "0": 0,
+              "1": 1,
+              "zero": 0,
+              "one": 1,
+              "src color": 768,
+              "one minus src color": 769,
+              "src alpha": 770,
+              "one minus src alpha": 771,
+              "dst color": 774,
+              "one minus dst color": 775,
+              "dst alpha": 772,
+              "one minus dst alpha": 773,
+              "constant color": 32769,
+              "one minus constant color": 32770,
+              "constant alpha": 32771,
+              "one minus constant alpha": 32772,
+              "src alpha saturate": 776
+            };
+            var compareFuncs = {
+              "never": 512,
+              "less": 513,
+              "<": 513,
+              "equal": 514,
+              "=": 514,
+              "==": 514,
+              "===": 514,
+              "lequal": 515,
+              "<=": 515,
+              "greater": 516,
+              ">": 516,
+              "notequal": 517,
+              "!=": 517,
+              "!==": 517,
+              "gequal": 518,
+              ">=": 518,
+              "always": 519
+            };
+            var stencilOps = {
+              "0": 0,
+              "zero": 0,
+              "keep": 7680,
+              "replace": 7681,
+              "increment": 7682,
+              "decrement": 7683,
+              "increment wrap": 34055,
+              "decrement wrap": 34056,
+              "invert": 5386
+            };
+            var orientationType = {
+              "cw": GL_CW,
+              "ccw": GL_CCW
+            };
+            function isBufferArgs(x2) {
+              return Array.isArray(x2) || isTypedArray2(x2) || isNDArrayLike(x2);
+            }
+            function sortState(state) {
+              return state.sort(function(a2, b2) {
+                if (a2 === S_VIEWPORT) {
+                  return -1;
+                } else if (b2 === S_VIEWPORT) {
+                  return 1;
+                }
+                return a2 < b2 ? -1 : 1;
+              });
+            }
+            function Declaration(thisDep, contextDep, propDep, append) {
+              this.thisDep = thisDep;
+              this.contextDep = contextDep;
+              this.propDep = propDep;
+              this.append = append;
+            }
+            function isStatic(decl) {
+              return decl && !(decl.thisDep || decl.contextDep || decl.propDep);
+            }
+            function createStaticDecl(append) {
+              return new Declaration(false, false, false, append);
+            }
+            function createDynamicDecl(dyn, append) {
+              var type = dyn.type;
+              if (type === DYN_FUNC$1) {
+                var numArgs = dyn.data.length;
+                return new Declaration(
+                  true,
+                  numArgs >= 1,
+                  numArgs >= 2,
+                  append
+                );
+              } else if (type === DYN_THUNK) {
+                var data = dyn.data;
+                return new Declaration(
+                  data.thisDep,
+                  data.contextDep,
+                  data.propDep,
+                  append
+                );
+              } else if (type === DYN_CONSTANT$1) {
+                return new Declaration(
+                  false,
+                  false,
+                  false,
+                  append
+                );
+              } else if (type === DYN_ARRAY$1) {
+                var thisDep = false;
+                var contextDep = false;
+                var propDep = false;
+                for (var i2 = 0; i2 < dyn.data.length; ++i2) {
+                  var subDyn = dyn.data[i2];
+                  if (subDyn.type === DYN_PROP$1) {
+                    propDep = true;
+                  } else if (subDyn.type === DYN_CONTEXT$1) {
+                    contextDep = true;
+                  } else if (subDyn.type === DYN_STATE$1) {
+                    thisDep = true;
+                  } else if (subDyn.type === DYN_FUNC$1) {
+                    thisDep = true;
+                    var subArgs = subDyn.data;
+                    if (subArgs >= 1) {
+                      contextDep = true;
+                    }
+                    if (subArgs >= 2) {
+                      propDep = true;
+                    }
+                  } else if (subDyn.type === DYN_THUNK) {
+                    thisDep = thisDep || subDyn.data.thisDep;
+                    contextDep = contextDep || subDyn.data.contextDep;
+                    propDep = propDep || subDyn.data.propDep;
+                  }
+                }
+                return new Declaration(
+                  thisDep,
+                  contextDep,
+                  propDep,
+                  append
+                );
+              } else {
+                return new Declaration(
+                  type === DYN_STATE$1,
+                  type === DYN_CONTEXT$1,
+                  type === DYN_PROP$1,
+                  append
+                );
+              }
+            }
+            var SCOPE_DECL = new Declaration(false, false, false, function() {
+            });
+            function reglCore(gl2, stringStore, extensions, limits, bufferState, elementState, textureState, framebufferState, uniformState, attributeState, shaderState, drawState, contextState, timer, cachedCode, config2) {
+              var AttributeRecord2 = attributeState.Record;
+              var blendEquations = {
+                "add": 32774,
+                "subtract": 32778,
+                "reverse subtract": 32779
+              };
+              if (extensions.ext_blend_minmax) {
+                blendEquations.min = GL_MIN_EXT;
+                blendEquations.max = GL_MAX_EXT;
+              }
+              var extInstancing = extensions.angle_instanced_arrays;
+              var extDrawBuffers = extensions.webgl_draw_buffers;
+              var extVertexArrays = extensions.oes_vertex_array_object;
+              var currentState = {
+                dirty: true,
+                profile: config2.profile
+              };
+              var nextState = {};
+              var GL_STATE_NAMES = [];
+              var GL_FLAGS = {};
+              var GL_VARIABLES = {};
+              function propName(name2) {
+                return name2.replace(".", "_");
+              }
+              function stateFlag(sname, cap, init) {
+                var name2 = propName(sname);
+                GL_STATE_NAMES.push(sname);
+                nextState[name2] = currentState[name2] = !!init;
+                GL_FLAGS[name2] = cap;
+              }
+              function stateVariable(sname, func, init) {
+                var name2 = propName(sname);
+                GL_STATE_NAMES.push(sname);
+                if (Array.isArray(init)) {
+                  currentState[name2] = init.slice();
+                  nextState[name2] = init.slice();
+                } else {
+                  currentState[name2] = nextState[name2] = init;
+                }
+                GL_VARIABLES[name2] = func;
+              }
+              function hasVariableReference(exp) {
+                if (!isNaN(exp)) {
+                  return false;
+                }
+                return true;
+              }
+              stateFlag(S_DITHER, GL_DITHER);
+              stateFlag(S_BLEND_ENABLE, GL_BLEND);
+              stateVariable(S_BLEND_COLOR, "blendColor", [0, 0, 0, 0]);
+              stateVariable(
+                S_BLEND_EQUATION,
+                "blendEquationSeparate",
+                [GL_FUNC_ADD, GL_FUNC_ADD]
+              );
+              stateVariable(
+                S_BLEND_FUNC,
+                "blendFuncSeparate",
+                [GL_ONE, GL_ZERO, GL_ONE, GL_ZERO]
+              );
+              stateFlag(S_DEPTH_ENABLE, GL_DEPTH_TEST, true);
+              stateVariable(S_DEPTH_FUNC, "depthFunc", GL_LESS);
+              stateVariable(S_DEPTH_RANGE, "depthRange", [0, 1]);
+              stateVariable(S_DEPTH_MASK, "depthMask", true);
+              stateVariable(S_COLOR_MASK, S_COLOR_MASK, [true, true, true, true]);
+              stateFlag(S_CULL_ENABLE, GL_CULL_FACE);
+              stateVariable(S_CULL_FACE, "cullFace", GL_BACK);
+              stateVariable(S_FRONT_FACE, S_FRONT_FACE, GL_CCW);
+              stateVariable(S_LINE_WIDTH, S_LINE_WIDTH, 1);
+              stateFlag(S_POLYGON_OFFSET_ENABLE, GL_POLYGON_OFFSET_FILL);
+              stateVariable(S_POLYGON_OFFSET_OFFSET, "polygonOffset", [0, 0]);
+              stateFlag(S_SAMPLE_ALPHA, GL_SAMPLE_ALPHA_TO_COVERAGE);
+              stateFlag(S_SAMPLE_ENABLE, GL_SAMPLE_COVERAGE);
+              stateVariable(S_SAMPLE_COVERAGE, "sampleCoverage", [1, false]);
+              stateFlag(S_STENCIL_ENABLE, GL_STENCIL_TEST);
+              stateVariable(S_STENCIL_MASK, "stencilMask", -1);
+              stateVariable(S_STENCIL_FUNC, "stencilFunc", [GL_ALWAYS, 0, -1]);
+              stateVariable(
+                S_STENCIL_OPFRONT,
+                "stencilOpSeparate",
+                [GL_FRONT, GL_KEEP, GL_KEEP, GL_KEEP]
+              );
+              stateVariable(
+                S_STENCIL_OPBACK,
+                "stencilOpSeparate",
+                [GL_BACK, GL_KEEP, GL_KEEP, GL_KEEP]
+              );
+              stateFlag(S_SCISSOR_ENABLE, GL_SCISSOR_TEST);
+              stateVariable(
+                S_SCISSOR_BOX,
+                "scissor",
+                [0, 0, gl2.drawingBufferWidth, gl2.drawingBufferHeight]
+              );
+              stateVariable(
+                S_VIEWPORT,
+                S_VIEWPORT,
+                [0, 0, gl2.drawingBufferWidth, gl2.drawingBufferHeight]
+              );
+              var sharedState = {
+                gl: gl2,
+                context: contextState,
+                strings: stringStore,
+                next: nextState,
+                current: currentState,
+                draw: drawState,
+                elements: elementState,
+                buffer: bufferState,
+                shader: shaderState,
+                attributes: attributeState.state,
+                vao: attributeState,
+                uniforms: uniformState,
+                framebuffer: framebufferState,
+                extensions,
+                timer,
+                isBufferArgs
+              };
+              var sharedConstants = {
+                primTypes,
+                compareFuncs,
+                blendFuncs,
+                blendEquations,
+                stencilOps,
+                glTypes,
+                orientationType
+              };
+              if (extDrawBuffers) {
+                sharedConstants.backBuffer = [GL_BACK];
+                sharedConstants.drawBuffer = loop(limits.maxDrawbuffers, function(i2) {
+                  if (i2 === 0) {
+                    return [0];
+                  }
+                  return loop(i2, function(j2) {
+                    return GL_COLOR_ATTACHMENT0$2 + j2;
+                  });
+                });
+              }
+              var drawCallCounter = 0;
+              function createREGLEnvironment() {
+                var env = createEnvironment({ cache: cachedCode });
+                var link = env.link;
+                var global2 = env.global;
+                env.id = drawCallCounter++;
+                env.batchId = "0";
+                var SHARED = link(sharedState);
+                var shared = env.shared = {
+                  props: "a0"
+                };
+                Object.keys(sharedState).forEach(function(prop) {
+                  shared[prop] = global2.def(SHARED, ".", prop);
+                });
+                var nextVars = env.next = {};
+                var currentVars = env.current = {};
+                Object.keys(GL_VARIABLES).forEach(function(variable) {
+                  if (Array.isArray(currentState[variable])) {
+                    nextVars[variable] = global2.def(shared.next, ".", variable);
+                    currentVars[variable] = global2.def(shared.current, ".", variable);
+                  }
+                });
+                var constants = env.constants = {};
+                Object.keys(sharedConstants).forEach(function(name2) {
+                  constants[name2] = global2.def(JSON.stringify(sharedConstants[name2]));
+                });
+                env.invoke = function(block, x2) {
+                  switch (x2.type) {
+                    case DYN_FUNC$1:
+                      var argList = [
+                        "this",
+                        shared.context,
+                        shared.props,
+                        env.batchId
+                      ];
+                      return block.def(
+                        link(x2.data),
+                        ".call(",
+                        argList.slice(0, Math.max(x2.data.length + 1, 4)),
+                        ")"
+                      );
+                    case DYN_PROP$1:
+                      return block.def(shared.props, x2.data);
+                    case DYN_CONTEXT$1:
+                      return block.def(shared.context, x2.data);
+                    case DYN_STATE$1:
+                      return block.def("this", x2.data);
+                    case DYN_THUNK:
+                      x2.data.append(env, block);
+                      return x2.data.ref;
+                    case DYN_CONSTANT$1:
+                      return x2.data.toString();
+                    case DYN_ARRAY$1:
+                      return x2.data.map(function(y2) {
+                        return env.invoke(block, y2);
+                      });
+                  }
+                };
+                env.attribCache = {};
+                var scopeAttribs = {};
+                env.scopeAttrib = function(name2) {
+                  var id2 = stringStore.id(name2);
+                  if (id2 in scopeAttribs) {
+                    return scopeAttribs[id2];
+                  }
+                  var binding = attributeState.scope[id2];
+                  if (!binding) {
+                    binding = attributeState.scope[id2] = new AttributeRecord2();
+                  }
+                  var result = scopeAttribs[id2] = link(binding);
+                  return result;
+                };
+                return env;
+              }
+              function parseProfile(options) {
+                var staticOptions = options.static;
+                var dynamicOptions = options.dynamic;
+                var profileEnable;
+                if (S_PROFILE in staticOptions) {
+                  var value = !!staticOptions[S_PROFILE];
+                  profileEnable = createStaticDecl(function(env, scope) {
+                    return value;
+                  });
+                  profileEnable.enable = value;
+                } else if (S_PROFILE in dynamicOptions) {
+                  var dyn = dynamicOptions[S_PROFILE];
+                  profileEnable = createDynamicDecl(dyn, function(env, scope) {
+                    return env.invoke(scope, dyn);
+                  });
+                }
+                return profileEnable;
+              }
+              function parseFramebuffer(options, env) {
+                var staticOptions = options.static;
+                var dynamicOptions = options.dynamic;
+                if (S_FRAMEBUFFER in staticOptions) {
+                  var framebuffer = staticOptions[S_FRAMEBUFFER];
+                  if (framebuffer) {
+                    framebuffer = framebufferState.getFramebuffer(framebuffer);
+                    return createStaticDecl(function(env2, block) {
+                      var FRAMEBUFFER = env2.link(framebuffer);
+                      var shared = env2.shared;
+                      block.set(
+                        shared.framebuffer,
+                        ".next",
+                        FRAMEBUFFER
+                      );
+                      var CONTEXT = shared.context;
+                      block.set(
+                        CONTEXT,
+                        "." + S_FRAMEBUFFER_WIDTH,
+                        FRAMEBUFFER + ".width"
+                      );
+                      block.set(
+                        CONTEXT,
+                        "." + S_FRAMEBUFFER_HEIGHT,
+                        FRAMEBUFFER + ".height"
+                      );
+                      return FRAMEBUFFER;
+                    });
+                  } else {
+                    return createStaticDecl(function(env2, scope) {
+                      var shared = env2.shared;
+                      scope.set(
+                        shared.framebuffer,
+                        ".next",
+                        "null"
+                      );
+                      var CONTEXT = shared.context;
+                      scope.set(
+                        CONTEXT,
+                        "." + S_FRAMEBUFFER_WIDTH,
+                        CONTEXT + "." + S_DRAWINGBUFFER_WIDTH
+                      );
+                      scope.set(
+                        CONTEXT,
+                        "." + S_FRAMEBUFFER_HEIGHT,
+                        CONTEXT + "." + S_DRAWINGBUFFER_HEIGHT
+                      );
+                      return "null";
+                    });
+                  }
+                } else if (S_FRAMEBUFFER in dynamicOptions) {
+                  var dyn = dynamicOptions[S_FRAMEBUFFER];
+                  return createDynamicDecl(dyn, function(env2, scope) {
+                    var FRAMEBUFFER_FUNC = env2.invoke(scope, dyn);
+                    var shared = env2.shared;
+                    var FRAMEBUFFER_STATE = shared.framebuffer;
+                    var FRAMEBUFFER = scope.def(
+                      FRAMEBUFFER_STATE,
+                      ".getFramebuffer(",
+                      FRAMEBUFFER_FUNC,
+                      ")"
+                    );
+                    scope.set(
+                      FRAMEBUFFER_STATE,
+                      ".next",
+                      FRAMEBUFFER
+                    );
+                    var CONTEXT = shared.context;
+                    scope.set(
+                      CONTEXT,
+                      "." + S_FRAMEBUFFER_WIDTH,
+                      FRAMEBUFFER + "?" + FRAMEBUFFER + ".width:" + CONTEXT + "." + S_DRAWINGBUFFER_WIDTH
+                    );
+                    scope.set(
+                      CONTEXT,
+                      "." + S_FRAMEBUFFER_HEIGHT,
+                      FRAMEBUFFER + "?" + FRAMEBUFFER + ".height:" + CONTEXT + "." + S_DRAWINGBUFFER_HEIGHT
+                    );
+                    return FRAMEBUFFER;
+                  });
+                } else {
+                  return null;
+                }
+              }
+              function parseViewportScissor(options, framebuffer, env) {
+                var staticOptions = options.static;
+                var dynamicOptions = options.dynamic;
+                function parseBox(param) {
+                  if (param in staticOptions) {
+                    var box = staticOptions[param];
+                    var isStatic2 = true;
+                    var x2 = box.x | 0;
+                    var y2 = box.y | 0;
+                    var w2, h2;
+                    if ("width" in box) {
+                      w2 = box.width | 0;
+                    } else {
+                      isStatic2 = false;
+                    }
+                    if ("height" in box) {
+                      h2 = box.height | 0;
+                    } else {
+                      isStatic2 = false;
+                    }
+                    return new Declaration(
+                      !isStatic2 && framebuffer && framebuffer.thisDep,
+                      !isStatic2 && framebuffer && framebuffer.contextDep,
+                      !isStatic2 && framebuffer && framebuffer.propDep,
+                      function(env2, scope) {
+                        var CONTEXT = env2.shared.context;
+                        var BOX_W = w2;
+                        if (!("width" in box)) {
+                          BOX_W = scope.def(CONTEXT, ".", S_FRAMEBUFFER_WIDTH, "-", x2);
+                        }
+                        var BOX_H = h2;
+                        if (!("height" in box)) {
+                          BOX_H = scope.def(CONTEXT, ".", S_FRAMEBUFFER_HEIGHT, "-", y2);
+                        }
+                        return [x2, y2, BOX_W, BOX_H];
+                      }
+                    );
+                  } else if (param in dynamicOptions) {
+                    var dynBox = dynamicOptions[param];
+                    var result = createDynamicDecl(dynBox, function(env2, scope) {
+                      var BOX = env2.invoke(scope, dynBox);
+                      var CONTEXT = env2.shared.context;
+                      var BOX_X = scope.def(BOX, ".x|0");
+                      var BOX_Y = scope.def(BOX, ".y|0");
+                      var BOX_W = scope.def(
+                        '"width" in ',
+                        BOX,
+                        "?",
+                        BOX,
+                        ".width|0:",
+                        "(",
+                        CONTEXT,
+                        ".",
+                        S_FRAMEBUFFER_WIDTH,
+                        "-",
+                        BOX_X,
+                        ")"
+                      );
+                      var BOX_H = scope.def(
+                        '"height" in ',
+                        BOX,
+                        "?",
+                        BOX,
+                        ".height|0:",
+                        "(",
+                        CONTEXT,
+                        ".",
+                        S_FRAMEBUFFER_HEIGHT,
+                        "-",
+                        BOX_Y,
+                        ")"
+                      );
+                      return [BOX_X, BOX_Y, BOX_W, BOX_H];
+                    });
+                    if (framebuffer) {
+                      result.thisDep = result.thisDep || framebuffer.thisDep;
+                      result.contextDep = result.contextDep || framebuffer.contextDep;
+                      result.propDep = result.propDep || framebuffer.propDep;
+                    }
+                    return result;
+                  } else if (framebuffer) {
+                    return new Declaration(
+                      framebuffer.thisDep,
+                      framebuffer.contextDep,
+                      framebuffer.propDep,
+                      function(env2, scope) {
+                        var CONTEXT = env2.shared.context;
+                        return [
+                          0,
+                          0,
+                          scope.def(CONTEXT, ".", S_FRAMEBUFFER_WIDTH),
+                          scope.def(CONTEXT, ".", S_FRAMEBUFFER_HEIGHT)
+                        ];
+                      }
+                    );
+                  } else {
+                    return null;
+                  }
+                }
+                var viewport = parseBox(S_VIEWPORT);
+                if (viewport) {
+                  var prevViewport = viewport;
+                  viewport = new Declaration(
+                    viewport.thisDep,
+                    viewport.contextDep,
+                    viewport.propDep,
+                    function(env2, scope) {
+                      var VIEWPORT = prevViewport.append(env2, scope);
+                      var CONTEXT = env2.shared.context;
+                      scope.set(
+                        CONTEXT,
+                        "." + S_VIEWPORT_WIDTH,
+                        VIEWPORT[2]
+                      );
+                      scope.set(
+                        CONTEXT,
+                        "." + S_VIEWPORT_HEIGHT,
+                        VIEWPORT[3]
+                      );
+                      return VIEWPORT;
+                    }
+                  );
+                }
+                return {
+                  viewport,
+                  scissor_box: parseBox(S_SCISSOR_BOX)
+                };
+              }
+              function parseAttribLocations(options, attributes) {
+                var staticOptions = options.static;
+                var staticProgram = typeof staticOptions[S_FRAG] === "string" && typeof staticOptions[S_VERT] === "string";
+                if (staticProgram) {
+                  if (Object.keys(attributes.dynamic).length > 0) {
+                    return null;
+                  }
+                  var staticAttributes = attributes.static;
+                  var sAttributes = Object.keys(staticAttributes);
+                  if (sAttributes.length > 0 && typeof staticAttributes[sAttributes[0]] === "number") {
+                    var bindings = [];
+                    for (var i2 = 0; i2 < sAttributes.length; ++i2) {
+                      bindings.push([staticAttributes[sAttributes[i2]] | 0, sAttributes[i2]]);
+                    }
+                    return bindings;
+                  }
+                }
+                return null;
+              }
+              function parseProgram(options, env, attribLocations) {
+                var staticOptions = options.static;
+                var dynamicOptions = options.dynamic;
+                function parseShader(name2) {
+                  if (name2 in staticOptions) {
+                    var id2 = stringStore.id(staticOptions[name2]);
+                    var result = createStaticDecl(function() {
+                      return id2;
+                    });
+                    result.id = id2;
+                    return result;
+                  } else if (name2 in dynamicOptions) {
+                    var dyn = dynamicOptions[name2];
+                    return createDynamicDecl(dyn, function(env2, scope) {
+                      var str = env2.invoke(scope, dyn);
+                      var id22 = scope.def(env2.shared.strings, ".id(", str, ")");
+                      return id22;
+                    });
+                  }
+                  return null;
+                }
+                var frag = parseShader(S_FRAG);
+                var vert = parseShader(S_VERT);
+                var program = null;
+                var progVar;
+                if (isStatic(frag) && isStatic(vert)) {
+                  program = shaderState.program(vert.id, frag.id, null, attribLocations);
+                  progVar = createStaticDecl(function(env2, scope) {
+                    return env2.link(program);
+                  });
+                } else {
+                  progVar = new Declaration(
+                    frag && frag.thisDep || vert && vert.thisDep,
+                    frag && frag.contextDep || vert && vert.contextDep,
+                    frag && frag.propDep || vert && vert.propDep,
+                    function(env2, scope) {
+                      var SHADER_STATE = env2.shared.shader;
+                      var fragId;
+                      if (frag) {
+                        fragId = frag.append(env2, scope);
+                      } else {
+                        fragId = scope.def(SHADER_STATE, ".", S_FRAG);
+                      }
+                      var vertId;
+                      if (vert) {
+                        vertId = vert.append(env2, scope);
+                      } else {
+                        vertId = scope.def(SHADER_STATE, ".", S_VERT);
+                      }
+                      var progDef = SHADER_STATE + ".program(" + vertId + "," + fragId;
+                      return scope.def(progDef + ")");
+                    }
+                  );
+                }
+                return {
+                  frag,
+                  vert,
+                  progVar,
+                  program
+                };
+              }
+              function parseDraw(options, env) {
+                var staticOptions = options.static;
+                var dynamicOptions = options.dynamic;
+                var staticDraw = {};
+                var vaoActive = false;
+                function parseVAO() {
+                  if (S_VAO in staticOptions) {
+                    var vao2 = staticOptions[S_VAO];
+                    if (vao2 !== null && attributeState.getVAO(vao2) === null) {
+                      vao2 = attributeState.createVAO(vao2);
+                    }
+                    vaoActive = true;
+                    staticDraw.vao = vao2;
+                    return createStaticDecl(function(env2) {
+                      var vaoRef = attributeState.getVAO(vao2);
+                      if (vaoRef) {
+                        return env2.link(vaoRef);
+                      } else {
+                        return "null";
+                      }
+                    });
+                  } else if (S_VAO in dynamicOptions) {
+                    vaoActive = true;
+                    var dyn = dynamicOptions[S_VAO];
+                    return createDynamicDecl(dyn, function(env2, scope) {
+                      var vaoRef = env2.invoke(scope, dyn);
+                      return scope.def(env2.shared.vao + ".getVAO(" + vaoRef + ")");
+                    });
+                  }
+                  return null;
+                }
+                var vao = parseVAO();
+                var elementsActive = false;
+                function parseElements() {
+                  if (S_ELEMENTS in staticOptions) {
+                    var elements2 = staticOptions[S_ELEMENTS];
+                    staticDraw.elements = elements2;
+                    if (isBufferArgs(elements2)) {
+                      var e2 = staticDraw.elements = elementState.create(elements2, true);
+                      elements2 = elementState.getElements(e2);
+                      elementsActive = true;
+                    } else if (elements2) {
+                      elements2 = elementState.getElements(elements2);
+                      elementsActive = true;
+                    }
+                    var result = createStaticDecl(function(env2, scope) {
+                      if (elements2) {
+                        var result2 = env2.link(elements2);
+                        env2.ELEMENTS = result2;
+                        return result2;
+                      }
+                      env2.ELEMENTS = null;
+                      return null;
+                    });
+                    result.value = elements2;
+                    return result;
+                  } else if (S_ELEMENTS in dynamicOptions) {
+                    elementsActive = true;
+                    var dyn = dynamicOptions[S_ELEMENTS];
+                    return createDynamicDecl(dyn, function(env2, scope) {
+                      var shared = env2.shared;
+                      var IS_BUFFER_ARGS = shared.isBufferArgs;
+                      var ELEMENT_STATE = shared.elements;
+                      var elementDefn = env2.invoke(scope, dyn);
+                      var elements3 = scope.def("null");
+                      var elementStream = scope.def(IS_BUFFER_ARGS, "(", elementDefn, ")");
+                      var ifte = env2.cond(elementStream).then(elements3, "=", ELEMENT_STATE, ".createStream(", elementDefn, ");").else(elements3, "=", ELEMENT_STATE, ".getElements(", elementDefn, ");");
+                      scope.entry(ifte);
+                      scope.exit(
+                        env2.cond(elementStream).then(ELEMENT_STATE, ".destroyStream(", elements3, ");")
+                      );
+                      env2.ELEMENTS = elements3;
+                      return elements3;
+                    });
+                  } else if (vaoActive) {
+                    return new Declaration(
+                      vao.thisDep,
+                      vao.contextDep,
+                      vao.propDep,
+                      function(env2, scope) {
+                        return scope.def(env2.shared.vao + ".currentVAO?" + env2.shared.elements + ".getElements(" + env2.shared.vao + ".currentVAO.elements):null");
+                      }
+                    );
+                  }
+                  return null;
+                }
+                var elements = parseElements();
+                function parsePrimitive() {
+                  if (S_PRIMITIVE in staticOptions) {
+                    var primitive2 = staticOptions[S_PRIMITIVE];
+                    staticDraw.primitive = primitive2;
+                    return createStaticDecl(function(env2, scope) {
+                      return primTypes[primitive2];
+                    });
+                  } else if (S_PRIMITIVE in dynamicOptions) {
+                    var dynPrimitive = dynamicOptions[S_PRIMITIVE];
+                    return createDynamicDecl(dynPrimitive, function(env2, scope) {
+                      var PRIM_TYPES = env2.constants.primTypes;
+                      var prim = env2.invoke(scope, dynPrimitive);
+                      return scope.def(PRIM_TYPES, "[", prim, "]");
+                    });
+                  } else if (elementsActive) {
+                    if (isStatic(elements)) {
+                      if (elements.value) {
+                        return createStaticDecl(function(env2, scope) {
+                          return scope.def(env2.ELEMENTS, ".primType");
+                        });
+                      } else {
+                        return createStaticDecl(function() {
+                          return GL_TRIANGLES$1;
+                        });
+                      }
+                    } else {
+                      return new Declaration(
+                        elements.thisDep,
+                        elements.contextDep,
+                        elements.propDep,
+                        function(env2, scope) {
+                          var elements2 = env2.ELEMENTS;
+                          return scope.def(elements2, "?", elements2, ".primType:", GL_TRIANGLES$1);
+                        }
+                      );
+                    }
+                  } else if (vaoActive) {
+                    return new Declaration(
+                      vao.thisDep,
+                      vao.contextDep,
+                      vao.propDep,
+                      function(env2, scope) {
+                        return scope.def(env2.shared.vao + ".currentVAO?" + env2.shared.vao + ".currentVAO.primitive:" + GL_TRIANGLES$1);
+                      }
+                    );
+                  }
+                  return null;
+                }
+                function parseParam(param, isOffset) {
+                  if (param in staticOptions) {
+                    var value = staticOptions[param] | 0;
+                    if (isOffset) {
+                      staticDraw.offset = value;
+                    } else {
+                      staticDraw.instances = value;
+                    }
+                    return createStaticDecl(function(env2, scope) {
+                      if (isOffset) {
+                        env2.OFFSET = value;
+                      }
+                      return value;
+                    });
+                  } else if (param in dynamicOptions) {
+                    var dynValue = dynamicOptions[param];
+                    return createDynamicDecl(dynValue, function(env2, scope) {
+                      var result = env2.invoke(scope, dynValue);
+                      if (isOffset) {
+                        env2.OFFSET = result;
+                      }
+                      return result;
+                    });
+                  } else if (isOffset) {
+                    if (elementsActive) {
+                      return createStaticDecl(function(env2, scope) {
+                        env2.OFFSET = 0;
+                        return 0;
+                      });
+                    } else if (vaoActive) {
+                      return new Declaration(
+                        vao.thisDep,
+                        vao.contextDep,
+                        vao.propDep,
+                        function(env2, scope) {
+                          return scope.def(env2.shared.vao + ".currentVAO?" + env2.shared.vao + ".currentVAO.offset:0");
+                        }
+                      );
+                    }
+                  } else if (vaoActive) {
+                    return new Declaration(
+                      vao.thisDep,
+                      vao.contextDep,
+                      vao.propDep,
+                      function(env2, scope) {
+                        return scope.def(env2.shared.vao + ".currentVAO?" + env2.shared.vao + ".currentVAO.instances:-1");
+                      }
+                    );
+                  }
+                  return null;
+                }
+                var OFFSET = parseParam(S_OFFSET, true);
+                function parseVertCount() {
+                  if (S_COUNT in staticOptions) {
+                    var count22 = staticOptions[S_COUNT] | 0;
+                    staticDraw.count = count22;
+                    return createStaticDecl(function() {
+                      return count22;
+                    });
+                  } else if (S_COUNT in dynamicOptions) {
+                    var dynCount = dynamicOptions[S_COUNT];
+                    return createDynamicDecl(dynCount, function(env2, scope) {
+                      var result2 = env2.invoke(scope, dynCount);
+                      return result2;
+                    });
+                  } else if (elementsActive) {
+                    if (isStatic(elements)) {
+                      if (elements) {
+                        if (OFFSET) {
+                          return new Declaration(
+                            OFFSET.thisDep,
+                            OFFSET.contextDep,
+                            OFFSET.propDep,
+                            function(env2, scope) {
+                              var result2 = scope.def(
+                                env2.ELEMENTS,
+                                ".vertCount-",
+                                env2.OFFSET
+                              );
+                              return result2;
+                            }
+                          );
+                        } else {
+                          return createStaticDecl(function(env2, scope) {
+                            return scope.def(env2.ELEMENTS, ".vertCount");
+                          });
+                        }
+                      } else {
+                        var result = createStaticDecl(function() {
+                          return -1;
+                        });
+                        return result;
+                      }
+                    } else {
+                      var variable = new Declaration(
+                        elements.thisDep || OFFSET.thisDep,
+                        elements.contextDep || OFFSET.contextDep,
+                        elements.propDep || OFFSET.propDep,
+                        function(env2, scope) {
+                          var elements2 = env2.ELEMENTS;
+                          if (env2.OFFSET) {
+                            return scope.def(
+                              elements2,
+                              "?",
+                              elements2,
+                              ".vertCount-",
+                              env2.OFFSET,
+                              ":-1"
+                            );
+                          }
+                          return scope.def(elements2, "?", elements2, ".vertCount:-1");
+                        }
+                      );
+                      return variable;
+                    }
+                  } else if (vaoActive) {
+                    var countVariable = new Declaration(
+                      vao.thisDep,
+                      vao.contextDep,
+                      vao.propDep,
+                      function(env2, scope) {
+                        return scope.def(env2.shared.vao, ".currentVAO?", env2.shared.vao, ".currentVAO.count:-1");
+                      }
+                    );
+                    return countVariable;
+                  }
+                  return null;
+                }
+                var primitive = parsePrimitive();
+                var count2 = parseVertCount();
+                var instances = parseParam(S_INSTANCES, false);
+                return {
+                  elements,
+                  primitive,
+                  count: count2,
+                  instances,
+                  offset: OFFSET,
+                  vao,
+                  vaoActive,
+                  elementsActive,
+                  // static draw props
+                  static: staticDraw
+                };
+              }
+              function parseGLState(options, env) {
+                var staticOptions = options.static;
+                var dynamicOptions = options.dynamic;
+                var STATE = {};
+                GL_STATE_NAMES.forEach(function(prop) {
+                  var param = propName(prop);
+                  function parseParam(parseStatic, parseDynamic) {
+                    if (prop in staticOptions) {
+                      var value = parseStatic(staticOptions[prop]);
+                      STATE[param] = createStaticDecl(function() {
+                        return value;
+                      });
+                    } else if (prop in dynamicOptions) {
+                      var dyn = dynamicOptions[prop];
+                      STATE[param] = createDynamicDecl(dyn, function(env2, scope) {
+                        return parseDynamic(env2, scope, env2.invoke(scope, dyn));
+                      });
+                    }
+                  }
+                  switch (prop) {
+                    case S_CULL_ENABLE:
+                    case S_BLEND_ENABLE:
+                    case S_DITHER:
+                    case S_STENCIL_ENABLE:
+                    case S_DEPTH_ENABLE:
+                    case S_SCISSOR_ENABLE:
+                    case S_POLYGON_OFFSET_ENABLE:
+                    case S_SAMPLE_ALPHA:
+                    case S_SAMPLE_ENABLE:
+                    case S_DEPTH_MASK:
+                      return parseParam(
+                        function(value) {
+                          return value;
+                        },
+                        function(env2, scope, value) {
+                          return value;
+                        }
+                      );
+                    case S_DEPTH_FUNC:
+                      return parseParam(
+                        function(value) {
+                          return compareFuncs[value];
+                        },
+                        function(env2, scope, value) {
+                          var COMPARE_FUNCS = env2.constants.compareFuncs;
+                          return scope.def(COMPARE_FUNCS, "[", value, "]");
+                        }
+                      );
+                    case S_DEPTH_RANGE:
+                      return parseParam(
+                        function(value) {
+                          return value;
+                        },
+                        function(env2, scope, value) {
+                          var Z_NEAR = scope.def("+", value, "[0]");
+                          var Z_FAR = scope.def("+", value, "[1]");
+                          return [Z_NEAR, Z_FAR];
+                        }
+                      );
+                    case S_BLEND_FUNC:
+                      return parseParam(
+                        function(value) {
+                          var srcRGB = "srcRGB" in value ? value.srcRGB : value.src;
+                          var srcAlpha = "srcAlpha" in value ? value.srcAlpha : value.src;
+                          var dstRGB = "dstRGB" in value ? value.dstRGB : value.dst;
+                          var dstAlpha = "dstAlpha" in value ? value.dstAlpha : value.dst;
+                          return [
+                            blendFuncs[srcRGB],
+                            blendFuncs[dstRGB],
+                            blendFuncs[srcAlpha],
+                            blendFuncs[dstAlpha]
+                          ];
+                        },
+                        function(env2, scope, value) {
+                          var BLEND_FUNCS = env2.constants.blendFuncs;
+                          function read(prefix, suffix) {
+                            var func = scope.def(
+                              '"',
+                              prefix,
+                              suffix,
+                              '" in ',
+                              value,
+                              "?",
+                              value,
+                              ".",
+                              prefix,
+                              suffix,
+                              ":",
+                              value,
+                              ".",
+                              prefix
+                            );
+                            return func;
+                          }
+                          var srcRGB = read("src", "RGB");
+                          var dstRGB = read("dst", "RGB");
+                          var SRC_RGB = scope.def(BLEND_FUNCS, "[", srcRGB, "]");
+                          var SRC_ALPHA = scope.def(BLEND_FUNCS, "[", read("src", "Alpha"), "]");
+                          var DST_RGB = scope.def(BLEND_FUNCS, "[", dstRGB, "]");
+                          var DST_ALPHA = scope.def(BLEND_FUNCS, "[", read("dst", "Alpha"), "]");
+                          return [SRC_RGB, DST_RGB, SRC_ALPHA, DST_ALPHA];
+                        }
+                      );
+                    case S_BLEND_EQUATION:
+                      return parseParam(
+                        function(value) {
+                          if (typeof value === "string") {
+                            return [
+                              blendEquations[value],
+                              blendEquations[value]
+                            ];
+                          } else if (typeof value === "object") {
+                            return [
+                              blendEquations[value.rgb],
+                              blendEquations[value.alpha]
+                            ];
+                          } else ;
+                        },
+                        function(env2, scope, value) {
+                          var BLEND_EQUATIONS = env2.constants.blendEquations;
+                          var RGB = scope.def();
+                          var ALPHA = scope.def();
+                          var ifte = env2.cond("typeof ", value, '==="string"');
+                          ifte.then(
+                            RGB,
+                            "=",
+                            ALPHA,
+                            "=",
+                            BLEND_EQUATIONS,
+                            "[",
+                            value,
+                            "];"
+                          );
+                          ifte.else(
+                            RGB,
+                            "=",
+                            BLEND_EQUATIONS,
+                            "[",
+                            value,
+                            ".rgb];",
+                            ALPHA,
+                            "=",
+                            BLEND_EQUATIONS,
+                            "[",
+                            value,
+                            ".alpha];"
+                          );
+                          scope(ifte);
+                          return [RGB, ALPHA];
+                        }
+                      );
+                    case S_BLEND_COLOR:
+                      return parseParam(
+                        function(value) {
+                          return loop(4, function(i2) {
+                            return +value[i2];
+                          });
+                        },
+                        function(env2, scope, value) {
+                          return loop(4, function(i2) {
+                            return scope.def("+", value, "[", i2, "]");
+                          });
+                        }
+                      );
+                    case S_STENCIL_MASK:
+                      return parseParam(
+                        function(value) {
+                          return value | 0;
+                        },
+                        function(env2, scope, value) {
+                          return scope.def(value, "|0");
+                        }
+                      );
+                    case S_STENCIL_FUNC:
+                      return parseParam(
+                        function(value) {
+                          var cmp = value.cmp || "keep";
+                          var ref = value.ref || 0;
+                          var mask = "mask" in value ? value.mask : -1;
+                          return [
+                            compareFuncs[cmp],
+                            ref,
+                            mask
+                          ];
+                        },
+                        function(env2, scope, value) {
+                          var COMPARE_FUNCS = env2.constants.compareFuncs;
+                          var cmp = scope.def(
+                            '"cmp" in ',
+                            value,
+                            "?",
+                            COMPARE_FUNCS,
+                            "[",
+                            value,
+                            ".cmp]",
+                            ":",
+                            GL_KEEP
+                          );
+                          var ref = scope.def(value, ".ref|0");
+                          var mask = scope.def(
+                            '"mask" in ',
+                            value,
+                            "?",
+                            value,
+                            ".mask|0:-1"
+                          );
+                          return [cmp, ref, mask];
+                        }
+                      );
+                    case S_STENCIL_OPFRONT:
+                    case S_STENCIL_OPBACK:
+                      return parseParam(
+                        function(value) {
+                          var fail = value.fail || "keep";
+                          var zfail = value.zfail || "keep";
+                          var zpass = value.zpass || "keep";
+                          return [
+                            prop === S_STENCIL_OPBACK ? GL_BACK : GL_FRONT,
+                            stencilOps[fail],
+                            stencilOps[zfail],
+                            stencilOps[zpass]
+                          ];
+                        },
+                        function(env2, scope, value) {
+                          var STENCIL_OPS = env2.constants.stencilOps;
+                          function read(name2) {
+                            return scope.def(
+                              '"',
+                              name2,
+                              '" in ',
+                              value,
+                              "?",
+                              STENCIL_OPS,
+                              "[",
+                              value,
+                              ".",
+                              name2,
+                              "]:",
+                              GL_KEEP
+                            );
+                          }
+                          return [
+                            prop === S_STENCIL_OPBACK ? GL_BACK : GL_FRONT,
+                            read("fail"),
+                            read("zfail"),
+                            read("zpass")
+                          ];
+                        }
+                      );
+                    case S_POLYGON_OFFSET_OFFSET:
+                      return parseParam(
+                        function(value) {
+                          var factor = value.factor | 0;
+                          var units = value.units | 0;
+                          return [factor, units];
+                        },
+                        function(env2, scope, value) {
+                          var FACTOR = scope.def(value, ".factor|0");
+                          var UNITS = scope.def(value, ".units|0");
+                          return [FACTOR, UNITS];
+                        }
+                      );
+                    case S_CULL_FACE:
+                      return parseParam(
+                        function(value) {
+                          var face = 0;
+                          if (value === "front") {
+                            face = GL_FRONT;
+                          } else if (value === "back") {
+                            face = GL_BACK;
+                          }
+                          return face;
+                        },
+                        function(env2, scope, value) {
+                          return scope.def(value, '==="front"?', GL_FRONT, ":", GL_BACK);
+                        }
+                      );
+                    case S_LINE_WIDTH:
+                      return parseParam(
+                        function(value) {
+                          return value;
+                        },
+                        function(env2, scope, value) {
+                          return value;
+                        }
+                      );
+                    case S_FRONT_FACE:
+                      return parseParam(
+                        function(value) {
+                          return orientationType[value];
+                        },
+                        function(env2, scope, value) {
+                          return scope.def(value + '==="cw"?' + GL_CW + ":" + GL_CCW);
+                        }
+                      );
+                    case S_COLOR_MASK:
+                      return parseParam(
+                        function(value) {
+                          return value.map(function(v2) {
+                            return !!v2;
+                          });
+                        },
+                        function(env2, scope, value) {
+                          return loop(4, function(i2) {
+                            return "!!" + value + "[" + i2 + "]";
+                          });
+                        }
+                      );
+                    case S_SAMPLE_COVERAGE:
+                      return parseParam(
+                        function(value) {
+                          var sampleValue = "value" in value ? value.value : 1;
+                          var sampleInvert = !!value.invert;
+                          return [sampleValue, sampleInvert];
+                        },
+                        function(env2, scope, value) {
+                          var VALUE = scope.def(
+                            '"value" in ',
+                            value,
+                            "?+",
+                            value,
+                            ".value:1"
+                          );
+                          var INVERT = scope.def("!!", value, ".invert");
+                          return [VALUE, INVERT];
+                        }
+                      );
+                  }
+                });
+                return STATE;
+              }
+              function parseUniforms(uniforms, env) {
+                var staticUniforms = uniforms.static;
+                var dynamicUniforms = uniforms.dynamic;
+                var UNIFORMS = {};
+                Object.keys(staticUniforms).forEach(function(name2) {
+                  var value = staticUniforms[name2];
+                  var result;
+                  if (typeof value === "number" || typeof value === "boolean") {
+                    result = createStaticDecl(function() {
+                      return value;
+                    });
+                  } else if (typeof value === "function") {
+                    var reglType = value._reglType;
+                    if (reglType === "texture2d" || reglType === "textureCube") {
+                      result = createStaticDecl(function(env2) {
+                        return env2.link(value);
+                      });
+                    } else if (reglType === "framebuffer" || reglType === "framebufferCube") {
+                      result = createStaticDecl(function(env2) {
+                        return env2.link(value.color[0]);
+                      });
+                    } else ;
+                  } else if (isArrayLike(value)) {
+                    result = createStaticDecl(function(env2) {
+                      var ITEM = env2.global.def(
+                        "[",
+                        loop(value.length, function(i2) {
+                          return value[i2];
+                        }),
+                        "]"
+                      );
+                      return ITEM;
+                    });
+                  } else ;
+                  result.value = value;
+                  UNIFORMS[name2] = result;
+                });
+                Object.keys(dynamicUniforms).forEach(function(key) {
+                  var dyn = dynamicUniforms[key];
+                  UNIFORMS[key] = createDynamicDecl(dyn, function(env2, scope) {
+                    return env2.invoke(scope, dyn);
+                  });
+                });
+                return UNIFORMS;
+              }
+              function parseAttributes(attributes, env) {
+                var staticAttributes = attributes.static;
+                var dynamicAttributes = attributes.dynamic;
+                var attributeDefs = {};
+                Object.keys(staticAttributes).forEach(function(attribute) {
+                  var value = staticAttributes[attribute];
+                  var id2 = stringStore.id(attribute);
+                  var record = new AttributeRecord2();
+                  if (isBufferArgs(value)) {
+                    record.state = ATTRIB_STATE_POINTER;
+                    record.buffer = bufferState.getBuffer(
+                      bufferState.create(value, GL_ARRAY_BUFFER$2, false, true)
+                    );
+                    record.type = 0;
+                  } else {
+                    var buffer = bufferState.getBuffer(value);
+                    if (buffer) {
+                      record.state = ATTRIB_STATE_POINTER;
+                      record.buffer = buffer;
+                      record.type = 0;
+                    } else {
+                      if ("constant" in value) {
+                        var constant = value.constant;
+                        record.buffer = "null";
+                        record.state = ATTRIB_STATE_CONSTANT;
+                        if (typeof constant === "number") {
+                          record.x = constant;
+                        } else {
+                          CUTE_COMPONENTS.forEach(function(c2, i2) {
+                            if (i2 < constant.length) {
+                              record[c2] = constant[i2];
+                            }
+                          });
+                        }
+                      } else {
+                        if (isBufferArgs(value.buffer)) {
+                          buffer = bufferState.getBuffer(
+                            bufferState.create(value.buffer, GL_ARRAY_BUFFER$2, false, true)
+                          );
+                        } else {
+                          buffer = bufferState.getBuffer(value.buffer);
+                        }
+                        var offset = value.offset | 0;
+                        var stride = value.stride | 0;
+                        var size = value.size | 0;
+                        var normalized = !!value.normalized;
+                        var type = 0;
+                        if ("type" in value) {
+                          type = glTypes[value.type];
+                        }
+                        var divisor = value.divisor | 0;
+                        record.buffer = buffer;
+                        record.state = ATTRIB_STATE_POINTER;
+                        record.size = size;
+                        record.normalized = normalized;
+                        record.type = type || buffer.dtype;
+                        record.offset = offset;
+                        record.stride = stride;
+                        record.divisor = divisor;
+                      }
+                    }
+                  }
+                  attributeDefs[attribute] = createStaticDecl(function(env2, scope) {
+                    var cache = env2.attribCache;
+                    if (id2 in cache) {
+                      return cache[id2];
+                    }
+                    var result = {
+                      isStream: false
+                    };
+                    Object.keys(record).forEach(function(key) {
+                      result[key] = record[key];
+                    });
+                    if (record.buffer) {
+                      result.buffer = env2.link(record.buffer);
+                      result.type = result.type || result.buffer + ".dtype";
+                    }
+                    cache[id2] = result;
+                    return result;
+                  });
+                });
+                Object.keys(dynamicAttributes).forEach(function(attribute) {
+                  var dyn = dynamicAttributes[attribute];
+                  function appendAttributeCode(env2, block) {
+                    var VALUE = env2.invoke(block, dyn);
+                    var shared = env2.shared;
+                    var constants = env2.constants;
+                    var IS_BUFFER_ARGS = shared.isBufferArgs;
+                    var BUFFER_STATE = shared.buffer;
+                    var result = {
+                      isStream: block.def(false)
+                    };
+                    var defaultRecord = new AttributeRecord2();
+                    defaultRecord.state = ATTRIB_STATE_POINTER;
+                    Object.keys(defaultRecord).forEach(function(key) {
+                      result[key] = block.def("" + defaultRecord[key]);
+                    });
+                    var BUFFER = result.buffer;
+                    var TYPE = result.type;
+                    block(
+                      "if(",
+                      IS_BUFFER_ARGS,
+                      "(",
+                      VALUE,
+                      ")){",
+                      result.isStream,
+                      "=true;",
+                      BUFFER,
+                      "=",
+                      BUFFER_STATE,
+                      ".createStream(",
+                      GL_ARRAY_BUFFER$2,
+                      ",",
+                      VALUE,
+                      ");",
+                      TYPE,
+                      "=",
+                      BUFFER,
+                      ".dtype;",
+                      "}else{",
+                      BUFFER,
+                      "=",
+                      BUFFER_STATE,
+                      ".getBuffer(",
+                      VALUE,
+                      ");",
+                      "if(",
+                      BUFFER,
+                      "){",
+                      TYPE,
+                      "=",
+                      BUFFER,
+                      ".dtype;",
+                      '}else if("constant" in ',
+                      VALUE,
+                      "){",
+                      result.state,
+                      "=",
+                      ATTRIB_STATE_CONSTANT,
+                      ";",
+                      "if(typeof " + VALUE + '.constant === "number"){',
+                      result[CUTE_COMPONENTS[0]],
+                      "=",
+                      VALUE,
+                      ".constant;",
+                      CUTE_COMPONENTS.slice(1).map(function(n2) {
+                        return result[n2];
+                      }).join("="),
+                      "=0;",
+                      "}else{",
+                      CUTE_COMPONENTS.map(function(name2, i2) {
+                        return result[name2] + "=" + VALUE + ".constant.length>" + i2 + "?" + VALUE + ".constant[" + i2 + "]:0;";
+                      }).join(""),
+                      "}}else{",
+                      "if(",
+                      IS_BUFFER_ARGS,
+                      "(",
+                      VALUE,
+                      ".buffer)){",
+                      BUFFER,
+                      "=",
+                      BUFFER_STATE,
+                      ".createStream(",
+                      GL_ARRAY_BUFFER$2,
+                      ",",
+                      VALUE,
+                      ".buffer);",
+                      "}else{",
+                      BUFFER,
+                      "=",
+                      BUFFER_STATE,
+                      ".getBuffer(",
+                      VALUE,
+                      ".buffer);",
+                      "}",
+                      TYPE,
+                      '="type" in ',
+                      VALUE,
+                      "?",
+                      constants.glTypes,
+                      "[",
+                      VALUE,
+                      ".type]:",
+                      BUFFER,
+                      ".dtype;",
+                      result.normalized,
+                      "=!!",
+                      VALUE,
+                      ".normalized;"
+                    );
+                    function emitReadRecord(name2) {
+                      block(result[name2], "=", VALUE, ".", name2, "|0;");
+                    }
+                    emitReadRecord("size");
+                    emitReadRecord("offset");
+                    emitReadRecord("stride");
+                    emitReadRecord("divisor");
+                    block("}}");
+                    block.exit(
+                      "if(",
+                      result.isStream,
+                      "){",
+                      BUFFER_STATE,
+                      ".destroyStream(",
+                      BUFFER,
+                      ");",
+                      "}"
+                    );
+                    return result;
+                  }
+                  attributeDefs[attribute] = createDynamicDecl(dyn, appendAttributeCode);
+                });
+                return attributeDefs;
+              }
+              function parseContext(context) {
+                var staticContext = context.static;
+                var dynamicContext = context.dynamic;
+                var result = {};
+                Object.keys(staticContext).forEach(function(name2) {
+                  var value = staticContext[name2];
+                  result[name2] = createStaticDecl(function(env, scope) {
+                    if (typeof value === "number" || typeof value === "boolean") {
+                      return "" + value;
+                    } else {
+                      return env.link(value);
+                    }
+                  });
+                });
+                Object.keys(dynamicContext).forEach(function(name2) {
+                  var dyn = dynamicContext[name2];
+                  result[name2] = createDynamicDecl(dyn, function(env, scope) {
+                    return env.invoke(scope, dyn);
+                  });
+                });
+                return result;
+              }
+              function parseArguments(options, attributes, uniforms, context, env) {
+                options.static;
+                options.dynamic;
+                var attribLocations = parseAttribLocations(options, attributes);
+                var framebuffer = parseFramebuffer(options);
+                var viewportAndScissor = parseViewportScissor(options, framebuffer);
+                var draw = parseDraw(options);
+                var state = parseGLState(options);
+                var shader = parseProgram(options, env, attribLocations);
+                function copyBox(name2) {
+                  var defn = viewportAndScissor[name2];
+                  if (defn) {
+                    state[name2] = defn;
+                  }
+                }
+                copyBox(S_VIEWPORT);
+                copyBox(propName(S_SCISSOR_BOX));
+                var dirty = Object.keys(state).length > 0;
+                var result = {
+                  framebuffer,
+                  draw,
+                  shader,
+                  state,
+                  dirty,
+                  scopeVAO: null,
+                  drawVAO: null,
+                  useVAO: false,
+                  attributes: {}
+                };
+                result.profile = parseProfile(options);
+                result.uniforms = parseUniforms(uniforms);
+                result.drawVAO = result.scopeVAO = draw.vao;
+                if (!result.drawVAO && shader.program && !attribLocations && extensions.angle_instanced_arrays && draw.static.elements) {
+                  var useVAO = true;
+                  var staticBindings = shader.program.attributes.map(function(attr) {
+                    var binding = attributes.static[attr];
+                    useVAO = useVAO && !!binding;
+                    return binding;
+                  });
+                  if (useVAO && staticBindings.length > 0) {
+                    var vao = attributeState.getVAO(attributeState.createVAO({
+                      attributes: staticBindings,
+                      elements: draw.static.elements
+                    }));
+                    result.drawVAO = new Declaration(null, null, null, function(env2, scope) {
+                      return env2.link(vao);
+                    });
+                    result.useVAO = true;
+                  }
+                }
+                if (attribLocations) {
+                  result.useVAO = true;
+                } else {
+                  result.attributes = parseAttributes(attributes);
+                }
+                result.context = parseContext(context);
+                return result;
+              }
+              function emitContext(env, scope, context) {
+                var shared = env.shared;
+                var CONTEXT = shared.context;
+                var contextEnter = env.scope();
+                Object.keys(context).forEach(function(name2) {
+                  scope.save(CONTEXT, "." + name2);
+                  var defn = context[name2];
+                  var value = defn.append(env, scope);
+                  if (Array.isArray(value)) {
+                    contextEnter(CONTEXT, ".", name2, "=[", value.join(), "];");
+                  } else {
+                    contextEnter(CONTEXT, ".", name2, "=", value, ";");
+                  }
+                });
+                scope(contextEnter);
+              }
+              function emitPollFramebuffer(env, scope, framebuffer, skipCheck) {
+                var shared = env.shared;
+                var GL = shared.gl;
+                var FRAMEBUFFER_STATE = shared.framebuffer;
+                var EXT_DRAW_BUFFERS;
+                if (extDrawBuffers) {
+                  EXT_DRAW_BUFFERS = scope.def(shared.extensions, ".webgl_draw_buffers");
+                }
+                var constants = env.constants;
+                var DRAW_BUFFERS = constants.drawBuffer;
+                var BACK_BUFFER = constants.backBuffer;
+                var NEXT;
+                if (framebuffer) {
+                  NEXT = framebuffer.append(env, scope);
+                } else {
+                  NEXT = scope.def(FRAMEBUFFER_STATE, ".next");
+                }
+                if (!skipCheck) {
+                  scope("if(", NEXT, "!==", FRAMEBUFFER_STATE, ".cur){");
+                }
+                scope(
+                  "if(",
+                  NEXT,
+                  "){",
+                  GL,
+                  ".bindFramebuffer(",
+                  GL_FRAMEBUFFER$2,
+                  ",",
+                  NEXT,
+                  ".framebuffer);"
+                );
+                if (extDrawBuffers) {
+                  scope(
+                    EXT_DRAW_BUFFERS,
+                    ".drawBuffersWEBGL(",
+                    DRAW_BUFFERS,
+                    "[",
+                    NEXT,
+                    ".colorAttachments.length]);"
+                  );
+                }
+                scope(
+                  "}else{",
+                  GL,
+                  ".bindFramebuffer(",
+                  GL_FRAMEBUFFER$2,
+                  ",null);"
+                );
+                if (extDrawBuffers) {
+                  scope(EXT_DRAW_BUFFERS, ".drawBuffersWEBGL(", BACK_BUFFER, ");");
+                }
+                scope(
+                  "}",
+                  FRAMEBUFFER_STATE,
+                  ".cur=",
+                  NEXT,
+                  ";"
+                );
+                if (!skipCheck) {
+                  scope("}");
+                }
+              }
+              function emitPollState(env, scope, args) {
+                var shared = env.shared;
+                var GL = shared.gl;
+                var CURRENT_VARS = env.current;
+                var NEXT_VARS = env.next;
+                var CURRENT_STATE = shared.current;
+                var NEXT_STATE = shared.next;
+                var block = env.cond(CURRENT_STATE, ".dirty");
+                GL_STATE_NAMES.forEach(function(prop) {
+                  var param = propName(prop);
+                  if (param in args.state) {
+                    return;
+                  }
+                  var NEXT, CURRENT;
+                  if (param in NEXT_VARS) {
+                    NEXT = NEXT_VARS[param];
+                    CURRENT = CURRENT_VARS[param];
+                    var parts = loop(currentState[param].length, function(i2) {
+                      return block.def(NEXT, "[", i2, "]");
+                    });
+                    block(env.cond(parts.map(function(p2, i2) {
+                      return p2 + "!==" + CURRENT + "[" + i2 + "]";
+                    }).join("||")).then(
+                      GL,
+                      ".",
+                      GL_VARIABLES[param],
+                      "(",
+                      parts,
+                      ");",
+                      parts.map(function(p2, i2) {
+                        return CURRENT + "[" + i2 + "]=" + p2;
+                      }).join(";"),
+                      ";"
+                    ));
+                  } else {
+                    NEXT = block.def(NEXT_STATE, ".", param);
+                    var ifte = env.cond(NEXT, "!==", CURRENT_STATE, ".", param);
+                    block(ifte);
+                    if (param in GL_FLAGS) {
+                      ifte(
+                        env.cond(NEXT).then(GL, ".enable(", GL_FLAGS[param], ");").else(GL, ".disable(", GL_FLAGS[param], ");"),
+                        CURRENT_STATE,
+                        ".",
+                        param,
+                        "=",
+                        NEXT,
+                        ";"
+                      );
+                    } else {
+                      ifte(
+                        GL,
+                        ".",
+                        GL_VARIABLES[param],
+                        "(",
+                        NEXT,
+                        ");",
+                        CURRENT_STATE,
+                        ".",
+                        param,
+                        "=",
+                        NEXT,
+                        ";"
+                      );
+                    }
+                  }
+                });
+                if (Object.keys(args.state).length === 0) {
+                  block(CURRENT_STATE, ".dirty=false;");
+                }
+                scope(block);
+              }
+              function emitSetOptions(env, scope, options, filter) {
+                var shared = env.shared;
+                var CURRENT_VARS = env.current;
+                var CURRENT_STATE = shared.current;
+                var GL = shared.gl;
+                var VALUE;
+                sortState(Object.keys(options)).forEach(function(param) {
+                  var defn = options[param];
+                  if (filter && !filter(defn)) {
+                    return;
+                  }
+                  var variable = defn.append(env, scope);
+                  if (GL_FLAGS[param]) {
+                    var flag = GL_FLAGS[param];
+                    if (isStatic(defn)) {
+                      VALUE = env.link(variable, { stable: true });
+                      scope(env.cond(VALUE).then(GL, ".enable(", flag, ");").else(GL, ".disable(", flag, ");"));
+                      scope(CURRENT_STATE, ".", param, "=", VALUE, ";");
+                    } else {
+                      scope(env.cond(variable).then(GL, ".enable(", flag, ");").else(GL, ".disable(", flag, ");"));
+                      scope(CURRENT_STATE, ".", param, "=", variable, ";");
+                    }
+                  } else if (isArrayLike(variable)) {
+                    var CURRENT = CURRENT_VARS[param];
+                    scope(
+                      GL,
+                      ".",
+                      GL_VARIABLES[param],
+                      "(",
+                      variable,
+                      ");",
+                      variable.map(function(v2, i2) {
+                        return CURRENT + "[" + i2 + "]=" + v2;
+                      }).join(";"),
+                      ";"
+                    );
+                  } else {
+                    if (isStatic(defn)) {
+                      VALUE = env.link(variable, { stable: true });
+                      scope(
+                        GL,
+                        ".",
+                        GL_VARIABLES[param],
+                        "(",
+                        VALUE,
+                        ");",
+                        CURRENT_STATE,
+                        ".",
+                        param,
+                        "=",
+                        VALUE,
+                        ";"
+                      );
+                    } else {
+                      scope(
+                        GL,
+                        ".",
+                        GL_VARIABLES[param],
+                        "(",
+                        variable,
+                        ");",
+                        CURRENT_STATE,
+                        ".",
+                        param,
+                        "=",
+                        variable,
+                        ";"
+                      );
+                    }
+                  }
+                });
+              }
+              function injectExtensions(env, scope) {
+                if (extInstancing) {
+                  env.instancing = scope.def(
+                    env.shared.extensions,
+                    ".angle_instanced_arrays"
+                  );
+                }
+              }
+              function emitProfile(env, scope, args, useScope, incrementCounter) {
+                var shared = env.shared;
+                var STATS = env.stats;
+                var CURRENT_STATE = shared.current;
+                var TIMER = shared.timer;
+                var profileArg = args.profile;
+                function perfCounter() {
+                  if (typeof performance === "undefined") {
+                    return "Date.now()";
+                  } else {
+                    return "performance.now()";
+                  }
+                }
+                var CPU_START, QUERY_COUNTER;
+                function emitProfileStart(block) {
+                  CPU_START = scope.def();
+                  block(CPU_START, "=", perfCounter(), ";");
+                  if (typeof incrementCounter === "string") {
+                    block(STATS, ".count+=", incrementCounter, ";");
+                  } else {
+                    block(STATS, ".count++;");
+                  }
+                  if (timer) {
+                    if (useScope) {
+                      QUERY_COUNTER = scope.def();
+                      block(QUERY_COUNTER, "=", TIMER, ".getNumPendingQueries();");
+                    } else {
+                      block(TIMER, ".beginQuery(", STATS, ");");
+                    }
+                  }
+                }
+                function emitProfileEnd(block) {
+                  block(STATS, ".cpuTime+=", perfCounter(), "-", CPU_START, ";");
+                  if (timer) {
+                    if (useScope) {
+                      block(
+                        TIMER,
+                        ".pushScopeStats(",
+                        QUERY_COUNTER,
+                        ",",
+                        TIMER,
+                        ".getNumPendingQueries(),",
+                        STATS,
+                        ");"
+                      );
+                    } else {
+                      block(TIMER, ".endQuery();");
+                    }
+                  }
+                }
+                function scopeProfile(value) {
+                  var prev = scope.def(CURRENT_STATE, ".profile");
+                  scope(CURRENT_STATE, ".profile=", value, ";");
+                  scope.exit(CURRENT_STATE, ".profile=", prev, ";");
+                }
+                var USE_PROFILE;
+                if (profileArg) {
+                  if (isStatic(profileArg)) {
+                    if (profileArg.enable) {
+                      emitProfileStart(scope);
+                      emitProfileEnd(scope.exit);
+                      scopeProfile("true");
+                    } else {
+                      scopeProfile("false");
+                    }
+                    return;
+                  }
+                  USE_PROFILE = profileArg.append(env, scope);
+                  scopeProfile(USE_PROFILE);
+                } else {
+                  USE_PROFILE = scope.def(CURRENT_STATE, ".profile");
+                }
+                var start = env.block();
+                emitProfileStart(start);
+                scope("if(", USE_PROFILE, "){", start, "}");
+                var end = env.block();
+                emitProfileEnd(end);
+                scope.exit("if(", USE_PROFILE, "){", end, "}");
+              }
+              function emitAttributes(env, scope, args, attributes, filter) {
+                var shared = env.shared;
+                function typeLength(x2) {
+                  switch (x2) {
+                    case GL_FLOAT_VEC2:
+                    case GL_INT_VEC2:
+                    case GL_BOOL_VEC2:
+                      return 2;
+                    case GL_FLOAT_VEC3:
+                    case GL_INT_VEC3:
+                    case GL_BOOL_VEC3:
+                      return 3;
+                    case GL_FLOAT_VEC4:
+                    case GL_INT_VEC4:
+                    case GL_BOOL_VEC4:
+                      return 4;
+                    default:
+                      return 1;
+                  }
+                }
+                function emitBindAttribute(ATTRIBUTE, size, record) {
+                  var GL = shared.gl;
+                  var LOCATION = scope.def(ATTRIBUTE, ".location");
+                  var BINDING = scope.def(shared.attributes, "[", LOCATION, "]");
+                  var STATE = record.state;
+                  var BUFFER = record.buffer;
+                  var CONST_COMPONENTS = [
+                    record.x,
+                    record.y,
+                    record.z,
+                    record.w
+                  ];
+                  var COMMON_KEYS = [
+                    "buffer",
+                    "normalized",
+                    "offset",
+                    "stride"
+                  ];
+                  function emitBuffer() {
+                    scope(
+                      "if(!",
+                      BINDING,
+                      ".buffer){",
+                      GL,
+                      ".enableVertexAttribArray(",
+                      LOCATION,
+                      ");}"
+                    );
+                    var TYPE = record.type;
+                    var SIZE;
+                    if (!record.size) {
+                      SIZE = size;
+                    } else {
+                      SIZE = scope.def(record.size, "||", size);
+                    }
+                    scope(
+                      "if(",
+                      BINDING,
+                      ".type!==",
+                      TYPE,
+                      "||",
+                      BINDING,
+                      ".size!==",
+                      SIZE,
+                      "||",
+                      COMMON_KEYS.map(function(key) {
+                        return BINDING + "." + key + "!==" + record[key];
+                      }).join("||"),
+                      "){",
+                      GL,
+                      ".bindBuffer(",
+                      GL_ARRAY_BUFFER$2,
+                      ",",
+                      BUFFER,
+                      ".buffer);",
+                      GL,
+                      ".vertexAttribPointer(",
+                      [
+                        LOCATION,
+                        SIZE,
+                        TYPE,
+                        record.normalized,
+                        record.stride,
+                        record.offset
+                      ],
+                      ");",
+                      BINDING,
+                      ".type=",
+                      TYPE,
+                      ";",
+                      BINDING,
+                      ".size=",
+                      SIZE,
+                      ";",
+                      COMMON_KEYS.map(function(key) {
+                        return BINDING + "." + key + "=" + record[key] + ";";
+                      }).join(""),
+                      "}"
+                    );
+                    if (extInstancing) {
+                      var DIVISOR = record.divisor;
+                      scope(
+                        "if(",
+                        BINDING,
+                        ".divisor!==",
+                        DIVISOR,
+                        "){",
+                        env.instancing,
+                        ".vertexAttribDivisorANGLE(",
+                        [LOCATION, DIVISOR],
+                        ");",
+                        BINDING,
+                        ".divisor=",
+                        DIVISOR,
+                        ";}"
+                      );
+                    }
+                  }
+                  function emitConstant() {
+                    scope(
+                      "if(",
+                      BINDING,
+                      ".buffer){",
+                      GL,
+                      ".disableVertexAttribArray(",
+                      LOCATION,
+                      ");",
+                      BINDING,
+                      ".buffer=null;",
+                      "}if(",
+                      CUTE_COMPONENTS.map(function(c2, i2) {
+                        return BINDING + "." + c2 + "!==" + CONST_COMPONENTS[i2];
+                      }).join("||"),
+                      "){",
+                      GL,
+                      ".vertexAttrib4f(",
+                      LOCATION,
+                      ",",
+                      CONST_COMPONENTS,
+                      ");",
+                      CUTE_COMPONENTS.map(function(c2, i2) {
+                        return BINDING + "." + c2 + "=" + CONST_COMPONENTS[i2] + ";";
+                      }).join(""),
+                      "}"
+                    );
+                  }
+                  if (STATE === ATTRIB_STATE_POINTER) {
+                    emitBuffer();
+                  } else if (STATE === ATTRIB_STATE_CONSTANT) {
+                    emitConstant();
+                  } else {
+                    scope("if(", STATE, "===", ATTRIB_STATE_POINTER, "){");
+                    emitBuffer();
+                    scope("}else{");
+                    emitConstant();
+                    scope("}");
+                  }
+                }
+                attributes.forEach(function(attribute) {
+                  var name2 = attribute.name;
+                  var arg = args.attributes[name2];
+                  var record;
+                  if (arg) {
+                    if (!filter(arg)) {
+                      return;
+                    }
+                    record = arg.append(env, scope);
+                  } else {
+                    if (!filter(SCOPE_DECL)) {
+                      return;
+                    }
+                    var scopeAttrib = env.scopeAttrib(name2);
+                    record = {};
+                    Object.keys(new AttributeRecord2()).forEach(function(key) {
+                      record[key] = scope.def(scopeAttrib, ".", key);
+                    });
+                  }
+                  emitBindAttribute(
+                    env.link(attribute),
+                    typeLength(attribute.info.type),
+                    record
+                  );
+                });
+              }
+              function emitUniforms(env, scope, args, uniforms, filter, isBatchInnerLoop) {
+                var shared = env.shared;
+                var GL = shared.gl;
+                var infix;
+                for (var i2 = 0; i2 < uniforms.length; ++i2) {
+                  var uniform = uniforms[i2];
+                  var name2 = uniform.name;
+                  var type = uniform.info.type;
+                  var arg = args.uniforms[name2];
+                  var UNIFORM = env.link(uniform);
+                  var LOCATION = UNIFORM + ".location";
+                  var VALUE;
+                  if (arg) {
+                    if (!filter(arg)) {
+                      continue;
+                    }
+                    if (isStatic(arg)) {
+                      var value = arg.value;
+                      if (type === GL_SAMPLER_2D || type === GL_SAMPLER_CUBE) {
+                        var TEX_VALUE = env.link(value._texture || value.color[0]._texture);
+                        scope(GL, ".uniform1i(", LOCATION, ",", TEX_VALUE + ".bind());");
+                        scope.exit(TEX_VALUE, ".unbind();");
+                      } else if (type === GL_FLOAT_MAT2 || type === GL_FLOAT_MAT3 || type === GL_FLOAT_MAT4) {
+                        var MAT_VALUE = env.global.def("new Float32Array([" + Array.prototype.slice.call(value) + "])");
+                        var dim = 2;
+                        if (type === GL_FLOAT_MAT3) {
+                          dim = 3;
+                        } else if (type === GL_FLOAT_MAT4) {
+                          dim = 4;
+                        }
+                        scope(
+                          GL,
+                          ".uniformMatrix",
+                          dim,
+                          "fv(",
+                          LOCATION,
+                          ",false,",
+                          MAT_VALUE,
+                          ");"
+                        );
+                      } else {
+                        switch (type) {
+                          case GL_FLOAT$7:
+                            infix = "1f";
+                            break;
+                          case GL_FLOAT_VEC2:
+                            infix = "2f";
+                            break;
+                          case GL_FLOAT_VEC3:
+                            infix = "3f";
+                            break;
+                          case GL_FLOAT_VEC4:
+                            infix = "4f";
+                            break;
+                          case GL_BOOL:
+                            infix = "1i";
+                            break;
+                          case GL_INT$2:
+                            infix = "1i";
+                            break;
+                          case GL_BOOL_VEC2:
+                            infix = "2i";
+                            break;
+                          case GL_INT_VEC2:
+                            infix = "2i";
+                            break;
+                          case GL_BOOL_VEC3:
+                            infix = "3i";
+                            break;
+                          case GL_INT_VEC3:
+                            infix = "3i";
+                            break;
+                          case GL_BOOL_VEC4:
+                            infix = "4i";
+                            break;
+                          case GL_INT_VEC4:
+                            infix = "4i";
+                            break;
+                        }
+                        scope(
+                          GL,
+                          ".uniform",
+                          infix,
+                          "(",
+                          LOCATION,
+                          ",",
+                          isArrayLike(value) ? Array.prototype.slice.call(value) : value,
+                          ");"
+                        );
+                      }
+                      continue;
+                    } else {
+                      VALUE = arg.append(env, scope);
+                    }
+                  } else {
+                    if (!filter(SCOPE_DECL)) {
+                      continue;
+                    }
+                    VALUE = scope.def(shared.uniforms, "[", stringStore.id(name2), "]");
+                  }
+                  if (type === GL_SAMPLER_2D) {
+                    scope(
+                      "if(",
+                      VALUE,
+                      "&&",
+                      VALUE,
+                      '._reglType==="framebuffer"){',
+                      VALUE,
+                      "=",
+                      VALUE,
+                      ".color[0];",
+                      "}"
+                    );
+                  } else if (type === GL_SAMPLER_CUBE) {
+                    scope(
+                      "if(",
+                      VALUE,
+                      "&&",
+                      VALUE,
+                      '._reglType==="framebufferCube"){',
+                      VALUE,
+                      "=",
+                      VALUE,
+                      ".color[0];",
+                      "}"
+                    );
+                  }
+                  var unroll = 1;
+                  switch (type) {
+                    case GL_SAMPLER_2D:
+                    case GL_SAMPLER_CUBE:
+                      var TEX = scope.def(VALUE, "._texture");
+                      scope(GL, ".uniform1i(", LOCATION, ",", TEX, ".bind());");
+                      scope.exit(TEX, ".unbind();");
+                      continue;
+                    case GL_INT$2:
+                    case GL_BOOL:
+                      infix = "1i";
+                      break;
+                    case GL_INT_VEC2:
+                    case GL_BOOL_VEC2:
+                      infix = "2i";
+                      unroll = 2;
+                      break;
+                    case GL_INT_VEC3:
+                    case GL_BOOL_VEC3:
+                      infix = "3i";
+                      unroll = 3;
+                      break;
+                    case GL_INT_VEC4:
+                    case GL_BOOL_VEC4:
+                      infix = "4i";
+                      unroll = 4;
+                      break;
+                    case GL_FLOAT$7:
+                      infix = "1f";
+                      break;
+                    case GL_FLOAT_VEC2:
+                      infix = "2f";
+                      unroll = 2;
+                      break;
+                    case GL_FLOAT_VEC3:
+                      infix = "3f";
+                      unroll = 3;
+                      break;
+                    case GL_FLOAT_VEC4:
+                      infix = "4f";
+                      unroll = 4;
+                      break;
+                    case GL_FLOAT_MAT2:
+                      infix = "Matrix2fv";
+                      break;
+                    case GL_FLOAT_MAT3:
+                      infix = "Matrix3fv";
+                      break;
+                    case GL_FLOAT_MAT4:
+                      infix = "Matrix4fv";
+                      break;
+                  }
+                  if (infix.charAt(0) === "M") {
+                    scope(GL, ".uniform", infix, "(", LOCATION, ",");
+                    var matSize = Math.pow(type - GL_FLOAT_MAT2 + 2, 2);
+                    var STORAGE = env.global.def("new Float32Array(", matSize, ")");
+                    if (Array.isArray(VALUE)) {
+                      scope(
+                        "false,(",
+                        loop(matSize, function(i22) {
+                          return STORAGE + "[" + i22 + "]=" + VALUE[i22];
+                        }),
+                        ",",
+                        STORAGE,
+                        ")"
+                      );
+                    } else {
+                      scope(
+                        "false,(Array.isArray(",
+                        VALUE,
+                        ")||",
+                        VALUE,
+                        " instanceof Float32Array)?",
+                        VALUE,
+                        ":(",
+                        loop(matSize, function(i22) {
+                          return STORAGE + "[" + i22 + "]=" + VALUE + "[" + i22 + "]";
+                        }),
+                        ",",
+                        STORAGE,
+                        ")"
+                      );
+                    }
+                    scope(");");
+                  } else if (unroll > 1) {
+                    var prev = [];
+                    var cur = [];
+                    for (var j2 = 0; j2 < unroll; ++j2) {
+                      if (Array.isArray(VALUE)) {
+                        cur.push(VALUE[j2]);
+                      } else {
+                        cur.push(scope.def(VALUE + "[" + j2 + "]"));
+                      }
+                      if (isBatchInnerLoop) {
+                        prev.push(scope.def());
+                      }
+                    }
+                    if (isBatchInnerLoop) {
+                      scope("if(!", env.batchId, "||", prev.map(function(p2, i22) {
+                        return p2 + "!==" + cur[i22];
+                      }).join("||"), "){", prev.map(function(p2, i22) {
+                        return p2 + "=" + cur[i22] + ";";
+                      }).join(""));
+                    }
+                    scope(GL, ".uniform", infix, "(", LOCATION, ",", cur.join(","), ");");
+                    if (isBatchInnerLoop) {
+                      scope("}");
+                    }
+                  } else {
+                    if (isBatchInnerLoop) {
+                      var prevS = scope.def();
+                      scope(
+                        "if(!",
+                        env.batchId,
+                        "||",
+                        prevS,
+                        "!==",
+                        VALUE,
+                        "){",
+                        prevS,
+                        "=",
+                        VALUE,
+                        ";"
+                      );
+                    }
+                    scope(GL, ".uniform", infix, "(", LOCATION, ",", VALUE, ");");
+                    if (isBatchInnerLoop) {
+                      scope("}");
+                    }
+                  }
+                }
+              }
+              function emitDraw(env, outer, inner, args) {
+                var shared = env.shared;
+                var GL = shared.gl;
+                var DRAW_STATE = shared.draw;
+                var drawOptions = args.draw;
+                function emitElements() {
+                  var defn = drawOptions.elements;
+                  var ELEMENTS2;
+                  var scope = outer;
+                  if (defn) {
+                    if (defn.contextDep && args.contextDynamic || defn.propDep) {
+                      scope = inner;
+                    }
+                    ELEMENTS2 = defn.append(env, scope);
+                    if (drawOptions.elementsActive) {
+                      scope(
+                        "if(" + ELEMENTS2 + ")" + GL + ".bindBuffer(" + GL_ELEMENT_ARRAY_BUFFER$2 + "," + ELEMENTS2 + ".buffer.buffer);"
+                      );
+                    }
+                  } else {
+                    ELEMENTS2 = scope.def();
+                    scope(
+                      ELEMENTS2,
+                      "=",
+                      DRAW_STATE,
+                      ".",
+                      S_ELEMENTS,
+                      ";",
+                      "if(",
+                      ELEMENTS2,
+                      "){",
+                      GL,
+                      ".bindBuffer(",
+                      GL_ELEMENT_ARRAY_BUFFER$2,
+                      ",",
+                      ELEMENTS2,
+                      ".buffer.buffer);}",
+                      "else if(",
+                      shared.vao,
+                      ".currentVAO){",
+                      ELEMENTS2,
+                      "=",
+                      env.shared.elements + ".getElements(" + shared.vao,
+                      ".currentVAO.elements);",
+                      !extVertexArrays ? "if(" + ELEMENTS2 + ")" + GL + ".bindBuffer(" + GL_ELEMENT_ARRAY_BUFFER$2 + "," + ELEMENTS2 + ".buffer.buffer);" : "",
+                      "}"
+                    );
+                  }
+                  return ELEMENTS2;
+                }
+                function emitCount() {
+                  var defn = drawOptions.count;
+                  var COUNT2;
+                  var scope = outer;
+                  if (defn) {
+                    if (defn.contextDep && args.contextDynamic || defn.propDep) {
+                      scope = inner;
+                    }
+                    COUNT2 = defn.append(env, scope);
+                  } else {
+                    COUNT2 = scope.def(DRAW_STATE, ".", S_COUNT);
+                  }
+                  return COUNT2;
+                }
+                var ELEMENTS = emitElements();
+                function emitValue(name2) {
+                  var defn = drawOptions[name2];
+                  if (defn) {
+                    if (defn.contextDep && args.contextDynamic || defn.propDep) {
+                      return defn.append(env, inner);
+                    } else {
+                      return defn.append(env, outer);
+                    }
+                  } else {
+                    return outer.def(DRAW_STATE, ".", name2);
+                  }
+                }
+                var PRIMITIVE = emitValue(S_PRIMITIVE);
+                var OFFSET = emitValue(S_OFFSET);
+                var COUNT = emitCount();
+                if (typeof COUNT === "number") {
+                  if (COUNT === 0) {
+                    return;
+                  }
+                } else {
+                  inner("if(", COUNT, "){");
+                  inner.exit("}");
+                }
+                var INSTANCES, EXT_INSTANCING;
+                if (extInstancing) {
+                  INSTANCES = emitValue(S_INSTANCES);
+                  EXT_INSTANCING = env.instancing;
+                }
+                var ELEMENT_TYPE = ELEMENTS + ".type";
+                var elementsStatic = drawOptions.elements && isStatic(drawOptions.elements) && !drawOptions.vaoActive;
+                function emitInstancing() {
+                  function drawElements() {
+                    inner(EXT_INSTANCING, ".drawElementsInstancedANGLE(", [
+                      PRIMITIVE,
+                      COUNT,
+                      ELEMENT_TYPE,
+                      OFFSET + "<<((" + ELEMENT_TYPE + "-" + GL_UNSIGNED_BYTE$7 + ")>>1)",
+                      INSTANCES
+                    ], ");");
+                  }
+                  function drawArrays() {
+                    inner(
+                      EXT_INSTANCING,
+                      ".drawArraysInstancedANGLE(",
+                      [PRIMITIVE, OFFSET, COUNT, INSTANCES],
+                      ");"
+                    );
+                  }
+                  if (ELEMENTS && ELEMENTS !== "null") {
+                    if (!elementsStatic) {
+                      inner("if(", ELEMENTS, "){");
+                      drawElements();
+                      inner("}else{");
+                      drawArrays();
+                      inner("}");
+                    } else {
+                      drawElements();
+                    }
+                  } else {
+                    drawArrays();
+                  }
+                }
+                function emitRegular() {
+                  function drawElements() {
+                    inner(GL + ".drawElements(" + [
+                      PRIMITIVE,
+                      COUNT,
+                      ELEMENT_TYPE,
+                      OFFSET + "<<((" + ELEMENT_TYPE + "-" + GL_UNSIGNED_BYTE$7 + ")>>1)"
+                    ] + ");");
+                  }
+                  function drawArrays() {
+                    inner(GL + ".drawArrays(" + [PRIMITIVE, OFFSET, COUNT] + ");");
+                  }
+                  if (ELEMENTS && ELEMENTS !== "null") {
+                    if (!elementsStatic) {
+                      inner("if(", ELEMENTS, "){");
+                      drawElements();
+                      inner("}else{");
+                      drawArrays();
+                      inner("}");
+                    } else {
+                      drawElements();
+                    }
+                  } else {
+                    drawArrays();
+                  }
+                }
+                if (extInstancing && (typeof INSTANCES !== "number" || INSTANCES >= 0)) {
+                  if (typeof INSTANCES === "string") {
+                    inner("if(", INSTANCES, ">0){");
+                    emitInstancing();
+                    inner("}else if(", INSTANCES, "<0){");
+                    emitRegular();
+                    inner("}");
+                  } else {
+                    emitInstancing();
+                  }
+                } else {
+                  emitRegular();
+                }
+              }
+              function createBody(emitBody, parentEnv, args, program, count2) {
+                var env = createREGLEnvironment();
+                var scope = env.proc("body", count2);
+                if (extInstancing) {
+                  env.instancing = scope.def(
+                    env.shared.extensions,
+                    ".angle_instanced_arrays"
+                  );
+                }
+                emitBody(env, scope, args, program);
+                return env.compile().body;
+              }
+              function emitDrawBody(env, draw, args, program) {
+                injectExtensions(env, draw);
+                if (args.useVAO) {
+                  if (args.drawVAO) {
+                    draw(env.shared.vao, ".setVAO(", args.drawVAO.append(env, draw), ");");
+                  } else {
+                    draw(env.shared.vao, ".setVAO(", env.shared.vao, ".targetVAO);");
+                  }
+                } else {
+                  draw(env.shared.vao, ".setVAO(null);");
+                  emitAttributes(env, draw, args, program.attributes, function() {
+                    return true;
+                  });
+                }
+                emitUniforms(env, draw, args, program.uniforms, function() {
+                  return true;
+                }, false);
+                emitDraw(env, draw, draw, args);
+              }
+              function emitDrawProc(env, args) {
+                var draw = env.proc("draw", 1);
+                injectExtensions(env, draw);
+                emitContext(env, draw, args.context);
+                emitPollFramebuffer(env, draw, args.framebuffer);
+                emitPollState(env, draw, args);
+                emitSetOptions(env, draw, args.state);
+                emitProfile(env, draw, args, false, true);
+                var program = args.shader.progVar.append(env, draw);
+                draw(env.shared.gl, ".useProgram(", program, ".program);");
+                if (args.shader.program) {
+                  emitDrawBody(env, draw, args, args.shader.program);
+                } else {
+                  draw(env.shared.vao, ".setVAO(null);");
+                  var drawCache = env.global.def("{}");
+                  var PROG_ID = draw.def(program, ".id");
+                  var CACHED_PROC = draw.def(drawCache, "[", PROG_ID, "]");
+                  draw(
+                    env.cond(CACHED_PROC).then(CACHED_PROC, ".call(this,a0);").else(
+                      CACHED_PROC,
+                      "=",
+                      drawCache,
+                      "[",
+                      PROG_ID,
+                      "]=",
+                      env.link(function(program2) {
+                        return createBody(emitDrawBody, env, args, program2, 1);
+                      }),
+                      "(",
+                      program,
+                      ");",
+                      CACHED_PROC,
+                      ".call(this,a0);"
+                    )
+                  );
+                }
+                if (Object.keys(args.state).length > 0) {
+                  draw(env.shared.current, ".dirty=true;");
+                }
+                if (env.shared.vao) {
+                  draw(env.shared.vao, ".setVAO(null);");
+                }
+              }
+              function emitBatchDynamicShaderBody(env, scope, args, program) {
+                env.batchId = "a1";
+                injectExtensions(env, scope);
+                function all() {
+                  return true;
+                }
+                emitAttributes(env, scope, args, program.attributes, all);
+                emitUniforms(env, scope, args, program.uniforms, all, false);
+                emitDraw(env, scope, scope, args);
+              }
+              function emitBatchBody(env, scope, args, program) {
+                injectExtensions(env, scope);
+                var contextDynamic = args.contextDep;
+                var BATCH_ID = scope.def();
+                var PROP_LIST = "a0";
+                var NUM_PROPS = "a1";
+                var PROPS = scope.def();
+                env.shared.props = PROPS;
+                env.batchId = BATCH_ID;
+                var outer = env.scope();
+                var inner = env.scope();
+                scope(
+                  outer.entry,
+                  "for(",
+                  BATCH_ID,
+                  "=0;",
+                  BATCH_ID,
+                  "<",
+                  NUM_PROPS,
+                  ";++",
+                  BATCH_ID,
+                  "){",
+                  PROPS,
+                  "=",
+                  PROP_LIST,
+                  "[",
+                  BATCH_ID,
+                  "];",
+                  inner,
+                  "}",
+                  outer.exit
+                );
+                function isInnerDefn(defn) {
+                  return defn.contextDep && contextDynamic || defn.propDep;
+                }
+                function isOuterDefn(defn) {
+                  return !isInnerDefn(defn);
+                }
+                if (args.needsContext) {
+                  emitContext(env, inner, args.context);
+                }
+                if (args.needsFramebuffer) {
+                  emitPollFramebuffer(env, inner, args.framebuffer);
+                }
+                emitSetOptions(env, inner, args.state, isInnerDefn);
+                if (args.profile && isInnerDefn(args.profile)) {
+                  emitProfile(env, inner, args, false, true);
+                }
+                if (!program) {
+                  var progCache = env.global.def("{}");
+                  var PROGRAM = args.shader.progVar.append(env, inner);
+                  var PROG_ID = inner.def(PROGRAM, ".id");
+                  var CACHED_PROC = inner.def(progCache, "[", PROG_ID, "]");
+                  inner(
+                    env.shared.gl,
+                    ".useProgram(",
+                    PROGRAM,
+                    ".program);",
+                    "if(!",
+                    CACHED_PROC,
+                    "){",
+                    CACHED_PROC,
+                    "=",
+                    progCache,
+                    "[",
+                    PROG_ID,
+                    "]=",
+                    env.link(function(program2) {
+                      return createBody(
+                        emitBatchDynamicShaderBody,
+                        env,
+                        args,
+                        program2,
+                        2
+                      );
+                    }),
+                    "(",
+                    PROGRAM,
+                    ");}",
+                    CACHED_PROC,
+                    ".call(this,a0[",
+                    BATCH_ID,
+                    "],",
+                    BATCH_ID,
+                    ");"
+                  );
+                } else {
+                  if (args.useVAO) {
+                    if (args.drawVAO) {
+                      if (isInnerDefn(args.drawVAO)) {
+                        inner(env.shared.vao, ".setVAO(", args.drawVAO.append(env, inner), ");");
+                      } else {
+                        outer(env.shared.vao, ".setVAO(", args.drawVAO.append(env, outer), ");");
+                      }
+                    } else {
+                      outer(env.shared.vao, ".setVAO(", env.shared.vao, ".targetVAO);");
+                    }
+                  } else {
+                    outer(env.shared.vao, ".setVAO(null);");
+                    emitAttributes(env, outer, args, program.attributes, isOuterDefn);
+                    emitAttributes(env, inner, args, program.attributes, isInnerDefn);
+                  }
+                  emitUniforms(env, outer, args, program.uniforms, isOuterDefn, false);
+                  emitUniforms(env, inner, args, program.uniforms, isInnerDefn, true);
+                  emitDraw(env, outer, inner, args);
+                }
+              }
+              function emitBatchProc(env, args) {
+                var batch = env.proc("batch", 2);
+                env.batchId = "0";
+                injectExtensions(env, batch);
+                var contextDynamic = false;
+                var needsContext = true;
+                Object.keys(args.context).forEach(function(name2) {
+                  contextDynamic = contextDynamic || args.context[name2].propDep;
+                });
+                if (!contextDynamic) {
+                  emitContext(env, batch, args.context);
+                  needsContext = false;
+                }
+                var framebuffer = args.framebuffer;
+                var needsFramebuffer = false;
+                if (framebuffer) {
+                  if (framebuffer.propDep) {
+                    contextDynamic = needsFramebuffer = true;
+                  } else if (framebuffer.contextDep && contextDynamic) {
+                    needsFramebuffer = true;
+                  }
+                  if (!needsFramebuffer) {
+                    emitPollFramebuffer(env, batch, framebuffer);
+                  }
+                } else {
+                  emitPollFramebuffer(env, batch, null);
+                }
+                if (args.state.viewport && args.state.viewport.propDep) {
+                  contextDynamic = true;
+                }
+                function isInnerDefn(defn) {
+                  return defn.contextDep && contextDynamic || defn.propDep;
+                }
+                emitPollState(env, batch, args);
+                emitSetOptions(env, batch, args.state, function(defn) {
+                  return !isInnerDefn(defn);
+                });
+                if (!args.profile || !isInnerDefn(args.profile)) {
+                  emitProfile(env, batch, args, false, "a1");
+                }
+                args.contextDep = contextDynamic;
+                args.needsContext = needsContext;
+                args.needsFramebuffer = needsFramebuffer;
+                var progDefn = args.shader.progVar;
+                if (progDefn.contextDep && contextDynamic || progDefn.propDep) {
+                  emitBatchBody(
+                    env,
+                    batch,
+                    args,
+                    null
+                  );
+                } else {
+                  var PROGRAM = progDefn.append(env, batch);
+                  batch(env.shared.gl, ".useProgram(", PROGRAM, ".program);");
+                  if (args.shader.program) {
+                    emitBatchBody(
+                      env,
+                      batch,
+                      args,
+                      args.shader.program
+                    );
+                  } else {
+                    batch(env.shared.vao, ".setVAO(null);");
+                    var batchCache = env.global.def("{}");
+                    var PROG_ID = batch.def(PROGRAM, ".id");
+                    var CACHED_PROC = batch.def(batchCache, "[", PROG_ID, "]");
+                    batch(
+                      env.cond(CACHED_PROC).then(CACHED_PROC, ".call(this,a0,a1);").else(
+                        CACHED_PROC,
+                        "=",
+                        batchCache,
+                        "[",
+                        PROG_ID,
+                        "]=",
+                        env.link(function(program) {
+                          return createBody(emitBatchBody, env, args, program, 2);
+                        }),
+                        "(",
+                        PROGRAM,
+                        ");",
+                        CACHED_PROC,
+                        ".call(this,a0,a1);"
+                      )
+                    );
+                  }
+                }
+                if (Object.keys(args.state).length > 0) {
+                  batch(env.shared.current, ".dirty=true;");
+                }
+                if (env.shared.vao) {
+                  batch(env.shared.vao, ".setVAO(null);");
+                }
+              }
+              function emitScopeProc(env, args) {
+                var scope = env.proc("scope", 3);
+                env.batchId = "a2";
+                var shared = env.shared;
+                var CURRENT_STATE = shared.current;
+                emitContext(env, scope, args.context);
+                if (args.framebuffer) {
+                  args.framebuffer.append(env, scope);
+                }
+                sortState(Object.keys(args.state)).forEach(function(name2) {
+                  var defn = args.state[name2];
+                  var value = defn.append(env, scope);
+                  if (isArrayLike(value)) {
+                    value.forEach(function(v2, i2) {
+                      if (hasVariableReference(v2)) {
+                        scope.set(env.next[name2], "[" + i2 + "]", v2);
+                      } else {
+                        scope.set(env.next[name2], "[" + i2 + "]", env.link(v2, { stable: true }));
+                      }
+                    });
+                  } else {
+                    if (isStatic(defn)) {
+                      scope.set(shared.next, "." + name2, env.link(value, { stable: true }));
+                    } else {
+                      scope.set(shared.next, "." + name2, value);
+                    }
+                  }
+                });
+                emitProfile(env, scope, args, true, true);
+                [S_ELEMENTS, S_OFFSET, S_COUNT, S_INSTANCES, S_PRIMITIVE].forEach(
+                  function(opt) {
+                    var variable = args.draw[opt];
+                    if (!variable) {
+                      return;
+                    }
+                    var VARIABLE2 = variable.append(env, scope);
+                    if (hasVariableReference(VARIABLE2)) {
+                      scope.set(shared.draw, "." + opt, VARIABLE2);
+                    } else {
+                      scope.set(shared.draw, "." + opt, env.link(VARIABLE2), { stable: true });
+                    }
+                  }
+                );
+                Object.keys(args.uniforms).forEach(function(opt) {
+                  var value = args.uniforms[opt].append(env, scope);
+                  if (Array.isArray(value)) {
+                    value = "[" + value.map(function(v2) {
+                      if (hasVariableReference(v2)) {
+                        return v2;
+                      } else {
+                        return env.link(v2, { stable: true });
+                      }
+                    }) + "]";
+                  }
+                  scope.set(
+                    shared.uniforms,
+                    "[" + env.link(stringStore.id(opt), { stable: true }) + "]",
+                    value
+                  );
+                });
+                Object.keys(args.attributes).forEach(function(name2) {
+                  var record = args.attributes[name2].append(env, scope);
+                  var scopeAttrib = env.scopeAttrib(name2);
+                  Object.keys(new AttributeRecord2()).forEach(function(prop) {
+                    scope.set(scopeAttrib, "." + prop, record[prop]);
+                  });
+                });
+                if (args.scopeVAO) {
+                  var VARIABLE = args.scopeVAO.append(env, scope);
+                  if (hasVariableReference(VARIABLE)) {
+                    scope.set(shared.vao, ".targetVAO", VARIABLE);
+                  } else {
+                    scope.set(shared.vao, ".targetVAO", env.link(VARIABLE, { stable: true }));
+                  }
+                }
+                function saveShader(name2) {
+                  var shader = args.shader[name2];
+                  if (shader) {
+                    var VARIABLE2 = shader.append(env, scope);
+                    if (hasVariableReference(VARIABLE2)) {
+                      scope.set(shared.shader, "." + name2, VARIABLE2);
+                    } else {
+                      scope.set(shared.shader, "." + name2, env.link(VARIABLE2, { stable: true }));
+                    }
+                  }
+                }
+                saveShader(S_VERT);
+                saveShader(S_FRAG);
+                if (Object.keys(args.state).length > 0) {
+                  scope(CURRENT_STATE, ".dirty=true;");
+                  scope.exit(CURRENT_STATE, ".dirty=true;");
+                }
+                scope("a1(", env.shared.context, ",a0,", env.batchId, ");");
+              }
+              function isDynamicObject(object) {
+                if (typeof object !== "object" || isArrayLike(object)) {
+                  return;
+                }
+                var props = Object.keys(object);
+                for (var i2 = 0; i2 < props.length; ++i2) {
+                  if (dynamic.isDynamic(object[props[i2]])) {
+                    return true;
+                  }
+                }
+                return false;
+              }
+              function splatObject(env, options, name2) {
+                var object = options.static[name2];
+                if (!object || !isDynamicObject(object)) {
+                  return;
+                }
+                var globals = env.global;
+                var keys = Object.keys(object);
+                var thisDep = false;
+                var contextDep = false;
+                var propDep = false;
+                var objectRef = env.global.def("{}");
+                keys.forEach(function(key) {
+                  var value = object[key];
+                  if (dynamic.isDynamic(value)) {
+                    if (typeof value === "function") {
+                      value = object[key] = dynamic.unbox(value);
+                    }
+                    var deps = createDynamicDecl(value, null);
+                    thisDep = thisDep || deps.thisDep;
+                    propDep = propDep || deps.propDep;
+                    contextDep = contextDep || deps.contextDep;
+                  } else {
+                    globals(objectRef, ".", key, "=");
+                    switch (typeof value) {
+                      case "number":
+                        globals(value);
+                        break;
+                      case "string":
+                        globals('"', value, '"');
+                        break;
+                      case "object":
+                        if (Array.isArray(value)) {
+                          globals("[", value.join(), "]");
+                        }
+                        break;
+                      default:
+                        globals(env.link(value));
+                        break;
+                    }
+                    globals(";");
+                  }
+                });
+                function appendBlock(env2, block) {
+                  keys.forEach(function(key) {
+                    var value = object[key];
+                    if (!dynamic.isDynamic(value)) {
+                      return;
+                    }
+                    var ref = env2.invoke(block, value);
+                    block(objectRef, ".", key, "=", ref, ";");
+                  });
+                }
+                options.dynamic[name2] = new dynamic.DynamicVariable(DYN_THUNK, {
+                  thisDep,
+                  contextDep,
+                  propDep,
+                  ref: objectRef,
+                  append: appendBlock
+                });
+                delete options.static[name2];
+              }
+              function compileCommand(options, attributes, uniforms, context, stats2) {
+                var env = createREGLEnvironment();
+                env.stats = env.link(stats2);
+                Object.keys(attributes.static).forEach(function(key) {
+                  splatObject(env, attributes, key);
+                });
+                NESTED_OPTIONS.forEach(function(name2) {
+                  splatObject(env, options, name2);
+                });
+                var args = parseArguments(options, attributes, uniforms, context, env);
+                if (args.shader.program) {
+                  args.shader.program.attributes.sort(function(a2, b2) {
+                    return a2.name < b2.name ? -1 : 1;
+                  });
+                  args.shader.program.uniforms.sort(function(a2, b2) {
+                    return a2.name < b2.name ? -1 : 1;
+                  });
+                }
+                emitDrawProc(env, args);
+                emitScopeProc(env, args);
+                emitBatchProc(env, args);
+                return extend2(env.compile(), {
+                  destroy: function() {
+                    args.shader.program.destroy();
+                  }
+                });
+              }
+              return {
+                next: nextState,
+                current: currentState,
+                procs: function() {
+                  var env = createREGLEnvironment();
+                  var poll = env.proc("poll");
+                  var refresh = env.proc("refresh");
+                  var common = env.block();
+                  poll(common);
+                  refresh(common);
+                  var shared = env.shared;
+                  var GL = shared.gl;
+                  var NEXT_STATE = shared.next;
+                  var CURRENT_STATE = shared.current;
+                  common(CURRENT_STATE, ".dirty=false;");
+                  emitPollFramebuffer(env, poll);
+                  emitPollFramebuffer(env, refresh, null, true);
+                  var INSTANCING;
+                  if (extInstancing) {
+                    INSTANCING = env.link(extInstancing);
+                  }
+                  if (extensions.oes_vertex_array_object) {
+                    refresh(env.link(extensions.oes_vertex_array_object), ".bindVertexArrayOES(null);");
+                  }
+                  var BINDING = refresh.def(shared.attributes);
+                  var TEMP_BINDING = refresh.def(0);
+                  var ifte = env.cond(TEMP_BINDING, ".buffer");
+                  ifte.then(
+                    GL,
+                    ".enableVertexAttribArray(i);",
+                    GL,
+                    ".bindBuffer(",
+                    GL_ARRAY_BUFFER$2,
+                    ",",
+                    TEMP_BINDING,
+                    ".buffer.buffer);",
+                    GL,
+                    ".vertexAttribPointer(i,",
+                    TEMP_BINDING,
+                    ".size,",
+                    TEMP_BINDING,
+                    ".type,",
+                    TEMP_BINDING,
+                    ".normalized,",
+                    TEMP_BINDING,
+                    ".stride,",
+                    TEMP_BINDING,
+                    ".offset);"
+                  ).else(
+                    GL,
+                    ".disableVertexAttribArray(i);",
+                    GL,
+                    ".vertexAttrib4f(i,",
+                    TEMP_BINDING,
+                    ".x,",
+                    TEMP_BINDING,
+                    ".y,",
+                    TEMP_BINDING,
+                    ".z,",
+                    TEMP_BINDING,
+                    ".w);",
+                    TEMP_BINDING,
+                    ".buffer=null;"
+                  );
+                  var MAX_ATTRIBUTES = env.link(limits.maxAttributes, { stable: true });
+                  refresh(
+                    "for(var i=0;i<",
+                    MAX_ATTRIBUTES,
+                    ";++i){",
+                    TEMP_BINDING,
+                    "=",
+                    BINDING,
+                    "[i];",
+                    ifte,
+                    "}"
+                  );
+                  if (extInstancing) {
+                    refresh(
+                      "for(var i=0;i<",
+                      MAX_ATTRIBUTES,
+                      ";++i){",
+                      INSTANCING,
+                      ".vertexAttribDivisorANGLE(i,",
+                      BINDING,
+                      "[i].divisor);",
+                      "}"
+                    );
+                  }
+                  refresh(
+                    env.shared.vao,
+                    ".currentVAO=null;",
+                    env.shared.vao,
+                    ".setVAO(",
+                    env.shared.vao,
+                    ".targetVAO);"
+                  );
+                  Object.keys(GL_FLAGS).forEach(function(flag) {
+                    var cap = GL_FLAGS[flag];
+                    var NEXT = common.def(NEXT_STATE, ".", flag);
+                    var block = env.block();
+                    block(
+                      "if(",
+                      NEXT,
+                      "){",
+                      GL,
+                      ".enable(",
+                      cap,
+                      ")}else{",
+                      GL,
+                      ".disable(",
+                      cap,
+                      ")}",
+                      CURRENT_STATE,
+                      ".",
+                      flag,
+                      "=",
+                      NEXT,
+                      ";"
+                    );
+                    refresh(block);
+                    poll(
+                      "if(",
+                      NEXT,
+                      "!==",
+                      CURRENT_STATE,
+                      ".",
+                      flag,
+                      "){",
+                      block,
+                      "}"
+                    );
+                  });
+                  Object.keys(GL_VARIABLES).forEach(function(name2) {
+                    var func = GL_VARIABLES[name2];
+                    var init = currentState[name2];
+                    var NEXT, CURRENT;
+                    var block = env.block();
+                    block(GL, ".", func, "(");
+                    if (isArrayLike(init)) {
+                      var n2 = init.length;
+                      NEXT = env.global.def(NEXT_STATE, ".", name2);
+                      CURRENT = env.global.def(CURRENT_STATE, ".", name2);
+                      block(
+                        loop(n2, function(i2) {
+                          return NEXT + "[" + i2 + "]";
+                        }),
+                        ");",
+                        loop(n2, function(i2) {
+                          return CURRENT + "[" + i2 + "]=" + NEXT + "[" + i2 + "];";
+                        }).join("")
+                      );
+                      poll(
+                        "if(",
+                        loop(n2, function(i2) {
+                          return NEXT + "[" + i2 + "]!==" + CURRENT + "[" + i2 + "]";
+                        }).join("||"),
+                        "){",
+                        block,
+                        "}"
+                      );
+                    } else {
+                      NEXT = common.def(NEXT_STATE, ".", name2);
+                      CURRENT = common.def(CURRENT_STATE, ".", name2);
+                      block(
+                        NEXT,
+                        ");",
+                        CURRENT_STATE,
+                        ".",
+                        name2,
+                        "=",
+                        NEXT,
+                        ";"
+                      );
+                      poll(
+                        "if(",
+                        NEXT,
+                        "!==",
+                        CURRENT,
+                        "){",
+                        block,
+                        "}"
+                      );
+                    }
+                    refresh(block);
+                  });
+                  return env.compile();
+                }(),
+                compile: compileCommand
+              };
+            }
+            function stats() {
+              return {
+                vaoCount: 0,
+                bufferCount: 0,
+                elementsCount: 0,
+                framebufferCount: 0,
+                shaderCount: 0,
+                textureCount: 0,
+                cubeCount: 0,
+                renderbufferCount: 0,
+                maxTextureUnits: 0
+              };
+            }
+            var GL_QUERY_RESULT_EXT = 34918;
+            var GL_QUERY_RESULT_AVAILABLE_EXT = 34919;
+            var GL_TIME_ELAPSED_EXT = 35007;
+            var createTimer = function(gl2, extensions) {
+              if (!extensions.ext_disjoint_timer_query) {
+                return null;
+              }
+              var queryPool = [];
+              function allocQuery() {
+                return queryPool.pop() || extensions.ext_disjoint_timer_query.createQueryEXT();
+              }
+              function freeQuery(query) {
+                queryPool.push(query);
+              }
+              var pendingQueries = [];
+              function beginQuery(stats2) {
+                var query = allocQuery();
+                extensions.ext_disjoint_timer_query.beginQueryEXT(GL_TIME_ELAPSED_EXT, query);
+                pendingQueries.push(query);
+                pushScopeStats(pendingQueries.length - 1, pendingQueries.length, stats2);
+              }
+              function endQuery() {
+                extensions.ext_disjoint_timer_query.endQueryEXT(GL_TIME_ELAPSED_EXT);
+              }
+              function PendingStats() {
+                this.startQueryIndex = -1;
+                this.endQueryIndex = -1;
+                this.sum = 0;
+                this.stats = null;
+              }
+              var pendingStatsPool = [];
+              function allocPendingStats() {
+                return pendingStatsPool.pop() || new PendingStats();
+              }
+              function freePendingStats(pendingStats2) {
+                pendingStatsPool.push(pendingStats2);
+              }
+              var pendingStats = [];
+              function pushScopeStats(start, end, stats2) {
+                var ps = allocPendingStats();
+                ps.startQueryIndex = start;
+                ps.endQueryIndex = end;
+                ps.sum = 0;
+                ps.stats = stats2;
+                pendingStats.push(ps);
+              }
+              var timeSum = [];
+              var queryPtr = [];
+              function update() {
+                var ptr, i2;
+                var n2 = pendingQueries.length;
+                if (n2 === 0) {
+                  return;
+                }
+                queryPtr.length = Math.max(queryPtr.length, n2 + 1);
+                timeSum.length = Math.max(timeSum.length, n2 + 1);
+                timeSum[0] = 0;
+                queryPtr[0] = 0;
+                var queryTime = 0;
+                ptr = 0;
+                for (i2 = 0; i2 < pendingQueries.length; ++i2) {
+                  var query = pendingQueries[i2];
+                  if (extensions.ext_disjoint_timer_query.getQueryObjectEXT(query, GL_QUERY_RESULT_AVAILABLE_EXT)) {
+                    queryTime += extensions.ext_disjoint_timer_query.getQueryObjectEXT(query, GL_QUERY_RESULT_EXT);
+                    freeQuery(query);
+                  } else {
+                    pendingQueries[ptr++] = query;
+                  }
+                  timeSum[i2 + 1] = queryTime;
+                  queryPtr[i2 + 1] = ptr;
+                }
+                pendingQueries.length = ptr;
+                ptr = 0;
+                for (i2 = 0; i2 < pendingStats.length; ++i2) {
+                  var stats2 = pendingStats[i2];
+                  var start = stats2.startQueryIndex;
+                  var end = stats2.endQueryIndex;
+                  stats2.sum += timeSum[end] - timeSum[start];
+                  var startPtr = queryPtr[start];
+                  var endPtr = queryPtr[end];
+                  if (endPtr === startPtr) {
+                    stats2.stats.gpuTime += stats2.sum / 1e6;
+                    freePendingStats(stats2);
+                  } else {
+                    stats2.startQueryIndex = startPtr;
+                    stats2.endQueryIndex = endPtr;
+                    pendingStats[ptr++] = stats2;
+                  }
+                }
+                pendingStats.length = ptr;
+              }
+              return {
+                beginQuery,
+                endQuery,
+                pushScopeStats,
+                update,
+                getNumPendingQueries: function() {
+                  return pendingQueries.length;
+                },
+                clear: function() {
+                  queryPool.push.apply(queryPool, pendingQueries);
+                  for (var i2 = 0; i2 < queryPool.length; i2++) {
+                    extensions.ext_disjoint_timer_query.deleteQueryEXT(queryPool[i2]);
+                  }
+                  pendingQueries.length = 0;
+                  queryPool.length = 0;
+                },
+                restore: function() {
+                  pendingQueries.length = 0;
+                  queryPool.length = 0;
+                }
+              };
+            };
+            var GL_COLOR_BUFFER_BIT = 16384;
+            var GL_DEPTH_BUFFER_BIT = 256;
+            var GL_STENCIL_BUFFER_BIT = 1024;
+            var GL_ARRAY_BUFFER = 34962;
+            var CONTEXT_LOST_EVENT = "webglcontextlost";
+            var CONTEXT_RESTORED_EVENT = "webglcontextrestored";
+            var DYN_PROP = 1;
+            var DYN_CONTEXT = 2;
+            var DYN_STATE = 3;
+            function find(haystack, needle) {
+              for (var i2 = 0; i2 < haystack.length; ++i2) {
+                if (haystack[i2] === needle) {
+                  return i2;
+                }
+              }
+              return -1;
+            }
+            function wrapREGL(args) {
+              var config2 = parseArgs(args);
+              if (!config2) {
+                return null;
+              }
+              var gl2 = config2.gl;
+              var glAttributes = gl2.getContextAttributes();
+              gl2.isContextLost();
+              var extensionState = createExtensionCache(gl2, config2);
+              if (!extensionState) {
+                return null;
+              }
+              var stringStore = createStringStore();
+              var stats$$1 = stats();
+              var cachedCode = config2.cachedCode || {};
+              var extensions = extensionState.extensions;
+              var timer = createTimer(gl2, extensions);
+              var START_TIME = clock();
+              var WIDTH = gl2.drawingBufferWidth;
+              var HEIGHT = gl2.drawingBufferHeight;
+              var contextState = {
+                tick: 0,
+                time: 0,
+                viewportWidth: WIDTH,
+                viewportHeight: HEIGHT,
+                framebufferWidth: WIDTH,
+                framebufferHeight: HEIGHT,
+                drawingBufferWidth: WIDTH,
+                drawingBufferHeight: HEIGHT,
+                pixelRatio: config2.pixelRatio
+              };
+              var uniformState = {};
+              var drawState = {
+                elements: null,
+                primitive: 4,
+                // GL_TRIANGLES
+                count: -1,
+                offset: 0,
+                instances: -1
+              };
+              var limits = wrapLimits(gl2, extensions);
+              var bufferState = wrapBufferState(
+                gl2,
+                stats$$1,
+                config2,
+                destroyBuffer
+              );
+              var elementState = wrapElementsState(gl2, extensions, bufferState, stats$$1);
+              var attributeState = wrapAttributeState(
+                gl2,
+                extensions,
+                limits,
+                stats$$1,
+                bufferState,
+                elementState,
+                drawState
+              );
+              function destroyBuffer(buffer) {
+                return attributeState.destroyBuffer(buffer);
+              }
+              var shaderState = wrapShaderState(gl2, stringStore, stats$$1, config2);
+              var textureState = createTextureSet(
+                gl2,
+                extensions,
+                limits,
+                function() {
+                  core.procs.poll();
+                },
+                contextState,
+                stats$$1,
+                config2
+              );
+              var renderbufferState = wrapRenderbuffers(gl2, extensions, limits, stats$$1, config2);
+              var framebufferState = wrapFBOState(
+                gl2,
+                extensions,
+                limits,
+                textureState,
+                renderbufferState,
+                stats$$1
+              );
+              var core = reglCore(
+                gl2,
+                stringStore,
+                extensions,
+                limits,
+                bufferState,
+                elementState,
+                textureState,
+                framebufferState,
+                uniformState,
+                attributeState,
+                shaderState,
+                drawState,
+                contextState,
+                timer,
+                cachedCode,
+                config2
+              );
+              var readPixels = wrapReadPixels(
+                gl2,
+                framebufferState,
+                core.procs.poll,
+                contextState
+              );
+              var nextState = core.next;
+              var canvas2 = gl2.canvas;
+              var rafCallbacks = [];
+              var lossCallbacks = [];
+              var restoreCallbacks = [];
+              var destroyCallbacks = [config2.onDestroy];
+              var activeRAF = null;
+              function handleRAF() {
+                if (rafCallbacks.length === 0) {
+                  if (timer) {
+                    timer.update();
+                  }
+                  activeRAF = null;
+                  return;
+                }
+                activeRAF = raf.next(handleRAF);
+                poll();
+                for (var i2 = rafCallbacks.length - 1; i2 >= 0; --i2) {
+                  var cb2 = rafCallbacks[i2];
+                  if (cb2) {
+                    cb2(contextState, null, 0);
+                  }
+                }
+                gl2.flush();
+                if (timer) {
+                  timer.update();
+                }
+              }
+              function startRAF() {
+                if (!activeRAF && rafCallbacks.length > 0) {
+                  activeRAF = raf.next(handleRAF);
+                }
+              }
+              function stopRAF() {
+                if (activeRAF) {
+                  raf.cancel(handleRAF);
+                  activeRAF = null;
+                }
+              }
+              function handleContextLoss(event) {
+                event.preventDefault();
+                stopRAF();
+                lossCallbacks.forEach(function(cb2) {
+                  cb2();
+                });
+              }
+              function handleContextRestored(event) {
+                gl2.getError();
+                extensionState.restore();
+                shaderState.restore();
+                bufferState.restore();
+                textureState.restore();
+                renderbufferState.restore();
+                framebufferState.restore();
+                attributeState.restore();
+                if (timer) {
+                  timer.restore();
+                }
+                core.procs.refresh();
+                startRAF();
+                restoreCallbacks.forEach(function(cb2) {
+                  cb2();
+                });
+              }
+              if (canvas2) {
+                canvas2.addEventListener(CONTEXT_LOST_EVENT, handleContextLoss, false);
+                canvas2.addEventListener(CONTEXT_RESTORED_EVENT, handleContextRestored, false);
+              }
+              function destroy() {
+                rafCallbacks.length = 0;
+                stopRAF();
+                if (canvas2) {
+                  canvas2.removeEventListener(CONTEXT_LOST_EVENT, handleContextLoss);
+                  canvas2.removeEventListener(CONTEXT_RESTORED_EVENT, handleContextRestored);
+                }
+                shaderState.clear();
+                framebufferState.clear();
+                renderbufferState.clear();
+                attributeState.clear();
+                textureState.clear();
+                elementState.clear();
+                bufferState.clear();
+                if (timer) {
+                  timer.clear();
+                }
+                destroyCallbacks.forEach(function(cb2) {
+                  cb2();
+                });
+              }
+              function compileProcedure(options) {
+                function flattenNestedOptions(options2) {
+                  var result = extend2({}, options2);
+                  delete result.uniforms;
+                  delete result.attributes;
+                  delete result.context;
+                  delete result.vao;
+                  if ("stencil" in result && result.stencil.op) {
+                    result.stencil.opBack = result.stencil.opFront = result.stencil.op;
+                    delete result.stencil.op;
+                  }
+                  function merge(name2) {
+                    if (name2 in result) {
+                      var child = result[name2];
+                      delete result[name2];
+                      Object.keys(child).forEach(function(prop) {
+                        result[name2 + "." + prop] = child[prop];
+                      });
+                    }
+                  }
+                  merge("blend");
+                  merge("depth");
+                  merge("cull");
+                  merge("stencil");
+                  merge("polygonOffset");
+                  merge("scissor");
+                  merge("sample");
+                  if ("vao" in options2) {
+                    result.vao = options2.vao;
+                  }
+                  return result;
+                }
+                function separateDynamic(object, useArrays) {
+                  var staticItems = {};
+                  var dynamicItems = {};
+                  Object.keys(object).forEach(function(option) {
+                    var value = object[option];
+                    if (dynamic.isDynamic(value)) {
+                      dynamicItems[option] = dynamic.unbox(value, option);
+                      return;
+                    } else if (useArrays && Array.isArray(value)) {
+                      for (var i2 = 0; i2 < value.length; ++i2) {
+                        if (dynamic.isDynamic(value[i2])) {
+                          dynamicItems[option] = dynamic.unbox(value, option);
+                          return;
+                        }
+                      }
+                    }
+                    staticItems[option] = value;
+                  });
+                  return {
+                    dynamic: dynamicItems,
+                    static: staticItems
+                  };
+                }
+                var context = separateDynamic(options.context || {}, true);
+                var uniforms = separateDynamic(options.uniforms || {}, true);
+                var attributes = separateDynamic(options.attributes || {}, false);
+                var opts = separateDynamic(flattenNestedOptions(options), false);
+                var stats$$12 = {
+                  gpuTime: 0,
+                  cpuTime: 0,
+                  count: 0
+                };
+                var compiled = core.compile(opts, attributes, uniforms, context, stats$$12);
+                var draw = compiled.draw;
+                var batch = compiled.batch;
+                var scope = compiled.scope;
+                var EMPTY_ARRAY2 = [];
+                function reserve(count2) {
+                  while (EMPTY_ARRAY2.length < count2) {
+                    EMPTY_ARRAY2.push(null);
+                  }
+                  return EMPTY_ARRAY2;
+                }
+                function REGLCommand(args2, body) {
+                  var i2;
+                  if (typeof args2 === "function") {
+                    return scope.call(this, null, args2, 0);
+                  } else if (typeof body === "function") {
+                    if (typeof args2 === "number") {
+                      for (i2 = 0; i2 < args2; ++i2) {
+                        scope.call(this, null, body, i2);
+                      }
+                    } else if (Array.isArray(args2)) {
+                      for (i2 = 0; i2 < args2.length; ++i2) {
+                        scope.call(this, args2[i2], body, i2);
+                      }
+                    } else {
+                      return scope.call(this, args2, body, 0);
+                    }
+                  } else if (typeof args2 === "number") {
+                    if (args2 > 0) {
+                      return batch.call(this, reserve(args2 | 0), args2 | 0);
+                    }
+                  } else if (Array.isArray(args2)) {
+                    if (args2.length) {
+                      return batch.call(this, args2, args2.length);
+                    }
+                  } else {
+                    return draw.call(this, args2);
+                  }
+                }
+                return extend2(REGLCommand, {
+                  stats: stats$$12,
+                  destroy: function() {
+                    compiled.destroy();
+                  }
+                });
+              }
+              var setFBO = framebufferState.setFBO = compileProcedure({
+                framebuffer: dynamic.define.call(null, DYN_PROP, "framebuffer")
+              });
+              function clearImpl(_2, options) {
+                var clearFlags = 0;
+                core.procs.poll();
+                var c2 = options.color;
+                if (c2) {
+                  gl2.clearColor(+c2[0] || 0, +c2[1] || 0, +c2[2] || 0, +c2[3] || 0);
+                  clearFlags |= GL_COLOR_BUFFER_BIT;
+                }
+                if ("depth" in options) {
+                  gl2.clearDepth(+options.depth);
+                  clearFlags |= GL_DEPTH_BUFFER_BIT;
+                }
+                if ("stencil" in options) {
+                  gl2.clearStencil(options.stencil | 0);
+                  clearFlags |= GL_STENCIL_BUFFER_BIT;
+                }
+                gl2.clear(clearFlags);
+              }
+              function clear(options) {
+                if ("framebuffer" in options) {
+                  if (options.framebuffer && options.framebuffer_reglType === "framebufferCube") {
+                    for (var i2 = 0; i2 < 6; ++i2) {
+                      setFBO(extend2({
+                        framebuffer: options.framebuffer.faces[i2]
+                      }, options), clearImpl);
+                    }
+                  } else {
+                    setFBO(options, clearImpl);
+                  }
+                } else {
+                  clearImpl(null, options);
+                }
+              }
+              function frame(cb2) {
+                rafCallbacks.push(cb2);
+                function cancel() {
+                  var i2 = find(rafCallbacks, cb2);
+                  function pendingCancel() {
+                    var index = find(rafCallbacks, pendingCancel);
+                    rafCallbacks[index] = rafCallbacks[rafCallbacks.length - 1];
+                    rafCallbacks.length -= 1;
+                    if (rafCallbacks.length <= 0) {
+                      stopRAF();
+                    }
+                  }
+                  rafCallbacks[i2] = pendingCancel;
+                }
+                startRAF();
+                return {
+                  cancel
+                };
+              }
+              function pollViewport() {
+                var viewport = nextState.viewport;
+                var scissorBox = nextState.scissor_box;
+                viewport[0] = viewport[1] = scissorBox[0] = scissorBox[1] = 0;
+                contextState.viewportWidth = contextState.framebufferWidth = contextState.drawingBufferWidth = viewport[2] = scissorBox[2] = gl2.drawingBufferWidth;
+                contextState.viewportHeight = contextState.framebufferHeight = contextState.drawingBufferHeight = viewport[3] = scissorBox[3] = gl2.drawingBufferHeight;
+              }
+              function poll() {
+                contextState.tick += 1;
+                contextState.time = now();
+                pollViewport();
+                core.procs.poll();
+              }
+              function refresh() {
+                textureState.refresh();
+                pollViewport();
+                core.procs.refresh();
+                if (timer) {
+                  timer.update();
+                }
+              }
+              function now() {
+                return (clock() - START_TIME) / 1e3;
+              }
+              refresh();
+              function addListener(event, callback) {
+                var callbacks;
+                switch (event) {
+                  case "frame":
+                    return frame(callback);
+                  case "lost":
+                    callbacks = lossCallbacks;
+                    break;
+                  case "restore":
+                    callbacks = restoreCallbacks;
+                    break;
+                  case "destroy":
+                    callbacks = destroyCallbacks;
+                    break;
+                }
+                callbacks.push(callback);
+                return {
+                  cancel: function() {
+                    for (var i2 = 0; i2 < callbacks.length; ++i2) {
+                      if (callbacks[i2] === callback) {
+                        callbacks[i2] = callbacks[callbacks.length - 1];
+                        callbacks.pop();
+                        return;
+                      }
+                    }
+                  }
+                };
+              }
+              function getCachedCode() {
+                return cachedCode;
+              }
+              function preloadCachedCode(moreCache) {
+                Object.entries(moreCache).forEach(function(kv) {
+                  cachedCode[kv[0]] = kv[1];
+                });
+              }
+              var regl = extend2(compileProcedure, {
+                // Clear current FBO
+                clear,
+                // Short cuts for dynamic variables
+                prop: dynamic.define.bind(null, DYN_PROP),
+                context: dynamic.define.bind(null, DYN_CONTEXT),
+                this: dynamic.define.bind(null, DYN_STATE),
+                // executes an empty draw command
+                draw: compileProcedure({}),
+                // Resources
+                buffer: function(options) {
+                  return bufferState.create(options, GL_ARRAY_BUFFER, false, false);
+                },
+                elements: function(options) {
+                  return elementState.create(options, false);
+                },
+                texture: textureState.create2D,
+                cube: textureState.createCube,
+                renderbuffer: renderbufferState.create,
+                framebuffer: framebufferState.create,
+                framebufferCube: framebufferState.createCube,
+                vao: attributeState.createVAO,
+                // Expose context attributes
+                attributes: glAttributes,
+                // Frame rendering
+                frame,
+                on: addListener,
+                // System limits
+                limits,
+                hasExtension: function(name2) {
+                  return limits.extensions.indexOf(name2.toLowerCase()) >= 0;
+                },
+                // Read pixels
+                read: readPixels,
+                // Destroy regl and all associated resources
+                destroy,
+                // Direct GL state manipulation
+                _gl: gl2,
+                _refresh: refresh,
+                poll: function() {
+                  poll();
+                  if (timer) {
+                    timer.update();
+                  }
+                },
+                // Current time
+                now,
+                // regl Statistics Information
+                stats: stats$$1,
+                // cache generated code
+                getCachedCode,
+                preloadCachedCode
+              });
+              config2.onDone(null, regl);
+              return regl;
+            }
+            return wrapREGL;
+          });
+        }
+      });
+      var require_context = __commonJS({
+        "node_modules/gl-util/context.js"(exports, module2) {
+          var pick = require_pick_by_alias();
+          module2.exports = function setContext(o2) {
+            if (!o2) o2 = {};
+            else if (typeof o2 === "string") o2 = { container: o2 };
+            if (isCanvas(o2)) {
+              o2 = { container: o2 };
+            } else if (isElement(o2)) {
+              o2 = { container: o2 };
+            } else if (isContext(o2)) {
+              o2 = { gl: o2 };
+            } else {
+              o2 = pick(o2, {
+                container: "container target element el canvas holder parent parentNode wrapper use ref root node",
+                gl: "gl context webgl glContext",
+                attrs: "attributes attrs contextAttributes",
+                pixelRatio: "pixelRatio pxRatio px ratio pxratio pixelratio",
+                width: "w width",
+                height: "h height"
+              }, true);
+            }
+            if (!o2.pixelRatio) o2.pixelRatio = window.pixelRatio || 1;
+            if (o2.gl) {
+              return o2.gl;
+            }
+            if (o2.canvas) {
+              o2.container = o2.canvas.parentNode;
+            }
+            if (o2.container) {
+              if (typeof o2.container === "string") {
+                var c2 = document.querySelector(o2.container);
+                if (!c2) throw Error("Element " + o2.container + " is not found");
+                o2.container = c2;
+              }
+              if (isCanvas(o2.container)) {
+                o2.canvas = o2.container;
+                o2.container = o2.canvas.parentNode;
+              } else if (!o2.canvas) {
+                o2.canvas = createCanvas();
+                o2.container.appendChild(o2.canvas);
+                resize(o2);
+              }
+            } else if (!o2.canvas) {
+              if (typeof document !== "undefined") {
+                o2.container = document.body || document.documentElement;
+                o2.canvas = createCanvas();
+                o2.container.appendChild(o2.canvas);
+                resize(o2);
+              } else {
+                throw Error("Not DOM environment. Use headless-gl.");
+              }
+            }
+            if (!o2.gl) {
+              ["webgl", "experimental-webgl", "webgl-experimental"].some(function(c22) {
+                try {
+                  o2.gl = o2.canvas.getContext(c22, o2.attrs);
+                } catch (e2) {
+                }
+                return o2.gl;
+              });
+            }
+            return o2.gl;
+          };
+          function resize(o2) {
+            if (o2.container) {
+              if (o2.container == document.body) {
+                if (!document.body.style.width) o2.canvas.width = o2.width || o2.pixelRatio * window.innerWidth;
+                if (!document.body.style.height) o2.canvas.height = o2.height || o2.pixelRatio * window.innerHeight;
+              } else {
+                var bounds = o2.container.getBoundingClientRect();
+                o2.canvas.width = o2.width || bounds.right - bounds.left;
+                o2.canvas.height = o2.height || bounds.bottom - bounds.top;
+              }
+            }
+          }
+          function isCanvas(e2) {
+            return typeof e2.getContext === "function" && "width" in e2 && "height" in e2;
+          }
+          function isElement(e2) {
+            return typeof e2.nodeName === "string" && typeof e2.appendChild === "function" && typeof e2.getBoundingClientRect === "function";
+          }
+          function isContext(e2) {
+            return typeof e2.drawArrays === "function" || typeof e2.drawElements === "function";
+          }
+          function createCanvas() {
+            var canvas2 = document.createElement("canvas");
+            canvas2.style.position = "absolute";
+            canvas2.style.top = 0;
+            canvas2.style.left = 0;
+            return canvas2;
+          }
+        }
+      });
+      var require_font_atlas = __commonJS({
+        "node_modules/font-atlas/index.js"(exports, module2) {
+          var stringifyFont = require_stringify();
+          var defaultChars = [32, 126];
+          module2.exports = atlas;
+          function atlas(options) {
+            options = options || {};
+            var shape = options.shape ? options.shape : options.canvas ? [options.canvas.width, options.canvas.height] : [512, 512];
+            var canvas2 = options.canvas || document.createElement("canvas");
+            var font = options.font;
+            var step = typeof options.step === "number" ? [options.step, options.step] : options.step || [32, 32];
+            var chars = options.chars || defaultChars;
+            if (font && typeof font !== "string") font = stringifyFont(font);
+            if (!Array.isArray(chars)) {
+              chars = String(chars).split("");
+            } else if (chars.length === 2 && typeof chars[0] === "number" && typeof chars[1] === "number") {
+              var newchars = [];
+              for (var i2 = chars[0], j2 = 0; i2 <= chars[1]; i2++) {
+                newchars[j2++] = String.fromCharCode(i2);
+              }
+              chars = newchars;
+            }
+            shape = shape.slice();
+            canvas2.width = shape[0];
+            canvas2.height = shape[1];
+            var ctx2 = canvas2.getContext("2d");
+            ctx2.fillStyle = "#000";
+            ctx2.fillRect(0, 0, canvas2.width, canvas2.height);
+            ctx2.font = font;
+            ctx2.textAlign = "center";
+            ctx2.textBaseline = "middle";
+            ctx2.fillStyle = "#fff";
+            var x2 = step[0] / 2;
+            var y2 = step[1] / 2;
+            for (var i2 = 0; i2 < chars.length; i2++) {
+              ctx2.fillText(chars[i2], x2, y2);
+              if ((x2 += step[0]) > shape[0] - step[0] / 2) x2 = step[0] / 2, y2 += step[1];
+            }
+            return canvas2;
+          }
+        }
+      });
+      var require_twiddle = __commonJS({
+        "node_modules/bit-twiddle/twiddle.js"(exports) {
+          "use restrict";
+          var INT_BITS = 32;
+          exports.INT_BITS = INT_BITS;
+          exports.INT_MAX = 2147483647;
+          exports.INT_MIN = -1 << INT_BITS - 1;
+          exports.sign = function(v2) {
+            return (v2 > 0) - (v2 < 0);
+          };
+          exports.abs = function(v2) {
+            var mask = v2 >> INT_BITS - 1;
+            return (v2 ^ mask) - mask;
+          };
+          exports.min = function(x2, y2) {
+            return y2 ^ (x2 ^ y2) & -(x2 < y2);
+          };
+          exports.max = function(x2, y2) {
+            return x2 ^ (x2 ^ y2) & -(x2 < y2);
+          };
+          exports.isPow2 = function(v2) {
+            return !(v2 & v2 - 1) && !!v2;
+          };
+          exports.log2 = function(v2) {
+            var r2, shift;
+            r2 = (v2 > 65535) << 4;
+            v2 >>>= r2;
+            shift = (v2 > 255) << 3;
+            v2 >>>= shift;
+            r2 |= shift;
+            shift = (v2 > 15) << 2;
+            v2 >>>= shift;
+            r2 |= shift;
+            shift = (v2 > 3) << 1;
+            v2 >>>= shift;
+            r2 |= shift;
+            return r2 | v2 >> 1;
+          };
+          exports.log10 = function(v2) {
+            return v2 >= 1e9 ? 9 : v2 >= 1e8 ? 8 : v2 >= 1e7 ? 7 : v2 >= 1e6 ? 6 : v2 >= 1e5 ? 5 : v2 >= 1e4 ? 4 : v2 >= 1e3 ? 3 : v2 >= 100 ? 2 : v2 >= 10 ? 1 : 0;
+          };
+          exports.popCount = function(v2) {
+            v2 = v2 - (v2 >>> 1 & 1431655765);
+            v2 = (v2 & 858993459) + (v2 >>> 2 & 858993459);
+            return (v2 + (v2 >>> 4) & 252645135) * 16843009 >>> 24;
+          };
+          function countTrailingZeros(v2) {
+            var c2 = 32;
+            v2 &= -v2;
+            if (v2) c2--;
+            if (v2 & 65535) c2 -= 16;
+            if (v2 & 16711935) c2 -= 8;
+            if (v2 & 252645135) c2 -= 4;
+            if (v2 & 858993459) c2 -= 2;
+            if (v2 & 1431655765) c2 -= 1;
+            return c2;
+          }
+          exports.countTrailingZeros = countTrailingZeros;
+          exports.nextPow2 = function(v2) {
+            v2 += v2 === 0;
+            --v2;
+            v2 |= v2 >>> 1;
+            v2 |= v2 >>> 2;
+            v2 |= v2 >>> 4;
+            v2 |= v2 >>> 8;
+            v2 |= v2 >>> 16;
+            return v2 + 1;
+          };
+          exports.prevPow2 = function(v2) {
+            v2 |= v2 >>> 1;
+            v2 |= v2 >>> 2;
+            v2 |= v2 >>> 4;
+            v2 |= v2 >>> 8;
+            v2 |= v2 >>> 16;
+            return v2 - (v2 >>> 1);
+          };
+          exports.parity = function(v2) {
+            v2 ^= v2 >>> 16;
+            v2 ^= v2 >>> 8;
+            v2 ^= v2 >>> 4;
+            v2 &= 15;
+            return 27030 >>> v2 & 1;
+          };
+          var REVERSE_TABLE = new Array(256);
+          (function(tab) {
+            for (var i2 = 0; i2 < 256; ++i2) {
+              var v2 = i2, r2 = i2, s2 = 7;
+              for (v2 >>>= 1; v2; v2 >>>= 1) {
+                r2 <<= 1;
+                r2 |= v2 & 1;
+                --s2;
+              }
+              tab[i2] = r2 << s2 & 255;
+            }
+          })(REVERSE_TABLE);
+          exports.reverse = function(v2) {
+            return REVERSE_TABLE[v2 & 255] << 24 | REVERSE_TABLE[v2 >>> 8 & 255] << 16 | REVERSE_TABLE[v2 >>> 16 & 255] << 8 | REVERSE_TABLE[v2 >>> 24 & 255];
+          };
+          exports.interleave2 = function(x2, y2) {
+            x2 &= 65535;
+            x2 = (x2 | x2 << 8) & 16711935;
+            x2 = (x2 | x2 << 4) & 252645135;
+            x2 = (x2 | x2 << 2) & 858993459;
+            x2 = (x2 | x2 << 1) & 1431655765;
+            y2 &= 65535;
+            y2 = (y2 | y2 << 8) & 16711935;
+            y2 = (y2 | y2 << 4) & 252645135;
+            y2 = (y2 | y2 << 2) & 858993459;
+            y2 = (y2 | y2 << 1) & 1431655765;
+            return x2 | y2 << 1;
+          };
+          exports.deinterleave2 = function(v2, n2) {
+            v2 = v2 >>> n2 & 1431655765;
+            v2 = (v2 | v2 >>> 1) & 858993459;
+            v2 = (v2 | v2 >>> 2) & 252645135;
+            v2 = (v2 | v2 >>> 4) & 16711935;
+            v2 = (v2 | v2 >>> 16) & 65535;
+            return v2 << 16 >> 16;
+          };
+          exports.interleave3 = function(x2, y2, z2) {
+            x2 &= 1023;
+            x2 = (x2 | x2 << 16) & 4278190335;
+            x2 = (x2 | x2 << 8) & 251719695;
+            x2 = (x2 | x2 << 4) & 3272356035;
+            x2 = (x2 | x2 << 2) & 1227133513;
+            y2 &= 1023;
+            y2 = (y2 | y2 << 16) & 4278190335;
+            y2 = (y2 | y2 << 8) & 251719695;
+            y2 = (y2 | y2 << 4) & 3272356035;
+            y2 = (y2 | y2 << 2) & 1227133513;
+            x2 |= y2 << 1;
+            z2 &= 1023;
+            z2 = (z2 | z2 << 16) & 4278190335;
+            z2 = (z2 | z2 << 8) & 251719695;
+            z2 = (z2 | z2 << 4) & 3272356035;
+            z2 = (z2 | z2 << 2) & 1227133513;
+            return x2 | z2 << 2;
+          };
+          exports.deinterleave3 = function(v2, n2) {
+            v2 = v2 >>> n2 & 1227133513;
+            v2 = (v2 | v2 >>> 2) & 3272356035;
+            v2 = (v2 | v2 >>> 4) & 251719695;
+            v2 = (v2 | v2 >>> 8) & 4278190335;
+            v2 = (v2 | v2 >>> 16) & 1023;
+            return v2 << 22 >> 22;
+          };
+          exports.nextCombination = function(v2) {
+            var t4 = v2 | v2 - 1;
+            return t4 + 1 | (~t4 & -~t4) - 1 >>> countTrailingZeros(v2) + 1;
+          };
+        }
+      });
+      var require_dup = __commonJS({
+        "node_modules/dup/dup.js"(exports, module2) {
+          function dupe_array(count2, value, i2) {
+            var c2 = count2[i2] | 0;
+            if (c2 <= 0) {
+              return [];
+            }
+            var result = new Array(c2), j2;
+            if (i2 === count2.length - 1) {
+              for (j2 = 0; j2 < c2; ++j2) {
+                result[j2] = value;
+              }
+            } else {
+              for (j2 = 0; j2 < c2; ++j2) {
+                result[j2] = dupe_array(count2, value, i2 + 1);
+              }
+            }
+            return result;
+          }
+          function dupe_number(count2, value) {
+            var result, i2;
+            result = new Array(count2);
+            for (i2 = 0; i2 < count2; ++i2) {
+              result[i2] = value;
+            }
+            return result;
+          }
+          function dupe(count2, value) {
+            if (typeof value === "undefined") {
+              value = 0;
+            }
+            switch (typeof count2) {
+              case "number":
+                if (count2 > 0) {
+                  return dupe_number(count2 | 0, value);
+                }
+                break;
+              case "object":
+                if (typeof count2.length === "number") {
+                  return dupe_array(count2, value, 0);
+                }
+                break;
+            }
+            return [];
+          }
+          module2.exports = dupe;
+        }
+      });
+      var require_pool = __commonJS({
+        "node_modules/typedarray-pool/pool.js"(exports) {
+          var bits = require_twiddle();
+          var dup = require_dup();
+          var Buffer22 = require_buffer().Buffer;
+          if (!window.__TYPEDARRAY_POOL) {
+            window.__TYPEDARRAY_POOL = {
+              UINT8: dup([32, 0]),
+              UINT16: dup([32, 0]),
+              UINT32: dup([32, 0]),
+              BIGUINT64: dup([32, 0]),
+              INT8: dup([32, 0]),
+              INT16: dup([32, 0]),
+              INT32: dup([32, 0]),
+              BIGINT64: dup([32, 0]),
+              FLOAT: dup([32, 0]),
+              DOUBLE: dup([32, 0]),
+              DATA: dup([32, 0]),
+              UINT8C: dup([32, 0]),
+              BUFFER: dup([32, 0])
+            };
+          }
+          var hasUint8C = typeof Uint8ClampedArray !== "undefined";
+          var hasBigUint64 = typeof BigUint64Array !== "undefined";
+          var hasBigInt64 = typeof BigInt64Array !== "undefined";
+          var POOL = window.__TYPEDARRAY_POOL;
+          if (!POOL.UINT8C) {
+            POOL.UINT8C = dup([32, 0]);
+          }
+          if (!POOL.BIGUINT64) {
+            POOL.BIGUINT64 = dup([32, 0]);
+          }
+          if (!POOL.BIGINT64) {
+            POOL.BIGINT64 = dup([32, 0]);
+          }
+          if (!POOL.BUFFER) {
+            POOL.BUFFER = dup([32, 0]);
+          }
+          var DATA = POOL.DATA;
+          var BUFFER = POOL.BUFFER;
+          exports.free = function free(array) {
+            if (Buffer22.isBuffer(array)) {
+              BUFFER[bits.log2(array.length)].push(array);
+            } else {
+              if (Object.prototype.toString.call(array) !== "[object ArrayBuffer]") {
+                array = array.buffer;
+              }
+              if (!array) {
+                return;
+              }
+              var n2 = array.length || array.byteLength;
+              var log_n = bits.log2(n2) | 0;
+              DATA[log_n].push(array);
+            }
+          };
+          function freeArrayBuffer(buffer) {
+            if (!buffer) {
+              return;
+            }
+            var n2 = buffer.length || buffer.byteLength;
+            var log_n = bits.log2(n2);
+            DATA[log_n].push(buffer);
+          }
+          function freeTypedArray(array) {
+            freeArrayBuffer(array.buffer);
+          }
+          exports.freeUint8 = exports.freeUint16 = exports.freeUint32 = exports.freeBigUint64 = exports.freeInt8 = exports.freeInt16 = exports.freeInt32 = exports.freeBigInt64 = exports.freeFloat32 = exports.freeFloat = exports.freeFloat64 = exports.freeDouble = exports.freeUint8Clamped = exports.freeDataView = freeTypedArray;
+          exports.freeArrayBuffer = freeArrayBuffer;
+          exports.freeBuffer = function freeBuffer(array) {
+            BUFFER[bits.log2(array.length)].push(array);
+          };
+          exports.malloc = function malloc(n2, dtype) {
+            if (dtype === void 0 || dtype === "arraybuffer") {
+              return mallocArrayBuffer(n2);
+            } else {
+              switch (dtype) {
+                case "uint8":
+                  return mallocUint8(n2);
+                case "uint16":
+                  return mallocUint16(n2);
+                case "uint32":
+                  return mallocUint32(n2);
+                case "int8":
+                  return mallocInt8(n2);
+                case "int16":
+                  return mallocInt16(n2);
+                case "int32":
+                  return mallocInt32(n2);
+                case "float":
+                case "float32":
+                  return mallocFloat(n2);
+                case "double":
+                case "float64":
+                  return mallocDouble(n2);
+                case "uint8_clamped":
+                  return mallocUint8Clamped(n2);
+                case "bigint64":
+                  return mallocBigInt64(n2);
+                case "biguint64":
+                  return mallocBigUint64(n2);
+                case "buffer":
+                  return mallocBuffer(n2);
+                case "data":
+                case "dataview":
+                  return mallocDataView(n2);
+                default:
+                  return null;
+              }
+            }
+            return null;
+          };
+          function mallocArrayBuffer(n2) {
+            var n2 = bits.nextPow2(n2);
+            var log_n = bits.log2(n2);
+            var d2 = DATA[log_n];
+            if (d2.length > 0) {
+              return d2.pop();
+            }
+            return new ArrayBuffer(n2);
+          }
+          exports.mallocArrayBuffer = mallocArrayBuffer;
+          function mallocUint8(n2) {
+            return new Uint8Array(mallocArrayBuffer(n2), 0, n2);
+          }
+          exports.mallocUint8 = mallocUint8;
+          function mallocUint16(n2) {
+            return new Uint16Array(mallocArrayBuffer(2 * n2), 0, n2);
+          }
+          exports.mallocUint16 = mallocUint16;
+          function mallocUint32(n2) {
+            return new Uint32Array(mallocArrayBuffer(4 * n2), 0, n2);
+          }
+          exports.mallocUint32 = mallocUint32;
+          function mallocInt8(n2) {
+            return new Int8Array(mallocArrayBuffer(n2), 0, n2);
+          }
+          exports.mallocInt8 = mallocInt8;
+          function mallocInt16(n2) {
+            return new Int16Array(mallocArrayBuffer(2 * n2), 0, n2);
+          }
+          exports.mallocInt16 = mallocInt16;
+          function mallocInt32(n2) {
+            return new Int32Array(mallocArrayBuffer(4 * n2), 0, n2);
+          }
+          exports.mallocInt32 = mallocInt32;
+          function mallocFloat(n2) {
+            return new Float32Array(mallocArrayBuffer(4 * n2), 0, n2);
+          }
+          exports.mallocFloat32 = exports.mallocFloat = mallocFloat;
+          function mallocDouble(n2) {
+            return new Float64Array(mallocArrayBuffer(8 * n2), 0, n2);
+          }
+          exports.mallocFloat64 = exports.mallocDouble = mallocDouble;
+          function mallocUint8Clamped(n2) {
+            if (hasUint8C) {
+              return new Uint8ClampedArray(mallocArrayBuffer(n2), 0, n2);
+            } else {
+              return mallocUint8(n2);
+            }
+          }
+          exports.mallocUint8Clamped = mallocUint8Clamped;
+          function mallocBigUint64(n2) {
+            if (hasBigUint64) {
+              return new BigUint64Array(mallocArrayBuffer(8 * n2), 0, n2);
+            } else {
+              return null;
+            }
+          }
+          exports.mallocBigUint64 = mallocBigUint64;
+          function mallocBigInt64(n2) {
+            if (hasBigInt64) {
+              return new BigInt64Array(mallocArrayBuffer(8 * n2), 0, n2);
+            } else {
+              return null;
+            }
+          }
+          exports.mallocBigInt64 = mallocBigInt64;
+          function mallocDataView(n2) {
+            return new DataView(mallocArrayBuffer(n2), 0, n2);
+          }
+          exports.mallocDataView = mallocDataView;
+          function mallocBuffer(n2) {
+            n2 = bits.nextPow2(n2);
+            var log_n = bits.log2(n2);
+            var cache = BUFFER[log_n];
+            if (cache.length > 0) {
+              return cache.pop();
+            }
+            return new Buffer22(n2);
+          }
+          exports.mallocBuffer = mallocBuffer;
+          exports.clearCache = function clearCache() {
+            for (var i2 = 0; i2 < 32; ++i2) {
+              POOL.UINT8[i2].length = 0;
+              POOL.UINT16[i2].length = 0;
+              POOL.UINT32[i2].length = 0;
+              POOL.INT8[i2].length = 0;
+              POOL.INT16[i2].length = 0;
+              POOL.INT32[i2].length = 0;
+              POOL.FLOAT[i2].length = 0;
+              POOL.DOUBLE[i2].length = 0;
+              POOL.BIGUINT64[i2].length = 0;
+              POOL.BIGINT64[i2].length = 0;
+              POOL.UINT8C[i2].length = 0;
+              DATA[i2].length = 0;
+              BUFFER[i2].length = 0;
+            }
+          };
+        }
+      });
+      var require_is_plain_obj = __commonJS({
+        "node_modules/is-plain-obj/index.js"(exports, module2) {
+          var toString = Object.prototype.toString;
+          module2.exports = function(x2) {
+            var prototype;
+            return toString.call(x2) === "[object Object]" && (prototype = Object.getPrototypeOf(x2), prototype === null || prototype === Object.getPrototypeOf({}));
+          };
+        }
+      });
+      var require_parse_unit = __commonJS({
+        "node_modules/parse-unit/index.js"(exports, module2) {
+          module2.exports = function parseUnit(str, out) {
+            if (!out)
+              out = [0, ""];
+            str = String(str);
+            var num = parseFloat(str, 10);
+            out[0] = num;
+            out[1] = str.match(/[\d.\-\+]*\s*(.*)/)[1] || "";
+            return out;
+          };
+        }
+      });
+      var require_topx = __commonJS({
+        "node_modules/to-px/topx.js"(exports, module2) {
+          var parseUnit = require_parse_unit();
+          module2.exports = toPX;
+          var PIXELS_PER_INCH = 96;
+          function getPropertyInPX(element, prop) {
+            var parts = parseUnit(getComputedStyle(element).getPropertyValue(prop));
+            return parts[0] * toPX(parts[1], element);
+          }
+          function getSizeBrutal(unit, element) {
+            var testDIV = document.createElement("div");
+            testDIV.style["font-size"] = "128" + unit;
+            element.appendChild(testDIV);
+            var size = getPropertyInPX(testDIV, "font-size") / 128;
+            element.removeChild(testDIV);
+            return size;
+          }
+          function toPX(str, element) {
+            element = element || document.body;
+            str = (str || "px").trim().toLowerCase();
+            if (element === window || element === document) {
+              element = document.body;
+            }
+            switch (str) {
+              case "%":
+                return element.clientHeight / 100;
+              case "ch":
+              case "ex":
+                return getSizeBrutal(str, element);
+              case "em":
+                return getPropertyInPX(element, "font-size");
+              case "rem":
+                return getPropertyInPX(document.body, "font-size");
+              case "vw":
+                return window.innerWidth / 100;
+              case "vh":
+                return window.innerHeight / 100;
+              case "vmin":
+                return Math.min(window.innerWidth, window.innerHeight) / 100;
+              case "vmax":
+                return Math.max(window.innerWidth, window.innerHeight) / 100;
+              case "in":
+                return PIXELS_PER_INCH;
+              case "cm":
+                return PIXELS_PER_INCH / 2.54;
+              case "mm":
+                return PIXELS_PER_INCH / 25.4;
+              case "pt":
+                return PIXELS_PER_INCH / 72;
+              case "pc":
+                return PIXELS_PER_INCH / 6;
+            }
+            return 1;
+          }
+        }
+      });
+      var require_detect_kerning = __commonJS({
+        "node_modules/detect-kerning/index.js"(exports, module2) {
+          module2.exports = kerning;
+          var canvas2 = kerning.canvas = document.createElement("canvas");
+          var ctx2 = canvas2.getContext("2d");
+          var asciiPairs = createPairs([32, 126]);
+          kerning.createPairs = createPairs;
+          kerning.ascii = asciiPairs;
+          function kerning(family, o2) {
+            if (Array.isArray(family)) family = family.join(", ");
+            var table = {}, pairs, fs2 = 16, threshold = 0.05;
+            if (o2) {
+              if (o2.length === 2 && typeof o2[0] === "number") {
+                pairs = createPairs(o2);
+              } else if (Array.isArray(o2)) {
+                pairs = o2;
+              } else {
+                if (o2.o) pairs = createPairs(o2.o);
+                else if (o2.pairs) pairs = o2.pairs;
+                if (o2.fontSize) fs2 = o2.fontSize;
+                if (o2.threshold != null) threshold = o2.threshold;
+              }
+            }
+            if (!pairs) pairs = asciiPairs;
+            ctx2.font = fs2 + "px " + family;
+            for (var i2 = 0; i2 < pairs.length; i2++) {
+              var pair = pairs[i2];
+              var width = ctx2.measureText(pair[0]).width + ctx2.measureText(pair[1]).width;
+              var kerningWidth = ctx2.measureText(pair).width;
+              if (Math.abs(width - kerningWidth) > fs2 * threshold) {
+                var emWidth = (kerningWidth - width) / fs2;
+                table[pair] = emWidth * 1e3;
+              }
+            }
+            return table;
+          }
+          function createPairs(range) {
+            var pairs = [];
+            for (var i2 = range[0]; i2 <= range[1]; i2++) {
+              var leftChar = String.fromCharCode(i2);
+              for (var j2 = range[0]; j2 < range[1]; j2++) {
+                var rightChar = String.fromCharCode(j2);
+                var pair = leftChar + rightChar;
+                pairs.push(pair);
+              }
+            }
+            return pairs;
+          }
+        }
+      });
+      var require_font_measure = __commonJS({
+        "node_modules/font-measure/index.js"(exports, module2) {
+          module2.exports = measure;
+          measure.canvas = document.createElement("canvas");
+          measure.cache = {};
+          function measure(font, o2) {
+            if (!o2) o2 = {};
+            if (typeof font === "string" || Array.isArray(font)) {
+              o2.family = font;
+            }
+            var family = Array.isArray(o2.family) ? o2.family.join(", ") : o2.family;
+            if (!family) throw Error("`family` must be defined");
+            var fs2 = o2.size || o2.fontSize || o2.em || 48;
+            var weight = o2.weight || o2.fontWeight || "";
+            var style = o2.style || o2.fontStyle || "";
+            var font = [style, weight, fs2].join(" ") + "px " + family;
+            var origin = o2.origin || "top";
+            if (measure.cache[family]) {
+              if (fs2 <= measure.cache[family].em) {
+                return applyOrigin(measure.cache[family], origin);
+              }
+            }
+            var canvas2 = o2.canvas || measure.canvas;
+            var ctx2 = canvas2.getContext("2d");
+            var chars = {
+              upper: o2.upper !== void 0 ? o2.upper : "H",
+              lower: o2.lower !== void 0 ? o2.lower : "x",
+              descent: o2.descent !== void 0 ? o2.descent : "p",
+              ascent: o2.ascent !== void 0 ? o2.ascent : "h",
+              tittle: o2.tittle !== void 0 ? o2.tittle : "i",
+              overshoot: o2.overshoot !== void 0 ? o2.overshoot : "O"
+            };
+            var l2 = Math.ceil(fs2 * 1.5);
+            canvas2.height = l2;
+            canvas2.width = l2 * 0.5;
+            ctx2.font = font;
+            var char = "H";
+            var result = {
+              top: 0
+            };
+            ctx2.clearRect(0, 0, l2, l2);
+            ctx2.textBaseline = "top";
+            ctx2.fillStyle = "black";
+            ctx2.fillText(char, 0, 0);
+            var topPx = firstTop(ctx2.getImageData(0, 0, l2, l2));
+            ctx2.clearRect(0, 0, l2, l2);
+            ctx2.textBaseline = "bottom";
+            ctx2.fillText(char, 0, l2);
+            var bottomPx = firstTop(ctx2.getImageData(0, 0, l2, l2));
+            result.lineHeight = result.bottom = l2 - bottomPx + topPx;
+            ctx2.clearRect(0, 0, l2, l2);
+            ctx2.textBaseline = "alphabetic";
+            ctx2.fillText(char, 0, l2);
+            var baselinePx = firstTop(ctx2.getImageData(0, 0, l2, l2));
+            var baseline = l2 - baselinePx - 1 + topPx;
+            result.baseline = result.alphabetic = baseline;
+            ctx2.clearRect(0, 0, l2, l2);
+            ctx2.textBaseline = "middle";
+            ctx2.fillText(char, 0, l2 * 0.5);
+            var medianPx = firstTop(ctx2.getImageData(0, 0, l2, l2));
+            result.median = result.middle = l2 - medianPx - 1 + topPx - l2 * 0.5;
+            ctx2.clearRect(0, 0, l2, l2);
+            ctx2.textBaseline = "hanging";
+            ctx2.fillText(char, 0, l2 * 0.5);
+            var hangingPx = firstTop(ctx2.getImageData(0, 0, l2, l2));
+            result.hanging = l2 - hangingPx - 1 + topPx - l2 * 0.5;
+            ctx2.clearRect(0, 0, l2, l2);
+            ctx2.textBaseline = "ideographic";
+            ctx2.fillText(char, 0, l2);
+            var ideographicPx = firstTop(ctx2.getImageData(0, 0, l2, l2));
+            result.ideographic = l2 - ideographicPx - 1 + topPx;
+            if (chars.upper) {
+              ctx2.clearRect(0, 0, l2, l2);
+              ctx2.textBaseline = "top";
+              ctx2.fillText(chars.upper, 0, 0);
+              result.upper = firstTop(ctx2.getImageData(0, 0, l2, l2));
+              result.capHeight = result.baseline - result.upper;
+            }
+            if (chars.lower) {
+              ctx2.clearRect(0, 0, l2, l2);
+              ctx2.textBaseline = "top";
+              ctx2.fillText(chars.lower, 0, 0);
+              result.lower = firstTop(ctx2.getImageData(0, 0, l2, l2));
+              result.xHeight = result.baseline - result.lower;
+            }
+            if (chars.tittle) {
+              ctx2.clearRect(0, 0, l2, l2);
+              ctx2.textBaseline = "top";
+              ctx2.fillText(chars.tittle, 0, 0);
+              result.tittle = firstTop(ctx2.getImageData(0, 0, l2, l2));
+            }
+            if (chars.ascent) {
+              ctx2.clearRect(0, 0, l2, l2);
+              ctx2.textBaseline = "top";
+              ctx2.fillText(chars.ascent, 0, 0);
+              result.ascent = firstTop(ctx2.getImageData(0, 0, l2, l2));
+            }
+            if (chars.descent) {
+              ctx2.clearRect(0, 0, l2, l2);
+              ctx2.textBaseline = "top";
+              ctx2.fillText(chars.descent, 0, 0);
+              result.descent = firstBottom(ctx2.getImageData(0, 0, l2, l2));
+            }
+            if (chars.overshoot) {
+              ctx2.clearRect(0, 0, l2, l2);
+              ctx2.textBaseline = "top";
+              ctx2.fillText(chars.overshoot, 0, 0);
+              var overshootPx = firstBottom(ctx2.getImageData(0, 0, l2, l2));
+              result.overshoot = overshootPx - baseline;
+            }
+            for (var name2 in result) {
+              result[name2] /= fs2;
+            }
+            result.em = fs2;
+            measure.cache[family] = result;
+            return applyOrigin(result, origin);
+          }
+          function applyOrigin(obj, origin) {
+            var res = {};
+            if (typeof origin === "string") origin = obj[origin];
+            for (var name2 in obj) {
+              if (name2 === "em") continue;
+              res[name2] = obj[name2] - origin;
+            }
+            return res;
+          }
+          function firstTop(iData) {
+            var l2 = iData.height;
+            var data = iData.data;
+            for (var i2 = 3; i2 < data.length; i2 += 4) {
+              if (data[i2] !== 0) {
+                return Math.floor((i2 - 3) * 0.25 / l2);
+              }
+            }
+          }
+          function firstBottom(iData) {
+            var l2 = iData.height;
+            var data = iData.data;
+            for (var i2 = data.length - 1; i2 > 0; i2 -= 4) {
+              if (data[i2] !== 0) {
+                return Math.floor((i2 - 3) * 0.25 / l2);
+              }
+            }
+          }
+        }
+      });
+      var require_dist = __commonJS({
+        "node_modules/gl-text/dist.js"(exports, module2) {
+          var Font = require_css_font();
+          var pick = require_pick_by_alias();
+          var createRegl = require_regl_unchecked();
+          var createGl = require_context();
+          var WeakMap2 = require_es6_weak_map();
+          var rgba3 = require_color_normalize();
+          var fontAtlas = require_font_atlas();
+          var pool = require_pool();
+          var parseRect = require_parse_rect();
+          var isObj = require_is_plain_obj();
+          var parseUnit = require_parse_unit();
+          var px = require_topx();
+          var kerning = require_detect_kerning();
+          var extend2 = require_object_assign();
+          var metrics = require_font_measure();
+          var flatten2 = require_flatten_vertex_data();
+          var ref = require_twiddle();
+          var nextPow2 = ref.nextPow2;
+          var shaderCache = new WeakMap2();
+          var isStretchSupported = false;
+          if (document.body) {
+            el2 = document.body.appendChild(document.createElement("div"));
+            el2.style.font = "italic small-caps bold condensed 16px/2 cursive";
+            if (getComputedStyle(el2).fontStretch) {
+              isStretchSupported = true;
+            }
+            document.body.removeChild(el2);
+          }
+          var el2;
+          var GlText = function GlText2(o2) {
+            if (isRegl(o2)) {
+              o2 = { regl: o2 };
+              this.gl = o2.regl._gl;
+            } else {
+              this.gl = createGl(o2);
+            }
+            this.shader = shaderCache.get(this.gl);
+            if (!this.shader) {
+              this.regl = o2.regl || createRegl({ gl: this.gl });
+            } else {
+              this.regl = this.shader.regl;
+            }
+            this.charBuffer = this.regl.buffer({ type: "uint8", usage: "stream" });
+            this.sizeBuffer = this.regl.buffer({ type: "float", usage: "stream" });
+            if (!this.shader) {
+              this.shader = this.createShader();
+              shaderCache.set(this.gl, this.shader);
+            }
+            this.batch = [];
+            this.fontSize = [];
+            this.font = [];
+            this.fontAtlas = [];
+            this.draw = this.shader.draw.bind(this);
+            this.render = function() {
+              this.regl._refresh();
+              this.draw(this.batch);
+            };
+            this.canvas = this.gl.canvas;
+            this.update(isObj(o2) ? o2 : {});
+          };
+          GlText.prototype.createShader = function createShader() {
+            var regl = this.regl;
+            var draw = regl({
+              blend: {
+                enable: true,
+                color: [0, 0, 0, 1],
+                func: {
+                  srcRGB: "src alpha",
+                  dstRGB: "one minus src alpha",
+                  srcAlpha: "one minus dst alpha",
+                  dstAlpha: "one"
+                }
+              },
+              stencil: { enable: false },
+              depth: { enable: false },
+              count: regl.prop("count"),
+              offset: regl.prop("offset"),
+              attributes: {
+                charOffset: {
+                  offset: 4,
+                  stride: 8,
+                  buffer: regl.this("sizeBuffer")
+                },
+                width: {
+                  offset: 0,
+                  stride: 8,
+                  buffer: regl.this("sizeBuffer")
+                },
+                char: regl.this("charBuffer"),
+                position: regl.this("position")
+              },
+              uniforms: {
+                atlasSize: function(c2, p2) {
+                  return [p2.atlas.width, p2.atlas.height];
+                },
+                atlasDim: function(c2, p2) {
+                  return [p2.atlas.cols, p2.atlas.rows];
+                },
+                atlas: function(c2, p2) {
+                  return p2.atlas.texture;
+                },
+                charStep: function(c2, p2) {
+                  return p2.atlas.step;
+                },
+                em: function(c2, p2) {
+                  return p2.atlas.em;
+                },
+                color: regl.prop("color"),
+                opacity: regl.prop("opacity"),
+                viewport: regl.this("viewportArray"),
+                scale: regl.this("scale"),
+                align: regl.prop("align"),
+                baseline: regl.prop("baseline"),
+                translate: regl.this("translate"),
+                positionOffset: regl.prop("positionOffset")
+              },
+              primitive: "points",
+              viewport: regl.this("viewport"),
+              vert: "\n			precision highp float;\n			attribute float width, charOffset, char;\n			attribute vec2 position;\n			uniform float fontSize, charStep, em, align, baseline;\n			uniform vec4 viewport;\n			uniform vec4 color;\n			uniform vec2 atlasSize, atlasDim, scale, translate, positionOffset;\n			varying vec2 charCoord, charId;\n			varying float charWidth;\n			varying vec4 fontColor;\n			void main () {\n				vec2 offset = floor(em * (vec2(align + charOffset, baseline)\n					+ vec2(positionOffset.x, -positionOffset.y)))\n					/ (viewport.zw * scale.xy);\n\n				vec2 position = (position + translate) * scale;\n				position += offset * scale;\n\n				charCoord = position * viewport.zw + viewport.xy;\n\n				gl_Position = vec4(position * 2. - 1., 0, 1);\n\n				gl_PointSize = charStep;\n\n				charId.x = mod(char, atlasDim.x);\n				charId.y = floor(char / atlasDim.x);\n\n				charWidth = width * em;\n\n				fontColor = color / 255.;\n			}",
+              frag: "\n			precision highp float;\n			uniform float fontSize, charStep, opacity;\n			uniform vec2 atlasSize;\n			uniform vec4 viewport;\n			uniform sampler2D atlas;\n			varying vec4 fontColor;\n			varying vec2 charCoord, charId;\n			varying float charWidth;\n\n			float lightness(vec4 color) {\n				return color.r * 0.299 + color.g * 0.587 + color.b * 0.114;\n			}\n\n			void main () {\n				vec2 uv = gl_FragCoord.xy - charCoord + charStep * .5;\n				float halfCharStep = floor(charStep * .5 + .5);\n\n				// invert y and shift by 1px (FF expecially needs that)\n				uv.y = charStep - uv.y;\n\n				// ignore points outside of character bounding box\n				float halfCharWidth = ceil(charWidth * .5);\n				if (floor(uv.x) > halfCharStep + halfCharWidth ||\n					floor(uv.x) < halfCharStep - halfCharWidth) return;\n\n				uv += charId * charStep;\n				uv = uv / atlasSize;\n\n				vec4 color = fontColor;\n				vec4 mask = texture2D(atlas, uv);\n\n				float maskY = lightness(mask);\n				// float colorY = lightness(color);\n				color.a *= maskY;\n				color.a *= opacity;\n\n				// color.a += .1;\n\n				// antialiasing, see yiq color space y-channel formula\n				// color.rgb += (1. - color.rgb) * (1. - mask.rgb);\n\n				gl_FragColor = color;\n			}"
+            });
+            var atlas = {};
+            return { regl, draw, atlas };
+          };
+          GlText.prototype.update = function update(o2) {
+            var this$1$1 = this;
+            if (typeof o2 === "string") {
+              o2 = { text: o2 };
+            } else if (!o2) {
+              return;
+            }
+            o2 = pick(o2, {
+              position: "position positions coord coords coordinates",
+              font: "font fontFace fontface typeface cssFont css-font family fontFamily",
+              fontSize: "fontSize fontsize size font-size",
+              text: "text texts chars characters value values symbols",
+              align: "align alignment textAlign textbaseline",
+              baseline: "baseline textBaseline textbaseline",
+              direction: "dir direction textDirection",
+              color: "color colour fill fill-color fillColor textColor textcolor",
+              kerning: "kerning kern",
+              range: "range dataBox",
+              viewport: "vp viewport viewBox viewbox viewPort",
+              opacity: "opacity alpha transparency visible visibility opaque",
+              offset: "offset positionOffset padding shift indent indentation"
+            }, true);
+            if (o2.opacity != null) {
+              if (Array.isArray(o2.opacity)) {
+                this.opacity = o2.opacity.map(function(o22) {
+                  return parseFloat(o22);
+                });
+              } else {
+                this.opacity = parseFloat(o2.opacity);
+              }
+            }
+            if (o2.viewport != null) {
+              this.viewport = parseRect(o2.viewport);
+              this.viewportArray = [this.viewport.x, this.viewport.y, this.viewport.width, this.viewport.height];
+            }
+            if (this.viewport == null) {
+              this.viewport = {
+                x: 0,
+                y: 0,
+                width: this.gl.drawingBufferWidth,
+                height: this.gl.drawingBufferHeight
+              };
+              this.viewportArray = [this.viewport.x, this.viewport.y, this.viewport.width, this.viewport.height];
+            }
+            if (o2.kerning != null) {
+              this.kerning = o2.kerning;
+            }
+            if (o2.offset != null) {
+              if (typeof o2.offset === "number") {
+                o2.offset = [o2.offset, 0];
+              }
+              this.positionOffset = flatten2(o2.offset);
+            }
+            if (o2.direction) {
+              this.direction = o2.direction;
+            }
+            if (o2.range) {
+              this.range = o2.range;
+              this.scale = [1 / (o2.range[2] - o2.range[0]), 1 / (o2.range[3] - o2.range[1])];
+              this.translate = [-o2.range[0], -o2.range[1]];
+            }
+            if (o2.scale) {
+              this.scale = o2.scale;
+            }
+            if (o2.translate) {
+              this.translate = o2.translate;
+            }
+            if (!this.scale) {
+              this.scale = [1 / this.viewport.width, 1 / this.viewport.height];
+            }
+            if (!this.translate) {
+              this.translate = [0, 0];
+            }
+            if (!this.font.length && !o2.font) {
+              o2.font = GlText.baseFontSize + "px sans-serif";
+            }
+            var newFont = false, newFontSize = false;
+            if (o2.font) {
+              (Array.isArray(o2.font) ? o2.font : [o2.font]).forEach(function(font2, i22) {
+                if (typeof font2 === "string") {
+                  try {
+                    font2 = Font.parse(font2);
+                  } catch (e2) {
+                    font2 = Font.parse(GlText.baseFontSize + "px " + font2);
+                  }
+                } else {
+                  var fontStyle = font2.style;
+                  var fontWeight = font2.weight;
+                  var fontStretch = font2.stretch;
+                  var fontVariant = font2.variant;
+                  font2 = Font.parse(Font.stringify(font2));
+                  if (fontStyle) font2.style = fontStyle;
+                  if (fontWeight) font2.weight = fontWeight;
+                  if (fontStretch) font2.stretch = fontStretch;
+                  if (fontVariant) font2.variant = fontVariant;
+                }
+                var baseString = Font.stringify({
+                  size: GlText.baseFontSize,
+                  family: font2.family,
+                  stretch: isStretchSupported ? font2.stretch : void 0,
+                  variant: font2.variant,
+                  weight: font2.weight,
+                  style: font2.style
+                });
+                var unit = parseUnit(font2.size);
+                var fs2 = Math.round(unit[0] * px(unit[1]));
+                if (fs2 !== this$1$1.fontSize[i22]) {
+                  newFontSize = true;
+                  this$1$1.fontSize[i22] = fs2;
+                }
+                if (!this$1$1.font[i22] || baseString != this$1$1.font[i22].baseString) {
+                  newFont = true;
+                  this$1$1.font[i22] = GlText.fonts[baseString];
+                  if (!this$1$1.font[i22]) {
+                    var family = font2.family.join(", ");
+                    var style = [font2.style];
+                    if (font2.style != font2.variant) {
+                      style.push(font2.variant);
+                    }
+                    if (font2.variant != font2.weight) {
+                      style.push(font2.weight);
+                    }
+                    if (isStretchSupported && font2.weight != font2.stretch) {
+                      style.push(font2.stretch);
+                    }
+                    this$1$1.font[i22] = {
+                      baseString,
+                      // typeface
+                      family,
+                      weight: font2.weight,
+                      stretch: font2.stretch,
+                      style: font2.style,
+                      variant: font2.variant,
+                      // widths of characters
+                      width: {},
+                      // kernin pairs offsets
+                      kerning: {},
+                      metrics: metrics(family, {
+                        origin: "top",
+                        fontSize: GlText.baseFontSize,
+                        fontStyle: style.join(" ")
+                      })
+                    };
+                    GlText.fonts[baseString] = this$1$1.font[i22];
+                  }
+                }
+              });
+            }
+            if (newFont || newFontSize) {
+              this.font.forEach(function(font2, i22) {
+                var fontString = Font.stringify({
+                  size: this$1$1.fontSize[i22],
+                  family: font2.family,
+                  stretch: isStretchSupported ? font2.stretch : void 0,
+                  variant: font2.variant,
+                  weight: font2.weight,
+                  style: font2.style
+                });
+                this$1$1.fontAtlas[i22] = this$1$1.shader.atlas[fontString];
+                if (!this$1$1.fontAtlas[i22]) {
+                  var metrics2 = font2.metrics;
+                  this$1$1.shader.atlas[fontString] = this$1$1.fontAtlas[i22] = {
+                    fontString,
+                    // even step is better for rendered characters
+                    step: Math.ceil(this$1$1.fontSize[i22] * metrics2.bottom * 0.5) * 2,
+                    em: this$1$1.fontSize[i22],
+                    cols: 0,
+                    rows: 0,
+                    height: 0,
+                    width: 0,
+                    chars: [],
+                    ids: {},
+                    texture: this$1$1.regl.texture()
+                  };
+                }
+                if (o2.text == null) {
+                  o2.text = this$1$1.text;
+                }
+              });
+            }
+            if (typeof o2.text === "string" && o2.position && o2.position.length > 2) {
+              var textArray = Array(o2.position.length * 0.5);
+              for (var i2 = 0; i2 < textArray.length; i2++) {
+                textArray[i2] = o2.text;
+              }
+              o2.text = textArray;
+            }
+            var newAtlasChars;
+            if (o2.text != null || newFont) {
+              this.textOffsets = [0];
+              if (Array.isArray(o2.text)) {
+                this.count = o2.text[0].length;
+                this.counts = [this.count];
+                for (var i$1 = 1; i$1 < o2.text.length; i$1++) {
+                  this.textOffsets[i$1] = this.textOffsets[i$1 - 1] + o2.text[i$1 - 1].length;
+                  this.count += o2.text[i$1].length;
+                  this.counts.push(o2.text[i$1].length);
+                }
+                this.text = o2.text.join("");
+              } else {
+                this.text = o2.text;
+                this.count = this.text.length;
+                this.counts = [this.count];
+              }
+              newAtlasChars = [];
+              this.font.forEach(function(font2, idx) {
+                GlText.atlasContext.font = font2.baseString;
+                var atlas2 = this$1$1.fontAtlas[idx];
+                for (var i22 = 0; i22 < this$1$1.text.length; i22++) {
+                  var char2 = this$1$1.text.charAt(i22);
+                  if (atlas2.ids[char2] == null) {
+                    atlas2.ids[char2] = atlas2.chars.length;
+                    atlas2.chars.push(char2);
+                    newAtlasChars.push(char2);
+                  }
+                  if (font2.width[char2] == null) {
+                    font2.width[char2] = GlText.atlasContext.measureText(char2).width / GlText.baseFontSize;
+                    if (this$1$1.kerning) {
+                      var pairs = [];
+                      for (var baseChar in font2.width) {
+                        pairs.push(baseChar + char2, char2 + baseChar);
+                      }
+                      extend2(font2.kerning, kerning(font2.family, {
+                        pairs
+                      }));
+                    }
+                  }
+                }
+              });
+            }
+            if (o2.position) {
+              if (o2.position.length > 2) {
+                var flat = !o2.position[0].length;
+                var positionData = pool.mallocFloat(this.count * 2);
+                for (var i$2 = 0, ptr = 0; i$2 < this.counts.length; i$2++) {
+                  var count2 = this.counts[i$2];
+                  if (flat) {
+                    for (var j2 = 0; j2 < count2; j2++) {
+                      positionData[ptr++] = o2.position[i$2 * 2];
+                      positionData[ptr++] = o2.position[i$2 * 2 + 1];
+                    }
+                  } else {
+                    for (var j$1 = 0; j$1 < count2; j$1++) {
+                      positionData[ptr++] = o2.position[i$2][0];
+                      positionData[ptr++] = o2.position[i$2][1];
+                    }
+                  }
+                }
+                if (this.position.call) {
+                  this.position({
+                    type: "float",
+                    data: positionData
+                  });
+                } else {
+                  this.position = this.regl.buffer({
+                    type: "float",
+                    data: positionData
+                  });
+                }
+                pool.freeFloat(positionData);
+              } else {
+                if (this.position.destroy) {
+                  this.position.destroy();
+                }
+                this.position = {
+                  constant: o2.position
+                };
+              }
+            }
+            if (o2.text || newFont) {
+              var charIds = pool.mallocUint8(this.count);
+              var sizeData = pool.mallocFloat(this.count * 2);
+              this.textWidth = [];
+              for (var i$3 = 0, ptr$1 = 0; i$3 < this.counts.length; i$3++) {
+                var count$1 = this.counts[i$3];
+                var font = this.font[i$3] || this.font[0];
+                var atlas = this.fontAtlas[i$3] || this.fontAtlas[0];
+                for (var j$2 = 0; j$2 < count$1; j$2++) {
+                  var char = this.text.charAt(ptr$1);
+                  var prevChar = this.text.charAt(ptr$1 - 1);
+                  charIds[ptr$1] = atlas.ids[char];
+                  sizeData[ptr$1 * 2] = font.width[char];
+                  if (j$2) {
+                    var prevWidth = sizeData[ptr$1 * 2 - 2];
+                    var currWidth = sizeData[ptr$1 * 2];
+                    var prevOffset = sizeData[ptr$1 * 2 - 1];
+                    var offset = prevOffset + prevWidth * 0.5 + currWidth * 0.5;
+                    if (this.kerning) {
+                      var kerning$1 = font.kerning[prevChar + char];
+                      if (kerning$1) {
+                        offset += kerning$1 * 1e-3;
+                      }
+                    }
+                    sizeData[ptr$1 * 2 + 1] = offset;
+                  } else {
+                    sizeData[ptr$1 * 2 + 1] = sizeData[ptr$1 * 2] * 0.5;
+                  }
+                  ptr$1++;
+                }
+                this.textWidth.push(
+                  !sizeData.length ? 0 : (
+                    // last offset + half last width
+                    sizeData[ptr$1 * 2 - 2] * 0.5 + sizeData[ptr$1 * 2 - 1]
+                  )
+                );
+              }
+              if (!o2.align) {
+                o2.align = this.align;
+              }
+              this.charBuffer({ data: charIds, type: "uint8", usage: "stream" });
+              this.sizeBuffer({ data: sizeData, type: "float", usage: "stream" });
+              pool.freeUint8(charIds);
+              pool.freeFloat(sizeData);
+              if (newAtlasChars.length) {
+                this.font.forEach(function(font2, i22) {
+                  var atlas2 = this$1$1.fontAtlas[i22];
+                  var step = atlas2.step;
+                  var maxCols = Math.floor(GlText.maxAtlasSize / step);
+                  var cols = Math.min(maxCols, atlas2.chars.length);
+                  var rows = Math.ceil(atlas2.chars.length / cols);
+                  var atlasWidth = nextPow2(cols * step);
+                  var atlasHeight = nextPow2(rows * step);
+                  atlas2.width = atlasWidth;
+                  atlas2.height = atlasHeight;
+                  atlas2.rows = rows;
+                  atlas2.cols = cols;
+                  if (!atlas2.em) {
+                    return;
+                  }
+                  atlas2.texture({
+                    data: fontAtlas({
+                      canvas: GlText.atlasCanvas,
+                      font: atlas2.fontString,
+                      chars: atlas2.chars,
+                      shape: [atlasWidth, atlasHeight],
+                      step: [step, step]
+                    })
+                  });
+                });
+              }
+            }
+            if (o2.align) {
+              this.align = o2.align;
+              this.alignOffset = this.textWidth.map(function(textWidth, i22) {
+                var align = !Array.isArray(this$1$1.align) ? this$1$1.align : this$1$1.align.length > 1 ? this$1$1.align[i22] : this$1$1.align[0];
+                if (typeof align === "number") {
+                  return align;
+                }
+                switch (align) {
+                  case "right":
+                  case "end":
+                    return -textWidth;
+                  case "center":
+                  case "centre":
+                  case "middle":
+                    return -textWidth * 0.5;
+                }
+                return 0;
+              });
+            }
+            if (this.baseline == null && o2.baseline == null) {
+              o2.baseline = 0;
+            }
+            if (o2.baseline != null) {
+              this.baseline = o2.baseline;
+              if (!Array.isArray(this.baseline)) {
+                this.baseline = [this.baseline];
+              }
+              this.baselineOffset = this.baseline.map(function(baseline, i22) {
+                var m2 = (this$1$1.font[i22] || this$1$1.font[0]).metrics;
+                var base = 0;
+                base += m2.bottom * 0.5;
+                if (typeof baseline === "number") {
+                  base += baseline - m2.baseline;
+                } else {
+                  base += -m2[baseline];
+                }
+                base *= -1;
+                return base;
+              });
+            }
+            if (o2.color != null) {
+              if (!o2.color) {
+                o2.color = "transparent";
+              }
+              if (typeof o2.color === "string" || !isNaN(o2.color)) {
+                this.color = rgba3(o2.color, "uint8");
+              } else {
+                var colorData;
+                if (typeof o2.color[0] === "number" && o2.color.length > this.counts.length) {
+                  var l2 = o2.color.length;
+                  colorData = pool.mallocUint8(l2);
+                  var sub2 = (o2.color.subarray || o2.color.slice).bind(o2.color);
+                  for (var i$4 = 0; i$4 < l2; i$4 += 4) {
+                    colorData.set(rgba3(sub2(i$4, i$4 + 4), "uint8"), i$4);
+                  }
+                } else {
+                  var l$12 = o2.color.length;
+                  colorData = pool.mallocUint8(l$12 * 4);
+                  for (var i$5 = 0; i$5 < l$12; i$5++) {
+                    colorData.set(rgba3(o2.color[i$5] || 0, "uint8"), i$5 * 4);
+                  }
+                }
+                this.color = colorData;
+              }
+            }
+            if (o2.position || o2.text || o2.color || o2.baseline || o2.align || o2.font || o2.offset || o2.opacity) {
+              var isBatch = this.color.length > 4 || this.baselineOffset.length > 1 || this.align && this.align.length > 1 || this.fontAtlas.length > 1 || this.positionOffset.length > 2;
+              if (isBatch) {
+                var length2 = Math.max(
+                  this.position.length * 0.5 || 0,
+                  this.color.length * 0.25 || 0,
+                  this.baselineOffset.length || 0,
+                  this.alignOffset.length || 0,
+                  this.font.length || 0,
+                  this.opacity.length || 0,
+                  this.positionOffset.length * 0.5 || 0
+                );
+                this.batch = Array(length2);
+                for (var i$6 = 0; i$6 < this.batch.length; i$6++) {
+                  this.batch[i$6] = {
+                    count: this.counts.length > 1 ? this.counts[i$6] : this.counts[0],
+                    offset: this.textOffsets.length > 1 ? this.textOffsets[i$6] : this.textOffsets[0],
+                    color: !this.color ? [0, 0, 0, 255] : this.color.length <= 4 ? this.color : this.color.subarray(i$6 * 4, i$6 * 4 + 4),
+                    opacity: Array.isArray(this.opacity) ? this.opacity[i$6] : this.opacity,
+                    baseline: this.baselineOffset[i$6] != null ? this.baselineOffset[i$6] : this.baselineOffset[0],
+                    align: !this.align ? 0 : this.alignOffset[i$6] != null ? this.alignOffset[i$6] : this.alignOffset[0],
+                    atlas: this.fontAtlas[i$6] || this.fontAtlas[0],
+                    positionOffset: this.positionOffset.length > 2 ? this.positionOffset.subarray(i$6 * 2, i$6 * 2 + 2) : this.positionOffset
+                  };
+                }
+              } else {
+                if (this.count) {
+                  this.batch = [{
+                    count: this.count,
+                    offset: 0,
+                    color: this.color || [0, 0, 0, 255],
+                    opacity: Array.isArray(this.opacity) ? this.opacity[0] : this.opacity,
+                    baseline: this.baselineOffset[0],
+                    align: this.alignOffset ? this.alignOffset[0] : 0,
+                    atlas: this.fontAtlas[0],
+                    positionOffset: this.positionOffset
+                  }];
+                } else {
+                  this.batch = [];
+                }
+              }
+            }
+          };
+          GlText.prototype.destroy = function destroy() {
+          };
+          GlText.prototype.kerning = true;
+          GlText.prototype.position = { constant: new Float32Array(2) };
+          GlText.prototype.translate = null;
+          GlText.prototype.scale = null;
+          GlText.prototype.font = null;
+          GlText.prototype.text = "";
+          GlText.prototype.positionOffset = [0, 0];
+          GlText.prototype.opacity = 1;
+          GlText.prototype.color = new Uint8Array([0, 0, 0, 255]);
+          GlText.prototype.alignOffset = [0, 0];
+          GlText.maxAtlasSize = 1024;
+          GlText.atlasCanvas = document.createElement("canvas");
+          GlText.atlasContext = GlText.atlasCanvas.getContext("2d", { alpha: false });
+          GlText.baseFontSize = 64;
+          GlText.fonts = {};
+          function isRegl(o2) {
+            return typeof o2 === "function" && o2._gl && o2.prop && o2.texture && o2.buffer;
+          }
+          module2.exports = GlText;
+        }
+      });
+      var require_regl_unchecked2 = __commonJS({
+        "node_modules/@plotly/regl/dist/regl.unchecked.js"(exports, module2) {
+          (function(global2, factory2) {
+            typeof exports === "object" && typeof module2 !== "undefined" ? module2.exports = factory2() : global2.createREGL = factory2();
+          })(exports, function() {
+            var extend2 = function(base, opts) {
+              var keys = Object.keys(opts);
+              for (var i2 = 0; i2 < keys.length; ++i2) {
+                base[keys[i2]] = opts[keys[i2]];
+              }
+              return base;
+            };
+            var VARIABLE_COUNTER = 0;
+            var DYN_FUNC = 0;
+            var DYN_CONSTANT = 5;
+            var DYN_ARRAY = 6;
+            function DynamicVariable(type, data) {
+              this.id = VARIABLE_COUNTER++;
+              this.type = type;
+              this.data = data;
+            }
+            function escapeStr(str) {
+              return str.replace(/\\/g, "\\\\").replace(/"/g, '\\"');
+            }
+            function splitParts(str) {
+              if (str.length === 0) {
+                return [];
+              }
+              var firstChar = str.charAt(0);
+              var lastChar = str.charAt(str.length - 1);
+              if (str.length > 1 && firstChar === lastChar && (firstChar === '"' || firstChar === "'")) {
+                return ['"' + escapeStr(str.substr(1, str.length - 2)) + '"'];
+              }
+              var parts = /\[(false|true|null|\d+|'[^']*'|"[^"]*")\]/.exec(str);
+              if (parts) {
+                return splitParts(str.substr(0, parts.index)).concat(splitParts(parts[1])).concat(splitParts(str.substr(parts.index + parts[0].length)));
+              }
+              var subparts = str.split(".");
+              if (subparts.length === 1) {
+                return ['"' + escapeStr(str) + '"'];
+              }
+              var result = [];
+              for (var i2 = 0; i2 < subparts.length; ++i2) {
+                result = result.concat(splitParts(subparts[i2]));
+              }
+              return result;
+            }
+            function toAccessorString(str) {
+              return "[" + splitParts(str).join("][") + "]";
+            }
+            function defineDynamic(type, data) {
+              return new DynamicVariable(type, toAccessorString(data + ""));
+            }
+            function isDynamic(x2) {
+              return typeof x2 === "function" && !x2._reglType || x2 instanceof DynamicVariable;
+            }
+            function unbox(x2, path) {
+              if (typeof x2 === "function") {
+                return new DynamicVariable(DYN_FUNC, x2);
+              } else if (typeof x2 === "number" || typeof x2 === "boolean") {
+                return new DynamicVariable(DYN_CONSTANT, x2);
+              } else if (Array.isArray(x2)) {
+                return new DynamicVariable(DYN_ARRAY, x2.map(function(y2, i2) {
+                  return unbox(y2);
+                }));
+              } else if (x2 instanceof DynamicVariable) {
+                return x2;
+              }
+            }
+            var dynamic = {
+              DynamicVariable,
+              define: defineDynamic,
+              isDynamic,
+              unbox,
+              accessor: toAccessorString
+            };
+            var raf = {
+              next: typeof requestAnimationFrame === "function" ? function(cb2) {
+                return requestAnimationFrame(cb2);
+              } : function(cb2) {
+                return setTimeout(cb2, 16);
+              },
+              cancel: typeof cancelAnimationFrame === "function" ? function(raf2) {
+                return cancelAnimationFrame(raf2);
+              } : clearTimeout
+            };
+            var clock = typeof performance !== "undefined" && performance.now ? function() {
+              return performance.now();
+            } : function() {
+              return +/* @__PURE__ */ new Date();
+            };
+            function createStringStore() {
+              var stringIds = { "": 0 };
+              var stringValues = [""];
+              return {
+                id: function(str) {
+                  var result = stringIds[str];
+                  if (result) {
+                    return result;
+                  }
+                  result = stringIds[str] = stringValues.length;
+                  stringValues.push(str);
+                  return result;
+                },
+                str: function(id2) {
+                  return stringValues[id2];
+                }
+              };
+            }
+            function createCanvas(element, onDone, pixelRatio) {
+              var canvas2 = document.createElement("canvas");
+              extend2(canvas2.style, {
+                border: 0,
+                margin: 0,
+                padding: 0,
+                top: 0,
+                left: 0,
+                width: "100%",
+                height: "100%"
+              });
+              element.appendChild(canvas2);
+              if (element === document.body) {
+                canvas2.style.position = "absolute";
+                extend2(element.style, {
+                  margin: 0,
+                  padding: 0
+                });
+              }
+              function resize() {
+                var w2 = window.innerWidth;
+                var h2 = window.innerHeight;
+                if (element !== document.body) {
+                  var bounds = canvas2.getBoundingClientRect();
+                  w2 = bounds.right - bounds.left;
+                  h2 = bounds.bottom - bounds.top;
+                }
+                canvas2.width = pixelRatio * w2;
+                canvas2.height = pixelRatio * h2;
+              }
+              var resizeObserver;
+              if (element !== document.body && typeof ResizeObserver === "function") {
+                resizeObserver = new ResizeObserver(function() {
+                  setTimeout(resize);
+                });
+                resizeObserver.observe(element);
+              } else {
+                window.addEventListener("resize", resize, false);
+              }
+              function onDestroy() {
+                if (resizeObserver) {
+                  resizeObserver.disconnect();
+                } else {
+                  window.removeEventListener("resize", resize);
+                }
+                element.removeChild(canvas2);
+              }
+              resize();
+              return {
+                canvas: canvas2,
+                onDestroy
+              };
+            }
+            function createContext(canvas2, contextAttributes) {
+              function get(name2) {
+                try {
+                  return canvas2.getContext(name2, contextAttributes);
+                } catch (e2) {
+                  return null;
+                }
+              }
+              return get("webgl") || get("experimental-webgl") || get("webgl-experimental");
+            }
+            function isHTMLElement(obj) {
+              return typeof obj.nodeName === "string" && typeof obj.appendChild === "function" && typeof obj.getBoundingClientRect === "function";
+            }
+            function isWebGLContext(obj) {
+              return typeof obj.drawArrays === "function" || typeof obj.drawElements === "function";
+            }
+            function parseExtensions(input) {
+              if (typeof input === "string") {
+                return input.split();
+              }
+              return input;
+            }
+            function getElement(desc) {
+              if (typeof desc === "string") {
+                return document.querySelector(desc);
+              }
+              return desc;
+            }
+            function parseArgs(args_) {
+              var args = args_ || {};
+              var element, container, canvas2, gl2;
+              var contextAttributes = {};
+              var extensions = [];
+              var optionalExtensions = [];
+              var pixelRatio = typeof window === "undefined" ? 1 : window.devicePixelRatio;
+              var profile = false;
+              var cachedCode = {};
+              var onDone = function(err) {
+              };
+              var onDestroy = function() {
+              };
+              if (typeof args === "string") {
+                element = document.querySelector(args);
+              } else if (typeof args === "object") {
+                if (isHTMLElement(args)) {
+                  element = args;
+                } else if (isWebGLContext(args)) {
+                  gl2 = args;
+                  canvas2 = gl2.canvas;
+                } else {
+                  if ("gl" in args) {
+                    gl2 = args.gl;
+                  } else if ("canvas" in args) {
+                    canvas2 = getElement(args.canvas);
+                  } else if ("container" in args) {
+                    container = getElement(args.container);
+                  }
+                  if ("attributes" in args) {
+                    contextAttributes = args.attributes;
+                  }
+                  if ("extensions" in args) {
+                    extensions = parseExtensions(args.extensions);
+                  }
+                  if ("optionalExtensions" in args) {
+                    optionalExtensions = parseExtensions(args.optionalExtensions);
+                  }
+                  if ("onDone" in args) {
+                    onDone = args.onDone;
+                  }
+                  if ("profile" in args) {
+                    profile = !!args.profile;
+                  }
+                  if ("pixelRatio" in args) {
+                    pixelRatio = +args.pixelRatio;
+                  }
+                  if ("cachedCode" in args) {
+                    cachedCode = args.cachedCode;
+                  }
+                }
+              } else ;
+              if (element) {
+                if (element.nodeName.toLowerCase() === "canvas") {
+                  canvas2 = element;
+                } else {
+                  container = element;
+                }
+              }
+              if (!gl2) {
+                if (!canvas2) {
+                  var result = createCanvas(container || document.body, onDone, pixelRatio);
+                  if (!result) {
+                    return null;
+                  }
+                  canvas2 = result.canvas;
+                  onDestroy = result.onDestroy;
+                }
+                if (contextAttributes.premultipliedAlpha === void 0) contextAttributes.premultipliedAlpha = true;
+                gl2 = createContext(canvas2, contextAttributes);
+              }
+              if (!gl2) {
+                onDestroy();
+                onDone("webgl not supported, try upgrading your browser or graphics drivers http://get.webgl.org");
+                return null;
+              }
+              return {
+                gl: gl2,
+                canvas: canvas2,
+                container,
+                extensions,
+                optionalExtensions,
+                pixelRatio,
+                profile,
+                cachedCode,
+                onDone,
+                onDestroy
+              };
+            }
+            function createExtensionCache(gl2, config2) {
+              var extensions = {};
+              function tryLoadExtension(name_) {
+                var name3 = name_.toLowerCase();
+                var ext;
+                try {
+                  ext = extensions[name3] = gl2.getExtension(name3);
+                } catch (e2) {
+                }
+                return !!ext;
+              }
+              for (var i2 = 0; i2 < config2.extensions.length; ++i2) {
+                var name2 = config2.extensions[i2];
+                if (!tryLoadExtension(name2)) {
+                  config2.onDestroy();
+                  config2.onDone('"' + name2 + '" extension is not supported by the current WebGL context, try upgrading your system or a different browser');
+                  return null;
+                }
+              }
+              config2.optionalExtensions.forEach(tryLoadExtension);
+              return {
+                extensions,
+                restore: function() {
+                  Object.keys(extensions).forEach(function(name3) {
+                    if (extensions[name3] && !tryLoadExtension(name3)) {
+                      throw new Error("(regl): error restoring extension " + name3);
+                    }
+                  });
+                }
+              };
+            }
+            function loop(n2, f2) {
+              var result = Array(n2);
+              for (var i2 = 0; i2 < n2; ++i2) {
+                result[i2] = f2(i2);
+              }
+              return result;
+            }
+            var GL_BYTE = 5120;
+            var GL_UNSIGNED_BYTE$1 = 5121;
+            var GL_SHORT = 5122;
+            var GL_UNSIGNED_SHORT = 5123;
+            var GL_INT = 5124;
+            var GL_UNSIGNED_INT = 5125;
+            var GL_FLOAT$1 = 5126;
+            function nextPow16(v2) {
+              for (var i2 = 16; i2 <= 1 << 28; i2 *= 16) {
+                if (v2 <= i2) {
+                  return i2;
+                }
+              }
+              return 0;
+            }
+            function log22(v2) {
+              var r2, shift;
+              r2 = (v2 > 65535) << 4;
+              v2 >>>= r2;
+              shift = (v2 > 255) << 3;
+              v2 >>>= shift;
+              r2 |= shift;
+              shift = (v2 > 15) << 2;
+              v2 >>>= shift;
+              r2 |= shift;
+              shift = (v2 > 3) << 1;
+              v2 >>>= shift;
+              r2 |= shift;
+              return r2 | v2 >> 1;
+            }
+            function createPool() {
+              var bufferPool = loop(8, function() {
+                return [];
+              });
+              function alloc(n2) {
+                var sz = nextPow16(n2);
+                var bin = bufferPool[log22(sz) >> 2];
+                if (bin.length > 0) {
+                  return bin.pop();
+                }
+                return new ArrayBuffer(sz);
+              }
+              function free(buf) {
+                bufferPool[log22(buf.byteLength) >> 2].push(buf);
+              }
+              function allocType(type, n2) {
+                var result = null;
+                switch (type) {
+                  case GL_BYTE:
+                    result = new Int8Array(alloc(n2), 0, n2);
+                    break;
+                  case GL_UNSIGNED_BYTE$1:
+                    result = new Uint8Array(alloc(n2), 0, n2);
+                    break;
+                  case GL_SHORT:
+                    result = new Int16Array(alloc(2 * n2), 0, n2);
+                    break;
+                  case GL_UNSIGNED_SHORT:
+                    result = new Uint16Array(alloc(2 * n2), 0, n2);
+                    break;
+                  case GL_INT:
+                    result = new Int32Array(alloc(4 * n2), 0, n2);
+                    break;
+                  case GL_UNSIGNED_INT:
+                    result = new Uint32Array(alloc(4 * n2), 0, n2);
+                    break;
+                  case GL_FLOAT$1:
+                    result = new Float32Array(alloc(4 * n2), 0, n2);
+                    break;
+                  default:
+                    return null;
+                }
+                if (result.length !== n2) {
+                  return result.subarray(0, n2);
+                }
+                return result;
+              }
+              function freeType(array) {
+                free(array.buffer);
+              }
+              return {
+                alloc,
+                free,
+                allocType,
+                freeType
+              };
+            }
+            var pool = createPool();
+            pool.zero = createPool();
+            var GL_SUBPIXEL_BITS = 3408;
+            var GL_RED_BITS = 3410;
+            var GL_GREEN_BITS = 3411;
+            var GL_BLUE_BITS = 3412;
+            var GL_ALPHA_BITS = 3413;
+            var GL_DEPTH_BITS = 3414;
+            var GL_STENCIL_BITS = 3415;
+            var GL_ALIASED_POINT_SIZE_RANGE = 33901;
+            var GL_ALIASED_LINE_WIDTH_RANGE = 33902;
+            var GL_MAX_TEXTURE_SIZE = 3379;
+            var GL_MAX_VIEWPORT_DIMS = 3386;
+            var GL_MAX_VERTEX_ATTRIBS = 34921;
+            var GL_MAX_VERTEX_UNIFORM_VECTORS = 36347;
+            var GL_MAX_VARYING_VECTORS = 36348;
+            var GL_MAX_COMBINED_TEXTURE_IMAGE_UNITS = 35661;
+            var GL_MAX_VERTEX_TEXTURE_IMAGE_UNITS = 35660;
+            var GL_MAX_TEXTURE_IMAGE_UNITS = 34930;
+            var GL_MAX_FRAGMENT_UNIFORM_VECTORS = 36349;
+            var GL_MAX_CUBE_MAP_TEXTURE_SIZE = 34076;
+            var GL_MAX_RENDERBUFFER_SIZE = 34024;
+            var GL_VENDOR = 7936;
+            var GL_RENDERER = 7937;
+            var GL_VERSION = 7938;
+            var GL_SHADING_LANGUAGE_VERSION = 35724;
+            var GL_MAX_TEXTURE_MAX_ANISOTROPY_EXT = 34047;
+            var GL_MAX_COLOR_ATTACHMENTS_WEBGL = 36063;
+            var GL_MAX_DRAW_BUFFERS_WEBGL = 34852;
+            var GL_TEXTURE_2D = 3553;
+            var GL_TEXTURE_CUBE_MAP = 34067;
+            var GL_TEXTURE_CUBE_MAP_POSITIVE_X = 34069;
+            var GL_TEXTURE0 = 33984;
+            var GL_RGBA = 6408;
+            var GL_FLOAT = 5126;
+            var GL_UNSIGNED_BYTE = 5121;
+            var GL_FRAMEBUFFER = 36160;
+            var GL_FRAMEBUFFER_COMPLETE = 36053;
+            var GL_COLOR_ATTACHMENT0 = 36064;
+            var GL_COLOR_BUFFER_BIT$1 = 16384;
+            var wrapLimits = function(gl2, extensions) {
+              var maxAnisotropic = 1;
+              if (extensions.ext_texture_filter_anisotropic) {
+                maxAnisotropic = gl2.getParameter(GL_MAX_TEXTURE_MAX_ANISOTROPY_EXT);
+              }
+              var maxDrawbuffers = 1;
+              var maxColorAttachments = 1;
+              if (extensions.webgl_draw_buffers) {
+                maxDrawbuffers = gl2.getParameter(GL_MAX_DRAW_BUFFERS_WEBGL);
+                maxColorAttachments = gl2.getParameter(GL_MAX_COLOR_ATTACHMENTS_WEBGL);
+              }
+              var readFloat = !!extensions.oes_texture_float;
+              if (readFloat) {
+                var readFloatTexture = gl2.createTexture();
+                gl2.bindTexture(GL_TEXTURE_2D, readFloatTexture);
+                gl2.texImage2D(GL_TEXTURE_2D, 0, GL_RGBA, 1, 1, 0, GL_RGBA, GL_FLOAT, null);
+                var fbo = gl2.createFramebuffer();
+                gl2.bindFramebuffer(GL_FRAMEBUFFER, fbo);
+                gl2.framebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, readFloatTexture, 0);
+                gl2.bindTexture(GL_TEXTURE_2D, null);
+                if (gl2.checkFramebufferStatus(GL_FRAMEBUFFER) !== GL_FRAMEBUFFER_COMPLETE) readFloat = false;
+                else {
+                  gl2.viewport(0, 0, 1, 1);
+                  gl2.clearColor(1, 0, 0, 1);
+                  gl2.clear(GL_COLOR_BUFFER_BIT$1);
+                  var pixels = pool.allocType(GL_FLOAT, 4);
+                  gl2.readPixels(0, 0, 1, 1, GL_RGBA, GL_FLOAT, pixels);
+                  if (gl2.getError()) readFloat = false;
+                  else {
+                    gl2.deleteFramebuffer(fbo);
+                    gl2.deleteTexture(readFloatTexture);
+                    readFloat = pixels[0] === 1;
+                  }
+                  pool.freeType(pixels);
+                }
+              }
+              var isIE = typeof navigator !== "undefined" && (/MSIE/.test(navigator.userAgent) || /Trident\//.test(navigator.appVersion) || /Edge/.test(navigator.userAgent));
+              var npotTextureCube = true;
+              if (!isIE) {
+                var cubeTexture = gl2.createTexture();
+                var data = pool.allocType(GL_UNSIGNED_BYTE, 36);
+                gl2.activeTexture(GL_TEXTURE0);
+                gl2.bindTexture(GL_TEXTURE_CUBE_MAP, cubeTexture);
+                gl2.texImage2D(GL_TEXTURE_CUBE_MAP_POSITIVE_X, 0, GL_RGBA, 3, 3, 0, GL_RGBA, GL_UNSIGNED_BYTE, data);
+                pool.freeType(data);
+                gl2.bindTexture(GL_TEXTURE_CUBE_MAP, null);
+                gl2.deleteTexture(cubeTexture);
+                npotTextureCube = !gl2.getError();
+              }
+              return {
+                // drawing buffer bit depth
+                colorBits: [
+                  gl2.getParameter(GL_RED_BITS),
+                  gl2.getParameter(GL_GREEN_BITS),
+                  gl2.getParameter(GL_BLUE_BITS),
+                  gl2.getParameter(GL_ALPHA_BITS)
+                ],
+                depthBits: gl2.getParameter(GL_DEPTH_BITS),
+                stencilBits: gl2.getParameter(GL_STENCIL_BITS),
+                subpixelBits: gl2.getParameter(GL_SUBPIXEL_BITS),
+                // supported extensions
+                extensions: Object.keys(extensions).filter(function(ext) {
+                  return !!extensions[ext];
+                }),
+                // max aniso samples
+                maxAnisotropic,
+                // max draw buffers
+                maxDrawbuffers,
+                maxColorAttachments,
+                // point and line size ranges
+                pointSizeDims: gl2.getParameter(GL_ALIASED_POINT_SIZE_RANGE),
+                lineWidthDims: gl2.getParameter(GL_ALIASED_LINE_WIDTH_RANGE),
+                maxViewportDims: gl2.getParameter(GL_MAX_VIEWPORT_DIMS),
+                maxCombinedTextureUnits: gl2.getParameter(GL_MAX_COMBINED_TEXTURE_IMAGE_UNITS),
+                maxCubeMapSize: gl2.getParameter(GL_MAX_CUBE_MAP_TEXTURE_SIZE),
+                maxRenderbufferSize: gl2.getParameter(GL_MAX_RENDERBUFFER_SIZE),
+                maxTextureUnits: gl2.getParameter(GL_MAX_TEXTURE_IMAGE_UNITS),
+                maxTextureSize: gl2.getParameter(GL_MAX_TEXTURE_SIZE),
+                maxAttributes: gl2.getParameter(GL_MAX_VERTEX_ATTRIBS),
+                maxVertexUniforms: gl2.getParameter(GL_MAX_VERTEX_UNIFORM_VECTORS),
+                maxVertexTextureUnits: gl2.getParameter(GL_MAX_VERTEX_TEXTURE_IMAGE_UNITS),
+                maxVaryingVectors: gl2.getParameter(GL_MAX_VARYING_VECTORS),
+                maxFragmentUniforms: gl2.getParameter(GL_MAX_FRAGMENT_UNIFORM_VECTORS),
+                // vendor info
+                glsl: gl2.getParameter(GL_SHADING_LANGUAGE_VERSION),
+                renderer: gl2.getParameter(GL_RENDERER),
+                vendor: gl2.getParameter(GL_VENDOR),
+                version: gl2.getParameter(GL_VERSION),
+                // quirks
+                readFloat,
+                npotTextureCube
+              };
+            };
+            var isTypedArray2 = function(x2) {
+              return x2 instanceof Uint8Array || x2 instanceof Uint16Array || x2 instanceof Uint32Array || x2 instanceof Int8Array || x2 instanceof Int16Array || x2 instanceof Int32Array || x2 instanceof Float32Array || x2 instanceof Float64Array || x2 instanceof Uint8ClampedArray;
+            };
+            function isNDArrayLike(obj) {
+              return !!obj && typeof obj === "object" && Array.isArray(obj.shape) && Array.isArray(obj.stride) && typeof obj.offset === "number" && obj.shape.length === obj.stride.length && (Array.isArray(obj.data) || isTypedArray2(obj.data));
+            }
+            var values = function(obj) {
+              return Object.keys(obj).map(function(key) {
+                return obj[key];
+              });
+            };
+            var flattenUtils = {
+              shape: arrayShape$1,
+              flatten: flattenArray2
+            };
+            function flatten1D(array, nx, out) {
+              for (var i2 = 0; i2 < nx; ++i2) {
+                out[i2] = array[i2];
+              }
+            }
+            function flatten2D(array, nx, ny, out) {
+              var ptr = 0;
+              for (var i2 = 0; i2 < nx; ++i2) {
+                var row = array[i2];
+                for (var j2 = 0; j2 < ny; ++j2) {
+                  out[ptr++] = row[j2];
+                }
+              }
+            }
+            function flatten3D(array, nx, ny, nz, out, ptr_) {
+              var ptr = ptr_;
+              for (var i2 = 0; i2 < nx; ++i2) {
+                var row = array[i2];
+                for (var j2 = 0; j2 < ny; ++j2) {
+                  var col = row[j2];
+                  for (var k2 = 0; k2 < nz; ++k2) {
+                    out[ptr++] = col[k2];
+                  }
+                }
+              }
+            }
+            function flattenRec(array, shape, level, out, ptr) {
+              var stride = 1;
+              for (var i2 = level + 1; i2 < shape.length; ++i2) {
+                stride *= shape[i2];
+              }
+              var n2 = shape[level];
+              if (shape.length - level === 4) {
+                var nx = shape[level + 1];
+                var ny = shape[level + 2];
+                var nz = shape[level + 3];
+                for (i2 = 0; i2 < n2; ++i2) {
+                  flatten3D(array[i2], nx, ny, nz, out, ptr);
+                  ptr += stride;
+                }
+              } else {
+                for (i2 = 0; i2 < n2; ++i2) {
+                  flattenRec(array[i2], shape, level + 1, out, ptr);
+                  ptr += stride;
+                }
+              }
+            }
+            function flattenArray2(array, shape, type, out_) {
+              var sz = 1;
+              if (shape.length) {
+                for (var i2 = 0; i2 < shape.length; ++i2) {
+                  sz *= shape[i2];
+                }
+              } else {
+                sz = 0;
+              }
+              var out = out_ || pool.allocType(type, sz);
+              switch (shape.length) {
+                case 0:
+                  break;
+                case 1:
+                  flatten1D(array, shape[0], out);
+                  break;
+                case 2:
+                  flatten2D(array, shape[0], shape[1], out);
+                  break;
+                case 3:
+                  flatten3D(array, shape[0], shape[1], shape[2], out, 0);
+                  break;
+                default:
+                  flattenRec(array, shape, 0, out, 0);
+              }
+              return out;
+            }
+            function arrayShape$1(array_) {
+              var shape = [];
+              for (var array = array_; array.length; array = array[0]) {
+                shape.push(array.length);
+              }
+              return shape;
+            }
+            var arrayTypes = {
+              "[object Int8Array]": 5120,
+              "[object Int16Array]": 5122,
+              "[object Int32Array]": 5124,
+              "[object Uint8Array]": 5121,
+              "[object Uint8ClampedArray]": 5121,
+              "[object Uint16Array]": 5123,
+              "[object Uint32Array]": 5125,
+              "[object Float32Array]": 5126,
+              "[object Float64Array]": 5121,
+              "[object ArrayBuffer]": 5121
+            };
+            var int8 = 5120;
+            var int16 = 5122;
+            var int322 = 5124;
+            var uint8 = 5121;
+            var uint16 = 5123;
+            var uint32 = 5125;
+            var float = 5126;
+            var float322 = 5126;
+            var glTypes = {
+              int8,
+              int16,
+              int32: int322,
+              uint8,
+              uint16,
+              uint32,
+              float,
+              float32: float322
+            };
+            var dynamic$1 = 35048;
+            var stream = 35040;
+            var usageTypes = {
+              dynamic: dynamic$1,
+              stream,
+              "static": 35044
+            };
+            var arrayFlatten = flattenUtils.flatten;
+            var arrayShape = flattenUtils.shape;
+            var GL_STATIC_DRAW = 35044;
+            var GL_STREAM_DRAW = 35040;
+            var GL_UNSIGNED_BYTE$2 = 5121;
+            var GL_FLOAT$2 = 5126;
+            var DTYPES_SIZES = [];
+            DTYPES_SIZES[5120] = 1;
+            DTYPES_SIZES[5122] = 2;
+            DTYPES_SIZES[5124] = 4;
+            DTYPES_SIZES[5121] = 1;
+            DTYPES_SIZES[5123] = 2;
+            DTYPES_SIZES[5125] = 4;
+            DTYPES_SIZES[5126] = 4;
+            function typedArrayCode(data) {
+              return arrayTypes[Object.prototype.toString.call(data)] | 0;
+            }
+            function copyArray(out, inp) {
+              for (var i2 = 0; i2 < inp.length; ++i2) {
+                out[i2] = inp[i2];
+              }
+            }
+            function transpose2(result, data, shapeX, shapeY, strideX, strideY, offset) {
+              var ptr = 0;
+              for (var i2 = 0; i2 < shapeX; ++i2) {
+                for (var j2 = 0; j2 < shapeY; ++j2) {
+                  result[ptr++] = data[strideX * i2 + strideY * j2 + offset];
+                }
+              }
+            }
+            function wrapBufferState(gl2, stats2, config2, destroyBuffer) {
+              var bufferCount = 0;
+              var bufferSet = {};
+              function REGLBuffer(type) {
+                this.id = bufferCount++;
+                this.buffer = gl2.createBuffer();
+                this.type = type;
+                this.usage = GL_STATIC_DRAW;
+                this.byteLength = 0;
+                this.dimension = 1;
+                this.dtype = GL_UNSIGNED_BYTE$2;
+                this.persistentData = null;
+                if (config2.profile) {
+                  this.stats = { size: 0 };
+                }
+              }
+              REGLBuffer.prototype.bind = function() {
+                gl2.bindBuffer(this.type, this.buffer);
+              };
+              REGLBuffer.prototype.destroy = function() {
+                destroy(this);
+              };
+              var streamPool = [];
+              function createStream(type, data) {
+                var buffer = streamPool.pop();
+                if (!buffer) {
+                  buffer = new REGLBuffer(type);
+                }
+                buffer.bind();
+                initBufferFromData(buffer, data, GL_STREAM_DRAW, 0, 1, false);
+                return buffer;
+              }
+              function destroyStream(stream$$1) {
+                streamPool.push(stream$$1);
+              }
+              function initBufferFromTypedArray(buffer, data, usage) {
+                buffer.byteLength = data.byteLength;
+                gl2.bufferData(buffer.type, data, usage);
+              }
+              function initBufferFromData(buffer, data, usage, dtype, dimension, persist) {
+                var shape;
+                buffer.usage = usage;
+                if (Array.isArray(data)) {
+                  buffer.dtype = dtype || GL_FLOAT$2;
+                  if (data.length > 0) {
+                    var flatData;
+                    if (Array.isArray(data[0])) {
+                      shape = arrayShape(data);
+                      var dim = 1;
+                      for (var i2 = 1; i2 < shape.length; ++i2) {
+                        dim *= shape[i2];
+                      }
+                      buffer.dimension = dim;
+                      flatData = arrayFlatten(data, shape, buffer.dtype);
+                      initBufferFromTypedArray(buffer, flatData, usage);
+                      if (persist) {
+                        buffer.persistentData = flatData;
+                      } else {
+                        pool.freeType(flatData);
+                      }
+                    } else if (typeof data[0] === "number") {
+                      buffer.dimension = dimension;
+                      var typedData = pool.allocType(buffer.dtype, data.length);
+                      copyArray(typedData, data);
+                      initBufferFromTypedArray(buffer, typedData, usage);
+                      if (persist) {
+                        buffer.persistentData = typedData;
+                      } else {
+                        pool.freeType(typedData);
+                      }
+                    } else if (isTypedArray2(data[0])) {
+                      buffer.dimension = data[0].length;
+                      buffer.dtype = dtype || typedArrayCode(data[0]) || GL_FLOAT$2;
+                      flatData = arrayFlatten(
+                        data,
+                        [data.length, data[0].length],
+                        buffer.dtype
+                      );
+                      initBufferFromTypedArray(buffer, flatData, usage);
+                      if (persist) {
+                        buffer.persistentData = flatData;
+                      } else {
+                        pool.freeType(flatData);
+                      }
+                    } else ;
+                  }
+                } else if (isTypedArray2(data)) {
+                  buffer.dtype = dtype || typedArrayCode(data);
+                  buffer.dimension = dimension;
+                  initBufferFromTypedArray(buffer, data, usage);
+                  if (persist) {
+                    buffer.persistentData = new Uint8Array(new Uint8Array(data.buffer));
+                  }
+                } else if (isNDArrayLike(data)) {
+                  shape = data.shape;
+                  var stride = data.stride;
+                  var offset = data.offset;
+                  var shapeX = 0;
+                  var shapeY = 0;
+                  var strideX = 0;
+                  var strideY = 0;
+                  if (shape.length === 1) {
+                    shapeX = shape[0];
+                    shapeY = 1;
+                    strideX = stride[0];
+                    strideY = 0;
+                  } else if (shape.length === 2) {
+                    shapeX = shape[0];
+                    shapeY = shape[1];
+                    strideX = stride[0];
+                    strideY = stride[1];
+                  } else ;
+                  buffer.dtype = dtype || typedArrayCode(data.data) || GL_FLOAT$2;
+                  buffer.dimension = shapeY;
+                  var transposeData2 = pool.allocType(buffer.dtype, shapeX * shapeY);
+                  transpose2(
+                    transposeData2,
+                    data.data,
+                    shapeX,
+                    shapeY,
+                    strideX,
+                    strideY,
+                    offset
+                  );
+                  initBufferFromTypedArray(buffer, transposeData2, usage);
+                  if (persist) {
+                    buffer.persistentData = transposeData2;
+                  } else {
+                    pool.freeType(transposeData2);
+                  }
+                } else if (data instanceof ArrayBuffer) {
+                  buffer.dtype = GL_UNSIGNED_BYTE$2;
+                  buffer.dimension = dimension;
+                  initBufferFromTypedArray(buffer, data, usage);
+                  if (persist) {
+                    buffer.persistentData = new Uint8Array(new Uint8Array(data));
+                  }
+                } else ;
+              }
+              function destroy(buffer) {
+                stats2.bufferCount--;
+                destroyBuffer(buffer);
+                var handle = buffer.buffer;
+                gl2.deleteBuffer(handle);
+                buffer.buffer = null;
+                delete bufferSet[buffer.id];
+              }
+              function createBuffer(options, type, deferInit, persistent) {
+                stats2.bufferCount++;
+                var buffer = new REGLBuffer(type);
+                bufferSet[buffer.id] = buffer;
+                function reglBuffer(options2) {
+                  var usage = GL_STATIC_DRAW;
+                  var data = null;
+                  var byteLength = 0;
+                  var dtype = 0;
+                  var dimension = 1;
+                  if (Array.isArray(options2) || isTypedArray2(options2) || isNDArrayLike(options2) || options2 instanceof ArrayBuffer) {
+                    data = options2;
+                  } else if (typeof options2 === "number") {
+                    byteLength = options2 | 0;
+                  } else if (options2) {
+                    if ("data" in options2) {
+                      data = options2.data;
+                    }
+                    if ("usage" in options2) {
+                      usage = usageTypes[options2.usage];
+                    }
+                    if ("type" in options2) {
+                      dtype = glTypes[options2.type];
+                    }
+                    if ("dimension" in options2) {
+                      dimension = options2.dimension | 0;
+                    }
+                    if ("length" in options2) {
+                      byteLength = options2.length | 0;
+                    }
+                  }
+                  buffer.bind();
+                  if (!data) {
+                    if (byteLength) gl2.bufferData(buffer.type, byteLength, usage);
+                    buffer.dtype = dtype || GL_UNSIGNED_BYTE$2;
+                    buffer.usage = usage;
+                    buffer.dimension = dimension;
+                    buffer.byteLength = byteLength;
+                  } else {
+                    initBufferFromData(buffer, data, usage, dtype, dimension, persistent);
+                  }
+                  if (config2.profile) {
+                    buffer.stats.size = buffer.byteLength * DTYPES_SIZES[buffer.dtype];
+                  }
+                  return reglBuffer;
+                }
+                function setSubData(data, offset) {
+                  gl2.bufferSubData(buffer.type, offset, data);
+                }
+                function subdata(data, offset_) {
+                  var offset = (offset_ || 0) | 0;
+                  var shape;
+                  buffer.bind();
+                  if (isTypedArray2(data) || data instanceof ArrayBuffer) {
+                    setSubData(data, offset);
+                  } else if (Array.isArray(data)) {
+                    if (data.length > 0) {
+                      if (typeof data[0] === "number") {
+                        var converted = pool.allocType(buffer.dtype, data.length);
+                        copyArray(converted, data);
+                        setSubData(converted, offset);
+                        pool.freeType(converted);
+                      } else if (Array.isArray(data[0]) || isTypedArray2(data[0])) {
+                        shape = arrayShape(data);
+                        var flatData = arrayFlatten(data, shape, buffer.dtype);
+                        setSubData(flatData, offset);
+                        pool.freeType(flatData);
+                      } else ;
+                    }
+                  } else if (isNDArrayLike(data)) {
+                    shape = data.shape;
+                    var stride = data.stride;
+                    var shapeX = 0;
+                    var shapeY = 0;
+                    var strideX = 0;
+                    var strideY = 0;
+                    if (shape.length === 1) {
+                      shapeX = shape[0];
+                      shapeY = 1;
+                      strideX = stride[0];
+                      strideY = 0;
+                    } else if (shape.length === 2) {
+                      shapeX = shape[0];
+                      shapeY = shape[1];
+                      strideX = stride[0];
+                      strideY = stride[1];
+                    } else ;
+                    var dtype = Array.isArray(data.data) ? buffer.dtype : typedArrayCode(data.data);
+                    var transposeData2 = pool.allocType(dtype, shapeX * shapeY);
+                    transpose2(
+                      transposeData2,
+                      data.data,
+                      shapeX,
+                      shapeY,
+                      strideX,
+                      strideY,
+                      data.offset
+                    );
+                    setSubData(transposeData2, offset);
+                    pool.freeType(transposeData2);
+                  } else ;
+                  return reglBuffer;
+                }
+                if (!deferInit) {
+                  reglBuffer(options);
+                }
+                reglBuffer._reglType = "buffer";
+                reglBuffer._buffer = buffer;
+                reglBuffer.subdata = subdata;
+                if (config2.profile) {
+                  reglBuffer.stats = buffer.stats;
+                }
+                reglBuffer.destroy = function() {
+                  destroy(buffer);
+                };
+                return reglBuffer;
+              }
+              function restoreBuffers() {
+                values(bufferSet).forEach(function(buffer) {
+                  buffer.buffer = gl2.createBuffer();
+                  gl2.bindBuffer(buffer.type, buffer.buffer);
+                  gl2.bufferData(
+                    buffer.type,
+                    buffer.persistentData || buffer.byteLength,
+                    buffer.usage
+                  );
+                });
+              }
+              if (config2.profile) {
+                stats2.getTotalBufferSize = function() {
+                  var total = 0;
+                  Object.keys(bufferSet).forEach(function(key) {
+                    total += bufferSet[key].stats.size;
+                  });
+                  return total;
+                };
+              }
+              return {
+                create: createBuffer,
+                createStream,
+                destroyStream,
+                clear: function() {
+                  values(bufferSet).forEach(destroy);
+                  streamPool.forEach(destroy);
+                },
+                getBuffer: function(wrapper) {
+                  if (wrapper && wrapper._buffer instanceof REGLBuffer) {
+                    return wrapper._buffer;
+                  }
+                  return null;
+                },
+                restore: restoreBuffers,
+                _initBuffer: initBufferFromData
+              };
+            }
+            var points = 0;
+            var point = 0;
+            var lines = 1;
+            var line = 1;
+            var triangles = 4;
+            var triangle = 4;
+            var primTypes = {
+              points,
+              point,
+              lines,
+              line,
+              triangles,
+              triangle,
+              "line loop": 2,
+              "line strip": 3,
+              "triangle strip": 5,
+              "triangle fan": 6
+            };
+            var GL_POINTS = 0;
+            var GL_LINES = 1;
+            var GL_TRIANGLES = 4;
+            var GL_BYTE$1 = 5120;
+            var GL_UNSIGNED_BYTE$3 = 5121;
+            var GL_SHORT$1 = 5122;
+            var GL_UNSIGNED_SHORT$1 = 5123;
+            var GL_INT$1 = 5124;
+            var GL_UNSIGNED_INT$1 = 5125;
+            var GL_ELEMENT_ARRAY_BUFFER = 34963;
+            var GL_STREAM_DRAW$1 = 35040;
+            var GL_STATIC_DRAW$1 = 35044;
+            function wrapElementsState(gl2, extensions, bufferState, stats2) {
+              var elementSet = {};
+              var elementCount = 0;
+              var elementTypes = {
+                "uint8": GL_UNSIGNED_BYTE$3,
+                "uint16": GL_UNSIGNED_SHORT$1
+              };
+              if (extensions.oes_element_index_uint) {
+                elementTypes.uint32 = GL_UNSIGNED_INT$1;
+              }
+              function REGLElementBuffer(buffer) {
+                this.id = elementCount++;
+                elementSet[this.id] = this;
+                this.buffer = buffer;
+                this.primType = GL_TRIANGLES;
+                this.vertCount = 0;
+                this.type = 0;
+              }
+              REGLElementBuffer.prototype.bind = function() {
+                this.buffer.bind();
+              };
+              var bufferPool = [];
+              function createElementStream(data) {
+                var result = bufferPool.pop();
+                if (!result) {
+                  result = new REGLElementBuffer(bufferState.create(
+                    null,
+                    GL_ELEMENT_ARRAY_BUFFER,
+                    true,
+                    false
+                  )._buffer);
+                }
+                initElements(result, data, GL_STREAM_DRAW$1, -1, -1, 0, 0);
+                return result;
+              }
+              function destroyElementStream(elements) {
+                bufferPool.push(elements);
+              }
+              function initElements(elements, data, usage, prim, count2, byteLength, type) {
+                elements.buffer.bind();
+                var dtype;
+                if (data) {
+                  var predictedType = type;
+                  if (!type && (!isTypedArray2(data) || isNDArrayLike(data) && !isTypedArray2(data.data))) {
+                    predictedType = extensions.oes_element_index_uint ? GL_UNSIGNED_INT$1 : GL_UNSIGNED_SHORT$1;
+                  }
+                  bufferState._initBuffer(
+                    elements.buffer,
+                    data,
+                    usage,
+                    predictedType,
+                    3
+                  );
+                } else {
+                  gl2.bufferData(GL_ELEMENT_ARRAY_BUFFER, byteLength, usage);
+                  elements.buffer.dtype = dtype || GL_UNSIGNED_BYTE$3;
+                  elements.buffer.usage = usage;
+                  elements.buffer.dimension = 3;
+                  elements.buffer.byteLength = byteLength;
+                }
+                dtype = type;
+                if (!type) {
+                  switch (elements.buffer.dtype) {
+                    case GL_UNSIGNED_BYTE$3:
+                    case GL_BYTE$1:
+                      dtype = GL_UNSIGNED_BYTE$3;
+                      break;
+                    case GL_UNSIGNED_SHORT$1:
+                    case GL_SHORT$1:
+                      dtype = GL_UNSIGNED_SHORT$1;
+                      break;
+                    case GL_UNSIGNED_INT$1:
+                    case GL_INT$1:
+                      dtype = GL_UNSIGNED_INT$1;
+                      break;
+                  }
+                  elements.buffer.dtype = dtype;
+                }
+                elements.type = dtype;
+                var vertCount = count2;
+                if (vertCount < 0) {
+                  vertCount = elements.buffer.byteLength;
+                  if (dtype === GL_UNSIGNED_SHORT$1) {
+                    vertCount >>= 1;
+                  } else if (dtype === GL_UNSIGNED_INT$1) {
+                    vertCount >>= 2;
+                  }
+                }
+                elements.vertCount = vertCount;
+                var primType = prim;
+                if (prim < 0) {
+                  primType = GL_TRIANGLES;
+                  var dimension = elements.buffer.dimension;
+                  if (dimension === 1) primType = GL_POINTS;
+                  if (dimension === 2) primType = GL_LINES;
+                  if (dimension === 3) primType = GL_TRIANGLES;
+                }
+                elements.primType = primType;
+              }
+              function destroyElements(elements) {
+                stats2.elementsCount--;
+                delete elementSet[elements.id];
+                elements.buffer.destroy();
+                elements.buffer = null;
+              }
+              function createElements(options, persistent) {
+                var buffer = bufferState.create(null, GL_ELEMENT_ARRAY_BUFFER, true);
+                var elements = new REGLElementBuffer(buffer._buffer);
+                stats2.elementsCount++;
+                function reglElements(options2) {
+                  if (!options2) {
+                    buffer();
+                    elements.primType = GL_TRIANGLES;
+                    elements.vertCount = 0;
+                    elements.type = GL_UNSIGNED_BYTE$3;
+                  } else if (typeof options2 === "number") {
+                    buffer(options2);
+                    elements.primType = GL_TRIANGLES;
+                    elements.vertCount = options2 | 0;
+                    elements.type = GL_UNSIGNED_BYTE$3;
+                  } else {
+                    var data = null;
+                    var usage = GL_STATIC_DRAW$1;
+                    var primType = -1;
+                    var vertCount = -1;
+                    var byteLength = 0;
+                    var dtype = 0;
+                    if (Array.isArray(options2) || isTypedArray2(options2) || isNDArrayLike(options2)) {
+                      data = options2;
+                    } else {
+                      if ("data" in options2) {
+                        data = options2.data;
+                      }
+                      if ("usage" in options2) {
+                        usage = usageTypes[options2.usage];
+                      }
+                      if ("primitive" in options2) {
+                        primType = primTypes[options2.primitive];
+                      }
+                      if ("count" in options2) {
+                        vertCount = options2.count | 0;
+                      }
+                      if ("type" in options2) {
+                        dtype = elementTypes[options2.type];
+                      }
+                      if ("length" in options2) {
+                        byteLength = options2.length | 0;
+                      } else {
+                        byteLength = vertCount;
+                        if (dtype === GL_UNSIGNED_SHORT$1 || dtype === GL_SHORT$1) {
+                          byteLength *= 2;
+                        } else if (dtype === GL_UNSIGNED_INT$1 || dtype === GL_INT$1) {
+                          byteLength *= 4;
+                        }
+                      }
+                    }
+                    initElements(
+                      elements,
+                      data,
+                      usage,
+                      primType,
+                      vertCount,
+                      byteLength,
+                      dtype
+                    );
+                  }
+                  return reglElements;
+                }
+                reglElements(options);
+                reglElements._reglType = "elements";
+                reglElements._elements = elements;
+                reglElements.subdata = function(data, offset) {
+                  buffer.subdata(data, offset);
+                  return reglElements;
+                };
+                reglElements.destroy = function() {
+                  destroyElements(elements);
+                };
+                return reglElements;
+              }
+              return {
+                create: createElements,
+                createStream: createElementStream,
+                destroyStream: destroyElementStream,
+                getElements: function(elements) {
+                  if (typeof elements === "function" && elements._elements instanceof REGLElementBuffer) {
+                    return elements._elements;
+                  }
+                  return null;
+                },
+                clear: function() {
+                  values(elementSet).forEach(destroyElements);
+                }
+              };
+            }
+            var FLOAT = new Float32Array(1);
+            var INT = new Uint32Array(FLOAT.buffer);
+            var GL_UNSIGNED_SHORT$3 = 5123;
+            function convertToHalfFloat(array) {
+              var ushorts = pool.allocType(GL_UNSIGNED_SHORT$3, array.length);
+              for (var i2 = 0; i2 < array.length; ++i2) {
+                if (isNaN(array[i2])) {
+                  ushorts[i2] = 65535;
+                } else if (array[i2] === Infinity) {
+                  ushorts[i2] = 31744;
+                } else if (array[i2] === -Infinity) {
+                  ushorts[i2] = 64512;
+                } else {
+                  FLOAT[0] = array[i2];
+                  var x2 = INT[0];
+                  var sgn = x2 >>> 31 << 15;
+                  var exp = (x2 << 1 >>> 24) - 127;
+                  var frac = x2 >> 13 & (1 << 10) - 1;
+                  if (exp < -24) {
+                    ushorts[i2] = sgn;
+                  } else if (exp < -14) {
+                    var s2 = -14 - exp;
+                    ushorts[i2] = sgn + (frac + (1 << 10) >> s2);
+                  } else if (exp > 15) {
+                    ushorts[i2] = sgn + 31744;
+                  } else {
+                    ushorts[i2] = sgn + (exp + 15 << 10) + frac;
+                  }
+                }
+              }
+              return ushorts;
+            }
+            function isArrayLike(s2) {
+              return Array.isArray(s2) || isTypedArray2(s2);
+            }
+            var GL_COMPRESSED_TEXTURE_FORMATS = 34467;
+            var GL_TEXTURE_2D$1 = 3553;
+            var GL_TEXTURE_CUBE_MAP$1 = 34067;
+            var GL_TEXTURE_CUBE_MAP_POSITIVE_X$1 = 34069;
+            var GL_RGBA$1 = 6408;
+            var GL_ALPHA = 6406;
+            var GL_RGB = 6407;
+            var GL_LUMINANCE = 6409;
+            var GL_LUMINANCE_ALPHA = 6410;
+            var GL_RGBA4 = 32854;
+            var GL_RGB5_A1 = 32855;
+            var GL_RGB565 = 36194;
+            var GL_UNSIGNED_SHORT_4_4_4_4 = 32819;
+            var GL_UNSIGNED_SHORT_5_5_5_1 = 32820;
+            var GL_UNSIGNED_SHORT_5_6_5 = 33635;
+            var GL_UNSIGNED_INT_24_8_WEBGL = 34042;
+            var GL_DEPTH_COMPONENT = 6402;
+            var GL_DEPTH_STENCIL = 34041;
+            var GL_SRGB_EXT = 35904;
+            var GL_SRGB_ALPHA_EXT = 35906;
+            var GL_HALF_FLOAT_OES = 36193;
+            var GL_COMPRESSED_RGB_S3TC_DXT1_EXT = 33776;
+            var GL_COMPRESSED_RGBA_S3TC_DXT1_EXT = 33777;
+            var GL_COMPRESSED_RGBA_S3TC_DXT3_EXT = 33778;
+            var GL_COMPRESSED_RGBA_S3TC_DXT5_EXT = 33779;
+            var GL_COMPRESSED_RGB_ATC_WEBGL = 35986;
+            var GL_COMPRESSED_RGBA_ATC_EXPLICIT_ALPHA_WEBGL = 35987;
+            var GL_COMPRESSED_RGBA_ATC_INTERPOLATED_ALPHA_WEBGL = 34798;
+            var GL_COMPRESSED_RGB_PVRTC_4BPPV1_IMG = 35840;
+            var GL_COMPRESSED_RGB_PVRTC_2BPPV1_IMG = 35841;
+            var GL_COMPRESSED_RGBA_PVRTC_4BPPV1_IMG = 35842;
+            var GL_COMPRESSED_RGBA_PVRTC_2BPPV1_IMG = 35843;
+            var GL_COMPRESSED_RGB_ETC1_WEBGL = 36196;
+            var GL_UNSIGNED_BYTE$4 = 5121;
+            var GL_UNSIGNED_SHORT$2 = 5123;
+            var GL_UNSIGNED_INT$2 = 5125;
+            var GL_FLOAT$3 = 5126;
+            var GL_TEXTURE_WRAP_S = 10242;
+            var GL_TEXTURE_WRAP_T = 10243;
+            var GL_REPEAT = 10497;
+            var GL_CLAMP_TO_EDGE = 33071;
+            var GL_MIRRORED_REPEAT = 33648;
+            var GL_TEXTURE_MAG_FILTER = 10240;
+            var GL_TEXTURE_MIN_FILTER = 10241;
+            var GL_NEAREST = 9728;
+            var GL_LINEAR = 9729;
+            var GL_NEAREST_MIPMAP_NEAREST = 9984;
+            var GL_LINEAR_MIPMAP_NEAREST = 9985;
+            var GL_NEAREST_MIPMAP_LINEAR = 9986;
+            var GL_LINEAR_MIPMAP_LINEAR = 9987;
+            var GL_GENERATE_MIPMAP_HINT = 33170;
+            var GL_DONT_CARE = 4352;
+            var GL_FASTEST = 4353;
+            var GL_NICEST = 4354;
+            var GL_TEXTURE_MAX_ANISOTROPY_EXT = 34046;
+            var GL_UNPACK_ALIGNMENT = 3317;
+            var GL_UNPACK_FLIP_Y_WEBGL = 37440;
+            var GL_UNPACK_PREMULTIPLY_ALPHA_WEBGL = 37441;
+            var GL_UNPACK_COLORSPACE_CONVERSION_WEBGL = 37443;
+            var GL_BROWSER_DEFAULT_WEBGL = 37444;
+            var GL_TEXTURE0$1 = 33984;
+            var MIPMAP_FILTERS = [
+              GL_NEAREST_MIPMAP_NEAREST,
+              GL_NEAREST_MIPMAP_LINEAR,
+              GL_LINEAR_MIPMAP_NEAREST,
+              GL_LINEAR_MIPMAP_LINEAR
+            ];
+            var CHANNELS_FORMAT = [
+              0,
+              GL_LUMINANCE,
+              GL_LUMINANCE_ALPHA,
+              GL_RGB,
+              GL_RGBA$1
+            ];
+            var FORMAT_CHANNELS = {};
+            FORMAT_CHANNELS[GL_LUMINANCE] = FORMAT_CHANNELS[GL_ALPHA] = FORMAT_CHANNELS[GL_DEPTH_COMPONENT] = 1;
+            FORMAT_CHANNELS[GL_DEPTH_STENCIL] = FORMAT_CHANNELS[GL_LUMINANCE_ALPHA] = 2;
+            FORMAT_CHANNELS[GL_RGB] = FORMAT_CHANNELS[GL_SRGB_EXT] = 3;
+            FORMAT_CHANNELS[GL_RGBA$1] = FORMAT_CHANNELS[GL_SRGB_ALPHA_EXT] = 4;
+            function objectName(str) {
+              return "[object " + str + "]";
+            }
+            var CANVAS_CLASS = objectName("HTMLCanvasElement");
+            var OFFSCREENCANVAS_CLASS = objectName("OffscreenCanvas");
+            var CONTEXT2D_CLASS = objectName("CanvasRenderingContext2D");
+            var BITMAP_CLASS = objectName("ImageBitmap");
+            var IMAGE_CLASS = objectName("HTMLImageElement");
+            var VIDEO_CLASS = objectName("HTMLVideoElement");
+            var PIXEL_CLASSES = Object.keys(arrayTypes).concat([
+              CANVAS_CLASS,
+              OFFSCREENCANVAS_CLASS,
+              CONTEXT2D_CLASS,
+              BITMAP_CLASS,
+              IMAGE_CLASS,
+              VIDEO_CLASS
+            ]);
+            var TYPE_SIZES = [];
+            TYPE_SIZES[GL_UNSIGNED_BYTE$4] = 1;
+            TYPE_SIZES[GL_FLOAT$3] = 4;
+            TYPE_SIZES[GL_HALF_FLOAT_OES] = 2;
+            TYPE_SIZES[GL_UNSIGNED_SHORT$2] = 2;
+            TYPE_SIZES[GL_UNSIGNED_INT$2] = 4;
+            var FORMAT_SIZES_SPECIAL = [];
+            FORMAT_SIZES_SPECIAL[GL_RGBA4] = 2;
+            FORMAT_SIZES_SPECIAL[GL_RGB5_A1] = 2;
+            FORMAT_SIZES_SPECIAL[GL_RGB565] = 2;
+            FORMAT_SIZES_SPECIAL[GL_DEPTH_STENCIL] = 4;
+            FORMAT_SIZES_SPECIAL[GL_COMPRESSED_RGB_S3TC_DXT1_EXT] = 0.5;
+            FORMAT_SIZES_SPECIAL[GL_COMPRESSED_RGBA_S3TC_DXT1_EXT] = 0.5;
+            FORMAT_SIZES_SPECIAL[GL_COMPRESSED_RGBA_S3TC_DXT3_EXT] = 1;
+            FORMAT_SIZES_SPECIAL[GL_COMPRESSED_RGBA_S3TC_DXT5_EXT] = 1;
+            FORMAT_SIZES_SPECIAL[GL_COMPRESSED_RGB_ATC_WEBGL] = 0.5;
+            FORMAT_SIZES_SPECIAL[GL_COMPRESSED_RGBA_ATC_EXPLICIT_ALPHA_WEBGL] = 1;
+            FORMAT_SIZES_SPECIAL[GL_COMPRESSED_RGBA_ATC_INTERPOLATED_ALPHA_WEBGL] = 1;
+            FORMAT_SIZES_SPECIAL[GL_COMPRESSED_RGB_PVRTC_4BPPV1_IMG] = 0.5;
+            FORMAT_SIZES_SPECIAL[GL_COMPRESSED_RGB_PVRTC_2BPPV1_IMG] = 0.25;
+            FORMAT_SIZES_SPECIAL[GL_COMPRESSED_RGBA_PVRTC_4BPPV1_IMG] = 0.5;
+            FORMAT_SIZES_SPECIAL[GL_COMPRESSED_RGBA_PVRTC_2BPPV1_IMG] = 0.25;
+            FORMAT_SIZES_SPECIAL[GL_COMPRESSED_RGB_ETC1_WEBGL] = 0.5;
+            function isNumericArray2(arr) {
+              return Array.isArray(arr) && (arr.length === 0 || typeof arr[0] === "number");
+            }
+            function isRectArray(arr) {
+              if (!Array.isArray(arr)) {
+                return false;
+              }
+              var width = arr.length;
+              if (width === 0 || !isArrayLike(arr[0])) {
+                return false;
+              }
+              return true;
+            }
+            function classString(x2) {
+              return Object.prototype.toString.call(x2);
+            }
+            function isCanvasElement(object) {
+              return classString(object) === CANVAS_CLASS;
+            }
+            function isOffscreenCanvas(object) {
+              return classString(object) === OFFSCREENCANVAS_CLASS;
+            }
+            function isContext2D(object) {
+              return classString(object) === CONTEXT2D_CLASS;
+            }
+            function isBitmap(object) {
+              return classString(object) === BITMAP_CLASS;
+            }
+            function isImageElement(object) {
+              return classString(object) === IMAGE_CLASS;
+            }
+            function isVideoElement(object) {
+              return classString(object) === VIDEO_CLASS;
+            }
+            function isPixelData(object) {
+              if (!object) {
+                return false;
+              }
+              var className = classString(object);
+              if (PIXEL_CLASSES.indexOf(className) >= 0) {
+                return true;
+              }
+              return isNumericArray2(object) || isRectArray(object) || isNDArrayLike(object);
+            }
+            function typedArrayCode$1(data) {
+              return arrayTypes[Object.prototype.toString.call(data)] | 0;
+            }
+            function convertData(result, data) {
+              var n2 = data.length;
+              switch (result.type) {
+                case GL_UNSIGNED_BYTE$4:
+                case GL_UNSIGNED_SHORT$2:
+                case GL_UNSIGNED_INT$2:
+                case GL_FLOAT$3:
+                  var converted = pool.allocType(result.type, n2);
+                  converted.set(data);
+                  result.data = converted;
+                  break;
+                case GL_HALF_FLOAT_OES:
+                  result.data = convertToHalfFloat(data);
+                  break;
+              }
+            }
+            function preConvert(image, n2) {
+              return pool.allocType(
+                image.type === GL_HALF_FLOAT_OES ? GL_FLOAT$3 : image.type,
+                n2
+              );
+            }
+            function postConvert(image, data) {
+              if (image.type === GL_HALF_FLOAT_OES) {
+                image.data = convertToHalfFloat(data);
+                pool.freeType(data);
+              } else {
+                image.data = data;
+              }
+            }
+            function transposeData(image, array, strideX, strideY, strideC, offset) {
+              var w2 = image.width;
+              var h2 = image.height;
+              var c2 = image.channels;
+              var n2 = w2 * h2 * c2;
+              var data = preConvert(image, n2);
+              var p2 = 0;
+              for (var i2 = 0; i2 < h2; ++i2) {
+                for (var j2 = 0; j2 < w2; ++j2) {
+                  for (var k2 = 0; k2 < c2; ++k2) {
+                    data[p2++] = array[strideX * j2 + strideY * i2 + strideC * k2 + offset];
+                  }
+                }
+              }
+              postConvert(image, data);
+            }
+            function getTextureSize(format, type, width, height, isMipmap, isCube) {
+              var s2;
+              if (typeof FORMAT_SIZES_SPECIAL[format] !== "undefined") {
+                s2 = FORMAT_SIZES_SPECIAL[format];
+              } else {
+                s2 = FORMAT_CHANNELS[format] * TYPE_SIZES[type];
+              }
+              if (isCube) {
+                s2 *= 6;
+              }
+              if (isMipmap) {
+                var total = 0;
+                var w2 = width;
+                while (w2 >= 1) {
+                  total += s2 * w2 * w2;
+                  w2 /= 2;
+                }
+                return total;
+              } else {
+                return s2 * width * height;
+              }
+            }
+            function createTextureSet(gl2, extensions, limits, reglPoll, contextState, stats2, config2) {
+              var mipmapHint = {
+                "don't care": GL_DONT_CARE,
+                "dont care": GL_DONT_CARE,
+                "nice": GL_NICEST,
+                "fast": GL_FASTEST
+              };
+              var wrapModes = {
+                "repeat": GL_REPEAT,
+                "clamp": GL_CLAMP_TO_EDGE,
+                "mirror": GL_MIRRORED_REPEAT
+              };
+              var magFilters = {
+                "nearest": GL_NEAREST,
+                "linear": GL_LINEAR
+              };
+              var minFilters = extend2({
+                "mipmap": GL_LINEAR_MIPMAP_LINEAR,
+                "nearest mipmap nearest": GL_NEAREST_MIPMAP_NEAREST,
+                "linear mipmap nearest": GL_LINEAR_MIPMAP_NEAREST,
+                "nearest mipmap linear": GL_NEAREST_MIPMAP_LINEAR,
+                "linear mipmap linear": GL_LINEAR_MIPMAP_LINEAR
+              }, magFilters);
+              var colorSpace = {
+                "none": 0,
+                "browser": GL_BROWSER_DEFAULT_WEBGL
+              };
+              var textureTypes = {
+                "uint8": GL_UNSIGNED_BYTE$4,
+                "rgba4": GL_UNSIGNED_SHORT_4_4_4_4,
+                "rgb565": GL_UNSIGNED_SHORT_5_6_5,
+                "rgb5 a1": GL_UNSIGNED_SHORT_5_5_5_1
+              };
+              var textureFormats = {
+                "alpha": GL_ALPHA,
+                "luminance": GL_LUMINANCE,
+                "luminance alpha": GL_LUMINANCE_ALPHA,
+                "rgb": GL_RGB,
+                "rgba": GL_RGBA$1,
+                "rgba4": GL_RGBA4,
+                "rgb5 a1": GL_RGB5_A1,
+                "rgb565": GL_RGB565
+              };
+              var compressedTextureFormats = {};
+              if (extensions.ext_srgb) {
+                textureFormats.srgb = GL_SRGB_EXT;
+                textureFormats.srgba = GL_SRGB_ALPHA_EXT;
+              }
+              if (extensions.oes_texture_float) {
+                textureTypes.float32 = textureTypes.float = GL_FLOAT$3;
+              }
+              if (extensions.oes_texture_half_float) {
+                textureTypes["float16"] = textureTypes["half float"] = GL_HALF_FLOAT_OES;
+              }
+              if (extensions.webgl_depth_texture) {
+                extend2(textureFormats, {
+                  "depth": GL_DEPTH_COMPONENT,
+                  "depth stencil": GL_DEPTH_STENCIL
+                });
+                extend2(textureTypes, {
+                  "uint16": GL_UNSIGNED_SHORT$2,
+                  "uint32": GL_UNSIGNED_INT$2,
+                  "depth stencil": GL_UNSIGNED_INT_24_8_WEBGL
+                });
+              }
+              if (extensions.webgl_compressed_texture_s3tc) {
+                extend2(compressedTextureFormats, {
+                  "rgb s3tc dxt1": GL_COMPRESSED_RGB_S3TC_DXT1_EXT,
+                  "rgba s3tc dxt1": GL_COMPRESSED_RGBA_S3TC_DXT1_EXT,
+                  "rgba s3tc dxt3": GL_COMPRESSED_RGBA_S3TC_DXT3_EXT,
+                  "rgba s3tc dxt5": GL_COMPRESSED_RGBA_S3TC_DXT5_EXT
+                });
+              }
+              if (extensions.webgl_compressed_texture_atc) {
+                extend2(compressedTextureFormats, {
+                  "rgb atc": GL_COMPRESSED_RGB_ATC_WEBGL,
+                  "rgba atc explicit alpha": GL_COMPRESSED_RGBA_ATC_EXPLICIT_ALPHA_WEBGL,
+                  "rgba atc interpolated alpha": GL_COMPRESSED_RGBA_ATC_INTERPOLATED_ALPHA_WEBGL
+                });
+              }
+              if (extensions.webgl_compressed_texture_pvrtc) {
+                extend2(compressedTextureFormats, {
+                  "rgb pvrtc 4bppv1": GL_COMPRESSED_RGB_PVRTC_4BPPV1_IMG,
+                  "rgb pvrtc 2bppv1": GL_COMPRESSED_RGB_PVRTC_2BPPV1_IMG,
+                  "rgba pvrtc 4bppv1": GL_COMPRESSED_RGBA_PVRTC_4BPPV1_IMG,
+                  "rgba pvrtc 2bppv1": GL_COMPRESSED_RGBA_PVRTC_2BPPV1_IMG
+                });
+              }
+              if (extensions.webgl_compressed_texture_etc1) {
+                compressedTextureFormats["rgb etc1"] = GL_COMPRESSED_RGB_ETC1_WEBGL;
+              }
+              var supportedCompressedFormats = Array.prototype.slice.call(
+                gl2.getParameter(GL_COMPRESSED_TEXTURE_FORMATS)
+              );
+              Object.keys(compressedTextureFormats).forEach(function(name2) {
+                var format = compressedTextureFormats[name2];
+                if (supportedCompressedFormats.indexOf(format) >= 0) {
+                  textureFormats[name2] = format;
+                }
+              });
+              var supportedFormats = Object.keys(textureFormats);
+              limits.textureFormats = supportedFormats;
+              var textureFormatsInvert = [];
+              Object.keys(textureFormats).forEach(function(key) {
+                var val = textureFormats[key];
+                textureFormatsInvert[val] = key;
+              });
+              var textureTypesInvert = [];
+              Object.keys(textureTypes).forEach(function(key) {
+                var val = textureTypes[key];
+                textureTypesInvert[val] = key;
+              });
+              var magFiltersInvert = [];
+              Object.keys(magFilters).forEach(function(key) {
+                var val = magFilters[key];
+                magFiltersInvert[val] = key;
+              });
+              var minFiltersInvert = [];
+              Object.keys(minFilters).forEach(function(key) {
+                var val = minFilters[key];
+                minFiltersInvert[val] = key;
+              });
+              var wrapModesInvert = [];
+              Object.keys(wrapModes).forEach(function(key) {
+                var val = wrapModes[key];
+                wrapModesInvert[val] = key;
+              });
+              var colorFormats = supportedFormats.reduce(function(color22, key) {
+                var glenum = textureFormats[key];
+                if (glenum === GL_LUMINANCE || glenum === GL_ALPHA || glenum === GL_LUMINANCE || glenum === GL_LUMINANCE_ALPHA || glenum === GL_DEPTH_COMPONENT || glenum === GL_DEPTH_STENCIL || extensions.ext_srgb && (glenum === GL_SRGB_EXT || glenum === GL_SRGB_ALPHA_EXT)) {
+                  color22[glenum] = glenum;
+                } else if (glenum === GL_RGB5_A1 || key.indexOf("rgba") >= 0) {
+                  color22[glenum] = GL_RGBA$1;
+                } else {
+                  color22[glenum] = GL_RGB;
+                }
+                return color22;
+              }, {});
+              function TexFlags() {
+                this.internalformat = GL_RGBA$1;
+                this.format = GL_RGBA$1;
+                this.type = GL_UNSIGNED_BYTE$4;
+                this.compressed = false;
+                this.premultiplyAlpha = false;
+                this.flipY = false;
+                this.unpackAlignment = 1;
+                this.colorSpace = GL_BROWSER_DEFAULT_WEBGL;
+                this.width = 0;
+                this.height = 0;
+                this.channels = 0;
+              }
+              function copyFlags(result, other) {
+                result.internalformat = other.internalformat;
+                result.format = other.format;
+                result.type = other.type;
+                result.compressed = other.compressed;
+                result.premultiplyAlpha = other.premultiplyAlpha;
+                result.flipY = other.flipY;
+                result.unpackAlignment = other.unpackAlignment;
+                result.colorSpace = other.colorSpace;
+                result.width = other.width;
+                result.height = other.height;
+                result.channels = other.channels;
+              }
+              function parseFlags(flags, options) {
+                if (typeof options !== "object" || !options) {
+                  return;
+                }
+                if ("premultiplyAlpha" in options) {
+                  flags.premultiplyAlpha = options.premultiplyAlpha;
+                }
+                if ("flipY" in options) {
+                  flags.flipY = options.flipY;
+                }
+                if ("alignment" in options) {
+                  flags.unpackAlignment = options.alignment;
+                }
+                if ("colorSpace" in options) {
+                  flags.colorSpace = colorSpace[options.colorSpace];
+                }
+                if ("type" in options) {
+                  var type = options.type;
+                  flags.type = textureTypes[type];
+                }
+                var w2 = flags.width;
+                var h2 = flags.height;
+                var c2 = flags.channels;
+                var hasChannels = false;
+                if ("shape" in options) {
+                  w2 = options.shape[0];
+                  h2 = options.shape[1];
+                  if (options.shape.length === 3) {
+                    c2 = options.shape[2];
+                    hasChannels = true;
+                  }
+                } else {
+                  if ("radius" in options) {
+                    w2 = h2 = options.radius;
+                  }
+                  if ("width" in options) {
+                    w2 = options.width;
+                  }
+                  if ("height" in options) {
+                    h2 = options.height;
+                  }
+                  if ("channels" in options) {
+                    c2 = options.channels;
+                    hasChannels = true;
+                  }
+                }
+                flags.width = w2 | 0;
+                flags.height = h2 | 0;
+                flags.channels = c2 | 0;
+                var hasFormat = false;
+                if ("format" in options) {
+                  var formatStr = options.format;
+                  var internalformat = flags.internalformat = textureFormats[formatStr];
+                  flags.format = colorFormats[internalformat];
+                  if (formatStr in textureTypes) {
+                    if (!("type" in options)) {
+                      flags.type = textureTypes[formatStr];
+                    }
+                  }
+                  if (formatStr in compressedTextureFormats) {
+                    flags.compressed = true;
+                  }
+                  hasFormat = true;
+                }
+                if (!hasChannels && hasFormat) {
+                  flags.channels = FORMAT_CHANNELS[flags.format];
+                } else if (hasChannels && !hasFormat) {
+                  if (flags.channels !== CHANNELS_FORMAT[flags.format]) {
+                    flags.format = flags.internalformat = CHANNELS_FORMAT[flags.channels];
+                  }
+                } else ;
+              }
+              function setFlags(flags) {
+                gl2.pixelStorei(GL_UNPACK_FLIP_Y_WEBGL, flags.flipY);
+                gl2.pixelStorei(GL_UNPACK_PREMULTIPLY_ALPHA_WEBGL, flags.premultiplyAlpha);
+                gl2.pixelStorei(GL_UNPACK_COLORSPACE_CONVERSION_WEBGL, flags.colorSpace);
+                gl2.pixelStorei(GL_UNPACK_ALIGNMENT, flags.unpackAlignment);
+              }
+              function TexImage() {
+                TexFlags.call(this);
+                this.xOffset = 0;
+                this.yOffset = 0;
+                this.data = null;
+                this.needsFree = false;
+                this.element = null;
+                this.needsCopy = false;
+              }
+              function parseImage2(image, options) {
+                var data = null;
+                if (isPixelData(options)) {
+                  data = options;
+                } else if (options) {
+                  parseFlags(image, options);
+                  if ("x" in options) {
+                    image.xOffset = options.x | 0;
+                  }
+                  if ("y" in options) {
+                    image.yOffset = options.y | 0;
+                  }
+                  if (isPixelData(options.data)) {
+                    data = options.data;
+                  }
+                }
+                if (options.copy) {
+                  var viewW = contextState.viewportWidth;
+                  var viewH = contextState.viewportHeight;
+                  image.width = image.width || viewW - image.xOffset;
+                  image.height = image.height || viewH - image.yOffset;
+                  image.needsCopy = true;
+                } else if (!data) {
+                  image.width = image.width || 1;
+                  image.height = image.height || 1;
+                  image.channels = image.channels || 4;
+                } else if (isTypedArray2(data)) {
+                  image.channels = image.channels || 4;
+                  image.data = data;
+                  if (!("type" in options) && image.type === GL_UNSIGNED_BYTE$4) {
+                    image.type = typedArrayCode$1(data);
+                  }
+                } else if (isNumericArray2(data)) {
+                  image.channels = image.channels || 4;
+                  convertData(image, data);
+                  image.alignment = 1;
+                  image.needsFree = true;
+                } else if (isNDArrayLike(data)) {
+                  var array = data.data;
+                  if (!Array.isArray(array) && image.type === GL_UNSIGNED_BYTE$4) {
+                    image.type = typedArrayCode$1(array);
+                  }
+                  var shape = data.shape;
+                  var stride = data.stride;
+                  var shapeX, shapeY, shapeC, strideX, strideY, strideC;
+                  if (shape.length === 3) {
+                    shapeC = shape[2];
+                    strideC = stride[2];
+                  } else {
+                    shapeC = 1;
+                    strideC = 1;
+                  }
+                  shapeX = shape[0];
+                  shapeY = shape[1];
+                  strideX = stride[0];
+                  strideY = stride[1];
+                  image.alignment = 1;
+                  image.width = shapeX;
+                  image.height = shapeY;
+                  image.channels = shapeC;
+                  image.format = image.internalformat = CHANNELS_FORMAT[shapeC];
+                  image.needsFree = true;
+                  transposeData(image, array, strideX, strideY, strideC, data.offset);
+                } else if (isCanvasElement(data) || isOffscreenCanvas(data) || isContext2D(data)) {
+                  if (isCanvasElement(data) || isOffscreenCanvas(data)) {
+                    image.element = data;
+                  } else {
+                    image.element = data.canvas;
+                  }
+                  image.width = image.element.width;
+                  image.height = image.element.height;
+                  image.channels = 4;
+                } else if (isBitmap(data)) {
+                  image.element = data;
+                  image.width = data.width;
+                  image.height = data.height;
+                  image.channels = 4;
+                } else if (isImageElement(data)) {
+                  image.element = data;
+                  image.width = data.naturalWidth;
+                  image.height = data.naturalHeight;
+                  image.channels = 4;
+                } else if (isVideoElement(data)) {
+                  image.element = data;
+                  image.width = data.videoWidth;
+                  image.height = data.videoHeight;
+                  image.channels = 4;
+                } else if (isRectArray(data)) {
+                  var w2 = image.width || data[0].length;
+                  var h2 = image.height || data.length;
+                  var c2 = image.channels;
+                  if (isArrayLike(data[0][0])) {
+                    c2 = c2 || data[0][0].length;
+                  } else {
+                    c2 = c2 || 1;
+                  }
+                  var arrayShape2 = flattenUtils.shape(data);
+                  var n2 = 1;
+                  for (var dd2 = 0; dd2 < arrayShape2.length; ++dd2) {
+                    n2 *= arrayShape2[dd2];
+                  }
+                  var allocData = preConvert(image, n2);
+                  flattenUtils.flatten(data, arrayShape2, "", allocData);
+                  postConvert(image, allocData);
+                  image.alignment = 1;
+                  image.width = w2;
+                  image.height = h2;
+                  image.channels = c2;
+                  image.format = image.internalformat = CHANNELS_FORMAT[c2];
+                  image.needsFree = true;
+                }
+                if (image.type === GL_FLOAT$3) ;
+                else if (image.type === GL_HALF_FLOAT_OES) ;
+              }
+              function setImage(info, target, miplevel) {
+                var element = info.element;
+                var data = info.data;
+                var internalformat = info.internalformat;
+                var format = info.format;
+                var type = info.type;
+                var width = info.width;
+                var height = info.height;
+                setFlags(info);
+                if (element) {
+                  gl2.texImage2D(target, miplevel, format, format, type, element);
+                } else if (info.compressed) {
+                  gl2.compressedTexImage2D(target, miplevel, internalformat, width, height, 0, data);
+                } else if (info.needsCopy) {
+                  reglPoll();
+                  gl2.copyTexImage2D(
+                    target,
+                    miplevel,
+                    format,
+                    info.xOffset,
+                    info.yOffset,
+                    width,
+                    height,
+                    0
+                  );
+                } else {
+                  gl2.texImage2D(target, miplevel, format, width, height, 0, format, type, data || null);
+                }
+              }
+              function setSubImage(info, target, x2, y2, miplevel) {
+                var element = info.element;
+                var data = info.data;
+                var internalformat = info.internalformat;
+                var format = info.format;
+                var type = info.type;
+                var width = info.width;
+                var height = info.height;
+                setFlags(info);
+                if (element) {
+                  gl2.texSubImage2D(
+                    target,
+                    miplevel,
+                    x2,
+                    y2,
+                    format,
+                    type,
+                    element
+                  );
+                } else if (info.compressed) {
+                  gl2.compressedTexSubImage2D(
+                    target,
+                    miplevel,
+                    x2,
+                    y2,
+                    internalformat,
+                    width,
+                    height,
+                    data
+                  );
+                } else if (info.needsCopy) {
+                  reglPoll();
+                  gl2.copyTexSubImage2D(
+                    target,
+                    miplevel,
+                    x2,
+                    y2,
+                    info.xOffset,
+                    info.yOffset,
+                    width,
+                    height
+                  );
+                } else {
+                  gl2.texSubImage2D(
+                    target,
+                    miplevel,
+                    x2,
+                    y2,
+                    width,
+                    height,
+                    format,
+                    type,
+                    data
+                  );
+                }
+              }
+              var imagePool = [];
+              function allocImage() {
+                return imagePool.pop() || new TexImage();
+              }
+              function freeImage(image) {
+                if (image.needsFree) {
+                  pool.freeType(image.data);
+                }
+                TexImage.call(image);
+                imagePool.push(image);
+              }
+              function MipMap() {
+                TexFlags.call(this);
+                this.genMipmaps = false;
+                this.mipmapHint = GL_DONT_CARE;
+                this.mipmask = 0;
+                this.images = Array(16);
+              }
+              function parseMipMapFromShape(mipmap, width, height) {
+                var img = mipmap.images[0] = allocImage();
+                mipmap.mipmask = 1;
+                img.width = mipmap.width = width;
+                img.height = mipmap.height = height;
+                img.channels = mipmap.channels = 4;
+              }
+              function parseMipMapFromObject(mipmap, options) {
+                var imgData = null;
+                if (isPixelData(options)) {
+                  imgData = mipmap.images[0] = allocImage();
+                  copyFlags(imgData, mipmap);
+                  parseImage2(imgData, options);
+                  mipmap.mipmask = 1;
+                } else {
+                  parseFlags(mipmap, options);
+                  if (Array.isArray(options.mipmap)) {
+                    var mipData = options.mipmap;
+                    for (var i2 = 0; i2 < mipData.length; ++i2) {
+                      imgData = mipmap.images[i2] = allocImage();
+                      copyFlags(imgData, mipmap);
+                      imgData.width >>= i2;
+                      imgData.height >>= i2;
+                      parseImage2(imgData, mipData[i2]);
+                      mipmap.mipmask |= 1 << i2;
+                    }
+                  } else {
+                    imgData = mipmap.images[0] = allocImage();
+                    copyFlags(imgData, mipmap);
+                    parseImage2(imgData, options);
+                    mipmap.mipmask = 1;
+                  }
+                }
+                copyFlags(mipmap, mipmap.images[0]);
+                if (mipmap.compressed && (mipmap.internalformat === GL_COMPRESSED_RGB_S3TC_DXT1_EXT || mipmap.internalformat === GL_COMPRESSED_RGBA_S3TC_DXT1_EXT || mipmap.internalformat === GL_COMPRESSED_RGBA_S3TC_DXT3_EXT || mipmap.internalformat === GL_COMPRESSED_RGBA_S3TC_DXT5_EXT)) ;
+              }
+              function setMipMap(mipmap, target) {
+                var images = mipmap.images;
+                for (var i2 = 0; i2 < images.length; ++i2) {
+                  if (!images[i2]) {
+                    return;
+                  }
+                  setImage(images[i2], target, i2);
+                }
+              }
+              var mipPool = [];
+              function allocMipMap() {
+                var result = mipPool.pop() || new MipMap();
+                TexFlags.call(result);
+                result.mipmask = 0;
+                for (var i2 = 0; i2 < 16; ++i2) {
+                  result.images[i2] = null;
+                }
+                return result;
+              }
+              function freeMipMap(mipmap) {
+                var images = mipmap.images;
+                for (var i2 = 0; i2 < images.length; ++i2) {
+                  if (images[i2]) {
+                    freeImage(images[i2]);
+                  }
+                  images[i2] = null;
+                }
+                mipPool.push(mipmap);
+              }
+              function TexInfo() {
+                this.minFilter = GL_NEAREST;
+                this.magFilter = GL_NEAREST;
+                this.wrapS = GL_CLAMP_TO_EDGE;
+                this.wrapT = GL_CLAMP_TO_EDGE;
+                this.anisotropic = 1;
+                this.genMipmaps = false;
+                this.mipmapHint = GL_DONT_CARE;
+              }
+              function parseTexInfo(info, options) {
+                if ("min" in options) {
+                  var minFilter = options.min;
+                  info.minFilter = minFilters[minFilter];
+                  if (MIPMAP_FILTERS.indexOf(info.minFilter) >= 0 && !("faces" in options)) {
+                    info.genMipmaps = true;
+                  }
+                }
+                if ("mag" in options) {
+                  var magFilter = options.mag;
+                  info.magFilter = magFilters[magFilter];
+                }
+                var wrapS = info.wrapS;
+                var wrapT = info.wrapT;
+                if ("wrap" in options) {
+                  var wrap = options.wrap;
+                  if (typeof wrap === "string") {
+                    wrapS = wrapT = wrapModes[wrap];
+                  } else if (Array.isArray(wrap)) {
+                    wrapS = wrapModes[wrap[0]];
+                    wrapT = wrapModes[wrap[1]];
+                  }
+                } else {
+                  if ("wrapS" in options) {
+                    var optWrapS = options.wrapS;
+                    wrapS = wrapModes[optWrapS];
+                  }
+                  if ("wrapT" in options) {
+                    var optWrapT = options.wrapT;
+                    wrapT = wrapModes[optWrapT];
+                  }
+                }
+                info.wrapS = wrapS;
+                info.wrapT = wrapT;
+                if ("anisotropic" in options) {
+                  options.anisotropic;
+                  info.anisotropic = options.anisotropic;
+                }
+                if ("mipmap" in options) {
+                  var hasMipMap = false;
+                  switch (typeof options.mipmap) {
+                    case "string":
+                      info.mipmapHint = mipmapHint[options.mipmap];
+                      info.genMipmaps = true;
+                      hasMipMap = true;
+                      break;
+                    case "boolean":
+                      hasMipMap = info.genMipmaps = options.mipmap;
+                      break;
+                    case "object":
+                      info.genMipmaps = false;
+                      hasMipMap = true;
+                      break;
+                  }
+                  if (hasMipMap && !("min" in options)) {
+                    info.minFilter = GL_NEAREST_MIPMAP_NEAREST;
+                  }
+                }
+              }
+              function setTexInfo(info, target) {
+                gl2.texParameteri(target, GL_TEXTURE_MIN_FILTER, info.minFilter);
+                gl2.texParameteri(target, GL_TEXTURE_MAG_FILTER, info.magFilter);
+                gl2.texParameteri(target, GL_TEXTURE_WRAP_S, info.wrapS);
+                gl2.texParameteri(target, GL_TEXTURE_WRAP_T, info.wrapT);
+                if (extensions.ext_texture_filter_anisotropic) {
+                  gl2.texParameteri(target, GL_TEXTURE_MAX_ANISOTROPY_EXT, info.anisotropic);
+                }
+                if (info.genMipmaps) {
+                  gl2.hint(GL_GENERATE_MIPMAP_HINT, info.mipmapHint);
+                  gl2.generateMipmap(target);
+                }
+              }
+              var textureCount = 0;
+              var textureSet = {};
+              var numTexUnits = limits.maxTextureUnits;
+              var textureUnits = Array(numTexUnits).map(function() {
+                return null;
+              });
+              function REGLTexture(target) {
+                TexFlags.call(this);
+                this.mipmask = 0;
+                this.internalformat = GL_RGBA$1;
+                this.id = textureCount++;
+                this.refCount = 1;
+                this.target = target;
+                this.texture = gl2.createTexture();
+                this.unit = -1;
+                this.bindCount = 0;
+                this.texInfo = new TexInfo();
+                if (config2.profile) {
+                  this.stats = { size: 0 };
+                }
+              }
+              function tempBind(texture) {
+                gl2.activeTexture(GL_TEXTURE0$1);
+                gl2.bindTexture(texture.target, texture.texture);
+              }
+              function tempRestore() {
+                var prev = textureUnits[0];
+                if (prev) {
+                  gl2.bindTexture(prev.target, prev.texture);
+                } else {
+                  gl2.bindTexture(GL_TEXTURE_2D$1, null);
+                }
+              }
+              function destroy(texture) {
+                var handle = texture.texture;
+                var unit = texture.unit;
+                var target = texture.target;
+                if (unit >= 0) {
+                  gl2.activeTexture(GL_TEXTURE0$1 + unit);
+                  gl2.bindTexture(target, null);
+                  textureUnits[unit] = null;
+                }
+                gl2.deleteTexture(handle);
+                texture.texture = null;
+                texture.params = null;
+                texture.pixels = null;
+                texture.refCount = 0;
+                delete textureSet[texture.id];
+                stats2.textureCount--;
+              }
+              extend2(REGLTexture.prototype, {
+                bind: function() {
+                  var texture = this;
+                  texture.bindCount += 1;
+                  var unit = texture.unit;
+                  if (unit < 0) {
+                    for (var i2 = 0; i2 < numTexUnits; ++i2) {
+                      var other = textureUnits[i2];
+                      if (other) {
+                        if (other.bindCount > 0) {
+                          continue;
+                        }
+                        other.unit = -1;
+                      }
+                      textureUnits[i2] = texture;
+                      unit = i2;
+                      break;
+                    }
+                    if (config2.profile && stats2.maxTextureUnits < unit + 1) {
+                      stats2.maxTextureUnits = unit + 1;
+                    }
+                    texture.unit = unit;
+                    gl2.activeTexture(GL_TEXTURE0$1 + unit);
+                    gl2.bindTexture(texture.target, texture.texture);
+                  }
+                  return unit;
+                },
+                unbind: function() {
+                  this.bindCount -= 1;
+                },
+                decRef: function() {
+                  if (--this.refCount <= 0) {
+                    destroy(this);
+                  }
+                }
+              });
+              function createTexture2D(a2, b2) {
+                var texture = new REGLTexture(GL_TEXTURE_2D$1);
+                textureSet[texture.id] = texture;
+                stats2.textureCount++;
+                function reglTexture2D(a22, b22) {
+                  var texInfo = texture.texInfo;
+                  TexInfo.call(texInfo);
+                  var mipData = allocMipMap();
+                  if (typeof a22 === "number") {
+                    if (typeof b22 === "number") {
+                      parseMipMapFromShape(mipData, a22 | 0, b22 | 0);
+                    } else {
+                      parseMipMapFromShape(mipData, a22 | 0, a22 | 0);
+                    }
+                  } else if (a22) {
+                    parseTexInfo(texInfo, a22);
+                    parseMipMapFromObject(mipData, a22);
+                  } else {
+                    parseMipMapFromShape(mipData, 1, 1);
+                  }
+                  if (texInfo.genMipmaps) {
+                    mipData.mipmask = (mipData.width << 1) - 1;
+                  }
+                  texture.mipmask = mipData.mipmask;
+                  copyFlags(texture, mipData);
+                  texture.internalformat = mipData.internalformat;
+                  reglTexture2D.width = mipData.width;
+                  reglTexture2D.height = mipData.height;
+                  tempBind(texture);
+                  setMipMap(mipData, GL_TEXTURE_2D$1);
+                  setTexInfo(texInfo, GL_TEXTURE_2D$1);
+                  tempRestore();
+                  freeMipMap(mipData);
+                  if (config2.profile) {
+                    texture.stats.size = getTextureSize(
+                      texture.internalformat,
+                      texture.type,
+                      mipData.width,
+                      mipData.height,
+                      texInfo.genMipmaps,
+                      false
+                    );
+                  }
+                  reglTexture2D.format = textureFormatsInvert[texture.internalformat];
+                  reglTexture2D.type = textureTypesInvert[texture.type];
+                  reglTexture2D.mag = magFiltersInvert[texInfo.magFilter];
+                  reglTexture2D.min = minFiltersInvert[texInfo.minFilter];
+                  reglTexture2D.wrapS = wrapModesInvert[texInfo.wrapS];
+                  reglTexture2D.wrapT = wrapModesInvert[texInfo.wrapT];
+                  return reglTexture2D;
+                }
+                function subimage(image, x_, y_, level_) {
+                  var x2 = x_ | 0;
+                  var y2 = y_ | 0;
+                  var level = level_ | 0;
+                  var imageData = allocImage();
+                  copyFlags(imageData, texture);
+                  imageData.width = 0;
+                  imageData.height = 0;
+                  parseImage2(imageData, image);
+                  imageData.width = imageData.width || (texture.width >> level) - x2;
+                  imageData.height = imageData.height || (texture.height >> level) - y2;
+                  tempBind(texture);
+                  setSubImage(imageData, GL_TEXTURE_2D$1, x2, y2, level);
+                  tempRestore();
+                  freeImage(imageData);
+                  return reglTexture2D;
+                }
+                function resize(w_, h_) {
+                  var w2 = w_ | 0;
+                  var h2 = h_ | 0 || w2;
+                  if (w2 === texture.width && h2 === texture.height) {
+                    return reglTexture2D;
+                  }
+                  reglTexture2D.width = texture.width = w2;
+                  reglTexture2D.height = texture.height = h2;
+                  tempBind(texture);
+                  for (var i2 = 0; texture.mipmask >> i2; ++i2) {
+                    var _w2 = w2 >> i2;
+                    var _h2 = h2 >> i2;
+                    if (!_w2 || !_h2) break;
+                    gl2.texImage2D(
+                      GL_TEXTURE_2D$1,
+                      i2,
+                      texture.format,
+                      _w2,
+                      _h2,
+                      0,
+                      texture.format,
+                      texture.type,
+                      null
+                    );
+                  }
+                  tempRestore();
+                  if (config2.profile) {
+                    texture.stats.size = getTextureSize(
+                      texture.internalformat,
+                      texture.type,
+                      w2,
+                      h2,
+                      false,
+                      false
+                    );
+                  }
+                  return reglTexture2D;
+                }
+                reglTexture2D(a2, b2);
+                reglTexture2D.subimage = subimage;
+                reglTexture2D.resize = resize;
+                reglTexture2D._reglType = "texture2d";
+                reglTexture2D._texture = texture;
+                if (config2.profile) {
+                  reglTexture2D.stats = texture.stats;
+                }
+                reglTexture2D.destroy = function() {
+                  texture.decRef();
+                };
+                return reglTexture2D;
+              }
+              function createTextureCube(a0, a1, a2, a3, a4, a5) {
+                var texture = new REGLTexture(GL_TEXTURE_CUBE_MAP$1);
+                textureSet[texture.id] = texture;
+                stats2.cubeCount++;
+                var faces = new Array(6);
+                function reglTextureCube(a02, a12, a22, a32, a42, a52) {
+                  var i2;
+                  var texInfo = texture.texInfo;
+                  TexInfo.call(texInfo);
+                  for (i2 = 0; i2 < 6; ++i2) {
+                    faces[i2] = allocMipMap();
+                  }
+                  if (typeof a02 === "number" || !a02) {
+                    var s2 = a02 | 0 || 1;
+                    for (i2 = 0; i2 < 6; ++i2) {
+                      parseMipMapFromShape(faces[i2], s2, s2);
+                    }
+                  } else if (typeof a02 === "object") {
+                    if (a12) {
+                      parseMipMapFromObject(faces[0], a02);
+                      parseMipMapFromObject(faces[1], a12);
+                      parseMipMapFromObject(faces[2], a22);
+                      parseMipMapFromObject(faces[3], a32);
+                      parseMipMapFromObject(faces[4], a42);
+                      parseMipMapFromObject(faces[5], a52);
+                    } else {
+                      parseTexInfo(texInfo, a02);
+                      parseFlags(texture, a02);
+                      if ("faces" in a02) {
+                        var faceInput = a02.faces;
+                        for (i2 = 0; i2 < 6; ++i2) {
+                          copyFlags(faces[i2], texture);
+                          parseMipMapFromObject(faces[i2], faceInput[i2]);
+                        }
+                      } else {
+                        for (i2 = 0; i2 < 6; ++i2) {
+                          parseMipMapFromObject(faces[i2], a02);
+                        }
+                      }
+                    }
+                  } else ;
+                  copyFlags(texture, faces[0]);
+                  if (texInfo.genMipmaps) {
+                    texture.mipmask = (faces[0].width << 1) - 1;
+                  } else {
+                    texture.mipmask = faces[0].mipmask;
+                  }
+                  texture.internalformat = faces[0].internalformat;
+                  reglTextureCube.width = faces[0].width;
+                  reglTextureCube.height = faces[0].height;
+                  tempBind(texture);
+                  for (i2 = 0; i2 < 6; ++i2) {
+                    setMipMap(faces[i2], GL_TEXTURE_CUBE_MAP_POSITIVE_X$1 + i2);
+                  }
+                  setTexInfo(texInfo, GL_TEXTURE_CUBE_MAP$1);
+                  tempRestore();
+                  if (config2.profile) {
+                    texture.stats.size = getTextureSize(
+                      texture.internalformat,
+                      texture.type,
+                      reglTextureCube.width,
+                      reglTextureCube.height,
+                      texInfo.genMipmaps,
+                      true
+                    );
+                  }
+                  reglTextureCube.format = textureFormatsInvert[texture.internalformat];
+                  reglTextureCube.type = textureTypesInvert[texture.type];
+                  reglTextureCube.mag = magFiltersInvert[texInfo.magFilter];
+                  reglTextureCube.min = minFiltersInvert[texInfo.minFilter];
+                  reglTextureCube.wrapS = wrapModesInvert[texInfo.wrapS];
+                  reglTextureCube.wrapT = wrapModesInvert[texInfo.wrapT];
+                  for (i2 = 0; i2 < 6; ++i2) {
+                    freeMipMap(faces[i2]);
+                  }
+                  return reglTextureCube;
+                }
+                function subimage(face, image, x_, y_, level_) {
+                  var x2 = x_ | 0;
+                  var y2 = y_ | 0;
+                  var level = level_ | 0;
+                  var imageData = allocImage();
+                  copyFlags(imageData, texture);
+                  imageData.width = 0;
+                  imageData.height = 0;
+                  parseImage2(imageData, image);
+                  imageData.width = imageData.width || (texture.width >> level) - x2;
+                  imageData.height = imageData.height || (texture.height >> level) - y2;
+                  tempBind(texture);
+                  setSubImage(imageData, GL_TEXTURE_CUBE_MAP_POSITIVE_X$1 + face, x2, y2, level);
+                  tempRestore();
+                  freeImage(imageData);
+                  return reglTextureCube;
+                }
+                function resize(radius_) {
+                  var radius = radius_ | 0;
+                  if (radius === texture.width) {
+                    return;
+                  }
+                  reglTextureCube.width = texture.width = radius;
+                  reglTextureCube.height = texture.height = radius;
+                  tempBind(texture);
+                  for (var i2 = 0; i2 < 6; ++i2) {
+                    for (var j2 = 0; texture.mipmask >> j2; ++j2) {
+                      gl2.texImage2D(
+                        GL_TEXTURE_CUBE_MAP_POSITIVE_X$1 + i2,
+                        j2,
+                        texture.format,
+                        radius >> j2,
+                        radius >> j2,
+                        0,
+                        texture.format,
+                        texture.type,
+                        null
+                      );
+                    }
+                  }
+                  tempRestore();
+                  if (config2.profile) {
+                    texture.stats.size = getTextureSize(
+                      texture.internalformat,
+                      texture.type,
+                      reglTextureCube.width,
+                      reglTextureCube.height,
+                      false,
+                      true
+                    );
+                  }
+                  return reglTextureCube;
+                }
+                reglTextureCube(a0, a1, a2, a3, a4, a5);
+                reglTextureCube.subimage = subimage;
+                reglTextureCube.resize = resize;
+                reglTextureCube._reglType = "textureCube";
+                reglTextureCube._texture = texture;
+                if (config2.profile) {
+                  reglTextureCube.stats = texture.stats;
+                }
+                reglTextureCube.destroy = function() {
+                  texture.decRef();
+                };
+                return reglTextureCube;
+              }
+              function destroyTextures() {
+                for (var i2 = 0; i2 < numTexUnits; ++i2) {
+                  gl2.activeTexture(GL_TEXTURE0$1 + i2);
+                  gl2.bindTexture(GL_TEXTURE_2D$1, null);
+                  textureUnits[i2] = null;
+                }
+                values(textureSet).forEach(destroy);
+                stats2.cubeCount = 0;
+                stats2.textureCount = 0;
+              }
+              if (config2.profile) {
+                stats2.getTotalTextureSize = function() {
+                  var total = 0;
+                  Object.keys(textureSet).forEach(function(key) {
+                    total += textureSet[key].stats.size;
+                  });
+                  return total;
+                };
+              }
+              function restoreTextures() {
+                for (var i2 = 0; i2 < numTexUnits; ++i2) {
+                  var tex = textureUnits[i2];
+                  if (tex) {
+                    tex.bindCount = 0;
+                    tex.unit = -1;
+                    textureUnits[i2] = null;
+                  }
+                }
+                values(textureSet).forEach(function(texture) {
+                  texture.texture = gl2.createTexture();
+                  gl2.bindTexture(texture.target, texture.texture);
+                  for (var i22 = 0; i22 < 32; ++i22) {
+                    if ((texture.mipmask & 1 << i22) === 0) {
+                      continue;
+                    }
+                    if (texture.target === GL_TEXTURE_2D$1) {
+                      gl2.texImage2D(
+                        GL_TEXTURE_2D$1,
+                        i22,
+                        texture.internalformat,
+                        texture.width >> i22,
+                        texture.height >> i22,
+                        0,
+                        texture.internalformat,
+                        texture.type,
+                        null
+                      );
+                    } else {
+                      for (var j2 = 0; j2 < 6; ++j2) {
+                        gl2.texImage2D(
+                          GL_TEXTURE_CUBE_MAP_POSITIVE_X$1 + j2,
+                          i22,
+                          texture.internalformat,
+                          texture.width >> i22,
+                          texture.height >> i22,
+                          0,
+                          texture.internalformat,
+                          texture.type,
+                          null
+                        );
+                      }
+                    }
+                  }
+                  setTexInfo(texture.texInfo, texture.target);
+                });
+              }
+              function refreshTextures() {
+                for (var i2 = 0; i2 < numTexUnits; ++i2) {
+                  var tex = textureUnits[i2];
+                  if (tex) {
+                    tex.bindCount = 0;
+                    tex.unit = -1;
+                    textureUnits[i2] = null;
+                  }
+                  gl2.activeTexture(GL_TEXTURE0$1 + i2);
+                  gl2.bindTexture(GL_TEXTURE_2D$1, null);
+                  gl2.bindTexture(GL_TEXTURE_CUBE_MAP$1, null);
+                }
+              }
+              return {
+                create2D: createTexture2D,
+                createCube: createTextureCube,
+                clear: destroyTextures,
+                getTexture: function(wrapper) {
+                  return null;
+                },
+                restore: restoreTextures,
+                refresh: refreshTextures
+              };
+            }
+            var GL_RENDERBUFFER = 36161;
+            var GL_RGBA4$1 = 32854;
+            var GL_RGB5_A1$1 = 32855;
+            var GL_RGB565$1 = 36194;
+            var GL_DEPTH_COMPONENT16 = 33189;
+            var GL_STENCIL_INDEX8 = 36168;
+            var GL_DEPTH_STENCIL$1 = 34041;
+            var GL_SRGB8_ALPHA8_EXT = 35907;
+            var GL_RGBA32F_EXT = 34836;
+            var GL_RGBA16F_EXT = 34842;
+            var GL_RGB16F_EXT = 34843;
+            var FORMAT_SIZES = [];
+            FORMAT_SIZES[GL_RGBA4$1] = 2;
+            FORMAT_SIZES[GL_RGB5_A1$1] = 2;
+            FORMAT_SIZES[GL_RGB565$1] = 2;
+            FORMAT_SIZES[GL_DEPTH_COMPONENT16] = 2;
+            FORMAT_SIZES[GL_STENCIL_INDEX8] = 1;
+            FORMAT_SIZES[GL_DEPTH_STENCIL$1] = 4;
+            FORMAT_SIZES[GL_SRGB8_ALPHA8_EXT] = 4;
+            FORMAT_SIZES[GL_RGBA32F_EXT] = 16;
+            FORMAT_SIZES[GL_RGBA16F_EXT] = 8;
+            FORMAT_SIZES[GL_RGB16F_EXT] = 6;
+            function getRenderbufferSize(format, width, height) {
+              return FORMAT_SIZES[format] * width * height;
+            }
+            var wrapRenderbuffers = function(gl2, extensions, limits, stats2, config2) {
+              var formatTypes = {
+                "rgba4": GL_RGBA4$1,
+                "rgb565": GL_RGB565$1,
+                "rgb5 a1": GL_RGB5_A1$1,
+                "depth": GL_DEPTH_COMPONENT16,
+                "stencil": GL_STENCIL_INDEX8,
+                "depth stencil": GL_DEPTH_STENCIL$1
+              };
+              if (extensions.ext_srgb) {
+                formatTypes["srgba"] = GL_SRGB8_ALPHA8_EXT;
+              }
+              if (extensions.ext_color_buffer_half_float) {
+                formatTypes["rgba16f"] = GL_RGBA16F_EXT;
+                formatTypes["rgb16f"] = GL_RGB16F_EXT;
+              }
+              if (extensions.webgl_color_buffer_float) {
+                formatTypes["rgba32f"] = GL_RGBA32F_EXT;
+              }
+              var formatTypesInvert = [];
+              Object.keys(formatTypes).forEach(function(key) {
+                var val = formatTypes[key];
+                formatTypesInvert[val] = key;
+              });
+              var renderbufferCount = 0;
+              var renderbufferSet = {};
+              function REGLRenderbuffer(renderbuffer) {
+                this.id = renderbufferCount++;
+                this.refCount = 1;
+                this.renderbuffer = renderbuffer;
+                this.format = GL_RGBA4$1;
+                this.width = 0;
+                this.height = 0;
+                if (config2.profile) {
+                  this.stats = { size: 0 };
+                }
+              }
+              REGLRenderbuffer.prototype.decRef = function() {
+                if (--this.refCount <= 0) {
+                  destroy(this);
+                }
+              };
+              function destroy(rb2) {
+                var handle = rb2.renderbuffer;
+                gl2.bindRenderbuffer(GL_RENDERBUFFER, null);
+                gl2.deleteRenderbuffer(handle);
+                rb2.renderbuffer = null;
+                rb2.refCount = 0;
+                delete renderbufferSet[rb2.id];
+                stats2.renderbufferCount--;
+              }
+              function createRenderbuffer(a2, b2) {
+                var renderbuffer = new REGLRenderbuffer(gl2.createRenderbuffer());
+                renderbufferSet[renderbuffer.id] = renderbuffer;
+                stats2.renderbufferCount++;
+                function reglRenderbuffer(a22, b22) {
+                  var w2 = 0;
+                  var h2 = 0;
+                  var format = GL_RGBA4$1;
+                  if (typeof a22 === "object" && a22) {
+                    var options = a22;
+                    if ("shape" in options) {
+                      var shape = options.shape;
+                      w2 = shape[0] | 0;
+                      h2 = shape[1] | 0;
+                    } else {
+                      if ("radius" in options) {
+                        w2 = h2 = options.radius | 0;
+                      }
+                      if ("width" in options) {
+                        w2 = options.width | 0;
+                      }
+                      if ("height" in options) {
+                        h2 = options.height | 0;
+                      }
+                    }
+                    if ("format" in options) {
+                      format = formatTypes[options.format];
+                    }
+                  } else if (typeof a22 === "number") {
+                    w2 = a22 | 0;
+                    if (typeof b22 === "number") {
+                      h2 = b22 | 0;
+                    } else {
+                      h2 = w2;
+                    }
+                  } else if (!a22) {
+                    w2 = h2 = 1;
+                  } else ;
+                  if (w2 === renderbuffer.width && h2 === renderbuffer.height && format === renderbuffer.format) {
+                    return;
+                  }
+                  reglRenderbuffer.width = renderbuffer.width = w2;
+                  reglRenderbuffer.height = renderbuffer.height = h2;
+                  renderbuffer.format = format;
+                  gl2.bindRenderbuffer(GL_RENDERBUFFER, renderbuffer.renderbuffer);
+                  gl2.renderbufferStorage(GL_RENDERBUFFER, format, w2, h2);
+                  if (config2.profile) {
+                    renderbuffer.stats.size = getRenderbufferSize(renderbuffer.format, renderbuffer.width, renderbuffer.height);
+                  }
+                  reglRenderbuffer.format = formatTypesInvert[renderbuffer.format];
+                  return reglRenderbuffer;
+                }
+                function resize(w_, h_) {
+                  var w2 = w_ | 0;
+                  var h2 = h_ | 0 || w2;
+                  if (w2 === renderbuffer.width && h2 === renderbuffer.height) {
+                    return reglRenderbuffer;
+                  }
+                  reglRenderbuffer.width = renderbuffer.width = w2;
+                  reglRenderbuffer.height = renderbuffer.height = h2;
+                  gl2.bindRenderbuffer(GL_RENDERBUFFER, renderbuffer.renderbuffer);
+                  gl2.renderbufferStorage(GL_RENDERBUFFER, renderbuffer.format, w2, h2);
+                  if (config2.profile) {
+                    renderbuffer.stats.size = getRenderbufferSize(
+                      renderbuffer.format,
+                      renderbuffer.width,
+                      renderbuffer.height
+                    );
+                  }
+                  return reglRenderbuffer;
+                }
+                reglRenderbuffer(a2, b2);
+                reglRenderbuffer.resize = resize;
+                reglRenderbuffer._reglType = "renderbuffer";
+                reglRenderbuffer._renderbuffer = renderbuffer;
+                if (config2.profile) {
+                  reglRenderbuffer.stats = renderbuffer.stats;
+                }
+                reglRenderbuffer.destroy = function() {
+                  renderbuffer.decRef();
+                };
+                return reglRenderbuffer;
+              }
+              if (config2.profile) {
+                stats2.getTotalRenderbufferSize = function() {
+                  var total = 0;
+                  Object.keys(renderbufferSet).forEach(function(key) {
+                    total += renderbufferSet[key].stats.size;
+                  });
+                  return total;
+                };
+              }
+              function restoreRenderbuffers() {
+                values(renderbufferSet).forEach(function(rb2) {
+                  rb2.renderbuffer = gl2.createRenderbuffer();
+                  gl2.bindRenderbuffer(GL_RENDERBUFFER, rb2.renderbuffer);
+                  gl2.renderbufferStorage(GL_RENDERBUFFER, rb2.format, rb2.width, rb2.height);
+                });
+                gl2.bindRenderbuffer(GL_RENDERBUFFER, null);
+              }
+              return {
+                create: createRenderbuffer,
+                clear: function() {
+                  values(renderbufferSet).forEach(destroy);
+                },
+                restore: restoreRenderbuffers
+              };
+            };
+            var GL_FRAMEBUFFER$1 = 36160;
+            var GL_RENDERBUFFER$1 = 36161;
+            var GL_TEXTURE_2D$2 = 3553;
+            var GL_TEXTURE_CUBE_MAP_POSITIVE_X$2 = 34069;
+            var GL_COLOR_ATTACHMENT0$1 = 36064;
+            var GL_DEPTH_ATTACHMENT = 36096;
+            var GL_STENCIL_ATTACHMENT = 36128;
+            var GL_DEPTH_STENCIL_ATTACHMENT = 33306;
+            var GL_FRAMEBUFFER_COMPLETE$1 = 36053;
+            var GL_HALF_FLOAT_OES$1 = 36193;
+            var GL_UNSIGNED_BYTE$5 = 5121;
+            var GL_FLOAT$4 = 5126;
+            var GL_RGB$1 = 6407;
+            var GL_RGBA$2 = 6408;
+            var textureFormatChannels = [];
+            textureFormatChannels[GL_RGBA$2] = 4;
+            textureFormatChannels[GL_RGB$1] = 3;
+            var textureTypeSizes = [];
+            textureTypeSizes[GL_UNSIGNED_BYTE$5] = 1;
+            textureTypeSizes[GL_FLOAT$4] = 4;
+            textureTypeSizes[GL_HALF_FLOAT_OES$1] = 2;
+            function wrapFBOState(gl2, extensions, limits, textureState, renderbufferState, stats2) {
+              var framebufferState = {
+                cur: null,
+                next: null,
+                dirty: false,
+                setFBO: null
+              };
+              var colorTextureFormats = ["rgba"];
+              var colorRenderbufferFormats = ["rgba4", "rgb565", "rgb5 a1"];
+              if (extensions.ext_srgb) {
+                colorRenderbufferFormats.push("srgba");
+              }
+              if (extensions.ext_color_buffer_half_float) {
+                colorRenderbufferFormats.push("rgba16f", "rgb16f");
+              }
+              if (extensions.webgl_color_buffer_float) {
+                colorRenderbufferFormats.push("rgba32f");
+              }
+              if (extensions.oes_texture_half_float) ;
+              if (extensions.oes_texture_float) ;
+              function FramebufferAttachment(target, texture, renderbuffer) {
+                this.target = target;
+                this.texture = texture;
+                this.renderbuffer = renderbuffer;
+                var w2 = 0;
+                var h2 = 0;
+                if (texture) {
+                  w2 = texture.width;
+                  h2 = texture.height;
+                } else if (renderbuffer) {
+                  w2 = renderbuffer.width;
+                  h2 = renderbuffer.height;
+                }
+                this.width = w2;
+                this.height = h2;
+              }
+              function decRef(attachment) {
+                if (attachment) {
+                  if (attachment.texture) {
+                    attachment.texture._texture.decRef();
+                  }
+                  if (attachment.renderbuffer) {
+                    attachment.renderbuffer._renderbuffer.decRef();
+                  }
+                }
+              }
+              function incRefAndCheckShape(attachment, width, height) {
+                if (!attachment) {
+                  return;
+                }
+                if (attachment.texture) {
+                  var texture = attachment.texture._texture;
+                  Math.max(1, texture.width);
+                  Math.max(1, texture.height);
+                  texture.refCount += 1;
+                } else {
+                  var renderbuffer = attachment.renderbuffer._renderbuffer;
+                  renderbuffer.refCount += 1;
+                }
+              }
+              function attach(location2, attachment) {
+                if (attachment) {
+                  if (attachment.texture) {
+                    gl2.framebufferTexture2D(
+                      GL_FRAMEBUFFER$1,
+                      location2,
+                      attachment.target,
+                      attachment.texture._texture.texture,
+                      0
+                    );
+                  } else {
+                    gl2.framebufferRenderbuffer(
+                      GL_FRAMEBUFFER$1,
+                      location2,
+                      GL_RENDERBUFFER$1,
+                      attachment.renderbuffer._renderbuffer.renderbuffer
+                    );
+                  }
+                }
+              }
+              function parseAttachment(attachment) {
+                var target = GL_TEXTURE_2D$2;
+                var texture = null;
+                var renderbuffer = null;
+                var data = attachment;
+                if (typeof attachment === "object") {
+                  data = attachment.data;
+                  if ("target" in attachment) {
+                    target = attachment.target | 0;
+                  }
+                }
+                var type = data._reglType;
+                if (type === "texture2d") {
+                  texture = data;
+                } else if (type === "textureCube") {
+                  texture = data;
+                } else if (type === "renderbuffer") {
+                  renderbuffer = data;
+                  target = GL_RENDERBUFFER$1;
+                } else ;
+                return new FramebufferAttachment(target, texture, renderbuffer);
+              }
+              function allocAttachment(width, height, isTexture, format, type) {
+                if (isTexture) {
+                  var texture = textureState.create2D({
+                    width,
+                    height,
+                    format,
+                    type
+                  });
+                  texture._texture.refCount = 0;
+                  return new FramebufferAttachment(GL_TEXTURE_2D$2, texture, null);
+                } else {
+                  var rb2 = renderbufferState.create({
+                    width,
+                    height,
+                    format
+                  });
+                  rb2._renderbuffer.refCount = 0;
+                  return new FramebufferAttachment(GL_RENDERBUFFER$1, null, rb2);
+                }
+              }
+              function unwrapAttachment(attachment) {
+                return attachment && (attachment.texture || attachment.renderbuffer);
+              }
+              function resizeAttachment(attachment, w2, h2) {
+                if (attachment) {
+                  if (attachment.texture) {
+                    attachment.texture.resize(w2, h2);
+                  } else if (attachment.renderbuffer) {
+                    attachment.renderbuffer.resize(w2, h2);
+                  }
+                  attachment.width = w2;
+                  attachment.height = h2;
+                }
+              }
+              var framebufferCount = 0;
+              var framebufferSet = {};
+              function REGLFramebuffer() {
+                this.id = framebufferCount++;
+                framebufferSet[this.id] = this;
+                this.framebuffer = gl2.createFramebuffer();
+                this.width = 0;
+                this.height = 0;
+                this.colorAttachments = [];
+                this.depthAttachment = null;
+                this.stencilAttachment = null;
+                this.depthStencilAttachment = null;
+              }
+              function decFBORefs(framebuffer) {
+                framebuffer.colorAttachments.forEach(decRef);
+                decRef(framebuffer.depthAttachment);
+                decRef(framebuffer.stencilAttachment);
+                decRef(framebuffer.depthStencilAttachment);
+              }
+              function destroy(framebuffer) {
+                var handle = framebuffer.framebuffer;
+                gl2.deleteFramebuffer(handle);
+                framebuffer.framebuffer = null;
+                stats2.framebufferCount--;
+                delete framebufferSet[framebuffer.id];
+              }
+              function updateFramebuffer(framebuffer) {
+                var i2;
+                gl2.bindFramebuffer(GL_FRAMEBUFFER$1, framebuffer.framebuffer);
+                var colorAttachments = framebuffer.colorAttachments;
+                for (i2 = 0; i2 < colorAttachments.length; ++i2) {
+                  attach(GL_COLOR_ATTACHMENT0$1 + i2, colorAttachments[i2]);
+                }
+                for (i2 = colorAttachments.length; i2 < limits.maxColorAttachments; ++i2) {
+                  gl2.framebufferTexture2D(
+                    GL_FRAMEBUFFER$1,
+                    GL_COLOR_ATTACHMENT0$1 + i2,
+                    GL_TEXTURE_2D$2,
+                    null,
+                    0
+                  );
+                }
+                gl2.framebufferTexture2D(
+                  GL_FRAMEBUFFER$1,
+                  GL_DEPTH_STENCIL_ATTACHMENT,
+                  GL_TEXTURE_2D$2,
+                  null,
+                  0
+                );
+                gl2.framebufferTexture2D(
+                  GL_FRAMEBUFFER$1,
+                  GL_DEPTH_ATTACHMENT,
+                  GL_TEXTURE_2D$2,
+                  null,
+                  0
+                );
+                gl2.framebufferTexture2D(
+                  GL_FRAMEBUFFER$1,
+                  GL_STENCIL_ATTACHMENT,
+                  GL_TEXTURE_2D$2,
+                  null,
+                  0
+                );
+                attach(GL_DEPTH_ATTACHMENT, framebuffer.depthAttachment);
+                attach(GL_STENCIL_ATTACHMENT, framebuffer.stencilAttachment);
+                attach(GL_DEPTH_STENCIL_ATTACHMENT, framebuffer.depthStencilAttachment);
+                var status = gl2.checkFramebufferStatus(GL_FRAMEBUFFER$1);
+                if (!gl2.isContextLost() && status !== GL_FRAMEBUFFER_COMPLETE$1) ;
+                gl2.bindFramebuffer(GL_FRAMEBUFFER$1, framebufferState.next ? framebufferState.next.framebuffer : null);
+                framebufferState.cur = framebufferState.next;
+                gl2.getError();
+              }
+              function createFBO(a0, a1) {
+                var framebuffer = new REGLFramebuffer();
+                stats2.framebufferCount++;
+                function reglFramebuffer(a2, b2) {
+                  var i2;
+                  var width = 0;
+                  var height = 0;
+                  var needsDepth = true;
+                  var needsStencil = true;
+                  var colorBuffer = null;
+                  var colorTexture = true;
+                  var colorFormat = "rgba";
+                  var colorType = "uint8";
+                  var colorCount = 1;
+                  var depthBuffer = null;
+                  var stencilBuffer = null;
+                  var depthStencilBuffer = null;
+                  var depthStencilTexture = false;
+                  if (typeof a2 === "number") {
+                    width = a2 | 0;
+                    height = b2 | 0 || width;
+                  } else if (!a2) {
+                    width = height = 1;
+                  } else {
+                    var options = a2;
+                    if ("shape" in options) {
+                      var shape = options.shape;
+                      width = shape[0];
+                      height = shape[1];
+                    } else {
+                      if ("radius" in options) {
+                        width = height = options.radius;
+                      }
+                      if ("width" in options) {
+                        width = options.width;
+                      }
+                      if ("height" in options) {
+                        height = options.height;
+                      }
+                    }
+                    if ("color" in options || "colors" in options) {
+                      colorBuffer = options.color || options.colors;
+                    }
+                    if (!colorBuffer) {
+                      if ("colorCount" in options) {
+                        colorCount = options.colorCount | 0;
+                      }
+                      if ("colorTexture" in options) {
+                        colorTexture = !!options.colorTexture;
+                        colorFormat = "rgba4";
+                      }
+                      if ("colorType" in options) {
+                        colorType = options.colorType;
+                        if (!colorTexture) {
+                          if (colorType === "half float" || colorType === "float16") {
+                            colorFormat = "rgba16f";
+                          } else if (colorType === "float" || colorType === "float32") {
+                            colorFormat = "rgba32f";
+                          }
+                        }
+                      }
+                      if ("colorFormat" in options) {
+                        colorFormat = options.colorFormat;
+                        if (colorTextureFormats.indexOf(colorFormat) >= 0) {
+                          colorTexture = true;
+                        } else if (colorRenderbufferFormats.indexOf(colorFormat) >= 0) {
+                          colorTexture = false;
+                        } else ;
+                      }
+                    }
+                    if ("depthTexture" in options || "depthStencilTexture" in options) {
+                      depthStencilTexture = !!(options.depthTexture || options.depthStencilTexture);
+                    }
+                    if ("depth" in options) {
+                      if (typeof options.depth === "boolean") {
+                        needsDepth = options.depth;
+                      } else {
+                        depthBuffer = options.depth;
+                        needsStencil = false;
+                      }
+                    }
+                    if ("stencil" in options) {
+                      if (typeof options.stencil === "boolean") {
+                        needsStencil = options.stencil;
+                      } else {
+                        stencilBuffer = options.stencil;
+                        needsDepth = false;
+                      }
+                    }
+                    if ("depthStencil" in options) {
+                      if (typeof options.depthStencil === "boolean") {
+                        needsDepth = needsStencil = options.depthStencil;
+                      } else {
+                        depthStencilBuffer = options.depthStencil;
+                        needsDepth = false;
+                        needsStencil = false;
+                      }
+                    }
+                  }
+                  var colorAttachments = null;
+                  var depthAttachment = null;
+                  var stencilAttachment = null;
+                  var depthStencilAttachment = null;
+                  if (Array.isArray(colorBuffer)) {
+                    colorAttachments = colorBuffer.map(parseAttachment);
+                  } else if (colorBuffer) {
+                    colorAttachments = [parseAttachment(colorBuffer)];
+                  } else {
+                    colorAttachments = new Array(colorCount);
+                    for (i2 = 0; i2 < colorCount; ++i2) {
+                      colorAttachments[i2] = allocAttachment(
+                        width,
+                        height,
+                        colorTexture,
+                        colorFormat,
+                        colorType
+                      );
+                    }
+                  }
+                  width = width || colorAttachments[0].width;
+                  height = height || colorAttachments[0].height;
+                  if (depthBuffer) {
+                    depthAttachment = parseAttachment(depthBuffer);
+                  } else if (needsDepth && !needsStencil) {
+                    depthAttachment = allocAttachment(
+                      width,
+                      height,
+                      depthStencilTexture,
+                      "depth",
+                      "uint32"
+                    );
+                  }
+                  if (stencilBuffer) {
+                    stencilAttachment = parseAttachment(stencilBuffer);
+                  } else if (needsStencil && !needsDepth) {
+                    stencilAttachment = allocAttachment(
+                      width,
+                      height,
+                      false,
+                      "stencil",
+                      "uint8"
+                    );
+                  }
+                  if (depthStencilBuffer) {
+                    depthStencilAttachment = parseAttachment(depthStencilBuffer);
+                  } else if (!depthBuffer && !stencilBuffer && needsStencil && needsDepth) {
+                    depthStencilAttachment = allocAttachment(
+                      width,
+                      height,
+                      depthStencilTexture,
+                      "depth stencil",
+                      "depth stencil"
+                    );
+                  }
+                  for (i2 = 0; i2 < colorAttachments.length; ++i2) {
+                    incRefAndCheckShape(colorAttachments[i2]);
+                    if (colorAttachments[i2] && colorAttachments[i2].texture) {
+                      textureFormatChannels[colorAttachments[i2].texture._texture.format] * textureTypeSizes[colorAttachments[i2].texture._texture.type];
+                    }
+                  }
+                  incRefAndCheckShape(depthAttachment);
+                  incRefAndCheckShape(stencilAttachment);
+                  incRefAndCheckShape(depthStencilAttachment);
+                  decFBORefs(framebuffer);
+                  framebuffer.width = width;
+                  framebuffer.height = height;
+                  framebuffer.colorAttachments = colorAttachments;
+                  framebuffer.depthAttachment = depthAttachment;
+                  framebuffer.stencilAttachment = stencilAttachment;
+                  framebuffer.depthStencilAttachment = depthStencilAttachment;
+                  reglFramebuffer.color = colorAttachments.map(unwrapAttachment);
+                  reglFramebuffer.depth = unwrapAttachment(depthAttachment);
+                  reglFramebuffer.stencil = unwrapAttachment(stencilAttachment);
+                  reglFramebuffer.depthStencil = unwrapAttachment(depthStencilAttachment);
+                  reglFramebuffer.width = framebuffer.width;
+                  reglFramebuffer.height = framebuffer.height;
+                  updateFramebuffer(framebuffer);
+                  return reglFramebuffer;
+                }
+                function resize(w_, h_) {
+                  var w2 = Math.max(w_ | 0, 1);
+                  var h2 = Math.max(h_ | 0 || w2, 1);
+                  if (w2 === framebuffer.width && h2 === framebuffer.height) {
+                    return reglFramebuffer;
+                  }
+                  var colorAttachments = framebuffer.colorAttachments;
+                  for (var i2 = 0; i2 < colorAttachments.length; ++i2) {
+                    resizeAttachment(colorAttachments[i2], w2, h2);
+                  }
+                  resizeAttachment(framebuffer.depthAttachment, w2, h2);
+                  resizeAttachment(framebuffer.stencilAttachment, w2, h2);
+                  resizeAttachment(framebuffer.depthStencilAttachment, w2, h2);
+                  framebuffer.width = reglFramebuffer.width = w2;
+                  framebuffer.height = reglFramebuffer.height = h2;
+                  updateFramebuffer(framebuffer);
+                  return reglFramebuffer;
+                }
+                reglFramebuffer(a0, a1);
+                return extend2(reglFramebuffer, {
+                  resize,
+                  _reglType: "framebuffer",
+                  _framebuffer: framebuffer,
+                  destroy: function() {
+                    destroy(framebuffer);
+                    decFBORefs(framebuffer);
+                  },
+                  use: function(block) {
+                    framebufferState.setFBO({
+                      framebuffer: reglFramebuffer
+                    }, block);
+                  }
+                });
+              }
+              function createCubeFBO(options) {
+                var faces = Array(6);
+                function reglFramebufferCube(a2) {
+                  var i2;
+                  var params = {
+                    color: null
+                  };
+                  var radius = 0;
+                  var colorBuffer = null;
+                  var colorFormat = "rgba";
+                  var colorType = "uint8";
+                  var colorCount = 1;
+                  if (typeof a2 === "number") {
+                    radius = a2 | 0;
+                  } else if (!a2) {
+                    radius = 1;
+                  } else {
+                    var options2 = a2;
+                    if ("shape" in options2) {
+                      var shape = options2.shape;
+                      radius = shape[0];
+                    } else {
+                      if ("radius" in options2) {
+                        radius = options2.radius | 0;
+                      }
+                      if ("width" in options2) {
+                        radius = options2.width | 0;
+                      } else if ("height" in options2) {
+                        radius = options2.height | 0;
+                      }
+                    }
+                    if ("color" in options2 || "colors" in options2) {
+                      colorBuffer = options2.color || options2.colors;
+                    }
+                    if (!colorBuffer) {
+                      if ("colorCount" in options2) {
+                        colorCount = options2.colorCount | 0;
+                      }
+                      if ("colorType" in options2) {
+                        colorType = options2.colorType;
+                      }
+                      if ("colorFormat" in options2) {
+                        colorFormat = options2.colorFormat;
+                      }
+                    }
+                    if ("depth" in options2) {
+                      params.depth = options2.depth;
+                    }
+                    if ("stencil" in options2) {
+                      params.stencil = options2.stencil;
+                    }
+                    if ("depthStencil" in options2) {
+                      params.depthStencil = options2.depthStencil;
+                    }
+                  }
+                  var colorCubes;
+                  if (colorBuffer) {
+                    if (Array.isArray(colorBuffer)) {
+                      colorCubes = [];
+                      for (i2 = 0; i2 < colorBuffer.length; ++i2) {
+                        colorCubes[i2] = colorBuffer[i2];
+                      }
+                    } else {
+                      colorCubes = [colorBuffer];
+                    }
+                  } else {
+                    colorCubes = Array(colorCount);
+                    var cubeMapParams = {
+                      radius,
+                      format: colorFormat,
+                      type: colorType
+                    };
+                    for (i2 = 0; i2 < colorCount; ++i2) {
+                      colorCubes[i2] = textureState.createCube(cubeMapParams);
+                    }
+                  }
+                  params.color = Array(colorCubes.length);
+                  for (i2 = 0; i2 < colorCubes.length; ++i2) {
+                    var cube = colorCubes[i2];
+                    radius = radius || cube.width;
+                    params.color[i2] = {
+                      target: GL_TEXTURE_CUBE_MAP_POSITIVE_X$2,
+                      data: colorCubes[i2]
+                    };
+                  }
+                  for (i2 = 0; i2 < 6; ++i2) {
+                    for (var j2 = 0; j2 < colorCubes.length; ++j2) {
+                      params.color[j2].target = GL_TEXTURE_CUBE_MAP_POSITIVE_X$2 + i2;
+                    }
+                    if (i2 > 0) {
+                      params.depth = faces[0].depth;
+                      params.stencil = faces[0].stencil;
+                      params.depthStencil = faces[0].depthStencil;
+                    }
+                    if (faces[i2]) {
+                      faces[i2](params);
+                    } else {
+                      faces[i2] = createFBO(params);
+                    }
+                  }
+                  return extend2(reglFramebufferCube, {
+                    width: radius,
+                    height: radius,
+                    color: colorCubes
+                  });
+                }
+                function resize(radius_) {
+                  var i2;
+                  var radius = radius_ | 0;
+                  if (radius === reglFramebufferCube.width) {
+                    return reglFramebufferCube;
+                  }
+                  var colors = reglFramebufferCube.color;
+                  for (i2 = 0; i2 < colors.length; ++i2) {
+                    colors[i2].resize(radius);
+                  }
+                  for (i2 = 0; i2 < 6; ++i2) {
+                    faces[i2].resize(radius);
+                  }
+                  reglFramebufferCube.width = reglFramebufferCube.height = radius;
+                  return reglFramebufferCube;
+                }
+                reglFramebufferCube(options);
+                return extend2(reglFramebufferCube, {
+                  faces,
+                  resize,
+                  _reglType: "framebufferCube",
+                  destroy: function() {
+                    faces.forEach(function(f2) {
+                      f2.destroy();
+                    });
+                  }
+                });
+              }
+              function restoreFramebuffers() {
+                framebufferState.cur = null;
+                framebufferState.next = null;
+                framebufferState.dirty = true;
+                values(framebufferSet).forEach(function(fb2) {
+                  fb2.framebuffer = gl2.createFramebuffer();
+                  updateFramebuffer(fb2);
+                });
+              }
+              return extend2(framebufferState, {
+                getFramebuffer: function(object) {
+                  if (typeof object === "function" && object._reglType === "framebuffer") {
+                    var fbo = object._framebuffer;
+                    if (fbo instanceof REGLFramebuffer) {
+                      return fbo;
+                    }
+                  }
+                  return null;
+                },
+                create: createFBO,
+                createCube: createCubeFBO,
+                clear: function() {
+                  values(framebufferSet).forEach(destroy);
+                },
+                restore: restoreFramebuffers
+              });
+            }
+            var GL_FLOAT$5 = 5126;
+            var GL_ARRAY_BUFFER$1 = 34962;
+            var GL_ELEMENT_ARRAY_BUFFER$1 = 34963;
+            function AttributeRecord() {
+              this.state = 0;
+              this.x = 0;
+              this.y = 0;
+              this.z = 0;
+              this.w = 0;
+              this.buffer = null;
+              this.size = 0;
+              this.normalized = false;
+              this.type = GL_FLOAT$5;
+              this.offset = 0;
+              this.stride = 0;
+              this.divisor = 0;
+            }
+            function wrapAttributeState(gl2, extensions, limits, stats2, bufferState, elementState, drawState) {
+              var NUM_ATTRIBUTES = limits.maxAttributes;
+              var attributeBindings = new Array(NUM_ATTRIBUTES);
+              for (var i2 = 0; i2 < NUM_ATTRIBUTES; ++i2) {
+                attributeBindings[i2] = new AttributeRecord();
+              }
+              var vaoCount = 0;
+              var vaoSet = {};
+              var state = {
+                Record: AttributeRecord,
+                scope: {},
+                state: attributeBindings,
+                currentVAO: null,
+                targetVAO: null,
+                restore: extVAO() ? restoreVAO : function() {
+                },
+                createVAO,
+                getVAO,
+                destroyBuffer,
+                setVAO: extVAO() ? setVAOEXT : setVAOEmulated,
+                clear: extVAO() ? destroyVAOEXT : function() {
+                }
+              };
+              function destroyBuffer(buffer) {
+                for (var i22 = 0; i22 < attributeBindings.length; ++i22) {
+                  var record = attributeBindings[i22];
+                  if (record.buffer === buffer) {
+                    gl2.disableVertexAttribArray(i22);
+                    record.buffer = null;
+                  }
+                }
+              }
+              function extVAO() {
+                return extensions.oes_vertex_array_object;
+              }
+              function extInstanced() {
+                return extensions.angle_instanced_arrays;
+              }
+              function getVAO(vao) {
+                if (typeof vao === "function" && vao._vao) {
+                  return vao._vao;
+                }
+                return null;
+              }
+              function setVAOEXT(vao) {
+                if (vao === state.currentVAO) {
+                  return;
+                }
+                var ext = extVAO();
+                if (vao) {
+                  ext.bindVertexArrayOES(vao.vao);
+                } else {
+                  ext.bindVertexArrayOES(null);
+                }
+                state.currentVAO = vao;
+              }
+              function setVAOEmulated(vao) {
+                if (vao === state.currentVAO) {
+                  return;
+                }
+                if (vao) {
+                  vao.bindAttrs();
+                } else {
+                  var exti = extInstanced();
+                  for (var i22 = 0; i22 < attributeBindings.length; ++i22) {
+                    var binding = attributeBindings[i22];
+                    if (binding.buffer) {
+                      gl2.enableVertexAttribArray(i22);
+                      binding.buffer.bind();
+                      gl2.vertexAttribPointer(i22, binding.size, binding.type, binding.normalized, binding.stride, binding.offfset);
+                      if (exti && binding.divisor) {
+                        exti.vertexAttribDivisorANGLE(i22, binding.divisor);
+                      }
+                    } else {
+                      gl2.disableVertexAttribArray(i22);
+                      gl2.vertexAttrib4f(i22, binding.x, binding.y, binding.z, binding.w);
+                    }
+                  }
+                  if (drawState.elements) {
+                    gl2.bindBuffer(GL_ELEMENT_ARRAY_BUFFER$1, drawState.elements.buffer.buffer);
+                  } else {
+                    gl2.bindBuffer(GL_ELEMENT_ARRAY_BUFFER$1, null);
+                  }
+                }
+                state.currentVAO = vao;
+              }
+              function destroyVAOEXT() {
+                values(vaoSet).forEach(function(vao) {
+                  vao.destroy();
+                });
+              }
+              function REGLVAO() {
+                this.id = ++vaoCount;
+                this.attributes = [];
+                this.elements = null;
+                this.ownsElements = false;
+                this.count = 0;
+                this.offset = 0;
+                this.instances = -1;
+                this.primitive = 4;
+                var extension = extVAO();
+                if (extension) {
+                  this.vao = extension.createVertexArrayOES();
+                } else {
+                  this.vao = null;
+                }
+                vaoSet[this.id] = this;
+                this.buffers = [];
+              }
+              REGLVAO.prototype.bindAttrs = function() {
+                var exti = extInstanced();
+                var attributes = this.attributes;
+                for (var i22 = 0; i22 < attributes.length; ++i22) {
+                  var attr = attributes[i22];
+                  if (attr.buffer) {
+                    gl2.enableVertexAttribArray(i22);
+                    gl2.bindBuffer(GL_ARRAY_BUFFER$1, attr.buffer.buffer);
+                    gl2.vertexAttribPointer(i22, attr.size, attr.type, attr.normalized, attr.stride, attr.offset);
+                    if (exti && attr.divisor) {
+                      exti.vertexAttribDivisorANGLE(i22, attr.divisor);
+                    }
+                  } else {
+                    gl2.disableVertexAttribArray(i22);
+                    gl2.vertexAttrib4f(i22, attr.x, attr.y, attr.z, attr.w);
+                  }
+                }
+                for (var j2 = attributes.length; j2 < NUM_ATTRIBUTES; ++j2) {
+                  gl2.disableVertexAttribArray(j2);
+                }
+                var elements = elementState.getElements(this.elements);
+                if (elements) {
+                  gl2.bindBuffer(GL_ELEMENT_ARRAY_BUFFER$1, elements.buffer.buffer);
+                } else {
+                  gl2.bindBuffer(GL_ELEMENT_ARRAY_BUFFER$1, null);
+                }
+              };
+              REGLVAO.prototype.refresh = function() {
+                var ext = extVAO();
+                if (ext) {
+                  ext.bindVertexArrayOES(this.vao);
+                  this.bindAttrs();
+                  state.currentVAO = null;
+                  ext.bindVertexArrayOES(null);
+                }
+              };
+              REGLVAO.prototype.destroy = function() {
+                if (this.vao) {
+                  var extension = extVAO();
+                  if (this === state.currentVAO) {
+                    state.currentVAO = null;
+                    extension.bindVertexArrayOES(null);
+                  }
+                  extension.deleteVertexArrayOES(this.vao);
+                  this.vao = null;
+                }
+                if (this.ownsElements) {
+                  this.elements.destroy();
+                  this.elements = null;
+                  this.ownsElements = false;
+                }
+                if (vaoSet[this.id]) {
+                  delete vaoSet[this.id];
+                  stats2.vaoCount -= 1;
+                }
+              };
+              function restoreVAO() {
+                var ext = extVAO();
+                if (ext) {
+                  values(vaoSet).forEach(function(vao) {
+                    vao.refresh();
+                  });
+                }
+              }
+              function createVAO(_attr) {
+                var vao = new REGLVAO();
+                stats2.vaoCount += 1;
+                function updateVAO(options) {
+                  var attributes;
+                  if (Array.isArray(options)) {
+                    attributes = options;
+                    if (vao.elements && vao.ownsElements) {
+                      vao.elements.destroy();
+                    }
+                    vao.elements = null;
+                    vao.ownsElements = false;
+                    vao.offset = 0;
+                    vao.count = 0;
+                    vao.instances = -1;
+                    vao.primitive = 4;
+                  } else {
+                    if (options.elements) {
+                      var elements = options.elements;
+                      if (vao.ownsElements) {
+                        if (typeof elements === "function" && elements._reglType === "elements") {
+                          vao.elements.destroy();
+                          vao.ownsElements = false;
+                        } else {
+                          vao.elements(elements);
+                          vao.ownsElements = false;
+                        }
+                      } else if (elementState.getElements(options.elements)) {
+                        vao.elements = options.elements;
+                        vao.ownsElements = false;
+                      } else {
+                        vao.elements = elementState.create(options.elements);
+                        vao.ownsElements = true;
+                      }
+                    } else {
+                      vao.elements = null;
+                      vao.ownsElements = false;
+                    }
+                    attributes = options.attributes;
+                    vao.offset = 0;
+                    vao.count = -1;
+                    vao.instances = -1;
+                    vao.primitive = 4;
+                    if (vao.elements) {
+                      vao.count = vao.elements._elements.vertCount;
+                      vao.primitive = vao.elements._elements.primType;
+                    }
+                    if ("offset" in options) {
+                      vao.offset = options.offset | 0;
+                    }
+                    if ("count" in options) {
+                      vao.count = options.count | 0;
+                    }
+                    if ("instances" in options) {
+                      vao.instances = options.instances | 0;
+                    }
+                    if ("primitive" in options) {
+                      vao.primitive = primTypes[options.primitive];
+                    }
+                  }
+                  var bufUpdated = {};
+                  var nattributes = vao.attributes;
+                  nattributes.length = attributes.length;
+                  for (var i22 = 0; i22 < attributes.length; ++i22) {
+                    var spec = attributes[i22];
+                    var rec = nattributes[i22] = new AttributeRecord();
+                    var data = spec.data || spec;
+                    if (Array.isArray(data) || isTypedArray2(data) || isNDArrayLike(data)) {
+                      var buf;
+                      if (vao.buffers[i22]) {
+                        buf = vao.buffers[i22];
+                        if (isTypedArray2(data) && buf._buffer.byteLength >= data.byteLength) {
+                          buf.subdata(data);
+                        } else {
+                          buf.destroy();
+                          vao.buffers[i22] = null;
+                        }
+                      }
+                      if (!vao.buffers[i22]) {
+                        buf = vao.buffers[i22] = bufferState.create(spec, GL_ARRAY_BUFFER$1, false, true);
+                      }
+                      rec.buffer = bufferState.getBuffer(buf);
+                      rec.size = rec.buffer.dimension | 0;
+                      rec.normalized = false;
+                      rec.type = rec.buffer.dtype;
+                      rec.offset = 0;
+                      rec.stride = 0;
+                      rec.divisor = 0;
+                      rec.state = 1;
+                      bufUpdated[i22] = 1;
+                    } else if (bufferState.getBuffer(spec)) {
+                      rec.buffer = bufferState.getBuffer(spec);
+                      rec.size = rec.buffer.dimension | 0;
+                      rec.normalized = false;
+                      rec.type = rec.buffer.dtype;
+                      rec.offset = 0;
+                      rec.stride = 0;
+                      rec.divisor = 0;
+                      rec.state = 1;
+                    } else if (bufferState.getBuffer(spec.buffer)) {
+                      rec.buffer = bufferState.getBuffer(spec.buffer);
+                      rec.size = (+spec.size || rec.buffer.dimension) | 0;
+                      rec.normalized = !!spec.normalized || false;
+                      if ("type" in spec) {
+                        rec.type = glTypes[spec.type];
+                      } else {
+                        rec.type = rec.buffer.dtype;
+                      }
+                      rec.offset = (spec.offset || 0) | 0;
+                      rec.stride = (spec.stride || 0) | 0;
+                      rec.divisor = (spec.divisor || 0) | 0;
+                      rec.state = 1;
+                    } else if ("x" in spec) {
+                      rec.x = +spec.x || 0;
+                      rec.y = +spec.y || 0;
+                      rec.z = +spec.z || 0;
+                      rec.w = +spec.w || 0;
+                      rec.state = 2;
+                    } else ;
+                  }
+                  for (var j2 = 0; j2 < vao.buffers.length; ++j2) {
+                    if (!bufUpdated[j2] && vao.buffers[j2]) {
+                      vao.buffers[j2].destroy();
+                      vao.buffers[j2] = null;
+                    }
+                  }
+                  vao.refresh();
+                  return updateVAO;
+                }
+                updateVAO.destroy = function() {
+                  for (var j2 = 0; j2 < vao.buffers.length; ++j2) {
+                    if (vao.buffers[j2]) {
+                      vao.buffers[j2].destroy();
+                    }
+                  }
+                  vao.buffers.length = 0;
+                  if (vao.ownsElements) {
+                    vao.elements.destroy();
+                    vao.elements = null;
+                    vao.ownsElements = false;
+                  }
+                  vao.destroy();
+                };
+                updateVAO._vao = vao;
+                updateVAO._reglType = "vao";
+                return updateVAO(_attr);
+              }
+              return state;
+            }
+            var GL_FRAGMENT_SHADER = 35632;
+            var GL_VERTEX_SHADER = 35633;
+            var GL_ACTIVE_UNIFORMS = 35718;
+            var GL_ACTIVE_ATTRIBUTES = 35721;
+            function wrapShaderState(gl2, stringStore, stats2, config2) {
+              var fragShaders = {};
+              var vertShaders = {};
+              function ActiveInfo(name2, id2, location2, info) {
+                this.name = name2;
+                this.id = id2;
+                this.location = location2;
+                this.info = info;
+              }
+              function insertActiveInfo(list, info) {
+                for (var i2 = 0; i2 < list.length; ++i2) {
+                  if (list[i2].id === info.id) {
+                    list[i2].location = info.location;
+                    return;
+                  }
+                }
+                list.push(info);
+              }
+              function getShader(type, id2, command) {
+                var cache = type === GL_FRAGMENT_SHADER ? fragShaders : vertShaders;
+                var shader = cache[id2];
+                if (!shader) {
+                  var source2 = stringStore.str(id2);
+                  shader = gl2.createShader(type);
+                  gl2.shaderSource(shader, source2);
+                  gl2.compileShader(shader);
+                  cache[id2] = shader;
+                }
+                return shader;
+              }
+              var programCache = {};
+              var programList = [];
+              var PROGRAM_COUNTER = 0;
+              function REGLProgram(fragId, vertId) {
+                this.id = PROGRAM_COUNTER++;
+                this.fragId = fragId;
+                this.vertId = vertId;
+                this.program = null;
+                this.uniforms = [];
+                this.attributes = [];
+                this.refCount = 1;
+                if (config2.profile) {
+                  this.stats = {
+                    uniformsCount: 0,
+                    attributesCount: 0
+                  };
+                }
+              }
+              function linkProgram(desc, command, attributeLocations) {
+                var i2, info;
+                var fragShader = getShader(GL_FRAGMENT_SHADER, desc.fragId);
+                var vertShader = getShader(GL_VERTEX_SHADER, desc.vertId);
+                var program = desc.program = gl2.createProgram();
+                gl2.attachShader(program, fragShader);
+                gl2.attachShader(program, vertShader);
+                if (attributeLocations) {
+                  for (i2 = 0; i2 < attributeLocations.length; ++i2) {
+                    var binding = attributeLocations[i2];
+                    gl2.bindAttribLocation(program, binding[0], binding[1]);
+                  }
+                }
+                gl2.linkProgram(program);
+                var numUniforms = gl2.getProgramParameter(program, GL_ACTIVE_UNIFORMS);
+                if (config2.profile) {
+                  desc.stats.uniformsCount = numUniforms;
+                }
+                var uniforms = desc.uniforms;
+                for (i2 = 0; i2 < numUniforms; ++i2) {
+                  info = gl2.getActiveUniform(program, i2);
+                  if (info) {
+                    if (info.size > 1) {
+                      for (var j2 = 0; j2 < info.size; ++j2) {
+                        var name2 = info.name.replace("[0]", "[" + j2 + "]");
+                        insertActiveInfo(uniforms, new ActiveInfo(
+                          name2,
+                          stringStore.id(name2),
+                          gl2.getUniformLocation(program, name2),
+                          info
+                        ));
+                      }
+                    } else {
+                      insertActiveInfo(uniforms, new ActiveInfo(
+                        info.name,
+                        stringStore.id(info.name),
+                        gl2.getUniformLocation(program, info.name),
+                        info
+                      ));
+                    }
+                  }
+                }
+                var numAttributes = gl2.getProgramParameter(program, GL_ACTIVE_ATTRIBUTES);
+                if (config2.profile) {
+                  desc.stats.attributesCount = numAttributes;
+                }
+                var attributes = desc.attributes;
+                for (i2 = 0; i2 < numAttributes; ++i2) {
+                  info = gl2.getActiveAttrib(program, i2);
+                  if (info) {
+                    insertActiveInfo(attributes, new ActiveInfo(
+                      info.name,
+                      stringStore.id(info.name),
+                      gl2.getAttribLocation(program, info.name),
+                      info
+                    ));
+                  }
+                }
+              }
+              if (config2.profile) {
+                stats2.getMaxUniformsCount = function() {
+                  var m2 = 0;
+                  programList.forEach(function(desc) {
+                    if (desc.stats.uniformsCount > m2) {
+                      m2 = desc.stats.uniformsCount;
+                    }
+                  });
+                  return m2;
+                };
+                stats2.getMaxAttributesCount = function() {
+                  var m2 = 0;
+                  programList.forEach(function(desc) {
+                    if (desc.stats.attributesCount > m2) {
+                      m2 = desc.stats.attributesCount;
+                    }
+                  });
+                  return m2;
+                };
+              }
+              function restoreShaders() {
+                fragShaders = {};
+                vertShaders = {};
+                for (var i2 = 0; i2 < programList.length; ++i2) {
+                  linkProgram(programList[i2], null, programList[i2].attributes.map(function(info) {
+                    return [info.location, info.name];
+                  }));
+                }
+              }
+              return {
+                clear: function() {
+                  var deleteShader = gl2.deleteShader.bind(gl2);
+                  values(fragShaders).forEach(deleteShader);
+                  fragShaders = {};
+                  values(vertShaders).forEach(deleteShader);
+                  vertShaders = {};
+                  programList.forEach(function(desc) {
+                    gl2.deleteProgram(desc.program);
+                  });
+                  programList.length = 0;
+                  programCache = {};
+                  stats2.shaderCount = 0;
+                },
+                program: function(vertId, fragId, command, attribLocations) {
+                  var cache = programCache[fragId];
+                  if (!cache) {
+                    cache = programCache[fragId] = {};
+                  }
+                  var prevProgram = cache[vertId];
+                  if (prevProgram) {
+                    prevProgram.refCount++;
+                    if (!attribLocations) {
+                      return prevProgram;
+                    }
+                  }
+                  var program = new REGLProgram(fragId, vertId);
+                  stats2.shaderCount++;
+                  linkProgram(program, command, attribLocations);
+                  if (!prevProgram) {
+                    cache[vertId] = program;
+                  }
+                  programList.push(program);
+                  return extend2(program, {
+                    destroy: function() {
+                      program.refCount--;
+                      if (program.refCount <= 0) {
+                        gl2.deleteProgram(program.program);
+                        var idx = programList.indexOf(program);
+                        programList.splice(idx, 1);
+                        stats2.shaderCount--;
+                      }
+                      if (cache[program.vertId].refCount <= 0) {
+                        gl2.deleteShader(vertShaders[program.vertId]);
+                        delete vertShaders[program.vertId];
+                        delete programCache[program.fragId][program.vertId];
+                      }
+                      if (!Object.keys(programCache[program.fragId]).length) {
+                        gl2.deleteShader(fragShaders[program.fragId]);
+                        delete fragShaders[program.fragId];
+                        delete programCache[program.fragId];
+                      }
+                    }
+                  });
+                },
+                restore: restoreShaders,
+                shader: getShader,
+                frag: -1,
+                vert: -1
+              };
+            }
+            var GL_RGBA$3 = 6408;
+            var GL_UNSIGNED_BYTE$6 = 5121;
+            var GL_PACK_ALIGNMENT = 3333;
+            var GL_FLOAT$6 = 5126;
+            function wrapReadPixels(gl2, framebufferState, reglPoll, context, glAttributes, extensions, limits) {
+              function readPixelsImpl(input) {
+                var type;
+                if (framebufferState.next === null) {
+                  type = GL_UNSIGNED_BYTE$6;
+                } else {
+                  type = framebufferState.next.colorAttachments[0].texture._texture.type;
+                }
+                var x2 = 0;
+                var y2 = 0;
+                var width = context.framebufferWidth;
+                var height = context.framebufferHeight;
+                var data = null;
+                if (isTypedArray2(input)) {
+                  data = input;
+                } else if (input) {
+                  x2 = input.x | 0;
+                  y2 = input.y | 0;
+                  width = (input.width || context.framebufferWidth - x2) | 0;
+                  height = (input.height || context.framebufferHeight - y2) | 0;
+                  data = input.data || null;
+                }
+                reglPoll();
+                var size = width * height * 4;
+                if (!data) {
+                  if (type === GL_UNSIGNED_BYTE$6) {
+                    data = new Uint8Array(size);
+                  } else if (type === GL_FLOAT$6) {
+                    data = data || new Float32Array(size);
+                  }
+                }
+                gl2.pixelStorei(GL_PACK_ALIGNMENT, 4);
+                gl2.readPixels(
+                  x2,
+                  y2,
+                  width,
+                  height,
+                  GL_RGBA$3,
+                  type,
+                  data
+                );
+                return data;
+              }
+              function readPixelsFBO(options) {
+                var result;
+                framebufferState.setFBO({
+                  framebuffer: options.framebuffer
+                }, function() {
+                  result = readPixelsImpl(options);
+                });
+                return result;
+              }
+              function readPixels(options) {
+                if (!options || !("framebuffer" in options)) {
+                  return readPixelsImpl(options);
+                } else {
+                  return readPixelsFBO(options);
+                }
+              }
+              return readPixels;
+            }
+            function hex_sha256(s2) {
+              return rstr2hex(rstr_sha256(str2rstr_utf8(s2)));
+            }
+            function rstr_sha256(s2) {
+              return binb2rstr(binb_sha256(rstr2binb(s2), s2.length * 8));
+            }
+            function rstr2hex(input) {
+              var hex_tab = "0123456789abcdef";
+              var output = "";
+              var x2;
+              for (var i2 = 0; i2 < input.length; i2++) {
+                x2 = input.charCodeAt(i2);
+                output += hex_tab.charAt(x2 >>> 4 & 15) + hex_tab.charAt(x2 & 15);
+              }
+              return output;
+            }
+            function str2rstr_utf8(input) {
+              var output = "";
+              var i2 = -1;
+              var x2, y2;
+              while (++i2 < input.length) {
+                x2 = input.charCodeAt(i2);
+                y2 = i2 + 1 < input.length ? input.charCodeAt(i2 + 1) : 0;
+                if (55296 <= x2 && x2 <= 56319 && 56320 <= y2 && y2 <= 57343) {
+                  x2 = 65536 + ((x2 & 1023) << 10) + (y2 & 1023);
+                  i2++;
+                }
+                if (x2 <= 127)
+                  output += String.fromCharCode(x2);
+                else if (x2 <= 2047)
+                  output += String.fromCharCode(
+                    192 | x2 >>> 6 & 31,
+                    128 | x2 & 63
+                  );
+                else if (x2 <= 65535)
+                  output += String.fromCharCode(
+                    224 | x2 >>> 12 & 15,
+                    128 | x2 >>> 6 & 63,
+                    128 | x2 & 63
+                  );
+                else if (x2 <= 2097151)
+                  output += String.fromCharCode(
+                    240 | x2 >>> 18 & 7,
+                    128 | x2 >>> 12 & 63,
+                    128 | x2 >>> 6 & 63,
+                    128 | x2 & 63
+                  );
+              }
+              return output;
+            }
+            function rstr2binb(input) {
+              var output = Array(input.length >> 2);
+              for (var i2 = 0; i2 < output.length; i2++)
+                output[i2] = 0;
+              for (var i2 = 0; i2 < input.length * 8; i2 += 8)
+                output[i2 >> 5] |= (input.charCodeAt(i2 / 8) & 255) << 24 - i2 % 32;
+              return output;
+            }
+            function binb2rstr(input) {
+              var output = "";
+              for (var i2 = 0; i2 < input.length * 32; i2 += 8)
+                output += String.fromCharCode(input[i2 >> 5] >>> 24 - i2 % 32 & 255);
+              return output;
+            }
+            function sha256_S(X2, n2) {
+              return X2 >>> n2 | X2 << 32 - n2;
+            }
+            function sha256_R(X2, n2) {
+              return X2 >>> n2;
+            }
+            function sha256_Ch(x2, y2, z2) {
+              return x2 & y2 ^ ~x2 & z2;
+            }
+            function sha256_Maj(x2, y2, z2) {
+              return x2 & y2 ^ x2 & z2 ^ y2 & z2;
+            }
+            function sha256_Sigma0256(x2) {
+              return sha256_S(x2, 2) ^ sha256_S(x2, 13) ^ sha256_S(x2, 22);
+            }
+            function sha256_Sigma1256(x2) {
+              return sha256_S(x2, 6) ^ sha256_S(x2, 11) ^ sha256_S(x2, 25);
+            }
+            function sha256_Gamma0256(x2) {
+              return sha256_S(x2, 7) ^ sha256_S(x2, 18) ^ sha256_R(x2, 3);
+            }
+            function sha256_Gamma1256(x2) {
+              return sha256_S(x2, 17) ^ sha256_S(x2, 19) ^ sha256_R(x2, 10);
+            }
+            var sha256_K = new Array(
+              1116352408,
+              1899447441,
+              -1245643825,
+              -373957723,
+              961987163,
+              1508970993,
+              -1841331548,
+              -1424204075,
+              -670586216,
+              310598401,
+              607225278,
+              1426881987,
+              1925078388,
+              -2132889090,
+              -1680079193,
+              -1046744716,
+              -459576895,
+              -272742522,
+              264347078,
+              604807628,
+              770255983,
+              1249150122,
+              1555081692,
+              1996064986,
+              -1740746414,
+              -1473132947,
+              -1341970488,
+              -1084653625,
+              -958395405,
+              -710438585,
+              113926993,
+              338241895,
+              666307205,
+              773529912,
+              1294757372,
+              1396182291,
+              1695183700,
+              1986661051,
+              -2117940946,
+              -1838011259,
+              -1564481375,
+              -1474664885,
+              -1035236496,
+              -949202525,
+              -778901479,
+              -694614492,
+              -200395387,
+              275423344,
+              430227734,
+              506948616,
+              659060556,
+              883997877,
+              958139571,
+              1322822218,
+              1537002063,
+              1747873779,
+              1955562222,
+              2024104815,
+              -2067236844,
+              -1933114872,
+              -1866530822,
+              -1538233109,
+              -1090935817,
+              -965641998
+            );
+            function binb_sha256(m2, l2) {
+              var HASH = new Array(
+                1779033703,
+                -1150833019,
+                1013904242,
+                -1521486534,
+                1359893119,
+                -1694144372,
+                528734635,
+                1541459225
+              );
+              var W2 = new Array(64);
+              var a2, b2, c2, d2, e2, f2, g2, h2;
+              var i2, j2, T1, T2;
+              m2[l2 >> 5] |= 128 << 24 - l2 % 32;
+              m2[(l2 + 64 >> 9 << 4) + 15] = l2;
+              for (i2 = 0; i2 < m2.length; i2 += 16) {
+                a2 = HASH[0];
+                b2 = HASH[1];
+                c2 = HASH[2];
+                d2 = HASH[3];
+                e2 = HASH[4];
+                f2 = HASH[5];
+                g2 = HASH[6];
+                h2 = HASH[7];
+                for (j2 = 0; j2 < 64; j2++) {
+                  if (j2 < 16) W2[j2] = m2[j2 + i2];
+                  else W2[j2] = safe_add(safe_add(
+                    safe_add(sha256_Gamma1256(W2[j2 - 2]), W2[j2 - 7]),
+                    sha256_Gamma0256(W2[j2 - 15])
+                  ), W2[j2 - 16]);
+                  T1 = safe_add(safe_add(
+                    safe_add(safe_add(h2, sha256_Sigma1256(e2)), sha256_Ch(e2, f2, g2)),
+                    sha256_K[j2]
+                  ), W2[j2]);
+                  T2 = safe_add(sha256_Sigma0256(a2), sha256_Maj(a2, b2, c2));
+                  h2 = g2;
+                  g2 = f2;
+                  f2 = e2;
+                  e2 = safe_add(d2, T1);
+                  d2 = c2;
+                  c2 = b2;
+                  b2 = a2;
+                  a2 = safe_add(T1, T2);
+                }
+                HASH[0] = safe_add(a2, HASH[0]);
+                HASH[1] = safe_add(b2, HASH[1]);
+                HASH[2] = safe_add(c2, HASH[2]);
+                HASH[3] = safe_add(d2, HASH[3]);
+                HASH[4] = safe_add(e2, HASH[4]);
+                HASH[5] = safe_add(f2, HASH[5]);
+                HASH[6] = safe_add(g2, HASH[6]);
+                HASH[7] = safe_add(h2, HASH[7]);
+              }
+              return HASH;
+            }
+            function safe_add(x2, y2) {
+              var lsw = (x2 & 65535) + (y2 & 65535);
+              var msw = (x2 >> 16) + (y2 >> 16) + (lsw >> 16);
+              return msw << 16 | lsw & 65535;
+            }
+            function slice(x2) {
+              return Array.prototype.slice.call(x2);
+            }
+            function join(x2) {
+              return slice(x2).join("");
+            }
+            function createEnvironment(options) {
+              var cache = options && options.cache;
+              var varCounter = 0;
+              var linkedNames = [];
+              var linkedValues = [];
+              var isStable = [];
+              function link(value, options2) {
+                var stable = options2 && options2.stable;
+                if (!stable) {
+                  for (var i2 = 0; i2 < linkedValues.length; ++i2) {
+                    if (linkedValues[i2] === value && !isStable[i2]) {
+                      return linkedNames[i2];
+                    }
+                  }
+                }
+                var name2 = "g" + varCounter++;
+                linkedNames.push(name2);
+                linkedValues.push(value);
+                isStable.push(stable);
+                return name2;
+              }
+              function block() {
+                var code = [];
+                function push() {
+                  code.push.apply(code, slice(arguments));
+                }
+                var vars = [];
+                function def() {
+                  var name2 = "v" + varCounter++;
+                  vars.push(name2);
+                  if (arguments.length > 0) {
+                    code.push(name2, "=");
+                    code.push.apply(code, slice(arguments));
+                    code.push(";");
+                  }
+                  return name2;
+                }
+                return extend2(push, {
+                  def,
+                  toString: function() {
+                    return join([
+                      vars.length > 0 ? "var " + vars.join(",") + ";" : "",
+                      join(code)
+                    ]);
+                  }
+                });
+              }
+              function scope() {
+                var entry = block();
+                var exit = block();
+                var entryToString = entry.toString;
+                var exitToString = exit.toString;
+                function save(object, prop) {
+                  exit(object, prop, "=", entry.def(object, prop), ";");
+                }
+                return extend2(function() {
+                  entry.apply(entry, slice(arguments));
+                }, {
+                  def: entry.def,
+                  entry,
+                  exit,
+                  save,
+                  set: function(object, prop, value) {
+                    save(object, prop);
+                    entry(object, prop, "=", value, ";");
+                  },
+                  toString: function() {
+                    return entryToString() + exitToString();
+                  }
+                });
+              }
+              function conditional() {
+                var pred = join(arguments);
+                var thenBlock = scope();
+                var elseBlock = scope();
+                var thenToString = thenBlock.toString;
+                var elseToString = elseBlock.toString;
+                return extend2(thenBlock, {
+                  then: function() {
+                    thenBlock.apply(thenBlock, slice(arguments));
+                    return this;
+                  },
+                  else: function() {
+                    elseBlock.apply(elseBlock, slice(arguments));
+                    return this;
+                  },
+                  toString: function() {
+                    var elseClause = elseToString();
+                    if (elseClause) {
+                      elseClause = "else{" + elseClause + "}";
+                    }
+                    return join([
+                      "if(",
+                      pred,
+                      "){",
+                      thenToString(),
+                      "}",
+                      elseClause
+                    ]);
+                  }
+                });
+              }
+              var globalBlock = block();
+              var procedures = {};
+              function proc(name2, count2) {
+                var args = [];
+                function arg() {
+                  var name3 = "a" + args.length;
+                  args.push(name3);
+                  return name3;
+                }
+                count2 = count2 || 0;
+                for (var i2 = 0; i2 < count2; ++i2) {
+                  arg();
+                }
+                var body = scope();
+                var bodyToString = body.toString;
+                var result = procedures[name2] = extend2(body, {
+                  arg,
+                  toString: function() {
+                    return join([
+                      "function(",
+                      args.join(),
+                      "){",
+                      bodyToString(),
+                      "}"
+                    ]);
+                  }
+                });
+                return result;
+              }
+              function compile() {
+                var code = [
+                  '"use strict";',
+                  globalBlock,
+                  "return {"
+                ];
+                Object.keys(procedures).forEach(function(name2) {
+                  code.push('"', name2, '":', procedures[name2].toString(), ",");
+                });
+                code.push("}");
+                var src = join(code).replace(/;/g, ";\n").replace(/}/g, "}\n").replace(/{/g, "{\n");
+                var key;
+                if (cache) {
+                  key = hex_sha256(src);
+                  if (cache[key]) {
+                    return cache[key].apply(null, linkedValues);
+                  }
+                }
+                var proc2 = Function.apply(null, linkedNames.concat(src));
+                if (cache) {
+                  cache[key] = proc2;
+                }
+                return proc2.apply(null, linkedValues);
+              }
+              return {
+                global: globalBlock,
+                link,
+                block,
+                proc,
+                scope,
+                cond: conditional,
+                compile
+              };
+            }
+            var CUTE_COMPONENTS = "xyzw".split("");
+            var GL_UNSIGNED_BYTE$7 = 5121;
+            var ATTRIB_STATE_POINTER = 1;
+            var ATTRIB_STATE_CONSTANT = 2;
+            var DYN_FUNC$1 = 0;
+            var DYN_PROP$1 = 1;
+            var DYN_CONTEXT$1 = 2;
+            var DYN_STATE$1 = 3;
+            var DYN_THUNK = 4;
+            var DYN_CONSTANT$1 = 5;
+            var DYN_ARRAY$1 = 6;
+            var S_DITHER = "dither";
+            var S_BLEND_ENABLE = "blend.enable";
+            var S_BLEND_COLOR = "blend.color";
+            var S_BLEND_EQUATION = "blend.equation";
+            var S_BLEND_FUNC = "blend.func";
+            var S_DEPTH_ENABLE = "depth.enable";
+            var S_DEPTH_FUNC = "depth.func";
+            var S_DEPTH_RANGE = "depth.range";
+            var S_DEPTH_MASK = "depth.mask";
+            var S_COLOR_MASK = "colorMask";
+            var S_CULL_ENABLE = "cull.enable";
+            var S_CULL_FACE = "cull.face";
+            var S_FRONT_FACE = "frontFace";
+            var S_LINE_WIDTH = "lineWidth";
+            var S_POLYGON_OFFSET_ENABLE = "polygonOffset.enable";
+            var S_POLYGON_OFFSET_OFFSET = "polygonOffset.offset";
+            var S_SAMPLE_ALPHA = "sample.alpha";
+            var S_SAMPLE_ENABLE = "sample.enable";
+            var S_SAMPLE_COVERAGE = "sample.coverage";
+            var S_STENCIL_ENABLE = "stencil.enable";
+            var S_STENCIL_MASK = "stencil.mask";
+            var S_STENCIL_FUNC = "stencil.func";
+            var S_STENCIL_OPFRONT = "stencil.opFront";
+            var S_STENCIL_OPBACK = "stencil.opBack";
+            var S_SCISSOR_ENABLE = "scissor.enable";
+            var S_SCISSOR_BOX = "scissor.box";
+            var S_VIEWPORT = "viewport";
+            var S_PROFILE = "profile";
+            var S_FRAMEBUFFER = "framebuffer";
+            var S_VERT = "vert";
+            var S_FRAG = "frag";
+            var S_ELEMENTS = "elements";
+            var S_PRIMITIVE = "primitive";
+            var S_COUNT = "count";
+            var S_OFFSET = "offset";
+            var S_INSTANCES = "instances";
+            var S_VAO = "vao";
+            var SUFFIX_WIDTH = "Width";
+            var SUFFIX_HEIGHT = "Height";
+            var S_FRAMEBUFFER_WIDTH = S_FRAMEBUFFER + SUFFIX_WIDTH;
+            var S_FRAMEBUFFER_HEIGHT = S_FRAMEBUFFER + SUFFIX_HEIGHT;
+            var S_VIEWPORT_WIDTH = S_VIEWPORT + SUFFIX_WIDTH;
+            var S_VIEWPORT_HEIGHT = S_VIEWPORT + SUFFIX_HEIGHT;
+            var S_DRAWINGBUFFER = "drawingBuffer";
+            var S_DRAWINGBUFFER_WIDTH = S_DRAWINGBUFFER + SUFFIX_WIDTH;
+            var S_DRAWINGBUFFER_HEIGHT = S_DRAWINGBUFFER + SUFFIX_HEIGHT;
+            var NESTED_OPTIONS = [
+              S_BLEND_FUNC,
+              S_BLEND_EQUATION,
+              S_STENCIL_FUNC,
+              S_STENCIL_OPFRONT,
+              S_STENCIL_OPBACK,
+              S_SAMPLE_COVERAGE,
+              S_VIEWPORT,
+              S_SCISSOR_BOX,
+              S_POLYGON_OFFSET_OFFSET
+            ];
+            var GL_ARRAY_BUFFER$2 = 34962;
+            var GL_ELEMENT_ARRAY_BUFFER$2 = 34963;
+            var GL_CULL_FACE = 2884;
+            var GL_BLEND = 3042;
+            var GL_DITHER = 3024;
+            var GL_STENCIL_TEST = 2960;
+            var GL_DEPTH_TEST = 2929;
+            var GL_SCISSOR_TEST = 3089;
+            var GL_POLYGON_OFFSET_FILL = 32823;
+            var GL_SAMPLE_ALPHA_TO_COVERAGE = 32926;
+            var GL_SAMPLE_COVERAGE = 32928;
+            var GL_FLOAT$7 = 5126;
+            var GL_FLOAT_VEC2 = 35664;
+            var GL_FLOAT_VEC3 = 35665;
+            var GL_FLOAT_VEC4 = 35666;
+            var GL_INT$2 = 5124;
+            var GL_INT_VEC2 = 35667;
+            var GL_INT_VEC3 = 35668;
+            var GL_INT_VEC4 = 35669;
+            var GL_BOOL = 35670;
+            var GL_BOOL_VEC2 = 35671;
+            var GL_BOOL_VEC3 = 35672;
+            var GL_BOOL_VEC4 = 35673;
+            var GL_FLOAT_MAT2 = 35674;
+            var GL_FLOAT_MAT3 = 35675;
+            var GL_FLOAT_MAT4 = 35676;
+            var GL_SAMPLER_2D = 35678;
+            var GL_SAMPLER_CUBE = 35680;
+            var GL_TRIANGLES$1 = 4;
+            var GL_FRONT = 1028;
+            var GL_BACK = 1029;
+            var GL_CW = 2304;
+            var GL_CCW = 2305;
+            var GL_MIN_EXT = 32775;
+            var GL_MAX_EXT = 32776;
+            var GL_ALWAYS = 519;
+            var GL_KEEP = 7680;
+            var GL_ZERO = 0;
+            var GL_ONE = 1;
+            var GL_FUNC_ADD = 32774;
+            var GL_LESS = 513;
+            var GL_FRAMEBUFFER$2 = 36160;
+            var GL_COLOR_ATTACHMENT0$2 = 36064;
+            var blendFuncs = {
+              "0": 0,
+              "1": 1,
+              "zero": 0,
+              "one": 1,
+              "src color": 768,
+              "one minus src color": 769,
+              "src alpha": 770,
+              "one minus src alpha": 771,
+              "dst color": 774,
+              "one minus dst color": 775,
+              "dst alpha": 772,
+              "one minus dst alpha": 773,
+              "constant color": 32769,
+              "one minus constant color": 32770,
+              "constant alpha": 32771,
+              "one minus constant alpha": 32772,
+              "src alpha saturate": 776
+            };
+            var compareFuncs = {
+              "never": 512,
+              "less": 513,
+              "<": 513,
+              "equal": 514,
+              "=": 514,
+              "==": 514,
+              "===": 514,
+              "lequal": 515,
+              "<=": 515,
+              "greater": 516,
+              ">": 516,
+              "notequal": 517,
+              "!=": 517,
+              "!==": 517,
+              "gequal": 518,
+              ">=": 518,
+              "always": 519
+            };
+            var stencilOps = {
+              "0": 0,
+              "zero": 0,
+              "keep": 7680,
+              "replace": 7681,
+              "increment": 7682,
+              "decrement": 7683,
+              "increment wrap": 34055,
+              "decrement wrap": 34056,
+              "invert": 5386
+            };
+            var orientationType = {
+              "cw": GL_CW,
+              "ccw": GL_CCW
+            };
+            function isBufferArgs(x2) {
+              return Array.isArray(x2) || isTypedArray2(x2) || isNDArrayLike(x2);
+            }
+            function sortState(state) {
+              return state.sort(function(a2, b2) {
+                if (a2 === S_VIEWPORT) {
+                  return -1;
+                } else if (b2 === S_VIEWPORT) {
+                  return 1;
+                }
+                return a2 < b2 ? -1 : 1;
+              });
+            }
+            function Declaration(thisDep, contextDep, propDep, append) {
+              this.thisDep = thisDep;
+              this.contextDep = contextDep;
+              this.propDep = propDep;
+              this.append = append;
+            }
+            function isStatic(decl) {
+              return decl && !(decl.thisDep || decl.contextDep || decl.propDep);
+            }
+            function createStaticDecl(append) {
+              return new Declaration(false, false, false, append);
+            }
+            function createDynamicDecl(dyn, append) {
+              var type = dyn.type;
+              if (type === DYN_FUNC$1) {
+                var numArgs = dyn.data.length;
+                return new Declaration(
+                  true,
+                  numArgs >= 1,
+                  numArgs >= 2,
+                  append
+                );
+              } else if (type === DYN_THUNK) {
+                var data = dyn.data;
+                return new Declaration(
+                  data.thisDep,
+                  data.contextDep,
+                  data.propDep,
+                  append
+                );
+              } else if (type === DYN_CONSTANT$1) {
+                return new Declaration(
+                  false,
+                  false,
+                  false,
+                  append
+                );
+              } else if (type === DYN_ARRAY$1) {
+                var thisDep = false;
+                var contextDep = false;
+                var propDep = false;
+                for (var i2 = 0; i2 < dyn.data.length; ++i2) {
+                  var subDyn = dyn.data[i2];
+                  if (subDyn.type === DYN_PROP$1) {
+                    propDep = true;
+                  } else if (subDyn.type === DYN_CONTEXT$1) {
+                    contextDep = true;
+                  } else if (subDyn.type === DYN_STATE$1) {
+                    thisDep = true;
+                  } else if (subDyn.type === DYN_FUNC$1) {
+                    thisDep = true;
+                    var subArgs = subDyn.data;
+                    if (subArgs >= 1) {
+                      contextDep = true;
+                    }
+                    if (subArgs >= 2) {
+                      propDep = true;
+                    }
+                  } else if (subDyn.type === DYN_THUNK) {
+                    thisDep = thisDep || subDyn.data.thisDep;
+                    contextDep = contextDep || subDyn.data.contextDep;
+                    propDep = propDep || subDyn.data.propDep;
+                  }
+                }
+                return new Declaration(
+                  thisDep,
+                  contextDep,
+                  propDep,
+                  append
+                );
+              } else {
+                return new Declaration(
+                  type === DYN_STATE$1,
+                  type === DYN_CONTEXT$1,
+                  type === DYN_PROP$1,
+                  append
+                );
+              }
+            }
+            var SCOPE_DECL = new Declaration(false, false, false, function() {
+            });
+            function reglCore(gl2, stringStore, extensions, limits, bufferState, elementState, textureState, framebufferState, uniformState, attributeState, shaderState, drawState, contextState, timer, cachedCode, config2) {
+              var AttributeRecord2 = attributeState.Record;
+              var blendEquations = {
+                "add": 32774,
+                "subtract": 32778,
+                "reverse subtract": 32779
+              };
+              if (extensions.ext_blend_minmax) {
+                blendEquations.min = GL_MIN_EXT;
+                blendEquations.max = GL_MAX_EXT;
+              }
+              var extInstancing = extensions.angle_instanced_arrays;
+              var extDrawBuffers = extensions.webgl_draw_buffers;
+              var extVertexArrays = extensions.oes_vertex_array_object;
+              var currentState = {
+                dirty: true,
+                profile: config2.profile
+              };
+              var nextState = {};
+              var GL_STATE_NAMES = [];
+              var GL_FLAGS = {};
+              var GL_VARIABLES = {};
+              function propName(name2) {
+                return name2.replace(".", "_");
+              }
+              function stateFlag(sname, cap, init) {
+                var name2 = propName(sname);
+                GL_STATE_NAMES.push(sname);
+                nextState[name2] = currentState[name2] = !!init;
+                GL_FLAGS[name2] = cap;
+              }
+              function stateVariable(sname, func, init) {
+                var name2 = propName(sname);
+                GL_STATE_NAMES.push(sname);
+                if (Array.isArray(init)) {
+                  currentState[name2] = init.slice();
+                  nextState[name2] = init.slice();
+                } else {
+                  currentState[name2] = nextState[name2] = init;
+                }
+                GL_VARIABLES[name2] = func;
+              }
+              function hasVariableReference(exp) {
+                if (!isNaN(exp)) {
+                  return false;
+                }
+                return true;
+              }
+              stateFlag(S_DITHER, GL_DITHER);
+              stateFlag(S_BLEND_ENABLE, GL_BLEND);
+              stateVariable(S_BLEND_COLOR, "blendColor", [0, 0, 0, 0]);
+              stateVariable(
+                S_BLEND_EQUATION,
+                "blendEquationSeparate",
+                [GL_FUNC_ADD, GL_FUNC_ADD]
+              );
+              stateVariable(
+                S_BLEND_FUNC,
+                "blendFuncSeparate",
+                [GL_ONE, GL_ZERO, GL_ONE, GL_ZERO]
+              );
+              stateFlag(S_DEPTH_ENABLE, GL_DEPTH_TEST, true);
+              stateVariable(S_DEPTH_FUNC, "depthFunc", GL_LESS);
+              stateVariable(S_DEPTH_RANGE, "depthRange", [0, 1]);
+              stateVariable(S_DEPTH_MASK, "depthMask", true);
+              stateVariable(S_COLOR_MASK, S_COLOR_MASK, [true, true, true, true]);
+              stateFlag(S_CULL_ENABLE, GL_CULL_FACE);
+              stateVariable(S_CULL_FACE, "cullFace", GL_BACK);
+              stateVariable(S_FRONT_FACE, S_FRONT_FACE, GL_CCW);
+              stateVariable(S_LINE_WIDTH, S_LINE_WIDTH, 1);
+              stateFlag(S_POLYGON_OFFSET_ENABLE, GL_POLYGON_OFFSET_FILL);
+              stateVariable(S_POLYGON_OFFSET_OFFSET, "polygonOffset", [0, 0]);
+              stateFlag(S_SAMPLE_ALPHA, GL_SAMPLE_ALPHA_TO_COVERAGE);
+              stateFlag(S_SAMPLE_ENABLE, GL_SAMPLE_COVERAGE);
+              stateVariable(S_SAMPLE_COVERAGE, "sampleCoverage", [1, false]);
+              stateFlag(S_STENCIL_ENABLE, GL_STENCIL_TEST);
+              stateVariable(S_STENCIL_MASK, "stencilMask", -1);
+              stateVariable(S_STENCIL_FUNC, "stencilFunc", [GL_ALWAYS, 0, -1]);
+              stateVariable(
+                S_STENCIL_OPFRONT,
+                "stencilOpSeparate",
+                [GL_FRONT, GL_KEEP, GL_KEEP, GL_KEEP]
+              );
+              stateVariable(
+                S_STENCIL_OPBACK,
+                "stencilOpSeparate",
+                [GL_BACK, GL_KEEP, GL_KEEP, GL_KEEP]
+              );
+              stateFlag(S_SCISSOR_ENABLE, GL_SCISSOR_TEST);
+              stateVariable(
+                S_SCISSOR_BOX,
+                "scissor",
+                [0, 0, gl2.drawingBufferWidth, gl2.drawingBufferHeight]
+              );
+              stateVariable(
+                S_VIEWPORT,
+                S_VIEWPORT,
+                [0, 0, gl2.drawingBufferWidth, gl2.drawingBufferHeight]
+              );
+              var sharedState = {
+                gl: gl2,
+                context: contextState,
+                strings: stringStore,
+                next: nextState,
+                current: currentState,
+                draw: drawState,
+                elements: elementState,
+                buffer: bufferState,
+                shader: shaderState,
+                attributes: attributeState.state,
+                vao: attributeState,
+                uniforms: uniformState,
+                framebuffer: framebufferState,
+                extensions,
+                timer,
+                isBufferArgs
+              };
+              var sharedConstants = {
+                primTypes,
+                compareFuncs,
+                blendFuncs,
+                blendEquations,
+                stencilOps,
+                glTypes,
+                orientationType
+              };
+              if (extDrawBuffers) {
+                sharedConstants.backBuffer = [GL_BACK];
+                sharedConstants.drawBuffer = loop(limits.maxDrawbuffers, function(i2) {
+                  if (i2 === 0) {
+                    return [0];
+                  }
+                  return loop(i2, function(j2) {
+                    return GL_COLOR_ATTACHMENT0$2 + j2;
+                  });
+                });
+              }
+              var drawCallCounter = 0;
+              function createREGLEnvironment() {
+                var env = createEnvironment({ cache: cachedCode });
+                var link = env.link;
+                var global2 = env.global;
+                env.id = drawCallCounter++;
+                env.batchId = "0";
+                var SHARED = link(sharedState);
+                var shared = env.shared = {
+                  props: "a0"
+                };
+                Object.keys(sharedState).forEach(function(prop) {
+                  shared[prop] = global2.def(SHARED, ".", prop);
+                });
+                var nextVars = env.next = {};
+                var currentVars = env.current = {};
+                Object.keys(GL_VARIABLES).forEach(function(variable) {
+                  if (Array.isArray(currentState[variable])) {
+                    nextVars[variable] = global2.def(shared.next, ".", variable);
+                    currentVars[variable] = global2.def(shared.current, ".", variable);
+                  }
+                });
+                var constants = env.constants = {};
+                Object.keys(sharedConstants).forEach(function(name2) {
+                  constants[name2] = global2.def(JSON.stringify(sharedConstants[name2]));
+                });
+                env.invoke = function(block, x2) {
+                  switch (x2.type) {
+                    case DYN_FUNC$1:
+                      var argList = [
+                        "this",
+                        shared.context,
+                        shared.props,
+                        env.batchId
+                      ];
+                      return block.def(
+                        link(x2.data),
+                        ".call(",
+                        argList.slice(0, Math.max(x2.data.length + 1, 4)),
+                        ")"
+                      );
+                    case DYN_PROP$1:
+                      return block.def(shared.props, x2.data);
+                    case DYN_CONTEXT$1:
+                      return block.def(shared.context, x2.data);
+                    case DYN_STATE$1:
+                      return block.def("this", x2.data);
+                    case DYN_THUNK:
+                      x2.data.append(env, block);
+                      return x2.data.ref;
+                    case DYN_CONSTANT$1:
+                      return x2.data.toString();
+                    case DYN_ARRAY$1:
+                      return x2.data.map(function(y2) {
+                        return env.invoke(block, y2);
+                      });
+                  }
+                };
+                env.attribCache = {};
+                var scopeAttribs = {};
+                env.scopeAttrib = function(name2) {
+                  var id2 = stringStore.id(name2);
+                  if (id2 in scopeAttribs) {
+                    return scopeAttribs[id2];
+                  }
+                  var binding = attributeState.scope[id2];
+                  if (!binding) {
+                    binding = attributeState.scope[id2] = new AttributeRecord2();
+                  }
+                  var result = scopeAttribs[id2] = link(binding);
+                  return result;
+                };
+                return env;
+              }
+              function parseProfile(options) {
+                var staticOptions = options.static;
+                var dynamicOptions = options.dynamic;
+                var profileEnable;
+                if (S_PROFILE in staticOptions) {
+                  var value = !!staticOptions[S_PROFILE];
+                  profileEnable = createStaticDecl(function(env, scope) {
+                    return value;
+                  });
+                  profileEnable.enable = value;
+                } else if (S_PROFILE in dynamicOptions) {
+                  var dyn = dynamicOptions[S_PROFILE];
+                  profileEnable = createDynamicDecl(dyn, function(env, scope) {
+                    return env.invoke(scope, dyn);
+                  });
+                }
+                return profileEnable;
+              }
+              function parseFramebuffer(options, env) {
+                var staticOptions = options.static;
+                var dynamicOptions = options.dynamic;
+                if (S_FRAMEBUFFER in staticOptions) {
+                  var framebuffer = staticOptions[S_FRAMEBUFFER];
+                  if (framebuffer) {
+                    framebuffer = framebufferState.getFramebuffer(framebuffer);
+                    return createStaticDecl(function(env2, block) {
+                      var FRAMEBUFFER = env2.link(framebuffer);
+                      var shared = env2.shared;
+                      block.set(
+                        shared.framebuffer,
+                        ".next",
+                        FRAMEBUFFER
+                      );
+                      var CONTEXT = shared.context;
+                      block.set(
+                        CONTEXT,
+                        "." + S_FRAMEBUFFER_WIDTH,
+                        FRAMEBUFFER + ".width"
+                      );
+                      block.set(
+                        CONTEXT,
+                        "." + S_FRAMEBUFFER_HEIGHT,
+                        FRAMEBUFFER + ".height"
+                      );
+                      return FRAMEBUFFER;
+                    });
+                  } else {
+                    return createStaticDecl(function(env2, scope) {
+                      var shared = env2.shared;
+                      scope.set(
+                        shared.framebuffer,
+                        ".next",
+                        "null"
+                      );
+                      var CONTEXT = shared.context;
+                      scope.set(
+                        CONTEXT,
+                        "." + S_FRAMEBUFFER_WIDTH,
+                        CONTEXT + "." + S_DRAWINGBUFFER_WIDTH
+                      );
+                      scope.set(
+                        CONTEXT,
+                        "." + S_FRAMEBUFFER_HEIGHT,
+                        CONTEXT + "." + S_DRAWINGBUFFER_HEIGHT
+                      );
+                      return "null";
+                    });
+                  }
+                } else if (S_FRAMEBUFFER in dynamicOptions) {
+                  var dyn = dynamicOptions[S_FRAMEBUFFER];
+                  return createDynamicDecl(dyn, function(env2, scope) {
+                    var FRAMEBUFFER_FUNC = env2.invoke(scope, dyn);
+                    var shared = env2.shared;
+                    var FRAMEBUFFER_STATE = shared.framebuffer;
+                    var FRAMEBUFFER = scope.def(
+                      FRAMEBUFFER_STATE,
+                      ".getFramebuffer(",
+                      FRAMEBUFFER_FUNC,
+                      ")"
+                    );
+                    scope.set(
+                      FRAMEBUFFER_STATE,
+                      ".next",
+                      FRAMEBUFFER
+                    );
+                    var CONTEXT = shared.context;
+                    scope.set(
+                      CONTEXT,
+                      "." + S_FRAMEBUFFER_WIDTH,
+                      FRAMEBUFFER + "?" + FRAMEBUFFER + ".width:" + CONTEXT + "." + S_DRAWINGBUFFER_WIDTH
+                    );
+                    scope.set(
+                      CONTEXT,
+                      "." + S_FRAMEBUFFER_HEIGHT,
+                      FRAMEBUFFER + "?" + FRAMEBUFFER + ".height:" + CONTEXT + "." + S_DRAWINGBUFFER_HEIGHT
+                    );
+                    return FRAMEBUFFER;
+                  });
+                } else {
+                  return null;
+                }
+              }
+              function parseViewportScissor(options, framebuffer, env) {
+                var staticOptions = options.static;
+                var dynamicOptions = options.dynamic;
+                function parseBox(param) {
+                  if (param in staticOptions) {
+                    var box = staticOptions[param];
+                    var isStatic2 = true;
+                    var x2 = box.x | 0;
+                    var y2 = box.y | 0;
+                    var w2, h2;
+                    if ("width" in box) {
+                      w2 = box.width | 0;
+                    } else {
+                      isStatic2 = false;
+                    }
+                    if ("height" in box) {
+                      h2 = box.height | 0;
+                    } else {
+                      isStatic2 = false;
+                    }
+                    return new Declaration(
+                      !isStatic2 && framebuffer && framebuffer.thisDep,
+                      !isStatic2 && framebuffer && framebuffer.contextDep,
+                      !isStatic2 && framebuffer && framebuffer.propDep,
+                      function(env2, scope) {
+                        var CONTEXT = env2.shared.context;
+                        var BOX_W = w2;
+                        if (!("width" in box)) {
+                          BOX_W = scope.def(CONTEXT, ".", S_FRAMEBUFFER_WIDTH, "-", x2);
+                        }
+                        var BOX_H = h2;
+                        if (!("height" in box)) {
+                          BOX_H = scope.def(CONTEXT, ".", S_FRAMEBUFFER_HEIGHT, "-", y2);
+                        }
+                        return [x2, y2, BOX_W, BOX_H];
+                      }
+                    );
+                  } else if (param in dynamicOptions) {
+                    var dynBox = dynamicOptions[param];
+                    var result = createDynamicDecl(dynBox, function(env2, scope) {
+                      var BOX = env2.invoke(scope, dynBox);
+                      var CONTEXT = env2.shared.context;
+                      var BOX_X = scope.def(BOX, ".x|0");
+                      var BOX_Y = scope.def(BOX, ".y|0");
+                      var BOX_W = scope.def(
+                        '"width" in ',
+                        BOX,
+                        "?",
+                        BOX,
+                        ".width|0:",
+                        "(",
+                        CONTEXT,
+                        ".",
+                        S_FRAMEBUFFER_WIDTH,
+                        "-",
+                        BOX_X,
+                        ")"
+                      );
+                      var BOX_H = scope.def(
+                        '"height" in ',
+                        BOX,
+                        "?",
+                        BOX,
+                        ".height|0:",
+                        "(",
+                        CONTEXT,
+                        ".",
+                        S_FRAMEBUFFER_HEIGHT,
+                        "-",
+                        BOX_Y,
+                        ")"
+                      );
+                      return [BOX_X, BOX_Y, BOX_W, BOX_H];
+                    });
+                    if (framebuffer) {
+                      result.thisDep = result.thisDep || framebuffer.thisDep;
+                      result.contextDep = result.contextDep || framebuffer.contextDep;
+                      result.propDep = result.propDep || framebuffer.propDep;
+                    }
+                    return result;
+                  } else if (framebuffer) {
+                    return new Declaration(
+                      framebuffer.thisDep,
+                      framebuffer.contextDep,
+                      framebuffer.propDep,
+                      function(env2, scope) {
+                        var CONTEXT = env2.shared.context;
+                        return [
+                          0,
+                          0,
+                          scope.def(CONTEXT, ".", S_FRAMEBUFFER_WIDTH),
+                          scope.def(CONTEXT, ".", S_FRAMEBUFFER_HEIGHT)
+                        ];
+                      }
+                    );
+                  } else {
+                    return null;
+                  }
+                }
+                var viewport = parseBox(S_VIEWPORT);
+                if (viewport) {
+                  var prevViewport = viewport;
+                  viewport = new Declaration(
+                    viewport.thisDep,
+                    viewport.contextDep,
+                    viewport.propDep,
+                    function(env2, scope) {
+                      var VIEWPORT = prevViewport.append(env2, scope);
+                      var CONTEXT = env2.shared.context;
+                      scope.set(
+                        CONTEXT,
+                        "." + S_VIEWPORT_WIDTH,
+                        VIEWPORT[2]
+                      );
+                      scope.set(
+                        CONTEXT,
+                        "." + S_VIEWPORT_HEIGHT,
+                        VIEWPORT[3]
+                      );
+                      return VIEWPORT;
+                    }
+                  );
+                }
+                return {
+                  viewport,
+                  scissor_box: parseBox(S_SCISSOR_BOX)
+                };
+              }
+              function parseAttribLocations(options, attributes) {
+                var staticOptions = options.static;
+                var staticProgram = typeof staticOptions[S_FRAG] === "string" && typeof staticOptions[S_VERT] === "string";
+                if (staticProgram) {
+                  if (Object.keys(attributes.dynamic).length > 0) {
+                    return null;
+                  }
+                  var staticAttributes = attributes.static;
+                  var sAttributes = Object.keys(staticAttributes);
+                  if (sAttributes.length > 0 && typeof staticAttributes[sAttributes[0]] === "number") {
+                    var bindings = [];
+                    for (var i2 = 0; i2 < sAttributes.length; ++i2) {
+                      bindings.push([staticAttributes[sAttributes[i2]] | 0, sAttributes[i2]]);
+                    }
+                    return bindings;
+                  }
+                }
+                return null;
+              }
+              function parseProgram(options, env, attribLocations) {
+                var staticOptions = options.static;
+                var dynamicOptions = options.dynamic;
+                function parseShader(name2) {
+                  if (name2 in staticOptions) {
+                    var id2 = stringStore.id(staticOptions[name2]);
+                    var result = createStaticDecl(function() {
+                      return id2;
+                    });
+                    result.id = id2;
+                    return result;
+                  } else if (name2 in dynamicOptions) {
+                    var dyn = dynamicOptions[name2];
+                    return createDynamicDecl(dyn, function(env2, scope) {
+                      var str = env2.invoke(scope, dyn);
+                      var id22 = scope.def(env2.shared.strings, ".id(", str, ")");
+                      return id22;
+                    });
+                  }
+                  return null;
+                }
+                var frag = parseShader(S_FRAG);
+                var vert = parseShader(S_VERT);
+                var program = null;
+                var progVar;
+                if (isStatic(frag) && isStatic(vert)) {
+                  program = shaderState.program(vert.id, frag.id, null, attribLocations);
+                  progVar = createStaticDecl(function(env2, scope) {
+                    return env2.link(program);
+                  });
+                } else {
+                  progVar = new Declaration(
+                    frag && frag.thisDep || vert && vert.thisDep,
+                    frag && frag.contextDep || vert && vert.contextDep,
+                    frag && frag.propDep || vert && vert.propDep,
+                    function(env2, scope) {
+                      var SHADER_STATE = env2.shared.shader;
+                      var fragId;
+                      if (frag) {
+                        fragId = frag.append(env2, scope);
+                      } else {
+                        fragId = scope.def(SHADER_STATE, ".", S_FRAG);
+                      }
+                      var vertId;
+                      if (vert) {
+                        vertId = vert.append(env2, scope);
+                      } else {
+                        vertId = scope.def(SHADER_STATE, ".", S_VERT);
+                      }
+                      var progDef = SHADER_STATE + ".program(" + vertId + "," + fragId;
+                      return scope.def(progDef + ")");
+                    }
+                  );
+                }
+                return {
+                  frag,
+                  vert,
+                  progVar,
+                  program
+                };
+              }
+              function parseDraw(options, env) {
+                var staticOptions = options.static;
+                var dynamicOptions = options.dynamic;
+                var staticDraw = {};
+                var vaoActive = false;
+                function parseVAO() {
+                  if (S_VAO in staticOptions) {
+                    var vao2 = staticOptions[S_VAO];
+                    if (vao2 !== null && attributeState.getVAO(vao2) === null) {
+                      vao2 = attributeState.createVAO(vao2);
+                    }
+                    vaoActive = true;
+                    staticDraw.vao = vao2;
+                    return createStaticDecl(function(env2) {
+                      var vaoRef = attributeState.getVAO(vao2);
+                      if (vaoRef) {
+                        return env2.link(vaoRef);
+                      } else {
+                        return "null";
+                      }
+                    });
+                  } else if (S_VAO in dynamicOptions) {
+                    vaoActive = true;
+                    var dyn = dynamicOptions[S_VAO];
+                    return createDynamicDecl(dyn, function(env2, scope) {
+                      var vaoRef = env2.invoke(scope, dyn);
+                      return scope.def(env2.shared.vao + ".getVAO(" + vaoRef + ")");
+                    });
+                  }
+                  return null;
+                }
+                var vao = parseVAO();
+                var elementsActive = false;
+                function parseElements() {
+                  if (S_ELEMENTS in staticOptions) {
+                    var elements2 = staticOptions[S_ELEMENTS];
+                    staticDraw.elements = elements2;
+                    if (isBufferArgs(elements2)) {
+                      var e2 = staticDraw.elements = elementState.create(elements2, true);
+                      elements2 = elementState.getElements(e2);
+                      elementsActive = true;
+                    } else if (elements2) {
+                      elements2 = elementState.getElements(elements2);
+                      elementsActive = true;
+                    }
+                    var result = createStaticDecl(function(env2, scope) {
+                      if (elements2) {
+                        var result2 = env2.link(elements2);
+                        env2.ELEMENTS = result2;
+                        return result2;
+                      }
+                      env2.ELEMENTS = null;
+                      return null;
+                    });
+                    result.value = elements2;
+                    return result;
+                  } else if (S_ELEMENTS in dynamicOptions) {
+                    elementsActive = true;
+                    var dyn = dynamicOptions[S_ELEMENTS];
+                    return createDynamicDecl(dyn, function(env2, scope) {
+                      var shared = env2.shared;
+                      var IS_BUFFER_ARGS = shared.isBufferArgs;
+                      var ELEMENT_STATE = shared.elements;
+                      var elementDefn = env2.invoke(scope, dyn);
+                      var elements3 = scope.def("null");
+                      var elementStream = scope.def(IS_BUFFER_ARGS, "(", elementDefn, ")");
+                      var ifte = env2.cond(elementStream).then(elements3, "=", ELEMENT_STATE, ".createStream(", elementDefn, ");").else(elements3, "=", ELEMENT_STATE, ".getElements(", elementDefn, ");");
+                      scope.entry(ifte);
+                      scope.exit(
+                        env2.cond(elementStream).then(ELEMENT_STATE, ".destroyStream(", elements3, ");")
+                      );
+                      env2.ELEMENTS = elements3;
+                      return elements3;
+                    });
+                  } else if (vaoActive) {
+                    return new Declaration(
+                      vao.thisDep,
+                      vao.contextDep,
+                      vao.propDep,
+                      function(env2, scope) {
+                        return scope.def(env2.shared.vao + ".currentVAO?" + env2.shared.elements + ".getElements(" + env2.shared.vao + ".currentVAO.elements):null");
+                      }
+                    );
+                  }
+                  return null;
+                }
+                var elements = parseElements();
+                function parsePrimitive() {
+                  if (S_PRIMITIVE in staticOptions) {
+                    var primitive2 = staticOptions[S_PRIMITIVE];
+                    staticDraw.primitive = primitive2;
+                    return createStaticDecl(function(env2, scope) {
+                      return primTypes[primitive2];
+                    });
+                  } else if (S_PRIMITIVE in dynamicOptions) {
+                    var dynPrimitive = dynamicOptions[S_PRIMITIVE];
+                    return createDynamicDecl(dynPrimitive, function(env2, scope) {
+                      var PRIM_TYPES = env2.constants.primTypes;
+                      var prim = env2.invoke(scope, dynPrimitive);
+                      return scope.def(PRIM_TYPES, "[", prim, "]");
+                    });
+                  } else if (elementsActive) {
+                    if (isStatic(elements)) {
+                      if (elements.value) {
+                        return createStaticDecl(function(env2, scope) {
+                          return scope.def(env2.ELEMENTS, ".primType");
+                        });
+                      } else {
+                        return createStaticDecl(function() {
+                          return GL_TRIANGLES$1;
+                        });
+                      }
+                    } else {
+                      return new Declaration(
+                        elements.thisDep,
+                        elements.contextDep,
+                        elements.propDep,
+                        function(env2, scope) {
+                          var elements2 = env2.ELEMENTS;
+                          return scope.def(elements2, "?", elements2, ".primType:", GL_TRIANGLES$1);
+                        }
+                      );
+                    }
+                  } else if (vaoActive) {
+                    return new Declaration(
+                      vao.thisDep,
+                      vao.contextDep,
+                      vao.propDep,
+                      function(env2, scope) {
+                        return scope.def(env2.shared.vao + ".currentVAO?" + env2.shared.vao + ".currentVAO.primitive:" + GL_TRIANGLES$1);
+                      }
+                    );
+                  }
+                  return null;
+                }
+                function parseParam(param, isOffset) {
+                  if (param in staticOptions) {
+                    var value = staticOptions[param] | 0;
+                    if (isOffset) {
+                      staticDraw.offset = value;
+                    } else {
+                      staticDraw.instances = value;
+                    }
+                    return createStaticDecl(function(env2, scope) {
+                      if (isOffset) {
+                        env2.OFFSET = value;
+                      }
+                      return value;
+                    });
+                  } else if (param in dynamicOptions) {
+                    var dynValue = dynamicOptions[param];
+                    return createDynamicDecl(dynValue, function(env2, scope) {
+                      var result = env2.invoke(scope, dynValue);
+                      if (isOffset) {
+                        env2.OFFSET = result;
+                      }
+                      return result;
+                    });
+                  } else if (isOffset) {
+                    if (elementsActive) {
+                      return createStaticDecl(function(env2, scope) {
+                        env2.OFFSET = 0;
+                        return 0;
+                      });
+                    } else if (vaoActive) {
+                      return new Declaration(
+                        vao.thisDep,
+                        vao.contextDep,
+                        vao.propDep,
+                        function(env2, scope) {
+                          return scope.def(env2.shared.vao + ".currentVAO?" + env2.shared.vao + ".currentVAO.offset:0");
+                        }
+                      );
+                    }
+                  } else if (vaoActive) {
+                    return new Declaration(
+                      vao.thisDep,
+                      vao.contextDep,
+                      vao.propDep,
+                      function(env2, scope) {
+                        return scope.def(env2.shared.vao + ".currentVAO?" + env2.shared.vao + ".currentVAO.instances:-1");
+                      }
+                    );
+                  }
+                  return null;
+                }
+                var OFFSET = parseParam(S_OFFSET, true);
+                function parseVertCount() {
+                  if (S_COUNT in staticOptions) {
+                    var count22 = staticOptions[S_COUNT] | 0;
+                    staticDraw.count = count22;
+                    return createStaticDecl(function() {
+                      return count22;
+                    });
+                  } else if (S_COUNT in dynamicOptions) {
+                    var dynCount = dynamicOptions[S_COUNT];
+                    return createDynamicDecl(dynCount, function(env2, scope) {
+                      var result2 = env2.invoke(scope, dynCount);
+                      return result2;
+                    });
+                  } else if (elementsActive) {
+                    if (isStatic(elements)) {
+                      if (elements) {
+                        if (OFFSET) {
+                          return new Declaration(
+                            OFFSET.thisDep,
+                            OFFSET.contextDep,
+                            OFFSET.propDep,
+                            function(env2, scope) {
+                              var result2 = scope.def(
+                                env2.ELEMENTS,
+                                ".vertCount-",
+                                env2.OFFSET
+                              );
+                              return result2;
+                            }
+                          );
+                        } else {
+                          return createStaticDecl(function(env2, scope) {
+                            return scope.def(env2.ELEMENTS, ".vertCount");
+                          });
+                        }
+                      } else {
+                        var result = createStaticDecl(function() {
+                          return -1;
+                        });
+                        return result;
+                      }
+                    } else {
+                      var variable = new Declaration(
+                        elements.thisDep || OFFSET.thisDep,
+                        elements.contextDep || OFFSET.contextDep,
+                        elements.propDep || OFFSET.propDep,
+                        function(env2, scope) {
+                          var elements2 = env2.ELEMENTS;
+                          if (env2.OFFSET) {
+                            return scope.def(
+                              elements2,
+                              "?",
+                              elements2,
+                              ".vertCount-",
+                              env2.OFFSET,
+                              ":-1"
+                            );
+                          }
+                          return scope.def(elements2, "?", elements2, ".vertCount:-1");
+                        }
+                      );
+                      return variable;
+                    }
+                  } else if (vaoActive) {
+                    var countVariable = new Declaration(
+                      vao.thisDep,
+                      vao.contextDep,
+                      vao.propDep,
+                      function(env2, scope) {
+                        return scope.def(env2.shared.vao, ".currentVAO?", env2.shared.vao, ".currentVAO.count:-1");
+                      }
+                    );
+                    return countVariable;
+                  }
+                  return null;
+                }
+                var primitive = parsePrimitive();
+                var count2 = parseVertCount();
+                var instances = parseParam(S_INSTANCES, false);
+                return {
+                  elements,
+                  primitive,
+                  count: count2,
+                  instances,
+                  offset: OFFSET,
+                  vao,
+                  vaoActive,
+                  elementsActive,
+                  // static draw props
+                  static: staticDraw
+                };
+              }
+              function parseGLState(options, env) {
+                var staticOptions = options.static;
+                var dynamicOptions = options.dynamic;
+                var STATE = {};
+                GL_STATE_NAMES.forEach(function(prop) {
+                  var param = propName(prop);
+                  function parseParam(parseStatic, parseDynamic) {
+                    if (prop in staticOptions) {
+                      var value = parseStatic(staticOptions[prop]);
+                      STATE[param] = createStaticDecl(function() {
+                        return value;
+                      });
+                    } else if (prop in dynamicOptions) {
+                      var dyn = dynamicOptions[prop];
+                      STATE[param] = createDynamicDecl(dyn, function(env2, scope) {
+                        return parseDynamic(env2, scope, env2.invoke(scope, dyn));
+                      });
+                    }
+                  }
+                  switch (prop) {
+                    case S_CULL_ENABLE:
+                    case S_BLEND_ENABLE:
+                    case S_DITHER:
+                    case S_STENCIL_ENABLE:
+                    case S_DEPTH_ENABLE:
+                    case S_SCISSOR_ENABLE:
+                    case S_POLYGON_OFFSET_ENABLE:
+                    case S_SAMPLE_ALPHA:
+                    case S_SAMPLE_ENABLE:
+                    case S_DEPTH_MASK:
+                      return parseParam(
+                        function(value) {
+                          return value;
+                        },
+                        function(env2, scope, value) {
+                          return value;
+                        }
+                      );
+                    case S_DEPTH_FUNC:
+                      return parseParam(
+                        function(value) {
+                          return compareFuncs[value];
+                        },
+                        function(env2, scope, value) {
+                          var COMPARE_FUNCS = env2.constants.compareFuncs;
+                          return scope.def(COMPARE_FUNCS, "[", value, "]");
+                        }
+                      );
+                    case S_DEPTH_RANGE:
+                      return parseParam(
+                        function(value) {
+                          return value;
+                        },
+                        function(env2, scope, value) {
+                          var Z_NEAR = scope.def("+", value, "[0]");
+                          var Z_FAR = scope.def("+", value, "[1]");
+                          return [Z_NEAR, Z_FAR];
+                        }
+                      );
+                    case S_BLEND_FUNC:
+                      return parseParam(
+                        function(value) {
+                          var srcRGB = "srcRGB" in value ? value.srcRGB : value.src;
+                          var srcAlpha = "srcAlpha" in value ? value.srcAlpha : value.src;
+                          var dstRGB = "dstRGB" in value ? value.dstRGB : value.dst;
+                          var dstAlpha = "dstAlpha" in value ? value.dstAlpha : value.dst;
+                          return [
+                            blendFuncs[srcRGB],
+                            blendFuncs[dstRGB],
+                            blendFuncs[srcAlpha],
+                            blendFuncs[dstAlpha]
+                          ];
+                        },
+                        function(env2, scope, value) {
+                          var BLEND_FUNCS = env2.constants.blendFuncs;
+                          function read(prefix, suffix) {
+                            var func = scope.def(
+                              '"',
+                              prefix,
+                              suffix,
+                              '" in ',
+                              value,
+                              "?",
+                              value,
+                              ".",
+                              prefix,
+                              suffix,
+                              ":",
+                              value,
+                              ".",
+                              prefix
+                            );
+                            return func;
+                          }
+                          var srcRGB = read("src", "RGB");
+                          var dstRGB = read("dst", "RGB");
+                          var SRC_RGB = scope.def(BLEND_FUNCS, "[", srcRGB, "]");
+                          var SRC_ALPHA = scope.def(BLEND_FUNCS, "[", read("src", "Alpha"), "]");
+                          var DST_RGB = scope.def(BLEND_FUNCS, "[", dstRGB, "]");
+                          var DST_ALPHA = scope.def(BLEND_FUNCS, "[", read("dst", "Alpha"), "]");
+                          return [SRC_RGB, DST_RGB, SRC_ALPHA, DST_ALPHA];
+                        }
+                      );
+                    case S_BLEND_EQUATION:
+                      return parseParam(
+                        function(value) {
+                          if (typeof value === "string") {
+                            return [
+                              blendEquations[value],
+                              blendEquations[value]
+                            ];
+                          } else if (typeof value === "object") {
+                            return [
+                              blendEquations[value.rgb],
+                              blendEquations[value.alpha]
+                            ];
+                          } else ;
+                        },
+                        function(env2, scope, value) {
+                          var BLEND_EQUATIONS = env2.constants.blendEquations;
+                          var RGB = scope.def();
+                          var ALPHA = scope.def();
+                          var ifte = env2.cond("typeof ", value, '==="string"');
+                          ifte.then(
+                            RGB,
+                            "=",
+                            ALPHA,
+                            "=",
+                            BLEND_EQUATIONS,
+                            "[",
+                            value,
+                            "];"
+                          );
+                          ifte.else(
+                            RGB,
+                            "=",
+                            BLEND_EQUATIONS,
+                            "[",
+                            value,
+                            ".rgb];",
+                            ALPHA,
+                            "=",
+                            BLEND_EQUATIONS,
+                            "[",
+                            value,
+                            ".alpha];"
+                          );
+                          scope(ifte);
+                          return [RGB, ALPHA];
+                        }
+                      );
+                    case S_BLEND_COLOR:
+                      return parseParam(
+                        function(value) {
+                          return loop(4, function(i2) {
+                            return +value[i2];
+                          });
+                        },
+                        function(env2, scope, value) {
+                          return loop(4, function(i2) {
+                            return scope.def("+", value, "[", i2, "]");
+                          });
+                        }
+                      );
+                    case S_STENCIL_MASK:
+                      return parseParam(
+                        function(value) {
+                          return value | 0;
+                        },
+                        function(env2, scope, value) {
+                          return scope.def(value, "|0");
+                        }
+                      );
+                    case S_STENCIL_FUNC:
+                      return parseParam(
+                        function(value) {
+                          var cmp = value.cmp || "keep";
+                          var ref = value.ref || 0;
+                          var mask = "mask" in value ? value.mask : -1;
+                          return [
+                            compareFuncs[cmp],
+                            ref,
+                            mask
+                          ];
+                        },
+                        function(env2, scope, value) {
+                          var COMPARE_FUNCS = env2.constants.compareFuncs;
+                          var cmp = scope.def(
+                            '"cmp" in ',
+                            value,
+                            "?",
+                            COMPARE_FUNCS,
+                            "[",
+                            value,
+                            ".cmp]",
+                            ":",
+                            GL_KEEP
+                          );
+                          var ref = scope.def(value, ".ref|0");
+                          var mask = scope.def(
+                            '"mask" in ',
+                            value,
+                            "?",
+                            value,
+                            ".mask|0:-1"
+                          );
+                          return [cmp, ref, mask];
+                        }
+                      );
+                    case S_STENCIL_OPFRONT:
+                    case S_STENCIL_OPBACK:
+                      return parseParam(
+                        function(value) {
+                          var fail = value.fail || "keep";
+                          var zfail = value.zfail || "keep";
+                          var zpass = value.zpass || "keep";
+                          return [
+                            prop === S_STENCIL_OPBACK ? GL_BACK : GL_FRONT,
+                            stencilOps[fail],
+                            stencilOps[zfail],
+                            stencilOps[zpass]
+                          ];
+                        },
+                        function(env2, scope, value) {
+                          var STENCIL_OPS = env2.constants.stencilOps;
+                          function read(name2) {
+                            return scope.def(
+                              '"',
+                              name2,
+                              '" in ',
+                              value,
+                              "?",
+                              STENCIL_OPS,
+                              "[",
+                              value,
+                              ".",
+                              name2,
+                              "]:",
+                              GL_KEEP
+                            );
+                          }
+                          return [
+                            prop === S_STENCIL_OPBACK ? GL_BACK : GL_FRONT,
+                            read("fail"),
+                            read("zfail"),
+                            read("zpass")
+                          ];
+                        }
+                      );
+                    case S_POLYGON_OFFSET_OFFSET:
+                      return parseParam(
+                        function(value) {
+                          var factor = value.factor | 0;
+                          var units = value.units | 0;
+                          return [factor, units];
+                        },
+                        function(env2, scope, value) {
+                          var FACTOR = scope.def(value, ".factor|0");
+                          var UNITS = scope.def(value, ".units|0");
+                          return [FACTOR, UNITS];
+                        }
+                      );
+                    case S_CULL_FACE:
+                      return parseParam(
+                        function(value) {
+                          var face = 0;
+                          if (value === "front") {
+                            face = GL_FRONT;
+                          } else if (value === "back") {
+                            face = GL_BACK;
+                          }
+                          return face;
+                        },
+                        function(env2, scope, value) {
+                          return scope.def(value, '==="front"?', GL_FRONT, ":", GL_BACK);
+                        }
+                      );
+                    case S_LINE_WIDTH:
+                      return parseParam(
+                        function(value) {
+                          return value;
+                        },
+                        function(env2, scope, value) {
+                          return value;
+                        }
+                      );
+                    case S_FRONT_FACE:
+                      return parseParam(
+                        function(value) {
+                          return orientationType[value];
+                        },
+                        function(env2, scope, value) {
+                          return scope.def(value + '==="cw"?' + GL_CW + ":" + GL_CCW);
+                        }
+                      );
+                    case S_COLOR_MASK:
+                      return parseParam(
+                        function(value) {
+                          return value.map(function(v2) {
+                            return !!v2;
+                          });
+                        },
+                        function(env2, scope, value) {
+                          return loop(4, function(i2) {
+                            return "!!" + value + "[" + i2 + "]";
+                          });
+                        }
+                      );
+                    case S_SAMPLE_COVERAGE:
+                      return parseParam(
+                        function(value) {
+                          var sampleValue = "value" in value ? value.value : 1;
+                          var sampleInvert = !!value.invert;
+                          return [sampleValue, sampleInvert];
+                        },
+                        function(env2, scope, value) {
+                          var VALUE = scope.def(
+                            '"value" in ',
+                            value,
+                            "?+",
+                            value,
+                            ".value:1"
+                          );
+                          var INVERT = scope.def("!!", value, ".invert");
+                          return [VALUE, INVERT];
+                        }
+                      );
+                  }
+                });
+                return STATE;
+              }
+              function parseUniforms(uniforms, env) {
+                var staticUniforms = uniforms.static;
+                var dynamicUniforms = uniforms.dynamic;
+                var UNIFORMS = {};
+                Object.keys(staticUniforms).forEach(function(name2) {
+                  var value = staticUniforms[name2];
+                  var result;
+                  if (typeof value === "number" || typeof value === "boolean") {
+                    result = createStaticDecl(function() {
+                      return value;
+                    });
+                  } else if (typeof value === "function") {
+                    var reglType = value._reglType;
+                    if (reglType === "texture2d" || reglType === "textureCube") {
+                      result = createStaticDecl(function(env2) {
+                        return env2.link(value);
+                      });
+                    } else if (reglType === "framebuffer" || reglType === "framebufferCube") {
+                      result = createStaticDecl(function(env2) {
+                        return env2.link(value.color[0]);
+                      });
+                    } else ;
+                  } else if (isArrayLike(value)) {
+                    result = createStaticDecl(function(env2) {
+                      var ITEM = env2.global.def(
+                        "[",
+                        loop(value.length, function(i2) {
+                          return value[i2];
+                        }),
+                        "]"
+                      );
+                      return ITEM;
+                    });
+                  } else ;
+                  result.value = value;
+                  UNIFORMS[name2] = result;
+                });
+                Object.keys(dynamicUniforms).forEach(function(key) {
+                  var dyn = dynamicUniforms[key];
+                  UNIFORMS[key] = createDynamicDecl(dyn, function(env2, scope) {
+                    return env2.invoke(scope, dyn);
+                  });
+                });
+                return UNIFORMS;
+              }
+              function parseAttributes(attributes, env) {
+                var staticAttributes = attributes.static;
+                var dynamicAttributes = attributes.dynamic;
+                var attributeDefs = {};
+                Object.keys(staticAttributes).forEach(function(attribute) {
+                  var value = staticAttributes[attribute];
+                  var id2 = stringStore.id(attribute);
+                  var record = new AttributeRecord2();
+                  if (isBufferArgs(value)) {
+                    record.state = ATTRIB_STATE_POINTER;
+                    record.buffer = bufferState.getBuffer(
+                      bufferState.create(value, GL_ARRAY_BUFFER$2, false, true)
+                    );
+                    record.type = 0;
+                  } else {
+                    var buffer = bufferState.getBuffer(value);
+                    if (buffer) {
+                      record.state = ATTRIB_STATE_POINTER;
+                      record.buffer = buffer;
+                      record.type = 0;
+                    } else {
+                      if ("constant" in value) {
+                        var constant = value.constant;
+                        record.buffer = "null";
+                        record.state = ATTRIB_STATE_CONSTANT;
+                        if (typeof constant === "number") {
+                          record.x = constant;
+                        } else {
+                          CUTE_COMPONENTS.forEach(function(c2, i2) {
+                            if (i2 < constant.length) {
+                              record[c2] = constant[i2];
+                            }
+                          });
+                        }
+                      } else {
+                        if (isBufferArgs(value.buffer)) {
+                          buffer = bufferState.getBuffer(
+                            bufferState.create(value.buffer, GL_ARRAY_BUFFER$2, false, true)
+                          );
+                        } else {
+                          buffer = bufferState.getBuffer(value.buffer);
+                        }
+                        var offset = value.offset | 0;
+                        var stride = value.stride | 0;
+                        var size = value.size | 0;
+                        var normalized = !!value.normalized;
+                        var type = 0;
+                        if ("type" in value) {
+                          type = glTypes[value.type];
+                        }
+                        var divisor = value.divisor | 0;
+                        record.buffer = buffer;
+                        record.state = ATTRIB_STATE_POINTER;
+                        record.size = size;
+                        record.normalized = normalized;
+                        record.type = type || buffer.dtype;
+                        record.offset = offset;
+                        record.stride = stride;
+                        record.divisor = divisor;
+                      }
+                    }
+                  }
+                  attributeDefs[attribute] = createStaticDecl(function(env2, scope) {
+                    var cache = env2.attribCache;
+                    if (id2 in cache) {
+                      return cache[id2];
+                    }
+                    var result = {
+                      isStream: false
+                    };
+                    Object.keys(record).forEach(function(key) {
+                      result[key] = record[key];
+                    });
+                    if (record.buffer) {
+                      result.buffer = env2.link(record.buffer);
+                      result.type = result.type || result.buffer + ".dtype";
+                    }
+                    cache[id2] = result;
+                    return result;
+                  });
+                });
+                Object.keys(dynamicAttributes).forEach(function(attribute) {
+                  var dyn = dynamicAttributes[attribute];
+                  function appendAttributeCode(env2, block) {
+                    var VALUE = env2.invoke(block, dyn);
+                    var shared = env2.shared;
+                    var constants = env2.constants;
+                    var IS_BUFFER_ARGS = shared.isBufferArgs;
+                    var BUFFER_STATE = shared.buffer;
+                    var result = {
+                      isStream: block.def(false)
+                    };
+                    var defaultRecord = new AttributeRecord2();
+                    defaultRecord.state = ATTRIB_STATE_POINTER;
+                    Object.keys(defaultRecord).forEach(function(key) {
+                      result[key] = block.def("" + defaultRecord[key]);
+                    });
+                    var BUFFER = result.buffer;
+                    var TYPE = result.type;
+                    block(
+                      "if(",
+                      IS_BUFFER_ARGS,
+                      "(",
+                      VALUE,
+                      ")){",
+                      result.isStream,
+                      "=true;",
+                      BUFFER,
+                      "=",
+                      BUFFER_STATE,
+                      ".createStream(",
+                      GL_ARRAY_BUFFER$2,
+                      ",",
+                      VALUE,
+                      ");",
+                      TYPE,
+                      "=",
+                      BUFFER,
+                      ".dtype;",
+                      "}else{",
+                      BUFFER,
+                      "=",
+                      BUFFER_STATE,
+                      ".getBuffer(",
+                      VALUE,
+                      ");",
+                      "if(",
+                      BUFFER,
+                      "){",
+                      TYPE,
+                      "=",
+                      BUFFER,
+                      ".dtype;",
+                      '}else if("constant" in ',
+                      VALUE,
+                      "){",
+                      result.state,
+                      "=",
+                      ATTRIB_STATE_CONSTANT,
+                      ";",
+                      "if(typeof " + VALUE + '.constant === "number"){',
+                      result[CUTE_COMPONENTS[0]],
+                      "=",
+                      VALUE,
+                      ".constant;",
+                      CUTE_COMPONENTS.slice(1).map(function(n2) {
+                        return result[n2];
+                      }).join("="),
+                      "=0;",
+                      "}else{",
+                      CUTE_COMPONENTS.map(function(name2, i2) {
+                        return result[name2] + "=" + VALUE + ".constant.length>" + i2 + "?" + VALUE + ".constant[" + i2 + "]:0;";
+                      }).join(""),
+                      "}}else{",
+                      "if(",
+                      IS_BUFFER_ARGS,
+                      "(",
+                      VALUE,
+                      ".buffer)){",
+                      BUFFER,
+                      "=",
+                      BUFFER_STATE,
+                      ".createStream(",
+                      GL_ARRAY_BUFFER$2,
+                      ",",
+                      VALUE,
+                      ".buffer);",
+                      "}else{",
+                      BUFFER,
+                      "=",
+                      BUFFER_STATE,
+                      ".getBuffer(",
+                      VALUE,
+                      ".buffer);",
+                      "}",
+                      TYPE,
+                      '="type" in ',
+                      VALUE,
+                      "?",
+                      constants.glTypes,
+                      "[",
+                      VALUE,
+                      ".type]:",
+                      BUFFER,
+                      ".dtype;",
+                      result.normalized,
+                      "=!!",
+                      VALUE,
+                      ".normalized;"
+                    );
+                    function emitReadRecord(name2) {
+                      block(result[name2], "=", VALUE, ".", name2, "|0;");
+                    }
+                    emitReadRecord("size");
+                    emitReadRecord("offset");
+                    emitReadRecord("stride");
+                    emitReadRecord("divisor");
+                    block("}}");
+                    block.exit(
+                      "if(",
+                      result.isStream,
+                      "){",
+                      BUFFER_STATE,
+                      ".destroyStream(",
+                      BUFFER,
+                      ");",
+                      "}"
+                    );
+                    return result;
+                  }
+                  attributeDefs[attribute] = createDynamicDecl(dyn, appendAttributeCode);
+                });
+                return attributeDefs;
+              }
+              function parseContext(context) {
+                var staticContext = context.static;
+                var dynamicContext = context.dynamic;
+                var result = {};
+                Object.keys(staticContext).forEach(function(name2) {
+                  var value = staticContext[name2];
+                  result[name2] = createStaticDecl(function(env, scope) {
+                    if (typeof value === "number" || typeof value === "boolean") {
+                      return "" + value;
+                    } else {
+                      return env.link(value);
+                    }
+                  });
+                });
+                Object.keys(dynamicContext).forEach(function(name2) {
+                  var dyn = dynamicContext[name2];
+                  result[name2] = createDynamicDecl(dyn, function(env, scope) {
+                    return env.invoke(scope, dyn);
+                  });
+                });
+                return result;
+              }
+              function parseArguments(options, attributes, uniforms, context, env) {
+                options.static;
+                options.dynamic;
+                var attribLocations = parseAttribLocations(options, attributes);
+                var framebuffer = parseFramebuffer(options);
+                var viewportAndScissor = parseViewportScissor(options, framebuffer);
+                var draw = parseDraw(options);
+                var state = parseGLState(options);
+                var shader = parseProgram(options, env, attribLocations);
+                function copyBox(name2) {
+                  var defn = viewportAndScissor[name2];
+                  if (defn) {
+                    state[name2] = defn;
+                  }
+                }
+                copyBox(S_VIEWPORT);
+                copyBox(propName(S_SCISSOR_BOX));
+                var dirty = Object.keys(state).length > 0;
+                var result = {
+                  framebuffer,
+                  draw,
+                  shader,
+                  state,
+                  dirty,
+                  scopeVAO: null,
+                  drawVAO: null,
+                  useVAO: false,
+                  attributes: {}
+                };
+                result.profile = parseProfile(options);
+                result.uniforms = parseUniforms(uniforms);
+                result.drawVAO = result.scopeVAO = draw.vao;
+                if (!result.drawVAO && shader.program && !attribLocations && extensions.angle_instanced_arrays && draw.static.elements) {
+                  var useVAO = true;
+                  var staticBindings = shader.program.attributes.map(function(attr) {
+                    var binding = attributes.static[attr];
+                    useVAO = useVAO && !!binding;
+                    return binding;
+                  });
+                  if (useVAO && staticBindings.length > 0) {
+                    var vao = attributeState.getVAO(attributeState.createVAO({
+                      attributes: staticBindings,
+                      elements: draw.static.elements
+                    }));
+                    result.drawVAO = new Declaration(null, null, null, function(env2, scope) {
+                      return env2.link(vao);
+                    });
+                    result.useVAO = true;
+                  }
+                }
+                if (attribLocations) {
+                  result.useVAO = true;
+                } else {
+                  result.attributes = parseAttributes(attributes);
+                }
+                result.context = parseContext(context);
+                return result;
+              }
+              function emitContext(env, scope, context) {
+                var shared = env.shared;
+                var CONTEXT = shared.context;
+                var contextEnter = env.scope();
+                Object.keys(context).forEach(function(name2) {
+                  scope.save(CONTEXT, "." + name2);
+                  var defn = context[name2];
+                  var value = defn.append(env, scope);
+                  if (Array.isArray(value)) {
+                    contextEnter(CONTEXT, ".", name2, "=[", value.join(), "];");
+                  } else {
+                    contextEnter(CONTEXT, ".", name2, "=", value, ";");
+                  }
+                });
+                scope(contextEnter);
+              }
+              function emitPollFramebuffer(env, scope, framebuffer, skipCheck) {
+                var shared = env.shared;
+                var GL = shared.gl;
+                var FRAMEBUFFER_STATE = shared.framebuffer;
+                var EXT_DRAW_BUFFERS;
+                if (extDrawBuffers) {
+                  EXT_DRAW_BUFFERS = scope.def(shared.extensions, ".webgl_draw_buffers");
+                }
+                var constants = env.constants;
+                var DRAW_BUFFERS = constants.drawBuffer;
+                var BACK_BUFFER = constants.backBuffer;
+                var NEXT;
+                if (framebuffer) {
+                  NEXT = framebuffer.append(env, scope);
+                } else {
+                  NEXT = scope.def(FRAMEBUFFER_STATE, ".next");
+                }
+                if (!skipCheck) {
+                  scope("if(", NEXT, "!==", FRAMEBUFFER_STATE, ".cur){");
+                }
+                scope(
+                  "if(",
+                  NEXT,
+                  "){",
+                  GL,
+                  ".bindFramebuffer(",
+                  GL_FRAMEBUFFER$2,
+                  ",",
+                  NEXT,
+                  ".framebuffer);"
+                );
+                if (extDrawBuffers) {
+                  scope(
+                    EXT_DRAW_BUFFERS,
+                    ".drawBuffersWEBGL(",
+                    DRAW_BUFFERS,
+                    "[",
+                    NEXT,
+                    ".colorAttachments.length]);"
+                  );
+                }
+                scope(
+                  "}else{",
+                  GL,
+                  ".bindFramebuffer(",
+                  GL_FRAMEBUFFER$2,
+                  ",null);"
+                );
+                if (extDrawBuffers) {
+                  scope(EXT_DRAW_BUFFERS, ".drawBuffersWEBGL(", BACK_BUFFER, ");");
+                }
+                scope(
+                  "}",
+                  FRAMEBUFFER_STATE,
+                  ".cur=",
+                  NEXT,
+                  ";"
+                );
+                if (!skipCheck) {
+                  scope("}");
+                }
+              }
+              function emitPollState(env, scope, args) {
+                var shared = env.shared;
+                var GL = shared.gl;
+                var CURRENT_VARS = env.current;
+                var NEXT_VARS = env.next;
+                var CURRENT_STATE = shared.current;
+                var NEXT_STATE = shared.next;
+                var block = env.cond(CURRENT_STATE, ".dirty");
+                GL_STATE_NAMES.forEach(function(prop) {
+                  var param = propName(prop);
+                  if (param in args.state) {
+                    return;
+                  }
+                  var NEXT, CURRENT;
+                  if (param in NEXT_VARS) {
+                    NEXT = NEXT_VARS[param];
+                    CURRENT = CURRENT_VARS[param];
+                    var parts = loop(currentState[param].length, function(i2) {
+                      return block.def(NEXT, "[", i2, "]");
+                    });
+                    block(env.cond(parts.map(function(p2, i2) {
+                      return p2 + "!==" + CURRENT + "[" + i2 + "]";
+                    }).join("||")).then(
+                      GL,
+                      ".",
+                      GL_VARIABLES[param],
+                      "(",
+                      parts,
+                      ");",
+                      parts.map(function(p2, i2) {
+                        return CURRENT + "[" + i2 + "]=" + p2;
+                      }).join(";"),
+                      ";"
+                    ));
+                  } else {
+                    NEXT = block.def(NEXT_STATE, ".", param);
+                    var ifte = env.cond(NEXT, "!==", CURRENT_STATE, ".", param);
+                    block(ifte);
+                    if (param in GL_FLAGS) {
+                      ifte(
+                        env.cond(NEXT).then(GL, ".enable(", GL_FLAGS[param], ");").else(GL, ".disable(", GL_FLAGS[param], ");"),
+                        CURRENT_STATE,
+                        ".",
+                        param,
+                        "=",
+                        NEXT,
+                        ";"
+                      );
+                    } else {
+                      ifte(
+                        GL,
+                        ".",
+                        GL_VARIABLES[param],
+                        "(",
+                        NEXT,
+                        ");",
+                        CURRENT_STATE,
+                        ".",
+                        param,
+                        "=",
+                        NEXT,
+                        ";"
+                      );
+                    }
+                  }
+                });
+                if (Object.keys(args.state).length === 0) {
+                  block(CURRENT_STATE, ".dirty=false;");
+                }
+                scope(block);
+              }
+              function emitSetOptions(env, scope, options, filter) {
+                var shared = env.shared;
+                var CURRENT_VARS = env.current;
+                var CURRENT_STATE = shared.current;
+                var GL = shared.gl;
+                var VALUE;
+                sortState(Object.keys(options)).forEach(function(param) {
+                  var defn = options[param];
+                  if (filter && !filter(defn)) {
+                    return;
+                  }
+                  var variable = defn.append(env, scope);
+                  if (GL_FLAGS[param]) {
+                    var flag = GL_FLAGS[param];
+                    if (isStatic(defn)) {
+                      VALUE = env.link(variable, { stable: true });
+                      scope(env.cond(VALUE).then(GL, ".enable(", flag, ");").else(GL, ".disable(", flag, ");"));
+                      scope(CURRENT_STATE, ".", param, "=", VALUE, ";");
+                    } else {
+                      scope(env.cond(variable).then(GL, ".enable(", flag, ");").else(GL, ".disable(", flag, ");"));
+                      scope(CURRENT_STATE, ".", param, "=", variable, ";");
+                    }
+                  } else if (isArrayLike(variable)) {
+                    var CURRENT = CURRENT_VARS[param];
+                    scope(
+                      GL,
+                      ".",
+                      GL_VARIABLES[param],
+                      "(",
+                      variable,
+                      ");",
+                      variable.map(function(v2, i2) {
+                        return CURRENT + "[" + i2 + "]=" + v2;
+                      }).join(";"),
+                      ";"
+                    );
+                  } else {
+                    if (isStatic(defn)) {
+                      VALUE = env.link(variable, { stable: true });
+                      scope(
+                        GL,
+                        ".",
+                        GL_VARIABLES[param],
+                        "(",
+                        VALUE,
+                        ");",
+                        CURRENT_STATE,
+                        ".",
+                        param,
+                        "=",
+                        VALUE,
+                        ";"
+                      );
+                    } else {
+                      scope(
+                        GL,
+                        ".",
+                        GL_VARIABLES[param],
+                        "(",
+                        variable,
+                        ");",
+                        CURRENT_STATE,
+                        ".",
+                        param,
+                        "=",
+                        variable,
+                        ";"
+                      );
+                    }
+                  }
+                });
+              }
+              function injectExtensions(env, scope) {
+                if (extInstancing) {
+                  env.instancing = scope.def(
+                    env.shared.extensions,
+                    ".angle_instanced_arrays"
+                  );
+                }
+              }
+              function emitProfile(env, scope, args, useScope, incrementCounter) {
+                var shared = env.shared;
+                var STATS = env.stats;
+                var CURRENT_STATE = shared.current;
+                var TIMER = shared.timer;
+                var profileArg = args.profile;
+                function perfCounter() {
+                  if (typeof performance === "undefined") {
+                    return "Date.now()";
+                  } else {
+                    return "performance.now()";
+                  }
+                }
+                var CPU_START, QUERY_COUNTER;
+                function emitProfileStart(block) {
+                  CPU_START = scope.def();
+                  block(CPU_START, "=", perfCounter(), ";");
+                  if (typeof incrementCounter === "string") {
+                    block(STATS, ".count+=", incrementCounter, ";");
+                  } else {
+                    block(STATS, ".count++;");
+                  }
+                  if (timer) {
+                    if (useScope) {
+                      QUERY_COUNTER = scope.def();
+                      block(QUERY_COUNTER, "=", TIMER, ".getNumPendingQueries();");
+                    } else {
+                      block(TIMER, ".beginQuery(", STATS, ");");
+                    }
+                  }
+                }
+                function emitProfileEnd(block) {
+                  block(STATS, ".cpuTime+=", perfCounter(), "-", CPU_START, ";");
+                  if (timer) {
+                    if (useScope) {
+                      block(
+                        TIMER,
+                        ".pushScopeStats(",
+                        QUERY_COUNTER,
+                        ",",
+                        TIMER,
+                        ".getNumPendingQueries(),",
+                        STATS,
+                        ");"
+                      );
+                    } else {
+                      block(TIMER, ".endQuery();");
+                    }
+                  }
+                }
+                function scopeProfile(value) {
+                  var prev = scope.def(CURRENT_STATE, ".profile");
+                  scope(CURRENT_STATE, ".profile=", value, ";");
+                  scope.exit(CURRENT_STATE, ".profile=", prev, ";");
+                }
+                var USE_PROFILE;
+                if (profileArg) {
+                  if (isStatic(profileArg)) {
+                    if (profileArg.enable) {
+                      emitProfileStart(scope);
+                      emitProfileEnd(scope.exit);
+                      scopeProfile("true");
+                    } else {
+                      scopeProfile("false");
+                    }
+                    return;
+                  }
+                  USE_PROFILE = profileArg.append(env, scope);
+                  scopeProfile(USE_PROFILE);
+                } else {
+                  USE_PROFILE = scope.def(CURRENT_STATE, ".profile");
+                }
+                var start = env.block();
+                emitProfileStart(start);
+                scope("if(", USE_PROFILE, "){", start, "}");
+                var end = env.block();
+                emitProfileEnd(end);
+                scope.exit("if(", USE_PROFILE, "){", end, "}");
+              }
+              function emitAttributes(env, scope, args, attributes, filter) {
+                var shared = env.shared;
+                function typeLength(x2) {
+                  switch (x2) {
+                    case GL_FLOAT_VEC2:
+                    case GL_INT_VEC2:
+                    case GL_BOOL_VEC2:
+                      return 2;
+                    case GL_FLOAT_VEC3:
+                    case GL_INT_VEC3:
+                    case GL_BOOL_VEC3:
+                      return 3;
+                    case GL_FLOAT_VEC4:
+                    case GL_INT_VEC4:
+                    case GL_BOOL_VEC4:
+                      return 4;
+                    default:
+                      return 1;
+                  }
+                }
+                function emitBindAttribute(ATTRIBUTE, size, record) {
+                  var GL = shared.gl;
+                  var LOCATION = scope.def(ATTRIBUTE, ".location");
+                  var BINDING = scope.def(shared.attributes, "[", LOCATION, "]");
+                  var STATE = record.state;
+                  var BUFFER = record.buffer;
+                  var CONST_COMPONENTS = [
+                    record.x,
+                    record.y,
+                    record.z,
+                    record.w
+                  ];
+                  var COMMON_KEYS = [
+                    "buffer",
+                    "normalized",
+                    "offset",
+                    "stride"
+                  ];
+                  function emitBuffer() {
+                    scope(
+                      "if(!",
+                      BINDING,
+                      ".buffer){",
+                      GL,
+                      ".enableVertexAttribArray(",
+                      LOCATION,
+                      ");}"
+                    );
+                    var TYPE = record.type;
+                    var SIZE;
+                    if (!record.size) {
+                      SIZE = size;
+                    } else {
+                      SIZE = scope.def(record.size, "||", size);
+                    }
+                    scope(
+                      "if(",
+                      BINDING,
+                      ".type!==",
+                      TYPE,
+                      "||",
+                      BINDING,
+                      ".size!==",
+                      SIZE,
+                      "||",
+                      COMMON_KEYS.map(function(key) {
+                        return BINDING + "." + key + "!==" + record[key];
+                      }).join("||"),
+                      "){",
+                      GL,
+                      ".bindBuffer(",
+                      GL_ARRAY_BUFFER$2,
+                      ",",
+                      BUFFER,
+                      ".buffer);",
+                      GL,
+                      ".vertexAttribPointer(",
+                      [
+                        LOCATION,
+                        SIZE,
+                        TYPE,
+                        record.normalized,
+                        record.stride,
+                        record.offset
+                      ],
+                      ");",
+                      BINDING,
+                      ".type=",
+                      TYPE,
+                      ";",
+                      BINDING,
+                      ".size=",
+                      SIZE,
+                      ";",
+                      COMMON_KEYS.map(function(key) {
+                        return BINDING + "." + key + "=" + record[key] + ";";
+                      }).join(""),
+                      "}"
+                    );
+                    if (extInstancing) {
+                      var DIVISOR = record.divisor;
+                      scope(
+                        "if(",
+                        BINDING,
+                        ".divisor!==",
+                        DIVISOR,
+                        "){",
+                        env.instancing,
+                        ".vertexAttribDivisorANGLE(",
+                        [LOCATION, DIVISOR],
+                        ");",
+                        BINDING,
+                        ".divisor=",
+                        DIVISOR,
+                        ";}"
+                      );
+                    }
+                  }
+                  function emitConstant() {
+                    scope(
+                      "if(",
+                      BINDING,
+                      ".buffer){",
+                      GL,
+                      ".disableVertexAttribArray(",
+                      LOCATION,
+                      ");",
+                      BINDING,
+                      ".buffer=null;",
+                      "}if(",
+                      CUTE_COMPONENTS.map(function(c2, i2) {
+                        return BINDING + "." + c2 + "!==" + CONST_COMPONENTS[i2];
+                      }).join("||"),
+                      "){",
+                      GL,
+                      ".vertexAttrib4f(",
+                      LOCATION,
+                      ",",
+                      CONST_COMPONENTS,
+                      ");",
+                      CUTE_COMPONENTS.map(function(c2, i2) {
+                        return BINDING + "." + c2 + "=" + CONST_COMPONENTS[i2] + ";";
+                      }).join(""),
+                      "}"
+                    );
+                  }
+                  if (STATE === ATTRIB_STATE_POINTER) {
+                    emitBuffer();
+                  } else if (STATE === ATTRIB_STATE_CONSTANT) {
+                    emitConstant();
+                  } else {
+                    scope("if(", STATE, "===", ATTRIB_STATE_POINTER, "){");
+                    emitBuffer();
+                    scope("}else{");
+                    emitConstant();
+                    scope("}");
+                  }
+                }
+                attributes.forEach(function(attribute) {
+                  var name2 = attribute.name;
+                  var arg = args.attributes[name2];
+                  var record;
+                  if (arg) {
+                    if (!filter(arg)) {
+                      return;
+                    }
+                    record = arg.append(env, scope);
+                  } else {
+                    if (!filter(SCOPE_DECL)) {
+                      return;
+                    }
+                    var scopeAttrib = env.scopeAttrib(name2);
+                    record = {};
+                    Object.keys(new AttributeRecord2()).forEach(function(key) {
+                      record[key] = scope.def(scopeAttrib, ".", key);
+                    });
+                  }
+                  emitBindAttribute(
+                    env.link(attribute),
+                    typeLength(attribute.info.type),
+                    record
+                  );
+                });
+              }
+              function emitUniforms(env, scope, args, uniforms, filter, isBatchInnerLoop) {
+                var shared = env.shared;
+                var GL = shared.gl;
+                var infix;
+                for (var i2 = 0; i2 < uniforms.length; ++i2) {
+                  var uniform = uniforms[i2];
+                  var name2 = uniform.name;
+                  var type = uniform.info.type;
+                  var arg = args.uniforms[name2];
+                  var UNIFORM = env.link(uniform);
+                  var LOCATION = UNIFORM + ".location";
+                  var VALUE;
+                  if (arg) {
+                    if (!filter(arg)) {
+                      continue;
+                    }
+                    if (isStatic(arg)) {
+                      var value = arg.value;
+                      if (type === GL_SAMPLER_2D || type === GL_SAMPLER_CUBE) {
+                        var TEX_VALUE = env.link(value._texture || value.color[0]._texture);
+                        scope(GL, ".uniform1i(", LOCATION, ",", TEX_VALUE + ".bind());");
+                        scope.exit(TEX_VALUE, ".unbind();");
+                      } else if (type === GL_FLOAT_MAT2 || type === GL_FLOAT_MAT3 || type === GL_FLOAT_MAT4) {
+                        var MAT_VALUE = env.global.def("new Float32Array([" + Array.prototype.slice.call(value) + "])");
+                        var dim = 2;
+                        if (type === GL_FLOAT_MAT3) {
+                          dim = 3;
+                        } else if (type === GL_FLOAT_MAT4) {
+                          dim = 4;
+                        }
+                        scope(
+                          GL,
+                          ".uniformMatrix",
+                          dim,
+                          "fv(",
+                          LOCATION,
+                          ",false,",
+                          MAT_VALUE,
+                          ");"
+                        );
+                      } else {
+                        switch (type) {
+                          case GL_FLOAT$7:
+                            infix = "1f";
+                            break;
+                          case GL_FLOAT_VEC2:
+                            infix = "2f";
+                            break;
+                          case GL_FLOAT_VEC3:
+                            infix = "3f";
+                            break;
+                          case GL_FLOAT_VEC4:
+                            infix = "4f";
+                            break;
+                          case GL_BOOL:
+                            infix = "1i";
+                            break;
+                          case GL_INT$2:
+                            infix = "1i";
+                            break;
+                          case GL_BOOL_VEC2:
+                            infix = "2i";
+                            break;
+                          case GL_INT_VEC2:
+                            infix = "2i";
+                            break;
+                          case GL_BOOL_VEC3:
+                            infix = "3i";
+                            break;
+                          case GL_INT_VEC3:
+                            infix = "3i";
+                            break;
+                          case GL_BOOL_VEC4:
+                            infix = "4i";
+                            break;
+                          case GL_INT_VEC4:
+                            infix = "4i";
+                            break;
+                        }
+                        scope(
+                          GL,
+                          ".uniform",
+                          infix,
+                          "(",
+                          LOCATION,
+                          ",",
+                          isArrayLike(value) ? Array.prototype.slice.call(value) : value,
+                          ");"
+                        );
+                      }
+                      continue;
+                    } else {
+                      VALUE = arg.append(env, scope);
+                    }
+                  } else {
+                    if (!filter(SCOPE_DECL)) {
+                      continue;
+                    }
+                    VALUE = scope.def(shared.uniforms, "[", stringStore.id(name2), "]");
+                  }
+                  if (type === GL_SAMPLER_2D) {
+                    scope(
+                      "if(",
+                      VALUE,
+                      "&&",
+                      VALUE,
+                      '._reglType==="framebuffer"){',
+                      VALUE,
+                      "=",
+                      VALUE,
+                      ".color[0];",
+                      "}"
+                    );
+                  } else if (type === GL_SAMPLER_CUBE) {
+                    scope(
+                      "if(",
+                      VALUE,
+                      "&&",
+                      VALUE,
+                      '._reglType==="framebufferCube"){',
+                      VALUE,
+                      "=",
+                      VALUE,
+                      ".color[0];",
+                      "}"
+                    );
+                  }
+                  var unroll = 1;
+                  switch (type) {
+                    case GL_SAMPLER_2D:
+                    case GL_SAMPLER_CUBE:
+                      var TEX = scope.def(VALUE, "._texture");
+                      scope(GL, ".uniform1i(", LOCATION, ",", TEX, ".bind());");
+                      scope.exit(TEX, ".unbind();");
+                      continue;
+                    case GL_INT$2:
+                    case GL_BOOL:
+                      infix = "1i";
+                      break;
+                    case GL_INT_VEC2:
+                    case GL_BOOL_VEC2:
+                      infix = "2i";
+                      unroll = 2;
+                      break;
+                    case GL_INT_VEC3:
+                    case GL_BOOL_VEC3:
+                      infix = "3i";
+                      unroll = 3;
+                      break;
+                    case GL_INT_VEC4:
+                    case GL_BOOL_VEC4:
+                      infix = "4i";
+                      unroll = 4;
+                      break;
+                    case GL_FLOAT$7:
+                      infix = "1f";
+                      break;
+                    case GL_FLOAT_VEC2:
+                      infix = "2f";
+                      unroll = 2;
+                      break;
+                    case GL_FLOAT_VEC3:
+                      infix = "3f";
+                      unroll = 3;
+                      break;
+                    case GL_FLOAT_VEC4:
+                      infix = "4f";
+                      unroll = 4;
+                      break;
+                    case GL_FLOAT_MAT2:
+                      infix = "Matrix2fv";
+                      break;
+                    case GL_FLOAT_MAT3:
+                      infix = "Matrix3fv";
+                      break;
+                    case GL_FLOAT_MAT4:
+                      infix = "Matrix4fv";
+                      break;
+                  }
+                  if (infix.charAt(0) === "M") {
+                    scope(GL, ".uniform", infix, "(", LOCATION, ",");
+                    var matSize = Math.pow(type - GL_FLOAT_MAT2 + 2, 2);
+                    var STORAGE = env.global.def("new Float32Array(", matSize, ")");
+                    if (Array.isArray(VALUE)) {
+                      scope(
+                        "false,(",
+                        loop(matSize, function(i22) {
+                          return STORAGE + "[" + i22 + "]=" + VALUE[i22];
+                        }),
+                        ",",
+                        STORAGE,
+                        ")"
+                      );
+                    } else {
+                      scope(
+                        "false,(Array.isArray(",
+                        VALUE,
+                        ")||",
+                        VALUE,
+                        " instanceof Float32Array)?",
+                        VALUE,
+                        ":(",
+                        loop(matSize, function(i22) {
+                          return STORAGE + "[" + i22 + "]=" + VALUE + "[" + i22 + "]";
+                        }),
+                        ",",
+                        STORAGE,
+                        ")"
+                      );
+                    }
+                    scope(");");
+                  } else if (unroll > 1) {
+                    var prev = [];
+                    var cur = [];
+                    for (var j2 = 0; j2 < unroll; ++j2) {
+                      if (Array.isArray(VALUE)) {
+                        cur.push(VALUE[j2]);
+                      } else {
+                        cur.push(scope.def(VALUE + "[" + j2 + "]"));
+                      }
+                      if (isBatchInnerLoop) {
+                        prev.push(scope.def());
+                      }
+                    }
+                    if (isBatchInnerLoop) {
+                      scope("if(!", env.batchId, "||", prev.map(function(p2, i22) {
+                        return p2 + "!==" + cur[i22];
+                      }).join("||"), "){", prev.map(function(p2, i22) {
+                        return p2 + "=" + cur[i22] + ";";
+                      }).join(""));
+                    }
+                    scope(GL, ".uniform", infix, "(", LOCATION, ",", cur.join(","), ");");
+                    if (isBatchInnerLoop) {
+                      scope("}");
+                    }
+                  } else {
+                    if (isBatchInnerLoop) {
+                      var prevS = scope.def();
+                      scope(
+                        "if(!",
+                        env.batchId,
+                        "||",
+                        prevS,
+                        "!==",
+                        VALUE,
+                        "){",
+                        prevS,
+                        "=",
+                        VALUE,
+                        ";"
+                      );
+                    }
+                    scope(GL, ".uniform", infix, "(", LOCATION, ",", VALUE, ");");
+                    if (isBatchInnerLoop) {
+                      scope("}");
+                    }
+                  }
+                }
+              }
+              function emitDraw(env, outer, inner, args) {
+                var shared = env.shared;
+                var GL = shared.gl;
+                var DRAW_STATE = shared.draw;
+                var drawOptions = args.draw;
+                function emitElements() {
+                  var defn = drawOptions.elements;
+                  var ELEMENTS2;
+                  var scope = outer;
+                  if (defn) {
+                    if (defn.contextDep && args.contextDynamic || defn.propDep) {
+                      scope = inner;
+                    }
+                    ELEMENTS2 = defn.append(env, scope);
+                    if (drawOptions.elementsActive) {
+                      scope(
+                        "if(" + ELEMENTS2 + ")" + GL + ".bindBuffer(" + GL_ELEMENT_ARRAY_BUFFER$2 + "," + ELEMENTS2 + ".buffer.buffer);"
+                      );
+                    }
+                  } else {
+                    ELEMENTS2 = scope.def();
+                    scope(
+                      ELEMENTS2,
+                      "=",
+                      DRAW_STATE,
+                      ".",
+                      S_ELEMENTS,
+                      ";",
+                      "if(",
+                      ELEMENTS2,
+                      "){",
+                      GL,
+                      ".bindBuffer(",
+                      GL_ELEMENT_ARRAY_BUFFER$2,
+                      ",",
+                      ELEMENTS2,
+                      ".buffer.buffer);}",
+                      "else if(",
+                      shared.vao,
+                      ".currentVAO){",
+                      ELEMENTS2,
+                      "=",
+                      env.shared.elements + ".getElements(" + shared.vao,
+                      ".currentVAO.elements);",
+                      !extVertexArrays ? "if(" + ELEMENTS2 + ")" + GL + ".bindBuffer(" + GL_ELEMENT_ARRAY_BUFFER$2 + "," + ELEMENTS2 + ".buffer.buffer);" : "",
+                      "}"
+                    );
+                  }
+                  return ELEMENTS2;
+                }
+                function emitCount() {
+                  var defn = drawOptions.count;
+                  var COUNT2;
+                  var scope = outer;
+                  if (defn) {
+                    if (defn.contextDep && args.contextDynamic || defn.propDep) {
+                      scope = inner;
+                    }
+                    COUNT2 = defn.append(env, scope);
+                  } else {
+                    COUNT2 = scope.def(DRAW_STATE, ".", S_COUNT);
+                  }
+                  return COUNT2;
+                }
+                var ELEMENTS = emitElements();
+                function emitValue(name2) {
+                  var defn = drawOptions[name2];
+                  if (defn) {
+                    if (defn.contextDep && args.contextDynamic || defn.propDep) {
+                      return defn.append(env, inner);
+                    } else {
+                      return defn.append(env, outer);
+                    }
+                  } else {
+                    return outer.def(DRAW_STATE, ".", name2);
+                  }
+                }
+                var PRIMITIVE = emitValue(S_PRIMITIVE);
+                var OFFSET = emitValue(S_OFFSET);
+                var COUNT = emitCount();
+                if (typeof COUNT === "number") {
+                  if (COUNT === 0) {
+                    return;
+                  }
+                } else {
+                  inner("if(", COUNT, "){");
+                  inner.exit("}");
+                }
+                var INSTANCES, EXT_INSTANCING;
+                if (extInstancing) {
+                  INSTANCES = emitValue(S_INSTANCES);
+                  EXT_INSTANCING = env.instancing;
+                }
+                var ELEMENT_TYPE = ELEMENTS + ".type";
+                var elementsStatic = drawOptions.elements && isStatic(drawOptions.elements) && !drawOptions.vaoActive;
+                function emitInstancing() {
+                  function drawElements() {
+                    inner(EXT_INSTANCING, ".drawElementsInstancedANGLE(", [
+                      PRIMITIVE,
+                      COUNT,
+                      ELEMENT_TYPE,
+                      OFFSET + "<<((" + ELEMENT_TYPE + "-" + GL_UNSIGNED_BYTE$7 + ")>>1)",
+                      INSTANCES
+                    ], ");");
+                  }
+                  function drawArrays() {
+                    inner(
+                      EXT_INSTANCING,
+                      ".drawArraysInstancedANGLE(",
+                      [PRIMITIVE, OFFSET, COUNT, INSTANCES],
+                      ");"
+                    );
+                  }
+                  if (ELEMENTS && ELEMENTS !== "null") {
+                    if (!elementsStatic) {
+                      inner("if(", ELEMENTS, "){");
+                      drawElements();
+                      inner("}else{");
+                      drawArrays();
+                      inner("}");
+                    } else {
+                      drawElements();
+                    }
+                  } else {
+                    drawArrays();
+                  }
+                }
+                function emitRegular() {
+                  function drawElements() {
+                    inner(GL + ".drawElements(" + [
+                      PRIMITIVE,
+                      COUNT,
+                      ELEMENT_TYPE,
+                      OFFSET + "<<((" + ELEMENT_TYPE + "-" + GL_UNSIGNED_BYTE$7 + ")>>1)"
+                    ] + ");");
+                  }
+                  function drawArrays() {
+                    inner(GL + ".drawArrays(" + [PRIMITIVE, OFFSET, COUNT] + ");");
+                  }
+                  if (ELEMENTS && ELEMENTS !== "null") {
+                    if (!elementsStatic) {
+                      inner("if(", ELEMENTS, "){");
+                      drawElements();
+                      inner("}else{");
+                      drawArrays();
+                      inner("}");
+                    } else {
+                      drawElements();
+                    }
+                  } else {
+                    drawArrays();
+                  }
+                }
+                if (extInstancing && (typeof INSTANCES !== "number" || INSTANCES >= 0)) {
+                  if (typeof INSTANCES === "string") {
+                    inner("if(", INSTANCES, ">0){");
+                    emitInstancing();
+                    inner("}else if(", INSTANCES, "<0){");
+                    emitRegular();
+                    inner("}");
+                  } else {
+                    emitInstancing();
+                  }
+                } else {
+                  emitRegular();
+                }
+              }
+              function createBody(emitBody, parentEnv, args, program, count2) {
+                var env = createREGLEnvironment();
+                var scope = env.proc("body", count2);
+                if (extInstancing) {
+                  env.instancing = scope.def(
+                    env.shared.extensions,
+                    ".angle_instanced_arrays"
+                  );
+                }
+                emitBody(env, scope, args, program);
+                return env.compile().body;
+              }
+              function emitDrawBody(env, draw, args, program) {
+                injectExtensions(env, draw);
+                if (args.useVAO) {
+                  if (args.drawVAO) {
+                    draw(env.shared.vao, ".setVAO(", args.drawVAO.append(env, draw), ");");
+                  } else {
+                    draw(env.shared.vao, ".setVAO(", env.shared.vao, ".targetVAO);");
+                  }
+                } else {
+                  draw(env.shared.vao, ".setVAO(null);");
+                  emitAttributes(env, draw, args, program.attributes, function() {
+                    return true;
+                  });
+                }
+                emitUniforms(env, draw, args, program.uniforms, function() {
+                  return true;
+                }, false);
+                emitDraw(env, draw, draw, args);
+              }
+              function emitDrawProc(env, args) {
+                var draw = env.proc("draw", 1);
+                injectExtensions(env, draw);
+                emitContext(env, draw, args.context);
+                emitPollFramebuffer(env, draw, args.framebuffer);
+                emitPollState(env, draw, args);
+                emitSetOptions(env, draw, args.state);
+                emitProfile(env, draw, args, false, true);
+                var program = args.shader.progVar.append(env, draw);
+                draw(env.shared.gl, ".useProgram(", program, ".program);");
+                if (args.shader.program) {
+                  emitDrawBody(env, draw, args, args.shader.program);
+                } else {
+                  draw(env.shared.vao, ".setVAO(null);");
+                  var drawCache = env.global.def("{}");
+                  var PROG_ID = draw.def(program, ".id");
+                  var CACHED_PROC = draw.def(drawCache, "[", PROG_ID, "]");
+                  draw(
+                    env.cond(CACHED_PROC).then(CACHED_PROC, ".call(this,a0);").else(
+                      CACHED_PROC,
+                      "=",
+                      drawCache,
+                      "[",
+                      PROG_ID,
+                      "]=",
+                      env.link(function(program2) {
+                        return createBody(emitDrawBody, env, args, program2, 1);
+                      }),
+                      "(",
+                      program,
+                      ");",
+                      CACHED_PROC,
+                      ".call(this,a0);"
+                    )
+                  );
+                }
+                if (Object.keys(args.state).length > 0) {
+                  draw(env.shared.current, ".dirty=true;");
+                }
+                if (env.shared.vao) {
+                  draw(env.shared.vao, ".setVAO(null);");
+                }
+              }
+              function emitBatchDynamicShaderBody(env, scope, args, program) {
+                env.batchId = "a1";
+                injectExtensions(env, scope);
+                function all() {
+                  return true;
+                }
+                emitAttributes(env, scope, args, program.attributes, all);
+                emitUniforms(env, scope, args, program.uniforms, all, false);
+                emitDraw(env, scope, scope, args);
+              }
+              function emitBatchBody(env, scope, args, program) {
+                injectExtensions(env, scope);
+                var contextDynamic = args.contextDep;
+                var BATCH_ID = scope.def();
+                var PROP_LIST = "a0";
+                var NUM_PROPS = "a1";
+                var PROPS = scope.def();
+                env.shared.props = PROPS;
+                env.batchId = BATCH_ID;
+                var outer = env.scope();
+                var inner = env.scope();
+                scope(
+                  outer.entry,
+                  "for(",
+                  BATCH_ID,
+                  "=0;",
+                  BATCH_ID,
+                  "<",
+                  NUM_PROPS,
+                  ";++",
+                  BATCH_ID,
+                  "){",
+                  PROPS,
+                  "=",
+                  PROP_LIST,
+                  "[",
+                  BATCH_ID,
+                  "];",
+                  inner,
+                  "}",
+                  outer.exit
+                );
+                function isInnerDefn(defn) {
+                  return defn.contextDep && contextDynamic || defn.propDep;
+                }
+                function isOuterDefn(defn) {
+                  return !isInnerDefn(defn);
+                }
+                if (args.needsContext) {
+                  emitContext(env, inner, args.context);
+                }
+                if (args.needsFramebuffer) {
+                  emitPollFramebuffer(env, inner, args.framebuffer);
+                }
+                emitSetOptions(env, inner, args.state, isInnerDefn);
+                if (args.profile && isInnerDefn(args.profile)) {
+                  emitProfile(env, inner, args, false, true);
+                }
+                if (!program) {
+                  var progCache = env.global.def("{}");
+                  var PROGRAM = args.shader.progVar.append(env, inner);
+                  var PROG_ID = inner.def(PROGRAM, ".id");
+                  var CACHED_PROC = inner.def(progCache, "[", PROG_ID, "]");
+                  inner(
+                    env.shared.gl,
+                    ".useProgram(",
+                    PROGRAM,
+                    ".program);",
+                    "if(!",
+                    CACHED_PROC,
+                    "){",
+                    CACHED_PROC,
+                    "=",
+                    progCache,
+                    "[",
+                    PROG_ID,
+                    "]=",
+                    env.link(function(program2) {
+                      return createBody(
+                        emitBatchDynamicShaderBody,
+                        env,
+                        args,
+                        program2,
+                        2
+                      );
+                    }),
+                    "(",
+                    PROGRAM,
+                    ");}",
+                    CACHED_PROC,
+                    ".call(this,a0[",
+                    BATCH_ID,
+                    "],",
+                    BATCH_ID,
+                    ");"
+                  );
+                } else {
+                  if (args.useVAO) {
+                    if (args.drawVAO) {
+                      if (isInnerDefn(args.drawVAO)) {
+                        inner(env.shared.vao, ".setVAO(", args.drawVAO.append(env, inner), ");");
+                      } else {
+                        outer(env.shared.vao, ".setVAO(", args.drawVAO.append(env, outer), ");");
+                      }
+                    } else {
+                      outer(env.shared.vao, ".setVAO(", env.shared.vao, ".targetVAO);");
+                    }
+                  } else {
+                    outer(env.shared.vao, ".setVAO(null);");
+                    emitAttributes(env, outer, args, program.attributes, isOuterDefn);
+                    emitAttributes(env, inner, args, program.attributes, isInnerDefn);
+                  }
+                  emitUniforms(env, outer, args, program.uniforms, isOuterDefn, false);
+                  emitUniforms(env, inner, args, program.uniforms, isInnerDefn, true);
+                  emitDraw(env, outer, inner, args);
+                }
+              }
+              function emitBatchProc(env, args) {
+                var batch = env.proc("batch", 2);
+                env.batchId = "0";
+                injectExtensions(env, batch);
+                var contextDynamic = false;
+                var needsContext = true;
+                Object.keys(args.context).forEach(function(name2) {
+                  contextDynamic = contextDynamic || args.context[name2].propDep;
+                });
+                if (!contextDynamic) {
+                  emitContext(env, batch, args.context);
+                  needsContext = false;
+                }
+                var framebuffer = args.framebuffer;
+                var needsFramebuffer = false;
+                if (framebuffer) {
+                  if (framebuffer.propDep) {
+                    contextDynamic = needsFramebuffer = true;
+                  } else if (framebuffer.contextDep && contextDynamic) {
+                    needsFramebuffer = true;
+                  }
+                  if (!needsFramebuffer) {
+                    emitPollFramebuffer(env, batch, framebuffer);
+                  }
+                } else {
+                  emitPollFramebuffer(env, batch, null);
+                }
+                if (args.state.viewport && args.state.viewport.propDep) {
+                  contextDynamic = true;
+                }
+                function isInnerDefn(defn) {
+                  return defn.contextDep && contextDynamic || defn.propDep;
+                }
+                emitPollState(env, batch, args);
+                emitSetOptions(env, batch, args.state, function(defn) {
+                  return !isInnerDefn(defn);
+                });
+                if (!args.profile || !isInnerDefn(args.profile)) {
+                  emitProfile(env, batch, args, false, "a1");
+                }
+                args.contextDep = contextDynamic;
+                args.needsContext = needsContext;
+                args.needsFramebuffer = needsFramebuffer;
+                var progDefn = args.shader.progVar;
+                if (progDefn.contextDep && contextDynamic || progDefn.propDep) {
+                  emitBatchBody(
+                    env,
+                    batch,
+                    args,
+                    null
+                  );
+                } else {
+                  var PROGRAM = progDefn.append(env, batch);
+                  batch(env.shared.gl, ".useProgram(", PROGRAM, ".program);");
+                  if (args.shader.program) {
+                    emitBatchBody(
+                      env,
+                      batch,
+                      args,
+                      args.shader.program
+                    );
+                  } else {
+                    batch(env.shared.vao, ".setVAO(null);");
+                    var batchCache = env.global.def("{}");
+                    var PROG_ID = batch.def(PROGRAM, ".id");
+                    var CACHED_PROC = batch.def(batchCache, "[", PROG_ID, "]");
+                    batch(
+                      env.cond(CACHED_PROC).then(CACHED_PROC, ".call(this,a0,a1);").else(
+                        CACHED_PROC,
+                        "=",
+                        batchCache,
+                        "[",
+                        PROG_ID,
+                        "]=",
+                        env.link(function(program) {
+                          return createBody(emitBatchBody, env, args, program, 2);
+                        }),
+                        "(",
+                        PROGRAM,
+                        ");",
+                        CACHED_PROC,
+                        ".call(this,a0,a1);"
+                      )
+                    );
+                  }
+                }
+                if (Object.keys(args.state).length > 0) {
+                  batch(env.shared.current, ".dirty=true;");
+                }
+                if (env.shared.vao) {
+                  batch(env.shared.vao, ".setVAO(null);");
+                }
+              }
+              function emitScopeProc(env, args) {
+                var scope = env.proc("scope", 3);
+                env.batchId = "a2";
+                var shared = env.shared;
+                var CURRENT_STATE = shared.current;
+                emitContext(env, scope, args.context);
+                if (args.framebuffer) {
+                  args.framebuffer.append(env, scope);
+                }
+                sortState(Object.keys(args.state)).forEach(function(name2) {
+                  var defn = args.state[name2];
+                  var value = defn.append(env, scope);
+                  if (isArrayLike(value)) {
+                    value.forEach(function(v2, i2) {
+                      if (hasVariableReference(v2)) {
+                        scope.set(env.next[name2], "[" + i2 + "]", v2);
+                      } else {
+                        scope.set(env.next[name2], "[" + i2 + "]", env.link(v2, { stable: true }));
+                      }
+                    });
+                  } else {
+                    if (isStatic(defn)) {
+                      scope.set(shared.next, "." + name2, env.link(value, { stable: true }));
+                    } else {
+                      scope.set(shared.next, "." + name2, value);
+                    }
+                  }
+                });
+                emitProfile(env, scope, args, true, true);
+                [S_ELEMENTS, S_OFFSET, S_COUNT, S_INSTANCES, S_PRIMITIVE].forEach(
+                  function(opt) {
+                    var variable = args.draw[opt];
+                    if (!variable) {
+                      return;
+                    }
+                    var VARIABLE2 = variable.append(env, scope);
+                    if (hasVariableReference(VARIABLE2)) {
+                      scope.set(shared.draw, "." + opt, VARIABLE2);
+                    } else {
+                      scope.set(shared.draw, "." + opt, env.link(VARIABLE2), { stable: true });
+                    }
+                  }
+                );
+                Object.keys(args.uniforms).forEach(function(opt) {
+                  var value = args.uniforms[opt].append(env, scope);
+                  if (Array.isArray(value)) {
+                    value = "[" + value.map(function(v2) {
+                      if (hasVariableReference(v2)) {
+                        return v2;
+                      } else {
+                        return env.link(v2, { stable: true });
+                      }
+                    }) + "]";
+                  }
+                  scope.set(
+                    shared.uniforms,
+                    "[" + env.link(stringStore.id(opt), { stable: true }) + "]",
+                    value
+                  );
+                });
+                Object.keys(args.attributes).forEach(function(name2) {
+                  var record = args.attributes[name2].append(env, scope);
+                  var scopeAttrib = env.scopeAttrib(name2);
+                  Object.keys(new AttributeRecord2()).forEach(function(prop) {
+                    scope.set(scopeAttrib, "." + prop, record[prop]);
+                  });
+                });
+                if (args.scopeVAO) {
+                  var VARIABLE = args.scopeVAO.append(env, scope);
+                  if (hasVariableReference(VARIABLE)) {
+                    scope.set(shared.vao, ".targetVAO", VARIABLE);
+                  } else {
+                    scope.set(shared.vao, ".targetVAO", env.link(VARIABLE, { stable: true }));
+                  }
+                }
+                function saveShader(name2) {
+                  var shader = args.shader[name2];
+                  if (shader) {
+                    var VARIABLE2 = shader.append(env, scope);
+                    if (hasVariableReference(VARIABLE2)) {
+                      scope.set(shared.shader, "." + name2, VARIABLE2);
+                    } else {
+                      scope.set(shared.shader, "." + name2, env.link(VARIABLE2, { stable: true }));
+                    }
+                  }
+                }
+                saveShader(S_VERT);
+                saveShader(S_FRAG);
+                if (Object.keys(args.state).length > 0) {
+                  scope(CURRENT_STATE, ".dirty=true;");
+                  scope.exit(CURRENT_STATE, ".dirty=true;");
+                }
+                scope("a1(", env.shared.context, ",a0,", env.batchId, ");");
+              }
+              function isDynamicObject(object) {
+                if (typeof object !== "object" || isArrayLike(object)) {
+                  return;
+                }
+                var props = Object.keys(object);
+                for (var i2 = 0; i2 < props.length; ++i2) {
+                  if (dynamic.isDynamic(object[props[i2]])) {
+                    return true;
+                  }
+                }
+                return false;
+              }
+              function splatObject(env, options, name2) {
+                var object = options.static[name2];
+                if (!object || !isDynamicObject(object)) {
+                  return;
+                }
+                var globals = env.global;
+                var keys = Object.keys(object);
+                var thisDep = false;
+                var contextDep = false;
+                var propDep = false;
+                var objectRef = env.global.def("{}");
+                keys.forEach(function(key) {
+                  var value = object[key];
+                  if (dynamic.isDynamic(value)) {
+                    if (typeof value === "function") {
+                      value = object[key] = dynamic.unbox(value);
+                    }
+                    var deps = createDynamicDecl(value, null);
+                    thisDep = thisDep || deps.thisDep;
+                    propDep = propDep || deps.propDep;
+                    contextDep = contextDep || deps.contextDep;
+                  } else {
+                    globals(objectRef, ".", key, "=");
+                    switch (typeof value) {
+                      case "number":
+                        globals(value);
+                        break;
+                      case "string":
+                        globals('"', value, '"');
+                        break;
+                      case "object":
+                        if (Array.isArray(value)) {
+                          globals("[", value.join(), "]");
+                        }
+                        break;
+                      default:
+                        globals(env.link(value));
+                        break;
+                    }
+                    globals(";");
+                  }
+                });
+                function appendBlock(env2, block) {
+                  keys.forEach(function(key) {
+                    var value = object[key];
+                    if (!dynamic.isDynamic(value)) {
+                      return;
+                    }
+                    var ref = env2.invoke(block, value);
+                    block(objectRef, ".", key, "=", ref, ";");
+                  });
+                }
+                options.dynamic[name2] = new dynamic.DynamicVariable(DYN_THUNK, {
+                  thisDep,
+                  contextDep,
+                  propDep,
+                  ref: objectRef,
+                  append: appendBlock
+                });
+                delete options.static[name2];
+              }
+              function compileCommand(options, attributes, uniforms, context, stats2) {
+                var env = createREGLEnvironment();
+                env.stats = env.link(stats2);
+                Object.keys(attributes.static).forEach(function(key) {
+                  splatObject(env, attributes, key);
+                });
+                NESTED_OPTIONS.forEach(function(name2) {
+                  splatObject(env, options, name2);
+                });
+                var args = parseArguments(options, attributes, uniforms, context, env);
+                if (args.shader.program) {
+                  args.shader.program.attributes.sort(function(a2, b2) {
+                    return a2.name < b2.name ? -1 : 1;
+                  });
+                  args.shader.program.uniforms.sort(function(a2, b2) {
+                    return a2.name < b2.name ? -1 : 1;
+                  });
+                }
+                emitDrawProc(env, args);
+                emitScopeProc(env, args);
+                emitBatchProc(env, args);
+                return extend2(env.compile(), {
+                  destroy: function() {
+                    args.shader.program.destroy();
+                  }
+                });
+              }
+              return {
+                next: nextState,
+                current: currentState,
+                procs: function() {
+                  var env = createREGLEnvironment();
+                  var poll = env.proc("poll");
+                  var refresh = env.proc("refresh");
+                  var common = env.block();
+                  poll(common);
+                  refresh(common);
+                  var shared = env.shared;
+                  var GL = shared.gl;
+                  var NEXT_STATE = shared.next;
+                  var CURRENT_STATE = shared.current;
+                  common(CURRENT_STATE, ".dirty=false;");
+                  emitPollFramebuffer(env, poll);
+                  emitPollFramebuffer(env, refresh, null, true);
+                  var INSTANCING;
+                  if (extInstancing) {
+                    INSTANCING = env.link(extInstancing);
+                  }
+                  if (extensions.oes_vertex_array_object) {
+                    refresh(env.link(extensions.oes_vertex_array_object), ".bindVertexArrayOES(null);");
+                  }
+                  var BINDING = refresh.def(shared.attributes);
+                  var TEMP_BINDING = refresh.def(0);
+                  var ifte = env.cond(TEMP_BINDING, ".buffer");
+                  ifte.then(
+                    GL,
+                    ".enableVertexAttribArray(i);",
+                    GL,
+                    ".bindBuffer(",
+                    GL_ARRAY_BUFFER$2,
+                    ",",
+                    TEMP_BINDING,
+                    ".buffer.buffer);",
+                    GL,
+                    ".vertexAttribPointer(i,",
+                    TEMP_BINDING,
+                    ".size,",
+                    TEMP_BINDING,
+                    ".type,",
+                    TEMP_BINDING,
+                    ".normalized,",
+                    TEMP_BINDING,
+                    ".stride,",
+                    TEMP_BINDING,
+                    ".offset);"
+                  ).else(
+                    GL,
+                    ".disableVertexAttribArray(i);",
+                    GL,
+                    ".vertexAttrib4f(i,",
+                    TEMP_BINDING,
+                    ".x,",
+                    TEMP_BINDING,
+                    ".y,",
+                    TEMP_BINDING,
+                    ".z,",
+                    TEMP_BINDING,
+                    ".w);",
+                    TEMP_BINDING,
+                    ".buffer=null;"
+                  );
+                  var MAX_ATTRIBUTES = env.link(limits.maxAttributes, { stable: true });
+                  refresh(
+                    "for(var i=0;i<",
+                    MAX_ATTRIBUTES,
+                    ";++i){",
+                    TEMP_BINDING,
+                    "=",
+                    BINDING,
+                    "[i];",
+                    ifte,
+                    "}"
+                  );
+                  if (extInstancing) {
+                    refresh(
+                      "for(var i=0;i<",
+                      MAX_ATTRIBUTES,
+                      ";++i){",
+                      INSTANCING,
+                      ".vertexAttribDivisorANGLE(i,",
+                      BINDING,
+                      "[i].divisor);",
+                      "}"
+                    );
+                  }
+                  refresh(
+                    env.shared.vao,
+                    ".currentVAO=null;",
+                    env.shared.vao,
+                    ".setVAO(",
+                    env.shared.vao,
+                    ".targetVAO);"
+                  );
+                  Object.keys(GL_FLAGS).forEach(function(flag) {
+                    var cap = GL_FLAGS[flag];
+                    var NEXT = common.def(NEXT_STATE, ".", flag);
+                    var block = env.block();
+                    block(
+                      "if(",
+                      NEXT,
+                      "){",
+                      GL,
+                      ".enable(",
+                      cap,
+                      ")}else{",
+                      GL,
+                      ".disable(",
+                      cap,
+                      ")}",
+                      CURRENT_STATE,
+                      ".",
+                      flag,
+                      "=",
+                      NEXT,
+                      ";"
+                    );
+                    refresh(block);
+                    poll(
+                      "if(",
+                      NEXT,
+                      "!==",
+                      CURRENT_STATE,
+                      ".",
+                      flag,
+                      "){",
+                      block,
+                      "}"
+                    );
+                  });
+                  Object.keys(GL_VARIABLES).forEach(function(name2) {
+                    var func = GL_VARIABLES[name2];
+                    var init = currentState[name2];
+                    var NEXT, CURRENT;
+                    var block = env.block();
+                    block(GL, ".", func, "(");
+                    if (isArrayLike(init)) {
+                      var n2 = init.length;
+                      NEXT = env.global.def(NEXT_STATE, ".", name2);
+                      CURRENT = env.global.def(CURRENT_STATE, ".", name2);
+                      block(
+                        loop(n2, function(i2) {
+                          return NEXT + "[" + i2 + "]";
+                        }),
+                        ");",
+                        loop(n2, function(i2) {
+                          return CURRENT + "[" + i2 + "]=" + NEXT + "[" + i2 + "];";
+                        }).join("")
+                      );
+                      poll(
+                        "if(",
+                        loop(n2, function(i2) {
+                          return NEXT + "[" + i2 + "]!==" + CURRENT + "[" + i2 + "]";
+                        }).join("||"),
+                        "){",
+                        block,
+                        "}"
+                      );
+                    } else {
+                      NEXT = common.def(NEXT_STATE, ".", name2);
+                      CURRENT = common.def(CURRENT_STATE, ".", name2);
+                      block(
+                        NEXT,
+                        ");",
+                        CURRENT_STATE,
+                        ".",
+                        name2,
+                        "=",
+                        NEXT,
+                        ";"
+                      );
+                      poll(
+                        "if(",
+                        NEXT,
+                        "!==",
+                        CURRENT,
+                        "){",
+                        block,
+                        "}"
+                      );
+                    }
+                    refresh(block);
+                  });
+                  return env.compile();
+                }(),
+                compile: compileCommand
+              };
+            }
+            function stats() {
+              return {
+                vaoCount: 0,
+                bufferCount: 0,
+                elementsCount: 0,
+                framebufferCount: 0,
+                shaderCount: 0,
+                textureCount: 0,
+                cubeCount: 0,
+                renderbufferCount: 0,
+                maxTextureUnits: 0
+              };
+            }
+            var GL_QUERY_RESULT_EXT = 34918;
+            var GL_QUERY_RESULT_AVAILABLE_EXT = 34919;
+            var GL_TIME_ELAPSED_EXT = 35007;
+            var createTimer = function(gl2, extensions) {
+              if (!extensions.ext_disjoint_timer_query) {
+                return null;
+              }
+              var queryPool = [];
+              function allocQuery() {
+                return queryPool.pop() || extensions.ext_disjoint_timer_query.createQueryEXT();
+              }
+              function freeQuery(query) {
+                queryPool.push(query);
+              }
+              var pendingQueries = [];
+              function beginQuery(stats2) {
+                var query = allocQuery();
+                extensions.ext_disjoint_timer_query.beginQueryEXT(GL_TIME_ELAPSED_EXT, query);
+                pendingQueries.push(query);
+                pushScopeStats(pendingQueries.length - 1, pendingQueries.length, stats2);
+              }
+              function endQuery() {
+                extensions.ext_disjoint_timer_query.endQueryEXT(GL_TIME_ELAPSED_EXT);
+              }
+              function PendingStats() {
+                this.startQueryIndex = -1;
+                this.endQueryIndex = -1;
+                this.sum = 0;
+                this.stats = null;
+              }
+              var pendingStatsPool = [];
+              function allocPendingStats() {
+                return pendingStatsPool.pop() || new PendingStats();
+              }
+              function freePendingStats(pendingStats2) {
+                pendingStatsPool.push(pendingStats2);
+              }
+              var pendingStats = [];
+              function pushScopeStats(start, end, stats2) {
+                var ps = allocPendingStats();
+                ps.startQueryIndex = start;
+                ps.endQueryIndex = end;
+                ps.sum = 0;
+                ps.stats = stats2;
+                pendingStats.push(ps);
+              }
+              var timeSum = [];
+              var queryPtr = [];
+              function update() {
+                var ptr, i2;
+                var n2 = pendingQueries.length;
+                if (n2 === 0) {
+                  return;
+                }
+                queryPtr.length = Math.max(queryPtr.length, n2 + 1);
+                timeSum.length = Math.max(timeSum.length, n2 + 1);
+                timeSum[0] = 0;
+                queryPtr[0] = 0;
+                var queryTime = 0;
+                ptr = 0;
+                for (i2 = 0; i2 < pendingQueries.length; ++i2) {
+                  var query = pendingQueries[i2];
+                  if (extensions.ext_disjoint_timer_query.getQueryObjectEXT(query, GL_QUERY_RESULT_AVAILABLE_EXT)) {
+                    queryTime += extensions.ext_disjoint_timer_query.getQueryObjectEXT(query, GL_QUERY_RESULT_EXT);
+                    freeQuery(query);
+                  } else {
+                    pendingQueries[ptr++] = query;
+                  }
+                  timeSum[i2 + 1] = queryTime;
+                  queryPtr[i2 + 1] = ptr;
+                }
+                pendingQueries.length = ptr;
+                ptr = 0;
+                for (i2 = 0; i2 < pendingStats.length; ++i2) {
+                  var stats2 = pendingStats[i2];
+                  var start = stats2.startQueryIndex;
+                  var end = stats2.endQueryIndex;
+                  stats2.sum += timeSum[end] - timeSum[start];
+                  var startPtr = queryPtr[start];
+                  var endPtr = queryPtr[end];
+                  if (endPtr === startPtr) {
+                    stats2.stats.gpuTime += stats2.sum / 1e6;
+                    freePendingStats(stats2);
+                  } else {
+                    stats2.startQueryIndex = startPtr;
+                    stats2.endQueryIndex = endPtr;
+                    pendingStats[ptr++] = stats2;
+                  }
+                }
+                pendingStats.length = ptr;
+              }
+              return {
+                beginQuery,
+                endQuery,
+                pushScopeStats,
+                update,
+                getNumPendingQueries: function() {
+                  return pendingQueries.length;
+                },
+                clear: function() {
+                  queryPool.push.apply(queryPool, pendingQueries);
+                  for (var i2 = 0; i2 < queryPool.length; i2++) {
+                    extensions.ext_disjoint_timer_query.deleteQueryEXT(queryPool[i2]);
+                  }
+                  pendingQueries.length = 0;
+                  queryPool.length = 0;
+                },
+                restore: function() {
+                  pendingQueries.length = 0;
+                  queryPool.length = 0;
+                }
+              };
+            };
+            var GL_COLOR_BUFFER_BIT = 16384;
+            var GL_DEPTH_BUFFER_BIT = 256;
+            var GL_STENCIL_BUFFER_BIT = 1024;
+            var GL_ARRAY_BUFFER = 34962;
+            var CONTEXT_LOST_EVENT = "webglcontextlost";
+            var CONTEXT_RESTORED_EVENT = "webglcontextrestored";
+            var DYN_PROP = 1;
+            var DYN_CONTEXT = 2;
+            var DYN_STATE = 3;
+            function find(haystack, needle) {
+              for (var i2 = 0; i2 < haystack.length; ++i2) {
+                if (haystack[i2] === needle) {
+                  return i2;
+                }
+              }
+              return -1;
+            }
+            function wrapREGL(args) {
+              var config2 = parseArgs(args);
+              if (!config2) {
+                return null;
+              }
+              var gl2 = config2.gl;
+              var glAttributes = gl2.getContextAttributes();
+              gl2.isContextLost();
+              var extensionState = createExtensionCache(gl2, config2);
+              if (!extensionState) {
+                return null;
+              }
+              var stringStore = createStringStore();
+              var stats$$1 = stats();
+              var cachedCode = config2.cachedCode || {};
+              var extensions = extensionState.extensions;
+              var timer = createTimer(gl2, extensions);
+              var START_TIME = clock();
+              var WIDTH = gl2.drawingBufferWidth;
+              var HEIGHT = gl2.drawingBufferHeight;
+              var contextState = {
+                tick: 0,
+                time: 0,
+                viewportWidth: WIDTH,
+                viewportHeight: HEIGHT,
+                framebufferWidth: WIDTH,
+                framebufferHeight: HEIGHT,
+                drawingBufferWidth: WIDTH,
+                drawingBufferHeight: HEIGHT,
+                pixelRatio: config2.pixelRatio
+              };
+              var uniformState = {};
+              var drawState = {
+                elements: null,
+                primitive: 4,
+                // GL_TRIANGLES
+                count: -1,
+                offset: 0,
+                instances: -1
+              };
+              var limits = wrapLimits(gl2, extensions);
+              var bufferState = wrapBufferState(
+                gl2,
+                stats$$1,
+                config2,
+                destroyBuffer
+              );
+              var elementState = wrapElementsState(gl2, extensions, bufferState, stats$$1);
+              var attributeState = wrapAttributeState(
+                gl2,
+                extensions,
+                limits,
+                stats$$1,
+                bufferState,
+                elementState,
+                drawState
+              );
+              function destroyBuffer(buffer) {
+                return attributeState.destroyBuffer(buffer);
+              }
+              var shaderState = wrapShaderState(gl2, stringStore, stats$$1, config2);
+              var textureState = createTextureSet(
+                gl2,
+                extensions,
+                limits,
+                function() {
+                  core.procs.poll();
+                },
+                contextState,
+                stats$$1,
+                config2
+              );
+              var renderbufferState = wrapRenderbuffers(gl2, extensions, limits, stats$$1, config2);
+              var framebufferState = wrapFBOState(
+                gl2,
+                extensions,
+                limits,
+                textureState,
+                renderbufferState,
+                stats$$1
+              );
+              var core = reglCore(
+                gl2,
+                stringStore,
+                extensions,
+                limits,
+                bufferState,
+                elementState,
+                textureState,
+                framebufferState,
+                uniformState,
+                attributeState,
+                shaderState,
+                drawState,
+                contextState,
+                timer,
+                cachedCode,
+                config2
+              );
+              var readPixels = wrapReadPixels(
+                gl2,
+                framebufferState,
+                core.procs.poll,
+                contextState
+              );
+              var nextState = core.next;
+              var canvas2 = gl2.canvas;
+              var rafCallbacks = [];
+              var lossCallbacks = [];
+              var restoreCallbacks = [];
+              var destroyCallbacks = [config2.onDestroy];
+              var activeRAF = null;
+              function handleRAF() {
+                if (rafCallbacks.length === 0) {
+                  if (timer) {
+                    timer.update();
+                  }
+                  activeRAF = null;
+                  return;
+                }
+                activeRAF = raf.next(handleRAF);
+                poll();
+                for (var i2 = rafCallbacks.length - 1; i2 >= 0; --i2) {
+                  var cb2 = rafCallbacks[i2];
+                  if (cb2) {
+                    cb2(contextState, null, 0);
+                  }
+                }
+                gl2.flush();
+                if (timer) {
+                  timer.update();
+                }
+              }
+              function startRAF() {
+                if (!activeRAF && rafCallbacks.length > 0) {
+                  activeRAF = raf.next(handleRAF);
+                }
+              }
+              function stopRAF() {
+                if (activeRAF) {
+                  raf.cancel(handleRAF);
+                  activeRAF = null;
+                }
+              }
+              function handleContextLoss(event) {
+                event.preventDefault();
+                stopRAF();
+                lossCallbacks.forEach(function(cb2) {
+                  cb2();
+                });
+              }
+              function handleContextRestored(event) {
+                gl2.getError();
+                extensionState.restore();
+                shaderState.restore();
+                bufferState.restore();
+                textureState.restore();
+                renderbufferState.restore();
+                framebufferState.restore();
+                attributeState.restore();
+                if (timer) {
+                  timer.restore();
+                }
+                core.procs.refresh();
+                startRAF();
+                restoreCallbacks.forEach(function(cb2) {
+                  cb2();
+                });
+              }
+              if (canvas2) {
+                canvas2.addEventListener(CONTEXT_LOST_EVENT, handleContextLoss, false);
+                canvas2.addEventListener(CONTEXT_RESTORED_EVENT, handleContextRestored, false);
+              }
+              function destroy() {
+                rafCallbacks.length = 0;
+                stopRAF();
+                if (canvas2) {
+                  canvas2.removeEventListener(CONTEXT_LOST_EVENT, handleContextLoss);
+                  canvas2.removeEventListener(CONTEXT_RESTORED_EVENT, handleContextRestored);
+                }
+                shaderState.clear();
+                framebufferState.clear();
+                renderbufferState.clear();
+                attributeState.clear();
+                textureState.clear();
+                elementState.clear();
+                bufferState.clear();
+                if (timer) {
+                  timer.clear();
+                }
+                destroyCallbacks.forEach(function(cb2) {
+                  cb2();
+                });
+              }
+              function compileProcedure(options) {
+                function flattenNestedOptions(options2) {
+                  var result = extend2({}, options2);
+                  delete result.uniforms;
+                  delete result.attributes;
+                  delete result.context;
+                  delete result.vao;
+                  if ("stencil" in result && result.stencil.op) {
+                    result.stencil.opBack = result.stencil.opFront = result.stencil.op;
+                    delete result.stencil.op;
+                  }
+                  function merge(name2) {
+                    if (name2 in result) {
+                      var child = result[name2];
+                      delete result[name2];
+                      Object.keys(child).forEach(function(prop) {
+                        result[name2 + "." + prop] = child[prop];
+                      });
+                    }
+                  }
+                  merge("blend");
+                  merge("depth");
+                  merge("cull");
+                  merge("stencil");
+                  merge("polygonOffset");
+                  merge("scissor");
+                  merge("sample");
+                  if ("vao" in options2) {
+                    result.vao = options2.vao;
+                  }
+                  return result;
+                }
+                function separateDynamic(object, useArrays) {
+                  var staticItems = {};
+                  var dynamicItems = {};
+                  Object.keys(object).forEach(function(option) {
+                    var value = object[option];
+                    if (dynamic.isDynamic(value)) {
+                      dynamicItems[option] = dynamic.unbox(value, option);
+                      return;
+                    } else if (useArrays && Array.isArray(value)) {
+                      for (var i2 = 0; i2 < value.length; ++i2) {
+                        if (dynamic.isDynamic(value[i2])) {
+                          dynamicItems[option] = dynamic.unbox(value, option);
+                          return;
+                        }
+                      }
+                    }
+                    staticItems[option] = value;
+                  });
+                  return {
+                    dynamic: dynamicItems,
+                    static: staticItems
+                  };
+                }
+                var context = separateDynamic(options.context || {}, true);
+                var uniforms = separateDynamic(options.uniforms || {}, true);
+                var attributes = separateDynamic(options.attributes || {}, false);
+                var opts = separateDynamic(flattenNestedOptions(options), false);
+                var stats$$12 = {
+                  gpuTime: 0,
+                  cpuTime: 0,
+                  count: 0
+                };
+                var compiled = core.compile(opts, attributes, uniforms, context, stats$$12);
+                var draw = compiled.draw;
+                var batch = compiled.batch;
+                var scope = compiled.scope;
+                var EMPTY_ARRAY2 = [];
+                function reserve(count2) {
+                  while (EMPTY_ARRAY2.length < count2) {
+                    EMPTY_ARRAY2.push(null);
+                  }
+                  return EMPTY_ARRAY2;
+                }
+                function REGLCommand(args2, body) {
+                  var i2;
+                  if (typeof args2 === "function") {
+                    return scope.call(this, null, args2, 0);
+                  } else if (typeof body === "function") {
+                    if (typeof args2 === "number") {
+                      for (i2 = 0; i2 < args2; ++i2) {
+                        scope.call(this, null, body, i2);
+                      }
+                    } else if (Array.isArray(args2)) {
+                      for (i2 = 0; i2 < args2.length; ++i2) {
+                        scope.call(this, args2[i2], body, i2);
+                      }
+                    } else {
+                      return scope.call(this, args2, body, 0);
+                    }
+                  } else if (typeof args2 === "number") {
+                    if (args2 > 0) {
+                      return batch.call(this, reserve(args2 | 0), args2 | 0);
+                    }
+                  } else if (Array.isArray(args2)) {
+                    if (args2.length) {
+                      return batch.call(this, args2, args2.length);
+                    }
+                  } else {
+                    return draw.call(this, args2);
+                  }
+                }
+                return extend2(REGLCommand, {
+                  stats: stats$$12,
+                  destroy: function() {
+                    compiled.destroy();
+                  }
+                });
+              }
+              var setFBO = framebufferState.setFBO = compileProcedure({
+                framebuffer: dynamic.define.call(null, DYN_PROP, "framebuffer")
+              });
+              function clearImpl(_2, options) {
+                var clearFlags = 0;
+                core.procs.poll();
+                var c2 = options.color;
+                if (c2) {
+                  gl2.clearColor(+c2[0] || 0, +c2[1] || 0, +c2[2] || 0, +c2[3] || 0);
+                  clearFlags |= GL_COLOR_BUFFER_BIT;
+                }
+                if ("depth" in options) {
+                  gl2.clearDepth(+options.depth);
+                  clearFlags |= GL_DEPTH_BUFFER_BIT;
+                }
+                if ("stencil" in options) {
+                  gl2.clearStencil(options.stencil | 0);
+                  clearFlags |= GL_STENCIL_BUFFER_BIT;
+                }
+                gl2.clear(clearFlags);
+              }
+              function clear(options) {
+                if ("framebuffer" in options) {
+                  if (options.framebuffer && options.framebuffer_reglType === "framebufferCube") {
+                    for (var i2 = 0; i2 < 6; ++i2) {
+                      setFBO(extend2({
+                        framebuffer: options.framebuffer.faces[i2]
+                      }, options), clearImpl);
+                    }
+                  } else {
+                    setFBO(options, clearImpl);
+                  }
+                } else {
+                  clearImpl(null, options);
+                }
+              }
+              function frame(cb2) {
+                rafCallbacks.push(cb2);
+                function cancel() {
+                  var i2 = find(rafCallbacks, cb2);
+                  function pendingCancel() {
+                    var index = find(rafCallbacks, pendingCancel);
+                    rafCallbacks[index] = rafCallbacks[rafCallbacks.length - 1];
+                    rafCallbacks.length -= 1;
+                    if (rafCallbacks.length <= 0) {
+                      stopRAF();
+                    }
+                  }
+                  rafCallbacks[i2] = pendingCancel;
+                }
+                startRAF();
+                return {
+                  cancel
+                };
+              }
+              function pollViewport() {
+                var viewport = nextState.viewport;
+                var scissorBox = nextState.scissor_box;
+                viewport[0] = viewport[1] = scissorBox[0] = scissorBox[1] = 0;
+                contextState.viewportWidth = contextState.framebufferWidth = contextState.drawingBufferWidth = viewport[2] = scissorBox[2] = gl2.drawingBufferWidth;
+                contextState.viewportHeight = contextState.framebufferHeight = contextState.drawingBufferHeight = viewport[3] = scissorBox[3] = gl2.drawingBufferHeight;
+              }
+              function poll() {
+                contextState.tick += 1;
+                contextState.time = now();
+                pollViewport();
+                core.procs.poll();
+              }
+              function refresh() {
+                textureState.refresh();
+                pollViewport();
+                core.procs.refresh();
+                if (timer) {
+                  timer.update();
+                }
+              }
+              function now() {
+                return (clock() - START_TIME) / 1e3;
+              }
+              refresh();
+              function addListener(event, callback) {
+                var callbacks;
+                switch (event) {
+                  case "frame":
+                    return frame(callback);
+                  case "lost":
+                    callbacks = lossCallbacks;
+                    break;
+                  case "restore":
+                    callbacks = restoreCallbacks;
+                    break;
+                  case "destroy":
+                    callbacks = destroyCallbacks;
+                    break;
+                }
+                callbacks.push(callback);
+                return {
+                  cancel: function() {
+                    for (var i2 = 0; i2 < callbacks.length; ++i2) {
+                      if (callbacks[i2] === callback) {
+                        callbacks[i2] = callbacks[callbacks.length - 1];
+                        callbacks.pop();
+                        return;
+                      }
+                    }
+                  }
+                };
+              }
+              function getCachedCode() {
+                return cachedCode;
+              }
+              function preloadCachedCode(moreCache) {
+                Object.entries(moreCache).forEach(function(kv) {
+                  cachedCode[kv[0]] = kv[1];
+                });
+              }
+              var regl = extend2(compileProcedure, {
+                // Clear current FBO
+                clear,
+                // Short cuts for dynamic variables
+                prop: dynamic.define.bind(null, DYN_PROP),
+                context: dynamic.define.bind(null, DYN_CONTEXT),
+                this: dynamic.define.bind(null, DYN_STATE),
+                // executes an empty draw command
+                draw: compileProcedure({}),
+                // Resources
+                buffer: function(options) {
+                  return bufferState.create(options, GL_ARRAY_BUFFER, false, false);
+                },
+                elements: function(options) {
+                  return elementState.create(options, false);
+                },
+                texture: textureState.create2D,
+                cube: textureState.createCube,
+                renderbuffer: renderbufferState.create,
+                framebuffer: framebufferState.create,
+                framebufferCube: framebufferState.createCube,
+                vao: attributeState.createVAO,
+                // Expose context attributes
+                attributes: glAttributes,
+                // Frame rendering
+                frame,
+                on: addListener,
+                // System limits
+                limits,
+                hasExtension: function(name2) {
+                  return limits.extensions.indexOf(name2.toLowerCase()) >= 0;
+                },
+                // Read pixels
+                read: readPixels,
+                // Destroy regl and all associated resources
+                destroy,
+                // Direct GL state manipulation
+                _gl: gl2,
+                _refresh: refresh,
+                poll: function() {
+                  poll();
+                  if (timer) {
+                    timer.update();
+                  }
+                },
+                // Current time
+                now,
+                // regl Statistics Information
+                stats: stats$$1,
+                // cache generated code
+                getCachedCode,
+                preloadCachedCode
+              });
+              config2.onDone(null, regl);
+              return regl;
+            }
+            return wrapREGL;
+          });
+        }
+      });
+      var require_prepare_regl = __commonJS({
+        "src/lib/prepare_regl.js"(exports, module2) {
+          var showNoWebGlMsg = require_show_no_webgl_msg();
+          var createRegl = require_regl_unchecked2();
+          module2.exports = function prepareRegl(gd2, extensions, reglPrecompiled) {
+            var fullLayout = gd2._fullLayout;
+            var success = true;
+            fullLayout._glcanvas.each(function(d2) {
+              if (d2.regl) {
+                d2.regl.preloadCachedCode(reglPrecompiled);
+                return;
+              }
+              if (d2.pick && !fullLayout._has("parcoords")) return;
+              try {
+                d2.regl = createRegl({
+                  canvas: this,
+                  attributes: {
+                    antialias: !d2.pick,
+                    preserveDrawingBuffer: true
+                  },
+                  pixelRatio: gd2._context.plotGlPixelRatio || window.devicePixelRatio,
+                  extensions: extensions || [],
+                  cachedCode: reglPrecompiled || {}
+                });
+              } catch (e2) {
+                success = false;
+              }
+              if (!d2.regl) success = false;
+              if (success) {
+                this.addEventListener("webglcontextlost", function(event) {
+                  if (gd2 && gd2.emit) {
+                    gd2.emit("plotly_webglcontextlost", {
+                      event,
+                      layer: d2.key
+                    });
+                  }
+                }, false);
+              }
+            });
+            if (!success) {
+              showNoWebGlMsg({ container: fullLayout._glcontainer.node() });
+            }
+            return success;
+          };
+        }
+      });
+      var require_plot19 = __commonJS({
+        "src/traces/scattergl/plot.js"(exports, module2) {
+          var createScatter = require_bundle();
+          var createLine = require_regl_line2d();
+          var createError = require_regl_error2d();
+          var Text = require_dist();
+          var Lib = require_lib();
+          var selectMode = require_helpers5().selectMode;
+          var prepareRegl = require_prepare_regl();
+          var subTypes = require_subtypes();
+          var linkTraces = require_link_traces();
+          var styleTextSelection = require_edit_style().styleTextSelection;
+          var reglPrecompiled = {};
+          function getViewport2(fullLayout, xaxis, yaxis, plotGlPixelRatio) {
+            var gs = fullLayout._size;
+            var width = fullLayout.width * plotGlPixelRatio;
+            var height = fullLayout.height * plotGlPixelRatio;
+            var l2 = gs.l * plotGlPixelRatio;
+            var b2 = gs.b * plotGlPixelRatio;
+            var r2 = gs.r * plotGlPixelRatio;
+            var t4 = gs.t * plotGlPixelRatio;
+            var w2 = gs.w * plotGlPixelRatio;
+            var h2 = gs.h * plotGlPixelRatio;
+            return [
+              l2 + xaxis.domain[0] * w2,
+              b2 + yaxis.domain[0] * h2,
+              width - r2 - (1 - xaxis.domain[1]) * w2,
+              height - t4 - (1 - yaxis.domain[1]) * h2
+            ];
+          }
+          var exports = module2.exports = function plot(gd2, subplot, cdata) {
+            if (!cdata.length) return;
+            var fullLayout = gd2._fullLayout;
+            var scene = subplot._scene;
+            var xaxis = subplot.xaxis;
+            var yaxis = subplot.yaxis;
+            var i2, j2;
+            if (!scene) return;
+            var success = prepareRegl(gd2, ["ANGLE_instanced_arrays", "OES_element_index_uint"], reglPrecompiled);
+            if (!success) {
+              scene.init();
+              return;
+            }
+            var count2 = scene.count;
+            var regl = fullLayout._glcanvas.data()[0].regl;
+            linkTraces(gd2, subplot, cdata);
+            if (scene.dirty) {
+              if ((scene.line2d || scene.error2d) && !(scene.scatter2d || scene.fill2d || scene.glText)) {
+                regl.clear({ color: true, depth: true });
+              }
+              if (scene.error2d === true) {
+                scene.error2d = createError(regl);
+              }
+              if (scene.line2d === true) {
+                scene.line2d = createLine(regl);
+              }
+              if (scene.scatter2d === true) {
+                scene.scatter2d = createScatter(regl);
+              }
+              if (scene.fill2d === true) {
+                scene.fill2d = createLine(regl);
+              }
+              if (scene.glText === true) {
+                scene.glText = new Array(count2);
+                for (i2 = 0; i2 < count2; i2++) {
+                  scene.glText[i2] = new Text(regl);
+                }
+              }
+              if (scene.glText) {
+                if (count2 > scene.glText.length) {
+                  var textsToAdd = count2 - scene.glText.length;
+                  for (i2 = 0; i2 < textsToAdd; i2++) {
+                    scene.glText.push(new Text(regl));
+                  }
+                } else if (count2 < scene.glText.length) {
+                  var textsToRemove = scene.glText.length - count2;
+                  var removedTexts = scene.glText.splice(count2, textsToRemove);
+                  removedTexts.forEach(function(text) {
+                    text.destroy();
+                  });
+                }
+                for (i2 = 0; i2 < count2; i2++) {
+                  scene.glText[i2].update(scene.textOptions[i2]);
+                }
+              }
+              if (scene.line2d) {
+                scene.line2d.update(scene.lineOptions);
+                scene.lineOptions = scene.lineOptions.map(function(lineOptions) {
+                  if (lineOptions && lineOptions.positions) {
+                    var srcPos = lineOptions.positions;
+                    var firstptdef = 0;
+                    while (firstptdef < srcPos.length && (isNaN(srcPos[firstptdef]) || isNaN(srcPos[firstptdef + 1]))) {
+                      firstptdef += 2;
+                    }
+                    var lastptdef = srcPos.length - 2;
+                    while (lastptdef > firstptdef && (isNaN(srcPos[lastptdef]) || isNaN(srcPos[lastptdef + 1]))) {
+                      lastptdef -= 2;
+                    }
+                    lineOptions.positions = srcPos.slice(firstptdef, lastptdef + 2);
+                  }
+                  return lineOptions;
+                });
+                scene.line2d.update(scene.lineOptions);
+              }
+              if (scene.error2d) {
+                var errorBatch = (scene.errorXOptions || []).concat(scene.errorYOptions || []);
+                scene.error2d.update(errorBatch);
+              }
+              if (scene.scatter2d) {
+                scene.scatter2d.update(scene.markerOptions);
+              }
+              scene.fillOrder = Lib.repeat(null, count2);
+              if (scene.fill2d) {
+                scene.fillOptions = scene.fillOptions.map(function(fillOptions, i22) {
+                  var cdscatter = cdata[i22];
+                  if (!fillOptions || !cdscatter || !cdscatter[0] || !cdscatter[0].trace) return;
+                  var cd2 = cdscatter[0];
+                  var trace2 = cd2.trace;
+                  var stash2 = cd2.t;
+                  var lineOptions = scene.lineOptions[i22];
+                  var last, j22;
+                  var fillData = [];
+                  if (trace2._ownfill) fillData.push(i22);
+                  if (trace2._nexttrace) fillData.push(i22 + 1);
+                  if (fillData.length) scene.fillOrder[i22] = fillData;
+                  var pos = [];
+                  var srcPos = lineOptions && lineOptions.positions || stash2.positions;
+                  var firstptdef, lastptdef;
+                  if (trace2.fill === "tozeroy") {
+                    firstptdef = 0;
+                    while (firstptdef < srcPos.length && isNaN(srcPos[firstptdef + 1])) {
+                      firstptdef += 2;
+                    }
+                    lastptdef = srcPos.length - 2;
+                    while (lastptdef > firstptdef && isNaN(srcPos[lastptdef + 1])) {
+                      lastptdef -= 2;
+                    }
+                    if (srcPos[firstptdef + 1] !== 0) {
+                      pos = [srcPos[firstptdef], 0];
+                    }
+                    pos = pos.concat(srcPos.slice(firstptdef, lastptdef + 2));
+                    if (srcPos[lastptdef + 1] !== 0) {
+                      pos = pos.concat([srcPos[lastptdef], 0]);
+                    }
+                  } else if (trace2.fill === "tozerox") {
+                    firstptdef = 0;
+                    while (firstptdef < srcPos.length && isNaN(srcPos[firstptdef])) {
+                      firstptdef += 2;
+                    }
+                    lastptdef = srcPos.length - 2;
+                    while (lastptdef > firstptdef && isNaN(srcPos[lastptdef])) {
+                      lastptdef -= 2;
+                    }
+                    if (srcPos[firstptdef] !== 0) {
+                      pos = [0, srcPos[firstptdef + 1]];
+                    }
+                    pos = pos.concat(srcPos.slice(firstptdef, lastptdef + 2));
+                    if (srcPos[lastptdef] !== 0) {
+                      pos = pos.concat([0, srcPos[lastptdef + 1]]);
+                    }
+                  } else if (trace2.fill === "toself" || trace2.fill === "tonext") {
+                    pos = [];
+                    last = 0;
+                    fillOptions.splitNull = true;
+                    for (j22 = 0; j22 < srcPos.length; j22 += 2) {
+                      if (isNaN(srcPos[j22]) || isNaN(srcPos[j22 + 1])) {
+                        pos = pos.concat(srcPos.slice(last, j22));
+                        pos.push(srcPos[last], srcPos[last + 1]);
+                        pos.push(null, null);
+                        last = j22 + 2;
+                      }
+                    }
+                    pos = pos.concat(srcPos.slice(last));
+                    if (last) {
+                      pos.push(srcPos[last], srcPos[last + 1]);
+                    }
+                  } else {
+                    var nextTrace = trace2._nexttrace;
+                    if (nextTrace) {
+                      var nextOptions = scene.lineOptions[i22 + 1];
+                      if (nextOptions) {
+                        var nextPos = nextOptions.positions;
+                        if (trace2.fill === "tonexty") {
+                          pos = srcPos.slice();
+                          for (i22 = Math.floor(nextPos.length / 2); i22--; ) {
+                            var xx = nextPos[i22 * 2];
+                            var yy = nextPos[i22 * 2 + 1];
+                            if (isNaN(xx) || isNaN(yy)) continue;
+                            pos.push(xx, yy);
+                          }
+                          fillOptions.fill = nextTrace.fillcolor;
+                        }
+                      }
+                    }
+                  }
+                  if (trace2._prevtrace && trace2._prevtrace.fill === "tonext") {
+                    var prevLinePos = scene.lineOptions[i22 - 1].positions;
+                    var offset = pos.length / 2;
+                    last = offset;
+                    var hole = [last];
+                    for (j22 = 0; j22 < prevLinePos.length; j22 += 2) {
+                      if (isNaN(prevLinePos[j22]) || isNaN(prevLinePos[j22 + 1])) {
+                        hole.push(j22 / 2 + offset + 1);
+                        last = j22 + 2;
+                      }
+                    }
+                    pos = pos.concat(prevLinePos);
+                    fillOptions.hole = hole;
+                  }
+                  fillOptions.fillmode = trace2.fill;
+                  fillOptions.opacity = trace2.opacity;
+                  fillOptions.positions = pos;
+                  return fillOptions;
+                });
+                scene.fill2d.update(scene.fillOptions);
+              }
+            }
+            var dragmode = fullLayout.dragmode;
+            var isSelectMode = selectMode(dragmode);
+            var clickSelectEnabled = fullLayout.clickmode.indexOf("select") > -1;
+            for (const [cd0] of cdata) {
+              if (!cd0) continue;
+              var trace = cd0.trace;
+              var stash = cd0.t;
+              var index = stash.index;
+              var len2 = trace._length;
+              var x2 = stash.x;
+              var y2 = stash.y;
+              if (trace.selectedpoints || isSelectMode || clickSelectEnabled) {
+                if (!isSelectMode) isSelectMode = true;
+                if (trace.selectedpoints) {
+                  var selPts = scene.selectBatch[index] = Lib.selIndices2selPoints(trace);
+                  var selDict = {};
+                  for (j2 = 0; j2 < selPts.length; j2++) {
+                    selDict[selPts[j2]] = 1;
+                  }
+                  var unselPts = [];
+                  for (j2 = 0; j2 < len2; j2++) {
+                    if (!selDict[j2]) unselPts.push(j2);
+                  }
+                  scene.unselectBatch[index] = unselPts;
+                }
+                var xpx = stash.xpx = new Array(len2);
+                var ypx = stash.ypx = new Array(len2);
+                for (j2 = 0; j2 < len2; j2++) {
+                  xpx[j2] = xaxis.c2p(x2[j2]);
+                  ypx[j2] = yaxis.c2p(y2[j2]);
+                }
+              } else {
+                stash.xpx = stash.ypx = null;
+              }
+            }
+            if (isSelectMode) {
+              if (!scene.select2d) {
+                scene.select2d = createScatter(fullLayout._glcanvas.data()[1].regl);
+              }
+              if (scene.scatter2d) {
+                var unselOpts = new Array(count2);
+                for (i2 = 0; i2 < count2; i2++) {
+                  unselOpts[i2] = scene.selectBatch[i2].length || scene.unselectBatch[i2].length ? scene.markerUnselectedOptions[i2] : {};
+                }
+                scene.scatter2d.update(unselOpts);
+              }
+              if (scene.select2d) {
+                scene.select2d.update(scene.markerOptions);
+                scene.select2d.update(scene.markerSelectedOptions);
+              }
+              if (scene.glText) {
+                cdata.forEach(function(cdscatter) {
+                  var trace2 = ((cdscatter || [])[0] || {}).trace || {};
+                  if (subTypes.hasText(trace2)) {
+                    styleTextSelection(cdscatter);
+                  }
+                });
+              }
+            } else {
+              if (scene.scatter2d) {
+                scene.scatter2d.update(scene.markerOptions);
+              }
+            }
+            var vpRange0 = {
+              viewport: getViewport2(fullLayout, xaxis, yaxis, gd2._context.plotGlPixelRatio),
+              // TODO do we need those fallbacks?
+              range: [
+                (xaxis._rl || xaxis.range)[0],
+                (yaxis._rl || yaxis.range)[0],
+                (xaxis._rl || xaxis.range)[1],
+                (yaxis._rl || yaxis.range)[1]
+              ]
+            };
+            var vpRange = Lib.repeat(vpRange0, scene.count);
+            if (scene.fill2d) {
+              scene.fill2d.update(vpRange);
+            }
+            if (scene.line2d) {
+              scene.line2d.update(vpRange);
+            }
+            if (scene.error2d) {
+              scene.error2d.update(vpRange.concat(vpRange));
+            }
+            if (scene.scatter2d) {
+              scene.scatter2d.update(vpRange);
+            }
+            if (scene.select2d) {
+              scene.select2d.update(vpRange);
+            }
+            if (scene.glText) {
+              scene.glText.forEach(function(text) {
+                text.update(vpRange0);
+              });
+            }
+          };
+          exports.reglPrecompiled = reglPrecompiled;
+        }
+      });
+      var require_scattergl = __commonJS({
+        "src/traces/scattergl/index.js"(exports, module2) {
+          var index = require_base_index();
+          index.plot = require_plot19();
+          module2.exports = index;
+        }
+      });
+      var require_scattergl2 = __commonJS({
+        "lib/scattergl.js"(exports, module2) {
+          module2.exports = require_scattergl();
+        }
+      });
+      var require_attributes51 = __commonJS({
+        "src/traces/splom/attributes.js"(exports, module2) {
+          var scatterAttrs = require_attributes12();
+          var colorScaleAttrs = require_attributes8();
+          var axisHoverFormat = require_axis_format_attributes().axisHoverFormat;
+          var { hovertemplateAttrs, templatefallbackAttrs } = require_template_attributes();
+          var scatterGlAttrs = require_attributes50();
+          var cartesianIdRegex = require_constants2().idRegex;
+          var templatedArray = require_plot_template().templatedArray;
+          var extendFlat = require_extend().extendFlat;
+          var scatterMarkerAttrs = scatterAttrs.marker;
+          var scatterMarkerLineAttrs = scatterMarkerAttrs.line;
+          var markerLineAttrs = extendFlat(colorScaleAttrs("marker.line", { editTypeOverride: "calc" }), {
+            width: extendFlat({}, scatterMarkerLineAttrs.width, { editType: "calc" }),
+            editType: "calc"
+          });
+          var markerAttrs = extendFlat(colorScaleAttrs("marker"), {
+            symbol: scatterMarkerAttrs.symbol,
+            angle: scatterMarkerAttrs.angle,
+            size: extendFlat({}, scatterMarkerAttrs.size, { editType: "markerSize" }),
+            sizeref: scatterMarkerAttrs.sizeref,
+            sizemin: scatterMarkerAttrs.sizemin,
+            sizemode: scatterMarkerAttrs.sizemode,
+            opacity: scatterMarkerAttrs.opacity,
+            colorbar: scatterMarkerAttrs.colorbar,
+            line: markerLineAttrs,
+            editType: "calc"
+          });
+          markerAttrs.color.editType = markerAttrs.cmin.editType = markerAttrs.cmax.editType = "style";
+          function makeAxesValObject(axLetter) {
+            return {
+              valType: "info_array",
+              freeLength: true,
+              editType: "calc",
+              items: {
+                valType: "subplotid",
+                regex: cartesianIdRegex[axLetter],
+                editType: "plot"
+              }
+            };
+          }
+          module2.exports = {
+            dimensions: templatedArray("dimension", {
+              visible: {
+                valType: "boolean",
+                dflt: true,
+                editType: "calc"
+              },
+              label: {
+                valType: "string",
+                editType: "calc"
+              },
+              values: {
+                valType: "data_array",
+                editType: "calc+clearAxisTypes"
+              },
+              axis: {
+                type: {
+                  valType: "enumerated",
+                  values: ["linear", "log", "date", "category"],
+                  editType: "calc+clearAxisTypes"
+                },
+                // TODO make 'true' the default in v3?
+                matches: {
+                  valType: "boolean",
+                  dflt: false,
+                  editType: "calc"
+                },
+                editType: "calc+clearAxisTypes"
+              },
+              // TODO should add an attribute to pin down x only vars and y only vars
+              // like https://seaborn.pydata.org/generated/seaborn.pairplot.html
+              // x_vars and y_vars
+              // maybe more axis defaulting option e.g. `showgrid: false`
+              editType: "calc+clearAxisTypes"
+            }),
+            // mode: {}, (only 'markers' for now)
+            text: extendFlat({}, scatterGlAttrs.text, {}),
+            hovertext: extendFlat({}, scatterGlAttrs.hovertext, {}),
+            hovertemplate: hovertemplateAttrs(),
+            hovertemplatefallback: templatefallbackAttrs(),
+            xhoverformat: axisHoverFormat("x"),
+            yhoverformat: axisHoverFormat("y"),
+            marker: markerAttrs,
+            xaxes: makeAxesValObject("x"),
+            yaxes: makeAxesValObject("y"),
+            diagonal: {
+              visible: {
+                valType: "boolean",
+                dflt: true,
+                editType: "calc"
+              },
+              // type: 'scattergl' | 'histogram' | 'box' | 'violin'
+              // ...
+              // more options
+              editType: "calc"
+            },
+            showupperhalf: {
+              valType: "boolean",
+              dflt: true,
+              editType: "calc"
+            },
+            showlowerhalf: {
+              valType: "boolean",
+              dflt: true,
+              editType: "calc"
+            },
+            selected: {
+              marker: scatterGlAttrs.selected.marker,
+              editType: "calc"
+            },
+            unselected: {
+              marker: scatterGlAttrs.unselected.marker,
+              editType: "calc"
+            },
+            opacity: scatterGlAttrs.opacity
+          };
+        }
+      });
+      var require_merge_length = __commonJS({
+        "src/traces/parcoords/merge_length.js"(exports, module2) {
+          module2.exports = function(traceOut, dimensions, dataAttr, len2) {
+            if (!len2) len2 = Infinity;
+            var i2, dimi;
+            for (i2 = 0; i2 < dimensions.length; i2++) {
+              dimi = dimensions[i2];
+              if (dimi.visible) len2 = Math.min(len2, dimi[dataAttr].length);
+            }
+            if (len2 === Infinity) len2 = 0;
+            traceOut._length = len2;
+            for (i2 = 0; i2 < dimensions.length; i2++) {
+              dimi = dimensions[i2];
+              if (dimi.visible) dimi._length = len2;
+            }
+            return len2;
+          };
+        }
+      });
+      var require_defaults47 = __commonJS({
+        "src/traces/splom/defaults.js"(exports, module2) {
+          var Lib = require_lib();
+          var handleArrayContainerDefaults = require_array_container_defaults();
+          var attributes = require_attributes51();
+          var subTypes = require_subtypes();
+          var handleMarkerDefaults = require_marker_defaults();
+          var mergeLength = require_merge_length();
+          var isOpenSymbol = require_helpers16().isOpenSymbol;
+          module2.exports = function supplyDefaults(traceIn, traceOut, defaultColor, layout) {
+            function coerce(attr, dflt) {
+              return Lib.coerce(traceIn, traceOut, attributes, attr, dflt);
+            }
+            var dimensions = handleArrayContainerDefaults(traceIn, traceOut, {
+              name: "dimensions",
+              handleItemDefaults: dimensionDefaults
+            });
+            var showDiag = coerce("diagonal.visible");
+            var showUpper = coerce("showupperhalf");
+            var showLower = coerce("showlowerhalf");
+            var dimLength = mergeLength(traceOut, dimensions, "values");
+            if (!dimLength || !showDiag && !showUpper && !showLower) {
+              traceOut.visible = false;
+              return;
+            }
+            coerce("text");
+            coerce("hovertext");
+            coerce("hovertemplate");
+            coerce("hovertemplatefallback");
+            coerce("xhoverformat");
+            coerce("yhoverformat");
+            handleMarkerDefaults(traceIn, traceOut, defaultColor, layout, coerce, {
+              noAngleRef: true,
+              noLineDash: true,
+              noStandOff: true
+            });
+            var isOpen = isOpenSymbol(traceOut.marker.symbol);
+            var isBubble = subTypes.isBubble(traceOut);
+            coerce("marker.line.width", isOpen || isBubble ? 1 : 0);
+            handleAxisDefaults(traceIn, traceOut, layout, coerce);
+            Lib.coerceSelectionMarkerOpacity(traceOut, coerce);
+          };
+          function dimensionDefaults(dimIn, dimOut) {
+            function coerce(attr, dflt) {
+              return Lib.coerce(dimIn, dimOut, attributes.dimensions, attr, dflt);
+            }
+            coerce("label");
+            var values = coerce("values");
+            if (!(values && values.length)) dimOut.visible = false;
+            else coerce("visible");
+            coerce("axis.type");
+            coerce("axis.matches");
+          }
+          function handleAxisDefaults(traceIn, traceOut, layout, coerce) {
+            var dimensions = traceOut.dimensions;
+            var dimLength = dimensions.length;
+            var showUpper = traceOut.showupperhalf;
+            var showLower = traceOut.showlowerhalf;
+            var showDiag = traceOut.diagonal.visible;
+            var i2, j2;
+            var xAxesDflt = new Array(dimLength);
+            var yAxesDflt = new Array(dimLength);
+            for (i2 = 0; i2 < dimLength; i2++) {
+              var suffix = i2 ? i2 + 1 : "";
+              xAxesDflt[i2] = "x" + suffix;
+              yAxesDflt[i2] = "y" + suffix;
+            }
+            var xaxes = coerce("xaxes", xAxesDflt);
+            var yaxes = coerce("yaxes", yAxesDflt);
+            var diag = traceOut._diag = new Array(dimLength);
+            traceOut._xaxes = {};
+            traceOut._yaxes = {};
+            var xList = [];
+            var yList = [];
+            function fillAxisStashes(axId, counterAxId, dim2, list) {
+              if (!axId) return;
+              var axLetter = axId.charAt(0);
+              var stash = layout._splomAxes[axLetter];
+              traceOut["_" + axLetter + "axes"][axId] = 1;
+              list.push(axId);
+              if (!(axId in stash)) {
+                var s2 = stash[axId] = {};
+                if (dim2) {
+                  s2.label = dim2.label || "";
+                  if (dim2.visible && dim2.axis) {
+                    if (dim2.axis.type) s2.type = dim2.axis.type;
+                    if (dim2.axis.matches) s2.matches = counterAxId;
+                  }
+                }
+              }
+            }
+            var mustShiftX = !showDiag && !showLower;
+            var mustShiftY = !showDiag && !showUpper;
+            traceOut._axesDim = {};
+            for (i2 = 0; i2 < dimLength; i2++) {
+              var dim = dimensions[i2];
+              var i0 = i2 === 0;
+              var iN = i2 === dimLength - 1;
+              var xaId = i0 && mustShiftX || iN && mustShiftY ? void 0 : xaxes[i2];
+              var yaId = i0 && mustShiftY || iN && mustShiftX ? void 0 : yaxes[i2];
+              fillAxisStashes(xaId, yaId, dim, xList);
+              fillAxisStashes(yaId, xaId, dim, yList);
+              diag[i2] = [xaId, yaId];
+              traceOut._axesDim[xaId] = i2;
+              traceOut._axesDim[yaId] = i2;
+            }
+            for (i2 = 0; i2 < xList.length; i2++) {
+              for (j2 = 0; j2 < yList.length; j2++) {
+                var id2 = xList[i2] + yList[j2];
+                if (i2 > j2 && showUpper) {
+                  layout._splomSubplots[id2] = 1;
+                } else if (i2 < j2 && showLower) {
+                  layout._splomSubplots[id2] = 1;
+                } else if (i2 === j2 && (showDiag || !showLower || !showUpper)) {
+                  layout._splomSubplots[id2] = 1;
+                }
+              }
+            }
+            if (!showLower || !showDiag && showUpper && showLower) {
+              layout._splomGridDflt.xside = "bottom";
+              layout._splomGridDflt.yside = "left";
+            }
+          }
+        }
+      });
+      var require_scene_update2 = __commonJS({
+        "src/traces/splom/scene_update.js"(exports, module2) {
+          var Lib = require_lib();
+          module2.exports = function sceneUpdate(gd2, trace) {
+            var fullLayout = gd2._fullLayout;
+            var uid2 = trace.uid;
+            var splomScenes = fullLayout._splomScenes;
+            if (!splomScenes) splomScenes = fullLayout._splomScenes = {};
+            var reset = {
+              dirty: true,
+              selectBatch: [],
+              unselectBatch: []
+            };
+            var first = {
+              matrix: false,
+              selectBatch: [],
+              unselectBatch: []
+            };
+            var scene = splomScenes[trace.uid];
+            if (!scene) {
+              scene = splomScenes[uid2] = Lib.extendFlat({}, reset, first);
+              scene.draw = function draw() {
+                if (scene.matrix && scene.matrix.draw) {
+                  if (scene.selectBatch.length || scene.unselectBatch.length) {
+                    scene.matrix.draw(scene.unselectBatch, scene.selectBatch);
+                  } else {
+                    scene.matrix.draw();
+                  }
+                }
+                scene.dirty = false;
+              };
+              scene.destroy = function destroy() {
+                if (scene.matrix && scene.matrix.destroy) {
+                  scene.matrix.destroy();
+                }
+                scene.matrixOptions = null;
+                scene.selectBatch = null;
+                scene.unselectBatch = null;
+                scene = null;
+              };
+            }
+            if (!scene.dirty) {
+              Lib.extendFlat(scene, reset);
+            }
+            return scene;
+          };
+        }
+      });
+      var require_calc30 = __commonJS({
+        "src/traces/splom/calc.js"(exports, module2) {
+          var Lib = require_lib();
+          var AxisIDs = require_axis_ids();
+          var calcMarkerSize = require_calc3().calcMarkerSize;
+          var calcAxisExpansion = require_calc3().calcAxisExpansion;
+          var calcColorscale = require_colorscale_calc();
+          var convertMarkerSelection = require_convert10().markerSelection;
+          var convertMarkerStyle = require_convert10().markerStyle;
+          var sceneUpdate = require_scene_update2();
+          var BADNUM = require_numerical().BADNUM;
+          var TOO_MANY_POINTS = require_constants23().TOO_MANY_POINTS;
+          module2.exports = function calc(gd2, trace) {
+            var dimensions = trace.dimensions;
+            var commonLength = trace._length;
+            var opts = {};
+            var cdata = opts.cdata = [];
+            var ldata = opts.data = [];
+            var visibleDims = trace._visibleDims = [];
+            var i2, k2, dim, xa, ya2;
+            function makeCalcdata(ax, dim2) {
+              var ccol = ax.makeCalcdata({
+                v: dim2.values,
+                vcalendar: trace.calendar
+              }, "v");
+              for (var j2 = 0; j2 < ccol.length; j2++) {
+                ccol[j2] = ccol[j2] === BADNUM ? NaN : ccol[j2];
+              }
+              cdata.push(ccol);
+              ldata.push(ax.type === "log" ? Lib.simpleMap(ccol, ax.c2l) : ccol);
+            }
+            for (i2 = 0; i2 < dimensions.length; i2++) {
+              dim = dimensions[i2];
+              if (dim.visible) {
+                xa = AxisIDs.getFromId(gd2, trace._diag[i2][0]);
+                ya2 = AxisIDs.getFromId(gd2, trace._diag[i2][1]);
+                if (xa && ya2 && xa.type !== ya2.type) {
+                  Lib.log("Skipping splom dimension " + i2 + " with conflicting axis types");
+                  continue;
+                }
+                if (xa) {
+                  makeCalcdata(xa, dim);
+                  if (ya2 && ya2.type === "category") {
+                    ya2._categories = xa._categories.slice();
+                  }
+                } else {
+                  makeCalcdata(ya2, dim);
+                }
+                visibleDims.push(i2);
+              }
+            }
+            calcColorscale(gd2, trace);
+            Lib.extendFlat(opts, convertMarkerStyle(gd2, trace));
+            var visibleLength = cdata.length;
+            var hasTooManyPoints = visibleLength * commonLength > TOO_MANY_POINTS;
+            var ppad;
+            if (hasTooManyPoints) {
+              ppad = opts.sizeAvg || Math.max(opts.size, 3);
+            } else {
+              ppad = calcMarkerSize(trace, commonLength);
+            }
+            for (k2 = 0; k2 < visibleDims.length; k2++) {
+              i2 = visibleDims[k2];
+              dim = dimensions[i2];
+              xa = AxisIDs.getFromId(gd2, trace._diag[i2][0]) || {};
+              ya2 = AxisIDs.getFromId(gd2, trace._diag[i2][1]) || {};
+              calcAxisExpansion(gd2, trace, xa, ya2, cdata[k2], cdata[k2], ppad);
+            }
+            var scene = sceneUpdate(gd2, trace);
+            if (!scene.matrix) scene.matrix = true;
+            scene.matrixOptions = opts;
+            scene.selectedOptions = convertMarkerSelection(gd2, trace, trace.selected);
+            scene.unselectedOptions = convertMarkerSelection(gd2, trace, trace.unselected);
+            return [{ x: false, y: false, t: {}, trace }];
+          };
+        }
+      });
+      var require_performance_now = __commonJS({
+        "node_modules/performance-now/lib/performance-now.js"(exports, module2) {
+          (function() {
+            var getNanoSeconds, hrtime, loadTime, moduleLoadTime, nodeLoadTime, upTime;
+            if (typeof performance !== "undefined" && performance !== null && performance.now) {
+              module2.exports = function() {
+                return performance.now();
+              };
+            } else if (typeof process !== "undefined" && process !== null && process.hrtime) {
+              module2.exports = function() {
+                return (getNanoSeconds() - nodeLoadTime) / 1e6;
+              };
+              hrtime = process.hrtime;
+              getNanoSeconds = function() {
+                var hr;
+                hr = hrtime();
+                return hr[0] * 1e9 + hr[1];
+              };
+              moduleLoadTime = getNanoSeconds();
+              upTime = process.uptime() * 1e9;
+              nodeLoadTime = moduleLoadTime - upTime;
+            } else if (Date.now) {
+              module2.exports = function() {
+                return Date.now() - loadTime;
+              };
+              loadTime = Date.now();
+            } else {
+              module2.exports = function() {
+                return (/* @__PURE__ */ new Date()).getTime() - loadTime;
+              };
+              loadTime = (/* @__PURE__ */ new Date()).getTime();
+            }
+          }).call(exports);
+        }
+      });
+      var require_raf = __commonJS({
+        "node_modules/raf/index.js"(exports, module2) {
+          var now = require_performance_now();
+          var root = typeof window === "undefined" ? window : window;
+          var vendors = ["moz", "webkit"];
+          var suffix = "AnimationFrame";
+          var raf = root["request" + suffix];
+          var caf = root["cancel" + suffix] || root["cancelRequest" + suffix];
+          for (i2 = 0; !raf && i2 < vendors.length; i2++) {
+            raf = root[vendors[i2] + "Request" + suffix];
+            caf = root[vendors[i2] + "Cancel" + suffix] || root[vendors[i2] + "CancelRequest" + suffix];
+          }
+          var i2;
+          if (!raf || !caf) {
+            last = 0, id2 = 0, queue = [], frameDuration = 1e3 / 60;
+            raf = function(callback) {
+              if (queue.length === 0) {
+                var _now = now(), next = Math.max(0, frameDuration - (_now - last));
+                last = next + _now;
+                setTimeout(function() {
+                  var cp = queue.slice(0);
+                  queue.length = 0;
+                  for (var i22 = 0; i22 < cp.length; i22++) {
+                    if (!cp[i22].cancelled) {
+                      try {
+                        cp[i22].callback(last);
+                      } catch (e2) {
+                        setTimeout(function() {
+                          throw e2;
+                        }, 0);
+                      }
+                    }
+                  }
+                }, Math.round(next));
+              }
+              queue.push({
+                handle: ++id2,
+                callback,
+                cancelled: false
+              });
+              return id2;
+            };
+            caf = function(handle) {
+              for (var i22 = 0; i22 < queue.length; i22++) {
+                if (queue[i22].handle === handle) {
+                  queue[i22].cancelled = true;
+                }
+              }
+            };
+          }
+          var last;
+          var id2;
+          var queue;
+          var frameDuration;
+          module2.exports = function(fn) {
+            return raf.call(root, fn);
+          };
+          module2.exports.cancel = function() {
+            caf.apply(root, arguments);
+          };
+          module2.exports.polyfill = function(object) {
+            if (!object) {
+              object = root;
+            }
+            object.requestAnimationFrame = raf;
+            object.cancelAnimationFrame = caf;
+          };
+        }
+      });
+      var require_array_range = __commonJS({
+        "node_modules/array-range/index.js"(exports, module2) {
+          module2.exports = function newArray(start, end) {
+            var n0 = typeof start === "number", n1 = typeof end === "number";
+            if (n0 && !n1) {
+              end = start;
+              start = 0;
+            } else if (!n0 && !n1) {
+              start = 0;
+              end = 0;
+            }
+            start = start | 0;
+            end = end | 0;
+            var len2 = end - start;
+            if (len2 < 0)
+              throw new Error("array length must be positive");
+            var a2 = new Array(len2);
+            for (var i2 = 0, c2 = start; i2 < len2; i2++, c2++)
+              a2[i2] = c2;
+            return a2;
+          };
+        }
+      });
+      var require_regl_splom = __commonJS({
+        "node_modules/regl-splom/index.js"(exports, module2) {
+          var createScatter = require_bundle();
+          var pick = require_pick_by_alias();
+          var getBounds2 = require_array_bounds();
+          var raf = require_raf();
+          var arrRange = require_array_range();
+          var rect = require_parse_rect();
+          var flatten2 = require_flatten_vertex_data();
+          module2.exports = SPLOM;
+          function SPLOM(regl, options) {
+            if (!(this instanceof SPLOM)) return new SPLOM(regl);
+            this.traces = [];
+            this.passes = {};
+            this.regl = regl;
+            this.scatter = createScatter(regl);
+            this.canvas = this.scatter.canvas;
+          }
+          SPLOM.prototype.render = function(...args) {
+            if (args.length) {
+              this.update(...args);
+            }
+            if (this.regl.attributes.preserveDrawingBuffer) return this.draw();
+            if (this.dirty) {
+              if (this.planned == null) {
+                this.planned = raf(() => {
+                  this.draw();
+                  this.dirty = true;
+                  this.planned = null;
+                });
+              }
+            } else {
+              this.draw();
+              this.dirty = true;
+              raf(() => {
+                this.dirty = false;
+              });
+            }
+            return this;
+          };
+          SPLOM.prototype.update = function(...args) {
+            if (!args.length) return;
+            for (let i2 = 0; i2 < args.length; i2++) {
+              this.updateItem(i2, args[i2]);
+            }
+            this.traces = this.traces.filter(Boolean);
+            let passes = [];
+            let offset = 0;
+            for (let i2 = 0; i2 < this.traces.length; i2++) {
+              let trace = this.traces[i2];
+              let tracePasses = this.traces[i2].passes;
+              for (let j2 = 0; j2 < tracePasses.length; j2++) {
+                passes.push(this.passes[tracePasses[j2]]);
+              }
+              trace.passOffset = offset;
+              offset += trace.passes.length;
+            }
+            this.scatter.update(...passes);
+            return this;
+          };
+          SPLOM.prototype.updateItem = function(i2, options) {
+            let { regl } = this;
+            if (options === null) {
+              this.traces[i2] = null;
+              return this;
+            }
+            if (!options) return this;
+            let o2 = pick(options, {
+              data: "data items columns rows values dimensions samples x",
+              snap: "snap cluster",
+              size: "sizes size radius",
+              color: "colors color fill fill-color fillColor",
+              opacity: "opacity alpha transparency opaque",
+              borderSize: "borderSizes borderSize border-size bordersize borderWidth borderWidths border-width borderwidth stroke-width strokeWidth strokewidth outline",
+              borderColor: "borderColors borderColor bordercolor stroke stroke-color strokeColor",
+              marker: "markers marker shape",
+              range: "range ranges databox dataBox",
+              viewport: "viewport viewBox viewbox",
+              domain: "domain domains area areas",
+              padding: "pad padding paddings pads margin margins",
+              transpose: "transpose transposed",
+              diagonal: "diagonal diag showDiagonal",
+              upper: "upper up top upperhalf upperHalf showupperhalf showUpper showUpperHalf",
+              lower: "lower low bottom lowerhalf lowerHalf showlowerhalf showLowerHalf showLower"
+            });
+            let trace = this.traces[i2] || (this.traces[i2] = {
+              id: i2,
+              buffer: regl.buffer({
+                usage: "dynamic",
+                type: "float",
+                data: new Uint8Array()
+              }),
+              color: "black",
+              marker: null,
+              size: 12,
+              borderColor: "transparent",
+              borderSize: 1,
+              viewport: rect([regl._gl.drawingBufferWidth, regl._gl.drawingBufferHeight]),
+              padding: [0, 0, 0, 0],
+              opacity: 1,
+              diagonal: true,
+              upper: true,
+              lower: true
+            });
+            if (o2.color != null) {
+              trace.color = o2.color;
+            }
+            if (o2.size != null) {
+              trace.size = o2.size;
+            }
+            if (o2.marker != null) {
+              trace.marker = o2.marker;
+            }
+            if (o2.borderColor != null) {
+              trace.borderColor = o2.borderColor;
+            }
+            if (o2.borderSize != null) {
+              trace.borderSize = o2.borderSize;
+            }
+            if (o2.opacity != null) {
+              trace.opacity = o2.opacity;
+            }
+            if (o2.viewport) {
+              trace.viewport = rect(o2.viewport);
+            }
+            if (o2.diagonal != null) trace.diagonal = o2.diagonal;
+            if (o2.upper != null) trace.upper = o2.upper;
+            if (o2.lower != null) trace.lower = o2.lower;
+            if (o2.data) {
+              trace.buffer(flatten2(o2.data));
+              trace.columns = o2.data.length;
+              trace.count = o2.data[0].length;
+              trace.bounds = [];
+              for (let i22 = 0; i22 < trace.columns; i22++) {
+                trace.bounds[i22] = getBounds2(o2.data[i22], 1);
+              }
+            }
+            let multirange;
+            if (o2.range) {
+              trace.range = o2.range;
+              multirange = trace.range && typeof trace.range[0] !== "number";
+            }
+            if (o2.domain) {
+              trace.domain = o2.domain;
+            }
+            let multipadding = false;
+            if (o2.padding != null) {
+              if (Array.isArray(o2.padding) && o2.padding.length === trace.columns && typeof o2.padding[o2.padding.length - 1] === "number") {
+                trace.padding = o2.padding.map(getPad);
+                multipadding = true;
+              } else {
+                trace.padding = getPad(o2.padding);
+              }
+            }
+            let m2 = trace.columns;
+            let n2 = trace.count;
+            let w2 = trace.viewport.width;
+            let h2 = trace.viewport.height;
+            let left = trace.viewport.x;
+            let top = trace.viewport.y;
+            let iw = w2 / m2;
+            let ih2 = h2 / m2;
+            trace.passes = [];
+            for (let i22 = 0; i22 < m2; i22++) {
+              for (let j2 = 0; j2 < m2; j2++) {
+                if (!trace.diagonal && j2 === i22) continue;
+                if (!trace.upper && i22 > j2) continue;
+                if (!trace.lower && i22 < j2) continue;
+                let key = passId(trace.id, i22, j2);
+                let pass = this.passes[key] || (this.passes[key] = {});
+                if (o2.data) {
+                  if (o2.transpose) {
+                    pass.positions = {
+                      x: { buffer: trace.buffer, offset: j2, count: n2, stride: m2 },
+                      y: { buffer: trace.buffer, offset: i22, count: n2, stride: m2 }
+                    };
+                  } else {
+                    pass.positions = {
+                      x: { buffer: trace.buffer, offset: j2 * n2, count: n2 },
+                      y: { buffer: trace.buffer, offset: i22 * n2, count: n2 }
+                    };
+                  }
+                  pass.bounds = getBox(trace.bounds, i22, j2);
+                }
+                if (o2.domain || o2.viewport || o2.data) {
+                  let pad = multipadding ? getBox(trace.padding, i22, j2) : trace.padding;
+                  if (trace.domain) {
+                    let [lox, loy, hix, hiy] = getBox(trace.domain, i22, j2);
+                    pass.viewport = [
+                      left + lox * w2 + pad[0],
+                      top + loy * h2 + pad[1],
+                      left + hix * w2 - pad[2],
+                      top + hiy * h2 - pad[3]
+                    ];
+                  } else {
+                    pass.viewport = [
+                      left + j2 * iw + iw * pad[0],
+                      top + i22 * ih2 + ih2 * pad[1],
+                      left + (j2 + 1) * iw - iw * pad[2],
+                      top + (i22 + 1) * ih2 - ih2 * pad[3]
+                    ];
+                  }
+                }
+                if (o2.color) pass.color = trace.color;
+                if (o2.size) pass.size = trace.size;
+                if (o2.marker) pass.marker = trace.marker;
+                if (o2.borderSize) pass.borderSize = trace.borderSize;
+                if (o2.borderColor) pass.borderColor = trace.borderColor;
+                if (o2.opacity) pass.opacity = trace.opacity;
+                if (o2.range) {
+                  pass.range = multirange ? getBox(trace.range, i22, j2) : trace.range || pass.bounds;
+                }
+                trace.passes.push(key);
+              }
+            }
+            return this;
+          };
+          SPLOM.prototype.draw = function(...args) {
+            if (!args.length) {
+              this.scatter.draw();
+            } else {
+              let idx = [];
+              for (let i2 = 0; i2 < args.length; i2++) {
+                if (typeof args[i2] === "number") {
+                  let { passes, passOffset } = this.traces[args[i2]];
+                  idx.push(...arrRange(passOffset, passOffset + passes.length));
+                } else if (args[i2].length) {
+                  let els = args[i2];
+                  let { passes, passOffset } = this.traces[i2];
+                  passes = passes.map((passId2, i22) => {
+                    idx[passOffset + i22] = els;
+                  });
+                }
+              }
+              this.scatter.draw(...idx);
+            }
+            return this;
+          };
+          SPLOM.prototype.destroy = function() {
+            this.traces.forEach((trace) => {
+              if (trace.buffer && trace.buffer.destroy) trace.buffer.destroy();
+            });
+            this.traces = null;
+            this.passes = null;
+            this.scatter.destroy();
+            return this;
+          };
+          function passId(trace, i2, j2) {
+            let id2 = trace.id != null ? trace.id : trace;
+            let n2 = i2;
+            let m2 = j2;
+            let key = id2 << 16 | (n2 & 255) << 8 | m2 & 255;
+            return key;
+          }
+          function getBox(items, i2, j2) {
+            let iloy, ihiy, jlox, jhix;
+            let iitem = items[i2], jitem = items[j2];
+            if (iitem.length > 2) {
+              iitem[0];
+              iitem[2];
+              iloy = iitem[1];
+              ihiy = iitem[3];
+            } else if (iitem.length) {
+              iloy = iitem[0];
+              ihiy = iitem[1];
+            } else {
+              iitem.x;
+              iloy = iitem.y;
+              iitem.x + iitem.width;
+              ihiy = iitem.y + iitem.height;
+            }
+            if (jitem.length > 2) {
+              jlox = jitem[0];
+              jhix = jitem[2];
+              jitem[1];
+              jitem[3];
+            } else if (jitem.length) {
+              jlox = jitem[0];
+              jhix = jitem[1];
+            } else {
+              jlox = jitem.x;
+              jitem.y;
+              jhix = jitem.x + jitem.width;
+              jitem.y + jitem.height;
+            }
+            return [jlox, iloy, jhix, ihiy];
+          }
+          function getPad(arg) {
+            if (typeof arg === "number") return [arg, arg, arg, arg];
+            else if (arg.length === 2) return [arg[0], arg[1], arg[0], arg[1]];
+            else {
+              let box = rect(arg);
+              return [box.x, box.y, box.x + box.width, box.y + box.height];
+            }
+          }
+        }
+      });
+      var require_plot20 = __commonJS({
+        "src/traces/splom/plot.js"(exports, module2) {
+          var createMatrix = require_regl_splom();
+          var Lib = require_lib();
+          var AxisIDs = require_axis_ids();
+          var selectMode = require_helpers5().selectMode;
+          module2.exports = function plot(gd2, _2, splomCalcData) {
+            if (!splomCalcData.length) return;
+            for (var i2 = 0; i2 < splomCalcData.length; i2++) {
+              plotOne(gd2, splomCalcData[i2][0]);
+            }
+          };
+          function plotOne(gd2, cd0) {
+            var fullLayout = gd2._fullLayout;
+            var gs = fullLayout._size;
+            var trace = cd0.trace;
+            var stash = cd0.t;
+            var scene = fullLayout._splomScenes[trace.uid];
+            var matrixOpts = scene.matrixOptions;
+            var cdata = matrixOpts.cdata;
+            var regl = fullLayout._glcanvas.data()[0].regl;
+            var dragmode = fullLayout.dragmode;
+            var xa, ya2;
+            var i2, j2, k2;
+            if (cdata.length === 0) return;
+            matrixOpts.lower = trace.showupperhalf;
+            matrixOpts.upper = trace.showlowerhalf;
+            matrixOpts.diagonal = trace.diagonal.visible;
+            var visibleDims = trace._visibleDims;
+            var visibleLength = cdata.length;
+            var viewOpts = scene.viewOpts = {};
+            viewOpts.ranges = new Array(visibleLength);
+            viewOpts.domains = new Array(visibleLength);
+            for (k2 = 0; k2 < visibleDims.length; k2++) {
+              i2 = visibleDims[k2];
+              var rng = viewOpts.ranges[k2] = new Array(4);
+              var dmn = viewOpts.domains[k2] = new Array(4);
+              xa = AxisIDs.getFromId(gd2, trace._diag[i2][0]);
+              if (xa) {
+                rng[0] = xa._rl[0];
+                rng[2] = xa._rl[1];
+                dmn[0] = xa.domain[0];
+                dmn[2] = xa.domain[1];
+              }
+              ya2 = AxisIDs.getFromId(gd2, trace._diag[i2][1]);
+              if (ya2) {
+                rng[1] = ya2._rl[0];
+                rng[3] = ya2._rl[1];
+                dmn[1] = ya2.domain[0];
+                dmn[3] = ya2.domain[1];
+              }
+            }
+            var plotGlPixelRatio = gd2._context.plotGlPixelRatio;
+            var l2 = gs.l * plotGlPixelRatio;
+            var b2 = gs.b * plotGlPixelRatio;
+            var w2 = gs.w * plotGlPixelRatio;
+            var h2 = gs.h * plotGlPixelRatio;
+            viewOpts.viewport = [l2, b2, w2 + l2, h2 + b2];
+            if (scene.matrix === true) {
+              scene.matrix = createMatrix(regl);
+            }
+            var clickSelectEnabled = fullLayout.clickmode.indexOf("select") > -1;
+            var isSelectMode = selectMode(dragmode) || !!trace.selectedpoints || clickSelectEnabled;
+            var needsBaseUpdate = true;
+            if (isSelectMode) {
+              var commonLength = trace._length;
+              if (trace.selectedpoints) {
+                scene.selectBatch = trace.selectedpoints;
+                var selPts = trace.selectedpoints;
+                var selDict = {};
+                for (i2 = 0; i2 < selPts.length; i2++) {
+                  selDict[selPts[i2]] = true;
+                }
+                var unselPts = [];
+                for (i2 = 0; i2 < commonLength; i2++) {
+                  if (!selDict[i2]) unselPts.push(i2);
+                }
+                scene.unselectBatch = unselPts;
+              }
+              var xpx = stash.xpx = new Array(visibleLength);
+              var ypx = stash.ypx = new Array(visibleLength);
+              for (k2 = 0; k2 < visibleDims.length; k2++) {
+                i2 = visibleDims[k2];
+                xa = AxisIDs.getFromId(gd2, trace._diag[i2][0]);
+                if (xa) {
+                  xpx[k2] = new Array(commonLength);
+                  for (j2 = 0; j2 < commonLength; j2++) {
+                    xpx[k2][j2] = xa.c2p(cdata[k2][j2]);
+                  }
+                }
+                ya2 = AxisIDs.getFromId(gd2, trace._diag[i2][1]);
+                if (ya2) {
+                  ypx[k2] = new Array(commonLength);
+                  for (j2 = 0; j2 < commonLength; j2++) {
+                    ypx[k2][j2] = ya2.c2p(cdata[k2][j2]);
+                  }
+                }
+              }
+              if (scene.selectBatch.length || scene.unselectBatch.length) {
+                var unselOpts = Lib.extendFlat({}, matrixOpts, scene.unselectedOptions, viewOpts);
+                var selOpts = Lib.extendFlat({}, matrixOpts, scene.selectedOptions, viewOpts);
+                scene.matrix.update(unselOpts, selOpts);
+                needsBaseUpdate = false;
+              }
+            } else {
+              stash.xpx = stash.ypx = null;
+            }
+            if (needsBaseUpdate) {
+              var opts = Lib.extendFlat({}, matrixOpts, viewOpts);
+              scene.matrix.update(opts, null);
+            }
+          }
+        }
+      });
+      var require_helpers17 = __commonJS({
+        "src/traces/splom/helpers.js"(exports) {
+          exports.getDimIndex = function getDimIndex(trace, ax) {
+            var axId = ax._id;
+            var axLetter = axId.charAt(0);
+            var ind = { x: 0, y: 1 }[axLetter];
+            var visibleDims = trace._visibleDims;
+            for (var k2 = 0; k2 < visibleDims.length; k2++) {
+              var i2 = visibleDims[k2];
+              if (trace._diag[i2][ind] === axId) return k2;
+            }
+            return false;
+          };
+        }
+      });
+      var require_hover17 = __commonJS({
+        "src/traces/splom/hover.js"(exports, module2) {
+          var helpers = require_helpers17();
+          var calcHover = require_hover16().calcHover;
+          var getFromId = require_axes().getFromId;
+          var extendFlat = require_extend().extendFlat;
+          function hoverPoints(pointData, xval, yval, hovermode, opts) {
+            if (!opts) opts = {};
+            var hovermodeHasX = (hovermode || "").charAt(0) === "x";
+            var hovermodeHasY = (hovermode || "").charAt(0) === "y";
+            var points = _hoverPoints(pointData, xval, yval);
+            if ((hovermodeHasX || hovermodeHasY) && opts.hoversubplots === "axis" && points[0]) {
+              var subplotsWith = (hovermodeHasX ? pointData.xa : pointData.ya)._subplotsWith;
+              var gd2 = opts.gd;
+              var _pointData = extendFlat({}, pointData);
+              for (var i2 = 0; i2 < subplotsWith.length; i2++) {
+                var spId = subplotsWith[i2];
+                if (spId === pointData.xa._id + pointData.ya._id) continue;
+                if (hovermodeHasY) {
+                  _pointData.xa = getFromId(gd2, spId, "x");
+                } else {
+                  _pointData.ya = getFromId(gd2, spId, "y");
+                }
+                var axisHoversubplots = hovermodeHasX || hovermodeHasY;
+                var newPoints = _hoverPoints(_pointData, xval, yval, axisHoversubplots);
+                points = points.concat(newPoints);
+              }
+            }
+            return points;
+          }
+          function _hoverPoints(pointData, xval, yval, axisHoversubplots) {
+            var cd2 = pointData.cd;
+            var trace = cd2[0].trace;
+            var scene = pointData.scene;
+            var cdata = scene.matrixOptions.cdata;
+            var xa = pointData.xa;
+            var ya2 = pointData.ya;
+            var xpx = xa.c2p(xval);
+            var ypx = ya2.c2p(yval);
+            var maxDistance = pointData.distance;
+            var xi2 = helpers.getDimIndex(trace, xa);
+            var yi2 = helpers.getDimIndex(trace, ya2);
+            if (xi2 === false || yi2 === false) return [pointData];
+            var x2 = cdata[xi2];
+            var y2 = cdata[yi2];
+            var id2, dxy;
+            var minDist = maxDistance;
+            for (var i2 = 0; i2 < x2.length; i2++) {
+              if (axisHoversubplots && i2 !== pointData.index) continue;
+              var ptx = x2[i2];
+              var pty = y2[i2];
+              var dx = xa.c2p(ptx) - xpx;
+              var dy = ya2.c2p(pty) - ypx;
+              var dist = Math.sqrt(dx * dx + dy * dy);
+              if (axisHoversubplots || dist < minDist) {
+                minDist = dxy = dist;
+                id2 = i2;
+              }
+            }
+            pointData.index = id2;
+            pointData.distance = minDist;
+            pointData.dxy = dxy;
+            if (id2 === void 0) return [pointData];
+            return [calcHover(pointData, x2, y2, trace)];
+          }
+          module2.exports = {
+            hoverPoints
+          };
+        }
+      });
+      var require_select8 = __commonJS({
+        "src/traces/splom/select.js"(exports, module2) {
+          var Lib = require_lib();
+          var pushUnique = Lib.pushUnique;
+          var subTypes = require_subtypes();
+          var helpers = require_helpers17();
+          module2.exports = function select(searchInfo, selectionTester) {
+            var cd2 = searchInfo.cd;
+            var trace = cd2[0].trace;
+            var stash = cd2[0].t;
+            var scene = searchInfo.scene;
+            var cdata = scene.matrixOptions.cdata;
+            var xa = searchInfo.xaxis;
+            var ya2 = searchInfo.yaxis;
+            var selection = [];
+            if (!scene) return selection;
+            var hasOnlyLines = !subTypes.hasMarkers(trace) && !subTypes.hasText(trace);
+            if (trace.visible !== true || hasOnlyLines) return selection;
+            var xi2 = helpers.getDimIndex(trace, xa);
+            var yi2 = helpers.getDimIndex(trace, ya2);
+            if (xi2 === false || yi2 === false) return selection;
+            var xpx = stash.xpx[xi2];
+            var ypx = stash.ypx[yi2];
+            var x2 = cdata[xi2];
+            var y2 = cdata[yi2];
+            var els = (searchInfo.scene.selectBatch || []).slice();
+            var unels = [];
+            if (selectionTester !== false && !selectionTester.degenerate) {
+              for (var i2 = 0; i2 < x2.length; i2++) {
+                if (selectionTester.contains([xpx[i2], ypx[i2]], null, i2, searchInfo)) {
+                  selection.push({
+                    pointNumber: i2,
+                    x: x2[i2],
+                    y: y2[i2]
+                  });
+                  pushUnique(els, i2);
+                } else if (els.indexOf(i2) !== -1) {
+                  pushUnique(els, i2);
+                } else {
+                  unels.push(i2);
+                }
+              }
+            }
+            var matrixOpts = scene.matrixOptions;
+            if (!els.length && !unels.length) {
+              scene.matrix.update(matrixOpts, null);
+            } else if (!scene.selectBatch.length && !scene.unselectBatch.length) {
+              scene.matrix.update(
+                scene.unselectedOptions,
+                Lib.extendFlat({}, matrixOpts, scene.selectedOptions, scene.viewOpts)
+              );
+            }
+            scene.selectBatch = els;
+            scene.unselectBatch = unels;
+            return selection;
+          };
+        }
+      });
+      var require_edit_style2 = __commonJS({
+        "src/traces/splom/edit_style.js"(exports, module2) {
+          var Lib = require_lib();
+          var calcColorscale = require_colorscale_calc();
+          var convertMarkerStyle = require_convert10().markerStyle;
+          module2.exports = function editStyle(gd2, cd0) {
+            var trace = cd0.trace;
+            var scene = gd2._fullLayout._splomScenes[trace.uid];
+            if (scene) {
+              calcColorscale(gd2, trace);
+              Lib.extendFlat(scene.matrixOptions, convertMarkerStyle(gd2, trace));
+              var opts = Lib.extendFlat({}, scene.matrixOptions, scene.viewOpts);
+              scene.matrix.update(opts, null);
+            }
+          };
+        }
+      });
+      var require_base_index2 = __commonJS({
+        "src/traces/splom/base_index.js"(exports, module2) {
+          var Registry = require_registry();
+          var Grid = require_grid();
+          module2.exports = {
+            moduleType: "trace",
+            name: "splom",
+            categories: ["gl", "regl", "cartesian", "symbols", "showLegend", "scatter-like"],
+            attributes: require_attributes51(),
+            supplyDefaults: require_defaults47(),
+            colorbar: require_marker_colorbar(),
+            calc: require_calc30(),
+            plot: require_plot20(),
+            hoverPoints: require_hover17().hoverPoints,
+            selectPoints: require_select8(),
+            editStyle: require_edit_style2(),
+            meta: {}
+          };
+          Registry.register(Grid);
+        }
+      });
+      var require_base_plot6 = __commonJS({
+        "src/traces/splom/base_plot.js"(exports, module2) {
+          var createLine = require_regl_line2d();
+          var Registry = require_registry();
+          var prepareRegl = require_prepare_regl();
+          var getModuleCalcData = require_get_data().getModuleCalcData;
+          var Cartesian = require_cartesian();
+          var getFromId = require_axis_ids().getFromId;
+          var shouldShowZeroLine = require_axes().shouldShowZeroLine;
+          var SPLOM = "splom";
+          var reglPrecompiled = {};
+          function plot(gd2) {
+            var fullLayout = gd2._fullLayout;
+            var _module = Registry.getModule(SPLOM);
+            var splomCalcData = getModuleCalcData(gd2.calcdata, _module)[0];
+            var success = prepareRegl(gd2, ["ANGLE_instanced_arrays", "OES_element_index_uint"], reglPrecompiled);
+            if (!success) return;
+            if (fullLayout._hasOnlyLargeSploms) {
+              updateGrid(gd2);
+            }
+            _module.plot(gd2, {}, splomCalcData);
+          }
+          function drag(gd2) {
+            var cd2 = gd2.calcdata;
+            var fullLayout = gd2._fullLayout;
+            if (fullLayout._hasOnlyLargeSploms) {
+              updateGrid(gd2);
+            }
+            for (var i2 = 0; i2 < cd2.length; i2++) {
+              var cd0 = cd2[i2][0];
+              var trace = cd0.trace;
+              var scene = fullLayout._splomScenes[trace.uid];
+              if (trace.type === "splom" && scene && scene.matrix) {
+                dragOne(gd2, trace, scene);
+              }
+            }
+          }
+          function dragOne(gd2, trace, scene) {
+            var visibleLength = scene.matrixOptions.data.length;
+            var visibleDims = trace._visibleDims;
+            var ranges = scene.viewOpts.ranges = new Array(visibleLength);
+            for (var k2 = 0; k2 < visibleDims.length; k2++) {
+              var i2 = visibleDims[k2];
+              var rng = ranges[k2] = new Array(4);
+              var xa = getFromId(gd2, trace._diag[i2][0]);
+              if (xa) {
+                rng[0] = xa.r2l(xa.range[0]);
+                rng[2] = xa.r2l(xa.range[1]);
+              }
+              var ya2 = getFromId(gd2, trace._diag[i2][1]);
+              if (ya2) {
+                rng[1] = ya2.r2l(ya2.range[0]);
+                rng[3] = ya2.r2l(ya2.range[1]);
+              }
+            }
+            if (scene.selectBatch.length || scene.unselectBatch.length) {
+              scene.matrix.update({ ranges }, { ranges });
+            } else {
+              scene.matrix.update({ ranges });
+            }
+          }
+          function updateGrid(gd2) {
+            var fullLayout = gd2._fullLayout;
+            var regl = fullLayout._glcanvas.data()[0].regl;
+            var splomGrid = fullLayout._splomGrid;
+            if (!splomGrid) {
+              splomGrid = fullLayout._splomGrid = createLine(regl);
+            }
+            splomGrid.update(makeGridData(gd2));
+          }
+          function makeGridData(gd2) {
+            var plotGlPixelRatio = gd2._context.plotGlPixelRatio;
+            var fullLayout = gd2._fullLayout;
+            var gs = fullLayout._size;
+            var fullView = [
+              0,
+              0,
+              fullLayout.width * plotGlPixelRatio,
+              fullLayout.height * plotGlPixelRatio
+            ];
+            var lookup = {};
+            var k2;
+            function push(prefix, ax, x0, x1, y0, y1) {
+              x0 *= plotGlPixelRatio;
+              x1 *= plotGlPixelRatio;
+              y0 *= plotGlPixelRatio;
+              y1 *= plotGlPixelRatio;
+              var lcolor = ax[prefix + "color"];
+              var lwidth = ax[prefix + "width"];
+              var key = String(lcolor + lwidth);
+              if (key in lookup) {
+                lookup[key].data.push(NaN, NaN, x0, x1, y0, y1);
+              } else {
+                lookup[key] = {
+                  data: [x0, x1, y0, y1],
+                  join: "rect",
+                  thickness: lwidth * plotGlPixelRatio,
+                  color: lcolor,
+                  viewport: fullView,
+                  range: fullView,
+                  overlay: false
+                };
+              }
+            }
+            for (k2 in fullLayout._splomSubplots) {
+              var sp = fullLayout._plots[k2];
+              var xa = sp.xaxis;
+              var ya2 = sp.yaxis;
+              var xVals = xa._gridVals;
+              var yVals = ya2._gridVals;
+              var xOffset = xa._offset;
+              var xLength = xa._length;
+              var yLength = ya2._length;
+              var yOffset = gs.b + ya2.domain[0] * gs.h;
+              var ym = -ya2._m;
+              var yb2 = -ym * ya2.r2l(ya2.range[0], ya2.calendar);
+              var x2, y2;
+              if (xa.showgrid) {
+                for (k2 = 0; k2 < xVals.length; k2++) {
+                  x2 = xOffset + xa.l2p(xVals[k2].x);
+                  push("grid", xa, x2, yOffset, x2, yOffset + yLength);
+                }
+              }
+              if (ya2.showgrid) {
+                for (k2 = 0; k2 < yVals.length; k2++) {
+                  y2 = yOffset + yb2 + ym * yVals[k2].x;
+                  push("grid", ya2, xOffset, y2, xOffset + xLength, y2);
+                }
+              }
+              if (shouldShowZeroLine(gd2, xa, ya2)) {
+                x2 = xOffset + xa.l2p(0);
+                push("zeroline", xa, x2, yOffset, x2, yOffset + yLength);
+              }
+              if (shouldShowZeroLine(gd2, ya2, xa)) {
+                y2 = yOffset + yb2 + 0;
+                push("zeroline", ya2, xOffset, y2, xOffset + xLength, y2);
+              }
+            }
+            var gridBatches = [];
+            for (k2 in lookup) {
+              gridBatches.push(lookup[k2]);
+            }
+            return gridBatches;
+          }
+          function clean(newFullData, newFullLayout, oldFullData, oldFullLayout) {
+            var lookup = {};
+            var i2;
+            if (oldFullLayout._splomScenes) {
+              for (i2 = 0; i2 < newFullData.length; i2++) {
+                var newTrace = newFullData[i2];
+                if (newTrace.type === "splom") {
+                  lookup[newTrace.uid] = 1;
+                }
+              }
+              for (i2 = 0; i2 < oldFullData.length; i2++) {
+                var oldTrace = oldFullData[i2];
+                if (!lookup[oldTrace.uid]) {
+                  var scene = oldFullLayout._splomScenes[oldTrace.uid];
+                  if (scene && scene.destroy) scene.destroy();
+                  oldFullLayout._splomScenes[oldTrace.uid] = null;
+                  delete oldFullLayout._splomScenes[oldTrace.uid];
+                }
+              }
+            }
+            if (Object.keys(oldFullLayout._splomScenes || {}).length === 0) {
+              delete oldFullLayout._splomScenes;
+            }
+            if (oldFullLayout._splomGrid && (!newFullLayout._hasOnlyLargeSploms && oldFullLayout._hasOnlyLargeSploms)) {
+              oldFullLayout._splomGrid.destroy();
+              oldFullLayout._splomGrid = null;
+              delete oldFullLayout._splomGrid;
+            }
+            Cartesian.clean(newFullData, newFullLayout, oldFullData, oldFullLayout);
+          }
+          module2.exports = {
+            name: SPLOM,
+            attr: Cartesian.attr,
+            attrRegex: Cartesian.attrRegex,
+            layoutAttributes: Cartesian.layoutAttributes,
+            supplyLayoutDefaults: Cartesian.supplyLayoutDefaults,
+            drawFramework: Cartesian.drawFramework,
+            plot,
+            drag,
+            updateGrid,
+            clean,
+            updateFx: Cartesian.updateFx,
+            toSVG: Cartesian.toSVG,
+            reglPrecompiled
+          };
+        }
+      });
+      var require_splom = __commonJS({
+        "src/traces/splom/index.js"(exports, module2) {
+          var index = require_base_index2();
+          index.basePlotModule = require_base_plot6(), module2.exports = index;
+        }
+      });
+      var require_splom2 = __commonJS({
+        "lib/splom.js"(exports, module2) {
+          module2.exports = require_splom();
+        }
+      });
+      var require_attributes52 = __commonJS({
+        "src/traces/parcoords/attributes.js"(exports, module2) {
+          var colorScaleAttrs = require_attributes8();
+          var axesAttrs = require_layout_attributes4();
+          var fontAttrs = require_font_attributes();
+          var domainAttrs = require_domain().attributes;
+          var extendFlat = require_extend().extendFlat;
+          var templatedArray = require_plot_template().templatedArray;
+          module2.exports = {
+            domain: domainAttrs({ name: "parcoords", trace: true, editType: "plot" }),
+            labelangle: {
+              valType: "angle",
+              dflt: 0,
+              editType: "plot"
+            },
+            labelside: {
+              valType: "enumerated",
+              values: ["top", "bottom"],
+              dflt: "top",
+              editType: "plot"
+            },
+            labelfont: fontAttrs({
+              editType: "plot"
+            }),
+            tickfont: fontAttrs({
+              autoShadowDflt: true,
+              editType: "plot"
+            }),
+            rangefont: fontAttrs({
+              editType: "plot"
+            }),
+            dimensions: templatedArray("dimension", {
+              label: {
+                valType: "string",
+                editType: "plot"
+              },
+              // TODO: better way to determine ordinal vs continuous axes,
+              // so users can use tickvals/ticktext with a continuous axis.
+              tickvals: extendFlat({}, axesAttrs.tickvals, {
+                editType: "plot"
+              }),
+              ticktext: extendFlat({}, axesAttrs.ticktext, {
+                editType: "plot"
+              }),
+              tickformat: extendFlat({}, axesAttrs.tickformat, {
+                editType: "plot"
+              }),
+              visible: {
+                valType: "boolean",
+                dflt: true,
+                editType: "plot"
+              },
+              range: {
+                valType: "info_array",
+                items: [
+                  { valType: "number", editType: "plot" },
+                  { valType: "number", editType: "plot" }
+                ],
+                editType: "plot"
+              },
+              constraintrange: {
+                valType: "info_array",
+                freeLength: true,
+                dimensions: "1-2",
+                items: [
+                  { valType: "any", editType: "plot" },
+                  { valType: "any", editType: "plot" }
+                ],
+                editType: "plot"
+              },
+              multiselect: {
+                valType: "boolean",
+                dflt: true,
+                editType: "plot"
+              },
+              values: {
+                valType: "data_array",
+                editType: "calc"
+              },
+              editType: "calc"
+            }),
+            line: extendFlat(
+              { editType: "calc" },
+              colorScaleAttrs("line", {
+                // the default autocolorscale isn't quite usable for parcoords due to context ambiguity around 0 (grey, off-white)
+                // autocolorscale therefore defaults to false too, to avoid being overridden by the blue-white-red autocolor palette
+                colorscaleDflt: "Viridis",
+                autoColorDflt: false,
+                editTypeOverride: "calc"
+              })
+            ),
+            unselected: {
+              line: {
+                color: {
+                  valType: "color",
+                  dflt: "#7f7f7f",
+                  editType: "plot"
+                },
+                opacity: {
+                  valType: "number",
+                  min: 0,
+                  max: 1,
+                  dflt: "auto",
+                  editType: "plot"
+                },
+                editType: "plot"
+              },
+              editType: "plot"
+            }
+          };
+        }
+      });
+      var require_constants24 = __commonJS({
+        "src/traces/parcoords/constants.js"(exports, module2) {
+          module2.exports = {
+            maxDimensionCount: 60,
+            // this cannot be increased without WebGL code refactoring
+            overdrag: 45,
+            verticalPadding: 2,
+            // otherwise, horizontal lines on top or bottom are of lower width
+            tickDistance: 50,
+            canvasPixelRatio: 1,
+            blockLineCount: 5e3,
+            layers: ["contextLineLayer", "focusLineLayer", "pickLineLayer"],
+            axisTitleOffset: 28,
+            axisExtentOffset: 10,
+            bar: {
+              width: 4,
+              // Visible width of the filter bar
+              captureWidth: 10,
+              // Mouse-sensitive width for interaction (Fitts law)
+              fillColor: "magenta",
+              // Color of the filter bar fill
+              fillOpacity: 1,
+              // Filter bar fill opacity
+              snapDuration: 150,
+              // tween duration in ms for brush snap for ordinal axes
+              snapRatio: 0.25,
+              // ratio of bar extension relative to the distance between two adjacent ordinal values
+              snapClose: 0.01,
+              // fraction of inter-value distance to snap to the closer one, even if you're not over it
+              strokeOpacity: 1,
+              // Filter bar side stroke opacity
+              strokeWidth: 1,
+              // Filter bar side stroke width in pixels
+              handleHeight: 8,
+              // Height of the filter bar vertical resize areas on top and bottom
+              handleOpacity: 1,
+              // Opacity of the filter bar vertical resize areas on top and bottom
+              handleOverlap: 0
+              // A larger than 0 value causes overlaps with the filter bar, represented as pixels
+            },
+            cn: {
+              axisExtentText: "axis-extent-text",
+              parcoordsLineLayers: "parcoords-line-layers",
+              parcoordsLineLayer: "parcoords-lines",
+              parcoords: "parcoords",
+              parcoordsControlView: "parcoords-control-view",
+              yAxis: "y-axis",
+              axisOverlays: "axis-overlays",
+              axis: "axis",
+              axisHeading: "axis-heading",
+              axisTitle: "axis-title",
+              axisExtent: "axis-extent",
+              axisExtentTop: "axis-extent-top",
+              axisExtentTopText: "axis-extent-top-text",
+              axisExtentBottom: "axis-extent-bottom",
+              axisExtentBottomText: "axis-extent-bottom-text",
+              axisBrush: "axis-brush"
+            },
+            id: {
+              filterBarPattern: "filter-bar-pattern"
+            }
+          };
+        }
+      });
+      var require_gup = __commonJS({
+        "src/lib/gup.js"(exports, module2) {
+          var identity22 = require_identity2();
+          function wrap(d2) {
+            return [d2];
+          }
+          module2.exports = {
+            // The D3 data binding concept and the General Update Pattern promotes the idea of
+            // traversing into the scenegraph by using the `.data(fun, keyFun)` call.
+            // The `fun` is most often a `repeat`, ie. the elements beneath a `<g>` element need
+            // access to the same data, or a `descend`, which fans a scenegraph node into a bunch of
+            // of elements, e.g. points, lines, rows, requiring an array as input.
+            // The role of the `keyFun` is to identify what elements are being entered/exited/updated,
+            // otherwise D3 reverts to using a plain index which would screw up `transition`s.
+            keyFun: function(d2) {
+              return d2.key;
+            },
+            repeat: wrap,
+            descend: identity22,
+            // Plotly.js uses a convention of storing the actual contents of the `calcData` as the
+            // element zero of a container array. These helpers are just used for clarity as a
+            // newcomer to the codebase may not know what the `[0]` is, and whether there can be further
+            // elements (not atm).
+            wrap,
+            unwrap: function(d2) {
+              return d2[0];
+            }
+          };
+        }
+      });
+      var require_axisbrush = __commonJS({
+        "src/traces/parcoords/axisbrush.js"(exports, module2) {
+          var c2 = require_constants24();
+          var d3 = require_d3();
+          var keyFun = require_gup().keyFun;
+          var repeat = require_gup().repeat;
+          var sortAsc = require_lib().sorterAsc;
+          var strTranslate = require_lib().strTranslate;
+          var snapRatio = c2.bar.snapRatio;
+          function snapOvershoot(v2, vAdjacent) {
+            return v2 * (1 - snapRatio) + vAdjacent * snapRatio;
+          }
+          var snapClose = c2.bar.snapClose;
+          function closeToCovering(v2, vAdjacent) {
+            return v2 * (1 - snapClose) + vAdjacent * snapClose;
+          }
+          function ordinalScaleSnap(isHigh, a2, v2, existingRanges) {
+            if (overlappingExisting(v2, existingRanges)) return v2;
+            var dir = isHigh ? -1 : 1;
+            var first = 0;
+            var last = a2.length - 1;
+            if (dir < 0) {
+              var tmp2 = first;
+              first = last;
+              last = tmp2;
+            }
+            var aHere = a2[first];
+            var aPrev = aHere;
+            for (var i2 = first; dir * i2 < dir * last; i2 += dir) {
+              var nextI = i2 + dir;
+              var aNext = a2[nextI];
+              if (dir * v2 < dir * closeToCovering(aHere, aNext)) return snapOvershoot(aHere, aPrev);
+              if (dir * v2 < dir * aNext || nextI === last) return snapOvershoot(aNext, aHere);
+              aPrev = aHere;
+              aHere = aNext;
+            }
+          }
+          function overlappingExisting(v2, existingRanges) {
+            for (var i2 = 0; i2 < existingRanges.length; i2++) {
+              if (v2 >= existingRanges[i2][0] && v2 <= existingRanges[i2][1]) return true;
+            }
+            return false;
+          }
+          function barHorizontalSetup(selection) {
+            selection.attr("x", -c2.bar.captureWidth / 2).attr("width", c2.bar.captureWidth);
+          }
+          function backgroundBarHorizontalSetup(selection) {
+            selection.attr("visibility", "visible").style("visibility", "visible").attr("fill", "yellow").attr("opacity", 0);
+          }
+          function setHighlight(d2) {
+            if (!d2.brush.filterSpecified) {
+              return "0," + d2.height;
+            }
+            var pixelRanges = unitToPx(d2.brush.filter.getConsolidated(), d2.height);
+            var dashArray = [0];
+            var p2, sectionHeight, iNext;
+            var currentGap = pixelRanges.length ? pixelRanges[0][0] : null;
+            for (var i2 = 0; i2 < pixelRanges.length; i2++) {
+              p2 = pixelRanges[i2];
+              sectionHeight = p2[1] - p2[0];
+              dashArray.push(currentGap);
+              dashArray.push(sectionHeight);
+              iNext = i2 + 1;
+              if (iNext < pixelRanges.length) {
+                currentGap = pixelRanges[iNext][0] - p2[1];
+              }
+            }
+            dashArray.push(d2.height);
+            return dashArray;
+          }
+          function unitToPx(unitRanges, height) {
+            return unitRanges.map(function(pr) {
+              return pr.map(function(v2) {
+                return Math.max(0, v2 * height);
+              }).sort(sortAsc);
+            });
+          }
+          function getRegion(fPix, y2) {
+            var pad = c2.bar.handleHeight;
+            if (y2 > fPix[1] + pad || y2 < fPix[0] - pad) return;
+            if (y2 >= 0.9 * fPix[1] + 0.1 * fPix[0]) return "n";
+            if (y2 <= 0.9 * fPix[0] + 0.1 * fPix[1]) return "s";
+            return "ns";
+          }
+          function clearCursor() {
+            d3.select(document.body).style("cursor", null);
+          }
+          function styleHighlight(selection) {
+            selection.attr("stroke-dasharray", setHighlight);
+          }
+          function renderHighlight(root, tweenCallback) {
+            var bar = d3.select(root).selectAll(".highlight, .highlight-shadow");
+            var barToStyle = tweenCallback ? bar.transition().duration(c2.bar.snapDuration).each("end", tweenCallback) : bar;
+            styleHighlight(barToStyle);
+          }
+          function getInterval2(d2, y2) {
+            var b2 = d2.brush;
+            var active = b2.filterSpecified;
+            var closestInterval = NaN;
+            var out = {};
+            var i2;
+            if (active) {
+              var height = d2.height;
+              var intervals = b2.filter.getConsolidated();
+              var pixIntervals = unitToPx(intervals, height);
+              var hoveredInterval = NaN;
+              var previousInterval = NaN;
+              var nextInterval = NaN;
+              for (i2 = 0; i2 <= pixIntervals.length; i2++) {
+                var p2 = pixIntervals[i2];
+                if (p2 && p2[0] <= y2 && y2 <= p2[1]) {
+                  hoveredInterval = i2;
+                  break;
+                } else {
+                  previousInterval = i2 ? i2 - 1 : NaN;
+                  if (p2 && p2[0] > y2) {
+                    nextInterval = i2;
+                    break;
+                  }
+                }
+              }
+              closestInterval = hoveredInterval;
+              if (isNaN(closestInterval)) {
+                if (isNaN(previousInterval) || isNaN(nextInterval)) {
+                  closestInterval = isNaN(previousInterval) ? nextInterval : previousInterval;
+                } else {
+                  closestInterval = y2 - pixIntervals[previousInterval][1] < pixIntervals[nextInterval][0] - y2 ? previousInterval : nextInterval;
+                }
+              }
+              if (!isNaN(closestInterval)) {
+                var fPix = pixIntervals[closestInterval];
+                var region = getRegion(fPix, y2);
+                if (region) {
+                  out.interval = intervals[closestInterval];
+                  out.intervalPix = fPix;
+                  out.region = region;
+                }
+              }
+            }
+            if (d2.ordinal && !out.region) {
+              var a2 = d2.unitTickvals;
+              var unitLocation = d2.unitToPaddedPx.invert(y2);
+              for (i2 = 0; i2 < a2.length; i2++) {
+                var rangei = [
+                  a2[Math.max(i2 - 1, 0)] * 0.25 + a2[i2] * 0.75,
+                  a2[Math.min(i2 + 1, a2.length - 1)] * 0.25 + a2[i2] * 0.75
+                ];
+                if (unitLocation >= rangei[0] && unitLocation <= rangei[1]) {
+                  out.clickableOrdinalRange = rangei;
+                  break;
+                }
+              }
+            }
+            return out;
+          }
+          function dragstart(lThis, d2) {
+            d3.event.sourceEvent.stopPropagation();
+            var y2 = d2.height - d3.mouse(lThis)[1] - 2 * c2.verticalPadding;
+            var unitLocation = d2.unitToPaddedPx.invert(y2);
+            var b2 = d2.brush;
+            var interval = getInterval2(d2, y2);
+            var unitRange = interval.interval;
+            var s2 = b2.svgBrush;
+            s2.wasDragged = false;
+            s2.grabbingBar = interval.region === "ns";
+            if (s2.grabbingBar) {
+              var pixelRange = unitRange.map(d2.unitToPaddedPx);
+              s2.grabPoint = y2 - pixelRange[0] - c2.verticalPadding;
+              s2.barLength = pixelRange[1] - pixelRange[0];
+            }
+            s2.clickableOrdinalRange = interval.clickableOrdinalRange;
+            s2.stayingIntervals = d2.multiselect && b2.filterSpecified ? b2.filter.getConsolidated() : [];
+            if (unitRange) {
+              s2.stayingIntervals = s2.stayingIntervals.filter(function(int2) {
+                return int2[0] !== unitRange[0] && int2[1] !== unitRange[1];
+              });
+            }
+            s2.startExtent = interval.region ? unitRange[interval.region === "s" ? 1 : 0] : unitLocation;
+            d2.parent.inBrushDrag = true;
+            s2.brushStartCallback();
+          }
+          function drag(lThis, d2) {
+            d3.event.sourceEvent.stopPropagation();
+            var y2 = d2.height - d3.mouse(lThis)[1] - 2 * c2.verticalPadding;
+            var s2 = d2.brush.svgBrush;
+            s2.wasDragged = true;
+            s2._dragging = true;
+            if (s2.grabbingBar) {
+              s2.newExtent = [y2 - s2.grabPoint, y2 + s2.barLength - s2.grabPoint].map(d2.unitToPaddedPx.invert);
+            } else {
+              s2.newExtent = [s2.startExtent, d2.unitToPaddedPx.invert(y2)].sort(sortAsc);
+            }
+            d2.brush.filterSpecified = true;
+            s2.extent = s2.stayingIntervals.concat([s2.newExtent]);
+            s2.brushCallback(d2);
+            renderHighlight(lThis.parentNode);
+          }
+          function dragend(lThis, d2) {
+            var brush = d2.brush;
+            var filter = brush.filter;
+            var s2 = brush.svgBrush;
+            if (!s2._dragging) {
+              mousemove(lThis, d2);
+              drag(lThis, d2);
+              d2.brush.svgBrush.wasDragged = false;
+            }
+            s2._dragging = false;
+            var e2 = d3.event;
+            e2.sourceEvent.stopPropagation();
+            var grabbingBar = s2.grabbingBar;
+            s2.grabbingBar = false;
+            s2.grabLocation = void 0;
+            d2.parent.inBrushDrag = false;
+            clearCursor();
+            if (!s2.wasDragged) {
+              s2.wasDragged = void 0;
+              if (s2.clickableOrdinalRange) {
+                if (brush.filterSpecified && d2.multiselect) {
+                  s2.extent.push(s2.clickableOrdinalRange);
+                } else {
+                  s2.extent = [s2.clickableOrdinalRange];
+                  brush.filterSpecified = true;
+                }
+              } else if (grabbingBar) {
+                s2.extent = s2.stayingIntervals;
+                if (s2.extent.length === 0) {
+                  brushClear(brush);
+                }
+              } else {
+                brushClear(brush);
+              }
+              s2.brushCallback(d2);
+              renderHighlight(lThis.parentNode);
+              s2.brushEndCallback(brush.filterSpecified ? filter.getConsolidated() : []);
+              return;
+            }
+            var mergeIntervals = function() {
+              filter.set(filter.getConsolidated());
+            };
+            if (d2.ordinal) {
+              var a2 = d2.unitTickvals;
+              if (a2[a2.length - 1] < a2[0]) a2.reverse();
+              s2.newExtent = [
+                ordinalScaleSnap(0, a2, s2.newExtent[0], s2.stayingIntervals),
+                ordinalScaleSnap(1, a2, s2.newExtent[1], s2.stayingIntervals)
+              ];
+              var hasNewExtent = s2.newExtent[1] > s2.newExtent[0];
+              s2.extent = s2.stayingIntervals.concat(hasNewExtent ? [s2.newExtent] : []);
+              if (!s2.extent.length) {
+                brushClear(brush);
+              }
+              s2.brushCallback(d2);
+              if (hasNewExtent) {
+                renderHighlight(lThis.parentNode, mergeIntervals);
+              } else {
+                mergeIntervals();
+                renderHighlight(lThis.parentNode);
+              }
+            } else {
+              mergeIntervals();
+            }
+            s2.brushEndCallback(brush.filterSpecified ? filter.getConsolidated() : []);
+          }
+          function mousemove(lThis, d2) {
+            var y2 = d2.height - d3.mouse(lThis)[1] - 2 * c2.verticalPadding;
+            var interval = getInterval2(d2, y2);
+            var cursor = "crosshair";
+            if (interval.clickableOrdinalRange) cursor = "pointer";
+            else if (interval.region) cursor = interval.region + "-resize";
+            d3.select(document.body).style("cursor", cursor);
+          }
+          function attachDragBehavior(selection) {
+            selection.on("mousemove", function(d2) {
+              d3.event.preventDefault();
+              if (!d2.parent.inBrushDrag) mousemove(this, d2);
+            }).on("mouseleave", function(d2) {
+              if (!d2.parent.inBrushDrag) clearCursor();
+            }).call(
+              d3.behavior.drag().on("dragstart", function(d2) {
+                dragstart(this, d2);
+              }).on("drag", function(d2) {
+                drag(this, d2);
+              }).on("dragend", function(d2) {
+                dragend(this, d2);
+              })
+            );
+          }
+          function startAsc(a2, b2) {
+            return a2[0] - b2[0];
+          }
+          function renderAxisBrush(axisBrush, paperColor, gd2) {
+            var isStatic = gd2._context.staticPlot;
+            var background = axisBrush.selectAll(".background").data(repeat);
+            background.enter().append("rect").classed("background", true).call(barHorizontalSetup).call(backgroundBarHorizontalSetup).style("pointer-events", isStatic ? "none" : "auto").attr("transform", strTranslate(0, c2.verticalPadding));
+            background.call(attachDragBehavior).attr("height", function(d2) {
+              return d2.height - c2.verticalPadding;
+            });
+            var highlightShadow = axisBrush.selectAll(".highlight-shadow").data(repeat);
+            highlightShadow.enter().append("line").classed("highlight-shadow", true).attr("x", -c2.bar.width / 2).attr("stroke-width", c2.bar.width + c2.bar.strokeWidth).attr("stroke", paperColor).attr("opacity", c2.bar.strokeOpacity).attr("stroke-linecap", "butt");
+            highlightShadow.attr("y1", function(d2) {
+              return d2.height;
+            }).call(styleHighlight);
+            var highlight = axisBrush.selectAll(".highlight").data(repeat);
+            highlight.enter().append("line").classed("highlight", true).attr("x", -c2.bar.width / 2).attr("stroke-width", c2.bar.width - c2.bar.strokeWidth).attr("stroke", c2.bar.fillColor).attr("opacity", c2.bar.fillOpacity).attr("stroke-linecap", "butt");
+            highlight.attr("y1", function(d2) {
+              return d2.height;
+            }).call(styleHighlight);
+          }
+          function ensureAxisBrush(axisOverlays, paperColor, gd2) {
+            var axisBrush = axisOverlays.selectAll("." + c2.cn.axisBrush).data(repeat, keyFun);
+            axisBrush.enter().append("g").classed(c2.cn.axisBrush, true);
+            renderAxisBrush(axisBrush, paperColor, gd2);
+          }
+          function getBrushExtent(brush) {
+            return brush.svgBrush.extent.map(function(e2) {
+              return e2.slice();
+            });
+          }
+          function brushClear(brush) {
+            brush.filterSpecified = false;
+            brush.svgBrush.extent = [[-Infinity, Infinity]];
+          }
+          function axisBrushMoved(callback) {
+            return function axisBrushMoved2(dimension) {
+              var brush = dimension.brush;
+              var extent = getBrushExtent(brush);
+              var newExtent = extent.slice();
+              brush.filter.set(newExtent);
+              callback();
+            };
+          }
+          function dedupeRealRanges(intervals) {
+            var queue = intervals.slice();
+            var result = [];
+            var currentInterval;
+            var current = queue.shift();
+            while (current) {
+              currentInterval = current.slice();
+              while ((current = queue.shift()) && current[0] <= /* right-open interval would need `<` */
+              currentInterval[1]) {
+                currentInterval[1] = Math.max(currentInterval[1], current[1]);
+              }
+              result.push(currentInterval);
+            }
+            if (result.length === 1 && result[0][0] > result[0][1]) {
+              result = [];
+            }
+            return result;
+          }
+          function makeFilter() {
+            var filter = [];
+            var consolidated;
+            var bounds;
+            return {
+              set: function(a2) {
+                filter = a2.map(function(d2) {
+                  return d2.slice().sort(sortAsc);
+                }).sort(startAsc);
+                if (filter.length === 1 && filter[0][0] === -Infinity && filter[0][1] === Infinity) {
+                  filter = [[0, -1]];
+                }
+                consolidated = dedupeRealRanges(filter);
+                bounds = filter.reduce(function(p2, n2) {
+                  return [Math.min(p2[0], n2[0]), Math.max(p2[1], n2[1])];
+                }, [Infinity, -Infinity]);
+              },
+              get: function() {
+                return filter.slice();
+              },
+              getConsolidated: function() {
+                return consolidated;
+              },
+              getBounds: function() {
+                return bounds;
+              }
+            };
+          }
+          function makeBrush(state, rangeSpecified, initialRange, brushStartCallback, brushCallback, brushEndCallback) {
+            var filter = makeFilter();
+            filter.set(initialRange);
+            return {
+              filter,
+              filterSpecified: rangeSpecified,
+              // there's a difference between not filtering and filtering a non-proper subset
+              svgBrush: {
+                extent: [],
+                // this is where the svgBrush writes contents into
+                brushStartCallback,
+                brushCallback: axisBrushMoved(brushCallback),
+                brushEndCallback
+              }
+            };
+          }
+          function cleanRanges(ranges, dimension) {
+            if (Array.isArray(ranges[0])) {
+              ranges = ranges.map(function(ri2) {
+                return ri2.sort(sortAsc);
+              });
+              if (!dimension.multiselect) ranges = [ranges[0]];
+              else ranges = dedupeRealRanges(ranges.sort(startAsc));
+            } else ranges = [ranges.sort(sortAsc)];
+            if (dimension.tickvals) {
+              var sortedTickVals = dimension.tickvals.slice().sort(sortAsc);
+              ranges = ranges.map(function(ri2) {
+                var rSnapped = [
+                  ordinalScaleSnap(0, sortedTickVals, ri2[0], []),
+                  ordinalScaleSnap(1, sortedTickVals, ri2[1], [])
+                ];
+                if (rSnapped[1] > rSnapped[0]) return rSnapped;
+              }).filter(function(ri2) {
+                return ri2;
+              });
+              if (!ranges.length) return;
+            }
+            return ranges.length > 1 ? ranges : ranges[0];
+          }
+          module2.exports = {
+            makeBrush,
+            ensureAxisBrush,
+            cleanRanges
+          };
+        }
+      });
+      var require_defaults48 = __commonJS({
+        "src/traces/parcoords/defaults.js"(exports, module2) {
+          var Lib = require_lib();
+          var hasColorscale = require_helpers().hasColorscale;
+          var colorscaleDefaults = require_defaults2();
+          var handleDomainDefaults = require_domain().defaults;
+          var handleArrayContainerDefaults = require_array_container_defaults();
+          var Axes = require_axes();
+          var attributes = require_attributes52();
+          var axisBrush = require_axisbrush();
+          var maxDimensionCount = require_constants24().maxDimensionCount;
+          var mergeLength = require_merge_length();
+          function handleLineDefaults(traceIn, traceOut, defaultColor, layout, coerce) {
+            var lineColor = coerce("line.color", defaultColor);
+            if (hasColorscale(traceIn, "line") && Lib.isArrayOrTypedArray(lineColor)) {
+              if (lineColor.length) {
+                coerce("line.colorscale");
+                colorscaleDefaults(traceIn, traceOut, layout, coerce, { prefix: "line.", cLetter: "c" });
+                return lineColor.length;
+              } else {
+                traceOut.line.color = defaultColor;
+              }
+            }
+            return Infinity;
+          }
+          function dimensionDefaults(dimensionIn, dimensionOut, parentOut, opts) {
+            function coerce(attr, dflt) {
+              return Lib.coerce(dimensionIn, dimensionOut, attributes.dimensions, attr, dflt);
+            }
+            var values = coerce("values");
+            var visible = coerce("visible");
+            if (!(values && values.length)) {
+              visible = dimensionOut.visible = false;
+            }
+            if (visible) {
+              coerce("label");
+              coerce("tickvals");
+              coerce("ticktext");
+              coerce("tickformat");
+              var range = coerce("range");
+              dimensionOut._ax = {
+                _id: "y",
+                type: "linear",
+                showexponent: "all",
+                exponentformat: "B",
+                range
+              };
+              Axes.setConvert(dimensionOut._ax, opts.layout);
+              coerce("multiselect");
+              var constraintRange = coerce("constraintrange");
+              if (constraintRange) {
+                dimensionOut.constraintrange = axisBrush.cleanRanges(constraintRange, dimensionOut);
+              }
+            }
+          }
+          module2.exports = function supplyDefaults(traceIn, traceOut, defaultColor, layout) {
+            function coerce(attr, dflt) {
+              return Lib.coerce(traceIn, traceOut, attributes, attr, dflt);
+            }
+            var dimensionsIn = traceIn.dimensions;
+            if (Array.isArray(dimensionsIn) && dimensionsIn.length > maxDimensionCount) {
+              Lib.log("parcoords traces support up to " + maxDimensionCount + " dimensions at the moment");
+              dimensionsIn.splice(maxDimensionCount);
+            }
+            var dimensions = handleArrayContainerDefaults(traceIn, traceOut, {
+              name: "dimensions",
+              layout,
+              handleItemDefaults: dimensionDefaults
+            });
+            var len2 = handleLineDefaults(traceIn, traceOut, defaultColor, layout, coerce);
+            handleDomainDefaults(traceOut, layout, coerce);
+            if (!Array.isArray(dimensions) || !dimensions.length) {
+              traceOut.visible = false;
+            }
+            mergeLength(traceOut, dimensions, "values", len2);
+            var fontDflt = Lib.extendFlat({}, layout.font, {
+              size: Math.round(layout.font.size / 1.2)
+            });
+            Lib.coerceFont(coerce, "labelfont", fontDflt);
+            Lib.coerceFont(coerce, "tickfont", fontDflt, { autoShadowDflt: true });
+            Lib.coerceFont(coerce, "rangefont", fontDflt);
+            coerce("labelangle");
+            coerce("labelside");
+            coerce("unselected.line.color");
+            coerce("unselected.line.opacity");
+          };
+        }
+      });
+      var require_calc31 = __commonJS({
+        "src/traces/parcoords/calc.js"(exports, module2) {
+          var isArrayOrTypedArray = require_lib().isArrayOrTypedArray;
+          var Colorscale = require_colorscale();
+          var wrap = require_gup().wrap;
+          module2.exports = function calc(gd2, trace) {
+            var lineColor;
+            var cscale;
+            if (Colorscale.hasColorscale(trace, "line") && isArrayOrTypedArray(trace.line.color)) {
+              lineColor = trace.line.color;
+              cscale = Colorscale.extractOpts(trace.line).colorscale;
+              Colorscale.calc(gd2, trace, {
+                vals: lineColor,
+                containerStr: "line",
+                cLetter: "c"
+              });
+            } else {
+              lineColor = constHalf(trace._length);
+              cscale = [[0, trace.line.color], [1, trace.line.color]];
+            }
+            return wrap({ lineColor, cscale });
+          };
+          function constHalf(len2) {
+            var out = new Array(len2);
+            for (var i2 = 0; i2 < len2; i2++) {
+              out[i2] = 0.5;
+            }
+            return out;
+          }
+        }
+      });
+      function parse2(cstr) {
+        var _a3, _b3;
+        var m2, parts = [], alpha = 1, space;
+        if (typeof cstr === "number") {
+          return { space: "rgb", values: [cstr >>> 16, (cstr & 65280) >>> 8, cstr & 255], alpha: 1 };
+        }
+        if (typeof cstr === "number") return { space: "rgb", values: [cstr >>> 16, (cstr & 65280) >>> 8, cstr & 255], alpha: 1 };
+        cstr = String(cstr).toLowerCase();
+        if (import_color_name.default[cstr]) {
+          parts = import_color_name.default[cstr].slice();
+          space = "rgb";
+        } else if (cstr === "transparent") {
+          alpha = 0;
+          space = "rgb";
+          parts = [0, 0, 0];
+        } else if (cstr[0] === "#") {
+          var base = cstr.slice(1);
+          var size = base.length;
+          var isShort = size <= 4;
+          alpha = 1;
+          if (isShort) {
+            parts = [
+              parseInt(base[0] + base[0], 16),
+              parseInt(base[1] + base[1], 16),
+              parseInt(base[2] + base[2], 16)
+            ];
+            if (size === 4) {
+              alpha = parseInt(base[3] + base[3], 16) / 255;
+            }
+          } else {
+            parts = [
+              parseInt(base[0] + base[1], 16),
+              parseInt(base[2] + base[3], 16),
+              parseInt(base[4] + base[5], 16)
+            ];
+            if (size === 8) {
+              alpha = parseInt(base[6] + base[7], 16) / 255;
+            }
+          }
+          if (!parts[0]) parts[0] = 0;
+          if (!parts[1]) parts[1] = 0;
+          if (!parts[2]) parts[2] = 0;
+          space = "rgb";
+        } else if (m2 = /^((?:rgba?|hs[lvb]a?|hwba?|cmyk?|xy[zy]|gray|lab|lchu?v?|[ly]uv|lms|oklch|oklab|color))\s*\(([^\)]*)\)/.exec(cstr)) {
+          var name2 = m2[1];
+          space = name2.replace(/a$/, "");
+          var dims = space === "cmyk" ? 4 : space === "gray" ? 1 : 3;
+          parts = m2[2].trim().split(/\s*[,\/]\s*|\s+/);
+          if (space === "color") space = parts.shift();
+          parts = parts.map(function(x2, i2) {
+            if (x2[x2.length - 1] === "%") {
+              x2 = parseFloat(x2) / 100;
+              if (i2 === 3) return x2;
+              if (space === "rgb") return x2 * 255;
+              if (space[0] === "h") return x2 * 100;
+              if (space[0] === "l" && !i2) return x2 * 100;
+              if (space === "lab") return x2 * 125;
+              if (space === "lch") return i2 < 2 ? x2 * 150 : x2 * 360;
+              if (space[0] === "o" && !i2) return x2;
+              if (space === "oklab") return x2 * 0.4;
+              if (space === "oklch") return i2 < 2 ? x2 * 0.4 : x2 * 360;
+              return x2;
+            }
+            if (space[i2] === "h" || i2 === 2 && space[space.length - 1] === "h") {
+              if (baseHues[x2] !== void 0) return baseHues[x2];
+              if (x2.endsWith("deg")) return parseFloat(x2);
+              if (x2.endsWith("turn")) return parseFloat(x2) * 360;
+              if (x2.endsWith("grad")) return parseFloat(x2) * 360 / 400;
+              if (x2.endsWith("rad")) return parseFloat(x2) * 180 / Math.PI;
+            }
+            if (x2 === "none") return 0;
+            return parseFloat(x2);
+          });
+          alpha = parts.length > dims ? parts.pop() : 1;
+        } else if (/[0-9](?:\s|\/|,)/.test(cstr)) {
+          parts = cstr.match(/([0-9]+)/g).map(function(value) {
+            return parseFloat(value);
+          });
+          space = ((_b3 = (_a3 = cstr.match(/([a-z])/ig)) == null ? void 0 : _a3.join("")) == null ? void 0 : _b3.toLowerCase()) || "rgb";
+        }
+        return {
+          space,
+          values: parts,
+          alpha
+        };
       }
-      return value;
-    };
-    switch (token) {
-      case "i":
-      case "ii":
-        return parseNDigits(token.length, dateString);
-      case "io":
-        return match2.ordinalNumber(dateString, { unit: "day" });
-      case "iii":
-        return mapValue(
-          match2.day(dateString, {
-            width: "abbreviated",
-            context: "formatting"
-          }) || match2.day(dateString, {
-            width: "short",
-            context: "formatting"
-          }) || match2.day(dateString, {
-            width: "narrow",
-            context: "formatting"
-          }),
-          valueCallback
-        );
-      case "iiiii":
-        return mapValue(
-          match2.day(dateString, {
-            width: "narrow",
-            context: "formatting"
-          }),
-          valueCallback
-        );
-      case "iiiiii":
-        return mapValue(
-          match2.day(dateString, {
-            width: "short",
-            context: "formatting"
-          }) || match2.day(dateString, {
-            width: "narrow",
-            context: "formatting"
-          }),
-          valueCallback
-        );
-      case "iiii":
-      default:
-        return mapValue(
-          match2.day(dateString, {
-            width: "wide",
-            context: "formatting"
-          }) || match2.day(dateString, {
-            width: "abbreviated",
-            context: "formatting"
-          }) || match2.day(dateString, {
-            width: "short",
-            context: "formatting"
-          }) || match2.day(dateString, {
-            width: "narrow",
-            context: "formatting"
-          }),
-          valueCallback
-        );
-    }
-  }
-  validate(_date, value) {
-    return value >= 1 && value <= 7;
-  }
-  set(date, _flags, value) {
-    date = setISODay(date, value);
-    date.setHours(0, 0, 0, 0);
-    return date;
-  }
-}
-class AMPMParser extends Parser {
-  constructor() {
-    super(...arguments);
-    __publicField(this, "priority", 80);
-    __publicField(this, "incompatibleTokens", ["b", "B", "H", "k", "t", "T"]);
-  }
-  parse(dateString, token, match2) {
-    switch (token) {
-      case "a":
-      case "aa":
-      case "aaa":
-        return match2.dayPeriod(dateString, {
-          width: "abbreviated",
-          context: "formatting"
-        }) || match2.dayPeriod(dateString, {
-          width: "narrow",
-          context: "formatting"
-        });
-      case "aaaaa":
-        return match2.dayPeriod(dateString, {
-          width: "narrow",
-          context: "formatting"
-        });
-      case "aaaa":
-      default:
-        return match2.dayPeriod(dateString, {
-          width: "wide",
-          context: "formatting"
-        }) || match2.dayPeriod(dateString, {
-          width: "abbreviated",
-          context: "formatting"
-        }) || match2.dayPeriod(dateString, {
-          width: "narrow",
-          context: "formatting"
-        });
-    }
-  }
-  set(date, _flags, value) {
-    date.setHours(dayPeriodEnumToHours(value), 0, 0, 0);
-    return date;
-  }
-}
-class AMPMMidnightParser extends Parser {
-  constructor() {
-    super(...arguments);
-    __publicField(this, "priority", 80);
-    __publicField(this, "incompatibleTokens", ["a", "B", "H", "k", "t", "T"]);
-  }
-  parse(dateString, token, match2) {
-    switch (token) {
-      case "b":
-      case "bb":
-      case "bbb":
-        return match2.dayPeriod(dateString, {
-          width: "abbreviated",
-          context: "formatting"
-        }) || match2.dayPeriod(dateString, {
-          width: "narrow",
-          context: "formatting"
-        });
-      case "bbbbb":
-        return match2.dayPeriod(dateString, {
-          width: "narrow",
-          context: "formatting"
-        });
-      case "bbbb":
-      default:
-        return match2.dayPeriod(dateString, {
-          width: "wide",
-          context: "formatting"
-        }) || match2.dayPeriod(dateString, {
-          width: "abbreviated",
-          context: "formatting"
-        }) || match2.dayPeriod(dateString, {
-          width: "narrow",
-          context: "formatting"
-        });
-    }
-  }
-  set(date, _flags, value) {
-    date.setHours(dayPeriodEnumToHours(value), 0, 0, 0);
-    return date;
-  }
-}
-class DayPeriodParser extends Parser {
-  constructor() {
-    super(...arguments);
-    __publicField(this, "priority", 80);
-    __publicField(this, "incompatibleTokens", ["a", "b", "t", "T"]);
-  }
-  parse(dateString, token, match2) {
-    switch (token) {
-      case "B":
-      case "BB":
-      case "BBB":
-        return match2.dayPeriod(dateString, {
-          width: "abbreviated",
-          context: "formatting"
-        }) || match2.dayPeriod(dateString, {
-          width: "narrow",
-          context: "formatting"
-        });
-      case "BBBBB":
-        return match2.dayPeriod(dateString, {
-          width: "narrow",
-          context: "formatting"
-        });
-      case "BBBB":
-      default:
-        return match2.dayPeriod(dateString, {
-          width: "wide",
-          context: "formatting"
-        }) || match2.dayPeriod(dateString, {
-          width: "abbreviated",
-          context: "formatting"
-        }) || match2.dayPeriod(dateString, {
-          width: "narrow",
-          context: "formatting"
-        });
-    }
-  }
-  set(date, _flags, value) {
-    date.setHours(dayPeriodEnumToHours(value), 0, 0, 0);
-    return date;
-  }
-}
-class Hour1to12Parser extends Parser {
-  constructor() {
-    super(...arguments);
-    __publicField(this, "priority", 70);
-    __publicField(this, "incompatibleTokens", ["H", "K", "k", "t", "T"]);
-  }
-  parse(dateString, token, match2) {
-    switch (token) {
-      case "h":
-        return parseNumericPattern(numericPatterns.hour12h, dateString);
-      case "ho":
-        return match2.ordinalNumber(dateString, { unit: "hour" });
-      default:
-        return parseNDigits(token.length, dateString);
-    }
-  }
-  validate(_date, value) {
-    return value >= 1 && value <= 12;
-  }
-  set(date, _flags, value) {
-    const isPM = date.getHours() >= 12;
-    if (isPM && value < 12) {
-      date.setHours(value + 12, 0, 0, 0);
-    } else if (!isPM && value === 12) {
-      date.setHours(0, 0, 0, 0);
-    } else {
-      date.setHours(value, 0, 0, 0);
-    }
-    return date;
-  }
-}
-class Hour0to23Parser extends Parser {
-  constructor() {
-    super(...arguments);
-    __publicField(this, "priority", 70);
-    __publicField(this, "incompatibleTokens", ["a", "b", "h", "K", "k", "t", "T"]);
-  }
-  parse(dateString, token, match2) {
-    switch (token) {
-      case "H":
-        return parseNumericPattern(numericPatterns.hour23h, dateString);
-      case "Ho":
-        return match2.ordinalNumber(dateString, { unit: "hour" });
-      default:
-        return parseNDigits(token.length, dateString);
-    }
-  }
-  validate(_date, value) {
-    return value >= 0 && value <= 23;
-  }
-  set(date, _flags, value) {
-    date.setHours(value, 0, 0, 0);
-    return date;
-  }
-}
-class Hour0To11Parser extends Parser {
-  constructor() {
-    super(...arguments);
-    __publicField(this, "priority", 70);
-    __publicField(this, "incompatibleTokens", ["h", "H", "k", "t", "T"]);
-  }
-  parse(dateString, token, match2) {
-    switch (token) {
-      case "K":
-        return parseNumericPattern(numericPatterns.hour11h, dateString);
-      case "Ko":
-        return match2.ordinalNumber(dateString, { unit: "hour" });
-      default:
-        return parseNDigits(token.length, dateString);
-    }
-  }
-  validate(_date, value) {
-    return value >= 0 && value <= 11;
-  }
-  set(date, _flags, value) {
-    const isPM = date.getHours() >= 12;
-    if (isPM && value < 12) {
-      date.setHours(value + 12, 0, 0, 0);
-    } else {
-      date.setHours(value, 0, 0, 0);
-    }
-    return date;
-  }
-}
-class Hour1To24Parser extends Parser {
-  constructor() {
-    super(...arguments);
-    __publicField(this, "priority", 70);
-    __publicField(this, "incompatibleTokens", ["a", "b", "h", "H", "K", "t", "T"]);
-  }
-  parse(dateString, token, match2) {
-    switch (token) {
-      case "k":
-        return parseNumericPattern(numericPatterns.hour24h, dateString);
-      case "ko":
-        return match2.ordinalNumber(dateString, { unit: "hour" });
-      default:
-        return parseNDigits(token.length, dateString);
-    }
-  }
-  validate(_date, value) {
-    return value >= 1 && value <= 24;
-  }
-  set(date, _flags, value) {
-    const hours = value <= 24 ? value % 24 : value;
-    date.setHours(hours, 0, 0, 0);
-    return date;
-  }
-}
-class MinuteParser extends Parser {
-  constructor() {
-    super(...arguments);
-    __publicField(this, "priority", 60);
-    __publicField(this, "incompatibleTokens", ["t", "T"]);
-  }
-  parse(dateString, token, match2) {
-    switch (token) {
-      case "m":
-        return parseNumericPattern(numericPatterns.minute, dateString);
-      case "mo":
-        return match2.ordinalNumber(dateString, { unit: "minute" });
-      default:
-        return parseNDigits(token.length, dateString);
-    }
-  }
-  validate(_date, value) {
-    return value >= 0 && value <= 59;
-  }
-  set(date, _flags, value) {
-    date.setMinutes(value, 0, 0);
-    return date;
-  }
+      var import_color_name, color_parse_default, baseHues;
+      var init_color_parse = __esm({
+        "node_modules/color-parse/index.js"() {
+          import_color_name = __toESM(require_color_name());
+          color_parse_default = parse2;
+          baseHues = {
+            red: 0,
+            orange: 60,
+            yellow: 120,
+            green: 180,
+            blue: 240,
+            purple: 300
+          };
+        }
+      });
+      var rgb_default2;
+      var init_rgb2 = __esm({
+        "node_modules/color-space/rgb.js"() {
+          rgb_default2 = {
+            name: "rgb",
+            min: [0, 0, 0],
+            max: [255, 255, 255],
+            channel: ["red", "green", "blue"],
+            alias: ["RGB"]
+          };
+        }
+      });
+      var hsl_default2;
+      var init_hsl2 = __esm({
+        "node_modules/color-space/hsl.js"() {
+          init_rgb2();
+          hsl_default2 = {
+            name: "hsl",
+            min: [0, 0, 0],
+            max: [360, 100, 100],
+            channel: ["hue", "saturation", "lightness"],
+            alias: ["HSL"],
+            rgb: function(hsl3) {
+              var h2 = hsl3[0] / 360, s2 = hsl3[1] / 100, l2 = hsl3[2] / 100, t12, t22, t32, rgb2, val, i2 = 0;
+              if (s2 === 0) return val = l2 * 255, [val, val, val];
+              t22 = l2 < 0.5 ? l2 * (1 + s2) : l2 + s2 - l2 * s2;
+              t12 = 2 * l2 - t22;
+              rgb2 = [0, 0, 0];
+              for (; i2 < 3; ) {
+                t32 = h2 + 1 / 3 * -(i2 - 1);
+                t32 < 0 ? t32++ : t32 > 1 && t32--;
+                val = 6 * t32 < 1 ? t12 + (t22 - t12) * 6 * t32 : 2 * t32 < 1 ? t22 : 3 * t32 < 2 ? t12 + (t22 - t12) * (2 / 3 - t32) * 6 : t12;
+                rgb2[i2++] = val * 255;
+              }
+              return rgb2;
+            }
+          };
+          rgb_default2.hsl = function(rgb2) {
+            var r2 = rgb2[0] / 255, g2 = rgb2[1] / 255, b2 = rgb2[2] / 255, min = Math.min(r2, g2, b2), max = Math.max(r2, g2, b2), delta = max - min, h2, s2, l2;
+            if (max === min) {
+              h2 = 0;
+            } else if (r2 === max) {
+              h2 = (g2 - b2) / delta;
+            } else if (g2 === max) {
+              h2 = 2 + (b2 - r2) / delta;
+            } else if (b2 === max) {
+              h2 = 4 + (r2 - g2) / delta;
+            }
+            h2 = Math.min(h2 * 60, 360);
+            if (h2 < 0) {
+              h2 += 360;
+            }
+            l2 = (min + max) / 2;
+            if (max === min) {
+              s2 = 0;
+            } else if (l2 <= 0.5) {
+              s2 = delta / (max + min);
+            } else {
+              s2 = delta / (2 - max - min);
+            }
+            return [h2, s2 * 100, l2 * 100];
+          };
+        }
+      });
+      var color_rgba_exports = {};
+      __export(color_rgba_exports, {
+        default: () => rgba2
+      });
+      function rgba2(color22) {
+        if (Array.isArray(color22) && color22.raw) color22 = String.raw(...arguments);
+        if (color22 instanceof Number) color22 = +color22;
+        var values;
+        var parsed = color_parse_default(color22);
+        if (!parsed.space) return [];
+        const min = parsed.space[0] === "h" ? hsl_default2.min : rgb_default2.min;
+        const max = parsed.space[0] === "h" ? hsl_default2.max : rgb_default2.max;
+        values = Array(3);
+        values[0] = Math.min(Math.max(parsed.values[0], min[0]), max[0]);
+        values[1] = Math.min(Math.max(parsed.values[1], min[1]), max[1]);
+        values[2] = Math.min(Math.max(parsed.values[2], min[2]), max[2]);
+        if (parsed.space[0] === "h") {
+          values = hsl_default2.rgb(values);
+        }
+        values.push(Math.min(Math.max(parsed.alpha, 0), 1));
+        return values;
+      }
+      var init_color_rgba = __esm({
+        "node_modules/color-rgba/index.js"() {
+          init_color_parse();
+          init_rgb2();
+          init_hsl2();
+        }
+      });
+      var require_helpers18 = __commonJS({
+        "src/traces/parcoords/helpers.js"(exports) {
+          var isTypedArray2 = require_lib().isTypedArray;
+          exports.convertTypedArray = function(a2) {
+            return isTypedArray2(a2) ? Array.prototype.slice.call(a2) : a2;
+          };
+          exports.isOrdinal = function(dimension) {
+            return !!dimension.tickvals;
+          };
+          exports.isVisible = function(dimension) {
+            return dimension.visible || !("visible" in dimension);
+          };
+        }
+      });
+      var require_lines = __commonJS({
+        "src/traces/parcoords/lines.js"(exports, module2) {
+          var vertexShaderSource = [
+            "precision highp float;",
+            "",
+            "varying vec4 fragColor;",
+            "",
+            "attribute vec4 p01_04, p05_08, p09_12, p13_16,",
+            "               p17_20, p21_24, p25_28, p29_32,",
+            "               p33_36, p37_40, p41_44, p45_48,",
+            "               p49_52, p53_56, p57_60, colors;",
+            "",
+            "uniform mat4 dim0A, dim1A, dim0B, dim1B, dim0C, dim1C, dim0D, dim1D,",
+            "             loA, hiA, loB, hiB, loC, hiC, loD, hiD;",
+            "",
+            "uniform vec2 resolution, viewBoxPos, viewBoxSize;",
+            "uniform float maskHeight;",
+            "uniform float drwLayer; // 0: context, 1: focus, 2: pick",
+            "uniform vec4 contextColor;",
+            "uniform sampler2D maskTexture, palette;",
+            "",
+            "bool isPick    = (drwLayer > 1.5);",
+            "bool isContext = (drwLayer < 0.5);",
+            "",
+            "const vec4 ZEROS = vec4(0.0, 0.0, 0.0, 0.0);",
+            "const vec4 UNITS = vec4(1.0, 1.0, 1.0, 1.0);",
+            "",
+            "float val(mat4 p, mat4 v) {",
+            "    return dot(matrixCompMult(p, v) * UNITS, UNITS);",
+            "}",
+            "",
+            "float axisY(float ratio, mat4 A, mat4 B, mat4 C, mat4 D) {",
+            "    float y1 = val(A, dim0A) + val(B, dim0B) + val(C, dim0C) + val(D, dim0D);",
+            "    float y2 = val(A, dim1A) + val(B, dim1B) + val(C, dim1C) + val(D, dim1D);",
+            "    return y1 * (1.0 - ratio) + y2 * ratio;",
+            "}",
+            "",
+            "int iMod(int a, int b) {",
+            "    return a - b * (a / b);",
+            "}",
+            "",
+            "bool fOutside(float p, float lo, float hi) {",
+            "    return (lo < hi) && (lo > p || p > hi);",
+            "}",
+            "",
+            "bool vOutside(vec4 p, vec4 lo, vec4 hi) {",
+            "    return (",
+            "        fOutside(p[0], lo[0], hi[0]) ||",
+            "        fOutside(p[1], lo[1], hi[1]) ||",
+            "        fOutside(p[2], lo[2], hi[2]) ||",
+            "        fOutside(p[3], lo[3], hi[3])",
+            "    );",
+            "}",
+            "",
+            "bool mOutside(mat4 p, mat4 lo, mat4 hi) {",
+            "    return (",
+            "        vOutside(p[0], lo[0], hi[0]) ||",
+            "        vOutside(p[1], lo[1], hi[1]) ||",
+            "        vOutside(p[2], lo[2], hi[2]) ||",
+            "        vOutside(p[3], lo[3], hi[3])",
+            "    );",
+            "}",
+            "",
+            "bool outsideBoundingBox(mat4 A, mat4 B, mat4 C, mat4 D) {",
+            "    return mOutside(A, loA, hiA) ||",
+            "           mOutside(B, loB, hiB) ||",
+            "           mOutside(C, loC, hiC) ||",
+            "           mOutside(D, loD, hiD);",
+            "}",
+            "",
+            "bool outsideRasterMask(mat4 A, mat4 B, mat4 C, mat4 D) {",
+            "    mat4 pnts[4];",
+            "    pnts[0] = A;",
+            "    pnts[1] = B;",
+            "    pnts[2] = C;",
+            "    pnts[3] = D;",
+            "",
+            "    for(int i = 0; i < 4; ++i) {",
+            "        for(int j = 0; j < 4; ++j) {",
+            "            for(int k = 0; k < 4; ++k) {",
+            "                if(0 == iMod(",
+            "                    int(255.0 * texture2D(maskTexture,",
+            "                        vec2(",
+            "                            (float(i * 2 + j / 2) + 0.5) / 8.0,",
+            "                            (pnts[i][j][k] * (maskHeight - 1.0) + 1.0) / maskHeight",
+            "                        ))[3]",
+            "                    ) / int(pow(2.0, float(iMod(j * 4 + k, 8)))),",
+            "                    2",
+            "                )) return true;",
+            "            }",
+            "        }",
+            "    }",
+            "    return false;",
+            "}",
+            "",
+            "vec4 position(bool isContext, float v, mat4 A, mat4 B, mat4 C, mat4 D) {",
+            "    float x = 0.5 * sign(v) + 0.5;",
+            "    float y = axisY(x, A, B, C, D);",
+            "    float z = 1.0 - abs(v);",
+            "",
+            "    z += isContext ? 0.0 : 2.0 * float(",
+            "        outsideBoundingBox(A, B, C, D) ||",
+            "        outsideRasterMask(A, B, C, D)",
+            "    );",
+            "",
+            "    return vec4(",
+            "        2.0 * (vec2(x, y) * viewBoxSize + viewBoxPos) / resolution - 1.0,",
+            "        z,",
+            "        1.0",
+            "    );",
+            "}",
+            "",
+            "void main() {",
+            "    mat4 A = mat4(p01_04, p05_08, p09_12, p13_16);",
+            "    mat4 B = mat4(p17_20, p21_24, p25_28, p29_32);",
+            "    mat4 C = mat4(p33_36, p37_40, p41_44, p45_48);",
+            "    mat4 D = mat4(p49_52, p53_56, p57_60, ZEROS);",
+            "",
+            "    float v = colors[3];",
+            "",
+            "    gl_Position = position(isContext, v, A, B, C, D);",
+            "",
+            "    fragColor =",
+            "        isContext ? vec4(contextColor) :",
+            "        isPick ? vec4(colors.rgb, 1.0) : texture2D(palette, vec2(abs(v), 0.5));",
+            "}"
+          ].join("\n");
+          var fragmentShaderSource = [
+            "precision highp float;",
+            "",
+            "varying vec4 fragColor;",
+            "",
+            "void main() {",
+            "    gl_FragColor = fragColor;",
+            "}"
+          ].join("\n");
+          var maxDim = require_constants24().maxDimensionCount;
+          var Lib = require_lib();
+          var depthLimitEpsilon = 1e-6;
+          var maskHeight = 2048;
+          var dummyPixel = new Uint8Array(4);
+          var dataPixel = new Uint8Array(4);
+          var paletteTextureConfig = {
+            shape: [256, 1],
+            format: "rgba",
+            type: "uint8",
+            mag: "nearest",
+            min: "nearest"
+          };
+          function ensureDraw(regl) {
+            regl.read({
+              x: 0,
+              y: 0,
+              width: 1,
+              height: 1,
+              data: dummyPixel
+            });
+          }
+          function clear(regl, x2, y2, width, height) {
+            var gl2 = regl._gl;
+            gl2.enable(gl2.SCISSOR_TEST);
+            gl2.scissor(x2, y2, width, height);
+            regl.clear({ color: [0, 0, 0, 0], depth: 1 });
+          }
+          function renderBlock(regl, glAes, renderState, blockLineCount, sampleCount, item) {
+            var rafKey = item.key;
+            function render(blockNumber) {
+              var count2 = Math.min(blockLineCount, sampleCount - blockNumber * blockLineCount);
+              if (blockNumber === 0) {
+                window.cancelAnimationFrame(renderState.currentRafs[rafKey]);
+                delete renderState.currentRafs[rafKey];
+                clear(regl, item.scissorX, item.scissorY, item.scissorWidth, item.viewBoxSize[1]);
+              }
+              if (renderState.clearOnly) {
+                return;
+              }
+              item.count = 2 * count2;
+              item.offset = 2 * blockNumber * blockLineCount;
+              glAes(item);
+              if (blockNumber * blockLineCount + count2 < sampleCount) {
+                renderState.currentRafs[rafKey] = window.requestAnimationFrame(function() {
+                  render(blockNumber + 1);
+                });
+              }
+              renderState.drawCompleted = false;
+            }
+            if (!renderState.drawCompleted) {
+              ensureDraw(regl);
+              renderState.drawCompleted = true;
+            }
+            render(0);
+          }
+          function adjustDepth(d2) {
+            return Math.max(depthLimitEpsilon, Math.min(1 - depthLimitEpsilon, d2));
+          }
+          function palette(unitToColor, opacity) {
+            var result = new Array(256);
+            for (var i2 = 0; i2 < 256; i2++) {
+              result[i2] = unitToColor(i2 / 255).concat(opacity);
+            }
+            return result;
+          }
+          function calcPickColor(i2, rgbIndex) {
+            return (i2 >>> 8 * rgbIndex) % 256 / 255;
+          }
+          function makePoints(sampleCount, dims, color22) {
+            var points = new Array(sampleCount * (maxDim + 4));
+            var n2 = 0;
+            for (var i2 = 0; i2 < sampleCount; i2++) {
+              for (var k2 = 0; k2 < maxDim; k2++) {
+                points[n2++] = k2 < dims.length ? dims[k2].paddedUnitValues[i2] : 0.5;
+              }
+              points[n2++] = calcPickColor(i2, 2);
+              points[n2++] = calcPickColor(i2, 1);
+              points[n2++] = calcPickColor(i2, 0);
+              points[n2++] = adjustDepth(color22[i2]);
+            }
+            return points;
+          }
+          function makeVecAttr(vecIndex, sampleCount, points) {
+            var pointPairs = new Array(sampleCount * 8);
+            var n2 = 0;
+            for (var i2 = 0; i2 < sampleCount; i2++) {
+              for (var j2 = 0; j2 < 2; j2++) {
+                for (var k2 = 0; k2 < 4; k2++) {
+                  var q2 = vecIndex * 4 + k2;
+                  var v2 = points[i2 * 64 + q2];
+                  if (q2 === 63 && j2 === 0) {
+                    v2 *= -1;
+                  }
+                  pointPairs[n2++] = v2;
+                }
+              }
+            }
+            return pointPairs;
+          }
+          function pad2(num) {
+            var s2 = "0" + num;
+            return s2.slice(-2);
+          }
+          function getAttrName(i2) {
+            return i2 < maxDim ? "p" + pad2(i2 + 1) + "_" + pad2(i2 + 4) : "colors";
+          }
+          function setAttributes(attributes, sampleCount, points) {
+            for (var i2 = 0; i2 <= maxDim; i2 += 4) {
+              attributes[getAttrName(i2)](makeVecAttr(i2 / 4, sampleCount, points));
+            }
+          }
+          function emptyAttributes(regl) {
+            var attributes = {};
+            for (var i2 = 0; i2 <= maxDim; i2 += 4) {
+              attributes[getAttrName(i2)] = regl.buffer({ usage: "dynamic", type: "float", data: new Uint8Array(0) });
+            }
+            return attributes;
+          }
+          function makeItem(model, leftmost, rightmost, itemNumber, i0, i1, x2, y2, panelSizeX, panelSizeY, crossfilterDimensionIndex, drwLayer, constraints, plotGlPixelRatio) {
+            var dims = [[], []];
+            for (var k2 = 0; k2 < 64; k2++) {
+              dims[0][k2] = k2 === i0 ? 1 : 0;
+              dims[1][k2] = k2 === i1 ? 1 : 0;
+            }
+            x2 *= plotGlPixelRatio;
+            y2 *= plotGlPixelRatio;
+            panelSizeX *= plotGlPixelRatio;
+            panelSizeY *= plotGlPixelRatio;
+            var overdrag = model.lines.canvasOverdrag * plotGlPixelRatio;
+            var domain = model.domain;
+            var canvasWidth = model.canvasWidth * plotGlPixelRatio;
+            var canvasHeight = model.canvasHeight * plotGlPixelRatio;
+            var padL = model.pad.l * plotGlPixelRatio;
+            var padB = model.pad.b * plotGlPixelRatio;
+            var layoutHeight = model.layoutHeight * plotGlPixelRatio;
+            var layoutWidth = model.layoutWidth * plotGlPixelRatio;
+            var deselectedLinesColor = model.deselectedLines.color;
+            var deselectedLinesOpacity = model.deselectedLines.opacity;
+            var itemModel = Lib.extendFlat({
+              key: crossfilterDimensionIndex,
+              resolution: [canvasWidth, canvasHeight],
+              viewBoxPos: [x2 + overdrag, y2],
+              viewBoxSize: [panelSizeX, panelSizeY],
+              i0,
+              i1,
+              dim0A: dims[0].slice(0, 16),
+              dim0B: dims[0].slice(16, 32),
+              dim0C: dims[0].slice(32, 48),
+              dim0D: dims[0].slice(48, 64),
+              dim1A: dims[1].slice(0, 16),
+              dim1B: dims[1].slice(16, 32),
+              dim1C: dims[1].slice(32, 48),
+              dim1D: dims[1].slice(48, 64),
+              drwLayer,
+              contextColor: [
+                deselectedLinesColor[0] / 255,
+                deselectedLinesColor[1] / 255,
+                deselectedLinesColor[2] / 255,
+                deselectedLinesOpacity !== "auto" ? deselectedLinesColor[3] * deselectedLinesOpacity : Math.max(1 / 255, Math.pow(1 / model.lines.color.length, 1 / 3))
+              ],
+              scissorX: (itemNumber === leftmost ? 0 : x2 + overdrag) + (padL - overdrag) + layoutWidth * domain.x[0],
+              scissorWidth: (itemNumber === rightmost ? canvasWidth - x2 + overdrag : panelSizeX + 0.5) + (itemNumber === leftmost ? x2 + overdrag : 0),
+              scissorY: y2 + padB + layoutHeight * domain.y[0],
+              scissorHeight: panelSizeY,
+              viewportX: padL - overdrag + layoutWidth * domain.x[0],
+              viewportY: padB + layoutHeight * domain.y[0],
+              viewportWidth: canvasWidth,
+              viewportHeight: canvasHeight
+            }, constraints);
+            return itemModel;
+          }
+          function expandedPixelRange(bounds) {
+            var dh2 = maskHeight - 1;
+            var a2 = Math.max(0, Math.floor(bounds[0] * dh2), 0);
+            var b2 = Math.min(dh2, Math.ceil(bounds[1] * dh2), dh2);
+            return [
+              Math.min(a2, b2),
+              Math.max(a2, b2)
+            ];
+          }
+          module2.exports = function(canvasGL, d2) {
+            var isContext = d2.context;
+            var isPick = d2.pick;
+            var regl = d2.regl;
+            var gl2 = regl._gl;
+            var supportedLineWidth = gl2.getParameter(gl2.ALIASED_LINE_WIDTH_RANGE);
+            var plotGlPixelRatio = Math.max(
+              supportedLineWidth[0],
+              Math.min(
+                supportedLineWidth[1],
+                d2.viewModel.plotGlPixelRatio
+              )
+            );
+            var renderState = {
+              currentRafs: {},
+              drawCompleted: true,
+              clearOnly: false
+            };
+            var model;
+            var vm;
+            var initialDims;
+            var sampleCount;
+            var attributes = emptyAttributes(regl);
+            var maskTexture;
+            var paletteTexture = regl.texture(paletteTextureConfig);
+            var prevAxisOrder = [];
+            update(d2);
+            var glAes = regl({
+              profile: false,
+              blend: {
+                enable: isContext,
+                func: {
+                  srcRGB: "src alpha",
+                  dstRGB: "one minus src alpha",
+                  srcAlpha: 1,
+                  dstAlpha: 1
+                  // 'one minus src alpha'
+                },
+                equation: {
+                  rgb: "add",
+                  alpha: "add"
+                },
+                color: [0, 0, 0, 0]
+              },
+              depth: {
+                enable: !isContext,
+                mask: true,
+                func: "less",
+                range: [0, 1]
+              },
+              // for polygons
+              cull: {
+                enable: true,
+                face: "back"
+              },
+              scissor: {
+                enable: true,
+                box: {
+                  x: regl.prop("scissorX"),
+                  y: regl.prop("scissorY"),
+                  width: regl.prop("scissorWidth"),
+                  height: regl.prop("scissorHeight")
+                }
+              },
+              viewport: {
+                x: regl.prop("viewportX"),
+                y: regl.prop("viewportY"),
+                width: regl.prop("viewportWidth"),
+                height: regl.prop("viewportHeight")
+              },
+              dither: false,
+              vert: vertexShaderSource,
+              frag: fragmentShaderSource,
+              primitive: "lines",
+              lineWidth: plotGlPixelRatio,
+              attributes,
+              uniforms: {
+                resolution: regl.prop("resolution"),
+                viewBoxPos: regl.prop("viewBoxPos"),
+                viewBoxSize: regl.prop("viewBoxSize"),
+                dim0A: regl.prop("dim0A"),
+                dim1A: regl.prop("dim1A"),
+                dim0B: regl.prop("dim0B"),
+                dim1B: regl.prop("dim1B"),
+                dim0C: regl.prop("dim0C"),
+                dim1C: regl.prop("dim1C"),
+                dim0D: regl.prop("dim0D"),
+                dim1D: regl.prop("dim1D"),
+                loA: regl.prop("loA"),
+                hiA: regl.prop("hiA"),
+                loB: regl.prop("loB"),
+                hiB: regl.prop("hiB"),
+                loC: regl.prop("loC"),
+                hiC: regl.prop("hiC"),
+                loD: regl.prop("loD"),
+                hiD: regl.prop("hiD"),
+                palette: paletteTexture,
+                contextColor: regl.prop("contextColor"),
+                maskTexture: regl.prop("maskTexture"),
+                drwLayer: regl.prop("drwLayer"),
+                maskHeight: regl.prop("maskHeight")
+              },
+              offset: regl.prop("offset"),
+              count: regl.prop("count")
+            });
+            function update(dNew) {
+              model = dNew.model;
+              vm = dNew.viewModel;
+              initialDims = vm.dimensions.slice();
+              sampleCount = initialDims[0] ? initialDims[0].values.length : 0;
+              var lines = model.lines;
+              var color22 = isPick ? lines.color.map(function(_2, i2) {
+                return i2 / lines.color.length;
+              }) : lines.color;
+              var points = makePoints(sampleCount, initialDims, color22);
+              setAttributes(attributes, sampleCount, points);
+              if (!isContext && !isPick) {
+                paletteTexture = regl.texture(Lib.extendFlat({
+                  data: palette(model.unitToColor, 255)
+                }, paletteTextureConfig));
+              }
+            }
+            function makeConstraints(isContext2) {
+              var i2, j2, k2;
+              var limits = [[], []];
+              for (k2 = 0; k2 < 64; k2++) {
+                var p2 = !isContext2 && k2 < initialDims.length ? initialDims[k2].brush.filter.getBounds() : [-Infinity, Infinity];
+                limits[0][k2] = p2[0];
+                limits[1][k2] = p2[1];
+              }
+              var len2 = maskHeight * 8;
+              var mask = new Array(len2);
+              for (i2 = 0; i2 < len2; i2++) {
+                mask[i2] = 255;
+              }
+              if (!isContext2) {
+                for (i2 = 0; i2 < initialDims.length; i2++) {
+                  var u2 = i2 % 8;
+                  var v2 = (i2 - u2) / 8;
+                  var bitMask = Math.pow(2, u2);
+                  var dim = initialDims[i2];
+                  var ranges = dim.brush.filter.get();
+                  if (ranges.length < 2) continue;
+                  var prevEnd = expandedPixelRange(ranges[0])[1];
+                  for (j2 = 1; j2 < ranges.length; j2++) {
+                    var nextRange = expandedPixelRange(ranges[j2]);
+                    for (k2 = prevEnd + 1; k2 < nextRange[0]; k2++) {
+                      mask[k2 * 8 + v2] &= ~bitMask;
+                    }
+                    prevEnd = Math.max(prevEnd, nextRange[1]);
+                  }
+                }
+              }
+              var textureData = {
+                // 8 units x 8 bits = 64 bits, just sufficient for the almost 64 dimensions we support
+                shape: [8, maskHeight],
+                format: "alpha",
+                type: "uint8",
+                mag: "nearest",
+                min: "nearest",
+                data: mask
+              };
+              if (maskTexture) maskTexture(textureData);
+              else maskTexture = regl.texture(textureData);
+              return {
+                maskTexture,
+                maskHeight,
+                loA: limits[0].slice(0, 16),
+                loB: limits[0].slice(16, 32),
+                loC: limits[0].slice(32, 48),
+                loD: limits[0].slice(48, 64),
+                hiA: limits[1].slice(0, 16),
+                hiB: limits[1].slice(16, 32),
+                hiC: limits[1].slice(32, 48),
+                hiD: limits[1].slice(48, 64)
+              };
+            }
+            function renderGLParcoords(panels, setChanged, clearOnly) {
+              var panelCount = panels.length;
+              var i2;
+              var leftmost;
+              var rightmost;
+              var lowestX = Infinity;
+              var highestX = -Infinity;
+              for (i2 = 0; i2 < panelCount; i2++) {
+                if (panels[i2].dim0.canvasX < lowestX) {
+                  lowestX = panels[i2].dim0.canvasX;
+                  leftmost = i2;
+                }
+                if (panels[i2].dim1.canvasX > highestX) {
+                  highestX = panels[i2].dim1.canvasX;
+                  rightmost = i2;
+                }
+              }
+              if (panelCount === 0) {
+                clear(regl, 0, 0, model.canvasWidth, model.canvasHeight);
+              }
+              var constraints = makeConstraints(isContext);
+              for (i2 = 0; i2 < panelCount; i2++) {
+                var p2 = panels[i2];
+                var i0 = p2.dim0.crossfilterDimensionIndex;
+                var i1 = p2.dim1.crossfilterDimensionIndex;
+                var x2 = p2.canvasX;
+                var y2 = p2.canvasY;
+                var nextX = x2 + p2.panelSizeX;
+                var plotGlPixelRatio2 = p2.plotGlPixelRatio;
+                if (setChanged || !prevAxisOrder[i0] || prevAxisOrder[i0][0] !== x2 || prevAxisOrder[i0][1] !== nextX) {
+                  prevAxisOrder[i0] = [x2, nextX];
+                  var item = makeItem(
+                    model,
+                    leftmost,
+                    rightmost,
+                    i2,
+                    i0,
+                    i1,
+                    x2,
+                    y2,
+                    p2.panelSizeX,
+                    p2.panelSizeY,
+                    p2.dim0.crossfilterDimensionIndex,
+                    isContext ? 0 : isPick ? 2 : 1,
+                    constraints,
+                    plotGlPixelRatio2
+                  );
+                  renderState.clearOnly = clearOnly;
+                  var blockLineCount = setChanged ? model.lines.blockLineCount : sampleCount;
+                  renderBlock(
+                    regl,
+                    glAes,
+                    renderState,
+                    blockLineCount,
+                    sampleCount,
+                    item
+                  );
+                }
+              }
+            }
+            function readPixel(canvasX, canvasY) {
+              regl.read({
+                x: canvasX,
+                y: canvasY,
+                width: 1,
+                height: 1,
+                data: dataPixel
+              });
+              return dataPixel;
+            }
+            function readPixels(canvasX, canvasY, width, height) {
+              var pixelArray = new Uint8Array(4 * width * height);
+              regl.read({
+                x: canvasX,
+                y: canvasY,
+                width,
+                height,
+                data: pixelArray
+              });
+              return pixelArray;
+            }
+            function destroy() {
+              canvasGL.style["pointer-events"] = "none";
+              paletteTexture.destroy();
+              if (maskTexture) maskTexture.destroy();
+              for (var k2 in attributes) attributes[k2].destroy();
+            }
+            return {
+              render: renderGLParcoords,
+              readPixel,
+              readPixels,
+              destroy,
+              update
+            };
+          };
+        }
+      });
+      var require_parcoords = __commonJS({
+        "src/traces/parcoords/parcoords.js"(exports, module2) {
+          var d3 = require_d3();
+          var Lib = require_lib();
+          var isArrayOrTypedArray = Lib.isArrayOrTypedArray;
+          var numberFormat = Lib.numberFormat;
+          var rgba3 = (init_color_rgba(), __toCommonJS(color_rgba_exports)).default;
+          var Axes = require_axes();
+          var strRotate = Lib.strRotate;
+          var strTranslate = Lib.strTranslate;
+          var svgTextUtils = require_svg_text_utils();
+          var Drawing = require_drawing();
+          var Colorscale = require_colorscale();
+          var gup = require_gup();
+          var keyFun = gup.keyFun;
+          var repeat = gup.repeat;
+          var unwrap = gup.unwrap;
+          var helpers = require_helpers18();
+          var c2 = require_constants24();
+          var brush = require_axisbrush();
+          var lineLayerMaker = require_lines();
+          function findExtreme(fn, values, len2) {
+            return Lib.aggNums(fn, null, values, len2);
+          }
+          function findExtremes(values, len2) {
+            return fixExtremes(
+              findExtreme(Math.min, values, len2),
+              findExtreme(Math.max, values, len2)
+            );
+          }
+          function dimensionExtent(dimension) {
+            var range = dimension.range;
+            return range ? fixExtremes(range[0], range[1]) : findExtremes(dimension.values, dimension._length);
+          }
+          function fixExtremes(lo, hi2) {
+            if (isNaN(lo) || !isFinite(lo)) {
+              lo = 0;
+            }
+            if (isNaN(hi2) || !isFinite(hi2)) {
+              hi2 = 0;
+            }
+            if (lo === hi2) {
+              if (lo === 0) {
+                lo -= 1;
+                hi2 += 1;
+              } else {
+                lo *= 0.9;
+                hi2 *= 1.1;
+              }
+            }
+            return [lo, hi2];
+          }
+          function toText(formatter, texts) {
+            if (texts) {
+              return function(v2, i2) {
+                var text = texts[i2];
+                if (text === null || text === void 0) return formatter(v2);
+                return text;
+              };
+            }
+            return formatter;
+          }
+          function domainScale(height, padding, dimension, tickvals, ticktext) {
+            var extent = dimensionExtent(dimension);
+            if (tickvals) {
+              return d3.scale.ordinal().domain(tickvals.map(toText(numberFormat(dimension.tickformat), ticktext))).range(
+                tickvals.map(function(d2) {
+                  var unitVal = (d2 - extent[0]) / (extent[1] - extent[0]);
+                  return height - padding + unitVal * (2 * padding - height);
+                })
+              );
+            }
+            return d3.scale.linear().domain(extent).range([height - padding, padding]);
+          }
+          function unitToPaddedPx(height, padding) {
+            return d3.scale.linear().range([padding, height - padding]);
+          }
+          function domainToPaddedUnitScale(dimension, padFraction) {
+            return d3.scale.linear().domain(dimensionExtent(dimension)).range([padFraction, 1 - padFraction]);
+          }
+          function ordinalScale(dimension) {
+            if (!dimension.tickvals) return;
+            var extent = dimensionExtent(dimension);
+            return d3.scale.ordinal().domain(dimension.tickvals).range(dimension.tickvals.map(function(d2) {
+              return (d2 - extent[0]) / (extent[1] - extent[0]);
+            }));
+          }
+          function unitToColorScale(cscale) {
+            var colorStops = cscale.map(function(d2) {
+              return d2[0];
+            });
+            var colorTuples = cscale.map(function(d2) {
+              var RGBA = rgba3(d2[1]);
+              return d3.rgb("rgb(" + RGBA[0] + "," + RGBA[1] + "," + RGBA[2] + ")");
+            });
+            var prop = function(n2) {
+              return function(o2) {
+                return o2[n2];
+              };
+            };
+            var polylinearUnitScales = "rgb".split("").map(function(key) {
+              return d3.scale.linear().clamp(true).domain(colorStops).range(colorTuples.map(prop(key)));
+            });
+            return function(d2) {
+              return polylinearUnitScales.map(function(s2) {
+                return s2(d2);
+              });
+            };
+          }
+          function someFiltersActive(view) {
+            return view.dimensions.some(function(p2) {
+              return p2.brush.filterSpecified;
+            });
+          }
+          function model(layout, d2, i2) {
+            var cd0 = unwrap(d2);
+            var trace = cd0.trace;
+            var lineColor = helpers.convertTypedArray(cd0.lineColor);
+            var line = trace.line;
+            var deselectedLines = {
+              color: rgba3(trace.unselected.line.color),
+              opacity: trace.unselected.line.opacity
+            };
+            var cOpts = Colorscale.extractOpts(line);
+            var cscale = cOpts.reversescale ? Colorscale.flipScale(cd0.cscale) : cd0.cscale;
+            var domain = trace.domain;
+            var dimensions = trace.dimensions;
+            var width = layout.width;
+            var labelAngle = trace.labelangle;
+            var labelSide = trace.labelside;
+            var labelFont = trace.labelfont;
+            var tickFont = trace.tickfont;
+            var rangeFont = trace.rangefont;
+            var lines = Lib.extendDeepNoArrays({}, line, {
+              color: lineColor.map(d3.scale.linear().domain(
+                dimensionExtent({
+                  values: lineColor,
+                  range: [cOpts.min, cOpts.max],
+                  _length: trace._length
+                })
+              )),
+              blockLineCount: c2.blockLineCount,
+              canvasOverdrag: c2.overdrag * c2.canvasPixelRatio
+            });
+            var groupWidth = Math.floor(width * (domain.x[1] - domain.x[0]));
+            var groupHeight = Math.floor(layout.height * (domain.y[1] - domain.y[0]));
+            var pad = layout.margin || { l: 80, r: 80, t: 100, b: 80 };
+            var rowContentWidth = groupWidth;
+            var rowHeight = groupHeight;
+            return {
+              key: i2,
+              colCount: dimensions.filter(helpers.isVisible).length,
+              dimensions,
+              tickDistance: c2.tickDistance,
+              unitToColor: unitToColorScale(cscale),
+              lines,
+              deselectedLines,
+              labelAngle,
+              labelSide,
+              labelFont,
+              tickFont,
+              rangeFont,
+              layoutWidth: width,
+              layoutHeight: layout.height,
+              domain,
+              translateX: domain.x[0] * width,
+              translateY: layout.height - domain.y[1] * layout.height,
+              pad,
+              canvasWidth: rowContentWidth * c2.canvasPixelRatio + 2 * lines.canvasOverdrag,
+              canvasHeight: rowHeight * c2.canvasPixelRatio,
+              width: rowContentWidth,
+              height: rowHeight,
+              canvasPixelRatio: c2.canvasPixelRatio
+            };
+          }
+          function viewModel(state, callbacks, model2) {
+            var width = model2.width;
+            var height = model2.height;
+            var dimensions = model2.dimensions;
+            var canvasPixelRatio = model2.canvasPixelRatio;
+            var xScale = function(d2) {
+              return width * d2 / Math.max(1, model2.colCount - 1);
+            };
+            var unitPad = c2.verticalPadding / height;
+            var _unitToPaddedPx = unitToPaddedPx(height, c2.verticalPadding);
+            var vm = {
+              key: model2.key,
+              xScale,
+              model: model2,
+              inBrushDrag: false
+              // consider factoring it out and putting it in a centralized global-ish gesture state object
+            };
+            var uniqueKeys = {};
+            vm.dimensions = dimensions.filter(helpers.isVisible).map(function(dimension, i2) {
+              var domainToPaddedUnit = domainToPaddedUnitScale(dimension, unitPad);
+              var foundKey = uniqueKeys[dimension.label];
+              uniqueKeys[dimension.label] = (foundKey || 0) + 1;
+              var key = dimension.label + (foundKey ? "__" + foundKey : "");
+              var specifiedConstraint = dimension.constraintrange;
+              var filterRangeSpecified = specifiedConstraint && specifiedConstraint.length;
+              if (filterRangeSpecified && !isArrayOrTypedArray(specifiedConstraint[0])) {
+                specifiedConstraint = [specifiedConstraint];
+              }
+              var filterRange = filterRangeSpecified ? specifiedConstraint.map(function(d2) {
+                return d2.map(domainToPaddedUnit);
+              }) : [[-Infinity, Infinity]];
+              var brushMove = function() {
+                var p2 = vm;
+                p2.focusLayer && p2.focusLayer.render(p2.panels, true);
+                var filtersActive = someFiltersActive(p2);
+                if (!state.contextShown() && filtersActive) {
+                  p2.contextLayer && p2.contextLayer.render(p2.panels, true);
+                  state.contextShown(true);
+                } else if (state.contextShown() && !filtersActive) {
+                  p2.contextLayer && p2.contextLayer.render(p2.panels, true, true);
+                  state.contextShown(false);
+                }
+              };
+              var truncatedValues = dimension.values;
+              if (truncatedValues.length > dimension._length) {
+                truncatedValues = truncatedValues.slice(0, dimension._length);
+              }
+              var tickvals = dimension.tickvals;
+              var ticktext;
+              function makeTickItem(v2, i22) {
+                return { val: v2, text: ticktext[i22] };
+              }
+              function sortTickItem(a2, b2) {
+                return a2.val - b2.val;
+              }
+              if (isArrayOrTypedArray(tickvals) && tickvals.length) {
+                if (Lib.isTypedArray(tickvals)) tickvals = Array.from(tickvals);
+                ticktext = dimension.ticktext;
+                if (!isArrayOrTypedArray(ticktext) || !ticktext.length) {
+                  ticktext = tickvals.map(numberFormat(dimension.tickformat));
+                } else if (ticktext.length > tickvals.length) {
+                  ticktext = ticktext.slice(0, tickvals.length);
+                } else if (tickvals.length > ticktext.length) {
+                  tickvals = tickvals.slice(0, ticktext.length);
+                }
+                for (var j2 = 1; j2 < tickvals.length; j2++) {
+                  if (tickvals[j2] < tickvals[j2 - 1]) {
+                    var tickItems = tickvals.map(makeTickItem).sort(sortTickItem);
+                    for (var k2 = 0; k2 < tickvals.length; k2++) {
+                      tickvals[k2] = tickItems[k2].val;
+                      ticktext[k2] = tickItems[k2].text;
+                    }
+                    break;
+                  }
+                }
+              } else tickvals = void 0;
+              truncatedValues = helpers.convertTypedArray(truncatedValues);
+              return {
+                key,
+                label: dimension.label,
+                tickFormat: dimension.tickformat,
+                tickvals,
+                ticktext,
+                ordinal: helpers.isOrdinal(dimension),
+                multiselect: dimension.multiselect,
+                xIndex: i2,
+                crossfilterDimensionIndex: i2,
+                visibleIndex: dimension._index,
+                height,
+                values: truncatedValues,
+                paddedUnitValues: truncatedValues.map(domainToPaddedUnit),
+                unitTickvals: tickvals && tickvals.map(domainToPaddedUnit),
+                xScale,
+                x: xScale(i2),
+                canvasX: xScale(i2) * canvasPixelRatio,
+                unitToPaddedPx: _unitToPaddedPx,
+                domainScale: domainScale(height, c2.verticalPadding, dimension, tickvals, ticktext),
+                ordinalScale: ordinalScale(dimension),
+                parent: vm,
+                model: model2,
+                brush: brush.makeBrush(
+                  state,
+                  filterRangeSpecified,
+                  filterRange,
+                  function() {
+                    state.linePickActive(false);
+                  },
+                  brushMove,
+                  function(f2) {
+                    vm.focusLayer.render(vm.panels, true);
+                    vm.pickLayer && vm.pickLayer.render(vm.panels, true);
+                    state.linePickActive(true);
+                    if (callbacks && callbacks.filterChanged) {
+                      var invScale = domainToPaddedUnit.invert;
+                      var newRanges = f2.map(function(r2) {
+                        return r2.map(invScale).sort(Lib.sorterAsc);
+                      }).sort(function(a2, b2) {
+                        return a2[0] - b2[0];
+                      });
+                      callbacks.filterChanged(vm.key, dimension._index, newRanges);
+                    }
+                  }
+                )
+              };
+            });
+            return vm;
+          }
+          function styleExtentTexts(selection) {
+            selection.classed(c2.cn.axisExtentText, true).attr("text-anchor", "middle").style("cursor", "default");
+          }
+          function parcoordsInteractionState() {
+            var linePickActive = true;
+            var contextShown = false;
+            return {
+              linePickActive: function(val) {
+                return arguments.length ? linePickActive = !!val : linePickActive;
+              },
+              contextShown: function(val) {
+                return arguments.length ? contextShown = !!val : contextShown;
+              }
+            };
+          }
+          function calcTilt(angle2, position) {
+            var dir = position === "top" ? 1 : -1;
+            var radians2 = angle2 * Math.PI / 180;
+            var dx = Math.sin(radians2);
+            var dy = Math.cos(radians2);
+            return {
+              dir,
+              dx,
+              dy,
+              degrees: angle2
+            };
+          }
+          function updatePanelLayout(yAxis, vm, plotGlPixelRatio) {
+            var panels = vm.panels || (vm.panels = []);
+            var data = yAxis.data();
+            for (var i2 = 0; i2 < data.length - 1; i2++) {
+              var p2 = panels[i2] || (panels[i2] = {});
+              var dim0 = data[i2];
+              var dim1 = data[i2 + 1];
+              p2.dim0 = dim0;
+              p2.dim1 = dim1;
+              p2.canvasX = dim0.canvasX;
+              p2.panelSizeX = dim1.canvasX - dim0.canvasX;
+              p2.panelSizeY = vm.model.canvasHeight;
+              p2.y = 0;
+              p2.canvasY = 0;
+              p2.plotGlPixelRatio = plotGlPixelRatio;
+            }
+          }
+          function calcAllTicks(cd2) {
+            for (var i2 = 0; i2 < cd2.length; i2++) {
+              for (var j2 = 0; j2 < cd2[i2].length; j2++) {
+                var trace = cd2[i2][j2].trace;
+                var dimensions = trace.dimensions;
+                for (var k2 = 0; k2 < dimensions.length; k2++) {
+                  var values = dimensions[k2].values;
+                  var dim = dimensions[k2]._ax;
+                  if (dim) {
+                    if (!dim.range) {
+                      dim.range = findExtremes(values, trace._length);
+                    } else {
+                      dim.range = fixExtremes(dim.range[0], dim.range[1]);
+                    }
+                    if (!dim.dtick) {
+                      dim.dtick = 0.01 * (Math.abs(dim.range[1] - dim.range[0]) || 1);
+                    }
+                    dim.tickformat = dimensions[k2].tickformat;
+                    Axes.calcTicks(dim);
+                    dim.cleanRange();
+                  }
+                }
+              }
+            }
+          }
+          function linearFormat(dim, v2) {
+            return Axes.tickText(dim._ax, v2, false).text;
+          }
+          function extremeText(d2, isTop) {
+            if (d2.ordinal) return "";
+            var domain = d2.domainScale.domain();
+            var v2 = domain[isTop ? domain.length - 1 : 0];
+            return linearFormat(d2.model.dimensions[d2.visibleIndex], v2);
+          }
+          module2.exports = function parcoords(gd2, cdModule, layout, callbacks) {
+            var isStatic = gd2._context.staticPlot;
+            var fullLayout = gd2._fullLayout;
+            var svg = fullLayout._toppaper;
+            var glContainer = fullLayout._glcontainer;
+            var plotGlPixelRatio = gd2._context.plotGlPixelRatio;
+            var paperColor = gd2._fullLayout.paper_bgcolor;
+            calcAllTicks(cdModule);
+            var state = parcoordsInteractionState();
+            var vm = cdModule.filter(function(d2) {
+              return unwrap(d2).trace.visible;
+            }).map(model.bind(0, layout)).map(viewModel.bind(0, state, callbacks));
+            glContainer.each(function(d2, i2) {
+              return Lib.extendFlat(d2, vm[i2]);
+            });
+            var glLayers = glContainer.selectAll(".gl-canvas").each(function(d2) {
+              d2.viewModel = vm[0];
+              d2.viewModel.plotGlPixelRatio = plotGlPixelRatio;
+              d2.viewModel.paperColor = paperColor;
+              d2.model = d2.viewModel ? d2.viewModel.model : null;
+            });
+            var lastHovered = null;
+            var pickLayer = glLayers.filter(function(d2) {
+              return d2.pick;
+            });
+            pickLayer.style("pointer-events", isStatic ? "none" : "auto").on("mousemove", function(d2) {
+              if (state.linePickActive() && d2.lineLayer && callbacks && callbacks.hover) {
+                var event = d3.event;
+                var cw = this.width;
+                var ch2 = this.height;
+                var pointer = d3.mouse(this);
+                var x2 = pointer[0];
+                var y2 = pointer[1];
+                if (x2 < 0 || y2 < 0 || x2 >= cw || y2 >= ch2) {
+                  return;
+                }
+                var pixel = d2.lineLayer.readPixel(x2, ch2 - 1 - y2);
+                var found = pixel[3] !== 0;
+                var curveNumber = found ? pixel[2] + 256 * (pixel[1] + 256 * pixel[0]) : null;
+                var eventData = {
+                  x: x2,
+                  y: y2,
+                  clientX: event.clientX,
+                  clientY: event.clientY,
+                  dataIndex: d2.model.key,
+                  curveNumber
+                };
+                if (curveNumber !== lastHovered) {
+                  if (found) {
+                    callbacks.hover(eventData);
+                  } else if (callbacks.unhover) {
+                    callbacks.unhover(eventData);
+                  }
+                  lastHovered = curveNumber;
+                }
+              }
+            });
+            glLayers.style("opacity", function(d2) {
+              return d2.pick ? 0 : 1;
+            });
+            svg.style("background", "rgba(255, 255, 255, 0)");
+            var controlOverlay = svg.selectAll("." + c2.cn.parcoords).data(vm, keyFun);
+            controlOverlay.exit().remove();
+            controlOverlay.enter().append("g").classed(c2.cn.parcoords, true).style("shape-rendering", "crispEdges").style("pointer-events", "none");
+            controlOverlay.attr("transform", function(d2) {
+              return strTranslate(d2.model.translateX, d2.model.translateY);
+            });
+            var parcoordsControlView = controlOverlay.selectAll("." + c2.cn.parcoordsControlView).data(repeat, keyFun);
+            parcoordsControlView.enter().append("g").classed(c2.cn.parcoordsControlView, true);
+            parcoordsControlView.attr("transform", function(d2) {
+              return strTranslate(d2.model.pad.l, d2.model.pad.t);
+            });
+            var yAxis = parcoordsControlView.selectAll("." + c2.cn.yAxis).data(function(p2) {
+              return p2.dimensions;
+            }, keyFun);
+            yAxis.enter().append("g").classed(c2.cn.yAxis, true);
+            parcoordsControlView.each(function(p2) {
+              updatePanelLayout(yAxis, p2, plotGlPixelRatio);
+            });
+            glLayers.each(function(d2) {
+              if (d2.viewModel) {
+                if (!d2.lineLayer || callbacks) {
+                  d2.lineLayer = lineLayerMaker(this, d2);
+                } else d2.lineLayer.update(d2);
+                if (d2.key || d2.key === 0) d2.viewModel[d2.key] = d2.lineLayer;
+                var setChanged = !d2.context || // don't update background
+                callbacks;
+                d2.lineLayer.render(d2.viewModel.panels, setChanged);
+              }
+            });
+            yAxis.attr("transform", function(d2) {
+              return strTranslate(d2.xScale(d2.xIndex), 0);
+            });
+            yAxis.call(
+              d3.behavior.drag().origin(function(d2) {
+                return d2;
+              }).on("drag", function(d2) {
+                var p2 = d2.parent;
+                state.linePickActive(false);
+                d2.x = Math.max(-c2.overdrag, Math.min(d2.model.width + c2.overdrag, d3.event.x));
+                d2.canvasX = d2.x * d2.model.canvasPixelRatio;
+                yAxis.sort(function(a2, b2) {
+                  return a2.x - b2.x;
+                }).each(function(e2, i2) {
+                  e2.xIndex = i2;
+                  e2.x = d2 === e2 ? e2.x : e2.xScale(e2.xIndex);
+                  e2.canvasX = e2.x * e2.model.canvasPixelRatio;
+                });
+                updatePanelLayout(yAxis, p2, plotGlPixelRatio);
+                yAxis.filter(function(e2) {
+                  return Math.abs(d2.xIndex - e2.xIndex) !== 0;
+                }).attr("transform", function(d22) {
+                  return strTranslate(d22.xScale(d22.xIndex), 0);
+                });
+                d3.select(this).attr("transform", strTranslate(d2.x, 0));
+                yAxis.each(function(e2, i0, i1) {
+                  if (i1 === d2.parent.key) p2.dimensions[i0] = e2;
+                });
+                p2.contextLayer && p2.contextLayer.render(p2.panels, false, !someFiltersActive(p2));
+                p2.focusLayer.render && p2.focusLayer.render(p2.panels);
+              }).on("dragend", function(d2) {
+                var p2 = d2.parent;
+                d2.x = d2.xScale(d2.xIndex);
+                d2.canvasX = d2.x * d2.model.canvasPixelRatio;
+                updatePanelLayout(yAxis, p2, plotGlPixelRatio);
+                d3.select(this).attr("transform", function(d22) {
+                  return strTranslate(d22.x, 0);
+                });
+                p2.contextLayer && p2.contextLayer.render(p2.panels, false, !someFiltersActive(p2));
+                p2.focusLayer && p2.focusLayer.render(p2.panels);
+                p2.pickLayer && p2.pickLayer.render(p2.panels, true);
+                state.linePickActive(true);
+                if (callbacks && callbacks.axesMoved) {
+                  callbacks.axesMoved(p2.key, p2.dimensions.map(function(e2) {
+                    return e2.crossfilterDimensionIndex;
+                  }));
+                }
+              })
+            );
+            yAxis.exit().remove();
+            var axisOverlays = yAxis.selectAll("." + c2.cn.axisOverlays).data(repeat, keyFun);
+            axisOverlays.enter().append("g").classed(c2.cn.axisOverlays, true);
+            axisOverlays.selectAll("." + c2.cn.axis).remove();
+            var axis = axisOverlays.selectAll("." + c2.cn.axis).data(repeat, keyFun);
+            axis.enter().append("g").classed(c2.cn.axis, true);
+            axis.each(function(d2) {
+              var wantedTickCount = d2.model.height / d2.model.tickDistance;
+              var scale2 = d2.domainScale;
+              var sdom = scale2.domain();
+              d3.select(this).call(d3.svg.axis().orient("left").tickSize(4).outerTickSize(2).ticks(wantedTickCount, d2.tickFormat).tickValues(d2.ordinal ? (
+                // and this works for ordinal scales
+                sdom
+              ) : null).tickFormat(function(v2) {
+                return helpers.isOrdinal(d2) ? v2 : linearFormat(d2.model.dimensions[d2.visibleIndex], v2);
+              }).scale(scale2));
+              Drawing.font(axis.selectAll("text"), d2.model.tickFont);
+            });
+            axis.selectAll(".domain, .tick>line").attr("fill", "none").attr("stroke", "black").attr("stroke-opacity", 0.25).attr("stroke-width", "1px");
+            axis.selectAll("text").style("cursor", "default");
+            var axisHeading = axisOverlays.selectAll("." + c2.cn.axisHeading).data(repeat, keyFun);
+            axisHeading.enter().append("g").classed(c2.cn.axisHeading, true);
+            var axisTitle = axisHeading.selectAll("." + c2.cn.axisTitle).data(repeat, keyFun);
+            axisTitle.enter().append("text").classed(c2.cn.axisTitle, true).attr("text-anchor", "middle").style("cursor", "ew-resize").style("pointer-events", isStatic ? "none" : "auto");
+            axisTitle.text(function(d2) {
+              return d2.label;
+            }).each(function(d2) {
+              var e2 = d3.select(this);
+              Drawing.font(e2, d2.model.labelFont);
+              svgTextUtils.convertToTspans(e2, gd2);
+            }).attr("transform", function(d2) {
+              var tilt = calcTilt(d2.model.labelAngle, d2.model.labelSide);
+              var r2 = c2.axisTitleOffset;
+              return (tilt.dir > 0 ? "" : strTranslate(0, 2 * r2 + d2.model.height)) + strRotate(tilt.degrees) + strTranslate(-r2 * tilt.dx, -r2 * tilt.dy);
+            }).attr("text-anchor", function(d2) {
+              var tilt = calcTilt(d2.model.labelAngle, d2.model.labelSide);
+              var adx = Math.abs(tilt.dx);
+              var ady = Math.abs(tilt.dy);
+              if (2 * adx > ady) {
+                return tilt.dir * tilt.dx < 0 ? "start" : "end";
+              } else {
+                return "middle";
+              }
+            });
+            var axisExtent = axisOverlays.selectAll("." + c2.cn.axisExtent).data(repeat, keyFun);
+            axisExtent.enter().append("g").classed(c2.cn.axisExtent, true);
+            var axisExtentTop = axisExtent.selectAll("." + c2.cn.axisExtentTop).data(repeat, keyFun);
+            axisExtentTop.enter().append("g").classed(c2.cn.axisExtentTop, true);
+            axisExtentTop.attr("transform", strTranslate(0, -c2.axisExtentOffset));
+            var axisExtentTopText = axisExtentTop.selectAll("." + c2.cn.axisExtentTopText).data(repeat, keyFun);
+            axisExtentTopText.enter().append("text").classed(c2.cn.axisExtentTopText, true).call(styleExtentTexts);
+            axisExtentTopText.text(function(d2) {
+              return extremeText(d2, true);
+            }).each(function(d2) {
+              Drawing.font(d3.select(this), d2.model.rangeFont);
+            });
+            var axisExtentBottom = axisExtent.selectAll("." + c2.cn.axisExtentBottom).data(repeat, keyFun);
+            axisExtentBottom.enter().append("g").classed(c2.cn.axisExtentBottom, true);
+            axisExtentBottom.attr("transform", function(d2) {
+              return strTranslate(0, d2.model.height + c2.axisExtentOffset);
+            });
+            var axisExtentBottomText = axisExtentBottom.selectAll("." + c2.cn.axisExtentBottomText).data(repeat, keyFun);
+            axisExtentBottomText.enter().append("text").classed(c2.cn.axisExtentBottomText, true).attr("dy", "0.75em").call(styleExtentTexts);
+            axisExtentBottomText.text(function(d2) {
+              return extremeText(d2, false);
+            }).each(function(d2) {
+              Drawing.font(d3.select(this), d2.model.rangeFont);
+            });
+            brush.ensureAxisBrush(axisOverlays, paperColor, gd2);
+          };
+        }
+      });
+      var require_plot21 = __commonJS({
+        "src/traces/parcoords/plot.js"(exports, module2) {
+          var parcoords = require_parcoords();
+          var prepareRegl = require_prepare_regl();
+          var isVisible = require_helpers18().isVisible;
+          var reglPrecompiled = {};
+          function newIndex(visibleIndices, orig, dim) {
+            var origIndex = orig.indexOf(dim);
+            var currentIndex = visibleIndices.indexOf(origIndex);
+            if (currentIndex === -1) {
+              currentIndex += orig.length;
+            }
+            return currentIndex;
+          }
+          function sorter(visibleIndices, orig) {
+            return function sorter2(d1, d2) {
+              return newIndex(visibleIndices, orig, d1) - newIndex(visibleIndices, orig, d2);
+            };
+          }
+          var exports = module2.exports = function plot(gd2, cdModule) {
+            var fullLayout = gd2._fullLayout;
+            var success = prepareRegl(gd2, [], reglPrecompiled);
+            if (!success) return;
+            var currentDims = {};
+            var initialDims = {};
+            var fullIndices = {};
+            var inputIndices = {};
+            var size = fullLayout._size;
+            cdModule.forEach(function(d2, i2) {
+              var trace = d2[0].trace;
+              fullIndices[i2] = trace.index;
+              var iIn = inputIndices[i2] = trace.index;
+              currentDims[i2] = gd2.data[iIn].dimensions;
+              initialDims[i2] = gd2.data[iIn].dimensions.slice();
+            });
+            var filterChanged = function(i2, initialDimIndex, newRanges) {
+              var dim = initialDims[i2][initialDimIndex];
+              var newConstraints = newRanges.map(function(r2) {
+                return r2.slice();
+              });
+              var aStr = "dimensions[" + initialDimIndex + "].constraintrange";
+              var preGUI = fullLayout._tracePreGUI[gd2._fullData[fullIndices[i2]]._fullInput.uid];
+              if (preGUI[aStr] === void 0) {
+                var initialVal = dim.constraintrange;
+                preGUI[aStr] = initialVal || null;
+              }
+              var fullDimension = gd2._fullData[fullIndices[i2]].dimensions[initialDimIndex];
+              if (!newConstraints.length) {
+                delete dim.constraintrange;
+                delete fullDimension.constraintrange;
+                newConstraints = null;
+              } else {
+                if (newConstraints.length === 1) newConstraints = newConstraints[0];
+                dim.constraintrange = newConstraints;
+                fullDimension.constraintrange = newConstraints.slice();
+                newConstraints = [newConstraints];
+              }
+              var restyleData = {};
+              restyleData[aStr] = newConstraints;
+              gd2.emit("plotly_restyle", [restyleData, [inputIndices[i2]]]);
+            };
+            var hover = function(eventData) {
+              gd2.emit("plotly_hover", eventData);
+            };
+            var unhover = function(eventData) {
+              gd2.emit("plotly_unhover", eventData);
+            };
+            var axesMoved = function(i2, visibleIndices) {
+              var orig = sorter(visibleIndices, initialDims[i2].filter(isVisible));
+              currentDims[i2].sort(orig);
+              initialDims[i2].filter(function(d2) {
+                return !isVisible(d2);
+              }).sort(function(d2) {
+                return initialDims[i2].indexOf(d2);
+              }).forEach(function(d2) {
+                currentDims[i2].splice(currentDims[i2].indexOf(d2), 1);
+                currentDims[i2].splice(initialDims[i2].indexOf(d2), 0, d2);
+              });
+              gd2.emit("plotly_restyle", [{ dimensions: [currentDims[i2]] }, [inputIndices[i2]]]);
+            };
+            parcoords(
+              gd2,
+              cdModule,
+              {
+                // layout
+                width: size.w,
+                height: size.h,
+                margin: {
+                  t: size.t,
+                  r: size.r,
+                  b: size.b,
+                  l: size.l
+                }
+              },
+              {
+                // callbacks
+                filterChanged,
+                hover,
+                unhover,
+                axesMoved
+              }
+            );
+          };
+          exports.reglPrecompiled = reglPrecompiled;
+        }
+      });
+      var require_base_plot7 = __commonJS({
+        "src/traces/parcoords/base_plot.js"(exports) {
+          var d3 = require_d3();
+          var getModuleCalcData = require_get_data().getModuleCalcData;
+          var parcoordsPlot = require_plot21();
+          var xmlnsNamespaces = require_xmlns_namespaces();
+          exports.name = "parcoords";
+          exports.plot = function(gd2) {
+            var calcData = getModuleCalcData(gd2.calcdata, "parcoords")[0];
+            if (calcData.length) parcoordsPlot(gd2, calcData);
+          };
+          exports.clean = function(newFullData, newFullLayout, oldFullData, oldFullLayout) {
+            var hadParcoords = oldFullLayout._has && oldFullLayout._has("parcoords");
+            var hasParcoords = newFullLayout._has && newFullLayout._has("parcoords");
+            if (hadParcoords && !hasParcoords) {
+              oldFullLayout._paperdiv.selectAll(".parcoords").remove();
+              oldFullLayout._glimages.selectAll("*").remove();
+            }
+          };
+          exports.toSVG = function(gd2) {
+            var imageRoot = gd2._fullLayout._glimages;
+            var root = d3.select(gd2).selectAll(".svg-container");
+            var canvases = root.filter(function(d2, i2) {
+              return i2 === root.size() - 1;
+            }).selectAll(".gl-canvas-context, .gl-canvas-focus");
+            function canvasToImage() {
+              var canvas2 = this;
+              var imageData = canvas2.toDataURL("image/png");
+              var image = imageRoot.append("svg:image");
+              image.attr({
+                xmlns: xmlnsNamespaces.svg,
+                "xlink:href": imageData,
+                preserveAspectRatio: "none",
+                x: 0,
+                y: 0,
+                width: canvas2.style.width,
+                height: canvas2.style.height
+              });
+            }
+            canvases.each(canvasToImage);
+            window.setTimeout(function() {
+              d3.selectAll("#filterBarPattern").attr("id", "filterBarPattern");
+            }, 60);
+          };
+        }
+      });
+      var require_base_index3 = __commonJS({
+        "src/traces/parcoords/base_index.js"(exports, module2) {
+          module2.exports = {
+            attributes: require_attributes52(),
+            supplyDefaults: require_defaults48(),
+            calc: require_calc31(),
+            colorbar: {
+              container: "line",
+              min: "cmin",
+              max: "cmax"
+            },
+            moduleType: "trace",
+            name: "parcoords",
+            basePlotModule: require_base_plot7(),
+            categories: ["gl", "regl", "noOpacity", "noHover"],
+            meta: {}
+          };
+        }
+      });
+      var require_parcoords2 = __commonJS({
+        "src/traces/parcoords/index.js"(exports, module2) {
+          var index = require_base_index3();
+          index.plot = require_plot21();
+          module2.exports = index;
+        }
+      });
+      var require_parcoords3 = __commonJS({
+        "lib/parcoords.js"(exports, module2) {
+          module2.exports = require_parcoords2();
+        }
+      });
+      var require_attributes53 = __commonJS({
+        "src/traces/parcats/attributes.js"(exports, module2) {
+          var extendFlat = require_extend().extendFlat;
+          var baseAttrs = require_attributes2();
+          var fontAttrs = require_font_attributes();
+          var colorScaleAttrs = require_attributes8();
+          var { hovertemplateAttrs, templatefallbackAttrs } = require_template_attributes();
+          var domainAttrs = require_domain().attributes;
+          var line = extendFlat({ editType: "calc" }, colorScaleAttrs("line", { editTypeOverride: "calc" }), {
+            shape: {
+              valType: "enumerated",
+              values: ["linear", "hspline"],
+              dflt: "linear",
+              editType: "plot"
+            },
+            hovertemplate: hovertemplateAttrs(
+              {
+                editType: "plot",
+                arrayOk: false
+              },
+              {
+                keys: ["count", "probability"]
+              }
+            ),
+            hovertemplatefallback: templatefallbackAttrs({ editType: "plot" })
+          });
+          module2.exports = {
+            domain: domainAttrs({ name: "parcats", trace: true, editType: "calc" }),
+            hoverinfo: extendFlat({}, baseAttrs.hoverinfo, {
+              flags: ["count", "probability"],
+              editType: "plot",
+              arrayOk: false
+            }),
+            hoveron: {
+              valType: "enumerated",
+              values: ["category", "color", "dimension"],
+              dflt: "category",
+              editType: "plot"
+            },
+            hovertemplate: hovertemplateAttrs(
+              {
+                editType: "plot",
+                arrayOk: false
+              },
+              {
+                keys: ["count", "probability", "category", "categorycount", "colorcount", "bandcolorcount"]
+              }
+            ),
+            hovertemplatefallback: templatefallbackAttrs({ editType: "plot" }),
+            arrangement: {
+              valType: "enumerated",
+              values: ["perpendicular", "freeform", "fixed"],
+              dflt: "perpendicular",
+              editType: "plot"
+            },
+            bundlecolors: {
+              valType: "boolean",
+              dflt: true,
+              editType: "plot"
+            },
+            sortpaths: {
+              valType: "enumerated",
+              values: ["forward", "backward"],
+              dflt: "forward",
+              editType: "plot"
+            },
+            labelfont: fontAttrs({
+              editType: "calc"
+            }),
+            tickfont: fontAttrs({
+              autoShadowDflt: true,
+              editType: "calc"
+            }),
+            dimensions: {
+              _isLinkedToArray: "dimension",
+              label: {
+                valType: "string",
+                editType: "calc"
+              },
+              categoryorder: {
+                valType: "enumerated",
+                values: ["trace", "category ascending", "category descending", "array"],
+                dflt: "trace",
+                editType: "calc"
+              },
+              categoryarray: {
+                valType: "data_array",
+                editType: "calc"
+              },
+              ticktext: {
+                valType: "data_array",
+                editType: "calc"
+              },
+              values: {
+                valType: "data_array",
+                dflt: [],
+                editType: "calc"
+              },
+              displayindex: {
+                valType: "integer",
+                editType: "calc"
+              },
+              editType: "calc",
+              visible: {
+                valType: "boolean",
+                dflt: true,
+                editType: "calc"
+              }
+            },
+            line,
+            counts: {
+              valType: "number",
+              min: 0,
+              dflt: 1,
+              arrayOk: true,
+              editType: "calc"
+            },
+            // Hide unsupported top-level properties from plot-schema
+            customdata: void 0,
+            hoverlabel: void 0,
+            ids: void 0,
+            legend: void 0,
+            legendgroup: void 0,
+            legendrank: void 0,
+            opacity: void 0,
+            selectedpoints: void 0,
+            showlegend: void 0
+          };
+        }
+      });
+      var require_defaults49 = __commonJS({
+        "src/traces/parcats/defaults.js"(exports, module2) {
+          var Lib = require_lib();
+          var hasColorscale = require_helpers().hasColorscale;
+          var colorscaleDefaults = require_defaults2();
+          var handleDomainDefaults = require_domain().defaults;
+          var handleArrayContainerDefaults = require_array_container_defaults();
+          var attributes = require_attributes53();
+          var mergeLength = require_merge_length();
+          var isTypedArraySpec = require_array().isTypedArraySpec;
+          function handleLineDefaults(traceIn, traceOut, defaultColor, layout, coerce) {
+            coerce("line.shape");
+            coerce("line.hovertemplate");
+            coerce("line.hovertemplatefallback");
+            var lineColor = coerce("line.color", layout.colorway[0]);
+            if (hasColorscale(traceIn, "line") && Lib.isArrayOrTypedArray(lineColor)) {
+              if (lineColor.length) {
+                coerce("line.colorscale");
+                colorscaleDefaults(traceIn, traceOut, layout, coerce, { prefix: "line.", cLetter: "c" });
+                return lineColor.length;
+              } else {
+                traceOut.line.color = defaultColor;
+              }
+            }
+            return Infinity;
+          }
+          function dimensionDefaults(dimensionIn, dimensionOut) {
+            function coerce(attr, dflt) {
+              return Lib.coerce(dimensionIn, dimensionOut, attributes.dimensions, attr, dflt);
+            }
+            var values = coerce("values");
+            var visible = coerce("visible");
+            if (!(values && values.length)) {
+              visible = dimensionOut.visible = false;
+            }
+            if (visible) {
+              coerce("label");
+              coerce("displayindex", dimensionOut._index);
+              var arrayIn = dimensionIn.categoryarray;
+              var isValidArray = Lib.isArrayOrTypedArray(arrayIn) && arrayIn.length > 0 || isTypedArraySpec(arrayIn);
+              var orderDefault;
+              if (isValidArray) orderDefault = "array";
+              var order = coerce("categoryorder", orderDefault);
+              if (order === "array") {
+                coerce("categoryarray");
+                coerce("ticktext");
+              } else {
+                delete dimensionIn.categoryarray;
+                delete dimensionIn.ticktext;
+              }
+              if (!isValidArray && order === "array") {
+                dimensionOut.categoryorder = "trace";
+              }
+            }
+          }
+          module2.exports = function supplyDefaults(traceIn, traceOut, defaultColor, layout) {
+            function coerce(attr, dflt) {
+              return Lib.coerce(traceIn, traceOut, attributes, attr, dflt);
+            }
+            var dimensions = handleArrayContainerDefaults(traceIn, traceOut, {
+              name: "dimensions",
+              handleItemDefaults: dimensionDefaults
+            });
+            var len2 = handleLineDefaults(traceIn, traceOut, defaultColor, layout, coerce);
+            handleDomainDefaults(traceOut, layout, coerce);
+            if (!Array.isArray(dimensions) || !dimensions.length) {
+              traceOut.visible = false;
+            }
+            mergeLength(traceOut, dimensions, "values", len2);
+            coerce("hoveron");
+            coerce("hovertemplate");
+            coerce("hovertemplatefallback");
+            coerce("arrangement");
+            coerce("bundlecolors");
+            coerce("sortpaths");
+            coerce("counts");
+            var layoutFont = layout.font;
+            Lib.coerceFont(coerce, "labelfont", layoutFont, {
+              overrideDflt: {
+                size: Math.round(layoutFont.size)
+              }
+            });
+            Lib.coerceFont(coerce, "tickfont", layoutFont, {
+              autoShadowDflt: true,
+              overrideDflt: {
+                size: Math.round(layoutFont.size / 1.2)
+              }
+            });
+          };
+        }
+      });
+      var require_calc32 = __commonJS({
+        "src/traces/parcats/calc.js"(exports, module2) {
+          var wrap = require_gup().wrap;
+          var hasColorscale = require_helpers().hasColorscale;
+          var colorscaleCalc = require_calc();
+          var filterUnique = require_filter_unique();
+          var Drawing = require_drawing();
+          var Lib = require_lib();
+          var isNumeric = require_fast_isnumeric();
+          module2.exports = function calc(gd2, trace) {
+            var visibleDims = Lib.filterVisible(trace.dimensions);
+            if (visibleDims.length === 0) return [];
+            var uniqueInfoDims = visibleDims.map(function(dim) {
+              var categoryValues;
+              if (dim.categoryorder === "trace") {
+                categoryValues = null;
+              } else if (dim.categoryorder === "array") {
+                categoryValues = dim.categoryarray;
+              } else {
+                categoryValues = filterUnique(dim.values);
+                var allNumeric = true;
+                for (var i2 = 0; i2 < categoryValues.length; i2++) {
+                  if (!isNumeric(categoryValues[i2])) {
+                    allNumeric = false;
+                    break;
+                  }
+                }
+                categoryValues.sort(allNumeric ? Lib.sorterAsc : void 0);
+                if (dim.categoryorder === "category descending") {
+                  categoryValues = categoryValues.reverse();
+                }
+              }
+              return getUniqueInfo(dim.values, categoryValues);
+            });
+            var counts, count2, totalCount;
+            if (Lib.isArrayOrTypedArray(trace.counts)) {
+              counts = trace.counts;
+            } else {
+              counts = [trace.counts];
+            }
+            validateDimensionDisplayInds(visibleDims);
+            visibleDims.forEach(function(dim, dimInd) {
+              validateCategoryProperties(dim, uniqueInfoDims[dimInd]);
+            });
+            var line = trace.line;
+            var markerColorscale;
+            if (line) {
+              if (hasColorscale(trace, "line")) {
+                colorscaleCalc(gd2, trace, {
+                  vals: trace.line.color,
+                  containerStr: "line",
+                  cLetter: "c"
+                });
+              }
+              markerColorscale = Drawing.tryColorscale(line);
+            } else {
+              markerColorscale = Lib.identity;
+            }
+            function getMarkerColorInfo(index) {
+              var value, rawColor;
+              if (Lib.isArrayOrTypedArray(line.color)) {
+                value = line.color[index % line.color.length];
+                rawColor = value;
+              } else {
+                value = line.color;
+              }
+              return { color: markerColorscale(value), rawColor };
+            }
+            var numValues = visibleDims[0].values.length;
+            var pathModels = {};
+            var categoryIndsDims = uniqueInfoDims.map(function(di2) {
+              return di2.inds;
+            });
+            totalCount = 0;
+            var valueInd;
+            var d2;
+            for (valueInd = 0; valueInd < numValues; valueInd++) {
+              var categoryIndsPath = [];
+              for (d2 = 0; d2 < categoryIndsDims.length; d2++) {
+                categoryIndsPath.push(categoryIndsDims[d2][valueInd]);
+              }
+              count2 = counts[valueInd % counts.length];
+              totalCount += count2;
+              var pathColorInfo = getMarkerColorInfo(valueInd);
+              var pathKey = categoryIndsPath + "-" + pathColorInfo.rawColor;
+              if (pathModels[pathKey] === void 0) {
+                pathModels[pathKey] = createPathModel(
+                  categoryIndsPath,
+                  pathColorInfo.color,
+                  pathColorInfo.rawColor
+                );
+              }
+              updatePathModel(pathModels[pathKey], valueInd, count2);
+            }
+            var dimensionModels = visibleDims.map(function(di2, i2) {
+              return createDimensionModel(i2, di2._index, di2._displayindex, di2.label, totalCount);
+            });
+            for (valueInd = 0; valueInd < numValues; valueInd++) {
+              count2 = counts[valueInd % counts.length];
+              for (d2 = 0; d2 < dimensionModels.length; d2++) {
+                var containerInd = dimensionModels[d2].containerInd;
+                var catInd = uniqueInfoDims[d2].inds[valueInd];
+                var cats = dimensionModels[d2].categories;
+                if (cats[catInd] === void 0) {
+                  var catValue = trace.dimensions[containerInd]._categoryarray[catInd];
+                  var catLabel = trace.dimensions[containerInd]._ticktext[catInd];
+                  cats[catInd] = createCategoryModel(d2, catInd, catValue, catLabel);
+                }
+                updateCategoryModel(cats[catInd], valueInd, count2);
+              }
+            }
+            return wrap(createParcatsModel(dimensionModels, pathModels, totalCount));
+          };
+          function createParcatsModel(dimensions, paths, count2) {
+            var maxCats = dimensions.map(function(d2) {
+              return d2.categories.length;
+            }).reduce(function(v1, v2) {
+              return Math.max(v1, v2);
+            });
+            return { dimensions, paths, trace: void 0, maxCats, count: count2 };
+          }
+          function createDimensionModel(dimensionInd, containerInd, displayInd, dimensionLabel, count2) {
+            return {
+              dimensionInd,
+              containerInd,
+              displayInd,
+              dimensionLabel,
+              count: count2,
+              categories: [],
+              dragX: null
+            };
+          }
+          function createCategoryModel(dimensionInd, categoryInd, categoryValue, categoryLabel) {
+            return {
+              dimensionInd,
+              categoryInd,
+              categoryValue,
+              displayInd: categoryInd,
+              categoryLabel,
+              valueInds: [],
+              count: 0,
+              dragY: null
+            };
+          }
+          function updateCategoryModel(categoryModel, valueInd, count2) {
+            categoryModel.valueInds.push(valueInd);
+            categoryModel.count += count2;
+          }
+          function createPathModel(categoryInds, color22, rawColor) {
+            return {
+              categoryInds,
+              color: color22,
+              rawColor,
+              valueInds: [],
+              count: 0
+            };
+          }
+          function updatePathModel(pathModel, valueInd, count2) {
+            pathModel.valueInds.push(valueInd);
+            pathModel.count += count2;
+          }
+          function getUniqueInfo(values, uniqueValues) {
+            if (uniqueValues === void 0 || uniqueValues === null) {
+              uniqueValues = [];
+            } else {
+              uniqueValues = uniqueValues.map(function(e2) {
+                return e2;
+              });
+            }
+            var uniqueValueCounts = {};
+            var uniqueValueInds = {};
+            var inds = [];
+            uniqueValues.forEach(function(uniqueVal, valInd) {
+              uniqueValueCounts[uniqueVal] = 0;
+              uniqueValueInds[uniqueVal] = valInd;
+            });
+            for (var i2 = 0; i2 < values.length; i2++) {
+              var item = values[i2];
+              var itemInd;
+              if (uniqueValueCounts[item] === void 0) {
+                uniqueValueCounts[item] = 1;
+                itemInd = uniqueValues.push(item) - 1;
+                uniqueValueInds[item] = itemInd;
+              } else {
+                uniqueValueCounts[item]++;
+                itemInd = uniqueValueInds[item];
+              }
+              inds.push(itemInd);
+            }
+            var uniqueCounts = uniqueValues.map(function(v2) {
+              return uniqueValueCounts[v2];
+            });
+            return {
+              uniqueValues,
+              uniqueCounts,
+              inds
+            };
+          }
+          function validateDimensionDisplayInds(visibleDims) {
+            var displayInds = visibleDims.map(function(d2) {
+              return d2.displayindex;
+            });
+            var i2;
+            if (isRangePermutation(displayInds)) {
+              for (i2 = 0; i2 < visibleDims.length; i2++) {
+                visibleDims[i2]._displayindex = visibleDims[i2].displayindex;
+              }
+            } else {
+              for (i2 = 0; i2 < visibleDims.length; i2++) {
+                visibleDims[i2]._displayindex = i2;
+              }
+            }
+          }
+          function validateCategoryProperties(dim, uniqueInfoDim) {
+            dim._categoryarray = uniqueInfoDim.uniqueValues;
+            if (dim.ticktext === null || dim.ticktext === void 0) {
+              dim._ticktext = [];
+            } else {
+              dim._ticktext = dim.ticktext.slice();
+            }
+            for (var i2 = dim._ticktext.length; i2 < uniqueInfoDim.uniqueValues.length; i2++) {
+              dim._ticktext.push(uniqueInfoDim.uniqueValues[i2]);
+            }
+          }
+          function isRangePermutation(inds) {
+            var indsSpecified = new Array(inds.length);
+            for (var i2 = 0; i2 < inds.length; i2++) {
+              if (inds[i2] < 0 || inds[i2] >= inds.length) {
+                return false;
+              }
+              if (indsSpecified[inds[i2]] !== void 0) {
+                return false;
+              }
+              indsSpecified[inds[i2]] = true;
+            }
+            return true;
+          }
+        }
+      });
+      var require_parcats = __commonJS({
+        "src/traces/parcats/parcats.js"(exports, module2) {
+          var d3 = require_d3();
+          var interpolateNumber = (init_src2(), __toCommonJS(src_exports)).interpolateNumber;
+          var Plotly2 = require_plot_api();
+          var Fx = require_fx();
+          var Lib = require_lib();
+          var strTranslate = Lib.strTranslate;
+          var Drawing = require_drawing();
+          var tinycolor = require_tinycolor();
+          var svgTextUtils = require_svg_text_utils();
+          function performPlot(parcatsModels, graphDiv, layout, svg) {
+            var isStatic = graphDiv._context.staticPlot;
+            var viewModels = parcatsModels.map(createParcatsViewModel.bind(0, graphDiv, layout));
+            var layerSelection = svg.selectAll("g.parcatslayer").data([null]);
+            layerSelection.enter().append("g").attr("class", "parcatslayer").style("pointer-events", isStatic ? "none" : "all");
+            var traceSelection = layerSelection.selectAll("g.trace.parcats").data(viewModels, key);
+            var traceEnter = traceSelection.enter().append("g").attr("class", "trace parcats");
+            traceSelection.attr("transform", function(d2) {
+              return strTranslate(d2.x, d2.y);
+            });
+            traceEnter.append("g").attr("class", "paths");
+            var pathsSelection = traceSelection.select("g.paths");
+            var pathSelection = pathsSelection.selectAll("path.path").data(function(d2) {
+              return d2.paths;
+            }, key);
+            pathSelection.attr("fill", function(d2) {
+              return d2.model.color;
+            });
+            var pathSelectionEnter = pathSelection.enter().append("path").attr("class", "path").attr("stroke-opacity", 0).attr("fill", function(d2) {
+              return d2.model.color;
+            }).attr("fill-opacity", 0);
+            stylePathsNoHover(pathSelectionEnter);
+            pathSelection.attr("d", function(d2) {
+              return d2.svgD;
+            });
+            if (!pathSelectionEnter.empty()) {
+              pathSelection.sort(compareRawColor);
+            }
+            pathSelection.exit().remove();
+            pathSelection.on("mouseover", mouseoverPath).on("mouseout", mouseoutPath).on("click", clickPath);
+            traceEnter.append("g").attr("class", "dimensions");
+            var dimensionsSelection = traceSelection.select("g.dimensions");
+            var dimensionSelection = dimensionsSelection.selectAll("g.dimension").data(function(d2) {
+              return d2.dimensions;
+            }, key);
+            dimensionSelection.enter().append("g").attr("class", "dimension");
+            dimensionSelection.attr("transform", function(d2) {
+              return strTranslate(d2.x, 0);
+            });
+            dimensionSelection.exit().remove();
+            var categorySelection = dimensionSelection.selectAll("g.category").data(function(d2) {
+              return d2.categories;
+            }, key);
+            var categoryGroupEnterSelection = categorySelection.enter().append("g").attr("class", "category");
+            categorySelection.attr("transform", function(d2) {
+              return strTranslate(0, d2.y);
+            });
+            categoryGroupEnterSelection.append("rect").attr("class", "catrect").attr("pointer-events", "none");
+            categorySelection.select("rect.catrect").attr("fill", "none").attr("width", function(d2) {
+              return d2.width;
+            }).attr("height", function(d2) {
+              return d2.height;
+            });
+            styleCategoriesNoHover(categoryGroupEnterSelection);
+            var bandSelection = categorySelection.selectAll("rect.bandrect").data(
+              /** @param {CategoryViewModel} catViewModel*/
+              function(catViewModel) {
+                return catViewModel.bands;
+              },
+              key
+            );
+            bandSelection.each(function() {
+              Lib.raiseToTop(this);
+            });
+            bandSelection.attr("fill", function(d2) {
+              return d2.color;
+            });
+            var bandsSelectionEnter = bandSelection.enter().append("rect").attr("class", "bandrect").attr("stroke-opacity", 0).attr("fill", function(d2) {
+              return d2.color;
+            }).attr("fill-opacity", 0);
+            bandSelection.attr("fill", function(d2) {
+              return d2.color;
+            }).attr("width", function(d2) {
+              return d2.width;
+            }).attr("height", function(d2) {
+              return d2.height;
+            }).attr("y", function(d2) {
+              return d2.y;
+            }).attr(
+              "cursor",
+              /** @param {CategoryBandViewModel} bandModel*/
+              function(bandModel) {
+                if (bandModel.parcatsViewModel.arrangement === "fixed") {
+                  return "default";
+                } else if (bandModel.parcatsViewModel.arrangement === "perpendicular") {
+                  return "ns-resize";
+                } else {
+                  return "move";
+                }
+              }
+            );
+            styleBandsNoHover(bandsSelectionEnter);
+            bandSelection.exit().remove();
+            categoryGroupEnterSelection.append("text").attr("class", "catlabel").attr("pointer-events", "none");
+            categorySelection.select("text.catlabel").attr(
+              "text-anchor",
+              function(d2) {
+                if (catInRightDim(d2)) {
+                  return "start";
+                } else {
+                  return "end";
+                }
+              }
+            ).attr("alignment-baseline", "middle").style("fill", "rgb(0, 0, 0)").attr(
+              "x",
+              function(d2) {
+                if (catInRightDim(d2)) {
+                  return d2.width + 5;
+                } else {
+                  return -5;
+                }
+              }
+            ).attr("y", function(d2) {
+              return d2.height / 2;
+            }).text(function(d2) {
+              return d2.model.categoryLabel;
+            }).each(
+              /** @param {CategoryViewModel} catModel*/
+              function(catModel) {
+                Drawing.font(d3.select(this), catModel.parcatsViewModel.categorylabelfont);
+                svgTextUtils.convertToTspans(d3.select(this), graphDiv);
+              }
+            );
+            categoryGroupEnterSelection.append("text").attr("class", "dimlabel");
+            categorySelection.select("text.dimlabel").attr("text-anchor", "middle").attr("alignment-baseline", "baseline").attr(
+              "cursor",
+              /** @param {CategoryViewModel} catModel*/
+              function(catModel) {
+                if (catModel.parcatsViewModel.arrangement === "fixed") {
+                  return "default";
+                } else {
+                  return "ew-resize";
+                }
+              }
+            ).attr("x", function(d2) {
+              return d2.width / 2;
+            }).attr("y", -5).text(function(d2, i2) {
+              if (i2 === 0) {
+                return d2.parcatsViewModel.model.dimensions[d2.model.dimensionInd].dimensionLabel;
+              } else {
+                return null;
+              }
+            }).each(
+              /** @param {CategoryViewModel} catModel*/
+              function(catModel) {
+                Drawing.font(d3.select(this), catModel.parcatsViewModel.labelfont);
+              }
+            );
+            categorySelection.selectAll("rect.bandrect").on("mouseover", mouseoverCategoryBand).on("mouseout", mouseoutCategory);
+            categorySelection.exit().remove();
+            dimensionSelection.call(d3.behavior.drag().origin(function(d2) {
+              return { x: d2.x, y: 0 };
+            }).on("dragstart", dragDimensionStart).on("drag", dragDimension).on("dragend", dragDimensionEnd));
+            traceSelection.each(function(d2) {
+              d2.traceSelection = d3.select(this);
+              d2.pathSelection = d3.select(this).selectAll("g.paths").selectAll("path.path");
+              d2.dimensionSelection = d3.select(this).selectAll("g.dimensions").selectAll("g.dimension");
+            });
+            traceSelection.exit().remove();
+          }
+          module2.exports = function(graphDiv, svg, parcatsModels, layout) {
+            performPlot(parcatsModels, graphDiv, layout, svg);
+          };
+          function key(d2) {
+            return d2.key;
+          }
+          function catInRightDim(d2) {
+            var numDims = d2.parcatsViewModel.dimensions.length;
+            var leftDimInd = d2.parcatsViewModel.dimensions[numDims - 1].model.dimensionInd;
+            return d2.model.dimensionInd === leftDimInd;
+          }
+          function compareRawColor(a2, b2) {
+            if (a2.model.rawColor > b2.model.rawColor) {
+              return 1;
+            } else if (a2.model.rawColor < b2.model.rawColor) {
+              return -1;
+            } else {
+              return 0;
+            }
+          }
+          function mouseoverPath(d2) {
+            if (!d2.parcatsViewModel.dragDimension) {
+              if (d2.parcatsViewModel.hoverinfoItems.indexOf("skip") === -1) {
+                Lib.raiseToTop(this);
+                stylePathsHover(d3.select(this));
+                var points = buildPointsArrayForPath(d2);
+                var constraints = buildConstraintsForPath(d2);
+                d2.parcatsViewModel.graphDiv.emit("plotly_hover", {
+                  points,
+                  event: d3.event,
+                  constraints
+                });
+                if (d2.parcatsViewModel.hoverinfoItems.indexOf("none") === -1) {
+                  var hoverX = d3.mouse(this)[0];
+                  var gd2 = d2.parcatsViewModel.graphDiv;
+                  var trace = d2.parcatsViewModel.trace;
+                  var fullLayout = gd2._fullLayout;
+                  var rootBBox = fullLayout._paperdiv.node().getBoundingClientRect();
+                  var graphDivBBox = d2.parcatsViewModel.graphDiv.getBoundingClientRect();
+                  var pathCenterX, pathCenterY, dimInd;
+                  for (dimInd = 0; dimInd < d2.leftXs.length - 1; dimInd++) {
+                    if (d2.leftXs[dimInd] + d2.dimWidths[dimInd] - 2 <= hoverX && hoverX <= d2.leftXs[dimInd + 1] + 2) {
+                      var leftDim = d2.parcatsViewModel.dimensions[dimInd];
+                      var rightDim = d2.parcatsViewModel.dimensions[dimInd + 1];
+                      pathCenterX = (leftDim.x + leftDim.width + rightDim.x) / 2;
+                      pathCenterY = (d2.topYs[dimInd] + d2.topYs[dimInd + 1] + d2.height) / 2;
+                      break;
+                    }
+                  }
+                  var hoverCenterX = d2.parcatsViewModel.x + pathCenterX;
+                  var hoverCenterY = d2.parcatsViewModel.y + pathCenterY;
+                  var textColor = tinycolor.mostReadable(d2.model.color, ["black", "white"]);
+                  var count2 = d2.model.count;
+                  var prob = count2 / d2.parcatsViewModel.model.count;
+                  var labels = {
+                    countLabel: count2,
+                    probabilityLabel: prob.toFixed(3)
+                  };
+                  var hovertextParts = [];
+                  if (d2.parcatsViewModel.hoverinfoItems.indexOf("count") !== -1) {
+                    hovertextParts.push(["Count:", labels.countLabel].join(" "));
+                  }
+                  if (d2.parcatsViewModel.hoverinfoItems.indexOf("probability") !== -1) {
+                    hovertextParts.push(["P:", labels.probabilityLabel].join(" "));
+                  }
+                  var hovertext = hovertextParts.join("<br>");
+                  var mouseX = d3.mouse(gd2)[0];
+                  Fx.loneHover({
+                    trace,
+                    x: hoverCenterX - rootBBox.left + graphDivBBox.left,
+                    y: hoverCenterY - rootBBox.top + graphDivBBox.top,
+                    text: hovertext,
+                    color: d2.model.color,
+                    borderColor: "black",
+                    fontFamily: 'Monaco, "Courier New", monospace',
+                    fontSize: 10,
+                    fontColor: textColor,
+                    idealAlign: mouseX < hoverCenterX ? "right" : "left",
+                    hovertemplate: (trace.line || {}).hovertemplate,
+                    hovertemplateLabels: labels,
+                    eventData: [{
+                      data: trace._input,
+                      fullData: trace,
+                      count: count2,
+                      probability: prob
+                    }]
+                  }, {
+                    container: fullLayout._hoverlayer.node(),
+                    outerContainer: fullLayout._paper.node(),
+                    gd: gd2
+                  });
+                }
+              }
+            }
+          }
+          function mouseoutPath(d2) {
+            if (!d2.parcatsViewModel.dragDimension) {
+              stylePathsNoHover(d3.select(this));
+              Fx.loneUnhover(d2.parcatsViewModel.graphDiv._fullLayout._hoverlayer.node());
+              d2.parcatsViewModel.pathSelection.sort(compareRawColor);
+              if (d2.parcatsViewModel.hoverinfoItems.indexOf("skip") === -1) {
+                var points = buildPointsArrayForPath(d2);
+                var constraints = buildConstraintsForPath(d2);
+                d2.parcatsViewModel.graphDiv.emit("plotly_unhover", {
+                  points,
+                  event: d3.event,
+                  constraints
+                });
+              }
+            }
+          }
+          function buildPointsArrayForPath(d2) {
+            var points = [];
+            var curveNumber = getTraceIndex(d2.parcatsViewModel);
+            for (var i2 = 0; i2 < d2.model.valueInds.length; i2++) {
+              var pointNumber = d2.model.valueInds[i2];
+              points.push({
+                curveNumber,
+                pointNumber
+              });
+            }
+            return points;
+          }
+          function buildConstraintsForPath(d2) {
+            var constraints = {};
+            var dimensions = d2.parcatsViewModel.model.dimensions;
+            for (var i2 = 0; i2 < dimensions.length; i2++) {
+              var dimension = dimensions[i2];
+              var category = dimension.categories[d2.model.categoryInds[i2]];
+              constraints[dimension.containerInd] = category.categoryValue;
+            }
+            if (d2.model.rawColor !== void 0) {
+              constraints.color = d2.model.rawColor;
+            }
+            return constraints;
+          }
+          function clickPath(d2) {
+            if (d2.parcatsViewModel.hoverinfoItems.indexOf("skip") === -1) {
+              var points = buildPointsArrayForPath(d2);
+              var constraints = buildConstraintsForPath(d2);
+              d2.parcatsViewModel.graphDiv.emit("plotly_click", {
+                points,
+                event: d3.event,
+                constraints
+              });
+            }
+          }
+          function stylePathsNoHover(pathSelection) {
+            pathSelection.attr("fill", function(d2) {
+              return d2.model.color;
+            }).attr("fill-opacity", 0.6).attr("stroke", "lightgray").attr("stroke-width", 0.2).attr("stroke-opacity", 1);
+          }
+          function stylePathsHover(pathSelection) {
+            pathSelection.attr("fill-opacity", 0.8).attr("stroke", function(d2) {
+              return tinycolor.mostReadable(d2.model.color, ["black", "white"]);
+            }).attr("stroke-width", 0.3);
+          }
+          function styleCategoryHover(categorySelection) {
+            categorySelection.select("rect.catrect").attr("stroke", "black").attr("stroke-width", 2.5);
+          }
+          function styleCategoriesNoHover(categorySelection) {
+            categorySelection.select("rect.catrect").attr("stroke", "black").attr("stroke-width", 1).attr("stroke-opacity", 1);
+          }
+          function styleBandsHover(bandsSelection) {
+            bandsSelection.attr("stroke", "black").attr("stroke-width", 1.5);
+          }
+          function styleBandsNoHover(bandsSelection) {
+            bandsSelection.attr("stroke", "black").attr("stroke-width", 0.2).attr("stroke-opacity", 1).attr("fill-opacity", 1);
+          }
+          function selectPathsThroughCategoryBandColor(catBandViewModel) {
+            var allPaths = catBandViewModel.parcatsViewModel.pathSelection;
+            var dimInd = catBandViewModel.categoryViewModel.model.dimensionInd;
+            var catInd = catBandViewModel.categoryViewModel.model.categoryInd;
+            return allPaths.filter(
+              /** @param {PathViewModel} pathViewModel */
+              function(pathViewModel) {
+                return pathViewModel.model.categoryInds[dimInd] === catInd && pathViewModel.model.color === catBandViewModel.color;
+              }
+            );
+          }
+          function styleForCategoryHovermode(bandElement) {
+            var bandSel = d3.select(bandElement.parentNode).selectAll("rect.bandrect");
+            bandSel.each(function(bvm) {
+              var paths = selectPathsThroughCategoryBandColor(bvm);
+              stylePathsHover(paths);
+              paths.each(function() {
+                Lib.raiseToTop(this);
+              });
+            });
+            styleCategoryHover(d3.select(bandElement.parentNode));
+          }
+          function styleForColorHovermode(bandElement) {
+            var bandViewModel = d3.select(bandElement).datum();
+            var catPaths = selectPathsThroughCategoryBandColor(bandViewModel);
+            stylePathsHover(catPaths);
+            catPaths.each(function() {
+              Lib.raiseToTop(this);
+            });
+            d3.select(bandElement.parentNode).selectAll("rect.bandrect").filter(function(b2) {
+              return b2.color === bandViewModel.color;
+            }).each(function() {
+              Lib.raiseToTop(this);
+              styleBandsHover(d3.select(this));
+            });
+          }
+          function emitPointsEventCategoryHovermode(bandElement, eventName, event) {
+            var bandViewModel = d3.select(bandElement).datum();
+            var categoryModel = bandViewModel.categoryViewModel.model;
+            var gd2 = bandViewModel.parcatsViewModel.graphDiv;
+            var bandSel = d3.select(bandElement.parentNode).selectAll("rect.bandrect");
+            var points = [];
+            bandSel.each(function(bvm) {
+              var paths = selectPathsThroughCategoryBandColor(bvm);
+              paths.each(function(pathViewModel) {
+                Array.prototype.push.apply(points, buildPointsArrayForPath(pathViewModel));
+              });
+            });
+            var constraints = {};
+            constraints[categoryModel.dimensionInd] = categoryModel.categoryValue;
+            gd2.emit(eventName, {
+              points,
+              event,
+              constraints
+            });
+          }
+          function emitPointsEventColorHovermode(bandElement, eventName, event) {
+            var bandViewModel = d3.select(bandElement).datum();
+            var categoryModel = bandViewModel.categoryViewModel.model;
+            var gd2 = bandViewModel.parcatsViewModel.graphDiv;
+            var paths = selectPathsThroughCategoryBandColor(bandViewModel);
+            var points = [];
+            paths.each(function(pathViewModel) {
+              Array.prototype.push.apply(points, buildPointsArrayForPath(pathViewModel));
+            });
+            var constraints = {};
+            constraints[categoryModel.dimensionInd] = categoryModel.categoryValue;
+            if (bandViewModel.rawColor !== void 0) {
+              constraints.color = bandViewModel.rawColor;
+            }
+            gd2.emit(eventName, {
+              points,
+              event,
+              constraints
+            });
+          }
+          function createHoverLabelForCategoryHovermode(gd2, rootBBox, bandElement) {
+            gd2._fullLayout._calcInverseTransform(gd2);
+            var scaleX2 = gd2._fullLayout._invScaleX;
+            var scaleY2 = gd2._fullLayout._invScaleY;
+            var rectSelection = d3.select(bandElement.parentNode).select("rect.catrect");
+            var rectBoundingBox = rectSelection.node().getBoundingClientRect();
+            var catViewModel = rectSelection.datum();
+            var parcatsViewModel = catViewModel.parcatsViewModel;
+            var dimensionModel = parcatsViewModel.model.dimensions[catViewModel.model.dimensionInd];
+            var trace = parcatsViewModel.trace;
+            var hoverCenterY = rectBoundingBox.top + rectBoundingBox.height / 2;
+            var hoverCenterX, hoverLabelIdealAlign;
+            if (parcatsViewModel.dimensions.length > 1 && dimensionModel.displayInd === parcatsViewModel.dimensions.length - 1) {
+              hoverCenterX = rectBoundingBox.left;
+              hoverLabelIdealAlign = "left";
+            } else {
+              hoverCenterX = rectBoundingBox.left + rectBoundingBox.width;
+              hoverLabelIdealAlign = "right";
+            }
+            var count2 = catViewModel.model.count;
+            var catLabel = catViewModel.model.categoryLabel;
+            var prob = count2 / catViewModel.parcatsViewModel.model.count;
+            var labels = {
+              countLabel: count2,
+              categoryLabel: catLabel,
+              probabilityLabel: prob.toFixed(3)
+            };
+            var hoverinfoParts = [];
+            if (catViewModel.parcatsViewModel.hoverinfoItems.indexOf("count") !== -1) {
+              hoverinfoParts.push(["Count:", labels.countLabel].join(" "));
+            }
+            if (catViewModel.parcatsViewModel.hoverinfoItems.indexOf("probability") !== -1) {
+              hoverinfoParts.push(["P(" + labels.categoryLabel + "):", labels.probabilityLabel].join(" "));
+            }
+            var hovertext = hoverinfoParts.join("<br>");
+            return {
+              trace,
+              x: scaleX2 * (hoverCenterX - rootBBox.left),
+              y: scaleY2 * (hoverCenterY - rootBBox.top),
+              text: hovertext,
+              color: "lightgray",
+              borderColor: "black",
+              fontFamily: 'Monaco, "Courier New", monospace',
+              fontSize: 12,
+              fontColor: "black",
+              idealAlign: hoverLabelIdealAlign,
+              hovertemplate: trace.hovertemplate,
+              hovertemplateLabels: labels,
+              eventData: [{
+                data: trace._input,
+                fullData: trace,
+                count: count2,
+                category: catLabel,
+                probability: prob
+              }]
+            };
+          }
+          function createHoverLabelForDimensionHovermode(gd2, rootBBox, bandElement) {
+            var allHoverlabels = [];
+            d3.select(bandElement.parentNode.parentNode).selectAll("g.category").select("rect.catrect").each(function() {
+              var bandNode = this;
+              allHoverlabels.push(createHoverLabelForCategoryHovermode(gd2, rootBBox, bandNode));
+            });
+            return allHoverlabels;
+          }
+          function createHoverLabelForColorHovermode(gd2, rootBBox, bandElement) {
+            gd2._fullLayout._calcInverseTransform(gd2);
+            var scaleX2 = gd2._fullLayout._invScaleX;
+            var scaleY2 = gd2._fullLayout._invScaleY;
+            var bandBoundingBox = bandElement.getBoundingClientRect();
+            var bandViewModel = d3.select(bandElement).datum();
+            var catViewModel = bandViewModel.categoryViewModel;
+            var parcatsViewModel = catViewModel.parcatsViewModel;
+            var dimensionModel = parcatsViewModel.model.dimensions[catViewModel.model.dimensionInd];
+            var trace = parcatsViewModel.trace;
+            var hoverCenterY = bandBoundingBox.y + bandBoundingBox.height / 2;
+            var hoverCenterX, hoverLabelIdealAlign;
+            if (parcatsViewModel.dimensions.length > 1 && dimensionModel.displayInd === parcatsViewModel.dimensions.length - 1) {
+              hoverCenterX = bandBoundingBox.left;
+              hoverLabelIdealAlign = "left";
+            } else {
+              hoverCenterX = bandBoundingBox.left + bandBoundingBox.width;
+              hoverLabelIdealAlign = "right";
+            }
+            var catLabel = catViewModel.model.categoryLabel;
+            var totalCount = bandViewModel.parcatsViewModel.model.count;
+            var bandColorCount = 0;
+            bandViewModel.categoryViewModel.bands.forEach(function(b2) {
+              if (b2.color === bandViewModel.color) {
+                bandColorCount += b2.count;
+              }
+            });
+            var catCount = catViewModel.model.count;
+            var colorCount = 0;
+            parcatsViewModel.pathSelection.each(
+              /** @param {PathViewModel} pathViewModel */
+              function(pathViewModel) {
+                if (pathViewModel.model.color === bandViewModel.color) {
+                  colorCount += pathViewModel.model.count;
+                }
+              }
+            );
+            var pColorAndCat = bandColorCount / totalCount;
+            var pCatGivenColor = bandColorCount / colorCount;
+            var pColorGivenCat = bandColorCount / catCount;
+            var labels = {
+              countLabel: bandColorCount,
+              categoryLabel: catLabel,
+              probabilityLabel: pColorAndCat.toFixed(3)
+            };
+            var hoverinfoParts = [];
+            if (catViewModel.parcatsViewModel.hoverinfoItems.indexOf("count") !== -1) {
+              hoverinfoParts.push(["Count:", labels.countLabel].join(" "));
+            }
+            if (catViewModel.parcatsViewModel.hoverinfoItems.indexOf("probability") !== -1) {
+              hoverinfoParts.push("P(color ∩ " + catLabel + "): " + labels.probabilityLabel);
+              hoverinfoParts.push("P(" + catLabel + " | color): " + pCatGivenColor.toFixed(3));
+              hoverinfoParts.push("P(color | " + catLabel + "): " + pColorGivenCat.toFixed(3));
+            }
+            var hovertext = hoverinfoParts.join("<br>");
+            var textColor = tinycolor.mostReadable(bandViewModel.color, ["black", "white"]);
+            return {
+              trace,
+              x: scaleX2 * (hoverCenterX - rootBBox.left),
+              y: scaleY2 * (hoverCenterY - rootBBox.top),
+              // name: 'NAME',
+              text: hovertext,
+              color: bandViewModel.color,
+              borderColor: "black",
+              fontFamily: 'Monaco, "Courier New", monospace',
+              fontColor: textColor,
+              fontSize: 10,
+              idealAlign: hoverLabelIdealAlign,
+              hovertemplate: trace.hovertemplate,
+              hovertemplateLabels: labels,
+              eventData: [{
+                data: trace._input,
+                fullData: trace,
+                category: catLabel,
+                count: totalCount,
+                probability: pColorAndCat,
+                categorycount: catCount,
+                colorcount: colorCount,
+                bandcolorcount: bandColorCount
+              }]
+            };
+          }
+          function mouseoverCategoryBand(bandViewModel) {
+            if (!bandViewModel.parcatsViewModel.dragDimension) {
+              if (bandViewModel.parcatsViewModel.hoverinfoItems.indexOf("skip") === -1) {
+                var mouseY = d3.mouse(this)[1];
+                if (mouseY < -1) {
+                  return;
+                }
+                var gd2 = bandViewModel.parcatsViewModel.graphDiv;
+                var fullLayout = gd2._fullLayout;
+                var rootBBox = fullLayout._paperdiv.node().getBoundingClientRect();
+                var hoveron = bandViewModel.parcatsViewModel.hoveron;
+                var bandElement = this;
+                if (hoveron === "color") {
+                  styleForColorHovermode(bandElement);
+                  emitPointsEventColorHovermode(bandElement, "plotly_hover", d3.event);
+                } else {
+                  styleForCategoryHovermode(bandElement);
+                  emitPointsEventCategoryHovermode(bandElement, "plotly_hover", d3.event);
+                }
+                if (bandViewModel.parcatsViewModel.hoverinfoItems.indexOf("none") === -1) {
+                  var hoverItems;
+                  if (hoveron === "category") {
+                    hoverItems = createHoverLabelForCategoryHovermode(gd2, rootBBox, bandElement);
+                  } else if (hoveron === "color") {
+                    hoverItems = createHoverLabelForColorHovermode(gd2, rootBBox, bandElement);
+                  } else if (hoveron === "dimension") {
+                    hoverItems = createHoverLabelForDimensionHovermode(gd2, rootBBox, bandElement);
+                  }
+                  if (hoverItems) {
+                    Fx.loneHover(hoverItems, {
+                      container: fullLayout._hoverlayer.node(),
+                      outerContainer: fullLayout._paper.node(),
+                      gd: gd2
+                    });
+                  }
+                }
+              }
+            }
+          }
+          function mouseoutCategory(bandViewModel) {
+            var parcatsViewModel = bandViewModel.parcatsViewModel;
+            if (!parcatsViewModel.dragDimension) {
+              stylePathsNoHover(parcatsViewModel.pathSelection);
+              styleCategoriesNoHover(parcatsViewModel.dimensionSelection.selectAll("g.category"));
+              styleBandsNoHover(parcatsViewModel.dimensionSelection.selectAll("g.category").selectAll("rect.bandrect"));
+              Fx.loneUnhover(parcatsViewModel.graphDiv._fullLayout._hoverlayer.node());
+              parcatsViewModel.pathSelection.sort(compareRawColor);
+              if (parcatsViewModel.hoverinfoItems.indexOf("skip") === -1) {
+                var hoveron = bandViewModel.parcatsViewModel.hoveron;
+                var bandElement = this;
+                if (hoveron === "color") {
+                  emitPointsEventColorHovermode(bandElement, "plotly_unhover", d3.event);
+                } else {
+                  emitPointsEventCategoryHovermode(bandElement, "plotly_unhover", d3.event);
+                }
+              }
+            }
+          }
+          function dragDimensionStart(d2) {
+            if (d2.parcatsViewModel.arrangement === "fixed") {
+              return;
+            }
+            d2.dragDimensionDisplayInd = d2.model.displayInd;
+            d2.initialDragDimensionDisplayInds = d2.parcatsViewModel.model.dimensions.map(function(d22) {
+              return d22.displayInd;
+            });
+            d2.dragHasMoved = false;
+            d2.dragCategoryDisplayInd = null;
+            d3.select(this).selectAll("g.category").select("rect.catrect").each(
+              /** @param {CategoryViewModel} catViewModel */
+              function(catViewModel) {
+                var catMouseX = d3.mouse(this)[0];
+                var catMouseY = d3.mouse(this)[1];
+                if (-2 <= catMouseX && catMouseX <= catViewModel.width + 2 && -2 <= catMouseY && catMouseY <= catViewModel.height + 2) {
+                  d2.dragCategoryDisplayInd = catViewModel.model.displayInd;
+                  d2.initialDragCategoryDisplayInds = d2.model.categories.map(function(c2) {
+                    return c2.displayInd;
+                  });
+                  catViewModel.model.dragY = catViewModel.y;
+                  Lib.raiseToTop(this.parentNode);
+                  d3.select(this.parentNode).selectAll("rect.bandrect").each(function(bandViewModel) {
+                    if (bandViewModel.y < catMouseY && catMouseY <= bandViewModel.y + bandViewModel.height) {
+                      d2.potentialClickBand = this;
+                    }
+                  });
+                }
+              }
+            );
+            d2.parcatsViewModel.dragDimension = d2;
+            Fx.loneUnhover(d2.parcatsViewModel.graphDiv._fullLayout._hoverlayer.node());
+          }
+          function dragDimension(d2) {
+            if (d2.parcatsViewModel.arrangement === "fixed") {
+              return;
+            }
+            d2.dragHasMoved = true;
+            if (d2.dragDimensionDisplayInd === null) {
+              return;
+            }
+            var dragDimInd = d2.dragDimensionDisplayInd;
+            var prevDimInd = dragDimInd - 1;
+            var nextDimInd = dragDimInd + 1;
+            var dragDimension2 = d2.parcatsViewModel.dimensions[dragDimInd];
+            if (d2.dragCategoryDisplayInd !== null) {
+              var dragCategory = dragDimension2.categories[d2.dragCategoryDisplayInd];
+              dragCategory.model.dragY += d3.event.dy;
+              var categoryY = dragCategory.model.dragY;
+              var catDisplayInd = dragCategory.model.displayInd;
+              var dimCategoryViews = dragDimension2.categories;
+              var catAbove = dimCategoryViews[catDisplayInd - 1];
+              var catBelow = dimCategoryViews[catDisplayInd + 1];
+              if (catAbove !== void 0) {
+                if (categoryY < catAbove.y + catAbove.height / 2) {
+                  dragCategory.model.displayInd = catAbove.model.displayInd;
+                  catAbove.model.displayInd = catDisplayInd;
+                }
+              }
+              if (catBelow !== void 0) {
+                if (categoryY + dragCategory.height > catBelow.y + catBelow.height / 2) {
+                  dragCategory.model.displayInd = catBelow.model.displayInd;
+                  catBelow.model.displayInd = catDisplayInd;
+                }
+              }
+              d2.dragCategoryDisplayInd = dragCategory.model.displayInd;
+            }
+            if (d2.dragCategoryDisplayInd === null || d2.parcatsViewModel.arrangement === "freeform") {
+              dragDimension2.model.dragX = d3.event.x;
+              var prevDimension = d2.parcatsViewModel.dimensions[prevDimInd];
+              var nextDimension = d2.parcatsViewModel.dimensions[nextDimInd];
+              if (prevDimension !== void 0) {
+                if (dragDimension2.model.dragX < prevDimension.x + prevDimension.width) {
+                  dragDimension2.model.displayInd = prevDimension.model.displayInd;
+                  prevDimension.model.displayInd = dragDimInd;
+                }
+              }
+              if (nextDimension !== void 0) {
+                if (dragDimension2.model.dragX + dragDimension2.width > nextDimension.x) {
+                  dragDimension2.model.displayInd = nextDimension.model.displayInd;
+                  nextDimension.model.displayInd = d2.dragDimensionDisplayInd;
+                }
+              }
+              d2.dragDimensionDisplayInd = dragDimension2.model.displayInd;
+            }
+            updateDimensionViewModels(d2.parcatsViewModel);
+            updatePathViewModels(d2.parcatsViewModel);
+            updateSvgCategories(d2.parcatsViewModel);
+            updateSvgPaths(d2.parcatsViewModel);
+          }
+          function dragDimensionEnd(d2) {
+            if (d2.parcatsViewModel.arrangement === "fixed") {
+              return;
+            }
+            if (d2.dragDimensionDisplayInd === null) {
+              return;
+            }
+            d3.select(this).selectAll("text").attr("font-weight", "normal");
+            var restyleData = {};
+            var traceInd = getTraceIndex(d2.parcatsViewModel);
+            var finalDragDimensionDisplayInds = d2.parcatsViewModel.model.dimensions.map(function(d22) {
+              return d22.displayInd;
+            });
+            var anyDimsReordered = d2.initialDragDimensionDisplayInds.some(function(initDimDisplay, dimInd) {
+              return initDimDisplay !== finalDragDimensionDisplayInds[dimInd];
+            });
+            if (anyDimsReordered) {
+              finalDragDimensionDisplayInds.forEach(function(finalDimDisplay, dimInd) {
+                var containerInd = d2.parcatsViewModel.model.dimensions[dimInd].containerInd;
+                restyleData["dimensions[" + containerInd + "].displayindex"] = finalDimDisplay;
+              });
+            }
+            var anyCatsReordered = false;
+            if (d2.dragCategoryDisplayInd !== null) {
+              var finalDragCategoryDisplayInds = d2.model.categories.map(function(c2) {
+                return c2.displayInd;
+              });
+              anyCatsReordered = d2.initialDragCategoryDisplayInds.some(function(initCatDisplay, catInd) {
+                return initCatDisplay !== finalDragCategoryDisplayInds[catInd];
+              });
+              if (anyCatsReordered) {
+                var sortedCategoryModels = d2.model.categories.slice().sort(
+                  function(a2, b2) {
+                    return a2.displayInd - b2.displayInd;
+                  }
+                );
+                var newCategoryArray = sortedCategoryModels.map(function(v2) {
+                  return v2.categoryValue;
+                });
+                var newCategoryLabels = sortedCategoryModels.map(function(v2) {
+                  return v2.categoryLabel;
+                });
+                restyleData["dimensions[" + d2.model.containerInd + "].categoryarray"] = [newCategoryArray];
+                restyleData["dimensions[" + d2.model.containerInd + "].ticktext"] = [newCategoryLabels];
+                restyleData["dimensions[" + d2.model.containerInd + "].categoryorder"] = "array";
+              }
+            }
+            if (d2.parcatsViewModel.hoverinfoItems.indexOf("skip") === -1) {
+              if (!d2.dragHasMoved && d2.potentialClickBand) {
+                if (d2.parcatsViewModel.hoveron === "color") {
+                  emitPointsEventColorHovermode(d2.potentialClickBand, "plotly_click", d3.event.sourceEvent);
+                } else {
+                  emitPointsEventCategoryHovermode(d2.potentialClickBand, "plotly_click", d3.event.sourceEvent);
+                }
+              }
+            }
+            d2.model.dragX = null;
+            if (d2.dragCategoryDisplayInd !== null) {
+              var dragCategory = d2.parcatsViewModel.dimensions[d2.dragDimensionDisplayInd].categories[d2.dragCategoryDisplayInd];
+              dragCategory.model.dragY = null;
+              d2.dragCategoryDisplayInd = null;
+            }
+            d2.dragDimensionDisplayInd = null;
+            d2.parcatsViewModel.dragDimension = null;
+            d2.dragHasMoved = null;
+            d2.potentialClickBand = null;
+            updateDimensionViewModels(d2.parcatsViewModel);
+            updatePathViewModels(d2.parcatsViewModel);
+            var transition = d3.transition().duration(300).ease("cubic-in-out");
+            transition.each(function() {
+              updateSvgCategories(d2.parcatsViewModel, true);
+              updateSvgPaths(d2.parcatsViewModel, true);
+            }).each("end", function() {
+              if (anyDimsReordered || anyCatsReordered) {
+                Plotly2.restyle(d2.parcatsViewModel.graphDiv, restyleData, [traceInd]);
+              }
+            });
+          }
+          function getTraceIndex(parcatsViewModel) {
+            var traceInd;
+            var allTraces = parcatsViewModel.graphDiv._fullData;
+            for (var i2 = 0; i2 < allTraces.length; i2++) {
+              if (parcatsViewModel.key === allTraces[i2].uid) {
+                traceInd = i2;
+                break;
+              }
+            }
+            return traceInd;
+          }
+          function updateSvgPaths(parcatsViewModel, hasTransition) {
+            if (hasTransition === void 0) {
+              hasTransition = false;
+            }
+            function transition(selection) {
+              return hasTransition ? selection.transition() : selection;
+            }
+            parcatsViewModel.pathSelection.data(function(d2) {
+              return d2.paths;
+            }, key);
+            transition(parcatsViewModel.pathSelection).attr("d", function(d2) {
+              return d2.svgD;
+            });
+          }
+          function updateSvgCategories(parcatsViewModel, hasTransition) {
+            if (hasTransition === void 0) {
+              hasTransition = false;
+            }
+            function transition(selection) {
+              return hasTransition ? selection.transition() : selection;
+            }
+            parcatsViewModel.dimensionSelection.data(function(d2) {
+              return d2.dimensions;
+            }, key);
+            var categorySelection = parcatsViewModel.dimensionSelection.selectAll("g.category").data(function(d2) {
+              return d2.categories;
+            }, key);
+            transition(parcatsViewModel.dimensionSelection).attr("transform", function(d2) {
+              return strTranslate(d2.x, 0);
+            });
+            transition(categorySelection).attr("transform", function(d2) {
+              return strTranslate(0, d2.y);
+            });
+            var dimLabelSelection = categorySelection.select(".dimlabel");
+            dimLabelSelection.text(function(d2, i2) {
+              if (i2 === 0) {
+                return d2.parcatsViewModel.model.dimensions[d2.model.dimensionInd].dimensionLabel;
+              } else {
+                return null;
+              }
+            });
+            var catLabelSelection = categorySelection.select(".catlabel");
+            catLabelSelection.attr(
+              "text-anchor",
+              function(d2) {
+                if (catInRightDim(d2)) {
+                  return "start";
+                } else {
+                  return "end";
+                }
+              }
+            ).attr(
+              "x",
+              function(d2) {
+                if (catInRightDim(d2)) {
+                  return d2.width + 5;
+                } else {
+                  return -5;
+                }
+              }
+            ).each(function(d2) {
+              var newX;
+              var newAnchor;
+              if (catInRightDim(d2)) {
+                newX = d2.width + 5;
+                newAnchor = "start";
+              } else {
+                newX = -5;
+                newAnchor = "end";
+              }
+              d3.select(this).selectAll("tspan").attr("x", newX).attr("text-anchor", newAnchor);
+            });
+            var bandSelection = categorySelection.selectAll("rect.bandrect").data(
+              /** @param {CategoryViewModel} catViewModel*/
+              function(catViewModel) {
+                return catViewModel.bands;
+              },
+              key
+            );
+            var bandsSelectionEnter = bandSelection.enter().append("rect").attr("class", "bandrect").attr("cursor", "move").attr("stroke-opacity", 0).attr("fill", function(d2) {
+              return d2.color;
+            }).attr("fill-opacity", 0);
+            bandSelection.attr("fill", function(d2) {
+              return d2.color;
+            }).attr("width", function(d2) {
+              return d2.width;
+            }).attr("height", function(d2) {
+              return d2.height;
+            }).attr("y", function(d2) {
+              return d2.y;
+            });
+            styleBandsNoHover(bandsSelectionEnter);
+            bandSelection.each(function() {
+              Lib.raiseToTop(this);
+            });
+            bandSelection.exit().remove();
+          }
+          function createParcatsViewModel(graphDiv, layout, wrappedParcatsModel) {
+            var parcatsModel = wrappedParcatsModel[0];
+            var margin = layout.margin || { l: 80, r: 80, t: 100, b: 80 };
+            var trace = parcatsModel.trace;
+            var domain = trace.domain;
+            var figureWidth = layout.width;
+            var figureHeight = layout.height;
+            var traceWidth = Math.floor(figureWidth * (domain.x[1] - domain.x[0]));
+            var traceHeight = Math.floor(figureHeight * (domain.y[1] - domain.y[0]));
+            var traceX = domain.x[0] * figureWidth + margin.l;
+            var traceY = layout.height - domain.y[1] * layout.height + margin.t;
+            var pathShape = trace.line.shape;
+            var hoverinfoItems;
+            if (trace.hoverinfo === "all") {
+              hoverinfoItems = ["count", "probability"];
+            } else {
+              hoverinfoItems = (trace.hoverinfo || "").split("+");
+            }
+            var parcatsViewModel = {
+              trace,
+              key: trace.uid,
+              model: parcatsModel,
+              x: traceX,
+              y: traceY,
+              width: traceWidth,
+              height: traceHeight,
+              hoveron: trace.hoveron,
+              hoverinfoItems,
+              arrangement: trace.arrangement,
+              bundlecolors: trace.bundlecolors,
+              sortpaths: trace.sortpaths,
+              labelfont: trace.labelfont,
+              categorylabelfont: trace.tickfont,
+              pathShape,
+              dragDimension: null,
+              margin,
+              paths: [],
+              dimensions: [],
+              graphDiv,
+              traceSelection: null,
+              pathSelection: null,
+              dimensionSelection: null
+            };
+            if (parcatsModel.dimensions) {
+              updateDimensionViewModels(parcatsViewModel);
+              updatePathViewModels(parcatsViewModel);
+            }
+            return parcatsViewModel;
+          }
+          function buildSvgPath(leftXPositions, pathYs, dimWidths, pathHeight, curvature) {
+            var xRefPoints1 = [];
+            var xRefPoints2 = [];
+            var refInterpolator;
+            var d2;
+            for (d2 = 0; d2 < dimWidths.length - 1; d2++) {
+              refInterpolator = interpolateNumber(dimWidths[d2] + leftXPositions[d2], leftXPositions[d2 + 1]);
+              xRefPoints1.push(refInterpolator(curvature));
+              xRefPoints2.push(refInterpolator(1 - curvature));
+            }
+            var svgD = "M " + leftXPositions[0] + "," + pathYs[0];
+            svgD += "l" + dimWidths[0] + ",0 ";
+            for (d2 = 1; d2 < dimWidths.length; d2++) {
+              svgD += "C" + xRefPoints1[d2 - 1] + "," + pathYs[d2 - 1] + " " + xRefPoints2[d2 - 1] + "," + pathYs[d2] + " " + leftXPositions[d2] + "," + pathYs[d2];
+              svgD += "l" + dimWidths[d2] + ",0 ";
+            }
+            svgD += "l0," + pathHeight + " ";
+            svgD += "l -" + dimWidths[dimWidths.length - 1] + ",0 ";
+            for (d2 = dimWidths.length - 2; d2 >= 0; d2--) {
+              svgD += "C" + xRefPoints2[d2] + "," + (pathYs[d2 + 1] + pathHeight) + " " + xRefPoints1[d2] + "," + (pathYs[d2] + pathHeight) + " " + (leftXPositions[d2] + dimWidths[d2]) + "," + (pathYs[d2] + pathHeight);
+              svgD += "l-" + dimWidths[d2] + ",0 ";
+            }
+            svgD += "Z";
+            return svgD;
+          }
+          function updatePathViewModels(parcatsViewModel) {
+            var dimensionViewModels = parcatsViewModel.dimensions;
+            var parcatsModel = parcatsViewModel.model;
+            var nextYPositions = dimensionViewModels.map(
+              function(d22) {
+                return d22.categories.map(
+                  function(c2) {
+                    return c2.y;
+                  }
+                );
+              }
+            );
+            var catToDisplayIndPerDim = parcatsViewModel.model.dimensions.map(
+              function(d22) {
+                return d22.categories.map(function(c2) {
+                  return c2.displayInd;
+                });
+              }
+            );
+            var dimToDisplayInd = parcatsViewModel.model.dimensions.map(function(d22) {
+              return d22.displayInd;
+            });
+            var displayToDimInd = parcatsViewModel.dimensions.map(function(d22) {
+              return d22.model.dimensionInd;
+            });
+            var leftXPositions = dimensionViewModels.map(
+              function(d22) {
+                return d22.x;
+              }
+            );
+            var dimWidths = dimensionViewModels.map(function(d22) {
+              return d22.width;
+            });
+            var pathModels = [];
+            for (var p2 in parcatsModel.paths) {
+              if (parcatsModel.paths.hasOwnProperty(p2)) {
+                pathModels.push(parcatsModel.paths[p2]);
+              }
+            }
+            function pathDisplayCategoryInds(pathModel2) {
+              var dimensionInds = pathModel2.categoryInds.map(function(catInd2, dimInd) {
+                return catToDisplayIndPerDim[dimInd][catInd2];
+              });
+              var displayInds = displayToDimInd.map(function(dimInd) {
+                return dimensionInds[dimInd];
+              });
+              return displayInds;
+            }
+            pathModels.sort(function(v1, v2) {
+              var sortArray1 = pathDisplayCategoryInds(v1);
+              var sortArray2 = pathDisplayCategoryInds(v2);
+              if (parcatsViewModel.sortpaths === "backward") {
+                sortArray1.reverse();
+                sortArray2.reverse();
+              }
+              sortArray1.push(v1.valueInds[0]);
+              sortArray2.push(v2.valueInds[0]);
+              if (parcatsViewModel.bundlecolors) {
+                sortArray1.unshift(v1.rawColor);
+                sortArray2.unshift(v2.rawColor);
+              }
+              if (sortArray1 < sortArray2) {
+                return -1;
+              }
+              if (sortArray1 > sortArray2) {
+                return 1;
+              }
+              return 0;
+            });
+            var pathViewModels = new Array(pathModels.length);
+            var totalCount = dimensionViewModels[0].model.count;
+            var totalHeight = dimensionViewModels[0].categories.map(function(c2) {
+              return c2.height;
+            }).reduce(function(v1, v2) {
+              return v1 + v2;
+            });
+            for (var pathNumber = 0; pathNumber < pathModels.length; pathNumber++) {
+              var pathModel = pathModels[pathNumber];
+              var pathHeight;
+              if (totalCount > 0) {
+                pathHeight = totalHeight * (pathModel.count / totalCount);
+              } else {
+                pathHeight = 0;
+              }
+              var pathYs = new Array(nextYPositions.length);
+              for (var d2 = 0; d2 < pathModel.categoryInds.length; d2++) {
+                var catInd = pathModel.categoryInds[d2];
+                var catDisplayInd = catToDisplayIndPerDim[d2][catInd];
+                var dimDisplayInd = dimToDisplayInd[d2];
+                pathYs[dimDisplayInd] = nextYPositions[dimDisplayInd][catDisplayInd];
+                nextYPositions[dimDisplayInd][catDisplayInd] += pathHeight;
+                var catViewModle = parcatsViewModel.dimensions[dimDisplayInd].categories[catDisplayInd];
+                var numBands = catViewModle.bands.length;
+                var lastCatBand = catViewModle.bands[numBands - 1];
+                if (lastCatBand === void 0 || pathModel.rawColor !== lastCatBand.rawColor) {
+                  var bandY = lastCatBand === void 0 ? 0 : lastCatBand.y + lastCatBand.height;
+                  catViewModle.bands.push({
+                    key: bandY,
+                    color: pathModel.color,
+                    rawColor: pathModel.rawColor,
+                    height: pathHeight,
+                    width: catViewModle.width,
+                    count: pathModel.count,
+                    y: bandY,
+                    categoryViewModel: catViewModle,
+                    parcatsViewModel
+                  });
+                } else {
+                  var currentBand = catViewModle.bands[numBands - 1];
+                  currentBand.height += pathHeight;
+                  currentBand.count += pathModel.count;
+                }
+              }
+              var svgD;
+              if (parcatsViewModel.pathShape === "hspline") {
+                svgD = buildSvgPath(leftXPositions, pathYs, dimWidths, pathHeight, 0.5);
+              } else {
+                svgD = buildSvgPath(leftXPositions, pathYs, dimWidths, pathHeight, 0);
+              }
+              pathViewModels[pathNumber] = {
+                key: pathModel.valueInds[0],
+                model: pathModel,
+                height: pathHeight,
+                leftXs: leftXPositions,
+                topYs: pathYs,
+                dimWidths,
+                svgD,
+                parcatsViewModel
+              };
+            }
+            parcatsViewModel.paths = pathViewModels;
+          }
+          function updateDimensionViewModels(parcatsViewModel) {
+            var dimensionsIndInfo = parcatsViewModel.model.dimensions.map(function(d2) {
+              return { displayInd: d2.displayInd, dimensionInd: d2.dimensionInd };
+            });
+            dimensionsIndInfo.sort(function(a2, b2) {
+              return a2.displayInd - b2.displayInd;
+            });
+            var dimensions = [];
+            for (var displayInd in dimensionsIndInfo) {
+              var dimensionInd = dimensionsIndInfo[displayInd].dimensionInd;
+              var dimModel = parcatsViewModel.model.dimensions[dimensionInd];
+              dimensions.push(createDimensionViewModel(parcatsViewModel, dimModel));
+            }
+            parcatsViewModel.dimensions = dimensions;
+          }
+          function createDimensionViewModel(parcatsViewModel, dimensionModel) {
+            var categoryLabelPad = 40;
+            var dimWidth = 16;
+            var numDimensions = parcatsViewModel.model.dimensions.length;
+            var displayInd = dimensionModel.displayInd;
+            var dimDx;
+            var dimX0;
+            var dimX;
+            if (numDimensions > 1) {
+              dimDx = (parcatsViewModel.width - 2 * categoryLabelPad - dimWidth) / (numDimensions - 1);
+            } else {
+              dimDx = 0;
+            }
+            dimX0 = categoryLabelPad;
+            dimX = dimX0 + dimDx * displayInd;
+            var categories = [];
+            var maxCats = parcatsViewModel.model.maxCats;
+            var numCats = dimensionModel.categories.length;
+            var catSpacing = 8;
+            var totalCount = dimensionModel.count;
+            var totalHeight = parcatsViewModel.height - catSpacing * (maxCats - 1);
+            var nextCatHeight;
+            var nextCatModel;
+            var nextCat;
+            var catInd;
+            var catDisplayInd;
+            var nextCatY = (maxCats - numCats) * catSpacing / 2;
+            var categoryIndInfo = dimensionModel.categories.map(function(c2) {
+              return { displayInd: c2.displayInd, categoryInd: c2.categoryInd };
+            });
+            categoryIndInfo.sort(function(a2, b2) {
+              return a2.displayInd - b2.displayInd;
+            });
+            for (catDisplayInd = 0; catDisplayInd < numCats; catDisplayInd++) {
+              catInd = categoryIndInfo[catDisplayInd].categoryInd;
+              nextCatModel = dimensionModel.categories[catInd];
+              if (totalCount > 0) {
+                nextCatHeight = nextCatModel.count / totalCount * totalHeight;
+              } else {
+                nextCatHeight = 0;
+              }
+              nextCat = {
+                key: nextCatModel.valueInds[0],
+                model: nextCatModel,
+                width: dimWidth,
+                height: nextCatHeight,
+                y: nextCatModel.dragY !== null ? nextCatModel.dragY : nextCatY,
+                bands: [],
+                parcatsViewModel
+              };
+              nextCatY = nextCatY + nextCatHeight + catSpacing;
+              categories.push(nextCat);
+            }
+            return {
+              key: dimensionModel.dimensionInd,
+              x: dimensionModel.dragX !== null ? dimensionModel.dragX : dimX,
+              y: 0,
+              width: dimWidth,
+              model: dimensionModel,
+              categories,
+              parcatsViewModel,
+              dragCategoryDisplayInd: null,
+              dragDimensionDisplayInd: null,
+              initialDragDimensionDisplayInds: null,
+              initialDragCategoryDisplayInds: null,
+              dragHasMoved: null,
+              potentialClickBand: null
+            };
+          }
+        }
+      });
+      var require_plot22 = __commonJS({
+        "src/traces/parcats/plot.js"(exports, module2) {
+          var parcats = require_parcats();
+          module2.exports = function plot(graphDiv, parcatsModels, transitionOpts, makeOnCompleteCallback) {
+            var fullLayout = graphDiv._fullLayout;
+            var svg = fullLayout._paper;
+            var size = fullLayout._size;
+            parcats(
+              graphDiv,
+              svg,
+              parcatsModels,
+              {
+                width: size.w,
+                height: size.h,
+                margin: {
+                  t: size.t,
+                  r: size.r,
+                  b: size.b,
+                  l: size.l
+                }
+              },
+              transitionOpts,
+              makeOnCompleteCallback
+            );
+          };
+        }
+      });
+      var require_base_plot8 = __commonJS({
+        "src/traces/parcats/base_plot.js"(exports) {
+          var getModuleCalcData = require_get_data().getModuleCalcData;
+          var parcatsPlot = require_plot22();
+          var PARCATS = "parcats";
+          exports.name = PARCATS;
+          exports.plot = function(gd2, traces, transitionOpts, makeOnCompleteCallback) {
+            var cdModuleAndOthers = getModuleCalcData(gd2.calcdata, PARCATS);
+            if (cdModuleAndOthers.length) {
+              var calcData = cdModuleAndOthers[0];
+              parcatsPlot(gd2, calcData, transitionOpts, makeOnCompleteCallback);
+            }
+          };
+          exports.clean = function(newFullData, newFullLayout, oldFullData, oldFullLayout) {
+            var hadTable = oldFullLayout._has && oldFullLayout._has("parcats");
+            var hasTable = newFullLayout._has && newFullLayout._has("parcats");
+            if (hadTable && !hasTable) {
+              oldFullLayout._paperdiv.selectAll(".parcats").remove();
+            }
+          };
+        }
+      });
+      var require_parcats2 = __commonJS({
+        "src/traces/parcats/index.js"(exports, module2) {
+          module2.exports = {
+            attributes: require_attributes53(),
+            supplyDefaults: require_defaults49(),
+            calc: require_calc32(),
+            plot: require_plot22(),
+            colorbar: {
+              container: "line",
+              min: "cmin",
+              max: "cmax"
+            },
+            moduleType: "trace",
+            name: "parcats",
+            basePlotModule: require_base_plot8(),
+            categories: ["noOpacity"],
+            meta: {}
+          };
+        }
+      });
+      var require_parcats3 = __commonJS({
+        "lib/parcats.js"(exports, module2) {
+          module2.exports = require_parcats2();
+        }
+      });
+      var require_constants25 = __commonJS({
+        "src/plots/mapbox/constants.js"(exports, module2) {
+          var sortObjectKeys = require_sort_object_keys();
+          var requiredVersion = "1.13.4";
+          var OSM = '© <a target="_blank" href="https://www.openstreetmap.org/copyright">OpenStreetMap</a> contributors';
+          var carto = [
+            '© <a target="_blank" href="https://carto.com/">Carto</a>',
+            OSM
+          ].join(" ");
+          var stamenTerrainOrToner = [
+            'Map tiles by <a target="_blank" href="https://stamen.com">Stamen Design</a>',
+            'under <a target="_blank" href="https://creativecommons.org/licenses/by/3.0">CC BY 3.0</a>',
+            "|",
+            'Data by <a target="_blank" href="https://openstreetmap.org">OpenStreetMap</a> contributors',
+            'under <a target="_blank" href="https://www.openstreetmap.org/copyright">ODbL</a>'
+          ].join(" ");
+          var stamenWaterColor = [
+            'Map tiles by <a target="_blank" href="https://stamen.com">Stamen Design</a>',
+            'under <a target="_blank" href="https://creativecommons.org/licenses/by/3.0">CC BY 3.0</a>',
+            "|",
+            'Data by <a target="_blank" href="https://openstreetmap.org">OpenStreetMap</a> contributors',
+            'under <a target="_blank" href="https://creativecommons.org/licenses/by-sa/3.0">CC BY SA</a>'
+          ].join(" ");
+          var stylesNonMapbox = {
+            "open-street-map": {
+              id: "osm",
+              version: 8,
+              sources: {
+                "plotly-osm-tiles": {
+                  type: "raster",
+                  attribution: OSM,
+                  tiles: [
+                    "https://a.tile.openstreetmap.org/{z}/{x}/{y}.png",
+                    "https://b.tile.openstreetmap.org/{z}/{x}/{y}.png"
+                  ],
+                  tileSize: 256
+                }
+              },
+              layers: [{
+                id: "plotly-osm-tiles",
+                type: "raster",
+                source: "plotly-osm-tiles",
+                minzoom: 0,
+                maxzoom: 22
+              }],
+              glyphs: "https://fonts.openmaptiles.org/{fontstack}/{range}.pbf"
+            },
+            "white-bg": {
+              id: "white-bg",
+              version: 8,
+              sources: {},
+              layers: [{
+                id: "white-bg",
+                type: "background",
+                paint: { "background-color": "#FFFFFF" },
+                minzoom: 0,
+                maxzoom: 22
+              }],
+              glyphs: "https://fonts.openmaptiles.org/{fontstack}/{range}.pbf"
+            },
+            "carto-positron": {
+              id: "carto-positron",
+              version: 8,
+              sources: {
+                "plotly-carto-positron": {
+                  type: "raster",
+                  attribution: carto,
+                  tiles: ["https://cartodb-basemaps-c.global.ssl.fastly.net/light_all/{z}/{x}/{y}.png"],
+                  tileSize: 256
+                }
+              },
+              layers: [{
+                id: "plotly-carto-positron",
+                type: "raster",
+                source: "plotly-carto-positron",
+                minzoom: 0,
+                maxzoom: 22
+              }],
+              glyphs: "https://fonts.openmaptiles.org/{fontstack}/{range}.pbf"
+            },
+            "carto-darkmatter": {
+              id: "carto-darkmatter",
+              version: 8,
+              sources: {
+                "plotly-carto-darkmatter": {
+                  type: "raster",
+                  attribution: carto,
+                  tiles: ["https://cartodb-basemaps-c.global.ssl.fastly.net/dark_all/{z}/{x}/{y}.png"],
+                  tileSize: 256
+                }
+              },
+              layers: [{
+                id: "plotly-carto-darkmatter",
+                type: "raster",
+                source: "plotly-carto-darkmatter",
+                minzoom: 0,
+                maxzoom: 22
+              }],
+              glyphs: "https://fonts.openmaptiles.org/{fontstack}/{range}.pbf"
+            },
+            "stamen-terrain": {
+              id: "stamen-terrain",
+              version: 8,
+              sources: {
+                "plotly-stamen-terrain": {
+                  type: "raster",
+                  attribution: stamenTerrainOrToner,
+                  tiles: ["https://tiles.stadiamaps.com/tiles/stamen_terrain/{z}/{x}/{y}.png?api_key="],
+                  tileSize: 256
+                }
+              },
+              layers: [{
+                id: "plotly-stamen-terrain",
+                type: "raster",
+                source: "plotly-stamen-terrain",
+                minzoom: 0,
+                maxzoom: 22
+              }],
+              glyphs: "https://fonts.openmaptiles.org/{fontstack}/{range}.pbf"
+            },
+            "stamen-toner": {
+              id: "stamen-toner",
+              version: 8,
+              sources: {
+                "plotly-stamen-toner": {
+                  type: "raster",
+                  attribution: stamenTerrainOrToner,
+                  tiles: ["https://tiles.stadiamaps.com/tiles/stamen_toner/{z}/{x}/{y}.png?api_key="],
+                  tileSize: 256
+                }
+              },
+              layers: [{
+                id: "plotly-stamen-toner",
+                type: "raster",
+                source: "plotly-stamen-toner",
+                minzoom: 0,
+                maxzoom: 22
+              }],
+              glyphs: "https://fonts.openmaptiles.org/{fontstack}/{range}.pbf"
+            },
+            "stamen-watercolor": {
+              id: "stamen-watercolor",
+              version: 8,
+              sources: {
+                "plotly-stamen-watercolor": {
+                  type: "raster",
+                  attribution: stamenWaterColor,
+                  tiles: ["https://tiles.stadiamaps.com/tiles/stamen_watercolor/{z}/{x}/{y}.jpg?api_key="],
+                  tileSize: 256
+                }
+              },
+              layers: [{
+                id: "plotly-stamen-watercolor",
+                type: "raster",
+                source: "plotly-stamen-watercolor",
+                minzoom: 0,
+                maxzoom: 22
+              }],
+              glyphs: "https://fonts.openmaptiles.org/{fontstack}/{range}.pbf"
+            }
+          };
+          var styleValuesNonMapbox = sortObjectKeys(stylesNonMapbox);
+          module2.exports = {
+            requiredVersion,
+            styleUrlPrefix: "mapbox://styles/mapbox/",
+            styleUrlSuffix: "v9",
+            styleValuesMapbox: ["basic", "streets", "outdoors", "light", "dark", "satellite", "satellite-streets"],
+            styleValueDflt: "basic",
+            stylesNonMapbox,
+            styleValuesNonMapbox,
+            traceLayerPrefix: "plotly-trace-layer-",
+            layoutLayerPrefix: "plotly-layout-layer-",
+            wrongVersionErrorMsg: [
+              "Your custom plotly.js bundle is not using the correct mapbox-gl version",
+              "Please install @plotly/mapbox-gl@" + requiredVersion + "."
+            ].join("\n"),
+            noAccessTokenErrorMsg: [
+              "Missing Mapbox access token.",
+              "Mapbox trace type require a Mapbox access token to be registered.",
+              "For example:",
+              "  Plotly.newPlot(gd, data, layout, { mapboxAccessToken: 'my-access-token' });",
+              "More info here: https://www.mapbox.com/help/define-access-token/"
+            ].join("\n"),
+            missingStyleErrorMsg: [
+              "No valid mapbox style found, please set `mapbox.style` to one of:",
+              styleValuesNonMapbox.join(", "),
+              "or register a Mapbox access token to use a Mapbox-served style."
+            ].join("\n"),
+            multipleTokensErrorMsg: [
+              "Set multiple mapbox access token across different mapbox subplot,",
+              "using first token found as mapbox-gl does not allow multipleaccess tokens on the same page."
+            ].join("\n"),
+            mapOnErrorMsg: "Mapbox error.",
+            // Mapbox logo for static export
+            mapboxLogo: {
+              path0: "m 10.5,1.24 c -5.11,0 -9.25,4.15 -9.25,9.25 0,5.1 4.15,9.25 9.25,9.25 5.1,0 9.25,-4.15 9.25,-9.25 0,-5.11 -4.14,-9.25 -9.25,-9.25 z m 4.39,11.53 c -1.93,1.93 -4.78,2.31 -6.7,2.31 -0.7,0 -1.41,-0.05 -2.1,-0.16 0,0 -1.02,-5.64 2.14,-8.81 0.83,-0.83 1.95,-1.28 3.13,-1.28 1.27,0 2.49,0.51 3.39,1.42 1.84,1.84 1.89,4.75 0.14,6.52 z",
+              path1: "M 10.5,-0.01 C 4.7,-0.01 0,4.7 0,10.49 c 0,5.79 4.7,10.5 10.5,10.5 5.8,0 10.5,-4.7 10.5,-10.5 C 20.99,4.7 16.3,-0.01 10.5,-0.01 Z m 0,19.75 c -5.11,0 -9.25,-4.15 -9.25,-9.25 0,-5.1 4.14,-9.26 9.25,-9.26 5.11,0 9.25,4.15 9.25,9.25 0,5.13 -4.14,9.26 -9.25,9.26 z",
+              path2: "M 14.74,6.25 C 12.9,4.41 9.98,4.35 8.23,6.1 5.07,9.27 6.09,14.91 6.09,14.91 c 0,0 5.64,1.02 8.81,-2.14 C 16.64,11 16.59,8.09 14.74,6.25 Z m -2.27,4.09 -0.91,1.87 -0.9,-1.87 -1.86,-0.91 1.86,-0.9 0.9,-1.87 0.91,1.87 1.86,0.9 z",
+              polygon: "11.56,12.21 10.66,10.34 8.8,9.43 10.66,8.53 11.56,6.66 12.47,8.53 14.33,9.43 12.47,10.34"
+            },
+            // a subset of node_modules/mapbox-gl/dist/mapbox-gl.css
+            styleRules: {
+              map: "overflow:hidden;position:relative;",
+              "missing-css": "display:none;",
+              canary: "background-color:salmon;",
+              // Reusing CSS directives from: https://api.tiles.mapbox.com/mapbox-gl-js/v1.1.1/mapbox-gl.css
+              "ctrl-bottom-left": "position: absolute; pointer-events: none; z-index: 2; bottom: 0; left: 0;",
+              "ctrl-bottom-right": "position: absolute; pointer-events: none; z-index: 2; right: 0; bottom: 0;",
+              ctrl: "clear: both; pointer-events: auto; transform: translate(0, 0);",
+              // Compact ctrl
+              "ctrl-attrib.mapboxgl-compact .mapboxgl-ctrl-attrib-inner": "display: none;",
+              "ctrl-attrib.mapboxgl-compact:hover .mapboxgl-ctrl-attrib-inner": "display: block; margin-top:2px",
+              "ctrl-attrib.mapboxgl-compact:hover": "padding: 2px 24px 2px 4px; visibility: visible; margin-top: 6px;",
+              "ctrl-attrib.mapboxgl-compact::after": `content: ""; cursor: pointer; position: absolute; background-image: url('data:image/svg+xml;charset=utf-8,%3Csvg viewBox="0 0 20 20" xmlns="http://www.w3.org/2000/svg"%3E %3Cpath fill="%23333333" fill-rule="evenodd" d="M4,10a6,6 0 1,0 12,0a6,6 0 1,0 -12,0 M9,7a1,1 0 1,0 2,0a1,1 0 1,0 -2,0 M9,10a1,1 0 1,1 2,0l0,3a1,1 0 1,1 -2,0"/%3E %3C/svg%3E'); background-color: rgba(255, 255, 255, 0.5); width: 24px; height: 24px; box-sizing: border-box; border-radius: 12px;`,
+              "ctrl-attrib.mapboxgl-compact": "min-height: 20px; padding: 0; margin: 10px; position: relative; background-color: #fff; border-radius: 3px 12px 12px 3px;",
+              "ctrl-bottom-right > .mapboxgl-ctrl-attrib.mapboxgl-compact::after": "bottom: 0; right: 0",
+              "ctrl-bottom-left > .mapboxgl-ctrl-attrib.mapboxgl-compact::after": "bottom: 0; left: 0",
+              "ctrl-bottom-left .mapboxgl-ctrl": "margin: 0 0 10px 10px; float: left;",
+              "ctrl-bottom-right .mapboxgl-ctrl": "margin: 0 10px 10px 0; float: right;",
+              "ctrl-attrib": "color: rgba(0, 0, 0, 0.75); text-decoration: none; font-size: 12px",
+              "ctrl-attrib a": "color: rgba(0, 0, 0, 0.75); text-decoration: none; font-size: 12px",
+              "ctrl-attrib a:hover": "color: inherit; text-decoration: underline;",
+              "ctrl-attrib .mapbox-improve-map": "font-weight: bold; margin-left: 2px;",
+              "attrib-empty": "display: none;",
+              // Compact Mapbox logo without text
+              "ctrl-logo": `display:block; width: 21px; height: 21px; background-image: url('data:image/svg+xml;charset=utf-8,%3C?xml version="1.0" encoding="utf-8"?%3E %3Csvg version="1.1" id="Layer_1" xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink" x="0px" y="0px" viewBox="0 0 21 21" style="enable-background:new 0 0 21 21;" xml:space="preserve"%3E%3Cg transform="translate(0,0.01)"%3E%3Cpath d="m 10.5,1.24 c -5.11,0 -9.25,4.15 -9.25,9.25 0,5.1 4.15,9.25 9.25,9.25 5.1,0 9.25,-4.15 9.25,-9.25 0,-5.11 -4.14,-9.25 -9.25,-9.25 z m 4.39,11.53 c -1.93,1.93 -4.78,2.31 -6.7,2.31 -0.7,0 -1.41,-0.05 -2.1,-0.16 0,0 -1.02,-5.64 2.14,-8.81 0.83,-0.83 1.95,-1.28 3.13,-1.28 1.27,0 2.49,0.51 3.39,1.42 1.84,1.84 1.89,4.75 0.14,6.52 z" style="opacity:0.9;fill:%23ffffff;enable-background:new" class="st0"/%3E%3Cpath d="M 10.5,-0.01 C 4.7,-0.01 0,4.7 0,10.49 c 0,5.79 4.7,10.5 10.5,10.5 5.8,0 10.5,-4.7 10.5,-10.5 C 20.99,4.7 16.3,-0.01 10.5,-0.01 Z m 0,19.75 c -5.11,0 -9.25,-4.15 -9.25,-9.25 0,-5.1 4.14,-9.26 9.25,-9.26 5.11,0 9.25,4.15 9.25,9.25 0,5.13 -4.14,9.26 -9.25,9.26 z" style="opacity:0.35;enable-background:new" class="st1"/%3E%3Cpath d="M 14.74,6.25 C 12.9,4.41 9.98,4.35 8.23,6.1 5.07,9.27 6.09,14.91 6.09,14.91 c 0,0 5.64,1.02 8.81,-2.14 C 16.64,11 16.59,8.09 14.74,6.25 Z m -2.27,4.09 -0.91,1.87 -0.9,-1.87 -1.86,-0.91 1.86,-0.9 0.9,-1.87 0.91,1.87 1.86,0.9 z" style="opacity:0.35;enable-background:new" class="st1"/%3E%3Cpolygon points="11.56,12.21 10.66,10.34 8.8,9.43 10.66,8.53 11.56,6.66 12.47,8.53 14.33,9.43 12.47,10.34 " style="opacity:0.9;fill:%23ffffff;enable-background:new" class="st0"/%3E%3C/g%3E%3C/svg%3E')`
+              // Mapbox logo WITH text below (commented out for now)
+              // 'ctrl-logo': 'width: 85px; height: 21px; margin: 0 0 -3px -3px; display: block; background-repeat: no-repeat; cursor: pointer; background-image: url(\'data:image/svg+xml;charset=utf-8,%3C?xml version="1.0" encoding="utf-8"?%3E%3Csvg version="1.1" id="Layer_1" xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink" x="0px" y="0px" viewBox="0 0 84.49 21" style="enable-background:new 0 0 84.49 21;" xml:space="preserve"%3E%3Cg%3E %3Cpath class="st0" style="opacity:0.9; fill: %23FFFFFF; enable-background: new;" d="M83.25,14.26c0,0.12-0.09,0.21-0.21,0.21h-1.61c-0.13,0-0.24-0.06-0.3-0.17l-1.44-2.39l-1.44,2.39 c-0.06,0.11-0.18,0.17-0.3,0.17h-1.61c-0.04,0-0.08-0.01-0.12-0.03c-0.09-0.06-0.13-0.19-0.06-0.28l0,0l2.43-3.68L76.2,6.84 c-0.02-0.03-0.03-0.07-0.03-0.12c0-0.12,0.09-0.21,0.21-0.21h1.61c0.13,0,0.24,0.06,0.3,0.17l1.41,2.36l1.4-2.35 c0.06-0.11,0.18-0.17,0.3-0.17H83c0.04,0,0.08,0.01,0.12,0.03c0.09,0.06,0.13,0.19,0.06,0.28l0,0l-2.37,3.63l2.43,3.67 C83.24,14.18,83.25,14.22,83.25,14.26z"/%3E %3Cpath class="st0" style="opacity:0.9; fill: %23FFFFFF; enable-background: new;" d="M66.24,9.59c-0.39-1.88-1.96-3.28-3.84-3.28c-1.03,0-2.03,0.42-2.73,1.18V3.51c0-0.13-0.1-0.23-0.23-0.23h-1.4 c-0.13,0-0.23,0.11-0.23,0.23v10.72c0,0.13,0.1,0.23,0.23,0.23h1.4c0.13,0,0.23-0.11,0.23-0.23V13.5c0.71,0.75,1.7,1.18,2.73,1.18 c1.88,0,3.45-1.41,3.84-3.29C66.37,10.79,66.37,10.18,66.24,9.59L66.24,9.59z M62.08,13c-1.32,0-2.39-1.11-2.41-2.48v-0.06 c0.02-1.38,1.09-2.48,2.41-2.48s2.42,1.12,2.42,2.51S63.41,13,62.08,13z"/%3E %3Cpath class="st0" style="opacity:0.9; fill: %23FFFFFF; enable-background: new;" d="M71.67,6.32c-1.98-0.01-3.72,1.35-4.16,3.29c-0.13,0.59-0.13,1.19,0,1.77c0.44,1.94,2.17,3.32,4.17,3.3 c2.35,0,4.26-1.87,4.26-4.19S74.04,6.32,71.67,6.32z M71.65,13.01c-1.33,0-2.42-1.12-2.42-2.51s1.08-2.52,2.42-2.52 c1.33,0,2.42,1.12,2.42,2.51S72.99,13,71.65,13.01L71.65,13.01z"/%3E %3Cpath class="st1" style="opacity:0.35; enable-background:new;" d="M62.08,7.98c-1.32,0-2.39,1.11-2.41,2.48v0.06C59.68,11.9,60.75,13,62.08,13s2.42-1.12,2.42-2.51 S63.41,7.98,62.08,7.98z M62.08,11.76c-0.63,0-1.14-0.56-1.17-1.25v-0.04c0.01-0.69,0.54-1.25,1.17-1.25 c0.63,0,1.17,0.57,1.17,1.27C63.24,11.2,62.73,11.76,62.08,11.76z"/%3E %3Cpath class="st1" style="opacity:0.35; enable-background:new;" d="M71.65,7.98c-1.33,0-2.42,1.12-2.42,2.51S70.32,13,71.65,13s2.42-1.12,2.42-2.51S72.99,7.98,71.65,7.98z M71.65,11.76c-0.64,0-1.17-0.57-1.17-1.27c0-0.7,0.53-1.26,1.17-1.26s1.17,0.57,1.17,1.27C72.82,11.21,72.29,11.76,71.65,11.76z"/%3E %3Cpath class="st0" style="opacity:0.9; fill: %23FFFFFF; enable-background: new;" d="M45.74,6.53h-1.4c-0.13,0-0.23,0.11-0.23,0.23v0.73c-0.71-0.75-1.7-1.18-2.73-1.18 c-2.17,0-3.94,1.87-3.94,4.19s1.77,4.19,3.94,4.19c1.04,0,2.03-0.43,2.73-1.19v0.73c0,0.13,0.1,0.23,0.23,0.23h1.4 c0.13,0,0.23-0.11,0.23-0.23V6.74c0-0.12-0.09-0.22-0.22-0.22C45.75,6.53,45.75,6.53,45.74,6.53z M44.12,10.53 C44.11,11.9,43.03,13,41.71,13s-2.42-1.12-2.42-2.51s1.08-2.52,2.4-2.52c1.33,0,2.39,1.11,2.41,2.48L44.12,10.53z"/%3E %3Cpath class="st1" style="opacity:0.35; enable-background:new;" d="M41.71,7.98c-1.33,0-2.42,1.12-2.42,2.51S40.37,13,41.71,13s2.39-1.11,2.41-2.48v-0.06 C44.1,9.09,43.03,7.98,41.71,7.98z M40.55,10.49c0-0.7,0.52-1.27,1.17-1.27c0.64,0,1.14,0.56,1.17,1.25v0.04 c-0.01,0.68-0.53,1.24-1.17,1.24C41.08,11.75,40.55,11.19,40.55,10.49z"/%3E %3Cpath class="st0" style="opacity:0.9; fill: %23FFFFFF; enable-background: new;" d="M52.41,6.32c-1.03,0-2.03,0.42-2.73,1.18V6.75c0-0.13-0.1-0.23-0.23-0.23h-1.4c-0.13,0-0.23,0.11-0.23,0.23 v10.72c0,0.13,0.1,0.23,0.23,0.23h1.4c0.13,0,0.23-0.1,0.23-0.23V13.5c0.71,0.75,1.7,1.18,2.74,1.18c2.17,0,3.94-1.87,3.94-4.19 S54.58,6.32,52.41,6.32z M52.08,13.01c-1.32,0-2.39-1.11-2.42-2.48v-0.07c0.02-1.38,1.09-2.49,2.4-2.49c1.32,0,2.41,1.12,2.41,2.51 S53.4,13,52.08,13.01L52.08,13.01z"/%3E %3Cpath class="st1" style="opacity:0.35; enable-background:new;" d="M52.08,7.98c-1.32,0-2.39,1.11-2.42,2.48v0.06c0.03,1.38,1.1,2.48,2.42,2.48s2.41-1.12,2.41-2.51 S53.4,7.98,52.08,7.98z M52.08,11.76c-0.63,0-1.14-0.56-1.17-1.25v-0.04c0.01-0.69,0.54-1.25,1.17-1.25c0.63,0,1.17,0.58,1.17,1.27 S52.72,11.76,52.08,11.76z"/%3E %3Cpath class="st0" style="opacity:0.9; fill: %23FFFFFF; enable-background: new;" d="M36.08,14.24c0,0.13-0.1,0.23-0.23,0.23h-1.41c-0.13,0-0.23-0.11-0.23-0.23V9.68c0-0.98-0.74-1.71-1.62-1.71 c-0.8,0-1.46,0.7-1.59,1.62l0.01,4.66c0,0.13-0.11,0.23-0.23,0.23h-1.41c-0.13,0-0.23-0.11-0.23-0.23V9.68 c0-0.98-0.74-1.71-1.62-1.71c-0.85,0-1.54,0.79-1.6,1.8v4.48c0,0.13-0.1,0.23-0.23,0.23h-1.4c-0.13,0-0.23-0.11-0.23-0.23V6.74 c0.01-0.13,0.1-0.22,0.23-0.22h1.4c0.13,0,0.22,0.11,0.23,0.22V7.4c0.5-0.68,1.3-1.09,2.16-1.1h0.03c1.09,0,2.09,0.6,2.6,1.55 c0.45-0.95,1.4-1.55,2.44-1.56c1.62,0,2.93,1.25,2.9,2.78L36.08,14.24z"/%3E %3Cpath class="st1" style="opacity:0.35; enable-background:new;" d="M84.34,13.59l-0.07-0.13l-1.96-2.99l1.94-2.95c0.44-0.67,0.26-1.56-0.41-2.02c-0.02,0-0.03,0-0.04-0.01 c-0.23-0.15-0.5-0.22-0.78-0.22h-1.61c-0.56,0-1.08,0.29-1.37,0.78L79.72,6.6l-0.34-0.56C79.09,5.56,78.57,5.27,78,5.27h-1.6 c-0.6,0-1.13,0.37-1.35,0.92c-2.19-1.66-5.28-1.47-7.26,0.45c-0.35,0.34-0.65,0.72-0.89,1.14c-0.9-1.62-2.58-2.72-4.5-2.72 c-0.5,0-1.01,0.07-1.48,0.23V3.51c0-0.82-0.66-1.48-1.47-1.48h-1.4c-0.81,0-1.47,0.66-1.47,1.47v3.75 c-0.95-1.36-2.5-2.18-4.17-2.19c-0.74,0-1.46,0.16-2.12,0.47c-0.24-0.17-0.54-0.26-0.84-0.26h-1.4c-0.45,0-0.87,0.21-1.15,0.56 c-0.02-0.03-0.04-0.05-0.07-0.08c-0.28-0.3-0.68-0.47-1.09-0.47h-1.39c-0.3,0-0.6,0.09-0.84,0.26c-0.67-0.3-1.39-0.46-2.12-0.46 c-1.83,0-3.43,1-4.37,2.5c-0.2-0.46-0.48-0.89-0.83-1.25c-0.8-0.81-1.89-1.25-3.02-1.25h-0.01c-0.89,0.01-1.75,0.33-2.46,0.88 c-0.74-0.57-1.64-0.88-2.57-0.88H28.1c-0.29,0-0.58,0.03-0.86,0.11c-0.28,0.06-0.56,0.16-0.82,0.28c-0.21-0.12-0.45-0.18-0.7-0.18 h-1.4c-0.82,0-1.47,0.66-1.47,1.47v7.5c0,0.82,0.66,1.47,1.47,1.47h1.4c0.82,0,1.48-0.66,1.48-1.48l0,0V9.79 c0.03-0.36,0.23-0.59,0.36-0.59c0.18,0,0.38,0.18,0.38,0.47v4.57c0,0.82,0.66,1.47,1.47,1.47h1.41c0.82,0,1.47-0.66,1.47-1.47 l-0.01-4.57c0.06-0.32,0.25-0.47,0.35-0.47c0.18,0,0.38,0.18,0.38,0.47v4.57c0,0.82,0.66,1.47,1.47,1.47h1.41 c0.82,0,1.47-0.66,1.47-1.47v-0.38c0.96,1.29,2.46,2.06,4.06,2.06c0.74,0,1.46-0.16,2.12-0.47c0.24,0.17,0.54,0.26,0.84,0.26h1.39 c0.3,0,0.6-0.09,0.84-0.26v2.01c0,0.82,0.66,1.47,1.47,1.47h1.4c0.82,0,1.47-0.66,1.47-1.47v-1.77c0.48,0.15,0.99,0.23,1.49,0.22 c1.7,0,3.22-0.87,4.17-2.2v0.52c0,0.82,0.66,1.47,1.47,1.47h1.4c0.3,0,0.6-0.09,0.84-0.26c0.66,0.31,1.39,0.47,2.12,0.47 c1.92,0,3.6-1.1,4.49-2.73c1.54,2.65,4.95,3.53,7.58,1.98c0.18-0.11,0.36-0.22,0.53-0.36c0.22,0.55,0.76,0.91,1.35,0.9H78 c0.56,0,1.08-0.29,1.37-0.78l0.37-0.61l0.37,0.61c0.29,0.48,0.81,0.78,1.38,0.78h1.6c0.81,0,1.46-0.66,1.45-1.46 C84.49,14.02,84.44,13.8,84.34,13.59L84.34,13.59z M35.86,14.47h-1.41c-0.13,0-0.23-0.11-0.23-0.23V9.68 c0-0.98-0.74-1.71-1.62-1.71c-0.8,0-1.46,0.7-1.59,1.62l0.01,4.66c0,0.13-0.1,0.23-0.23,0.23h-1.41c-0.13,0-0.23-0.11-0.23-0.23 V9.68c0-0.98-0.74-1.71-1.62-1.71c-0.85,0-1.54,0.79-1.6,1.8v4.48c0,0.13-0.1,0.23-0.23,0.23h-1.4c-0.13,0-0.23-0.11-0.23-0.23 V6.74c0.01-0.13,0.11-0.22,0.23-0.22h1.4c0.13,0,0.22,0.11,0.23,0.22V7.4c0.5-0.68,1.3-1.09,2.16-1.1h0.03 c1.09,0,2.09,0.6,2.6,1.55c0.45-0.95,1.4-1.55,2.44-1.56c1.62,0,2.93,1.25,2.9,2.78l0.01,5.16C36.09,14.36,35.98,14.46,35.86,14.47 L35.86,14.47z M45.97,14.24c0,0.13-0.1,0.23-0.23,0.23h-1.4c-0.13,0-0.23-0.11-0.23-0.23V13.5c-0.7,0.76-1.69,1.18-2.72,1.18 c-2.17,0-3.94-1.87-3.94-4.19s1.77-4.19,3.94-4.19c1.03,0,2.02,0.43,2.73,1.18V6.74c0-0.13,0.1-0.23,0.23-0.23h1.4 c0.12-0.01,0.22,0.08,0.23,0.21c0,0.01,0,0.01,0,0.02v7.51h-0.01V14.24z M52.41,14.67c-1.03,0-2.02-0.43-2.73-1.18v3.97 c0,0.13-0.1,0.23-0.23,0.23h-1.4c-0.13,0-0.23-0.1-0.23-0.23V6.75c0-0.13,0.1-0.22,0.23-0.22h1.4c0.13,0,0.23,0.11,0.23,0.23v0.73 c0.71-0.76,1.7-1.18,2.73-1.18c2.17,0,3.94,1.86,3.94,4.18S54.58,14.67,52.41,14.67z M66.24,11.39c-0.39,1.87-1.96,3.29-3.84,3.29 c-1.03,0-2.02-0.43-2.73-1.18v0.73c0,0.13-0.1,0.23-0.23,0.23h-1.4c-0.13,0-0.23-0.11-0.23-0.23V3.51c0-0.13,0.1-0.23,0.23-0.23 h1.4c0.13,0,0.23,0.11,0.23,0.23v3.97c0.71-0.75,1.7-1.18,2.73-1.17c1.88,0,3.45,1.4,3.84,3.28C66.37,10.19,66.37,10.8,66.24,11.39 L66.24,11.39L66.24,11.39z M71.67,14.68c-2,0.01-3.73-1.35-4.17-3.3c-0.13-0.59-0.13-1.19,0-1.77c0.44-1.94,2.17-3.31,4.17-3.3 c2.36,0,4.26,1.87,4.26,4.19S74.03,14.68,71.67,14.68L71.67,14.68z M83.04,14.47h-1.61c-0.13,0-0.24-0.06-0.3-0.17l-1.44-2.39 l-1.44,2.39c-0.06,0.11-0.18,0.17-0.3,0.17h-1.61c-0.04,0-0.08-0.01-0.12-0.03c-0.09-0.06-0.13-0.19-0.06-0.28l0,0l2.43-3.68 L76.2,6.84c-0.02-0.03-0.03-0.07-0.03-0.12c0-0.12,0.09-0.21,0.21-0.21h1.61c0.13,0,0.24,0.06,0.3,0.17l1.41,2.36l1.41-2.36 c0.06-0.11,0.18-0.17,0.3-0.17h1.61c0.04,0,0.08,0.01,0.12,0.03c0.09,0.06,0.13,0.19,0.06,0.28l0,0l-2.38,3.64l2.43,3.67 c0.02,0.03,0.03,0.07,0.03,0.12C83.25,14.38,83.16,14.47,83.04,14.47L83.04,14.47L83.04,14.47z"/%3E %3Cpath class="st0" style="opacity:0.9; fill: %23FFFFFF; enable-background: new;" d="M10.5,1.24c-5.11,0-9.25,4.15-9.25,9.25s4.15,9.25,9.25,9.25s9.25-4.15,9.25-9.25 C19.75,5.38,15.61,1.24,10.5,1.24z M14.89,12.77c-1.93,1.93-4.78,2.31-6.7,2.31c-0.7,0-1.41-0.05-2.1-0.16c0,0-1.02-5.64,2.14-8.81 c0.83-0.83,1.95-1.28,3.13-1.28c1.27,0,2.49,0.51,3.39,1.42C16.59,8.09,16.64,11,14.89,12.77z"/%3E %3Cpath class="st1" style="opacity:0.35; enable-background:new;" d="M10.5-0.01C4.7-0.01,0,4.7,0,10.49s4.7,10.5,10.5,10.5S21,16.29,21,10.49C20.99,4.7,16.3-0.01,10.5-0.01z M10.5,19.74c-5.11,0-9.25-4.15-9.25-9.25s4.14-9.26,9.25-9.26s9.25,4.15,9.25,9.25C19.75,15.61,15.61,19.74,10.5,19.74z"/%3E %3Cpath class="st1" style="opacity:0.35; enable-background:new;" d="M14.74,6.25C12.9,4.41,9.98,4.35,8.23,6.1c-3.16,3.17-2.14,8.81-2.14,8.81s5.64,1.02,8.81-2.14 C16.64,11,16.59,8.09,14.74,6.25z M12.47,10.34l-0.91,1.87l-0.9-1.87L8.8,9.43l1.86-0.9l0.9-1.87l0.91,1.87l1.86,0.9L12.47,10.34z"/%3E %3Cpolygon class="st0" style="opacity:0.9; fill: %23FFFFFF; enable-background: new;" points="14.33,9.43 12.47,10.34 11.56,12.21 10.66,10.34 8.8,9.43 10.66,8.53 11.56,6.66 12.47,8.53 "/%3E%3C/g%3E%3C/svg%3E\');'
+            }
+          };
+        }
+      });
+      var require_layout_attributes19 = __commonJS({
+        "src/plots/mapbox/layout_attributes.js"(exports, module2) {
+          var Lib = require_lib();
+          var defaultLine = require_color().defaultLine;
+          var domainAttrs = require_domain().attributes;
+          var fontAttrs = require_font_attributes();
+          var textposition = require_attributes12().textposition;
+          var overrideAll = require_edit_types().overrideAll;
+          var templatedArray = require_plot_template().templatedArray;
+          var constants = require_constants25();
+          var fontAttr = fontAttrs({
+            noFontVariant: true,
+            noFontShadow: true,
+            noFontLineposition: true,
+            noFontTextcase: true
+          });
+          fontAttr.family.dflt = "Open Sans Regular, Arial Unicode MS Regular";
+          var attrs = module2.exports = overrideAll({
+            _arrayAttrRegexps: [Lib.counterRegex("mapbox", ".layers", true)],
+            domain: domainAttrs({ name: "mapbox" }),
+            accesstoken: {
+              valType: "string",
+              noBlank: true,
+              strict: true
+            },
+            style: {
+              valType: "any",
+              values: constants.styleValuesMapbox.concat(constants.styleValuesNonMapbox),
+              dflt: constants.styleValueDflt
+            },
+            center: {
+              lon: {
+                valType: "number",
+                dflt: 0
+              },
+              lat: {
+                valType: "number",
+                dflt: 0
+              }
+            },
+            zoom: {
+              valType: "number",
+              dflt: 1
+            },
+            bearing: {
+              valType: "number",
+              dflt: 0
+            },
+            pitch: {
+              valType: "number",
+              dflt: 0
+            },
+            bounds: {
+              west: {
+                valType: "number"
+              },
+              east: {
+                valType: "number"
+              },
+              south: {
+                valType: "number"
+              },
+              north: {
+                valType: "number"
+              }
+            },
+            layers: templatedArray("layer", {
+              visible: {
+                valType: "boolean",
+                dflt: true
+              },
+              sourcetype: {
+                valType: "enumerated",
+                values: ["geojson", "vector", "raster", "image"],
+                dflt: "geojson"
+              },
+              source: {
+                valType: "any"
+              },
+              sourcelayer: {
+                valType: "string",
+                dflt: ""
+              },
+              sourceattribution: {
+                valType: "string"
+              },
+              type: {
+                valType: "enumerated",
+                values: ["circle", "line", "fill", "symbol", "raster"],
+                dflt: "circle"
+              },
+              coordinates: {
+                valType: "any"
+              },
+              // attributes shared between all types
+              below: {
+                valType: "string"
+              },
+              color: {
+                valType: "color",
+                dflt: defaultLine
+              },
+              opacity: {
+                valType: "number",
+                min: 0,
+                max: 1,
+                dflt: 1
+              },
+              minzoom: {
+                valType: "number",
+                min: 0,
+                max: 24,
+                dflt: 0
+              },
+              maxzoom: {
+                valType: "number",
+                min: 0,
+                max: 24,
+                dflt: 24
+              },
+              // type-specific style attributes
+              circle: {
+                radius: {
+                  valType: "number",
+                  dflt: 15
+                }
+              },
+              line: {
+                width: {
+                  valType: "number",
+                  dflt: 2
+                },
+                dash: {
+                  valType: "data_array"
+                }
+              },
+              fill: {
+                outlinecolor: {
+                  valType: "color",
+                  dflt: defaultLine
+                }
+              },
+              symbol: {
+                icon: {
+                  valType: "string",
+                  dflt: "marker"
+                },
+                iconsize: {
+                  valType: "number",
+                  dflt: 10
+                },
+                text: {
+                  valType: "string",
+                  dflt: ""
+                },
+                placement: {
+                  valType: "enumerated",
+                  values: ["point", "line", "line-center"],
+                  dflt: "point"
+                },
+                textfont: fontAttr,
+                textposition: Lib.extendFlat({}, textposition, { arrayOk: false })
+              }
+            })
+          }, "plot", "from-root");
+          attrs.uirevision = {
+            valType: "any",
+            editType: "none"
+          };
+        }
+      });
+      var require_attributes54 = __commonJS({
+        "src/traces/scattermapbox/attributes.js"(exports, module2) {
+          var { hovertemplateAttrs, texttemplateAttrs, templatefallbackAttrs } = require_template_attributes();
+          var makeFillcolorAttr = require_fillcolor_attribute();
+          var scatterGeoAttrs = require_attributes48();
+          var scatterAttrs = require_attributes12();
+          var mapboxAttrs = require_layout_attributes19();
+          var baseAttrs = require_attributes2();
+          var colorScaleAttrs = require_attributes8();
+          var extendFlat = require_extend().extendFlat;
+          var overrideAll = require_edit_types().overrideAll;
+          var mapboxLayoutAtributes = require_layout_attributes19();
+          var lineAttrs = scatterGeoAttrs.line;
+          var markerAttrs = scatterGeoAttrs.marker;
+          module2.exports = overrideAll(
+            {
+              lon: scatterGeoAttrs.lon,
+              lat: scatterGeoAttrs.lat,
+              cluster: {
+                enabled: {
+                  valType: "boolean"
+                },
+                maxzoom: extendFlat({}, mapboxLayoutAtributes.layers.maxzoom, {}),
+                step: {
+                  valType: "number",
+                  arrayOk: true,
+                  dflt: -1,
+                  min: -1
+                },
+                size: {
+                  valType: "number",
+                  arrayOk: true,
+                  dflt: 20,
+                  min: 0
+                },
+                color: {
+                  valType: "color",
+                  arrayOk: true
+                },
+                opacity: extendFlat({}, markerAttrs.opacity, {
+                  dflt: 1
+                })
+              },
+              // locations
+              // locationmode
+              mode: extendFlat({}, scatterAttrs.mode, {
+                dflt: "markers"
+              }),
+              text: extendFlat({}, scatterAttrs.text, {}),
+              texttemplate: texttemplateAttrs({ editType: "plot" }, { keys: ["lat", "lon", "text"] }),
+              texttemplatefallback: templatefallbackAttrs({ editType: "plot" }),
+              hovertext: extendFlat({}, scatterAttrs.hovertext, {}),
+              line: {
+                color: lineAttrs.color,
+                width: lineAttrs.width
+                // TODO
+                // dash: dash
+              },
+              connectgaps: scatterAttrs.connectgaps,
+              marker: extendFlat(
+                {
+                  symbol: {
+                    valType: "string",
+                    dflt: "circle",
+                    arrayOk: true
+                  },
+                  angle: {
+                    valType: "number",
+                    dflt: "auto",
+                    arrayOk: true
+                  },
+                  allowoverlap: {
+                    valType: "boolean",
+                    dflt: false
+                  },
+                  opacity: markerAttrs.opacity,
+                  size: markerAttrs.size,
+                  sizeref: markerAttrs.sizeref,
+                  sizemin: markerAttrs.sizemin,
+                  sizemode: markerAttrs.sizemode
+                },
+                colorScaleAttrs("marker")
+                // line
+              ),
+              fill: scatterGeoAttrs.fill,
+              fillcolor: makeFillcolorAttr(),
+              textfont: mapboxAttrs.layers.symbol.textfont,
+              textposition: mapboxAttrs.layers.symbol.textposition,
+              below: {
+                valType: "string"
+              },
+              selected: {
+                marker: scatterAttrs.selected.marker
+              },
+              unselected: {
+                marker: scatterAttrs.unselected.marker
+              },
+              hoverinfo: extendFlat({}, baseAttrs.hoverinfo, {
+                flags: ["lon", "lat", "text", "name"]
+              }),
+              hovertemplate: hovertemplateAttrs(),
+              hovertemplatefallback: templatefallbackAttrs()
+            },
+            "calc",
+            "nested"
+          );
+        }
+      });
+      var require_constants26 = __commonJS({
+        "src/traces/scattermapbox/constants.js"(exports, module2) {
+          var supportedFonts = [
+            "Metropolis Black Italic",
+            "Metropolis Black",
+            "Metropolis Bold Italic",
+            "Metropolis Bold",
+            "Metropolis Extra Bold Italic",
+            "Metropolis Extra Bold",
+            "Metropolis Extra Light Italic",
+            "Metropolis Extra Light",
+            "Metropolis Light Italic",
+            "Metropolis Light",
+            "Metropolis Medium Italic",
+            "Metropolis Medium",
+            "Metropolis Regular Italic",
+            "Metropolis Regular",
+            "Metropolis Semi Bold Italic",
+            "Metropolis Semi Bold",
+            "Metropolis Thin Italic",
+            "Metropolis Thin",
+            "Open Sans Bold Italic",
+            "Open Sans Bold",
+            "Open Sans Extrabold Italic",
+            "Open Sans Extrabold",
+            "Open Sans Italic",
+            "Open Sans Light Italic",
+            "Open Sans Light",
+            "Open Sans Regular",
+            "Open Sans Semibold Italic",
+            "Open Sans Semibold",
+            "Klokantech Noto Sans Bold",
+            "Klokantech Noto Sans CJK Bold",
+            "Klokantech Noto Sans CJK Regular",
+            "Klokantech Noto Sans Italic",
+            "Klokantech Noto Sans Regular"
+          ];
+          module2.exports = {
+            isSupportedFont: function(a2) {
+              return supportedFonts.indexOf(a2) !== -1;
+            }
+          };
+        }
+      });
+      var require_defaults50 = __commonJS({
+        "src/traces/scattermapbox/defaults.js"(exports, module2) {
+          var Lib = require_lib();
+          var subTypes = require_subtypes();
+          var handleMarkerDefaults = require_marker_defaults();
+          var handleLineDefaults = require_line_defaults();
+          var handleTextDefaults = require_text_defaults();
+          var handleFillColorDefaults = require_fillcolor_defaults();
+          var attributes = require_attributes54();
+          var isSupportedFont = require_constants26().isSupportedFont;
+          module2.exports = function supplyDefaults(traceIn, traceOut, defaultColor, layout) {
+            function coerce(attr, dflt) {
+              return Lib.coerce(traceIn, traceOut, attributes, attr, dflt);
+            }
+            function coerce2(attr, dflt) {
+              return Lib.coerce2(traceIn, traceOut, attributes, attr, dflt);
+            }
+            var len2 = handleLonLatDefaults(traceIn, traceOut, coerce);
+            if (!len2) {
+              traceOut.visible = false;
+              return;
+            }
+            coerce("text");
+            coerce("texttemplate");
+            coerce("texttemplatefallback");
+            coerce("hovertext");
+            coerce("hovertemplate");
+            coerce("hovertemplatefallback");
+            coerce("mode");
+            coerce("below");
+            if (subTypes.hasMarkers(traceOut)) {
+              handleMarkerDefaults(traceIn, traceOut, defaultColor, layout, coerce, { noLine: true, noAngle: true });
+              coerce("marker.allowoverlap");
+              coerce("marker.angle");
+              var marker = traceOut.marker;
+              if (marker.symbol !== "circle") {
+                if (Lib.isArrayOrTypedArray(marker.size)) marker.size = marker.size[0];
+                if (Lib.isArrayOrTypedArray(marker.color)) marker.color = marker.color[0];
+              }
+            }
+            if (subTypes.hasLines(traceOut)) {
+              handleLineDefaults(traceIn, traceOut, defaultColor, layout, coerce, { noDash: true });
+              coerce("connectgaps");
+            }
+            var clusterMaxzoom = coerce2("cluster.maxzoom");
+            var clusterStep = coerce2("cluster.step");
+            var clusterColor = coerce2("cluster.color", traceOut.marker && traceOut.marker.color || defaultColor);
+            var clusterSize = coerce2("cluster.size");
+            var clusterOpacity = coerce2("cluster.opacity");
+            var clusterEnabledDflt = clusterMaxzoom !== false || clusterStep !== false || clusterColor !== false || clusterSize !== false || clusterOpacity !== false;
+            var clusterEnabled = coerce("cluster.enabled", clusterEnabledDflt);
+            if (clusterEnabled || subTypes.hasText(traceOut)) {
+              var layoutFontFamily = layout.font.family;
+              handleTextDefaults(traceIn, traceOut, layout, coerce, {
+                noSelect: true,
+                noFontVariant: true,
+                noFontShadow: true,
+                noFontLineposition: true,
+                noFontTextcase: true,
+                font: {
+                  family: isSupportedFont(layoutFontFamily) ? layoutFontFamily : "Open Sans Regular",
+                  weight: layout.font.weight,
+                  style: layout.font.style,
+                  size: layout.font.size,
+                  color: layout.font.color
+                }
+              });
+            }
+            coerce("fill");
+            if (traceOut.fill !== "none") {
+              handleFillColorDefaults(traceIn, traceOut, defaultColor, coerce);
+            }
+            Lib.coerceSelectionMarkerOpacity(traceOut, coerce);
+          };
+          function handleLonLatDefaults(traceIn, traceOut, coerce) {
+            var lon = coerce("lon") || [];
+            var lat = coerce("lat") || [];
+            var len2 = Math.min(lon.length, lat.length);
+            traceOut._length = len2;
+            return len2;
+          }
+        }
+      });
+      var require_format_labels5 = __commonJS({
+        "src/traces/scattermapbox/format_labels.js"(exports, module2) {
+          var Axes = require_axes();
+          module2.exports = function formatLabels(cdi, trace, fullLayout) {
+            var labels = {};
+            var subplot = fullLayout[trace.subplot]._subplot;
+            var ax = subplot.mockAxis;
+            var lonlat = cdi.lonlat;
+            labels.lonLabel = Axes.tickText(ax, ax.c2l(lonlat[0]), true).text;
+            labels.latLabel = Axes.tickText(ax, ax.c2l(lonlat[1]), true).text;
+            return labels;
+          };
+        }
+      });
+      var require_convert_text_opts = __commonJS({
+        "src/plots/mapbox/convert_text_opts.js"(exports, module2) {
+          var Lib = require_lib();
+          module2.exports = function convertTextOpts(textposition, iconSize) {
+            var parts = textposition.split(" ");
+            var vPos = parts[0];
+            var hPos = parts[1];
+            var factor = Lib.isArrayOrTypedArray(iconSize) ? Lib.mean(iconSize) : iconSize;
+            var xInc = 0.5 + factor / 100;
+            var yInc = 1.5 + factor / 100;
+            var anchorVals = ["", ""];
+            var offset = [0, 0];
+            switch (vPos) {
+              case "top":
+                anchorVals[0] = "top";
+                offset[1] = -yInc;
+                break;
+              case "bottom":
+                anchorVals[0] = "bottom";
+                offset[1] = yInc;
+                break;
+            }
+            switch (hPos) {
+              case "left":
+                anchorVals[1] = "right";
+                offset[0] = -xInc;
+                break;
+              case "right":
+                anchorVals[1] = "left";
+                offset[0] = xInc;
+                break;
+            }
+            var anchor;
+            if (anchorVals[0] && anchorVals[1]) anchor = anchorVals.join("-");
+            else if (anchorVals[0]) anchor = anchorVals[0];
+            else if (anchorVals[1]) anchor = anchorVals[1];
+            else anchor = "center";
+            return { anchor, offset };
+          };
+        }
+      });
+      var require_convert11 = __commonJS({
+        "src/traces/scattermapbox/convert.js"(exports, module2) {
+          var isNumeric = require_fast_isnumeric();
+          var Lib = require_lib();
+          var BADNUM = require_numerical().BADNUM;
+          var geoJsonUtils = require_geojson_utils();
+          var Colorscale = require_colorscale();
+          var Drawing = require_drawing();
+          var makeBubbleSizeFn = require_make_bubble_size_func();
+          var subTypes = require_subtypes();
+          var isSupportedFont = require_constants26().isSupportedFont;
+          var convertTextOpts = require_convert_text_opts();
+          var appendArrayPointValue = require_helpers2().appendArrayPointValue;
+          var NEWLINES = require_svg_text_utils().NEWLINES;
+          var BR_TAG_ALL = require_svg_text_utils().BR_TAG_ALL;
+          module2.exports = function convert(gd2, calcTrace) {
+            var trace = calcTrace[0].trace;
+            var isVisible = trace.visible === true && trace._length !== 0;
+            var hasFill = trace.fill !== "none";
+            var hasLines = subTypes.hasLines(trace);
+            var hasMarkers = subTypes.hasMarkers(trace);
+            var hasText = subTypes.hasText(trace);
+            var hasCircles = hasMarkers && trace.marker.symbol === "circle";
+            var hasSymbols = hasMarkers && trace.marker.symbol !== "circle";
+            var hasCluster = trace.cluster && trace.cluster.enabled;
+            var fill = initContainer("fill");
+            var line = initContainer("line");
+            var circle = initContainer("circle");
+            var symbol = initContainer("symbol");
+            var opts = {
+              fill,
+              line,
+              circle,
+              symbol
+            };
+            if (!isVisible) return opts;
+            var lineCoords;
+            if (hasFill || hasLines) {
+              lineCoords = geoJsonUtils.calcTraceToLineCoords(calcTrace);
+            }
+            if (hasFill) {
+              fill.geojson = geoJsonUtils.makePolygon(lineCoords);
+              fill.layout.visibility = "visible";
+              Lib.extendFlat(fill.paint, {
+                "fill-color": trace.fillcolor
+              });
+            }
+            if (hasLines) {
+              line.geojson = geoJsonUtils.makeLine(lineCoords);
+              line.layout.visibility = "visible";
+              Lib.extendFlat(line.paint, {
+                "line-width": trace.line.width,
+                "line-color": trace.line.color,
+                "line-opacity": trace.opacity
+              });
+            }
+            if (hasCircles) {
+              var circleOpts = makeCircleOpts(calcTrace);
+              circle.geojson = circleOpts.geojson;
+              circle.layout.visibility = "visible";
+              if (hasCluster) {
+                circle.filter = ["!", ["has", "point_count"]];
+                opts.cluster = {
+                  type: "circle",
+                  filter: ["has", "point_count"],
+                  layout: { visibility: "visible" },
+                  paint: {
+                    "circle-color": arrayifyAttribute(trace.cluster.color, trace.cluster.step),
+                    "circle-radius": arrayifyAttribute(trace.cluster.size, trace.cluster.step),
+                    "circle-opacity": arrayifyAttribute(trace.cluster.opacity, trace.cluster.step)
+                  }
+                };
+                opts.clusterCount = {
+                  type: "symbol",
+                  filter: ["has", "point_count"],
+                  paint: {},
+                  layout: {
+                    "text-field": "{point_count_abbreviated}",
+                    "text-font": getTextFont(trace),
+                    "text-size": 12
+                  }
+                };
+              }
+              Lib.extendFlat(circle.paint, {
+                "circle-color": circleOpts.mcc,
+                "circle-radius": circleOpts.mrc,
+                "circle-opacity": circleOpts.mo
+              });
+            }
+            if (hasCircles && hasCluster) {
+              circle.filter = ["!", ["has", "point_count"]];
+            }
+            if (hasSymbols || hasText) {
+              symbol.geojson = makeSymbolGeoJSON(calcTrace, gd2);
+              Lib.extendFlat(symbol.layout, {
+                visibility: "visible",
+                "icon-image": "{symbol}-15",
+                "text-field": "{text}"
+              });
+              if (hasSymbols) {
+                Lib.extendFlat(symbol.layout, {
+                  "icon-size": trace.marker.size / 10
+                });
+                if ("angle" in trace.marker && trace.marker.angle !== "auto") {
+                  Lib.extendFlat(symbol.layout, {
+                    // unfortunately cant use {angle} do to this issue:
+                    // https://github.com/mapbox/mapbox-gl-js/issues/873
+                    "icon-rotate": {
+                      type: "identity",
+                      property: "angle"
+                    },
+                    "icon-rotation-alignment": "map"
+                  });
+                }
+                symbol.layout["icon-allow-overlap"] = trace.marker.allowoverlap;
+                Lib.extendFlat(symbol.paint, {
+                  "icon-opacity": trace.opacity * trace.marker.opacity,
+                  // TODO does not work ??
+                  "icon-color": trace.marker.color
+                });
+              }
+              if (hasText) {
+                var iconSize = (trace.marker || {}).size;
+                var textOpts = convertTextOpts(trace.textposition, iconSize);
+                Lib.extendFlat(symbol.layout, {
+                  "text-size": trace.textfont.size,
+                  "text-anchor": textOpts.anchor,
+                  "text-offset": textOpts.offset,
+                  "text-font": getTextFont(trace)
+                });
+                Lib.extendFlat(symbol.paint, {
+                  "text-color": trace.textfont.color,
+                  "text-opacity": trace.opacity
+                });
+              }
+            }
+            return opts;
+          };
+          function initContainer(type) {
+            return {
+              type,
+              geojson: geoJsonUtils.makeBlank(),
+              layout: { visibility: "none" },
+              filter: null,
+              paint: {}
+            };
+          }
+          function makeCircleOpts(calcTrace) {
+            var trace = calcTrace[0].trace;
+            var marker = trace.marker;
+            var selectedpoints = trace.selectedpoints;
+            var arrayColor = Lib.isArrayOrTypedArray(marker.color);
+            var arraySize = Lib.isArrayOrTypedArray(marker.size);
+            var arrayOpacity = Lib.isArrayOrTypedArray(marker.opacity);
+            var i2;
+            function addTraceOpacity(o2) {
+              return trace.opacity * o2;
+            }
+            function size2radius(s2) {
+              return s2 / 2;
+            }
+            var colorFn;
+            if (arrayColor) {
+              if (Colorscale.hasColorscale(trace, "marker")) {
+                colorFn = Colorscale.makeColorScaleFuncFromTrace(marker);
+              } else {
+                colorFn = Lib.identity;
+              }
+            }
+            var sizeFn;
+            if (arraySize) {
+              sizeFn = makeBubbleSizeFn(trace);
+            }
+            var opacityFn;
+            if (arrayOpacity) {
+              opacityFn = function(mo) {
+                var mo2 = isNumeric(mo) ? +Lib.constrain(mo, 0, 1) : 0;
+                return addTraceOpacity(mo2);
+              };
+            }
+            var features = [];
+            for (i2 = 0; i2 < calcTrace.length; i2++) {
+              var calcPt = calcTrace[i2];
+              var lonlat = calcPt.lonlat;
+              if (isBADNUM(lonlat)) continue;
+              var props = {};
+              if (colorFn) props.mcc = calcPt.mcc = colorFn(calcPt.mc);
+              if (sizeFn) props.mrc = calcPt.mrc = sizeFn(calcPt.ms);
+              if (opacityFn) props.mo = opacityFn(calcPt.mo);
+              if (selectedpoints) props.selected = calcPt.selected || 0;
+              features.push({
+                type: "Feature",
+                id: i2 + 1,
+                geometry: { type: "Point", coordinates: lonlat },
+                properties: props
+              });
+            }
+            var fns;
+            if (selectedpoints) {
+              fns = Drawing.makeSelectedPointStyleFns(trace);
+              for (i2 = 0; i2 < features.length; i2++) {
+                var d2 = features[i2].properties;
+                if (fns.selectedOpacityFn) {
+                  d2.mo = addTraceOpacity(fns.selectedOpacityFn(d2));
+                }
+                if (fns.selectedColorFn) {
+                  d2.mcc = fns.selectedColorFn(d2);
+                }
+                if (fns.selectedSizeFn) {
+                  d2.mrc = fns.selectedSizeFn(d2);
+                }
+              }
+            }
+            return {
+              geojson: { type: "FeatureCollection", features },
+              mcc: arrayColor || fns && fns.selectedColorFn ? { type: "identity", property: "mcc" } : marker.color,
+              mrc: arraySize || fns && fns.selectedSizeFn ? { type: "identity", property: "mrc" } : size2radius(marker.size),
+              mo: arrayOpacity || fns && fns.selectedOpacityFn ? { type: "identity", property: "mo" } : addTraceOpacity(marker.opacity)
+            };
+          }
+          function makeSymbolGeoJSON(calcTrace, gd2) {
+            var fullLayout = gd2._fullLayout;
+            var trace = calcTrace[0].trace;
+            var marker = trace.marker || {};
+            var symbol = marker.symbol;
+            var angle2 = marker.angle;
+            var fillSymbol = symbol !== "circle" ? getFillFunc(symbol) : blankFillFunc;
+            var fillAngle = angle2 !== "auto" ? getFillFunc(angle2, true) : blankFillFunc;
+            var fillText = subTypes.hasText(trace) ? getFillFunc(trace.text) : blankFillFunc;
+            var features = [];
+            for (var i2 = 0; i2 < calcTrace.length; i2++) {
+              var calcPt = calcTrace[i2];
+              if (isBADNUM(calcPt.lonlat)) continue;
+              var texttemplate = trace.texttemplate;
+              var text;
+              if (texttemplate) {
+                var tt2 = Array.isArray(texttemplate) ? texttemplate[i2] || "" : texttemplate;
+                var labels = trace._module.formatLabels(calcPt, trace, fullLayout);
+                var pointValues = {};
+                appendArrayPointValue(pointValues, trace, calcPt.i);
+                text = Lib.texttemplateString({
+                  data: [pointValues, calcPt, trace._meta],
+                  fallback: trace.texttemplatefallback,
+                  labels,
+                  locale: fullLayout._d3locale,
+                  template: tt2
+                });
+              } else {
+                text = fillText(i2);
+              }
+              if (text) {
+                text = text.replace(NEWLINES, "").replace(BR_TAG_ALL, "\n");
+              }
+              features.push({
+                type: "Feature",
+                geometry: {
+                  type: "Point",
+                  coordinates: calcPt.lonlat
+                },
+                properties: {
+                  symbol: fillSymbol(i2),
+                  angle: fillAngle(i2),
+                  text
+                }
+              });
+            }
+            return {
+              type: "FeatureCollection",
+              features
+            };
+          }
+          function getFillFunc(attr, numeric) {
+            if (Lib.isArrayOrTypedArray(attr)) {
+              if (numeric) {
+                return function(i2) {
+                  return isNumeric(attr[i2]) ? +attr[i2] : 0;
+                };
+              }
+              return function(i2) {
+                return attr[i2];
+              };
+            } else if (attr) {
+              return function() {
+                return attr;
+              };
+            } else {
+              return blankFillFunc;
+            }
+          }
+          function blankFillFunc() {
+            return "";
+          }
+          function isBADNUM(lonlat) {
+            return lonlat[0] === BADNUM;
+          }
+          function arrayifyAttribute(values, step) {
+            var newAttribute;
+            if (Lib.isArrayOrTypedArray(values) && Lib.isArrayOrTypedArray(step)) {
+              newAttribute = ["step", ["get", "point_count"], values[0]];
+              for (var idx = 1; idx < values.length; idx++) {
+                newAttribute.push(step[idx - 1], values[idx]);
+              }
+            } else {
+              newAttribute = values;
+            }
+            return newAttribute;
+          }
+          function getTextFont(trace) {
+            var font = trace.textfont;
+            var family = font.family;
+            var style = font.style;
+            var weight = font.weight;
+            var parts = family.split(" ");
+            var isItalic = parts[parts.length - 1] === "Italic";
+            if (isItalic) parts.pop();
+            isItalic = isItalic || style === "italic";
+            var str = parts.join(" ");
+            if (weight === "bold" && parts.indexOf("Bold") === -1) {
+              str += " Bold";
+            } else if (weight <= 1e3) {
+              if (parts[0] === "Metropolis") {
+                str = "Metropolis";
+                if (weight > 850) str += " Black";
+                else if (weight > 750) str += " Extra Bold";
+                else if (weight > 650) str += " Bold";
+                else if (weight > 550) str += " Semi Bold";
+                else if (weight > 450) str += " Medium";
+                else if (weight > 350) str += " Regular";
+                else if (weight > 250) str += " Light";
+                else if (weight > 150) str += " Extra Light";
+                else str += " Thin";
+              } else if (parts.slice(0, 2).join(" ") === "Open Sans") {
+                str = "Open Sans";
+                if (weight > 750) str += " Extrabold";
+                else if (weight > 650) str += " Bold";
+                else if (weight > 550) str += " Semibold";
+                else if (weight > 350) str += " Regular";
+                else str += " Light";
+              } else if (parts.slice(0, 3).join(" ") === "Klokantech Noto Sans") {
+                str = "Klokantech Noto Sans";
+                if (parts[3] === "CJK") str += " CJK";
+                str += weight > 500 ? " Bold" : " Regular";
+              }
+            }
+            if (isItalic) str += " Italic";
+            if (str === "Open Sans Regular Italic") str = "Open Sans Italic";
+            else if (str === "Open Sans Regular Bold") str = "Open Sans Bold";
+            else if (str === "Open Sans Regular Bold Italic") str = "Open Sans Bold Italic";
+            else if (str === "Klokantech Noto Sans Regular Italic") str = "Klokantech Noto Sans Italic";
+            if (!isSupportedFont(str)) {
+              str = family;
+            }
+            var textFont = str.split(", ");
+            return textFont;
+          }
+        }
+      });
+      var require_plot23 = __commonJS({
+        "src/traces/scattermapbox/plot.js"(exports, module2) {
+          var Lib = require_lib();
+          var convert = require_convert11();
+          var LAYER_PREFIX = require_constants25().traceLayerPrefix;
+          var ORDER = {
+            cluster: ["cluster", "clusterCount", "circle"],
+            nonCluster: ["fill", "line", "circle", "symbol"]
+          };
+          function ScatterMapbox(subplot, uid2, clusterEnabled, isHidden) {
+            this.type = "scattermapbox";
+            this.subplot = subplot;
+            this.uid = uid2;
+            this.clusterEnabled = clusterEnabled;
+            this.isHidden = isHidden;
+            this.sourceIds = {
+              fill: "source-" + uid2 + "-fill",
+              line: "source-" + uid2 + "-line",
+              circle: "source-" + uid2 + "-circle",
+              symbol: "source-" + uid2 + "-symbol",
+              cluster: "source-" + uid2 + "-circle",
+              clusterCount: "source-" + uid2 + "-circle"
+            };
+            this.layerIds = {
+              fill: LAYER_PREFIX + uid2 + "-fill",
+              line: LAYER_PREFIX + uid2 + "-line",
+              circle: LAYER_PREFIX + uid2 + "-circle",
+              symbol: LAYER_PREFIX + uid2 + "-symbol",
+              cluster: LAYER_PREFIX + uid2 + "-cluster",
+              clusterCount: LAYER_PREFIX + uid2 + "-cluster-count"
+            };
+            this.below = null;
+          }
+          var proto = ScatterMapbox.prototype;
+          proto.addSource = function(k2, opts, cluster) {
+            var sourceOpts = {
+              type: "geojson",
+              data: opts.geojson
+            };
+            if (cluster && cluster.enabled) {
+              Lib.extendFlat(sourceOpts, {
+                cluster: true,
+                clusterMaxZoom: cluster.maxzoom
+              });
+            }
+            var isSourceExists = this.subplot.map.getSource(this.sourceIds[k2]);
+            if (isSourceExists) {
+              isSourceExists.setData(opts.geojson);
+            } else {
+              this.subplot.map.addSource(this.sourceIds[k2], sourceOpts);
+            }
+          };
+          proto.setSourceData = function(k2, opts) {
+            this.subplot.map.getSource(this.sourceIds[k2]).setData(opts.geojson);
+          };
+          proto.addLayer = function(k2, opts, below) {
+            var source2 = {
+              type: opts.type,
+              id: this.layerIds[k2],
+              source: this.sourceIds[k2],
+              layout: opts.layout,
+              paint: opts.paint
+            };
+            if (opts.filter) {
+              source2.filter = opts.filter;
+            }
+            var currentLayerId = this.layerIds[k2];
+            var layerExist;
+            var layers = this.subplot.getMapLayers();
+            for (var i2 = 0; i2 < layers.length; i2++) {
+              if (layers[i2].id === currentLayerId) {
+                layerExist = true;
+                break;
+              }
+            }
+            if (layerExist) {
+              this.subplot.setOptions(currentLayerId, "setLayoutProperty", source2.layout);
+              if (source2.layout.visibility === "visible") {
+                this.subplot.setOptions(currentLayerId, "setPaintProperty", source2.paint);
+              }
+            } else {
+              this.subplot.addLayer(source2, below);
+            }
+          };
+          proto.update = function update(calcTrace) {
+            var trace = calcTrace[0].trace;
+            var subplot = this.subplot;
+            var map2 = subplot.map;
+            var optsAll = convert(subplot.gd, calcTrace);
+            var below = subplot.belowLookup["trace-" + this.uid];
+            var hasCluster = !!(trace.cluster && trace.cluster.enabled);
+            var hadCluster = !!this.clusterEnabled;
+            var lThis = this;
+            function addCluster(noSource) {
+              if (!noSource) lThis.addSource("circle", optsAll.circle, trace.cluster);
+              var order = ORDER.cluster;
+              for (var i2 = 0; i2 < order.length; i2++) {
+                var k2 = order[i2];
+                var opts = optsAll[k2];
+                lThis.addLayer(k2, opts, below);
+              }
+            }
+            function removeCluster(noSource) {
+              var order = ORDER.cluster;
+              for (var i2 = order.length - 1; i2 >= 0; i2--) {
+                var k2 = order[i2];
+                map2.removeLayer(lThis.layerIds[k2]);
+              }
+              if (!noSource) map2.removeSource(lThis.sourceIds.circle);
+            }
+            function addNonCluster(noSource) {
+              var order = ORDER.nonCluster;
+              for (var i2 = 0; i2 < order.length; i2++) {
+                var k2 = order[i2];
+                var opts = optsAll[k2];
+                if (!noSource) lThis.addSource(k2, opts);
+                lThis.addLayer(k2, opts, below);
+              }
+            }
+            function removeNonCluster(noSource) {
+              var order = ORDER.nonCluster;
+              for (var i2 = order.length - 1; i2 >= 0; i2--) {
+                var k2 = order[i2];
+                map2.removeLayer(lThis.layerIds[k2]);
+                if (!noSource) map2.removeSource(lThis.sourceIds[k2]);
+              }
+            }
+            function remove(noSource) {
+              if (hadCluster) removeCluster(noSource);
+              else removeNonCluster(noSource);
+            }
+            function add2(noSource) {
+              if (hasCluster) addCluster(noSource);
+              else addNonCluster(noSource);
+            }
+            function repaint() {
+              var order = hasCluster ? ORDER.cluster : ORDER.nonCluster;
+              for (var i2 = 0; i2 < order.length; i2++) {
+                var k2 = order[i2];
+                var opts = optsAll[k2];
+                if (!opts) continue;
+                subplot.setOptions(lThis.layerIds[k2], "setLayoutProperty", opts.layout);
+                if (opts.layout.visibility === "visible") {
+                  if (k2 !== "cluster") {
+                    lThis.setSourceData(k2, opts);
+                  }
+                  subplot.setOptions(lThis.layerIds[k2], "setPaintProperty", opts.paint);
+                }
+              }
+            }
+            var wasHidden = this.isHidden;
+            var isHidden = trace.visible !== true;
+            if (isHidden) {
+              if (!wasHidden) remove();
+            } else if (wasHidden) {
+              if (!isHidden) add2();
+            } else if (hadCluster !== hasCluster) {
+              remove();
+              add2();
+            } else if (this.below !== below) {
+              remove(true);
+              add2(true);
+              repaint();
+            } else {
+              repaint();
+            }
+            this.clusterEnabled = hasCluster;
+            this.isHidden = isHidden;
+            this.below = below;
+            calcTrace[0].trace._glTrace = this;
+          };
+          proto.dispose = function dispose() {
+            var map2 = this.subplot.map;
+            var order = this.clusterEnabled ? ORDER.cluster : ORDER.nonCluster;
+            for (var i2 = order.length - 1; i2 >= 0; i2--) {
+              var k2 = order[i2];
+              map2.removeLayer(this.layerIds[k2]);
+              map2.removeSource(this.sourceIds[k2]);
+            }
+          };
+          module2.exports = function createScatterMapbox(subplot, calcTrace) {
+            var trace = calcTrace[0].trace;
+            var hasCluster = trace.cluster && trace.cluster.enabled;
+            var isHidden = trace.visible !== true;
+            var scatterMapbox = new ScatterMapbox(
+              subplot,
+              trace.uid,
+              hasCluster,
+              isHidden
+            );
+            var optsAll = convert(subplot.gd, calcTrace);
+            var below = scatterMapbox.below = subplot.belowLookup["trace-" + trace.uid];
+            var i2, k2, opts;
+            if (hasCluster) {
+              scatterMapbox.addSource("circle", optsAll.circle, trace.cluster);
+              for (i2 = 0; i2 < ORDER.cluster.length; i2++) {
+                k2 = ORDER.cluster[i2];
+                opts = optsAll[k2];
+                scatterMapbox.addLayer(k2, opts, below);
+              }
+            } else {
+              for (i2 = 0; i2 < ORDER.nonCluster.length; i2++) {
+                k2 = ORDER.nonCluster[i2];
+                opts = optsAll[k2];
+                scatterMapbox.addSource(k2, opts, trace.cluster);
+                scatterMapbox.addLayer(k2, opts, below);
+              }
+            }
+            calcTrace[0].trace._glTrace = scatterMapbox;
+            return scatterMapbox;
+          };
+        }
+      });
+      var require_hover18 = __commonJS({
+        "src/traces/scattermapbox/hover.js"(exports, module2) {
+          var Fx = require_fx();
+          var Lib = require_lib();
+          var getTraceColor = require_get_trace_color();
+          var fillText = Lib.fillText;
+          var BADNUM = require_numerical().BADNUM;
+          var LAYER_PREFIX = require_constants25().traceLayerPrefix;
+          function hoverPoints(pointData, xval, yval) {
+            var cd2 = pointData.cd;
+            var trace = cd2[0].trace;
+            var xa = pointData.xa;
+            var ya2 = pointData.ya;
+            var subplot = pointData.subplot;
+            var clusteredPointsIds = [];
+            var layer = LAYER_PREFIX + trace.uid + "-circle";
+            var hasCluster = trace.cluster && trace.cluster.enabled;
+            if (hasCluster) {
+              var elems = subplot.map.queryRenderedFeatures(null, { layers: [layer] });
+              clusteredPointsIds = elems.map(function(elem) {
+                return elem.id;
+              });
+            }
+            var winding = xval >= 0 ? Math.floor((xval + 180) / 360) : Math.ceil((xval - 180) / 360);
+            var lonShift = winding * 360;
+            var xval2 = xval - lonShift;
+            function distFn(d2) {
+              var lonlat2 = d2.lonlat;
+              if (lonlat2[0] === BADNUM) return Infinity;
+              if (hasCluster && clusteredPointsIds.indexOf(d2.i + 1) === -1) return Infinity;
+              var lon = Lib.modHalf(lonlat2[0], 360);
+              var lat = lonlat2[1];
+              var pt2 = subplot.project([lon, lat]);
+              var dx = pt2.x - xa.c2p([xval2, lat]);
+              var dy = pt2.y - ya2.c2p([lon, yval]);
+              var rad2 = Math.max(3, d2.mrc || 0);
+              return Math.max(Math.sqrt(dx * dx + dy * dy) - rad2, 1 - 3 / rad2);
+            }
+            Fx.getClosest(cd2, distFn, pointData);
+            if (pointData.index === false) return;
+            var di2 = cd2[pointData.index];
+            var lonlat = di2.lonlat;
+            var lonlatShifted = [Lib.modHalf(lonlat[0], 360) + lonShift, lonlat[1]];
+            var xc2 = xa.c2p(lonlatShifted);
+            var yc2 = ya2.c2p(lonlatShifted);
+            var rad = di2.mrc || 1;
+            pointData.x0 = xc2 - rad;
+            pointData.x1 = xc2 + rad;
+            pointData.y0 = yc2 - rad;
+            pointData.y1 = yc2 + rad;
+            var fullLayout = {};
+            fullLayout[trace.subplot] = { _subplot: subplot };
+            var labels = trace._module.formatLabels(di2, trace, fullLayout);
+            pointData.lonLabel = labels.lonLabel;
+            pointData.latLabel = labels.latLabel;
+            pointData.color = getTraceColor(trace, di2);
+            pointData.extraText = getExtraText(trace, di2, cd2[0].t.labels);
+            pointData.hovertemplate = trace.hovertemplate;
+            return [pointData];
+          }
+          function getExtraText(trace, di2, labels) {
+            if (trace.hovertemplate) return;
+            var hoverinfo = di2.hi || trace.hoverinfo;
+            var parts = hoverinfo.split("+");
+            var isAll = parts.indexOf("all") !== -1;
+            var hasLon = parts.indexOf("lon") !== -1;
+            var hasLat = parts.indexOf("lat") !== -1;
+            var lonlat = di2.lonlat;
+            var text = [];
+            function format(v2) {
+              return v2 + "°";
+            }
+            if (isAll || hasLon && hasLat) {
+              text.push("(" + format(lonlat[1]) + ", " + format(lonlat[0]) + ")");
+            } else if (hasLon) {
+              text.push(labels.lon + format(lonlat[0]));
+            } else if (hasLat) {
+              text.push(labels.lat + format(lonlat[1]));
+            }
+            if (isAll || parts.indexOf("text") !== -1) {
+              fillText(di2, trace, text);
+            }
+            return text.join("<br>");
+          }
+          module2.exports = {
+            hoverPoints,
+            getExtraText
+          };
+        }
+      });
+      var require_event_data11 = __commonJS({
+        "src/traces/scattermapbox/event_data.js"(exports, module2) {
+          module2.exports = function eventData(out, pt2) {
+            out.lon = pt2.lon;
+            out.lat = pt2.lat;
+            return out;
+          };
+        }
+      });
+      var require_select9 = __commonJS({
+        "src/traces/scattermapbox/select.js"(exports, module2) {
+          var Lib = require_lib();
+          var subtypes = require_subtypes();
+          var BADNUM = require_numerical().BADNUM;
+          module2.exports = function selectPoints(searchInfo, selectionTester) {
+            var cd2 = searchInfo.cd;
+            var xa = searchInfo.xaxis;
+            var ya2 = searchInfo.yaxis;
+            var selection = [];
+            var trace = cd2[0].trace;
+            var i2;
+            if (!subtypes.hasMarkers(trace)) return [];
+            if (selectionTester === false) {
+              for (i2 = 0; i2 < cd2.length; i2++) {
+                cd2[i2].selected = 0;
+              }
+            } else {
+              for (i2 = 0; i2 < cd2.length; i2++) {
+                var di2 = cd2[i2];
+                var lonlat = di2.lonlat;
+                if (lonlat[0] !== BADNUM) {
+                  var lonlat2 = [Lib.modHalf(lonlat[0], 360), lonlat[1]];
+                  var xy = [xa.c2p(lonlat2), ya2.c2p(lonlat2)];
+                  if (selectionTester.contains(xy, null, i2, searchInfo)) {
+                    selection.push({
+                      pointNumber: i2,
+                      lon: lonlat[0],
+                      lat: lonlat[1]
+                    });
+                    di2.selected = 1;
+                  } else {
+                    di2.selected = 0;
+                  }
+                }
+              }
+            }
+            return selection;
+          };
+        }
+      });
+      var require_mapbox_gl_unminified = __commonJS({
+        "node_modules/@plotly/mapbox-gl/dist/mapbox-gl-unminified.js"(exports, module2) {
+          (function(global2, factory2) {
+            typeof exports === "object" && typeof module2 !== "undefined" ? module2.exports = factory2() : (global2 = global2 || self, global2.mapboxgl = factory2());
+          })(exports, function() {
+            var shared, worker, mapboxgl;
+            function define2(_2, chunk) {
+              if (!shared) {
+                shared = chunk;
+              } else if (!worker) {
+                worker = chunk;
+              } else {
+                var workerBundleString = "var sharedChunk = {}; (" + shared + ")(sharedChunk); (" + worker + ")(sharedChunk);";
+                var sharedChunk = {};
+                shared(sharedChunk);
+                mapboxgl = chunk(sharedChunk);
+                if (typeof window !== "undefined") {
+                  mapboxgl.workerUrl = window.URL.createObjectURL(new Blob([workerBundleString], { type: "text/javascript" }));
+                }
+              }
+            }
+            define2(["exports"], function(exports2) {
+              function createCommonjsModule(fn, module22) {
+                return module22 = { exports: {} }, fn(module22, module22.exports), module22.exports;
+              }
+              var version2 = "1.13.4";
+              var unitbezier = UnitBezier;
+              function UnitBezier(p1x, p1y, p2x, p2y) {
+                this.cx = 3 * p1x;
+                this.bx = 3 * (p2x - p1x) - this.cx;
+                this.ax = 1 - this.cx - this.bx;
+                this.cy = 3 * p1y;
+                this.by = 3 * (p2y - p1y) - this.cy;
+                this.ay = 1 - this.cy - this.by;
+                this.p1x = p1x;
+                this.p1y = p2y;
+                this.p2x = p2x;
+                this.p2y = p2y;
+              }
+              UnitBezier.prototype.sampleCurveX = function(t4) {
+                return ((this.ax * t4 + this.bx) * t4 + this.cx) * t4;
+              };
+              UnitBezier.prototype.sampleCurveY = function(t4) {
+                return ((this.ay * t4 + this.by) * t4 + this.cy) * t4;
+              };
+              UnitBezier.prototype.sampleCurveDerivativeX = function(t4) {
+                return (3 * this.ax * t4 + 2 * this.bx) * t4 + this.cx;
+              };
+              UnitBezier.prototype.solveCurveX = function(x2, epsilon) {
+                if (typeof epsilon === "undefined") {
+                  epsilon = 1e-6;
+                }
+                var t03, t13, t23, x22, i2;
+                for (t23 = x2, i2 = 0; i2 < 8; i2++) {
+                  x22 = this.sampleCurveX(t23) - x2;
+                  if (Math.abs(x22) < epsilon) {
+                    return t23;
+                  }
+                  var d2 = this.sampleCurveDerivativeX(t23);
+                  if (Math.abs(d2) < 1e-6) {
+                    break;
+                  }
+                  t23 = t23 - x22 / d2;
+                }
+                t03 = 0;
+                t13 = 1;
+                t23 = x2;
+                if (t23 < t03) {
+                  return t03;
+                }
+                if (t23 > t13) {
+                  return t13;
+                }
+                while (t03 < t13) {
+                  x22 = this.sampleCurveX(t23);
+                  if (Math.abs(x22 - x2) < epsilon) {
+                    return t23;
+                  }
+                  if (x2 > x22) {
+                    t03 = t23;
+                  } else {
+                    t13 = t23;
+                  }
+                  t23 = (t13 - t03) * 0.5 + t03;
+                }
+                return t23;
+              };
+              UnitBezier.prototype.solve = function(x2, epsilon) {
+                return this.sampleCurveY(this.solveCurveX(x2, epsilon));
+              };
+              var pointGeometry = Point;
+              function Point(x2, y2) {
+                this.x = x2;
+                this.y = y2;
+              }
+              Point.prototype = {
+                clone: function() {
+                  return new Point(this.x, this.y);
+                },
+                add: function(p2) {
+                  return this.clone()._add(p2);
+                },
+                sub: function(p2) {
+                  return this.clone()._sub(p2);
+                },
+                multByPoint: function(p2) {
+                  return this.clone()._multByPoint(p2);
+                },
+                divByPoint: function(p2) {
+                  return this.clone()._divByPoint(p2);
+                },
+                mult: function(k2) {
+                  return this.clone()._mult(k2);
+                },
+                div: function(k2) {
+                  return this.clone()._div(k2);
+                },
+                rotate: function(a2) {
+                  return this.clone()._rotate(a2);
+                },
+                rotateAround: function(a2, p2) {
+                  return this.clone()._rotateAround(a2, p2);
+                },
+                matMult: function(m2) {
+                  return this.clone()._matMult(m2);
+                },
+                unit: function() {
+                  return this.clone()._unit();
+                },
+                perp: function() {
+                  return this.clone()._perp();
+                },
+                round: function() {
+                  return this.clone()._round();
+                },
+                mag: function() {
+                  return Math.sqrt(this.x * this.x + this.y * this.y);
+                },
+                equals: function(other) {
+                  return this.x === other.x && this.y === other.y;
+                },
+                dist: function(p2) {
+                  return Math.sqrt(this.distSqr(p2));
+                },
+                distSqr: function(p2) {
+                  var dx = p2.x - this.x, dy = p2.y - this.y;
+                  return dx * dx + dy * dy;
+                },
+                angle: function() {
+                  return Math.atan2(this.y, this.x);
+                },
+                angleTo: function(b2) {
+                  return Math.atan2(this.y - b2.y, this.x - b2.x);
+                },
+                angleWith: function(b2) {
+                  return this.angleWithSep(b2.x, b2.y);
+                },
+                angleWithSep: function(x2, y2) {
+                  return Math.atan2(this.x * y2 - this.y * x2, this.x * x2 + this.y * y2);
+                },
+                _matMult: function(m2) {
+                  var x2 = m2[0] * this.x + m2[1] * this.y, y2 = m2[2] * this.x + m2[3] * this.y;
+                  this.x = x2;
+                  this.y = y2;
+                  return this;
+                },
+                _add: function(p2) {
+                  this.x += p2.x;
+                  this.y += p2.y;
+                  return this;
+                },
+                _sub: function(p2) {
+                  this.x -= p2.x;
+                  this.y -= p2.y;
+                  return this;
+                },
+                _mult: function(k2) {
+                  this.x *= k2;
+                  this.y *= k2;
+                  return this;
+                },
+                _div: function(k2) {
+                  this.x /= k2;
+                  this.y /= k2;
+                  return this;
+                },
+                _multByPoint: function(p2) {
+                  this.x *= p2.x;
+                  this.y *= p2.y;
+                  return this;
+                },
+                _divByPoint: function(p2) {
+                  this.x /= p2.x;
+                  this.y /= p2.y;
+                  return this;
+                },
+                _unit: function() {
+                  this._div(this.mag());
+                  return this;
+                },
+                _perp: function() {
+                  var y2 = this.y;
+                  this.y = this.x;
+                  this.x = -y2;
+                  return this;
+                },
+                _rotate: function(angle2) {
+                  var cos = Math.cos(angle2), sin = Math.sin(angle2), x2 = cos * this.x - sin * this.y, y2 = sin * this.x + cos * this.y;
+                  this.x = x2;
+                  this.y = y2;
+                  return this;
+                },
+                _rotateAround: function(angle2, p2) {
+                  var cos = Math.cos(angle2), sin = Math.sin(angle2), x2 = p2.x + cos * (this.x - p2.x) - sin * (this.y - p2.y), y2 = p2.y + sin * (this.x - p2.x) + cos * (this.y - p2.y);
+                  this.x = x2;
+                  this.y = y2;
+                  return this;
+                },
+                _round: function() {
+                  this.x = Math.round(this.x);
+                  this.y = Math.round(this.y);
+                  return this;
+                }
+              };
+              Point.convert = function(a2) {
+                if (a2 instanceof Point) {
+                  return a2;
+                }
+                if (Array.isArray(a2)) {
+                  return new Point(a2[0], a2[1]);
+                }
+                return a2;
+              };
+              var window$1 = typeof self !== "undefined" ? self : {};
+              function deepEqual2(a2, b2) {
+                if (Array.isArray(a2)) {
+                  if (!Array.isArray(b2) || a2.length !== b2.length) {
+                    return false;
+                  }
+                  for (var i2 = 0; i2 < a2.length; i2++) {
+                    if (!deepEqual2(a2[i2], b2[i2])) {
+                      return false;
+                    }
+                  }
+                  return true;
+                }
+                if (typeof a2 === "object" && a2 !== null && b2 !== null) {
+                  if (!(typeof b2 === "object")) {
+                    return false;
+                  }
+                  var keys = Object.keys(a2);
+                  if (keys.length !== Object.keys(b2).length) {
+                    return false;
+                  }
+                  for (var key in a2) {
+                    if (!deepEqual2(a2[key], b2[key])) {
+                      return false;
+                    }
+                  }
+                  return true;
+                }
+                return a2 === b2;
+              }
+              var MAX_SAFE_INTEGER = Math.pow(2, 53) - 1;
+              function easeCubicInOut(t4) {
+                if (t4 <= 0) {
+                  return 0;
+                }
+                if (t4 >= 1) {
+                  return 1;
+                }
+                var t23 = t4 * t4, t33 = t23 * t4;
+                return 4 * (t4 < 0.5 ? t33 : 3 * (t4 - t23) + t33 - 0.75);
+              }
+              function bezier(p1x, p1y, p2x, p2y) {
+                var bezier2 = new unitbezier(p1x, p1y, p2x, p2y);
+                return function(t4) {
+                  return bezier2.solve(t4);
+                };
+              }
+              var ease = bezier(0.25, 0.1, 0.25, 1);
+              function clamp2(n2, min, max) {
+                return Math.min(max, Math.max(min, n2));
+              }
+              function wrap(n2, min, max) {
+                var d2 = max - min;
+                var w2 = ((n2 - min) % d2 + d2) % d2 + min;
+                return w2 === min ? max : w2;
+              }
+              function asyncAll(array2, fn, callback) {
+                if (!array2.length) {
+                  return callback(null, []);
+                }
+                var remaining = array2.length;
+                var results = new Array(array2.length);
+                var error2 = null;
+                array2.forEach(function(item, i2) {
+                  fn(item, function(err, result) {
+                    if (err) {
+                      error2 = err;
+                    }
+                    results[i2] = result;
+                    if (--remaining === 0) {
+                      callback(error2, results);
+                    }
+                  });
+                });
+              }
+              function values(obj) {
+                var result = [];
+                for (var k2 in obj) {
+                  result.push(obj[k2]);
+                }
+                return result;
+              }
+              function keysDifference(obj, other) {
+                var difference = [];
+                for (var i2 in obj) {
+                  if (!(i2 in other)) {
+                    difference.push(i2);
+                  }
+                }
+                return difference;
+              }
+              function extend2(dest) {
+                var sources2 = [], len2 = arguments.length - 1;
+                while (len2-- > 0)
+                  sources2[len2] = arguments[len2 + 1];
+                for (var i2 = 0, list = sources2; i2 < list.length; i2 += 1) {
+                  var src = list[i2];
+                  for (var k2 in src) {
+                    dest[k2] = src[k2];
+                  }
+                }
+                return dest;
+              }
+              function pick(src, properties2) {
+                var result = {};
+                for (var i2 = 0; i2 < properties2.length; i2++) {
+                  var k2 = properties2[i2];
+                  if (k2 in src) {
+                    result[k2] = src[k2];
+                  }
+                }
+                return result;
+              }
+              var id2 = 1;
+              function uniqueId2() {
+                return id2++;
+              }
+              function uuid() {
+                function b2(a2) {
+                  return a2 ? (a2 ^ Math.random() * 16 >> a2 / 4).toString(16) : ([1e7] + -[1e3] + -4e3 + -8e3 + -1e11).replace(/[018]/g, b2);
+                }
+                return b2();
+              }
+              function nextPowerOfTwo(value) {
+                if (value <= 1) {
+                  return 1;
+                }
+                return Math.pow(2, Math.ceil(Math.log(value) / Math.LN2));
+              }
+              function validateUuid(str) {
+                return str ? /^[0-9a-f]{8}-[0-9a-f]{4}-[4][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i.test(str) : false;
+              }
+              function bindAll(fns, context) {
+                fns.forEach(function(fn) {
+                  if (!context[fn]) {
+                    return;
+                  }
+                  context[fn] = context[fn].bind(context);
+                });
+              }
+              function endsWith(string, suffix) {
+                return string.indexOf(suffix, string.length - suffix.length) !== -1;
+              }
+              function mapObject(input, iterator, context) {
+                var output = {};
+                for (var key in input) {
+                  output[key] = iterator.call(context || this, input[key], key, input);
+                }
+                return output;
+              }
+              function filterObject(input, iterator, context) {
+                var output = {};
+                for (var key in input) {
+                  if (iterator.call(context || this, input[key], key, input)) {
+                    output[key] = input[key];
+                  }
+                }
+                return output;
+              }
+              function clone(input) {
+                if (Array.isArray(input)) {
+                  return input.map(clone);
+                } else if (typeof input === "object" && input) {
+                  return mapObject(input, clone);
+                } else {
+                  return input;
+                }
+              }
+              function arraysIntersect(a2, b2) {
+                for (var l2 = 0; l2 < a2.length; l2++) {
+                  if (b2.indexOf(a2[l2]) >= 0) {
+                    return true;
+                  }
+                }
+                return false;
+              }
+              var warnOnceHistory = {};
+              function warnOnce(message2) {
+                if (!warnOnceHistory[message2]) {
+                  if (typeof console !== "undefined") {
+                    console.warn(message2);
+                  }
+                  warnOnceHistory[message2] = true;
+                }
+              }
+              function isCounterClockwise(a2, b2, c2) {
+                return (c2.y - a2.y) * (b2.x - a2.x) > (b2.y - a2.y) * (c2.x - a2.x);
+              }
+              function calculateSignedArea(ring) {
+                var sum = 0;
+                for (var i2 = 0, len2 = ring.length, j2 = len2 - 1, p1 = void 0, p2 = void 0; i2 < len2; j2 = i2++) {
+                  p1 = ring[i2];
+                  p2 = ring[j2];
+                  sum += (p2.x - p1.x) * (p1.y + p2.y);
+                }
+                return sum;
+              }
+              function sphericalToCartesian(ref) {
+                var r2 = ref[0];
+                var azimuthal = ref[1];
+                var polar = ref[2];
+                azimuthal += 90;
+                azimuthal *= Math.PI / 180;
+                polar *= Math.PI / 180;
+                return {
+                  x: r2 * Math.cos(azimuthal) * Math.sin(polar),
+                  y: r2 * Math.sin(azimuthal) * Math.sin(polar),
+                  z: r2 * Math.cos(polar)
+                };
+              }
+              function isWorker() {
+                return typeof WorkerGlobalScope !== "undefined" && typeof self !== "undefined" && self instanceof WorkerGlobalScope;
+              }
+              function parseCacheControl(cacheControl) {
+                var re2 = /(?:^|(?:\s*\,\s*))([^\x00-\x20\(\)<>@\,;\:\\"\/\[\]\?\=\{\}\x7F]+)(?:\=(?:([^\x00-\x20\(\)<>@\,;\:\\"\/\[\]\?\=\{\}\x7F]+)|(?:\"((?:[^"\\]|\\.)*)\")))?/g;
+                var header = {};
+                cacheControl.replace(re2, function($0, $1, $2, $3) {
+                  var value = $2 || $3;
+                  header[$1] = value ? value.toLowerCase() : true;
+                  return "";
+                });
+                if (header["max-age"]) {
+                  var maxAge = parseInt(header["max-age"], 10);
+                  if (isNaN(maxAge)) {
+                    delete header["max-age"];
+                  } else {
+                    header["max-age"] = maxAge;
+                  }
+                }
+                return header;
+              }
+              var _isSafari = null;
+              function isSafari(scope) {
+                if (_isSafari == null) {
+                  var userAgent2 = scope.navigator ? scope.navigator.userAgent : null;
+                  _isSafari = !!scope.safari || !!(userAgent2 && (/\b(iPad|iPhone|iPod)\b/.test(userAgent2) || !!userAgent2.match("Safari") && !userAgent2.match("Chrome")));
+                }
+                return _isSafari;
+              }
+              function storageAvailable(type) {
+                try {
+                  var storage = window$1[type];
+                  storage.setItem("_mapbox_test_", 1);
+                  storage.removeItem("_mapbox_test_");
+                  return true;
+                } catch (e2) {
+                  return false;
+                }
+              }
+              function b64EncodeUnicode(str) {
+                return window$1.btoa(encodeURIComponent(str).replace(/%([0-9A-F]{2})/g, function(match, p1) {
+                  return String.fromCharCode(Number("0x" + p1));
+                }));
+              }
+              function b64DecodeUnicode(str) {
+                return decodeURIComponent(window$1.atob(str).split("").map(function(c2) {
+                  return "%" + ("00" + c2.charCodeAt(0).toString(16)).slice(-2);
+                }).join(""));
+              }
+              var now = window$1.performance && window$1.performance.now ? window$1.performance.now.bind(window$1.performance) : Date.now.bind(Date);
+              var raf = window$1.requestAnimationFrame || window$1.mozRequestAnimationFrame || window$1.webkitRequestAnimationFrame || window$1.msRequestAnimationFrame;
+              var cancel = window$1.cancelAnimationFrame || window$1.mozCancelAnimationFrame || window$1.webkitCancelAnimationFrame || window$1.msCancelAnimationFrame;
+              var linkEl;
+              var reducedMotionQuery;
+              var exported = {
+                now,
+                frame: function frame(fn) {
+                  var frame2 = raf(fn);
+                  return {
+                    cancel: function() {
+                      return cancel(frame2);
+                    }
+                  };
+                },
+                getImageData: function getImageData2(img, padding) {
+                  if (padding === void 0)
+                    padding = 0;
+                  var canvas2 = window$1.document.createElement("canvas");
+                  var context = canvas2.getContext("2d");
+                  if (!context) {
+                    throw new Error("failed to create canvas 2d context");
+                  }
+                  canvas2.width = img.width;
+                  canvas2.height = img.height;
+                  context.drawImage(img, 0, 0, img.width, img.height);
+                  return context.getImageData(-padding, -padding, img.width + 2 * padding, img.height + 2 * padding);
+                },
+                resolveURL: function resolveURL(path) {
+                  if (!linkEl) {
+                    linkEl = window$1.document.createElement("a");
+                  }
+                  linkEl.href = path;
+                  return linkEl.href;
+                },
+                hardwareConcurrency: window$1.navigator && window$1.navigator.hardwareConcurrency || 4,
+                get devicePixelRatio() {
+                  return window$1.devicePixelRatio;
+                },
+                get prefersReducedMotion() {
+                  if (!window$1.matchMedia) {
+                    return false;
+                  }
+                  if (reducedMotionQuery == null) {
+                    reducedMotionQuery = window$1.matchMedia("(prefers-reduced-motion: reduce)");
+                  }
+                  return reducedMotionQuery.matches;
+                }
+              };
+              var config2 = {
+                API_URL: "https://api.mapbox.com",
+                get EVENTS_URL() {
+                  if (!this.API_URL) {
+                    return null;
+                  }
+                  if (this.API_URL.indexOf("https://api.mapbox.cn") === 0) {
+                    return "https://events.mapbox.cn/events/v2";
+                  } else if (this.API_URL.indexOf("https://api.mapbox.com") === 0) {
+                    return "https://events.mapbox.com/events/v2";
+                  } else {
+                    return null;
+                  }
+                },
+                FEEDBACK_URL: "https://apps.mapbox.com/feedback",
+                REQUIRE_ACCESS_TOKEN: true,
+                ACCESS_TOKEN: null,
+                MAX_PARALLEL_IMAGE_REQUESTS: 16
+              };
+              var exported$1 = {
+                supported: false,
+                testSupport
+              };
+              var glForTesting;
+              var webpCheckComplete = false;
+              var webpImgTest;
+              var webpImgTestOnloadComplete = false;
+              if (window$1.document) {
+                webpImgTest = window$1.document.createElement("img");
+                webpImgTest.onload = function() {
+                  if (glForTesting) {
+                    testWebpTextureUpload(glForTesting);
+                  }
+                  glForTesting = null;
+                  webpImgTestOnloadComplete = true;
+                };
+                webpImgTest.onerror = function() {
+                  webpCheckComplete = true;
+                  glForTesting = null;
+                };
+                webpImgTest.src = "data:image/webp;base64,UklGRh4AAABXRUJQVlA4TBEAAAAvAQAAAAfQ//73v/+BiOh/AAA=";
+              }
+              function testSupport(gl2) {
+                if (webpCheckComplete || !webpImgTest) {
+                  return;
+                }
+                if (webpImgTestOnloadComplete) {
+                  testWebpTextureUpload(gl2);
+                } else {
+                  glForTesting = gl2;
+                }
+              }
+              function testWebpTextureUpload(gl2) {
+                var texture = gl2.createTexture();
+                gl2.bindTexture(gl2.TEXTURE_2D, texture);
+                try {
+                  gl2.texImage2D(gl2.TEXTURE_2D, 0, gl2.RGBA, gl2.RGBA, gl2.UNSIGNED_BYTE, webpImgTest);
+                  if (gl2.isContextLost()) {
+                    return;
+                  }
+                  exported$1.supported = true;
+                } catch (e2) {
+                }
+                gl2.deleteTexture(texture);
+                webpCheckComplete = true;
+              }
+              var SKU_ID = "01";
+              function createSkuToken() {
+                var TOKEN_VERSION = "1";
+                var base62chars = "0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ";
+                var sessionRandomizer = "";
+                for (var i2 = 0; i2 < 10; i2++) {
+                  sessionRandomizer += base62chars[Math.floor(Math.random() * 62)];
+                }
+                var expiration = 12 * 60 * 60 * 1e3;
+                var token = [
+                  TOKEN_VERSION,
+                  SKU_ID,
+                  sessionRandomizer
+                ].join("");
+                var tokenExpiresAt = Date.now() + expiration;
+                return {
+                  token,
+                  tokenExpiresAt
+                };
+              }
+              var RequestManager = function RequestManager2(transformRequestFn, customAccessToken) {
+                this._transformRequestFn = transformRequestFn;
+                this._customAccessToken = customAccessToken;
+                this._createSkuToken();
+              };
+              RequestManager.prototype._createSkuToken = function _createSkuToken() {
+                var skuToken = createSkuToken();
+                this._skuToken = skuToken.token;
+                this._skuTokenExpiresAt = skuToken.tokenExpiresAt;
+              };
+              RequestManager.prototype._isSkuTokenExpired = function _isSkuTokenExpired() {
+                return Date.now() > this._skuTokenExpiresAt;
+              };
+              RequestManager.prototype.transformRequest = function transformRequest(url, type) {
+                if (this._transformRequestFn) {
+                  return this._transformRequestFn(url, type) || { url };
+                }
+                return { url };
+              };
+              RequestManager.prototype.normalizeStyleURL = function normalizeStyleURL(url, accessToken) {
+                if (!isMapboxURL(url)) {
+                  return url;
+                }
+                var urlObject = parseUrl(url);
+                urlObject.path = "/styles/v1" + urlObject.path;
+                return this._makeAPIURL(urlObject, this._customAccessToken || accessToken);
+              };
+              RequestManager.prototype.normalizeGlyphsURL = function normalizeGlyphsURL(url, accessToken) {
+                if (!isMapboxURL(url)) {
+                  return url;
+                }
+                var urlObject = parseUrl(url);
+                urlObject.path = "/fonts/v1" + urlObject.path;
+                return this._makeAPIURL(urlObject, this._customAccessToken || accessToken);
+              };
+              RequestManager.prototype.normalizeSourceURL = function normalizeSourceURL(url, accessToken) {
+                if (!isMapboxURL(url)) {
+                  return url;
+                }
+                var urlObject = parseUrl(url);
+                urlObject.path = "/v4/" + urlObject.authority + ".json";
+                urlObject.params.push("secure");
+                return this._makeAPIURL(urlObject, this._customAccessToken || accessToken);
+              };
+              RequestManager.prototype.normalizeSpriteURL = function normalizeSpriteURL(url, format, extension, accessToken) {
+                var urlObject = parseUrl(url);
+                if (!isMapboxURL(url)) {
+                  urlObject.path += "" + format + extension;
+                  return formatUrl(urlObject);
+                }
+                urlObject.path = "/styles/v1" + urlObject.path + "/sprite" + format + extension;
+                return this._makeAPIURL(urlObject, this._customAccessToken || accessToken);
+              };
+              RequestManager.prototype.normalizeTileURL = function normalizeTileURL(tileURL, tileSize) {
+                if (this._isSkuTokenExpired()) {
+                  this._createSkuToken();
+                }
+                if (tileURL && !isMapboxURL(tileURL)) {
+                  return tileURL;
+                }
+                var urlObject = parseUrl(tileURL);
+                var imageExtensionRe = /(\.(png|jpg)\d*)(?=$)/;
+                var tileURLAPIPrefixRe = /^.+\/v4\//;
+                var suffix = exported.devicePixelRatio >= 2 || tileSize === 512 ? "@2x" : "";
+                var extension = exported$1.supported ? ".webp" : "$1";
+                urlObject.path = urlObject.path.replace(imageExtensionRe, "" + suffix + extension);
+                urlObject.path = urlObject.path.replace(tileURLAPIPrefixRe, "/");
+                urlObject.path = "/v4" + urlObject.path;
+                var accessToken = this._customAccessToken || getAccessToken(urlObject.params) || config2.ACCESS_TOKEN;
+                if (config2.REQUIRE_ACCESS_TOKEN && accessToken && this._skuToken) {
+                  urlObject.params.push("sku=" + this._skuToken);
+                }
+                return this._makeAPIURL(urlObject, accessToken);
+              };
+              RequestManager.prototype.canonicalizeTileURL = function canonicalizeTileURL(url, removeAccessToken) {
+                var version22 = "/v4/";
+                var extensionRe = /\.[\w]+$/;
+                var urlObject = parseUrl(url);
+                if (!urlObject.path.match(/(^\/v4\/)/) || !urlObject.path.match(extensionRe)) {
+                  return url;
+                }
+                var result = "mapbox://tiles/";
+                result += urlObject.path.replace(version22, "");
+                var params = urlObject.params;
+                if (removeAccessToken) {
+                  params = params.filter(function(p2) {
+                    return !p2.match(/^access_token=/);
+                  });
+                }
+                if (params.length) {
+                  result += "?" + params.join("&");
+                }
+                return result;
+              };
+              RequestManager.prototype.canonicalizeTileset = function canonicalizeTileset(tileJSON, sourceURL) {
+                var removeAccessToken = sourceURL ? isMapboxURL(sourceURL) : false;
+                var canonical = [];
+                for (var i2 = 0, list = tileJSON.tiles || []; i2 < list.length; i2 += 1) {
+                  var url = list[i2];
+                  if (isMapboxHTTPURL(url)) {
+                    canonical.push(this.canonicalizeTileURL(url, removeAccessToken));
+                  } else {
+                    canonical.push(url);
+                  }
+                }
+                return canonical;
+              };
+              RequestManager.prototype._makeAPIURL = function _makeAPIURL(urlObject, accessToken) {
+                var help = "See https://www.mapbox.com/api-documentation/#access-tokens-and-token-scopes";
+                var apiUrlObject = parseUrl(config2.API_URL);
+                urlObject.protocol = apiUrlObject.protocol;
+                urlObject.authority = apiUrlObject.authority;
+                if (urlObject.protocol === "http") {
+                  var i2 = urlObject.params.indexOf("secure");
+                  if (i2 >= 0) {
+                    urlObject.params.splice(i2, 1);
+                  }
+                }
+                if (apiUrlObject.path !== "/") {
+                  urlObject.path = "" + apiUrlObject.path + urlObject.path;
+                }
+                if (!config2.REQUIRE_ACCESS_TOKEN) {
+                  return formatUrl(urlObject);
+                }
+                accessToken = accessToken || config2.ACCESS_TOKEN;
+                if (!accessToken) {
+                  throw new Error("An API access token is required to use Mapbox GL. " + help);
+                }
+                if (accessToken[0] === "s") {
+                  throw new Error("Use a public access token (pk.*) with Mapbox GL, not a secret access token (sk.*). " + help);
+                }
+                urlObject.params = urlObject.params.filter(function(d2) {
+                  return d2.indexOf("access_token") === -1;
+                });
+                urlObject.params.push("access_token=" + accessToken);
+                return formatUrl(urlObject);
+              };
+              function isMapboxURL(url) {
+                return url.indexOf("mapbox:") === 0;
+              }
+              var mapboxHTTPURLRe = /^((https?:)?\/\/)?([^\/]+\.)?mapbox\.c(n|om)(\/|\?|$)/i;
+              function isMapboxHTTPURL(url) {
+                return mapboxHTTPURLRe.test(url);
+              }
+              function hasCacheDefeatingSku(url) {
+                return url.indexOf("sku=") > 0 && isMapboxHTTPURL(url);
+              }
+              function getAccessToken(params) {
+                for (var i2 = 0, list = params; i2 < list.length; i2 += 1) {
+                  var param = list[i2];
+                  var match = param.match(/^access_token=(.*)$/);
+                  if (match) {
+                    return match[1];
+                  }
+                }
+                return null;
+              }
+              var urlRe = /^(\w+):\/\/([^/?]*)(\/[^?]+)?\??(.+)?/;
+              function parseUrl(url) {
+                var parts = url.match(urlRe);
+                if (!parts) {
+                  throw new Error("Unable to parse URL object");
+                }
+                return {
+                  protocol: parts[1],
+                  authority: parts[2],
+                  path: parts[3] || "/",
+                  params: parts[4] ? parts[4].split("&") : []
+                };
+              }
+              function formatUrl(obj) {
+                var params = obj.params.length ? "?" + obj.params.join("&") : "";
+                return obj.protocol + "://" + obj.authority + obj.path + params;
+              }
+              var telemEventKey = "mapbox.eventData";
+              function parseAccessToken(accessToken) {
+                if (!accessToken) {
+                  return null;
+                }
+                var parts = accessToken.split(".");
+                if (!parts || parts.length !== 3) {
+                  return null;
+                }
+                try {
+                  var jsonData = JSON.parse(b64DecodeUnicode(parts[1]));
+                  return jsonData;
+                } catch (e2) {
+                  return null;
+                }
+              }
+              var TelemetryEvent = function TelemetryEvent2(type) {
+                this.type = type;
+                this.anonId = null;
+                this.eventData = {};
+                this.queue = [];
+                this.pendingRequest = null;
+              };
+              TelemetryEvent.prototype.getStorageKey = function getStorageKey(domain) {
+                var tokenData = parseAccessToken(config2.ACCESS_TOKEN);
+                var u2 = "";
+                if (tokenData && tokenData["u"]) {
+                  u2 = b64EncodeUnicode(tokenData["u"]);
+                } else {
+                  u2 = config2.ACCESS_TOKEN || "";
+                }
+                return domain ? telemEventKey + "." + domain + ":" + u2 : telemEventKey + ":" + u2;
+              };
+              TelemetryEvent.prototype.fetchEventData = function fetchEventData() {
+                var isLocalStorageAvailable = storageAvailable("localStorage");
+                var storageKey = this.getStorageKey();
+                var uuidKey = this.getStorageKey("uuid");
+                if (isLocalStorageAvailable) {
+                  try {
+                    var data = window$1.localStorage.getItem(storageKey);
+                    if (data) {
+                      this.eventData = JSON.parse(data);
+                    }
+                    var uuid2 = window$1.localStorage.getItem(uuidKey);
+                    if (uuid2) {
+                      this.anonId = uuid2;
+                    }
+                  } catch (e2) {
+                    warnOnce("Unable to read from LocalStorage");
+                  }
+                }
+              };
+              TelemetryEvent.prototype.saveEventData = function saveEventData() {
+                var isLocalStorageAvailable = storageAvailable("localStorage");
+                var storageKey = this.getStorageKey();
+                var uuidKey = this.getStorageKey("uuid");
+                if (isLocalStorageAvailable) {
+                  try {
+                    window$1.localStorage.setItem(uuidKey, this.anonId);
+                    if (Object.keys(this.eventData).length >= 1) {
+                      window$1.localStorage.setItem(storageKey, JSON.stringify(this.eventData));
+                    }
+                  } catch (e2) {
+                    warnOnce("Unable to write to LocalStorage");
+                  }
+                }
+              };
+              TelemetryEvent.prototype.processRequests = function processRequests(_2) {
+              };
+              TelemetryEvent.prototype.postEvent = function postEvent(timestamp, additionalPayload, callback, customAccessToken) {
+                var this$1$1 = this;
+                if (!config2.EVENTS_URL) {
+                  return;
+                }
+                var eventsUrlObject = parseUrl(config2.EVENTS_URL);
+                eventsUrlObject.params.push("access_token=" + (customAccessToken || config2.ACCESS_TOKEN || ""));
+                var payload = {
+                  event: this.type,
+                  created: new Date(timestamp).toISOString(),
+                  sdkIdentifier: "mapbox-gl-js",
+                  sdkVersion: version2,
+                  skuId: SKU_ID,
+                  userId: this.anonId
+                };
+                var finalPayload = additionalPayload ? extend2(payload, additionalPayload) : payload;
+                var request = {
+                  url: formatUrl(eventsUrlObject),
+                  headers: { "Content-Type": "text/plain" },
+                  body: JSON.stringify([finalPayload])
+                };
+                this.pendingRequest = postData(request, function(error2) {
+                  this$1$1.pendingRequest = null;
+                  callback(error2);
+                  this$1$1.saveEventData();
+                  this$1$1.processRequests(customAccessToken);
+                });
+              };
+              TelemetryEvent.prototype.queueRequest = function queueRequest(event, customAccessToken) {
+                this.queue.push(event);
+                this.processRequests(customAccessToken);
+              };
+              var MapLoadEvent = function(TelemetryEvent2) {
+                function MapLoadEvent2() {
+                  TelemetryEvent2.call(this, "map.load");
+                  this.success = {};
+                  this.skuToken = "";
+                }
+                if (TelemetryEvent2)
+                  MapLoadEvent2.__proto__ = TelemetryEvent2;
+                MapLoadEvent2.prototype = Object.create(TelemetryEvent2 && TelemetryEvent2.prototype);
+                MapLoadEvent2.prototype.constructor = MapLoadEvent2;
+                MapLoadEvent2.prototype.postMapLoadEvent = function postMapLoadEvent2(tileUrls, mapId, skuToken, customAccessToken) {
+                  this.skuToken = skuToken;
+                  if (config2.EVENTS_URL && customAccessToken || config2.ACCESS_TOKEN && Array.isArray(tileUrls) && tileUrls.some(function(url) {
+                    return isMapboxURL(url) || isMapboxHTTPURL(url);
+                  })) {
+                    this.queueRequest({
+                      id: mapId,
+                      timestamp: Date.now()
+                    }, customAccessToken);
+                  }
+                };
+                MapLoadEvent2.prototype.processRequests = function processRequests(customAccessToken) {
+                  var this$1$1 = this;
+                  if (this.pendingRequest || this.queue.length === 0) {
+                    return;
+                  }
+                  var ref = this.queue.shift();
+                  var id22 = ref.id;
+                  var timestamp = ref.timestamp;
+                  if (id22 && this.success[id22]) {
+                    return;
+                  }
+                  if (!this.anonId) {
+                    this.fetchEventData();
+                  }
+                  if (!validateUuid(this.anonId)) {
+                    this.anonId = uuid();
+                  }
+                  this.postEvent(timestamp, { skuToken: this.skuToken }, function(err) {
+                    if (!err) {
+                      if (id22) {
+                        this$1$1.success[id22] = true;
+                      }
+                    }
+                  }, customAccessToken);
+                };
+                return MapLoadEvent2;
+              }(TelemetryEvent);
+              var TurnstileEvent = function(TelemetryEvent2) {
+                function TurnstileEvent2(customAccessToken) {
+                  TelemetryEvent2.call(this, "appUserTurnstile");
+                  this._customAccessToken = customAccessToken;
+                }
+                if (TelemetryEvent2)
+                  TurnstileEvent2.__proto__ = TelemetryEvent2;
+                TurnstileEvent2.prototype = Object.create(TelemetryEvent2 && TelemetryEvent2.prototype);
+                TurnstileEvent2.prototype.constructor = TurnstileEvent2;
+                TurnstileEvent2.prototype.postTurnstileEvent = function postTurnstileEvent2(tileUrls, customAccessToken) {
+                  if (config2.EVENTS_URL && config2.ACCESS_TOKEN && Array.isArray(tileUrls) && tileUrls.some(function(url) {
+                    return isMapboxURL(url) || isMapboxHTTPURL(url);
+                  })) {
+                    this.queueRequest(Date.now(), customAccessToken);
+                  }
+                };
+                TurnstileEvent2.prototype.processRequests = function processRequests(customAccessToken) {
+                  var this$1$1 = this;
+                  if (this.pendingRequest || this.queue.length === 0) {
+                    return;
+                  }
+                  if (!this.anonId || !this.eventData.lastSuccess || !this.eventData.tokenU) {
+                    this.fetchEventData();
+                  }
+                  var tokenData = parseAccessToken(config2.ACCESS_TOKEN);
+                  var tokenU = tokenData ? tokenData["u"] : config2.ACCESS_TOKEN;
+                  var dueForEvent = tokenU !== this.eventData.tokenU;
+                  if (!validateUuid(this.anonId)) {
+                    this.anonId = uuid();
+                    dueForEvent = true;
+                  }
+                  var nextUpdate = this.queue.shift();
+                  if (this.eventData.lastSuccess) {
+                    var lastUpdate = new Date(this.eventData.lastSuccess);
+                    var nextDate = new Date(nextUpdate);
+                    var daysElapsed = (nextUpdate - this.eventData.lastSuccess) / (24 * 60 * 60 * 1e3);
+                    dueForEvent = dueForEvent || daysElapsed >= 1 || daysElapsed < -1 || lastUpdate.getDate() !== nextDate.getDate();
+                  } else {
+                    dueForEvent = true;
+                  }
+                  if (!dueForEvent) {
+                    return this.processRequests();
+                  }
+                  this.postEvent(nextUpdate, { "enabled.telemetry": false }, function(err) {
+                    if (!err) {
+                      this$1$1.eventData.lastSuccess = nextUpdate;
+                      this$1$1.eventData.tokenU = tokenU;
+                    }
+                  }, customAccessToken);
+                };
+                return TurnstileEvent2;
+              }(TelemetryEvent);
+              var turnstileEvent_ = new TurnstileEvent();
+              var postTurnstileEvent = turnstileEvent_.postTurnstileEvent.bind(turnstileEvent_);
+              var mapLoadEvent_ = new MapLoadEvent();
+              var postMapLoadEvent = mapLoadEvent_.postMapLoadEvent.bind(mapLoadEvent_);
+              var CACHE_NAME = "mapbox-tiles";
+              var cacheLimit = 500;
+              var cacheCheckThreshold = 50;
+              var MIN_TIME_UNTIL_EXPIRY = 1e3 * 60 * 7;
+              var sharedCache;
+              function cacheOpen() {
+                if (window$1.caches && !sharedCache) {
+                  sharedCache = window$1.caches.open(CACHE_NAME);
+                }
+              }
+              var responseConstructorSupportsReadableStream;
+              function prepareBody(response, callback) {
+                if (responseConstructorSupportsReadableStream === void 0) {
+                  try {
+                    new Response(new ReadableStream());
+                    responseConstructorSupportsReadableStream = true;
+                  } catch (e2) {
+                    responseConstructorSupportsReadableStream = false;
+                  }
+                }
+                if (responseConstructorSupportsReadableStream) {
+                  callback(response.body);
+                } else {
+                  response.blob().then(callback);
+                }
+              }
+              function cachePut(request, response, requestTime) {
+                cacheOpen();
+                if (!sharedCache) {
+                  return;
+                }
+                var options = {
+                  status: response.status,
+                  statusText: response.statusText,
+                  headers: new window$1.Headers()
+                };
+                response.headers.forEach(function(v2, k2) {
+                  return options.headers.set(k2, v2);
+                });
+                var cacheControl = parseCacheControl(response.headers.get("Cache-Control") || "");
+                if (cacheControl["no-store"]) {
+                  return;
+                }
+                if (cacheControl["max-age"]) {
+                  options.headers.set("Expires", new Date(requestTime + cacheControl["max-age"] * 1e3).toUTCString());
+                }
+                var timeUntilExpiry = new Date(options.headers.get("Expires")).getTime() - requestTime;
+                if (timeUntilExpiry < MIN_TIME_UNTIL_EXPIRY) {
+                  return;
+                }
+                prepareBody(response, function(body) {
+                  var clonedResponse = new window$1.Response(body, options);
+                  cacheOpen();
+                  if (!sharedCache) {
+                    return;
+                  }
+                  sharedCache.then(function(cache) {
+                    return cache.put(stripQueryParameters(request.url), clonedResponse);
+                  }).catch(function(e2) {
+                    return warnOnce(e2.message);
+                  });
+                });
+              }
+              function stripQueryParameters(url) {
+                var start = url.indexOf("?");
+                return start < 0 ? url : url.slice(0, start);
+              }
+              function cacheGet(request, callback) {
+                cacheOpen();
+                if (!sharedCache) {
+                  return callback(null);
+                }
+                var strippedURL = stripQueryParameters(request.url);
+                sharedCache.then(function(cache) {
+                  cache.match(strippedURL).then(function(response) {
+                    var fresh = isFresh(response);
+                    cache.delete(strippedURL);
+                    if (fresh) {
+                      cache.put(strippedURL, response.clone());
+                    }
+                    callback(null, response, fresh);
+                  }).catch(callback);
+                }).catch(callback);
+              }
+              function isFresh(response) {
+                if (!response) {
+                  return false;
+                }
+                var expires = new Date(response.headers.get("Expires") || 0);
+                var cacheControl = parseCacheControl(response.headers.get("Cache-Control") || "");
+                return expires > Date.now() && !cacheControl["no-cache"];
+              }
+              var globalEntryCounter = Infinity;
+              function cacheEntryPossiblyAdded(dispatcher) {
+                globalEntryCounter++;
+                if (globalEntryCounter > cacheCheckThreshold) {
+                  dispatcher.getActor().send("enforceCacheSizeLimit", cacheLimit);
+                  globalEntryCounter = 0;
+                }
+              }
+              function enforceCacheSizeLimit(limit) {
+                cacheOpen();
+                if (!sharedCache) {
+                  return;
+                }
+                sharedCache.then(function(cache) {
+                  cache.keys().then(function(keys) {
+                    for (var i2 = 0; i2 < keys.length - limit; i2++) {
+                      cache.delete(keys[i2]);
+                    }
+                  });
+                });
+              }
+              function clearTileCache(callback) {
+                var promise = window$1.caches.delete(CACHE_NAME);
+                if (callback) {
+                  promise.catch(callback).then(function() {
+                    return callback();
+                  });
+                }
+              }
+              function setCacheLimits(limit, checkThreshold) {
+                cacheLimit = limit;
+                cacheCheckThreshold = checkThreshold;
+              }
+              var supportsOffscreenCanvas;
+              function offscreenCanvasSupported() {
+                if (supportsOffscreenCanvas == null) {
+                  supportsOffscreenCanvas = window$1.OffscreenCanvas && new window$1.OffscreenCanvas(1, 1).getContext("2d") && typeof window$1.createImageBitmap === "function";
+                }
+                return supportsOffscreenCanvas;
+              }
+              var ResourceType = {
+                Unknown: "Unknown",
+                Style: "Style",
+                Source: "Source",
+                Tile: "Tile",
+                Glyphs: "Glyphs",
+                SpriteImage: "SpriteImage",
+                SpriteJSON: "SpriteJSON",
+                Image: "Image"
+              };
+              if (typeof Object.freeze == "function") {
+                Object.freeze(ResourceType);
+              }
+              var AJAXError = function(Error2) {
+                function AJAXError2(message2, status2, url) {
+                  if (status2 === 401 && isMapboxHTTPURL(url)) {
+                    message2 += ": you may have provided an invalid Mapbox access token. See https://www.mapbox.com/api-documentation/#access-tokens-and-token-scopes";
+                  }
+                  Error2.call(this, message2);
+                  this.status = status2;
+                  this.url = url;
+                  this.name = this.constructor.name;
+                  this.message = message2;
+                }
+                if (Error2)
+                  AJAXError2.__proto__ = Error2;
+                AJAXError2.prototype = Object.create(Error2 && Error2.prototype);
+                AJAXError2.prototype.constructor = AJAXError2;
+                AJAXError2.prototype.toString = function toString2() {
+                  return this.name + ": " + this.message + " (" + this.status + "): " + this.url;
+                };
+                return AJAXError2;
+              }(Error);
+              var getReferrer = isWorker() ? function() {
+                return self.worker && self.worker.referrer;
+              } : function() {
+                return (window$1.location.protocol === "blob:" ? window$1.parent : window$1).location.href;
+              };
+              var isFileURL = function(url) {
+                return /^file:/.test(url) || /^file:/.test(getReferrer()) && !/^\w+:/.test(url);
+              };
+              function makeFetchRequest(requestParameters, callback) {
+                var controller = new window$1.AbortController();
+                var request = new window$1.Request(requestParameters.url, {
+                  method: requestParameters.method || "GET",
+                  body: requestParameters.body,
+                  credentials: requestParameters.credentials,
+                  headers: requestParameters.headers,
+                  referrer: getReferrer(),
+                  signal: controller.signal
+                });
+                var complete = false;
+                var aborted = false;
+                var cacheIgnoringSearch = hasCacheDefeatingSku(request.url);
+                if (requestParameters.type === "json") {
+                  request.headers.set("Accept", "application/json");
+                }
+                var validateOrFetch = function(err, cachedResponse, responseIsFresh) {
+                  if (aborted) {
+                    return;
+                  }
+                  if (err) {
+                    if (err.message !== "SecurityError") {
+                      warnOnce(err);
+                    }
+                  }
+                  if (cachedResponse && responseIsFresh) {
+                    return finishRequest(cachedResponse);
+                  }
+                  var requestTime = Date.now();
+                  window$1.fetch(request).then(function(response) {
+                    if (response.ok) {
+                      var cacheableResponse = cacheIgnoringSearch ? response.clone() : null;
+                      return finishRequest(response, cacheableResponse, requestTime);
+                    } else {
+                      return callback(new AJAXError(response.statusText, response.status, requestParameters.url));
+                    }
+                  }).catch(function(error2) {
+                    if (error2.code === 20) {
+                      return;
+                    }
+                    callback(new Error(error2.message));
+                  });
+                };
+                var finishRequest = function(response, cacheableResponse, requestTime) {
+                  (requestParameters.type === "arrayBuffer" ? response.arrayBuffer() : requestParameters.type === "json" ? response.json() : response.text()).then(function(result) {
+                    if (aborted) {
+                      return;
+                    }
+                    if (cacheableResponse && requestTime) {
+                      cachePut(request, cacheableResponse, requestTime);
+                    }
+                    complete = true;
+                    callback(null, result, response.headers.get("Cache-Control"), response.headers.get("Expires"));
+                  }).catch(function(err) {
+                    if (!aborted) {
+                      callback(new Error(err.message));
+                    }
+                  });
+                };
+                if (cacheIgnoringSearch) {
+                  cacheGet(request, validateOrFetch);
+                } else {
+                  validateOrFetch(null, null);
+                }
+                return {
+                  cancel: function() {
+                    aborted = true;
+                    if (!complete) {
+                      controller.abort();
+                    }
+                  }
+                };
+              }
+              function makeXMLHttpRequest(requestParameters, callback) {
+                var xhr = new window$1.XMLHttpRequest();
+                xhr.open(requestParameters.method || "GET", requestParameters.url, true);
+                if (requestParameters.type === "arrayBuffer") {
+                  xhr.responseType = "arraybuffer";
+                }
+                for (var k2 in requestParameters.headers) {
+                  xhr.setRequestHeader(k2, requestParameters.headers[k2]);
+                }
+                if (requestParameters.type === "json") {
+                  xhr.responseType = "text";
+                  xhr.setRequestHeader("Accept", "application/json");
+                }
+                xhr.withCredentials = requestParameters.credentials === "include";
+                xhr.onerror = function() {
+                  callback(new Error(xhr.statusText));
+                };
+                xhr.onload = function() {
+                  if ((xhr.status >= 200 && xhr.status < 300 || xhr.status === 0) && xhr.response !== null) {
+                    var data = xhr.response;
+                    if (requestParameters.type === "json") {
+                      try {
+                        data = JSON.parse(xhr.response);
+                      } catch (err) {
+                        return callback(err);
+                      }
+                    }
+                    callback(null, data, xhr.getResponseHeader("Cache-Control"), xhr.getResponseHeader("Expires"));
+                  } else {
+                    callback(new AJAXError(xhr.statusText, xhr.status, requestParameters.url));
+                  }
+                };
+                xhr.send(requestParameters.body);
+                return {
+                  cancel: function() {
+                    return xhr.abort();
+                  }
+                };
+              }
+              var makeRequest = function(requestParameters, callback) {
+                if (!isFileURL(requestParameters.url)) {
+                  if (window$1.fetch && window$1.Request && window$1.AbortController && window$1.Request.prototype.hasOwnProperty("signal")) {
+                    return makeFetchRequest(requestParameters, callback);
+                  }
+                  if (isWorker() && self.worker && self.worker.actor) {
+                    var queueOnMainThread = true;
+                    return self.worker.actor.send("getResource", requestParameters, callback, void 0, queueOnMainThread);
+                  }
+                }
+                return makeXMLHttpRequest(requestParameters, callback);
+              };
+              var getJSON = function(requestParameters, callback) {
+                return makeRequest(extend2(requestParameters, { type: "json" }), callback);
+              };
+              var getArrayBuffer = function(requestParameters, callback) {
+                return makeRequest(extend2(requestParameters, { type: "arrayBuffer" }), callback);
+              };
+              var postData = function(requestParameters, callback) {
+                return makeRequest(extend2(requestParameters, { method: "POST" }), callback);
+              };
+              function sameOrigin(url) {
+                var a2 = window$1.document.createElement("a");
+                a2.href = url;
+                return a2.protocol === window$1.document.location.protocol && a2.host === window$1.document.location.host;
+              }
+              var transparentPngUrl = "data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAYAAAAfFcSJAAAAC0lEQVQYV2NgAAIAAAUAAarVyFEAAAAASUVORK5CYII=";
+              function arrayBufferToImage(data, callback, cacheControl, expires) {
+                var img = new window$1.Image();
+                var URL2 = window$1.URL;
+                img.onload = function() {
+                  callback(null, img);
+                  URL2.revokeObjectURL(img.src);
+                  img.onload = null;
+                  window$1.requestAnimationFrame(function() {
+                    img.src = transparentPngUrl;
+                  });
+                };
+                img.onerror = function() {
+                  return callback(new Error("Could not load image. Please make sure to use a supported image type such as PNG or JPEG. Note that SVGs are not supported."));
+                };
+                var blob = new window$1.Blob([new Uint8Array(data)], { type: "image/png" });
+                img.cacheControl = cacheControl;
+                img.expires = expires;
+                img.src = data.byteLength ? URL2.createObjectURL(blob) : transparentPngUrl;
+              }
+              function arrayBufferToImageBitmap(data, callback) {
+                var blob = new window$1.Blob([new Uint8Array(data)], { type: "image/png" });
+                window$1.createImageBitmap(blob).then(function(imgBitmap) {
+                  callback(null, imgBitmap);
+                }).catch(function(e2) {
+                  callback(new Error("Could not load image because of " + e2.message + ". Please make sure to use a supported image type such as PNG or JPEG. Note that SVGs are not supported."));
+                });
+              }
+              var imageQueue, numImageRequests;
+              var resetImageRequestQueue = function() {
+                imageQueue = [];
+                numImageRequests = 0;
+              };
+              resetImageRequestQueue();
+              var getImage = function(requestParameters, callback) {
+                if (exported$1.supported) {
+                  if (!requestParameters.headers) {
+                    requestParameters.headers = {};
+                  }
+                  requestParameters.headers.accept = "image/webp,*/*";
+                }
+                if (numImageRequests >= config2.MAX_PARALLEL_IMAGE_REQUESTS) {
+                  var queued = {
+                    requestParameters,
+                    callback,
+                    cancelled: false,
+                    cancel: function cancel2() {
+                      this.cancelled = true;
+                    }
+                  };
+                  imageQueue.push(queued);
+                  return queued;
+                }
+                numImageRequests++;
+                var advanced = false;
+                var advanceImageRequestQueue = function() {
+                  if (advanced) {
+                    return;
+                  }
+                  advanced = true;
+                  numImageRequests--;
+                  while (imageQueue.length && numImageRequests < config2.MAX_PARALLEL_IMAGE_REQUESTS) {
+                    var request2 = imageQueue.shift();
+                    var requestParameters2 = request2.requestParameters;
+                    var callback2 = request2.callback;
+                    var cancelled = request2.cancelled;
+                    if (!cancelled) {
+                      request2.cancel = getImage(requestParameters2, callback2).cancel;
+                    }
+                  }
+                };
+                var request = getArrayBuffer(requestParameters, function(err, data, cacheControl, expires) {
+                  advanceImageRequestQueue();
+                  if (err) {
+                    callback(err);
+                  } else if (data) {
+                    if (offscreenCanvasSupported()) {
+                      arrayBufferToImageBitmap(data, callback);
+                    } else {
+                      arrayBufferToImage(data, callback, cacheControl, expires);
+                    }
+                  }
+                });
+                return {
+                  cancel: function() {
+                    request.cancel();
+                    advanceImageRequestQueue();
+                  }
+                };
+              };
+              var getVideo = function(urls, callback) {
+                var video = window$1.document.createElement("video");
+                video.muted = true;
+                video.onloadstart = function() {
+                  callback(null, video);
+                };
+                for (var i2 = 0; i2 < urls.length; i2++) {
+                  var s2 = window$1.document.createElement("source");
+                  if (!sameOrigin(urls[i2])) {
+                    video.crossOrigin = "Anonymous";
+                  }
+                  s2.src = urls[i2];
+                  video.appendChild(s2);
+                }
+                return {
+                  cancel: function() {
+                  }
+                };
+              };
+              function _addEventListener(type, listener, listenerList) {
+                var listenerExists = listenerList[type] && listenerList[type].indexOf(listener) !== -1;
+                if (!listenerExists) {
+                  listenerList[type] = listenerList[type] || [];
+                  listenerList[type].push(listener);
+                }
+              }
+              function _removeEventListener(type, listener, listenerList) {
+                if (listenerList && listenerList[type]) {
+                  var index = listenerList[type].indexOf(listener);
+                  if (index !== -1) {
+                    listenerList[type].splice(index, 1);
+                  }
+                }
+              }
+              var Event2 = function Event22(type, data) {
+                if (data === void 0)
+                  data = {};
+                extend2(this, data);
+                this.type = type;
+              };
+              var ErrorEvent = function(Event22) {
+                function ErrorEvent2(error2, data) {
+                  if (data === void 0)
+                    data = {};
+                  Event22.call(this, "error", extend2({ error: error2 }, data));
+                }
+                if (Event22)
+                  ErrorEvent2.__proto__ = Event22;
+                ErrorEvent2.prototype = Object.create(Event22 && Event22.prototype);
+                ErrorEvent2.prototype.constructor = ErrorEvent2;
+                return ErrorEvent2;
+              }(Event2);
+              var Evented = function Evented2() {
+              };
+              Evented.prototype.on = function on(type, listener) {
+                this._listeners = this._listeners || {};
+                _addEventListener(type, listener, this._listeners);
+                return this;
+              };
+              Evented.prototype.off = function off(type, listener) {
+                _removeEventListener(type, listener, this._listeners);
+                _removeEventListener(type, listener, this._oneTimeListeners);
+                return this;
+              };
+              Evented.prototype.once = function once(type, listener) {
+                this._oneTimeListeners = this._oneTimeListeners || {};
+                _addEventListener(type, listener, this._oneTimeListeners);
+                return this;
+              };
+              Evented.prototype.fire = function fire(event, properties2) {
+                if (typeof event === "string") {
+                  event = new Event2(event, properties2 || {});
+                }
+                var type = event.type;
+                if (this.listens(type)) {
+                  event.target = this;
+                  var listeners = this._listeners && this._listeners[type] ? this._listeners[type].slice() : [];
+                  for (var i2 = 0, list = listeners; i2 < list.length; i2 += 1) {
+                    var listener = list[i2];
+                    listener.call(this, event);
+                  }
+                  var oneTimeListeners = this._oneTimeListeners && this._oneTimeListeners[type] ? this._oneTimeListeners[type].slice() : [];
+                  for (var i$1 = 0, list$1 = oneTimeListeners; i$1 < list$1.length; i$1 += 1) {
+                    var listener$1 = list$1[i$1];
+                    _removeEventListener(type, listener$1, this._oneTimeListeners);
+                    listener$1.call(this, event);
+                  }
+                  var parent = this._eventedParent;
+                  if (parent) {
+                    extend2(event, typeof this._eventedParentData === "function" ? this._eventedParentData() : this._eventedParentData);
+                    parent.fire(event);
+                  }
+                } else if (event instanceof ErrorEvent) {
+                  console.error(event.error);
+                }
+                return this;
+              };
+              Evented.prototype.listens = function listens(type) {
+                return this._listeners && this._listeners[type] && this._listeners[type].length > 0 || this._oneTimeListeners && this._oneTimeListeners[type] && this._oneTimeListeners[type].length > 0 || this._eventedParent && this._eventedParent.listens(type);
+              };
+              Evented.prototype.setEventedParent = function setEventedParent(parent, data) {
+                this._eventedParent = parent;
+                this._eventedParentData = data;
+                return this;
+              };
+              var $version = 8;
+              var $root = {
+                version: {
+                  required: true,
+                  type: "enum",
+                  values: [
+                    8
+                  ]
+                },
+                name: {
+                  type: "string"
+                },
+                metadata: {
+                  type: "*"
+                },
+                center: {
+                  type: "array",
+                  value: "number"
+                },
+                zoom: {
+                  type: "number"
+                },
+                bearing: {
+                  type: "number",
+                  "default": 0,
+                  period: 360,
+                  units: "degrees"
+                },
+                pitch: {
+                  type: "number",
+                  "default": 0,
+                  units: "degrees"
+                },
+                light: {
+                  type: "light"
+                },
+                sources: {
+                  required: true,
+                  type: "sources"
+                },
+                sprite: {
+                  type: "string"
+                },
+                glyphs: {
+                  type: "string"
+                },
+                transition: {
+                  type: "transition"
+                },
+                layers: {
+                  required: true,
+                  type: "array",
+                  value: "layer"
+                }
+              };
+              var sources = {
+                "*": {
+                  type: "source"
+                }
+              };
+              var source2 = [
+                "source_vector",
+                "source_raster",
+                "source_raster_dem",
+                "source_geojson",
+                "source_video",
+                "source_image"
+              ];
+              var source_vector = {
+                type: {
+                  required: true,
+                  type: "enum",
+                  values: {
+                    vector: {}
+                  }
+                },
+                url: {
+                  type: "string"
+                },
+                tiles: {
+                  type: "array",
+                  value: "string"
+                },
+                bounds: {
+                  type: "array",
+                  value: "number",
+                  length: 4,
+                  "default": [
+                    -180,
+                    -85.051129,
+                    180,
+                    85.051129
+                  ]
+                },
+                scheme: {
+                  type: "enum",
+                  values: {
+                    xyz: {},
+                    tms: {}
+                  },
+                  "default": "xyz"
+                },
+                minzoom: {
+                  type: "number",
+                  "default": 0
+                },
+                maxzoom: {
+                  type: "number",
+                  "default": 22
+                },
+                attribution: {
+                  type: "string"
+                },
+                promoteId: {
+                  type: "promoteId"
+                },
+                volatile: {
+                  type: "boolean",
+                  "default": false
+                },
+                "*": {
+                  type: "*"
+                }
+              };
+              var source_raster = {
+                type: {
+                  required: true,
+                  type: "enum",
+                  values: {
+                    raster: {}
+                  }
+                },
+                url: {
+                  type: "string"
+                },
+                tiles: {
+                  type: "array",
+                  value: "string"
+                },
+                bounds: {
+                  type: "array",
+                  value: "number",
+                  length: 4,
+                  "default": [
+                    -180,
+                    -85.051129,
+                    180,
+                    85.051129
+                  ]
+                },
+                minzoom: {
+                  type: "number",
+                  "default": 0
+                },
+                maxzoom: {
+                  type: "number",
+                  "default": 22
+                },
+                tileSize: {
+                  type: "number",
+                  "default": 512,
+                  units: "pixels"
+                },
+                scheme: {
+                  type: "enum",
+                  values: {
+                    xyz: {},
+                    tms: {}
+                  },
+                  "default": "xyz"
+                },
+                attribution: {
+                  type: "string"
+                },
+                volatile: {
+                  type: "boolean",
+                  "default": false
+                },
+                "*": {
+                  type: "*"
+                }
+              };
+              var source_raster_dem = {
+                type: {
+                  required: true,
+                  type: "enum",
+                  values: {
+                    "raster-dem": {}
+                  }
+                },
+                url: {
+                  type: "string"
+                },
+                tiles: {
+                  type: "array",
+                  value: "string"
+                },
+                bounds: {
+                  type: "array",
+                  value: "number",
+                  length: 4,
+                  "default": [
+                    -180,
+                    -85.051129,
+                    180,
+                    85.051129
+                  ]
+                },
+                minzoom: {
+                  type: "number",
+                  "default": 0
+                },
+                maxzoom: {
+                  type: "number",
+                  "default": 22
+                },
+                tileSize: {
+                  type: "number",
+                  "default": 512,
+                  units: "pixels"
+                },
+                attribution: {
+                  type: "string"
+                },
+                encoding: {
+                  type: "enum",
+                  values: {
+                    terrarium: {},
+                    mapbox: {}
+                  },
+                  "default": "mapbox"
+                },
+                volatile: {
+                  type: "boolean",
+                  "default": false
+                },
+                "*": {
+                  type: "*"
+                }
+              };
+              var source_geojson = {
+                type: {
+                  required: true,
+                  type: "enum",
+                  values: {
+                    geojson: {}
+                  }
+                },
+                data: {
+                  type: "*"
+                },
+                maxzoom: {
+                  type: "number",
+                  "default": 18
+                },
+                attribution: {
+                  type: "string"
+                },
+                buffer: {
+                  type: "number",
+                  "default": 128,
+                  maximum: 512,
+                  minimum: 0
+                },
+                filter: {
+                  type: "*"
+                },
+                tolerance: {
+                  type: "number",
+                  "default": 0.375
+                },
+                cluster: {
+                  type: "boolean",
+                  "default": false
+                },
+                clusterRadius: {
+                  type: "number",
+                  "default": 50,
+                  minimum: 0
+                },
+                clusterMaxZoom: {
+                  type: "number"
+                },
+                clusterMinPoints: {
+                  type: "number"
+                },
+                clusterProperties: {
+                  type: "*"
+                },
+                lineMetrics: {
+                  type: "boolean",
+                  "default": false
+                },
+                generateId: {
+                  type: "boolean",
+                  "default": false
+                },
+                promoteId: {
+                  type: "promoteId"
+                }
+              };
+              var source_video = {
+                type: {
+                  required: true,
+                  type: "enum",
+                  values: {
+                    video: {}
+                  }
+                },
+                urls: {
+                  required: true,
+                  type: "array",
+                  value: "string"
+                },
+                coordinates: {
+                  required: true,
+                  type: "array",
+                  length: 4,
+                  value: {
+                    type: "array",
+                    length: 2,
+                    value: "number"
+                  }
+                }
+              };
+              var source_image = {
+                type: {
+                  required: true,
+                  type: "enum",
+                  values: {
+                    image: {}
+                  }
+                },
+                url: {
+                  required: true,
+                  type: "string"
+                },
+                coordinates: {
+                  required: true,
+                  type: "array",
+                  length: 4,
+                  value: {
+                    type: "array",
+                    length: 2,
+                    value: "number"
+                  }
+                }
+              };
+              var layer = {
+                id: {
+                  type: "string",
+                  required: true
+                },
+                type: {
+                  type: "enum",
+                  values: {
+                    fill: {},
+                    line: {},
+                    symbol: {},
+                    circle: {},
+                    heatmap: {},
+                    "fill-extrusion": {},
+                    raster: {},
+                    hillshade: {},
+                    background: {}
+                  },
+                  required: true
+                },
+                metadata: {
+                  type: "*"
+                },
+                source: {
+                  type: "string"
+                },
+                "source-layer": {
+                  type: "string"
+                },
+                minzoom: {
+                  type: "number",
+                  minimum: 0,
+                  maximum: 24
+                },
+                maxzoom: {
+                  type: "number",
+                  minimum: 0,
+                  maximum: 24
+                },
+                filter: {
+                  type: "filter"
+                },
+                layout: {
+                  type: "layout"
+                },
+                paint: {
+                  type: "paint"
+                }
+              };
+              var layout = [
+                "layout_fill",
+                "layout_line",
+                "layout_circle",
+                "layout_heatmap",
+                "layout_fill-extrusion",
+                "layout_symbol",
+                "layout_raster",
+                "layout_hillshade",
+                "layout_background"
+              ];
+              var layout_background = {
+                visibility: {
+                  type: "enum",
+                  values: {
+                    visible: {},
+                    none: {}
+                  },
+                  "default": "visible",
+                  "property-type": "constant"
+                }
+              };
+              var layout_fill = {
+                "fill-sort-key": {
+                  type: "number",
+                  expression: {
+                    interpolated: false,
+                    parameters: [
+                      "zoom",
+                      "feature"
+                    ]
+                  },
+                  "property-type": "data-driven"
+                },
+                visibility: {
+                  type: "enum",
+                  values: {
+                    visible: {},
+                    none: {}
+                  },
+                  "default": "visible",
+                  "property-type": "constant"
+                }
+              };
+              var layout_circle = {
+                "circle-sort-key": {
+                  type: "number",
+                  expression: {
+                    interpolated: false,
+                    parameters: [
+                      "zoom",
+                      "feature"
+                    ]
+                  },
+                  "property-type": "data-driven"
+                },
+                visibility: {
+                  type: "enum",
+                  values: {
+                    visible: {},
+                    none: {}
+                  },
+                  "default": "visible",
+                  "property-type": "constant"
+                }
+              };
+              var layout_heatmap = {
+                visibility: {
+                  type: "enum",
+                  values: {
+                    visible: {},
+                    none: {}
+                  },
+                  "default": "visible",
+                  "property-type": "constant"
+                }
+              };
+              var layout_line = {
+                "line-cap": {
+                  type: "enum",
+                  values: {
+                    butt: {},
+                    round: {},
+                    square: {}
+                  },
+                  "default": "butt",
+                  expression: {
+                    interpolated: false,
+                    parameters: [
+                      "zoom"
+                    ]
+                  },
+                  "property-type": "data-constant"
+                },
+                "line-join": {
+                  type: "enum",
+                  values: {
+                    bevel: {},
+                    round: {},
+                    miter: {}
+                  },
+                  "default": "miter",
+                  expression: {
+                    interpolated: false,
+                    parameters: [
+                      "zoom",
+                      "feature"
+                    ]
+                  },
+                  "property-type": "data-driven"
+                },
+                "line-miter-limit": {
+                  type: "number",
+                  "default": 2,
+                  requires: [
+                    {
+                      "line-join": "miter"
+                    }
+                  ],
+                  expression: {
+                    interpolated: true,
+                    parameters: [
+                      "zoom"
+                    ]
+                  },
+                  "property-type": "data-constant"
+                },
+                "line-round-limit": {
+                  type: "number",
+                  "default": 1.05,
+                  requires: [
+                    {
+                      "line-join": "round"
+                    }
+                  ],
+                  expression: {
+                    interpolated: true,
+                    parameters: [
+                      "zoom"
+                    ]
+                  },
+                  "property-type": "data-constant"
+                },
+                "line-sort-key": {
+                  type: "number",
+                  expression: {
+                    interpolated: false,
+                    parameters: [
+                      "zoom",
+                      "feature"
+                    ]
+                  },
+                  "property-type": "data-driven"
+                },
+                visibility: {
+                  type: "enum",
+                  values: {
+                    visible: {},
+                    none: {}
+                  },
+                  "default": "visible",
+                  "property-type": "constant"
+                }
+              };
+              var layout_symbol = {
+                "symbol-placement": {
+                  type: "enum",
+                  values: {
+                    point: {},
+                    line: {},
+                    "line-center": {}
+                  },
+                  "default": "point",
+                  expression: {
+                    interpolated: false,
+                    parameters: [
+                      "zoom"
+                    ]
+                  },
+                  "property-type": "data-constant"
+                },
+                "symbol-spacing": {
+                  type: "number",
+                  "default": 250,
+                  minimum: 1,
+                  units: "pixels",
+                  requires: [
+                    {
+                      "symbol-placement": "line"
+                    }
+                  ],
+                  expression: {
+                    interpolated: true,
+                    parameters: [
+                      "zoom"
+                    ]
+                  },
+                  "property-type": "data-constant"
+                },
+                "symbol-avoid-edges": {
+                  type: "boolean",
+                  "default": false,
+                  expression: {
+                    interpolated: false,
+                    parameters: [
+                      "zoom"
+                    ]
+                  },
+                  "property-type": "data-constant"
+                },
+                "symbol-sort-key": {
+                  type: "number",
+                  expression: {
+                    interpolated: false,
+                    parameters: [
+                      "zoom",
+                      "feature"
+                    ]
+                  },
+                  "property-type": "data-driven"
+                },
+                "symbol-z-order": {
+                  type: "enum",
+                  values: {
+                    auto: {},
+                    "viewport-y": {},
+                    source: {}
+                  },
+                  "default": "auto",
+                  expression: {
+                    interpolated: false,
+                    parameters: [
+                      "zoom"
+                    ]
+                  },
+                  "property-type": "data-constant"
+                },
+                "icon-allow-overlap": {
+                  type: "boolean",
+                  "default": false,
+                  requires: [
+                    "icon-image"
+                  ],
+                  expression: {
+                    interpolated: false,
+                    parameters: [
+                      "zoom"
+                    ]
+                  },
+                  "property-type": "data-constant"
+                },
+                "icon-ignore-placement": {
+                  type: "boolean",
+                  "default": false,
+                  requires: [
+                    "icon-image"
+                  ],
+                  expression: {
+                    interpolated: false,
+                    parameters: [
+                      "zoom"
+                    ]
+                  },
+                  "property-type": "data-constant"
+                },
+                "icon-optional": {
+                  type: "boolean",
+                  "default": false,
+                  requires: [
+                    "icon-image",
+                    "text-field"
+                  ],
+                  expression: {
+                    interpolated: false,
+                    parameters: [
+                      "zoom"
+                    ]
+                  },
+                  "property-type": "data-constant"
+                },
+                "icon-rotation-alignment": {
+                  type: "enum",
+                  values: {
+                    map: {},
+                    viewport: {},
+                    auto: {}
+                  },
+                  "default": "auto",
+                  requires: [
+                    "icon-image"
+                  ],
+                  expression: {
+                    interpolated: false,
+                    parameters: [
+                      "zoom"
+                    ]
+                  },
+                  "property-type": "data-constant"
+                },
+                "icon-size": {
+                  type: "number",
+                  "default": 1,
+                  minimum: 0,
+                  units: "factor of the original icon size",
+                  requires: [
+                    "icon-image"
+                  ],
+                  expression: {
+                    interpolated: true,
+                    parameters: [
+                      "zoom",
+                      "feature"
+                    ]
+                  },
+                  "property-type": "data-driven"
+                },
+                "icon-text-fit": {
+                  type: "enum",
+                  values: {
+                    none: {},
+                    width: {},
+                    height: {},
+                    both: {}
+                  },
+                  "default": "none",
+                  requires: [
+                    "icon-image",
+                    "text-field"
+                  ],
+                  expression: {
+                    interpolated: false,
+                    parameters: [
+                      "zoom"
+                    ]
+                  },
+                  "property-type": "data-constant"
+                },
+                "icon-text-fit-padding": {
+                  type: "array",
+                  value: "number",
+                  length: 4,
+                  "default": [
+                    0,
+                    0,
+                    0,
+                    0
+                  ],
+                  units: "pixels",
+                  requires: [
+                    "icon-image",
+                    "text-field",
+                    {
+                      "icon-text-fit": [
+                        "both",
+                        "width",
+                        "height"
+                      ]
+                    }
+                  ],
+                  expression: {
+                    interpolated: true,
+                    parameters: [
+                      "zoom"
+                    ]
+                  },
+                  "property-type": "data-constant"
+                },
+                "icon-image": {
+                  type: "resolvedImage",
+                  tokens: true,
+                  expression: {
+                    interpolated: false,
+                    parameters: [
+                      "zoom",
+                      "feature"
+                    ]
+                  },
+                  "property-type": "data-driven"
+                },
+                "icon-rotate": {
+                  type: "number",
+                  "default": 0,
+                  period: 360,
+                  units: "degrees",
+                  requires: [
+                    "icon-image"
+                  ],
+                  expression: {
+                    interpolated: true,
+                    parameters: [
+                      "zoom",
+                      "feature"
+                    ]
+                  },
+                  "property-type": "data-driven"
+                },
+                "icon-padding": {
+                  type: "number",
+                  "default": 2,
+                  minimum: 0,
+                  units: "pixels",
+                  requires: [
+                    "icon-image"
+                  ],
+                  expression: {
+                    interpolated: true,
+                    parameters: [
+                      "zoom"
+                    ]
+                  },
+                  "property-type": "data-constant"
+                },
+                "icon-keep-upright": {
+                  type: "boolean",
+                  "default": false,
+                  requires: [
+                    "icon-image",
+                    {
+                      "icon-rotation-alignment": "map"
+                    },
+                    {
+                      "symbol-placement": [
+                        "line",
+                        "line-center"
+                      ]
+                    }
+                  ],
+                  expression: {
+                    interpolated: false,
+                    parameters: [
+                      "zoom"
+                    ]
+                  },
+                  "property-type": "data-constant"
+                },
+                "icon-offset": {
+                  type: "array",
+                  value: "number",
+                  length: 2,
+                  "default": [
+                    0,
+                    0
+                  ],
+                  requires: [
+                    "icon-image"
+                  ],
+                  expression: {
+                    interpolated: true,
+                    parameters: [
+                      "zoom",
+                      "feature"
+                    ]
+                  },
+                  "property-type": "data-driven"
+                },
+                "icon-anchor": {
+                  type: "enum",
+                  values: {
+                    center: {},
+                    left: {},
+                    right: {},
+                    top: {},
+                    bottom: {},
+                    "top-left": {},
+                    "top-right": {},
+                    "bottom-left": {},
+                    "bottom-right": {}
+                  },
+                  "default": "center",
+                  requires: [
+                    "icon-image"
+                  ],
+                  expression: {
+                    interpolated: false,
+                    parameters: [
+                      "zoom",
+                      "feature"
+                    ]
+                  },
+                  "property-type": "data-driven"
+                },
+                "icon-pitch-alignment": {
+                  type: "enum",
+                  values: {
+                    map: {},
+                    viewport: {},
+                    auto: {}
+                  },
+                  "default": "auto",
+                  requires: [
+                    "icon-image"
+                  ],
+                  expression: {
+                    interpolated: false,
+                    parameters: [
+                      "zoom"
+                    ]
+                  },
+                  "property-type": "data-constant"
+                },
+                "text-pitch-alignment": {
+                  type: "enum",
+                  values: {
+                    map: {},
+                    viewport: {},
+                    auto: {}
+                  },
+                  "default": "auto",
+                  requires: [
+                    "text-field"
+                  ],
+                  expression: {
+                    interpolated: false,
+                    parameters: [
+                      "zoom"
+                    ]
+                  },
+                  "property-type": "data-constant"
+                },
+                "text-rotation-alignment": {
+                  type: "enum",
+                  values: {
+                    map: {},
+                    viewport: {},
+                    auto: {}
+                  },
+                  "default": "auto",
+                  requires: [
+                    "text-field"
+                  ],
+                  expression: {
+                    interpolated: false,
+                    parameters: [
+                      "zoom"
+                    ]
+                  },
+                  "property-type": "data-constant"
+                },
+                "text-field": {
+                  type: "formatted",
+                  "default": "",
+                  tokens: true,
+                  expression: {
+                    interpolated: false,
+                    parameters: [
+                      "zoom",
+                      "feature"
+                    ]
+                  },
+                  "property-type": "data-driven"
+                },
+                "text-font": {
+                  type: "array",
+                  value: "string",
+                  "default": [
+                    "Open Sans Regular",
+                    "Arial Unicode MS Regular"
+                  ],
+                  requires: [
+                    "text-field"
+                  ],
+                  expression: {
+                    interpolated: false,
+                    parameters: [
+                      "zoom",
+                      "feature"
+                    ]
+                  },
+                  "property-type": "data-driven"
+                },
+                "text-size": {
+                  type: "number",
+                  "default": 16,
+                  minimum: 0,
+                  units: "pixels",
+                  requires: [
+                    "text-field"
+                  ],
+                  expression: {
+                    interpolated: true,
+                    parameters: [
+                      "zoom",
+                      "feature"
+                    ]
+                  },
+                  "property-type": "data-driven"
+                },
+                "text-max-width": {
+                  type: "number",
+                  "default": 10,
+                  minimum: 0,
+                  units: "ems",
+                  requires: [
+                    "text-field"
+                  ],
+                  expression: {
+                    interpolated: true,
+                    parameters: [
+                      "zoom",
+                      "feature"
+                    ]
+                  },
+                  "property-type": "data-driven"
+                },
+                "text-line-height": {
+                  type: "number",
+                  "default": 1.2,
+                  units: "ems",
+                  requires: [
+                    "text-field"
+                  ],
+                  expression: {
+                    interpolated: true,
+                    parameters: [
+                      "zoom"
+                    ]
+                  },
+                  "property-type": "data-constant"
+                },
+                "text-letter-spacing": {
+                  type: "number",
+                  "default": 0,
+                  units: "ems",
+                  requires: [
+                    "text-field"
+                  ],
+                  expression: {
+                    interpolated: true,
+                    parameters: [
+                      "zoom",
+                      "feature"
+                    ]
+                  },
+                  "property-type": "data-driven"
+                },
+                "text-justify": {
+                  type: "enum",
+                  values: {
+                    auto: {},
+                    left: {},
+                    center: {},
+                    right: {}
+                  },
+                  "default": "center",
+                  requires: [
+                    "text-field"
+                  ],
+                  expression: {
+                    interpolated: false,
+                    parameters: [
+                      "zoom",
+                      "feature"
+                    ]
+                  },
+                  "property-type": "data-driven"
+                },
+                "text-radial-offset": {
+                  type: "number",
+                  units: "ems",
+                  "default": 0,
+                  requires: [
+                    "text-field"
+                  ],
+                  "property-type": "data-driven",
+                  expression: {
+                    interpolated: true,
+                    parameters: [
+                      "zoom",
+                      "feature"
+                    ]
+                  }
+                },
+                "text-variable-anchor": {
+                  type: "array",
+                  value: "enum",
+                  values: {
+                    center: {},
+                    left: {},
+                    right: {},
+                    top: {},
+                    bottom: {},
+                    "top-left": {},
+                    "top-right": {},
+                    "bottom-left": {},
+                    "bottom-right": {}
+                  },
+                  requires: [
+                    "text-field",
+                    {
+                      "symbol-placement": [
+                        "point"
+                      ]
+                    }
+                  ],
+                  expression: {
+                    interpolated: false,
+                    parameters: [
+                      "zoom"
+                    ]
+                  },
+                  "property-type": "data-constant"
+                },
+                "text-anchor": {
+                  type: "enum",
+                  values: {
+                    center: {},
+                    left: {},
+                    right: {},
+                    top: {},
+                    bottom: {},
+                    "top-left": {},
+                    "top-right": {},
+                    "bottom-left": {},
+                    "bottom-right": {}
+                  },
+                  "default": "center",
+                  requires: [
+                    "text-field",
+                    {
+                      "!": "text-variable-anchor"
+                    }
+                  ],
+                  expression: {
+                    interpolated: false,
+                    parameters: [
+                      "zoom",
+                      "feature"
+                    ]
+                  },
+                  "property-type": "data-driven"
+                },
+                "text-max-angle": {
+                  type: "number",
+                  "default": 45,
+                  units: "degrees",
+                  requires: [
+                    "text-field",
+                    {
+                      "symbol-placement": [
+                        "line",
+                        "line-center"
+                      ]
+                    }
+                  ],
+                  expression: {
+                    interpolated: true,
+                    parameters: [
+                      "zoom"
+                    ]
+                  },
+                  "property-type": "data-constant"
+                },
+                "text-writing-mode": {
+                  type: "array",
+                  value: "enum",
+                  values: {
+                    horizontal: {},
+                    vertical: {}
+                  },
+                  requires: [
+                    "text-field",
+                    {
+                      "symbol-placement": [
+                        "point"
+                      ]
+                    }
+                  ],
+                  expression: {
+                    interpolated: false,
+                    parameters: [
+                      "zoom"
+                    ]
+                  },
+                  "property-type": "data-constant"
+                },
+                "text-rotate": {
+                  type: "number",
+                  "default": 0,
+                  period: 360,
+                  units: "degrees",
+                  requires: [
+                    "text-field"
+                  ],
+                  expression: {
+                    interpolated: true,
+                    parameters: [
+                      "zoom",
+                      "feature"
+                    ]
+                  },
+                  "property-type": "data-driven"
+                },
+                "text-padding": {
+                  type: "number",
+                  "default": 2,
+                  minimum: 0,
+                  units: "pixels",
+                  requires: [
+                    "text-field"
+                  ],
+                  expression: {
+                    interpolated: true,
+                    parameters: [
+                      "zoom"
+                    ]
+                  },
+                  "property-type": "data-constant"
+                },
+                "text-keep-upright": {
+                  type: "boolean",
+                  "default": true,
+                  requires: [
+                    "text-field",
+                    {
+                      "text-rotation-alignment": "map"
+                    },
+                    {
+                      "symbol-placement": [
+                        "line",
+                        "line-center"
+                      ]
+                    }
+                  ],
+                  expression: {
+                    interpolated: false,
+                    parameters: [
+                      "zoom"
+                    ]
+                  },
+                  "property-type": "data-constant"
+                },
+                "text-transform": {
+                  type: "enum",
+                  values: {
+                    none: {},
+                    uppercase: {},
+                    lowercase: {}
+                  },
+                  "default": "none",
+                  requires: [
+                    "text-field"
+                  ],
+                  expression: {
+                    interpolated: false,
+                    parameters: [
+                      "zoom",
+                      "feature"
+                    ]
+                  },
+                  "property-type": "data-driven"
+                },
+                "text-offset": {
+                  type: "array",
+                  value: "number",
+                  units: "ems",
+                  length: 2,
+                  "default": [
+                    0,
+                    0
+                  ],
+                  requires: [
+                    "text-field",
+                    {
+                      "!": "text-radial-offset"
+                    }
+                  ],
+                  expression: {
+                    interpolated: true,
+                    parameters: [
+                      "zoom",
+                      "feature"
+                    ]
+                  },
+                  "property-type": "data-driven"
+                },
+                "text-allow-overlap": {
+                  type: "boolean",
+                  "default": false,
+                  requires: [
+                    "text-field"
+                  ],
+                  expression: {
+                    interpolated: false,
+                    parameters: [
+                      "zoom"
+                    ]
+                  },
+                  "property-type": "data-constant"
+                },
+                "text-ignore-placement": {
+                  type: "boolean",
+                  "default": false,
+                  requires: [
+                    "text-field"
+                  ],
+                  expression: {
+                    interpolated: false,
+                    parameters: [
+                      "zoom"
+                    ]
+                  },
+                  "property-type": "data-constant"
+                },
+                "text-optional": {
+                  type: "boolean",
+                  "default": false,
+                  requires: [
+                    "text-field",
+                    "icon-image"
+                  ],
+                  expression: {
+                    interpolated: false,
+                    parameters: [
+                      "zoom"
+                    ]
+                  },
+                  "property-type": "data-constant"
+                },
+                visibility: {
+                  type: "enum",
+                  values: {
+                    visible: {},
+                    none: {}
+                  },
+                  "default": "visible",
+                  "property-type": "constant"
+                }
+              };
+              var layout_raster = {
+                visibility: {
+                  type: "enum",
+                  values: {
+                    visible: {},
+                    none: {}
+                  },
+                  "default": "visible",
+                  "property-type": "constant"
+                }
+              };
+              var layout_hillshade = {
+                visibility: {
+                  type: "enum",
+                  values: {
+                    visible: {},
+                    none: {}
+                  },
+                  "default": "visible",
+                  "property-type": "constant"
+                }
+              };
+              var filter = {
+                type: "array",
+                value: "*"
+              };
+              var filter_operator = {
+                type: "enum",
+                values: {
+                  "==": {},
+                  "!=": {},
+                  ">": {},
+                  ">=": {},
+                  "<": {},
+                  "<=": {},
+                  "in": {},
+                  "!in": {},
+                  all: {},
+                  any: {},
+                  none: {},
+                  has: {},
+                  "!has": {},
+                  within: {}
+                }
+              };
+              var geometry_type = {
+                type: "enum",
+                values: {
+                  Point: {},
+                  LineString: {},
+                  Polygon: {}
+                }
+              };
+              var function_stop = {
+                type: "array",
+                minimum: 0,
+                maximum: 24,
+                value: [
+                  "number",
+                  "color"
+                ],
+                length: 2
+              };
+              var expression = {
+                type: "array",
+                value: "*",
+                minimum: 1
+              };
+              var light = {
+                anchor: {
+                  type: "enum",
+                  "default": "viewport",
+                  values: {
+                    map: {},
+                    viewport: {}
+                  },
+                  "property-type": "data-constant",
+                  transition: false,
+                  expression: {
+                    interpolated: false,
+                    parameters: [
+                      "zoom"
+                    ]
+                  }
+                },
+                position: {
+                  type: "array",
+                  "default": [
+                    1.15,
+                    210,
+                    30
+                  ],
+                  length: 3,
+                  value: "number",
+                  "property-type": "data-constant",
+                  transition: true,
+                  expression: {
+                    interpolated: true,
+                    parameters: [
+                      "zoom"
+                    ]
+                  }
+                },
+                color: {
+                  type: "color",
+                  "property-type": "data-constant",
+                  "default": "#ffffff",
+                  expression: {
+                    interpolated: true,
+                    parameters: [
+                      "zoom"
+                    ]
+                  },
+                  transition: true
+                },
+                intensity: {
+                  type: "number",
+                  "property-type": "data-constant",
+                  "default": 0.5,
+                  minimum: 0,
+                  maximum: 1,
+                  expression: {
+                    interpolated: true,
+                    parameters: [
+                      "zoom"
+                    ]
+                  },
+                  transition: true
+                }
+              };
+              var paint = [
+                "paint_fill",
+                "paint_line",
+                "paint_circle",
+                "paint_heatmap",
+                "paint_fill-extrusion",
+                "paint_symbol",
+                "paint_raster",
+                "paint_hillshade",
+                "paint_background"
+              ];
+              var paint_fill = {
+                "fill-antialias": {
+                  type: "boolean",
+                  "default": true,
+                  expression: {
+                    interpolated: false,
+                    parameters: [
+                      "zoom"
+                    ]
+                  },
+                  "property-type": "data-constant"
+                },
+                "fill-opacity": {
+                  type: "number",
+                  "default": 1,
+                  minimum: 0,
+                  maximum: 1,
+                  transition: true,
+                  expression: {
+                    interpolated: true,
+                    parameters: [
+                      "zoom",
+                      "feature",
+                      "feature-state"
+                    ]
+                  },
+                  "property-type": "data-driven"
+                },
+                "fill-color": {
+                  type: "color",
+                  "default": "#000000",
+                  transition: true,
+                  requires: [
+                    {
+                      "!": "fill-pattern"
+                    }
+                  ],
+                  expression: {
+                    interpolated: true,
+                    parameters: [
+                      "zoom",
+                      "feature",
+                      "feature-state"
+                    ]
+                  },
+                  "property-type": "data-driven"
+                },
+                "fill-outline-color": {
+                  type: "color",
+                  transition: true,
+                  requires: [
+                    {
+                      "!": "fill-pattern"
+                    },
+                    {
+                      "fill-antialias": true
+                    }
+                  ],
+                  expression: {
+                    interpolated: true,
+                    parameters: [
+                      "zoom",
+                      "feature",
+                      "feature-state"
+                    ]
+                  },
+                  "property-type": "data-driven"
+                },
+                "fill-translate": {
+                  type: "array",
+                  value: "number",
+                  length: 2,
+                  "default": [
+                    0,
+                    0
+                  ],
+                  transition: true,
+                  units: "pixels",
+                  expression: {
+                    interpolated: true,
+                    parameters: [
+                      "zoom"
+                    ]
+                  },
+                  "property-type": "data-constant"
+                },
+                "fill-translate-anchor": {
+                  type: "enum",
+                  values: {
+                    map: {},
+                    viewport: {}
+                  },
+                  "default": "map",
+                  requires: [
+                    "fill-translate"
+                  ],
+                  expression: {
+                    interpolated: false,
+                    parameters: [
+                      "zoom"
+                    ]
+                  },
+                  "property-type": "data-constant"
+                },
+                "fill-pattern": {
+                  type: "resolvedImage",
+                  transition: true,
+                  expression: {
+                    interpolated: false,
+                    parameters: [
+                      "zoom",
+                      "feature"
+                    ]
+                  },
+                  "property-type": "cross-faded-data-driven"
+                }
+              };
+              var paint_line = {
+                "line-opacity": {
+                  type: "number",
+                  "default": 1,
+                  minimum: 0,
+                  maximum: 1,
+                  transition: true,
+                  expression: {
+                    interpolated: true,
+                    parameters: [
+                      "zoom",
+                      "feature",
+                      "feature-state"
+                    ]
+                  },
+                  "property-type": "data-driven"
+                },
+                "line-color": {
+                  type: "color",
+                  "default": "#000000",
+                  transition: true,
+                  requires: [
+                    {
+                      "!": "line-pattern"
+                    }
+                  ],
+                  expression: {
+                    interpolated: true,
+                    parameters: [
+                      "zoom",
+                      "feature",
+                      "feature-state"
+                    ]
+                  },
+                  "property-type": "data-driven"
+                },
+                "line-translate": {
+                  type: "array",
+                  value: "number",
+                  length: 2,
+                  "default": [
+                    0,
+                    0
+                  ],
+                  transition: true,
+                  units: "pixels",
+                  expression: {
+                    interpolated: true,
+                    parameters: [
+                      "zoom"
+                    ]
+                  },
+                  "property-type": "data-constant"
+                },
+                "line-translate-anchor": {
+                  type: "enum",
+                  values: {
+                    map: {},
+                    viewport: {}
+                  },
+                  "default": "map",
+                  requires: [
+                    "line-translate"
+                  ],
+                  expression: {
+                    interpolated: false,
+                    parameters: [
+                      "zoom"
+                    ]
+                  },
+                  "property-type": "data-constant"
+                },
+                "line-width": {
+                  type: "number",
+                  "default": 1,
+                  minimum: 0,
+                  transition: true,
+                  units: "pixels",
+                  expression: {
+                    interpolated: true,
+                    parameters: [
+                      "zoom",
+                      "feature",
+                      "feature-state"
+                    ]
+                  },
+                  "property-type": "data-driven"
+                },
+                "line-gap-width": {
+                  type: "number",
+                  "default": 0,
+                  minimum: 0,
+                  transition: true,
+                  units: "pixels",
+                  expression: {
+                    interpolated: true,
+                    parameters: [
+                      "zoom",
+                      "feature",
+                      "feature-state"
+                    ]
+                  },
+                  "property-type": "data-driven"
+                },
+                "line-offset": {
+                  type: "number",
+                  "default": 0,
+                  transition: true,
+                  units: "pixels",
+                  expression: {
+                    interpolated: true,
+                    parameters: [
+                      "zoom",
+                      "feature",
+                      "feature-state"
+                    ]
+                  },
+                  "property-type": "data-driven"
+                },
+                "line-blur": {
+                  type: "number",
+                  "default": 0,
+                  minimum: 0,
+                  transition: true,
+                  units: "pixels",
+                  expression: {
+                    interpolated: true,
+                    parameters: [
+                      "zoom",
+                      "feature",
+                      "feature-state"
+                    ]
+                  },
+                  "property-type": "data-driven"
+                },
+                "line-dasharray": {
+                  type: "array",
+                  value: "number",
+                  minimum: 0,
+                  transition: true,
+                  units: "line widths",
+                  requires: [
+                    {
+                      "!": "line-pattern"
+                    }
+                  ],
+                  expression: {
+                    interpolated: false,
+                    parameters: [
+                      "zoom"
+                    ]
+                  },
+                  "property-type": "cross-faded"
+                },
+                "line-pattern": {
+                  type: "resolvedImage",
+                  transition: true,
+                  expression: {
+                    interpolated: false,
+                    parameters: [
+                      "zoom",
+                      "feature"
+                    ]
+                  },
+                  "property-type": "cross-faded-data-driven"
+                },
+                "line-gradient": {
+                  type: "color",
+                  transition: false,
+                  requires: [
+                    {
+                      "!": "line-dasharray"
+                    },
+                    {
+                      "!": "line-pattern"
+                    },
+                    {
+                      source: "geojson",
+                      has: {
+                        lineMetrics: true
+                      }
+                    }
+                  ],
+                  expression: {
+                    interpolated: true,
+                    parameters: [
+                      "line-progress"
+                    ]
+                  },
+                  "property-type": "color-ramp"
+                }
+              };
+              var paint_circle = {
+                "circle-radius": {
+                  type: "number",
+                  "default": 5,
+                  minimum: 0,
+                  transition: true,
+                  units: "pixels",
+                  expression: {
+                    interpolated: true,
+                    parameters: [
+                      "zoom",
+                      "feature",
+                      "feature-state"
+                    ]
+                  },
+                  "property-type": "data-driven"
+                },
+                "circle-color": {
+                  type: "color",
+                  "default": "#000000",
+                  transition: true,
+                  expression: {
+                    interpolated: true,
+                    parameters: [
+                      "zoom",
+                      "feature",
+                      "feature-state"
+                    ]
+                  },
+                  "property-type": "data-driven"
+                },
+                "circle-blur": {
+                  type: "number",
+                  "default": 0,
+                  transition: true,
+                  expression: {
+                    interpolated: true,
+                    parameters: [
+                      "zoom",
+                      "feature",
+                      "feature-state"
+                    ]
+                  },
+                  "property-type": "data-driven"
+                },
+                "circle-opacity": {
+                  type: "number",
+                  "default": 1,
+                  minimum: 0,
+                  maximum: 1,
+                  transition: true,
+                  expression: {
+                    interpolated: true,
+                    parameters: [
+                      "zoom",
+                      "feature",
+                      "feature-state"
+                    ]
+                  },
+                  "property-type": "data-driven"
+                },
+                "circle-translate": {
+                  type: "array",
+                  value: "number",
+                  length: 2,
+                  "default": [
+                    0,
+                    0
+                  ],
+                  transition: true,
+                  units: "pixels",
+                  expression: {
+                    interpolated: true,
+                    parameters: [
+                      "zoom"
+                    ]
+                  },
+                  "property-type": "data-constant"
+                },
+                "circle-translate-anchor": {
+                  type: "enum",
+                  values: {
+                    map: {},
+                    viewport: {}
+                  },
+                  "default": "map",
+                  requires: [
+                    "circle-translate"
+                  ],
+                  expression: {
+                    interpolated: false,
+                    parameters: [
+                      "zoom"
+                    ]
+                  },
+                  "property-type": "data-constant"
+                },
+                "circle-pitch-scale": {
+                  type: "enum",
+                  values: {
+                    map: {},
+                    viewport: {}
+                  },
+                  "default": "map",
+                  expression: {
+                    interpolated: false,
+                    parameters: [
+                      "zoom"
+                    ]
+                  },
+                  "property-type": "data-constant"
+                },
+                "circle-pitch-alignment": {
+                  type: "enum",
+                  values: {
+                    map: {},
+                    viewport: {}
+                  },
+                  "default": "viewport",
+                  expression: {
+                    interpolated: false,
+                    parameters: [
+                      "zoom"
+                    ]
+                  },
+                  "property-type": "data-constant"
+                },
+                "circle-stroke-width": {
+                  type: "number",
+                  "default": 0,
+                  minimum: 0,
+                  transition: true,
+                  units: "pixels",
+                  expression: {
+                    interpolated: true,
+                    parameters: [
+                      "zoom",
+                      "feature",
+                      "feature-state"
+                    ]
+                  },
+                  "property-type": "data-driven"
+                },
+                "circle-stroke-color": {
+                  type: "color",
+                  "default": "#000000",
+                  transition: true,
+                  expression: {
+                    interpolated: true,
+                    parameters: [
+                      "zoom",
+                      "feature",
+                      "feature-state"
+                    ]
+                  },
+                  "property-type": "data-driven"
+                },
+                "circle-stroke-opacity": {
+                  type: "number",
+                  "default": 1,
+                  minimum: 0,
+                  maximum: 1,
+                  transition: true,
+                  expression: {
+                    interpolated: true,
+                    parameters: [
+                      "zoom",
+                      "feature",
+                      "feature-state"
+                    ]
+                  },
+                  "property-type": "data-driven"
+                }
+              };
+              var paint_heatmap = {
+                "heatmap-radius": {
+                  type: "number",
+                  "default": 30,
+                  minimum: 1,
+                  transition: true,
+                  units: "pixels",
+                  expression: {
+                    interpolated: true,
+                    parameters: [
+                      "zoom",
+                      "feature",
+                      "feature-state"
+                    ]
+                  },
+                  "property-type": "data-driven"
+                },
+                "heatmap-weight": {
+                  type: "number",
+                  "default": 1,
+                  minimum: 0,
+                  transition: false,
+                  expression: {
+                    interpolated: true,
+                    parameters: [
+                      "zoom",
+                      "feature",
+                      "feature-state"
+                    ]
+                  },
+                  "property-type": "data-driven"
+                },
+                "heatmap-intensity": {
+                  type: "number",
+                  "default": 1,
+                  minimum: 0,
+                  transition: true,
+                  expression: {
+                    interpolated: true,
+                    parameters: [
+                      "zoom"
+                    ]
+                  },
+                  "property-type": "data-constant"
+                },
+                "heatmap-color": {
+                  type: "color",
+                  "default": [
+                    "interpolate",
+                    [
+                      "linear"
+                    ],
+                    [
+                      "heatmap-density"
+                    ],
+                    0,
+                    "rgba(0, 0, 255, 0)",
+                    0.1,
+                    "royalblue",
+                    0.3,
+                    "cyan",
+                    0.5,
+                    "lime",
+                    0.7,
+                    "yellow",
+                    1,
+                    "red"
+                  ],
+                  transition: false,
+                  expression: {
+                    interpolated: true,
+                    parameters: [
+                      "heatmap-density"
+                    ]
+                  },
+                  "property-type": "color-ramp"
+                },
+                "heatmap-opacity": {
+                  type: "number",
+                  "default": 1,
+                  minimum: 0,
+                  maximum: 1,
+                  transition: true,
+                  expression: {
+                    interpolated: true,
+                    parameters: [
+                      "zoom"
+                    ]
+                  },
+                  "property-type": "data-constant"
+                }
+              };
+              var paint_symbol = {
+                "icon-opacity": {
+                  type: "number",
+                  "default": 1,
+                  minimum: 0,
+                  maximum: 1,
+                  transition: true,
+                  requires: [
+                    "icon-image"
+                  ],
+                  expression: {
+                    interpolated: true,
+                    parameters: [
+                      "zoom",
+                      "feature",
+                      "feature-state"
+                    ]
+                  },
+                  "property-type": "data-driven"
+                },
+                "icon-color": {
+                  type: "color",
+                  "default": "#000000",
+                  transition: true,
+                  requires: [
+                    "icon-image"
+                  ],
+                  expression: {
+                    interpolated: true,
+                    parameters: [
+                      "zoom",
+                      "feature",
+                      "feature-state"
+                    ]
+                  },
+                  "property-type": "data-driven"
+                },
+                "icon-halo-color": {
+                  type: "color",
+                  "default": "rgba(0, 0, 0, 0)",
+                  transition: true,
+                  requires: [
+                    "icon-image"
+                  ],
+                  expression: {
+                    interpolated: true,
+                    parameters: [
+                      "zoom",
+                      "feature",
+                      "feature-state"
+                    ]
+                  },
+                  "property-type": "data-driven"
+                },
+                "icon-halo-width": {
+                  type: "number",
+                  "default": 0,
+                  minimum: 0,
+                  transition: true,
+                  units: "pixels",
+                  requires: [
+                    "icon-image"
+                  ],
+                  expression: {
+                    interpolated: true,
+                    parameters: [
+                      "zoom",
+                      "feature",
+                      "feature-state"
+                    ]
+                  },
+                  "property-type": "data-driven"
+                },
+                "icon-halo-blur": {
+                  type: "number",
+                  "default": 0,
+                  minimum: 0,
+                  transition: true,
+                  units: "pixels",
+                  requires: [
+                    "icon-image"
+                  ],
+                  expression: {
+                    interpolated: true,
+                    parameters: [
+                      "zoom",
+                      "feature",
+                      "feature-state"
+                    ]
+                  },
+                  "property-type": "data-driven"
+                },
+                "icon-translate": {
+                  type: "array",
+                  value: "number",
+                  length: 2,
+                  "default": [
+                    0,
+                    0
+                  ],
+                  transition: true,
+                  units: "pixels",
+                  requires: [
+                    "icon-image"
+                  ],
+                  expression: {
+                    interpolated: true,
+                    parameters: [
+                      "zoom"
+                    ]
+                  },
+                  "property-type": "data-constant"
+                },
+                "icon-translate-anchor": {
+                  type: "enum",
+                  values: {
+                    map: {},
+                    viewport: {}
+                  },
+                  "default": "map",
+                  requires: [
+                    "icon-image",
+                    "icon-translate"
+                  ],
+                  expression: {
+                    interpolated: false,
+                    parameters: [
+                      "zoom"
+                    ]
+                  },
+                  "property-type": "data-constant"
+                },
+                "text-opacity": {
+                  type: "number",
+                  "default": 1,
+                  minimum: 0,
+                  maximum: 1,
+                  transition: true,
+                  requires: [
+                    "text-field"
+                  ],
+                  expression: {
+                    interpolated: true,
+                    parameters: [
+                      "zoom",
+                      "feature",
+                      "feature-state"
+                    ]
+                  },
+                  "property-type": "data-driven"
+                },
+                "text-color": {
+                  type: "color",
+                  "default": "#000000",
+                  transition: true,
+                  overridable: true,
+                  requires: [
+                    "text-field"
+                  ],
+                  expression: {
+                    interpolated: true,
+                    parameters: [
+                      "zoom",
+                      "feature",
+                      "feature-state"
+                    ]
+                  },
+                  "property-type": "data-driven"
+                },
+                "text-halo-color": {
+                  type: "color",
+                  "default": "rgba(0, 0, 0, 0)",
+                  transition: true,
+                  requires: [
+                    "text-field"
+                  ],
+                  expression: {
+                    interpolated: true,
+                    parameters: [
+                      "zoom",
+                      "feature",
+                      "feature-state"
+                    ]
+                  },
+                  "property-type": "data-driven"
+                },
+                "text-halo-width": {
+                  type: "number",
+                  "default": 0,
+                  minimum: 0,
+                  transition: true,
+                  units: "pixels",
+                  requires: [
+                    "text-field"
+                  ],
+                  expression: {
+                    interpolated: true,
+                    parameters: [
+                      "zoom",
+                      "feature",
+                      "feature-state"
+                    ]
+                  },
+                  "property-type": "data-driven"
+                },
+                "text-halo-blur": {
+                  type: "number",
+                  "default": 0,
+                  minimum: 0,
+                  transition: true,
+                  units: "pixels",
+                  requires: [
+                    "text-field"
+                  ],
+                  expression: {
+                    interpolated: true,
+                    parameters: [
+                      "zoom",
+                      "feature",
+                      "feature-state"
+                    ]
+                  },
+                  "property-type": "data-driven"
+                },
+                "text-translate": {
+                  type: "array",
+                  value: "number",
+                  length: 2,
+                  "default": [
+                    0,
+                    0
+                  ],
+                  transition: true,
+                  units: "pixels",
+                  requires: [
+                    "text-field"
+                  ],
+                  expression: {
+                    interpolated: true,
+                    parameters: [
+                      "zoom"
+                    ]
+                  },
+                  "property-type": "data-constant"
+                },
+                "text-translate-anchor": {
+                  type: "enum",
+                  values: {
+                    map: {},
+                    viewport: {}
+                  },
+                  "default": "map",
+                  requires: [
+                    "text-field",
+                    "text-translate"
+                  ],
+                  expression: {
+                    interpolated: false,
+                    parameters: [
+                      "zoom"
+                    ]
+                  },
+                  "property-type": "data-constant"
+                }
+              };
+              var paint_raster = {
+                "raster-opacity": {
+                  type: "number",
+                  "default": 1,
+                  minimum: 0,
+                  maximum: 1,
+                  transition: true,
+                  expression: {
+                    interpolated: true,
+                    parameters: [
+                      "zoom"
+                    ]
+                  },
+                  "property-type": "data-constant"
+                },
+                "raster-hue-rotate": {
+                  type: "number",
+                  "default": 0,
+                  period: 360,
+                  transition: true,
+                  units: "degrees",
+                  expression: {
+                    interpolated: true,
+                    parameters: [
+                      "zoom"
+                    ]
+                  },
+                  "property-type": "data-constant"
+                },
+                "raster-brightness-min": {
+                  type: "number",
+                  "default": 0,
+                  minimum: 0,
+                  maximum: 1,
+                  transition: true,
+                  expression: {
+                    interpolated: true,
+                    parameters: [
+                      "zoom"
+                    ]
+                  },
+                  "property-type": "data-constant"
+                },
+                "raster-brightness-max": {
+                  type: "number",
+                  "default": 1,
+                  minimum: 0,
+                  maximum: 1,
+                  transition: true,
+                  expression: {
+                    interpolated: true,
+                    parameters: [
+                      "zoom"
+                    ]
+                  },
+                  "property-type": "data-constant"
+                },
+                "raster-saturation": {
+                  type: "number",
+                  "default": 0,
+                  minimum: -1,
+                  maximum: 1,
+                  transition: true,
+                  expression: {
+                    interpolated: true,
+                    parameters: [
+                      "zoom"
+                    ]
+                  },
+                  "property-type": "data-constant"
+                },
+                "raster-contrast": {
+                  type: "number",
+                  "default": 0,
+                  minimum: -1,
+                  maximum: 1,
+                  transition: true,
+                  expression: {
+                    interpolated: true,
+                    parameters: [
+                      "zoom"
+                    ]
+                  },
+                  "property-type": "data-constant"
+                },
+                "raster-resampling": {
+                  type: "enum",
+                  values: {
+                    linear: {},
+                    nearest: {}
+                  },
+                  "default": "linear",
+                  expression: {
+                    interpolated: false,
+                    parameters: [
+                      "zoom"
+                    ]
+                  },
+                  "property-type": "data-constant"
+                },
+                "raster-fade-duration": {
+                  type: "number",
+                  "default": 300,
+                  minimum: 0,
+                  transition: false,
+                  units: "milliseconds",
+                  expression: {
+                    interpolated: true,
+                    parameters: [
+                      "zoom"
+                    ]
+                  },
+                  "property-type": "data-constant"
+                }
+              };
+              var paint_hillshade = {
+                "hillshade-illumination-direction": {
+                  type: "number",
+                  "default": 335,
+                  minimum: 0,
+                  maximum: 359,
+                  transition: false,
+                  expression: {
+                    interpolated: true,
+                    parameters: [
+                      "zoom"
+                    ]
+                  },
+                  "property-type": "data-constant"
+                },
+                "hillshade-illumination-anchor": {
+                  type: "enum",
+                  values: {
+                    map: {},
+                    viewport: {}
+                  },
+                  "default": "viewport",
+                  expression: {
+                    interpolated: false,
+                    parameters: [
+                      "zoom"
+                    ]
+                  },
+                  "property-type": "data-constant"
+                },
+                "hillshade-exaggeration": {
+                  type: "number",
+                  "default": 0.5,
+                  minimum: 0,
+                  maximum: 1,
+                  transition: true,
+                  expression: {
+                    interpolated: true,
+                    parameters: [
+                      "zoom"
+                    ]
+                  },
+                  "property-type": "data-constant"
+                },
+                "hillshade-shadow-color": {
+                  type: "color",
+                  "default": "#000000",
+                  transition: true,
+                  expression: {
+                    interpolated: true,
+                    parameters: [
+                      "zoom"
+                    ]
+                  },
+                  "property-type": "data-constant"
+                },
+                "hillshade-highlight-color": {
+                  type: "color",
+                  "default": "#FFFFFF",
+                  transition: true,
+                  expression: {
+                    interpolated: true,
+                    parameters: [
+                      "zoom"
+                    ]
+                  },
+                  "property-type": "data-constant"
+                },
+                "hillshade-accent-color": {
+                  type: "color",
+                  "default": "#000000",
+                  transition: true,
+                  expression: {
+                    interpolated: true,
+                    parameters: [
+                      "zoom"
+                    ]
+                  },
+                  "property-type": "data-constant"
+                }
+              };
+              var paint_background = {
+                "background-color": {
+                  type: "color",
+                  "default": "#000000",
+                  transition: true,
+                  requires: [
+                    {
+                      "!": "background-pattern"
+                    }
+                  ],
+                  expression: {
+                    interpolated: true,
+                    parameters: [
+                      "zoom"
+                    ]
+                  },
+                  "property-type": "data-constant"
+                },
+                "background-pattern": {
+                  type: "resolvedImage",
+                  transition: true,
+                  expression: {
+                    interpolated: false,
+                    parameters: [
+                      "zoom"
+                    ]
+                  },
+                  "property-type": "cross-faded"
+                },
+                "background-opacity": {
+                  type: "number",
+                  "default": 1,
+                  minimum: 0,
+                  maximum: 1,
+                  transition: true,
+                  expression: {
+                    interpolated: true,
+                    parameters: [
+                      "zoom"
+                    ]
+                  },
+                  "property-type": "data-constant"
+                }
+              };
+              var transition = {
+                duration: {
+                  type: "number",
+                  "default": 300,
+                  minimum: 0,
+                  units: "milliseconds"
+                },
+                delay: {
+                  type: "number",
+                  "default": 0,
+                  minimum: 0,
+                  units: "milliseconds"
+                }
+              };
+              var promoteId = {
+                "*": {
+                  type: "string"
+                }
+              };
+              var spec = {
+                $version,
+                $root,
+                sources,
+                source: source2,
+                source_vector,
+                source_raster,
+                source_raster_dem,
+                source_geojson,
+                source_video,
+                source_image,
+                layer,
+                layout,
+                layout_background,
+                layout_fill,
+                layout_circle,
+                layout_heatmap,
+                "layout_fill-extrusion": {
+                  visibility: {
+                    type: "enum",
+                    values: {
+                      visible: {},
+                      none: {}
+                    },
+                    "default": "visible",
+                    "property-type": "constant"
+                  }
+                },
+                layout_line,
+                layout_symbol,
+                layout_raster,
+                layout_hillshade,
+                filter,
+                filter_operator,
+                geometry_type,
+                "function": {
+                  expression: {
+                    type: "expression"
+                  },
+                  stops: {
+                    type: "array",
+                    value: "function_stop"
+                  },
+                  base: {
+                    type: "number",
+                    "default": 1,
+                    minimum: 0
+                  },
+                  property: {
+                    type: "string",
+                    "default": "$zoom"
+                  },
+                  type: {
+                    type: "enum",
+                    values: {
+                      identity: {},
+                      exponential: {},
+                      interval: {},
+                      categorical: {}
+                    },
+                    "default": "exponential"
+                  },
+                  colorSpace: {
+                    type: "enum",
+                    values: {
+                      rgb: {},
+                      lab: {},
+                      hcl: {}
+                    },
+                    "default": "rgb"
+                  },
+                  "default": {
+                    type: "*",
+                    required: false
+                  }
+                },
+                function_stop,
+                expression,
+                light,
+                paint,
+                paint_fill,
+                "paint_fill-extrusion": {
+                  "fill-extrusion-opacity": {
+                    type: "number",
+                    "default": 1,
+                    minimum: 0,
+                    maximum: 1,
+                    transition: true,
+                    expression: {
+                      interpolated: true,
+                      parameters: [
+                        "zoom"
+                      ]
+                    },
+                    "property-type": "data-constant"
+                  },
+                  "fill-extrusion-color": {
+                    type: "color",
+                    "default": "#000000",
+                    transition: true,
+                    requires: [
+                      {
+                        "!": "fill-extrusion-pattern"
+                      }
+                    ],
+                    expression: {
+                      interpolated: true,
+                      parameters: [
+                        "zoom",
+                        "feature",
+                        "feature-state"
+                      ]
+                    },
+                    "property-type": "data-driven"
+                  },
+                  "fill-extrusion-translate": {
+                    type: "array",
+                    value: "number",
+                    length: 2,
+                    "default": [
+                      0,
+                      0
+                    ],
+                    transition: true,
+                    units: "pixels",
+                    expression: {
+                      interpolated: true,
+                      parameters: [
+                        "zoom"
+                      ]
+                    },
+                    "property-type": "data-constant"
+                  },
+                  "fill-extrusion-translate-anchor": {
+                    type: "enum",
+                    values: {
+                      map: {},
+                      viewport: {}
+                    },
+                    "default": "map",
+                    requires: [
+                      "fill-extrusion-translate"
+                    ],
+                    expression: {
+                      interpolated: false,
+                      parameters: [
+                        "zoom"
+                      ]
+                    },
+                    "property-type": "data-constant"
+                  },
+                  "fill-extrusion-pattern": {
+                    type: "resolvedImage",
+                    transition: true,
+                    expression: {
+                      interpolated: false,
+                      parameters: [
+                        "zoom",
+                        "feature"
+                      ]
+                    },
+                    "property-type": "cross-faded-data-driven"
+                  },
+                  "fill-extrusion-height": {
+                    type: "number",
+                    "default": 0,
+                    minimum: 0,
+                    units: "meters",
+                    transition: true,
+                    expression: {
+                      interpolated: true,
+                      parameters: [
+                        "zoom",
+                        "feature",
+                        "feature-state"
+                      ]
+                    },
+                    "property-type": "data-driven"
+                  },
+                  "fill-extrusion-base": {
+                    type: "number",
+                    "default": 0,
+                    minimum: 0,
+                    units: "meters",
+                    transition: true,
+                    requires: [
+                      "fill-extrusion-height"
+                    ],
+                    expression: {
+                      interpolated: true,
+                      parameters: [
+                        "zoom",
+                        "feature",
+                        "feature-state"
+                      ]
+                    },
+                    "property-type": "data-driven"
+                  },
+                  "fill-extrusion-vertical-gradient": {
+                    type: "boolean",
+                    "default": true,
+                    transition: false,
+                    expression: {
+                      interpolated: false,
+                      parameters: [
+                        "zoom"
+                      ]
+                    },
+                    "property-type": "data-constant"
+                  }
+                },
+                paint_line,
+                paint_circle,
+                paint_heatmap,
+                paint_symbol,
+                paint_raster,
+                paint_hillshade,
+                paint_background,
+                transition,
+                "property-type": {
+                  "data-driven": {
+                    type: "property-type"
+                  },
+                  "cross-faded": {
+                    type: "property-type"
+                  },
+                  "cross-faded-data-driven": {
+                    type: "property-type"
+                  },
+                  "color-ramp": {
+                    type: "property-type"
+                  },
+                  "data-constant": {
+                    type: "property-type"
+                  },
+                  constant: {
+                    type: "property-type"
+                  }
+                },
+                promoteId
+              };
+              var ValidationError = function ValidationError2(key, value, message2, identifier) {
+                this.message = (key ? key + ": " : "") + message2;
+                if (identifier) {
+                  this.identifier = identifier;
+                }
+                if (value !== null && value !== void 0 && value.__line__) {
+                  this.line = value.__line__;
+                }
+              };
+              function validateConstants(options) {
+                var key = options.key;
+                var constants = options.value;
+                if (constants) {
+                  return [new ValidationError(key, constants, "constants have been deprecated as of v8")];
+                } else {
+                  return [];
+                }
+              }
+              function extend$1(output) {
+                var inputs = [], len2 = arguments.length - 1;
+                while (len2-- > 0)
+                  inputs[len2] = arguments[len2 + 1];
+                for (var i2 = 0, list = inputs; i2 < list.length; i2 += 1) {
+                  var input = list[i2];
+                  for (var k2 in input) {
+                    output[k2] = input[k2];
+                  }
+                }
+                return output;
+              }
+              function unbundle(value) {
+                if (value instanceof Number || value instanceof String || value instanceof Boolean) {
+                  return value.valueOf();
+                } else {
+                  return value;
+                }
+              }
+              function deepUnbundle(value) {
+                if (Array.isArray(value)) {
+                  return value.map(deepUnbundle);
+                } else if (value instanceof Object && !(value instanceof Number || value instanceof String || value instanceof Boolean)) {
+                  var unbundledValue = {};
+                  for (var key in value) {
+                    unbundledValue[key] = deepUnbundle(value[key]);
+                  }
+                  return unbundledValue;
+                }
+                return unbundle(value);
+              }
+              var ParsingError = function(Error2) {
+                function ParsingError2(key, message2) {
+                  Error2.call(this, message2);
+                  this.message = message2;
+                  this.key = key;
+                }
+                if (Error2)
+                  ParsingError2.__proto__ = Error2;
+                ParsingError2.prototype = Object.create(Error2 && Error2.prototype);
+                ParsingError2.prototype.constructor = ParsingError2;
+                return ParsingError2;
+              }(Error);
+              var Scope = function Scope2(parent, bindings) {
+                if (bindings === void 0)
+                  bindings = [];
+                this.parent = parent;
+                this.bindings = {};
+                for (var i2 = 0, list = bindings; i2 < list.length; i2 += 1) {
+                  var ref = list[i2];
+                  var name3 = ref[0];
+                  var expression2 = ref[1];
+                  this.bindings[name3] = expression2;
+                }
+              };
+              Scope.prototype.concat = function concat(bindings) {
+                return new Scope(this, bindings);
+              };
+              Scope.prototype.get = function get2(name3) {
+                if (this.bindings[name3]) {
+                  return this.bindings[name3];
+                }
+                if (this.parent) {
+                  return this.parent.get(name3);
+                }
+                throw new Error(name3 + " not found in scope.");
+              };
+              Scope.prototype.has = function has2(name3) {
+                if (this.bindings[name3]) {
+                  return true;
+                }
+                return this.parent ? this.parent.has(name3) : false;
+              };
+              var NullType = { kind: "null" };
+              var NumberType = { kind: "number" };
+              var StringType = { kind: "string" };
+              var BooleanType = { kind: "boolean" };
+              var ColorType = { kind: "color" };
+              var ObjectType = { kind: "object" };
+              var ValueType = { kind: "value" };
+              var ErrorType = { kind: "error" };
+              var CollatorType = { kind: "collator" };
+              var FormattedType = { kind: "formatted" };
+              var ResolvedImageType = { kind: "resolvedImage" };
+              function array(itemType, N2) {
+                return {
+                  kind: "array",
+                  itemType,
+                  N: N2
+                };
+              }
+              function toString(type) {
+                if (type.kind === "array") {
+                  var itemType = toString(type.itemType);
+                  return typeof type.N === "number" ? "array<" + itemType + ", " + type.N + ">" : type.itemType.kind === "value" ? "array" : "array<" + itemType + ">";
+                } else {
+                  return type.kind;
+                }
+              }
+              var valueMemberTypes = [
+                NullType,
+                NumberType,
+                StringType,
+                BooleanType,
+                ColorType,
+                FormattedType,
+                ObjectType,
+                array(ValueType),
+                ResolvedImageType
+              ];
+              function checkSubtype(expected, t4) {
+                if (t4.kind === "error") {
+                  return null;
+                } else if (expected.kind === "array") {
+                  if (t4.kind === "array" && (t4.N === 0 && t4.itemType.kind === "value" || !checkSubtype(expected.itemType, t4.itemType)) && (typeof expected.N !== "number" || expected.N === t4.N)) {
+                    return null;
+                  }
+                } else if (expected.kind === t4.kind) {
+                  return null;
+                } else if (expected.kind === "value") {
+                  for (var i2 = 0, list = valueMemberTypes; i2 < list.length; i2 += 1) {
+                    var memberType = list[i2];
+                    if (!checkSubtype(memberType, t4)) {
+                      return null;
+                    }
+                  }
+                }
+                return "Expected " + toString(expected) + " but found " + toString(t4) + " instead.";
+              }
+              function isValidType(provided, allowedTypes) {
+                return allowedTypes.some(function(t4) {
+                  return t4.kind === provided.kind;
+                });
+              }
+              function isValidNativeType(provided, allowedTypes) {
+                return allowedTypes.some(function(t4) {
+                  if (t4 === "null") {
+                    return provided === null;
+                  } else if (t4 === "array") {
+                    return Array.isArray(provided);
+                  } else if (t4 === "object") {
+                    return provided && !Array.isArray(provided) && typeof provided === "object";
+                  } else {
+                    return t4 === typeof provided;
+                  }
+                });
+              }
+              var csscolorparser = createCommonjsModule(function(module22, exports3) {
+                var kCSSColorTable = {
+                  "transparent": [
+                    0,
+                    0,
+                    0,
+                    0
+                  ],
+                  "aliceblue": [
+                    240,
+                    248,
+                    255,
+                    1
+                  ],
+                  "antiquewhite": [
+                    250,
+                    235,
+                    215,
+                    1
+                  ],
+                  "aqua": [
+                    0,
+                    255,
+                    255,
+                    1
+                  ],
+                  "aquamarine": [
+                    127,
+                    255,
+                    212,
+                    1
+                  ],
+                  "azure": [
+                    240,
+                    255,
+                    255,
+                    1
+                  ],
+                  "beige": [
+                    245,
+                    245,
+                    220,
+                    1
+                  ],
+                  "bisque": [
+                    255,
+                    228,
+                    196,
+                    1
+                  ],
+                  "black": [
+                    0,
+                    0,
+                    0,
+                    1
+                  ],
+                  "blanchedalmond": [
+                    255,
+                    235,
+                    205,
+                    1
+                  ],
+                  "blue": [
+                    0,
+                    0,
+                    255,
+                    1
+                  ],
+                  "blueviolet": [
+                    138,
+                    43,
+                    226,
+                    1
+                  ],
+                  "brown": [
+                    165,
+                    42,
+                    42,
+                    1
+                  ],
+                  "burlywood": [
+                    222,
+                    184,
+                    135,
+                    1
+                  ],
+                  "cadetblue": [
+                    95,
+                    158,
+                    160,
+                    1
+                  ],
+                  "chartreuse": [
+                    127,
+                    255,
+                    0,
+                    1
+                  ],
+                  "chocolate": [
+                    210,
+                    105,
+                    30,
+                    1
+                  ],
+                  "coral": [
+                    255,
+                    127,
+                    80,
+                    1
+                  ],
+                  "cornflowerblue": [
+                    100,
+                    149,
+                    237,
+                    1
+                  ],
+                  "cornsilk": [
+                    255,
+                    248,
+                    220,
+                    1
+                  ],
+                  "crimson": [
+                    220,
+                    20,
+                    60,
+                    1
+                  ],
+                  "cyan": [
+                    0,
+                    255,
+                    255,
+                    1
+                  ],
+                  "darkblue": [
+                    0,
+                    0,
+                    139,
+                    1
+                  ],
+                  "darkcyan": [
+                    0,
+                    139,
+                    139,
+                    1
+                  ],
+                  "darkgoldenrod": [
+                    184,
+                    134,
+                    11,
+                    1
+                  ],
+                  "darkgray": [
+                    169,
+                    169,
+                    169,
+                    1
+                  ],
+                  "darkgreen": [
+                    0,
+                    100,
+                    0,
+                    1
+                  ],
+                  "darkgrey": [
+                    169,
+                    169,
+                    169,
+                    1
+                  ],
+                  "darkkhaki": [
+                    189,
+                    183,
+                    107,
+                    1
+                  ],
+                  "darkmagenta": [
+                    139,
+                    0,
+                    139,
+                    1
+                  ],
+                  "darkolivegreen": [
+                    85,
+                    107,
+                    47,
+                    1
+                  ],
+                  "darkorange": [
+                    255,
+                    140,
+                    0,
+                    1
+                  ],
+                  "darkorchid": [
+                    153,
+                    50,
+                    204,
+                    1
+                  ],
+                  "darkred": [
+                    139,
+                    0,
+                    0,
+                    1
+                  ],
+                  "darksalmon": [
+                    233,
+                    150,
+                    122,
+                    1
+                  ],
+                  "darkseagreen": [
+                    143,
+                    188,
+                    143,
+                    1
+                  ],
+                  "darkslateblue": [
+                    72,
+                    61,
+                    139,
+                    1
+                  ],
+                  "darkslategray": [
+                    47,
+                    79,
+                    79,
+                    1
+                  ],
+                  "darkslategrey": [
+                    47,
+                    79,
+                    79,
+                    1
+                  ],
+                  "darkturquoise": [
+                    0,
+                    206,
+                    209,
+                    1
+                  ],
+                  "darkviolet": [
+                    148,
+                    0,
+                    211,
+                    1
+                  ],
+                  "deeppink": [
+                    255,
+                    20,
+                    147,
+                    1
+                  ],
+                  "deepskyblue": [
+                    0,
+                    191,
+                    255,
+                    1
+                  ],
+                  "dimgray": [
+                    105,
+                    105,
+                    105,
+                    1
+                  ],
+                  "dimgrey": [
+                    105,
+                    105,
+                    105,
+                    1
+                  ],
+                  "dodgerblue": [
+                    30,
+                    144,
+                    255,
+                    1
+                  ],
+                  "firebrick": [
+                    178,
+                    34,
+                    34,
+                    1
+                  ],
+                  "floralwhite": [
+                    255,
+                    250,
+                    240,
+                    1
+                  ],
+                  "forestgreen": [
+                    34,
+                    139,
+                    34,
+                    1
+                  ],
+                  "fuchsia": [
+                    255,
+                    0,
+                    255,
+                    1
+                  ],
+                  "gainsboro": [
+                    220,
+                    220,
+                    220,
+                    1
+                  ],
+                  "ghostwhite": [
+                    248,
+                    248,
+                    255,
+                    1
+                  ],
+                  "gold": [
+                    255,
+                    215,
+                    0,
+                    1
+                  ],
+                  "goldenrod": [
+                    218,
+                    165,
+                    32,
+                    1
+                  ],
+                  "gray": [
+                    128,
+                    128,
+                    128,
+                    1
+                  ],
+                  "green": [
+                    0,
+                    128,
+                    0,
+                    1
+                  ],
+                  "greenyellow": [
+                    173,
+                    255,
+                    47,
+                    1
+                  ],
+                  "grey": [
+                    128,
+                    128,
+                    128,
+                    1
+                  ],
+                  "honeydew": [
+                    240,
+                    255,
+                    240,
+                    1
+                  ],
+                  "hotpink": [
+                    255,
+                    105,
+                    180,
+                    1
+                  ],
+                  "indianred": [
+                    205,
+                    92,
+                    92,
+                    1
+                  ],
+                  "indigo": [
+                    75,
+                    0,
+                    130,
+                    1
+                  ],
+                  "ivory": [
+                    255,
+                    255,
+                    240,
+                    1
+                  ],
+                  "khaki": [
+                    240,
+                    230,
+                    140,
+                    1
+                  ],
+                  "lavender": [
+                    230,
+                    230,
+                    250,
+                    1
+                  ],
+                  "lavenderblush": [
+                    255,
+                    240,
+                    245,
+                    1
+                  ],
+                  "lawngreen": [
+                    124,
+                    252,
+                    0,
+                    1
+                  ],
+                  "lemonchiffon": [
+                    255,
+                    250,
+                    205,
+                    1
+                  ],
+                  "lightblue": [
+                    173,
+                    216,
+                    230,
+                    1
+                  ],
+                  "lightcoral": [
+                    240,
+                    128,
+                    128,
+                    1
+                  ],
+                  "lightcyan": [
+                    224,
+                    255,
+                    255,
+                    1
+                  ],
+                  "lightgoldenrodyellow": [
+                    250,
+                    250,
+                    210,
+                    1
+                  ],
+                  "lightgray": [
+                    211,
+                    211,
+                    211,
+                    1
+                  ],
+                  "lightgreen": [
+                    144,
+                    238,
+                    144,
+                    1
+                  ],
+                  "lightgrey": [
+                    211,
+                    211,
+                    211,
+                    1
+                  ],
+                  "lightpink": [
+                    255,
+                    182,
+                    193,
+                    1
+                  ],
+                  "lightsalmon": [
+                    255,
+                    160,
+                    122,
+                    1
+                  ],
+                  "lightseagreen": [
+                    32,
+                    178,
+                    170,
+                    1
+                  ],
+                  "lightskyblue": [
+                    135,
+                    206,
+                    250,
+                    1
+                  ],
+                  "lightslategray": [
+                    119,
+                    136,
+                    153,
+                    1
+                  ],
+                  "lightslategrey": [
+                    119,
+                    136,
+                    153,
+                    1
+                  ],
+                  "lightsteelblue": [
+                    176,
+                    196,
+                    222,
+                    1
+                  ],
+                  "lightyellow": [
+                    255,
+                    255,
+                    224,
+                    1
+                  ],
+                  "lime": [
+                    0,
+                    255,
+                    0,
+                    1
+                  ],
+                  "limegreen": [
+                    50,
+                    205,
+                    50,
+                    1
+                  ],
+                  "linen": [
+                    250,
+                    240,
+                    230,
+                    1
+                  ],
+                  "magenta": [
+                    255,
+                    0,
+                    255,
+                    1
+                  ],
+                  "maroon": [
+                    128,
+                    0,
+                    0,
+                    1
+                  ],
+                  "mediumaquamarine": [
+                    102,
+                    205,
+                    170,
+                    1
+                  ],
+                  "mediumblue": [
+                    0,
+                    0,
+                    205,
+                    1
+                  ],
+                  "mediumorchid": [
+                    186,
+                    85,
+                    211,
+                    1
+                  ],
+                  "mediumpurple": [
+                    147,
+                    112,
+                    219,
+                    1
+                  ],
+                  "mediumseagreen": [
+                    60,
+                    179,
+                    113,
+                    1
+                  ],
+                  "mediumslateblue": [
+                    123,
+                    104,
+                    238,
+                    1
+                  ],
+                  "mediumspringgreen": [
+                    0,
+                    250,
+                    154,
+                    1
+                  ],
+                  "mediumturquoise": [
+                    72,
+                    209,
+                    204,
+                    1
+                  ],
+                  "mediumvioletred": [
+                    199,
+                    21,
+                    133,
+                    1
+                  ],
+                  "midnightblue": [
+                    25,
+                    25,
+                    112,
+                    1
+                  ],
+                  "mintcream": [
+                    245,
+                    255,
+                    250,
+                    1
+                  ],
+                  "mistyrose": [
+                    255,
+                    228,
+                    225,
+                    1
+                  ],
+                  "moccasin": [
+                    255,
+                    228,
+                    181,
+                    1
+                  ],
+                  "navajowhite": [
+                    255,
+                    222,
+                    173,
+                    1
+                  ],
+                  "navy": [
+                    0,
+                    0,
+                    128,
+                    1
+                  ],
+                  "oldlace": [
+                    253,
+                    245,
+                    230,
+                    1
+                  ],
+                  "olive": [
+                    128,
+                    128,
+                    0,
+                    1
+                  ],
+                  "olivedrab": [
+                    107,
+                    142,
+                    35,
+                    1
+                  ],
+                  "orange": [
+                    255,
+                    165,
+                    0,
+                    1
+                  ],
+                  "orangered": [
+                    255,
+                    69,
+                    0,
+                    1
+                  ],
+                  "orchid": [
+                    218,
+                    112,
+                    214,
+                    1
+                  ],
+                  "palegoldenrod": [
+                    238,
+                    232,
+                    170,
+                    1
+                  ],
+                  "palegreen": [
+                    152,
+                    251,
+                    152,
+                    1
+                  ],
+                  "paleturquoise": [
+                    175,
+                    238,
+                    238,
+                    1
+                  ],
+                  "palevioletred": [
+                    219,
+                    112,
+                    147,
+                    1
+                  ],
+                  "papayawhip": [
+                    255,
+                    239,
+                    213,
+                    1
+                  ],
+                  "peachpuff": [
+                    255,
+                    218,
+                    185,
+                    1
+                  ],
+                  "peru": [
+                    205,
+                    133,
+                    63,
+                    1
+                  ],
+                  "pink": [
+                    255,
+                    192,
+                    203,
+                    1
+                  ],
+                  "plum": [
+                    221,
+                    160,
+                    221,
+                    1
+                  ],
+                  "powderblue": [
+                    176,
+                    224,
+                    230,
+                    1
+                  ],
+                  "purple": [
+                    128,
+                    0,
+                    128,
+                    1
+                  ],
+                  "rebeccapurple": [
+                    102,
+                    51,
+                    153,
+                    1
+                  ],
+                  "red": [
+                    255,
+                    0,
+                    0,
+                    1
+                  ],
+                  "rosybrown": [
+                    188,
+                    143,
+                    143,
+                    1
+                  ],
+                  "royalblue": [
+                    65,
+                    105,
+                    225,
+                    1
+                  ],
+                  "saddlebrown": [
+                    139,
+                    69,
+                    19,
+                    1
+                  ],
+                  "salmon": [
+                    250,
+                    128,
+                    114,
+                    1
+                  ],
+                  "sandybrown": [
+                    244,
+                    164,
+                    96,
+                    1
+                  ],
+                  "seagreen": [
+                    46,
+                    139,
+                    87,
+                    1
+                  ],
+                  "seashell": [
+                    255,
+                    245,
+                    238,
+                    1
+                  ],
+                  "sienna": [
+                    160,
+                    82,
+                    45,
+                    1
+                  ],
+                  "silver": [
+                    192,
+                    192,
+                    192,
+                    1
+                  ],
+                  "skyblue": [
+                    135,
+                    206,
+                    235,
+                    1
+                  ],
+                  "slateblue": [
+                    106,
+                    90,
+                    205,
+                    1
+                  ],
+                  "slategray": [
+                    112,
+                    128,
+                    144,
+                    1
+                  ],
+                  "slategrey": [
+                    112,
+                    128,
+                    144,
+                    1
+                  ],
+                  "snow": [
+                    255,
+                    250,
+                    250,
+                    1
+                  ],
+                  "springgreen": [
+                    0,
+                    255,
+                    127,
+                    1
+                  ],
+                  "steelblue": [
+                    70,
+                    130,
+                    180,
+                    1
+                  ],
+                  "tan": [
+                    210,
+                    180,
+                    140,
+                    1
+                  ],
+                  "teal": [
+                    0,
+                    128,
+                    128,
+                    1
+                  ],
+                  "thistle": [
+                    216,
+                    191,
+                    216,
+                    1
+                  ],
+                  "tomato": [
+                    255,
+                    99,
+                    71,
+                    1
+                  ],
+                  "turquoise": [
+                    64,
+                    224,
+                    208,
+                    1
+                  ],
+                  "violet": [
+                    238,
+                    130,
+                    238,
+                    1
+                  ],
+                  "wheat": [
+                    245,
+                    222,
+                    179,
+                    1
+                  ],
+                  "white": [
+                    255,
+                    255,
+                    255,
+                    1
+                  ],
+                  "whitesmoke": [
+                    245,
+                    245,
+                    245,
+                    1
+                  ],
+                  "yellow": [
+                    255,
+                    255,
+                    0,
+                    1
+                  ],
+                  "yellowgreen": [
+                    154,
+                    205,
+                    50,
+                    1
+                  ]
+                };
+                function clamp_css_byte(i2) {
+                  i2 = Math.round(i2);
+                  return i2 < 0 ? 0 : i2 > 255 ? 255 : i2;
+                }
+                function clamp_css_float(f2) {
+                  return f2 < 0 ? 0 : f2 > 1 ? 1 : f2;
+                }
+                function parse_css_int(str) {
+                  if (str[str.length - 1] === "%") {
+                    return clamp_css_byte(parseFloat(str) / 100 * 255);
+                  }
+                  return clamp_css_byte(parseInt(str));
+                }
+                function parse_css_float(str) {
+                  if (str[str.length - 1] === "%") {
+                    return clamp_css_float(parseFloat(str) / 100);
+                  }
+                  return clamp_css_float(parseFloat(str));
+                }
+                function css_hue_to_rgb(m1, m2, h2) {
+                  if (h2 < 0) {
+                    h2 += 1;
+                  } else if (h2 > 1) {
+                    h2 -= 1;
+                  }
+                  if (h2 * 6 < 1) {
+                    return m1 + (m2 - m1) * h2 * 6;
+                  }
+                  if (h2 * 2 < 1) {
+                    return m2;
+                  }
+                  if (h2 * 3 < 2) {
+                    return m1 + (m2 - m1) * (2 / 3 - h2) * 6;
+                  }
+                  return m1;
+                }
+                function parseCSSColor(css_str) {
+                  var str = css_str.replace(/ /g, "").toLowerCase();
+                  if (str in kCSSColorTable) {
+                    return kCSSColorTable[str].slice();
+                  }
+                  if (str[0] === "#") {
+                    if (str.length === 4) {
+                      var iv = parseInt(str.substr(1), 16);
+                      if (!(iv >= 0 && iv <= 4095)) {
+                        return null;
+                      }
+                      return [
+                        (iv & 3840) >> 4 | (iv & 3840) >> 8,
+                        iv & 240 | (iv & 240) >> 4,
+                        iv & 15 | (iv & 15) << 4,
+                        1
+                      ];
+                    } else if (str.length === 7) {
+                      var iv = parseInt(str.substr(1), 16);
+                      if (!(iv >= 0 && iv <= 16777215)) {
+                        return null;
+                      }
+                      return [
+                        (iv & 16711680) >> 16,
+                        (iv & 65280) >> 8,
+                        iv & 255,
+                        1
+                      ];
+                    }
+                    return null;
+                  }
+                  var op = str.indexOf("("), ep = str.indexOf(")");
+                  if (op !== -1 && ep + 1 === str.length) {
+                    var fname = str.substr(0, op);
+                    var params = str.substr(op + 1, ep - (op + 1)).split(",");
+                    var alpha = 1;
+                    switch (fname) {
+                      case "rgba":
+                        if (params.length !== 4) {
+                          return null;
+                        }
+                        alpha = parse_css_float(params.pop());
+                      case "rgb":
+                        if (params.length !== 3) {
+                          return null;
+                        }
+                        return [
+                          parse_css_int(params[0]),
+                          parse_css_int(params[1]),
+                          parse_css_int(params[2]),
+                          alpha
+                        ];
+                      case "hsla":
+                        if (params.length !== 4) {
+                          return null;
+                        }
+                        alpha = parse_css_float(params.pop());
+                      case "hsl":
+                        if (params.length !== 3) {
+                          return null;
+                        }
+                        var h2 = (parseFloat(params[0]) % 360 + 360) % 360 / 360;
+                        var s2 = parse_css_float(params[1]);
+                        var l2 = parse_css_float(params[2]);
+                        var m2 = l2 <= 0.5 ? l2 * (s2 + 1) : l2 + s2 - l2 * s2;
+                        var m1 = l2 * 2 - m2;
+                        return [
+                          clamp_css_byte(css_hue_to_rgb(m1, m2, h2 + 1 / 3) * 255),
+                          clamp_css_byte(css_hue_to_rgb(m1, m2, h2) * 255),
+                          clamp_css_byte(css_hue_to_rgb(m1, m2, h2 - 1 / 3) * 255),
+                          alpha
+                        ];
+                      default:
+                        return null;
+                    }
+                  }
+                  return null;
+                }
+                try {
+                  exports3.parseCSSColor = parseCSSColor;
+                } catch (e2) {
+                }
+              });
+              var csscolorparser_1 = csscolorparser.parseCSSColor;
+              var Color2 = function Color3(r2, g2, b2, a2) {
+                if (a2 === void 0)
+                  a2 = 1;
+                this.r = r2;
+                this.g = g2;
+                this.b = b2;
+                this.a = a2;
+              };
+              Color2.parse = function parse22(input) {
+                if (!input) {
+                  return void 0;
+                }
+                if (input instanceof Color2) {
+                  return input;
+                }
+                if (typeof input !== "string") {
+                  return void 0;
+                }
+                var rgba4 = csscolorparser_1(input);
+                if (!rgba4) {
+                  return void 0;
+                }
+                return new Color2(rgba4[0] / 255 * rgba4[3], rgba4[1] / 255 * rgba4[3], rgba4[2] / 255 * rgba4[3], rgba4[3]);
+              };
+              Color2.prototype.toString = function toString2() {
+                var ref = this.toArray();
+                var r2 = ref[0];
+                var g2 = ref[1];
+                var b2 = ref[2];
+                var a2 = ref[3];
+                return "rgba(" + Math.round(r2) + "," + Math.round(g2) + "," + Math.round(b2) + "," + a2 + ")";
+              };
+              Color2.prototype.toArray = function toArray() {
+                var ref = this;
+                var r2 = ref.r;
+                var g2 = ref.g;
+                var b2 = ref.b;
+                var a2 = ref.a;
+                return a2 === 0 ? [
+                  0,
+                  0,
+                  0,
+                  0
+                ] : [
+                  r2 * 255 / a2,
+                  g2 * 255 / a2,
+                  b2 * 255 / a2,
+                  a2
+                ];
+              };
+              Color2.black = new Color2(0, 0, 0, 1);
+              Color2.white = new Color2(1, 1, 1, 1);
+              Color2.transparent = new Color2(0, 0, 0, 0);
+              Color2.red = new Color2(1, 0, 0, 1);
+              var Collator = function Collator2(caseSensitive, diacriticSensitive, locale) {
+                if (caseSensitive) {
+                  this.sensitivity = diacriticSensitive ? "variant" : "case";
+                } else {
+                  this.sensitivity = diacriticSensitive ? "accent" : "base";
+                }
+                this.locale = locale;
+                this.collator = new Intl.Collator(this.locale ? this.locale : [], {
+                  sensitivity: this.sensitivity,
+                  usage: "search"
+                });
+              };
+              Collator.prototype.compare = function compare2(lhs, rhs) {
+                return this.collator.compare(lhs, rhs);
+              };
+              Collator.prototype.resolvedLocale = function resolvedLocale() {
+                return new Intl.Collator(this.locale ? this.locale : []).resolvedOptions().locale;
+              };
+              var FormattedSection = function FormattedSection2(text, image, scale22, fontStack, textColor) {
+                this.text = text;
+                this.image = image;
+                this.scale = scale22;
+                this.fontStack = fontStack;
+                this.textColor = textColor;
+              };
+              var Formatted = function Formatted2(sections) {
+                this.sections = sections;
+              };
+              Formatted.fromString = function fromString(unformatted) {
+                return new Formatted([new FormattedSection(unformatted, null, null, null, null)]);
+              };
+              Formatted.prototype.isEmpty = function isEmpty2() {
+                if (this.sections.length === 0) {
+                  return true;
+                }
+                return !this.sections.some(function(section) {
+                  return section.text.length !== 0 || section.image && section.image.name.length !== 0;
+                });
+              };
+              Formatted.factory = function factory2(text) {
+                if (text instanceof Formatted) {
+                  return text;
+                } else {
+                  return Formatted.fromString(text);
+                }
+              };
+              Formatted.prototype.toString = function toString2() {
+                if (this.sections.length === 0) {
+                  return "";
+                }
+                return this.sections.map(function(section) {
+                  return section.text;
+                }).join("");
+              };
+              Formatted.prototype.serialize = function serialize2() {
+                var serialized = ["format"];
+                for (var i2 = 0, list = this.sections; i2 < list.length; i2 += 1) {
+                  var section = list[i2];
+                  if (section.image) {
+                    serialized.push([
+                      "image",
+                      section.image.name
+                    ]);
+                    continue;
+                  }
+                  serialized.push(section.text);
+                  var options = {};
+                  if (section.fontStack) {
+                    options["text-font"] = [
+                      "literal",
+                      section.fontStack.split(",")
+                    ];
+                  }
+                  if (section.scale) {
+                    options["font-scale"] = section.scale;
+                  }
+                  if (section.textColor) {
+                    options["text-color"] = ["rgba"].concat(section.textColor.toArray());
+                  }
+                  serialized.push(options);
+                }
+                return serialized;
+              };
+              var ResolvedImage = function ResolvedImage2(options) {
+                this.name = options.name;
+                this.available = options.available;
+              };
+              ResolvedImage.prototype.toString = function toString2() {
+                return this.name;
+              };
+              ResolvedImage.fromString = function fromString(name3) {
+                if (!name3) {
+                  return null;
+                }
+                return new ResolvedImage({
+                  name: name3,
+                  available: false
+                });
+              };
+              ResolvedImage.prototype.serialize = function serialize2() {
+                return [
+                  "image",
+                  this.name
+                ];
+              };
+              function validateRGBA(r2, g2, b2, a2) {
+                if (!(typeof r2 === "number" && r2 >= 0 && r2 <= 255 && typeof g2 === "number" && g2 >= 0 && g2 <= 255 && typeof b2 === "number" && b2 >= 0 && b2 <= 255)) {
+                  var value = typeof a2 === "number" ? [
+                    r2,
+                    g2,
+                    b2,
+                    a2
+                  ] : [
+                    r2,
+                    g2,
+                    b2
+                  ];
+                  return "Invalid rgba value [" + value.join(", ") + "]: 'r', 'g', and 'b' must be between 0 and 255.";
+                }
+                if (!(typeof a2 === "undefined" || typeof a2 === "number" && a2 >= 0 && a2 <= 1)) {
+                  return "Invalid rgba value [" + [
+                    r2,
+                    g2,
+                    b2,
+                    a2
+                  ].join(", ") + "]: 'a' must be between 0 and 1.";
+                }
+                return null;
+              }
+              function isValue(mixed) {
+                if (mixed === null) {
+                  return true;
+                } else if (typeof mixed === "string") {
+                  return true;
+                } else if (typeof mixed === "boolean") {
+                  return true;
+                } else if (typeof mixed === "number") {
+                  return true;
+                } else if (mixed instanceof Color2) {
+                  return true;
+                } else if (mixed instanceof Collator) {
+                  return true;
+                } else if (mixed instanceof Formatted) {
+                  return true;
+                } else if (mixed instanceof ResolvedImage) {
+                  return true;
+                } else if (Array.isArray(mixed)) {
+                  for (var i2 = 0, list = mixed; i2 < list.length; i2 += 1) {
+                    var item = list[i2];
+                    if (!isValue(item)) {
+                      return false;
+                    }
+                  }
+                  return true;
+                } else if (typeof mixed === "object") {
+                  for (var key in mixed) {
+                    if (!isValue(mixed[key])) {
+                      return false;
+                    }
+                  }
+                  return true;
+                } else {
+                  return false;
+                }
+              }
+              function typeOf(value) {
+                if (value === null) {
+                  return NullType;
+                } else if (typeof value === "string") {
+                  return StringType;
+                } else if (typeof value === "boolean") {
+                  return BooleanType;
+                } else if (typeof value === "number") {
+                  return NumberType;
+                } else if (value instanceof Color2) {
+                  return ColorType;
+                } else if (value instanceof Collator) {
+                  return CollatorType;
+                } else if (value instanceof Formatted) {
+                  return FormattedType;
+                } else if (value instanceof ResolvedImage) {
+                  return ResolvedImageType;
+                } else if (Array.isArray(value)) {
+                  var length2 = value.length;
+                  var itemType;
+                  for (var i2 = 0, list = value; i2 < list.length; i2 += 1) {
+                    var item = list[i2];
+                    var t4 = typeOf(item);
+                    if (!itemType) {
+                      itemType = t4;
+                    } else if (itemType === t4) {
+                      continue;
+                    } else {
+                      itemType = ValueType;
+                      break;
+                    }
+                  }
+                  return array(itemType || ValueType, length2);
+                } else {
+                  return ObjectType;
+                }
+              }
+              function toString$1(value) {
+                var type = typeof value;
+                if (value === null) {
+                  return "";
+                } else if (type === "string" || type === "number" || type === "boolean") {
+                  return String(value);
+                } else if (value instanceof Color2 || value instanceof Formatted || value instanceof ResolvedImage) {
+                  return value.toString();
+                } else {
+                  return JSON.stringify(value);
+                }
+              }
+              var Literal = function Literal2(type, value) {
+                this.type = type;
+                this.value = value;
+              };
+              Literal.parse = function parse22(args, context) {
+                if (args.length !== 2) {
+                  return context.error("'literal' expression requires exactly one argument, but found " + (args.length - 1) + " instead.");
+                }
+                if (!isValue(args[1])) {
+                  return context.error("invalid value");
+                }
+                var value = args[1];
+                var type = typeOf(value);
+                var expected = context.expectedType;
+                if (type.kind === "array" && type.N === 0 && expected && expected.kind === "array" && (typeof expected.N !== "number" || expected.N === 0)) {
+                  type = expected;
+                }
+                return new Literal(type, value);
+              };
+              Literal.prototype.evaluate = function evaluate() {
+                return this.value;
+              };
+              Literal.prototype.eachChild = function eachChild() {
+              };
+              Literal.prototype.outputDefined = function outputDefined() {
+                return true;
+              };
+              Literal.prototype.serialize = function serialize2() {
+                if (this.type.kind === "array" || this.type.kind === "object") {
+                  return [
+                    "literal",
+                    this.value
+                  ];
+                } else if (this.value instanceof Color2) {
+                  return ["rgba"].concat(this.value.toArray());
+                } else if (this.value instanceof Formatted) {
+                  return this.value.serialize();
+                } else {
+                  return this.value;
+                }
+              };
+              var RuntimeError = function RuntimeError2(message2) {
+                this.name = "ExpressionEvaluationError";
+                this.message = message2;
+              };
+              RuntimeError.prototype.toJSON = function toJSON() {
+                return this.message;
+              };
+              var types = {
+                string: StringType,
+                number: NumberType,
+                boolean: BooleanType,
+                object: ObjectType
+              };
+              var Assertion = function Assertion2(type, args) {
+                this.type = type;
+                this.args = args;
+              };
+              Assertion.parse = function parse22(args, context) {
+                if (args.length < 2) {
+                  return context.error("Expected at least one argument.");
+                }
+                var i2 = 1;
+                var type;
+                var name3 = args[0];
+                if (name3 === "array") {
+                  var itemType;
+                  if (args.length > 2) {
+                    var type$1 = args[1];
+                    if (typeof type$1 !== "string" || !(type$1 in types) || type$1 === "object") {
+                      return context.error('The item type argument of "array" must be one of string, number, boolean', 1);
+                    }
+                    itemType = types[type$1];
+                    i2++;
+                  } else {
+                    itemType = ValueType;
+                  }
+                  var N2;
+                  if (args.length > 3) {
+                    if (args[2] !== null && (typeof args[2] !== "number" || args[2] < 0 || args[2] !== Math.floor(args[2]))) {
+                      return context.error('The length argument to "array" must be a positive integer literal', 2);
+                    }
+                    N2 = args[2];
+                    i2++;
+                  }
+                  type = array(itemType, N2);
+                } else {
+                  type = types[name3];
+                }
+                var parsed = [];
+                for (; i2 < args.length; i2++) {
+                  var input = context.parse(args[i2], i2, ValueType);
+                  if (!input) {
+                    return null;
+                  }
+                  parsed.push(input);
+                }
+                return new Assertion(type, parsed);
+              };
+              Assertion.prototype.evaluate = function evaluate(ctx2) {
+                for (var i2 = 0; i2 < this.args.length; i2++) {
+                  var value = this.args[i2].evaluate(ctx2);
+                  var error2 = checkSubtype(this.type, typeOf(value));
+                  if (!error2) {
+                    return value;
+                  } else if (i2 === this.args.length - 1) {
+                    throw new RuntimeError("Expected value to be of type " + toString(this.type) + ", but found " + toString(typeOf(value)) + " instead.");
+                  }
+                }
+                return null;
+              };
+              Assertion.prototype.eachChild = function eachChild(fn) {
+                this.args.forEach(fn);
+              };
+              Assertion.prototype.outputDefined = function outputDefined() {
+                return this.args.every(function(arg) {
+                  return arg.outputDefined();
+                });
+              };
+              Assertion.prototype.serialize = function serialize2() {
+                var type = this.type;
+                var serialized = [type.kind];
+                if (type.kind === "array") {
+                  var itemType = type.itemType;
+                  if (itemType.kind === "string" || itemType.kind === "number" || itemType.kind === "boolean") {
+                    serialized.push(itemType.kind);
+                    var N2 = type.N;
+                    if (typeof N2 === "number" || this.args.length > 1) {
+                      serialized.push(N2);
+                    }
+                  }
+                }
+                return serialized.concat(this.args.map(function(arg) {
+                  return arg.serialize();
+                }));
+              };
+              var FormatExpression = function FormatExpression2(sections) {
+                this.type = FormattedType;
+                this.sections = sections;
+              };
+              FormatExpression.parse = function parse22(args, context) {
+                if (args.length < 2) {
+                  return context.error("Expected at least one argument.");
+                }
+                var firstArg = args[1];
+                if (!Array.isArray(firstArg) && typeof firstArg === "object") {
+                  return context.error("First argument must be an image or text section.");
+                }
+                var sections = [];
+                var nextTokenMayBeObject = false;
+                for (var i2 = 1; i2 <= args.length - 1; ++i2) {
+                  var arg = args[i2];
+                  if (nextTokenMayBeObject && typeof arg === "object" && !Array.isArray(arg)) {
+                    nextTokenMayBeObject = false;
+                    var scale22 = null;
+                    if (arg["font-scale"]) {
+                      scale22 = context.parse(arg["font-scale"], 1, NumberType);
+                      if (!scale22) {
+                        return null;
+                      }
+                    }
+                    var font = null;
+                    if (arg["text-font"]) {
+                      font = context.parse(arg["text-font"], 1, array(StringType));
+                      if (!font) {
+                        return null;
+                      }
+                    }
+                    var textColor = null;
+                    if (arg["text-color"]) {
+                      textColor = context.parse(arg["text-color"], 1, ColorType);
+                      if (!textColor) {
+                        return null;
+                      }
+                    }
+                    var lastExpression = sections[sections.length - 1];
+                    lastExpression.scale = scale22;
+                    lastExpression.font = font;
+                    lastExpression.textColor = textColor;
+                  } else {
+                    var content = context.parse(args[i2], 1, ValueType);
+                    if (!content) {
+                      return null;
+                    }
+                    var kind = content.type.kind;
+                    if (kind !== "string" && kind !== "value" && kind !== "null" && kind !== "resolvedImage") {
+                      return context.error("Formatted text type must be 'string', 'value', 'image' or 'null'.");
+                    }
+                    nextTokenMayBeObject = true;
+                    sections.push({
+                      content,
+                      scale: null,
+                      font: null,
+                      textColor: null
+                    });
+                  }
+                }
+                return new FormatExpression(sections);
+              };
+              FormatExpression.prototype.evaluate = function evaluate(ctx2) {
+                var evaluateSection = function(section) {
+                  var evaluatedContent = section.content.evaluate(ctx2);
+                  if (typeOf(evaluatedContent) === ResolvedImageType) {
+                    return new FormattedSection("", evaluatedContent, null, null, null);
+                  }
+                  return new FormattedSection(toString$1(evaluatedContent), null, section.scale ? section.scale.evaluate(ctx2) : null, section.font ? section.font.evaluate(ctx2).join(",") : null, section.textColor ? section.textColor.evaluate(ctx2) : null);
+                };
+                return new Formatted(this.sections.map(evaluateSection));
+              };
+              FormatExpression.prototype.eachChild = function eachChild(fn) {
+                for (var i2 = 0, list = this.sections; i2 < list.length; i2 += 1) {
+                  var section = list[i2];
+                  fn(section.content);
+                  if (section.scale) {
+                    fn(section.scale);
+                  }
+                  if (section.font) {
+                    fn(section.font);
+                  }
+                  if (section.textColor) {
+                    fn(section.textColor);
+                  }
+                }
+              };
+              FormatExpression.prototype.outputDefined = function outputDefined() {
+                return false;
+              };
+              FormatExpression.prototype.serialize = function serialize2() {
+                var serialized = ["format"];
+                for (var i2 = 0, list = this.sections; i2 < list.length; i2 += 1) {
+                  var section = list[i2];
+                  serialized.push(section.content.serialize());
+                  var options = {};
+                  if (section.scale) {
+                    options["font-scale"] = section.scale.serialize();
+                  }
+                  if (section.font) {
+                    options["text-font"] = section.font.serialize();
+                  }
+                  if (section.textColor) {
+                    options["text-color"] = section.textColor.serialize();
+                  }
+                  serialized.push(options);
+                }
+                return serialized;
+              };
+              var ImageExpression = function ImageExpression2(input) {
+                this.type = ResolvedImageType;
+                this.input = input;
+              };
+              ImageExpression.parse = function parse22(args, context) {
+                if (args.length !== 2) {
+                  return context.error("Expected two arguments.");
+                }
+                var name3 = context.parse(args[1], 1, StringType);
+                if (!name3) {
+                  return context.error("No image name provided.");
+                }
+                return new ImageExpression(name3);
+              };
+              ImageExpression.prototype.evaluate = function evaluate(ctx2) {
+                var evaluatedImageName = this.input.evaluate(ctx2);
+                var value = ResolvedImage.fromString(evaluatedImageName);
+                if (value && ctx2.availableImages) {
+                  value.available = ctx2.availableImages.indexOf(evaluatedImageName) > -1;
+                }
+                return value;
+              };
+              ImageExpression.prototype.eachChild = function eachChild(fn) {
+                fn(this.input);
+              };
+              ImageExpression.prototype.outputDefined = function outputDefined() {
+                return false;
+              };
+              ImageExpression.prototype.serialize = function serialize2() {
+                return [
+                  "image",
+                  this.input.serialize()
+                ];
+              };
+              var types$1 = {
+                "to-boolean": BooleanType,
+                "to-color": ColorType,
+                "to-number": NumberType,
+                "to-string": StringType
+              };
+              var Coercion = function Coercion2(type, args) {
+                this.type = type;
+                this.args = args;
+              };
+              Coercion.parse = function parse22(args, context) {
+                if (args.length < 2) {
+                  return context.error("Expected at least one argument.");
+                }
+                var name3 = args[0];
+                if ((name3 === "to-boolean" || name3 === "to-string") && args.length !== 2) {
+                  return context.error("Expected one argument.");
+                }
+                var type = types$1[name3];
+                var parsed = [];
+                for (var i2 = 1; i2 < args.length; i2++) {
+                  var input = context.parse(args[i2], i2, ValueType);
+                  if (!input) {
+                    return null;
+                  }
+                  parsed.push(input);
+                }
+                return new Coercion(type, parsed);
+              };
+              Coercion.prototype.evaluate = function evaluate(ctx2) {
+                if (this.type.kind === "boolean") {
+                  return Boolean(this.args[0].evaluate(ctx2));
+                } else if (this.type.kind === "color") {
+                  var input;
+                  var error2;
+                  for (var i2 = 0, list = this.args; i2 < list.length; i2 += 1) {
+                    var arg = list[i2];
+                    input = arg.evaluate(ctx2);
+                    error2 = null;
+                    if (input instanceof Color2) {
+                      return input;
+                    } else if (typeof input === "string") {
+                      var c2 = ctx2.parseColor(input);
+                      if (c2) {
+                        return c2;
+                      }
+                    } else if (Array.isArray(input)) {
+                      if (input.length < 3 || input.length > 4) {
+                        error2 = "Invalid rbga value " + JSON.stringify(input) + ": expected an array containing either three or four numeric values.";
+                      } else {
+                        error2 = validateRGBA(input[0], input[1], input[2], input[3]);
+                      }
+                      if (!error2) {
+                        return new Color2(input[0] / 255, input[1] / 255, input[2] / 255, input[3]);
+                      }
+                    }
+                  }
+                  throw new RuntimeError(error2 || "Could not parse color from value '" + (typeof input === "string" ? input : String(JSON.stringify(input))) + "'");
+                } else if (this.type.kind === "number") {
+                  var value = null;
+                  for (var i$1 = 0, list$1 = this.args; i$1 < list$1.length; i$1 += 1) {
+                    var arg$1 = list$1[i$1];
+                    value = arg$1.evaluate(ctx2);
+                    if (value === null) {
+                      return 0;
+                    }
+                    var num = Number(value);
+                    if (isNaN(num)) {
+                      continue;
+                    }
+                    return num;
+                  }
+                  throw new RuntimeError("Could not convert " + JSON.stringify(value) + " to number.");
+                } else if (this.type.kind === "formatted") {
+                  return Formatted.fromString(toString$1(this.args[0].evaluate(ctx2)));
+                } else if (this.type.kind === "resolvedImage") {
+                  return ResolvedImage.fromString(toString$1(this.args[0].evaluate(ctx2)));
+                } else {
+                  return toString$1(this.args[0].evaluate(ctx2));
+                }
+              };
+              Coercion.prototype.eachChild = function eachChild(fn) {
+                this.args.forEach(fn);
+              };
+              Coercion.prototype.outputDefined = function outputDefined() {
+                return this.args.every(function(arg) {
+                  return arg.outputDefined();
+                });
+              };
+              Coercion.prototype.serialize = function serialize2() {
+                if (this.type.kind === "formatted") {
+                  return new FormatExpression([{
+                    content: this.args[0],
+                    scale: null,
+                    font: null,
+                    textColor: null
+                  }]).serialize();
+                }
+                if (this.type.kind === "resolvedImage") {
+                  return new ImageExpression(this.args[0]).serialize();
+                }
+                var serialized = ["to-" + this.type.kind];
+                this.eachChild(function(child) {
+                  serialized.push(child.serialize());
+                });
+                return serialized;
+              };
+              var geometryTypes = [
+                "Unknown",
+                "Point",
+                "LineString",
+                "Polygon"
+              ];
+              var EvaluationContext = function EvaluationContext2() {
+                this.globals = null;
+                this.feature = null;
+                this.featureState = null;
+                this.formattedSection = null;
+                this._parseColorCache = {};
+                this.availableImages = null;
+                this.canonical = null;
+              };
+              EvaluationContext.prototype.id = function id22() {
+                return this.feature && "id" in this.feature ? this.feature.id : null;
+              };
+              EvaluationContext.prototype.geometryType = function geometryType() {
+                return this.feature ? typeof this.feature.type === "number" ? geometryTypes[this.feature.type] : this.feature.type : null;
+              };
+              EvaluationContext.prototype.geometry = function geometry2() {
+                return this.feature && "geometry" in this.feature ? this.feature.geometry : null;
+              };
+              EvaluationContext.prototype.canonicalID = function canonicalID() {
+                return this.canonical;
+              };
+              EvaluationContext.prototype.properties = function properties2() {
+                return this.feature && this.feature.properties || {};
+              };
+              EvaluationContext.prototype.parseColor = function parseColor(input) {
+                var cached = this._parseColorCache[input];
+                if (!cached) {
+                  cached = this._parseColorCache[input] = Color2.parse(input);
+                }
+                return cached;
+              };
+              var CompoundExpression = function CompoundExpression2(name3, type, evaluate, args) {
+                this.name = name3;
+                this.type = type;
+                this._evaluate = evaluate;
+                this.args = args;
+              };
+              CompoundExpression.prototype.evaluate = function evaluate(ctx2) {
+                return this._evaluate(ctx2, this.args);
+              };
+              CompoundExpression.prototype.eachChild = function eachChild(fn) {
+                this.args.forEach(fn);
+              };
+              CompoundExpression.prototype.outputDefined = function outputDefined() {
+                return false;
+              };
+              CompoundExpression.prototype.serialize = function serialize2() {
+                return [this.name].concat(this.args.map(function(arg) {
+                  return arg.serialize();
+                }));
+              };
+              CompoundExpression.parse = function parse22(args, context) {
+                var ref$1;
+                var op = args[0];
+                var definition = CompoundExpression.definitions[op];
+                if (!definition) {
+                  return context.error('Unknown expression "' + op + '". If you wanted a literal array, use ["literal", [...]].', 0);
+                }
+                var type = Array.isArray(definition) ? definition[0] : definition.type;
+                var availableOverloads = Array.isArray(definition) ? [[
+                  definition[1],
+                  definition[2]
+                ]] : definition.overloads;
+                var overloads = availableOverloads.filter(function(ref2) {
+                  var signature = ref2[0];
+                  return !Array.isArray(signature) || signature.length === args.length - 1;
+                });
+                var signatureContext = null;
+                for (var i$3 = 0, list = overloads; i$3 < list.length; i$3 += 1) {
+                  var ref = list[i$3];
+                  var params = ref[0];
+                  var evaluate = ref[1];
+                  signatureContext = new ParsingContext(context.registry, context.path, null, context.scope);
+                  var parsedArgs = [];
+                  var argParseFailed = false;
+                  for (var i2 = 1; i2 < args.length; i2++) {
+                    var arg = args[i2];
+                    var expectedType = Array.isArray(params) ? params[i2 - 1] : params.type;
+                    var parsed = signatureContext.parse(arg, 1 + parsedArgs.length, expectedType);
+                    if (!parsed) {
+                      argParseFailed = true;
+                      break;
+                    }
+                    parsedArgs.push(parsed);
+                  }
+                  if (argParseFailed) {
+                    continue;
+                  }
+                  if (Array.isArray(params)) {
+                    if (params.length !== parsedArgs.length) {
+                      signatureContext.error("Expected " + params.length + " arguments, but found " + parsedArgs.length + " instead.");
+                      continue;
+                    }
+                  }
+                  for (var i$1 = 0; i$1 < parsedArgs.length; i$1++) {
+                    var expected = Array.isArray(params) ? params[i$1] : params.type;
+                    var arg$1 = parsedArgs[i$1];
+                    signatureContext.concat(i$1 + 1).checkSubtype(expected, arg$1.type);
+                  }
+                  if (signatureContext.errors.length === 0) {
+                    return new CompoundExpression(op, type, evaluate, parsedArgs);
+                  }
+                }
+                if (overloads.length === 1) {
+                  (ref$1 = context.errors).push.apply(ref$1, signatureContext.errors);
+                } else {
+                  var expected$1 = overloads.length ? overloads : availableOverloads;
+                  var signatures = expected$1.map(function(ref2) {
+                    var params2 = ref2[0];
+                    return stringifySignature(params2);
+                  }).join(" | ");
+                  var actualTypes = [];
+                  for (var i$2 = 1; i$2 < args.length; i$2++) {
+                    var parsed$1 = context.parse(args[i$2], 1 + actualTypes.length);
+                    if (!parsed$1) {
+                      return null;
+                    }
+                    actualTypes.push(toString(parsed$1.type));
+                  }
+                  context.error("Expected arguments of type " + signatures + ", but found (" + actualTypes.join(", ") + ") instead.");
+                }
+                return null;
+              };
+              CompoundExpression.register = function register22(registry2, definitions) {
+                CompoundExpression.definitions = definitions;
+                for (var name3 in definitions) {
+                  registry2[name3] = CompoundExpression;
+                }
+              };
+              function stringifySignature(signature) {
+                if (Array.isArray(signature)) {
+                  return "(" + signature.map(toString).join(", ") + ")";
+                } else {
+                  return "(" + toString(signature.type) + "...)";
+                }
+              }
+              var CollatorExpression = function CollatorExpression2(caseSensitive, diacriticSensitive, locale) {
+                this.type = CollatorType;
+                this.locale = locale;
+                this.caseSensitive = caseSensitive;
+                this.diacriticSensitive = diacriticSensitive;
+              };
+              CollatorExpression.parse = function parse22(args, context) {
+                if (args.length !== 2) {
+                  return context.error("Expected one argument.");
+                }
+                var options = args[1];
+                if (typeof options !== "object" || Array.isArray(options)) {
+                  return context.error("Collator options argument must be an object.");
+                }
+                var caseSensitive = context.parse(options["case-sensitive"] === void 0 ? false : options["case-sensitive"], 1, BooleanType);
+                if (!caseSensitive) {
+                  return null;
+                }
+                var diacriticSensitive = context.parse(options["diacritic-sensitive"] === void 0 ? false : options["diacritic-sensitive"], 1, BooleanType);
+                if (!diacriticSensitive) {
+                  return null;
+                }
+                var locale = null;
+                if (options["locale"]) {
+                  locale = context.parse(options["locale"], 1, StringType);
+                  if (!locale) {
+                    return null;
+                  }
+                }
+                return new CollatorExpression(caseSensitive, diacriticSensitive, locale);
+              };
+              CollatorExpression.prototype.evaluate = function evaluate(ctx2) {
+                return new Collator(this.caseSensitive.evaluate(ctx2), this.diacriticSensitive.evaluate(ctx2), this.locale ? this.locale.evaluate(ctx2) : null);
+              };
+              CollatorExpression.prototype.eachChild = function eachChild(fn) {
+                fn(this.caseSensitive);
+                fn(this.diacriticSensitive);
+                if (this.locale) {
+                  fn(this.locale);
+                }
+              };
+              CollatorExpression.prototype.outputDefined = function outputDefined() {
+                return false;
+              };
+              CollatorExpression.prototype.serialize = function serialize2() {
+                var options = {};
+                options["case-sensitive"] = this.caseSensitive.serialize();
+                options["diacritic-sensitive"] = this.diacriticSensitive.serialize();
+                if (this.locale) {
+                  options["locale"] = this.locale.serialize();
+                }
+                return [
+                  "collator",
+                  options
+                ];
+              };
+              var EXTENT = 8192;
+              function updateBBox(bbox, coord) {
+                bbox[0] = Math.min(bbox[0], coord[0]);
+                bbox[1] = Math.min(bbox[1], coord[1]);
+                bbox[2] = Math.max(bbox[2], coord[0]);
+                bbox[3] = Math.max(bbox[3], coord[1]);
+              }
+              function mercatorXfromLng(lng) {
+                return (180 + lng) / 360;
+              }
+              function mercatorYfromLat(lat) {
+                return (180 - 180 / Math.PI * Math.log(Math.tan(Math.PI / 4 + lat * Math.PI / 360))) / 360;
+              }
+              function boxWithinBox(bbox1, bbox2) {
+                if (bbox1[0] <= bbox2[0]) {
+                  return false;
+                }
+                if (bbox1[2] >= bbox2[2]) {
+                  return false;
+                }
+                if (bbox1[1] <= bbox2[1]) {
+                  return false;
+                }
+                if (bbox1[3] >= bbox2[3]) {
+                  return false;
+                }
+                return true;
+              }
+              function getTileCoordinates(p2, canonical) {
+                var x2 = mercatorXfromLng(p2[0]);
+                var y2 = mercatorYfromLat(p2[1]);
+                var tilesAtZoom = Math.pow(2, canonical.z);
+                return [
+                  Math.round(x2 * tilesAtZoom * EXTENT),
+                  Math.round(y2 * tilesAtZoom * EXTENT)
+                ];
+              }
+              function onBoundary(p2, p1, p22) {
+                var x1 = p2[0] - p1[0];
+                var y1 = p2[1] - p1[1];
+                var x2 = p2[0] - p22[0];
+                var y2 = p2[1] - p22[1];
+                return x1 * y2 - x2 * y1 === 0 && x1 * x2 <= 0 && y1 * y2 <= 0;
+              }
+              function rayIntersect(p2, p1, p22) {
+                return p1[1] > p2[1] !== p22[1] > p2[1] && p2[0] < (p22[0] - p1[0]) * (p2[1] - p1[1]) / (p22[1] - p1[1]) + p1[0];
+              }
+              function pointWithinPolygon(point, rings) {
+                var inside = false;
+                for (var i2 = 0, len2 = rings.length; i2 < len2; i2++) {
+                  var ring = rings[i2];
+                  for (var j2 = 0, len22 = ring.length; j2 < len22 - 1; j2++) {
+                    if (onBoundary(point, ring[j2], ring[j2 + 1])) {
+                      return false;
+                    }
+                    if (rayIntersect(point, ring[j2], ring[j2 + 1])) {
+                      inside = !inside;
+                    }
+                  }
+                }
+                return inside;
+              }
+              function pointWithinPolygons(point, polygons) {
+                for (var i2 = 0; i2 < polygons.length; i2++) {
+                  if (pointWithinPolygon(point, polygons[i2])) {
+                    return true;
+                  }
+                }
+                return false;
+              }
+              function perp(v1, v2) {
+                return v1[0] * v2[1] - v1[1] * v2[0];
+              }
+              function twoSided(p1, p2, q1, q2) {
+                var x1 = p1[0] - q1[0];
+                var y1 = p1[1] - q1[1];
+                var x2 = p2[0] - q1[0];
+                var y2 = p2[1] - q1[1];
+                var x3 = q2[0] - q1[0];
+                var y3 = q2[1] - q1[1];
+                var det1 = x1 * y3 - x3 * y1;
+                var det2 = x2 * y3 - x3 * y2;
+                if (det1 > 0 && det2 < 0 || det1 < 0 && det2 > 0) {
+                  return true;
+                }
+                return false;
+              }
+              function lineIntersectLine(a2, b2, c2, d2) {
+                var vectorP = [
+                  b2[0] - a2[0],
+                  b2[1] - a2[1]
+                ];
+                var vectorQ = [
+                  d2[0] - c2[0],
+                  d2[1] - c2[1]
+                ];
+                if (perp(vectorQ, vectorP) === 0) {
+                  return false;
+                }
+                if (twoSided(a2, b2, c2, d2) && twoSided(c2, d2, a2, b2)) {
+                  return true;
+                }
+                return false;
+              }
+              function lineIntersectPolygon(p1, p2, polygon) {
+                for (var i2 = 0, list = polygon; i2 < list.length; i2 += 1) {
+                  var ring = list[i2];
+                  for (var j2 = 0; j2 < ring.length - 1; ++j2) {
+                    if (lineIntersectLine(p1, p2, ring[j2], ring[j2 + 1])) {
+                      return true;
+                    }
+                  }
+                }
+                return false;
+              }
+              function lineStringWithinPolygon(line, polygon) {
+                for (var i2 = 0; i2 < line.length; ++i2) {
+                  if (!pointWithinPolygon(line[i2], polygon)) {
+                    return false;
+                  }
+                }
+                for (var i$1 = 0; i$1 < line.length - 1; ++i$1) {
+                  if (lineIntersectPolygon(line[i$1], line[i$1 + 1], polygon)) {
+                    return false;
+                  }
+                }
+                return true;
+              }
+              function lineStringWithinPolygons(line, polygons) {
+                for (var i2 = 0; i2 < polygons.length; i2++) {
+                  if (lineStringWithinPolygon(line, polygons[i2])) {
+                    return true;
+                  }
+                }
+                return false;
+              }
+              function getTilePolygon(coordinates, bbox, canonical) {
+                var polygon = [];
+                for (var i2 = 0; i2 < coordinates.length; i2++) {
+                  var ring = [];
+                  for (var j2 = 0; j2 < coordinates[i2].length; j2++) {
+                    var coord = getTileCoordinates(coordinates[i2][j2], canonical);
+                    updateBBox(bbox, coord);
+                    ring.push(coord);
+                  }
+                  polygon.push(ring);
+                }
+                return polygon;
+              }
+              function getTilePolygons(coordinates, bbox, canonical) {
+                var polygons = [];
+                for (var i2 = 0; i2 < coordinates.length; i2++) {
+                  var polygon = getTilePolygon(coordinates[i2], bbox, canonical);
+                  polygons.push(polygon);
+                }
+                return polygons;
+              }
+              function updatePoint(p2, bbox, polyBBox, worldSize) {
+                if (p2[0] < polyBBox[0] || p2[0] > polyBBox[2]) {
+                  var halfWorldSize = worldSize * 0.5;
+                  var shift = p2[0] - polyBBox[0] > halfWorldSize ? -worldSize : polyBBox[0] - p2[0] > halfWorldSize ? worldSize : 0;
+                  if (shift === 0) {
+                    shift = p2[0] - polyBBox[2] > halfWorldSize ? -worldSize : polyBBox[2] - p2[0] > halfWorldSize ? worldSize : 0;
+                  }
+                  p2[0] += shift;
+                }
+                updateBBox(bbox, p2);
+              }
+              function resetBBox(bbox) {
+                bbox[0] = bbox[1] = Infinity;
+                bbox[2] = bbox[3] = -Infinity;
+              }
+              function getTilePoints(geometry2, pointBBox, polyBBox, canonical) {
+                var worldSize = Math.pow(2, canonical.z) * EXTENT;
+                var shifts = [
+                  canonical.x * EXTENT,
+                  canonical.y * EXTENT
+                ];
+                var tilePoints = [];
+                for (var i$1 = 0, list$1 = geometry2; i$1 < list$1.length; i$1 += 1) {
+                  var points = list$1[i$1];
+                  for (var i2 = 0, list = points; i2 < list.length; i2 += 1) {
+                    var point = list[i2];
+                    var p2 = [
+                      point.x + shifts[0],
+                      point.y + shifts[1]
+                    ];
+                    updatePoint(p2, pointBBox, polyBBox, worldSize);
+                    tilePoints.push(p2);
+                  }
+                }
+                return tilePoints;
+              }
+              function getTileLines(geometry2, lineBBox, polyBBox, canonical) {
+                var worldSize = Math.pow(2, canonical.z) * EXTENT;
+                var shifts = [
+                  canonical.x * EXTENT,
+                  canonical.y * EXTENT
+                ];
+                var tileLines = [];
+                for (var i$1 = 0, list$1 = geometry2; i$1 < list$1.length; i$1 += 1) {
+                  var line = list$1[i$1];
+                  var tileLine = [];
+                  for (var i2 = 0, list = line; i2 < list.length; i2 += 1) {
+                    var point = list[i2];
+                    var p2 = [
+                      point.x + shifts[0],
+                      point.y + shifts[1]
+                    ];
+                    updateBBox(lineBBox, p2);
+                    tileLine.push(p2);
+                  }
+                  tileLines.push(tileLine);
+                }
+                if (lineBBox[2] - lineBBox[0] <= worldSize / 2) {
+                  resetBBox(lineBBox);
+                  for (var i$3 = 0, list$3 = tileLines; i$3 < list$3.length; i$3 += 1) {
+                    var line$1 = list$3[i$3];
+                    for (var i$2 = 0, list$2 = line$1; i$2 < list$2.length; i$2 += 1) {
+                      var p$12 = list$2[i$2];
+                      updatePoint(p$12, lineBBox, polyBBox, worldSize);
+                    }
+                  }
+                }
+                return tileLines;
+              }
+              function pointsWithinPolygons(ctx2, polygonGeometry) {
+                var pointBBox = [
+                  Infinity,
+                  Infinity,
+                  -Infinity,
+                  -Infinity
+                ];
+                var polyBBox = [
+                  Infinity,
+                  Infinity,
+                  -Infinity,
+                  -Infinity
+                ];
+                var canonical = ctx2.canonicalID();
+                if (polygonGeometry.type === "Polygon") {
+                  var tilePolygon = getTilePolygon(polygonGeometry.coordinates, polyBBox, canonical);
+                  var tilePoints = getTilePoints(ctx2.geometry(), pointBBox, polyBBox, canonical);
+                  if (!boxWithinBox(pointBBox, polyBBox)) {
+                    return false;
+                  }
+                  for (var i2 = 0, list = tilePoints; i2 < list.length; i2 += 1) {
+                    var point = list[i2];
+                    if (!pointWithinPolygon(point, tilePolygon)) {
+                      return false;
+                    }
+                  }
+                }
+                if (polygonGeometry.type === "MultiPolygon") {
+                  var tilePolygons = getTilePolygons(polygonGeometry.coordinates, polyBBox, canonical);
+                  var tilePoints$1 = getTilePoints(ctx2.geometry(), pointBBox, polyBBox, canonical);
+                  if (!boxWithinBox(pointBBox, polyBBox)) {
+                    return false;
+                  }
+                  for (var i$1 = 0, list$1 = tilePoints$1; i$1 < list$1.length; i$1 += 1) {
+                    var point$1 = list$1[i$1];
+                    if (!pointWithinPolygons(point$1, tilePolygons)) {
+                      return false;
+                    }
+                  }
+                }
+                return true;
+              }
+              function linesWithinPolygons(ctx2, polygonGeometry) {
+                var lineBBox = [
+                  Infinity,
+                  Infinity,
+                  -Infinity,
+                  -Infinity
+                ];
+                var polyBBox = [
+                  Infinity,
+                  Infinity,
+                  -Infinity,
+                  -Infinity
+                ];
+                var canonical = ctx2.canonicalID();
+                if (polygonGeometry.type === "Polygon") {
+                  var tilePolygon = getTilePolygon(polygonGeometry.coordinates, polyBBox, canonical);
+                  var tileLines = getTileLines(ctx2.geometry(), lineBBox, polyBBox, canonical);
+                  if (!boxWithinBox(lineBBox, polyBBox)) {
+                    return false;
+                  }
+                  for (var i2 = 0, list = tileLines; i2 < list.length; i2 += 1) {
+                    var line = list[i2];
+                    if (!lineStringWithinPolygon(line, tilePolygon)) {
+                      return false;
+                    }
+                  }
+                }
+                if (polygonGeometry.type === "MultiPolygon") {
+                  var tilePolygons = getTilePolygons(polygonGeometry.coordinates, polyBBox, canonical);
+                  var tileLines$1 = getTileLines(ctx2.geometry(), lineBBox, polyBBox, canonical);
+                  if (!boxWithinBox(lineBBox, polyBBox)) {
+                    return false;
+                  }
+                  for (var i$1 = 0, list$1 = tileLines$1; i$1 < list$1.length; i$1 += 1) {
+                    var line$1 = list$1[i$1];
+                    if (!lineStringWithinPolygons(line$1, tilePolygons)) {
+                      return false;
+                    }
+                  }
+                }
+                return true;
+              }
+              var Within = function Within2(geojson, geometries) {
+                this.type = BooleanType;
+                this.geojson = geojson;
+                this.geometries = geometries;
+              };
+              Within.parse = function parse22(args, context) {
+                if (args.length !== 2) {
+                  return context.error("'within' expression requires exactly one argument, but found " + (args.length - 1) + " instead.");
+                }
+                if (isValue(args[1])) {
+                  var geojson = args[1];
+                  if (geojson.type === "FeatureCollection") {
+                    for (var i2 = 0; i2 < geojson.features.length; ++i2) {
+                      var type = geojson.features[i2].geometry.type;
+                      if (type === "Polygon" || type === "MultiPolygon") {
+                        return new Within(geojson, geojson.features[i2].geometry);
+                      }
+                    }
+                  } else if (geojson.type === "Feature") {
+                    var type$1 = geojson.geometry.type;
+                    if (type$1 === "Polygon" || type$1 === "MultiPolygon") {
+                      return new Within(geojson, geojson.geometry);
+                    }
+                  } else if (geojson.type === "Polygon" || geojson.type === "MultiPolygon") {
+                    return new Within(geojson, geojson);
+                  }
+                }
+                return context.error("'within' expression requires valid geojson object that contains polygon geometry type.");
+              };
+              Within.prototype.evaluate = function evaluate(ctx2) {
+                if (ctx2.geometry() != null && ctx2.canonicalID() != null) {
+                  if (ctx2.geometryType() === "Point") {
+                    return pointsWithinPolygons(ctx2, this.geometries);
+                  } else if (ctx2.geometryType() === "LineString") {
+                    return linesWithinPolygons(ctx2, this.geometries);
+                  }
+                }
+                return false;
+              };
+              Within.prototype.eachChild = function eachChild() {
+              };
+              Within.prototype.outputDefined = function outputDefined() {
+                return true;
+              };
+              Within.prototype.serialize = function serialize2() {
+                return [
+                  "within",
+                  this.geojson
+                ];
+              };
+              function isFeatureConstant(e2) {
+                if (e2 instanceof CompoundExpression) {
+                  if (e2.name === "get" && e2.args.length === 1) {
+                    return false;
+                  } else if (e2.name === "feature-state") {
+                    return false;
+                  } else if (e2.name === "has" && e2.args.length === 1) {
+                    return false;
+                  } else if (e2.name === "properties" || e2.name === "geometry-type" || e2.name === "id") {
+                    return false;
+                  } else if (/^filter-/.test(e2.name)) {
+                    return false;
+                  }
+                }
+                if (e2 instanceof Within) {
+                  return false;
+                }
+                var result = true;
+                e2.eachChild(function(arg) {
+                  if (result && !isFeatureConstant(arg)) {
+                    result = false;
+                  }
+                });
+                return result;
+              }
+              function isStateConstant(e2) {
+                if (e2 instanceof CompoundExpression) {
+                  if (e2.name === "feature-state") {
+                    return false;
+                  }
+                }
+                var result = true;
+                e2.eachChild(function(arg) {
+                  if (result && !isStateConstant(arg)) {
+                    result = false;
+                  }
+                });
+                return result;
+              }
+              function isGlobalPropertyConstant(e2, properties2) {
+                if (e2 instanceof CompoundExpression && properties2.indexOf(e2.name) >= 0) {
+                  return false;
+                }
+                var result = true;
+                e2.eachChild(function(arg) {
+                  if (result && !isGlobalPropertyConstant(arg, properties2)) {
+                    result = false;
+                  }
+                });
+                return result;
+              }
+              var Var = function Var2(name3, boundExpression) {
+                this.type = boundExpression.type;
+                this.name = name3;
+                this.boundExpression = boundExpression;
+              };
+              Var.parse = function parse22(args, context) {
+                if (args.length !== 2 || typeof args[1] !== "string") {
+                  return context.error("'var' expression requires exactly one string literal argument.");
+                }
+                var name3 = args[1];
+                if (!context.scope.has(name3)) {
+                  return context.error('Unknown variable "' + name3 + '". Make sure "' + name3 + '" has been bound in an enclosing "let" expression before using it.', 1);
+                }
+                return new Var(name3, context.scope.get(name3));
+              };
+              Var.prototype.evaluate = function evaluate(ctx2) {
+                return this.boundExpression.evaluate(ctx2);
+              };
+              Var.prototype.eachChild = function eachChild() {
+              };
+              Var.prototype.outputDefined = function outputDefined() {
+                return false;
+              };
+              Var.prototype.serialize = function serialize2() {
+                return [
+                  "var",
+                  this.name
+                ];
+              };
+              var ParsingContext = function ParsingContext2(registry2, path, expectedType, scope, errors) {
+                if (path === void 0)
+                  path = [];
+                if (scope === void 0)
+                  scope = new Scope();
+                if (errors === void 0)
+                  errors = [];
+                this.registry = registry2;
+                this.path = path;
+                this.key = path.map(function(part) {
+                  return "[" + part + "]";
+                }).join("");
+                this.scope = scope;
+                this.errors = errors;
+                this.expectedType = expectedType;
+              };
+              ParsingContext.prototype.parse = function parse22(expr, index, expectedType, bindings, options) {
+                if (options === void 0)
+                  options = {};
+                if (index) {
+                  return this.concat(index, expectedType, bindings)._parse(expr, options);
+                }
+                return this._parse(expr, options);
+              };
+              ParsingContext.prototype._parse = function _parse(expr, options) {
+                if (expr === null || typeof expr === "string" || typeof expr === "boolean" || typeof expr === "number") {
+                  expr = [
+                    "literal",
+                    expr
+                  ];
+                }
+                function annotate(parsed2, type, typeAnnotation) {
+                  if (typeAnnotation === "assert") {
+                    return new Assertion(type, [parsed2]);
+                  } else if (typeAnnotation === "coerce") {
+                    return new Coercion(type, [parsed2]);
+                  } else {
+                    return parsed2;
+                  }
+                }
+                if (Array.isArray(expr)) {
+                  if (expr.length === 0) {
+                    return this.error('Expected an array with at least one element. If you wanted a literal array, use ["literal", []].');
+                  }
+                  var op = expr[0];
+                  if (typeof op !== "string") {
+                    this.error("Expression name must be a string, but found " + typeof op + ' instead. If you wanted a literal array, use ["literal", [...]].', 0);
+                    return null;
+                  }
+                  var Expr = this.registry[op];
+                  if (Expr) {
+                    var parsed = Expr.parse(expr, this);
+                    if (!parsed) {
+                      return null;
+                    }
+                    if (this.expectedType) {
+                      var expected = this.expectedType;
+                      var actual = parsed.type;
+                      if ((expected.kind === "string" || expected.kind === "number" || expected.kind === "boolean" || expected.kind === "object" || expected.kind === "array") && actual.kind === "value") {
+                        parsed = annotate(parsed, expected, options.typeAnnotation || "assert");
+                      } else if ((expected.kind === "color" || expected.kind === "formatted" || expected.kind === "resolvedImage") && (actual.kind === "value" || actual.kind === "string")) {
+                        parsed = annotate(parsed, expected, options.typeAnnotation || "coerce");
+                      } else if (this.checkSubtype(expected, actual)) {
+                        return null;
+                      }
+                    }
+                    if (!(parsed instanceof Literal) && parsed.type.kind !== "resolvedImage" && isConstant(parsed)) {
+                      var ec2 = new EvaluationContext();
+                      try {
+                        parsed = new Literal(parsed.type, parsed.evaluate(ec2));
+                      } catch (e2) {
+                        this.error(e2.message);
+                        return null;
+                      }
+                    }
+                    return parsed;
+                  }
+                  return this.error('Unknown expression "' + op + '". If you wanted a literal array, use ["literal", [...]].', 0);
+                } else if (typeof expr === "undefined") {
+                  return this.error("'undefined' value invalid. Use null instead.");
+                } else if (typeof expr === "object") {
+                  return this.error('Bare objects invalid. Use ["literal", {...}] instead.');
+                } else {
+                  return this.error("Expected an array, but found " + typeof expr + " instead.");
+                }
+              };
+              ParsingContext.prototype.concat = function concat(index, expectedType, bindings) {
+                var path = typeof index === "number" ? this.path.concat(index) : this.path;
+                var scope = bindings ? this.scope.concat(bindings) : this.scope;
+                return new ParsingContext(this.registry, path, expectedType || null, scope, this.errors);
+              };
+              ParsingContext.prototype.error = function error2(error$1) {
+                var keys = [], len2 = arguments.length - 1;
+                while (len2-- > 0)
+                  keys[len2] = arguments[len2 + 1];
+                var key = "" + this.key + keys.map(function(k2) {
+                  return "[" + k2 + "]";
+                }).join("");
+                this.errors.push(new ParsingError(key, error$1));
+              };
+              ParsingContext.prototype.checkSubtype = function checkSubtype$1(expected, t4) {
+                var error2 = checkSubtype(expected, t4);
+                if (error2) {
+                  this.error(error2);
+                }
+                return error2;
+              };
+              function isConstant(expression2) {
+                if (expression2 instanceof Var) {
+                  return isConstant(expression2.boundExpression);
+                } else if (expression2 instanceof CompoundExpression && expression2.name === "error") {
+                  return false;
+                } else if (expression2 instanceof CollatorExpression) {
+                  return false;
+                } else if (expression2 instanceof Within) {
+                  return false;
+                }
+                var isTypeAnnotation = expression2 instanceof Coercion || expression2 instanceof Assertion;
+                var childrenConstant = true;
+                expression2.eachChild(function(child) {
+                  if (isTypeAnnotation) {
+                    childrenConstant = childrenConstant && isConstant(child);
+                  } else {
+                    childrenConstant = childrenConstant && child instanceof Literal;
+                  }
+                });
+                if (!childrenConstant) {
+                  return false;
+                }
+                return isFeatureConstant(expression2) && isGlobalPropertyConstant(expression2, [
+                  "zoom",
+                  "heatmap-density",
+                  "line-progress",
+                  "accumulated",
+                  "is-supported-script"
+                ]);
+              }
+              function findStopLessThanOrEqualTo(stops, input) {
+                var lastIndex = stops.length - 1;
+                var lowerIndex = 0;
+                var upperIndex = lastIndex;
+                var currentIndex = 0;
+                var currentValue, nextValue;
+                while (lowerIndex <= upperIndex) {
+                  currentIndex = Math.floor((lowerIndex + upperIndex) / 2);
+                  currentValue = stops[currentIndex];
+                  nextValue = stops[currentIndex + 1];
+                  if (currentValue <= input) {
+                    if (currentIndex === lastIndex || input < nextValue) {
+                      return currentIndex;
+                    }
+                    lowerIndex = currentIndex + 1;
+                  } else if (currentValue > input) {
+                    upperIndex = currentIndex - 1;
+                  } else {
+                    throw new RuntimeError("Input is not a number.");
+                  }
+                }
+                return 0;
+              }
+              var Step = function Step2(type, input, stops) {
+                this.type = type;
+                this.input = input;
+                this.labels = [];
+                this.outputs = [];
+                for (var i2 = 0, list = stops; i2 < list.length; i2 += 1) {
+                  var ref = list[i2];
+                  var label = ref[0];
+                  var expression2 = ref[1];
+                  this.labels.push(label);
+                  this.outputs.push(expression2);
+                }
+              };
+              Step.parse = function parse22(args, context) {
+                if (args.length - 1 < 4) {
+                  return context.error("Expected at least 4 arguments, but found only " + (args.length - 1) + ".");
+                }
+                if ((args.length - 1) % 2 !== 0) {
+                  return context.error("Expected an even number of arguments.");
+                }
+                var input = context.parse(args[1], 1, NumberType);
+                if (!input) {
+                  return null;
+                }
+                var stops = [];
+                var outputType = null;
+                if (context.expectedType && context.expectedType.kind !== "value") {
+                  outputType = context.expectedType;
+                }
+                for (var i2 = 1; i2 < args.length; i2 += 2) {
+                  var label = i2 === 1 ? -Infinity : args[i2];
+                  var value = args[i2 + 1];
+                  var labelKey = i2;
+                  var valueKey = i2 + 1;
+                  if (typeof label !== "number") {
+                    return context.error('Input/output pairs for "step" expressions must be defined using literal numeric values (not computed expressions) for the input values.', labelKey);
+                  }
+                  if (stops.length && stops[stops.length - 1][0] >= label) {
+                    return context.error('Input/output pairs for "step" expressions must be arranged with input values in strictly ascending order.', labelKey);
+                  }
+                  var parsed = context.parse(value, valueKey, outputType);
+                  if (!parsed) {
+                    return null;
+                  }
+                  outputType = outputType || parsed.type;
+                  stops.push([
+                    label,
+                    parsed
+                  ]);
+                }
+                return new Step(outputType, input, stops);
+              };
+              Step.prototype.evaluate = function evaluate(ctx2) {
+                var labels = this.labels;
+                var outputs = this.outputs;
+                if (labels.length === 1) {
+                  return outputs[0].evaluate(ctx2);
+                }
+                var value = this.input.evaluate(ctx2);
+                if (value <= labels[0]) {
+                  return outputs[0].evaluate(ctx2);
+                }
+                var stopCount = labels.length;
+                if (value >= labels[stopCount - 1]) {
+                  return outputs[stopCount - 1].evaluate(ctx2);
+                }
+                var index = findStopLessThanOrEqualTo(labels, value);
+                return outputs[index].evaluate(ctx2);
+              };
+              Step.prototype.eachChild = function eachChild(fn) {
+                fn(this.input);
+                for (var i2 = 0, list = this.outputs; i2 < list.length; i2 += 1) {
+                  var expression2 = list[i2];
+                  fn(expression2);
+                }
+              };
+              Step.prototype.outputDefined = function outputDefined() {
+                return this.outputs.every(function(out) {
+                  return out.outputDefined();
+                });
+              };
+              Step.prototype.serialize = function serialize2() {
+                var serialized = [
+                  "step",
+                  this.input.serialize()
+                ];
+                for (var i2 = 0; i2 < this.labels.length; i2++) {
+                  if (i2 > 0) {
+                    serialized.push(this.labels[i2]);
+                  }
+                  serialized.push(this.outputs[i2].serialize());
+                }
+                return serialized;
+              };
+              function number(a2, b2, t4) {
+                return a2 * (1 - t4) + b2 * t4;
+              }
+              function color22(from, to, t4) {
+                return new Color2(number(from.r, to.r, t4), number(from.g, to.g, t4), number(from.b, to.b, t4), number(from.a, to.a, t4));
+              }
+              function array$1(from, to, t4) {
+                return from.map(function(d2, i2) {
+                  return number(d2, to[i2], t4);
+                });
+              }
+              var interpolate = /* @__PURE__ */ Object.freeze({
+                __proto__: null,
+                number,
+                color: color22,
+                array: array$1
+              });
+              var Xn2 = 0.95047, Yn2 = 1, Zn2 = 1.08883, t02 = 4 / 29, t12 = 6 / 29, t22 = 3 * t12 * t12, t32 = t12 * t12 * t12, deg2rad = Math.PI / 180, rad2deg = 180 / Math.PI;
+              function xyz2lab2(t4) {
+                return t4 > t32 ? Math.pow(t4, 1 / 3) : t4 / t22 + t02;
+              }
+              function lab2xyz2(t4) {
+                return t4 > t12 ? t4 * t4 * t4 : t22 * (t4 - t02);
+              }
+              function xyz2rgb(x2) {
+                return 255 * (x2 <= 31308e-7 ? 12.92 * x2 : 1.055 * Math.pow(x2, 1 / 2.4) - 0.055);
+              }
+              function rgb2xyz(x2) {
+                x2 /= 255;
+                return x2 <= 0.04045 ? x2 / 12.92 : Math.pow((x2 + 0.055) / 1.055, 2.4);
+              }
+              function rgbToLab(rgbColor) {
+                var b2 = rgb2xyz(rgbColor.r), a2 = rgb2xyz(rgbColor.g), l2 = rgb2xyz(rgbColor.b), x2 = xyz2lab2((0.4124564 * b2 + 0.3575761 * a2 + 0.1804375 * l2) / Xn2), y2 = xyz2lab2((0.2126729 * b2 + 0.7151522 * a2 + 0.072175 * l2) / Yn2), z2 = xyz2lab2((0.0193339 * b2 + 0.119192 * a2 + 0.9503041 * l2) / Zn2);
+                return {
+                  l: 116 * y2 - 16,
+                  a: 500 * (x2 - y2),
+                  b: 200 * (y2 - z2),
+                  alpha: rgbColor.a
+                };
+              }
+              function labToRgb(labColor) {
+                var y2 = (labColor.l + 16) / 116, x2 = isNaN(labColor.a) ? y2 : y2 + labColor.a / 500, z2 = isNaN(labColor.b) ? y2 : y2 - labColor.b / 200;
+                y2 = Yn2 * lab2xyz2(y2);
+                x2 = Xn2 * lab2xyz2(x2);
+                z2 = Zn2 * lab2xyz2(z2);
+                return new Color2(xyz2rgb(3.2404542 * x2 - 1.5371385 * y2 - 0.4985314 * z2), xyz2rgb(-0.969266 * x2 + 1.8760108 * y2 + 0.041556 * z2), xyz2rgb(0.0556434 * x2 - 0.2040259 * y2 + 1.0572252 * z2), labColor.alpha);
+              }
+              function interpolateLab(from, to, t4) {
+                return {
+                  l: number(from.l, to.l, t4),
+                  a: number(from.a, to.a, t4),
+                  b: number(from.b, to.b, t4),
+                  alpha: number(from.alpha, to.alpha, t4)
+                };
+              }
+              function rgbToHcl(rgbColor) {
+                var ref = rgbToLab(rgbColor);
+                var l2 = ref.l;
+                var a2 = ref.a;
+                var b2 = ref.b;
+                var h2 = Math.atan2(b2, a2) * rad2deg;
+                return {
+                  h: h2 < 0 ? h2 + 360 : h2,
+                  c: Math.sqrt(a2 * a2 + b2 * b2),
+                  l: l2,
+                  alpha: rgbColor.a
+                };
+              }
+              function hclToRgb(hclColor) {
+                var h2 = hclColor.h * deg2rad, c2 = hclColor.c, l2 = hclColor.l;
+                return labToRgb({
+                  l: l2,
+                  a: Math.cos(h2) * c2,
+                  b: Math.sin(h2) * c2,
+                  alpha: hclColor.alpha
+                });
+              }
+              function interpolateHue(a2, b2, t4) {
+                var d2 = b2 - a2;
+                return a2 + t4 * (d2 > 180 || d2 < -180 ? d2 - 360 * Math.round(d2 / 360) : d2);
+              }
+              function interpolateHcl(from, to, t4) {
+                return {
+                  h: interpolateHue(from.h, to.h, t4),
+                  c: number(from.c, to.c, t4),
+                  l: number(from.l, to.l, t4),
+                  alpha: number(from.alpha, to.alpha, t4)
+                };
+              }
+              var lab3 = {
+                forward: rgbToLab,
+                reverse: labToRgb,
+                interpolate: interpolateLab
+              };
+              var hcl3 = {
+                forward: rgbToHcl,
+                reverse: hclToRgb,
+                interpolate: interpolateHcl
+              };
+              var colorSpaces = /* @__PURE__ */ Object.freeze({
+                __proto__: null,
+                lab: lab3,
+                hcl: hcl3
+              });
+              var Interpolate = function Interpolate2(type, operator, interpolation, input, stops) {
+                this.type = type;
+                this.operator = operator;
+                this.interpolation = interpolation;
+                this.input = input;
+                this.labels = [];
+                this.outputs = [];
+                for (var i2 = 0, list = stops; i2 < list.length; i2 += 1) {
+                  var ref = list[i2];
+                  var label = ref[0];
+                  var expression2 = ref[1];
+                  this.labels.push(label);
+                  this.outputs.push(expression2);
+                }
+              };
+              Interpolate.interpolationFactor = function interpolationFactor2(interpolation, input, lower, upper) {
+                var t4 = 0;
+                if (interpolation.name === "exponential") {
+                  t4 = exponentialInterpolation(input, interpolation.base, lower, upper);
+                } else if (interpolation.name === "linear") {
+                  t4 = exponentialInterpolation(input, 1, lower, upper);
+                } else if (interpolation.name === "cubic-bezier") {
+                  var c2 = interpolation.controlPoints;
+                  var ub2 = new unitbezier(c2[0], c2[1], c2[2], c2[3]);
+                  t4 = ub2.solve(exponentialInterpolation(input, 1, lower, upper));
+                }
+                return t4;
+              };
+              Interpolate.parse = function parse22(args, context) {
+                var operator = args[0];
+                var interpolation = args[1];
+                var input = args[2];
+                var rest = args.slice(3);
+                if (!Array.isArray(interpolation) || interpolation.length === 0) {
+                  return context.error("Expected an interpolation type expression.", 1);
+                }
+                if (interpolation[0] === "linear") {
+                  interpolation = { name: "linear" };
+                } else if (interpolation[0] === "exponential") {
+                  var base = interpolation[1];
+                  if (typeof base !== "number") {
+                    return context.error("Exponential interpolation requires a numeric base.", 1, 1);
+                  }
+                  interpolation = {
+                    name: "exponential",
+                    base
+                  };
+                } else if (interpolation[0] === "cubic-bezier") {
+                  var controlPoints = interpolation.slice(1);
+                  if (controlPoints.length !== 4 || controlPoints.some(function(t4) {
+                    return typeof t4 !== "number" || t4 < 0 || t4 > 1;
+                  })) {
+                    return context.error("Cubic bezier interpolation requires four numeric arguments with values between 0 and 1.", 1);
+                  }
+                  interpolation = {
+                    name: "cubic-bezier",
+                    controlPoints
+                  };
+                } else {
+                  return context.error("Unknown interpolation type " + String(interpolation[0]), 1, 0);
+                }
+                if (args.length - 1 < 4) {
+                  return context.error("Expected at least 4 arguments, but found only " + (args.length - 1) + ".");
+                }
+                if ((args.length - 1) % 2 !== 0) {
+                  return context.error("Expected an even number of arguments.");
+                }
+                input = context.parse(input, 2, NumberType);
+                if (!input) {
+                  return null;
+                }
+                var stops = [];
+                var outputType = null;
+                if (operator === "interpolate-hcl" || operator === "interpolate-lab") {
+                  outputType = ColorType;
+                } else if (context.expectedType && context.expectedType.kind !== "value") {
+                  outputType = context.expectedType;
+                }
+                for (var i2 = 0; i2 < rest.length; i2 += 2) {
+                  var label = rest[i2];
+                  var value = rest[i2 + 1];
+                  var labelKey = i2 + 3;
+                  var valueKey = i2 + 4;
+                  if (typeof label !== "number") {
+                    return context.error('Input/output pairs for "interpolate" expressions must be defined using literal numeric values (not computed expressions) for the input values.', labelKey);
+                  }
+                  if (stops.length && stops[stops.length - 1][0] >= label) {
+                    return context.error('Input/output pairs for "interpolate" expressions must be arranged with input values in strictly ascending order.', labelKey);
+                  }
+                  var parsed = context.parse(value, valueKey, outputType);
+                  if (!parsed) {
+                    return null;
+                  }
+                  outputType = outputType || parsed.type;
+                  stops.push([
+                    label,
+                    parsed
+                  ]);
+                }
+                if (outputType.kind !== "number" && outputType.kind !== "color" && !(outputType.kind === "array" && outputType.itemType.kind === "number" && typeof outputType.N === "number")) {
+                  return context.error("Type " + toString(outputType) + " is not interpolatable.");
+                }
+                return new Interpolate(outputType, operator, interpolation, input, stops);
+              };
+              Interpolate.prototype.evaluate = function evaluate(ctx2) {
+                var labels = this.labels;
+                var outputs = this.outputs;
+                if (labels.length === 1) {
+                  return outputs[0].evaluate(ctx2);
+                }
+                var value = this.input.evaluate(ctx2);
+                if (value <= labels[0]) {
+                  return outputs[0].evaluate(ctx2);
+                }
+                var stopCount = labels.length;
+                if (value >= labels[stopCount - 1]) {
+                  return outputs[stopCount - 1].evaluate(ctx2);
+                }
+                var index = findStopLessThanOrEqualTo(labels, value);
+                var lower = labels[index];
+                var upper = labels[index + 1];
+                var t4 = Interpolate.interpolationFactor(this.interpolation, value, lower, upper);
+                var outputLower = outputs[index].evaluate(ctx2);
+                var outputUpper = outputs[index + 1].evaluate(ctx2);
+                if (this.operator === "interpolate") {
+                  return interpolate[this.type.kind.toLowerCase()](outputLower, outputUpper, t4);
+                } else if (this.operator === "interpolate-hcl") {
+                  return hcl3.reverse(hcl3.interpolate(hcl3.forward(outputLower), hcl3.forward(outputUpper), t4));
+                } else {
+                  return lab3.reverse(lab3.interpolate(lab3.forward(outputLower), lab3.forward(outputUpper), t4));
+                }
+              };
+              Interpolate.prototype.eachChild = function eachChild(fn) {
+                fn(this.input);
+                for (var i2 = 0, list = this.outputs; i2 < list.length; i2 += 1) {
+                  var expression2 = list[i2];
+                  fn(expression2);
+                }
+              };
+              Interpolate.prototype.outputDefined = function outputDefined() {
+                return this.outputs.every(function(out) {
+                  return out.outputDefined();
+                });
+              };
+              Interpolate.prototype.serialize = function serialize2() {
+                var interpolation;
+                if (this.interpolation.name === "linear") {
+                  interpolation = ["linear"];
+                } else if (this.interpolation.name === "exponential") {
+                  if (this.interpolation.base === 1) {
+                    interpolation = ["linear"];
+                  } else {
+                    interpolation = [
+                      "exponential",
+                      this.interpolation.base
+                    ];
+                  }
+                } else {
+                  interpolation = ["cubic-bezier"].concat(this.interpolation.controlPoints);
+                }
+                var serialized = [
+                  this.operator,
+                  interpolation,
+                  this.input.serialize()
+                ];
+                for (var i2 = 0; i2 < this.labels.length; i2++) {
+                  serialized.push(this.labels[i2], this.outputs[i2].serialize());
+                }
+                return serialized;
+              };
+              function exponentialInterpolation(input, base, lowerValue, upperValue) {
+                var difference = upperValue - lowerValue;
+                var progress = input - lowerValue;
+                if (difference === 0) {
+                  return 0;
+                } else if (base === 1) {
+                  return progress / difference;
+                } else {
+                  return (Math.pow(base, progress) - 1) / (Math.pow(base, difference) - 1);
+                }
+              }
+              var Coalesce = function Coalesce2(type, args) {
+                this.type = type;
+                this.args = args;
+              };
+              Coalesce.parse = function parse22(args, context) {
+                if (args.length < 2) {
+                  return context.error("Expectected at least one argument.");
+                }
+                var outputType = null;
+                var expectedType = context.expectedType;
+                if (expectedType && expectedType.kind !== "value") {
+                  outputType = expectedType;
+                }
+                var parsedArgs = [];
+                for (var i2 = 0, list = args.slice(1); i2 < list.length; i2 += 1) {
+                  var arg = list[i2];
+                  var parsed = context.parse(arg, 1 + parsedArgs.length, outputType, void 0, { typeAnnotation: "omit" });
+                  if (!parsed) {
+                    return null;
+                  }
+                  outputType = outputType || parsed.type;
+                  parsedArgs.push(parsed);
+                }
+                var needsAnnotation = expectedType && parsedArgs.some(function(arg2) {
+                  return checkSubtype(expectedType, arg2.type);
+                });
+                return needsAnnotation ? new Coalesce(ValueType, parsedArgs) : new Coalesce(outputType, parsedArgs);
+              };
+              Coalesce.prototype.evaluate = function evaluate(ctx2) {
+                var result = null;
+                var argCount = 0;
+                var requestedImageName;
+                for (var i2 = 0, list = this.args; i2 < list.length; i2 += 1) {
+                  var arg = list[i2];
+                  argCount++;
+                  result = arg.evaluate(ctx2);
+                  if (result && result instanceof ResolvedImage && !result.available) {
+                    if (!requestedImageName) {
+                      requestedImageName = result.name;
+                    }
+                    result = null;
+                    if (argCount === this.args.length) {
+                      result = requestedImageName;
+                    }
+                  }
+                  if (result !== null) {
+                    break;
+                  }
+                }
+                return result;
+              };
+              Coalesce.prototype.eachChild = function eachChild(fn) {
+                this.args.forEach(fn);
+              };
+              Coalesce.prototype.outputDefined = function outputDefined() {
+                return this.args.every(function(arg) {
+                  return arg.outputDefined();
+                });
+              };
+              Coalesce.prototype.serialize = function serialize2() {
+                var serialized = ["coalesce"];
+                this.eachChild(function(child) {
+                  serialized.push(child.serialize());
+                });
+                return serialized;
+              };
+              var Let = function Let2(bindings, result) {
+                this.type = result.type;
+                this.bindings = [].concat(bindings);
+                this.result = result;
+              };
+              Let.prototype.evaluate = function evaluate(ctx2) {
+                return this.result.evaluate(ctx2);
+              };
+              Let.prototype.eachChild = function eachChild(fn) {
+                for (var i2 = 0, list = this.bindings; i2 < list.length; i2 += 1) {
+                  var binding = list[i2];
+                  fn(binding[1]);
+                }
+                fn(this.result);
+              };
+              Let.parse = function parse22(args, context) {
+                if (args.length < 4) {
+                  return context.error("Expected at least 3 arguments, but found " + (args.length - 1) + " instead.");
+                }
+                var bindings = [];
+                for (var i2 = 1; i2 < args.length - 1; i2 += 2) {
+                  var name3 = args[i2];
+                  if (typeof name3 !== "string") {
+                    return context.error("Expected string, but found " + typeof name3 + " instead.", i2);
+                  }
+                  if (/[^a-zA-Z0-9_]/.test(name3)) {
+                    return context.error("Variable names must contain only alphanumeric characters or '_'.", i2);
+                  }
+                  var value = context.parse(args[i2 + 1], i2 + 1);
+                  if (!value) {
+                    return null;
+                  }
+                  bindings.push([
+                    name3,
+                    value
+                  ]);
+                }
+                var result = context.parse(args[args.length - 1], args.length - 1, context.expectedType, bindings);
+                if (!result) {
+                  return null;
+                }
+                return new Let(bindings, result);
+              };
+              Let.prototype.outputDefined = function outputDefined() {
+                return this.result.outputDefined();
+              };
+              Let.prototype.serialize = function serialize2() {
+                var serialized = ["let"];
+                for (var i2 = 0, list = this.bindings; i2 < list.length; i2 += 1) {
+                  var ref = list[i2];
+                  var name3 = ref[0];
+                  var expr = ref[1];
+                  serialized.push(name3, expr.serialize());
+                }
+                serialized.push(this.result.serialize());
+                return serialized;
+              };
+              var At = function At2(type, index, input) {
+                this.type = type;
+                this.index = index;
+                this.input = input;
+              };
+              At.parse = function parse22(args, context) {
+                if (args.length !== 3) {
+                  return context.error("Expected 2 arguments, but found " + (args.length - 1) + " instead.");
+                }
+                var index = context.parse(args[1], 1, NumberType);
+                var input = context.parse(args[2], 2, array(context.expectedType || ValueType));
+                if (!index || !input) {
+                  return null;
+                }
+                var t4 = input.type;
+                return new At(t4.itemType, index, input);
+              };
+              At.prototype.evaluate = function evaluate(ctx2) {
+                var index = this.index.evaluate(ctx2);
+                var array2 = this.input.evaluate(ctx2);
+                if (index < 0) {
+                  throw new RuntimeError("Array index out of bounds: " + index + " < 0.");
+                }
+                if (index >= array2.length) {
+                  throw new RuntimeError("Array index out of bounds: " + index + " > " + (array2.length - 1) + ".");
+                }
+                if (index !== Math.floor(index)) {
+                  throw new RuntimeError("Array index must be an integer, but found " + index + " instead.");
+                }
+                return array2[index];
+              };
+              At.prototype.eachChild = function eachChild(fn) {
+                fn(this.index);
+                fn(this.input);
+              };
+              At.prototype.outputDefined = function outputDefined() {
+                return false;
+              };
+              At.prototype.serialize = function serialize2() {
+                return [
+                  "at",
+                  this.index.serialize(),
+                  this.input.serialize()
+                ];
+              };
+              var In = function In2(needle, haystack) {
+                this.type = BooleanType;
+                this.needle = needle;
+                this.haystack = haystack;
+              };
+              In.parse = function parse22(args, context) {
+                if (args.length !== 3) {
+                  return context.error("Expected 2 arguments, but found " + (args.length - 1) + " instead.");
+                }
+                var needle = context.parse(args[1], 1, ValueType);
+                var haystack = context.parse(args[2], 2, ValueType);
+                if (!needle || !haystack) {
+                  return null;
+                }
+                if (!isValidType(needle.type, [
+                  BooleanType,
+                  StringType,
+                  NumberType,
+                  NullType,
+                  ValueType
+                ])) {
+                  return context.error("Expected first argument to be of type boolean, string, number or null, but found " + toString(needle.type) + " instead");
+                }
+                return new In(needle, haystack);
+              };
+              In.prototype.evaluate = function evaluate(ctx2) {
+                var needle = this.needle.evaluate(ctx2);
+                var haystack = this.haystack.evaluate(ctx2);
+                if (!haystack) {
+                  return false;
+                }
+                if (!isValidNativeType(needle, [
+                  "boolean",
+                  "string",
+                  "number",
+                  "null"
+                ])) {
+                  throw new RuntimeError("Expected first argument to be of type boolean, string, number or null, but found " + toString(typeOf(needle)) + " instead.");
+                }
+                if (!isValidNativeType(haystack, [
+                  "string",
+                  "array"
+                ])) {
+                  throw new RuntimeError("Expected second argument to be of type array or string, but found " + toString(typeOf(haystack)) + " instead.");
+                }
+                return haystack.indexOf(needle) >= 0;
+              };
+              In.prototype.eachChild = function eachChild(fn) {
+                fn(this.needle);
+                fn(this.haystack);
+              };
+              In.prototype.outputDefined = function outputDefined() {
+                return true;
+              };
+              In.prototype.serialize = function serialize2() {
+                return [
+                  "in",
+                  this.needle.serialize(),
+                  this.haystack.serialize()
+                ];
+              };
+              var IndexOf = function IndexOf2(needle, haystack, fromIndex) {
+                this.type = NumberType;
+                this.needle = needle;
+                this.haystack = haystack;
+                this.fromIndex = fromIndex;
+              };
+              IndexOf.parse = function parse22(args, context) {
+                if (args.length <= 2 || args.length >= 5) {
+                  return context.error("Expected 3 or 4 arguments, but found " + (args.length - 1) + " instead.");
+                }
+                var needle = context.parse(args[1], 1, ValueType);
+                var haystack = context.parse(args[2], 2, ValueType);
+                if (!needle || !haystack) {
+                  return null;
+                }
+                if (!isValidType(needle.type, [
+                  BooleanType,
+                  StringType,
+                  NumberType,
+                  NullType,
+                  ValueType
+                ])) {
+                  return context.error("Expected first argument to be of type boolean, string, number or null, but found " + toString(needle.type) + " instead");
+                }
+                if (args.length === 4) {
+                  var fromIndex = context.parse(args[3], 3, NumberType);
+                  if (!fromIndex) {
+                    return null;
+                  }
+                  return new IndexOf(needle, haystack, fromIndex);
+                } else {
+                  return new IndexOf(needle, haystack);
+                }
+              };
+              IndexOf.prototype.evaluate = function evaluate(ctx2) {
+                var needle = this.needle.evaluate(ctx2);
+                var haystack = this.haystack.evaluate(ctx2);
+                if (!isValidNativeType(needle, [
+                  "boolean",
+                  "string",
+                  "number",
+                  "null"
+                ])) {
+                  throw new RuntimeError("Expected first argument to be of type boolean, string, number or null, but found " + toString(typeOf(needle)) + " instead.");
+                }
+                if (!isValidNativeType(haystack, [
+                  "string",
+                  "array"
+                ])) {
+                  throw new RuntimeError("Expected second argument to be of type array or string, but found " + toString(typeOf(haystack)) + " instead.");
+                }
+                if (this.fromIndex) {
+                  var fromIndex = this.fromIndex.evaluate(ctx2);
+                  return haystack.indexOf(needle, fromIndex);
+                }
+                return haystack.indexOf(needle);
+              };
+              IndexOf.prototype.eachChild = function eachChild(fn) {
+                fn(this.needle);
+                fn(this.haystack);
+                if (this.fromIndex) {
+                  fn(this.fromIndex);
+                }
+              };
+              IndexOf.prototype.outputDefined = function outputDefined() {
+                return false;
+              };
+              IndexOf.prototype.serialize = function serialize2() {
+                if (this.fromIndex != null && this.fromIndex !== void 0) {
+                  var fromIndex = this.fromIndex.serialize();
+                  return [
+                    "index-of",
+                    this.needle.serialize(),
+                    this.haystack.serialize(),
+                    fromIndex
+                  ];
+                }
+                return [
+                  "index-of",
+                  this.needle.serialize(),
+                  this.haystack.serialize()
+                ];
+              };
+              var Match = function Match2(inputType, outputType, input, cases, outputs, otherwise) {
+                this.inputType = inputType;
+                this.type = outputType;
+                this.input = input;
+                this.cases = cases;
+                this.outputs = outputs;
+                this.otherwise = otherwise;
+              };
+              Match.parse = function parse22(args, context) {
+                if (args.length < 5) {
+                  return context.error("Expected at least 4 arguments, but found only " + (args.length - 1) + ".");
+                }
+                if (args.length % 2 !== 1) {
+                  return context.error("Expected an even number of arguments.");
+                }
+                var inputType;
+                var outputType;
+                if (context.expectedType && context.expectedType.kind !== "value") {
+                  outputType = context.expectedType;
+                }
+                var cases = {};
+                var outputs = [];
+                for (var i2 = 2; i2 < args.length - 1; i2 += 2) {
+                  var labels = args[i2];
+                  var value = args[i2 + 1];
+                  if (!Array.isArray(labels)) {
+                    labels = [labels];
+                  }
+                  var labelContext = context.concat(i2);
+                  if (labels.length === 0) {
+                    return labelContext.error("Expected at least one branch label.");
+                  }
+                  for (var i$1 = 0, list = labels; i$1 < list.length; i$1 += 1) {
+                    var label = list[i$1];
+                    if (typeof label !== "number" && typeof label !== "string") {
+                      return labelContext.error("Branch labels must be numbers or strings.");
+                    } else if (typeof label === "number" && Math.abs(label) > Number.MAX_SAFE_INTEGER) {
+                      return labelContext.error("Branch labels must be integers no larger than " + Number.MAX_SAFE_INTEGER + ".");
+                    } else if (typeof label === "number" && Math.floor(label) !== label) {
+                      return labelContext.error("Numeric branch labels must be integer values.");
+                    } else if (!inputType) {
+                      inputType = typeOf(label);
+                    } else if (labelContext.checkSubtype(inputType, typeOf(label))) {
+                      return null;
+                    }
+                    if (typeof cases[String(label)] !== "undefined") {
+                      return labelContext.error("Branch labels must be unique.");
+                    }
+                    cases[String(label)] = outputs.length;
+                  }
+                  var result = context.parse(value, i2, outputType);
+                  if (!result) {
+                    return null;
+                  }
+                  outputType = outputType || result.type;
+                  outputs.push(result);
+                }
+                var input = context.parse(args[1], 1, ValueType);
+                if (!input) {
+                  return null;
+                }
+                var otherwise = context.parse(args[args.length - 1], args.length - 1, outputType);
+                if (!otherwise) {
+                  return null;
+                }
+                if (input.type.kind !== "value" && context.concat(1).checkSubtype(inputType, input.type)) {
+                  return null;
+                }
+                return new Match(inputType, outputType, input, cases, outputs, otherwise);
+              };
+              Match.prototype.evaluate = function evaluate(ctx2) {
+                var input = this.input.evaluate(ctx2);
+                var output = typeOf(input) === this.inputType && this.outputs[this.cases[input]] || this.otherwise;
+                return output.evaluate(ctx2);
+              };
+              Match.prototype.eachChild = function eachChild(fn) {
+                fn(this.input);
+                this.outputs.forEach(fn);
+                fn(this.otherwise);
+              };
+              Match.prototype.outputDefined = function outputDefined() {
+                return this.outputs.every(function(out) {
+                  return out.outputDefined();
+                }) && this.otherwise.outputDefined();
+              };
+              Match.prototype.serialize = function serialize2() {
+                var this$1$1 = this;
+                var serialized = [
+                  "match",
+                  this.input.serialize()
+                ];
+                var sortedLabels = Object.keys(this.cases).sort();
+                var groupedByOutput = [];
+                var outputLookup = {};
+                for (var i2 = 0, list = sortedLabels; i2 < list.length; i2 += 1) {
+                  var label = list[i2];
+                  var outputIndex = outputLookup[this.cases[label]];
+                  if (outputIndex === void 0) {
+                    outputLookup[this.cases[label]] = groupedByOutput.length;
+                    groupedByOutput.push([
+                      this.cases[label],
+                      [label]
+                    ]);
+                  } else {
+                    groupedByOutput[outputIndex][1].push(label);
+                  }
+                }
+                var coerceLabel = function(label2) {
+                  return this$1$1.inputType.kind === "number" ? Number(label2) : label2;
+                };
+                for (var i$1 = 0, list$1 = groupedByOutput; i$1 < list$1.length; i$1 += 1) {
+                  var ref = list$1[i$1];
+                  var outputIndex = ref[0];
+                  var labels = ref[1];
+                  if (labels.length === 1) {
+                    serialized.push(coerceLabel(labels[0]));
+                  } else {
+                    serialized.push(labels.map(coerceLabel));
+                  }
+                  serialized.push(this.outputs[outputIndex$1].serialize());
+                }
+                serialized.push(this.otherwise.serialize());
+                return serialized;
+              };
+              var Case = function Case2(type, branches, otherwise) {
+                this.type = type;
+                this.branches = branches;
+                this.otherwise = otherwise;
+              };
+              Case.parse = function parse22(args, context) {
+                if (args.length < 4) {
+                  return context.error("Expected at least 3 arguments, but found only " + (args.length - 1) + ".");
+                }
+                if (args.length % 2 !== 0) {
+                  return context.error("Expected an odd number of arguments.");
+                }
+                var outputType;
+                if (context.expectedType && context.expectedType.kind !== "value") {
+                  outputType = context.expectedType;
+                }
+                var branches = [];
+                for (var i2 = 1; i2 < args.length - 1; i2 += 2) {
+                  var test = context.parse(args[i2], i2, BooleanType);
+                  if (!test) {
+                    return null;
+                  }
+                  var result = context.parse(args[i2 + 1], i2 + 1, outputType);
+                  if (!result) {
+                    return null;
+                  }
+                  branches.push([
+                    test,
+                    result
+                  ]);
+                  outputType = outputType || result.type;
+                }
+                var otherwise = context.parse(args[args.length - 1], args.length - 1, outputType);
+                if (!otherwise) {
+                  return null;
+                }
+                return new Case(outputType, branches, otherwise);
+              };
+              Case.prototype.evaluate = function evaluate(ctx2) {
+                for (var i2 = 0, list = this.branches; i2 < list.length; i2 += 1) {
+                  var ref = list[i2];
+                  var test = ref[0];
+                  var expression2 = ref[1];
+                  if (test.evaluate(ctx2)) {
+                    return expression2.evaluate(ctx2);
+                  }
+                }
+                return this.otherwise.evaluate(ctx2);
+              };
+              Case.prototype.eachChild = function eachChild(fn) {
+                for (var i2 = 0, list = this.branches; i2 < list.length; i2 += 1) {
+                  var ref = list[i2];
+                  var test = ref[0];
+                  var expression2 = ref[1];
+                  fn(test);
+                  fn(expression2);
+                }
+                fn(this.otherwise);
+              };
+              Case.prototype.outputDefined = function outputDefined() {
+                return this.branches.every(function(ref) {
+                  ref[0];
+                  var out = ref[1];
+                  return out.outputDefined();
+                }) && this.otherwise.outputDefined();
+              };
+              Case.prototype.serialize = function serialize2() {
+                var serialized = ["case"];
+                this.eachChild(function(child) {
+                  serialized.push(child.serialize());
+                });
+                return serialized;
+              };
+              var Slice = function Slice2(type, input, beginIndex, endIndex) {
+                this.type = type;
+                this.input = input;
+                this.beginIndex = beginIndex;
+                this.endIndex = endIndex;
+              };
+              Slice.parse = function parse22(args, context) {
+                if (args.length <= 2 || args.length >= 5) {
+                  return context.error("Expected 3 or 4 arguments, but found " + (args.length - 1) + " instead.");
+                }
+                var input = context.parse(args[1], 1, ValueType);
+                var beginIndex = context.parse(args[2], 2, NumberType);
+                if (!input || !beginIndex) {
+                  return null;
+                }
+                if (!isValidType(input.type, [
+                  array(ValueType),
+                  StringType,
+                  ValueType
+                ])) {
+                  return context.error("Expected first argument to be of type array or string, but found " + toString(input.type) + " instead");
+                }
+                if (args.length === 4) {
+                  var endIndex = context.parse(args[3], 3, NumberType);
+                  if (!endIndex) {
+                    return null;
+                  }
+                  return new Slice(input.type, input, beginIndex, endIndex);
+                } else {
+                  return new Slice(input.type, input, beginIndex);
+                }
+              };
+              Slice.prototype.evaluate = function evaluate(ctx2) {
+                var input = this.input.evaluate(ctx2);
+                var beginIndex = this.beginIndex.evaluate(ctx2);
+                if (!isValidNativeType(input, [
+                  "string",
+                  "array"
+                ])) {
+                  throw new RuntimeError("Expected first argument to be of type array or string, but found " + toString(typeOf(input)) + " instead.");
+                }
+                if (this.endIndex) {
+                  var endIndex = this.endIndex.evaluate(ctx2);
+                  return input.slice(beginIndex, endIndex);
+                }
+                return input.slice(beginIndex);
+              };
+              Slice.prototype.eachChild = function eachChild(fn) {
+                fn(this.input);
+                fn(this.beginIndex);
+                if (this.endIndex) {
+                  fn(this.endIndex);
+                }
+              };
+              Slice.prototype.outputDefined = function outputDefined() {
+                return false;
+              };
+              Slice.prototype.serialize = function serialize2() {
+                if (this.endIndex != null && this.endIndex !== void 0) {
+                  var endIndex = this.endIndex.serialize();
+                  return [
+                    "slice",
+                    this.input.serialize(),
+                    this.beginIndex.serialize(),
+                    endIndex
+                  ];
+                }
+                return [
+                  "slice",
+                  this.input.serialize(),
+                  this.beginIndex.serialize()
+                ];
+              };
+              function isComparableType(op, type) {
+                if (op === "==" || op === "!=") {
+                  return type.kind === "boolean" || type.kind === "string" || type.kind === "number" || type.kind === "null" || type.kind === "value";
+                } else {
+                  return type.kind === "string" || type.kind === "number" || type.kind === "value";
+                }
+              }
+              function eq(ctx2, a2, b2) {
+                return a2 === b2;
+              }
+              function neq(ctx2, a2, b2) {
+                return a2 !== b2;
+              }
+              function lt2(ctx2, a2, b2) {
+                return a2 < b2;
+              }
+              function gt2(ctx2, a2, b2) {
+                return a2 > b2;
+              }
+              function lteq(ctx2, a2, b2) {
+                return a2 <= b2;
+              }
+              function gteq(ctx2, a2, b2) {
+                return a2 >= b2;
+              }
+              function eqCollate(ctx2, a2, b2, c2) {
+                return c2.compare(a2, b2) === 0;
+              }
+              function neqCollate(ctx2, a2, b2, c2) {
+                return !eqCollate(ctx2, a2, b2, c2);
+              }
+              function ltCollate(ctx2, a2, b2, c2) {
+                return c2.compare(a2, b2) < 0;
+              }
+              function gtCollate(ctx2, a2, b2, c2) {
+                return c2.compare(a2, b2) > 0;
+              }
+              function lteqCollate(ctx2, a2, b2, c2) {
+                return c2.compare(a2, b2) <= 0;
+              }
+              function gteqCollate(ctx2, a2, b2, c2) {
+                return c2.compare(a2, b2) >= 0;
+              }
+              function makeComparison(op, compareBasic, compareWithCollator) {
+                var isOrderComparison = op !== "==" && op !== "!=";
+                return function() {
+                  function Comparison(lhs, rhs, collator) {
+                    this.type = BooleanType;
+                    this.lhs = lhs;
+                    this.rhs = rhs;
+                    this.collator = collator;
+                    this.hasUntypedArgument = lhs.type.kind === "value" || rhs.type.kind === "value";
+                  }
+                  Comparison.parse = function parse22(args, context) {
+                    if (args.length !== 3 && args.length !== 4) {
+                      return context.error("Expected two or three arguments.");
+                    }
+                    var op2 = args[0];
+                    var lhs = context.parse(args[1], 1, ValueType);
+                    if (!lhs) {
+                      return null;
+                    }
+                    if (!isComparableType(op2, lhs.type)) {
+                      return context.concat(1).error('"' + op2 + `" comparisons are not supported for type '` + toString(lhs.type) + "'.");
+                    }
+                    var rhs = context.parse(args[2], 2, ValueType);
+                    if (!rhs) {
+                      return null;
+                    }
+                    if (!isComparableType(op2, rhs.type)) {
+                      return context.concat(2).error('"' + op2 + `" comparisons are not supported for type '` + toString(rhs.type) + "'.");
+                    }
+                    if (lhs.type.kind !== rhs.type.kind && lhs.type.kind !== "value" && rhs.type.kind !== "value") {
+                      return context.error("Cannot compare types '" + toString(lhs.type) + "' and '" + toString(rhs.type) + "'.");
+                    }
+                    if (isOrderComparison) {
+                      if (lhs.type.kind === "value" && rhs.type.kind !== "value") {
+                        lhs = new Assertion(rhs.type, [lhs]);
+                      } else if (lhs.type.kind !== "value" && rhs.type.kind === "value") {
+                        rhs = new Assertion(lhs.type, [rhs]);
+                      }
+                    }
+                    var collator = null;
+                    if (args.length === 4) {
+                      if (lhs.type.kind !== "string" && rhs.type.kind !== "string" && lhs.type.kind !== "value" && rhs.type.kind !== "value") {
+                        return context.error("Cannot use collator to compare non-string types.");
+                      }
+                      collator = context.parse(args[3], 3, CollatorType);
+                      if (!collator) {
+                        return null;
+                      }
+                    }
+                    return new Comparison(lhs, rhs, collator);
+                  };
+                  Comparison.prototype.evaluate = function evaluate(ctx2) {
+                    var lhs = this.lhs.evaluate(ctx2);
+                    var rhs = this.rhs.evaluate(ctx2);
+                    if (isOrderComparison && this.hasUntypedArgument) {
+                      var lt22 = typeOf(lhs);
+                      var rt2 = typeOf(rhs);
+                      if (lt22.kind !== rt2.kind || !(lt22.kind === "string" || lt22.kind === "number")) {
+                        throw new RuntimeError('Expected arguments for "' + op + '" to be (string, string) or (number, number), but found (' + lt22.kind + ", " + rt2.kind + ") instead.");
+                      }
+                    }
+                    if (this.collator && !isOrderComparison && this.hasUntypedArgument) {
+                      var lt$1 = typeOf(lhs);
+                      var rt$1 = typeOf(rhs);
+                      if (lt$1.kind !== "string" || rt$1.kind !== "string") {
+                        return compareBasic(ctx2, lhs, rhs);
+                      }
+                    }
+                    return this.collator ? compareWithCollator(ctx2, lhs, rhs, this.collator.evaluate(ctx2)) : compareBasic(ctx2, lhs, rhs);
+                  };
+                  Comparison.prototype.eachChild = function eachChild(fn) {
+                    fn(this.lhs);
+                    fn(this.rhs);
+                    if (this.collator) {
+                      fn(this.collator);
+                    }
+                  };
+                  Comparison.prototype.outputDefined = function outputDefined() {
+                    return true;
+                  };
+                  Comparison.prototype.serialize = function serialize2() {
+                    var serialized = [op];
+                    this.eachChild(function(child) {
+                      serialized.push(child.serialize());
+                    });
+                    return serialized;
+                  };
+                  return Comparison;
+                }();
+              }
+              var Equals = makeComparison("==", eq, eqCollate);
+              var NotEquals = makeComparison("!=", neq, neqCollate);
+              var LessThan = makeComparison("<", lt2, ltCollate);
+              var GreaterThan = makeComparison(">", gt2, gtCollate);
+              var LessThanOrEqual = makeComparison("<=", lteq, lteqCollate);
+              var GreaterThanOrEqual = makeComparison(">=", gteq, gteqCollate);
+              var NumberFormat = function NumberFormat2(number2, locale, currency, minFractionDigits, maxFractionDigits) {
+                this.type = StringType;
+                this.number = number2;
+                this.locale = locale;
+                this.currency = currency;
+                this.minFractionDigits = minFractionDigits;
+                this.maxFractionDigits = maxFractionDigits;
+              };
+              NumberFormat.parse = function parse22(args, context) {
+                if (args.length !== 3) {
+                  return context.error("Expected two arguments.");
+                }
+                var number2 = context.parse(args[1], 1, NumberType);
+                if (!number2) {
+                  return null;
+                }
+                var options = args[2];
+                if (typeof options !== "object" || Array.isArray(options)) {
+                  return context.error("NumberFormat options argument must be an object.");
+                }
+                var locale = null;
+                if (options["locale"]) {
+                  locale = context.parse(options["locale"], 1, StringType);
+                  if (!locale) {
+                    return null;
+                  }
+                }
+                var currency = null;
+                if (options["currency"]) {
+                  currency = context.parse(options["currency"], 1, StringType);
+                  if (!currency) {
+                    return null;
+                  }
+                }
+                var minFractionDigits = null;
+                if (options["min-fraction-digits"]) {
+                  minFractionDigits = context.parse(options["min-fraction-digits"], 1, NumberType);
+                  if (!minFractionDigits) {
+                    return null;
+                  }
+                }
+                var maxFractionDigits = null;
+                if (options["max-fraction-digits"]) {
+                  maxFractionDigits = context.parse(options["max-fraction-digits"], 1, NumberType);
+                  if (!maxFractionDigits) {
+                    return null;
+                  }
+                }
+                return new NumberFormat(number2, locale, currency, minFractionDigits, maxFractionDigits);
+              };
+              NumberFormat.prototype.evaluate = function evaluate(ctx2) {
+                return new Intl.NumberFormat(this.locale ? this.locale.evaluate(ctx2) : [], {
+                  style: this.currency ? "currency" : "decimal",
+                  currency: this.currency ? this.currency.evaluate(ctx2) : void 0,
+                  minimumFractionDigits: this.minFractionDigits ? this.minFractionDigits.evaluate(ctx2) : void 0,
+                  maximumFractionDigits: this.maxFractionDigits ? this.maxFractionDigits.evaluate(ctx2) : void 0
+                }).format(this.number.evaluate(ctx2));
+              };
+              NumberFormat.prototype.eachChild = function eachChild(fn) {
+                fn(this.number);
+                if (this.locale) {
+                  fn(this.locale);
+                }
+                if (this.currency) {
+                  fn(this.currency);
+                }
+                if (this.minFractionDigits) {
+                  fn(this.minFractionDigits);
+                }
+                if (this.maxFractionDigits) {
+                  fn(this.maxFractionDigits);
+                }
+              };
+              NumberFormat.prototype.outputDefined = function outputDefined() {
+                return false;
+              };
+              NumberFormat.prototype.serialize = function serialize2() {
+                var options = {};
+                if (this.locale) {
+                  options["locale"] = this.locale.serialize();
+                }
+                if (this.currency) {
+                  options["currency"] = this.currency.serialize();
+                }
+                if (this.minFractionDigits) {
+                  options["min-fraction-digits"] = this.minFractionDigits.serialize();
+                }
+                if (this.maxFractionDigits) {
+                  options["max-fraction-digits"] = this.maxFractionDigits.serialize();
+                }
+                return [
+                  "number-format",
+                  this.number.serialize(),
+                  options
+                ];
+              };
+              var Length = function Length2(input) {
+                this.type = NumberType;
+                this.input = input;
+              };
+              Length.parse = function parse22(args, context) {
+                if (args.length !== 2) {
+                  return context.error("Expected 1 argument, but found " + (args.length - 1) + " instead.");
+                }
+                var input = context.parse(args[1], 1);
+                if (!input) {
+                  return null;
+                }
+                if (input.type.kind !== "array" && input.type.kind !== "string" && input.type.kind !== "value") {
+                  return context.error("Expected argument of type string or array, but found " + toString(input.type) + " instead.");
+                }
+                return new Length(input);
+              };
+              Length.prototype.evaluate = function evaluate(ctx2) {
+                var input = this.input.evaluate(ctx2);
+                if (typeof input === "string") {
+                  return input.length;
+                } else if (Array.isArray(input)) {
+                  return input.length;
+                } else {
+                  throw new RuntimeError("Expected value to be of type string or array, but found " + toString(typeOf(input)) + " instead.");
+                }
+              };
+              Length.prototype.eachChild = function eachChild(fn) {
+                fn(this.input);
+              };
+              Length.prototype.outputDefined = function outputDefined() {
+                return false;
+              };
+              Length.prototype.serialize = function serialize2() {
+                var serialized = ["length"];
+                this.eachChild(function(child) {
+                  serialized.push(child.serialize());
+                });
+                return serialized;
+              };
+              var expressions = {
+                "==": Equals,
+                "!=": NotEquals,
+                ">": GreaterThan,
+                "<": LessThan,
+                ">=": GreaterThanOrEqual,
+                "<=": LessThanOrEqual,
+                "array": Assertion,
+                "at": At,
+                "boolean": Assertion,
+                "case": Case,
+                "coalesce": Coalesce,
+                "collator": CollatorExpression,
+                "format": FormatExpression,
+                "image": ImageExpression,
+                "in": In,
+                "index-of": IndexOf,
+                "interpolate": Interpolate,
+                "interpolate-hcl": Interpolate,
+                "interpolate-lab": Interpolate,
+                "length": Length,
+                "let": Let,
+                "literal": Literal,
+                "match": Match,
+                "number": Assertion,
+                "number-format": NumberFormat,
+                "object": Assertion,
+                "slice": Slice,
+                "step": Step,
+                "string": Assertion,
+                "to-boolean": Coercion,
+                "to-color": Coercion,
+                "to-number": Coercion,
+                "to-string": Coercion,
+                "var": Var,
+                "within": Within
+              };
+              function rgba3(ctx2, ref) {
+                var r2 = ref[0];
+                var g2 = ref[1];
+                var b2 = ref[2];
+                var a2 = ref[3];
+                r2 = r2.evaluate(ctx2);
+                g2 = g2.evaluate(ctx2);
+                b2 = b2.evaluate(ctx2);
+                var alpha = a2 ? a2.evaluate(ctx2) : 1;
+                var error2 = validateRGBA(r2, g2, b2, alpha);
+                if (error2) {
+                  throw new RuntimeError(error2);
+                }
+                return new Color2(r2 / 255 * alpha, g2 / 255 * alpha, b2 / 255 * alpha, alpha);
+              }
+              function has(key, obj) {
+                return key in obj;
+              }
+              function get(key, obj) {
+                var v2 = obj[key];
+                return typeof v2 === "undefined" ? null : v2;
+              }
+              function binarySearch2(v2, a2, i2, j2) {
+                while (i2 <= j2) {
+                  var m2 = i2 + j2 >> 1;
+                  if (a2[m2] === v2) {
+                    return true;
+                  }
+                  if (a2[m2] > v2) {
+                    j2 = m2 - 1;
+                  } else {
+                    i2 = m2 + 1;
+                  }
+                }
+                return false;
+              }
+              function varargs(type) {
+                return { type };
+              }
+              CompoundExpression.register(expressions, {
+                "error": [
+                  ErrorType,
+                  [StringType],
+                  function(ctx2, ref) {
+                    var v2 = ref[0];
+                    throw new RuntimeError(v2.evaluate(ctx2));
+                  }
+                ],
+                "typeof": [
+                  StringType,
+                  [ValueType],
+                  function(ctx2, ref) {
+                    var v2 = ref[0];
+                    return toString(typeOf(v2.evaluate(ctx2)));
+                  }
+                ],
+                "to-rgba": [
+                  array(NumberType, 4),
+                  [ColorType],
+                  function(ctx2, ref) {
+                    var v2 = ref[0];
+                    return v2.evaluate(ctx2).toArray();
+                  }
+                ],
+                "rgb": [
+                  ColorType,
+                  [
+                    NumberType,
+                    NumberType,
+                    NumberType
+                  ],
+                  rgba3
+                ],
+                "rgba": [
+                  ColorType,
+                  [
+                    NumberType,
+                    NumberType,
+                    NumberType,
+                    NumberType
+                  ],
+                  rgba3
+                ],
+                "has": {
+                  type: BooleanType,
+                  overloads: [
+                    [
+                      [StringType],
+                      function(ctx2, ref) {
+                        var key = ref[0];
+                        return has(key.evaluate(ctx2), ctx2.properties());
+                      }
+                    ],
+                    [
+                      [
+                        StringType,
+                        ObjectType
+                      ],
+                      function(ctx2, ref) {
+                        var key = ref[0];
+                        var obj = ref[1];
+                        return has(key.evaluate(ctx2), obj.evaluate(ctx2));
+                      }
+                    ]
+                  ]
+                },
+                "get": {
+                  type: ValueType,
+                  overloads: [
+                    [
+                      [StringType],
+                      function(ctx2, ref) {
+                        var key = ref[0];
+                        return get(key.evaluate(ctx2), ctx2.properties());
+                      }
+                    ],
+                    [
+                      [
+                        StringType,
+                        ObjectType
+                      ],
+                      function(ctx2, ref) {
+                        var key = ref[0];
+                        var obj = ref[1];
+                        return get(key.evaluate(ctx2), obj.evaluate(ctx2));
+                      }
+                    ]
+                  ]
+                },
+                "feature-state": [
+                  ValueType,
+                  [StringType],
+                  function(ctx2, ref) {
+                    var key = ref[0];
+                    return get(key.evaluate(ctx2), ctx2.featureState || {});
+                  }
+                ],
+                "properties": [
+                  ObjectType,
+                  [],
+                  function(ctx2) {
+                    return ctx2.properties();
+                  }
+                ],
+                "geometry-type": [
+                  StringType,
+                  [],
+                  function(ctx2) {
+                    return ctx2.geometryType();
+                  }
+                ],
+                "id": [
+                  ValueType,
+                  [],
+                  function(ctx2) {
+                    return ctx2.id();
+                  }
+                ],
+                "zoom": [
+                  NumberType,
+                  [],
+                  function(ctx2) {
+                    return ctx2.globals.zoom;
+                  }
+                ],
+                "heatmap-density": [
+                  NumberType,
+                  [],
+                  function(ctx2) {
+                    return ctx2.globals.heatmapDensity || 0;
+                  }
+                ],
+                "line-progress": [
+                  NumberType,
+                  [],
+                  function(ctx2) {
+                    return ctx2.globals.lineProgress || 0;
+                  }
+                ],
+                "accumulated": [
+                  ValueType,
+                  [],
+                  function(ctx2) {
+                    return ctx2.globals.accumulated === void 0 ? null : ctx2.globals.accumulated;
+                  }
+                ],
+                "+": [
+                  NumberType,
+                  varargs(NumberType),
+                  function(ctx2, args) {
+                    var result = 0;
+                    for (var i2 = 0, list = args; i2 < list.length; i2 += 1) {
+                      var arg = list[i2];
+                      result += arg.evaluate(ctx2);
+                    }
+                    return result;
+                  }
+                ],
+                "*": [
+                  NumberType,
+                  varargs(NumberType),
+                  function(ctx2, args) {
+                    var result = 1;
+                    for (var i2 = 0, list = args; i2 < list.length; i2 += 1) {
+                      var arg = list[i2];
+                      result *= arg.evaluate(ctx2);
+                    }
+                    return result;
+                  }
+                ],
+                "-": {
+                  type: NumberType,
+                  overloads: [
+                    [
+                      [
+                        NumberType,
+                        NumberType
+                      ],
+                      function(ctx2, ref) {
+                        var a2 = ref[0];
+                        var b2 = ref[1];
+                        return a2.evaluate(ctx2) - b2.evaluate(ctx2);
+                      }
+                    ],
+                    [
+                      [NumberType],
+                      function(ctx2, ref) {
+                        var a2 = ref[0];
+                        return -a2.evaluate(ctx2);
+                      }
+                    ]
+                  ]
+                },
+                "/": [
+                  NumberType,
+                  [
+                    NumberType,
+                    NumberType
+                  ],
+                  function(ctx2, ref) {
+                    var a2 = ref[0];
+                    var b2 = ref[1];
+                    return a2.evaluate(ctx2) / b2.evaluate(ctx2);
+                  }
+                ],
+                "%": [
+                  NumberType,
+                  [
+                    NumberType,
+                    NumberType
+                  ],
+                  function(ctx2, ref) {
+                    var a2 = ref[0];
+                    var b2 = ref[1];
+                    return a2.evaluate(ctx2) % b2.evaluate(ctx2);
+                  }
+                ],
+                "ln2": [
+                  NumberType,
+                  [],
+                  function() {
+                    return Math.LN2;
+                  }
+                ],
+                "pi": [
+                  NumberType,
+                  [],
+                  function() {
+                    return Math.PI;
+                  }
+                ],
+                "e": [
+                  NumberType,
+                  [],
+                  function() {
+                    return Math.E;
+                  }
+                ],
+                "^": [
+                  NumberType,
+                  [
+                    NumberType,
+                    NumberType
+                  ],
+                  function(ctx2, ref) {
+                    var b2 = ref[0];
+                    var e2 = ref[1];
+                    return Math.pow(b2.evaluate(ctx2), e2.evaluate(ctx2));
+                  }
+                ],
+                "sqrt": [
+                  NumberType,
+                  [NumberType],
+                  function(ctx2, ref) {
+                    var x2 = ref[0];
+                    return Math.sqrt(x2.evaluate(ctx2));
+                  }
+                ],
+                "log10": [
+                  NumberType,
+                  [NumberType],
+                  function(ctx2, ref) {
+                    var n2 = ref[0];
+                    return Math.log(n2.evaluate(ctx2)) / Math.LN10;
+                  }
+                ],
+                "ln": [
+                  NumberType,
+                  [NumberType],
+                  function(ctx2, ref) {
+                    var n2 = ref[0];
+                    return Math.log(n2.evaluate(ctx2));
+                  }
+                ],
+                "log2": [
+                  NumberType,
+                  [NumberType],
+                  function(ctx2, ref) {
+                    var n2 = ref[0];
+                    return Math.log(n2.evaluate(ctx2)) / Math.LN2;
+                  }
+                ],
+                "sin": [
+                  NumberType,
+                  [NumberType],
+                  function(ctx2, ref) {
+                    var n2 = ref[0];
+                    return Math.sin(n2.evaluate(ctx2));
+                  }
+                ],
+                "cos": [
+                  NumberType,
+                  [NumberType],
+                  function(ctx2, ref) {
+                    var n2 = ref[0];
+                    return Math.cos(n2.evaluate(ctx2));
+                  }
+                ],
+                "tan": [
+                  NumberType,
+                  [NumberType],
+                  function(ctx2, ref) {
+                    var n2 = ref[0];
+                    return Math.tan(n2.evaluate(ctx2));
+                  }
+                ],
+                "asin": [
+                  NumberType,
+                  [NumberType],
+                  function(ctx2, ref) {
+                    var n2 = ref[0];
+                    return Math.asin(n2.evaluate(ctx2));
+                  }
+                ],
+                "acos": [
+                  NumberType,
+                  [NumberType],
+                  function(ctx2, ref) {
+                    var n2 = ref[0];
+                    return Math.acos(n2.evaluate(ctx2));
+                  }
+                ],
+                "atan": [
+                  NumberType,
+                  [NumberType],
+                  function(ctx2, ref) {
+                    var n2 = ref[0];
+                    return Math.atan(n2.evaluate(ctx2));
+                  }
+                ],
+                "min": [
+                  NumberType,
+                  varargs(NumberType),
+                  function(ctx2, args) {
+                    return Math.min.apply(Math, args.map(function(arg) {
+                      return arg.evaluate(ctx2);
+                    }));
+                  }
+                ],
+                "max": [
+                  NumberType,
+                  varargs(NumberType),
+                  function(ctx2, args) {
+                    return Math.max.apply(Math, args.map(function(arg) {
+                      return arg.evaluate(ctx2);
+                    }));
+                  }
+                ],
+                "abs": [
+                  NumberType,
+                  [NumberType],
+                  function(ctx2, ref) {
+                    var n2 = ref[0];
+                    return Math.abs(n2.evaluate(ctx2));
+                  }
+                ],
+                "round": [
+                  NumberType,
+                  [NumberType],
+                  function(ctx2, ref) {
+                    var n2 = ref[0];
+                    var v2 = n2.evaluate(ctx2);
+                    return v2 < 0 ? -Math.round(-v2) : Math.round(v2);
+                  }
+                ],
+                "floor": [
+                  NumberType,
+                  [NumberType],
+                  function(ctx2, ref) {
+                    var n2 = ref[0];
+                    return Math.floor(n2.evaluate(ctx2));
+                  }
+                ],
+                "ceil": [
+                  NumberType,
+                  [NumberType],
+                  function(ctx2, ref) {
+                    var n2 = ref[0];
+                    return Math.ceil(n2.evaluate(ctx2));
+                  }
+                ],
+                "filter-==": [
+                  BooleanType,
+                  [
+                    StringType,
+                    ValueType
+                  ],
+                  function(ctx2, ref) {
+                    var k2 = ref[0];
+                    var v2 = ref[1];
+                    return ctx2.properties()[k2.value] === v2.value;
+                  }
+                ],
+                "filter-id-==": [
+                  BooleanType,
+                  [ValueType],
+                  function(ctx2, ref) {
+                    var v2 = ref[0];
+                    return ctx2.id() === v2.value;
+                  }
+                ],
+                "filter-type-==": [
+                  BooleanType,
+                  [StringType],
+                  function(ctx2, ref) {
+                    var v2 = ref[0];
+                    return ctx2.geometryType() === v2.value;
+                  }
+                ],
+                "filter-<": [
+                  BooleanType,
+                  [
+                    StringType,
+                    ValueType
+                  ],
+                  function(ctx2, ref) {
+                    var k2 = ref[0];
+                    var v2 = ref[1];
+                    var a2 = ctx2.properties()[k2.value];
+                    var b2 = v2.value;
+                    return typeof a2 === typeof b2 && a2 < b2;
+                  }
+                ],
+                "filter-id-<": [
+                  BooleanType,
+                  [ValueType],
+                  function(ctx2, ref) {
+                    var v2 = ref[0];
+                    var a2 = ctx2.id();
+                    var b2 = v2.value;
+                    return typeof a2 === typeof b2 && a2 < b2;
+                  }
+                ],
+                "filter->": [
+                  BooleanType,
+                  [
+                    StringType,
+                    ValueType
+                  ],
+                  function(ctx2, ref) {
+                    var k2 = ref[0];
+                    var v2 = ref[1];
+                    var a2 = ctx2.properties()[k2.value];
+                    var b2 = v2.value;
+                    return typeof a2 === typeof b2 && a2 > b2;
+                  }
+                ],
+                "filter-id->": [
+                  BooleanType,
+                  [ValueType],
+                  function(ctx2, ref) {
+                    var v2 = ref[0];
+                    var a2 = ctx2.id();
+                    var b2 = v2.value;
+                    return typeof a2 === typeof b2 && a2 > b2;
+                  }
+                ],
+                "filter-<=": [
+                  BooleanType,
+                  [
+                    StringType,
+                    ValueType
+                  ],
+                  function(ctx2, ref) {
+                    var k2 = ref[0];
+                    var v2 = ref[1];
+                    var a2 = ctx2.properties()[k2.value];
+                    var b2 = v2.value;
+                    return typeof a2 === typeof b2 && a2 <= b2;
+                  }
+                ],
+                "filter-id-<=": [
+                  BooleanType,
+                  [ValueType],
+                  function(ctx2, ref) {
+                    var v2 = ref[0];
+                    var a2 = ctx2.id();
+                    var b2 = v2.value;
+                    return typeof a2 === typeof b2 && a2 <= b2;
+                  }
+                ],
+                "filter->=": [
+                  BooleanType,
+                  [
+                    StringType,
+                    ValueType
+                  ],
+                  function(ctx2, ref) {
+                    var k2 = ref[0];
+                    var v2 = ref[1];
+                    var a2 = ctx2.properties()[k2.value];
+                    var b2 = v2.value;
+                    return typeof a2 === typeof b2 && a2 >= b2;
+                  }
+                ],
+                "filter-id->=": [
+                  BooleanType,
+                  [ValueType],
+                  function(ctx2, ref) {
+                    var v2 = ref[0];
+                    var a2 = ctx2.id();
+                    var b2 = v2.value;
+                    return typeof a2 === typeof b2 && a2 >= b2;
+                  }
+                ],
+                "filter-has": [
+                  BooleanType,
+                  [ValueType],
+                  function(ctx2, ref) {
+                    var k2 = ref[0];
+                    return k2.value in ctx2.properties();
+                  }
+                ],
+                "filter-has-id": [
+                  BooleanType,
+                  [],
+                  function(ctx2) {
+                    return ctx2.id() !== null && ctx2.id() !== void 0;
+                  }
+                ],
+                "filter-type-in": [
+                  BooleanType,
+                  [array(StringType)],
+                  function(ctx2, ref) {
+                    var v2 = ref[0];
+                    return v2.value.indexOf(ctx2.geometryType()) >= 0;
+                  }
+                ],
+                "filter-id-in": [
+                  BooleanType,
+                  [array(ValueType)],
+                  function(ctx2, ref) {
+                    var v2 = ref[0];
+                    return v2.value.indexOf(ctx2.id()) >= 0;
+                  }
+                ],
+                "filter-in-small": [
+                  BooleanType,
+                  [
+                    StringType,
+                    array(ValueType)
+                  ],
+                  function(ctx2, ref) {
+                    var k2 = ref[0];
+                    var v2 = ref[1];
+                    return v2.value.indexOf(ctx2.properties()[k2.value]) >= 0;
+                  }
+                ],
+                "filter-in-large": [
+                  BooleanType,
+                  [
+                    StringType,
+                    array(ValueType)
+                  ],
+                  function(ctx2, ref) {
+                    var k2 = ref[0];
+                    var v2 = ref[1];
+                    return binarySearch2(ctx2.properties()[k2.value], v2.value, 0, v2.value.length - 1);
+                  }
+                ],
+                "all": {
+                  type: BooleanType,
+                  overloads: [
+                    [
+                      [
+                        BooleanType,
+                        BooleanType
+                      ],
+                      function(ctx2, ref) {
+                        var a2 = ref[0];
+                        var b2 = ref[1];
+                        return a2.evaluate(ctx2) && b2.evaluate(ctx2);
+                      }
+                    ],
+                    [
+                      varargs(BooleanType),
+                      function(ctx2, args) {
+                        for (var i2 = 0, list = args; i2 < list.length; i2 += 1) {
+                          var arg = list[i2];
+                          if (!arg.evaluate(ctx2)) {
+                            return false;
+                          }
+                        }
+                        return true;
+                      }
+                    ]
+                  ]
+                },
+                "any": {
+                  type: BooleanType,
+                  overloads: [
+                    [
+                      [
+                        BooleanType,
+                        BooleanType
+                      ],
+                      function(ctx2, ref) {
+                        var a2 = ref[0];
+                        var b2 = ref[1];
+                        return a2.evaluate(ctx2) || b2.evaluate(ctx2);
+                      }
+                    ],
+                    [
+                      varargs(BooleanType),
+                      function(ctx2, args) {
+                        for (var i2 = 0, list = args; i2 < list.length; i2 += 1) {
+                          var arg = list[i2];
+                          if (arg.evaluate(ctx2)) {
+                            return true;
+                          }
+                        }
+                        return false;
+                      }
+                    ]
+                  ]
+                },
+                "!": [
+                  BooleanType,
+                  [BooleanType],
+                  function(ctx2, ref) {
+                    var b2 = ref[0];
+                    return !b2.evaluate(ctx2);
+                  }
+                ],
+                "is-supported-script": [
+                  BooleanType,
+                  [StringType],
+                  function(ctx2, ref) {
+                    var s2 = ref[0];
+                    var isSupportedScript = ctx2.globals && ctx2.globals.isSupportedScript;
+                    if (isSupportedScript) {
+                      return isSupportedScript(s2.evaluate(ctx2));
+                    }
+                    return true;
+                  }
+                ],
+                "upcase": [
+                  StringType,
+                  [StringType],
+                  function(ctx2, ref) {
+                    var s2 = ref[0];
+                    return s2.evaluate(ctx2).toUpperCase();
+                  }
+                ],
+                "downcase": [
+                  StringType,
+                  [StringType],
+                  function(ctx2, ref) {
+                    var s2 = ref[0];
+                    return s2.evaluate(ctx2).toLowerCase();
+                  }
+                ],
+                "concat": [
+                  StringType,
+                  varargs(ValueType),
+                  function(ctx2, args) {
+                    return args.map(function(arg) {
+                      return toString$1(arg.evaluate(ctx2));
+                    }).join("");
+                  }
+                ],
+                "resolved-locale": [
+                  StringType,
+                  [CollatorType],
+                  function(ctx2, ref) {
+                    var collator = ref[0];
+                    return collator.evaluate(ctx2).resolvedLocale();
+                  }
+                ]
+              });
+              function success(value) {
+                return {
+                  result: "success",
+                  value
+                };
+              }
+              function error(value) {
+                return {
+                  result: "error",
+                  value
+                };
+              }
+              function supportsPropertyExpression(spec2) {
+                return spec2["property-type"] === "data-driven" || spec2["property-type"] === "cross-faded-data-driven";
+              }
+              function supportsZoomExpression(spec2) {
+                return !!spec2.expression && spec2.expression.parameters.indexOf("zoom") > -1;
+              }
+              function supportsInterpolation(spec2) {
+                return !!spec2.expression && spec2.expression.interpolated;
+              }
+              function getType2(val) {
+                if (val instanceof Number) {
+                  return "number";
+                } else if (val instanceof String) {
+                  return "string";
+                } else if (val instanceof Boolean) {
+                  return "boolean";
+                } else if (Array.isArray(val)) {
+                  return "array";
+                } else if (val === null) {
+                  return "null";
+                } else {
+                  return typeof val;
+                }
+              }
+              function isFunction2(value) {
+                return typeof value === "object" && value !== null && !Array.isArray(value);
+              }
+              function identityFunction(x2) {
+                return x2;
+              }
+              function createFunction(parameters, propertySpec) {
+                var isColor = propertySpec.type === "color";
+                var zoomAndFeatureDependent = parameters.stops && typeof parameters.stops[0][0] === "object";
+                var featureDependent = zoomAndFeatureDependent || parameters.property !== void 0;
+                var zoomDependent = zoomAndFeatureDependent || !featureDependent;
+                var type = parameters.type || (supportsInterpolation(propertySpec) ? "exponential" : "interval");
+                if (isColor) {
+                  parameters = extend$1({}, parameters);
+                  if (parameters.stops) {
+                    parameters.stops = parameters.stops.map(function(stop2) {
+                      return [
+                        stop2[0],
+                        Color2.parse(stop2[1])
+                      ];
+                    });
+                  }
+                  if (parameters.default) {
+                    parameters.default = Color2.parse(parameters.default);
+                  } else {
+                    parameters.default = Color2.parse(propertySpec.default);
+                  }
+                }
+                if (parameters.colorSpace && parameters.colorSpace !== "rgb" && !colorSpaces[parameters.colorSpace]) {
+                  throw new Error("Unknown color space: " + parameters.colorSpace);
+                }
+                var innerFun;
+                var hashedStops;
+                var categoricalKeyType;
+                if (type === "exponential") {
+                  innerFun = evaluateExponentialFunction;
+                } else if (type === "interval") {
+                  innerFun = evaluateIntervalFunction;
+                } else if (type === "categorical") {
+                  innerFun = evaluateCategoricalFunction;
+                  hashedStops = /* @__PURE__ */ Object.create(null);
+                  for (var i2 = 0, list = parameters.stops; i2 < list.length; i2 += 1) {
+                    var stop = list[i2];
+                    hashedStops[stop[0]] = stop[1];
+                  }
+                  categoricalKeyType = typeof parameters.stops[0][0];
+                } else if (type === "identity") {
+                  innerFun = evaluateIdentityFunction;
+                } else {
+                  throw new Error('Unknown function type "' + type + '"');
+                }
+                if (zoomAndFeatureDependent) {
+                  var featureFunctions = {};
+                  var zoomStops = [];
+                  for (var s2 = 0; s2 < parameters.stops.length; s2++) {
+                    var stop$1 = parameters.stops[s2];
+                    var zoom = stop$1[0].zoom;
+                    if (featureFunctions[zoom] === void 0) {
+                      featureFunctions[zoom] = {
+                        zoom,
+                        type: parameters.type,
+                        property: parameters.property,
+                        default: parameters.default,
+                        stops: []
+                      };
+                      zoomStops.push(zoom);
+                    }
+                    featureFunctions[zoom].stops.push([
+                      stop$1[0].value,
+                      stop$1[1]
+                    ]);
+                  }
+                  var featureFunctionStops = [];
+                  for (var i$1 = 0, list$1 = zoomStops; i$1 < list$1.length; i$1 += 1) {
+                    var z2 = list$1[i$1];
+                    featureFunctionStops.push([
+                      featureFunctions[z2].zoom,
+                      createFunction(featureFunctions[z2], propertySpec)
+                    ]);
+                  }
+                  var interpolationType = { name: "linear" };
+                  return {
+                    kind: "composite",
+                    interpolationType,
+                    interpolationFactor: Interpolate.interpolationFactor.bind(void 0, interpolationType),
+                    zoomStops: featureFunctionStops.map(function(s22) {
+                      return s22[0];
+                    }),
+                    evaluate: function evaluate(ref, properties2) {
+                      var zoom2 = ref.zoom;
+                      return evaluateExponentialFunction({
+                        stops: featureFunctionStops,
+                        base: parameters.base
+                      }, propertySpec, zoom2).evaluate(zoom2, properties2);
+                    }
+                  };
+                } else if (zoomDependent) {
+                  var interpolationType$1 = type === "exponential" ? {
+                    name: "exponential",
+                    base: parameters.base !== void 0 ? parameters.base : 1
+                  } : null;
+                  return {
+                    kind: "camera",
+                    interpolationType: interpolationType$1,
+                    interpolationFactor: Interpolate.interpolationFactor.bind(void 0, interpolationType$1),
+                    zoomStops: parameters.stops.map(function(s22) {
+                      return s22[0];
+                    }),
+                    evaluate: function(ref) {
+                      var zoom2 = ref.zoom;
+                      return innerFun(parameters, propertySpec, zoom2, hashedStops, categoricalKeyType);
+                    }
+                  };
+                } else {
+                  return {
+                    kind: "source",
+                    evaluate: function evaluate(_2, feature) {
+                      var value = feature && feature.properties ? feature.properties[parameters.property] : void 0;
+                      if (value === void 0) {
+                        return coalesce(parameters.default, propertySpec.default);
+                      }
+                      return innerFun(parameters, propertySpec, value, hashedStops, categoricalKeyType);
+                    }
+                  };
+                }
+              }
+              function coalesce(a2, b2, c2) {
+                if (a2 !== void 0) {
+                  return a2;
+                }
+                if (b2 !== void 0) {
+                  return b2;
+                }
+                if (c2 !== void 0) {
+                  return c2;
+                }
+              }
+              function evaluateCategoricalFunction(parameters, propertySpec, input, hashedStops, keyType) {
+                var evaluated = typeof input === keyType ? hashedStops[input] : void 0;
+                return coalesce(evaluated, parameters.default, propertySpec.default);
+              }
+              function evaluateIntervalFunction(parameters, propertySpec, input) {
+                if (getType2(input) !== "number") {
+                  return coalesce(parameters.default, propertySpec.default);
+                }
+                var n2 = parameters.stops.length;
+                if (n2 === 1) {
+                  return parameters.stops[0][1];
+                }
+                if (input <= parameters.stops[0][0]) {
+                  return parameters.stops[0][1];
+                }
+                if (input >= parameters.stops[n2 - 1][0]) {
+                  return parameters.stops[n2 - 1][1];
+                }
+                var index = findStopLessThanOrEqualTo(parameters.stops.map(function(stop) {
+                  return stop[0];
+                }), input);
+                return parameters.stops[index][1];
+              }
+              function evaluateExponentialFunction(parameters, propertySpec, input) {
+                var base = parameters.base !== void 0 ? parameters.base : 1;
+                if (getType2(input) !== "number") {
+                  return coalesce(parameters.default, propertySpec.default);
+                }
+                var n2 = parameters.stops.length;
+                if (n2 === 1) {
+                  return parameters.stops[0][1];
+                }
+                if (input <= parameters.stops[0][0]) {
+                  return parameters.stops[0][1];
+                }
+                if (input >= parameters.stops[n2 - 1][0]) {
+                  return parameters.stops[n2 - 1][1];
+                }
+                var index = findStopLessThanOrEqualTo(parameters.stops.map(function(stop) {
+                  return stop[0];
+                }), input);
+                var t4 = interpolationFactor(input, base, parameters.stops[index][0], parameters.stops[index + 1][0]);
+                var outputLower = parameters.stops[index][1];
+                var outputUpper = parameters.stops[index + 1][1];
+                var interp = interpolate[propertySpec.type] || identityFunction;
+                if (parameters.colorSpace && parameters.colorSpace !== "rgb") {
+                  var colorspace = colorSpaces[parameters.colorSpace];
+                  interp = function(a2, b2) {
+                    return colorspace.reverse(colorspace.interpolate(colorspace.forward(a2), colorspace.forward(b2), t4));
+                  };
+                }
+                if (typeof outputLower.evaluate === "function") {
+                  return {
+                    evaluate: function evaluate() {
+                      var args = [], len2 = arguments.length;
+                      while (len2--)
+                        args[len2] = arguments[len2];
+                      var evaluatedLower = outputLower.evaluate.apply(void 0, args);
+                      var evaluatedUpper = outputUpper.evaluate.apply(void 0, args);
+                      if (evaluatedLower === void 0 || evaluatedUpper === void 0) {
+                        return void 0;
+                      }
+                      return interp(evaluatedLower, evaluatedUpper, t4);
+                    }
+                  };
+                }
+                return interp(outputLower, outputUpper, t4);
+              }
+              function evaluateIdentityFunction(parameters, propertySpec, input) {
+                if (propertySpec.type === "color") {
+                  input = Color2.parse(input);
+                } else if (propertySpec.type === "formatted") {
+                  input = Formatted.fromString(input.toString());
+                } else if (propertySpec.type === "resolvedImage") {
+                  input = ResolvedImage.fromString(input.toString());
+                } else if (getType2(input) !== propertySpec.type && (propertySpec.type !== "enum" || !propertySpec.values[input])) {
+                  input = void 0;
+                }
+                return coalesce(input, parameters.default, propertySpec.default);
+              }
+              function interpolationFactor(input, base, lowerValue, upperValue) {
+                var difference = upperValue - lowerValue;
+                var progress = input - lowerValue;
+                if (difference === 0) {
+                  return 0;
+                } else if (base === 1) {
+                  return progress / difference;
+                } else {
+                  return (Math.pow(base, progress) - 1) / (Math.pow(base, difference) - 1);
+                }
+              }
+              var StyleExpression = function StyleExpression2(expression2, propertySpec) {
+                this.expression = expression2;
+                this._warningHistory = {};
+                this._evaluator = new EvaluationContext();
+                this._defaultValue = propertySpec ? getDefaultValue(propertySpec) : null;
+                this._enumValues = propertySpec && propertySpec.type === "enum" ? propertySpec.values : null;
+              };
+              StyleExpression.prototype.evaluateWithoutErrorHandling = function evaluateWithoutErrorHandling(globals, feature, featureState, canonical, availableImages, formattedSection) {
+                this._evaluator.globals = globals;
+                this._evaluator.feature = feature;
+                this._evaluator.featureState = featureState;
+                this._evaluator.canonical = canonical;
+                this._evaluator.availableImages = availableImages || null;
+                this._evaluator.formattedSection = formattedSection;
+                return this.expression.evaluate(this._evaluator);
+              };
+              StyleExpression.prototype.evaluate = function evaluate(globals, feature, featureState, canonical, availableImages, formattedSection) {
+                this._evaluator.globals = globals;
+                this._evaluator.feature = feature || null;
+                this._evaluator.featureState = featureState || null;
+                this._evaluator.canonical = canonical;
+                this._evaluator.availableImages = availableImages || null;
+                this._evaluator.formattedSection = formattedSection || null;
+                try {
+                  var val = this.expression.evaluate(this._evaluator);
+                  if (val === null || val === void 0 || typeof val === "number" && val !== val) {
+                    return this._defaultValue;
+                  }
+                  if (this._enumValues && !(val in this._enumValues)) {
+                    throw new RuntimeError("Expected value to be one of " + Object.keys(this._enumValues).map(function(v2) {
+                      return JSON.stringify(v2);
+                    }).join(", ") + ", but found " + JSON.stringify(val) + " instead.");
+                  }
+                  return val;
+                } catch (e2) {
+                  if (!this._warningHistory[e2.message]) {
+                    this._warningHistory[e2.message] = true;
+                    if (typeof console !== "undefined") {
+                      console.warn(e2.message);
+                    }
+                  }
+                  return this._defaultValue;
+                }
+              };
+              function isExpression(expression2) {
+                return Array.isArray(expression2) && expression2.length > 0 && typeof expression2[0] === "string" && expression2[0] in expressions;
+              }
+              function createExpression(expression2, propertySpec) {
+                var parser = new ParsingContext(expressions, [], propertySpec ? getExpectedType(propertySpec) : void 0);
+                var parsed = parser.parse(expression2, void 0, void 0, void 0, propertySpec && propertySpec.type === "string" ? { typeAnnotation: "coerce" } : void 0);
+                if (!parsed) {
+                  return error(parser.errors);
+                }
+                return success(new StyleExpression(parsed, propertySpec));
+              }
+              var ZoomConstantExpression = function ZoomConstantExpression2(kind, expression2) {
+                this.kind = kind;
+                this._styleExpression = expression2;
+                this.isStateDependent = kind !== "constant" && !isStateConstant(expression2.expression);
+              };
+              ZoomConstantExpression.prototype.evaluateWithoutErrorHandling = function evaluateWithoutErrorHandling(globals, feature, featureState, canonical, availableImages, formattedSection) {
+                return this._styleExpression.evaluateWithoutErrorHandling(globals, feature, featureState, canonical, availableImages, formattedSection);
+              };
+              ZoomConstantExpression.prototype.evaluate = function evaluate(globals, feature, featureState, canonical, availableImages, formattedSection) {
+                return this._styleExpression.evaluate(globals, feature, featureState, canonical, availableImages, formattedSection);
+              };
+              var ZoomDependentExpression = function ZoomDependentExpression2(kind, expression2, zoomStops, interpolationType) {
+                this.kind = kind;
+                this.zoomStops = zoomStops;
+                this._styleExpression = expression2;
+                this.isStateDependent = kind !== "camera" && !isStateConstant(expression2.expression);
+                this.interpolationType = interpolationType;
+              };
+              ZoomDependentExpression.prototype.evaluateWithoutErrorHandling = function evaluateWithoutErrorHandling(globals, feature, featureState, canonical, availableImages, formattedSection) {
+                return this._styleExpression.evaluateWithoutErrorHandling(globals, feature, featureState, canonical, availableImages, formattedSection);
+              };
+              ZoomDependentExpression.prototype.evaluate = function evaluate(globals, feature, featureState, canonical, availableImages, formattedSection) {
+                return this._styleExpression.evaluate(globals, feature, featureState, canonical, availableImages, formattedSection);
+              };
+              ZoomDependentExpression.prototype.interpolationFactor = function interpolationFactor2(input, lower, upper) {
+                if (this.interpolationType) {
+                  return Interpolate.interpolationFactor(this.interpolationType, input, lower, upper);
+                } else {
+                  return 0;
+                }
+              };
+              function createPropertyExpression(expression2, propertySpec) {
+                expression2 = createExpression(expression2, propertySpec);
+                if (expression2.result === "error") {
+                  return expression2;
+                }
+                var parsed = expression2.value.expression;
+                var isFeatureConstant$1 = isFeatureConstant(parsed);
+                if (!isFeatureConstant$1 && !supportsPropertyExpression(propertySpec)) {
+                  return error([new ParsingError("", "data expressions not supported")]);
+                }
+                var isZoomConstant = isGlobalPropertyConstant(parsed, ["zoom"]);
+                if (!isZoomConstant && !supportsZoomExpression(propertySpec)) {
+                  return error([new ParsingError("", "zoom expressions not supported")]);
+                }
+                var zoomCurve = findZoomCurve(parsed);
+                if (!zoomCurve && !isZoomConstant) {
+                  return error([new ParsingError("", '"zoom" expression may only be used as input to a top-level "step" or "interpolate" expression.')]);
+                } else if (zoomCurve instanceof ParsingError) {
+                  return error([zoomCurve]);
+                } else if (zoomCurve instanceof Interpolate && !supportsInterpolation(propertySpec)) {
+                  return error([new ParsingError("", '"interpolate" expressions cannot be used with this property')]);
+                }
+                if (!zoomCurve) {
+                  return success(isFeatureConstant$1 ? new ZoomConstantExpression("constant", expression2.value) : new ZoomConstantExpression("source", expression2.value));
+                }
+                var interpolationType = zoomCurve instanceof Interpolate ? zoomCurve.interpolation : void 0;
+                return success(isFeatureConstant$1 ? new ZoomDependentExpression("camera", expression2.value, zoomCurve.labels, interpolationType) : new ZoomDependentExpression("composite", expression2.value, zoomCurve.labels, interpolationType));
+              }
+              var StylePropertyFunction = function StylePropertyFunction2(parameters, specification) {
+                this._parameters = parameters;
+                this._specification = specification;
+                extend$1(this, createFunction(this._parameters, this._specification));
+              };
+              StylePropertyFunction.deserialize = function deserialize2(serialized) {
+                return new StylePropertyFunction(serialized._parameters, serialized._specification);
+              };
+              StylePropertyFunction.serialize = function serialize2(input) {
+                return {
+                  _parameters: input._parameters,
+                  _specification: input._specification
+                };
+              };
+              function normalizePropertyExpression(value, specification) {
+                if (isFunction2(value)) {
+                  return new StylePropertyFunction(value, specification);
+                } else if (isExpression(value)) {
+                  var expression2 = createPropertyExpression(value, specification);
+                  if (expression2.result === "error") {
+                    throw new Error(expression2.value.map(function(err) {
+                      return err.key + ": " + err.message;
+                    }).join(", "));
+                  }
+                  return expression2.value;
+                } else {
+                  var constant = value;
+                  if (typeof value === "string" && specification.type === "color") {
+                    constant = Color2.parse(value);
+                  }
+                  return {
+                    kind: "constant",
+                    evaluate: function() {
+                      return constant;
+                    }
+                  };
+                }
+              }
+              function findZoomCurve(expression2) {
+                var result = null;
+                if (expression2 instanceof Let) {
+                  result = findZoomCurve(expression2.result);
+                } else if (expression2 instanceof Coalesce) {
+                  for (var i2 = 0, list = expression2.args; i2 < list.length; i2 += 1) {
+                    var arg = list[i2];
+                    result = findZoomCurve(arg);
+                    if (result) {
+                      break;
+                    }
+                  }
+                } else if ((expression2 instanceof Step || expression2 instanceof Interpolate) && expression2.input instanceof CompoundExpression && expression2.input.name === "zoom") {
+                  result = expression2;
+                }
+                if (result instanceof ParsingError) {
+                  return result;
+                }
+                expression2.eachChild(function(child) {
+                  var childResult = findZoomCurve(child);
+                  if (childResult instanceof ParsingError) {
+                    result = childResult;
+                  } else if (!result && childResult) {
+                    result = new ParsingError("", '"zoom" expression may only be used as input to a top-level "step" or "interpolate" expression.');
+                  } else if (result && childResult && result !== childResult) {
+                    result = new ParsingError("", 'Only one zoom-based "step" or "interpolate" subexpression may be used in an expression.');
+                  }
+                });
+                return result;
+              }
+              function getExpectedType(spec2) {
+                var types2 = {
+                  color: ColorType,
+                  string: StringType,
+                  number: NumberType,
+                  enum: StringType,
+                  boolean: BooleanType,
+                  formatted: FormattedType,
+                  resolvedImage: ResolvedImageType
+                };
+                if (spec2.type === "array") {
+                  return array(types2[spec2.value] || ValueType, spec2.length);
+                }
+                return types2[spec2.type];
+              }
+              function getDefaultValue(spec2) {
+                if (spec2.type === "color" && isFunction2(spec2.default)) {
+                  return new Color2(0, 0, 0, 0);
+                } else if (spec2.type === "color") {
+                  return Color2.parse(spec2.default) || null;
+                } else if (spec2.default === void 0) {
+                  return null;
+                } else {
+                  return spec2.default;
+                }
+              }
+              function validateObject(options) {
+                var key = options.key;
+                var object = options.value;
+                var elementSpecs = options.valueSpec || {};
+                var elementValidators = options.objectElementValidators || {};
+                var style = options.style;
+                var styleSpec = options.styleSpec;
+                var errors = [];
+                var type = getType2(object);
+                if (type !== "object") {
+                  return [new ValidationError(key, object, "object expected, " + type + " found")];
+                }
+                for (var objectKey in object) {
+                  var elementSpecKey = objectKey.split(".")[0];
+                  var elementSpec = elementSpecs[elementSpecKey] || elementSpecs["*"];
+                  var validateElement = void 0;
+                  if (elementValidators[elementSpecKey]) {
+                    validateElement = elementValidators[elementSpecKey];
+                  } else if (elementSpecs[elementSpecKey]) {
+                    validateElement = validate;
+                  } else if (elementValidators["*"]) {
+                    validateElement = elementValidators["*"];
+                  } else if (elementSpecs["*"]) {
+                    validateElement = validate;
+                  } else {
+                    errors.push(new ValidationError(key, object[objectKey], 'unknown property "' + objectKey + '"'));
+                    continue;
+                  }
+                  errors = errors.concat(validateElement({
+                    key: (key ? key + "." : key) + objectKey,
+                    value: object[objectKey],
+                    valueSpec: elementSpec,
+                    style,
+                    styleSpec,
+                    object,
+                    objectKey
+                  }, object));
+                }
+                for (var elementSpecKey$1 in elementSpecs) {
+                  if (elementValidators[elementSpecKey$1]) {
+                    continue;
+                  }
+                  if (elementSpecs[elementSpecKey$1].required && elementSpecs[elementSpecKey$1]["default"] === void 0 && object[elementSpecKey$1] === void 0) {
+                    errors.push(new ValidationError(key, object, 'missing required property "' + elementSpecKey$1 + '"'));
+                  }
+                }
+                return errors;
+              }
+              function validateArray(options) {
+                var array2 = options.value;
+                var arraySpec = options.valueSpec;
+                var style = options.style;
+                var styleSpec = options.styleSpec;
+                var key = options.key;
+                var validateArrayElement = options.arrayElementValidator || validate;
+                if (getType2(array2) !== "array") {
+                  return [new ValidationError(key, array2, "array expected, " + getType2(array2) + " found")];
+                }
+                if (arraySpec.length && array2.length !== arraySpec.length) {
+                  return [new ValidationError(key, array2, "array length " + arraySpec.length + " expected, length " + array2.length + " found")];
+                }
+                if (arraySpec["min-length"] && array2.length < arraySpec["min-length"]) {
+                  return [new ValidationError(key, array2, "array length at least " + arraySpec["min-length"] + " expected, length " + array2.length + " found")];
+                }
+                var arrayElementSpec = {
+                  "type": arraySpec.value,
+                  "values": arraySpec.values
+                };
+                if (styleSpec.$version < 7) {
+                  arrayElementSpec.function = arraySpec.function;
+                }
+                if (getType2(arraySpec.value) === "object") {
+                  arrayElementSpec = arraySpec.value;
+                }
+                var errors = [];
+                for (var i2 = 0; i2 < array2.length; i2++) {
+                  errors = errors.concat(validateArrayElement({
+                    array: array2,
+                    arrayIndex: i2,
+                    value: array2[i2],
+                    valueSpec: arrayElementSpec,
+                    style,
+                    styleSpec,
+                    key: key + "[" + i2 + "]"
+                  }));
+                }
+                return errors;
+              }
+              function validateNumber(options) {
+                var key = options.key;
+                var value = options.value;
+                var valueSpec = options.valueSpec;
+                var type = getType2(value);
+                if (type === "number" && value !== value) {
+                  type = "NaN";
+                }
+                if (type !== "number") {
+                  return [new ValidationError(key, value, "number expected, " + type + " found")];
+                }
+                if ("minimum" in valueSpec && value < valueSpec.minimum) {
+                  return [new ValidationError(key, value, value + " is less than the minimum value " + valueSpec.minimum)];
+                }
+                if ("maximum" in valueSpec && value > valueSpec.maximum) {
+                  return [new ValidationError(key, value, value + " is greater than the maximum value " + valueSpec.maximum)];
+                }
+                return [];
+              }
+              function validateFunction(options) {
+                var functionValueSpec = options.valueSpec;
+                var functionType = unbundle(options.value.type);
+                var stopKeyType;
+                var stopDomainValues = {};
+                var previousStopDomainValue;
+                var previousStopDomainZoom;
+                var isZoomFunction = functionType !== "categorical" && options.value.property === void 0;
+                var isPropertyFunction = !isZoomFunction;
+                var isZoomAndPropertyFunction = getType2(options.value.stops) === "array" && getType2(options.value.stops[0]) === "array" && getType2(options.value.stops[0][0]) === "object";
+                var errors = validateObject({
+                  key: options.key,
+                  value: options.value,
+                  valueSpec: options.styleSpec.function,
+                  style: options.style,
+                  styleSpec: options.styleSpec,
+                  objectElementValidators: {
+                    stops: validateFunctionStops,
+                    default: validateFunctionDefault
+                  }
+                });
+                if (functionType === "identity" && isZoomFunction) {
+                  errors.push(new ValidationError(options.key, options.value, 'missing required property "property"'));
+                }
+                if (functionType !== "identity" && !options.value.stops) {
+                  errors.push(new ValidationError(options.key, options.value, 'missing required property "stops"'));
+                }
+                if (functionType === "exponential" && options.valueSpec.expression && !supportsInterpolation(options.valueSpec)) {
+                  errors.push(new ValidationError(options.key, options.value, "exponential functions not supported"));
+                }
+                if (options.styleSpec.$version >= 8) {
+                  if (isPropertyFunction && !supportsPropertyExpression(options.valueSpec)) {
+                    errors.push(new ValidationError(options.key, options.value, "property functions not supported"));
+                  } else if (isZoomFunction && !supportsZoomExpression(options.valueSpec)) {
+                    errors.push(new ValidationError(options.key, options.value, "zoom functions not supported"));
+                  }
+                }
+                if ((functionType === "categorical" || isZoomAndPropertyFunction) && options.value.property === void 0) {
+                  errors.push(new ValidationError(options.key, options.value, '"property" property is required'));
+                }
+                return errors;
+                function validateFunctionStops(options2) {
+                  if (functionType === "identity") {
+                    return [new ValidationError(options2.key, options2.value, 'identity function may not have a "stops" property')];
+                  }
+                  var errors2 = [];
+                  var value = options2.value;
+                  errors2 = errors2.concat(validateArray({
+                    key: options2.key,
+                    value,
+                    valueSpec: options2.valueSpec,
+                    style: options2.style,
+                    styleSpec: options2.styleSpec,
+                    arrayElementValidator: validateFunctionStop
+                  }));
+                  if (getType2(value) === "array" && value.length === 0) {
+                    errors2.push(new ValidationError(options2.key, value, "array must have at least one stop"));
+                  }
+                  return errors2;
+                }
+                function validateFunctionStop(options2) {
+                  var errors2 = [];
+                  var value = options2.value;
+                  var key = options2.key;
+                  if (getType2(value) !== "array") {
+                    return [new ValidationError(key, value, "array expected, " + getType2(value) + " found")];
+                  }
+                  if (value.length !== 2) {
+                    return [new ValidationError(key, value, "array length 2 expected, length " + value.length + " found")];
+                  }
+                  if (isZoomAndPropertyFunction) {
+                    if (getType2(value[0]) !== "object") {
+                      return [new ValidationError(key, value, "object expected, " + getType2(value[0]) + " found")];
+                    }
+                    if (value[0].zoom === void 0) {
+                      return [new ValidationError(key, value, "object stop key must have zoom")];
+                    }
+                    if (value[0].value === void 0) {
+                      return [new ValidationError(key, value, "object stop key must have value")];
+                    }
+                    if (previousStopDomainZoom && previousStopDomainZoom > unbundle(value[0].zoom)) {
+                      return [new ValidationError(key, value[0].zoom, "stop zoom values must appear in ascending order")];
+                    }
+                    if (unbundle(value[0].zoom) !== previousStopDomainZoom) {
+                      previousStopDomainZoom = unbundle(value[0].zoom);
+                      previousStopDomainValue = void 0;
+                      stopDomainValues = {};
+                    }
+                    errors2 = errors2.concat(validateObject({
+                      key: key + "[0]",
+                      value: value[0],
+                      valueSpec: { zoom: {} },
+                      style: options2.style,
+                      styleSpec: options2.styleSpec,
+                      objectElementValidators: {
+                        zoom: validateNumber,
+                        value: validateStopDomainValue
+                      }
+                    }));
+                  } else {
+                    errors2 = errors2.concat(validateStopDomainValue({
+                      key: key + "[0]",
+                      value: value[0],
+                      style: options2.style,
+                      styleSpec: options2.styleSpec
+                    }, value));
+                  }
+                  if (isExpression(deepUnbundle(value[1]))) {
+                    return errors2.concat([new ValidationError(key + "[1]", value[1], "expressions are not allowed in function stops.")]);
+                  }
+                  return errors2.concat(validate({
+                    key: key + "[1]",
+                    value: value[1],
+                    valueSpec: functionValueSpec,
+                    style: options2.style,
+                    styleSpec: options2.styleSpec
+                  }));
+                }
+                function validateStopDomainValue(options2, stop) {
+                  var type = getType2(options2.value);
+                  var value = unbundle(options2.value);
+                  var reportValue = options2.value !== null ? options2.value : stop;
+                  if (!stopKeyType) {
+                    stopKeyType = type;
+                  } else if (type !== stopKeyType) {
+                    return [new ValidationError(options2.key, reportValue, type + " stop domain type must match previous stop domain type " + stopKeyType)];
+                  }
+                  if (type !== "number" && type !== "string" && type !== "boolean") {
+                    return [new ValidationError(options2.key, reportValue, "stop domain value must be a number, string, or boolean")];
+                  }
+                  if (type !== "number" && functionType !== "categorical") {
+                    var message2 = "number expected, " + type + " found";
+                    if (supportsPropertyExpression(functionValueSpec) && functionType === void 0) {
+                      message2 += '\nIf you intended to use a categorical function, specify `"type": "categorical"`.';
+                    }
+                    return [new ValidationError(options2.key, reportValue, message2)];
+                  }
+                  if (functionType === "categorical" && type === "number" && (!isFinite(value) || Math.floor(value) !== value)) {
+                    return [new ValidationError(options2.key, reportValue, "integer expected, found " + value)];
+                  }
+                  if (functionType !== "categorical" && type === "number" && previousStopDomainValue !== void 0 && value < previousStopDomainValue) {
+                    return [new ValidationError(options2.key, reportValue, "stop domain values must appear in ascending order")];
+                  } else {
+                    previousStopDomainValue = value;
+                  }
+                  if (functionType === "categorical" && value in stopDomainValues) {
+                    return [new ValidationError(options2.key, reportValue, "stop domain values must be unique")];
+                  } else {
+                    stopDomainValues[value] = true;
+                  }
+                  return [];
+                }
+                function validateFunctionDefault(options2) {
+                  return validate({
+                    key: options2.key,
+                    value: options2.value,
+                    valueSpec: functionValueSpec,
+                    style: options2.style,
+                    styleSpec: options2.styleSpec
+                  });
+                }
+              }
+              function validateExpression(options) {
+                var expression2 = (options.expressionContext === "property" ? createPropertyExpression : createExpression)(deepUnbundle(options.value), options.valueSpec);
+                if (expression2.result === "error") {
+                  return expression2.value.map(function(error2) {
+                    return new ValidationError("" + options.key + error2.key, options.value, error2.message);
+                  });
+                }
+                var expressionObj = expression2.value.expression || expression2.value._styleExpression.expression;
+                if (options.expressionContext === "property" && options.propertyKey === "text-font" && !expressionObj.outputDefined()) {
+                  return [new ValidationError(options.key, options.value, 'Invalid data expression for "' + options.propertyKey + '". Output values must be contained as literals within the expression.')];
+                }
+                if (options.expressionContext === "property" && options.propertyType === "layout" && !isStateConstant(expressionObj)) {
+                  return [new ValidationError(options.key, options.value, '"feature-state" data expressions are not supported with layout properties.')];
+                }
+                if (options.expressionContext === "filter" && !isStateConstant(expressionObj)) {
+                  return [new ValidationError(options.key, options.value, '"feature-state" data expressions are not supported with filters.')];
+                }
+                if (options.expressionContext && options.expressionContext.indexOf("cluster") === 0) {
+                  if (!isGlobalPropertyConstant(expressionObj, [
+                    "zoom",
+                    "feature-state"
+                  ])) {
+                    return [new ValidationError(options.key, options.value, '"zoom" and "feature-state" expressions are not supported with cluster properties.')];
+                  }
+                  if (options.expressionContext === "cluster-initial" && !isFeatureConstant(expressionObj)) {
+                    return [new ValidationError(options.key, options.value, "Feature data expressions are not supported with initial expression part of cluster properties.")];
+                  }
+                }
+                return [];
+              }
+              function validateBoolean(options) {
+                var value = options.value;
+                var key = options.key;
+                var type = getType2(value);
+                if (type !== "boolean") {
+                  return [new ValidationError(key, value, "boolean expected, " + type + " found")];
+                }
+                return [];
+              }
+              function validateColor(options) {
+                var key = options.key;
+                var value = options.value;
+                var type = getType2(value);
+                if (type !== "string") {
+                  return [new ValidationError(key, value, "color expected, " + type + " found")];
+                }
+                if (csscolorparser_1(value) === null) {
+                  return [new ValidationError(key, value, 'color expected, "' + value + '" found')];
+                }
+                return [];
+              }
+              function validateEnum(options) {
+                var key = options.key;
+                var value = options.value;
+                var valueSpec = options.valueSpec;
+                var errors = [];
+                if (Array.isArray(valueSpec.values)) {
+                  if (valueSpec.values.indexOf(unbundle(value)) === -1) {
+                    errors.push(new ValidationError(key, value, "expected one of [" + valueSpec.values.join(", ") + "], " + JSON.stringify(value) + " found"));
+                  }
+                } else {
+                  if (Object.keys(valueSpec.values).indexOf(unbundle(value)) === -1) {
+                    errors.push(new ValidationError(key, value, "expected one of [" + Object.keys(valueSpec.values).join(", ") + "], " + JSON.stringify(value) + " found"));
+                  }
+                }
+                return errors;
+              }
+              function isExpressionFilter(filter2) {
+                if (filter2 === true || filter2 === false) {
+                  return true;
+                }
+                if (!Array.isArray(filter2) || filter2.length === 0) {
+                  return false;
+                }
+                switch (filter2[0]) {
+                  case "has":
+                    return filter2.length >= 2 && filter2[1] !== "$id" && filter2[1] !== "$type";
+                  case "in":
+                    return filter2.length >= 3 && (typeof filter2[1] !== "string" || Array.isArray(filter2[2]));
+                  case "!in":
+                  case "!has":
+                  case "none":
+                    return false;
+                  case "==":
+                  case "!=":
+                  case ">":
+                  case ">=":
+                  case "<":
+                  case "<=":
+                    return filter2.length !== 3 || (Array.isArray(filter2[1]) || Array.isArray(filter2[2]));
+                  case "any":
+                  case "all":
+                    for (var i2 = 0, list = filter2.slice(1); i2 < list.length; i2 += 1) {
+                      var f2 = list[i2];
+                      if (!isExpressionFilter(f2) && typeof f2 !== "boolean") {
+                        return false;
+                      }
+                    }
+                    return true;
+                  default:
+                    return true;
+                }
+              }
+              var filterSpec = {
+                "type": "boolean",
+                "default": false
+              };
+              function createFilter(filter2) {
+                if (filter2 === null || filter2 === void 0) {
+                  return {
+                    filter: function() {
+                      return true;
+                    },
+                    needGeometry: false
+                  };
+                }
+                if (!isExpressionFilter(filter2)) {
+                  filter2 = convertFilter(filter2);
+                }
+                var compiled = createExpression(filter2, filterSpec);
+                if (compiled.result === "error") {
+                  throw new Error(compiled.value.map(function(err) {
+                    return err.key + ": " + err.message;
+                  }).join(", "));
+                } else {
+                  var needGeometry = geometryNeeded(filter2);
+                  return {
+                    filter: function(globalProperties, feature, canonical) {
+                      return compiled.value.evaluate(globalProperties, feature, {}, canonical);
+                    },
+                    needGeometry
+                  };
+                }
+              }
+              function compare(a2, b2) {
+                return a2 < b2 ? -1 : a2 > b2 ? 1 : 0;
+              }
+              function geometryNeeded(filter2) {
+                if (!Array.isArray(filter2)) {
+                  return false;
+                }
+                if (filter2[0] === "within") {
+                  return true;
+                }
+                for (var index = 1; index < filter2.length; index++) {
+                  if (geometryNeeded(filter2[index])) {
+                    return true;
+                  }
+                }
+                return false;
+              }
+              function convertFilter(filter2) {
+                if (!filter2) {
+                  return true;
+                }
+                var op = filter2[0];
+                if (filter2.length <= 1) {
+                  return op !== "any";
+                }
+                var converted = op === "==" ? convertComparisonOp(filter2[1], filter2[2], "==") : op === "!=" ? convertNegation(convertComparisonOp(filter2[1], filter2[2], "==")) : op === "<" || op === ">" || op === "<=" || op === ">=" ? convertComparisonOp(filter2[1], filter2[2], op) : op === "any" ? convertDisjunctionOp(filter2.slice(1)) : op === "all" ? ["all"].concat(filter2.slice(1).map(convertFilter)) : op === "none" ? ["all"].concat(filter2.slice(1).map(convertFilter).map(convertNegation)) : op === "in" ? convertInOp(filter2[1], filter2.slice(2)) : op === "!in" ? convertNegation(convertInOp(filter2[1], filter2.slice(2))) : op === "has" ? convertHasOp(filter2[1]) : op === "!has" ? convertNegation(convertHasOp(filter2[1])) : op === "within" ? filter2 : true;
+                return converted;
+              }
+              function convertComparisonOp(property, value, op) {
+                switch (property) {
+                  case "$type":
+                    return [
+                      "filter-type-" + op,
+                      value
+                    ];
+                  case "$id":
+                    return [
+                      "filter-id-" + op,
+                      value
+                    ];
+                  default:
+                    return [
+                      "filter-" + op,
+                      property,
+                      value
+                    ];
+                }
+              }
+              function convertDisjunctionOp(filters) {
+                return ["any"].concat(filters.map(convertFilter));
+              }
+              function convertInOp(property, values2) {
+                if (values2.length === 0) {
+                  return false;
+                }
+                switch (property) {
+                  case "$type":
+                    return [
+                      "filter-type-in",
+                      [
+                        "literal",
+                        values2
+                      ]
+                    ];
+                  case "$id":
+                    return [
+                      "filter-id-in",
+                      [
+                        "literal",
+                        values2
+                      ]
+                    ];
+                  default:
+                    if (values2.length > 200 && !values2.some(function(v2) {
+                      return typeof v2 !== typeof values2[0];
+                    })) {
+                      return [
+                        "filter-in-large",
+                        property,
+                        [
+                          "literal",
+                          values2.sort(compare)
+                        ]
+                      ];
+                    } else {
+                      return [
+                        "filter-in-small",
+                        property,
+                        [
+                          "literal",
+                          values2
+                        ]
+                      ];
+                    }
+                }
+              }
+              function convertHasOp(property) {
+                switch (property) {
+                  case "$type":
+                    return true;
+                  case "$id":
+                    return ["filter-has-id"];
+                  default:
+                    return [
+                      "filter-has",
+                      property
+                    ];
+                }
+              }
+              function convertNegation(filter2) {
+                return [
+                  "!",
+                  filter2
+                ];
+              }
+              function validateFilter(options) {
+                if (isExpressionFilter(deepUnbundle(options.value))) {
+                  return validateExpression(extend$1({}, options, {
+                    expressionContext: "filter",
+                    valueSpec: { value: "boolean" }
+                  }));
+                } else {
+                  return validateNonExpressionFilter(options);
+                }
+              }
+              function validateNonExpressionFilter(options) {
+                var value = options.value;
+                var key = options.key;
+                if (getType2(value) !== "array") {
+                  return [new ValidationError(key, value, "array expected, " + getType2(value) + " found")];
+                }
+                var styleSpec = options.styleSpec;
+                var type;
+                var errors = [];
+                if (value.length < 1) {
+                  return [new ValidationError(key, value, "filter array must have at least 1 element")];
+                }
+                errors = errors.concat(validateEnum({
+                  key: key + "[0]",
+                  value: value[0],
+                  valueSpec: styleSpec.filter_operator,
+                  style: options.style,
+                  styleSpec: options.styleSpec
+                }));
+                switch (unbundle(value[0])) {
+                  case "<":
+                  case "<=":
+                  case ">":
+                  case ">=":
+                    if (value.length >= 2 && unbundle(value[1]) === "$type") {
+                      errors.push(new ValidationError(key, value, '"$type" cannot be use with operator "' + value[0] + '"'));
+                    }
+                  case "==":
+                  case "!=":
+                    if (value.length !== 3) {
+                      errors.push(new ValidationError(key, value, 'filter array for operator "' + value[0] + '" must have 3 elements'));
+                    }
+                  case "in":
+                  case "!in":
+                    if (value.length >= 2) {
+                      type = getType2(value[1]);
+                      if (type !== "string") {
+                        errors.push(new ValidationError(key + "[1]", value[1], "string expected, " + type + " found"));
+                      }
+                    }
+                    for (var i2 = 2; i2 < value.length; i2++) {
+                      type = getType2(value[i2]);
+                      if (unbundle(value[1]) === "$type") {
+                        errors = errors.concat(validateEnum({
+                          key: key + "[" + i2 + "]",
+                          value: value[i2],
+                          valueSpec: styleSpec.geometry_type,
+                          style: options.style,
+                          styleSpec: options.styleSpec
+                        }));
+                      } else if (type !== "string" && type !== "number" && type !== "boolean") {
+                        errors.push(new ValidationError(key + "[" + i2 + "]", value[i2], "string, number, or boolean expected, " + type + " found"));
+                      }
+                    }
+                    break;
+                  case "any":
+                  case "all":
+                  case "none":
+                    for (var i$1 = 1; i$1 < value.length; i$1++) {
+                      errors = errors.concat(validateNonExpressionFilter({
+                        key: key + "[" + i$1 + "]",
+                        value: value[i$1],
+                        style: options.style,
+                        styleSpec: options.styleSpec
+                      }));
+                    }
+                    break;
+                  case "has":
+                  case "!has":
+                    type = getType2(value[1]);
+                    if (value.length !== 2) {
+                      errors.push(new ValidationError(key, value, 'filter array for "' + value[0] + '" operator must have 2 elements'));
+                    } else if (type !== "string") {
+                      errors.push(new ValidationError(key + "[1]", value[1], "string expected, " + type + " found"));
+                    }
+                    break;
+                  case "within":
+                    type = getType2(value[1]);
+                    if (value.length !== 2) {
+                      errors.push(new ValidationError(key, value, 'filter array for "' + value[0] + '" operator must have 2 elements'));
+                    } else if (type !== "object") {
+                      errors.push(new ValidationError(key + "[1]", value[1], "object expected, " + type + " found"));
+                    }
+                    break;
+                }
+                return errors;
+              }
+              function validateProperty(options, propertyType) {
+                var key = options.key;
+                var style = options.style;
+                var styleSpec = options.styleSpec;
+                var value = options.value;
+                var propertyKey = options.objectKey;
+                var layerSpec = styleSpec[propertyType + "_" + options.layerType];
+                if (!layerSpec) {
+                  return [];
+                }
+                var transitionMatch = propertyKey.match(/^(.*)-transition$/);
+                if (propertyType === "paint" && transitionMatch && layerSpec[transitionMatch[1]] && layerSpec[transitionMatch[1]].transition) {
+                  return validate({
+                    key,
+                    value,
+                    valueSpec: styleSpec.transition,
+                    style,
+                    styleSpec
+                  });
+                }
+                var valueSpec = options.valueSpec || layerSpec[propertyKey];
+                if (!valueSpec) {
+                  return [new ValidationError(key, value, 'unknown property "' + propertyKey + '"')];
+                }
+                var tokenMatch;
+                if (getType2(value) === "string" && supportsPropertyExpression(valueSpec) && !valueSpec.tokens && (tokenMatch = /^{([^}]+)}$/.exec(value))) {
+                  return [new ValidationError(key, value, '"' + propertyKey + '" does not support interpolation syntax\nUse an identity property function instead: `{ "type": "identity", "property": ' + JSON.stringify(tokenMatch[1]) + " }`.")];
+                }
+                var errors = [];
+                if (options.layerType === "symbol") {
+                  if (propertyKey === "text-field" && style && !style.glyphs) {
+                    errors.push(new ValidationError(key, value, 'use of "text-field" requires a style "glyphs" property'));
+                  }
+                  if (propertyKey === "text-font" && isFunction2(deepUnbundle(value)) && unbundle(value.type) === "identity") {
+                    errors.push(new ValidationError(key, value, '"text-font" does not support identity functions'));
+                  }
+                }
+                return errors.concat(validate({
+                  key: options.key,
+                  value,
+                  valueSpec,
+                  style,
+                  styleSpec,
+                  expressionContext: "property",
+                  propertyType,
+                  propertyKey
+                }));
+              }
+              function validatePaintProperty(options) {
+                return validateProperty(options, "paint");
+              }
+              function validateLayoutProperty(options) {
+                return validateProperty(options, "layout");
+              }
+              function validateLayer(options) {
+                var errors = [];
+                var layer2 = options.value;
+                var key = options.key;
+                var style = options.style;
+                var styleSpec = options.styleSpec;
+                if (!layer2.type && !layer2.ref) {
+                  errors.push(new ValidationError(key, layer2, 'either "type" or "ref" is required'));
+                }
+                var type = unbundle(layer2.type);
+                var ref = unbundle(layer2.ref);
+                if (layer2.id) {
+                  var layerId = unbundle(layer2.id);
+                  for (var i2 = 0; i2 < options.arrayIndex; i2++) {
+                    var otherLayer = style.layers[i2];
+                    if (unbundle(otherLayer.id) === layerId) {
+                      errors.push(new ValidationError(key, layer2.id, 'duplicate layer id "' + layer2.id + '", previously used at line ' + otherLayer.id.__line__));
+                    }
+                  }
+                }
+                if ("ref" in layer2) {
+                  [
+                    "type",
+                    "source",
+                    "source-layer",
+                    "filter",
+                    "layout"
+                  ].forEach(function(p2) {
+                    if (p2 in layer2) {
+                      errors.push(new ValidationError(key, layer2[p2], '"' + p2 + '" is prohibited for ref layers'));
+                    }
+                  });
+                  var parent;
+                  style.layers.forEach(function(layer3) {
+                    if (unbundle(layer3.id) === ref) {
+                      parent = layer3;
+                    }
+                  });
+                  if (!parent) {
+                    errors.push(new ValidationError(key, layer2.ref, 'ref layer "' + ref + '" not found'));
+                  } else if (parent.ref) {
+                    errors.push(new ValidationError(key, layer2.ref, "ref cannot reference another ref layer"));
+                  } else {
+                    type = unbundle(parent.type);
+                  }
+                } else if (type !== "background") {
+                  if (!layer2.source) {
+                    errors.push(new ValidationError(key, layer2, 'missing required property "source"'));
+                  } else {
+                    var source22 = style.sources && style.sources[layer2.source];
+                    var sourceType = source22 && unbundle(source22.type);
+                    if (!source22) {
+                      errors.push(new ValidationError(key, layer2.source, 'source "' + layer2.source + '" not found'));
+                    } else if (sourceType === "vector" && type === "raster") {
+                      errors.push(new ValidationError(key, layer2.source, 'layer "' + layer2.id + '" requires a raster source'));
+                    } else if (sourceType === "raster" && type !== "raster") {
+                      errors.push(new ValidationError(key, layer2.source, 'layer "' + layer2.id + '" requires a vector source'));
+                    } else if (sourceType === "vector" && !layer2["source-layer"]) {
+                      errors.push(new ValidationError(key, layer2, 'layer "' + layer2.id + '" must specify a "source-layer"'));
+                    } else if (sourceType === "raster-dem" && type !== "hillshade") {
+                      errors.push(new ValidationError(key, layer2.source, "raster-dem source can only be used with layer type 'hillshade'."));
+                    } else if (type === "line" && layer2.paint && layer2.paint["line-gradient"] && (sourceType !== "geojson" || !source22.lineMetrics)) {
+                      errors.push(new ValidationError(key, layer2, 'layer "' + layer2.id + '" specifies a line-gradient, which requires a GeoJSON source with `lineMetrics` enabled.'));
+                    }
+                  }
+                }
+                errors = errors.concat(validateObject({
+                  key,
+                  value: layer2,
+                  valueSpec: styleSpec.layer,
+                  style: options.style,
+                  styleSpec: options.styleSpec,
+                  objectElementValidators: {
+                    "*": function _2() {
+                      return [];
+                    },
+                    type: function type2() {
+                      return validate({
+                        key: key + ".type",
+                        value: layer2.type,
+                        valueSpec: styleSpec.layer.type,
+                        style: options.style,
+                        styleSpec: options.styleSpec,
+                        object: layer2,
+                        objectKey: "type"
+                      });
+                    },
+                    filter: validateFilter,
+                    layout: function layout2(options2) {
+                      return validateObject({
+                        layer: layer2,
+                        key: options2.key,
+                        value: options2.value,
+                        style: options2.style,
+                        styleSpec: options2.styleSpec,
+                        objectElementValidators: {
+                          "*": function _2(options3) {
+                            return validateLayoutProperty(extend$1({ layerType: type }, options3));
+                          }
+                        }
+                      });
+                    },
+                    paint: function paint2(options2) {
+                      return validateObject({
+                        layer: layer2,
+                        key: options2.key,
+                        value: options2.value,
+                        style: options2.style,
+                        styleSpec: options2.styleSpec,
+                        objectElementValidators: {
+                          "*": function _2(options3) {
+                            return validatePaintProperty(extend$1({ layerType: type }, options3));
+                          }
+                        }
+                      });
+                    }
+                  }
+                }));
+                return errors;
+              }
+              function validateString(options) {
+                var value = options.value;
+                var key = options.key;
+                var type = getType2(value);
+                if (type !== "string") {
+                  return [new ValidationError(key, value, "string expected, " + type + " found")];
+                }
+                return [];
+              }
+              var objectElementValidators = { promoteId: validatePromoteId };
+              function validateSource(options) {
+                var value = options.value;
+                var key = options.key;
+                var styleSpec = options.styleSpec;
+                var style = options.style;
+                if (!value.type) {
+                  return [new ValidationError(key, value, '"type" is required')];
+                }
+                var type = unbundle(value.type);
+                var errors;
+                switch (type) {
+                  case "vector":
+                  case "raster":
+                  case "raster-dem":
+                    errors = validateObject({
+                      key,
+                      value,
+                      valueSpec: styleSpec["source_" + type.replace("-", "_")],
+                      style: options.style,
+                      styleSpec,
+                      objectElementValidators
+                    });
+                    return errors;
+                  case "geojson":
+                    errors = validateObject({
+                      key,
+                      value,
+                      valueSpec: styleSpec.source_geojson,
+                      style,
+                      styleSpec,
+                      objectElementValidators
+                    });
+                    if (value.cluster) {
+                      for (var prop in value.clusterProperties) {
+                        var ref = value.clusterProperties[prop];
+                        var operator = ref[0];
+                        var mapExpr = ref[1];
+                        var reduceExpr = typeof operator === "string" ? [
+                          operator,
+                          ["accumulated"],
+                          [
+                            "get",
+                            prop
+                          ]
+                        ] : operator;
+                        errors.push.apply(errors, validateExpression({
+                          key: key + "." + prop + ".map",
+                          value: mapExpr,
+                          expressionContext: "cluster-map"
+                        }));
+                        errors.push.apply(errors, validateExpression({
+                          key: key + "." + prop + ".reduce",
+                          value: reduceExpr,
+                          expressionContext: "cluster-reduce"
+                        }));
+                      }
+                    }
+                    return errors;
+                  case "video":
+                    return validateObject({
+                      key,
+                      value,
+                      valueSpec: styleSpec.source_video,
+                      style,
+                      styleSpec
+                    });
+                  case "image":
+                    return validateObject({
+                      key,
+                      value,
+                      valueSpec: styleSpec.source_image,
+                      style,
+                      styleSpec
+                    });
+                  case "canvas":
+                    return [new ValidationError(key, null, "Please use runtime APIs to add canvas sources, rather than including them in stylesheets.", "source.canvas")];
+                  default:
+                    return validateEnum({
+                      key: key + ".type",
+                      value: value.type,
+                      valueSpec: {
+                        values: [
+                          "vector",
+                          "raster",
+                          "raster-dem",
+                          "geojson",
+                          "video",
+                          "image"
+                        ]
+                      }
+                    });
+                }
+              }
+              function validatePromoteId(ref) {
+                var key = ref.key;
+                var value = ref.value;
+                if (getType2(value) === "string") {
+                  return validateString({
+                    key,
+                    value
+                  });
+                } else {
+                  var errors = [];
+                  for (var prop in value) {
+                    errors.push.apply(errors, validateString({
+                      key: key + "." + prop,
+                      value: value[prop]
+                    }));
+                  }
+                  return errors;
+                }
+              }
+              function validateLight(options) {
+                var light2 = options.value;
+                var styleSpec = options.styleSpec;
+                var lightSpec = styleSpec.light;
+                var style = options.style;
+                var errors = [];
+                var rootType = getType2(light2);
+                if (light2 === void 0) {
+                  return errors;
+                } else if (rootType !== "object") {
+                  errors = errors.concat([new ValidationError("light", light2, "object expected, " + rootType + " found")]);
+                  return errors;
+                }
+                for (var key in light2) {
+                  var transitionMatch = key.match(/^(.*)-transition$/);
+                  if (transitionMatch && lightSpec[transitionMatch[1]] && lightSpec[transitionMatch[1]].transition) {
+                    errors = errors.concat(validate({
+                      key,
+                      value: light2[key],
+                      valueSpec: styleSpec.transition,
+                      style,
+                      styleSpec
+                    }));
+                  } else if (lightSpec[key]) {
+                    errors = errors.concat(validate({
+                      key,
+                      value: light2[key],
+                      valueSpec: lightSpec[key],
+                      style,
+                      styleSpec
+                    }));
+                  } else {
+                    errors = errors.concat([new ValidationError(key, light2[key], 'unknown property "' + key + '"')]);
+                  }
+                }
+                return errors;
+              }
+              function validateFormatted(options) {
+                if (validateString(options).length === 0) {
+                  return [];
+                }
+                return validateExpression(options);
+              }
+              function validateImage(options) {
+                if (validateString(options).length === 0) {
+                  return [];
+                }
+                return validateExpression(options);
+              }
+              var VALIDATORS = {
+                "*": function _2() {
+                  return [];
+                },
+                "array": validateArray,
+                "boolean": validateBoolean,
+                "number": validateNumber,
+                "color": validateColor,
+                "constants": validateConstants,
+                "enum": validateEnum,
+                "filter": validateFilter,
+                "function": validateFunction,
+                "layer": validateLayer,
+                "object": validateObject,
+                "source": validateSource,
+                "light": validateLight,
+                "string": validateString,
+                "formatted": validateFormatted,
+                "resolvedImage": validateImage
+              };
+              function validate(options) {
+                var value = options.value;
+                var valueSpec = options.valueSpec;
+                var styleSpec = options.styleSpec;
+                if (valueSpec.expression && isFunction2(unbundle(value))) {
+                  return validateFunction(options);
+                } else if (valueSpec.expression && isExpression(deepUnbundle(value))) {
+                  return validateExpression(options);
+                } else if (valueSpec.type && VALIDATORS[valueSpec.type]) {
+                  return VALIDATORS[valueSpec.type](options);
+                } else {
+                  var valid = validateObject(extend$1({}, options, { valueSpec: valueSpec.type ? styleSpec[valueSpec.type] : valueSpec }));
+                  return valid;
+                }
+              }
+              function validateGlyphsURL(options) {
+                var value = options.value;
+                var key = options.key;
+                var errors = validateString(options);
+                if (errors.length) {
+                  return errors;
+                }
+                if (value.indexOf("{fontstack}") === -1) {
+                  errors.push(new ValidationError(key, value, '"glyphs" url must include a "{fontstack}" token'));
+                }
+                if (value.indexOf("{range}") === -1) {
+                  errors.push(new ValidationError(key, value, '"glyphs" url must include a "{range}" token'));
+                }
+                return errors;
+              }
+              function validateStyleMin(style, styleSpec) {
+                if (styleSpec === void 0)
+                  styleSpec = spec;
+                var errors = [];
+                errors = errors.concat(validate({
+                  key: "",
+                  value: style,
+                  valueSpec: styleSpec.$root,
+                  styleSpec,
+                  style,
+                  objectElementValidators: {
+                    glyphs: validateGlyphsURL,
+                    "*": function _2() {
+                      return [];
+                    }
+                  }
+                }));
+                if (style.constants) {
+                  errors = errors.concat(validateConstants({
+                    key: "constants",
+                    value: style.constants
+                  }));
+                }
+                return sortErrors(errors);
+              }
+              validateStyleMin.source = wrapCleanErrors(validateSource);
+              validateStyleMin.light = wrapCleanErrors(validateLight);
+              validateStyleMin.layer = wrapCleanErrors(validateLayer);
+              validateStyleMin.filter = wrapCleanErrors(validateFilter);
+              validateStyleMin.paintProperty = wrapCleanErrors(validatePaintProperty);
+              validateStyleMin.layoutProperty = wrapCleanErrors(validateLayoutProperty);
+              function sortErrors(errors) {
+                return [].concat(errors).sort(function(a2, b2) {
+                  return a2.line - b2.line;
+                });
+              }
+              function wrapCleanErrors(inner) {
+                return function() {
+                  var args = [], len2 = arguments.length;
+                  while (len2--)
+                    args[len2] = arguments[len2];
+                  return sortErrors(inner.apply(this, args));
+                };
+              }
+              var validateStyle = validateStyleMin;
+              var validateLight$1 = validateStyle.light;
+              var validatePaintProperty$1 = validateStyle.paintProperty;
+              var validateLayoutProperty$1 = validateStyle.layoutProperty;
+              function emitValidationErrors(emitter, errors) {
+                var hasErrors = false;
+                if (errors && errors.length) {
+                  for (var i2 = 0, list = errors; i2 < list.length; i2 += 1) {
+                    var error2 = list[i2];
+                    emitter.fire(new ErrorEvent(new Error(error2.message)));
+                    hasErrors = true;
+                  }
+                }
+                return hasErrors;
+              }
+              var gridIndex = GridIndex;
+              var NUM_PARAMS = 3;
+              function GridIndex(extent, n2, padding) {
+                var cells = this.cells = [];
+                if (extent instanceof ArrayBuffer) {
+                  this.arrayBuffer = extent;
+                  var array2 = new Int32Array(this.arrayBuffer);
+                  extent = array2[0];
+                  n2 = array2[1];
+                  padding = array2[2];
+                  this.d = n2 + 2 * padding;
+                  for (var k2 = 0; k2 < this.d * this.d; k2++) {
+                    var start = array2[NUM_PARAMS + k2];
+                    var end = array2[NUM_PARAMS + k2 + 1];
+                    cells.push(start === end ? null : array2.subarray(start, end));
+                  }
+                  var keysOffset = array2[NUM_PARAMS + cells.length];
+                  var bboxesOffset = array2[NUM_PARAMS + cells.length + 1];
+                  this.keys = array2.subarray(keysOffset, bboxesOffset);
+                  this.bboxes = array2.subarray(bboxesOffset);
+                  this.insert = this._insertReadonly;
+                } else {
+                  this.d = n2 + 2 * padding;
+                  for (var i2 = 0; i2 < this.d * this.d; i2++) {
+                    cells.push([]);
+                  }
+                  this.keys = [];
+                  this.bboxes = [];
+                }
+                this.n = n2;
+                this.extent = extent;
+                this.padding = padding;
+                this.scale = n2 / extent;
+                this.uid = 0;
+                var p2 = padding / n2 * extent;
+                this.min = -p2;
+                this.max = extent + p2;
+              }
+              GridIndex.prototype.insert = function(key, x1, y1, x2, y2) {
+                this._forEachCell(x1, y1, x2, y2, this._insertCell, this.uid++);
+                this.keys.push(key);
+                this.bboxes.push(x1);
+                this.bboxes.push(y1);
+                this.bboxes.push(x2);
+                this.bboxes.push(y2);
+              };
+              GridIndex.prototype._insertReadonly = function() {
+                throw "Cannot insert into a GridIndex created from an ArrayBuffer.";
+              };
+              GridIndex.prototype._insertCell = function(x1, y1, x2, y2, cellIndex, uid2) {
+                this.cells[cellIndex].push(uid2);
+              };
+              GridIndex.prototype.query = function(x1, y1, x2, y2, intersectionTest) {
+                var min = this.min;
+                var max = this.max;
+                if (x1 <= min && y1 <= min && max <= x2 && max <= y2 && !intersectionTest) {
+                  return Array.prototype.slice.call(this.keys);
+                } else {
+                  var result = [];
+                  var seenUids = {};
+                  this._forEachCell(x1, y1, x2, y2, this._queryCell, result, seenUids, intersectionTest);
+                  return result;
+                }
+              };
+              GridIndex.prototype._queryCell = function(x1, y1, x2, y2, cellIndex, result, seenUids, intersectionTest) {
+                var cell = this.cells[cellIndex];
+                if (cell !== null) {
+                  var keys = this.keys;
+                  var bboxes = this.bboxes;
+                  for (var u2 = 0; u2 < cell.length; u2++) {
+                    var uid2 = cell[u2];
+                    if (seenUids[uid2] === void 0) {
+                      var offset = uid2 * 4;
+                      if (intersectionTest ? intersectionTest(bboxes[offset + 0], bboxes[offset + 1], bboxes[offset + 2], bboxes[offset + 3]) : x1 <= bboxes[offset + 2] && y1 <= bboxes[offset + 3] && x2 >= bboxes[offset + 0] && y2 >= bboxes[offset + 1]) {
+                        seenUids[uid2] = true;
+                        result.push(keys[uid2]);
+                      } else {
+                        seenUids[uid2] = false;
+                      }
+                    }
+                  }
+                }
+              };
+              GridIndex.prototype._forEachCell = function(x1, y1, x2, y2, fn, arg1, arg2, intersectionTest) {
+                var cx1 = this._convertToCellCoord(x1);
+                var cy1 = this._convertToCellCoord(y1);
+                var cx2 = this._convertToCellCoord(x2);
+                var cy2 = this._convertToCellCoord(y2);
+                for (var x3 = cx1; x3 <= cx2; x3++) {
+                  for (var y3 = cy1; y3 <= cy2; y3++) {
+                    var cellIndex = this.d * y3 + x3;
+                    if (intersectionTest && !intersectionTest(this._convertFromCellCoord(x3), this._convertFromCellCoord(y3), this._convertFromCellCoord(x3 + 1), this._convertFromCellCoord(y3 + 1))) {
+                      continue;
+                    }
+                    if (fn.call(this, x1, y1, x2, y2, cellIndex, arg1, arg2, intersectionTest)) {
+                      return;
+                    }
+                  }
+                }
+              };
+              GridIndex.prototype._convertFromCellCoord = function(x2) {
+                return (x2 - this.padding) / this.scale;
+              };
+              GridIndex.prototype._convertToCellCoord = function(x2) {
+                return Math.max(0, Math.min(this.d - 1, Math.floor(x2 * this.scale) + this.padding));
+              };
+              GridIndex.prototype.toArrayBuffer = function() {
+                if (this.arrayBuffer) {
+                  return this.arrayBuffer;
+                }
+                var cells = this.cells;
+                var metadataLength = NUM_PARAMS + this.cells.length + 1 + 1;
+                var totalCellLength = 0;
+                for (var i2 = 0; i2 < this.cells.length; i2++) {
+                  totalCellLength += this.cells[i2].length;
+                }
+                var array2 = new Int32Array(metadataLength + totalCellLength + this.keys.length + this.bboxes.length);
+                array2[0] = this.extent;
+                array2[1] = this.n;
+                array2[2] = this.padding;
+                var offset = metadataLength;
+                for (var k2 = 0; k2 < cells.length; k2++) {
+                  var cell = cells[k2];
+                  array2[NUM_PARAMS + k2] = offset;
+                  array2.set(cell, offset);
+                  offset += cell.length;
+                }
+                array2[NUM_PARAMS + cells.length] = offset;
+                array2.set(this.keys, offset);
+                offset += this.keys.length;
+                array2[NUM_PARAMS + cells.length + 1] = offset;
+                array2.set(this.bboxes, offset);
+                offset += this.bboxes.length;
+                return array2.buffer;
+              };
+              var ImageData2 = window$1.ImageData;
+              var ImageBitmap2 = window$1.ImageBitmap;
+              var registry = {};
+              function register2(name3, klass, options) {
+                if (options === void 0)
+                  options = {};
+                Object.defineProperty(klass, "_classRegistryKey", {
+                  value: name3,
+                  writeable: false
+                });
+                registry[name3] = {
+                  klass,
+                  omit: options.omit || [],
+                  shallow: options.shallow || []
+                };
+              }
+              register2("Object", Object);
+              gridIndex.serialize = function serialize2(grid, transferables) {
+                var buffer = grid.toArrayBuffer();
+                if (transferables) {
+                  transferables.push(buffer);
+                }
+                return { buffer };
+              };
+              gridIndex.deserialize = function deserialize2(serialized) {
+                return new gridIndex(serialized.buffer);
+              };
+              register2("Grid", gridIndex);
+              register2("Color", Color2);
+              register2("Error", Error);
+              register2("ResolvedImage", ResolvedImage);
+              register2("StylePropertyFunction", StylePropertyFunction);
+              register2("StyleExpression", StyleExpression, { omit: ["_evaluator"] });
+              register2("ZoomDependentExpression", ZoomDependentExpression);
+              register2("ZoomConstantExpression", ZoomConstantExpression);
+              register2("CompoundExpression", CompoundExpression, { omit: ["_evaluate"] });
+              for (var name2 in expressions) {
+                if (expressions[name2]._classRegistryKey) {
+                  continue;
+                }
+                register2("Expression_" + name2, expressions[name2]);
+              }
+              function isArrayBuffer(val) {
+                return val && typeof ArrayBuffer !== "undefined" && (val instanceof ArrayBuffer || val.constructor && val.constructor.name === "ArrayBuffer");
+              }
+              function isImageBitmap(val) {
+                return ImageBitmap2 && val instanceof ImageBitmap2;
+              }
+              function serialize(input, transferables) {
+                if (input === null || input === void 0 || typeof input === "boolean" || typeof input === "number" || typeof input === "string" || input instanceof Boolean || input instanceof Number || input instanceof String || input instanceof Date || input instanceof RegExp) {
+                  return input;
+                }
+                if (isArrayBuffer(input) || isImageBitmap(input)) {
+                  if (transferables) {
+                    transferables.push(input);
+                  }
+                  return input;
+                }
+                if (ArrayBuffer.isView(input)) {
+                  var view = input;
+                  if (transferables) {
+                    transferables.push(view.buffer);
+                  }
+                  return view;
+                }
+                if (input instanceof ImageData2) {
+                  if (transferables) {
+                    transferables.push(input.data.buffer);
+                  }
+                  return input;
+                }
+                if (Array.isArray(input)) {
+                  var serialized = [];
+                  for (var i2 = 0, list = input; i2 < list.length; i2 += 1) {
+                    var item = list[i2];
+                    serialized.push(serialize(item, transferables));
+                  }
+                  return serialized;
+                }
+                if (typeof input === "object") {
+                  var klass = input.constructor;
+                  var name3 = klass._classRegistryKey;
+                  if (!name3) {
+                    throw new Error("can't serialize object of unregistered class");
+                  }
+                  var properties2 = klass.serialize ? klass.serialize(input, transferables) : {};
+                  if (!klass.serialize) {
+                    for (var key in input) {
+                      if (!input.hasOwnProperty(key)) {
+                        continue;
+                      }
+                      if (registry[name3].omit.indexOf(key) >= 0) {
+                        continue;
+                      }
+                      var property = input[key];
+                      properties2[key] = registry[name3].shallow.indexOf(key) >= 0 ? property : serialize(property, transferables);
+                    }
+                    if (input instanceof Error) {
+                      properties2.message = input.message;
+                    }
+                  }
+                  if (properties2.$name) {
+                    throw new Error("$name property is reserved for worker serialization logic.");
+                  }
+                  if (name3 !== "Object") {
+                    properties2.$name = name3;
+                  }
+                  return properties2;
+                }
+                throw new Error("can't serialize object of type " + typeof input);
+              }
+              function deserialize(input) {
+                if (input === null || input === void 0 || typeof input === "boolean" || typeof input === "number" || typeof input === "string" || input instanceof Boolean || input instanceof Number || input instanceof String || input instanceof Date || input instanceof RegExp || isArrayBuffer(input) || isImageBitmap(input) || ArrayBuffer.isView(input) || input instanceof ImageData2) {
+                  return input;
+                }
+                if (Array.isArray(input)) {
+                  return input.map(deserialize);
+                }
+                if (typeof input === "object") {
+                  var name3 = input.$name || "Object";
+                  var ref = registry[name3];
+                  var klass = ref.klass;
+                  if (!klass) {
+                    throw new Error("can't deserialize unregistered class " + name3);
+                  }
+                  if (klass.deserialize) {
+                    return klass.deserialize(input);
+                  }
+                  var result = Object.create(klass.prototype);
+                  for (var i2 = 0, list = Object.keys(input); i2 < list.length; i2 += 1) {
+                    var key = list[i2];
+                    if (key === "$name") {
+                      continue;
+                    }
+                    var value = input[key];
+                    result[key] = registry[name3].shallow.indexOf(key) >= 0 ? value : deserialize(value);
+                  }
+                  return result;
+                }
+                throw new Error("can't deserialize object of type " + typeof input);
+              }
+              var ZoomHistory = function ZoomHistory2() {
+                this.first = true;
+              };
+              ZoomHistory.prototype.update = function update(z2, now2) {
+                var floorZ = Math.floor(z2);
+                if (this.first) {
+                  this.first = false;
+                  this.lastIntegerZoom = floorZ;
+                  this.lastIntegerZoomTime = 0;
+                  this.lastZoom = z2;
+                  this.lastFloorZoom = floorZ;
+                  return true;
+                }
+                if (this.lastFloorZoom > floorZ) {
+                  this.lastIntegerZoom = floorZ + 1;
+                  this.lastIntegerZoomTime = now2;
+                } else if (this.lastFloorZoom < floorZ) {
+                  this.lastIntegerZoom = floorZ;
+                  this.lastIntegerZoomTime = now2;
+                }
+                if (z2 !== this.lastZoom) {
+                  this.lastZoom = z2;
+                  this.lastFloorZoom = floorZ;
+                  return true;
+                }
+                return false;
+              };
+              var unicodeBlockLookup = {
+                "Latin-1 Supplement": function(char) {
+                  return char >= 128 && char <= 255;
+                },
+                "Arabic": function(char) {
+                  return char >= 1536 && char <= 1791;
+                },
+                "Arabic Supplement": function(char) {
+                  return char >= 1872 && char <= 1919;
+                },
+                "Arabic Extended-A": function(char) {
+                  return char >= 2208 && char <= 2303;
+                },
+                "Hangul Jamo": function(char) {
+                  return char >= 4352 && char <= 4607;
+                },
+                "Unified Canadian Aboriginal Syllabics": function(char) {
+                  return char >= 5120 && char <= 5759;
+                },
+                "Khmer": function(char) {
+                  return char >= 6016 && char <= 6143;
+                },
+                "Unified Canadian Aboriginal Syllabics Extended": function(char) {
+                  return char >= 6320 && char <= 6399;
+                },
+                "General Punctuation": function(char) {
+                  return char >= 8192 && char <= 8303;
+                },
+                "Letterlike Symbols": function(char) {
+                  return char >= 8448 && char <= 8527;
+                },
+                "Number Forms": function(char) {
+                  return char >= 8528 && char <= 8591;
+                },
+                "Miscellaneous Technical": function(char) {
+                  return char >= 8960 && char <= 9215;
+                },
+                "Control Pictures": function(char) {
+                  return char >= 9216 && char <= 9279;
+                },
+                "Optical Character Recognition": function(char) {
+                  return char >= 9280 && char <= 9311;
+                },
+                "Enclosed Alphanumerics": function(char) {
+                  return char >= 9312 && char <= 9471;
+                },
+                "Geometric Shapes": function(char) {
+                  return char >= 9632 && char <= 9727;
+                },
+                "Miscellaneous Symbols": function(char) {
+                  return char >= 9728 && char <= 9983;
+                },
+                "Miscellaneous Symbols and Arrows": function(char) {
+                  return char >= 11008 && char <= 11263;
+                },
+                "CJK Radicals Supplement": function(char) {
+                  return char >= 11904 && char <= 12031;
+                },
+                "Kangxi Radicals": function(char) {
+                  return char >= 12032 && char <= 12255;
+                },
+                "Ideographic Description Characters": function(char) {
+                  return char >= 12272 && char <= 12287;
+                },
+                "CJK Symbols and Punctuation": function(char) {
+                  return char >= 12288 && char <= 12351;
+                },
+                "Hiragana": function(char) {
+                  return char >= 12352 && char <= 12447;
+                },
+                "Katakana": function(char) {
+                  return char >= 12448 && char <= 12543;
+                },
+                "Bopomofo": function(char) {
+                  return char >= 12544 && char <= 12591;
+                },
+                "Hangul Compatibility Jamo": function(char) {
+                  return char >= 12592 && char <= 12687;
+                },
+                "Kanbun": function(char) {
+                  return char >= 12688 && char <= 12703;
+                },
+                "Bopomofo Extended": function(char) {
+                  return char >= 12704 && char <= 12735;
+                },
+                "CJK Strokes": function(char) {
+                  return char >= 12736 && char <= 12783;
+                },
+                "Katakana Phonetic Extensions": function(char) {
+                  return char >= 12784 && char <= 12799;
+                },
+                "Enclosed CJK Letters and Months": function(char) {
+                  return char >= 12800 && char <= 13055;
+                },
+                "CJK Compatibility": function(char) {
+                  return char >= 13056 && char <= 13311;
+                },
+                "CJK Unified Ideographs Extension A": function(char) {
+                  return char >= 13312 && char <= 19903;
+                },
+                "Yijing Hexagram Symbols": function(char) {
+                  return char >= 19904 && char <= 19967;
+                },
+                "CJK Unified Ideographs": function(char) {
+                  return char >= 19968 && char <= 40959;
+                },
+                "Yi Syllables": function(char) {
+                  return char >= 40960 && char <= 42127;
+                },
+                "Yi Radicals": function(char) {
+                  return char >= 42128 && char <= 42191;
+                },
+                "Hangul Jamo Extended-A": function(char) {
+                  return char >= 43360 && char <= 43391;
+                },
+                "Hangul Syllables": function(char) {
+                  return char >= 44032 && char <= 55215;
+                },
+                "Hangul Jamo Extended-B": function(char) {
+                  return char >= 55216 && char <= 55295;
+                },
+                "Private Use Area": function(char) {
+                  return char >= 57344 && char <= 63743;
+                },
+                "CJK Compatibility Ideographs": function(char) {
+                  return char >= 63744 && char <= 64255;
+                },
+                "Arabic Presentation Forms-A": function(char) {
+                  return char >= 64336 && char <= 65023;
+                },
+                "Vertical Forms": function(char) {
+                  return char >= 65040 && char <= 65055;
+                },
+                "CJK Compatibility Forms": function(char) {
+                  return char >= 65072 && char <= 65103;
+                },
+                "Small Form Variants": function(char) {
+                  return char >= 65104 && char <= 65135;
+                },
+                "Arabic Presentation Forms-B": function(char) {
+                  return char >= 65136 && char <= 65279;
+                },
+                "Halfwidth and Fullwidth Forms": function(char) {
+                  return char >= 65280 && char <= 65519;
+                }
+              };
+              function allowsVerticalWritingMode(chars) {
+                for (var i2 = 0, list = chars; i2 < list.length; i2 += 1) {
+                  var char = list[i2];
+                  if (charHasUprightVerticalOrientation(char.charCodeAt(0))) {
+                    return true;
+                  }
+                }
+                return false;
+              }
+              function allowsLetterSpacing(chars) {
+                for (var i2 = 0, list = chars; i2 < list.length; i2 += 1) {
+                  var char = list[i2];
+                  if (!charAllowsLetterSpacing(char.charCodeAt(0))) {
+                    return false;
+                  }
+                }
+                return true;
+              }
+              function charAllowsLetterSpacing(char) {
+                if (unicodeBlockLookup["Arabic"](char)) {
+                  return false;
+                }
+                if (unicodeBlockLookup["Arabic Supplement"](char)) {
+                  return false;
+                }
+                if (unicodeBlockLookup["Arabic Extended-A"](char)) {
+                  return false;
+                }
+                if (unicodeBlockLookup["Arabic Presentation Forms-A"](char)) {
+                  return false;
+                }
+                if (unicodeBlockLookup["Arabic Presentation Forms-B"](char)) {
+                  return false;
+                }
+                return true;
+              }
+              function charAllowsIdeographicBreaking(char) {
+                if (char < 11904) {
+                  return false;
+                }
+                if (unicodeBlockLookup["Bopomofo Extended"](char)) {
+                  return true;
+                }
+                if (unicodeBlockLookup["Bopomofo"](char)) {
+                  return true;
+                }
+                if (unicodeBlockLookup["CJK Compatibility Forms"](char)) {
+                  return true;
+                }
+                if (unicodeBlockLookup["CJK Compatibility Ideographs"](char)) {
+                  return true;
+                }
+                if (unicodeBlockLookup["CJK Compatibility"](char)) {
+                  return true;
+                }
+                if (unicodeBlockLookup["CJK Radicals Supplement"](char)) {
+                  return true;
+                }
+                if (unicodeBlockLookup["CJK Strokes"](char)) {
+                  return true;
+                }
+                if (unicodeBlockLookup["CJK Symbols and Punctuation"](char)) {
+                  return true;
+                }
+                if (unicodeBlockLookup["CJK Unified Ideographs Extension A"](char)) {
+                  return true;
+                }
+                if (unicodeBlockLookup["CJK Unified Ideographs"](char)) {
+                  return true;
+                }
+                if (unicodeBlockLookup["Enclosed CJK Letters and Months"](char)) {
+                  return true;
+                }
+                if (unicodeBlockLookup["Halfwidth and Fullwidth Forms"](char)) {
+                  return true;
+                }
+                if (unicodeBlockLookup["Hiragana"](char)) {
+                  return true;
+                }
+                if (unicodeBlockLookup["Ideographic Description Characters"](char)) {
+                  return true;
+                }
+                if (unicodeBlockLookup["Kangxi Radicals"](char)) {
+                  return true;
+                }
+                if (unicodeBlockLookup["Katakana Phonetic Extensions"](char)) {
+                  return true;
+                }
+                if (unicodeBlockLookup["Katakana"](char)) {
+                  return true;
+                }
+                if (unicodeBlockLookup["Vertical Forms"](char)) {
+                  return true;
+                }
+                if (unicodeBlockLookup["Yi Radicals"](char)) {
+                  return true;
+                }
+                if (unicodeBlockLookup["Yi Syllables"](char)) {
+                  return true;
+                }
+                return false;
+              }
+              function charHasUprightVerticalOrientation(char) {
+                if (char === 746 || char === 747) {
+                  return true;
+                }
+                if (char < 4352) {
+                  return false;
+                }
+                if (unicodeBlockLookup["Bopomofo Extended"](char)) {
+                  return true;
+                }
+                if (unicodeBlockLookup["Bopomofo"](char)) {
+                  return true;
+                }
+                if (unicodeBlockLookup["CJK Compatibility Forms"](char)) {
+                  if (!(char >= 65097 && char <= 65103)) {
+                    return true;
+                  }
+                }
+                if (unicodeBlockLookup["CJK Compatibility Ideographs"](char)) {
+                  return true;
+                }
+                if (unicodeBlockLookup["CJK Compatibility"](char)) {
+                  return true;
+                }
+                if (unicodeBlockLookup["CJK Radicals Supplement"](char)) {
+                  return true;
+                }
+                if (unicodeBlockLookup["CJK Strokes"](char)) {
+                  return true;
+                }
+                if (unicodeBlockLookup["CJK Symbols and Punctuation"](char)) {
+                  if (!(char >= 12296 && char <= 12305) && !(char >= 12308 && char <= 12319) && char !== 12336) {
+                    return true;
+                  }
+                }
+                if (unicodeBlockLookup["CJK Unified Ideographs Extension A"](char)) {
+                  return true;
+                }
+                if (unicodeBlockLookup["CJK Unified Ideographs"](char)) {
+                  return true;
+                }
+                if (unicodeBlockLookup["Enclosed CJK Letters and Months"](char)) {
+                  return true;
+                }
+                if (unicodeBlockLookup["Hangul Compatibility Jamo"](char)) {
+                  return true;
+                }
+                if (unicodeBlockLookup["Hangul Jamo Extended-A"](char)) {
+                  return true;
+                }
+                if (unicodeBlockLookup["Hangul Jamo Extended-B"](char)) {
+                  return true;
+                }
+                if (unicodeBlockLookup["Hangul Jamo"](char)) {
+                  return true;
+                }
+                if (unicodeBlockLookup["Hangul Syllables"](char)) {
+                  return true;
+                }
+                if (unicodeBlockLookup["Hiragana"](char)) {
+                  return true;
+                }
+                if (unicodeBlockLookup["Ideographic Description Characters"](char)) {
+                  return true;
+                }
+                if (unicodeBlockLookup["Kanbun"](char)) {
+                  return true;
+                }
+                if (unicodeBlockLookup["Kangxi Radicals"](char)) {
+                  return true;
+                }
+                if (unicodeBlockLookup["Katakana Phonetic Extensions"](char)) {
+                  return true;
+                }
+                if (unicodeBlockLookup["Katakana"](char)) {
+                  if (char !== 12540) {
+                    return true;
+                  }
+                }
+                if (unicodeBlockLookup["Halfwidth and Fullwidth Forms"](char)) {
+                  if (char !== 65288 && char !== 65289 && char !== 65293 && !(char >= 65306 && char <= 65310) && char !== 65339 && char !== 65341 && char !== 65343 && !(char >= 65371 && char <= 65503) && char !== 65507 && !(char >= 65512 && char <= 65519)) {
+                    return true;
+                  }
+                }
+                if (unicodeBlockLookup["Small Form Variants"](char)) {
+                  if (!(char >= 65112 && char <= 65118) && !(char >= 65123 && char <= 65126)) {
+                    return true;
+                  }
+                }
+                if (unicodeBlockLookup["Unified Canadian Aboriginal Syllabics"](char)) {
+                  return true;
+                }
+                if (unicodeBlockLookup["Unified Canadian Aboriginal Syllabics Extended"](char)) {
+                  return true;
+                }
+                if (unicodeBlockLookup["Vertical Forms"](char)) {
+                  return true;
+                }
+                if (unicodeBlockLookup["Yijing Hexagram Symbols"](char)) {
+                  return true;
+                }
+                if (unicodeBlockLookup["Yi Syllables"](char)) {
+                  return true;
+                }
+                if (unicodeBlockLookup["Yi Radicals"](char)) {
+                  return true;
+                }
+                return false;
+              }
+              function charHasNeutralVerticalOrientation(char) {
+                if (unicodeBlockLookup["Latin-1 Supplement"](char)) {
+                  if (char === 167 || char === 169 || char === 174 || char === 177 || char === 188 || char === 189 || char === 190 || char === 215 || char === 247) {
+                    return true;
+                  }
+                }
+                if (unicodeBlockLookup["General Punctuation"](char)) {
+                  if (char === 8214 || char === 8224 || char === 8225 || char === 8240 || char === 8241 || char === 8251 || char === 8252 || char === 8258 || char === 8263 || char === 8264 || char === 8265 || char === 8273) {
+                    return true;
+                  }
+                }
+                if (unicodeBlockLookup["Letterlike Symbols"](char)) {
+                  return true;
+                }
+                if (unicodeBlockLookup["Number Forms"](char)) {
+                  return true;
+                }
+                if (unicodeBlockLookup["Miscellaneous Technical"](char)) {
+                  if (char >= 8960 && char <= 8967 || char >= 8972 && char <= 8991 || char >= 8996 && char <= 9e3 || char === 9003 || char >= 9085 && char <= 9114 || char >= 9150 && char <= 9165 || char === 9167 || char >= 9169 && char <= 9179 || char >= 9186 && char <= 9215) {
+                    return true;
+                  }
+                }
+                if (unicodeBlockLookup["Control Pictures"](char) && char !== 9251) {
+                  return true;
+                }
+                if (unicodeBlockLookup["Optical Character Recognition"](char)) {
+                  return true;
+                }
+                if (unicodeBlockLookup["Enclosed Alphanumerics"](char)) {
+                  return true;
+                }
+                if (unicodeBlockLookup["Geometric Shapes"](char)) {
+                  return true;
+                }
+                if (unicodeBlockLookup["Miscellaneous Symbols"](char)) {
+                  if (!(char >= 9754 && char <= 9759)) {
+                    return true;
+                  }
+                }
+                if (unicodeBlockLookup["Miscellaneous Symbols and Arrows"](char)) {
+                  if (char >= 11026 && char <= 11055 || char >= 11088 && char <= 11097 || char >= 11192 && char <= 11243) {
+                    return true;
+                  }
+                }
+                if (unicodeBlockLookup["CJK Symbols and Punctuation"](char)) {
+                  return true;
+                }
+                if (unicodeBlockLookup["Katakana"](char)) {
+                  return true;
+                }
+                if (unicodeBlockLookup["Private Use Area"](char)) {
+                  return true;
+                }
+                if (unicodeBlockLookup["CJK Compatibility Forms"](char)) {
+                  return true;
+                }
+                if (unicodeBlockLookup["Small Form Variants"](char)) {
+                  return true;
+                }
+                if (unicodeBlockLookup["Halfwidth and Fullwidth Forms"](char)) {
+                  return true;
+                }
+                if (char === 8734 || char === 8756 || char === 8757 || char >= 9984 && char <= 10087 || char >= 10102 && char <= 10131 || char === 65532 || char === 65533) {
+                  return true;
+                }
+                return false;
+              }
+              function charHasRotatedVerticalOrientation(char) {
+                return !(charHasUprightVerticalOrientation(char) || charHasNeutralVerticalOrientation(char));
+              }
+              function charInComplexShapingScript(char) {
+                return unicodeBlockLookup["Arabic"](char) || unicodeBlockLookup["Arabic Supplement"](char) || unicodeBlockLookup["Arabic Extended-A"](char) || unicodeBlockLookup["Arabic Presentation Forms-A"](char) || unicodeBlockLookup["Arabic Presentation Forms-B"](char);
+              }
+              function charInRTLScript(char) {
+                return char >= 1424 && char <= 2303 || unicodeBlockLookup["Arabic Presentation Forms-A"](char) || unicodeBlockLookup["Arabic Presentation Forms-B"](char);
+              }
+              function charInSupportedScript(char, canRenderRTL) {
+                if (!canRenderRTL && charInRTLScript(char)) {
+                  return false;
+                }
+                if (char >= 2304 && char <= 3583 || char >= 3840 && char <= 4255 || unicodeBlockLookup["Khmer"](char)) {
+                  return false;
+                }
+                return true;
+              }
+              function stringContainsRTLText(chars) {
+                for (var i2 = 0, list = chars; i2 < list.length; i2 += 1) {
+                  var char = list[i2];
+                  if (charInRTLScript(char.charCodeAt(0))) {
+                    return true;
+                  }
+                }
+                return false;
+              }
+              function isStringInSupportedScript(chars, canRenderRTL) {
+                for (var i2 = 0, list = chars; i2 < list.length; i2 += 1) {
+                  var char = list[i2];
+                  if (!charInSupportedScript(char.charCodeAt(0), canRenderRTL)) {
+                    return false;
+                  }
+                }
+                return true;
+              }
+              var status = {
+                unavailable: "unavailable",
+                deferred: "deferred",
+                loading: "loading",
+                loaded: "loaded",
+                error: "error"
+              };
+              var _completionCallback = null;
+              var pluginStatus = status.unavailable;
+              var pluginURL = null;
+              var triggerPluginCompletionEvent = function(error2) {
+                if (error2 && typeof error2 === "string" && error2.indexOf("NetworkError") > -1) {
+                  pluginStatus = status.error;
+                }
+                if (_completionCallback) {
+                  _completionCallback(error2);
+                }
+              };
+              function sendPluginStateToWorker() {
+                evented.fire(new Event2("pluginStateChange", {
+                  pluginStatus,
+                  pluginURL
+                }));
+              }
+              var evented = new Evented();
+              var getRTLTextPluginStatus = function() {
+                return pluginStatus;
+              };
+              var registerForPluginStateChange = function(callback) {
+                callback({
+                  pluginStatus,
+                  pluginURL
+                });
+                evented.on("pluginStateChange", callback);
+                return callback;
+              };
+              var setRTLTextPlugin = function(url, callback, deferred) {
+                if (deferred === void 0)
+                  deferred = false;
+                if (pluginStatus === status.deferred || pluginStatus === status.loading || pluginStatus === status.loaded) {
+                  throw new Error("setRTLTextPlugin cannot be called multiple times.");
+                }
+                pluginURL = exported.resolveURL(url);
+                pluginStatus = status.deferred;
+                _completionCallback = callback;
+                sendPluginStateToWorker();
+                if (!deferred) {
+                  downloadRTLTextPlugin();
+                }
+              };
+              var downloadRTLTextPlugin = function() {
+                if (pluginStatus !== status.deferred || !pluginURL) {
+                  throw new Error("rtl-text-plugin cannot be downloaded unless a pluginURL is specified");
+                }
+                pluginStatus = status.loading;
+                sendPluginStateToWorker();
+                if (pluginURL) {
+                  getArrayBuffer({ url: pluginURL }, function(error2) {
+                    if (error2) {
+                      triggerPluginCompletionEvent(error2);
+                    } else {
+                      pluginStatus = status.loaded;
+                      sendPluginStateToWorker();
+                    }
+                  });
+                }
+              };
+              var plugin = {
+                applyArabicShaping: null,
+                processBidirectionalText: null,
+                processStyledBidirectionalText: null,
+                isLoaded: function isLoaded() {
+                  return pluginStatus === status.loaded || plugin.applyArabicShaping != null;
+                },
+                isLoading: function isLoading() {
+                  return pluginStatus === status.loading;
+                },
+                setState: function setState(state) {
+                  pluginStatus = state.pluginStatus;
+                  pluginURL = state.pluginURL;
+                },
+                isParsed: function isParsed() {
+                  return plugin.applyArabicShaping != null && plugin.processBidirectionalText != null && plugin.processStyledBidirectionalText != null;
+                },
+                getPluginURL: function getPluginURL() {
+                  return pluginURL;
+                }
+              };
+              var lazyLoadRTLTextPlugin = function() {
+                if (!plugin.isLoading() && !plugin.isLoaded() && getRTLTextPluginStatus() === "deferred") {
+                  downloadRTLTextPlugin();
+                }
+              };
+              var EvaluationParameters = function EvaluationParameters2(zoom, options) {
+                this.zoom = zoom;
+                if (options) {
+                  this.now = options.now;
+                  this.fadeDuration = options.fadeDuration;
+                  this.zoomHistory = options.zoomHistory;
+                  this.transition = options.transition;
+                } else {
+                  this.now = 0;
+                  this.fadeDuration = 0;
+                  this.zoomHistory = new ZoomHistory();
+                  this.transition = {};
+                }
+              };
+              EvaluationParameters.prototype.isSupportedScript = function isSupportedScript(str) {
+                return isStringInSupportedScript(str, plugin.isLoaded());
+              };
+              EvaluationParameters.prototype.crossFadingFactor = function crossFadingFactor() {
+                if (this.fadeDuration === 0) {
+                  return 1;
+                } else {
+                  return Math.min((this.now - this.zoomHistory.lastIntegerZoomTime) / this.fadeDuration, 1);
+                }
+              };
+              EvaluationParameters.prototype.getCrossfadeParameters = function getCrossfadeParameters() {
+                var z2 = this.zoom;
+                var fraction = z2 - Math.floor(z2);
+                var t4 = this.crossFadingFactor();
+                return z2 > this.zoomHistory.lastIntegerZoom ? {
+                  fromScale: 2,
+                  toScale: 1,
+                  t: fraction + (1 - fraction) * t4
+                } : {
+                  fromScale: 0.5,
+                  toScale: 1,
+                  t: 1 - (1 - t4) * fraction
+                };
+              };
+              var PropertyValue = function PropertyValue2(property, value) {
+                this.property = property;
+                this.value = value;
+                this.expression = normalizePropertyExpression(value === void 0 ? property.specification.default : value, property.specification);
+              };
+              PropertyValue.prototype.isDataDriven = function isDataDriven() {
+                return this.expression.kind === "source" || this.expression.kind === "composite";
+              };
+              PropertyValue.prototype.possiblyEvaluate = function possiblyEvaluate(parameters, canonical, availableImages) {
+                return this.property.possiblyEvaluate(this, parameters, canonical, availableImages);
+              };
+              var TransitionablePropertyValue = function TransitionablePropertyValue2(property) {
+                this.property = property;
+                this.value = new PropertyValue(property, void 0);
+              };
+              TransitionablePropertyValue.prototype.transitioned = function transitioned(parameters, prior) {
+                return new TransitioningPropertyValue(this.property, this.value, prior, extend2({}, parameters.transition, this.transition), parameters.now);
+              };
+              TransitionablePropertyValue.prototype.untransitioned = function untransitioned() {
+                return new TransitioningPropertyValue(this.property, this.value, null, {}, 0);
+              };
+              var Transitionable = function Transitionable2(properties2) {
+                this._properties = properties2;
+                this._values = Object.create(properties2.defaultTransitionablePropertyValues);
+              };
+              Transitionable.prototype.getValue = function getValue2(name3) {
+                return clone(this._values[name3].value.value);
+              };
+              Transitionable.prototype.setValue = function setValue(name3, value) {
+                if (!this._values.hasOwnProperty(name3)) {
+                  this._values[name3] = new TransitionablePropertyValue(this._values[name3].property);
+                }
+                this._values[name3].value = new PropertyValue(this._values[name3].property, value === null ? void 0 : clone(value));
+              };
+              Transitionable.prototype.getTransition = function getTransition(name3) {
+                return clone(this._values[name3].transition);
+              };
+              Transitionable.prototype.setTransition = function setTransition(name3, value) {
+                if (!this._values.hasOwnProperty(name3)) {
+                  this._values[name3] = new TransitionablePropertyValue(this._values[name3].property);
+                }
+                this._values[name3].transition = clone(value) || void 0;
+              };
+              Transitionable.prototype.serialize = function serialize2() {
+                var result = {};
+                for (var i2 = 0, list = Object.keys(this._values); i2 < list.length; i2 += 1) {
+                  var property = list[i2];
+                  var value = this.getValue(property);
+                  if (value !== void 0) {
+                    result[property] = value;
+                  }
+                  var transition2 = this.getTransition(property);
+                  if (transition2 !== void 0) {
+                    result[property + "-transition"] = transition2;
+                  }
+                }
+                return result;
+              };
+              Transitionable.prototype.transitioned = function transitioned(parameters, prior) {
+                var result = new Transitioning(this._properties);
+                for (var i2 = 0, list = Object.keys(this._values); i2 < list.length; i2 += 1) {
+                  var property = list[i2];
+                  result._values[property] = this._values[property].transitioned(parameters, prior._values[property]);
+                }
+                return result;
+              };
+              Transitionable.prototype.untransitioned = function untransitioned() {
+                var result = new Transitioning(this._properties);
+                for (var i2 = 0, list = Object.keys(this._values); i2 < list.length; i2 += 1) {
+                  var property = list[i2];
+                  result._values[property] = this._values[property].untransitioned();
+                }
+                return result;
+              };
+              var TransitioningPropertyValue = function TransitioningPropertyValue2(property, value, prior, transition2, now2) {
+                this.property = property;
+                this.value = value;
+                this.begin = now2 + transition2.delay || 0;
+                this.end = this.begin + transition2.duration || 0;
+                if (property.specification.transition && (transition2.delay || transition2.duration)) {
+                  this.prior = prior;
+                }
+              };
+              TransitioningPropertyValue.prototype.possiblyEvaluate = function possiblyEvaluate(parameters, canonical, availableImages) {
+                var now2 = parameters.now || 0;
+                var finalValue = this.value.possiblyEvaluate(parameters, canonical, availableImages);
+                var prior = this.prior;
+                if (!prior) {
+                  return finalValue;
+                } else if (now2 > this.end) {
+                  this.prior = null;
+                  return finalValue;
+                } else if (this.value.isDataDriven()) {
+                  this.prior = null;
+                  return finalValue;
+                } else if (now2 < this.begin) {
+                  return prior.possiblyEvaluate(parameters, canonical, availableImages);
+                } else {
+                  var t4 = (now2 - this.begin) / (this.end - this.begin);
+                  return this.property.interpolate(prior.possiblyEvaluate(parameters, canonical, availableImages), finalValue, easeCubicInOut(t4));
+                }
+              };
+              var Transitioning = function Transitioning2(properties2) {
+                this._properties = properties2;
+                this._values = Object.create(properties2.defaultTransitioningPropertyValues);
+              };
+              Transitioning.prototype.possiblyEvaluate = function possiblyEvaluate(parameters, canonical, availableImages) {
+                var result = new PossiblyEvaluated(this._properties);
+                for (var i2 = 0, list = Object.keys(this._values); i2 < list.length; i2 += 1) {
+                  var property = list[i2];
+                  result._values[property] = this._values[property].possiblyEvaluate(parameters, canonical, availableImages);
+                }
+                return result;
+              };
+              Transitioning.prototype.hasTransition = function hasTransition() {
+                for (var i2 = 0, list = Object.keys(this._values); i2 < list.length; i2 += 1) {
+                  var property = list[i2];
+                  if (this._values[property].prior) {
+                    return true;
+                  }
+                }
+                return false;
+              };
+              var Layout = function Layout2(properties2) {
+                this._properties = properties2;
+                this._values = Object.create(properties2.defaultPropertyValues);
+              };
+              Layout.prototype.getValue = function getValue2(name3) {
+                return clone(this._values[name3].value);
+              };
+              Layout.prototype.setValue = function setValue(name3, value) {
+                this._values[name3] = new PropertyValue(this._values[name3].property, value === null ? void 0 : clone(value));
+              };
+              Layout.prototype.serialize = function serialize2() {
+                var result = {};
+                for (var i2 = 0, list = Object.keys(this._values); i2 < list.length; i2 += 1) {
+                  var property = list[i2];
+                  var value = this.getValue(property);
+                  if (value !== void 0) {
+                    result[property] = value;
+                  }
+                }
+                return result;
+              };
+              Layout.prototype.possiblyEvaluate = function possiblyEvaluate(parameters, canonical, availableImages) {
+                var result = new PossiblyEvaluated(this._properties);
+                for (var i2 = 0, list = Object.keys(this._values); i2 < list.length; i2 += 1) {
+                  var property = list[i2];
+                  result._values[property] = this._values[property].possiblyEvaluate(parameters, canonical, availableImages);
+                }
+                return result;
+              };
+              var PossiblyEvaluatedPropertyValue = function PossiblyEvaluatedPropertyValue2(property, value, parameters) {
+                this.property = property;
+                this.value = value;
+                this.parameters = parameters;
+              };
+              PossiblyEvaluatedPropertyValue.prototype.isConstant = function isConstant2() {
+                return this.value.kind === "constant";
+              };
+              PossiblyEvaluatedPropertyValue.prototype.constantOr = function constantOr(value) {
+                if (this.value.kind === "constant") {
+                  return this.value.value;
+                } else {
+                  return value;
+                }
+              };
+              PossiblyEvaluatedPropertyValue.prototype.evaluate = function evaluate(feature, featureState, canonical, availableImages) {
+                return this.property.evaluate(this.value, this.parameters, feature, featureState, canonical, availableImages);
+              };
+              var PossiblyEvaluated = function PossiblyEvaluated2(properties2) {
+                this._properties = properties2;
+                this._values = Object.create(properties2.defaultPossiblyEvaluatedValues);
+              };
+              PossiblyEvaluated.prototype.get = function get2(name3) {
+                return this._values[name3];
+              };
+              var DataConstantProperty = function DataConstantProperty2(specification) {
+                this.specification = specification;
+              };
+              DataConstantProperty.prototype.possiblyEvaluate = function possiblyEvaluate(value, parameters) {
+                return value.expression.evaluate(parameters);
+              };
+              DataConstantProperty.prototype.interpolate = function interpolate$1(a2, b2, t4) {
+                var interp = interpolate[this.specification.type];
+                if (interp) {
+                  return interp(a2, b2, t4);
+                } else {
+                  return a2;
+                }
+              };
+              var DataDrivenProperty = function DataDrivenProperty2(specification, overrides) {
+                this.specification = specification;
+                this.overrides = overrides;
+              };
+              DataDrivenProperty.prototype.possiblyEvaluate = function possiblyEvaluate(value, parameters, canonical, availableImages) {
+                if (value.expression.kind === "constant" || value.expression.kind === "camera") {
+                  return new PossiblyEvaluatedPropertyValue(this, {
+                    kind: "constant",
+                    value: value.expression.evaluate(parameters, null, {}, canonical, availableImages)
+                  }, parameters);
+                } else {
+                  return new PossiblyEvaluatedPropertyValue(this, value.expression, parameters);
+                }
+              };
+              DataDrivenProperty.prototype.interpolate = function interpolate$2(a2, b2, t4) {
+                if (a2.value.kind !== "constant" || b2.value.kind !== "constant") {
+                  return a2;
+                }
+                if (a2.value.value === void 0 || b2.value.value === void 0) {
+                  return new PossiblyEvaluatedPropertyValue(this, {
+                    kind: "constant",
+                    value: void 0
+                  }, a2.parameters);
+                }
+                var interp = interpolate[this.specification.type];
+                if (interp) {
+                  return new PossiblyEvaluatedPropertyValue(this, {
+                    kind: "constant",
+                    value: interp(a2.value.value, b2.value.value, t4)
+                  }, a2.parameters);
+                } else {
+                  return a2;
+                }
+              };
+              DataDrivenProperty.prototype.evaluate = function evaluate(value, parameters, feature, featureState, canonical, availableImages) {
+                if (value.kind === "constant") {
+                  return value.value;
+                } else {
+                  return value.evaluate(parameters, feature, featureState, canonical, availableImages);
+                }
+              };
+              var CrossFadedDataDrivenProperty = function(DataDrivenProperty2) {
+                function CrossFadedDataDrivenProperty2() {
+                  DataDrivenProperty2.apply(this, arguments);
+                }
+                if (DataDrivenProperty2)
+                  CrossFadedDataDrivenProperty2.__proto__ = DataDrivenProperty2;
+                CrossFadedDataDrivenProperty2.prototype = Object.create(DataDrivenProperty2 && DataDrivenProperty2.prototype);
+                CrossFadedDataDrivenProperty2.prototype.constructor = CrossFadedDataDrivenProperty2;
+                CrossFadedDataDrivenProperty2.prototype.possiblyEvaluate = function possiblyEvaluate(value, parameters, canonical, availableImages) {
+                  if (value.value === void 0) {
+                    return new PossiblyEvaluatedPropertyValue(this, {
+                      kind: "constant",
+                      value: void 0
+                    }, parameters);
+                  } else if (value.expression.kind === "constant") {
+                    var evaluatedValue = value.expression.evaluate(parameters, null, {}, canonical, availableImages);
+                    var isImageExpression = value.property.specification.type === "resolvedImage";
+                    var constantValue = isImageExpression && typeof evaluatedValue !== "string" ? evaluatedValue.name : evaluatedValue;
+                    var constant = this._calculate(constantValue, constantValue, constantValue, parameters);
+                    return new PossiblyEvaluatedPropertyValue(this, {
+                      kind: "constant",
+                      value: constant
+                    }, parameters);
+                  } else if (value.expression.kind === "camera") {
+                    var cameraVal = this._calculate(value.expression.evaluate({ zoom: parameters.zoom - 1 }), value.expression.evaluate({ zoom: parameters.zoom }), value.expression.evaluate({ zoom: parameters.zoom + 1 }), parameters);
+                    return new PossiblyEvaluatedPropertyValue(this, {
+                      kind: "constant",
+                      value: cameraVal
+                    }, parameters);
+                  } else {
+                    return new PossiblyEvaluatedPropertyValue(this, value.expression, parameters);
+                  }
+                };
+                CrossFadedDataDrivenProperty2.prototype.evaluate = function evaluate(value, globals, feature, featureState, canonical, availableImages) {
+                  if (value.kind === "source") {
+                    var constant = value.evaluate(globals, feature, featureState, canonical, availableImages);
+                    return this._calculate(constant, constant, constant, globals);
+                  } else if (value.kind === "composite") {
+                    return this._calculate(value.evaluate({ zoom: Math.floor(globals.zoom) - 1 }, feature, featureState), value.evaluate({ zoom: Math.floor(globals.zoom) }, feature, featureState), value.evaluate({ zoom: Math.floor(globals.zoom) + 1 }, feature, featureState), globals);
+                  } else {
+                    return value.value;
+                  }
+                };
+                CrossFadedDataDrivenProperty2.prototype._calculate = function _calculate(min, mid, max, parameters) {
+                  var z2 = parameters.zoom;
+                  return z2 > parameters.zoomHistory.lastIntegerZoom ? {
+                    from: min,
+                    to: mid
+                  } : {
+                    from: max,
+                    to: mid
+                  };
+                };
+                CrossFadedDataDrivenProperty2.prototype.interpolate = function interpolate2(a2) {
+                  return a2;
+                };
+                return CrossFadedDataDrivenProperty2;
+              }(DataDrivenProperty);
+              var CrossFadedProperty = function CrossFadedProperty2(specification) {
+                this.specification = specification;
+              };
+              CrossFadedProperty.prototype.possiblyEvaluate = function possiblyEvaluate(value, parameters, canonical, availableImages) {
+                if (value.value === void 0) {
+                  return void 0;
+                } else if (value.expression.kind === "constant") {
+                  var constant = value.expression.evaluate(parameters, null, {}, canonical, availableImages);
+                  return this._calculate(constant, constant, constant, parameters);
+                } else {
+                  return this._calculate(value.expression.evaluate(new EvaluationParameters(Math.floor(parameters.zoom - 1), parameters)), value.expression.evaluate(new EvaluationParameters(Math.floor(parameters.zoom), parameters)), value.expression.evaluate(new EvaluationParameters(Math.floor(parameters.zoom + 1), parameters)), parameters);
+                }
+              };
+              CrossFadedProperty.prototype._calculate = function _calculate(min, mid, max, parameters) {
+                var z2 = parameters.zoom;
+                return z2 > parameters.zoomHistory.lastIntegerZoom ? {
+                  from: min,
+                  to: mid
+                } : {
+                  from: max,
+                  to: mid
+                };
+              };
+              CrossFadedProperty.prototype.interpolate = function interpolate2(a2) {
+                return a2;
+              };
+              var ColorRampProperty = function ColorRampProperty2(specification) {
+                this.specification = specification;
+              };
+              ColorRampProperty.prototype.possiblyEvaluate = function possiblyEvaluate(value, parameters, canonical, availableImages) {
+                return !!value.expression.evaluate(parameters, null, {}, canonical, availableImages);
+              };
+              ColorRampProperty.prototype.interpolate = function interpolate2() {
+                return false;
+              };
+              var Properties = function Properties2(properties2) {
+                this.properties = properties2;
+                this.defaultPropertyValues = {};
+                this.defaultTransitionablePropertyValues = {};
+                this.defaultTransitioningPropertyValues = {};
+                this.defaultPossiblyEvaluatedValues = {};
+                this.overridableProperties = [];
+                for (var property in properties2) {
+                  var prop = properties2[property];
+                  if (prop.specification.overridable) {
+                    this.overridableProperties.push(property);
+                  }
+                  var defaultPropertyValue = this.defaultPropertyValues[property] = new PropertyValue(prop, void 0);
+                  var defaultTransitionablePropertyValue = this.defaultTransitionablePropertyValues[property] = new TransitionablePropertyValue(prop);
+                  this.defaultTransitioningPropertyValues[property] = defaultTransitionablePropertyValue.untransitioned();
+                  this.defaultPossiblyEvaluatedValues[property] = defaultPropertyValue.possiblyEvaluate({});
+                }
+              };
+              register2("DataDrivenProperty", DataDrivenProperty);
+              register2("DataConstantProperty", DataConstantProperty);
+              register2("CrossFadedDataDrivenProperty", CrossFadedDataDrivenProperty);
+              register2("CrossFadedProperty", CrossFadedProperty);
+              register2("ColorRampProperty", ColorRampProperty);
+              var TRANSITION_SUFFIX = "-transition";
+              var StyleLayer = function(Evented2) {
+                function StyleLayer2(layer2, properties2) {
+                  Evented2.call(this);
+                  this.id = layer2.id;
+                  this.type = layer2.type;
+                  this._featureFilter = {
+                    filter: function() {
+                      return true;
+                    },
+                    needGeometry: false
+                  };
+                  if (layer2.type === "custom") {
+                    return;
+                  }
+                  layer2 = layer2;
+                  this.metadata = layer2.metadata;
+                  this.minzoom = layer2.minzoom;
+                  this.maxzoom = layer2.maxzoom;
+                  if (layer2.type !== "background") {
+                    this.source = layer2.source;
+                    this.sourceLayer = layer2["source-layer"];
+                    this.filter = layer2.filter;
+                  }
+                  if (properties2.layout) {
+                    this._unevaluatedLayout = new Layout(properties2.layout);
+                  }
+                  if (properties2.paint) {
+                    this._transitionablePaint = new Transitionable(properties2.paint);
+                    for (var property in layer2.paint) {
+                      this.setPaintProperty(property, layer2.paint[property], { validate: false });
+                    }
+                    for (var property$1 in layer2.layout) {
+                      this.setLayoutProperty(property$1, layer2.layout[property$1], { validate: false });
+                    }
+                    this._transitioningPaint = this._transitionablePaint.untransitioned();
+                    this.paint = new PossiblyEvaluated(properties2.paint);
+                  }
+                }
+                if (Evented2)
+                  StyleLayer2.__proto__ = Evented2;
+                StyleLayer2.prototype = Object.create(Evented2 && Evented2.prototype);
+                StyleLayer2.prototype.constructor = StyleLayer2;
+                StyleLayer2.prototype.getCrossfadeParameters = function getCrossfadeParameters() {
+                  return this._crossfadeParameters;
+                };
+                StyleLayer2.prototype.getLayoutProperty = function getLayoutProperty(name3) {
+                  if (name3 === "visibility") {
+                    return this.visibility;
+                  }
+                  return this._unevaluatedLayout.getValue(name3);
+                };
+                StyleLayer2.prototype.setLayoutProperty = function setLayoutProperty(name3, value, options) {
+                  if (options === void 0)
+                    options = {};
+                  if (value !== null && value !== void 0) {
+                    var key = "layers." + this.id + ".layout." + name3;
+                    if (this._validate(validateLayoutProperty$1, key, name3, value, options)) {
+                      return;
+                    }
+                  }
+                  if (name3 === "visibility") {
+                    this.visibility = value;
+                    return;
+                  }
+                  this._unevaluatedLayout.setValue(name3, value);
+                };
+                StyleLayer2.prototype.getPaintProperty = function getPaintProperty(name3) {
+                  if (endsWith(name3, TRANSITION_SUFFIX)) {
+                    return this._transitionablePaint.getTransition(name3.slice(0, -TRANSITION_SUFFIX.length));
+                  } else {
+                    return this._transitionablePaint.getValue(name3);
+                  }
+                };
+                StyleLayer2.prototype.setPaintProperty = function setPaintProperty(name3, value, options) {
+                  if (options === void 0)
+                    options = {};
+                  if (value !== null && value !== void 0) {
+                    var key = "layers." + this.id + ".paint." + name3;
+                    if (this._validate(validatePaintProperty$1, key, name3, value, options)) {
+                      return false;
+                    }
+                  }
+                  if (endsWith(name3, TRANSITION_SUFFIX)) {
+                    this._transitionablePaint.setTransition(name3.slice(0, -TRANSITION_SUFFIX.length), value || void 0);
+                    return false;
+                  } else {
+                    var transitionable = this._transitionablePaint._values[name3];
+                    var isCrossFadedProperty = transitionable.property.specification["property-type"] === "cross-faded-data-driven";
+                    var wasDataDriven = transitionable.value.isDataDriven();
+                    var oldValue = transitionable.value;
+                    this._transitionablePaint.setValue(name3, value);
+                    this._handleSpecialPaintPropertyUpdate(name3);
+                    var newValue = this._transitionablePaint._values[name3].value;
+                    var isDataDriven = newValue.isDataDriven();
+                    return isDataDriven || wasDataDriven || isCrossFadedProperty || this._handleOverridablePaintPropertyUpdate(name3, oldValue, newValue);
+                  }
+                };
+                StyleLayer2.prototype._handleSpecialPaintPropertyUpdate = function _handleSpecialPaintPropertyUpdate(_2) {
+                };
+                StyleLayer2.prototype._handleOverridablePaintPropertyUpdate = function _handleOverridablePaintPropertyUpdate(name3, oldValue, newValue) {
+                  return false;
+                };
+                StyleLayer2.prototype.isHidden = function isHidden(zoom) {
+                  if (this.minzoom && zoom < this.minzoom) {
+                    return true;
+                  }
+                  if (this.maxzoom && zoom >= this.maxzoom) {
+                    return true;
+                  }
+                  return this.visibility === "none";
+                };
+                StyleLayer2.prototype.updateTransitions = function updateTransitions(parameters) {
+                  this._transitioningPaint = this._transitionablePaint.transitioned(parameters, this._transitioningPaint);
+                };
+                StyleLayer2.prototype.hasTransition = function hasTransition() {
+                  return this._transitioningPaint.hasTransition();
+                };
+                StyleLayer2.prototype.recalculate = function recalculate(parameters, availableImages) {
+                  if (parameters.getCrossfadeParameters) {
+                    this._crossfadeParameters = parameters.getCrossfadeParameters();
+                  }
+                  if (this._unevaluatedLayout) {
+                    this.layout = this._unevaluatedLayout.possiblyEvaluate(parameters, void 0, availableImages);
+                  }
+                  this.paint = this._transitioningPaint.possiblyEvaluate(parameters, void 0, availableImages);
+                };
+                StyleLayer2.prototype.serialize = function serialize2() {
+                  var output = {
+                    "id": this.id,
+                    "type": this.type,
+                    "source": this.source,
+                    "source-layer": this.sourceLayer,
+                    "metadata": this.metadata,
+                    "minzoom": this.minzoom,
+                    "maxzoom": this.maxzoom,
+                    "filter": this.filter,
+                    "layout": this._unevaluatedLayout && this._unevaluatedLayout.serialize(),
+                    "paint": this._transitionablePaint && this._transitionablePaint.serialize()
+                  };
+                  if (this.visibility) {
+                    output.layout = output.layout || {};
+                    output.layout.visibility = this.visibility;
+                  }
+                  return filterObject(output, function(value, key) {
+                    return value !== void 0 && !(key === "layout" && !Object.keys(value).length) && !(key === "paint" && !Object.keys(value).length);
+                  });
+                };
+                StyleLayer2.prototype._validate = function _validate(validate2, key, name3, value, options) {
+                  if (options === void 0)
+                    options = {};
+                  if (options && options.validate === false) {
+                    return false;
+                  }
+                  return emitValidationErrors(this, validate2.call(validateStyle, {
+                    key,
+                    layerType: this.type,
+                    objectKey: name3,
+                    value,
+                    styleSpec: spec,
+                    style: {
+                      glyphs: true,
+                      sprite: true
+                    }
+                  }));
+                };
+                StyleLayer2.prototype.is3D = function is3D() {
+                  return false;
+                };
+                StyleLayer2.prototype.isTileClipped = function isTileClipped() {
+                  return false;
+                };
+                StyleLayer2.prototype.hasOffscreenPass = function hasOffscreenPass() {
+                  return false;
+                };
+                StyleLayer2.prototype.resize = function resize() {
+                };
+                StyleLayer2.prototype.isStateDependent = function isStateDependent() {
+                  for (var property in this.paint._values) {
+                    var value = this.paint.get(property);
+                    if (!(value instanceof PossiblyEvaluatedPropertyValue) || !supportsPropertyExpression(value.property.specification)) {
+                      continue;
+                    }
+                    if ((value.value.kind === "source" || value.value.kind === "composite") && value.value.isStateDependent) {
+                      return true;
+                    }
+                  }
+                  return false;
+                };
+                return StyleLayer2;
+              }(Evented);
+              var viewTypes = {
+                "Int8": Int8Array,
+                "Uint8": Uint8Array,
+                "Int16": Int16Array,
+                "Uint16": Uint16Array,
+                "Int32": Int32Array,
+                "Uint32": Uint32Array,
+                "Float32": Float32Array
+              };
+              var Struct2 = function Struct22(structArray, index) {
+                this._structArray = structArray;
+                this._pos1 = index * this.size;
+                this._pos2 = this._pos1 / 2;
+                this._pos4 = this._pos1 / 4;
+                this._pos8 = this._pos1 / 8;
+              };
+              var DEFAULT_CAPACITY = 128;
+              var RESIZE_MULTIPLIER = 5;
+              var StructArray = function StructArray2() {
+                this.isTransferred = false;
+                this.capacity = -1;
+                this.resize(0);
+              };
+              StructArray.serialize = function serialize2(array2, transferables) {
+                array2._trim();
+                if (transferables) {
+                  array2.isTransferred = true;
+                  transferables.push(array2.arrayBuffer);
+                }
+                return {
+                  length: array2.length,
+                  arrayBuffer: array2.arrayBuffer
+                };
+              };
+              StructArray.deserialize = function deserialize2(input) {
+                var structArray = Object.create(this.prototype);
+                structArray.arrayBuffer = input.arrayBuffer;
+                structArray.length = input.length;
+                structArray.capacity = input.arrayBuffer.byteLength / structArray.bytesPerElement;
+                structArray._refreshViews();
+                return structArray;
+              };
+              StructArray.prototype._trim = function _trim() {
+                if (this.length !== this.capacity) {
+                  this.capacity = this.length;
+                  this.arrayBuffer = this.arrayBuffer.slice(0, this.length * this.bytesPerElement);
+                  this._refreshViews();
+                }
+              };
+              StructArray.prototype.clear = function clear() {
+                this.length = 0;
+              };
+              StructArray.prototype.resize = function resize(n2) {
+                this.reserve(n2);
+                this.length = n2;
+              };
+              StructArray.prototype.reserve = function reserve(n2) {
+                if (n2 > this.capacity) {
+                  this.capacity = Math.max(n2, Math.floor(this.capacity * RESIZE_MULTIPLIER), DEFAULT_CAPACITY);
+                  this.arrayBuffer = new ArrayBuffer(this.capacity * this.bytesPerElement);
+                  var oldUint8Array = this.uint8;
+                  this._refreshViews();
+                  if (oldUint8Array) {
+                    this.uint8.set(oldUint8Array);
+                  }
+                }
+              };
+              StructArray.prototype._refreshViews = function _refreshViews() {
+                throw new Error("_refreshViews() must be implemented by each concrete StructArray layout");
+              };
+              function createLayout(members2, alignment) {
+                if (alignment === void 0)
+                  alignment = 1;
+                var offset = 0;
+                var maxSize = 0;
+                var layoutMembers = members2.map(function(member) {
+                  var typeSize = sizeOf(member.type);
+                  var memberOffset = offset = align(offset, Math.max(alignment, typeSize));
+                  var components = member.components || 1;
+                  maxSize = Math.max(maxSize, typeSize);
+                  offset += typeSize * components;
+                  return {
+                    name: member.name,
+                    type: member.type,
+                    components,
+                    offset: memberOffset
+                  };
+                });
+                var size = align(offset, Math.max(maxSize, alignment));
+                return {
+                  members: layoutMembers,
+                  size,
+                  alignment
+                };
+              }
+              function sizeOf(type) {
+                return viewTypes[type].BYTES_PER_ELEMENT;
+              }
+              function align(offset, size) {
+                return Math.ceil(offset / size) * size;
+              }
+              var StructArrayLayout2i4 = function(StructArray2) {
+                function StructArrayLayout2i42() {
+                  StructArray2.apply(this, arguments);
+                }
+                if (StructArray2)
+                  StructArrayLayout2i42.__proto__ = StructArray2;
+                StructArrayLayout2i42.prototype = Object.create(StructArray2 && StructArray2.prototype);
+                StructArrayLayout2i42.prototype.constructor = StructArrayLayout2i42;
+                StructArrayLayout2i42.prototype._refreshViews = function _refreshViews() {
+                  this.uint8 = new Uint8Array(this.arrayBuffer);
+                  this.int16 = new Int16Array(this.arrayBuffer);
+                };
+                StructArrayLayout2i42.prototype.emplaceBack = function emplaceBack(v0, v1) {
+                  var i2 = this.length;
+                  this.resize(i2 + 1);
+                  return this.emplace(i2, v0, v1);
+                };
+                StructArrayLayout2i42.prototype.emplace = function emplace(i2, v0, v1) {
+                  var o2 = i2 * 2;
+                  this.int16[o2 + 0] = v0;
+                  this.int16[o2 + 1] = v1;
+                  return i2;
+                };
+                return StructArrayLayout2i42;
+              }(StructArray);
+              StructArrayLayout2i4.prototype.bytesPerElement = 4;
+              register2("StructArrayLayout2i4", StructArrayLayout2i4);
+              var StructArrayLayout4i8 = function(StructArray2) {
+                function StructArrayLayout4i82() {
+                  StructArray2.apply(this, arguments);
+                }
+                if (StructArray2)
+                  StructArrayLayout4i82.__proto__ = StructArray2;
+                StructArrayLayout4i82.prototype = Object.create(StructArray2 && StructArray2.prototype);
+                StructArrayLayout4i82.prototype.constructor = StructArrayLayout4i82;
+                StructArrayLayout4i82.prototype._refreshViews = function _refreshViews() {
+                  this.uint8 = new Uint8Array(this.arrayBuffer);
+                  this.int16 = new Int16Array(this.arrayBuffer);
+                };
+                StructArrayLayout4i82.prototype.emplaceBack = function emplaceBack(v0, v1, v2, v3) {
+                  var i2 = this.length;
+                  this.resize(i2 + 1);
+                  return this.emplace(i2, v0, v1, v2, v3);
+                };
+                StructArrayLayout4i82.prototype.emplace = function emplace(i2, v0, v1, v2, v3) {
+                  var o2 = i2 * 4;
+                  this.int16[o2 + 0] = v0;
+                  this.int16[o2 + 1] = v1;
+                  this.int16[o2 + 2] = v2;
+                  this.int16[o2 + 3] = v3;
+                  return i2;
+                };
+                return StructArrayLayout4i82;
+              }(StructArray);
+              StructArrayLayout4i8.prototype.bytesPerElement = 8;
+              register2("StructArrayLayout4i8", StructArrayLayout4i8);
+              var StructArrayLayout2i4i12 = function(StructArray2) {
+                function StructArrayLayout2i4i122() {
+                  StructArray2.apply(this, arguments);
+                }
+                if (StructArray2)
+                  StructArrayLayout2i4i122.__proto__ = StructArray2;
+                StructArrayLayout2i4i122.prototype = Object.create(StructArray2 && StructArray2.prototype);
+                StructArrayLayout2i4i122.prototype.constructor = StructArrayLayout2i4i122;
+                StructArrayLayout2i4i122.prototype._refreshViews = function _refreshViews() {
+                  this.uint8 = new Uint8Array(this.arrayBuffer);
+                  this.int16 = new Int16Array(this.arrayBuffer);
+                };
+                StructArrayLayout2i4i122.prototype.emplaceBack = function emplaceBack(v0, v1, v2, v3, v4, v5) {
+                  var i2 = this.length;
+                  this.resize(i2 + 1);
+                  return this.emplace(i2, v0, v1, v2, v3, v4, v5);
+                };
+                StructArrayLayout2i4i122.prototype.emplace = function emplace(i2, v0, v1, v2, v3, v4, v5) {
+                  var o2 = i2 * 6;
+                  this.int16[o2 + 0] = v0;
+                  this.int16[o2 + 1] = v1;
+                  this.int16[o2 + 2] = v2;
+                  this.int16[o2 + 3] = v3;
+                  this.int16[o2 + 4] = v4;
+                  this.int16[o2 + 5] = v5;
+                  return i2;
+                };
+                return StructArrayLayout2i4i122;
+              }(StructArray);
+              StructArrayLayout2i4i12.prototype.bytesPerElement = 12;
+              register2("StructArrayLayout2i4i12", StructArrayLayout2i4i12);
+              var StructArrayLayout2i4ub8 = function(StructArray2) {
+                function StructArrayLayout2i4ub82() {
+                  StructArray2.apply(this, arguments);
+                }
+                if (StructArray2)
+                  StructArrayLayout2i4ub82.__proto__ = StructArray2;
+                StructArrayLayout2i4ub82.prototype = Object.create(StructArray2 && StructArray2.prototype);
+                StructArrayLayout2i4ub82.prototype.constructor = StructArrayLayout2i4ub82;
+                StructArrayLayout2i4ub82.prototype._refreshViews = function _refreshViews() {
+                  this.uint8 = new Uint8Array(this.arrayBuffer);
+                  this.int16 = new Int16Array(this.arrayBuffer);
+                };
+                StructArrayLayout2i4ub82.prototype.emplaceBack = function emplaceBack(v0, v1, v2, v3, v4, v5) {
+                  var i2 = this.length;
+                  this.resize(i2 + 1);
+                  return this.emplace(i2, v0, v1, v2, v3, v4, v5);
+                };
+                StructArrayLayout2i4ub82.prototype.emplace = function emplace(i2, v0, v1, v2, v3, v4, v5) {
+                  var o2 = i2 * 4;
+                  var o1 = i2 * 8;
+                  this.int16[o2 + 0] = v0;
+                  this.int16[o2 + 1] = v1;
+                  this.uint8[o1 + 4] = v2;
+                  this.uint8[o1 + 5] = v3;
+                  this.uint8[o1 + 6] = v4;
+                  this.uint8[o1 + 7] = v5;
+                  return i2;
+                };
+                return StructArrayLayout2i4ub82;
+              }(StructArray);
+              StructArrayLayout2i4ub8.prototype.bytesPerElement = 8;
+              register2("StructArrayLayout2i4ub8", StructArrayLayout2i4ub8);
+              var StructArrayLayout2f8 = function(StructArray2) {
+                function StructArrayLayout2f82() {
+                  StructArray2.apply(this, arguments);
+                }
+                if (StructArray2)
+                  StructArrayLayout2f82.__proto__ = StructArray2;
+                StructArrayLayout2f82.prototype = Object.create(StructArray2 && StructArray2.prototype);
+                StructArrayLayout2f82.prototype.constructor = StructArrayLayout2f82;
+                StructArrayLayout2f82.prototype._refreshViews = function _refreshViews() {
+                  this.uint8 = new Uint8Array(this.arrayBuffer);
+                  this.float32 = new Float32Array(this.arrayBuffer);
+                };
+                StructArrayLayout2f82.prototype.emplaceBack = function emplaceBack(v0, v1) {
+                  var i2 = this.length;
+                  this.resize(i2 + 1);
+                  return this.emplace(i2, v0, v1);
+                };
+                StructArrayLayout2f82.prototype.emplace = function emplace(i2, v0, v1) {
+                  var o4 = i2 * 2;
+                  this.float32[o4 + 0] = v0;
+                  this.float32[o4 + 1] = v1;
+                  return i2;
+                };
+                return StructArrayLayout2f82;
+              }(StructArray);
+              StructArrayLayout2f8.prototype.bytesPerElement = 8;
+              register2("StructArrayLayout2f8", StructArrayLayout2f8);
+              var StructArrayLayout10ui20 = function(StructArray2) {
+                function StructArrayLayout10ui202() {
+                  StructArray2.apply(this, arguments);
+                }
+                if (StructArray2)
+                  StructArrayLayout10ui202.__proto__ = StructArray2;
+                StructArrayLayout10ui202.prototype = Object.create(StructArray2 && StructArray2.prototype);
+                StructArrayLayout10ui202.prototype.constructor = StructArrayLayout10ui202;
+                StructArrayLayout10ui202.prototype._refreshViews = function _refreshViews() {
+                  this.uint8 = new Uint8Array(this.arrayBuffer);
+                  this.uint16 = new Uint16Array(this.arrayBuffer);
+                };
+                StructArrayLayout10ui202.prototype.emplaceBack = function emplaceBack(v0, v1, v2, v3, v4, v5, v6, v7, v8, v9) {
+                  var i2 = this.length;
+                  this.resize(i2 + 1);
+                  return this.emplace(i2, v0, v1, v2, v3, v4, v5, v6, v7, v8, v9);
+                };
+                StructArrayLayout10ui202.prototype.emplace = function emplace(i2, v0, v1, v2, v3, v4, v5, v6, v7, v8, v9) {
+                  var o2 = i2 * 10;
+                  this.uint16[o2 + 0] = v0;
+                  this.uint16[o2 + 1] = v1;
+                  this.uint16[o2 + 2] = v2;
+                  this.uint16[o2 + 3] = v3;
+                  this.uint16[o2 + 4] = v4;
+                  this.uint16[o2 + 5] = v5;
+                  this.uint16[o2 + 6] = v6;
+                  this.uint16[o2 + 7] = v7;
+                  this.uint16[o2 + 8] = v8;
+                  this.uint16[o2 + 9] = v9;
+                  return i2;
+                };
+                return StructArrayLayout10ui202;
+              }(StructArray);
+              StructArrayLayout10ui20.prototype.bytesPerElement = 20;
+              register2("StructArrayLayout10ui20", StructArrayLayout10ui20);
+              var StructArrayLayout4i4ui4i24 = function(StructArray2) {
+                function StructArrayLayout4i4ui4i242() {
+                  StructArray2.apply(this, arguments);
+                }
+                if (StructArray2)
+                  StructArrayLayout4i4ui4i242.__proto__ = StructArray2;
+                StructArrayLayout4i4ui4i242.prototype = Object.create(StructArray2 && StructArray2.prototype);
+                StructArrayLayout4i4ui4i242.prototype.constructor = StructArrayLayout4i4ui4i242;
+                StructArrayLayout4i4ui4i242.prototype._refreshViews = function _refreshViews() {
+                  this.uint8 = new Uint8Array(this.arrayBuffer);
+                  this.int16 = new Int16Array(this.arrayBuffer);
+                  this.uint16 = new Uint16Array(this.arrayBuffer);
+                };
+                StructArrayLayout4i4ui4i242.prototype.emplaceBack = function emplaceBack(v0, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11) {
+                  var i2 = this.length;
+                  this.resize(i2 + 1);
+                  return this.emplace(i2, v0, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11);
+                };
+                StructArrayLayout4i4ui4i242.prototype.emplace = function emplace(i2, v0, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11) {
+                  var o2 = i2 * 12;
+                  this.int16[o2 + 0] = v0;
+                  this.int16[o2 + 1] = v1;
+                  this.int16[o2 + 2] = v2;
+                  this.int16[o2 + 3] = v3;
+                  this.uint16[o2 + 4] = v4;
+                  this.uint16[o2 + 5] = v5;
+                  this.uint16[o2 + 6] = v6;
+                  this.uint16[o2 + 7] = v7;
+                  this.int16[o2 + 8] = v8;
+                  this.int16[o2 + 9] = v9;
+                  this.int16[o2 + 10] = v10;
+                  this.int16[o2 + 11] = v11;
+                  return i2;
+                };
+                return StructArrayLayout4i4ui4i242;
+              }(StructArray);
+              StructArrayLayout4i4ui4i24.prototype.bytesPerElement = 24;
+              register2("StructArrayLayout4i4ui4i24", StructArrayLayout4i4ui4i24);
+              var StructArrayLayout3f12 = function(StructArray2) {
+                function StructArrayLayout3f122() {
+                  StructArray2.apply(this, arguments);
+                }
+                if (StructArray2)
+                  StructArrayLayout3f122.__proto__ = StructArray2;
+                StructArrayLayout3f122.prototype = Object.create(StructArray2 && StructArray2.prototype);
+                StructArrayLayout3f122.prototype.constructor = StructArrayLayout3f122;
+                StructArrayLayout3f122.prototype._refreshViews = function _refreshViews() {
+                  this.uint8 = new Uint8Array(this.arrayBuffer);
+                  this.float32 = new Float32Array(this.arrayBuffer);
+                };
+                StructArrayLayout3f122.prototype.emplaceBack = function emplaceBack(v0, v1, v2) {
+                  var i2 = this.length;
+                  this.resize(i2 + 1);
+                  return this.emplace(i2, v0, v1, v2);
+                };
+                StructArrayLayout3f122.prototype.emplace = function emplace(i2, v0, v1, v2) {
+                  var o4 = i2 * 3;
+                  this.float32[o4 + 0] = v0;
+                  this.float32[o4 + 1] = v1;
+                  this.float32[o4 + 2] = v2;
+                  return i2;
+                };
+                return StructArrayLayout3f122;
+              }(StructArray);
+              StructArrayLayout3f12.prototype.bytesPerElement = 12;
+              register2("StructArrayLayout3f12", StructArrayLayout3f12);
+              var StructArrayLayout1ul4 = function(StructArray2) {
+                function StructArrayLayout1ul42() {
+                  StructArray2.apply(this, arguments);
+                }
+                if (StructArray2)
+                  StructArrayLayout1ul42.__proto__ = StructArray2;
+                StructArrayLayout1ul42.prototype = Object.create(StructArray2 && StructArray2.prototype);
+                StructArrayLayout1ul42.prototype.constructor = StructArrayLayout1ul42;
+                StructArrayLayout1ul42.prototype._refreshViews = function _refreshViews() {
+                  this.uint8 = new Uint8Array(this.arrayBuffer);
+                  this.uint32 = new Uint32Array(this.arrayBuffer);
+                };
+                StructArrayLayout1ul42.prototype.emplaceBack = function emplaceBack(v0) {
+                  var i2 = this.length;
+                  this.resize(i2 + 1);
+                  return this.emplace(i2, v0);
+                };
+                StructArrayLayout1ul42.prototype.emplace = function emplace(i2, v0) {
+                  var o4 = i2 * 1;
+                  this.uint32[o4 + 0] = v0;
+                  return i2;
+                };
+                return StructArrayLayout1ul42;
+              }(StructArray);
+              StructArrayLayout1ul4.prototype.bytesPerElement = 4;
+              register2("StructArrayLayout1ul4", StructArrayLayout1ul4);
+              var StructArrayLayout6i1ul2ui20 = function(StructArray2) {
+                function StructArrayLayout6i1ul2ui202() {
+                  StructArray2.apply(this, arguments);
+                }
+                if (StructArray2)
+                  StructArrayLayout6i1ul2ui202.__proto__ = StructArray2;
+                StructArrayLayout6i1ul2ui202.prototype = Object.create(StructArray2 && StructArray2.prototype);
+                StructArrayLayout6i1ul2ui202.prototype.constructor = StructArrayLayout6i1ul2ui202;
+                StructArrayLayout6i1ul2ui202.prototype._refreshViews = function _refreshViews() {
+                  this.uint8 = new Uint8Array(this.arrayBuffer);
+                  this.int16 = new Int16Array(this.arrayBuffer);
+                  this.uint32 = new Uint32Array(this.arrayBuffer);
+                  this.uint16 = new Uint16Array(this.arrayBuffer);
+                };
+                StructArrayLayout6i1ul2ui202.prototype.emplaceBack = function emplaceBack(v0, v1, v2, v3, v4, v5, v6, v7, v8) {
+                  var i2 = this.length;
+                  this.resize(i2 + 1);
+                  return this.emplace(i2, v0, v1, v2, v3, v4, v5, v6, v7, v8);
+                };
+                StructArrayLayout6i1ul2ui202.prototype.emplace = function emplace(i2, v0, v1, v2, v3, v4, v5, v6, v7, v8) {
+                  var o2 = i2 * 10;
+                  var o4 = i2 * 5;
+                  this.int16[o2 + 0] = v0;
+                  this.int16[o2 + 1] = v1;
+                  this.int16[o2 + 2] = v2;
+                  this.int16[o2 + 3] = v3;
+                  this.int16[o2 + 4] = v4;
+                  this.int16[o2 + 5] = v5;
+                  this.uint32[o4 + 3] = v6;
+                  this.uint16[o2 + 8] = v7;
+                  this.uint16[o2 + 9] = v8;
+                  return i2;
+                };
+                return StructArrayLayout6i1ul2ui202;
+              }(StructArray);
+              StructArrayLayout6i1ul2ui20.prototype.bytesPerElement = 20;
+              register2("StructArrayLayout6i1ul2ui20", StructArrayLayout6i1ul2ui20);
+              var StructArrayLayout2i2i2i12 = function(StructArray2) {
+                function StructArrayLayout2i2i2i122() {
+                  StructArray2.apply(this, arguments);
+                }
+                if (StructArray2)
+                  StructArrayLayout2i2i2i122.__proto__ = StructArray2;
+                StructArrayLayout2i2i2i122.prototype = Object.create(StructArray2 && StructArray2.prototype);
+                StructArrayLayout2i2i2i122.prototype.constructor = StructArrayLayout2i2i2i122;
+                StructArrayLayout2i2i2i122.prototype._refreshViews = function _refreshViews() {
+                  this.uint8 = new Uint8Array(this.arrayBuffer);
+                  this.int16 = new Int16Array(this.arrayBuffer);
+                };
+                StructArrayLayout2i2i2i122.prototype.emplaceBack = function emplaceBack(v0, v1, v2, v3, v4, v5) {
+                  var i2 = this.length;
+                  this.resize(i2 + 1);
+                  return this.emplace(i2, v0, v1, v2, v3, v4, v5);
+                };
+                StructArrayLayout2i2i2i122.prototype.emplace = function emplace(i2, v0, v1, v2, v3, v4, v5) {
+                  var o2 = i2 * 6;
+                  this.int16[o2 + 0] = v0;
+                  this.int16[o2 + 1] = v1;
+                  this.int16[o2 + 2] = v2;
+                  this.int16[o2 + 3] = v3;
+                  this.int16[o2 + 4] = v4;
+                  this.int16[o2 + 5] = v5;
+                  return i2;
+                };
+                return StructArrayLayout2i2i2i122;
+              }(StructArray);
+              StructArrayLayout2i2i2i12.prototype.bytesPerElement = 12;
+              register2("StructArrayLayout2i2i2i12", StructArrayLayout2i2i2i12);
+              var StructArrayLayout2f1f2i16 = function(StructArray2) {
+                function StructArrayLayout2f1f2i162() {
+                  StructArray2.apply(this, arguments);
+                }
+                if (StructArray2)
+                  StructArrayLayout2f1f2i162.__proto__ = StructArray2;
+                StructArrayLayout2f1f2i162.prototype = Object.create(StructArray2 && StructArray2.prototype);
+                StructArrayLayout2f1f2i162.prototype.constructor = StructArrayLayout2f1f2i162;
+                StructArrayLayout2f1f2i162.prototype._refreshViews = function _refreshViews() {
+                  this.uint8 = new Uint8Array(this.arrayBuffer);
+                  this.float32 = new Float32Array(this.arrayBuffer);
+                  this.int16 = new Int16Array(this.arrayBuffer);
+                };
+                StructArrayLayout2f1f2i162.prototype.emplaceBack = function emplaceBack(v0, v1, v2, v3, v4) {
+                  var i2 = this.length;
+                  this.resize(i2 + 1);
+                  return this.emplace(i2, v0, v1, v2, v3, v4);
+                };
+                StructArrayLayout2f1f2i162.prototype.emplace = function emplace(i2, v0, v1, v2, v3, v4) {
+                  var o4 = i2 * 4;
+                  var o2 = i2 * 8;
+                  this.float32[o4 + 0] = v0;
+                  this.float32[o4 + 1] = v1;
+                  this.float32[o4 + 2] = v2;
+                  this.int16[o2 + 6] = v3;
+                  this.int16[o2 + 7] = v4;
+                  return i2;
+                };
+                return StructArrayLayout2f1f2i162;
+              }(StructArray);
+              StructArrayLayout2f1f2i16.prototype.bytesPerElement = 16;
+              register2("StructArrayLayout2f1f2i16", StructArrayLayout2f1f2i16);
+              var StructArrayLayout2ub2f12 = function(StructArray2) {
+                function StructArrayLayout2ub2f122() {
+                  StructArray2.apply(this, arguments);
+                }
+                if (StructArray2)
+                  StructArrayLayout2ub2f122.__proto__ = StructArray2;
+                StructArrayLayout2ub2f122.prototype = Object.create(StructArray2 && StructArray2.prototype);
+                StructArrayLayout2ub2f122.prototype.constructor = StructArrayLayout2ub2f122;
+                StructArrayLayout2ub2f122.prototype._refreshViews = function _refreshViews() {
+                  this.uint8 = new Uint8Array(this.arrayBuffer);
+                  this.float32 = new Float32Array(this.arrayBuffer);
+                };
+                StructArrayLayout2ub2f122.prototype.emplaceBack = function emplaceBack(v0, v1, v2, v3) {
+                  var i2 = this.length;
+                  this.resize(i2 + 1);
+                  return this.emplace(i2, v0, v1, v2, v3);
+                };
+                StructArrayLayout2ub2f122.prototype.emplace = function emplace(i2, v0, v1, v2, v3) {
+                  var o1 = i2 * 12;
+                  var o4 = i2 * 3;
+                  this.uint8[o1 + 0] = v0;
+                  this.uint8[o1 + 1] = v1;
+                  this.float32[o4 + 1] = v2;
+                  this.float32[o4 + 2] = v3;
+                  return i2;
+                };
+                return StructArrayLayout2ub2f122;
+              }(StructArray);
+              StructArrayLayout2ub2f12.prototype.bytesPerElement = 12;
+              register2("StructArrayLayout2ub2f12", StructArrayLayout2ub2f12);
+              var StructArrayLayout3ui6 = function(StructArray2) {
+                function StructArrayLayout3ui62() {
+                  StructArray2.apply(this, arguments);
+                }
+                if (StructArray2)
+                  StructArrayLayout3ui62.__proto__ = StructArray2;
+                StructArrayLayout3ui62.prototype = Object.create(StructArray2 && StructArray2.prototype);
+                StructArrayLayout3ui62.prototype.constructor = StructArrayLayout3ui62;
+                StructArrayLayout3ui62.prototype._refreshViews = function _refreshViews() {
+                  this.uint8 = new Uint8Array(this.arrayBuffer);
+                  this.uint16 = new Uint16Array(this.arrayBuffer);
+                };
+                StructArrayLayout3ui62.prototype.emplaceBack = function emplaceBack(v0, v1, v2) {
+                  var i2 = this.length;
+                  this.resize(i2 + 1);
+                  return this.emplace(i2, v0, v1, v2);
+                };
+                StructArrayLayout3ui62.prototype.emplace = function emplace(i2, v0, v1, v2) {
+                  var o2 = i2 * 3;
+                  this.uint16[o2 + 0] = v0;
+                  this.uint16[o2 + 1] = v1;
+                  this.uint16[o2 + 2] = v2;
+                  return i2;
+                };
+                return StructArrayLayout3ui62;
+              }(StructArray);
+              StructArrayLayout3ui6.prototype.bytesPerElement = 6;
+              register2("StructArrayLayout3ui6", StructArrayLayout3ui6);
+              var StructArrayLayout2i2ui3ul3ui2f3ub1ul1i48 = function(StructArray2) {
+                function StructArrayLayout2i2ui3ul3ui2f3ub1ul1i482() {
+                  StructArray2.apply(this, arguments);
+                }
+                if (StructArray2)
+                  StructArrayLayout2i2ui3ul3ui2f3ub1ul1i482.__proto__ = StructArray2;
+                StructArrayLayout2i2ui3ul3ui2f3ub1ul1i482.prototype = Object.create(StructArray2 && StructArray2.prototype);
+                StructArrayLayout2i2ui3ul3ui2f3ub1ul1i482.prototype.constructor = StructArrayLayout2i2ui3ul3ui2f3ub1ul1i482;
+                StructArrayLayout2i2ui3ul3ui2f3ub1ul1i482.prototype._refreshViews = function _refreshViews() {
+                  this.uint8 = new Uint8Array(this.arrayBuffer);
+                  this.int16 = new Int16Array(this.arrayBuffer);
+                  this.uint16 = new Uint16Array(this.arrayBuffer);
+                  this.uint32 = new Uint32Array(this.arrayBuffer);
+                  this.float32 = new Float32Array(this.arrayBuffer);
+                };
+                StructArrayLayout2i2ui3ul3ui2f3ub1ul1i482.prototype.emplaceBack = function emplaceBack(v0, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16) {
+                  var i2 = this.length;
+                  this.resize(i2 + 1);
+                  return this.emplace(i2, v0, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16);
+                };
+                StructArrayLayout2i2ui3ul3ui2f3ub1ul1i482.prototype.emplace = function emplace(i2, v0, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16) {
+                  var o2 = i2 * 24;
+                  var o4 = i2 * 12;
+                  var o1 = i2 * 48;
+                  this.int16[o2 + 0] = v0;
+                  this.int16[o2 + 1] = v1;
+                  this.uint16[o2 + 2] = v2;
+                  this.uint16[o2 + 3] = v3;
+                  this.uint32[o4 + 2] = v4;
+                  this.uint32[o4 + 3] = v5;
+                  this.uint32[o4 + 4] = v6;
+                  this.uint16[o2 + 10] = v7;
+                  this.uint16[o2 + 11] = v8;
+                  this.uint16[o2 + 12] = v9;
+                  this.float32[o4 + 7] = v10;
+                  this.float32[o4 + 8] = v11;
+                  this.uint8[o1 + 36] = v12;
+                  this.uint8[o1 + 37] = v13;
+                  this.uint8[o1 + 38] = v14;
+                  this.uint32[o4 + 10] = v15;
+                  this.int16[o2 + 22] = v16;
+                  return i2;
+                };
+                return StructArrayLayout2i2ui3ul3ui2f3ub1ul1i482;
+              }(StructArray);
+              StructArrayLayout2i2ui3ul3ui2f3ub1ul1i48.prototype.bytesPerElement = 48;
+              register2("StructArrayLayout2i2ui3ul3ui2f3ub1ul1i48", StructArrayLayout2i2ui3ul3ui2f3ub1ul1i48);
+              var StructArrayLayout8i15ui1ul4f68 = function(StructArray2) {
+                function StructArrayLayout8i15ui1ul4f682() {
+                  StructArray2.apply(this, arguments);
+                }
+                if (StructArray2)
+                  StructArrayLayout8i15ui1ul4f682.__proto__ = StructArray2;
+                StructArrayLayout8i15ui1ul4f682.prototype = Object.create(StructArray2 && StructArray2.prototype);
+                StructArrayLayout8i15ui1ul4f682.prototype.constructor = StructArrayLayout8i15ui1ul4f682;
+                StructArrayLayout8i15ui1ul4f682.prototype._refreshViews = function _refreshViews() {
+                  this.uint8 = new Uint8Array(this.arrayBuffer);
+                  this.int16 = new Int16Array(this.arrayBuffer);
+                  this.uint16 = new Uint16Array(this.arrayBuffer);
+                  this.uint32 = new Uint32Array(this.arrayBuffer);
+                  this.float32 = new Float32Array(this.arrayBuffer);
+                };
+                StructArrayLayout8i15ui1ul4f682.prototype.emplaceBack = function emplaceBack(v0, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27) {
+                  var i2 = this.length;
+                  this.resize(i2 + 1);
+                  return this.emplace(i2, v0, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27);
+                };
+                StructArrayLayout8i15ui1ul4f682.prototype.emplace = function emplace(i2, v0, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27) {
+                  var o2 = i2 * 34;
+                  var o4 = i2 * 17;
+                  this.int16[o2 + 0] = v0;
+                  this.int16[o2 + 1] = v1;
+                  this.int16[o2 + 2] = v2;
+                  this.int16[o2 + 3] = v3;
+                  this.int16[o2 + 4] = v4;
+                  this.int16[o2 + 5] = v5;
+                  this.int16[o2 + 6] = v6;
+                  this.int16[o2 + 7] = v7;
+                  this.uint16[o2 + 8] = v8;
+                  this.uint16[o2 + 9] = v9;
+                  this.uint16[o2 + 10] = v10;
+                  this.uint16[o2 + 11] = v11;
+                  this.uint16[o2 + 12] = v12;
+                  this.uint16[o2 + 13] = v13;
+                  this.uint16[o2 + 14] = v14;
+                  this.uint16[o2 + 15] = v15;
+                  this.uint16[o2 + 16] = v16;
+                  this.uint16[o2 + 17] = v17;
+                  this.uint16[o2 + 18] = v18;
+                  this.uint16[o2 + 19] = v19;
+                  this.uint16[o2 + 20] = v20;
+                  this.uint16[o2 + 21] = v21;
+                  this.uint16[o2 + 22] = v22;
+                  this.uint32[o4 + 12] = v23;
+                  this.float32[o4 + 13] = v24;
+                  this.float32[o4 + 14] = v25;
+                  this.float32[o4 + 15] = v26;
+                  this.float32[o4 + 16] = v27;
+                  return i2;
+                };
+                return StructArrayLayout8i15ui1ul4f682;
+              }(StructArray);
+              StructArrayLayout8i15ui1ul4f68.prototype.bytesPerElement = 68;
+              register2("StructArrayLayout8i15ui1ul4f68", StructArrayLayout8i15ui1ul4f68);
+              var StructArrayLayout1f4 = function(StructArray2) {
+                function StructArrayLayout1f42() {
+                  StructArray2.apply(this, arguments);
+                }
+                if (StructArray2)
+                  StructArrayLayout1f42.__proto__ = StructArray2;
+                StructArrayLayout1f42.prototype = Object.create(StructArray2 && StructArray2.prototype);
+                StructArrayLayout1f42.prototype.constructor = StructArrayLayout1f42;
+                StructArrayLayout1f42.prototype._refreshViews = function _refreshViews() {
+                  this.uint8 = new Uint8Array(this.arrayBuffer);
+                  this.float32 = new Float32Array(this.arrayBuffer);
+                };
+                StructArrayLayout1f42.prototype.emplaceBack = function emplaceBack(v0) {
+                  var i2 = this.length;
+                  this.resize(i2 + 1);
+                  return this.emplace(i2, v0);
+                };
+                StructArrayLayout1f42.prototype.emplace = function emplace(i2, v0) {
+                  var o4 = i2 * 1;
+                  this.float32[o4 + 0] = v0;
+                  return i2;
+                };
+                return StructArrayLayout1f42;
+              }(StructArray);
+              StructArrayLayout1f4.prototype.bytesPerElement = 4;
+              register2("StructArrayLayout1f4", StructArrayLayout1f4);
+              var StructArrayLayout3i6 = function(StructArray2) {
+                function StructArrayLayout3i62() {
+                  StructArray2.apply(this, arguments);
+                }
+                if (StructArray2)
+                  StructArrayLayout3i62.__proto__ = StructArray2;
+                StructArrayLayout3i62.prototype = Object.create(StructArray2 && StructArray2.prototype);
+                StructArrayLayout3i62.prototype.constructor = StructArrayLayout3i62;
+                StructArrayLayout3i62.prototype._refreshViews = function _refreshViews() {
+                  this.uint8 = new Uint8Array(this.arrayBuffer);
+                  this.int16 = new Int16Array(this.arrayBuffer);
+                };
+                StructArrayLayout3i62.prototype.emplaceBack = function emplaceBack(v0, v1, v2) {
+                  var i2 = this.length;
+                  this.resize(i2 + 1);
+                  return this.emplace(i2, v0, v1, v2);
+                };
+                StructArrayLayout3i62.prototype.emplace = function emplace(i2, v0, v1, v2) {
+                  var o2 = i2 * 3;
+                  this.int16[o2 + 0] = v0;
+                  this.int16[o2 + 1] = v1;
+                  this.int16[o2 + 2] = v2;
+                  return i2;
+                };
+                return StructArrayLayout3i62;
+              }(StructArray);
+              StructArrayLayout3i6.prototype.bytesPerElement = 6;
+              register2("StructArrayLayout3i6", StructArrayLayout3i6);
+              var StructArrayLayout1ul2ui8 = function(StructArray2) {
+                function StructArrayLayout1ul2ui82() {
+                  StructArray2.apply(this, arguments);
+                }
+                if (StructArray2)
+                  StructArrayLayout1ul2ui82.__proto__ = StructArray2;
+                StructArrayLayout1ul2ui82.prototype = Object.create(StructArray2 && StructArray2.prototype);
+                StructArrayLayout1ul2ui82.prototype.constructor = StructArrayLayout1ul2ui82;
+                StructArrayLayout1ul2ui82.prototype._refreshViews = function _refreshViews() {
+                  this.uint8 = new Uint8Array(this.arrayBuffer);
+                  this.uint32 = new Uint32Array(this.arrayBuffer);
+                  this.uint16 = new Uint16Array(this.arrayBuffer);
+                };
+                StructArrayLayout1ul2ui82.prototype.emplaceBack = function emplaceBack(v0, v1, v2) {
+                  var i2 = this.length;
+                  this.resize(i2 + 1);
+                  return this.emplace(i2, v0, v1, v2);
+                };
+                StructArrayLayout1ul2ui82.prototype.emplace = function emplace(i2, v0, v1, v2) {
+                  var o4 = i2 * 2;
+                  var o2 = i2 * 4;
+                  this.uint32[o4 + 0] = v0;
+                  this.uint16[o2 + 2] = v1;
+                  this.uint16[o2 + 3] = v2;
+                  return i2;
+                };
+                return StructArrayLayout1ul2ui82;
+              }(StructArray);
+              StructArrayLayout1ul2ui8.prototype.bytesPerElement = 8;
+              register2("StructArrayLayout1ul2ui8", StructArrayLayout1ul2ui8);
+              var StructArrayLayout2ui4 = function(StructArray2) {
+                function StructArrayLayout2ui42() {
+                  StructArray2.apply(this, arguments);
+                }
+                if (StructArray2)
+                  StructArrayLayout2ui42.__proto__ = StructArray2;
+                StructArrayLayout2ui42.prototype = Object.create(StructArray2 && StructArray2.prototype);
+                StructArrayLayout2ui42.prototype.constructor = StructArrayLayout2ui42;
+                StructArrayLayout2ui42.prototype._refreshViews = function _refreshViews() {
+                  this.uint8 = new Uint8Array(this.arrayBuffer);
+                  this.uint16 = new Uint16Array(this.arrayBuffer);
+                };
+                StructArrayLayout2ui42.prototype.emplaceBack = function emplaceBack(v0, v1) {
+                  var i2 = this.length;
+                  this.resize(i2 + 1);
+                  return this.emplace(i2, v0, v1);
+                };
+                StructArrayLayout2ui42.prototype.emplace = function emplace(i2, v0, v1) {
+                  var o2 = i2 * 2;
+                  this.uint16[o2 + 0] = v0;
+                  this.uint16[o2 + 1] = v1;
+                  return i2;
+                };
+                return StructArrayLayout2ui42;
+              }(StructArray);
+              StructArrayLayout2ui4.prototype.bytesPerElement = 4;
+              register2("StructArrayLayout2ui4", StructArrayLayout2ui4);
+              var StructArrayLayout1ui2 = function(StructArray2) {
+                function StructArrayLayout1ui22() {
+                  StructArray2.apply(this, arguments);
+                }
+                if (StructArray2)
+                  StructArrayLayout1ui22.__proto__ = StructArray2;
+                StructArrayLayout1ui22.prototype = Object.create(StructArray2 && StructArray2.prototype);
+                StructArrayLayout1ui22.prototype.constructor = StructArrayLayout1ui22;
+                StructArrayLayout1ui22.prototype._refreshViews = function _refreshViews() {
+                  this.uint8 = new Uint8Array(this.arrayBuffer);
+                  this.uint16 = new Uint16Array(this.arrayBuffer);
+                };
+                StructArrayLayout1ui22.prototype.emplaceBack = function emplaceBack(v0) {
+                  var i2 = this.length;
+                  this.resize(i2 + 1);
+                  return this.emplace(i2, v0);
+                };
+                StructArrayLayout1ui22.prototype.emplace = function emplace(i2, v0) {
+                  var o2 = i2 * 1;
+                  this.uint16[o2 + 0] = v0;
+                  return i2;
+                };
+                return StructArrayLayout1ui22;
+              }(StructArray);
+              StructArrayLayout1ui2.prototype.bytesPerElement = 2;
+              register2("StructArrayLayout1ui2", StructArrayLayout1ui2);
+              var StructArrayLayout4f16 = function(StructArray2) {
+                function StructArrayLayout4f162() {
+                  StructArray2.apply(this, arguments);
+                }
+                if (StructArray2)
+                  StructArrayLayout4f162.__proto__ = StructArray2;
+                StructArrayLayout4f162.prototype = Object.create(StructArray2 && StructArray2.prototype);
+                StructArrayLayout4f162.prototype.constructor = StructArrayLayout4f162;
+                StructArrayLayout4f162.prototype._refreshViews = function _refreshViews() {
+                  this.uint8 = new Uint8Array(this.arrayBuffer);
+                  this.float32 = new Float32Array(this.arrayBuffer);
+                };
+                StructArrayLayout4f162.prototype.emplaceBack = function emplaceBack(v0, v1, v2, v3) {
+                  var i2 = this.length;
+                  this.resize(i2 + 1);
+                  return this.emplace(i2, v0, v1, v2, v3);
+                };
+                StructArrayLayout4f162.prototype.emplace = function emplace(i2, v0, v1, v2, v3) {
+                  var o4 = i2 * 4;
+                  this.float32[o4 + 0] = v0;
+                  this.float32[o4 + 1] = v1;
+                  this.float32[o4 + 2] = v2;
+                  this.float32[o4 + 3] = v3;
+                  return i2;
+                };
+                return StructArrayLayout4f162;
+              }(StructArray);
+              StructArrayLayout4f16.prototype.bytesPerElement = 16;
+              register2("StructArrayLayout4f16", StructArrayLayout4f16);
+              var CollisionBoxStruct = function(Struct22) {
+                function CollisionBoxStruct2() {
+                  Struct22.apply(this, arguments);
+                }
+                if (Struct22)
+                  CollisionBoxStruct2.__proto__ = Struct22;
+                CollisionBoxStruct2.prototype = Object.create(Struct22 && Struct22.prototype);
+                CollisionBoxStruct2.prototype.constructor = CollisionBoxStruct2;
+                var prototypeAccessors2 = {
+                  anchorPointX: { configurable: true },
+                  anchorPointY: { configurable: true },
+                  x1: { configurable: true },
+                  y1: { configurable: true },
+                  x2: { configurable: true },
+                  y2: { configurable: true },
+                  featureIndex: { configurable: true },
+                  sourceLayerIndex: { configurable: true },
+                  bucketIndex: { configurable: true },
+                  anchorPoint: { configurable: true }
+                };
+                prototypeAccessors2.anchorPointX.get = function() {
+                  return this._structArray.int16[this._pos2 + 0];
+                };
+                prototypeAccessors2.anchorPointY.get = function() {
+                  return this._structArray.int16[this._pos2 + 1];
+                };
+                prototypeAccessors2.x1.get = function() {
+                  return this._structArray.int16[this._pos2 + 2];
+                };
+                prototypeAccessors2.y1.get = function() {
+                  return this._structArray.int16[this._pos2 + 3];
+                };
+                prototypeAccessors2.x2.get = function() {
+                  return this._structArray.int16[this._pos2 + 4];
+                };
+                prototypeAccessors2.y2.get = function() {
+                  return this._structArray.int16[this._pos2 + 5];
+                };
+                prototypeAccessors2.featureIndex.get = function() {
+                  return this._structArray.uint32[this._pos4 + 3];
+                };
+                prototypeAccessors2.sourceLayerIndex.get = function() {
+                  return this._structArray.uint16[this._pos2 + 8];
+                };
+                prototypeAccessors2.bucketIndex.get = function() {
+                  return this._structArray.uint16[this._pos2 + 9];
+                };
+                prototypeAccessors2.anchorPoint.get = function() {
+                  return new pointGeometry(this.anchorPointX, this.anchorPointY);
+                };
+                Object.defineProperties(CollisionBoxStruct2.prototype, prototypeAccessors2);
+                return CollisionBoxStruct2;
+              }(Struct2);
+              CollisionBoxStruct.prototype.size = 20;
+              var CollisionBoxArray = function(StructArrayLayout6i1ul2ui202) {
+                function CollisionBoxArray2() {
+                  StructArrayLayout6i1ul2ui202.apply(this, arguments);
+                }
+                if (StructArrayLayout6i1ul2ui202)
+                  CollisionBoxArray2.__proto__ = StructArrayLayout6i1ul2ui202;
+                CollisionBoxArray2.prototype = Object.create(StructArrayLayout6i1ul2ui202 && StructArrayLayout6i1ul2ui202.prototype);
+                CollisionBoxArray2.prototype.constructor = CollisionBoxArray2;
+                CollisionBoxArray2.prototype.get = function get2(index) {
+                  return new CollisionBoxStruct(this, index);
+                };
+                return CollisionBoxArray2;
+              }(StructArrayLayout6i1ul2ui20);
+              register2("CollisionBoxArray", CollisionBoxArray);
+              var PlacedSymbolStruct = function(Struct22) {
+                function PlacedSymbolStruct2() {
+                  Struct22.apply(this, arguments);
+                }
+                if (Struct22)
+                  PlacedSymbolStruct2.__proto__ = Struct22;
+                PlacedSymbolStruct2.prototype = Object.create(Struct22 && Struct22.prototype);
+                PlacedSymbolStruct2.prototype.constructor = PlacedSymbolStruct2;
+                var prototypeAccessors$12 = {
+                  anchorX: { configurable: true },
+                  anchorY: { configurable: true },
+                  glyphStartIndex: { configurable: true },
+                  numGlyphs: { configurable: true },
+                  vertexStartIndex: { configurable: true },
+                  lineStartIndex: { configurable: true },
+                  lineLength: { configurable: true },
+                  segment: { configurable: true },
+                  lowerSize: { configurable: true },
+                  upperSize: { configurable: true },
+                  lineOffsetX: { configurable: true },
+                  lineOffsetY: { configurable: true },
+                  writingMode: { configurable: true },
+                  placedOrientation: { configurable: true },
+                  hidden: { configurable: true },
+                  crossTileID: { configurable: true },
+                  associatedIconIndex: { configurable: true }
+                };
+                prototypeAccessors$12.anchorX.get = function() {
+                  return this._structArray.int16[this._pos2 + 0];
+                };
+                prototypeAccessors$12.anchorY.get = function() {
+                  return this._structArray.int16[this._pos2 + 1];
+                };
+                prototypeAccessors$12.glyphStartIndex.get = function() {
+                  return this._structArray.uint16[this._pos2 + 2];
+                };
+                prototypeAccessors$12.numGlyphs.get = function() {
+                  return this._structArray.uint16[this._pos2 + 3];
+                };
+                prototypeAccessors$12.vertexStartIndex.get = function() {
+                  return this._structArray.uint32[this._pos4 + 2];
+                };
+                prototypeAccessors$12.lineStartIndex.get = function() {
+                  return this._structArray.uint32[this._pos4 + 3];
+                };
+                prototypeAccessors$12.lineLength.get = function() {
+                  return this._structArray.uint32[this._pos4 + 4];
+                };
+                prototypeAccessors$12.segment.get = function() {
+                  return this._structArray.uint16[this._pos2 + 10];
+                };
+                prototypeAccessors$12.lowerSize.get = function() {
+                  return this._structArray.uint16[this._pos2 + 11];
+                };
+                prototypeAccessors$12.upperSize.get = function() {
+                  return this._structArray.uint16[this._pos2 + 12];
+                };
+                prototypeAccessors$12.lineOffsetX.get = function() {
+                  return this._structArray.float32[this._pos4 + 7];
+                };
+                prototypeAccessors$12.lineOffsetY.get = function() {
+                  return this._structArray.float32[this._pos4 + 8];
+                };
+                prototypeAccessors$12.writingMode.get = function() {
+                  return this._structArray.uint8[this._pos1 + 36];
+                };
+                prototypeAccessors$12.placedOrientation.get = function() {
+                  return this._structArray.uint8[this._pos1 + 37];
+                };
+                prototypeAccessors$12.placedOrientation.set = function(x2) {
+                  this._structArray.uint8[this._pos1 + 37] = x2;
+                };
+                prototypeAccessors$12.hidden.get = function() {
+                  return this._structArray.uint8[this._pos1 + 38];
+                };
+                prototypeAccessors$12.hidden.set = function(x2) {
+                  this._structArray.uint8[this._pos1 + 38] = x2;
+                };
+                prototypeAccessors$12.crossTileID.get = function() {
+                  return this._structArray.uint32[this._pos4 + 10];
+                };
+                prototypeAccessors$12.crossTileID.set = function(x2) {
+                  this._structArray.uint32[this._pos4 + 10] = x2;
+                };
+                prototypeAccessors$12.associatedIconIndex.get = function() {
+                  return this._structArray.int16[this._pos2 + 22];
+                };
+                Object.defineProperties(PlacedSymbolStruct2.prototype, prototypeAccessors$12);
+                return PlacedSymbolStruct2;
+              }(Struct2);
+              PlacedSymbolStruct.prototype.size = 48;
+              var PlacedSymbolArray = function(StructArrayLayout2i2ui3ul3ui2f3ub1ul1i482) {
+                function PlacedSymbolArray2() {
+                  StructArrayLayout2i2ui3ul3ui2f3ub1ul1i482.apply(this, arguments);
+                }
+                if (StructArrayLayout2i2ui3ul3ui2f3ub1ul1i482)
+                  PlacedSymbolArray2.__proto__ = StructArrayLayout2i2ui3ul3ui2f3ub1ul1i482;
+                PlacedSymbolArray2.prototype = Object.create(StructArrayLayout2i2ui3ul3ui2f3ub1ul1i482 && StructArrayLayout2i2ui3ul3ui2f3ub1ul1i482.prototype);
+                PlacedSymbolArray2.prototype.constructor = PlacedSymbolArray2;
+                PlacedSymbolArray2.prototype.get = function get2(index) {
+                  return new PlacedSymbolStruct(this, index);
+                };
+                return PlacedSymbolArray2;
+              }(StructArrayLayout2i2ui3ul3ui2f3ub1ul1i48);
+              register2("PlacedSymbolArray", PlacedSymbolArray);
+              var SymbolInstanceStruct = function(Struct22) {
+                function SymbolInstanceStruct2() {
+                  Struct22.apply(this, arguments);
+                }
+                if (Struct22)
+                  SymbolInstanceStruct2.__proto__ = Struct22;
+                SymbolInstanceStruct2.prototype = Object.create(Struct22 && Struct22.prototype);
+                SymbolInstanceStruct2.prototype.constructor = SymbolInstanceStruct2;
+                var prototypeAccessors$2 = {
+                  anchorX: { configurable: true },
+                  anchorY: { configurable: true },
+                  rightJustifiedTextSymbolIndex: { configurable: true },
+                  centerJustifiedTextSymbolIndex: { configurable: true },
+                  leftJustifiedTextSymbolIndex: { configurable: true },
+                  verticalPlacedTextSymbolIndex: { configurable: true },
+                  placedIconSymbolIndex: { configurable: true },
+                  verticalPlacedIconSymbolIndex: { configurable: true },
+                  key: { configurable: true },
+                  textBoxStartIndex: { configurable: true },
+                  textBoxEndIndex: { configurable: true },
+                  verticalTextBoxStartIndex: { configurable: true },
+                  verticalTextBoxEndIndex: { configurable: true },
+                  iconBoxStartIndex: { configurable: true },
+                  iconBoxEndIndex: { configurable: true },
+                  verticalIconBoxStartIndex: { configurable: true },
+                  verticalIconBoxEndIndex: { configurable: true },
+                  featureIndex: { configurable: true },
+                  numHorizontalGlyphVertices: { configurable: true },
+                  numVerticalGlyphVertices: { configurable: true },
+                  numIconVertices: { configurable: true },
+                  numVerticalIconVertices: { configurable: true },
+                  useRuntimeCollisionCircles: { configurable: true },
+                  crossTileID: { configurable: true },
+                  textBoxScale: { configurable: true },
+                  textOffset0: { configurable: true },
+                  textOffset1: { configurable: true },
+                  collisionCircleDiameter: { configurable: true }
+                };
+                prototypeAccessors$2.anchorX.get = function() {
+                  return this._structArray.int16[this._pos2 + 0];
+                };
+                prototypeAccessors$2.anchorY.get = function() {
+                  return this._structArray.int16[this._pos2 + 1];
+                };
+                prototypeAccessors$2.rightJustifiedTextSymbolIndex.get = function() {
+                  return this._structArray.int16[this._pos2 + 2];
+                };
+                prototypeAccessors$2.centerJustifiedTextSymbolIndex.get = function() {
+                  return this._structArray.int16[this._pos2 + 3];
+                };
+                prototypeAccessors$2.leftJustifiedTextSymbolIndex.get = function() {
+                  return this._structArray.int16[this._pos2 + 4];
+                };
+                prototypeAccessors$2.verticalPlacedTextSymbolIndex.get = function() {
+                  return this._structArray.int16[this._pos2 + 5];
+                };
+                prototypeAccessors$2.placedIconSymbolIndex.get = function() {
+                  return this._structArray.int16[this._pos2 + 6];
+                };
+                prototypeAccessors$2.verticalPlacedIconSymbolIndex.get = function() {
+                  return this._structArray.int16[this._pos2 + 7];
+                };
+                prototypeAccessors$2.key.get = function() {
+                  return this._structArray.uint16[this._pos2 + 8];
+                };
+                prototypeAccessors$2.textBoxStartIndex.get = function() {
+                  return this._structArray.uint16[this._pos2 + 9];
+                };
+                prototypeAccessors$2.textBoxEndIndex.get = function() {
+                  return this._structArray.uint16[this._pos2 + 10];
+                };
+                prototypeAccessors$2.verticalTextBoxStartIndex.get = function() {
+                  return this._structArray.uint16[this._pos2 + 11];
+                };
+                prototypeAccessors$2.verticalTextBoxEndIndex.get = function() {
+                  return this._structArray.uint16[this._pos2 + 12];
+                };
+                prototypeAccessors$2.iconBoxStartIndex.get = function() {
+                  return this._structArray.uint16[this._pos2 + 13];
+                };
+                prototypeAccessors$2.iconBoxEndIndex.get = function() {
+                  return this._structArray.uint16[this._pos2 + 14];
+                };
+                prototypeAccessors$2.verticalIconBoxStartIndex.get = function() {
+                  return this._structArray.uint16[this._pos2 + 15];
+                };
+                prototypeAccessors$2.verticalIconBoxEndIndex.get = function() {
+                  return this._structArray.uint16[this._pos2 + 16];
+                };
+                prototypeAccessors$2.featureIndex.get = function() {
+                  return this._structArray.uint16[this._pos2 + 17];
+                };
+                prototypeAccessors$2.numHorizontalGlyphVertices.get = function() {
+                  return this._structArray.uint16[this._pos2 + 18];
+                };
+                prototypeAccessors$2.numVerticalGlyphVertices.get = function() {
+                  return this._structArray.uint16[this._pos2 + 19];
+                };
+                prototypeAccessors$2.numIconVertices.get = function() {
+                  return this._structArray.uint16[this._pos2 + 20];
+                };
+                prototypeAccessors$2.numVerticalIconVertices.get = function() {
+                  return this._structArray.uint16[this._pos2 + 21];
+                };
+                prototypeAccessors$2.useRuntimeCollisionCircles.get = function() {
+                  return this._structArray.uint16[this._pos2 + 22];
+                };
+                prototypeAccessors$2.crossTileID.get = function() {
+                  return this._structArray.uint32[this._pos4 + 12];
+                };
+                prototypeAccessors$2.crossTileID.set = function(x2) {
+                  this._structArray.uint32[this._pos4 + 12] = x2;
+                };
+                prototypeAccessors$2.textBoxScale.get = function() {
+                  return this._structArray.float32[this._pos4 + 13];
+                };
+                prototypeAccessors$2.textOffset0.get = function() {
+                  return this._structArray.float32[this._pos4 + 14];
+                };
+                prototypeAccessors$2.textOffset1.get = function() {
+                  return this._structArray.float32[this._pos4 + 15];
+                };
+                prototypeAccessors$2.collisionCircleDiameter.get = function() {
+                  return this._structArray.float32[this._pos4 + 16];
+                };
+                Object.defineProperties(SymbolInstanceStruct2.prototype, prototypeAccessors$2);
+                return SymbolInstanceStruct2;
+              }(Struct2);
+              SymbolInstanceStruct.prototype.size = 68;
+              var SymbolInstanceArray = function(StructArrayLayout8i15ui1ul4f682) {
+                function SymbolInstanceArray2() {
+                  StructArrayLayout8i15ui1ul4f682.apply(this, arguments);
+                }
+                if (StructArrayLayout8i15ui1ul4f682)
+                  SymbolInstanceArray2.__proto__ = StructArrayLayout8i15ui1ul4f682;
+                SymbolInstanceArray2.prototype = Object.create(StructArrayLayout8i15ui1ul4f682 && StructArrayLayout8i15ui1ul4f682.prototype);
+                SymbolInstanceArray2.prototype.constructor = SymbolInstanceArray2;
+                SymbolInstanceArray2.prototype.get = function get2(index) {
+                  return new SymbolInstanceStruct(this, index);
+                };
+                return SymbolInstanceArray2;
+              }(StructArrayLayout8i15ui1ul4f68);
+              register2("SymbolInstanceArray", SymbolInstanceArray);
+              var GlyphOffsetArray = function(StructArrayLayout1f42) {
+                function GlyphOffsetArray2() {
+                  StructArrayLayout1f42.apply(this, arguments);
+                }
+                if (StructArrayLayout1f42)
+                  GlyphOffsetArray2.__proto__ = StructArrayLayout1f42;
+                GlyphOffsetArray2.prototype = Object.create(StructArrayLayout1f42 && StructArrayLayout1f42.prototype);
+                GlyphOffsetArray2.prototype.constructor = GlyphOffsetArray2;
+                GlyphOffsetArray2.prototype.getoffsetX = function getoffsetX(index) {
+                  return this.float32[index * 1 + 0];
+                };
+                return GlyphOffsetArray2;
+              }(StructArrayLayout1f4);
+              register2("GlyphOffsetArray", GlyphOffsetArray);
+              var SymbolLineVertexArray = function(StructArrayLayout3i62) {
+                function SymbolLineVertexArray2() {
+                  StructArrayLayout3i62.apply(this, arguments);
+                }
+                if (StructArrayLayout3i62)
+                  SymbolLineVertexArray2.__proto__ = StructArrayLayout3i62;
+                SymbolLineVertexArray2.prototype = Object.create(StructArrayLayout3i62 && StructArrayLayout3i62.prototype);
+                SymbolLineVertexArray2.prototype.constructor = SymbolLineVertexArray2;
+                SymbolLineVertexArray2.prototype.getx = function getx(index) {
+                  return this.int16[index * 3 + 0];
+                };
+                SymbolLineVertexArray2.prototype.gety = function gety(index) {
+                  return this.int16[index * 3 + 1];
+                };
+                SymbolLineVertexArray2.prototype.gettileUnitDistanceFromAnchor = function gettileUnitDistanceFromAnchor(index) {
+                  return this.int16[index * 3 + 2];
+                };
+                return SymbolLineVertexArray2;
+              }(StructArrayLayout3i6);
+              register2("SymbolLineVertexArray", SymbolLineVertexArray);
+              var FeatureIndexStruct = function(Struct22) {
+                function FeatureIndexStruct2() {
+                  Struct22.apply(this, arguments);
+                }
+                if (Struct22)
+                  FeatureIndexStruct2.__proto__ = Struct22;
+                FeatureIndexStruct2.prototype = Object.create(Struct22 && Struct22.prototype);
+                FeatureIndexStruct2.prototype.constructor = FeatureIndexStruct2;
+                var prototypeAccessors$3 = {
+                  featureIndex: { configurable: true },
+                  sourceLayerIndex: { configurable: true },
+                  bucketIndex: { configurable: true }
+                };
+                prototypeAccessors$3.featureIndex.get = function() {
+                  return this._structArray.uint32[this._pos4 + 0];
+                };
+                prototypeAccessors$3.sourceLayerIndex.get = function() {
+                  return this._structArray.uint16[this._pos2 + 2];
+                };
+                prototypeAccessors$3.bucketIndex.get = function() {
+                  return this._structArray.uint16[this._pos2 + 3];
+                };
+                Object.defineProperties(FeatureIndexStruct2.prototype, prototypeAccessors$3);
+                return FeatureIndexStruct2;
+              }(Struct2);
+              FeatureIndexStruct.prototype.size = 8;
+              var FeatureIndexArray = function(StructArrayLayout1ul2ui82) {
+                function FeatureIndexArray2() {
+                  StructArrayLayout1ul2ui82.apply(this, arguments);
+                }
+                if (StructArrayLayout1ul2ui82)
+                  FeatureIndexArray2.__proto__ = StructArrayLayout1ul2ui82;
+                FeatureIndexArray2.prototype = Object.create(StructArrayLayout1ul2ui82 && StructArrayLayout1ul2ui82.prototype);
+                FeatureIndexArray2.prototype.constructor = FeatureIndexArray2;
+                FeatureIndexArray2.prototype.get = function get2(index) {
+                  return new FeatureIndexStruct(this, index);
+                };
+                return FeatureIndexArray2;
+              }(StructArrayLayout1ul2ui8);
+              register2("FeatureIndexArray", FeatureIndexArray);
+              var layout$1 = createLayout([{
+                name: "a_pos",
+                components: 2,
+                type: "Int16"
+              }], 4);
+              var members = layout$1.members;
+              var SegmentVector = function SegmentVector2(segments) {
+                if (segments === void 0)
+                  segments = [];
+                this.segments = segments;
+              };
+              SegmentVector.prototype.prepareSegment = function prepareSegment(numVertices, layoutVertexArray, indexArray, sortKey) {
+                var segment = this.segments[this.segments.length - 1];
+                if (numVertices > SegmentVector.MAX_VERTEX_ARRAY_LENGTH) {
+                  warnOnce("Max vertices per segment is " + SegmentVector.MAX_VERTEX_ARRAY_LENGTH + ": bucket requested " + numVertices);
+                }
+                if (!segment || segment.vertexLength + numVertices > SegmentVector.MAX_VERTEX_ARRAY_LENGTH || segment.sortKey !== sortKey) {
+                  segment = {
+                    vertexOffset: layoutVertexArray.length,
+                    primitiveOffset: indexArray.length,
+                    vertexLength: 0,
+                    primitiveLength: 0
+                  };
+                  if (sortKey !== void 0) {
+                    segment.sortKey = sortKey;
+                  }
+                  this.segments.push(segment);
+                }
+                return segment;
+              };
+              SegmentVector.prototype.get = function get2() {
+                return this.segments;
+              };
+              SegmentVector.prototype.destroy = function destroy() {
+                for (var i2 = 0, list = this.segments; i2 < list.length; i2 += 1) {
+                  var segment = list[i2];
+                  for (var k2 in segment.vaos) {
+                    segment.vaos[k2].destroy();
+                  }
+                }
+              };
+              SegmentVector.simpleSegment = function simpleSegment(vertexOffset, primitiveOffset, vertexLength, primitiveLength) {
+                return new SegmentVector([{
+                  vertexOffset,
+                  primitiveOffset,
+                  vertexLength,
+                  primitiveLength,
+                  vaos: {},
+                  sortKey: 0
+                }]);
+              };
+              SegmentVector.MAX_VERTEX_ARRAY_LENGTH = Math.pow(2, 16) - 1;
+              register2("SegmentVector", SegmentVector);
+              function packUint8ToFloat(a2, b2) {
+                a2 = clamp2(Math.floor(a2), 0, 255);
+                b2 = clamp2(Math.floor(b2), 0, 255);
+                return 256 * a2 + b2;
+              }
+              var patternAttributes = createLayout([
+                {
+                  name: "a_pattern_from",
+                  components: 4,
+                  type: "Uint16"
+                },
+                {
+                  name: "a_pattern_to",
+                  components: 4,
+                  type: "Uint16"
+                },
+                {
+                  name: "a_pixel_ratio_from",
+                  components: 1,
+                  type: "Uint16"
+                },
+                {
+                  name: "a_pixel_ratio_to",
+                  components: 1,
+                  type: "Uint16"
+                }
+              ]);
+              var murmurhash3_gc = createCommonjsModule(function(module22) {
+                function murmurhash3_32_gc(key, seed) {
+                  var remainder, bytes, h1, h1b, c1, c2, k1, i2;
+                  remainder = key.length & 3;
+                  bytes = key.length - remainder;
+                  h1 = seed;
+                  c1 = 3432918353;
+                  c2 = 461845907;
+                  i2 = 0;
+                  while (i2 < bytes) {
+                    k1 = key.charCodeAt(i2) & 255 | (key.charCodeAt(++i2) & 255) << 8 | (key.charCodeAt(++i2) & 255) << 16 | (key.charCodeAt(++i2) & 255) << 24;
+                    ++i2;
+                    k1 = (k1 & 65535) * c1 + (((k1 >>> 16) * c1 & 65535) << 16) & 4294967295;
+                    k1 = k1 << 15 | k1 >>> 17;
+                    k1 = (k1 & 65535) * c2 + (((k1 >>> 16) * c2 & 65535) << 16) & 4294967295;
+                    h1 ^= k1;
+                    h1 = h1 << 13 | h1 >>> 19;
+                    h1b = (h1 & 65535) * 5 + (((h1 >>> 16) * 5 & 65535) << 16) & 4294967295;
+                    h1 = (h1b & 65535) + 27492 + (((h1b >>> 16) + 58964 & 65535) << 16);
+                  }
+                  k1 = 0;
+                  switch (remainder) {
+                    case 3:
+                      k1 ^= (key.charCodeAt(i2 + 2) & 255) << 16;
+                    case 2:
+                      k1 ^= (key.charCodeAt(i2 + 1) & 255) << 8;
+                    case 1:
+                      k1 ^= key.charCodeAt(i2) & 255;
+                      k1 = (k1 & 65535) * c1 + (((k1 >>> 16) * c1 & 65535) << 16) & 4294967295;
+                      k1 = k1 << 15 | k1 >>> 17;
+                      k1 = (k1 & 65535) * c2 + (((k1 >>> 16) * c2 & 65535) << 16) & 4294967295;
+                      h1 ^= k1;
+                  }
+                  h1 ^= key.length;
+                  h1 ^= h1 >>> 16;
+                  h1 = (h1 & 65535) * 2246822507 + (((h1 >>> 16) * 2246822507 & 65535) << 16) & 4294967295;
+                  h1 ^= h1 >>> 13;
+                  h1 = (h1 & 65535) * 3266489909 + (((h1 >>> 16) * 3266489909 & 65535) << 16) & 4294967295;
+                  h1 ^= h1 >>> 16;
+                  return h1 >>> 0;
+                }
+                {
+                  module22.exports = murmurhash3_32_gc;
+                }
+              });
+              var murmurhash2_gc = createCommonjsModule(function(module22) {
+                function murmurhash2_32_gc(str, seed) {
+                  var l2 = str.length, h2 = seed ^ l2, i2 = 0, k2;
+                  while (l2 >= 4) {
+                    k2 = str.charCodeAt(i2) & 255 | (str.charCodeAt(++i2) & 255) << 8 | (str.charCodeAt(++i2) & 255) << 16 | (str.charCodeAt(++i2) & 255) << 24;
+                    k2 = (k2 & 65535) * 1540483477 + (((k2 >>> 16) * 1540483477 & 65535) << 16);
+                    k2 ^= k2 >>> 24;
+                    k2 = (k2 & 65535) * 1540483477 + (((k2 >>> 16) * 1540483477 & 65535) << 16);
+                    h2 = (h2 & 65535) * 1540483477 + (((h2 >>> 16) * 1540483477 & 65535) << 16) ^ k2;
+                    l2 -= 4;
+                    ++i2;
+                  }
+                  switch (l2) {
+                    case 3:
+                      h2 ^= (str.charCodeAt(i2 + 2) & 255) << 16;
+                    case 2:
+                      h2 ^= (str.charCodeAt(i2 + 1) & 255) << 8;
+                    case 1:
+                      h2 ^= str.charCodeAt(i2) & 255;
+                      h2 = (h2 & 65535) * 1540483477 + (((h2 >>> 16) * 1540483477 & 65535) << 16);
+                  }
+                  h2 ^= h2 >>> 13;
+                  h2 = (h2 & 65535) * 1540483477 + (((h2 >>> 16) * 1540483477 & 65535) << 16);
+                  h2 ^= h2 >>> 15;
+                  return h2 >>> 0;
+                }
+                {
+                  module22.exports = murmurhash2_32_gc;
+                }
+              });
+              var murmurhashJs = murmurhash3_gc;
+              var murmur3_1 = murmurhash3_gc;
+              var murmur2_1 = murmurhash2_gc;
+              murmurhashJs.murmur3 = murmur3_1;
+              murmurhashJs.murmur2 = murmur2_1;
+              var FeaturePositionMap = function FeaturePositionMap2() {
+                this.ids = [];
+                this.positions = [];
+                this.indexed = false;
+              };
+              FeaturePositionMap.prototype.add = function add22(id22, index, start, end) {
+                this.ids.push(getNumericId(id22));
+                this.positions.push(index, start, end);
+              };
+              FeaturePositionMap.prototype.getPositions = function getPositions(id22) {
+                var intId = getNumericId(id22);
+                var i2 = 0;
+                var j2 = this.ids.length - 1;
+                while (i2 < j2) {
+                  var m2 = i2 + j2 >> 1;
+                  if (this.ids[m2] >= intId) {
+                    j2 = m2;
+                  } else {
+                    i2 = m2 + 1;
+                  }
+                }
+                var positions = [];
+                while (this.ids[i2] === intId) {
+                  var index = this.positions[3 * i2];
+                  var start = this.positions[3 * i2 + 1];
+                  var end = this.positions[3 * i2 + 2];
+                  positions.push({
+                    index,
+                    start,
+                    end
+                  });
+                  i2++;
+                }
+                return positions;
+              };
+              FeaturePositionMap.serialize = function serialize2(map2, transferables) {
+                var ids = new Float64Array(map2.ids);
+                var positions = new Uint32Array(map2.positions);
+                sort(ids, positions, 0, ids.length - 1);
+                if (transferables) {
+                  transferables.push(ids.buffer, positions.buffer);
+                }
+                return {
+                  ids,
+                  positions
+                };
+              };
+              FeaturePositionMap.deserialize = function deserialize2(obj) {
+                var map2 = new FeaturePositionMap();
+                map2.ids = obj.ids;
+                map2.positions = obj.positions;
+                map2.indexed = true;
+                return map2;
+              };
+              var MAX_SAFE_INTEGER$1 = Math.pow(2, 53) - 1;
+              function getNumericId(value) {
+                var numValue = +value;
+                if (!isNaN(numValue) && numValue <= MAX_SAFE_INTEGER$1) {
+                  return numValue;
+                }
+                return murmurhashJs(String(value));
+              }
+              function sort(ids, positions, left, right) {
+                while (left < right) {
+                  var pivot = ids[left + right >> 1];
+                  var i2 = left - 1;
+                  var j2 = right + 1;
+                  while (true) {
+                    do {
+                      i2++;
+                    } while (ids[i2] < pivot);
+                    do {
+                      j2--;
+                    } while (ids[j2] > pivot);
+                    if (i2 >= j2) {
+                      break;
+                    }
+                    swap(ids, i2, j2);
+                    swap(positions, 3 * i2, 3 * j2);
+                    swap(positions, 3 * i2 + 1, 3 * j2 + 1);
+                    swap(positions, 3 * i2 + 2, 3 * j2 + 2);
+                  }
+                  if (j2 - left < right - j2) {
+                    sort(ids, positions, left, j2);
+                    left = j2 + 1;
+                  } else {
+                    sort(ids, positions, j2 + 1, right);
+                    right = j2;
+                  }
+                }
+              }
+              function swap(arr, i2, j2) {
+                var tmp2 = arr[i2];
+                arr[i2] = arr[j2];
+                arr[j2] = tmp2;
+              }
+              register2("FeaturePositionMap", FeaturePositionMap);
+              var Uniform = function Uniform2(context, location2) {
+                this.gl = context.gl;
+                this.location = location2;
+              };
+              var Uniform1i = function(Uniform2) {
+                function Uniform1i2(context, location2) {
+                  Uniform2.call(this, context, location2);
+                  this.current = 0;
+                }
+                if (Uniform2)
+                  Uniform1i2.__proto__ = Uniform2;
+                Uniform1i2.prototype = Object.create(Uniform2 && Uniform2.prototype);
+                Uniform1i2.prototype.constructor = Uniform1i2;
+                Uniform1i2.prototype.set = function set(v2) {
+                  if (this.current !== v2) {
+                    this.current = v2;
+                    this.gl.uniform1i(this.location, v2);
+                  }
+                };
+                return Uniform1i2;
+              }(Uniform);
+              var Uniform1f = function(Uniform2) {
+                function Uniform1f2(context, location2) {
+                  Uniform2.call(this, context, location2);
+                  this.current = 0;
+                }
+                if (Uniform2)
+                  Uniform1f2.__proto__ = Uniform2;
+                Uniform1f2.prototype = Object.create(Uniform2 && Uniform2.prototype);
+                Uniform1f2.prototype.constructor = Uniform1f2;
+                Uniform1f2.prototype.set = function set(v2) {
+                  if (this.current !== v2) {
+                    this.current = v2;
+                    this.gl.uniform1f(this.location, v2);
+                  }
+                };
+                return Uniform1f2;
+              }(Uniform);
+              var Uniform2f = function(Uniform2) {
+                function Uniform2f2(context, location2) {
+                  Uniform2.call(this, context, location2);
+                  this.current = [
+                    0,
+                    0
+                  ];
+                }
+                if (Uniform2)
+                  Uniform2f2.__proto__ = Uniform2;
+                Uniform2f2.prototype = Object.create(Uniform2 && Uniform2.prototype);
+                Uniform2f2.prototype.constructor = Uniform2f2;
+                Uniform2f2.prototype.set = function set(v2) {
+                  if (v2[0] !== this.current[0] || v2[1] !== this.current[1]) {
+                    this.current = v2;
+                    this.gl.uniform2f(this.location, v2[0], v2[1]);
+                  }
+                };
+                return Uniform2f2;
+              }(Uniform);
+              var Uniform3f = function(Uniform2) {
+                function Uniform3f2(context, location2) {
+                  Uniform2.call(this, context, location2);
+                  this.current = [
+                    0,
+                    0,
+                    0
+                  ];
+                }
+                if (Uniform2)
+                  Uniform3f2.__proto__ = Uniform2;
+                Uniform3f2.prototype = Object.create(Uniform2 && Uniform2.prototype);
+                Uniform3f2.prototype.constructor = Uniform3f2;
+                Uniform3f2.prototype.set = function set(v2) {
+                  if (v2[0] !== this.current[0] || v2[1] !== this.current[1] || v2[2] !== this.current[2]) {
+                    this.current = v2;
+                    this.gl.uniform3f(this.location, v2[0], v2[1], v2[2]);
+                  }
+                };
+                return Uniform3f2;
+              }(Uniform);
+              var Uniform4f = function(Uniform2) {
+                function Uniform4f2(context, location2) {
+                  Uniform2.call(this, context, location2);
+                  this.current = [
+                    0,
+                    0,
+                    0,
+                    0
+                  ];
+                }
+                if (Uniform2)
+                  Uniform4f2.__proto__ = Uniform2;
+                Uniform4f2.prototype = Object.create(Uniform2 && Uniform2.prototype);
+                Uniform4f2.prototype.constructor = Uniform4f2;
+                Uniform4f2.prototype.set = function set(v2) {
+                  if (v2[0] !== this.current[0] || v2[1] !== this.current[1] || v2[2] !== this.current[2] || v2[3] !== this.current[3]) {
+                    this.current = v2;
+                    this.gl.uniform4f(this.location, v2[0], v2[1], v2[2], v2[3]);
+                  }
+                };
+                return Uniform4f2;
+              }(Uniform);
+              var UniformColor = function(Uniform2) {
+                function UniformColor2(context, location2) {
+                  Uniform2.call(this, context, location2);
+                  this.current = Color2.transparent;
+                }
+                if (Uniform2)
+                  UniformColor2.__proto__ = Uniform2;
+                UniformColor2.prototype = Object.create(Uniform2 && Uniform2.prototype);
+                UniformColor2.prototype.constructor = UniformColor2;
+                UniformColor2.prototype.set = function set(v2) {
+                  if (v2.r !== this.current.r || v2.g !== this.current.g || v2.b !== this.current.b || v2.a !== this.current.a) {
+                    this.current = v2;
+                    this.gl.uniform4f(this.location, v2.r, v2.g, v2.b, v2.a);
+                  }
+                };
+                return UniformColor2;
+              }(Uniform);
+              var emptyMat4 = new Float32Array(16);
+              var UniformMatrix4f = function(Uniform2) {
+                function UniformMatrix4f2(context, location2) {
+                  Uniform2.call(this, context, location2);
+                  this.current = emptyMat4;
+                }
+                if (Uniform2)
+                  UniformMatrix4f2.__proto__ = Uniform2;
+                UniformMatrix4f2.prototype = Object.create(Uniform2 && Uniform2.prototype);
+                UniformMatrix4f2.prototype.constructor = UniformMatrix4f2;
+                UniformMatrix4f2.prototype.set = function set(v2) {
+                  if (v2[12] !== this.current[12] || v2[0] !== this.current[0]) {
+                    this.current = v2;
+                    this.gl.uniformMatrix4fv(this.location, false, v2);
+                    return;
+                  }
+                  for (var i2 = 1; i2 < 16; i2++) {
+                    if (v2[i2] !== this.current[i2]) {
+                      this.current = v2;
+                      this.gl.uniformMatrix4fv(this.location, false, v2);
+                      break;
+                    }
+                  }
+                };
+                return UniformMatrix4f2;
+              }(Uniform);
+              function packColor(color3) {
+                return [
+                  packUint8ToFloat(255 * color3.r, 255 * color3.g),
+                  packUint8ToFloat(255 * color3.b, 255 * color3.a)
+                ];
+              }
+              var ConstantBinder = function ConstantBinder2(value, names2, type) {
+                this.value = value;
+                this.uniformNames = names2.map(function(name3) {
+                  return "u_" + name3;
+                });
+                this.type = type;
+              };
+              ConstantBinder.prototype.setUniform = function setUniform2(uniform, globals, currentValue) {
+                uniform.set(currentValue.constantOr(this.value));
+              };
+              ConstantBinder.prototype.getBinding = function getBinding(context, location2, _2) {
+                return this.type === "color" ? new UniformColor(context, location2) : new Uniform1f(context, location2);
+              };
+              var CrossFadedConstantBinder = function CrossFadedConstantBinder2(value, names2) {
+                this.uniformNames = names2.map(function(name3) {
+                  return "u_" + name3;
+                });
+                this.patternFrom = null;
+                this.patternTo = null;
+                this.pixelRatioFrom = 1;
+                this.pixelRatioTo = 1;
+              };
+              CrossFadedConstantBinder.prototype.setConstantPatternPositions = function setConstantPatternPositions(posTo, posFrom) {
+                this.pixelRatioFrom = posFrom.pixelRatio;
+                this.pixelRatioTo = posTo.pixelRatio;
+                this.patternFrom = posFrom.tlbr;
+                this.patternTo = posTo.tlbr;
+              };
+              CrossFadedConstantBinder.prototype.setUniform = function setUniform2(uniform, globals, currentValue, uniformName) {
+                var pos = uniformName === "u_pattern_to" ? this.patternTo : uniformName === "u_pattern_from" ? this.patternFrom : uniformName === "u_pixel_ratio_to" ? this.pixelRatioTo : uniformName === "u_pixel_ratio_from" ? this.pixelRatioFrom : null;
+                if (pos) {
+                  uniform.set(pos);
+                }
+              };
+              CrossFadedConstantBinder.prototype.getBinding = function getBinding(context, location2, name3) {
+                return name3.substr(0, 9) === "u_pattern" ? new Uniform4f(context, location2) : new Uniform1f(context, location2);
+              };
+              var SourceExpressionBinder = function SourceExpressionBinder2(expression2, names2, type, PaintVertexArray) {
+                this.expression = expression2;
+                this.type = type;
+                this.maxValue = 0;
+                this.paintVertexAttributes = names2.map(function(name3) {
+                  return {
+                    name: "a_" + name3,
+                    type: "Float32",
+                    components: type === "color" ? 2 : 1,
+                    offset: 0
+                  };
+                });
+                this.paintVertexArray = new PaintVertexArray();
+              };
+              SourceExpressionBinder.prototype.populatePaintArray = function populatePaintArray(newLength, feature, imagePositions, canonical, formattedSection) {
+                var start = this.paintVertexArray.length;
+                var value = this.expression.evaluate(new EvaluationParameters(0), feature, {}, canonical, [], formattedSection);
+                this.paintVertexArray.resize(newLength);
+                this._setPaintValue(start, newLength, value);
+              };
+              SourceExpressionBinder.prototype.updatePaintArray = function updatePaintArray(start, end, feature, featureState) {
+                var value = this.expression.evaluate({ zoom: 0 }, feature, featureState);
+                this._setPaintValue(start, end, value);
+              };
+              SourceExpressionBinder.prototype._setPaintValue = function _setPaintValue(start, end, value) {
+                if (this.type === "color") {
+                  var color3 = packColor(value);
+                  for (var i2 = start; i2 < end; i2++) {
+                    this.paintVertexArray.emplace(i2, color3[0], color3[1]);
+                  }
+                } else {
+                  for (var i$1 = start; i$1 < end; i$1++) {
+                    this.paintVertexArray.emplace(i$1, value);
+                  }
+                  this.maxValue = Math.max(this.maxValue, Math.abs(value));
+                }
+              };
+              SourceExpressionBinder.prototype.upload = function upload(context) {
+                if (this.paintVertexArray && this.paintVertexArray.arrayBuffer) {
+                  if (this.paintVertexBuffer && this.paintVertexBuffer.buffer) {
+                    this.paintVertexBuffer.updateData(this.paintVertexArray);
+                  } else {
+                    this.paintVertexBuffer = context.createVertexBuffer(this.paintVertexArray, this.paintVertexAttributes, this.expression.isStateDependent);
+                  }
+                }
+              };
+              SourceExpressionBinder.prototype.destroy = function destroy() {
+                if (this.paintVertexBuffer) {
+                  this.paintVertexBuffer.destroy();
+                }
+              };
+              var CompositeExpressionBinder = function CompositeExpressionBinder2(expression2, names2, type, useIntegerZoom, zoom, PaintVertexArray) {
+                this.expression = expression2;
+                this.uniformNames = names2.map(function(name3) {
+                  return "u_" + name3 + "_t";
+                });
+                this.type = type;
+                this.useIntegerZoom = useIntegerZoom;
+                this.zoom = zoom;
+                this.maxValue = 0;
+                this.paintVertexAttributes = names2.map(function(name3) {
+                  return {
+                    name: "a_" + name3,
+                    type: "Float32",
+                    components: type === "color" ? 4 : 2,
+                    offset: 0
+                  };
+                });
+                this.paintVertexArray = new PaintVertexArray();
+              };
+              CompositeExpressionBinder.prototype.populatePaintArray = function populatePaintArray(newLength, feature, imagePositions, canonical, formattedSection) {
+                var min = this.expression.evaluate(new EvaluationParameters(this.zoom), feature, {}, canonical, [], formattedSection);
+                var max = this.expression.evaluate(new EvaluationParameters(this.zoom + 1), feature, {}, canonical, [], formattedSection);
+                var start = this.paintVertexArray.length;
+                this.paintVertexArray.resize(newLength);
+                this._setPaintValue(start, newLength, min, max);
+              };
+              CompositeExpressionBinder.prototype.updatePaintArray = function updatePaintArray(start, end, feature, featureState) {
+                var min = this.expression.evaluate({ zoom: this.zoom }, feature, featureState);
+                var max = this.expression.evaluate({ zoom: this.zoom + 1 }, feature, featureState);
+                this._setPaintValue(start, end, min, max);
+              };
+              CompositeExpressionBinder.prototype._setPaintValue = function _setPaintValue(start, end, min, max) {
+                if (this.type === "color") {
+                  var minColor = packColor(min);
+                  var maxColor = packColor(max);
+                  for (var i2 = start; i2 < end; i2++) {
+                    this.paintVertexArray.emplace(i2, minColor[0], minColor[1], maxColor[0], maxColor[1]);
+                  }
+                } else {
+                  for (var i$1 = start; i$1 < end; i$1++) {
+                    this.paintVertexArray.emplace(i$1, min, max);
+                  }
+                  this.maxValue = Math.max(this.maxValue, Math.abs(min), Math.abs(max));
+                }
+              };
+              CompositeExpressionBinder.prototype.upload = function upload(context) {
+                if (this.paintVertexArray && this.paintVertexArray.arrayBuffer) {
+                  if (this.paintVertexBuffer && this.paintVertexBuffer.buffer) {
+                    this.paintVertexBuffer.updateData(this.paintVertexArray);
+                  } else {
+                    this.paintVertexBuffer = context.createVertexBuffer(this.paintVertexArray, this.paintVertexAttributes, this.expression.isStateDependent);
+                  }
+                }
+              };
+              CompositeExpressionBinder.prototype.destroy = function destroy() {
+                if (this.paintVertexBuffer) {
+                  this.paintVertexBuffer.destroy();
+                }
+              };
+              CompositeExpressionBinder.prototype.setUniform = function setUniform2(uniform, globals) {
+                var currentZoom = this.useIntegerZoom ? Math.floor(globals.zoom) : globals.zoom;
+                var factor = clamp2(this.expression.interpolationFactor(currentZoom, this.zoom, this.zoom + 1), 0, 1);
+                uniform.set(factor);
+              };
+              CompositeExpressionBinder.prototype.getBinding = function getBinding(context, location2, _2) {
+                return new Uniform1f(context, location2);
+              };
+              var CrossFadedCompositeBinder = function CrossFadedCompositeBinder2(expression2, type, useIntegerZoom, zoom, PaintVertexArray, layerId) {
+                this.expression = expression2;
+                this.type = type;
+                this.useIntegerZoom = useIntegerZoom;
+                this.zoom = zoom;
+                this.layerId = layerId;
+                this.zoomInPaintVertexArray = new PaintVertexArray();
+                this.zoomOutPaintVertexArray = new PaintVertexArray();
+              };
+              CrossFadedCompositeBinder.prototype.populatePaintArray = function populatePaintArray(length2, feature, imagePositions) {
+                var start = this.zoomInPaintVertexArray.length;
+                this.zoomInPaintVertexArray.resize(length2);
+                this.zoomOutPaintVertexArray.resize(length2);
+                this._setPaintValues(start, length2, feature.patterns && feature.patterns[this.layerId], imagePositions);
+              };
+              CrossFadedCompositeBinder.prototype.updatePaintArray = function updatePaintArray(start, end, feature, featureState, imagePositions) {
+                this._setPaintValues(start, end, feature.patterns && feature.patterns[this.layerId], imagePositions);
+              };
+              CrossFadedCompositeBinder.prototype._setPaintValues = function _setPaintValues(start, end, patterns, positions) {
+                if (!positions || !patterns) {
+                  return;
+                }
+                var min = patterns.min;
+                var mid = patterns.mid;
+                var max = patterns.max;
+                var imageMin = positions[min];
+                var imageMid = positions[mid];
+                var imageMax = positions[max];
+                if (!imageMin || !imageMid || !imageMax) {
+                  return;
+                }
+                for (var i2 = start; i2 < end; i2++) {
+                  this.zoomInPaintVertexArray.emplace(i2, imageMid.tl[0], imageMid.tl[1], imageMid.br[0], imageMid.br[1], imageMin.tl[0], imageMin.tl[1], imageMin.br[0], imageMin.br[1], imageMid.pixelRatio, imageMin.pixelRatio);
+                  this.zoomOutPaintVertexArray.emplace(i2, imageMid.tl[0], imageMid.tl[1], imageMid.br[0], imageMid.br[1], imageMax.tl[0], imageMax.tl[1], imageMax.br[0], imageMax.br[1], imageMid.pixelRatio, imageMax.pixelRatio);
+                }
+              };
+              CrossFadedCompositeBinder.prototype.upload = function upload(context) {
+                if (this.zoomInPaintVertexArray && this.zoomInPaintVertexArray.arrayBuffer && this.zoomOutPaintVertexArray && this.zoomOutPaintVertexArray.arrayBuffer) {
+                  this.zoomInPaintVertexBuffer = context.createVertexBuffer(this.zoomInPaintVertexArray, patternAttributes.members, this.expression.isStateDependent);
+                  this.zoomOutPaintVertexBuffer = context.createVertexBuffer(this.zoomOutPaintVertexArray, patternAttributes.members, this.expression.isStateDependent);
+                }
+              };
+              CrossFadedCompositeBinder.prototype.destroy = function destroy() {
+                if (this.zoomOutPaintVertexBuffer) {
+                  this.zoomOutPaintVertexBuffer.destroy();
+                }
+                if (this.zoomInPaintVertexBuffer) {
+                  this.zoomInPaintVertexBuffer.destroy();
+                }
+              };
+              var ProgramConfiguration = function ProgramConfiguration2(layer2, zoom, filterProperties) {
+                this.binders = {};
+                this._buffers = [];
+                var keys = [];
+                for (var property in layer2.paint._values) {
+                  if (!filterProperties(property)) {
+                    continue;
+                  }
+                  var value = layer2.paint.get(property);
+                  if (!(value instanceof PossiblyEvaluatedPropertyValue) || !supportsPropertyExpression(value.property.specification)) {
+                    continue;
+                  }
+                  var names2 = paintAttributeNames(property, layer2.type);
+                  var expression2 = value.value;
+                  var type = value.property.specification.type;
+                  var useIntegerZoom = value.property.useIntegerZoom;
+                  var propType = value.property.specification["property-type"];
+                  var isCrossFaded = propType === "cross-faded" || propType === "cross-faded-data-driven";
+                  if (expression2.kind === "constant") {
+                    this.binders[property] = isCrossFaded ? new CrossFadedConstantBinder(expression2.value, names2) : new ConstantBinder(expression2.value, names2, type);
+                    keys.push("/u_" + property);
+                  } else if (expression2.kind === "source" || isCrossFaded) {
+                    var StructArrayLayout = layoutType(property, type, "source");
+                    this.binders[property] = isCrossFaded ? new CrossFadedCompositeBinder(expression2, type, useIntegerZoom, zoom, StructArrayLayout, layer2.id) : new SourceExpressionBinder(expression2, names2, type, StructArrayLayout);
+                    keys.push("/a_" + property);
+                  } else {
+                    var StructArrayLayout$1 = layoutType(property, type, "composite");
+                    this.binders[property] = new CompositeExpressionBinder(expression2, names2, type, useIntegerZoom, zoom, StructArrayLayout$1);
+                    keys.push("/z_" + property);
+                  }
+                }
+                this.cacheKey = keys.sort().join("");
+              };
+              ProgramConfiguration.prototype.getMaxValue = function getMaxValue(property) {
+                var binder = this.binders[property];
+                return binder instanceof SourceExpressionBinder || binder instanceof CompositeExpressionBinder ? binder.maxValue : 0;
+              };
+              ProgramConfiguration.prototype.populatePaintArrays = function populatePaintArrays(newLength, feature, imagePositions, canonical, formattedSection) {
+                for (var property in this.binders) {
+                  var binder = this.binders[property];
+                  if (binder instanceof SourceExpressionBinder || binder instanceof CompositeExpressionBinder || binder instanceof CrossFadedCompositeBinder) {
+                    binder.populatePaintArray(newLength, feature, imagePositions, canonical, formattedSection);
+                  }
+                }
+              };
+              ProgramConfiguration.prototype.setConstantPatternPositions = function setConstantPatternPositions(posTo, posFrom) {
+                for (var property in this.binders) {
+                  var binder = this.binders[property];
+                  if (binder instanceof CrossFadedConstantBinder) {
+                    binder.setConstantPatternPositions(posTo, posFrom);
+                  }
+                }
+              };
+              ProgramConfiguration.prototype.updatePaintArrays = function updatePaintArrays(featureStates, featureMap, vtLayer, layer2, imagePositions) {
+                var dirty = false;
+                for (var id22 in featureStates) {
+                  var positions = featureMap.getPositions(id22);
+                  for (var i2 = 0, list = positions; i2 < list.length; i2 += 1) {
+                    var pos = list[i2];
+                    var feature = vtLayer.feature(pos.index);
+                    for (var property in this.binders) {
+                      var binder = this.binders[property];
+                      if ((binder instanceof SourceExpressionBinder || binder instanceof CompositeExpressionBinder || binder instanceof CrossFadedCompositeBinder) && binder.expression.isStateDependent === true) {
+                        var value = layer2.paint.get(property);
+                        binder.expression = value.value;
+                        binder.updatePaintArray(pos.start, pos.end, feature, featureStates[id22], imagePositions);
+                        dirty = true;
+                      }
+                    }
+                  }
+                }
+                return dirty;
+              };
+              ProgramConfiguration.prototype.defines = function defines2() {
+                var result = [];
+                for (var property in this.binders) {
+                  var binder = this.binders[property];
+                  if (binder instanceof ConstantBinder || binder instanceof CrossFadedConstantBinder) {
+                    result.push.apply(result, binder.uniformNames.map(function(name3) {
+                      return "#define HAS_UNIFORM_" + name3;
+                    }));
+                  }
+                }
+                return result;
+              };
+              ProgramConfiguration.prototype.getBinderAttributes = function getBinderAttributes() {
+                var result = [];
+                for (var property in this.binders) {
+                  var binder = this.binders[property];
+                  if (binder instanceof SourceExpressionBinder || binder instanceof CompositeExpressionBinder) {
+                    for (var i2 = 0; i2 < binder.paintVertexAttributes.length; i2++) {
+                      result.push(binder.paintVertexAttributes[i2].name);
+                    }
+                  } else if (binder instanceof CrossFadedCompositeBinder) {
+                    for (var i$1 = 0; i$1 < patternAttributes.members.length; i$1++) {
+                      result.push(patternAttributes.members[i$1].name);
+                    }
+                  }
+                }
+                return result;
+              };
+              ProgramConfiguration.prototype.getBinderUniforms = function getBinderUniforms() {
+                var uniforms = [];
+                for (var property in this.binders) {
+                  var binder = this.binders[property];
+                  if (binder instanceof ConstantBinder || binder instanceof CrossFadedConstantBinder || binder instanceof CompositeExpressionBinder) {
+                    for (var i2 = 0, list = binder.uniformNames; i2 < list.length; i2 += 1) {
+                      var uniformName = list[i2];
+                      uniforms.push(uniformName);
+                    }
+                  }
+                }
+                return uniforms;
+              };
+              ProgramConfiguration.prototype.getPaintVertexBuffers = function getPaintVertexBuffers() {
+                return this._buffers;
+              };
+              ProgramConfiguration.prototype.getUniforms = function getUniforms2(context, locations) {
+                var uniforms = [];
+                for (var property in this.binders) {
+                  var binder = this.binders[property];
+                  if (binder instanceof ConstantBinder || binder instanceof CrossFadedConstantBinder || binder instanceof CompositeExpressionBinder) {
+                    for (var i2 = 0, list = binder.uniformNames; i2 < list.length; i2 += 1) {
+                      var name3 = list[i2];
+                      if (locations[name3]) {
+                        var binding = binder.getBinding(context, locations[name3], name3);
+                        uniforms.push({
+                          name: name3,
+                          property,
+                          binding
+                        });
+                      }
+                    }
+                  }
+                }
+                return uniforms;
+              };
+              ProgramConfiguration.prototype.setUniforms = function setUniforms(context, binderUniforms, properties2, globals) {
+                for (var i2 = 0, list = binderUniforms; i2 < list.length; i2 += 1) {
+                  var ref = list[i2];
+                  var name3 = ref.name;
+                  var property = ref.property;
+                  var binding = ref.binding;
+                  this.binders[property].setUniform(binding, globals, properties2.get(property), name3);
+                }
+              };
+              ProgramConfiguration.prototype.updatePaintBuffers = function updatePaintBuffers(crossfade) {
+                this._buffers = [];
+                for (var property in this.binders) {
+                  var binder = this.binders[property];
+                  if (crossfade && binder instanceof CrossFadedCompositeBinder) {
+                    var patternVertexBuffer = crossfade.fromScale === 2 ? binder.zoomInPaintVertexBuffer : binder.zoomOutPaintVertexBuffer;
+                    if (patternVertexBuffer) {
+                      this._buffers.push(patternVertexBuffer);
+                    }
+                  } else if ((binder instanceof SourceExpressionBinder || binder instanceof CompositeExpressionBinder) && binder.paintVertexBuffer) {
+                    this._buffers.push(binder.paintVertexBuffer);
+                  }
+                }
+              };
+              ProgramConfiguration.prototype.upload = function upload(context) {
+                for (var property in this.binders) {
+                  var binder = this.binders[property];
+                  if (binder instanceof SourceExpressionBinder || binder instanceof CompositeExpressionBinder || binder instanceof CrossFadedCompositeBinder) {
+                    binder.upload(context);
+                  }
+                }
+                this.updatePaintBuffers();
+              };
+              ProgramConfiguration.prototype.destroy = function destroy() {
+                for (var property in this.binders) {
+                  var binder = this.binders[property];
+                  if (binder instanceof SourceExpressionBinder || binder instanceof CompositeExpressionBinder || binder instanceof CrossFadedCompositeBinder) {
+                    binder.destroy();
+                  }
+                }
+              };
+              var ProgramConfigurationSet = function ProgramConfigurationSet2(layers, zoom, filterProperties) {
+                if (filterProperties === void 0)
+                  filterProperties = function() {
+                    return true;
+                  };
+                this.programConfigurations = {};
+                for (var i2 = 0, list = layers; i2 < list.length; i2 += 1) {
+                  var layer2 = list[i2];
+                  this.programConfigurations[layer2.id] = new ProgramConfiguration(layer2, zoom, filterProperties);
+                }
+                this.needsUpload = false;
+                this._featureMap = new FeaturePositionMap();
+                this._bufferOffset = 0;
+              };
+              ProgramConfigurationSet.prototype.populatePaintArrays = function populatePaintArrays(length2, feature, index, imagePositions, canonical, formattedSection) {
+                for (var key in this.programConfigurations) {
+                  this.programConfigurations[key].populatePaintArrays(length2, feature, imagePositions, canonical, formattedSection);
+                }
+                if (feature.id !== void 0) {
+                  this._featureMap.add(feature.id, index, this._bufferOffset, length2);
+                }
+                this._bufferOffset = length2;
+                this.needsUpload = true;
+              };
+              ProgramConfigurationSet.prototype.updatePaintArrays = function updatePaintArrays(featureStates, vtLayer, layers, imagePositions) {
+                for (var i2 = 0, list = layers; i2 < list.length; i2 += 1) {
+                  var layer2 = list[i2];
+                  this.needsUpload = this.programConfigurations[layer2.id].updatePaintArrays(featureStates, this._featureMap, vtLayer, layer2, imagePositions) || this.needsUpload;
+                }
+              };
+              ProgramConfigurationSet.prototype.get = function get2(layerId) {
+                return this.programConfigurations[layerId];
+              };
+              ProgramConfigurationSet.prototype.upload = function upload(context) {
+                if (!this.needsUpload) {
+                  return;
+                }
+                for (var layerId in this.programConfigurations) {
+                  this.programConfigurations[layerId].upload(context);
+                }
+                this.needsUpload = false;
+              };
+              ProgramConfigurationSet.prototype.destroy = function destroy() {
+                for (var layerId in this.programConfigurations) {
+                  this.programConfigurations[layerId].destroy();
+                }
+              };
+              function paintAttributeNames(property, type) {
+                var attributeNameExceptions = {
+                  "text-opacity": ["opacity"],
+                  "icon-opacity": ["opacity"],
+                  "text-color": ["fill_color"],
+                  "icon-color": ["fill_color"],
+                  "text-halo-color": ["halo_color"],
+                  "icon-halo-color": ["halo_color"],
+                  "text-halo-blur": ["halo_blur"],
+                  "icon-halo-blur": ["halo_blur"],
+                  "text-halo-width": ["halo_width"],
+                  "icon-halo-width": ["halo_width"],
+                  "line-gap-width": ["gapwidth"],
+                  "line-pattern": [
+                    "pattern_to",
+                    "pattern_from",
+                    "pixel_ratio_to",
+                    "pixel_ratio_from"
+                  ],
+                  "fill-pattern": [
+                    "pattern_to",
+                    "pattern_from",
+                    "pixel_ratio_to",
+                    "pixel_ratio_from"
+                  ],
+                  "fill-extrusion-pattern": [
+                    "pattern_to",
+                    "pattern_from",
+                    "pixel_ratio_to",
+                    "pixel_ratio_from"
+                  ]
+                };
+                return attributeNameExceptions[property] || [property.replace(type + "-", "").replace(/-/g, "_")];
+              }
+              function getLayoutException(property) {
+                var propertyExceptions = {
+                  "line-pattern": {
+                    "source": StructArrayLayout10ui20,
+                    "composite": StructArrayLayout10ui20
+                  },
+                  "fill-pattern": {
+                    "source": StructArrayLayout10ui20,
+                    "composite": StructArrayLayout10ui20
+                  },
+                  "fill-extrusion-pattern": {
+                    "source": StructArrayLayout10ui20,
+                    "composite": StructArrayLayout10ui20
+                  }
+                };
+                return propertyExceptions[property];
+              }
+              function layoutType(property, type, binderType) {
+                var defaultLayouts = {
+                  "color": {
+                    "source": StructArrayLayout2f8,
+                    "composite": StructArrayLayout4f16
+                  },
+                  "number": {
+                    "source": StructArrayLayout1f4,
+                    "composite": StructArrayLayout2f8
+                  }
+                };
+                var layoutException = getLayoutException(property);
+                return layoutException && layoutException[binderType] || defaultLayouts[type][binderType];
+              }
+              register2("ConstantBinder", ConstantBinder);
+              register2("CrossFadedConstantBinder", CrossFadedConstantBinder);
+              register2("SourceExpressionBinder", SourceExpressionBinder);
+              register2("CrossFadedCompositeBinder", CrossFadedCompositeBinder);
+              register2("CompositeExpressionBinder", CompositeExpressionBinder);
+              register2("ProgramConfiguration", ProgramConfiguration, { omit: ["_buffers"] });
+              register2("ProgramConfigurationSet", ProgramConfigurationSet);
+              var EXTENT$1 = 8192;
+              var BITS = 15;
+              var MAX = Math.pow(2, BITS - 1) - 1;
+              var MIN = -MAX - 1;
+              function loadGeometry(feature) {
+                var scale22 = EXTENT$1 / feature.extent;
+                var geometry2 = feature.loadGeometry();
+                for (var r2 = 0; r2 < geometry2.length; r2++) {
+                  var ring = geometry2[r2];
+                  for (var p2 = 0; p2 < ring.length; p2++) {
+                    var point = ring[p2];
+                    var x2 = Math.round(point.x * scale22);
+                    var y2 = Math.round(point.y * scale22);
+                    point.x = clamp2(x2, MIN, MAX);
+                    point.y = clamp2(y2, MIN, MAX);
+                    if (x2 < point.x || x2 > point.x + 1 || y2 < point.y || y2 > point.y + 1) {
+                      warnOnce("Geometry exceeds allowed extent, reduce your vector tile buffer size");
+                    }
+                  }
+                }
+                return geometry2;
+              }
+              function toEvaluationFeature(feature, needGeometry) {
+                return {
+                  type: feature.type,
+                  id: feature.id,
+                  properties: feature.properties,
+                  geometry: needGeometry ? loadGeometry(feature) : []
+                };
+              }
+              function addCircleVertex(layoutVertexArray, x2, y2, extrudeX, extrudeY) {
+                layoutVertexArray.emplaceBack(x2 * 2 + (extrudeX + 1) / 2, y2 * 2 + (extrudeY + 1) / 2);
+              }
+              var CircleBucket = function CircleBucket2(options) {
+                this.zoom = options.zoom;
+                this.overscaling = options.overscaling;
+                this.layers = options.layers;
+                this.layerIds = this.layers.map(function(layer2) {
+                  return layer2.id;
+                });
+                this.index = options.index;
+                this.hasPattern = false;
+                this.layoutVertexArray = new StructArrayLayout2i4();
+                this.indexArray = new StructArrayLayout3ui6();
+                this.segments = new SegmentVector();
+                this.programConfigurations = new ProgramConfigurationSet(options.layers, options.zoom);
+                this.stateDependentLayerIds = this.layers.filter(function(l2) {
+                  return l2.isStateDependent();
+                }).map(function(l2) {
+                  return l2.id;
+                });
+              };
+              CircleBucket.prototype.populate = function populate(features, options, canonical) {
+                var styleLayer = this.layers[0];
+                var bucketFeatures = [];
+                var circleSortKey = null;
+                if (styleLayer.type === "circle") {
+                  circleSortKey = styleLayer.layout.get("circle-sort-key");
+                }
+                for (var i2 = 0, list = features; i2 < list.length; i2 += 1) {
+                  var ref = list[i2];
+                  var feature = ref.feature;
+                  var id22 = ref.id;
+                  var index = ref.index;
+                  var sourceLayerIndex = ref.sourceLayerIndex;
+                  var needGeometry = this.layers[0]._featureFilter.needGeometry;
+                  var evaluationFeature = toEvaluationFeature(feature, needGeometry);
+                  if (!this.layers[0]._featureFilter.filter(new EvaluationParameters(this.zoom), evaluationFeature, canonical)) {
+                    continue;
+                  }
+                  var sortKey = circleSortKey ? circleSortKey.evaluate(evaluationFeature, {}, canonical) : void 0;
+                  var bucketFeature = {
+                    id: id22,
+                    properties: feature.properties,
+                    type: feature.type,
+                    sourceLayerIndex,
+                    index,
+                    geometry: needGeometry ? evaluationFeature.geometry : loadGeometry(feature),
+                    patterns: {},
+                    sortKey
+                  };
+                  bucketFeatures.push(bucketFeature);
+                }
+                if (circleSortKey) {
+                  bucketFeatures.sort(function(a2, b2) {
+                    return a2.sortKey - b2.sortKey;
+                  });
+                }
+                for (var i$1 = 0, list$1 = bucketFeatures; i$1 < list$1.length; i$1 += 1) {
+                  var bucketFeature$1 = list$1[i$1];
+                  var ref$1 = bucketFeature$1;
+                  var geometry2 = ref$1.geometry;
+                  var index$1 = ref$1.index;
+                  var sourceLayerIndex$1 = ref$1.sourceLayerIndex;
+                  var feature$1 = features[index$1].feature;
+                  this.addFeature(bucketFeature$1, geometry2, index$1, canonical);
+                  options.featureIndex.insert(feature$1, geometry2, index$1, sourceLayerIndex$1, this.index);
+                }
+              };
+              CircleBucket.prototype.update = function update(states, vtLayer, imagePositions) {
+                if (!this.stateDependentLayers.length) {
+                  return;
+                }
+                this.programConfigurations.updatePaintArrays(states, vtLayer, this.stateDependentLayers, imagePositions);
+              };
+              CircleBucket.prototype.isEmpty = function isEmpty2() {
+                return this.layoutVertexArray.length === 0;
+              };
+              CircleBucket.prototype.uploadPending = function uploadPending() {
+                return !this.uploaded || this.programConfigurations.needsUpload;
+              };
+              CircleBucket.prototype.upload = function upload(context) {
+                if (!this.uploaded) {
+                  this.layoutVertexBuffer = context.createVertexBuffer(this.layoutVertexArray, members);
+                  this.indexBuffer = context.createIndexBuffer(this.indexArray);
+                }
+                this.programConfigurations.upload(context);
+                this.uploaded = true;
+              };
+              CircleBucket.prototype.destroy = function destroy() {
+                if (!this.layoutVertexBuffer) {
+                  return;
+                }
+                this.layoutVertexBuffer.destroy();
+                this.indexBuffer.destroy();
+                this.programConfigurations.destroy();
+                this.segments.destroy();
+              };
+              CircleBucket.prototype.addFeature = function addFeature2(feature, geometry2, index, canonical) {
+                for (var i$1 = 0, list$1 = geometry2; i$1 < list$1.length; i$1 += 1) {
+                  var ring = list$1[i$1];
+                  for (var i2 = 0, list = ring; i2 < list.length; i2 += 1) {
+                    var point = list[i2];
+                    var x2 = point.x;
+                    var y2 = point.y;
+                    if (x2 < 0 || x2 >= EXTENT$1 || y2 < 0 || y2 >= EXTENT$1) {
+                      continue;
+                    }
+                    var segment = this.segments.prepareSegment(4, this.layoutVertexArray, this.indexArray, feature.sortKey);
+                    var index$1 = segment.vertexLength;
+                    addCircleVertex(this.layoutVertexArray, x2, y2, -1, -1);
+                    addCircleVertex(this.layoutVertexArray, x2, y2, 1, -1);
+                    addCircleVertex(this.layoutVertexArray, x2, y2, 1, 1);
+                    addCircleVertex(this.layoutVertexArray, x2, y2, -1, 1);
+                    this.indexArray.emplaceBack(index$1, index$1 + 1, index$1 + 2);
+                    this.indexArray.emplaceBack(index$1, index$1 + 3, index$1 + 2);
+                    segment.vertexLength += 4;
+                    segment.primitiveLength += 2;
+                  }
+                }
+                this.programConfigurations.populatePaintArrays(this.layoutVertexArray.length, feature, index, {}, canonical);
+              };
+              register2("CircleBucket", CircleBucket, { omit: ["layers"] });
+              function polygonIntersectsPolygon(polygonA, polygonB) {
+                for (var i2 = 0; i2 < polygonA.length; i2++) {
+                  if (polygonContainsPoint(polygonB, polygonA[i2])) {
+                    return true;
+                  }
+                }
+                for (var i$1 = 0; i$1 < polygonB.length; i$1++) {
+                  if (polygonContainsPoint(polygonA, polygonB[i$1])) {
+                    return true;
+                  }
+                }
+                if (lineIntersectsLine(polygonA, polygonB)) {
+                  return true;
+                }
+                return false;
+              }
+              function polygonIntersectsBufferedPoint(polygon, point, radius) {
+                if (polygonContainsPoint(polygon, point)) {
+                  return true;
+                }
+                if (pointIntersectsBufferedLine(point, polygon, radius)) {
+                  return true;
+                }
+                return false;
+              }
+              function polygonIntersectsMultiPolygon(polygon, multiPolygon) {
+                if (polygon.length === 1) {
+                  return multiPolygonContainsPoint(multiPolygon, polygon[0]);
+                }
+                for (var m2 = 0; m2 < multiPolygon.length; m2++) {
+                  var ring = multiPolygon[m2];
+                  for (var n2 = 0; n2 < ring.length; n2++) {
+                    if (polygonContainsPoint(polygon, ring[n2])) {
+                      return true;
+                    }
+                  }
+                }
+                for (var i2 = 0; i2 < polygon.length; i2++) {
+                  if (multiPolygonContainsPoint(multiPolygon, polygon[i2])) {
+                    return true;
+                  }
+                }
+                for (var k2 = 0; k2 < multiPolygon.length; k2++) {
+                  if (lineIntersectsLine(polygon, multiPolygon[k2])) {
+                    return true;
+                  }
+                }
+                return false;
+              }
+              function polygonIntersectsBufferedMultiLine(polygon, multiLine, radius) {
+                for (var i2 = 0; i2 < multiLine.length; i2++) {
+                  var line = multiLine[i2];
+                  if (polygon.length >= 3) {
+                    for (var k2 = 0; k2 < line.length; k2++) {
+                      if (polygonContainsPoint(polygon, line[k2])) {
+                        return true;
+                      }
+                    }
+                  }
+                  if (lineIntersectsBufferedLine(polygon, line, radius)) {
+                    return true;
+                  }
+                }
+                return false;
+              }
+              function lineIntersectsBufferedLine(lineA, lineB, radius) {
+                if (lineA.length > 1) {
+                  if (lineIntersectsLine(lineA, lineB)) {
+                    return true;
+                  }
+                  for (var j2 = 0; j2 < lineB.length; j2++) {
+                    if (pointIntersectsBufferedLine(lineB[j2], lineA, radius)) {
+                      return true;
+                    }
+                  }
+                }
+                for (var k2 = 0; k2 < lineA.length; k2++) {
+                  if (pointIntersectsBufferedLine(lineA[k2], lineB, radius)) {
+                    return true;
+                  }
+                }
+                return false;
+              }
+              function lineIntersectsLine(lineA, lineB) {
+                if (lineA.length === 0 || lineB.length === 0) {
+                  return false;
+                }
+                for (var i2 = 0; i2 < lineA.length - 1; i2++) {
+                  var a0 = lineA[i2];
+                  var a1 = lineA[i2 + 1];
+                  for (var j2 = 0; j2 < lineB.length - 1; j2++) {
+                    var b0 = lineB[j2];
+                    var b1 = lineB[j2 + 1];
+                    if (lineSegmentIntersectsLineSegment(a0, a1, b0, b1)) {
+                      return true;
+                    }
+                  }
+                }
+                return false;
+              }
+              function lineSegmentIntersectsLineSegment(a0, a1, b0, b1) {
+                return isCounterClockwise(a0, b0, b1) !== isCounterClockwise(a1, b0, b1) && isCounterClockwise(a0, a1, b0) !== isCounterClockwise(a0, a1, b1);
+              }
+              function pointIntersectsBufferedLine(p2, line, radius) {
+                var radiusSquared = radius * radius;
+                if (line.length === 1) {
+                  return p2.distSqr(line[0]) < radiusSquared;
+                }
+                for (var i2 = 1; i2 < line.length; i2++) {
+                  var v2 = line[i2 - 1], w2 = line[i2];
+                  if (distToSegmentSquared(p2, v2, w2) < radiusSquared) {
+                    return true;
+                  }
+                }
+                return false;
+              }
+              function distToSegmentSquared(p2, v2, w2) {
+                var l2 = v2.distSqr(w2);
+                if (l2 === 0) {
+                  return p2.distSqr(v2);
+                }
+                var t4 = ((p2.x - v2.x) * (w2.x - v2.x) + (p2.y - v2.y) * (w2.y - v2.y)) / l2;
+                if (t4 < 0) {
+                  return p2.distSqr(v2);
+                }
+                if (t4 > 1) {
+                  return p2.distSqr(w2);
+                }
+                return p2.distSqr(w2.sub(v2)._mult(t4)._add(v2));
+              }
+              function multiPolygonContainsPoint(rings, p2) {
+                var c2 = false, ring, p1, p22;
+                for (var k2 = 0; k2 < rings.length; k2++) {
+                  ring = rings[k2];
+                  for (var i2 = 0, j2 = ring.length - 1; i2 < ring.length; j2 = i2++) {
+                    p1 = ring[i2];
+                    p22 = ring[j2];
+                    if (p1.y > p2.y !== p22.y > p2.y && p2.x < (p22.x - p1.x) * (p2.y - p1.y) / (p22.y - p1.y) + p1.x) {
+                      c2 = !c2;
+                    }
+                  }
+                }
+                return c2;
+              }
+              function polygonContainsPoint(ring, p2) {
+                var c2 = false;
+                for (var i2 = 0, j2 = ring.length - 1; i2 < ring.length; j2 = i2++) {
+                  var p1 = ring[i2];
+                  var p22 = ring[j2];
+                  if (p1.y > p2.y !== p22.y > p2.y && p2.x < (p22.x - p1.x) * (p2.y - p1.y) / (p22.y - p1.y) + p1.x) {
+                    c2 = !c2;
+                  }
+                }
+                return c2;
+              }
+              function polygonIntersectsBox(ring, boxX1, boxY1, boxX2, boxY2) {
+                for (var i$1 = 0, list = ring; i$1 < list.length; i$1 += 1) {
+                  var p2 = list[i$1];
+                  if (boxX1 <= p2.x && boxY1 <= p2.y && boxX2 >= p2.x && boxY2 >= p2.y) {
+                    return true;
+                  }
+                }
+                var corners = [
+                  new pointGeometry(boxX1, boxY1),
+                  new pointGeometry(boxX1, boxY2),
+                  new pointGeometry(boxX2, boxY2),
+                  new pointGeometry(boxX2, boxY1)
+                ];
+                if (ring.length > 2) {
+                  for (var i$2 = 0, list$1 = corners; i$2 < list$1.length; i$2 += 1) {
+                    var corner = list$1[i$2];
+                    if (polygonContainsPoint(ring, corner)) {
+                      return true;
+                    }
+                  }
+                }
+                for (var i2 = 0; i2 < ring.length - 1; i2++) {
+                  var p1 = ring[i2];
+                  var p22 = ring[i2 + 1];
+                  if (edgeIntersectsBox(p1, p22, corners)) {
+                    return true;
+                  }
+                }
+                return false;
+              }
+              function edgeIntersectsBox(e1, e2, corners) {
+                var tl2 = corners[0];
+                var br = corners[2];
+                if (e1.x < tl2.x && e2.x < tl2.x || e1.x > br.x && e2.x > br.x || e1.y < tl2.y && e2.y < tl2.y || e1.y > br.y && e2.y > br.y) {
+                  return false;
+                }
+                var dir = isCounterClockwise(e1, e2, corners[0]);
+                return dir !== isCounterClockwise(e1, e2, corners[1]) || dir !== isCounterClockwise(e1, e2, corners[2]) || dir !== isCounterClockwise(e1, e2, corners[3]);
+              }
+              function getMaximumPaintValue(property, layer2, bucket) {
+                var value = layer2.paint.get(property).value;
+                if (value.kind === "constant") {
+                  return value.value;
+                } else {
+                  return bucket.programConfigurations.get(layer2.id).getMaxValue(property);
+                }
+              }
+              function translateDistance(translate22) {
+                return Math.sqrt(translate22[0] * translate22[0] + translate22[1] * translate22[1]);
+              }
+              function translate2(queryGeometry, translate22, translateAnchor, bearing, pixelsToTileUnits) {
+                if (!translate22[0] && !translate22[1]) {
+                  return queryGeometry;
+                }
+                var pt2 = pointGeometry.convert(translate22)._mult(pixelsToTileUnits);
+                if (translateAnchor === "viewport") {
+                  pt2._rotate(-bearing);
+                }
+                var translated = [];
+                for (var i2 = 0; i2 < queryGeometry.length; i2++) {
+                  var point = queryGeometry[i2];
+                  translated.push(point.sub(pt2));
+                }
+                return translated;
+              }
+              var layout$2 = new Properties({ "circle-sort-key": new DataDrivenProperty(spec["layout_circle"]["circle-sort-key"]) });
+              var paint$1 = new Properties({
+                "circle-radius": new DataDrivenProperty(spec["paint_circle"]["circle-radius"]),
+                "circle-color": new DataDrivenProperty(spec["paint_circle"]["circle-color"]),
+                "circle-blur": new DataDrivenProperty(spec["paint_circle"]["circle-blur"]),
+                "circle-opacity": new DataDrivenProperty(spec["paint_circle"]["circle-opacity"]),
+                "circle-translate": new DataConstantProperty(spec["paint_circle"]["circle-translate"]),
+                "circle-translate-anchor": new DataConstantProperty(spec["paint_circle"]["circle-translate-anchor"]),
+                "circle-pitch-scale": new DataConstantProperty(spec["paint_circle"]["circle-pitch-scale"]),
+                "circle-pitch-alignment": new DataConstantProperty(spec["paint_circle"]["circle-pitch-alignment"]),
+                "circle-stroke-width": new DataDrivenProperty(spec["paint_circle"]["circle-stroke-width"]),
+                "circle-stroke-color": new DataDrivenProperty(spec["paint_circle"]["circle-stroke-color"]),
+                "circle-stroke-opacity": new DataDrivenProperty(spec["paint_circle"]["circle-stroke-opacity"])
+              });
+              var properties = {
+                paint: paint$1,
+                layout: layout$2
+              };
+              var ARRAY_TYPE2 = typeof Float32Array !== "undefined" ? Float32Array : Array;
+              if (!Math.hypot) {
+                Math.hypot = function() {
+                  var arguments$1 = arguments;
+                  var y2 = 0, i2 = arguments.length;
+                  while (i2--) {
+                    y2 += arguments$1[i2] * arguments$1[i2];
+                  }
+                  return Math.sqrt(y2);
+                };
+              }
+              function create2() {
+                var out = new ARRAY_TYPE2(4);
+                if (ARRAY_TYPE2 != Float32Array) {
+                  out[1] = 0;
+                  out[2] = 0;
+                }
+                out[0] = 1;
+                out[3] = 1;
+                return out;
+              }
+              function rotate2(out, a2, rad) {
+                var a0 = a2[0], a1 = a2[1], a22 = a2[2], a3 = a2[3];
+                var s2 = Math.sin(rad);
+                var c2 = Math.cos(rad);
+                out[0] = a0 * c2 + a22 * s2;
+                out[1] = a1 * c2 + a3 * s2;
+                out[2] = a0 * -s2 + a22 * c2;
+                out[3] = a1 * -s2 + a3 * c2;
+                return out;
+              }
+              function create$12() {
+                var out = new ARRAY_TYPE2(9);
+                if (ARRAY_TYPE2 != Float32Array) {
+                  out[1] = 0;
+                  out[2] = 0;
+                  out[3] = 0;
+                  out[5] = 0;
+                  out[6] = 0;
+                  out[7] = 0;
+                }
+                out[0] = 1;
+                out[4] = 1;
+                out[8] = 1;
+                return out;
+              }
+              function fromRotation(out, rad) {
+                var s2 = Math.sin(rad), c2 = Math.cos(rad);
+                out[0] = c2;
+                out[1] = s2;
+                out[2] = 0;
+                out[3] = -s2;
+                out[4] = c2;
+                out[5] = 0;
+                out[6] = 0;
+                out[7] = 0;
+                out[8] = 1;
+                return out;
+              }
+              function create$22() {
+                var out = new ARRAY_TYPE2(16);
+                if (ARRAY_TYPE2 != Float32Array) {
+                  out[1] = 0;
+                  out[2] = 0;
+                  out[3] = 0;
+                  out[4] = 0;
+                  out[6] = 0;
+                  out[7] = 0;
+                  out[8] = 0;
+                  out[9] = 0;
+                  out[11] = 0;
+                  out[12] = 0;
+                  out[13] = 0;
+                  out[14] = 0;
+                }
+                out[0] = 1;
+                out[5] = 1;
+                out[10] = 1;
+                out[15] = 1;
+                return out;
+              }
+              function clone$1(a2) {
+                var out = new ARRAY_TYPE2(16);
+                out[0] = a2[0];
+                out[1] = a2[1];
+                out[2] = a2[2];
+                out[3] = a2[3];
+                out[4] = a2[4];
+                out[5] = a2[5];
+                out[6] = a2[6];
+                out[7] = a2[7];
+                out[8] = a2[8];
+                out[9] = a2[9];
+                out[10] = a2[10];
+                out[11] = a2[11];
+                out[12] = a2[12];
+                out[13] = a2[13];
+                out[14] = a2[14];
+                out[15] = a2[15];
+                return out;
+              }
+              function identity22(out) {
+                out[0] = 1;
+                out[1] = 0;
+                out[2] = 0;
+                out[3] = 0;
+                out[4] = 0;
+                out[5] = 1;
+                out[6] = 0;
+                out[7] = 0;
+                out[8] = 0;
+                out[9] = 0;
+                out[10] = 1;
+                out[11] = 0;
+                out[12] = 0;
+                out[13] = 0;
+                out[14] = 0;
+                out[15] = 1;
+                return out;
+              }
+              function invert2(out, a2) {
+                var a00 = a2[0], a01 = a2[1], a02 = a2[2], a03 = a2[3];
+                var a10 = a2[4], a11 = a2[5], a12 = a2[6], a13 = a2[7];
+                var a20 = a2[8], a21 = a2[9], a22 = a2[10], a23 = a2[11];
+                var a30 = a2[12], a31 = a2[13], a32 = a2[14], a33 = a2[15];
+                var b00 = a00 * a11 - a01 * a10;
+                var b01 = a00 * a12 - a02 * a10;
+                var b02 = a00 * a13 - a03 * a10;
+                var b03 = a01 * a12 - a02 * a11;
+                var b04 = a01 * a13 - a03 * a11;
+                var b05 = a02 * a13 - a03 * a12;
+                var b06 = a20 * a31 - a21 * a30;
+                var b07 = a20 * a32 - a22 * a30;
+                var b08 = a20 * a33 - a23 * a30;
+                var b09 = a21 * a32 - a22 * a31;
+                var b10 = a21 * a33 - a23 * a31;
+                var b11 = a22 * a33 - a23 * a32;
+                var det = b00 * b11 - b01 * b10 + b02 * b09 + b03 * b08 - b04 * b07 + b05 * b06;
+                if (!det) {
+                  return null;
+                }
+                det = 1 / det;
+                out[0] = (a11 * b11 - a12 * b10 + a13 * b09) * det;
+                out[1] = (a02 * b10 - a01 * b11 - a03 * b09) * det;
+                out[2] = (a31 * b05 - a32 * b04 + a33 * b03) * det;
+                out[3] = (a22 * b04 - a21 * b05 - a23 * b03) * det;
+                out[4] = (a12 * b08 - a10 * b11 - a13 * b07) * det;
+                out[5] = (a00 * b11 - a02 * b08 + a03 * b07) * det;
+                out[6] = (a32 * b02 - a30 * b05 - a33 * b01) * det;
+                out[7] = (a20 * b05 - a22 * b02 + a23 * b01) * det;
+                out[8] = (a10 * b10 - a11 * b08 + a13 * b06) * det;
+                out[9] = (a01 * b08 - a00 * b10 - a03 * b06) * det;
+                out[10] = (a30 * b04 - a31 * b02 + a33 * b00) * det;
+                out[11] = (a21 * b02 - a20 * b04 - a23 * b00) * det;
+                out[12] = (a11 * b07 - a10 * b09 - a12 * b06) * det;
+                out[13] = (a00 * b09 - a01 * b07 + a02 * b06) * det;
+                out[14] = (a31 * b01 - a30 * b03 - a32 * b00) * det;
+                out[15] = (a20 * b03 - a21 * b01 + a22 * b00) * det;
+                return out;
+              }
+              function multiply2(out, a2, b2) {
+                var a00 = a2[0], a01 = a2[1], a02 = a2[2], a03 = a2[3];
+                var a10 = a2[4], a11 = a2[5], a12 = a2[6], a13 = a2[7];
+                var a20 = a2[8], a21 = a2[9], a22 = a2[10], a23 = a2[11];
+                var a30 = a2[12], a31 = a2[13], a32 = a2[14], a33 = a2[15];
+                var b0 = b2[0], b1 = b2[1], b22 = b2[2], b3 = b2[3];
+                out[0] = b0 * a00 + b1 * a10 + b22 * a20 + b3 * a30;
+                out[1] = b0 * a01 + b1 * a11 + b22 * a21 + b3 * a31;
+                out[2] = b0 * a02 + b1 * a12 + b22 * a22 + b3 * a32;
+                out[3] = b0 * a03 + b1 * a13 + b22 * a23 + b3 * a33;
+                b0 = b2[4];
+                b1 = b2[5];
+                b22 = b2[6];
+                b3 = b2[7];
+                out[4] = b0 * a00 + b1 * a10 + b22 * a20 + b3 * a30;
+                out[5] = b0 * a01 + b1 * a11 + b22 * a21 + b3 * a31;
+                out[6] = b0 * a02 + b1 * a12 + b22 * a22 + b3 * a32;
+                out[7] = b0 * a03 + b1 * a13 + b22 * a23 + b3 * a33;
+                b0 = b2[8];
+                b1 = b2[9];
+                b22 = b2[10];
+                b3 = b2[11];
+                out[8] = b0 * a00 + b1 * a10 + b22 * a20 + b3 * a30;
+                out[9] = b0 * a01 + b1 * a11 + b22 * a21 + b3 * a31;
+                out[10] = b0 * a02 + b1 * a12 + b22 * a22 + b3 * a32;
+                out[11] = b0 * a03 + b1 * a13 + b22 * a23 + b3 * a33;
+                b0 = b2[12];
+                b1 = b2[13];
+                b22 = b2[14];
+                b3 = b2[15];
+                out[12] = b0 * a00 + b1 * a10 + b22 * a20 + b3 * a30;
+                out[13] = b0 * a01 + b1 * a11 + b22 * a21 + b3 * a31;
+                out[14] = b0 * a02 + b1 * a12 + b22 * a22 + b3 * a32;
+                out[15] = b0 * a03 + b1 * a13 + b22 * a23 + b3 * a33;
+                return out;
+              }
+              function translate$1(out, a2, v2) {
+                var x2 = v2[0], y2 = v2[1], z2 = v2[2];
+                var a00, a01, a02, a03;
+                var a10, a11, a12, a13;
+                var a20, a21, a22, a23;
+                if (a2 === out) {
+                  out[12] = a2[0] * x2 + a2[4] * y2 + a2[8] * z2 + a2[12];
+                  out[13] = a2[1] * x2 + a2[5] * y2 + a2[9] * z2 + a2[13];
+                  out[14] = a2[2] * x2 + a2[6] * y2 + a2[10] * z2 + a2[14];
+                  out[15] = a2[3] * x2 + a2[7] * y2 + a2[11] * z2 + a2[15];
+                } else {
+                  a00 = a2[0];
+                  a01 = a2[1];
+                  a02 = a2[2];
+                  a03 = a2[3];
+                  a10 = a2[4];
+                  a11 = a2[5];
+                  a12 = a2[6];
+                  a13 = a2[7];
+                  a20 = a2[8];
+                  a21 = a2[9];
+                  a22 = a2[10];
+                  a23 = a2[11];
+                  out[0] = a00;
+                  out[1] = a01;
+                  out[2] = a02;
+                  out[3] = a03;
+                  out[4] = a10;
+                  out[5] = a11;
+                  out[6] = a12;
+                  out[7] = a13;
+                  out[8] = a20;
+                  out[9] = a21;
+                  out[10] = a22;
+                  out[11] = a23;
+                  out[12] = a00 * x2 + a10 * y2 + a20 * z2 + a2[12];
+                  out[13] = a01 * x2 + a11 * y2 + a21 * z2 + a2[13];
+                  out[14] = a02 * x2 + a12 * y2 + a22 * z2 + a2[14];
+                  out[15] = a03 * x2 + a13 * y2 + a23 * z2 + a2[15];
+                }
+                return out;
+              }
+              function scale2(out, a2, v2) {
+                var x2 = v2[0], y2 = v2[1], z2 = v2[2];
+                out[0] = a2[0] * x2;
+                out[1] = a2[1] * x2;
+                out[2] = a2[2] * x2;
+                out[3] = a2[3] * x2;
+                out[4] = a2[4] * y2;
+                out[5] = a2[5] * y2;
+                out[6] = a2[6] * y2;
+                out[7] = a2[7] * y2;
+                out[8] = a2[8] * z2;
+                out[9] = a2[9] * z2;
+                out[10] = a2[10] * z2;
+                out[11] = a2[11] * z2;
+                out[12] = a2[12];
+                out[13] = a2[13];
+                out[14] = a2[14];
+                out[15] = a2[15];
+                return out;
+              }
+              function rotateX2(out, a2, rad) {
+                var s2 = Math.sin(rad);
+                var c2 = Math.cos(rad);
+                var a10 = a2[4];
+                var a11 = a2[5];
+                var a12 = a2[6];
+                var a13 = a2[7];
+                var a20 = a2[8];
+                var a21 = a2[9];
+                var a22 = a2[10];
+                var a23 = a2[11];
+                if (a2 !== out) {
+                  out[0] = a2[0];
+                  out[1] = a2[1];
+                  out[2] = a2[2];
+                  out[3] = a2[3];
+                  out[12] = a2[12];
+                  out[13] = a2[13];
+                  out[14] = a2[14];
+                  out[15] = a2[15];
+                }
+                out[4] = a10 * c2 + a20 * s2;
+                out[5] = a11 * c2 + a21 * s2;
+                out[6] = a12 * c2 + a22 * s2;
+                out[7] = a13 * c2 + a23 * s2;
+                out[8] = a20 * c2 - a10 * s2;
+                out[9] = a21 * c2 - a11 * s2;
+                out[10] = a22 * c2 - a12 * s2;
+                out[11] = a23 * c2 - a13 * s2;
+                return out;
+              }
+              function rotateZ2(out, a2, rad) {
+                var s2 = Math.sin(rad);
+                var c2 = Math.cos(rad);
+                var a00 = a2[0];
+                var a01 = a2[1];
+                var a02 = a2[2];
+                var a03 = a2[3];
+                var a10 = a2[4];
+                var a11 = a2[5];
+                var a12 = a2[6];
+                var a13 = a2[7];
+                if (a2 !== out) {
+                  out[8] = a2[8];
+                  out[9] = a2[9];
+                  out[10] = a2[10];
+                  out[11] = a2[11];
+                  out[12] = a2[12];
+                  out[13] = a2[13];
+                  out[14] = a2[14];
+                  out[15] = a2[15];
+                }
+                out[0] = a00 * c2 + a10 * s2;
+                out[1] = a01 * c2 + a11 * s2;
+                out[2] = a02 * c2 + a12 * s2;
+                out[3] = a03 * c2 + a13 * s2;
+                out[4] = a10 * c2 - a00 * s2;
+                out[5] = a11 * c2 - a01 * s2;
+                out[6] = a12 * c2 - a02 * s2;
+                out[7] = a13 * c2 - a03 * s2;
+                return out;
+              }
+              function perspective2(out, fovy, aspect, near, far) {
+                var f2 = 1 / Math.tan(fovy / 2), nf2;
+                out[0] = f2 / aspect;
+                out[1] = 0;
+                out[2] = 0;
+                out[3] = 0;
+                out[4] = 0;
+                out[5] = f2;
+                out[6] = 0;
+                out[7] = 0;
+                out[8] = 0;
+                out[9] = 0;
+                out[11] = -1;
+                out[12] = 0;
+                out[13] = 0;
+                out[15] = 0;
+                if (far != null && far !== Infinity) {
+                  nf2 = 1 / (near - far);
+                  out[10] = (far + near) * nf2;
+                  out[14] = 2 * far * near * nf2;
+                } else {
+                  out[10] = -1;
+                  out[14] = -2 * near;
+                }
+                return out;
+              }
+              function ortho2(out, left, right, bottom, top, near, far) {
+                var lr = 1 / (left - right);
+                var bt = 1 / (bottom - top);
+                var nf2 = 1 / (near - far);
+                out[0] = -2 * lr;
+                out[1] = 0;
+                out[2] = 0;
+                out[3] = 0;
+                out[4] = 0;
+                out[5] = -2 * bt;
+                out[6] = 0;
+                out[7] = 0;
+                out[8] = 0;
+                out[9] = 0;
+                out[10] = 2 * nf2;
+                out[11] = 0;
+                out[12] = (left + right) * lr;
+                out[13] = (top + bottom) * bt;
+                out[14] = (far + near) * nf2;
+                out[15] = 1;
+                return out;
+              }
+              var mul = multiply2;
+              function create$3() {
+                var out = new ARRAY_TYPE2(3);
+                if (ARRAY_TYPE2 != Float32Array) {
+                  out[0] = 0;
+                  out[1] = 0;
+                  out[2] = 0;
+                }
+                return out;
+              }
+              function clone$2(a2) {
+                var out = new ARRAY_TYPE2(3);
+                out[0] = a2[0];
+                out[1] = a2[1];
+                out[2] = a2[2];
+                return out;
+              }
+              function add2(out, a2, b2) {
+                out[0] = a2[0] + b2[0];
+                out[1] = a2[1] + b2[1];
+                out[2] = a2[2] + b2[2];
+                return out;
+              }
+              function subtract2(out, a2, b2) {
+                out[0] = a2[0] - b2[0];
+                out[1] = a2[1] - b2[1];
+                out[2] = a2[2] - b2[2];
+                return out;
+              }
+              function scale$12(out, a2, b2) {
+                out[0] = a2[0] * b2;
+                out[1] = a2[1] * b2;
+                out[2] = a2[2] * b2;
+                return out;
+              }
+              function normalize(out, a2) {
+                var x2 = a2[0];
+                var y2 = a2[1];
+                var z2 = a2[2];
+                var len2 = x2 * x2 + y2 * y2 + z2 * z2;
+                if (len2 > 0) {
+                  len2 = 1 / Math.sqrt(len2);
+                }
+                out[0] = a2[0] * len2;
+                out[1] = a2[1] * len2;
+                out[2] = a2[2] * len2;
+                return out;
+              }
+              function dot2(a2, b2) {
+                return a2[0] * b2[0] + a2[1] * b2[1] + a2[2] * b2[2];
+              }
+              function cross2(out, a2, b2) {
+                var ax = a2[0], ay = a2[1], az = a2[2];
+                var bx = b2[0], by = b2[1], bz = b2[2];
+                out[0] = ay * bz - az * by;
+                out[1] = az * bx - ax * bz;
+                out[2] = ax * by - ay * bx;
+                return out;
+              }
+              function transformMat32(out, a2, m2) {
+                var x2 = a2[0], y2 = a2[1], z2 = a2[2];
+                out[0] = x2 * m2[0] + y2 * m2[3] + z2 * m2[6];
+                out[1] = x2 * m2[1] + y2 * m2[4] + z2 * m2[7];
+                out[2] = x2 * m2[2] + y2 * m2[5] + z2 * m2[8];
+                return out;
+              }
+              var sub2 = subtract2;
+              (function() {
+                var vec = create$3();
+                return function(a2, stride, offset, count2, fn, arg) {
+                  var i2, l2;
+                  if (!stride) {
+                    stride = 3;
+                  }
+                  if (!offset) {
+                    offset = 0;
+                  }
+                  if (count2) {
+                    l2 = Math.min(count2 * stride + offset, a2.length);
+                  } else {
+                    l2 = a2.length;
+                  }
+                  for (i2 = offset; i2 < l2; i2 += stride) {
+                    vec[0] = a2[i2];
+                    vec[1] = a2[i2 + 1];
+                    vec[2] = a2[i2 + 2];
+                    fn(vec, vec, arg);
+                    a2[i2] = vec[0];
+                    a2[i2 + 1] = vec[1];
+                    a2[i2 + 2] = vec[2];
+                  }
+                  return a2;
+                };
+              })();
+              function create$4() {
+                var out = new ARRAY_TYPE2(4);
+                if (ARRAY_TYPE2 != Float32Array) {
+                  out[0] = 0;
+                  out[1] = 0;
+                  out[2] = 0;
+                  out[3] = 0;
+                }
+                return out;
+              }
+              function scale$2(out, a2, b2) {
+                out[0] = a2[0] * b2;
+                out[1] = a2[1] * b2;
+                out[2] = a2[2] * b2;
+                out[3] = a2[3] * b2;
+                return out;
+              }
+              function dot$1(a2, b2) {
+                return a2[0] * b2[0] + a2[1] * b2[1] + a2[2] * b2[2] + a2[3] * b2[3];
+              }
+              function transformMat42(out, a2, m2) {
+                var x2 = a2[0], y2 = a2[1], z2 = a2[2], w2 = a2[3];
+                out[0] = m2[0] * x2 + m2[4] * y2 + m2[8] * z2 + m2[12] * w2;
+                out[1] = m2[1] * x2 + m2[5] * y2 + m2[9] * z2 + m2[13] * w2;
+                out[2] = m2[2] * x2 + m2[6] * y2 + m2[10] * z2 + m2[14] * w2;
+                out[3] = m2[3] * x2 + m2[7] * y2 + m2[11] * z2 + m2[15] * w2;
+                return out;
+              }
+              (function() {
+                var vec = create$4();
+                return function(a2, stride, offset, count2, fn, arg) {
+                  var i2, l2;
+                  if (!stride) {
+                    stride = 4;
+                  }
+                  if (!offset) {
+                    offset = 0;
+                  }
+                  if (count2) {
+                    l2 = Math.min(count2 * stride + offset, a2.length);
+                  } else {
+                    l2 = a2.length;
+                  }
+                  for (i2 = offset; i2 < l2; i2 += stride) {
+                    vec[0] = a2[i2];
+                    vec[1] = a2[i2 + 1];
+                    vec[2] = a2[i2 + 2];
+                    vec[3] = a2[i2 + 3];
+                    fn(vec, vec, arg);
+                    a2[i2] = vec[0];
+                    a2[i2 + 1] = vec[1];
+                    a2[i2 + 2] = vec[2];
+                    a2[i2 + 3] = vec[3];
+                  }
+                  return a2;
+                };
+              })();
+              function create$5() {
+                var out = new ARRAY_TYPE2(2);
+                if (ARRAY_TYPE2 != Float32Array) {
+                  out[0] = 0;
+                  out[1] = 0;
+                }
+                return out;
+              }
+              function squaredLength2(a2) {
+                var x2 = a2[0], y2 = a2[1];
+                return x2 * x2 + y2 * y2;
+              }
+              var sqrLen2 = squaredLength2;
+              (function() {
+                var vec = create$5();
+                return function(a2, stride, offset, count2, fn, arg) {
+                  var i2, l2;
+                  if (!stride) {
+                    stride = 2;
+                  }
+                  if (!offset) {
+                    offset = 0;
+                  }
+                  if (count2) {
+                    l2 = Math.min(count2 * stride + offset, a2.length);
+                  } else {
+                    l2 = a2.length;
+                  }
+                  for (i2 = offset; i2 < l2; i2 += stride) {
+                    vec[0] = a2[i2];
+                    vec[1] = a2[i2 + 1];
+                    fn(vec, vec, arg);
+                    a2[i2] = vec[0];
+                    a2[i2 + 1] = vec[1];
+                  }
+                  return a2;
+                };
+              })();
+              var CircleStyleLayer = function(StyleLayer2) {
+                function CircleStyleLayer2(layer2) {
+                  StyleLayer2.call(this, layer2, properties);
+                }
+                if (StyleLayer2)
+                  CircleStyleLayer2.__proto__ = StyleLayer2;
+                CircleStyleLayer2.prototype = Object.create(StyleLayer2 && StyleLayer2.prototype);
+                CircleStyleLayer2.prototype.constructor = CircleStyleLayer2;
+                CircleStyleLayer2.prototype.createBucket = function createBucket(parameters) {
+                  return new CircleBucket(parameters);
+                };
+                CircleStyleLayer2.prototype.queryRadius = function queryRadius(bucket) {
+                  var circleBucket = bucket;
+                  return getMaximumPaintValue("circle-radius", this, circleBucket) + getMaximumPaintValue("circle-stroke-width", this, circleBucket) + translateDistance(this.paint.get("circle-translate"));
+                };
+                CircleStyleLayer2.prototype.queryIntersectsFeature = function queryIntersectsFeature(queryGeometry, feature, featureState, geometry2, zoom, transform, pixelsToTileUnits, pixelPosMatrix) {
+                  var translatedPolygon = translate2(queryGeometry, this.paint.get("circle-translate"), this.paint.get("circle-translate-anchor"), transform.angle, pixelsToTileUnits);
+                  var radius = this.paint.get("circle-radius").evaluate(feature, featureState);
+                  var stroke = this.paint.get("circle-stroke-width").evaluate(feature, featureState);
+                  var size = radius + stroke;
+                  var alignWithMap = this.paint.get("circle-pitch-alignment") === "map";
+                  var transformedPolygon = alignWithMap ? translatedPolygon : projectQueryGeometry(translatedPolygon, pixelPosMatrix);
+                  var transformedSize = alignWithMap ? size * pixelsToTileUnits : size;
+                  for (var i$1 = 0, list$1 = geometry2; i$1 < list$1.length; i$1 += 1) {
+                    var ring = list$1[i$1];
+                    for (var i2 = 0, list = ring; i2 < list.length; i2 += 1) {
+                      var point = list[i2];
+                      var transformedPoint = alignWithMap ? point : projectPoint(point, pixelPosMatrix);
+                      var adjustedSize = transformedSize;
+                      var projectedCenter = transformMat42([], [
+                        point.x,
+                        point.y,
+                        0,
+                        1
+                      ], pixelPosMatrix);
+                      if (this.paint.get("circle-pitch-scale") === "viewport" && this.paint.get("circle-pitch-alignment") === "map") {
+                        adjustedSize *= projectedCenter[3] / transform.cameraToCenterDistance;
+                      } else if (this.paint.get("circle-pitch-scale") === "map" && this.paint.get("circle-pitch-alignment") === "viewport") {
+                        adjustedSize *= transform.cameraToCenterDistance / projectedCenter[3];
+                      }
+                      if (polygonIntersectsBufferedPoint(transformedPolygon, transformedPoint, adjustedSize)) {
+                        return true;
+                      }
+                    }
+                  }
+                  return false;
+                };
+                return CircleStyleLayer2;
+              }(StyleLayer);
+              function projectPoint(p2, pixelPosMatrix) {
+                var point = transformMat42([], [
+                  p2.x,
+                  p2.y,
+                  0,
+                  1
+                ], pixelPosMatrix);
+                return new pointGeometry(point[0] / point[3], point[1] / point[3]);
+              }
+              function projectQueryGeometry(queryGeometry, pixelPosMatrix) {
+                return queryGeometry.map(function(p2) {
+                  return projectPoint(p2, pixelPosMatrix);
+                });
+              }
+              var HeatmapBucket = function(CircleBucket2) {
+                function HeatmapBucket2() {
+                  CircleBucket2.apply(this, arguments);
+                }
+                if (CircleBucket2)
+                  HeatmapBucket2.__proto__ = CircleBucket2;
+                HeatmapBucket2.prototype = Object.create(CircleBucket2 && CircleBucket2.prototype);
+                HeatmapBucket2.prototype.constructor = HeatmapBucket2;
+                return HeatmapBucket2;
+              }(CircleBucket);
+              register2("HeatmapBucket", HeatmapBucket, { omit: ["layers"] });
+              function createImage(image, ref, channels, data) {
+                var width = ref.width;
+                var height = ref.height;
+                if (!data) {
+                  data = new Uint8Array(width * height * channels);
+                } else if (data instanceof Uint8ClampedArray) {
+                  data = new Uint8Array(data.buffer);
+                } else if (data.length !== width * height * channels) {
+                  throw new RangeError("mismatched image size");
+                }
+                image.width = width;
+                image.height = height;
+                image.data = data;
+                return image;
+              }
+              function resizeImage(image, ref, channels) {
+                var width = ref.width;
+                var height = ref.height;
+                if (width === image.width && height === image.height) {
+                  return;
+                }
+                var newImage = createImage({}, {
+                  width,
+                  height
+                }, channels);
+                copyImage(image, newImage, {
+                  x: 0,
+                  y: 0
+                }, {
+                  x: 0,
+                  y: 0
+                }, {
+                  width: Math.min(image.width, width),
+                  height: Math.min(image.height, height)
+                }, channels);
+                image.width = width;
+                image.height = height;
+                image.data = newImage.data;
+              }
+              function copyImage(srcImg, dstImg, srcPt, dstPt, size, channels) {
+                if (size.width === 0 || size.height === 0) {
+                  return dstImg;
+                }
+                if (size.width > srcImg.width || size.height > srcImg.height || srcPt.x > srcImg.width - size.width || srcPt.y > srcImg.height - size.height) {
+                  throw new RangeError("out of range source coordinates for image copy");
+                }
+                if (size.width > dstImg.width || size.height > dstImg.height || dstPt.x > dstImg.width - size.width || dstPt.y > dstImg.height - size.height) {
+                  throw new RangeError("out of range destination coordinates for image copy");
+                }
+                var srcData = srcImg.data;
+                var dstData = dstImg.data;
+                for (var y2 = 0; y2 < size.height; y2++) {
+                  var srcOffset = ((srcPt.y + y2) * srcImg.width + srcPt.x) * channels;
+                  var dstOffset = ((dstPt.y + y2) * dstImg.width + dstPt.x) * channels;
+                  for (var i2 = 0; i2 < size.width * channels; i2++) {
+                    dstData[dstOffset + i2] = srcData[srcOffset + i2];
+                  }
+                }
+                return dstImg;
+              }
+              var AlphaImage = function AlphaImage2(size, data) {
+                createImage(this, size, 1, data);
+              };
+              AlphaImage.prototype.resize = function resize(size) {
+                resizeImage(this, size, 1);
+              };
+              AlphaImage.prototype.clone = function clone2() {
+                return new AlphaImage({
+                  width: this.width,
+                  height: this.height
+                }, new Uint8Array(this.data));
+              };
+              AlphaImage.copy = function copy(srcImg, dstImg, srcPt, dstPt, size) {
+                copyImage(srcImg, dstImg, srcPt, dstPt, size, 1);
+              };
+              var RGBAImage = function RGBAImage2(size, data) {
+                createImage(this, size, 4, data);
+              };
+              RGBAImage.prototype.resize = function resize(size) {
+                resizeImage(this, size, 4);
+              };
+              RGBAImage.prototype.replace = function replace(data, copy) {
+                if (copy) {
+                  this.data.set(data);
+                } else if (data instanceof Uint8ClampedArray) {
+                  this.data = new Uint8Array(data.buffer);
+                } else {
+                  this.data = data;
+                }
+              };
+              RGBAImage.prototype.clone = function clone2() {
+                return new RGBAImage({
+                  width: this.width,
+                  height: this.height
+                }, new Uint8Array(this.data));
+              };
+              RGBAImage.copy = function copy(srcImg, dstImg, srcPt, dstPt, size) {
+                copyImage(srcImg, dstImg, srcPt, dstPt, size, 4);
+              };
+              register2("AlphaImage", AlphaImage);
+              register2("RGBAImage", RGBAImage);
+              var paint$2 = new Properties({
+                "heatmap-radius": new DataDrivenProperty(spec["paint_heatmap"]["heatmap-radius"]),
+                "heatmap-weight": new DataDrivenProperty(spec["paint_heatmap"]["heatmap-weight"]),
+                "heatmap-intensity": new DataConstantProperty(spec["paint_heatmap"]["heatmap-intensity"]),
+                "heatmap-color": new ColorRampProperty(spec["paint_heatmap"]["heatmap-color"]),
+                "heatmap-opacity": new DataConstantProperty(spec["paint_heatmap"]["heatmap-opacity"])
+              });
+              var properties$1 = { paint: paint$2 };
+              function renderColorRamp(params) {
+                var evaluationGlobals = {};
+                var width = params.resolution || 256;
+                var height = params.clips ? params.clips.length : 1;
+                var image = params.image || new RGBAImage({
+                  width,
+                  height
+                });
+                var renderPixel = function(stride2, index, progress2) {
+                  evaluationGlobals[params.evaluationKey] = progress2;
+                  var pxColor = params.expression.evaluate(evaluationGlobals);
+                  image.data[stride2 + index + 0] = Math.floor(pxColor.r * 255 / pxColor.a);
+                  image.data[stride2 + index + 1] = Math.floor(pxColor.g * 255 / pxColor.a);
+                  image.data[stride2 + index + 2] = Math.floor(pxColor.b * 255 / pxColor.a);
+                  image.data[stride2 + index + 3] = Math.floor(pxColor.a * 255);
+                };
+                if (!params.clips) {
+                  for (var i2 = 0, j2 = 0; i2 < width; i2++, j2 += 4) {
+                    var progress = i2 / (width - 1);
+                    renderPixel(0, j2, progress);
+                  }
+                } else {
+                  for (var clip = 0, stride = 0; clip < height; ++clip, stride += width * 4) {
+                    for (var i$1 = 0, j$1 = 0; i$1 < width; i$1++, j$1 += 4) {
+                      var progress$1 = i$1 / (width - 1);
+                      var ref = params.clips[clip];
+                      var start = ref.start;
+                      var end = ref.end;
+                      var evaluationProgress = start * (1 - progress$1) + end * progress$1;
+                      renderPixel(stride, j$1, evaluationProgress);
+                    }
+                  }
+                }
+                return image;
+              }
+              var HeatmapStyleLayer = function(StyleLayer2) {
+                function HeatmapStyleLayer2(layer2) {
+                  StyleLayer2.call(this, layer2, properties$1);
+                  this._updateColorRamp();
+                }
+                if (StyleLayer2)
+                  HeatmapStyleLayer2.__proto__ = StyleLayer2;
+                HeatmapStyleLayer2.prototype = Object.create(StyleLayer2 && StyleLayer2.prototype);
+                HeatmapStyleLayer2.prototype.constructor = HeatmapStyleLayer2;
+                HeatmapStyleLayer2.prototype.createBucket = function createBucket(options) {
+                  return new HeatmapBucket(options);
+                };
+                HeatmapStyleLayer2.prototype._handleSpecialPaintPropertyUpdate = function _handleSpecialPaintPropertyUpdate(name3) {
+                  if (name3 === "heatmap-color") {
+                    this._updateColorRamp();
+                  }
+                };
+                HeatmapStyleLayer2.prototype._updateColorRamp = function _updateColorRamp() {
+                  var expression2 = this._transitionablePaint._values["heatmap-color"].value.expression;
+                  this.colorRamp = renderColorRamp({
+                    expression: expression2,
+                    evaluationKey: "heatmapDensity",
+                    image: this.colorRamp
+                  });
+                  this.colorRampTexture = null;
+                };
+                HeatmapStyleLayer2.prototype.resize = function resize() {
+                  if (this.heatmapFbo) {
+                    this.heatmapFbo.destroy();
+                    this.heatmapFbo = null;
+                  }
+                };
+                HeatmapStyleLayer2.prototype.queryRadius = function queryRadius() {
+                  return 0;
+                };
+                HeatmapStyleLayer2.prototype.queryIntersectsFeature = function queryIntersectsFeature() {
+                  return false;
+                };
+                HeatmapStyleLayer2.prototype.hasOffscreenPass = function hasOffscreenPass() {
+                  return this.paint.get("heatmap-opacity") !== 0 && this.visibility !== "none";
+                };
+                return HeatmapStyleLayer2;
+              }(StyleLayer);
+              var paint$3 = new Properties({
+                "hillshade-illumination-direction": new DataConstantProperty(spec["paint_hillshade"]["hillshade-illumination-direction"]),
+                "hillshade-illumination-anchor": new DataConstantProperty(spec["paint_hillshade"]["hillshade-illumination-anchor"]),
+                "hillshade-exaggeration": new DataConstantProperty(spec["paint_hillshade"]["hillshade-exaggeration"]),
+                "hillshade-shadow-color": new DataConstantProperty(spec["paint_hillshade"]["hillshade-shadow-color"]),
+                "hillshade-highlight-color": new DataConstantProperty(spec["paint_hillshade"]["hillshade-highlight-color"]),
+                "hillshade-accent-color": new DataConstantProperty(spec["paint_hillshade"]["hillshade-accent-color"])
+              });
+              var properties$2 = { paint: paint$3 };
+              var HillshadeStyleLayer = function(StyleLayer2) {
+                function HillshadeStyleLayer2(layer2) {
+                  StyleLayer2.call(this, layer2, properties$2);
+                }
+                if (StyleLayer2)
+                  HillshadeStyleLayer2.__proto__ = StyleLayer2;
+                HillshadeStyleLayer2.prototype = Object.create(StyleLayer2 && StyleLayer2.prototype);
+                HillshadeStyleLayer2.prototype.constructor = HillshadeStyleLayer2;
+                HillshadeStyleLayer2.prototype.hasOffscreenPass = function hasOffscreenPass() {
+                  return this.paint.get("hillshade-exaggeration") !== 0 && this.visibility !== "none";
+                };
+                return HillshadeStyleLayer2;
+              }(StyleLayer);
+              var layout$3 = createLayout([{
+                name: "a_pos",
+                components: 2,
+                type: "Int16"
+              }], 4);
+              var members$1 = layout$3.members;
+              var earcut_1 = earcut;
+              var default_1 = earcut;
+              function earcut(data, holeIndices, dim) {
+                dim = dim || 2;
+                var hasHoles = holeIndices && holeIndices.length, outerLen = hasHoles ? holeIndices[0] * dim : data.length, outerNode = linkedList(data, 0, outerLen, dim, true), triangles = [];
+                if (!outerNode || outerNode.next === outerNode.prev) {
+                  return triangles;
+                }
+                var minX, minY, maxX, maxY, x2, y2, invSize;
+                if (hasHoles) {
+                  outerNode = eliminateHoles(data, holeIndices, outerNode, dim);
+                }
+                if (data.length > 80 * dim) {
+                  minX = maxX = data[0];
+                  minY = maxY = data[1];
+                  for (var i2 = dim; i2 < outerLen; i2 += dim) {
+                    x2 = data[i2];
+                    y2 = data[i2 + 1];
+                    if (x2 < minX) {
+                      minX = x2;
+                    }
+                    if (y2 < minY) {
+                      minY = y2;
+                    }
+                    if (x2 > maxX) {
+                      maxX = x2;
+                    }
+                    if (y2 > maxY) {
+                      maxY = y2;
+                    }
+                  }
+                  invSize = Math.max(maxX - minX, maxY - minY);
+                  invSize = invSize !== 0 ? 1 / invSize : 0;
+                }
+                earcutLinked(outerNode, triangles, dim, minX, minY, invSize);
+                return triangles;
+              }
+              function linkedList(data, start, end, dim, clockwise) {
+                var i2, last;
+                if (clockwise === signedArea(data, start, end, dim) > 0) {
+                  for (i2 = start; i2 < end; i2 += dim) {
+                    last = insertNode(i2, data[i2], data[i2 + 1], last);
+                  }
+                } else {
+                  for (i2 = end - dim; i2 >= start; i2 -= dim) {
+                    last = insertNode(i2, data[i2], data[i2 + 1], last);
+                  }
+                }
+                if (last && equals2(last, last.next)) {
+                  removeNode(last);
+                  last = last.next;
+                }
+                return last;
+              }
+              function filterPoints(start, end) {
+                if (!start) {
+                  return start;
+                }
+                if (!end) {
+                  end = start;
+                }
+                var p2 = start, again;
+                do {
+                  again = false;
+                  if (!p2.steiner && (equals2(p2, p2.next) || area(p2.prev, p2, p2.next) === 0)) {
+                    removeNode(p2);
+                    p2 = end = p2.prev;
+                    if (p2 === p2.next) {
+                      break;
+                    }
+                    again = true;
+                  } else {
+                    p2 = p2.next;
+                  }
+                } while (again || p2 !== end);
+                return end;
+              }
+              function earcutLinked(ear, triangles, dim, minX, minY, invSize, pass) {
+                if (!ear) {
+                  return;
+                }
+                if (!pass && invSize) {
+                  indexCurve(ear, minX, minY, invSize);
+                }
+                var stop = ear, prev, next;
+                while (ear.prev !== ear.next) {
+                  prev = ear.prev;
+                  next = ear.next;
+                  if (invSize ? isEarHashed(ear, minX, minY, invSize) : isEar(ear)) {
+                    triangles.push(prev.i / dim);
+                    triangles.push(ear.i / dim);
+                    triangles.push(next.i / dim);
+                    removeNode(ear);
+                    ear = next.next;
+                    stop = next.next;
+                    continue;
+                  }
+                  ear = next;
+                  if (ear === stop) {
+                    if (!pass) {
+                      earcutLinked(filterPoints(ear), triangles, dim, minX, minY, invSize, 1);
+                    } else if (pass === 1) {
+                      ear = cureLocalIntersections(filterPoints(ear), triangles, dim);
+                      earcutLinked(ear, triangles, dim, minX, minY, invSize, 2);
+                    } else if (pass === 2) {
+                      splitEarcut(ear, triangles, dim, minX, minY, invSize);
+                    }
+                    break;
+                  }
+                }
+              }
+              function isEar(ear) {
+                var a2 = ear.prev, b2 = ear, c2 = ear.next;
+                if (area(a2, b2, c2) >= 0) {
+                  return false;
+                }
+                var p2 = ear.next.next;
+                while (p2 !== ear.prev) {
+                  if (pointInTriangle(a2.x, a2.y, b2.x, b2.y, c2.x, c2.y, p2.x, p2.y) && area(p2.prev, p2, p2.next) >= 0) {
+                    return false;
+                  }
+                  p2 = p2.next;
+                }
+                return true;
+              }
+              function isEarHashed(ear, minX, minY, invSize) {
+                var a2 = ear.prev, b2 = ear, c2 = ear.next;
+                if (area(a2, b2, c2) >= 0) {
+                  return false;
+                }
+                var minTX = a2.x < b2.x ? a2.x < c2.x ? a2.x : c2.x : b2.x < c2.x ? b2.x : c2.x, minTY = a2.y < b2.y ? a2.y < c2.y ? a2.y : c2.y : b2.y < c2.y ? b2.y : c2.y, maxTX = a2.x > b2.x ? a2.x > c2.x ? a2.x : c2.x : b2.x > c2.x ? b2.x : c2.x, maxTY = a2.y > b2.y ? a2.y > c2.y ? a2.y : c2.y : b2.y > c2.y ? b2.y : c2.y;
+                var minZ = zOrder(minTX, minTY, minX, minY, invSize), maxZ = zOrder(maxTX, maxTY, minX, minY, invSize);
+                var p2 = ear.prevZ, n2 = ear.nextZ;
+                while (p2 && p2.z >= minZ && n2 && n2.z <= maxZ) {
+                  if (p2 !== ear.prev && p2 !== ear.next && pointInTriangle(a2.x, a2.y, b2.x, b2.y, c2.x, c2.y, p2.x, p2.y) && area(p2.prev, p2, p2.next) >= 0) {
+                    return false;
+                  }
+                  p2 = p2.prevZ;
+                  if (n2 !== ear.prev && n2 !== ear.next && pointInTriangle(a2.x, a2.y, b2.x, b2.y, c2.x, c2.y, n2.x, n2.y) && area(n2.prev, n2, n2.next) >= 0) {
+                    return false;
+                  }
+                  n2 = n2.nextZ;
+                }
+                while (p2 && p2.z >= minZ) {
+                  if (p2 !== ear.prev && p2 !== ear.next && pointInTriangle(a2.x, a2.y, b2.x, b2.y, c2.x, c2.y, p2.x, p2.y) && area(p2.prev, p2, p2.next) >= 0) {
+                    return false;
+                  }
+                  p2 = p2.prevZ;
+                }
+                while (n2 && n2.z <= maxZ) {
+                  if (n2 !== ear.prev && n2 !== ear.next && pointInTriangle(a2.x, a2.y, b2.x, b2.y, c2.x, c2.y, n2.x, n2.y) && area(n2.prev, n2, n2.next) >= 0) {
+                    return false;
+                  }
+                  n2 = n2.nextZ;
+                }
+                return true;
+              }
+              function cureLocalIntersections(start, triangles, dim) {
+                var p2 = start;
+                do {
+                  var a2 = p2.prev, b2 = p2.next.next;
+                  if (!equals2(a2, b2) && intersects(a2, p2, p2.next, b2) && locallyInside(a2, b2) && locallyInside(b2, a2)) {
+                    triangles.push(a2.i / dim);
+                    triangles.push(p2.i / dim);
+                    triangles.push(b2.i / dim);
+                    removeNode(p2);
+                    removeNode(p2.next);
+                    p2 = start = b2;
+                  }
+                  p2 = p2.next;
+                } while (p2 !== start);
+                return filterPoints(p2);
+              }
+              function splitEarcut(start, triangles, dim, minX, minY, invSize) {
+                var a2 = start;
+                do {
+                  var b2 = a2.next.next;
+                  while (b2 !== a2.prev) {
+                    if (a2.i !== b2.i && isValidDiagonal(a2, b2)) {
+                      var c2 = splitPolygon(a2, b2);
+                      a2 = filterPoints(a2, a2.next);
+                      c2 = filterPoints(c2, c2.next);
+                      earcutLinked(a2, triangles, dim, minX, minY, invSize);
+                      earcutLinked(c2, triangles, dim, minX, minY, invSize);
+                      return;
+                    }
+                    b2 = b2.next;
+                  }
+                  a2 = a2.next;
+                } while (a2 !== start);
+              }
+              function eliminateHoles(data, holeIndices, outerNode, dim) {
+                var queue = [], i2, len2, start, end, list;
+                for (i2 = 0, len2 = holeIndices.length; i2 < len2; i2++) {
+                  start = holeIndices[i2] * dim;
+                  end = i2 < len2 - 1 ? holeIndices[i2 + 1] * dim : data.length;
+                  list = linkedList(data, start, end, dim, false);
+                  if (list === list.next) {
+                    list.steiner = true;
+                  }
+                  queue.push(getLeftmost(list));
+                }
+                queue.sort(compareX);
+                for (i2 = 0; i2 < queue.length; i2++) {
+                  eliminateHole(queue[i2], outerNode);
+                  outerNode = filterPoints(outerNode, outerNode.next);
+                }
+                return outerNode;
+              }
+              function compareX(a2, b2) {
+                return a2.x - b2.x;
+              }
+              function eliminateHole(hole, outerNode) {
+                outerNode = findHoleBridge(hole, outerNode);
+                if (outerNode) {
+                  var b2 = splitPolygon(outerNode, hole);
+                  filterPoints(outerNode, outerNode.next);
+                  filterPoints(b2, b2.next);
+                }
+              }
+              function findHoleBridge(hole, outerNode) {
+                var p2 = outerNode, hx = hole.x, hy = hole.y, qx = -Infinity, m2;
+                do {
+                  if (hy <= p2.y && hy >= p2.next.y && p2.next.y !== p2.y) {
+                    var x2 = p2.x + (hy - p2.y) * (p2.next.x - p2.x) / (p2.next.y - p2.y);
+                    if (x2 <= hx && x2 > qx) {
+                      qx = x2;
+                      if (x2 === hx) {
+                        if (hy === p2.y) {
+                          return p2;
+                        }
+                        if (hy === p2.next.y) {
+                          return p2.next;
+                        }
+                      }
+                      m2 = p2.x < p2.next.x ? p2 : p2.next;
+                    }
+                  }
+                  p2 = p2.next;
+                } while (p2 !== outerNode);
+                if (!m2) {
+                  return null;
+                }
+                if (hx === qx) {
+                  return m2;
+                }
+                var stop = m2, mx = m2.x, my = m2.y, tanMin = Infinity, tan;
+                p2 = m2;
+                do {
+                  if (hx >= p2.x && p2.x >= mx && hx !== p2.x && pointInTriangle(hy < my ? hx : qx, hy, mx, my, hy < my ? qx : hx, hy, p2.x, p2.y)) {
+                    tan = Math.abs(hy - p2.y) / (hx - p2.x);
+                    if (locallyInside(p2, hole) && (tan < tanMin || tan === tanMin && (p2.x > m2.x || p2.x === m2.x && sectorContainsSector(m2, p2)))) {
+                      m2 = p2;
+                      tanMin = tan;
+                    }
+                  }
+                  p2 = p2.next;
+                } while (p2 !== stop);
+                return m2;
+              }
+              function sectorContainsSector(m2, p2) {
+                return area(m2.prev, m2, p2.prev) < 0 && area(p2.next, m2, m2.next) < 0;
+              }
+              function indexCurve(start, minX, minY, invSize) {
+                var p2 = start;
+                do {
+                  if (p2.z === null) {
+                    p2.z = zOrder(p2.x, p2.y, minX, minY, invSize);
+                  }
+                  p2.prevZ = p2.prev;
+                  p2.nextZ = p2.next;
+                  p2 = p2.next;
+                } while (p2 !== start);
+                p2.prevZ.nextZ = null;
+                p2.prevZ = null;
+                sortLinked(p2);
+              }
+              function sortLinked(list) {
+                var i2, p2, q2, e2, tail, numMerges, pSize, qSize, inSize = 1;
+                do {
+                  p2 = list;
+                  list = null;
+                  tail = null;
+                  numMerges = 0;
+                  while (p2) {
+                    numMerges++;
+                    q2 = p2;
+                    pSize = 0;
+                    for (i2 = 0; i2 < inSize; i2++) {
+                      pSize++;
+                      q2 = q2.nextZ;
+                      if (!q2) {
+                        break;
+                      }
+                    }
+                    qSize = inSize;
+                    while (pSize > 0 || qSize > 0 && q2) {
+                      if (pSize !== 0 && (qSize === 0 || !q2 || p2.z <= q2.z)) {
+                        e2 = p2;
+                        p2 = p2.nextZ;
+                        pSize--;
+                      } else {
+                        e2 = q2;
+                        q2 = q2.nextZ;
+                        qSize--;
+                      }
+                      if (tail) {
+                        tail.nextZ = e2;
+                      } else {
+                        list = e2;
+                      }
+                      e2.prevZ = tail;
+                      tail = e2;
+                    }
+                    p2 = q2;
+                  }
+                  tail.nextZ = null;
+                  inSize *= 2;
+                } while (numMerges > 1);
+                return list;
+              }
+              function zOrder(x2, y2, minX, minY, invSize) {
+                x2 = 32767 * (x2 - minX) * invSize;
+                y2 = 32767 * (y2 - minY) * invSize;
+                x2 = (x2 | x2 << 8) & 16711935;
+                x2 = (x2 | x2 << 4) & 252645135;
+                x2 = (x2 | x2 << 2) & 858993459;
+                x2 = (x2 | x2 << 1) & 1431655765;
+                y2 = (y2 | y2 << 8) & 16711935;
+                y2 = (y2 | y2 << 4) & 252645135;
+                y2 = (y2 | y2 << 2) & 858993459;
+                y2 = (y2 | y2 << 1) & 1431655765;
+                return x2 | y2 << 1;
+              }
+              function getLeftmost(start) {
+                var p2 = start, leftmost = start;
+                do {
+                  if (p2.x < leftmost.x || p2.x === leftmost.x && p2.y < leftmost.y) {
+                    leftmost = p2;
+                  }
+                  p2 = p2.next;
+                } while (p2 !== start);
+                return leftmost;
+              }
+              function pointInTriangle(ax, ay, bx, by, cx, cy, px, py) {
+                return (cx - px) * (ay - py) - (ax - px) * (cy - py) >= 0 && (ax - px) * (by - py) - (bx - px) * (ay - py) >= 0 && (bx - px) * (cy - py) - (cx - px) * (by - py) >= 0;
+              }
+              function isValidDiagonal(a2, b2) {
+                return a2.next.i !== b2.i && a2.prev.i !== b2.i && !intersectsPolygon(a2, b2) && (locallyInside(a2, b2) && locallyInside(b2, a2) && middleInside(a2, b2) && (area(a2.prev, a2, b2.prev) || area(a2, b2.prev, b2)) || equals2(a2, b2) && area(a2.prev, a2, a2.next) > 0 && area(b2.prev, b2, b2.next) > 0);
+              }
+              function area(p2, q2, r2) {
+                return (q2.y - p2.y) * (r2.x - q2.x) - (q2.x - p2.x) * (r2.y - q2.y);
+              }
+              function equals2(p1, p2) {
+                return p1.x === p2.x && p1.y === p2.y;
+              }
+              function intersects(p1, q1, p2, q2) {
+                var o1 = sign(area(p1, q1, p2));
+                var o2 = sign(area(p1, q1, q2));
+                var o3 = sign(area(p2, q2, p1));
+                var o4 = sign(area(p2, q2, q1));
+                if (o1 !== o2 && o3 !== o4) {
+                  return true;
+                }
+                if (o1 === 0 && onSegment(p1, p2, q1)) {
+                  return true;
+                }
+                if (o2 === 0 && onSegment(p1, q2, q1)) {
+                  return true;
+                }
+                if (o3 === 0 && onSegment(p2, p1, q2)) {
+                  return true;
+                }
+                if (o4 === 0 && onSegment(p2, q1, q2)) {
+                  return true;
+                }
+                return false;
+              }
+              function onSegment(p2, q2, r2) {
+                return q2.x <= Math.max(p2.x, r2.x) && q2.x >= Math.min(p2.x, r2.x) && q2.y <= Math.max(p2.y, r2.y) && q2.y >= Math.min(p2.y, r2.y);
+              }
+              function sign(num) {
+                return num > 0 ? 1 : num < 0 ? -1 : 0;
+              }
+              function intersectsPolygon(a2, b2) {
+                var p2 = a2;
+                do {
+                  if (p2.i !== a2.i && p2.next.i !== a2.i && p2.i !== b2.i && p2.next.i !== b2.i && intersects(p2, p2.next, a2, b2)) {
+                    return true;
+                  }
+                  p2 = p2.next;
+                } while (p2 !== a2);
+                return false;
+              }
+              function locallyInside(a2, b2) {
+                return area(a2.prev, a2, a2.next) < 0 ? area(a2, b2, a2.next) >= 0 && area(a2, a2.prev, b2) >= 0 : area(a2, b2, a2.prev) < 0 || area(a2, a2.next, b2) < 0;
+              }
+              function middleInside(a2, b2) {
+                var p2 = a2, inside = false, px = (a2.x + b2.x) / 2, py = (a2.y + b2.y) / 2;
+                do {
+                  if (p2.y > py !== p2.next.y > py && p2.next.y !== p2.y && px < (p2.next.x - p2.x) * (py - p2.y) / (p2.next.y - p2.y) + p2.x) {
+                    inside = !inside;
+                  }
+                  p2 = p2.next;
+                } while (p2 !== a2);
+                return inside;
+              }
+              function splitPolygon(a2, b2) {
+                var a22 = new Node(a2.i, a2.x, a2.y), b22 = new Node(b2.i, b2.x, b2.y), an = a2.next, bp = b2.prev;
+                a2.next = b2;
+                b2.prev = a2;
+                a22.next = an;
+                an.prev = a22;
+                b22.next = a22;
+                a22.prev = b22;
+                bp.next = b22;
+                b22.prev = bp;
+                return b22;
+              }
+              function insertNode(i2, x2, y2, last) {
+                var p2 = new Node(i2, x2, y2);
+                if (!last) {
+                  p2.prev = p2;
+                  p2.next = p2;
+                } else {
+                  p2.next = last.next;
+                  p2.prev = last;
+                  last.next.prev = p2;
+                  last.next = p2;
+                }
+                return p2;
+              }
+              function removeNode(p2) {
+                p2.next.prev = p2.prev;
+                p2.prev.next = p2.next;
+                if (p2.prevZ) {
+                  p2.prevZ.nextZ = p2.nextZ;
+                }
+                if (p2.nextZ) {
+                  p2.nextZ.prevZ = p2.prevZ;
+                }
+              }
+              function Node(i2, x2, y2) {
+                this.i = i2;
+                this.x = x2;
+                this.y = y2;
+                this.prev = null;
+                this.next = null;
+                this.z = null;
+                this.prevZ = null;
+                this.nextZ = null;
+                this.steiner = false;
+              }
+              earcut.deviation = function(data, holeIndices, dim, triangles) {
+                var hasHoles = holeIndices && holeIndices.length;
+                var outerLen = hasHoles ? holeIndices[0] * dim : data.length;
+                var polygonArea = Math.abs(signedArea(data, 0, outerLen, dim));
+                if (hasHoles) {
+                  for (var i2 = 0, len2 = holeIndices.length; i2 < len2; i2++) {
+                    var start = holeIndices[i2] * dim;
+                    var end = i2 < len2 - 1 ? holeIndices[i2 + 1] * dim : data.length;
+                    polygonArea -= Math.abs(signedArea(data, start, end, dim));
+                  }
+                }
+                var trianglesArea = 0;
+                for (i2 = 0; i2 < triangles.length; i2 += 3) {
+                  var a2 = triangles[i2] * dim;
+                  var b2 = triangles[i2 + 1] * dim;
+                  var c2 = triangles[i2 + 2] * dim;
+                  trianglesArea += Math.abs((data[a2] - data[c2]) * (data[b2 + 1] - data[a2 + 1]) - (data[a2] - data[b2]) * (data[c2 + 1] - data[a2 + 1]));
+                }
+                return polygonArea === 0 && trianglesArea === 0 ? 0 : Math.abs((trianglesArea - polygonArea) / polygonArea);
+              };
+              function signedArea(data, start, end, dim) {
+                var sum = 0;
+                for (var i2 = start, j2 = end - dim; i2 < end; i2 += dim) {
+                  sum += (data[j2] - data[i2]) * (data[i2 + 1] + data[j2 + 1]);
+                  j2 = i2;
+                }
+                return sum;
+              }
+              earcut.flatten = function(data) {
+                var dim = data[0][0].length, result = {
+                  vertices: [],
+                  holes: [],
+                  dimensions: dim
+                }, holeIndex = 0;
+                for (var i2 = 0; i2 < data.length; i2++) {
+                  for (var j2 = 0; j2 < data[i2].length; j2++) {
+                    for (var d2 = 0; d2 < dim; d2++) {
+                      result.vertices.push(data[i2][j2][d2]);
+                    }
+                  }
+                  if (i2 > 0) {
+                    holeIndex += data[i2 - 1].length;
+                    result.holes.push(holeIndex);
+                  }
+                }
+                return result;
+              };
+              earcut_1.default = default_1;
+              function quickselect(arr, k2, left, right, compare2) {
+                quickselectStep(arr, k2, left, right || arr.length - 1, compare2 || defaultCompare);
+              }
+              function quickselectStep(arr, k2, left, right, compare2) {
+                while (right > left) {
+                  if (right - left > 600) {
+                    var n2 = right - left + 1;
+                    var m2 = k2 - left + 1;
+                    var z2 = Math.log(n2);
+                    var s2 = 0.5 * Math.exp(2 * z2 / 3);
+                    var sd2 = 0.5 * Math.sqrt(z2 * s2 * (n2 - s2) / n2) * (m2 - n2 / 2 < 0 ? -1 : 1);
+                    var newLeft = Math.max(left, Math.floor(k2 - m2 * s2 / n2 + sd2));
+                    var newRight = Math.min(right, Math.floor(k2 + (n2 - m2) * s2 / n2 + sd2));
+                    quickselectStep(arr, k2, newLeft, newRight, compare2);
+                  }
+                  var t4 = arr[k2];
+                  var i2 = left;
+                  var j2 = right;
+                  swap$1(arr, left, k2);
+                  if (compare2(arr[right], t4) > 0) {
+                    swap$1(arr, left, right);
+                  }
+                  while (i2 < j2) {
+                    swap$1(arr, i2, j2);
+                    i2++;
+                    j2--;
+                    while (compare2(arr[i2], t4) < 0) {
+                      i2++;
+                    }
+                    while (compare2(arr[j2], t4) > 0) {
+                      j2--;
+                    }
+                  }
+                  if (compare2(arr[left], t4) === 0) {
+                    swap$1(arr, left, j2);
+                  } else {
+                    j2++;
+                    swap$1(arr, j2, right);
+                  }
+                  if (j2 <= k2) {
+                    left = j2 + 1;
+                  }
+                  if (k2 <= j2) {
+                    right = j2 - 1;
+                  }
+                }
+              }
+              function swap$1(arr, i2, j2) {
+                var tmp2 = arr[i2];
+                arr[i2] = arr[j2];
+                arr[j2] = tmp2;
+              }
+              function defaultCompare(a2, b2) {
+                return a2 < b2 ? -1 : a2 > b2 ? 1 : 0;
+              }
+              function classifyRings(rings, maxRings) {
+                var len2 = rings.length;
+                if (len2 <= 1) {
+                  return [rings];
+                }
+                var polygons = [];
+                var polygon, ccw;
+                for (var i2 = 0; i2 < len2; i2++) {
+                  var area2 = calculateSignedArea(rings[i2]);
+                  if (area2 === 0) {
+                    continue;
+                  }
+                  rings[i2].area = Math.abs(area2);
+                  if (ccw === void 0) {
+                    ccw = area2 < 0;
+                  }
+                  if (ccw === area2 < 0) {
+                    if (polygon) {
+                      polygons.push(polygon);
+                    }
+                    polygon = [rings[i2]];
+                  } else {
+                    polygon.push(rings[i2]);
+                  }
+                }
+                if (polygon) {
+                  polygons.push(polygon);
+                }
+                if (maxRings > 1) {
+                  for (var j2 = 0; j2 < polygons.length; j2++) {
+                    if (polygons[j2].length <= maxRings) {
+                      continue;
+                    }
+                    quickselect(polygons[j2], maxRings, 1, polygons[j2].length - 1, compareAreas);
+                    polygons[j2] = polygons[j2].slice(0, maxRings);
+                  }
+                }
+                return polygons;
+              }
+              function compareAreas(a2, b2) {
+                return b2.area - a2.area;
+              }
+              function hasPattern(type, layers, options) {
+                var patterns = options.patternDependencies;
+                var hasPattern2 = false;
+                for (var i2 = 0, list = layers; i2 < list.length; i2 += 1) {
+                  var layer2 = list[i2];
+                  var patternProperty = layer2.paint.get(type + "-pattern");
+                  if (!patternProperty.isConstant()) {
+                    hasPattern2 = true;
+                  }
+                  var constantPattern = patternProperty.constantOr(null);
+                  if (constantPattern) {
+                    hasPattern2 = true;
+                    patterns[constantPattern.to] = true;
+                    patterns[constantPattern.from] = true;
+                  }
+                }
+                return hasPattern2;
+              }
+              function addPatternDependencies(type, layers, patternFeature, zoom, options) {
+                var patterns = options.patternDependencies;
+                for (var i2 = 0, list = layers; i2 < list.length; i2 += 1) {
+                  var layer2 = list[i2];
+                  var patternProperty = layer2.paint.get(type + "-pattern");
+                  var patternPropertyValue = patternProperty.value;
+                  if (patternPropertyValue.kind !== "constant") {
+                    var min = patternPropertyValue.evaluate({ zoom: zoom - 1 }, patternFeature, {}, options.availableImages);
+                    var mid = patternPropertyValue.evaluate({ zoom }, patternFeature, {}, options.availableImages);
+                    var max = patternPropertyValue.evaluate({ zoom: zoom + 1 }, patternFeature, {}, options.availableImages);
+                    min = min && min.name ? min.name : min;
+                    mid = mid && mid.name ? mid.name : mid;
+                    max = max && max.name ? max.name : max;
+                    patterns[min] = true;
+                    patterns[mid] = true;
+                    patterns[max] = true;
+                    patternFeature.patterns[layer2.id] = {
+                      min,
+                      mid,
+                      max
+                    };
+                  }
+                }
+                return patternFeature;
+              }
+              var EARCUT_MAX_RINGS = 500;
+              var FillBucket = function FillBucket2(options) {
+                this.zoom = options.zoom;
+                this.overscaling = options.overscaling;
+                this.layers = options.layers;
+                this.layerIds = this.layers.map(function(layer2) {
+                  return layer2.id;
+                });
+                this.index = options.index;
+                this.hasPattern = false;
+                this.patternFeatures = [];
+                this.layoutVertexArray = new StructArrayLayout2i4();
+                this.indexArray = new StructArrayLayout3ui6();
+                this.indexArray2 = new StructArrayLayout2ui4();
+                this.programConfigurations = new ProgramConfigurationSet(options.layers, options.zoom);
+                this.segments = new SegmentVector();
+                this.segments2 = new SegmentVector();
+                this.stateDependentLayerIds = this.layers.filter(function(l2) {
+                  return l2.isStateDependent();
+                }).map(function(l2) {
+                  return l2.id;
+                });
+              };
+              FillBucket.prototype.populate = function populate(features, options, canonical) {
+                this.hasPattern = hasPattern("fill", this.layers, options);
+                var fillSortKey = this.layers[0].layout.get("fill-sort-key");
+                var bucketFeatures = [];
+                for (var i2 = 0, list = features; i2 < list.length; i2 += 1) {
+                  var ref = list[i2];
+                  var feature = ref.feature;
+                  var id22 = ref.id;
+                  var index = ref.index;
+                  var sourceLayerIndex = ref.sourceLayerIndex;
+                  var needGeometry = this.layers[0]._featureFilter.needGeometry;
+                  var evaluationFeature = toEvaluationFeature(feature, needGeometry);
+                  if (!this.layers[0]._featureFilter.filter(new EvaluationParameters(this.zoom), evaluationFeature, canonical)) {
+                    continue;
+                  }
+                  var sortKey = fillSortKey ? fillSortKey.evaluate(evaluationFeature, {}, canonical, options.availableImages) : void 0;
+                  var bucketFeature = {
+                    id: id22,
+                    properties: feature.properties,
+                    type: feature.type,
+                    sourceLayerIndex,
+                    index,
+                    geometry: needGeometry ? evaluationFeature.geometry : loadGeometry(feature),
+                    patterns: {},
+                    sortKey
+                  };
+                  bucketFeatures.push(bucketFeature);
+                }
+                if (fillSortKey) {
+                  bucketFeatures.sort(function(a2, b2) {
+                    return a2.sortKey - b2.sortKey;
+                  });
+                }
+                for (var i$1 = 0, list$1 = bucketFeatures; i$1 < list$1.length; i$1 += 1) {
+                  var bucketFeature$1 = list$1[i$1];
+                  var ref$1 = bucketFeature$1;
+                  var geometry2 = ref$1.geometry;
+                  var index$1 = ref$1.index;
+                  var sourceLayerIndex$1 = ref$1.sourceLayerIndex;
+                  if (this.hasPattern) {
+                    var patternFeature = addPatternDependencies("fill", this.layers, bucketFeature$1, this.zoom, options);
+                    this.patternFeatures.push(patternFeature);
+                  } else {
+                    this.addFeature(bucketFeature$1, geometry2, index$1, canonical, {});
+                  }
+                  var feature$1 = features[index$1].feature;
+                  options.featureIndex.insert(feature$1, geometry2, index$1, sourceLayerIndex$1, this.index);
+                }
+              };
+              FillBucket.prototype.update = function update(states, vtLayer, imagePositions) {
+                if (!this.stateDependentLayers.length) {
+                  return;
+                }
+                this.programConfigurations.updatePaintArrays(states, vtLayer, this.stateDependentLayers, imagePositions);
+              };
+              FillBucket.prototype.addFeatures = function addFeatures(options, canonical, imagePositions) {
+                for (var i2 = 0, list = this.patternFeatures; i2 < list.length; i2 += 1) {
+                  var feature = list[i2];
+                  this.addFeature(feature, feature.geometry, feature.index, canonical, imagePositions);
+                }
+              };
+              FillBucket.prototype.isEmpty = function isEmpty2() {
+                return this.layoutVertexArray.length === 0;
+              };
+              FillBucket.prototype.uploadPending = function uploadPending() {
+                return !this.uploaded || this.programConfigurations.needsUpload;
+              };
+              FillBucket.prototype.upload = function upload(context) {
+                if (!this.uploaded) {
+                  this.layoutVertexBuffer = context.createVertexBuffer(this.layoutVertexArray, members$1);
+                  this.indexBuffer = context.createIndexBuffer(this.indexArray);
+                  this.indexBuffer2 = context.createIndexBuffer(this.indexArray2);
+                }
+                this.programConfigurations.upload(context);
+                this.uploaded = true;
+              };
+              FillBucket.prototype.destroy = function destroy() {
+                if (!this.layoutVertexBuffer) {
+                  return;
+                }
+                this.layoutVertexBuffer.destroy();
+                this.indexBuffer.destroy();
+                this.indexBuffer2.destroy();
+                this.programConfigurations.destroy();
+                this.segments.destroy();
+                this.segments2.destroy();
+              };
+              FillBucket.prototype.addFeature = function addFeature2(feature, geometry2, index, canonical, imagePositions) {
+                for (var i$4 = 0, list$2 = classifyRings(geometry2, EARCUT_MAX_RINGS); i$4 < list$2.length; i$4 += 1) {
+                  var polygon = list$2[i$4];
+                  var numVertices = 0;
+                  for (var i$2 = 0, list = polygon; i$2 < list.length; i$2 += 1) {
+                    var ring = list[i$2];
+                    numVertices += ring.length;
+                  }
+                  var triangleSegment = this.segments.prepareSegment(numVertices, this.layoutVertexArray, this.indexArray);
+                  var triangleIndex = triangleSegment.vertexLength;
+                  var flattened = [];
+                  var holeIndices = [];
+                  for (var i$3 = 0, list$1 = polygon; i$3 < list$1.length; i$3 += 1) {
+                    var ring$1 = list$1[i$3];
+                    if (ring$1.length === 0) {
+                      continue;
+                    }
+                    if (ring$1 !== polygon[0]) {
+                      holeIndices.push(flattened.length / 2);
+                    }
+                    var lineSegment = this.segments2.prepareSegment(ring$1.length, this.layoutVertexArray, this.indexArray2);
+                    var lineIndex = lineSegment.vertexLength;
+                    this.layoutVertexArray.emplaceBack(ring$1[0].x, ring$1[0].y);
+                    this.indexArray2.emplaceBack(lineIndex + ring$1.length - 1, lineIndex);
+                    flattened.push(ring$1[0].x);
+                    flattened.push(ring$1[0].y);
+                    for (var i2 = 1; i2 < ring$1.length; i2++) {
+                      this.layoutVertexArray.emplaceBack(ring$1[i2].x, ring$1[i2].y);
+                      this.indexArray2.emplaceBack(lineIndex + i2 - 1, lineIndex + i2);
+                      flattened.push(ring$1[i2].x);
+                      flattened.push(ring$1[i2].y);
+                    }
+                    lineSegment.vertexLength += ring$1.length;
+                    lineSegment.primitiveLength += ring$1.length;
+                  }
+                  var indices = earcut_1(flattened, holeIndices);
+                  for (var i$1 = 0; i$1 < indices.length; i$1 += 3) {
+                    this.indexArray.emplaceBack(triangleIndex + indices[i$1], triangleIndex + indices[i$1 + 1], triangleIndex + indices[i$1 + 2]);
+                  }
+                  triangleSegment.vertexLength += numVertices;
+                  triangleSegment.primitiveLength += indices.length / 3;
+                }
+                this.programConfigurations.populatePaintArrays(this.layoutVertexArray.length, feature, index, imagePositions, canonical);
+              };
+              register2("FillBucket", FillBucket, {
+                omit: [
+                  "layers",
+                  "patternFeatures"
+                ]
+              });
+              var layout$4 = new Properties({ "fill-sort-key": new DataDrivenProperty(spec["layout_fill"]["fill-sort-key"]) });
+              var paint$4 = new Properties({
+                "fill-antialias": new DataConstantProperty(spec["paint_fill"]["fill-antialias"]),
+                "fill-opacity": new DataDrivenProperty(spec["paint_fill"]["fill-opacity"]),
+                "fill-color": new DataDrivenProperty(spec["paint_fill"]["fill-color"]),
+                "fill-outline-color": new DataDrivenProperty(spec["paint_fill"]["fill-outline-color"]),
+                "fill-translate": new DataConstantProperty(spec["paint_fill"]["fill-translate"]),
+                "fill-translate-anchor": new DataConstantProperty(spec["paint_fill"]["fill-translate-anchor"]),
+                "fill-pattern": new CrossFadedDataDrivenProperty(spec["paint_fill"]["fill-pattern"])
+              });
+              var properties$3 = {
+                paint: paint$4,
+                layout: layout$4
+              };
+              var FillStyleLayer = function(StyleLayer2) {
+                function FillStyleLayer2(layer2) {
+                  StyleLayer2.call(this, layer2, properties$3);
+                }
+                if (StyleLayer2)
+                  FillStyleLayer2.__proto__ = StyleLayer2;
+                FillStyleLayer2.prototype = Object.create(StyleLayer2 && StyleLayer2.prototype);
+                FillStyleLayer2.prototype.constructor = FillStyleLayer2;
+                FillStyleLayer2.prototype.recalculate = function recalculate(parameters, availableImages) {
+                  StyleLayer2.prototype.recalculate.call(this, parameters, availableImages);
+                  var outlineColor = this.paint._values["fill-outline-color"];
+                  if (outlineColor.value.kind === "constant" && outlineColor.value.value === void 0) {
+                    this.paint._values["fill-outline-color"] = this.paint._values["fill-color"];
+                  }
+                };
+                FillStyleLayer2.prototype.createBucket = function createBucket(parameters) {
+                  return new FillBucket(parameters);
+                };
+                FillStyleLayer2.prototype.queryRadius = function queryRadius() {
+                  return translateDistance(this.paint.get("fill-translate"));
+                };
+                FillStyleLayer2.prototype.queryIntersectsFeature = function queryIntersectsFeature(queryGeometry, feature, featureState, geometry2, zoom, transform, pixelsToTileUnits) {
+                  var translatedPolygon = translate2(queryGeometry, this.paint.get("fill-translate"), this.paint.get("fill-translate-anchor"), transform.angle, pixelsToTileUnits);
+                  return polygonIntersectsMultiPolygon(translatedPolygon, geometry2);
+                };
+                FillStyleLayer2.prototype.isTileClipped = function isTileClipped() {
+                  return true;
+                };
+                return FillStyleLayer2;
+              }(StyleLayer);
+              var layout$5 = createLayout([
+                {
+                  name: "a_pos",
+                  components: 2,
+                  type: "Int16"
+                },
+                {
+                  name: "a_normal_ed",
+                  components: 4,
+                  type: "Int16"
+                }
+              ], 4);
+              var members$2 = layout$5.members;
+              var vectortilefeature = VectorTileFeature;
+              function VectorTileFeature(pbf2, end, extent, keys, values2) {
+                this.properties = {};
+                this.extent = extent;
+                this.type = 0;
+                this._pbf = pbf2;
+                this._geometry = -1;
+                this._keys = keys;
+                this._values = values2;
+                pbf2.readFields(readFeature, this, end);
+              }
+              function readFeature(tag, feature, pbf2) {
+                if (tag == 1) {
+                  feature.id = pbf2.readVarint();
+                } else if (tag == 2) {
+                  readTag(pbf2, feature);
+                } else if (tag == 3) {
+                  feature.type = pbf2.readVarint();
+                } else if (tag == 4) {
+                  feature._geometry = pbf2.pos;
+                }
+              }
+              function readTag(pbf2, feature) {
+                var end = pbf2.readVarint() + pbf2.pos;
+                while (pbf2.pos < end) {
+                  var key = feature._keys[pbf2.readVarint()], value = feature._values[pbf2.readVarint()];
+                  feature.properties[key] = value;
+                }
+              }
+              VectorTileFeature.types = [
+                "Unknown",
+                "Point",
+                "LineString",
+                "Polygon"
+              ];
+              VectorTileFeature.prototype.loadGeometry = function() {
+                var pbf2 = this._pbf;
+                pbf2.pos = this._geometry;
+                var end = pbf2.readVarint() + pbf2.pos, cmd = 1, length2 = 0, x2 = 0, y2 = 0, lines = [], line;
+                while (pbf2.pos < end) {
+                  if (length2 <= 0) {
+                    var cmdLen = pbf2.readVarint();
+                    cmd = cmdLen & 7;
+                    length2 = cmdLen >> 3;
+                  }
+                  length2--;
+                  if (cmd === 1 || cmd === 2) {
+                    x2 += pbf2.readSVarint();
+                    y2 += pbf2.readSVarint();
+                    if (cmd === 1) {
+                      if (line) {
+                        lines.push(line);
+                      }
+                      line = [];
+                    }
+                    line.push(new pointGeometry(x2, y2));
+                  } else if (cmd === 7) {
+                    if (line) {
+                      line.push(line[0].clone());
+                    }
+                  } else {
+                    throw new Error("unknown command " + cmd);
+                  }
+                }
+                if (line) {
+                  lines.push(line);
+                }
+                return lines;
+              };
+              VectorTileFeature.prototype.bbox = function() {
+                var pbf2 = this._pbf;
+                pbf2.pos = this._geometry;
+                var end = pbf2.readVarint() + pbf2.pos, cmd = 1, length2 = 0, x2 = 0, y2 = 0, x1 = Infinity, x22 = -Infinity, y1 = Infinity, y22 = -Infinity;
+                while (pbf2.pos < end) {
+                  if (length2 <= 0) {
+                    var cmdLen = pbf2.readVarint();
+                    cmd = cmdLen & 7;
+                    length2 = cmdLen >> 3;
+                  }
+                  length2--;
+                  if (cmd === 1 || cmd === 2) {
+                    x2 += pbf2.readSVarint();
+                    y2 += pbf2.readSVarint();
+                    if (x2 < x1) {
+                      x1 = x2;
+                    }
+                    if (x2 > x22) {
+                      x22 = x2;
+                    }
+                    if (y2 < y1) {
+                      y1 = y2;
+                    }
+                    if (y2 > y22) {
+                      y22 = y2;
+                    }
+                  } else if (cmd !== 7) {
+                    throw new Error("unknown command " + cmd);
+                  }
+                }
+                return [
+                  x1,
+                  y1,
+                  x22,
+                  y22
+                ];
+              };
+              VectorTileFeature.prototype.toGeoJSON = function(x2, y2, z2) {
+                var size = this.extent * Math.pow(2, z2), x0 = this.extent * x2, y0 = this.extent * y2, coords = this.loadGeometry(), type = VectorTileFeature.types[this.type], i2, j2;
+                function project2(line) {
+                  for (var j22 = 0; j22 < line.length; j22++) {
+                    var p2 = line[j22], y22 = 180 - (p2.y + y0) * 360 / size;
+                    line[j22] = [
+                      (p2.x + x0) * 360 / size - 180,
+                      360 / Math.PI * Math.atan(Math.exp(y22 * Math.PI / 180)) - 90
+                    ];
+                  }
+                }
+                switch (this.type) {
+                  case 1:
+                    var points = [];
+                    for (i2 = 0; i2 < coords.length; i2++) {
+                      points[i2] = coords[i2][0];
+                    }
+                    coords = points;
+                    project2(coords);
+                    break;
+                  case 2:
+                    for (i2 = 0; i2 < coords.length; i2++) {
+                      project2(coords[i2]);
+                    }
+                    break;
+                  case 3:
+                    coords = classifyRings$1(coords);
+                    for (i2 = 0; i2 < coords.length; i2++) {
+                      for (j2 = 0; j2 < coords[i2].length; j2++) {
+                        project2(coords[i2][j2]);
+                      }
+                    }
+                    break;
+                }
+                if (coords.length === 1) {
+                  coords = coords[0];
+                } else {
+                  type = "Multi" + type;
+                }
+                var result = {
+                  type: "Feature",
+                  geometry: {
+                    type,
+                    coordinates: coords
+                  },
+                  properties: this.properties
+                };
+                if ("id" in this) {
+                  result.id = this.id;
+                }
+                return result;
+              };
+              function classifyRings$1(rings) {
+                var len2 = rings.length;
+                if (len2 <= 1) {
+                  return [rings];
+                }
+                var polygons = [], polygon, ccw;
+                for (var i2 = 0; i2 < len2; i2++) {
+                  var area2 = signedArea$1(rings[i2]);
+                  if (area2 === 0) {
+                    continue;
+                  }
+                  if (ccw === void 0) {
+                    ccw = area2 < 0;
+                  }
+                  if (ccw === area2 < 0) {
+                    if (polygon) {
+                      polygons.push(polygon);
+                    }
+                    polygon = [rings[i2]];
+                  } else {
+                    polygon.push(rings[i2]);
+                  }
+                }
+                if (polygon) {
+                  polygons.push(polygon);
+                }
+                return polygons;
+              }
+              function signedArea$1(ring) {
+                var sum = 0;
+                for (var i2 = 0, len2 = ring.length, j2 = len2 - 1, p1, p2; i2 < len2; j2 = i2++) {
+                  p1 = ring[i2];
+                  p2 = ring[j2];
+                  sum += (p2.x - p1.x) * (p1.y + p2.y);
+                }
+                return sum;
+              }
+              var vectortilelayer = VectorTileLayer;
+              function VectorTileLayer(pbf2, end) {
+                this.version = 1;
+                this.name = null;
+                this.extent = 4096;
+                this.length = 0;
+                this._pbf = pbf2;
+                this._keys = [];
+                this._values = [];
+                this._features = [];
+                pbf2.readFields(readLayer, this, end);
+                this.length = this._features.length;
+              }
+              function readLayer(tag, layer2, pbf2) {
+                if (tag === 15) {
+                  layer2.version = pbf2.readVarint();
+                } else if (tag === 1) {
+                  layer2.name = pbf2.readString();
+                } else if (tag === 5) {
+                  layer2.extent = pbf2.readVarint();
+                } else if (tag === 2) {
+                  layer2._features.push(pbf2.pos);
+                } else if (tag === 3) {
+                  layer2._keys.push(pbf2.readString());
+                } else if (tag === 4) {
+                  layer2._values.push(readValueMessage(pbf2));
+                }
+              }
+              function readValueMessage(pbf2) {
+                var value = null, end = pbf2.readVarint() + pbf2.pos;
+                while (pbf2.pos < end) {
+                  var tag = pbf2.readVarint() >> 3;
+                  value = tag === 1 ? pbf2.readString() : tag === 2 ? pbf2.readFloat() : tag === 3 ? pbf2.readDouble() : tag === 4 ? pbf2.readVarint64() : tag === 5 ? pbf2.readVarint() : tag === 6 ? pbf2.readSVarint() : tag === 7 ? pbf2.readBoolean() : null;
+                }
+                return value;
+              }
+              VectorTileLayer.prototype.feature = function(i2) {
+                if (i2 < 0 || i2 >= this._features.length) {
+                  throw new Error("feature index out of bounds");
+                }
+                this._pbf.pos = this._features[i2];
+                var end = this._pbf.readVarint() + this._pbf.pos;
+                return new vectortilefeature(this._pbf, end, this.extent, this._keys, this._values);
+              };
+              var vectortile = VectorTile;
+              function VectorTile(pbf2, end) {
+                this.layers = pbf2.readFields(readTile, {}, end);
+              }
+              function readTile(tag, layers, pbf2) {
+                if (tag === 3) {
+                  var layer2 = new vectortilelayer(pbf2, pbf2.readVarint() + pbf2.pos);
+                  if (layer2.length) {
+                    layers[layer2.name] = layer2;
+                  }
+                }
+              }
+              var VectorTile$1 = vectortile;
+              var VectorTileFeature$1 = vectortilefeature;
+              var VectorTileLayer$1 = vectortilelayer;
+              var vectorTile = {
+                VectorTile: VectorTile$1,
+                VectorTileFeature: VectorTileFeature$1,
+                VectorTileLayer: VectorTileLayer$1
+              };
+              var vectorTileFeatureTypes = vectorTile.VectorTileFeature.types;
+              var EARCUT_MAX_RINGS$1 = 500;
+              var FACTOR = Math.pow(2, 13);
+              function addVertex(vertexArray, x2, y2, nx, ny, nz, t4, e2) {
+                vertexArray.emplaceBack(x2, y2, Math.floor(nx * FACTOR) * 2 + t4, ny * FACTOR * 2, nz * FACTOR * 2, Math.round(e2));
+              }
+              var FillExtrusionBucket = function FillExtrusionBucket2(options) {
+                this.zoom = options.zoom;
+                this.overscaling = options.overscaling;
+                this.layers = options.layers;
+                this.layerIds = this.layers.map(function(layer2) {
+                  return layer2.id;
+                });
+                this.index = options.index;
+                this.hasPattern = false;
+                this.layoutVertexArray = new StructArrayLayout2i4i12();
+                this.indexArray = new StructArrayLayout3ui6();
+                this.programConfigurations = new ProgramConfigurationSet(options.layers, options.zoom);
+                this.segments = new SegmentVector();
+                this.stateDependentLayerIds = this.layers.filter(function(l2) {
+                  return l2.isStateDependent();
+                }).map(function(l2) {
+                  return l2.id;
+                });
+              };
+              FillExtrusionBucket.prototype.populate = function populate(features, options, canonical) {
+                this.features = [];
+                this.hasPattern = hasPattern("fill-extrusion", this.layers, options);
+                for (var i2 = 0, list = features; i2 < list.length; i2 += 1) {
+                  var ref = list[i2];
+                  var feature = ref.feature;
+                  var id22 = ref.id;
+                  var index = ref.index;
+                  var sourceLayerIndex = ref.sourceLayerIndex;
+                  var needGeometry = this.layers[0]._featureFilter.needGeometry;
+                  var evaluationFeature = toEvaluationFeature(feature, needGeometry);
+                  if (!this.layers[0]._featureFilter.filter(new EvaluationParameters(this.zoom), evaluationFeature, canonical)) {
+                    continue;
+                  }
+                  var bucketFeature = {
+                    id: id22,
+                    sourceLayerIndex,
+                    index,
+                    geometry: needGeometry ? evaluationFeature.geometry : loadGeometry(feature),
+                    properties: feature.properties,
+                    type: feature.type,
+                    patterns: {}
+                  };
+                  if (this.hasPattern) {
+                    this.features.push(addPatternDependencies("fill-extrusion", this.layers, bucketFeature, this.zoom, options));
+                  } else {
+                    this.addFeature(bucketFeature, bucketFeature.geometry, index, canonical, {});
+                  }
+                  options.featureIndex.insert(feature, bucketFeature.geometry, index, sourceLayerIndex, this.index, true);
+                }
+              };
+              FillExtrusionBucket.prototype.addFeatures = function addFeatures(options, canonical, imagePositions) {
+                for (var i2 = 0, list = this.features; i2 < list.length; i2 += 1) {
+                  var feature = list[i2];
+                  var geometry2 = feature.geometry;
+                  this.addFeature(feature, geometry2, feature.index, canonical, imagePositions);
+                }
+              };
+              FillExtrusionBucket.prototype.update = function update(states, vtLayer, imagePositions) {
+                if (!this.stateDependentLayers.length) {
+                  return;
+                }
+                this.programConfigurations.updatePaintArrays(states, vtLayer, this.stateDependentLayers, imagePositions);
+              };
+              FillExtrusionBucket.prototype.isEmpty = function isEmpty2() {
+                return this.layoutVertexArray.length === 0;
+              };
+              FillExtrusionBucket.prototype.uploadPending = function uploadPending() {
+                return !this.uploaded || this.programConfigurations.needsUpload;
+              };
+              FillExtrusionBucket.prototype.upload = function upload(context) {
+                if (!this.uploaded) {
+                  this.layoutVertexBuffer = context.createVertexBuffer(this.layoutVertexArray, members$2);
+                  this.indexBuffer = context.createIndexBuffer(this.indexArray);
+                }
+                this.programConfigurations.upload(context);
+                this.uploaded = true;
+              };
+              FillExtrusionBucket.prototype.destroy = function destroy() {
+                if (!this.layoutVertexBuffer) {
+                  return;
+                }
+                this.layoutVertexBuffer.destroy();
+                this.indexBuffer.destroy();
+                this.programConfigurations.destroy();
+                this.segments.destroy();
+              };
+              FillExtrusionBucket.prototype.addFeature = function addFeature2(feature, geometry2, index, canonical, imagePositions) {
+                for (var i$4 = 0, list$3 = classifyRings(geometry2, EARCUT_MAX_RINGS$1); i$4 < list$3.length; i$4 += 1) {
+                  var polygon = list$3[i$4];
+                  var numVertices = 0;
+                  for (var i$1 = 0, list = polygon; i$1 < list.length; i$1 += 1) {
+                    var ring = list[i$1];
+                    numVertices += ring.length;
+                  }
+                  var segment = this.segments.prepareSegment(4, this.layoutVertexArray, this.indexArray);
+                  for (var i$2 = 0, list$1 = polygon; i$2 < list$1.length; i$2 += 1) {
+                    var ring$1 = list$1[i$2];
+                    if (ring$1.length === 0) {
+                      continue;
+                    }
+                    if (isEntirelyOutside(ring$1)) {
+                      continue;
+                    }
+                    var edgeDistance = 0;
+                    for (var p2 = 0; p2 < ring$1.length; p2++) {
+                      var p1 = ring$1[p2];
+                      if (p2 >= 1) {
+                        var p22 = ring$1[p2 - 1];
+                        if (!isBoundaryEdge(p1, p22)) {
+                          if (segment.vertexLength + 4 > SegmentVector.MAX_VERTEX_ARRAY_LENGTH) {
+                            segment = this.segments.prepareSegment(4, this.layoutVertexArray, this.indexArray);
+                          }
+                          var perp2 = p1.sub(p22)._perp()._unit();
+                          var dist = p22.dist(p1);
+                          if (edgeDistance + dist > 32768) {
+                            edgeDistance = 0;
+                          }
+                          addVertex(this.layoutVertexArray, p1.x, p1.y, perp2.x, perp2.y, 0, 0, edgeDistance);
+                          addVertex(this.layoutVertexArray, p1.x, p1.y, perp2.x, perp2.y, 0, 1, edgeDistance);
+                          edgeDistance += dist;
+                          addVertex(this.layoutVertexArray, p22.x, p22.y, perp2.x, perp2.y, 0, 0, edgeDistance);
+                          addVertex(this.layoutVertexArray, p22.x, p22.y, perp2.x, perp2.y, 0, 1, edgeDistance);
+                          var bottomRight = segment.vertexLength;
+                          this.indexArray.emplaceBack(bottomRight, bottomRight + 2, bottomRight + 1);
+                          this.indexArray.emplaceBack(bottomRight + 1, bottomRight + 2, bottomRight + 3);
+                          segment.vertexLength += 4;
+                          segment.primitiveLength += 2;
+                        }
+                      }
+                    }
+                  }
+                  if (segment.vertexLength + numVertices > SegmentVector.MAX_VERTEX_ARRAY_LENGTH) {
+                    segment = this.segments.prepareSegment(numVertices, this.layoutVertexArray, this.indexArray);
+                  }
+                  if (vectorTileFeatureTypes[feature.type] !== "Polygon") {
+                    continue;
+                  }
+                  var flattened = [];
+                  var holeIndices = [];
+                  var triangleIndex = segment.vertexLength;
+                  for (var i$3 = 0, list$2 = polygon; i$3 < list$2.length; i$3 += 1) {
+                    var ring$2 = list$2[i$3];
+                    if (ring$2.length === 0) {
+                      continue;
+                    }
+                    if (ring$2 !== polygon[0]) {
+                      holeIndices.push(flattened.length / 2);
+                    }
+                    for (var i2 = 0; i2 < ring$2.length; i2++) {
+                      var p$12 = ring$2[i2];
+                      addVertex(this.layoutVertexArray, p$12.x, p$12.y, 0, 0, 1, 1, 0);
+                      flattened.push(p$12.x);
+                      flattened.push(p$12.y);
+                    }
+                  }
+                  var indices = earcut_1(flattened, holeIndices);
+                  for (var j2 = 0; j2 < indices.length; j2 += 3) {
+                    this.indexArray.emplaceBack(triangleIndex + indices[j2], triangleIndex + indices[j2 + 2], triangleIndex + indices[j2 + 1]);
+                  }
+                  segment.primitiveLength += indices.length / 3;
+                  segment.vertexLength += numVertices;
+                }
+                this.programConfigurations.populatePaintArrays(this.layoutVertexArray.length, feature, index, imagePositions, canonical);
+              };
+              register2("FillExtrusionBucket", FillExtrusionBucket, {
+                omit: [
+                  "layers",
+                  "features"
+                ]
+              });
+              function isBoundaryEdge(p1, p2) {
+                return p1.x === p2.x && (p1.x < 0 || p1.x > EXTENT$1) || p1.y === p2.y && (p1.y < 0 || p1.y > EXTENT$1);
+              }
+              function isEntirelyOutside(ring) {
+                return ring.every(function(p2) {
+                  return p2.x < 0;
+                }) || ring.every(function(p2) {
+                  return p2.x > EXTENT$1;
+                }) || ring.every(function(p2) {
+                  return p2.y < 0;
+                }) || ring.every(function(p2) {
+                  return p2.y > EXTENT$1;
+                });
+              }
+              var paint$5 = new Properties({
+                "fill-extrusion-opacity": new DataConstantProperty(spec["paint_fill-extrusion"]["fill-extrusion-opacity"]),
+                "fill-extrusion-color": new DataDrivenProperty(spec["paint_fill-extrusion"]["fill-extrusion-color"]),
+                "fill-extrusion-translate": new DataConstantProperty(spec["paint_fill-extrusion"]["fill-extrusion-translate"]),
+                "fill-extrusion-translate-anchor": new DataConstantProperty(spec["paint_fill-extrusion"]["fill-extrusion-translate-anchor"]),
+                "fill-extrusion-pattern": new CrossFadedDataDrivenProperty(spec["paint_fill-extrusion"]["fill-extrusion-pattern"]),
+                "fill-extrusion-height": new DataDrivenProperty(spec["paint_fill-extrusion"]["fill-extrusion-height"]),
+                "fill-extrusion-base": new DataDrivenProperty(spec["paint_fill-extrusion"]["fill-extrusion-base"]),
+                "fill-extrusion-vertical-gradient": new DataConstantProperty(spec["paint_fill-extrusion"]["fill-extrusion-vertical-gradient"])
+              });
+              var properties$4 = { paint: paint$5 };
+              var FillExtrusionStyleLayer = function(StyleLayer2) {
+                function FillExtrusionStyleLayer2(layer2) {
+                  StyleLayer2.call(this, layer2, properties$4);
+                }
+                if (StyleLayer2)
+                  FillExtrusionStyleLayer2.__proto__ = StyleLayer2;
+                FillExtrusionStyleLayer2.prototype = Object.create(StyleLayer2 && StyleLayer2.prototype);
+                FillExtrusionStyleLayer2.prototype.constructor = FillExtrusionStyleLayer2;
+                FillExtrusionStyleLayer2.prototype.createBucket = function createBucket(parameters) {
+                  return new FillExtrusionBucket(parameters);
+                };
+                FillExtrusionStyleLayer2.prototype.queryRadius = function queryRadius() {
+                  return translateDistance(this.paint.get("fill-extrusion-translate"));
+                };
+                FillExtrusionStyleLayer2.prototype.is3D = function is3D() {
+                  return true;
+                };
+                FillExtrusionStyleLayer2.prototype.queryIntersectsFeature = function queryIntersectsFeature(queryGeometry, feature, featureState, geometry2, zoom, transform, pixelsToTileUnits, pixelPosMatrix) {
+                  var translatedPolygon = translate2(queryGeometry, this.paint.get("fill-extrusion-translate"), this.paint.get("fill-extrusion-translate-anchor"), transform.angle, pixelsToTileUnits);
+                  var height = this.paint.get("fill-extrusion-height").evaluate(feature, featureState);
+                  var base = this.paint.get("fill-extrusion-base").evaluate(feature, featureState);
+                  var projectedQueryGeometry = projectQueryGeometry$1(translatedPolygon, pixelPosMatrix, transform, 0);
+                  var projected = projectExtrusion(geometry2, base, height, pixelPosMatrix);
+                  var projectedBase = projected[0];
+                  var projectedTop = projected[1];
+                  return checkIntersection(projectedBase, projectedTop, projectedQueryGeometry);
+                };
+                return FillExtrusionStyleLayer2;
+              }(StyleLayer);
+              function dot$2(a2, b2) {
+                return a2.x * b2.x + a2.y * b2.y;
+              }
+              function getIntersectionDistance(projectedQueryGeometry, projectedFace) {
+                if (projectedQueryGeometry.length === 1) {
+                  var i2 = 0;
+                  var a2 = projectedFace[i2++];
+                  var b2;
+                  while (!b2 || a2.equals(b2)) {
+                    b2 = projectedFace[i2++];
+                    if (!b2) {
+                      return Infinity;
+                    }
+                  }
+                  for (; i2 < projectedFace.length; i2++) {
+                    var c2 = projectedFace[i2];
+                    var p2 = projectedQueryGeometry[0];
+                    var ab2 = b2.sub(a2);
+                    var ac2 = c2.sub(a2);
+                    var ap = p2.sub(a2);
+                    var dotABAB = dot$2(ab2, ab2);
+                    var dotABAC = dot$2(ab2, ac2);
+                    var dotACAC = dot$2(ac2, ac2);
+                    var dotAPAB = dot$2(ap, ab2);
+                    var dotAPAC = dot$2(ap, ac2);
+                    var denom = dotABAB * dotACAC - dotABAC * dotABAC;
+                    var v2 = (dotACAC * dotAPAB - dotABAC * dotAPAC) / denom;
+                    var w2 = (dotABAB * dotAPAC - dotABAC * dotAPAB) / denom;
+                    var u2 = 1 - v2 - w2;
+                    var distance2 = a2.z * u2 + b2.z * v2 + c2.z * w2;
+                    if (isFinite(distance2)) {
+                      return distance2;
+                    }
+                  }
+                  return Infinity;
+                } else {
+                  var closestDistance = Infinity;
+                  for (var i$1 = 0, list = projectedFace; i$1 < list.length; i$1 += 1) {
+                    var p$12 = list[i$1];
+                    closestDistance = Math.min(closestDistance, p$12.z);
+                  }
+                  return closestDistance;
+                }
+              }
+              function checkIntersection(projectedBase, projectedTop, projectedQueryGeometry) {
+                var closestDistance = Infinity;
+                if (polygonIntersectsMultiPolygon(projectedQueryGeometry, projectedTop)) {
+                  closestDistance = getIntersectionDistance(projectedQueryGeometry, projectedTop[0]);
+                }
+                for (var r2 = 0; r2 < projectedTop.length; r2++) {
+                  var ringTop = projectedTop[r2];
+                  var ringBase = projectedBase[r2];
+                  for (var p2 = 0; p2 < ringTop.length - 1; p2++) {
+                    var topA = ringTop[p2];
+                    var topB = ringTop[p2 + 1];
+                    var baseA = ringBase[p2];
+                    var baseB = ringBase[p2 + 1];
+                    var face = [
+                      topA,
+                      topB,
+                      baseB,
+                      baseA,
+                      topA
+                    ];
+                    if (polygonIntersectsPolygon(projectedQueryGeometry, face)) {
+                      closestDistance = Math.min(closestDistance, getIntersectionDistance(projectedQueryGeometry, face));
+                    }
+                  }
+                }
+                return closestDistance === Infinity ? false : closestDistance;
+              }
+              function projectExtrusion(geometry2, zBase, zTop, m2) {
+                var projectedBase = [];
+                var projectedTop = [];
+                var baseXZ = m2[8] * zBase;
+                var baseYZ = m2[9] * zBase;
+                var baseZZ = m2[10] * zBase;
+                var baseWZ = m2[11] * zBase;
+                var topXZ = m2[8] * zTop;
+                var topYZ = m2[9] * zTop;
+                var topZZ = m2[10] * zTop;
+                var topWZ = m2[11] * zTop;
+                for (var i$1 = 0, list$1 = geometry2; i$1 < list$1.length; i$1 += 1) {
+                  var r2 = list$1[i$1];
+                  var ringBase = [];
+                  var ringTop = [];
+                  for (var i2 = 0, list = r2; i2 < list.length; i2 += 1) {
+                    var p2 = list[i2];
+                    var x2 = p2.x;
+                    var y2 = p2.y;
+                    var sX = m2[0] * x2 + m2[4] * y2 + m2[12];
+                    var sY = m2[1] * x2 + m2[5] * y2 + m2[13];
+                    var sZ = m2[2] * x2 + m2[6] * y2 + m2[14];
+                    var sW = m2[3] * x2 + m2[7] * y2 + m2[15];
+                    var baseX = sX + baseXZ;
+                    var baseY = sY + baseYZ;
+                    var baseZ = sZ + baseZZ;
+                    var baseW = sW + baseWZ;
+                    var topX = sX + topXZ;
+                    var topY = sY + topYZ;
+                    var topZ = sZ + topZZ;
+                    var topW = sW + topWZ;
+                    var b2 = new pointGeometry(baseX / baseW, baseY / baseW);
+                    b2.z = baseZ / baseW;
+                    ringBase.push(b2);
+                    var t4 = new pointGeometry(topX / topW, topY / topW);
+                    t4.z = topZ / topW;
+                    ringTop.push(t4);
+                  }
+                  projectedBase.push(ringBase);
+                  projectedTop.push(ringTop);
+                }
+                return [
+                  projectedBase,
+                  projectedTop
+                ];
+              }
+              function projectQueryGeometry$1(queryGeometry, pixelPosMatrix, transform, z2) {
+                var projectedQueryGeometry = [];
+                for (var i2 = 0, list = queryGeometry; i2 < list.length; i2 += 1) {
+                  var p2 = list[i2];
+                  var v2 = [
+                    p2.x,
+                    p2.y,
+                    z2,
+                    1
+                  ];
+                  transformMat42(v2, v2, pixelPosMatrix);
+                  projectedQueryGeometry.push(new pointGeometry(v2[0] / v2[3], v2[1] / v2[3]));
+                }
+                return projectedQueryGeometry;
+              }
+              var lineLayoutAttributes = createLayout([
+                {
+                  name: "a_pos_normal",
+                  components: 2,
+                  type: "Int16"
+                },
+                {
+                  name: "a_data",
+                  components: 4,
+                  type: "Uint8"
+                }
+              ], 4);
+              var members$3 = lineLayoutAttributes.members;
+              var lineLayoutAttributesExt = createLayout([
+                {
+                  name: "a_uv_x",
+                  components: 1,
+                  type: "Float32"
+                },
+                {
+                  name: "a_split_index",
+                  components: 1,
+                  type: "Float32"
+                }
+              ]);
+              var members$4 = lineLayoutAttributesExt.members;
+              var vectorTileFeatureTypes$1 = vectorTile.VectorTileFeature.types;
+              var EXTRUDE_SCALE = 63;
+              var COS_HALF_SHARP_CORNER = Math.cos(75 / 2 * (Math.PI / 180));
+              var SHARP_CORNER_OFFSET = 15;
+              var DEG_PER_TRIANGLE = 20;
+              var LINE_DISTANCE_BUFFER_BITS = 15;
+              var LINE_DISTANCE_SCALE = 1 / 2;
+              var MAX_LINE_DISTANCE = Math.pow(2, LINE_DISTANCE_BUFFER_BITS - 1) / LINE_DISTANCE_SCALE;
+              var LineBucket = function LineBucket2(options) {
+                var this$1$1 = this;
+                this.zoom = options.zoom;
+                this.overscaling = options.overscaling;
+                this.layers = options.layers;
+                this.layerIds = this.layers.map(function(layer2) {
+                  return layer2.id;
+                });
+                this.index = options.index;
+                this.hasPattern = false;
+                this.patternFeatures = [];
+                this.lineClipsArray = [];
+                this.gradients = {};
+                this.layers.forEach(function(layer2) {
+                  this$1$1.gradients[layer2.id] = {};
+                });
+                this.layoutVertexArray = new StructArrayLayout2i4ub8();
+                this.layoutVertexArray2 = new StructArrayLayout2f8();
+                this.indexArray = new StructArrayLayout3ui6();
+                this.programConfigurations = new ProgramConfigurationSet(options.layers, options.zoom);
+                this.segments = new SegmentVector();
+                this.maxLineLength = 0;
+                this.stateDependentLayerIds = this.layers.filter(function(l2) {
+                  return l2.isStateDependent();
+                }).map(function(l2) {
+                  return l2.id;
+                });
+              };
+              LineBucket.prototype.populate = function populate(features, options, canonical) {
+                this.hasPattern = hasPattern("line", this.layers, options);
+                var lineSortKey = this.layers[0].layout.get("line-sort-key");
+                var bucketFeatures = [];
+                for (var i2 = 0, list = features; i2 < list.length; i2 += 1) {
+                  var ref = list[i2];
+                  var feature = ref.feature;
+                  var id22 = ref.id;
+                  var index = ref.index;
+                  var sourceLayerIndex = ref.sourceLayerIndex;
+                  var needGeometry = this.layers[0]._featureFilter.needGeometry;
+                  var evaluationFeature = toEvaluationFeature(feature, needGeometry);
+                  if (!this.layers[0]._featureFilter.filter(new EvaluationParameters(this.zoom), evaluationFeature, canonical)) {
+                    continue;
+                  }
+                  var sortKey = lineSortKey ? lineSortKey.evaluate(evaluationFeature, {}, canonical) : void 0;
+                  var bucketFeature = {
+                    id: id22,
+                    properties: feature.properties,
+                    type: feature.type,
+                    sourceLayerIndex,
+                    index,
+                    geometry: needGeometry ? evaluationFeature.geometry : loadGeometry(feature),
+                    patterns: {},
+                    sortKey
+                  };
+                  bucketFeatures.push(bucketFeature);
+                }
+                if (lineSortKey) {
+                  bucketFeatures.sort(function(a2, b2) {
+                    return a2.sortKey - b2.sortKey;
+                  });
+                }
+                for (var i$1 = 0, list$1 = bucketFeatures; i$1 < list$1.length; i$1 += 1) {
+                  var bucketFeature$1 = list$1[i$1];
+                  var ref$1 = bucketFeature$1;
+                  var geometry2 = ref$1.geometry;
+                  var index$1 = ref$1.index;
+                  var sourceLayerIndex$1 = ref$1.sourceLayerIndex;
+                  if (this.hasPattern) {
+                    var patternBucketFeature = addPatternDependencies("line", this.layers, bucketFeature$1, this.zoom, options);
+                    this.patternFeatures.push(patternBucketFeature);
+                  } else {
+                    this.addFeature(bucketFeature$1, geometry2, index$1, canonical, {});
+                  }
+                  var feature$1 = features[index$1].feature;
+                  options.featureIndex.insert(feature$1, geometry2, index$1, sourceLayerIndex$1, this.index);
+                }
+              };
+              LineBucket.prototype.update = function update(states, vtLayer, imagePositions) {
+                if (!this.stateDependentLayers.length) {
+                  return;
+                }
+                this.programConfigurations.updatePaintArrays(states, vtLayer, this.stateDependentLayers, imagePositions);
+              };
+              LineBucket.prototype.addFeatures = function addFeatures(options, canonical, imagePositions) {
+                for (var i2 = 0, list = this.patternFeatures; i2 < list.length; i2 += 1) {
+                  var feature = list[i2];
+                  this.addFeature(feature, feature.geometry, feature.index, canonical, imagePositions);
+                }
+              };
+              LineBucket.prototype.isEmpty = function isEmpty2() {
+                return this.layoutVertexArray.length === 0;
+              };
+              LineBucket.prototype.uploadPending = function uploadPending() {
+                return !this.uploaded || this.programConfigurations.needsUpload;
+              };
+              LineBucket.prototype.upload = function upload(context) {
+                if (!this.uploaded) {
+                  if (this.layoutVertexArray2.length !== 0) {
+                    this.layoutVertexBuffer2 = context.createVertexBuffer(this.layoutVertexArray2, members$4);
+                  }
+                  this.layoutVertexBuffer = context.createVertexBuffer(this.layoutVertexArray, members$3);
+                  this.indexBuffer = context.createIndexBuffer(this.indexArray);
+                }
+                this.programConfigurations.upload(context);
+                this.uploaded = true;
+              };
+              LineBucket.prototype.destroy = function destroy() {
+                if (!this.layoutVertexBuffer) {
+                  return;
+                }
+                this.layoutVertexBuffer.destroy();
+                this.indexBuffer.destroy();
+                this.programConfigurations.destroy();
+                this.segments.destroy();
+              };
+              LineBucket.prototype.lineFeatureClips = function lineFeatureClips(feature) {
+                if (!!feature.properties && feature.properties.hasOwnProperty("mapbox_clip_start") && feature.properties.hasOwnProperty("mapbox_clip_end")) {
+                  var start = +feature.properties["mapbox_clip_start"];
+                  var end = +feature.properties["mapbox_clip_end"];
+                  return {
+                    start,
+                    end
+                  };
+                }
+              };
+              LineBucket.prototype.addFeature = function addFeature2(feature, geometry2, index, canonical, imagePositions) {
+                var layout2 = this.layers[0].layout;
+                var join = layout2.get("line-join").evaluate(feature, {});
+                var cap = layout2.get("line-cap");
+                var miterLimit = layout2.get("line-miter-limit");
+                var roundLimit = layout2.get("line-round-limit");
+                this.lineClips = this.lineFeatureClips(feature);
+                for (var i2 = 0, list = geometry2; i2 < list.length; i2 += 1) {
+                  var line = list[i2];
+                  this.addLine(line, feature, join, cap, miterLimit, roundLimit);
+                }
+                this.programConfigurations.populatePaintArrays(this.layoutVertexArray.length, feature, index, imagePositions, canonical);
+              };
+              LineBucket.prototype.addLine = function addLine(vertices, feature, join, cap, miterLimit, roundLimit) {
+                this.distance = 0;
+                this.scaledDistance = 0;
+                this.totalDistance = 0;
+                if (this.lineClips) {
+                  this.lineClipsArray.push(this.lineClips);
+                  for (var i2 = 0; i2 < vertices.length - 1; i2++) {
+                    this.totalDistance += vertices[i2].dist(vertices[i2 + 1]);
+                  }
+                  this.updateScaledDistance();
+                  this.maxLineLength = Math.max(this.maxLineLength, this.totalDistance);
+                }
+                var isPolygon = vectorTileFeatureTypes$1[feature.type] === "Polygon";
+                var len2 = vertices.length;
+                while (len2 >= 2 && vertices[len2 - 1].equals(vertices[len2 - 2])) {
+                  len2--;
+                }
+                var first = 0;
+                while (first < len2 - 1 && vertices[first].equals(vertices[first + 1])) {
+                  first++;
+                }
+                if (len2 < (isPolygon ? 3 : 2)) {
+                  return;
+                }
+                if (join === "bevel") {
+                  miterLimit = 1.05;
+                }
+                var sharpCornerOffset = this.overscaling <= 16 ? SHARP_CORNER_OFFSET * EXTENT$1 / (512 * this.overscaling) : 0;
+                var segment = this.segments.prepareSegment(len2 * 10, this.layoutVertexArray, this.indexArray);
+                var currentVertex;
+                var prevVertex = void 0;
+                var nextVertex = void 0;
+                var prevNormal = void 0;
+                var nextNormal = void 0;
+                this.e1 = this.e2 = -1;
+                if (isPolygon) {
+                  currentVertex = vertices[len2 - 2];
+                  nextNormal = vertices[first].sub(currentVertex)._unit()._perp();
+                }
+                for (var i$1 = first; i$1 < len2; i$1++) {
+                  nextVertex = i$1 === len2 - 1 ? isPolygon ? vertices[first + 1] : void 0 : vertices[i$1 + 1];
+                  if (nextVertex && vertices[i$1].equals(nextVertex)) {
+                    continue;
+                  }
+                  if (nextNormal) {
+                    prevNormal = nextNormal;
+                  }
+                  if (currentVertex) {
+                    prevVertex = currentVertex;
+                  }
+                  currentVertex = vertices[i$1];
+                  nextNormal = nextVertex ? nextVertex.sub(currentVertex)._unit()._perp() : prevNormal;
+                  prevNormal = prevNormal || nextNormal;
+                  var joinNormal = prevNormal.add(nextNormal);
+                  if (joinNormal.x !== 0 || joinNormal.y !== 0) {
+                    joinNormal._unit();
+                  }
+                  var cosAngle = prevNormal.x * nextNormal.x + prevNormal.y * nextNormal.y;
+                  var cosHalfAngle = joinNormal.x * nextNormal.x + joinNormal.y * nextNormal.y;
+                  var miterLength = cosHalfAngle !== 0 ? 1 / cosHalfAngle : Infinity;
+                  var approxAngle = 2 * Math.sqrt(2 - 2 * cosHalfAngle);
+                  var isSharpCorner = cosHalfAngle < COS_HALF_SHARP_CORNER && prevVertex && nextVertex;
+                  var lineTurnsLeft = prevNormal.x * nextNormal.y - prevNormal.y * nextNormal.x > 0;
+                  if (isSharpCorner && i$1 > first) {
+                    var prevSegmentLength = currentVertex.dist(prevVertex);
+                    if (prevSegmentLength > 2 * sharpCornerOffset) {
+                      var newPrevVertex = currentVertex.sub(currentVertex.sub(prevVertex)._mult(sharpCornerOffset / prevSegmentLength)._round());
+                      this.updateDistance(prevVertex, newPrevVertex);
+                      this.addCurrentVertex(newPrevVertex, prevNormal, 0, 0, segment);
+                      prevVertex = newPrevVertex;
+                    }
+                  }
+                  var middleVertex = prevVertex && nextVertex;
+                  var currentJoin = middleVertex ? join : isPolygon ? "butt" : cap;
+                  if (middleVertex && currentJoin === "round") {
+                    if (miterLength < roundLimit) {
+                      currentJoin = "miter";
+                    } else if (miterLength <= 2) {
+                      currentJoin = "fakeround";
+                    }
+                  }
+                  if (currentJoin === "miter" && miterLength > miterLimit) {
+                    currentJoin = "bevel";
+                  }
+                  if (currentJoin === "bevel") {
+                    if (miterLength > 2) {
+                      currentJoin = "flipbevel";
+                    }
+                    if (miterLength < miterLimit) {
+                      currentJoin = "miter";
+                    }
+                  }
+                  if (prevVertex) {
+                    this.updateDistance(prevVertex, currentVertex);
+                  }
+                  if (currentJoin === "miter") {
+                    joinNormal._mult(miterLength);
+                    this.addCurrentVertex(currentVertex, joinNormal, 0, 0, segment);
+                  } else if (currentJoin === "flipbevel") {
+                    if (miterLength > 100) {
+                      joinNormal = nextNormal.mult(-1);
+                    } else {
+                      var bevelLength = miterLength * prevNormal.add(nextNormal).mag() / prevNormal.sub(nextNormal).mag();
+                      joinNormal._perp()._mult(bevelLength * (lineTurnsLeft ? -1 : 1));
+                    }
+                    this.addCurrentVertex(currentVertex, joinNormal, 0, 0, segment);
+                    this.addCurrentVertex(currentVertex, joinNormal.mult(-1), 0, 0, segment);
+                  } else if (currentJoin === "bevel" || currentJoin === "fakeround") {
+                    var offset = -Math.sqrt(miterLength * miterLength - 1);
+                    var offsetA = lineTurnsLeft ? offset : 0;
+                    var offsetB = lineTurnsLeft ? 0 : offset;
+                    if (prevVertex) {
+                      this.addCurrentVertex(currentVertex, prevNormal, offsetA, offsetB, segment);
+                    }
+                    if (currentJoin === "fakeround") {
+                      var n2 = Math.round(approxAngle * 180 / Math.PI / DEG_PER_TRIANGLE);
+                      for (var m2 = 1; m2 < n2; m2++) {
+                        var t4 = m2 / n2;
+                        if (t4 !== 0.5) {
+                          var t23 = t4 - 0.5;
+                          var A22 = 1.0904 + cosAngle * (-3.2452 + cosAngle * (3.55645 - cosAngle * 1.43519));
+                          var B22 = 0.848013 + cosAngle * (-1.06021 + cosAngle * 0.215638);
+                          t4 = t4 + t4 * t23 * (t4 - 1) * (A22 * t23 * t23 + B22);
+                        }
+                        var extrude = nextNormal.sub(prevNormal)._mult(t4)._add(prevNormal)._unit()._mult(lineTurnsLeft ? -1 : 1);
+                        this.addHalfVertex(currentVertex, extrude.x, extrude.y, false, lineTurnsLeft, 0, segment);
+                      }
+                    }
+                    if (nextVertex) {
+                      this.addCurrentVertex(currentVertex, nextNormal, -offsetA, -offsetB, segment);
+                    }
+                  } else if (currentJoin === "butt") {
+                    this.addCurrentVertex(currentVertex, joinNormal, 0, 0, segment);
+                  } else if (currentJoin === "square") {
+                    var offset$1 = prevVertex ? 1 : -1;
+                    this.addCurrentVertex(currentVertex, joinNormal, offset$1, offset$1, segment);
+                  } else if (currentJoin === "round") {
+                    if (prevVertex) {
+                      this.addCurrentVertex(currentVertex, prevNormal, 0, 0, segment);
+                      this.addCurrentVertex(currentVertex, prevNormal, 1, 1, segment, true);
+                    }
+                    if (nextVertex) {
+                      this.addCurrentVertex(currentVertex, nextNormal, -1, -1, segment, true);
+                      this.addCurrentVertex(currentVertex, nextNormal, 0, 0, segment);
+                    }
+                  }
+                  if (isSharpCorner && i$1 < len2 - 1) {
+                    var nextSegmentLength = currentVertex.dist(nextVertex);
+                    if (nextSegmentLength > 2 * sharpCornerOffset) {
+                      var newCurrentVertex = currentVertex.add(nextVertex.sub(currentVertex)._mult(sharpCornerOffset / nextSegmentLength)._round());
+                      this.updateDistance(currentVertex, newCurrentVertex);
+                      this.addCurrentVertex(newCurrentVertex, nextNormal, 0, 0, segment);
+                      currentVertex = newCurrentVertex;
+                    }
+                  }
+                }
+              };
+              LineBucket.prototype.addCurrentVertex = function addCurrentVertex(p2, normal, endLeft, endRight, segment, round2) {
+                if (round2 === void 0)
+                  round2 = false;
+                var leftX = normal.x + normal.y * endLeft;
+                var leftY = normal.y - normal.x * endLeft;
+                var rightX = -normal.x + normal.y * endRight;
+                var rightY = -normal.y - normal.x * endRight;
+                this.addHalfVertex(p2, leftX, leftY, round2, false, endLeft, segment);
+                this.addHalfVertex(p2, rightX, rightY, round2, true, -endRight, segment);
+                if (this.distance > MAX_LINE_DISTANCE / 2 && this.totalDistance === 0) {
+                  this.distance = 0;
+                  this.addCurrentVertex(p2, normal, endLeft, endRight, segment, round2);
+                }
+              };
+              LineBucket.prototype.addHalfVertex = function addHalfVertex(ref, extrudeX, extrudeY, round2, up, dir, segment) {
+                var x2 = ref.x;
+                var y2 = ref.y;
+                var totalDistance = this.lineClips ? this.scaledDistance * (MAX_LINE_DISTANCE - 1) : this.scaledDistance;
+                var linesofarScaled = totalDistance * LINE_DISTANCE_SCALE;
+                this.layoutVertexArray.emplaceBack((x2 << 1) + (round2 ? 1 : 0), (y2 << 1) + (up ? 1 : 0), Math.round(EXTRUDE_SCALE * extrudeX) + 128, Math.round(EXTRUDE_SCALE * extrudeY) + 128, (dir === 0 ? 0 : dir < 0 ? -1 : 1) + 1 | (linesofarScaled & 63) << 2, linesofarScaled >> 6);
+                if (this.lineClips) {
+                  var progressRealigned = this.scaledDistance - this.lineClips.start;
+                  var endClipRealigned = this.lineClips.end - this.lineClips.start;
+                  var uvX = progressRealigned / endClipRealigned;
+                  this.layoutVertexArray2.emplaceBack(uvX, this.lineClipsArray.length);
+                }
+                var e2 = segment.vertexLength++;
+                if (this.e1 >= 0 && this.e2 >= 0) {
+                  this.indexArray.emplaceBack(this.e1, this.e2, e2);
+                  segment.primitiveLength++;
+                }
+                if (up) {
+                  this.e2 = e2;
+                } else {
+                  this.e1 = e2;
+                }
+              };
+              LineBucket.prototype.updateScaledDistance = function updateScaledDistance() {
+                this.scaledDistance = this.lineClips ? this.lineClips.start + (this.lineClips.end - this.lineClips.start) * this.distance / this.totalDistance : this.distance;
+              };
+              LineBucket.prototype.updateDistance = function updateDistance(prev, next) {
+                this.distance += prev.dist(next);
+                this.updateScaledDistance();
+              };
+              register2("LineBucket", LineBucket, {
+                omit: [
+                  "layers",
+                  "patternFeatures"
+                ]
+              });
+              var layout$6 = new Properties({
+                "line-cap": new DataConstantProperty(spec["layout_line"]["line-cap"]),
+                "line-join": new DataDrivenProperty(spec["layout_line"]["line-join"]),
+                "line-miter-limit": new DataConstantProperty(spec["layout_line"]["line-miter-limit"]),
+                "line-round-limit": new DataConstantProperty(spec["layout_line"]["line-round-limit"]),
+                "line-sort-key": new DataDrivenProperty(spec["layout_line"]["line-sort-key"])
+              });
+              var paint$6 = new Properties({
+                "line-opacity": new DataDrivenProperty(spec["paint_line"]["line-opacity"]),
+                "line-color": new DataDrivenProperty(spec["paint_line"]["line-color"]),
+                "line-translate": new DataConstantProperty(spec["paint_line"]["line-translate"]),
+                "line-translate-anchor": new DataConstantProperty(spec["paint_line"]["line-translate-anchor"]),
+                "line-width": new DataDrivenProperty(spec["paint_line"]["line-width"]),
+                "line-gap-width": new DataDrivenProperty(spec["paint_line"]["line-gap-width"]),
+                "line-offset": new DataDrivenProperty(spec["paint_line"]["line-offset"]),
+                "line-blur": new DataDrivenProperty(spec["paint_line"]["line-blur"]),
+                "line-dasharray": new CrossFadedProperty(spec["paint_line"]["line-dasharray"]),
+                "line-pattern": new CrossFadedDataDrivenProperty(spec["paint_line"]["line-pattern"]),
+                "line-gradient": new ColorRampProperty(spec["paint_line"]["line-gradient"])
+              });
+              var properties$5 = {
+                paint: paint$6,
+                layout: layout$6
+              };
+              var LineFloorwidthProperty = function(DataDrivenProperty2) {
+                function LineFloorwidthProperty2() {
+                  DataDrivenProperty2.apply(this, arguments);
+                }
+                if (DataDrivenProperty2)
+                  LineFloorwidthProperty2.__proto__ = DataDrivenProperty2;
+                LineFloorwidthProperty2.prototype = Object.create(DataDrivenProperty2 && DataDrivenProperty2.prototype);
+                LineFloorwidthProperty2.prototype.constructor = LineFloorwidthProperty2;
+                LineFloorwidthProperty2.prototype.possiblyEvaluate = function possiblyEvaluate(value, parameters) {
+                  parameters = new EvaluationParameters(Math.floor(parameters.zoom), {
+                    now: parameters.now,
+                    fadeDuration: parameters.fadeDuration,
+                    zoomHistory: parameters.zoomHistory,
+                    transition: parameters.transition
+                  });
+                  return DataDrivenProperty2.prototype.possiblyEvaluate.call(this, value, parameters);
+                };
+                LineFloorwidthProperty2.prototype.evaluate = function evaluate(value, globals, feature, featureState) {
+                  globals = extend2({}, globals, { zoom: Math.floor(globals.zoom) });
+                  return DataDrivenProperty2.prototype.evaluate.call(this, value, globals, feature, featureState);
+                };
+                return LineFloorwidthProperty2;
+              }(DataDrivenProperty);
+              var lineFloorwidthProperty = new LineFloorwidthProperty(properties$5.paint.properties["line-width"].specification);
+              lineFloorwidthProperty.useIntegerZoom = true;
+              var LineStyleLayer = function(StyleLayer2) {
+                function LineStyleLayer2(layer2) {
+                  StyleLayer2.call(this, layer2, properties$5);
+                  this.gradientVersion = 0;
+                }
+                if (StyleLayer2)
+                  LineStyleLayer2.__proto__ = StyleLayer2;
+                LineStyleLayer2.prototype = Object.create(StyleLayer2 && StyleLayer2.prototype);
+                LineStyleLayer2.prototype.constructor = LineStyleLayer2;
+                LineStyleLayer2.prototype._handleSpecialPaintPropertyUpdate = function _handleSpecialPaintPropertyUpdate(name3) {
+                  if (name3 === "line-gradient") {
+                    var expression2 = this._transitionablePaint._values["line-gradient"].value.expression;
+                    this.stepInterpolant = expression2._styleExpression.expression instanceof Step;
+                    this.gradientVersion = (this.gradientVersion + 1) % MAX_SAFE_INTEGER;
+                  }
+                };
+                LineStyleLayer2.prototype.gradientExpression = function gradientExpression() {
+                  return this._transitionablePaint._values["line-gradient"].value.expression;
+                };
+                LineStyleLayer2.prototype.recalculate = function recalculate(parameters, availableImages) {
+                  StyleLayer2.prototype.recalculate.call(this, parameters, availableImages);
+                  this.paint._values["line-floorwidth"] = lineFloorwidthProperty.possiblyEvaluate(this._transitioningPaint._values["line-width"].value, parameters);
+                };
+                LineStyleLayer2.prototype.createBucket = function createBucket(parameters) {
+                  return new LineBucket(parameters);
+                };
+                LineStyleLayer2.prototype.queryRadius = function queryRadius(bucket) {
+                  var lineBucket = bucket;
+                  var width = getLineWidth(getMaximumPaintValue("line-width", this, lineBucket), getMaximumPaintValue("line-gap-width", this, lineBucket));
+                  var offset = getMaximumPaintValue("line-offset", this, lineBucket);
+                  return width / 2 + Math.abs(offset) + translateDistance(this.paint.get("line-translate"));
+                };
+                LineStyleLayer2.prototype.queryIntersectsFeature = function queryIntersectsFeature(queryGeometry, feature, featureState, geometry2, zoom, transform, pixelsToTileUnits) {
+                  var translatedPolygon = translate2(queryGeometry, this.paint.get("line-translate"), this.paint.get("line-translate-anchor"), transform.angle, pixelsToTileUnits);
+                  var halfWidth = pixelsToTileUnits / 2 * getLineWidth(this.paint.get("line-width").evaluate(feature, featureState), this.paint.get("line-gap-width").evaluate(feature, featureState));
+                  var lineOffset = this.paint.get("line-offset").evaluate(feature, featureState);
+                  if (lineOffset) {
+                    geometry2 = offsetLine(geometry2, lineOffset * pixelsToTileUnits);
+                  }
+                  return polygonIntersectsBufferedMultiLine(translatedPolygon, geometry2, halfWidth);
+                };
+                LineStyleLayer2.prototype.isTileClipped = function isTileClipped() {
+                  return true;
+                };
+                return LineStyleLayer2;
+              }(StyleLayer);
+              function getLineWidth(lineWidth, lineGapWidth) {
+                if (lineGapWidth > 0) {
+                  return lineGapWidth + 2 * lineWidth;
+                } else {
+                  return lineWidth;
+                }
+              }
+              function offsetLine(rings, offset) {
+                var newRings = [];
+                var zero2 = new pointGeometry(0, 0);
+                for (var k2 = 0; k2 < rings.length; k2++) {
+                  var ring = rings[k2];
+                  var newRing = [];
+                  for (var i2 = 0; i2 < ring.length; i2++) {
+                    var a2 = ring[i2 - 1];
+                    var b2 = ring[i2];
+                    var c2 = ring[i2 + 1];
+                    var aToB = i2 === 0 ? zero2 : b2.sub(a2)._unit()._perp();
+                    var bToC = i2 === ring.length - 1 ? zero2 : c2.sub(b2)._unit()._perp();
+                    var extrude = aToB._add(bToC)._unit();
+                    var cosHalfAngle = extrude.x * bToC.x + extrude.y * bToC.y;
+                    extrude._mult(1 / cosHalfAngle);
+                    newRing.push(extrude._mult(offset)._add(b2));
+                  }
+                  newRings.push(newRing);
+                }
+                return newRings;
+              }
+              var symbolLayoutAttributes = createLayout([
+                {
+                  name: "a_pos_offset",
+                  components: 4,
+                  type: "Int16"
+                },
+                {
+                  name: "a_data",
+                  components: 4,
+                  type: "Uint16"
+                },
+                {
+                  name: "a_pixeloffset",
+                  components: 4,
+                  type: "Int16"
+                }
+              ], 4);
+              var dynamicLayoutAttributes = createLayout([{
+                name: "a_projected_pos",
+                components: 3,
+                type: "Float32"
+              }], 4);
+              createLayout([{
+                name: "a_fade_opacity",
+                components: 1,
+                type: "Uint32"
+              }], 4);
+              var collisionVertexAttributes = createLayout([
+                {
+                  name: "a_placed",
+                  components: 2,
+                  type: "Uint8"
+                },
+                {
+                  name: "a_shift",
+                  components: 2,
+                  type: "Float32"
+                }
+              ]);
+              createLayout([
+                {
+                  type: "Int16",
+                  name: "anchorPointX"
+                },
+                {
+                  type: "Int16",
+                  name: "anchorPointY"
+                },
+                {
+                  type: "Int16",
+                  name: "x1"
+                },
+                {
+                  type: "Int16",
+                  name: "y1"
+                },
+                {
+                  type: "Int16",
+                  name: "x2"
+                },
+                {
+                  type: "Int16",
+                  name: "y2"
+                },
+                {
+                  type: "Uint32",
+                  name: "featureIndex"
+                },
+                {
+                  type: "Uint16",
+                  name: "sourceLayerIndex"
+                },
+                {
+                  type: "Uint16",
+                  name: "bucketIndex"
+                }
+              ]);
+              var collisionBoxLayout = createLayout([
+                {
+                  name: "a_pos",
+                  components: 2,
+                  type: "Int16"
+                },
+                {
+                  name: "a_anchor_pos",
+                  components: 2,
+                  type: "Int16"
+                },
+                {
+                  name: "a_extrude",
+                  components: 2,
+                  type: "Int16"
+                }
+              ], 4);
+              var collisionCircleLayout = createLayout([
+                {
+                  name: "a_pos",
+                  components: 2,
+                  type: "Float32"
+                },
+                {
+                  name: "a_radius",
+                  components: 1,
+                  type: "Float32"
+                },
+                {
+                  name: "a_flags",
+                  components: 2,
+                  type: "Int16"
+                }
+              ], 4);
+              createLayout([{
+                name: "triangle",
+                components: 3,
+                type: "Uint16"
+              }]);
+              createLayout([
+                {
+                  type: "Int16",
+                  name: "anchorX"
+                },
+                {
+                  type: "Int16",
+                  name: "anchorY"
+                },
+                {
+                  type: "Uint16",
+                  name: "glyphStartIndex"
+                },
+                {
+                  type: "Uint16",
+                  name: "numGlyphs"
+                },
+                {
+                  type: "Uint32",
+                  name: "vertexStartIndex"
+                },
+                {
+                  type: "Uint32",
+                  name: "lineStartIndex"
+                },
+                {
+                  type: "Uint32",
+                  name: "lineLength"
+                },
+                {
+                  type: "Uint16",
+                  name: "segment"
+                },
+                {
+                  type: "Uint16",
+                  name: "lowerSize"
+                },
+                {
+                  type: "Uint16",
+                  name: "upperSize"
+                },
+                {
+                  type: "Float32",
+                  name: "lineOffsetX"
+                },
+                {
+                  type: "Float32",
+                  name: "lineOffsetY"
+                },
+                {
+                  type: "Uint8",
+                  name: "writingMode"
+                },
+                {
+                  type: "Uint8",
+                  name: "placedOrientation"
+                },
+                {
+                  type: "Uint8",
+                  name: "hidden"
+                },
+                {
+                  type: "Uint32",
+                  name: "crossTileID"
+                },
+                {
+                  type: "Int16",
+                  name: "associatedIconIndex"
+                }
+              ]);
+              createLayout([
+                {
+                  type: "Int16",
+                  name: "anchorX"
+                },
+                {
+                  type: "Int16",
+                  name: "anchorY"
+                },
+                {
+                  type: "Int16",
+                  name: "rightJustifiedTextSymbolIndex"
+                },
+                {
+                  type: "Int16",
+                  name: "centerJustifiedTextSymbolIndex"
+                },
+                {
+                  type: "Int16",
+                  name: "leftJustifiedTextSymbolIndex"
+                },
+                {
+                  type: "Int16",
+                  name: "verticalPlacedTextSymbolIndex"
+                },
+                {
+                  type: "Int16",
+                  name: "placedIconSymbolIndex"
+                },
+                {
+                  type: "Int16",
+                  name: "verticalPlacedIconSymbolIndex"
+                },
+                {
+                  type: "Uint16",
+                  name: "key"
+                },
+                {
+                  type: "Uint16",
+                  name: "textBoxStartIndex"
+                },
+                {
+                  type: "Uint16",
+                  name: "textBoxEndIndex"
+                },
+                {
+                  type: "Uint16",
+                  name: "verticalTextBoxStartIndex"
+                },
+                {
+                  type: "Uint16",
+                  name: "verticalTextBoxEndIndex"
+                },
+                {
+                  type: "Uint16",
+                  name: "iconBoxStartIndex"
+                },
+                {
+                  type: "Uint16",
+                  name: "iconBoxEndIndex"
+                },
+                {
+                  type: "Uint16",
+                  name: "verticalIconBoxStartIndex"
+                },
+                {
+                  type: "Uint16",
+                  name: "verticalIconBoxEndIndex"
+                },
+                {
+                  type: "Uint16",
+                  name: "featureIndex"
+                },
+                {
+                  type: "Uint16",
+                  name: "numHorizontalGlyphVertices"
+                },
+                {
+                  type: "Uint16",
+                  name: "numVerticalGlyphVertices"
+                },
+                {
+                  type: "Uint16",
+                  name: "numIconVertices"
+                },
+                {
+                  type: "Uint16",
+                  name: "numVerticalIconVertices"
+                },
+                {
+                  type: "Uint16",
+                  name: "useRuntimeCollisionCircles"
+                },
+                {
+                  type: "Uint32",
+                  name: "crossTileID"
+                },
+                {
+                  type: "Float32",
+                  name: "textBoxScale"
+                },
+                {
+                  type: "Float32",
+                  components: 2,
+                  name: "textOffset"
+                },
+                {
+                  type: "Float32",
+                  name: "collisionCircleDiameter"
+                }
+              ]);
+              createLayout([{
+                type: "Float32",
+                name: "offsetX"
+              }]);
+              createLayout([
+                {
+                  type: "Int16",
+                  name: "x"
+                },
+                {
+                  type: "Int16",
+                  name: "y"
+                },
+                {
+                  type: "Int16",
+                  name: "tileUnitDistanceFromAnchor"
+                }
+              ]);
+              function transformText(text, layer2, feature) {
+                var transform = layer2.layout.get("text-transform").evaluate(feature, {});
+                if (transform === "uppercase") {
+                  text = text.toLocaleUpperCase();
+                } else if (transform === "lowercase") {
+                  text = text.toLocaleLowerCase();
+                }
+                if (plugin.applyArabicShaping) {
+                  text = plugin.applyArabicShaping(text);
+                }
+                return text;
+              }
+              function transformText$1(text, layer2, feature) {
+                text.sections.forEach(function(section) {
+                  section.text = transformText(section.text, layer2, feature);
+                });
+                return text;
+              }
+              function mergeLines(features) {
+                var leftIndex = {};
+                var rightIndex = {};
+                var mergedFeatures = [];
+                var mergedIndex = 0;
+                function add22(k22) {
+                  mergedFeatures.push(features[k22]);
+                  mergedIndex++;
+                }
+                function mergeFromRight(leftKey2, rightKey2, geom2) {
+                  var i22 = rightIndex[leftKey2];
+                  delete rightIndex[leftKey2];
+                  rightIndex[rightKey2] = i22;
+                  mergedFeatures[i22].geometry[0].pop();
+                  mergedFeatures[i22].geometry[0] = mergedFeatures[i22].geometry[0].concat(geom2[0]);
+                  return i22;
+                }
+                function mergeFromLeft(leftKey2, rightKey2, geom2) {
+                  var i22 = leftIndex[rightKey2];
+                  delete leftIndex[rightKey2];
+                  leftIndex[leftKey2] = i22;
+                  mergedFeatures[i22].geometry[0].shift();
+                  mergedFeatures[i22].geometry[0] = geom2[0].concat(mergedFeatures[i22].geometry[0]);
+                  return i22;
+                }
+                function getKey(text2, geom2, onRight) {
+                  var point = onRight ? geom2[0][geom2[0].length - 1] : geom2[0][0];
+                  return text2 + ":" + point.x + ":" + point.y;
+                }
+                for (var k2 = 0; k2 < features.length; k2++) {
+                  var feature = features[k2];
+                  var geom = feature.geometry;
+                  var text = feature.text ? feature.text.toString() : null;
+                  if (!text) {
+                    add22(k2);
+                    continue;
+                  }
+                  var leftKey = getKey(text, geom), rightKey = getKey(text, geom, true);
+                  if (leftKey in rightIndex && rightKey in leftIndex && rightIndex[leftKey] !== leftIndex[rightKey]) {
+                    var j2 = mergeFromLeft(leftKey, rightKey, geom);
+                    var i2 = mergeFromRight(leftKey, rightKey, mergedFeatures[j2].geometry);
+                    delete leftIndex[leftKey];
+                    delete rightIndex[rightKey];
+                    rightIndex[getKey(text, mergedFeatures[i2].geometry, true)] = i2;
+                    mergedFeatures[j2].geometry = null;
+                  } else if (leftKey in rightIndex) {
+                    mergeFromRight(leftKey, rightKey, geom);
+                  } else if (rightKey in leftIndex) {
+                    mergeFromLeft(leftKey, rightKey, geom);
+                  } else {
+                    add22(k2);
+                    leftIndex[leftKey] = mergedIndex - 1;
+                    rightIndex[rightKey] = mergedIndex - 1;
+                  }
+                }
+                return mergedFeatures.filter(function(f2) {
+                  return f2.geometry;
+                });
+              }
+              var verticalizedCharacterMap = {
+                "!": "︕",
+                "#": "＃",
+                "$": "＄",
+                "%": "％",
+                "&": "＆",
+                "(": "︵",
+                ")": "︶",
+                "*": "＊",
+                "+": "＋",
+                ",": "︐",
+                "-": "︲",
+                ".": "・",
+                "/": "／",
+                ":": "︓",
+                ";": "︔",
+                "<": "︿",
+                "=": "＝",
+                ">": "﹀",
+                "?": "︖",
+                "@": "＠",
+                "[": "﹇",
+                "\\": "＼",
+                "]": "﹈",
+                "^": "＾",
+                "_": "︳",
+                "`": "｀",
+                "{": "︷",
+                "|": "―",
+                "}": "︸",
+                "~": "～",
+                "¢": "￠",
+                "£": "￡",
+                "¥": "￥",
+                "¦": "￤",
+                "¬": "￢",
+                "¯": "￣",
+                "–": "︲",
+                "—": "︱",
+                "‘": "﹃",
+                "’": "﹄",
+                "“": "﹁",
+                "”": "﹂",
+                "…": "︙",
+                "‧": "・",
+                "₩": "￦",
+                "、": "︑",
+                "。": "︒",
+                "〈": "︿",
+                "〉": "﹀",
+                "《": "︽",
+                "》": "︾",
+                "「": "﹁",
+                "」": "﹂",
+                "『": "﹃",
+                "』": "﹄",
+                "【": "︻",
+                "】": "︼",
+                "〔": "︹",
+                "〕": "︺",
+                "〖": "︗",
+                "〗": "︘",
+                "！": "︕",
+                "（": "︵",
+                "）": "︶",
+                "，": "︐",
+                "－": "︲",
+                "．": "・",
+                "：": "︓",
+                "；": "︔",
+                "＜": "︿",
+                "＞": "﹀",
+                "？": "︖",
+                "［": "﹇",
+                "］": "﹈",
+                "＿": "︳",
+                "｛": "︷",
+                "｜": "―",
+                "｝": "︸",
+                "｟": "︵",
+                "｠": "︶",
+                "｡": "︒",
+                "｢": "﹁",
+                "｣": "﹂"
+              };
+              function verticalizePunctuation(input) {
+                var output = "";
+                for (var i2 = 0; i2 < input.length; i2++) {
+                  var nextCharCode = input.charCodeAt(i2 + 1) || null;
+                  var prevCharCode = input.charCodeAt(i2 - 1) || null;
+                  var canReplacePunctuation = (!nextCharCode || !charHasRotatedVerticalOrientation(nextCharCode) || verticalizedCharacterMap[input[i2 + 1]]) && (!prevCharCode || !charHasRotatedVerticalOrientation(prevCharCode) || verticalizedCharacterMap[input[i2 - 1]]);
+                  if (canReplacePunctuation && verticalizedCharacterMap[input[i2]]) {
+                    output += verticalizedCharacterMap[input[i2]];
+                  } else {
+                    output += input[i2];
+                  }
+                }
+                return output;
+              }
+              var ONE_EM = 24;
+              var read = function(buffer, offset, isLE, mLen, nBytes) {
+                var e2, m2;
+                var eLen = nBytes * 8 - mLen - 1;
+                var eMax = (1 << eLen) - 1;
+                var eBias = eMax >> 1;
+                var nBits = -7;
+                var i2 = isLE ? nBytes - 1 : 0;
+                var d2 = isLE ? -1 : 1;
+                var s2 = buffer[offset + i2];
+                i2 += d2;
+                e2 = s2 & (1 << -nBits) - 1;
+                s2 >>= -nBits;
+                nBits += eLen;
+                for (; nBits > 0; e2 = e2 * 256 + buffer[offset + i2], i2 += d2, nBits -= 8) {
+                }
+                m2 = e2 & (1 << -nBits) - 1;
+                e2 >>= -nBits;
+                nBits += mLen;
+                for (; nBits > 0; m2 = m2 * 256 + buffer[offset + i2], i2 += d2, nBits -= 8) {
+                }
+                if (e2 === 0) {
+                  e2 = 1 - eBias;
+                } else if (e2 === eMax) {
+                  return m2 ? NaN : (s2 ? -1 : 1) * Infinity;
+                } else {
+                  m2 = m2 + Math.pow(2, mLen);
+                  e2 = e2 - eBias;
+                }
+                return (s2 ? -1 : 1) * m2 * Math.pow(2, e2 - mLen);
+              };
+              var write = function(buffer, value, offset, isLE, mLen, nBytes) {
+                var e2, m2, c2;
+                var eLen = nBytes * 8 - mLen - 1;
+                var eMax = (1 << eLen) - 1;
+                var eBias = eMax >> 1;
+                var rt2 = mLen === 23 ? Math.pow(2, -24) - Math.pow(2, -77) : 0;
+                var i2 = isLE ? 0 : nBytes - 1;
+                var d2 = isLE ? 1 : -1;
+                var s2 = value < 0 || value === 0 && 1 / value < 0 ? 1 : 0;
+                value = Math.abs(value);
+                if (isNaN(value) || value === Infinity) {
+                  m2 = isNaN(value) ? 1 : 0;
+                  e2 = eMax;
+                } else {
+                  e2 = Math.floor(Math.log(value) / Math.LN2);
+                  if (value * (c2 = Math.pow(2, -e2)) < 1) {
+                    e2--;
+                    c2 *= 2;
+                  }
+                  if (e2 + eBias >= 1) {
+                    value += rt2 / c2;
+                  } else {
+                    value += rt2 * Math.pow(2, 1 - eBias);
+                  }
+                  if (value * c2 >= 2) {
+                    e2++;
+                    c2 /= 2;
+                  }
+                  if (e2 + eBias >= eMax) {
+                    m2 = 0;
+                    e2 = eMax;
+                  } else if (e2 + eBias >= 1) {
+                    m2 = (value * c2 - 1) * Math.pow(2, mLen);
+                    e2 = e2 + eBias;
+                  } else {
+                    m2 = value * Math.pow(2, eBias - 1) * Math.pow(2, mLen);
+                    e2 = 0;
+                  }
+                }
+                for (; mLen >= 8; buffer[offset + i2] = m2 & 255, i2 += d2, m2 /= 256, mLen -= 8) {
+                }
+                e2 = e2 << mLen | m2;
+                eLen += mLen;
+                for (; eLen > 0; buffer[offset + i2] = e2 & 255, i2 += d2, e2 /= 256, eLen -= 8) {
+                }
+                buffer[offset + i2 - d2] |= s2 * 128;
+              };
+              var ieee754 = {
+                read,
+                write
+              };
+              var pbf = Pbf;
+              function Pbf(buf) {
+                this.buf = ArrayBuffer.isView && ArrayBuffer.isView(buf) ? buf : new Uint8Array(buf || 0);
+                this.pos = 0;
+                this.type = 0;
+                this.length = this.buf.length;
+              }
+              Pbf.Varint = 0;
+              Pbf.Fixed64 = 1;
+              Pbf.Bytes = 2;
+              Pbf.Fixed32 = 5;
+              var SHIFT_LEFT_32 = (1 << 16) * (1 << 16), SHIFT_RIGHT_32 = 1 / SHIFT_LEFT_32;
+              var TEXT_DECODER_MIN_LENGTH = 12;
+              var utf8TextDecoder = typeof TextDecoder === "undefined" ? null : new TextDecoder("utf8");
+              Pbf.prototype = {
+                destroy: function() {
+                  this.buf = null;
+                },
+                readFields: function(readField, result, end) {
+                  end = end || this.length;
+                  while (this.pos < end) {
+                    var val = this.readVarint(), tag = val >> 3, startPos = this.pos;
+                    this.type = val & 7;
+                    readField(tag, result, this);
+                    if (this.pos === startPos) {
+                      this.skip(val);
+                    }
+                  }
+                  return result;
+                },
+                readMessage: function(readField, result) {
+                  return this.readFields(readField, result, this.readVarint() + this.pos);
+                },
+                readFixed32: function() {
+                  var val = readUInt32(this.buf, this.pos);
+                  this.pos += 4;
+                  return val;
+                },
+                readSFixed32: function() {
+                  var val = readInt32(this.buf, this.pos);
+                  this.pos += 4;
+                  return val;
+                },
+                readFixed64: function() {
+                  var val = readUInt32(this.buf, this.pos) + readUInt32(this.buf, this.pos + 4) * SHIFT_LEFT_32;
+                  this.pos += 8;
+                  return val;
+                },
+                readSFixed64: function() {
+                  var val = readUInt32(this.buf, this.pos) + readInt32(this.buf, this.pos + 4) * SHIFT_LEFT_32;
+                  this.pos += 8;
+                  return val;
+                },
+                readFloat: function() {
+                  var val = ieee754.read(this.buf, this.pos, true, 23, 4);
+                  this.pos += 4;
+                  return val;
+                },
+                readDouble: function() {
+                  var val = ieee754.read(this.buf, this.pos, true, 52, 8);
+                  this.pos += 8;
+                  return val;
+                },
+                readVarint: function(isSigned) {
+                  var buf = this.buf, val, b2;
+                  b2 = buf[this.pos++];
+                  val = b2 & 127;
+                  if (b2 < 128) {
+                    return val;
+                  }
+                  b2 = buf[this.pos++];
+                  val |= (b2 & 127) << 7;
+                  if (b2 < 128) {
+                    return val;
+                  }
+                  b2 = buf[this.pos++];
+                  val |= (b2 & 127) << 14;
+                  if (b2 < 128) {
+                    return val;
+                  }
+                  b2 = buf[this.pos++];
+                  val |= (b2 & 127) << 21;
+                  if (b2 < 128) {
+                    return val;
+                  }
+                  b2 = buf[this.pos];
+                  val |= (b2 & 15) << 28;
+                  return readVarintRemainder(val, isSigned, this);
+                },
+                readVarint64: function() {
+                  return this.readVarint(true);
+                },
+                readSVarint: function() {
+                  var num = this.readVarint();
+                  return num % 2 === 1 ? (num + 1) / -2 : num / 2;
+                },
+                readBoolean: function() {
+                  return Boolean(this.readVarint());
+                },
+                readString: function() {
+                  var end = this.readVarint() + this.pos;
+                  var pos = this.pos;
+                  this.pos = end;
+                  if (end - pos >= TEXT_DECODER_MIN_LENGTH && utf8TextDecoder) {
+                    return readUtf8TextDecoder(this.buf, pos, end);
+                  }
+                  return readUtf8(this.buf, pos, end);
+                },
+                readBytes: function() {
+                  var end = this.readVarint() + this.pos, buffer = this.buf.subarray(this.pos, end);
+                  this.pos = end;
+                  return buffer;
+                },
+                readPackedVarint: function(arr, isSigned) {
+                  if (this.type !== Pbf.Bytes) {
+                    return arr.push(this.readVarint(isSigned));
+                  }
+                  var end = readPackedEnd(this);
+                  arr = arr || [];
+                  while (this.pos < end) {
+                    arr.push(this.readVarint(isSigned));
+                  }
+                  return arr;
+                },
+                readPackedSVarint: function(arr) {
+                  if (this.type !== Pbf.Bytes) {
+                    return arr.push(this.readSVarint());
+                  }
+                  var end = readPackedEnd(this);
+                  arr = arr || [];
+                  while (this.pos < end) {
+                    arr.push(this.readSVarint());
+                  }
+                  return arr;
+                },
+                readPackedBoolean: function(arr) {
+                  if (this.type !== Pbf.Bytes) {
+                    return arr.push(this.readBoolean());
+                  }
+                  var end = readPackedEnd(this);
+                  arr = arr || [];
+                  while (this.pos < end) {
+                    arr.push(this.readBoolean());
+                  }
+                  return arr;
+                },
+                readPackedFloat: function(arr) {
+                  if (this.type !== Pbf.Bytes) {
+                    return arr.push(this.readFloat());
+                  }
+                  var end = readPackedEnd(this);
+                  arr = arr || [];
+                  while (this.pos < end) {
+                    arr.push(this.readFloat());
+                  }
+                  return arr;
+                },
+                readPackedDouble: function(arr) {
+                  if (this.type !== Pbf.Bytes) {
+                    return arr.push(this.readDouble());
+                  }
+                  var end = readPackedEnd(this);
+                  arr = arr || [];
+                  while (this.pos < end) {
+                    arr.push(this.readDouble());
+                  }
+                  return arr;
+                },
+                readPackedFixed32: function(arr) {
+                  if (this.type !== Pbf.Bytes) {
+                    return arr.push(this.readFixed32());
+                  }
+                  var end = readPackedEnd(this);
+                  arr = arr || [];
+                  while (this.pos < end) {
+                    arr.push(this.readFixed32());
+                  }
+                  return arr;
+                },
+                readPackedSFixed32: function(arr) {
+                  if (this.type !== Pbf.Bytes) {
+                    return arr.push(this.readSFixed32());
+                  }
+                  var end = readPackedEnd(this);
+                  arr = arr || [];
+                  while (this.pos < end) {
+                    arr.push(this.readSFixed32());
+                  }
+                  return arr;
+                },
+                readPackedFixed64: function(arr) {
+                  if (this.type !== Pbf.Bytes) {
+                    return arr.push(this.readFixed64());
+                  }
+                  var end = readPackedEnd(this);
+                  arr = arr || [];
+                  while (this.pos < end) {
+                    arr.push(this.readFixed64());
+                  }
+                  return arr;
+                },
+                readPackedSFixed64: function(arr) {
+                  if (this.type !== Pbf.Bytes) {
+                    return arr.push(this.readSFixed64());
+                  }
+                  var end = readPackedEnd(this);
+                  arr = arr || [];
+                  while (this.pos < end) {
+                    arr.push(this.readSFixed64());
+                  }
+                  return arr;
+                },
+                skip: function(val) {
+                  var type = val & 7;
+                  if (type === Pbf.Varint) {
+                    while (this.buf[this.pos++] > 127) {
+                    }
+                  } else if (type === Pbf.Bytes) {
+                    this.pos = this.readVarint() + this.pos;
+                  } else if (type === Pbf.Fixed32) {
+                    this.pos += 4;
+                  } else if (type === Pbf.Fixed64) {
+                    this.pos += 8;
+                  } else {
+                    throw new Error("Unimplemented type: " + type);
+                  }
+                },
+                writeTag: function(tag, type) {
+                  this.writeVarint(tag << 3 | type);
+                },
+                realloc: function(min) {
+                  var length2 = this.length || 16;
+                  while (length2 < this.pos + min) {
+                    length2 *= 2;
+                  }
+                  if (length2 !== this.length) {
+                    var buf = new Uint8Array(length2);
+                    buf.set(this.buf);
+                    this.buf = buf;
+                    this.length = length2;
+                  }
+                },
+                finish: function() {
+                  this.length = this.pos;
+                  this.pos = 0;
+                  return this.buf.subarray(0, this.length);
+                },
+                writeFixed32: function(val) {
+                  this.realloc(4);
+                  writeInt32(this.buf, val, this.pos);
+                  this.pos += 4;
+                },
+                writeSFixed32: function(val) {
+                  this.realloc(4);
+                  writeInt32(this.buf, val, this.pos);
+                  this.pos += 4;
+                },
+                writeFixed64: function(val) {
+                  this.realloc(8);
+                  writeInt32(this.buf, val & -1, this.pos);
+                  writeInt32(this.buf, Math.floor(val * SHIFT_RIGHT_32), this.pos + 4);
+                  this.pos += 8;
+                },
+                writeSFixed64: function(val) {
+                  this.realloc(8);
+                  writeInt32(this.buf, val & -1, this.pos);
+                  writeInt32(this.buf, Math.floor(val * SHIFT_RIGHT_32), this.pos + 4);
+                  this.pos += 8;
+                },
+                writeVarint: function(val) {
+                  val = +val || 0;
+                  if (val > 268435455 || val < 0) {
+                    writeBigVarint(val, this);
+                    return;
+                  }
+                  this.realloc(4);
+                  this.buf[this.pos++] = val & 127 | (val > 127 ? 128 : 0);
+                  if (val <= 127) {
+                    return;
+                  }
+                  this.buf[this.pos++] = (val >>>= 7) & 127 | (val > 127 ? 128 : 0);
+                  if (val <= 127) {
+                    return;
+                  }
+                  this.buf[this.pos++] = (val >>>= 7) & 127 | (val > 127 ? 128 : 0);
+                  if (val <= 127) {
+                    return;
+                  }
+                  this.buf[this.pos++] = val >>> 7 & 127;
+                },
+                writeSVarint: function(val) {
+                  this.writeVarint(val < 0 ? -val * 2 - 1 : val * 2);
+                },
+                writeBoolean: function(val) {
+                  this.writeVarint(Boolean(val));
+                },
+                writeString: function(str) {
+                  str = String(str);
+                  this.realloc(str.length * 4);
+                  this.pos++;
+                  var startPos = this.pos;
+                  this.pos = writeUtf8(this.buf, str, this.pos);
+                  var len2 = this.pos - startPos;
+                  if (len2 >= 128) {
+                    makeRoomForExtraLength(startPos, len2, this);
+                  }
+                  this.pos = startPos - 1;
+                  this.writeVarint(len2);
+                  this.pos += len2;
+                },
+                writeFloat: function(val) {
+                  this.realloc(4);
+                  ieee754.write(this.buf, val, this.pos, true, 23, 4);
+                  this.pos += 4;
+                },
+                writeDouble: function(val) {
+                  this.realloc(8);
+                  ieee754.write(this.buf, val, this.pos, true, 52, 8);
+                  this.pos += 8;
+                },
+                writeBytes: function(buffer) {
+                  var len2 = buffer.length;
+                  this.writeVarint(len2);
+                  this.realloc(len2);
+                  for (var i2 = 0; i2 < len2; i2++) {
+                    this.buf[this.pos++] = buffer[i2];
+                  }
+                },
+                writeRawMessage: function(fn, obj) {
+                  this.pos++;
+                  var startPos = this.pos;
+                  fn(obj, this);
+                  var len2 = this.pos - startPos;
+                  if (len2 >= 128) {
+                    makeRoomForExtraLength(startPos, len2, this);
+                  }
+                  this.pos = startPos - 1;
+                  this.writeVarint(len2);
+                  this.pos += len2;
+                },
+                writeMessage: function(tag, fn, obj) {
+                  this.writeTag(tag, Pbf.Bytes);
+                  this.writeRawMessage(fn, obj);
+                },
+                writePackedVarint: function(tag, arr) {
+                  if (arr.length) {
+                    this.writeMessage(tag, writePackedVarint, arr);
+                  }
+                },
+                writePackedSVarint: function(tag, arr) {
+                  if (arr.length) {
+                    this.writeMessage(tag, writePackedSVarint, arr);
+                  }
+                },
+                writePackedBoolean: function(tag, arr) {
+                  if (arr.length) {
+                    this.writeMessage(tag, writePackedBoolean, arr);
+                  }
+                },
+                writePackedFloat: function(tag, arr) {
+                  if (arr.length) {
+                    this.writeMessage(tag, writePackedFloat, arr);
+                  }
+                },
+                writePackedDouble: function(tag, arr) {
+                  if (arr.length) {
+                    this.writeMessage(tag, writePackedDouble, arr);
+                  }
+                },
+                writePackedFixed32: function(tag, arr) {
+                  if (arr.length) {
+                    this.writeMessage(tag, writePackedFixed32, arr);
+                  }
+                },
+                writePackedSFixed32: function(tag, arr) {
+                  if (arr.length) {
+                    this.writeMessage(tag, writePackedSFixed32, arr);
+                  }
+                },
+                writePackedFixed64: function(tag, arr) {
+                  if (arr.length) {
+                    this.writeMessage(tag, writePackedFixed64, arr);
+                  }
+                },
+                writePackedSFixed64: function(tag, arr) {
+                  if (arr.length) {
+                    this.writeMessage(tag, writePackedSFixed64, arr);
+                  }
+                },
+                writeBytesField: function(tag, buffer) {
+                  this.writeTag(tag, Pbf.Bytes);
+                  this.writeBytes(buffer);
+                },
+                writeFixed32Field: function(tag, val) {
+                  this.writeTag(tag, Pbf.Fixed32);
+                  this.writeFixed32(val);
+                },
+                writeSFixed32Field: function(tag, val) {
+                  this.writeTag(tag, Pbf.Fixed32);
+                  this.writeSFixed32(val);
+                },
+                writeFixed64Field: function(tag, val) {
+                  this.writeTag(tag, Pbf.Fixed64);
+                  this.writeFixed64(val);
+                },
+                writeSFixed64Field: function(tag, val) {
+                  this.writeTag(tag, Pbf.Fixed64);
+                  this.writeSFixed64(val);
+                },
+                writeVarintField: function(tag, val) {
+                  this.writeTag(tag, Pbf.Varint);
+                  this.writeVarint(val);
+                },
+                writeSVarintField: function(tag, val) {
+                  this.writeTag(tag, Pbf.Varint);
+                  this.writeSVarint(val);
+                },
+                writeStringField: function(tag, str) {
+                  this.writeTag(tag, Pbf.Bytes);
+                  this.writeString(str);
+                },
+                writeFloatField: function(tag, val) {
+                  this.writeTag(tag, Pbf.Fixed32);
+                  this.writeFloat(val);
+                },
+                writeDoubleField: function(tag, val) {
+                  this.writeTag(tag, Pbf.Fixed64);
+                  this.writeDouble(val);
+                },
+                writeBooleanField: function(tag, val) {
+                  this.writeVarintField(tag, Boolean(val));
+                }
+              };
+              function readVarintRemainder(l2, s2, p2) {
+                var buf = p2.buf, h2, b2;
+                b2 = buf[p2.pos++];
+                h2 = (b2 & 112) >> 4;
+                if (b2 < 128) {
+                  return toNum(l2, h2, s2);
+                }
+                b2 = buf[p2.pos++];
+                h2 |= (b2 & 127) << 3;
+                if (b2 < 128) {
+                  return toNum(l2, h2, s2);
+                }
+                b2 = buf[p2.pos++];
+                h2 |= (b2 & 127) << 10;
+                if (b2 < 128) {
+                  return toNum(l2, h2, s2);
+                }
+                b2 = buf[p2.pos++];
+                h2 |= (b2 & 127) << 17;
+                if (b2 < 128) {
+                  return toNum(l2, h2, s2);
+                }
+                b2 = buf[p2.pos++];
+                h2 |= (b2 & 127) << 24;
+                if (b2 < 128) {
+                  return toNum(l2, h2, s2);
+                }
+                b2 = buf[p2.pos++];
+                h2 |= (b2 & 1) << 31;
+                if (b2 < 128) {
+                  return toNum(l2, h2, s2);
+                }
+                throw new Error("Expected varint not more than 10 bytes");
+              }
+              function readPackedEnd(pbf2) {
+                return pbf2.type === Pbf.Bytes ? pbf2.readVarint() + pbf2.pos : pbf2.pos + 1;
+              }
+              function toNum(low, high, isSigned) {
+                if (isSigned) {
+                  return high * 4294967296 + (low >>> 0);
+                }
+                return (high >>> 0) * 4294967296 + (low >>> 0);
+              }
+              function writeBigVarint(val, pbf2) {
+                var low, high;
+                if (val >= 0) {
+                  low = val % 4294967296 | 0;
+                  high = val / 4294967296 | 0;
+                } else {
+                  low = ~(-val % 4294967296);
+                  high = ~(-val / 4294967296);
+                  if (low ^ 4294967295) {
+                    low = low + 1 | 0;
+                  } else {
+                    low = 0;
+                    high = high + 1 | 0;
+                  }
+                }
+                if (val >= 18446744073709552e3 || val < -18446744073709552e3) {
+                  throw new Error("Given varint doesn't fit into 10 bytes");
+                }
+                pbf2.realloc(10);
+                writeBigVarintLow(low, high, pbf2);
+                writeBigVarintHigh(high, pbf2);
+              }
+              function writeBigVarintLow(low, high, pbf2) {
+                pbf2.buf[pbf2.pos++] = low & 127 | 128;
+                low >>>= 7;
+                pbf2.buf[pbf2.pos++] = low & 127 | 128;
+                low >>>= 7;
+                pbf2.buf[pbf2.pos++] = low & 127 | 128;
+                low >>>= 7;
+                pbf2.buf[pbf2.pos++] = low & 127 | 128;
+                low >>>= 7;
+                pbf2.buf[pbf2.pos] = low & 127;
+              }
+              function writeBigVarintHigh(high, pbf2) {
+                var lsb = (high & 7) << 4;
+                pbf2.buf[pbf2.pos++] |= lsb | ((high >>>= 3) ? 128 : 0);
+                if (!high) {
+                  return;
+                }
+                pbf2.buf[pbf2.pos++] = high & 127 | ((high >>>= 7) ? 128 : 0);
+                if (!high) {
+                  return;
+                }
+                pbf2.buf[pbf2.pos++] = high & 127 | ((high >>>= 7) ? 128 : 0);
+                if (!high) {
+                  return;
+                }
+                pbf2.buf[pbf2.pos++] = high & 127 | ((high >>>= 7) ? 128 : 0);
+                if (!high) {
+                  return;
+                }
+                pbf2.buf[pbf2.pos++] = high & 127 | ((high >>>= 7) ? 128 : 0);
+                if (!high) {
+                  return;
+                }
+                pbf2.buf[pbf2.pos++] = high & 127;
+              }
+              function makeRoomForExtraLength(startPos, len2, pbf2) {
+                var extraLen = len2 <= 16383 ? 1 : len2 <= 2097151 ? 2 : len2 <= 268435455 ? 3 : Math.floor(Math.log(len2) / (Math.LN2 * 7));
+                pbf2.realloc(extraLen);
+                for (var i2 = pbf2.pos - 1; i2 >= startPos; i2--) {
+                  pbf2.buf[i2 + extraLen] = pbf2.buf[i2];
+                }
+              }
+              function writePackedVarint(arr, pbf2) {
+                for (var i2 = 0; i2 < arr.length; i2++) {
+                  pbf2.writeVarint(arr[i2]);
+                }
+              }
+              function writePackedSVarint(arr, pbf2) {
+                for (var i2 = 0; i2 < arr.length; i2++) {
+                  pbf2.writeSVarint(arr[i2]);
+                }
+              }
+              function writePackedFloat(arr, pbf2) {
+                for (var i2 = 0; i2 < arr.length; i2++) {
+                  pbf2.writeFloat(arr[i2]);
+                }
+              }
+              function writePackedDouble(arr, pbf2) {
+                for (var i2 = 0; i2 < arr.length; i2++) {
+                  pbf2.writeDouble(arr[i2]);
+                }
+              }
+              function writePackedBoolean(arr, pbf2) {
+                for (var i2 = 0; i2 < arr.length; i2++) {
+                  pbf2.writeBoolean(arr[i2]);
+                }
+              }
+              function writePackedFixed32(arr, pbf2) {
+                for (var i2 = 0; i2 < arr.length; i2++) {
+                  pbf2.writeFixed32(arr[i2]);
+                }
+              }
+              function writePackedSFixed32(arr, pbf2) {
+                for (var i2 = 0; i2 < arr.length; i2++) {
+                  pbf2.writeSFixed32(arr[i2]);
+                }
+              }
+              function writePackedFixed64(arr, pbf2) {
+                for (var i2 = 0; i2 < arr.length; i2++) {
+                  pbf2.writeFixed64(arr[i2]);
+                }
+              }
+              function writePackedSFixed64(arr, pbf2) {
+                for (var i2 = 0; i2 < arr.length; i2++) {
+                  pbf2.writeSFixed64(arr[i2]);
+                }
+              }
+              function readUInt32(buf, pos) {
+                return (buf[pos] | buf[pos + 1] << 8 | buf[pos + 2] << 16) + buf[pos + 3] * 16777216;
+              }
+              function writeInt32(buf, val, pos) {
+                buf[pos] = val;
+                buf[pos + 1] = val >>> 8;
+                buf[pos + 2] = val >>> 16;
+                buf[pos + 3] = val >>> 24;
+              }
+              function readInt32(buf, pos) {
+                return (buf[pos] | buf[pos + 1] << 8 | buf[pos + 2] << 16) + (buf[pos + 3] << 24);
+              }
+              function readUtf8(buf, pos, end) {
+                var str = "";
+                var i2 = pos;
+                while (i2 < end) {
+                  var b0 = buf[i2];
+                  var c2 = null;
+                  var bytesPerSequence = b0 > 239 ? 4 : b0 > 223 ? 3 : b0 > 191 ? 2 : 1;
+                  if (i2 + bytesPerSequence > end) {
+                    break;
+                  }
+                  var b1, b2, b3;
+                  if (bytesPerSequence === 1) {
+                    if (b0 < 128) {
+                      c2 = b0;
+                    }
+                  } else if (bytesPerSequence === 2) {
+                    b1 = buf[i2 + 1];
+                    if ((b1 & 192) === 128) {
+                      c2 = (b0 & 31) << 6 | b1 & 63;
+                      if (c2 <= 127) {
+                        c2 = null;
+                      }
+                    }
+                  } else if (bytesPerSequence === 3) {
+                    b1 = buf[i2 + 1];
+                    b2 = buf[i2 + 2];
+                    if ((b1 & 192) === 128 && (b2 & 192) === 128) {
+                      c2 = (b0 & 15) << 12 | (b1 & 63) << 6 | b2 & 63;
+                      if (c2 <= 2047 || c2 >= 55296 && c2 <= 57343) {
+                        c2 = null;
+                      }
+                    }
+                  } else if (bytesPerSequence === 4) {
+                    b1 = buf[i2 + 1];
+                    b2 = buf[i2 + 2];
+                    b3 = buf[i2 + 3];
+                    if ((b1 & 192) === 128 && (b2 & 192) === 128 && (b3 & 192) === 128) {
+                      c2 = (b0 & 15) << 18 | (b1 & 63) << 12 | (b2 & 63) << 6 | b3 & 63;
+                      if (c2 <= 65535 || c2 >= 1114112) {
+                        c2 = null;
+                      }
+                    }
+                  }
+                  if (c2 === null) {
+                    c2 = 65533;
+                    bytesPerSequence = 1;
+                  } else if (c2 > 65535) {
+                    c2 -= 65536;
+                    str += String.fromCharCode(c2 >>> 10 & 1023 | 55296);
+                    c2 = 56320 | c2 & 1023;
+                  }
+                  str += String.fromCharCode(c2);
+                  i2 += bytesPerSequence;
+                }
+                return str;
+              }
+              function readUtf8TextDecoder(buf, pos, end) {
+                return utf8TextDecoder.decode(buf.subarray(pos, end));
+              }
+              function writeUtf8(buf, str, pos) {
+                for (var i2 = 0, c2, lead; i2 < str.length; i2++) {
+                  c2 = str.charCodeAt(i2);
+                  if (c2 > 55295 && c2 < 57344) {
+                    if (lead) {
+                      if (c2 < 56320) {
+                        buf[pos++] = 239;
+                        buf[pos++] = 191;
+                        buf[pos++] = 189;
+                        lead = c2;
+                        continue;
+                      } else {
+                        c2 = lead - 55296 << 10 | c2 - 56320 | 65536;
+                        lead = null;
+                      }
+                    } else {
+                      if (c2 > 56319 || i2 + 1 === str.length) {
+                        buf[pos++] = 239;
+                        buf[pos++] = 191;
+                        buf[pos++] = 189;
+                      } else {
+                        lead = c2;
+                      }
+                      continue;
+                    }
+                  } else if (lead) {
+                    buf[pos++] = 239;
+                    buf[pos++] = 191;
+                    buf[pos++] = 189;
+                    lead = null;
+                  }
+                  if (c2 < 128) {
+                    buf[pos++] = c2;
+                  } else {
+                    if (c2 < 2048) {
+                      buf[pos++] = c2 >> 6 | 192;
+                    } else {
+                      if (c2 < 65536) {
+                        buf[pos++] = c2 >> 12 | 224;
+                      } else {
+                        buf[pos++] = c2 >> 18 | 240;
+                        buf[pos++] = c2 >> 12 & 63 | 128;
+                      }
+                      buf[pos++] = c2 >> 6 & 63 | 128;
+                    }
+                    buf[pos++] = c2 & 63 | 128;
+                  }
+                }
+                return pos;
+              }
+              var border = 3;
+              function readFontstacks(tag, glyphs, pbf2) {
+                if (tag === 1) {
+                  pbf2.readMessage(readFontstack, glyphs);
+                }
+              }
+              function readFontstack(tag, glyphs, pbf2) {
+                if (tag === 3) {
+                  var ref = pbf2.readMessage(readGlyph, {});
+                  var id22 = ref.id;
+                  var bitmap = ref.bitmap;
+                  var width = ref.width;
+                  var height = ref.height;
+                  var left = ref.left;
+                  var top = ref.top;
+                  var advance = ref.advance;
+                  glyphs.push({
+                    id: id22,
+                    bitmap: new AlphaImage({
+                      width: width + 2 * border,
+                      height: height + 2 * border
+                    }, bitmap),
+                    metrics: {
+                      width,
+                      height,
+                      left,
+                      top,
+                      advance
+                    }
+                  });
+                }
+              }
+              function readGlyph(tag, glyph, pbf2) {
+                if (tag === 1) {
+                  glyph.id = pbf2.readVarint();
+                } else if (tag === 2) {
+                  glyph.bitmap = pbf2.readBytes();
+                } else if (tag === 3) {
+                  glyph.width = pbf2.readVarint();
+                } else if (tag === 4) {
+                  glyph.height = pbf2.readVarint();
+                } else if (tag === 5) {
+                  glyph.left = pbf2.readSVarint();
+                } else if (tag === 6) {
+                  glyph.top = pbf2.readSVarint();
+                } else if (tag === 7) {
+                  glyph.advance = pbf2.readVarint();
+                }
+              }
+              function parseGlyphPBF(data) {
+                return new pbf(data).readFields(readFontstacks, []);
+              }
+              var GLYPH_PBF_BORDER = border;
+              function potpack(boxes) {
+                var area2 = 0;
+                var maxWidth = 0;
+                for (var i$1 = 0, list = boxes; i$1 < list.length; i$1 += 1) {
+                  var box = list[i$1];
+                  area2 += box.w * box.h;
+                  maxWidth = Math.max(maxWidth, box.w);
+                }
+                boxes.sort(function(a2, b2) {
+                  return b2.h - a2.h;
+                });
+                var startWidth = Math.max(Math.ceil(Math.sqrt(area2 / 0.95)), maxWidth);
+                var spaces = [{ x: 0, y: 0, w: startWidth, h: Infinity }];
+                var width = 0;
+                var height = 0;
+                for (var i$2 = 0, list$1 = boxes; i$2 < list$1.length; i$2 += 1) {
+                  var box$1 = list$1[i$2];
+                  for (var i2 = spaces.length - 1; i2 >= 0; i2--) {
+                    var space = spaces[i2];
+                    if (box$1.w > space.w || box$1.h > space.h) {
+                      continue;
+                    }
+                    box$1.x = space.x;
+                    box$1.y = space.y;
+                    height = Math.max(height, box$1.y + box$1.h);
+                    width = Math.max(width, box$1.x + box$1.w);
+                    if (box$1.w === space.w && box$1.h === space.h) {
+                      var last = spaces.pop();
+                      if (i2 < spaces.length) {
+                        spaces[i2] = last;
+                      }
+                    } else if (box$1.h === space.h) {
+                      space.x += box$1.w;
+                      space.w -= box$1.w;
+                    } else if (box$1.w === space.w) {
+                      space.y += box$1.h;
+                      space.h -= box$1.h;
+                    } else {
+                      spaces.push({
+                        x: space.x + box$1.w,
+                        y: space.y,
+                        w: space.w - box$1.w,
+                        h: box$1.h
+                      });
+                      space.y += box$1.h;
+                      space.h -= box$1.h;
+                    }
+                    break;
+                  }
+                }
+                return {
+                  w: width,
+                  // container width
+                  h: height,
+                  // container height
+                  fill: area2 / (width * height) || 0
+                  // space utilization
+                };
+              }
+              var IMAGE_PADDING = 1;
+              var ImagePosition = function ImagePosition2(paddedRect, ref) {
+                var pixelRatio = ref.pixelRatio;
+                var version22 = ref.version;
+                var stretchX = ref.stretchX;
+                var stretchY = ref.stretchY;
+                var content = ref.content;
+                this.paddedRect = paddedRect;
+                this.pixelRatio = pixelRatio;
+                this.stretchX = stretchX;
+                this.stretchY = stretchY;
+                this.content = content;
+                this.version = version22;
+              };
+              var prototypeAccessors = {
+                tl: { configurable: true },
+                br: { configurable: true },
+                tlbr: { configurable: true },
+                displaySize: { configurable: true }
+              };
+              prototypeAccessors.tl.get = function() {
+                return [
+                  this.paddedRect.x + IMAGE_PADDING,
+                  this.paddedRect.y + IMAGE_PADDING
+                ];
+              };
+              prototypeAccessors.br.get = function() {
+                return [
+                  this.paddedRect.x + this.paddedRect.w - IMAGE_PADDING,
+                  this.paddedRect.y + this.paddedRect.h - IMAGE_PADDING
+                ];
+              };
+              prototypeAccessors.tlbr.get = function() {
+                return this.tl.concat(this.br);
+              };
+              prototypeAccessors.displaySize.get = function() {
+                return [
+                  (this.paddedRect.w - IMAGE_PADDING * 2) / this.pixelRatio,
+                  (this.paddedRect.h - IMAGE_PADDING * 2) / this.pixelRatio
+                ];
+              };
+              Object.defineProperties(ImagePosition.prototype, prototypeAccessors);
+              var ImageAtlas = function ImageAtlas2(icons, patterns) {
+                var iconPositions = {}, patternPositions = {};
+                this.haveRenderCallbacks = [];
+                var bins = [];
+                this.addImages(icons, iconPositions, bins);
+                this.addImages(patterns, patternPositions, bins);
+                var ref = potpack(bins);
+                var w2 = ref.w;
+                var h2 = ref.h;
+                var image = new RGBAImage({
+                  width: w2 || 1,
+                  height: h2 || 1
+                });
+                for (var id22 in icons) {
+                  var src = icons[id22];
+                  var bin = iconPositions[id22].paddedRect;
+                  RGBAImage.copy(src.data, image, {
+                    x: 0,
+                    y: 0
+                  }, {
+                    x: bin.x + IMAGE_PADDING,
+                    y: bin.y + IMAGE_PADDING
+                  }, src.data);
+                }
+                for (var id$1 in patterns) {
+                  var src$1 = patterns[id$1];
+                  var bin$1 = patternPositions[id$1].paddedRect;
+                  var x2 = bin$1.x + IMAGE_PADDING, y2 = bin$1.y + IMAGE_PADDING, w$12 = src$1.data.width, h$1 = src$1.data.height;
+                  RGBAImage.copy(src$1.data, image, {
+                    x: 0,
+                    y: 0
+                  }, {
+                    x: x2,
+                    y: y2
+                  }, src$1.data);
+                  RGBAImage.copy(src$1.data, image, {
+                    x: 0,
+                    y: h$1 - 1
+                  }, {
+                    x: x2,
+                    y: y2 - 1
+                  }, {
+                    width: w$12,
+                    height: 1
+                  });
+                  RGBAImage.copy(src$1.data, image, {
+                    x: 0,
+                    y: 0
+                  }, {
+                    x: x2,
+                    y: y2 + h$1
+                  }, {
+                    width: w$12,
+                    height: 1
+                  });
+                  RGBAImage.copy(src$1.data, image, {
+                    x: w$12 - 1,
+                    y: 0
+                  }, {
+                    x: x2 - 1,
+                    y: y2
+                  }, {
+                    width: 1,
+                    height: h$1
+                  });
+                  RGBAImage.copy(src$1.data, image, {
+                    x: 0,
+                    y: 0
+                  }, {
+                    x: x2 + w$12,
+                    y: y2
+                  }, {
+                    width: 1,
+                    height: h$1
+                  });
+                }
+                this.image = image;
+                this.iconPositions = iconPositions;
+                this.patternPositions = patternPositions;
+              };
+              ImageAtlas.prototype.addImages = function addImages(images, positions, bins) {
+                for (var id22 in images) {
+                  var src = images[id22];
+                  var bin = {
+                    x: 0,
+                    y: 0,
+                    w: src.data.width + 2 * IMAGE_PADDING,
+                    h: src.data.height + 2 * IMAGE_PADDING
+                  };
+                  bins.push(bin);
+                  positions[id22] = new ImagePosition(bin, src);
+                  if (src.hasRenderCallback) {
+                    this.haveRenderCallbacks.push(id22);
+                  }
+                }
+              };
+              ImageAtlas.prototype.patchUpdatedImages = function patchUpdatedImages(imageManager, texture) {
+                imageManager.dispatchRenderCallbacks(this.haveRenderCallbacks);
+                for (var name3 in imageManager.updatedImages) {
+                  this.patchUpdatedImage(this.iconPositions[name3], imageManager.getImage(name3), texture);
+                  this.patchUpdatedImage(this.patternPositions[name3], imageManager.getImage(name3), texture);
+                }
+              };
+              ImageAtlas.prototype.patchUpdatedImage = function patchUpdatedImage(position, image, texture) {
+                if (!position || !image) {
+                  return;
+                }
+                if (position.version === image.version) {
+                  return;
+                }
+                position.version = image.version;
+                var ref = position.tl;
+                var x2 = ref[0];
+                var y2 = ref[1];
+                texture.update(image.data, void 0, {
+                  x: x2,
+                  y: y2
+                });
+              };
+              register2("ImagePosition", ImagePosition);
+              register2("ImageAtlas", ImageAtlas);
+              var WritingMode = {
+                horizontal: 1,
+                vertical: 2,
+                horizontalOnly: 3
+              };
+              var SHAPING_DEFAULT_OFFSET = -17;
+              function isEmpty(positionedLines) {
+                for (var i2 = 0, list = positionedLines; i2 < list.length; i2 += 1) {
+                  var line = list[i2];
+                  if (line.positionedGlyphs.length !== 0) {
+                    return false;
+                  }
+                }
+                return true;
+              }
+              var PUAbegin = 57344;
+              var PUAend = 63743;
+              var SectionOptions = function SectionOptions2() {
+                this.scale = 1;
+                this.fontStack = "";
+                this.imageName = null;
+              };
+              SectionOptions.forText = function forText(scale22, fontStack) {
+                var textOptions = new SectionOptions();
+                textOptions.scale = scale22 || 1;
+                textOptions.fontStack = fontStack;
+                return textOptions;
+              };
+              SectionOptions.forImage = function forImage(imageName) {
+                var imageOptions = new SectionOptions();
+                imageOptions.imageName = imageName;
+                return imageOptions;
+              };
+              var TaggedString = function TaggedString2() {
+                this.text = "";
+                this.sectionIndex = [];
+                this.sections = [];
+                this.imageSectionID = null;
+              };
+              TaggedString.fromFeature = function fromFeature(text, defaultFontStack) {
+                var result = new TaggedString();
+                for (var i2 = 0; i2 < text.sections.length; i2++) {
+                  var section = text.sections[i2];
+                  if (!section.image) {
+                    result.addTextSection(section, defaultFontStack);
+                  } else {
+                    result.addImageSection(section);
+                  }
+                }
+                return result;
+              };
+              TaggedString.prototype.length = function length2() {
+                return this.text.length;
+              };
+              TaggedString.prototype.getSection = function getSection(index) {
+                return this.sections[this.sectionIndex[index]];
+              };
+              TaggedString.prototype.getSectionIndex = function getSectionIndex(index) {
+                return this.sectionIndex[index];
+              };
+              TaggedString.prototype.getCharCode = function getCharCode(index) {
+                return this.text.charCodeAt(index);
+              };
+              TaggedString.prototype.verticalizePunctuation = function verticalizePunctuation$1() {
+                this.text = verticalizePunctuation(this.text);
+              };
+              TaggedString.prototype.trim = function trim() {
+                var beginningWhitespace = 0;
+                for (var i2 = 0; i2 < this.text.length && whitespace[this.text.charCodeAt(i2)]; i2++) {
+                  beginningWhitespace++;
+                }
+                var trailingWhitespace = this.text.length;
+                for (var i$1 = this.text.length - 1; i$1 >= 0 && i$1 >= beginningWhitespace && whitespace[this.text.charCodeAt(i$1)]; i$1--) {
+                  trailingWhitespace--;
+                }
+                this.text = this.text.substring(beginningWhitespace, trailingWhitespace);
+                this.sectionIndex = this.sectionIndex.slice(beginningWhitespace, trailingWhitespace);
+              };
+              TaggedString.prototype.substring = function substring(start, end) {
+                var substring2 = new TaggedString();
+                substring2.text = this.text.substring(start, end);
+                substring2.sectionIndex = this.sectionIndex.slice(start, end);
+                substring2.sections = this.sections;
+                return substring2;
+              };
+              TaggedString.prototype.toString = function toString2() {
+                return this.text;
+              };
+              TaggedString.prototype.getMaxScale = function getMaxScale() {
+                var this$1$1 = this;
+                return this.sectionIndex.reduce(function(max, index) {
+                  return Math.max(max, this$1$1.sections[index].scale);
+                }, 0);
+              };
+              TaggedString.prototype.addTextSection = function addTextSection(section, defaultFontStack) {
+                this.text += section.text;
+                this.sections.push(SectionOptions.forText(section.scale, section.fontStack || defaultFontStack));
+                var index = this.sections.length - 1;
+                for (var i2 = 0; i2 < section.text.length; ++i2) {
+                  this.sectionIndex.push(index);
+                }
+              };
+              TaggedString.prototype.addImageSection = function addImageSection(section) {
+                var imageName = section.image ? section.image.name : "";
+                if (imageName.length === 0) {
+                  warnOnce("Can't add FormattedSection with an empty image.");
+                  return;
+                }
+                var nextImageSectionCharCode = this.getNextImageSectionCharCode();
+                if (!nextImageSectionCharCode) {
+                  warnOnce("Reached maximum number of images " + (PUAend - PUAbegin + 2));
+                  return;
+                }
+                this.text += String.fromCharCode(nextImageSectionCharCode);
+                this.sections.push(SectionOptions.forImage(imageName));
+                this.sectionIndex.push(this.sections.length - 1);
+              };
+              TaggedString.prototype.getNextImageSectionCharCode = function getNextImageSectionCharCode() {
+                if (!this.imageSectionID) {
+                  this.imageSectionID = PUAbegin;
+                  return this.imageSectionID;
+                }
+                if (this.imageSectionID >= PUAend) {
+                  return null;
+                }
+                return ++this.imageSectionID;
+              };
+              function breakLines(input, lineBreakPoints) {
+                var lines = [];
+                var text = input.text;
+                var start = 0;
+                for (var i2 = 0, list = lineBreakPoints; i2 < list.length; i2 += 1) {
+                  var lineBreak = list[i2];
+                  lines.push(input.substring(start, lineBreak));
+                  start = lineBreak;
+                }
+                if (start < text.length) {
+                  lines.push(input.substring(start, text.length));
+                }
+                return lines;
+              }
+              function shapeText(text, glyphMap, glyphPositions, imagePositions, defaultFontStack, maxWidth, lineHeight, textAnchor, textJustify, spacing, translate22, writingMode, allowVerticalPlacement, symbolPlacement, layoutTextSize, layoutTextSizeThisZoom) {
+                var logicalInput = TaggedString.fromFeature(text, defaultFontStack);
+                if (writingMode === WritingMode.vertical) {
+                  logicalInput.verticalizePunctuation();
+                }
+                var lines;
+                var processBidirectionalText = plugin.processBidirectionalText;
+                var processStyledBidirectionalText = plugin.processStyledBidirectionalText;
+                if (processBidirectionalText && logicalInput.sections.length === 1) {
+                  lines = [];
+                  var untaggedLines = processBidirectionalText(logicalInput.toString(), determineLineBreaks(logicalInput, spacing, maxWidth, glyphMap, imagePositions, symbolPlacement, layoutTextSize));
+                  for (var i$1 = 0, list = untaggedLines; i$1 < list.length; i$1 += 1) {
+                    var line = list[i$1];
+                    var taggedLine = new TaggedString();
+                    taggedLine.text = line;
+                    taggedLine.sections = logicalInput.sections;
+                    for (var i2 = 0; i2 < line.length; i2++) {
+                      taggedLine.sectionIndex.push(0);
+                    }
+                    lines.push(taggedLine);
+                  }
+                } else if (processStyledBidirectionalText) {
+                  lines = [];
+                  var processedLines = processStyledBidirectionalText(logicalInput.text, logicalInput.sectionIndex, determineLineBreaks(logicalInput, spacing, maxWidth, glyphMap, imagePositions, symbolPlacement, layoutTextSize));
+                  for (var i$2 = 0, list$1 = processedLines; i$2 < list$1.length; i$2 += 1) {
+                    var line$1 = list$1[i$2];
+                    var taggedLine$1 = new TaggedString();
+                    taggedLine$1.text = line$1[0];
+                    taggedLine$1.sectionIndex = line$1[1];
+                    taggedLine$1.sections = logicalInput.sections;
+                    lines.push(taggedLine$1);
+                  }
+                } else {
+                  lines = breakLines(logicalInput, determineLineBreaks(logicalInput, spacing, maxWidth, glyphMap, imagePositions, symbolPlacement, layoutTextSize));
+                }
+                var positionedLines = [];
+                var shaping = {
+                  positionedLines,
+                  text: logicalInput.toString(),
+                  top: translate22[1],
+                  bottom: translate22[1],
+                  left: translate22[0],
+                  right: translate22[0],
+                  writingMode,
+                  iconsInText: false,
+                  verticalizable: false
+                };
+                shapeLines(shaping, glyphMap, glyphPositions, imagePositions, lines, lineHeight, textAnchor, textJustify, writingMode, spacing, allowVerticalPlacement, layoutTextSizeThisZoom);
+                if (isEmpty(positionedLines)) {
+                  return false;
+                }
+                return shaping;
+              }
+              var whitespace = {};
+              whitespace[9] = true;
+              whitespace[10] = true;
+              whitespace[11] = true;
+              whitespace[12] = true;
+              whitespace[13] = true;
+              whitespace[32] = true;
+              var breakable = {};
+              breakable[10] = true;
+              breakable[32] = true;
+              breakable[38] = true;
+              breakable[40] = true;
+              breakable[41] = true;
+              breakable[43] = true;
+              breakable[45] = true;
+              breakable[47] = true;
+              breakable[173] = true;
+              breakable[183] = true;
+              breakable[8203] = true;
+              breakable[8208] = true;
+              breakable[8211] = true;
+              breakable[8231] = true;
+              function getGlyphAdvance(codePoint, section, glyphMap, imagePositions, spacing, layoutTextSize) {
+                if (!section.imageName) {
+                  var positions = glyphMap[section.fontStack];
+                  var glyph = positions && positions[codePoint];
+                  if (!glyph) {
+                    return 0;
+                  }
+                  return glyph.metrics.advance * section.scale + spacing;
+                } else {
+                  var imagePosition = imagePositions[section.imageName];
+                  if (!imagePosition) {
+                    return 0;
+                  }
+                  return imagePosition.displaySize[0] * section.scale * ONE_EM / layoutTextSize + spacing;
+                }
+              }
+              function determineAverageLineWidth(logicalInput, spacing, maxWidth, glyphMap, imagePositions, layoutTextSize) {
+                var totalWidth = 0;
+                for (var index = 0; index < logicalInput.length(); index++) {
+                  var section = logicalInput.getSection(index);
+                  totalWidth += getGlyphAdvance(logicalInput.getCharCode(index), section, glyphMap, imagePositions, spacing, layoutTextSize);
+                }
+                var lineCount = Math.max(1, Math.ceil(totalWidth / maxWidth));
+                return totalWidth / lineCount;
+              }
+              function calculateBadness(lineWidth, targetWidth, penalty, isLastBreak) {
+                var raggedness = Math.pow(lineWidth - targetWidth, 2);
+                if (isLastBreak) {
+                  if (lineWidth < targetWidth) {
+                    return raggedness / 2;
+                  } else {
+                    return raggedness * 2;
+                  }
+                }
+                return raggedness + Math.abs(penalty) * penalty;
+              }
+              function calculatePenalty(codePoint, nextCodePoint, penalizableIdeographicBreak) {
+                var penalty = 0;
+                if (codePoint === 10) {
+                  penalty -= 1e4;
+                }
+                if (penalizableIdeographicBreak) {
+                  penalty += 150;
+                }
+                if (codePoint === 40 || codePoint === 65288) {
+                  penalty += 50;
+                }
+                if (nextCodePoint === 41 || nextCodePoint === 65289) {
+                  penalty += 50;
+                }
+                return penalty;
+              }
+              function evaluateBreak(breakIndex, breakX, targetWidth, potentialBreaks, penalty, isLastBreak) {
+                var bestPriorBreak = null;
+                var bestBreakBadness = calculateBadness(breakX, targetWidth, penalty, isLastBreak);
+                for (var i2 = 0, list = potentialBreaks; i2 < list.length; i2 += 1) {
+                  var potentialBreak = list[i2];
+                  var lineWidth = breakX - potentialBreak.x;
+                  var breakBadness = calculateBadness(lineWidth, targetWidth, penalty, isLastBreak) + potentialBreak.badness;
+                  if (breakBadness <= bestBreakBadness) {
+                    bestPriorBreak = potentialBreak;
+                    bestBreakBadness = breakBadness;
+                  }
+                }
+                return {
+                  index: breakIndex,
+                  x: breakX,
+                  priorBreak: bestPriorBreak,
+                  badness: bestBreakBadness
+                };
+              }
+              function leastBadBreaks(lastLineBreak) {
+                if (!lastLineBreak) {
+                  return [];
+                }
+                return leastBadBreaks(lastLineBreak.priorBreak).concat(lastLineBreak.index);
+              }
+              function determineLineBreaks(logicalInput, spacing, maxWidth, glyphMap, imagePositions, symbolPlacement, layoutTextSize) {
+                if (symbolPlacement !== "point") {
+                  return [];
+                }
+                if (!logicalInput) {
+                  return [];
+                }
+                var potentialLineBreaks = [];
+                var targetWidth = determineAverageLineWidth(logicalInput, spacing, maxWidth, glyphMap, imagePositions, layoutTextSize);
+                var hasServerSuggestedBreakpoints = logicalInput.text.indexOf("​") >= 0;
+                var currentX = 0;
+                for (var i2 = 0; i2 < logicalInput.length(); i2++) {
+                  var section = logicalInput.getSection(i2);
+                  var codePoint = logicalInput.getCharCode(i2);
+                  if (!whitespace[codePoint]) {
+                    currentX += getGlyphAdvance(codePoint, section, glyphMap, imagePositions, spacing, layoutTextSize);
+                  }
+                  if (i2 < logicalInput.length() - 1) {
+                    var ideographicBreak = charAllowsIdeographicBreaking(codePoint);
+                    if (breakable[codePoint] || ideographicBreak || section.imageName) {
+                      potentialLineBreaks.push(evaluateBreak(i2 + 1, currentX, targetWidth, potentialLineBreaks, calculatePenalty(codePoint, logicalInput.getCharCode(i2 + 1), ideographicBreak && hasServerSuggestedBreakpoints), false));
+                    }
+                  }
+                }
+                return leastBadBreaks(evaluateBreak(logicalInput.length(), currentX, targetWidth, potentialLineBreaks, 0, true));
+              }
+              function getAnchorAlignment(anchor) {
+                var horizontalAlign = 0.5, verticalAlign = 0.5;
+                switch (anchor) {
+                  case "right":
+                  case "top-right":
+                  case "bottom-right":
+                    horizontalAlign = 1;
+                    break;
+                  case "left":
+                  case "top-left":
+                  case "bottom-left":
+                    horizontalAlign = 0;
+                    break;
+                }
+                switch (anchor) {
+                  case "bottom":
+                  case "bottom-right":
+                  case "bottom-left":
+                    verticalAlign = 1;
+                    break;
+                  case "top":
+                  case "top-right":
+                  case "top-left":
+                    verticalAlign = 0;
+                    break;
+                }
+                return {
+                  horizontalAlign,
+                  verticalAlign
+                };
+              }
+              function shapeLines(shaping, glyphMap, glyphPositions, imagePositions, lines, lineHeight, textAnchor, textJustify, writingMode, spacing, allowVerticalPlacement, layoutTextSizeThisZoom) {
+                var x2 = 0;
+                var y2 = SHAPING_DEFAULT_OFFSET;
+                var maxLineLength = 0;
+                var maxLineHeight = 0;
+                var justify = textJustify === "right" ? 1 : textJustify === "left" ? 0 : 0.5;
+                var lineIndex = 0;
+                for (var i$1 = 0, list = lines; i$1 < list.length; i$1 += 1) {
+                  var line = list[i$1];
+                  line.trim();
+                  var lineMaxScale = line.getMaxScale();
+                  var maxLineOffset = (lineMaxScale - 1) * ONE_EM;
+                  var positionedLine = {
+                    positionedGlyphs: [],
+                    lineOffset: 0
+                  };
+                  shaping.positionedLines[lineIndex] = positionedLine;
+                  var positionedGlyphs = positionedLine.positionedGlyphs;
+                  var lineOffset = 0;
+                  if (!line.length()) {
+                    y2 += lineHeight;
+                    ++lineIndex;
+                    continue;
+                  }
+                  for (var i2 = 0; i2 < line.length(); i2++) {
+                    var section = line.getSection(i2);
+                    var sectionIndex = line.getSectionIndex(i2);
+                    var codePoint = line.getCharCode(i2);
+                    var baselineOffset2 = 0;
+                    var metrics = null;
+                    var rect = null;
+                    var imageName = null;
+                    var verticalAdvance = ONE_EM;
+                    var vertical = !(writingMode === WritingMode.horizontal || !allowVerticalPlacement && !charHasUprightVerticalOrientation(codePoint) || allowVerticalPlacement && (whitespace[codePoint] || charInComplexShapingScript(codePoint)));
+                    if (!section.imageName) {
+                      var positions = glyphPositions[section.fontStack];
+                      var glyphPosition = positions && positions[codePoint];
+                      if (glyphPosition && glyphPosition.rect) {
+                        rect = glyphPosition.rect;
+                        metrics = glyphPosition.metrics;
+                      } else {
+                        var glyphs = glyphMap[section.fontStack];
+                        var glyph = glyphs && glyphs[codePoint];
+                        if (!glyph) {
+                          continue;
+                        }
+                        metrics = glyph.metrics;
+                      }
+                      baselineOffset2 = (lineMaxScale - section.scale) * ONE_EM;
+                    } else {
+                      var imagePosition = imagePositions[section.imageName];
+                      if (!imagePosition) {
+                        continue;
+                      }
+                      imageName = section.imageName;
+                      shaping.iconsInText = shaping.iconsInText || true;
+                      rect = imagePosition.paddedRect;
+                      var size = imagePosition.displaySize;
+                      section.scale = section.scale * ONE_EM / layoutTextSizeThisZoom;
+                      metrics = {
+                        width: size[0],
+                        height: size[1],
+                        left: IMAGE_PADDING,
+                        top: -3,
+                        advance: vertical ? size[1] : size[0]
+                      };
+                      var imageOffset = ONE_EM - size[1] * section.scale;
+                      baselineOffset2 = maxLineOffset + imageOffset;
+                      verticalAdvance = metrics.advance;
+                      var offset = vertical ? size[0] * section.scale - ONE_EM * lineMaxScale : size[1] * section.scale - ONE_EM * lineMaxScale;
+                      if (offset > 0 && offset > lineOffset) {
+                        lineOffset = offset;
+                      }
+                    }
+                    if (!vertical) {
+                      positionedGlyphs.push({
+                        glyph: codePoint,
+                        imageName,
+                        x: x2,
+                        y: y2 + baselineOffset2,
+                        vertical,
+                        scale: section.scale,
+                        fontStack: section.fontStack,
+                        sectionIndex,
+                        metrics,
+                        rect
+                      });
+                      x2 += metrics.advance * section.scale + spacing;
+                    } else {
+                      shaping.verticalizable = true;
+                      positionedGlyphs.push({
+                        glyph: codePoint,
+                        imageName,
+                        x: x2,
+                        y: y2 + baselineOffset2,
+                        vertical,
+                        scale: section.scale,
+                        fontStack: section.fontStack,
+                        sectionIndex,
+                        metrics,
+                        rect
+                      });
+                      x2 += verticalAdvance * section.scale + spacing;
+                    }
+                  }
+                  if (positionedGlyphs.length !== 0) {
+                    var lineLength = x2 - spacing;
+                    maxLineLength = Math.max(lineLength, maxLineLength);
+                    justifyLine(positionedGlyphs, 0, positionedGlyphs.length - 1, justify, lineOffset);
+                  }
+                  x2 = 0;
+                  var currentLineHeight = lineHeight * lineMaxScale + lineOffset;
+                  positionedLine.lineOffset = Math.max(lineOffset, maxLineOffset);
+                  y2 += currentLineHeight;
+                  maxLineHeight = Math.max(currentLineHeight, maxLineHeight);
+                  ++lineIndex;
+                }
+                var height = y2 - SHAPING_DEFAULT_OFFSET;
+                var ref = getAnchorAlignment(textAnchor);
+                var horizontalAlign = ref.horizontalAlign;
+                var verticalAlign = ref.verticalAlign;
+                align$1(shaping.positionedLines, justify, horizontalAlign, verticalAlign, maxLineLength, maxLineHeight, lineHeight, height, lines.length);
+                shaping.top += -verticalAlign * height;
+                shaping.bottom = shaping.top + height;
+                shaping.left += -horizontalAlign * maxLineLength;
+                shaping.right = shaping.left + maxLineLength;
+              }
+              function justifyLine(positionedGlyphs, start, end, justify, lineOffset) {
+                if (!justify && !lineOffset) {
+                  return;
+                }
+                var lastPositionedGlyph = positionedGlyphs[end];
+                var lastAdvance = lastPositionedGlyph.metrics.advance * lastPositionedGlyph.scale;
+                var lineIndent = (positionedGlyphs[end].x + lastAdvance) * justify;
+                for (var j2 = start; j2 <= end; j2++) {
+                  positionedGlyphs[j2].x -= lineIndent;
+                  positionedGlyphs[j2].y += lineOffset;
+                }
+              }
+              function align$1(positionedLines, justify, horizontalAlign, verticalAlign, maxLineLength, maxLineHeight, lineHeight, blockHeight, lineCount) {
+                var shiftX = (justify - horizontalAlign) * maxLineLength;
+                var shiftY = 0;
+                if (maxLineHeight !== lineHeight) {
+                  shiftY = -blockHeight * verticalAlign - SHAPING_DEFAULT_OFFSET;
+                } else {
+                  shiftY = (-verticalAlign * lineCount + 0.5) * lineHeight;
+                }
+                for (var i$1 = 0, list$1 = positionedLines; i$1 < list$1.length; i$1 += 1) {
+                  var line = list$1[i$1];
+                  for (var i2 = 0, list = line.positionedGlyphs; i2 < list.length; i2 += 1) {
+                    var positionedGlyph = list[i2];
+                    positionedGlyph.x += shiftX;
+                    positionedGlyph.y += shiftY;
+                  }
+                }
+              }
+              function shapeIcon(image, iconOffset, iconAnchor) {
+                var ref = getAnchorAlignment(iconAnchor);
+                var horizontalAlign = ref.horizontalAlign;
+                var verticalAlign = ref.verticalAlign;
+                var dx = iconOffset[0];
+                var dy = iconOffset[1];
+                var x1 = dx - image.displaySize[0] * horizontalAlign;
+                var x2 = x1 + image.displaySize[0];
+                var y1 = dy - image.displaySize[1] * verticalAlign;
+                var y2 = y1 + image.displaySize[1];
+                return {
+                  image,
+                  top: y1,
+                  bottom: y2,
+                  left: x1,
+                  right: x2
+                };
+              }
+              function fitIconToText(shapedIcon, shapedText, textFit, padding, iconOffset, fontScale) {
+                var image = shapedIcon.image;
+                var collisionPadding;
+                if (image.content) {
+                  var content = image.content;
+                  var pixelRatio = image.pixelRatio || 1;
+                  collisionPadding = [
+                    content[0] / pixelRatio,
+                    content[1] / pixelRatio,
+                    image.displaySize[0] - content[2] / pixelRatio,
+                    image.displaySize[1] - content[3] / pixelRatio
+                  ];
+                }
+                var textLeft = shapedText.left * fontScale;
+                var textRight = shapedText.right * fontScale;
+                var top, right, bottom, left;
+                if (textFit === "width" || textFit === "both") {
+                  left = iconOffset[0] + textLeft - padding[3];
+                  right = iconOffset[0] + textRight + padding[1];
+                } else {
+                  left = iconOffset[0] + (textLeft + textRight - image.displaySize[0]) / 2;
+                  right = left + image.displaySize[0];
+                }
+                var textTop = shapedText.top * fontScale;
+                var textBottom = shapedText.bottom * fontScale;
+                if (textFit === "height" || textFit === "both") {
+                  top = iconOffset[1] + textTop - padding[0];
+                  bottom = iconOffset[1] + textBottom + padding[2];
+                } else {
+                  top = iconOffset[1] + (textTop + textBottom - image.displaySize[1]) / 2;
+                  bottom = top + image.displaySize[1];
+                }
+                return {
+                  image,
+                  top,
+                  right,
+                  bottom,
+                  left,
+                  collisionPadding
+                };
+              }
+              var Anchor = function(Point2) {
+                function Anchor2(x2, y2, angle2, segment) {
+                  Point2.call(this, x2, y2);
+                  this.angle = angle2;
+                  if (segment !== void 0) {
+                    this.segment = segment;
+                  }
+                }
+                if (Point2)
+                  Anchor2.__proto__ = Point2;
+                Anchor2.prototype = Object.create(Point2 && Point2.prototype);
+                Anchor2.prototype.constructor = Anchor2;
+                Anchor2.prototype.clone = function clone2() {
+                  return new Anchor2(this.x, this.y, this.angle, this.segment);
+                };
+                return Anchor2;
+              }(pointGeometry);
+              register2("Anchor", Anchor);
+              var SIZE_PACK_FACTOR = 128;
+              function getSizeData(tileZoom, value) {
+                var expression2 = value.expression;
+                if (expression2.kind === "constant") {
+                  var layoutSize = expression2.evaluate(new EvaluationParameters(tileZoom + 1));
+                  return {
+                    kind: "constant",
+                    layoutSize
+                  };
+                } else if (expression2.kind === "source") {
+                  return { kind: "source" };
+                } else {
+                  var zoomStops = expression2.zoomStops;
+                  var interpolationType = expression2.interpolationType;
+                  var lower = 0;
+                  while (lower < zoomStops.length && zoomStops[lower] <= tileZoom) {
+                    lower++;
+                  }
+                  lower = Math.max(0, lower - 1);
+                  var upper = lower;
+                  while (upper < zoomStops.length && zoomStops[upper] < tileZoom + 1) {
+                    upper++;
+                  }
+                  upper = Math.min(zoomStops.length - 1, upper);
+                  var minZoom = zoomStops[lower];
+                  var maxZoom = zoomStops[upper];
+                  if (expression2.kind === "composite") {
+                    return {
+                      kind: "composite",
+                      minZoom,
+                      maxZoom,
+                      interpolationType
+                    };
+                  }
+                  var minSize = expression2.evaluate(new EvaluationParameters(minZoom));
+                  var maxSize = expression2.evaluate(new EvaluationParameters(maxZoom));
+                  return {
+                    kind: "camera",
+                    minZoom,
+                    maxZoom,
+                    minSize,
+                    maxSize,
+                    interpolationType
+                  };
+                }
+              }
+              function evaluateSizeForFeature(sizeData, ref, ref$1) {
+                var uSize = ref.uSize;
+                var uSizeT = ref.uSizeT;
+                var lowerSize = ref$1.lowerSize;
+                var upperSize = ref$1.upperSize;
+                if (sizeData.kind === "source") {
+                  return lowerSize / SIZE_PACK_FACTOR;
+                } else if (sizeData.kind === "composite") {
+                  return number(lowerSize / SIZE_PACK_FACTOR, upperSize / SIZE_PACK_FACTOR, uSizeT);
+                }
+                return uSize;
+              }
+              function evaluateSizeForZoom(sizeData, zoom) {
+                var uSizeT = 0;
+                var uSize = 0;
+                if (sizeData.kind === "constant") {
+                  uSize = sizeData.layoutSize;
+                } else if (sizeData.kind !== "source") {
+                  var interpolationType = sizeData.interpolationType;
+                  var minZoom = sizeData.minZoom;
+                  var maxZoom = sizeData.maxZoom;
+                  var t4 = !interpolationType ? 0 : clamp2(Interpolate.interpolationFactor(interpolationType, zoom, minZoom, maxZoom), 0, 1);
+                  if (sizeData.kind === "camera") {
+                    uSize = number(sizeData.minSize, sizeData.maxSize, t4);
+                  } else {
+                    uSizeT = t4;
+                  }
+                }
+                return {
+                  uSizeT,
+                  uSize
+                };
+              }
+              var symbolSize = /* @__PURE__ */ Object.freeze({
+                __proto__: null,
+                getSizeData,
+                evaluateSizeForFeature,
+                evaluateSizeForZoom,
+                SIZE_PACK_FACTOR
+              });
+              function checkMaxAngle(line, anchor, labelLength, windowSize, maxAngle) {
+                if (anchor.segment === void 0) {
+                  return true;
+                }
+                var p2 = anchor;
+                var index = anchor.segment + 1;
+                var anchorDistance = 0;
+                while (anchorDistance > -labelLength / 2) {
+                  index--;
+                  if (index < 0) {
+                    return false;
+                  }
+                  anchorDistance -= line[index].dist(p2);
+                  p2 = line[index];
+                }
+                anchorDistance += line[index].dist(line[index + 1]);
+                index++;
+                var recentCorners = [];
+                var recentAngleDelta = 0;
+                while (anchorDistance < labelLength / 2) {
+                  var prev = line[index - 1];
+                  var current = line[index];
+                  var next = line[index + 1];
+                  if (!next) {
+                    return false;
+                  }
+                  var angleDelta = prev.angleTo(current) - current.angleTo(next);
+                  angleDelta = Math.abs((angleDelta + 3 * Math.PI) % (Math.PI * 2) - Math.PI);
+                  recentCorners.push({
+                    distance: anchorDistance,
+                    angleDelta
+                  });
+                  recentAngleDelta += angleDelta;
+                  while (anchorDistance - recentCorners[0].distance > windowSize) {
+                    recentAngleDelta -= recentCorners.shift().angleDelta;
+                  }
+                  if (recentAngleDelta > maxAngle) {
+                    return false;
+                  }
+                  index++;
+                  anchorDistance += current.dist(next);
+                }
+                return true;
+              }
+              function getLineLength(line) {
+                var lineLength = 0;
+                for (var k2 = 0; k2 < line.length - 1; k2++) {
+                  lineLength += line[k2].dist(line[k2 + 1]);
+                }
+                return lineLength;
+              }
+              function getAngleWindowSize(shapedText, glyphSize, boxScale) {
+                return shapedText ? 3 / 5 * glyphSize * boxScale : 0;
+              }
+              function getShapedLabelLength(shapedText, shapedIcon) {
+                return Math.max(shapedText ? shapedText.right - shapedText.left : 0, shapedIcon ? shapedIcon.right - shapedIcon.left : 0);
+              }
+              function getCenterAnchor(line, maxAngle, shapedText, shapedIcon, glyphSize, boxScale) {
+                var angleWindowSize = getAngleWindowSize(shapedText, glyphSize, boxScale);
+                var labelLength = getShapedLabelLength(shapedText, shapedIcon) * boxScale;
+                var prevDistance = 0;
+                var centerDistance = getLineLength(line) / 2;
+                for (var i2 = 0; i2 < line.length - 1; i2++) {
+                  var a2 = line[i2], b2 = line[i2 + 1];
+                  var segmentDistance = a2.dist(b2);
+                  if (prevDistance + segmentDistance > centerDistance) {
+                    var t4 = (centerDistance - prevDistance) / segmentDistance, x2 = number(a2.x, b2.x, t4), y2 = number(a2.y, b2.y, t4);
+                    var anchor = new Anchor(x2, y2, b2.angleTo(a2), i2);
+                    anchor._round();
+                    if (!angleWindowSize || checkMaxAngle(line, anchor, labelLength, angleWindowSize, maxAngle)) {
+                      return anchor;
+                    } else {
+                      return;
+                    }
+                  }
+                  prevDistance += segmentDistance;
+                }
+              }
+              function getAnchors(line, spacing, maxAngle, shapedText, shapedIcon, glyphSize, boxScale, overscaling, tileExtent) {
+                var angleWindowSize = getAngleWindowSize(shapedText, glyphSize, boxScale);
+                var shapedLabelLength = getShapedLabelLength(shapedText, shapedIcon);
+                var labelLength = shapedLabelLength * boxScale;
+                var isLineContinued = line[0].x === 0 || line[0].x === tileExtent || line[0].y === 0 || line[0].y === tileExtent;
+                if (spacing - labelLength < spacing / 4) {
+                  spacing = labelLength + spacing / 4;
+                }
+                var fixedExtraOffset = glyphSize * 2;
+                var offset = !isLineContinued ? (shapedLabelLength / 2 + fixedExtraOffset) * boxScale * overscaling % spacing : spacing / 2 * overscaling % spacing;
+                return resample(line, offset, spacing, angleWindowSize, maxAngle, labelLength, isLineContinued, false, tileExtent);
+              }
+              function resample(line, offset, spacing, angleWindowSize, maxAngle, labelLength, isLineContinued, placeAtMiddle, tileExtent) {
+                var halfLabelLength = labelLength / 2;
+                var lineLength = getLineLength(line);
+                var distance2 = 0, markedDistance = offset - spacing;
+                var anchors = [];
+                for (var i2 = 0; i2 < line.length - 1; i2++) {
+                  var a2 = line[i2], b2 = line[i2 + 1];
+                  var segmentDist = a2.dist(b2), angle2 = b2.angleTo(a2);
+                  while (markedDistance + spacing < distance2 + segmentDist) {
+                    markedDistance += spacing;
+                    var t4 = (markedDistance - distance2) / segmentDist, x2 = number(a2.x, b2.x, t4), y2 = number(a2.y, b2.y, t4);
+                    if (x2 >= 0 && x2 < tileExtent && y2 >= 0 && y2 < tileExtent && markedDistance - halfLabelLength >= 0 && markedDistance + halfLabelLength <= lineLength) {
+                      var anchor = new Anchor(x2, y2, angle2, i2);
+                      anchor._round();
+                      if (!angleWindowSize || checkMaxAngle(line, anchor, labelLength, angleWindowSize, maxAngle)) {
+                        anchors.push(anchor);
+                      }
+                    }
+                  }
+                  distance2 += segmentDist;
+                }
+                if (!placeAtMiddle && !anchors.length && !isLineContinued) {
+                  anchors = resample(line, distance2 / 2, spacing, angleWindowSize, maxAngle, labelLength, isLineContinued, true, tileExtent);
+                }
+                return anchors;
+              }
+              function clipLine(lines, x1, y1, x2, y2) {
+                var clippedLines = [];
+                for (var l2 = 0; l2 < lines.length; l2++) {
+                  var line = lines[l2];
+                  var clippedLine = void 0;
+                  for (var i2 = 0; i2 < line.length - 1; i2++) {
+                    var p0 = line[i2];
+                    var p1 = line[i2 + 1];
+                    if (p0.x < x1 && p1.x < x1) {
+                      continue;
+                    } else if (p0.x < x1) {
+                      p0 = new pointGeometry(x1, p0.y + (p1.y - p0.y) * ((x1 - p0.x) / (p1.x - p0.x)))._round();
+                    } else if (p1.x < x1) {
+                      p1 = new pointGeometry(x1, p0.y + (p1.y - p0.y) * ((x1 - p0.x) / (p1.x - p0.x)))._round();
+                    }
+                    if (p0.y < y1 && p1.y < y1) {
+                      continue;
+                    } else if (p0.y < y1) {
+                      p0 = new pointGeometry(p0.x + (p1.x - p0.x) * ((y1 - p0.y) / (p1.y - p0.y)), y1)._round();
+                    } else if (p1.y < y1) {
+                      p1 = new pointGeometry(p0.x + (p1.x - p0.x) * ((y1 - p0.y) / (p1.y - p0.y)), y1)._round();
+                    }
+                    if (p0.x >= x2 && p1.x >= x2) {
+                      continue;
+                    } else if (p0.x >= x2) {
+                      p0 = new pointGeometry(x2, p0.y + (p1.y - p0.y) * ((x2 - p0.x) / (p1.x - p0.x)))._round();
+                    } else if (p1.x >= x2) {
+                      p1 = new pointGeometry(x2, p0.y + (p1.y - p0.y) * ((x2 - p0.x) / (p1.x - p0.x)))._round();
+                    }
+                    if (p0.y >= y2 && p1.y >= y2) {
+                      continue;
+                    } else if (p0.y >= y2) {
+                      p0 = new pointGeometry(p0.x + (p1.x - p0.x) * ((y2 - p0.y) / (p1.y - p0.y)), y2)._round();
+                    } else if (p1.y >= y2) {
+                      p1 = new pointGeometry(p0.x + (p1.x - p0.x) * ((y2 - p0.y) / (p1.y - p0.y)), y2)._round();
+                    }
+                    if (!clippedLine || !p0.equals(clippedLine[clippedLine.length - 1])) {
+                      clippedLine = [p0];
+                      clippedLines.push(clippedLine);
+                    }
+                    clippedLine.push(p1);
+                  }
+                }
+                return clippedLines;
+              }
+              var border$1 = IMAGE_PADDING;
+              function getIconQuads(shapedIcon, iconRotate, isSDFIcon, hasIconTextFit) {
+                var quads = [];
+                var image = shapedIcon.image;
+                var pixelRatio = image.pixelRatio;
+                var imageWidth = image.paddedRect.w - 2 * border$1;
+                var imageHeight = image.paddedRect.h - 2 * border$1;
+                var iconWidth = shapedIcon.right - shapedIcon.left;
+                var iconHeight = shapedIcon.bottom - shapedIcon.top;
+                var stretchX = image.stretchX || [[
+                  0,
+                  imageWidth
+                ]];
+                var stretchY = image.stretchY || [[
+                  0,
+                  imageHeight
+                ]];
+                var reduceRanges = function(sum, range) {
+                  return sum + range[1] - range[0];
+                };
+                var stretchWidth = stretchX.reduce(reduceRanges, 0);
+                var stretchHeight = stretchY.reduce(reduceRanges, 0);
+                var fixedWidth = imageWidth - stretchWidth;
+                var fixedHeight = imageHeight - stretchHeight;
+                var stretchOffsetX = 0;
+                var stretchContentWidth = stretchWidth;
+                var stretchOffsetY = 0;
+                var stretchContentHeight = stretchHeight;
+                var fixedOffsetX = 0;
+                var fixedContentWidth = fixedWidth;
+                var fixedOffsetY = 0;
+                var fixedContentHeight = fixedHeight;
+                if (image.content && hasIconTextFit) {
+                  var content = image.content;
+                  stretchOffsetX = sumWithinRange(stretchX, 0, content[0]);
+                  stretchOffsetY = sumWithinRange(stretchY, 0, content[1]);
+                  stretchContentWidth = sumWithinRange(stretchX, content[0], content[2]);
+                  stretchContentHeight = sumWithinRange(stretchY, content[1], content[3]);
+                  fixedOffsetX = content[0] - stretchOffsetX;
+                  fixedOffsetY = content[1] - stretchOffsetY;
+                  fixedContentWidth = content[2] - content[0] - stretchContentWidth;
+                  fixedContentHeight = content[3] - content[1] - stretchContentHeight;
+                }
+                var makeBox = function(left, top, right, bottom) {
+                  var leftEm = getEmOffset(left.stretch - stretchOffsetX, stretchContentWidth, iconWidth, shapedIcon.left);
+                  var leftPx = getPxOffset(left.fixed - fixedOffsetX, fixedContentWidth, left.stretch, stretchWidth);
+                  var topEm = getEmOffset(top.stretch - stretchOffsetY, stretchContentHeight, iconHeight, shapedIcon.top);
+                  var topPx = getPxOffset(top.fixed - fixedOffsetY, fixedContentHeight, top.stretch, stretchHeight);
+                  var rightEm = getEmOffset(right.stretch - stretchOffsetX, stretchContentWidth, iconWidth, shapedIcon.left);
+                  var rightPx = getPxOffset(right.fixed - fixedOffsetX, fixedContentWidth, right.stretch, stretchWidth);
+                  var bottomEm = getEmOffset(bottom.stretch - stretchOffsetY, stretchContentHeight, iconHeight, shapedIcon.top);
+                  var bottomPx = getPxOffset(bottom.fixed - fixedOffsetY, fixedContentHeight, bottom.stretch, stretchHeight);
+                  var tl2 = new pointGeometry(leftEm, topEm);
+                  var tr = new pointGeometry(rightEm, topEm);
+                  var br = new pointGeometry(rightEm, bottomEm);
+                  var bl2 = new pointGeometry(leftEm, bottomEm);
+                  var pixelOffsetTL = new pointGeometry(leftPx / pixelRatio, topPx / pixelRatio);
+                  var pixelOffsetBR = new pointGeometry(rightPx / pixelRatio, bottomPx / pixelRatio);
+                  var angle2 = iconRotate * Math.PI / 180;
+                  if (angle2) {
+                    var sin = Math.sin(angle2), cos = Math.cos(angle2), matrix = [
+                      cos,
+                      -sin,
+                      sin,
+                      cos
+                    ];
+                    tl2._matMult(matrix);
+                    tr._matMult(matrix);
+                    bl2._matMult(matrix);
+                    br._matMult(matrix);
+                  }
+                  var x12 = left.stretch + left.fixed;
+                  var x22 = right.stretch + right.fixed;
+                  var y12 = top.stretch + top.fixed;
+                  var y22 = bottom.stretch + bottom.fixed;
+                  var subRect = {
+                    x: image.paddedRect.x + border$1 + x12,
+                    y: image.paddedRect.y + border$1 + y12,
+                    w: x22 - x12,
+                    h: y22 - y12
+                  };
+                  var minFontScaleX = fixedContentWidth / pixelRatio / iconWidth;
+                  var minFontScaleY = fixedContentHeight / pixelRatio / iconHeight;
+                  return {
+                    tl: tl2,
+                    tr,
+                    bl: bl2,
+                    br,
+                    tex: subRect,
+                    writingMode: void 0,
+                    glyphOffset: [
+                      0,
+                      0
+                    ],
+                    sectionIndex: 0,
+                    pixelOffsetTL,
+                    pixelOffsetBR,
+                    minFontScaleX,
+                    minFontScaleY,
+                    isSDF: isSDFIcon
+                  };
+                };
+                if (!hasIconTextFit || !image.stretchX && !image.stretchY) {
+                  quads.push(makeBox({
+                    fixed: 0,
+                    stretch: -1
+                  }, {
+                    fixed: 0,
+                    stretch: -1
+                  }, {
+                    fixed: 0,
+                    stretch: imageWidth + 1
+                  }, {
+                    fixed: 0,
+                    stretch: imageHeight + 1
+                  }));
+                } else {
+                  var xCuts = stretchZonesToCuts(stretchX, fixedWidth, stretchWidth);
+                  var yCuts = stretchZonesToCuts(stretchY, fixedHeight, stretchHeight);
+                  for (var xi2 = 0; xi2 < xCuts.length - 1; xi2++) {
+                    var x1 = xCuts[xi2];
+                    var x2 = xCuts[xi2 + 1];
+                    for (var yi2 = 0; yi2 < yCuts.length - 1; yi2++) {
+                      var y1 = yCuts[yi2];
+                      var y2 = yCuts[yi2 + 1];
+                      quads.push(makeBox(x1, y1, x2, y2));
+                    }
+                  }
+                }
+                return quads;
+              }
+              function sumWithinRange(ranges, min, max) {
+                var sum = 0;
+                for (var i2 = 0, list = ranges; i2 < list.length; i2 += 1) {
+                  var range = list[i2];
+                  sum += Math.max(min, Math.min(max, range[1])) - Math.max(min, Math.min(max, range[0]));
+                }
+                return sum;
+              }
+              function stretchZonesToCuts(stretchZones, fixedSize, stretchSize) {
+                var cuts = [{
+                  fixed: -1,
+                  stretch: 0
+                }];
+                for (var i2 = 0, list = stretchZones; i2 < list.length; i2 += 1) {
+                  var ref = list[i2];
+                  var c1 = ref[0];
+                  var c2 = ref[1];
+                  var last = cuts[cuts.length - 1];
+                  cuts.push({
+                    fixed: c1 - last.stretch,
+                    stretch: last.stretch
+                  });
+                  cuts.push({
+                    fixed: c1 - last.stretch,
+                    stretch: last.stretch + (c2 - c1)
+                  });
+                }
+                cuts.push({
+                  fixed: fixedSize + border$1,
+                  stretch: stretchSize
+                });
+                return cuts;
+              }
+              function getEmOffset(stretchOffset, stretchSize, iconSize, iconOffset) {
+                return stretchOffset / stretchSize * iconSize + iconOffset;
+              }
+              function getPxOffset(fixedOffset, fixedSize, stretchOffset, stretchSize) {
+                return fixedOffset - fixedSize * stretchOffset / stretchSize;
+              }
+              function getGlyphQuads(anchor, shaping, textOffset, layer2, alongLine, feature, imageMap, allowVerticalPlacement) {
+                var textRotate = layer2.layout.get("text-rotate").evaluate(feature, {}) * Math.PI / 180;
+                var quads = [];
+                for (var i$1 = 0, list$1 = shaping.positionedLines; i$1 < list$1.length; i$1 += 1) {
+                  var line = list$1[i$1];
+                  for (var i2 = 0, list = line.positionedGlyphs; i2 < list.length; i2 += 1) {
+                    var positionedGlyph = list[i2];
+                    if (!positionedGlyph.rect) {
+                      continue;
+                    }
+                    var textureRect = positionedGlyph.rect || {};
+                    var glyphPadding = 1;
+                    var rectBuffer = GLYPH_PBF_BORDER + glyphPadding;
+                    var isSDF = true;
+                    var pixelRatio = 1;
+                    var lineOffset = 0;
+                    var rotateVerticalGlyph = (alongLine || allowVerticalPlacement) && positionedGlyph.vertical;
+                    var halfAdvance = positionedGlyph.metrics.advance * positionedGlyph.scale / 2;
+                    if (allowVerticalPlacement && shaping.verticalizable) {
+                      var scaledGlyphOffset = (positionedGlyph.scale - 1) * ONE_EM;
+                      var imageOffset = (ONE_EM - positionedGlyph.metrics.width * positionedGlyph.scale) / 2;
+                      lineOffset = line.lineOffset / 2 - (positionedGlyph.imageName ? -imageOffset : scaledGlyphOffset);
+                    }
+                    if (positionedGlyph.imageName) {
+                      var image = imageMap[positionedGlyph.imageName];
+                      isSDF = image.sdf;
+                      pixelRatio = image.pixelRatio;
+                      rectBuffer = IMAGE_PADDING / pixelRatio;
+                    }
+                    var glyphOffset2 = alongLine ? [
+                      positionedGlyph.x + halfAdvance,
+                      positionedGlyph.y
+                    ] : [
+                      0,
+                      0
+                    ];
+                    var builtInOffset = alongLine ? [
+                      0,
+                      0
+                    ] : [
+                      positionedGlyph.x + halfAdvance + textOffset[0],
+                      positionedGlyph.y + textOffset[1] - lineOffset
+                    ];
+                    var verticalizedLabelOffset = [
+                      0,
+                      0
+                    ];
+                    if (rotateVerticalGlyph) {
+                      verticalizedLabelOffset = builtInOffset;
+                      builtInOffset = [
+                        0,
+                        0
+                      ];
+                    }
+                    var x1 = (positionedGlyph.metrics.left - rectBuffer) * positionedGlyph.scale - halfAdvance + builtInOffset[0];
+                    var y1 = (-positionedGlyph.metrics.top - rectBuffer) * positionedGlyph.scale + builtInOffset[1];
+                    var x2 = x1 + textureRect.w * positionedGlyph.scale / pixelRatio;
+                    var y2 = y1 + textureRect.h * positionedGlyph.scale / pixelRatio;
+                    var tl2 = new pointGeometry(x1, y1);
+                    var tr = new pointGeometry(x2, y1);
+                    var bl2 = new pointGeometry(x1, y2);
+                    var br = new pointGeometry(x2, y2);
+                    if (rotateVerticalGlyph) {
+                      var center = new pointGeometry(-halfAdvance, halfAdvance - SHAPING_DEFAULT_OFFSET);
+                      var verticalRotation = -Math.PI / 2;
+                      var xHalfWidthOffsetCorrection = ONE_EM / 2 - halfAdvance;
+                      var yImageOffsetCorrection = positionedGlyph.imageName ? xHalfWidthOffsetCorrection : 0;
+                      var halfWidthOffsetCorrection = new pointGeometry(5 - SHAPING_DEFAULT_OFFSET - xHalfWidthOffsetCorrection, -yImageOffsetCorrection);
+                      var verticalOffsetCorrection = new (Function.prototype.bind.apply(pointGeometry, [null].concat(verticalizedLabelOffset)))();
+                      tl2._rotateAround(verticalRotation, center)._add(halfWidthOffsetCorrection)._add(verticalOffsetCorrection);
+                      tr._rotateAround(verticalRotation, center)._add(halfWidthOffsetCorrection)._add(verticalOffsetCorrection);
+                      bl2._rotateAround(verticalRotation, center)._add(halfWidthOffsetCorrection)._add(verticalOffsetCorrection);
+                      br._rotateAround(verticalRotation, center)._add(halfWidthOffsetCorrection)._add(verticalOffsetCorrection);
+                    }
+                    if (textRotate) {
+                      var sin = Math.sin(textRotate), cos = Math.cos(textRotate), matrix = [
+                        cos,
+                        -sin,
+                        sin,
+                        cos
+                      ];
+                      tl2._matMult(matrix);
+                      tr._matMult(matrix);
+                      bl2._matMult(matrix);
+                      br._matMult(matrix);
+                    }
+                    var pixelOffsetTL = new pointGeometry(0, 0);
+                    var pixelOffsetBR = new pointGeometry(0, 0);
+                    var minFontScaleX = 0;
+                    var minFontScaleY = 0;
+                    quads.push({
+                      tl: tl2,
+                      tr,
+                      bl: bl2,
+                      br,
+                      tex: textureRect,
+                      writingMode: shaping.writingMode,
+                      glyphOffset: glyphOffset2,
+                      sectionIndex: positionedGlyph.sectionIndex,
+                      isSDF,
+                      pixelOffsetTL,
+                      pixelOffsetBR,
+                      minFontScaleX,
+                      minFontScaleY
+                    });
+                  }
+                }
+                return quads;
+              }
+              var CollisionFeature = function CollisionFeature2(collisionBoxArray, anchor, featureIndex, sourceLayerIndex, bucketIndex, shaped, boxScale, padding, alignLine, rotate22) {
+                this.boxStartIndex = collisionBoxArray.length;
+                if (alignLine) {
+                  var top = shaped.top;
+                  var bottom = shaped.bottom;
+                  var collisionPadding = shaped.collisionPadding;
+                  if (collisionPadding) {
+                    top -= collisionPadding[1];
+                    bottom += collisionPadding[3];
+                  }
+                  var height = bottom - top;
+                  if (height > 0) {
+                    height = Math.max(10, height);
+                    this.circleDiameter = height;
+                  }
+                } else {
+                  var y1 = shaped.top * boxScale - padding;
+                  var y2 = shaped.bottom * boxScale + padding;
+                  var x1 = shaped.left * boxScale - padding;
+                  var x2 = shaped.right * boxScale + padding;
+                  var collisionPadding$1 = shaped.collisionPadding;
+                  if (collisionPadding$1) {
+                    x1 -= collisionPadding$1[0] * boxScale;
+                    y1 -= collisionPadding$1[1] * boxScale;
+                    x2 += collisionPadding$1[2] * boxScale;
+                    y2 += collisionPadding$1[3] * boxScale;
+                  }
+                  if (rotate22) {
+                    var tl2 = new pointGeometry(x1, y1);
+                    var tr = new pointGeometry(x2, y1);
+                    var bl2 = new pointGeometry(x1, y2);
+                    var br = new pointGeometry(x2, y2);
+                    var rotateRadians = rotate22 * Math.PI / 180;
+                    tl2._rotate(rotateRadians);
+                    tr._rotate(rotateRadians);
+                    bl2._rotate(rotateRadians);
+                    br._rotate(rotateRadians);
+                    x1 = Math.min(tl2.x, tr.x, bl2.x, br.x);
+                    x2 = Math.max(tl2.x, tr.x, bl2.x, br.x);
+                    y1 = Math.min(tl2.y, tr.y, bl2.y, br.y);
+                    y2 = Math.max(tl2.y, tr.y, bl2.y, br.y);
+                  }
+                  collisionBoxArray.emplaceBack(anchor.x, anchor.y, x1, y1, x2, y2, featureIndex, sourceLayerIndex, bucketIndex);
+                }
+                this.boxEndIndex = collisionBoxArray.length;
+              };
+              var TinyQueue = function TinyQueue2(data, compare2) {
+                if (data === void 0)
+                  data = [];
+                if (compare2 === void 0)
+                  compare2 = defaultCompare$1;
+                this.data = data;
+                this.length = this.data.length;
+                this.compare = compare2;
+                if (this.length > 0) {
+                  for (var i2 = (this.length >> 1) - 1; i2 >= 0; i2--) {
+                    this._down(i2);
+                  }
+                }
+              };
+              TinyQueue.prototype.push = function push(item) {
+                this.data.push(item);
+                this.length++;
+                this._up(this.length - 1);
+              };
+              TinyQueue.prototype.pop = function pop() {
+                if (this.length === 0) {
+                  return void 0;
+                }
+                var top = this.data[0];
+                var bottom = this.data.pop();
+                this.length--;
+                if (this.length > 0) {
+                  this.data[0] = bottom;
+                  this._down(0);
+                }
+                return top;
+              };
+              TinyQueue.prototype.peek = function peek() {
+                return this.data[0];
+              };
+              TinyQueue.prototype._up = function _up(pos) {
+                var ref = this;
+                var data = ref.data;
+                var compare2 = ref.compare;
+                var item = data[pos];
+                while (pos > 0) {
+                  var parent = pos - 1 >> 1;
+                  var current = data[parent];
+                  if (compare2(item, current) >= 0) {
+                    break;
+                  }
+                  data[pos] = current;
+                  pos = parent;
+                }
+                data[pos] = item;
+              };
+              TinyQueue.prototype._down = function _down(pos) {
+                var ref = this;
+                var data = ref.data;
+                var compare2 = ref.compare;
+                var halfLength = this.length >> 1;
+                var item = data[pos];
+                while (pos < halfLength) {
+                  var left = (pos << 1) + 1;
+                  var best = data[left];
+                  var right = left + 1;
+                  if (right < this.length && compare2(data[right], best) < 0) {
+                    left = right;
+                    best = data[right];
+                  }
+                  if (compare2(best, item) >= 0) {
+                    break;
+                  }
+                  data[pos] = best;
+                  pos = left;
+                }
+                data[pos] = item;
+              };
+              function defaultCompare$1(a2, b2) {
+                return a2 < b2 ? -1 : a2 > b2 ? 1 : 0;
+              }
+              function findPoleOfInaccessibility(polygonRings, precision, debug2) {
+                if (debug2 === void 0)
+                  debug2 = false;
+                var minX = Infinity, minY = Infinity, maxX = -Infinity, maxY = -Infinity;
+                var outerRing = polygonRings[0];
+                for (var i2 = 0; i2 < outerRing.length; i2++) {
+                  var p2 = outerRing[i2];
+                  if (!i2 || p2.x < minX) {
+                    minX = p2.x;
+                  }
+                  if (!i2 || p2.y < minY) {
+                    minY = p2.y;
+                  }
+                  if (!i2 || p2.x > maxX) {
+                    maxX = p2.x;
+                  }
+                  if (!i2 || p2.y > maxY) {
+                    maxY = p2.y;
+                  }
+                }
+                var width = maxX - minX;
+                var height = maxY - minY;
+                var cellSize = Math.min(width, height);
+                var h2 = cellSize / 2;
+                var cellQueue = new TinyQueue([], compareMax);
+                if (cellSize === 0) {
+                  return new pointGeometry(minX, minY);
+                }
+                for (var x2 = minX; x2 < maxX; x2 += cellSize) {
+                  for (var y2 = minY; y2 < maxY; y2 += cellSize) {
+                    cellQueue.push(new Cell(x2 + h2, y2 + h2, h2, polygonRings));
+                  }
+                }
+                var bestCell = getCentroidCell(polygonRings);
+                var numProbes = cellQueue.length;
+                while (cellQueue.length) {
+                  var cell = cellQueue.pop();
+                  if (cell.d > bestCell.d || !bestCell.d) {
+                    bestCell = cell;
+                    if (debug2) {
+                      console.log("found best %d after %d probes", Math.round(1e4 * cell.d) / 1e4, numProbes);
+                    }
+                  }
+                  if (cell.max - bestCell.d <= precision) {
+                    continue;
+                  }
+                  h2 = cell.h / 2;
+                  cellQueue.push(new Cell(cell.p.x - h2, cell.p.y - h2, h2, polygonRings));
+                  cellQueue.push(new Cell(cell.p.x + h2, cell.p.y - h2, h2, polygonRings));
+                  cellQueue.push(new Cell(cell.p.x - h2, cell.p.y + h2, h2, polygonRings));
+                  cellQueue.push(new Cell(cell.p.x + h2, cell.p.y + h2, h2, polygonRings));
+                  numProbes += 4;
+                }
+                if (debug2) {
+                  console.log("num probes: " + numProbes);
+                  console.log("best distance: " + bestCell.d);
+                }
+                return bestCell.p;
+              }
+              function compareMax(a2, b2) {
+                return b2.max - a2.max;
+              }
+              function Cell(x2, y2, h2, polygon) {
+                this.p = new pointGeometry(x2, y2);
+                this.h = h2;
+                this.d = pointToPolygonDist(this.p, polygon);
+                this.max = this.d + this.h * Math.SQRT2;
+              }
+              function pointToPolygonDist(p2, polygon) {
+                var inside = false;
+                var minDistSq = Infinity;
+                for (var k2 = 0; k2 < polygon.length; k2++) {
+                  var ring = polygon[k2];
+                  for (var i2 = 0, len2 = ring.length, j2 = len2 - 1; i2 < len2; j2 = i2++) {
+                    var a2 = ring[i2];
+                    var b2 = ring[j2];
+                    if (a2.y > p2.y !== b2.y > p2.y && p2.x < (b2.x - a2.x) * (p2.y - a2.y) / (b2.y - a2.y) + a2.x) {
+                      inside = !inside;
+                    }
+                    minDistSq = Math.min(minDistSq, distToSegmentSquared(p2, a2, b2));
+                  }
+                }
+                return (inside ? 1 : -1) * Math.sqrt(minDistSq);
+              }
+              function getCentroidCell(polygon) {
+                var area2 = 0;
+                var x2 = 0;
+                var y2 = 0;
+                var points = polygon[0];
+                for (var i2 = 0, len2 = points.length, j2 = len2 - 1; i2 < len2; j2 = i2++) {
+                  var a2 = points[i2];
+                  var b2 = points[j2];
+                  var f2 = a2.x * b2.y - b2.x * a2.y;
+                  x2 += (a2.x + b2.x) * f2;
+                  y2 += (a2.y + b2.y) * f2;
+                  area2 += f2 * 3;
+                }
+                return new Cell(x2 / area2, y2 / area2, 0, polygon);
+              }
+              var baselineOffset = 7;
+              var INVALID_TEXT_OFFSET = Number.POSITIVE_INFINITY;
+              function evaluateVariableOffset(anchor, offset) {
+                function fromRadialOffset(anchor2, radialOffset) {
+                  var x2 = 0, y2 = 0;
+                  if (radialOffset < 0) {
+                    radialOffset = 0;
+                  }
+                  var hypotenuse = radialOffset / Math.sqrt(2);
+                  switch (anchor2) {
+                    case "top-right":
+                    case "top-left":
+                      y2 = hypotenuse - baselineOffset;
+                      break;
+                    case "bottom-right":
+                    case "bottom-left":
+                      y2 = -hypotenuse + baselineOffset;
+                      break;
+                    case "bottom":
+                      y2 = -radialOffset + baselineOffset;
+                      break;
+                    case "top":
+                      y2 = radialOffset - baselineOffset;
+                      break;
+                  }
+                  switch (anchor2) {
+                    case "top-right":
+                    case "bottom-right":
+                      x2 = -hypotenuse;
+                      break;
+                    case "top-left":
+                    case "bottom-left":
+                      x2 = hypotenuse;
+                      break;
+                    case "left":
+                      x2 = radialOffset;
+                      break;
+                    case "right":
+                      x2 = -radialOffset;
+                      break;
+                  }
+                  return [
+                    x2,
+                    y2
+                  ];
+                }
+                function fromTextOffset(anchor2, offsetX, offsetY) {
+                  var x2 = 0, y2 = 0;
+                  offsetX = Math.abs(offsetX);
+                  offsetY = Math.abs(offsetY);
+                  switch (anchor2) {
+                    case "top-right":
+                    case "top-left":
+                    case "top":
+                      y2 = offsetY - baselineOffset;
+                      break;
+                    case "bottom-right":
+                    case "bottom-left":
+                    case "bottom":
+                      y2 = -offsetY + baselineOffset;
+                      break;
+                  }
+                  switch (anchor2) {
+                    case "top-right":
+                    case "bottom-right":
+                    case "right":
+                      x2 = -offsetX;
+                      break;
+                    case "top-left":
+                    case "bottom-left":
+                    case "left":
+                      x2 = offsetX;
+                      break;
+                  }
+                  return [
+                    x2,
+                    y2
+                  ];
+                }
+                return offset[1] !== INVALID_TEXT_OFFSET ? fromTextOffset(anchor, offset[0], offset[1]) : fromRadialOffset(anchor, offset[0]);
+              }
+              function performSymbolLayout(bucket, glyphMap, glyphPositions, imageMap, imagePositions, showCollisionBoxes, canonical) {
+                bucket.createArrays();
+                var tileSize = 512 * bucket.overscaling;
+                bucket.tilePixelRatio = EXTENT$1 / tileSize;
+                bucket.compareText = {};
+                bucket.iconsNeedLinear = false;
+                var layout2 = bucket.layers[0].layout;
+                var unevaluatedLayoutValues = bucket.layers[0]._unevaluatedLayout._values;
+                var sizes = {};
+                if (bucket.textSizeData.kind === "composite") {
+                  var ref = bucket.textSizeData;
+                  var minZoom = ref.minZoom;
+                  var maxZoom = ref.maxZoom;
+                  sizes.compositeTextSizes = [
+                    unevaluatedLayoutValues["text-size"].possiblyEvaluate(new EvaluationParameters(minZoom), canonical),
+                    unevaluatedLayoutValues["text-size"].possiblyEvaluate(new EvaluationParameters(maxZoom), canonical)
+                  ];
+                }
+                if (bucket.iconSizeData.kind === "composite") {
+                  var ref$1 = bucket.iconSizeData;
+                  var minZoom$1 = ref$1.minZoom;
+                  var maxZoom$1 = ref$1.maxZoom;
+                  sizes.compositeIconSizes = [
+                    unevaluatedLayoutValues["icon-size"].possiblyEvaluate(new EvaluationParameters(minZoom$1), canonical),
+                    unevaluatedLayoutValues["icon-size"].possiblyEvaluate(new EvaluationParameters(maxZoom$1), canonical)
+                  ];
+                }
+                sizes.layoutTextSize = unevaluatedLayoutValues["text-size"].possiblyEvaluate(new EvaluationParameters(bucket.zoom + 1), canonical);
+                sizes.layoutIconSize = unevaluatedLayoutValues["icon-size"].possiblyEvaluate(new EvaluationParameters(bucket.zoom + 1), canonical);
+                sizes.textMaxSize = unevaluatedLayoutValues["text-size"].possiblyEvaluate(new EvaluationParameters(18));
+                var lineHeight = layout2.get("text-line-height") * ONE_EM;
+                var textAlongLine = layout2.get("text-rotation-alignment") === "map" && layout2.get("symbol-placement") !== "point";
+                var keepUpright = layout2.get("text-keep-upright");
+                var textSize = layout2.get("text-size");
+                var loop = function() {
+                  var feature = list[i$1];
+                  var fontstack = layout2.get("text-font").evaluate(feature, {}, canonical).join(",");
+                  var layoutTextSizeThisZoom = textSize.evaluate(feature, {}, canonical);
+                  var layoutTextSize = sizes.layoutTextSize.evaluate(feature, {}, canonical);
+                  var layoutIconSize = sizes.layoutIconSize.evaluate(feature, {}, canonical);
+                  var shapedTextOrientations = {
+                    horizontal: {},
+                    vertical: void 0
+                  };
+                  var text = feature.text;
+                  var textOffset = [
+                    0,
+                    0
+                  ];
+                  if (text) {
+                    var unformattedText = text.toString();
+                    var spacing = layout2.get("text-letter-spacing").evaluate(feature, {}, canonical) * ONE_EM;
+                    var spacingIfAllowed = allowsLetterSpacing(unformattedText) ? spacing : 0;
+                    var textAnchor = layout2.get("text-anchor").evaluate(feature, {}, canonical);
+                    var variableTextAnchor = layout2.get("text-variable-anchor");
+                    if (!variableTextAnchor) {
+                      var radialOffset = layout2.get("text-radial-offset").evaluate(feature, {}, canonical);
+                      if (radialOffset) {
+                        textOffset = evaluateVariableOffset(textAnchor, [
+                          radialOffset * ONE_EM,
+                          INVALID_TEXT_OFFSET
+                        ]);
+                      } else {
+                        textOffset = layout2.get("text-offset").evaluate(feature, {}, canonical).map(function(t4) {
+                          return t4 * ONE_EM;
+                        });
+                      }
+                    }
+                    var textJustify = textAlongLine ? "center" : layout2.get("text-justify").evaluate(feature, {}, canonical);
+                    var symbolPlacement = layout2.get("symbol-placement");
+                    var maxWidth = symbolPlacement === "point" ? layout2.get("text-max-width").evaluate(feature, {}, canonical) * ONE_EM : 0;
+                    var addVerticalShapingForPointLabelIfNeeded = function() {
+                      if (bucket.allowVerticalPlacement && allowsVerticalWritingMode(unformattedText)) {
+                        shapedTextOrientations.vertical = shapeText(text, glyphMap, glyphPositions, imagePositions, fontstack, maxWidth, lineHeight, textAnchor, "left", spacingIfAllowed, textOffset, WritingMode.vertical, true, symbolPlacement, layoutTextSize, layoutTextSizeThisZoom);
+                      }
+                    };
+                    if (!textAlongLine && variableTextAnchor) {
+                      var justifications = textJustify === "auto" ? variableTextAnchor.map(function(a2) {
+                        return getAnchorJustification(a2);
+                      }) : [textJustify];
+                      var singleLine = false;
+                      for (var i2 = 0; i2 < justifications.length; i2++) {
+                        var justification = justifications[i2];
+                        if (shapedTextOrientations.horizontal[justification]) {
+                          continue;
+                        }
+                        if (singleLine) {
+                          shapedTextOrientations.horizontal[justification] = shapedTextOrientations.horizontal[0];
+                        } else {
+                          var shaping = shapeText(text, glyphMap, glyphPositions, imagePositions, fontstack, maxWidth, lineHeight, "center", justification, spacingIfAllowed, textOffset, WritingMode.horizontal, false, symbolPlacement, layoutTextSize, layoutTextSizeThisZoom);
+                          if (shaping) {
+                            shapedTextOrientations.horizontal[justification] = shaping;
+                            singleLine = shaping.positionedLines.length === 1;
+                          }
+                        }
+                      }
+                      addVerticalShapingForPointLabelIfNeeded();
+                    } else {
+                      if (textJustify === "auto") {
+                        textJustify = getAnchorJustification(textAnchor);
+                      }
+                      var shaping$1 = shapeText(text, glyphMap, glyphPositions, imagePositions, fontstack, maxWidth, lineHeight, textAnchor, textJustify, spacingIfAllowed, textOffset, WritingMode.horizontal, false, symbolPlacement, layoutTextSize, layoutTextSizeThisZoom);
+                      if (shaping$1) {
+                        shapedTextOrientations.horizontal[textJustify] = shaping$1;
+                      }
+                      addVerticalShapingForPointLabelIfNeeded();
+                      if (allowsVerticalWritingMode(unformattedText) && textAlongLine && keepUpright) {
+                        shapedTextOrientations.vertical = shapeText(text, glyphMap, glyphPositions, imagePositions, fontstack, maxWidth, lineHeight, textAnchor, textJustify, spacingIfAllowed, textOffset, WritingMode.vertical, false, symbolPlacement, layoutTextSize, layoutTextSizeThisZoom);
+                      }
+                    }
+                  }
+                  var shapedIcon = void 0;
+                  var isSDFIcon = false;
+                  if (feature.icon && feature.icon.name) {
+                    var image = imageMap[feature.icon.name];
+                    if (image) {
+                      shapedIcon = shapeIcon(imagePositions[feature.icon.name], layout2.get("icon-offset").evaluate(feature, {}, canonical), layout2.get("icon-anchor").evaluate(feature, {}, canonical));
+                      isSDFIcon = image.sdf;
+                      if (bucket.sdfIcons === void 0) {
+                        bucket.sdfIcons = image.sdf;
+                      } else if (bucket.sdfIcons !== image.sdf) {
+                        warnOnce("Style sheet warning: Cannot mix SDF and non-SDF icons in one buffer");
+                      }
+                      if (image.pixelRatio !== bucket.pixelRatio) {
+                        bucket.iconsNeedLinear = true;
+                      } else if (layout2.get("icon-rotate").constantOr(1) !== 0) {
+                        bucket.iconsNeedLinear = true;
+                      }
+                    }
+                  }
+                  var shapedText = getDefaultHorizontalShaping(shapedTextOrientations.horizontal) || shapedTextOrientations.vertical;
+                  bucket.iconsInText = shapedText ? shapedText.iconsInText : false;
+                  if (shapedText || shapedIcon) {
+                    addFeature(bucket, feature, shapedTextOrientations, shapedIcon, imageMap, sizes, layoutTextSize, layoutIconSize, textOffset, isSDFIcon, canonical);
+                  }
+                };
+                for (var i$1 = 0, list = bucket.features; i$1 < list.length; i$1 += 1)
+                  loop();
+                if (showCollisionBoxes) {
+                  bucket.generateCollisionDebugBuffers();
+                }
+              }
+              function getAnchorJustification(anchor) {
+                switch (anchor) {
+                  case "right":
+                  case "top-right":
+                  case "bottom-right":
+                    return "right";
+                  case "left":
+                  case "top-left":
+                  case "bottom-left":
+                    return "left";
+                }
+                return "center";
+              }
+              function addFeature(bucket, feature, shapedTextOrientations, shapedIcon, imageMap, sizes, layoutTextSize, layoutIconSize, textOffset, isSDFIcon, canonical) {
+                var textMaxSize = sizes.textMaxSize.evaluate(feature, {});
+                if (textMaxSize === void 0) {
+                  textMaxSize = layoutTextSize;
+                }
+                var layout2 = bucket.layers[0].layout;
+                var iconOffset = layout2.get("icon-offset").evaluate(feature, {}, canonical);
+                var defaultHorizontalShaping = getDefaultHorizontalShaping(shapedTextOrientations.horizontal);
+                var glyphSize = 24, fontScale = layoutTextSize / glyphSize, textBoxScale = bucket.tilePixelRatio * fontScale, textMaxBoxScale = bucket.tilePixelRatio * textMaxSize / glyphSize, iconBoxScale = bucket.tilePixelRatio * layoutIconSize, symbolMinDistance = bucket.tilePixelRatio * layout2.get("symbol-spacing"), textPadding = layout2.get("text-padding") * bucket.tilePixelRatio, iconPadding = layout2.get("icon-padding") * bucket.tilePixelRatio, textMaxAngle = layout2.get("text-max-angle") / 180 * Math.PI, textAlongLine = layout2.get("text-rotation-alignment") === "map" && layout2.get("symbol-placement") !== "point", iconAlongLine = layout2.get("icon-rotation-alignment") === "map" && layout2.get("symbol-placement") !== "point", symbolPlacement = layout2.get("symbol-placement"), textRepeatDistance = symbolMinDistance / 2;
+                var iconTextFit = layout2.get("icon-text-fit");
+                var verticallyShapedIcon;
+                if (shapedIcon && iconTextFit !== "none") {
+                  if (bucket.allowVerticalPlacement && shapedTextOrientations.vertical) {
+                    verticallyShapedIcon = fitIconToText(shapedIcon, shapedTextOrientations.vertical, iconTextFit, layout2.get("icon-text-fit-padding"), iconOffset, fontScale);
+                  }
+                  if (defaultHorizontalShaping) {
+                    shapedIcon = fitIconToText(shapedIcon, defaultHorizontalShaping, iconTextFit, layout2.get("icon-text-fit-padding"), iconOffset, fontScale);
+                  }
+                }
+                var addSymbolAtAnchor = function(line2, anchor2) {
+                  if (anchor2.x < 0 || anchor2.x >= EXTENT$1 || anchor2.y < 0 || anchor2.y >= EXTENT$1) {
+                    return;
+                  }
+                  addSymbol(bucket, anchor2, line2, shapedTextOrientations, shapedIcon, imageMap, verticallyShapedIcon, bucket.layers[0], bucket.collisionBoxArray, feature.index, feature.sourceLayerIndex, bucket.index, textBoxScale, textPadding, textAlongLine, textOffset, iconBoxScale, iconPadding, iconAlongLine, iconOffset, feature, sizes, isSDFIcon, canonical, layoutTextSize);
+                };
+                if (symbolPlacement === "line") {
+                  for (var i$1 = 0, list$1 = clipLine(feature.geometry, 0, 0, EXTENT$1, EXTENT$1); i$1 < list$1.length; i$1 += 1) {
+                    var line = list$1[i$1];
+                    var anchors = getAnchors(line, symbolMinDistance, textMaxAngle, shapedTextOrientations.vertical || defaultHorizontalShaping, shapedIcon, glyphSize, textMaxBoxScale, bucket.overscaling, EXTENT$1);
+                    for (var i2 = 0, list = anchors; i2 < list.length; i2 += 1) {
+                      var anchor = list[i2];
+                      var shapedText = defaultHorizontalShaping;
+                      if (!shapedText || !anchorIsTooClose(bucket, shapedText.text, textRepeatDistance, anchor)) {
+                        addSymbolAtAnchor(line, anchor);
+                      }
+                    }
+                  }
+                } else if (symbolPlacement === "line-center") {
+                  for (var i$2 = 0, list$2 = feature.geometry; i$2 < list$2.length; i$2 += 1) {
+                    var line$1 = list$2[i$2];
+                    if (line$1.length > 1) {
+                      var anchor$1 = getCenterAnchor(line$1, textMaxAngle, shapedTextOrientations.vertical || defaultHorizontalShaping, shapedIcon, glyphSize, textMaxBoxScale);
+                      if (anchor$1) {
+                        addSymbolAtAnchor(line$1, anchor$1);
+                      }
+                    }
+                  }
+                } else if (feature.type === "Polygon") {
+                  for (var i$3 = 0, list$3 = classifyRings(feature.geometry, 0); i$3 < list$3.length; i$3 += 1) {
+                    var polygon = list$3[i$3];
+                    var poi = findPoleOfInaccessibility(polygon, 16);
+                    addSymbolAtAnchor(polygon[0], new Anchor(poi.x, poi.y, 0));
+                  }
+                } else if (feature.type === "LineString") {
+                  for (var i$4 = 0, list$4 = feature.geometry; i$4 < list$4.length; i$4 += 1) {
+                    var line$2 = list$4[i$4];
+                    addSymbolAtAnchor(line$2, new Anchor(line$2[0].x, line$2[0].y, 0));
+                  }
+                } else if (feature.type === "Point") {
+                  for (var i$6 = 0, list$6 = feature.geometry; i$6 < list$6.length; i$6 += 1) {
+                    var points = list$6[i$6];
+                    for (var i$5 = 0, list$5 = points; i$5 < list$5.length; i$5 += 1) {
+                      var point = list$5[i$5];
+                      addSymbolAtAnchor([point], new Anchor(point.x, point.y, 0));
+                    }
+                  }
+                }
+              }
+              var MAX_GLYPH_ICON_SIZE = 255;
+              var MAX_PACKED_SIZE = MAX_GLYPH_ICON_SIZE * SIZE_PACK_FACTOR;
+              function addTextVertices(bucket, anchor, shapedText, imageMap, layer2, textAlongLine, feature, textOffset, lineArray, writingMode, placementTypes, placedTextSymbolIndices, placedIconIndex, sizes, canonical) {
+                var glyphQuads = getGlyphQuads(anchor, shapedText, textOffset, layer2, textAlongLine, feature, imageMap, bucket.allowVerticalPlacement);
+                var sizeData = bucket.textSizeData;
+                var textSizeData = null;
+                if (sizeData.kind === "source") {
+                  textSizeData = [SIZE_PACK_FACTOR * layer2.layout.get("text-size").evaluate(feature, {})];
+                  if (textSizeData[0] > MAX_PACKED_SIZE) {
+                    warnOnce(bucket.layerIds[0] + ': Value for "text-size" is >= ' + MAX_GLYPH_ICON_SIZE + '. Reduce your "text-size".');
+                  }
+                } else if (sizeData.kind === "composite") {
+                  textSizeData = [
+                    SIZE_PACK_FACTOR * sizes.compositeTextSizes[0].evaluate(feature, {}, canonical),
+                    SIZE_PACK_FACTOR * sizes.compositeTextSizes[1].evaluate(feature, {}, canonical)
+                  ];
+                  if (textSizeData[0] > MAX_PACKED_SIZE || textSizeData[1] > MAX_PACKED_SIZE) {
+                    warnOnce(bucket.layerIds[0] + ': Value for "text-size" is >= ' + MAX_GLYPH_ICON_SIZE + '. Reduce your "text-size".');
+                  }
+                }
+                bucket.addSymbols(bucket.text, glyphQuads, textSizeData, textOffset, textAlongLine, feature, writingMode, anchor, lineArray.lineStartIndex, lineArray.lineLength, placedIconIndex, canonical);
+                for (var i2 = 0, list = placementTypes; i2 < list.length; i2 += 1) {
+                  var placementType = list[i2];
+                  placedTextSymbolIndices[placementType] = bucket.text.placedSymbolArray.length - 1;
+                }
+                return glyphQuads.length * 4;
+              }
+              function getDefaultHorizontalShaping(horizontalShaping) {
+                for (var justification in horizontalShaping) {
+                  return horizontalShaping[justification];
+                }
+                return null;
+              }
+              function addSymbol(bucket, anchor, line, shapedTextOrientations, shapedIcon, imageMap, verticallyShapedIcon, layer2, collisionBoxArray, featureIndex, sourceLayerIndex, bucketIndex, textBoxScale, textPadding, textAlongLine, textOffset, iconBoxScale, iconPadding, iconAlongLine, iconOffset, feature, sizes, isSDFIcon, canonical, layoutTextSize) {
+                var assign;
+                var lineArray = bucket.addToLineVertexArray(anchor, line);
+                var textCollisionFeature, iconCollisionFeature, verticalTextCollisionFeature, verticalIconCollisionFeature;
+                var numIconVertices = 0;
+                var numVerticalIconVertices = 0;
+                var numHorizontalGlyphVertices = 0;
+                var numVerticalGlyphVertices = 0;
+                var placedIconSymbolIndex = -1;
+                var verticalPlacedIconSymbolIndex = -1;
+                var placedTextSymbolIndices = {};
+                var key = murmurhashJs("");
+                var textOffset0 = 0;
+                var textOffset1 = 0;
+                if (layer2._unevaluatedLayout.getValue("text-radial-offset") === void 0) {
+                  assign = layer2.layout.get("text-offset").evaluate(feature, {}, canonical).map(function(t4) {
+                    return t4 * ONE_EM;
+                  }), textOffset0 = assign[0], textOffset1 = assign[1];
+                } else {
+                  textOffset0 = layer2.layout.get("text-radial-offset").evaluate(feature, {}, canonical) * ONE_EM;
+                  textOffset1 = INVALID_TEXT_OFFSET;
+                }
+                if (bucket.allowVerticalPlacement && shapedTextOrientations.vertical) {
+                  var textRotation = layer2.layout.get("text-rotate").evaluate(feature, {}, canonical);
+                  var verticalTextRotation = textRotation + 90;
+                  var verticalShaping = shapedTextOrientations.vertical;
+                  verticalTextCollisionFeature = new CollisionFeature(collisionBoxArray, anchor, featureIndex, sourceLayerIndex, bucketIndex, verticalShaping, textBoxScale, textPadding, textAlongLine, verticalTextRotation);
+                  if (verticallyShapedIcon) {
+                    verticalIconCollisionFeature = new CollisionFeature(collisionBoxArray, anchor, featureIndex, sourceLayerIndex, bucketIndex, verticallyShapedIcon, iconBoxScale, iconPadding, textAlongLine, verticalTextRotation);
+                  }
+                }
+                if (shapedIcon) {
+                  var iconRotate = layer2.layout.get("icon-rotate").evaluate(feature, {});
+                  var hasIconTextFit = layer2.layout.get("icon-text-fit") !== "none";
+                  var iconQuads = getIconQuads(shapedIcon, iconRotate, isSDFIcon, hasIconTextFit);
+                  var verticalIconQuads = verticallyShapedIcon ? getIconQuads(verticallyShapedIcon, iconRotate, isSDFIcon, hasIconTextFit) : void 0;
+                  iconCollisionFeature = new CollisionFeature(collisionBoxArray, anchor, featureIndex, sourceLayerIndex, bucketIndex, shapedIcon, iconBoxScale, iconPadding, false, iconRotate);
+                  numIconVertices = iconQuads.length * 4;
+                  var sizeData = bucket.iconSizeData;
+                  var iconSizeData = null;
+                  if (sizeData.kind === "source") {
+                    iconSizeData = [SIZE_PACK_FACTOR * layer2.layout.get("icon-size").evaluate(feature, {})];
+                    if (iconSizeData[0] > MAX_PACKED_SIZE) {
+                      warnOnce(bucket.layerIds[0] + ': Value for "icon-size" is >= ' + MAX_GLYPH_ICON_SIZE + '. Reduce your "icon-size".');
+                    }
+                  } else if (sizeData.kind === "composite") {
+                    iconSizeData = [
+                      SIZE_PACK_FACTOR * sizes.compositeIconSizes[0].evaluate(feature, {}, canonical),
+                      SIZE_PACK_FACTOR * sizes.compositeIconSizes[1].evaluate(feature, {}, canonical)
+                    ];
+                    if (iconSizeData[0] > MAX_PACKED_SIZE || iconSizeData[1] > MAX_PACKED_SIZE) {
+                      warnOnce(bucket.layerIds[0] + ': Value for "icon-size" is >= ' + MAX_GLYPH_ICON_SIZE + '. Reduce your "icon-size".');
+                    }
+                  }
+                  bucket.addSymbols(bucket.icon, iconQuads, iconSizeData, iconOffset, iconAlongLine, feature, false, anchor, lineArray.lineStartIndex, lineArray.lineLength, -1, canonical);
+                  placedIconSymbolIndex = bucket.icon.placedSymbolArray.length - 1;
+                  if (verticalIconQuads) {
+                    numVerticalIconVertices = verticalIconQuads.length * 4;
+                    bucket.addSymbols(bucket.icon, verticalIconQuads, iconSizeData, iconOffset, iconAlongLine, feature, WritingMode.vertical, anchor, lineArray.lineStartIndex, lineArray.lineLength, -1, canonical);
+                    verticalPlacedIconSymbolIndex = bucket.icon.placedSymbolArray.length - 1;
+                  }
+                }
+                for (var justification in shapedTextOrientations.horizontal) {
+                  var shaping = shapedTextOrientations.horizontal[justification];
+                  if (!textCollisionFeature) {
+                    key = murmurhashJs(shaping.text);
+                    var textRotate = layer2.layout.get("text-rotate").evaluate(feature, {}, canonical);
+                    textCollisionFeature = new CollisionFeature(collisionBoxArray, anchor, featureIndex, sourceLayerIndex, bucketIndex, shaping, textBoxScale, textPadding, textAlongLine, textRotate);
+                  }
+                  var singleLine = shaping.positionedLines.length === 1;
+                  numHorizontalGlyphVertices += addTextVertices(bucket, anchor, shaping, imageMap, layer2, textAlongLine, feature, textOffset, lineArray, shapedTextOrientations.vertical ? WritingMode.horizontal : WritingMode.horizontalOnly, singleLine ? Object.keys(shapedTextOrientations.horizontal) : [justification], placedTextSymbolIndices, placedIconSymbolIndex, sizes, canonical);
+                  if (singleLine) {
+                    break;
+                  }
+                }
+                if (shapedTextOrientations.vertical) {
+                  numVerticalGlyphVertices += addTextVertices(bucket, anchor, shapedTextOrientations.vertical, imageMap, layer2, textAlongLine, feature, textOffset, lineArray, WritingMode.vertical, ["vertical"], placedTextSymbolIndices, verticalPlacedIconSymbolIndex, sizes, canonical);
+                }
+                var textBoxStartIndex = textCollisionFeature ? textCollisionFeature.boxStartIndex : bucket.collisionBoxArray.length;
+                var textBoxEndIndex = textCollisionFeature ? textCollisionFeature.boxEndIndex : bucket.collisionBoxArray.length;
+                var verticalTextBoxStartIndex = verticalTextCollisionFeature ? verticalTextCollisionFeature.boxStartIndex : bucket.collisionBoxArray.length;
+                var verticalTextBoxEndIndex = verticalTextCollisionFeature ? verticalTextCollisionFeature.boxEndIndex : bucket.collisionBoxArray.length;
+                var iconBoxStartIndex = iconCollisionFeature ? iconCollisionFeature.boxStartIndex : bucket.collisionBoxArray.length;
+                var iconBoxEndIndex = iconCollisionFeature ? iconCollisionFeature.boxEndIndex : bucket.collisionBoxArray.length;
+                var verticalIconBoxStartIndex = verticalIconCollisionFeature ? verticalIconCollisionFeature.boxStartIndex : bucket.collisionBoxArray.length;
+                var verticalIconBoxEndIndex = verticalIconCollisionFeature ? verticalIconCollisionFeature.boxEndIndex : bucket.collisionBoxArray.length;
+                var collisionCircleDiameter = -1;
+                var getCollisionCircleHeight = function(feature2, prevHeight) {
+                  if (feature2 && feature2.circleDiameter) {
+                    return Math.max(feature2.circleDiameter, prevHeight);
+                  }
+                  return prevHeight;
+                };
+                collisionCircleDiameter = getCollisionCircleHeight(textCollisionFeature, collisionCircleDiameter);
+                collisionCircleDiameter = getCollisionCircleHeight(verticalTextCollisionFeature, collisionCircleDiameter);
+                collisionCircleDiameter = getCollisionCircleHeight(iconCollisionFeature, collisionCircleDiameter);
+                collisionCircleDiameter = getCollisionCircleHeight(verticalIconCollisionFeature, collisionCircleDiameter);
+                var useRuntimeCollisionCircles = collisionCircleDiameter > -1 ? 1 : 0;
+                if (useRuntimeCollisionCircles) {
+                  collisionCircleDiameter *= layoutTextSize / ONE_EM;
+                }
+                if (bucket.glyphOffsetArray.length >= SymbolBucket.MAX_GLYPHS) {
+                  warnOnce("Too many glyphs being rendered in a tile. See https://github.com/mapbox/mapbox-gl-js/issues/2907");
+                }
+                if (feature.sortKey !== void 0) {
+                  bucket.addToSortKeyRanges(bucket.symbolInstances.length, feature.sortKey);
+                }
+                bucket.symbolInstances.emplaceBack(anchor.x, anchor.y, placedTextSymbolIndices.right >= 0 ? placedTextSymbolIndices.right : -1, placedTextSymbolIndices.center >= 0 ? placedTextSymbolIndices.center : -1, placedTextSymbolIndices.left >= 0 ? placedTextSymbolIndices.left : -1, placedTextSymbolIndices.vertical || -1, placedIconSymbolIndex, verticalPlacedIconSymbolIndex, key, textBoxStartIndex, textBoxEndIndex, verticalTextBoxStartIndex, verticalTextBoxEndIndex, iconBoxStartIndex, iconBoxEndIndex, verticalIconBoxStartIndex, verticalIconBoxEndIndex, featureIndex, numHorizontalGlyphVertices, numVerticalGlyphVertices, numIconVertices, numVerticalIconVertices, useRuntimeCollisionCircles, 0, textBoxScale, textOffset0, textOffset1, collisionCircleDiameter);
+              }
+              function anchorIsTooClose(bucket, text, repeatDistance, anchor) {
+                var compareText = bucket.compareText;
+                if (!(text in compareText)) {
+                  compareText[text] = [];
+                } else {
+                  var otherAnchors = compareText[text];
+                  for (var k2 = otherAnchors.length - 1; k2 >= 0; k2--) {
+                    if (anchor.dist(otherAnchors[k2]) < repeatDistance) {
+                      return true;
+                    }
+                  }
+                }
+                compareText[text].push(anchor);
+                return false;
+              }
+              var vectorTileFeatureTypes$2 = vectorTile.VectorTileFeature.types;
+              var shaderOpacityAttributes = [{
+                name: "a_fade_opacity",
+                components: 1,
+                type: "Uint8",
+                offset: 0
+              }];
+              function addVertex$1(array2, anchorX, anchorY, ox, oy, tx, ty, sizeVertex, isSDF, pixelOffsetX, pixelOffsetY, minFontScaleX, minFontScaleY) {
+                var aSizeX = sizeVertex ? Math.min(MAX_PACKED_SIZE, Math.round(sizeVertex[0])) : 0;
+                var aSizeY = sizeVertex ? Math.min(MAX_PACKED_SIZE, Math.round(sizeVertex[1])) : 0;
+                array2.emplaceBack(anchorX, anchorY, Math.round(ox * 32), Math.round(oy * 32), tx, ty, (aSizeX << 1) + (isSDF ? 1 : 0), aSizeY, pixelOffsetX * 16, pixelOffsetY * 16, minFontScaleX * 256, minFontScaleY * 256);
+              }
+              function addDynamicAttributes(dynamicLayoutVertexArray, p2, angle2) {
+                dynamicLayoutVertexArray.emplaceBack(p2.x, p2.y, angle2);
+                dynamicLayoutVertexArray.emplaceBack(p2.x, p2.y, angle2);
+                dynamicLayoutVertexArray.emplaceBack(p2.x, p2.y, angle2);
+                dynamicLayoutVertexArray.emplaceBack(p2.x, p2.y, angle2);
+              }
+              function containsRTLText(formattedText) {
+                for (var i2 = 0, list = formattedText.sections; i2 < list.length; i2 += 1) {
+                  var section = list[i2];
+                  if (stringContainsRTLText(section.text)) {
+                    return true;
+                  }
+                }
+                return false;
+              }
+              var SymbolBuffers = function SymbolBuffers2(programConfigurations) {
+                this.layoutVertexArray = new StructArrayLayout4i4ui4i24();
+                this.indexArray = new StructArrayLayout3ui6();
+                this.programConfigurations = programConfigurations;
+                this.segments = new SegmentVector();
+                this.dynamicLayoutVertexArray = new StructArrayLayout3f12();
+                this.opacityVertexArray = new StructArrayLayout1ul4();
+                this.placedSymbolArray = new PlacedSymbolArray();
+              };
+              SymbolBuffers.prototype.isEmpty = function isEmpty2() {
+                return this.layoutVertexArray.length === 0 && this.indexArray.length === 0 && this.dynamicLayoutVertexArray.length === 0 && this.opacityVertexArray.length === 0;
+              };
+              SymbolBuffers.prototype.upload = function upload(context, dynamicIndexBuffer, upload$1, update) {
+                if (this.isEmpty()) {
+                  return;
+                }
+                if (upload$1) {
+                  this.layoutVertexBuffer = context.createVertexBuffer(this.layoutVertexArray, symbolLayoutAttributes.members);
+                  this.indexBuffer = context.createIndexBuffer(this.indexArray, dynamicIndexBuffer);
+                  this.dynamicLayoutVertexBuffer = context.createVertexBuffer(this.dynamicLayoutVertexArray, dynamicLayoutAttributes.members, true);
+                  this.opacityVertexBuffer = context.createVertexBuffer(this.opacityVertexArray, shaderOpacityAttributes, true);
+                  this.opacityVertexBuffer.itemSize = 1;
+                }
+                if (upload$1 || update) {
+                  this.programConfigurations.upload(context);
+                }
+              };
+              SymbolBuffers.prototype.destroy = function destroy() {
+                if (!this.layoutVertexBuffer) {
+                  return;
+                }
+                this.layoutVertexBuffer.destroy();
+                this.indexBuffer.destroy();
+                this.programConfigurations.destroy();
+                this.segments.destroy();
+                this.dynamicLayoutVertexBuffer.destroy();
+                this.opacityVertexBuffer.destroy();
+              };
+              register2("SymbolBuffers", SymbolBuffers);
+              var CollisionBuffers = function CollisionBuffers2(LayoutArray, layoutAttributes, IndexArray) {
+                this.layoutVertexArray = new LayoutArray();
+                this.layoutAttributes = layoutAttributes;
+                this.indexArray = new IndexArray();
+                this.segments = new SegmentVector();
+                this.collisionVertexArray = new StructArrayLayout2ub2f12();
+              };
+              CollisionBuffers.prototype.upload = function upload(context) {
+                this.layoutVertexBuffer = context.createVertexBuffer(this.layoutVertexArray, this.layoutAttributes);
+                this.indexBuffer = context.createIndexBuffer(this.indexArray);
+                this.collisionVertexBuffer = context.createVertexBuffer(this.collisionVertexArray, collisionVertexAttributes.members, true);
+              };
+              CollisionBuffers.prototype.destroy = function destroy() {
+                if (!this.layoutVertexBuffer) {
+                  return;
+                }
+                this.layoutVertexBuffer.destroy();
+                this.indexBuffer.destroy();
+                this.segments.destroy();
+                this.collisionVertexBuffer.destroy();
+              };
+              register2("CollisionBuffers", CollisionBuffers);
+              var SymbolBucket = function SymbolBucket2(options) {
+                this.collisionBoxArray = options.collisionBoxArray;
+                this.zoom = options.zoom;
+                this.overscaling = options.overscaling;
+                this.layers = options.layers;
+                this.layerIds = this.layers.map(function(layer3) {
+                  return layer3.id;
+                });
+                this.index = options.index;
+                this.pixelRatio = options.pixelRatio;
+                this.sourceLayerIndex = options.sourceLayerIndex;
+                this.hasPattern = false;
+                this.hasRTLText = false;
+                this.sortKeyRanges = [];
+                this.collisionCircleArray = [];
+                this.placementInvProjMatrix = identity22([]);
+                this.placementViewportMatrix = identity22([]);
+                var layer2 = this.layers[0];
+                var unevaluatedLayoutValues = layer2._unevaluatedLayout._values;
+                this.textSizeData = getSizeData(this.zoom, unevaluatedLayoutValues["text-size"]);
+                this.iconSizeData = getSizeData(this.zoom, unevaluatedLayoutValues["icon-size"]);
+                var layout2 = this.layers[0].layout;
+                var sortKey = layout2.get("symbol-sort-key");
+                var zOrder2 = layout2.get("symbol-z-order");
+                this.canOverlap = layout2.get("text-allow-overlap") || layout2.get("icon-allow-overlap") || layout2.get("text-ignore-placement") || layout2.get("icon-ignore-placement");
+                this.sortFeaturesByKey = zOrder2 !== "viewport-y" && sortKey.constantOr(1) !== void 0;
+                var zOrderByViewportY = zOrder2 === "viewport-y" || zOrder2 === "auto" && !this.sortFeaturesByKey;
+                this.sortFeaturesByY = zOrderByViewportY && this.canOverlap;
+                if (layout2.get("symbol-placement") === "point") {
+                  this.writingModes = layout2.get("text-writing-mode").map(function(wm) {
+                    return WritingMode[wm];
+                  });
+                }
+                this.stateDependentLayerIds = this.layers.filter(function(l2) {
+                  return l2.isStateDependent();
+                }).map(function(l2) {
+                  return l2.id;
+                });
+                this.sourceID = options.sourceID;
+              };
+              SymbolBucket.prototype.createArrays = function createArrays() {
+                this.text = new SymbolBuffers(new ProgramConfigurationSet(this.layers, this.zoom, function(property) {
+                  return /^text/.test(property);
+                }));
+                this.icon = new SymbolBuffers(new ProgramConfigurationSet(this.layers, this.zoom, function(property) {
+                  return /^icon/.test(property);
+                }));
+                this.glyphOffsetArray = new GlyphOffsetArray();
+                this.lineVertexArray = new SymbolLineVertexArray();
+                this.symbolInstances = new SymbolInstanceArray();
+              };
+              SymbolBucket.prototype.calculateGlyphDependencies = function calculateGlyphDependencies(text, stack, textAlongLine, allowVerticalPlacement, doesAllowVerticalWritingMode) {
+                for (var i2 = 0; i2 < text.length; i2++) {
+                  stack[text.charCodeAt(i2)] = true;
+                  if ((textAlongLine || allowVerticalPlacement) && doesAllowVerticalWritingMode) {
+                    var verticalChar = verticalizedCharacterMap[text.charAt(i2)];
+                    if (verticalChar) {
+                      stack[verticalChar.charCodeAt(0)] = true;
+                    }
+                  }
+                }
+              };
+              SymbolBucket.prototype.populate = function populate(features, options, canonical) {
+                var layer2 = this.layers[0];
+                var layout2 = layer2.layout;
+                var textFont = layout2.get("text-font");
+                var textField = layout2.get("text-field");
+                var iconImage = layout2.get("icon-image");
+                var hasText = (textField.value.kind !== "constant" || textField.value.value instanceof Formatted && !textField.value.value.isEmpty() || textField.value.value.toString().length > 0) && (textFont.value.kind !== "constant" || textFont.value.value.length > 0);
+                var hasIcon = iconImage.value.kind !== "constant" || !!iconImage.value.value || Object.keys(iconImage.parameters).length > 0;
+                var symbolSortKey = layout2.get("symbol-sort-key");
+                this.features = [];
+                if (!hasText && !hasIcon) {
+                  return;
+                }
+                var icons = options.iconDependencies;
+                var stacks = options.glyphDependencies;
+                var availableImages = options.availableImages;
+                var globalProperties = new EvaluationParameters(this.zoom);
+                for (var i$1 = 0, list$1 = features; i$1 < list$1.length; i$1 += 1) {
+                  var ref = list$1[i$1];
+                  var feature = ref.feature;
+                  var id22 = ref.id;
+                  var index = ref.index;
+                  var sourceLayerIndex = ref.sourceLayerIndex;
+                  var needGeometry = layer2._featureFilter.needGeometry;
+                  var evaluationFeature = toEvaluationFeature(feature, needGeometry);
+                  if (!layer2._featureFilter.filter(globalProperties, evaluationFeature, canonical)) {
+                    continue;
+                  }
+                  if (!needGeometry) {
+                    evaluationFeature.geometry = loadGeometry(feature);
+                  }
+                  var text = void 0;
+                  if (hasText) {
+                    var resolvedTokens = layer2.getValueAndResolveTokens("text-field", evaluationFeature, canonical, availableImages);
+                    var formattedText = Formatted.factory(resolvedTokens);
+                    if (containsRTLText(formattedText)) {
+                      this.hasRTLText = true;
+                    }
+                    if (!this.hasRTLText || getRTLTextPluginStatus() === "unavailable" || this.hasRTLText && plugin.isParsed()) {
+                      text = transformText$1(formattedText, layer2, evaluationFeature);
+                    }
+                  }
+                  var icon = void 0;
+                  if (hasIcon) {
+                    var resolvedTokens$1 = layer2.getValueAndResolveTokens("icon-image", evaluationFeature, canonical, availableImages);
+                    if (resolvedTokens$1 instanceof ResolvedImage) {
+                      icon = resolvedTokens$1;
+                    } else {
+                      icon = ResolvedImage.fromString(resolvedTokens$1);
+                    }
+                  }
+                  if (!text && !icon) {
+                    continue;
+                  }
+                  var sortKey = this.sortFeaturesByKey ? symbolSortKey.evaluate(evaluationFeature, {}, canonical) : void 0;
+                  var symbolFeature = {
+                    id: id22,
+                    text,
+                    icon,
+                    index,
+                    sourceLayerIndex,
+                    geometry: evaluationFeature.geometry,
+                    properties: feature.properties,
+                    type: vectorTileFeatureTypes$2[feature.type],
+                    sortKey
+                  };
+                  this.features.push(symbolFeature);
+                  if (icon) {
+                    icons[icon.name] = true;
+                  }
+                  if (text) {
+                    var fontStack = textFont.evaluate(evaluationFeature, {}, canonical).join(",");
+                    var textAlongLine = layout2.get("text-rotation-alignment") === "map" && layout2.get("symbol-placement") !== "point";
+                    this.allowVerticalPlacement = this.writingModes && this.writingModes.indexOf(WritingMode.vertical) >= 0;
+                    for (var i2 = 0, list = text.sections; i2 < list.length; i2 += 1) {
+                      var section = list[i2];
+                      if (!section.image) {
+                        var doesAllowVerticalWritingMode = allowsVerticalWritingMode(text.toString());
+                        var sectionFont = section.fontStack || fontStack;
+                        var sectionStack = stacks[sectionFont] = stacks[sectionFont] || {};
+                        this.calculateGlyphDependencies(section.text, sectionStack, textAlongLine, this.allowVerticalPlacement, doesAllowVerticalWritingMode);
+                      } else {
+                        icons[section.image.name] = true;
+                      }
+                    }
+                  }
+                }
+                if (layout2.get("symbol-placement") === "line") {
+                  this.features = mergeLines(this.features);
+                }
+                if (this.sortFeaturesByKey) {
+                  this.features.sort(function(a2, b2) {
+                    return a2.sortKey - b2.sortKey;
+                  });
+                }
+              };
+              SymbolBucket.prototype.update = function update(states, vtLayer, imagePositions) {
+                if (!this.stateDependentLayers.length) {
+                  return;
+                }
+                this.text.programConfigurations.updatePaintArrays(states, vtLayer, this.layers, imagePositions);
+                this.icon.programConfigurations.updatePaintArrays(states, vtLayer, this.layers, imagePositions);
+              };
+              SymbolBucket.prototype.isEmpty = function isEmpty2() {
+                return this.symbolInstances.length === 0 && !this.hasRTLText;
+              };
+              SymbolBucket.prototype.uploadPending = function uploadPending() {
+                return !this.uploaded || this.text.programConfigurations.needsUpload || this.icon.programConfigurations.needsUpload;
+              };
+              SymbolBucket.prototype.upload = function upload(context) {
+                if (!this.uploaded && this.hasDebugData()) {
+                  this.textCollisionBox.upload(context);
+                  this.iconCollisionBox.upload(context);
+                }
+                this.text.upload(context, this.sortFeaturesByY, !this.uploaded, this.text.programConfigurations.needsUpload);
+                this.icon.upload(context, this.sortFeaturesByY, !this.uploaded, this.icon.programConfigurations.needsUpload);
+                this.uploaded = true;
+              };
+              SymbolBucket.prototype.destroyDebugData = function destroyDebugData() {
+                this.textCollisionBox.destroy();
+                this.iconCollisionBox.destroy();
+              };
+              SymbolBucket.prototype.destroy = function destroy() {
+                this.text.destroy();
+                this.icon.destroy();
+                if (this.hasDebugData()) {
+                  this.destroyDebugData();
+                }
+              };
+              SymbolBucket.prototype.addToLineVertexArray = function addToLineVertexArray(anchor, line) {
+                var lineStartIndex = this.lineVertexArray.length;
+                if (anchor.segment !== void 0) {
+                  var sumForwardLength = anchor.dist(line[anchor.segment + 1]);
+                  var sumBackwardLength = anchor.dist(line[anchor.segment]);
+                  var vertices = {};
+                  for (var i2 = anchor.segment + 1; i2 < line.length; i2++) {
+                    vertices[i2] = {
+                      x: line[i2].x,
+                      y: line[i2].y,
+                      tileUnitDistanceFromAnchor: sumForwardLength
+                    };
+                    if (i2 < line.length - 1) {
+                      sumForwardLength += line[i2 + 1].dist(line[i2]);
+                    }
+                  }
+                  for (var i$1 = anchor.segment || 0; i$1 >= 0; i$1--) {
+                    vertices[i$1] = {
+                      x: line[i$1].x,
+                      y: line[i$1].y,
+                      tileUnitDistanceFromAnchor: sumBackwardLength
+                    };
+                    if (i$1 > 0) {
+                      sumBackwardLength += line[i$1 - 1].dist(line[i$1]);
+                    }
+                  }
+                  for (var i$2 = 0; i$2 < line.length; i$2++) {
+                    var vertex2 = vertices[i$2];
+                    this.lineVertexArray.emplaceBack(vertex2.x, vertex2.y, vertex2.tileUnitDistanceFromAnchor);
+                  }
+                }
+                return {
+                  lineStartIndex,
+                  lineLength: this.lineVertexArray.length - lineStartIndex
+                };
+              };
+              SymbolBucket.prototype.addSymbols = function addSymbols(arrays, quads, sizeVertex, lineOffset, alongLine, feature, writingMode, labelAnchor, lineStartIndex, lineLength, associatedIconIndex, canonical) {
+                var indexArray = arrays.indexArray;
+                var layoutVertexArray = arrays.layoutVertexArray;
+                var segment = arrays.segments.prepareSegment(4 * quads.length, layoutVertexArray, indexArray, this.canOverlap ? feature.sortKey : void 0);
+                var glyphOffsetArrayStart = this.glyphOffsetArray.length;
+                var vertexStartIndex = segment.vertexLength;
+                var angle2 = this.allowVerticalPlacement && writingMode === WritingMode.vertical ? Math.PI / 2 : 0;
+                var sections = feature.text && feature.text.sections;
+                for (var i2 = 0; i2 < quads.length; i2++) {
+                  var ref = quads[i2];
+                  var tl2 = ref.tl;
+                  var tr = ref.tr;
+                  var bl2 = ref.bl;
+                  var br = ref.br;
+                  var tex = ref.tex;
+                  var pixelOffsetTL = ref.pixelOffsetTL;
+                  var pixelOffsetBR = ref.pixelOffsetBR;
+                  var minFontScaleX = ref.minFontScaleX;
+                  var minFontScaleY = ref.minFontScaleY;
+                  var glyphOffset2 = ref.glyphOffset;
+                  var isSDF = ref.isSDF;
+                  var sectionIndex = ref.sectionIndex;
+                  var index = segment.vertexLength;
+                  var y2 = glyphOffset2[1];
+                  addVertex$1(layoutVertexArray, labelAnchor.x, labelAnchor.y, tl2.x, y2 + tl2.y, tex.x, tex.y, sizeVertex, isSDF, pixelOffsetTL.x, pixelOffsetTL.y, minFontScaleX, minFontScaleY);
+                  addVertex$1(layoutVertexArray, labelAnchor.x, labelAnchor.y, tr.x, y2 + tr.y, tex.x + tex.w, tex.y, sizeVertex, isSDF, pixelOffsetBR.x, pixelOffsetTL.y, minFontScaleX, minFontScaleY);
+                  addVertex$1(layoutVertexArray, labelAnchor.x, labelAnchor.y, bl2.x, y2 + bl2.y, tex.x, tex.y + tex.h, sizeVertex, isSDF, pixelOffsetTL.x, pixelOffsetBR.y, minFontScaleX, minFontScaleY);
+                  addVertex$1(layoutVertexArray, labelAnchor.x, labelAnchor.y, br.x, y2 + br.y, tex.x + tex.w, tex.y + tex.h, sizeVertex, isSDF, pixelOffsetBR.x, pixelOffsetBR.y, minFontScaleX, minFontScaleY);
+                  addDynamicAttributes(arrays.dynamicLayoutVertexArray, labelAnchor, angle2);
+                  indexArray.emplaceBack(index, index + 1, index + 2);
+                  indexArray.emplaceBack(index + 1, index + 2, index + 3);
+                  segment.vertexLength += 4;
+                  segment.primitiveLength += 2;
+                  this.glyphOffsetArray.emplaceBack(glyphOffset2[0]);
+                  if (i2 === quads.length - 1 || sectionIndex !== quads[i2 + 1].sectionIndex) {
+                    arrays.programConfigurations.populatePaintArrays(layoutVertexArray.length, feature, feature.index, {}, canonical, sections && sections[sectionIndex]);
+                  }
+                }
+                arrays.placedSymbolArray.emplaceBack(labelAnchor.x, labelAnchor.y, glyphOffsetArrayStart, this.glyphOffsetArray.length - glyphOffsetArrayStart, vertexStartIndex, lineStartIndex, lineLength, labelAnchor.segment, sizeVertex ? sizeVertex[0] : 0, sizeVertex ? sizeVertex[1] : 0, lineOffset[0], lineOffset[1], writingMode, 0, false, 0, associatedIconIndex);
+              };
+              SymbolBucket.prototype._addCollisionDebugVertex = function _addCollisionDebugVertex(layoutVertexArray, collisionVertexArray, point, anchorX, anchorY, extrude) {
+                collisionVertexArray.emplaceBack(0, 0);
+                return layoutVertexArray.emplaceBack(point.x, point.y, anchorX, anchorY, Math.round(extrude.x), Math.round(extrude.y));
+              };
+              SymbolBucket.prototype.addCollisionDebugVertices = function addCollisionDebugVertices(x1, y1, x2, y2, arrays, boxAnchorPoint, symbolInstance2) {
+                var segment = arrays.segments.prepareSegment(4, arrays.layoutVertexArray, arrays.indexArray);
+                var index = segment.vertexLength;
+                var layoutVertexArray = arrays.layoutVertexArray;
+                var collisionVertexArray = arrays.collisionVertexArray;
+                var anchorX = symbolInstance2.anchorX;
+                var anchorY = symbolInstance2.anchorY;
+                this._addCollisionDebugVertex(layoutVertexArray, collisionVertexArray, boxAnchorPoint, anchorX, anchorY, new pointGeometry(x1, y1));
+                this._addCollisionDebugVertex(layoutVertexArray, collisionVertexArray, boxAnchorPoint, anchorX, anchorY, new pointGeometry(x2, y1));
+                this._addCollisionDebugVertex(layoutVertexArray, collisionVertexArray, boxAnchorPoint, anchorX, anchorY, new pointGeometry(x2, y2));
+                this._addCollisionDebugVertex(layoutVertexArray, collisionVertexArray, boxAnchorPoint, anchorX, anchorY, new pointGeometry(x1, y2));
+                segment.vertexLength += 4;
+                var indexArray = arrays.indexArray;
+                indexArray.emplaceBack(index, index + 1);
+                indexArray.emplaceBack(index + 1, index + 2);
+                indexArray.emplaceBack(index + 2, index + 3);
+                indexArray.emplaceBack(index + 3, index);
+                segment.primitiveLength += 4;
+              };
+              SymbolBucket.prototype.addDebugCollisionBoxes = function addDebugCollisionBoxes(startIndex, endIndex, symbolInstance2, isText) {
+                for (var b2 = startIndex; b2 < endIndex; b2++) {
+                  var box = this.collisionBoxArray.get(b2);
+                  var x1 = box.x1;
+                  var y1 = box.y1;
+                  var x2 = box.x2;
+                  var y2 = box.y2;
+                  this.addCollisionDebugVertices(x1, y1, x2, y2, isText ? this.textCollisionBox : this.iconCollisionBox, box.anchorPoint, symbolInstance2);
+                }
+              };
+              SymbolBucket.prototype.generateCollisionDebugBuffers = function generateCollisionDebugBuffers() {
+                if (this.hasDebugData()) {
+                  this.destroyDebugData();
+                }
+                this.textCollisionBox = new CollisionBuffers(StructArrayLayout2i2i2i12, collisionBoxLayout.members, StructArrayLayout2ui4);
+                this.iconCollisionBox = new CollisionBuffers(StructArrayLayout2i2i2i12, collisionBoxLayout.members, StructArrayLayout2ui4);
+                for (var i2 = 0; i2 < this.symbolInstances.length; i2++) {
+                  var symbolInstance2 = this.symbolInstances.get(i2);
+                  this.addDebugCollisionBoxes(symbolInstance2.textBoxStartIndex, symbolInstance2.textBoxEndIndex, symbolInstance2, true);
+                  this.addDebugCollisionBoxes(symbolInstance2.verticalTextBoxStartIndex, symbolInstance2.verticalTextBoxEndIndex, symbolInstance2, true);
+                  this.addDebugCollisionBoxes(symbolInstance2.iconBoxStartIndex, symbolInstance2.iconBoxEndIndex, symbolInstance2, false);
+                  this.addDebugCollisionBoxes(symbolInstance2.verticalIconBoxStartIndex, symbolInstance2.verticalIconBoxEndIndex, symbolInstance2, false);
+                }
+              };
+              SymbolBucket.prototype._deserializeCollisionBoxesForSymbol = function _deserializeCollisionBoxesForSymbol(collisionBoxArray, textStartIndex, textEndIndex, verticalTextStartIndex, verticalTextEndIndex, iconStartIndex, iconEndIndex, verticalIconStartIndex, verticalIconEndIndex) {
+                var collisionArrays = {};
+                for (var k2 = textStartIndex; k2 < textEndIndex; k2++) {
+                  var box = collisionBoxArray.get(k2);
+                  collisionArrays.textBox = {
+                    x1: box.x1,
+                    y1: box.y1,
+                    x2: box.x2,
+                    y2: box.y2,
+                    anchorPointX: box.anchorPointX,
+                    anchorPointY: box.anchorPointY
+                  };
+                  collisionArrays.textFeatureIndex = box.featureIndex;
+                  break;
+                }
+                for (var k$12 = verticalTextStartIndex; k$12 < verticalTextEndIndex; k$12++) {
+                  var box$1 = collisionBoxArray.get(k$12);
+                  collisionArrays.verticalTextBox = {
+                    x1: box$1.x1,
+                    y1: box$1.y1,
+                    x2: box$1.x2,
+                    y2: box$1.y2,
+                    anchorPointX: box$1.anchorPointX,
+                    anchorPointY: box$1.anchorPointY
+                  };
+                  collisionArrays.verticalTextFeatureIndex = box$1.featureIndex;
+                  break;
+                }
+                for (var k$2 = iconStartIndex; k$2 < iconEndIndex; k$2++) {
+                  var box$2 = collisionBoxArray.get(k$2);
+                  collisionArrays.iconBox = {
+                    x1: box$2.x1,
+                    y1: box$2.y1,
+                    x2: box$2.x2,
+                    y2: box$2.y2,
+                    anchorPointX: box$2.anchorPointX,
+                    anchorPointY: box$2.anchorPointY
+                  };
+                  collisionArrays.iconFeatureIndex = box$2.featureIndex;
+                  break;
+                }
+                for (var k$3 = verticalIconStartIndex; k$3 < verticalIconEndIndex; k$3++) {
+                  var box$3 = collisionBoxArray.get(k$3);
+                  collisionArrays.verticalIconBox = {
+                    x1: box$3.x1,
+                    y1: box$3.y1,
+                    x2: box$3.x2,
+                    y2: box$3.y2,
+                    anchorPointX: box$3.anchorPointX,
+                    anchorPointY: box$3.anchorPointY
+                  };
+                  collisionArrays.verticalIconFeatureIndex = box$3.featureIndex;
+                  break;
+                }
+                return collisionArrays;
+              };
+              SymbolBucket.prototype.deserializeCollisionBoxes = function deserializeCollisionBoxes(collisionBoxArray) {
+                this.collisionArrays = [];
+                for (var i2 = 0; i2 < this.symbolInstances.length; i2++) {
+                  var symbolInstance2 = this.symbolInstances.get(i2);
+                  this.collisionArrays.push(this._deserializeCollisionBoxesForSymbol(collisionBoxArray, symbolInstance2.textBoxStartIndex, symbolInstance2.textBoxEndIndex, symbolInstance2.verticalTextBoxStartIndex, symbolInstance2.verticalTextBoxEndIndex, symbolInstance2.iconBoxStartIndex, symbolInstance2.iconBoxEndIndex, symbolInstance2.verticalIconBoxStartIndex, symbolInstance2.verticalIconBoxEndIndex));
+                }
+              };
+              SymbolBucket.prototype.hasTextData = function hasTextData() {
+                return this.text.segments.get().length > 0;
+              };
+              SymbolBucket.prototype.hasIconData = function hasIconData() {
+                return this.icon.segments.get().length > 0;
+              };
+              SymbolBucket.prototype.hasDebugData = function hasDebugData() {
+                return this.textCollisionBox && this.iconCollisionBox;
+              };
+              SymbolBucket.prototype.hasTextCollisionBoxData = function hasTextCollisionBoxData() {
+                return this.hasDebugData() && this.textCollisionBox.segments.get().length > 0;
+              };
+              SymbolBucket.prototype.hasIconCollisionBoxData = function hasIconCollisionBoxData() {
+                return this.hasDebugData() && this.iconCollisionBox.segments.get().length > 0;
+              };
+              SymbolBucket.prototype.addIndicesForPlacedSymbol = function addIndicesForPlacedSymbol(iconOrText, placedSymbolIndex) {
+                var placedSymbol = iconOrText.placedSymbolArray.get(placedSymbolIndex);
+                var endIndex = placedSymbol.vertexStartIndex + placedSymbol.numGlyphs * 4;
+                for (var vertexIndex = placedSymbol.vertexStartIndex; vertexIndex < endIndex; vertexIndex += 4) {
+                  iconOrText.indexArray.emplaceBack(vertexIndex, vertexIndex + 1, vertexIndex + 2);
+                  iconOrText.indexArray.emplaceBack(vertexIndex + 1, vertexIndex + 2, vertexIndex + 3);
+                }
+              };
+              SymbolBucket.prototype.getSortedSymbolIndexes = function getSortedSymbolIndexes(angle2) {
+                if (this.sortedAngle === angle2 && this.symbolInstanceIndexes !== void 0) {
+                  return this.symbolInstanceIndexes;
+                }
+                var sin = Math.sin(angle2);
+                var cos = Math.cos(angle2);
+                var rotatedYs = [];
+                var featureIndexes = [];
+                var result = [];
+                for (var i2 = 0; i2 < this.symbolInstances.length; ++i2) {
+                  result.push(i2);
+                  var symbolInstance2 = this.symbolInstances.get(i2);
+                  rotatedYs.push(Math.round(sin * symbolInstance2.anchorX + cos * symbolInstance2.anchorY) | 0);
+                  featureIndexes.push(symbolInstance2.featureIndex);
+                }
+                result.sort(function(aIndex, bIndex) {
+                  return rotatedYs[aIndex] - rotatedYs[bIndex] || featureIndexes[bIndex] - featureIndexes[aIndex];
+                });
+                return result;
+              };
+              SymbolBucket.prototype.addToSortKeyRanges = function addToSortKeyRanges(symbolInstanceIndex, sortKey) {
+                var last = this.sortKeyRanges[this.sortKeyRanges.length - 1];
+                if (last && last.sortKey === sortKey) {
+                  last.symbolInstanceEnd = symbolInstanceIndex + 1;
+                } else {
+                  this.sortKeyRanges.push({
+                    sortKey,
+                    symbolInstanceStart: symbolInstanceIndex,
+                    symbolInstanceEnd: symbolInstanceIndex + 1
+                  });
+                }
+              };
+              SymbolBucket.prototype.sortFeatures = function sortFeatures(angle2) {
+                var this$1$1 = this;
+                if (!this.sortFeaturesByY) {
+                  return;
+                }
+                if (this.sortedAngle === angle2) {
+                  return;
+                }
+                if (this.text.segments.get().length > 1 || this.icon.segments.get().length > 1) {
+                  return;
+                }
+                this.symbolInstanceIndexes = this.getSortedSymbolIndexes(angle2);
+                this.sortedAngle = angle2;
+                this.text.indexArray.clear();
+                this.icon.indexArray.clear();
+                this.featureSortOrder = [];
+                for (var i$1 = 0, list = this.symbolInstanceIndexes; i$1 < list.length; i$1 += 1) {
+                  var i2 = list[i$1];
+                  var symbolInstance2 = this.symbolInstances.get(i2);
+                  this.featureSortOrder.push(symbolInstance2.featureIndex);
+                  [
+                    symbolInstance2.rightJustifiedTextSymbolIndex,
+                    symbolInstance2.centerJustifiedTextSymbolIndex,
+                    symbolInstance2.leftJustifiedTextSymbolIndex
+                  ].forEach(function(index, i22, array2) {
+                    if (index >= 0 && array2.indexOf(index) === i22) {
+                      this$1$1.addIndicesForPlacedSymbol(this$1$1.text, index);
+                    }
+                  });
+                  if (symbolInstance2.verticalPlacedTextSymbolIndex >= 0) {
+                    this.addIndicesForPlacedSymbol(this.text, symbolInstance2.verticalPlacedTextSymbolIndex);
+                  }
+                  if (symbolInstance2.placedIconSymbolIndex >= 0) {
+                    this.addIndicesForPlacedSymbol(this.icon, symbolInstance2.placedIconSymbolIndex);
+                  }
+                  if (symbolInstance2.verticalPlacedIconSymbolIndex >= 0) {
+                    this.addIndicesForPlacedSymbol(this.icon, symbolInstance2.verticalPlacedIconSymbolIndex);
+                  }
+                }
+                if (this.text.indexBuffer) {
+                  this.text.indexBuffer.updateData(this.text.indexArray);
+                }
+                if (this.icon.indexBuffer) {
+                  this.icon.indexBuffer.updateData(this.icon.indexArray);
+                }
+              };
+              register2("SymbolBucket", SymbolBucket, {
+                omit: [
+                  "layers",
+                  "collisionBoxArray",
+                  "features",
+                  "compareText"
+                ]
+              });
+              SymbolBucket.MAX_GLYPHS = 65535;
+              SymbolBucket.addDynamicAttributes = addDynamicAttributes;
+              function resolveTokens(properties2, text) {
+                return text.replace(/{([^{}]+)}/g, function(match, key) {
+                  return key in properties2 ? String(properties2[key]) : "";
+                });
+              }
+              var layout$7 = new Properties({
+                "symbol-placement": new DataConstantProperty(spec["layout_symbol"]["symbol-placement"]),
+                "symbol-spacing": new DataConstantProperty(spec["layout_symbol"]["symbol-spacing"]),
+                "symbol-avoid-edges": new DataConstantProperty(spec["layout_symbol"]["symbol-avoid-edges"]),
+                "symbol-sort-key": new DataDrivenProperty(spec["layout_symbol"]["symbol-sort-key"]),
+                "symbol-z-order": new DataConstantProperty(spec["layout_symbol"]["symbol-z-order"]),
+                "icon-allow-overlap": new DataConstantProperty(spec["layout_symbol"]["icon-allow-overlap"]),
+                "icon-ignore-placement": new DataConstantProperty(spec["layout_symbol"]["icon-ignore-placement"]),
+                "icon-optional": new DataConstantProperty(spec["layout_symbol"]["icon-optional"]),
+                "icon-rotation-alignment": new DataConstantProperty(spec["layout_symbol"]["icon-rotation-alignment"]),
+                "icon-size": new DataDrivenProperty(spec["layout_symbol"]["icon-size"]),
+                "icon-text-fit": new DataConstantProperty(spec["layout_symbol"]["icon-text-fit"]),
+                "icon-text-fit-padding": new DataConstantProperty(spec["layout_symbol"]["icon-text-fit-padding"]),
+                "icon-image": new DataDrivenProperty(spec["layout_symbol"]["icon-image"]),
+                "icon-rotate": new DataDrivenProperty(spec["layout_symbol"]["icon-rotate"]),
+                "icon-padding": new DataConstantProperty(spec["layout_symbol"]["icon-padding"]),
+                "icon-keep-upright": new DataConstantProperty(spec["layout_symbol"]["icon-keep-upright"]),
+                "icon-offset": new DataDrivenProperty(spec["layout_symbol"]["icon-offset"]),
+                "icon-anchor": new DataDrivenProperty(spec["layout_symbol"]["icon-anchor"]),
+                "icon-pitch-alignment": new DataConstantProperty(spec["layout_symbol"]["icon-pitch-alignment"]),
+                "text-pitch-alignment": new DataConstantProperty(spec["layout_symbol"]["text-pitch-alignment"]),
+                "text-rotation-alignment": new DataConstantProperty(spec["layout_symbol"]["text-rotation-alignment"]),
+                "text-field": new DataDrivenProperty(spec["layout_symbol"]["text-field"]),
+                "text-font": new DataDrivenProperty(spec["layout_symbol"]["text-font"]),
+                "text-size": new DataDrivenProperty(spec["layout_symbol"]["text-size"]),
+                "text-max-width": new DataDrivenProperty(spec["layout_symbol"]["text-max-width"]),
+                "text-line-height": new DataConstantProperty(spec["layout_symbol"]["text-line-height"]),
+                "text-letter-spacing": new DataDrivenProperty(spec["layout_symbol"]["text-letter-spacing"]),
+                "text-justify": new DataDrivenProperty(spec["layout_symbol"]["text-justify"]),
+                "text-radial-offset": new DataDrivenProperty(spec["layout_symbol"]["text-radial-offset"]),
+                "text-variable-anchor": new DataConstantProperty(spec["layout_symbol"]["text-variable-anchor"]),
+                "text-anchor": new DataDrivenProperty(spec["layout_symbol"]["text-anchor"]),
+                "text-max-angle": new DataConstantProperty(spec["layout_symbol"]["text-max-angle"]),
+                "text-writing-mode": new DataConstantProperty(spec["layout_symbol"]["text-writing-mode"]),
+                "text-rotate": new DataDrivenProperty(spec["layout_symbol"]["text-rotate"]),
+                "text-padding": new DataConstantProperty(spec["layout_symbol"]["text-padding"]),
+                "text-keep-upright": new DataConstantProperty(spec["layout_symbol"]["text-keep-upright"]),
+                "text-transform": new DataDrivenProperty(spec["layout_symbol"]["text-transform"]),
+                "text-offset": new DataDrivenProperty(spec["layout_symbol"]["text-offset"]),
+                "text-allow-overlap": new DataConstantProperty(spec["layout_symbol"]["text-allow-overlap"]),
+                "text-ignore-placement": new DataConstantProperty(spec["layout_symbol"]["text-ignore-placement"]),
+                "text-optional": new DataConstantProperty(spec["layout_symbol"]["text-optional"])
+              });
+              var paint$7 = new Properties({
+                "icon-opacity": new DataDrivenProperty(spec["paint_symbol"]["icon-opacity"]),
+                "icon-color": new DataDrivenProperty(spec["paint_symbol"]["icon-color"]),
+                "icon-halo-color": new DataDrivenProperty(spec["paint_symbol"]["icon-halo-color"]),
+                "icon-halo-width": new DataDrivenProperty(spec["paint_symbol"]["icon-halo-width"]),
+                "icon-halo-blur": new DataDrivenProperty(spec["paint_symbol"]["icon-halo-blur"]),
+                "icon-translate": new DataConstantProperty(spec["paint_symbol"]["icon-translate"]),
+                "icon-translate-anchor": new DataConstantProperty(spec["paint_symbol"]["icon-translate-anchor"]),
+                "text-opacity": new DataDrivenProperty(spec["paint_symbol"]["text-opacity"]),
+                "text-color": new DataDrivenProperty(spec["paint_symbol"]["text-color"], {
+                  runtimeType: ColorType,
+                  getOverride: function(o2) {
+                    return o2.textColor;
+                  },
+                  hasOverride: function(o2) {
+                    return !!o2.textColor;
+                  }
+                }),
+                "text-halo-color": new DataDrivenProperty(spec["paint_symbol"]["text-halo-color"]),
+                "text-halo-width": new DataDrivenProperty(spec["paint_symbol"]["text-halo-width"]),
+                "text-halo-blur": new DataDrivenProperty(spec["paint_symbol"]["text-halo-blur"]),
+                "text-translate": new DataConstantProperty(spec["paint_symbol"]["text-translate"]),
+                "text-translate-anchor": new DataConstantProperty(spec["paint_symbol"]["text-translate-anchor"])
+              });
+              var properties$6 = {
+                paint: paint$7,
+                layout: layout$7
+              };
+              var FormatSectionOverride = function FormatSectionOverride2(defaultValue) {
+                this.type = defaultValue.property.overrides ? defaultValue.property.overrides.runtimeType : NullType;
+                this.defaultValue = defaultValue;
+              };
+              FormatSectionOverride.prototype.evaluate = function evaluate(ctx2) {
+                if (ctx2.formattedSection) {
+                  var overrides = this.defaultValue.property.overrides;
+                  if (overrides && overrides.hasOverride(ctx2.formattedSection)) {
+                    return overrides.getOverride(ctx2.formattedSection);
+                  }
+                }
+                if (ctx2.feature && ctx2.featureState) {
+                  return this.defaultValue.evaluate(ctx2.feature, ctx2.featureState);
+                }
+                return this.defaultValue.property.specification.default;
+              };
+              FormatSectionOverride.prototype.eachChild = function eachChild(fn) {
+                if (!this.defaultValue.isConstant()) {
+                  var expr = this.defaultValue.value;
+                  fn(expr._styleExpression.expression);
+                }
+              };
+              FormatSectionOverride.prototype.outputDefined = function outputDefined() {
+                return false;
+              };
+              FormatSectionOverride.prototype.serialize = function serialize2() {
+                return null;
+              };
+              register2("FormatSectionOverride", FormatSectionOverride, { omit: ["defaultValue"] });
+              var SymbolStyleLayer = function(StyleLayer2) {
+                function SymbolStyleLayer2(layer2) {
+                  StyleLayer2.call(this, layer2, properties$6);
+                }
+                if (StyleLayer2)
+                  SymbolStyleLayer2.__proto__ = StyleLayer2;
+                SymbolStyleLayer2.prototype = Object.create(StyleLayer2 && StyleLayer2.prototype);
+                SymbolStyleLayer2.prototype.constructor = SymbolStyleLayer2;
+                SymbolStyleLayer2.prototype.recalculate = function recalculate(parameters, availableImages) {
+                  StyleLayer2.prototype.recalculate.call(this, parameters, availableImages);
+                  if (this.layout.get("icon-rotation-alignment") === "auto") {
+                    if (this.layout.get("symbol-placement") !== "point") {
+                      this.layout._values["icon-rotation-alignment"] = "map";
+                    } else {
+                      this.layout._values["icon-rotation-alignment"] = "viewport";
+                    }
+                  }
+                  if (this.layout.get("text-rotation-alignment") === "auto") {
+                    if (this.layout.get("symbol-placement") !== "point") {
+                      this.layout._values["text-rotation-alignment"] = "map";
+                    } else {
+                      this.layout._values["text-rotation-alignment"] = "viewport";
+                    }
+                  }
+                  if (this.layout.get("text-pitch-alignment") === "auto") {
+                    this.layout._values["text-pitch-alignment"] = this.layout.get("text-rotation-alignment");
+                  }
+                  if (this.layout.get("icon-pitch-alignment") === "auto") {
+                    this.layout._values["icon-pitch-alignment"] = this.layout.get("icon-rotation-alignment");
+                  }
+                  if (this.layout.get("symbol-placement") === "point") {
+                    var writingModes = this.layout.get("text-writing-mode");
+                    if (writingModes) {
+                      var deduped = [];
+                      for (var i2 = 0, list = writingModes; i2 < list.length; i2 += 1) {
+                        var m2 = list[i2];
+                        if (deduped.indexOf(m2) < 0) {
+                          deduped.push(m2);
+                        }
+                      }
+                      this.layout._values["text-writing-mode"] = deduped;
+                    } else {
+                      this.layout._values["text-writing-mode"] = ["horizontal"];
+                    }
+                  }
+                  this._setPaintOverrides();
+                };
+                SymbolStyleLayer2.prototype.getValueAndResolveTokens = function getValueAndResolveTokens(name3, feature, canonical, availableImages) {
+                  var value = this.layout.get(name3).evaluate(feature, {}, canonical, availableImages);
+                  var unevaluated = this._unevaluatedLayout._values[name3];
+                  if (!unevaluated.isDataDriven() && !isExpression(unevaluated.value) && value) {
+                    return resolveTokens(feature.properties, value);
+                  }
+                  return value;
+                };
+                SymbolStyleLayer2.prototype.createBucket = function createBucket(parameters) {
+                  return new SymbolBucket(parameters);
+                };
+                SymbolStyleLayer2.prototype.queryRadius = function queryRadius() {
+                  return 0;
+                };
+                SymbolStyleLayer2.prototype.queryIntersectsFeature = function queryIntersectsFeature() {
+                  return false;
+                };
+                SymbolStyleLayer2.prototype._setPaintOverrides = function _setPaintOverrides() {
+                  for (var i2 = 0, list = properties$6.paint.overridableProperties; i2 < list.length; i2 += 1) {
+                    var overridable = list[i2];
+                    if (!SymbolStyleLayer2.hasPaintOverride(this.layout, overridable)) {
+                      continue;
+                    }
+                    var overriden = this.paint.get(overridable);
+                    var override = new FormatSectionOverride(overriden);
+                    var styleExpression = new StyleExpression(override, overriden.property.specification);
+                    var expression2 = null;
+                    if (overriden.value.kind === "constant" || overriden.value.kind === "source") {
+                      expression2 = new ZoomConstantExpression("source", styleExpression);
+                    } else {
+                      expression2 = new ZoomDependentExpression("composite", styleExpression, overriden.value.zoomStops, overriden.value._interpolationType);
+                    }
+                    this.paint._values[overridable] = new PossiblyEvaluatedPropertyValue(overriden.property, expression2, overriden.parameters);
+                  }
+                };
+                SymbolStyleLayer2.prototype._handleOverridablePaintPropertyUpdate = function _handleOverridablePaintPropertyUpdate(name3, oldValue, newValue) {
+                  if (!this.layout || oldValue.isDataDriven() || newValue.isDataDriven()) {
+                    return false;
+                  }
+                  return SymbolStyleLayer2.hasPaintOverride(this.layout, name3);
+                };
+                SymbolStyleLayer2.hasPaintOverride = function hasPaintOverride(layout2, propertyName) {
+                  var textField = layout2.get("text-field");
+                  var property = properties$6.paint.properties[propertyName];
+                  var hasOverrides = false;
+                  var checkSections = function(sections) {
+                    for (var i2 = 0, list = sections; i2 < list.length; i2 += 1) {
+                      var section = list[i2];
+                      if (property.overrides && property.overrides.hasOverride(section)) {
+                        hasOverrides = true;
+                        return;
+                      }
+                    }
+                  };
+                  if (textField.value.kind === "constant" && textField.value.value instanceof Formatted) {
+                    checkSections(textField.value.value.sections);
+                  } else if (textField.value.kind === "source") {
+                    var checkExpression = function(expression2) {
+                      if (hasOverrides) {
+                        return;
+                      }
+                      if (expression2 instanceof Literal && typeOf(expression2.value) === FormattedType) {
+                        var formatted = expression2.value;
+                        checkSections(formatted.sections);
+                      } else if (expression2 instanceof FormatExpression) {
+                        checkSections(expression2.sections);
+                      } else {
+                        expression2.eachChild(checkExpression);
+                      }
+                    };
+                    var expr = textField.value;
+                    if (expr._styleExpression) {
+                      checkExpression(expr._styleExpression.expression);
+                    }
+                  }
+                  return hasOverrides;
+                };
+                return SymbolStyleLayer2;
+              }(StyleLayer);
+              var paint$8 = new Properties({
+                "background-color": new DataConstantProperty(spec["paint_background"]["background-color"]),
+                "background-pattern": new CrossFadedProperty(spec["paint_background"]["background-pattern"]),
+                "background-opacity": new DataConstantProperty(spec["paint_background"]["background-opacity"])
+              });
+              var properties$7 = { paint: paint$8 };
+              var BackgroundStyleLayer = function(StyleLayer2) {
+                function BackgroundStyleLayer2(layer2) {
+                  StyleLayer2.call(this, layer2, properties$7);
+                }
+                if (StyleLayer2)
+                  BackgroundStyleLayer2.__proto__ = StyleLayer2;
+                BackgroundStyleLayer2.prototype = Object.create(StyleLayer2 && StyleLayer2.prototype);
+                BackgroundStyleLayer2.prototype.constructor = BackgroundStyleLayer2;
+                return BackgroundStyleLayer2;
+              }(StyleLayer);
+              var paint$9 = new Properties({
+                "raster-opacity": new DataConstantProperty(spec["paint_raster"]["raster-opacity"]),
+                "raster-hue-rotate": new DataConstantProperty(spec["paint_raster"]["raster-hue-rotate"]),
+                "raster-brightness-min": new DataConstantProperty(spec["paint_raster"]["raster-brightness-min"]),
+                "raster-brightness-max": new DataConstantProperty(spec["paint_raster"]["raster-brightness-max"]),
+                "raster-saturation": new DataConstantProperty(spec["paint_raster"]["raster-saturation"]),
+                "raster-contrast": new DataConstantProperty(spec["paint_raster"]["raster-contrast"]),
+                "raster-resampling": new DataConstantProperty(spec["paint_raster"]["raster-resampling"]),
+                "raster-fade-duration": new DataConstantProperty(spec["paint_raster"]["raster-fade-duration"])
+              });
+              var properties$8 = { paint: paint$9 };
+              var RasterStyleLayer = function(StyleLayer2) {
+                function RasterStyleLayer2(layer2) {
+                  StyleLayer2.call(this, layer2, properties$8);
+                }
+                if (StyleLayer2)
+                  RasterStyleLayer2.__proto__ = StyleLayer2;
+                RasterStyleLayer2.prototype = Object.create(StyleLayer2 && StyleLayer2.prototype);
+                RasterStyleLayer2.prototype.constructor = RasterStyleLayer2;
+                return RasterStyleLayer2;
+              }(StyleLayer);
+              function validateCustomStyleLayer(layerObject) {
+                var errors = [];
+                var id22 = layerObject.id;
+                if (id22 === void 0) {
+                  errors.push({ message: "layers." + id22 + ': missing required property "id"' });
+                }
+                if (layerObject.render === void 0) {
+                  errors.push({ message: "layers." + id22 + ': missing required method "render"' });
+                }
+                if (layerObject.renderingMode && layerObject.renderingMode !== "2d" && layerObject.renderingMode !== "3d") {
+                  errors.push({ message: "layers." + id22 + ': property "renderingMode" must be either "2d" or "3d"' });
+                }
+                return errors;
+              }
+              var CustomStyleLayer = function(StyleLayer2) {
+                function CustomStyleLayer2(implementation) {
+                  StyleLayer2.call(this, implementation, {});
+                  this.implementation = implementation;
+                }
+                if (StyleLayer2)
+                  CustomStyleLayer2.__proto__ = StyleLayer2;
+                CustomStyleLayer2.prototype = Object.create(StyleLayer2 && StyleLayer2.prototype);
+                CustomStyleLayer2.prototype.constructor = CustomStyleLayer2;
+                CustomStyleLayer2.prototype.is3D = function is3D() {
+                  return this.implementation.renderingMode === "3d";
+                };
+                CustomStyleLayer2.prototype.hasOffscreenPass = function hasOffscreenPass() {
+                  return this.implementation.prerender !== void 0;
+                };
+                CustomStyleLayer2.prototype.recalculate = function recalculate() {
+                };
+                CustomStyleLayer2.prototype.updateTransitions = function updateTransitions() {
+                };
+                CustomStyleLayer2.prototype.hasTransition = function hasTransition() {
+                };
+                CustomStyleLayer2.prototype.serialize = function serialize2() {
+                };
+                CustomStyleLayer2.prototype.onAdd = function onAdd(map2) {
+                  if (this.implementation.onAdd) {
+                    this.implementation.onAdd(map2, map2.painter.context.gl);
+                  }
+                };
+                CustomStyleLayer2.prototype.onRemove = function onRemove(map2) {
+                  if (this.implementation.onRemove) {
+                    this.implementation.onRemove(map2, map2.painter.context.gl);
+                  }
+                };
+                return CustomStyleLayer2;
+              }(StyleLayer);
+              var subclasses = {
+                circle: CircleStyleLayer,
+                heatmap: HeatmapStyleLayer,
+                hillshade: HillshadeStyleLayer,
+                fill: FillStyleLayer,
+                "fill-extrusion": FillExtrusionStyleLayer,
+                line: LineStyleLayer,
+                symbol: SymbolStyleLayer,
+                background: BackgroundStyleLayer,
+                raster: RasterStyleLayer
+              };
+              function createStyleLayer(layer2) {
+                if (layer2.type === "custom") {
+                  return new CustomStyleLayer(layer2);
+                } else {
+                  return new subclasses[layer2.type](layer2);
+                }
+              }
+              var HTMLImageElement2 = window$1.HTMLImageElement;
+              var HTMLCanvasElement2 = window$1.HTMLCanvasElement;
+              var HTMLVideoElement2 = window$1.HTMLVideoElement;
+              var ImageData$1 = window$1.ImageData;
+              var ImageBitmap$1 = window$1.ImageBitmap;
+              var Texture2 = function Texture22(context, image, format, options) {
+                this.context = context;
+                this.format = format;
+                this.texture = context.gl.createTexture();
+                this.update(image, options);
+              };
+              Texture2.prototype.update = function update(image, options, position) {
+                var width = image.width;
+                var height = image.height;
+                var resize = (!this.size || this.size[0] !== width || this.size[1] !== height) && !position;
+                var ref = this;
+                var context = ref.context;
+                var gl2 = context.gl;
+                this.useMipmap = Boolean(options && options.useMipmap);
+                gl2.bindTexture(gl2.TEXTURE_2D, this.texture);
+                context.pixelStoreUnpackFlipY.set(false);
+                context.pixelStoreUnpack.set(1);
+                context.pixelStoreUnpackPremultiplyAlpha.set(this.format === gl2.RGBA && (!options || options.premultiply !== false));
+                if (resize) {
+                  this.size = [
+                    width,
+                    height
+                  ];
+                  if (image instanceof HTMLImageElement2 || image instanceof HTMLCanvasElement2 || image instanceof HTMLVideoElement2 || image instanceof ImageData$1 || ImageBitmap$1 && image instanceof ImageBitmap$1) {
+                    gl2.texImage2D(gl2.TEXTURE_2D, 0, this.format, this.format, gl2.UNSIGNED_BYTE, image);
+                  } else {
+                    gl2.texImage2D(gl2.TEXTURE_2D, 0, this.format, width, height, 0, this.format, gl2.UNSIGNED_BYTE, image.data);
+                  }
+                } else {
+                  var ref$1 = position || {
+                    x: 0,
+                    y: 0
+                  };
+                  var x2 = ref$1.x;
+                  var y2 = ref$1.y;
+                  if (image instanceof HTMLImageElement2 || image instanceof HTMLCanvasElement2 || image instanceof HTMLVideoElement2 || image instanceof ImageData$1 || ImageBitmap$1 && image instanceof ImageBitmap$1) {
+                    gl2.texSubImage2D(gl2.TEXTURE_2D, 0, x2, y2, gl2.RGBA, gl2.UNSIGNED_BYTE, image);
+                  } else {
+                    gl2.texSubImage2D(gl2.TEXTURE_2D, 0, x2, y2, width, height, gl2.RGBA, gl2.UNSIGNED_BYTE, image.data);
+                  }
+                }
+                if (this.useMipmap && this.isSizePowerOfTwo()) {
+                  gl2.generateMipmap(gl2.TEXTURE_2D);
+                }
+              };
+              Texture2.prototype.bind = function bind(filter2, wrap2, minFilter) {
+                var ref = this;
+                var context = ref.context;
+                var gl2 = context.gl;
+                gl2.bindTexture(gl2.TEXTURE_2D, this.texture);
+                if (minFilter === gl2.LINEAR_MIPMAP_NEAREST && !this.isSizePowerOfTwo()) {
+                  minFilter = gl2.LINEAR;
+                }
+                if (filter2 !== this.filter) {
+                  gl2.texParameteri(gl2.TEXTURE_2D, gl2.TEXTURE_MAG_FILTER, filter2);
+                  gl2.texParameteri(gl2.TEXTURE_2D, gl2.TEXTURE_MIN_FILTER, minFilter || filter2);
+                  this.filter = filter2;
+                }
+                if (wrap2 !== this.wrap) {
+                  gl2.texParameteri(gl2.TEXTURE_2D, gl2.TEXTURE_WRAP_S, wrap2);
+                  gl2.texParameteri(gl2.TEXTURE_2D, gl2.TEXTURE_WRAP_T, wrap2);
+                  this.wrap = wrap2;
+                }
+              };
+              Texture2.prototype.isSizePowerOfTwo = function isSizePowerOfTwo() {
+                return this.size[0] === this.size[1] && Math.log(this.size[0]) / Math.LN2 % 1 === 0;
+              };
+              Texture2.prototype.destroy = function destroy() {
+                var ref = this.context;
+                var gl2 = ref.gl;
+                gl2.deleteTexture(this.texture);
+                this.texture = null;
+              };
+              var ThrottledInvoker = function ThrottledInvoker2(callback) {
+                var this$1$1 = this;
+                this._callback = callback;
+                this._triggered = false;
+                if (typeof MessageChannel !== "undefined") {
+                  this._channel = new MessageChannel();
+                  this._channel.port2.onmessage = function() {
+                    this$1$1._triggered = false;
+                    this$1$1._callback();
+                  };
+                }
+              };
+              ThrottledInvoker.prototype.trigger = function trigger() {
+                var this$1$1 = this;
+                if (!this._triggered) {
+                  this._triggered = true;
+                  if (this._channel) {
+                    this._channel.port1.postMessage(true);
+                  } else {
+                    setTimeout(function() {
+                      this$1$1._triggered = false;
+                      this$1$1._callback();
+                    }, 0);
+                  }
+                }
+              };
+              ThrottledInvoker.prototype.remove = function remove() {
+                delete this._channel;
+                this._callback = function() {
+                };
+              };
+              var Actor = function Actor2(target, parent, mapId) {
+                this.target = target;
+                this.parent = parent;
+                this.mapId = mapId;
+                this.callbacks = {};
+                this.tasks = {};
+                this.taskQueue = [];
+                this.cancelCallbacks = {};
+                bindAll([
+                  "receive",
+                  "process"
+                ], this);
+                this.invoker = new ThrottledInvoker(this.process);
+                this.target.addEventListener("message", this.receive, false);
+                this.globalScope = isWorker() ? target : window$1;
+              };
+              Actor.prototype.send = function send(type, data, callback, targetMapId, mustQueue) {
+                var this$1$1 = this;
+                if (mustQueue === void 0)
+                  mustQueue = false;
+                var id22 = Math.round(Math.random() * 1e18).toString(36).substring(0, 10);
+                if (callback) {
+                  this.callbacks[id22] = callback;
+                }
+                var buffers = isSafari(this.globalScope) ? void 0 : [];
+                this.target.postMessage({
+                  id: id22,
+                  type,
+                  hasCallback: !!callback,
+                  targetMapId,
+                  mustQueue,
+                  sourceMapId: this.mapId,
+                  data: serialize(data, buffers)
+                }, buffers);
+                return {
+                  cancel: function() {
+                    if (callback) {
+                      delete this$1$1.callbacks[id22];
+                    }
+                    this$1$1.target.postMessage({
+                      id: id22,
+                      type: "<cancel>",
+                      targetMapId,
+                      sourceMapId: this$1$1.mapId
+                    });
+                  }
+                };
+              };
+              Actor.prototype.receive = function receive(message2) {
+                var data = message2.data, id22 = data.id;
+                if (!id22) {
+                  return;
+                }
+                if (data.targetMapId && this.mapId !== data.targetMapId) {
+                  return;
+                }
+                if (data.type === "<cancel>") {
+                  delete this.tasks[id22];
+                  var cancel2 = this.cancelCallbacks[id22];
+                  delete this.cancelCallbacks[id22];
+                  if (cancel2) {
+                    cancel2();
+                  }
+                } else {
+                  if (isWorker() || data.mustQueue) {
+                    this.tasks[id22] = data;
+                    this.taskQueue.push(id22);
+                    this.invoker.trigger();
+                  } else {
+                    this.processTask(id22, data);
+                  }
+                }
+              };
+              Actor.prototype.process = function process2() {
+                if (!this.taskQueue.length) {
+                  return;
+                }
+                var id22 = this.taskQueue.shift();
+                var task = this.tasks[id22];
+                delete this.tasks[id22];
+                if (this.taskQueue.length) {
+                  this.invoker.trigger();
+                }
+                if (!task) {
+                  return;
+                }
+                this.processTask(id22, task);
+              };
+              Actor.prototype.processTask = function processTask(id22, task) {
+                var this$1$1 = this;
+                if (task.type === "<response>") {
+                  var callback = this.callbacks[id22];
+                  delete this.callbacks[id22];
+                  if (callback) {
+                    if (task.error) {
+                      callback(deserialize(task.error));
+                    } else {
+                      callback(null, deserialize(task.data));
+                    }
+                  }
+                } else {
+                  var completed = false;
+                  var buffers = isSafari(this.globalScope) ? void 0 : [];
+                  var done = task.hasCallback ? function(err, data) {
+                    completed = true;
+                    delete this$1$1.cancelCallbacks[id22];
+                    this$1$1.target.postMessage({
+                      id: id22,
+                      type: "<response>",
+                      sourceMapId: this$1$1.mapId,
+                      error: err ? serialize(err) : null,
+                      data: serialize(data, buffers)
+                    }, buffers);
+                  } : function(_2) {
+                    completed = true;
+                  };
+                  var callback$1 = null;
+                  var params = deserialize(task.data);
+                  if (this.parent[task.type]) {
+                    callback$1 = this.parent[task.type](task.sourceMapId, params, done);
+                  } else if (this.parent.getWorkerSource) {
+                    var keys = task.type.split(".");
+                    var scope = this.parent.getWorkerSource(task.sourceMapId, keys[0], params.source);
+                    callback$1 = scope[keys[1]](params, done);
+                  } else {
+                    done(new Error("Could not find function " + task.type));
+                  }
+                  if (!completed && callback$1 && callback$1.cancel) {
+                    this.cancelCallbacks[id22] = callback$1.cancel;
+                  }
+                }
+              };
+              Actor.prototype.remove = function remove() {
+                this.invoker.remove();
+                this.target.removeEventListener("message", this.receive, false);
+              };
+              function getTileBBox(x2, y2, z2) {
+                y2 = Math.pow(2, z2) - y2 - 1;
+                var min = getMercCoords(x2 * 256, y2 * 256, z2), max = getMercCoords((x2 + 1) * 256, (y2 + 1) * 256, z2);
+                return min[0] + "," + min[1] + "," + max[0] + "," + max[1];
+              }
+              function getMercCoords(x2, y2, z2) {
+                var resolution = 2 * Math.PI * 6378137 / 256 / Math.pow(2, z2), merc_x = x2 * resolution - 2 * Math.PI * 6378137 / 2, merc_y = y2 * resolution - 2 * Math.PI * 6378137 / 2;
+                return [merc_x, merc_y];
+              }
+              var LngLatBounds = function LngLatBounds2(sw, ne2) {
+                if (!sw) ;
+                else if (ne2) {
+                  this.setSouthWest(sw).setNorthEast(ne2);
+                } else if (sw.length === 4) {
+                  this.setSouthWest([
+                    sw[0],
+                    sw[1]
+                  ]).setNorthEast([
+                    sw[2],
+                    sw[3]
+                  ]);
+                } else {
+                  this.setSouthWest(sw[0]).setNorthEast(sw[1]);
+                }
+              };
+              LngLatBounds.prototype.setNorthEast = function setNorthEast(ne2) {
+                this._ne = ne2 instanceof LngLat ? new LngLat(ne2.lng, ne2.lat) : LngLat.convert(ne2);
+                return this;
+              };
+              LngLatBounds.prototype.setSouthWest = function setSouthWest(sw) {
+                this._sw = sw instanceof LngLat ? new LngLat(sw.lng, sw.lat) : LngLat.convert(sw);
+                return this;
+              };
+              LngLatBounds.prototype.extend = function extend3(obj) {
+                var sw = this._sw, ne2 = this._ne;
+                var sw2, ne22;
+                if (obj instanceof LngLat) {
+                  sw2 = obj;
+                  ne22 = obj;
+                } else if (obj instanceof LngLatBounds) {
+                  sw2 = obj._sw;
+                  ne22 = obj._ne;
+                  if (!sw2 || !ne22) {
+                    return this;
+                  }
+                } else {
+                  if (Array.isArray(obj)) {
+                    if (obj.length === 4 || obj.every(Array.isArray)) {
+                      var lngLatBoundsObj = obj;
+                      return this.extend(LngLatBounds.convert(lngLatBoundsObj));
+                    } else {
+                      var lngLatObj = obj;
+                      return this.extend(LngLat.convert(lngLatObj));
+                    }
+                  }
+                  return this;
+                }
+                if (!sw && !ne2) {
+                  this._sw = new LngLat(sw2.lng, sw2.lat);
+                  this._ne = new LngLat(ne22.lng, ne22.lat);
+                } else {
+                  sw.lng = Math.min(sw2.lng, sw.lng);
+                  sw.lat = Math.min(sw2.lat, sw.lat);
+                  ne2.lng = Math.max(ne22.lng, ne2.lng);
+                  ne2.lat = Math.max(ne22.lat, ne2.lat);
+                }
+                return this;
+              };
+              LngLatBounds.prototype.getCenter = function getCenter2() {
+                return new LngLat((this._sw.lng + this._ne.lng) / 2, (this._sw.lat + this._ne.lat) / 2);
+              };
+              LngLatBounds.prototype.getSouthWest = function getSouthWest() {
+                return this._sw;
+              };
+              LngLatBounds.prototype.getNorthEast = function getNorthEast() {
+                return this._ne;
+              };
+              LngLatBounds.prototype.getNorthWest = function getNorthWest() {
+                return new LngLat(this.getWest(), this.getNorth());
+              };
+              LngLatBounds.prototype.getSouthEast = function getSouthEast() {
+                return new LngLat(this.getEast(), this.getSouth());
+              };
+              LngLatBounds.prototype.getWest = function getWest() {
+                return this._sw.lng;
+              };
+              LngLatBounds.prototype.getSouth = function getSouth() {
+                return this._sw.lat;
+              };
+              LngLatBounds.prototype.getEast = function getEast() {
+                return this._ne.lng;
+              };
+              LngLatBounds.prototype.getNorth = function getNorth() {
+                return this._ne.lat;
+              };
+              LngLatBounds.prototype.toArray = function toArray() {
+                return [
+                  this._sw.toArray(),
+                  this._ne.toArray()
+                ];
+              };
+              LngLatBounds.prototype.toString = function toString2() {
+                return "LngLatBounds(" + this._sw.toString() + ", " + this._ne.toString() + ")";
+              };
+              LngLatBounds.prototype.isEmpty = function isEmpty2() {
+                return !(this._sw && this._ne);
+              };
+              LngLatBounds.prototype.contains = function contains(lnglat) {
+                var ref = LngLat.convert(lnglat);
+                var lng = ref.lng;
+                var lat = ref.lat;
+                var containsLatitude = this._sw.lat <= lat && lat <= this._ne.lat;
+                var containsLongitude = this._sw.lng <= lng && lng <= this._ne.lng;
+                if (this._sw.lng > this._ne.lng) {
+                  containsLongitude = this._sw.lng >= lng && lng >= this._ne.lng;
+                }
+                return containsLatitude && containsLongitude;
+              };
+              LngLatBounds.convert = function convert(input) {
+                if (!input || input instanceof LngLatBounds) {
+                  return input;
+                }
+                return new LngLatBounds(input);
+              };
+              var earthRadius = 63710088e-1;
+              var LngLat = function LngLat2(lng, lat) {
+                if (isNaN(lng) || isNaN(lat)) {
+                  throw new Error("Invalid LngLat object: (" + lng + ", " + lat + ")");
+                }
+                this.lng = +lng;
+                this.lat = +lat;
+                if (this.lat > 90 || this.lat < -90) {
+                  throw new Error("Invalid LngLat latitude value: must be between -90 and 90");
+                }
+              };
+              LngLat.prototype.wrap = function wrap$1() {
+                return new LngLat(wrap(this.lng, -180, 180), this.lat);
+              };
+              LngLat.prototype.toArray = function toArray() {
+                return [
+                  this.lng,
+                  this.lat
+                ];
+              };
+              LngLat.prototype.toString = function toString2() {
+                return "LngLat(" + this.lng + ", " + this.lat + ")";
+              };
+              LngLat.prototype.distanceTo = function distanceTo(lngLat) {
+                var rad = Math.PI / 180;
+                var lat1 = this.lat * rad;
+                var lat2 = lngLat.lat * rad;
+                var a2 = Math.sin(lat1) * Math.sin(lat2) + Math.cos(lat1) * Math.cos(lat2) * Math.cos((lngLat.lng - this.lng) * rad);
+                var maxMeters = earthRadius * Math.acos(Math.min(a2, 1));
+                return maxMeters;
+              };
+              LngLat.prototype.toBounds = function toBounds(radius) {
+                if (radius === void 0)
+                  radius = 0;
+                var earthCircumferenceInMetersAtEquator = 40075017;
+                var latAccuracy = 360 * radius / earthCircumferenceInMetersAtEquator, lngAccuracy = latAccuracy / Math.cos(Math.PI / 180 * this.lat);
+                return new LngLatBounds(new LngLat(this.lng - lngAccuracy, this.lat - latAccuracy), new LngLat(this.lng + lngAccuracy, this.lat + latAccuracy));
+              };
+              LngLat.convert = function convert(input) {
+                if (input instanceof LngLat) {
+                  return input;
+                }
+                if (Array.isArray(input) && (input.length === 2 || input.length === 3)) {
+                  return new LngLat(Number(input[0]), Number(input[1]));
+                }
+                if (!Array.isArray(input) && typeof input === "object" && input !== null) {
+                  return new LngLat(Number("lng" in input ? input.lng : input.lon), Number(input.lat));
+                }
+                throw new Error("`LngLatLike` argument must be specified as a LngLat instance, an object {lng: <lng>, lat: <lat>}, an object {lon: <lng>, lat: <lat>}, or an array of [<lng>, <lat>]");
+              };
+              var earthCircumfrence = 2 * Math.PI * earthRadius;
+              function circumferenceAtLatitude(latitude) {
+                return earthCircumfrence * Math.cos(latitude * Math.PI / 180);
+              }
+              function mercatorXfromLng$1(lng) {
+                return (180 + lng) / 360;
+              }
+              function mercatorYfromLat$1(lat) {
+                return (180 - 180 / Math.PI * Math.log(Math.tan(Math.PI / 4 + lat * Math.PI / 360))) / 360;
+              }
+              function mercatorZfromAltitude(altitude, lat) {
+                return altitude / circumferenceAtLatitude(lat);
+              }
+              function lngFromMercatorX(x2) {
+                return x2 * 360 - 180;
+              }
+              function latFromMercatorY(y2) {
+                var y22 = 180 - y2 * 360;
+                return 360 / Math.PI * Math.atan(Math.exp(y22 * Math.PI / 180)) - 90;
+              }
+              function altitudeFromMercatorZ(z2, y2) {
+                return z2 * circumferenceAtLatitude(latFromMercatorY(y2));
+              }
+              function mercatorScale(lat) {
+                return 1 / Math.cos(lat * Math.PI / 180);
+              }
+              var MercatorCoordinate = function MercatorCoordinate2(x2, y2, z2) {
+                if (z2 === void 0)
+                  z2 = 0;
+                this.x = +x2;
+                this.y = +y2;
+                this.z = +z2;
+              };
+              MercatorCoordinate.fromLngLat = function fromLngLat(lngLatLike, altitude) {
+                if (altitude === void 0)
+                  altitude = 0;
+                var lngLat = LngLat.convert(lngLatLike);
+                return new MercatorCoordinate(mercatorXfromLng$1(lngLat.lng), mercatorYfromLat$1(lngLat.lat), mercatorZfromAltitude(altitude, lngLat.lat));
+              };
+              MercatorCoordinate.prototype.toLngLat = function toLngLat() {
+                return new LngLat(lngFromMercatorX(this.x), latFromMercatorY(this.y));
+              };
+              MercatorCoordinate.prototype.toAltitude = function toAltitude() {
+                return altitudeFromMercatorZ(this.z, this.y);
+              };
+              MercatorCoordinate.prototype.meterInMercatorCoordinateUnits = function meterInMercatorCoordinateUnits() {
+                return 1 / earthCircumfrence * mercatorScale(latFromMercatorY(this.y));
+              };
+              var CanonicalTileID = function CanonicalTileID2(z2, x2, y2) {
+                this.z = z2;
+                this.x = x2;
+                this.y = y2;
+                this.key = calculateKey(0, z2, z2, x2, y2);
+              };
+              CanonicalTileID.prototype.equals = function equals22(id22) {
+                return this.z === id22.z && this.x === id22.x && this.y === id22.y;
+              };
+              CanonicalTileID.prototype.url = function url(urls, scheme) {
+                var bbox = getTileBBox(this.x, this.y, this.z);
+                var quadkey = getQuadkey(this.z, this.x, this.y);
+                return urls[(this.x + this.y) % urls.length].replace("{prefix}", (this.x % 16).toString(16) + (this.y % 16).toString(16)).replace("{z}", String(this.z)).replace("{x}", String(this.x)).replace("{y}", String(scheme === "tms" ? Math.pow(2, this.z) - this.y - 1 : this.y)).replace("{quadkey}", quadkey).replace("{bbox-epsg-3857}", bbox);
+              };
+              CanonicalTileID.prototype.getTilePoint = function getTilePoint(coord) {
+                var tilesAtZoom = Math.pow(2, this.z);
+                return new pointGeometry((coord.x * tilesAtZoom - this.x) * EXTENT$1, (coord.y * tilesAtZoom - this.y) * EXTENT$1);
+              };
+              CanonicalTileID.prototype.toString = function toString2() {
+                return this.z + "/" + this.x + "/" + this.y;
+              };
+              var UnwrappedTileID = function UnwrappedTileID2(wrap2, canonical) {
+                this.wrap = wrap2;
+                this.canonical = canonical;
+                this.key = calculateKey(wrap2, canonical.z, canonical.z, canonical.x, canonical.y);
+              };
+              var OverscaledTileID = function OverscaledTileID2(overscaledZ, wrap2, z2, x2, y2) {
+                this.overscaledZ = overscaledZ;
+                this.wrap = wrap2;
+                this.canonical = new CanonicalTileID(z2, +x2, +y2);
+                this.key = calculateKey(wrap2, overscaledZ, z2, x2, y2);
+              };
+              OverscaledTileID.prototype.equals = function equals22(id22) {
+                return this.overscaledZ === id22.overscaledZ && this.wrap === id22.wrap && this.canonical.equals(id22.canonical);
+              };
+              OverscaledTileID.prototype.scaledTo = function scaledTo(targetZ) {
+                var zDifference = this.canonical.z - targetZ;
+                if (targetZ > this.canonical.z) {
+                  return new OverscaledTileID(targetZ, this.wrap, this.canonical.z, this.canonical.x, this.canonical.y);
+                } else {
+                  return new OverscaledTileID(targetZ, this.wrap, targetZ, this.canonical.x >> zDifference, this.canonical.y >> zDifference);
+                }
+              };
+              OverscaledTileID.prototype.calculateScaledKey = function calculateScaledKey(targetZ, withWrap) {
+                var zDifference = this.canonical.z - targetZ;
+                if (targetZ > this.canonical.z) {
+                  return calculateKey(this.wrap * +withWrap, targetZ, this.canonical.z, this.canonical.x, this.canonical.y);
+                } else {
+                  return calculateKey(this.wrap * +withWrap, targetZ, targetZ, this.canonical.x >> zDifference, this.canonical.y >> zDifference);
+                }
+              };
+              OverscaledTileID.prototype.isChildOf = function isChildOf(parent) {
+                if (parent.wrap !== this.wrap) {
+                  return false;
+                }
+                var zDifference = this.canonical.z - parent.canonical.z;
+                return parent.overscaledZ === 0 || parent.overscaledZ < this.overscaledZ && parent.canonical.x === this.canonical.x >> zDifference && parent.canonical.y === this.canonical.y >> zDifference;
+              };
+              OverscaledTileID.prototype.children = function children(sourceMaxZoom) {
+                if (this.overscaledZ >= sourceMaxZoom) {
+                  return [new OverscaledTileID(this.overscaledZ + 1, this.wrap, this.canonical.z, this.canonical.x, this.canonical.y)];
+                }
+                var z2 = this.canonical.z + 1;
+                var x2 = this.canonical.x * 2;
+                var y2 = this.canonical.y * 2;
+                return [
+                  new OverscaledTileID(z2, this.wrap, z2, x2, y2),
+                  new OverscaledTileID(z2, this.wrap, z2, x2 + 1, y2),
+                  new OverscaledTileID(z2, this.wrap, z2, x2, y2 + 1),
+                  new OverscaledTileID(z2, this.wrap, z2, x2 + 1, y2 + 1)
+                ];
+              };
+              OverscaledTileID.prototype.isLessThan = function isLessThan(rhs) {
+                if (this.wrap < rhs.wrap) {
+                  return true;
+                }
+                if (this.wrap > rhs.wrap) {
+                  return false;
+                }
+                if (this.overscaledZ < rhs.overscaledZ) {
+                  return true;
+                }
+                if (this.overscaledZ > rhs.overscaledZ) {
+                  return false;
+                }
+                if (this.canonical.x < rhs.canonical.x) {
+                  return true;
+                }
+                if (this.canonical.x > rhs.canonical.x) {
+                  return false;
+                }
+                if (this.canonical.y < rhs.canonical.y) {
+                  return true;
+                }
+                return false;
+              };
+              OverscaledTileID.prototype.wrapped = function wrapped() {
+                return new OverscaledTileID(this.overscaledZ, 0, this.canonical.z, this.canonical.x, this.canonical.y);
+              };
+              OverscaledTileID.prototype.unwrapTo = function unwrapTo(wrap2) {
+                return new OverscaledTileID(this.overscaledZ, wrap2, this.canonical.z, this.canonical.x, this.canonical.y);
+              };
+              OverscaledTileID.prototype.overscaleFactor = function overscaleFactor() {
+                return Math.pow(2, this.overscaledZ - this.canonical.z);
+              };
+              OverscaledTileID.prototype.toUnwrapped = function toUnwrapped() {
+                return new UnwrappedTileID(this.wrap, this.canonical);
+              };
+              OverscaledTileID.prototype.toString = function toString2() {
+                return this.overscaledZ + "/" + this.canonical.x + "/" + this.canonical.y;
+              };
+              OverscaledTileID.prototype.getTilePoint = function getTilePoint(coord) {
+                return this.canonical.getTilePoint(new MercatorCoordinate(coord.x - this.wrap, coord.y));
+              };
+              function calculateKey(wrap2, overscaledZ, z2, x2, y2) {
+                wrap2 *= 2;
+                if (wrap2 < 0) {
+                  wrap2 = wrap2 * -1 - 1;
+                }
+                var dim = 1 << z2;
+                return (dim * dim * wrap2 + dim * y2 + x2).toString(36) + z2.toString(36) + overscaledZ.toString(36);
+              }
+              function getQuadkey(z2, x2, y2) {
+                var quadkey = "", mask;
+                for (var i2 = z2; i2 > 0; i2--) {
+                  mask = 1 << i2 - 1;
+                  quadkey += (x2 & mask ? 1 : 0) + (y2 & mask ? 2 : 0);
+                }
+                return quadkey;
+              }
+              register2("CanonicalTileID", CanonicalTileID);
+              register2("OverscaledTileID", OverscaledTileID, { omit: ["posMatrix"] });
+              var DEMData = function DEMData2(uid2, data, encoding) {
+                this.uid = uid2;
+                if (data.height !== data.width) {
+                  throw new RangeError("DEM tiles must be square");
+                }
+                if (encoding && encoding !== "mapbox" && encoding !== "terrarium") {
+                  return warnOnce('"' + encoding + '" is not a valid encoding type. Valid types include "mapbox" and "terrarium".');
+                }
+                this.stride = data.height;
+                var dim = this.dim = data.height - 2;
+                this.data = new Uint32Array(data.data.buffer);
+                this.encoding = encoding || "mapbox";
+                for (var x2 = 0; x2 < dim; x2++) {
+                  this.data[this._idx(-1, x2)] = this.data[this._idx(0, x2)];
+                  this.data[this._idx(dim, x2)] = this.data[this._idx(dim - 1, x2)];
+                  this.data[this._idx(x2, -1)] = this.data[this._idx(x2, 0)];
+                  this.data[this._idx(x2, dim)] = this.data[this._idx(x2, dim - 1)];
+                }
+                this.data[this._idx(-1, -1)] = this.data[this._idx(0, 0)];
+                this.data[this._idx(dim, -1)] = this.data[this._idx(dim - 1, 0)];
+                this.data[this._idx(-1, dim)] = this.data[this._idx(0, dim - 1)];
+                this.data[this._idx(dim, dim)] = this.data[this._idx(dim - 1, dim - 1)];
+              };
+              DEMData.prototype.get = function get2(x2, y2) {
+                var pixels = new Uint8Array(this.data.buffer);
+                var index = this._idx(x2, y2) * 4;
+                var unpack = this.encoding === "terrarium" ? this._unpackTerrarium : this._unpackMapbox;
+                return unpack(pixels[index], pixels[index + 1], pixels[index + 2]);
+              };
+              DEMData.prototype.getUnpackVector = function getUnpackVector() {
+                return this.encoding === "terrarium" ? [
+                  256,
+                  1,
+                  1 / 256,
+                  32768
+                ] : [
+                  6553.6,
+                  25.6,
+                  0.1,
+                  1e4
+                ];
+              };
+              DEMData.prototype._idx = function _idx(x2, y2) {
+                if (x2 < -1 || x2 >= this.dim + 1 || y2 < -1 || y2 >= this.dim + 1) {
+                  throw new RangeError("out of range source coordinates for DEM data");
+                }
+                return (y2 + 1) * this.stride + (x2 + 1);
+              };
+              DEMData.prototype._unpackMapbox = function _unpackMapbox(r2, g2, b2) {
+                return (r2 * 256 * 256 + g2 * 256 + b2) / 10 - 1e4;
+              };
+              DEMData.prototype._unpackTerrarium = function _unpackTerrarium(r2, g2, b2) {
+                return r2 * 256 + g2 + b2 / 256 - 32768;
+              };
+              DEMData.prototype.getPixels = function getPixels() {
+                return new RGBAImage({
+                  width: this.stride,
+                  height: this.stride
+                }, new Uint8Array(this.data.buffer));
+              };
+              DEMData.prototype.backfillBorder = function backfillBorder(borderTile, dx, dy) {
+                if (this.dim !== borderTile.dim) {
+                  throw new Error("dem dimension mismatch");
+                }
+                var xMin = dx * this.dim, xMax = dx * this.dim + this.dim, yMin = dy * this.dim, yMax = dy * this.dim + this.dim;
+                switch (dx) {
+                  case -1:
+                    xMin = xMax - 1;
+                    break;
+                  case 1:
+                    xMax = xMin + 1;
+                    break;
+                }
+                switch (dy) {
+                  case -1:
+                    yMin = yMax - 1;
+                    break;
+                  case 1:
+                    yMax = yMin + 1;
+                    break;
+                }
+                var ox = -dx * this.dim;
+                var oy = -dy * this.dim;
+                for (var y2 = yMin; y2 < yMax; y2++) {
+                  for (var x2 = xMin; x2 < xMax; x2++) {
+                    this.data[this._idx(x2, y2)] = borderTile.data[this._idx(x2 + ox, y2 + oy)];
+                  }
+                }
+              };
+              register2("DEMData", DEMData);
+              function deserialize$1(input, style) {
+                var output = {};
+                if (!style) {
+                  return output;
+                }
+                var loop = function() {
+                  var bucket = list$1[i$1];
+                  var layers = bucket.layerIds.map(function(id22) {
+                    return style.getLayer(id22);
+                  }).filter(Boolean);
+                  if (layers.length === 0) {
+                    return;
+                  }
+                  bucket.layers = layers;
+                  if (bucket.stateDependentLayerIds) {
+                    bucket.stateDependentLayers = bucket.stateDependentLayerIds.map(function(lId) {
+                      return layers.filter(function(l2) {
+                        return l2.id === lId;
+                      })[0];
+                    });
+                  }
+                  for (var i2 = 0, list = layers; i2 < list.length; i2 += 1) {
+                    var layer2 = list[i2];
+                    output[layer2.id] = bucket;
+                  }
+                };
+                for (var i$1 = 0, list$1 = input; i$1 < list$1.length; i$1 += 1)
+                  loop();
+                return output;
+              }
+              var DictionaryCoder = function DictionaryCoder2(strings) {
+                this._stringToNumber = {};
+                this._numberToString = [];
+                for (var i2 = 0; i2 < strings.length; i2++) {
+                  var string = strings[i2];
+                  this._stringToNumber[string] = i2;
+                  this._numberToString[i2] = string;
+                }
+              };
+              DictionaryCoder.prototype.encode = function encode(string) {
+                return this._stringToNumber[string];
+              };
+              DictionaryCoder.prototype.decode = function decode(n2) {
+                return this._numberToString[n2];
+              };
+              var Feature = function Feature2(vectorTileFeature, z2, x2, y2, id22) {
+                this.type = "Feature";
+                this._vectorTileFeature = vectorTileFeature;
+                vectorTileFeature._z = z2;
+                vectorTileFeature._x = x2;
+                vectorTileFeature._y = y2;
+                this.properties = vectorTileFeature.properties;
+                this.id = id22;
+              };
+              var prototypeAccessors$1 = { geometry: { configurable: true } };
+              prototypeAccessors$1.geometry.get = function() {
+                if (this._geometry === void 0) {
+                  this._geometry = this._vectorTileFeature.toGeoJSON(this._vectorTileFeature._x, this._vectorTileFeature._y, this._vectorTileFeature._z).geometry;
+                }
+                return this._geometry;
+              };
+              prototypeAccessors$1.geometry.set = function(g2) {
+                this._geometry = g2;
+              };
+              Feature.prototype.toJSON = function toJSON() {
+                var json = { geometry: this.geometry };
+                for (var i2 in this) {
+                  if (i2 === "_geometry" || i2 === "_vectorTileFeature") {
+                    continue;
+                  }
+                  json[i2] = this[i2];
+                }
+                return json;
+              };
+              Object.defineProperties(Feature.prototype, prototypeAccessors$1);
+              var SourceFeatureState = function SourceFeatureState2() {
+                this.state = {};
+                this.stateChanges = {};
+                this.deletedStates = {};
+              };
+              SourceFeatureState.prototype.updateState = function updateState(sourceLayer, featureId, newState) {
+                var feature = String(featureId);
+                this.stateChanges[sourceLayer] = this.stateChanges[sourceLayer] || {};
+                this.stateChanges[sourceLayer][feature] = this.stateChanges[sourceLayer][feature] || {};
+                extend2(this.stateChanges[sourceLayer][feature], newState);
+                if (this.deletedStates[sourceLayer] === null) {
+                  this.deletedStates[sourceLayer] = {};
+                  for (var ft2 in this.state[sourceLayer]) {
+                    if (ft2 !== feature) {
+                      this.deletedStates[sourceLayer][ft2] = null;
+                    }
+                  }
+                } else {
+                  var featureDeletionQueued = this.deletedStates[sourceLayer] && this.deletedStates[sourceLayer][feature] === null;
+                  if (featureDeletionQueued) {
+                    this.deletedStates[sourceLayer][feature] = {};
+                    for (var prop in this.state[sourceLayer][feature]) {
+                      if (!newState[prop]) {
+                        this.deletedStates[sourceLayer][feature][prop] = null;
+                      }
+                    }
+                  } else {
+                    for (var key in newState) {
+                      var deletionInQueue = this.deletedStates[sourceLayer] && this.deletedStates[sourceLayer][feature] && this.deletedStates[sourceLayer][feature][key] === null;
+                      if (deletionInQueue) {
+                        delete this.deletedStates[sourceLayer][feature][key];
+                      }
+                    }
+                  }
+                }
+              };
+              SourceFeatureState.prototype.removeFeatureState = function removeFeatureState(sourceLayer, featureId, key) {
+                var sourceLayerDeleted = this.deletedStates[sourceLayer] === null;
+                if (sourceLayerDeleted) {
+                  return;
+                }
+                var feature = String(featureId);
+                this.deletedStates[sourceLayer] = this.deletedStates[sourceLayer] || {};
+                if (key && featureId !== void 0) {
+                  if (this.deletedStates[sourceLayer][feature] !== null) {
+                    this.deletedStates[sourceLayer][feature] = this.deletedStates[sourceLayer][feature] || {};
+                    this.deletedStates[sourceLayer][feature][key] = null;
+                  }
+                } else if (featureId !== void 0) {
+                  var updateInQueue = this.stateChanges[sourceLayer] && this.stateChanges[sourceLayer][feature];
+                  if (updateInQueue) {
+                    this.deletedStates[sourceLayer][feature] = {};
+                    for (key in this.stateChanges[sourceLayer][feature]) {
+                      this.deletedStates[sourceLayer][feature][key] = null;
+                    }
+                  } else {
+                    this.deletedStates[sourceLayer][feature] = null;
+                  }
+                } else {
+                  this.deletedStates[sourceLayer] = null;
+                }
+              };
+              SourceFeatureState.prototype.getState = function getState(sourceLayer, featureId) {
+                var feature = String(featureId);
+                var base = this.state[sourceLayer] || {};
+                var changes = this.stateChanges[sourceLayer] || {};
+                var reconciledState = extend2({}, base[feature], changes[feature]);
+                if (this.deletedStates[sourceLayer] === null) {
+                  return {};
+                } else if (this.deletedStates[sourceLayer]) {
+                  var featureDeletions = this.deletedStates[sourceLayer][featureId];
+                  if (featureDeletions === null) {
+                    return {};
+                  }
+                  for (var prop in featureDeletions) {
+                    delete reconciledState[prop];
+                  }
+                }
+                return reconciledState;
+              };
+              SourceFeatureState.prototype.initializeTileState = function initializeTileState(tile, painter) {
+                tile.setFeatureState(this.state, painter);
+              };
+              SourceFeatureState.prototype.coalesceChanges = function coalesceChanges(tiles, painter) {
+                var featuresChanged = {};
+                for (var sourceLayer in this.stateChanges) {
+                  this.state[sourceLayer] = this.state[sourceLayer] || {};
+                  var layerStates = {};
+                  for (var feature in this.stateChanges[sourceLayer]) {
+                    if (!this.state[sourceLayer][feature]) {
+                      this.state[sourceLayer][feature] = {};
+                    }
+                    extend2(this.state[sourceLayer][feature], this.stateChanges[sourceLayer][feature]);
+                    layerStates[feature] = this.state[sourceLayer][feature];
+                  }
+                  featuresChanged[sourceLayer] = layerStates;
+                }
+                for (var sourceLayer$1 in this.deletedStates) {
+                  this.state[sourceLayer$1] = this.state[sourceLayer$1] || {};
+                  var layerStates$1 = {};
+                  if (this.deletedStates[sourceLayer$1] === null) {
+                    for (var ft2 in this.state[sourceLayer$1]) {
+                      layerStates$1[ft2] = {};
+                      this.state[sourceLayer$1][ft2] = {};
+                    }
+                  } else {
+                    for (var feature$1 in this.deletedStates[sourceLayer$1]) {
+                      var deleteWholeFeatureState = this.deletedStates[sourceLayer$1][feature$1] === null;
+                      if (deleteWholeFeatureState) {
+                        this.state[sourceLayer$1][feature$1] = {};
+                      } else {
+                        for (var i2 = 0, list = Object.keys(this.deletedStates[sourceLayer$1][feature$1]); i2 < list.length; i2 += 1) {
+                          var key = list[i2];
+                          delete this.state[sourceLayer$1][feature$1][key];
+                        }
+                      }
+                      layerStates$1[feature$1] = this.state[sourceLayer$1][feature$1];
+                    }
+                  }
+                  featuresChanged[sourceLayer$1] = featuresChanged[sourceLayer$1] || {};
+                  extend2(featuresChanged[sourceLayer$1], layerStates$1);
+                }
+                this.stateChanges = {};
+                this.deletedStates = {};
+                if (Object.keys(featuresChanged).length === 0) {
+                  return;
+                }
+                for (var id22 in tiles) {
+                  var tile = tiles[id22];
+                  tile.setFeatureState(featuresChanged, painter);
+                }
+              };
+              var FeatureIndex = function FeatureIndex2(tileID, promoteId2) {
+                this.tileID = tileID;
+                this.x = tileID.canonical.x;
+                this.y = tileID.canonical.y;
+                this.z = tileID.canonical.z;
+                this.grid = new gridIndex(EXTENT$1, 16, 0);
+                this.grid3D = new gridIndex(EXTENT$1, 16, 0);
+                this.featureIndexArray = new FeatureIndexArray();
+                this.promoteId = promoteId2;
+              };
+              FeatureIndex.prototype.insert = function insert(feature, geometry2, featureIndex, sourceLayerIndex, bucketIndex, is3D) {
+                var key = this.featureIndexArray.length;
+                this.featureIndexArray.emplaceBack(featureIndex, sourceLayerIndex, bucketIndex);
+                var grid = is3D ? this.grid3D : this.grid;
+                for (var r2 = 0; r2 < geometry2.length; r2++) {
+                  var ring = geometry2[r2];
+                  var bbox = [
+                    Infinity,
+                    Infinity,
+                    -Infinity,
+                    -Infinity
+                  ];
+                  for (var i2 = 0; i2 < ring.length; i2++) {
+                    var p2 = ring[i2];
+                    bbox[0] = Math.min(bbox[0], p2.x);
+                    bbox[1] = Math.min(bbox[1], p2.y);
+                    bbox[2] = Math.max(bbox[2], p2.x);
+                    bbox[3] = Math.max(bbox[3], p2.y);
+                  }
+                  if (bbox[0] < EXTENT$1 && bbox[1] < EXTENT$1 && bbox[2] >= 0 && bbox[3] >= 0) {
+                    grid.insert(key, bbox[0], bbox[1], bbox[2], bbox[3]);
+                  }
+                }
+              };
+              FeatureIndex.prototype.loadVTLayers = function loadVTLayers() {
+                if (!this.vtLayers) {
+                  this.vtLayers = new vectorTile.VectorTile(new pbf(this.rawTileData)).layers;
+                  this.sourceLayerCoder = new DictionaryCoder(this.vtLayers ? Object.keys(this.vtLayers).sort() : ["_geojsonTileLayer"]);
+                }
+                return this.vtLayers;
+              };
+              FeatureIndex.prototype.query = function query(args, styleLayers, serializedLayers, sourceFeatureState) {
+                var this$1$1 = this;
+                this.loadVTLayers();
+                var params = args.params || {}, pixelsToTileUnits = EXTENT$1 / args.tileSize / args.scale, filter2 = createFilter(params.filter);
+                var queryGeometry = args.queryGeometry;
+                var queryPadding = args.queryPadding * pixelsToTileUnits;
+                var bounds = getBounds2(queryGeometry);
+                var matching = this.grid.query(bounds.minX - queryPadding, bounds.minY - queryPadding, bounds.maxX + queryPadding, bounds.maxY + queryPadding);
+                var cameraBounds = getBounds2(args.cameraQueryGeometry);
+                var matching3D = this.grid3D.query(cameraBounds.minX - queryPadding, cameraBounds.minY - queryPadding, cameraBounds.maxX + queryPadding, cameraBounds.maxY + queryPadding, function(bx1, by1, bx2, by2) {
+                  return polygonIntersectsBox(args.cameraQueryGeometry, bx1 - queryPadding, by1 - queryPadding, bx2 + queryPadding, by2 + queryPadding);
+                });
+                for (var i2 = 0, list = matching3D; i2 < list.length; i2 += 1) {
+                  var key = list[i2];
+                  matching.push(key);
+                }
+                matching.sort(topDownFeatureComparator);
+                var result = {};
+                var previousIndex;
+                var loop = function(k22) {
+                  var index = matching[k22];
+                  if (index === previousIndex) {
+                    return;
+                  }
+                  previousIndex = index;
+                  var match = this$1$1.featureIndexArray.get(index);
+                  var featureGeometry = null;
+                  this$1$1.loadMatchingFeature(result, match.bucketIndex, match.sourceLayerIndex, match.featureIndex, filter2, params.layers, params.availableImages, styleLayers, serializedLayers, sourceFeatureState, function(feature, styleLayer, featureState) {
+                    if (!featureGeometry) {
+                      featureGeometry = loadGeometry(feature);
+                    }
+                    return styleLayer.queryIntersectsFeature(queryGeometry, feature, featureState, featureGeometry, this$1$1.z, args.transform, pixelsToTileUnits, args.pixelPosMatrix);
+                  });
+                };
+                for (var k2 = 0; k2 < matching.length; k2++)
+                  loop(k2);
+                return result;
+              };
+              FeatureIndex.prototype.loadMatchingFeature = function loadMatchingFeature(result, bucketIndex, sourceLayerIndex, featureIndex, filter2, filterLayerIDs, availableImages, styleLayers, serializedLayers, sourceFeatureState, intersectionTest) {
+                var layerIDs = this.bucketLayerIDs[bucketIndex];
+                if (filterLayerIDs && !arraysIntersect(filterLayerIDs, layerIDs)) {
+                  return;
+                }
+                var sourceLayerName = this.sourceLayerCoder.decode(sourceLayerIndex);
+                var sourceLayer = this.vtLayers[sourceLayerName];
+                var feature = sourceLayer.feature(featureIndex);
+                if (filter2.needGeometry) {
+                  var evaluationFeature = toEvaluationFeature(feature, true);
+                  if (!filter2.filter(new EvaluationParameters(this.tileID.overscaledZ), evaluationFeature, this.tileID.canonical)) {
+                    return;
+                  }
+                } else if (!filter2.filter(new EvaluationParameters(this.tileID.overscaledZ), feature)) {
+                  return;
+                }
+                var id22 = this.getId(feature, sourceLayerName);
+                for (var l2 = 0; l2 < layerIDs.length; l2++) {
+                  var layerID = layerIDs[l2];
+                  if (filterLayerIDs && filterLayerIDs.indexOf(layerID) < 0) {
+                    continue;
+                  }
+                  var styleLayer = styleLayers[layerID];
+                  if (!styleLayer) {
+                    continue;
+                  }
+                  var featureState = {};
+                  if (id22 !== void 0 && sourceFeatureState) {
+                    featureState = sourceFeatureState.getState(styleLayer.sourceLayer || "_geojsonTileLayer", id22);
+                  }
+                  var serializedLayer = extend2({}, serializedLayers[layerID]);
+                  serializedLayer.paint = evaluateProperties(serializedLayer.paint, styleLayer.paint, feature, featureState, availableImages);
+                  serializedLayer.layout = evaluateProperties(serializedLayer.layout, styleLayer.layout, feature, featureState, availableImages);
+                  var intersectionZ = !intersectionTest || intersectionTest(feature, styleLayer, featureState);
+                  if (!intersectionZ) {
+                    continue;
+                  }
+                  var geojsonFeature = new Feature(feature, this.z, this.x, this.y, id22);
+                  geojsonFeature.layer = serializedLayer;
+                  var layerResult = result[layerID];
+                  if (layerResult === void 0) {
+                    layerResult = result[layerID] = [];
+                  }
+                  layerResult.push({
+                    featureIndex,
+                    feature: geojsonFeature,
+                    intersectionZ
+                  });
+                }
+              };
+              FeatureIndex.prototype.lookupSymbolFeatures = function lookupSymbolFeatures(symbolFeatureIndexes, serializedLayers, bucketIndex, sourceLayerIndex, filterSpec2, filterLayerIDs, availableImages, styleLayers) {
+                var result = {};
+                this.loadVTLayers();
+                var filter2 = createFilter(filterSpec2);
+                for (var i2 = 0, list = symbolFeatureIndexes; i2 < list.length; i2 += 1) {
+                  var symbolFeatureIndex = list[i2];
+                  this.loadMatchingFeature(result, bucketIndex, sourceLayerIndex, symbolFeatureIndex, filter2, filterLayerIDs, availableImages, styleLayers, serializedLayers);
+                }
+                return result;
+              };
+              FeatureIndex.prototype.hasLayer = function hasLayer(id22) {
+                for (var i$1 = 0, list$1 = this.bucketLayerIDs; i$1 < list$1.length; i$1 += 1) {
+                  var layerIDs = list$1[i$1];
+                  for (var i2 = 0, list = layerIDs; i2 < list.length; i2 += 1) {
+                    var layerID = list[i2];
+                    if (id22 === layerID) {
+                      return true;
+                    }
+                  }
+                }
+                return false;
+              };
+              FeatureIndex.prototype.getId = function getId2(feature, sourceLayerId) {
+                var id22 = feature.id;
+                if (this.promoteId) {
+                  var propName = typeof this.promoteId === "string" ? this.promoteId : this.promoteId[sourceLayerId];
+                  id22 = feature.properties[propName];
+                  if (typeof id22 === "boolean") {
+                    id22 = Number(id22);
+                  }
+                }
+                return id22;
+              };
+              register2("FeatureIndex", FeatureIndex, {
+                omit: [
+                  "rawTileData",
+                  "sourceLayerCoder"
+                ]
+              });
+              function evaluateProperties(serializedProperties, styleLayerProperties, feature, featureState, availableImages) {
+                return mapObject(serializedProperties, function(property, key) {
+                  var prop = styleLayerProperties instanceof PossiblyEvaluated ? styleLayerProperties.get(key) : null;
+                  return prop && prop.evaluate ? prop.evaluate(feature, featureState, availableImages) : prop;
+                });
+              }
+              function getBounds2(geometry2) {
+                var minX = Infinity;
+                var minY = Infinity;
+                var maxX = -Infinity;
+                var maxY = -Infinity;
+                for (var i2 = 0, list = geometry2; i2 < list.length; i2 += 1) {
+                  var p2 = list[i2];
+                  minX = Math.min(minX, p2.x);
+                  minY = Math.min(minY, p2.y);
+                  maxX = Math.max(maxX, p2.x);
+                  maxY = Math.max(maxY, p2.y);
+                }
+                return {
+                  minX,
+                  minY,
+                  maxX,
+                  maxY
+                };
+              }
+              function topDownFeatureComparator(a2, b2) {
+                return b2 - a2;
+              }
+              var CLOCK_SKEW_RETRY_TIMEOUT = 3e4;
+              var Tile = function Tile2(tileID, size) {
+                this.tileID = tileID;
+                this.uid = uniqueId2();
+                this.uses = 0;
+                this.tileSize = size;
+                this.buckets = {};
+                this.expirationTime = null;
+                this.queryPadding = 0;
+                this.hasSymbolBuckets = false;
+                this.hasRTLText = false;
+                this.dependencies = {};
+                this.expiredRequestCount = 0;
+                this.state = "loading";
+              };
+              Tile.prototype.registerFadeDuration = function registerFadeDuration(duration) {
+                var fadeEndTime = duration + this.timeAdded;
+                if (fadeEndTime < exported.now()) {
+                  return;
+                }
+                if (this.fadeEndTime && fadeEndTime < this.fadeEndTime) {
+                  return;
+                }
+                this.fadeEndTime = fadeEndTime;
+              };
+              Tile.prototype.wasRequested = function wasRequested() {
+                return this.state === "errored" || this.state === "loaded" || this.state === "reloading";
+              };
+              Tile.prototype.loadVectorData = function loadVectorData(data, painter, justReloaded) {
+                if (this.hasData()) {
+                  this.unloadVectorData();
+                }
+                this.state = "loaded";
+                if (!data) {
+                  this.collisionBoxArray = new CollisionBoxArray();
+                  return;
+                }
+                if (data.featureIndex) {
+                  this.latestFeatureIndex = data.featureIndex;
+                  if (data.rawTileData) {
+                    this.latestRawTileData = data.rawTileData;
+                    this.latestFeatureIndex.rawTileData = data.rawTileData;
+                  } else if (this.latestRawTileData) {
+                    this.latestFeatureIndex.rawTileData = this.latestRawTileData;
+                  }
+                }
+                this.collisionBoxArray = data.collisionBoxArray;
+                this.buckets = deserialize$1(data.buckets, painter.style);
+                this.hasSymbolBuckets = false;
+                for (var id22 in this.buckets) {
+                  var bucket = this.buckets[id22];
+                  if (bucket instanceof SymbolBucket) {
+                    this.hasSymbolBuckets = true;
+                    if (justReloaded) {
+                      bucket.justReloaded = true;
+                    } else {
+                      break;
+                    }
+                  }
+                }
+                this.hasRTLText = false;
+                if (this.hasSymbolBuckets) {
+                  for (var id$1 in this.buckets) {
+                    var bucket$1 = this.buckets[id$1];
+                    if (bucket$1 instanceof SymbolBucket) {
+                      if (bucket$1.hasRTLText) {
+                        this.hasRTLText = true;
+                        lazyLoadRTLTextPlugin();
+                        break;
+                      }
+                    }
+                  }
+                }
+                this.queryPadding = 0;
+                for (var id$2 in this.buckets) {
+                  var bucket$2 = this.buckets[id$2];
+                  this.queryPadding = Math.max(this.queryPadding, painter.style.getLayer(id$2).queryRadius(bucket$2));
+                }
+                if (data.imageAtlas) {
+                  this.imageAtlas = data.imageAtlas;
+                }
+                if (data.glyphAtlasImage) {
+                  this.glyphAtlasImage = data.glyphAtlasImage;
+                }
+              };
+              Tile.prototype.unloadVectorData = function unloadVectorData() {
+                for (var id22 in this.buckets) {
+                  this.buckets[id22].destroy();
+                }
+                this.buckets = {};
+                if (this.imageAtlasTexture) {
+                  this.imageAtlasTexture.destroy();
+                }
+                if (this.imageAtlas) {
+                  this.imageAtlas = null;
+                }
+                if (this.glyphAtlasTexture) {
+                  this.glyphAtlasTexture.destroy();
+                }
+                this.latestFeatureIndex = null;
+                this.state = "unloaded";
+              };
+              Tile.prototype.getBucket = function getBucket(layer2) {
+                return this.buckets[layer2.id];
+              };
+              Tile.prototype.upload = function upload(context) {
+                for (var id22 in this.buckets) {
+                  var bucket = this.buckets[id22];
+                  if (bucket.uploadPending()) {
+                    bucket.upload(context);
+                  }
+                }
+                var gl2 = context.gl;
+                if (this.imageAtlas && !this.imageAtlas.uploaded) {
+                  this.imageAtlasTexture = new Texture2(context, this.imageAtlas.image, gl2.RGBA);
+                  this.imageAtlas.uploaded = true;
+                }
+                if (this.glyphAtlasImage) {
+                  this.glyphAtlasTexture = new Texture2(context, this.glyphAtlasImage, gl2.ALPHA);
+                  this.glyphAtlasImage = null;
+                }
+              };
+              Tile.prototype.prepare = function prepare(imageManager) {
+                if (this.imageAtlas) {
+                  this.imageAtlas.patchUpdatedImages(imageManager, this.imageAtlasTexture);
+                }
+              };
+              Tile.prototype.queryRenderedFeatures = function queryRenderedFeatures(layers, serializedLayers, sourceFeatureState, queryGeometry, cameraQueryGeometry, scale22, params, transform, maxPitchScaleFactor, pixelPosMatrix) {
+                if (!this.latestFeatureIndex || !this.latestFeatureIndex.rawTileData) {
+                  return {};
+                }
+                return this.latestFeatureIndex.query({
+                  queryGeometry,
+                  cameraQueryGeometry,
+                  scale: scale22,
+                  tileSize: this.tileSize,
+                  pixelPosMatrix,
+                  transform,
+                  params,
+                  queryPadding: this.queryPadding * maxPitchScaleFactor
+                }, layers, serializedLayers, sourceFeatureState);
+              };
+              Tile.prototype.querySourceFeatures = function querySourceFeatures(result, params) {
+                var featureIndex = this.latestFeatureIndex;
+                if (!featureIndex || !featureIndex.rawTileData) {
+                  return;
+                }
+                var vtLayers = featureIndex.loadVTLayers();
+                var sourceLayer = params ? params.sourceLayer : "";
+                var layer2 = vtLayers._geojsonTileLayer || vtLayers[sourceLayer];
+                if (!layer2) {
+                  return;
+                }
+                var filter2 = createFilter(params && params.filter);
+                var ref = this.tileID.canonical;
+                var z2 = ref.z;
+                var x2 = ref.x;
+                var y2 = ref.y;
+                var coord = {
+                  z: z2,
+                  x: x2,
+                  y: y2
+                };
+                for (var i2 = 0; i2 < layer2.length; i2++) {
+                  var feature = layer2.feature(i2);
+                  if (filter2.needGeometry) {
+                    var evaluationFeature = toEvaluationFeature(feature, true);
+                    if (!filter2.filter(new EvaluationParameters(this.tileID.overscaledZ), evaluationFeature, this.tileID.canonical)) {
+                      continue;
+                    }
+                  } else if (!filter2.filter(new EvaluationParameters(this.tileID.overscaledZ), feature)) {
+                    continue;
+                  }
+                  var id22 = featureIndex.getId(feature, sourceLayer);
+                  var geojsonFeature = new Feature(feature, z2, x2, y2, id22);
+                  geojsonFeature.tile = coord;
+                  result.push(geojsonFeature);
+                }
+              };
+              Tile.prototype.hasData = function hasData() {
+                return this.state === "loaded" || this.state === "reloading" || this.state === "expired";
+              };
+              Tile.prototype.patternsLoaded = function patternsLoaded() {
+                return this.imageAtlas && !!Object.keys(this.imageAtlas.patternPositions).length;
+              };
+              Tile.prototype.setExpiryData = function setExpiryData(data) {
+                var prior = this.expirationTime;
+                if (data.cacheControl) {
+                  var parsedCC = parseCacheControl(data.cacheControl);
+                  if (parsedCC["max-age"]) {
+                    this.expirationTime = Date.now() + parsedCC["max-age"] * 1e3;
+                  }
+                } else if (data.expires) {
+                  this.expirationTime = new Date(data.expires).getTime();
+                }
+                if (this.expirationTime) {
+                  var now2 = Date.now();
+                  var isExpired = false;
+                  if (this.expirationTime > now2) {
+                    isExpired = false;
+                  } else if (!prior) {
+                    isExpired = true;
+                  } else if (this.expirationTime < prior) {
+                    isExpired = true;
+                  } else {
+                    var delta = this.expirationTime - prior;
+                    if (!delta) {
+                      isExpired = true;
+                    } else {
+                      this.expirationTime = now2 + Math.max(delta, CLOCK_SKEW_RETRY_TIMEOUT);
+                    }
+                  }
+                  if (isExpired) {
+                    this.expiredRequestCount++;
+                    this.state = "expired";
+                  } else {
+                    this.expiredRequestCount = 0;
+                  }
+                }
+              };
+              Tile.prototype.getExpiryTimeout = function getExpiryTimeout() {
+                if (this.expirationTime) {
+                  if (this.expiredRequestCount) {
+                    return 1e3 * (1 << Math.min(this.expiredRequestCount - 1, 31));
+                  } else {
+                    return Math.min(this.expirationTime - (/* @__PURE__ */ new Date()).getTime(), Math.pow(2, 31) - 1);
+                  }
+                }
+              };
+              Tile.prototype.setFeatureState = function setFeatureState(states, painter) {
+                if (!this.latestFeatureIndex || !this.latestFeatureIndex.rawTileData || Object.keys(states).length === 0) {
+                  return;
+                }
+                var vtLayers = this.latestFeatureIndex.loadVTLayers();
+                for (var id22 in this.buckets) {
+                  if (!painter.style.hasLayer(id22)) {
+                    continue;
+                  }
+                  var bucket = this.buckets[id22];
+                  var sourceLayerId = bucket.layers[0]["sourceLayer"] || "_geojsonTileLayer";
+                  var sourceLayer = vtLayers[sourceLayerId];
+                  var sourceLayerStates = states[sourceLayerId];
+                  if (!sourceLayer || !sourceLayerStates || Object.keys(sourceLayerStates).length === 0) {
+                    continue;
+                  }
+                  bucket.update(sourceLayerStates, sourceLayer, this.imageAtlas && this.imageAtlas.patternPositions || {});
+                  var layer2 = painter && painter.style && painter.style.getLayer(id22);
+                  if (layer2) {
+                    this.queryPadding = Math.max(this.queryPadding, layer2.queryRadius(bucket));
+                  }
+                }
+              };
+              Tile.prototype.holdingForFade = function holdingForFade() {
+                return this.symbolFadeHoldUntil !== void 0;
+              };
+              Tile.prototype.symbolFadeFinished = function symbolFadeFinished() {
+                return !this.symbolFadeHoldUntil || this.symbolFadeHoldUntil < exported.now();
+              };
+              Tile.prototype.clearFadeHold = function clearFadeHold() {
+                this.symbolFadeHoldUntil = void 0;
+              };
+              Tile.prototype.setHoldDuration = function setHoldDuration(duration) {
+                this.symbolFadeHoldUntil = exported.now() + duration;
+              };
+              Tile.prototype.setDependencies = function setDependencies(namespace, dependencies) {
+                var index = {};
+                for (var i2 = 0, list = dependencies; i2 < list.length; i2 += 1) {
+                  var dep = list[i2];
+                  index[dep] = true;
+                }
+                this.dependencies[namespace] = index;
+              };
+              Tile.prototype.hasDependency = function hasDependency(namespaces, keys) {
+                for (var i$1 = 0, list$1 = namespaces; i$1 < list$1.length; i$1 += 1) {
+                  var namespace = list$1[i$1];
+                  var dependencies = this.dependencies[namespace];
+                  if (dependencies) {
+                    for (var i2 = 0, list = keys; i2 < list.length; i2 += 1) {
+                      var key = list[i2];
+                      if (dependencies[key]) {
+                        return true;
+                      }
+                    }
+                  }
+                }
+                return false;
+              };
+              var refProperties = [
+                "type",
+                "source",
+                "source-layer",
+                "minzoom",
+                "maxzoom",
+                "filter",
+                "layout"
+              ];
+              var performance2 = window$1.performance;
+              var RequestPerformance = function RequestPerformance2(request) {
+                this._marks = {
+                  start: [
+                    request.url,
+                    "start"
+                  ].join("#"),
+                  end: [
+                    request.url,
+                    "end"
+                  ].join("#"),
+                  measure: request.url.toString()
+                };
+                performance2.mark(this._marks.start);
+              };
+              RequestPerformance.prototype.finish = function finish() {
+                performance2.mark(this._marks.end);
+                var resourceTimingData = performance2.getEntriesByName(this._marks.measure);
+                if (resourceTimingData.length === 0) {
+                  performance2.measure(this._marks.measure, this._marks.start, this._marks.end);
+                  resourceTimingData = performance2.getEntriesByName(this._marks.measure);
+                  performance2.clearMarks(this._marks.start);
+                  performance2.clearMarks(this._marks.end);
+                  performance2.clearMeasures(this._marks.measure);
+                }
+                return resourceTimingData;
+              };
+              exports2.Actor = Actor;
+              exports2.AlphaImage = AlphaImage;
+              exports2.CanonicalTileID = CanonicalTileID;
+              exports2.CollisionBoxArray = CollisionBoxArray;
+              exports2.Color = Color2;
+              exports2.DEMData = DEMData;
+              exports2.DataConstantProperty = DataConstantProperty;
+              exports2.DictionaryCoder = DictionaryCoder;
+              exports2.EXTENT = EXTENT$1;
+              exports2.ErrorEvent = ErrorEvent;
+              exports2.EvaluationParameters = EvaluationParameters;
+              exports2.Event = Event2;
+              exports2.Evented = Evented;
+              exports2.FeatureIndex = FeatureIndex;
+              exports2.FillBucket = FillBucket;
+              exports2.FillExtrusionBucket = FillExtrusionBucket;
+              exports2.ImageAtlas = ImageAtlas;
+              exports2.ImagePosition = ImagePosition;
+              exports2.LineBucket = LineBucket;
+              exports2.LngLat = LngLat;
+              exports2.LngLatBounds = LngLatBounds;
+              exports2.MercatorCoordinate = MercatorCoordinate;
+              exports2.ONE_EM = ONE_EM;
+              exports2.OverscaledTileID = OverscaledTileID;
+              exports2.Point = pointGeometry;
+              exports2.Point$1 = pointGeometry;
+              exports2.Properties = Properties;
+              exports2.Protobuf = pbf;
+              exports2.RGBAImage = RGBAImage;
+              exports2.RequestManager = RequestManager;
+              exports2.RequestPerformance = RequestPerformance;
+              exports2.ResourceType = ResourceType;
+              exports2.SegmentVector = SegmentVector;
+              exports2.SourceFeatureState = SourceFeatureState;
+              exports2.StructArrayLayout1ui2 = StructArrayLayout1ui2;
+              exports2.StructArrayLayout2f1f2i16 = StructArrayLayout2f1f2i16;
+              exports2.StructArrayLayout2i4 = StructArrayLayout2i4;
+              exports2.StructArrayLayout3ui6 = StructArrayLayout3ui6;
+              exports2.StructArrayLayout4i8 = StructArrayLayout4i8;
+              exports2.SymbolBucket = SymbolBucket;
+              exports2.Texture = Texture2;
+              exports2.Tile = Tile;
+              exports2.Transitionable = Transitionable;
+              exports2.Uniform1f = Uniform1f;
+              exports2.Uniform1i = Uniform1i;
+              exports2.Uniform2f = Uniform2f;
+              exports2.Uniform3f = Uniform3f;
+              exports2.Uniform4f = Uniform4f;
+              exports2.UniformColor = UniformColor;
+              exports2.UniformMatrix4f = UniformMatrix4f;
+              exports2.UnwrappedTileID = UnwrappedTileID;
+              exports2.ValidationError = ValidationError;
+              exports2.WritingMode = WritingMode;
+              exports2.ZoomHistory = ZoomHistory;
+              exports2.add = add2;
+              exports2.addDynamicAttributes = addDynamicAttributes;
+              exports2.asyncAll = asyncAll;
+              exports2.bezier = bezier;
+              exports2.bindAll = bindAll;
+              exports2.browser = exported;
+              exports2.cacheEntryPossiblyAdded = cacheEntryPossiblyAdded;
+              exports2.clamp = clamp2;
+              exports2.clearTileCache = clearTileCache;
+              exports2.clipLine = clipLine;
+              exports2.clone = clone$1;
+              exports2.clone$1 = clone;
+              exports2.clone$2 = clone$2;
+              exports2.collisionCircleLayout = collisionCircleLayout;
+              exports2.config = config2;
+              exports2.create = create$22;
+              exports2.create$1 = create$12;
+              exports2.create$2 = create2;
+              exports2.createCommonjsModule = createCommonjsModule;
+              exports2.createExpression = createExpression;
+              exports2.createLayout = createLayout;
+              exports2.createStyleLayer = createStyleLayer;
+              exports2.cross = cross2;
+              exports2.deepEqual = deepEqual2;
+              exports2.dot = dot2;
+              exports2.dot$1 = dot$1;
+              exports2.ease = ease;
+              exports2.emitValidationErrors = emitValidationErrors;
+              exports2.endsWith = endsWith;
+              exports2.enforceCacheSizeLimit = enforceCacheSizeLimit;
+              exports2.evaluateSizeForFeature = evaluateSizeForFeature;
+              exports2.evaluateSizeForZoom = evaluateSizeForZoom;
+              exports2.evaluateVariableOffset = evaluateVariableOffset;
+              exports2.evented = evented;
+              exports2.extend = extend2;
+              exports2.featureFilter = createFilter;
+              exports2.filterObject = filterObject;
+              exports2.fromRotation = fromRotation;
+              exports2.getAnchorAlignment = getAnchorAlignment;
+              exports2.getAnchorJustification = getAnchorJustification;
+              exports2.getArrayBuffer = getArrayBuffer;
+              exports2.getImage = getImage;
+              exports2.getJSON = getJSON;
+              exports2.getRTLTextPluginStatus = getRTLTextPluginStatus;
+              exports2.getReferrer = getReferrer;
+              exports2.getVideo = getVideo;
+              exports2.identity = identity22;
+              exports2.invert = invert2;
+              exports2.isChar = unicodeBlockLookup;
+              exports2.isMapboxURL = isMapboxURL;
+              exports2.keysDifference = keysDifference;
+              exports2.makeRequest = makeRequest;
+              exports2.mapObject = mapObject;
+              exports2.mercatorXfromLng = mercatorXfromLng$1;
+              exports2.mercatorYfromLat = mercatorYfromLat$1;
+              exports2.mercatorZfromAltitude = mercatorZfromAltitude;
+              exports2.mul = mul;
+              exports2.multiply = multiply2;
+              exports2.mvt = vectorTile;
+              exports2.nextPowerOfTwo = nextPowerOfTwo;
+              exports2.normalize = normalize;
+              exports2.number = number;
+              exports2.offscreenCanvasSupported = offscreenCanvasSupported;
+              exports2.ortho = ortho2;
+              exports2.parseGlyphPBF = parseGlyphPBF;
+              exports2.pbf = pbf;
+              exports2.performSymbolLayout = performSymbolLayout;
+              exports2.perspective = perspective2;
+              exports2.pick = pick;
+              exports2.plugin = plugin;
+              exports2.polygonIntersectsPolygon = polygonIntersectsPolygon;
+              exports2.postMapLoadEvent = postMapLoadEvent;
+              exports2.postTurnstileEvent = postTurnstileEvent;
+              exports2.potpack = potpack;
+              exports2.refProperties = refProperties;
+              exports2.register = register2;
+              exports2.registerForPluginStateChange = registerForPluginStateChange;
+              exports2.renderColorRamp = renderColorRamp;
+              exports2.rotate = rotate2;
+              exports2.rotateX = rotateX2;
+              exports2.rotateZ = rotateZ2;
+              exports2.scale = scale2;
+              exports2.scale$1 = scale$2;
+              exports2.scale$2 = scale$12;
+              exports2.setCacheLimits = setCacheLimits;
+              exports2.setRTLTextPlugin = setRTLTextPlugin;
+              exports2.sphericalToCartesian = sphericalToCartesian;
+              exports2.sqrLen = sqrLen2;
+              exports2.styleSpec = spec;
+              exports2.sub = sub2;
+              exports2.symbolSize = symbolSize;
+              exports2.transformMat3 = transformMat32;
+              exports2.transformMat4 = transformMat42;
+              exports2.translate = translate$1;
+              exports2.triggerPluginCompletionEvent = triggerPluginCompletionEvent;
+              exports2.uniqueId = uniqueId2;
+              exports2.validateCustomStyleLayer = validateCustomStyleLayer;
+              exports2.validateLight = validateLight$1;
+              exports2.validateStyle = validateStyle;
+              exports2.values = values;
+              exports2.vectorTile = vectorTile;
+              exports2.version = version2;
+              exports2.warnOnce = warnOnce;
+              exports2.webpSupported = exported$1;
+              exports2.window = window$1;
+              exports2.wrap = wrap;
+            });
+            define2(["./shared"], function(performance2) {
+              function stringify(obj) {
+                var type = typeof obj;
+                if (type === "number" || type === "boolean" || type === "string" || obj === void 0 || obj === null) {
+                  return JSON.stringify(obj);
+                }
+                if (Array.isArray(obj)) {
+                  var str$1 = "[";
+                  for (var i$1 = 0, list = obj; i$1 < list.length; i$1 += 1) {
+                    var val = list[i$1];
+                    str$1 += stringify(val) + ",";
+                  }
+                  return str$1 + "]";
+                }
+                var keys = Object.keys(obj).sort();
+                var str = "{";
+                for (var i2 = 0; i2 < keys.length; i2++) {
+                  str += JSON.stringify(keys[i2]) + ":" + stringify(obj[keys[i2]]) + ",";
+                }
+                return str + "}";
+              }
+              function getKey(layer) {
+                var key = "";
+                for (var i2 = 0, list = performance2.refProperties; i2 < list.length; i2 += 1) {
+                  var k2 = list[i2];
+                  key += "/" + stringify(layer[k2]);
+                }
+                return key;
+              }
+              function groupByLayout(layers, cachedKeys) {
+                var groups = {};
+                for (var i2 = 0; i2 < layers.length; i2++) {
+                  var k2 = cachedKeys && cachedKeys[layers[i2].id] || getKey(layers[i2]);
+                  if (cachedKeys) {
+                    cachedKeys[layers[i2].id] = k2;
+                  }
+                  var group = groups[k2];
+                  if (!group) {
+                    group = groups[k2] = [];
+                  }
+                  group.push(layers[i2]);
+                }
+                var result = [];
+                for (var k$12 in groups) {
+                  result.push(groups[k$12]);
+                }
+                return result;
+              }
+              var StyleLayerIndex = function StyleLayerIndex2(layerConfigs) {
+                this.keyCache = {};
+                if (layerConfigs) {
+                  this.replace(layerConfigs);
+                }
+              };
+              StyleLayerIndex.prototype.replace = function replace(layerConfigs) {
+                this._layerConfigs = {};
+                this._layers = {};
+                this.update(layerConfigs, []);
+              };
+              StyleLayerIndex.prototype.update = function update(layerConfigs, removedIds) {
+                var this$1$1 = this;
+                for (var i2 = 0, list = layerConfigs; i2 < list.length; i2 += 1) {
+                  var layerConfig = list[i2];
+                  this._layerConfigs[layerConfig.id] = layerConfig;
+                  var layer = this._layers[layerConfig.id] = performance2.createStyleLayer(layerConfig);
+                  layer._featureFilter = performance2.featureFilter(layer.filter);
+                  if (this.keyCache[layerConfig.id]) {
+                    delete this.keyCache[layerConfig.id];
+                  }
+                }
+                for (var i$1 = 0, list$1 = removedIds; i$1 < list$1.length; i$1 += 1) {
+                  var id2 = list$1[i$1];
+                  delete this.keyCache[id2];
+                  delete this._layerConfigs[id2];
+                  delete this._layers[id2];
+                }
+                this.familiesBySource = {};
+                var groups = groupByLayout(performance2.values(this._layerConfigs), this.keyCache);
+                for (var i$2 = 0, list$2 = groups; i$2 < list$2.length; i$2 += 1) {
+                  var layerConfigs$1 = list$2[i$2];
+                  var layers = layerConfigs$1.map(function(layerConfig2) {
+                    return this$1$1._layers[layerConfig2.id];
+                  });
+                  var layer$1 = layers[0];
+                  if (layer$1.visibility === "none") {
+                    continue;
+                  }
+                  var sourceId = layer$1.source || "";
+                  var sourceGroup = this.familiesBySource[sourceId];
+                  if (!sourceGroup) {
+                    sourceGroup = this.familiesBySource[sourceId] = {};
+                  }
+                  var sourceLayerId = layer$1.sourceLayer || "_geojsonTileLayer";
+                  var sourceLayerFamilies = sourceGroup[sourceLayerId];
+                  if (!sourceLayerFamilies) {
+                    sourceLayerFamilies = sourceGroup[sourceLayerId] = [];
+                  }
+                  sourceLayerFamilies.push(layers);
+                }
+              };
+              var padding = 1;
+              var GlyphAtlas = function GlyphAtlas2(stacks) {
+                var positions = {};
+                var bins = [];
+                for (var stack in stacks) {
+                  var glyphs = stacks[stack];
+                  var stackPositions = positions[stack] = {};
+                  for (var id2 in glyphs) {
+                    var src = glyphs[+id2];
+                    if (!src || src.bitmap.width === 0 || src.bitmap.height === 0) {
+                      continue;
+                    }
+                    var bin = {
+                      x: 0,
+                      y: 0,
+                      w: src.bitmap.width + 2 * padding,
+                      h: src.bitmap.height + 2 * padding
+                    };
+                    bins.push(bin);
+                    stackPositions[id2] = {
+                      rect: bin,
+                      metrics: src.metrics
+                    };
+                  }
+                }
+                var ref = performance2.potpack(bins);
+                var w2 = ref.w;
+                var h2 = ref.h;
+                var image = new performance2.AlphaImage({
+                  width: w2 || 1,
+                  height: h2 || 1
+                });
+                for (var stack$1 in stacks) {
+                  var glyphs$1 = stacks[stack$1];
+                  for (var id$1 in glyphs$1) {
+                    var src$1 = glyphs$1[+id$1];
+                    if (!src$1 || src$1.bitmap.width === 0 || src$1.bitmap.height === 0) {
+                      continue;
+                    }
+                    var bin$1 = positions[stack$1][id$1].rect;
+                    performance2.AlphaImage.copy(src$1.bitmap, image, {
+                      x: 0,
+                      y: 0
+                    }, {
+                      x: bin$1.x + padding,
+                      y: bin$1.y + padding
+                    }, src$1.bitmap);
+                  }
+                }
+                this.image = image;
+                this.positions = positions;
+              };
+              performance2.register("GlyphAtlas", GlyphAtlas);
+              var WorkerTile = function WorkerTile2(params) {
+                this.tileID = new performance2.OverscaledTileID(params.tileID.overscaledZ, params.tileID.wrap, params.tileID.canonical.z, params.tileID.canonical.x, params.tileID.canonical.y);
+                this.uid = params.uid;
+                this.zoom = params.zoom;
+                this.pixelRatio = params.pixelRatio;
+                this.tileSize = params.tileSize;
+                this.source = params.source;
+                this.overscaling = this.tileID.overscaleFactor();
+                this.showCollisionBoxes = params.showCollisionBoxes;
+                this.collectResourceTiming = !!params.collectResourceTiming;
+                this.returnDependencies = !!params.returnDependencies;
+                this.promoteId = params.promoteId;
+              };
+              WorkerTile.prototype.parse = function parse22(data, layerIndex, availableImages, actor, callback) {
+                var this$1$1 = this;
+                this.status = "parsing";
+                this.data = data;
+                this.collisionBoxArray = new performance2.CollisionBoxArray();
+                var sourceLayerCoder = new performance2.DictionaryCoder(Object.keys(data.layers).sort());
+                var featureIndex = new performance2.FeatureIndex(this.tileID, this.promoteId);
+                featureIndex.bucketLayerIDs = [];
+                var buckets = {};
+                var options = {
+                  featureIndex,
+                  iconDependencies: {},
+                  patternDependencies: {},
+                  glyphDependencies: {},
+                  availableImages
+                };
+                var layerFamilies = layerIndex.familiesBySource[this.source];
+                for (var sourceLayerId in layerFamilies) {
+                  var sourceLayer = data.layers[sourceLayerId];
+                  if (!sourceLayer) {
+                    continue;
+                  }
+                  if (sourceLayer.version === 1) {
+                    performance2.warnOnce('Vector tile source "' + this.source + '" layer "' + sourceLayerId + '" does not use vector tile spec v2 and therefore may have some rendering errors.');
+                  }
+                  var sourceLayerIndex = sourceLayerCoder.encode(sourceLayerId);
+                  var features = [];
+                  for (var index = 0; index < sourceLayer.length; index++) {
+                    var feature = sourceLayer.feature(index);
+                    var id2 = featureIndex.getId(feature, sourceLayerId);
+                    features.push({
+                      feature,
+                      id: id2,
+                      index,
+                      sourceLayerIndex
+                    });
+                  }
+                  for (var i2 = 0, list = layerFamilies[sourceLayerId]; i2 < list.length; i2 += 1) {
+                    var family = list[i2];
+                    var layer = family[0];
+                    if (layer.minzoom && this.zoom < Math.floor(layer.minzoom)) {
+                      continue;
+                    }
+                    if (layer.maxzoom && this.zoom >= layer.maxzoom) {
+                      continue;
+                    }
+                    if (layer.visibility === "none") {
+                      continue;
+                    }
+                    recalculateLayers(family, this.zoom, availableImages);
+                    var bucket = buckets[layer.id] = layer.createBucket({
+                      index: featureIndex.bucketLayerIDs.length,
+                      layers: family,
+                      zoom: this.zoom,
+                      pixelRatio: this.pixelRatio,
+                      overscaling: this.overscaling,
+                      collisionBoxArray: this.collisionBoxArray,
+                      sourceLayerIndex,
+                      sourceID: this.source
+                    });
+                    bucket.populate(features, options, this.tileID.canonical);
+                    featureIndex.bucketLayerIDs.push(family.map(function(l2) {
+                      return l2.id;
+                    }));
+                  }
+                }
+                var error;
+                var glyphMap;
+                var iconMap;
+                var patternMap;
+                var stacks = performance2.mapObject(options.glyphDependencies, function(glyphs) {
+                  return Object.keys(glyphs).map(Number);
+                });
+                if (Object.keys(stacks).length) {
+                  actor.send("getGlyphs", {
+                    uid: this.uid,
+                    stacks
+                  }, function(err, result) {
+                    if (!error) {
+                      error = err;
+                      glyphMap = result;
+                      maybePrepare.call(this$1$1);
+                    }
+                  });
+                } else {
+                  glyphMap = {};
+                }
+                var icons = Object.keys(options.iconDependencies);
+                if (icons.length) {
+                  actor.send("getImages", {
+                    icons,
+                    source: this.source,
+                    tileID: this.tileID,
+                    type: "icons"
+                  }, function(err, result) {
+                    if (!error) {
+                      error = err;
+                      iconMap = result;
+                      maybePrepare.call(this$1$1);
+                    }
+                  });
+                } else {
+                  iconMap = {};
+                }
+                var patterns = Object.keys(options.patternDependencies);
+                if (patterns.length) {
+                  actor.send("getImages", {
+                    icons: patterns,
+                    source: this.source,
+                    tileID: this.tileID,
+                    type: "patterns"
+                  }, function(err, result) {
+                    if (!error) {
+                      error = err;
+                      patternMap = result;
+                      maybePrepare.call(this$1$1);
+                    }
+                  });
+                } else {
+                  patternMap = {};
+                }
+                maybePrepare.call(this);
+                function maybePrepare() {
+                  if (error) {
+                    return callback(error);
+                  } else if (glyphMap && iconMap && patternMap) {
+                    var glyphAtlas = new GlyphAtlas(glyphMap);
+                    var imageAtlas = new performance2.ImageAtlas(iconMap, patternMap);
+                    for (var key in buckets) {
+                      var bucket2 = buckets[key];
+                      if (bucket2 instanceof performance2.SymbolBucket) {
+                        recalculateLayers(bucket2.layers, this.zoom, availableImages);
+                        performance2.performSymbolLayout(bucket2, glyphMap, glyphAtlas.positions, iconMap, imageAtlas.iconPositions, this.showCollisionBoxes, this.tileID.canonical);
+                      } else if (bucket2.hasPattern && (bucket2 instanceof performance2.LineBucket || bucket2 instanceof performance2.FillBucket || bucket2 instanceof performance2.FillExtrusionBucket)) {
+                        recalculateLayers(bucket2.layers, this.zoom, availableImages);
+                        bucket2.addFeatures(options, this.tileID.canonical, imageAtlas.patternPositions);
+                      }
+                    }
+                    this.status = "done";
+                    callback(null, {
+                      buckets: performance2.values(buckets).filter(function(b2) {
+                        return !b2.isEmpty();
+                      }),
+                      featureIndex,
+                      collisionBoxArray: this.collisionBoxArray,
+                      glyphAtlasImage: glyphAtlas.image,
+                      imageAtlas,
+                      glyphMap: this.returnDependencies ? glyphMap : null,
+                      iconMap: this.returnDependencies ? iconMap : null,
+                      glyphPositions: this.returnDependencies ? glyphAtlas.positions : null
+                    });
+                  }
+                }
+              };
+              function recalculateLayers(layers, zoom, availableImages) {
+                var parameters = new performance2.EvaluationParameters(zoom);
+                for (var i2 = 0, list = layers; i2 < list.length; i2 += 1) {
+                  var layer = list[i2];
+                  layer.recalculate(parameters, availableImages);
+                }
+              }
+              function loadVectorTile(params, callback) {
+                var request = performance2.getArrayBuffer(params.request, function(err, data, cacheControl, expires) {
+                  if (err) {
+                    callback(err);
+                  } else if (data) {
+                    callback(null, {
+                      vectorTile: new performance2.vectorTile.VectorTile(new performance2.pbf(data)),
+                      rawData: data,
+                      cacheControl,
+                      expires
+                    });
+                  }
+                });
+                return function() {
+                  request.cancel();
+                  callback();
+                };
+              }
+              var VectorTileWorkerSource = function VectorTileWorkerSource2(actor, layerIndex, availableImages, loadVectorData) {
+                this.actor = actor;
+                this.layerIndex = layerIndex;
+                this.availableImages = availableImages;
+                this.loadVectorData = loadVectorData || loadVectorTile;
+                this.loading = {};
+                this.loaded = {};
+              };
+              VectorTileWorkerSource.prototype.loadTile = function loadTile(params, callback) {
+                var this$1$1 = this;
+                var uid2 = params.uid;
+                if (!this.loading) {
+                  this.loading = {};
+                }
+                var perf = params && params.request && params.request.collectResourceTiming ? new performance2.RequestPerformance(params.request) : false;
+                var workerTile = this.loading[uid2] = new WorkerTile(params);
+                workerTile.abort = this.loadVectorData(params, function(err, response) {
+                  delete this$1$1.loading[uid2];
+                  if (err || !response) {
+                    workerTile.status = "done";
+                    this$1$1.loaded[uid2] = workerTile;
+                    return callback(err);
+                  }
+                  var rawTileData = response.rawData;
+                  var cacheControl = {};
+                  if (response.expires) {
+                    cacheControl.expires = response.expires;
+                  }
+                  if (response.cacheControl) {
+                    cacheControl.cacheControl = response.cacheControl;
+                  }
+                  var resourceTiming = {};
+                  if (perf) {
+                    var resourceTimingData = perf.finish();
+                    if (resourceTimingData) {
+                      resourceTiming.resourceTiming = JSON.parse(JSON.stringify(resourceTimingData));
+                    }
+                  }
+                  workerTile.vectorTile = response.vectorTile;
+                  workerTile.parse(response.vectorTile, this$1$1.layerIndex, this$1$1.availableImages, this$1$1.actor, function(err2, result) {
+                    if (err2 || !result) {
+                      return callback(err2);
+                    }
+                    callback(null, performance2.extend({ rawTileData: rawTileData.slice(0) }, result, cacheControl, resourceTiming));
+                  });
+                  this$1$1.loaded = this$1$1.loaded || {};
+                  this$1$1.loaded[uid2] = workerTile;
+                });
+              };
+              VectorTileWorkerSource.prototype.reloadTile = function reloadTile(params, callback) {
+                var this$1$1 = this;
+                var loaded = this.loaded, uid2 = params.uid, vtSource = this;
+                if (loaded && loaded[uid2]) {
+                  var workerTile = loaded[uid2];
+                  workerTile.showCollisionBoxes = params.showCollisionBoxes;
+                  var done = function(err, data) {
+                    var reloadCallback = workerTile.reloadCallback;
+                    if (reloadCallback) {
+                      delete workerTile.reloadCallback;
+                      workerTile.parse(workerTile.vectorTile, vtSource.layerIndex, this$1$1.availableImages, vtSource.actor, reloadCallback);
+                    }
+                    callback(err, data);
+                  };
+                  if (workerTile.status === "parsing") {
+                    workerTile.reloadCallback = done;
+                  } else if (workerTile.status === "done") {
+                    if (workerTile.vectorTile) {
+                      workerTile.parse(workerTile.vectorTile, this.layerIndex, this.availableImages, this.actor, done);
+                    } else {
+                      done();
+                    }
+                  }
+                }
+              };
+              VectorTileWorkerSource.prototype.abortTile = function abortTile(params, callback) {
+                var loading = this.loading, uid2 = params.uid;
+                if (loading && loading[uid2] && loading[uid2].abort) {
+                  loading[uid2].abort();
+                  delete loading[uid2];
+                }
+                callback();
+              };
+              VectorTileWorkerSource.prototype.removeTile = function removeTile(params, callback) {
+                var loaded = this.loaded, uid2 = params.uid;
+                if (loaded && loaded[uid2]) {
+                  delete loaded[uid2];
+                }
+                callback();
+              };
+              var ImageBitmap2 = performance2.window.ImageBitmap;
+              var RasterDEMTileWorkerSource = function RasterDEMTileWorkerSource2() {
+                this.loaded = {};
+              };
+              RasterDEMTileWorkerSource.prototype.loadTile = function loadTile(params, callback) {
+                var uid2 = params.uid;
+                var encoding = params.encoding;
+                var rawImageData = params.rawImageData;
+                var imagePixels = ImageBitmap2 && rawImageData instanceof ImageBitmap2 ? this.getImageData(rawImageData) : rawImageData;
+                var dem = new performance2.DEMData(uid2, imagePixels, encoding);
+                this.loaded = this.loaded || {};
+                this.loaded[uid2] = dem;
+                callback(null, dem);
+              };
+              RasterDEMTileWorkerSource.prototype.getImageData = function getImageData2(imgBitmap) {
+                if (!this.offscreenCanvas || !this.offscreenCanvasContext) {
+                  this.offscreenCanvas = new OffscreenCanvas(imgBitmap.width, imgBitmap.height);
+                  this.offscreenCanvasContext = this.offscreenCanvas.getContext("2d");
+                }
+                this.offscreenCanvas.width = imgBitmap.width;
+                this.offscreenCanvas.height = imgBitmap.height;
+                this.offscreenCanvasContext.drawImage(imgBitmap, 0, 0, imgBitmap.width, imgBitmap.height);
+                var imgData = this.offscreenCanvasContext.getImageData(-1, -1, imgBitmap.width + 2, imgBitmap.height + 2);
+                this.offscreenCanvasContext.clearRect(0, 0, this.offscreenCanvas.width, this.offscreenCanvas.height);
+                return new performance2.RGBAImage({
+                  width: imgData.width,
+                  height: imgData.height
+                }, imgData.data);
+              };
+              RasterDEMTileWorkerSource.prototype.removeTile = function removeTile(params) {
+                var loaded = this.loaded, uid2 = params.uid;
+                if (loaded && loaded[uid2]) {
+                  delete loaded[uid2];
+                }
+              };
+              var geojsonRewind = rewind;
+              function rewind(gj2, outer) {
+                var type = gj2 && gj2.type, i2;
+                if (type === "FeatureCollection") {
+                  for (i2 = 0; i2 < gj2.features.length; i2++) {
+                    rewind(gj2.features[i2], outer);
+                  }
+                } else if (type === "GeometryCollection") {
+                  for (i2 = 0; i2 < gj2.geometries.length; i2++) {
+                    rewind(gj2.geometries[i2], outer);
+                  }
+                } else if (type === "Feature") {
+                  rewind(gj2.geometry, outer);
+                } else if (type === "Polygon") {
+                  rewindRings(gj2.coordinates, outer);
+                } else if (type === "MultiPolygon") {
+                  for (i2 = 0; i2 < gj2.coordinates.length; i2++) {
+                    rewindRings(gj2.coordinates[i2], outer);
+                  }
+                }
+                return gj2;
+              }
+              function rewindRings(rings, outer) {
+                if (rings.length === 0) {
+                  return;
+                }
+                rewindRing(rings[0], outer);
+                for (var i2 = 1; i2 < rings.length; i2++) {
+                  rewindRing(rings[i2], !outer);
+                }
+              }
+              function rewindRing(ring, dir) {
+                var area = 0;
+                for (var i2 = 0, len2 = ring.length, j2 = len2 - 1; i2 < len2; j2 = i2++) {
+                  area += (ring[i2][0] - ring[j2][0]) * (ring[j2][1] + ring[i2][1]);
+                }
+                if (area >= 0 !== !!dir) {
+                  ring.reverse();
+                }
+              }
+              var toGeoJSON = performance2.vectorTile.VectorTileFeature.prototype.toGeoJSON;
+              var FeatureWrapper = function FeatureWrapper2(feature) {
+                this._feature = feature;
+                this.extent = performance2.EXTENT;
+                this.type = feature.type;
+                this.properties = feature.tags;
+                if ("id" in feature && !isNaN(feature.id)) {
+                  this.id = parseInt(feature.id, 10);
+                }
+              };
+              FeatureWrapper.prototype.loadGeometry = function loadGeometry() {
+                if (this._feature.type === 1) {
+                  var geometry2 = [];
+                  for (var i2 = 0, list = this._feature.geometry; i2 < list.length; i2 += 1) {
+                    var point = list[i2];
+                    geometry2.push([new performance2.Point$1(point[0], point[1])]);
+                  }
+                  return geometry2;
+                } else {
+                  var geometry$1 = [];
+                  for (var i$2 = 0, list$2 = this._feature.geometry; i$2 < list$2.length; i$2 += 1) {
+                    var ring = list$2[i$2];
+                    var newRing = [];
+                    for (var i$1 = 0, list$1 = ring; i$1 < list$1.length; i$1 += 1) {
+                      var point$1 = list$1[i$1];
+                      newRing.push(new performance2.Point$1(point$1[0], point$1[1]));
+                    }
+                    geometry$1.push(newRing);
+                  }
+                  return geometry$1;
+                }
+              };
+              FeatureWrapper.prototype.toGeoJSON = function toGeoJSON$1(x2, y2, z2) {
+                return toGeoJSON.call(this, x2, y2, z2);
+              };
+              var GeoJSONWrapper = function GeoJSONWrapper2(features) {
+                this.layers = { "_geojsonTileLayer": this };
+                this.name = "_geojsonTileLayer";
+                this.extent = performance2.EXTENT;
+                this.length = features.length;
+                this._features = features;
+              };
+              GeoJSONWrapper.prototype.feature = function feature(i2) {
+                return new FeatureWrapper(this._features[i2]);
+              };
+              var VectorTileFeature = performance2.vectorTile.VectorTileFeature;
+              var geojson_wrapper = GeoJSONWrapper$1;
+              function GeoJSONWrapper$1(features, options) {
+                this.options = options || {};
+                this.features = features;
+                this.length = features.length;
+              }
+              GeoJSONWrapper$1.prototype.feature = function(i2) {
+                return new FeatureWrapper$1(this.features[i2], this.options.extent);
+              };
+              function FeatureWrapper$1(feature, extent) {
+                this.id = typeof feature.id === "number" ? feature.id : void 0;
+                this.type = feature.type;
+                this.rawGeometry = feature.type === 1 ? [feature.geometry] : feature.geometry;
+                this.properties = feature.tags;
+                this.extent = extent || 4096;
+              }
+              FeatureWrapper$1.prototype.loadGeometry = function() {
+                var rings = this.rawGeometry;
+                this.geometry = [];
+                for (var i2 = 0; i2 < rings.length; i2++) {
+                  var ring = rings[i2];
+                  var newRing = [];
+                  for (var j2 = 0; j2 < ring.length; j2++) {
+                    newRing.push(new performance2.Point$1(ring[j2][0], ring[j2][1]));
+                  }
+                  this.geometry.push(newRing);
+                }
+                return this.geometry;
+              };
+              FeatureWrapper$1.prototype.bbox = function() {
+                if (!this.geometry) {
+                  this.loadGeometry();
+                }
+                var rings = this.geometry;
+                var x1 = Infinity;
+                var x2 = -Infinity;
+                var y1 = Infinity;
+                var y2 = -Infinity;
+                for (var i2 = 0; i2 < rings.length; i2++) {
+                  var ring = rings[i2];
+                  for (var j2 = 0; j2 < ring.length; j2++) {
+                    var coord = ring[j2];
+                    x1 = Math.min(x1, coord.x);
+                    x2 = Math.max(x2, coord.x);
+                    y1 = Math.min(y1, coord.y);
+                    y2 = Math.max(y2, coord.y);
+                  }
+                }
+                return [
+                  x1,
+                  y1,
+                  x2,
+                  y2
+                ];
+              };
+              FeatureWrapper$1.prototype.toGeoJSON = VectorTileFeature.prototype.toGeoJSON;
+              var vtPbf = fromVectorTileJs;
+              var fromVectorTileJs_1 = fromVectorTileJs;
+              var fromGeojsonVt_1 = fromGeojsonVt;
+              var GeoJSONWrapper_1 = geojson_wrapper;
+              function fromVectorTileJs(tile) {
+                var out = new performance2.pbf();
+                writeTile(tile, out);
+                return out.finish();
+              }
+              function fromGeojsonVt(layers, options) {
+                options = options || {};
+                var l2 = {};
+                for (var k2 in layers) {
+                  l2[k2] = new geojson_wrapper(layers[k2].features, options);
+                  l2[k2].name = k2;
+                  l2[k2].version = options.version;
+                  l2[k2].extent = options.extent;
+                }
+                return fromVectorTileJs({ layers: l2 });
+              }
+              function writeTile(tile, pbf) {
+                for (var key in tile.layers) {
+                  pbf.writeMessage(3, writeLayer, tile.layers[key]);
+                }
+              }
+              function writeLayer(layer, pbf) {
+                pbf.writeVarintField(15, layer.version || 1);
+                pbf.writeStringField(1, layer.name || "");
+                pbf.writeVarintField(5, layer.extent || 4096);
+                var i2;
+                var context = {
+                  keys: [],
+                  values: [],
+                  keycache: {},
+                  valuecache: {}
+                };
+                for (i2 = 0; i2 < layer.length; i2++) {
+                  context.feature = layer.feature(i2);
+                  pbf.writeMessage(2, writeFeature, context);
+                }
+                var keys = context.keys;
+                for (i2 = 0; i2 < keys.length; i2++) {
+                  pbf.writeStringField(3, keys[i2]);
+                }
+                var values = context.values;
+                for (i2 = 0; i2 < values.length; i2++) {
+                  pbf.writeMessage(4, writeValue, values[i2]);
+                }
+              }
+              function writeFeature(context, pbf) {
+                var feature = context.feature;
+                if (feature.id !== void 0) {
+                  pbf.writeVarintField(1, feature.id);
+                }
+                pbf.writeMessage(2, writeProperties, context);
+                pbf.writeVarintField(3, feature.type);
+                pbf.writeMessage(4, writeGeometry, feature);
+              }
+              function writeProperties(context, pbf) {
+                var feature = context.feature;
+                var keys = context.keys;
+                var values = context.values;
+                var keycache = context.keycache;
+                var valuecache = context.valuecache;
+                for (var key in feature.properties) {
+                  var keyIndex = keycache[key];
+                  if (typeof keyIndex === "undefined") {
+                    keys.push(key);
+                    keyIndex = keys.length - 1;
+                    keycache[key] = keyIndex;
+                  }
+                  pbf.writeVarint(keyIndex);
+                  var value = feature.properties[key];
+                  var type = typeof value;
+                  if (type !== "string" && type !== "boolean" && type !== "number") {
+                    value = JSON.stringify(value);
+                  }
+                  var valueKey = type + ":" + value;
+                  var valueIndex = valuecache[valueKey];
+                  if (typeof valueIndex === "undefined") {
+                    values.push(value);
+                    valueIndex = values.length - 1;
+                    valuecache[valueKey] = valueIndex;
+                  }
+                  pbf.writeVarint(valueIndex);
+                }
+              }
+              function command(cmd, length2) {
+                return (length2 << 3) + (cmd & 7);
+              }
+              function zigzag(num) {
+                return num << 1 ^ num >> 31;
+              }
+              function writeGeometry(feature, pbf) {
+                var geometry2 = feature.loadGeometry();
+                var type = feature.type;
+                var x2 = 0;
+                var y2 = 0;
+                var rings = geometry2.length;
+                for (var r2 = 0; r2 < rings; r2++) {
+                  var ring = geometry2[r2];
+                  var count2 = 1;
+                  if (type === 1) {
+                    count2 = ring.length;
+                  }
+                  pbf.writeVarint(command(1, count2));
+                  var lineCount = type === 3 ? ring.length - 1 : ring.length;
+                  for (var i2 = 0; i2 < lineCount; i2++) {
+                    if (i2 === 1 && type !== 1) {
+                      pbf.writeVarint(command(2, lineCount - 1));
+                    }
+                    var dx = ring[i2].x - x2;
+                    var dy = ring[i2].y - y2;
+                    pbf.writeVarint(zigzag(dx));
+                    pbf.writeVarint(zigzag(dy));
+                    x2 += dx;
+                    y2 += dy;
+                  }
+                  if (type === 3) {
+                    pbf.writeVarint(command(7, 1));
+                  }
+                }
+              }
+              function writeValue(value, pbf) {
+                var type = typeof value;
+                if (type === "string") {
+                  pbf.writeStringField(1, value);
+                } else if (type === "boolean") {
+                  pbf.writeBooleanField(7, value);
+                } else if (type === "number") {
+                  if (value % 1 !== 0) {
+                    pbf.writeDoubleField(3, value);
+                  } else if (value < 0) {
+                    pbf.writeSVarintField(6, value);
+                  } else {
+                    pbf.writeVarintField(5, value);
+                  }
+                }
+              }
+              vtPbf.fromVectorTileJs = fromVectorTileJs_1;
+              vtPbf.fromGeojsonVt = fromGeojsonVt_1;
+              vtPbf.GeoJSONWrapper = GeoJSONWrapper_1;
+              function sortKD(ids, coords, nodeSize, left, right, depth) {
+                if (right - left <= nodeSize) {
+                  return;
+                }
+                var m2 = left + right >> 1;
+                select(ids, coords, m2, left, right, depth % 2);
+                sortKD(ids, coords, nodeSize, left, m2 - 1, depth + 1);
+                sortKD(ids, coords, nodeSize, m2 + 1, right, depth + 1);
+              }
+              function select(ids, coords, k2, left, right, inc) {
+                while (right > left) {
+                  if (right - left > 600) {
+                    var n2 = right - left + 1;
+                    var m2 = k2 - left + 1;
+                    var z2 = Math.log(n2);
+                    var s2 = 0.5 * Math.exp(2 * z2 / 3);
+                    var sd2 = 0.5 * Math.sqrt(z2 * s2 * (n2 - s2) / n2) * (m2 - n2 / 2 < 0 ? -1 : 1);
+                    var newLeft = Math.max(left, Math.floor(k2 - m2 * s2 / n2 + sd2));
+                    var newRight = Math.min(right, Math.floor(k2 + (n2 - m2) * s2 / n2 + sd2));
+                    select(ids, coords, k2, newLeft, newRight, inc);
+                  }
+                  var t4 = coords[2 * k2 + inc];
+                  var i2 = left;
+                  var j2 = right;
+                  swapItem(ids, coords, left, k2);
+                  if (coords[2 * right + inc] > t4) {
+                    swapItem(ids, coords, left, right);
+                  }
+                  while (i2 < j2) {
+                    swapItem(ids, coords, i2, j2);
+                    i2++;
+                    j2--;
+                    while (coords[2 * i2 + inc] < t4) {
+                      i2++;
+                    }
+                    while (coords[2 * j2 + inc] > t4) {
+                      j2--;
+                    }
+                  }
+                  if (coords[2 * left + inc] === t4) {
+                    swapItem(ids, coords, left, j2);
+                  } else {
+                    j2++;
+                    swapItem(ids, coords, j2, right);
+                  }
+                  if (j2 <= k2) {
+                    left = j2 + 1;
+                  }
+                  if (k2 <= j2) {
+                    right = j2 - 1;
+                  }
+                }
+              }
+              function swapItem(ids, coords, i2, j2) {
+                swap(ids, i2, j2);
+                swap(coords, 2 * i2, 2 * j2);
+                swap(coords, 2 * i2 + 1, 2 * j2 + 1);
+              }
+              function swap(arr, i2, j2) {
+                var tmp2 = arr[i2];
+                arr[i2] = arr[j2];
+                arr[j2] = tmp2;
+              }
+              function range(ids, coords, minX, minY, maxX, maxY, nodeSize) {
+                var stack = [
+                  0,
+                  ids.length - 1,
+                  0
+                ];
+                var result = [];
+                var x2, y2;
+                while (stack.length) {
+                  var axis = stack.pop();
+                  var right = stack.pop();
+                  var left = stack.pop();
+                  if (right - left <= nodeSize) {
+                    for (var i2 = left; i2 <= right; i2++) {
+                      x2 = coords[2 * i2];
+                      y2 = coords[2 * i2 + 1];
+                      if (x2 >= minX && x2 <= maxX && y2 >= minY && y2 <= maxY) {
+                        result.push(ids[i2]);
+                      }
+                    }
+                    continue;
+                  }
+                  var m2 = Math.floor((left + right) / 2);
+                  x2 = coords[2 * m2];
+                  y2 = coords[2 * m2 + 1];
+                  if (x2 >= minX && x2 <= maxX && y2 >= minY && y2 <= maxY) {
+                    result.push(ids[m2]);
+                  }
+                  var nextAxis = (axis + 1) % 2;
+                  if (axis === 0 ? minX <= x2 : minY <= y2) {
+                    stack.push(left);
+                    stack.push(m2 - 1);
+                    stack.push(nextAxis);
+                  }
+                  if (axis === 0 ? maxX >= x2 : maxY >= y2) {
+                    stack.push(m2 + 1);
+                    stack.push(right);
+                    stack.push(nextAxis);
+                  }
+                }
+                return result;
+              }
+              function within(ids, coords, qx, qy, r2, nodeSize) {
+                var stack = [
+                  0,
+                  ids.length - 1,
+                  0
+                ];
+                var result = [];
+                var r22 = r2 * r2;
+                while (stack.length) {
+                  var axis = stack.pop();
+                  var right = stack.pop();
+                  var left = stack.pop();
+                  if (right - left <= nodeSize) {
+                    for (var i2 = left; i2 <= right; i2++) {
+                      if (sqDist(coords[2 * i2], coords[2 * i2 + 1], qx, qy) <= r22) {
+                        result.push(ids[i2]);
+                      }
+                    }
+                    continue;
+                  }
+                  var m2 = Math.floor((left + right) / 2);
+                  var x2 = coords[2 * m2];
+                  var y2 = coords[2 * m2 + 1];
+                  if (sqDist(x2, y2, qx, qy) <= r22) {
+                    result.push(ids[m2]);
+                  }
+                  var nextAxis = (axis + 1) % 2;
+                  if (axis === 0 ? qx - r2 <= x2 : qy - r2 <= y2) {
+                    stack.push(left);
+                    stack.push(m2 - 1);
+                    stack.push(nextAxis);
+                  }
+                  if (axis === 0 ? qx + r2 >= x2 : qy + r2 >= y2) {
+                    stack.push(m2 + 1);
+                    stack.push(right);
+                    stack.push(nextAxis);
+                  }
+                }
+                return result;
+              }
+              function sqDist(ax, ay, bx, by) {
+                var dx = ax - bx;
+                var dy = ay - by;
+                return dx * dx + dy * dy;
+              }
+              var defaultGetX = function(p2) {
+                return p2[0];
+              };
+              var defaultGetY = function(p2) {
+                return p2[1];
+              };
+              var KDBush = function KDBush2(points, getX2, getY2, nodeSize, ArrayType) {
+                if (getX2 === void 0)
+                  getX2 = defaultGetX;
+                if (getY2 === void 0)
+                  getY2 = defaultGetY;
+                if (nodeSize === void 0)
+                  nodeSize = 64;
+                if (ArrayType === void 0)
+                  ArrayType = Float64Array;
+                this.nodeSize = nodeSize;
+                this.points = points;
+                var IndexArrayType = points.length < 65536 ? Uint16Array : Uint32Array;
+                var ids = this.ids = new IndexArrayType(points.length);
+                var coords = this.coords = new ArrayType(points.length * 2);
+                for (var i2 = 0; i2 < points.length; i2++) {
+                  ids[i2] = i2;
+                  coords[2 * i2] = getX2(points[i2]);
+                  coords[2 * i2 + 1] = getY2(points[i2]);
+                }
+                sortKD(ids, coords, nodeSize, 0, ids.length - 1, 0);
+              };
+              KDBush.prototype.range = function range$1(minX, minY, maxX, maxY) {
+                return range(this.ids, this.coords, minX, minY, maxX, maxY, this.nodeSize);
+              };
+              KDBush.prototype.within = function within$1(x2, y2, r2) {
+                return within(this.ids, this.coords, x2, y2, r2, this.nodeSize);
+              };
+              var defaultOptions2 = {
+                minZoom: 0,
+                maxZoom: 16,
+                minPoints: 2,
+                radius: 40,
+                extent: 512,
+                nodeSize: 64,
+                log: false,
+                generateId: false,
+                reduce: null,
+                map: function(props) {
+                  return props;
+                }
+              };
+              var Supercluster = function Supercluster2(options) {
+                this.options = extend2(Object.create(defaultOptions2), options);
+                this.trees = new Array(this.options.maxZoom + 1);
+              };
+              Supercluster.prototype.load = function load2(points) {
+                var ref = this.options;
+                var log3 = ref.log;
+                var minZoom = ref.minZoom;
+                var maxZoom = ref.maxZoom;
+                var nodeSize = ref.nodeSize;
+                if (log3) {
+                  console.time("total time");
+                }
+                var timerId = "prepare " + points.length + " points";
+                if (log3) {
+                  console.time(timerId);
+                }
+                this.points = points;
+                var clusters = [];
+                for (var i2 = 0; i2 < points.length; i2++) {
+                  if (!points[i2].geometry) {
+                    continue;
+                  }
+                  clusters.push(createPointCluster(points[i2], i2));
+                }
+                this.trees[maxZoom + 1] = new KDBush(clusters, getX, getY, nodeSize, Float32Array);
+                if (log3) {
+                  console.timeEnd(timerId);
+                }
+                for (var z2 = maxZoom; z2 >= minZoom; z2--) {
+                  var now = +Date.now();
+                  clusters = this._cluster(clusters, z2);
+                  this.trees[z2] = new KDBush(clusters, getX, getY, nodeSize, Float32Array);
+                  if (log3) {
+                    console.log("z%d: %d clusters in %dms", z2, clusters.length, +Date.now() - now);
+                  }
+                }
+                if (log3) {
+                  console.timeEnd("total time");
+                }
+                return this;
+              };
+              Supercluster.prototype.getClusters = function getClusters(bbox, zoom) {
+                var minLng = ((bbox[0] + 180) % 360 + 360) % 360 - 180;
+                var minLat = Math.max(-90, Math.min(90, bbox[1]));
+                var maxLng = bbox[2] === 180 ? 180 : ((bbox[2] + 180) % 360 + 360) % 360 - 180;
+                var maxLat = Math.max(-90, Math.min(90, bbox[3]));
+                if (bbox[2] - bbox[0] >= 360) {
+                  minLng = -180;
+                  maxLng = 180;
+                } else if (minLng > maxLng) {
+                  var easternHem = this.getClusters([
+                    minLng,
+                    minLat,
+                    180,
+                    maxLat
+                  ], zoom);
+                  var westernHem = this.getClusters([
+                    -180,
+                    minLat,
+                    maxLng,
+                    maxLat
+                  ], zoom);
+                  return easternHem.concat(westernHem);
+                }
+                var tree = this.trees[this._limitZoom(zoom)];
+                var ids = tree.range(lngX(minLng), latY(maxLat), lngX(maxLng), latY(minLat));
+                var clusters = [];
+                for (var i2 = 0, list = ids; i2 < list.length; i2 += 1) {
+                  var id2 = list[i2];
+                  var c2 = tree.points[id2];
+                  clusters.push(c2.numPoints ? getClusterJSON(c2) : this.points[c2.index]);
+                }
+                return clusters;
+              };
+              Supercluster.prototype.getChildren = function getChildren(clusterId) {
+                var originId = this._getOriginId(clusterId);
+                var originZoom = this._getOriginZoom(clusterId);
+                var errorMsg = "No cluster with the specified id.";
+                var index = this.trees[originZoom];
+                if (!index) {
+                  throw new Error(errorMsg);
+                }
+                var origin = index.points[originId];
+                if (!origin) {
+                  throw new Error(errorMsg);
+                }
+                var r2 = this.options.radius / (this.options.extent * Math.pow(2, originZoom - 1));
+                var ids = index.within(origin.x, origin.y, r2);
+                var children = [];
+                for (var i2 = 0, list = ids; i2 < list.length; i2 += 1) {
+                  var id2 = list[i2];
+                  var c2 = index.points[id2];
+                  if (c2.parentId === clusterId) {
+                    children.push(c2.numPoints ? getClusterJSON(c2) : this.points[c2.index]);
+                  }
+                }
+                if (children.length === 0) {
+                  throw new Error(errorMsg);
+                }
+                return children;
+              };
+              Supercluster.prototype.getLeaves = function getLeaves(clusterId, limit, offset) {
+                limit = limit || 10;
+                offset = offset || 0;
+                var leaves = [];
+                this._appendLeaves(leaves, clusterId, limit, offset, 0);
+                return leaves;
+              };
+              Supercluster.prototype.getTile = function getTile(z2, x2, y2) {
+                var tree = this.trees[this._limitZoom(z2)];
+                var z22 = Math.pow(2, z2);
+                var ref = this.options;
+                var extent = ref.extent;
+                var radius = ref.radius;
+                var p2 = radius / extent;
+                var top = (y2 - p2) / z22;
+                var bottom = (y2 + 1 + p2) / z22;
+                var tile = { features: [] };
+                this._addTileFeatures(tree.range((x2 - p2) / z22, top, (x2 + 1 + p2) / z22, bottom), tree.points, x2, y2, z22, tile);
+                if (x2 === 0) {
+                  this._addTileFeatures(tree.range(1 - p2 / z22, top, 1, bottom), tree.points, z22, y2, z22, tile);
+                }
+                if (x2 === z22 - 1) {
+                  this._addTileFeatures(tree.range(0, top, p2 / z22, bottom), tree.points, -1, y2, z22, tile);
+                }
+                return tile.features.length ? tile : null;
+              };
+              Supercluster.prototype.getClusterExpansionZoom = function getClusterExpansionZoom(clusterId) {
+                var expansionZoom = this._getOriginZoom(clusterId) - 1;
+                while (expansionZoom <= this.options.maxZoom) {
+                  var children = this.getChildren(clusterId);
+                  expansionZoom++;
+                  if (children.length !== 1) {
+                    break;
+                  }
+                  clusterId = children[0].properties.cluster_id;
+                }
+                return expansionZoom;
+              };
+              Supercluster.prototype._appendLeaves = function _appendLeaves(result, clusterId, limit, offset, skipped) {
+                var children = this.getChildren(clusterId);
+                for (var i2 = 0, list = children; i2 < list.length; i2 += 1) {
+                  var child = list[i2];
+                  var props = child.properties;
+                  if (props && props.cluster) {
+                    if (skipped + props.point_count <= offset) {
+                      skipped += props.point_count;
+                    } else {
+                      skipped = this._appendLeaves(result, props.cluster_id, limit, offset, skipped);
+                    }
+                  } else if (skipped < offset) {
+                    skipped++;
+                  } else {
+                    result.push(child);
+                  }
+                  if (result.length === limit) {
+                    break;
+                  }
+                }
+                return skipped;
+              };
+              Supercluster.prototype._addTileFeatures = function _addTileFeatures(ids, points, x2, y2, z2, tile) {
+                for (var i$1 = 0, list = ids; i$1 < list.length; i$1 += 1) {
+                  var i2 = list[i$1];
+                  var c2 = points[i2];
+                  var isCluster = c2.numPoints;
+                  var f2 = {
+                    type: 1,
+                    geometry: [[
+                      Math.round(this.options.extent * (c2.x * z2 - x2)),
+                      Math.round(this.options.extent * (c2.y * z2 - y2))
+                    ]],
+                    tags: isCluster ? getClusterProperties(c2) : this.points[c2.index].properties
+                  };
+                  var id2 = void 0;
+                  if (isCluster) {
+                    id2 = c2.id;
+                  } else if (this.options.generateId) {
+                    id2 = c2.index;
+                  } else if (this.points[c2.index].id) {
+                    id2 = this.points[c2.index].id;
+                  }
+                  if (id2 !== void 0) {
+                    f2.id = id2;
+                  }
+                  tile.features.push(f2);
+                }
+              };
+              Supercluster.prototype._limitZoom = function _limitZoom(z2) {
+                return Math.max(this.options.minZoom, Math.min(+z2, this.options.maxZoom + 1));
+              };
+              Supercluster.prototype._cluster = function _cluster(points, zoom) {
+                var clusters = [];
+                var ref = this.options;
+                var radius = ref.radius;
+                var extent = ref.extent;
+                var reduce = ref.reduce;
+                var minPoints = ref.minPoints;
+                var r2 = radius / (extent * Math.pow(2, zoom));
+                for (var i2 = 0; i2 < points.length; i2++) {
+                  var p2 = points[i2];
+                  if (p2.zoom <= zoom) {
+                    continue;
+                  }
+                  p2.zoom = zoom;
+                  var tree = this.trees[zoom + 1];
+                  var neighborIds = tree.within(p2.x, p2.y, r2);
+                  var numPointsOrigin = p2.numPoints || 1;
+                  var numPoints = numPointsOrigin;
+                  for (var i$1 = 0, list = neighborIds; i$1 < list.length; i$1 += 1) {
+                    var neighborId = list[i$1];
+                    var b2 = tree.points[neighborId];
+                    if (b2.zoom > zoom) {
+                      numPoints += b2.numPoints || 1;
+                    }
+                  }
+                  if (numPoints >= minPoints) {
+                    var wx = p2.x * numPointsOrigin;
+                    var wy = p2.y * numPointsOrigin;
+                    var clusterProperties = reduce && numPointsOrigin > 1 ? this._map(p2, true) : null;
+                    var id2 = (i2 << 5) + (zoom + 1) + this.points.length;
+                    for (var i$2 = 0, list$1 = neighborIds; i$2 < list$1.length; i$2 += 1) {
+                      var neighborId$1 = list$1[i$2];
+                      var b$1 = tree.points[neighborId$1];
+                      if (b$1.zoom <= zoom) {
+                        continue;
+                      }
+                      b$1.zoom = zoom;
+                      var numPoints2 = b$1.numPoints || 1;
+                      wx += b$1.x * numPoints2;
+                      wy += b$1.y * numPoints2;
+                      b$1.parentId = id2;
+                      if (reduce) {
+                        if (!clusterProperties) {
+                          clusterProperties = this._map(p2, true);
+                        }
+                        reduce(clusterProperties, this._map(b$1));
+                      }
+                    }
+                    p2.parentId = id2;
+                    clusters.push(createCluster(wx / numPoints, wy / numPoints, id2, numPoints, clusterProperties));
+                  } else {
+                    clusters.push(p2);
+                    if (numPoints > 1) {
+                      for (var i$3 = 0, list$2 = neighborIds; i$3 < list$2.length; i$3 += 1) {
+                        var neighborId$2 = list$2[i$3];
+                        var b$2 = tree.points[neighborId$2];
+                        if (b$2.zoom <= zoom) {
+                          continue;
+                        }
+                        b$2.zoom = zoom;
+                        clusters.push(b$2);
+                      }
+                    }
+                  }
+                }
+                return clusters;
+              };
+              Supercluster.prototype._getOriginId = function _getOriginId(clusterId) {
+                return clusterId - this.points.length >> 5;
+              };
+              Supercluster.prototype._getOriginZoom = function _getOriginZoom(clusterId) {
+                return (clusterId - this.points.length) % 32;
+              };
+              Supercluster.prototype._map = function _map(point, clone) {
+                if (point.numPoints) {
+                  return clone ? extend2({}, point.properties) : point.properties;
+                }
+                var original = this.points[point.index].properties;
+                var result = this.options.map(original);
+                return clone && result === original ? extend2({}, result) : result;
+              };
+              function createCluster(x2, y2, id2, numPoints, properties) {
+                return {
+                  x: x2,
+                  y: y2,
+                  zoom: Infinity,
+                  id: id2,
+                  parentId: -1,
+                  numPoints,
+                  properties
+                };
+              }
+              function createPointCluster(p2, id2) {
+                var ref = p2.geometry.coordinates;
+                var x2 = ref[0];
+                var y2 = ref[1];
+                return {
+                  x: lngX(x2),
+                  y: latY(y2),
+                  zoom: Infinity,
+                  index: id2,
+                  parentId: -1
+                };
+              }
+              function getClusterJSON(cluster) {
+                return {
+                  type: "Feature",
+                  id: cluster.id,
+                  properties: getClusterProperties(cluster),
+                  geometry: {
+                    type: "Point",
+                    coordinates: [
+                      xLng(cluster.x),
+                      yLat(cluster.y)
+                    ]
+                  }
+                };
+              }
+              function getClusterProperties(cluster) {
+                var count2 = cluster.numPoints;
+                var abbrev = count2 >= 1e4 ? Math.round(count2 / 1e3) + "k" : count2 >= 1e3 ? Math.round(count2 / 100) / 10 + "k" : count2;
+                return extend2(extend2({}, cluster.properties), {
+                  cluster: true,
+                  cluster_id: cluster.id,
+                  point_count: count2,
+                  point_count_abbreviated: abbrev
+                });
+              }
+              function lngX(lng) {
+                return lng / 360 + 0.5;
+              }
+              function latY(lat) {
+                var sin = Math.sin(lat * Math.PI / 180);
+                var y2 = 0.5 - 0.25 * Math.log((1 + sin) / (1 - sin)) / Math.PI;
+                return y2 < 0 ? 0 : y2 > 1 ? 1 : y2;
+              }
+              function xLng(x2) {
+                return (x2 - 0.5) * 360;
+              }
+              function yLat(y2) {
+                var y22 = (180 - y2 * 360) * Math.PI / 180;
+                return 360 * Math.atan(Math.exp(y22)) / Math.PI - 90;
+              }
+              function extend2(dest, src) {
+                for (var id2 in src) {
+                  dest[id2] = src[id2];
+                }
+                return dest;
+              }
+              function getX(p2) {
+                return p2.x;
+              }
+              function getY(p2) {
+                return p2.y;
+              }
+              function simplify(coords, first, last, sqTolerance) {
+                var maxSqDist = sqTolerance;
+                var mid = last - first >> 1;
+                var minPosToMid = last - first;
+                var index;
+                var ax = coords[first];
+                var ay = coords[first + 1];
+                var bx = coords[last];
+                var by = coords[last + 1];
+                for (var i2 = first + 3; i2 < last; i2 += 3) {
+                  var d2 = getSqSegDist(coords[i2], coords[i2 + 1], ax, ay, bx, by);
+                  if (d2 > maxSqDist) {
+                    index = i2;
+                    maxSqDist = d2;
+                  } else if (d2 === maxSqDist) {
+                    var posToMid = Math.abs(i2 - mid);
+                    if (posToMid < minPosToMid) {
+                      index = i2;
+                      minPosToMid = posToMid;
+                    }
+                  }
+                }
+                if (maxSqDist > sqTolerance) {
+                  if (index - first > 3) {
+                    simplify(coords, first, index, sqTolerance);
+                  }
+                  coords[index + 2] = maxSqDist;
+                  if (last - index > 3) {
+                    simplify(coords, index, last, sqTolerance);
+                  }
+                }
+              }
+              function getSqSegDist(px, py, x2, y2, bx, by) {
+                var dx = bx - x2;
+                var dy = by - y2;
+                if (dx !== 0 || dy !== 0) {
+                  var t4 = ((px - x2) * dx + (py - y2) * dy) / (dx * dx + dy * dy);
+                  if (t4 > 1) {
+                    x2 = bx;
+                    y2 = by;
+                  } else if (t4 > 0) {
+                    x2 += dx * t4;
+                    y2 += dy * t4;
+                  }
+                }
+                dx = px - x2;
+                dy = py - y2;
+                return dx * dx + dy * dy;
+              }
+              function createFeature(id2, type, geom, tags) {
+                var feature = {
+                  id: typeof id2 === "undefined" ? null : id2,
+                  type,
+                  geometry: geom,
+                  tags,
+                  minX: Infinity,
+                  minY: Infinity,
+                  maxX: -Infinity,
+                  maxY: -Infinity
+                };
+                calcBBox(feature);
+                return feature;
+              }
+              function calcBBox(feature) {
+                var geom = feature.geometry;
+                var type = feature.type;
+                if (type === "Point" || type === "MultiPoint" || type === "LineString") {
+                  calcLineBBox(feature, geom);
+                } else if (type === "Polygon" || type === "MultiLineString") {
+                  for (var i2 = 0; i2 < geom.length; i2++) {
+                    calcLineBBox(feature, geom[i2]);
+                  }
+                } else if (type === "MultiPolygon") {
+                  for (i2 = 0; i2 < geom.length; i2++) {
+                    for (var j2 = 0; j2 < geom[i2].length; j2++) {
+                      calcLineBBox(feature, geom[i2][j2]);
+                    }
+                  }
+                }
+              }
+              function calcLineBBox(feature, geom) {
+                for (var i2 = 0; i2 < geom.length; i2 += 3) {
+                  feature.minX = Math.min(feature.minX, geom[i2]);
+                  feature.minY = Math.min(feature.minY, geom[i2 + 1]);
+                  feature.maxX = Math.max(feature.maxX, geom[i2]);
+                  feature.maxY = Math.max(feature.maxY, geom[i2 + 1]);
+                }
+              }
+              function convert(data, options) {
+                var features = [];
+                if (data.type === "FeatureCollection") {
+                  for (var i2 = 0; i2 < data.features.length; i2++) {
+                    convertFeature(features, data.features[i2], options, i2);
+                  }
+                } else if (data.type === "Feature") {
+                  convertFeature(features, data, options);
+                } else {
+                  convertFeature(features, { geometry: data }, options);
+                }
+                return features;
+              }
+              function convertFeature(features, geojson, options, index) {
+                if (!geojson.geometry) {
+                  return;
+                }
+                var coords = geojson.geometry.coordinates;
+                var type = geojson.geometry.type;
+                var tolerance = Math.pow(options.tolerance / ((1 << options.maxZoom) * options.extent), 2);
+                var geometry2 = [];
+                var id2 = geojson.id;
+                if (options.promoteId) {
+                  id2 = geojson.properties[options.promoteId];
+                } else if (options.generateId) {
+                  id2 = index || 0;
+                }
+                if (type === "Point") {
+                  convertPoint(coords, geometry2);
+                } else if (type === "MultiPoint") {
+                  for (var i2 = 0; i2 < coords.length; i2++) {
+                    convertPoint(coords[i2], geometry2);
+                  }
+                } else if (type === "LineString") {
+                  convertLine(coords, geometry2, tolerance, false);
+                } else if (type === "MultiLineString") {
+                  if (options.lineMetrics) {
+                    for (i2 = 0; i2 < coords.length; i2++) {
+                      geometry2 = [];
+                      convertLine(coords[i2], geometry2, tolerance, false);
+                      features.push(createFeature(id2, "LineString", geometry2, geojson.properties));
+                    }
+                    return;
+                  } else {
+                    convertLines(coords, geometry2, tolerance, false);
+                  }
+                } else if (type === "Polygon") {
+                  convertLines(coords, geometry2, tolerance, true);
+                } else if (type === "MultiPolygon") {
+                  for (i2 = 0; i2 < coords.length; i2++) {
+                    var polygon = [];
+                    convertLines(coords[i2], polygon, tolerance, true);
+                    geometry2.push(polygon);
+                  }
+                } else if (type === "GeometryCollection") {
+                  for (i2 = 0; i2 < geojson.geometry.geometries.length; i2++) {
+                    convertFeature(features, {
+                      id: id2,
+                      geometry: geojson.geometry.geometries[i2],
+                      properties: geojson.properties
+                    }, options, index);
+                  }
+                  return;
+                } else {
+                  throw new Error("Input data is not a valid GeoJSON object.");
+                }
+                features.push(createFeature(id2, type, geometry2, geojson.properties));
+              }
+              function convertPoint(coords, out) {
+                out.push(projectX(coords[0]));
+                out.push(projectY(coords[1]));
+                out.push(0);
+              }
+              function convertLine(ring, out, tolerance, isPolygon) {
+                var x0, y0;
+                var size = 0;
+                for (var j2 = 0; j2 < ring.length; j2++) {
+                  var x2 = projectX(ring[j2][0]);
+                  var y2 = projectY(ring[j2][1]);
+                  out.push(x2);
+                  out.push(y2);
+                  out.push(0);
+                  if (j2 > 0) {
+                    if (isPolygon) {
+                      size += (x0 * y2 - x2 * y0) / 2;
+                    } else {
+                      size += Math.sqrt(Math.pow(x2 - x0, 2) + Math.pow(y2 - y0, 2));
+                    }
+                  }
+                  x0 = x2;
+                  y0 = y2;
+                }
+                var last = out.length - 3;
+                out[2] = 1;
+                simplify(out, 0, last, tolerance);
+                out[last + 2] = 1;
+                out.size = Math.abs(size);
+                out.start = 0;
+                out.end = out.size;
+              }
+              function convertLines(rings, out, tolerance, isPolygon) {
+                for (var i2 = 0; i2 < rings.length; i2++) {
+                  var geom = [];
+                  convertLine(rings[i2], geom, tolerance, isPolygon);
+                  out.push(geom);
+                }
+              }
+              function projectX(x2) {
+                return x2 / 360 + 0.5;
+              }
+              function projectY(y2) {
+                var sin = Math.sin(y2 * Math.PI / 180);
+                var y22 = 0.5 - 0.25 * Math.log((1 + sin) / (1 - sin)) / Math.PI;
+                return y22 < 0 ? 0 : y22 > 1 ? 1 : y22;
+              }
+              function clip(features, scale2, k1, k2, axis, minAll, maxAll, options) {
+                k1 /= scale2;
+                k2 /= scale2;
+                if (minAll >= k1 && maxAll < k2) {
+                  return features;
+                } else if (maxAll < k1 || minAll >= k2) {
+                  return null;
+                }
+                var clipped = [];
+                for (var i2 = 0; i2 < features.length; i2++) {
+                  var feature = features[i2];
+                  var geometry2 = feature.geometry;
+                  var type = feature.type;
+                  var min = axis === 0 ? feature.minX : feature.minY;
+                  var max = axis === 0 ? feature.maxX : feature.maxY;
+                  if (min >= k1 && max < k2) {
+                    clipped.push(feature);
+                    continue;
+                  } else if (max < k1 || min >= k2) {
+                    continue;
+                  }
+                  var newGeometry = [];
+                  if (type === "Point" || type === "MultiPoint") {
+                    clipPoints(geometry2, newGeometry, k1, k2, axis);
+                  } else if (type === "LineString") {
+                    clipLine(geometry2, newGeometry, k1, k2, axis, false, options.lineMetrics);
+                  } else if (type === "MultiLineString") {
+                    clipLines(geometry2, newGeometry, k1, k2, axis, false);
+                  } else if (type === "Polygon") {
+                    clipLines(geometry2, newGeometry, k1, k2, axis, true);
+                  } else if (type === "MultiPolygon") {
+                    for (var j2 = 0; j2 < geometry2.length; j2++) {
+                      var polygon = [];
+                      clipLines(geometry2[j2], polygon, k1, k2, axis, true);
+                      if (polygon.length) {
+                        newGeometry.push(polygon);
+                      }
+                    }
+                  }
+                  if (newGeometry.length) {
+                    if (options.lineMetrics && type === "LineString") {
+                      for (j2 = 0; j2 < newGeometry.length; j2++) {
+                        clipped.push(createFeature(feature.id, type, newGeometry[j2], feature.tags));
+                      }
+                      continue;
+                    }
+                    if (type === "LineString" || type === "MultiLineString") {
+                      if (newGeometry.length === 1) {
+                        type = "LineString";
+                        newGeometry = newGeometry[0];
+                      } else {
+                        type = "MultiLineString";
+                      }
+                    }
+                    if (type === "Point" || type === "MultiPoint") {
+                      type = newGeometry.length === 3 ? "Point" : "MultiPoint";
+                    }
+                    clipped.push(createFeature(feature.id, type, newGeometry, feature.tags));
+                  }
+                }
+                return clipped.length ? clipped : null;
+              }
+              function clipPoints(geom, newGeom, k1, k2, axis) {
+                for (var i2 = 0; i2 < geom.length; i2 += 3) {
+                  var a2 = geom[i2 + axis];
+                  if (a2 >= k1 && a2 <= k2) {
+                    newGeom.push(geom[i2]);
+                    newGeom.push(geom[i2 + 1]);
+                    newGeom.push(geom[i2 + 2]);
+                  }
+                }
+              }
+              function clipLine(geom, newGeom, k1, k2, axis, isPolygon, trackMetrics) {
+                var slice = newSlice(geom);
+                var intersect = axis === 0 ? intersectX : intersectY;
+                var len2 = geom.start;
+                var segLen, t4;
+                for (var i2 = 0; i2 < geom.length - 3; i2 += 3) {
+                  var ax = geom[i2];
+                  var ay = geom[i2 + 1];
+                  var az = geom[i2 + 2];
+                  var bx = geom[i2 + 3];
+                  var by = geom[i2 + 4];
+                  var a2 = axis === 0 ? ax : ay;
+                  var b2 = axis === 0 ? bx : by;
+                  var exited = false;
+                  if (trackMetrics) {
+                    segLen = Math.sqrt(Math.pow(ax - bx, 2) + Math.pow(ay - by, 2));
+                  }
+                  if (a2 < k1) {
+                    if (b2 > k1) {
+                      t4 = intersect(slice, ax, ay, bx, by, k1);
+                      if (trackMetrics) {
+                        slice.start = len2 + segLen * t4;
+                      }
+                    }
+                  } else if (a2 > k2) {
+                    if (b2 < k2) {
+                      t4 = intersect(slice, ax, ay, bx, by, k2);
+                      if (trackMetrics) {
+                        slice.start = len2 + segLen * t4;
+                      }
+                    }
+                  } else {
+                    addPoint(slice, ax, ay, az);
+                  }
+                  if (b2 < k1 && a2 >= k1) {
+                    t4 = intersect(slice, ax, ay, bx, by, k1);
+                    exited = true;
+                  }
+                  if (b2 > k2 && a2 <= k2) {
+                    t4 = intersect(slice, ax, ay, bx, by, k2);
+                    exited = true;
+                  }
+                  if (!isPolygon && exited) {
+                    if (trackMetrics) {
+                      slice.end = len2 + segLen * t4;
+                    }
+                    newGeom.push(slice);
+                    slice = newSlice(geom);
+                  }
+                  if (trackMetrics) {
+                    len2 += segLen;
+                  }
+                }
+                var last = geom.length - 3;
+                ax = geom[last];
+                ay = geom[last + 1];
+                az = geom[last + 2];
+                a2 = axis === 0 ? ax : ay;
+                if (a2 >= k1 && a2 <= k2) {
+                  addPoint(slice, ax, ay, az);
+                }
+                last = slice.length - 3;
+                if (isPolygon && last >= 3 && (slice[last] !== slice[0] || slice[last + 1] !== slice[1])) {
+                  addPoint(slice, slice[0], slice[1], slice[2]);
+                }
+                if (slice.length) {
+                  newGeom.push(slice);
+                }
+              }
+              function newSlice(line) {
+                var slice = [];
+                slice.size = line.size;
+                slice.start = line.start;
+                slice.end = line.end;
+                return slice;
+              }
+              function clipLines(geom, newGeom, k1, k2, axis, isPolygon) {
+                for (var i2 = 0; i2 < geom.length; i2++) {
+                  clipLine(geom[i2], newGeom, k1, k2, axis, isPolygon, false);
+                }
+              }
+              function addPoint(out, x2, y2, z2) {
+                out.push(x2);
+                out.push(y2);
+                out.push(z2);
+              }
+              function intersectX(out, ax, ay, bx, by, x2) {
+                var t4 = (x2 - ax) / (bx - ax);
+                out.push(x2);
+                out.push(ay + (by - ay) * t4);
+                out.push(1);
+                return t4;
+              }
+              function intersectY(out, ax, ay, bx, by, y2) {
+                var t4 = (y2 - ay) / (by - ay);
+                out.push(ax + (bx - ax) * t4);
+                out.push(y2);
+                out.push(1);
+                return t4;
+              }
+              function wrap(features, options) {
+                var buffer = options.buffer / options.extent;
+                var merged = features;
+                var left = clip(features, 1, -1 - buffer, buffer, 0, -1, 2, options);
+                var right = clip(features, 1, 1 - buffer, 2 + buffer, 0, -1, 2, options);
+                if (left || right) {
+                  merged = clip(features, 1, -buffer, 1 + buffer, 0, -1, 2, options) || [];
+                  if (left) {
+                    merged = shiftFeatureCoords(left, 1).concat(merged);
+                  }
+                  if (right) {
+                    merged = merged.concat(shiftFeatureCoords(right, -1));
+                  }
+                }
+                return merged;
+              }
+              function shiftFeatureCoords(features, offset) {
+                var newFeatures = [];
+                for (var i2 = 0; i2 < features.length; i2++) {
+                  var feature = features[i2], type = feature.type;
+                  var newGeometry;
+                  if (type === "Point" || type === "MultiPoint" || type === "LineString") {
+                    newGeometry = shiftCoords(feature.geometry, offset);
+                  } else if (type === "MultiLineString" || type === "Polygon") {
+                    newGeometry = [];
+                    for (var j2 = 0; j2 < feature.geometry.length; j2++) {
+                      newGeometry.push(shiftCoords(feature.geometry[j2], offset));
+                    }
+                  } else if (type === "MultiPolygon") {
+                    newGeometry = [];
+                    for (j2 = 0; j2 < feature.geometry.length; j2++) {
+                      var newPolygon = [];
+                      for (var k2 = 0; k2 < feature.geometry[j2].length; k2++) {
+                        newPolygon.push(shiftCoords(feature.geometry[j2][k2], offset));
+                      }
+                      newGeometry.push(newPolygon);
+                    }
+                  }
+                  newFeatures.push(createFeature(feature.id, type, newGeometry, feature.tags));
+                }
+                return newFeatures;
+              }
+              function shiftCoords(points, offset) {
+                var newPoints = [];
+                newPoints.size = points.size;
+                if (points.start !== void 0) {
+                  newPoints.start = points.start;
+                  newPoints.end = points.end;
+                }
+                for (var i2 = 0; i2 < points.length; i2 += 3) {
+                  newPoints.push(points[i2] + offset, points[i2 + 1], points[i2 + 2]);
+                }
+                return newPoints;
+              }
+              function transformTile(tile, extent) {
+                if (tile.transformed) {
+                  return tile;
+                }
+                var z2 = 1 << tile.z, tx = tile.x, ty = tile.y, i2, j2, k2;
+                for (i2 = 0; i2 < tile.features.length; i2++) {
+                  var feature = tile.features[i2], geom = feature.geometry, type = feature.type;
+                  feature.geometry = [];
+                  if (type === 1) {
+                    for (j2 = 0; j2 < geom.length; j2 += 2) {
+                      feature.geometry.push(transformPoint(geom[j2], geom[j2 + 1], extent, z2, tx, ty));
+                    }
+                  } else {
+                    for (j2 = 0; j2 < geom.length; j2++) {
+                      var ring = [];
+                      for (k2 = 0; k2 < geom[j2].length; k2 += 2) {
+                        ring.push(transformPoint(geom[j2][k2], geom[j2][k2 + 1], extent, z2, tx, ty));
+                      }
+                      feature.geometry.push(ring);
+                    }
+                  }
+                }
+                tile.transformed = true;
+                return tile;
+              }
+              function transformPoint(x2, y2, extent, z2, tx, ty) {
+                return [
+                  Math.round(extent * (x2 * z2 - tx)),
+                  Math.round(extent * (y2 * z2 - ty))
+                ];
+              }
+              function createTile(features, z2, tx, ty, options) {
+                var tolerance = z2 === options.maxZoom ? 0 : options.tolerance / ((1 << z2) * options.extent);
+                var tile = {
+                  features: [],
+                  numPoints: 0,
+                  numSimplified: 0,
+                  numFeatures: 0,
+                  source: null,
+                  x: tx,
+                  y: ty,
+                  z: z2,
+                  transformed: false,
+                  minX: 2,
+                  minY: 1,
+                  maxX: -1,
+                  maxY: 0
+                };
+                for (var i2 = 0; i2 < features.length; i2++) {
+                  tile.numFeatures++;
+                  addFeature(tile, features[i2], tolerance, options);
+                  var minX = features[i2].minX;
+                  var minY = features[i2].minY;
+                  var maxX = features[i2].maxX;
+                  var maxY = features[i2].maxY;
+                  if (minX < tile.minX) {
+                    tile.minX = minX;
+                  }
+                  if (minY < tile.minY) {
+                    tile.minY = minY;
+                  }
+                  if (maxX > tile.maxX) {
+                    tile.maxX = maxX;
+                  }
+                  if (maxY > tile.maxY) {
+                    tile.maxY = maxY;
+                  }
+                }
+                return tile;
+              }
+              function addFeature(tile, feature, tolerance, options) {
+                var geom = feature.geometry, type = feature.type, simplified = [];
+                if (type === "Point" || type === "MultiPoint") {
+                  for (var i2 = 0; i2 < geom.length; i2 += 3) {
+                    simplified.push(geom[i2]);
+                    simplified.push(geom[i2 + 1]);
+                    tile.numPoints++;
+                    tile.numSimplified++;
+                  }
+                } else if (type === "LineString") {
+                  addLine(simplified, geom, tile, tolerance, false, false);
+                } else if (type === "MultiLineString" || type === "Polygon") {
+                  for (i2 = 0; i2 < geom.length; i2++) {
+                    addLine(simplified, geom[i2], tile, tolerance, type === "Polygon", i2 === 0);
+                  }
+                } else if (type === "MultiPolygon") {
+                  for (var k2 = 0; k2 < geom.length; k2++) {
+                    var polygon = geom[k2];
+                    for (i2 = 0; i2 < polygon.length; i2++) {
+                      addLine(simplified, polygon[i2], tile, tolerance, true, i2 === 0);
+                    }
+                  }
+                }
+                if (simplified.length) {
+                  var tags = feature.tags || null;
+                  if (type === "LineString" && options.lineMetrics) {
+                    tags = {};
+                    for (var key in feature.tags) {
+                      tags[key] = feature.tags[key];
+                    }
+                    tags["mapbox_clip_start"] = geom.start / geom.size;
+                    tags["mapbox_clip_end"] = geom.end / geom.size;
+                  }
+                  var tileFeature = {
+                    geometry: simplified,
+                    type: type === "Polygon" || type === "MultiPolygon" ? 3 : type === "LineString" || type === "MultiLineString" ? 2 : 1,
+                    tags
+                  };
+                  if (feature.id !== null) {
+                    tileFeature.id = feature.id;
+                  }
+                  tile.features.push(tileFeature);
+                }
+              }
+              function addLine(result, geom, tile, tolerance, isPolygon, isOuter) {
+                var sqTolerance = tolerance * tolerance;
+                if (tolerance > 0 && geom.size < (isPolygon ? sqTolerance : tolerance)) {
+                  tile.numPoints += geom.length / 3;
+                  return;
+                }
+                var ring = [];
+                for (var i2 = 0; i2 < geom.length; i2 += 3) {
+                  if (tolerance === 0 || geom[i2 + 2] > sqTolerance) {
+                    tile.numSimplified++;
+                    ring.push(geom[i2]);
+                    ring.push(geom[i2 + 1]);
+                  }
+                  tile.numPoints++;
+                }
+                if (isPolygon) {
+                  rewind$1(ring, isOuter);
+                }
+                result.push(ring);
+              }
+              function rewind$1(ring, clockwise) {
+                var area = 0;
+                for (var i2 = 0, len2 = ring.length, j2 = len2 - 2; i2 < len2; j2 = i2, i2 += 2) {
+                  area += (ring[i2] - ring[j2]) * (ring[i2 + 1] + ring[j2 + 1]);
+                }
+                if (area > 0 === clockwise) {
+                  for (i2 = 0, len2 = ring.length; i2 < len2 / 2; i2 += 2) {
+                    var x2 = ring[i2];
+                    var y2 = ring[i2 + 1];
+                    ring[i2] = ring[len2 - 2 - i2];
+                    ring[i2 + 1] = ring[len2 - 1 - i2];
+                    ring[len2 - 2 - i2] = x2;
+                    ring[len2 - 1 - i2] = y2;
+                  }
+                }
+              }
+              function geojsonvt(data, options) {
+                return new GeoJSONVT(data, options);
+              }
+              function GeoJSONVT(data, options) {
+                options = this.options = extend$1(Object.create(this.options), options);
+                var debug2 = options.debug;
+                if (debug2) {
+                  console.time("preprocess data");
+                }
+                if (options.maxZoom < 0 || options.maxZoom > 24) {
+                  throw new Error("maxZoom should be in the 0-24 range");
+                }
+                if (options.promoteId && options.generateId) {
+                  throw new Error("promoteId and generateId cannot be used together.");
+                }
+                var features = convert(data, options);
+                this.tiles = {};
+                this.tileCoords = [];
+                if (debug2) {
+                  console.timeEnd("preprocess data");
+                  console.log("index: maxZoom: %d, maxPoints: %d", options.indexMaxZoom, options.indexMaxPoints);
+                  console.time("generate tiles");
+                  this.stats = {};
+                  this.total = 0;
+                }
+                features = wrap(features, options);
+                if (features.length) {
+                  this.splitTile(features, 0, 0, 0);
+                }
+                if (debug2) {
+                  if (features.length) {
+                    console.log("features: %d, points: %d", this.tiles[0].numFeatures, this.tiles[0].numPoints);
+                  }
+                  console.timeEnd("generate tiles");
+                  console.log("tiles generated:", this.total, JSON.stringify(this.stats));
+                }
+              }
+              GeoJSONVT.prototype.options = {
+                maxZoom: 14,
+                indexMaxZoom: 5,
+                indexMaxPoints: 1e5,
+                tolerance: 3,
+                extent: 4096,
+                buffer: 64,
+                lineMetrics: false,
+                promoteId: null,
+                generateId: false,
+                debug: 0
+              };
+              GeoJSONVT.prototype.splitTile = function(features, z2, x2, y2, cz, cx, cy) {
+                var stack = [
+                  features,
+                  z2,
+                  x2,
+                  y2
+                ], options = this.options, debug2 = options.debug;
+                while (stack.length) {
+                  y2 = stack.pop();
+                  x2 = stack.pop();
+                  z2 = stack.pop();
+                  features = stack.pop();
+                  var z22 = 1 << z2, id2 = toID(z2, x2, y2), tile = this.tiles[id2];
+                  if (!tile) {
+                    if (debug2 > 1) {
+                      console.time("creation");
+                    }
+                    tile = this.tiles[id2] = createTile(features, z2, x2, y2, options);
+                    this.tileCoords.push({
+                      z: z2,
+                      x: x2,
+                      y: y2
+                    });
+                    if (debug2) {
+                      if (debug2 > 1) {
+                        console.log("tile z%d-%d-%d (features: %d, points: %d, simplified: %d)", z2, x2, y2, tile.numFeatures, tile.numPoints, tile.numSimplified);
+                        console.timeEnd("creation");
+                      }
+                      var key = "z" + z2;
+                      this.stats[key] = (this.stats[key] || 0) + 1;
+                      this.total++;
+                    }
+                  }
+                  tile.source = features;
+                  if (!cz) {
+                    if (z2 === options.indexMaxZoom || tile.numPoints <= options.indexMaxPoints) {
+                      continue;
+                    }
+                  } else {
+                    if (z2 === options.maxZoom || z2 === cz) {
+                      continue;
+                    }
+                    var m2 = 1 << cz - z2;
+                    if (x2 !== Math.floor(cx / m2) || y2 !== Math.floor(cy / m2)) {
+                      continue;
+                    }
+                  }
+                  tile.source = null;
+                  if (features.length === 0) {
+                    continue;
+                  }
+                  if (debug2 > 1) {
+                    console.time("clipping");
+                  }
+                  var k1 = 0.5 * options.buffer / options.extent, k2 = 0.5 - k1, k3 = 0.5 + k1, k4 = 1 + k1, tl2, bl2, tr, br, left, right;
+                  tl2 = bl2 = tr = br = null;
+                  left = clip(features, z22, x2 - k1, x2 + k3, 0, tile.minX, tile.maxX, options);
+                  right = clip(features, z22, x2 + k2, x2 + k4, 0, tile.minX, tile.maxX, options);
+                  features = null;
+                  if (left) {
+                    tl2 = clip(left, z22, y2 - k1, y2 + k3, 1, tile.minY, tile.maxY, options);
+                    bl2 = clip(left, z22, y2 + k2, y2 + k4, 1, tile.minY, tile.maxY, options);
+                    left = null;
+                  }
+                  if (right) {
+                    tr = clip(right, z22, y2 - k1, y2 + k3, 1, tile.minY, tile.maxY, options);
+                    br = clip(right, z22, y2 + k2, y2 + k4, 1, tile.minY, tile.maxY, options);
+                    right = null;
+                  }
+                  if (debug2 > 1) {
+                    console.timeEnd("clipping");
+                  }
+                  stack.push(tl2 || [], z2 + 1, x2 * 2, y2 * 2);
+                  stack.push(bl2 || [], z2 + 1, x2 * 2, y2 * 2 + 1);
+                  stack.push(tr || [], z2 + 1, x2 * 2 + 1, y2 * 2);
+                  stack.push(br || [], z2 + 1, x2 * 2 + 1, y2 * 2 + 1);
+                }
+              };
+              GeoJSONVT.prototype.getTile = function(z2, x2, y2) {
+                var options = this.options, extent = options.extent, debug2 = options.debug;
+                if (z2 < 0 || z2 > 24) {
+                  return null;
+                }
+                var z22 = 1 << z2;
+                x2 = (x2 % z22 + z22) % z22;
+                var id2 = toID(z2, x2, y2);
+                if (this.tiles[id2]) {
+                  return transformTile(this.tiles[id2], extent);
+                }
+                if (debug2 > 1) {
+                  console.log("drilling down to z%d-%d-%d", z2, x2, y2);
+                }
+                var z0 = z2, x0 = x2, y0 = y2, parent;
+                while (!parent && z0 > 0) {
+                  z0--;
+                  x0 = Math.floor(x0 / 2);
+                  y0 = Math.floor(y0 / 2);
+                  parent = this.tiles[toID(z0, x0, y0)];
+                }
+                if (!parent || !parent.source) {
+                  return null;
+                }
+                if (debug2 > 1) {
+                  console.log("found parent tile z%d-%d-%d", z0, x0, y0);
+                }
+                if (debug2 > 1) {
+                  console.time("drilling down");
+                }
+                this.splitTile(parent.source, z0, x0, y0, z2, x2, y2);
+                if (debug2 > 1) {
+                  console.timeEnd("drilling down");
+                }
+                return this.tiles[id2] ? transformTile(this.tiles[id2], extent) : null;
+              };
+              function toID(z2, x2, y2) {
+                return ((1 << z2) * y2 + x2) * 32 + z2;
+              }
+              function extend$1(dest, src) {
+                for (var i2 in src) {
+                  dest[i2] = src[i2];
+                }
+                return dest;
+              }
+              function loadGeoJSONTile(params, callback) {
+                var canonical = params.tileID.canonical;
+                if (!this._geoJSONIndex) {
+                  return callback(null, null);
+                }
+                var geoJSONTile = this._geoJSONIndex.getTile(canonical.z, canonical.x, canonical.y);
+                if (!geoJSONTile) {
+                  return callback(null, null);
+                }
+                var geojsonWrapper = new GeoJSONWrapper(geoJSONTile.features);
+                var pbf = vtPbf(geojsonWrapper);
+                if (pbf.byteOffset !== 0 || pbf.byteLength !== pbf.buffer.byteLength) {
+                  pbf = new Uint8Array(pbf);
+                }
+                callback(null, {
+                  vectorTile: geojsonWrapper,
+                  rawData: pbf.buffer
+                });
+              }
+              var GeoJSONWorkerSource = function(VectorTileWorkerSource2) {
+                function GeoJSONWorkerSource2(actor, layerIndex, availableImages, loadGeoJSON) {
+                  VectorTileWorkerSource2.call(this, actor, layerIndex, availableImages, loadGeoJSONTile);
+                  if (loadGeoJSON) {
+                    this.loadGeoJSON = loadGeoJSON;
+                  }
+                }
+                if (VectorTileWorkerSource2)
+                  GeoJSONWorkerSource2.__proto__ = VectorTileWorkerSource2;
+                GeoJSONWorkerSource2.prototype = Object.create(VectorTileWorkerSource2 && VectorTileWorkerSource2.prototype);
+                GeoJSONWorkerSource2.prototype.constructor = GeoJSONWorkerSource2;
+                GeoJSONWorkerSource2.prototype.loadData = function loadData(params, callback) {
+                  if (this._pendingCallback) {
+                    this._pendingCallback(null, { abandoned: true });
+                  }
+                  this._pendingCallback = callback;
+                  this._pendingLoadDataParams = params;
+                  if (this._state && this._state !== "Idle") {
+                    this._state = "NeedsLoadData";
+                  } else {
+                    this._state = "Coalescing";
+                    this._loadData();
+                  }
+                };
+                GeoJSONWorkerSource2.prototype._loadData = function _loadData() {
+                  var this$1$1 = this;
+                  if (!this._pendingCallback || !this._pendingLoadDataParams) {
+                    return;
+                  }
+                  var callback = this._pendingCallback;
+                  var params = this._pendingLoadDataParams;
+                  delete this._pendingCallback;
+                  delete this._pendingLoadDataParams;
+                  var perf = params && params.request && params.request.collectResourceTiming ? new performance2.RequestPerformance(params.request) : false;
+                  this.loadGeoJSON(params, function(err, data) {
+                    if (err || !data) {
+                      return callback(err);
+                    } else if (typeof data !== "object") {
+                      return callback(new Error("Input data given to '" + params.source + "' is not a valid GeoJSON object."));
+                    } else {
+                      geojsonRewind(data, true);
+                      try {
+                        if (params.filter) {
+                          var compiled = performance2.createExpression(params.filter, {
+                            type: "boolean",
+                            "property-type": "data-driven",
+                            overridable: false,
+                            transition: false
+                          });
+                          if (compiled.result === "error") {
+                            throw new Error(compiled.value.map(function(err2) {
+                              return err2.key + ": " + err2.message;
+                            }).join(", "));
+                          }
+                          var features = data.features.filter(function(feature) {
+                            return compiled.value.evaluate({ zoom: 0 }, feature);
+                          });
+                          data = {
+                            type: "FeatureCollection",
+                            features
+                          };
+                        }
+                        this$1$1._geoJSONIndex = params.cluster ? new Supercluster(getSuperclusterOptions(params)).load(data.features) : geojsonvt(data, params.geojsonVtOptions);
+                      } catch (err2) {
+                        return callback(err2);
+                      }
+                      this$1$1.loaded = {};
+                      var result = {};
+                      if (perf) {
+                        var resourceTimingData = perf.finish();
+                        if (resourceTimingData) {
+                          result.resourceTiming = {};
+                          result.resourceTiming[params.source] = JSON.parse(JSON.stringify(resourceTimingData));
+                        }
+                      }
+                      callback(null, result);
+                    }
+                  });
+                };
+                GeoJSONWorkerSource2.prototype.coalesce = function coalesce() {
+                  if (this._state === "Coalescing") {
+                    this._state = "Idle";
+                  } else if (this._state === "NeedsLoadData") {
+                    this._state = "Coalescing";
+                    this._loadData();
+                  }
+                };
+                GeoJSONWorkerSource2.prototype.reloadTile = function reloadTile(params, callback) {
+                  var loaded = this.loaded, uid2 = params.uid;
+                  if (loaded && loaded[uid2]) {
+                    return VectorTileWorkerSource2.prototype.reloadTile.call(this, params, callback);
+                  } else {
+                    return this.loadTile(params, callback);
+                  }
+                };
+                GeoJSONWorkerSource2.prototype.loadGeoJSON = function loadGeoJSON(params, callback) {
+                  if (params.request) {
+                    performance2.getJSON(params.request, callback);
+                  } else if (typeof params.data === "string") {
+                    try {
+                      return callback(null, JSON.parse(params.data));
+                    } catch (e2) {
+                      return callback(new Error("Input data given to '" + params.source + "' is not a valid GeoJSON object."));
+                    }
+                  } else {
+                    return callback(new Error("Input data given to '" + params.source + "' is not a valid GeoJSON object."));
+                  }
+                };
+                GeoJSONWorkerSource2.prototype.removeSource = function removeSource(params, callback) {
+                  if (this._pendingCallback) {
+                    this._pendingCallback(null, { abandoned: true });
+                  }
+                  callback();
+                };
+                GeoJSONWorkerSource2.prototype.getClusterExpansionZoom = function getClusterExpansionZoom(params, callback) {
+                  try {
+                    callback(null, this._geoJSONIndex.getClusterExpansionZoom(params.clusterId));
+                  } catch (e2) {
+                    callback(e2);
+                  }
+                };
+                GeoJSONWorkerSource2.prototype.getClusterChildren = function getClusterChildren(params, callback) {
+                  try {
+                    callback(null, this._geoJSONIndex.getChildren(params.clusterId));
+                  } catch (e2) {
+                    callback(e2);
+                  }
+                };
+                GeoJSONWorkerSource2.prototype.getClusterLeaves = function getClusterLeaves(params, callback) {
+                  try {
+                    callback(null, this._geoJSONIndex.getLeaves(params.clusterId, params.limit, params.offset));
+                  } catch (e2) {
+                    callback(e2);
+                  }
+                };
+                return GeoJSONWorkerSource2;
+              }(VectorTileWorkerSource);
+              function getSuperclusterOptions(ref) {
+                var superclusterOptions = ref.superclusterOptions;
+                var clusterProperties = ref.clusterProperties;
+                if (!clusterProperties || !superclusterOptions) {
+                  return superclusterOptions;
+                }
+                var mapExpressions = {};
+                var reduceExpressions = {};
+                var globals = {
+                  accumulated: null,
+                  zoom: 0
+                };
+                var feature = { properties: null };
+                var propertyNames = Object.keys(clusterProperties);
+                for (var i2 = 0, list = propertyNames; i2 < list.length; i2 += 1) {
+                  var key = list[i2];
+                  var ref$1 = clusterProperties[key];
+                  var operator = ref$1[0];
+                  var mapExpression = ref$1[1];
+                  var mapExpressionParsed = performance2.createExpression(mapExpression);
+                  var reduceExpressionParsed = performance2.createExpression(typeof operator === "string" ? [
+                    operator,
+                    ["accumulated"],
+                    [
+                      "get",
+                      key
+                    ]
+                  ] : operator);
+                  mapExpressions[key] = mapExpressionParsed.value;
+                  reduceExpressions[key] = reduceExpressionParsed.value;
+                }
+                superclusterOptions.map = function(pointProperties) {
+                  feature.properties = pointProperties;
+                  var properties = {};
+                  for (var i22 = 0, list2 = propertyNames; i22 < list2.length; i22 += 1) {
+                    var key2 = list2[i22];
+                    properties[key2] = mapExpressions[key2].evaluate(globals, feature);
+                  }
+                  return properties;
+                };
+                superclusterOptions.reduce = function(accumulated, clusterProperties2) {
+                  feature.properties = clusterProperties2;
+                  for (var i22 = 0, list2 = propertyNames; i22 < list2.length; i22 += 1) {
+                    var key2 = list2[i22];
+                    globals.accumulated = accumulated[key2];
+                    accumulated[key2] = reduceExpressions[key2].evaluate(globals, feature);
+                  }
+                };
+                return superclusterOptions;
+              }
+              var Worker2 = function Worker3(self2) {
+                var this$1$1 = this;
+                this.self = self2;
+                this.actor = new performance2.Actor(self2, this);
+                this.layerIndexes = {};
+                this.availableImages = {};
+                this.workerSourceTypes = {
+                  vector: VectorTileWorkerSource,
+                  geojson: GeoJSONWorkerSource
+                };
+                this.workerSources = {};
+                this.demWorkerSources = {};
+                this.self.registerWorkerSource = function(name2, WorkerSource) {
+                  if (this$1$1.workerSourceTypes[name2]) {
+                    throw new Error('Worker source with name "' + name2 + '" already registered.');
+                  }
+                  this$1$1.workerSourceTypes[name2] = WorkerSource;
+                };
+                this.self.registerRTLTextPlugin = function(rtlTextPlugin) {
+                  if (performance2.plugin.isParsed()) {
+                    throw new Error("RTL text plugin already registered.");
+                  }
+                  performance2.plugin["applyArabicShaping"] = rtlTextPlugin.applyArabicShaping;
+                  performance2.plugin["processBidirectionalText"] = rtlTextPlugin.processBidirectionalText;
+                  performance2.plugin["processStyledBidirectionalText"] = rtlTextPlugin.processStyledBidirectionalText;
+                };
+              };
+              Worker2.prototype.setReferrer = function setReferrer(mapID, referrer) {
+                this.referrer = referrer;
+              };
+              Worker2.prototype.setImages = function setImages(mapId, images, callback) {
+                this.availableImages[mapId] = images;
+                for (var workerSource in this.workerSources[mapId]) {
+                  var ws = this.workerSources[mapId][workerSource];
+                  for (var source2 in ws) {
+                    ws[source2].availableImages = images;
+                  }
+                }
+                callback();
+              };
+              Worker2.prototype.setLayers = function setLayers(mapId, layers, callback) {
+                this.getLayerIndex(mapId).replace(layers);
+                callback();
+              };
+              Worker2.prototype.updateLayers = function updateLayers(mapId, params, callback) {
+                this.getLayerIndex(mapId).update(params.layers, params.removedIds);
+                callback();
+              };
+              Worker2.prototype.loadTile = function loadTile(mapId, params, callback) {
+                this.getWorkerSource(mapId, params.type, params.source).loadTile(params, callback);
+              };
+              Worker2.prototype.loadDEMTile = function loadDEMTile(mapId, params, callback) {
+                this.getDEMWorkerSource(mapId, params.source).loadTile(params, callback);
+              };
+              Worker2.prototype.reloadTile = function reloadTile(mapId, params, callback) {
+                this.getWorkerSource(mapId, params.type, params.source).reloadTile(params, callback);
+              };
+              Worker2.prototype.abortTile = function abortTile(mapId, params, callback) {
+                this.getWorkerSource(mapId, params.type, params.source).abortTile(params, callback);
+              };
+              Worker2.prototype.removeTile = function removeTile(mapId, params, callback) {
+                this.getWorkerSource(mapId, params.type, params.source).removeTile(params, callback);
+              };
+              Worker2.prototype.removeDEMTile = function removeDEMTile(mapId, params) {
+                this.getDEMWorkerSource(mapId, params.source).removeTile(params);
+              };
+              Worker2.prototype.removeSource = function removeSource(mapId, params, callback) {
+                if (!this.workerSources[mapId] || !this.workerSources[mapId][params.type] || !this.workerSources[mapId][params.type][params.source]) {
+                  return;
+                }
+                var worker2 = this.workerSources[mapId][params.type][params.source];
+                delete this.workerSources[mapId][params.type][params.source];
+                if (worker2.removeSource !== void 0) {
+                  worker2.removeSource(params, callback);
+                } else {
+                  callback();
+                }
+              };
+              Worker2.prototype.loadWorkerSource = function loadWorkerSource(map2, params, callback) {
+                try {
+                  this.self.importScripts(params.url);
+                  callback();
+                } catch (e2) {
+                  callback(e2.toString());
+                }
+              };
+              Worker2.prototype.syncRTLPluginState = function syncRTLPluginState(map2, state, callback) {
+                try {
+                  performance2.plugin.setState(state);
+                  var pluginURL = performance2.plugin.getPluginURL();
+                  if (performance2.plugin.isLoaded() && !performance2.plugin.isParsed() && pluginURL != null) {
+                    this.self.importScripts(pluginURL);
+                    var complete = performance2.plugin.isParsed();
+                    var error = complete ? void 0 : new Error("RTL Text Plugin failed to import scripts from " + pluginURL);
+                    callback(error, complete);
+                  }
+                } catch (e2) {
+                  callback(e2.toString());
+                }
+              };
+              Worker2.prototype.getAvailableImages = function getAvailableImages(mapId) {
+                var availableImages = this.availableImages[mapId];
+                if (!availableImages) {
+                  availableImages = [];
+                }
+                return availableImages;
+              };
+              Worker2.prototype.getLayerIndex = function getLayerIndex(mapId) {
+                var layerIndexes = this.layerIndexes[mapId];
+                if (!layerIndexes) {
+                  layerIndexes = this.layerIndexes[mapId] = new StyleLayerIndex();
+                }
+                return layerIndexes;
+              };
+              Worker2.prototype.getWorkerSource = function getWorkerSource(mapId, type, source2) {
+                var this$1$1 = this;
+                if (!this.workerSources[mapId]) {
+                  this.workerSources[mapId] = {};
+                }
+                if (!this.workerSources[mapId][type]) {
+                  this.workerSources[mapId][type] = {};
+                }
+                if (!this.workerSources[mapId][type][source2]) {
+                  var actor = {
+                    send: function(type2, data, callback) {
+                      this$1$1.actor.send(type2, data, callback, mapId);
+                    }
+                  };
+                  this.workerSources[mapId][type][source2] = new this.workerSourceTypes[type](actor, this.getLayerIndex(mapId), this.getAvailableImages(mapId));
+                }
+                return this.workerSources[mapId][type][source2];
+              };
+              Worker2.prototype.getDEMWorkerSource = function getDEMWorkerSource(mapId, source2) {
+                if (!this.demWorkerSources[mapId]) {
+                  this.demWorkerSources[mapId] = {};
+                }
+                if (!this.demWorkerSources[mapId][source2]) {
+                  this.demWorkerSources[mapId][source2] = new RasterDEMTileWorkerSource();
+                }
+                return this.demWorkerSources[mapId][source2];
+              };
+              Worker2.prototype.enforceCacheSizeLimit = function enforceCacheSizeLimit$1(mapId, limit) {
+                performance2.enforceCacheSizeLimit(limit);
+              };
+              if (typeof WorkerGlobalScope !== "undefined" && typeof self !== "undefined" && self instanceof WorkerGlobalScope) {
+                self.worker = new Worker2(self);
+              }
+              return Worker2;
+            });
+            define2(["./shared"], function(performance2) {
+              var mapboxGlSupported = performance2.createCommonjsModule(function(module22) {
+                if (module22.exports) {
+                  module22.exports = isSupported;
+                } else if (window) {
+                  window.mapboxgl = window.mapboxgl || {};
+                  window.mapboxgl.supported = isSupported;
+                  window.mapboxgl.notSupportedReason = notSupportedReason;
+                }
+                function isSupported(options) {
+                  return !notSupportedReason(options);
+                }
+                function notSupportedReason(options) {
+                  if (!isBrowser2()) {
+                    return "not a browser";
+                  }
+                  if (!isArraySupported()) {
+                    return "insufficent Array support";
+                  }
+                  if (!isFunctionSupported()) {
+                    return "insufficient Function support";
+                  }
+                  if (!isObjectSupported()) {
+                    return "insufficient Object support";
+                  }
+                  if (!isJSONSupported()) {
+                    return "insufficient JSON support";
+                  }
+                  if (!isWorkerSupported()) {
+                    return "insufficient worker support";
+                  }
+                  if (!isUint8ClampedArraySupported()) {
+                    return "insufficient Uint8ClampedArray support";
+                  }
+                  if (!isArrayBufferSupported()) {
+                    return "insufficient ArrayBuffer support";
+                  }
+                  if (!isCanvasGetImageDataSupported()) {
+                    return "insufficient Canvas/getImageData support";
+                  }
+                  if (!isWebGLSupportedCached(options && options.failIfMajorPerformanceCaveat)) {
+                    return "insufficient WebGL support";
+                  }
+                }
+                function isBrowser2() {
+                  return typeof window !== "undefined" && typeof document !== "undefined";
+                }
+                function isArraySupported() {
+                  return Array.prototype && Array.prototype.every && Array.prototype.filter && Array.prototype.forEach && Array.prototype.indexOf && Array.prototype.lastIndexOf && Array.prototype.map && Array.prototype.some && Array.prototype.reduce && Array.prototype.reduceRight && Array.isArray;
+                }
+                function isFunctionSupported() {
+                  return Function.prototype && Function.prototype.bind;
+                }
+                function isObjectSupported() {
+                  return Object.keys && Object.create && Object.getPrototypeOf && Object.getOwnPropertyNames && Object.isSealed && Object.isFrozen && Object.isExtensible && Object.getOwnPropertyDescriptor && Object.defineProperty && Object.defineProperties && Object.seal && Object.freeze && Object.preventExtensions;
+                }
+                function isJSONSupported() {
+                  return "JSON" in window && "parse" in JSON && "stringify" in JSON;
+                }
+                function isWorkerSupported() {
+                  if (!("Worker" in window && "Blob" in window && "URL" in window)) {
+                    return false;
+                  }
+                  var blob = new Blob([""], { type: "text/javascript" });
+                  var workerURL = URL.createObjectURL(blob);
+                  var supported;
+                  var worker2;
+                  try {
+                    worker2 = new Worker(workerURL);
+                    supported = true;
+                  } catch (e2) {
+                    supported = false;
+                  }
+                  if (worker2) {
+                    worker2.terminate();
+                  }
+                  URL.revokeObjectURL(workerURL);
+                  return supported;
+                }
+                function isUint8ClampedArraySupported() {
+                  return "Uint8ClampedArray" in window;
+                }
+                function isArrayBufferSupported() {
+                  return ArrayBuffer.isView;
+                }
+                function isCanvasGetImageDataSupported() {
+                  var canvas2 = document.createElement("canvas");
+                  canvas2.width = canvas2.height = 1;
+                  var context = canvas2.getContext("2d");
+                  if (!context) {
+                    return false;
+                  }
+                  var imageData = context.getImageData(0, 0, 1, 1);
+                  return imageData && imageData.width === canvas2.width;
+                }
+                var isWebGLSupportedCache = {};
+                function isWebGLSupportedCached(failIfMajorPerformanceCaveat) {
+                  if (isWebGLSupportedCache[failIfMajorPerformanceCaveat] === void 0) {
+                    isWebGLSupportedCache[failIfMajorPerformanceCaveat] = isWebGLSupported(failIfMajorPerformanceCaveat);
+                  }
+                  return isWebGLSupportedCache[failIfMajorPerformanceCaveat];
+                }
+                isSupported.webGLContextAttributes = {
+                  antialias: false,
+                  alpha: true,
+                  stencil: true,
+                  depth: true
+                };
+                function getWebGLContext(failIfMajorPerformanceCaveat) {
+                  var canvas2 = document.createElement("canvas");
+                  var attributes = Object.create(isSupported.webGLContextAttributes);
+                  attributes.failIfMajorPerformanceCaveat = failIfMajorPerformanceCaveat;
+                  if (canvas2.probablySupportsContext) {
+                    return canvas2.probablySupportsContext("webgl", attributes) || canvas2.probablySupportsContext("experimental-webgl", attributes);
+                  } else if (canvas2.supportsContext) {
+                    return canvas2.supportsContext("webgl", attributes) || canvas2.supportsContext("experimental-webgl", attributes);
+                  } else {
+                    return canvas2.getContext("webgl", attributes) || canvas2.getContext("experimental-webgl", attributes);
+                  }
+                }
+                function isWebGLSupported(failIfMajorPerformanceCaveat) {
+                  var gl2 = getWebGLContext(failIfMajorPerformanceCaveat);
+                  if (!gl2) {
+                    return false;
+                  }
+                  var shader = gl2.createShader(gl2.VERTEX_SHADER);
+                  if (!shader || gl2.isContextLost()) {
+                    return false;
+                  }
+                  gl2.shaderSource(shader, "void main() {}");
+                  gl2.compileShader(shader);
+                  return gl2.getShaderParameter(shader, gl2.COMPILE_STATUS) === true;
+                }
+              });
+              var DOM = {};
+              DOM.create = function(tagName, className, container) {
+                var el2 = performance2.window.document.createElement(tagName);
+                if (className !== void 0) {
+                  el2.className = className;
+                }
+                if (container) {
+                  container.appendChild(el2);
+                }
+                return el2;
+              };
+              DOM.createNS = function(namespaceURI, tagName) {
+                var el2 = performance2.window.document.createElementNS(namespaceURI, tagName);
+                return el2;
+              };
+              var docStyle = performance2.window.document && performance2.window.document.documentElement.style;
+              function testProp(props) {
+                if (!docStyle) {
+                  return props[0];
+                }
+                for (var i2 = 0; i2 < props.length; i2++) {
+                  if (props[i2] in docStyle) {
+                    return props[i2];
+                  }
+                }
+                return props[0];
+              }
+              var selectProp = testProp([
+                "userSelect",
+                "MozUserSelect",
+                "WebkitUserSelect",
+                "msUserSelect"
+              ]);
+              var userSelect;
+              DOM.disableDrag = function() {
+                if (docStyle && selectProp) {
+                  userSelect = docStyle[selectProp];
+                  docStyle[selectProp] = "none";
+                }
+              };
+              DOM.enableDrag = function() {
+                if (docStyle && selectProp) {
+                  docStyle[selectProp] = userSelect;
+                }
+              };
+              var transformProp = testProp([
+                "transform",
+                "WebkitTransform"
+              ]);
+              DOM.setTransform = function(el2, value) {
+                el2.style[transformProp] = value;
+              };
+              var passiveSupported = false;
+              try {
+                var options$1 = Object.defineProperty({}, "passive", {
+                  get: function get() {
+                    passiveSupported = true;
+                  }
+                });
+                performance2.window.addEventListener("test", options$1, options$1);
+                performance2.window.removeEventListener("test", options$1, options$1);
+              } catch (err) {
+                passiveSupported = false;
+              }
+              DOM.addEventListener = function(target, type, callback, options) {
+                if (options === void 0)
+                  options = {};
+                if ("passive" in options && passiveSupported) {
+                  target.addEventListener(type, callback, options);
+                } else {
+                  target.addEventListener(type, callback, options.capture);
+                }
+              };
+              DOM.removeEventListener = function(target, type, callback, options) {
+                if (options === void 0)
+                  options = {};
+                if ("passive" in options && passiveSupported) {
+                  target.removeEventListener(type, callback, options);
+                } else {
+                  target.removeEventListener(type, callback, options.capture);
+                }
+              };
+              var suppressClick = function(e2) {
+                e2.preventDefault();
+                e2.stopPropagation();
+                performance2.window.removeEventListener("click", suppressClick, true);
+              };
+              DOM.suppressClick = function() {
+                performance2.window.addEventListener("click", suppressClick, true);
+                performance2.window.setTimeout(function() {
+                  performance2.window.removeEventListener("click", suppressClick, true);
+                }, 0);
+              };
+              DOM.mousePos = function(el2, e2) {
+                var rect = el2.getBoundingClientRect();
+                return new performance2.Point(e2.clientX - rect.left - el2.clientLeft, e2.clientY - rect.top - el2.clientTop);
+              };
+              DOM.touchPos = function(el2, touches) {
+                var rect = el2.getBoundingClientRect(), points = [];
+                for (var i2 = 0; i2 < touches.length; i2++) {
+                  points.push(new performance2.Point(touches[i2].clientX - rect.left - el2.clientLeft, touches[i2].clientY - rect.top - el2.clientTop));
+                }
+                return points;
+              };
+              DOM.mouseButton = function(e2) {
+                if (typeof performance2.window.InstallTrigger !== "undefined" && e2.button === 2 && e2.ctrlKey && performance2.window.navigator.platform.toUpperCase().indexOf("MAC") >= 0) {
+                  return 0;
+                }
+                return e2.button;
+              };
+              DOM.remove = function(node) {
+                if (node.parentNode) {
+                  node.parentNode.removeChild(node);
+                }
+              };
+              function loadSprite(baseURL, requestManager, callback) {
+                var json, image, error;
+                var format = performance2.browser.devicePixelRatio > 1 ? "@2x" : "";
+                var jsonRequest = performance2.getJSON(requestManager.transformRequest(requestManager.normalizeSpriteURL(baseURL, format, ".json"), performance2.ResourceType.SpriteJSON), function(err, data) {
+                  jsonRequest = null;
+                  if (!error) {
+                    error = err;
+                    json = data;
+                    maybeComplete();
+                  }
+                });
+                var imageRequest = performance2.getImage(requestManager.transformRequest(requestManager.normalizeSpriteURL(baseURL, format, ".png"), performance2.ResourceType.SpriteImage), function(err, img) {
+                  imageRequest = null;
+                  if (!error) {
+                    error = err;
+                    image = img;
+                    maybeComplete();
+                  }
+                });
+                function maybeComplete() {
+                  if (error) {
+                    callback(error);
+                  } else if (json && image) {
+                    var imageData = performance2.browser.getImageData(image);
+                    var result = {};
+                    for (var id2 in json) {
+                      var ref = json[id2];
+                      var width = ref.width;
+                      var height = ref.height;
+                      var x2 = ref.x;
+                      var y2 = ref.y;
+                      var sdf = ref.sdf;
+                      var pixelRatio = ref.pixelRatio;
+                      var stretchX = ref.stretchX;
+                      var stretchY = ref.stretchY;
+                      var content = ref.content;
+                      var data = new performance2.RGBAImage({
+                        width,
+                        height
+                      });
+                      performance2.RGBAImage.copy(imageData, data, {
+                        x: x2,
+                        y: y2
+                      }, {
+                        x: 0,
+                        y: 0
+                      }, {
+                        width,
+                        height
+                      });
+                      result[id2] = {
+                        data,
+                        pixelRatio,
+                        sdf,
+                        stretchX,
+                        stretchY,
+                        content
+                      };
+                    }
+                    callback(null, result);
+                  }
+                }
+                return {
+                  cancel: function cancel() {
+                    if (jsonRequest) {
+                      jsonRequest.cancel();
+                      jsonRequest = null;
+                    }
+                    if (imageRequest) {
+                      imageRequest.cancel();
+                      imageRequest = null;
+                    }
+                  }
+                };
+              }
+              function renderStyleImage(image) {
+                var userImage = image.userImage;
+                if (userImage && userImage.render) {
+                  var updated = userImage.render();
+                  if (updated) {
+                    image.data.replace(new Uint8Array(userImage.data.buffer));
+                    return true;
+                  }
+                }
+                return false;
+              }
+              var padding = 1;
+              var ImageManager = function(Evented) {
+                function ImageManager2() {
+                  Evented.call(this);
+                  this.images = {};
+                  this.updatedImages = {};
+                  this.callbackDispatchedThisFrame = {};
+                  this.loaded = false;
+                  this.requestors = [];
+                  this.patterns = {};
+                  this.atlasImage = new performance2.RGBAImage({
+                    width: 1,
+                    height: 1
+                  });
+                  this.dirty = true;
+                }
+                if (Evented)
+                  ImageManager2.__proto__ = Evented;
+                ImageManager2.prototype = Object.create(Evented && Evented.prototype);
+                ImageManager2.prototype.constructor = ImageManager2;
+                ImageManager2.prototype.isLoaded = function isLoaded() {
+                  return this.loaded;
+                };
+                ImageManager2.prototype.setLoaded = function setLoaded(loaded) {
+                  if (this.loaded === loaded) {
+                    return;
+                  }
+                  this.loaded = loaded;
+                  if (loaded) {
+                    for (var i2 = 0, list = this.requestors; i2 < list.length; i2 += 1) {
+                      var ref = list[i2];
+                      var ids = ref.ids;
+                      var callback = ref.callback;
+                      this._notify(ids, callback);
+                    }
+                    this.requestors = [];
+                  }
+                };
+                ImageManager2.prototype.getImage = function getImage(id2) {
+                  return this.images[id2];
+                };
+                ImageManager2.prototype.addImage = function addImage(id2, image) {
+                  if (this._validate(id2, image)) {
+                    this.images[id2] = image;
+                  }
+                };
+                ImageManager2.prototype._validate = function _validate(id2, image) {
+                  var valid = true;
+                  if (!this._validateStretch(image.stretchX, image.data && image.data.width)) {
+                    this.fire(new performance2.ErrorEvent(new Error('Image "' + id2 + '" has invalid "stretchX" value')));
+                    valid = false;
+                  }
+                  if (!this._validateStretch(image.stretchY, image.data && image.data.height)) {
+                    this.fire(new performance2.ErrorEvent(new Error('Image "' + id2 + '" has invalid "stretchY" value')));
+                    valid = false;
+                  }
+                  if (!this._validateContent(image.content, image)) {
+                    this.fire(new performance2.ErrorEvent(new Error('Image "' + id2 + '" has invalid "content" value')));
+                    valid = false;
+                  }
+                  return valid;
+                };
+                ImageManager2.prototype._validateStretch = function _validateStretch(stretch, size) {
+                  if (!stretch) {
+                    return true;
+                  }
+                  var last = 0;
+                  for (var i2 = 0, list = stretch; i2 < list.length; i2 += 1) {
+                    var part = list[i2];
+                    if (part[0] < last || part[1] < part[0] || size < part[1]) {
+                      return false;
+                    }
+                    last = part[1];
+                  }
+                  return true;
+                };
+                ImageManager2.prototype._validateContent = function _validateContent(content, image) {
+                  if (!content) {
+                    return true;
+                  }
+                  if (content.length !== 4) {
+                    return false;
+                  }
+                  if (content[0] < 0 || image.data.width < content[0]) {
+                    return false;
+                  }
+                  if (content[1] < 0 || image.data.height < content[1]) {
+                    return false;
+                  }
+                  if (content[2] < 0 || image.data.width < content[2]) {
+                    return false;
+                  }
+                  if (content[3] < 0 || image.data.height < content[3]) {
+                    return false;
+                  }
+                  if (content[2] < content[0]) {
+                    return false;
+                  }
+                  if (content[3] < content[1]) {
+                    return false;
+                  }
+                  return true;
+                };
+                ImageManager2.prototype.updateImage = function updateImage(id2, image) {
+                  var oldImage = this.images[id2];
+                  image.version = oldImage.version + 1;
+                  this.images[id2] = image;
+                  this.updatedImages[id2] = true;
+                };
+                ImageManager2.prototype.removeImage = function removeImage(id2) {
+                  var image = this.images[id2];
+                  delete this.images[id2];
+                  delete this.patterns[id2];
+                  if (image.userImage && image.userImage.onRemove) {
+                    image.userImage.onRemove();
+                  }
+                };
+                ImageManager2.prototype.listImages = function listImages() {
+                  return Object.keys(this.images);
+                };
+                ImageManager2.prototype.getImages = function getImages(ids, callback) {
+                  var hasAllDependencies = true;
+                  if (!this.isLoaded()) {
+                    for (var i2 = 0, list = ids; i2 < list.length; i2 += 1) {
+                      var id2 = list[i2];
+                      if (!this.images[id2]) {
+                        hasAllDependencies = false;
+                      }
+                    }
+                  }
+                  if (this.isLoaded() || hasAllDependencies) {
+                    this._notify(ids, callback);
+                  } else {
+                    this.requestors.push({
+                      ids,
+                      callback
+                    });
+                  }
+                };
+                ImageManager2.prototype._notify = function _notify(ids, callback) {
+                  var response = {};
+                  for (var i2 = 0, list = ids; i2 < list.length; i2 += 1) {
+                    var id2 = list[i2];
+                    if (!this.images[id2]) {
+                      this.fire(new performance2.Event("styleimagemissing", { id: id2 }));
+                    }
+                    var image = this.images[id2];
+                    if (image) {
+                      response[id2] = {
+                        data: image.data.clone(),
+                        pixelRatio: image.pixelRatio,
+                        sdf: image.sdf,
+                        version: image.version,
+                        stretchX: image.stretchX,
+                        stretchY: image.stretchY,
+                        content: image.content,
+                        hasRenderCallback: Boolean(image.userImage && image.userImage.render)
+                      };
+                    } else {
+                      performance2.warnOnce('Image "' + id2 + '" could not be loaded. Please make sure you have added the image with map.addImage() or a "sprite" property in your style. You can provide missing images by listening for the "styleimagemissing" map event.');
+                    }
+                  }
+                  callback(null, response);
+                };
+                ImageManager2.prototype.getPixelSize = function getPixelSize() {
+                  var ref = this.atlasImage;
+                  var width = ref.width;
+                  var height = ref.height;
+                  return {
+                    width,
+                    height
+                  };
+                };
+                ImageManager2.prototype.getPattern = function getPattern(id2) {
+                  var pattern = this.patterns[id2];
+                  var image = this.getImage(id2);
+                  if (!image) {
+                    return null;
+                  }
+                  if (pattern && pattern.position.version === image.version) {
+                    return pattern.position;
+                  }
+                  if (!pattern) {
+                    var w2 = image.data.width + padding * 2;
+                    var h2 = image.data.height + padding * 2;
+                    var bin = {
+                      w: w2,
+                      h: h2,
+                      x: 0,
+                      y: 0
+                    };
+                    var position = new performance2.ImagePosition(bin, image);
+                    this.patterns[id2] = {
+                      bin,
+                      position
+                    };
+                  } else {
+                    pattern.position.version = image.version;
+                  }
+                  this._updatePatternAtlas();
+                  return this.patterns[id2].position;
+                };
+                ImageManager2.prototype.bind = function bind(context) {
+                  var gl2 = context.gl;
+                  if (!this.atlasTexture) {
+                    this.atlasTexture = new performance2.Texture(context, this.atlasImage, gl2.RGBA);
+                  } else if (this.dirty) {
+                    this.atlasTexture.update(this.atlasImage);
+                    this.dirty = false;
+                  }
+                  this.atlasTexture.bind(gl2.LINEAR, gl2.CLAMP_TO_EDGE);
+                };
+                ImageManager2.prototype._updatePatternAtlas = function _updatePatternAtlas() {
+                  var bins = [];
+                  for (var id2 in this.patterns) {
+                    bins.push(this.patterns[id2].bin);
+                  }
+                  var ref = performance2.potpack(bins);
+                  var w2 = ref.w;
+                  var h2 = ref.h;
+                  var dst = this.atlasImage;
+                  dst.resize({
+                    width: w2 || 1,
+                    height: h2 || 1
+                  });
+                  for (var id$1 in this.patterns) {
+                    var ref$1 = this.patterns[id$1];
+                    var bin = ref$1.bin;
+                    var x2 = bin.x + padding;
+                    var y2 = bin.y + padding;
+                    var src = this.images[id$1].data;
+                    var w$12 = src.width;
+                    var h$1 = src.height;
+                    performance2.RGBAImage.copy(src, dst, {
+                      x: 0,
+                      y: 0
+                    }, {
+                      x: x2,
+                      y: y2
+                    }, {
+                      width: w$12,
+                      height: h$1
+                    });
+                    performance2.RGBAImage.copy(src, dst, {
+                      x: 0,
+                      y: h$1 - 1
+                    }, {
+                      x: x2,
+                      y: y2 - 1
+                    }, {
+                      width: w$12,
+                      height: 1
+                    });
+                    performance2.RGBAImage.copy(src, dst, {
+                      x: 0,
+                      y: 0
+                    }, {
+                      x: x2,
+                      y: y2 + h$1
+                    }, {
+                      width: w$12,
+                      height: 1
+                    });
+                    performance2.RGBAImage.copy(src, dst, {
+                      x: w$12 - 1,
+                      y: 0
+                    }, {
+                      x: x2 - 1,
+                      y: y2
+                    }, {
+                      width: 1,
+                      height: h$1
+                    });
+                    performance2.RGBAImage.copy(src, dst, {
+                      x: 0,
+                      y: 0
+                    }, {
+                      x: x2 + w$12,
+                      y: y2
+                    }, {
+                      width: 1,
+                      height: h$1
+                    });
+                  }
+                  this.dirty = true;
+                };
+                ImageManager2.prototype.beginFrame = function beginFrame() {
+                  this.callbackDispatchedThisFrame = {};
+                };
+                ImageManager2.prototype.dispatchRenderCallbacks = function dispatchRenderCallbacks(ids) {
+                  for (var i2 = 0, list = ids; i2 < list.length; i2 += 1) {
+                    var id2 = list[i2];
+                    if (this.callbackDispatchedThisFrame[id2]) {
+                      continue;
+                    }
+                    this.callbackDispatchedThisFrame[id2] = true;
+                    var image = this.images[id2];
+                    var updated = renderStyleImage(image);
+                    if (updated) {
+                      this.updateImage(id2, image);
+                    }
+                  }
+                };
+                return ImageManager2;
+              }(performance2.Evented);
+              function loadGlyphRange(fontstack, range, urlTemplate, requestManager, callback) {
+                var begin = range * 256;
+                var end = begin + 255;
+                var request = requestManager.transformRequest(requestManager.normalizeGlyphsURL(urlTemplate).replace("{fontstack}", fontstack).replace("{range}", begin + "-" + end), performance2.ResourceType.Glyphs);
+                performance2.getArrayBuffer(request, function(err, data) {
+                  if (err) {
+                    callback(err);
+                  } else if (data) {
+                    var glyphs = {};
+                    for (var i2 = 0, list = performance2.parseGlyphPBF(data); i2 < list.length; i2 += 1) {
+                      var glyph = list[i2];
+                      glyphs[glyph.id] = glyph;
+                    }
+                    callback(null, glyphs);
+                  }
+                });
+              }
+              var tinySdf = TinySDF;
+              var default_1 = TinySDF;
+              var INF = 1e20;
+              function TinySDF(fontSize, buffer, radius, cutoff, fontFamily, fontWeight) {
+                this.fontSize = fontSize || 24;
+                this.buffer = buffer === void 0 ? 3 : buffer;
+                this.cutoff = cutoff || 0.25;
+                this.fontFamily = fontFamily || "sans-serif";
+                this.fontWeight = fontWeight || "normal";
+                this.radius = radius || 8;
+                var size = this.size = this.fontSize + this.buffer * 2;
+                this.canvas = document.createElement("canvas");
+                this.canvas.width = this.canvas.height = size;
+                this.ctx = this.canvas.getContext("2d");
+                this.ctx.font = this.fontWeight + " " + this.fontSize + "px " + this.fontFamily;
+                this.ctx.textBaseline = "middle";
+                this.ctx.fillStyle = "black";
+                this.gridOuter = new Float64Array(size * size);
+                this.gridInner = new Float64Array(size * size);
+                this.f = new Float64Array(size);
+                this.d = new Float64Array(size);
+                this.z = new Float64Array(size + 1);
+                this.v = new Int16Array(size);
+                this.middle = Math.round(size / 2 * (navigator.userAgent.indexOf("Gecko/") >= 0 ? 1.2 : 1));
+              }
+              TinySDF.prototype.draw = function(char) {
+                this.ctx.clearRect(0, 0, this.size, this.size);
+                this.ctx.fillText(char, this.buffer, this.middle);
+                var imgData = this.ctx.getImageData(0, 0, this.size, this.size);
+                var alphaChannel = new Uint8ClampedArray(this.size * this.size);
+                for (var i2 = 0; i2 < this.size * this.size; i2++) {
+                  var a2 = imgData.data[i2 * 4 + 3] / 255;
+                  this.gridOuter[i2] = a2 === 1 ? 0 : a2 === 0 ? INF : Math.pow(Math.max(0, 0.5 - a2), 2);
+                  this.gridInner[i2] = a2 === 1 ? INF : a2 === 0 ? 0 : Math.pow(Math.max(0, a2 - 0.5), 2);
+                }
+                edt(this.gridOuter, this.size, this.size, this.f, this.d, this.v, this.z);
+                edt(this.gridInner, this.size, this.size, this.f, this.d, this.v, this.z);
+                for (i2 = 0; i2 < this.size * this.size; i2++) {
+                  var d2 = this.gridOuter[i2] - this.gridInner[i2];
+                  alphaChannel[i2] = Math.max(0, Math.min(255, Math.round(255 - 255 * (d2 / this.radius + this.cutoff))));
+                }
+                return alphaChannel;
+              };
+              function edt(data, width, height, f2, d2, v2, z2) {
+                for (var x2 = 0; x2 < width; x2++) {
+                  for (var y2 = 0; y2 < height; y2++) {
+                    f2[y2] = data[y2 * width + x2];
+                  }
+                  edt1d(f2, d2, v2, z2, height);
+                  for (y2 = 0; y2 < height; y2++) {
+                    data[y2 * width + x2] = d2[y2];
+                  }
+                }
+                for (y2 = 0; y2 < height; y2++) {
+                  for (x2 = 0; x2 < width; x2++) {
+                    f2[x2] = data[y2 * width + x2];
+                  }
+                  edt1d(f2, d2, v2, z2, width);
+                  for (x2 = 0; x2 < width; x2++) {
+                    data[y2 * width + x2] = Math.sqrt(d2[x2]);
+                  }
+                }
+              }
+              function edt1d(f2, d2, v2, z2, n2) {
+                v2[0] = 0;
+                z2[0] = -1e20;
+                z2[1] = 1e20;
+                for (var q2 = 1, k2 = 0; q2 < n2; q2++) {
+                  var s2 = (f2[q2] + q2 * q2 - (f2[v2[k2]] + v2[k2] * v2[k2])) / (2 * q2 - 2 * v2[k2]);
+                  while (s2 <= z2[k2]) {
+                    k2--;
+                    s2 = (f2[q2] + q2 * q2 - (f2[v2[k2]] + v2[k2] * v2[k2])) / (2 * q2 - 2 * v2[k2]);
+                  }
+                  k2++;
+                  v2[k2] = q2;
+                  z2[k2] = s2;
+                  z2[k2 + 1] = 1e20;
+                }
+                for (q2 = 0, k2 = 0; q2 < n2; q2++) {
+                  while (z2[k2 + 1] < q2) {
+                    k2++;
+                  }
+                  d2[q2] = (q2 - v2[k2]) * (q2 - v2[k2]) + f2[v2[k2]];
+                }
+              }
+              tinySdf.default = default_1;
+              var GlyphManager = function GlyphManager2(requestManager, localIdeographFontFamily) {
+                this.requestManager = requestManager;
+                this.localIdeographFontFamily = localIdeographFontFamily;
+                this.entries = {};
+              };
+              GlyphManager.prototype.setURL = function setURL(url) {
+                this.url = url;
+              };
+              GlyphManager.prototype.getGlyphs = function getGlyphs(glyphs, callback) {
+                var this$1$1 = this;
+                var all = [];
+                for (var stack in glyphs) {
+                  for (var i2 = 0, list = glyphs[stack]; i2 < list.length; i2 += 1) {
+                    var id2 = list[i2];
+                    all.push({
+                      stack,
+                      id: id2
+                    });
+                  }
+                }
+                performance2.asyncAll(all, function(ref, callback2) {
+                  var stack2 = ref.stack;
+                  var id22 = ref.id;
+                  var entry = this$1$1.entries[stack2];
+                  if (!entry) {
+                    entry = this$1$1.entries[stack2] = {
+                      glyphs: {},
+                      requests: {},
+                      ranges: {}
+                    };
+                  }
+                  var glyph = entry.glyphs[id22];
+                  if (glyph !== void 0) {
+                    callback2(null, {
+                      stack: stack2,
+                      id: id22,
+                      glyph
+                    });
+                    return;
+                  }
+                  glyph = this$1$1._tinySDF(entry, stack2, id22);
+                  if (glyph) {
+                    entry.glyphs[id22] = glyph;
+                    callback2(null, {
+                      stack: stack2,
+                      id: id22,
+                      glyph
+                    });
+                    return;
+                  }
+                  var range = Math.floor(id22 / 256);
+                  if (range * 256 > 65535) {
+                    callback2(new Error("glyphs > 65535 not supported"));
+                    return;
+                  }
+                  if (entry.ranges[range]) {
+                    callback2(null, {
+                      stack: stack2,
+                      id: id22,
+                      glyph
+                    });
+                    return;
+                  }
+                  var requests = entry.requests[range];
+                  if (!requests) {
+                    requests = entry.requests[range] = [];
+                    GlyphManager.loadGlyphRange(stack2, range, this$1$1.url, this$1$1.requestManager, function(err, response) {
+                      if (response) {
+                        for (var id3 in response) {
+                          if (!this$1$1._doesCharSupportLocalGlyph(+id3)) {
+                            entry.glyphs[+id3] = response[+id3];
+                          }
+                        }
+                        entry.ranges[range] = true;
+                      }
+                      for (var i22 = 0, list2 = requests; i22 < list2.length; i22 += 1) {
+                        var cb2 = list2[i22];
+                        cb2(err, response);
+                      }
+                      delete entry.requests[range];
+                    });
+                  }
+                  requests.push(function(err, result) {
+                    if (err) {
+                      callback2(err);
+                    } else if (result) {
+                      callback2(null, {
+                        stack: stack2,
+                        id: id22,
+                        glyph: result[id22] || null
+                      });
+                    }
+                  });
+                }, function(err, glyphs2) {
+                  if (err) {
+                    callback(err);
+                  } else if (glyphs2) {
+                    var result = {};
+                    for (var i22 = 0, list2 = glyphs2; i22 < list2.length; i22 += 1) {
+                      var ref = list2[i22];
+                      var stack2 = ref.stack;
+                      var id22 = ref.id;
+                      var glyph = ref.glyph;
+                      (result[stack2] || (result[stack2] = {}))[id22] = glyph && {
+                        id: glyph.id,
+                        bitmap: glyph.bitmap.clone(),
+                        metrics: glyph.metrics
+                      };
+                    }
+                    callback(null, result);
+                  }
+                });
+              };
+              GlyphManager.prototype._doesCharSupportLocalGlyph = function _doesCharSupportLocalGlyph(id2) {
+                return !!this.localIdeographFontFamily && (performance2.isChar["CJK Unified Ideographs"](id2) || performance2.isChar["Hangul Syllables"](id2) || performance2.isChar["Hiragana"](id2) || performance2.isChar["Katakana"](id2));
+              };
+              GlyphManager.prototype._tinySDF = function _tinySDF(entry, stack, id2) {
+                var family = this.localIdeographFontFamily;
+                if (!family) {
+                  return;
+                }
+                if (!this._doesCharSupportLocalGlyph(id2)) {
+                  return;
+                }
+                var tinySDF = entry.tinySDF;
+                if (!tinySDF) {
+                  var fontWeight = "400";
+                  if (/bold/i.test(stack)) {
+                    fontWeight = "900";
+                  } else if (/medium/i.test(stack)) {
+                    fontWeight = "500";
+                  } else if (/light/i.test(stack)) {
+                    fontWeight = "200";
+                  }
+                  tinySDF = entry.tinySDF = new GlyphManager.TinySDF(24, 3, 8, 0.25, family, fontWeight);
+                }
+                return {
+                  id: id2,
+                  bitmap: new performance2.AlphaImage({
+                    width: 30,
+                    height: 30
+                  }, tinySDF.draw(String.fromCharCode(id2))),
+                  metrics: {
+                    width: 24,
+                    height: 24,
+                    left: 0,
+                    top: -8,
+                    advance: 24
+                  }
+                };
+              };
+              GlyphManager.loadGlyphRange = loadGlyphRange;
+              GlyphManager.TinySDF = tinySdf;
+              var LightPositionProperty = function LightPositionProperty2() {
+                this.specification = performance2.styleSpec.light.position;
+              };
+              LightPositionProperty.prototype.possiblyEvaluate = function possiblyEvaluate(value, parameters) {
+                return performance2.sphericalToCartesian(value.expression.evaluate(parameters));
+              };
+              LightPositionProperty.prototype.interpolate = function interpolate$1(a2, b2, t4) {
+                return {
+                  x: performance2.number(a2.x, b2.x, t4),
+                  y: performance2.number(a2.y, b2.y, t4),
+                  z: performance2.number(a2.z, b2.z, t4)
+                };
+              };
+              var properties = new performance2.Properties({
+                "anchor": new performance2.DataConstantProperty(performance2.styleSpec.light.anchor),
+                "position": new LightPositionProperty(),
+                "color": new performance2.DataConstantProperty(performance2.styleSpec.light.color),
+                "intensity": new performance2.DataConstantProperty(performance2.styleSpec.light.intensity)
+              });
+              var TRANSITION_SUFFIX = "-transition";
+              var Light = function(Evented) {
+                function Light2(lightOptions) {
+                  Evented.call(this);
+                  this._transitionable = new performance2.Transitionable(properties);
+                  this.setLight(lightOptions);
+                  this._transitioning = this._transitionable.untransitioned();
+                }
+                if (Evented)
+                  Light2.__proto__ = Evented;
+                Light2.prototype = Object.create(Evented && Evented.prototype);
+                Light2.prototype.constructor = Light2;
+                Light2.prototype.getLight = function getLight() {
+                  return this._transitionable.serialize();
+                };
+                Light2.prototype.setLight = function setLight(light, options) {
+                  if (options === void 0)
+                    options = {};
+                  if (this._validate(performance2.validateLight, light, options)) {
+                    return;
+                  }
+                  for (var name2 in light) {
+                    var value = light[name2];
+                    if (performance2.endsWith(name2, TRANSITION_SUFFIX)) {
+                      this._transitionable.setTransition(name2.slice(0, -TRANSITION_SUFFIX.length), value);
+                    } else {
+                      this._transitionable.setValue(name2, value);
+                    }
+                  }
+                };
+                Light2.prototype.updateTransitions = function updateTransitions(parameters) {
+                  this._transitioning = this._transitionable.transitioned(parameters, this._transitioning);
+                };
+                Light2.prototype.hasTransition = function hasTransition() {
+                  return this._transitioning.hasTransition();
+                };
+                Light2.prototype.recalculate = function recalculate(parameters) {
+                  this.properties = this._transitioning.possiblyEvaluate(parameters);
+                };
+                Light2.prototype._validate = function _validate(validate, value, options) {
+                  if (options && options.validate === false) {
+                    return false;
+                  }
+                  return performance2.emitValidationErrors(this, validate.call(performance2.validateStyle, performance2.extend({
+                    value,
+                    style: {
+                      glyphs: true,
+                      sprite: true
+                    },
+                    styleSpec: performance2.styleSpec
+                  })));
+                };
+                return Light2;
+              }(performance2.Evented);
+              var LineAtlas = function LineAtlas2(width, height) {
+                this.width = width;
+                this.height = height;
+                this.nextRow = 0;
+                this.data = new Uint8Array(this.width * this.height);
+                this.dashEntry = {};
+              };
+              LineAtlas.prototype.getDash = function getDash(dasharray, round2) {
+                var key = dasharray.join(",") + String(round2);
+                if (!this.dashEntry[key]) {
+                  this.dashEntry[key] = this.addDash(dasharray, round2);
+                }
+                return this.dashEntry[key];
+              };
+              LineAtlas.prototype.getDashRanges = function getDashRanges(dasharray, lineAtlasWidth, stretch) {
+                var oddDashArray = dasharray.length % 2 === 1;
+                var ranges = [];
+                var left = oddDashArray ? -dasharray[dasharray.length - 1] * stretch : 0;
+                var right = dasharray[0] * stretch;
+                var isDash = true;
+                ranges.push({
+                  left,
+                  right,
+                  isDash,
+                  zeroLength: dasharray[0] === 0
+                });
+                var currentDashLength = dasharray[0];
+                for (var i2 = 1; i2 < dasharray.length; i2++) {
+                  isDash = !isDash;
+                  var dashLength = dasharray[i2];
+                  left = currentDashLength * stretch;
+                  currentDashLength += dashLength;
+                  right = currentDashLength * stretch;
+                  ranges.push({
+                    left,
+                    right,
+                    isDash,
+                    zeroLength: dashLength === 0
+                  });
+                }
+                return ranges;
+              };
+              LineAtlas.prototype.addRoundDash = function addRoundDash(ranges, stretch, n2) {
+                var halfStretch = stretch / 2;
+                for (var y2 = -n2; y2 <= n2; y2++) {
+                  var row = this.nextRow + n2 + y2;
+                  var index = this.width * row;
+                  var currIndex = 0;
+                  var range = ranges[currIndex];
+                  for (var x2 = 0; x2 < this.width; x2++) {
+                    if (x2 / range.right > 1) {
+                      range = ranges[++currIndex];
+                    }
+                    var distLeft = Math.abs(x2 - range.left);
+                    var distRight = Math.abs(x2 - range.right);
+                    var minDist = Math.min(distLeft, distRight);
+                    var signedDistance = void 0;
+                    var distMiddle = y2 / n2 * (halfStretch + 1);
+                    if (range.isDash) {
+                      var distEdge = halfStretch - Math.abs(distMiddle);
+                      signedDistance = Math.sqrt(minDist * minDist + distEdge * distEdge);
+                    } else {
+                      signedDistance = halfStretch - Math.sqrt(minDist * minDist + distMiddle * distMiddle);
+                    }
+                    this.data[index + x2] = Math.max(0, Math.min(255, signedDistance + 128));
+                  }
+                }
+              };
+              LineAtlas.prototype.addRegularDash = function addRegularDash(ranges) {
+                for (var i2 = ranges.length - 1; i2 >= 0; --i2) {
+                  var part = ranges[i2];
+                  var next = ranges[i2 + 1];
+                  if (part.zeroLength) {
+                    ranges.splice(i2, 1);
+                  } else if (next && next.isDash === part.isDash) {
+                    next.left = part.left;
+                    ranges.splice(i2, 1);
+                  }
+                }
+                var first = ranges[0];
+                var last = ranges[ranges.length - 1];
+                if (first.isDash === last.isDash) {
+                  first.left = last.left - this.width;
+                  last.right = first.right + this.width;
+                }
+                var index = this.width * this.nextRow;
+                var currIndex = 0;
+                var range = ranges[currIndex];
+                for (var x2 = 0; x2 < this.width; x2++) {
+                  if (x2 / range.right > 1) {
+                    range = ranges[++currIndex];
+                  }
+                  var distLeft = Math.abs(x2 - range.left);
+                  var distRight = Math.abs(x2 - range.right);
+                  var minDist = Math.min(distLeft, distRight);
+                  var signedDistance = range.isDash ? minDist : -minDist;
+                  this.data[index + x2] = Math.max(0, Math.min(255, signedDistance + 128));
+                }
+              };
+              LineAtlas.prototype.addDash = function addDash(dasharray, round2) {
+                var n2 = round2 ? 7 : 0;
+                var height = 2 * n2 + 1;
+                if (this.nextRow + height > this.height) {
+                  performance2.warnOnce("LineAtlas out of space");
+                  return null;
+                }
+                var length2 = 0;
+                for (var i2 = 0; i2 < dasharray.length; i2++) {
+                  length2 += dasharray[i2];
+                }
+                if (length2 !== 0) {
+                  var stretch = this.width / length2;
+                  var ranges = this.getDashRanges(dasharray, this.width, stretch);
+                  if (round2) {
+                    this.addRoundDash(ranges, stretch, n2);
+                  } else {
+                    this.addRegularDash(ranges);
+                  }
+                }
+                var dashEntry = {
+                  y: (this.nextRow + n2 + 0.5) / this.height,
+                  height: 2 * n2 / this.height,
+                  width: length2
+                };
+                this.nextRow += height;
+                this.dirty = true;
+                return dashEntry;
+              };
+              LineAtlas.prototype.bind = function bind(context) {
+                var gl2 = context.gl;
+                if (!this.texture) {
+                  this.texture = gl2.createTexture();
+                  gl2.bindTexture(gl2.TEXTURE_2D, this.texture);
+                  gl2.texParameteri(gl2.TEXTURE_2D, gl2.TEXTURE_WRAP_S, gl2.REPEAT);
+                  gl2.texParameteri(gl2.TEXTURE_2D, gl2.TEXTURE_WRAP_T, gl2.REPEAT);
+                  gl2.texParameteri(gl2.TEXTURE_2D, gl2.TEXTURE_MIN_FILTER, gl2.LINEAR);
+                  gl2.texParameteri(gl2.TEXTURE_2D, gl2.TEXTURE_MAG_FILTER, gl2.LINEAR);
+                  gl2.texImage2D(gl2.TEXTURE_2D, 0, gl2.ALPHA, this.width, this.height, 0, gl2.ALPHA, gl2.UNSIGNED_BYTE, this.data);
+                } else {
+                  gl2.bindTexture(gl2.TEXTURE_2D, this.texture);
+                  if (this.dirty) {
+                    this.dirty = false;
+                    gl2.texSubImage2D(gl2.TEXTURE_2D, 0, 0, 0, this.width, this.height, gl2.ALPHA, gl2.UNSIGNED_BYTE, this.data);
+                  }
+                }
+              };
+              var Dispatcher = function Dispatcher2(workerPool, parent) {
+                this.workerPool = workerPool;
+                this.actors = [];
+                this.currentActor = 0;
+                this.id = performance2.uniqueId();
+                var workers = this.workerPool.acquire(this.id);
+                for (var i2 = 0; i2 < workers.length; i2++) {
+                  var worker2 = workers[i2];
+                  var actor = new Dispatcher2.Actor(worker2, parent, this.id);
+                  actor.name = "Worker " + i2;
+                  this.actors.push(actor);
+                }
+              };
+              Dispatcher.prototype.broadcast = function broadcast(type, data, cb2) {
+                cb2 = cb2 || function() {
+                };
+                performance2.asyncAll(this.actors, function(actor, done) {
+                  actor.send(type, data, done);
+                }, cb2);
+              };
+              Dispatcher.prototype.getActor = function getActor() {
+                this.currentActor = (this.currentActor + 1) % this.actors.length;
+                return this.actors[this.currentActor];
+              };
+              Dispatcher.prototype.remove = function remove() {
+                this.actors.forEach(function(actor) {
+                  actor.remove();
+                });
+                this.actors = [];
+                this.workerPool.release(this.id);
+              };
+              Dispatcher.Actor = performance2.Actor;
+              function loadTileJSON(options, requestManager, callback) {
+                var loaded = function(err, tileJSON) {
+                  if (err) {
+                    return callback(err);
+                  } else if (tileJSON) {
+                    var result = performance2.pick(performance2.extend(tileJSON, options), [
+                      "tiles",
+                      "minzoom",
+                      "maxzoom",
+                      "attribution",
+                      "mapbox_logo",
+                      "bounds",
+                      "scheme",
+                      "tileSize",
+                      "encoding"
+                    ]);
+                    if (tileJSON.vector_layers) {
+                      result.vectorLayers = tileJSON.vector_layers;
+                      result.vectorLayerIds = result.vectorLayers.map(function(layer) {
+                        return layer.id;
+                      });
+                    }
+                    result.tiles = requestManager.canonicalizeTileset(result, options.url);
+                    callback(null, result);
+                  }
+                };
+                if (options.url) {
+                  return performance2.getJSON(requestManager.transformRequest(requestManager.normalizeSourceURL(options.url), performance2.ResourceType.Source), loaded);
+                } else {
+                  return performance2.browser.frame(function() {
+                    return loaded(null, options);
+                  });
+                }
+              }
+              var TileBounds = function TileBounds2(bounds, minzoom, maxzoom) {
+                this.bounds = performance2.LngLatBounds.convert(this.validateBounds(bounds));
+                this.minzoom = minzoom || 0;
+                this.maxzoom = maxzoom || 24;
+              };
+              TileBounds.prototype.validateBounds = function validateBounds(bounds) {
+                if (!Array.isArray(bounds) || bounds.length !== 4) {
+                  return [
+                    -180,
+                    -90,
+                    180,
+                    90
+                  ];
+                }
+                return [
+                  Math.max(-180, bounds[0]),
+                  Math.max(-90, bounds[1]),
+                  Math.min(180, bounds[2]),
+                  Math.min(90, bounds[3])
+                ];
+              };
+              TileBounds.prototype.contains = function contains(tileID) {
+                var worldSize = Math.pow(2, tileID.z);
+                var level = {
+                  minX: Math.floor(performance2.mercatorXfromLng(this.bounds.getWest()) * worldSize),
+                  minY: Math.floor(performance2.mercatorYfromLat(this.bounds.getNorth()) * worldSize),
+                  maxX: Math.ceil(performance2.mercatorXfromLng(this.bounds.getEast()) * worldSize),
+                  maxY: Math.ceil(performance2.mercatorYfromLat(this.bounds.getSouth()) * worldSize)
+                };
+                var hit = tileID.x >= level.minX && tileID.x < level.maxX && tileID.y >= level.minY && tileID.y < level.maxY;
+                return hit;
+              };
+              var VectorTileSource = function(Evented) {
+                function VectorTileSource2(id2, options, dispatcher, eventedParent) {
+                  Evented.call(this);
+                  this.id = id2;
+                  this.dispatcher = dispatcher;
+                  this.type = "vector";
+                  this.minzoom = 0;
+                  this.maxzoom = 22;
+                  this.scheme = "xyz";
+                  this.tileSize = 512;
+                  this.reparseOverscaled = true;
+                  this.isTileClipped = true;
+                  this._loaded = false;
+                  performance2.extend(this, performance2.pick(options, [
+                    "url",
+                    "scheme",
+                    "tileSize",
+                    "promoteId"
+                  ]));
+                  this._options = performance2.extend({ type: "vector" }, options);
+                  this._collectResourceTiming = options.collectResourceTiming;
+                  if (this.tileSize !== 512) {
+                    throw new Error("vector tile sources must have a tileSize of 512");
+                  }
+                  this.setEventedParent(eventedParent);
+                }
+                if (Evented)
+                  VectorTileSource2.__proto__ = Evented;
+                VectorTileSource2.prototype = Object.create(Evented && Evented.prototype);
+                VectorTileSource2.prototype.constructor = VectorTileSource2;
+                VectorTileSource2.prototype.load = function load2() {
+                  var this$1$1 = this;
+                  this._loaded = false;
+                  this.fire(new performance2.Event("dataloading", { dataType: "source" }));
+                  this._tileJSONRequest = loadTileJSON(this._options, this.map._requestManager, function(err, tileJSON) {
+                    this$1$1._tileJSONRequest = null;
+                    this$1$1._loaded = true;
+                    if (err) {
+                      this$1$1.fire(new performance2.ErrorEvent(err));
+                    } else if (tileJSON) {
+                      performance2.extend(this$1$1, tileJSON);
+                      if (tileJSON.bounds) {
+                        this$1$1.tileBounds = new TileBounds(tileJSON.bounds, this$1$1.minzoom, this$1$1.maxzoom);
+                      }
+                      performance2.postTurnstileEvent(tileJSON.tiles, this$1$1.map._requestManager._customAccessToken);
+                      performance2.postMapLoadEvent(tileJSON.tiles, this$1$1.map._getMapId(), this$1$1.map._requestManager._skuToken, this$1$1.map._requestManager._customAccessToken);
+                      this$1$1.fire(new performance2.Event("data", {
+                        dataType: "source",
+                        sourceDataType: "metadata"
+                      }));
+                      this$1$1.fire(new performance2.Event("data", {
+                        dataType: "source",
+                        sourceDataType: "content"
+                      }));
+                    }
+                  });
+                };
+                VectorTileSource2.prototype.loaded = function loaded() {
+                  return this._loaded;
+                };
+                VectorTileSource2.prototype.hasTile = function hasTile(tileID) {
+                  return !this.tileBounds || this.tileBounds.contains(tileID.canonical);
+                };
+                VectorTileSource2.prototype.onAdd = function onAdd(map2) {
+                  this.map = map2;
+                  this.load();
+                };
+                VectorTileSource2.prototype.setSourceProperty = function setSourceProperty(callback) {
+                  if (this._tileJSONRequest) {
+                    this._tileJSONRequest.cancel();
+                  }
+                  callback();
+                  var sourceCache = this.map.style.sourceCaches[this.id];
+                  sourceCache.clearTiles();
+                  this.load();
+                };
+                VectorTileSource2.prototype.setTiles = function setTiles(tiles) {
+                  var this$1$1 = this;
+                  this.setSourceProperty(function() {
+                    this$1$1._options.tiles = tiles;
+                  });
+                  return this;
+                };
+                VectorTileSource2.prototype.setUrl = function setUrl(url) {
+                  var this$1$1 = this;
+                  this.setSourceProperty(function() {
+                    this$1$1.url = url;
+                    this$1$1._options.url = url;
+                  });
+                  return this;
+                };
+                VectorTileSource2.prototype.onRemove = function onRemove() {
+                  if (this._tileJSONRequest) {
+                    this._tileJSONRequest.cancel();
+                    this._tileJSONRequest = null;
+                  }
+                };
+                VectorTileSource2.prototype.serialize = function serialize() {
+                  return performance2.extend({}, this._options);
+                };
+                VectorTileSource2.prototype.loadTile = function loadTile(tile, callback) {
+                  var url = this.map._requestManager.normalizeTileURL(tile.tileID.canonical.url(this.tiles, this.scheme));
+                  var params = {
+                    request: this.map._requestManager.transformRequest(url, performance2.ResourceType.Tile),
+                    uid: tile.uid,
+                    tileID: tile.tileID,
+                    zoom: tile.tileID.overscaledZ,
+                    tileSize: this.tileSize * tile.tileID.overscaleFactor(),
+                    type: this.type,
+                    source: this.id,
+                    pixelRatio: performance2.browser.devicePixelRatio,
+                    showCollisionBoxes: this.map.showCollisionBoxes,
+                    promoteId: this.promoteId
+                  };
+                  params.request.collectResourceTiming = this._collectResourceTiming;
+                  if (!tile.actor || tile.state === "expired") {
+                    tile.actor = this.dispatcher.getActor();
+                    tile.request = tile.actor.send("loadTile", params, done.bind(this));
+                  } else if (tile.state === "loading") {
+                    tile.reloadCallback = callback;
+                  } else {
+                    tile.request = tile.actor.send("reloadTile", params, done.bind(this));
+                  }
+                  function done(err, data) {
+                    delete tile.request;
+                    if (tile.aborted) {
+                      return callback(null);
+                    }
+                    if (err && err.status !== 404) {
+                      return callback(err);
+                    }
+                    if (data && data.resourceTiming) {
+                      tile.resourceTiming = data.resourceTiming;
+                    }
+                    if (this.map._refreshExpiredTiles && data) {
+                      tile.setExpiryData(data);
+                    }
+                    tile.loadVectorData(data, this.map.painter);
+                    performance2.cacheEntryPossiblyAdded(this.dispatcher);
+                    callback(null);
+                    if (tile.reloadCallback) {
+                      this.loadTile(tile, tile.reloadCallback);
+                      tile.reloadCallback = null;
+                    }
+                  }
+                };
+                VectorTileSource2.prototype.abortTile = function abortTile(tile) {
+                  if (tile.request) {
+                    tile.request.cancel();
+                    delete tile.request;
+                  }
+                  if (tile.actor) {
+                    tile.actor.send("abortTile", {
+                      uid: tile.uid,
+                      type: this.type,
+                      source: this.id
+                    }, void 0);
+                  }
+                };
+                VectorTileSource2.prototype.unloadTile = function unloadTile(tile) {
+                  tile.unloadVectorData();
+                  if (tile.actor) {
+                    tile.actor.send("removeTile", {
+                      uid: tile.uid,
+                      type: this.type,
+                      source: this.id
+                    }, void 0);
+                  }
+                };
+                VectorTileSource2.prototype.hasTransition = function hasTransition() {
+                  return false;
+                };
+                return VectorTileSource2;
+              }(performance2.Evented);
+              var RasterTileSource = function(Evented) {
+                function RasterTileSource2(id2, options, dispatcher, eventedParent) {
+                  Evented.call(this);
+                  this.id = id2;
+                  this.dispatcher = dispatcher;
+                  this.setEventedParent(eventedParent);
+                  this.type = "raster";
+                  this.minzoom = 0;
+                  this.maxzoom = 22;
+                  this.roundZoom = true;
+                  this.scheme = "xyz";
+                  this.tileSize = 512;
+                  this._loaded = false;
+                  this._options = performance2.extend({ type: "raster" }, options);
+                  performance2.extend(this, performance2.pick(options, [
+                    "url",
+                    "scheme",
+                    "tileSize"
+                  ]));
+                }
+                if (Evented)
+                  RasterTileSource2.__proto__ = Evented;
+                RasterTileSource2.prototype = Object.create(Evented && Evented.prototype);
+                RasterTileSource2.prototype.constructor = RasterTileSource2;
+                RasterTileSource2.prototype.load = function load2() {
+                  var this$1$1 = this;
+                  this._loaded = false;
+                  this.fire(new performance2.Event("dataloading", { dataType: "source" }));
+                  this._tileJSONRequest = loadTileJSON(this._options, this.map._requestManager, function(err, tileJSON) {
+                    this$1$1._tileJSONRequest = null;
+                    this$1$1._loaded = true;
+                    if (err) {
+                      this$1$1.fire(new performance2.ErrorEvent(err));
+                    } else if (tileJSON) {
+                      performance2.extend(this$1$1, tileJSON);
+                      if (tileJSON.bounds) {
+                        this$1$1.tileBounds = new TileBounds(tileJSON.bounds, this$1$1.minzoom, this$1$1.maxzoom);
+                      }
+                      performance2.postTurnstileEvent(tileJSON.tiles);
+                      performance2.postMapLoadEvent(tileJSON.tiles, this$1$1.map._getMapId(), this$1$1.map._requestManager._skuToken);
+                      this$1$1.fire(new performance2.Event("data", {
+                        dataType: "source",
+                        sourceDataType: "metadata"
+                      }));
+                      this$1$1.fire(new performance2.Event("data", {
+                        dataType: "source",
+                        sourceDataType: "content"
+                      }));
+                    }
+                  });
+                };
+                RasterTileSource2.prototype.loaded = function loaded() {
+                  return this._loaded;
+                };
+                RasterTileSource2.prototype.onAdd = function onAdd(map2) {
+                  this.map = map2;
+                  this.load();
+                };
+                RasterTileSource2.prototype.onRemove = function onRemove() {
+                  if (this._tileJSONRequest) {
+                    this._tileJSONRequest.cancel();
+                    this._tileJSONRequest = null;
+                  }
+                };
+                RasterTileSource2.prototype.serialize = function serialize() {
+                  return performance2.extend({}, this._options);
+                };
+                RasterTileSource2.prototype.hasTile = function hasTile(tileID) {
+                  return !this.tileBounds || this.tileBounds.contains(tileID.canonical);
+                };
+                RasterTileSource2.prototype.loadTile = function loadTile(tile, callback) {
+                  var this$1$1 = this;
+                  var url = this.map._requestManager.normalizeTileURL(tile.tileID.canonical.url(this.tiles, this.scheme), this.tileSize);
+                  tile.request = performance2.getImage(this.map._requestManager.transformRequest(url, performance2.ResourceType.Tile), function(err, img) {
+                    delete tile.request;
+                    if (tile.aborted) {
+                      tile.state = "unloaded";
+                      callback(null);
+                    } else if (err) {
+                      tile.state = "errored";
+                      callback(err);
+                    } else if (img) {
+                      if (this$1$1.map._refreshExpiredTiles) {
+                        tile.setExpiryData(img);
+                      }
+                      delete img.cacheControl;
+                      delete img.expires;
+                      var context = this$1$1.map.painter.context;
+                      var gl2 = context.gl;
+                      tile.texture = this$1$1.map.painter.getTileTexture(img.width);
+                      if (tile.texture) {
+                        tile.texture.update(img, { useMipmap: true });
+                      } else {
+                        tile.texture = new performance2.Texture(context, img, gl2.RGBA, { useMipmap: true });
+                        tile.texture.bind(gl2.LINEAR, gl2.CLAMP_TO_EDGE, gl2.LINEAR_MIPMAP_NEAREST);
+                        if (context.extTextureFilterAnisotropic) {
+                          gl2.texParameterf(gl2.TEXTURE_2D, context.extTextureFilterAnisotropic.TEXTURE_MAX_ANISOTROPY_EXT, context.extTextureFilterAnisotropicMax);
+                        }
+                      }
+                      tile.state = "loaded";
+                      performance2.cacheEntryPossiblyAdded(this$1$1.dispatcher);
+                      callback(null);
+                    }
+                  });
+                };
+                RasterTileSource2.prototype.abortTile = function abortTile(tile, callback) {
+                  if (tile.request) {
+                    tile.request.cancel();
+                    delete tile.request;
+                  }
+                  callback();
+                };
+                RasterTileSource2.prototype.unloadTile = function unloadTile(tile, callback) {
+                  if (tile.texture) {
+                    this.map.painter.saveTileTexture(tile.texture);
+                  }
+                  callback();
+                };
+                RasterTileSource2.prototype.hasTransition = function hasTransition() {
+                  return false;
+                };
+                return RasterTileSource2;
+              }(performance2.Evented);
+              var RasterDEMTileSource = function(RasterTileSource2) {
+                function RasterDEMTileSource2(id2, options, dispatcher, eventedParent) {
+                  RasterTileSource2.call(this, id2, options, dispatcher, eventedParent);
+                  this.type = "raster-dem";
+                  this.maxzoom = 22;
+                  this._options = performance2.extend({ type: "raster-dem" }, options);
+                  this.encoding = options.encoding || "mapbox";
+                }
+                if (RasterTileSource2)
+                  RasterDEMTileSource2.__proto__ = RasterTileSource2;
+                RasterDEMTileSource2.prototype = Object.create(RasterTileSource2 && RasterTileSource2.prototype);
+                RasterDEMTileSource2.prototype.constructor = RasterDEMTileSource2;
+                RasterDEMTileSource2.prototype.serialize = function serialize() {
+                  return {
+                    type: "raster-dem",
+                    url: this.url,
+                    tileSize: this.tileSize,
+                    tiles: this.tiles,
+                    bounds: this.bounds,
+                    encoding: this.encoding
+                  };
+                };
+                RasterDEMTileSource2.prototype.loadTile = function loadTile(tile, callback) {
+                  var url = this.map._requestManager.normalizeTileURL(tile.tileID.canonical.url(this.tiles, this.scheme), this.tileSize);
+                  tile.request = performance2.getImage(this.map._requestManager.transformRequest(url, performance2.ResourceType.Tile), imageLoaded.bind(this));
+                  tile.neighboringTiles = this._getNeighboringTiles(tile.tileID);
+                  function imageLoaded(err, img) {
+                    delete tile.request;
+                    if (tile.aborted) {
+                      tile.state = "unloaded";
+                      callback(null);
+                    } else if (err) {
+                      tile.state = "errored";
+                      callback(err);
+                    } else if (img) {
+                      if (this.map._refreshExpiredTiles) {
+                        tile.setExpiryData(img);
+                      }
+                      delete img.cacheControl;
+                      delete img.expires;
+                      var transfer = performance2.window.ImageBitmap && img instanceof performance2.window.ImageBitmap && performance2.offscreenCanvasSupported();
+                      var rawImageData = transfer ? img : performance2.browser.getImageData(img, 1);
+                      var params = {
+                        uid: tile.uid,
+                        coord: tile.tileID,
+                        source: this.id,
+                        rawImageData,
+                        encoding: this.encoding
+                      };
+                      if (!tile.actor || tile.state === "expired") {
+                        tile.actor = this.dispatcher.getActor();
+                        tile.actor.send("loadDEMTile", params, done.bind(this));
+                      }
+                    }
+                  }
+                  function done(err, dem) {
+                    if (err) {
+                      tile.state = "errored";
+                      callback(err);
+                    }
+                    if (dem) {
+                      tile.dem = dem;
+                      tile.needsHillshadePrepare = true;
+                      tile.state = "loaded";
+                      callback(null);
+                    }
+                  }
+                };
+                RasterDEMTileSource2.prototype._getNeighboringTiles = function _getNeighboringTiles(tileID) {
+                  var canonical = tileID.canonical;
+                  var dim = Math.pow(2, canonical.z);
+                  var px = (canonical.x - 1 + dim) % dim;
+                  var pxw = canonical.x === 0 ? tileID.wrap - 1 : tileID.wrap;
+                  var nx = (canonical.x + 1 + dim) % dim;
+                  var nxw = canonical.x + 1 === dim ? tileID.wrap + 1 : tileID.wrap;
+                  var neighboringTiles = {};
+                  neighboringTiles[new performance2.OverscaledTileID(tileID.overscaledZ, pxw, canonical.z, px, canonical.y).key] = { backfilled: false };
+                  neighboringTiles[new performance2.OverscaledTileID(tileID.overscaledZ, nxw, canonical.z, nx, canonical.y).key] = { backfilled: false };
+                  if (canonical.y > 0) {
+                    neighboringTiles[new performance2.OverscaledTileID(tileID.overscaledZ, pxw, canonical.z, px, canonical.y - 1).key] = { backfilled: false };
+                    neighboringTiles[new performance2.OverscaledTileID(tileID.overscaledZ, tileID.wrap, canonical.z, canonical.x, canonical.y - 1).key] = { backfilled: false };
+                    neighboringTiles[new performance2.OverscaledTileID(tileID.overscaledZ, nxw, canonical.z, nx, canonical.y - 1).key] = { backfilled: false };
+                  }
+                  if (canonical.y + 1 < dim) {
+                    neighboringTiles[new performance2.OverscaledTileID(tileID.overscaledZ, pxw, canonical.z, px, canonical.y + 1).key] = { backfilled: false };
+                    neighboringTiles[new performance2.OverscaledTileID(tileID.overscaledZ, tileID.wrap, canonical.z, canonical.x, canonical.y + 1).key] = { backfilled: false };
+                    neighboringTiles[new performance2.OverscaledTileID(tileID.overscaledZ, nxw, canonical.z, nx, canonical.y + 1).key] = { backfilled: false };
+                  }
+                  return neighboringTiles;
+                };
+                RasterDEMTileSource2.prototype.unloadTile = function unloadTile(tile) {
+                  if (tile.demTexture) {
+                    this.map.painter.saveTileTexture(tile.demTexture);
+                  }
+                  if (tile.fbo) {
+                    tile.fbo.destroy();
+                    delete tile.fbo;
+                  }
+                  if (tile.dem) {
+                    delete tile.dem;
+                  }
+                  delete tile.neighboringTiles;
+                  tile.state = "unloaded";
+                  if (tile.actor) {
+                    tile.actor.send("removeDEMTile", {
+                      uid: tile.uid,
+                      source: this.id
+                    });
+                  }
+                };
+                return RasterDEMTileSource2;
+              }(RasterTileSource);
+              var GeoJSONSource = function(Evented) {
+                function GeoJSONSource2(id2, options, dispatcher, eventedParent) {
+                  Evented.call(this);
+                  this.id = id2;
+                  this.type = "geojson";
+                  this.minzoom = 0;
+                  this.maxzoom = 18;
+                  this.tileSize = 512;
+                  this.isTileClipped = true;
+                  this.reparseOverscaled = true;
+                  this._removed = false;
+                  this._loaded = false;
+                  this.actor = dispatcher.getActor();
+                  this.setEventedParent(eventedParent);
+                  this._data = options.data;
+                  this._options = performance2.extend({}, options);
+                  this._collectResourceTiming = options.collectResourceTiming;
+                  this._resourceTiming = [];
+                  if (options.maxzoom !== void 0) {
+                    this.maxzoom = options.maxzoom;
+                  }
+                  if (options.type) {
+                    this.type = options.type;
+                  }
+                  if (options.attribution) {
+                    this.attribution = options.attribution;
+                  }
+                  this.promoteId = options.promoteId;
+                  var scale2 = performance2.EXTENT / this.tileSize;
+                  this.workerOptions = performance2.extend({
+                    source: this.id,
+                    cluster: options.cluster || false,
+                    geojsonVtOptions: {
+                      buffer: (options.buffer !== void 0 ? options.buffer : 128) * scale2,
+                      tolerance: (options.tolerance !== void 0 ? options.tolerance : 0.375) * scale2,
+                      extent: performance2.EXTENT,
+                      maxZoom: this.maxzoom,
+                      lineMetrics: options.lineMetrics || false,
+                      generateId: options.generateId || false
+                    },
+                    superclusterOptions: {
+                      maxZoom: options.clusterMaxZoom !== void 0 ? Math.min(options.clusterMaxZoom, this.maxzoom - 1) : this.maxzoom - 1,
+                      minPoints: Math.max(2, options.clusterMinPoints || 2),
+                      extent: performance2.EXTENT,
+                      radius: (options.clusterRadius || 50) * scale2,
+                      log: false,
+                      generateId: options.generateId || false
+                    },
+                    clusterProperties: options.clusterProperties,
+                    filter: options.filter
+                  }, options.workerOptions);
+                }
+                if (Evented)
+                  GeoJSONSource2.__proto__ = Evented;
+                GeoJSONSource2.prototype = Object.create(Evented && Evented.prototype);
+                GeoJSONSource2.prototype.constructor = GeoJSONSource2;
+                GeoJSONSource2.prototype.load = function load2() {
+                  var this$1$1 = this;
+                  this.fire(new performance2.Event("dataloading", { dataType: "source" }));
+                  this._updateWorkerData(function(err) {
+                    if (err) {
+                      this$1$1.fire(new performance2.ErrorEvent(err));
+                      return;
+                    }
+                    var data = {
+                      dataType: "source",
+                      sourceDataType: "metadata"
+                    };
+                    if (this$1$1._collectResourceTiming && this$1$1._resourceTiming && this$1$1._resourceTiming.length > 0) {
+                      data.resourceTiming = this$1$1._resourceTiming;
+                      this$1$1._resourceTiming = [];
+                    }
+                    this$1$1.fire(new performance2.Event("data", data));
+                  });
+                };
+                GeoJSONSource2.prototype.onAdd = function onAdd(map2) {
+                  this.map = map2;
+                  this.load();
+                };
+                GeoJSONSource2.prototype.setData = function setData(data) {
+                  var this$1$1 = this;
+                  this._data = data;
+                  this.fire(new performance2.Event("dataloading", { dataType: "source" }));
+                  this._updateWorkerData(function(err) {
+                    if (err) {
+                      this$1$1.fire(new performance2.ErrorEvent(err));
+                      return;
+                    }
+                    var data2 = {
+                      dataType: "source",
+                      sourceDataType: "content"
+                    };
+                    if (this$1$1._collectResourceTiming && this$1$1._resourceTiming && this$1$1._resourceTiming.length > 0) {
+                      data2.resourceTiming = this$1$1._resourceTiming;
+                      this$1$1._resourceTiming = [];
+                    }
+                    this$1$1.fire(new performance2.Event("data", data2));
+                  });
+                  return this;
+                };
+                GeoJSONSource2.prototype.getClusterExpansionZoom = function getClusterExpansionZoom(clusterId, callback) {
+                  this.actor.send("geojson.getClusterExpansionZoom", {
+                    clusterId,
+                    source: this.id
+                  }, callback);
+                  return this;
+                };
+                GeoJSONSource2.prototype.getClusterChildren = function getClusterChildren(clusterId, callback) {
+                  this.actor.send("geojson.getClusterChildren", {
+                    clusterId,
+                    source: this.id
+                  }, callback);
+                  return this;
+                };
+                GeoJSONSource2.prototype.getClusterLeaves = function getClusterLeaves(clusterId, limit, offset, callback) {
+                  this.actor.send("geojson.getClusterLeaves", {
+                    source: this.id,
+                    clusterId,
+                    limit,
+                    offset
+                  }, callback);
+                  return this;
+                };
+                GeoJSONSource2.prototype._updateWorkerData = function _updateWorkerData(callback) {
+                  var this$1$1 = this;
+                  this._loaded = false;
+                  var options = performance2.extend({}, this.workerOptions);
+                  var data = this._data;
+                  if (typeof data === "string") {
+                    options.request = this.map._requestManager.transformRequest(performance2.browser.resolveURL(data), performance2.ResourceType.Source);
+                    options.request.collectResourceTiming = this._collectResourceTiming;
+                  } else {
+                    options.data = JSON.stringify(data);
+                  }
+                  this.actor.send(this.type + ".loadData", options, function(err, result) {
+                    if (this$1$1._removed || result && result.abandoned) {
+                      return;
+                    }
+                    this$1$1._loaded = true;
+                    if (result && result.resourceTiming && result.resourceTiming[this$1$1.id]) {
+                      this$1$1._resourceTiming = result.resourceTiming[this$1$1.id].slice(0);
+                    }
+                    this$1$1.actor.send(this$1$1.type + ".coalesce", { source: options.source }, null);
+                    callback(err);
+                  });
+                };
+                GeoJSONSource2.prototype.loaded = function loaded() {
+                  return this._loaded;
+                };
+                GeoJSONSource2.prototype.loadTile = function loadTile(tile, callback) {
+                  var this$1$1 = this;
+                  var message2 = !tile.actor ? "loadTile" : "reloadTile";
+                  tile.actor = this.actor;
+                  var params = {
+                    type: this.type,
+                    uid: tile.uid,
+                    tileID: tile.tileID,
+                    zoom: tile.tileID.overscaledZ,
+                    maxZoom: this.maxzoom,
+                    tileSize: this.tileSize,
+                    source: this.id,
+                    pixelRatio: performance2.browser.devicePixelRatio,
+                    showCollisionBoxes: this.map.showCollisionBoxes,
+                    promoteId: this.promoteId
+                  };
+                  tile.request = this.actor.send(message2, params, function(err, data) {
+                    delete tile.request;
+                    tile.unloadVectorData();
+                    if (tile.aborted) {
+                      return callback(null);
+                    }
+                    if (err) {
+                      return callback(err);
+                    }
+                    tile.loadVectorData(data, this$1$1.map.painter, message2 === "reloadTile");
+                    return callback(null);
+                  });
+                };
+                GeoJSONSource2.prototype.abortTile = function abortTile(tile) {
+                  if (tile.request) {
+                    tile.request.cancel();
+                    delete tile.request;
+                  }
+                  tile.aborted = true;
+                };
+                GeoJSONSource2.prototype.unloadTile = function unloadTile(tile) {
+                  tile.unloadVectorData();
+                  this.actor.send("removeTile", {
+                    uid: tile.uid,
+                    type: this.type,
+                    source: this.id
+                  });
+                };
+                GeoJSONSource2.prototype.onRemove = function onRemove() {
+                  this._removed = true;
+                  this.actor.send("removeSource", {
+                    type: this.type,
+                    source: this.id
+                  });
+                };
+                GeoJSONSource2.prototype.serialize = function serialize() {
+                  return performance2.extend({}, this._options, {
+                    type: this.type,
+                    data: this._data
+                  });
+                };
+                GeoJSONSource2.prototype.hasTransition = function hasTransition() {
+                  return false;
+                };
+                return GeoJSONSource2;
+              }(performance2.Evented);
+              var rasterBoundsAttributes = performance2.createLayout([
+                {
+                  name: "a_pos",
+                  type: "Int16",
+                  components: 2
+                },
+                {
+                  name: "a_texture_pos",
+                  type: "Int16",
+                  components: 2
+                }
+              ]);
+              var ImageSource = function(Evented) {
+                function ImageSource2(id2, options, dispatcher, eventedParent) {
+                  Evented.call(this);
+                  this.id = id2;
+                  this.dispatcher = dispatcher;
+                  this.coordinates = options.coordinates;
+                  this.type = "image";
+                  this.minzoom = 0;
+                  this.maxzoom = 22;
+                  this.tileSize = 512;
+                  this.tiles = {};
+                  this._loaded = false;
+                  this.setEventedParent(eventedParent);
+                  this.options = options;
+                }
+                if (Evented)
+                  ImageSource2.__proto__ = Evented;
+                ImageSource2.prototype = Object.create(Evented && Evented.prototype);
+                ImageSource2.prototype.constructor = ImageSource2;
+                ImageSource2.prototype.load = function load2(newCoordinates, successCallback) {
+                  var this$1$1 = this;
+                  this._loaded = false;
+                  this.fire(new performance2.Event("dataloading", { dataType: "source" }));
+                  this.url = this.options.url;
+                  performance2.getImage(this.map._requestManager.transformRequest(this.url, performance2.ResourceType.Image), function(err, image) {
+                    this$1$1._loaded = true;
+                    if (err) {
+                      this$1$1.fire(new performance2.ErrorEvent(err));
+                    } else if (image) {
+                      this$1$1.image = image;
+                      if (newCoordinates) {
+                        this$1$1.coordinates = newCoordinates;
+                      }
+                      if (successCallback) {
+                        successCallback();
+                      }
+                      this$1$1._finishLoading();
+                    }
+                  });
+                };
+                ImageSource2.prototype.loaded = function loaded() {
+                  return this._loaded;
+                };
+                ImageSource2.prototype.updateImage = function updateImage(options) {
+                  var this$1$1 = this;
+                  if (!this.image || !options.url) {
+                    return this;
+                  }
+                  this.options.url = options.url;
+                  this.load(options.coordinates, function() {
+                    this$1$1.texture = null;
+                  });
+                  return this;
+                };
+                ImageSource2.prototype._finishLoading = function _finishLoading() {
+                  if (this.map) {
+                    this.setCoordinates(this.coordinates);
+                    this.fire(new performance2.Event("data", {
+                      dataType: "source",
+                      sourceDataType: "metadata"
+                    }));
+                  }
+                };
+                ImageSource2.prototype.onAdd = function onAdd(map2) {
+                  this.map = map2;
+                  this.load();
+                };
+                ImageSource2.prototype.setCoordinates = function setCoordinates(coordinates) {
+                  var this$1$1 = this;
+                  this.coordinates = coordinates;
+                  var cornerCoords = coordinates.map(performance2.MercatorCoordinate.fromLngLat);
+                  this.tileID = getCoordinatesCenterTileID(cornerCoords);
+                  this.minzoom = this.maxzoom = this.tileID.z;
+                  var tileCoords = cornerCoords.map(function(coord) {
+                    return this$1$1.tileID.getTilePoint(coord)._round();
+                  });
+                  this._boundsArray = new performance2.StructArrayLayout4i8();
+                  this._boundsArray.emplaceBack(tileCoords[0].x, tileCoords[0].y, 0, 0);
+                  this._boundsArray.emplaceBack(tileCoords[1].x, tileCoords[1].y, performance2.EXTENT, 0);
+                  this._boundsArray.emplaceBack(tileCoords[3].x, tileCoords[3].y, 0, performance2.EXTENT);
+                  this._boundsArray.emplaceBack(tileCoords[2].x, tileCoords[2].y, performance2.EXTENT, performance2.EXTENT);
+                  if (this.boundsBuffer) {
+                    this.boundsBuffer.destroy();
+                    delete this.boundsBuffer;
+                  }
+                  this.fire(new performance2.Event("data", {
+                    dataType: "source",
+                    sourceDataType: "content"
+                  }));
+                  return this;
+                };
+                ImageSource2.prototype.prepare = function prepare() {
+                  if (Object.keys(this.tiles).length === 0 || !this.image) {
+                    return;
+                  }
+                  var context = this.map.painter.context;
+                  var gl2 = context.gl;
+                  if (!this.boundsBuffer) {
+                    this.boundsBuffer = context.createVertexBuffer(this._boundsArray, rasterBoundsAttributes.members);
+                  }
+                  if (!this.boundsSegments) {
+                    this.boundsSegments = performance2.SegmentVector.simpleSegment(0, 0, 4, 2);
+                  }
+                  if (!this.texture) {
+                    this.texture = new performance2.Texture(context, this.image, gl2.RGBA);
+                    this.texture.bind(gl2.LINEAR, gl2.CLAMP_TO_EDGE);
+                  }
+                  for (var w2 in this.tiles) {
+                    var tile = this.tiles[w2];
+                    if (tile.state !== "loaded") {
+                      tile.state = "loaded";
+                      tile.texture = this.texture;
+                    }
+                  }
+                };
+                ImageSource2.prototype.loadTile = function loadTile(tile, callback) {
+                  if (this.tileID && this.tileID.equals(tile.tileID.canonical)) {
+                    this.tiles[String(tile.tileID.wrap)] = tile;
+                    tile.buckets = {};
+                    callback(null);
+                  } else {
+                    tile.state = "errored";
+                    callback(null);
+                  }
+                };
+                ImageSource2.prototype.serialize = function serialize() {
+                  return {
+                    type: "image",
+                    url: this.options.url,
+                    coordinates: this.coordinates
+                  };
+                };
+                ImageSource2.prototype.hasTransition = function hasTransition() {
+                  return false;
+                };
+                return ImageSource2;
+              }(performance2.Evented);
+              function getCoordinatesCenterTileID(coords) {
+                var minX = Infinity;
+                var minY = Infinity;
+                var maxX = -Infinity;
+                var maxY = -Infinity;
+                for (var i2 = 0, list = coords; i2 < list.length; i2 += 1) {
+                  var coord = list[i2];
+                  minX = Math.min(minX, coord.x);
+                  minY = Math.min(minY, coord.y);
+                  maxX = Math.max(maxX, coord.x);
+                  maxY = Math.max(maxY, coord.y);
+                }
+                var dx = maxX - minX;
+                var dy = maxY - minY;
+                var dMax = Math.max(dx, dy);
+                var zoom = Math.max(0, Math.floor(-Math.log(dMax) / Math.LN2));
+                var tilesAtZoom = Math.pow(2, zoom);
+                return new performance2.CanonicalTileID(zoom, Math.floor((minX + maxX) / 2 * tilesAtZoom), Math.floor((minY + maxY) / 2 * tilesAtZoom));
+              }
+              var VideoSource = function(ImageSource2) {
+                function VideoSource2(id2, options, dispatcher, eventedParent) {
+                  ImageSource2.call(this, id2, options, dispatcher, eventedParent);
+                  this.roundZoom = true;
+                  this.type = "video";
+                  this.options = options;
+                }
+                if (ImageSource2)
+                  VideoSource2.__proto__ = ImageSource2;
+                VideoSource2.prototype = Object.create(ImageSource2 && ImageSource2.prototype);
+                VideoSource2.prototype.constructor = VideoSource2;
+                VideoSource2.prototype.load = function load2() {
+                  var this$1$1 = this;
+                  this._loaded = false;
+                  var options = this.options;
+                  this.urls = [];
+                  for (var i2 = 0, list = options.urls; i2 < list.length; i2 += 1) {
+                    var url = list[i2];
+                    this.urls.push(this.map._requestManager.transformRequest(url, performance2.ResourceType.Source).url);
+                  }
+                  performance2.getVideo(this.urls, function(err, video) {
+                    this$1$1._loaded = true;
+                    if (err) {
+                      this$1$1.fire(new performance2.ErrorEvent(err));
+                    } else if (video) {
+                      this$1$1.video = video;
+                      this$1$1.video.loop = true;
+                      this$1$1.video.addEventListener("playing", function() {
+                        this$1$1.map.triggerRepaint();
+                      });
+                      if (this$1$1.map) {
+                        this$1$1.video.play();
+                      }
+                      this$1$1._finishLoading();
+                    }
+                  });
+                };
+                VideoSource2.prototype.pause = function pause() {
+                  if (this.video) {
+                    this.video.pause();
+                  }
+                };
+                VideoSource2.prototype.play = function play() {
+                  if (this.video) {
+                    this.video.play();
+                  }
+                };
+                VideoSource2.prototype.seek = function seek(seconds) {
+                  if (this.video) {
+                    var seekableRange = this.video.seekable;
+                    if (seconds < seekableRange.start(0) || seconds > seekableRange.end(0)) {
+                      this.fire(new performance2.ErrorEvent(new performance2.ValidationError("sources." + this.id, null, "Playback for this video can be set only between the " + seekableRange.start(0) + " and " + seekableRange.end(0) + "-second mark.")));
+                    } else {
+                      this.video.currentTime = seconds;
+                    }
+                  }
+                };
+                VideoSource2.prototype.getVideo = function getVideo() {
+                  return this.video;
+                };
+                VideoSource2.prototype.onAdd = function onAdd(map2) {
+                  if (this.map) {
+                    return;
+                  }
+                  this.map = map2;
+                  this.load();
+                  if (this.video) {
+                    this.video.play();
+                    this.setCoordinates(this.coordinates);
+                  }
+                };
+                VideoSource2.prototype.prepare = function prepare() {
+                  if (Object.keys(this.tiles).length === 0 || this.video.readyState < 2) {
+                    return;
+                  }
+                  var context = this.map.painter.context;
+                  var gl2 = context.gl;
+                  if (!this.boundsBuffer) {
+                    this.boundsBuffer = context.createVertexBuffer(this._boundsArray, rasterBoundsAttributes.members);
+                  }
+                  if (!this.boundsSegments) {
+                    this.boundsSegments = performance2.SegmentVector.simpleSegment(0, 0, 4, 2);
+                  }
+                  if (!this.texture) {
+                    this.texture = new performance2.Texture(context, this.video, gl2.RGBA);
+                    this.texture.bind(gl2.LINEAR, gl2.CLAMP_TO_EDGE);
+                  } else if (!this.video.paused) {
+                    this.texture.bind(gl2.LINEAR, gl2.CLAMP_TO_EDGE);
+                    gl2.texSubImage2D(gl2.TEXTURE_2D, 0, 0, 0, gl2.RGBA, gl2.UNSIGNED_BYTE, this.video);
+                  }
+                  for (var w2 in this.tiles) {
+                    var tile = this.tiles[w2];
+                    if (tile.state !== "loaded") {
+                      tile.state = "loaded";
+                      tile.texture = this.texture;
+                    }
+                  }
+                };
+                VideoSource2.prototype.serialize = function serialize() {
+                  return {
+                    type: "video",
+                    urls: this.urls,
+                    coordinates: this.coordinates
+                  };
+                };
+                VideoSource2.prototype.hasTransition = function hasTransition() {
+                  return this.video && !this.video.paused;
+                };
+                return VideoSource2;
+              }(ImageSource);
+              var CanvasSource = function(ImageSource2) {
+                function CanvasSource2(id2, options, dispatcher, eventedParent) {
+                  ImageSource2.call(this, id2, options, dispatcher, eventedParent);
+                  if (!options.coordinates) {
+                    this.fire(new performance2.ErrorEvent(new performance2.ValidationError("sources." + id2, null, 'missing required property "coordinates"')));
+                  } else if (!Array.isArray(options.coordinates) || options.coordinates.length !== 4 || options.coordinates.some(function(c2) {
+                    return !Array.isArray(c2) || c2.length !== 2 || c2.some(function(l2) {
+                      return typeof l2 !== "number";
+                    });
+                  })) {
+                    this.fire(new performance2.ErrorEvent(new performance2.ValidationError("sources." + id2, null, '"coordinates" property must be an array of 4 longitude/latitude array pairs')));
+                  }
+                  if (options.animate && typeof options.animate !== "boolean") {
+                    this.fire(new performance2.ErrorEvent(new performance2.ValidationError("sources." + id2, null, 'optional "animate" property must be a boolean value')));
+                  }
+                  if (!options.canvas) {
+                    this.fire(new performance2.ErrorEvent(new performance2.ValidationError("sources." + id2, null, 'missing required property "canvas"')));
+                  } else if (typeof options.canvas !== "string" && !(options.canvas instanceof performance2.window.HTMLCanvasElement)) {
+                    this.fire(new performance2.ErrorEvent(new performance2.ValidationError("sources." + id2, null, '"canvas" must be either a string representing the ID of the canvas element from which to read, or an HTMLCanvasElement instance')));
+                  }
+                  this.options = options;
+                  this.animate = options.animate !== void 0 ? options.animate : true;
+                }
+                if (ImageSource2)
+                  CanvasSource2.__proto__ = ImageSource2;
+                CanvasSource2.prototype = Object.create(ImageSource2 && ImageSource2.prototype);
+                CanvasSource2.prototype.constructor = CanvasSource2;
+                CanvasSource2.prototype.load = function load2() {
+                  this._loaded = true;
+                  if (!this.canvas) {
+                    this.canvas = this.options.canvas instanceof performance2.window.HTMLCanvasElement ? this.options.canvas : performance2.window.document.getElementById(this.options.canvas);
+                  }
+                  this.width = this.canvas.width;
+                  this.height = this.canvas.height;
+                  if (this._hasInvalidDimensions()) {
+                    this.fire(new performance2.ErrorEvent(new Error("Canvas dimensions cannot be less than or equal to zero.")));
+                    return;
+                  }
+                  this.play = function() {
+                    this._playing = true;
+                    this.map.triggerRepaint();
+                  };
+                  this.pause = function() {
+                    if (this._playing) {
+                      this.prepare();
+                      this._playing = false;
+                    }
+                  };
+                  this._finishLoading();
+                };
+                CanvasSource2.prototype.getCanvas = function getCanvas() {
+                  return this.canvas;
+                };
+                CanvasSource2.prototype.onAdd = function onAdd(map2) {
+                  this.map = map2;
+                  this.load();
+                  if (this.canvas) {
+                    if (this.animate) {
+                      this.play();
+                    }
+                  }
+                };
+                CanvasSource2.prototype.onRemove = function onRemove() {
+                  this.pause();
+                };
+                CanvasSource2.prototype.prepare = function prepare() {
+                  var resize = false;
+                  if (this.canvas.width !== this.width) {
+                    this.width = this.canvas.width;
+                    resize = true;
+                  }
+                  if (this.canvas.height !== this.height) {
+                    this.height = this.canvas.height;
+                    resize = true;
+                  }
+                  if (this._hasInvalidDimensions()) {
+                    return;
+                  }
+                  if (Object.keys(this.tiles).length === 0) {
+                    return;
+                  }
+                  var context = this.map.painter.context;
+                  var gl2 = context.gl;
+                  if (!this.boundsBuffer) {
+                    this.boundsBuffer = context.createVertexBuffer(this._boundsArray, rasterBoundsAttributes.members);
+                  }
+                  if (!this.boundsSegments) {
+                    this.boundsSegments = performance2.SegmentVector.simpleSegment(0, 0, 4, 2);
+                  }
+                  if (!this.texture) {
+                    this.texture = new performance2.Texture(context, this.canvas, gl2.RGBA, { premultiply: true });
+                  } else if (resize || this._playing) {
+                    this.texture.update(this.canvas, { premultiply: true });
+                  }
+                  for (var w2 in this.tiles) {
+                    var tile = this.tiles[w2];
+                    if (tile.state !== "loaded") {
+                      tile.state = "loaded";
+                      tile.texture = this.texture;
+                    }
+                  }
+                };
+                CanvasSource2.prototype.serialize = function serialize() {
+                  return {
+                    type: "canvas",
+                    coordinates: this.coordinates
+                  };
+                };
+                CanvasSource2.prototype.hasTransition = function hasTransition() {
+                  return this._playing;
+                };
+                CanvasSource2.prototype._hasInvalidDimensions = function _hasInvalidDimensions() {
+                  for (var i2 = 0, list = [
+                    this.canvas.width,
+                    this.canvas.height
+                  ]; i2 < list.length; i2 += 1) {
+                    var x2 = list[i2];
+                    if (isNaN(x2) || x2 <= 0) {
+                      return true;
+                    }
+                  }
+                  return false;
+                };
+                return CanvasSource2;
+              }(ImageSource);
+              var sourceTypes = {
+                vector: VectorTileSource,
+                raster: RasterTileSource,
+                "raster-dem": RasterDEMTileSource,
+                geojson: GeoJSONSource,
+                video: VideoSource,
+                image: ImageSource,
+                canvas: CanvasSource
+              };
+              var create2 = function(id2, specification, dispatcher, eventedParent) {
+                var source2 = new sourceTypes[specification.type](id2, specification, dispatcher, eventedParent);
+                if (source2.id !== id2) {
+                  throw new Error("Expected Source id to be " + id2 + " instead of " + source2.id);
+                }
+                performance2.bindAll([
+                  "load",
+                  "abort",
+                  "unload",
+                  "serialize",
+                  "prepare"
+                ], source2);
+                return source2;
+              };
+              var getType2 = function(name2) {
+                return sourceTypes[name2];
+              };
+              var setType = function(name2, type) {
+                sourceTypes[name2] = type;
+              };
+              function getPixelPosMatrix(transform, tileID) {
+                var t4 = performance2.identity([]);
+                performance2.translate(t4, t4, [
+                  1,
+                  1,
+                  0
+                ]);
+                performance2.scale(t4, t4, [
+                  transform.width * 0.5,
+                  transform.height * 0.5,
+                  1
+                ]);
+                return performance2.multiply(t4, t4, transform.calculatePosMatrix(tileID.toUnwrapped()));
+              }
+              function queryIncludes3DLayer(layers, styleLayers, sourceID) {
+                if (layers) {
+                  for (var i2 = 0, list = layers; i2 < list.length; i2 += 1) {
+                    var layerID = list[i2];
+                    var layer = styleLayers[layerID];
+                    if (layer && layer.source === sourceID && layer.type === "fill-extrusion") {
+                      return true;
+                    }
+                  }
+                } else {
+                  for (var key in styleLayers) {
+                    var layer$1 = styleLayers[key];
+                    if (layer$1.source === sourceID && layer$1.type === "fill-extrusion") {
+                      return true;
+                    }
+                  }
+                }
+                return false;
+              }
+              function queryRenderedFeatures(sourceCache, styleLayers, serializedLayers, queryGeometry, params, transform) {
+                var has3DLayer = queryIncludes3DLayer(params && params.layers, styleLayers, sourceCache.id);
+                var maxPitchScaleFactor = transform.maxPitchScaleFactor();
+                var tilesIn = sourceCache.tilesIn(queryGeometry, maxPitchScaleFactor, has3DLayer);
+                tilesIn.sort(sortTilesIn);
+                var renderedFeatureLayers = [];
+                for (var i2 = 0, list = tilesIn; i2 < list.length; i2 += 1) {
+                  var tileIn = list[i2];
+                  renderedFeatureLayers.push({
+                    wrappedTileID: tileIn.tileID.wrapped().key,
+                    queryResults: tileIn.tile.queryRenderedFeatures(styleLayers, serializedLayers, sourceCache._state, tileIn.queryGeometry, tileIn.cameraQueryGeometry, tileIn.scale, params, transform, maxPitchScaleFactor, getPixelPosMatrix(sourceCache.transform, tileIn.tileID))
+                  });
+                }
+                var result = mergeRenderedFeatureLayers(renderedFeatureLayers);
+                for (var layerID in result) {
+                  result[layerID].forEach(function(featureWrapper) {
+                    var feature = featureWrapper.feature;
+                    var state = sourceCache.getFeatureState(feature.layer["source-layer"], feature.id);
+                    feature.source = feature.layer.source;
+                    if (feature.layer["source-layer"]) {
+                      feature.sourceLayer = feature.layer["source-layer"];
+                    }
+                    feature.state = state;
+                  });
+                }
+                return result;
+              }
+              function queryRenderedSymbols(styleLayers, serializedLayers, sourceCaches, queryGeometry, params, collisionIndex, retainedQueryData) {
+                var result = {};
+                var renderedSymbols = collisionIndex.queryRenderedSymbols(queryGeometry);
+                var bucketQueryData = [];
+                for (var i2 = 0, list = Object.keys(renderedSymbols).map(Number); i2 < list.length; i2 += 1) {
+                  var bucketInstanceId = list[i2];
+                  bucketQueryData.push(retainedQueryData[bucketInstanceId]);
+                }
+                bucketQueryData.sort(sortTilesIn);
+                var loop = function() {
+                  var queryData = list$2[i$2];
+                  var bucketSymbols = queryData.featureIndex.lookupSymbolFeatures(renderedSymbols[queryData.bucketInstanceId], serializedLayers, queryData.bucketIndex, queryData.sourceLayerIndex, params.filter, params.layers, params.availableImages, styleLayers);
+                  for (var layerID in bucketSymbols) {
+                    var resultFeatures = result[layerID] = result[layerID] || [];
+                    var layerSymbols = bucketSymbols[layerID];
+                    layerSymbols.sort(function(a2, b2) {
+                      var featureSortOrder = queryData.featureSortOrder;
+                      if (featureSortOrder) {
+                        var sortedA = featureSortOrder.indexOf(a2.featureIndex);
+                        var sortedB = featureSortOrder.indexOf(b2.featureIndex);
+                        return sortedB - sortedA;
+                      } else {
+                        return b2.featureIndex - a2.featureIndex;
+                      }
+                    });
+                    for (var i$1 = 0, list$1 = layerSymbols; i$1 < list$1.length; i$1 += 1) {
+                      var symbolFeature = list$1[i$1];
+                      resultFeatures.push(symbolFeature);
+                    }
+                  }
+                };
+                for (var i$2 = 0, list$2 = bucketQueryData; i$2 < list$2.length; i$2 += 1)
+                  loop();
+                var loop$1 = function(layerName2) {
+                  result[layerName2].forEach(function(featureWrapper) {
+                    var feature = featureWrapper.feature;
+                    var layer = styleLayers[layerName2];
+                    var sourceCache = sourceCaches[layer.source];
+                    var state = sourceCache.getFeatureState(feature.layer["source-layer"], feature.id);
+                    feature.source = feature.layer.source;
+                    if (feature.layer["source-layer"]) {
+                      feature.sourceLayer = feature.layer["source-layer"];
+                    }
+                    feature.state = state;
+                  });
+                };
+                for (var layerName in result)
+                  loop$1(layerName);
+                return result;
+              }
+              function querySourceFeatures(sourceCache, params) {
+                var tiles = sourceCache.getRenderableIds().map(function(id2) {
+                  return sourceCache.getTileByID(id2);
+                });
+                var result = [];
+                var dataTiles = {};
+                for (var i2 = 0; i2 < tiles.length; i2++) {
+                  var tile = tiles[i2];
+                  var dataID = tile.tileID.canonical.key;
+                  if (!dataTiles[dataID]) {
+                    dataTiles[dataID] = true;
+                    tile.querySourceFeatures(result, params);
+                  }
+                }
+                return result;
+              }
+              function sortTilesIn(a2, b2) {
+                var idA = a2.tileID;
+                var idB = b2.tileID;
+                return idA.overscaledZ - idB.overscaledZ || idA.canonical.y - idB.canonical.y || idA.wrap - idB.wrap || idA.canonical.x - idB.canonical.x;
+              }
+              function mergeRenderedFeatureLayers(tiles) {
+                var result = {};
+                var wrappedIDLayerMap = {};
+                for (var i$1 = 0, list$1 = tiles; i$1 < list$1.length; i$1 += 1) {
+                  var tile = list$1[i$1];
+                  var queryResults = tile.queryResults;
+                  var wrappedID = tile.wrappedTileID;
+                  var wrappedIDLayers = wrappedIDLayerMap[wrappedID] = wrappedIDLayerMap[wrappedID] || {};
+                  for (var layerID in queryResults) {
+                    var tileFeatures = queryResults[layerID];
+                    var wrappedIDFeatures = wrappedIDLayers[layerID] = wrappedIDLayers[layerID] || {};
+                    var resultFeatures = result[layerID] = result[layerID] || [];
+                    for (var i2 = 0, list = tileFeatures; i2 < list.length; i2 += 1) {
+                      var tileFeature = list[i2];
+                      if (!wrappedIDFeatures[tileFeature.featureIndex]) {
+                        wrappedIDFeatures[tileFeature.featureIndex] = true;
+                        resultFeatures.push(tileFeature);
+                      }
+                    }
+                  }
+                }
+                return result;
+              }
+              var TileCache = function TileCache2(max, onRemove) {
+                this.max = max;
+                this.onRemove = onRemove;
+                this.reset();
+              };
+              TileCache.prototype.reset = function reset() {
+                for (var key in this.data) {
+                  for (var i2 = 0, list = this.data[key]; i2 < list.length; i2 += 1) {
+                    var removedData = list[i2];
+                    if (removedData.timeout) {
+                      clearTimeout(removedData.timeout);
+                    }
+                    this.onRemove(removedData.value);
+                  }
+                }
+                this.data = {};
+                this.order = [];
+                return this;
+              };
+              TileCache.prototype.add = function add2(tileID, data, expiryTimeout) {
+                var this$1$1 = this;
+                var key = tileID.wrapped().key;
+                if (this.data[key] === void 0) {
+                  this.data[key] = [];
+                }
+                var dataWrapper = {
+                  value: data,
+                  timeout: void 0
+                };
+                if (expiryTimeout !== void 0) {
+                  dataWrapper.timeout = setTimeout(function() {
+                    this$1$1.remove(tileID, dataWrapper);
+                  }, expiryTimeout);
+                }
+                this.data[key].push(dataWrapper);
+                this.order.push(key);
+                if (this.order.length > this.max) {
+                  var removedData = this._getAndRemoveByKey(this.order[0]);
+                  if (removedData) {
+                    this.onRemove(removedData);
+                  }
+                }
+                return this;
+              };
+              TileCache.prototype.has = function has(tileID) {
+                return tileID.wrapped().key in this.data;
+              };
+              TileCache.prototype.getAndRemove = function getAndRemove(tileID) {
+                if (!this.has(tileID)) {
+                  return null;
+                }
+                return this._getAndRemoveByKey(tileID.wrapped().key);
+              };
+              TileCache.prototype._getAndRemoveByKey = function _getAndRemoveByKey(key) {
+                var data = this.data[key].shift();
+                if (data.timeout) {
+                  clearTimeout(data.timeout);
+                }
+                if (this.data[key].length === 0) {
+                  delete this.data[key];
+                }
+                this.order.splice(this.order.indexOf(key), 1);
+                return data.value;
+              };
+              TileCache.prototype.getByKey = function getByKey(key) {
+                var data = this.data[key];
+                return data ? data[0].value : null;
+              };
+              TileCache.prototype.get = function get(tileID) {
+                if (!this.has(tileID)) {
+                  return null;
+                }
+                var data = this.data[tileID.wrapped().key][0];
+                return data.value;
+              };
+              TileCache.prototype.remove = function remove(tileID, value) {
+                if (!this.has(tileID)) {
+                  return this;
+                }
+                var key = tileID.wrapped().key;
+                var dataIndex = value === void 0 ? 0 : this.data[key].indexOf(value);
+                var data = this.data[key][dataIndex];
+                this.data[key].splice(dataIndex, 1);
+                if (data.timeout) {
+                  clearTimeout(data.timeout);
+                }
+                if (this.data[key].length === 0) {
+                  delete this.data[key];
+                }
+                this.onRemove(data.value);
+                this.order.splice(this.order.indexOf(key), 1);
+                return this;
+              };
+              TileCache.prototype.setMaxSize = function setMaxSize(max) {
+                this.max = max;
+                while (this.order.length > this.max) {
+                  var removedData = this._getAndRemoveByKey(this.order[0]);
+                  if (removedData) {
+                    this.onRemove(removedData);
+                  }
+                }
+                return this;
+              };
+              TileCache.prototype.filter = function filter(filterFn) {
+                var removed = [];
+                for (var key in this.data) {
+                  for (var i2 = 0, list = this.data[key]; i2 < list.length; i2 += 1) {
+                    var entry = list[i2];
+                    if (!filterFn(entry.value)) {
+                      removed.push(entry);
+                    }
+                  }
+                }
+                for (var i$1 = 0, list$1 = removed; i$1 < list$1.length; i$1 += 1) {
+                  var r2 = list$1[i$1];
+                  this.remove(r2.value.tileID, r2);
+                }
+              };
+              var IndexBuffer = function IndexBuffer2(context, array, dynamicDraw) {
+                this.context = context;
+                var gl2 = context.gl;
+                this.buffer = gl2.createBuffer();
+                this.dynamicDraw = Boolean(dynamicDraw);
+                this.context.unbindVAO();
+                context.bindElementBuffer.set(this.buffer);
+                gl2.bufferData(gl2.ELEMENT_ARRAY_BUFFER, array.arrayBuffer, this.dynamicDraw ? gl2.DYNAMIC_DRAW : gl2.STATIC_DRAW);
+                if (!this.dynamicDraw) {
+                  delete array.arrayBuffer;
+                }
+              };
+              IndexBuffer.prototype.bind = function bind() {
+                this.context.bindElementBuffer.set(this.buffer);
+              };
+              IndexBuffer.prototype.updateData = function updateData(array) {
+                var gl2 = this.context.gl;
+                this.context.unbindVAO();
+                this.bind();
+                gl2.bufferSubData(gl2.ELEMENT_ARRAY_BUFFER, 0, array.arrayBuffer);
+              };
+              IndexBuffer.prototype.destroy = function destroy() {
+                var gl2 = this.context.gl;
+                if (this.buffer) {
+                  gl2.deleteBuffer(this.buffer);
+                  delete this.buffer;
+                }
+              };
+              var AttributeType = {
+                Int8: "BYTE",
+                Uint8: "UNSIGNED_BYTE",
+                Int16: "SHORT",
+                Uint16: "UNSIGNED_SHORT",
+                Int32: "INT",
+                Uint32: "UNSIGNED_INT",
+                Float32: "FLOAT"
+              };
+              var VertexBuffer = function VertexBuffer2(context, array, attributes, dynamicDraw) {
+                this.length = array.length;
+                this.attributes = attributes;
+                this.itemSize = array.bytesPerElement;
+                this.dynamicDraw = dynamicDraw;
+                this.context = context;
+                var gl2 = context.gl;
+                this.buffer = gl2.createBuffer();
+                context.bindVertexBuffer.set(this.buffer);
+                gl2.bufferData(gl2.ARRAY_BUFFER, array.arrayBuffer, this.dynamicDraw ? gl2.DYNAMIC_DRAW : gl2.STATIC_DRAW);
+                if (!this.dynamicDraw) {
+                  delete array.arrayBuffer;
+                }
+              };
+              VertexBuffer.prototype.bind = function bind() {
+                this.context.bindVertexBuffer.set(this.buffer);
+              };
+              VertexBuffer.prototype.updateData = function updateData(array) {
+                var gl2 = this.context.gl;
+                this.bind();
+                gl2.bufferSubData(gl2.ARRAY_BUFFER, 0, array.arrayBuffer);
+              };
+              VertexBuffer.prototype.enableAttributes = function enableAttributes(gl2, program) {
+                for (var j2 = 0; j2 < this.attributes.length; j2++) {
+                  var member = this.attributes[j2];
+                  var attribIndex = program.attributes[member.name];
+                  if (attribIndex !== void 0) {
+                    gl2.enableVertexAttribArray(attribIndex);
+                  }
+                }
+              };
+              VertexBuffer.prototype.setVertexAttribPointers = function setVertexAttribPointers(gl2, program, vertexOffset) {
+                for (var j2 = 0; j2 < this.attributes.length; j2++) {
+                  var member = this.attributes[j2];
+                  var attribIndex = program.attributes[member.name];
+                  if (attribIndex !== void 0) {
+                    gl2.vertexAttribPointer(attribIndex, member.components, gl2[AttributeType[member.type]], false, this.itemSize, member.offset + this.itemSize * (vertexOffset || 0));
+                  }
+                }
+              };
+              VertexBuffer.prototype.destroy = function destroy() {
+                var gl2 = this.context.gl;
+                if (this.buffer) {
+                  gl2.deleteBuffer(this.buffer);
+                  delete this.buffer;
+                }
+              };
+              var BaseValue = function BaseValue2(context) {
+                this.gl = context.gl;
+                this.default = this.getDefault();
+                this.current = this.default;
+                this.dirty = false;
+              };
+              BaseValue.prototype.get = function get() {
+                return this.current;
+              };
+              BaseValue.prototype.set = function set(value) {
+              };
+              BaseValue.prototype.getDefault = function getDefault() {
+                return this.default;
+              };
+              BaseValue.prototype.setDefault = function setDefault() {
+                this.set(this.default);
+              };
+              var ClearColor = function(BaseValue2) {
+                function ClearColor2() {
+                  BaseValue2.apply(this, arguments);
+                }
+                if (BaseValue2)
+                  ClearColor2.__proto__ = BaseValue2;
+                ClearColor2.prototype = Object.create(BaseValue2 && BaseValue2.prototype);
+                ClearColor2.prototype.constructor = ClearColor2;
+                ClearColor2.prototype.getDefault = function getDefault() {
+                  return performance2.Color.transparent;
+                };
+                ClearColor2.prototype.set = function set(v2) {
+                  var c2 = this.current;
+                  if (v2.r === c2.r && v2.g === c2.g && v2.b === c2.b && v2.a === c2.a && !this.dirty) {
+                    return;
+                  }
+                  this.gl.clearColor(v2.r, v2.g, v2.b, v2.a);
+                  this.current = v2;
+                  this.dirty = false;
+                };
+                return ClearColor2;
+              }(BaseValue);
+              var ClearDepth = function(BaseValue2) {
+                function ClearDepth2() {
+                  BaseValue2.apply(this, arguments);
+                }
+                if (BaseValue2)
+                  ClearDepth2.__proto__ = BaseValue2;
+                ClearDepth2.prototype = Object.create(BaseValue2 && BaseValue2.prototype);
+                ClearDepth2.prototype.constructor = ClearDepth2;
+                ClearDepth2.prototype.getDefault = function getDefault() {
+                  return 1;
+                };
+                ClearDepth2.prototype.set = function set(v2) {
+                  if (v2 === this.current && !this.dirty) {
+                    return;
+                  }
+                  this.gl.clearDepth(v2);
+                  this.current = v2;
+                  this.dirty = false;
+                };
+                return ClearDepth2;
+              }(BaseValue);
+              var ClearStencil = function(BaseValue2) {
+                function ClearStencil2() {
+                  BaseValue2.apply(this, arguments);
+                }
+                if (BaseValue2)
+                  ClearStencil2.__proto__ = BaseValue2;
+                ClearStencil2.prototype = Object.create(BaseValue2 && BaseValue2.prototype);
+                ClearStencil2.prototype.constructor = ClearStencil2;
+                ClearStencil2.prototype.getDefault = function getDefault() {
+                  return 0;
+                };
+                ClearStencil2.prototype.set = function set(v2) {
+                  if (v2 === this.current && !this.dirty) {
+                    return;
+                  }
+                  this.gl.clearStencil(v2);
+                  this.current = v2;
+                  this.dirty = false;
+                };
+                return ClearStencil2;
+              }(BaseValue);
+              var ColorMask = function(BaseValue2) {
+                function ColorMask2() {
+                  BaseValue2.apply(this, arguments);
+                }
+                if (BaseValue2)
+                  ColorMask2.__proto__ = BaseValue2;
+                ColorMask2.prototype = Object.create(BaseValue2 && BaseValue2.prototype);
+                ColorMask2.prototype.constructor = ColorMask2;
+                ColorMask2.prototype.getDefault = function getDefault() {
+                  return [
+                    true,
+                    true,
+                    true,
+                    true
+                  ];
+                };
+                ColorMask2.prototype.set = function set(v2) {
+                  var c2 = this.current;
+                  if (v2[0] === c2[0] && v2[1] === c2[1] && v2[2] === c2[2] && v2[3] === c2[3] && !this.dirty) {
+                    return;
+                  }
+                  this.gl.colorMask(v2[0], v2[1], v2[2], v2[3]);
+                  this.current = v2;
+                  this.dirty = false;
+                };
+                return ColorMask2;
+              }(BaseValue);
+              var DepthMask = function(BaseValue2) {
+                function DepthMask2() {
+                  BaseValue2.apply(this, arguments);
+                }
+                if (BaseValue2)
+                  DepthMask2.__proto__ = BaseValue2;
+                DepthMask2.prototype = Object.create(BaseValue2 && BaseValue2.prototype);
+                DepthMask2.prototype.constructor = DepthMask2;
+                DepthMask2.prototype.getDefault = function getDefault() {
+                  return true;
+                };
+                DepthMask2.prototype.set = function set(v2) {
+                  if (v2 === this.current && !this.dirty) {
+                    return;
+                  }
+                  this.gl.depthMask(v2);
+                  this.current = v2;
+                  this.dirty = false;
+                };
+                return DepthMask2;
+              }(BaseValue);
+              var StencilMask = function(BaseValue2) {
+                function StencilMask2() {
+                  BaseValue2.apply(this, arguments);
+                }
+                if (BaseValue2)
+                  StencilMask2.__proto__ = BaseValue2;
+                StencilMask2.prototype = Object.create(BaseValue2 && BaseValue2.prototype);
+                StencilMask2.prototype.constructor = StencilMask2;
+                StencilMask2.prototype.getDefault = function getDefault() {
+                  return 255;
+                };
+                StencilMask2.prototype.set = function set(v2) {
+                  if (v2 === this.current && !this.dirty) {
+                    return;
+                  }
+                  this.gl.stencilMask(v2);
+                  this.current = v2;
+                  this.dirty = false;
+                };
+                return StencilMask2;
+              }(BaseValue);
+              var StencilFunc = function(BaseValue2) {
+                function StencilFunc2() {
+                  BaseValue2.apply(this, arguments);
+                }
+                if (BaseValue2)
+                  StencilFunc2.__proto__ = BaseValue2;
+                StencilFunc2.prototype = Object.create(BaseValue2 && BaseValue2.prototype);
+                StencilFunc2.prototype.constructor = StencilFunc2;
+                StencilFunc2.prototype.getDefault = function getDefault() {
+                  return {
+                    func: this.gl.ALWAYS,
+                    ref: 0,
+                    mask: 255
+                  };
+                };
+                StencilFunc2.prototype.set = function set(v2) {
+                  var c2 = this.current;
+                  if (v2.func === c2.func && v2.ref === c2.ref && v2.mask === c2.mask && !this.dirty) {
+                    return;
+                  }
+                  this.gl.stencilFunc(v2.func, v2.ref, v2.mask);
+                  this.current = v2;
+                  this.dirty = false;
+                };
+                return StencilFunc2;
+              }(BaseValue);
+              var StencilOp = function(BaseValue2) {
+                function StencilOp2() {
+                  BaseValue2.apply(this, arguments);
+                }
+                if (BaseValue2)
+                  StencilOp2.__proto__ = BaseValue2;
+                StencilOp2.prototype = Object.create(BaseValue2 && BaseValue2.prototype);
+                StencilOp2.prototype.constructor = StencilOp2;
+                StencilOp2.prototype.getDefault = function getDefault() {
+                  var gl2 = this.gl;
+                  return [
+                    gl2.KEEP,
+                    gl2.KEEP,
+                    gl2.KEEP
+                  ];
+                };
+                StencilOp2.prototype.set = function set(v2) {
+                  var c2 = this.current;
+                  if (v2[0] === c2[0] && v2[1] === c2[1] && v2[2] === c2[2] && !this.dirty) {
+                    return;
+                  }
+                  this.gl.stencilOp(v2[0], v2[1], v2[2]);
+                  this.current = v2;
+                  this.dirty = false;
+                };
+                return StencilOp2;
+              }(BaseValue);
+              var StencilTest = function(BaseValue2) {
+                function StencilTest2() {
+                  BaseValue2.apply(this, arguments);
+                }
+                if (BaseValue2)
+                  StencilTest2.__proto__ = BaseValue2;
+                StencilTest2.prototype = Object.create(BaseValue2 && BaseValue2.prototype);
+                StencilTest2.prototype.constructor = StencilTest2;
+                StencilTest2.prototype.getDefault = function getDefault() {
+                  return false;
+                };
+                StencilTest2.prototype.set = function set(v2) {
+                  if (v2 === this.current && !this.dirty) {
+                    return;
+                  }
+                  var gl2 = this.gl;
+                  if (v2) {
+                    gl2.enable(gl2.STENCIL_TEST);
+                  } else {
+                    gl2.disable(gl2.STENCIL_TEST);
+                  }
+                  this.current = v2;
+                  this.dirty = false;
+                };
+                return StencilTest2;
+              }(BaseValue);
+              var DepthRange = function(BaseValue2) {
+                function DepthRange2() {
+                  BaseValue2.apply(this, arguments);
+                }
+                if (BaseValue2)
+                  DepthRange2.__proto__ = BaseValue2;
+                DepthRange2.prototype = Object.create(BaseValue2 && BaseValue2.prototype);
+                DepthRange2.prototype.constructor = DepthRange2;
+                DepthRange2.prototype.getDefault = function getDefault() {
+                  return [
+                    0,
+                    1
+                  ];
+                };
+                DepthRange2.prototype.set = function set(v2) {
+                  var c2 = this.current;
+                  if (v2[0] === c2[0] && v2[1] === c2[1] && !this.dirty) {
+                    return;
+                  }
+                  this.gl.depthRange(v2[0], v2[1]);
+                  this.current = v2;
+                  this.dirty = false;
+                };
+                return DepthRange2;
+              }(BaseValue);
+              var DepthTest = function(BaseValue2) {
+                function DepthTest2() {
+                  BaseValue2.apply(this, arguments);
+                }
+                if (BaseValue2)
+                  DepthTest2.__proto__ = BaseValue2;
+                DepthTest2.prototype = Object.create(BaseValue2 && BaseValue2.prototype);
+                DepthTest2.prototype.constructor = DepthTest2;
+                DepthTest2.prototype.getDefault = function getDefault() {
+                  return false;
+                };
+                DepthTest2.prototype.set = function set(v2) {
+                  if (v2 === this.current && !this.dirty) {
+                    return;
+                  }
+                  var gl2 = this.gl;
+                  if (v2) {
+                    gl2.enable(gl2.DEPTH_TEST);
+                  } else {
+                    gl2.disable(gl2.DEPTH_TEST);
+                  }
+                  this.current = v2;
+                  this.dirty = false;
+                };
+                return DepthTest2;
+              }(BaseValue);
+              var DepthFunc = function(BaseValue2) {
+                function DepthFunc2() {
+                  BaseValue2.apply(this, arguments);
+                }
+                if (BaseValue2)
+                  DepthFunc2.__proto__ = BaseValue2;
+                DepthFunc2.prototype = Object.create(BaseValue2 && BaseValue2.prototype);
+                DepthFunc2.prototype.constructor = DepthFunc2;
+                DepthFunc2.prototype.getDefault = function getDefault() {
+                  return this.gl.LESS;
+                };
+                DepthFunc2.prototype.set = function set(v2) {
+                  if (v2 === this.current && !this.dirty) {
+                    return;
+                  }
+                  this.gl.depthFunc(v2);
+                  this.current = v2;
+                  this.dirty = false;
+                };
+                return DepthFunc2;
+              }(BaseValue);
+              var Blend = function(BaseValue2) {
+                function Blend2() {
+                  BaseValue2.apply(this, arguments);
+                }
+                if (BaseValue2)
+                  Blend2.__proto__ = BaseValue2;
+                Blend2.prototype = Object.create(BaseValue2 && BaseValue2.prototype);
+                Blend2.prototype.constructor = Blend2;
+                Blend2.prototype.getDefault = function getDefault() {
+                  return false;
+                };
+                Blend2.prototype.set = function set(v2) {
+                  if (v2 === this.current && !this.dirty) {
+                    return;
+                  }
+                  var gl2 = this.gl;
+                  if (v2) {
+                    gl2.enable(gl2.BLEND);
+                  } else {
+                    gl2.disable(gl2.BLEND);
+                  }
+                  this.current = v2;
+                  this.dirty = false;
+                };
+                return Blend2;
+              }(BaseValue);
+              var BlendFunc = function(BaseValue2) {
+                function BlendFunc2() {
+                  BaseValue2.apply(this, arguments);
+                }
+                if (BaseValue2)
+                  BlendFunc2.__proto__ = BaseValue2;
+                BlendFunc2.prototype = Object.create(BaseValue2 && BaseValue2.prototype);
+                BlendFunc2.prototype.constructor = BlendFunc2;
+                BlendFunc2.prototype.getDefault = function getDefault() {
+                  var gl2 = this.gl;
+                  return [
+                    gl2.ONE,
+                    gl2.ZERO
+                  ];
+                };
+                BlendFunc2.prototype.set = function set(v2) {
+                  var c2 = this.current;
+                  if (v2[0] === c2[0] && v2[1] === c2[1] && !this.dirty) {
+                    return;
+                  }
+                  this.gl.blendFunc(v2[0], v2[1]);
+                  this.current = v2;
+                  this.dirty = false;
+                };
+                return BlendFunc2;
+              }(BaseValue);
+              var BlendColor = function(BaseValue2) {
+                function BlendColor2() {
+                  BaseValue2.apply(this, arguments);
+                }
+                if (BaseValue2)
+                  BlendColor2.__proto__ = BaseValue2;
+                BlendColor2.prototype = Object.create(BaseValue2 && BaseValue2.prototype);
+                BlendColor2.prototype.constructor = BlendColor2;
+                BlendColor2.prototype.getDefault = function getDefault() {
+                  return performance2.Color.transparent;
+                };
+                BlendColor2.prototype.set = function set(v2) {
+                  var c2 = this.current;
+                  if (v2.r === c2.r && v2.g === c2.g && v2.b === c2.b && v2.a === c2.a && !this.dirty) {
+                    return;
+                  }
+                  this.gl.blendColor(v2.r, v2.g, v2.b, v2.a);
+                  this.current = v2;
+                  this.dirty = false;
+                };
+                return BlendColor2;
+              }(BaseValue);
+              var BlendEquation = function(BaseValue2) {
+                function BlendEquation2() {
+                  BaseValue2.apply(this, arguments);
+                }
+                if (BaseValue2)
+                  BlendEquation2.__proto__ = BaseValue2;
+                BlendEquation2.prototype = Object.create(BaseValue2 && BaseValue2.prototype);
+                BlendEquation2.prototype.constructor = BlendEquation2;
+                BlendEquation2.prototype.getDefault = function getDefault() {
+                  return this.gl.FUNC_ADD;
+                };
+                BlendEquation2.prototype.set = function set(v2) {
+                  if (v2 === this.current && !this.dirty) {
+                    return;
+                  }
+                  this.gl.blendEquation(v2);
+                  this.current = v2;
+                  this.dirty = false;
+                };
+                return BlendEquation2;
+              }(BaseValue);
+              var CullFace = function(BaseValue2) {
+                function CullFace2() {
+                  BaseValue2.apply(this, arguments);
+                }
+                if (BaseValue2)
+                  CullFace2.__proto__ = BaseValue2;
+                CullFace2.prototype = Object.create(BaseValue2 && BaseValue2.prototype);
+                CullFace2.prototype.constructor = CullFace2;
+                CullFace2.prototype.getDefault = function getDefault() {
+                  return false;
+                };
+                CullFace2.prototype.set = function set(v2) {
+                  if (v2 === this.current && !this.dirty) {
+                    return;
+                  }
+                  var gl2 = this.gl;
+                  if (v2) {
+                    gl2.enable(gl2.CULL_FACE);
+                  } else {
+                    gl2.disable(gl2.CULL_FACE);
+                  }
+                  this.current = v2;
+                  this.dirty = false;
+                };
+                return CullFace2;
+              }(BaseValue);
+              var CullFaceSide = function(BaseValue2) {
+                function CullFaceSide2() {
+                  BaseValue2.apply(this, arguments);
+                }
+                if (BaseValue2)
+                  CullFaceSide2.__proto__ = BaseValue2;
+                CullFaceSide2.prototype = Object.create(BaseValue2 && BaseValue2.prototype);
+                CullFaceSide2.prototype.constructor = CullFaceSide2;
+                CullFaceSide2.prototype.getDefault = function getDefault() {
+                  return this.gl.BACK;
+                };
+                CullFaceSide2.prototype.set = function set(v2) {
+                  if (v2 === this.current && !this.dirty) {
+                    return;
+                  }
+                  this.gl.cullFace(v2);
+                  this.current = v2;
+                  this.dirty = false;
+                };
+                return CullFaceSide2;
+              }(BaseValue);
+              var FrontFace = function(BaseValue2) {
+                function FrontFace2() {
+                  BaseValue2.apply(this, arguments);
+                }
+                if (BaseValue2)
+                  FrontFace2.__proto__ = BaseValue2;
+                FrontFace2.prototype = Object.create(BaseValue2 && BaseValue2.prototype);
+                FrontFace2.prototype.constructor = FrontFace2;
+                FrontFace2.prototype.getDefault = function getDefault() {
+                  return this.gl.CCW;
+                };
+                FrontFace2.prototype.set = function set(v2) {
+                  if (v2 === this.current && !this.dirty) {
+                    return;
+                  }
+                  this.gl.frontFace(v2);
+                  this.current = v2;
+                  this.dirty = false;
+                };
+                return FrontFace2;
+              }(BaseValue);
+              var Program = function(BaseValue2) {
+                function Program2() {
+                  BaseValue2.apply(this, arguments);
+                }
+                if (BaseValue2)
+                  Program2.__proto__ = BaseValue2;
+                Program2.prototype = Object.create(BaseValue2 && BaseValue2.prototype);
+                Program2.prototype.constructor = Program2;
+                Program2.prototype.getDefault = function getDefault() {
+                  return null;
+                };
+                Program2.prototype.set = function set(v2) {
+                  if (v2 === this.current && !this.dirty) {
+                    return;
+                  }
+                  this.gl.useProgram(v2);
+                  this.current = v2;
+                  this.dirty = false;
+                };
+                return Program2;
+              }(BaseValue);
+              var ActiveTextureUnit = function(BaseValue2) {
+                function ActiveTextureUnit2() {
+                  BaseValue2.apply(this, arguments);
+                }
+                if (BaseValue2)
+                  ActiveTextureUnit2.__proto__ = BaseValue2;
+                ActiveTextureUnit2.prototype = Object.create(BaseValue2 && BaseValue2.prototype);
+                ActiveTextureUnit2.prototype.constructor = ActiveTextureUnit2;
+                ActiveTextureUnit2.prototype.getDefault = function getDefault() {
+                  return this.gl.TEXTURE0;
+                };
+                ActiveTextureUnit2.prototype.set = function set(v2) {
+                  if (v2 === this.current && !this.dirty) {
+                    return;
+                  }
+                  this.gl.activeTexture(v2);
+                  this.current = v2;
+                  this.dirty = false;
+                };
+                return ActiveTextureUnit2;
+              }(BaseValue);
+              var Viewport2 = function(BaseValue2) {
+                function Viewport22() {
+                  BaseValue2.apply(this, arguments);
+                }
+                if (BaseValue2)
+                  Viewport22.__proto__ = BaseValue2;
+                Viewport22.prototype = Object.create(BaseValue2 && BaseValue2.prototype);
+                Viewport22.prototype.constructor = Viewport22;
+                Viewport22.prototype.getDefault = function getDefault() {
+                  var gl2 = this.gl;
+                  return [
+                    0,
+                    0,
+                    gl2.drawingBufferWidth,
+                    gl2.drawingBufferHeight
+                  ];
+                };
+                Viewport22.prototype.set = function set(v2) {
+                  var c2 = this.current;
+                  if (v2[0] === c2[0] && v2[1] === c2[1] && v2[2] === c2[2] && v2[3] === c2[3] && !this.dirty) {
+                    return;
+                  }
+                  this.gl.viewport(v2[0], v2[1], v2[2], v2[3]);
+                  this.current = v2;
+                  this.dirty = false;
+                };
+                return Viewport22;
+              }(BaseValue);
+              var BindFramebuffer = function(BaseValue2) {
+                function BindFramebuffer2() {
+                  BaseValue2.apply(this, arguments);
+                }
+                if (BaseValue2)
+                  BindFramebuffer2.__proto__ = BaseValue2;
+                BindFramebuffer2.prototype = Object.create(BaseValue2 && BaseValue2.prototype);
+                BindFramebuffer2.prototype.constructor = BindFramebuffer2;
+                BindFramebuffer2.prototype.getDefault = function getDefault() {
+                  return null;
+                };
+                BindFramebuffer2.prototype.set = function set(v2) {
+                  if (v2 === this.current && !this.dirty) {
+                    return;
+                  }
+                  var gl2 = this.gl;
+                  gl2.bindFramebuffer(gl2.FRAMEBUFFER, v2);
+                  this.current = v2;
+                  this.dirty = false;
+                };
+                return BindFramebuffer2;
+              }(BaseValue);
+              var BindRenderbuffer = function(BaseValue2) {
+                function BindRenderbuffer2() {
+                  BaseValue2.apply(this, arguments);
+                }
+                if (BaseValue2)
+                  BindRenderbuffer2.__proto__ = BaseValue2;
+                BindRenderbuffer2.prototype = Object.create(BaseValue2 && BaseValue2.prototype);
+                BindRenderbuffer2.prototype.constructor = BindRenderbuffer2;
+                BindRenderbuffer2.prototype.getDefault = function getDefault() {
+                  return null;
+                };
+                BindRenderbuffer2.prototype.set = function set(v2) {
+                  if (v2 === this.current && !this.dirty) {
+                    return;
+                  }
+                  var gl2 = this.gl;
+                  gl2.bindRenderbuffer(gl2.RENDERBUFFER, v2);
+                  this.current = v2;
+                  this.dirty = false;
+                };
+                return BindRenderbuffer2;
+              }(BaseValue);
+              var BindTexture = function(BaseValue2) {
+                function BindTexture2() {
+                  BaseValue2.apply(this, arguments);
+                }
+                if (BaseValue2)
+                  BindTexture2.__proto__ = BaseValue2;
+                BindTexture2.prototype = Object.create(BaseValue2 && BaseValue2.prototype);
+                BindTexture2.prototype.constructor = BindTexture2;
+                BindTexture2.prototype.getDefault = function getDefault() {
+                  return null;
+                };
+                BindTexture2.prototype.set = function set(v2) {
+                  if (v2 === this.current && !this.dirty) {
+                    return;
+                  }
+                  var gl2 = this.gl;
+                  gl2.bindTexture(gl2.TEXTURE_2D, v2);
+                  this.current = v2;
+                  this.dirty = false;
+                };
+                return BindTexture2;
+              }(BaseValue);
+              var BindVertexBuffer = function(BaseValue2) {
+                function BindVertexBuffer2() {
+                  BaseValue2.apply(this, arguments);
+                }
+                if (BaseValue2)
+                  BindVertexBuffer2.__proto__ = BaseValue2;
+                BindVertexBuffer2.prototype = Object.create(BaseValue2 && BaseValue2.prototype);
+                BindVertexBuffer2.prototype.constructor = BindVertexBuffer2;
+                BindVertexBuffer2.prototype.getDefault = function getDefault() {
+                  return null;
+                };
+                BindVertexBuffer2.prototype.set = function set(v2) {
+                  if (v2 === this.current && !this.dirty) {
+                    return;
+                  }
+                  var gl2 = this.gl;
+                  gl2.bindBuffer(gl2.ARRAY_BUFFER, v2);
+                  this.current = v2;
+                  this.dirty = false;
+                };
+                return BindVertexBuffer2;
+              }(BaseValue);
+              var BindElementBuffer = function(BaseValue2) {
+                function BindElementBuffer2() {
+                  BaseValue2.apply(this, arguments);
+                }
+                if (BaseValue2)
+                  BindElementBuffer2.__proto__ = BaseValue2;
+                BindElementBuffer2.prototype = Object.create(BaseValue2 && BaseValue2.prototype);
+                BindElementBuffer2.prototype.constructor = BindElementBuffer2;
+                BindElementBuffer2.prototype.getDefault = function getDefault() {
+                  return null;
+                };
+                BindElementBuffer2.prototype.set = function set(v2) {
+                  var gl2 = this.gl;
+                  gl2.bindBuffer(gl2.ELEMENT_ARRAY_BUFFER, v2);
+                  this.current = v2;
+                  this.dirty = false;
+                };
+                return BindElementBuffer2;
+              }(BaseValue);
+              var BindVertexArrayOES = function(BaseValue2) {
+                function BindVertexArrayOES2(context) {
+                  BaseValue2.call(this, context);
+                  this.vao = context.extVertexArrayObject;
+                }
+                if (BaseValue2)
+                  BindVertexArrayOES2.__proto__ = BaseValue2;
+                BindVertexArrayOES2.prototype = Object.create(BaseValue2 && BaseValue2.prototype);
+                BindVertexArrayOES2.prototype.constructor = BindVertexArrayOES2;
+                BindVertexArrayOES2.prototype.getDefault = function getDefault() {
+                  return null;
+                };
+                BindVertexArrayOES2.prototype.set = function set(v2) {
+                  if (!this.vao || v2 === this.current && !this.dirty) {
+                    return;
+                  }
+                  this.vao.bindVertexArrayOES(v2);
+                  this.current = v2;
+                  this.dirty = false;
+                };
+                return BindVertexArrayOES2;
+              }(BaseValue);
+              var PixelStoreUnpack = function(BaseValue2) {
+                function PixelStoreUnpack2() {
+                  BaseValue2.apply(this, arguments);
+                }
+                if (BaseValue2)
+                  PixelStoreUnpack2.__proto__ = BaseValue2;
+                PixelStoreUnpack2.prototype = Object.create(BaseValue2 && BaseValue2.prototype);
+                PixelStoreUnpack2.prototype.constructor = PixelStoreUnpack2;
+                PixelStoreUnpack2.prototype.getDefault = function getDefault() {
+                  return 4;
+                };
+                PixelStoreUnpack2.prototype.set = function set(v2) {
+                  if (v2 === this.current && !this.dirty) {
+                    return;
+                  }
+                  var gl2 = this.gl;
+                  gl2.pixelStorei(gl2.UNPACK_ALIGNMENT, v2);
+                  this.current = v2;
+                  this.dirty = false;
+                };
+                return PixelStoreUnpack2;
+              }(BaseValue);
+              var PixelStoreUnpackPremultiplyAlpha = function(BaseValue2) {
+                function PixelStoreUnpackPremultiplyAlpha2() {
+                  BaseValue2.apply(this, arguments);
+                }
+                if (BaseValue2)
+                  PixelStoreUnpackPremultiplyAlpha2.__proto__ = BaseValue2;
+                PixelStoreUnpackPremultiplyAlpha2.prototype = Object.create(BaseValue2 && BaseValue2.prototype);
+                PixelStoreUnpackPremultiplyAlpha2.prototype.constructor = PixelStoreUnpackPremultiplyAlpha2;
+                PixelStoreUnpackPremultiplyAlpha2.prototype.getDefault = function getDefault() {
+                  return false;
+                };
+                PixelStoreUnpackPremultiplyAlpha2.prototype.set = function set(v2) {
+                  if (v2 === this.current && !this.dirty) {
+                    return;
+                  }
+                  var gl2 = this.gl;
+                  gl2.pixelStorei(gl2.UNPACK_PREMULTIPLY_ALPHA_WEBGL, v2);
+                  this.current = v2;
+                  this.dirty = false;
+                };
+                return PixelStoreUnpackPremultiplyAlpha2;
+              }(BaseValue);
+              var PixelStoreUnpackFlipY = function(BaseValue2) {
+                function PixelStoreUnpackFlipY2() {
+                  BaseValue2.apply(this, arguments);
+                }
+                if (BaseValue2)
+                  PixelStoreUnpackFlipY2.__proto__ = BaseValue2;
+                PixelStoreUnpackFlipY2.prototype = Object.create(BaseValue2 && BaseValue2.prototype);
+                PixelStoreUnpackFlipY2.prototype.constructor = PixelStoreUnpackFlipY2;
+                PixelStoreUnpackFlipY2.prototype.getDefault = function getDefault() {
+                  return false;
+                };
+                PixelStoreUnpackFlipY2.prototype.set = function set(v2) {
+                  if (v2 === this.current && !this.dirty) {
+                    return;
+                  }
+                  var gl2 = this.gl;
+                  gl2.pixelStorei(gl2.UNPACK_FLIP_Y_WEBGL, v2);
+                  this.current = v2;
+                  this.dirty = false;
+                };
+                return PixelStoreUnpackFlipY2;
+              }(BaseValue);
+              var FramebufferAttachment = function(BaseValue2) {
+                function FramebufferAttachment2(context, parent) {
+                  BaseValue2.call(this, context);
+                  this.context = context;
+                  this.parent = parent;
+                }
+                if (BaseValue2)
+                  FramebufferAttachment2.__proto__ = BaseValue2;
+                FramebufferAttachment2.prototype = Object.create(BaseValue2 && BaseValue2.prototype);
+                FramebufferAttachment2.prototype.constructor = FramebufferAttachment2;
+                FramebufferAttachment2.prototype.getDefault = function getDefault() {
+                  return null;
+                };
+                return FramebufferAttachment2;
+              }(BaseValue);
+              var ColorAttachment = function(FramebufferAttachment2) {
+                function ColorAttachment2() {
+                  FramebufferAttachment2.apply(this, arguments);
+                }
+                if (FramebufferAttachment2)
+                  ColorAttachment2.__proto__ = FramebufferAttachment2;
+                ColorAttachment2.prototype = Object.create(FramebufferAttachment2 && FramebufferAttachment2.prototype);
+                ColorAttachment2.prototype.constructor = ColorAttachment2;
+                ColorAttachment2.prototype.setDirty = function setDirty() {
+                  this.dirty = true;
+                };
+                ColorAttachment2.prototype.set = function set(v2) {
+                  if (v2 === this.current && !this.dirty) {
+                    return;
+                  }
+                  this.context.bindFramebuffer.set(this.parent);
+                  var gl2 = this.gl;
+                  gl2.framebufferTexture2D(gl2.FRAMEBUFFER, gl2.COLOR_ATTACHMENT0, gl2.TEXTURE_2D, v2, 0);
+                  this.current = v2;
+                  this.dirty = false;
+                };
+                return ColorAttachment2;
+              }(FramebufferAttachment);
+              var DepthAttachment = function(FramebufferAttachment2) {
+                function DepthAttachment2() {
+                  FramebufferAttachment2.apply(this, arguments);
+                }
+                if (FramebufferAttachment2)
+                  DepthAttachment2.__proto__ = FramebufferAttachment2;
+                DepthAttachment2.prototype = Object.create(FramebufferAttachment2 && FramebufferAttachment2.prototype);
+                DepthAttachment2.prototype.constructor = DepthAttachment2;
+                DepthAttachment2.prototype.set = function set(v2) {
+                  if (v2 === this.current && !this.dirty) {
+                    return;
+                  }
+                  this.context.bindFramebuffer.set(this.parent);
+                  var gl2 = this.gl;
+                  gl2.framebufferRenderbuffer(gl2.FRAMEBUFFER, gl2.DEPTH_ATTACHMENT, gl2.RENDERBUFFER, v2);
+                  this.current = v2;
+                  this.dirty = false;
+                };
+                return DepthAttachment2;
+              }(FramebufferAttachment);
+              var Framebuffer2 = function Framebuffer22(context, width, height, hasDepth) {
+                this.context = context;
+                this.width = width;
+                this.height = height;
+                var gl2 = context.gl;
+                var fbo = this.framebuffer = gl2.createFramebuffer();
+                this.colorAttachment = new ColorAttachment(context, fbo);
+                if (hasDepth) {
+                  this.depthAttachment = new DepthAttachment(context, fbo);
+                }
+              };
+              Framebuffer2.prototype.destroy = function destroy() {
+                var gl2 = this.context.gl;
+                var texture = this.colorAttachment.get();
+                if (texture) {
+                  gl2.deleteTexture(texture);
+                }
+                if (this.depthAttachment) {
+                  var renderbuffer = this.depthAttachment.get();
+                  if (renderbuffer) {
+                    gl2.deleteRenderbuffer(renderbuffer);
+                  }
+                }
+                gl2.deleteFramebuffer(this.framebuffer);
+              };
+              var ALWAYS = 519;
+              var DepthMode = function DepthMode2(depthFunc, depthMask, depthRange) {
+                this.func = depthFunc;
+                this.mask = depthMask;
+                this.range = depthRange;
+              };
+              DepthMode.ReadOnly = false;
+              DepthMode.ReadWrite = true;
+              DepthMode.disabled = new DepthMode(ALWAYS, DepthMode.ReadOnly, [
+                0,
+                1
+              ]);
+              var ALWAYS$1 = 519;
+              var KEEP = 7680;
+              var StencilMode = function StencilMode2(test, ref, mask, fail, depthFail, pass) {
+                this.test = test;
+                this.ref = ref;
+                this.mask = mask;
+                this.fail = fail;
+                this.depthFail = depthFail;
+                this.pass = pass;
+              };
+              StencilMode.disabled = new StencilMode({
+                func: ALWAYS$1,
+                mask: 0
+              }, 0, 0, KEEP, KEEP, KEEP);
+              var ZERO2 = 0;
+              var ONE = 1;
+              var ONE_MINUS_SRC_ALPHA = 771;
+              var ColorMode = function ColorMode2(blendFunction, blendColor, mask) {
+                this.blendFunction = blendFunction;
+                this.blendColor = blendColor;
+                this.mask = mask;
+              };
+              ColorMode.Replace = [
+                ONE,
+                ZERO2
+              ];
+              ColorMode.disabled = new ColorMode(ColorMode.Replace, performance2.Color.transparent, [
+                false,
+                false,
+                false,
+                false
+              ]);
+              ColorMode.unblended = new ColorMode(ColorMode.Replace, performance2.Color.transparent, [
+                true,
+                true,
+                true,
+                true
+              ]);
+              ColorMode.alphaBlended = new ColorMode([
+                ONE,
+                ONE_MINUS_SRC_ALPHA
+              ], performance2.Color.transparent, [
+                true,
+                true,
+                true,
+                true
+              ]);
+              var BACK = 1029;
+              var CCW = 2305;
+              var CullFaceMode = function CullFaceMode2(enable2, mode, frontFace) {
+                this.enable = enable2;
+                this.mode = mode;
+                this.frontFace = frontFace;
+              };
+              CullFaceMode.disabled = new CullFaceMode(false, BACK, CCW);
+              CullFaceMode.backCCW = new CullFaceMode(true, BACK, CCW);
+              var Context = function Context2(gl2) {
+                this.gl = gl2;
+                this.extVertexArrayObject = this.gl.getExtension("OES_vertex_array_object");
+                this.clearColor = new ClearColor(this);
+                this.clearDepth = new ClearDepth(this);
+                this.clearStencil = new ClearStencil(this);
+                this.colorMask = new ColorMask(this);
+                this.depthMask = new DepthMask(this);
+                this.stencilMask = new StencilMask(this);
+                this.stencilFunc = new StencilFunc(this);
+                this.stencilOp = new StencilOp(this);
+                this.stencilTest = new StencilTest(this);
+                this.depthRange = new DepthRange(this);
+                this.depthTest = new DepthTest(this);
+                this.depthFunc = new DepthFunc(this);
+                this.blend = new Blend(this);
+                this.blendFunc = new BlendFunc(this);
+                this.blendColor = new BlendColor(this);
+                this.blendEquation = new BlendEquation(this);
+                this.cullFace = new CullFace(this);
+                this.cullFaceSide = new CullFaceSide(this);
+                this.frontFace = new FrontFace(this);
+                this.program = new Program(this);
+                this.activeTexture = new ActiveTextureUnit(this);
+                this.viewport = new Viewport2(this);
+                this.bindFramebuffer = new BindFramebuffer(this);
+                this.bindRenderbuffer = new BindRenderbuffer(this);
+                this.bindTexture = new BindTexture(this);
+                this.bindVertexBuffer = new BindVertexBuffer(this);
+                this.bindElementBuffer = new BindElementBuffer(this);
+                this.bindVertexArrayOES = this.extVertexArrayObject && new BindVertexArrayOES(this);
+                this.pixelStoreUnpack = new PixelStoreUnpack(this);
+                this.pixelStoreUnpackPremultiplyAlpha = new PixelStoreUnpackPremultiplyAlpha(this);
+                this.pixelStoreUnpackFlipY = new PixelStoreUnpackFlipY(this);
+                this.extTextureFilterAnisotropic = gl2.getExtension("EXT_texture_filter_anisotropic") || gl2.getExtension("MOZ_EXT_texture_filter_anisotropic") || gl2.getExtension("WEBKIT_EXT_texture_filter_anisotropic");
+                if (this.extTextureFilterAnisotropic) {
+                  this.extTextureFilterAnisotropicMax = gl2.getParameter(this.extTextureFilterAnisotropic.MAX_TEXTURE_MAX_ANISOTROPY_EXT);
+                }
+                this.extTextureHalfFloat = gl2.getExtension("OES_texture_half_float");
+                if (this.extTextureHalfFloat) {
+                  gl2.getExtension("OES_texture_half_float_linear");
+                  this.extRenderToTextureHalfFloat = gl2.getExtension("EXT_color_buffer_half_float");
+                }
+                this.extTimerQuery = gl2.getExtension("EXT_disjoint_timer_query");
+                this.maxTextureSize = gl2.getParameter(gl2.MAX_TEXTURE_SIZE);
+              };
+              Context.prototype.setDefault = function setDefault() {
+                this.unbindVAO();
+                this.clearColor.setDefault();
+                this.clearDepth.setDefault();
+                this.clearStencil.setDefault();
+                this.colorMask.setDefault();
+                this.depthMask.setDefault();
+                this.stencilMask.setDefault();
+                this.stencilFunc.setDefault();
+                this.stencilOp.setDefault();
+                this.stencilTest.setDefault();
+                this.depthRange.setDefault();
+                this.depthTest.setDefault();
+                this.depthFunc.setDefault();
+                this.blend.setDefault();
+                this.blendFunc.setDefault();
+                this.blendColor.setDefault();
+                this.blendEquation.setDefault();
+                this.cullFace.setDefault();
+                this.cullFaceSide.setDefault();
+                this.frontFace.setDefault();
+                this.program.setDefault();
+                this.activeTexture.setDefault();
+                this.bindFramebuffer.setDefault();
+                this.pixelStoreUnpack.setDefault();
+                this.pixelStoreUnpackPremultiplyAlpha.setDefault();
+                this.pixelStoreUnpackFlipY.setDefault();
+              };
+              Context.prototype.setDirty = function setDirty() {
+                this.clearColor.dirty = true;
+                this.clearDepth.dirty = true;
+                this.clearStencil.dirty = true;
+                this.colorMask.dirty = true;
+                this.depthMask.dirty = true;
+                this.stencilMask.dirty = true;
+                this.stencilFunc.dirty = true;
+                this.stencilOp.dirty = true;
+                this.stencilTest.dirty = true;
+                this.depthRange.dirty = true;
+                this.depthTest.dirty = true;
+                this.depthFunc.dirty = true;
+                this.blend.dirty = true;
+                this.blendFunc.dirty = true;
+                this.blendColor.dirty = true;
+                this.blendEquation.dirty = true;
+                this.cullFace.dirty = true;
+                this.cullFaceSide.dirty = true;
+                this.frontFace.dirty = true;
+                this.program.dirty = true;
+                this.activeTexture.dirty = true;
+                this.viewport.dirty = true;
+                this.bindFramebuffer.dirty = true;
+                this.bindRenderbuffer.dirty = true;
+                this.bindTexture.dirty = true;
+                this.bindVertexBuffer.dirty = true;
+                this.bindElementBuffer.dirty = true;
+                if (this.extVertexArrayObject) {
+                  this.bindVertexArrayOES.dirty = true;
+                }
+                this.pixelStoreUnpack.dirty = true;
+                this.pixelStoreUnpackPremultiplyAlpha.dirty = true;
+                this.pixelStoreUnpackFlipY.dirty = true;
+              };
+              Context.prototype.createIndexBuffer = function createIndexBuffer(array, dynamicDraw) {
+                return new IndexBuffer(this, array, dynamicDraw);
+              };
+              Context.prototype.createVertexBuffer = function createVertexBuffer(array, attributes, dynamicDraw) {
+                return new VertexBuffer(this, array, attributes, dynamicDraw);
+              };
+              Context.prototype.createRenderbuffer = function createRenderbuffer(storageFormat, width, height) {
+                var gl2 = this.gl;
+                var rbo = gl2.createRenderbuffer();
+                this.bindRenderbuffer.set(rbo);
+                gl2.renderbufferStorage(gl2.RENDERBUFFER, storageFormat, width, height);
+                this.bindRenderbuffer.set(null);
+                return rbo;
+              };
+              Context.prototype.createFramebuffer = function createFramebuffer(width, height, hasDepth) {
+                return new Framebuffer2(this, width, height, hasDepth);
+              };
+              Context.prototype.clear = function clear(ref) {
+                var color22 = ref.color;
+                var depth = ref.depth;
+                var gl2 = this.gl;
+                var mask = 0;
+                if (color22) {
+                  mask |= gl2.COLOR_BUFFER_BIT;
+                  this.clearColor.set(color22);
+                  this.colorMask.set([
+                    true,
+                    true,
+                    true,
+                    true
+                  ]);
+                }
+                if (typeof depth !== "undefined") {
+                  mask |= gl2.DEPTH_BUFFER_BIT;
+                  this.depthRange.set([
+                    0,
+                    1
+                  ]);
+                  this.clearDepth.set(depth);
+                  this.depthMask.set(true);
+                }
+                gl2.clear(mask);
+              };
+              Context.prototype.setCullFace = function setCullFace(cullFaceMode) {
+                if (cullFaceMode.enable === false) {
+                  this.cullFace.set(false);
+                } else {
+                  this.cullFace.set(true);
+                  this.cullFaceSide.set(cullFaceMode.mode);
+                  this.frontFace.set(cullFaceMode.frontFace);
+                }
+              };
+              Context.prototype.setDepthMode = function setDepthMode(depthMode) {
+                if (depthMode.func === this.gl.ALWAYS && !depthMode.mask) {
+                  this.depthTest.set(false);
+                } else {
+                  this.depthTest.set(true);
+                  this.depthFunc.set(depthMode.func);
+                  this.depthMask.set(depthMode.mask);
+                  this.depthRange.set(depthMode.range);
+                }
+              };
+              Context.prototype.setStencilMode = function setStencilMode(stencilMode) {
+                if (stencilMode.test.func === this.gl.ALWAYS && !stencilMode.mask) {
+                  this.stencilTest.set(false);
+                } else {
+                  this.stencilTest.set(true);
+                  this.stencilMask.set(stencilMode.mask);
+                  this.stencilOp.set([
+                    stencilMode.fail,
+                    stencilMode.depthFail,
+                    stencilMode.pass
+                  ]);
+                  this.stencilFunc.set({
+                    func: stencilMode.test.func,
+                    ref: stencilMode.ref,
+                    mask: stencilMode.test.mask
+                  });
+                }
+              };
+              Context.prototype.setColorMode = function setColorMode(colorMode) {
+                if (performance2.deepEqual(colorMode.blendFunction, ColorMode.Replace)) {
+                  this.blend.set(false);
+                } else {
+                  this.blend.set(true);
+                  this.blendFunc.set(colorMode.blendFunction);
+                  this.blendColor.set(colorMode.blendColor);
+                }
+                this.colorMask.set(colorMode.mask);
+              };
+              Context.prototype.unbindVAO = function unbindVAO() {
+                if (this.extVertexArrayObject) {
+                  this.bindVertexArrayOES.set(null);
+                }
+              };
+              var SourceCache = function(Evented) {
+                function SourceCache2(id2, options, dispatcher) {
+                  var this$1$1 = this;
+                  Evented.call(this);
+                  this.id = id2;
+                  this.dispatcher = dispatcher;
+                  this.on("data", function(e2) {
+                    if (e2.dataType === "source" && e2.sourceDataType === "metadata") {
+                      this$1$1._sourceLoaded = true;
+                    }
+                    if (this$1$1._sourceLoaded && !this$1$1._paused && e2.dataType === "source" && e2.sourceDataType === "content") {
+                      this$1$1.reload();
+                      if (this$1$1.transform) {
+                        this$1$1.update(this$1$1.transform);
+                      }
+                    }
+                  });
+                  this.on("error", function() {
+                    this$1$1._sourceErrored = true;
+                  });
+                  this._source = create2(id2, options, dispatcher, this);
+                  this._tiles = {};
+                  this._cache = new TileCache(0, this._unloadTile.bind(this));
+                  this._timers = {};
+                  this._cacheTimers = {};
+                  this._maxTileCacheSize = null;
+                  this._loadedParentTiles = {};
+                  this._coveredTiles = {};
+                  this._state = new performance2.SourceFeatureState();
+                }
+                if (Evented)
+                  SourceCache2.__proto__ = Evented;
+                SourceCache2.prototype = Object.create(Evented && Evented.prototype);
+                SourceCache2.prototype.constructor = SourceCache2;
+                SourceCache2.prototype.onAdd = function onAdd(map2) {
+                  this.map = map2;
+                  this._maxTileCacheSize = map2 ? map2._maxTileCacheSize : null;
+                  if (this._source && this._source.onAdd) {
+                    this._source.onAdd(map2);
+                  }
+                };
+                SourceCache2.prototype.onRemove = function onRemove(map2) {
+                  if (this._source && this._source.onRemove) {
+                    this._source.onRemove(map2);
+                  }
+                };
+                SourceCache2.prototype.loaded = function loaded() {
+                  if (this._sourceErrored) {
+                    return true;
+                  }
+                  if (!this._sourceLoaded) {
+                    return false;
+                  }
+                  if (!this._source.loaded()) {
+                    return false;
+                  }
+                  for (var t4 in this._tiles) {
+                    var tile = this._tiles[t4];
+                    if (tile.state !== "loaded" && tile.state !== "errored") {
+                      return false;
+                    }
+                  }
+                  return true;
+                };
+                SourceCache2.prototype.getSource = function getSource() {
+                  return this._source;
+                };
+                SourceCache2.prototype.pause = function pause() {
+                  this._paused = true;
+                };
+                SourceCache2.prototype.resume = function resume() {
+                  if (!this._paused) {
+                    return;
+                  }
+                  var shouldReload = this._shouldReloadOnResume;
+                  this._paused = false;
+                  this._shouldReloadOnResume = false;
+                  if (shouldReload) {
+                    this.reload();
+                  }
+                  if (this.transform) {
+                    this.update(this.transform);
+                  }
+                };
+                SourceCache2.prototype._loadTile = function _loadTile(tile, callback) {
+                  return this._source.loadTile(tile, callback);
+                };
+                SourceCache2.prototype._unloadTile = function _unloadTile(tile) {
+                  if (this._source.unloadTile) {
+                    return this._source.unloadTile(tile, function() {
+                    });
+                  }
+                };
+                SourceCache2.prototype._abortTile = function _abortTile(tile) {
+                  if (this._source.abortTile) {
+                    return this._source.abortTile(tile, function() {
+                    });
+                  }
+                };
+                SourceCache2.prototype.serialize = function serialize() {
+                  return this._source.serialize();
+                };
+                SourceCache2.prototype.prepare = function prepare(context) {
+                  if (this._source.prepare) {
+                    this._source.prepare();
+                  }
+                  this._state.coalesceChanges(this._tiles, this.map ? this.map.painter : null);
+                  for (var i2 in this._tiles) {
+                    var tile = this._tiles[i2];
+                    tile.upload(context);
+                    tile.prepare(this.map.style.imageManager);
+                  }
+                };
+                SourceCache2.prototype.getIds = function getIds() {
+                  return performance2.values(this._tiles).map(function(tile) {
+                    return tile.tileID;
+                  }).sort(compareTileId).map(function(id2) {
+                    return id2.key;
+                  });
+                };
+                SourceCache2.prototype.getRenderableIds = function getRenderableIds(symbolLayer) {
+                  var this$1$1 = this;
+                  var renderables = [];
+                  for (var id2 in this._tiles) {
+                    if (this._isIdRenderable(id2, symbolLayer)) {
+                      renderables.push(this._tiles[id2]);
+                    }
+                  }
+                  if (symbolLayer) {
+                    return renderables.sort(function(a_, b_) {
+                      var a2 = a_.tileID;
+                      var b2 = b_.tileID;
+                      var rotatedA = new performance2.Point(a2.canonical.x, a2.canonical.y)._rotate(this$1$1.transform.angle);
+                      var rotatedB = new performance2.Point(b2.canonical.x, b2.canonical.y)._rotate(this$1$1.transform.angle);
+                      return a2.overscaledZ - b2.overscaledZ || rotatedB.y - rotatedA.y || rotatedB.x - rotatedA.x;
+                    }).map(function(tile) {
+                      return tile.tileID.key;
+                    });
+                  }
+                  return renderables.map(function(tile) {
+                    return tile.tileID;
+                  }).sort(compareTileId).map(function(id22) {
+                    return id22.key;
+                  });
+                };
+                SourceCache2.prototype.hasRenderableParent = function hasRenderableParent(tileID) {
+                  var parentTile = this.findLoadedParent(tileID, 0);
+                  if (parentTile) {
+                    return this._isIdRenderable(parentTile.tileID.key);
+                  }
+                  return false;
+                };
+                SourceCache2.prototype._isIdRenderable = function _isIdRenderable(id2, symbolLayer) {
+                  return this._tiles[id2] && this._tiles[id2].hasData() && !this._coveredTiles[id2] && (symbolLayer || !this._tiles[id2].holdingForFade());
+                };
+                SourceCache2.prototype.reload = function reload() {
+                  if (this._paused) {
+                    this._shouldReloadOnResume = true;
+                    return;
+                  }
+                  this._cache.reset();
+                  for (var i2 in this._tiles) {
+                    if (this._tiles[i2].state !== "errored") {
+                      this._reloadTile(i2, "reloading");
+                    }
+                  }
+                };
+                SourceCache2.prototype._reloadTile = function _reloadTile(id2, state) {
+                  var tile = this._tiles[id2];
+                  if (!tile) {
+                    return;
+                  }
+                  if (tile.state !== "loading") {
+                    tile.state = state;
+                  }
+                  this._loadTile(tile, this._tileLoaded.bind(this, tile, id2, state));
+                };
+                SourceCache2.prototype._tileLoaded = function _tileLoaded(tile, id2, previousState, err) {
+                  if (err) {
+                    tile.state = "errored";
+                    if (err.status !== 404) {
+                      this._source.fire(new performance2.ErrorEvent(err, { tile }));
+                    } else {
+                      this.update(this.transform);
+                    }
+                    return;
+                  }
+                  tile.timeAdded = performance2.browser.now();
+                  if (previousState === "expired") {
+                    tile.refreshedUponExpiration = true;
+                  }
+                  this._setTileReloadTimer(id2, tile);
+                  if (this.getSource().type === "raster-dem" && tile.dem) {
+                    this._backfillDEM(tile);
+                  }
+                  this._state.initializeTileState(tile, this.map ? this.map.painter : null);
+                  this._source.fire(new performance2.Event("data", {
+                    dataType: "source",
+                    tile,
+                    coord: tile.tileID
+                  }));
+                };
+                SourceCache2.prototype._backfillDEM = function _backfillDEM(tile) {
+                  var renderables = this.getRenderableIds();
+                  for (var i2 = 0; i2 < renderables.length; i2++) {
+                    var borderId = renderables[i2];
+                    if (tile.neighboringTiles && tile.neighboringTiles[borderId]) {
+                      var borderTile = this.getTileByID(borderId);
+                      fillBorder(tile, borderTile);
+                      fillBorder(borderTile, tile);
+                    }
+                  }
+                  function fillBorder(tile2, borderTile2) {
+                    tile2.needsHillshadePrepare = true;
+                    var dx = borderTile2.tileID.canonical.x - tile2.tileID.canonical.x;
+                    var dy = borderTile2.tileID.canonical.y - tile2.tileID.canonical.y;
+                    var dim = Math.pow(2, tile2.tileID.canonical.z);
+                    var borderId2 = borderTile2.tileID.key;
+                    if (dx === 0 && dy === 0) {
+                      return;
+                    }
+                    if (Math.abs(dy) > 1) {
+                      return;
+                    }
+                    if (Math.abs(dx) > 1) {
+                      if (Math.abs(dx + dim) === 1) {
+                        dx += dim;
+                      } else if (Math.abs(dx - dim) === 1) {
+                        dx -= dim;
+                      }
+                    }
+                    if (!borderTile2.dem || !tile2.dem) {
+                      return;
+                    }
+                    tile2.dem.backfillBorder(borderTile2.dem, dx, dy);
+                    if (tile2.neighboringTiles && tile2.neighboringTiles[borderId2]) {
+                      tile2.neighboringTiles[borderId2].backfilled = true;
+                    }
+                  }
+                };
+                SourceCache2.prototype.getTile = function getTile(tileID) {
+                  return this.getTileByID(tileID.key);
+                };
+                SourceCache2.prototype.getTileByID = function getTileByID(id2) {
+                  return this._tiles[id2];
+                };
+                SourceCache2.prototype._retainLoadedChildren = function _retainLoadedChildren(idealTiles, zoom, maxCoveringZoom, retain) {
+                  for (var id2 in this._tiles) {
+                    var tile = this._tiles[id2];
+                    if (retain[id2] || !tile.hasData() || tile.tileID.overscaledZ <= zoom || tile.tileID.overscaledZ > maxCoveringZoom) {
+                      continue;
+                    }
+                    var topmostLoadedID = tile.tileID;
+                    while (tile && tile.tileID.overscaledZ > zoom + 1) {
+                      var parentID = tile.tileID.scaledTo(tile.tileID.overscaledZ - 1);
+                      tile = this._tiles[parentID.key];
+                      if (tile && tile.hasData()) {
+                        topmostLoadedID = parentID;
+                      }
+                    }
+                    var tileID = topmostLoadedID;
+                    while (tileID.overscaledZ > zoom) {
+                      tileID = tileID.scaledTo(tileID.overscaledZ - 1);
+                      if (idealTiles[tileID.key]) {
+                        retain[topmostLoadedID.key] = topmostLoadedID;
+                        break;
+                      }
+                    }
+                  }
+                };
+                SourceCache2.prototype.findLoadedParent = function findLoadedParent(tileID, minCoveringZoom) {
+                  if (tileID.key in this._loadedParentTiles) {
+                    var parent = this._loadedParentTiles[tileID.key];
+                    if (parent && parent.tileID.overscaledZ >= minCoveringZoom) {
+                      return parent;
+                    } else {
+                      return null;
+                    }
+                  }
+                  for (var z2 = tileID.overscaledZ - 1; z2 >= minCoveringZoom; z2--) {
+                    var parentTileID = tileID.scaledTo(z2);
+                    var tile = this._getLoadedTile(parentTileID);
+                    if (tile) {
+                      return tile;
+                    }
+                  }
+                };
+                SourceCache2.prototype._getLoadedTile = function _getLoadedTile(tileID) {
+                  var tile = this._tiles[tileID.key];
+                  if (tile && tile.hasData()) {
+                    return tile;
+                  }
+                  var cachedTile = this._cache.getByKey(tileID.wrapped().key);
+                  return cachedTile;
+                };
+                SourceCache2.prototype.updateCacheSize = function updateCacheSize(transform) {
+                  var widthInTiles = Math.ceil(transform.width / this._source.tileSize) + 1;
+                  var heightInTiles = Math.ceil(transform.height / this._source.tileSize) + 1;
+                  var approxTilesInView = widthInTiles * heightInTiles;
+                  var commonZoomRange = 5;
+                  var viewDependentMaxSize = Math.floor(approxTilesInView * commonZoomRange);
+                  var maxSize = typeof this._maxTileCacheSize === "number" ? Math.min(this._maxTileCacheSize, viewDependentMaxSize) : viewDependentMaxSize;
+                  this._cache.setMaxSize(maxSize);
+                };
+                SourceCache2.prototype.handleWrapJump = function handleWrapJump(lng) {
+                  var prevLng = this._prevLng === void 0 ? lng : this._prevLng;
+                  var lngDifference = lng - prevLng;
+                  var worldDifference = lngDifference / 360;
+                  var wrapDelta = Math.round(worldDifference);
+                  this._prevLng = lng;
+                  if (wrapDelta) {
+                    var tiles = {};
+                    for (var key in this._tiles) {
+                      var tile = this._tiles[key];
+                      tile.tileID = tile.tileID.unwrapTo(tile.tileID.wrap + wrapDelta);
+                      tiles[tile.tileID.key] = tile;
+                    }
+                    this._tiles = tiles;
+                    for (var id2 in this._timers) {
+                      clearTimeout(this._timers[id2]);
+                      delete this._timers[id2];
+                    }
+                    for (var id$1 in this._tiles) {
+                      var tile$1 = this._tiles[id$1];
+                      this._setTileReloadTimer(id$1, tile$1);
+                    }
+                  }
+                };
+                SourceCache2.prototype.update = function update(transform) {
+                  var this$1$1 = this;
+                  this.transform = transform;
+                  if (!this._sourceLoaded || this._paused) {
+                    return;
+                  }
+                  this.updateCacheSize(transform);
+                  this.handleWrapJump(this.transform.center.lng);
+                  this._coveredTiles = {};
+                  var idealTileIDs;
+                  if (!this.used) {
+                    idealTileIDs = [];
+                  } else if (this._source.tileID) {
+                    idealTileIDs = transform.getVisibleUnwrappedCoordinates(this._source.tileID).map(function(unwrapped) {
+                      return new performance2.OverscaledTileID(unwrapped.canonical.z, unwrapped.wrap, unwrapped.canonical.z, unwrapped.canonical.x, unwrapped.canonical.y);
+                    });
+                  } else {
+                    idealTileIDs = transform.coveringTiles({
+                      tileSize: this._source.tileSize,
+                      minzoom: this._source.minzoom,
+                      maxzoom: this._source.maxzoom,
+                      roundZoom: this._source.roundZoom,
+                      reparseOverscaled: this._source.reparseOverscaled
+                    });
+                    if (this._source.hasTile) {
+                      idealTileIDs = idealTileIDs.filter(function(coord) {
+                        return this$1$1._source.hasTile(coord);
+                      });
+                    }
+                  }
+                  var zoom = transform.coveringZoomLevel(this._source);
+                  var minCoveringZoom = Math.max(zoom - SourceCache2.maxOverzooming, this._source.minzoom);
+                  var maxCoveringZoom = Math.max(zoom + SourceCache2.maxUnderzooming, this._source.minzoom);
+                  var retain = this._updateRetainedTiles(idealTileIDs, zoom);
+                  if (isRasterType(this._source.type)) {
+                    var parentsForFading = {};
+                    var fadingTiles = {};
+                    var ids = Object.keys(retain);
+                    for (var i2 = 0, list = ids; i2 < list.length; i2 += 1) {
+                      var id2 = list[i2];
+                      var tileID = retain[id2];
+                      var tile = this._tiles[id2];
+                      if (!tile || tile.fadeEndTime && tile.fadeEndTime <= performance2.browser.now()) {
+                        continue;
+                      }
+                      var parentTile = this.findLoadedParent(tileID, minCoveringZoom);
+                      if (parentTile) {
+                        this._addTile(parentTile.tileID);
+                        parentsForFading[parentTile.tileID.key] = parentTile.tileID;
+                      }
+                      fadingTiles[id2] = tileID;
+                    }
+                    this._retainLoadedChildren(fadingTiles, zoom, maxCoveringZoom, retain);
+                    for (var id$1 in parentsForFading) {
+                      if (!retain[id$1]) {
+                        this._coveredTiles[id$1] = true;
+                        retain[id$1] = parentsForFading[id$1];
+                      }
+                    }
+                  }
+                  for (var retainedId in retain) {
+                    this._tiles[retainedId].clearFadeHold();
+                  }
+                  var remove = performance2.keysDifference(this._tiles, retain);
+                  for (var i$1 = 0, list$1 = remove; i$1 < list$1.length; i$1 += 1) {
+                    var tileID$1 = list$1[i$1];
+                    var tile$1 = this._tiles[tileID$1];
+                    if (tile$1.hasSymbolBuckets && !tile$1.holdingForFade()) {
+                      tile$1.setHoldDuration(this.map._fadeDuration);
+                    } else if (!tile$1.hasSymbolBuckets || tile$1.symbolFadeFinished()) {
+                      this._removeTile(tileID$1);
+                    }
+                  }
+                  this._updateLoadedParentTileCache();
+                };
+                SourceCache2.prototype.releaseSymbolFadeTiles = function releaseSymbolFadeTiles() {
+                  for (var id2 in this._tiles) {
+                    if (this._tiles[id2].holdingForFade()) {
+                      this._removeTile(id2);
+                    }
+                  }
+                };
+                SourceCache2.prototype._updateRetainedTiles = function _updateRetainedTiles(idealTileIDs, zoom) {
+                  var retain = {};
+                  var checked = {};
+                  var minCoveringZoom = Math.max(zoom - SourceCache2.maxOverzooming, this._source.minzoom);
+                  var maxCoveringZoom = Math.max(zoom + SourceCache2.maxUnderzooming, this._source.minzoom);
+                  var missingTiles = {};
+                  for (var i2 = 0, list = idealTileIDs; i2 < list.length; i2 += 1) {
+                    var tileID = list[i2];
+                    var tile = this._addTile(tileID);
+                    retain[tileID.key] = tileID;
+                    if (tile.hasData()) {
+                      continue;
+                    }
+                    if (zoom < this._source.maxzoom) {
+                      missingTiles[tileID.key] = tileID;
+                    }
+                  }
+                  this._retainLoadedChildren(missingTiles, zoom, maxCoveringZoom, retain);
+                  for (var i$1 = 0, list$1 = idealTileIDs; i$1 < list$1.length; i$1 += 1) {
+                    var tileID$1 = list$1[i$1];
+                    var tile$1 = this._tiles[tileID$1.key];
+                    if (tile$1.hasData()) {
+                      continue;
+                    }
+                    if (zoom + 1 > this._source.maxzoom) {
+                      var childCoord = tileID$1.children(this._source.maxzoom)[0];
+                      var childTile = this.getTile(childCoord);
+                      if (!!childTile && childTile.hasData()) {
+                        retain[childCoord.key] = childCoord;
+                        continue;
+                      }
+                    } else {
+                      var children = tileID$1.children(this._source.maxzoom);
+                      if (retain[children[0].key] && retain[children[1].key] && retain[children[2].key] && retain[children[3].key]) {
+                        continue;
+                      }
+                    }
+                    var parentWasRequested = tile$1.wasRequested();
+                    for (var overscaledZ = tileID$1.overscaledZ - 1; overscaledZ >= minCoveringZoom; --overscaledZ) {
+                      var parentId = tileID$1.scaledTo(overscaledZ);
+                      if (checked[parentId.key]) {
+                        break;
+                      }
+                      checked[parentId.key] = true;
+                      tile$1 = this.getTile(parentId);
+                      if (!tile$1 && parentWasRequested) {
+                        tile$1 = this._addTile(parentId);
+                      }
+                      if (tile$1) {
+                        retain[parentId.key] = parentId;
+                        parentWasRequested = tile$1.wasRequested();
+                        if (tile$1.hasData()) {
+                          break;
+                        }
+                      }
+                    }
+                  }
+                  return retain;
+                };
+                SourceCache2.prototype._updateLoadedParentTileCache = function _updateLoadedParentTileCache() {
+                  this._loadedParentTiles = {};
+                  for (var tileKey in this._tiles) {
+                    var path = [];
+                    var parentTile = void 0;
+                    var currentId = this._tiles[tileKey].tileID;
+                    while (currentId.overscaledZ > 0) {
+                      if (currentId.key in this._loadedParentTiles) {
+                        parentTile = this._loadedParentTiles[currentId.key];
+                        break;
+                      }
+                      path.push(currentId.key);
+                      var parentId = currentId.scaledTo(currentId.overscaledZ - 1);
+                      parentTile = this._getLoadedTile(parentId);
+                      if (parentTile) {
+                        break;
+                      }
+                      currentId = parentId;
+                    }
+                    for (var i2 = 0, list = path; i2 < list.length; i2 += 1) {
+                      var key = list[i2];
+                      this._loadedParentTiles[key] = parentTile;
+                    }
+                  }
+                };
+                SourceCache2.prototype._addTile = function _addTile(tileID) {
+                  var tile = this._tiles[tileID.key];
+                  if (tile) {
+                    return tile;
+                  }
+                  tile = this._cache.getAndRemove(tileID);
+                  if (tile) {
+                    this._setTileReloadTimer(tileID.key, tile);
+                    tile.tileID = tileID;
+                    this._state.initializeTileState(tile, this.map ? this.map.painter : null);
+                    if (this._cacheTimers[tileID.key]) {
+                      clearTimeout(this._cacheTimers[tileID.key]);
+                      delete this._cacheTimers[tileID.key];
+                      this._setTileReloadTimer(tileID.key, tile);
+                    }
+                  }
+                  var cached = Boolean(tile);
+                  if (!cached) {
+                    tile = new performance2.Tile(tileID, this._source.tileSize * tileID.overscaleFactor());
+                    this._loadTile(tile, this._tileLoaded.bind(this, tile, tileID.key, tile.state));
+                  }
+                  if (!tile) {
+                    return null;
+                  }
+                  tile.uses++;
+                  this._tiles[tileID.key] = tile;
+                  if (!cached) {
+                    this._source.fire(new performance2.Event("dataloading", {
+                      tile,
+                      coord: tile.tileID,
+                      dataType: "source"
+                    }));
+                  }
+                  return tile;
+                };
+                SourceCache2.prototype._setTileReloadTimer = function _setTileReloadTimer(id2, tile) {
+                  var this$1$1 = this;
+                  if (id2 in this._timers) {
+                    clearTimeout(this._timers[id2]);
+                    delete this._timers[id2];
+                  }
+                  var expiryTimeout = tile.getExpiryTimeout();
+                  if (expiryTimeout) {
+                    this._timers[id2] = setTimeout(function() {
+                      this$1$1._reloadTile(id2, "expired");
+                      delete this$1$1._timers[id2];
+                    }, expiryTimeout);
+                  }
+                };
+                SourceCache2.prototype._removeTile = function _removeTile(id2) {
+                  var tile = this._tiles[id2];
+                  if (!tile) {
+                    return;
+                  }
+                  tile.uses--;
+                  delete this._tiles[id2];
+                  if (this._timers[id2]) {
+                    clearTimeout(this._timers[id2]);
+                    delete this._timers[id2];
+                  }
+                  if (tile.uses > 0) {
+                    return;
+                  }
+                  if (tile.hasData() && tile.state !== "reloading") {
+                    this._cache.add(tile.tileID, tile, tile.getExpiryTimeout());
+                  } else {
+                    tile.aborted = true;
+                    this._abortTile(tile);
+                    this._unloadTile(tile);
+                  }
+                };
+                SourceCache2.prototype.clearTiles = function clearTiles() {
+                  this._shouldReloadOnResume = false;
+                  this._paused = false;
+                  for (var id2 in this._tiles) {
+                    this._removeTile(id2);
+                  }
+                  this._cache.reset();
+                };
+                SourceCache2.prototype.tilesIn = function tilesIn(pointQueryGeometry, maxPitchScaleFactor, has3DLayer) {
+                  var this$1$1 = this;
+                  var tileResults = [];
+                  var transform = this.transform;
+                  if (!transform) {
+                    return tileResults;
+                  }
+                  var cameraPointQueryGeometry = has3DLayer ? transform.getCameraQueryGeometry(pointQueryGeometry) : pointQueryGeometry;
+                  var queryGeometry = pointQueryGeometry.map(function(p22) {
+                    return transform.pointCoordinate(p22);
+                  });
+                  var cameraQueryGeometry = cameraPointQueryGeometry.map(function(p22) {
+                    return transform.pointCoordinate(p22);
+                  });
+                  var ids = this.getIds();
+                  var minX = Infinity;
+                  var minY = Infinity;
+                  var maxX = -Infinity;
+                  var maxY = -Infinity;
+                  for (var i$1 = 0, list = cameraQueryGeometry; i$1 < list.length; i$1 += 1) {
+                    var p2 = list[i$1];
+                    minX = Math.min(minX, p2.x);
+                    minY = Math.min(minY, p2.y);
+                    maxX = Math.max(maxX, p2.x);
+                    maxY = Math.max(maxY, p2.y);
+                  }
+                  var loop = function(i22) {
+                    var tile = this$1$1._tiles[ids[i22]];
+                    if (tile.holdingForFade()) {
+                      return;
+                    }
+                    var tileID = tile.tileID;
+                    var scale2 = Math.pow(2, transform.zoom - tile.tileID.overscaledZ);
+                    var queryPadding = maxPitchScaleFactor * tile.queryPadding * performance2.EXTENT / tile.tileSize / scale2;
+                    var tileSpaceBounds = [
+                      tileID.getTilePoint(new performance2.MercatorCoordinate(minX, minY)),
+                      tileID.getTilePoint(new performance2.MercatorCoordinate(maxX, maxY))
+                    ];
+                    if (tileSpaceBounds[0].x - queryPadding < performance2.EXTENT && tileSpaceBounds[0].y - queryPadding < performance2.EXTENT && tileSpaceBounds[1].x + queryPadding >= 0 && tileSpaceBounds[1].y + queryPadding >= 0) {
+                      var tileSpaceQueryGeometry = queryGeometry.map(function(c2) {
+                        return tileID.getTilePoint(c2);
+                      });
+                      var tileSpaceCameraQueryGeometry = cameraQueryGeometry.map(function(c2) {
+                        return tileID.getTilePoint(c2);
+                      });
+                      tileResults.push({
+                        tile,
+                        tileID,
+                        queryGeometry: tileSpaceQueryGeometry,
+                        cameraQueryGeometry: tileSpaceCameraQueryGeometry,
+                        scale: scale2
+                      });
+                    }
+                  };
+                  for (var i2 = 0; i2 < ids.length; i2++)
+                    loop(i2);
+                  return tileResults;
+                };
+                SourceCache2.prototype.getVisibleCoordinates = function getVisibleCoordinates(symbolLayer) {
+                  var this$1$1 = this;
+                  var coords = this.getRenderableIds(symbolLayer).map(function(id2) {
+                    return this$1$1._tiles[id2].tileID;
+                  });
+                  for (var i2 = 0, list = coords; i2 < list.length; i2 += 1) {
+                    var coord = list[i2];
+                    coord.posMatrix = this.transform.calculatePosMatrix(coord.toUnwrapped());
+                  }
+                  return coords;
+                };
+                SourceCache2.prototype.hasTransition = function hasTransition() {
+                  if (this._source.hasTransition()) {
+                    return true;
+                  }
+                  if (isRasterType(this._source.type)) {
+                    for (var id2 in this._tiles) {
+                      var tile = this._tiles[id2];
+                      if (tile.fadeEndTime !== void 0 && tile.fadeEndTime >= performance2.browser.now()) {
+                        return true;
+                      }
+                    }
+                  }
+                  return false;
+                };
+                SourceCache2.prototype.setFeatureState = function setFeatureState(sourceLayer, featureId, state) {
+                  sourceLayer = sourceLayer || "_geojsonTileLayer";
+                  this._state.updateState(sourceLayer, featureId, state);
+                };
+                SourceCache2.prototype.removeFeatureState = function removeFeatureState(sourceLayer, featureId, key) {
+                  sourceLayer = sourceLayer || "_geojsonTileLayer";
+                  this._state.removeFeatureState(sourceLayer, featureId, key);
+                };
+                SourceCache2.prototype.getFeatureState = function getFeatureState(sourceLayer, featureId) {
+                  sourceLayer = sourceLayer || "_geojsonTileLayer";
+                  return this._state.getState(sourceLayer, featureId);
+                };
+                SourceCache2.prototype.setDependencies = function setDependencies(tileKey, namespace, dependencies) {
+                  var tile = this._tiles[tileKey];
+                  if (tile) {
+                    tile.setDependencies(namespace, dependencies);
+                  }
+                };
+                SourceCache2.prototype.reloadTilesForDependencies = function reloadTilesForDependencies(namespaces, keys) {
+                  for (var id2 in this._tiles) {
+                    var tile = this._tiles[id2];
+                    if (tile.hasDependency(namespaces, keys)) {
+                      this._reloadTile(id2, "reloading");
+                    }
+                  }
+                  this._cache.filter(function(tile2) {
+                    return !tile2.hasDependency(namespaces, keys);
+                  });
+                };
+                return SourceCache2;
+              }(performance2.Evented);
+              SourceCache.maxOverzooming = 10;
+              SourceCache.maxUnderzooming = 3;
+              function compareTileId(a2, b2) {
+                var aWrap = Math.abs(a2.wrap * 2) - +(a2.wrap < 0);
+                var bWrap = Math.abs(b2.wrap * 2) - +(b2.wrap < 0);
+                return a2.overscaledZ - b2.overscaledZ || bWrap - aWrap || b2.canonical.y - a2.canonical.y || b2.canonical.x - a2.canonical.x;
+              }
+              function isRasterType(type) {
+                return type === "raster" || type === "image" || type === "video";
+              }
+              function WebWorker() {
+                return new performance2.window.Worker(exported.workerUrl);
+              }
+              var PRELOAD_POOL_ID = "mapboxgl_preloaded_worker_pool";
+              var WorkerPool2 = function WorkerPool22() {
+                this.active = {};
+              };
+              WorkerPool2.prototype.acquire = function acquire(mapId) {
+                if (!this.workers) {
+                  this.workers = [];
+                  while (this.workers.length < WorkerPool2.workerCount) {
+                    this.workers.push(new WebWorker());
+                  }
+                }
+                this.active[mapId] = true;
+                return this.workers.slice();
+              };
+              WorkerPool2.prototype.release = function release(mapId) {
+                delete this.active[mapId];
+                if (this.numActive() === 0) {
+                  this.workers.forEach(function(w2) {
+                    w2.terminate();
+                  });
+                  this.workers = null;
+                }
+              };
+              WorkerPool2.prototype.isPreloaded = function isPreloaded() {
+                return !!this.active[PRELOAD_POOL_ID];
+              };
+              WorkerPool2.prototype.numActive = function numActive() {
+                return Object.keys(this.active).length;
+              };
+              var availableLogicalProcessors = Math.floor(performance2.browser.hardwareConcurrency / 2);
+              WorkerPool2.workerCount = Math.max(Math.min(availableLogicalProcessors, 6), 1);
+              var globalWorkerPool;
+              function getGlobalWorkerPool() {
+                if (!globalWorkerPool) {
+                  globalWorkerPool = new WorkerPool2();
+                }
+                return globalWorkerPool;
+              }
+              function prewarm() {
+                var workerPool = getGlobalWorkerPool();
+                workerPool.acquire(PRELOAD_POOL_ID);
+              }
+              function clearPrewarmedResources() {
+                var pool = globalWorkerPool;
+                if (pool) {
+                  if (pool.isPreloaded() && pool.numActive() === 1) {
+                    pool.release(PRELOAD_POOL_ID);
+                    globalWorkerPool = null;
+                  } else {
+                    console.warn("Could not clear WebWorkers since there are active Map instances that still reference it. The pre-warmed WebWorker pool can only be cleared when all map instances have been removed with map.remove()");
+                  }
+                }
+              }
+              function deref(layer, parent) {
+                var result = {};
+                for (var k2 in layer) {
+                  if (k2 !== "ref") {
+                    result[k2] = layer[k2];
+                  }
+                }
+                performance2.refProperties.forEach(function(k22) {
+                  if (k22 in parent) {
+                    result[k22] = parent[k22];
+                  }
+                });
+                return result;
+              }
+              function derefLayers(layers) {
+                layers = layers.slice();
+                var map2 = /* @__PURE__ */ Object.create(null);
+                for (var i2 = 0; i2 < layers.length; i2++) {
+                  map2[layers[i2].id] = layers[i2];
+                }
+                for (var i$1 = 0; i$1 < layers.length; i$1++) {
+                  if ("ref" in layers[i$1]) {
+                    layers[i$1] = deref(layers[i$1], map2[layers[i$1].ref]);
+                  }
+                }
+                return layers;
+              }
+              function emptyStyle() {
+                var style = {};
+                var version2 = performance2.styleSpec["$version"];
+                for (var styleKey in performance2.styleSpec["$root"]) {
+                  var spec = performance2.styleSpec["$root"][styleKey];
+                  if (spec.required) {
+                    var value = null;
+                    if (styleKey === "version") {
+                      value = version2;
+                    } else {
+                      if (spec.type === "array") {
+                        value = [];
+                      } else {
+                        value = {};
+                      }
+                    }
+                    if (value != null) {
+                      style[styleKey] = value;
+                    }
+                  }
+                }
+                return style;
+              }
+              var operations = {
+                setStyle: "setStyle",
+                addLayer: "addLayer",
+                removeLayer: "removeLayer",
+                setPaintProperty: "setPaintProperty",
+                setLayoutProperty: "setLayoutProperty",
+                setFilter: "setFilter",
+                addSource: "addSource",
+                removeSource: "removeSource",
+                setGeoJSONSourceData: "setGeoJSONSourceData",
+                setLayerZoomRange: "setLayerZoomRange",
+                setLayerProperty: "setLayerProperty",
+                setCenter: "setCenter",
+                setZoom: "setZoom",
+                setBearing: "setBearing",
+                setPitch: "setPitch",
+                setSprite: "setSprite",
+                setGlyphs: "setGlyphs",
+                setTransition: "setTransition",
+                setLight: "setLight"
+              };
+              function addSource(sourceId, after, commands) {
+                commands.push({
+                  command: operations.addSource,
+                  args: [
+                    sourceId,
+                    after[sourceId]
+                  ]
+                });
+              }
+              function removeSource(sourceId, commands, sourcesRemoved) {
+                commands.push({
+                  command: operations.removeSource,
+                  args: [sourceId]
+                });
+                sourcesRemoved[sourceId] = true;
+              }
+              function updateSource(sourceId, after, commands, sourcesRemoved) {
+                removeSource(sourceId, commands, sourcesRemoved);
+                addSource(sourceId, after, commands);
+              }
+              function canUpdateGeoJSON(before, after, sourceId) {
+                var prop;
+                for (prop in before[sourceId]) {
+                  if (!before[sourceId].hasOwnProperty(prop)) {
+                    continue;
+                  }
+                  if (prop !== "data" && !performance2.deepEqual(before[sourceId][prop], after[sourceId][prop])) {
+                    return false;
+                  }
+                }
+                for (prop in after[sourceId]) {
+                  if (!after[sourceId].hasOwnProperty(prop)) {
+                    continue;
+                  }
+                  if (prop !== "data" && !performance2.deepEqual(before[sourceId][prop], after[sourceId][prop])) {
+                    return false;
+                  }
+                }
+                return true;
+              }
+              function diffSources(before, after, commands, sourcesRemoved) {
+                before = before || {};
+                after = after || {};
+                var sourceId;
+                for (sourceId in before) {
+                  if (!before.hasOwnProperty(sourceId)) {
+                    continue;
+                  }
+                  if (!after.hasOwnProperty(sourceId)) {
+                    removeSource(sourceId, commands, sourcesRemoved);
+                  }
+                }
+                for (sourceId in after) {
+                  if (!after.hasOwnProperty(sourceId)) {
+                    continue;
+                  }
+                  if (!before.hasOwnProperty(sourceId)) {
+                    addSource(sourceId, after, commands);
+                  } else if (!performance2.deepEqual(before[sourceId], after[sourceId])) {
+                    if (before[sourceId].type === "geojson" && after[sourceId].type === "geojson" && canUpdateGeoJSON(before, after, sourceId)) {
+                      commands.push({
+                        command: operations.setGeoJSONSourceData,
+                        args: [
+                          sourceId,
+                          after[sourceId].data
+                        ]
+                      });
+                    } else {
+                      updateSource(sourceId, after, commands, sourcesRemoved);
+                    }
+                  }
+                }
+              }
+              function diffLayerPropertyChanges(before, after, commands, layerId, klass, command) {
+                before = before || {};
+                after = after || {};
+                var prop;
+                for (prop in before) {
+                  if (!before.hasOwnProperty(prop)) {
+                    continue;
+                  }
+                  if (!performance2.deepEqual(before[prop], after[prop])) {
+                    commands.push({
+                      command,
+                      args: [
+                        layerId,
+                        prop,
+                        after[prop],
+                        klass
+                      ]
+                    });
+                  }
+                }
+                for (prop in after) {
+                  if (!after.hasOwnProperty(prop) || before.hasOwnProperty(prop)) {
+                    continue;
+                  }
+                  if (!performance2.deepEqual(before[prop], after[prop])) {
+                    commands.push({
+                      command,
+                      args: [
+                        layerId,
+                        prop,
+                        after[prop],
+                        klass
+                      ]
+                    });
+                  }
+                }
+              }
+              function pluckId(layer) {
+                return layer.id;
+              }
+              function indexById(group, layer) {
+                group[layer.id] = layer;
+                return group;
+              }
+              function diffLayers(before, after, commands) {
+                before = before || [];
+                after = after || [];
+                var beforeOrder = before.map(pluckId);
+                var afterOrder = after.map(pluckId);
+                var beforeIndex = before.reduce(indexById, {});
+                var afterIndex = after.reduce(indexById, {});
+                var tracker = beforeOrder.slice();
+                var clean = /* @__PURE__ */ Object.create(null);
+                var i2, d2, layerId, beforeLayer, afterLayer, insertBeforeLayerId, prop;
+                for (i2 = 0, d2 = 0; i2 < beforeOrder.length; i2++) {
+                  layerId = beforeOrder[i2];
+                  if (!afterIndex.hasOwnProperty(layerId)) {
+                    commands.push({
+                      command: operations.removeLayer,
+                      args: [layerId]
+                    });
+                    tracker.splice(tracker.indexOf(layerId, d2), 1);
+                  } else {
+                    d2++;
+                  }
+                }
+                for (i2 = 0, d2 = 0; i2 < afterOrder.length; i2++) {
+                  layerId = afterOrder[afterOrder.length - 1 - i2];
+                  if (tracker[tracker.length - 1 - i2] === layerId) {
+                    continue;
+                  }
+                  if (beforeIndex.hasOwnProperty(layerId)) {
+                    commands.push({
+                      command: operations.removeLayer,
+                      args: [layerId]
+                    });
+                    tracker.splice(tracker.lastIndexOf(layerId, tracker.length - d2), 1);
+                  } else {
+                    d2++;
+                  }
+                  insertBeforeLayerId = tracker[tracker.length - i2];
+                  commands.push({
+                    command: operations.addLayer,
+                    args: [
+                      afterIndex[layerId],
+                      insertBeforeLayerId
+                    ]
+                  });
+                  tracker.splice(tracker.length - i2, 0, layerId);
+                  clean[layerId] = true;
+                }
+                for (i2 = 0; i2 < afterOrder.length; i2++) {
+                  layerId = afterOrder[i2];
+                  beforeLayer = beforeIndex[layerId];
+                  afterLayer = afterIndex[layerId];
+                  if (clean[layerId] || performance2.deepEqual(beforeLayer, afterLayer)) {
+                    continue;
+                  }
+                  if (!performance2.deepEqual(beforeLayer.source, afterLayer.source) || !performance2.deepEqual(beforeLayer["source-layer"], afterLayer["source-layer"]) || !performance2.deepEqual(beforeLayer.type, afterLayer.type)) {
+                    commands.push({
+                      command: operations.removeLayer,
+                      args: [layerId]
+                    });
+                    insertBeforeLayerId = tracker[tracker.lastIndexOf(layerId) + 1];
+                    commands.push({
+                      command: operations.addLayer,
+                      args: [
+                        afterLayer,
+                        insertBeforeLayerId
+                      ]
+                    });
+                    continue;
+                  }
+                  diffLayerPropertyChanges(beforeLayer.layout, afterLayer.layout, commands, layerId, null, operations.setLayoutProperty);
+                  diffLayerPropertyChanges(beforeLayer.paint, afterLayer.paint, commands, layerId, null, operations.setPaintProperty);
+                  if (!performance2.deepEqual(beforeLayer.filter, afterLayer.filter)) {
+                    commands.push({
+                      command: operations.setFilter,
+                      args: [
+                        layerId,
+                        afterLayer.filter
+                      ]
+                    });
+                  }
+                  if (!performance2.deepEqual(beforeLayer.minzoom, afterLayer.minzoom) || !performance2.deepEqual(beforeLayer.maxzoom, afterLayer.maxzoom)) {
+                    commands.push({
+                      command: operations.setLayerZoomRange,
+                      args: [
+                        layerId,
+                        afterLayer.minzoom,
+                        afterLayer.maxzoom
+                      ]
+                    });
+                  }
+                  for (prop in beforeLayer) {
+                    if (!beforeLayer.hasOwnProperty(prop)) {
+                      continue;
+                    }
+                    if (prop === "layout" || prop === "paint" || prop === "filter" || prop === "metadata" || prop === "minzoom" || prop === "maxzoom") {
+                      continue;
+                    }
+                    if (prop.indexOf("paint.") === 0) {
+                      diffLayerPropertyChanges(beforeLayer[prop], afterLayer[prop], commands, layerId, prop.slice(6), operations.setPaintProperty);
+                    } else if (!performance2.deepEqual(beforeLayer[prop], afterLayer[prop])) {
+                      commands.push({
+                        command: operations.setLayerProperty,
+                        args: [
+                          layerId,
+                          prop,
+                          afterLayer[prop]
+                        ]
+                      });
+                    }
+                  }
+                  for (prop in afterLayer) {
+                    if (!afterLayer.hasOwnProperty(prop) || beforeLayer.hasOwnProperty(prop)) {
+                      continue;
+                    }
+                    if (prop === "layout" || prop === "paint" || prop === "filter" || prop === "metadata" || prop === "minzoom" || prop === "maxzoom") {
+                      continue;
+                    }
+                    if (prop.indexOf("paint.") === 0) {
+                      diffLayerPropertyChanges(beforeLayer[prop], afterLayer[prop], commands, layerId, prop.slice(6), operations.setPaintProperty);
+                    } else if (!performance2.deepEqual(beforeLayer[prop], afterLayer[prop])) {
+                      commands.push({
+                        command: operations.setLayerProperty,
+                        args: [
+                          layerId,
+                          prop,
+                          afterLayer[prop]
+                        ]
+                      });
+                    }
+                  }
+                }
+              }
+              function diffStyles(before, after) {
+                if (!before) {
+                  return [{
+                    command: operations.setStyle,
+                    args: [after]
+                  }];
+                }
+                var commands = [];
+                try {
+                  if (!performance2.deepEqual(before.version, after.version)) {
+                    return [{
+                      command: operations.setStyle,
+                      args: [after]
+                    }];
+                  }
+                  if (!performance2.deepEqual(before.center, after.center)) {
+                    commands.push({
+                      command: operations.setCenter,
+                      args: [after.center]
+                    });
+                  }
+                  if (!performance2.deepEqual(before.zoom, after.zoom)) {
+                    commands.push({
+                      command: operations.setZoom,
+                      args: [after.zoom]
+                    });
+                  }
+                  if (!performance2.deepEqual(before.bearing, after.bearing)) {
+                    commands.push({
+                      command: operations.setBearing,
+                      args: [after.bearing]
+                    });
+                  }
+                  if (!performance2.deepEqual(before.pitch, after.pitch)) {
+                    commands.push({
+                      command: operations.setPitch,
+                      args: [after.pitch]
+                    });
+                  }
+                  if (!performance2.deepEqual(before.sprite, after.sprite)) {
+                    commands.push({
+                      command: operations.setSprite,
+                      args: [after.sprite]
+                    });
+                  }
+                  if (!performance2.deepEqual(before.glyphs, after.glyphs)) {
+                    commands.push({
+                      command: operations.setGlyphs,
+                      args: [after.glyphs]
+                    });
+                  }
+                  if (!performance2.deepEqual(before.transition, after.transition)) {
+                    commands.push({
+                      command: operations.setTransition,
+                      args: [after.transition]
+                    });
+                  }
+                  if (!performance2.deepEqual(before.light, after.light)) {
+                    commands.push({
+                      command: operations.setLight,
+                      args: [after.light]
+                    });
+                  }
+                  var sourcesRemoved = {};
+                  var removeOrAddSourceCommands = [];
+                  diffSources(before.sources, after.sources, removeOrAddSourceCommands, sourcesRemoved);
+                  var beforeLayers = [];
+                  if (before.layers) {
+                    before.layers.forEach(function(layer) {
+                      if (sourcesRemoved[layer.source]) {
+                        commands.push({
+                          command: operations.removeLayer,
+                          args: [layer.id]
+                        });
+                      } else {
+                        beforeLayers.push(layer);
+                      }
+                    });
+                  }
+                  commands = commands.concat(removeOrAddSourceCommands);
+                  diffLayers(beforeLayers, after.layers, commands);
+                } catch (e2) {
+                  console.warn("Unable to compute style diff:", e2);
+                  commands = [{
+                    command: operations.setStyle,
+                    args: [after]
+                  }];
+                }
+                return commands;
+              }
+              var PathInterpolator = function PathInterpolator2(points_, padding_) {
+                this.reset(points_, padding_);
+              };
+              PathInterpolator.prototype.reset = function reset(points_, padding_) {
+                this.points = points_ || [];
+                this._distances = [0];
+                for (var i2 = 1; i2 < this.points.length; i2++) {
+                  this._distances[i2] = this._distances[i2 - 1] + this.points[i2].dist(this.points[i2 - 1]);
+                }
+                this.length = this._distances[this._distances.length - 1];
+                this.padding = Math.min(padding_ || 0, this.length * 0.5);
+                this.paddedLength = this.length - this.padding * 2;
+              };
+              PathInterpolator.prototype.lerp = function lerp2(t4) {
+                if (this.points.length === 1) {
+                  return this.points[0];
+                }
+                t4 = performance2.clamp(t4, 0, 1);
+                var currentIndex = 1;
+                var distOfCurrentIdx = this._distances[currentIndex];
+                var distToTarget = t4 * this.paddedLength + this.padding;
+                while (distOfCurrentIdx < distToTarget && currentIndex < this._distances.length) {
+                  distOfCurrentIdx = this._distances[++currentIndex];
+                }
+                var idxOfPrevPoint = currentIndex - 1;
+                var distOfPrevIdx = this._distances[idxOfPrevPoint];
+                var segmentLength = distOfCurrentIdx - distOfPrevIdx;
+                var segmentT = segmentLength > 0 ? (distToTarget - distOfPrevIdx) / segmentLength : 0;
+                return this.points[idxOfPrevPoint].mult(1 - segmentT).add(this.points[currentIndex].mult(segmentT));
+              };
+              var GridIndex = function GridIndex2(width, height, cellSize) {
+                var boxCells = this.boxCells = [];
+                var circleCells = this.circleCells = [];
+                this.xCellCount = Math.ceil(width / cellSize);
+                this.yCellCount = Math.ceil(height / cellSize);
+                for (var i2 = 0; i2 < this.xCellCount * this.yCellCount; i2++) {
+                  boxCells.push([]);
+                  circleCells.push([]);
+                }
+                this.circleKeys = [];
+                this.boxKeys = [];
+                this.bboxes = [];
+                this.circles = [];
+                this.width = width;
+                this.height = height;
+                this.xScale = this.xCellCount / width;
+                this.yScale = this.yCellCount / height;
+                this.boxUid = 0;
+                this.circleUid = 0;
+              };
+              GridIndex.prototype.keysLength = function keysLength() {
+                return this.boxKeys.length + this.circleKeys.length;
+              };
+              GridIndex.prototype.insert = function insert(key, x1, y1, x2, y2) {
+                this._forEachCell(x1, y1, x2, y2, this._insertBoxCell, this.boxUid++);
+                this.boxKeys.push(key);
+                this.bboxes.push(x1);
+                this.bboxes.push(y1);
+                this.bboxes.push(x2);
+                this.bboxes.push(y2);
+              };
+              GridIndex.prototype.insertCircle = function insertCircle(key, x2, y2, radius) {
+                this._forEachCell(x2 - radius, y2 - radius, x2 + radius, y2 + radius, this._insertCircleCell, this.circleUid++);
+                this.circleKeys.push(key);
+                this.circles.push(x2);
+                this.circles.push(y2);
+                this.circles.push(radius);
+              };
+              GridIndex.prototype._insertBoxCell = function _insertBoxCell(x1, y1, x2, y2, cellIndex, uid2) {
+                this.boxCells[cellIndex].push(uid2);
+              };
+              GridIndex.prototype._insertCircleCell = function _insertCircleCell(x1, y1, x2, y2, cellIndex, uid2) {
+                this.circleCells[cellIndex].push(uid2);
+              };
+              GridIndex.prototype._query = function _query(x1, y1, x2, y2, hitTest, predicate) {
+                if (x2 < 0 || x1 > this.width || y2 < 0 || y1 > this.height) {
+                  return hitTest ? false : [];
+                }
+                var result = [];
+                if (x1 <= 0 && y1 <= 0 && this.width <= x2 && this.height <= y2) {
+                  if (hitTest) {
+                    return true;
+                  }
+                  for (var boxUid = 0; boxUid < this.boxKeys.length; boxUid++) {
+                    result.push({
+                      key: this.boxKeys[boxUid],
+                      x1: this.bboxes[boxUid * 4],
+                      y1: this.bboxes[boxUid * 4 + 1],
+                      x2: this.bboxes[boxUid * 4 + 2],
+                      y2: this.bboxes[boxUid * 4 + 3]
+                    });
+                  }
+                  for (var circleUid = 0; circleUid < this.circleKeys.length; circleUid++) {
+                    var x3 = this.circles[circleUid * 3];
+                    var y3 = this.circles[circleUid * 3 + 1];
+                    var radius = this.circles[circleUid * 3 + 2];
+                    result.push({
+                      key: this.circleKeys[circleUid],
+                      x1: x3 - radius,
+                      y1: y3 - radius,
+                      x2: x3 + radius,
+                      y2: y3 + radius
+                    });
+                  }
+                  return predicate ? result.filter(predicate) : result;
+                } else {
+                  var queryArgs = {
+                    hitTest,
+                    seenUids: {
+                      box: {},
+                      circle: {}
+                    }
+                  };
+                  this._forEachCell(x1, y1, x2, y2, this._queryCell, result, queryArgs, predicate);
+                  return hitTest ? result.length > 0 : result;
+                }
+              };
+              GridIndex.prototype._queryCircle = function _queryCircle(x2, y2, radius, hitTest, predicate) {
+                var x1 = x2 - radius;
+                var x22 = x2 + radius;
+                var y1 = y2 - radius;
+                var y22 = y2 + radius;
+                if (x22 < 0 || x1 > this.width || y22 < 0 || y1 > this.height) {
+                  return hitTest ? false : [];
+                }
+                var result = [];
+                var queryArgs = {
+                  hitTest,
+                  circle: {
+                    x: x2,
+                    y: y2,
+                    radius
+                  },
+                  seenUids: {
+                    box: {},
+                    circle: {}
+                  }
+                };
+                this._forEachCell(x1, y1, x22, y22, this._queryCellCircle, result, queryArgs, predicate);
+                return hitTest ? result.length > 0 : result;
+              };
+              GridIndex.prototype.query = function query(x1, y1, x2, y2, predicate) {
+                return this._query(x1, y1, x2, y2, false, predicate);
+              };
+              GridIndex.prototype.hitTest = function hitTest(x1, y1, x2, y2, predicate) {
+                return this._query(x1, y1, x2, y2, true, predicate);
+              };
+              GridIndex.prototype.hitTestCircle = function hitTestCircle(x2, y2, radius, predicate) {
+                return this._queryCircle(x2, y2, radius, true, predicate);
+              };
+              GridIndex.prototype._queryCell = function _queryCell(x1, y1, x2, y2, cellIndex, result, queryArgs, predicate) {
+                var seenUids = queryArgs.seenUids;
+                var boxCell = this.boxCells[cellIndex];
+                if (boxCell !== null) {
+                  var bboxes = this.bboxes;
+                  for (var i2 = 0, list = boxCell; i2 < list.length; i2 += 1) {
+                    var boxUid = list[i2];
+                    if (!seenUids.box[boxUid]) {
+                      seenUids.box[boxUid] = true;
+                      var offset = boxUid * 4;
+                      if (x1 <= bboxes[offset + 2] && y1 <= bboxes[offset + 3] && x2 >= bboxes[offset + 0] && y2 >= bboxes[offset + 1] && (!predicate || predicate(this.boxKeys[boxUid]))) {
+                        if (queryArgs.hitTest) {
+                          result.push(true);
+                          return true;
+                        } else {
+                          result.push({
+                            key: this.boxKeys[boxUid],
+                            x1: bboxes[offset],
+                            y1: bboxes[offset + 1],
+                            x2: bboxes[offset + 2],
+                            y2: bboxes[offset + 3]
+                          });
+                        }
+                      }
+                    }
+                  }
+                }
+                var circleCell = this.circleCells[cellIndex];
+                if (circleCell !== null) {
+                  var circles = this.circles;
+                  for (var i$1 = 0, list$1 = circleCell; i$1 < list$1.length; i$1 += 1) {
+                    var circleUid = list$1[i$1];
+                    if (!seenUids.circle[circleUid]) {
+                      seenUids.circle[circleUid] = true;
+                      var offset$1 = circleUid * 3;
+                      if (this._circleAndRectCollide(circles[offset$1], circles[offset$1 + 1], circles[offset$1 + 2], x1, y1, x2, y2) && (!predicate || predicate(this.circleKeys[circleUid]))) {
+                        if (queryArgs.hitTest) {
+                          result.push(true);
+                          return true;
+                        } else {
+                          var x3 = circles[offset$1];
+                          var y3 = circles[offset$1 + 1];
+                          var radius = circles[offset$1 + 2];
+                          result.push({
+                            key: this.circleKeys[circleUid],
+                            x1: x3 - radius,
+                            y1: y3 - radius,
+                            x2: x3 + radius,
+                            y2: y3 + radius
+                          });
+                        }
+                      }
+                    }
+                  }
+                }
+              };
+              GridIndex.prototype._queryCellCircle = function _queryCellCircle(x1, y1, x2, y2, cellIndex, result, queryArgs, predicate) {
+                var circle2 = queryArgs.circle;
+                var seenUids = queryArgs.seenUids;
+                var boxCell = this.boxCells[cellIndex];
+                if (boxCell !== null) {
+                  var bboxes = this.bboxes;
+                  for (var i2 = 0, list = boxCell; i2 < list.length; i2 += 1) {
+                    var boxUid = list[i2];
+                    if (!seenUids.box[boxUid]) {
+                      seenUids.box[boxUid] = true;
+                      var offset = boxUid * 4;
+                      if (this._circleAndRectCollide(circle2.x, circle2.y, circle2.radius, bboxes[offset + 0], bboxes[offset + 1], bboxes[offset + 2], bboxes[offset + 3]) && (!predicate || predicate(this.boxKeys[boxUid]))) {
+                        result.push(true);
+                        return true;
+                      }
+                    }
+                  }
+                }
+                var circleCell = this.circleCells[cellIndex];
+                if (circleCell !== null) {
+                  var circles = this.circles;
+                  for (var i$1 = 0, list$1 = circleCell; i$1 < list$1.length; i$1 += 1) {
+                    var circleUid = list$1[i$1];
+                    if (!seenUids.circle[circleUid]) {
+                      seenUids.circle[circleUid] = true;
+                      var offset$1 = circleUid * 3;
+                      if (this._circlesCollide(circles[offset$1], circles[offset$1 + 1], circles[offset$1 + 2], circle2.x, circle2.y, circle2.radius) && (!predicate || predicate(this.circleKeys[circleUid]))) {
+                        result.push(true);
+                        return true;
+                      }
+                    }
+                  }
+                }
+              };
+              GridIndex.prototype._forEachCell = function _forEachCell(x1, y1, x2, y2, fn, arg1, arg2, predicate) {
+                var cx1 = this._convertToXCellCoord(x1);
+                var cy1 = this._convertToYCellCoord(y1);
+                var cx2 = this._convertToXCellCoord(x2);
+                var cy2 = this._convertToYCellCoord(y2);
+                for (var x3 = cx1; x3 <= cx2; x3++) {
+                  for (var y3 = cy1; y3 <= cy2; y3++) {
+                    var cellIndex = this.xCellCount * y3 + x3;
+                    if (fn.call(this, x1, y1, x2, y2, cellIndex, arg1, arg2, predicate)) {
+                      return;
+                    }
+                  }
+                }
+              };
+              GridIndex.prototype._convertToXCellCoord = function _convertToXCellCoord(x2) {
+                return Math.max(0, Math.min(this.xCellCount - 1, Math.floor(x2 * this.xScale)));
+              };
+              GridIndex.prototype._convertToYCellCoord = function _convertToYCellCoord(y2) {
+                return Math.max(0, Math.min(this.yCellCount - 1, Math.floor(y2 * this.yScale)));
+              };
+              GridIndex.prototype._circlesCollide = function _circlesCollide(x1, y1, r1, x2, y2, r2) {
+                var dx = x2 - x1;
+                var dy = y2 - y1;
+                var bothRadii = r1 + r2;
+                return bothRadii * bothRadii > dx * dx + dy * dy;
+              };
+              GridIndex.prototype._circleAndRectCollide = function _circleAndRectCollide(circleX, circleY, radius, x1, y1, x2, y2) {
+                var halfRectWidth = (x2 - x1) / 2;
+                var distX = Math.abs(circleX - (x1 + halfRectWidth));
+                if (distX > halfRectWidth + radius) {
+                  return false;
+                }
+                var halfRectHeight = (y2 - y1) / 2;
+                var distY = Math.abs(circleY - (y1 + halfRectHeight));
+                if (distY > halfRectHeight + radius) {
+                  return false;
+                }
+                if (distX <= halfRectWidth || distY <= halfRectHeight) {
+                  return true;
+                }
+                var dx = distX - halfRectWidth;
+                var dy = distY - halfRectHeight;
+                return dx * dx + dy * dy <= radius * radius;
+              };
+              function getLabelPlaneMatrix(posMatrix, pitchWithMap, rotateWithMap, transform, pixelsToTileUnits2) {
+                var m2 = performance2.create();
+                if (pitchWithMap) {
+                  performance2.scale(m2, m2, [
+                    1 / pixelsToTileUnits2,
+                    1 / pixelsToTileUnits2,
+                    1
+                  ]);
+                  if (!rotateWithMap) {
+                    performance2.rotateZ(m2, m2, transform.angle);
+                  }
+                } else {
+                  performance2.multiply(m2, transform.labelPlaneMatrix, posMatrix);
+                }
+                return m2;
+              }
+              function getGlCoordMatrix(posMatrix, pitchWithMap, rotateWithMap, transform, pixelsToTileUnits2) {
+                if (pitchWithMap) {
+                  var m2 = performance2.clone(posMatrix);
+                  performance2.scale(m2, m2, [
+                    pixelsToTileUnits2,
+                    pixelsToTileUnits2,
+                    1
+                  ]);
+                  if (!rotateWithMap) {
+                    performance2.rotateZ(m2, m2, -transform.angle);
+                  }
+                  return m2;
+                } else {
+                  return transform.glCoordMatrix;
+                }
+              }
+              function project2(point, matrix) {
+                var pos = [
+                  point.x,
+                  point.y,
+                  0,
+                  1
+                ];
+                xyTransformMat4(pos, pos, matrix);
+                var w2 = pos[3];
+                return {
+                  point: new performance2.Point(pos[0] / w2, pos[1] / w2),
+                  signedDistanceFromCamera: w2
+                };
+              }
+              function getPerspectiveRatio(cameraToCenterDistance, signedDistanceFromCamera) {
+                return 0.5 + 0.5 * (cameraToCenterDistance / signedDistanceFromCamera);
+              }
+              function isVisible(anchorPos, clippingBuffer) {
+                var x2 = anchorPos[0] / anchorPos[3];
+                var y2 = anchorPos[1] / anchorPos[3];
+                var inPaddedViewport = x2 >= -clippingBuffer[0] && x2 <= clippingBuffer[0] && y2 >= -clippingBuffer[1] && y2 <= clippingBuffer[1];
+                return inPaddedViewport;
+              }
+              function updateLineLabels(bucket, posMatrix, painter, isText, labelPlaneMatrix, glCoordMatrix, pitchWithMap, keepUpright) {
+                var sizeData = isText ? bucket.textSizeData : bucket.iconSizeData;
+                var partiallyEvaluatedSize = performance2.evaluateSizeForZoom(sizeData, painter.transform.zoom);
+                var clippingBuffer = [
+                  256 / painter.width * 2 + 1,
+                  256 / painter.height * 2 + 1
+                ];
+                var dynamicLayoutVertexArray = isText ? bucket.text.dynamicLayoutVertexArray : bucket.icon.dynamicLayoutVertexArray;
+                dynamicLayoutVertexArray.clear();
+                var lineVertexArray = bucket.lineVertexArray;
+                var placedSymbols = isText ? bucket.text.placedSymbolArray : bucket.icon.placedSymbolArray;
+                var aspectRatio = painter.transform.width / painter.transform.height;
+                var useVertical = false;
+                for (var s2 = 0; s2 < placedSymbols.length; s2++) {
+                  var symbol = placedSymbols.get(s2);
+                  if (symbol.hidden || symbol.writingMode === performance2.WritingMode.vertical && !useVertical) {
+                    hideGlyphs(symbol.numGlyphs, dynamicLayoutVertexArray);
+                    continue;
+                  }
+                  useVertical = false;
+                  var anchorPos = [
+                    symbol.anchorX,
+                    symbol.anchorY,
+                    0,
+                    1
+                  ];
+                  performance2.transformMat4(anchorPos, anchorPos, posMatrix);
+                  if (!isVisible(anchorPos, clippingBuffer)) {
+                    hideGlyphs(symbol.numGlyphs, dynamicLayoutVertexArray);
+                    continue;
+                  }
+                  var cameraToAnchorDistance = anchorPos[3];
+                  var perspectiveRatio = getPerspectiveRatio(painter.transform.cameraToCenterDistance, cameraToAnchorDistance);
+                  var fontSize = performance2.evaluateSizeForFeature(sizeData, partiallyEvaluatedSize, symbol);
+                  var pitchScaledFontSize = pitchWithMap ? fontSize / perspectiveRatio : fontSize * perspectiveRatio;
+                  var tileAnchorPoint = new performance2.Point(symbol.anchorX, symbol.anchorY);
+                  var anchorPoint = project2(tileAnchorPoint, labelPlaneMatrix).point;
+                  var projectionCache = {};
+                  var placeUnflipped = placeGlyphsAlongLine(symbol, pitchScaledFontSize, false, keepUpright, posMatrix, labelPlaneMatrix, glCoordMatrix, bucket.glyphOffsetArray, lineVertexArray, dynamicLayoutVertexArray, anchorPoint, tileAnchorPoint, projectionCache, aspectRatio);
+                  useVertical = placeUnflipped.useVertical;
+                  if (placeUnflipped.notEnoughRoom || useVertical || placeUnflipped.needsFlipping && placeGlyphsAlongLine(symbol, pitchScaledFontSize, true, keepUpright, posMatrix, labelPlaneMatrix, glCoordMatrix, bucket.glyphOffsetArray, lineVertexArray, dynamicLayoutVertexArray, anchorPoint, tileAnchorPoint, projectionCache, aspectRatio).notEnoughRoom) {
+                    hideGlyphs(symbol.numGlyphs, dynamicLayoutVertexArray);
+                  }
+                }
+                if (isText) {
+                  bucket.text.dynamicLayoutVertexBuffer.updateData(dynamicLayoutVertexArray);
+                } else {
+                  bucket.icon.dynamicLayoutVertexBuffer.updateData(dynamicLayoutVertexArray);
+                }
+              }
+              function placeFirstAndLastGlyph(fontScale, glyphOffsetArray, lineOffsetX, lineOffsetY, flip, anchorPoint, tileAnchorPoint, symbol, lineVertexArray, labelPlaneMatrix, projectionCache) {
+                var glyphEndIndex = symbol.glyphStartIndex + symbol.numGlyphs;
+                var lineStartIndex = symbol.lineStartIndex;
+                var lineEndIndex = symbol.lineStartIndex + symbol.lineLength;
+                var firstGlyphOffset = glyphOffsetArray.getoffsetX(symbol.glyphStartIndex);
+                var lastGlyphOffset = glyphOffsetArray.getoffsetX(glyphEndIndex - 1);
+                var firstPlacedGlyph = placeGlyphAlongLine(fontScale * firstGlyphOffset, lineOffsetX, lineOffsetY, flip, anchorPoint, tileAnchorPoint, symbol.segment, lineStartIndex, lineEndIndex, lineVertexArray, labelPlaneMatrix, projectionCache);
+                if (!firstPlacedGlyph) {
+                  return null;
+                }
+                var lastPlacedGlyph = placeGlyphAlongLine(fontScale * lastGlyphOffset, lineOffsetX, lineOffsetY, flip, anchorPoint, tileAnchorPoint, symbol.segment, lineStartIndex, lineEndIndex, lineVertexArray, labelPlaneMatrix, projectionCache);
+                if (!lastPlacedGlyph) {
+                  return null;
+                }
+                return {
+                  first: firstPlacedGlyph,
+                  last: lastPlacedGlyph
+                };
+              }
+              function requiresOrientationChange(writingMode, firstPoint, lastPoint, aspectRatio) {
+                if (writingMode === performance2.WritingMode.horizontal) {
+                  var rise = Math.abs(lastPoint.y - firstPoint.y);
+                  var run = Math.abs(lastPoint.x - firstPoint.x) * aspectRatio;
+                  if (rise > run) {
+                    return { useVertical: true };
+                  }
+                }
+                if (writingMode === performance2.WritingMode.vertical ? firstPoint.y < lastPoint.y : firstPoint.x > lastPoint.x) {
+                  return { needsFlipping: true };
+                }
+                return null;
+              }
+              function placeGlyphsAlongLine(symbol, fontSize, flip, keepUpright, posMatrix, labelPlaneMatrix, glCoordMatrix, glyphOffsetArray, lineVertexArray, dynamicLayoutVertexArray, anchorPoint, tileAnchorPoint, projectionCache, aspectRatio) {
+                var fontScale = fontSize / 24;
+                var lineOffsetX = symbol.lineOffsetX * fontScale;
+                var lineOffsetY = symbol.lineOffsetY * fontScale;
+                var placedGlyphs;
+                if (symbol.numGlyphs > 1) {
+                  var glyphEndIndex = symbol.glyphStartIndex + symbol.numGlyphs;
+                  var lineStartIndex = symbol.lineStartIndex;
+                  var lineEndIndex = symbol.lineStartIndex + symbol.lineLength;
+                  var firstAndLastGlyph = placeFirstAndLastGlyph(fontScale, glyphOffsetArray, lineOffsetX, lineOffsetY, flip, anchorPoint, tileAnchorPoint, symbol, lineVertexArray, labelPlaneMatrix, projectionCache);
+                  if (!firstAndLastGlyph) {
+                    return { notEnoughRoom: true };
+                  }
+                  var firstPoint = project2(firstAndLastGlyph.first.point, glCoordMatrix).point;
+                  var lastPoint = project2(firstAndLastGlyph.last.point, glCoordMatrix).point;
+                  if (keepUpright && !flip) {
+                    var orientationChange = requiresOrientationChange(symbol.writingMode, firstPoint, lastPoint, aspectRatio);
+                    if (orientationChange) {
+                      return orientationChange;
+                    }
+                  }
+                  placedGlyphs = [firstAndLastGlyph.first];
+                  for (var glyphIndex = symbol.glyphStartIndex + 1; glyphIndex < glyphEndIndex - 1; glyphIndex++) {
+                    placedGlyphs.push(placeGlyphAlongLine(fontScale * glyphOffsetArray.getoffsetX(glyphIndex), lineOffsetX, lineOffsetY, flip, anchorPoint, tileAnchorPoint, symbol.segment, lineStartIndex, lineEndIndex, lineVertexArray, labelPlaneMatrix, projectionCache));
+                  }
+                  placedGlyphs.push(firstAndLastGlyph.last);
+                } else {
+                  if (keepUpright && !flip) {
+                    var a2 = project2(tileAnchorPoint, posMatrix).point;
+                    var tileVertexIndex = symbol.lineStartIndex + symbol.segment + 1;
+                    var tileSegmentEnd = new performance2.Point(lineVertexArray.getx(tileVertexIndex), lineVertexArray.gety(tileVertexIndex));
+                    var projectedVertex = project2(tileSegmentEnd, posMatrix);
+                    var b2 = projectedVertex.signedDistanceFromCamera > 0 ? projectedVertex.point : projectTruncatedLineSegment(tileAnchorPoint, tileSegmentEnd, a2, 1, posMatrix);
+                    var orientationChange$1 = requiresOrientationChange(symbol.writingMode, a2, b2, aspectRatio);
+                    if (orientationChange$1) {
+                      return orientationChange$1;
+                    }
+                  }
+                  var singleGlyph = placeGlyphAlongLine(fontScale * glyphOffsetArray.getoffsetX(symbol.glyphStartIndex), lineOffsetX, lineOffsetY, flip, anchorPoint, tileAnchorPoint, symbol.segment, symbol.lineStartIndex, symbol.lineStartIndex + symbol.lineLength, lineVertexArray, labelPlaneMatrix, projectionCache);
+                  if (!singleGlyph) {
+                    return { notEnoughRoom: true };
+                  }
+                  placedGlyphs = [singleGlyph];
+                }
+                for (var i2 = 0, list = placedGlyphs; i2 < list.length; i2 += 1) {
+                  var glyph = list[i2];
+                  performance2.addDynamicAttributes(dynamicLayoutVertexArray, glyph.point, glyph.angle);
+                }
+                return {};
+              }
+              function projectTruncatedLineSegment(previousTilePoint, currentTilePoint, previousProjectedPoint, minimumLength, projectionMatrix) {
+                var projectedUnitVertex = project2(previousTilePoint.add(previousTilePoint.sub(currentTilePoint)._unit()), projectionMatrix).point;
+                var projectedUnitSegment = previousProjectedPoint.sub(projectedUnitVertex);
+                return previousProjectedPoint.add(projectedUnitSegment._mult(minimumLength / projectedUnitSegment.mag()));
+              }
+              function placeGlyphAlongLine(offsetX, lineOffsetX, lineOffsetY, flip, anchorPoint, tileAnchorPoint, anchorSegment, lineStartIndex, lineEndIndex, lineVertexArray, labelPlaneMatrix, projectionCache) {
+                var combinedOffsetX = flip ? offsetX - lineOffsetX : offsetX + lineOffsetX;
+                var dir = combinedOffsetX > 0 ? 1 : -1;
+                var angle2 = 0;
+                if (flip) {
+                  dir *= -1;
+                  angle2 = Math.PI;
+                }
+                if (dir < 0) {
+                  angle2 += Math.PI;
+                }
+                var currentIndex = dir > 0 ? lineStartIndex + anchorSegment : lineStartIndex + anchorSegment + 1;
+                var current = anchorPoint;
+                var prev = anchorPoint;
+                var distanceToPrev = 0;
+                var currentSegmentDistance = 0;
+                var absOffsetX = Math.abs(combinedOffsetX);
+                var pathVertices = [];
+                while (distanceToPrev + currentSegmentDistance <= absOffsetX) {
+                  currentIndex += dir;
+                  if (currentIndex < lineStartIndex || currentIndex >= lineEndIndex) {
+                    return null;
+                  }
+                  prev = current;
+                  pathVertices.push(current);
+                  current = projectionCache[currentIndex];
+                  if (current === void 0) {
+                    var currentVertex = new performance2.Point(lineVertexArray.getx(currentIndex), lineVertexArray.gety(currentIndex));
+                    var projection = project2(currentVertex, labelPlaneMatrix);
+                    if (projection.signedDistanceFromCamera > 0) {
+                      current = projectionCache[currentIndex] = projection.point;
+                    } else {
+                      var previousLineVertexIndex = currentIndex - dir;
+                      var previousTilePoint = distanceToPrev === 0 ? tileAnchorPoint : new performance2.Point(lineVertexArray.getx(previousLineVertexIndex), lineVertexArray.gety(previousLineVertexIndex));
+                      current = projectTruncatedLineSegment(previousTilePoint, currentVertex, prev, absOffsetX - distanceToPrev + 1, labelPlaneMatrix);
+                    }
+                  }
+                  distanceToPrev += currentSegmentDistance;
+                  currentSegmentDistance = prev.dist(current);
+                }
+                var segmentInterpolationT = (absOffsetX - distanceToPrev) / currentSegmentDistance;
+                var prevToCurrent = current.sub(prev);
+                var p2 = prevToCurrent.mult(segmentInterpolationT)._add(prev);
+                p2._add(prevToCurrent._unit()._perp()._mult(lineOffsetY * dir));
+                var segmentAngle = angle2 + Math.atan2(current.y - prev.y, current.x - prev.x);
+                pathVertices.push(p2);
+                return {
+                  point: p2,
+                  angle: segmentAngle,
+                  path: pathVertices
+                };
+              }
+              var hiddenGlyphAttributes = new Float32Array([
+                -Infinity,
+                -Infinity,
+                0,
+                -Infinity,
+                -Infinity,
+                0,
+                -Infinity,
+                -Infinity,
+                0,
+                -Infinity,
+                -Infinity,
+                0
+              ]);
+              function hideGlyphs(num, dynamicLayoutVertexArray) {
+                for (var i2 = 0; i2 < num; i2++) {
+                  var offset = dynamicLayoutVertexArray.length;
+                  dynamicLayoutVertexArray.resize(offset + 4);
+                  dynamicLayoutVertexArray.float32.set(hiddenGlyphAttributes, offset * 3);
+                }
+              }
+              function xyTransformMat4(out, a2, m2) {
+                var x2 = a2[0], y2 = a2[1];
+                out[0] = m2[0] * x2 + m2[4] * y2 + m2[12];
+                out[1] = m2[1] * x2 + m2[5] * y2 + m2[13];
+                out[3] = m2[3] * x2 + m2[7] * y2 + m2[15];
+                return out;
+              }
+              var viewportPadding = 100;
+              var CollisionIndex = function CollisionIndex2(transform, grid, ignoredGrid) {
+                if (grid === void 0)
+                  grid = new GridIndex(transform.width + 2 * viewportPadding, transform.height + 2 * viewportPadding, 25);
+                if (ignoredGrid === void 0)
+                  ignoredGrid = new GridIndex(transform.width + 2 * viewportPadding, transform.height + 2 * viewportPadding, 25);
+                this.transform = transform;
+                this.grid = grid;
+                this.ignoredGrid = ignoredGrid;
+                this.pitchfactor = Math.cos(transform._pitch) * transform.cameraToCenterDistance;
+                this.screenRightBoundary = transform.width + viewportPadding;
+                this.screenBottomBoundary = transform.height + viewportPadding;
+                this.gridRightBoundary = transform.width + 2 * viewportPadding;
+                this.gridBottomBoundary = transform.height + 2 * viewportPadding;
+              };
+              CollisionIndex.prototype.placeCollisionBox = function placeCollisionBox(collisionBox2, allowOverlap, textPixelRatio, posMatrix, collisionGroupPredicate) {
+                var projectedPoint = this.projectAndGetPerspectiveRatio(posMatrix, collisionBox2.anchorPointX, collisionBox2.anchorPointY);
+                var tileToViewport = textPixelRatio * projectedPoint.perspectiveRatio;
+                var tlX = collisionBox2.x1 * tileToViewport + projectedPoint.point.x;
+                var tlY = collisionBox2.y1 * tileToViewport + projectedPoint.point.y;
+                var brX = collisionBox2.x2 * tileToViewport + projectedPoint.point.x;
+                var brY = collisionBox2.y2 * tileToViewport + projectedPoint.point.y;
+                if (!this.isInsideGrid(tlX, tlY, brX, brY) || !allowOverlap && this.grid.hitTest(tlX, tlY, brX, brY, collisionGroupPredicate)) {
+                  return {
+                    box: [],
+                    offscreen: false
+                  };
+                }
+                return {
+                  box: [
+                    tlX,
+                    tlY,
+                    brX,
+                    brY
+                  ],
+                  offscreen: this.isOffscreen(tlX, tlY, brX, brY)
+                };
+              };
+              CollisionIndex.prototype.placeCollisionCircles = function placeCollisionCircles(allowOverlap, symbol, lineVertexArray, glyphOffsetArray, fontSize, posMatrix, labelPlaneMatrix, labelToScreenMatrix, showCollisionCircles, pitchWithMap, collisionGroupPredicate, circlePixelDiameter, textPixelPadding) {
+                var placedCollisionCircles = [];
+                var tileUnitAnchorPoint = new performance2.Point(symbol.anchorX, symbol.anchorY);
+                var screenAnchorPoint = project2(tileUnitAnchorPoint, posMatrix);
+                var perspectiveRatio = getPerspectiveRatio(this.transform.cameraToCenterDistance, screenAnchorPoint.signedDistanceFromCamera);
+                var labelPlaneFontSize = pitchWithMap ? fontSize / perspectiveRatio : fontSize * perspectiveRatio;
+                var labelPlaneFontScale = labelPlaneFontSize / performance2.ONE_EM;
+                var labelPlaneAnchorPoint = project2(tileUnitAnchorPoint, labelPlaneMatrix).point;
+                var projectionCache = {};
+                var lineOffsetX = symbol.lineOffsetX * labelPlaneFontScale;
+                var lineOffsetY = symbol.lineOffsetY * labelPlaneFontScale;
+                var firstAndLastGlyph = placeFirstAndLastGlyph(labelPlaneFontScale, glyphOffsetArray, lineOffsetX, lineOffsetY, false, labelPlaneAnchorPoint, tileUnitAnchorPoint, symbol, lineVertexArray, labelPlaneMatrix, projectionCache);
+                var collisionDetected = false;
+                var inGrid = false;
+                var entirelyOffscreen = true;
+                if (firstAndLastGlyph) {
+                  var radius = circlePixelDiameter * 0.5 * perspectiveRatio + textPixelPadding;
+                  var screenPlaneMin = new performance2.Point(-100, -100);
+                  var screenPlaneMax = new performance2.Point(this.screenRightBoundary, this.screenBottomBoundary);
+                  var interpolator = new PathInterpolator();
+                  var first = firstAndLastGlyph.first;
+                  var last = firstAndLastGlyph.last;
+                  var projectedPath = [];
+                  for (var i2 = first.path.length - 1; i2 >= 1; i2--) {
+                    projectedPath.push(first.path[i2]);
+                  }
+                  for (var i$1 = 1; i$1 < last.path.length; i$1++) {
+                    projectedPath.push(last.path[i$1]);
+                  }
+                  var circleDist = radius * 2.5;
+                  if (labelToScreenMatrix) {
+                    var screenSpacePath = projectedPath.map(function(p2) {
+                      return project2(p2, labelToScreenMatrix);
+                    });
+                    if (screenSpacePath.some(function(point) {
+                      return point.signedDistanceFromCamera <= 0;
+                    })) {
+                      projectedPath = [];
+                    } else {
+                      projectedPath = screenSpacePath.map(function(p2) {
+                        return p2.point;
+                      });
+                    }
+                  }
+                  var segments = [];
+                  if (projectedPath.length > 0) {
+                    var minPoint = projectedPath[0].clone();
+                    var maxPoint = projectedPath[0].clone();
+                    for (var i$2 = 1; i$2 < projectedPath.length; i$2++) {
+                      minPoint.x = Math.min(minPoint.x, projectedPath[i$2].x);
+                      minPoint.y = Math.min(minPoint.y, projectedPath[i$2].y);
+                      maxPoint.x = Math.max(maxPoint.x, projectedPath[i$2].x);
+                      maxPoint.y = Math.max(maxPoint.y, projectedPath[i$2].y);
+                    }
+                    if (minPoint.x >= screenPlaneMin.x && maxPoint.x <= screenPlaneMax.x && minPoint.y >= screenPlaneMin.y && maxPoint.y <= screenPlaneMax.y) {
+                      segments = [projectedPath];
+                    } else if (maxPoint.x < screenPlaneMin.x || minPoint.x > screenPlaneMax.x || maxPoint.y < screenPlaneMin.y || minPoint.y > screenPlaneMax.y) {
+                      segments = [];
+                    } else {
+                      segments = performance2.clipLine([projectedPath], screenPlaneMin.x, screenPlaneMin.y, screenPlaneMax.x, screenPlaneMax.y);
+                    }
+                  }
+                  for (var i$4 = 0, list = segments; i$4 < list.length; i$4 += 1) {
+                    var seg = list[i$4];
+                    interpolator.reset(seg, radius * 0.25);
+                    var numCircles = 0;
+                    if (interpolator.length <= 0.5 * radius) {
+                      numCircles = 1;
+                    } else {
+                      numCircles = Math.ceil(interpolator.paddedLength / circleDist) + 1;
+                    }
+                    for (var i$3 = 0; i$3 < numCircles; i$3++) {
+                      var t4 = i$3 / Math.max(numCircles - 1, 1);
+                      var circlePosition = interpolator.lerp(t4);
+                      var centerX = circlePosition.x + viewportPadding;
+                      var centerY = circlePosition.y + viewportPadding;
+                      placedCollisionCircles.push(centerX, centerY, radius, 0);
+                      var x1 = centerX - radius;
+                      var y1 = centerY - radius;
+                      var x2 = centerX + radius;
+                      var y2 = centerY + radius;
+                      entirelyOffscreen = entirelyOffscreen && this.isOffscreen(x1, y1, x2, y2);
+                      inGrid = inGrid || this.isInsideGrid(x1, y1, x2, y2);
+                      if (!allowOverlap) {
+                        if (this.grid.hitTestCircle(centerX, centerY, radius, collisionGroupPredicate)) {
+                          collisionDetected = true;
+                          if (!showCollisionCircles) {
+                            return {
+                              circles: [],
+                              offscreen: false,
+                              collisionDetected
+                            };
+                          }
+                        }
+                      }
+                    }
+                  }
+                }
+                return {
+                  circles: !showCollisionCircles && collisionDetected || !inGrid ? [] : placedCollisionCircles,
+                  offscreen: entirelyOffscreen,
+                  collisionDetected
+                };
+              };
+              CollisionIndex.prototype.queryRenderedSymbols = function queryRenderedSymbols2(viewportQueryGeometry) {
+                if (viewportQueryGeometry.length === 0 || this.grid.keysLength() === 0 && this.ignoredGrid.keysLength() === 0) {
+                  return {};
+                }
+                var query = [];
+                var minX = Infinity;
+                var minY = Infinity;
+                var maxX = -Infinity;
+                var maxY = -Infinity;
+                for (var i2 = 0, list = viewportQueryGeometry; i2 < list.length; i2 += 1) {
+                  var point = list[i2];
+                  var gridPoint = new performance2.Point(point.x + viewportPadding, point.y + viewportPadding);
+                  minX = Math.min(minX, gridPoint.x);
+                  minY = Math.min(minY, gridPoint.y);
+                  maxX = Math.max(maxX, gridPoint.x);
+                  maxY = Math.max(maxY, gridPoint.y);
+                  query.push(gridPoint);
+                }
+                var features = this.grid.query(minX, minY, maxX, maxY).concat(this.ignoredGrid.query(minX, minY, maxX, maxY));
+                var seenFeatures = {};
+                var result = {};
+                for (var i$1 = 0, list$1 = features; i$1 < list$1.length; i$1 += 1) {
+                  var feature = list$1[i$1];
+                  var featureKey = feature.key;
+                  if (seenFeatures[featureKey.bucketInstanceId] === void 0) {
+                    seenFeatures[featureKey.bucketInstanceId] = {};
+                  }
+                  if (seenFeatures[featureKey.bucketInstanceId][featureKey.featureIndex]) {
+                    continue;
+                  }
+                  var bbox = [
+                    new performance2.Point(feature.x1, feature.y1),
+                    new performance2.Point(feature.x2, feature.y1),
+                    new performance2.Point(feature.x2, feature.y2),
+                    new performance2.Point(feature.x1, feature.y2)
+                  ];
+                  if (!performance2.polygonIntersectsPolygon(query, bbox)) {
+                    continue;
+                  }
+                  seenFeatures[featureKey.bucketInstanceId][featureKey.featureIndex] = true;
+                  if (result[featureKey.bucketInstanceId] === void 0) {
+                    result[featureKey.bucketInstanceId] = [];
+                  }
+                  result[featureKey.bucketInstanceId].push(featureKey.featureIndex);
+                }
+                return result;
+              };
+              CollisionIndex.prototype.insertCollisionBox = function insertCollisionBox(collisionBox2, ignorePlacement, bucketInstanceId, featureIndex, collisionGroupID) {
+                var grid = ignorePlacement ? this.ignoredGrid : this.grid;
+                var key = {
+                  bucketInstanceId,
+                  featureIndex,
+                  collisionGroupID
+                };
+                grid.insert(key, collisionBox2[0], collisionBox2[1], collisionBox2[2], collisionBox2[3]);
+              };
+              CollisionIndex.prototype.insertCollisionCircles = function insertCollisionCircles(collisionCircles, ignorePlacement, bucketInstanceId, featureIndex, collisionGroupID) {
+                var grid = ignorePlacement ? this.ignoredGrid : this.grid;
+                var key = {
+                  bucketInstanceId,
+                  featureIndex,
+                  collisionGroupID
+                };
+                for (var k2 = 0; k2 < collisionCircles.length; k2 += 4) {
+                  grid.insertCircle(key, collisionCircles[k2], collisionCircles[k2 + 1], collisionCircles[k2 + 2]);
+                }
+              };
+              CollisionIndex.prototype.projectAndGetPerspectiveRatio = function projectAndGetPerspectiveRatio(posMatrix, x2, y2) {
+                var p2 = [
+                  x2,
+                  y2,
+                  0,
+                  1
+                ];
+                xyTransformMat4(p2, p2, posMatrix);
+                var a2 = new performance2.Point((p2[0] / p2[3] + 1) / 2 * this.transform.width + viewportPadding, (-p2[1] / p2[3] + 1) / 2 * this.transform.height + viewportPadding);
+                return {
+                  point: a2,
+                  perspectiveRatio: 0.5 + 0.5 * (this.transform.cameraToCenterDistance / p2[3])
+                };
+              };
+              CollisionIndex.prototype.isOffscreen = function isOffscreen(x1, y1, x2, y2) {
+                return x2 < viewportPadding || x1 >= this.screenRightBoundary || y2 < viewportPadding || y1 > this.screenBottomBoundary;
+              };
+              CollisionIndex.prototype.isInsideGrid = function isInsideGrid(x1, y1, x2, y2) {
+                return x2 >= 0 && x1 < this.gridRightBoundary && y2 >= 0 && y1 < this.gridBottomBoundary;
+              };
+              CollisionIndex.prototype.getViewportMatrix = function getViewportMatrix() {
+                var m2 = performance2.identity([]);
+                performance2.translate(m2, m2, [
+                  -100,
+                  -100,
+                  0
+                ]);
+                return m2;
+              };
+              function pixelsToTileUnits(tile, pixelValue, z2) {
+                return pixelValue * (performance2.EXTENT / (tile.tileSize * Math.pow(2, z2 - tile.tileID.overscaledZ)));
+              }
+              var OpacityState = function OpacityState2(prevState, increment, placed, skipFade) {
+                if (prevState) {
+                  this.opacity = Math.max(0, Math.min(1, prevState.opacity + (prevState.placed ? increment : -increment)));
+                } else {
+                  this.opacity = skipFade && placed ? 1 : 0;
+                }
+                this.placed = placed;
+              };
+              OpacityState.prototype.isHidden = function isHidden() {
+                return this.opacity === 0 && !this.placed;
+              };
+              var JointOpacityState = function JointOpacityState2(prevState, increment, placedText, placedIcon, skipFade) {
+                this.text = new OpacityState(prevState ? prevState.text : null, increment, placedText, skipFade);
+                this.icon = new OpacityState(prevState ? prevState.icon : null, increment, placedIcon, skipFade);
+              };
+              JointOpacityState.prototype.isHidden = function isHidden() {
+                return this.text.isHidden() && this.icon.isHidden();
+              };
+              var JointPlacement = function JointPlacement2(text, icon, skipFade) {
+                this.text = text;
+                this.icon = icon;
+                this.skipFade = skipFade;
+              };
+              var CollisionCircleArray = function CollisionCircleArray2() {
+                this.invProjMatrix = performance2.create();
+                this.viewportMatrix = performance2.create();
+                this.circles = [];
+              };
+              var RetainedQueryData = function RetainedQueryData2(bucketInstanceId, featureIndex, sourceLayerIndex, bucketIndex, tileID) {
+                this.bucketInstanceId = bucketInstanceId;
+                this.featureIndex = featureIndex;
+                this.sourceLayerIndex = sourceLayerIndex;
+                this.bucketIndex = bucketIndex;
+                this.tileID = tileID;
+              };
+              var CollisionGroups = function CollisionGroups2(crossSourceCollisions) {
+                this.crossSourceCollisions = crossSourceCollisions;
+                this.maxGroupID = 0;
+                this.collisionGroups = {};
+              };
+              CollisionGroups.prototype.get = function get(sourceID) {
+                if (!this.crossSourceCollisions) {
+                  if (!this.collisionGroups[sourceID]) {
+                    var nextGroupID = ++this.maxGroupID;
+                    this.collisionGroups[sourceID] = {
+                      ID: nextGroupID,
+                      predicate: function(key) {
+                        return key.collisionGroupID === nextGroupID;
+                      }
+                    };
+                  }
+                  return this.collisionGroups[sourceID];
+                } else {
+                  return {
+                    ID: 0,
+                    predicate: null
+                  };
+                }
+              };
+              function calculateVariableLayoutShift(anchor, width, height, textOffset, textBoxScale) {
+                var ref = performance2.getAnchorAlignment(anchor);
+                var horizontalAlign = ref.horizontalAlign;
+                var verticalAlign = ref.verticalAlign;
+                var shiftX = -(horizontalAlign - 0.5) * width;
+                var shiftY = -(verticalAlign - 0.5) * height;
+                var offset = performance2.evaluateVariableOffset(anchor, textOffset);
+                return new performance2.Point(shiftX + offset[0] * textBoxScale, shiftY + offset[1] * textBoxScale);
+              }
+              function shiftVariableCollisionBox(collisionBox2, shiftX, shiftY, rotateWithMap, pitchWithMap, angle2) {
+                var x1 = collisionBox2.x1;
+                var x2 = collisionBox2.x2;
+                var y1 = collisionBox2.y1;
+                var y2 = collisionBox2.y2;
+                var anchorPointX = collisionBox2.anchorPointX;
+                var anchorPointY = collisionBox2.anchorPointY;
+                var rotatedOffset = new performance2.Point(shiftX, shiftY);
+                if (rotateWithMap) {
+                  rotatedOffset._rotate(pitchWithMap ? angle2 : -angle2);
+                }
+                return {
+                  x1: x1 + rotatedOffset.x,
+                  y1: y1 + rotatedOffset.y,
+                  x2: x2 + rotatedOffset.x,
+                  y2: y2 + rotatedOffset.y,
+                  anchorPointX,
+                  anchorPointY
+                };
+              }
+              var Placement = function Placement2(transform, fadeDuration, crossSourceCollisions, prevPlacement) {
+                this.transform = transform.clone();
+                this.collisionIndex = new CollisionIndex(this.transform);
+                this.placements = {};
+                this.opacities = {};
+                this.variableOffsets = {};
+                this.stale = false;
+                this.commitTime = 0;
+                this.fadeDuration = fadeDuration;
+                this.retainedQueryData = {};
+                this.collisionGroups = new CollisionGroups(crossSourceCollisions);
+                this.collisionCircleArrays = {};
+                this.prevPlacement = prevPlacement;
+                if (prevPlacement) {
+                  prevPlacement.prevPlacement = void 0;
+                }
+                this.placedOrientations = {};
+              };
+              Placement.prototype.getBucketParts = function getBucketParts(results, styleLayer, tile, sortAcrossTiles) {
+                var symbolBucket = tile.getBucket(styleLayer);
+                var bucketFeatureIndex = tile.latestFeatureIndex;
+                if (!symbolBucket || !bucketFeatureIndex || styleLayer.id !== symbolBucket.layerIds[0]) {
+                  return;
+                }
+                var collisionBoxArray = tile.collisionBoxArray;
+                var layout = symbolBucket.layers[0].layout;
+                var scale2 = Math.pow(2, this.transform.zoom - tile.tileID.overscaledZ);
+                var textPixelRatio = tile.tileSize / performance2.EXTENT;
+                var posMatrix = this.transform.calculatePosMatrix(tile.tileID.toUnwrapped());
+                var pitchWithMap = layout.get("text-pitch-alignment") === "map";
+                var rotateWithMap = layout.get("text-rotation-alignment") === "map";
+                var pixelsToTiles = pixelsToTileUnits(tile, 1, this.transform.zoom);
+                var textLabelPlaneMatrix = getLabelPlaneMatrix(posMatrix, pitchWithMap, rotateWithMap, this.transform, pixelsToTiles);
+                var labelToScreenMatrix = null;
+                if (pitchWithMap) {
+                  var glMatrix = getGlCoordMatrix(posMatrix, pitchWithMap, rotateWithMap, this.transform, pixelsToTiles);
+                  labelToScreenMatrix = performance2.multiply([], this.transform.labelPlaneMatrix, glMatrix);
+                }
+                this.retainedQueryData[symbolBucket.bucketInstanceId] = new RetainedQueryData(symbolBucket.bucketInstanceId, bucketFeatureIndex, symbolBucket.sourceLayerIndex, symbolBucket.index, tile.tileID);
+                var parameters = {
+                  bucket: symbolBucket,
+                  layout,
+                  posMatrix,
+                  textLabelPlaneMatrix,
+                  labelToScreenMatrix,
+                  scale: scale2,
+                  textPixelRatio,
+                  holdingForFade: tile.holdingForFade(),
+                  collisionBoxArray,
+                  partiallyEvaluatedTextSize: performance2.evaluateSizeForZoom(symbolBucket.textSizeData, this.transform.zoom),
+                  collisionGroup: this.collisionGroups.get(symbolBucket.sourceID)
+                };
+                if (sortAcrossTiles) {
+                  for (var i2 = 0, list = symbolBucket.sortKeyRanges; i2 < list.length; i2 += 1) {
+                    var range = list[i2];
+                    var sortKey = range.sortKey;
+                    var symbolInstanceStart = range.symbolInstanceStart;
+                    var symbolInstanceEnd = range.symbolInstanceEnd;
+                    results.push({
+                      sortKey,
+                      symbolInstanceStart,
+                      symbolInstanceEnd,
+                      parameters
+                    });
+                  }
+                } else {
+                  results.push({
+                    symbolInstanceStart: 0,
+                    symbolInstanceEnd: symbolBucket.symbolInstances.length,
+                    parameters
+                  });
+                }
+              };
+              Placement.prototype.attemptAnchorPlacement = function attemptAnchorPlacement(anchor, textBox, width, height, textBoxScale, rotateWithMap, pitchWithMap, textPixelRatio, posMatrix, collisionGroup, textAllowOverlap, symbolInstance, bucket, orientation, iconBox) {
+                var textOffset = [
+                  symbolInstance.textOffset0,
+                  symbolInstance.textOffset1
+                ];
+                var shift = calculateVariableLayoutShift(anchor, width, height, textOffset, textBoxScale);
+                var placedGlyphBoxes = this.collisionIndex.placeCollisionBox(shiftVariableCollisionBox(textBox, shift.x, shift.y, rotateWithMap, pitchWithMap, this.transform.angle), textAllowOverlap, textPixelRatio, posMatrix, collisionGroup.predicate);
+                if (iconBox) {
+                  var placedIconBoxes = this.collisionIndex.placeCollisionBox(shiftVariableCollisionBox(iconBox, shift.x, shift.y, rotateWithMap, pitchWithMap, this.transform.angle), textAllowOverlap, textPixelRatio, posMatrix, collisionGroup.predicate);
+                  if (placedIconBoxes.box.length === 0) {
+                    return;
+                  }
+                }
+                if (placedGlyphBoxes.box.length > 0) {
+                  var prevAnchor;
+                  if (this.prevPlacement && this.prevPlacement.variableOffsets[symbolInstance.crossTileID] && this.prevPlacement.placements[symbolInstance.crossTileID] && this.prevPlacement.placements[symbolInstance.crossTileID].text) {
+                    prevAnchor = this.prevPlacement.variableOffsets[symbolInstance.crossTileID].anchor;
+                  }
+                  this.variableOffsets[symbolInstance.crossTileID] = {
+                    textOffset,
+                    width,
+                    height,
+                    anchor,
+                    textBoxScale,
+                    prevAnchor
+                  };
+                  this.markUsedJustification(bucket, anchor, symbolInstance, orientation);
+                  if (bucket.allowVerticalPlacement) {
+                    this.markUsedOrientation(bucket, orientation, symbolInstance);
+                    this.placedOrientations[symbolInstance.crossTileID] = orientation;
+                  }
+                  return {
+                    shift,
+                    placedGlyphBoxes
+                  };
+                }
+              };
+              Placement.prototype.placeLayerBucketPart = function placeLayerBucketPart(bucketPart, seenCrossTileIDs, showCollisionBoxes) {
+                var this$1$1 = this;
+                var ref = bucketPart.parameters;
+                var bucket = ref.bucket;
+                var layout = ref.layout;
+                var posMatrix = ref.posMatrix;
+                var textLabelPlaneMatrix = ref.textLabelPlaneMatrix;
+                var labelToScreenMatrix = ref.labelToScreenMatrix;
+                var textPixelRatio = ref.textPixelRatio;
+                var holdingForFade = ref.holdingForFade;
+                var collisionBoxArray = ref.collisionBoxArray;
+                var partiallyEvaluatedTextSize = ref.partiallyEvaluatedTextSize;
+                var collisionGroup = ref.collisionGroup;
+                var textOptional = layout.get("text-optional");
+                var iconOptional = layout.get("icon-optional");
+                var textAllowOverlap = layout.get("text-allow-overlap");
+                var iconAllowOverlap = layout.get("icon-allow-overlap");
+                var rotateWithMap = layout.get("text-rotation-alignment") === "map";
+                var pitchWithMap = layout.get("text-pitch-alignment") === "map";
+                var hasIconTextFit = layout.get("icon-text-fit") !== "none";
+                var zOrderByViewportY = layout.get("symbol-z-order") === "viewport-y";
+                var alwaysShowText = textAllowOverlap && (iconAllowOverlap || !bucket.hasIconData() || iconOptional);
+                var alwaysShowIcon = iconAllowOverlap && (textAllowOverlap || !bucket.hasTextData() || textOptional);
+                if (!bucket.collisionArrays && collisionBoxArray) {
+                  bucket.deserializeCollisionBoxes(collisionBoxArray);
+                }
+                var placeSymbol = function(symbolInstance, collisionArrays) {
+                  if (seenCrossTileIDs[symbolInstance.crossTileID]) {
+                    return;
+                  }
+                  if (holdingForFade) {
+                    this$1$1.placements[symbolInstance.crossTileID] = new JointPlacement(false, false, false);
+                    return;
+                  }
+                  var placeText = false;
+                  var placeIcon = false;
+                  var offscreen = true;
+                  var shift = null;
+                  var placed = {
+                    box: null,
+                    offscreen: null
+                  };
+                  var placedVerticalText = {
+                    box: null
+                  };
+                  var placedGlyphBoxes = null;
+                  var placedGlyphCircles = null;
+                  var placedIconBoxes = null;
+                  var textFeatureIndex = 0;
+                  var verticalTextFeatureIndex = 0;
+                  var iconFeatureIndex = 0;
+                  if (collisionArrays.textFeatureIndex) {
+                    textFeatureIndex = collisionArrays.textFeatureIndex;
+                  } else if (symbolInstance.useRuntimeCollisionCircles) {
+                    textFeatureIndex = symbolInstance.featureIndex;
+                  }
+                  if (collisionArrays.verticalTextFeatureIndex) {
+                    verticalTextFeatureIndex = collisionArrays.verticalTextFeatureIndex;
+                  }
+                  var textBox = collisionArrays.textBox;
+                  if (textBox) {
+                    var updatePreviousOrientationIfNotPlaced = function(isPlaced) {
+                      var previousOrientation = performance2.WritingMode.horizontal;
+                      if (bucket.allowVerticalPlacement && !isPlaced && this$1$1.prevPlacement) {
+                        var prevPlacedOrientation = this$1$1.prevPlacement.placedOrientations[symbolInstance.crossTileID];
+                        if (prevPlacedOrientation) {
+                          this$1$1.placedOrientations[symbolInstance.crossTileID] = prevPlacedOrientation;
+                          previousOrientation = prevPlacedOrientation;
+                          this$1$1.markUsedOrientation(bucket, previousOrientation, symbolInstance);
+                        }
+                      }
+                      return previousOrientation;
+                    };
+                    var placeTextForPlacementModes = function(placeHorizontalFn, placeVerticalFn) {
+                      if (bucket.allowVerticalPlacement && symbolInstance.numVerticalGlyphVertices > 0 && collisionArrays.verticalTextBox) {
+                        for (var i3 = 0, list = bucket.writingModes; i3 < list.length; i3 += 1) {
+                          var placementMode = list[i3];
+                          if (placementMode === performance2.WritingMode.vertical) {
+                            placed = placeVerticalFn();
+                            placedVerticalText = placed;
+                          } else {
+                            placed = placeHorizontalFn();
+                          }
+                          if (placed && placed.box && placed.box.length) {
+                            break;
+                          }
+                        }
+                      } else {
+                        placed = placeHorizontalFn();
+                      }
+                    };
+                    if (!layout.get("text-variable-anchor")) {
+                      var placeBox = function(collisionTextBox, orientation) {
+                        var placedFeature = this$1$1.collisionIndex.placeCollisionBox(collisionTextBox, textAllowOverlap, textPixelRatio, posMatrix, collisionGroup.predicate);
+                        if (placedFeature && placedFeature.box && placedFeature.box.length) {
+                          this$1$1.markUsedOrientation(bucket, orientation, symbolInstance);
+                          this$1$1.placedOrientations[symbolInstance.crossTileID] = orientation;
+                        }
+                        return placedFeature;
+                      };
+                      var placeHorizontal = function() {
+                        return placeBox(textBox, performance2.WritingMode.horizontal);
+                      };
+                      var placeVertical = function() {
+                        var verticalTextBox = collisionArrays.verticalTextBox;
+                        if (bucket.allowVerticalPlacement && symbolInstance.numVerticalGlyphVertices > 0 && verticalTextBox) {
+                          return placeBox(verticalTextBox, performance2.WritingMode.vertical);
+                        }
+                        return {
+                          box: null,
+                          offscreen: null
+                        };
+                      };
+                      placeTextForPlacementModes(placeHorizontal, placeVertical);
+                      updatePreviousOrientationIfNotPlaced(placed && placed.box && placed.box.length);
+                    } else {
+                      var anchors = layout.get("text-variable-anchor");
+                      if (this$1$1.prevPlacement && this$1$1.prevPlacement.variableOffsets[symbolInstance.crossTileID]) {
+                        var prevOffsets = this$1$1.prevPlacement.variableOffsets[symbolInstance.crossTileID];
+                        if (anchors.indexOf(prevOffsets.anchor) > 0) {
+                          anchors = anchors.filter(function(anchor) {
+                            return anchor !== prevOffsets.anchor;
+                          });
+                          anchors.unshift(prevOffsets.anchor);
+                        }
+                      }
+                      var placeBoxForVariableAnchors = function(collisionTextBox, collisionIconBox, orientation) {
+                        var width = collisionTextBox.x2 - collisionTextBox.x1;
+                        var height = collisionTextBox.y2 - collisionTextBox.y1;
+                        var textBoxScale = symbolInstance.textBoxScale;
+                        var variableIconBox = hasIconTextFit && !iconAllowOverlap ? collisionIconBox : null;
+                        var placedBox = {
+                          box: [],
+                          offscreen: false
+                        };
+                        var placementAttempts = textAllowOverlap ? anchors.length * 2 : anchors.length;
+                        for (var i3 = 0; i3 < placementAttempts; ++i3) {
+                          var anchor = anchors[i3 % anchors.length];
+                          var allowOverlap = i3 >= anchors.length;
+                          var result = this$1$1.attemptAnchorPlacement(anchor, collisionTextBox, width, height, textBoxScale, rotateWithMap, pitchWithMap, textPixelRatio, posMatrix, collisionGroup, allowOverlap, symbolInstance, bucket, orientation, variableIconBox);
+                          if (result) {
+                            placedBox = result.placedGlyphBoxes;
+                            if (placedBox && placedBox.box && placedBox.box.length) {
+                              placeText = true;
+                              shift = result.shift;
+                              break;
+                            }
+                          }
+                        }
+                        return placedBox;
+                      };
+                      var placeHorizontal$1 = function() {
+                        return placeBoxForVariableAnchors(textBox, collisionArrays.iconBox, performance2.WritingMode.horizontal);
+                      };
+                      var placeVertical$1 = function() {
+                        var verticalTextBox = collisionArrays.verticalTextBox;
+                        var wasPlaced = placed && placed.box && placed.box.length;
+                        if (bucket.allowVerticalPlacement && !wasPlaced && symbolInstance.numVerticalGlyphVertices > 0 && verticalTextBox) {
+                          return placeBoxForVariableAnchors(verticalTextBox, collisionArrays.verticalIconBox, performance2.WritingMode.vertical);
+                        }
+                        return {
+                          box: null,
+                          offscreen: null
+                        };
+                      };
+                      placeTextForPlacementModes(placeHorizontal$1, placeVertical$1);
+                      if (placed) {
+                        placeText = placed.box;
+                        offscreen = placed.offscreen;
+                      }
+                      var prevOrientation = updatePreviousOrientationIfNotPlaced(placed && placed.box);
+                      if (!placeText && this$1$1.prevPlacement) {
+                        var prevOffset = this$1$1.prevPlacement.variableOffsets[symbolInstance.crossTileID];
+                        if (prevOffset) {
+                          this$1$1.variableOffsets[symbolInstance.crossTileID] = prevOffset;
+                          this$1$1.markUsedJustification(bucket, prevOffset.anchor, symbolInstance, prevOrientation);
+                        }
+                      }
+                    }
+                  }
+                  placedGlyphBoxes = placed;
+                  placeText = placedGlyphBoxes && placedGlyphBoxes.box && placedGlyphBoxes.box.length > 0;
+                  offscreen = placedGlyphBoxes && placedGlyphBoxes.offscreen;
+                  if (symbolInstance.useRuntimeCollisionCircles) {
+                    var placedSymbol = bucket.text.placedSymbolArray.get(symbolInstance.centerJustifiedTextSymbolIndex);
+                    var fontSize = performance2.evaluateSizeForFeature(bucket.textSizeData, partiallyEvaluatedTextSize, placedSymbol);
+                    var textPixelPadding = layout.get("text-padding");
+                    var circlePixelDiameter = symbolInstance.collisionCircleDiameter;
+                    placedGlyphCircles = this$1$1.collisionIndex.placeCollisionCircles(textAllowOverlap, placedSymbol, bucket.lineVertexArray, bucket.glyphOffsetArray, fontSize, posMatrix, textLabelPlaneMatrix, labelToScreenMatrix, showCollisionBoxes, pitchWithMap, collisionGroup.predicate, circlePixelDiameter, textPixelPadding);
+                    placeText = textAllowOverlap || placedGlyphCircles.circles.length > 0 && !placedGlyphCircles.collisionDetected;
+                    offscreen = offscreen && placedGlyphCircles.offscreen;
+                  }
+                  if (collisionArrays.iconFeatureIndex) {
+                    iconFeatureIndex = collisionArrays.iconFeatureIndex;
+                  }
+                  if (collisionArrays.iconBox) {
+                    var placeIconFeature = function(iconBox) {
+                      var shiftedIconBox = hasIconTextFit && shift ? shiftVariableCollisionBox(iconBox, shift.x, shift.y, rotateWithMap, pitchWithMap, this$1$1.transform.angle) : iconBox;
+                      return this$1$1.collisionIndex.placeCollisionBox(shiftedIconBox, iconAllowOverlap, textPixelRatio, posMatrix, collisionGroup.predicate);
+                    };
+                    if (placedVerticalText && placedVerticalText.box && placedVerticalText.box.length && collisionArrays.verticalIconBox) {
+                      placedIconBoxes = placeIconFeature(collisionArrays.verticalIconBox);
+                      placeIcon = placedIconBoxes.box.length > 0;
+                    } else {
+                      placedIconBoxes = placeIconFeature(collisionArrays.iconBox);
+                      placeIcon = placedIconBoxes.box.length > 0;
+                    }
+                    offscreen = offscreen && placedIconBoxes.offscreen;
+                  }
+                  var iconWithoutText = textOptional || symbolInstance.numHorizontalGlyphVertices === 0 && symbolInstance.numVerticalGlyphVertices === 0;
+                  var textWithoutIcon = iconOptional || symbolInstance.numIconVertices === 0;
+                  if (!iconWithoutText && !textWithoutIcon) {
+                    placeIcon = placeText = placeIcon && placeText;
+                  } else if (!textWithoutIcon) {
+                    placeText = placeIcon && placeText;
+                  } else if (!iconWithoutText) {
+                    placeIcon = placeIcon && placeText;
+                  }
+                  if (placeText && placedGlyphBoxes && placedGlyphBoxes.box) {
+                    if (placedVerticalText && placedVerticalText.box && verticalTextFeatureIndex) {
+                      this$1$1.collisionIndex.insertCollisionBox(placedGlyphBoxes.box, layout.get("text-ignore-placement"), bucket.bucketInstanceId, verticalTextFeatureIndex, collisionGroup.ID);
+                    } else {
+                      this$1$1.collisionIndex.insertCollisionBox(placedGlyphBoxes.box, layout.get("text-ignore-placement"), bucket.bucketInstanceId, textFeatureIndex, collisionGroup.ID);
+                    }
+                  }
+                  if (placeIcon && placedIconBoxes) {
+                    this$1$1.collisionIndex.insertCollisionBox(placedIconBoxes.box, layout.get("icon-ignore-placement"), bucket.bucketInstanceId, iconFeatureIndex, collisionGroup.ID);
+                  }
+                  if (placedGlyphCircles) {
+                    if (placeText) {
+                      this$1$1.collisionIndex.insertCollisionCircles(placedGlyphCircles.circles, layout.get("text-ignore-placement"), bucket.bucketInstanceId, textFeatureIndex, collisionGroup.ID);
+                    }
+                    if (showCollisionBoxes) {
+                      var id2 = bucket.bucketInstanceId;
+                      var circleArray2 = this$1$1.collisionCircleArrays[id2];
+                      if (circleArray2 === void 0) {
+                        circleArray2 = this$1$1.collisionCircleArrays[id2] = new CollisionCircleArray();
+                      }
+                      for (var i22 = 0; i22 < placedGlyphCircles.circles.length; i22 += 4) {
+                        circleArray2.circles.push(placedGlyphCircles.circles[i22 + 0]);
+                        circleArray2.circles.push(placedGlyphCircles.circles[i22 + 1]);
+                        circleArray2.circles.push(placedGlyphCircles.circles[i22 + 2]);
+                        circleArray2.circles.push(placedGlyphCircles.collisionDetected ? 1 : 0);
+                      }
+                    }
+                  }
+                  this$1$1.placements[symbolInstance.crossTileID] = new JointPlacement(placeText || alwaysShowText, placeIcon || alwaysShowIcon, offscreen || bucket.justReloaded);
+                  seenCrossTileIDs[symbolInstance.crossTileID] = true;
+                };
+                if (zOrderByViewportY) {
+                  var symbolIndexes = bucket.getSortedSymbolIndexes(this.transform.angle);
+                  for (var i2 = symbolIndexes.length - 1; i2 >= 0; --i2) {
+                    var symbolIndex = symbolIndexes[i2];
+                    placeSymbol(bucket.symbolInstances.get(symbolIndex), bucket.collisionArrays[symbolIndex]);
+                  }
+                } else {
+                  for (var i$1 = bucketPart.symbolInstanceStart; i$1 < bucketPart.symbolInstanceEnd; i$1++) {
+                    placeSymbol(bucket.symbolInstances.get(i$1), bucket.collisionArrays[i$1]);
+                  }
+                }
+                if (showCollisionBoxes && bucket.bucketInstanceId in this.collisionCircleArrays) {
+                  var circleArray = this.collisionCircleArrays[bucket.bucketInstanceId];
+                  performance2.invert(circleArray.invProjMatrix, posMatrix);
+                  circleArray.viewportMatrix = this.collisionIndex.getViewportMatrix();
+                }
+                bucket.justReloaded = false;
+              };
+              Placement.prototype.markUsedJustification = function markUsedJustification(bucket, placedAnchor, symbolInstance, orientation) {
+                var justifications = {
+                  "left": symbolInstance.leftJustifiedTextSymbolIndex,
+                  "center": symbolInstance.centerJustifiedTextSymbolIndex,
+                  "right": symbolInstance.rightJustifiedTextSymbolIndex
+                };
+                var autoIndex;
+                if (orientation === performance2.WritingMode.vertical) {
+                  autoIndex = symbolInstance.verticalPlacedTextSymbolIndex;
+                } else {
+                  autoIndex = justifications[performance2.getAnchorJustification(placedAnchor)];
+                }
+                var indexes = [
+                  symbolInstance.leftJustifiedTextSymbolIndex,
+                  symbolInstance.centerJustifiedTextSymbolIndex,
+                  symbolInstance.rightJustifiedTextSymbolIndex,
+                  symbolInstance.verticalPlacedTextSymbolIndex
+                ];
+                for (var i2 = 0, list = indexes; i2 < list.length; i2 += 1) {
+                  var index = list[i2];
+                  if (index >= 0) {
+                    if (autoIndex >= 0 && index !== autoIndex) {
+                      bucket.text.placedSymbolArray.get(index).crossTileID = 0;
+                    } else {
+                      bucket.text.placedSymbolArray.get(index).crossTileID = symbolInstance.crossTileID;
+                    }
+                  }
+                }
+              };
+              Placement.prototype.markUsedOrientation = function markUsedOrientation(bucket, orientation, symbolInstance) {
+                var horizontal = orientation === performance2.WritingMode.horizontal || orientation === performance2.WritingMode.horizontalOnly ? orientation : 0;
+                var vertical = orientation === performance2.WritingMode.vertical ? orientation : 0;
+                var horizontalIndexes = [
+                  symbolInstance.leftJustifiedTextSymbolIndex,
+                  symbolInstance.centerJustifiedTextSymbolIndex,
+                  symbolInstance.rightJustifiedTextSymbolIndex
+                ];
+                for (var i2 = 0, list = horizontalIndexes; i2 < list.length; i2 += 1) {
+                  var index = list[i2];
+                  bucket.text.placedSymbolArray.get(index).placedOrientation = horizontal;
+                }
+                if (symbolInstance.verticalPlacedTextSymbolIndex) {
+                  bucket.text.placedSymbolArray.get(symbolInstance.verticalPlacedTextSymbolIndex).placedOrientation = vertical;
+                }
+              };
+              Placement.prototype.commit = function commit(now) {
+                this.commitTime = now;
+                this.zoomAtLastRecencyCheck = this.transform.zoom;
+                var prevPlacement = this.prevPlacement;
+                var placementChanged = false;
+                this.prevZoomAdjustment = prevPlacement ? prevPlacement.zoomAdjustment(this.transform.zoom) : 0;
+                var increment = prevPlacement ? prevPlacement.symbolFadeChange(now) : 1;
+                var prevOpacities = prevPlacement ? prevPlacement.opacities : {};
+                var prevOffsets = prevPlacement ? prevPlacement.variableOffsets : {};
+                var prevOrientations = prevPlacement ? prevPlacement.placedOrientations : {};
+                for (var crossTileID in this.placements) {
+                  var jointPlacement = this.placements[crossTileID];
+                  var prevOpacity = prevOpacities[crossTileID];
+                  if (prevOpacity) {
+                    this.opacities[crossTileID] = new JointOpacityState(prevOpacity, increment, jointPlacement.text, jointPlacement.icon);
+                    placementChanged = placementChanged || jointPlacement.text !== prevOpacity.text.placed || jointPlacement.icon !== prevOpacity.icon.placed;
+                  } else {
+                    this.opacities[crossTileID] = new JointOpacityState(null, increment, jointPlacement.text, jointPlacement.icon, jointPlacement.skipFade);
+                    placementChanged = placementChanged || jointPlacement.text || jointPlacement.icon;
+                  }
+                }
+                for (var crossTileID$1 in prevOpacities) {
+                  var prevOpacity$1 = prevOpacities[crossTileID$1];
+                  if (!this.opacities[crossTileID$1]) {
+                    var jointOpacity = new JointOpacityState(prevOpacity$1, increment, false, false);
+                    if (!jointOpacity.isHidden()) {
+                      this.opacities[crossTileID$1] = jointOpacity;
+                      placementChanged = placementChanged || prevOpacity$1.text.placed || prevOpacity$1.icon.placed;
+                    }
+                  }
+                }
+                for (var crossTileID$2 in prevOffsets) {
+                  if (!this.variableOffsets[crossTileID$2] && this.opacities[crossTileID$2] && !this.opacities[crossTileID$2].isHidden()) {
+                    this.variableOffsets[crossTileID$2] = prevOffsets[crossTileID$2];
+                  }
+                }
+                for (var crossTileID$3 in prevOrientations) {
+                  if (!this.placedOrientations[crossTileID$3] && this.opacities[crossTileID$3] && !this.opacities[crossTileID$3].isHidden()) {
+                    this.placedOrientations[crossTileID$3] = prevOrientations[crossTileID$3];
+                  }
+                }
+                if (placementChanged) {
+                  this.lastPlacementChangeTime = now;
+                } else if (typeof this.lastPlacementChangeTime !== "number") {
+                  this.lastPlacementChangeTime = prevPlacement ? prevPlacement.lastPlacementChangeTime : now;
+                }
+              };
+              Placement.prototype.updateLayerOpacities = function updateLayerOpacities(styleLayer, tiles) {
+                var seenCrossTileIDs = {};
+                for (var i2 = 0, list = tiles; i2 < list.length; i2 += 1) {
+                  var tile = list[i2];
+                  var symbolBucket = tile.getBucket(styleLayer);
+                  if (symbolBucket && tile.latestFeatureIndex && styleLayer.id === symbolBucket.layerIds[0]) {
+                    this.updateBucketOpacities(symbolBucket, seenCrossTileIDs, tile.collisionBoxArray);
+                  }
+                }
+              };
+              Placement.prototype.updateBucketOpacities = function updateBucketOpacities(bucket, seenCrossTileIDs, collisionBoxArray) {
+                var this$1$1 = this;
+                if (bucket.hasTextData()) {
+                  bucket.text.opacityVertexArray.clear();
+                }
+                if (bucket.hasIconData()) {
+                  bucket.icon.opacityVertexArray.clear();
+                }
+                if (bucket.hasIconCollisionBoxData()) {
+                  bucket.iconCollisionBox.collisionVertexArray.clear();
+                }
+                if (bucket.hasTextCollisionBoxData()) {
+                  bucket.textCollisionBox.collisionVertexArray.clear();
+                }
+                var layout = bucket.layers[0].layout;
+                var duplicateOpacityState = new JointOpacityState(null, 0, false, false, true);
+                var textAllowOverlap = layout.get("text-allow-overlap");
+                var iconAllowOverlap = layout.get("icon-allow-overlap");
+                var variablePlacement = layout.get("text-variable-anchor");
+                var rotateWithMap = layout.get("text-rotation-alignment") === "map";
+                var pitchWithMap = layout.get("text-pitch-alignment") === "map";
+                var hasIconTextFit = layout.get("icon-text-fit") !== "none";
+                var defaultOpacityState = new JointOpacityState(null, 0, textAllowOverlap && (iconAllowOverlap || !bucket.hasIconData() || layout.get("icon-optional")), iconAllowOverlap && (textAllowOverlap || !bucket.hasTextData() || layout.get("text-optional")), true);
+                if (!bucket.collisionArrays && collisionBoxArray && (bucket.hasIconCollisionBoxData() || bucket.hasTextCollisionBoxData())) {
+                  bucket.deserializeCollisionBoxes(collisionBoxArray);
+                }
+                var addOpacities = function(iconOrText, numVertices, opacity) {
+                  for (var i2 = 0; i2 < numVertices / 4; i2++) {
+                    iconOrText.opacityVertexArray.emplaceBack(opacity);
+                  }
+                };
+                var loop = function(s22) {
+                  var symbolInstance = bucket.symbolInstances.get(s22);
+                  var numHorizontalGlyphVertices = symbolInstance.numHorizontalGlyphVertices;
+                  var numVerticalGlyphVertices = symbolInstance.numVerticalGlyphVertices;
+                  var crossTileID = symbolInstance.crossTileID;
+                  var isDuplicate = seenCrossTileIDs[crossTileID];
+                  var opacityState = this$1$1.opacities[crossTileID];
+                  if (isDuplicate) {
+                    opacityState = duplicateOpacityState;
+                  } else if (!opacityState) {
+                    opacityState = defaultOpacityState;
+                    this$1$1.opacities[crossTileID] = opacityState;
+                  }
+                  seenCrossTileIDs[crossTileID] = true;
+                  var hasText = numHorizontalGlyphVertices > 0 || numVerticalGlyphVertices > 0;
+                  var hasIcon = symbolInstance.numIconVertices > 0;
+                  var placedOrientation = this$1$1.placedOrientations[symbolInstance.crossTileID];
+                  var horizontalHidden = placedOrientation === performance2.WritingMode.vertical;
+                  var verticalHidden = placedOrientation === performance2.WritingMode.horizontal || placedOrientation === performance2.WritingMode.horizontalOnly;
+                  if (hasText) {
+                    var packedOpacity = packOpacity(opacityState.text);
+                    var horizontalOpacity = horizontalHidden ? PACKED_HIDDEN_OPACITY : packedOpacity;
+                    addOpacities(bucket.text, numHorizontalGlyphVertices, horizontalOpacity);
+                    var verticalOpacity = verticalHidden ? PACKED_HIDDEN_OPACITY : packedOpacity;
+                    addOpacities(bucket.text, numVerticalGlyphVertices, verticalOpacity);
+                    var symbolHidden = opacityState.text.isHidden();
+                    [
+                      symbolInstance.rightJustifiedTextSymbolIndex,
+                      symbolInstance.centerJustifiedTextSymbolIndex,
+                      symbolInstance.leftJustifiedTextSymbolIndex
+                    ].forEach(function(index) {
+                      if (index >= 0) {
+                        bucket.text.placedSymbolArray.get(index).hidden = symbolHidden || horizontalHidden ? 1 : 0;
+                      }
+                    });
+                    if (symbolInstance.verticalPlacedTextSymbolIndex >= 0) {
+                      bucket.text.placedSymbolArray.get(symbolInstance.verticalPlacedTextSymbolIndex).hidden = symbolHidden || verticalHidden ? 1 : 0;
+                    }
+                    var prevOffset = this$1$1.variableOffsets[symbolInstance.crossTileID];
+                    if (prevOffset) {
+                      this$1$1.markUsedJustification(bucket, prevOffset.anchor, symbolInstance, placedOrientation);
+                    }
+                    var prevOrientation = this$1$1.placedOrientations[symbolInstance.crossTileID];
+                    if (prevOrientation) {
+                      this$1$1.markUsedJustification(bucket, "left", symbolInstance, prevOrientation);
+                      this$1$1.markUsedOrientation(bucket, prevOrientation, symbolInstance);
+                    }
+                  }
+                  if (hasIcon) {
+                    var packedOpacity$1 = packOpacity(opacityState.icon);
+                    var useHorizontal = !(hasIconTextFit && symbolInstance.verticalPlacedIconSymbolIndex && horizontalHidden);
+                    if (symbolInstance.placedIconSymbolIndex >= 0) {
+                      var horizontalOpacity$1 = useHorizontal ? packedOpacity$1 : PACKED_HIDDEN_OPACITY;
+                      addOpacities(bucket.icon, symbolInstance.numIconVertices, horizontalOpacity$1);
+                      bucket.icon.placedSymbolArray.get(symbolInstance.placedIconSymbolIndex).hidden = opacityState.icon.isHidden();
+                    }
+                    if (symbolInstance.verticalPlacedIconSymbolIndex >= 0) {
+                      var verticalOpacity$1 = !useHorizontal ? packedOpacity$1 : PACKED_HIDDEN_OPACITY;
+                      addOpacities(bucket.icon, symbolInstance.numVerticalIconVertices, verticalOpacity$1);
+                      bucket.icon.placedSymbolArray.get(symbolInstance.verticalPlacedIconSymbolIndex).hidden = opacityState.icon.isHidden();
+                    }
+                  }
+                  if (bucket.hasIconCollisionBoxData() || bucket.hasTextCollisionBoxData()) {
+                    var collisionArrays = bucket.collisionArrays[s22];
+                    if (collisionArrays) {
+                      var shift = new performance2.Point(0, 0);
+                      if (collisionArrays.textBox || collisionArrays.verticalTextBox) {
+                        var used = true;
+                        if (variablePlacement) {
+                          var variableOffset = this$1$1.variableOffsets[crossTileID];
+                          if (variableOffset) {
+                            shift = calculateVariableLayoutShift(variableOffset.anchor, variableOffset.width, variableOffset.height, variableOffset.textOffset, variableOffset.textBoxScale);
+                            if (rotateWithMap) {
+                              shift._rotate(pitchWithMap ? this$1$1.transform.angle : -this$1$1.transform.angle);
+                            }
+                          } else {
+                            used = false;
+                          }
+                        }
+                        if (collisionArrays.textBox) {
+                          updateCollisionVertices(bucket.textCollisionBox.collisionVertexArray, opacityState.text.placed, !used || horizontalHidden, shift.x, shift.y);
+                        }
+                        if (collisionArrays.verticalTextBox) {
+                          updateCollisionVertices(bucket.textCollisionBox.collisionVertexArray, opacityState.text.placed, !used || verticalHidden, shift.x, shift.y);
+                        }
+                      }
+                      var verticalIconUsed = Boolean(!verticalHidden && collisionArrays.verticalIconBox);
+                      if (collisionArrays.iconBox) {
+                        updateCollisionVertices(bucket.iconCollisionBox.collisionVertexArray, opacityState.icon.placed, verticalIconUsed, hasIconTextFit ? shift.x : 0, hasIconTextFit ? shift.y : 0);
+                      }
+                      if (collisionArrays.verticalIconBox) {
+                        updateCollisionVertices(bucket.iconCollisionBox.collisionVertexArray, opacityState.icon.placed, !verticalIconUsed, hasIconTextFit ? shift.x : 0, hasIconTextFit ? shift.y : 0);
+                      }
+                    }
+                  }
+                };
+                for (var s2 = 0; s2 < bucket.symbolInstances.length; s2++)
+                  loop(s2);
+                bucket.sortFeatures(this.transform.angle);
+                if (this.retainedQueryData[bucket.bucketInstanceId]) {
+                  this.retainedQueryData[bucket.bucketInstanceId].featureSortOrder = bucket.featureSortOrder;
+                }
+                if (bucket.hasTextData() && bucket.text.opacityVertexBuffer) {
+                  bucket.text.opacityVertexBuffer.updateData(bucket.text.opacityVertexArray);
+                }
+                if (bucket.hasIconData() && bucket.icon.opacityVertexBuffer) {
+                  bucket.icon.opacityVertexBuffer.updateData(bucket.icon.opacityVertexArray);
+                }
+                if (bucket.hasIconCollisionBoxData() && bucket.iconCollisionBox.collisionVertexBuffer) {
+                  bucket.iconCollisionBox.collisionVertexBuffer.updateData(bucket.iconCollisionBox.collisionVertexArray);
+                }
+                if (bucket.hasTextCollisionBoxData() && bucket.textCollisionBox.collisionVertexBuffer) {
+                  bucket.textCollisionBox.collisionVertexBuffer.updateData(bucket.textCollisionBox.collisionVertexArray);
+                }
+                if (bucket.bucketInstanceId in this.collisionCircleArrays) {
+                  var instance2 = this.collisionCircleArrays[bucket.bucketInstanceId];
+                  bucket.placementInvProjMatrix = instance2.invProjMatrix;
+                  bucket.placementViewportMatrix = instance2.viewportMatrix;
+                  bucket.collisionCircleArray = instance2.circles;
+                  delete this.collisionCircleArrays[bucket.bucketInstanceId];
+                }
+              };
+              Placement.prototype.symbolFadeChange = function symbolFadeChange(now) {
+                return this.fadeDuration === 0 ? 1 : (now - this.commitTime) / this.fadeDuration + this.prevZoomAdjustment;
+              };
+              Placement.prototype.zoomAdjustment = function zoomAdjustment(zoom) {
+                return Math.max(0, (this.transform.zoom - zoom) / 1.5);
+              };
+              Placement.prototype.hasTransitions = function hasTransitions(now) {
+                return this.stale || now - this.lastPlacementChangeTime < this.fadeDuration;
+              };
+              Placement.prototype.stillRecent = function stillRecent(now, zoom) {
+                var durationAdjustment = this.zoomAtLastRecencyCheck === zoom ? 1 - this.zoomAdjustment(zoom) : 1;
+                this.zoomAtLastRecencyCheck = zoom;
+                return this.commitTime + this.fadeDuration * durationAdjustment > now;
+              };
+              Placement.prototype.setStale = function setStale() {
+                this.stale = true;
+              };
+              function updateCollisionVertices(collisionVertexArray, placed, notUsed, shiftX, shiftY) {
+                collisionVertexArray.emplaceBack(placed ? 1 : 0, notUsed ? 1 : 0, shiftX || 0, shiftY || 0);
+                collisionVertexArray.emplaceBack(placed ? 1 : 0, notUsed ? 1 : 0, shiftX || 0, shiftY || 0);
+                collisionVertexArray.emplaceBack(placed ? 1 : 0, notUsed ? 1 : 0, shiftX || 0, shiftY || 0);
+                collisionVertexArray.emplaceBack(placed ? 1 : 0, notUsed ? 1 : 0, shiftX || 0, shiftY || 0);
+              }
+              var shift25 = Math.pow(2, 25);
+              var shift24 = Math.pow(2, 24);
+              var shift17 = Math.pow(2, 17);
+              var shift16 = Math.pow(2, 16);
+              var shift9 = Math.pow(2, 9);
+              var shift8 = Math.pow(2, 8);
+              var shift1 = Math.pow(2, 1);
+              function packOpacity(opacityState) {
+                if (opacityState.opacity === 0 && !opacityState.placed) {
+                  return 0;
+                } else if (opacityState.opacity === 1 && opacityState.placed) {
+                  return 4294967295;
+                }
+                var targetBit = opacityState.placed ? 1 : 0;
+                var opacityBits = Math.floor(opacityState.opacity * 127);
+                return opacityBits * shift25 + targetBit * shift24 + opacityBits * shift17 + targetBit * shift16 + opacityBits * shift9 + targetBit * shift8 + opacityBits * shift1 + targetBit;
+              }
+              var PACKED_HIDDEN_OPACITY = 0;
+              var LayerPlacement = function LayerPlacement2(styleLayer) {
+                this._sortAcrossTiles = styleLayer.layout.get("symbol-z-order") !== "viewport-y" && styleLayer.layout.get("symbol-sort-key").constantOr(1) !== void 0;
+                this._currentTileIndex = 0;
+                this._currentPartIndex = 0;
+                this._seenCrossTileIDs = {};
+                this._bucketParts = [];
+              };
+              LayerPlacement.prototype.continuePlacement = function continuePlacement(tiles, placement, showCollisionBoxes, styleLayer, shouldPausePlacement) {
+                var bucketParts = this._bucketParts;
+                while (this._currentTileIndex < tiles.length) {
+                  var tile = tiles[this._currentTileIndex];
+                  placement.getBucketParts(bucketParts, styleLayer, tile, this._sortAcrossTiles);
+                  this._currentTileIndex++;
+                  if (shouldPausePlacement()) {
+                    return true;
+                  }
+                }
+                if (this._sortAcrossTiles) {
+                  this._sortAcrossTiles = false;
+                  bucketParts.sort(function(a2, b2) {
+                    return a2.sortKey - b2.sortKey;
+                  });
+                }
+                while (this._currentPartIndex < bucketParts.length) {
+                  var bucketPart = bucketParts[this._currentPartIndex];
+                  placement.placeLayerBucketPart(bucketPart, this._seenCrossTileIDs, showCollisionBoxes);
+                  this._currentPartIndex++;
+                  if (shouldPausePlacement()) {
+                    return true;
+                  }
+                }
+                return false;
+              };
+              var PauseablePlacement = function PauseablePlacement2(transform, order, forceFullPlacement, showCollisionBoxes, fadeDuration, crossSourceCollisions, prevPlacement) {
+                this.placement = new Placement(transform, fadeDuration, crossSourceCollisions, prevPlacement);
+                this._currentPlacementIndex = order.length - 1;
+                this._forceFullPlacement = forceFullPlacement;
+                this._showCollisionBoxes = showCollisionBoxes;
+                this._done = false;
+              };
+              PauseablePlacement.prototype.isDone = function isDone() {
+                return this._done;
+              };
+              PauseablePlacement.prototype.continuePlacement = function continuePlacement(order, layers, layerTiles) {
+                var this$1$1 = this;
+                var startTime = performance2.browser.now();
+                var shouldPausePlacement = function() {
+                  var elapsedTime = performance2.browser.now() - startTime;
+                  return this$1$1._forceFullPlacement ? false : elapsedTime > 2;
+                };
+                while (this._currentPlacementIndex >= 0) {
+                  var layerId = order[this._currentPlacementIndex];
+                  var layer = layers[layerId];
+                  var placementZoom = this.placement.collisionIndex.transform.zoom;
+                  if (layer.type === "symbol" && (!layer.minzoom || layer.minzoom <= placementZoom) && (!layer.maxzoom || layer.maxzoom > placementZoom)) {
+                    if (!this._inProgressLayer) {
+                      this._inProgressLayer = new LayerPlacement(layer);
+                    }
+                    var pausePlacement = this._inProgressLayer.continuePlacement(layerTiles[layer.source], this.placement, this._showCollisionBoxes, layer, shouldPausePlacement);
+                    if (pausePlacement) {
+                      return;
+                    }
+                    delete this._inProgressLayer;
+                  }
+                  this._currentPlacementIndex--;
+                }
+                this._done = true;
+              };
+              PauseablePlacement.prototype.commit = function commit(now) {
+                this.placement.commit(now);
+                return this.placement;
+              };
+              var roundingFactor = 512 / performance2.EXTENT / 2;
+              var TileLayerIndex = function TileLayerIndex2(tileID, symbolInstances, bucketInstanceId) {
+                this.tileID = tileID;
+                this.indexedSymbolInstances = {};
+                this.bucketInstanceId = bucketInstanceId;
+                for (var i2 = 0; i2 < symbolInstances.length; i2++) {
+                  var symbolInstance = symbolInstances.get(i2);
+                  var key = symbolInstance.key;
+                  if (!this.indexedSymbolInstances[key]) {
+                    this.indexedSymbolInstances[key] = [];
+                  }
+                  this.indexedSymbolInstances[key].push({
+                    crossTileID: symbolInstance.crossTileID,
+                    coord: this.getScaledCoordinates(symbolInstance, tileID)
+                  });
+                }
+              };
+              TileLayerIndex.prototype.getScaledCoordinates = function getScaledCoordinates(symbolInstance, childTileID) {
+                var zDifference = childTileID.canonical.z - this.tileID.canonical.z;
+                var scale2 = roundingFactor / Math.pow(2, zDifference);
+                return {
+                  x: Math.floor((childTileID.canonical.x * performance2.EXTENT + symbolInstance.anchorX) * scale2),
+                  y: Math.floor((childTileID.canonical.y * performance2.EXTENT + symbolInstance.anchorY) * scale2)
+                };
+              };
+              TileLayerIndex.prototype.findMatches = function findMatches(symbolInstances, newTileID, zoomCrossTileIDs) {
+                var tolerance = this.tileID.canonical.z < newTileID.canonical.z ? 1 : Math.pow(2, this.tileID.canonical.z - newTileID.canonical.z);
+                for (var i2 = 0; i2 < symbolInstances.length; i2++) {
+                  var symbolInstance = symbolInstances.get(i2);
+                  if (symbolInstance.crossTileID) {
+                    continue;
+                  }
+                  var indexedInstances = this.indexedSymbolInstances[symbolInstance.key];
+                  if (!indexedInstances) {
+                    continue;
+                  }
+                  var scaledSymbolCoord = this.getScaledCoordinates(symbolInstance, newTileID);
+                  for (var i$1 = 0, list = indexedInstances; i$1 < list.length; i$1 += 1) {
+                    var thisTileSymbol = list[i$1];
+                    if (Math.abs(thisTileSymbol.coord.x - scaledSymbolCoord.x) <= tolerance && Math.abs(thisTileSymbol.coord.y - scaledSymbolCoord.y) <= tolerance && !zoomCrossTileIDs[thisTileSymbol.crossTileID]) {
+                      zoomCrossTileIDs[thisTileSymbol.crossTileID] = true;
+                      symbolInstance.crossTileID = thisTileSymbol.crossTileID;
+                      break;
+                    }
+                  }
+                }
+              };
+              var CrossTileIDs = function CrossTileIDs2() {
+                this.maxCrossTileID = 0;
+              };
+              CrossTileIDs.prototype.generate = function generate() {
+                return ++this.maxCrossTileID;
+              };
+              var CrossTileSymbolLayerIndex = function CrossTileSymbolLayerIndex2() {
+                this.indexes = {};
+                this.usedCrossTileIDs = {};
+                this.lng = 0;
+              };
+              CrossTileSymbolLayerIndex.prototype.handleWrapJump = function handleWrapJump(lng) {
+                var wrapDelta = Math.round((lng - this.lng) / 360);
+                if (wrapDelta !== 0) {
+                  for (var zoom in this.indexes) {
+                    var zoomIndexes = this.indexes[zoom];
+                    var newZoomIndex = {};
+                    for (var key in zoomIndexes) {
+                      var index = zoomIndexes[key];
+                      index.tileID = index.tileID.unwrapTo(index.tileID.wrap + wrapDelta);
+                      newZoomIndex[index.tileID.key] = index;
+                    }
+                    this.indexes[zoom] = newZoomIndex;
+                  }
+                }
+                this.lng = lng;
+              };
+              CrossTileSymbolLayerIndex.prototype.addBucket = function addBucket(tileID, bucket, crossTileIDs) {
+                if (this.indexes[tileID.overscaledZ] && this.indexes[tileID.overscaledZ][tileID.key]) {
+                  if (this.indexes[tileID.overscaledZ][tileID.key].bucketInstanceId === bucket.bucketInstanceId) {
+                    return false;
+                  } else {
+                    this.removeBucketCrossTileIDs(tileID.overscaledZ, this.indexes[tileID.overscaledZ][tileID.key]);
+                  }
+                }
+                for (var i2 = 0; i2 < bucket.symbolInstances.length; i2++) {
+                  var symbolInstance = bucket.symbolInstances.get(i2);
+                  symbolInstance.crossTileID = 0;
+                }
+                if (!this.usedCrossTileIDs[tileID.overscaledZ]) {
+                  this.usedCrossTileIDs[tileID.overscaledZ] = {};
+                }
+                var zoomCrossTileIDs = this.usedCrossTileIDs[tileID.overscaledZ];
+                for (var zoom in this.indexes) {
+                  var zoomIndexes = this.indexes[zoom];
+                  if (Number(zoom) > tileID.overscaledZ) {
+                    for (var id2 in zoomIndexes) {
+                      var childIndex = zoomIndexes[id2];
+                      if (childIndex.tileID.isChildOf(tileID)) {
+                        childIndex.findMatches(bucket.symbolInstances, tileID, zoomCrossTileIDs);
+                      }
+                    }
+                  } else {
+                    var parentCoord = tileID.scaledTo(Number(zoom));
+                    var parentIndex = zoomIndexes[parentCoord.key];
+                    if (parentIndex) {
+                      parentIndex.findMatches(bucket.symbolInstances, tileID, zoomCrossTileIDs);
+                    }
+                  }
+                }
+                for (var i$1 = 0; i$1 < bucket.symbolInstances.length; i$1++) {
+                  var symbolInstance$1 = bucket.symbolInstances.get(i$1);
+                  if (!symbolInstance$1.crossTileID) {
+                    symbolInstance$1.crossTileID = crossTileIDs.generate();
+                    zoomCrossTileIDs[symbolInstance$1.crossTileID] = true;
+                  }
+                }
+                if (this.indexes[tileID.overscaledZ] === void 0) {
+                  this.indexes[tileID.overscaledZ] = {};
+                }
+                this.indexes[tileID.overscaledZ][tileID.key] = new TileLayerIndex(tileID, bucket.symbolInstances, bucket.bucketInstanceId);
+                return true;
+              };
+              CrossTileSymbolLayerIndex.prototype.removeBucketCrossTileIDs = function removeBucketCrossTileIDs(zoom, removedBucket) {
+                for (var key in removedBucket.indexedSymbolInstances) {
+                  for (var i2 = 0, list = removedBucket.indexedSymbolInstances[key]; i2 < list.length; i2 += 1) {
+                    var symbolInstance = list[i2];
+                    delete this.usedCrossTileIDs[zoom][symbolInstance.crossTileID];
+                  }
+                }
+              };
+              CrossTileSymbolLayerIndex.prototype.removeStaleBuckets = function removeStaleBuckets(currentIDs) {
+                var tilesChanged = false;
+                for (var z2 in this.indexes) {
+                  var zoomIndexes = this.indexes[z2];
+                  for (var tileKey in zoomIndexes) {
+                    if (!currentIDs[zoomIndexes[tileKey].bucketInstanceId]) {
+                      this.removeBucketCrossTileIDs(z2, zoomIndexes[tileKey]);
+                      delete zoomIndexes[tileKey];
+                      tilesChanged = true;
+                    }
+                  }
+                }
+                return tilesChanged;
+              };
+              var CrossTileSymbolIndex = function CrossTileSymbolIndex2() {
+                this.layerIndexes = {};
+                this.crossTileIDs = new CrossTileIDs();
+                this.maxBucketInstanceId = 0;
+                this.bucketsInCurrentPlacement = {};
+              };
+              CrossTileSymbolIndex.prototype.addLayer = function addLayer(styleLayer, tiles, lng) {
+                var layerIndex = this.layerIndexes[styleLayer.id];
+                if (layerIndex === void 0) {
+                  layerIndex = this.layerIndexes[styleLayer.id] = new CrossTileSymbolLayerIndex();
+                }
+                var symbolBucketsChanged = false;
+                var currentBucketIDs = {};
+                layerIndex.handleWrapJump(lng);
+                for (var i2 = 0, list = tiles; i2 < list.length; i2 += 1) {
+                  var tile = list[i2];
+                  var symbolBucket = tile.getBucket(styleLayer);
+                  if (!symbolBucket || styleLayer.id !== symbolBucket.layerIds[0]) {
+                    continue;
+                  }
+                  if (!symbolBucket.bucketInstanceId) {
+                    symbolBucket.bucketInstanceId = ++this.maxBucketInstanceId;
+                  }
+                  if (layerIndex.addBucket(tile.tileID, symbolBucket, this.crossTileIDs)) {
+                    symbolBucketsChanged = true;
+                  }
+                  currentBucketIDs[symbolBucket.bucketInstanceId] = true;
+                }
+                if (layerIndex.removeStaleBuckets(currentBucketIDs)) {
+                  symbolBucketsChanged = true;
+                }
+                return symbolBucketsChanged;
+              };
+              CrossTileSymbolIndex.prototype.pruneUnusedLayers = function pruneUnusedLayers(usedLayers) {
+                var usedLayerMap = {};
+                usedLayers.forEach(function(usedLayer) {
+                  usedLayerMap[usedLayer] = true;
+                });
+                for (var layerId in this.layerIndexes) {
+                  if (!usedLayerMap[layerId]) {
+                    delete this.layerIndexes[layerId];
+                  }
+                }
+              };
+              var emitValidationErrors = function(evented, errors) {
+                return performance2.emitValidationErrors(evented, errors && errors.filter(function(error) {
+                  return error.identifier !== "source.canvas";
+                }));
+              };
+              var supportedDiffOperations = performance2.pick(operations, [
+                "addLayer",
+                "removeLayer",
+                "setPaintProperty",
+                "setLayoutProperty",
+                "setFilter",
+                "addSource",
+                "removeSource",
+                "setLayerZoomRange",
+                "setLight",
+                "setTransition",
+                "setGeoJSONSourceData"
+              ]);
+              var ignoredDiffOperations = performance2.pick(operations, [
+                "setCenter",
+                "setZoom",
+                "setBearing",
+                "setPitch"
+              ]);
+              var empty = emptyStyle();
+              var Style = function(Evented) {
+                function Style2(map2, options) {
+                  var this$1$1 = this;
+                  if (options === void 0)
+                    options = {};
+                  Evented.call(this);
+                  this.map = map2;
+                  this.dispatcher = new Dispatcher(getGlobalWorkerPool(), this);
+                  this.imageManager = new ImageManager();
+                  this.imageManager.setEventedParent(this);
+                  this.glyphManager = new GlyphManager(map2._requestManager, options.localIdeographFontFamily);
+                  this.lineAtlas = new LineAtlas(256, 512);
+                  this.crossTileSymbolIndex = new CrossTileSymbolIndex();
+                  this._layers = {};
+                  this._serializedLayers = {};
+                  this._order = [];
+                  this.sourceCaches = {};
+                  this.zoomHistory = new performance2.ZoomHistory();
+                  this._loaded = false;
+                  this._availableImages = [];
+                  this._resetUpdates();
+                  this.dispatcher.broadcast("setReferrer", performance2.getReferrer());
+                  var self2 = this;
+                  this._rtlTextPluginCallback = Style2.registerForPluginStateChange(function(event) {
+                    var state = {
+                      pluginStatus: event.pluginStatus,
+                      pluginURL: event.pluginURL
+                    };
+                    self2.dispatcher.broadcast("syncRTLPluginState", state, function(err, results) {
+                      performance2.triggerPluginCompletionEvent(err);
+                      if (results) {
+                        var allComplete = results.every(function(elem) {
+                          return elem;
+                        });
+                        if (allComplete) {
+                          for (var id2 in self2.sourceCaches) {
+                            self2.sourceCaches[id2].reload();
+                          }
+                        }
+                      }
+                    });
+                  });
+                  this.on("data", function(event) {
+                    if (event.dataType !== "source" || event.sourceDataType !== "metadata") {
+                      return;
+                    }
+                    var sourceCache = this$1$1.sourceCaches[event.sourceId];
+                    if (!sourceCache) {
+                      return;
+                    }
+                    var source2 = sourceCache.getSource();
+                    if (!source2 || !source2.vectorLayerIds) {
+                      return;
+                    }
+                    for (var layerId in this$1$1._layers) {
+                      var layer = this$1$1._layers[layerId];
+                      if (layer.source === source2.id) {
+                        this$1$1._validateLayer(layer);
+                      }
+                    }
+                  });
+                }
+                if (Evented)
+                  Style2.__proto__ = Evented;
+                Style2.prototype = Object.create(Evented && Evented.prototype);
+                Style2.prototype.constructor = Style2;
+                Style2.prototype.loadURL = function loadURL(url, options) {
+                  var this$1$1 = this;
+                  if (options === void 0)
+                    options = {};
+                  this.fire(new performance2.Event("dataloading", { dataType: "style" }));
+                  var validate = typeof options.validate === "boolean" ? options.validate : !performance2.isMapboxURL(url);
+                  url = this.map._requestManager.normalizeStyleURL(url, options.accessToken);
+                  var request = this.map._requestManager.transformRequest(url, performance2.ResourceType.Style);
+                  this._request = performance2.getJSON(request, function(error, json) {
+                    this$1$1._request = null;
+                    if (error) {
+                      this$1$1.fire(new performance2.ErrorEvent(error));
+                    } else if (json) {
+                      this$1$1._load(json, validate);
+                    }
+                  });
+                };
+                Style2.prototype.loadJSON = function loadJSON(json, options) {
+                  var this$1$1 = this;
+                  if (options === void 0)
+                    options = {};
+                  this.fire(new performance2.Event("dataloading", { dataType: "style" }));
+                  this._request = performance2.browser.frame(function() {
+                    this$1$1._request = null;
+                    this$1$1._load(json, options.validate !== false);
+                  });
+                };
+                Style2.prototype.loadEmpty = function loadEmpty() {
+                  this.fire(new performance2.Event("dataloading", { dataType: "style" }));
+                  this._load(empty, false);
+                };
+                Style2.prototype._load = function _load(json, validate) {
+                  if (validate && emitValidationErrors(this, performance2.validateStyle(json))) {
+                    return;
+                  }
+                  this._loaded = true;
+                  this.stylesheet = json;
+                  for (var id2 in json.sources) {
+                    this.addSource(id2, json.sources[id2], { validate: false });
+                  }
+                  if (json.sprite) {
+                    this._loadSprite(json.sprite);
+                  } else {
+                    this.imageManager.setLoaded(true);
+                  }
+                  this.glyphManager.setURL(json.glyphs);
+                  var layers = derefLayers(this.stylesheet.layers);
+                  this._order = layers.map(function(layer2) {
+                    return layer2.id;
+                  });
+                  this._layers = {};
+                  this._serializedLayers = {};
+                  for (var i2 = 0, list = layers; i2 < list.length; i2 += 1) {
+                    var layer = list[i2];
+                    layer = performance2.createStyleLayer(layer);
+                    layer.setEventedParent(this, { layer: { id: layer.id } });
+                    this._layers[layer.id] = layer;
+                    this._serializedLayers[layer.id] = layer.serialize();
+                  }
+                  this.dispatcher.broadcast("setLayers", this._serializeLayers(this._order));
+                  this.light = new Light(this.stylesheet.light);
+                  this.fire(new performance2.Event("data", { dataType: "style" }));
+                  this.fire(new performance2.Event("style.load"));
+                };
+                Style2.prototype._loadSprite = function _loadSprite(url) {
+                  var this$1$1 = this;
+                  this._spriteRequest = loadSprite(url, this.map._requestManager, function(err, images) {
+                    this$1$1._spriteRequest = null;
+                    if (err) {
+                      this$1$1.fire(new performance2.ErrorEvent(err));
+                    } else if (images) {
+                      for (var id2 in images) {
+                        this$1$1.imageManager.addImage(id2, images[id2]);
+                      }
+                    }
+                    this$1$1.imageManager.setLoaded(true);
+                    this$1$1._availableImages = this$1$1.imageManager.listImages();
+                    this$1$1.dispatcher.broadcast("setImages", this$1$1._availableImages);
+                    this$1$1.fire(new performance2.Event("data", { dataType: "style" }));
+                  });
+                };
+                Style2.prototype._validateLayer = function _validateLayer(layer) {
+                  var sourceCache = this.sourceCaches[layer.source];
+                  if (!sourceCache) {
+                    return;
+                  }
+                  var sourceLayer = layer.sourceLayer;
+                  if (!sourceLayer) {
+                    return;
+                  }
+                  var source2 = sourceCache.getSource();
+                  if (source2.type === "geojson" || source2.vectorLayerIds && source2.vectorLayerIds.indexOf(sourceLayer) === -1) {
+                    this.fire(new performance2.ErrorEvent(new Error('Source layer "' + sourceLayer + '" does not exist on source "' + source2.id + '" as specified by style layer "' + layer.id + '"')));
+                  }
+                };
+                Style2.prototype.loaded = function loaded() {
+                  if (!this._loaded) {
+                    return false;
+                  }
+                  if (Object.keys(this._updatedSources).length) {
+                    return false;
+                  }
+                  for (var id2 in this.sourceCaches) {
+                    if (!this.sourceCaches[id2].loaded()) {
+                      return false;
+                    }
+                  }
+                  if (!this.imageManager.isLoaded()) {
+                    return false;
+                  }
+                  return true;
+                };
+                Style2.prototype._serializeLayers = function _serializeLayers(ids) {
+                  var serializedLayers = [];
+                  for (var i2 = 0, list = ids; i2 < list.length; i2 += 1) {
+                    var id2 = list[i2];
+                    var layer = this._layers[id2];
+                    if (layer.type !== "custom") {
+                      serializedLayers.push(layer.serialize());
+                    }
+                  }
+                  return serializedLayers;
+                };
+                Style2.prototype.hasTransitions = function hasTransitions() {
+                  if (this.light && this.light.hasTransition()) {
+                    return true;
+                  }
+                  for (var id2 in this.sourceCaches) {
+                    if (this.sourceCaches[id2].hasTransition()) {
+                      return true;
+                    }
+                  }
+                  for (var id$1 in this._layers) {
+                    if (this._layers[id$1].hasTransition()) {
+                      return true;
+                    }
+                  }
+                  return false;
+                };
+                Style2.prototype._checkLoaded = function _checkLoaded() {
+                  if (!this._loaded) {
+                    throw new Error("Style is not done loading");
+                  }
+                };
+                Style2.prototype.update = function update(parameters) {
+                  if (!this._loaded) {
+                    return;
+                  }
+                  var changed = this._changed;
+                  if (this._changed) {
+                    var updatedIds = Object.keys(this._updatedLayers);
+                    var removedIds = Object.keys(this._removedLayers);
+                    if (updatedIds.length || removedIds.length) {
+                      this._updateWorkerLayers(updatedIds, removedIds);
+                    }
+                    for (var id2 in this._updatedSources) {
+                      var action = this._updatedSources[id2];
+                      if (action === "reload") {
+                        this._reloadSource(id2);
+                      } else if (action === "clear") {
+                        this._clearSource(id2);
+                      }
+                    }
+                    this._updateTilesForChangedImages();
+                    for (var id$1 in this._updatedPaintProps) {
+                      this._layers[id$1].updateTransitions(parameters);
+                    }
+                    this.light.updateTransitions(parameters);
+                    this._resetUpdates();
+                  }
+                  var sourcesUsedBefore = {};
+                  for (var sourceId in this.sourceCaches) {
+                    var sourceCache = this.sourceCaches[sourceId];
+                    sourcesUsedBefore[sourceId] = sourceCache.used;
+                    sourceCache.used = false;
+                  }
+                  for (var i2 = 0, list = this._order; i2 < list.length; i2 += 1) {
+                    var layerId = list[i2];
+                    var layer = this._layers[layerId];
+                    layer.recalculate(parameters, this._availableImages);
+                    if (!layer.isHidden(parameters.zoom) && layer.source) {
+                      this.sourceCaches[layer.source].used = true;
+                    }
+                  }
+                  for (var sourceId$1 in sourcesUsedBefore) {
+                    var sourceCache$1 = this.sourceCaches[sourceId$1];
+                    if (sourcesUsedBefore[sourceId$1] !== sourceCache$1.used) {
+                      sourceCache$1.fire(new performance2.Event("data", {
+                        sourceDataType: "visibility",
+                        dataType: "source",
+                        sourceId: sourceId$1
+                      }));
+                    }
+                  }
+                  this.light.recalculate(parameters);
+                  this.z = parameters.zoom;
+                  if (changed) {
+                    this.fire(new performance2.Event("data", { dataType: "style" }));
+                  }
+                };
+                Style2.prototype._updateTilesForChangedImages = function _updateTilesForChangedImages() {
+                  var changedImages = Object.keys(this._changedImages);
+                  if (changedImages.length) {
+                    for (var name2 in this.sourceCaches) {
+                      this.sourceCaches[name2].reloadTilesForDependencies([
+                        "icons",
+                        "patterns"
+                      ], changedImages);
+                    }
+                    this._changedImages = {};
+                  }
+                };
+                Style2.prototype._updateWorkerLayers = function _updateWorkerLayers(updatedIds, removedIds) {
+                  this.dispatcher.broadcast("updateLayers", {
+                    layers: this._serializeLayers(updatedIds),
+                    removedIds
+                  });
+                };
+                Style2.prototype._resetUpdates = function _resetUpdates() {
+                  this._changed = false;
+                  this._updatedLayers = {};
+                  this._removedLayers = {};
+                  this._updatedSources = {};
+                  this._updatedPaintProps = {};
+                  this._changedImages = {};
+                };
+                Style2.prototype.setState = function setState(nextState) {
+                  var this$1$1 = this;
+                  this._checkLoaded();
+                  if (emitValidationErrors(this, performance2.validateStyle(nextState))) {
+                    return false;
+                  }
+                  nextState = performance2.clone$1(nextState);
+                  nextState.layers = derefLayers(nextState.layers);
+                  var changes = diffStyles(this.serialize(), nextState).filter(function(op) {
+                    return !(op.command in ignoredDiffOperations);
+                  });
+                  if (changes.length === 0) {
+                    return false;
+                  }
+                  var unimplementedOps = changes.filter(function(op) {
+                    return !(op.command in supportedDiffOperations);
+                  });
+                  if (unimplementedOps.length > 0) {
+                    throw new Error("Unimplemented: " + unimplementedOps.map(function(op) {
+                      return op.command;
+                    }).join(", ") + ".");
+                  }
+                  changes.forEach(function(op) {
+                    if (op.command === "setTransition") {
+                      return;
+                    }
+                    this$1$1[op.command].apply(this$1$1, op.args);
+                  });
+                  this.stylesheet = nextState;
+                  return true;
+                };
+                Style2.prototype.addImage = function addImage(id2, image) {
+                  if (this.getImage(id2)) {
+                    return this.fire(new performance2.ErrorEvent(new Error("An image with this name already exists.")));
+                  }
+                  this.imageManager.addImage(id2, image);
+                  this._afterImageUpdated(id2);
+                };
+                Style2.prototype.updateImage = function updateImage(id2, image) {
+                  this.imageManager.updateImage(id2, image);
+                };
+                Style2.prototype.getImage = function getImage(id2) {
+                  return this.imageManager.getImage(id2);
+                };
+                Style2.prototype.removeImage = function removeImage(id2) {
+                  if (!this.getImage(id2)) {
+                    return this.fire(new performance2.ErrorEvent(new Error("No image with this name exists.")));
+                  }
+                  this.imageManager.removeImage(id2);
+                  this._afterImageUpdated(id2);
+                };
+                Style2.prototype._afterImageUpdated = function _afterImageUpdated(id2) {
+                  this._availableImages = this.imageManager.listImages();
+                  this._changedImages[id2] = true;
+                  this._changed = true;
+                  this.dispatcher.broadcast("setImages", this._availableImages);
+                  this.fire(new performance2.Event("data", { dataType: "style" }));
+                };
+                Style2.prototype.listImages = function listImages() {
+                  this._checkLoaded();
+                  return this.imageManager.listImages();
+                };
+                Style2.prototype.addSource = function addSource2(id2, source2, options) {
+                  var this$1$1 = this;
+                  if (options === void 0)
+                    options = {};
+                  this._checkLoaded();
+                  if (this.sourceCaches[id2] !== void 0) {
+                    throw new Error("There is already a source with this ID");
+                  }
+                  if (!source2.type) {
+                    throw new Error("The type property must be defined, but only the following properties were given: " + Object.keys(source2).join(", ") + ".");
+                  }
+                  var builtIns = [
+                    "vector",
+                    "raster",
+                    "geojson",
+                    "video",
+                    "image"
+                  ];
+                  var shouldValidate = builtIns.indexOf(source2.type) >= 0;
+                  if (shouldValidate && this._validate(performance2.validateStyle.source, "sources." + id2, source2, null, options)) {
+                    return;
+                  }
+                  if (this.map && this.map._collectResourceTiming) {
+                    source2.collectResourceTiming = true;
+                  }
+                  var sourceCache = this.sourceCaches[id2] = new SourceCache(id2, source2, this.dispatcher);
+                  sourceCache.style = this;
+                  sourceCache.setEventedParent(this, function() {
+                    return {
+                      isSourceLoaded: this$1$1.loaded(),
+                      source: sourceCache.serialize(),
+                      sourceId: id2
+                    };
+                  });
+                  sourceCache.onAdd(this.map);
+                  this._changed = true;
+                };
+                Style2.prototype.removeSource = function removeSource2(id2) {
+                  this._checkLoaded();
+                  if (this.sourceCaches[id2] === void 0) {
+                    throw new Error("There is no source with this ID");
+                  }
+                  for (var layerId in this._layers) {
+                    if (this._layers[layerId].source === id2) {
+                      return this.fire(new performance2.ErrorEvent(new Error('Source "' + id2 + '" cannot be removed while layer "' + layerId + '" is using it.')));
+                    }
+                  }
+                  var sourceCache = this.sourceCaches[id2];
+                  delete this.sourceCaches[id2];
+                  delete this._updatedSources[id2];
+                  sourceCache.fire(new performance2.Event("data", {
+                    sourceDataType: "metadata",
+                    dataType: "source",
+                    sourceId: id2
+                  }));
+                  sourceCache.setEventedParent(null);
+                  sourceCache.clearTiles();
+                  if (sourceCache.onRemove) {
+                    sourceCache.onRemove(this.map);
+                  }
+                  this._changed = true;
+                };
+                Style2.prototype.setGeoJSONSourceData = function setGeoJSONSourceData(id2, data) {
+                  this._checkLoaded();
+                  var geojsonSource = this.sourceCaches[id2].getSource();
+                  geojsonSource.setData(data);
+                  this._changed = true;
+                };
+                Style2.prototype.getSource = function getSource(id2) {
+                  return this.sourceCaches[id2] && this.sourceCaches[id2].getSource();
+                };
+                Style2.prototype.addLayer = function addLayer(layerObject, before, options) {
+                  if (options === void 0)
+                    options = {};
+                  this._checkLoaded();
+                  var id2 = layerObject.id;
+                  if (this.getLayer(id2)) {
+                    this.fire(new performance2.ErrorEvent(new Error('Layer with id "' + id2 + '" already exists on this map')));
+                    return;
+                  }
+                  var layer;
+                  if (layerObject.type === "custom") {
+                    if (emitValidationErrors(this, performance2.validateCustomStyleLayer(layerObject))) {
+                      return;
+                    }
+                    layer = performance2.createStyleLayer(layerObject);
+                  } else {
+                    if (typeof layerObject.source === "object") {
+                      this.addSource(id2, layerObject.source);
+                      layerObject = performance2.clone$1(layerObject);
+                      layerObject = performance2.extend(layerObject, { source: id2 });
+                    }
+                    if (this._validate(performance2.validateStyle.layer, "layers." + id2, layerObject, { arrayIndex: -1 }, options)) {
+                      return;
+                    }
+                    layer = performance2.createStyleLayer(layerObject);
+                    this._validateLayer(layer);
+                    layer.setEventedParent(this, { layer: { id: id2 } });
+                    this._serializedLayers[layer.id] = layer.serialize();
+                  }
+                  var index = before ? this._order.indexOf(before) : this._order.length;
+                  if (before && index === -1) {
+                    this.fire(new performance2.ErrorEvent(new Error('Layer with id "' + before + '" does not exist on this map.')));
+                    return;
+                  }
+                  this._order.splice(index, 0, id2);
+                  this._layerOrderChanged = true;
+                  this._layers[id2] = layer;
+                  if (this._removedLayers[id2] && layer.source && layer.type !== "custom") {
+                    var removed = this._removedLayers[id2];
+                    delete this._removedLayers[id2];
+                    if (removed.type !== layer.type) {
+                      this._updatedSources[layer.source] = "clear";
+                    } else {
+                      this._updatedSources[layer.source] = "reload";
+                      this.sourceCaches[layer.source].pause();
+                    }
+                  }
+                  this._updateLayer(layer);
+                  if (layer.onAdd) {
+                    layer.onAdd(this.map);
+                  }
+                };
+                Style2.prototype.moveLayer = function moveLayer(id2, before) {
+                  this._checkLoaded();
+                  this._changed = true;
+                  var layer = this._layers[id2];
+                  if (!layer) {
+                    this.fire(new performance2.ErrorEvent(new Error("The layer '" + id2 + "' does not exist in the map's style and cannot be moved.")));
+                    return;
+                  }
+                  if (id2 === before) {
+                    return;
+                  }
+                  var index = this._order.indexOf(id2);
+                  this._order.splice(index, 1);
+                  var newIndex = before ? this._order.indexOf(before) : this._order.length;
+                  if (before && newIndex === -1) {
+                    this.fire(new performance2.ErrorEvent(new Error('Layer with id "' + before + '" does not exist on this map.')));
+                    return;
+                  }
+                  this._order.splice(newIndex, 0, id2);
+                  this._layerOrderChanged = true;
+                };
+                Style2.prototype.removeLayer = function removeLayer(id2) {
+                  this._checkLoaded();
+                  var layer = this._layers[id2];
+                  if (!layer) {
+                    this.fire(new performance2.ErrorEvent(new Error("The layer '" + id2 + "' does not exist in the map's style and cannot be removed.")));
+                    return;
+                  }
+                  layer.setEventedParent(null);
+                  var index = this._order.indexOf(id2);
+                  this._order.splice(index, 1);
+                  this._layerOrderChanged = true;
+                  this._changed = true;
+                  this._removedLayers[id2] = layer;
+                  delete this._layers[id2];
+                  delete this._serializedLayers[id2];
+                  delete this._updatedLayers[id2];
+                  delete this._updatedPaintProps[id2];
+                  if (layer.onRemove) {
+                    layer.onRemove(this.map);
+                  }
+                };
+                Style2.prototype.getLayer = function getLayer(id2) {
+                  return this._layers[id2];
+                };
+                Style2.prototype.hasLayer = function hasLayer(id2) {
+                  return id2 in this._layers;
+                };
+                Style2.prototype.setLayerZoomRange = function setLayerZoomRange(layerId, minzoom, maxzoom) {
+                  this._checkLoaded();
+                  var layer = this.getLayer(layerId);
+                  if (!layer) {
+                    this.fire(new performance2.ErrorEvent(new Error("The layer '" + layerId + "' does not exist in the map's style and cannot have zoom extent.")));
+                    return;
+                  }
+                  if (layer.minzoom === minzoom && layer.maxzoom === maxzoom) {
+                    return;
+                  }
+                  if (minzoom != null) {
+                    layer.minzoom = minzoom;
+                  }
+                  if (maxzoom != null) {
+                    layer.maxzoom = maxzoom;
+                  }
+                  this._updateLayer(layer);
+                };
+                Style2.prototype.setFilter = function setFilter(layerId, filter, options) {
+                  if (options === void 0)
+                    options = {};
+                  this._checkLoaded();
+                  var layer = this.getLayer(layerId);
+                  if (!layer) {
+                    this.fire(new performance2.ErrorEvent(new Error("The layer '" + layerId + "' does not exist in the map's style and cannot be filtered.")));
+                    return;
+                  }
+                  if (performance2.deepEqual(layer.filter, filter)) {
+                    return;
+                  }
+                  if (filter === null || filter === void 0) {
+                    layer.filter = void 0;
+                    this._updateLayer(layer);
+                    return;
+                  }
+                  if (this._validate(performance2.validateStyle.filter, "layers." + layer.id + ".filter", filter, null, options)) {
+                    return;
+                  }
+                  layer.filter = performance2.clone$1(filter);
+                  this._updateLayer(layer);
+                };
+                Style2.prototype.getFilter = function getFilter(layer) {
+                  return performance2.clone$1(this.getLayer(layer).filter);
+                };
+                Style2.prototype.setLayoutProperty = function setLayoutProperty(layerId, name2, value, options) {
+                  if (options === void 0)
+                    options = {};
+                  this._checkLoaded();
+                  var layer = this.getLayer(layerId);
+                  if (!layer) {
+                    this.fire(new performance2.ErrorEvent(new Error("The layer '" + layerId + "' does not exist in the map's style and cannot be styled.")));
+                    return;
+                  }
+                  if (performance2.deepEqual(layer.getLayoutProperty(name2), value)) {
+                    return;
+                  }
+                  layer.setLayoutProperty(name2, value, options);
+                  this._updateLayer(layer);
+                };
+                Style2.prototype.getLayoutProperty = function getLayoutProperty(layerId, name2) {
+                  var layer = this.getLayer(layerId);
+                  if (!layer) {
+                    this.fire(new performance2.ErrorEvent(new Error("The layer '" + layerId + "' does not exist in the map's style.")));
+                    return;
+                  }
+                  return layer.getLayoutProperty(name2);
+                };
+                Style2.prototype.setPaintProperty = function setPaintProperty(layerId, name2, value, options) {
+                  if (options === void 0)
+                    options = {};
+                  this._checkLoaded();
+                  var layer = this.getLayer(layerId);
+                  if (!layer) {
+                    this.fire(new performance2.ErrorEvent(new Error("The layer '" + layerId + "' does not exist in the map's style and cannot be styled.")));
+                    return;
+                  }
+                  if (performance2.deepEqual(layer.getPaintProperty(name2), value)) {
+                    return;
+                  }
+                  var requiresRelayout = layer.setPaintProperty(name2, value, options);
+                  if (requiresRelayout) {
+                    this._updateLayer(layer);
+                  }
+                  this._changed = true;
+                  this._updatedPaintProps[layerId] = true;
+                };
+                Style2.prototype.getPaintProperty = function getPaintProperty(layer, name2) {
+                  return this.getLayer(layer).getPaintProperty(name2);
+                };
+                Style2.prototype.setFeatureState = function setFeatureState(target, state) {
+                  this._checkLoaded();
+                  var sourceId = target.source;
+                  var sourceLayer = target.sourceLayer;
+                  var sourceCache = this.sourceCaches[sourceId];
+                  if (sourceCache === void 0) {
+                    this.fire(new performance2.ErrorEvent(new Error("The source '" + sourceId + "' does not exist in the map's style.")));
+                    return;
+                  }
+                  var sourceType = sourceCache.getSource().type;
+                  if (sourceType === "geojson" && sourceLayer) {
+                    this.fire(new performance2.ErrorEvent(new Error("GeoJSON sources cannot have a sourceLayer parameter.")));
+                    return;
+                  }
+                  if (sourceType === "vector" && !sourceLayer) {
+                    this.fire(new performance2.ErrorEvent(new Error("The sourceLayer parameter must be provided for vector source types.")));
+                    return;
+                  }
+                  if (target.id === void 0) {
+                    this.fire(new performance2.ErrorEvent(new Error("The feature id parameter must be provided.")));
+                  }
+                  sourceCache.setFeatureState(sourceLayer, target.id, state);
+                };
+                Style2.prototype.removeFeatureState = function removeFeatureState(target, key) {
+                  this._checkLoaded();
+                  var sourceId = target.source;
+                  var sourceCache = this.sourceCaches[sourceId];
+                  if (sourceCache === void 0) {
+                    this.fire(new performance2.ErrorEvent(new Error("The source '" + sourceId + "' does not exist in the map's style.")));
+                    return;
+                  }
+                  var sourceType = sourceCache.getSource().type;
+                  var sourceLayer = sourceType === "vector" ? target.sourceLayer : void 0;
+                  if (sourceType === "vector" && !sourceLayer) {
+                    this.fire(new performance2.ErrorEvent(new Error("The sourceLayer parameter must be provided for vector source types.")));
+                    return;
+                  }
+                  if (key && (typeof target.id !== "string" && typeof target.id !== "number")) {
+                    this.fire(new performance2.ErrorEvent(new Error("A feature id is required to remove its specific state property.")));
+                    return;
+                  }
+                  sourceCache.removeFeatureState(sourceLayer, target.id, key);
+                };
+                Style2.prototype.getFeatureState = function getFeatureState(target) {
+                  this._checkLoaded();
+                  var sourceId = target.source;
+                  var sourceLayer = target.sourceLayer;
+                  var sourceCache = this.sourceCaches[sourceId];
+                  if (sourceCache === void 0) {
+                    this.fire(new performance2.ErrorEvent(new Error("The source '" + sourceId + "' does not exist in the map's style.")));
+                    return;
+                  }
+                  var sourceType = sourceCache.getSource().type;
+                  if (sourceType === "vector" && !sourceLayer) {
+                    this.fire(new performance2.ErrorEvent(new Error("The sourceLayer parameter must be provided for vector source types.")));
+                    return;
+                  }
+                  if (target.id === void 0) {
+                    this.fire(new performance2.ErrorEvent(new Error("The feature id parameter must be provided.")));
+                  }
+                  return sourceCache.getFeatureState(sourceLayer, target.id);
+                };
+                Style2.prototype.getTransition = function getTransition() {
+                  return performance2.extend({
+                    duration: 300,
+                    delay: 0
+                  }, this.stylesheet && this.stylesheet.transition);
+                };
+                Style2.prototype.serialize = function serialize() {
+                  return performance2.filterObject({
+                    version: this.stylesheet.version,
+                    name: this.stylesheet.name,
+                    metadata: this.stylesheet.metadata,
+                    light: this.stylesheet.light,
+                    center: this.stylesheet.center,
+                    zoom: this.stylesheet.zoom,
+                    bearing: this.stylesheet.bearing,
+                    pitch: this.stylesheet.pitch,
+                    sprite: this.stylesheet.sprite,
+                    glyphs: this.stylesheet.glyphs,
+                    transition: this.stylesheet.transition,
+                    sources: performance2.mapObject(this.sourceCaches, function(source2) {
+                      return source2.serialize();
+                    }),
+                    layers: this._serializeLayers(this._order)
+                  }, function(value) {
+                    return value !== void 0;
+                  });
+                };
+                Style2.prototype._updateLayer = function _updateLayer(layer) {
+                  this._updatedLayers[layer.id] = true;
+                  if (layer.source && !this._updatedSources[layer.source] && this.sourceCaches[layer.source].getSource().type !== "raster") {
+                    this._updatedSources[layer.source] = "reload";
+                    this.sourceCaches[layer.source].pause();
+                  }
+                  this._changed = true;
+                };
+                Style2.prototype._flattenAndSortRenderedFeatures = function _flattenAndSortRenderedFeatures(sourceResults) {
+                  var this$1$1 = this;
+                  var isLayer3D = function(layerId2) {
+                    return this$1$1._layers[layerId2].type === "fill-extrusion";
+                  };
+                  var layerIndex = {};
+                  var features3D = [];
+                  for (var l2 = this._order.length - 1; l2 >= 0; l2--) {
+                    var layerId = this._order[l2];
+                    if (isLayer3D(layerId)) {
+                      layerIndex[layerId] = l2;
+                      for (var i$2 = 0, list$1 = sourceResults; i$2 < list$1.length; i$2 += 1) {
+                        var sourceResult = list$1[i$2];
+                        var layerFeatures = sourceResult[layerId];
+                        if (layerFeatures) {
+                          for (var i$1 = 0, list = layerFeatures; i$1 < list.length; i$1 += 1) {
+                            var featureWrapper = list[i$1];
+                            features3D.push(featureWrapper);
+                          }
+                        }
+                      }
+                    }
+                  }
+                  features3D.sort(function(a2, b2) {
+                    return b2.intersectionZ - a2.intersectionZ;
+                  });
+                  var features = [];
+                  for (var l$12 = this._order.length - 1; l$12 >= 0; l$12--) {
+                    var layerId$1 = this._order[l$12];
+                    if (isLayer3D(layerId$1)) {
+                      for (var i2 = features3D.length - 1; i2 >= 0; i2--) {
+                        var topmost3D = features3D[i2].feature;
+                        if (layerIndex[topmost3D.layer.id] < l$12) {
+                          break;
+                        }
+                        features.push(topmost3D);
+                        features3D.pop();
+                      }
+                    } else {
+                      for (var i$4 = 0, list$3 = sourceResults; i$4 < list$3.length; i$4 += 1) {
+                        var sourceResult$1 = list$3[i$4];
+                        var layerFeatures$1 = sourceResult$1[layerId$1];
+                        if (layerFeatures$1) {
+                          for (var i$3 = 0, list$2 = layerFeatures$1; i$3 < list$2.length; i$3 += 1) {
+                            var featureWrapper$1 = list$2[i$3];
+                            features.push(featureWrapper$1.feature);
+                          }
+                        }
+                      }
+                    }
+                  }
+                  return features;
+                };
+                Style2.prototype.queryRenderedFeatures = function queryRenderedFeatures$1(queryGeometry, params, transform) {
+                  if (params && params.filter) {
+                    this._validate(performance2.validateStyle.filter, "queryRenderedFeatures.filter", params.filter, null, params);
+                  }
+                  var includedSources = {};
+                  if (params && params.layers) {
+                    if (!Array.isArray(params.layers)) {
+                      this.fire(new performance2.ErrorEvent(new Error("parameters.layers must be an Array.")));
+                      return [];
+                    }
+                    for (var i2 = 0, list = params.layers; i2 < list.length; i2 += 1) {
+                      var layerId = list[i2];
+                      var layer = this._layers[layerId];
+                      if (!layer) {
+                        this.fire(new performance2.ErrorEvent(new Error("The layer '" + layerId + "' does not exist in the map's style and cannot be queried for features.")));
+                        return [];
+                      }
+                      includedSources[layer.source] = true;
+                    }
+                  }
+                  var sourceResults = [];
+                  params.availableImages = this._availableImages;
+                  for (var id2 in this.sourceCaches) {
+                    if (params.layers && !includedSources[id2]) {
+                      continue;
+                    }
+                    sourceResults.push(queryRenderedFeatures(this.sourceCaches[id2], this._layers, this._serializedLayers, queryGeometry, params, transform));
+                  }
+                  if (this.placement) {
+                    sourceResults.push(queryRenderedSymbols(this._layers, this._serializedLayers, this.sourceCaches, queryGeometry, params, this.placement.collisionIndex, this.placement.retainedQueryData));
+                  }
+                  return this._flattenAndSortRenderedFeatures(sourceResults);
+                };
+                Style2.prototype.querySourceFeatures = function querySourceFeatures$1(sourceID, params) {
+                  if (params && params.filter) {
+                    this._validate(performance2.validateStyle.filter, "querySourceFeatures.filter", params.filter, null, params);
+                  }
+                  var sourceCache = this.sourceCaches[sourceID];
+                  return sourceCache ? querySourceFeatures(sourceCache, params) : [];
+                };
+                Style2.prototype.addSourceType = function addSourceType(name2, SourceType, callback) {
+                  if (Style2.getSourceType(name2)) {
+                    return callback(new Error('A source type called "' + name2 + '" already exists.'));
+                  }
+                  Style2.setSourceType(name2, SourceType);
+                  if (!SourceType.workerSourceURL) {
+                    return callback(null, null);
+                  }
+                  this.dispatcher.broadcast("loadWorkerSource", {
+                    name: name2,
+                    url: SourceType.workerSourceURL
+                  }, callback);
+                };
+                Style2.prototype.getLight = function getLight() {
+                  return this.light.getLight();
+                };
+                Style2.prototype.setLight = function setLight(lightOptions, options) {
+                  if (options === void 0)
+                    options = {};
+                  this._checkLoaded();
+                  var light = this.light.getLight();
+                  var _update = false;
+                  for (var key in lightOptions) {
+                    if (!performance2.deepEqual(lightOptions[key], light[key])) {
+                      _update = true;
+                      break;
+                    }
+                  }
+                  if (!_update) {
+                    return;
+                  }
+                  var parameters = {
+                    now: performance2.browser.now(),
+                    transition: performance2.extend({
+                      duration: 300,
+                      delay: 0
+                    }, this.stylesheet.transition)
+                  };
+                  this.light.setLight(lightOptions, options);
+                  this.light.updateTransitions(parameters);
+                };
+                Style2.prototype._validate = function _validate(validate, key, value, props, options) {
+                  if (options === void 0)
+                    options = {};
+                  if (options && options.validate === false) {
+                    return false;
+                  }
+                  return emitValidationErrors(this, validate.call(performance2.validateStyle, performance2.extend({
+                    key,
+                    style: this.serialize(),
+                    value,
+                    styleSpec: performance2.styleSpec
+                  }, props)));
+                };
+                Style2.prototype._remove = function _remove() {
+                  if (this._request) {
+                    this._request.cancel();
+                    this._request = null;
+                  }
+                  if (this._spriteRequest) {
+                    this._spriteRequest.cancel();
+                    this._spriteRequest = null;
+                  }
+                  performance2.evented.off("pluginStateChange", this._rtlTextPluginCallback);
+                  for (var layerId in this._layers) {
+                    var layer = this._layers[layerId];
+                    layer.setEventedParent(null);
+                  }
+                  for (var id2 in this.sourceCaches) {
+                    this.sourceCaches[id2].clearTiles();
+                    this.sourceCaches[id2].setEventedParent(null);
+                  }
+                  this.imageManager.setEventedParent(null);
+                  this.setEventedParent(null);
+                  this.dispatcher.remove();
+                };
+                Style2.prototype._clearSource = function _clearSource(id2) {
+                  this.sourceCaches[id2].clearTiles();
+                };
+                Style2.prototype._reloadSource = function _reloadSource(id2) {
+                  this.sourceCaches[id2].resume();
+                  this.sourceCaches[id2].reload();
+                };
+                Style2.prototype._updateSources = function _updateSources(transform) {
+                  for (var id2 in this.sourceCaches) {
+                    this.sourceCaches[id2].update(transform);
+                  }
+                };
+                Style2.prototype._generateCollisionBoxes = function _generateCollisionBoxes() {
+                  for (var id2 in this.sourceCaches) {
+                    this._reloadSource(id2);
+                  }
+                };
+                Style2.prototype._updatePlacement = function _updatePlacement(transform, showCollisionBoxes, fadeDuration, crossSourceCollisions, forceFullPlacement) {
+                  if (forceFullPlacement === void 0)
+                    forceFullPlacement = false;
+                  var symbolBucketsChanged = false;
+                  var placementCommitted = false;
+                  var layerTiles = {};
+                  for (var i2 = 0, list = this._order; i2 < list.length; i2 += 1) {
+                    var layerID = list[i2];
+                    var styleLayer = this._layers[layerID];
+                    if (styleLayer.type !== "symbol") {
+                      continue;
+                    }
+                    if (!layerTiles[styleLayer.source]) {
+                      var sourceCache = this.sourceCaches[styleLayer.source];
+                      layerTiles[styleLayer.source] = sourceCache.getRenderableIds(true).map(function(id2) {
+                        return sourceCache.getTileByID(id2);
+                      }).sort(function(a2, b2) {
+                        return b2.tileID.overscaledZ - a2.tileID.overscaledZ || (a2.tileID.isLessThan(b2.tileID) ? -1 : 1);
+                      });
+                    }
+                    var layerBucketsChanged = this.crossTileSymbolIndex.addLayer(styleLayer, layerTiles[styleLayer.source], transform.center.lng);
+                    symbolBucketsChanged = symbolBucketsChanged || layerBucketsChanged;
+                  }
+                  this.crossTileSymbolIndex.pruneUnusedLayers(this._order);
+                  forceFullPlacement = forceFullPlacement || this._layerOrderChanged || fadeDuration === 0;
+                  if (forceFullPlacement || !this.pauseablePlacement || this.pauseablePlacement.isDone() && !this.placement.stillRecent(performance2.browser.now(), transform.zoom)) {
+                    this.pauseablePlacement = new PauseablePlacement(transform, this._order, forceFullPlacement, showCollisionBoxes, fadeDuration, crossSourceCollisions, this.placement);
+                    this._layerOrderChanged = false;
+                  }
+                  if (this.pauseablePlacement.isDone()) {
+                    this.placement.setStale();
+                  } else {
+                    this.pauseablePlacement.continuePlacement(this._order, this._layers, layerTiles);
+                    if (this.pauseablePlacement.isDone()) {
+                      this.placement = this.pauseablePlacement.commit(performance2.browser.now());
+                      placementCommitted = true;
+                    }
+                    if (symbolBucketsChanged) {
+                      this.pauseablePlacement.placement.setStale();
+                    }
+                  }
+                  if (placementCommitted || symbolBucketsChanged) {
+                    for (var i$1 = 0, list$1 = this._order; i$1 < list$1.length; i$1 += 1) {
+                      var layerID$1 = list$1[i$1];
+                      var styleLayer$1 = this._layers[layerID$1];
+                      if (styleLayer$1.type !== "symbol") {
+                        continue;
+                      }
+                      this.placement.updateLayerOpacities(styleLayer$1, layerTiles[styleLayer$1.source]);
+                    }
+                  }
+                  var needsRerender = !this.pauseablePlacement.isDone() || this.placement.hasTransitions(performance2.browser.now());
+                  return needsRerender;
+                };
+                Style2.prototype._releaseSymbolFadeTiles = function _releaseSymbolFadeTiles() {
+                  for (var id2 in this.sourceCaches) {
+                    this.sourceCaches[id2].releaseSymbolFadeTiles();
+                  }
+                };
+                Style2.prototype.getImages = function getImages(mapId, params, callback) {
+                  this.imageManager.getImages(params.icons, callback);
+                  this._updateTilesForChangedImages();
+                  var sourceCache = this.sourceCaches[params.source];
+                  if (sourceCache) {
+                    sourceCache.setDependencies(params.tileID.key, params.type, params.icons);
+                  }
+                };
+                Style2.prototype.getGlyphs = function getGlyphs(mapId, params, callback) {
+                  this.glyphManager.getGlyphs(params.stacks, callback);
+                };
+                Style2.prototype.getResource = function getResource(mapId, params, callback) {
+                  return performance2.makeRequest(params, callback);
+                };
+                return Style2;
+              }(performance2.Evented);
+              Style.getSourceType = getType2;
+              Style.setSourceType = setType;
+              Style.registerForPluginStateChange = performance2.registerForPluginStateChange;
+              var posAttributes = performance2.createLayout([{
+                name: "a_pos",
+                type: "Int16",
+                components: 2
+              }]);
+              var preludeFrag = "#ifdef GL_ES\nprecision mediump float;\n#else\n#if !defined(lowp)\n#define lowp\n#endif\n#if !defined(mediump)\n#define mediump\n#endif\n#if !defined(highp)\n#define highp\n#endif\n#endif";
+              var preludeVert = "#ifdef GL_ES\nprecision highp float;\n#else\n#if !defined(lowp)\n#define lowp\n#endif\n#if !defined(mediump)\n#define mediump\n#endif\n#if !defined(highp)\n#define highp\n#endif\n#endif\nvec2 unpack_float(const float packedValue) {int packedIntValue=int(packedValue);int v0=packedIntValue/256;return vec2(v0,packedIntValue-v0*256);}vec2 unpack_opacity(const float packedOpacity) {int intOpacity=int(packedOpacity)/2;return vec2(float(intOpacity)/127.0,mod(packedOpacity,2.0));}vec4 decode_color(const vec2 encodedColor) {return vec4(unpack_float(encodedColor[0])/255.0,unpack_float(encodedColor[1])/255.0\n);}float unpack_mix_vec2(const vec2 packedValue,const float t) {return mix(packedValue[0],packedValue[1],t);}vec4 unpack_mix_color(const vec4 packedColors,const float t) {vec4 minColor=decode_color(vec2(packedColors[0],packedColors[1]));vec4 maxColor=decode_color(vec2(packedColors[2],packedColors[3]));return mix(minColor,maxColor,t);}vec2 get_pattern_pos(const vec2 pixel_coord_upper,const vec2 pixel_coord_lower,const vec2 pattern_size,const float tile_units_to_pixels,const vec2 pos) {vec2 offset=mod(mod(mod(pixel_coord_upper,pattern_size)*256.0,pattern_size)*256.0+pixel_coord_lower,pattern_size);return (tile_units_to_pixels*pos+offset)/pattern_size;}";
+              var backgroundFrag = "uniform vec4 u_color;uniform float u_opacity;void main() {gl_FragColor=u_color*u_opacity;\n#ifdef OVERDRAW_INSPECTOR\ngl_FragColor=vec4(1.0);\n#endif\n}";
+              var backgroundVert = "attribute vec2 a_pos;uniform mat4 u_matrix;void main() {gl_Position=u_matrix*vec4(a_pos,0,1);}";
+              var backgroundPatternFrag = "uniform vec2 u_pattern_tl_a;uniform vec2 u_pattern_br_a;uniform vec2 u_pattern_tl_b;uniform vec2 u_pattern_br_b;uniform vec2 u_texsize;uniform float u_mix;uniform float u_opacity;uniform sampler2D u_image;varying vec2 v_pos_a;varying vec2 v_pos_b;void main() {vec2 imagecoord=mod(v_pos_a,1.0);vec2 pos=mix(u_pattern_tl_a/u_texsize,u_pattern_br_a/u_texsize,imagecoord);vec4 color1=texture2D(u_image,pos);vec2 imagecoord_b=mod(v_pos_b,1.0);vec2 pos2=mix(u_pattern_tl_b/u_texsize,u_pattern_br_b/u_texsize,imagecoord_b);vec4 color2=texture2D(u_image,pos2);gl_FragColor=mix(color1,color2,u_mix)*u_opacity;\n#ifdef OVERDRAW_INSPECTOR\ngl_FragColor=vec4(1.0);\n#endif\n}";
+              var backgroundPatternVert = "uniform mat4 u_matrix;uniform vec2 u_pattern_size_a;uniform vec2 u_pattern_size_b;uniform vec2 u_pixel_coord_upper;uniform vec2 u_pixel_coord_lower;uniform float u_scale_a;uniform float u_scale_b;uniform float u_tile_units_to_pixels;attribute vec2 a_pos;varying vec2 v_pos_a;varying vec2 v_pos_b;void main() {gl_Position=u_matrix*vec4(a_pos,0,1);v_pos_a=get_pattern_pos(u_pixel_coord_upper,u_pixel_coord_lower,u_scale_a*u_pattern_size_a,u_tile_units_to_pixels,a_pos);v_pos_b=get_pattern_pos(u_pixel_coord_upper,u_pixel_coord_lower,u_scale_b*u_pattern_size_b,u_tile_units_to_pixels,a_pos);}";
+              var circleFrag = "varying vec3 v_data;\n#pragma mapbox: define highp vec4 color\n#pragma mapbox: define mediump float radius\n#pragma mapbox: define lowp float blur\n#pragma mapbox: define lowp float opacity\n#pragma mapbox: define highp vec4 stroke_color\n#pragma mapbox: define mediump float stroke_width\n#pragma mapbox: define lowp float stroke_opacity\nvoid main() {\n#pragma mapbox: initialize highp vec4 color\n#pragma mapbox: initialize mediump float radius\n#pragma mapbox: initialize lowp float blur\n#pragma mapbox: initialize lowp float opacity\n#pragma mapbox: initialize highp vec4 stroke_color\n#pragma mapbox: initialize mediump float stroke_width\n#pragma mapbox: initialize lowp float stroke_opacity\nvec2 extrude=v_data.xy;float extrude_length=length(extrude);lowp float antialiasblur=v_data.z;float antialiased_blur=-max(blur,antialiasblur);float opacity_t=smoothstep(0.0,antialiased_blur,extrude_length-1.0);float color_t=stroke_width < 0.01 ? 0.0 : smoothstep(antialiased_blur,0.0,extrude_length-radius/(radius+stroke_width));gl_FragColor=opacity_t*mix(color*opacity,stroke_color*stroke_opacity,color_t);\n#ifdef OVERDRAW_INSPECTOR\ngl_FragColor=vec4(1.0);\n#endif\n}";
+              var circleVert = "uniform mat4 u_matrix;uniform bool u_scale_with_map;uniform bool u_pitch_with_map;uniform vec2 u_extrude_scale;uniform lowp float u_device_pixel_ratio;uniform highp float u_camera_to_center_distance;attribute vec2 a_pos;varying vec3 v_data;\n#pragma mapbox: define highp vec4 color\n#pragma mapbox: define mediump float radius\n#pragma mapbox: define lowp float blur\n#pragma mapbox: define lowp float opacity\n#pragma mapbox: define highp vec4 stroke_color\n#pragma mapbox: define mediump float stroke_width\n#pragma mapbox: define lowp float stroke_opacity\nvoid main(void) {\n#pragma mapbox: initialize highp vec4 color\n#pragma mapbox: initialize mediump float radius\n#pragma mapbox: initialize lowp float blur\n#pragma mapbox: initialize lowp float opacity\n#pragma mapbox: initialize highp vec4 stroke_color\n#pragma mapbox: initialize mediump float stroke_width\n#pragma mapbox: initialize lowp float stroke_opacity\nvec2 extrude=vec2(mod(a_pos,2.0)*2.0-1.0);vec2 circle_center=floor(a_pos*0.5);if (u_pitch_with_map) {vec2 corner_position=circle_center;if (u_scale_with_map) {corner_position+=extrude*(radius+stroke_width)*u_extrude_scale;} else {vec4 projected_center=u_matrix*vec4(circle_center,0,1);corner_position+=extrude*(radius+stroke_width)*u_extrude_scale*(projected_center.w/u_camera_to_center_distance);}gl_Position=u_matrix*vec4(corner_position,0,1);} else {gl_Position=u_matrix*vec4(circle_center,0,1);if (u_scale_with_map) {gl_Position.xy+=extrude*(radius+stroke_width)*u_extrude_scale*u_camera_to_center_distance;} else {gl_Position.xy+=extrude*(radius+stroke_width)*u_extrude_scale*gl_Position.w;}}lowp float antialiasblur=1.0/u_device_pixel_ratio/(radius+stroke_width);v_data=vec3(extrude.x,extrude.y,antialiasblur);}";
+              var clippingMaskFrag = "void main() {gl_FragColor=vec4(1.0);}";
+              var clippingMaskVert = "attribute vec2 a_pos;uniform mat4 u_matrix;void main() {gl_Position=u_matrix*vec4(a_pos,0,1);}";
+              var heatmapFrag = "uniform highp float u_intensity;varying vec2 v_extrude;\n#pragma mapbox: define highp float weight\n#define GAUSS_COEF 0.3989422804014327\nvoid main() {\n#pragma mapbox: initialize highp float weight\nfloat d=-0.5*3.0*3.0*dot(v_extrude,v_extrude);float val=weight*u_intensity*GAUSS_COEF*exp(d);gl_FragColor=vec4(val,1.0,1.0,1.0);\n#ifdef OVERDRAW_INSPECTOR\ngl_FragColor=vec4(1.0);\n#endif\n}";
+              var heatmapVert = "uniform mat4 u_matrix;uniform float u_extrude_scale;uniform float u_opacity;uniform float u_intensity;attribute vec2 a_pos;varying vec2 v_extrude;\n#pragma mapbox: define highp float weight\n#pragma mapbox: define mediump float radius\nconst highp float ZERO=1.0/255.0/16.0;\n#define GAUSS_COEF 0.3989422804014327\nvoid main(void) {\n#pragma mapbox: initialize highp float weight\n#pragma mapbox: initialize mediump float radius\nvec2 unscaled_extrude=vec2(mod(a_pos,2.0)*2.0-1.0);float S=sqrt(-2.0*log(ZERO/weight/u_intensity/GAUSS_COEF))/3.0;v_extrude=S*unscaled_extrude;vec2 extrude=v_extrude*radius*u_extrude_scale;vec4 pos=vec4(floor(a_pos*0.5)+extrude,0,1);gl_Position=u_matrix*pos;}";
+              var heatmapTextureFrag = "uniform sampler2D u_image;uniform sampler2D u_color_ramp;uniform float u_opacity;varying vec2 v_pos;void main() {float t=texture2D(u_image,v_pos).r;vec4 color=texture2D(u_color_ramp,vec2(t,0.5));gl_FragColor=color*u_opacity;\n#ifdef OVERDRAW_INSPECTOR\ngl_FragColor=vec4(0.0);\n#endif\n}";
+              var heatmapTextureVert = "uniform mat4 u_matrix;uniform vec2 u_world;attribute vec2 a_pos;varying vec2 v_pos;void main() {gl_Position=u_matrix*vec4(a_pos*u_world,0,1);v_pos.x=a_pos.x;v_pos.y=1.0-a_pos.y;}";
+              var collisionBoxFrag = "varying float v_placed;varying float v_notUsed;void main() {float alpha=0.5;gl_FragColor=vec4(1.0,0.0,0.0,1.0)*alpha;if (v_placed > 0.5) {gl_FragColor=vec4(0.0,0.0,1.0,0.5)*alpha;}if (v_notUsed > 0.5) {gl_FragColor*=.1;}}";
+              var collisionBoxVert = "attribute vec2 a_pos;attribute vec2 a_anchor_pos;attribute vec2 a_extrude;attribute vec2 a_placed;attribute vec2 a_shift;uniform mat4 u_matrix;uniform vec2 u_extrude_scale;uniform float u_camera_to_center_distance;varying float v_placed;varying float v_notUsed;void main() {vec4 projectedPoint=u_matrix*vec4(a_anchor_pos,0,1);highp float camera_to_anchor_distance=projectedPoint.w;highp float collision_perspective_ratio=clamp(0.5+0.5*(u_camera_to_center_distance/camera_to_anchor_distance),0.0,4.0);gl_Position=u_matrix*vec4(a_pos,0.0,1.0);gl_Position.xy+=(a_extrude+a_shift)*u_extrude_scale*gl_Position.w*collision_perspective_ratio;v_placed=a_placed.x;v_notUsed=a_placed.y;}";
+              var collisionCircleFrag = "varying float v_radius;varying vec2 v_extrude;varying float v_perspective_ratio;varying float v_collision;void main() {float alpha=0.5*min(v_perspective_ratio,1.0);float stroke_radius=0.9*max(v_perspective_ratio,1.0);float distance_to_center=length(v_extrude);float distance_to_edge=abs(distance_to_center-v_radius);float opacity_t=smoothstep(-stroke_radius,0.0,-distance_to_edge);vec4 color=mix(vec4(0.0,0.0,1.0,0.5),vec4(1.0,0.0,0.0,1.0),v_collision);gl_FragColor=color*alpha*opacity_t;}";
+              var collisionCircleVert = "attribute vec2 a_pos;attribute float a_radius;attribute vec2 a_flags;uniform mat4 u_matrix;uniform mat4 u_inv_matrix;uniform vec2 u_viewport_size;uniform float u_camera_to_center_distance;varying float v_radius;varying vec2 v_extrude;varying float v_perspective_ratio;varying float v_collision;vec3 toTilePosition(vec2 screenPos) {vec4 rayStart=u_inv_matrix*vec4(screenPos,-1.0,1.0);vec4 rayEnd  =u_inv_matrix*vec4(screenPos, 1.0,1.0);rayStart.xyz/=rayStart.w;rayEnd.xyz  /=rayEnd.w;highp float t=(0.0-rayStart.z)/(rayEnd.z-rayStart.z);return mix(rayStart.xyz,rayEnd.xyz,t);}void main() {vec2 quadCenterPos=a_pos;float radius=a_radius;float collision=a_flags.x;float vertexIdx=a_flags.y;vec2 quadVertexOffset=vec2(mix(-1.0,1.0,float(vertexIdx >=2.0)),mix(-1.0,1.0,float(vertexIdx >=1.0 && vertexIdx <=2.0)));vec2 quadVertexExtent=quadVertexOffset*radius;vec3 tilePos=toTilePosition(quadCenterPos);vec4 clipPos=u_matrix*vec4(tilePos,1.0);highp float camera_to_anchor_distance=clipPos.w;highp float collision_perspective_ratio=clamp(0.5+0.5*(u_camera_to_center_distance/camera_to_anchor_distance),0.0,4.0);float padding_factor=1.2;v_radius=radius;v_extrude=quadVertexExtent*padding_factor;v_perspective_ratio=collision_perspective_ratio;v_collision=collision;gl_Position=vec4(clipPos.xyz/clipPos.w,1.0)+vec4(quadVertexExtent*padding_factor/u_viewport_size*2.0,0.0,0.0);}";
+              var debugFrag = "uniform highp vec4 u_color;uniform sampler2D u_overlay;varying vec2 v_uv;void main() {vec4 overlay_color=texture2D(u_overlay,v_uv);gl_FragColor=mix(u_color,overlay_color,overlay_color.a);}";
+              var debugVert = "attribute vec2 a_pos;varying vec2 v_uv;uniform mat4 u_matrix;uniform float u_overlay_scale;void main() {v_uv=a_pos/8192.0;gl_Position=u_matrix*vec4(a_pos*u_overlay_scale,0,1);}";
+              var fillFrag = "#pragma mapbox: define highp vec4 color\n#pragma mapbox: define lowp float opacity\nvoid main() {\n#pragma mapbox: initialize highp vec4 color\n#pragma mapbox: initialize lowp float opacity\ngl_FragColor=color*opacity;\n#ifdef OVERDRAW_INSPECTOR\ngl_FragColor=vec4(1.0);\n#endif\n}";
+              var fillVert = "attribute vec2 a_pos;uniform mat4 u_matrix;\n#pragma mapbox: define highp vec4 color\n#pragma mapbox: define lowp float opacity\nvoid main() {\n#pragma mapbox: initialize highp vec4 color\n#pragma mapbox: initialize lowp float opacity\ngl_Position=u_matrix*vec4(a_pos,0,1);}";
+              var fillOutlineFrag = "varying vec2 v_pos;\n#pragma mapbox: define highp vec4 outline_color\n#pragma mapbox: define lowp float opacity\nvoid main() {\n#pragma mapbox: initialize highp vec4 outline_color\n#pragma mapbox: initialize lowp float opacity\nfloat dist=length(v_pos-gl_FragCoord.xy);float alpha=1.0-smoothstep(0.0,1.0,dist);gl_FragColor=outline_color*(alpha*opacity);\n#ifdef OVERDRAW_INSPECTOR\ngl_FragColor=vec4(1.0);\n#endif\n}";
+              var fillOutlineVert = "attribute vec2 a_pos;uniform mat4 u_matrix;uniform vec2 u_world;varying vec2 v_pos;\n#pragma mapbox: define highp vec4 outline_color\n#pragma mapbox: define lowp float opacity\nvoid main() {\n#pragma mapbox: initialize highp vec4 outline_color\n#pragma mapbox: initialize lowp float opacity\ngl_Position=u_matrix*vec4(a_pos,0,1);v_pos=(gl_Position.xy/gl_Position.w+1.0)/2.0*u_world;}";
+              var fillOutlinePatternFrag = "uniform vec2 u_texsize;uniform sampler2D u_image;uniform float u_fade;varying vec2 v_pos_a;varying vec2 v_pos_b;varying vec2 v_pos;\n#pragma mapbox: define lowp float opacity\n#pragma mapbox: define lowp vec4 pattern_from\n#pragma mapbox: define lowp vec4 pattern_to\nvoid main() {\n#pragma mapbox: initialize lowp float opacity\n#pragma mapbox: initialize mediump vec4 pattern_from\n#pragma mapbox: initialize mediump vec4 pattern_to\nvec2 pattern_tl_a=pattern_from.xy;vec2 pattern_br_a=pattern_from.zw;vec2 pattern_tl_b=pattern_to.xy;vec2 pattern_br_b=pattern_to.zw;vec2 imagecoord=mod(v_pos_a,1.0);vec2 pos=mix(pattern_tl_a/u_texsize,pattern_br_a/u_texsize,imagecoord);vec4 color1=texture2D(u_image,pos);vec2 imagecoord_b=mod(v_pos_b,1.0);vec2 pos2=mix(pattern_tl_b/u_texsize,pattern_br_b/u_texsize,imagecoord_b);vec4 color2=texture2D(u_image,pos2);float dist=length(v_pos-gl_FragCoord.xy);float alpha=1.0-smoothstep(0.0,1.0,dist);gl_FragColor=mix(color1,color2,u_fade)*alpha*opacity;\n#ifdef OVERDRAW_INSPECTOR\ngl_FragColor=vec4(1.0);\n#endif\n}";
+              var fillOutlinePatternVert = "uniform mat4 u_matrix;uniform vec2 u_world;uniform vec2 u_pixel_coord_upper;uniform vec2 u_pixel_coord_lower;uniform vec3 u_scale;attribute vec2 a_pos;varying vec2 v_pos_a;varying vec2 v_pos_b;varying vec2 v_pos;\n#pragma mapbox: define lowp float opacity\n#pragma mapbox: define lowp vec4 pattern_from\n#pragma mapbox: define lowp vec4 pattern_to\n#pragma mapbox: define lowp float pixel_ratio_from\n#pragma mapbox: define lowp float pixel_ratio_to\nvoid main() {\n#pragma mapbox: initialize lowp float opacity\n#pragma mapbox: initialize mediump vec4 pattern_from\n#pragma mapbox: initialize mediump vec4 pattern_to\n#pragma mapbox: initialize lowp float pixel_ratio_from\n#pragma mapbox: initialize lowp float pixel_ratio_to\nvec2 pattern_tl_a=pattern_from.xy;vec2 pattern_br_a=pattern_from.zw;vec2 pattern_tl_b=pattern_to.xy;vec2 pattern_br_b=pattern_to.zw;float tileRatio=u_scale.x;float fromScale=u_scale.y;float toScale=u_scale.z;gl_Position=u_matrix*vec4(a_pos,0,1);vec2 display_size_a=(pattern_br_a-pattern_tl_a)/pixel_ratio_from;vec2 display_size_b=(pattern_br_b-pattern_tl_b)/pixel_ratio_to;v_pos_a=get_pattern_pos(u_pixel_coord_upper,u_pixel_coord_lower,fromScale*display_size_a,tileRatio,a_pos);v_pos_b=get_pattern_pos(u_pixel_coord_upper,u_pixel_coord_lower,toScale*display_size_b,tileRatio,a_pos);v_pos=(gl_Position.xy/gl_Position.w+1.0)/2.0*u_world;}";
+              var fillPatternFrag = "uniform vec2 u_texsize;uniform float u_fade;uniform sampler2D u_image;varying vec2 v_pos_a;varying vec2 v_pos_b;\n#pragma mapbox: define lowp float opacity\n#pragma mapbox: define lowp vec4 pattern_from\n#pragma mapbox: define lowp vec4 pattern_to\nvoid main() {\n#pragma mapbox: initialize lowp float opacity\n#pragma mapbox: initialize mediump vec4 pattern_from\n#pragma mapbox: initialize mediump vec4 pattern_to\nvec2 pattern_tl_a=pattern_from.xy;vec2 pattern_br_a=pattern_from.zw;vec2 pattern_tl_b=pattern_to.xy;vec2 pattern_br_b=pattern_to.zw;vec2 imagecoord=mod(v_pos_a,1.0);vec2 pos=mix(pattern_tl_a/u_texsize,pattern_br_a/u_texsize,imagecoord);vec4 color1=texture2D(u_image,pos);vec2 imagecoord_b=mod(v_pos_b,1.0);vec2 pos2=mix(pattern_tl_b/u_texsize,pattern_br_b/u_texsize,imagecoord_b);vec4 color2=texture2D(u_image,pos2);gl_FragColor=mix(color1,color2,u_fade)*opacity;\n#ifdef OVERDRAW_INSPECTOR\ngl_FragColor=vec4(1.0);\n#endif\n}";
+              var fillPatternVert = "uniform mat4 u_matrix;uniform vec2 u_pixel_coord_upper;uniform vec2 u_pixel_coord_lower;uniform vec3 u_scale;attribute vec2 a_pos;varying vec2 v_pos_a;varying vec2 v_pos_b;\n#pragma mapbox: define lowp float opacity\n#pragma mapbox: define lowp vec4 pattern_from\n#pragma mapbox: define lowp vec4 pattern_to\n#pragma mapbox: define lowp float pixel_ratio_from\n#pragma mapbox: define lowp float pixel_ratio_to\nvoid main() {\n#pragma mapbox: initialize lowp float opacity\n#pragma mapbox: initialize mediump vec4 pattern_from\n#pragma mapbox: initialize mediump vec4 pattern_to\n#pragma mapbox: initialize lowp float pixel_ratio_from\n#pragma mapbox: initialize lowp float pixel_ratio_to\nvec2 pattern_tl_a=pattern_from.xy;vec2 pattern_br_a=pattern_from.zw;vec2 pattern_tl_b=pattern_to.xy;vec2 pattern_br_b=pattern_to.zw;float tileZoomRatio=u_scale.x;float fromScale=u_scale.y;float toScale=u_scale.z;vec2 display_size_a=(pattern_br_a-pattern_tl_a)/pixel_ratio_from;vec2 display_size_b=(pattern_br_b-pattern_tl_b)/pixel_ratio_to;gl_Position=u_matrix*vec4(a_pos,0,1);v_pos_a=get_pattern_pos(u_pixel_coord_upper,u_pixel_coord_lower,fromScale*display_size_a,tileZoomRatio,a_pos);v_pos_b=get_pattern_pos(u_pixel_coord_upper,u_pixel_coord_lower,toScale*display_size_b,tileZoomRatio,a_pos);}";
+              var fillExtrusionFrag = "varying vec4 v_color;void main() {gl_FragColor=v_color;\n#ifdef OVERDRAW_INSPECTOR\ngl_FragColor=vec4(1.0);\n#endif\n}";
+              var fillExtrusionVert = "uniform mat4 u_matrix;uniform vec3 u_lightcolor;uniform lowp vec3 u_lightpos;uniform lowp float u_lightintensity;uniform float u_vertical_gradient;uniform lowp float u_opacity;attribute vec2 a_pos;attribute vec4 a_normal_ed;varying vec4 v_color;\n#pragma mapbox: define highp float base\n#pragma mapbox: define highp float height\n#pragma mapbox: define highp vec4 color\nvoid main() {\n#pragma mapbox: initialize highp float base\n#pragma mapbox: initialize highp float height\n#pragma mapbox: initialize highp vec4 color\nvec3 normal=a_normal_ed.xyz;base=max(0.0,base);height=max(0.0,height);float t=mod(normal.x,2.0);gl_Position=u_matrix*vec4(a_pos,t > 0.0 ? height : base,1);float colorvalue=color.r*0.2126+color.g*0.7152+color.b*0.0722;v_color=vec4(0.0,0.0,0.0,1.0);vec4 ambientlight=vec4(0.03,0.03,0.03,1.0);color+=ambientlight;float directional=clamp(dot(normal/16384.0,u_lightpos),0.0,1.0);directional=mix((1.0-u_lightintensity),max((1.0-colorvalue+u_lightintensity),1.0),directional);if (normal.y !=0.0) {directional*=((1.0-u_vertical_gradient)+(u_vertical_gradient*clamp((t+base)*pow(height/150.0,0.5),mix(0.7,0.98,1.0-u_lightintensity),1.0)));}v_color.r+=clamp(color.r*directional*u_lightcolor.r,mix(0.0,0.3,1.0-u_lightcolor.r),1.0);v_color.g+=clamp(color.g*directional*u_lightcolor.g,mix(0.0,0.3,1.0-u_lightcolor.g),1.0);v_color.b+=clamp(color.b*directional*u_lightcolor.b,mix(0.0,0.3,1.0-u_lightcolor.b),1.0);v_color*=u_opacity;}";
+              var fillExtrusionPatternFrag = "uniform vec2 u_texsize;uniform float u_fade;uniform sampler2D u_image;varying vec2 v_pos_a;varying vec2 v_pos_b;varying vec4 v_lighting;\n#pragma mapbox: define lowp float base\n#pragma mapbox: define lowp float height\n#pragma mapbox: define lowp vec4 pattern_from\n#pragma mapbox: define lowp vec4 pattern_to\n#pragma mapbox: define lowp float pixel_ratio_from\n#pragma mapbox: define lowp float pixel_ratio_to\nvoid main() {\n#pragma mapbox: initialize lowp float base\n#pragma mapbox: initialize lowp float height\n#pragma mapbox: initialize mediump vec4 pattern_from\n#pragma mapbox: initialize mediump vec4 pattern_to\n#pragma mapbox: initialize lowp float pixel_ratio_from\n#pragma mapbox: initialize lowp float pixel_ratio_to\nvec2 pattern_tl_a=pattern_from.xy;vec2 pattern_br_a=pattern_from.zw;vec2 pattern_tl_b=pattern_to.xy;vec2 pattern_br_b=pattern_to.zw;vec2 imagecoord=mod(v_pos_a,1.0);vec2 pos=mix(pattern_tl_a/u_texsize,pattern_br_a/u_texsize,imagecoord);vec4 color1=texture2D(u_image,pos);vec2 imagecoord_b=mod(v_pos_b,1.0);vec2 pos2=mix(pattern_tl_b/u_texsize,pattern_br_b/u_texsize,imagecoord_b);vec4 color2=texture2D(u_image,pos2);vec4 mixedColor=mix(color1,color2,u_fade);gl_FragColor=mixedColor*v_lighting;\n#ifdef OVERDRAW_INSPECTOR\ngl_FragColor=vec4(1.0);\n#endif\n}";
+              var fillExtrusionPatternVert = "uniform mat4 u_matrix;uniform vec2 u_pixel_coord_upper;uniform vec2 u_pixel_coord_lower;uniform float u_height_factor;uniform vec3 u_scale;uniform float u_vertical_gradient;uniform lowp float u_opacity;uniform vec3 u_lightcolor;uniform lowp vec3 u_lightpos;uniform lowp float u_lightintensity;attribute vec2 a_pos;attribute vec4 a_normal_ed;varying vec2 v_pos_a;varying vec2 v_pos_b;varying vec4 v_lighting;\n#pragma mapbox: define lowp float base\n#pragma mapbox: define lowp float height\n#pragma mapbox: define lowp vec4 pattern_from\n#pragma mapbox: define lowp vec4 pattern_to\n#pragma mapbox: define lowp float pixel_ratio_from\n#pragma mapbox: define lowp float pixel_ratio_to\nvoid main() {\n#pragma mapbox: initialize lowp float base\n#pragma mapbox: initialize lowp float height\n#pragma mapbox: initialize mediump vec4 pattern_from\n#pragma mapbox: initialize mediump vec4 pattern_to\n#pragma mapbox: initialize lowp float pixel_ratio_from\n#pragma mapbox: initialize lowp float pixel_ratio_to\nvec2 pattern_tl_a=pattern_from.xy;vec2 pattern_br_a=pattern_from.zw;vec2 pattern_tl_b=pattern_to.xy;vec2 pattern_br_b=pattern_to.zw;float tileRatio=u_scale.x;float fromScale=u_scale.y;float toScale=u_scale.z;vec3 normal=a_normal_ed.xyz;float edgedistance=a_normal_ed.w;vec2 display_size_a=(pattern_br_a-pattern_tl_a)/pixel_ratio_from;vec2 display_size_b=(pattern_br_b-pattern_tl_b)/pixel_ratio_to;base=max(0.0,base);height=max(0.0,height);float t=mod(normal.x,2.0);float z=t > 0.0 ? height : base;gl_Position=u_matrix*vec4(a_pos,z,1);vec2 pos=normal.x==1.0 && normal.y==0.0 && normal.z==16384.0\n? a_pos\n: vec2(edgedistance,z*u_height_factor);v_pos_a=get_pattern_pos(u_pixel_coord_upper,u_pixel_coord_lower,fromScale*display_size_a,tileRatio,pos);v_pos_b=get_pattern_pos(u_pixel_coord_upper,u_pixel_coord_lower,toScale*display_size_b,tileRatio,pos);v_lighting=vec4(0.0,0.0,0.0,1.0);float directional=clamp(dot(normal/16383.0,u_lightpos),0.0,1.0);directional=mix((1.0-u_lightintensity),max((0.5+u_lightintensity),1.0),directional);if (normal.y !=0.0) {directional*=((1.0-u_vertical_gradient)+(u_vertical_gradient*clamp((t+base)*pow(height/150.0,0.5),mix(0.7,0.98,1.0-u_lightintensity),1.0)));}v_lighting.rgb+=clamp(directional*u_lightcolor,mix(vec3(0.0),vec3(0.3),1.0-u_lightcolor),vec3(1.0));v_lighting*=u_opacity;}";
+              var hillshadePrepareFrag = "#ifdef GL_ES\nprecision highp float;\n#endif\nuniform sampler2D u_image;varying vec2 v_pos;uniform vec2 u_dimension;uniform float u_zoom;uniform vec4 u_unpack;float getElevation(vec2 coord,float bias) {vec4 data=texture2D(u_image,coord)*255.0;data.a=-1.0;return dot(data,u_unpack)/4.0;}void main() {vec2 epsilon=1.0/u_dimension;float a=getElevation(v_pos+vec2(-epsilon.x,-epsilon.y),0.0);float b=getElevation(v_pos+vec2(0,-epsilon.y),0.0);float c=getElevation(v_pos+vec2(epsilon.x,-epsilon.y),0.0);float d=getElevation(v_pos+vec2(-epsilon.x,0),0.0);float e=getElevation(v_pos,0.0);float f=getElevation(v_pos+vec2(epsilon.x,0),0.0);float g=getElevation(v_pos+vec2(-epsilon.x,epsilon.y),0.0);float h=getElevation(v_pos+vec2(0,epsilon.y),0.0);float i=getElevation(v_pos+vec2(epsilon.x,epsilon.y),0.0);float exaggerationFactor=u_zoom < 2.0 ? 0.4 : u_zoom < 4.5 ? 0.35 : 0.3;float exaggeration=u_zoom < 15.0 ? (u_zoom-15.0)*exaggerationFactor : 0.0;vec2 deriv=vec2((c+f+f+i)-(a+d+d+g),(g+h+h+i)-(a+b+b+c))/pow(2.0,exaggeration+(19.2562-u_zoom));gl_FragColor=clamp(vec4(deriv.x/2.0+0.5,deriv.y/2.0+0.5,1.0,1.0),0.0,1.0);\n#ifdef OVERDRAW_INSPECTOR\ngl_FragColor=vec4(1.0);\n#endif\n}";
+              var hillshadePrepareVert = "uniform mat4 u_matrix;uniform vec2 u_dimension;attribute vec2 a_pos;attribute vec2 a_texture_pos;varying vec2 v_pos;void main() {gl_Position=u_matrix*vec4(a_pos,0,1);highp vec2 epsilon=1.0/u_dimension;float scale=(u_dimension.x-2.0)/u_dimension.x;v_pos=(a_texture_pos/8192.0)*scale+epsilon;}";
+              var hillshadeFrag = "uniform sampler2D u_image;varying vec2 v_pos;uniform vec2 u_latrange;uniform vec2 u_light;uniform vec4 u_shadow;uniform vec4 u_highlight;uniform vec4 u_accent;\n#define PI 3.141592653589793\nvoid main() {vec4 pixel=texture2D(u_image,v_pos);vec2 deriv=((pixel.rg*2.0)-1.0);float scaleFactor=cos(radians((u_latrange[0]-u_latrange[1])*(1.0-v_pos.y)+u_latrange[1]));float slope=atan(1.25*length(deriv)/scaleFactor);float aspect=deriv.x !=0.0 ? atan(deriv.y,-deriv.x) : PI/2.0*(deriv.y > 0.0 ? 1.0 :-1.0);float intensity=u_light.x;float azimuth=u_light.y+PI;float base=1.875-intensity*1.75;float maxValue=0.5*PI;float scaledSlope=intensity !=0.5 ? ((pow(base,slope)-1.0)/(pow(base,maxValue)-1.0))*maxValue : slope;float accent=cos(scaledSlope);vec4 accent_color=(1.0-accent)*u_accent*clamp(intensity*2.0,0.0,1.0);float shade=abs(mod((aspect+azimuth)/PI+0.5,2.0)-1.0);vec4 shade_color=mix(u_shadow,u_highlight,shade)*sin(scaledSlope)*clamp(intensity*2.0,0.0,1.0);gl_FragColor=accent_color*(1.0-shade_color.a)+shade_color;\n#ifdef OVERDRAW_INSPECTOR\ngl_FragColor=vec4(1.0);\n#endif\n}";
+              var hillshadeVert = "uniform mat4 u_matrix;attribute vec2 a_pos;attribute vec2 a_texture_pos;varying vec2 v_pos;void main() {gl_Position=u_matrix*vec4(a_pos,0,1);v_pos=a_texture_pos/8192.0;}";
+              var lineFrag = "uniform lowp float u_device_pixel_ratio;varying vec2 v_width2;varying vec2 v_normal;varying float v_gamma_scale;\n#pragma mapbox: define highp vec4 color\n#pragma mapbox: define lowp float blur\n#pragma mapbox: define lowp float opacity\nvoid main() {\n#pragma mapbox: initialize highp vec4 color\n#pragma mapbox: initialize lowp float blur\n#pragma mapbox: initialize lowp float opacity\nfloat dist=length(v_normal)*v_width2.s;float blur2=(blur+1.0/u_device_pixel_ratio)*v_gamma_scale;float alpha=clamp(min(dist-(v_width2.t-blur2),v_width2.s-dist)/blur2,0.0,1.0);gl_FragColor=color*(alpha*opacity);\n#ifdef OVERDRAW_INSPECTOR\ngl_FragColor=vec4(1.0);\n#endif\n}";
+              var lineVert = "\n#define scale 0.015873016\nattribute vec2 a_pos_normal;attribute vec4 a_data;uniform mat4 u_matrix;uniform mediump float u_ratio;uniform vec2 u_units_to_pixels;uniform lowp float u_device_pixel_ratio;varying vec2 v_normal;varying vec2 v_width2;varying float v_gamma_scale;varying highp float v_linesofar;\n#pragma mapbox: define highp vec4 color\n#pragma mapbox: define lowp float blur\n#pragma mapbox: define lowp float opacity\n#pragma mapbox: define mediump float gapwidth\n#pragma mapbox: define lowp float offset\n#pragma mapbox: define mediump float width\nvoid main() {\n#pragma mapbox: initialize highp vec4 color\n#pragma mapbox: initialize lowp float blur\n#pragma mapbox: initialize lowp float opacity\n#pragma mapbox: initialize mediump float gapwidth\n#pragma mapbox: initialize lowp float offset\n#pragma mapbox: initialize mediump float width\nfloat ANTIALIASING=1.0/u_device_pixel_ratio/2.0;vec2 a_extrude=a_data.xy-128.0;float a_direction=mod(a_data.z,4.0)-1.0;v_linesofar=(floor(a_data.z/4.0)+a_data.w*64.0)*2.0;vec2 pos=floor(a_pos_normal*0.5);mediump vec2 normal=a_pos_normal-2.0*pos;normal.y=normal.y*2.0-1.0;v_normal=normal;gapwidth=gapwidth/2.0;float halfwidth=width/2.0;offset=-1.0*offset;float inset=gapwidth+(gapwidth > 0.0 ? ANTIALIASING : 0.0);float outset=gapwidth+halfwidth*(gapwidth > 0.0 ? 2.0 : 1.0)+(halfwidth==0.0 ? 0.0 : ANTIALIASING);mediump vec2 dist=outset*a_extrude*scale;mediump float u=0.5*a_direction;mediump float t=1.0-abs(u);mediump vec2 offset2=offset*a_extrude*scale*normal.y*mat2(t,-u,u,t);vec4 projected_extrude=u_matrix*vec4(dist/u_ratio,0.0,0.0);gl_Position=u_matrix*vec4(pos+offset2/u_ratio,0.0,1.0)+projected_extrude;float extrude_length_without_perspective=length(dist);float extrude_length_with_perspective=length(projected_extrude.xy/gl_Position.w*u_units_to_pixels);v_gamma_scale=extrude_length_without_perspective/extrude_length_with_perspective;v_width2=vec2(outset,inset);}";
+              var lineGradientFrag = "uniform lowp float u_device_pixel_ratio;uniform sampler2D u_image;varying vec2 v_width2;varying vec2 v_normal;varying float v_gamma_scale;varying highp vec2 v_uv;\n#pragma mapbox: define lowp float blur\n#pragma mapbox: define lowp float opacity\nvoid main() {\n#pragma mapbox: initialize lowp float blur\n#pragma mapbox: initialize lowp float opacity\nfloat dist=length(v_normal)*v_width2.s;float blur2=(blur+1.0/u_device_pixel_ratio)*v_gamma_scale;float alpha=clamp(min(dist-(v_width2.t-blur2),v_width2.s-dist)/blur2,0.0,1.0);vec4 color=texture2D(u_image,v_uv);gl_FragColor=color*(alpha*opacity);\n#ifdef OVERDRAW_INSPECTOR\ngl_FragColor=vec4(1.0);\n#endif\n}";
+              var lineGradientVert = "\n#define scale 0.015873016\nattribute vec2 a_pos_normal;attribute vec4 a_data;attribute float a_uv_x;attribute float a_split_index;uniform mat4 u_matrix;uniform mediump float u_ratio;uniform lowp float u_device_pixel_ratio;uniform vec2 u_units_to_pixels;uniform float u_image_height;varying vec2 v_normal;varying vec2 v_width2;varying float v_gamma_scale;varying highp vec2 v_uv;\n#pragma mapbox: define lowp float blur\n#pragma mapbox: define lowp float opacity\n#pragma mapbox: define mediump float gapwidth\n#pragma mapbox: define lowp float offset\n#pragma mapbox: define mediump float width\nvoid main() {\n#pragma mapbox: initialize lowp float blur\n#pragma mapbox: initialize lowp float opacity\n#pragma mapbox: initialize mediump float gapwidth\n#pragma mapbox: initialize lowp float offset\n#pragma mapbox: initialize mediump float width\nfloat ANTIALIASING=1.0/u_device_pixel_ratio/2.0;vec2 a_extrude=a_data.xy-128.0;float a_direction=mod(a_data.z,4.0)-1.0;highp float texel_height=1.0/u_image_height;highp float half_texel_height=0.5*texel_height;v_uv=vec2(a_uv_x,a_split_index*texel_height-half_texel_height);vec2 pos=floor(a_pos_normal*0.5);mediump vec2 normal=a_pos_normal-2.0*pos;normal.y=normal.y*2.0-1.0;v_normal=normal;gapwidth=gapwidth/2.0;float halfwidth=width/2.0;offset=-1.0*offset;float inset=gapwidth+(gapwidth > 0.0 ? ANTIALIASING : 0.0);float outset=gapwidth+halfwidth*(gapwidth > 0.0 ? 2.0 : 1.0)+(halfwidth==0.0 ? 0.0 : ANTIALIASING);mediump vec2 dist=outset*a_extrude*scale;mediump float u=0.5*a_direction;mediump float t=1.0-abs(u);mediump vec2 offset2=offset*a_extrude*scale*normal.y*mat2(t,-u,u,t);vec4 projected_extrude=u_matrix*vec4(dist/u_ratio,0.0,0.0);gl_Position=u_matrix*vec4(pos+offset2/u_ratio,0.0,1.0)+projected_extrude;float extrude_length_without_perspective=length(dist);float extrude_length_with_perspective=length(projected_extrude.xy/gl_Position.w*u_units_to_pixels);v_gamma_scale=extrude_length_without_perspective/extrude_length_with_perspective;v_width2=vec2(outset,inset);}";
+              var linePatternFrag = "uniform lowp float u_device_pixel_ratio;uniform vec2 u_texsize;uniform float u_fade;uniform mediump vec3 u_scale;uniform sampler2D u_image;varying vec2 v_normal;varying vec2 v_width2;varying float v_linesofar;varying float v_gamma_scale;varying float v_width;\n#pragma mapbox: define lowp vec4 pattern_from\n#pragma mapbox: define lowp vec4 pattern_to\n#pragma mapbox: define lowp float pixel_ratio_from\n#pragma mapbox: define lowp float pixel_ratio_to\n#pragma mapbox: define lowp float blur\n#pragma mapbox: define lowp float opacity\nvoid main() {\n#pragma mapbox: initialize mediump vec4 pattern_from\n#pragma mapbox: initialize mediump vec4 pattern_to\n#pragma mapbox: initialize lowp float pixel_ratio_from\n#pragma mapbox: initialize lowp float pixel_ratio_to\n#pragma mapbox: initialize lowp float blur\n#pragma mapbox: initialize lowp float opacity\nvec2 pattern_tl_a=pattern_from.xy;vec2 pattern_br_a=pattern_from.zw;vec2 pattern_tl_b=pattern_to.xy;vec2 pattern_br_b=pattern_to.zw;float tileZoomRatio=u_scale.x;float fromScale=u_scale.y;float toScale=u_scale.z;vec2 display_size_a=(pattern_br_a-pattern_tl_a)/pixel_ratio_from;vec2 display_size_b=(pattern_br_b-pattern_tl_b)/pixel_ratio_to;vec2 pattern_size_a=vec2(display_size_a.x*fromScale/tileZoomRatio,display_size_a.y);vec2 pattern_size_b=vec2(display_size_b.x*toScale/tileZoomRatio,display_size_b.y);float aspect_a=display_size_a.y/v_width;float aspect_b=display_size_b.y/v_width;float dist=length(v_normal)*v_width2.s;float blur2=(blur+1.0/u_device_pixel_ratio)*v_gamma_scale;float alpha=clamp(min(dist-(v_width2.t-blur2),v_width2.s-dist)/blur2,0.0,1.0);float x_a=mod(v_linesofar/pattern_size_a.x*aspect_a,1.0);float x_b=mod(v_linesofar/pattern_size_b.x*aspect_b,1.0);float y=0.5*v_normal.y+0.5;vec2 texel_size=1.0/u_texsize;vec2 pos_a=mix(pattern_tl_a*texel_size-texel_size,pattern_br_a*texel_size+texel_size,vec2(x_a,y));vec2 pos_b=mix(pattern_tl_b*texel_size-texel_size,pattern_br_b*texel_size+texel_size,vec2(x_b,y));vec4 color=mix(texture2D(u_image,pos_a),texture2D(u_image,pos_b),u_fade);gl_FragColor=color*alpha*opacity;\n#ifdef OVERDRAW_INSPECTOR\ngl_FragColor=vec4(1.0);\n#endif\n}";
+              var linePatternVert = "\n#define scale 0.015873016\n#define LINE_DISTANCE_SCALE 2.0\nattribute vec2 a_pos_normal;attribute vec4 a_data;uniform mat4 u_matrix;uniform vec2 u_units_to_pixels;uniform mediump float u_ratio;uniform lowp float u_device_pixel_ratio;varying vec2 v_normal;varying vec2 v_width2;varying float v_linesofar;varying float v_gamma_scale;varying float v_width;\n#pragma mapbox: define lowp float blur\n#pragma mapbox: define lowp float opacity\n#pragma mapbox: define lowp float offset\n#pragma mapbox: define mediump float gapwidth\n#pragma mapbox: define mediump float width\n#pragma mapbox: define lowp float floorwidth\n#pragma mapbox: define lowp vec4 pattern_from\n#pragma mapbox: define lowp vec4 pattern_to\n#pragma mapbox: define lowp float pixel_ratio_from\n#pragma mapbox: define lowp float pixel_ratio_to\nvoid main() {\n#pragma mapbox: initialize lowp float blur\n#pragma mapbox: initialize lowp float opacity\n#pragma mapbox: initialize lowp float offset\n#pragma mapbox: initialize mediump float gapwidth\n#pragma mapbox: initialize mediump float width\n#pragma mapbox: initialize lowp float floorwidth\n#pragma mapbox: initialize mediump vec4 pattern_from\n#pragma mapbox: initialize mediump vec4 pattern_to\n#pragma mapbox: initialize lowp float pixel_ratio_from\n#pragma mapbox: initialize lowp float pixel_ratio_to\nfloat ANTIALIASING=1.0/u_device_pixel_ratio/2.0;vec2 a_extrude=a_data.xy-128.0;float a_direction=mod(a_data.z,4.0)-1.0;float a_linesofar=(floor(a_data.z/4.0)+a_data.w*64.0)*LINE_DISTANCE_SCALE;vec2 pos=floor(a_pos_normal*0.5);mediump vec2 normal=a_pos_normal-2.0*pos;normal.y=normal.y*2.0-1.0;v_normal=normal;gapwidth=gapwidth/2.0;float halfwidth=width/2.0;offset=-1.0*offset;float inset=gapwidth+(gapwidth > 0.0 ? ANTIALIASING : 0.0);float outset=gapwidth+halfwidth*(gapwidth > 0.0 ? 2.0 : 1.0)+(halfwidth==0.0 ? 0.0 : ANTIALIASING);mediump vec2 dist=outset*a_extrude*scale;mediump float u=0.5*a_direction;mediump float t=1.0-abs(u);mediump vec2 offset2=offset*a_extrude*scale*normal.y*mat2(t,-u,u,t);vec4 projected_extrude=u_matrix*vec4(dist/u_ratio,0.0,0.0);gl_Position=u_matrix*vec4(pos+offset2/u_ratio,0.0,1.0)+projected_extrude;float extrude_length_without_perspective=length(dist);float extrude_length_with_perspective=length(projected_extrude.xy/gl_Position.w*u_units_to_pixels);v_gamma_scale=extrude_length_without_perspective/extrude_length_with_perspective;v_linesofar=a_linesofar;v_width2=vec2(outset,inset);v_width=floorwidth;}";
+              var lineSDFFrag = "uniform lowp float u_device_pixel_ratio;uniform sampler2D u_image;uniform float u_sdfgamma;uniform float u_mix;varying vec2 v_normal;varying vec2 v_width2;varying vec2 v_tex_a;varying vec2 v_tex_b;varying float v_gamma_scale;\n#pragma mapbox: define highp vec4 color\n#pragma mapbox: define lowp float blur\n#pragma mapbox: define lowp float opacity\n#pragma mapbox: define mediump float width\n#pragma mapbox: define lowp float floorwidth\nvoid main() {\n#pragma mapbox: initialize highp vec4 color\n#pragma mapbox: initialize lowp float blur\n#pragma mapbox: initialize lowp float opacity\n#pragma mapbox: initialize mediump float width\n#pragma mapbox: initialize lowp float floorwidth\nfloat dist=length(v_normal)*v_width2.s;float blur2=(blur+1.0/u_device_pixel_ratio)*v_gamma_scale;float alpha=clamp(min(dist-(v_width2.t-blur2),v_width2.s-dist)/blur2,0.0,1.0);float sdfdist_a=texture2D(u_image,v_tex_a).a;float sdfdist_b=texture2D(u_image,v_tex_b).a;float sdfdist=mix(sdfdist_a,sdfdist_b,u_mix);alpha*=smoothstep(0.5-u_sdfgamma/floorwidth,0.5+u_sdfgamma/floorwidth,sdfdist);gl_FragColor=color*(alpha*opacity);\n#ifdef OVERDRAW_INSPECTOR\ngl_FragColor=vec4(1.0);\n#endif\n}";
+              var lineSDFVert = "\n#define scale 0.015873016\n#define LINE_DISTANCE_SCALE 2.0\nattribute vec2 a_pos_normal;attribute vec4 a_data;uniform mat4 u_matrix;uniform mediump float u_ratio;uniform lowp float u_device_pixel_ratio;uniform vec2 u_patternscale_a;uniform float u_tex_y_a;uniform vec2 u_patternscale_b;uniform float u_tex_y_b;uniform vec2 u_units_to_pixels;varying vec2 v_normal;varying vec2 v_width2;varying vec2 v_tex_a;varying vec2 v_tex_b;varying float v_gamma_scale;\n#pragma mapbox: define highp vec4 color\n#pragma mapbox: define lowp float blur\n#pragma mapbox: define lowp float opacity\n#pragma mapbox: define mediump float gapwidth\n#pragma mapbox: define lowp float offset\n#pragma mapbox: define mediump float width\n#pragma mapbox: define lowp float floorwidth\nvoid main() {\n#pragma mapbox: initialize highp vec4 color\n#pragma mapbox: initialize lowp float blur\n#pragma mapbox: initialize lowp float opacity\n#pragma mapbox: initialize mediump float gapwidth\n#pragma mapbox: initialize lowp float offset\n#pragma mapbox: initialize mediump float width\n#pragma mapbox: initialize lowp float floorwidth\nfloat ANTIALIASING=1.0/u_device_pixel_ratio/2.0;vec2 a_extrude=a_data.xy-128.0;float a_direction=mod(a_data.z,4.0)-1.0;float a_linesofar=(floor(a_data.z/4.0)+a_data.w*64.0)*LINE_DISTANCE_SCALE;vec2 pos=floor(a_pos_normal*0.5);mediump vec2 normal=a_pos_normal-2.0*pos;normal.y=normal.y*2.0-1.0;v_normal=normal;gapwidth=gapwidth/2.0;float halfwidth=width/2.0;offset=-1.0*offset;float inset=gapwidth+(gapwidth > 0.0 ? ANTIALIASING : 0.0);float outset=gapwidth+halfwidth*(gapwidth > 0.0 ? 2.0 : 1.0)+(halfwidth==0.0 ? 0.0 : ANTIALIASING);mediump vec2 dist=outset*a_extrude*scale;mediump float u=0.5*a_direction;mediump float t=1.0-abs(u);mediump vec2 offset2=offset*a_extrude*scale*normal.y*mat2(t,-u,u,t);vec4 projected_extrude=u_matrix*vec4(dist/u_ratio,0.0,0.0);gl_Position=u_matrix*vec4(pos+offset2/u_ratio,0.0,1.0)+projected_extrude;float extrude_length_without_perspective=length(dist);float extrude_length_with_perspective=length(projected_extrude.xy/gl_Position.w*u_units_to_pixels);v_gamma_scale=extrude_length_without_perspective/extrude_length_with_perspective;v_tex_a=vec2(a_linesofar*u_patternscale_a.x/floorwidth,normal.y*u_patternscale_a.y+u_tex_y_a);v_tex_b=vec2(a_linesofar*u_patternscale_b.x/floorwidth,normal.y*u_patternscale_b.y+u_tex_y_b);v_width2=vec2(outset,inset);}";
+              var rasterFrag = "uniform float u_fade_t;uniform float u_opacity;uniform sampler2D u_image0;uniform sampler2D u_image1;varying vec2 v_pos0;varying vec2 v_pos1;uniform float u_brightness_low;uniform float u_brightness_high;uniform float u_saturation_factor;uniform float u_contrast_factor;uniform vec3 u_spin_weights;void main() {vec4 color0=texture2D(u_image0,v_pos0);vec4 color1=texture2D(u_image1,v_pos1);if (color0.a > 0.0) {color0.rgb=color0.rgb/color0.a;}if (color1.a > 0.0) {color1.rgb=color1.rgb/color1.a;}vec4 color=mix(color0,color1,u_fade_t);color.a*=u_opacity;vec3 rgb=color.rgb;rgb=vec3(dot(rgb,u_spin_weights.xyz),dot(rgb,u_spin_weights.zxy),dot(rgb,u_spin_weights.yzx));float average=(color.r+color.g+color.b)/3.0;rgb+=(average-rgb)*u_saturation_factor;rgb=(rgb-0.5)*u_contrast_factor+0.5;vec3 u_high_vec=vec3(u_brightness_low,u_brightness_low,u_brightness_low);vec3 u_low_vec=vec3(u_brightness_high,u_brightness_high,u_brightness_high);gl_FragColor=vec4(mix(u_high_vec,u_low_vec,rgb)*color.a,color.a);\n#ifdef OVERDRAW_INSPECTOR\ngl_FragColor=vec4(1.0);\n#endif\n}";
+              var rasterVert = "uniform mat4 u_matrix;uniform vec2 u_tl_parent;uniform float u_scale_parent;uniform float u_buffer_scale;attribute vec2 a_pos;attribute vec2 a_texture_pos;varying vec2 v_pos0;varying vec2 v_pos1;void main() {gl_Position=u_matrix*vec4(a_pos,0,1);v_pos0=(((a_texture_pos/8192.0)-0.5)/u_buffer_scale )+0.5;v_pos1=(v_pos0*u_scale_parent)+u_tl_parent;}";
+              var symbolIconFrag = "uniform sampler2D u_texture;varying vec2 v_tex;varying float v_fade_opacity;\n#pragma mapbox: define lowp float opacity\nvoid main() {\n#pragma mapbox: initialize lowp float opacity\nlowp float alpha=opacity*v_fade_opacity;gl_FragColor=texture2D(u_texture,v_tex)*alpha;\n#ifdef OVERDRAW_INSPECTOR\ngl_FragColor=vec4(1.0);\n#endif\n}";
+              var symbolIconVert = "const float PI=3.141592653589793;attribute vec4 a_pos_offset;attribute vec4 a_data;attribute vec4 a_pixeloffset;attribute vec3 a_projected_pos;attribute float a_fade_opacity;uniform bool u_is_size_zoom_constant;uniform bool u_is_size_feature_constant;uniform highp float u_size_t;uniform highp float u_size;uniform highp float u_camera_to_center_distance;uniform highp float u_pitch;uniform bool u_rotate_symbol;uniform highp float u_aspect_ratio;uniform float u_fade_change;uniform mat4 u_matrix;uniform mat4 u_label_plane_matrix;uniform mat4 u_coord_matrix;uniform bool u_is_text;uniform bool u_pitch_with_map;uniform vec2 u_texsize;varying vec2 v_tex;varying float v_fade_opacity;\n#pragma mapbox: define lowp float opacity\nvoid main() {\n#pragma mapbox: initialize lowp float opacity\nvec2 a_pos=a_pos_offset.xy;vec2 a_offset=a_pos_offset.zw;vec2 a_tex=a_data.xy;vec2 a_size=a_data.zw;float a_size_min=floor(a_size[0]*0.5);vec2 a_pxoffset=a_pixeloffset.xy;vec2 a_minFontScale=a_pixeloffset.zw/256.0;highp float segment_angle=-a_projected_pos[2];float size;if (!u_is_size_zoom_constant && !u_is_size_feature_constant) {size=mix(a_size_min,a_size[1],u_size_t)/128.0;} else if (u_is_size_zoom_constant && !u_is_size_feature_constant) {size=a_size_min/128.0;} else {size=u_size;}vec4 projectedPoint=u_matrix*vec4(a_pos,0,1);highp float camera_to_anchor_distance=projectedPoint.w;highp float distance_ratio=u_pitch_with_map ?\ncamera_to_anchor_distance/u_camera_to_center_distance :\nu_camera_to_center_distance/camera_to_anchor_distance;highp float perspective_ratio=clamp(0.5+0.5*distance_ratio,0.0,4.0);size*=perspective_ratio;float fontScale=u_is_text ? size/24.0 : size;highp float symbol_rotation=0.0;if (u_rotate_symbol) {vec4 offsetProjectedPoint=u_matrix*vec4(a_pos+vec2(1,0),0,1);vec2 a=projectedPoint.xy/projectedPoint.w;vec2 b=offsetProjectedPoint.xy/offsetProjectedPoint.w;symbol_rotation=atan((b.y-a.y)/u_aspect_ratio,b.x-a.x);}highp float angle_sin=sin(segment_angle+symbol_rotation);highp float angle_cos=cos(segment_angle+symbol_rotation);mat2 rotation_matrix=mat2(angle_cos,-1.0*angle_sin,angle_sin,angle_cos);vec4 projected_pos=u_label_plane_matrix*vec4(a_projected_pos.xy,0.0,1.0);gl_Position=u_coord_matrix*vec4(projected_pos.xy/projected_pos.w+rotation_matrix*(a_offset/32.0*max(a_minFontScale,fontScale)+a_pxoffset/16.0),0.0,1.0);v_tex=a_tex/u_texsize;vec2 fade_opacity=unpack_opacity(a_fade_opacity);float fade_change=fade_opacity[1] > 0.5 ? u_fade_change :-u_fade_change;v_fade_opacity=max(0.0,min(1.0,fade_opacity[0]+fade_change));}";
+              var symbolSDFFrag = "#define SDF_PX 8.0\nuniform bool u_is_halo;uniform sampler2D u_texture;uniform highp float u_gamma_scale;uniform lowp float u_device_pixel_ratio;uniform bool u_is_text;varying vec2 v_data0;varying vec3 v_data1;\n#pragma mapbox: define highp vec4 fill_color\n#pragma mapbox: define highp vec4 halo_color\n#pragma mapbox: define lowp float opacity\n#pragma mapbox: define lowp float halo_width\n#pragma mapbox: define lowp float halo_blur\nvoid main() {\n#pragma mapbox: initialize highp vec4 fill_color\n#pragma mapbox: initialize highp vec4 halo_color\n#pragma mapbox: initialize lowp float opacity\n#pragma mapbox: initialize lowp float halo_width\n#pragma mapbox: initialize lowp float halo_blur\nfloat EDGE_GAMMA=0.105/u_device_pixel_ratio;vec2 tex=v_data0.xy;float gamma_scale=v_data1.x;float size=v_data1.y;float fade_opacity=v_data1[2];float fontScale=u_is_text ? size/24.0 : size;lowp vec4 color=fill_color;highp float gamma=EDGE_GAMMA/(fontScale*u_gamma_scale);lowp float buff=(256.0-64.0)/256.0;if (u_is_halo) {color=halo_color;gamma=(halo_blur*1.19/SDF_PX+EDGE_GAMMA)/(fontScale*u_gamma_scale);buff=(6.0-halo_width/fontScale)/SDF_PX;}lowp float dist=texture2D(u_texture,tex).a;highp float gamma_scaled=gamma*gamma_scale;highp float alpha=smoothstep(buff-gamma_scaled,buff+gamma_scaled,dist);gl_FragColor=color*(alpha*opacity*fade_opacity);\n#ifdef OVERDRAW_INSPECTOR\ngl_FragColor=vec4(1.0);\n#endif\n}";
+              var symbolSDFVert = "const float PI=3.141592653589793;attribute vec4 a_pos_offset;attribute vec4 a_data;attribute vec4 a_pixeloffset;attribute vec3 a_projected_pos;attribute float a_fade_opacity;uniform bool u_is_size_zoom_constant;uniform bool u_is_size_feature_constant;uniform highp float u_size_t;uniform highp float u_size;uniform mat4 u_matrix;uniform mat4 u_label_plane_matrix;uniform mat4 u_coord_matrix;uniform bool u_is_text;uniform bool u_pitch_with_map;uniform highp float u_pitch;uniform bool u_rotate_symbol;uniform highp float u_aspect_ratio;uniform highp float u_camera_to_center_distance;uniform float u_fade_change;uniform vec2 u_texsize;varying vec2 v_data0;varying vec3 v_data1;\n#pragma mapbox: define highp vec4 fill_color\n#pragma mapbox: define highp vec4 halo_color\n#pragma mapbox: define lowp float opacity\n#pragma mapbox: define lowp float halo_width\n#pragma mapbox: define lowp float halo_blur\nvoid main() {\n#pragma mapbox: initialize highp vec4 fill_color\n#pragma mapbox: initialize highp vec4 halo_color\n#pragma mapbox: initialize lowp float opacity\n#pragma mapbox: initialize lowp float halo_width\n#pragma mapbox: initialize lowp float halo_blur\nvec2 a_pos=a_pos_offset.xy;vec2 a_offset=a_pos_offset.zw;vec2 a_tex=a_data.xy;vec2 a_size=a_data.zw;float a_size_min=floor(a_size[0]*0.5);vec2 a_pxoffset=a_pixeloffset.xy;highp float segment_angle=-a_projected_pos[2];float size;if (!u_is_size_zoom_constant && !u_is_size_feature_constant) {size=mix(a_size_min,a_size[1],u_size_t)/128.0;} else if (u_is_size_zoom_constant && !u_is_size_feature_constant) {size=a_size_min/128.0;} else {size=u_size;}vec4 projectedPoint=u_matrix*vec4(a_pos,0,1);highp float camera_to_anchor_distance=projectedPoint.w;highp float distance_ratio=u_pitch_with_map ?\ncamera_to_anchor_distance/u_camera_to_center_distance :\nu_camera_to_center_distance/camera_to_anchor_distance;highp float perspective_ratio=clamp(0.5+0.5*distance_ratio,0.0,4.0);size*=perspective_ratio;float fontScale=u_is_text ? size/24.0 : size;highp float symbol_rotation=0.0;if (u_rotate_symbol) {vec4 offsetProjectedPoint=u_matrix*vec4(a_pos+vec2(1,0),0,1);vec2 a=projectedPoint.xy/projectedPoint.w;vec2 b=offsetProjectedPoint.xy/offsetProjectedPoint.w;symbol_rotation=atan((b.y-a.y)/u_aspect_ratio,b.x-a.x);}highp float angle_sin=sin(segment_angle+symbol_rotation);highp float angle_cos=cos(segment_angle+symbol_rotation);mat2 rotation_matrix=mat2(angle_cos,-1.0*angle_sin,angle_sin,angle_cos);vec4 projected_pos=u_label_plane_matrix*vec4(a_projected_pos.xy,0.0,1.0);gl_Position=u_coord_matrix*vec4(projected_pos.xy/projected_pos.w+rotation_matrix*(a_offset/32.0*fontScale+a_pxoffset),0.0,1.0);float gamma_scale=gl_Position.w;vec2 fade_opacity=unpack_opacity(a_fade_opacity);float fade_change=fade_opacity[1] > 0.5 ? u_fade_change :-u_fade_change;float interpolated_fade_opacity=max(0.0,min(1.0,fade_opacity[0]+fade_change));v_data0=a_tex/u_texsize;v_data1=vec3(gamma_scale,size,interpolated_fade_opacity);}";
+              var symbolTextAndIconFrag = "#define SDF_PX 8.0\n#define SDF 1.0\n#define ICON 0.0\nuniform bool u_is_halo;uniform sampler2D u_texture;uniform sampler2D u_texture_icon;uniform highp float u_gamma_scale;uniform lowp float u_device_pixel_ratio;varying vec4 v_data0;varying vec4 v_data1;\n#pragma mapbox: define highp vec4 fill_color\n#pragma mapbox: define highp vec4 halo_color\n#pragma mapbox: define lowp float opacity\n#pragma mapbox: define lowp float halo_width\n#pragma mapbox: define lowp float halo_blur\nvoid main() {\n#pragma mapbox: initialize highp vec4 fill_color\n#pragma mapbox: initialize highp vec4 halo_color\n#pragma mapbox: initialize lowp float opacity\n#pragma mapbox: initialize lowp float halo_width\n#pragma mapbox: initialize lowp float halo_blur\nfloat fade_opacity=v_data1[2];if (v_data1.w==ICON) {vec2 tex_icon=v_data0.zw;lowp float alpha=opacity*fade_opacity;gl_FragColor=texture2D(u_texture_icon,tex_icon)*alpha;\n#ifdef OVERDRAW_INSPECTOR\ngl_FragColor=vec4(1.0);\n#endif\nreturn;}vec2 tex=v_data0.xy;float EDGE_GAMMA=0.105/u_device_pixel_ratio;float gamma_scale=v_data1.x;float size=v_data1.y;float fontScale=size/24.0;lowp vec4 color=fill_color;highp float gamma=EDGE_GAMMA/(fontScale*u_gamma_scale);lowp float buff=(256.0-64.0)/256.0;if (u_is_halo) {color=halo_color;gamma=(halo_blur*1.19/SDF_PX+EDGE_GAMMA)/(fontScale*u_gamma_scale);buff=(6.0-halo_width/fontScale)/SDF_PX;}lowp float dist=texture2D(u_texture,tex).a;highp float gamma_scaled=gamma*gamma_scale;highp float alpha=smoothstep(buff-gamma_scaled,buff+gamma_scaled,dist);gl_FragColor=color*(alpha*opacity*fade_opacity);\n#ifdef OVERDRAW_INSPECTOR\ngl_FragColor=vec4(1.0);\n#endif\n}";
+              var symbolTextAndIconVert = "const float PI=3.141592653589793;attribute vec4 a_pos_offset;attribute vec4 a_data;attribute vec3 a_projected_pos;attribute float a_fade_opacity;uniform bool u_is_size_zoom_constant;uniform bool u_is_size_feature_constant;uniform highp float u_size_t;uniform highp float u_size;uniform mat4 u_matrix;uniform mat4 u_label_plane_matrix;uniform mat4 u_coord_matrix;uniform bool u_is_text;uniform bool u_pitch_with_map;uniform highp float u_pitch;uniform bool u_rotate_symbol;uniform highp float u_aspect_ratio;uniform highp float u_camera_to_center_distance;uniform float u_fade_change;uniform vec2 u_texsize;uniform vec2 u_texsize_icon;varying vec4 v_data0;varying vec4 v_data1;\n#pragma mapbox: define highp vec4 fill_color\n#pragma mapbox: define highp vec4 halo_color\n#pragma mapbox: define lowp float opacity\n#pragma mapbox: define lowp float halo_width\n#pragma mapbox: define lowp float halo_blur\nvoid main() {\n#pragma mapbox: initialize highp vec4 fill_color\n#pragma mapbox: initialize highp vec4 halo_color\n#pragma mapbox: initialize lowp float opacity\n#pragma mapbox: initialize lowp float halo_width\n#pragma mapbox: initialize lowp float halo_blur\nvec2 a_pos=a_pos_offset.xy;vec2 a_offset=a_pos_offset.zw;vec2 a_tex=a_data.xy;vec2 a_size=a_data.zw;float a_size_min=floor(a_size[0]*0.5);float is_sdf=a_size[0]-2.0*a_size_min;highp float segment_angle=-a_projected_pos[2];float size;if (!u_is_size_zoom_constant && !u_is_size_feature_constant) {size=mix(a_size_min,a_size[1],u_size_t)/128.0;} else if (u_is_size_zoom_constant && !u_is_size_feature_constant) {size=a_size_min/128.0;} else {size=u_size;}vec4 projectedPoint=u_matrix*vec4(a_pos,0,1);highp float camera_to_anchor_distance=projectedPoint.w;highp float distance_ratio=u_pitch_with_map ?\ncamera_to_anchor_distance/u_camera_to_center_distance :\nu_camera_to_center_distance/camera_to_anchor_distance;highp float perspective_ratio=clamp(0.5+0.5*distance_ratio,0.0,4.0);size*=perspective_ratio;float fontScale=size/24.0;highp float symbol_rotation=0.0;if (u_rotate_symbol) {vec4 offsetProjectedPoint=u_matrix*vec4(a_pos+vec2(1,0),0,1);vec2 a=projectedPoint.xy/projectedPoint.w;vec2 b=offsetProjectedPoint.xy/offsetProjectedPoint.w;symbol_rotation=atan((b.y-a.y)/u_aspect_ratio,b.x-a.x);}highp float angle_sin=sin(segment_angle+symbol_rotation);highp float angle_cos=cos(segment_angle+symbol_rotation);mat2 rotation_matrix=mat2(angle_cos,-1.0*angle_sin,angle_sin,angle_cos);vec4 projected_pos=u_label_plane_matrix*vec4(a_projected_pos.xy,0.0,1.0);gl_Position=u_coord_matrix*vec4(projected_pos.xy/projected_pos.w+rotation_matrix*(a_offset/32.0*fontScale),0.0,1.0);float gamma_scale=gl_Position.w;vec2 fade_opacity=unpack_opacity(a_fade_opacity);float fade_change=fade_opacity[1] > 0.5 ? u_fade_change :-u_fade_change;float interpolated_fade_opacity=max(0.0,min(1.0,fade_opacity[0]+fade_change));v_data0.xy=a_tex/u_texsize;v_data0.zw=a_tex/u_texsize_icon;v_data1=vec4(gamma_scale,size,interpolated_fade_opacity,is_sdf);}";
+              var prelude = compile(preludeFrag, preludeVert);
+              var background = compile(backgroundFrag, backgroundVert);
+              var backgroundPattern = compile(backgroundPatternFrag, backgroundPatternVert);
+              var circle = compile(circleFrag, circleVert);
+              var clippingMask = compile(clippingMaskFrag, clippingMaskVert);
+              var heatmap = compile(heatmapFrag, heatmapVert);
+              var heatmapTexture = compile(heatmapTextureFrag, heatmapTextureVert);
+              var collisionBox = compile(collisionBoxFrag, collisionBoxVert);
+              var collisionCircle = compile(collisionCircleFrag, collisionCircleVert);
+              var debug2 = compile(debugFrag, debugVert);
+              var fill = compile(fillFrag, fillVert);
+              var fillOutline = compile(fillOutlineFrag, fillOutlineVert);
+              var fillOutlinePattern = compile(fillOutlinePatternFrag, fillOutlinePatternVert);
+              var fillPattern = compile(fillPatternFrag, fillPatternVert);
+              var fillExtrusion = compile(fillExtrusionFrag, fillExtrusionVert);
+              var fillExtrusionPattern = compile(fillExtrusionPatternFrag, fillExtrusionPatternVert);
+              var hillshadePrepare = compile(hillshadePrepareFrag, hillshadePrepareVert);
+              var hillshade = compile(hillshadeFrag, hillshadeVert);
+              var line = compile(lineFrag, lineVert);
+              var lineGradient = compile(lineGradientFrag, lineGradientVert);
+              var linePattern = compile(linePatternFrag, linePatternVert);
+              var lineSDF = compile(lineSDFFrag, lineSDFVert);
+              var raster = compile(rasterFrag, rasterVert);
+              var symbolIcon = compile(symbolIconFrag, symbolIconVert);
+              var symbolSDF = compile(symbolSDFFrag, symbolSDFVert);
+              var symbolTextAndIcon = compile(symbolTextAndIconFrag, symbolTextAndIconVert);
+              function compile(fragmentSource, vertexSource) {
+                var re2 = /#pragma mapbox: ([\w]+) ([\w]+) ([\w]+) ([\w]+)/g;
+                var staticAttributes = vertexSource.match(/attribute ([\w]+) ([\w]+)/g);
+                var fragmentUniforms = fragmentSource.match(/uniform ([\w]+) ([\w]+)([\s]*)([\w]*)/g);
+                var vertexUniforms = vertexSource.match(/uniform ([\w]+) ([\w]+)([\s]*)([\w]*)/g);
+                var staticUniforms = vertexUniforms ? vertexUniforms.concat(fragmentUniforms) : fragmentUniforms;
+                var fragmentPragmas = {};
+                fragmentSource = fragmentSource.replace(re2, function(match, operation, precision, type, name2) {
+                  fragmentPragmas[name2] = true;
+                  if (operation === "define") {
+                    return "\n#ifndef HAS_UNIFORM_u_" + name2 + "\nvarying " + precision + " " + type + " " + name2 + ";\n#else\nuniform " + precision + " " + type + " u_" + name2 + ";\n#endif\n";
+                  } else {
+                    return "\n#ifdef HAS_UNIFORM_u_" + name2 + "\n    " + precision + " " + type + " " + name2 + " = u_" + name2 + ";\n#endif\n";
+                  }
+                });
+                vertexSource = vertexSource.replace(re2, function(match, operation, precision, type, name2) {
+                  var attrType = type === "float" ? "vec2" : "vec4";
+                  var unpackType = name2.match(/color/) ? "color" : attrType;
+                  if (fragmentPragmas[name2]) {
+                    if (operation === "define") {
+                      return "\n#ifndef HAS_UNIFORM_u_" + name2 + "\nuniform lowp float u_" + name2 + "_t;\nattribute " + precision + " " + attrType + " a_" + name2 + ";\nvarying " + precision + " " + type + " " + name2 + ";\n#else\nuniform " + precision + " " + type + " u_" + name2 + ";\n#endif\n";
+                    } else {
+                      if (unpackType === "vec4") {
+                        return "\n#ifndef HAS_UNIFORM_u_" + name2 + "\n    " + name2 + " = a_" + name2 + ";\n#else\n    " + precision + " " + type + " " + name2 + " = u_" + name2 + ";\n#endif\n";
+                      } else {
+                        return "\n#ifndef HAS_UNIFORM_u_" + name2 + "\n    " + name2 + " = unpack_mix_" + unpackType + "(a_" + name2 + ", u_" + name2 + "_t);\n#else\n    " + precision + " " + type + " " + name2 + " = u_" + name2 + ";\n#endif\n";
+                      }
+                    }
+                  } else {
+                    if (operation === "define") {
+                      return "\n#ifndef HAS_UNIFORM_u_" + name2 + "\nuniform lowp float u_" + name2 + "_t;\nattribute " + precision + " " + attrType + " a_" + name2 + ";\n#else\nuniform " + precision + " " + type + " u_" + name2 + ";\n#endif\n";
+                    } else {
+                      if (unpackType === "vec4") {
+                        return "\n#ifndef HAS_UNIFORM_u_" + name2 + "\n    " + precision + " " + type + " " + name2 + " = a_" + name2 + ";\n#else\n    " + precision + " " + type + " " + name2 + " = u_" + name2 + ";\n#endif\n";
+                      } else {
+                        return "\n#ifndef HAS_UNIFORM_u_" + name2 + "\n    " + precision + " " + type + " " + name2 + " = unpack_mix_" + unpackType + "(a_" + name2 + ", u_" + name2 + "_t);\n#else\n    " + precision + " " + type + " " + name2 + " = u_" + name2 + ";\n#endif\n";
+                      }
+                    }
+                  }
+                });
+                return {
+                  fragmentSource,
+                  vertexSource,
+                  staticAttributes,
+                  staticUniforms
+                };
+              }
+              var shaders = /* @__PURE__ */ Object.freeze({
+                __proto__: null,
+                prelude,
+                background,
+                backgroundPattern,
+                circle,
+                clippingMask,
+                heatmap,
+                heatmapTexture,
+                collisionBox,
+                collisionCircle,
+                debug: debug2,
+                fill,
+                fillOutline,
+                fillOutlinePattern,
+                fillPattern,
+                fillExtrusion,
+                fillExtrusionPattern,
+                hillshadePrepare,
+                hillshade,
+                line,
+                lineGradient,
+                linePattern,
+                lineSDF,
+                raster,
+                symbolIcon,
+                symbolSDF,
+                symbolTextAndIcon
+              });
+              var VertexArrayObject = function VertexArrayObject2() {
+                this.boundProgram = null;
+                this.boundLayoutVertexBuffer = null;
+                this.boundPaintVertexBuffers = [];
+                this.boundIndexBuffer = null;
+                this.boundVertexOffset = null;
+                this.boundDynamicVertexBuffer = null;
+                this.vao = null;
+              };
+              VertexArrayObject.prototype.bind = function bind(context, program, layoutVertexBuffer, paintVertexBuffers, indexBuffer, vertexOffset, dynamicVertexBuffer, dynamicVertexBuffer2) {
+                this.context = context;
+                var paintBuffersDiffer = this.boundPaintVertexBuffers.length !== paintVertexBuffers.length;
+                for (var i2 = 0; !paintBuffersDiffer && i2 < paintVertexBuffers.length; i2++) {
+                  if (this.boundPaintVertexBuffers[i2] !== paintVertexBuffers[i2]) {
+                    paintBuffersDiffer = true;
+                  }
+                }
+                var isFreshBindRequired = !this.vao || this.boundProgram !== program || this.boundLayoutVertexBuffer !== layoutVertexBuffer || paintBuffersDiffer || this.boundIndexBuffer !== indexBuffer || this.boundVertexOffset !== vertexOffset || this.boundDynamicVertexBuffer !== dynamicVertexBuffer || this.boundDynamicVertexBuffer2 !== dynamicVertexBuffer2;
+                if (!context.extVertexArrayObject || isFreshBindRequired) {
+                  this.freshBind(program, layoutVertexBuffer, paintVertexBuffers, indexBuffer, vertexOffset, dynamicVertexBuffer, dynamicVertexBuffer2);
+                } else {
+                  context.bindVertexArrayOES.set(this.vao);
+                  if (dynamicVertexBuffer) {
+                    dynamicVertexBuffer.bind();
+                  }
+                  if (indexBuffer && indexBuffer.dynamicDraw) {
+                    indexBuffer.bind();
+                  }
+                  if (dynamicVertexBuffer2) {
+                    dynamicVertexBuffer2.bind();
+                  }
+                }
+              };
+              VertexArrayObject.prototype.freshBind = function freshBind(program, layoutVertexBuffer, paintVertexBuffers, indexBuffer, vertexOffset, dynamicVertexBuffer, dynamicVertexBuffer2) {
+                var numPrevAttributes;
+                var numNextAttributes = program.numAttributes;
+                var context = this.context;
+                var gl2 = context.gl;
+                if (context.extVertexArrayObject) {
+                  if (this.vao) {
+                    this.destroy();
+                  }
+                  this.vao = context.extVertexArrayObject.createVertexArrayOES();
+                  context.bindVertexArrayOES.set(this.vao);
+                  numPrevAttributes = 0;
+                  this.boundProgram = program;
+                  this.boundLayoutVertexBuffer = layoutVertexBuffer;
+                  this.boundPaintVertexBuffers = paintVertexBuffers;
+                  this.boundIndexBuffer = indexBuffer;
+                  this.boundVertexOffset = vertexOffset;
+                  this.boundDynamicVertexBuffer = dynamicVertexBuffer;
+                  this.boundDynamicVertexBuffer2 = dynamicVertexBuffer2;
+                } else {
+                  numPrevAttributes = context.currentNumAttributes || 0;
+                  for (var i2 = numNextAttributes; i2 < numPrevAttributes; i2++) {
+                    gl2.disableVertexAttribArray(i2);
+                  }
+                }
+                layoutVertexBuffer.enableAttributes(gl2, program);
+                for (var i$1 = 0, list = paintVertexBuffers; i$1 < list.length; i$1 += 1) {
+                  var vertexBuffer = list[i$1];
+                  vertexBuffer.enableAttributes(gl2, program);
+                }
+                if (dynamicVertexBuffer) {
+                  dynamicVertexBuffer.enableAttributes(gl2, program);
+                }
+                if (dynamicVertexBuffer2) {
+                  dynamicVertexBuffer2.enableAttributes(gl2, program);
+                }
+                layoutVertexBuffer.bind();
+                layoutVertexBuffer.setVertexAttribPointers(gl2, program, vertexOffset);
+                for (var i$2 = 0, list$1 = paintVertexBuffers; i$2 < list$1.length; i$2 += 1) {
+                  var vertexBuffer$1 = list$1[i$2];
+                  vertexBuffer$1.bind();
+                  vertexBuffer$1.setVertexAttribPointers(gl2, program, vertexOffset);
+                }
+                if (dynamicVertexBuffer) {
+                  dynamicVertexBuffer.bind();
+                  dynamicVertexBuffer.setVertexAttribPointers(gl2, program, vertexOffset);
+                }
+                if (indexBuffer) {
+                  indexBuffer.bind();
+                }
+                if (dynamicVertexBuffer2) {
+                  dynamicVertexBuffer2.bind();
+                  dynamicVertexBuffer2.setVertexAttribPointers(gl2, program, vertexOffset);
+                }
+                context.currentNumAttributes = numNextAttributes;
+              };
+              VertexArrayObject.prototype.destroy = function destroy() {
+                if (this.vao) {
+                  this.context.extVertexArrayObject.deleteVertexArrayOES(this.vao);
+                  this.vao = null;
+                }
+              };
+              function getTokenizedAttributesAndUniforms(array) {
+                var result = [];
+                for (var i2 = 0; i2 < array.length; i2++) {
+                  if (array[i2] === null) {
+                    continue;
+                  }
+                  var token = array[i2].split(" ");
+                  result.push(token.pop());
+                }
+                return result;
+              }
+              var Program$1 = function Program2(context, name2, source2, configuration, fixedUniforms, showOverdrawInspector) {
+                var gl2 = context.gl;
+                this.program = gl2.createProgram();
+                var staticAttrInfo = getTokenizedAttributesAndUniforms(source2.staticAttributes);
+                var dynamicAttrInfo = configuration ? configuration.getBinderAttributes() : [];
+                var allAttrInfo = staticAttrInfo.concat(dynamicAttrInfo);
+                var staticUniformsInfo = source2.staticUniforms ? getTokenizedAttributesAndUniforms(source2.staticUniforms) : [];
+                var dynamicUniformsInfo = configuration ? configuration.getBinderUniforms() : [];
+                var uniformList = staticUniformsInfo.concat(dynamicUniformsInfo);
+                var allUniformsInfo = [];
+                for (var i$1 = 0, list = uniformList; i$1 < list.length; i$1 += 1) {
+                  var uniform = list[i$1];
+                  if (allUniformsInfo.indexOf(uniform) < 0) {
+                    allUniformsInfo.push(uniform);
+                  }
+                }
+                var defines2 = configuration ? configuration.defines() : [];
+                if (showOverdrawInspector) {
+                  defines2.push("#define OVERDRAW_INSPECTOR;");
+                }
+                var fragmentSource = defines2.concat(prelude.fragmentSource, source2.fragmentSource).join("\n");
+                var vertexSource = defines2.concat(prelude.vertexSource, source2.vertexSource).join("\n");
+                var fragmentShader = gl2.createShader(gl2.FRAGMENT_SHADER);
+                if (gl2.isContextLost()) {
+                  this.failedToCreate = true;
+                  return;
+                }
+                gl2.shaderSource(fragmentShader, fragmentSource);
+                gl2.compileShader(fragmentShader);
+                gl2.attachShader(this.program, fragmentShader);
+                var vertexShader = gl2.createShader(gl2.VERTEX_SHADER);
+                if (gl2.isContextLost()) {
+                  this.failedToCreate = true;
+                  return;
+                }
+                gl2.shaderSource(vertexShader, vertexSource);
+                gl2.compileShader(vertexShader);
+                gl2.attachShader(this.program, vertexShader);
+                this.attributes = {};
+                var uniformLocations = {};
+                this.numAttributes = allAttrInfo.length;
+                for (var i2 = 0; i2 < this.numAttributes; i2++) {
+                  if (allAttrInfo[i2]) {
+                    gl2.bindAttribLocation(this.program, i2, allAttrInfo[i2]);
+                    this.attributes[allAttrInfo[i2]] = i2;
+                  }
+                }
+                gl2.linkProgram(this.program);
+                gl2.deleteShader(vertexShader);
+                gl2.deleteShader(fragmentShader);
+                for (var it2 = 0; it2 < allUniformsInfo.length; it2++) {
+                  var uniform$1 = allUniformsInfo[it2];
+                  if (uniform$1 && !uniformLocations[uniform$1]) {
+                    var uniformLocation = gl2.getUniformLocation(this.program, uniform$1);
+                    if (uniformLocation) {
+                      uniformLocations[uniform$1] = uniformLocation;
+                    }
+                  }
+                }
+                this.fixedUniforms = fixedUniforms(context, uniformLocations);
+                this.binderUniforms = configuration ? configuration.getUniforms(context, uniformLocations) : [];
+              };
+              Program$1.prototype.draw = function draw2(context, drawMode, depthMode, stencilMode, colorMode, cullFaceMode, uniformValues, layerID, layoutVertexBuffer, indexBuffer, segments, currentProperties, zoom, configuration, dynamicLayoutBuffer, dynamicLayoutBuffer2) {
+                var obj;
+                var gl2 = context.gl;
+                if (this.failedToCreate) {
+                  return;
+                }
+                context.program.set(this.program);
+                context.setDepthMode(depthMode);
+                context.setStencilMode(stencilMode);
+                context.setColorMode(colorMode);
+                context.setCullFace(cullFaceMode);
+                for (var name2 in this.fixedUniforms) {
+                  this.fixedUniforms[name2].set(uniformValues[name2]);
+                }
+                if (configuration) {
+                  configuration.setUniforms(context, this.binderUniforms, currentProperties, { zoom });
+                }
+                var primitiveSize = (obj = {}, obj[gl2.LINES] = 2, obj[gl2.TRIANGLES] = 3, obj[gl2.LINE_STRIP] = 1, obj)[drawMode];
+                for (var i2 = 0, list = segments.get(); i2 < list.length; i2 += 1) {
+                  var segment = list[i2];
+                  var vaos = segment.vaos || (segment.vaos = {});
+                  var vao = vaos[layerID] || (vaos[layerID] = new VertexArrayObject());
+                  vao.bind(context, this, layoutVertexBuffer, configuration ? configuration.getPaintVertexBuffers() : [], indexBuffer, segment.vertexOffset, dynamicLayoutBuffer, dynamicLayoutBuffer2);
+                  gl2.drawElements(drawMode, segment.primitiveLength * primitiveSize, gl2.UNSIGNED_SHORT, segment.primitiveOffset * primitiveSize * 2);
+                }
+              };
+              function patternUniformValues(crossfade, painter, tile) {
+                var tileRatio = 1 / pixelsToTileUnits(tile, 1, painter.transform.tileZoom);
+                var numTiles = Math.pow(2, tile.tileID.overscaledZ);
+                var tileSizeAtNearestZoom = tile.tileSize * Math.pow(2, painter.transform.tileZoom) / numTiles;
+                var pixelX = tileSizeAtNearestZoom * (tile.tileID.canonical.x + tile.tileID.wrap * numTiles);
+                var pixelY = tileSizeAtNearestZoom * tile.tileID.canonical.y;
+                return {
+                  "u_image": 0,
+                  "u_texsize": tile.imageAtlasTexture.size,
+                  "u_scale": [
+                    tileRatio,
+                    crossfade.fromScale,
+                    crossfade.toScale
+                  ],
+                  "u_fade": crossfade.t,
+                  "u_pixel_coord_upper": [
+                    pixelX >> 16,
+                    pixelY >> 16
+                  ],
+                  "u_pixel_coord_lower": [
+                    pixelX & 65535,
+                    pixelY & 65535
+                  ]
+                };
+              }
+              function bgPatternUniformValues(image, crossfade, painter, tile) {
+                var imagePosA = painter.imageManager.getPattern(image.from.toString());
+                var imagePosB = painter.imageManager.getPattern(image.to.toString());
+                var ref = painter.imageManager.getPixelSize();
+                var width = ref.width;
+                var height = ref.height;
+                var numTiles = Math.pow(2, tile.tileID.overscaledZ);
+                var tileSizeAtNearestZoom = tile.tileSize * Math.pow(2, painter.transform.tileZoom) / numTiles;
+                var pixelX = tileSizeAtNearestZoom * (tile.tileID.canonical.x + tile.tileID.wrap * numTiles);
+                var pixelY = tileSizeAtNearestZoom * tile.tileID.canonical.y;
+                return {
+                  "u_image": 0,
+                  "u_pattern_tl_a": imagePosA.tl,
+                  "u_pattern_br_a": imagePosA.br,
+                  "u_pattern_tl_b": imagePosB.tl,
+                  "u_pattern_br_b": imagePosB.br,
+                  "u_texsize": [
+                    width,
+                    height
+                  ],
+                  "u_mix": crossfade.t,
+                  "u_pattern_size_a": imagePosA.displaySize,
+                  "u_pattern_size_b": imagePosB.displaySize,
+                  "u_scale_a": crossfade.fromScale,
+                  "u_scale_b": crossfade.toScale,
+                  "u_tile_units_to_pixels": 1 / pixelsToTileUnits(tile, 1, painter.transform.tileZoom),
+                  "u_pixel_coord_upper": [
+                    pixelX >> 16,
+                    pixelY >> 16
+                  ],
+                  "u_pixel_coord_lower": [
+                    pixelX & 65535,
+                    pixelY & 65535
+                  ]
+                };
+              }
+              var fillExtrusionUniforms = function(context, locations) {
+                return {
+                  "u_matrix": new performance2.UniformMatrix4f(context, locations.u_matrix),
+                  "u_lightpos": new performance2.Uniform3f(context, locations.u_lightpos),
+                  "u_lightintensity": new performance2.Uniform1f(context, locations.u_lightintensity),
+                  "u_lightcolor": new performance2.Uniform3f(context, locations.u_lightcolor),
+                  "u_vertical_gradient": new performance2.Uniform1f(context, locations.u_vertical_gradient),
+                  "u_opacity": new performance2.Uniform1f(context, locations.u_opacity)
+                };
+              };
+              var fillExtrusionPatternUniforms = function(context, locations) {
+                return {
+                  "u_matrix": new performance2.UniformMatrix4f(context, locations.u_matrix),
+                  "u_lightpos": new performance2.Uniform3f(context, locations.u_lightpos),
+                  "u_lightintensity": new performance2.Uniform1f(context, locations.u_lightintensity),
+                  "u_lightcolor": new performance2.Uniform3f(context, locations.u_lightcolor),
+                  "u_vertical_gradient": new performance2.Uniform1f(context, locations.u_vertical_gradient),
+                  "u_height_factor": new performance2.Uniform1f(context, locations.u_height_factor),
+                  "u_image": new performance2.Uniform1i(context, locations.u_image),
+                  "u_texsize": new performance2.Uniform2f(context, locations.u_texsize),
+                  "u_pixel_coord_upper": new performance2.Uniform2f(context, locations.u_pixel_coord_upper),
+                  "u_pixel_coord_lower": new performance2.Uniform2f(context, locations.u_pixel_coord_lower),
+                  "u_scale": new performance2.Uniform3f(context, locations.u_scale),
+                  "u_fade": new performance2.Uniform1f(context, locations.u_fade),
+                  "u_opacity": new performance2.Uniform1f(context, locations.u_opacity)
+                };
+              };
+              var fillExtrusionUniformValues = function(matrix, painter, shouldUseVerticalGradient, opacity) {
+                var light = painter.style.light;
+                var _lp = light.properties.get("position");
+                var lightPos = [
+                  _lp.x,
+                  _lp.y,
+                  _lp.z
+                ];
+                var lightMat = performance2.create$1();
+                if (light.properties.get("anchor") === "viewport") {
+                  performance2.fromRotation(lightMat, -painter.transform.angle);
+                }
+                performance2.transformMat3(lightPos, lightPos, lightMat);
+                var lightColor = light.properties.get("color");
+                return {
+                  "u_matrix": matrix,
+                  "u_lightpos": lightPos,
+                  "u_lightintensity": light.properties.get("intensity"),
+                  "u_lightcolor": [
+                    lightColor.r,
+                    lightColor.g,
+                    lightColor.b
+                  ],
+                  "u_vertical_gradient": +shouldUseVerticalGradient,
+                  "u_opacity": opacity
+                };
+              };
+              var fillExtrusionPatternUniformValues = function(matrix, painter, shouldUseVerticalGradient, opacity, coord, crossfade, tile) {
+                return performance2.extend(fillExtrusionUniformValues(matrix, painter, shouldUseVerticalGradient, opacity), patternUniformValues(crossfade, painter, tile), { "u_height_factor": -Math.pow(2, coord.overscaledZ) / tile.tileSize / 8 });
+              };
+              var fillUniforms = function(context, locations) {
+                return { "u_matrix": new performance2.UniformMatrix4f(context, locations.u_matrix) };
+              };
+              var fillPatternUniforms = function(context, locations) {
+                return {
+                  "u_matrix": new performance2.UniformMatrix4f(context, locations.u_matrix),
+                  "u_image": new performance2.Uniform1i(context, locations.u_image),
+                  "u_texsize": new performance2.Uniform2f(context, locations.u_texsize),
+                  "u_pixel_coord_upper": new performance2.Uniform2f(context, locations.u_pixel_coord_upper),
+                  "u_pixel_coord_lower": new performance2.Uniform2f(context, locations.u_pixel_coord_lower),
+                  "u_scale": new performance2.Uniform3f(context, locations.u_scale),
+                  "u_fade": new performance2.Uniform1f(context, locations.u_fade)
+                };
+              };
+              var fillOutlineUniforms = function(context, locations) {
+                return {
+                  "u_matrix": new performance2.UniformMatrix4f(context, locations.u_matrix),
+                  "u_world": new performance2.Uniform2f(context, locations.u_world)
+                };
+              };
+              var fillOutlinePatternUniforms = function(context, locations) {
+                return {
+                  "u_matrix": new performance2.UniformMatrix4f(context, locations.u_matrix),
+                  "u_world": new performance2.Uniform2f(context, locations.u_world),
+                  "u_image": new performance2.Uniform1i(context, locations.u_image),
+                  "u_texsize": new performance2.Uniform2f(context, locations.u_texsize),
+                  "u_pixel_coord_upper": new performance2.Uniform2f(context, locations.u_pixel_coord_upper),
+                  "u_pixel_coord_lower": new performance2.Uniform2f(context, locations.u_pixel_coord_lower),
+                  "u_scale": new performance2.Uniform3f(context, locations.u_scale),
+                  "u_fade": new performance2.Uniform1f(context, locations.u_fade)
+                };
+              };
+              var fillUniformValues = function(matrix) {
+                return { "u_matrix": matrix };
+              };
+              var fillPatternUniformValues = function(matrix, painter, crossfade, tile) {
+                return performance2.extend(fillUniformValues(matrix), patternUniformValues(crossfade, painter, tile));
+              };
+              var fillOutlineUniformValues = function(matrix, drawingBufferSize) {
+                return {
+                  "u_matrix": matrix,
+                  "u_world": drawingBufferSize
+                };
+              };
+              var fillOutlinePatternUniformValues = function(matrix, painter, crossfade, tile, drawingBufferSize) {
+                return performance2.extend(fillPatternUniformValues(matrix, painter, crossfade, tile), { "u_world": drawingBufferSize });
+              };
+              var circleUniforms = function(context, locations) {
+                return {
+                  "u_camera_to_center_distance": new performance2.Uniform1f(context, locations.u_camera_to_center_distance),
+                  "u_scale_with_map": new performance2.Uniform1i(context, locations.u_scale_with_map),
+                  "u_pitch_with_map": new performance2.Uniform1i(context, locations.u_pitch_with_map),
+                  "u_extrude_scale": new performance2.Uniform2f(context, locations.u_extrude_scale),
+                  "u_device_pixel_ratio": new performance2.Uniform1f(context, locations.u_device_pixel_ratio),
+                  "u_matrix": new performance2.UniformMatrix4f(context, locations.u_matrix)
+                };
+              };
+              var circleUniformValues = function(painter, coord, tile, layer) {
+                var transform = painter.transform;
+                var pitchWithMap, extrudeScale;
+                if (layer.paint.get("circle-pitch-alignment") === "map") {
+                  var pixelRatio = pixelsToTileUnits(tile, 1, transform.zoom);
+                  pitchWithMap = true;
+                  extrudeScale = [
+                    pixelRatio,
+                    pixelRatio
+                  ];
+                } else {
+                  pitchWithMap = false;
+                  extrudeScale = transform.pixelsToGLUnits;
+                }
+                return {
+                  "u_camera_to_center_distance": transform.cameraToCenterDistance,
+                  "u_scale_with_map": +(layer.paint.get("circle-pitch-scale") === "map"),
+                  "u_matrix": painter.translatePosMatrix(coord.posMatrix, tile, layer.paint.get("circle-translate"), layer.paint.get("circle-translate-anchor")),
+                  "u_pitch_with_map": +pitchWithMap,
+                  "u_device_pixel_ratio": performance2.browser.devicePixelRatio,
+                  "u_extrude_scale": extrudeScale
+                };
+              };
+              var collisionUniforms = function(context, locations) {
+                return {
+                  "u_matrix": new performance2.UniformMatrix4f(context, locations.u_matrix),
+                  "u_camera_to_center_distance": new performance2.Uniform1f(context, locations.u_camera_to_center_distance),
+                  "u_pixels_to_tile_units": new performance2.Uniform1f(context, locations.u_pixels_to_tile_units),
+                  "u_extrude_scale": new performance2.Uniform2f(context, locations.u_extrude_scale),
+                  "u_overscale_factor": new performance2.Uniform1f(context, locations.u_overscale_factor)
+                };
+              };
+              var collisionCircleUniforms = function(context, locations) {
+                return {
+                  "u_matrix": new performance2.UniformMatrix4f(context, locations.u_matrix),
+                  "u_inv_matrix": new performance2.UniformMatrix4f(context, locations.u_inv_matrix),
+                  "u_camera_to_center_distance": new performance2.Uniform1f(context, locations.u_camera_to_center_distance),
+                  "u_viewport_size": new performance2.Uniform2f(context, locations.u_viewport_size)
+                };
+              };
+              var collisionUniformValues = function(matrix, transform, tile) {
+                var pixelRatio = pixelsToTileUnits(tile, 1, transform.zoom);
+                var scale2 = Math.pow(2, transform.zoom - tile.tileID.overscaledZ);
+                var overscaleFactor = tile.tileID.overscaleFactor();
+                return {
+                  "u_matrix": matrix,
+                  "u_camera_to_center_distance": transform.cameraToCenterDistance,
+                  "u_pixels_to_tile_units": pixelRatio,
+                  "u_extrude_scale": [
+                    transform.pixelsToGLUnits[0] / (pixelRatio * scale2),
+                    transform.pixelsToGLUnits[1] / (pixelRatio * scale2)
+                  ],
+                  "u_overscale_factor": overscaleFactor
+                };
+              };
+              var collisionCircleUniformValues = function(matrix, invMatrix, transform) {
+                return {
+                  "u_matrix": matrix,
+                  "u_inv_matrix": invMatrix,
+                  "u_camera_to_center_distance": transform.cameraToCenterDistance,
+                  "u_viewport_size": [
+                    transform.width,
+                    transform.height
+                  ]
+                };
+              };
+              var debugUniforms = function(context, locations) {
+                return {
+                  "u_color": new performance2.UniformColor(context, locations.u_color),
+                  "u_matrix": new performance2.UniformMatrix4f(context, locations.u_matrix),
+                  "u_overlay": new performance2.Uniform1i(context, locations.u_overlay),
+                  "u_overlay_scale": new performance2.Uniform1f(context, locations.u_overlay_scale)
+                };
+              };
+              var debugUniformValues = function(matrix, color22, scaleRatio) {
+                if (scaleRatio === void 0)
+                  scaleRatio = 1;
+                return {
+                  "u_matrix": matrix,
+                  "u_color": color22,
+                  "u_overlay": 0,
+                  "u_overlay_scale": scaleRatio
+                };
+              };
+              var clippingMaskUniforms = function(context, locations) {
+                return { "u_matrix": new performance2.UniformMatrix4f(context, locations.u_matrix) };
+              };
+              var clippingMaskUniformValues = function(matrix) {
+                return { "u_matrix": matrix };
+              };
+              var heatmapUniforms = function(context, locations) {
+                return {
+                  "u_extrude_scale": new performance2.Uniform1f(context, locations.u_extrude_scale),
+                  "u_intensity": new performance2.Uniform1f(context, locations.u_intensity),
+                  "u_matrix": new performance2.UniformMatrix4f(context, locations.u_matrix)
+                };
+              };
+              var heatmapTextureUniforms = function(context, locations) {
+                return {
+                  "u_matrix": new performance2.UniformMatrix4f(context, locations.u_matrix),
+                  "u_world": new performance2.Uniform2f(context, locations.u_world),
+                  "u_image": new performance2.Uniform1i(context, locations.u_image),
+                  "u_color_ramp": new performance2.Uniform1i(context, locations.u_color_ramp),
+                  "u_opacity": new performance2.Uniform1f(context, locations.u_opacity)
+                };
+              };
+              var heatmapUniformValues = function(matrix, tile, zoom, intensity) {
+                return {
+                  "u_matrix": matrix,
+                  "u_extrude_scale": pixelsToTileUnits(tile, 1, zoom),
+                  "u_intensity": intensity
+                };
+              };
+              var heatmapTextureUniformValues = function(painter, layer, textureUnit, colorRampUnit) {
+                var matrix = performance2.create();
+                performance2.ortho(matrix, 0, painter.width, painter.height, 0, 0, 1);
+                var gl2 = painter.context.gl;
+                return {
+                  "u_matrix": matrix,
+                  "u_world": [
+                    gl2.drawingBufferWidth,
+                    gl2.drawingBufferHeight
+                  ],
+                  "u_image": textureUnit,
+                  "u_color_ramp": colorRampUnit,
+                  "u_opacity": layer.paint.get("heatmap-opacity")
+                };
+              };
+              var hillshadeUniforms = function(context, locations) {
+                return {
+                  "u_matrix": new performance2.UniformMatrix4f(context, locations.u_matrix),
+                  "u_image": new performance2.Uniform1i(context, locations.u_image),
+                  "u_latrange": new performance2.Uniform2f(context, locations.u_latrange),
+                  "u_light": new performance2.Uniform2f(context, locations.u_light),
+                  "u_shadow": new performance2.UniformColor(context, locations.u_shadow),
+                  "u_highlight": new performance2.UniformColor(context, locations.u_highlight),
+                  "u_accent": new performance2.UniformColor(context, locations.u_accent)
+                };
+              };
+              var hillshadePrepareUniforms = function(context, locations) {
+                return {
+                  "u_matrix": new performance2.UniformMatrix4f(context, locations.u_matrix),
+                  "u_image": new performance2.Uniform1i(context, locations.u_image),
+                  "u_dimension": new performance2.Uniform2f(context, locations.u_dimension),
+                  "u_zoom": new performance2.Uniform1f(context, locations.u_zoom),
+                  "u_unpack": new performance2.Uniform4f(context, locations.u_unpack)
+                };
+              };
+              var hillshadeUniformValues = function(painter, tile, layer) {
+                var shadow2 = layer.paint.get("hillshade-shadow-color");
+                var highlight = layer.paint.get("hillshade-highlight-color");
+                var accent = layer.paint.get("hillshade-accent-color");
+                var azimuthal = layer.paint.get("hillshade-illumination-direction") * (Math.PI / 180);
+                if (layer.paint.get("hillshade-illumination-anchor") === "viewport") {
+                  azimuthal -= painter.transform.angle;
+                }
+                var align = !painter.options.moving;
+                return {
+                  "u_matrix": painter.transform.calculatePosMatrix(tile.tileID.toUnwrapped(), align),
+                  "u_image": 0,
+                  "u_latrange": getTileLatRange(painter, tile.tileID),
+                  "u_light": [
+                    layer.paint.get("hillshade-exaggeration"),
+                    azimuthal
+                  ],
+                  "u_shadow": shadow2,
+                  "u_highlight": highlight,
+                  "u_accent": accent
+                };
+              };
+              var hillshadeUniformPrepareValues = function(tileID, dem) {
+                var stride = dem.stride;
+                var matrix = performance2.create();
+                performance2.ortho(matrix, 0, performance2.EXTENT, -performance2.EXTENT, 0, 0, 1);
+                performance2.translate(matrix, matrix, [
+                  0,
+                  -performance2.EXTENT,
+                  0
+                ]);
+                return {
+                  "u_matrix": matrix,
+                  "u_image": 1,
+                  "u_dimension": [
+                    stride,
+                    stride
+                  ],
+                  "u_zoom": tileID.overscaledZ,
+                  "u_unpack": dem.getUnpackVector()
+                };
+              };
+              function getTileLatRange(painter, tileID) {
+                var tilesAtZoom = Math.pow(2, tileID.canonical.z);
+                var y2 = tileID.canonical.y;
+                return [
+                  new performance2.MercatorCoordinate(0, y2 / tilesAtZoom).toLngLat().lat,
+                  new performance2.MercatorCoordinate(0, (y2 + 1) / tilesAtZoom).toLngLat().lat
+                ];
+              }
+              var lineUniforms = function(context, locations) {
+                return {
+                  "u_matrix": new performance2.UniformMatrix4f(context, locations.u_matrix),
+                  "u_ratio": new performance2.Uniform1f(context, locations.u_ratio),
+                  "u_device_pixel_ratio": new performance2.Uniform1f(context, locations.u_device_pixel_ratio),
+                  "u_units_to_pixels": new performance2.Uniform2f(context, locations.u_units_to_pixels)
+                };
+              };
+              var lineGradientUniforms = function(context, locations) {
+                return {
+                  "u_matrix": new performance2.UniformMatrix4f(context, locations.u_matrix),
+                  "u_ratio": new performance2.Uniform1f(context, locations.u_ratio),
+                  "u_device_pixel_ratio": new performance2.Uniform1f(context, locations.u_device_pixel_ratio),
+                  "u_units_to_pixels": new performance2.Uniform2f(context, locations.u_units_to_pixels),
+                  "u_image": new performance2.Uniform1i(context, locations.u_image),
+                  "u_image_height": new performance2.Uniform1f(context, locations.u_image_height)
+                };
+              };
+              var linePatternUniforms = function(context, locations) {
+                return {
+                  "u_matrix": new performance2.UniformMatrix4f(context, locations.u_matrix),
+                  "u_texsize": new performance2.Uniform2f(context, locations.u_texsize),
+                  "u_ratio": new performance2.Uniform1f(context, locations.u_ratio),
+                  "u_device_pixel_ratio": new performance2.Uniform1f(context, locations.u_device_pixel_ratio),
+                  "u_image": new performance2.Uniform1i(context, locations.u_image),
+                  "u_units_to_pixels": new performance2.Uniform2f(context, locations.u_units_to_pixels),
+                  "u_scale": new performance2.Uniform3f(context, locations.u_scale),
+                  "u_fade": new performance2.Uniform1f(context, locations.u_fade)
+                };
+              };
+              var lineSDFUniforms = function(context, locations) {
+                return {
+                  "u_matrix": new performance2.UniformMatrix4f(context, locations.u_matrix),
+                  "u_ratio": new performance2.Uniform1f(context, locations.u_ratio),
+                  "u_device_pixel_ratio": new performance2.Uniform1f(context, locations.u_device_pixel_ratio),
+                  "u_units_to_pixels": new performance2.Uniform2f(context, locations.u_units_to_pixels),
+                  "u_patternscale_a": new performance2.Uniform2f(context, locations.u_patternscale_a),
+                  "u_patternscale_b": new performance2.Uniform2f(context, locations.u_patternscale_b),
+                  "u_sdfgamma": new performance2.Uniform1f(context, locations.u_sdfgamma),
+                  "u_image": new performance2.Uniform1i(context, locations.u_image),
+                  "u_tex_y_a": new performance2.Uniform1f(context, locations.u_tex_y_a),
+                  "u_tex_y_b": new performance2.Uniform1f(context, locations.u_tex_y_b),
+                  "u_mix": new performance2.Uniform1f(context, locations.u_mix)
+                };
+              };
+              var lineUniformValues = function(painter, tile, layer) {
+                var transform = painter.transform;
+                return {
+                  "u_matrix": calculateMatrix(painter, tile, layer),
+                  "u_ratio": 1 / pixelsToTileUnits(tile, 1, transform.zoom),
+                  "u_device_pixel_ratio": performance2.browser.devicePixelRatio,
+                  "u_units_to_pixels": [
+                    1 / transform.pixelsToGLUnits[0],
+                    1 / transform.pixelsToGLUnits[1]
+                  ]
+                };
+              };
+              var lineGradientUniformValues = function(painter, tile, layer, imageHeight) {
+                return performance2.extend(lineUniformValues(painter, tile, layer), {
+                  "u_image": 0,
+                  "u_image_height": imageHeight
+                });
+              };
+              var linePatternUniformValues = function(painter, tile, layer, crossfade) {
+                var transform = painter.transform;
+                var tileZoomRatio = calculateTileRatio(tile, transform);
+                return {
+                  "u_matrix": calculateMatrix(painter, tile, layer),
+                  "u_texsize": tile.imageAtlasTexture.size,
+                  "u_ratio": 1 / pixelsToTileUnits(tile, 1, transform.zoom),
+                  "u_device_pixel_ratio": performance2.browser.devicePixelRatio,
+                  "u_image": 0,
+                  "u_scale": [
+                    tileZoomRatio,
+                    crossfade.fromScale,
+                    crossfade.toScale
+                  ],
+                  "u_fade": crossfade.t,
+                  "u_units_to_pixels": [
+                    1 / transform.pixelsToGLUnits[0],
+                    1 / transform.pixelsToGLUnits[1]
+                  ]
+                };
+              };
+              var lineSDFUniformValues = function(painter, tile, layer, dasharray, crossfade) {
+                var transform = painter.transform;
+                var lineAtlas = painter.lineAtlas;
+                var tileRatio = calculateTileRatio(tile, transform);
+                var round2 = layer.layout.get("line-cap") === "round";
+                var posA = lineAtlas.getDash(dasharray.from, round2);
+                var posB = lineAtlas.getDash(dasharray.to, round2);
+                var widthA = posA.width * crossfade.fromScale;
+                var widthB = posB.width * crossfade.toScale;
+                return performance2.extend(lineUniformValues(painter, tile, layer), {
+                  "u_patternscale_a": [
+                    tileRatio / widthA,
+                    -posA.height / 2
+                  ],
+                  "u_patternscale_b": [
+                    tileRatio / widthB,
+                    -posB.height / 2
+                  ],
+                  "u_sdfgamma": lineAtlas.width / (Math.min(widthA, widthB) * 256 * performance2.browser.devicePixelRatio) / 2,
+                  "u_image": 0,
+                  "u_tex_y_a": posA.y,
+                  "u_tex_y_b": posB.y,
+                  "u_mix": crossfade.t
+                });
+              };
+              function calculateTileRatio(tile, transform) {
+                return 1 / pixelsToTileUnits(tile, 1, transform.tileZoom);
+              }
+              function calculateMatrix(painter, tile, layer) {
+                return painter.translatePosMatrix(tile.tileID.posMatrix, tile, layer.paint.get("line-translate"), layer.paint.get("line-translate-anchor"));
+              }
+              var rasterUniforms = function(context, locations) {
+                return {
+                  "u_matrix": new performance2.UniformMatrix4f(context, locations.u_matrix),
+                  "u_tl_parent": new performance2.Uniform2f(context, locations.u_tl_parent),
+                  "u_scale_parent": new performance2.Uniform1f(context, locations.u_scale_parent),
+                  "u_buffer_scale": new performance2.Uniform1f(context, locations.u_buffer_scale),
+                  "u_fade_t": new performance2.Uniform1f(context, locations.u_fade_t),
+                  "u_opacity": new performance2.Uniform1f(context, locations.u_opacity),
+                  "u_image0": new performance2.Uniform1i(context, locations.u_image0),
+                  "u_image1": new performance2.Uniform1i(context, locations.u_image1),
+                  "u_brightness_low": new performance2.Uniform1f(context, locations.u_brightness_low),
+                  "u_brightness_high": new performance2.Uniform1f(context, locations.u_brightness_high),
+                  "u_saturation_factor": new performance2.Uniform1f(context, locations.u_saturation_factor),
+                  "u_contrast_factor": new performance2.Uniform1f(context, locations.u_contrast_factor),
+                  "u_spin_weights": new performance2.Uniform3f(context, locations.u_spin_weights)
+                };
+              };
+              var rasterUniformValues = function(matrix, parentTL, parentScaleBy, fade, layer) {
+                return {
+                  "u_matrix": matrix,
+                  "u_tl_parent": parentTL,
+                  "u_scale_parent": parentScaleBy,
+                  "u_buffer_scale": 1,
+                  "u_fade_t": fade.mix,
+                  "u_opacity": fade.opacity * layer.paint.get("raster-opacity"),
+                  "u_image0": 0,
+                  "u_image1": 1,
+                  "u_brightness_low": layer.paint.get("raster-brightness-min"),
+                  "u_brightness_high": layer.paint.get("raster-brightness-max"),
+                  "u_saturation_factor": saturationFactor(layer.paint.get("raster-saturation")),
+                  "u_contrast_factor": contrastFactor(layer.paint.get("raster-contrast")),
+                  "u_spin_weights": spinWeights(layer.paint.get("raster-hue-rotate"))
+                };
+              };
+              function spinWeights(angle2) {
+                angle2 *= Math.PI / 180;
+                var s2 = Math.sin(angle2);
+                var c2 = Math.cos(angle2);
+                return [
+                  (2 * c2 + 1) / 3,
+                  (-Math.sqrt(3) * s2 - c2 + 1) / 3,
+                  (Math.sqrt(3) * s2 - c2 + 1) / 3
+                ];
+              }
+              function contrastFactor(contrast) {
+                return contrast > 0 ? 1 / (1 - contrast) : 1 + contrast;
+              }
+              function saturationFactor(saturation) {
+                return saturation > 0 ? 1 - 1 / (1.001 - saturation) : -saturation;
+              }
+              var symbolIconUniforms = function(context, locations) {
+                return {
+                  "u_is_size_zoom_constant": new performance2.Uniform1i(context, locations.u_is_size_zoom_constant),
+                  "u_is_size_feature_constant": new performance2.Uniform1i(context, locations.u_is_size_feature_constant),
+                  "u_size_t": new performance2.Uniform1f(context, locations.u_size_t),
+                  "u_size": new performance2.Uniform1f(context, locations.u_size),
+                  "u_camera_to_center_distance": new performance2.Uniform1f(context, locations.u_camera_to_center_distance),
+                  "u_pitch": new performance2.Uniform1f(context, locations.u_pitch),
+                  "u_rotate_symbol": new performance2.Uniform1i(context, locations.u_rotate_symbol),
+                  "u_aspect_ratio": new performance2.Uniform1f(context, locations.u_aspect_ratio),
+                  "u_fade_change": new performance2.Uniform1f(context, locations.u_fade_change),
+                  "u_matrix": new performance2.UniformMatrix4f(context, locations.u_matrix),
+                  "u_label_plane_matrix": new performance2.UniformMatrix4f(context, locations.u_label_plane_matrix),
+                  "u_coord_matrix": new performance2.UniformMatrix4f(context, locations.u_coord_matrix),
+                  "u_is_text": new performance2.Uniform1i(context, locations.u_is_text),
+                  "u_pitch_with_map": new performance2.Uniform1i(context, locations.u_pitch_with_map),
+                  "u_texsize": new performance2.Uniform2f(context, locations.u_texsize),
+                  "u_texture": new performance2.Uniform1i(context, locations.u_texture)
+                };
+              };
+              var symbolSDFUniforms = function(context, locations) {
+                return {
+                  "u_is_size_zoom_constant": new performance2.Uniform1i(context, locations.u_is_size_zoom_constant),
+                  "u_is_size_feature_constant": new performance2.Uniform1i(context, locations.u_is_size_feature_constant),
+                  "u_size_t": new performance2.Uniform1f(context, locations.u_size_t),
+                  "u_size": new performance2.Uniform1f(context, locations.u_size),
+                  "u_camera_to_center_distance": new performance2.Uniform1f(context, locations.u_camera_to_center_distance),
+                  "u_pitch": new performance2.Uniform1f(context, locations.u_pitch),
+                  "u_rotate_symbol": new performance2.Uniform1i(context, locations.u_rotate_symbol),
+                  "u_aspect_ratio": new performance2.Uniform1f(context, locations.u_aspect_ratio),
+                  "u_fade_change": new performance2.Uniform1f(context, locations.u_fade_change),
+                  "u_matrix": new performance2.UniformMatrix4f(context, locations.u_matrix),
+                  "u_label_plane_matrix": new performance2.UniformMatrix4f(context, locations.u_label_plane_matrix),
+                  "u_coord_matrix": new performance2.UniformMatrix4f(context, locations.u_coord_matrix),
+                  "u_is_text": new performance2.Uniform1i(context, locations.u_is_text),
+                  "u_pitch_with_map": new performance2.Uniform1i(context, locations.u_pitch_with_map),
+                  "u_texsize": new performance2.Uniform2f(context, locations.u_texsize),
+                  "u_texture": new performance2.Uniform1i(context, locations.u_texture),
+                  "u_gamma_scale": new performance2.Uniform1f(context, locations.u_gamma_scale),
+                  "u_device_pixel_ratio": new performance2.Uniform1f(context, locations.u_device_pixel_ratio),
+                  "u_is_halo": new performance2.Uniform1i(context, locations.u_is_halo)
+                };
+              };
+              var symbolTextAndIconUniforms = function(context, locations) {
+                return {
+                  "u_is_size_zoom_constant": new performance2.Uniform1i(context, locations.u_is_size_zoom_constant),
+                  "u_is_size_feature_constant": new performance2.Uniform1i(context, locations.u_is_size_feature_constant),
+                  "u_size_t": new performance2.Uniform1f(context, locations.u_size_t),
+                  "u_size": new performance2.Uniform1f(context, locations.u_size),
+                  "u_camera_to_center_distance": new performance2.Uniform1f(context, locations.u_camera_to_center_distance),
+                  "u_pitch": new performance2.Uniform1f(context, locations.u_pitch),
+                  "u_rotate_symbol": new performance2.Uniform1i(context, locations.u_rotate_symbol),
+                  "u_aspect_ratio": new performance2.Uniform1f(context, locations.u_aspect_ratio),
+                  "u_fade_change": new performance2.Uniform1f(context, locations.u_fade_change),
+                  "u_matrix": new performance2.UniformMatrix4f(context, locations.u_matrix),
+                  "u_label_plane_matrix": new performance2.UniformMatrix4f(context, locations.u_label_plane_matrix),
+                  "u_coord_matrix": new performance2.UniformMatrix4f(context, locations.u_coord_matrix),
+                  "u_is_text": new performance2.Uniform1i(context, locations.u_is_text),
+                  "u_pitch_with_map": new performance2.Uniform1i(context, locations.u_pitch_with_map),
+                  "u_texsize": new performance2.Uniform2f(context, locations.u_texsize),
+                  "u_texsize_icon": new performance2.Uniform2f(context, locations.u_texsize_icon),
+                  "u_texture": new performance2.Uniform1i(context, locations.u_texture),
+                  "u_texture_icon": new performance2.Uniform1i(context, locations.u_texture_icon),
+                  "u_gamma_scale": new performance2.Uniform1f(context, locations.u_gamma_scale),
+                  "u_device_pixel_ratio": new performance2.Uniform1f(context, locations.u_device_pixel_ratio),
+                  "u_is_halo": new performance2.Uniform1i(context, locations.u_is_halo)
+                };
+              };
+              var symbolIconUniformValues = function(functionType, size, rotateInShader, pitchWithMap, painter, matrix, labelPlaneMatrix, glCoordMatrix, isText, texSize) {
+                var transform = painter.transform;
+                return {
+                  "u_is_size_zoom_constant": +(functionType === "constant" || functionType === "source"),
+                  "u_is_size_feature_constant": +(functionType === "constant" || functionType === "camera"),
+                  "u_size_t": size ? size.uSizeT : 0,
+                  "u_size": size ? size.uSize : 0,
+                  "u_camera_to_center_distance": transform.cameraToCenterDistance,
+                  "u_pitch": transform.pitch / 360 * 2 * Math.PI,
+                  "u_rotate_symbol": +rotateInShader,
+                  "u_aspect_ratio": transform.width / transform.height,
+                  "u_fade_change": painter.options.fadeDuration ? painter.symbolFadeChange : 1,
+                  "u_matrix": matrix,
+                  "u_label_plane_matrix": labelPlaneMatrix,
+                  "u_coord_matrix": glCoordMatrix,
+                  "u_is_text": +isText,
+                  "u_pitch_with_map": +pitchWithMap,
+                  "u_texsize": texSize,
+                  "u_texture": 0
+                };
+              };
+              var symbolSDFUniformValues = function(functionType, size, rotateInShader, pitchWithMap, painter, matrix, labelPlaneMatrix, glCoordMatrix, isText, texSize, isHalo) {
+                var transform = painter.transform;
+                return performance2.extend(symbolIconUniformValues(functionType, size, rotateInShader, pitchWithMap, painter, matrix, labelPlaneMatrix, glCoordMatrix, isText, texSize), {
+                  "u_gamma_scale": pitchWithMap ? Math.cos(transform._pitch) * transform.cameraToCenterDistance : 1,
+                  "u_device_pixel_ratio": performance2.browser.devicePixelRatio,
+                  "u_is_halo": 1
+                });
+              };
+              var symbolTextAndIconUniformValues = function(functionType, size, rotateInShader, pitchWithMap, painter, matrix, labelPlaneMatrix, glCoordMatrix, texSizeSDF, texSizeIcon) {
+                return performance2.extend(symbolSDFUniformValues(functionType, size, rotateInShader, pitchWithMap, painter, matrix, labelPlaneMatrix, glCoordMatrix, true, texSizeSDF), {
+                  "u_texsize_icon": texSizeIcon,
+                  "u_texture_icon": 1
+                });
+              };
+              var backgroundUniforms = function(context, locations) {
+                return {
+                  "u_matrix": new performance2.UniformMatrix4f(context, locations.u_matrix),
+                  "u_opacity": new performance2.Uniform1f(context, locations.u_opacity),
+                  "u_color": new performance2.UniformColor(context, locations.u_color)
+                };
+              };
+              var backgroundPatternUniforms = function(context, locations) {
+                return {
+                  "u_matrix": new performance2.UniformMatrix4f(context, locations.u_matrix),
+                  "u_opacity": new performance2.Uniform1f(context, locations.u_opacity),
+                  "u_image": new performance2.Uniform1i(context, locations.u_image),
+                  "u_pattern_tl_a": new performance2.Uniform2f(context, locations.u_pattern_tl_a),
+                  "u_pattern_br_a": new performance2.Uniform2f(context, locations.u_pattern_br_a),
+                  "u_pattern_tl_b": new performance2.Uniform2f(context, locations.u_pattern_tl_b),
+                  "u_pattern_br_b": new performance2.Uniform2f(context, locations.u_pattern_br_b),
+                  "u_texsize": new performance2.Uniform2f(context, locations.u_texsize),
+                  "u_mix": new performance2.Uniform1f(context, locations.u_mix),
+                  "u_pattern_size_a": new performance2.Uniform2f(context, locations.u_pattern_size_a),
+                  "u_pattern_size_b": new performance2.Uniform2f(context, locations.u_pattern_size_b),
+                  "u_scale_a": new performance2.Uniform1f(context, locations.u_scale_a),
+                  "u_scale_b": new performance2.Uniform1f(context, locations.u_scale_b),
+                  "u_pixel_coord_upper": new performance2.Uniform2f(context, locations.u_pixel_coord_upper),
+                  "u_pixel_coord_lower": new performance2.Uniform2f(context, locations.u_pixel_coord_lower),
+                  "u_tile_units_to_pixels": new performance2.Uniform1f(context, locations.u_tile_units_to_pixels)
+                };
+              };
+              var backgroundUniformValues = function(matrix, opacity, color22) {
+                return {
+                  "u_matrix": matrix,
+                  "u_opacity": opacity,
+                  "u_color": color22
+                };
+              };
+              var backgroundPatternUniformValues = function(matrix, opacity, painter, image, tile, crossfade) {
+                return performance2.extend(bgPatternUniformValues(image, crossfade, painter, tile), {
+                  "u_matrix": matrix,
+                  "u_opacity": opacity
+                });
+              };
+              var programUniforms = {
+                fillExtrusion: fillExtrusionUniforms,
+                fillExtrusionPattern: fillExtrusionPatternUniforms,
+                fill: fillUniforms,
+                fillPattern: fillPatternUniforms,
+                fillOutline: fillOutlineUniforms,
+                fillOutlinePattern: fillOutlinePatternUniforms,
+                circle: circleUniforms,
+                collisionBox: collisionUniforms,
+                collisionCircle: collisionCircleUniforms,
+                debug: debugUniforms,
+                clippingMask: clippingMaskUniforms,
+                heatmap: heatmapUniforms,
+                heatmapTexture: heatmapTextureUniforms,
+                hillshade: hillshadeUniforms,
+                hillshadePrepare: hillshadePrepareUniforms,
+                line: lineUniforms,
+                lineGradient: lineGradientUniforms,
+                linePattern: linePatternUniforms,
+                lineSDF: lineSDFUniforms,
+                raster: rasterUniforms,
+                symbolIcon: symbolIconUniforms,
+                symbolSDF: symbolSDFUniforms,
+                symbolTextAndIcon: symbolTextAndIconUniforms,
+                background: backgroundUniforms,
+                backgroundPattern: backgroundPatternUniforms
+              };
+              var quadTriangles;
+              function drawCollisionDebug(painter, sourceCache, layer, coords, translate2, translateAnchor, isText) {
+                var context = painter.context;
+                var gl2 = context.gl;
+                var program = painter.useProgram("collisionBox");
+                var tileBatches = [];
+                var circleCount = 0;
+                var circleOffset = 0;
+                for (var i2 = 0; i2 < coords.length; i2++) {
+                  var coord = coords[i2];
+                  var tile = sourceCache.getTile(coord);
+                  var bucket = tile.getBucket(layer);
+                  if (!bucket) {
+                    continue;
+                  }
+                  var posMatrix = coord.posMatrix;
+                  if (translate2[0] !== 0 || translate2[1] !== 0) {
+                    posMatrix = painter.translatePosMatrix(coord.posMatrix, tile, translate2, translateAnchor);
+                  }
+                  var buffers = isText ? bucket.textCollisionBox : bucket.iconCollisionBox;
+                  var circleArray = bucket.collisionCircleArray;
+                  if (circleArray.length > 0) {
+                    var invTransform = performance2.create();
+                    var transform = posMatrix;
+                    performance2.mul(invTransform, bucket.placementInvProjMatrix, painter.transform.glCoordMatrix);
+                    performance2.mul(invTransform, invTransform, bucket.placementViewportMatrix);
+                    tileBatches.push({
+                      circleArray,
+                      circleOffset,
+                      transform,
+                      invTransform
+                    });
+                    circleCount += circleArray.length / 4;
+                    circleOffset = circleCount;
+                  }
+                  if (!buffers) {
+                    continue;
+                  }
+                  program.draw(context, gl2.LINES, DepthMode.disabled, StencilMode.disabled, painter.colorModeForRenderPass(), CullFaceMode.disabled, collisionUniformValues(posMatrix, painter.transform, tile), layer.id, buffers.layoutVertexBuffer, buffers.indexBuffer, buffers.segments, null, painter.transform.zoom, null, null, buffers.collisionVertexBuffer);
+                }
+                if (!isText || !tileBatches.length) {
+                  return;
+                }
+                var circleProgram = painter.useProgram("collisionCircle");
+                var vertexData = new performance2.StructArrayLayout2f1f2i16();
+                vertexData.resize(circleCount * 4);
+                vertexData._trim();
+                var vertexOffset = 0;
+                for (var i$2 = 0, list = tileBatches; i$2 < list.length; i$2 += 1) {
+                  var batch = list[i$2];
+                  for (var i$1 = 0; i$1 < batch.circleArray.length / 4; i$1++) {
+                    var circleIdx = i$1 * 4;
+                    var x2 = batch.circleArray[circleIdx + 0];
+                    var y2 = batch.circleArray[circleIdx + 1];
+                    var radius = batch.circleArray[circleIdx + 2];
+                    var collision = batch.circleArray[circleIdx + 3];
+                    vertexData.emplace(vertexOffset++, x2, y2, radius, collision, 0);
+                    vertexData.emplace(vertexOffset++, x2, y2, radius, collision, 1);
+                    vertexData.emplace(vertexOffset++, x2, y2, radius, collision, 2);
+                    vertexData.emplace(vertexOffset++, x2, y2, radius, collision, 3);
+                  }
+                }
+                if (!quadTriangles || quadTriangles.length < circleCount * 2) {
+                  quadTriangles = createQuadTriangles(circleCount);
+                }
+                var indexBuffer = context.createIndexBuffer(quadTriangles, true);
+                var vertexBuffer = context.createVertexBuffer(vertexData, performance2.collisionCircleLayout.members, true);
+                for (var i$3 = 0, list$1 = tileBatches; i$3 < list$1.length; i$3 += 1) {
+                  var batch$1 = list$1[i$3];
+                  var uniforms = collisionCircleUniformValues(batch$1.transform, batch$1.invTransform, painter.transform);
+                  circleProgram.draw(context, gl2.TRIANGLES, DepthMode.disabled, StencilMode.disabled, painter.colorModeForRenderPass(), CullFaceMode.disabled, uniforms, layer.id, vertexBuffer, indexBuffer, performance2.SegmentVector.simpleSegment(0, batch$1.circleOffset * 2, batch$1.circleArray.length, batch$1.circleArray.length / 2), null, painter.transform.zoom, null, null, null);
+                }
+                vertexBuffer.destroy();
+                indexBuffer.destroy();
+              }
+              function createQuadTriangles(quadCount) {
+                var triCount = quadCount * 2;
+                var array = new performance2.StructArrayLayout3ui6();
+                array.resize(triCount);
+                array._trim();
+                for (var i2 = 0; i2 < triCount; i2++) {
+                  var idx = i2 * 6;
+                  array.uint16[idx + 0] = i2 * 4 + 0;
+                  array.uint16[idx + 1] = i2 * 4 + 1;
+                  array.uint16[idx + 2] = i2 * 4 + 2;
+                  array.uint16[idx + 3] = i2 * 4 + 2;
+                  array.uint16[idx + 4] = i2 * 4 + 3;
+                  array.uint16[idx + 5] = i2 * 4 + 0;
+                }
+                return array;
+              }
+              var identityMat4 = performance2.identity(new Float32Array(16));
+              function drawSymbols(painter, sourceCache, layer, coords, variableOffsets) {
+                if (painter.renderPass !== "translucent") {
+                  return;
+                }
+                var stencilMode = StencilMode.disabled;
+                var colorMode = painter.colorModeForRenderPass();
+                var variablePlacement = layer.layout.get("text-variable-anchor");
+                if (variablePlacement) {
+                  updateVariableAnchors(coords, painter, layer, sourceCache, layer.layout.get("text-rotation-alignment"), layer.layout.get("text-pitch-alignment"), variableOffsets);
+                }
+                if (layer.paint.get("icon-opacity").constantOr(1) !== 0) {
+                  drawLayerSymbols(painter, sourceCache, layer, coords, false, layer.paint.get("icon-translate"), layer.paint.get("icon-translate-anchor"), layer.layout.get("icon-rotation-alignment"), layer.layout.get("icon-pitch-alignment"), layer.layout.get("icon-keep-upright"), stencilMode, colorMode);
+                }
+                if (layer.paint.get("text-opacity").constantOr(1) !== 0) {
+                  drawLayerSymbols(painter, sourceCache, layer, coords, true, layer.paint.get("text-translate"), layer.paint.get("text-translate-anchor"), layer.layout.get("text-rotation-alignment"), layer.layout.get("text-pitch-alignment"), layer.layout.get("text-keep-upright"), stencilMode, colorMode);
+                }
+                if (sourceCache.map.showCollisionBoxes) {
+                  drawCollisionDebug(painter, sourceCache, layer, coords, layer.paint.get("text-translate"), layer.paint.get("text-translate-anchor"), true);
+                  drawCollisionDebug(painter, sourceCache, layer, coords, layer.paint.get("icon-translate"), layer.paint.get("icon-translate-anchor"), false);
+                }
+              }
+              function calculateVariableRenderShift(anchor, width, height, textOffset, textBoxScale, renderTextSize) {
+                var ref = performance2.getAnchorAlignment(anchor);
+                var horizontalAlign = ref.horizontalAlign;
+                var verticalAlign = ref.verticalAlign;
+                var shiftX = -(horizontalAlign - 0.5) * width;
+                var shiftY = -(verticalAlign - 0.5) * height;
+                var variableOffset = performance2.evaluateVariableOffset(anchor, textOffset);
+                return new performance2.Point((shiftX / textBoxScale + variableOffset[0]) * renderTextSize, (shiftY / textBoxScale + variableOffset[1]) * renderTextSize);
+              }
+              function updateVariableAnchors(coords, painter, layer, sourceCache, rotationAlignment, pitchAlignment, variableOffsets) {
+                var tr = painter.transform;
+                var rotateWithMap = rotationAlignment === "map";
+                var pitchWithMap = pitchAlignment === "map";
+                for (var i2 = 0, list = coords; i2 < list.length; i2 += 1) {
+                  var coord = list[i2];
+                  var tile = sourceCache.getTile(coord);
+                  var bucket = tile.getBucket(layer);
+                  if (!bucket || !bucket.text || !bucket.text.segments.get().length) {
+                    continue;
+                  }
+                  var sizeData = bucket.textSizeData;
+                  var size = performance2.evaluateSizeForZoom(sizeData, tr.zoom);
+                  var pixelToTileScale = pixelsToTileUnits(tile, 1, painter.transform.zoom);
+                  var labelPlaneMatrix = getLabelPlaneMatrix(coord.posMatrix, pitchWithMap, rotateWithMap, painter.transform, pixelToTileScale);
+                  var updateTextFitIcon = layer.layout.get("icon-text-fit") !== "none" && bucket.hasIconData();
+                  if (size) {
+                    var tileScale = Math.pow(2, tr.zoom - tile.tileID.overscaledZ);
+                    updateVariableAnchorsForBucket(bucket, rotateWithMap, pitchWithMap, variableOffsets, performance2.symbolSize, tr, labelPlaneMatrix, coord.posMatrix, tileScale, size, updateTextFitIcon);
+                  }
+                }
+              }
+              function updateVariableAnchorsForBucket(bucket, rotateWithMap, pitchWithMap, variableOffsets, symbolSize, transform, labelPlaneMatrix, posMatrix, tileScale, size, updateTextFitIcon) {
+                var placedSymbols = bucket.text.placedSymbolArray;
+                var dynamicTextLayoutVertexArray = bucket.text.dynamicLayoutVertexArray;
+                var dynamicIconLayoutVertexArray = bucket.icon.dynamicLayoutVertexArray;
+                var placedTextShifts = {};
+                dynamicTextLayoutVertexArray.clear();
+                for (var s2 = 0; s2 < placedSymbols.length; s2++) {
+                  var symbol = placedSymbols.get(s2);
+                  var skipOrientation = bucket.allowVerticalPlacement && !symbol.placedOrientation;
+                  var variableOffset = !symbol.hidden && symbol.crossTileID && !skipOrientation ? variableOffsets[symbol.crossTileID] : null;
+                  if (!variableOffset) {
+                    hideGlyphs(symbol.numGlyphs, dynamicTextLayoutVertexArray);
+                  } else {
+                    var tileAnchor = new performance2.Point(symbol.anchorX, symbol.anchorY);
+                    var projectedAnchor = project2(tileAnchor, pitchWithMap ? posMatrix : labelPlaneMatrix);
+                    var perspectiveRatio = getPerspectiveRatio(transform.cameraToCenterDistance, projectedAnchor.signedDistanceFromCamera);
+                    var renderTextSize = symbolSize.evaluateSizeForFeature(bucket.textSizeData, size, symbol) * perspectiveRatio / performance2.ONE_EM;
+                    if (pitchWithMap) {
+                      renderTextSize *= bucket.tilePixelRatio / tileScale;
+                    }
+                    var width = variableOffset.width;
+                    var height = variableOffset.height;
+                    var anchor = variableOffset.anchor;
+                    var textOffset = variableOffset.textOffset;
+                    var textBoxScale = variableOffset.textBoxScale;
+                    var shift = calculateVariableRenderShift(anchor, width, height, textOffset, textBoxScale, renderTextSize);
+                    var shiftedAnchor = pitchWithMap ? project2(tileAnchor.add(shift), labelPlaneMatrix).point : projectedAnchor.point.add(rotateWithMap ? shift.rotate(-transform.angle) : shift);
+                    var angle2 = bucket.allowVerticalPlacement && symbol.placedOrientation === performance2.WritingMode.vertical ? Math.PI / 2 : 0;
+                    for (var g2 = 0; g2 < symbol.numGlyphs; g2++) {
+                      performance2.addDynamicAttributes(dynamicTextLayoutVertexArray, shiftedAnchor, angle2);
+                    }
+                    if (updateTextFitIcon && symbol.associatedIconIndex >= 0) {
+                      placedTextShifts[symbol.associatedIconIndex] = {
+                        shiftedAnchor,
+                        angle: angle2
+                      };
+                    }
+                  }
+                }
+                if (updateTextFitIcon) {
+                  dynamicIconLayoutVertexArray.clear();
+                  var placedIcons = bucket.icon.placedSymbolArray;
+                  for (var i2 = 0; i2 < placedIcons.length; i2++) {
+                    var placedIcon = placedIcons.get(i2);
+                    if (placedIcon.hidden) {
+                      hideGlyphs(placedIcon.numGlyphs, dynamicIconLayoutVertexArray);
+                    } else {
+                      var shift$1 = placedTextShifts[i2];
+                      if (!shift$1) {
+                        hideGlyphs(placedIcon.numGlyphs, dynamicIconLayoutVertexArray);
+                      } else {
+                        for (var g$1 = 0; g$1 < placedIcon.numGlyphs; g$1++) {
+                          performance2.addDynamicAttributes(dynamicIconLayoutVertexArray, shift$1.shiftedAnchor, shift$1.angle);
+                        }
+                      }
+                    }
+                  }
+                  bucket.icon.dynamicLayoutVertexBuffer.updateData(dynamicIconLayoutVertexArray);
+                }
+                bucket.text.dynamicLayoutVertexBuffer.updateData(dynamicTextLayoutVertexArray);
+              }
+              function getSymbolProgramName(isSDF, isText, bucket) {
+                if (bucket.iconsInText && isText) {
+                  return "symbolTextAndIcon";
+                } else if (isSDF) {
+                  return "symbolSDF";
+                } else {
+                  return "symbolIcon";
+                }
+              }
+              function drawLayerSymbols(painter, sourceCache, layer, coords, isText, translate2, translateAnchor, rotationAlignment, pitchAlignment, keepUpright, stencilMode, colorMode) {
+                var context = painter.context;
+                var gl2 = context.gl;
+                var tr = painter.transform;
+                var rotateWithMap = rotationAlignment === "map";
+                var pitchWithMap = pitchAlignment === "map";
+                var alongLine = rotateWithMap && layer.layout.get("symbol-placement") !== "point";
+                var rotateInShader = rotateWithMap && !pitchWithMap && !alongLine;
+                var hasSortKey = layer.layout.get("symbol-sort-key").constantOr(1) !== void 0;
+                var sortFeaturesByKey = false;
+                var depthMode = painter.depthModeForSublayer(0, DepthMode.ReadOnly);
+                var variablePlacement = layer.layout.get("text-variable-anchor");
+                var tileRenderState = [];
+                for (var i$1 = 0, list$1 = coords; i$1 < list$1.length; i$1 += 1) {
+                  var coord = list$1[i$1];
+                  var tile = sourceCache.getTile(coord);
+                  var bucket = tile.getBucket(layer);
+                  if (!bucket) {
+                    continue;
+                  }
+                  var buffers = isText ? bucket.text : bucket.icon;
+                  if (!buffers || !buffers.segments.get().length) {
+                    continue;
+                  }
+                  var programConfiguration = buffers.programConfigurations.get(layer.id);
+                  var isSDF = isText || bucket.sdfIcons;
+                  var sizeData = isText ? bucket.textSizeData : bucket.iconSizeData;
+                  var transformed = pitchWithMap || tr.pitch !== 0;
+                  var program = painter.useProgram(getSymbolProgramName(isSDF, isText, bucket), programConfiguration);
+                  var size = performance2.evaluateSizeForZoom(sizeData, tr.zoom);
+                  var texSize = void 0;
+                  var texSizeIcon = [
+                    0,
+                    0
+                  ];
+                  var atlasTexture = void 0;
+                  var atlasInterpolation = void 0;
+                  var atlasTextureIcon = null;
+                  var atlasInterpolationIcon = void 0;
+                  if (isText) {
+                    atlasTexture = tile.glyphAtlasTexture;
+                    atlasInterpolation = gl2.LINEAR;
+                    texSize = tile.glyphAtlasTexture.size;
+                    if (bucket.iconsInText) {
+                      texSizeIcon = tile.imageAtlasTexture.size;
+                      atlasTextureIcon = tile.imageAtlasTexture;
+                      var zoomDependentSize = sizeData.kind === "composite" || sizeData.kind === "camera";
+                      atlasInterpolationIcon = transformed || painter.options.rotating || painter.options.zooming || zoomDependentSize ? gl2.LINEAR : gl2.NEAREST;
+                    }
+                  } else {
+                    var iconScaled = layer.layout.get("icon-size").constantOr(0) !== 1 || bucket.iconsNeedLinear;
+                    atlasTexture = tile.imageAtlasTexture;
+                    atlasInterpolation = isSDF || painter.options.rotating || painter.options.zooming || iconScaled || transformed ? gl2.LINEAR : gl2.NEAREST;
+                    texSize = tile.imageAtlasTexture.size;
+                  }
+                  var s2 = pixelsToTileUnits(tile, 1, painter.transform.zoom);
+                  var labelPlaneMatrix = getLabelPlaneMatrix(coord.posMatrix, pitchWithMap, rotateWithMap, painter.transform, s2);
+                  var glCoordMatrix = getGlCoordMatrix(coord.posMatrix, pitchWithMap, rotateWithMap, painter.transform, s2);
+                  var hasVariableAnchors = variablePlacement && bucket.hasTextData();
+                  var updateTextFitIcon = layer.layout.get("icon-text-fit") !== "none" && hasVariableAnchors && bucket.hasIconData();
+                  if (alongLine) {
+                    updateLineLabels(bucket, coord.posMatrix, painter, isText, labelPlaneMatrix, glCoordMatrix, pitchWithMap, keepUpright);
+                  }
+                  var matrix = painter.translatePosMatrix(coord.posMatrix, tile, translate2, translateAnchor), uLabelPlaneMatrix = alongLine || isText && variablePlacement || updateTextFitIcon ? identityMat4 : labelPlaneMatrix, uglCoordMatrix = painter.translatePosMatrix(glCoordMatrix, tile, translate2, translateAnchor, true);
+                  var hasHalo = isSDF && layer.paint.get(isText ? "text-halo-width" : "icon-halo-width").constantOr(1) !== 0;
+                  var uniformValues = void 0;
+                  if (isSDF) {
+                    if (!bucket.iconsInText) {
+                      uniformValues = symbolSDFUniformValues(sizeData.kind, size, rotateInShader, pitchWithMap, painter, matrix, uLabelPlaneMatrix, uglCoordMatrix, isText, texSize);
+                    } else {
+                      uniformValues = symbolTextAndIconUniformValues(sizeData.kind, size, rotateInShader, pitchWithMap, painter, matrix, uLabelPlaneMatrix, uglCoordMatrix, texSize, texSizeIcon);
+                    }
+                  } else {
+                    uniformValues = symbolIconUniformValues(sizeData.kind, size, rotateInShader, pitchWithMap, painter, matrix, uLabelPlaneMatrix, uglCoordMatrix, isText, texSize);
+                  }
+                  var state = {
+                    program,
+                    buffers,
+                    uniformValues,
+                    atlasTexture,
+                    atlasTextureIcon,
+                    atlasInterpolation,
+                    atlasInterpolationIcon,
+                    isSDF,
+                    hasHalo
+                  };
+                  if (hasSortKey && bucket.canOverlap) {
+                    sortFeaturesByKey = true;
+                    var oldSegments = buffers.segments.get();
+                    for (var i2 = 0, list = oldSegments; i2 < list.length; i2 += 1) {
+                      var segment = list[i2];
+                      tileRenderState.push({
+                        segments: new performance2.SegmentVector([segment]),
+                        sortKey: segment.sortKey,
+                        state
+                      });
+                    }
+                  } else {
+                    tileRenderState.push({
+                      segments: buffers.segments,
+                      sortKey: 0,
+                      state
+                    });
+                  }
+                }
+                if (sortFeaturesByKey) {
+                  tileRenderState.sort(function(a2, b2) {
+                    return a2.sortKey - b2.sortKey;
+                  });
+                }
+                for (var i$2 = 0, list$2 = tileRenderState; i$2 < list$2.length; i$2 += 1) {
+                  var segmentState = list$2[i$2];
+                  var state$1 = segmentState.state;
+                  context.activeTexture.set(gl2.TEXTURE0);
+                  state$1.atlasTexture.bind(state$1.atlasInterpolation, gl2.CLAMP_TO_EDGE);
+                  if (state$1.atlasTextureIcon) {
+                    context.activeTexture.set(gl2.TEXTURE1);
+                    if (state$1.atlasTextureIcon) {
+                      state$1.atlasTextureIcon.bind(state$1.atlasInterpolationIcon, gl2.CLAMP_TO_EDGE);
+                    }
+                  }
+                  if (state$1.isSDF) {
+                    var uniformValues$1 = state$1.uniformValues;
+                    if (state$1.hasHalo) {
+                      uniformValues$1["u_is_halo"] = 1;
+                      drawSymbolElements(state$1.buffers, segmentState.segments, layer, painter, state$1.program, depthMode, stencilMode, colorMode, uniformValues$1);
+                    }
+                    uniformValues$1["u_is_halo"] = 0;
+                  }
+                  drawSymbolElements(state$1.buffers, segmentState.segments, layer, painter, state$1.program, depthMode, stencilMode, colorMode, state$1.uniformValues);
+                }
+              }
+              function drawSymbolElements(buffers, segments, layer, painter, program, depthMode, stencilMode, colorMode, uniformValues) {
+                var context = painter.context;
+                var gl2 = context.gl;
+                program.draw(context, gl2.TRIANGLES, depthMode, stencilMode, colorMode, CullFaceMode.disabled, uniformValues, layer.id, buffers.layoutVertexBuffer, buffers.indexBuffer, segments, layer.paint, painter.transform.zoom, buffers.programConfigurations.get(layer.id), buffers.dynamicLayoutVertexBuffer, buffers.opacityVertexBuffer);
+              }
+              function drawCircles(painter, sourceCache, layer, coords) {
+                if (painter.renderPass !== "translucent") {
+                  return;
+                }
+                var opacity = layer.paint.get("circle-opacity");
+                var strokeWidth = layer.paint.get("circle-stroke-width");
+                var strokeOpacity = layer.paint.get("circle-stroke-opacity");
+                var sortFeaturesByKey = layer.layout.get("circle-sort-key").constantOr(1) !== void 0;
+                if (opacity.constantOr(1) === 0 && (strokeWidth.constantOr(1) === 0 || strokeOpacity.constantOr(1) === 0)) {
+                  return;
+                }
+                var context = painter.context;
+                var gl2 = context.gl;
+                var depthMode = painter.depthModeForSublayer(0, DepthMode.ReadOnly);
+                var stencilMode = StencilMode.disabled;
+                var colorMode = painter.colorModeForRenderPass();
+                var segmentsRenderStates = [];
+                for (var i2 = 0; i2 < coords.length; i2++) {
+                  var coord = coords[i2];
+                  var tile = sourceCache.getTile(coord);
+                  var bucket = tile.getBucket(layer);
+                  if (!bucket) {
+                    continue;
+                  }
+                  var programConfiguration = bucket.programConfigurations.get(layer.id);
+                  var program = painter.useProgram("circle", programConfiguration);
+                  var layoutVertexBuffer = bucket.layoutVertexBuffer;
+                  var indexBuffer = bucket.indexBuffer;
+                  var uniformValues = circleUniformValues(painter, coord, tile, layer);
+                  var state = {
+                    programConfiguration,
+                    program,
+                    layoutVertexBuffer,
+                    indexBuffer,
+                    uniformValues
+                  };
+                  if (sortFeaturesByKey) {
+                    var oldSegments = bucket.segments.get();
+                    for (var i$1 = 0, list = oldSegments; i$1 < list.length; i$1 += 1) {
+                      var segment = list[i$1];
+                      segmentsRenderStates.push({
+                        segments: new performance2.SegmentVector([segment]),
+                        sortKey: segment.sortKey,
+                        state
+                      });
+                    }
+                  } else {
+                    segmentsRenderStates.push({
+                      segments: bucket.segments,
+                      sortKey: 0,
+                      state
+                    });
+                  }
+                }
+                if (sortFeaturesByKey) {
+                  segmentsRenderStates.sort(function(a2, b2) {
+                    return a2.sortKey - b2.sortKey;
+                  });
+                }
+                for (var i$2 = 0, list$1 = segmentsRenderStates; i$2 < list$1.length; i$2 += 1) {
+                  var segmentsState = list$1[i$2];
+                  var ref = segmentsState.state;
+                  var programConfiguration$1 = ref.programConfiguration;
+                  var program$1 = ref.program;
+                  var layoutVertexBuffer$1 = ref.layoutVertexBuffer;
+                  var indexBuffer$1 = ref.indexBuffer;
+                  var uniformValues$1 = ref.uniformValues;
+                  var segments = segmentsState.segments;
+                  program$1.draw(context, gl2.TRIANGLES, depthMode, stencilMode, colorMode, CullFaceMode.disabled, uniformValues$1, layer.id, layoutVertexBuffer$1, indexBuffer$1, segments, layer.paint, painter.transform.zoom, programConfiguration$1);
+                }
+              }
+              function drawHeatmap(painter, sourceCache, layer, coords) {
+                if (layer.paint.get("heatmap-opacity") === 0) {
+                  return;
+                }
+                if (painter.renderPass === "offscreen") {
+                  var context = painter.context;
+                  var gl2 = context.gl;
+                  var stencilMode = StencilMode.disabled;
+                  var colorMode = new ColorMode([
+                    gl2.ONE,
+                    gl2.ONE
+                  ], performance2.Color.transparent, [
+                    true,
+                    true,
+                    true,
+                    true
+                  ]);
+                  bindFramebuffer2(context, painter, layer);
+                  context.clear({ color: performance2.Color.transparent });
+                  for (var i2 = 0; i2 < coords.length; i2++) {
+                    var coord = coords[i2];
+                    if (sourceCache.hasRenderableParent(coord)) {
+                      continue;
+                    }
+                    var tile = sourceCache.getTile(coord);
+                    var bucket = tile.getBucket(layer);
+                    if (!bucket) {
+                      continue;
+                    }
+                    var programConfiguration = bucket.programConfigurations.get(layer.id);
+                    var program = painter.useProgram("heatmap", programConfiguration);
+                    var ref = painter.transform;
+                    var zoom = ref.zoom;
+                    program.draw(context, gl2.TRIANGLES, DepthMode.disabled, stencilMode, colorMode, CullFaceMode.disabled, heatmapUniformValues(coord.posMatrix, tile, zoom, layer.paint.get("heatmap-intensity")), layer.id, bucket.layoutVertexBuffer, bucket.indexBuffer, bucket.segments, layer.paint, painter.transform.zoom, programConfiguration);
+                  }
+                  context.viewport.set([
+                    0,
+                    0,
+                    painter.width,
+                    painter.height
+                  ]);
+                } else if (painter.renderPass === "translucent") {
+                  painter.context.setColorMode(painter.colorModeForRenderPass());
+                  renderTextureToMap(painter, layer);
+                }
+              }
+              function bindFramebuffer2(context, painter, layer) {
+                var gl2 = context.gl;
+                context.activeTexture.set(gl2.TEXTURE1);
+                context.viewport.set([
+                  0,
+                  0,
+                  painter.width / 4,
+                  painter.height / 4
+                ]);
+                var fbo = layer.heatmapFbo;
+                if (!fbo) {
+                  var texture = gl2.createTexture();
+                  gl2.bindTexture(gl2.TEXTURE_2D, texture);
+                  gl2.texParameteri(gl2.TEXTURE_2D, gl2.TEXTURE_WRAP_S, gl2.CLAMP_TO_EDGE);
+                  gl2.texParameteri(gl2.TEXTURE_2D, gl2.TEXTURE_WRAP_T, gl2.CLAMP_TO_EDGE);
+                  gl2.texParameteri(gl2.TEXTURE_2D, gl2.TEXTURE_MIN_FILTER, gl2.LINEAR);
+                  gl2.texParameteri(gl2.TEXTURE_2D, gl2.TEXTURE_MAG_FILTER, gl2.LINEAR);
+                  fbo = layer.heatmapFbo = context.createFramebuffer(painter.width / 4, painter.height / 4, false);
+                  bindTextureToFramebuffer(context, painter, texture, fbo);
+                } else {
+                  gl2.bindTexture(gl2.TEXTURE_2D, fbo.colorAttachment.get());
+                  context.bindFramebuffer.set(fbo.framebuffer);
+                }
+              }
+              function bindTextureToFramebuffer(context, painter, texture, fbo) {
+                var gl2 = context.gl;
+                var internalFormat = context.extRenderToTextureHalfFloat ? context.extTextureHalfFloat.HALF_FLOAT_OES : gl2.UNSIGNED_BYTE;
+                gl2.texImage2D(gl2.TEXTURE_2D, 0, gl2.RGBA, painter.width / 4, painter.height / 4, 0, gl2.RGBA, internalFormat, null);
+                fbo.colorAttachment.set(texture);
+              }
+              function renderTextureToMap(painter, layer) {
+                var context = painter.context;
+                var gl2 = context.gl;
+                var fbo = layer.heatmapFbo;
+                if (!fbo) {
+                  return;
+                }
+                context.activeTexture.set(gl2.TEXTURE0);
+                gl2.bindTexture(gl2.TEXTURE_2D, fbo.colorAttachment.get());
+                context.activeTexture.set(gl2.TEXTURE1);
+                var colorRampTexture = layer.colorRampTexture;
+                if (!colorRampTexture) {
+                  colorRampTexture = layer.colorRampTexture = new performance2.Texture(context, layer.colorRamp, gl2.RGBA);
+                }
+                colorRampTexture.bind(gl2.LINEAR, gl2.CLAMP_TO_EDGE);
+                painter.useProgram("heatmapTexture").draw(context, gl2.TRIANGLES, DepthMode.disabled, StencilMode.disabled, painter.colorModeForRenderPass(), CullFaceMode.disabled, heatmapTextureUniformValues(painter, layer, 0, 1), layer.id, painter.viewportBuffer, painter.quadTriangleIndexBuffer, painter.viewportSegments, layer.paint, painter.transform.zoom);
+              }
+              function drawLine(painter, sourceCache, layer, coords) {
+                if (painter.renderPass !== "translucent") {
+                  return;
+                }
+                var opacity = layer.paint.get("line-opacity");
+                var width = layer.paint.get("line-width");
+                if (opacity.constantOr(1) === 0 || width.constantOr(1) === 0) {
+                  return;
+                }
+                var depthMode = painter.depthModeForSublayer(0, DepthMode.ReadOnly);
+                var colorMode = painter.colorModeForRenderPass();
+                var dasharray = layer.paint.get("line-dasharray");
+                var patternProperty = layer.paint.get("line-pattern");
+                var image = patternProperty.constantOr(1);
+                var gradient = layer.paint.get("line-gradient");
+                var crossfade = layer.getCrossfadeParameters();
+                var programId = image ? "linePattern" : dasharray ? "lineSDF" : gradient ? "lineGradient" : "line";
+                var context = painter.context;
+                var gl2 = context.gl;
+                var firstTile = true;
+                for (var i2 = 0, list = coords; i2 < list.length; i2 += 1) {
+                  var coord = list[i2];
+                  var tile = sourceCache.getTile(coord);
+                  if (image && !tile.patternsLoaded()) {
+                    continue;
+                  }
+                  var bucket = tile.getBucket(layer);
+                  if (!bucket) {
+                    continue;
+                  }
+                  var programConfiguration = bucket.programConfigurations.get(layer.id);
+                  var prevProgram = painter.context.program.get();
+                  var program = painter.useProgram(programId, programConfiguration);
+                  var programChanged = firstTile || program.program !== prevProgram;
+                  var constantPattern = patternProperty.constantOr(null);
+                  if (constantPattern && tile.imageAtlas) {
+                    var atlas = tile.imageAtlas;
+                    var posTo = atlas.patternPositions[constantPattern.to.toString()];
+                    var posFrom = atlas.patternPositions[constantPattern.from.toString()];
+                    if (posTo && posFrom) {
+                      programConfiguration.setConstantPatternPositions(posTo, posFrom);
+                    }
+                  }
+                  var uniformValues = image ? linePatternUniformValues(painter, tile, layer, crossfade) : dasharray ? lineSDFUniformValues(painter, tile, layer, dasharray, crossfade) : gradient ? lineGradientUniformValues(painter, tile, layer, bucket.lineClipsArray.length) : lineUniformValues(painter, tile, layer);
+                  if (image) {
+                    context.activeTexture.set(gl2.TEXTURE0);
+                    tile.imageAtlasTexture.bind(gl2.LINEAR, gl2.CLAMP_TO_EDGE);
+                    programConfiguration.updatePaintBuffers(crossfade);
+                  } else if (dasharray && (programChanged || painter.lineAtlas.dirty)) {
+                    context.activeTexture.set(gl2.TEXTURE0);
+                    painter.lineAtlas.bind(context);
+                  } else if (gradient) {
+                    var layerGradient = bucket.gradients[layer.id];
+                    var gradientTexture = layerGradient.texture;
+                    if (layer.gradientVersion !== layerGradient.version) {
+                      var textureResolution = 256;
+                      if (layer.stepInterpolant) {
+                        var sourceMaxZoom = sourceCache.getSource().maxzoom;
+                        var potentialOverzoom = coord.canonical.z === sourceMaxZoom ? Math.ceil(1 << painter.transform.maxZoom - coord.canonical.z) : 1;
+                        var lineLength = bucket.maxLineLength / performance2.EXTENT;
+                        var maxTilePixelSize = 1024;
+                        var maxTextureCoverage = lineLength * maxTilePixelSize * potentialOverzoom;
+                        textureResolution = performance2.clamp(performance2.nextPowerOfTwo(maxTextureCoverage), 256, context.maxTextureSize);
+                      }
+                      layerGradient.gradient = performance2.renderColorRamp({
+                        expression: layer.gradientExpression(),
+                        evaluationKey: "lineProgress",
+                        resolution: textureResolution,
+                        image: layerGradient.gradient || void 0,
+                        clips: bucket.lineClipsArray
+                      });
+                      if (layerGradient.texture) {
+                        layerGradient.texture.update(layerGradient.gradient);
+                      } else {
+                        layerGradient.texture = new performance2.Texture(context, layerGradient.gradient, gl2.RGBA);
+                      }
+                      layerGradient.version = layer.gradientVersion;
+                      gradientTexture = layerGradient.texture;
+                    }
+                    context.activeTexture.set(gl2.TEXTURE0);
+                    gradientTexture.bind(layer.stepInterpolant ? gl2.NEAREST : gl2.LINEAR, gl2.CLAMP_TO_EDGE);
+                  }
+                  program.draw(context, gl2.TRIANGLES, depthMode, painter.stencilModeForClipping(coord), colorMode, CullFaceMode.disabled, uniformValues, layer.id, bucket.layoutVertexBuffer, bucket.indexBuffer, bucket.segments, layer.paint, painter.transform.zoom, programConfiguration, bucket.layoutVertexBuffer2);
+                  firstTile = false;
+                }
+              }
+              function drawFill(painter, sourceCache, layer, coords) {
+                var color22 = layer.paint.get("fill-color");
+                var opacity = layer.paint.get("fill-opacity");
+                if (opacity.constantOr(1) === 0) {
+                  return;
+                }
+                var colorMode = painter.colorModeForRenderPass();
+                var pattern = layer.paint.get("fill-pattern");
+                var pass = painter.opaquePassEnabledForLayer() && (!pattern.constantOr(1) && color22.constantOr(performance2.Color.transparent).a === 1 && opacity.constantOr(0) === 1) ? "opaque" : "translucent";
+                if (painter.renderPass === pass) {
+                  var depthMode = painter.depthModeForSublayer(1, painter.renderPass === "opaque" ? DepthMode.ReadWrite : DepthMode.ReadOnly);
+                  drawFillTiles(painter, sourceCache, layer, coords, depthMode, colorMode, false);
+                }
+                if (painter.renderPass === "translucent" && layer.paint.get("fill-antialias")) {
+                  var depthMode$1 = painter.depthModeForSublayer(layer.getPaintProperty("fill-outline-color") ? 2 : 0, DepthMode.ReadOnly);
+                  drawFillTiles(painter, sourceCache, layer, coords, depthMode$1, colorMode, true);
+                }
+              }
+              function drawFillTiles(painter, sourceCache, layer, coords, depthMode, colorMode, isOutline) {
+                var gl2 = painter.context.gl;
+                var patternProperty = layer.paint.get("fill-pattern");
+                var image = patternProperty && patternProperty.constantOr(1);
+                var crossfade = layer.getCrossfadeParameters();
+                var drawMode, programName, uniformValues, indexBuffer, segments;
+                if (!isOutline) {
+                  programName = image ? "fillPattern" : "fill";
+                  drawMode = gl2.TRIANGLES;
+                } else {
+                  programName = image && !layer.getPaintProperty("fill-outline-color") ? "fillOutlinePattern" : "fillOutline";
+                  drawMode = gl2.LINES;
+                }
+                for (var i2 = 0, list = coords; i2 < list.length; i2 += 1) {
+                  var coord = list[i2];
+                  var tile = sourceCache.getTile(coord);
+                  if (image && !tile.patternsLoaded()) {
+                    continue;
+                  }
+                  var bucket = tile.getBucket(layer);
+                  if (!bucket) {
+                    continue;
+                  }
+                  var programConfiguration = bucket.programConfigurations.get(layer.id);
+                  var program = painter.useProgram(programName, programConfiguration);
+                  if (image) {
+                    painter.context.activeTexture.set(gl2.TEXTURE0);
+                    tile.imageAtlasTexture.bind(gl2.LINEAR, gl2.CLAMP_TO_EDGE);
+                    programConfiguration.updatePaintBuffers(crossfade);
+                  }
+                  var constantPattern = patternProperty.constantOr(null);
+                  if (constantPattern && tile.imageAtlas) {
+                    var atlas = tile.imageAtlas;
+                    var posTo = atlas.patternPositions[constantPattern.to.toString()];
+                    var posFrom = atlas.patternPositions[constantPattern.from.toString()];
+                    if (posTo && posFrom) {
+                      programConfiguration.setConstantPatternPositions(posTo, posFrom);
+                    }
+                  }
+                  var tileMatrix = painter.translatePosMatrix(coord.posMatrix, tile, layer.paint.get("fill-translate"), layer.paint.get("fill-translate-anchor"));
+                  if (!isOutline) {
+                    indexBuffer = bucket.indexBuffer;
+                    segments = bucket.segments;
+                    uniformValues = image ? fillPatternUniformValues(tileMatrix, painter, crossfade, tile) : fillUniformValues(tileMatrix);
+                  } else {
+                    indexBuffer = bucket.indexBuffer2;
+                    segments = bucket.segments2;
+                    var drawingBufferSize = [
+                      gl2.drawingBufferWidth,
+                      gl2.drawingBufferHeight
+                    ];
+                    uniformValues = programName === "fillOutlinePattern" && image ? fillOutlinePatternUniformValues(tileMatrix, painter, crossfade, tile, drawingBufferSize) : fillOutlineUniformValues(tileMatrix, drawingBufferSize);
+                  }
+                  program.draw(painter.context, drawMode, depthMode, painter.stencilModeForClipping(coord), colorMode, CullFaceMode.disabled, uniformValues, layer.id, bucket.layoutVertexBuffer, indexBuffer, segments, layer.paint, painter.transform.zoom, programConfiguration);
+                }
+              }
+              function draw(painter, source2, layer, coords) {
+                var opacity = layer.paint.get("fill-extrusion-opacity");
+                if (opacity === 0) {
+                  return;
+                }
+                if (painter.renderPass === "translucent") {
+                  var depthMode = new DepthMode(painter.context.gl.LEQUAL, DepthMode.ReadWrite, painter.depthRangeFor3D);
+                  if (opacity === 1 && !layer.paint.get("fill-extrusion-pattern").constantOr(1)) {
+                    var colorMode = painter.colorModeForRenderPass();
+                    drawExtrusionTiles(painter, source2, layer, coords, depthMode, StencilMode.disabled, colorMode);
+                  } else {
+                    drawExtrusionTiles(painter, source2, layer, coords, depthMode, StencilMode.disabled, ColorMode.disabled);
+                    drawExtrusionTiles(painter, source2, layer, coords, depthMode, painter.stencilModeFor3D(), painter.colorModeForRenderPass());
+                  }
+                }
+              }
+              function drawExtrusionTiles(painter, source2, layer, coords, depthMode, stencilMode, colorMode) {
+                var context = painter.context;
+                var gl2 = context.gl;
+                var patternProperty = layer.paint.get("fill-extrusion-pattern");
+                var image = patternProperty.constantOr(1);
+                var crossfade = layer.getCrossfadeParameters();
+                var opacity = layer.paint.get("fill-extrusion-opacity");
+                for (var i2 = 0, list = coords; i2 < list.length; i2 += 1) {
+                  var coord = list[i2];
+                  var tile = source2.getTile(coord);
+                  var bucket = tile.getBucket(layer);
+                  if (!bucket) {
+                    continue;
+                  }
+                  var programConfiguration = bucket.programConfigurations.get(layer.id);
+                  var program = painter.useProgram(image ? "fillExtrusionPattern" : "fillExtrusion", programConfiguration);
+                  if (image) {
+                    painter.context.activeTexture.set(gl2.TEXTURE0);
+                    tile.imageAtlasTexture.bind(gl2.LINEAR, gl2.CLAMP_TO_EDGE);
+                    programConfiguration.updatePaintBuffers(crossfade);
+                  }
+                  var constantPattern = patternProperty.constantOr(null);
+                  if (constantPattern && tile.imageAtlas) {
+                    var atlas = tile.imageAtlas;
+                    var posTo = atlas.patternPositions[constantPattern.to.toString()];
+                    var posFrom = atlas.patternPositions[constantPattern.from.toString()];
+                    if (posTo && posFrom) {
+                      programConfiguration.setConstantPatternPositions(posTo, posFrom);
+                    }
+                  }
+                  var matrix = painter.translatePosMatrix(coord.posMatrix, tile, layer.paint.get("fill-extrusion-translate"), layer.paint.get("fill-extrusion-translate-anchor"));
+                  var shouldUseVerticalGradient = layer.paint.get("fill-extrusion-vertical-gradient");
+                  var uniformValues = image ? fillExtrusionPatternUniformValues(matrix, painter, shouldUseVerticalGradient, opacity, coord, crossfade, tile) : fillExtrusionUniformValues(matrix, painter, shouldUseVerticalGradient, opacity);
+                  program.draw(context, context.gl.TRIANGLES, depthMode, stencilMode, colorMode, CullFaceMode.backCCW, uniformValues, layer.id, bucket.layoutVertexBuffer, bucket.indexBuffer, bucket.segments, layer.paint, painter.transform.zoom, programConfiguration);
+                }
+              }
+              function drawHillshade(painter, sourceCache, layer, tileIDs) {
+                if (painter.renderPass !== "offscreen" && painter.renderPass !== "translucent") {
+                  return;
+                }
+                var context = painter.context;
+                var depthMode = painter.depthModeForSublayer(0, DepthMode.ReadOnly);
+                var colorMode = painter.colorModeForRenderPass();
+                var ref = painter.renderPass === "translucent" ? painter.stencilConfigForOverlap(tileIDs) : [
+                  {},
+                  tileIDs
+                ];
+                var stencilModes = ref[0];
+                var coords = ref[1];
+                for (var i2 = 0, list = coords; i2 < list.length; i2 += 1) {
+                  var coord = list[i2];
+                  var tile = sourceCache.getTile(coord);
+                  if (tile.needsHillshadePrepare && painter.renderPass === "offscreen") {
+                    prepareHillshade(painter, tile, layer, depthMode, StencilMode.disabled, colorMode);
+                  } else if (painter.renderPass === "translucent") {
+                    renderHillshade(painter, tile, layer, depthMode, stencilModes[coord.overscaledZ], colorMode);
+                  }
+                }
+                context.viewport.set([
+                  0,
+                  0,
+                  painter.width,
+                  painter.height
+                ]);
+              }
+              function renderHillshade(painter, tile, layer, depthMode, stencilMode, colorMode) {
+                var context = painter.context;
+                var gl2 = context.gl;
+                var fbo = tile.fbo;
+                if (!fbo) {
+                  return;
+                }
+                var program = painter.useProgram("hillshade");
+                context.activeTexture.set(gl2.TEXTURE0);
+                gl2.bindTexture(gl2.TEXTURE_2D, fbo.colorAttachment.get());
+                var uniformValues = hillshadeUniformValues(painter, tile, layer);
+                program.draw(context, gl2.TRIANGLES, depthMode, stencilMode, colorMode, CullFaceMode.disabled, uniformValues, layer.id, painter.rasterBoundsBuffer, painter.quadTriangleIndexBuffer, painter.rasterBoundsSegments);
+              }
+              function prepareHillshade(painter, tile, layer, depthMode, stencilMode, colorMode) {
+                var context = painter.context;
+                var gl2 = context.gl;
+                var dem = tile.dem;
+                if (dem && dem.data) {
+                  var tileSize = dem.dim;
+                  var textureStride = dem.stride;
+                  var pixelData = dem.getPixels();
+                  context.activeTexture.set(gl2.TEXTURE1);
+                  context.pixelStoreUnpackPremultiplyAlpha.set(false);
+                  tile.demTexture = tile.demTexture || painter.getTileTexture(textureStride);
+                  if (tile.demTexture) {
+                    var demTexture = tile.demTexture;
+                    demTexture.update(pixelData, { premultiply: false });
+                    demTexture.bind(gl2.NEAREST, gl2.CLAMP_TO_EDGE);
+                  } else {
+                    tile.demTexture = new performance2.Texture(context, pixelData, gl2.RGBA, { premultiply: false });
+                    tile.demTexture.bind(gl2.NEAREST, gl2.CLAMP_TO_EDGE);
+                  }
+                  context.activeTexture.set(gl2.TEXTURE0);
+                  var fbo = tile.fbo;
+                  if (!fbo) {
+                    var renderTexture = new performance2.Texture(context, {
+                      width: tileSize,
+                      height: tileSize,
+                      data: null
+                    }, gl2.RGBA);
+                    renderTexture.bind(gl2.LINEAR, gl2.CLAMP_TO_EDGE);
+                    fbo = tile.fbo = context.createFramebuffer(tileSize, tileSize, true);
+                    fbo.colorAttachment.set(renderTexture.texture);
+                  }
+                  context.bindFramebuffer.set(fbo.framebuffer);
+                  context.viewport.set([
+                    0,
+                    0,
+                    tileSize,
+                    tileSize
+                  ]);
+                  painter.useProgram("hillshadePrepare").draw(context, gl2.TRIANGLES, depthMode, stencilMode, colorMode, CullFaceMode.disabled, hillshadeUniformPrepareValues(tile.tileID, dem), layer.id, painter.rasterBoundsBuffer, painter.quadTriangleIndexBuffer, painter.rasterBoundsSegments);
+                  tile.needsHillshadePrepare = false;
+                }
+              }
+              function drawRaster(painter, sourceCache, layer, tileIDs) {
+                if (painter.renderPass !== "translucent") {
+                  return;
+                }
+                if (layer.paint.get("raster-opacity") === 0) {
+                  return;
+                }
+                if (!tileIDs.length) {
+                  return;
+                }
+                var context = painter.context;
+                var gl2 = context.gl;
+                var source2 = sourceCache.getSource();
+                var program = painter.useProgram("raster");
+                var colorMode = painter.colorModeForRenderPass();
+                var ref = source2 instanceof ImageSource ? [
+                  {},
+                  tileIDs
+                ] : painter.stencilConfigForOverlap(tileIDs);
+                var stencilModes = ref[0];
+                var coords = ref[1];
+                var minTileZ = coords[coords.length - 1].overscaledZ;
+                var align = !painter.options.moving;
+                for (var i2 = 0, list = coords; i2 < list.length; i2 += 1) {
+                  var coord = list[i2];
+                  var depthMode = painter.depthModeForSublayer(coord.overscaledZ - minTileZ, layer.paint.get("raster-opacity") === 1 ? DepthMode.ReadWrite : DepthMode.ReadOnly, gl2.LESS);
+                  var tile = sourceCache.getTile(coord);
+                  var posMatrix = painter.transform.calculatePosMatrix(coord.toUnwrapped(), align);
+                  tile.registerFadeDuration(layer.paint.get("raster-fade-duration"));
+                  var parentTile = sourceCache.findLoadedParent(coord, 0), fade = getFadeValues(tile, parentTile, sourceCache, layer, painter.transform);
+                  var parentScaleBy = void 0, parentTL = void 0;
+                  var textureFilter = layer.paint.get("raster-resampling") === "nearest" ? gl2.NEAREST : gl2.LINEAR;
+                  context.activeTexture.set(gl2.TEXTURE0);
+                  tile.texture.bind(textureFilter, gl2.CLAMP_TO_EDGE, gl2.LINEAR_MIPMAP_NEAREST);
+                  context.activeTexture.set(gl2.TEXTURE1);
+                  if (parentTile) {
+                    parentTile.texture.bind(textureFilter, gl2.CLAMP_TO_EDGE, gl2.LINEAR_MIPMAP_NEAREST);
+                    parentScaleBy = Math.pow(2, parentTile.tileID.overscaledZ - tile.tileID.overscaledZ);
+                    parentTL = [
+                      tile.tileID.canonical.x * parentScaleBy % 1,
+                      tile.tileID.canonical.y * parentScaleBy % 1
+                    ];
+                  } else {
+                    tile.texture.bind(textureFilter, gl2.CLAMP_TO_EDGE, gl2.LINEAR_MIPMAP_NEAREST);
+                  }
+                  var uniformValues = rasterUniformValues(posMatrix, parentTL || [
+                    0,
+                    0
+                  ], parentScaleBy || 1, fade, layer);
+                  if (source2 instanceof ImageSource) {
+                    program.draw(context, gl2.TRIANGLES, depthMode, StencilMode.disabled, colorMode, CullFaceMode.disabled, uniformValues, layer.id, source2.boundsBuffer, painter.quadTriangleIndexBuffer, source2.boundsSegments);
+                  } else {
+                    program.draw(context, gl2.TRIANGLES, depthMode, stencilModes[coord.overscaledZ], colorMode, CullFaceMode.disabled, uniformValues, layer.id, painter.rasterBoundsBuffer, painter.quadTriangleIndexBuffer, painter.rasterBoundsSegments);
+                  }
+                }
+              }
+              function getFadeValues(tile, parentTile, sourceCache, layer, transform) {
+                var fadeDuration = layer.paint.get("raster-fade-duration");
+                if (fadeDuration > 0) {
+                  var now = performance2.browser.now();
+                  var sinceTile = (now - tile.timeAdded) / fadeDuration;
+                  var sinceParent = parentTile ? (now - parentTile.timeAdded) / fadeDuration : -1;
+                  var source2 = sourceCache.getSource();
+                  var idealZ = transform.coveringZoomLevel({
+                    tileSize: source2.tileSize,
+                    roundZoom: source2.roundZoom
+                  });
+                  var fadeIn = !parentTile || Math.abs(parentTile.tileID.overscaledZ - idealZ) > Math.abs(tile.tileID.overscaledZ - idealZ);
+                  var childOpacity = fadeIn && tile.refreshedUponExpiration ? 1 : performance2.clamp(fadeIn ? sinceTile : 1 - sinceParent, 0, 1);
+                  if (tile.refreshedUponExpiration && sinceTile >= 1) {
+                    tile.refreshedUponExpiration = false;
+                  }
+                  if (parentTile) {
+                    return {
+                      opacity: 1,
+                      mix: 1 - childOpacity
+                    };
+                  } else {
+                    return {
+                      opacity: childOpacity,
+                      mix: 0
+                    };
+                  }
+                } else {
+                  return {
+                    opacity: 1,
+                    mix: 0
+                  };
+                }
+              }
+              function drawBackground(painter, sourceCache, layer) {
+                var color22 = layer.paint.get("background-color");
+                var opacity = layer.paint.get("background-opacity");
+                if (opacity === 0) {
+                  return;
+                }
+                var context = painter.context;
+                var gl2 = context.gl;
+                var transform = painter.transform;
+                var tileSize = transform.tileSize;
+                var image = layer.paint.get("background-pattern");
+                if (painter.isPatternMissing(image)) {
+                  return;
+                }
+                var pass = !image && color22.a === 1 && opacity === 1 && painter.opaquePassEnabledForLayer() ? "opaque" : "translucent";
+                if (painter.renderPass !== pass) {
+                  return;
+                }
+                var stencilMode = StencilMode.disabled;
+                var depthMode = painter.depthModeForSublayer(0, pass === "opaque" ? DepthMode.ReadWrite : DepthMode.ReadOnly);
+                var colorMode = painter.colorModeForRenderPass();
+                var program = painter.useProgram(image ? "backgroundPattern" : "background");
+                var tileIDs = transform.coveringTiles({ tileSize });
+                if (image) {
+                  context.activeTexture.set(gl2.TEXTURE0);
+                  painter.imageManager.bind(painter.context);
+                }
+                var crossfade = layer.getCrossfadeParameters();
+                for (var i2 = 0, list = tileIDs; i2 < list.length; i2 += 1) {
+                  var tileID = list[i2];
+                  var matrix = painter.transform.calculatePosMatrix(tileID.toUnwrapped());
+                  var uniformValues = image ? backgroundPatternUniformValues(matrix, opacity, painter, image, {
+                    tileID,
+                    tileSize
+                  }, crossfade) : backgroundUniformValues(matrix, opacity, color22);
+                  program.draw(context, gl2.TRIANGLES, depthMode, stencilMode, colorMode, CullFaceMode.disabled, uniformValues, layer.id, painter.tileExtentBuffer, painter.quadTriangleIndexBuffer, painter.tileExtentSegments);
+                }
+              }
+              var topColor = new performance2.Color(1, 0, 0, 1);
+              var btmColor = new performance2.Color(0, 1, 0, 1);
+              var leftColor = new performance2.Color(0, 0, 1, 1);
+              var rightColor = new performance2.Color(1, 0, 1, 1);
+              var centerColor = new performance2.Color(0, 1, 1, 1);
+              function drawDebugPadding(painter) {
+                var padding2 = painter.transform.padding;
+                var lineWidth = 3;
+                drawHorizontalLine(painter, painter.transform.height - (padding2.top || 0), lineWidth, topColor);
+                drawHorizontalLine(painter, padding2.bottom || 0, lineWidth, btmColor);
+                drawVerticalLine(painter, padding2.left || 0, lineWidth, leftColor);
+                drawVerticalLine(painter, painter.transform.width - (padding2.right || 0), lineWidth, rightColor);
+                var center = painter.transform.centerPoint;
+                drawCrosshair(painter, center.x, painter.transform.height - center.y, centerColor);
+              }
+              function drawCrosshair(painter, x2, y2, color22) {
+                var size = 20;
+                var lineWidth = 2;
+                drawDebugSSRect(painter, x2 - lineWidth / 2, y2 - size / 2, lineWidth, size, color22);
+                drawDebugSSRect(painter, x2 - size / 2, y2 - lineWidth / 2, size, lineWidth, color22);
+              }
+              function drawHorizontalLine(painter, y2, lineWidth, color22) {
+                drawDebugSSRect(painter, 0, y2 + lineWidth / 2, painter.transform.width, lineWidth, color22);
+              }
+              function drawVerticalLine(painter, x2, lineWidth, color22) {
+                drawDebugSSRect(painter, x2 - lineWidth / 2, 0, lineWidth, painter.transform.height, color22);
+              }
+              function drawDebugSSRect(painter, x2, y2, width, height, color22) {
+                var context = painter.context;
+                var gl2 = context.gl;
+                gl2.enable(gl2.SCISSOR_TEST);
+                gl2.scissor(x2 * performance2.browser.devicePixelRatio, y2 * performance2.browser.devicePixelRatio, width * performance2.browser.devicePixelRatio, height * performance2.browser.devicePixelRatio);
+                context.clear({ color: color22 });
+                gl2.disable(gl2.SCISSOR_TEST);
+              }
+              function drawDebug(painter, sourceCache, coords) {
+                for (var i2 = 0; i2 < coords.length; i2++) {
+                  drawDebugTile(painter, sourceCache, coords[i2]);
+                }
+              }
+              function drawDebugTile(painter, sourceCache, coord) {
+                var context = painter.context;
+                var gl2 = context.gl;
+                var posMatrix = coord.posMatrix;
+                var program = painter.useProgram("debug");
+                var depthMode = DepthMode.disabled;
+                var stencilMode = StencilMode.disabled;
+                var colorMode = painter.colorModeForRenderPass();
+                var id2 = "$debug";
+                context.activeTexture.set(gl2.TEXTURE0);
+                painter.emptyTexture.bind(gl2.LINEAR, gl2.CLAMP_TO_EDGE);
+                program.draw(context, gl2.LINE_STRIP, depthMode, stencilMode, colorMode, CullFaceMode.disabled, debugUniformValues(posMatrix, performance2.Color.red), id2, painter.debugBuffer, painter.tileBorderIndexBuffer, painter.debugSegments);
+                var tileRawData = sourceCache.getTileByID(coord.key).latestRawTileData;
+                var tileByteLength = tileRawData && tileRawData.byteLength || 0;
+                var tileSizeKb = Math.floor(tileByteLength / 1024);
+                var tileSize = sourceCache.getTile(coord).tileSize;
+                var scaleRatio = 512 / Math.min(tileSize, 512) * (coord.overscaledZ / painter.transform.zoom) * 0.5;
+                var tileIdText = coord.canonical.toString();
+                if (coord.overscaledZ !== coord.canonical.z) {
+                  tileIdText += " => " + coord.overscaledZ;
+                }
+                var tileLabel = tileIdText + " " + tileSizeKb + "kb";
+                drawTextToOverlay(painter, tileLabel);
+                program.draw(context, gl2.TRIANGLES, depthMode, stencilMode, ColorMode.alphaBlended, CullFaceMode.disabled, debugUniformValues(posMatrix, performance2.Color.transparent, scaleRatio), id2, painter.debugBuffer, painter.quadTriangleIndexBuffer, painter.debugSegments);
+              }
+              function drawTextToOverlay(painter, text) {
+                painter.initDebugOverlayCanvas();
+                var canvas2 = painter.debugOverlayCanvas;
+                var gl2 = painter.context.gl;
+                var ctx2d = painter.debugOverlayCanvas.getContext("2d");
+                ctx2d.clearRect(0, 0, canvas2.width, canvas2.height);
+                ctx2d.shadowColor = "white";
+                ctx2d.shadowBlur = 2;
+                ctx2d.lineWidth = 1.5;
+                ctx2d.strokeStyle = "white";
+                ctx2d.textBaseline = "top";
+                ctx2d.font = "bold 36px Open Sans, sans-serif";
+                ctx2d.fillText(text, 5, 5);
+                ctx2d.strokeText(text, 5, 5);
+                painter.debugOverlayTexture.update(canvas2);
+                painter.debugOverlayTexture.bind(gl2.LINEAR, gl2.CLAMP_TO_EDGE);
+              }
+              function drawCustom(painter, sourceCache, layer) {
+                var context = painter.context;
+                var implementation = layer.implementation;
+                if (painter.renderPass === "offscreen") {
+                  var prerender = implementation.prerender;
+                  if (prerender) {
+                    painter.setCustomLayerDefaults();
+                    context.setColorMode(painter.colorModeForRenderPass());
+                    prerender.call(implementation, context.gl, painter.transform.customLayerMatrix());
+                    context.setDirty();
+                    painter.setBaseState();
+                  }
+                } else if (painter.renderPass === "translucent") {
+                  painter.setCustomLayerDefaults();
+                  context.setColorMode(painter.colorModeForRenderPass());
+                  context.setStencilMode(StencilMode.disabled);
+                  var depthMode = implementation.renderingMode === "3d" ? new DepthMode(painter.context.gl.LEQUAL, DepthMode.ReadWrite, painter.depthRangeFor3D) : painter.depthModeForSublayer(0, DepthMode.ReadOnly);
+                  context.setDepthMode(depthMode);
+                  implementation.render(context.gl, painter.transform.customLayerMatrix());
+                  context.setDirty();
+                  painter.setBaseState();
+                  context.bindFramebuffer.set(null);
+                }
+              }
+              var draw$1 = {
+                symbol: drawSymbols,
+                circle: drawCircles,
+                heatmap: drawHeatmap,
+                line: drawLine,
+                fill: drawFill,
+                "fill-extrusion": draw,
+                hillshade: drawHillshade,
+                raster: drawRaster,
+                background: drawBackground,
+                debug: drawDebug,
+                custom: drawCustom
+              };
+              var Painter = function Painter2(gl2, transform) {
+                this.context = new Context(gl2);
+                this.transform = transform;
+                this._tileTextures = {};
+                this.setup();
+                this.numSublayers = SourceCache.maxUnderzooming + SourceCache.maxOverzooming + 1;
+                this.depthEpsilon = 1 / Math.pow(2, 16);
+                this.crossTileSymbolIndex = new CrossTileSymbolIndex();
+                this.gpuTimers = {};
+              };
+              Painter.prototype.resize = function resize(width, height) {
+                this.width = width * performance2.browser.devicePixelRatio;
+                this.height = height * performance2.browser.devicePixelRatio;
+                this.context.viewport.set([
+                  0,
+                  0,
+                  this.width,
+                  this.height
+                ]);
+                if (this.style) {
+                  for (var i2 = 0, list = this.style._order; i2 < list.length; i2 += 1) {
+                    var layerId = list[i2];
+                    this.style._layers[layerId].resize();
+                  }
+                }
+              };
+              Painter.prototype.setup = function setup() {
+                var context = this.context;
+                var tileExtentArray = new performance2.StructArrayLayout2i4();
+                tileExtentArray.emplaceBack(0, 0);
+                tileExtentArray.emplaceBack(performance2.EXTENT, 0);
+                tileExtentArray.emplaceBack(0, performance2.EXTENT);
+                tileExtentArray.emplaceBack(performance2.EXTENT, performance2.EXTENT);
+                this.tileExtentBuffer = context.createVertexBuffer(tileExtentArray, posAttributes.members);
+                this.tileExtentSegments = performance2.SegmentVector.simpleSegment(0, 0, 4, 2);
+                var debugArray = new performance2.StructArrayLayout2i4();
+                debugArray.emplaceBack(0, 0);
+                debugArray.emplaceBack(performance2.EXTENT, 0);
+                debugArray.emplaceBack(0, performance2.EXTENT);
+                debugArray.emplaceBack(performance2.EXTENT, performance2.EXTENT);
+                this.debugBuffer = context.createVertexBuffer(debugArray, posAttributes.members);
+                this.debugSegments = performance2.SegmentVector.simpleSegment(0, 0, 4, 5);
+                var rasterBoundsArray = new performance2.StructArrayLayout4i8();
+                rasterBoundsArray.emplaceBack(0, 0, 0, 0);
+                rasterBoundsArray.emplaceBack(performance2.EXTENT, 0, performance2.EXTENT, 0);
+                rasterBoundsArray.emplaceBack(0, performance2.EXTENT, 0, performance2.EXTENT);
+                rasterBoundsArray.emplaceBack(performance2.EXTENT, performance2.EXTENT, performance2.EXTENT, performance2.EXTENT);
+                this.rasterBoundsBuffer = context.createVertexBuffer(rasterBoundsArray, rasterBoundsAttributes.members);
+                this.rasterBoundsSegments = performance2.SegmentVector.simpleSegment(0, 0, 4, 2);
+                var viewportArray = new performance2.StructArrayLayout2i4();
+                viewportArray.emplaceBack(0, 0);
+                viewportArray.emplaceBack(1, 0);
+                viewportArray.emplaceBack(0, 1);
+                viewportArray.emplaceBack(1, 1);
+                this.viewportBuffer = context.createVertexBuffer(viewportArray, posAttributes.members);
+                this.viewportSegments = performance2.SegmentVector.simpleSegment(0, 0, 4, 2);
+                var tileLineStripIndices = new performance2.StructArrayLayout1ui2();
+                tileLineStripIndices.emplaceBack(0);
+                tileLineStripIndices.emplaceBack(1);
+                tileLineStripIndices.emplaceBack(3);
+                tileLineStripIndices.emplaceBack(2);
+                tileLineStripIndices.emplaceBack(0);
+                this.tileBorderIndexBuffer = context.createIndexBuffer(tileLineStripIndices);
+                var quadTriangleIndices = new performance2.StructArrayLayout3ui6();
+                quadTriangleIndices.emplaceBack(0, 1, 2);
+                quadTriangleIndices.emplaceBack(2, 1, 3);
+                this.quadTriangleIndexBuffer = context.createIndexBuffer(quadTriangleIndices);
+                this.emptyTexture = new performance2.Texture(context, {
+                  width: 1,
+                  height: 1,
+                  data: new Uint8Array([
+                    0,
+                    0,
+                    0,
+                    0
+                  ])
+                }, context.gl.RGBA);
+                var gl2 = this.context.gl;
+                this.stencilClearMode = new StencilMode({
+                  func: gl2.ALWAYS,
+                  mask: 0
+                }, 0, 255, gl2.ZERO, gl2.ZERO, gl2.ZERO);
+              };
+              Painter.prototype.clearStencil = function clearStencil() {
+                var context = this.context;
+                var gl2 = context.gl;
+                this.nextStencilID = 1;
+                this.currentStencilSource = void 0;
+                var matrix = performance2.create();
+                performance2.ortho(matrix, 0, this.width, this.height, 0, 0, 1);
+                performance2.scale(matrix, matrix, [
+                  gl2.drawingBufferWidth,
+                  gl2.drawingBufferHeight,
+                  0
+                ]);
+                this.useProgram("clippingMask").draw(context, gl2.TRIANGLES, DepthMode.disabled, this.stencilClearMode, ColorMode.disabled, CullFaceMode.disabled, clippingMaskUniformValues(matrix), "$clipping", this.viewportBuffer, this.quadTriangleIndexBuffer, this.viewportSegments);
+              };
+              Painter.prototype._renderTileClippingMasks = function _renderTileClippingMasks(layer, tileIDs) {
+                if (this.currentStencilSource === layer.source || !layer.isTileClipped() || !tileIDs || !tileIDs.length) {
+                  return;
+                }
+                this.currentStencilSource = layer.source;
+                var context = this.context;
+                var gl2 = context.gl;
+                if (this.nextStencilID + tileIDs.length > 256) {
+                  this.clearStencil();
+                }
+                context.setColorMode(ColorMode.disabled);
+                context.setDepthMode(DepthMode.disabled);
+                var program = this.useProgram("clippingMask");
+                this._tileClippingMaskIDs = {};
+                for (var i2 = 0, list = tileIDs; i2 < list.length; i2 += 1) {
+                  var tileID = list[i2];
+                  var id2 = this._tileClippingMaskIDs[tileID.key] = this.nextStencilID++;
+                  program.draw(context, gl2.TRIANGLES, DepthMode.disabled, new StencilMode({
+                    func: gl2.ALWAYS,
+                    mask: 0
+                  }, id2, 255, gl2.KEEP, gl2.KEEP, gl2.REPLACE), ColorMode.disabled, CullFaceMode.disabled, clippingMaskUniformValues(tileID.posMatrix), "$clipping", this.tileExtentBuffer, this.quadTriangleIndexBuffer, this.tileExtentSegments);
+                }
+              };
+              Painter.prototype.stencilModeFor3D = function stencilModeFor3D() {
+                this.currentStencilSource = void 0;
+                if (this.nextStencilID + 1 > 256) {
+                  this.clearStencil();
+                }
+                var id2 = this.nextStencilID++;
+                var gl2 = this.context.gl;
+                return new StencilMode({
+                  func: gl2.NOTEQUAL,
+                  mask: 255
+                }, id2, 255, gl2.KEEP, gl2.KEEP, gl2.REPLACE);
+              };
+              Painter.prototype.stencilModeForClipping = function stencilModeForClipping(tileID) {
+                var gl2 = this.context.gl;
+                return new StencilMode({
+                  func: gl2.EQUAL,
+                  mask: 255
+                }, this._tileClippingMaskIDs[tileID.key], 0, gl2.KEEP, gl2.KEEP, gl2.REPLACE);
+              };
+              Painter.prototype.stencilConfigForOverlap = function stencilConfigForOverlap(tileIDs) {
+                var obj;
+                var gl2 = this.context.gl;
+                var coords = tileIDs.sort(function(a2, b2) {
+                  return b2.overscaledZ - a2.overscaledZ;
+                });
+                var minTileZ = coords[coords.length - 1].overscaledZ;
+                var stencilValues = coords[0].overscaledZ - minTileZ + 1;
+                if (stencilValues > 1) {
+                  this.currentStencilSource = void 0;
+                  if (this.nextStencilID + stencilValues > 256) {
+                    this.clearStencil();
+                  }
+                  var zToStencilMode = {};
+                  for (var i2 = 0; i2 < stencilValues; i2++) {
+                    zToStencilMode[i2 + minTileZ] = new StencilMode({
+                      func: gl2.GEQUAL,
+                      mask: 255
+                    }, i2 + this.nextStencilID, 255, gl2.KEEP, gl2.KEEP, gl2.REPLACE);
+                  }
+                  this.nextStencilID += stencilValues;
+                  return [
+                    zToStencilMode,
+                    coords
+                  ];
+                }
+                return [
+                  (obj = {}, obj[minTileZ] = StencilMode.disabled, obj),
+                  coords
+                ];
+              };
+              Painter.prototype.colorModeForRenderPass = function colorModeForRenderPass() {
+                var gl2 = this.context.gl;
+                if (this._showOverdrawInspector) {
+                  var numOverdrawSteps = 8;
+                  var a2 = 1 / numOverdrawSteps;
+                  return new ColorMode([
+                    gl2.CONSTANT_COLOR,
+                    gl2.ONE
+                  ], new performance2.Color(a2, a2, a2, 0), [
+                    true,
+                    true,
+                    true,
+                    true
+                  ]);
+                } else if (this.renderPass === "opaque") {
+                  return ColorMode.unblended;
+                } else {
+                  return ColorMode.alphaBlended;
+                }
+              };
+              Painter.prototype.depthModeForSublayer = function depthModeForSublayer(n2, mask, func) {
+                if (!this.opaquePassEnabledForLayer()) {
+                  return DepthMode.disabled;
+                }
+                var depth = 1 - ((1 + this.currentLayer) * this.numSublayers + n2) * this.depthEpsilon;
+                return new DepthMode(func || this.context.gl.LEQUAL, mask, [
+                  depth,
+                  depth
+                ]);
+              };
+              Painter.prototype.opaquePassEnabledForLayer = function opaquePassEnabledForLayer() {
+                return this.currentLayer < this.opaquePassCutoff;
+              };
+              Painter.prototype.render = function render(style, options) {
+                var this$1$1 = this;
+                this.style = style;
+                this.options = options;
+                this.lineAtlas = style.lineAtlas;
+                this.imageManager = style.imageManager;
+                this.glyphManager = style.glyphManager;
+                this.symbolFadeChange = style.placement.symbolFadeChange(performance2.browser.now());
+                this.imageManager.beginFrame();
+                var layerIds = this.style._order;
+                var sourceCaches = this.style.sourceCaches;
+                for (var id2 in sourceCaches) {
+                  var sourceCache = sourceCaches[id2];
+                  if (sourceCache.used) {
+                    sourceCache.prepare(this.context);
+                  }
+                }
+                var coordsAscending = {};
+                var coordsDescending = {};
+                var coordsDescendingSymbol = {};
+                for (var id$1 in sourceCaches) {
+                  var sourceCache$1 = sourceCaches[id$1];
+                  coordsAscending[id$1] = sourceCache$1.getVisibleCoordinates();
+                  coordsDescending[id$1] = coordsAscending[id$1].slice().reverse();
+                  coordsDescendingSymbol[id$1] = sourceCache$1.getVisibleCoordinates(true).reverse();
+                }
+                this.opaquePassCutoff = Infinity;
+                for (var i2 = 0; i2 < layerIds.length; i2++) {
+                  var layerId = layerIds[i2];
+                  if (this.style._layers[layerId].is3D()) {
+                    this.opaquePassCutoff = i2;
+                    break;
+                  }
+                }
+                this.renderPass = "offscreen";
+                for (var i$1 = 0, list = layerIds; i$1 < list.length; i$1 += 1) {
+                  var layerId$1 = list[i$1];
+                  var layer = this.style._layers[layerId$1];
+                  if (!layer.hasOffscreenPass() || layer.isHidden(this.transform.zoom)) {
+                    continue;
+                  }
+                  var coords = coordsDescending[layer.source];
+                  if (layer.type !== "custom" && !coords.length) {
+                    continue;
+                  }
+                  this.renderLayer(this, sourceCaches[layer.source], layer, coords);
+                }
+                this.context.bindFramebuffer.set(null);
+                this.context.clear({
+                  color: options.showOverdrawInspector ? performance2.Color.black : performance2.Color.transparent,
+                  depth: 1
+                });
+                this.clearStencil();
+                this._showOverdrawInspector = options.showOverdrawInspector;
+                this.depthRangeFor3D = [
+                  0,
+                  1 - (style._order.length + 2) * this.numSublayers * this.depthEpsilon
+                ];
+                this.renderPass = "opaque";
+                for (this.currentLayer = layerIds.length - 1; this.currentLayer >= 0; this.currentLayer--) {
+                  var layer$1 = this.style._layers[layerIds[this.currentLayer]];
+                  var sourceCache$2 = sourceCaches[layer$1.source];
+                  var coords$1 = coordsAscending[layer$1.source];
+                  this._renderTileClippingMasks(layer$1, coords$1);
+                  this.renderLayer(this, sourceCache$2, layer$1, coords$1);
+                }
+                this.renderPass = "translucent";
+                for (this.currentLayer = 0; this.currentLayer < layerIds.length; this.currentLayer++) {
+                  var layer$2 = this.style._layers[layerIds[this.currentLayer]];
+                  var sourceCache$3 = sourceCaches[layer$2.source];
+                  var coords$2 = (layer$2.type === "symbol" ? coordsDescendingSymbol : coordsDescending)[layer$2.source];
+                  this._renderTileClippingMasks(layer$2, coordsAscending[layer$2.source]);
+                  this.renderLayer(this, sourceCache$3, layer$2, coords$2);
+                }
+                if (this.options.showTileBoundaries) {
+                  var selectedSource;
+                  var sourceCache$4;
+                  var layers = performance2.values(this.style._layers);
+                  layers.forEach(function(layer2) {
+                    if (layer2.source && !layer2.isHidden(this$1$1.transform.zoom)) {
+                      if (layer2.source !== (sourceCache$4 && sourceCache$4.id)) {
+                        sourceCache$4 = this$1$1.style.sourceCaches[layer2.source];
+                      }
+                      if (!selectedSource || selectedSource.getSource().maxzoom < sourceCache$4.getSource().maxzoom) {
+                        selectedSource = sourceCache$4;
+                      }
+                    }
+                  });
+                  if (selectedSource) {
+                    draw$1.debug(this, selectedSource, selectedSource.getVisibleCoordinates());
+                  }
+                }
+                if (this.options.showPadding) {
+                  drawDebugPadding(this);
+                }
+                this.context.setDefault();
+              };
+              Painter.prototype.renderLayer = function renderLayer(painter, sourceCache, layer, coords) {
+                if (layer.isHidden(this.transform.zoom)) {
+                  return;
+                }
+                if (layer.type !== "background" && layer.type !== "custom" && !coords.length) {
+                  return;
+                }
+                this.id = layer.id;
+                this.gpuTimingStart(layer);
+                draw$1[layer.type](painter, sourceCache, layer, coords, this.style.placement.variableOffsets);
+                this.gpuTimingEnd();
+              };
+              Painter.prototype.gpuTimingStart = function gpuTimingStart(layer) {
+                if (!this.options.gpuTiming) {
+                  return;
+                }
+                var ext = this.context.extTimerQuery;
+                var layerTimer = this.gpuTimers[layer.id];
+                if (!layerTimer) {
+                  layerTimer = this.gpuTimers[layer.id] = {
+                    calls: 0,
+                    cpuTime: 0,
+                    query: ext.createQueryEXT()
+                  };
+                }
+                layerTimer.calls++;
+                ext.beginQueryEXT(ext.TIME_ELAPSED_EXT, layerTimer.query);
+              };
+              Painter.prototype.gpuTimingEnd = function gpuTimingEnd() {
+                if (!this.options.gpuTiming) {
+                  return;
+                }
+                var ext = this.context.extTimerQuery;
+                ext.endQueryEXT(ext.TIME_ELAPSED_EXT);
+              };
+              Painter.prototype.collectGpuTimers = function collectGpuTimers() {
+                var currentLayerTimers = this.gpuTimers;
+                this.gpuTimers = {};
+                return currentLayerTimers;
+              };
+              Painter.prototype.queryGpuTimers = function queryGpuTimers(gpuTimers) {
+                var layers = {};
+                for (var layerId in gpuTimers) {
+                  var gpuTimer = gpuTimers[layerId];
+                  var ext = this.context.extTimerQuery;
+                  var gpuTime = ext.getQueryObjectEXT(gpuTimer.query, ext.QUERY_RESULT_EXT) / (1e3 * 1e3);
+                  ext.deleteQueryEXT(gpuTimer.query);
+                  layers[layerId] = gpuTime;
+                }
+                return layers;
+              };
+              Painter.prototype.translatePosMatrix = function translatePosMatrix(matrix, tile, translate2, translateAnchor, inViewportPixelUnitsUnits) {
+                if (!translate2[0] && !translate2[1]) {
+                  return matrix;
+                }
+                var angle2 = inViewportPixelUnitsUnits ? translateAnchor === "map" ? this.transform.angle : 0 : translateAnchor === "viewport" ? -this.transform.angle : 0;
+                if (angle2) {
+                  var sinA = Math.sin(angle2);
+                  var cosA = Math.cos(angle2);
+                  translate2 = [
+                    translate2[0] * cosA - translate2[1] * sinA,
+                    translate2[0] * sinA + translate2[1] * cosA
+                  ];
+                }
+                var translation = [
+                  inViewportPixelUnitsUnits ? translate2[0] : pixelsToTileUnits(tile, translate2[0], this.transform.zoom),
+                  inViewportPixelUnitsUnits ? translate2[1] : pixelsToTileUnits(tile, translate2[1], this.transform.zoom),
+                  0
+                ];
+                var translatedMatrix = new Float32Array(16);
+                performance2.translate(translatedMatrix, matrix, translation);
+                return translatedMatrix;
+              };
+              Painter.prototype.saveTileTexture = function saveTileTexture(texture) {
+                var textures = this._tileTextures[texture.size[0]];
+                if (!textures) {
+                  this._tileTextures[texture.size[0]] = [texture];
+                } else {
+                  textures.push(texture);
+                }
+              };
+              Painter.prototype.getTileTexture = function getTileTexture(size) {
+                var textures = this._tileTextures[size];
+                return textures && textures.length > 0 ? textures.pop() : null;
+              };
+              Painter.prototype.isPatternMissing = function isPatternMissing(image) {
+                if (!image) {
+                  return false;
+                }
+                if (!image.from || !image.to) {
+                  return true;
+                }
+                var imagePosA = this.imageManager.getPattern(image.from.toString());
+                var imagePosB = this.imageManager.getPattern(image.to.toString());
+                return !imagePosA || !imagePosB;
+              };
+              Painter.prototype.useProgram = function useProgram(name2, programConfiguration) {
+                this.cache = this.cache || {};
+                var key = "" + name2 + (programConfiguration ? programConfiguration.cacheKey : "") + (this._showOverdrawInspector ? "/overdraw" : "");
+                if (!this.cache[key]) {
+                  this.cache[key] = new Program$1(this.context, name2, shaders[name2], programConfiguration, programUniforms[name2], this._showOverdrawInspector);
+                }
+                return this.cache[key];
+              };
+              Painter.prototype.setCustomLayerDefaults = function setCustomLayerDefaults() {
+                this.context.unbindVAO();
+                this.context.cullFace.setDefault();
+                this.context.activeTexture.setDefault();
+                this.context.pixelStoreUnpack.setDefault();
+                this.context.pixelStoreUnpackPremultiplyAlpha.setDefault();
+                this.context.pixelStoreUnpackFlipY.setDefault();
+              };
+              Painter.prototype.setBaseState = function setBaseState() {
+                var gl2 = this.context.gl;
+                this.context.cullFace.set(false);
+                this.context.viewport.set([
+                  0,
+                  0,
+                  this.width,
+                  this.height
+                ]);
+                this.context.blendEquation.set(gl2.FUNC_ADD);
+              };
+              Painter.prototype.initDebugOverlayCanvas = function initDebugOverlayCanvas() {
+                if (this.debugOverlayCanvas == null) {
+                  this.debugOverlayCanvas = performance2.window.document.createElement("canvas");
+                  this.debugOverlayCanvas.width = 512;
+                  this.debugOverlayCanvas.height = 512;
+                  var gl2 = this.context.gl;
+                  this.debugOverlayTexture = new performance2.Texture(this.context, this.debugOverlayCanvas, gl2.RGBA);
+                }
+              };
+              Painter.prototype.destroy = function destroy() {
+                this.emptyTexture.destroy();
+                if (this.debugOverlayTexture) {
+                  this.debugOverlayTexture.destroy();
+                }
+              };
+              var Frustum = function Frustum2(points_, planes_) {
+                this.points = points_;
+                this.planes = planes_;
+              };
+              Frustum.fromInvProjectionMatrix = function fromInvProjectionMatrix(invProj, worldSize, zoom) {
+                var clipSpaceCorners = [
+                  [
+                    -1,
+                    1,
+                    -1,
+                    1
+                  ],
+                  [
+                    1,
+                    1,
+                    -1,
+                    1
+                  ],
+                  [
+                    1,
+                    -1,
+                    -1,
+                    1
+                  ],
+                  [
+                    -1,
+                    -1,
+                    -1,
+                    1
+                  ],
+                  [
+                    -1,
+                    1,
+                    1,
+                    1
+                  ],
+                  [
+                    1,
+                    1,
+                    1,
+                    1
+                  ],
+                  [
+                    1,
+                    -1,
+                    1,
+                    1
+                  ],
+                  [
+                    -1,
+                    -1,
+                    1,
+                    1
+                  ]
+                ];
+                var scale2 = Math.pow(2, zoom);
+                var frustumCoords = clipSpaceCorners.map(function(v2) {
+                  return performance2.transformMat4([], v2, invProj);
+                }).map(function(v2) {
+                  return performance2.scale$1([], v2, 1 / v2[3] / worldSize * scale2);
+                });
+                var frustumPlanePointIndices = [
+                  [
+                    0,
+                    1,
+                    2
+                  ],
+                  [
+                    6,
+                    5,
+                    4
+                  ],
+                  [
+                    0,
+                    3,
+                    7
+                  ],
+                  [
+                    2,
+                    1,
+                    5
+                  ],
+                  [
+                    3,
+                    2,
+                    6
+                  ],
+                  [
+                    0,
+                    4,
+                    5
+                  ]
+                ];
+                var frustumPlanes = frustumPlanePointIndices.map(function(p2) {
+                  var a2 = performance2.sub([], frustumCoords[p2[0]], frustumCoords[p2[1]]);
+                  var b2 = performance2.sub([], frustumCoords[p2[2]], frustumCoords[p2[1]]);
+                  var n2 = performance2.normalize([], performance2.cross([], a2, b2));
+                  var d2 = -performance2.dot(n2, frustumCoords[p2[1]]);
+                  return n2.concat(d2);
+                });
+                return new Frustum(frustumCoords, frustumPlanes);
+              };
+              var Aabb = function Aabb2(min_, max_) {
+                this.min = min_;
+                this.max = max_;
+                this.center = performance2.scale$2([], performance2.add([], this.min, this.max), 0.5);
+              };
+              Aabb.prototype.quadrant = function quadrant(index) {
+                var split = [
+                  index % 2 === 0,
+                  index < 2
+                ];
+                var qMin = performance2.clone$2(this.min);
+                var qMax = performance2.clone$2(this.max);
+                for (var axis = 0; axis < split.length; axis++) {
+                  qMin[axis] = split[axis] ? this.min[axis] : this.center[axis];
+                  qMax[axis] = split[axis] ? this.center[axis] : this.max[axis];
+                }
+                qMax[2] = this.max[2];
+                return new Aabb(qMin, qMax);
+              };
+              Aabb.prototype.distanceX = function distanceX(point) {
+                var pointOnAabb = Math.max(Math.min(this.max[0], point[0]), this.min[0]);
+                return pointOnAabb - point[0];
+              };
+              Aabb.prototype.distanceY = function distanceY(point) {
+                var pointOnAabb = Math.max(Math.min(this.max[1], point[1]), this.min[1]);
+                return pointOnAabb - point[1];
+              };
+              Aabb.prototype.intersects = function intersects(frustum2) {
+                var aabbPoints = [
+                  [
+                    this.min[0],
+                    this.min[1],
+                    0,
+                    1
+                  ],
+                  [
+                    this.max[0],
+                    this.min[1],
+                    0,
+                    1
+                  ],
+                  [
+                    this.max[0],
+                    this.max[1],
+                    0,
+                    1
+                  ],
+                  [
+                    this.min[0],
+                    this.max[1],
+                    0,
+                    1
+                  ]
+                ];
+                var fullyInside = true;
+                for (var p2 = 0; p2 < frustum2.planes.length; p2++) {
+                  var plane = frustum2.planes[p2];
+                  var pointsInside = 0;
+                  for (var i2 = 0; i2 < aabbPoints.length; i2++) {
+                    pointsInside += performance2.dot$1(plane, aabbPoints[i2]) >= 0;
+                  }
+                  if (pointsInside === 0) {
+                    return 0;
+                  }
+                  if (pointsInside !== aabbPoints.length) {
+                    fullyInside = false;
+                  }
+                }
+                if (fullyInside) {
+                  return 2;
+                }
+                for (var axis = 0; axis < 3; axis++) {
+                  var projMin = Number.MAX_VALUE;
+                  var projMax = -Number.MAX_VALUE;
+                  for (var p$12 = 0; p$12 < frustum2.points.length; p$12++) {
+                    var projectedPoint = frustum2.points[p$12][axis] - this.min[axis];
+                    projMin = Math.min(projMin, projectedPoint);
+                    projMax = Math.max(projMax, projectedPoint);
+                  }
+                  if (projMax < 0 || projMin > this.max[axis] - this.min[axis]) {
+                    return 0;
+                  }
+                }
+                return 1;
+              };
+              var EdgeInsets = function EdgeInsets2(top, bottom, left, right) {
+                if (top === void 0)
+                  top = 0;
+                if (bottom === void 0)
+                  bottom = 0;
+                if (left === void 0)
+                  left = 0;
+                if (right === void 0)
+                  right = 0;
+                if (isNaN(top) || top < 0 || isNaN(bottom) || bottom < 0 || isNaN(left) || left < 0 || isNaN(right) || right < 0) {
+                  throw new Error("Invalid value for edge-insets, top, bottom, left and right must all be numbers");
+                }
+                this.top = top;
+                this.bottom = bottom;
+                this.left = left;
+                this.right = right;
+              };
+              EdgeInsets.prototype.interpolate = function interpolate(start, target, t4) {
+                if (target.top != null && start.top != null) {
+                  this.top = performance2.number(start.top, target.top, t4);
+                }
+                if (target.bottom != null && start.bottom != null) {
+                  this.bottom = performance2.number(start.bottom, target.bottom, t4);
+                }
+                if (target.left != null && start.left != null) {
+                  this.left = performance2.number(start.left, target.left, t4);
+                }
+                if (target.right != null && start.right != null) {
+                  this.right = performance2.number(start.right, target.right, t4);
+                }
+                return this;
+              };
+              EdgeInsets.prototype.getCenter = function getCenter2(width, height) {
+                var x2 = performance2.clamp((this.left + width - this.right) / 2, 0, width);
+                var y2 = performance2.clamp((this.top + height - this.bottom) / 2, 0, height);
+                return new performance2.Point(x2, y2);
+              };
+              EdgeInsets.prototype.equals = function equals2(other) {
+                return this.top === other.top && this.bottom === other.bottom && this.left === other.left && this.right === other.right;
+              };
+              EdgeInsets.prototype.clone = function clone() {
+                return new EdgeInsets(this.top, this.bottom, this.left, this.right);
+              };
+              EdgeInsets.prototype.toJSON = function toJSON() {
+                return {
+                  top: this.top,
+                  bottom: this.bottom,
+                  left: this.left,
+                  right: this.right
+                };
+              };
+              var Transform = function Transform2(minZoom, maxZoom, minPitch, maxPitch, renderWorldCopies) {
+                this.tileSize = 512;
+                this.maxValidLatitude = 85.051129;
+                this._renderWorldCopies = renderWorldCopies === void 0 ? true : renderWorldCopies;
+                this._minZoom = minZoom || 0;
+                this._maxZoom = maxZoom || 22;
+                this._minPitch = minPitch === void 0 || minPitch === null ? 0 : minPitch;
+                this._maxPitch = maxPitch === void 0 || maxPitch === null ? 60 : maxPitch;
+                this.setMaxBounds();
+                this.width = 0;
+                this.height = 0;
+                this._center = new performance2.LngLat(0, 0);
+                this.zoom = 0;
+                this.angle = 0;
+                this._fov = 0.6435011087932844;
+                this._pitch = 0;
+                this._unmodified = true;
+                this._edgeInsets = new EdgeInsets();
+                this._posMatrixCache = {};
+                this._alignedPosMatrixCache = {};
+              };
+              var prototypeAccessors = {
+                minZoom: { configurable: true },
+                maxZoom: { configurable: true },
+                minPitch: { configurable: true },
+                maxPitch: { configurable: true },
+                renderWorldCopies: { configurable: true },
+                worldSize: { configurable: true },
+                centerOffset: { configurable: true },
+                size: { configurable: true },
+                bearing: { configurable: true },
+                pitch: { configurable: true },
+                fov: { configurable: true },
+                zoom: { configurable: true },
+                center: { configurable: true },
+                padding: { configurable: true },
+                centerPoint: { configurable: true },
+                unmodified: { configurable: true },
+                point: { configurable: true }
+              };
+              Transform.prototype.clone = function clone() {
+                var clone2 = new Transform(this._minZoom, this._maxZoom, this._minPitch, this.maxPitch, this._renderWorldCopies);
+                clone2.tileSize = this.tileSize;
+                clone2.latRange = this.latRange;
+                clone2.width = this.width;
+                clone2.height = this.height;
+                clone2._center = this._center;
+                clone2.zoom = this.zoom;
+                clone2.angle = this.angle;
+                clone2._fov = this._fov;
+                clone2._pitch = this._pitch;
+                clone2._unmodified = this._unmodified;
+                clone2._edgeInsets = this._edgeInsets.clone();
+                clone2._calcMatrices();
+                return clone2;
+              };
+              prototypeAccessors.minZoom.get = function() {
+                return this._minZoom;
+              };
+              prototypeAccessors.minZoom.set = function(zoom) {
+                if (this._minZoom === zoom) {
+                  return;
+                }
+                this._minZoom = zoom;
+                this.zoom = Math.max(this.zoom, zoom);
+              };
+              prototypeAccessors.maxZoom.get = function() {
+                return this._maxZoom;
+              };
+              prototypeAccessors.maxZoom.set = function(zoom) {
+                if (this._maxZoom === zoom) {
+                  return;
+                }
+                this._maxZoom = zoom;
+                this.zoom = Math.min(this.zoom, zoom);
+              };
+              prototypeAccessors.minPitch.get = function() {
+                return this._minPitch;
+              };
+              prototypeAccessors.minPitch.set = function(pitch) {
+                if (this._minPitch === pitch) {
+                  return;
+                }
+                this._minPitch = pitch;
+                this.pitch = Math.max(this.pitch, pitch);
+              };
+              prototypeAccessors.maxPitch.get = function() {
+                return this._maxPitch;
+              };
+              prototypeAccessors.maxPitch.set = function(pitch) {
+                if (this._maxPitch === pitch) {
+                  return;
+                }
+                this._maxPitch = pitch;
+                this.pitch = Math.min(this.pitch, pitch);
+              };
+              prototypeAccessors.renderWorldCopies.get = function() {
+                return this._renderWorldCopies;
+              };
+              prototypeAccessors.renderWorldCopies.set = function(renderWorldCopies) {
+                if (renderWorldCopies === void 0) {
+                  renderWorldCopies = true;
+                } else if (renderWorldCopies === null) {
+                  renderWorldCopies = false;
+                }
+                this._renderWorldCopies = renderWorldCopies;
+              };
+              prototypeAccessors.worldSize.get = function() {
+                return this.tileSize * this.scale;
+              };
+              prototypeAccessors.centerOffset.get = function() {
+                return this.centerPoint._sub(this.size._div(2));
+              };
+              prototypeAccessors.size.get = function() {
+                return new performance2.Point(this.width, this.height);
+              };
+              prototypeAccessors.bearing.get = function() {
+                return -this.angle / Math.PI * 180;
+              };
+              prototypeAccessors.bearing.set = function(bearing) {
+                var b2 = -performance2.wrap(bearing, -180, 180) * Math.PI / 180;
+                if (this.angle === b2) {
+                  return;
+                }
+                this._unmodified = false;
+                this.angle = b2;
+                this._calcMatrices();
+                this.rotationMatrix = performance2.create$2();
+                performance2.rotate(this.rotationMatrix, this.rotationMatrix, this.angle);
+              };
+              prototypeAccessors.pitch.get = function() {
+                return this._pitch / Math.PI * 180;
+              };
+              prototypeAccessors.pitch.set = function(pitch) {
+                var p2 = performance2.clamp(pitch, this.minPitch, this.maxPitch) / 180 * Math.PI;
+                if (this._pitch === p2) {
+                  return;
+                }
+                this._unmodified = false;
+                this._pitch = p2;
+                this._calcMatrices();
+              };
+              prototypeAccessors.fov.get = function() {
+                return this._fov / Math.PI * 180;
+              };
+              prototypeAccessors.fov.set = function(fov) {
+                fov = Math.max(0.01, Math.min(60, fov));
+                if (this._fov === fov) {
+                  return;
+                }
+                this._unmodified = false;
+                this._fov = fov / 180 * Math.PI;
+                this._calcMatrices();
+              };
+              prototypeAccessors.zoom.get = function() {
+                return this._zoom;
+              };
+              prototypeAccessors.zoom.set = function(zoom) {
+                var z2 = Math.min(Math.max(zoom, this.minZoom), this.maxZoom);
+                if (this._zoom === z2) {
+                  return;
+                }
+                this._unmodified = false;
+                this._zoom = z2;
+                this.scale = this.zoomScale(z2);
+                this.tileZoom = Math.floor(z2);
+                this.zoomFraction = z2 - this.tileZoom;
+                this._constrain();
+                this._calcMatrices();
+              };
+              prototypeAccessors.center.get = function() {
+                return this._center;
+              };
+              prototypeAccessors.center.set = function(center) {
+                if (center.lat === this._center.lat && center.lng === this._center.lng) {
+                  return;
+                }
+                this._unmodified = false;
+                this._center = center;
+                this._constrain();
+                this._calcMatrices();
+              };
+              prototypeAccessors.padding.get = function() {
+                return this._edgeInsets.toJSON();
+              };
+              prototypeAccessors.padding.set = function(padding2) {
+                if (this._edgeInsets.equals(padding2)) {
+                  return;
+                }
+                this._unmodified = false;
+                this._edgeInsets.interpolate(this._edgeInsets, padding2, 1);
+                this._calcMatrices();
+              };
+              prototypeAccessors.centerPoint.get = function() {
+                return this._edgeInsets.getCenter(this.width, this.height);
+              };
+              Transform.prototype.isPaddingEqual = function isPaddingEqual(padding2) {
+                return this._edgeInsets.equals(padding2);
+              };
+              Transform.prototype.interpolatePadding = function interpolatePadding(start, target, t4) {
+                this._unmodified = false;
+                this._edgeInsets.interpolate(start, target, t4);
+                this._constrain();
+                this._calcMatrices();
+              };
+              Transform.prototype.coveringZoomLevel = function coveringZoomLevel(options) {
+                var z2 = (options.roundZoom ? Math.round : Math.floor)(this.zoom + this.scaleZoom(this.tileSize / options.tileSize));
+                return Math.max(0, z2);
+              };
+              Transform.prototype.getVisibleUnwrappedCoordinates = function getVisibleUnwrappedCoordinates(tileID) {
+                var result = [new performance2.UnwrappedTileID(0, tileID)];
+                if (this._renderWorldCopies) {
+                  var utl = this.pointCoordinate(new performance2.Point(0, 0));
+                  var utr = this.pointCoordinate(new performance2.Point(this.width, 0));
+                  var ubl = this.pointCoordinate(new performance2.Point(this.width, this.height));
+                  var ubr = this.pointCoordinate(new performance2.Point(0, this.height));
+                  var w0 = Math.floor(Math.min(utl.x, utr.x, ubl.x, ubr.x));
+                  var w1 = Math.floor(Math.max(utl.x, utr.x, ubl.x, ubr.x));
+                  var extraWorldCopy = 1;
+                  for (var w2 = w0 - extraWorldCopy; w2 <= w1 + extraWorldCopy; w2++) {
+                    if (w2 === 0) {
+                      continue;
+                    }
+                    result.push(new performance2.UnwrappedTileID(w2, tileID));
+                  }
+                }
+                return result;
+              };
+              Transform.prototype.coveringTiles = function coveringTiles(options) {
+                var z2 = this.coveringZoomLevel(options);
+                var actualZ = z2;
+                if (options.minzoom !== void 0 && z2 < options.minzoom) {
+                  return [];
+                }
+                if (options.maxzoom !== void 0 && z2 > options.maxzoom) {
+                  z2 = options.maxzoom;
+                }
+                var centerCoord = performance2.MercatorCoordinate.fromLngLat(this.center);
+                var numTiles = Math.pow(2, z2);
+                var centerPoint = [
+                  numTiles * centerCoord.x,
+                  numTiles * centerCoord.y,
+                  0
+                ];
+                var cameraFrustum = Frustum.fromInvProjectionMatrix(this.invProjMatrix, this.worldSize, z2);
+                var minZoom = options.minzoom || 0;
+                if (this.pitch <= 60 && this._edgeInsets.top < 0.1) {
+                  minZoom = z2;
+                }
+                var radiusOfMaxLvlLodInTiles = 3;
+                var newRootTile = function(wrap) {
+                  return {
+                    aabb: new Aabb([
+                      wrap * numTiles,
+                      0,
+                      0
+                    ], [
+                      (wrap + 1) * numTiles,
+                      numTiles,
+                      0
+                    ]),
+                    zoom: 0,
+                    x: 0,
+                    y: 0,
+                    wrap,
+                    fullyVisible: false
+                  };
+                };
+                var stack = [];
+                var result = [];
+                var maxZoom = z2;
+                var overscaledZ = options.reparseOverscaled ? actualZ : z2;
+                if (this._renderWorldCopies) {
+                  for (var i2 = 1; i2 <= 3; i2++) {
+                    stack.push(newRootTile(-i2));
+                    stack.push(newRootTile(i2));
+                  }
+                }
+                stack.push(newRootTile(0));
+                while (stack.length > 0) {
+                  var it2 = stack.pop();
+                  var x2 = it2.x;
+                  var y2 = it2.y;
+                  var fullyVisible = it2.fullyVisible;
+                  if (!fullyVisible) {
+                    var intersectResult = it2.aabb.intersects(cameraFrustum);
+                    if (intersectResult === 0) {
+                      continue;
+                    }
+                    fullyVisible = intersectResult === 2;
+                  }
+                  var distanceX = it2.aabb.distanceX(centerPoint);
+                  var distanceY = it2.aabb.distanceY(centerPoint);
+                  var longestDim = Math.max(Math.abs(distanceX), Math.abs(distanceY));
+                  var distToSplit = radiusOfMaxLvlLodInTiles + (1 << maxZoom - it2.zoom) - 2;
+                  if (it2.zoom === maxZoom || longestDim > distToSplit && it2.zoom >= minZoom) {
+                    result.push({
+                      tileID: new performance2.OverscaledTileID(it2.zoom === maxZoom ? overscaledZ : it2.zoom, it2.wrap, it2.zoom, x2, y2),
+                      distanceSq: performance2.sqrLen([
+                        centerPoint[0] - 0.5 - x2,
+                        centerPoint[1] - 0.5 - y2
+                      ])
+                    });
+                    continue;
+                  }
+                  for (var i$1 = 0; i$1 < 4; i$1++) {
+                    var childX = (x2 << 1) + i$1 % 2;
+                    var childY = (y2 << 1) + (i$1 >> 1);
+                    stack.push({
+                      aabb: it2.aabb.quadrant(i$1),
+                      zoom: it2.zoom + 1,
+                      x: childX,
+                      y: childY,
+                      wrap: it2.wrap,
+                      fullyVisible
+                    });
+                  }
+                }
+                return result.sort(function(a2, b2) {
+                  return a2.distanceSq - b2.distanceSq;
+                }).map(function(a2) {
+                  return a2.tileID;
+                });
+              };
+              Transform.prototype.resize = function resize(width, height) {
+                this.width = width;
+                this.height = height;
+                this.pixelsToGLUnits = [
+                  2 / width,
+                  -2 / height
+                ];
+                this._constrain();
+                this._calcMatrices();
+              };
+              prototypeAccessors.unmodified.get = function() {
+                return this._unmodified;
+              };
+              Transform.prototype.zoomScale = function zoomScale(zoom) {
+                return Math.pow(2, zoom);
+              };
+              Transform.prototype.scaleZoom = function scaleZoom(scale2) {
+                return Math.log(scale2) / Math.LN2;
+              };
+              Transform.prototype.project = function project22(lnglat) {
+                var lat = performance2.clamp(lnglat.lat, -this.maxValidLatitude, this.maxValidLatitude);
+                return new performance2.Point(performance2.mercatorXfromLng(lnglat.lng) * this.worldSize, performance2.mercatorYfromLat(lat) * this.worldSize);
+              };
+              Transform.prototype.unproject = function unproject(point) {
+                return new performance2.MercatorCoordinate(point.x / this.worldSize, point.y / this.worldSize).toLngLat();
+              };
+              prototypeAccessors.point.get = function() {
+                return this.project(this.center);
+              };
+              Transform.prototype.setLocationAtPoint = function setLocationAtPoint(lnglat, point) {
+                var a2 = this.pointCoordinate(point);
+                var b2 = this.pointCoordinate(this.centerPoint);
+                var loc = this.locationCoordinate(lnglat);
+                var newCenter = new performance2.MercatorCoordinate(loc.x - (a2.x - b2.x), loc.y - (a2.y - b2.y));
+                this.center = this.coordinateLocation(newCenter);
+                if (this._renderWorldCopies) {
+                  this.center = this.center.wrap();
+                }
+              };
+              Transform.prototype.locationPoint = function locationPoint(lnglat) {
+                return this.coordinatePoint(this.locationCoordinate(lnglat));
+              };
+              Transform.prototype.pointLocation = function pointLocation(p2) {
+                return this.coordinateLocation(this.pointCoordinate(p2));
+              };
+              Transform.prototype.locationCoordinate = function locationCoordinate(lnglat) {
+                return performance2.MercatorCoordinate.fromLngLat(lnglat);
+              };
+              Transform.prototype.coordinateLocation = function coordinateLocation(coord) {
+                return coord.toLngLat();
+              };
+              Transform.prototype.pointCoordinate = function pointCoordinate(p2) {
+                var targetZ = 0;
+                var coord0 = [
+                  p2.x,
+                  p2.y,
+                  0,
+                  1
+                ];
+                var coord1 = [
+                  p2.x,
+                  p2.y,
+                  1,
+                  1
+                ];
+                performance2.transformMat4(coord0, coord0, this.pixelMatrixInverse);
+                performance2.transformMat4(coord1, coord1, this.pixelMatrixInverse);
+                var w0 = coord0[3];
+                var w1 = coord1[3];
+                var x0 = coord0[0] / w0;
+                var x1 = coord1[0] / w1;
+                var y0 = coord0[1] / w0;
+                var y1 = coord1[1] / w1;
+                var z0 = coord0[2] / w0;
+                var z1 = coord1[2] / w1;
+                var t4 = z0 === z1 ? 0 : (targetZ - z0) / (z1 - z0);
+                return new performance2.MercatorCoordinate(performance2.number(x0, x1, t4) / this.worldSize, performance2.number(y0, y1, t4) / this.worldSize);
+              };
+              Transform.prototype.coordinatePoint = function coordinatePoint(coord) {
+                var p2 = [
+                  coord.x * this.worldSize,
+                  coord.y * this.worldSize,
+                  0,
+                  1
+                ];
+                performance2.transformMat4(p2, p2, this.pixelMatrix);
+                return new performance2.Point(p2[0] / p2[3], p2[1] / p2[3]);
+              };
+              Transform.prototype.getBounds = function getBounds2() {
+                return new performance2.LngLatBounds().extend(this.pointLocation(new performance2.Point(0, 0))).extend(this.pointLocation(new performance2.Point(this.width, 0))).extend(this.pointLocation(new performance2.Point(this.width, this.height))).extend(this.pointLocation(new performance2.Point(0, this.height)));
+              };
+              Transform.prototype.getMaxBounds = function getMaxBounds() {
+                if (!this.latRange || this.latRange.length !== 2 || !this.lngRange || this.lngRange.length !== 2) {
+                  return null;
+                }
+                return new performance2.LngLatBounds([
+                  this.lngRange[0],
+                  this.latRange[0]
+                ], [
+                  this.lngRange[1],
+                  this.latRange[1]
+                ]);
+              };
+              Transform.prototype.setMaxBounds = function setMaxBounds(bounds) {
+                if (bounds) {
+                  this.lngRange = [
+                    bounds.getWest(),
+                    bounds.getEast()
+                  ];
+                  this.latRange = [
+                    bounds.getSouth(),
+                    bounds.getNorth()
+                  ];
+                  this._constrain();
+                } else {
+                  this.lngRange = null;
+                  this.latRange = [
+                    -this.maxValidLatitude,
+                    this.maxValidLatitude
+                  ];
+                }
+              };
+              Transform.prototype.calculatePosMatrix = function calculatePosMatrix(unwrappedTileID, aligned) {
+                if (aligned === void 0)
+                  aligned = false;
+                var posMatrixKey = unwrappedTileID.key;
+                var cache = aligned ? this._alignedPosMatrixCache : this._posMatrixCache;
+                if (cache[posMatrixKey]) {
+                  return cache[posMatrixKey];
+                }
+                var canonical = unwrappedTileID.canonical;
+                var scale2 = this.worldSize / this.zoomScale(canonical.z);
+                var unwrappedX = canonical.x + Math.pow(2, canonical.z) * unwrappedTileID.wrap;
+                var posMatrix = performance2.identity(new Float64Array(16));
+                performance2.translate(posMatrix, posMatrix, [
+                  unwrappedX * scale2,
+                  canonical.y * scale2,
+                  0
+                ]);
+                performance2.scale(posMatrix, posMatrix, [
+                  scale2 / performance2.EXTENT,
+                  scale2 / performance2.EXTENT,
+                  1
+                ]);
+                performance2.multiply(posMatrix, aligned ? this.alignedProjMatrix : this.projMatrix, posMatrix);
+                cache[posMatrixKey] = new Float32Array(posMatrix);
+                return cache[posMatrixKey];
+              };
+              Transform.prototype.customLayerMatrix = function customLayerMatrix() {
+                return this.mercatorMatrix.slice();
+              };
+              Transform.prototype._constrain = function _constrain() {
+                if (!this.center || !this.width || !this.height || this._constraining) {
+                  return;
+                }
+                this._constraining = true;
+                var minY = -90;
+                var maxY = 90;
+                var minX = -180;
+                var maxX = 180;
+                var sy, sx, x2, y2;
+                var size = this.size, unmodified = this._unmodified;
+                if (this.latRange) {
+                  var latRange = this.latRange;
+                  minY = performance2.mercatorYfromLat(latRange[1]) * this.worldSize;
+                  maxY = performance2.mercatorYfromLat(latRange[0]) * this.worldSize;
+                  sy = maxY - minY < size.y ? size.y / (maxY - minY) : 0;
+                }
+                if (this.lngRange) {
+                  var lngRange = this.lngRange;
+                  minX = performance2.mercatorXfromLng(lngRange[0]) * this.worldSize;
+                  maxX = performance2.mercatorXfromLng(lngRange[1]) * this.worldSize;
+                  sx = maxX - minX < size.x ? size.x / (maxX - minX) : 0;
+                }
+                var point = this.point;
+                var s2 = Math.max(sx || 0, sy || 0);
+                if (s2) {
+                  this.center = this.unproject(new performance2.Point(sx ? (maxX + minX) / 2 : point.x, sy ? (maxY + minY) / 2 : point.y));
+                  this.zoom += this.scaleZoom(s2);
+                  this._unmodified = unmodified;
+                  this._constraining = false;
+                  return;
+                }
+                if (this.latRange) {
+                  var y3 = point.y, h2 = size.y / 2;
+                  if (y3 - h2 < minY) {
+                    y2 = minY + h2;
+                  }
+                  if (y3 + h2 > maxY) {
+                    y2 = maxY - h2;
+                  }
+                }
+                if (this.lngRange) {
+                  var x3 = point.x, w2 = size.x / 2;
+                  if (x3 - w2 < minX) {
+                    x2 = minX + w2;
+                  }
+                  if (x3 + w2 > maxX) {
+                    x2 = maxX - w2;
+                  }
+                }
+                if (x2 !== void 0 || y2 !== void 0) {
+                  this.center = this.unproject(new performance2.Point(x2 !== void 0 ? x2 : point.x, y2 !== void 0 ? y2 : point.y));
+                }
+                this._unmodified = unmodified;
+                this._constraining = false;
+              };
+              Transform.prototype._calcMatrices = function _calcMatrices() {
+                if (!this.height) {
+                  return;
+                }
+                var halfFov = this._fov / 2;
+                var offset = this.centerOffset;
+                this.cameraToCenterDistance = 0.5 / Math.tan(halfFov) * this.height;
+                var groundAngle = Math.PI / 2 + this._pitch;
+                var fovAboveCenter = this._fov * (0.5 + offset.y / this.height);
+                var topHalfSurfaceDistance = Math.sin(fovAboveCenter) * this.cameraToCenterDistance / Math.sin(performance2.clamp(Math.PI - groundAngle - fovAboveCenter, 0.01, Math.PI - 0.01));
+                var point = this.point;
+                var x2 = point.x, y2 = point.y;
+                var furthestDistance = Math.cos(Math.PI / 2 - this._pitch) * topHalfSurfaceDistance + this.cameraToCenterDistance;
+                var farZ = furthestDistance * 1.01;
+                var nearZ = this.height / 50;
+                var m2 = new Float64Array(16);
+                performance2.perspective(m2, this._fov, this.width / this.height, nearZ, farZ);
+                m2[8] = -offset.x * 2 / this.width;
+                m2[9] = offset.y * 2 / this.height;
+                performance2.scale(m2, m2, [
+                  1,
+                  -1,
+                  1
+                ]);
+                performance2.translate(m2, m2, [
+                  0,
+                  0,
+                  -this.cameraToCenterDistance
+                ]);
+                performance2.rotateX(m2, m2, this._pitch);
+                performance2.rotateZ(m2, m2, this.angle);
+                performance2.translate(m2, m2, [
+                  -x2,
+                  -y2,
+                  0
+                ]);
+                this.mercatorMatrix = performance2.scale([], m2, [
+                  this.worldSize,
+                  this.worldSize,
+                  this.worldSize
+                ]);
+                performance2.scale(m2, m2, [
+                  1,
+                  1,
+                  performance2.mercatorZfromAltitude(1, this.center.lat) * this.worldSize,
+                  1
+                ]);
+                this.projMatrix = m2;
+                this.invProjMatrix = performance2.invert([], this.projMatrix);
+                var xShift = this.width % 2 / 2, yShift = this.height % 2 / 2, angleCos = Math.cos(this.angle), angleSin = Math.sin(this.angle), dx = x2 - Math.round(x2) + angleCos * xShift + angleSin * yShift, dy = y2 - Math.round(y2) + angleCos * yShift + angleSin * xShift;
+                var alignedM = new Float64Array(m2);
+                performance2.translate(alignedM, alignedM, [
+                  dx > 0.5 ? dx - 1 : dx,
+                  dy > 0.5 ? dy - 1 : dy,
+                  0
+                ]);
+                this.alignedProjMatrix = alignedM;
+                m2 = performance2.create();
+                performance2.scale(m2, m2, [
+                  this.width / 2,
+                  -this.height / 2,
+                  1
+                ]);
+                performance2.translate(m2, m2, [
+                  1,
+                  -1,
+                  0
+                ]);
+                this.labelPlaneMatrix = m2;
+                m2 = performance2.create();
+                performance2.scale(m2, m2, [
+                  1,
+                  -1,
+                  1
+                ]);
+                performance2.translate(m2, m2, [
+                  -1,
+                  -1,
+                  0
+                ]);
+                performance2.scale(m2, m2, [
+                  2 / this.width,
+                  2 / this.height,
+                  1
+                ]);
+                this.glCoordMatrix = m2;
+                this.pixelMatrix = performance2.multiply(new Float64Array(16), this.labelPlaneMatrix, this.projMatrix);
+                m2 = performance2.invert(new Float64Array(16), this.pixelMatrix);
+                if (!m2) {
+                  throw new Error("failed to invert matrix");
+                }
+                this.pixelMatrixInverse = m2;
+                this._posMatrixCache = {};
+                this._alignedPosMatrixCache = {};
+              };
+              Transform.prototype.maxPitchScaleFactor = function maxPitchScaleFactor() {
+                if (!this.pixelMatrixInverse) {
+                  return 1;
+                }
+                var coord = this.pointCoordinate(new performance2.Point(0, 0));
+                var p2 = [
+                  coord.x * this.worldSize,
+                  coord.y * this.worldSize,
+                  0,
+                  1
+                ];
+                var topPoint = performance2.transformMat4(p2, p2, this.pixelMatrix);
+                return topPoint[3] / this.cameraToCenterDistance;
+              };
+              Transform.prototype.getCameraPoint = function getCameraPoint() {
+                var pitch = this._pitch;
+                var yOffset = Math.tan(pitch) * (this.cameraToCenterDistance || 1);
+                return this.centerPoint.add(new performance2.Point(0, yOffset));
+              };
+              Transform.prototype.getCameraQueryGeometry = function getCameraQueryGeometry(queryGeometry) {
+                var c2 = this.getCameraPoint();
+                if (queryGeometry.length === 1) {
+                  return [
+                    queryGeometry[0],
+                    c2
+                  ];
+                } else {
+                  var minX = c2.x;
+                  var minY = c2.y;
+                  var maxX = c2.x;
+                  var maxY = c2.y;
+                  for (var i2 = 0, list = queryGeometry; i2 < list.length; i2 += 1) {
+                    var p2 = list[i2];
+                    minX = Math.min(minX, p2.x);
+                    minY = Math.min(minY, p2.y);
+                    maxX = Math.max(maxX, p2.x);
+                    maxY = Math.max(maxY, p2.y);
+                  }
+                  return [
+                    new performance2.Point(minX, minY),
+                    new performance2.Point(maxX, minY),
+                    new performance2.Point(maxX, maxY),
+                    new performance2.Point(minX, maxY),
+                    new performance2.Point(minX, minY)
+                  ];
+                }
+              };
+              Object.defineProperties(Transform.prototype, prototypeAccessors);
+              function throttle(fn, time) {
+                var pending = false;
+                var timerId = null;
+                var later = function() {
+                  timerId = null;
+                  if (pending) {
+                    fn();
+                    timerId = setTimeout(later, time);
+                    pending = false;
+                  }
+                };
+                return function() {
+                  pending = true;
+                  if (!timerId) {
+                    later();
+                  }
+                  return timerId;
+                };
+              }
+              var Hash = function Hash2(hashName) {
+                this._hashName = hashName && encodeURIComponent(hashName);
+                performance2.bindAll([
+                  "_getCurrentHash",
+                  "_onHashChange",
+                  "_updateHash"
+                ], this);
+                this._updateHash = throttle(this._updateHashUnthrottled.bind(this), 30 * 1e3 / 100);
+              };
+              Hash.prototype.addTo = function addTo(map2) {
+                this._map = map2;
+                performance2.window.addEventListener("hashchange", this._onHashChange, false);
+                this._map.on("moveend", this._updateHash);
+                return this;
+              };
+              Hash.prototype.remove = function remove() {
+                performance2.window.removeEventListener("hashchange", this._onHashChange, false);
+                this._map.off("moveend", this._updateHash);
+                clearTimeout(this._updateHash());
+                delete this._map;
+                return this;
+              };
+              Hash.prototype.getHashString = function getHashString(mapFeedback) {
+                var center = this._map.getCenter(), zoom = Math.round(this._map.getZoom() * 100) / 100, precision = Math.ceil((zoom * Math.LN2 + Math.log(512 / 360 / 0.5)) / Math.LN10), m2 = Math.pow(10, precision), lng = Math.round(center.lng * m2) / m2, lat = Math.round(center.lat * m2) / m2, bearing = this._map.getBearing(), pitch = this._map.getPitch();
+                var hash = "";
+                if (mapFeedback) {
+                  hash += "/" + lng + "/" + lat + "/" + zoom;
+                } else {
+                  hash += zoom + "/" + lat + "/" + lng;
+                }
+                if (bearing || pitch) {
+                  hash += "/" + Math.round(bearing * 10) / 10;
+                }
+                if (pitch) {
+                  hash += "/" + Math.round(pitch);
+                }
+                if (this._hashName) {
+                  var hashName = this._hashName;
+                  var found = false;
+                  var parts = performance2.window.location.hash.slice(1).split("&").map(function(part) {
+                    var key = part.split("=")[0];
+                    if (key === hashName) {
+                      found = true;
+                      return key + "=" + hash;
+                    }
+                    return part;
+                  }).filter(function(a2) {
+                    return a2;
+                  });
+                  if (!found) {
+                    parts.push(hashName + "=" + hash);
+                  }
+                  return "#" + parts.join("&");
+                }
+                return "#" + hash;
+              };
+              Hash.prototype._getCurrentHash = function _getCurrentHash() {
+                var this$1$1 = this;
+                var hash = performance2.window.location.hash.replace("#", "");
+                if (this._hashName) {
+                  var keyval;
+                  hash.split("&").map(function(part) {
+                    return part.split("=");
+                  }).forEach(function(part) {
+                    if (part[0] === this$1$1._hashName) {
+                      keyval = part;
+                    }
+                  });
+                  return (keyval ? keyval[1] || "" : "").split("/");
+                }
+                return hash.split("/");
+              };
+              Hash.prototype._onHashChange = function _onHashChange() {
+                var loc = this._getCurrentHash();
+                if (loc.length >= 3 && !loc.some(function(v2) {
+                  return isNaN(v2);
+                })) {
+                  var bearing = this._map.dragRotate.isEnabled() && this._map.touchZoomRotate.isEnabled() ? +(loc[3] || 0) : this._map.getBearing();
+                  this._map.jumpTo({
+                    center: [
+                      +loc[2],
+                      +loc[1]
+                    ],
+                    zoom: +loc[0],
+                    bearing,
+                    pitch: +(loc[4] || 0)
+                  });
+                  return true;
+                }
+                return false;
+              };
+              Hash.prototype._updateHashUnthrottled = function _updateHashUnthrottled() {
+                var location2 = performance2.window.location.href.replace(/(#.+)?$/, this.getHashString());
+                try {
+                  performance2.window.history.replaceState(performance2.window.history.state, null, location2);
+                } catch (SecurityError) {
+                }
+              };
+              var defaultInertiaOptions = {
+                linearity: 0.3,
+                easing: performance2.bezier(0, 0, 0.3, 1)
+              };
+              var defaultPanInertiaOptions = performance2.extend({
+                deceleration: 2500,
+                maxSpeed: 1400
+              }, defaultInertiaOptions);
+              var defaultZoomInertiaOptions = performance2.extend({
+                deceleration: 20,
+                maxSpeed: 1400
+              }, defaultInertiaOptions);
+              var defaultBearingInertiaOptions = performance2.extend({
+                deceleration: 1e3,
+                maxSpeed: 360
+              }, defaultInertiaOptions);
+              var defaultPitchInertiaOptions = performance2.extend({
+                deceleration: 1e3,
+                maxSpeed: 90
+              }, defaultInertiaOptions);
+              var HandlerInertia = function HandlerInertia2(map2) {
+                this._map = map2;
+                this.clear();
+              };
+              HandlerInertia.prototype.clear = function clear() {
+                this._inertiaBuffer = [];
+              };
+              HandlerInertia.prototype.record = function record(settings) {
+                this._drainInertiaBuffer();
+                this._inertiaBuffer.push({
+                  time: performance2.browser.now(),
+                  settings
+                });
+              };
+              HandlerInertia.prototype._drainInertiaBuffer = function _drainInertiaBuffer() {
+                var inertia = this._inertiaBuffer, now = performance2.browser.now(), cutoff = 160;
+                while (inertia.length > 0 && now - inertia[0].time > cutoff) {
+                  inertia.shift();
+                }
+              };
+              HandlerInertia.prototype._onMoveEnd = function _onMoveEnd(panInertiaOptions) {
+                this._drainInertiaBuffer();
+                if (this._inertiaBuffer.length < 2) {
+                  return;
+                }
+                var deltas = {
+                  zoom: 0,
+                  bearing: 0,
+                  pitch: 0,
+                  pan: new performance2.Point(0, 0),
+                  pinchAround: void 0,
+                  around: void 0
+                };
+                for (var i2 = 0, list = this._inertiaBuffer; i2 < list.length; i2 += 1) {
+                  var ref = list[i2];
+                  var settings = ref.settings;
+                  deltas.zoom += settings.zoomDelta || 0;
+                  deltas.bearing += settings.bearingDelta || 0;
+                  deltas.pitch += settings.pitchDelta || 0;
+                  if (settings.panDelta) {
+                    deltas.pan._add(settings.panDelta);
+                  }
+                  if (settings.around) {
+                    deltas.around = settings.around;
+                  }
+                  if (settings.pinchAround) {
+                    deltas.pinchAround = settings.pinchAround;
+                  }
+                }
+                var lastEntry = this._inertiaBuffer[this._inertiaBuffer.length - 1];
+                var duration = lastEntry.time - this._inertiaBuffer[0].time;
+                var easeOptions = {};
+                if (deltas.pan.mag()) {
+                  var result = calculateEasing(deltas.pan.mag(), duration, performance2.extend({}, defaultPanInertiaOptions, panInertiaOptions || {}));
+                  easeOptions.offset = deltas.pan.mult(result.amount / deltas.pan.mag());
+                  easeOptions.center = this._map.transform.center;
+                  extendDuration(easeOptions, result);
+                }
+                if (deltas.zoom) {
+                  var result$1 = calculateEasing(deltas.zoom, duration, defaultZoomInertiaOptions);
+                  easeOptions.zoom = this._map.transform.zoom + result$1.amount;
+                  extendDuration(easeOptions, result$1);
+                }
+                if (deltas.bearing) {
+                  var result$2 = calculateEasing(deltas.bearing, duration, defaultBearingInertiaOptions);
+                  easeOptions.bearing = this._map.transform.bearing + performance2.clamp(result$2.amount, -179, 179);
+                  extendDuration(easeOptions, result$2);
+                }
+                if (deltas.pitch) {
+                  var result$3 = calculateEasing(deltas.pitch, duration, defaultPitchInertiaOptions);
+                  easeOptions.pitch = this._map.transform.pitch + result$3.amount;
+                  extendDuration(easeOptions, result$3);
+                }
+                if (easeOptions.zoom || easeOptions.bearing) {
+                  var last = deltas.pinchAround === void 0 ? deltas.around : deltas.pinchAround;
+                  easeOptions.around = last ? this._map.unproject(last) : this._map.getCenter();
+                }
+                this.clear();
+                return performance2.extend(easeOptions, { noMoveStart: true });
+              };
+              function extendDuration(easeOptions, result) {
+                if (!easeOptions.duration || easeOptions.duration < result.duration) {
+                  easeOptions.duration = result.duration;
+                  easeOptions.easing = result.easing;
+                }
+              }
+              function calculateEasing(amount, inertiaDuration, inertiaOptions) {
+                var maxSpeed = inertiaOptions.maxSpeed;
+                var linearity = inertiaOptions.linearity;
+                var deceleration = inertiaOptions.deceleration;
+                var speed = performance2.clamp(amount * linearity / (inertiaDuration / 1e3), -maxSpeed, maxSpeed);
+                var duration = Math.abs(speed) / (deceleration * linearity);
+                return {
+                  easing: inertiaOptions.easing,
+                  duration: duration * 1e3,
+                  amount: speed * (duration / 2)
+                };
+              }
+              var MapMouseEvent = function(Event2) {
+                function MapMouseEvent2(type, map2, originalEvent, data) {
+                  if (data === void 0)
+                    data = {};
+                  var point = DOM.mousePos(map2.getCanvasContainer(), originalEvent);
+                  var lngLat = map2.unproject(point);
+                  Event2.call(this, type, performance2.extend({
+                    point,
+                    lngLat,
+                    originalEvent
+                  }, data));
+                  this._defaultPrevented = false;
+                  this.target = map2;
+                }
+                if (Event2)
+                  MapMouseEvent2.__proto__ = Event2;
+                MapMouseEvent2.prototype = Object.create(Event2 && Event2.prototype);
+                MapMouseEvent2.prototype.constructor = MapMouseEvent2;
+                var prototypeAccessors2 = { defaultPrevented: { configurable: true } };
+                MapMouseEvent2.prototype.preventDefault = function preventDefault() {
+                  this._defaultPrevented = true;
+                };
+                prototypeAccessors2.defaultPrevented.get = function() {
+                  return this._defaultPrevented;
+                };
+                Object.defineProperties(MapMouseEvent2.prototype, prototypeAccessors2);
+                return MapMouseEvent2;
+              }(performance2.Event);
+              var MapTouchEvent = function(Event2) {
+                function MapTouchEvent2(type, map2, originalEvent) {
+                  var touches = type === "touchend" ? originalEvent.changedTouches : originalEvent.touches;
+                  var points = DOM.touchPos(map2.getCanvasContainer(), touches);
+                  var lngLats = points.map(function(t4) {
+                    return map2.unproject(t4);
+                  });
+                  var point = points.reduce(function(prev, curr, i2, arr) {
+                    return prev.add(curr.div(arr.length));
+                  }, new performance2.Point(0, 0));
+                  var lngLat = map2.unproject(point);
+                  Event2.call(this, type, {
+                    points,
+                    point,
+                    lngLats,
+                    lngLat,
+                    originalEvent
+                  });
+                  this._defaultPrevented = false;
+                }
+                if (Event2)
+                  MapTouchEvent2.__proto__ = Event2;
+                MapTouchEvent2.prototype = Object.create(Event2 && Event2.prototype);
+                MapTouchEvent2.prototype.constructor = MapTouchEvent2;
+                var prototypeAccessors$1 = { defaultPrevented: { configurable: true } };
+                MapTouchEvent2.prototype.preventDefault = function preventDefault() {
+                  this._defaultPrevented = true;
+                };
+                prototypeAccessors$1.defaultPrevented.get = function() {
+                  return this._defaultPrevented;
+                };
+                Object.defineProperties(MapTouchEvent2.prototype, prototypeAccessors$1);
+                return MapTouchEvent2;
+              }(performance2.Event);
+              var MapWheelEvent = function(Event2) {
+                function MapWheelEvent2(type, map2, originalEvent) {
+                  Event2.call(this, type, { originalEvent });
+                  this._defaultPrevented = false;
+                }
+                if (Event2)
+                  MapWheelEvent2.__proto__ = Event2;
+                MapWheelEvent2.prototype = Object.create(Event2 && Event2.prototype);
+                MapWheelEvent2.prototype.constructor = MapWheelEvent2;
+                var prototypeAccessors$2 = { defaultPrevented: { configurable: true } };
+                MapWheelEvent2.prototype.preventDefault = function preventDefault() {
+                  this._defaultPrevented = true;
+                };
+                prototypeAccessors$2.defaultPrevented.get = function() {
+                  return this._defaultPrevented;
+                };
+                Object.defineProperties(MapWheelEvent2.prototype, prototypeAccessors$2);
+                return MapWheelEvent2;
+              }(performance2.Event);
+              var MapEventHandler = function MapEventHandler2(map2, options) {
+                this._map = map2;
+                this._clickTolerance = options.clickTolerance;
+              };
+              MapEventHandler.prototype.reset = function reset() {
+                delete this._mousedownPos;
+              };
+              MapEventHandler.prototype.wheel = function wheel(e2) {
+                return this._firePreventable(new MapWheelEvent(e2.type, this._map, e2));
+              };
+              MapEventHandler.prototype.mousedown = function mousedown(e2, point) {
+                this._mousedownPos = point;
+                return this._firePreventable(new MapMouseEvent(e2.type, this._map, e2));
+              };
+              MapEventHandler.prototype.mouseup = function mouseup(e2) {
+                this._map.fire(new MapMouseEvent(e2.type, this._map, e2));
+              };
+              MapEventHandler.prototype.click = function click(e2, point) {
+                if (this._mousedownPos && this._mousedownPos.dist(point) >= this._clickTolerance) {
+                  return;
+                }
+                this._map.fire(new MapMouseEvent(e2.type, this._map, e2));
+              };
+              MapEventHandler.prototype.dblclick = function dblclick(e2) {
+                return this._firePreventable(new MapMouseEvent(e2.type, this._map, e2));
+              };
+              MapEventHandler.prototype.mouseover = function mouseover(e2) {
+                this._map.fire(new MapMouseEvent(e2.type, this._map, e2));
+              };
+              MapEventHandler.prototype.mouseout = function mouseout(e2) {
+                this._map.fire(new MapMouseEvent(e2.type, this._map, e2));
+              };
+              MapEventHandler.prototype.touchstart = function touchstart(e2) {
+                return this._firePreventable(new MapTouchEvent(e2.type, this._map, e2));
+              };
+              MapEventHandler.prototype.touchmove = function touchmove(e2) {
+                this._map.fire(new MapTouchEvent(e2.type, this._map, e2));
+              };
+              MapEventHandler.prototype.touchend = function touchend(e2) {
+                this._map.fire(new MapTouchEvent(e2.type, this._map, e2));
+              };
+              MapEventHandler.prototype.touchcancel = function touchcancel(e2) {
+                this._map.fire(new MapTouchEvent(e2.type, this._map, e2));
+              };
+              MapEventHandler.prototype._firePreventable = function _firePreventable(mapEvent) {
+                this._map.fire(mapEvent);
+                if (mapEvent.defaultPrevented) {
+                  return {};
+                }
+              };
+              MapEventHandler.prototype.isEnabled = function isEnabled2() {
+                return true;
+              };
+              MapEventHandler.prototype.isActive = function isActive() {
+                return false;
+              };
+              MapEventHandler.prototype.enable = function enable2() {
+              };
+              MapEventHandler.prototype.disable = function disable() {
+              };
+              var BlockableMapEventHandler = function BlockableMapEventHandler2(map2) {
+                this._map = map2;
+              };
+              BlockableMapEventHandler.prototype.reset = function reset() {
+                this._delayContextMenu = false;
+                delete this._contextMenuEvent;
+              };
+              BlockableMapEventHandler.prototype.mousemove = function mousemove(e2) {
+                this._map.fire(new MapMouseEvent(e2.type, this._map, e2));
+              };
+              BlockableMapEventHandler.prototype.mousedown = function mousedown() {
+                this._delayContextMenu = true;
+              };
+              BlockableMapEventHandler.prototype.mouseup = function mouseup() {
+                this._delayContextMenu = false;
+                if (this._contextMenuEvent) {
+                  this._map.fire(new MapMouseEvent("contextmenu", this._map, this._contextMenuEvent));
+                  delete this._contextMenuEvent;
+                }
+              };
+              BlockableMapEventHandler.prototype.contextmenu = function contextmenu(e2) {
+                if (this._delayContextMenu) {
+                  this._contextMenuEvent = e2;
+                } else {
+                  this._map.fire(new MapMouseEvent(e2.type, this._map, e2));
+                }
+                if (this._map.listens("contextmenu")) {
+                  e2.preventDefault();
+                }
+              };
+              BlockableMapEventHandler.prototype.isEnabled = function isEnabled2() {
+                return true;
+              };
+              BlockableMapEventHandler.prototype.isActive = function isActive() {
+                return false;
+              };
+              BlockableMapEventHandler.prototype.enable = function enable2() {
+              };
+              BlockableMapEventHandler.prototype.disable = function disable() {
+              };
+              var BoxZoomHandler = function BoxZoomHandler2(map2, options) {
+                this._map = map2;
+                this._el = map2.getCanvasContainer();
+                this._container = map2.getContainer();
+                this._clickTolerance = options.clickTolerance || 1;
+              };
+              BoxZoomHandler.prototype.isEnabled = function isEnabled2() {
+                return !!this._enabled;
+              };
+              BoxZoomHandler.prototype.isActive = function isActive() {
+                return !!this._active;
+              };
+              BoxZoomHandler.prototype.enable = function enable2() {
+                if (this.isEnabled()) {
+                  return;
+                }
+                this._enabled = true;
+              };
+              BoxZoomHandler.prototype.disable = function disable() {
+                if (!this.isEnabled()) {
+                  return;
+                }
+                this._enabled = false;
+              };
+              BoxZoomHandler.prototype.mousedown = function mousedown(e2, point) {
+                if (!this.isEnabled()) {
+                  return;
+                }
+                if (!(e2.shiftKey && e2.button === 0)) {
+                  return;
+                }
+                DOM.disableDrag();
+                this._startPos = this._lastPos = point;
+                this._active = true;
+              };
+              BoxZoomHandler.prototype.mousemoveWindow = function mousemoveWindow(e2, point) {
+                if (!this._active) {
+                  return;
+                }
+                var pos = point;
+                if (this._lastPos.equals(pos) || !this._box && pos.dist(this._startPos) < this._clickTolerance) {
+                  return;
+                }
+                var p0 = this._startPos;
+                this._lastPos = pos;
+                if (!this._box) {
+                  this._box = DOM.create("div", "mapboxgl-boxzoom", this._container);
+                  this._container.classList.add("mapboxgl-crosshair");
+                  this._fireEvent("boxzoomstart", e2);
+                }
+                var minX = Math.min(p0.x, pos.x), maxX = Math.max(p0.x, pos.x), minY = Math.min(p0.y, pos.y), maxY = Math.max(p0.y, pos.y);
+                DOM.setTransform(this._box, "translate(" + minX + "px," + minY + "px)");
+                this._box.style.width = maxX - minX + "px";
+                this._box.style.height = maxY - minY + "px";
+              };
+              BoxZoomHandler.prototype.mouseupWindow = function mouseupWindow(e2, point) {
+                var this$1$1 = this;
+                if (!this._active) {
+                  return;
+                }
+                if (e2.button !== 0) {
+                  return;
+                }
+                var p0 = this._startPos, p1 = point;
+                this.reset();
+                DOM.suppressClick();
+                if (p0.x === p1.x && p0.y === p1.y) {
+                  this._fireEvent("boxzoomcancel", e2);
+                } else {
+                  this._map.fire(new performance2.Event("boxzoomend", { originalEvent: e2 }));
+                  return {
+                    cameraAnimation: function(map2) {
+                      return map2.fitScreenCoordinates(p0, p1, this$1$1._map.getBearing(), { linear: true });
+                    }
+                  };
+                }
+              };
+              BoxZoomHandler.prototype.keydown = function keydown(e2) {
+                if (!this._active) {
+                  return;
+                }
+                if (e2.keyCode === 27) {
+                  this.reset();
+                  this._fireEvent("boxzoomcancel", e2);
+                }
+              };
+              BoxZoomHandler.prototype.reset = function reset() {
+                this._active = false;
+                this._container.classList.remove("mapboxgl-crosshair");
+                if (this._box) {
+                  DOM.remove(this._box);
+                  this._box = null;
+                }
+                DOM.enableDrag();
+                delete this._startPos;
+                delete this._lastPos;
+              };
+              BoxZoomHandler.prototype._fireEvent = function _fireEvent(type, e2) {
+                return this._map.fire(new performance2.Event(type, { originalEvent: e2 }));
+              };
+              function indexTouches(touches, points) {
+                var obj = {};
+                for (var i2 = 0; i2 < touches.length; i2++) {
+                  obj[touches[i2].identifier] = points[i2];
+                }
+                return obj;
+              }
+              function getCentroid(points) {
+                var sum = new performance2.Point(0, 0);
+                for (var i2 = 0, list = points; i2 < list.length; i2 += 1) {
+                  var point = list[i2];
+                  sum._add(point);
+                }
+                return sum.div(points.length);
+              }
+              var MAX_TAP_INTERVAL = 500;
+              var MAX_TOUCH_TIME = 500;
+              var MAX_DIST = 30;
+              var SingleTapRecognizer = function SingleTapRecognizer2(options) {
+                this.reset();
+                this.numTouches = options.numTouches;
+              };
+              SingleTapRecognizer.prototype.reset = function reset() {
+                delete this.centroid;
+                delete this.startTime;
+                delete this.touches;
+                this.aborted = false;
+              };
+              SingleTapRecognizer.prototype.touchstart = function touchstart(e2, points, mapTouches) {
+                if (this.centroid || mapTouches.length > this.numTouches) {
+                  this.aborted = true;
+                }
+                if (this.aborted) {
+                  return;
+                }
+                if (this.startTime === void 0) {
+                  this.startTime = e2.timeStamp;
+                }
+                if (mapTouches.length === this.numTouches) {
+                  this.centroid = getCentroid(points);
+                  this.touches = indexTouches(mapTouches, points);
+                }
+              };
+              SingleTapRecognizer.prototype.touchmove = function touchmove(e2, points, mapTouches) {
+                if (this.aborted || !this.centroid) {
+                  return;
+                }
+                var newTouches = indexTouches(mapTouches, points);
+                for (var id2 in this.touches) {
+                  var prevPos = this.touches[id2];
+                  var pos = newTouches[id2];
+                  if (!pos || pos.dist(prevPos) > MAX_DIST) {
+                    this.aborted = true;
+                  }
+                }
+              };
+              SingleTapRecognizer.prototype.touchend = function touchend(e2, points, mapTouches) {
+                if (!this.centroid || e2.timeStamp - this.startTime > MAX_TOUCH_TIME) {
+                  this.aborted = true;
+                }
+                if (mapTouches.length === 0) {
+                  var centroid = !this.aborted && this.centroid;
+                  this.reset();
+                  if (centroid) {
+                    return centroid;
+                  }
+                }
+              };
+              var TapRecognizer2 = function TapRecognizer22(options) {
+                this.singleTap = new SingleTapRecognizer(options);
+                this.numTaps = options.numTaps;
+                this.reset();
+              };
+              TapRecognizer2.prototype.reset = function reset() {
+                this.lastTime = Infinity;
+                delete this.lastTap;
+                this.count = 0;
+                this.singleTap.reset();
+              };
+              TapRecognizer2.prototype.touchstart = function touchstart(e2, points, mapTouches) {
+                this.singleTap.touchstart(e2, points, mapTouches);
+              };
+              TapRecognizer2.prototype.touchmove = function touchmove(e2, points, mapTouches) {
+                this.singleTap.touchmove(e2, points, mapTouches);
+              };
+              TapRecognizer2.prototype.touchend = function touchend(e2, points, mapTouches) {
+                var tap = this.singleTap.touchend(e2, points, mapTouches);
+                if (tap) {
+                  var soonEnough = e2.timeStamp - this.lastTime < MAX_TAP_INTERVAL;
+                  var closeEnough = !this.lastTap || this.lastTap.dist(tap) < MAX_DIST;
+                  if (!soonEnough || !closeEnough) {
+                    this.reset();
+                  }
+                  this.count++;
+                  this.lastTime = e2.timeStamp;
+                  this.lastTap = tap;
+                  if (this.count === this.numTaps) {
+                    this.reset();
+                    return tap;
+                  }
+                }
+              };
+              var TapZoomHandler = function TapZoomHandler2() {
+                this._zoomIn = new TapRecognizer2({
+                  numTouches: 1,
+                  numTaps: 2
+                });
+                this._zoomOut = new TapRecognizer2({
+                  numTouches: 2,
+                  numTaps: 1
+                });
+                this.reset();
+              };
+              TapZoomHandler.prototype.reset = function reset() {
+                this._active = false;
+                this._zoomIn.reset();
+                this._zoomOut.reset();
+              };
+              TapZoomHandler.prototype.touchstart = function touchstart(e2, points, mapTouches) {
+                this._zoomIn.touchstart(e2, points, mapTouches);
+                this._zoomOut.touchstart(e2, points, mapTouches);
+              };
+              TapZoomHandler.prototype.touchmove = function touchmove(e2, points, mapTouches) {
+                this._zoomIn.touchmove(e2, points, mapTouches);
+                this._zoomOut.touchmove(e2, points, mapTouches);
+              };
+              TapZoomHandler.prototype.touchend = function touchend(e2, points, mapTouches) {
+                var this$1$1 = this;
+                var zoomInPoint = this._zoomIn.touchend(e2, points, mapTouches);
+                var zoomOutPoint = this._zoomOut.touchend(e2, points, mapTouches);
+                if (zoomInPoint) {
+                  this._active = true;
+                  e2.preventDefault();
+                  setTimeout(function() {
+                    return this$1$1.reset();
+                  }, 0);
+                  return {
+                    cameraAnimation: function(map2) {
+                      return map2.easeTo({
+                        duration: 300,
+                        zoom: map2.getZoom() + 1,
+                        around: map2.unproject(zoomInPoint)
+                      }, { originalEvent: e2 });
+                    }
+                  };
+                } else if (zoomOutPoint) {
+                  this._active = true;
+                  e2.preventDefault();
+                  setTimeout(function() {
+                    return this$1$1.reset();
+                  }, 0);
+                  return {
+                    cameraAnimation: function(map2) {
+                      return map2.easeTo({
+                        duration: 300,
+                        zoom: map2.getZoom() - 1,
+                        around: map2.unproject(zoomOutPoint)
+                      }, { originalEvent: e2 });
+                    }
+                  };
+                }
+              };
+              TapZoomHandler.prototype.touchcancel = function touchcancel() {
+                this.reset();
+              };
+              TapZoomHandler.prototype.enable = function enable2() {
+                this._enabled = true;
+              };
+              TapZoomHandler.prototype.disable = function disable() {
+                this._enabled = false;
+                this.reset();
+              };
+              TapZoomHandler.prototype.isEnabled = function isEnabled2() {
+                return this._enabled;
+              };
+              TapZoomHandler.prototype.isActive = function isActive() {
+                return this._active;
+              };
+              var LEFT_BUTTON = 0;
+              var RIGHT_BUTTON = 2;
+              var BUTTONS_FLAGS = {};
+              BUTTONS_FLAGS[LEFT_BUTTON] = 1;
+              BUTTONS_FLAGS[RIGHT_BUTTON] = 2;
+              function buttonStillPressed(e2, button) {
+                var flag = BUTTONS_FLAGS[button];
+                return e2.buttons === void 0 || (e2.buttons & flag) !== flag;
+              }
+              var MouseHandler = function MouseHandler2(options) {
+                this.reset();
+                this._clickTolerance = options.clickTolerance || 1;
+              };
+              MouseHandler.prototype.reset = function reset() {
+                this._active = false;
+                this._moved = false;
+                delete this._lastPoint;
+                delete this._eventButton;
+              };
+              MouseHandler.prototype._correctButton = function _correctButton(e2, button) {
+                return false;
+              };
+              MouseHandler.prototype._move = function _move(lastPoint, point) {
+                return {};
+              };
+              MouseHandler.prototype.mousedown = function mousedown(e2, point) {
+                if (this._lastPoint) {
+                  return;
+                }
+                var eventButton = DOM.mouseButton(e2);
+                if (!this._correctButton(e2, eventButton)) {
+                  return;
+                }
+                this._lastPoint = point;
+                this._eventButton = eventButton;
+              };
+              MouseHandler.prototype.mousemoveWindow = function mousemoveWindow(e2, point) {
+                var lastPoint = this._lastPoint;
+                if (!lastPoint) {
+                  return;
+                }
+                e2.preventDefault();
+                if (buttonStillPressed(e2, this._eventButton)) {
+                  this.reset();
+                  return;
+                }
+                if (!this._moved && point.dist(lastPoint) < this._clickTolerance) {
+                  return;
+                }
+                this._moved = true;
+                this._lastPoint = point;
+                return this._move(lastPoint, point);
+              };
+              MouseHandler.prototype.mouseupWindow = function mouseupWindow(e2) {
+                if (!this._lastPoint) {
+                  return;
+                }
+                var eventButton = DOM.mouseButton(e2);
+                if (eventButton !== this._eventButton) {
+                  return;
+                }
+                if (this._moved) {
+                  DOM.suppressClick();
+                }
+                this.reset();
+              };
+              MouseHandler.prototype.enable = function enable2() {
+                this._enabled = true;
+              };
+              MouseHandler.prototype.disable = function disable() {
+                this._enabled = false;
+                this.reset();
+              };
+              MouseHandler.prototype.isEnabled = function isEnabled2() {
+                return this._enabled;
+              };
+              MouseHandler.prototype.isActive = function isActive() {
+                return this._active;
+              };
+              var MousePanHandler = function(MouseHandler2) {
+                function MousePanHandler2() {
+                  MouseHandler2.apply(this, arguments);
+                }
+                if (MouseHandler2)
+                  MousePanHandler2.__proto__ = MouseHandler2;
+                MousePanHandler2.prototype = Object.create(MouseHandler2 && MouseHandler2.prototype);
+                MousePanHandler2.prototype.constructor = MousePanHandler2;
+                MousePanHandler2.prototype.mousedown = function mousedown(e2, point) {
+                  MouseHandler2.prototype.mousedown.call(this, e2, point);
+                  if (this._lastPoint) {
+                    this._active = true;
+                  }
+                };
+                MousePanHandler2.prototype._correctButton = function _correctButton(e2, button) {
+                  return button === LEFT_BUTTON && !e2.ctrlKey;
+                };
+                MousePanHandler2.prototype._move = function _move(lastPoint, point) {
+                  return {
+                    around: point,
+                    panDelta: point.sub(lastPoint)
+                  };
+                };
+                return MousePanHandler2;
+              }(MouseHandler);
+              var MouseRotateHandler = function(MouseHandler2) {
+                function MouseRotateHandler2() {
+                  MouseHandler2.apply(this, arguments);
+                }
+                if (MouseHandler2)
+                  MouseRotateHandler2.__proto__ = MouseHandler2;
+                MouseRotateHandler2.prototype = Object.create(MouseHandler2 && MouseHandler2.prototype);
+                MouseRotateHandler2.prototype.constructor = MouseRotateHandler2;
+                MouseRotateHandler2.prototype._correctButton = function _correctButton(e2, button) {
+                  return button === LEFT_BUTTON && e2.ctrlKey || button === RIGHT_BUTTON;
+                };
+                MouseRotateHandler2.prototype._move = function _move(lastPoint, point) {
+                  var degreesPerPixelMoved = 0.8;
+                  var bearingDelta = (point.x - lastPoint.x) * degreesPerPixelMoved;
+                  if (bearingDelta) {
+                    this._active = true;
+                    return { bearingDelta };
+                  }
+                };
+                MouseRotateHandler2.prototype.contextmenu = function contextmenu(e2) {
+                  e2.preventDefault();
+                };
+                return MouseRotateHandler2;
+              }(MouseHandler);
+              var MousePitchHandler = function(MouseHandler2) {
+                function MousePitchHandler2() {
+                  MouseHandler2.apply(this, arguments);
+                }
+                if (MouseHandler2)
+                  MousePitchHandler2.__proto__ = MouseHandler2;
+                MousePitchHandler2.prototype = Object.create(MouseHandler2 && MouseHandler2.prototype);
+                MousePitchHandler2.prototype.constructor = MousePitchHandler2;
+                MousePitchHandler2.prototype._correctButton = function _correctButton(e2, button) {
+                  return button === LEFT_BUTTON && e2.ctrlKey || button === RIGHT_BUTTON;
+                };
+                MousePitchHandler2.prototype._move = function _move(lastPoint, point) {
+                  var degreesPerPixelMoved = -0.5;
+                  var pitchDelta = (point.y - lastPoint.y) * degreesPerPixelMoved;
+                  if (pitchDelta) {
+                    this._active = true;
+                    return { pitchDelta };
+                  }
+                };
+                MousePitchHandler2.prototype.contextmenu = function contextmenu(e2) {
+                  e2.preventDefault();
+                };
+                return MousePitchHandler2;
+              }(MouseHandler);
+              var TouchPanHandler = function TouchPanHandler2(options) {
+                this._minTouches = 1;
+                this._clickTolerance = options.clickTolerance || 1;
+                this.reset();
+              };
+              TouchPanHandler.prototype.reset = function reset() {
+                this._active = false;
+                this._touches = {};
+                this._sum = new performance2.Point(0, 0);
+              };
+              TouchPanHandler.prototype.touchstart = function touchstart(e2, points, mapTouches) {
+                return this._calculateTransform(e2, points, mapTouches);
+              };
+              TouchPanHandler.prototype.touchmove = function touchmove(e2, points, mapTouches) {
+                if (!this._active || mapTouches.length < this._minTouches) {
+                  return;
+                }
+                e2.preventDefault();
+                return this._calculateTransform(e2, points, mapTouches);
+              };
+              TouchPanHandler.prototype.touchend = function touchend(e2, points, mapTouches) {
+                this._calculateTransform(e2, points, mapTouches);
+                if (this._active && mapTouches.length < this._minTouches) {
+                  this.reset();
+                }
+              };
+              TouchPanHandler.prototype.touchcancel = function touchcancel() {
+                this.reset();
+              };
+              TouchPanHandler.prototype._calculateTransform = function _calculateTransform(e2, points, mapTouches) {
+                if (mapTouches.length > 0) {
+                  this._active = true;
+                }
+                var touches = indexTouches(mapTouches, points);
+                var touchPointSum = new performance2.Point(0, 0);
+                var touchDeltaSum = new performance2.Point(0, 0);
+                var touchDeltaCount = 0;
+                for (var identifier in touches) {
+                  var point = touches[identifier];
+                  var prevPoint = this._touches[identifier];
+                  if (prevPoint) {
+                    touchPointSum._add(point);
+                    touchDeltaSum._add(point.sub(prevPoint));
+                    touchDeltaCount++;
+                    touches[identifier] = point;
+                  }
+                }
+                this._touches = touches;
+                if (touchDeltaCount < this._minTouches || !touchDeltaSum.mag()) {
+                  return;
+                }
+                var panDelta = touchDeltaSum.div(touchDeltaCount);
+                this._sum._add(panDelta);
+                if (this._sum.mag() < this._clickTolerance) {
+                  return;
+                }
+                var around = touchPointSum.div(touchDeltaCount);
+                return {
+                  around,
+                  panDelta
+                };
+              };
+              TouchPanHandler.prototype.enable = function enable2() {
+                this._enabled = true;
+              };
+              TouchPanHandler.prototype.disable = function disable() {
+                this._enabled = false;
+                this.reset();
+              };
+              TouchPanHandler.prototype.isEnabled = function isEnabled2() {
+                return this._enabled;
+              };
+              TouchPanHandler.prototype.isActive = function isActive() {
+                return this._active;
+              };
+              var TwoTouchHandler = function TwoTouchHandler2() {
+                this.reset();
+              };
+              TwoTouchHandler.prototype.reset = function reset() {
+                this._active = false;
+                delete this._firstTwoTouches;
+              };
+              TwoTouchHandler.prototype._start = function _start(points) {
+              };
+              TwoTouchHandler.prototype._move = function _move(points, pinchAround, e2) {
+                return {};
+              };
+              TwoTouchHandler.prototype.touchstart = function touchstart(e2, points, mapTouches) {
+                if (this._firstTwoTouches || mapTouches.length < 2) {
+                  return;
+                }
+                this._firstTwoTouches = [
+                  mapTouches[0].identifier,
+                  mapTouches[1].identifier
+                ];
+                this._start([
+                  points[0],
+                  points[1]
+                ]);
+              };
+              TwoTouchHandler.prototype.touchmove = function touchmove(e2, points, mapTouches) {
+                if (!this._firstTwoTouches) {
+                  return;
+                }
+                e2.preventDefault();
+                var ref = this._firstTwoTouches;
+                var idA = ref[0];
+                var idB = ref[1];
+                var a2 = getTouchById(mapTouches, points, idA);
+                var b2 = getTouchById(mapTouches, points, idB);
+                if (!a2 || !b2) {
+                  return;
+                }
+                var pinchAround = this._aroundCenter ? null : a2.add(b2).div(2);
+                return this._move([
+                  a2,
+                  b2
+                ], pinchAround, e2);
+              };
+              TwoTouchHandler.prototype.touchend = function touchend(e2, points, mapTouches) {
+                if (!this._firstTwoTouches) {
+                  return;
+                }
+                var ref = this._firstTwoTouches;
+                var idA = ref[0];
+                var idB = ref[1];
+                var a2 = getTouchById(mapTouches, points, idA);
+                var b2 = getTouchById(mapTouches, points, idB);
+                if (a2 && b2) {
+                  return;
+                }
+                if (this._active) {
+                  DOM.suppressClick();
+                }
+                this.reset();
+              };
+              TwoTouchHandler.prototype.touchcancel = function touchcancel() {
+                this.reset();
+              };
+              TwoTouchHandler.prototype.enable = function enable2(options) {
+                this._enabled = true;
+                this._aroundCenter = !!options && options.around === "center";
+              };
+              TwoTouchHandler.prototype.disable = function disable() {
+                this._enabled = false;
+                this.reset();
+              };
+              TwoTouchHandler.prototype.isEnabled = function isEnabled2() {
+                return this._enabled;
+              };
+              TwoTouchHandler.prototype.isActive = function isActive() {
+                return this._active;
+              };
+              function getTouchById(mapTouches, points, identifier) {
+                for (var i2 = 0; i2 < mapTouches.length; i2++) {
+                  if (mapTouches[i2].identifier === identifier) {
+                    return points[i2];
+                  }
+                }
+              }
+              var ZOOM_THRESHOLD = 0.1;
+              function getZoomDelta(distance2, lastDistance) {
+                return Math.log(distance2 / lastDistance) / Math.LN2;
+              }
+              var TouchZoomHandler = function(TwoTouchHandler2) {
+                function TouchZoomHandler2() {
+                  TwoTouchHandler2.apply(this, arguments);
+                }
+                if (TwoTouchHandler2)
+                  TouchZoomHandler2.__proto__ = TwoTouchHandler2;
+                TouchZoomHandler2.prototype = Object.create(TwoTouchHandler2 && TwoTouchHandler2.prototype);
+                TouchZoomHandler2.prototype.constructor = TouchZoomHandler2;
+                TouchZoomHandler2.prototype.reset = function reset() {
+                  TwoTouchHandler2.prototype.reset.call(this);
+                  delete this._distance;
+                  delete this._startDistance;
+                };
+                TouchZoomHandler2.prototype._start = function _start(points) {
+                  this._startDistance = this._distance = points[0].dist(points[1]);
+                };
+                TouchZoomHandler2.prototype._move = function _move(points, pinchAround) {
+                  var lastDistance = this._distance;
+                  this._distance = points[0].dist(points[1]);
+                  if (!this._active && Math.abs(getZoomDelta(this._distance, this._startDistance)) < ZOOM_THRESHOLD) {
+                    return;
+                  }
+                  this._active = true;
+                  return {
+                    zoomDelta: getZoomDelta(this._distance, lastDistance),
+                    pinchAround
+                  };
+                };
+                return TouchZoomHandler2;
+              }(TwoTouchHandler);
+              var ROTATION_THRESHOLD = 25;
+              function getBearingDelta(a2, b2) {
+                return a2.angleWith(b2) * 180 / Math.PI;
+              }
+              var TouchRotateHandler = function(TwoTouchHandler2) {
+                function TouchRotateHandler2() {
+                  TwoTouchHandler2.apply(this, arguments);
+                }
+                if (TwoTouchHandler2)
+                  TouchRotateHandler2.__proto__ = TwoTouchHandler2;
+                TouchRotateHandler2.prototype = Object.create(TwoTouchHandler2 && TwoTouchHandler2.prototype);
+                TouchRotateHandler2.prototype.constructor = TouchRotateHandler2;
+                TouchRotateHandler2.prototype.reset = function reset() {
+                  TwoTouchHandler2.prototype.reset.call(this);
+                  delete this._minDiameter;
+                  delete this._startVector;
+                  delete this._vector;
+                };
+                TouchRotateHandler2.prototype._start = function _start(points) {
+                  this._startVector = this._vector = points[0].sub(points[1]);
+                  this._minDiameter = points[0].dist(points[1]);
+                };
+                TouchRotateHandler2.prototype._move = function _move(points, pinchAround) {
+                  var lastVector = this._vector;
+                  this._vector = points[0].sub(points[1]);
+                  if (!this._active && this._isBelowThreshold(this._vector)) {
+                    return;
+                  }
+                  this._active = true;
+                  return {
+                    bearingDelta: getBearingDelta(this._vector, lastVector),
+                    pinchAround
+                  };
+                };
+                TouchRotateHandler2.prototype._isBelowThreshold = function _isBelowThreshold(vector) {
+                  this._minDiameter = Math.min(this._minDiameter, vector.mag());
+                  var circumference = Math.PI * this._minDiameter;
+                  var threshold = ROTATION_THRESHOLD / circumference * 360;
+                  var bearingDeltaSinceStart = getBearingDelta(vector, this._startVector);
+                  return Math.abs(bearingDeltaSinceStart) < threshold;
+                };
+                return TouchRotateHandler2;
+              }(TwoTouchHandler);
+              function isVertical(vector) {
+                return Math.abs(vector.y) > Math.abs(vector.x);
+              }
+              var ALLOWED_SINGLE_TOUCH_TIME = 100;
+              var TouchPitchHandler = function(TwoTouchHandler2) {
+                function TouchPitchHandler2() {
+                  TwoTouchHandler2.apply(this, arguments);
+                }
+                if (TwoTouchHandler2)
+                  TouchPitchHandler2.__proto__ = TwoTouchHandler2;
+                TouchPitchHandler2.prototype = Object.create(TwoTouchHandler2 && TwoTouchHandler2.prototype);
+                TouchPitchHandler2.prototype.constructor = TouchPitchHandler2;
+                TouchPitchHandler2.prototype.reset = function reset() {
+                  TwoTouchHandler2.prototype.reset.call(this);
+                  this._valid = void 0;
+                  delete this._firstMove;
+                  delete this._lastPoints;
+                };
+                TouchPitchHandler2.prototype._start = function _start(points) {
+                  this._lastPoints = points;
+                  if (isVertical(points[0].sub(points[1]))) {
+                    this._valid = false;
+                  }
+                };
+                TouchPitchHandler2.prototype._move = function _move(points, center, e2) {
+                  var vectorA = points[0].sub(this._lastPoints[0]);
+                  var vectorB = points[1].sub(this._lastPoints[1]);
+                  this._valid = this.gestureBeginsVertically(vectorA, vectorB, e2.timeStamp);
+                  if (!this._valid) {
+                    return;
+                  }
+                  this._lastPoints = points;
+                  this._active = true;
+                  var yDeltaAverage = (vectorA.y + vectorB.y) / 2;
+                  var degreesPerPixelMoved = -0.5;
+                  return { pitchDelta: yDeltaAverage * degreesPerPixelMoved };
+                };
+                TouchPitchHandler2.prototype.gestureBeginsVertically = function gestureBeginsVertically(vectorA, vectorB, timeStamp) {
+                  if (this._valid !== void 0) {
+                    return this._valid;
+                  }
+                  var threshold = 2;
+                  var movedA = vectorA.mag() >= threshold;
+                  var movedB = vectorB.mag() >= threshold;
+                  if (!movedA && !movedB) {
+                    return;
+                  }
+                  if (!movedA || !movedB) {
+                    if (this._firstMove === void 0) {
+                      this._firstMove = timeStamp;
+                    }
+                    if (timeStamp - this._firstMove < ALLOWED_SINGLE_TOUCH_TIME) {
+                      return void 0;
+                    } else {
+                      return false;
+                    }
+                  }
+                  var isSameDirection = vectorA.y > 0 === vectorB.y > 0;
+                  return isVertical(vectorA) && isVertical(vectorB) && isSameDirection;
+                };
+                return TouchPitchHandler2;
+              }(TwoTouchHandler);
+              var defaultOptions2 = {
+                panStep: 100,
+                bearingStep: 15,
+                pitchStep: 10
+              };
+              var KeyboardHandler = function KeyboardHandler2() {
+                var stepOptions = defaultOptions2;
+                this._panStep = stepOptions.panStep;
+                this._bearingStep = stepOptions.bearingStep;
+                this._pitchStep = stepOptions.pitchStep;
+                this._rotationDisabled = false;
+              };
+              KeyboardHandler.prototype.reset = function reset() {
+                this._active = false;
+              };
+              KeyboardHandler.prototype.keydown = function keydown(e2) {
+                var this$1$1 = this;
+                if (e2.altKey || e2.ctrlKey || e2.metaKey) {
+                  return;
+                }
+                var zoomDir = 0;
+                var bearingDir = 0;
+                var pitchDir = 0;
+                var xDir = 0;
+                var yDir = 0;
+                switch (e2.keyCode) {
+                  case 61:
+                  case 107:
+                  case 171:
+                  case 187:
+                    zoomDir = 1;
+                    break;
+                  case 189:
+                  case 109:
+                  case 173:
+                    zoomDir = -1;
+                    break;
+                  case 37:
+                    if (e2.shiftKey) {
+                      bearingDir = -1;
+                    } else {
+                      e2.preventDefault();
+                      xDir = -1;
+                    }
+                    break;
+                  case 39:
+                    if (e2.shiftKey) {
+                      bearingDir = 1;
+                    } else {
+                      e2.preventDefault();
+                      xDir = 1;
+                    }
+                    break;
+                  case 38:
+                    if (e2.shiftKey) {
+                      pitchDir = 1;
+                    } else {
+                      e2.preventDefault();
+                      yDir = -1;
+                    }
+                    break;
+                  case 40:
+                    if (e2.shiftKey) {
+                      pitchDir = -1;
+                    } else {
+                      e2.preventDefault();
+                      yDir = 1;
+                    }
+                    break;
+                  default:
+                    return;
+                }
+                if (this._rotationDisabled) {
+                  bearingDir = 0;
+                  pitchDir = 0;
+                }
+                return {
+                  cameraAnimation: function(map2) {
+                    var zoom = map2.getZoom();
+                    map2.easeTo({
+                      duration: 300,
+                      easeId: "keyboardHandler",
+                      easing: easeOut,
+                      zoom: zoomDir ? Math.round(zoom) + zoomDir * (e2.shiftKey ? 2 : 1) : zoom,
+                      bearing: map2.getBearing() + bearingDir * this$1$1._bearingStep,
+                      pitch: map2.getPitch() + pitchDir * this$1$1._pitchStep,
+                      offset: [
+                        -xDir * this$1$1._panStep,
+                        -yDir * this$1$1._panStep
+                      ],
+                      center: map2.getCenter()
+                    }, { originalEvent: e2 });
+                  }
+                };
+              };
+              KeyboardHandler.prototype.enable = function enable2() {
+                this._enabled = true;
+              };
+              KeyboardHandler.prototype.disable = function disable() {
+                this._enabled = false;
+                this.reset();
+              };
+              KeyboardHandler.prototype.isEnabled = function isEnabled2() {
+                return this._enabled;
+              };
+              KeyboardHandler.prototype.isActive = function isActive() {
+                return this._active;
+              };
+              KeyboardHandler.prototype.disableRotation = function disableRotation() {
+                this._rotationDisabled = true;
+              };
+              KeyboardHandler.prototype.enableRotation = function enableRotation() {
+                this._rotationDisabled = false;
+              };
+              function easeOut(t4) {
+                return t4 * (2 - t4);
+              }
+              var wheelZoomDelta = 4.000244140625;
+              var defaultZoomRate = 1 / 100;
+              var wheelZoomRate = 1 / 450;
+              var maxScalePerFrame = 2;
+              var ScrollZoomHandler = function ScrollZoomHandler2(map2, handler) {
+                this._map = map2;
+                this._el = map2.getCanvasContainer();
+                this._handler = handler;
+                this._delta = 0;
+                this._defaultZoomRate = defaultZoomRate;
+                this._wheelZoomRate = wheelZoomRate;
+                performance2.bindAll(["_onTimeout"], this);
+              };
+              ScrollZoomHandler.prototype.setZoomRate = function setZoomRate(zoomRate) {
+                this._defaultZoomRate = zoomRate;
+              };
+              ScrollZoomHandler.prototype.setWheelZoomRate = function setWheelZoomRate(wheelZoomRate2) {
+                this._wheelZoomRate = wheelZoomRate2;
+              };
+              ScrollZoomHandler.prototype.isEnabled = function isEnabled2() {
+                return !!this._enabled;
+              };
+              ScrollZoomHandler.prototype.isActive = function isActive() {
+                return !!this._active || this._finishTimeout !== void 0;
+              };
+              ScrollZoomHandler.prototype.isZooming = function isZooming() {
+                return !!this._zooming;
+              };
+              ScrollZoomHandler.prototype.enable = function enable2(options) {
+                if (this.isEnabled()) {
+                  return;
+                }
+                this._enabled = true;
+                this._aroundCenter = options && options.around === "center";
+              };
+              ScrollZoomHandler.prototype.disable = function disable() {
+                if (!this.isEnabled()) {
+                  return;
+                }
+                this._enabled = false;
+              };
+              ScrollZoomHandler.prototype.wheel = function wheel(e2) {
+                if (!this.isEnabled()) {
+                  return;
+                }
+                var value = e2.deltaMode === performance2.window.WheelEvent.DOM_DELTA_LINE ? e2.deltaY * 40 : e2.deltaY;
+                var now = performance2.browser.now(), timeDelta = now - (this._lastWheelEventTime || 0);
+                this._lastWheelEventTime = now;
+                if (value !== 0 && value % wheelZoomDelta === 0) {
+                  this._type = "wheel";
+                } else if (value !== 0 && Math.abs(value) < 4) {
+                  this._type = "trackpad";
+                } else if (timeDelta > 400) {
+                  this._type = null;
+                  this._lastValue = value;
+                  this._timeout = setTimeout(this._onTimeout, 40, e2);
+                } else if (!this._type) {
+                  this._type = Math.abs(timeDelta * value) < 200 ? "trackpad" : "wheel";
+                  if (this._timeout) {
+                    clearTimeout(this._timeout);
+                    this._timeout = null;
+                    value += this._lastValue;
+                  }
+                }
+                if (e2.shiftKey && value) {
+                  value = value / 4;
+                }
+                if (this._type) {
+                  this._lastWheelEvent = e2;
+                  this._delta -= value;
+                  if (!this._active) {
+                    this._start(e2);
+                  }
+                }
+                e2.preventDefault();
+              };
+              ScrollZoomHandler.prototype._onTimeout = function _onTimeout(initialEvent) {
+                this._type = "wheel";
+                this._delta -= this._lastValue;
+                if (!this._active) {
+                  this._start(initialEvent);
+                }
+              };
+              ScrollZoomHandler.prototype._start = function _start(e2) {
+                if (!this._delta) {
+                  return;
+                }
+                if (this._frameId) {
+                  this._frameId = null;
+                }
+                this._active = true;
+                if (!this.isZooming()) {
+                  this._zooming = true;
+                }
+                if (this._finishTimeout) {
+                  clearTimeout(this._finishTimeout);
+                  delete this._finishTimeout;
+                }
+                var pos = DOM.mousePos(this._el, e2);
+                this._around = performance2.LngLat.convert(this._aroundCenter ? this._map.getCenter() : this._map.unproject(pos));
+                this._aroundPoint = this._map.transform.locationPoint(this._around);
+                if (!this._frameId) {
+                  this._frameId = true;
+                  this._handler._triggerRenderFrame();
+                }
+              };
+              ScrollZoomHandler.prototype.renderFrame = function renderFrame() {
+                var this$1$1 = this;
+                if (!this._frameId) {
+                  return;
+                }
+                this._frameId = null;
+                if (!this.isActive()) {
+                  return;
+                }
+                var tr = this._map.transform;
+                if (this._delta !== 0) {
+                  var zoomRate = this._type === "wheel" && Math.abs(this._delta) > wheelZoomDelta ? this._wheelZoomRate : this._defaultZoomRate;
+                  var scale2 = maxScalePerFrame / (1 + Math.exp(-Math.abs(this._delta * zoomRate)));
+                  if (this._delta < 0 && scale2 !== 0) {
+                    scale2 = 1 / scale2;
+                  }
+                  var fromScale = typeof this._targetZoom === "number" ? tr.zoomScale(this._targetZoom) : tr.scale;
+                  this._targetZoom = Math.min(tr.maxZoom, Math.max(tr.minZoom, tr.scaleZoom(fromScale * scale2)));
+                  if (this._type === "wheel") {
+                    this._startZoom = tr.zoom;
+                    this._easing = this._smoothOutEasing(200);
+                  }
+                  this._delta = 0;
+                }
+                var targetZoom = typeof this._targetZoom === "number" ? this._targetZoom : tr.zoom;
+                var startZoom = this._startZoom;
+                var easing = this._easing;
+                var finished = false;
+                var zoom;
+                if (this._type === "wheel" && startZoom && easing) {
+                  var t4 = Math.min((performance2.browser.now() - this._lastWheelEventTime) / 200, 1);
+                  var k2 = easing(t4);
+                  zoom = performance2.number(startZoom, targetZoom, k2);
+                  if (t4 < 1) {
+                    if (!this._frameId) {
+                      this._frameId = true;
+                    }
+                  } else {
+                    finished = true;
+                  }
+                } else {
+                  zoom = targetZoom;
+                  finished = true;
+                }
+                this._active = true;
+                if (finished) {
+                  this._active = false;
+                  this._finishTimeout = setTimeout(function() {
+                    this$1$1._zooming = false;
+                    this$1$1._handler._triggerRenderFrame();
+                    delete this$1$1._targetZoom;
+                    delete this$1$1._finishTimeout;
+                  }, 200);
+                }
+                return {
+                  noInertia: true,
+                  needsRenderFrame: !finished,
+                  zoomDelta: zoom - tr.zoom,
+                  around: this._aroundPoint,
+                  originalEvent: this._lastWheelEvent
+                };
+              };
+              ScrollZoomHandler.prototype._smoothOutEasing = function _smoothOutEasing(duration) {
+                var easing = performance2.ease;
+                if (this._prevEase) {
+                  var ease = this._prevEase, t4 = (performance2.browser.now() - ease.start) / ease.duration, speed = ease.easing(t4 + 0.01) - ease.easing(t4), x2 = 0.27 / Math.sqrt(speed * speed + 1e-4) * 0.01, y2 = Math.sqrt(0.27 * 0.27 - x2 * x2);
+                  easing = performance2.bezier(x2, y2, 0.25, 1);
+                }
+                this._prevEase = {
+                  start: performance2.browser.now(),
+                  duration,
+                  easing
+                };
+                return easing;
+              };
+              ScrollZoomHandler.prototype.reset = function reset() {
+                this._active = false;
+              };
+              var DoubleClickZoomHandler = function DoubleClickZoomHandler2(clickZoom, TapZoom) {
+                this._clickZoom = clickZoom;
+                this._tapZoom = TapZoom;
+              };
+              DoubleClickZoomHandler.prototype.enable = function enable2() {
+                this._clickZoom.enable();
+                this._tapZoom.enable();
+              };
+              DoubleClickZoomHandler.prototype.disable = function disable() {
+                this._clickZoom.disable();
+                this._tapZoom.disable();
+              };
+              DoubleClickZoomHandler.prototype.isEnabled = function isEnabled2() {
+                return this._clickZoom.isEnabled() && this._tapZoom.isEnabled();
+              };
+              DoubleClickZoomHandler.prototype.isActive = function isActive() {
+                return this._clickZoom.isActive() || this._tapZoom.isActive();
+              };
+              var ClickZoomHandler = function ClickZoomHandler2() {
+                this.reset();
+              };
+              ClickZoomHandler.prototype.reset = function reset() {
+                this._active = false;
+              };
+              ClickZoomHandler.prototype.dblclick = function dblclick(e2, point) {
+                e2.preventDefault();
+                return {
+                  cameraAnimation: function(map2) {
+                    map2.easeTo({
+                      duration: 300,
+                      zoom: map2.getZoom() + (e2.shiftKey ? -1 : 1),
+                      around: map2.unproject(point)
+                    }, { originalEvent: e2 });
+                  }
+                };
+              };
+              ClickZoomHandler.prototype.enable = function enable2() {
+                this._enabled = true;
+              };
+              ClickZoomHandler.prototype.disable = function disable() {
+                this._enabled = false;
+                this.reset();
+              };
+              ClickZoomHandler.prototype.isEnabled = function isEnabled2() {
+                return this._enabled;
+              };
+              ClickZoomHandler.prototype.isActive = function isActive() {
+                return this._active;
+              };
+              var TapDragZoomHandler = function TapDragZoomHandler2() {
+                this._tap = new TapRecognizer2({
+                  numTouches: 1,
+                  numTaps: 1
+                });
+                this.reset();
+              };
+              TapDragZoomHandler.prototype.reset = function reset() {
+                this._active = false;
+                delete this._swipePoint;
+                delete this._swipeTouch;
+                delete this._tapTime;
+                this._tap.reset();
+              };
+              TapDragZoomHandler.prototype.touchstart = function touchstart(e2, points, mapTouches) {
+                if (this._swipePoint) {
+                  return;
+                }
+                if (this._tapTime && e2.timeStamp - this._tapTime > MAX_TAP_INTERVAL) {
+                  this.reset();
+                }
+                if (!this._tapTime) {
+                  this._tap.touchstart(e2, points, mapTouches);
+                } else if (mapTouches.length > 0) {
+                  this._swipePoint = points[0];
+                  this._swipeTouch = mapTouches[0].identifier;
+                }
+              };
+              TapDragZoomHandler.prototype.touchmove = function touchmove(e2, points, mapTouches) {
+                if (!this._tapTime) {
+                  this._tap.touchmove(e2, points, mapTouches);
+                } else if (this._swipePoint) {
+                  if (mapTouches[0].identifier !== this._swipeTouch) {
+                    return;
+                  }
+                  var newSwipePoint = points[0];
+                  var dist = newSwipePoint.y - this._swipePoint.y;
+                  this._swipePoint = newSwipePoint;
+                  e2.preventDefault();
+                  this._active = true;
+                  return { zoomDelta: dist / 128 };
+                }
+              };
+              TapDragZoomHandler.prototype.touchend = function touchend(e2, points, mapTouches) {
+                if (!this._tapTime) {
+                  var point = this._tap.touchend(e2, points, mapTouches);
+                  if (point) {
+                    this._tapTime = e2.timeStamp;
+                  }
+                } else if (this._swipePoint) {
+                  if (mapTouches.length === 0) {
+                    this.reset();
+                  }
+                }
+              };
+              TapDragZoomHandler.prototype.touchcancel = function touchcancel() {
+                this.reset();
+              };
+              TapDragZoomHandler.prototype.enable = function enable2() {
+                this._enabled = true;
+              };
+              TapDragZoomHandler.prototype.disable = function disable() {
+                this._enabled = false;
+                this.reset();
+              };
+              TapDragZoomHandler.prototype.isEnabled = function isEnabled2() {
+                return this._enabled;
+              };
+              TapDragZoomHandler.prototype.isActive = function isActive() {
+                return this._active;
+              };
+              var DragPanHandler = function DragPanHandler2(el2, mousePan, touchPan) {
+                this._el = el2;
+                this._mousePan = mousePan;
+                this._touchPan = touchPan;
+              };
+              DragPanHandler.prototype.enable = function enable2(options) {
+                this._inertiaOptions = options || {};
+                this._mousePan.enable();
+                this._touchPan.enable();
+                this._el.classList.add("mapboxgl-touch-drag-pan");
+              };
+              DragPanHandler.prototype.disable = function disable() {
+                this._mousePan.disable();
+                this._touchPan.disable();
+                this._el.classList.remove("mapboxgl-touch-drag-pan");
+              };
+              DragPanHandler.prototype.isEnabled = function isEnabled2() {
+                return this._mousePan.isEnabled() && this._touchPan.isEnabled();
+              };
+              DragPanHandler.prototype.isActive = function isActive() {
+                return this._mousePan.isActive() || this._touchPan.isActive();
+              };
+              var DragRotateHandler = function DragRotateHandler2(options, mouseRotate, mousePitch) {
+                this._pitchWithRotate = options.pitchWithRotate;
+                this._mouseRotate = mouseRotate;
+                this._mousePitch = mousePitch;
+              };
+              DragRotateHandler.prototype.enable = function enable2() {
+                this._mouseRotate.enable();
+                if (this._pitchWithRotate) {
+                  this._mousePitch.enable();
+                }
+              };
+              DragRotateHandler.prototype.disable = function disable() {
+                this._mouseRotate.disable();
+                this._mousePitch.disable();
+              };
+              DragRotateHandler.prototype.isEnabled = function isEnabled2() {
+                return this._mouseRotate.isEnabled() && (!this._pitchWithRotate || this._mousePitch.isEnabled());
+              };
+              DragRotateHandler.prototype.isActive = function isActive() {
+                return this._mouseRotate.isActive() || this._mousePitch.isActive();
+              };
+              var TouchZoomRotateHandler = function TouchZoomRotateHandler2(el2, touchZoom, touchRotate, tapDragZoom) {
+                this._el = el2;
+                this._touchZoom = touchZoom;
+                this._touchRotate = touchRotate;
+                this._tapDragZoom = tapDragZoom;
+                this._rotationDisabled = false;
+                this._enabled = true;
+              };
+              TouchZoomRotateHandler.prototype.enable = function enable2(options) {
+                this._touchZoom.enable(options);
+                if (!this._rotationDisabled) {
+                  this._touchRotate.enable(options);
+                }
+                this._tapDragZoom.enable();
+                this._el.classList.add("mapboxgl-touch-zoom-rotate");
+              };
+              TouchZoomRotateHandler.prototype.disable = function disable() {
+                this._touchZoom.disable();
+                this._touchRotate.disable();
+                this._tapDragZoom.disable();
+                this._el.classList.remove("mapboxgl-touch-zoom-rotate");
+              };
+              TouchZoomRotateHandler.prototype.isEnabled = function isEnabled2() {
+                return this._touchZoom.isEnabled() && (this._rotationDisabled || this._touchRotate.isEnabled()) && this._tapDragZoom.isEnabled();
+              };
+              TouchZoomRotateHandler.prototype.isActive = function isActive() {
+                return this._touchZoom.isActive() || this._touchRotate.isActive() || this._tapDragZoom.isActive();
+              };
+              TouchZoomRotateHandler.prototype.disableRotation = function disableRotation() {
+                this._rotationDisabled = true;
+                this._touchRotate.disable();
+              };
+              TouchZoomRotateHandler.prototype.enableRotation = function enableRotation() {
+                this._rotationDisabled = false;
+                if (this._touchZoom.isEnabled()) {
+                  this._touchRotate.enable();
+                }
+              };
+              var isMoving = function(p2) {
+                return p2.zoom || p2.drag || p2.pitch || p2.rotate;
+              };
+              var RenderFrameEvent = function(Event2) {
+                function RenderFrameEvent2() {
+                  Event2.apply(this, arguments);
+                }
+                if (Event2)
+                  RenderFrameEvent2.__proto__ = Event2;
+                RenderFrameEvent2.prototype = Object.create(Event2 && Event2.prototype);
+                RenderFrameEvent2.prototype.constructor = RenderFrameEvent2;
+                return RenderFrameEvent2;
+              }(performance2.Event);
+              function hasChange(result) {
+                return result.panDelta && result.panDelta.mag() || result.zoomDelta || result.bearingDelta || result.pitchDelta;
+              }
+              var HandlerManager = function HandlerManager2(map2, options) {
+                this._map = map2;
+                this._el = this._map.getCanvasContainer();
+                this._handlers = [];
+                this._handlersById = {};
+                this._changes = [];
+                this._inertia = new HandlerInertia(map2);
+                this._bearingSnap = options.bearingSnap;
+                this._previousActiveHandlers = {};
+                this._eventsInProgress = {};
+                this._addDefaultHandlers(options);
+                performance2.bindAll([
+                  "handleEvent",
+                  "handleWindowEvent"
+                ], this);
+                var el2 = this._el;
+                this._listeners = [
+                  [
+                    el2,
+                    "touchstart",
+                    { passive: true }
+                  ],
+                  [
+                    el2,
+                    "touchmove",
+                    { passive: false }
+                  ],
+                  [
+                    el2,
+                    "touchend",
+                    void 0
+                  ],
+                  [
+                    el2,
+                    "touchcancel",
+                    void 0
+                  ],
+                  [
+                    el2,
+                    "mousedown",
+                    void 0
+                  ],
+                  [
+                    el2,
+                    "mousemove",
+                    void 0
+                  ],
+                  [
+                    el2,
+                    "mouseup",
+                    void 0
+                  ],
+                  [
+                    performance2.window.document,
+                    "mousemove",
+                    { capture: true }
+                  ],
+                  [
+                    performance2.window.document,
+                    "mouseup",
+                    void 0
+                  ],
+                  [
+                    el2,
+                    "mouseover",
+                    void 0
+                  ],
+                  [
+                    el2,
+                    "mouseout",
+                    void 0
+                  ],
+                  [
+                    el2,
+                    "dblclick",
+                    void 0
+                  ],
+                  [
+                    el2,
+                    "click",
+                    void 0
+                  ],
+                  [
+                    el2,
+                    "keydown",
+                    { capture: false }
+                  ],
+                  [
+                    el2,
+                    "keyup",
+                    void 0
+                  ],
+                  [
+                    el2,
+                    "wheel",
+                    { passive: false }
+                  ],
+                  [
+                    el2,
+                    "contextmenu",
+                    void 0
+                  ],
+                  [
+                    performance2.window,
+                    "blur",
+                    void 0
+                  ]
+                ];
+                for (var i2 = 0, list = this._listeners; i2 < list.length; i2 += 1) {
+                  var ref = list[i2];
+                  var target = ref[0];
+                  var type = ref[1];
+                  var listenerOptions = ref[2];
+                  DOM.addEventListener(target, type, target === performance2.window.document ? this.handleWindowEvent : this.handleEvent, listenerOptions);
+                }
+              };
+              HandlerManager.prototype.destroy = function destroy() {
+                for (var i2 = 0, list = this._listeners; i2 < list.length; i2 += 1) {
+                  var ref = list[i2];
+                  var target = ref[0];
+                  var type = ref[1];
+                  var listenerOptions = ref[2];
+                  DOM.removeEventListener(target, type, target === performance2.window.document ? this.handleWindowEvent : this.handleEvent, listenerOptions);
+                }
+              };
+              HandlerManager.prototype._addDefaultHandlers = function _addDefaultHandlers(options) {
+                var map2 = this._map;
+                var el2 = map2.getCanvasContainer();
+                this._add("mapEvent", new MapEventHandler(map2, options));
+                var boxZoom = map2.boxZoom = new BoxZoomHandler(map2, options);
+                this._add("boxZoom", boxZoom);
+                var tapZoom = new TapZoomHandler();
+                var clickZoom = new ClickZoomHandler();
+                map2.doubleClickZoom = new DoubleClickZoomHandler(clickZoom, tapZoom);
+                this._add("tapZoom", tapZoom);
+                this._add("clickZoom", clickZoom);
+                var tapDragZoom = new TapDragZoomHandler();
+                this._add("tapDragZoom", tapDragZoom);
+                var touchPitch = map2.touchPitch = new TouchPitchHandler();
+                this._add("touchPitch", touchPitch);
+                var mouseRotate = new MouseRotateHandler(options);
+                var mousePitch = new MousePitchHandler(options);
+                map2.dragRotate = new DragRotateHandler(options, mouseRotate, mousePitch);
+                this._add("mouseRotate", mouseRotate, ["mousePitch"]);
+                this._add("mousePitch", mousePitch, ["mouseRotate"]);
+                var mousePan = new MousePanHandler(options);
+                var touchPan = new TouchPanHandler(options);
+                map2.dragPan = new DragPanHandler(el2, mousePan, touchPan);
+                this._add("mousePan", mousePan);
+                this._add("touchPan", touchPan, [
+                  "touchZoom",
+                  "touchRotate"
+                ]);
+                var touchRotate = new TouchRotateHandler();
+                var touchZoom = new TouchZoomHandler();
+                map2.touchZoomRotate = new TouchZoomRotateHandler(el2, touchZoom, touchRotate, tapDragZoom);
+                this._add("touchRotate", touchRotate, [
+                  "touchPan",
+                  "touchZoom"
+                ]);
+                this._add("touchZoom", touchZoom, [
+                  "touchPan",
+                  "touchRotate"
+                ]);
+                var scrollZoom = map2.scrollZoom = new ScrollZoomHandler(map2, this);
+                this._add("scrollZoom", scrollZoom, ["mousePan"]);
+                var keyboard = map2.keyboard = new KeyboardHandler();
+                this._add("keyboard", keyboard);
+                this._add("blockableMapEvent", new BlockableMapEventHandler(map2));
+                for (var i2 = 0, list = [
+                  "boxZoom",
+                  "doubleClickZoom",
+                  "tapDragZoom",
+                  "touchPitch",
+                  "dragRotate",
+                  "dragPan",
+                  "touchZoomRotate",
+                  "scrollZoom",
+                  "keyboard"
+                ]; i2 < list.length; i2 += 1) {
+                  var name2 = list[i2];
+                  if (options.interactive && options[name2]) {
+                    map2[name2].enable(options[name2]);
+                  }
+                }
+              };
+              HandlerManager.prototype._add = function _add(handlerName, handler, allowed) {
+                this._handlers.push({
+                  handlerName,
+                  handler,
+                  allowed
+                });
+                this._handlersById[handlerName] = handler;
+              };
+              HandlerManager.prototype.stop = function stop(allowEndAnimation) {
+                if (this._updatingCamera) {
+                  return;
+                }
+                for (var i2 = 0, list = this._handlers; i2 < list.length; i2 += 1) {
+                  var ref = list[i2];
+                  var handler = ref.handler;
+                  handler.reset();
+                }
+                this._inertia.clear();
+                this._fireEvents({}, {}, allowEndAnimation);
+                this._changes = [];
+              };
+              HandlerManager.prototype.isActive = function isActive() {
+                for (var i2 = 0, list = this._handlers; i2 < list.length; i2 += 1) {
+                  var ref = list[i2];
+                  var handler = ref.handler;
+                  if (handler.isActive()) {
+                    return true;
+                  }
+                }
+                return false;
+              };
+              HandlerManager.prototype.isZooming = function isZooming() {
+                return !!this._eventsInProgress.zoom || this._map.scrollZoom.isZooming();
+              };
+              HandlerManager.prototype.isRotating = function isRotating() {
+                return !!this._eventsInProgress.rotate;
+              };
+              HandlerManager.prototype.isMoving = function isMoving$1() {
+                return Boolean(isMoving(this._eventsInProgress)) || this.isZooming();
+              };
+              HandlerManager.prototype._blockedByActive = function _blockedByActive(activeHandlers, allowed, myName) {
+                for (var name2 in activeHandlers) {
+                  if (name2 === myName) {
+                    continue;
+                  }
+                  if (!allowed || allowed.indexOf(name2) < 0) {
+                    return true;
+                  }
+                }
+                return false;
+              };
+              HandlerManager.prototype.handleWindowEvent = function handleWindowEvent(e2) {
+                this.handleEvent(e2, e2.type + "Window");
+              };
+              HandlerManager.prototype._getMapTouches = function _getMapTouches(touches) {
+                var mapTouches = [];
+                for (var i2 = 0, list = touches; i2 < list.length; i2 += 1) {
+                  var t4 = list[i2];
+                  var target = t4.target;
+                  if (this._el.contains(target)) {
+                    mapTouches.push(t4);
+                  }
+                }
+                return mapTouches;
+              };
+              HandlerManager.prototype.handleEvent = function handleEvent(e2, eventName) {
+                if (e2.type === "blur") {
+                  this.stop(true);
+                  return;
+                }
+                this._updatingCamera = true;
+                var inputEvent = e2.type === "renderFrame" ? void 0 : e2;
+                var mergedHandlerResult = { needsRenderFrame: false };
+                var eventsInProgress = {};
+                var activeHandlers = {};
+                var mapTouches = e2.touches ? this._getMapTouches(e2.touches) : void 0;
+                var points = mapTouches ? DOM.touchPos(this._el, mapTouches) : DOM.mousePos(this._el, e2);
+                for (var i2 = 0, list = this._handlers; i2 < list.length; i2 += 1) {
+                  var ref = list[i2];
+                  var handlerName = ref.handlerName;
+                  var handler = ref.handler;
+                  var allowed = ref.allowed;
+                  if (!handler.isEnabled()) {
+                    continue;
+                  }
+                  var data = void 0;
+                  if (this._blockedByActive(activeHandlers, allowed, handlerName)) {
+                    handler.reset();
+                  } else {
+                    if (handler[eventName || e2.type]) {
+                      data = handler[eventName || e2.type](e2, points, mapTouches);
+                      this.mergeHandlerResult(mergedHandlerResult, eventsInProgress, data, handlerName, inputEvent);
+                      if (data && data.needsRenderFrame) {
+                        this._triggerRenderFrame();
+                      }
+                    }
+                  }
+                  if (data || handler.isActive()) {
+                    activeHandlers[handlerName] = handler;
+                  }
+                }
+                var deactivatedHandlers = {};
+                for (var name2 in this._previousActiveHandlers) {
+                  if (!activeHandlers[name2]) {
+                    deactivatedHandlers[name2] = inputEvent;
+                  }
+                }
+                this._previousActiveHandlers = activeHandlers;
+                if (Object.keys(deactivatedHandlers).length || hasChange(mergedHandlerResult)) {
+                  this._changes.push([
+                    mergedHandlerResult,
+                    eventsInProgress,
+                    deactivatedHandlers
+                  ]);
+                  this._triggerRenderFrame();
+                }
+                if (Object.keys(activeHandlers).length || hasChange(mergedHandlerResult)) {
+                  this._map._stop(true);
+                }
+                this._updatingCamera = false;
+                var cameraAnimation = mergedHandlerResult.cameraAnimation;
+                if (cameraAnimation) {
+                  this._inertia.clear();
+                  this._fireEvents({}, {}, true);
+                  this._changes = [];
+                  cameraAnimation(this._map);
+                }
+              };
+              HandlerManager.prototype.mergeHandlerResult = function mergeHandlerResult(mergedHandlerResult, eventsInProgress, handlerResult, name2, e2) {
+                if (!handlerResult) {
+                  return;
+                }
+                performance2.extend(mergedHandlerResult, handlerResult);
+                var eventData = {
+                  handlerName: name2,
+                  originalEvent: handlerResult.originalEvent || e2
+                };
+                if (handlerResult.zoomDelta !== void 0) {
+                  eventsInProgress.zoom = eventData;
+                }
+                if (handlerResult.panDelta !== void 0) {
+                  eventsInProgress.drag = eventData;
+                }
+                if (handlerResult.pitchDelta !== void 0) {
+                  eventsInProgress.pitch = eventData;
+                }
+                if (handlerResult.bearingDelta !== void 0) {
+                  eventsInProgress.rotate = eventData;
+                }
+              };
+              HandlerManager.prototype._applyChanges = function _applyChanges() {
+                var combined = {};
+                var combinedEventsInProgress = {};
+                var combinedDeactivatedHandlers = {};
+                for (var i2 = 0, list = this._changes; i2 < list.length; i2 += 1) {
+                  var ref = list[i2];
+                  var change = ref[0];
+                  var eventsInProgress = ref[1];
+                  var deactivatedHandlers = ref[2];
+                  if (change.panDelta) {
+                    combined.panDelta = (combined.panDelta || new performance2.Point(0, 0))._add(change.panDelta);
+                  }
+                  if (change.zoomDelta) {
+                    combined.zoomDelta = (combined.zoomDelta || 0) + change.zoomDelta;
+                  }
+                  if (change.bearingDelta) {
+                    combined.bearingDelta = (combined.bearingDelta || 0) + change.bearingDelta;
+                  }
+                  if (change.pitchDelta) {
+                    combined.pitchDelta = (combined.pitchDelta || 0) + change.pitchDelta;
+                  }
+                  if (change.around !== void 0) {
+                    combined.around = change.around;
+                  }
+                  if (change.pinchAround !== void 0) {
+                    combined.pinchAround = change.pinchAround;
+                  }
+                  if (change.noInertia) {
+                    combined.noInertia = change.noInertia;
+                  }
+                  performance2.extend(combinedEventsInProgress, eventsInProgress);
+                  performance2.extend(combinedDeactivatedHandlers, deactivatedHandlers);
+                }
+                this._updateMapTransform(combined, combinedEventsInProgress, combinedDeactivatedHandlers);
+                this._changes = [];
+              };
+              HandlerManager.prototype._updateMapTransform = function _updateMapTransform(combinedResult, combinedEventsInProgress, deactivatedHandlers) {
+                var map2 = this._map;
+                var tr = map2.transform;
+                if (!hasChange(combinedResult)) {
+                  return this._fireEvents(combinedEventsInProgress, deactivatedHandlers, true);
+                }
+                var panDelta = combinedResult.panDelta;
+                var zoomDelta = combinedResult.zoomDelta;
+                var bearingDelta = combinedResult.bearingDelta;
+                var pitchDelta = combinedResult.pitchDelta;
+                var around = combinedResult.around;
+                var pinchAround = combinedResult.pinchAround;
+                if (pinchAround !== void 0) {
+                  around = pinchAround;
+                }
+                map2._stop(true);
+                around = around || map2.transform.centerPoint;
+                var loc = tr.pointLocation(panDelta ? around.sub(panDelta) : around);
+                if (bearingDelta) {
+                  tr.bearing += bearingDelta;
+                }
+                if (pitchDelta) {
+                  tr.pitch += pitchDelta;
+                }
+                if (zoomDelta) {
+                  tr.zoom += zoomDelta;
+                }
+                tr.setLocationAtPoint(loc, around);
+                this._map._update();
+                if (!combinedResult.noInertia) {
+                  this._inertia.record(combinedResult);
+                }
+                this._fireEvents(combinedEventsInProgress, deactivatedHandlers, true);
+              };
+              HandlerManager.prototype._fireEvents = function _fireEvents(newEventsInProgress, deactivatedHandlers, allowEndAnimation) {
+                var this$1$1 = this;
+                var wasMoving = isMoving(this._eventsInProgress);
+                var nowMoving = isMoving(newEventsInProgress);
+                var startEvents = {};
+                for (var eventName in newEventsInProgress) {
+                  var ref = newEventsInProgress[eventName];
+                  var originalEvent = ref.originalEvent;
+                  if (!this._eventsInProgress[eventName]) {
+                    startEvents[eventName + "start"] = originalEvent;
+                  }
+                  this._eventsInProgress[eventName] = newEventsInProgress[eventName];
+                }
+                if (!wasMoving && nowMoving) {
+                  this._fireEvent("movestart", nowMoving.originalEvent);
+                }
+                for (var name2 in startEvents) {
+                  this._fireEvent(name2, startEvents[name2]);
+                }
+                if (nowMoving) {
+                  this._fireEvent("move", nowMoving.originalEvent);
+                }
+                for (var eventName$1 in newEventsInProgress) {
+                  var ref$1 = newEventsInProgress[eventName$1];
+                  var originalEvent$1 = ref$1.originalEvent;
+                  this._fireEvent(eventName$1, originalEvent$1);
+                }
+                var endEvents = {};
+                var originalEndEvent;
+                for (var eventName$2 in this._eventsInProgress) {
+                  var ref$2 = this._eventsInProgress[eventName$2];
+                  var handlerName = ref$2.handlerName;
+                  var originalEvent$2 = ref$2.originalEvent;
+                  if (!this._handlersById[handlerName].isActive()) {
+                    delete this._eventsInProgress[eventName$2];
+                    originalEndEvent = deactivatedHandlers[handlerName] || originalEvent$2;
+                    endEvents[eventName$2 + "end"] = originalEndEvent;
+                  }
+                }
+                for (var name$1 in endEvents) {
+                  this._fireEvent(name$1, endEvents[name$1]);
+                }
+                var stillMoving = isMoving(this._eventsInProgress);
+                if (allowEndAnimation && (wasMoving || nowMoving) && !stillMoving) {
+                  this._updatingCamera = true;
+                  var inertialEase = this._inertia._onMoveEnd(this._map.dragPan._inertiaOptions);
+                  var shouldSnapToNorth = function(bearing) {
+                    return bearing !== 0 && -this$1$1._bearingSnap < bearing && bearing < this$1$1._bearingSnap;
+                  };
+                  if (inertialEase) {
+                    if (shouldSnapToNorth(inertialEase.bearing || this._map.getBearing())) {
+                      inertialEase.bearing = 0;
+                    }
+                    this._map.easeTo(inertialEase, { originalEvent: originalEndEvent });
+                  } else {
+                    this._map.fire(new performance2.Event("moveend", { originalEvent: originalEndEvent }));
+                    if (shouldSnapToNorth(this._map.getBearing())) {
+                      this._map.resetNorth();
+                    }
+                  }
+                  this._updatingCamera = false;
+                }
+              };
+              HandlerManager.prototype._fireEvent = function _fireEvent(type, e2) {
+                this._map.fire(new performance2.Event(type, e2 ? { originalEvent: e2 } : {}));
+              };
+              HandlerManager.prototype._requestFrame = function _requestFrame() {
+                var this$1$1 = this;
+                this._map.triggerRepaint();
+                return this._map._renderTaskQueue.add(function(timeStamp) {
+                  delete this$1$1._frameId;
+                  this$1$1.handleEvent(new RenderFrameEvent("renderFrame", { timeStamp }));
+                  this$1$1._applyChanges();
+                });
+              };
+              HandlerManager.prototype._triggerRenderFrame = function _triggerRenderFrame() {
+                if (this._frameId === void 0) {
+                  this._frameId = this._requestFrame();
+                }
+              };
+              var Camera = function(Evented) {
+                function Camera2(transform, options) {
+                  Evented.call(this);
+                  this._moving = false;
+                  this._zooming = false;
+                  this.transform = transform;
+                  this._bearingSnap = options.bearingSnap;
+                  performance2.bindAll(["_renderFrameCallback"], this);
+                }
+                if (Evented)
+                  Camera2.__proto__ = Evented;
+                Camera2.prototype = Object.create(Evented && Evented.prototype);
+                Camera2.prototype.constructor = Camera2;
+                Camera2.prototype.getCenter = function getCenter2() {
+                  return new performance2.LngLat(this.transform.center.lng, this.transform.center.lat);
+                };
+                Camera2.prototype.setCenter = function setCenter(center, eventData) {
+                  return this.jumpTo({ center }, eventData);
+                };
+                Camera2.prototype.panBy = function panBy(offset, options, eventData) {
+                  offset = performance2.Point.convert(offset).mult(-1);
+                  return this.panTo(this.transform.center, performance2.extend({ offset }, options), eventData);
+                };
+                Camera2.prototype.panTo = function panTo(lnglat, options, eventData) {
+                  return this.easeTo(performance2.extend({ center: lnglat }, options), eventData);
+                };
+                Camera2.prototype.getZoom = function getZoom() {
+                  return this.transform.zoom;
+                };
+                Camera2.prototype.setZoom = function setZoom(zoom, eventData) {
+                  this.jumpTo({ zoom }, eventData);
+                  return this;
+                };
+                Camera2.prototype.zoomTo = function zoomTo(zoom, options, eventData) {
+                  return this.easeTo(performance2.extend({ zoom }, options), eventData);
+                };
+                Camera2.prototype.zoomIn = function zoomIn(options, eventData) {
+                  this.zoomTo(this.getZoom() + 1, options, eventData);
+                  return this;
+                };
+                Camera2.prototype.zoomOut = function zoomOut(options, eventData) {
+                  this.zoomTo(this.getZoom() - 1, options, eventData);
+                  return this;
+                };
+                Camera2.prototype.getBearing = function getBearing() {
+                  return this.transform.bearing;
+                };
+                Camera2.prototype.setBearing = function setBearing(bearing, eventData) {
+                  this.jumpTo({ bearing }, eventData);
+                  return this;
+                };
+                Camera2.prototype.getPadding = function getPadding() {
+                  return this.transform.padding;
+                };
+                Camera2.prototype.setPadding = function setPadding(padding2, eventData) {
+                  this.jumpTo({ padding: padding2 }, eventData);
+                  return this;
+                };
+                Camera2.prototype.rotateTo = function rotateTo(bearing, options, eventData) {
+                  return this.easeTo(performance2.extend({ bearing }, options), eventData);
+                };
+                Camera2.prototype.resetNorth = function resetNorth(options, eventData) {
+                  this.rotateTo(0, performance2.extend({ duration: 1e3 }, options), eventData);
+                  return this;
+                };
+                Camera2.prototype.resetNorthPitch = function resetNorthPitch(options, eventData) {
+                  this.easeTo(performance2.extend({
+                    bearing: 0,
+                    pitch: 0,
+                    duration: 1e3
+                  }, options), eventData);
+                  return this;
+                };
+                Camera2.prototype.snapToNorth = function snapToNorth(options, eventData) {
+                  if (Math.abs(this.getBearing()) < this._bearingSnap) {
+                    return this.resetNorth(options, eventData);
+                  }
+                  return this;
+                };
+                Camera2.prototype.getPitch = function getPitch() {
+                  return this.transform.pitch;
+                };
+                Camera2.prototype.setPitch = function setPitch(pitch, eventData) {
+                  this.jumpTo({ pitch }, eventData);
+                  return this;
+                };
+                Camera2.prototype.cameraForBounds = function cameraForBounds(bounds, options) {
+                  bounds = performance2.LngLatBounds.convert(bounds);
+                  var bearing = options && options.bearing || 0;
+                  return this._cameraForBoxAndBearing(bounds.getNorthWest(), bounds.getSouthEast(), bearing, options);
+                };
+                Camera2.prototype._cameraForBoxAndBearing = function _cameraForBoxAndBearing(p0, p1, bearing, options) {
+                  var defaultPadding = {
+                    top: 0,
+                    bottom: 0,
+                    right: 0,
+                    left: 0
+                  };
+                  options = performance2.extend({
+                    padding: defaultPadding,
+                    offset: [
+                      0,
+                      0
+                    ],
+                    maxZoom: this.transform.maxZoom
+                  }, options);
+                  if (typeof options.padding === "number") {
+                    var p2 = options.padding;
+                    options.padding = {
+                      top: p2,
+                      bottom: p2,
+                      right: p2,
+                      left: p2
+                    };
+                  }
+                  options.padding = performance2.extend(defaultPadding, options.padding);
+                  var tr = this.transform;
+                  var edgePadding = tr.padding;
+                  var p0world = tr.project(performance2.LngLat.convert(p0));
+                  var p1world = tr.project(performance2.LngLat.convert(p1));
+                  var p0rotated = p0world.rotate(-bearing * Math.PI / 180);
+                  var p1rotated = p1world.rotate(-bearing * Math.PI / 180);
+                  var upperRight = new performance2.Point(Math.max(p0rotated.x, p1rotated.x), Math.max(p0rotated.y, p1rotated.y));
+                  var lowerLeft = new performance2.Point(Math.min(p0rotated.x, p1rotated.x), Math.min(p0rotated.y, p1rotated.y));
+                  var size = upperRight.sub(lowerLeft);
+                  var scaleX2 = (tr.width - (edgePadding.left + edgePadding.right + options.padding.left + options.padding.right)) / size.x;
+                  var scaleY2 = (tr.height - (edgePadding.top + edgePadding.bottom + options.padding.top + options.padding.bottom)) / size.y;
+                  if (scaleY2 < 0 || scaleX2 < 0) {
+                    performance2.warnOnce("Map cannot fit within canvas with the given bounds, padding, and/or offset.");
+                    return;
+                  }
+                  var zoom = Math.min(tr.scaleZoom(tr.scale * Math.min(scaleX2, scaleY2)), options.maxZoom);
+                  var offset = typeof options.offset.x === "number" ? new performance2.Point(options.offset.x, options.offset.y) : performance2.Point.convert(options.offset);
+                  var paddingOffsetX = (options.padding.left - options.padding.right) / 2;
+                  var paddingOffsetY = (options.padding.top - options.padding.bottom) / 2;
+                  var paddingOffset = new performance2.Point(paddingOffsetX, paddingOffsetY);
+                  var rotatedPaddingOffset = paddingOffset.rotate(bearing * Math.PI / 180);
+                  var offsetAtInitialZoom = offset.add(rotatedPaddingOffset);
+                  var offsetAtFinalZoom = offsetAtInitialZoom.mult(tr.scale / tr.zoomScale(zoom));
+                  var center = tr.unproject(p0world.add(p1world).div(2).sub(offsetAtFinalZoom));
+                  return {
+                    center,
+                    zoom,
+                    bearing
+                  };
+                };
+                Camera2.prototype.fitBounds = function fitBounds2(bounds, options, eventData) {
+                  return this._fitInternal(this.cameraForBounds(bounds, options), options, eventData);
+                };
+                Camera2.prototype.fitScreenCoordinates = function fitScreenCoordinates(p0, p1, bearing, options, eventData) {
+                  return this._fitInternal(this._cameraForBoxAndBearing(this.transform.pointLocation(performance2.Point.convert(p0)), this.transform.pointLocation(performance2.Point.convert(p1)), bearing, options), options, eventData);
+                };
+                Camera2.prototype._fitInternal = function _fitInternal(calculatedOptions, options, eventData) {
+                  if (!calculatedOptions) {
+                    return this;
+                  }
+                  options = performance2.extend(calculatedOptions, options);
+                  delete options.padding;
+                  return options.linear ? this.easeTo(options, eventData) : this.flyTo(options, eventData);
+                };
+                Camera2.prototype.jumpTo = function jumpTo(options, eventData) {
+                  this.stop();
+                  var tr = this.transform;
+                  var zoomChanged = false, bearingChanged = false, pitchChanged = false;
+                  if ("zoom" in options && tr.zoom !== +options.zoom) {
+                    zoomChanged = true;
+                    tr.zoom = +options.zoom;
+                  }
+                  if (options.center !== void 0) {
+                    tr.center = performance2.LngLat.convert(options.center);
+                  }
+                  if ("bearing" in options && tr.bearing !== +options.bearing) {
+                    bearingChanged = true;
+                    tr.bearing = +options.bearing;
+                  }
+                  if ("pitch" in options && tr.pitch !== +options.pitch) {
+                    pitchChanged = true;
+                    tr.pitch = +options.pitch;
+                  }
+                  if (options.padding != null && !tr.isPaddingEqual(options.padding)) {
+                    tr.padding = options.padding;
+                  }
+                  this.fire(new performance2.Event("movestart", eventData)).fire(new performance2.Event("move", eventData));
+                  if (zoomChanged) {
+                    this.fire(new performance2.Event("zoomstart", eventData)).fire(new performance2.Event("zoom", eventData)).fire(new performance2.Event("zoomend", eventData));
+                  }
+                  if (bearingChanged) {
+                    this.fire(new performance2.Event("rotatestart", eventData)).fire(new performance2.Event("rotate", eventData)).fire(new performance2.Event("rotateend", eventData));
+                  }
+                  if (pitchChanged) {
+                    this.fire(new performance2.Event("pitchstart", eventData)).fire(new performance2.Event("pitch", eventData)).fire(new performance2.Event("pitchend", eventData));
+                  }
+                  return this.fire(new performance2.Event("moveend", eventData));
+                };
+                Camera2.prototype.easeTo = function easeTo(options, eventData) {
+                  var this$1$1 = this;
+                  this._stop(false, options.easeId);
+                  options = performance2.extend({
+                    offset: [
+                      0,
+                      0
+                    ],
+                    duration: 500,
+                    easing: performance2.ease
+                  }, options);
+                  if (options.animate === false || !options.essential && performance2.browser.prefersReducedMotion) {
+                    options.duration = 0;
+                  }
+                  var tr = this.transform, startZoom = this.getZoom(), startBearing = this.getBearing(), startPitch = this.getPitch(), startPadding = this.getPadding(), zoom = "zoom" in options ? +options.zoom : startZoom, bearing = "bearing" in options ? this._normalizeBearing(options.bearing, startBearing) : startBearing, pitch = "pitch" in options ? +options.pitch : startPitch, padding2 = "padding" in options ? options.padding : tr.padding;
+                  var offsetAsPoint = performance2.Point.convert(options.offset);
+                  var pointAtOffset = tr.centerPoint.add(offsetAsPoint);
+                  var locationAtOffset = tr.pointLocation(pointAtOffset);
+                  var center = performance2.LngLat.convert(options.center || locationAtOffset);
+                  this._normalizeCenter(center);
+                  var from = tr.project(locationAtOffset);
+                  var delta = tr.project(center).sub(from);
+                  var finalScale = tr.zoomScale(zoom - startZoom);
+                  var around, aroundPoint;
+                  if (options.around) {
+                    around = performance2.LngLat.convert(options.around);
+                    aroundPoint = tr.locationPoint(around);
+                  }
+                  var currently = {
+                    moving: this._moving,
+                    zooming: this._zooming,
+                    rotating: this._rotating,
+                    pitching: this._pitching
+                  };
+                  this._zooming = this._zooming || zoom !== startZoom;
+                  this._rotating = this._rotating || startBearing !== bearing;
+                  this._pitching = this._pitching || pitch !== startPitch;
+                  this._padding = !tr.isPaddingEqual(padding2);
+                  this._easeId = options.easeId;
+                  this._prepareEase(eventData, options.noMoveStart, currently);
+                  this._ease(function(k2) {
+                    if (this$1$1._zooming) {
+                      tr.zoom = performance2.number(startZoom, zoom, k2);
+                    }
+                    if (this$1$1._rotating) {
+                      tr.bearing = performance2.number(startBearing, bearing, k2);
+                    }
+                    if (this$1$1._pitching) {
+                      tr.pitch = performance2.number(startPitch, pitch, k2);
+                    }
+                    if (this$1$1._padding) {
+                      tr.interpolatePadding(startPadding, padding2, k2);
+                      pointAtOffset = tr.centerPoint.add(offsetAsPoint);
+                    }
+                    if (around) {
+                      tr.setLocationAtPoint(around, aroundPoint);
+                    } else {
+                      var scale2 = tr.zoomScale(tr.zoom - startZoom);
+                      var base = zoom > startZoom ? Math.min(2, finalScale) : Math.max(0.5, finalScale);
+                      var speedup = Math.pow(base, 1 - k2);
+                      var newCenter = tr.unproject(from.add(delta.mult(k2 * speedup)).mult(scale2));
+                      tr.setLocationAtPoint(tr.renderWorldCopies ? newCenter.wrap() : newCenter, pointAtOffset);
+                    }
+                    this$1$1._fireMoveEvents(eventData);
+                  }, function(interruptingEaseId) {
+                    this$1$1._afterEase(eventData, interruptingEaseId);
+                  }, options);
+                  return this;
+                };
+                Camera2.prototype._prepareEase = function _prepareEase(eventData, noMoveStart, currently) {
+                  if (currently === void 0)
+                    currently = {};
+                  this._moving = true;
+                  if (!noMoveStart && !currently.moving) {
+                    this.fire(new performance2.Event("movestart", eventData));
+                  }
+                  if (this._zooming && !currently.zooming) {
+                    this.fire(new performance2.Event("zoomstart", eventData));
+                  }
+                  if (this._rotating && !currently.rotating) {
+                    this.fire(new performance2.Event("rotatestart", eventData));
+                  }
+                  if (this._pitching && !currently.pitching) {
+                    this.fire(new performance2.Event("pitchstart", eventData));
+                  }
+                };
+                Camera2.prototype._fireMoveEvents = function _fireMoveEvents(eventData) {
+                  this.fire(new performance2.Event("move", eventData));
+                  if (this._zooming) {
+                    this.fire(new performance2.Event("zoom", eventData));
+                  }
+                  if (this._rotating) {
+                    this.fire(new performance2.Event("rotate", eventData));
+                  }
+                  if (this._pitching) {
+                    this.fire(new performance2.Event("pitch", eventData));
+                  }
+                };
+                Camera2.prototype._afterEase = function _afterEase(eventData, easeId) {
+                  if (this._easeId && easeId && this._easeId === easeId) {
+                    return;
+                  }
+                  delete this._easeId;
+                  var wasZooming = this._zooming;
+                  var wasRotating = this._rotating;
+                  var wasPitching = this._pitching;
+                  this._moving = false;
+                  this._zooming = false;
+                  this._rotating = false;
+                  this._pitching = false;
+                  this._padding = false;
+                  if (wasZooming) {
+                    this.fire(new performance2.Event("zoomend", eventData));
+                  }
+                  if (wasRotating) {
+                    this.fire(new performance2.Event("rotateend", eventData));
+                  }
+                  if (wasPitching) {
+                    this.fire(new performance2.Event("pitchend", eventData));
+                  }
+                  this.fire(new performance2.Event("moveend", eventData));
+                };
+                Camera2.prototype.flyTo = function flyTo(options, eventData) {
+                  var this$1$1 = this;
+                  if (!options.essential && performance2.browser.prefersReducedMotion) {
+                    var coercedOptions = performance2.pick(options, [
+                      "center",
+                      "zoom",
+                      "bearing",
+                      "pitch",
+                      "around"
+                    ]);
+                    return this.jumpTo(coercedOptions, eventData);
+                  }
+                  this.stop();
+                  options = performance2.extend({
+                    offset: [
+                      0,
+                      0
+                    ],
+                    speed: 1.2,
+                    curve: 1.42,
+                    easing: performance2.ease
+                  }, options);
+                  var tr = this.transform, startZoom = this.getZoom(), startBearing = this.getBearing(), startPitch = this.getPitch(), startPadding = this.getPadding();
+                  var zoom = "zoom" in options ? performance2.clamp(+options.zoom, tr.minZoom, tr.maxZoom) : startZoom;
+                  var bearing = "bearing" in options ? this._normalizeBearing(options.bearing, startBearing) : startBearing;
+                  var pitch = "pitch" in options ? +options.pitch : startPitch;
+                  var padding2 = "padding" in options ? options.padding : tr.padding;
+                  var scale2 = tr.zoomScale(zoom - startZoom);
+                  var offsetAsPoint = performance2.Point.convert(options.offset);
+                  var pointAtOffset = tr.centerPoint.add(offsetAsPoint);
+                  var locationAtOffset = tr.pointLocation(pointAtOffset);
+                  var center = performance2.LngLat.convert(options.center || locationAtOffset);
+                  this._normalizeCenter(center);
+                  var from = tr.project(locationAtOffset);
+                  var delta = tr.project(center).sub(from);
+                  var rho = options.curve;
+                  var w0 = Math.max(tr.width, tr.height), w1 = w0 / scale2, u1 = delta.mag();
+                  if ("minZoom" in options) {
+                    var minZoom = performance2.clamp(Math.min(options.minZoom, startZoom, zoom), tr.minZoom, tr.maxZoom);
+                    var wMax = w0 / tr.zoomScale(minZoom - startZoom);
+                    rho = Math.sqrt(wMax / u1 * 2);
+                  }
+                  var rho2 = rho * rho;
+                  function r2(i2) {
+                    var b2 = (w1 * w1 - w0 * w0 + (i2 ? -1 : 1) * rho2 * rho2 * u1 * u1) / (2 * (i2 ? w1 : w0) * rho2 * u1);
+                    return Math.log(Math.sqrt(b2 * b2 + 1) - b2);
+                  }
+                  function sinh2(n2) {
+                    return (Math.exp(n2) - Math.exp(-n2)) / 2;
+                  }
+                  function cosh2(n2) {
+                    return (Math.exp(n2) + Math.exp(-n2)) / 2;
+                  }
+                  function tanh2(n2) {
+                    return sinh2(n2) / cosh2(n2);
+                  }
+                  var r0 = r2(0);
+                  var w2 = function(s2) {
+                    return cosh2(r0) / cosh2(r0 + rho * s2);
+                  };
+                  var u2 = function(s2) {
+                    return w0 * ((cosh2(r0) * tanh2(r0 + rho * s2) - sinh2(r0)) / rho2) / u1;
+                  };
+                  var S2 = (r2(1) - r0) / rho;
+                  if (Math.abs(u1) < 1e-6 || !isFinite(S2)) {
+                    if (Math.abs(w0 - w1) < 1e-6) {
+                      return this.easeTo(options, eventData);
+                    }
+                    var k2 = w1 < w0 ? -1 : 1;
+                    S2 = Math.abs(Math.log(w1 / w0)) / rho;
+                    u2 = function() {
+                      return 0;
+                    };
+                    w2 = function(s2) {
+                      return Math.exp(k2 * rho * s2);
+                    };
+                  }
+                  if ("duration" in options) {
+                    options.duration = +options.duration;
+                  } else {
+                    var V2 = "screenSpeed" in options ? +options.screenSpeed / rho : +options.speed;
+                    options.duration = 1e3 * S2 / V2;
+                  }
+                  if (options.maxDuration && options.duration > options.maxDuration) {
+                    options.duration = 0;
+                  }
+                  this._zooming = true;
+                  this._rotating = startBearing !== bearing;
+                  this._pitching = pitch !== startPitch;
+                  this._padding = !tr.isPaddingEqual(padding2);
+                  this._prepareEase(eventData, false);
+                  this._ease(function(k22) {
+                    var s2 = k22 * S2;
+                    var scale22 = 1 / w2(s2);
+                    tr.zoom = k22 === 1 ? zoom : startZoom + tr.scaleZoom(scale22);
+                    if (this$1$1._rotating) {
+                      tr.bearing = performance2.number(startBearing, bearing, k22);
+                    }
+                    if (this$1$1._pitching) {
+                      tr.pitch = performance2.number(startPitch, pitch, k22);
+                    }
+                    if (this$1$1._padding) {
+                      tr.interpolatePadding(startPadding, padding2, k22);
+                      pointAtOffset = tr.centerPoint.add(offsetAsPoint);
+                    }
+                    var newCenter = k22 === 1 ? center : tr.unproject(from.add(delta.mult(u2(s2))).mult(scale22));
+                    tr.setLocationAtPoint(tr.renderWorldCopies ? newCenter.wrap() : newCenter, pointAtOffset);
+                    this$1$1._fireMoveEvents(eventData);
+                  }, function() {
+                    return this$1$1._afterEase(eventData);
+                  }, options);
+                  return this;
+                };
+                Camera2.prototype.isEasing = function isEasing() {
+                  return !!this._easeFrameId;
+                };
+                Camera2.prototype.stop = function stop() {
+                  return this._stop();
+                };
+                Camera2.prototype._stop = function _stop(allowGestures, easeId) {
+                  if (this._easeFrameId) {
+                    this._cancelRenderFrame(this._easeFrameId);
+                    delete this._easeFrameId;
+                    delete this._onEaseFrame;
+                  }
+                  if (this._onEaseEnd) {
+                    var onEaseEnd = this._onEaseEnd;
+                    delete this._onEaseEnd;
+                    onEaseEnd.call(this, easeId);
+                  }
+                  if (!allowGestures) {
+                    var handlers = this.handlers;
+                    if (handlers) {
+                      handlers.stop(false);
+                    }
+                  }
+                  return this;
+                };
+                Camera2.prototype._ease = function _ease(frame, finish, options) {
+                  if (options.animate === false || options.duration === 0) {
+                    frame(1);
+                    finish();
+                  } else {
+                    this._easeStart = performance2.browser.now();
+                    this._easeOptions = options;
+                    this._onEaseFrame = frame;
+                    this._onEaseEnd = finish;
+                    this._easeFrameId = this._requestRenderFrame(this._renderFrameCallback);
+                  }
+                };
+                Camera2.prototype._renderFrameCallback = function _renderFrameCallback() {
+                  var t4 = Math.min((performance2.browser.now() - this._easeStart) / this._easeOptions.duration, 1);
+                  this._onEaseFrame(this._easeOptions.easing(t4));
+                  if (t4 < 1) {
+                    this._easeFrameId = this._requestRenderFrame(this._renderFrameCallback);
+                  } else {
+                    this.stop();
+                  }
+                };
+                Camera2.prototype._normalizeBearing = function _normalizeBearing(bearing, currentBearing) {
+                  bearing = performance2.wrap(bearing, -180, 180);
+                  var diff = Math.abs(bearing - currentBearing);
+                  if (Math.abs(bearing - 360 - currentBearing) < diff) {
+                    bearing -= 360;
+                  }
+                  if (Math.abs(bearing + 360 - currentBearing) < diff) {
+                    bearing += 360;
+                  }
+                  return bearing;
+                };
+                Camera2.prototype._normalizeCenter = function _normalizeCenter(center) {
+                  var tr = this.transform;
+                  if (!tr.renderWorldCopies || tr.lngRange) {
+                    return;
+                  }
+                  var delta = center.lng - tr.center.lng;
+                  center.lng += delta > 180 ? -360 : delta < -180 ? 360 : 0;
+                };
+                return Camera2;
+              }(performance2.Evented);
+              var AttributionControl = function AttributionControl2(options) {
+                if (options === void 0)
+                  options = {};
+                this.options = options;
+                performance2.bindAll([
+                  "_toggleAttribution",
+                  "_updateEditLink",
+                  "_updateData",
+                  "_updateCompact"
+                ], this);
+              };
+              AttributionControl.prototype.getDefaultPosition = function getDefaultPosition() {
+                return "bottom-right";
+              };
+              AttributionControl.prototype.onAdd = function onAdd(map2) {
+                var compact = this.options && this.options.compact;
+                this._map = map2;
+                this._container = DOM.create("div", "mapboxgl-ctrl mapboxgl-ctrl-attrib");
+                this._compactButton = DOM.create("button", "mapboxgl-ctrl-attrib-button", this._container);
+                this._compactButton.addEventListener("click", this._toggleAttribution);
+                this._setElementTitle(this._compactButton, "ToggleAttribution");
+                this._innerContainer = DOM.create("div", "mapboxgl-ctrl-attrib-inner", this._container);
+                this._innerContainer.setAttribute("role", "list");
+                if (compact) {
+                  this._container.classList.add("mapboxgl-compact");
+                }
+                this._updateAttributions();
+                this._updateEditLink();
+                this._map.on("styledata", this._updateData);
+                this._map.on("sourcedata", this._updateData);
+                this._map.on("moveend", this._updateEditLink);
+                if (compact === void 0) {
+                  this._map.on("resize", this._updateCompact);
+                  this._updateCompact();
+                }
+                return this._container;
+              };
+              AttributionControl.prototype.onRemove = function onRemove() {
+                DOM.remove(this._container);
+                this._map.off("styledata", this._updateData);
+                this._map.off("sourcedata", this._updateData);
+                this._map.off("moveend", this._updateEditLink);
+                this._map.off("resize", this._updateCompact);
+                this._map = void 0;
+                this._attribHTML = void 0;
+              };
+              AttributionControl.prototype._setElementTitle = function _setElementTitle(element, title) {
+                var str = this._map._getUIString("AttributionControl." + title);
+                element.title = str;
+                element.setAttribute("aria-label", str);
+              };
+              AttributionControl.prototype._toggleAttribution = function _toggleAttribution() {
+                if (this._container.classList.contains("mapboxgl-compact-show")) {
+                  this._container.classList.remove("mapboxgl-compact-show");
+                  this._compactButton.setAttribute("aria-pressed", "false");
+                } else {
+                  this._container.classList.add("mapboxgl-compact-show");
+                  this._compactButton.setAttribute("aria-pressed", "true");
+                }
+              };
+              AttributionControl.prototype._updateEditLink = function _updateEditLink() {
+                var editLink = this._editLink;
+                if (!editLink) {
+                  editLink = this._editLink = this._container.querySelector(".mapbox-improve-map");
+                }
+                var params = [
+                  {
+                    key: "owner",
+                    value: this.styleOwner
+                  },
+                  {
+                    key: "id",
+                    value: this.styleId
+                  },
+                  {
+                    key: "access_token",
+                    value: this._map._requestManager._customAccessToken || performance2.config.ACCESS_TOKEN
+                  }
+                ];
+                if (editLink) {
+                  var paramString = params.reduce(function(acc, next, i2) {
+                    if (next.value) {
+                      acc += next.key + "=" + next.value + (i2 < params.length - 1 ? "&" : "");
+                    }
+                    return acc;
+                  }, "?");
+                  editLink.href = performance2.config.FEEDBACK_URL + "/" + paramString + (this._map._hash ? this._map._hash.getHashString(true) : "");
+                  editLink.rel = "noopener nofollow";
+                  this._setElementTitle(editLink, "MapFeedback");
+                }
+              };
+              AttributionControl.prototype._updateData = function _updateData(e2) {
+                if (e2 && (e2.sourceDataType === "metadata" || e2.sourceDataType === "visibility" || e2.dataType === "style")) {
+                  this._updateAttributions();
+                  this._updateEditLink();
+                }
+              };
+              AttributionControl.prototype._updateAttributions = function _updateAttributions() {
+                if (!this._map.style) {
+                  return;
+                }
+                var attributions = [];
+                if (this.options.customAttribution) {
+                  if (Array.isArray(this.options.customAttribution)) {
+                    attributions = attributions.concat(this.options.customAttribution.map(function(attribution) {
+                      if (typeof attribution !== "string") {
+                        return "";
+                      }
+                      return attribution;
+                    }));
+                  } else if (typeof this.options.customAttribution === "string") {
+                    attributions.push(this.options.customAttribution);
+                  }
+                }
+                if (this._map.style.stylesheet) {
+                  var stylesheet = this._map.style.stylesheet;
+                  this.styleOwner = stylesheet.owner;
+                  this.styleId = stylesheet.id;
+                }
+                var sourceCaches = this._map.style.sourceCaches;
+                for (var id2 in sourceCaches) {
+                  var sourceCache = sourceCaches[id2];
+                  if (sourceCache.used) {
+                    var source2 = sourceCache.getSource();
+                    if (source2.attribution && attributions.indexOf(source2.attribution) < 0) {
+                      attributions.push(source2.attribution);
+                    }
+                  }
+                }
+                attributions.sort(function(a2, b2) {
+                  return a2.length - b2.length;
+                });
+                attributions = attributions.filter(function(attrib, i2) {
+                  for (var j2 = i2 + 1; j2 < attributions.length; j2++) {
+                    if (attributions[j2].indexOf(attrib) >= 0) {
+                      return false;
+                    }
+                  }
+                  return true;
+                });
+                var attribHTML = attributions.join(" | ");
+                if (attribHTML === this._attribHTML) {
+                  return;
+                }
+                this._attribHTML = attribHTML;
+                if (attributions.length) {
+                  this._innerContainer.innerHTML = attribHTML;
+                  this._container.classList.remove("mapboxgl-attrib-empty");
+                } else {
+                  this._container.classList.add("mapboxgl-attrib-empty");
+                }
+                this._editLink = null;
+              };
+              AttributionControl.prototype._updateCompact = function _updateCompact() {
+                if (this._map.getCanvasContainer().offsetWidth <= 640) {
+                  this._container.classList.add("mapboxgl-compact");
+                } else {
+                  this._container.classList.remove("mapboxgl-compact", "mapboxgl-compact-show");
+                }
+              };
+              var LogoControl = function LogoControl2() {
+                performance2.bindAll(["_updateLogo"], this);
+                performance2.bindAll(["_updateCompact"], this);
+              };
+              LogoControl.prototype.onAdd = function onAdd(map2) {
+                this._map = map2;
+                this._container = DOM.create("div", "mapboxgl-ctrl");
+                var anchor = DOM.create("a", "mapboxgl-ctrl-logo");
+                anchor.target = "_blank";
+                anchor.rel = "noopener nofollow";
+                anchor.href = "https://www.mapbox.com/";
+                anchor.setAttribute("aria-label", this._map._getUIString("LogoControl.Title"));
+                anchor.setAttribute("rel", "noopener nofollow");
+                this._container.appendChild(anchor);
+                this._container.style.display = "none";
+                this._map.on("sourcedata", this._updateLogo);
+                this._updateLogo();
+                this._map.on("resize", this._updateCompact);
+                this._updateCompact();
+                return this._container;
+              };
+              LogoControl.prototype.onRemove = function onRemove() {
+                DOM.remove(this._container);
+                this._map.off("sourcedata", this._updateLogo);
+                this._map.off("resize", this._updateCompact);
+              };
+              LogoControl.prototype.getDefaultPosition = function getDefaultPosition() {
+                return "bottom-left";
+              };
+              LogoControl.prototype._updateLogo = function _updateLogo(e2) {
+                if (!e2 || e2.sourceDataType === "metadata") {
+                  this._container.style.display = this._logoRequired() ? "block" : "none";
+                }
+              };
+              LogoControl.prototype._logoRequired = function _logoRequired() {
+                if (!this._map.style) {
+                  return;
+                }
+                var sourceCaches = this._map.style.sourceCaches;
+                for (var id2 in sourceCaches) {
+                  var source2 = sourceCaches[id2].getSource();
+                  if (source2.mapbox_logo) {
+                    return true;
+                  }
+                }
+                return false;
+              };
+              LogoControl.prototype._updateCompact = function _updateCompact() {
+                var containerChildren = this._container.children;
+                if (containerChildren.length) {
+                  var anchor = containerChildren[0];
+                  if (this._map.getCanvasContainer().offsetWidth < 250) {
+                    anchor.classList.add("mapboxgl-compact");
+                  } else {
+                    anchor.classList.remove("mapboxgl-compact");
+                  }
+                }
+              };
+              var TaskQueue = function TaskQueue2() {
+                this._queue = [];
+                this._id = 0;
+                this._cleared = false;
+                this._currentlyRunning = false;
+              };
+              TaskQueue.prototype.add = function add2(callback) {
+                var id2 = ++this._id;
+                var queue = this._queue;
+                queue.push({
+                  callback,
+                  id: id2,
+                  cancelled: false
+                });
+                return id2;
+              };
+              TaskQueue.prototype.remove = function remove(id2) {
+                var running = this._currentlyRunning;
+                var queue = running ? this._queue.concat(running) : this._queue;
+                for (var i2 = 0, list = queue; i2 < list.length; i2 += 1) {
+                  var task = list[i2];
+                  if (task.id === id2) {
+                    task.cancelled = true;
+                    return;
+                  }
+                }
+              };
+              TaskQueue.prototype.run = function run(timeStamp) {
+                if (timeStamp === void 0)
+                  timeStamp = 0;
+                var queue = this._currentlyRunning = this._queue;
+                this._queue = [];
+                for (var i2 = 0, list = queue; i2 < list.length; i2 += 1) {
+                  var task = list[i2];
+                  if (task.cancelled) {
+                    continue;
+                  }
+                  task.callback(timeStamp);
+                  if (this._cleared) {
+                    break;
+                  }
+                }
+                this._cleared = false;
+                this._currentlyRunning = false;
+              };
+              TaskQueue.prototype.clear = function clear() {
+                if (this._currentlyRunning) {
+                  this._cleared = true;
+                }
+                this._queue = [];
+              };
+              var defaultLocale = {
+                "AttributionControl.ToggleAttribution": "Toggle attribution",
+                "AttributionControl.MapFeedback": "Map feedback",
+                "FullscreenControl.Enter": "Enter fullscreen",
+                "FullscreenControl.Exit": "Exit fullscreen",
+                "GeolocateControl.FindMyLocation": "Find my location",
+                "GeolocateControl.LocationNotAvailable": "Location not available",
+                "LogoControl.Title": "Mapbox logo",
+                "NavigationControl.ResetBearing": "Reset bearing to north",
+                "NavigationControl.ZoomIn": "Zoom in",
+                "NavigationControl.ZoomOut": "Zoom out",
+                "ScaleControl.Feet": "ft",
+                "ScaleControl.Meters": "m",
+                "ScaleControl.Kilometers": "km",
+                "ScaleControl.Miles": "mi",
+                "ScaleControl.NauticalMiles": "nm"
+              };
+              var HTMLImageElement2 = performance2.window.HTMLImageElement;
+              var HTMLElement2 = performance2.window.HTMLElement;
+              var ImageBitmap2 = performance2.window.ImageBitmap;
+              var defaultMinZoom = -2;
+              var defaultMaxZoom = 22;
+              var defaultMinPitch = 0;
+              var defaultMaxPitch = 60;
+              var defaultOptions$1 = {
+                center: [
+                  0,
+                  0
+                ],
+                zoom: 0,
+                bearing: 0,
+                pitch: 0,
+                minZoom: defaultMinZoom,
+                maxZoom: defaultMaxZoom,
+                minPitch: defaultMinPitch,
+                maxPitch: defaultMaxPitch,
+                interactive: true,
+                scrollZoom: true,
+                boxZoom: true,
+                dragRotate: true,
+                dragPan: true,
+                keyboard: true,
+                doubleClickZoom: true,
+                touchZoomRotate: true,
+                touchPitch: true,
+                bearingSnap: 7,
+                clickTolerance: 3,
+                pitchWithRotate: true,
+                hash: false,
+                attributionControl: true,
+                failIfMajorPerformanceCaveat: false,
+                preserveDrawingBuffer: false,
+                trackResize: true,
+                renderWorldCopies: true,
+                refreshExpiredTiles: true,
+                maxTileCacheSize: null,
+                localIdeographFontFamily: "sans-serif",
+                transformRequest: null,
+                accessToken: null,
+                fadeDuration: 300,
+                crossSourceCollisions: true
+              };
+              var Map22 = function(Camera2) {
+                function Map3(options) {
+                  var this$1$1 = this;
+                  options = performance2.extend({}, defaultOptions$1, options);
+                  if (options.minZoom != null && options.maxZoom != null && options.minZoom > options.maxZoom) {
+                    throw new Error("maxZoom must be greater than or equal to minZoom");
+                  }
+                  if (options.minPitch != null && options.maxPitch != null && options.minPitch > options.maxPitch) {
+                    throw new Error("maxPitch must be greater than or equal to minPitch");
+                  }
+                  if (options.minPitch != null && options.minPitch < defaultMinPitch) {
+                    throw new Error("minPitch must be greater than or equal to " + defaultMinPitch);
+                  }
+                  if (options.maxPitch != null && options.maxPitch > defaultMaxPitch) {
+                    throw new Error("maxPitch must be less than or equal to " + defaultMaxPitch);
+                  }
+                  var transform = new Transform(options.minZoom, options.maxZoom, options.minPitch, options.maxPitch, options.renderWorldCopies);
+                  Camera2.call(this, transform, options);
+                  this._interactive = options.interactive;
+                  this._maxTileCacheSize = options.maxTileCacheSize;
+                  this._failIfMajorPerformanceCaveat = options.failIfMajorPerformanceCaveat;
+                  this._preserveDrawingBuffer = options.preserveDrawingBuffer;
+                  this._antialias = options.antialias;
+                  this._trackResize = options.trackResize;
+                  this._bearingSnap = options.bearingSnap;
+                  this._refreshExpiredTiles = options.refreshExpiredTiles;
+                  this._fadeDuration = options.fadeDuration;
+                  this._crossSourceCollisions = options.crossSourceCollisions;
+                  this._crossFadingFactor = 1;
+                  this._collectResourceTiming = options.collectResourceTiming;
+                  this._renderTaskQueue = new TaskQueue();
+                  this._controls = [];
+                  this._mapId = performance2.uniqueId();
+                  this._locale = performance2.extend({}, defaultLocale, options.locale);
+                  this._clickTolerance = options.clickTolerance;
+                  this._requestManager = new performance2.RequestManager(options.transformRequest, options.accessToken);
+                  if (typeof options.container === "string") {
+                    this._container = performance2.window.document.getElementById(options.container);
+                    if (!this._container) {
+                      throw new Error("Container '" + options.container + "' not found.");
+                    }
+                  } else if (options.container instanceof HTMLElement2) {
+                    this._container = options.container;
+                  } else {
+                    throw new Error("Invalid type: 'container' must be a String or HTMLElement.");
+                  }
+                  if (options.maxBounds) {
+                    this.setMaxBounds(options.maxBounds);
+                  }
+                  performance2.bindAll([
+                    "_onWindowOnline",
+                    "_onWindowResize",
+                    "_onMapScroll",
+                    "_contextLost",
+                    "_contextRestored"
+                  ], this);
+                  this._setupContainer();
+                  this._setupPainter();
+                  if (this.painter === void 0) {
+                    throw new Error("Failed to initialize WebGL.");
+                  }
+                  this.on("move", function() {
+                    return this$1$1._update(false);
+                  });
+                  this.on("moveend", function() {
+                    return this$1$1._update(false);
+                  });
+                  this.on("zoom", function() {
+                    return this$1$1._update(true);
+                  });
+                  if (typeof performance2.window !== "undefined") {
+                    performance2.window.addEventListener("online", this._onWindowOnline, false);
+                    performance2.window.addEventListener("resize", this._onWindowResize, false);
+                    performance2.window.addEventListener("orientationchange", this._onWindowResize, false);
+                  }
+                  this.handlers = new HandlerManager(this, options);
+                  var hashName = typeof options.hash === "string" && options.hash || void 0;
+                  this._hash = options.hash && new Hash(hashName).addTo(this);
+                  if (!this._hash || !this._hash._onHashChange()) {
+                    this.jumpTo({
+                      center: options.center,
+                      zoom: options.zoom,
+                      bearing: options.bearing,
+                      pitch: options.pitch
+                    });
+                    if (options.bounds) {
+                      this.resize();
+                      this.fitBounds(options.bounds, performance2.extend({}, options.fitBoundsOptions, { duration: 0 }));
+                    }
+                  }
+                  this.resize();
+                  this._localIdeographFontFamily = options.localIdeographFontFamily;
+                  if (options.style) {
+                    this.setStyle(options.style, { localIdeographFontFamily: options.localIdeographFontFamily });
+                  }
+                  if (options.attributionControl) {
+                    this.addControl(new AttributionControl({ customAttribution: options.customAttribution }));
+                  }
+                  this.addControl(new LogoControl(), options.logoPosition);
+                  this.on("style.load", function() {
+                    if (this$1$1.transform.unmodified) {
+                      this$1$1.jumpTo(this$1$1.style.stylesheet);
+                    }
+                  });
+                  this.on("data", function(event) {
+                    this$1$1._update(event.dataType === "style");
+                    this$1$1.fire(new performance2.Event(event.dataType + "data", event));
+                  });
+                  this.on("dataloading", function(event) {
+                    this$1$1.fire(new performance2.Event(event.dataType + "dataloading", event));
+                  });
+                }
+                if (Camera2)
+                  Map3.__proto__ = Camera2;
+                Map3.prototype = Object.create(Camera2 && Camera2.prototype);
+                Map3.prototype.constructor = Map3;
+                var prototypeAccessors2 = {
+                  showTileBoundaries: { configurable: true },
+                  showPadding: { configurable: true },
+                  showCollisionBoxes: { configurable: true },
+                  showOverdrawInspector: { configurable: true },
+                  repaint: { configurable: true },
+                  vertices: { configurable: true },
+                  version: { configurable: true }
+                };
+                Map3.prototype._getMapId = function _getMapId() {
+                  return this._mapId;
+                };
+                Map3.prototype.addControl = function addControl(control, position) {
+                  if (position === void 0) {
+                    if (control.getDefaultPosition) {
+                      position = control.getDefaultPosition();
+                    } else {
+                      position = "top-right";
+                    }
+                  }
+                  if (!control || !control.onAdd) {
+                    return this.fire(new performance2.ErrorEvent(new Error("Invalid argument to map.addControl(). Argument must be a control with onAdd and onRemove methods.")));
+                  }
+                  var controlElement = control.onAdd(this);
+                  this._controls.push(control);
+                  var positionContainer = this._controlPositions[position];
+                  if (position.indexOf("bottom") !== -1) {
+                    positionContainer.insertBefore(controlElement, positionContainer.firstChild);
+                  } else {
+                    positionContainer.appendChild(controlElement);
+                  }
+                  return this;
+                };
+                Map3.prototype.removeControl = function removeControl(control) {
+                  if (!control || !control.onRemove) {
+                    return this.fire(new performance2.ErrorEvent(new Error("Invalid argument to map.removeControl(). Argument must be a control with onAdd and onRemove methods.")));
+                  }
+                  var ci2 = this._controls.indexOf(control);
+                  if (ci2 > -1) {
+                    this._controls.splice(ci2, 1);
+                  }
+                  control.onRemove(this);
+                  return this;
+                };
+                Map3.prototype.hasControl = function hasControl(control) {
+                  return this._controls.indexOf(control) > -1;
+                };
+                Map3.prototype.resize = function resize(eventData) {
+                  var dimensions = this._containerDimensions();
+                  var width = dimensions[0];
+                  var height = dimensions[1];
+                  this._resizeCanvas(width, height);
+                  this.transform.resize(width, height);
+                  this.painter.resize(width, height);
+                  var fireMoving = !this._moving;
+                  if (fireMoving) {
+                    this.stop();
+                    this.fire(new performance2.Event("movestart", eventData)).fire(new performance2.Event("move", eventData));
+                  }
+                  this.fire(new performance2.Event("resize", eventData));
+                  if (fireMoving) {
+                    this.fire(new performance2.Event("moveend", eventData));
+                  }
+                  return this;
+                };
+                Map3.prototype.getBounds = function getBounds2() {
+                  return this.transform.getBounds();
+                };
+                Map3.prototype.getMaxBounds = function getMaxBounds() {
+                  return this.transform.getMaxBounds();
+                };
+                Map3.prototype.setMaxBounds = function setMaxBounds(bounds) {
+                  this.transform.setMaxBounds(performance2.LngLatBounds.convert(bounds));
+                  return this._update();
+                };
+                Map3.prototype.setMinZoom = function setMinZoom(minZoom) {
+                  minZoom = minZoom === null || minZoom === void 0 ? defaultMinZoom : minZoom;
+                  if (minZoom >= defaultMinZoom && minZoom <= this.transform.maxZoom) {
+                    this.transform.minZoom = minZoom;
+                    this._update();
+                    if (this.getZoom() < minZoom) {
+                      this.setZoom(minZoom);
+                    }
+                    return this;
+                  } else {
+                    throw new Error("minZoom must be between " + defaultMinZoom + " and the current maxZoom, inclusive");
+                  }
+                };
+                Map3.prototype.getMinZoom = function getMinZoom() {
+                  return this.transform.minZoom;
+                };
+                Map3.prototype.setMaxZoom = function setMaxZoom(maxZoom) {
+                  maxZoom = maxZoom === null || maxZoom === void 0 ? defaultMaxZoom : maxZoom;
+                  if (maxZoom >= this.transform.minZoom) {
+                    this.transform.maxZoom = maxZoom;
+                    this._update();
+                    if (this.getZoom() > maxZoom) {
+                      this.setZoom(maxZoom);
+                    }
+                    return this;
+                  } else {
+                    throw new Error("maxZoom must be greater than the current minZoom");
+                  }
+                };
+                Map3.prototype.getMaxZoom = function getMaxZoom() {
+                  return this.transform.maxZoom;
+                };
+                Map3.prototype.setMinPitch = function setMinPitch(minPitch) {
+                  minPitch = minPitch === null || minPitch === void 0 ? defaultMinPitch : minPitch;
+                  if (minPitch < defaultMinPitch) {
+                    throw new Error("minPitch must be greater than or equal to " + defaultMinPitch);
+                  }
+                  if (minPitch >= defaultMinPitch && minPitch <= this.transform.maxPitch) {
+                    this.transform.minPitch = minPitch;
+                    this._update();
+                    if (this.getPitch() < minPitch) {
+                      this.setPitch(minPitch);
+                    }
+                    return this;
+                  } else {
+                    throw new Error("minPitch must be between " + defaultMinPitch + " and the current maxPitch, inclusive");
+                  }
+                };
+                Map3.prototype.getMinPitch = function getMinPitch() {
+                  return this.transform.minPitch;
+                };
+                Map3.prototype.setMaxPitch = function setMaxPitch(maxPitch) {
+                  maxPitch = maxPitch === null || maxPitch === void 0 ? defaultMaxPitch : maxPitch;
+                  if (maxPitch > defaultMaxPitch) {
+                    throw new Error("maxPitch must be less than or equal to " + defaultMaxPitch);
+                  }
+                  if (maxPitch >= this.transform.minPitch) {
+                    this.transform.maxPitch = maxPitch;
+                    this._update();
+                    if (this.getPitch() > maxPitch) {
+                      this.setPitch(maxPitch);
+                    }
+                    return this;
+                  } else {
+                    throw new Error("maxPitch must be greater than the current minPitch");
+                  }
+                };
+                Map3.prototype.getMaxPitch = function getMaxPitch() {
+                  return this.transform.maxPitch;
+                };
+                Map3.prototype.getRenderWorldCopies = function getRenderWorldCopies() {
+                  return this.transform.renderWorldCopies;
+                };
+                Map3.prototype.setRenderWorldCopies = function setRenderWorldCopies(renderWorldCopies) {
+                  this.transform.renderWorldCopies = renderWorldCopies;
+                  return this._update();
+                };
+                Map3.prototype.project = function project22(lnglat) {
+                  return this.transform.locationPoint(performance2.LngLat.convert(lnglat));
+                };
+                Map3.prototype.unproject = function unproject(point) {
+                  return this.transform.pointLocation(performance2.Point.convert(point));
+                };
+                Map3.prototype.isMoving = function isMoving2() {
+                  return this._moving || this.handlers.isMoving();
+                };
+                Map3.prototype.isZooming = function isZooming() {
+                  return this._zooming || this.handlers.isZooming();
+                };
+                Map3.prototype.isRotating = function isRotating() {
+                  return this._rotating || this.handlers.isRotating();
+                };
+                Map3.prototype._createDelegatedListener = function _createDelegatedListener(type, layerId, listener) {
+                  var this$1$1 = this;
+                  var obj;
+                  if (type === "mouseenter" || type === "mouseover") {
+                    var mousein = false;
+                    var mousemove = function(e2) {
+                      var features = this$1$1.getLayer(layerId) ? this$1$1.queryRenderedFeatures(e2.point, { layers: [layerId] }) : [];
+                      if (!features.length) {
+                        mousein = false;
+                      } else if (!mousein) {
+                        mousein = true;
+                        listener.call(this$1$1, new MapMouseEvent(type, this$1$1, e2.originalEvent, { features }));
+                      }
+                    };
+                    var mouseout = function() {
+                      mousein = false;
+                    };
+                    return {
+                      layer: layerId,
+                      listener,
+                      delegates: {
+                        mousemove,
+                        mouseout
+                      }
+                    };
+                  } else if (type === "mouseleave" || type === "mouseout") {
+                    var mousein$1 = false;
+                    var mousemove$1 = function(e2) {
+                      var features = this$1$1.getLayer(layerId) ? this$1$1.queryRenderedFeatures(e2.point, { layers: [layerId] }) : [];
+                      if (features.length) {
+                        mousein$1 = true;
+                      } else if (mousein$1) {
+                        mousein$1 = false;
+                        listener.call(this$1$1, new MapMouseEvent(type, this$1$1, e2.originalEvent));
+                      }
+                    };
+                    var mouseout$1 = function(e2) {
+                      if (mousein$1) {
+                        mousein$1 = false;
+                        listener.call(this$1$1, new MapMouseEvent(type, this$1$1, e2.originalEvent));
+                      }
+                    };
+                    return {
+                      layer: layerId,
+                      listener,
+                      delegates: {
+                        mousemove: mousemove$1,
+                        mouseout: mouseout$1
+                      }
+                    };
+                  } else {
+                    var delegate = function(e2) {
+                      var features = this$1$1.getLayer(layerId) ? this$1$1.queryRenderedFeatures(e2.point, { layers: [layerId] }) : [];
+                      if (features.length) {
+                        e2.features = features;
+                        listener.call(this$1$1, e2);
+                        delete e2.features;
+                      }
+                    };
+                    return {
+                      layer: layerId,
+                      listener,
+                      delegates: (obj = {}, obj[type] = delegate, obj)
+                    };
+                  }
+                };
+                Map3.prototype.on = function on(type, layerId, listener) {
+                  if (listener === void 0) {
+                    return Camera2.prototype.on.call(this, type, layerId);
+                  }
+                  var delegatedListener = this._createDelegatedListener(type, layerId, listener);
+                  this._delegatedListeners = this._delegatedListeners || {};
+                  this._delegatedListeners[type] = this._delegatedListeners[type] || [];
+                  this._delegatedListeners[type].push(delegatedListener);
+                  for (var event in delegatedListener.delegates) {
+                    this.on(event, delegatedListener.delegates[event]);
+                  }
+                  return this;
+                };
+                Map3.prototype.once = function once(type, layerId, listener) {
+                  if (listener === void 0) {
+                    return Camera2.prototype.once.call(this, type, layerId);
+                  }
+                  var delegatedListener = this._createDelegatedListener(type, layerId, listener);
+                  for (var event in delegatedListener.delegates) {
+                    this.once(event, delegatedListener.delegates[event]);
+                  }
+                  return this;
+                };
+                Map3.prototype.off = function off(type, layerId, listener) {
+                  var this$1$1 = this;
+                  if (listener === void 0) {
+                    return Camera2.prototype.off.call(this, type, layerId);
+                  }
+                  var removeDelegatedListener = function(delegatedListeners) {
+                    var listeners = delegatedListeners[type];
+                    for (var i2 = 0; i2 < listeners.length; i2++) {
+                      var delegatedListener = listeners[i2];
+                      if (delegatedListener.layer === layerId && delegatedListener.listener === listener) {
+                        for (var event in delegatedListener.delegates) {
+                          this$1$1.off(event, delegatedListener.delegates[event]);
+                        }
+                        listeners.splice(i2, 1);
+                        return this$1$1;
+                      }
+                    }
+                  };
+                  if (this._delegatedListeners && this._delegatedListeners[type]) {
+                    removeDelegatedListener(this._delegatedListeners);
+                  }
+                  return this;
+                };
+                Map3.prototype.queryRenderedFeatures = function queryRenderedFeatures2(geometry2, options) {
+                  if (!this.style) {
+                    return [];
+                  }
+                  if (options === void 0 && geometry2 !== void 0 && !(geometry2 instanceof performance2.Point) && !Array.isArray(geometry2)) {
+                    options = geometry2;
+                    geometry2 = void 0;
+                  }
+                  options = options || {};
+                  geometry2 = geometry2 || [
+                    [
+                      0,
+                      0
+                    ],
+                    [
+                      this.transform.width,
+                      this.transform.height
+                    ]
+                  ];
+                  var queryGeometry;
+                  if (geometry2 instanceof performance2.Point || typeof geometry2[0] === "number") {
+                    queryGeometry = [performance2.Point.convert(geometry2)];
+                  } else {
+                    var tl2 = performance2.Point.convert(geometry2[0]);
+                    var br = performance2.Point.convert(geometry2[1]);
+                    queryGeometry = [
+                      tl2,
+                      new performance2.Point(br.x, tl2.y),
+                      br,
+                      new performance2.Point(tl2.x, br.y),
+                      tl2
+                    ];
+                  }
+                  return this.style.queryRenderedFeatures(queryGeometry, options, this.transform);
+                };
+                Map3.prototype.querySourceFeatures = function querySourceFeatures2(sourceId, parameters) {
+                  return this.style.querySourceFeatures(sourceId, parameters);
+                };
+                Map3.prototype.setStyle = function setStyle(style, options) {
+                  options = performance2.extend({}, { localIdeographFontFamily: this._localIdeographFontFamily }, options);
+                  if (options.diff !== false && options.localIdeographFontFamily === this._localIdeographFontFamily && this.style && style) {
+                    this._diffStyle(style, options);
+                    return this;
+                  } else {
+                    this._localIdeographFontFamily = options.localIdeographFontFamily;
+                    return this._updateStyle(style, options);
+                  }
+                };
+                Map3.prototype._getUIString = function _getUIString(key) {
+                  var str = this._locale[key];
+                  if (str == null) {
+                    throw new Error("Missing UI string '" + key + "'");
+                  }
+                  return str;
+                };
+                Map3.prototype._updateStyle = function _updateStyle(style, options) {
+                  if (this.style) {
+                    this.style.setEventedParent(null);
+                    this.style._remove();
+                  }
+                  if (!style) {
+                    delete this.style;
+                    return this;
+                  } else {
+                    this.style = new Style(this, options || {});
+                  }
+                  this.style.setEventedParent(this, { style: this.style });
+                  if (typeof style === "string") {
+                    this.style.loadURL(style);
+                  } else {
+                    this.style.loadJSON(style);
+                  }
+                  return this;
+                };
+                Map3.prototype._lazyInitEmptyStyle = function _lazyInitEmptyStyle() {
+                  if (!this.style) {
+                    this.style = new Style(this, {});
+                    this.style.setEventedParent(this, { style: this.style });
+                    this.style.loadEmpty();
+                  }
+                };
+                Map3.prototype._diffStyle = function _diffStyle(style, options) {
+                  var this$1$1 = this;
+                  if (typeof style === "string") {
+                    var url = this._requestManager.normalizeStyleURL(style);
+                    var request = this._requestManager.transformRequest(url, performance2.ResourceType.Style);
+                    performance2.getJSON(request, function(error, json) {
+                      if (error) {
+                        this$1$1.fire(new performance2.ErrorEvent(error));
+                      } else if (json) {
+                        this$1$1._updateDiff(json, options);
+                      }
+                    });
+                  } else if (typeof style === "object") {
+                    this._updateDiff(style, options);
+                  }
+                };
+                Map3.prototype._updateDiff = function _updateDiff(style, options) {
+                  try {
+                    if (this.style.setState(style)) {
+                      this._update(true);
+                    }
+                  } catch (e2) {
+                    performance2.warnOnce("Unable to perform style diff: " + (e2.message || e2.error || e2) + ".  Rebuilding the style from scratch.");
+                    this._updateStyle(style, options);
+                  }
+                };
+                Map3.prototype.getStyle = function getStyle() {
+                  if (this.style) {
+                    return this.style.serialize();
+                  }
+                };
+                Map3.prototype.isStyleLoaded = function isStyleLoaded() {
+                  if (!this.style) {
+                    return performance2.warnOnce("There is no style added to the map.");
+                  }
+                  return this.style.loaded();
+                };
+                Map3.prototype.addSource = function addSource2(id2, source2) {
+                  this._lazyInitEmptyStyle();
+                  this.style.addSource(id2, source2);
+                  return this._update(true);
+                };
+                Map3.prototype.isSourceLoaded = function isSourceLoaded(id2) {
+                  var source2 = this.style && this.style.sourceCaches[id2];
+                  if (source2 === void 0) {
+                    this.fire(new performance2.ErrorEvent(new Error("There is no source with ID '" + id2 + "'")));
+                    return;
+                  }
+                  return source2.loaded();
+                };
+                Map3.prototype.areTilesLoaded = function areTilesLoaded() {
+                  var sources = this.style && this.style.sourceCaches;
+                  for (var id2 in sources) {
+                    var source2 = sources[id2];
+                    var tiles = source2._tiles;
+                    for (var t4 in tiles) {
+                      var tile = tiles[t4];
+                      if (!(tile.state === "loaded" || tile.state === "errored")) {
+                        return false;
+                      }
+                    }
+                  }
+                  return true;
+                };
+                Map3.prototype.addSourceType = function addSourceType(name2, SourceType, callback) {
+                  this._lazyInitEmptyStyle();
+                  return this.style.addSourceType(name2, SourceType, callback);
+                };
+                Map3.prototype.removeSource = function removeSource2(id2) {
+                  this.style.removeSource(id2);
+                  return this._update(true);
+                };
+                Map3.prototype.getSource = function getSource(id2) {
+                  return this.style.getSource(id2);
+                };
+                Map3.prototype.addImage = function addImage(id2, image, ref) {
+                  if (ref === void 0)
+                    ref = {};
+                  var pixelRatio = ref.pixelRatio;
+                  if (pixelRatio === void 0)
+                    pixelRatio = 1;
+                  var sdf = ref.sdf;
+                  if (sdf === void 0)
+                    sdf = false;
+                  var stretchX = ref.stretchX;
+                  var stretchY = ref.stretchY;
+                  var content = ref.content;
+                  this._lazyInitEmptyStyle();
+                  var version2 = 0;
+                  if (image instanceof HTMLImageElement2 || ImageBitmap2 && image instanceof ImageBitmap2) {
+                    var ref$1 = performance2.browser.getImageData(image);
+                    var width = ref$1.width;
+                    var height = ref$1.height;
+                    var data = ref$1.data;
+                    this.style.addImage(id2, {
+                      data: new performance2.RGBAImage({
+                        width,
+                        height
+                      }, data),
+                      pixelRatio,
+                      stretchX,
+                      stretchY,
+                      content,
+                      sdf,
+                      version: version2
+                    });
+                  } else if (image.width === void 0 || image.height === void 0) {
+                    return this.fire(new performance2.ErrorEvent(new Error("Invalid arguments to map.addImage(). The second argument must be an `HTMLImageElement`, `ImageData`, `ImageBitmap`, or object with `width`, `height`, and `data` properties with the same format as `ImageData`")));
+                  } else {
+                    var width$1 = image.width;
+                    var height$1 = image.height;
+                    var data$1 = image.data;
+                    var userImage = image;
+                    this.style.addImage(id2, {
+                      data: new performance2.RGBAImage({
+                        width: width$1,
+                        height: height$1
+                      }, new Uint8Array(data$1)),
+                      pixelRatio,
+                      stretchX,
+                      stretchY,
+                      content,
+                      sdf,
+                      version: version2,
+                      userImage
+                    });
+                    if (userImage.onAdd) {
+                      userImage.onAdd(this, id2);
+                    }
+                  }
+                };
+                Map3.prototype.updateImage = function updateImage(id2, image) {
+                  var existingImage = this.style.getImage(id2);
+                  if (!existingImage) {
+                    return this.fire(new performance2.ErrorEvent(new Error("The map has no image with that id. If you are adding a new image use `map.addImage(...)` instead.")));
+                  }
+                  var imageData = image instanceof HTMLImageElement2 || ImageBitmap2 && image instanceof ImageBitmap2 ? performance2.browser.getImageData(image) : image;
+                  var width = imageData.width;
+                  var height = imageData.height;
+                  var data = imageData.data;
+                  if (width === void 0 || height === void 0) {
+                    return this.fire(new performance2.ErrorEvent(new Error("Invalid arguments to map.updateImage(). The second argument must be an `HTMLImageElement`, `ImageData`, `ImageBitmap`, or object with `width`, `height`, and `data` properties with the same format as `ImageData`")));
+                  }
+                  if (width !== existingImage.data.width || height !== existingImage.data.height) {
+                    return this.fire(new performance2.ErrorEvent(new Error("The width and height of the updated image must be that same as the previous version of the image")));
+                  }
+                  var copy = !(image instanceof HTMLImageElement2 || ImageBitmap2 && image instanceof ImageBitmap2);
+                  existingImage.data.replace(data, copy);
+                  this.style.updateImage(id2, existingImage);
+                };
+                Map3.prototype.hasImage = function hasImage(id2) {
+                  if (!id2) {
+                    this.fire(new performance2.ErrorEvent(new Error("Missing required image id")));
+                    return false;
+                  }
+                  return !!this.style.getImage(id2);
+                };
+                Map3.prototype.removeImage = function removeImage(id2) {
+                  this.style.removeImage(id2);
+                };
+                Map3.prototype.loadImage = function loadImage(url, callback) {
+                  performance2.getImage(this._requestManager.transformRequest(url, performance2.ResourceType.Image), callback);
+                };
+                Map3.prototype.listImages = function listImages() {
+                  return this.style.listImages();
+                };
+                Map3.prototype.addLayer = function addLayer(layer, beforeId) {
+                  this._lazyInitEmptyStyle();
+                  this.style.addLayer(layer, beforeId);
+                  return this._update(true);
+                };
+                Map3.prototype.moveLayer = function moveLayer(id2, beforeId) {
+                  this.style.moveLayer(id2, beforeId);
+                  return this._update(true);
+                };
+                Map3.prototype.removeLayer = function removeLayer(id2) {
+                  this.style.removeLayer(id2);
+                  return this._update(true);
+                };
+                Map3.prototype.getLayer = function getLayer(id2) {
+                  return this.style.getLayer(id2);
+                };
+                Map3.prototype.setLayerZoomRange = function setLayerZoomRange(layerId, minzoom, maxzoom) {
+                  this.style.setLayerZoomRange(layerId, minzoom, maxzoom);
+                  return this._update(true);
+                };
+                Map3.prototype.setFilter = function setFilter(layerId, filter, options) {
+                  if (options === void 0)
+                    options = {};
+                  this.style.setFilter(layerId, filter, options);
+                  return this._update(true);
+                };
+                Map3.prototype.getFilter = function getFilter(layerId) {
+                  return this.style.getFilter(layerId);
+                };
+                Map3.prototype.setPaintProperty = function setPaintProperty(layerId, name2, value, options) {
+                  if (options === void 0)
+                    options = {};
+                  this.style.setPaintProperty(layerId, name2, value, options);
+                  return this._update(true);
+                };
+                Map3.prototype.getPaintProperty = function getPaintProperty(layerId, name2) {
+                  return this.style.getPaintProperty(layerId, name2);
+                };
+                Map3.prototype.setLayoutProperty = function setLayoutProperty(layerId, name2, value, options) {
+                  if (options === void 0)
+                    options = {};
+                  this.style.setLayoutProperty(layerId, name2, value, options);
+                  return this._update(true);
+                };
+                Map3.prototype.getLayoutProperty = function getLayoutProperty(layerId, name2) {
+                  return this.style.getLayoutProperty(layerId, name2);
+                };
+                Map3.prototype.setLight = function setLight(light, options) {
+                  if (options === void 0)
+                    options = {};
+                  this._lazyInitEmptyStyle();
+                  this.style.setLight(light, options);
+                  return this._update(true);
+                };
+                Map3.prototype.getLight = function getLight() {
+                  return this.style.getLight();
+                };
+                Map3.prototype.setFeatureState = function setFeatureState(feature, state) {
+                  this.style.setFeatureState(feature, state);
+                  return this._update();
+                };
+                Map3.prototype.removeFeatureState = function removeFeatureState(target, key) {
+                  this.style.removeFeatureState(target, key);
+                  return this._update();
+                };
+                Map3.prototype.getFeatureState = function getFeatureState(feature) {
+                  return this.style.getFeatureState(feature);
+                };
+                Map3.prototype.getContainer = function getContainer2() {
+                  return this._container;
+                };
+                Map3.prototype.getCanvasContainer = function getCanvasContainer() {
+                  return this._canvasContainer;
+                };
+                Map3.prototype.getCanvas = function getCanvas() {
+                  return this._canvas;
+                };
+                Map3.prototype._containerDimensions = function _containerDimensions() {
+                  var width = 0;
+                  var height = 0;
+                  if (this._container) {
+                    width = this._container.clientWidth || 400;
+                    height = this._container.clientHeight || 300;
+                  }
+                  return [
+                    width,
+                    height
+                  ];
+                };
+                Map3.prototype._detectMissingCSS = function _detectMissingCSS() {
+                  var computedColor = performance2.window.getComputedStyle(this._missingCSSCanary).getPropertyValue("background-color");
+                  if (computedColor !== "rgb(250, 128, 114)") {
+                    performance2.warnOnce("This page appears to be missing CSS declarations for Mapbox GL JS, which may cause the map to display incorrectly. Please ensure your page includes mapbox-gl.css, as described in https://www.mapbox.com/mapbox-gl-js/api/.");
+                  }
+                };
+                Map3.prototype._setupContainer = function _setupContainer() {
+                  var container = this._container;
+                  container.classList.add("mapboxgl-map");
+                  var missingCSSCanary = this._missingCSSCanary = DOM.create("div", "mapboxgl-canary", container);
+                  missingCSSCanary.style.visibility = "hidden";
+                  this._detectMissingCSS();
+                  var canvasContainer = this._canvasContainer = DOM.create("div", "mapboxgl-canvas-container", container);
+                  if (this._interactive) {
+                    canvasContainer.classList.add("mapboxgl-interactive");
+                  }
+                  this._canvas = DOM.create("canvas", "mapboxgl-canvas", canvasContainer);
+                  this._canvas.addEventListener("webglcontextlost", this._contextLost, false);
+                  this._canvas.addEventListener("webglcontextrestored", this._contextRestored, false);
+                  this._canvas.setAttribute("tabindex", "0");
+                  this._canvas.setAttribute("aria-label", "Map");
+                  this._canvas.setAttribute("role", "region");
+                  var dimensions = this._containerDimensions();
+                  this._resizeCanvas(dimensions[0], dimensions[1]);
+                  var controlContainer = this._controlContainer = DOM.create("div", "mapboxgl-control-container", container);
+                  var positions = this._controlPositions = {};
+                  [
+                    "top-left",
+                    "top-right",
+                    "bottom-left",
+                    "bottom-right"
+                  ].forEach(function(positionName) {
+                    positions[positionName] = DOM.create("div", "mapboxgl-ctrl-" + positionName, controlContainer);
+                  });
+                  this._container.addEventListener("scroll", this._onMapScroll, false);
+                };
+                Map3.prototype._resizeCanvas = function _resizeCanvas(width, height) {
+                  var pixelRatio = performance2.browser.devicePixelRatio || 1;
+                  this._canvas.width = pixelRatio * width;
+                  this._canvas.height = pixelRatio * height;
+                  this._canvas.style.width = width + "px";
+                  this._canvas.style.height = height + "px";
+                };
+                Map3.prototype._setupPainter = function _setupPainter() {
+                  var attributes = performance2.extend({}, mapboxGlSupported.webGLContextAttributes, {
+                    failIfMajorPerformanceCaveat: this._failIfMajorPerformanceCaveat,
+                    preserveDrawingBuffer: this._preserveDrawingBuffer,
+                    antialias: this._antialias || false
+                  });
+                  var gl2 = this._canvas.getContext("webgl", attributes) || this._canvas.getContext("experimental-webgl", attributes);
+                  if (!gl2) {
+                    this.fire(new performance2.ErrorEvent(new Error("Failed to initialize WebGL")));
+                    return;
+                  }
+                  this.painter = new Painter(gl2, this.transform);
+                  performance2.webpSupported.testSupport(gl2);
+                };
+                Map3.prototype._contextLost = function _contextLost(event) {
+                  event.preventDefault();
+                  if (this._frame) {
+                    this._frame.cancel();
+                    this._frame = null;
+                  }
+                  this.fire(new performance2.Event("webglcontextlost", { originalEvent: event }));
+                };
+                Map3.prototype._contextRestored = function _contextRestored(event) {
+                  this._setupPainter();
+                  this.resize();
+                  this._update();
+                  this.fire(new performance2.Event("webglcontextrestored", { originalEvent: event }));
+                };
+                Map3.prototype._onMapScroll = function _onMapScroll(event) {
+                  if (event.target !== this._container) {
+                    return;
+                  }
+                  this._container.scrollTop = 0;
+                  this._container.scrollLeft = 0;
+                  return false;
+                };
+                Map3.prototype.loaded = function loaded() {
+                  return !this._styleDirty && !this._sourcesDirty && !!this.style && this.style.loaded();
+                };
+                Map3.prototype._update = function _update(updateStyle) {
+                  if (!this.style) {
+                    return this;
+                  }
+                  this._styleDirty = this._styleDirty || updateStyle;
+                  this._sourcesDirty = true;
+                  this.triggerRepaint();
+                  return this;
+                };
+                Map3.prototype._requestRenderFrame = function _requestRenderFrame(callback) {
+                  this._update();
+                  return this._renderTaskQueue.add(callback);
+                };
+                Map3.prototype._cancelRenderFrame = function _cancelRenderFrame(id2) {
+                  this._renderTaskQueue.remove(id2);
+                };
+                Map3.prototype._render = function _render(paintStartTimeStamp) {
+                  var this$1$1 = this;
+                  var gpuTimer, frameStartTime = 0;
+                  var extTimerQuery = this.painter.context.extTimerQuery;
+                  if (this.listens("gpu-timing-frame")) {
+                    gpuTimer = extTimerQuery.createQueryEXT();
+                    extTimerQuery.beginQueryEXT(extTimerQuery.TIME_ELAPSED_EXT, gpuTimer);
+                    frameStartTime = performance2.browser.now();
+                  }
+                  this.painter.context.setDirty();
+                  this.painter.setBaseState();
+                  this._renderTaskQueue.run(paintStartTimeStamp);
+                  if (this._removed) {
+                    return;
+                  }
+                  var crossFading = false;
+                  if (this.style && this._styleDirty) {
+                    this._styleDirty = false;
+                    var zoom = this.transform.zoom;
+                    var now = performance2.browser.now();
+                    this.style.zoomHistory.update(zoom, now);
+                    var parameters = new performance2.EvaluationParameters(zoom, {
+                      now,
+                      fadeDuration: this._fadeDuration,
+                      zoomHistory: this.style.zoomHistory,
+                      transition: this.style.getTransition()
+                    });
+                    var factor = parameters.crossFadingFactor();
+                    if (factor !== 1 || factor !== this._crossFadingFactor) {
+                      crossFading = true;
+                      this._crossFadingFactor = factor;
+                    }
+                    this.style.update(parameters);
+                  }
+                  if (this.style && this._sourcesDirty) {
+                    this._sourcesDirty = false;
+                    this.style._updateSources(this.transform);
+                  }
+                  this._placementDirty = this.style && this.style._updatePlacement(this.painter.transform, this.showCollisionBoxes, this._fadeDuration, this._crossSourceCollisions);
+                  this.painter.render(this.style, {
+                    showTileBoundaries: this.showTileBoundaries,
+                    showOverdrawInspector: this._showOverdrawInspector,
+                    rotating: this.isRotating(),
+                    zooming: this.isZooming(),
+                    moving: this.isMoving(),
+                    fadeDuration: this._fadeDuration,
+                    showPadding: this.showPadding,
+                    gpuTiming: !!this.listens("gpu-timing-layer")
+                  });
+                  this.fire(new performance2.Event("render"));
+                  if (this.loaded() && !this._loaded) {
+                    this._loaded = true;
+                    this.fire(new performance2.Event("load"));
+                  }
+                  if (this.style && (this.style.hasTransitions() || crossFading)) {
+                    this._styleDirty = true;
+                  }
+                  if (this.style && !this._placementDirty) {
+                    this.style._releaseSymbolFadeTiles();
+                  }
+                  if (this.listens("gpu-timing-frame")) {
+                    var renderCPUTime = performance2.browser.now() - frameStartTime;
+                    extTimerQuery.endQueryEXT(extTimerQuery.TIME_ELAPSED_EXT, gpuTimer);
+                    setTimeout(function() {
+                      var renderGPUTime = extTimerQuery.getQueryObjectEXT(gpuTimer, extTimerQuery.QUERY_RESULT_EXT) / (1e3 * 1e3);
+                      extTimerQuery.deleteQueryEXT(gpuTimer);
+                      this$1$1.fire(new performance2.Event("gpu-timing-frame", {
+                        cpuTime: renderCPUTime,
+                        gpuTime: renderGPUTime
+                      }));
+                    }, 50);
+                  }
+                  if (this.listens("gpu-timing-layer")) {
+                    var frameLayerQueries = this.painter.collectGpuTimers();
+                    setTimeout(function() {
+                      var renderedLayerTimes = this$1$1.painter.queryGpuTimers(frameLayerQueries);
+                      this$1$1.fire(new performance2.Event("gpu-timing-layer", { layerTimes: renderedLayerTimes }));
+                    }, 50);
+                  }
+                  var somethingDirty = this._sourcesDirty || this._styleDirty || this._placementDirty;
+                  if (somethingDirty || this._repaint) {
+                    this.triggerRepaint();
+                  } else if (!this.isMoving() && this.loaded()) {
+                    this.fire(new performance2.Event("idle"));
+                  }
+                  if (this._loaded && !this._fullyLoaded && !somethingDirty) {
+                    this._fullyLoaded = true;
+                  }
+                  return this;
+                };
+                Map3.prototype.remove = function remove() {
+                  if (this._hash) {
+                    this._hash.remove();
+                  }
+                  for (var i2 = 0, list = this._controls; i2 < list.length; i2 += 1) {
+                    var control = list[i2];
+                    control.onRemove(this);
+                  }
+                  this._controls = [];
+                  if (this._frame) {
+                    this._frame.cancel();
+                    this._frame = null;
+                  }
+                  this._renderTaskQueue.clear();
+                  this.painter.destroy();
+                  this.handlers.destroy();
+                  delete this.handlers;
+                  this.setStyle(null);
+                  if (typeof performance2.window !== "undefined") {
+                    performance2.window.removeEventListener("resize", this._onWindowResize, false);
+                    performance2.window.removeEventListener("orientationchange", this._onWindowResize, false);
+                    performance2.window.removeEventListener("online", this._onWindowOnline, false);
+                  }
+                  var extension = this.painter.context.gl.getExtension("WEBGL_lose_context");
+                  if (extension && extension.loseContext) {
+                    extension.loseContext();
+                  }
+                  removeNode(this._canvasContainer);
+                  removeNode(this._controlContainer);
+                  removeNode(this._missingCSSCanary);
+                  this._container.classList.remove("mapboxgl-map");
+                  this._removed = true;
+                  this.fire(new performance2.Event("remove"));
+                };
+                Map3.prototype.triggerRepaint = function triggerRepaint() {
+                  var this$1$1 = this;
+                  if (this.style && !this._frame) {
+                    this._frame = performance2.browser.frame(function(paintStartTimeStamp) {
+                      this$1$1._frame = null;
+                      this$1$1._render(paintStartTimeStamp);
+                    });
+                  }
+                };
+                Map3.prototype._onWindowOnline = function _onWindowOnline() {
+                  this._update();
+                };
+                Map3.prototype._onWindowResize = function _onWindowResize(event) {
+                  if (this._trackResize) {
+                    this.resize({ originalEvent: event })._update();
+                  }
+                };
+                prototypeAccessors2.showTileBoundaries.get = function() {
+                  return !!this._showTileBoundaries;
+                };
+                prototypeAccessors2.showTileBoundaries.set = function(value) {
+                  if (this._showTileBoundaries === value) {
+                    return;
+                  }
+                  this._showTileBoundaries = value;
+                  this._update();
+                };
+                prototypeAccessors2.showPadding.get = function() {
+                  return !!this._showPadding;
+                };
+                prototypeAccessors2.showPadding.set = function(value) {
+                  if (this._showPadding === value) {
+                    return;
+                  }
+                  this._showPadding = value;
+                  this._update();
+                };
+                prototypeAccessors2.showCollisionBoxes.get = function() {
+                  return !!this._showCollisionBoxes;
+                };
+                prototypeAccessors2.showCollisionBoxes.set = function(value) {
+                  if (this._showCollisionBoxes === value) {
+                    return;
+                  }
+                  this._showCollisionBoxes = value;
+                  if (value) {
+                    this.style._generateCollisionBoxes();
+                  } else {
+                    this._update();
+                  }
+                };
+                prototypeAccessors2.showOverdrawInspector.get = function() {
+                  return !!this._showOverdrawInspector;
+                };
+                prototypeAccessors2.showOverdrawInspector.set = function(value) {
+                  if (this._showOverdrawInspector === value) {
+                    return;
+                  }
+                  this._showOverdrawInspector = value;
+                  this._update();
+                };
+                prototypeAccessors2.repaint.get = function() {
+                  return !!this._repaint;
+                };
+                prototypeAccessors2.repaint.set = function(value) {
+                  if (this._repaint !== value) {
+                    this._repaint = value;
+                    this.triggerRepaint();
+                  }
+                };
+                prototypeAccessors2.vertices.get = function() {
+                  return !!this._vertices;
+                };
+                prototypeAccessors2.vertices.set = function(value) {
+                  this._vertices = value;
+                  this._update();
+                };
+                Map3.prototype._setCacheLimits = function _setCacheLimits(limit, checkThreshold) {
+                  performance2.setCacheLimits(limit, checkThreshold);
+                };
+                prototypeAccessors2.version.get = function() {
+                  return performance2.version;
+                };
+                Object.defineProperties(Map3.prototype, prototypeAccessors2);
+                return Map3;
+              }(Camera);
+              function removeNode(node) {
+                if (node.parentNode) {
+                  node.parentNode.removeChild(node);
+                }
+              }
+              var defaultOptions$2 = {
+                showCompass: true,
+                showZoom: true,
+                visualizePitch: false
+              };
+              var NavigationControl = function NavigationControl2(options) {
+                var this$1$1 = this;
+                this.options = performance2.extend({}, defaultOptions$2, options);
+                this._container = DOM.create("div", "mapboxgl-ctrl mapboxgl-ctrl-group");
+                this._container.addEventListener("contextmenu", function(e2) {
+                  return e2.preventDefault();
+                });
+                if (this.options.showZoom) {
+                  performance2.bindAll([
+                    "_setButtonTitle",
+                    "_updateZoomButtons"
+                  ], this);
+                  this._zoomInButton = this._createButton("mapboxgl-ctrl-zoom-in", function(e2) {
+                    return this$1$1._map.zoomIn({}, { originalEvent: e2 });
+                  });
+                  DOM.create("span", "mapboxgl-ctrl-icon", this._zoomInButton).setAttribute("aria-hidden", true);
+                  this._zoomOutButton = this._createButton("mapboxgl-ctrl-zoom-out", function(e2) {
+                    return this$1$1._map.zoomOut({}, { originalEvent: e2 });
+                  });
+                  DOM.create("span", "mapboxgl-ctrl-icon", this._zoomOutButton).setAttribute("aria-hidden", true);
+                }
+                if (this.options.showCompass) {
+                  performance2.bindAll(["_rotateCompassArrow"], this);
+                  this._compass = this._createButton("mapboxgl-ctrl-compass", function(e2) {
+                    if (this$1$1.options.visualizePitch) {
+                      this$1$1._map.resetNorthPitch({}, { originalEvent: e2 });
+                    } else {
+                      this$1$1._map.resetNorth({}, { originalEvent: e2 });
+                    }
+                  });
+                  this._compassIcon = DOM.create("span", "mapboxgl-ctrl-icon", this._compass);
+                  this._compassIcon.setAttribute("aria-hidden", true);
+                }
+              };
+              NavigationControl.prototype._updateZoomButtons = function _updateZoomButtons() {
+                var zoom = this._map.getZoom();
+                var isMax = zoom === this._map.getMaxZoom();
+                var isMin = zoom === this._map.getMinZoom();
+                this._zoomInButton.disabled = isMax;
+                this._zoomOutButton.disabled = isMin;
+                this._zoomInButton.setAttribute("aria-disabled", isMax.toString());
+                this._zoomOutButton.setAttribute("aria-disabled", isMin.toString());
+              };
+              NavigationControl.prototype._rotateCompassArrow = function _rotateCompassArrow() {
+                var rotate2 = this.options.visualizePitch ? "scale(" + 1 / Math.pow(Math.cos(this._map.transform.pitch * (Math.PI / 180)), 0.5) + ") rotateX(" + this._map.transform.pitch + "deg) rotateZ(" + this._map.transform.angle * (180 / Math.PI) + "deg)" : "rotate(" + this._map.transform.angle * (180 / Math.PI) + "deg)";
+                this._compassIcon.style.transform = rotate2;
+              };
+              NavigationControl.prototype.onAdd = function onAdd(map2) {
+                this._map = map2;
+                if (this.options.showZoom) {
+                  this._setButtonTitle(this._zoomInButton, "ZoomIn");
+                  this._setButtonTitle(this._zoomOutButton, "ZoomOut");
+                  this._map.on("zoom", this._updateZoomButtons);
+                  this._updateZoomButtons();
+                }
+                if (this.options.showCompass) {
+                  this._setButtonTitle(this._compass, "ResetBearing");
+                  if (this.options.visualizePitch) {
+                    this._map.on("pitch", this._rotateCompassArrow);
+                  }
+                  this._map.on("rotate", this._rotateCompassArrow);
+                  this._rotateCompassArrow();
+                  this._handler = new MouseRotateWrapper(this._map, this._compass, this.options.visualizePitch);
+                }
+                return this._container;
+              };
+              NavigationControl.prototype.onRemove = function onRemove() {
+                DOM.remove(this._container);
+                if (this.options.showZoom) {
+                  this._map.off("zoom", this._updateZoomButtons);
+                }
+                if (this.options.showCompass) {
+                  if (this.options.visualizePitch) {
+                    this._map.off("pitch", this._rotateCompassArrow);
+                  }
+                  this._map.off("rotate", this._rotateCompassArrow);
+                  this._handler.off();
+                  delete this._handler;
+                }
+                delete this._map;
+              };
+              NavigationControl.prototype._createButton = function _createButton(className, fn) {
+                var a2 = DOM.create("button", className, this._container);
+                a2.type = "button";
+                a2.addEventListener("click", fn);
+                return a2;
+              };
+              NavigationControl.prototype._setButtonTitle = function _setButtonTitle(button, title) {
+                var str = this._map._getUIString("NavigationControl." + title);
+                button.title = str;
+                button.setAttribute("aria-label", str);
+              };
+              var MouseRotateWrapper = function MouseRotateWrapper2(map2, element, pitch) {
+                if (pitch === void 0)
+                  pitch = false;
+                this._clickTolerance = 10;
+                this.element = element;
+                this.mouseRotate = new MouseRotateHandler({ clickTolerance: map2.dragRotate._mouseRotate._clickTolerance });
+                this.map = map2;
+                if (pitch) {
+                  this.mousePitch = new MousePitchHandler({ clickTolerance: map2.dragRotate._mousePitch._clickTolerance });
+                }
+                performance2.bindAll([
+                  "mousedown",
+                  "mousemove",
+                  "mouseup",
+                  "touchstart",
+                  "touchmove",
+                  "touchend",
+                  "reset"
+                ], this);
+                DOM.addEventListener(element, "mousedown", this.mousedown);
+                DOM.addEventListener(element, "touchstart", this.touchstart, { passive: false });
+                DOM.addEventListener(element, "touchmove", this.touchmove);
+                DOM.addEventListener(element, "touchend", this.touchend);
+                DOM.addEventListener(element, "touchcancel", this.reset);
+              };
+              MouseRotateWrapper.prototype.down = function down(e2, point) {
+                this.mouseRotate.mousedown(e2, point);
+                if (this.mousePitch) {
+                  this.mousePitch.mousedown(e2, point);
+                }
+                DOM.disableDrag();
+              };
+              MouseRotateWrapper.prototype.move = function move(e2, point) {
+                var map2 = this.map;
+                var r2 = this.mouseRotate.mousemoveWindow(e2, point);
+                if (r2 && r2.bearingDelta) {
+                  map2.setBearing(map2.getBearing() + r2.bearingDelta);
+                }
+                if (this.mousePitch) {
+                  var p2 = this.mousePitch.mousemoveWindow(e2, point);
+                  if (p2 && p2.pitchDelta) {
+                    map2.setPitch(map2.getPitch() + p2.pitchDelta);
+                  }
+                }
+              };
+              MouseRotateWrapper.prototype.off = function off() {
+                var element = this.element;
+                DOM.removeEventListener(element, "mousedown", this.mousedown);
+                DOM.removeEventListener(element, "touchstart", this.touchstart, { passive: false });
+                DOM.removeEventListener(element, "touchmove", this.touchmove);
+                DOM.removeEventListener(element, "touchend", this.touchend);
+                DOM.removeEventListener(element, "touchcancel", this.reset);
+                this.offTemp();
+              };
+              MouseRotateWrapper.prototype.offTemp = function offTemp() {
+                DOM.enableDrag();
+                DOM.removeEventListener(performance2.window, "mousemove", this.mousemove);
+                DOM.removeEventListener(performance2.window, "mouseup", this.mouseup);
+              };
+              MouseRotateWrapper.prototype.mousedown = function mousedown(e2) {
+                this.down(performance2.extend({}, e2, {
+                  ctrlKey: true,
+                  preventDefault: function() {
+                    return e2.preventDefault();
+                  }
+                }), DOM.mousePos(this.element, e2));
+                DOM.addEventListener(performance2.window, "mousemove", this.mousemove);
+                DOM.addEventListener(performance2.window, "mouseup", this.mouseup);
+              };
+              MouseRotateWrapper.prototype.mousemove = function mousemove(e2) {
+                this.move(e2, DOM.mousePos(this.element, e2));
+              };
+              MouseRotateWrapper.prototype.mouseup = function mouseup(e2) {
+                this.mouseRotate.mouseupWindow(e2);
+                if (this.mousePitch) {
+                  this.mousePitch.mouseupWindow(e2);
+                }
+                this.offTemp();
+              };
+              MouseRotateWrapper.prototype.touchstart = function touchstart(e2) {
+                if (e2.targetTouches.length !== 1) {
+                  this.reset();
+                } else {
+                  this._startPos = this._lastPos = DOM.touchPos(this.element, e2.targetTouches)[0];
+                  this.down({
+                    type: "mousedown",
+                    button: 0,
+                    ctrlKey: true,
+                    preventDefault: function() {
+                      return e2.preventDefault();
+                    }
+                  }, this._startPos);
+                }
+              };
+              MouseRotateWrapper.prototype.touchmove = function touchmove(e2) {
+                if (e2.targetTouches.length !== 1) {
+                  this.reset();
+                } else {
+                  this._lastPos = DOM.touchPos(this.element, e2.targetTouches)[0];
+                  this.move({
+                    preventDefault: function() {
+                      return e2.preventDefault();
+                    }
+                  }, this._lastPos);
+                }
+              };
+              MouseRotateWrapper.prototype.touchend = function touchend(e2) {
+                if (e2.targetTouches.length === 0 && this._startPos && this._lastPos && this._startPos.dist(this._lastPos) < this._clickTolerance) {
+                  this.element.click();
+                }
+                this.reset();
+              };
+              MouseRotateWrapper.prototype.reset = function reset() {
+                this.mouseRotate.reset();
+                if (this.mousePitch) {
+                  this.mousePitch.reset();
+                }
+                delete this._startPos;
+                delete this._lastPos;
+                this.offTemp();
+              };
+              function smartWrap(lngLat, priorPos, transform) {
+                lngLat = new performance2.LngLat(lngLat.lng, lngLat.lat);
+                if (priorPos) {
+                  var left = new performance2.LngLat(lngLat.lng - 360, lngLat.lat);
+                  var right = new performance2.LngLat(lngLat.lng + 360, lngLat.lat);
+                  var delta = transform.locationPoint(lngLat).distSqr(priorPos);
+                  if (transform.locationPoint(left).distSqr(priorPos) < delta) {
+                    lngLat = left;
+                  } else if (transform.locationPoint(right).distSqr(priorPos) < delta) {
+                    lngLat = right;
+                  }
+                }
+                while (Math.abs(lngLat.lng - transform.center.lng) > 180) {
+                  var pos = transform.locationPoint(lngLat);
+                  if (pos.x >= 0 && pos.y >= 0 && pos.x <= transform.width && pos.y <= transform.height) {
+                    break;
+                  }
+                  if (lngLat.lng > transform.center.lng) {
+                    lngLat.lng -= 360;
+                  } else {
+                    lngLat.lng += 360;
+                  }
+                }
+                return lngLat;
+              }
+              var anchorTranslate = {
+                "center": "translate(-50%,-50%)",
+                "top": "translate(-50%,0)",
+                "top-left": "translate(0,0)",
+                "top-right": "translate(-100%,0)",
+                "bottom": "translate(-50%,-100%)",
+                "bottom-left": "translate(0,-100%)",
+                "bottom-right": "translate(-100%,-100%)",
+                "left": "translate(0,-50%)",
+                "right": "translate(-100%,-50%)"
+              };
+              function applyAnchorClass(element, anchor, prefix) {
+                var classList = element.classList;
+                for (var key in anchorTranslate) {
+                  classList.remove("mapboxgl-" + prefix + "-anchor-" + key);
+                }
+                classList.add("mapboxgl-" + prefix + "-anchor-" + anchor);
+              }
+              var Marker = function(Evented) {
+                function Marker2(options, legacyOptions) {
+                  Evented.call(this);
+                  if (options instanceof performance2.window.HTMLElement || legacyOptions) {
+                    options = performance2.extend({ element: options }, legacyOptions);
+                  }
+                  performance2.bindAll([
+                    "_update",
+                    "_onMove",
+                    "_onUp",
+                    "_addDragHandler",
+                    "_onMapClick",
+                    "_onKeyPress"
+                  ], this);
+                  this._anchor = options && options.anchor || "center";
+                  this._color = options && options.color || "#3FB1CE";
+                  this._scale = options && options.scale || 1;
+                  this._draggable = options && options.draggable || false;
+                  this._clickTolerance = options && options.clickTolerance || 0;
+                  this._isDragging = false;
+                  this._state = "inactive";
+                  this._rotation = options && options.rotation || 0;
+                  this._rotationAlignment = options && options.rotationAlignment || "auto";
+                  this._pitchAlignment = options && options.pitchAlignment && options.pitchAlignment !== "auto" ? options.pitchAlignment : this._rotationAlignment;
+                  if (!options || !options.element) {
+                    this._defaultMarker = true;
+                    this._element = DOM.create("div");
+                    this._element.setAttribute("aria-label", "Map marker");
+                    var svg = DOM.createNS("http://www.w3.org/2000/svg", "svg");
+                    var defaultHeight = 41;
+                    var defaultWidth = 27;
+                    svg.setAttributeNS(null, "display", "block");
+                    svg.setAttributeNS(null, "height", defaultHeight + "px");
+                    svg.setAttributeNS(null, "width", defaultWidth + "px");
+                    svg.setAttributeNS(null, "viewBox", "0 0 " + defaultWidth + " " + defaultHeight);
+                    var markerLarge = DOM.createNS("http://www.w3.org/2000/svg", "g");
+                    markerLarge.setAttributeNS(null, "stroke", "none");
+                    markerLarge.setAttributeNS(null, "stroke-width", "1");
+                    markerLarge.setAttributeNS(null, "fill", "none");
+                    markerLarge.setAttributeNS(null, "fill-rule", "evenodd");
+                    var page1 = DOM.createNS("http://www.w3.org/2000/svg", "g");
+                    page1.setAttributeNS(null, "fill-rule", "nonzero");
+                    var shadow2 = DOM.createNS("http://www.w3.org/2000/svg", "g");
+                    shadow2.setAttributeNS(null, "transform", "translate(3.0, 29.0)");
+                    shadow2.setAttributeNS(null, "fill", "#000000");
+                    var ellipses = [
+                      {
+                        "rx": "10.5",
+                        "ry": "5.25002273"
+                      },
+                      {
+                        "rx": "10.5",
+                        "ry": "5.25002273"
+                      },
+                      {
+                        "rx": "9.5",
+                        "ry": "4.77275007"
+                      },
+                      {
+                        "rx": "8.5",
+                        "ry": "4.29549936"
+                      },
+                      {
+                        "rx": "7.5",
+                        "ry": "3.81822308"
+                      },
+                      {
+                        "rx": "6.5",
+                        "ry": "3.34094679"
+                      },
+                      {
+                        "rx": "5.5",
+                        "ry": "2.86367051"
+                      },
+                      {
+                        "rx": "4.5",
+                        "ry": "2.38636864"
+                      }
+                    ];
+                    for (var i2 = 0, list = ellipses; i2 < list.length; i2 += 1) {
+                      var data = list[i2];
+                      var ellipse = DOM.createNS("http://www.w3.org/2000/svg", "ellipse");
+                      ellipse.setAttributeNS(null, "opacity", "0.04");
+                      ellipse.setAttributeNS(null, "cx", "10.5");
+                      ellipse.setAttributeNS(null, "cy", "5.80029008");
+                      ellipse.setAttributeNS(null, "rx", data["rx"]);
+                      ellipse.setAttributeNS(null, "ry", data["ry"]);
+                      shadow2.appendChild(ellipse);
+                    }
+                    var background2 = DOM.createNS("http://www.w3.org/2000/svg", "g");
+                    background2.setAttributeNS(null, "fill", this._color);
+                    var bgPath = DOM.createNS("http://www.w3.org/2000/svg", "path");
+                    bgPath.setAttributeNS(null, "d", "M27,13.5 C27,19.074644 20.250001,27.000002 14.75,34.500002 C14.016665,35.500004 12.983335,35.500004 12.25,34.500002 C6.7499993,27.000002 0,19.222562 0,13.5 C0,6.0441559 6.0441559,0 13.5,0 C20.955844,0 27,6.0441559 27,13.5 Z");
+                    background2.appendChild(bgPath);
+                    var border = DOM.createNS("http://www.w3.org/2000/svg", "g");
+                    border.setAttributeNS(null, "opacity", "0.25");
+                    border.setAttributeNS(null, "fill", "#000000");
+                    var borderPath = DOM.createNS("http://www.w3.org/2000/svg", "path");
+                    borderPath.setAttributeNS(null, "d", "M13.5,0 C6.0441559,0 0,6.0441559 0,13.5 C0,19.222562 6.7499993,27 12.25,34.5 C13,35.522727 14.016664,35.500004 14.75,34.5 C20.250001,27 27,19.074644 27,13.5 C27,6.0441559 20.955844,0 13.5,0 Z M13.5,1 C20.415404,1 26,6.584596 26,13.5 C26,15.898657 24.495584,19.181431 22.220703,22.738281 C19.945823,26.295132 16.705119,30.142167 13.943359,33.908203 C13.743445,34.180814 13.612715,34.322738 13.5,34.441406 C13.387285,34.322738 13.256555,34.180814 13.056641,33.908203 C10.284481,30.127985 7.4148684,26.314159 5.015625,22.773438 C2.6163816,19.232715 1,15.953538 1,13.5 C1,6.584596 6.584596,1 13.5,1 Z");
+                    border.appendChild(borderPath);
+                    var maki = DOM.createNS("http://www.w3.org/2000/svg", "g");
+                    maki.setAttributeNS(null, "transform", "translate(6.0, 7.0)");
+                    maki.setAttributeNS(null, "fill", "#FFFFFF");
+                    var circleContainer = DOM.createNS("http://www.w3.org/2000/svg", "g");
+                    circleContainer.setAttributeNS(null, "transform", "translate(8.0, 8.0)");
+                    var circle1 = DOM.createNS("http://www.w3.org/2000/svg", "circle");
+                    circle1.setAttributeNS(null, "fill", "#000000");
+                    circle1.setAttributeNS(null, "opacity", "0.25");
+                    circle1.setAttributeNS(null, "cx", "5.5");
+                    circle1.setAttributeNS(null, "cy", "5.5");
+                    circle1.setAttributeNS(null, "r", "5.4999962");
+                    var circle2 = DOM.createNS("http://www.w3.org/2000/svg", "circle");
+                    circle2.setAttributeNS(null, "fill", "#FFFFFF");
+                    circle2.setAttributeNS(null, "cx", "5.5");
+                    circle2.setAttributeNS(null, "cy", "5.5");
+                    circle2.setAttributeNS(null, "r", "5.4999962");
+                    circleContainer.appendChild(circle1);
+                    circleContainer.appendChild(circle2);
+                    page1.appendChild(shadow2);
+                    page1.appendChild(background2);
+                    page1.appendChild(border);
+                    page1.appendChild(maki);
+                    page1.appendChild(circleContainer);
+                    svg.appendChild(page1);
+                    svg.setAttributeNS(null, "height", defaultHeight * this._scale + "px");
+                    svg.setAttributeNS(null, "width", defaultWidth * this._scale + "px");
+                    this._element.appendChild(svg);
+                    this._offset = performance2.Point.convert(options && options.offset || [
+                      0,
+                      -14
+                    ]);
+                  } else {
+                    this._element = options.element;
+                    this._offset = performance2.Point.convert(options && options.offset || [
+                      0,
+                      0
+                    ]);
+                  }
+                  this._element.classList.add("mapboxgl-marker");
+                  this._element.addEventListener("dragstart", function(e2) {
+                    e2.preventDefault();
+                  });
+                  this._element.addEventListener("mousedown", function(e2) {
+                    e2.preventDefault();
+                  });
+                  applyAnchorClass(this._element, this._anchor, "marker");
+                  this._popup = null;
+                }
+                if (Evented)
+                  Marker2.__proto__ = Evented;
+                Marker2.prototype = Object.create(Evented && Evented.prototype);
+                Marker2.prototype.constructor = Marker2;
+                Marker2.prototype.addTo = function addTo(map2) {
+                  this.remove();
+                  this._map = map2;
+                  map2.getCanvasContainer().appendChild(this._element);
+                  map2.on("move", this._update);
+                  map2.on("moveend", this._update);
+                  this.setDraggable(this._draggable);
+                  this._update();
+                  this._map.on("click", this._onMapClick);
+                  return this;
+                };
+                Marker2.prototype.remove = function remove() {
+                  if (this._map) {
+                    this._map.off("click", this._onMapClick);
+                    this._map.off("move", this._update);
+                    this._map.off("moveend", this._update);
+                    this._map.off("mousedown", this._addDragHandler);
+                    this._map.off("touchstart", this._addDragHandler);
+                    this._map.off("mouseup", this._onUp);
+                    this._map.off("touchend", this._onUp);
+                    this._map.off("mousemove", this._onMove);
+                    this._map.off("touchmove", this._onMove);
+                    delete this._map;
+                  }
+                  DOM.remove(this._element);
+                  if (this._popup) {
+                    this._popup.remove();
+                  }
+                  return this;
+                };
+                Marker2.prototype.getLngLat = function getLngLat() {
+                  return this._lngLat;
+                };
+                Marker2.prototype.setLngLat = function setLngLat(lnglat) {
+                  this._lngLat = performance2.LngLat.convert(lnglat);
+                  this._pos = null;
+                  if (this._popup) {
+                    this._popup.setLngLat(this._lngLat);
+                  }
+                  this._update();
+                  return this;
+                };
+                Marker2.prototype.getElement = function getElement() {
+                  return this._element;
+                };
+                Marker2.prototype.setPopup = function setPopup(popup) {
+                  if (this._popup) {
+                    this._popup.remove();
+                    this._popup = null;
+                    this._element.removeEventListener("keypress", this._onKeyPress);
+                    if (!this._originalTabIndex) {
+                      this._element.removeAttribute("tabindex");
+                    }
+                  }
+                  if (popup) {
+                    if (!("offset" in popup.options)) {
+                      var markerHeight = 41 - 5.8 / 2;
+                      var markerRadius = 13.5;
+                      var linearOffset = Math.sqrt(Math.pow(markerRadius, 2) / 2);
+                      popup.options.offset = this._defaultMarker ? {
+                        "top": [
+                          0,
+                          0
+                        ],
+                        "top-left": [
+                          0,
+                          0
+                        ],
+                        "top-right": [
+                          0,
+                          0
+                        ],
+                        "bottom": [
+                          0,
+                          -markerHeight
+                        ],
+                        "bottom-left": [
+                          linearOffset,
+                          (markerHeight - markerRadius + linearOffset) * -1
+                        ],
+                        "bottom-right": [
+                          -linearOffset,
+                          (markerHeight - markerRadius + linearOffset) * -1
+                        ],
+                        "left": [
+                          markerRadius,
+                          (markerHeight - markerRadius) * -1
+                        ],
+                        "right": [
+                          -markerRadius,
+                          (markerHeight - markerRadius) * -1
+                        ]
+                      } : this._offset;
+                    }
+                    this._popup = popup;
+                    if (this._lngLat) {
+                      this._popup.setLngLat(this._lngLat);
+                    }
+                    this._originalTabIndex = this._element.getAttribute("tabindex");
+                    if (!this._originalTabIndex) {
+                      this._element.setAttribute("tabindex", "0");
+                    }
+                    this._element.addEventListener("keypress", this._onKeyPress);
+                  }
+                  return this;
+                };
+                Marker2.prototype._onKeyPress = function _onKeyPress(e2) {
+                  var code = e2.code;
+                  var legacyCode = e2.charCode || e2.keyCode;
+                  if (code === "Space" || code === "Enter" || legacyCode === 32 || legacyCode === 13) {
+                    this.togglePopup();
+                  }
+                };
+                Marker2.prototype._onMapClick = function _onMapClick(e2) {
+                  var targetElement = e2.originalEvent.target;
+                  var element = this._element;
+                  if (this._popup && (targetElement === element || element.contains(targetElement))) {
+                    this.togglePopup();
+                  }
+                };
+                Marker2.prototype.getPopup = function getPopup() {
+                  return this._popup;
+                };
+                Marker2.prototype.togglePopup = function togglePopup() {
+                  var popup = this._popup;
+                  if (!popup) {
+                    return this;
+                  } else if (popup.isOpen()) {
+                    popup.remove();
+                  } else {
+                    popup.addTo(this._map);
+                  }
+                  return this;
+                };
+                Marker2.prototype._update = function _update(e2) {
+                  if (!this._map) {
+                    return;
+                  }
+                  if (this._map.transform.renderWorldCopies) {
+                    this._lngLat = smartWrap(this._lngLat, this._pos, this._map.transform);
+                  }
+                  this._pos = this._map.project(this._lngLat)._add(this._offset);
+                  var rotation = "";
+                  if (this._rotationAlignment === "viewport" || this._rotationAlignment === "auto") {
+                    rotation = "rotateZ(" + this._rotation + "deg)";
+                  } else if (this._rotationAlignment === "map") {
+                    rotation = "rotateZ(" + (this._rotation - this._map.getBearing()) + "deg)";
+                  }
+                  var pitch = "";
+                  if (this._pitchAlignment === "viewport" || this._pitchAlignment === "auto") {
+                    pitch = "rotateX(0deg)";
+                  } else if (this._pitchAlignment === "map") {
+                    pitch = "rotateX(" + this._map.getPitch() + "deg)";
+                  }
+                  if (!e2 || e2.type === "moveend") {
+                    this._pos = this._pos.round();
+                  }
+                  DOM.setTransform(this._element, anchorTranslate[this._anchor] + " translate(" + this._pos.x + "px, " + this._pos.y + "px) " + pitch + " " + rotation);
+                };
+                Marker2.prototype.getOffset = function getOffset() {
+                  return this._offset;
+                };
+                Marker2.prototype.setOffset = function setOffset(offset) {
+                  this._offset = performance2.Point.convert(offset);
+                  this._update();
+                  return this;
+                };
+                Marker2.prototype._onMove = function _onMove(e2) {
+                  if (!this._isDragging) {
+                    var clickTolerance = this._clickTolerance || this._map._clickTolerance;
+                    this._isDragging = e2.point.dist(this._pointerdownPos) >= clickTolerance;
+                  }
+                  if (!this._isDragging) {
+                    return;
+                  }
+                  this._pos = e2.point.sub(this._positionDelta);
+                  this._lngLat = this._map.unproject(this._pos);
+                  this.setLngLat(this._lngLat);
+                  this._element.style.pointerEvents = "none";
+                  if (this._state === "pending") {
+                    this._state = "active";
+                    this.fire(new performance2.Event("dragstart"));
+                  }
+                  this.fire(new performance2.Event("drag"));
+                };
+                Marker2.prototype._onUp = function _onUp() {
+                  this._element.style.pointerEvents = "auto";
+                  this._positionDelta = null;
+                  this._pointerdownPos = null;
+                  this._isDragging = false;
+                  this._map.off("mousemove", this._onMove);
+                  this._map.off("touchmove", this._onMove);
+                  if (this._state === "active") {
+                    this.fire(new performance2.Event("dragend"));
+                  }
+                  this._state = "inactive";
+                };
+                Marker2.prototype._addDragHandler = function _addDragHandler(e2) {
+                  if (this._element.contains(e2.originalEvent.target)) {
+                    e2.preventDefault();
+                    this._positionDelta = e2.point.sub(this._pos).add(this._offset);
+                    this._pointerdownPos = e2.point;
+                    this._state = "pending";
+                    this._map.on("mousemove", this._onMove);
+                    this._map.on("touchmove", this._onMove);
+                    this._map.once("mouseup", this._onUp);
+                    this._map.once("touchend", this._onUp);
+                  }
+                };
+                Marker2.prototype.setDraggable = function setDraggable(shouldBeDraggable) {
+                  this._draggable = !!shouldBeDraggable;
+                  if (this._map) {
+                    if (shouldBeDraggable) {
+                      this._map.on("mousedown", this._addDragHandler);
+                      this._map.on("touchstart", this._addDragHandler);
+                    } else {
+                      this._map.off("mousedown", this._addDragHandler);
+                      this._map.off("touchstart", this._addDragHandler);
+                    }
+                  }
+                  return this;
+                };
+                Marker2.prototype.isDraggable = function isDraggable() {
+                  return this._draggable;
+                };
+                Marker2.prototype.setRotation = function setRotation(rotation) {
+                  this._rotation = rotation || 0;
+                  this._update();
+                  return this;
+                };
+                Marker2.prototype.getRotation = function getRotation2() {
+                  return this._rotation;
+                };
+                Marker2.prototype.setRotationAlignment = function setRotationAlignment(alignment) {
+                  this._rotationAlignment = alignment || "auto";
+                  this._update();
+                  return this;
+                };
+                Marker2.prototype.getRotationAlignment = function getRotationAlignment() {
+                  return this._rotationAlignment;
+                };
+                Marker2.prototype.setPitchAlignment = function setPitchAlignment(alignment) {
+                  this._pitchAlignment = alignment && alignment !== "auto" ? alignment : this._rotationAlignment;
+                  this._update();
+                  return this;
+                };
+                Marker2.prototype.getPitchAlignment = function getPitchAlignment() {
+                  return this._pitchAlignment;
+                };
+                return Marker2;
+              }(performance2.Evented);
+              var defaultOptions$3 = {
+                positionOptions: {
+                  enableHighAccuracy: false,
+                  maximumAge: 0,
+                  timeout: 6e3
+                },
+                fitBoundsOptions: { maxZoom: 15 },
+                trackUserLocation: false,
+                showAccuracyCircle: true,
+                showUserLocation: true
+              };
+              var supportsGeolocation;
+              function checkGeolocationSupport(callback) {
+                if (supportsGeolocation !== void 0) {
+                  callback(supportsGeolocation);
+                } else if (performance2.window.navigator.permissions !== void 0) {
+                  performance2.window.navigator.permissions.query({ name: "geolocation" }).then(function(p2) {
+                    supportsGeolocation = p2.state !== "denied";
+                    callback(supportsGeolocation);
+                  });
+                } else {
+                  supportsGeolocation = !!performance2.window.navigator.geolocation;
+                  callback(supportsGeolocation);
+                }
+              }
+              var numberOfWatches = 0;
+              var noTimeout = false;
+              var GeolocateControl = function(Evented) {
+                function GeolocateControl2(options) {
+                  Evented.call(this);
+                  this.options = performance2.extend({}, defaultOptions$3, options);
+                  performance2.bindAll([
+                    "_onSuccess",
+                    "_onError",
+                    "_onZoom",
+                    "_finish",
+                    "_setupUI",
+                    "_updateCamera",
+                    "_updateMarker"
+                  ], this);
+                }
+                if (Evented)
+                  GeolocateControl2.__proto__ = Evented;
+                GeolocateControl2.prototype = Object.create(Evented && Evented.prototype);
+                GeolocateControl2.prototype.constructor = GeolocateControl2;
+                GeolocateControl2.prototype.onAdd = function onAdd(map2) {
+                  this._map = map2;
+                  this._container = DOM.create("div", "mapboxgl-ctrl mapboxgl-ctrl-group");
+                  checkGeolocationSupport(this._setupUI);
+                  return this._container;
+                };
+                GeolocateControl2.prototype.onRemove = function onRemove() {
+                  if (this._geolocationWatchID !== void 0) {
+                    performance2.window.navigator.geolocation.clearWatch(this._geolocationWatchID);
+                    this._geolocationWatchID = void 0;
+                  }
+                  if (this.options.showUserLocation && this._userLocationDotMarker) {
+                    this._userLocationDotMarker.remove();
+                  }
+                  if (this.options.showAccuracyCircle && this._accuracyCircleMarker) {
+                    this._accuracyCircleMarker.remove();
+                  }
+                  DOM.remove(this._container);
+                  this._map.off("zoom", this._onZoom);
+                  this._map = void 0;
+                  numberOfWatches = 0;
+                  noTimeout = false;
+                };
+                GeolocateControl2.prototype._isOutOfMapMaxBounds = function _isOutOfMapMaxBounds(position) {
+                  var bounds = this._map.getMaxBounds();
+                  var coordinates = position.coords;
+                  return bounds && (coordinates.longitude < bounds.getWest() || coordinates.longitude > bounds.getEast() || coordinates.latitude < bounds.getSouth() || coordinates.latitude > bounds.getNorth());
+                };
+                GeolocateControl2.prototype._setErrorState = function _setErrorState() {
+                  switch (this._watchState) {
+                    case "WAITING_ACTIVE":
+                      this._watchState = "ACTIVE_ERROR";
+                      this._geolocateButton.classList.remove("mapboxgl-ctrl-geolocate-active");
+                      this._geolocateButton.classList.add("mapboxgl-ctrl-geolocate-active-error");
+                      break;
+                    case "ACTIVE_LOCK":
+                      this._watchState = "ACTIVE_ERROR";
+                      this._geolocateButton.classList.remove("mapboxgl-ctrl-geolocate-active");
+                      this._geolocateButton.classList.add("mapboxgl-ctrl-geolocate-active-error");
+                      this._geolocateButton.classList.add("mapboxgl-ctrl-geolocate-waiting");
+                      break;
+                    case "BACKGROUND":
+                      this._watchState = "BACKGROUND_ERROR";
+                      this._geolocateButton.classList.remove("mapboxgl-ctrl-geolocate-background");
+                      this._geolocateButton.classList.add("mapboxgl-ctrl-geolocate-background-error");
+                      this._geolocateButton.classList.add("mapboxgl-ctrl-geolocate-waiting");
+                      break;
+                  }
+                };
+                GeolocateControl2.prototype._onSuccess = function _onSuccess(position) {
+                  if (!this._map) {
+                    return;
+                  }
+                  if (this._isOutOfMapMaxBounds(position)) {
+                    this._setErrorState();
+                    this.fire(new performance2.Event("outofmaxbounds", position));
+                    this._updateMarker();
+                    this._finish();
+                    return;
+                  }
+                  if (this.options.trackUserLocation) {
+                    this._lastKnownPosition = position;
+                    switch (this._watchState) {
+                      case "WAITING_ACTIVE":
+                      case "ACTIVE_LOCK":
+                      case "ACTIVE_ERROR":
+                        this._watchState = "ACTIVE_LOCK";
+                        this._geolocateButton.classList.remove("mapboxgl-ctrl-geolocate-waiting");
+                        this._geolocateButton.classList.remove("mapboxgl-ctrl-geolocate-active-error");
+                        this._geolocateButton.classList.add("mapboxgl-ctrl-geolocate-active");
+                        break;
+                      case "BACKGROUND":
+                      case "BACKGROUND_ERROR":
+                        this._watchState = "BACKGROUND";
+                        this._geolocateButton.classList.remove("mapboxgl-ctrl-geolocate-waiting");
+                        this._geolocateButton.classList.remove("mapboxgl-ctrl-geolocate-background-error");
+                        this._geolocateButton.classList.add("mapboxgl-ctrl-geolocate-background");
+                        break;
+                    }
+                  }
+                  if (this.options.showUserLocation && this._watchState !== "OFF") {
+                    this._updateMarker(position);
+                  }
+                  if (!this.options.trackUserLocation || this._watchState === "ACTIVE_LOCK") {
+                    this._updateCamera(position);
+                  }
+                  if (this.options.showUserLocation) {
+                    this._dotElement.classList.remove("mapboxgl-user-location-dot-stale");
+                  }
+                  this.fire(new performance2.Event("geolocate", position));
+                  this._finish();
+                };
+                GeolocateControl2.prototype._updateCamera = function _updateCamera(position) {
+                  var center = new performance2.LngLat(position.coords.longitude, position.coords.latitude);
+                  var radius = position.coords.accuracy;
+                  var bearing = this._map.getBearing();
+                  var options = performance2.extend({ bearing }, this.options.fitBoundsOptions);
+                  this._map.fitBounds(center.toBounds(radius), options, { geolocateSource: true });
+                };
+                GeolocateControl2.prototype._updateMarker = function _updateMarker(position) {
+                  if (position) {
+                    var center = new performance2.LngLat(position.coords.longitude, position.coords.latitude);
+                    this._accuracyCircleMarker.setLngLat(center).addTo(this._map);
+                    this._userLocationDotMarker.setLngLat(center).addTo(this._map);
+                    this._accuracy = position.coords.accuracy;
+                    if (this.options.showUserLocation && this.options.showAccuracyCircle) {
+                      this._updateCircleRadius();
+                    }
+                  } else {
+                    this._userLocationDotMarker.remove();
+                    this._accuracyCircleMarker.remove();
+                  }
+                };
+                GeolocateControl2.prototype._updateCircleRadius = function _updateCircleRadius() {
+                  var y2 = this._map._container.clientHeight / 2;
+                  var a2 = this._map.unproject([
+                    0,
+                    y2
+                  ]);
+                  var b2 = this._map.unproject([
+                    1,
+                    y2
+                  ]);
+                  var metersPerPixel = a2.distanceTo(b2);
+                  var circleDiameter = Math.ceil(2 * this._accuracy / metersPerPixel);
+                  this._circleElement.style.width = circleDiameter + "px";
+                  this._circleElement.style.height = circleDiameter + "px";
+                };
+                GeolocateControl2.prototype._onZoom = function _onZoom() {
+                  if (this.options.showUserLocation && this.options.showAccuracyCircle) {
+                    this._updateCircleRadius();
+                  }
+                };
+                GeolocateControl2.prototype._onError = function _onError(error) {
+                  if (!this._map) {
+                    return;
+                  }
+                  if (this.options.trackUserLocation) {
+                    if (error.code === 1) {
+                      this._watchState = "OFF";
+                      this._geolocateButton.classList.remove("mapboxgl-ctrl-geolocate-waiting");
+                      this._geolocateButton.classList.remove("mapboxgl-ctrl-geolocate-active");
+                      this._geolocateButton.classList.remove("mapboxgl-ctrl-geolocate-active-error");
+                      this._geolocateButton.classList.remove("mapboxgl-ctrl-geolocate-background");
+                      this._geolocateButton.classList.remove("mapboxgl-ctrl-geolocate-background-error");
+                      this._geolocateButton.disabled = true;
+                      var title = this._map._getUIString("GeolocateControl.LocationNotAvailable");
+                      this._geolocateButton.title = title;
+                      this._geolocateButton.setAttribute("aria-label", title);
+                      if (this._geolocationWatchID !== void 0) {
+                        this._clearWatch();
+                      }
+                    } else if (error.code === 3 && noTimeout) {
+                      return;
+                    } else {
+                      this._setErrorState();
+                    }
+                  }
+                  if (this._watchState !== "OFF" && this.options.showUserLocation) {
+                    this._dotElement.classList.add("mapboxgl-user-location-dot-stale");
+                  }
+                  this.fire(new performance2.Event("error", error));
+                  this._finish();
+                };
+                GeolocateControl2.prototype._finish = function _finish() {
+                  if (this._timeoutId) {
+                    clearTimeout(this._timeoutId);
+                  }
+                  this._timeoutId = void 0;
+                };
+                GeolocateControl2.prototype._setupUI = function _setupUI(supported) {
+                  var this$1$1 = this;
+                  this._container.addEventListener("contextmenu", function(e2) {
+                    return e2.preventDefault();
+                  });
+                  this._geolocateButton = DOM.create("button", "mapboxgl-ctrl-geolocate", this._container);
+                  DOM.create("span", "mapboxgl-ctrl-icon", this._geolocateButton).setAttribute("aria-hidden", true);
+                  this._geolocateButton.type = "button";
+                  if (supported === false) {
+                    performance2.warnOnce("Geolocation support is not available so the GeolocateControl will be disabled.");
+                    var title = this._map._getUIString("GeolocateControl.LocationNotAvailable");
+                    this._geolocateButton.disabled = true;
+                    this._geolocateButton.title = title;
+                    this._geolocateButton.setAttribute("aria-label", title);
+                  } else {
+                    var title$1 = this._map._getUIString("GeolocateControl.FindMyLocation");
+                    this._geolocateButton.title = title$1;
+                    this._geolocateButton.setAttribute("aria-label", title$1);
+                  }
+                  if (this.options.trackUserLocation) {
+                    this._geolocateButton.setAttribute("aria-pressed", "false");
+                    this._watchState = "OFF";
+                  }
+                  if (this.options.showUserLocation) {
+                    this._dotElement = DOM.create("div", "mapboxgl-user-location-dot");
+                    this._userLocationDotMarker = new Marker(this._dotElement);
+                    this._circleElement = DOM.create("div", "mapboxgl-user-location-accuracy-circle");
+                    this._accuracyCircleMarker = new Marker({
+                      element: this._circleElement,
+                      pitchAlignment: "map"
+                    });
+                    if (this.options.trackUserLocation) {
+                      this._watchState = "OFF";
+                    }
+                    this._map.on("zoom", this._onZoom);
+                  }
+                  this._geolocateButton.addEventListener("click", this.trigger.bind(this));
+                  this._setup = true;
+                  if (this.options.trackUserLocation) {
+                    this._map.on("movestart", function(event) {
+                      var fromResize = event.originalEvent && event.originalEvent.type === "resize";
+                      if (!event.geolocateSource && this$1$1._watchState === "ACTIVE_LOCK" && !fromResize) {
+                        this$1$1._watchState = "BACKGROUND";
+                        this$1$1._geolocateButton.classList.add("mapboxgl-ctrl-geolocate-background");
+                        this$1$1._geolocateButton.classList.remove("mapboxgl-ctrl-geolocate-active");
+                        this$1$1.fire(new performance2.Event("trackuserlocationend"));
+                      }
+                    });
+                  }
+                };
+                GeolocateControl2.prototype.trigger = function trigger() {
+                  if (!this._setup) {
+                    performance2.warnOnce("Geolocate control triggered before added to a map");
+                    return false;
+                  }
+                  if (this.options.trackUserLocation) {
+                    switch (this._watchState) {
+                      case "OFF":
+                        this._watchState = "WAITING_ACTIVE";
+                        this.fire(new performance2.Event("trackuserlocationstart"));
+                        break;
+                      case "WAITING_ACTIVE":
+                      case "ACTIVE_LOCK":
+                      case "ACTIVE_ERROR":
+                      case "BACKGROUND_ERROR":
+                        numberOfWatches--;
+                        noTimeout = false;
+                        this._watchState = "OFF";
+                        this._geolocateButton.classList.remove("mapboxgl-ctrl-geolocate-waiting");
+                        this._geolocateButton.classList.remove("mapboxgl-ctrl-geolocate-active");
+                        this._geolocateButton.classList.remove("mapboxgl-ctrl-geolocate-active-error");
+                        this._geolocateButton.classList.remove("mapboxgl-ctrl-geolocate-background");
+                        this._geolocateButton.classList.remove("mapboxgl-ctrl-geolocate-background-error");
+                        this.fire(new performance2.Event("trackuserlocationend"));
+                        break;
+                      case "BACKGROUND":
+                        this._watchState = "ACTIVE_LOCK";
+                        this._geolocateButton.classList.remove("mapboxgl-ctrl-geolocate-background");
+                        if (this._lastKnownPosition) {
+                          this._updateCamera(this._lastKnownPosition);
+                        }
+                        this.fire(new performance2.Event("trackuserlocationstart"));
+                        break;
+                    }
+                    switch (this._watchState) {
+                      case "WAITING_ACTIVE":
+                        this._geolocateButton.classList.add("mapboxgl-ctrl-geolocate-waiting");
+                        this._geolocateButton.classList.add("mapboxgl-ctrl-geolocate-active");
+                        break;
+                      case "ACTIVE_LOCK":
+                        this._geolocateButton.classList.add("mapboxgl-ctrl-geolocate-active");
+                        break;
+                      case "ACTIVE_ERROR":
+                        this._geolocateButton.classList.add("mapboxgl-ctrl-geolocate-waiting");
+                        this._geolocateButton.classList.add("mapboxgl-ctrl-geolocate-active-error");
+                        break;
+                      case "BACKGROUND":
+                        this._geolocateButton.classList.add("mapboxgl-ctrl-geolocate-background");
+                        break;
+                      case "BACKGROUND_ERROR":
+                        this._geolocateButton.classList.add("mapboxgl-ctrl-geolocate-waiting");
+                        this._geolocateButton.classList.add("mapboxgl-ctrl-geolocate-background-error");
+                        break;
+                    }
+                    if (this._watchState === "OFF" && this._geolocationWatchID !== void 0) {
+                      this._clearWatch();
+                    } else if (this._geolocationWatchID === void 0) {
+                      this._geolocateButton.classList.add("mapboxgl-ctrl-geolocate-waiting");
+                      this._geolocateButton.setAttribute("aria-pressed", "true");
+                      numberOfWatches++;
+                      var positionOptions;
+                      if (numberOfWatches > 1) {
+                        positionOptions = {
+                          maximumAge: 6e5,
+                          timeout: 0
+                        };
+                        noTimeout = true;
+                      } else {
+                        positionOptions = this.options.positionOptions;
+                        noTimeout = false;
+                      }
+                      this._geolocationWatchID = performance2.window.navigator.geolocation.watchPosition(this._onSuccess, this._onError, positionOptions);
+                    }
+                  } else {
+                    performance2.window.navigator.geolocation.getCurrentPosition(this._onSuccess, this._onError, this.options.positionOptions);
+                    this._timeoutId = setTimeout(this._finish, 1e4);
+                  }
+                  return true;
+                };
+                GeolocateControl2.prototype._clearWatch = function _clearWatch() {
+                  performance2.window.navigator.geolocation.clearWatch(this._geolocationWatchID);
+                  this._geolocationWatchID = void 0;
+                  this._geolocateButton.classList.remove("mapboxgl-ctrl-geolocate-waiting");
+                  this._geolocateButton.setAttribute("aria-pressed", "false");
+                  if (this.options.showUserLocation) {
+                    this._updateMarker(null);
+                  }
+                };
+                return GeolocateControl2;
+              }(performance2.Evented);
+              var defaultOptions$4 = {
+                maxWidth: 100,
+                unit: "metric"
+              };
+              var ScaleControl = function ScaleControl2(options) {
+                this.options = performance2.extend({}, defaultOptions$4, options);
+                performance2.bindAll([
+                  "_onMove",
+                  "setUnit"
+                ], this);
+              };
+              ScaleControl.prototype.getDefaultPosition = function getDefaultPosition() {
+                return "bottom-left";
+              };
+              ScaleControl.prototype._onMove = function _onMove() {
+                updateScale(this._map, this._container, this.options);
+              };
+              ScaleControl.prototype.onAdd = function onAdd(map2) {
+                this._map = map2;
+                this._container = DOM.create("div", "mapboxgl-ctrl mapboxgl-ctrl-scale", map2.getContainer());
+                this._map.on("move", this._onMove);
+                this._onMove();
+                return this._container;
+              };
+              ScaleControl.prototype.onRemove = function onRemove() {
+                DOM.remove(this._container);
+                this._map.off("move", this._onMove);
+                this._map = void 0;
+              };
+              ScaleControl.prototype.setUnit = function setUnit(unit) {
+                this.options.unit = unit;
+                updateScale(this._map, this._container, this.options);
+              };
+              function updateScale(map2, container, options) {
+                var maxWidth = options && options.maxWidth || 100;
+                var y2 = map2._container.clientHeight / 2;
+                var left = map2.unproject([
+                  0,
+                  y2
+                ]);
+                var right = map2.unproject([
+                  maxWidth,
+                  y2
+                ]);
+                var maxMeters = left.distanceTo(right);
+                if (options && options.unit === "imperial") {
+                  var maxFeet = 3.2808 * maxMeters;
+                  if (maxFeet > 5280) {
+                    var maxMiles = maxFeet / 5280;
+                    setScale(container, maxWidth, maxMiles, map2._getUIString("ScaleControl.Miles"));
+                  } else {
+                    setScale(container, maxWidth, maxFeet, map2._getUIString("ScaleControl.Feet"));
+                  }
+                } else if (options && options.unit === "nautical") {
+                  var maxNauticals = maxMeters / 1852;
+                  setScale(container, maxWidth, maxNauticals, map2._getUIString("ScaleControl.NauticalMiles"));
+                } else if (maxMeters >= 1e3) {
+                  setScale(container, maxWidth, maxMeters / 1e3, map2._getUIString("ScaleControl.Kilometers"));
+                } else {
+                  setScale(container, maxWidth, maxMeters, map2._getUIString("ScaleControl.Meters"));
+                }
+              }
+              function setScale(container, maxWidth, maxDistance, unit) {
+                var distance2 = getRoundNum(maxDistance);
+                var ratio = distance2 / maxDistance;
+                container.style.width = maxWidth * ratio + "px";
+                container.innerHTML = distance2 + "&nbsp;" + unit;
+              }
+              function getDecimalRoundNum(d2) {
+                var multiplier = Math.pow(10, Math.ceil(-Math.log(d2) / Math.LN10));
+                return Math.round(d2 * multiplier) / multiplier;
+              }
+              function getRoundNum(num) {
+                var pow10 = Math.pow(10, ("" + Math.floor(num)).length - 1);
+                var d2 = num / pow10;
+                d2 = d2 >= 10 ? 10 : d2 >= 5 ? 5 : d2 >= 3 ? 3 : d2 >= 2 ? 2 : d2 >= 1 ? 1 : getDecimalRoundNum(d2);
+                return pow10 * d2;
+              }
+              var FullscreenControl = function FullscreenControl2(options) {
+                this._fullscreen = false;
+                if (options && options.container) {
+                  if (options.container instanceof performance2.window.HTMLElement) {
+                    this._container = options.container;
+                  } else {
+                    performance2.warnOnce("Full screen control 'container' must be a DOM element.");
+                  }
+                }
+                performance2.bindAll([
+                  "_onClickFullscreen",
+                  "_changeIcon"
+                ], this);
+                if ("onfullscreenchange" in performance2.window.document) {
+                  this._fullscreenchange = "fullscreenchange";
+                } else if ("onmozfullscreenchange" in performance2.window.document) {
+                  this._fullscreenchange = "mozfullscreenchange";
+                } else if ("onwebkitfullscreenchange" in performance2.window.document) {
+                  this._fullscreenchange = "webkitfullscreenchange";
+                } else if ("onmsfullscreenchange" in performance2.window.document) {
+                  this._fullscreenchange = "MSFullscreenChange";
+                }
+              };
+              FullscreenControl.prototype.onAdd = function onAdd(map2) {
+                this._map = map2;
+                if (!this._container) {
+                  this._container = this._map.getContainer();
+                }
+                this._controlContainer = DOM.create("div", "mapboxgl-ctrl mapboxgl-ctrl-group");
+                if (this._checkFullscreenSupport()) {
+                  this._setupUI();
+                } else {
+                  this._controlContainer.style.display = "none";
+                  performance2.warnOnce("This device does not support fullscreen mode.");
+                }
+                return this._controlContainer;
+              };
+              FullscreenControl.prototype.onRemove = function onRemove() {
+                DOM.remove(this._controlContainer);
+                this._map = null;
+                performance2.window.document.removeEventListener(this._fullscreenchange, this._changeIcon);
+              };
+              FullscreenControl.prototype._checkFullscreenSupport = function _checkFullscreenSupport() {
+                return !!(performance2.window.document.fullscreenEnabled || performance2.window.document.mozFullScreenEnabled || performance2.window.document.msFullscreenEnabled || performance2.window.document.webkitFullscreenEnabled);
+              };
+              FullscreenControl.prototype._setupUI = function _setupUI() {
+                var button = this._fullscreenButton = DOM.create("button", "mapboxgl-ctrl-fullscreen", this._controlContainer);
+                DOM.create("span", "mapboxgl-ctrl-icon", button).setAttribute("aria-hidden", true);
+                button.type = "button";
+                this._updateTitle();
+                this._fullscreenButton.addEventListener("click", this._onClickFullscreen);
+                performance2.window.document.addEventListener(this._fullscreenchange, this._changeIcon);
+              };
+              FullscreenControl.prototype._updateTitle = function _updateTitle() {
+                var title = this._getTitle();
+                this._fullscreenButton.setAttribute("aria-label", title);
+                this._fullscreenButton.title = title;
+              };
+              FullscreenControl.prototype._getTitle = function _getTitle() {
+                return this._map._getUIString(this._isFullscreen() ? "FullscreenControl.Exit" : "FullscreenControl.Enter");
+              };
+              FullscreenControl.prototype._isFullscreen = function _isFullscreen() {
+                return this._fullscreen;
+              };
+              FullscreenControl.prototype._changeIcon = function _changeIcon() {
+                var fullscreenElement = performance2.window.document.fullscreenElement || performance2.window.document.mozFullScreenElement || performance2.window.document.webkitFullscreenElement || performance2.window.document.msFullscreenElement;
+                if (fullscreenElement === this._container !== this._fullscreen) {
+                  this._fullscreen = !this._fullscreen;
+                  this._fullscreenButton.classList.toggle("mapboxgl-ctrl-shrink");
+                  this._fullscreenButton.classList.toggle("mapboxgl-ctrl-fullscreen");
+                  this._updateTitle();
+                }
+              };
+              FullscreenControl.prototype._onClickFullscreen = function _onClickFullscreen() {
+                if (this._isFullscreen()) {
+                  if (performance2.window.document.exitFullscreen) {
+                    performance2.window.document.exitFullscreen();
+                  } else if (performance2.window.document.mozCancelFullScreen) {
+                    performance2.window.document.mozCancelFullScreen();
+                  } else if (performance2.window.document.msExitFullscreen) {
+                    performance2.window.document.msExitFullscreen();
+                  } else if (performance2.window.document.webkitCancelFullScreen) {
+                    performance2.window.document.webkitCancelFullScreen();
+                  }
+                } else if (this._container.requestFullscreen) {
+                  this._container.requestFullscreen();
+                } else if (this._container.mozRequestFullScreen) {
+                  this._container.mozRequestFullScreen();
+                } else if (this._container.msRequestFullscreen) {
+                  this._container.msRequestFullscreen();
+                } else if (this._container.webkitRequestFullscreen) {
+                  this._container.webkitRequestFullscreen();
+                }
+              };
+              var defaultOptions$5 = {
+                closeButton: true,
+                closeOnClick: true,
+                focusAfterOpen: true,
+                className: "",
+                maxWidth: "240px"
+              };
+              var focusQuerySelector = [
+                "a[href]",
+                "[tabindex]:not([tabindex='-1'])",
+                "[contenteditable]:not([contenteditable='false'])",
+                "button:not([disabled])",
+                "input:not([disabled])",
+                "select:not([disabled])",
+                "textarea:not([disabled])"
+              ].join(", ");
+              var Popup = function(Evented) {
+                function Popup2(options) {
+                  Evented.call(this);
+                  this.options = performance2.extend(Object.create(defaultOptions$5), options);
+                  performance2.bindAll([
+                    "_update",
+                    "_onClose",
+                    "remove",
+                    "_onMouseMove",
+                    "_onMouseUp",
+                    "_onDrag"
+                  ], this);
+                }
+                if (Evented)
+                  Popup2.__proto__ = Evented;
+                Popup2.prototype = Object.create(Evented && Evented.prototype);
+                Popup2.prototype.constructor = Popup2;
+                Popup2.prototype.addTo = function addTo(map2) {
+                  if (this._map) {
+                    this.remove();
+                  }
+                  this._map = map2;
+                  if (this.options.closeOnClick) {
+                    this._map.on("click", this._onClose);
+                  }
+                  if (this.options.closeOnMove) {
+                    this._map.on("move", this._onClose);
+                  }
+                  this._map.on("remove", this.remove);
+                  this._update();
+                  this._focusFirstElement();
+                  if (this._trackPointer) {
+                    this._map.on("mousemove", this._onMouseMove);
+                    this._map.on("mouseup", this._onMouseUp);
+                    if (this._container) {
+                      this._container.classList.add("mapboxgl-popup-track-pointer");
+                    }
+                    this._map._canvasContainer.classList.add("mapboxgl-track-pointer");
+                  } else {
+                    this._map.on("move", this._update);
+                  }
+                  this.fire(new performance2.Event("open"));
+                  return this;
+                };
+                Popup2.prototype.isOpen = function isOpen() {
+                  return !!this._map;
+                };
+                Popup2.prototype.remove = function remove() {
+                  if (this._content) {
+                    DOM.remove(this._content);
+                  }
+                  if (this._container) {
+                    DOM.remove(this._container);
+                    delete this._container;
+                  }
+                  if (this._map) {
+                    this._map.off("move", this._update);
+                    this._map.off("move", this._onClose);
+                    this._map.off("click", this._onClose);
+                    this._map.off("remove", this.remove);
+                    this._map.off("mousemove", this._onMouseMove);
+                    this._map.off("mouseup", this._onMouseUp);
+                    this._map.off("drag", this._onDrag);
+                    delete this._map;
+                  }
+                  this.fire(new performance2.Event("close"));
+                  return this;
+                };
+                Popup2.prototype.getLngLat = function getLngLat() {
+                  return this._lngLat;
+                };
+                Popup2.prototype.setLngLat = function setLngLat(lnglat) {
+                  this._lngLat = performance2.LngLat.convert(lnglat);
+                  this._pos = null;
+                  this._trackPointer = false;
+                  this._update();
+                  if (this._map) {
+                    this._map.on("move", this._update);
+                    this._map.off("mousemove", this._onMouseMove);
+                    if (this._container) {
+                      this._container.classList.remove("mapboxgl-popup-track-pointer");
+                    }
+                    this._map._canvasContainer.classList.remove("mapboxgl-track-pointer");
+                  }
+                  return this;
+                };
+                Popup2.prototype.trackPointer = function trackPointer() {
+                  this._trackPointer = true;
+                  this._pos = null;
+                  this._update();
+                  if (this._map) {
+                    this._map.off("move", this._update);
+                    this._map.on("mousemove", this._onMouseMove);
+                    this._map.on("drag", this._onDrag);
+                    if (this._container) {
+                      this._container.classList.add("mapboxgl-popup-track-pointer");
+                    }
+                    this._map._canvasContainer.classList.add("mapboxgl-track-pointer");
+                  }
+                  return this;
+                };
+                Popup2.prototype.getElement = function getElement() {
+                  return this._container;
+                };
+                Popup2.prototype.setText = function setText(text) {
+                  return this.setDOMContent(performance2.window.document.createTextNode(text));
+                };
+                Popup2.prototype.setHTML = function setHTML(html) {
+                  var frag = performance2.window.document.createDocumentFragment();
+                  var temp = performance2.window.document.createElement("body");
+                  var child;
+                  temp.innerHTML = html;
+                  while (true) {
+                    child = temp.firstChild;
+                    if (!child) {
+                      break;
+                    }
+                    frag.appendChild(child);
+                  }
+                  return this.setDOMContent(frag);
+                };
+                Popup2.prototype.getMaxWidth = function getMaxWidth() {
+                  return this._container && this._container.style.maxWidth;
+                };
+                Popup2.prototype.setMaxWidth = function setMaxWidth(maxWidth) {
+                  this.options.maxWidth = maxWidth;
+                  this._update();
+                  return this;
+                };
+                Popup2.prototype.setDOMContent = function setDOMContent(htmlNode) {
+                  if (this._content) {
+                    while (this._content.hasChildNodes()) {
+                      if (this._content.firstChild) {
+                        this._content.removeChild(this._content.firstChild);
+                      }
+                    }
+                  } else {
+                    this._content = DOM.create("div", "mapboxgl-popup-content", this._container);
+                  }
+                  this._content.appendChild(htmlNode);
+                  this._createCloseButton();
+                  this._update();
+                  this._focusFirstElement();
+                  return this;
+                };
+                Popup2.prototype.addClassName = function addClassName(className) {
+                  if (this._container) {
+                    this._container.classList.add(className);
+                  }
+                };
+                Popup2.prototype.removeClassName = function removeClassName(className) {
+                  if (this._container) {
+                    this._container.classList.remove(className);
+                  }
+                };
+                Popup2.prototype.setOffset = function setOffset(offset) {
+                  this.options.offset = offset;
+                  this._update();
+                  return this;
+                };
+                Popup2.prototype.toggleClassName = function toggleClassName(className) {
+                  if (this._container) {
+                    return this._container.classList.toggle(className);
+                  }
+                };
+                Popup2.prototype._createCloseButton = function _createCloseButton() {
+                  if (this.options.closeButton) {
+                    this._closeButton = DOM.create("button", "mapboxgl-popup-close-button", this._content);
+                    this._closeButton.type = "button";
+                    this._closeButton.setAttribute("aria-label", "Close popup");
+                    this._closeButton.innerHTML = "&#215;";
+                    this._closeButton.addEventListener("click", this._onClose);
+                  }
+                };
+                Popup2.prototype._onMouseUp = function _onMouseUp(event) {
+                  this._update(event.point);
+                };
+                Popup2.prototype._onMouseMove = function _onMouseMove(event) {
+                  this._update(event.point);
+                };
+                Popup2.prototype._onDrag = function _onDrag(event) {
+                  this._update(event.point);
+                };
+                Popup2.prototype._update = function _update(cursor) {
+                  var this$1$1 = this;
+                  var hasPosition = this._lngLat || this._trackPointer;
+                  if (!this._map || !hasPosition || !this._content) {
+                    return;
+                  }
+                  if (!this._container) {
+                    this._container = DOM.create("div", "mapboxgl-popup", this._map.getContainer());
+                    this._tip = DOM.create("div", "mapboxgl-popup-tip", this._container);
+                    this._container.appendChild(this._content);
+                    if (this.options.className) {
+                      this.options.className.split(" ").forEach(function(name2) {
+                        return this$1$1._container.classList.add(name2);
+                      });
+                    }
+                    if (this._trackPointer) {
+                      this._container.classList.add("mapboxgl-popup-track-pointer");
+                    }
+                  }
+                  if (this.options.maxWidth && this._container.style.maxWidth !== this.options.maxWidth) {
+                    this._container.style.maxWidth = this.options.maxWidth;
+                  }
+                  if (this._map.transform.renderWorldCopies && !this._trackPointer) {
+                    this._lngLat = smartWrap(this._lngLat, this._pos, this._map.transform);
+                  }
+                  if (this._trackPointer && !cursor) {
+                    return;
+                  }
+                  var pos = this._pos = this._trackPointer && cursor ? cursor : this._map.project(this._lngLat);
+                  var anchor = this.options.anchor;
+                  var offset = normalizeOffset(this.options.offset);
+                  if (!anchor) {
+                    var width = this._container.offsetWidth;
+                    var height = this._container.offsetHeight;
+                    var anchorComponents;
+                    if (pos.y + offset.bottom.y < height) {
+                      anchorComponents = ["top"];
+                    } else if (pos.y > this._map.transform.height - height) {
+                      anchorComponents = ["bottom"];
+                    } else {
+                      anchorComponents = [];
+                    }
+                    if (pos.x < width / 2) {
+                      anchorComponents.push("left");
+                    } else if (pos.x > this._map.transform.width - width / 2) {
+                      anchorComponents.push("right");
+                    }
+                    if (anchorComponents.length === 0) {
+                      anchor = "bottom";
+                    } else {
+                      anchor = anchorComponents.join("-");
+                    }
+                  }
+                  var offsetedPos = pos.add(offset[anchor]).round();
+                  DOM.setTransform(this._container, anchorTranslate[anchor] + " translate(" + offsetedPos.x + "px," + offsetedPos.y + "px)");
+                  applyAnchorClass(this._container, anchor, "popup");
+                };
+                Popup2.prototype._focusFirstElement = function _focusFirstElement() {
+                  if (!this.options.focusAfterOpen || !this._container) {
+                    return;
+                  }
+                  var firstFocusable = this._container.querySelector(focusQuerySelector);
+                  if (firstFocusable) {
+                    firstFocusable.focus();
+                  }
+                };
+                Popup2.prototype._onClose = function _onClose() {
+                  this.remove();
+                };
+                return Popup2;
+              }(performance2.Evented);
+              function normalizeOffset(offset) {
+                if (!offset) {
+                  return normalizeOffset(new performance2.Point(0, 0));
+                } else if (typeof offset === "number") {
+                  var cornerOffset = Math.round(Math.sqrt(0.5 * Math.pow(offset, 2)));
+                  return {
+                    "center": new performance2.Point(0, 0),
+                    "top": new performance2.Point(0, offset),
+                    "top-left": new performance2.Point(cornerOffset, cornerOffset),
+                    "top-right": new performance2.Point(-cornerOffset, cornerOffset),
+                    "bottom": new performance2.Point(0, -offset),
+                    "bottom-left": new performance2.Point(cornerOffset, -cornerOffset),
+                    "bottom-right": new performance2.Point(-cornerOffset, -cornerOffset),
+                    "left": new performance2.Point(offset, 0),
+                    "right": new performance2.Point(-offset, 0)
+                  };
+                } else if (offset instanceof performance2.Point || Array.isArray(offset)) {
+                  var convertedOffset = performance2.Point.convert(offset);
+                  return {
+                    "center": convertedOffset,
+                    "top": convertedOffset,
+                    "top-left": convertedOffset,
+                    "top-right": convertedOffset,
+                    "bottom": convertedOffset,
+                    "bottom-left": convertedOffset,
+                    "bottom-right": convertedOffset,
+                    "left": convertedOffset,
+                    "right": convertedOffset
+                  };
+                } else {
+                  return {
+                    "center": performance2.Point.convert(offset["center"] || [
+                      0,
+                      0
+                    ]),
+                    "top": performance2.Point.convert(offset["top"] || [
+                      0,
+                      0
+                    ]),
+                    "top-left": performance2.Point.convert(offset["top-left"] || [
+                      0,
+                      0
+                    ]),
+                    "top-right": performance2.Point.convert(offset["top-right"] || [
+                      0,
+                      0
+                    ]),
+                    "bottom": performance2.Point.convert(offset["bottom"] || [
+                      0,
+                      0
+                    ]),
+                    "bottom-left": performance2.Point.convert(offset["bottom-left"] || [
+                      0,
+                      0
+                    ]),
+                    "bottom-right": performance2.Point.convert(offset["bottom-right"] || [
+                      0,
+                      0
+                    ]),
+                    "left": performance2.Point.convert(offset["left"] || [
+                      0,
+                      0
+                    ]),
+                    "right": performance2.Point.convert(offset["right"] || [
+                      0,
+                      0
+                    ])
+                  };
+                }
+              }
+              var exported = {
+                version: performance2.version,
+                supported: mapboxGlSupported,
+                setRTLTextPlugin: performance2.setRTLTextPlugin,
+                getRTLTextPluginStatus: performance2.getRTLTextPluginStatus,
+                Map: Map22,
+                NavigationControl,
+                GeolocateControl,
+                AttributionControl,
+                ScaleControl,
+                FullscreenControl,
+                Popup,
+                Marker,
+                Style,
+                LngLat: performance2.LngLat,
+                LngLatBounds: performance2.LngLatBounds,
+                Point: performance2.Point,
+                MercatorCoordinate: performance2.MercatorCoordinate,
+                Evented: performance2.Evented,
+                config: performance2.config,
+                prewarm,
+                clearPrewarmedResources,
+                get accessToken() {
+                  return performance2.config.ACCESS_TOKEN;
+                },
+                set accessToken(token) {
+                  performance2.config.ACCESS_TOKEN = token;
+                },
+                get baseApiUrl() {
+                  return performance2.config.API_URL;
+                },
+                set baseApiUrl(url) {
+                  performance2.config.API_URL = url;
+                },
+                get workerCount() {
+                  return WorkerPool2.workerCount;
+                },
+                set workerCount(count2) {
+                  WorkerPool2.workerCount = count2;
+                },
+                get maxParallelImageRequests() {
+                  return performance2.config.MAX_PARALLEL_IMAGE_REQUESTS;
+                },
+                set maxParallelImageRequests(numRequests) {
+                  performance2.config.MAX_PARALLEL_IMAGE_REQUESTS = numRequests;
+                },
+                clearStorage: function clearStorage(callback) {
+                  performance2.clearTileCache(callback);
+                },
+                workerUrl: ""
+              };
+              return exported;
+            });
+            return mapboxgl;
+          });
+        }
+      });
+      var require_layers = __commonJS({
+        "src/plots/mapbox/layers.js"(exports, module2) {
+          var Lib = require_lib();
+          var sanitizeHTML = require_svg_text_utils().sanitizeHTML;
+          var convertTextOpts = require_convert_text_opts();
+          var constants = require_constants25();
+          function MapboxLayer2(subplot, index) {
+            this.subplot = subplot;
+            this.uid = subplot.uid + "-" + index;
+            this.index = index;
+            this.idSource = "source-" + this.uid;
+            this.idLayer = constants.layoutLayerPrefix + this.uid;
+            this.sourceType = null;
+            this.source = null;
+            this.layerType = null;
+            this.below = null;
+            this.visible = false;
+          }
+          var proto = MapboxLayer2.prototype;
+          proto.update = function update(opts) {
+            if (!this.visible) {
+              this.updateSource(opts);
+              this.updateLayer(opts);
+            } else if (this.needsNewImage(opts)) {
+              this.updateImage(opts);
+            } else if (this.needsNewSource(opts)) {
+              this.removeLayer();
+              this.updateSource(opts);
+              this.updateLayer(opts);
+            } else if (this.needsNewLayer(opts)) {
+              this.updateLayer(opts);
+            } else {
+              this.updateStyle(opts);
+            }
+            this.visible = isVisible(opts);
+          };
+          proto.needsNewImage = function(opts) {
+            var map2 = this.subplot.map;
+            return map2.getSource(this.idSource) && this.sourceType === "image" && opts.sourcetype === "image" && (this.source !== opts.source || JSON.stringify(this.coordinates) !== JSON.stringify(opts.coordinates));
+          };
+          proto.needsNewSource = function(opts) {
+            return this.sourceType !== opts.sourcetype || JSON.stringify(this.source) !== JSON.stringify(opts.source) || this.layerType !== opts.type;
+          };
+          proto.needsNewLayer = function(opts) {
+            return this.layerType !== opts.type || this.below !== this.subplot.belowLookup["layout-" + this.index];
+          };
+          proto.lookupBelow = function() {
+            return this.subplot.belowLookup["layout-" + this.index];
+          };
+          proto.updateImage = function(opts) {
+            var map2 = this.subplot.map;
+            map2.getSource(this.idSource).updateImage({
+              url: opts.source,
+              coordinates: opts.coordinates
+            });
+            var _below = this.findFollowingMapboxLayerId(this.lookupBelow());
+            if (_below !== null) {
+              this.subplot.map.moveLayer(this.idLayer, _below);
+            }
+          };
+          proto.updateSource = function(opts) {
+            var map2 = this.subplot.map;
+            if (map2.getSource(this.idSource)) map2.removeSource(this.idSource);
+            this.sourceType = opts.sourcetype;
+            this.source = opts.source;
+            if (!isVisible(opts)) return;
+            var sourceOpts = convertSourceOpts(opts);
+            map2.addSource(this.idSource, sourceOpts);
+          };
+          proto.findFollowingMapboxLayerId = function(below) {
+            if (below === "traces") {
+              var mapLayers = this.subplot.getMapLayers();
+              for (var i2 = 0; i2 < mapLayers.length; i2++) {
+                var layerId = mapLayers[i2].id;
+                if (typeof layerId === "string" && layerId.indexOf(constants.traceLayerPrefix) === 0) {
+                  below = layerId;
+                  break;
+                }
+              }
+            }
+            return below;
+          };
+          proto.updateLayer = function(opts) {
+            var subplot = this.subplot;
+            var convertedOpts = convertOpts(opts);
+            var below = this.lookupBelow();
+            var _below = this.findFollowingMapboxLayerId(below);
+            this.removeLayer();
+            if (isVisible(opts)) {
+              subplot.addLayer({
+                id: this.idLayer,
+                source: this.idSource,
+                "source-layer": opts.sourcelayer || "",
+                type: opts.type,
+                minzoom: opts.minzoom,
+                maxzoom: opts.maxzoom,
+                layout: convertedOpts.layout,
+                paint: convertedOpts.paint
+              }, _below);
+            }
+            this.layerType = opts.type;
+            this.below = below;
+          };
+          proto.updateStyle = function(opts) {
+            if (isVisible(opts)) {
+              var convertedOpts = convertOpts(opts);
+              this.subplot.setOptions(this.idLayer, "setLayoutProperty", convertedOpts.layout);
+              this.subplot.setOptions(this.idLayer, "setPaintProperty", convertedOpts.paint);
+            }
+          };
+          proto.removeLayer = function() {
+            var map2 = this.subplot.map;
+            if (map2.getLayer(this.idLayer)) {
+              map2.removeLayer(this.idLayer);
+            }
+          };
+          proto.dispose = function() {
+            var map2 = this.subplot.map;
+            if (map2.getLayer(this.idLayer)) map2.removeLayer(this.idLayer);
+            if (map2.getSource(this.idSource)) map2.removeSource(this.idSource);
+          };
+          function isVisible(opts) {
+            if (!opts.visible) return false;
+            var source2 = opts.source;
+            if (Array.isArray(source2) && source2.length > 0) {
+              for (var i2 = 0; i2 < source2.length; i2++) {
+                if (typeof source2[i2] !== "string" || source2[i2].length === 0) {
+                  return false;
+                }
+              }
+              return true;
+            }
+            return Lib.isPlainObject(source2) || typeof source2 === "string" && source2.length > 0;
+          }
+          function convertOpts(opts) {
+            var layout = {};
+            var paint = {};
+            switch (opts.type) {
+              case "circle":
+                Lib.extendFlat(paint, {
+                  "circle-radius": opts.circle.radius,
+                  "circle-color": opts.color,
+                  "circle-opacity": opts.opacity
+                });
+                break;
+              case "line":
+                Lib.extendFlat(paint, {
+                  "line-width": opts.line.width,
+                  "line-color": opts.color,
+                  "line-opacity": opts.opacity,
+                  "line-dasharray": opts.line.dash
+                });
+                break;
+              case "fill":
+                Lib.extendFlat(paint, {
+                  "fill-color": opts.color,
+                  "fill-outline-color": opts.fill.outlinecolor,
+                  "fill-opacity": opts.opacity
+                  // no way to pass specify outline width at the moment
+                });
+                break;
+              case "symbol":
+                var symbol = opts.symbol;
+                var textOpts = convertTextOpts(symbol.textposition, symbol.iconsize);
+                Lib.extendFlat(layout, {
+                  "icon-image": symbol.icon + "-15",
+                  "icon-size": symbol.iconsize / 10,
+                  "text-field": symbol.text,
+                  "text-size": symbol.textfont.size,
+                  "text-anchor": textOpts.anchor,
+                  "text-offset": textOpts.offset,
+                  "symbol-placement": symbol.placement
+                  // TODO font family
+                  // 'text-font': symbol.textfont.family.split(', '),
+                });
+                Lib.extendFlat(paint, {
+                  "icon-color": opts.color,
+                  "text-color": symbol.textfont.color,
+                  "text-opacity": opts.opacity
+                });
+                break;
+              case "raster":
+                Lib.extendFlat(paint, {
+                  "raster-fade-duration": 0,
+                  "raster-opacity": opts.opacity
+                });
+                break;
+            }
+            return {
+              layout,
+              paint
+            };
+          }
+          function convertSourceOpts(opts) {
+            var sourceType = opts.sourcetype;
+            var source2 = opts.source;
+            var sourceOpts = { type: sourceType };
+            var field;
+            if (sourceType === "geojson") {
+              field = "data";
+            } else if (sourceType === "vector") {
+              field = typeof source2 === "string" ? "url" : "tiles";
+            } else if (sourceType === "raster") {
+              field = "tiles";
+              sourceOpts.tileSize = 256;
+            } else if (sourceType === "image") {
+              field = "url";
+              sourceOpts.coordinates = opts.coordinates;
+            }
+            sourceOpts[field] = source2;
+            if (opts.sourceattribution) {
+              sourceOpts.attribution = sanitizeHTML(opts.sourceattribution);
+            }
+            return sourceOpts;
+          }
+          module2.exports = function createMapboxLayer(subplot, index, opts) {
+            var mapboxLayer = new MapboxLayer2(subplot, index);
+            mapboxLayer.update(opts);
+            return mapboxLayer;
+          };
+        }
+      });
+      var require_mapbox = __commonJS({
+        "src/plots/mapbox/mapbox.js"(exports, module2) {
+          var mapboxgl = require_mapbox_gl_unminified();
+          var Lib = require_lib();
+          var geoUtils = require_geo_location_utils();
+          var Registry = require_registry();
+          var Axes = require_axes();
+          var dragElement = require_dragelement();
+          var Fx = require_fx();
+          var dragHelpers = require_helpers5();
+          var drawMode = dragHelpers.drawMode;
+          var selectMode = dragHelpers.selectMode;
+          var prepSelect = require_selections().prepSelect;
+          var clearOutline = require_selections().clearOutline;
+          var clearSelectionsCache = require_selections().clearSelectionsCache;
+          var selectOnClick = require_selections().selectOnClick;
+          var constants = require_constants25();
+          var createMapboxLayer = require_layers();
+          function Mapbox(gd2, id2) {
+            this.id = id2;
+            this.gd = gd2;
+            var fullLayout = gd2._fullLayout;
+            var context = gd2._context;
+            this.container = fullLayout._glcontainer.node();
+            this.isStatic = context.staticPlot;
+            this.uid = fullLayout._uid + "-" + this.id;
+            this.div = null;
+            this.xaxis = null;
+            this.yaxis = null;
+            this.createFramework(fullLayout);
+            this.map = null;
+            this.accessToken = null;
+            this.styleObj = null;
+            this.traceHash = {};
+            this.layerList = [];
+            this.belowLookup = {};
+            this.dragging = false;
+            this.wheeling = false;
+          }
+          var proto = Mapbox.prototype;
+          proto.plot = function(calcData, fullLayout, promises) {
+            var self2 = this;
+            var opts = fullLayout[self2.id];
+            if (self2.map && opts.accesstoken !== self2.accessToken) {
+              self2.map.remove();
+              self2.map = null;
+              self2.styleObj = null;
+              self2.traceHash = {};
+              self2.layerList = [];
+            }
+            var promise;
+            if (!self2.map) {
+              promise = new Promise(function(resolve, reject) {
+                self2.createMap(calcData, fullLayout, resolve, reject);
+              });
+            } else {
+              promise = new Promise(function(resolve, reject) {
+                self2.updateMap(calcData, fullLayout, resolve, reject);
+              });
+            }
+            promises.push(promise);
+          };
+          proto.createMap = function(calcData, fullLayout, resolve, reject) {
+            var self2 = this;
+            var opts = fullLayout[self2.id];
+            var styleObj = self2.styleObj = getStyleObj(opts.style, fullLayout);
+            self2.accessToken = opts.accesstoken;
+            var bounds = opts.bounds;
+            var maxBounds = bounds ? [[bounds.west, bounds.south], [bounds.east, bounds.north]] : null;
+            var map2 = self2.map = new mapboxgl.Map({
+              container: self2.div,
+              style: styleObj.style,
+              center: convertCenter(opts.center),
+              zoom: opts.zoom,
+              bearing: opts.bearing,
+              pitch: opts.pitch,
+              maxBounds,
+              interactive: !self2.isStatic,
+              preserveDrawingBuffer: self2.isStatic,
+              doubleClickZoom: false,
+              boxZoom: false,
+              attributionControl: false
+            }).addControl(new mapboxgl.AttributionControl({
+              compact: true
+            }));
+            map2._canvas.style.left = "0px";
+            map2._canvas.style.top = "0px";
+            self2.rejectOnError(reject);
+            if (!self2.isStatic) {
+              self2.initFx(calcData, fullLayout);
+            }
+            var promises = [];
+            promises.push(new Promise(function(resolve2) {
+              map2.once("load", resolve2);
+            }));
+            promises = promises.concat(geoUtils.fetchTraceGeoData(calcData));
+            Promise.all(promises).then(function() {
+              self2.fillBelowLookup(calcData, fullLayout);
+              self2.updateData(calcData);
+              self2.updateLayout(fullLayout);
+              self2.resolveOnRender(resolve);
+            }).catch(reject);
+          };
+          proto.updateMap = function(calcData, fullLayout, resolve, reject) {
+            var self2 = this;
+            var map2 = self2.map;
+            var opts = fullLayout[this.id];
+            self2.rejectOnError(reject);
+            var promises = [];
+            var styleObj = getStyleObj(opts.style, fullLayout);
+            if (JSON.stringify(self2.styleObj) !== JSON.stringify(styleObj)) {
+              self2.styleObj = styleObj;
+              map2.setStyle(styleObj.style);
+              self2.traceHash = {};
+              promises.push(new Promise(function(resolve2) {
+                map2.once("styledata", resolve2);
+              }));
+            }
+            promises = promises.concat(geoUtils.fetchTraceGeoData(calcData));
+            Promise.all(promises).then(function() {
+              self2.fillBelowLookup(calcData, fullLayout);
+              self2.updateData(calcData);
+              self2.updateLayout(fullLayout);
+              self2.resolveOnRender(resolve);
+            }).catch(reject);
+          };
+          proto.fillBelowLookup = function(calcData, fullLayout) {
+            var opts = fullLayout[this.id];
+            var layers = opts.layers;
+            var i2, val;
+            var belowLookup = this.belowLookup = {};
+            var hasTraceAtTop = false;
+            for (i2 = 0; i2 < calcData.length; i2++) {
+              var trace = calcData[i2][0].trace;
+              var _module = trace._module;
+              if (typeof trace.below === "string") {
+                val = trace.below;
+              } else if (_module.getBelow) {
+                val = _module.getBelow(trace, this);
+              }
+              if (val === "") {
+                hasTraceAtTop = true;
+              }
+              belowLookup["trace-" + trace.uid] = val || "";
+            }
+            for (i2 = 0; i2 < layers.length; i2++) {
+              var item = layers[i2];
+              if (typeof item.below === "string") {
+                val = item.below;
+              } else if (hasTraceAtTop) {
+                val = "traces";
+              } else {
+                val = "";
+              }
+              belowLookup["layout-" + i2] = val;
+            }
+            var val2list = {};
+            var k2, id2;
+            for (k2 in belowLookup) {
+              val = belowLookup[k2];
+              if (val2list[val]) {
+                val2list[val].push(k2);
+              } else {
+                val2list[val] = [k2];
+              }
+            }
+            for (val in val2list) {
+              var list = val2list[val];
+              if (list.length > 1) {
+                for (i2 = 0; i2 < list.length; i2++) {
+                  k2 = list[i2];
+                  if (k2.indexOf("trace-") === 0) {
+                    id2 = k2.split("trace-")[1];
+                    if (this.traceHash[id2]) {
+                      this.traceHash[id2].below = null;
+                    }
+                  } else if (k2.indexOf("layout-") === 0) {
+                    id2 = k2.split("layout-")[1];
+                    if (this.layerList[id2]) {
+                      this.layerList[id2].below = null;
+                    }
+                  }
+                }
+              }
+            }
+          };
+          var traceType2orderIndex = {
+            choroplethmapbox: 0,
+            densitymapbox: 1,
+            scattermapbox: 2
+          };
+          proto.updateData = function(calcData) {
+            var traceHash = this.traceHash;
+            var traceObj, trace, i2, j2;
+            var calcDataSorted = calcData.slice().sort(function(a2, b2) {
+              return traceType2orderIndex[a2[0].trace.type] - traceType2orderIndex[b2[0].trace.type];
+            });
+            for (i2 = 0; i2 < calcDataSorted.length; i2++) {
+              var calcTrace = calcDataSorted[i2];
+              trace = calcTrace[0].trace;
+              traceObj = traceHash[trace.uid];
+              var didUpdate = false;
+              if (traceObj) {
+                if (traceObj.type === trace.type) {
+                  traceObj.update(calcTrace);
+                  didUpdate = true;
+                } else {
+                  traceObj.dispose();
+                }
+              }
+              if (!didUpdate && trace._module) {
+                traceHash[trace.uid] = trace._module.plot(this, calcTrace);
+              }
+            }
+            var ids = Object.keys(traceHash);
+            idLoop:
+              for (i2 = 0; i2 < ids.length; i2++) {
+                var id2 = ids[i2];
+                for (j2 = 0; j2 < calcData.length; j2++) {
+                  trace = calcData[j2][0].trace;
+                  if (id2 === trace.uid) continue idLoop;
+                }
+                traceObj = traceHash[id2];
+                traceObj.dispose();
+                delete traceHash[id2];
+              }
+          };
+          proto.updateLayout = function(fullLayout) {
+            var map2 = this.map;
+            var opts = fullLayout[this.id];
+            if (!this.dragging && !this.wheeling) {
+              map2.setCenter(convertCenter(opts.center));
+              map2.setZoom(opts.zoom);
+              map2.setBearing(opts.bearing);
+              map2.setPitch(opts.pitch);
+            }
+            this.updateLayers(fullLayout);
+            this.updateFramework(fullLayout);
+            this.updateFx(fullLayout);
+            this.map.resize();
+            if (this.gd._context._scrollZoom.mapbox) {
+              map2.scrollZoom.enable();
+            } else {
+              map2.scrollZoom.disable();
+            }
+          };
+          proto.resolveOnRender = function(resolve) {
+            var map2 = this.map;
+            map2.on("render", function onRender() {
+              if (map2.loaded()) {
+                map2.off("render", onRender);
+                setTimeout(resolve, 10);
+              }
+            });
+          };
+          proto.rejectOnError = function(reject) {
+            var map2 = this.map;
+            function handler() {
+              reject(new Error(constants.mapOnErrorMsg));
+            }
+            map2.once("error", handler);
+            map2.once("style.error", handler);
+            map2.once("source.error", handler);
+            map2.once("tile.error", handler);
+            map2.once("layer.error", handler);
+          };
+          proto.createFramework = function(fullLayout) {
+            var self2 = this;
+            var div = self2.div = document.createElement("div");
+            div.id = self2.uid;
+            div.style.position = "absolute";
+            self2.container.appendChild(div);
+            self2.xaxis = {
+              _id: "x",
+              c2p: function(v2) {
+                return self2.project(v2).x;
+              }
+            };
+            self2.yaxis = {
+              _id: "y",
+              c2p: function(v2) {
+                return self2.project(v2).y;
+              }
+            };
+            self2.updateFramework(fullLayout);
+            self2.mockAxis = {
+              type: "linear",
+              showexponent: "all",
+              exponentformat: "B"
+            };
+            Axes.setConvert(self2.mockAxis, fullLayout);
+          };
+          proto.initFx = function(calcData, fullLayout) {
+            var self2 = this;
+            var gd2 = self2.gd;
+            var map2 = self2.map;
+            map2.on("moveend", function(evt) {
+              if (!self2.map) return;
+              var fullLayoutNow = gd2._fullLayout;
+              if (evt.originalEvent || self2.wheeling) {
+                var optsNow = fullLayoutNow[self2.id];
+                Registry.call("_storeDirectGUIEdit", gd2.layout, fullLayoutNow._preGUI, self2.getViewEdits(optsNow));
+                var viewNow = self2.getView();
+                optsNow._input.center = optsNow.center = viewNow.center;
+                optsNow._input.zoom = optsNow.zoom = viewNow.zoom;
+                optsNow._input.bearing = optsNow.bearing = viewNow.bearing;
+                optsNow._input.pitch = optsNow.pitch = viewNow.pitch;
+                gd2.emit("plotly_relayout", self2.getViewEditsWithDerived(viewNow));
+              }
+              if (evt.originalEvent && evt.originalEvent.type === "mouseup") {
+                self2.dragging = false;
+              } else if (self2.wheeling) {
+                self2.wheeling = false;
+              }
+              if (fullLayoutNow._rehover) {
+                fullLayoutNow._rehover();
+              }
+            });
+            map2.on("wheel", function() {
+              self2.wheeling = true;
+            });
+            map2.on("mousemove", function(evt) {
+              var bb2 = self2.div.getBoundingClientRect();
+              var xy = [
+                evt.originalEvent.offsetX,
+                evt.originalEvent.offsetY
+              ];
+              evt.target.getBoundingClientRect = function() {
+                return bb2;
+              };
+              self2.xaxis.p2c = function() {
+                return map2.unproject(xy).lng;
+              };
+              self2.yaxis.p2c = function() {
+                return map2.unproject(xy).lat;
+              };
+              gd2._fullLayout._rehover = function() {
+                if (gd2._fullLayout._hoversubplot === self2.id && gd2._fullLayout[self2.id]) {
+                  Fx.hover(gd2, evt, self2.id);
+                }
+              };
+              Fx.hover(gd2, evt, self2.id);
+              gd2._fullLayout._hoversubplot = self2.id;
+            });
+            function unhover() {
+              Fx.loneUnhover(fullLayout._hoverlayer);
+            }
+            map2.on("dragstart", function() {
+              self2.dragging = true;
+              unhover();
+            });
+            map2.on("zoomstart", unhover);
+            map2.on("mouseout", function() {
+              gd2._fullLayout._hoversubplot = null;
+            });
+            function emitUpdate() {
+              var viewNow = self2.getView();
+              gd2.emit("plotly_relayouting", self2.getViewEditsWithDerived(viewNow));
+            }
+            map2.on("drag", emitUpdate);
+            map2.on("zoom", emitUpdate);
+            map2.on("dblclick", function() {
+              var optsNow = gd2._fullLayout[self2.id];
+              Registry.call("_storeDirectGUIEdit", gd2.layout, gd2._fullLayout._preGUI, self2.getViewEdits(optsNow));
+              var viewInitial = self2.viewInitial;
+              map2.setCenter(convertCenter(viewInitial.center));
+              map2.setZoom(viewInitial.zoom);
+              map2.setBearing(viewInitial.bearing);
+              map2.setPitch(viewInitial.pitch);
+              var viewNow = self2.getView();
+              optsNow._input.center = optsNow.center = viewNow.center;
+              optsNow._input.zoom = optsNow.zoom = viewNow.zoom;
+              optsNow._input.bearing = optsNow.bearing = viewNow.bearing;
+              optsNow._input.pitch = optsNow.pitch = viewNow.pitch;
+              gd2.emit("plotly_doubleclick", null);
+              gd2.emit("plotly_relayout", self2.getViewEditsWithDerived(viewNow));
+            });
+            self2.clearOutline = function() {
+              clearSelectionsCache(self2.dragOptions);
+              clearOutline(self2.dragOptions.gd);
+            };
+            self2.onClickInPanFn = function(dragOptions) {
+              return function(evt) {
+                var clickMode = gd2._fullLayout.clickmode;
+                if (clickMode.indexOf("select") > -1) {
+                  selectOnClick(evt.originalEvent, gd2, [self2.xaxis], [self2.yaxis], self2.id, dragOptions);
+                }
+                if (clickMode.indexOf("event") > -1) {
+                  Fx.click(gd2, evt.originalEvent);
+                }
+              };
+            };
+          };
+          proto.updateFx = function(fullLayout) {
+            var self2 = this;
+            var map2 = self2.map;
+            var gd2 = self2.gd;
+            if (self2.isStatic) return;
+            function invert2(pxpy) {
+              var obj = self2.map.unproject(pxpy);
+              return [obj.lng, obj.lat];
+            }
+            var dragMode = fullLayout.dragmode;
+            var fillRangeItems;
+            fillRangeItems = function(eventData, poly) {
+              if (poly.isRect) {
+                var ranges = eventData.range = {};
+                ranges[self2.id] = [
+                  invert2([poly.xmin, poly.ymin]),
+                  invert2([poly.xmax, poly.ymax])
+                ];
+              } else {
+                var dataPts = eventData.lassoPoints = {};
+                dataPts[self2.id] = poly.map(invert2);
+              }
+            };
+            var oldDragOptions = self2.dragOptions;
+            self2.dragOptions = Lib.extendDeep(oldDragOptions || {}, {
+              dragmode: fullLayout.dragmode,
+              element: self2.div,
+              gd: gd2,
+              plotinfo: {
+                id: self2.id,
+                domain: fullLayout[self2.id].domain,
+                xaxis: self2.xaxis,
+                yaxis: self2.yaxis,
+                fillRangeItems
+              },
+              xaxes: [self2.xaxis],
+              yaxes: [self2.yaxis],
+              subplot: self2.id
+            });
+            map2.off("click", self2.onClickInPanHandler);
+            if (selectMode(dragMode) || drawMode(dragMode)) {
+              map2.dragPan.disable();
+              map2.on("zoomstart", self2.clearOutline);
+              self2.dragOptions.prepFn = function(e2, startX, startY) {
+                prepSelect(e2, startX, startY, self2.dragOptions, dragMode);
+              };
+              dragElement.init(self2.dragOptions);
+            } else {
+              map2.dragPan.enable();
+              map2.off("zoomstart", self2.clearOutline);
+              self2.div.onmousedown = null;
+              self2.div.ontouchstart = null;
+              self2.div.removeEventListener("touchstart", self2.div._ontouchstart);
+              self2.onClickInPanHandler = self2.onClickInPanFn(self2.dragOptions);
+              map2.on("click", self2.onClickInPanHandler);
+            }
+          };
+          proto.updateFramework = function(fullLayout) {
+            var domain = fullLayout[this.id].domain;
+            var size = fullLayout._size;
+            var style = this.div.style;
+            style.width = size.w * (domain.x[1] - domain.x[0]) + "px";
+            style.height = size.h * (domain.y[1] - domain.y[0]) + "px";
+            style.left = size.l + domain.x[0] * size.w + "px";
+            style.top = size.t + (1 - domain.y[1]) * size.h + "px";
+            this.xaxis._offset = size.l + domain.x[0] * size.w;
+            this.xaxis._length = size.w * (domain.x[1] - domain.x[0]);
+            this.yaxis._offset = size.t + (1 - domain.y[1]) * size.h;
+            this.yaxis._length = size.h * (domain.y[1] - domain.y[0]);
+          };
+          proto.updateLayers = function(fullLayout) {
+            var opts = fullLayout[this.id];
+            var layers = opts.layers;
+            var layerList = this.layerList;
+            var i2;
+            if (layers.length !== layerList.length) {
+              for (i2 = 0; i2 < layerList.length; i2++) {
+                layerList[i2].dispose();
+              }
+              layerList = this.layerList = [];
+              for (i2 = 0; i2 < layers.length; i2++) {
+                layerList.push(createMapboxLayer(this, i2, layers[i2]));
+              }
+            } else {
+              for (i2 = 0; i2 < layers.length; i2++) {
+                layerList[i2].update(layers[i2]);
+              }
+            }
+          };
+          proto.destroy = function() {
+            if (this.map) {
+              this.map.remove();
+              this.map = null;
+              this.container.removeChild(this.div);
+            }
+          };
+          proto.toImage = function() {
+            this.map.stop();
+            return this.map.getCanvas().toDataURL();
+          };
+          proto.setOptions = function(id2, methodName, opts) {
+            for (var k2 in opts) {
+              this.map[methodName](id2, k2, opts[k2]);
+            }
+          };
+          proto.getMapLayers = function() {
+            return this.map.getStyle().layers;
+          };
+          proto.addLayer = function(opts, below) {
+            var map2 = this.map;
+            if (typeof below === "string") {
+              if (below === "") {
+                map2.addLayer(opts, below);
+                return;
+              }
+              var mapLayers = this.getMapLayers();
+              for (var i2 = 0; i2 < mapLayers.length; i2++) {
+                if (below === mapLayers[i2].id) {
+                  map2.addLayer(opts, below);
+                  return;
+                }
+              }
+              Lib.warn([
+                "Trying to add layer with *below* value",
+                below,
+                "referencing a layer that does not exist",
+                "or that does not yet exist."
+              ].join(" "));
+            }
+            map2.addLayer(opts);
+          };
+          proto.project = function(v2) {
+            return this.map.project(new mapboxgl.LngLat(v2[0], v2[1]));
+          };
+          proto.getView = function() {
+            var map2 = this.map;
+            var mapCenter = map2.getCenter();
+            var lon = mapCenter.lng;
+            var lat = mapCenter.lat;
+            var center = { lon, lat };
+            var canvas2 = map2.getCanvas();
+            var w2 = parseInt(canvas2.style.width);
+            var h2 = parseInt(canvas2.style.height);
+            return {
+              center,
+              zoom: map2.getZoom(),
+              bearing: map2.getBearing(),
+              pitch: map2.getPitch(),
+              _derived: {
+                coordinates: [
+                  map2.unproject([0, 0]).toArray(),
+                  map2.unproject([w2, 0]).toArray(),
+                  map2.unproject([w2, h2]).toArray(),
+                  map2.unproject([0, h2]).toArray()
+                ]
+              }
+            };
+          };
+          proto.getViewEdits = function(cont) {
+            var id2 = this.id;
+            var keys = ["center", "zoom", "bearing", "pitch"];
+            var obj = {};
+            for (var i2 = 0; i2 < keys.length; i2++) {
+              var k2 = keys[i2];
+              obj[id2 + "." + k2] = cont[k2];
+            }
+            return obj;
+          };
+          proto.getViewEditsWithDerived = function(cont) {
+            var id2 = this.id;
+            var obj = this.getViewEdits(cont);
+            obj[id2 + "._derived"] = cont._derived;
+            return obj;
+          };
+          function getStyleObj(val, fullLayout) {
+            var styleObj = {};
+            if (Lib.isPlainObject(val)) {
+              styleObj.id = val.id;
+              styleObj.style = val;
+            } else if (typeof val === "string") {
+              styleObj.id = val;
+              if (constants.styleValuesMapbox.indexOf(val) !== -1) {
+                styleObj.style = convertStyleVal(val);
+              } else if (constants.stylesNonMapbox[val]) {
+                styleObj.style = constants.stylesNonMapbox[val];
+                var spec = styleObj.style.sources["plotly-" + val];
+                var tiles = spec ? spec.tiles : void 0;
+                if (tiles && tiles[0] && tiles[0].slice(-9) === "?api_key=") {
+                  tiles[0] += fullLayout._mapboxAccessToken;
+                }
+              } else {
+                styleObj.style = val;
+              }
+            } else {
+              styleObj.id = constants.styleValueDflt;
+              styleObj.style = convertStyleVal(constants.styleValueDflt);
+            }
+            styleObj.transition = { duration: 0, delay: 0 };
+            return styleObj;
+          }
+          function convertStyleVal(val) {
+            return constants.styleUrlPrefix + val + "-" + constants.styleUrlSuffix;
+          }
+          function convertCenter(center) {
+            return [center.lon, center.lat];
+          }
+          module2.exports = Mapbox;
+        }
+      });
+      var require_layout_defaults17 = __commonJS({
+        "src/plots/mapbox/layout_defaults.js"(exports, module2) {
+          var Lib = require_lib();
+          var handleSubplotDefaults = require_subplot_defaults();
+          var handleArrayContainerDefaults = require_array_container_defaults();
+          var layoutAttributes = require_layout_attributes19();
+          module2.exports = function supplyLayoutDefaults(layoutIn, layoutOut, fullData) {
+            handleSubplotDefaults(layoutIn, layoutOut, fullData, {
+              type: "mapbox",
+              attributes: layoutAttributes,
+              handleDefaults,
+              partition: "y",
+              accessToken: layoutOut._mapboxAccessToken
+            });
+          };
+          function handleDefaults(containerIn, containerOut, coerce, opts) {
+            coerce("accesstoken", opts.accessToken);
+            coerce("style");
+            coerce("center.lon");
+            coerce("center.lat");
+            coerce("zoom");
+            coerce("bearing");
+            coerce("pitch");
+            var west = coerce("bounds.west");
+            var east = coerce("bounds.east");
+            var south = coerce("bounds.south");
+            var north = coerce("bounds.north");
+            if (west === void 0 || east === void 0 || south === void 0 || north === void 0) {
+              delete containerOut.bounds;
+            }
+            handleArrayContainerDefaults(containerIn, containerOut, {
+              name: "layers",
+              handleItemDefaults: handleLayerDefaults
+            });
+            containerOut._input = containerIn;
+          }
+          function handleLayerDefaults(layerIn, layerOut) {
+            function coerce(attr, dflt) {
+              return Lib.coerce(layerIn, layerOut, layoutAttributes.layers, attr, dflt);
+            }
+            var visible = coerce("visible");
+            if (visible) {
+              var sourceType = coerce("sourcetype");
+              var mustBeRasterLayer = sourceType === "raster" || sourceType === "image";
+              coerce("source");
+              coerce("sourceattribution");
+              if (sourceType === "vector") {
+                coerce("sourcelayer");
+              }
+              if (sourceType === "image") {
+                coerce("coordinates");
+              }
+              var typeDflt;
+              if (mustBeRasterLayer) typeDflt = "raster";
+              var type = coerce("type", typeDflt);
+              if (mustBeRasterLayer && type !== "raster") {
+                type = layerOut.type = "raster";
+                Lib.log("Source types *raster* and *image* must drawn *raster* layer type.");
+              }
+              coerce("below");
+              coerce("color");
+              coerce("opacity");
+              coerce("minzoom");
+              coerce("maxzoom");
+              if (type === "circle") {
+                coerce("circle.radius");
+              }
+              if (type === "line") {
+                coerce("line.width");
+                coerce("line.dash");
+              }
+              if (type === "fill") {
+                coerce("fill.outlinecolor");
+              }
+              if (type === "symbol") {
+                coerce("symbol.icon");
+                coerce("symbol.iconsize");
+                coerce("symbol.text");
+                Lib.coerceFont(coerce, "symbol.textfont", void 0, {
+                  noFontVariant: true,
+                  noFontShadow: true,
+                  noFontLineposition: true,
+                  noFontTextcase: true
+                });
+                coerce("symbol.textposition");
+                coerce("symbol.placement");
+              }
+            }
+          }
+        }
+      });
+      var require_mapbox2 = __commonJS({
+        "src/plots/mapbox/index.js"(exports) {
+          var mapboxgl = require_mapbox_gl_unminified();
+          var Lib = require_lib();
+          var strTranslate = Lib.strTranslate;
+          var strScale = Lib.strScale;
+          var getSubplotCalcData = require_get_data().getSubplotCalcData;
+          var xmlnsNamespaces = require_xmlns_namespaces();
+          var d3 = require_d3();
+          var Drawing = require_drawing();
+          var svgTextUtils = require_svg_text_utils();
+          var Mapbox = require_mapbox();
+          var MAPBOX = "mapbox";
+          var constants = exports.constants = require_constants25();
+          exports.name = MAPBOX;
+          exports.attr = "subplot";
+          exports.idRoot = MAPBOX;
+          exports.idRegex = exports.attrRegex = Lib.counterRegex(MAPBOX);
+          var deprecationWarning = [
+            "mapbox subplots and traces are deprecated!",
+            "Please consider switching to `map` subplots and traces.",
+            "Learn more at: https://plotly.com/python/maplibre-migration/",
+            "as well as https://plotly.com/javascript/maplibre-migration/"
+          ].join(" ");
+          exports.attributes = {
+            subplot: {
+              valType: "subplotid",
+              dflt: "mapbox",
+              editType: "calc"
+            }
+          };
+          exports.layoutAttributes = require_layout_attributes19();
+          exports.supplyLayoutDefaults = require_layout_defaults17();
+          var firstPlot = true;
+          exports.plot = function plot(gd2) {
+            if (firstPlot) {
+              firstPlot = false;
+              Lib.warn(deprecationWarning);
+            }
+            var fullLayout = gd2._fullLayout;
+            var calcData = gd2.calcdata;
+            var mapboxIds = fullLayout._subplots[MAPBOX];
+            if (mapboxgl.version !== constants.requiredVersion) {
+              throw new Error(constants.wrongVersionErrorMsg);
+            }
+            var accessToken = findAccessToken(gd2, mapboxIds);
+            mapboxgl.accessToken = accessToken;
+            for (var i2 = 0; i2 < mapboxIds.length; i2++) {
+              var id2 = mapboxIds[i2];
+              var subplotCalcData = getSubplotCalcData(calcData, MAPBOX, id2);
+              var opts = fullLayout[id2];
+              var mapbox = opts._subplot;
+              if (!mapbox) {
+                mapbox = new Mapbox(gd2, id2);
+                fullLayout[id2]._subplot = mapbox;
+              }
+              if (!mapbox.viewInitial) {
+                mapbox.viewInitial = {
+                  center: Lib.extendFlat({}, opts.center),
+                  zoom: opts.zoom,
+                  bearing: opts.bearing,
+                  pitch: opts.pitch
+                };
+              }
+              mapbox.plot(subplotCalcData, fullLayout, gd2._promises);
+            }
+          };
+          exports.clean = function(newFullData, newFullLayout, oldFullData, oldFullLayout) {
+            var oldMapboxKeys = oldFullLayout._subplots[MAPBOX] || [];
+            for (var i2 = 0; i2 < oldMapboxKeys.length; i2++) {
+              var oldMapboxKey = oldMapboxKeys[i2];
+              if (!newFullLayout[oldMapboxKey] && !!oldFullLayout[oldMapboxKey]._subplot) {
+                oldFullLayout[oldMapboxKey]._subplot.destroy();
+              }
+            }
+          };
+          exports.toSVG = function(gd2) {
+            var fullLayout = gd2._fullLayout;
+            var subplotIds = fullLayout._subplots[MAPBOX];
+            var size = fullLayout._size;
+            for (var i2 = 0; i2 < subplotIds.length; i2++) {
+              var opts = fullLayout[subplotIds[i2]];
+              var domain = opts.domain;
+              var mapbox = opts._subplot;
+              var imageData = mapbox.toImage("png");
+              var image = fullLayout._glimages.append("svg:image");
+              image.attr({
+                xmlns: xmlnsNamespaces.svg,
+                "xlink:href": imageData,
+                x: size.l + size.w * domain.x[0],
+                y: size.t + size.h * (1 - domain.y[1]),
+                width: size.w * (domain.x[1] - domain.x[0]),
+                height: size.h * (domain.y[1] - domain.y[0]),
+                preserveAspectRatio: "none"
+              });
+              var subplotDiv = d3.select(opts._subplot.div);
+              var hidden = subplotDiv.select(".mapboxgl-ctrl-logo").node().offsetParent === null;
+              if (!hidden) {
+                var logo = fullLayout._glimages.append("g");
+                logo.attr("transform", strTranslate(size.l + size.w * domain.x[0] + 10, size.t + size.h * (1 - domain.y[0]) - 31));
+                logo.append("path").attr("d", constants.mapboxLogo.path0).style({
+                  opacity: 0.9,
+                  fill: "#ffffff",
+                  "enable-background": "new"
+                });
+                logo.append("path").attr("d", constants.mapboxLogo.path1).style("opacity", 0.35).style("enable-background", "new");
+                logo.append("path").attr("d", constants.mapboxLogo.path2).style("opacity", 0.35).style("enable-background", "new");
+                logo.append("polygon").attr("points", constants.mapboxLogo.polygon).style({
+                  opacity: 0.9,
+                  fill: "#ffffff",
+                  "enable-background": "new"
+                });
+              }
+              var attributions = subplotDiv.select(".mapboxgl-ctrl-attrib").text().replace("Improve this map", "");
+              var attributionGroup = fullLayout._glimages.append("g");
+              var attributionText = attributionGroup.append("text");
+              attributionText.text(attributions).classed("static-attribution", true).attr({
+                "font-size": 12,
+                "font-family": "Arial",
+                color: "rgba(0, 0, 0, 0.75)",
+                "text-anchor": "end",
+                "data-unformatted": attributions
+              });
+              var bBox = Drawing.bBox(attributionText.node());
+              var maxWidth = size.w * (domain.x[1] - domain.x[0]);
+              if (bBox.width > maxWidth / 2) {
+                var multilineAttributions = attributions.split("|").join("<br>");
+                attributionText.text(multilineAttributions).attr("data-unformatted", multilineAttributions).call(svgTextUtils.convertToTspans, gd2);
+                bBox = Drawing.bBox(attributionText.node());
+              }
+              attributionText.attr("transform", strTranslate(-3, -bBox.height + 8));
+              attributionGroup.insert("rect", ".static-attribution").attr({
+                x: -bBox.width - 6,
+                y: -bBox.height - 3,
+                width: bBox.width + 6,
+                height: bBox.height + 3,
+                fill: "rgba(255, 255, 255, 0.75)"
+              });
+              var scaleRatio = 1;
+              if (bBox.width + 6 > maxWidth) scaleRatio = maxWidth / (bBox.width + 6);
+              var offset = [size.l + size.w * domain.x[1], size.t + size.h * (1 - domain.y[0])];
+              attributionGroup.attr("transform", strTranslate(offset[0], offset[1]) + strScale(scaleRatio));
+            }
+          };
+          function findAccessToken(gd2, mapboxIds) {
+            var fullLayout = gd2._fullLayout;
+            var context = gd2._context;
+            if (context.mapboxAccessToken === "") return "";
+            var tokensUseful = [];
+            var tokensListed = [];
+            var hasOneSetMapboxStyle = false;
+            var wontWork = false;
+            for (var i2 = 0; i2 < mapboxIds.length; i2++) {
+              var opts = fullLayout[mapboxIds[i2]];
+              var token = opts.accesstoken;
+              if (isStyleRequireAccessToken(opts.style)) {
+                if (token) {
+                  Lib.pushUnique(tokensUseful, token);
+                } else {
+                  if (isStyleRequireAccessToken(opts._input.style)) {
+                    Lib.error("Uses Mapbox map style, but did not set an access token.");
+                    hasOneSetMapboxStyle = true;
+                  }
+                  wontWork = true;
+                }
+              }
+              if (token) {
+                Lib.pushUnique(tokensListed, token);
+              }
+            }
+            if (wontWork) {
+              var msg = hasOneSetMapboxStyle ? constants.noAccessTokenErrorMsg : constants.missingStyleErrorMsg;
+              Lib.error(msg);
+              throw new Error(msg);
+            }
+            if (tokensUseful.length) {
+              if (tokensUseful.length > 1) {
+                Lib.warn(constants.multipleTokensErrorMsg);
+              }
+              return tokensUseful[0];
+            } else {
+              if (tokensListed.length) {
+                Lib.log([
+                  "Listed mapbox access token(s)",
+                  tokensListed.join(","),
+                  "but did not use a Mapbox map style, ignoring token(s)."
+                ].join(" "));
+              }
+              return "";
+            }
+          }
+          function isStyleRequireAccessToken(s2) {
+            return typeof s2 === "string" && (constants.styleValuesMapbox.indexOf(s2) !== -1 || s2.indexOf("mapbox://") === 0 || s2.indexOf("stamen") === 0);
+          }
+          exports.updateFx = function(gd2) {
+            var fullLayout = gd2._fullLayout;
+            var subplotIds = fullLayout._subplots[MAPBOX];
+            for (var i2 = 0; i2 < subplotIds.length; i2++) {
+              var subplotObj = fullLayout[subplotIds[i2]]._subplot;
+              subplotObj.updateFx(fullLayout);
+            }
+          };
+        }
+      });
+      var require_scattermapbox = __commonJS({
+        "src/traces/scattermapbox/index.js"(exports, module2) {
+          module2.exports = {
+            attributes: require_attributes54(),
+            supplyDefaults: require_defaults50(),
+            colorbar: require_marker_colorbar(),
+            formatLabels: require_format_labels5(),
+            calc: require_calc27(),
+            plot: require_plot23(),
+            hoverPoints: require_hover18().hoverPoints,
+            eventData: require_event_data11(),
+            selectPoints: require_select9(),
+            styleOnSelect: function(_2, cd2) {
+              if (cd2) {
+                var trace = cd2[0].trace;
+                trace._glTrace.update(cd2);
+              }
+            },
+            moduleType: "trace",
+            name: "scattermapbox",
+            basePlotModule: require_mapbox2(),
+            categories: ["mapbox", "gl", "symbols", "showLegend", "scatter-like"],
+            meta: {}
+          };
+        }
+      });
+      var require_scattermapbox2 = __commonJS({
+        "lib/scattermapbox.js"(exports, module2) {
+          module2.exports = require_scattermapbox();
+        }
+      });
+      var require_attributes55 = __commonJS({
+        "src/traces/choroplethmapbox/attributes.js"(exports, module2) {
+          var choroplethAttrs = require_attributes49();
+          var colorScaleAttrs = require_attributes8();
+          var { hovertemplateAttrs, templatefallbackAttrs } = require_template_attributes();
+          var baseAttrs = require_attributes2();
+          var extendFlat = require_extend().extendFlat;
+          module2.exports = extendFlat(
+            {
+              locations: {
+                valType: "data_array",
+                editType: "calc"
+              },
+              // TODO
+              // Maybe start with only one value (that we could name e.g. 'geojson-id'),
+              // but eventually:
+              // - we could also support for our own dist/topojson/*
+              //   .. and locationmode: choroplethAttrs.locationmode,
+              z: {
+                valType: "data_array",
+                editType: "calc"
+              },
+              // TODO maybe we could also set a "key" to dig out values out of the
+              // GeoJSON feature `properties` fields?
+              geojson: {
+                valType: "any",
+                editType: "calc"
+              },
+              featureidkey: extendFlat({}, choroplethAttrs.featureidkey, {}),
+              // TODO agree on name / behaviour
+              //
+              // 'below' is used currently for layout.mapbox.layers,
+              // even though it's not very plotly-esque.
+              //
+              // Note also, that the mapbox-gl style don't all have the same layers,
+              // see https://codepen.io/etpinard/pen/ydVMwM for full list
+              below: {
+                valType: "string",
+                editType: "plot"
+              },
+              text: choroplethAttrs.text,
+              hovertext: choroplethAttrs.hovertext,
+              marker: {
+                line: {
+                  color: extendFlat({}, choroplethAttrs.marker.line.color, { editType: "plot" }),
+                  width: extendFlat({}, choroplethAttrs.marker.line.width, { editType: "plot" }),
+                  editType: "calc"
+                },
+                // TODO maybe having a dflt less than 1, together with `below:''` would be better?
+                opacity: extendFlat({}, choroplethAttrs.marker.opacity, { editType: "plot" }),
+                editType: "calc"
+              },
+              selected: {
+                marker: {
+                  opacity: extendFlat({}, choroplethAttrs.selected.marker.opacity, { editType: "plot" }),
+                  editType: "plot"
+                },
+                editType: "plot"
+              },
+              unselected: {
+                marker: {
+                  opacity: extendFlat({}, choroplethAttrs.unselected.marker.opacity, { editType: "plot" }),
+                  editType: "plot"
+                },
+                editType: "plot"
+              },
+              hoverinfo: choroplethAttrs.hoverinfo,
+              hovertemplate: hovertemplateAttrs({}, { keys: ["properties"] }),
+              hovertemplatefallback: templatefallbackAttrs(),
+              showlegend: extendFlat({}, baseAttrs.showlegend, { dflt: false })
+            },
+            colorScaleAttrs("", {
+              cLetter: "z",
+              editTypeOverride: "calc"
+            })
+          );
+        }
+      });
+      var require_defaults51 = __commonJS({
+        "src/traces/choroplethmapbox/defaults.js"(exports, module2) {
+          var Lib = require_lib();
+          var colorscaleDefaults = require_defaults2();
+          var attributes = require_attributes55();
+          module2.exports = function supplyDefaults(traceIn, traceOut, defaultColor, layout) {
+            function coerce(attr, dflt) {
+              return Lib.coerce(traceIn, traceOut, attributes, attr, dflt);
+            }
+            var locations = coerce("locations");
+            var z2 = coerce("z");
+            var geojson = coerce("geojson");
+            if (!Lib.isArrayOrTypedArray(locations) || !locations.length || !Lib.isArrayOrTypedArray(z2) || !z2.length || !(typeof geojson === "string" && geojson !== "" || Lib.isPlainObject(geojson))) {
+              traceOut.visible = false;
+              return;
+            }
+            coerce("featureidkey");
+            traceOut._length = Math.min(locations.length, z2.length);
+            coerce("below");
+            coerce("text");
+            coerce("hovertext");
+            coerce("hovertemplate");
+            coerce("hovertemplatefallback");
+            var mlw = coerce("marker.line.width");
+            if (mlw) coerce("marker.line.color");
+            coerce("marker.opacity");
+            colorscaleDefaults(traceIn, traceOut, layout, coerce, { prefix: "", cLetter: "z" });
+            Lib.coerceSelectionMarkerOpacity(traceOut, coerce);
+          };
+        }
+      });
+      var require_convert12 = __commonJS({
+        "src/traces/choroplethmapbox/convert.js"(exports, module2) {
+          var isNumeric = require_fast_isnumeric();
+          var Lib = require_lib();
+          var Colorscale = require_colorscale();
+          var Drawing = require_drawing();
+          var makeBlank = require_geojson_utils().makeBlank;
+          var geoUtils = require_geo_location_utils();
+          function convert(calcTrace) {
+            var trace = calcTrace[0].trace;
+            var isVisible = trace.visible === true && trace._length !== 0;
+            var fill = {
+              layout: { visibility: "none" },
+              paint: {}
+            };
+            var line = {
+              layout: { visibility: "none" },
+              paint: {}
+            };
+            var opts = trace._opts = {
+              fill,
+              line,
+              geojson: makeBlank()
+            };
+            if (!isVisible) return opts;
+            var features = geoUtils.extractTraceFeature(calcTrace);
+            if (!features) return opts;
+            var sclFunc = Colorscale.makeColorScaleFuncFromTrace(trace);
+            var marker = trace.marker;
+            var markerLine = marker.line || {};
+            var opacityFn;
+            if (Lib.isArrayOrTypedArray(marker.opacity)) {
+              opacityFn = function(d2) {
+                var mo = d2.mo;
+                return isNumeric(mo) ? +Lib.constrain(mo, 0, 1) : 0;
+              };
+            }
+            var lineColorFn;
+            if (Lib.isArrayOrTypedArray(markerLine.color)) {
+              lineColorFn = function(d2) {
+                return d2.mlc;
+              };
+            }
+            var lineWidthFn;
+            if (Lib.isArrayOrTypedArray(markerLine.width)) {
+              lineWidthFn = function(d2) {
+                return d2.mlw;
+              };
+            }
+            for (var i2 = 0; i2 < calcTrace.length; i2++) {
+              var cdi = calcTrace[i2];
+              var fOut = cdi.fOut;
+              if (fOut) {
+                var props = fOut.properties;
+                props.fc = sclFunc(cdi.z);
+                if (opacityFn) props.mo = opacityFn(cdi);
+                if (lineColorFn) props.mlc = lineColorFn(cdi);
+                if (lineWidthFn) props.mlw = lineWidthFn(cdi);
+                cdi.ct = props.ct;
+                cdi._polygons = geoUtils.feature2polygons(fOut);
+              }
+            }
+            var opacitySetting = opacityFn ? { type: "identity", property: "mo" } : marker.opacity;
+            Lib.extendFlat(fill.paint, {
+              "fill-color": { type: "identity", property: "fc" },
+              "fill-opacity": opacitySetting
+            });
+            Lib.extendFlat(line.paint, {
+              "line-color": lineColorFn ? { type: "identity", property: "mlc" } : markerLine.color,
+              "line-width": lineWidthFn ? { type: "identity", property: "mlw" } : markerLine.width,
+              "line-opacity": opacitySetting
+            });
+            fill.layout.visibility = "visible";
+            line.layout.visibility = "visible";
+            opts.geojson = { type: "FeatureCollection", features };
+            convertOnSelect(calcTrace);
+            return opts;
+          }
+          function convertOnSelect(calcTrace) {
+            var trace = calcTrace[0].trace;
+            var opts = trace._opts;
+            var opacitySetting;
+            if (trace.selectedpoints) {
+              var fns = Drawing.makeSelectedPointStyleFns(trace);
+              for (var i2 = 0; i2 < calcTrace.length; i2++) {
+                var cdi = calcTrace[i2];
+                if (cdi.fOut) {
+                  cdi.fOut.properties.mo2 = fns.selectedOpacityFn(cdi);
+                }
+              }
+              opacitySetting = { type: "identity", property: "mo2" };
+            } else {
+              opacitySetting = Lib.isArrayOrTypedArray(trace.marker.opacity) ? { type: "identity", property: "mo" } : trace.marker.opacity;
+            }
+            Lib.extendFlat(opts.fill.paint, { "fill-opacity": opacitySetting });
+            Lib.extendFlat(opts.line.paint, { "line-opacity": opacitySetting });
+            return opts;
+          }
+          module2.exports = {
+            convert,
+            convertOnSelect
+          };
+        }
+      });
+      var require_plot24 = __commonJS({
+        "src/traces/choroplethmapbox/plot.js"(exports, module2) {
+          var convert = require_convert12().convert;
+          var convertOnSelect = require_convert12().convertOnSelect;
+          var LAYER_PREFIX = require_constants25().traceLayerPrefix;
+          function ChoroplethMapbox(subplot, uid2) {
+            this.type = "choroplethmapbox";
+            this.subplot = subplot;
+            this.uid = uid2;
+            this.sourceId = "source-" + uid2;
+            this.layerList = [
+              ["fill", LAYER_PREFIX + uid2 + "-fill"],
+              ["line", LAYER_PREFIX + uid2 + "-line"]
+            ];
+            this.below = null;
+          }
+          var proto = ChoroplethMapbox.prototype;
+          proto.update = function(calcTrace) {
+            this._update(convert(calcTrace));
+            calcTrace[0].trace._glTrace = this;
+          };
+          proto.updateOnSelect = function(calcTrace) {
+            this._update(convertOnSelect(calcTrace));
+          };
+          proto._update = function(optsAll) {
+            var subplot = this.subplot;
+            var layerList = this.layerList;
+            var below = subplot.belowLookup["trace-" + this.uid];
+            subplot.map.getSource(this.sourceId).setData(optsAll.geojson);
+            if (below !== this.below) {
+              this._removeLayers();
+              this._addLayers(optsAll, below);
+              this.below = below;
+            }
+            for (var i2 = 0; i2 < layerList.length; i2++) {
+              var item = layerList[i2];
+              var k2 = item[0];
+              var id2 = item[1];
+              var opts = optsAll[k2];
+              subplot.setOptions(id2, "setLayoutProperty", opts.layout);
+              if (opts.layout.visibility === "visible") {
+                subplot.setOptions(id2, "setPaintProperty", opts.paint);
+              }
+            }
+          };
+          proto._addLayers = function(optsAll, below) {
+            var subplot = this.subplot;
+            var layerList = this.layerList;
+            var sourceId = this.sourceId;
+            for (var i2 = 0; i2 < layerList.length; i2++) {
+              var item = layerList[i2];
+              var k2 = item[0];
+              var opts = optsAll[k2];
+              subplot.addLayer({
+                type: k2,
+                id: item[1],
+                source: sourceId,
+                layout: opts.layout,
+                paint: opts.paint
+              }, below);
+            }
+          };
+          proto._removeLayers = function() {
+            var map2 = this.subplot.map;
+            var layerList = this.layerList;
+            for (var i2 = layerList.length - 1; i2 >= 0; i2--) {
+              map2.removeLayer(layerList[i2][1]);
+            }
+          };
+          proto.dispose = function() {
+            var map2 = this.subplot.map;
+            this._removeLayers();
+            map2.removeSource(this.sourceId);
+          };
+          module2.exports = function createChoroplethMapbox(subplot, calcTrace) {
+            var trace = calcTrace[0].trace;
+            var choroplethMapbox = new ChoroplethMapbox(subplot, trace.uid);
+            var sourceId = choroplethMapbox.sourceId;
+            var optsAll = convert(calcTrace);
+            var below = choroplethMapbox.below = subplot.belowLookup["trace-" + trace.uid];
+            subplot.map.addSource(sourceId, {
+              type: "geojson",
+              data: optsAll.geojson
+            });
+            choroplethMapbox._addLayers(optsAll, below);
+            calcTrace[0].trace._glTrace = choroplethMapbox;
+            return choroplethMapbox;
+          };
+        }
+      });
+      var require_choroplethmapbox = __commonJS({
+        "src/traces/choroplethmapbox/index.js"(exports, module2) {
+          module2.exports = {
+            attributes: require_attributes55(),
+            supplyDefaults: require_defaults51(),
+            colorbar: require_colorbar2(),
+            calc: require_calc28(),
+            plot: require_plot24(),
+            hoverPoints: require_hover15(),
+            eventData: require_event_data10(),
+            selectPoints: require_select6(),
+            styleOnSelect: function(_2, cd2) {
+              if (cd2) {
+                var trace = cd2[0].trace;
+                trace._glTrace.updateOnSelect(cd2);
+              }
+            },
+            getBelow: function(trace, subplot) {
+              var mapLayers = subplot.getMapLayers();
+              for (var i2 = mapLayers.length - 2; i2 >= 0; i2--) {
+                var layerId = mapLayers[i2].id;
+                if (typeof layerId === "string" && layerId.indexOf("water") === 0) {
+                  for (var j2 = i2 + 1; j2 < mapLayers.length; j2++) {
+                    layerId = mapLayers[j2].id;
+                    if (typeof layerId === "string" && layerId.indexOf("plotly-") === -1) {
+                      return layerId;
+                    }
+                  }
+                }
+              }
+            },
+            moduleType: "trace",
+            name: "choroplethmapbox",
+            basePlotModule: require_mapbox2(),
+            categories: ["mapbox", "gl", "noOpacity", "showLegend"],
+            meta: {
+              hr_name: "choropleth_mapbox"
+            }
+          };
+        }
+      });
+      var require_choroplethmapbox2 = __commonJS({
+        "lib/choroplethmapbox.js"(exports, module2) {
+          module2.exports = require_choroplethmapbox();
+        }
+      });
+      var require_attributes56 = __commonJS({
+        "src/traces/densitymapbox/attributes.js"(exports, module2) {
+          var colorScaleAttrs = require_attributes8();
+          var { hovertemplateAttrs, templatefallbackAttrs } = require_template_attributes();
+          var baseAttrs = require_attributes2();
+          var scatterMapboxAttrs = require_attributes54();
+          var extendFlat = require_extend().extendFlat;
+          module2.exports = extendFlat(
+            {
+              lon: scatterMapboxAttrs.lon,
+              lat: scatterMapboxAttrs.lat,
+              z: {
+                valType: "data_array",
+                editType: "calc"
+              },
+              radius: {
+                valType: "number",
+                editType: "plot",
+                arrayOk: true,
+                min: 1,
+                dflt: 30
+              },
+              below: {
+                valType: "string",
+                editType: "plot"
+              },
+              text: scatterMapboxAttrs.text,
+              hovertext: scatterMapboxAttrs.hovertext,
+              hoverinfo: extendFlat({}, baseAttrs.hoverinfo, {
+                flags: ["lon", "lat", "z", "text", "name"]
+              }),
+              hovertemplate: hovertemplateAttrs(),
+              hovertemplatefallback: templatefallbackAttrs(),
+              showlegend: extendFlat({}, baseAttrs.showlegend, { dflt: false })
+            },
+            colorScaleAttrs("", {
+              cLetter: "z",
+              editTypeOverride: "calc"
+            })
+          );
+        }
+      });
+      var require_defaults52 = __commonJS({
+        "src/traces/densitymapbox/defaults.js"(exports, module2) {
+          var Lib = require_lib();
+          var colorscaleDefaults = require_defaults2();
+          var attributes = require_attributes56();
+          module2.exports = function supplyDefaults(traceIn, traceOut, defaultColor, layout) {
+            function coerce(attr, dflt) {
+              return Lib.coerce(traceIn, traceOut, attributes, attr, dflt);
+            }
+            var lon = coerce("lon") || [];
+            var lat = coerce("lat") || [];
+            var len2 = Math.min(lon.length, lat.length);
+            if (!len2) {
+              traceOut.visible = false;
+              return;
+            }
+            traceOut._length = len2;
+            coerce("z");
+            coerce("radius");
+            coerce("below");
+            coerce("text");
+            coerce("hovertext");
+            coerce("hovertemplate");
+            coerce("hovertemplatefallback");
+            colorscaleDefaults(traceIn, traceOut, layout, coerce, { prefix: "", cLetter: "z" });
+          };
+        }
+      });
+      var require_calc33 = __commonJS({
+        "src/traces/densitymapbox/calc.js"(exports, module2) {
+          var isNumeric = require_fast_isnumeric();
+          var isArrayOrTypedArray = require_lib().isArrayOrTypedArray;
+          var BADNUM = require_numerical().BADNUM;
+          var colorscaleCalc = require_calc();
+          var _2 = require_lib()._;
+          module2.exports = function calc(gd2, trace) {
+            var len2 = trace._length;
+            var calcTrace = new Array(len2);
+            var z2 = trace.z;
+            var hasZ = isArrayOrTypedArray(z2) && z2.length;
+            for (var i2 = 0; i2 < len2; i2++) {
+              var cdi = calcTrace[i2] = {};
+              var lon = trace.lon[i2];
+              var lat = trace.lat[i2];
+              cdi.lonlat = isNumeric(lon) && isNumeric(lat) ? [+lon, +lat] : [BADNUM, BADNUM];
+              if (hasZ) {
+                var zi2 = z2[i2];
+                cdi.z = isNumeric(zi2) ? zi2 : BADNUM;
+              }
+            }
+            colorscaleCalc(gd2, trace, {
+              vals: hasZ ? z2 : [0, 1],
+              containerStr: "",
+              cLetter: "z"
+            });
+            if (len2) {
+              calcTrace[0].t = {
+                labels: {
+                  lat: _2(gd2, "lat:") + " ",
+                  lon: _2(gd2, "lon:") + " "
+                }
+              };
+            }
+            return calcTrace;
+          };
+        }
+      });
+      var require_convert13 = __commonJS({
+        "src/traces/densitymapbox/convert.js"(exports, module2) {
+          var isNumeric = require_fast_isnumeric();
+          var Lib = require_lib();
+          var Color2 = require_color();
+          var Colorscale = require_colorscale();
+          var BADNUM = require_numerical().BADNUM;
+          var makeBlank = require_geojson_utils().makeBlank;
+          module2.exports = function convert(calcTrace) {
+            var trace = calcTrace[0].trace;
+            var isVisible = trace.visible === true && trace._length !== 0;
+            var heatmap = {
+              layout: { visibility: "none" },
+              paint: {}
+            };
+            var opts = trace._opts = {
+              heatmap,
+              geojson: makeBlank()
+            };
+            if (!isVisible) return opts;
+            var features = [];
+            var i2;
+            var z2 = trace.z;
+            var radius = trace.radius;
+            var hasZ = Lib.isArrayOrTypedArray(z2) && z2.length;
+            var hasArrayRadius = Lib.isArrayOrTypedArray(radius);
+            for (i2 = 0; i2 < calcTrace.length; i2++) {
+              var cdi = calcTrace[i2];
+              var lonlat = cdi.lonlat;
+              if (lonlat[0] !== BADNUM) {
+                var props = {};
+                if (hasZ) {
+                  var zi2 = cdi.z;
+                  props.z = zi2 !== BADNUM ? zi2 : 0;
+                }
+                if (hasArrayRadius) {
+                  props.r = isNumeric(radius[i2]) && radius[i2] > 0 ? +radius[i2] : 0;
+                }
+                features.push({
+                  type: "Feature",
+                  geometry: { type: "Point", coordinates: lonlat },
+                  properties: props
+                });
+              }
+            }
+            var cOpts = Colorscale.extractOpts(trace);
+            var scl = cOpts.reversescale ? Colorscale.flipScale(cOpts.colorscale) : cOpts.colorscale;
+            var scl01 = scl[0][1];
+            var color0 = Color2.opacity(scl01) < 1 ? scl01 : Color2.addOpacity(scl01, 0);
+            var heatmapColor = [
+              "interpolate",
+              ["linear"],
+              ["heatmap-density"],
+              0,
+              color0
+            ];
+            for (i2 = 1; i2 < scl.length; i2++) {
+              heatmapColor.push(scl[i2][0], scl[i2][1]);
+            }
+            var zExp = [
+              "interpolate",
+              ["linear"],
+              ["get", "z"],
+              cOpts.min,
+              0,
+              cOpts.max,
+              1
+            ];
+            Lib.extendFlat(opts.heatmap.paint, {
+              "heatmap-weight": hasZ ? zExp : 1 / (cOpts.max - cOpts.min),
+              "heatmap-color": heatmapColor,
+              "heatmap-radius": hasArrayRadius ? { type: "identity", property: "r" } : trace.radius,
+              "heatmap-opacity": trace.opacity
+            });
+            opts.geojson = { type: "FeatureCollection", features };
+            opts.heatmap.layout.visibility = "visible";
+            return opts;
+          };
+        }
+      });
+      var require_plot25 = __commonJS({
+        "src/traces/densitymapbox/plot.js"(exports, module2) {
+          var convert = require_convert13();
+          var LAYER_PREFIX = require_constants25().traceLayerPrefix;
+          function DensityMapbox(subplot, uid2) {
+            this.type = "densitymapbox";
+            this.subplot = subplot;
+            this.uid = uid2;
+            this.sourceId = "source-" + uid2;
+            this.layerList = [
+              ["heatmap", LAYER_PREFIX + uid2 + "-heatmap"]
+            ];
+            this.below = null;
+          }
+          var proto = DensityMapbox.prototype;
+          proto.update = function(calcTrace) {
+            var subplot = this.subplot;
+            var layerList = this.layerList;
+            var optsAll = convert(calcTrace);
+            var below = subplot.belowLookup["trace-" + this.uid];
+            subplot.map.getSource(this.sourceId).setData(optsAll.geojson);
+            if (below !== this.below) {
+              this._removeLayers();
+              this._addLayers(optsAll, below);
+              this.below = below;
+            }
+            for (var i2 = 0; i2 < layerList.length; i2++) {
+              var item = layerList[i2];
+              var k2 = item[0];
+              var id2 = item[1];
+              var opts = optsAll[k2];
+              subplot.setOptions(id2, "setLayoutProperty", opts.layout);
+              if (opts.layout.visibility === "visible") {
+                subplot.setOptions(id2, "setPaintProperty", opts.paint);
+              }
+            }
+          };
+          proto._addLayers = function(optsAll, below) {
+            var subplot = this.subplot;
+            var layerList = this.layerList;
+            var sourceId = this.sourceId;
+            for (var i2 = 0; i2 < layerList.length; i2++) {
+              var item = layerList[i2];
+              var k2 = item[0];
+              var opts = optsAll[k2];
+              subplot.addLayer({
+                type: k2,
+                id: item[1],
+                source: sourceId,
+                layout: opts.layout,
+                paint: opts.paint
+              }, below);
+            }
+          };
+          proto._removeLayers = function() {
+            var map2 = this.subplot.map;
+            var layerList = this.layerList;
+            for (var i2 = layerList.length - 1; i2 >= 0; i2--) {
+              map2.removeLayer(layerList[i2][1]);
+            }
+          };
+          proto.dispose = function() {
+            var map2 = this.subplot.map;
+            this._removeLayers();
+            map2.removeSource(this.sourceId);
+          };
+          module2.exports = function createDensityMapbox(subplot, calcTrace) {
+            var trace = calcTrace[0].trace;
+            var densityMapbox = new DensityMapbox(subplot, trace.uid);
+            var sourceId = densityMapbox.sourceId;
+            var optsAll = convert(calcTrace);
+            var below = densityMapbox.below = subplot.belowLookup["trace-" + trace.uid];
+            subplot.map.addSource(sourceId, {
+              type: "geojson",
+              data: optsAll.geojson
+            });
+            densityMapbox._addLayers(optsAll, below);
+            return densityMapbox;
+          };
+        }
+      });
+      var require_hover19 = __commonJS({
+        "src/traces/densitymapbox/hover.js"(exports, module2) {
+          var Axes = require_axes();
+          var scatterMapboxHoverPoints = require_hover18().hoverPoints;
+          var getExtraText = require_hover18().getExtraText;
+          module2.exports = function hoverPoints(pointData, xval, yval) {
+            var pts = scatterMapboxHoverPoints(pointData, xval, yval);
+            if (!pts) return;
+            var newPointData = pts[0];
+            var cd2 = newPointData.cd;
+            var trace = cd2[0].trace;
+            var di2 = cd2[newPointData.index];
+            delete newPointData.color;
+            if ("z" in di2) {
+              var ax = newPointData.subplot.mockAxis;
+              newPointData.z = di2.z;
+              newPointData.zLabel = Axes.tickText(ax, ax.c2l(di2.z), "hover").text;
+            }
+            newPointData.extraText = getExtraText(trace, di2, cd2[0].t.labels);
+            return [newPointData];
+          };
+        }
+      });
+      var require_event_data12 = __commonJS({
+        "src/traces/densitymapbox/event_data.js"(exports, module2) {
+          module2.exports = function eventData(out, pt2) {
+            out.lon = pt2.lon;
+            out.lat = pt2.lat;
+            out.z = pt2.z;
+            return out;
+          };
+        }
+      });
+      var require_densitymapbox = __commonJS({
+        "src/traces/densitymapbox/index.js"(exports, module2) {
+          module2.exports = {
+            attributes: require_attributes56(),
+            supplyDefaults: require_defaults52(),
+            colorbar: require_colorbar2(),
+            formatLabels: require_format_labels5(),
+            calc: require_calc33(),
+            plot: require_plot25(),
+            hoverPoints: require_hover19(),
+            eventData: require_event_data12(),
+            getBelow: function(trace, subplot) {
+              var mapLayers = subplot.getMapLayers();
+              for (var i2 = 0; i2 < mapLayers.length; i2++) {
+                var layer = mapLayers[i2];
+                var layerId = layer.id;
+                if (layer.type === "symbol" && typeof layerId === "string" && layerId.indexOf("plotly-") === -1) {
+                  return layerId;
+                }
+              }
+            },
+            moduleType: "trace",
+            name: "densitymapbox",
+            basePlotModule: require_mapbox2(),
+            categories: ["mapbox", "gl", "showLegend"],
+            meta: {
+              hr_name: "density_mapbox"
+            }
+          };
+        }
+      });
+      var require_densitymapbox2 = __commonJS({
+        "lib/densitymapbox.js"(exports, module2) {
+          module2.exports = require_densitymapbox();
+        }
+      });
+      var require_arcgis_sat_hybrid = __commonJS({
+        "src/plots/map/styles/arcgis-sat-hybrid.js"(exports, module2) {
+          module2.exports = {
+            "version": 8,
+            "name": "orto",
+            "metadata": { "maputnik:renderer": "mlgljs" },
+            "center": [1.537786, 41.837539],
+            "zoom": 12,
+            "bearing": 0,
+            "pitch": 0,
+            "light": {
+              "anchor": "viewport",
+              "color": "white",
+              "intensity": 0.4,
+              "position": [1.15, 45, 30]
+            },
+            "sources": {
+              "ortoEsri": {
+                "type": "raster",
+                "tiles": [
+                  "https://server.arcgisonline.com/ArcGIS/rest/services/World_Imagery/MapServer/tile/{z}/{y}/{x}"
+                ],
+                "tileSize": 256,
+                "maxzoom": 18,
+                "attribution": "ESRI &copy; <a href='http://www.esri.com'>ESRI</a>"
+              },
+              "ortoInstaMaps": {
+                "type": "raster",
+                "tiles": [
+                  "https://tilemaps.icgc.cat/mapfactory/wmts/orto_8_12/CAT3857/{z}/{x}/{y}.png"
+                ],
+                "tileSize": 256,
+                "maxzoom": 13
+              },
+              "ortoICGC": {
+                "type": "raster",
+                "tiles": [
+                  "https://geoserveis.icgc.cat/icc_mapesmultibase/noutm/wmts/orto/GRID3857/{z}/{x}/{y}.jpeg"
+                ],
+                "tileSize": 256,
+                "minzoom": 13.1,
+                "maxzoom": 20
+              },
+              "openmaptiles": {
+                "type": "vector",
+                "url": "https://geoserveis.icgc.cat/contextmaps/basemap.json"
+              }
+            },
+            "sprite": "https://geoserveis.icgc.cat/contextmaps/sprites/sprite@1",
+            "glyphs": "https://geoserveis.icgc.cat/contextmaps/glyphs/{fontstack}/{range}.pbf",
+            "layers": [
+              {
+                "id": "background",
+                "type": "background",
+                "paint": { "background-color": "#F4F9F4" }
+              },
+              {
+                "id": "ortoEsri",
+                "type": "raster",
+                "source": "ortoEsri",
+                "maxzoom": 16,
+                "layout": { "visibility": "visible" }
+              },
+              {
+                "id": "ortoICGC",
+                "type": "raster",
+                "source": "ortoICGC",
+                "minzoom": 13.1,
+                "maxzoom": 19,
+                "layout": { "visibility": "visible" }
+              },
+              {
+                "id": "ortoInstaMaps",
+                "type": "raster",
+                "source": "ortoInstaMaps",
+                "maxzoom": 13,
+                "layout": { "visibility": "visible" }
+              },
+              {
+                "id": "waterway_tunnel",
+                "type": "line",
+                "source": "openmaptiles",
+                "source-layer": "waterway",
+                "minzoom": 14,
+                "filter": [
+                  "all",
+                  ["in", "class", "river", "stream", "canal"],
+                  ["==", "brunnel", "tunnel"]
+                ],
+                "layout": { "line-cap": "round" },
+                "paint": {
+                  "line-color": "#a0c8f0",
+                  "line-width": { "base": 1.3, "stops": [[13, 0.5], [20, 6]] },
+                  "line-dasharray": [2, 4]
+                }
+              },
+              {
+                "id": "waterway-other",
+                "type": "line",
+                "metadata": { "mapbox:group": "1444849382550.77" },
+                "source": "openmaptiles",
+                "source-layer": "waterway",
+                "filter": ["!in", "class", "canal", "river", "stream"],
+                "layout": { "line-cap": "round" },
+                "paint": {
+                  "line-color": "#a0c8f0",
+                  "line-width": { "base": 1.3, "stops": [[13, 0.5], [20, 2]] }
+                }
+              },
+              {
+                "id": "waterway-stream-canal",
+                "type": "line",
+                "metadata": { "mapbox:group": "1444849382550.77" },
+                "source": "openmaptiles",
+                "source-layer": "waterway",
+                "filter": [
+                  "all",
+                  ["in", "class", "canal", "stream"],
+                  ["!=", "brunnel", "tunnel"]
+                ],
+                "layout": { "line-cap": "round" },
+                "paint": {
+                  "line-color": "#a0c8f0",
+                  "line-width": { "base": 1.3, "stops": [[13, 0.5], [20, 6]] }
+                }
+              },
+              {
+                "id": "waterway-river",
+                "type": "line",
+                "metadata": { "mapbox:group": "1444849382550.77" },
+                "source": "openmaptiles",
+                "source-layer": "waterway",
+                "filter": ["all", ["==", "class", "river"], ["!=", "brunnel", "tunnel"]],
+                "layout": { "line-cap": "round" },
+                "paint": {
+                  "line-color": "#a0c8f0",
+                  "line-width": { "base": 1.2, "stops": [[10, 0.8], [20, 4]] },
+                  "line-opacity": 0.5
+                }
+              },
+              {
+                "id": "water-offset",
+                "type": "fill",
+                "metadata": { "mapbox:group": "1444849382550.77" },
+                "source": "openmaptiles",
+                "source-layer": "water",
+                "maxzoom": 8,
+                "filter": ["==", "$type", "Polygon"],
+                "layout": { "visibility": "visible" },
+                "paint": {
+                  "fill-opacity": 0,
+                  "fill-color": "#a0c8f0",
+                  "fill-translate": { "base": 1, "stops": [[6, [2, 0]], [8, [0, 0]]] }
+                }
+              },
+              {
+                "id": "water",
+                "type": "fill",
+                "metadata": { "mapbox:group": "1444849382550.77" },
+                "source": "openmaptiles",
+                "source-layer": "water",
+                "layout": { "visibility": "visible" },
+                "paint": { "fill-color": "hsl(210, 67%, 85%)", "fill-opacity": 0 }
+              },
+              {
+                "id": "water-pattern",
+                "type": "fill",
+                "metadata": { "mapbox:group": "1444849382550.77" },
+                "source": "openmaptiles",
+                "source-layer": "water",
+                "layout": { "visibility": "visible" },
+                "paint": {
+                  "fill-translate": [0, 2.5],
+                  "fill-pattern": "wave",
+                  "fill-opacity": 1
+                }
+              },
+              {
+                "id": "landcover-ice-shelf",
+                "type": "fill",
+                "metadata": { "mapbox:group": "1444849382550.77" },
+                "source": "openmaptiles",
+                "source-layer": "landcover",
+                "filter": ["==", "subclass", "ice_shelf"],
+                "layout": { "visibility": "visible" },
+                "paint": {
+                  "fill-color": "#fff",
+                  "fill-opacity": { "base": 1, "stops": [[0, 0.9], [10, 0.3]] }
+                }
+              },
+              {
+                "id": "tunnel-service-track-casing",
+                "type": "line",
+                "metadata": { "mapbox:group": "1444849354174.1904" },
+                "source": "openmaptiles",
+                "source-layer": "transportation",
+                "filter": [
+                  "all",
+                  ["==", "brunnel", "tunnel"],
+                  ["in", "class", "service", "track"]
+                ],
+                "layout": { "line-join": "round" },
+                "paint": {
+                  "line-color": "#cfcdca",
+                  "line-dasharray": [0.5, 0.25],
+                  "line-width": { "base": 1.2, "stops": [[15, 1], [16, 4], [20, 11]] }
+                }
+              },
+              {
+                "id": "tunnel-minor-casing",
+                "type": "line",
+                "metadata": { "mapbox:group": "1444849354174.1904" },
+                "source": "openmaptiles",
+                "source-layer": "transportation",
+                "filter": ["all", ["==", "brunnel", "tunnel"], ["==", "class", "minor"]],
+                "layout": { "line-join": "round" },
+                "paint": {
+                  "line-color": "#cfcdca",
+                  "line-opacity": { "stops": [[12, 0], [12.5, 1]] },
+                  "line-width": {
+                    "base": 1.2,
+                    "stops": [[12, 0.5], [13, 1], [14, 4], [20, 15]]
+                  }
+                }
+              },
+              {
+                "id": "tunnel-secondary-tertiary-casing",
+                "type": "line",
+                "metadata": { "mapbox:group": "1444849354174.1904" },
+                "source": "openmaptiles",
+                "source-layer": "transportation",
+                "filter": [
+                  "all",
+                  ["==", "brunnel", "tunnel"],
+                  ["in", "class", "secondary", "tertiary"]
+                ],
+                "layout": { "line-join": "round" },
+                "paint": {
+                  "line-color": "#e9ac77",
+                  "line-opacity": 1,
+                  "line-width": { "base": 1.2, "stops": [[8, 1.5], [20, 17]] }
+                }
+              },
+              {
+                "id": "tunnel-trunk-primary-casing",
+                "type": "line",
+                "metadata": { "mapbox:group": "1444849354174.1904" },
+                "source": "openmaptiles",
+                "source-layer": "transportation",
+                "filter": [
+                  "all",
+                  ["==", "brunnel", "tunnel"],
+                  ["in", "class", "primary", "trunk"]
+                ],
+                "layout": { "line-join": "round" },
+                "paint": {
+                  "line-color": "#e9ac77",
+                  "line-width": {
+                    "base": 1.2,
+                    "stops": [[5, 0.4], [6, 0.6], [7, 1.5], [20, 22]]
+                  },
+                  "line-opacity": 0.7
+                }
+              },
+              {
+                "id": "tunnel-motorway-casing",
+                "type": "line",
+                "metadata": { "mapbox:group": "1444849354174.1904" },
+                "source": "openmaptiles",
+                "source-layer": "transportation",
+                "filter": [
+                  "all",
+                  ["==", "brunnel", "tunnel"],
+                  ["==", "class", "motorway"]
+                ],
+                "layout": { "line-join": "round", "visibility": "visible" },
+                "paint": {
+                  "line-color": "#e9ac77",
+                  "line-dasharray": [0.5, 0.25],
+                  "line-width": {
+                    "base": 1.2,
+                    "stops": [[5, 0.4], [6, 0.6], [7, 1.5], [20, 22]]
+                  },
+                  "line-opacity": 0.5
+                }
+              },
+              {
+                "id": "tunnel-path",
+                "type": "line",
+                "metadata": { "mapbox:group": "1444849354174.1904" },
+                "source": "openmaptiles",
+                "source-layer": "transportation",
+                "filter": [
+                  "all",
+                  ["==", "$type", "LineString"],
+                  ["all", ["==", "brunnel", "tunnel"], ["==", "class", "path"]]
+                ],
+                "paint": {
+                  "line-color": "#cba",
+                  "line-dasharray": [1.5, 0.75],
+                  "line-width": { "base": 1.2, "stops": [[15, 1.2], [20, 4]] }
+                }
+              },
+              {
+                "id": "tunnel-service-track",
+                "type": "line",
+                "metadata": { "mapbox:group": "1444849354174.1904" },
+                "source": "openmaptiles",
+                "source-layer": "transportation",
+                "filter": [
+                  "all",
+                  ["==", "brunnel", "tunnel"],
+                  ["in", "class", "service", "track"]
+                ],
+                "layout": { "line-join": "round" },
+                "paint": {
+                  "line-color": "#fff",
+                  "line-width": { "base": 1.2, "stops": [[15.5, 0], [16, 2], [20, 7.5]] }
+                }
+              },
+              {
+                "id": "tunnel-minor",
+                "type": "line",
+                "metadata": { "mapbox:group": "1444849354174.1904" },
+                "source": "openmaptiles",
+                "source-layer": "transportation",
+                "filter": [
+                  "all",
+                  ["==", "brunnel", "tunnel"],
+                  ["==", "class", "minor_road"]
+                ],
+                "layout": { "line-join": "round" },
+                "paint": {
+                  "line-color": "#fff",
+                  "line-opacity": 1,
+                  "line-width": { "base": 1.2, "stops": [[13.5, 0], [14, 2.5], [20, 11.5]] }
+                }
+              },
+              {
+                "id": "tunnel-secondary-tertiary",
+                "type": "line",
+                "metadata": { "mapbox:group": "1444849354174.1904" },
+                "source": "openmaptiles",
+                "source-layer": "transportation",
+                "filter": [
+                  "all",
+                  ["==", "brunnel", "tunnel"],
+                  ["in", "class", "secondary", "tertiary"]
+                ],
+                "layout": { "line-join": "round" },
+                "paint": {
+                  "line-color": "#fff4c6",
+                  "line-width": { "base": 1.2, "stops": [[6.5, 0], [7, 0.5], [20, 10]] }
+                }
+              },
+              {
+                "id": "tunnel-trunk-primary",
+                "type": "line",
+                "metadata": { "mapbox:group": "1444849354174.1904" },
+                "source": "openmaptiles",
+                "source-layer": "transportation",
+                "filter": [
+                  "all",
+                  ["==", "brunnel", "tunnel"],
+                  ["in", "class", "primary", "trunk"]
+                ],
+                "layout": { "line-join": "round" },
+                "paint": {
+                  "line-color": "#fff4c6",
+                  "line-width": { "base": 1.2, "stops": [[6.5, 0], [7, 0.5], [20, 18]] },
+                  "line-opacity": 0.5
+                }
+              },
+              {
+                "id": "tunnel-motorway",
+                "type": "line",
+                "metadata": { "mapbox:group": "1444849354174.1904" },
+                "source": "openmaptiles",
+                "source-layer": "transportation",
+                "filter": [
+                  "all",
+                  ["==", "brunnel", "tunnel"],
+                  ["==", "class", "motorway"]
+                ],
+                "layout": { "line-join": "round", "visibility": "visible" },
+                "paint": {
+                  "line-color": "#ffdaa6",
+                  "line-width": { "base": 1.2, "stops": [[6.5, 0], [7, 0.5], [20, 18]] },
+                  "line-opacity": 0.5
+                }
+              },
+              {
+                "id": "tunnel-railway",
+                "type": "line",
+                "metadata": { "mapbox:group": "1444849354174.1904" },
+                "source": "openmaptiles",
+                "source-layer": "transportation",
+                "filter": ["all", ["==", "brunnel", "tunnel"], ["==", "class", "rail"]],
+                "paint": {
+                  "line-color": "#bbb",
+                  "line-width": { "base": 1.4, "stops": [[14, 0.4], [15, 0.75], [20, 2]] },
+                  "line-dasharray": [2, 2]
+                }
+              },
+              {
+                "id": "ferry",
+                "type": "line",
+                "source": "openmaptiles",
+                "source-layer": "transportation",
+                "filter": ["all", ["in", "class", "ferry"]],
+                "layout": { "line-join": "round", "visibility": "visible" },
+                "paint": {
+                  "line-color": "rgba(108, 159, 182, 1)",
+                  "line-width": 1.1,
+                  "line-dasharray": [2, 2]
+                }
+              },
+              {
+                "id": "aeroway-taxiway-casing",
+                "type": "line",
+                "metadata": { "mapbox:group": "1444849345966.4436" },
+                "source": "openmaptiles",
+                "source-layer": "aeroway",
+                "minzoom": 12,
+                "filter": ["all", ["in", "class", "taxiway"]],
+                "layout": {
+                  "line-cap": "round",
+                  "line-join": "round",
+                  "visibility": "visible"
+                },
+                "paint": {
+                  "line-color": "rgba(153, 153, 153, 1)",
+                  "line-width": { "base": 1.5, "stops": [[11, 2], [17, 12]] },
+                  "line-opacity": 1
+                }
+              },
+              {
+                "id": "aeroway-runway-casing",
+                "type": "line",
+                "metadata": { "mapbox:group": "1444849345966.4436" },
+                "source": "openmaptiles",
+                "source-layer": "aeroway",
+                "minzoom": 12,
+                "filter": ["all", ["in", "class", "runway"]],
+                "layout": {
+                  "line-cap": "round",
+                  "line-join": "round",
+                  "visibility": "visible"
+                },
+                "paint": {
+                  "line-color": "rgba(153, 153, 153, 1)",
+                  "line-width": { "base": 1.5, "stops": [[11, 5], [17, 55]] },
+                  "line-opacity": 1
+                }
+              },
+              {
+                "id": "aeroway-taxiway",
+                "type": "line",
+                "metadata": { "mapbox:group": "1444849345966.4436" },
+                "source": "openmaptiles",
+                "source-layer": "aeroway",
+                "minzoom": 4,
+                "filter": [
+                  "all",
+                  ["in", "class", "taxiway"],
+                  ["==", "$type", "LineString"]
+                ],
+                "layout": {
+                  "line-cap": "round",
+                  "line-join": "round",
+                  "visibility": "visible"
+                },
+                "paint": {
+                  "line-color": "rgba(255, 255, 255, 1)",
+                  "line-width": { "base": 1.5, "stops": [[11, 1], [17, 10]] },
+                  "line-opacity": { "base": 1, "stops": [[11, 0], [12, 1]] }
+                }
+              },
+              {
+                "id": "aeroway-runway",
+                "type": "line",
+                "metadata": { "mapbox:group": "1444849345966.4436" },
+                "source": "openmaptiles",
+                "source-layer": "aeroway",
+                "minzoom": 4,
+                "filter": [
+                  "all",
+                  ["in", "class", "runway"],
+                  ["==", "$type", "LineString"]
+                ],
+                "layout": {
+                  "line-cap": "round",
+                  "line-join": "round",
+                  "visibility": "visible"
+                },
+                "paint": {
+                  "line-color": "rgba(255, 255, 255, 1)",
+                  "line-width": { "base": 1.5, "stops": [[11, 4], [17, 50]] },
+                  "line-opacity": { "base": 1, "stops": [[11, 0], [12, 1]] }
+                }
+              },
+              {
+                "id": "highway-motorway-link-casing",
+                "type": "line",
+                "metadata": { "mapbox:group": "1444849345966.4436" },
+                "source": "openmaptiles",
+                "source-layer": "transportation",
+                "minzoom": 12,
+                "filter": [
+                  "all",
+                  ["!in", "brunnel", "bridge", "tunnel"],
+                  ["==", "class", "motorway_link"]
+                ],
+                "layout": { "line-cap": "round", "line-join": "round" },
+                "paint": {
+                  "line-color": "#e9ac77",
+                  "line-opacity": 1,
+                  "line-width": {
+                    "base": 1.2,
+                    "stops": [[12, 1], [13, 3], [14, 4], [20, 15]]
+                  }
+                }
+              },
+              {
+                "id": "highway-link-casing",
+                "type": "line",
+                "metadata": { "mapbox:group": "1444849345966.4436" },
+                "source": "openmaptiles",
+                "source-layer": "transportation",
+                "minzoom": 13,
+                "filter": [
+                  "all",
+                  ["!in", "brunnel", "bridge", "tunnel"],
+                  [
+                    "in",
+                    "class",
+                    "primary_link",
+                    "secondary_link",
+                    "tertiary_link",
+                    "trunk_link"
+                  ]
+                ],
+                "layout": {
+                  "line-cap": "round",
+                  "line-join": "round",
+                  "visibility": "visible"
+                },
+                "paint": {
+                  "line-color": "#e9ac77",
+                  "line-opacity": 1,
+                  "line-width": {
+                    "base": 1.2,
+                    "stops": [[12, 1], [13, 3], [14, 4], [20, 15]]
+                  }
+                }
+              },
+              {
+                "id": "highway-minor-casing",
+                "type": "line",
+                "metadata": { "mapbox:group": "1444849345966.4436" },
+                "source": "openmaptiles",
+                "source-layer": "transportation",
+                "filter": [
+                  "all",
+                  ["==", "$type", "LineString"],
+                  [
+                    "all",
+                    ["!=", "brunnel", "tunnel"],
+                    ["in", "class", "minor", "service", "track"]
+                  ]
+                ],
+                "layout": { "line-cap": "round", "line-join": "round" },
+                "paint": {
+                  "line-color": "#cfcdca",
+                  "line-opacity": { "stops": [[12, 0], [12.5, 0]] },
+                  "line-width": {
+                    "base": 1.2,
+                    "stops": [[12, 0.5], [13, 1], [14, 4], [20, 15]]
+                  }
+                }
+              },
+              {
+                "id": "highway-secondary-tertiary-casing",
+                "type": "line",
+                "metadata": { "mapbox:group": "1444849345966.4436" },
+                "source": "openmaptiles",
+                "source-layer": "transportation",
+                "filter": [
+                  "all",
+                  ["!in", "brunnel", "bridge", "tunnel"],
+                  ["in", "class", "secondary", "tertiary"]
+                ],
+                "layout": {
+                  "line-cap": "butt",
+                  "line-join": "round",
+                  "visibility": "visible"
+                },
+                "paint": {
+                  "line-color": "#e9ac77",
+                  "line-opacity": 0.5,
+                  "line-width": { "base": 1.2, "stops": [[8, 1.5], [20, 17]] }
+                }
+              },
+              {
+                "id": "highway-primary-casing",
+                "type": "line",
+                "metadata": { "mapbox:group": "1444849345966.4436" },
+                "source": "openmaptiles",
+                "source-layer": "transportation",
+                "minzoom": 5,
+                "filter": [
+                  "all",
+                  ["!in", "brunnel", "bridge", "tunnel"],
+                  ["in", "class", "primary"]
+                ],
+                "layout": {
+                  "line-cap": "butt",
+                  "line-join": "round",
+                  "visibility": "visible"
+                },
+                "paint": {
+                  "line-color": "#e9ac77",
+                  "line-opacity": { "stops": [[7, 0], [8, 0.6]] },
+                  "line-width": {
+                    "base": 1.2,
+                    "stops": [[7, 0], [8, 0.6], [9, 1.5], [20, 22]]
+                  }
+                }
+              },
+              {
+                "id": "highway-trunk-casing",
+                "type": "line",
+                "metadata": { "mapbox:group": "1444849345966.4436" },
+                "source": "openmaptiles",
+                "source-layer": "transportation",
+                "minzoom": 5,
+                "filter": [
+                  "all",
+                  ["!in", "brunnel", "bridge", "tunnel"],
+                  ["in", "class", "trunk"]
+                ],
+                "layout": {
+                  "line-cap": "butt",
+                  "line-join": "round",
+                  "visibility": "visible"
+                },
+                "paint": {
+                  "line-color": "#e9ac77",
+                  "line-opacity": { "stops": [[5, 0], [6, 0.5]] },
+                  "line-width": {
+                    "base": 1.2,
+                    "stops": [[5, 0], [6, 0.6], [7, 1.5], [20, 22]]
+                  }
+                }
+              },
+              {
+                "id": "highway-motorway-casing",
+                "type": "line",
+                "metadata": { "mapbox:group": "1444849345966.4436" },
+                "source": "openmaptiles",
+                "source-layer": "transportation",
+                "minzoom": 4,
+                "filter": [
+                  "all",
+                  ["!in", "brunnel", "bridge", "tunnel"],
+                  ["==", "class", "motorway"]
+                ],
+                "layout": {
+                  "line-cap": "butt",
+                  "line-join": "round",
+                  "visibility": "visible"
+                },
+                "paint": {
+                  "line-color": "#e9ac77",
+                  "line-width": {
+                    "base": 1.2,
+                    "stops": [[4, 0], [5, 0.4], [6, 0.6], [7, 1.5], [20, 22]]
+                  },
+                  "line-opacity": { "stops": [[4, 0], [5, 0.5]] }
+                }
+              },
+              {
+                "id": "highway-path",
+                "type": "line",
+                "metadata": { "mapbox:group": "1444849345966.4436" },
+                "source": "openmaptiles",
+                "source-layer": "transportation",
+                "filter": [
+                  "all",
+                  ["==", "$type", "LineString"],
+                  ["all", ["!in", "brunnel", "bridge", "tunnel"], ["==", "class", "path"]]
+                ],
+                "paint": {
+                  "line-color": "#cba",
+                  "line-dasharray": [1.5, 0.75],
+                  "line-width": { "base": 1.2, "stops": [[15, 1.2], [20, 4]] }
+                }
+              },
+              {
+                "id": "highway-motorway-link",
+                "type": "line",
+                "metadata": { "mapbox:group": "1444849345966.4436" },
+                "source": "openmaptiles",
+                "source-layer": "transportation",
+                "minzoom": 12,
+                "filter": [
+                  "all",
+                  ["!in", "brunnel", "bridge", "tunnel"],
+                  ["==", "class", "motorway_link"]
+                ],
+                "layout": { "line-cap": "round", "line-join": "round" },
+                "paint": {
+                  "line-color": "#fc8",
+                  "line-width": {
+                    "base": 1.2,
+                    "stops": [[12.5, 0], [13, 1.5], [14, 2.5], [20, 11.5]]
+                  }
+                }
+              },
+              {
+                "id": "highway-link",
+                "type": "line",
+                "metadata": { "mapbox:group": "1444849345966.4436" },
+                "source": "openmaptiles",
+                "source-layer": "transportation",
+                "minzoom": 13,
+                "filter": [
+                  "all",
+                  ["!in", "brunnel", "bridge", "tunnel"],
+                  [
+                    "in",
+                    "class",
+                    "primary_link",
+                    "secondary_link",
+                    "tertiary_link",
+                    "trunk_link"
+                  ]
+                ],
+                "layout": {
+                  "line-cap": "round",
+                  "line-join": "round",
+                  "visibility": "visible"
+                },
+                "paint": {
+                  "line-color": "#fea",
+                  "line-width": {
+                    "base": 1.2,
+                    "stops": [[12.5, 0], [13, 1.5], [14, 2.5], [20, 11.5]]
+                  }
+                }
+              },
+              {
+                "id": "highway-minor",
+                "type": "line",
+                "metadata": { "mapbox:group": "1444849345966.4436" },
+                "source": "openmaptiles",
+                "source-layer": "transportation",
+                "filter": [
+                  "all",
+                  ["==", "$type", "LineString"],
+                  [
+                    "all",
+                    ["!=", "brunnel", "tunnel"],
+                    ["in", "class", "minor", "service", "track"]
+                  ]
+                ],
+                "layout": { "line-cap": "round", "line-join": "round" },
+                "paint": {
+                  "line-color": "#fff",
+                  "line-opacity": 0.5,
+                  "line-width": { "base": 1.2, "stops": [[13.5, 0], [14, 2.5], [20, 11.5]] }
+                }
+              },
+              {
+                "id": "highway-secondary-tertiary",
+                "type": "line",
+                "metadata": { "mapbox:group": "1444849345966.4436" },
+                "source": "openmaptiles",
+                "source-layer": "transportation",
+                "filter": [
+                  "all",
+                  ["!in", "brunnel", "bridge", "tunnel"],
+                  ["in", "class", "secondary", "tertiary"]
+                ],
+                "layout": {
+                  "line-cap": "round",
+                  "line-join": "round",
+                  "visibility": "visible"
+                },
+                "paint": {
+                  "line-color": "#fea",
+                  "line-width": { "base": 1.2, "stops": [[6.5, 0], [8, 0.5], [20, 13]] },
+                  "line-opacity": 0.5
+                }
+              },
+              {
+                "id": "highway-primary",
+                "type": "line",
+                "metadata": { "mapbox:group": "1444849345966.4436" },
+                "source": "openmaptiles",
+                "source-layer": "transportation",
+                "filter": [
+                  "all",
+                  ["==", "$type", "LineString"],
+                  [
+                    "all",
+                    ["!in", "brunnel", "bridge", "tunnel"],
+                    ["in", "class", "primary"]
+                  ]
+                ],
+                "layout": {
+                  "line-cap": "round",
+                  "line-join": "round",
+                  "visibility": "visible"
+                },
+                "paint": {
+                  "line-color": "#fea",
+                  "line-width": { "base": 1.2, "stops": [[8.5, 0], [9, 0.5], [20, 18]] },
+                  "line-opacity": 0
+                }
+              },
+              {
+                "id": "highway-trunk",
+                "type": "line",
+                "metadata": { "mapbox:group": "1444849345966.4436" },
+                "source": "openmaptiles",
+                "source-layer": "transportation",
+                "filter": [
+                  "all",
+                  ["==", "$type", "LineString"],
+                  [
+                    "all",
+                    ["!in", "brunnel", "bridge", "tunnel"],
+                    ["in", "class", "trunk"]
+                  ]
+                ],
+                "layout": {
+                  "line-cap": "round",
+                  "line-join": "round",
+                  "visibility": "visible"
+                },
+                "paint": {
+                  "line-color": "#fea",
+                  "line-width": { "base": 1.2, "stops": [[6.5, 0], [7, 0.5], [20, 18]] },
+                  "line-opacity": 0.5
+                }
+              },
+              {
+                "id": "highway-motorway",
+                "type": "line",
+                "metadata": { "mapbox:group": "1444849345966.4436" },
+                "source": "openmaptiles",
+                "source-layer": "transportation",
+                "minzoom": 5,
+                "filter": [
+                  "all",
+                  ["==", "$type", "LineString"],
+                  [
+                    "all",
+                    ["!in", "brunnel", "bridge", "tunnel"],
+                    ["==", "class", "motorway"]
+                  ]
+                ],
+                "layout": {
+                  "line-cap": "round",
+                  "line-join": "round",
+                  "visibility": "visible"
+                },
+                "paint": {
+                  "line-color": "#fc8",
+                  "line-width": { "base": 1.2, "stops": [[6.5, 0], [7, 0.5], [20, 18]] },
+                  "line-opacity": 0.5
+                }
+              },
+              {
+                "id": "railway-transit",
+                "type": "line",
+                "metadata": { "mapbox:group": "1444849345966.4436" },
+                "source": "openmaptiles",
+                "source-layer": "transportation",
+                "filter": [
+                  "all",
+                  ["==", "$type", "LineString"],
+                  ["all", ["==", "class", "transit"], ["!in", "brunnel", "tunnel"]]
+                ],
+                "layout": { "visibility": "visible" },
+                "paint": {
+                  "line-color": "hsla(0, 0%, 73%, 0.77)",
+                  "line-width": { "base": 1.4, "stops": [[14, 0.4], [20, 1]] }
+                }
+              },
+              {
+                "id": "railway-transit-hatching",
+                "type": "line",
+                "metadata": { "mapbox:group": "1444849345966.4436" },
+                "source": "openmaptiles",
+                "source-layer": "transportation",
+                "filter": [
+                  "all",
+                  ["==", "$type", "LineString"],
+                  ["all", ["==", "class", "transit"], ["!in", "brunnel", "tunnel"]]
+                ],
+                "layout": { "visibility": "visible" },
+                "paint": {
+                  "line-color": "hsla(0, 0%, 73%, 0.68)",
+                  "line-dasharray": [0.2, 8],
+                  "line-width": { "base": 1.4, "stops": [[14.5, 0], [15, 2], [20, 6]] }
+                }
+              },
+              {
+                "id": "railway-service",
+                "type": "line",
+                "metadata": { "mapbox:group": "1444849345966.4436" },
+                "source": "openmaptiles",
+                "source-layer": "transportation",
+                "filter": [
+                  "all",
+                  ["==", "$type", "LineString"],
+                  ["all", ["==", "class", "rail"], ["has", "service"]]
+                ],
+                "paint": {
+                  "line-color": "hsla(0, 0%, 73%, 0.77)",
+                  "line-width": { "base": 1.4, "stops": [[14, 0.4], [20, 1]] }
+                }
+              },
+              {
+                "id": "railway-service-hatching",
+                "type": "line",
+                "metadata": { "mapbox:group": "1444849345966.4436" },
+                "source": "openmaptiles",
+                "source-layer": "transportation",
+                "filter": [
+                  "all",
+                  ["==", "$type", "LineString"],
+                  ["all", ["==", "class", "rail"], ["has", "service"]]
+                ],
+                "layout": { "visibility": "visible" },
+                "paint": {
+                  "line-color": "hsla(0, 0%, 73%, 0.68)",
+                  "line-dasharray": [0.2, 8],
+                  "line-width": { "base": 1.4, "stops": [[14.5, 0], [15, 2], [20, 6]] }
+                }
+              },
+              {
+                "id": "railway",
+                "type": "line",
+                "metadata": { "mapbox:group": "1444849345966.4436" },
+                "source": "openmaptiles",
+                "source-layer": "transportation",
+                "filter": [
+                  "all",
+                  ["==", "$type", "LineString"],
+                  [
+                    "all",
+                    ["!has", "service"],
+                    ["!in", "brunnel", "bridge", "tunnel"],
+                    ["==", "class", "rail"]
+                  ]
+                ],
+                "paint": {
+                  "line-color": "#bbb",
+                  "line-width": { "base": 1.4, "stops": [[14, 0.4], [15, 0.75], [20, 2]] }
+                }
+              },
+              {
+                "id": "railway-hatching",
+                "type": "line",
+                "metadata": { "mapbox:group": "1444849345966.4436" },
+                "source": "openmaptiles",
+                "source-layer": "transportation",
+                "filter": [
+                  "all",
+                  ["==", "$type", "LineString"],
+                  [
+                    "all",
+                    ["!has", "service"],
+                    ["!in", "brunnel", "bridge", "tunnel"],
+                    ["==", "class", "rail"]
+                  ]
+                ],
+                "paint": {
+                  "line-color": "#bbb",
+                  "line-dasharray": [0.2, 8],
+                  "line-width": { "base": 1.4, "stops": [[14.5, 0], [15, 3], [20, 8]] }
+                }
+              },
+              {
+                "id": "bridge-motorway-link-casing",
+                "type": "line",
+                "metadata": { "mapbox:group": "1444849334699.1902" },
+                "source": "openmaptiles",
+                "source-layer": "transportation",
+                "filter": [
+                  "all",
+                  ["==", "brunnel", "bridge"],
+                  ["==", "class", "motorway_link"]
+                ],
+                "layout": { "line-join": "round" },
+                "paint": {
+                  "line-color": "#e9ac77",
+                  "line-opacity": 1,
+                  "line-width": {
+                    "base": 1.2,
+                    "stops": [[12, 1], [13, 3], [14, 4], [20, 15]]
+                  }
+                }
+              },
+              {
+                "id": "bridge-link-casing",
+                "type": "line",
+                "metadata": { "mapbox:group": "1444849334699.1902" },
+                "source": "openmaptiles",
+                "source-layer": "transportation",
+                "filter": [
+                  "all",
+                  ["==", "brunnel", "bridge"],
+                  [
+                    "in",
+                    "class",
+                    "primary_link",
+                    "secondary_link",
+                    "tertiary_link",
+                    "trunk_link"
+                  ]
+                ],
+                "layout": { "line-join": "round" },
+                "paint": {
+                  "line-color": "#e9ac77",
+                  "line-opacity": 1,
+                  "line-width": {
+                    "base": 1.2,
+                    "stops": [[12, 1], [13, 3], [14, 4], [20, 15]]
+                  }
+                }
+              },
+              {
+                "id": "bridge-secondary-tertiary-casing",
+                "type": "line",
+                "metadata": { "mapbox:group": "1444849334699.1902" },
+                "source": "openmaptiles",
+                "source-layer": "transportation",
+                "filter": [
+                  "all",
+                  ["==", "brunnel", "bridge"],
+                  ["in", "class", "secondary", "tertiary"]
+                ],
+                "layout": { "line-join": "round" },
+                "paint": {
+                  "line-color": "#e9ac77",
+                  "line-opacity": 1,
+                  "line-width": { "base": 1.2, "stops": [[8, 1.5], [20, 28]] }
+                }
+              },
+              {
+                "id": "bridge-trunk-primary-casing",
+                "type": "line",
+                "metadata": { "mapbox:group": "1444849334699.1902" },
+                "source": "openmaptiles",
+                "source-layer": "transportation",
+                "filter": [
+                  "all",
+                  ["==", "brunnel", "bridge"],
+                  ["in", "class", "primary", "trunk"]
+                ],
+                "layout": { "line-join": "round" },
+                "paint": {
+                  "line-color": "hsl(28, 76%, 67%)",
+                  "line-width": {
+                    "base": 1.2,
+                    "stops": [[5, 0.4], [6, 0.6], [7, 1.5], [20, 26]]
+                  }
+                }
+              },
+              {
+                "id": "bridge-motorway-casing",
+                "type": "line",
+                "metadata": { "mapbox:group": "1444849334699.1902" },
+                "source": "openmaptiles",
+                "source-layer": "transportation",
+                "filter": [
+                  "all",
+                  ["==", "brunnel", "bridge"],
+                  ["==", "class", "motorway"]
+                ],
+                "layout": { "line-join": "round" },
+                "paint": {
+                  "line-color": "#e9ac77",
+                  "line-width": {
+                    "base": 1.2,
+                    "stops": [[5, 0.4], [6, 0.6], [7, 1.5], [20, 22]]
+                  },
+                  "line-opacity": 0.5
+                }
+              },
+              {
+                "id": "bridge-path-casing",
+                "type": "line",
+                "metadata": { "mapbox:group": "1444849334699.1902" },
+                "source": "openmaptiles",
+                "source-layer": "transportation",
+                "filter": [
+                  "all",
+                  ["==", "$type", "LineString"],
+                  ["all", ["==", "brunnel", "bridge"], ["==", "class", "path"]]
+                ],
+                "paint": {
+                  "line-color": "#f8f4f0",
+                  "line-width": { "base": 1.2, "stops": [[15, 1.2], [20, 18]] }
+                }
+              },
+              {
+                "id": "bridge-path",
+                "type": "line",
+                "metadata": { "mapbox:group": "1444849334699.1902" },
+                "source": "openmaptiles",
+                "source-layer": "transportation",
+                "filter": [
+                  "all",
+                  ["==", "$type", "LineString"],
+                  ["all", ["==", "brunnel", "bridge"], ["==", "class", "path"]]
+                ],
+                "paint": {
+                  "line-color": "#cba",
+                  "line-width": { "base": 1.2, "stops": [[15, 1.2], [20, 4]] },
+                  "line-dasharray": [1.5, 0.75]
+                }
+              },
+              {
+                "id": "bridge-motorway-link",
+                "type": "line",
+                "metadata": { "mapbox:group": "1444849334699.1902" },
+                "source": "openmaptiles",
+                "source-layer": "transportation",
+                "filter": [
+                  "all",
+                  ["==", "brunnel", "bridge"],
+                  ["==", "class", "motorway_link"]
+                ],
+                "layout": { "line-join": "round" },
+                "paint": {
+                  "line-color": "#fc8",
+                  "line-width": {
+                    "base": 1.2,
+                    "stops": [[12.5, 0], [13, 1.5], [14, 2.5], [20, 11.5]]
+                  }
+                }
+              },
+              {
+                "id": "bridge-link",
+                "type": "line",
+                "metadata": { "mapbox:group": "1444849334699.1902" },
+                "source": "openmaptiles",
+                "source-layer": "transportation",
+                "filter": [
+                  "all",
+                  ["==", "brunnel", "bridge"],
+                  [
+                    "in",
+                    "class",
+                    "primary_link",
+                    "secondary_link",
+                    "tertiary_link",
+                    "trunk_link"
+                  ]
+                ],
+                "layout": { "line-join": "round" },
+                "paint": {
+                  "line-color": "#fea",
+                  "line-width": {
+                    "base": 1.2,
+                    "stops": [[12.5, 0], [13, 1.5], [14, 2.5], [20, 11.5]]
+                  }
+                }
+              },
+              {
+                "id": "bridge-secondary-tertiary",
+                "type": "line",
+                "metadata": { "mapbox:group": "1444849334699.1902" },
+                "source": "openmaptiles",
+                "source-layer": "transportation",
+                "filter": [
+                  "all",
+                  ["==", "brunnel", "bridge"],
+                  ["in", "class", "secondary", "tertiary"]
+                ],
+                "layout": { "line-join": "round" },
+                "paint": {
+                  "line-color": "#fea",
+                  "line-width": { "base": 1.2, "stops": [[6.5, 0], [7, 0.5], [20, 20]] }
+                }
+              },
+              {
+                "id": "bridge-trunk-primary",
+                "type": "line",
+                "metadata": { "mapbox:group": "1444849334699.1902" },
+                "source": "openmaptiles",
+                "source-layer": "transportation",
+                "filter": [
+                  "all",
+                  ["==", "brunnel", "bridge"],
+                  ["in", "class", "primary", "trunk"]
+                ],
+                "layout": { "line-join": "round" },
+                "paint": {
+                  "line-color": "#fea",
+                  "line-width": { "base": 1.2, "stops": [[6.5, 0], [7, 0.5], [20, 18]] }
+                }
+              },
+              {
+                "id": "bridge-motorway",
+                "type": "line",
+                "metadata": { "mapbox:group": "1444849334699.1902" },
+                "source": "openmaptiles",
+                "source-layer": "transportation",
+                "filter": [
+                  "all",
+                  ["==", "brunnel", "bridge"],
+                  ["==", "class", "motorway"]
+                ],
+                "layout": { "line-join": "round" },
+                "paint": {
+                  "line-color": "#fc8",
+                  "line-width": { "base": 1.2, "stops": [[6.5, 0], [7, 0.5], [20, 18]] },
+                  "line-opacity": 0.5
+                }
+              },
+              {
+                "id": "bridge-railway",
+                "type": "line",
+                "metadata": { "mapbox:group": "1444849334699.1902" },
+                "source": "openmaptiles",
+                "source-layer": "transportation",
+                "filter": ["all", ["==", "brunnel", "bridge"], ["==", "class", "rail"]],
+                "paint": {
+                  "line-color": "#bbb",
+                  "line-width": { "base": 1.4, "stops": [[14, 0.4], [15, 0.75], [20, 2]] }
+                }
+              },
+              {
+                "id": "bridge-railway-hatching",
+                "type": "line",
+                "metadata": { "mapbox:group": "1444849334699.1902" },
+                "source": "openmaptiles",
+                "source-layer": "transportation",
+                "filter": ["all", ["==", "brunnel", "bridge"], ["==", "class", "rail"]],
+                "paint": {
+                  "line-color": "#bbb",
+                  "line-dasharray": [0.2, 8],
+                  "line-width": { "base": 1.4, "stops": [[14.5, 0], [15, 3], [20, 8]] }
+                }
+              },
+              {
+                "id": "cablecar",
+                "type": "line",
+                "source": "openmaptiles",
+                "source-layer": "transportation",
+                "minzoom": 13,
+                "filter": ["==", "class", "cable_car"],
+                "layout": { "visibility": "visible", "line-cap": "round" },
+                "paint": {
+                  "line-color": "hsl(0, 0%, 70%)",
+                  "line-width": { "base": 1, "stops": [[11, 1], [19, 2.5]] }
+                }
+              },
+              {
+                "id": "cablecar-dash",
+                "type": "line",
+                "source": "openmaptiles",
+                "source-layer": "transportation",
+                "minzoom": 13,
+                "filter": ["==", "class", "cable_car"],
+                "layout": { "visibility": "visible", "line-cap": "round" },
+                "paint": {
+                  "line-color": "hsl(0, 0%, 70%)",
+                  "line-width": { "base": 1, "stops": [[11, 3], [19, 5.5]] },
+                  "line-dasharray": [2, 3]
+                }
+              },
+              {
+                "id": "boundary-land-level-4",
+                "type": "line",
+                "source": "openmaptiles",
+                "source-layer": "boundary",
+                "filter": [
+                  "all",
+                  [">=", "admin_level", 4],
+                  ["<=", "admin_level", 8],
+                  ["!=", "maritime", 1]
+                ],
+                "layout": { "line-join": "round" },
+                "paint": {
+                  "line-color": "#9e9cab",
+                  "line-dasharray": [3, 1, 1, 1],
+                  "line-width": { "base": 1.4, "stops": [[4, 0.4], [5, 1], [12, 3]] },
+                  "line-opacity": 0.6
+                }
+              },
+              {
+                "id": "boundary-land-level-2",
+                "type": "line",
+                "source": "openmaptiles",
+                "source-layer": "boundary",
+                "filter": [
+                  "all",
+                  ["==", "admin_level", 2],
+                  ["!=", "maritime", 1],
+                  ["!=", "disputed", 1]
+                ],
+                "layout": { "line-cap": "round", "line-join": "round" },
+                "paint": {
+                  "line-color": "hsl(248, 7%, 66%)",
+                  "line-width": {
+                    "base": 1,
+                    "stops": [[0, 0.6], [4, 1.4], [5, 2], [12, 2]]
+                  }
+                }
+              },
+              {
+                "id": "boundary-land-disputed",
+                "type": "line",
+                "source": "openmaptiles",
+                "source-layer": "boundary",
+                "filter": ["all", ["!=", "maritime", 1], ["==", "disputed", 1]],
+                "layout": { "line-cap": "round", "line-join": "round" },
+                "paint": {
+                  "line-color": "hsl(248, 7%, 70%)",
+                  "line-dasharray": [1, 3],
+                  "line-width": {
+                    "base": 1,
+                    "stops": [[0, 0.6], [4, 1.4], [5, 2], [12, 8]]
+                  }
+                }
+              },
+              {
+                "id": "boundary-water",
+                "type": "line",
+                "source": "openmaptiles",
+                "source-layer": "boundary",
+                "filter": ["all", ["in", "admin_level", 2, 4], ["==", "maritime", 1]],
+                "layout": { "line-cap": "round", "line-join": "round" },
+                "paint": {
+                  "line-color": "rgba(154, 189, 214, 1)",
+                  "line-width": { "base": 1, "stops": [[0, 0.6], [4, 1], [5, 1], [12, 1]] },
+                  "line-opacity": { "stops": [[6, 0], [10, 0]] }
+                }
+              },
+              {
+                "id": "waterway-name",
+                "type": "symbol",
+                "source": "openmaptiles",
+                "source-layer": "waterway",
+                "minzoom": 13,
+                "filter": ["all", ["==", "$type", "LineString"], ["has", "name"]],
+                "layout": {
+                  "text-font": ["Noto Sans Italic"],
+                  "text-size": 14,
+                  "text-field": "{name:latin} {name:nonlatin}",
+                  "text-max-width": 5,
+                  "text-rotation-alignment": "map",
+                  "symbol-placement": "line",
+                  "text-letter-spacing": 0.2,
+                  "symbol-spacing": 350
+                },
+                "paint": {
+                  "text-color": "#74aee9",
+                  "text-halo-width": 1.5,
+                  "text-halo-color": "rgba(255,255,255,0.7)"
+                }
+              },
+              {
+                "id": "water-name-lakeline",
+                "type": "symbol",
+                "source": "openmaptiles",
+                "source-layer": "water_name",
+                "filter": ["==", "$type", "LineString"],
+                "layout": {
+                  "text-font": ["Noto Sans Italic"],
+                  "text-size": 14,
+                  "text-field": "{name:latin}\n{name:nonlatin}",
+                  "text-max-width": 5,
+                  "text-rotation-alignment": "map",
+                  "symbol-placement": "line",
+                  "symbol-spacing": 350,
+                  "text-letter-spacing": 0.2
+                },
+                "paint": {
+                  "text-color": "#74aee9",
+                  "text-halo-width": 1.5,
+                  "text-halo-color": "rgba(255,255,255,0.7)"
+                }
+              },
+              {
+                "id": "water-name-ocean",
+                "type": "symbol",
+                "source": "openmaptiles",
+                "source-layer": "water_name",
+                "filter": ["all", ["==", "$type", "Point"], ["==", "class", "ocean"]],
+                "layout": {
+                  "text-font": ["Noto Sans Italic"],
+                  "text-size": 14,
+                  "text-field": "{name:latin}",
+                  "text-max-width": 5,
+                  "text-rotation-alignment": "map",
+                  "symbol-placement": "point",
+                  "symbol-spacing": 350,
+                  "text-letter-spacing": 0.2
+                },
+                "paint": {
+                  "text-color": "#74aee9",
+                  "text-halo-width": 1.5,
+                  "text-halo-color": "rgba(255,255,255,0.7)"
+                }
+              },
+              {
+                "id": "water-name-other",
+                "type": "symbol",
+                "source": "openmaptiles",
+                "source-layer": "water_name",
+                "filter": ["all", ["==", "$type", "Point"], ["!in", "class", "ocean"]],
+                "layout": {
+                  "text-font": ["Noto Sans Italic"],
+                  "text-size": { "stops": [[0, 10], [6, 14]] },
+                  "text-field": "{name:latin}\n{name:nonlatin}",
+                  "text-max-width": 5,
+                  "text-rotation-alignment": "map",
+                  "symbol-placement": "point",
+                  "symbol-spacing": 350,
+                  "text-letter-spacing": 0.2,
+                  "visibility": "visible"
+                },
+                "paint": {
+                  "text-color": "#74aee9",
+                  "text-halo-width": 1.5,
+                  "text-halo-color": "rgba(255,255,255,0.7)"
+                }
+              },
+              {
+                "id": "poi-level-3",
+                "type": "symbol",
+                "source": "openmaptiles",
+                "source-layer": "poi",
+                "minzoom": 16,
+                "filter": ["all", ["==", "$type", "Point"], [">=", "rank", 25]],
+                "layout": {
+                  "text-padding": 2,
+                  "text-font": ["Noto Sans Regular"],
+                  "text-anchor": "top",
+                  "icon-image": "{class}_11",
+                  "text-field": "{name:latin}\n{name:nonlatin}",
+                  "text-offset": [0, 0.6],
+                  "text-size": 12,
+                  "text-max-width": 9
+                },
+                "paint": {
+                  "text-halo-blur": 0.5,
+                  "text-color": "#666",
+                  "text-halo-width": 1,
+                  "text-halo-color": "#ffffff"
+                }
+              },
+              {
+                "id": "poi-level-2",
+                "type": "symbol",
+                "source": "openmaptiles",
+                "source-layer": "poi",
+                "minzoom": 15,
+                "filter": [
+                  "all",
+                  ["==", "$type", "Point"],
+                  ["<=", "rank", 24],
+                  [">=", "rank", 15]
+                ],
+                "layout": {
+                  "text-padding": 2,
+                  "text-font": ["Noto Sans Regular"],
+                  "text-anchor": "top",
+                  "icon-image": "{class}_11",
+                  "text-field": "{name:latin}\n{name:nonlatin}",
+                  "text-offset": [0, 0.6],
+                  "text-size": 12,
+                  "text-max-width": 9
+                },
+                "paint": {
+                  "text-halo-blur": 0.5,
+                  "text-color": "#666",
+                  "text-halo-width": 1,
+                  "text-halo-color": "#ffffff"
+                }
+              },
+              {
+                "id": "poi-level-1",
+                "type": "symbol",
+                "source": "openmaptiles",
+                "source-layer": "poi",
+                "minzoom": 14,
+                "filter": [
+                  "all",
+                  ["==", "$type", "Point"],
+                  ["<=", "rank", 14],
+                  ["has", "name"]
+                ],
+                "layout": {
+                  "text-padding": 2,
+                  "text-font": ["Noto Sans Regular"],
+                  "text-anchor": "top",
+                  "icon-image": "{class}_11",
+                  "text-field": "{name:latin}\n{name:nonlatin}",
+                  "text-offset": [0, 0.6],
+                  "text-size": 11,
+                  "text-max-width": 9
+                },
+                "paint": {
+                  "text-halo-blur": 0.5,
+                  "text-color": "rgba(191, 228, 172, 1)",
+                  "text-halo-width": 1,
+                  "text-halo-color": "rgba(30, 29, 29, 1)"
+                }
+              },
+              {
+                "id": "poi-railway",
+                "type": "symbol",
+                "source": "openmaptiles",
+                "source-layer": "poi",
+                "minzoom": 13,
+                "filter": [
+                  "all",
+                  ["==", "$type", "Point"],
+                  ["has", "name"],
+                  ["==", "class", "railway"],
+                  ["==", "subclass", "station"]
+                ],
+                "layout": {
+                  "text-padding": 2,
+                  "text-font": ["Noto Sans Regular"],
+                  "text-anchor": "top",
+                  "icon-image": "{class}_11",
+                  "text-field": "{name:latin}\n{name:nonlatin}",
+                  "text-offset": [0, 0.6],
+                  "text-size": 12,
+                  "text-max-width": 9,
+                  "icon-optional": false,
+                  "icon-ignore-placement": false,
+                  "icon-allow-overlap": false,
+                  "text-ignore-placement": false,
+                  "text-allow-overlap": false,
+                  "text-optional": true
+                },
+                "paint": {
+                  "text-halo-blur": 0.5,
+                  "text-color": "#666",
+                  "text-halo-width": 1,
+                  "text-halo-color": "#ffffff"
+                }
+              },
+              {
+                "id": "road_oneway",
+                "type": "symbol",
+                "source": "openmaptiles",
+                "source-layer": "transportation",
+                "minzoom": 15,
+                "filter": [
+                  "all",
+                  ["==", "oneway", 1],
+                  [
+                    "in",
+                    "class",
+                    "motorway",
+                    "trunk",
+                    "primary",
+                    "secondary",
+                    "tertiary",
+                    "minor",
+                    "service"
+                  ]
+                ],
+                "layout": {
+                  "symbol-placement": "line",
+                  "icon-image": "oneway",
+                  "symbol-spacing": 75,
+                  "icon-padding": 2,
+                  "icon-rotation-alignment": "map",
+                  "icon-rotate": 90,
+                  "icon-size": { "stops": [[15, 0.5], [19, 1]] }
+                },
+                "paint": { "icon-opacity": 0.5 }
+              },
+              {
+                "id": "road_oneway_opposite",
+                "type": "symbol",
+                "source": "openmaptiles",
+                "source-layer": "transportation",
+                "minzoom": 15,
+                "filter": [
+                  "all",
+                  ["==", "oneway", -1],
+                  [
+                    "in",
+                    "class",
+                    "motorway",
+                    "trunk",
+                    "primary",
+                    "secondary",
+                    "tertiary",
+                    "minor",
+                    "service"
+                  ]
+                ],
+                "layout": {
+                  "symbol-placement": "line",
+                  "icon-image": "oneway",
+                  "symbol-spacing": 75,
+                  "icon-padding": 2,
+                  "icon-rotation-alignment": "map",
+                  "icon-rotate": -90,
+                  "icon-size": { "stops": [[15, 0.5], [19, 1]] }
+                },
+                "paint": { "icon-opacity": 0.5 }
+              },
+              {
+                "id": "highway-name-path",
+                "type": "symbol",
+                "source": "openmaptiles",
+                "source-layer": "transportation_name",
+                "minzoom": 15.5,
+                "filter": ["==", "class", "path"],
+                "layout": {
+                  "text-size": { "base": 1, "stops": [[13, 12], [14, 13]] },
+                  "text-font": ["Noto Sans Regular"],
+                  "text-field": "{name:latin} {name:nonlatin}",
+                  "symbol-placement": "line",
+                  "text-rotation-alignment": "map"
+                },
+                "paint": {
+                  "text-halo-color": "#f8f4f0",
+                  "text-color": "hsl(30, 23%, 62%)",
+                  "text-halo-width": 0.5
+                }
+              },
+              {
+                "id": "highway-name-minor",
+                "type": "symbol",
+                "source": "openmaptiles",
+                "source-layer": "transportation_name",
+                "minzoom": 15,
+                "filter": [
+                  "all",
+                  ["==", "$type", "LineString"],
+                  ["in", "class", "minor", "service", "track"]
+                ],
+                "layout": {
+                  "text-size": { "base": 1, "stops": [[13, 12], [14, 13]] },
+                  "text-font": ["Noto Sans Regular"],
+                  "text-field": "{name:latin} {name:nonlatin}",
+                  "symbol-placement": "line",
+                  "text-rotation-alignment": "map"
+                },
+                "paint": {
+                  "text-halo-blur": 0.5,
+                  "text-color": "#765",
+                  "text-halo-width": 1
+                }
+              },
+              {
+                "id": "highway-name-major",
+                "type": "symbol",
+                "source": "openmaptiles",
+                "source-layer": "transportation_name",
+                "minzoom": 12.2,
+                "filter": ["in", "class", "primary", "secondary", "tertiary", "trunk"],
+                "layout": {
+                  "text-size": { "base": 1, "stops": [[13, 12], [14, 13]] },
+                  "text-font": ["Noto Sans Regular"],
+                  "text-field": "{name:latin} {name:nonlatin}",
+                  "symbol-placement": "line",
+                  "text-rotation-alignment": "map"
+                },
+                "paint": {
+                  "text-halo-blur": 0.5,
+                  "text-color": "#765",
+                  "text-halo-width": 1
+                }
+              },
+              {
+                "id": "highway-shield",
+                "type": "symbol",
+                "source": "openmaptiles",
+                "source-layer": "transportation_name",
+                "minzoom": 8,
+                "filter": [
+                  "all",
+                  ["<=", "ref_length", 6],
+                  ["==", "$type", "LineString"],
+                  ["!in", "network", "us-interstate", "us-highway", "us-state"]
+                ],
+                "layout": {
+                  "text-size": 10,
+                  "icon-image": "road_{ref_length}",
+                  "icon-rotation-alignment": "viewport",
+                  "symbol-spacing": 200,
+                  "text-font": ["Noto Sans Regular"],
+                  "symbol-placement": { "base": 1, "stops": [[10, "point"], [11, "line"]] },
+                  "text-rotation-alignment": "viewport",
+                  "icon-size": 1,
+                  "text-field": "{ref}"
+                },
+                "paint": {
+                  "text-opacity": 1,
+                  "text-color": "rgba(20, 19, 19, 1)",
+                  "text-halo-color": "rgba(230, 221, 221, 0)",
+                  "text-halo-width": 2,
+                  "icon-color": "rgba(183, 18, 18, 1)",
+                  "icon-opacity": 0.3,
+                  "icon-halo-color": "rgba(183, 55, 55, 0)"
+                }
+              },
+              {
+                "id": "highway-shield-us-interstate",
+                "type": "symbol",
+                "source": "openmaptiles",
+                "source-layer": "transportation_name",
+                "minzoom": 7,
+                "filter": [
+                  "all",
+                  ["<=", "ref_length", 6],
+                  ["==", "$type", "LineString"],
+                  ["in", "network", "us-interstate"]
+                ],
+                "layout": {
+                  "text-size": 10,
+                  "icon-image": "{network}_{ref_length}",
+                  "icon-rotation-alignment": "viewport",
+                  "symbol-spacing": 200,
+                  "text-font": ["Noto Sans Regular"],
+                  "symbol-placement": {
+                    "base": 1,
+                    "stops": [[7, "point"], [7, "line"], [8, "line"]]
+                  },
+                  "text-rotation-alignment": "viewport",
+                  "icon-size": 1,
+                  "text-field": "{ref}"
+                },
+                "paint": { "text-color": "rgba(0, 0, 0, 1)" }
+              },
+              {
+                "id": "highway-shield-us-other",
+                "type": "symbol",
+                "source": "openmaptiles",
+                "source-layer": "transportation_name",
+                "minzoom": 9,
+                "filter": [
+                  "all",
+                  ["<=", "ref_length", 6],
+                  ["==", "$type", "LineString"],
+                  ["in", "network", "us-highway", "us-state"]
+                ],
+                "layout": {
+                  "text-size": 10,
+                  "icon-image": "{network}_{ref_length}",
+                  "icon-rotation-alignment": "viewport",
+                  "symbol-spacing": 200,
+                  "text-font": ["Noto Sans Regular"],
+                  "symbol-placement": { "base": 1, "stops": [[10, "point"], [11, "line"]] },
+                  "text-rotation-alignment": "viewport",
+                  "icon-size": 1,
+                  "text-field": "{ref}"
+                },
+                "paint": { "text-color": "rgba(0, 0, 0, 1)" }
+              },
+              {
+                "id": "place-other",
+                "type": "symbol",
+                "metadata": { "mapbox:group": "1444849242106.713" },
+                "source": "openmaptiles",
+                "source-layer": "place",
+                "minzoom": 12,
+                "filter": [
+                  "!in",
+                  "class",
+                  "city",
+                  "town",
+                  "village",
+                  "country",
+                  "continent"
+                ],
+                "layout": {
+                  "text-letter-spacing": 0.1,
+                  "text-size": { "base": 1.2, "stops": [[12, 10], [15, 14]] },
+                  "text-font": ["Noto Sans Bold"],
+                  "text-field": "{name:latin}\n{name:nonlatin}",
+                  "text-transform": "uppercase",
+                  "text-max-width": 9,
+                  "visibility": "visible"
+                },
+                "paint": {
+                  "text-color": "rgba(255,255,255,1)",
+                  "text-halo-width": 1.2,
+                  "text-halo-color": "rgba(57, 28, 28, 1)"
+                }
+              },
+              {
+                "id": "place-village",
+                "type": "symbol",
+                "metadata": { "mapbox:group": "1444849242106.713" },
+                "source": "openmaptiles",
+                "source-layer": "place",
+                "minzoom": 10,
+                "filter": ["==", "class", "village"],
+                "layout": {
+                  "text-font": ["Noto Sans Regular"],
+                  "text-size": { "base": 1.2, "stops": [[10, 12], [15, 16]] },
+                  "text-field": "{name:latin}\n{name:nonlatin}",
+                  "text-max-width": 8,
+                  "visibility": "visible"
+                },
+                "paint": {
+                  "text-color": "rgba(255, 255, 255, 1)",
+                  "text-halo-width": 1.2,
+                  "text-halo-color": "rgba(10, 9, 9, 0.8)"
+                }
+              },
+              {
+                "id": "place-town",
+                "type": "symbol",
+                "metadata": { "mapbox:group": "1444849242106.713" },
+                "source": "openmaptiles",
+                "source-layer": "place",
+                "filter": ["==", "class", "town"],
+                "layout": {
+                  "text-font": ["Noto Sans Regular"],
+                  "text-size": { "base": 1.2, "stops": [[10, 14], [15, 24]] },
+                  "text-field": "{name:latin}\n{name:nonlatin}",
+                  "text-max-width": 8,
+                  "visibility": "visible"
+                },
+                "paint": {
+                  "text-color": "rgba(255, 255, 255, 1)",
+                  "text-halo-width": 1.2,
+                  "text-halo-color": "rgba(22, 22, 22, 0.8)"
+                }
+              },
+              {
+                "id": "place-city",
+                "type": "symbol",
+                "metadata": { "mapbox:group": "1444849242106.713" },
+                "source": "openmaptiles",
+                "source-layer": "place",
+                "filter": ["all", ["!=", "capital", 2], ["==", "class", "city"]],
+                "layout": {
+                  "text-font": ["Noto Sans Regular"],
+                  "text-size": { "base": 1.2, "stops": [[7, 14], [11, 24]] },
+                  "text-field": "{name:latin}\n{name:nonlatin}",
+                  "text-max-width": 8,
+                  "visibility": "visible"
+                },
+                "paint": {
+                  "text-color": "rgba(0, 0, 0, 1)",
+                  "text-halo-width": 1.2,
+                  "text-halo-color": "rgba(255,255,255,0.8)"
+                }
+              },
+              {
+                "id": "place-city-capital",
+                "type": "symbol",
+                "metadata": { "mapbox:group": "1444849242106.713" },
+                "source": "openmaptiles",
+                "source-layer": "place",
+                "filter": ["all", ["==", "capital", 2], ["==", "class", "city"]],
+                "layout": {
+                  "text-font": ["Noto Sans Regular"],
+                  "text-size": { "base": 1.2, "stops": [[7, 14], [11, 24]] },
+                  "text-field": "{name:latin}\n{name:nonlatin}",
+                  "text-max-width": 8,
+                  "icon-image": "star_11",
+                  "text-offset": [0.4, 0],
+                  "icon-size": 0.8,
+                  "text-anchor": "left",
+                  "visibility": "visible"
+                },
+                "paint": {
+                  "text-color": "#333",
+                  "text-halo-width": 1.2,
+                  "text-halo-color": "rgba(255,255,255,0.8)"
+                }
+              },
+              {
+                "id": "place-country-other",
+                "type": "symbol",
+                "metadata": { "mapbox:group": "1444849242106.713" },
+                "source": "openmaptiles",
+                "source-layer": "place",
+                "filter": [
+                  "all",
+                  ["==", "class", "country"],
+                  [">=", "rank", 3],
+                  ["!has", "iso_a2"]
+                ],
+                "layout": {
+                  "text-font": ["Noto Sans Italic"],
+                  "text-field": "{name:latin}",
+                  "text-size": { "stops": [[3, 11], [7, 17]] },
+                  "text-transform": "uppercase",
+                  "text-max-width": 6.25,
+                  "visibility": "visible"
+                },
+                "paint": {
+                  "text-halo-blur": 1,
+                  "text-color": "#334",
+                  "text-halo-width": 2,
+                  "text-halo-color": "rgba(255,255,255,0.8)"
+                }
+              },
+              {
+                "id": "place-country-3",
+                "type": "symbol",
+                "metadata": { "mapbox:group": "1444849242106.713" },
+                "source": "openmaptiles",
+                "source-layer": "place",
+                "filter": [
+                  "all",
+                  ["==", "class", "country"],
+                  [">=", "rank", 3],
+                  ["has", "iso_a2"]
+                ],
+                "layout": {
+                  "text-font": ["Noto Sans Bold"],
+                  "text-field": "{name:latin}",
+                  "text-size": { "stops": [[3, 11], [7, 17]] },
+                  "text-transform": "uppercase",
+                  "text-max-width": 6.25,
+                  "visibility": "visible"
+                },
+                "paint": {
+                  "text-halo-blur": 1,
+                  "text-color": "#334",
+                  "text-halo-width": 2,
+                  "text-halo-color": "rgba(255,255,255,0.8)"
+                }
+              },
+              {
+                "id": "place-country-2",
+                "type": "symbol",
+                "metadata": { "mapbox:group": "1444849242106.713" },
+                "source": "openmaptiles",
+                "source-layer": "place",
+                "filter": [
+                  "all",
+                  ["==", "class", "country"],
+                  ["==", "rank", 2],
+                  ["has", "iso_a2"]
+                ],
+                "layout": {
+                  "text-font": ["Noto Sans Bold"],
+                  "text-field": "{name:latin}",
+                  "text-size": { "stops": [[2, 11], [5, 17]] },
+                  "text-transform": "uppercase",
+                  "text-max-width": 6.25,
+                  "visibility": "visible"
+                },
+                "paint": {
+                  "text-halo-blur": 1,
+                  "text-color": "#334",
+                  "text-halo-width": 2,
+                  "text-halo-color": "rgba(255,255,255,0.8)"
+                }
+              },
+              {
+                "id": "place-country-1",
+                "type": "symbol",
+                "metadata": { "mapbox:group": "1444849242106.713" },
+                "source": "openmaptiles",
+                "source-layer": "place",
+                "filter": [
+                  "all",
+                  ["==", "class", "country"],
+                  ["==", "rank", 1],
+                  ["has", "iso_a2"]
+                ],
+                "layout": {
+                  "text-font": ["Noto Sans Bold"],
+                  "text-field": "{name:latin}",
+                  "text-size": { "stops": [[1, 11], [4, 17]] },
+                  "text-transform": "uppercase",
+                  "text-max-width": 6.25,
+                  "visibility": "visible"
+                },
+                "paint": {
+                  "text-halo-blur": 1,
+                  "text-color": "#334",
+                  "text-halo-width": 2,
+                  "text-halo-color": "rgba(255,255,255,0.8)"
+                }
+              },
+              {
+                "id": "place-continent",
+                "type": "symbol",
+                "metadata": { "mapbox:group": "1444849242106.713" },
+                "source": "openmaptiles",
+                "source-layer": "place",
+                "maxzoom": 1,
+                "filter": ["==", "class", "continent"],
+                "layout": {
+                  "text-font": ["Noto Sans Bold"],
+                  "text-field": "{name:latin}",
+                  "text-size": 14,
+                  "text-max-width": 6.25,
+                  "text-transform": "uppercase",
+                  "visibility": "visible"
+                },
+                "paint": {
+                  "text-halo-blur": 1,
+                  "text-color": "#334",
+                  "text-halo-width": 2,
+                  "text-halo-color": "rgba(255,255,255,0.8)"
+                }
+              }
+            ],
+            "id": "qebnlkra6"
+          };
+        }
+      });
+      var require_arcgis_sat = __commonJS({
+        "src/plots/map/styles/arcgis-sat.js"(exports, module2) {
+          module2.exports = {
+            "version": 8,
+            "name": "orto",
+            "metadata": {},
+            "center": [
+              1.537786,
+              41.837539
+            ],
+            "zoom": 12,
+            "bearing": 0,
+            "pitch": 0,
+            "light": {
+              "anchor": "viewport",
+              "color": "white",
+              "intensity": 0.4,
+              "position": [
+                1.15,
+                45,
+                30
+              ]
+            },
+            "sources": {
+              "ortoEsri": {
+                "type": "raster",
+                "tiles": [
+                  "https://server.arcgisonline.com/ArcGIS/rest/services/World_Imagery/MapServer/tile/{z}/{y}/{x}"
+                ],
+                "tileSize": 256,
+                "maxzoom": 18,
+                "attribution": "ESRI &copy; <a href='http://www.esri.com'>ESRI</a>"
+              },
+              "ortoInstaMaps": {
+                "type": "raster",
+                "tiles": [
+                  "https://tilemaps.icgc.cat/mapfactory/wmts/orto_8_12/CAT3857/{z}/{x}/{y}.png"
+                ],
+                "tileSize": 256,
+                "maxzoom": 13
+              },
+              "ortoICGC": {
+                "type": "raster",
+                "tiles": [
+                  "https://geoserveis.icgc.cat/icc_mapesmultibase/noutm/wmts/orto/GRID3857/{z}/{x}/{y}.jpeg"
+                ],
+                "tileSize": 256,
+                "minzoom": 13.1,
+                "maxzoom": 20
+              },
+              "openmaptiles": {
+                "type": "vector",
+                "url": "https://geoserveis.icgc.cat/contextmaps/basemap.json"
+              }
+            },
+            "sprite": "https://geoserveis.icgc.cat/contextmaps/sprites/sprite@1",
+            "glyphs": "https://geoserveis.icgc.cat/contextmaps/glyphs/{fontstack}/{range}.pbf",
+            "layers": [
+              {
+                "id": "background",
+                "type": "background",
+                "paint": {
+                  "background-color": "#F4F9F4"
+                }
+              },
+              {
+                "id": "ortoEsri",
+                "type": "raster",
+                "source": "ortoEsri",
+                "maxzoom": 16,
+                "layout": {
+                  "visibility": "visible"
+                }
+              },
+              {
+                "id": "ortoICGC",
+                "type": "raster",
+                "source": "ortoICGC",
+                "minzoom": 13.1,
+                "maxzoom": 19,
+                "layout": {
+                  "visibility": "visible"
+                }
+              },
+              {
+                "id": "ortoInstaMaps",
+                "type": "raster",
+                "source": "ortoInstaMaps",
+                "maxzoom": 13,
+                "layout": {
+                  "visibility": "visible"
+                }
+              }
+            ]
+          };
+        }
+      });
+      var require_constants27 = __commonJS({
+        "src/plots/map/constants.js"(exports, module2) {
+          var sortObjectKeys = require_sort_object_keys();
+          var arcgisSatHybrid = require_arcgis_sat_hybrid();
+          var arcgisSat = require_arcgis_sat();
+          var OSM = '© <a target="_blank" href="https://www.openstreetmap.org/copyright">OpenStreetMap</a> contributors';
+          var cartoPositron = "https://basemaps.cartocdn.com/gl/positron-gl-style/style.json";
+          var cartoDarkmatter = "https://basemaps.cartocdn.com/gl/dark-matter-gl-style/style.json";
+          var cartoVoyager = "https://basemaps.cartocdn.com/gl/voyager-gl-style/style.json";
+          var cartoPositronNoLabels = "https://basemaps.cartocdn.com/gl/positron-nolabels-gl-style/style.json";
+          var cartoDarkmatterNoLabels = "https://basemaps.cartocdn.com/gl/dark-matter-nolabels-gl-style/style.json";
+          var cartoVoyagerNoLabels = "https://basemaps.cartocdn.com/gl/voyager-nolabels-gl-style/style.json";
+          var stylesMap = {
+            basic: cartoVoyager,
+            streets: cartoVoyager,
+            outdoors: cartoVoyager,
+            light: cartoPositron,
+            dark: cartoDarkmatter,
+            satellite: arcgisSat,
+            "satellite-streets": arcgisSatHybrid,
+            "open-street-map": {
+              id: "osm",
+              version: 8,
+              sources: {
+                "plotly-osm-tiles": {
+                  type: "raster",
+                  attribution: OSM,
+                  tiles: [
+                    "https://tile.openstreetmap.org/{z}/{x}/{y}.png"
+                  ],
+                  tileSize: 256
+                }
+              },
+              layers: [{
+                id: "plotly-osm-tiles",
+                type: "raster",
+                source: "plotly-osm-tiles",
+                minzoom: 0,
+                maxzoom: 22
+              }],
+              glyphs: "https://fonts.openmaptiles.org/{fontstack}/{range}.pbf"
+            },
+            "white-bg": {
+              id: "white-bg",
+              version: 8,
+              sources: {},
+              layers: [{
+                id: "white-bg",
+                type: "background",
+                paint: { "background-color": "#FFFFFF" },
+                minzoom: 0,
+                maxzoom: 22
+              }],
+              glyphs: "https://fonts.openmaptiles.org/{fontstack}/{range}.pbf"
+            },
+            "carto-positron": cartoPositron,
+            "carto-darkmatter": cartoDarkmatter,
+            "carto-voyager": cartoVoyager,
+            "carto-positron-nolabels": cartoPositronNoLabels,
+            "carto-darkmatter-nolabels": cartoDarkmatterNoLabels,
+            "carto-voyager-nolabels": cartoVoyagerNoLabels
+          };
+          var styleValuesMap = sortObjectKeys(stylesMap);
+          module2.exports = {
+            styleValueDflt: "basic",
+            stylesMap,
+            styleValuesMap,
+            traceLayerPrefix: "plotly-trace-layer-",
+            layoutLayerPrefix: "plotly-layout-layer-",
+            missingStyleErrorMsg: [
+              "No valid maplibre style found, please set `map.style` to one of:",
+              styleValuesMap.join(", "),
+              "or use a tile service."
+            ].join("\n"),
+            mapOnErrorMsg: "Map error."
+          };
+        }
+      });
+      var require_layout_attributes20 = __commonJS({
+        "src/plots/map/layout_attributes.js"(exports, module2) {
+          var Lib = require_lib();
+          var defaultLine = require_color().defaultLine;
+          var domainAttrs = require_domain().attributes;
+          var fontAttrs = require_font_attributes();
+          var textposition = require_attributes12().textposition;
+          var overrideAll = require_edit_types().overrideAll;
+          var templatedArray = require_plot_template().templatedArray;
+          var constants = require_constants27();
+          var fontAttr = fontAttrs({
+            noFontVariant: true,
+            noFontShadow: true,
+            noFontLineposition: true,
+            noFontTextcase: true
+          });
+          fontAttr.family.dflt = "Open Sans Regular, Arial Unicode MS Regular";
+          var attrs = module2.exports = overrideAll({
+            _arrayAttrRegexps: [Lib.counterRegex("map", ".layers", true)],
+            domain: domainAttrs({ name: "map" }),
+            style: {
+              valType: "any",
+              values: constants.styleValuesMap,
+              dflt: constants.styleValueDflt
+            },
+            center: {
+              lon: {
+                valType: "number",
+                dflt: 0
+              },
+              lat: {
+                valType: "number",
+                dflt: 0
+              }
+            },
+            zoom: {
+              valType: "number",
+              dflt: 1
+            },
+            bearing: {
+              valType: "number",
+              dflt: 0
+            },
+            pitch: {
+              valType: "number",
+              dflt: 0
+            },
+            bounds: {
+              west: {
+                valType: "number"
+              },
+              east: {
+                valType: "number"
+              },
+              south: {
+                valType: "number"
+              },
+              north: {
+                valType: "number"
+              }
+            },
+            layers: templatedArray("layer", {
+              visible: {
+                valType: "boolean",
+                dflt: true
+              },
+              sourcetype: {
+                valType: "enumerated",
+                values: ["geojson", "vector", "raster", "image"],
+                dflt: "geojson"
+              },
+              source: {
+                valType: "any"
+              },
+              sourcelayer: {
+                valType: "string",
+                dflt: ""
+              },
+              sourceattribution: {
+                valType: "string"
+              },
+              type: {
+                valType: "enumerated",
+                values: ["circle", "line", "fill", "symbol", "raster"],
+                dflt: "circle"
+              },
+              coordinates: {
+                valType: "any"
+              },
+              // attributes shared between all types
+              below: {
+                valType: "string"
+              },
+              color: {
+                valType: "color",
+                dflt: defaultLine
+              },
+              opacity: {
+                valType: "number",
+                min: 0,
+                max: 1,
+                dflt: 1
+              },
+              minzoom: {
+                valType: "number",
+                min: 0,
+                max: 24,
+                dflt: 0
+              },
+              maxzoom: {
+                valType: "number",
+                min: 0,
+                max: 24,
+                dflt: 24
+              },
+              // type-specific style attributes
+              circle: {
+                radius: {
+                  valType: "number",
+                  dflt: 15
+                }
+              },
+              line: {
+                width: {
+                  valType: "number",
+                  dflt: 2
+                },
+                dash: {
+                  valType: "data_array"
+                }
+              },
+              fill: {
+                outlinecolor: {
+                  valType: "color",
+                  dflt: defaultLine
+                }
+              },
+              symbol: {
+                icon: {
+                  valType: "string",
+                  dflt: "marker"
+                },
+                iconsize: {
+                  valType: "number",
+                  dflt: 10
+                },
+                text: {
+                  valType: "string",
+                  dflt: ""
+                },
+                placement: {
+                  valType: "enumerated",
+                  values: ["point", "line", "line-center"],
+                  dflt: "point"
+                },
+                textfont: fontAttr,
+                textposition: Lib.extendFlat({}, textposition, { arrayOk: false })
+              }
+            })
+          }, "plot", "from-root");
+          attrs.uirevision = {
+            valType: "any",
+            editType: "none"
+          };
+        }
+      });
+      var require_attributes57 = __commonJS({
+        "src/traces/scattermap/attributes.js"(exports, module2) {
+          var { hovertemplateAttrs, texttemplateAttrs, templatefallbackAttrs } = require_template_attributes();
+          var makeFillcolorAttr = require_fillcolor_attribute();
+          var scatterGeoAttrs = require_attributes48();
+          var scatterAttrs = require_attributes12();
+          var mapAttrs = require_layout_attributes20();
+          var baseAttrs = require_attributes2();
+          var colorScaleAttrs = require_attributes8();
+          var extendFlat = require_extend().extendFlat;
+          var overrideAll = require_edit_types().overrideAll;
+          var mapLayoutAtributes = require_layout_attributes20();
+          var lineAttrs = scatterGeoAttrs.line;
+          var markerAttrs = scatterGeoAttrs.marker;
+          module2.exports = overrideAll(
+            {
+              lon: scatterGeoAttrs.lon,
+              lat: scatterGeoAttrs.lat,
+              cluster: {
+                enabled: {
+                  valType: "boolean"
+                },
+                maxzoom: extendFlat({}, mapLayoutAtributes.layers.maxzoom, {}),
+                step: {
+                  valType: "number",
+                  arrayOk: true,
+                  dflt: -1,
+                  min: -1
+                },
+                size: {
+                  valType: "number",
+                  arrayOk: true,
+                  dflt: 20,
+                  min: 0
+                },
+                color: {
+                  valType: "color",
+                  arrayOk: true
+                },
+                opacity: extendFlat({}, markerAttrs.opacity, {
+                  dflt: 1
+                })
+              },
+              // locations
+              // locationmode
+              mode: extendFlat({}, scatterAttrs.mode, {
+                dflt: "markers"
+              }),
+              text: extendFlat({}, scatterAttrs.text, {}),
+              texttemplate: texttemplateAttrs({ editType: "plot" }, { keys: ["lat", "lon", "text"] }),
+              texttemplatefallback: templatefallbackAttrs({ editType: "plot" }),
+              hovertext: extendFlat({}, scatterAttrs.hovertext, {}),
+              line: {
+                color: lineAttrs.color,
+                width: lineAttrs.width
+                // TODO
+                // dash: dash
+              },
+              connectgaps: scatterAttrs.connectgaps,
+              marker: extendFlat(
+                {
+                  symbol: {
+                    valType: "string",
+                    dflt: "circle",
+                    arrayOk: true
+                  },
+                  angle: {
+                    valType: "number",
+                    dflt: "auto",
+                    arrayOk: true
+                  },
+                  allowoverlap: {
+                    valType: "boolean",
+                    dflt: false
+                  },
+                  opacity: markerAttrs.opacity,
+                  size: markerAttrs.size,
+                  sizeref: markerAttrs.sizeref,
+                  sizemin: markerAttrs.sizemin,
+                  sizemode: markerAttrs.sizemode
+                },
+                colorScaleAttrs("marker")
+                // line
+              ),
+              fill: scatterGeoAttrs.fill,
+              fillcolor: makeFillcolorAttr(),
+              textfont: mapAttrs.layers.symbol.textfont,
+              textposition: mapAttrs.layers.symbol.textposition,
+              below: {
+                valType: "string"
+              },
+              selected: {
+                marker: scatterAttrs.selected.marker
+              },
+              unselected: {
+                marker: scatterAttrs.unselected.marker
+              },
+              hoverinfo: extendFlat({}, baseAttrs.hoverinfo, {
+                flags: ["lon", "lat", "text", "name"]
+              }),
+              hovertemplate: hovertemplateAttrs(),
+              hovertemplatefallback: templatefallbackAttrs()
+            },
+            "calc",
+            "nested"
+          );
+        }
+      });
+      var require_constants28 = __commonJS({
+        "src/traces/scattermap/constants.js"(exports, module2) {
+          var supportedFonts = [
+            "Metropolis Black Italic",
+            "Metropolis Black",
+            "Metropolis Bold Italic",
+            "Metropolis Bold",
+            "Metropolis Extra Bold Italic",
+            "Metropolis Extra Bold",
+            "Metropolis Extra Light Italic",
+            "Metropolis Extra Light",
+            "Metropolis Light Italic",
+            "Metropolis Light",
+            "Metropolis Medium Italic",
+            "Metropolis Medium",
+            "Metropolis Regular Italic",
+            "Metropolis Regular",
+            "Metropolis Semi Bold Italic",
+            "Metropolis Semi Bold",
+            "Metropolis Thin Italic",
+            "Metropolis Thin",
+            "Open Sans Bold Italic",
+            "Open Sans Bold",
+            "Open Sans Extrabold Italic",
+            "Open Sans Extrabold",
+            "Open Sans Italic",
+            "Open Sans Light Italic",
+            "Open Sans Light",
+            "Open Sans Regular",
+            "Open Sans Semibold Italic",
+            "Open Sans Semibold",
+            "Klokantech Noto Sans Bold",
+            "Klokantech Noto Sans CJK Bold",
+            "Klokantech Noto Sans CJK Regular",
+            "Klokantech Noto Sans Italic",
+            "Klokantech Noto Sans Regular"
+          ];
+          module2.exports = {
+            isSupportedFont: function(a2) {
+              return supportedFonts.indexOf(a2) !== -1;
+            }
+          };
+        }
+      });
+      var require_defaults53 = __commonJS({
+        "src/traces/scattermap/defaults.js"(exports, module2) {
+          var Lib = require_lib();
+          var subTypes = require_subtypes();
+          var handleMarkerDefaults = require_marker_defaults();
+          var handleLineDefaults = require_line_defaults();
+          var handleTextDefaults = require_text_defaults();
+          var handleFillColorDefaults = require_fillcolor_defaults();
+          var attributes = require_attributes57();
+          var isSupportedFont = require_constants28().isSupportedFont;
+          module2.exports = function supplyDefaults(traceIn, traceOut, defaultColor, layout) {
+            function coerce(attr, dflt) {
+              return Lib.coerce(traceIn, traceOut, attributes, attr, dflt);
+            }
+            function coerce2(attr, dflt) {
+              return Lib.coerce2(traceIn, traceOut, attributes, attr, dflt);
+            }
+            var len2 = handleLonLatDefaults(traceIn, traceOut, coerce);
+            if (!len2) {
+              traceOut.visible = false;
+              return;
+            }
+            coerce("text");
+            coerce("texttemplate");
+            coerce("texttemplatefallback");
+            coerce("hovertext");
+            coerce("hovertemplate");
+            coerce("hovertemplatefallback");
+            coerce("mode");
+            coerce("below");
+            if (subTypes.hasMarkers(traceOut)) {
+              handleMarkerDefaults(traceIn, traceOut, defaultColor, layout, coerce, { noLine: true, noAngle: true });
+              coerce("marker.allowoverlap");
+              coerce("marker.angle");
+              var marker = traceOut.marker;
+              if (marker.symbol !== "circle") {
+                if (Lib.isArrayOrTypedArray(marker.size)) marker.size = marker.size[0];
+                if (Lib.isArrayOrTypedArray(marker.color)) marker.color = marker.color[0];
+              }
+            }
+            if (subTypes.hasLines(traceOut)) {
+              handleLineDefaults(traceIn, traceOut, defaultColor, layout, coerce, { noDash: true });
+              coerce("connectgaps");
+            }
+            var clusterMaxzoom = coerce2("cluster.maxzoom");
+            var clusterStep = coerce2("cluster.step");
+            var clusterColor = coerce2("cluster.color", traceOut.marker && traceOut.marker.color || defaultColor);
+            var clusterSize = coerce2("cluster.size");
+            var clusterOpacity = coerce2("cluster.opacity");
+            var clusterEnabledDflt = clusterMaxzoom !== false || clusterStep !== false || clusterColor !== false || clusterSize !== false || clusterOpacity !== false;
+            var clusterEnabled = coerce("cluster.enabled", clusterEnabledDflt);
+            if (clusterEnabled || subTypes.hasText(traceOut)) {
+              var layoutFontFamily = layout.font.family;
+              handleTextDefaults(traceIn, traceOut, layout, coerce, {
+                noSelect: true,
+                noFontVariant: true,
+                noFontShadow: true,
+                noFontLineposition: true,
+                noFontTextcase: true,
+                font: {
+                  family: isSupportedFont(layoutFontFamily) ? layoutFontFamily : "Open Sans Regular",
+                  weight: layout.font.weight,
+                  style: layout.font.style,
+                  size: layout.font.size,
+                  color: layout.font.color
+                }
+              });
+            }
+            coerce("fill");
+            if (traceOut.fill !== "none") {
+              handleFillColorDefaults(traceIn, traceOut, defaultColor, coerce);
+            }
+            Lib.coerceSelectionMarkerOpacity(traceOut, coerce);
+          };
+          function handleLonLatDefaults(traceIn, traceOut, coerce) {
+            var lon = coerce("lon") || [];
+            var lat = coerce("lat") || [];
+            var len2 = Math.min(lon.length, lat.length);
+            traceOut._length = len2;
+            return len2;
+          }
+        }
+      });
+      var require_format_labels6 = __commonJS({
+        "src/traces/scattermap/format_labels.js"(exports, module2) {
+          var Axes = require_axes();
+          module2.exports = function formatLabels(cdi, trace, fullLayout) {
+            var labels = {};
+            var subplot = fullLayout[trace.subplot]._subplot;
+            var ax = subplot.mockAxis;
+            var lonlat = cdi.lonlat;
+            labels.lonLabel = Axes.tickText(ax, ax.c2l(lonlat[0]), true).text;
+            labels.latLabel = Axes.tickText(ax, ax.c2l(lonlat[1]), true).text;
+            return labels;
+          };
+        }
+      });
+      var require_convert_text_opts2 = __commonJS({
+        "src/plots/map/convert_text_opts.js"(exports, module2) {
+          var Lib = require_lib();
+          module2.exports = function convertTextOpts(textposition, iconSize) {
+            var parts = textposition.split(" ");
+            var vPos = parts[0];
+            var hPos = parts[1];
+            var factor = Lib.isArrayOrTypedArray(iconSize) ? Lib.mean(iconSize) : iconSize;
+            var xInc = 0.5 + factor / 100;
+            var yInc = 1.5 + factor / 100;
+            var anchorVals = ["", ""];
+            var offset = [0, 0];
+            switch (vPos) {
+              case "top":
+                anchorVals[0] = "top";
+                offset[1] = -yInc;
+                break;
+              case "bottom":
+                anchorVals[0] = "bottom";
+                offset[1] = yInc;
+                break;
+            }
+            switch (hPos) {
+              case "left":
+                anchorVals[1] = "right";
+                offset[0] = -xInc;
+                break;
+              case "right":
+                anchorVals[1] = "left";
+                offset[0] = xInc;
+                break;
+            }
+            var anchor;
+            if (anchorVals[0] && anchorVals[1]) anchor = anchorVals.join("-");
+            else if (anchorVals[0]) anchor = anchorVals[0];
+            else if (anchorVals[1]) anchor = anchorVals[1];
+            else anchor = "center";
+            return { anchor, offset };
+          };
+        }
+      });
+      var require_convert14 = __commonJS({
+        "src/traces/scattermap/convert.js"(exports, module2) {
+          var isNumeric = require_fast_isnumeric();
+          var Lib = require_lib();
+          var BADNUM = require_numerical().BADNUM;
+          var geoJsonUtils = require_geojson_utils();
+          var Colorscale = require_colorscale();
+          var Drawing = require_drawing();
+          var makeBubbleSizeFn = require_make_bubble_size_func();
+          var subTypes = require_subtypes();
+          var isSupportedFont = require_constants28().isSupportedFont;
+          var convertTextOpts = require_convert_text_opts2();
+          var appendArrayPointValue = require_helpers2().appendArrayPointValue;
+          var NEWLINES = require_svg_text_utils().NEWLINES;
+          var BR_TAG_ALL = require_svg_text_utils().BR_TAG_ALL;
+          module2.exports = function convert(gd2, calcTrace) {
+            var trace = calcTrace[0].trace;
+            var isVisible = trace.visible === true && trace._length !== 0;
+            var hasFill = trace.fill !== "none";
+            var hasLines = subTypes.hasLines(trace);
+            var hasMarkers = subTypes.hasMarkers(trace);
+            var hasText = subTypes.hasText(trace);
+            var hasCircles = hasMarkers && trace.marker.symbol === "circle";
+            var hasSymbols = hasMarkers && trace.marker.symbol !== "circle";
+            var hasCluster = trace.cluster && trace.cluster.enabled;
+            var fill = initContainer("fill");
+            var line = initContainer("line");
+            var circle = initContainer("circle");
+            var symbol = initContainer("symbol");
+            var opts = {
+              fill,
+              line,
+              circle,
+              symbol
+            };
+            if (!isVisible) return opts;
+            var lineCoords;
+            if (hasFill || hasLines) {
+              lineCoords = geoJsonUtils.calcTraceToLineCoords(calcTrace);
+            }
+            if (hasFill) {
+              fill.geojson = geoJsonUtils.makePolygon(lineCoords);
+              fill.layout.visibility = "visible";
+              Lib.extendFlat(fill.paint, {
+                "fill-color": trace.fillcolor
+              });
+            }
+            if (hasLines) {
+              line.geojson = geoJsonUtils.makeLine(lineCoords);
+              line.layout.visibility = "visible";
+              Lib.extendFlat(line.paint, {
+                "line-width": trace.line.width,
+                "line-color": trace.line.color,
+                "line-opacity": trace.opacity
+              });
+            }
+            if (hasCircles) {
+              var circleOpts = makeCircleOpts(calcTrace);
+              circle.geojson = circleOpts.geojson;
+              circle.layout.visibility = "visible";
+              if (hasCluster) {
+                circle.filter = ["!", ["has", "point_count"]];
+                opts.cluster = {
+                  type: "circle",
+                  filter: ["has", "point_count"],
+                  layout: { visibility: "visible" },
+                  paint: {
+                    "circle-color": arrayifyAttribute(trace.cluster.color, trace.cluster.step),
+                    "circle-radius": arrayifyAttribute(trace.cluster.size, trace.cluster.step),
+                    "circle-opacity": arrayifyAttribute(trace.cluster.opacity, trace.cluster.step)
+                  }
+                };
+                opts.clusterCount = {
+                  type: "symbol",
+                  filter: ["has", "point_count"],
+                  paint: {},
+                  layout: {
+                    "text-field": "{point_count_abbreviated}",
+                    "text-font": getTextFont(trace),
+                    "text-size": 12
+                  }
+                };
+              }
+              Lib.extendFlat(circle.paint, {
+                "circle-color": circleOpts.mcc,
+                "circle-radius": circleOpts.mrc,
+                "circle-opacity": circleOpts.mo
+              });
+            }
+            if (hasCircles && hasCluster) {
+              circle.filter = ["!", ["has", "point_count"]];
+            }
+            if (hasSymbols || hasText) {
+              symbol.geojson = makeSymbolGeoJSON(calcTrace, gd2);
+              Lib.extendFlat(symbol.layout, {
+                visibility: "visible",
+                "icon-image": "{symbol}-15",
+                "text-field": "{text}"
+              });
+              if (hasSymbols) {
+                Lib.extendFlat(symbol.layout, {
+                  "icon-size": trace.marker.size / 10
+                });
+                if ("angle" in trace.marker && trace.marker.angle !== "auto") {
+                  Lib.extendFlat(symbol.layout, {
+                    // unfortunately cant use {angle} do to this issue:
+                    // https://github.com/mapbox/mapbox-gl-js/issues/873
+                    "icon-rotate": {
+                      type: "identity",
+                      property: "angle"
+                    },
+                    "icon-rotation-alignment": "map"
+                  });
+                }
+                symbol.layout["icon-allow-overlap"] = trace.marker.allowoverlap;
+                Lib.extendFlat(symbol.paint, {
+                  "icon-opacity": trace.opacity * trace.marker.opacity,
+                  // TODO does not work ??
+                  "icon-color": trace.marker.color
+                });
+              }
+              if (hasText) {
+                var iconSize = (trace.marker || {}).size;
+                var textOpts = convertTextOpts(trace.textposition, iconSize);
+                Lib.extendFlat(symbol.layout, {
+                  "text-size": trace.textfont.size,
+                  "text-anchor": textOpts.anchor,
+                  "text-offset": textOpts.offset,
+                  "text-font": getTextFont(trace)
+                });
+                Lib.extendFlat(symbol.paint, {
+                  "text-color": trace.textfont.color,
+                  "text-opacity": trace.opacity
+                });
+              }
+            }
+            return opts;
+          };
+          function initContainer(type) {
+            return {
+              type,
+              geojson: geoJsonUtils.makeBlank(),
+              layout: { visibility: "none" },
+              filter: null,
+              paint: {}
+            };
+          }
+          function makeCircleOpts(calcTrace) {
+            var trace = calcTrace[0].trace;
+            var marker = trace.marker;
+            var selectedpoints = trace.selectedpoints;
+            var arrayColor = Lib.isArrayOrTypedArray(marker.color);
+            var arraySize = Lib.isArrayOrTypedArray(marker.size);
+            var arrayOpacity = Lib.isArrayOrTypedArray(marker.opacity);
+            var i2;
+            function addTraceOpacity(o2) {
+              return trace.opacity * o2;
+            }
+            function size2radius(s2) {
+              return s2 / 2;
+            }
+            var colorFn;
+            if (arrayColor) {
+              if (Colorscale.hasColorscale(trace, "marker")) {
+                colorFn = Colorscale.makeColorScaleFuncFromTrace(marker);
+              } else {
+                colorFn = Lib.identity;
+              }
+            }
+            var sizeFn;
+            if (arraySize) {
+              sizeFn = makeBubbleSizeFn(trace);
+            }
+            var opacityFn;
+            if (arrayOpacity) {
+              opacityFn = function(mo) {
+                var mo2 = isNumeric(mo) ? +Lib.constrain(mo, 0, 1) : 0;
+                return addTraceOpacity(mo2);
+              };
+            }
+            var features = [];
+            for (i2 = 0; i2 < calcTrace.length; i2++) {
+              var calcPt = calcTrace[i2];
+              var lonlat = calcPt.lonlat;
+              if (isBADNUM(lonlat)) continue;
+              var props = {};
+              if (colorFn) props.mcc = calcPt.mcc = colorFn(calcPt.mc);
+              if (sizeFn) props.mrc = calcPt.mrc = sizeFn(calcPt.ms);
+              if (opacityFn) props.mo = opacityFn(calcPt.mo);
+              if (selectedpoints) props.selected = calcPt.selected || 0;
+              features.push({
+                type: "Feature",
+                id: i2 + 1,
+                geometry: { type: "Point", coordinates: lonlat },
+                properties: props
+              });
+            }
+            var fns;
+            if (selectedpoints) {
+              fns = Drawing.makeSelectedPointStyleFns(trace);
+              for (i2 = 0; i2 < features.length; i2++) {
+                var d2 = features[i2].properties;
+                if (fns.selectedOpacityFn) {
+                  d2.mo = addTraceOpacity(fns.selectedOpacityFn(d2));
+                }
+                if (fns.selectedColorFn) {
+                  d2.mcc = fns.selectedColorFn(d2);
+                }
+                if (fns.selectedSizeFn) {
+                  d2.mrc = fns.selectedSizeFn(d2);
+                }
+              }
+            }
+            return {
+              geojson: { type: "FeatureCollection", features },
+              mcc: arrayColor || fns && fns.selectedColorFn ? { type: "identity", property: "mcc" } : marker.color,
+              mrc: arraySize || fns && fns.selectedSizeFn ? { type: "identity", property: "mrc" } : size2radius(marker.size),
+              mo: arrayOpacity || fns && fns.selectedOpacityFn ? { type: "identity", property: "mo" } : addTraceOpacity(marker.opacity)
+            };
+          }
+          function makeSymbolGeoJSON(calcTrace, gd2) {
+            var fullLayout = gd2._fullLayout;
+            var trace = calcTrace[0].trace;
+            var marker = trace.marker || {};
+            var symbol = marker.symbol;
+            var angle2 = marker.angle;
+            var fillSymbol = symbol !== "circle" ? getFillFunc(symbol) : blankFillFunc;
+            var fillAngle = angle2 !== "auto" ? getFillFunc(angle2, true) : blankFillFunc;
+            var fillText = subTypes.hasText(trace) ? getFillFunc(trace.text) : blankFillFunc;
+            var features = [];
+            for (var i2 = 0; i2 < calcTrace.length; i2++) {
+              var calcPt = calcTrace[i2];
+              if (isBADNUM(calcPt.lonlat)) continue;
+              var texttemplate = trace.texttemplate;
+              var text;
+              if (texttemplate) {
+                var tt2 = Array.isArray(texttemplate) ? texttemplate[i2] || "" : texttemplate;
+                var labels = trace._module.formatLabels(calcPt, trace, fullLayout);
+                var pointValues = {};
+                appendArrayPointValue(pointValues, trace, calcPt.i);
+                text = Lib.texttemplateString({
+                  data: [pointValues, calcPt, trace._meta],
+                  fallback: trace.texttemplatefallback,
+                  labels,
+                  locale: fullLayout._d3locale,
+                  template: tt2
+                });
+              } else {
+                text = fillText(i2);
+              }
+              if (text) {
+                text = text.replace(NEWLINES, "").replace(BR_TAG_ALL, "\n");
+              }
+              features.push({
+                type: "Feature",
+                geometry: {
+                  type: "Point",
+                  coordinates: calcPt.lonlat
+                },
+                properties: {
+                  symbol: fillSymbol(i2),
+                  angle: fillAngle(i2),
+                  text
+                }
+              });
+            }
+            return {
+              type: "FeatureCollection",
+              features
+            };
+          }
+          function getFillFunc(attr, numeric) {
+            if (Lib.isArrayOrTypedArray(attr)) {
+              if (numeric) {
+                return function(i2) {
+                  return isNumeric(attr[i2]) ? +attr[i2] : 0;
+                };
+              }
+              return function(i2) {
+                return attr[i2];
+              };
+            } else if (attr) {
+              return function() {
+                return attr;
+              };
+            } else {
+              return blankFillFunc;
+            }
+          }
+          function blankFillFunc() {
+            return "";
+          }
+          function isBADNUM(lonlat) {
+            return lonlat[0] === BADNUM;
+          }
+          function arrayifyAttribute(values, step) {
+            var newAttribute;
+            if (Lib.isArrayOrTypedArray(values) && Lib.isArrayOrTypedArray(step)) {
+              newAttribute = ["step", ["get", "point_count"], values[0]];
+              for (var idx = 1; idx < values.length; idx++) {
+                newAttribute.push(step[idx - 1], values[idx]);
+              }
+            } else {
+              newAttribute = values;
+            }
+            return newAttribute;
+          }
+          function getTextFont(trace) {
+            var font = trace.textfont;
+            var family = font.family;
+            var style = font.style;
+            var weight = font.weight;
+            var parts = family.split(" ");
+            var isItalic = parts[parts.length - 1] === "Italic";
+            if (isItalic) parts.pop();
+            isItalic = isItalic || style === "italic";
+            var str = parts.join(" ");
+            if (weight === "bold" && parts.indexOf("Bold") === -1) {
+              str += " Bold";
+            } else if (weight <= 1e3) {
+              if (parts[0] === "Metropolis") {
+                str = "Metropolis";
+                if (weight > 850) str += " Black";
+                else if (weight > 750) str += " Extra Bold";
+                else if (weight > 650) str += " Bold";
+                else if (weight > 550) str += " Semi Bold";
+                else if (weight > 450) str += " Medium";
+                else if (weight > 350) str += " Regular";
+                else if (weight > 250) str += " Light";
+                else if (weight > 150) str += " Extra Light";
+                else str += " Thin";
+              } else if (parts.slice(0, 2).join(" ") === "Open Sans") {
+                str = "Open Sans";
+                if (weight > 750) str += " Extrabold";
+                else if (weight > 650) str += " Bold";
+                else if (weight > 550) str += " Semibold";
+                else if (weight > 350) str += " Regular";
+                else str += " Light";
+              } else if (parts.slice(0, 3).join(" ") === "Klokantech Noto Sans") {
+                str = "Klokantech Noto Sans";
+                if (parts[3] === "CJK") str += " CJK";
+                str += weight > 500 ? " Bold" : " Regular";
+              }
+            }
+            if (isItalic) str += " Italic";
+            if (str === "Open Sans Regular Italic") str = "Open Sans Italic";
+            else if (str === "Open Sans Regular Bold") str = "Open Sans Bold";
+            else if (str === "Open Sans Regular Bold Italic") str = "Open Sans Bold Italic";
+            else if (str === "Klokantech Noto Sans Regular Italic") str = "Klokantech Noto Sans Italic";
+            if (!isSupportedFont(str)) {
+              str = family;
+            }
+            var textFont = str.split(", ");
+            return textFont;
+          }
+        }
+      });
+      var require_plot26 = __commonJS({
+        "src/traces/scattermap/plot.js"(exports, module2) {
+          var Lib = require_lib();
+          var convert = require_convert14();
+          var LAYER_PREFIX = require_constants27().traceLayerPrefix;
+          var ORDER = {
+            cluster: ["cluster", "clusterCount", "circle"],
+            nonCluster: ["fill", "line", "circle", "symbol"]
+          };
+          function ScatterMap(subplot, uid2, clusterEnabled, isHidden) {
+            this.type = "scattermap";
+            this.subplot = subplot;
+            this.uid = uid2;
+            this.clusterEnabled = clusterEnabled;
+            this.isHidden = isHidden;
+            this.sourceIds = {
+              fill: "source-" + uid2 + "-fill",
+              line: "source-" + uid2 + "-line",
+              circle: "source-" + uid2 + "-circle",
+              symbol: "source-" + uid2 + "-symbol",
+              cluster: "source-" + uid2 + "-circle",
+              clusterCount: "source-" + uid2 + "-circle"
+            };
+            this.layerIds = {
+              fill: LAYER_PREFIX + uid2 + "-fill",
+              line: LAYER_PREFIX + uid2 + "-line",
+              circle: LAYER_PREFIX + uid2 + "-circle",
+              symbol: LAYER_PREFIX + uid2 + "-symbol",
+              cluster: LAYER_PREFIX + uid2 + "-cluster",
+              clusterCount: LAYER_PREFIX + uid2 + "-cluster-count"
+            };
+            this.below = null;
+          }
+          var proto = ScatterMap.prototype;
+          proto.addSource = function(k2, opts, cluster) {
+            var sourceOpts = {
+              type: "geojson",
+              data: opts.geojson
+            };
+            if (cluster && cluster.enabled) {
+              Lib.extendFlat(sourceOpts, {
+                cluster: true,
+                clusterMaxZoom: cluster.maxzoom
+              });
+            }
+            var isSourceExists = this.subplot.map.getSource(this.sourceIds[k2]);
+            if (isSourceExists) {
+              isSourceExists.setData(opts.geojson);
+            } else {
+              this.subplot.map.addSource(this.sourceIds[k2], sourceOpts);
+            }
+          };
+          proto.setSourceData = function(k2, opts) {
+            this.subplot.map.getSource(this.sourceIds[k2]).setData(opts.geojson);
+          };
+          proto.addLayer = function(k2, opts, below) {
+            var source2 = {
+              type: opts.type,
+              id: this.layerIds[k2],
+              source: this.sourceIds[k2],
+              layout: opts.layout,
+              paint: opts.paint
+            };
+            if (opts.filter) {
+              source2.filter = opts.filter;
+            }
+            var currentLayerId = this.layerIds[k2];
+            var layerExist;
+            var layers = this.subplot.getMapLayers();
+            for (var i2 = 0; i2 < layers.length; i2++) {
+              if (layers[i2].id === currentLayerId) {
+                layerExist = true;
+                break;
+              }
+            }
+            if (layerExist) {
+              this.subplot.setOptions(currentLayerId, "setLayoutProperty", source2.layout);
+              if (source2.layout.visibility === "visible") {
+                this.subplot.setOptions(currentLayerId, "setPaintProperty", source2.paint);
+              }
+            } else {
+              this.subplot.addLayer(source2, below);
+            }
+          };
+          proto.update = function update(calcTrace) {
+            var trace = calcTrace[0].trace;
+            var subplot = this.subplot;
+            var map2 = subplot.map;
+            var optsAll = convert(subplot.gd, calcTrace);
+            var below = subplot.belowLookup["trace-" + this.uid];
+            var hasCluster = !!(trace.cluster && trace.cluster.enabled);
+            var hadCluster = !!this.clusterEnabled;
+            var lThis = this;
+            function addCluster(noSource) {
+              if (!noSource) lThis.addSource("circle", optsAll.circle, trace.cluster);
+              var order = ORDER.cluster;
+              for (var i2 = 0; i2 < order.length; i2++) {
+                var k2 = order[i2];
+                var opts = optsAll[k2];
+                lThis.addLayer(k2, opts, below);
+              }
+            }
+            function removeCluster(noSource) {
+              var order = ORDER.cluster;
+              for (var i2 = order.length - 1; i2 >= 0; i2--) {
+                var k2 = order[i2];
+                map2.removeLayer(lThis.layerIds[k2]);
+              }
+              if (!noSource) map2.removeSource(lThis.sourceIds.circle);
+            }
+            function addNonCluster(noSource) {
+              var order = ORDER.nonCluster;
+              for (var i2 = 0; i2 < order.length; i2++) {
+                var k2 = order[i2];
+                var opts = optsAll[k2];
+                if (!noSource) lThis.addSource(k2, opts);
+                lThis.addLayer(k2, opts, below);
+              }
+            }
+            function removeNonCluster(noSource) {
+              var order = ORDER.nonCluster;
+              for (var i2 = order.length - 1; i2 >= 0; i2--) {
+                var k2 = order[i2];
+                map2.removeLayer(lThis.layerIds[k2]);
+                if (!noSource) map2.removeSource(lThis.sourceIds[k2]);
+              }
+            }
+            function remove(noSource) {
+              if (hadCluster) removeCluster(noSource);
+              else removeNonCluster(noSource);
+            }
+            function add2(noSource) {
+              if (hasCluster) addCluster(noSource);
+              else addNonCluster(noSource);
+            }
+            function repaint() {
+              var order = hasCluster ? ORDER.cluster : ORDER.nonCluster;
+              for (var i2 = 0; i2 < order.length; i2++) {
+                var k2 = order[i2];
+                var opts = optsAll[k2];
+                if (!opts) continue;
+                subplot.setOptions(lThis.layerIds[k2], "setLayoutProperty", opts.layout);
+                if (opts.layout.visibility === "visible") {
+                  if (k2 !== "cluster") {
+                    lThis.setSourceData(k2, opts);
+                  }
+                  subplot.setOptions(lThis.layerIds[k2], "setPaintProperty", opts.paint);
+                }
+              }
+            }
+            var wasHidden = this.isHidden;
+            var isHidden = trace.visible !== true;
+            if (isHidden) {
+              if (!wasHidden) remove();
+            } else if (wasHidden) {
+              if (!isHidden) add2();
+            } else if (hadCluster !== hasCluster) {
+              remove();
+              add2();
+            } else if (this.below !== below) {
+              remove(true);
+              add2(true);
+              repaint();
+            } else {
+              repaint();
+            }
+            this.clusterEnabled = hasCluster;
+            this.isHidden = isHidden;
+            this.below = below;
+            calcTrace[0].trace._glTrace = this;
+          };
+          proto.dispose = function dispose() {
+            var map2 = this.subplot.map;
+            var order = this.clusterEnabled ? ORDER.cluster : ORDER.nonCluster;
+            for (var i2 = order.length - 1; i2 >= 0; i2--) {
+              var k2 = order[i2];
+              map2.removeLayer(this.layerIds[k2]);
+              map2.removeSource(this.sourceIds[k2]);
+            }
+          };
+          module2.exports = function createScatterMap(subplot, calcTrace) {
+            var trace = calcTrace[0].trace;
+            var hasCluster = trace.cluster && trace.cluster.enabled;
+            var isHidden = trace.visible !== true;
+            var scatterMap = new ScatterMap(
+              subplot,
+              trace.uid,
+              hasCluster,
+              isHidden
+            );
+            var optsAll = convert(subplot.gd, calcTrace);
+            var below = scatterMap.below = subplot.belowLookup["trace-" + trace.uid];
+            var i2, k2, opts;
+            if (hasCluster) {
+              scatterMap.addSource("circle", optsAll.circle, trace.cluster);
+              for (i2 = 0; i2 < ORDER.cluster.length; i2++) {
+                k2 = ORDER.cluster[i2];
+                opts = optsAll[k2];
+                scatterMap.addLayer(k2, opts, below);
+              }
+            } else {
+              for (i2 = 0; i2 < ORDER.nonCluster.length; i2++) {
+                k2 = ORDER.nonCluster[i2];
+                opts = optsAll[k2];
+                scatterMap.addSource(k2, opts, trace.cluster);
+                scatterMap.addLayer(k2, opts, below);
+              }
+            }
+            calcTrace[0].trace._glTrace = scatterMap;
+            return scatterMap;
+          };
+        }
+      });
+      var require_hover20 = __commonJS({
+        "src/traces/scattermap/hover.js"(exports, module2) {
+          var Fx = require_fx();
+          var Lib = require_lib();
+          var getTraceColor = require_get_trace_color();
+          var fillText = Lib.fillText;
+          var BADNUM = require_numerical().BADNUM;
+          var LAYER_PREFIX = require_constants27().traceLayerPrefix;
+          function hoverPoints(pointData, xval, yval) {
+            var cd2 = pointData.cd;
+            var trace = cd2[0].trace;
+            var xa = pointData.xa;
+            var ya2 = pointData.ya;
+            var subplot = pointData.subplot;
+            var clusteredPointsIds = [];
+            var layer = LAYER_PREFIX + trace.uid + "-circle";
+            var hasCluster = trace.cluster && trace.cluster.enabled;
+            if (hasCluster) {
+              var elems = subplot.map.queryRenderedFeatures(null, { layers: [layer] });
+              clusteredPointsIds = elems.map(function(elem) {
+                return elem.id;
+              });
+            }
+            var winding = xval >= 0 ? Math.floor((xval + 180) / 360) : Math.ceil((xval - 180) / 360);
+            var lonShift = winding * 360;
+            var xval2 = xval - lonShift;
+            function distFn(d2) {
+              var lonlat2 = d2.lonlat;
+              if (lonlat2[0] === BADNUM) return Infinity;
+              if (hasCluster && clusteredPointsIds.indexOf(d2.i + 1) === -1) return Infinity;
+              var lon = Lib.modHalf(lonlat2[0], 360);
+              var lat = lonlat2[1];
+              var pt2 = subplot.project([lon, lat]);
+              var dx = pt2.x - xa.c2p([xval2, lat]);
+              var dy = pt2.y - ya2.c2p([lon, yval]);
+              var rad2 = Math.max(3, d2.mrc || 0);
+              return Math.max(Math.sqrt(dx * dx + dy * dy) - rad2, 1 - 3 / rad2);
+            }
+            Fx.getClosest(cd2, distFn, pointData);
+            if (pointData.index === false) return;
+            var di2 = cd2[pointData.index];
+            var lonlat = di2.lonlat;
+            var lonlatShifted = [Lib.modHalf(lonlat[0], 360) + lonShift, lonlat[1]];
+            var xc2 = xa.c2p(lonlatShifted);
+            var yc2 = ya2.c2p(lonlatShifted);
+            var rad = di2.mrc || 1;
+            pointData.x0 = xc2 - rad;
+            pointData.x1 = xc2 + rad;
+            pointData.y0 = yc2 - rad;
+            pointData.y1 = yc2 + rad;
+            var fullLayout = {};
+            fullLayout[trace.subplot] = { _subplot: subplot };
+            var labels = trace._module.formatLabels(di2, trace, fullLayout);
+            pointData.lonLabel = labels.lonLabel;
+            pointData.latLabel = labels.latLabel;
+            pointData.color = getTraceColor(trace, di2);
+            pointData.extraText = getExtraText(trace, di2, cd2[0].t.labels);
+            pointData.hovertemplate = trace.hovertemplate;
+            return [pointData];
+          }
+          function getExtraText(trace, di2, labels) {
+            if (trace.hovertemplate) return;
+            var hoverinfo = di2.hi || trace.hoverinfo;
+            var parts = hoverinfo.split("+");
+            var isAll = parts.indexOf("all") !== -1;
+            var hasLon = parts.indexOf("lon") !== -1;
+            var hasLat = parts.indexOf("lat") !== -1;
+            var lonlat = di2.lonlat;
+            var text = [];
+            function format(v2) {
+              return v2 + "°";
+            }
+            if (isAll || hasLon && hasLat) {
+              text.push("(" + format(lonlat[1]) + ", " + format(lonlat[0]) + ")");
+            } else if (hasLon) {
+              text.push(labels.lon + format(lonlat[0]));
+            } else if (hasLat) {
+              text.push(labels.lat + format(lonlat[1]));
+            }
+            if (isAll || parts.indexOf("text") !== -1) {
+              fillText(di2, trace, text);
+            }
+            return text.join("<br>");
+          }
+          module2.exports = {
+            hoverPoints,
+            getExtraText
+          };
+        }
+      });
+      var require_event_data13 = __commonJS({
+        "src/traces/scattermap/event_data.js"(exports, module2) {
+          module2.exports = function eventData(out, pt2) {
+            out.lon = pt2.lon;
+            out.lat = pt2.lat;
+            return out;
+          };
+        }
+      });
+      var require_select10 = __commonJS({
+        "src/traces/scattermap/select.js"(exports, module2) {
+          var Lib = require_lib();
+          var subtypes = require_subtypes();
+          var BADNUM = require_numerical().BADNUM;
+          module2.exports = function selectPoints(searchInfo, selectionTester) {
+            var cd2 = searchInfo.cd;
+            var xa = searchInfo.xaxis;
+            var ya2 = searchInfo.yaxis;
+            var selection = [];
+            var trace = cd2[0].trace;
+            var i2;
+            if (!subtypes.hasMarkers(trace)) return [];
+            if (selectionTester === false) {
+              for (i2 = 0; i2 < cd2.length; i2++) {
+                cd2[i2].selected = 0;
+              }
+            } else {
+              for (i2 = 0; i2 < cd2.length; i2++) {
+                var di2 = cd2[i2];
+                var lonlat = di2.lonlat;
+                if (lonlat[0] !== BADNUM) {
+                  var lonlat2 = [Lib.modHalf(lonlat[0], 360), lonlat[1]];
+                  var xy = [xa.c2p(lonlat2), ya2.c2p(lonlat2)];
+                  if (selectionTester.contains(xy, null, i2, searchInfo)) {
+                    selection.push({
+                      pointNumber: i2,
+                      lon: lonlat[0],
+                      lat: lonlat[1]
+                    });
+                    di2.selected = 1;
+                  } else {
+                    di2.selected = 0;
+                  }
+                }
+              }
+            }
+            return selection;
+          };
+        }
+      });
+      var require_maplibre_gl2 = __commonJS({
+        "node_modules/maplibre-gl/dist/maplibre-gl.js"(exports, module2) {
+          (function(global2, factory2) {
+            typeof exports === "object" && typeof module2 !== "undefined" ? module2.exports = factory2() : (global2 = typeof globalThis !== "undefined" ? globalThis : global2 || self, global2.maplibregl = factory2());
+          })(exports, function() {
+            var maplibregl2 = {};
+            var modules = {};
+            function define2(moduleName, _dependencies, moduleFactory) {
+              modules[moduleName] = moduleFactory;
+              if (moduleName !== "index") {
+                return;
+              }
+              var workerBundleString = "var sharedModule = {}; (" + modules.shared + ")(sharedModule); (" + modules.worker + ")(sharedModule);";
+              var sharedModule = {};
+              modules.shared(sharedModule);
+              modules.index(maplibregl2, sharedModule);
+              if (typeof window !== "undefined") {
+                maplibregl2.setWorkerUrl(window.URL.createObjectURL(new Blob([workerBundleString], { type: "text/javascript" })));
+              }
+              return maplibregl2;
+            }
+            define2("shared", ["exports"], function(t4) {
+              function e2(t42, e22, r22, n22) {
+                return new (r22 || (r22 = Promise))(function(i22, s22) {
+                  function a22(t5) {
+                    try {
+                      l22(n22.next(t5));
+                    } catch (t6) {
+                      s22(t6);
+                    }
+                  }
+                  function o22(t5) {
+                    try {
+                      l22(n22.throw(t5));
+                    } catch (t6) {
+                      s22(t6);
+                    }
+                  }
+                  function l22(t5) {
+                    var e3;
+                    t5.done ? i22(t5.value) : (e3 = t5.value, e3 instanceof r22 ? e3 : new r22(function(t6) {
+                      t6(e3);
+                    })).then(a22, o22);
+                  }
+                  l22((n22 = n22.apply(t42, e22 || [])).next());
+                });
+              }
+              function r2(t42) {
+                return t42 && t42.__esModule && Object.prototype.hasOwnProperty.call(t42, "default") ? t42.default : t42;
+              }
+              "function" == typeof SuppressedError && SuppressedError;
+              var n2 = i2;
+              function i2(t42, e22) {
+                this.x = t42, this.y = e22;
+              }
+              i2.prototype = { clone: function() {
+                return new i2(this.x, this.y);
+              }, add: function(t42) {
+                return this.clone()._add(t42);
+              }, sub: function(t42) {
+                return this.clone()._sub(t42);
+              }, multByPoint: function(t42) {
+                return this.clone()._multByPoint(t42);
+              }, divByPoint: function(t42) {
+                return this.clone()._divByPoint(t42);
+              }, mult: function(t42) {
+                return this.clone()._mult(t42);
+              }, div: function(t42) {
+                return this.clone()._div(t42);
+              }, rotate: function(t42) {
+                return this.clone()._rotate(t42);
+              }, rotateAround: function(t42, e22) {
+                return this.clone()._rotateAround(t42, e22);
+              }, matMult: function(t42) {
+                return this.clone()._matMult(t42);
+              }, unit: function() {
+                return this.clone()._unit();
+              }, perp: function() {
+                return this.clone()._perp();
+              }, round: function() {
+                return this.clone()._round();
+              }, mag: function() {
+                return Math.sqrt(this.x * this.x + this.y * this.y);
+              }, equals: function(t42) {
+                return this.x === t42.x && this.y === t42.y;
+              }, dist: function(t42) {
+                return Math.sqrt(this.distSqr(t42));
+              }, distSqr: function(t42) {
+                var e22 = t42.x - this.x, r22 = t42.y - this.y;
+                return e22 * e22 + r22 * r22;
+              }, angle: function() {
+                return Math.atan2(this.y, this.x);
+              }, angleTo: function(t42) {
+                return Math.atan2(this.y - t42.y, this.x - t42.x);
+              }, angleWith: function(t42) {
+                return this.angleWithSep(t42.x, t42.y);
+              }, angleWithSep: function(t42, e22) {
+                return Math.atan2(this.x * e22 - this.y * t42, this.x * t42 + this.y * e22);
+              }, _matMult: function(t42) {
+                var e22 = t42[2] * this.x + t42[3] * this.y;
+                return this.x = t42[0] * this.x + t42[1] * this.y, this.y = e22, this;
+              }, _add: function(t42) {
+                return this.x += t42.x, this.y += t42.y, this;
+              }, _sub: function(t42) {
+                return this.x -= t42.x, this.y -= t42.y, this;
+              }, _mult: function(t42) {
+                return this.x *= t42, this.y *= t42, this;
+              }, _div: function(t42) {
+                return this.x /= t42, this.y /= t42, this;
+              }, _multByPoint: function(t42) {
+                return this.x *= t42.x, this.y *= t42.y, this;
+              }, _divByPoint: function(t42) {
+                return this.x /= t42.x, this.y /= t42.y, this;
+              }, _unit: function() {
+                return this._div(this.mag()), this;
+              }, _perp: function() {
+                var t42 = this.y;
+                return this.y = this.x, this.x = -t42, this;
+              }, _rotate: function(t42) {
+                var e22 = Math.cos(t42), r22 = Math.sin(t42), n22 = r22 * this.x + e22 * this.y;
+                return this.x = e22 * this.x - r22 * this.y, this.y = n22, this;
+              }, _rotateAround: function(t42, e22) {
+                var r22 = Math.cos(t42), n22 = Math.sin(t42), i22 = e22.y + n22 * (this.x - e22.x) + r22 * (this.y - e22.y);
+                return this.x = e22.x + r22 * (this.x - e22.x) - n22 * (this.y - e22.y), this.y = i22, this;
+              }, _round: function() {
+                return this.x = Math.round(this.x), this.y = Math.round(this.y), this;
+              } }, i2.convert = function(t42) {
+                return t42 instanceof i2 ? t42 : Array.isArray(t42) ? new i2(t42[0], t42[1]) : t42;
+              };
+              var s2 = r2(n2), a2 = o2;
+              function o2(t42, e22, r22, n22) {
+                this.cx = 3 * t42, this.bx = 3 * (r22 - t42) - this.cx, this.ax = 1 - this.cx - this.bx, this.cy = 3 * e22, this.by = 3 * (n22 - e22) - this.cy, this.ay = 1 - this.cy - this.by, this.p1x = t42, this.p1y = e22, this.p2x = r22, this.p2y = n22;
+              }
+              o2.prototype = { sampleCurveX: function(t42) {
+                return ((this.ax * t42 + this.bx) * t42 + this.cx) * t42;
+              }, sampleCurveY: function(t42) {
+                return ((this.ay * t42 + this.by) * t42 + this.cy) * t42;
+              }, sampleCurveDerivativeX: function(t42) {
+                return (3 * this.ax * t42 + 2 * this.bx) * t42 + this.cx;
+              }, solveCurveX: function(t42, e22) {
+                if (void 0 === e22 && (e22 = 1e-6), t42 < 0) return 0;
+                if (t42 > 1) return 1;
+                for (var r22 = t42, n22 = 0; n22 < 8; n22++) {
+                  var i22 = this.sampleCurveX(r22) - t42;
+                  if (Math.abs(i22) < e22) return r22;
+                  var s22 = this.sampleCurveDerivativeX(r22);
+                  if (Math.abs(s22) < 1e-6) break;
+                  r22 -= i22 / s22;
+                }
+                var a22 = 0, o22 = 1;
+                for (r22 = t42, n22 = 0; n22 < 20 && (i22 = this.sampleCurveX(r22), !(Math.abs(i22 - t42) < e22)); n22++) t42 > i22 ? a22 = r22 : o22 = r22, r22 = 0.5 * (o22 - a22) + a22;
+                return r22;
+              }, solve: function(t42, e22) {
+                return this.sampleCurveY(this.solveCurveX(t42, e22));
+              } };
+              var l2 = r2(a2);
+              let u2, c2;
+              function h2() {
+                return null == u2 && (u2 = "undefined" != typeof OffscreenCanvas && new OffscreenCanvas(1, 1).getContext("2d") && "function" == typeof createImageBitmap), u2;
+              }
+              function p2() {
+                if (null == c2 && (c2 = false, h2())) {
+                  const t42 = 5, e22 = new OffscreenCanvas(t42, t42).getContext("2d", { willReadFrequently: true });
+                  if (e22) {
+                    for (let r3 = 0; r3 < t42 * t42; r3++) {
+                      const n22 = 4 * r3;
+                      e22.fillStyle = `rgb(${n22},${n22 + 1},${n22 + 2})`, e22.fillRect(r3 % t42, Math.floor(r3 / t42), 1, 1);
+                    }
+                    const r22 = e22.getImageData(0, 0, t42, t42).data;
+                    for (let e3 = 0; e3 < t42 * t42 * 4; e3++) if (e3 % 4 != 3 && r22[e3] !== e3) {
+                      c2 = true;
+                      break;
+                    }
+                  }
+                }
+                return c2 || false;
+              }
+              function f2(t42, e22, r22, n22) {
+                const i22 = new l2(t42, e22, r22, n22);
+                return (t5) => i22.solve(t5);
+              }
+              const d2 = f2(0.25, 0.1, 0.25, 1);
+              function y2(t42, e22, r22) {
+                return Math.min(r22, Math.max(e22, t42));
+              }
+              function m2(t42, e22, r22) {
+                const n22 = r22 - e22, i22 = ((t42 - e22) % n22 + n22) % n22 + e22;
+                return i22 === e22 ? r22 : i22;
+              }
+              function g2(t42, ...e22) {
+                for (const r22 of e22) for (const e3 in r22) t42[e3] = r22[e3];
+                return t42;
+              }
+              let x2 = 1;
+              function v2(t42, e22, r22) {
+                const n22 = {};
+                for (const r3 in t42) n22[r3] = e22.call(this, t42[r3], r3, t42);
+                return n22;
+              }
+              function b2(t42, e22, r22) {
+                const n22 = {};
+                for (const r3 in t42) e22.call(this, t42[r3], r3, t42) && (n22[r3] = t42[r3]);
+                return n22;
+              }
+              function w2(t42) {
+                return Array.isArray(t42) ? t42.map(w2) : "object" == typeof t42 && t42 ? v2(t42, w2) : t42;
+              }
+              const _2 = {};
+              function A22(t42) {
+                _2[t42] || ("undefined" != typeof console && console.warn(t42), _2[t42] = true);
+              }
+              function S2(t42, e22, r22) {
+                return (r22.y - t42.y) * (e22.x - t42.x) > (e22.y - t42.y) * (r22.x - t42.x);
+              }
+              function k2(t42) {
+                return "undefined" != typeof WorkerGlobalScope && void 0 !== t42 && t42 instanceof WorkerGlobalScope;
+              }
+              let M2 = null;
+              function I2(t42) {
+                return "undefined" != typeof ImageBitmap && t42 instanceof ImageBitmap;
+              }
+              const z2 = "data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAYAAAAfFcSJAAAAC0lEQVQYV2NgAAIAAAUAAarVyFEAAAAASUVORK5CYII=";
+              function P2(t42, r22, n22, i22, s22) {
+                return e2(this, void 0, void 0, function* () {
+                  if ("undefined" == typeof VideoFrame) throw new Error("VideoFrame not supported");
+                  const e22 = new VideoFrame(t42, { timestamp: 0 });
+                  try {
+                    const a22 = null == e22 ? void 0 : e22.format;
+                    if (!a22 || !a22.startsWith("BGR") && !a22.startsWith("RGB")) throw new Error(`Unrecognized format ${a22}`);
+                    const o22 = a22.startsWith("BGR"), l22 = new Uint8ClampedArray(i22 * s22 * 4);
+                    if (yield e22.copyTo(l22, function(t5, e3, r3, n3, i3) {
+                      const s3 = 4 * Math.max(-e3, 0), a3 = (Math.max(0, r3) - r3) * n3 * 4 + s3, o3 = 4 * n3, l3 = Math.max(0, e3), u22 = Math.max(0, r3);
+                      return { rect: { x: l3, y: u22, width: Math.min(t5.width, e3 + n3) - l3, height: Math.min(t5.height, r3 + i3) - u22 }, layout: [{ offset: a3, stride: o3 }] };
+                    }(t42, r22, n22, i22, s22)), o22) for (let t5 = 0; t5 < l22.length; t5 += 4) {
+                      const e3 = l22[t5];
+                      l22[t5] = l22[t5 + 2], l22[t5 + 2] = e3;
+                    }
+                    return l22;
+                  } finally {
+                    e22.close();
+                  }
+                });
+              }
+              let C22, B22;
+              const V2 = "AbortError";
+              function E22() {
+                return new Error(V2);
+              }
+              const F2 = { MAX_PARALLEL_IMAGE_REQUESTS: 16, MAX_PARALLEL_IMAGE_REQUESTS_PER_FRAME: 8, MAX_TILE_CACHE_ZOOM_LEVELS: 5, REGISTERED_PROTOCOLS: {}, WORKER_URL: "" };
+              function T2(t42) {
+                return F2.REGISTERED_PROTOCOLS[t42.substring(0, t42.indexOf("://"))];
+              }
+              const $2 = "global-dispatcher";
+              class L2 extends Error {
+                constructor(t42, e22, r22, n22) {
+                  super(`AJAXError: ${e22} (${t42}): ${r22}`), this.status = t42, this.statusText = e22, this.url = r22, this.body = n22;
+                }
+              }
+              const D22 = () => k2(self) ? self.worker && self.worker.referrer : ("blob:" === window.location.protocol ? window.parent : window).location.href, O2 = function(t42, r22) {
+                if (/:\/\//.test(t42.url) && !/^https?:|^file:/.test(t42.url)) {
+                  const e22 = T2(t42.url);
+                  if (e22) return e22(t42, r22);
+                  if (k2(self) && self.worker && self.worker.actor) return self.worker.actor.sendAsync({ type: "GR", data: t42, targetMapId: $2 }, r22);
+                }
+                if (!(/^file:/.test(n22 = t42.url) || /^file:/.test(D22()) && !/^\w+:/.test(n22))) {
+                  if (fetch && Request && AbortController && Object.prototype.hasOwnProperty.call(Request.prototype, "signal")) return function(t5, r3) {
+                    return e2(this, void 0, void 0, function* () {
+                      const e22 = new Request(t5.url, { method: t5.method || "GET", body: t5.body, credentials: t5.credentials, headers: t5.headers, cache: t5.cache, referrer: D22(), signal: r3.signal });
+                      "json" !== t5.type || e22.headers.has("Accept") || e22.headers.set("Accept", "application/json");
+                      const n3 = yield fetch(e22);
+                      if (!n3.ok) {
+                        const e3 = yield n3.blob();
+                        throw new L2(n3.status, n3.statusText, t5.url, e3);
+                      }
+                      let i22;
+                      i22 = "arrayBuffer" === t5.type || "image" === t5.type ? n3.arrayBuffer() : "json" === t5.type ? n3.json() : n3.text();
+                      const s22 = yield i22;
+                      if (r3.signal.aborted) throw E22();
+                      return { data: s22, cacheControl: n3.headers.get("Cache-Control"), expires: n3.headers.get("Expires") };
+                    });
+                  }(t42, r22);
+                  if (k2(self) && self.worker && self.worker.actor) return self.worker.actor.sendAsync({ type: "GR", data: t42, mustQueue: true, targetMapId: $2 }, r22);
+                }
+                var n22;
+                return function(t5, e22) {
+                  return new Promise((r3, n3) => {
+                    var i22;
+                    const s22 = new XMLHttpRequest();
+                    s22.open(t5.method || "GET", t5.url, true), "arrayBuffer" !== t5.type && "image" !== t5.type || (s22.responseType = "arraybuffer");
+                    for (const e3 in t5.headers) s22.setRequestHeader(e3, t5.headers[e3]);
+                    "json" === t5.type && (s22.responseType = "text", (null === (i22 = t5.headers) || void 0 === i22 ? void 0 : i22.Accept) || s22.setRequestHeader("Accept", "application/json")), s22.withCredentials = "include" === t5.credentials, s22.onerror = () => {
+                      n3(new Error(s22.statusText));
+                    }, s22.onload = () => {
+                      if (!e22.signal.aborted) if ((s22.status >= 200 && s22.status < 300 || 0 === s22.status) && null !== s22.response) {
+                        let e3 = s22.response;
+                        if ("json" === t5.type) try {
+                          e3 = JSON.parse(s22.response);
+                        } catch (t6) {
+                          return void n3(t6);
+                        }
+                        r3({ data: e3, cacheControl: s22.getResponseHeader("Cache-Control"), expires: s22.getResponseHeader("Expires") });
+                      } else {
+                        const e3 = new Blob([s22.response], { type: s22.getResponseHeader("Content-Type") });
+                        n3(new L2(s22.status, s22.statusText, t5.url, e3));
+                      }
+                    }, e22.signal.addEventListener("abort", () => {
+                      s22.abort(), n3(E22());
+                    }), s22.send(t5.body);
+                  });
+                }(t42, r22);
+              };
+              function j2(t42) {
+                if (!t42 || t42.indexOf("://") <= 0 || 0 === t42.indexOf("data:image/") || 0 === t42.indexOf("blob:")) return true;
+                const e22 = new URL(t42), r22 = window.location;
+                return e22.protocol === r22.protocol && e22.host === r22.host;
+              }
+              function R2(t42, e22, r22) {
+                r22[t42] && -1 !== r22[t42].indexOf(e22) || (r22[t42] = r22[t42] || [], r22[t42].push(e22));
+              }
+              function U2(t42, e22, r22) {
+                if (r22 && r22[t42]) {
+                  const n22 = r22[t42].indexOf(e22);
+                  -1 !== n22 && r22[t42].splice(n22, 1);
+                }
+              }
+              class q2 {
+                constructor(t42, e22 = {}) {
+                  g2(this, e22), this.type = t42;
+                }
+              }
+              class N2 extends q2 {
+                constructor(t42, e22 = {}) {
+                  super("error", g2({ error: t42 }, e22));
+                }
+              }
+              class Z2 {
+                on(t42, e22) {
+                  return this._listeners = this._listeners || {}, R2(t42, e22, this._listeners), this;
+                }
+                off(t42, e22) {
+                  return U2(t42, e22, this._listeners), U2(t42, e22, this._oneTimeListeners), this;
+                }
+                once(t42, e22) {
+                  return e22 ? (this._oneTimeListeners = this._oneTimeListeners || {}, R2(t42, e22, this._oneTimeListeners), this) : new Promise((e3) => this.once(t42, e3));
+                }
+                fire(t42, e22) {
+                  "string" == typeof t42 && (t42 = new q2(t42, e22 || {}));
+                  const r22 = t42.type;
+                  if (this.listens(r22)) {
+                    t42.target = this;
+                    const e3 = this._listeners && this._listeners[r22] ? this._listeners[r22].slice() : [];
+                    for (const r3 of e3) r3.call(this, t42);
+                    const n22 = this._oneTimeListeners && this._oneTimeListeners[r22] ? this._oneTimeListeners[r22].slice() : [];
+                    for (const e4 of n22) U2(r22, e4, this._oneTimeListeners), e4.call(this, t42);
+                    const i22 = this._eventedParent;
+                    i22 && (g2(t42, "function" == typeof this._eventedParentData ? this._eventedParentData() : this._eventedParentData), i22.fire(t42));
+                  } else t42 instanceof N2 && console.error(t42.error);
+                  return this;
+                }
+                listens(t42) {
+                  return this._listeners && this._listeners[t42] && this._listeners[t42].length > 0 || this._oneTimeListeners && this._oneTimeListeners[t42] && this._oneTimeListeners[t42].length > 0 || this._eventedParent && this._eventedParent.listens(t42);
+                }
+                setEventedParent(t42, e22) {
+                  return this._eventedParent = t42, this._eventedParentData = e22, this;
+                }
+              }
+              var G2 = { $version: 8, $root: { version: { required: true, type: "enum", values: [8] }, name: { type: "string" }, metadata: { type: "*" }, center: { type: "array", value: "number" }, zoom: { type: "number" }, bearing: { type: "number", default: 0, period: 360, units: "degrees" }, pitch: { type: "number", default: 0, units: "degrees" }, light: { type: "light" }, sky: { type: "sky" }, projection: { type: "projection" }, terrain: { type: "terrain" }, sources: { required: true, type: "sources" }, sprite: { type: "sprite" }, glyphs: { type: "string" }, transition: { type: "transition" }, layers: { required: true, type: "array", value: "layer" } }, sources: { "*": { type: "source" } }, source: ["source_vector", "source_raster", "source_raster_dem", "source_geojson", "source_video", "source_image"], source_vector: { type: { required: true, type: "enum", values: { vector: {} } }, url: { type: "string" }, tiles: { type: "array", value: "string" }, bounds: { type: "array", value: "number", length: 4, default: [-180, -85.051129, 180, 85.051129] }, scheme: { type: "enum", values: { xyz: {}, tms: {} }, default: "xyz" }, minzoom: { type: "number", default: 0 }, maxzoom: { type: "number", default: 22 }, attribution: { type: "string" }, promoteId: { type: "promoteId" }, volatile: { type: "boolean", default: false }, "*": { type: "*" } }, source_raster: { type: { required: true, type: "enum", values: { raster: {} } }, url: { type: "string" }, tiles: { type: "array", value: "string" }, bounds: { type: "array", value: "number", length: 4, default: [-180, -85.051129, 180, 85.051129] }, minzoom: { type: "number", default: 0 }, maxzoom: { type: "number", default: 22 }, tileSize: { type: "number", default: 512, units: "pixels" }, scheme: { type: "enum", values: { xyz: {}, tms: {} }, default: "xyz" }, attribution: { type: "string" }, volatile: { type: "boolean", default: false }, "*": { type: "*" } }, source_raster_dem: { type: { required: true, type: "enum", values: { "raster-dem": {} } }, url: { type: "string" }, tiles: { type: "array", value: "string" }, bounds: { type: "array", value: "number", length: 4, default: [-180, -85.051129, 180, 85.051129] }, minzoom: { type: "number", default: 0 }, maxzoom: { type: "number", default: 22 }, tileSize: { type: "number", default: 512, units: "pixels" }, attribution: { type: "string" }, encoding: { type: "enum", values: { terrarium: {}, mapbox: {}, custom: {} }, default: "mapbox" }, redFactor: { type: "number", default: 1 }, blueFactor: { type: "number", default: 1 }, greenFactor: { type: "number", default: 1 }, baseShift: { type: "number", default: 0 }, volatile: { type: "boolean", default: false }, "*": { type: "*" } }, source_geojson: { type: { required: true, type: "enum", values: { geojson: {} } }, data: { required: true, type: "*" }, maxzoom: { type: "number", default: 18 }, attribution: { type: "string" }, buffer: { type: "number", default: 128, maximum: 512, minimum: 0 }, filter: { type: "*" }, tolerance: { type: "number", default: 0.375 }, cluster: { type: "boolean", default: false }, clusterRadius: { type: "number", default: 50, minimum: 0 }, clusterMaxZoom: { type: "number" }, clusterMinPoints: { type: "number" }, clusterProperties: { type: "*" }, lineMetrics: { type: "boolean", default: false }, generateId: { type: "boolean", default: false }, promoteId: { type: "promoteId" } }, source_video: { type: { required: true, type: "enum", values: { video: {} } }, urls: { required: true, type: "array", value: "string" }, coordinates: { required: true, type: "array", length: 4, value: { type: "array", length: 2, value: "number" } } }, source_image: { type: { required: true, type: "enum", values: { image: {} } }, url: { required: true, type: "string" }, coordinates: { required: true, type: "array", length: 4, value: { type: "array", length: 2, value: "number" } } }, layer: { id: { type: "string", required: true }, type: { type: "enum", values: { fill: {}, line: {}, symbol: {}, circle: {}, heatmap: {}, "fill-extrusion": {}, raster: {}, hillshade: {}, background: {} }, required: true }, metadata: { type: "*" }, source: { type: "string" }, "source-layer": { type: "string" }, minzoom: { type: "number", minimum: 0, maximum: 24 }, maxzoom: { type: "number", minimum: 0, maximum: 24 }, filter: { type: "filter" }, layout: { type: "layout" }, paint: { type: "paint" } }, layout: ["layout_fill", "layout_line", "layout_circle", "layout_heatmap", "layout_fill-extrusion", "layout_symbol", "layout_raster", "layout_hillshade", "layout_background"], layout_background: { visibility: { type: "enum", values: { visible: {}, none: {} }, default: "visible", "property-type": "constant" } }, layout_fill: { "fill-sort-key": { type: "number", expression: { interpolated: false, parameters: ["zoom", "feature"] }, "property-type": "data-driven" }, visibility: { type: "enum", values: { visible: {}, none: {} }, default: "visible", "property-type": "constant" } }, layout_circle: { "circle-sort-key": { type: "number", expression: { interpolated: false, parameters: ["zoom", "feature"] }, "property-type": "data-driven" }, visibility: { type: "enum", values: { visible: {}, none: {} }, default: "visible", "property-type": "constant" } }, layout_heatmap: { visibility: { type: "enum", values: { visible: {}, none: {} }, default: "visible", "property-type": "constant" } }, "layout_fill-extrusion": { visibility: { type: "enum", values: { visible: {}, none: {} }, default: "visible", "property-type": "constant" } }, layout_line: { "line-cap": { type: "enum", values: { butt: {}, round: {}, square: {} }, default: "butt", expression: { interpolated: false, parameters: ["zoom"] }, "property-type": "data-constant" }, "line-join": { type: "enum", values: { bevel: {}, round: {}, miter: {} }, default: "miter", expression: { interpolated: false, parameters: ["zoom", "feature"] }, "property-type": "data-driven" }, "line-miter-limit": { type: "number", default: 2, requires: [{ "line-join": "miter" }], expression: { interpolated: true, parameters: ["zoom"] }, "property-type": "data-constant" }, "line-round-limit": { type: "number", default: 1.05, requires: [{ "line-join": "round" }], expression: { interpolated: true, parameters: ["zoom"] }, "property-type": "data-constant" }, "line-sort-key": { type: "number", expression: { interpolated: false, parameters: ["zoom", "feature"] }, "property-type": "data-driven" }, visibility: { type: "enum", values: { visible: {}, none: {} }, default: "visible", "property-type": "constant" } }, layout_symbol: { "symbol-placement": { type: "enum", values: { point: {}, line: {}, "line-center": {} }, default: "point", expression: { interpolated: false, parameters: ["zoom"] }, "property-type": "data-constant" }, "symbol-spacing": { type: "number", default: 250, minimum: 1, units: "pixels", requires: [{ "symbol-placement": "line" }], expression: { interpolated: true, parameters: ["zoom"] }, "property-type": "data-constant" }, "symbol-avoid-edges": { type: "boolean", default: false, expression: { interpolated: false, parameters: ["zoom"] }, "property-type": "data-constant" }, "symbol-sort-key": { type: "number", expression: { interpolated: false, parameters: ["zoom", "feature"] }, "property-type": "data-driven" }, "symbol-z-order": { type: "enum", values: { auto: {}, "viewport-y": {}, source: {} }, default: "auto", expression: { interpolated: false, parameters: ["zoom"] }, "property-type": "data-constant" }, "icon-allow-overlap": { type: "boolean", default: false, requires: ["icon-image", { "!": "icon-overlap" }], expression: { interpolated: false, parameters: ["zoom"] }, "property-type": "data-constant" }, "icon-overlap": { type: "enum", values: { never: {}, always: {}, cooperative: {} }, requires: ["icon-image"], expression: { interpolated: false, parameters: ["zoom"] }, "property-type": "data-constant" }, "icon-ignore-placement": { type: "boolean", default: false, requires: ["icon-image"], expression: { interpolated: false, parameters: ["zoom"] }, "property-type": "data-constant" }, "icon-optional": { type: "boolean", default: false, requires: ["icon-image", "text-field"], expression: { interpolated: false, parameters: ["zoom"] }, "property-type": "data-constant" }, "icon-rotation-alignment": { type: "enum", values: { map: {}, viewport: {}, auto: {} }, default: "auto", requires: ["icon-image"], expression: { interpolated: false, parameters: ["zoom"] }, "property-type": "data-constant" }, "icon-size": { type: "number", default: 1, minimum: 0, units: "factor of the original icon size", requires: ["icon-image"], expression: { interpolated: true, parameters: ["zoom", "feature"] }, "property-type": "data-driven" }, "icon-text-fit": { type: "enum", values: { none: {}, width: {}, height: {}, both: {} }, default: "none", requires: ["icon-image", "text-field"], expression: { interpolated: false, parameters: ["zoom"] }, "property-type": "data-constant" }, "icon-text-fit-padding": { type: "array", value: "number", length: 4, default: [0, 0, 0, 0], units: "pixels", requires: ["icon-image", "text-field", { "icon-text-fit": ["both", "width", "height"] }], expression: { interpolated: true, parameters: ["zoom"] }, "property-type": "data-constant" }, "icon-image": { type: "resolvedImage", tokens: true, expression: { interpolated: false, parameters: ["zoom", "feature"] }, "property-type": "data-driven" }, "icon-rotate": { type: "number", default: 0, period: 360, units: "degrees", requires: ["icon-image"], expression: { interpolated: true, parameters: ["zoom", "feature"] }, "property-type": "data-driven" }, "icon-padding": { type: "padding", default: [2], units: "pixels", requires: ["icon-image"], expression: { interpolated: true, parameters: ["zoom", "feature"] }, "property-type": "data-driven" }, "icon-keep-upright": { type: "boolean", default: false, requires: ["icon-image", { "icon-rotation-alignment": "map" }, { "symbol-placement": ["line", "line-center"] }], expression: { interpolated: false, parameters: ["zoom"] }, "property-type": "data-constant" }, "icon-offset": { type: "array", value: "number", length: 2, default: [0, 0], requires: ["icon-image"], expression: { interpolated: true, parameters: ["zoom", "feature"] }, "property-type": "data-driven" }, "icon-anchor": { type: "enum", values: { center: {}, left: {}, right: {}, top: {}, bottom: {}, "top-left": {}, "top-right": {}, "bottom-left": {}, "bottom-right": {} }, default: "center", requires: ["icon-image"], expression: { interpolated: false, parameters: ["zoom", "feature"] }, "property-type": "data-driven" }, "icon-pitch-alignment": { type: "enum", values: { map: {}, viewport: {}, auto: {} }, default: "auto", requires: ["icon-image"], expression: { interpolated: false, parameters: ["zoom"] }, "property-type": "data-constant" }, "text-pitch-alignment": { type: "enum", values: { map: {}, viewport: {}, auto: {} }, default: "auto", requires: ["text-field"], expression: { interpolated: false, parameters: ["zoom"] }, "property-type": "data-constant" }, "text-rotation-alignment": { type: "enum", values: { map: {}, viewport: {}, "viewport-glyph": {}, auto: {} }, default: "auto", requires: ["text-field"], expression: { interpolated: false, parameters: ["zoom"] }, "property-type": "data-constant" }, "text-field": { type: "formatted", default: "", tokens: true, expression: { interpolated: false, parameters: ["zoom", "feature"] }, "property-type": "data-driven" }, "text-font": { type: "array", value: "string", default: ["Open Sans Regular", "Arial Unicode MS Regular"], requires: ["text-field"], expression: { interpolated: false, parameters: ["zoom", "feature"] }, "property-type": "data-driven" }, "text-size": { type: "number", default: 16, minimum: 0, units: "pixels", requires: ["text-field"], expression: { interpolated: true, parameters: ["zoom", "feature"] }, "property-type": "data-driven" }, "text-max-width": { type: "number", default: 10, minimum: 0, units: "ems", requires: ["text-field"], expression: { interpolated: true, parameters: ["zoom", "feature"] }, "property-type": "data-driven" }, "text-line-height": { type: "number", default: 1.2, units: "ems", requires: ["text-field"], expression: { interpolated: true, parameters: ["zoom"] }, "property-type": "data-constant" }, "text-letter-spacing": { type: "number", default: 0, units: "ems", requires: ["text-field"], expression: { interpolated: true, parameters: ["zoom", "feature"] }, "property-type": "data-driven" }, "text-justify": { type: "enum", values: { auto: {}, left: {}, center: {}, right: {} }, default: "center", requires: ["text-field"], expression: { interpolated: false, parameters: ["zoom", "feature"] }, "property-type": "data-driven" }, "text-radial-offset": { type: "number", units: "ems", default: 0, requires: ["text-field"], "property-type": "data-driven", expression: { interpolated: true, parameters: ["zoom", "feature"] } }, "text-variable-anchor": { type: "array", value: "enum", values: { center: {}, left: {}, right: {}, top: {}, bottom: {}, "top-left": {}, "top-right": {}, "bottom-left": {}, "bottom-right": {} }, requires: ["text-field", { "symbol-placement": ["point"] }], expression: { interpolated: false, parameters: ["zoom"] }, "property-type": "data-constant" }, "text-variable-anchor-offset": { type: "variableAnchorOffsetCollection", requires: ["text-field", { "symbol-placement": ["point"] }], expression: { interpolated: true, parameters: ["zoom", "feature"] }, "property-type": "data-driven" }, "text-anchor": { type: "enum", values: { center: {}, left: {}, right: {}, top: {}, bottom: {}, "top-left": {}, "top-right": {}, "bottom-left": {}, "bottom-right": {} }, default: "center", requires: ["text-field", { "!": "text-variable-anchor" }], expression: { interpolated: false, parameters: ["zoom", "feature"] }, "property-type": "data-driven" }, "text-max-angle": { type: "number", default: 45, units: "degrees", requires: ["text-field", { "symbol-placement": ["line", "line-center"] }], expression: { interpolated: true, parameters: ["zoom"] }, "property-type": "data-constant" }, "text-writing-mode": { type: "array", value: "enum", values: { horizontal: {}, vertical: {} }, requires: ["text-field", { "symbol-placement": ["point"] }], expression: { interpolated: false, parameters: ["zoom"] }, "property-type": "data-constant" }, "text-rotate": { type: "number", default: 0, period: 360, units: "degrees", requires: ["text-field"], expression: { interpolated: true, parameters: ["zoom", "feature"] }, "property-type": "data-driven" }, "text-padding": { type: "number", default: 2, minimum: 0, units: "pixels", requires: ["text-field"], expression: { interpolated: true, parameters: ["zoom"] }, "property-type": "data-constant" }, "text-keep-upright": { type: "boolean", default: true, requires: ["text-field", { "text-rotation-alignment": "map" }, { "symbol-placement": ["line", "line-center"] }], expression: { interpolated: false, parameters: ["zoom"] }, "property-type": "data-constant" }, "text-transform": { type: "enum", values: { none: {}, uppercase: {}, lowercase: {} }, default: "none", requires: ["text-field"], expression: { interpolated: false, parameters: ["zoom", "feature"] }, "property-type": "data-driven" }, "text-offset": { type: "array", value: "number", units: "ems", length: 2, default: [0, 0], requires: ["text-field", { "!": "text-radial-offset" }], expression: { interpolated: true, parameters: ["zoom", "feature"] }, "property-type": "data-driven" }, "text-allow-overlap": { type: "boolean", default: false, requires: ["text-field", { "!": "text-overlap" }], expression: { interpolated: false, parameters: ["zoom"] }, "property-type": "data-constant" }, "text-overlap": { type: "enum", values: { never: {}, always: {}, cooperative: {} }, requires: ["text-field"], expression: { interpolated: false, parameters: ["zoom"] }, "property-type": "data-constant" }, "text-ignore-placement": { type: "boolean", default: false, requires: ["text-field"], expression: { interpolated: false, parameters: ["zoom"] }, "property-type": "data-constant" }, "text-optional": { type: "boolean", default: false, requires: ["text-field", "icon-image"], expression: { interpolated: false, parameters: ["zoom"] }, "property-type": "data-constant" }, visibility: { type: "enum", values: { visible: {}, none: {} }, default: "visible", "property-type": "constant" } }, layout_raster: { visibility: { type: "enum", values: { visible: {}, none: {} }, default: "visible", "property-type": "constant" } }, layout_hillshade: { visibility: { type: "enum", values: { visible: {}, none: {} }, default: "visible", "property-type": "constant" } }, filter: { type: "array", value: "*" }, filter_operator: { type: "enum", values: { "==": {}, "!=": {}, ">": {}, ">=": {}, "<": {}, "<=": {}, in: {}, "!in": {}, all: {}, any: {}, none: {}, has: {}, "!has": {} } }, geometry_type: { type: "enum", values: { Point: {}, LineString: {}, Polygon: {} } }, function: { expression: { type: "expression" }, stops: { type: "array", value: "function_stop" }, base: { type: "number", default: 1, minimum: 0 }, property: { type: "string", default: "$zoom" }, type: { type: "enum", values: { identity: {}, exponential: {}, interval: {}, categorical: {} }, default: "exponential" }, colorSpace: { type: "enum", values: { rgb: {}, lab: {}, hcl: {} }, default: "rgb" }, default: { type: "*", required: false } }, function_stop: { type: "array", minimum: 0, maximum: 24, value: ["number", "color"], length: 2 }, expression: { type: "array", value: "*", minimum: 1 }, light: { anchor: { type: "enum", default: "viewport", values: { map: {}, viewport: {} }, "property-type": "data-constant", transition: false, expression: { interpolated: false, parameters: ["zoom"] } }, position: { type: "array", default: [1.15, 210, 30], length: 3, value: "number", "property-type": "data-constant", transition: true, expression: { interpolated: true, parameters: ["zoom"] } }, color: { type: "color", "property-type": "data-constant", default: "#ffffff", expression: { interpolated: true, parameters: ["zoom"] }, transition: true }, intensity: { type: "number", "property-type": "data-constant", default: 0.5, minimum: 0, maximum: 1, expression: { interpolated: true, parameters: ["zoom"] }, transition: true } }, sky: { "sky-color": { type: "color", "property-type": "data-constant", default: "#88C6FC", expression: { interpolated: true, parameters: ["zoom"] }, transition: true }, "horizon-color": { type: "color", "property-type": "data-constant", default: "#ffffff", expression: { interpolated: true, parameters: ["zoom"] }, transition: true }, "fog-color": { type: "color", "property-type": "data-constant", default: "#ffffff", expression: { interpolated: true, parameters: ["zoom"] }, transition: true }, "fog-ground-blend": { type: "number", "property-type": "data-constant", default: 0.5, minimum: 0, maximum: 1, expression: { interpolated: true, parameters: ["zoom"] }, transition: true }, "horizon-fog-blend": { type: "number", "property-type": "data-constant", default: 0.8, minimum: 0, maximum: 1, expression: { interpolated: true, parameters: ["zoom"] }, transition: true }, "sky-horizon-blend": { type: "number", "property-type": "data-constant", default: 0.8, minimum: 0, maximum: 1, expression: { interpolated: true, parameters: ["zoom"] }, transition: true }, "atmosphere-blend": { type: "number", "property-type": "data-constant", default: 0.8, minimum: 0, maximum: 1, expression: { interpolated: true, parameters: ["zoom"] }, transition: true } }, terrain: { source: { type: "string", required: true }, exaggeration: { type: "number", minimum: 0, default: 1 } }, projection: { type: { type: "enum", default: "mercator", values: { mercator: {}, globe: {} } } }, paint: ["paint_fill", "paint_line", "paint_circle", "paint_heatmap", "paint_fill-extrusion", "paint_symbol", "paint_raster", "paint_hillshade", "paint_background"], paint_fill: { "fill-antialias": { type: "boolean", default: true, expression: { interpolated: false, parameters: ["zoom"] }, "property-type": "data-constant" }, "fill-opacity": { type: "number", default: 1, minimum: 0, maximum: 1, transition: true, expression: { interpolated: true, parameters: ["zoom", "feature", "feature-state"] }, "property-type": "data-driven" }, "fill-color": { type: "color", default: "#000000", transition: true, requires: [{ "!": "fill-pattern" }], expression: { interpolated: true, parameters: ["zoom", "feature", "feature-state"] }, "property-type": "data-driven" }, "fill-outline-color": { type: "color", transition: true, requires: [{ "!": "fill-pattern" }, { "fill-antialias": true }], expression: { interpolated: true, parameters: ["zoom", "feature", "feature-state"] }, "property-type": "data-driven" }, "fill-translate": { type: "array", value: "number", length: 2, default: [0, 0], transition: true, units: "pixels", expression: { interpolated: true, parameters: ["zoom"] }, "property-type": "data-constant" }, "fill-translate-anchor": { type: "enum", values: { map: {}, viewport: {} }, default: "map", requires: ["fill-translate"], expression: { interpolated: false, parameters: ["zoom"] }, "property-type": "data-constant" }, "fill-pattern": { type: "resolvedImage", transition: true, expression: { interpolated: false, parameters: ["zoom", "feature"] }, "property-type": "cross-faded-data-driven" } }, "paint_fill-extrusion": { "fill-extrusion-opacity": { type: "number", default: 1, minimum: 0, maximum: 1, transition: true, expression: { interpolated: true, parameters: ["zoom"] }, "property-type": "data-constant" }, "fill-extrusion-color": { type: "color", default: "#000000", transition: true, requires: [{ "!": "fill-extrusion-pattern" }], expression: { interpolated: true, parameters: ["zoom", "feature", "feature-state"] }, "property-type": "data-driven" }, "fill-extrusion-translate": { type: "array", value: "number", length: 2, default: [0, 0], transition: true, units: "pixels", expression: { interpolated: true, parameters: ["zoom"] }, "property-type": "data-constant" }, "fill-extrusion-translate-anchor": { type: "enum", values: { map: {}, viewport: {} }, default: "map", requires: ["fill-extrusion-translate"], expression: { interpolated: false, parameters: ["zoom"] }, "property-type": "data-constant" }, "fill-extrusion-pattern": { type: "resolvedImage", transition: true, expression: { interpolated: false, parameters: ["zoom", "feature"] }, "property-type": "cross-faded-data-driven" }, "fill-extrusion-height": { type: "number", default: 0, minimum: 0, units: "meters", transition: true, expression: { interpolated: true, parameters: ["zoom", "feature", "feature-state"] }, "property-type": "data-driven" }, "fill-extrusion-base": { type: "number", default: 0, minimum: 0, units: "meters", transition: true, requires: ["fill-extrusion-height"], expression: { interpolated: true, parameters: ["zoom", "feature", "feature-state"] }, "property-type": "data-driven" }, "fill-extrusion-vertical-gradient": { type: "boolean", default: true, transition: false, expression: { interpolated: false, parameters: ["zoom"] }, "property-type": "data-constant" } }, paint_line: { "line-opacity": { type: "number", default: 1, minimum: 0, maximum: 1, transition: true, expression: { interpolated: true, parameters: ["zoom", "feature", "feature-state"] }, "property-type": "data-driven" }, "line-color": { type: "color", default: "#000000", transition: true, requires: [{ "!": "line-pattern" }], expression: { interpolated: true, parameters: ["zoom", "feature", "feature-state"] }, "property-type": "data-driven" }, "line-translate": { type: "array", value: "number", length: 2, default: [0, 0], transition: true, units: "pixels", expression: { interpolated: true, parameters: ["zoom"] }, "property-type": "data-constant" }, "line-translate-anchor": { type: "enum", values: { map: {}, viewport: {} }, default: "map", requires: ["line-translate"], expression: { interpolated: false, parameters: ["zoom"] }, "property-type": "data-constant" }, "line-width": { type: "number", default: 1, minimum: 0, transition: true, units: "pixels", expression: { interpolated: true, parameters: ["zoom", "feature", "feature-state"] }, "property-type": "data-driven" }, "line-gap-width": { type: "number", default: 0, minimum: 0, transition: true, units: "pixels", expression: { interpolated: true, parameters: ["zoom", "feature", "feature-state"] }, "property-type": "data-driven" }, "line-offset": { type: "number", default: 0, transition: true, units: "pixels", expression: { interpolated: true, parameters: ["zoom", "feature", "feature-state"] }, "property-type": "data-driven" }, "line-blur": { type: "number", default: 0, minimum: 0, transition: true, units: "pixels", expression: { interpolated: true, parameters: ["zoom", "feature", "feature-state"] }, "property-type": "data-driven" }, "line-dasharray": { type: "array", value: "number", minimum: 0, transition: true, units: "line widths", requires: [{ "!": "line-pattern" }], expression: { interpolated: false, parameters: ["zoom"] }, "property-type": "cross-faded" }, "line-pattern": { type: "resolvedImage", transition: true, expression: { interpolated: false, parameters: ["zoom", "feature"] }, "property-type": "cross-faded-data-driven" }, "line-gradient": { type: "color", transition: false, requires: [{ "!": "line-dasharray" }, { "!": "line-pattern" }, { source: "geojson", has: { lineMetrics: true } }], expression: { interpolated: true, parameters: ["line-progress"] }, "property-type": "color-ramp" } }, paint_circle: { "circle-radius": { type: "number", default: 5, minimum: 0, transition: true, units: "pixels", expression: { interpolated: true, parameters: ["zoom", "feature", "feature-state"] }, "property-type": "data-driven" }, "circle-color": { type: "color", default: "#000000", transition: true, expression: { interpolated: true, parameters: ["zoom", "feature", "feature-state"] }, "property-type": "data-driven" }, "circle-blur": { type: "number", default: 0, transition: true, expression: { interpolated: true, parameters: ["zoom", "feature", "feature-state"] }, "property-type": "data-driven" }, "circle-opacity": { type: "number", default: 1, minimum: 0, maximum: 1, transition: true, expression: { interpolated: true, parameters: ["zoom", "feature", "feature-state"] }, "property-type": "data-driven" }, "circle-translate": { type: "array", value: "number", length: 2, default: [0, 0], transition: true, units: "pixels", expression: { interpolated: true, parameters: ["zoom"] }, "property-type": "data-constant" }, "circle-translate-anchor": { type: "enum", values: { map: {}, viewport: {} }, default: "map", requires: ["circle-translate"], expression: { interpolated: false, parameters: ["zoom"] }, "property-type": "data-constant" }, "circle-pitch-scale": { type: "enum", values: { map: {}, viewport: {} }, default: "map", expression: { interpolated: false, parameters: ["zoom"] }, "property-type": "data-constant" }, "circle-pitch-alignment": { type: "enum", values: { map: {}, viewport: {} }, default: "viewport", expression: { interpolated: false, parameters: ["zoom"] }, "property-type": "data-constant" }, "circle-stroke-width": { type: "number", default: 0, minimum: 0, transition: true, units: "pixels", expression: { interpolated: true, parameters: ["zoom", "feature", "feature-state"] }, "property-type": "data-driven" }, "circle-stroke-color": { type: "color", default: "#000000", transition: true, expression: { interpolated: true, parameters: ["zoom", "feature", "feature-state"] }, "property-type": "data-driven" }, "circle-stroke-opacity": { type: "number", default: 1, minimum: 0, maximum: 1, transition: true, expression: { interpolated: true, parameters: ["zoom", "feature", "feature-state"] }, "property-type": "data-driven" } }, paint_heatmap: { "heatmap-radius": { type: "number", default: 30, minimum: 1, transition: true, units: "pixels", expression: { interpolated: true, parameters: ["zoom", "feature", "feature-state"] }, "property-type": "data-driven" }, "heatmap-weight": { type: "number", default: 1, minimum: 0, transition: false, expression: { interpolated: true, parameters: ["zoom", "feature", "feature-state"] }, "property-type": "data-driven" }, "heatmap-intensity": { type: "number", default: 1, minimum: 0, transition: true, expression: { interpolated: true, parameters: ["zoom"] }, "property-type": "data-constant" }, "heatmap-color": { type: "color", default: ["interpolate", ["linear"], ["heatmap-density"], 0, "rgba(0, 0, 255, 0)", 0.1, "royalblue", 0.3, "cyan", 0.5, "lime", 0.7, "yellow", 1, "red"], transition: false, expression: { interpolated: true, parameters: ["heatmap-density"] }, "property-type": "color-ramp" }, "heatmap-opacity": { type: "number", default: 1, minimum: 0, maximum: 1, transition: true, expression: { interpolated: true, parameters: ["zoom"] }, "property-type": "data-constant" } }, paint_symbol: { "icon-opacity": { type: "number", default: 1, minimum: 0, maximum: 1, transition: true, requires: ["icon-image"], expression: { interpolated: true, parameters: ["zoom", "feature", "feature-state"] }, "property-type": "data-driven" }, "icon-color": { type: "color", default: "#000000", transition: true, requires: ["icon-image"], expression: { interpolated: true, parameters: ["zoom", "feature", "feature-state"] }, "property-type": "data-driven" }, "icon-halo-color": { type: "color", default: "rgba(0, 0, 0, 0)", transition: true, requires: ["icon-image"], expression: { interpolated: true, parameters: ["zoom", "feature", "feature-state"] }, "property-type": "data-driven" }, "icon-halo-width": { type: "number", default: 0, minimum: 0, transition: true, units: "pixels", requires: ["icon-image"], expression: { interpolated: true, parameters: ["zoom", "feature", "feature-state"] }, "property-type": "data-driven" }, "icon-halo-blur": { type: "number", default: 0, minimum: 0, transition: true, units: "pixels", requires: ["icon-image"], expression: { interpolated: true, parameters: ["zoom", "feature", "feature-state"] }, "property-type": "data-driven" }, "icon-translate": { type: "array", value: "number", length: 2, default: [0, 0], transition: true, units: "pixels", requires: ["icon-image"], expression: { interpolated: true, parameters: ["zoom"] }, "property-type": "data-constant" }, "icon-translate-anchor": { type: "enum", values: { map: {}, viewport: {} }, default: "map", requires: ["icon-image", "icon-translate"], expression: { interpolated: false, parameters: ["zoom"] }, "property-type": "data-constant" }, "text-opacity": { type: "number", default: 1, minimum: 0, maximum: 1, transition: true, requires: ["text-field"], expression: { interpolated: true, parameters: ["zoom", "feature", "feature-state"] }, "property-type": "data-driven" }, "text-color": { type: "color", default: "#000000", transition: true, overridable: true, requires: ["text-field"], expression: { interpolated: true, parameters: ["zoom", "feature", "feature-state"] }, "property-type": "data-driven" }, "text-halo-color": { type: "color", default: "rgba(0, 0, 0, 0)", transition: true, requires: ["text-field"], expression: { interpolated: true, parameters: ["zoom", "feature", "feature-state"] }, "property-type": "data-driven" }, "text-halo-width": { type: "number", default: 0, minimum: 0, transition: true, units: "pixels", requires: ["text-field"], expression: { interpolated: true, parameters: ["zoom", "feature", "feature-state"] }, "property-type": "data-driven" }, "text-halo-blur": { type: "number", default: 0, minimum: 0, transition: true, units: "pixels", requires: ["text-field"], expression: { interpolated: true, parameters: ["zoom", "feature", "feature-state"] }, "property-type": "data-driven" }, "text-translate": { type: "array", value: "number", length: 2, default: [0, 0], transition: true, units: "pixels", requires: ["text-field"], expression: { interpolated: true, parameters: ["zoom"] }, "property-type": "data-constant" }, "text-translate-anchor": { type: "enum", values: { map: {}, viewport: {} }, default: "map", requires: ["text-field", "text-translate"], expression: { interpolated: false, parameters: ["zoom"] }, "property-type": "data-constant" } }, paint_raster: { "raster-opacity": { type: "number", default: 1, minimum: 0, maximum: 1, transition: true, expression: { interpolated: true, parameters: ["zoom"] }, "property-type": "data-constant" }, "raster-hue-rotate": { type: "number", default: 0, period: 360, transition: true, units: "degrees", expression: { interpolated: true, parameters: ["zoom"] }, "property-type": "data-constant" }, "raster-brightness-min": { type: "number", default: 0, minimum: 0, maximum: 1, transition: true, expression: { interpolated: true, parameters: ["zoom"] }, "property-type": "data-constant" }, "raster-brightness-max": { type: "number", default: 1, minimum: 0, maximum: 1, transition: true, expression: { interpolated: true, parameters: ["zoom"] }, "property-type": "data-constant" }, "raster-saturation": { type: "number", default: 0, minimum: -1, maximum: 1, transition: true, expression: { interpolated: true, parameters: ["zoom"] }, "property-type": "data-constant" }, "raster-contrast": { type: "number", default: 0, minimum: -1, maximum: 1, transition: true, expression: { interpolated: true, parameters: ["zoom"] }, "property-type": "data-constant" }, "raster-resampling": { type: "enum", values: { linear: {}, nearest: {} }, default: "linear", expression: { interpolated: false, parameters: ["zoom"] }, "property-type": "data-constant" }, "raster-fade-duration": { type: "number", default: 300, minimum: 0, transition: false, units: "milliseconds", expression: { interpolated: true, parameters: ["zoom"] }, "property-type": "data-constant" } }, paint_hillshade: { "hillshade-illumination-direction": { type: "number", default: 335, minimum: 0, maximum: 359, transition: false, expression: { interpolated: true, parameters: ["zoom"] }, "property-type": "data-constant" }, "hillshade-illumination-anchor": { type: "enum", values: { map: {}, viewport: {} }, default: "viewport", expression: { interpolated: false, parameters: ["zoom"] }, "property-type": "data-constant" }, "hillshade-exaggeration": { type: "number", default: 0.5, minimum: 0, maximum: 1, transition: true, expression: { interpolated: true, parameters: ["zoom"] }, "property-type": "data-constant" }, "hillshade-shadow-color": { type: "color", default: "#000000", transition: true, expression: { interpolated: true, parameters: ["zoom"] }, "property-type": "data-constant" }, "hillshade-highlight-color": { type: "color", default: "#FFFFFF", transition: true, expression: { interpolated: true, parameters: ["zoom"] }, "property-type": "data-constant" }, "hillshade-accent-color": { type: "color", default: "#000000", transition: true, expression: { interpolated: true, parameters: ["zoom"] }, "property-type": "data-constant" } }, paint_background: { "background-color": { type: "color", default: "#000000", transition: true, requires: [{ "!": "background-pattern" }], expression: { interpolated: true, parameters: ["zoom"] }, "property-type": "data-constant" }, "background-pattern": { type: "resolvedImage", transition: true, expression: { interpolated: false, parameters: ["zoom"] }, "property-type": "cross-faded" }, "background-opacity": { type: "number", default: 1, minimum: 0, maximum: 1, transition: true, expression: { interpolated: true, parameters: ["zoom"] }, "property-type": "data-constant" } }, transition: { duration: { type: "number", default: 300, minimum: 0, units: "milliseconds" }, delay: { type: "number", default: 0, minimum: 0, units: "milliseconds" } }, "property-type": { "data-driven": { type: "property-type" }, "cross-faded": { type: "property-type" }, "cross-faded-data-driven": { type: "property-type" }, "color-ramp": { type: "property-type" }, "data-constant": { type: "property-type" }, constant: { type: "property-type" } }, promoteId: { "*": { type: "string" } } };
+              const K22 = ["type", "source", "source-layer", "minzoom", "maxzoom", "filter", "layout"];
+              function X2(t42, e22) {
+                const r22 = {};
+                for (const e3 in t42) "ref" !== e3 && (r22[e3] = t42[e3]);
+                return K22.forEach((t5) => {
+                  t5 in e22 && (r22[t5] = e22[t5]);
+                }), r22;
+              }
+              function H2(t42, e22) {
+                if (Array.isArray(t42)) {
+                  if (!Array.isArray(e22) || t42.length !== e22.length) return false;
+                  for (let r22 = 0; r22 < t42.length; r22++) if (!H2(t42[r22], e22[r22])) return false;
+                  return true;
+                }
+                if ("object" == typeof t42 && null !== t42 && null !== e22) {
+                  if ("object" != typeof e22) return false;
+                  if (Object.keys(t42).length !== Object.keys(e22).length) return false;
+                  for (const r22 in t42) if (!H2(t42[r22], e22[r22])) return false;
+                  return true;
+                }
+                return t42 === e22;
+              }
+              function Y2(t42, e22) {
+                t42.push(e22);
+              }
+              function J2(t42, e22, r22) {
+                Y2(r22, { command: "addSource", args: [t42, e22[t42]] });
+              }
+              function W2(t42, e22, r22) {
+                Y2(e22, { command: "removeSource", args: [t42] }), r22[t42] = true;
+              }
+              function Q2(t42, e22, r22, n22) {
+                W2(t42, r22, n22), J2(t42, e22, r22);
+              }
+              function tt2(t42, e22, r22) {
+                let n22;
+                for (n22 in t42[r22]) if (Object.prototype.hasOwnProperty.call(t42[r22], n22) && "data" !== n22 && !H2(t42[r22][n22], e22[r22][n22])) return false;
+                for (n22 in e22[r22]) if (Object.prototype.hasOwnProperty.call(e22[r22], n22) && "data" !== n22 && !H2(t42[r22][n22], e22[r22][n22])) return false;
+                return true;
+              }
+              function et2(t42, e22, r22, n22, i22, s22) {
+                t42 = t42 || {}, e22 = e22 || {};
+                for (const a22 in t42) Object.prototype.hasOwnProperty.call(t42, a22) && (H2(t42[a22], e22[a22]) || r22.push({ command: s22, args: [n22, a22, e22[a22], i22] }));
+                for (const a22 in e22) Object.prototype.hasOwnProperty.call(e22, a22) && !Object.prototype.hasOwnProperty.call(t42, a22) && (H2(t42[a22], e22[a22]) || r22.push({ command: s22, args: [n22, a22, e22[a22], i22] }));
+              }
+              function rt2(t42) {
+                return t42.id;
+              }
+              function nt2(t42, e22) {
+                return t42[e22.id] = e22, t42;
+              }
+              class it2 {
+                constructor(t42, e22, r22, n22) {
+                  this.message = (t42 ? `${t42}: ` : "") + r22, n22 && (this.identifier = n22), null != e22 && e22.__line__ && (this.line = e22.__line__);
+                }
+              }
+              function st2(t42, ...e22) {
+                for (const r22 of e22) for (const e3 in r22) t42[e3] = r22[e3];
+                return t42;
+              }
+              class at2 extends Error {
+                constructor(t42, e22) {
+                  super(e22), this.message = e22, this.key = t42;
+                }
+              }
+              class ot2 {
+                constructor(t42, e22 = []) {
+                  this.parent = t42, this.bindings = {};
+                  for (const [t5, r22] of e22) this.bindings[t5] = r22;
+                }
+                concat(t42) {
+                  return new ot2(this, t42);
+                }
+                get(t42) {
+                  if (this.bindings[t42]) return this.bindings[t42];
+                  if (this.parent) return this.parent.get(t42);
+                  throw new Error(`${t42} not found in scope.`);
+                }
+                has(t42) {
+                  return !!this.bindings[t42] || !!this.parent && this.parent.has(t42);
+                }
+              }
+              const lt2 = { kind: "null" }, ut2 = { kind: "number" }, ct2 = { kind: "string" }, ht2 = { kind: "boolean" }, pt2 = { kind: "color" }, ft2 = { kind: "object" }, dt2 = { kind: "value" }, yt = { kind: "collator" }, mt2 = { kind: "formatted" }, gt2 = { kind: "padding" }, xt = { kind: "resolvedImage" }, vt = { kind: "variableAnchorOffsetCollection" };
+              function bt(t42, e22) {
+                return { kind: "array", itemType: t42, N: e22 };
+              }
+              function wt(t42) {
+                if ("array" === t42.kind) {
+                  const e22 = wt(t42.itemType);
+                  return "number" == typeof t42.N ? `array<${e22}, ${t42.N}>` : "value" === t42.itemType.kind ? "array" : `array<${e22}>`;
+                }
+                return t42.kind;
+              }
+              const _t2 = [lt2, ut2, ct2, ht2, pt2, mt2, ft2, bt(dt2), gt2, xt, vt];
+              function At(t42, e22) {
+                if ("error" === e22.kind) return null;
+                if ("array" === t42.kind) {
+                  if ("array" === e22.kind && (0 === e22.N && "value" === e22.itemType.kind || !At(t42.itemType, e22.itemType)) && ("number" != typeof t42.N || t42.N === e22.N)) return null;
+                } else {
+                  if (t42.kind === e22.kind) return null;
+                  if ("value" === t42.kind) {
+                    for (const t5 of _t2) if (!At(t5, e22)) return null;
+                  }
+                }
+                return `Expected ${wt(t42)} but found ${wt(e22)} instead.`;
+              }
+              function St(t42, e22) {
+                return e22.some((e3) => e3.kind === t42.kind);
+              }
+              function kt(t42, e22) {
+                return e22.some((e3) => "null" === e3 ? null === t42 : "array" === e3 ? Array.isArray(t42) : "object" === e3 ? t42 && !Array.isArray(t42) && "object" == typeof t42 : e3 === typeof t42);
+              }
+              function Mt(t42, e22) {
+                return "array" === t42.kind && "array" === e22.kind ? t42.itemType.kind === e22.itemType.kind && "number" == typeof t42.N : t42.kind === e22.kind;
+              }
+              const It = 0.96422, zt = 0.82521, Pt = 4 / 29, Ct = 6 / 29, Bt = 3 * Ct * Ct, Vt = Ct * Ct * Ct, Et = Math.PI / 180, Ft = 180 / Math.PI;
+              function Tt(t42) {
+                return (t42 %= 360) < 0 && (t42 += 360), t42;
+              }
+              function $t([t42, e22, r22, n22]) {
+                let i22, s22;
+                const a22 = Dt((0.2225045 * (t42 = Lt(t42)) + 0.7168786 * (e22 = Lt(e22)) + 0.0606169 * (r22 = Lt(r22))) / 1);
+                t42 === e22 && e22 === r22 ? i22 = s22 = a22 : (i22 = Dt((0.4360747 * t42 + 0.3850649 * e22 + 0.1430804 * r22) / It), s22 = Dt((0.0139322 * t42 + 0.0971045 * e22 + 0.7141733 * r22) / zt));
+                const o22 = 116 * a22 - 16;
+                return [o22 < 0 ? 0 : o22, 500 * (i22 - a22), 200 * (a22 - s22), n22];
+              }
+              function Lt(t42) {
+                return t42 <= 0.04045 ? t42 / 12.92 : Math.pow((t42 + 0.055) / 1.055, 2.4);
+              }
+              function Dt(t42) {
+                return t42 > Vt ? Math.pow(t42, 1 / 3) : t42 / Bt + Pt;
+              }
+              function Ot([t42, e22, r22, n22]) {
+                let i22 = (t42 + 16) / 116, s22 = isNaN(e22) ? i22 : i22 + e22 / 500, a22 = isNaN(r22) ? i22 : i22 - r22 / 200;
+                return i22 = 1 * Rt(i22), s22 = It * Rt(s22), a22 = zt * Rt(a22), [jt(3.1338561 * s22 - 1.6168667 * i22 - 0.4906146 * a22), jt(-0.9787684 * s22 + 1.9161415 * i22 + 0.033454 * a22), jt(0.0719453 * s22 - 0.2289914 * i22 + 1.4052427 * a22), n22];
+              }
+              function jt(t42) {
+                return (t42 = t42 <= 304e-5 ? 12.92 * t42 : 1.055 * Math.pow(t42, 1 / 2.4) - 0.055) < 0 ? 0 : t42 > 1 ? 1 : t42;
+              }
+              function Rt(t42) {
+                return t42 > Ct ? t42 * t42 * t42 : Bt * (t42 - Pt);
+              }
+              function Ut(t42) {
+                return parseInt(t42.padEnd(2, t42), 16) / 255;
+              }
+              function qt(t42, e22) {
+                return Nt(e22 ? t42 / 100 : t42, 0, 1);
+              }
+              function Nt(t42, e22, r22) {
+                return Math.min(Math.max(e22, t42), r22);
+              }
+              function Zt(t42) {
+                return !t42.some(Number.isNaN);
+              }
+              const Gt = { aliceblue: [240, 248, 255], antiquewhite: [250, 235, 215], aqua: [0, 255, 255], aquamarine: [127, 255, 212], azure: [240, 255, 255], beige: [245, 245, 220], bisque: [255, 228, 196], black: [0, 0, 0], blanchedalmond: [255, 235, 205], blue: [0, 0, 255], blueviolet: [138, 43, 226], brown: [165, 42, 42], burlywood: [222, 184, 135], cadetblue: [95, 158, 160], chartreuse: [127, 255, 0], chocolate: [210, 105, 30], coral: [255, 127, 80], cornflowerblue: [100, 149, 237], cornsilk: [255, 248, 220], crimson: [220, 20, 60], cyan: [0, 255, 255], darkblue: [0, 0, 139], darkcyan: [0, 139, 139], darkgoldenrod: [184, 134, 11], darkgray: [169, 169, 169], darkgreen: [0, 100, 0], darkgrey: [169, 169, 169], darkkhaki: [189, 183, 107], darkmagenta: [139, 0, 139], darkolivegreen: [85, 107, 47], darkorange: [255, 140, 0], darkorchid: [153, 50, 204], darkred: [139, 0, 0], darksalmon: [233, 150, 122], darkseagreen: [143, 188, 143], darkslateblue: [72, 61, 139], darkslategray: [47, 79, 79], darkslategrey: [47, 79, 79], darkturquoise: [0, 206, 209], darkviolet: [148, 0, 211], deeppink: [255, 20, 147], deepskyblue: [0, 191, 255], dimgray: [105, 105, 105], dimgrey: [105, 105, 105], dodgerblue: [30, 144, 255], firebrick: [178, 34, 34], floralwhite: [255, 250, 240], forestgreen: [34, 139, 34], fuchsia: [255, 0, 255], gainsboro: [220, 220, 220], ghostwhite: [248, 248, 255], gold: [255, 215, 0], goldenrod: [218, 165, 32], gray: [128, 128, 128], green: [0, 128, 0], greenyellow: [173, 255, 47], grey: [128, 128, 128], honeydew: [240, 255, 240], hotpink: [255, 105, 180], indianred: [205, 92, 92], indigo: [75, 0, 130], ivory: [255, 255, 240], khaki: [240, 230, 140], lavender: [230, 230, 250], lavenderblush: [255, 240, 245], lawngreen: [124, 252, 0], lemonchiffon: [255, 250, 205], lightblue: [173, 216, 230], lightcoral: [240, 128, 128], lightcyan: [224, 255, 255], lightgoldenrodyellow: [250, 250, 210], lightgray: [211, 211, 211], lightgreen: [144, 238, 144], lightgrey: [211, 211, 211], lightpink: [255, 182, 193], lightsalmon: [255, 160, 122], lightseagreen: [32, 178, 170], lightskyblue: [135, 206, 250], lightslategray: [119, 136, 153], lightslategrey: [119, 136, 153], lightsteelblue: [176, 196, 222], lightyellow: [255, 255, 224], lime: [0, 255, 0], limegreen: [50, 205, 50], linen: [250, 240, 230], magenta: [255, 0, 255], maroon: [128, 0, 0], mediumaquamarine: [102, 205, 170], mediumblue: [0, 0, 205], mediumorchid: [186, 85, 211], mediumpurple: [147, 112, 219], mediumseagreen: [60, 179, 113], mediumslateblue: [123, 104, 238], mediumspringgreen: [0, 250, 154], mediumturquoise: [72, 209, 204], mediumvioletred: [199, 21, 133], midnightblue: [25, 25, 112], mintcream: [245, 255, 250], mistyrose: [255, 228, 225], moccasin: [255, 228, 181], navajowhite: [255, 222, 173], navy: [0, 0, 128], oldlace: [253, 245, 230], olive: [128, 128, 0], olivedrab: [107, 142, 35], orange: [255, 165, 0], orangered: [255, 69, 0], orchid: [218, 112, 214], palegoldenrod: [238, 232, 170], palegreen: [152, 251, 152], paleturquoise: [175, 238, 238], palevioletred: [219, 112, 147], papayawhip: [255, 239, 213], peachpuff: [255, 218, 185], peru: [205, 133, 63], pink: [255, 192, 203], plum: [221, 160, 221], powderblue: [176, 224, 230], purple: [128, 0, 128], rebeccapurple: [102, 51, 153], red: [255, 0, 0], rosybrown: [188, 143, 143], royalblue: [65, 105, 225], saddlebrown: [139, 69, 19], salmon: [250, 128, 114], sandybrown: [244, 164, 96], seagreen: [46, 139, 87], seashell: [255, 245, 238], sienna: [160, 82, 45], silver: [192, 192, 192], skyblue: [135, 206, 235], slateblue: [106, 90, 205], slategray: [112, 128, 144], slategrey: [112, 128, 144], snow: [255, 250, 250], springgreen: [0, 255, 127], steelblue: [70, 130, 180], tan: [210, 180, 140], teal: [0, 128, 128], thistle: [216, 191, 216], tomato: [255, 99, 71], turquoise: [64, 224, 208], violet: [238, 130, 238], wheat: [245, 222, 179], white: [255, 255, 255], whitesmoke: [245, 245, 245], yellow: [255, 255, 0], yellowgreen: [154, 205, 50] };
+              class Kt {
+                constructor(t42, e22, r22, n22 = 1, i22 = true) {
+                  this.r = t42, this.g = e22, this.b = r22, this.a = n22, i22 || (this.r *= n22, this.g *= n22, this.b *= n22, n22 || this.overwriteGetter("rgb", [t42, e22, r22, n22]));
+                }
+                static parse(t42) {
+                  if (t42 instanceof Kt) return t42;
+                  if ("string" != typeof t42) return;
+                  const e22 = function(t5) {
+                    if ("transparent" === (t5 = t5.toLowerCase().trim())) return [0, 0, 0, 0];
+                    const e3 = Gt[t5];
+                    if (e3) {
+                      const [t6, r3, n22] = e3;
+                      return [t6 / 255, r3 / 255, n22 / 255, 1];
+                    }
+                    if (t5.startsWith("#") && /^#(?:[0-9a-f]{3,4}|[0-9a-f]{6}|[0-9a-f]{8})$/.test(t5)) {
+                      const e4 = t5.length < 6 ? 1 : 2;
+                      let r3 = 1;
+                      return [Ut(t5.slice(r3, r3 += e4)), Ut(t5.slice(r3, r3 += e4)), Ut(t5.slice(r3, r3 += e4)), Ut(t5.slice(r3, r3 + e4) || "ff")];
+                    }
+                    if (t5.startsWith("rgb")) {
+                      const e4 = t5.match(/^rgba?\(\s*([\de.+-]+)(%)?(?:\s+|\s*(,)\s*)([\de.+-]+)(%)?(?:\s+|\s*(,)\s*)([\de.+-]+)(%)?(?:\s*([,\/])\s*([\de.+-]+)(%)?)?\s*\)$/);
+                      if (e4) {
+                        const [t6, r3, n22, i22, s22, a22, o22, l22, u22, c22, h22, p22] = e4, f22 = [i22 || " ", o22 || " ", c22].join("");
+                        if ("  " === f22 || "  /" === f22 || ",," === f22 || ",,," === f22) {
+                          const t7 = [n22, a22, u22].join(""), e5 = "%%%" === t7 ? 100 : "" === t7 ? 255 : 0;
+                          if (e5) {
+                            const t8 = [Nt(+r3 / e5, 0, 1), Nt(+s22 / e5, 0, 1), Nt(+l22 / e5, 0, 1), h22 ? qt(+h22, p22) : 1];
+                            if (Zt(t8)) return t8;
+                          }
+                        }
+                        return;
+                      }
+                    }
+                    const r22 = t5.match(/^hsla?\(\s*([\de.+-]+)(?:deg)?(?:\s+|\s*(,)\s*)([\de.+-]+)%(?:\s+|\s*(,)\s*)([\de.+-]+)%(?:\s*([,\/])\s*([\de.+-]+)(%)?)?\s*\)$/);
+                    if (r22) {
+                      const [t6, e4, n22, i22, s22, a22, o22, l22, u22] = r22, c22 = [n22 || " ", s22 || " ", o22].join("");
+                      if ("  " === c22 || "  /" === c22 || ",," === c22 || ",,," === c22) {
+                        const t7 = [+e4, Nt(+i22, 0, 100), Nt(+a22, 0, 100), l22 ? qt(+l22, u22) : 1];
+                        if (Zt(t7)) return function([t8, e5, r3, n3]) {
+                          function i3(n4) {
+                            const i4 = (n4 + t8 / 30) % 12, s3 = e5 * Math.min(r3, 1 - r3);
+                            return r3 - s3 * Math.max(-1, Math.min(i4 - 3, 9 - i4, 1));
+                          }
+                          return t8 = Tt(t8), e5 /= 100, r3 /= 100, [i3(0), i3(8), i3(4), n3];
+                        }(t7);
+                      }
+                    }
+                  }(t42);
+                  return e22 ? new Kt(...e22, false) : void 0;
+                }
+                get rgb() {
+                  const { r: t42, g: e22, b: r22, a: n22 } = this, i22 = n22 || 1 / 0;
+                  return this.overwriteGetter("rgb", [t42 / i22, e22 / i22, r22 / i22, n22]);
+                }
+                get hcl() {
+                  return this.overwriteGetter("hcl", function(t42) {
+                    const [e22, r22, n22, i22] = $t(t42), s22 = Math.sqrt(r22 * r22 + n22 * n22);
+                    return [Math.round(1e4 * s22) ? Tt(Math.atan2(n22, r22) * Ft) : NaN, s22, e22, i22];
+                  }(this.rgb));
+                }
+                get lab() {
+                  return this.overwriteGetter("lab", $t(this.rgb));
+                }
+                overwriteGetter(t42, e22) {
+                  return Object.defineProperty(this, t42, { value: e22 }), e22;
+                }
+                toString() {
+                  const [t42, e22, r22, n22] = this.rgb;
+                  return `rgba(${[t42, e22, r22].map((t5) => Math.round(255 * t5)).join(",")},${n22})`;
+                }
+              }
+              Kt.black = new Kt(0, 0, 0, 1), Kt.white = new Kt(1, 1, 1, 1), Kt.transparent = new Kt(0, 0, 0, 0), Kt.red = new Kt(1, 0, 0, 1);
+              class Xt {
+                constructor(t42, e22, r22) {
+                  this.sensitivity = t42 ? e22 ? "variant" : "case" : e22 ? "accent" : "base", this.locale = r22, this.collator = new Intl.Collator(this.locale ? this.locale : [], { sensitivity: this.sensitivity, usage: "search" });
+                }
+                compare(t42, e22) {
+                  return this.collator.compare(t42, e22);
+                }
+                resolvedLocale() {
+                  return new Intl.Collator(this.locale ? this.locale : []).resolvedOptions().locale;
+                }
+              }
+              class Ht {
+                constructor(t42, e22, r22, n22, i22) {
+                  this.text = t42, this.image = e22, this.scale = r22, this.fontStack = n22, this.textColor = i22;
+                }
+              }
+              class Yt {
+                constructor(t42) {
+                  this.sections = t42;
+                }
+                static fromString(t42) {
+                  return new Yt([new Ht(t42, null, null, null, null)]);
+                }
+                isEmpty() {
+                  return 0 === this.sections.length || !this.sections.some((t42) => 0 !== t42.text.length || t42.image && 0 !== t42.image.name.length);
+                }
+                static factory(t42) {
+                  return t42 instanceof Yt ? t42 : Yt.fromString(t42);
+                }
+                toString() {
+                  return 0 === this.sections.length ? "" : this.sections.map((t42) => t42.text).join("");
+                }
+              }
+              class Jt {
+                constructor(t42) {
+                  this.values = t42.slice();
+                }
+                static parse(t42) {
+                  if (t42 instanceof Jt) return t42;
+                  if ("number" == typeof t42) return new Jt([t42, t42, t42, t42]);
+                  if (Array.isArray(t42) && !(t42.length < 1 || t42.length > 4)) {
+                    for (const e22 of t42) if ("number" != typeof e22) return;
+                    switch (t42.length) {
+                      case 1:
+                        t42 = [t42[0], t42[0], t42[0], t42[0]];
+                        break;
+                      case 2:
+                        t42 = [t42[0], t42[1], t42[0], t42[1]];
+                        break;
+                      case 3:
+                        t42 = [t42[0], t42[1], t42[2], t42[1]];
+                    }
+                    return new Jt(t42);
+                  }
+                }
+                toString() {
+                  return JSON.stringify(this.values);
+                }
+              }
+              const Wt = /* @__PURE__ */ new Set(["center", "left", "right", "top", "bottom", "top-left", "top-right", "bottom-left", "bottom-right"]);
+              class Qt {
+                constructor(t42) {
+                  this.values = t42.slice();
+                }
+                static parse(t42) {
+                  if (t42 instanceof Qt) return t42;
+                  if (Array.isArray(t42) && !(t42.length < 1) && t42.length % 2 == 0) {
+                    for (let e22 = 0; e22 < t42.length; e22 += 2) {
+                      const r22 = t42[e22], n22 = t42[e22 + 1];
+                      if ("string" != typeof r22 || !Wt.has(r22)) return;
+                      if (!Array.isArray(n22) || 2 !== n22.length || "number" != typeof n22[0] || "number" != typeof n22[1]) return;
+                    }
+                    return new Qt(t42);
+                  }
+                }
+                toString() {
+                  return JSON.stringify(this.values);
+                }
+              }
+              class te2 {
+                constructor(t42) {
+                  this.name = t42.name, this.available = t42.available;
+                }
+                toString() {
+                  return this.name;
+                }
+                static fromString(t42) {
+                  return t42 ? new te2({ name: t42, available: false }) : null;
+                }
+              }
+              function ee2(t42, e22, r22, n22) {
+                return "number" == typeof t42 && t42 >= 0 && t42 <= 255 && "number" == typeof e22 && e22 >= 0 && e22 <= 255 && "number" == typeof r22 && r22 >= 0 && r22 <= 255 ? void 0 === n22 || "number" == typeof n22 && n22 >= 0 && n22 <= 1 ? null : `Invalid rgba value [${[t42, e22, r22, n22].join(", ")}]: 'a' must be between 0 and 1.` : `Invalid rgba value [${("number" == typeof n22 ? [t42, e22, r22, n22] : [t42, e22, r22]).join(", ")}]: 'r', 'g', and 'b' must be between 0 and 255.`;
+              }
+              function re2(t42) {
+                if (null === t42 || "string" == typeof t42 || "boolean" == typeof t42 || "number" == typeof t42 || t42 instanceof Kt || t42 instanceof Xt || t42 instanceof Yt || t42 instanceof Jt || t42 instanceof Qt || t42 instanceof te2) return true;
+                if (Array.isArray(t42)) {
+                  for (const e22 of t42) if (!re2(e22)) return false;
+                  return true;
+                }
+                if ("object" == typeof t42) {
+                  for (const e22 in t42) if (!re2(t42[e22])) return false;
+                  return true;
+                }
+                return false;
+              }
+              function ne2(t42) {
+                if (null === t42) return lt2;
+                if ("string" == typeof t42) return ct2;
+                if ("boolean" == typeof t42) return ht2;
+                if ("number" == typeof t42) return ut2;
+                if (t42 instanceof Kt) return pt2;
+                if (t42 instanceof Xt) return yt;
+                if (t42 instanceof Yt) return mt2;
+                if (t42 instanceof Jt) return gt2;
+                if (t42 instanceof Qt) return vt;
+                if (t42 instanceof te2) return xt;
+                if (Array.isArray(t42)) {
+                  const e22 = t42.length;
+                  let r22;
+                  for (const e3 of t42) {
+                    const t5 = ne2(e3);
+                    if (r22) {
+                      if (r22 === t5) continue;
+                      r22 = dt2;
+                      break;
+                    }
+                    r22 = t5;
+                  }
+                  return bt(r22 || dt2, e22);
+                }
+                return ft2;
+              }
+              function ie2(t42) {
+                const e22 = typeof t42;
+                return null === t42 ? "" : "string" === e22 || "number" === e22 || "boolean" === e22 ? String(t42) : t42 instanceof Kt || t42 instanceof Yt || t42 instanceof Jt || t42 instanceof Qt || t42 instanceof te2 ? t42.toString() : JSON.stringify(t42);
+              }
+              class se2 {
+                constructor(t42, e22) {
+                  this.type = t42, this.value = e22;
+                }
+                static parse(t42, e22) {
+                  if (2 !== t42.length) return e22.error(`'literal' expression requires exactly one argument, but found ${t42.length - 1} instead.`);
+                  if (!re2(t42[1])) return e22.error("invalid value");
+                  const r22 = t42[1];
+                  let n22 = ne2(r22);
+                  const i22 = e22.expectedType;
+                  return "array" !== n22.kind || 0 !== n22.N || !i22 || "array" !== i22.kind || "number" == typeof i22.N && 0 !== i22.N || (n22 = i22), new se2(n22, r22);
+                }
+                evaluate() {
+                  return this.value;
+                }
+                eachChild() {
+                }
+                outputDefined() {
+                  return true;
+                }
+              }
+              class ae2 {
+                constructor(t42) {
+                  this.name = "ExpressionEvaluationError", this.message = t42;
+                }
+                toJSON() {
+                  return this.message;
+                }
+              }
+              const oe2 = { string: ct2, number: ut2, boolean: ht2, object: ft2 };
+              class le2 {
+                constructor(t42, e22) {
+                  this.type = t42, this.args = e22;
+                }
+                static parse(t42, e22) {
+                  if (t42.length < 2) return e22.error("Expected at least one argument.");
+                  let r22, n22 = 1;
+                  const i22 = t42[0];
+                  if ("array" === i22) {
+                    let i3, s3;
+                    if (t42.length > 2) {
+                      const r3 = t42[1];
+                      if ("string" != typeof r3 || !(r3 in oe2) || "object" === r3) return e22.error('The item type argument of "array" must be one of string, number, boolean', 1);
+                      i3 = oe2[r3], n22++;
+                    } else i3 = dt2;
+                    if (t42.length > 3) {
+                      if (null !== t42[2] && ("number" != typeof t42[2] || t42[2] < 0 || t42[2] !== Math.floor(t42[2]))) return e22.error('The length argument to "array" must be a positive integer literal', 2);
+                      s3 = t42[2], n22++;
+                    }
+                    r22 = bt(i3, s3);
+                  } else {
+                    if (!oe2[i22]) throw new Error(`Types doesn't contain name = ${i22}`);
+                    r22 = oe2[i22];
+                  }
+                  const s22 = [];
+                  for (; n22 < t42.length; n22++) {
+                    const r3 = e22.parse(t42[n22], n22, dt2);
+                    if (!r3) return null;
+                    s22.push(r3);
+                  }
+                  return new le2(r22, s22);
+                }
+                evaluate(t42) {
+                  for (let e22 = 0; e22 < this.args.length; e22++) {
+                    const r22 = this.args[e22].evaluate(t42);
+                    if (!At(this.type, ne2(r22))) return r22;
+                    if (e22 === this.args.length - 1) throw new ae2(`Expected value to be of type ${wt(this.type)}, but found ${wt(ne2(r22))} instead.`);
+                  }
+                  throw new Error();
+                }
+                eachChild(t42) {
+                  this.args.forEach(t42);
+                }
+                outputDefined() {
+                  return this.args.every((t42) => t42.outputDefined());
+                }
+              }
+              const ue2 = { "to-boolean": ht2, "to-color": pt2, "to-number": ut2, "to-string": ct2 };
+              class ce2 {
+                constructor(t42, e22) {
+                  this.type = t42, this.args = e22;
+                }
+                static parse(t42, e22) {
+                  if (t42.length < 2) return e22.error("Expected at least one argument.");
+                  const r22 = t42[0];
+                  if (!ue2[r22]) throw new Error(`Can't parse ${r22} as it is not part of the known types`);
+                  if (("to-boolean" === r22 || "to-string" === r22) && 2 !== t42.length) return e22.error("Expected one argument.");
+                  const n22 = ue2[r22], i22 = [];
+                  for (let r3 = 1; r3 < t42.length; r3++) {
+                    const n3 = e22.parse(t42[r3], r3, dt2);
+                    if (!n3) return null;
+                    i22.push(n3);
+                  }
+                  return new ce2(n22, i22);
+                }
+                evaluate(t42) {
+                  switch (this.type.kind) {
+                    case "boolean":
+                      return Boolean(this.args[0].evaluate(t42));
+                    case "color": {
+                      let e22, r22;
+                      for (const n22 of this.args) {
+                        if (e22 = n22.evaluate(t42), r22 = null, e22 instanceof Kt) return e22;
+                        if ("string" == typeof e22) {
+                          const r3 = t42.parseColor(e22);
+                          if (r3) return r3;
+                        } else if (Array.isArray(e22) && (r22 = e22.length < 3 || e22.length > 4 ? `Invalid rbga value ${JSON.stringify(e22)}: expected an array containing either three or four numeric values.` : ee2(e22[0], e22[1], e22[2], e22[3]), !r22)) return new Kt(e22[0] / 255, e22[1] / 255, e22[2] / 255, e22[3]);
+                      }
+                      throw new ae2(r22 || `Could not parse color from value '${"string" == typeof e22 ? e22 : JSON.stringify(e22)}'`);
+                    }
+                    case "padding": {
+                      let e22;
+                      for (const r22 of this.args) {
+                        e22 = r22.evaluate(t42);
+                        const n22 = Jt.parse(e22);
+                        if (n22) return n22;
+                      }
+                      throw new ae2(`Could not parse padding from value '${"string" == typeof e22 ? e22 : JSON.stringify(e22)}'`);
+                    }
+                    case "variableAnchorOffsetCollection": {
+                      let e22;
+                      for (const r22 of this.args) {
+                        e22 = r22.evaluate(t42);
+                        const n22 = Qt.parse(e22);
+                        if (n22) return n22;
+                      }
+                      throw new ae2(`Could not parse variableAnchorOffsetCollection from value '${"string" == typeof e22 ? e22 : JSON.stringify(e22)}'`);
+                    }
+                    case "number": {
+                      let e22 = null;
+                      for (const r22 of this.args) {
+                        if (e22 = r22.evaluate(t42), null === e22) return 0;
+                        const n22 = Number(e22);
+                        if (!isNaN(n22)) return n22;
+                      }
+                      throw new ae2(`Could not convert ${JSON.stringify(e22)} to number.`);
+                    }
+                    case "formatted":
+                      return Yt.fromString(ie2(this.args[0].evaluate(t42)));
+                    case "resolvedImage":
+                      return te2.fromString(ie2(this.args[0].evaluate(t42)));
+                    default:
+                      return ie2(this.args[0].evaluate(t42));
+                  }
+                }
+                eachChild(t42) {
+                  this.args.forEach(t42);
+                }
+                outputDefined() {
+                  return this.args.every((t42) => t42.outputDefined());
+                }
+              }
+              const he2 = ["Unknown", "Point", "LineString", "Polygon"];
+              class pe2 {
+                constructor() {
+                  this.globals = null, this.feature = null, this.featureState = null, this.formattedSection = null, this._parseColorCache = {}, this.availableImages = null, this.canonical = null;
+                }
+                id() {
+                  return this.feature && "id" in this.feature ? this.feature.id : null;
+                }
+                geometryType() {
+                  return this.feature ? "number" == typeof this.feature.type ? he2[this.feature.type] : this.feature.type : null;
+                }
+                geometry() {
+                  return this.feature && "geometry" in this.feature ? this.feature.geometry : null;
+                }
+                canonicalID() {
+                  return this.canonical;
+                }
+                properties() {
+                  return this.feature && this.feature.properties || {};
+                }
+                parseColor(t42) {
+                  let e22 = this._parseColorCache[t42];
+                  return e22 || (e22 = this._parseColorCache[t42] = Kt.parse(t42)), e22;
+                }
+              }
+              class fe2 {
+                constructor(t42, e22, r22 = [], n22, i22 = new ot2(), s22 = []) {
+                  this.registry = t42, this.path = r22, this.key = r22.map((t5) => `[${t5}]`).join(""), this.scope = i22, this.errors = s22, this.expectedType = n22, this._isConstant = e22;
+                }
+                parse(t42, e22, r22, n22, i22 = {}) {
+                  return e22 ? this.concat(e22, r22, n22)._parse(t42, i22) : this._parse(t42, i22);
+                }
+                _parse(t42, e22) {
+                  function r22(t5, e3, r3) {
+                    return "assert" === r3 ? new le2(e3, [t5]) : "coerce" === r3 ? new ce2(e3, [t5]) : t5;
+                  }
+                  if (null !== t42 && "string" != typeof t42 && "boolean" != typeof t42 && "number" != typeof t42 || (t42 = ["literal", t42]), Array.isArray(t42)) {
+                    if (0 === t42.length) return this.error('Expected an array with at least one element. If you wanted a literal array, use ["literal", []].');
+                    const n22 = t42[0];
+                    if ("string" != typeof n22) return this.error(`Expression name must be a string, but found ${typeof n22} instead. If you wanted a literal array, use ["literal", [...]].`, 0), null;
+                    const i22 = this.registry[n22];
+                    if (i22) {
+                      let n3 = i22.parse(t42, this);
+                      if (!n3) return null;
+                      if (this.expectedType) {
+                        const t5 = this.expectedType, i3 = n3.type;
+                        if ("string" !== t5.kind && "number" !== t5.kind && "boolean" !== t5.kind && "object" !== t5.kind && "array" !== t5.kind || "value" !== i3.kind) if ("color" !== t5.kind && "formatted" !== t5.kind && "resolvedImage" !== t5.kind || "value" !== i3.kind && "string" !== i3.kind) if ("padding" !== t5.kind || "value" !== i3.kind && "number" !== i3.kind && "array" !== i3.kind) if ("variableAnchorOffsetCollection" !== t5.kind || "value" !== i3.kind && "array" !== i3.kind) {
+                          if (this.checkSubtype(t5, i3)) return null;
+                        } else n3 = r22(n3, t5, e22.typeAnnotation || "coerce");
+                        else n3 = r22(n3, t5, e22.typeAnnotation || "coerce");
+                        else n3 = r22(n3, t5, e22.typeAnnotation || "coerce");
+                        else n3 = r22(n3, t5, e22.typeAnnotation || "assert");
+                      }
+                      if (!(n3 instanceof se2) && "resolvedImage" !== n3.type.kind && this._isConstant(n3)) {
+                        const t5 = new pe2();
+                        try {
+                          n3 = new se2(n3.type, n3.evaluate(t5));
+                        } catch (t6) {
+                          return this.error(t6.message), null;
+                        }
+                      }
+                      return n3;
+                    }
+                    return this.error(`Unknown expression "${n22}". If you wanted a literal array, use ["literal", [...]].`, 0);
+                  }
+                  return this.error(void 0 === t42 ? "'undefined' value invalid. Use null instead." : "object" == typeof t42 ? 'Bare objects invalid. Use ["literal", {...}] instead.' : `Expected an array, but found ${typeof t42} instead.`);
+                }
+                concat(t42, e22, r22) {
+                  const n22 = "number" == typeof t42 ? this.path.concat(t42) : this.path, i22 = r22 ? this.scope.concat(r22) : this.scope;
+                  return new fe2(this.registry, this._isConstant, n22, e22 || null, i22, this.errors);
+                }
+                error(t42, ...e22) {
+                  const r22 = `${this.key}${e22.map((t5) => `[${t5}]`).join("")}`;
+                  this.errors.push(new at2(r22, t42));
+                }
+                checkSubtype(t42, e22) {
+                  const r22 = At(t42, e22);
+                  return r22 && this.error(r22), r22;
+                }
+              }
+              class de2 {
+                constructor(t42, e22) {
+                  this.type = e22.type, this.bindings = [].concat(t42), this.result = e22;
+                }
+                evaluate(t42) {
+                  return this.result.evaluate(t42);
+                }
+                eachChild(t42) {
+                  for (const e22 of this.bindings) t42(e22[1]);
+                  t42(this.result);
+                }
+                static parse(t42, e22) {
+                  if (t42.length < 4) return e22.error(`Expected at least 3 arguments, but found ${t42.length - 1} instead.`);
+                  const r22 = [];
+                  for (let n3 = 1; n3 < t42.length - 1; n3 += 2) {
+                    const i22 = t42[n3];
+                    if ("string" != typeof i22) return e22.error(`Expected string, but found ${typeof i22} instead.`, n3);
+                    if (/[^a-zA-Z0-9_]/.test(i22)) return e22.error("Variable names must contain only alphanumeric characters or '_'.", n3);
+                    const s22 = e22.parse(t42[n3 + 1], n3 + 1);
+                    if (!s22) return null;
+                    r22.push([i22, s22]);
+                  }
+                  const n22 = e22.parse(t42[t42.length - 1], t42.length - 1, e22.expectedType, r22);
+                  return n22 ? new de2(r22, n22) : null;
+                }
+                outputDefined() {
+                  return this.result.outputDefined();
+                }
+              }
+              class ye2 {
+                constructor(t42, e22) {
+                  this.type = e22.type, this.name = t42, this.boundExpression = e22;
+                }
+                static parse(t42, e22) {
+                  if (2 !== t42.length || "string" != typeof t42[1]) return e22.error("'var' expression requires exactly one string literal argument.");
+                  const r22 = t42[1];
+                  return e22.scope.has(r22) ? new ye2(r22, e22.scope.get(r22)) : e22.error(`Unknown variable "${r22}". Make sure "${r22}" has been bound in an enclosing "let" expression before using it.`, 1);
+                }
+                evaluate(t42) {
+                  return this.boundExpression.evaluate(t42);
+                }
+                eachChild() {
+                }
+                outputDefined() {
+                  return false;
+                }
+              }
+              class me2 {
+                constructor(t42, e22, r22) {
+                  this.type = t42, this.index = e22, this.input = r22;
+                }
+                static parse(t42, e22) {
+                  if (3 !== t42.length) return e22.error(`Expected 2 arguments, but found ${t42.length - 1} instead.`);
+                  const r22 = e22.parse(t42[1], 1, ut2), n22 = e22.parse(t42[2], 2, bt(e22.expectedType || dt2));
+                  return r22 && n22 ? new me2(n22.type.itemType, r22, n22) : null;
+                }
+                evaluate(t42) {
+                  const e22 = this.index.evaluate(t42), r22 = this.input.evaluate(t42);
+                  if (e22 < 0) throw new ae2(`Array index out of bounds: ${e22} < 0.`);
+                  if (e22 >= r22.length) throw new ae2(`Array index out of bounds: ${e22} > ${r22.length - 1}.`);
+                  if (e22 !== Math.floor(e22)) throw new ae2(`Array index must be an integer, but found ${e22} instead.`);
+                  return r22[e22];
+                }
+                eachChild(t42) {
+                  t42(this.index), t42(this.input);
+                }
+                outputDefined() {
+                  return false;
+                }
+              }
+              class ge2 {
+                constructor(t42, e22) {
+                  this.type = ht2, this.needle = t42, this.haystack = e22;
+                }
+                static parse(t42, e22) {
+                  if (3 !== t42.length) return e22.error(`Expected 2 arguments, but found ${t42.length - 1} instead.`);
+                  const r22 = e22.parse(t42[1], 1, dt2), n22 = e22.parse(t42[2], 2, dt2);
+                  return r22 && n22 ? St(r22.type, [ht2, ct2, ut2, lt2, dt2]) ? new ge2(r22, n22) : e22.error(`Expected first argument to be of type boolean, string, number or null, but found ${wt(r22.type)} instead`) : null;
+                }
+                evaluate(t42) {
+                  const e22 = this.needle.evaluate(t42), r22 = this.haystack.evaluate(t42);
+                  if (!r22) return false;
+                  if (!kt(e22, ["boolean", "string", "number", "null"])) throw new ae2(`Expected first argument to be of type boolean, string, number or null, but found ${wt(ne2(e22))} instead.`);
+                  if (!kt(r22, ["string", "array"])) throw new ae2(`Expected second argument to be of type array or string, but found ${wt(ne2(r22))} instead.`);
+                  return r22.indexOf(e22) >= 0;
+                }
+                eachChild(t42) {
+                  t42(this.needle), t42(this.haystack);
+                }
+                outputDefined() {
+                  return true;
+                }
+              }
+              class xe2 {
+                constructor(t42, e22, r22) {
+                  this.type = ut2, this.needle = t42, this.haystack = e22, this.fromIndex = r22;
+                }
+                static parse(t42, e22) {
+                  if (t42.length <= 2 || t42.length >= 5) return e22.error(`Expected 3 or 4 arguments, but found ${t42.length - 1} instead.`);
+                  const r22 = e22.parse(t42[1], 1, dt2), n22 = e22.parse(t42[2], 2, dt2);
+                  if (!r22 || !n22) return null;
+                  if (!St(r22.type, [ht2, ct2, ut2, lt2, dt2])) return e22.error(`Expected first argument to be of type boolean, string, number or null, but found ${wt(r22.type)} instead`);
+                  if (4 === t42.length) {
+                    const i22 = e22.parse(t42[3], 3, ut2);
+                    return i22 ? new xe2(r22, n22, i22) : null;
+                  }
+                  return new xe2(r22, n22);
+                }
+                evaluate(t42) {
+                  const e22 = this.needle.evaluate(t42), r22 = this.haystack.evaluate(t42);
+                  if (!kt(e22, ["boolean", "string", "number", "null"])) throw new ae2(`Expected first argument to be of type boolean, string, number or null, but found ${wt(ne2(e22))} instead.`);
+                  let n22;
+                  if (this.fromIndex && (n22 = this.fromIndex.evaluate(t42)), kt(r22, ["string"])) {
+                    const t5 = r22.indexOf(e22, n22);
+                    return -1 === t5 ? -1 : [...r22.slice(0, t5)].length;
+                  }
+                  if (kt(r22, ["array"])) return r22.indexOf(e22, n22);
+                  throw new ae2(`Expected second argument to be of type array or string, but found ${wt(ne2(r22))} instead.`);
+                }
+                eachChild(t42) {
+                  t42(this.needle), t42(this.haystack), this.fromIndex && t42(this.fromIndex);
+                }
+                outputDefined() {
+                  return false;
+                }
+              }
+              class ve2 {
+                constructor(t42, e22, r22, n22, i22, s22) {
+                  this.inputType = t42, this.type = e22, this.input = r22, this.cases = n22, this.outputs = i22, this.otherwise = s22;
+                }
+                static parse(t42, e22) {
+                  if (t42.length < 5) return e22.error(`Expected at least 4 arguments, but found only ${t42.length - 1}.`);
+                  if (t42.length % 2 != 1) return e22.error("Expected an even number of arguments.");
+                  let r22, n22;
+                  e22.expectedType && "value" !== e22.expectedType.kind && (n22 = e22.expectedType);
+                  const i22 = {}, s22 = [];
+                  for (let a3 = 2; a3 < t42.length - 1; a3 += 2) {
+                    let o3 = t42[a3];
+                    const l22 = t42[a3 + 1];
+                    Array.isArray(o3) || (o3 = [o3]);
+                    const u22 = e22.concat(a3);
+                    if (0 === o3.length) return u22.error("Expected at least one branch label.");
+                    for (const t5 of o3) {
+                      if ("number" != typeof t5 && "string" != typeof t5) return u22.error("Branch labels must be numbers or strings.");
+                      if ("number" == typeof t5 && Math.abs(t5) > Number.MAX_SAFE_INTEGER) return u22.error(`Branch labels must be integers no larger than ${Number.MAX_SAFE_INTEGER}.`);
+                      if ("number" == typeof t5 && Math.floor(t5) !== t5) return u22.error("Numeric branch labels must be integer values.");
+                      if (r22) {
+                        if (u22.checkSubtype(r22, ne2(t5))) return null;
+                      } else r22 = ne2(t5);
+                      if (void 0 !== i22[String(t5)]) return u22.error("Branch labels must be unique.");
+                      i22[String(t5)] = s22.length;
+                    }
+                    const c22 = e22.parse(l22, a3, n22);
+                    if (!c22) return null;
+                    n22 = n22 || c22.type, s22.push(c22);
+                  }
+                  const a22 = e22.parse(t42[1], 1, dt2);
+                  if (!a22) return null;
+                  const o22 = e22.parse(t42[t42.length - 1], t42.length - 1, n22);
+                  return o22 ? "value" !== a22.type.kind && e22.concat(1).checkSubtype(r22, a22.type) ? null : new ve2(r22, n22, a22, i22, s22, o22) : null;
+                }
+                evaluate(t42) {
+                  const e22 = this.input.evaluate(t42);
+                  return (ne2(e22) === this.inputType && this.outputs[this.cases[e22]] || this.otherwise).evaluate(t42);
+                }
+                eachChild(t42) {
+                  t42(this.input), this.outputs.forEach(t42), t42(this.otherwise);
+                }
+                outputDefined() {
+                  return this.outputs.every((t42) => t42.outputDefined()) && this.otherwise.outputDefined();
+                }
+              }
+              class be2 {
+                constructor(t42, e22, r22) {
+                  this.type = t42, this.branches = e22, this.otherwise = r22;
+                }
+                static parse(t42, e22) {
+                  if (t42.length < 4) return e22.error(`Expected at least 3 arguments, but found only ${t42.length - 1}.`);
+                  if (t42.length % 2 != 0) return e22.error("Expected an odd number of arguments.");
+                  let r22;
+                  e22.expectedType && "value" !== e22.expectedType.kind && (r22 = e22.expectedType);
+                  const n22 = [];
+                  for (let i3 = 1; i3 < t42.length - 1; i3 += 2) {
+                    const s22 = e22.parse(t42[i3], i3, ht2);
+                    if (!s22) return null;
+                    const a22 = e22.parse(t42[i3 + 1], i3 + 1, r22);
+                    if (!a22) return null;
+                    n22.push([s22, a22]), r22 = r22 || a22.type;
+                  }
+                  const i22 = e22.parse(t42[t42.length - 1], t42.length - 1, r22);
+                  if (!i22) return null;
+                  if (!r22) throw new Error("Can't infer output type");
+                  return new be2(r22, n22, i22);
+                }
+                evaluate(t42) {
+                  for (const [e22, r22] of this.branches) if (e22.evaluate(t42)) return r22.evaluate(t42);
+                  return this.otherwise.evaluate(t42);
+                }
+                eachChild(t42) {
+                  for (const [e22, r22] of this.branches) t42(e22), t42(r22);
+                  t42(this.otherwise);
+                }
+                outputDefined() {
+                  return this.branches.every(([t42, e22]) => e22.outputDefined()) && this.otherwise.outputDefined();
+                }
+              }
+              class we2 {
+                constructor(t42, e22, r22, n22) {
+                  this.type = t42, this.input = e22, this.beginIndex = r22, this.endIndex = n22;
+                }
+                static parse(t42, e22) {
+                  if (t42.length <= 2 || t42.length >= 5) return e22.error(`Expected 3 or 4 arguments, but found ${t42.length - 1} instead.`);
+                  const r22 = e22.parse(t42[1], 1, dt2), n22 = e22.parse(t42[2], 2, ut2);
+                  if (!r22 || !n22) return null;
+                  if (!St(r22.type, [bt(dt2), ct2, dt2])) return e22.error(`Expected first argument to be of type array or string, but found ${wt(r22.type)} instead`);
+                  if (4 === t42.length) {
+                    const i22 = e22.parse(t42[3], 3, ut2);
+                    return i22 ? new we2(r22.type, r22, n22, i22) : null;
+                  }
+                  return new we2(r22.type, r22, n22);
+                }
+                evaluate(t42) {
+                  const e22 = this.input.evaluate(t42), r22 = this.beginIndex.evaluate(t42);
+                  let n22;
+                  if (this.endIndex && (n22 = this.endIndex.evaluate(t42)), kt(e22, ["string"])) return [...e22].slice(r22, n22).join("");
+                  if (kt(e22, ["array"])) return e22.slice(r22, n22);
+                  throw new ae2(`Expected first argument to be of type array or string, but found ${wt(ne2(e22))} instead.`);
+                }
+                eachChild(t42) {
+                  t42(this.input), t42(this.beginIndex), this.endIndex && t42(this.endIndex);
+                }
+                outputDefined() {
+                  return false;
+                }
+              }
+              function _e2(t42, e22) {
+                const r22 = t42.length - 1;
+                let n22, i22, s22 = 0, a22 = r22, o22 = 0;
+                for (; s22 <= a22; ) if (o22 = Math.floor((s22 + a22) / 2), n22 = t42[o22], i22 = t42[o22 + 1], n22 <= e22) {
+                  if (o22 === r22 || e22 < i22) return o22;
+                  s22 = o22 + 1;
+                } else {
+                  if (!(n22 > e22)) throw new ae2("Input is not a number.");
+                  a22 = o22 - 1;
+                }
+                return 0;
+              }
+              class Ae2 {
+                constructor(t42, e22, r22) {
+                  this.type = t42, this.input = e22, this.labels = [], this.outputs = [];
+                  for (const [t5, e3] of r22) this.labels.push(t5), this.outputs.push(e3);
+                }
+                static parse(t42, e22) {
+                  if (t42.length - 1 < 4) return e22.error(`Expected at least 4 arguments, but found only ${t42.length - 1}.`);
+                  if ((t42.length - 1) % 2 != 0) return e22.error("Expected an even number of arguments.");
+                  const r22 = e22.parse(t42[1], 1, ut2);
+                  if (!r22) return null;
+                  const n22 = [];
+                  let i22 = null;
+                  e22.expectedType && "value" !== e22.expectedType.kind && (i22 = e22.expectedType);
+                  for (let r3 = 1; r3 < t42.length; r3 += 2) {
+                    const s22 = 1 === r3 ? -1 / 0 : t42[r3], a22 = t42[r3 + 1], o22 = r3, l22 = r3 + 1;
+                    if ("number" != typeof s22) return e22.error('Input/output pairs for "step" expressions must be defined using literal numeric values (not computed expressions) for the input values.', o22);
+                    if (n22.length && n22[n22.length - 1][0] >= s22) return e22.error('Input/output pairs for "step" expressions must be arranged with input values in strictly ascending order.', o22);
+                    const u22 = e22.parse(a22, l22, i22);
+                    if (!u22) return null;
+                    i22 = i22 || u22.type, n22.push([s22, u22]);
+                  }
+                  return new Ae2(i22, r22, n22);
+                }
+                evaluate(t42) {
+                  const e22 = this.labels, r22 = this.outputs;
+                  if (1 === e22.length) return r22[0].evaluate(t42);
+                  const n22 = this.input.evaluate(t42);
+                  if (n22 <= e22[0]) return r22[0].evaluate(t42);
+                  const i22 = e22.length;
+                  return n22 >= e22[i22 - 1] ? r22[i22 - 1].evaluate(t42) : r22[_e2(e22, n22)].evaluate(t42);
+                }
+                eachChild(t42) {
+                  t42(this.input);
+                  for (const e22 of this.outputs) t42(e22);
+                }
+                outputDefined() {
+                  return this.outputs.every((t42) => t42.outputDefined());
+                }
+              }
+              function Se2(t42) {
+                return t42 && t42.__esModule && Object.prototype.hasOwnProperty.call(t42, "default") ? t42.default : t42;
+              }
+              var ke2 = Me2;
+              function Me2(t42, e22, r22, n22) {
+                this.cx = 3 * t42, this.bx = 3 * (r22 - t42) - this.cx, this.ax = 1 - this.cx - this.bx, this.cy = 3 * e22, this.by = 3 * (n22 - e22) - this.cy, this.ay = 1 - this.cy - this.by, this.p1x = t42, this.p1y = e22, this.p2x = r22, this.p2y = n22;
+              }
+              Me2.prototype = { sampleCurveX: function(t42) {
+                return ((this.ax * t42 + this.bx) * t42 + this.cx) * t42;
+              }, sampleCurveY: function(t42) {
+                return ((this.ay * t42 + this.by) * t42 + this.cy) * t42;
+              }, sampleCurveDerivativeX: function(t42) {
+                return (3 * this.ax * t42 + 2 * this.bx) * t42 + this.cx;
+              }, solveCurveX: function(t42, e22) {
+                if (void 0 === e22 && (e22 = 1e-6), t42 < 0) return 0;
+                if (t42 > 1) return 1;
+                for (var r22 = t42, n22 = 0; n22 < 8; n22++) {
+                  var i22 = this.sampleCurveX(r22) - t42;
+                  if (Math.abs(i22) < e22) return r22;
+                  var s22 = this.sampleCurveDerivativeX(r22);
+                  if (Math.abs(s22) < 1e-6) break;
+                  r22 -= i22 / s22;
+                }
+                var a22 = 0, o22 = 1;
+                for (r22 = t42, n22 = 0; n22 < 20 && (i22 = this.sampleCurveX(r22), !(Math.abs(i22 - t42) < e22)); n22++) t42 > i22 ? a22 = r22 : o22 = r22, r22 = 0.5 * (o22 - a22) + a22;
+                return r22;
+              }, solve: function(t42, e22) {
+                return this.sampleCurveY(this.solveCurveX(t42, e22));
+              } };
+              var Ie2 = Se2(ke2);
+              function ze2(t42, e22, r22) {
+                return t42 + r22 * (e22 - t42);
+              }
+              function Pe2(t42, e22, r22) {
+                return t42.map((t5, n22) => ze2(t5, e22[n22], r22));
+              }
+              const Ce2 = { number: ze2, color: function(t42, e22, r22, n22 = "rgb") {
+                switch (n22) {
+                  case "rgb": {
+                    const [n3, i22, s22, a22] = Pe2(t42.rgb, e22.rgb, r22);
+                    return new Kt(n3, i22, s22, a22, false);
+                  }
+                  case "hcl": {
+                    const [n3, i22, s22, a22] = t42.hcl, [o22, l22, u22, c22] = e22.hcl;
+                    let h22, p22;
+                    if (isNaN(n3) || isNaN(o22)) isNaN(n3) ? isNaN(o22) ? h22 = NaN : (h22 = o22, 1 !== s22 && 0 !== s22 || (p22 = l22)) : (h22 = n3, 1 !== u22 && 0 !== u22 || (p22 = i22));
+                    else {
+                      let t5 = o22 - n3;
+                      o22 > n3 && t5 > 180 ? t5 -= 360 : o22 < n3 && n3 - o22 > 180 && (t5 += 360), h22 = n3 + r22 * t5;
+                    }
+                    const [f22, d22, y22, m22] = function([t5, e3, r3, n4]) {
+                      return t5 = isNaN(t5) ? 0 : t5 * Et, Ot([r3, Math.cos(t5) * e3, Math.sin(t5) * e3, n4]);
+                    }([h22, null != p22 ? p22 : ze2(i22, l22, r22), ze2(s22, u22, r22), ze2(a22, c22, r22)]);
+                    return new Kt(f22, d22, y22, m22, false);
+                  }
+                  case "lab": {
+                    const [n3, i22, s22, a22] = Ot(Pe2(t42.lab, e22.lab, r22));
+                    return new Kt(n3, i22, s22, a22, false);
+                  }
+                }
+              }, array: Pe2, padding: function(t42, e22, r22) {
+                return new Jt(Pe2(t42.values, e22.values, r22));
+              }, variableAnchorOffsetCollection: function(t42, e22, r22) {
+                const n22 = t42.values, i22 = e22.values;
+                if (n22.length !== i22.length) throw new ae2(`Cannot interpolate values of different length. from: ${t42.toString()}, to: ${e22.toString()}`);
+                const s22 = [];
+                for (let t5 = 0; t5 < n22.length; t5 += 2) {
+                  if (n22[t5] !== i22[t5]) throw new ae2(`Cannot interpolate values containing mismatched anchors. from[${t5}]: ${n22[t5]}, to[${t5}]: ${i22[t5]}`);
+                  s22.push(n22[t5]);
+                  const [e3, a22] = n22[t5 + 1], [o22, l22] = i22[t5 + 1];
+                  s22.push([ze2(e3, o22, r22), ze2(a22, l22, r22)]);
+                }
+                return new Qt(s22);
+              } };
+              class Be2 {
+                constructor(t42, e22, r22, n22, i22) {
+                  this.type = t42, this.operator = e22, this.interpolation = r22, this.input = n22, this.labels = [], this.outputs = [];
+                  for (const [t5, e3] of i22) this.labels.push(t5), this.outputs.push(e3);
+                }
+                static interpolationFactor(t42, e22, r22, n22) {
+                  let i22 = 0;
+                  if ("exponential" === t42.name) i22 = Ve2(e22, t42.base, r22, n22);
+                  else if ("linear" === t42.name) i22 = Ve2(e22, 1, r22, n22);
+                  else if ("cubic-bezier" === t42.name) {
+                    const s22 = t42.controlPoints;
+                    i22 = new Ie2(s22[0], s22[1], s22[2], s22[3]).solve(Ve2(e22, 1, r22, n22));
+                  }
+                  return i22;
+                }
+                static parse(t42, e22) {
+                  let [r22, n22, i22, ...s22] = t42;
+                  if (!Array.isArray(n22) || 0 === n22.length) return e22.error("Expected an interpolation type expression.", 1);
+                  if ("linear" === n22[0]) n22 = { name: "linear" };
+                  else if ("exponential" === n22[0]) {
+                    const t5 = n22[1];
+                    if ("number" != typeof t5) return e22.error("Exponential interpolation requires a numeric base.", 1, 1);
+                    n22 = { name: "exponential", base: t5 };
+                  } else {
+                    if ("cubic-bezier" !== n22[0]) return e22.error(`Unknown interpolation type ${String(n22[0])}`, 1, 0);
+                    {
+                      const t5 = n22.slice(1);
+                      if (4 !== t5.length || t5.some((t6) => "number" != typeof t6 || t6 < 0 || t6 > 1)) return e22.error("Cubic bezier interpolation requires four numeric arguments with values between 0 and 1.", 1);
+                      n22 = { name: "cubic-bezier", controlPoints: t5 };
+                    }
+                  }
+                  if (t42.length - 1 < 4) return e22.error(`Expected at least 4 arguments, but found only ${t42.length - 1}.`);
+                  if ((t42.length - 1) % 2 != 0) return e22.error("Expected an even number of arguments.");
+                  if (i22 = e22.parse(i22, 2, ut2), !i22) return null;
+                  const a22 = [];
+                  let o22 = null;
+                  "interpolate-hcl" === r22 || "interpolate-lab" === r22 ? o22 = pt2 : e22.expectedType && "value" !== e22.expectedType.kind && (o22 = e22.expectedType);
+                  for (let t5 = 0; t5 < s22.length; t5 += 2) {
+                    const r3 = s22[t5], n3 = s22[t5 + 1], i3 = t5 + 3, l22 = t5 + 4;
+                    if ("number" != typeof r3) return e22.error('Input/output pairs for "interpolate" expressions must be defined using literal numeric values (not computed expressions) for the input values.', i3);
+                    if (a22.length && a22[a22.length - 1][0] >= r3) return e22.error('Input/output pairs for "interpolate" expressions must be arranged with input values in strictly ascending order.', i3);
+                    const u22 = e22.parse(n3, l22, o22);
+                    if (!u22) return null;
+                    o22 = o22 || u22.type, a22.push([r3, u22]);
+                  }
+                  return Mt(o22, ut2) || Mt(o22, pt2) || Mt(o22, gt2) || Mt(o22, vt) || Mt(o22, bt(ut2)) ? new Be2(o22, r22, n22, i22, a22) : e22.error(`Type ${wt(o22)} is not interpolatable.`);
+                }
+                evaluate(t42) {
+                  const e22 = this.labels, r22 = this.outputs;
+                  if (1 === e22.length) return r22[0].evaluate(t42);
+                  const n22 = this.input.evaluate(t42);
+                  if (n22 <= e22[0]) return r22[0].evaluate(t42);
+                  const i22 = e22.length;
+                  if (n22 >= e22[i22 - 1]) return r22[i22 - 1].evaluate(t42);
+                  const s22 = _e2(e22, n22), a22 = Be2.interpolationFactor(this.interpolation, n22, e22[s22], e22[s22 + 1]), o22 = r22[s22].evaluate(t42), l22 = r22[s22 + 1].evaluate(t42);
+                  switch (this.operator) {
+                    case "interpolate":
+                      return Ce2[this.type.kind](o22, l22, a22);
+                    case "interpolate-hcl":
+                      return Ce2.color(o22, l22, a22, "hcl");
+                    case "interpolate-lab":
+                      return Ce2.color(o22, l22, a22, "lab");
+                  }
+                }
+                eachChild(t42) {
+                  t42(this.input);
+                  for (const e22 of this.outputs) t42(e22);
+                }
+                outputDefined() {
+                  return this.outputs.every((t42) => t42.outputDefined());
+                }
+              }
+              function Ve2(t42, e22, r22, n22) {
+                const i22 = n22 - r22, s22 = t42 - r22;
+                return 0 === i22 ? 0 : 1 === e22 ? s22 / i22 : (Math.pow(e22, s22) - 1) / (Math.pow(e22, i22) - 1);
+              }
+              class Ee2 {
+                constructor(t42, e22) {
+                  this.type = t42, this.args = e22;
+                }
+                static parse(t42, e22) {
+                  if (t42.length < 2) return e22.error("Expectected at least one argument.");
+                  let r22 = null;
+                  const n22 = e22.expectedType;
+                  n22 && "value" !== n22.kind && (r22 = n22);
+                  const i22 = [];
+                  for (const n3 of t42.slice(1)) {
+                    const t5 = e22.parse(n3, 1 + i22.length, r22, void 0, { typeAnnotation: "omit" });
+                    if (!t5) return null;
+                    r22 = r22 || t5.type, i22.push(t5);
+                  }
+                  if (!r22) throw new Error("No output type");
+                  const s22 = n22 && i22.some((t5) => At(n22, t5.type));
+                  return new Ee2(s22 ? dt2 : r22, i22);
+                }
+                evaluate(t42) {
+                  let e22, r22 = null, n22 = 0;
+                  for (const i22 of this.args) if (n22++, r22 = i22.evaluate(t42), r22 && r22 instanceof te2 && !r22.available && (e22 || (e22 = r22.name), r22 = null, n22 === this.args.length && (r22 = e22)), null !== r22) break;
+                  return r22;
+                }
+                eachChild(t42) {
+                  this.args.forEach(t42);
+                }
+                outputDefined() {
+                  return this.args.every((t42) => t42.outputDefined());
+                }
+              }
+              function Fe2(t42, e22) {
+                return "==" === t42 || "!=" === t42 ? "boolean" === e22.kind || "string" === e22.kind || "number" === e22.kind || "null" === e22.kind || "value" === e22.kind : "string" === e22.kind || "number" === e22.kind || "value" === e22.kind;
+              }
+              function Te2(t42, e22, r22, n22) {
+                return 0 === n22.compare(e22, r22);
+              }
+              function $e2(t42, e22, r22) {
+                const n22 = "==" !== t42 && "!=" !== t42;
+                return class i22 {
+                  constructor(t5, e3, r3) {
+                    this.type = ht2, this.lhs = t5, this.rhs = e3, this.collator = r3, this.hasUntypedArgument = "value" === t5.type.kind || "value" === e3.type.kind;
+                  }
+                  static parse(t5, e3) {
+                    if (3 !== t5.length && 4 !== t5.length) return e3.error("Expected two or three arguments.");
+                    const r3 = t5[0];
+                    let s22 = e3.parse(t5[1], 1, dt2);
+                    if (!s22) return null;
+                    if (!Fe2(r3, s22.type)) return e3.concat(1).error(`"${r3}" comparisons are not supported for type '${wt(s22.type)}'.`);
+                    let a22 = e3.parse(t5[2], 2, dt2);
+                    if (!a22) return null;
+                    if (!Fe2(r3, a22.type)) return e3.concat(2).error(`"${r3}" comparisons are not supported for type '${wt(a22.type)}'.`);
+                    if (s22.type.kind !== a22.type.kind && "value" !== s22.type.kind && "value" !== a22.type.kind) return e3.error(`Cannot compare types '${wt(s22.type)}' and '${wt(a22.type)}'.`);
+                    n22 && ("value" === s22.type.kind && "value" !== a22.type.kind ? s22 = new le2(a22.type, [s22]) : "value" !== s22.type.kind && "value" === a22.type.kind && (a22 = new le2(s22.type, [a22])));
+                    let o22 = null;
+                    if (4 === t5.length) {
+                      if ("string" !== s22.type.kind && "string" !== a22.type.kind && "value" !== s22.type.kind && "value" !== a22.type.kind) return e3.error("Cannot use collator to compare non-string types.");
+                      if (o22 = e3.parse(t5[3], 3, yt), !o22) return null;
+                    }
+                    return new i22(s22, a22, o22);
+                  }
+                  evaluate(i3) {
+                    const s22 = this.lhs.evaluate(i3), a22 = this.rhs.evaluate(i3);
+                    if (n22 && this.hasUntypedArgument) {
+                      const e3 = ne2(s22), r3 = ne2(a22);
+                      if (e3.kind !== r3.kind || "string" !== e3.kind && "number" !== e3.kind) throw new ae2(`Expected arguments for "${t42}" to be (string, string) or (number, number), but found (${e3.kind}, ${r3.kind}) instead.`);
+                    }
+                    if (this.collator && !n22 && this.hasUntypedArgument) {
+                      const t5 = ne2(s22), r3 = ne2(a22);
+                      if ("string" !== t5.kind || "string" !== r3.kind) return e22(i3, s22, a22);
+                    }
+                    return this.collator ? r22(i3, s22, a22, this.collator.evaluate(i3)) : e22(i3, s22, a22);
+                  }
+                  eachChild(t5) {
+                    t5(this.lhs), t5(this.rhs), this.collator && t5(this.collator);
+                  }
+                  outputDefined() {
+                    return true;
+                  }
+                };
+              }
+              const Le2 = $e2("==", function(t42, e22, r22) {
+                return e22 === r22;
+              }, Te2), De2 = $e2("!=", function(t42, e22, r22) {
+                return e22 !== r22;
+              }, function(t42, e22, r22, n22) {
+                return !Te2(0, e22, r22, n22);
+              }), Oe2 = $e2("<", function(t42, e22, r22) {
+                return e22 < r22;
+              }, function(t42, e22, r22, n22) {
+                return n22.compare(e22, r22) < 0;
+              }), je2 = $e2(">", function(t42, e22, r22) {
+                return e22 > r22;
+              }, function(t42, e22, r22, n22) {
+                return n22.compare(e22, r22) > 0;
+              }), Re2 = $e2("<=", function(t42, e22, r22) {
+                return e22 <= r22;
+              }, function(t42, e22, r22, n22) {
+                return n22.compare(e22, r22) <= 0;
+              }), Ue2 = $e2(">=", function(t42, e22, r22) {
+                return e22 >= r22;
+              }, function(t42, e22, r22, n22) {
+                return n22.compare(e22, r22) >= 0;
+              });
+              class qe2 {
+                constructor(t42, e22, r22) {
+                  this.type = yt, this.locale = r22, this.caseSensitive = t42, this.diacriticSensitive = e22;
+                }
+                static parse(t42, e22) {
+                  if (2 !== t42.length) return e22.error("Expected one argument.");
+                  const r22 = t42[1];
+                  if ("object" != typeof r22 || Array.isArray(r22)) return e22.error("Collator options argument must be an object.");
+                  const n22 = e22.parse(void 0 !== r22["case-sensitive"] && r22["case-sensitive"], 1, ht2);
+                  if (!n22) return null;
+                  const i22 = e22.parse(void 0 !== r22["diacritic-sensitive"] && r22["diacritic-sensitive"], 1, ht2);
+                  if (!i22) return null;
+                  let s22 = null;
+                  return r22.locale && (s22 = e22.parse(r22.locale, 1, ct2), !s22) ? null : new qe2(n22, i22, s22);
+                }
+                evaluate(t42) {
+                  return new Xt(this.caseSensitive.evaluate(t42), this.diacriticSensitive.evaluate(t42), this.locale ? this.locale.evaluate(t42) : null);
+                }
+                eachChild(t42) {
+                  t42(this.caseSensitive), t42(this.diacriticSensitive), this.locale && t42(this.locale);
+                }
+                outputDefined() {
+                  return false;
+                }
+              }
+              class Ne2 {
+                constructor(t42, e22, r22, n22, i22) {
+                  this.type = ct2, this.number = t42, this.locale = e22, this.currency = r22, this.minFractionDigits = n22, this.maxFractionDigits = i22;
+                }
+                static parse(t42, e22) {
+                  if (3 !== t42.length) return e22.error("Expected two arguments.");
+                  const r22 = e22.parse(t42[1], 1, ut2);
+                  if (!r22) return null;
+                  const n22 = t42[2];
+                  if ("object" != typeof n22 || Array.isArray(n22)) return e22.error("NumberFormat options argument must be an object.");
+                  let i22 = null;
+                  if (n22.locale && (i22 = e22.parse(n22.locale, 1, ct2), !i22)) return null;
+                  let s22 = null;
+                  if (n22.currency && (s22 = e22.parse(n22.currency, 1, ct2), !s22)) return null;
+                  let a22 = null;
+                  if (n22["min-fraction-digits"] && (a22 = e22.parse(n22["min-fraction-digits"], 1, ut2), !a22)) return null;
+                  let o22 = null;
+                  return n22["max-fraction-digits"] && (o22 = e22.parse(n22["max-fraction-digits"], 1, ut2), !o22) ? null : new Ne2(r22, i22, s22, a22, o22);
+                }
+                evaluate(t42) {
+                  return new Intl.NumberFormat(this.locale ? this.locale.evaluate(t42) : [], { style: this.currency ? "currency" : "decimal", currency: this.currency ? this.currency.evaluate(t42) : void 0, minimumFractionDigits: this.minFractionDigits ? this.minFractionDigits.evaluate(t42) : void 0, maximumFractionDigits: this.maxFractionDigits ? this.maxFractionDigits.evaluate(t42) : void 0 }).format(this.number.evaluate(t42));
+                }
+                eachChild(t42) {
+                  t42(this.number), this.locale && t42(this.locale), this.currency && t42(this.currency), this.minFractionDigits && t42(this.minFractionDigits), this.maxFractionDigits && t42(this.maxFractionDigits);
+                }
+                outputDefined() {
+                  return false;
+                }
+              }
+              class Ze2 {
+                constructor(t42) {
+                  this.type = mt2, this.sections = t42;
+                }
+                static parse(t42, e22) {
+                  if (t42.length < 2) return e22.error("Expected at least one argument.");
+                  const r22 = t42[1];
+                  if (!Array.isArray(r22) && "object" == typeof r22) return e22.error("First argument must be an image or text section.");
+                  const n22 = [];
+                  let i22 = false;
+                  for (let r3 = 1; r3 <= t42.length - 1; ++r3) {
+                    const s22 = t42[r3];
+                    if (i22 && "object" == typeof s22 && !Array.isArray(s22)) {
+                      i22 = false;
+                      let t5 = null;
+                      if (s22["font-scale"] && (t5 = e22.parse(s22["font-scale"], 1, ut2), !t5)) return null;
+                      let r4 = null;
+                      if (s22["text-font"] && (r4 = e22.parse(s22["text-font"], 1, bt(ct2)), !r4)) return null;
+                      let a22 = null;
+                      if (s22["text-color"] && (a22 = e22.parse(s22["text-color"], 1, pt2), !a22)) return null;
+                      const o22 = n22[n22.length - 1];
+                      o22.scale = t5, o22.font = r4, o22.textColor = a22;
+                    } else {
+                      const s3 = e22.parse(t42[r3], 1, dt2);
+                      if (!s3) return null;
+                      const a22 = s3.type.kind;
+                      if ("string" !== a22 && "value" !== a22 && "null" !== a22 && "resolvedImage" !== a22) return e22.error("Formatted text type must be 'string', 'value', 'image' or 'null'.");
+                      i22 = true, n22.push({ content: s3, scale: null, font: null, textColor: null });
+                    }
+                  }
+                  return new Ze2(n22);
+                }
+                evaluate(t42) {
+                  return new Yt(this.sections.map((e22) => {
+                    const r22 = e22.content.evaluate(t42);
+                    return ne2(r22) === xt ? new Ht("", r22, null, null, null) : new Ht(ie2(r22), null, e22.scale ? e22.scale.evaluate(t42) : null, e22.font ? e22.font.evaluate(t42).join(",") : null, e22.textColor ? e22.textColor.evaluate(t42) : null);
+                  }));
+                }
+                eachChild(t42) {
+                  for (const e22 of this.sections) t42(e22.content), e22.scale && t42(e22.scale), e22.font && t42(e22.font), e22.textColor && t42(e22.textColor);
+                }
+                outputDefined() {
+                  return false;
+                }
+              }
+              class Ge2 {
+                constructor(t42) {
+                  this.type = xt, this.input = t42;
+                }
+                static parse(t42, e22) {
+                  if (2 !== t42.length) return e22.error("Expected two arguments.");
+                  const r22 = e22.parse(t42[1], 1, ct2);
+                  return r22 ? new Ge2(r22) : e22.error("No image name provided.");
+                }
+                evaluate(t42) {
+                  const e22 = this.input.evaluate(t42), r22 = te2.fromString(e22);
+                  return r22 && t42.availableImages && (r22.available = t42.availableImages.indexOf(e22) > -1), r22;
+                }
+                eachChild(t42) {
+                  t42(this.input);
+                }
+                outputDefined() {
+                  return false;
+                }
+              }
+              class Ke2 {
+                constructor(t42) {
+                  this.type = ut2, this.input = t42;
+                }
+                static parse(t42, e22) {
+                  if (2 !== t42.length) return e22.error(`Expected 1 argument, but found ${t42.length - 1} instead.`);
+                  const r22 = e22.parse(t42[1], 1);
+                  return r22 ? "array" !== r22.type.kind && "string" !== r22.type.kind && "value" !== r22.type.kind ? e22.error(`Expected argument of type string or array, but found ${wt(r22.type)} instead.`) : new Ke2(r22) : null;
+                }
+                evaluate(t42) {
+                  const e22 = this.input.evaluate(t42);
+                  if ("string" == typeof e22) return [...e22].length;
+                  if (Array.isArray(e22)) return e22.length;
+                  throw new ae2(`Expected value to be of type string or array, but found ${wt(ne2(e22))} instead.`);
+                }
+                eachChild(t42) {
+                  t42(this.input);
+                }
+                outputDefined() {
+                  return false;
+                }
+              }
+              const Xe2 = 8192;
+              function He2(t42, e22) {
+                const r22 = (180 + t42[0]) / 360, n22 = (180 - 180 / Math.PI * Math.log(Math.tan(Math.PI / 4 + t42[1] * Math.PI / 360))) / 360, i22 = Math.pow(2, e22.z);
+                return [Math.round(r22 * i22 * Xe2), Math.round(n22 * i22 * Xe2)];
+              }
+              function Ye2(t42, e22) {
+                const r22 = Math.pow(2, e22.z);
+                return [(i22 = (t42[0] / Xe2 + e22.x) / r22, 360 * i22 - 180), (n22 = (t42[1] / Xe2 + e22.y) / r22, 360 / Math.PI * Math.atan(Math.exp((180 - 360 * n22) * Math.PI / 180)) - 90)];
+                var n22, i22;
+              }
+              function Je2(t42, e22) {
+                t42[0] = Math.min(t42[0], e22[0]), t42[1] = Math.min(t42[1], e22[1]), t42[2] = Math.max(t42[2], e22[0]), t42[3] = Math.max(t42[3], e22[1]);
+              }
+              function We2(t42, e22) {
+                return !(t42[0] <= e22[0] || t42[2] >= e22[2] || t42[1] <= e22[1] || t42[3] >= e22[3]);
+              }
+              function Qe2(t42, e22, r22) {
+                const n22 = t42[0] - e22[0], i22 = t42[1] - e22[1], s22 = t42[0] - r22[0], a22 = t42[1] - r22[1];
+                return n22 * a22 - s22 * i22 == 0 && n22 * s22 <= 0 && i22 * a22 <= 0;
+              }
+              function tr(t42, e22, r22, n22) {
+                return 0 != (i22 = [n22[0] - r22[0], n22[1] - r22[1]])[0] * (s22 = [e22[0] - t42[0], e22[1] - t42[1]])[1] - i22[1] * s22[0] && !(!ar(t42, e22, r22, n22) || !ar(r22, n22, t42, e22));
+                var i22, s22;
+              }
+              function er(t42, e22, r22) {
+                for (const n22 of r22) for (let r3 = 0; r3 < n22.length - 1; ++r3) if (tr(t42, e22, n22[r3], n22[r3 + 1])) return true;
+                return false;
+              }
+              function rr(t42, e22, r22 = false) {
+                let n22 = false;
+                for (const o22 of e22) for (let e3 = 0; e3 < o22.length - 1; e3++) {
+                  if (Qe2(t42, o22[e3], o22[e3 + 1])) return r22;
+                  (s22 = o22[e3])[1] > (i22 = t42)[1] != (a22 = o22[e3 + 1])[1] > i22[1] && i22[0] < (a22[0] - s22[0]) * (i22[1] - s22[1]) / (a22[1] - s22[1]) + s22[0] && (n22 = !n22);
+                }
+                var i22, s22, a22;
+                return n22;
+              }
+              function nr(t42, e22) {
+                for (const r22 of e22) if (rr(t42, r22)) return true;
+                return false;
+              }
+              function ir(t42, e22) {
+                for (const r22 of t42) if (!rr(r22, e22)) return false;
+                for (let r22 = 0; r22 < t42.length - 1; ++r22) if (er(t42[r22], t42[r22 + 1], e22)) return false;
+                return true;
+              }
+              function sr(t42, e22) {
+                for (const r22 of e22) if (ir(t42, r22)) return true;
+                return false;
+              }
+              function ar(t42, e22, r22, n22) {
+                const i22 = n22[0] - r22[0], s22 = n22[1] - r22[1], a22 = (t42[0] - r22[0]) * s22 - i22 * (t42[1] - r22[1]), o22 = (e22[0] - r22[0]) * s22 - i22 * (e22[1] - r22[1]);
+                return a22 > 0 && o22 < 0 || a22 < 0 && o22 > 0;
+              }
+              function or(t42, e22, r22) {
+                const n22 = [];
+                for (let i22 = 0; i22 < t42.length; i22++) {
+                  const s22 = [];
+                  for (let n3 = 0; n3 < t42[i22].length; n3++) {
+                    const a22 = He2(t42[i22][n3], r22);
+                    Je2(e22, a22), s22.push(a22);
+                  }
+                  n22.push(s22);
+                }
+                return n22;
+              }
+              function lr(t42, e22, r22) {
+                const n22 = [];
+                for (let i22 = 0; i22 < t42.length; i22++) {
+                  const s22 = or(t42[i22], e22, r22);
+                  n22.push(s22);
+                }
+                return n22;
+              }
+              function ur(t42, e22, r22, n22) {
+                if (t42[0] < r22[0] || t42[0] > r22[2]) {
+                  const e3 = 0.5 * n22;
+                  let i22 = t42[0] - r22[0] > e3 ? -n22 : r22[0] - t42[0] > e3 ? n22 : 0;
+                  0 === i22 && (i22 = t42[0] - r22[2] > e3 ? -n22 : r22[2] - t42[0] > e3 ? n22 : 0), t42[0] += i22;
+                }
+                Je2(e22, t42);
+              }
+              function cr(t42, e22, r22, n22) {
+                const i22 = Math.pow(2, n22.z) * Xe2, s22 = [n22.x * Xe2, n22.y * Xe2], a22 = [];
+                for (const n3 of t42) for (const t5 of n3) {
+                  const n4 = [t5.x + s22[0], t5.y + s22[1]];
+                  ur(n4, e22, r22, i22), a22.push(n4);
+                }
+                return a22;
+              }
+              function hr(t42, e22, r22, n22) {
+                const i22 = Math.pow(2, n22.z) * Xe2, s22 = [n22.x * Xe2, n22.y * Xe2], a22 = [];
+                for (const r3 of t42) {
+                  const t5 = [];
+                  for (const n3 of r3) {
+                    const r4 = [n3.x + s22[0], n3.y + s22[1]];
+                    Je2(e22, r4), t5.push(r4);
+                  }
+                  a22.push(t5);
+                }
+                if (e22[2] - e22[0] <= i22 / 2) {
+                  (o22 = e22)[0] = o22[1] = 1 / 0, o22[2] = o22[3] = -1 / 0;
+                  for (const t5 of a22) for (const n3 of t5) ur(n3, e22, r22, i22);
+                }
+                var o22;
+                return a22;
+              }
+              class pr {
+                constructor(t42, e22) {
+                  this.type = ht2, this.geojson = t42, this.geometries = e22;
+                }
+                static parse(t42, e22) {
+                  if (2 !== t42.length) return e22.error(`'within' expression requires exactly one argument, but found ${t42.length - 1} instead.`);
+                  if (re2(t42[1])) {
+                    const e3 = t42[1];
+                    if ("FeatureCollection" === e3.type) {
+                      const t5 = [];
+                      for (const r22 of e3.features) {
+                        const { type: e4, coordinates: n22 } = r22.geometry;
+                        "Polygon" === e4 && t5.push(n22), "MultiPolygon" === e4 && t5.push(...n22);
+                      }
+                      if (t5.length) return new pr(e3, { type: "MultiPolygon", coordinates: t5 });
+                    } else if ("Feature" === e3.type) {
+                      const t5 = e3.geometry.type;
+                      if ("Polygon" === t5 || "MultiPolygon" === t5) return new pr(e3, e3.geometry);
+                    } else if ("Polygon" === e3.type || "MultiPolygon" === e3.type) return new pr(e3, e3);
+                  }
+                  return e22.error("'within' expression requires valid geojson object that contains polygon geometry type.");
+                }
+                evaluate(t42) {
+                  if (null != t42.geometry() && null != t42.canonicalID()) {
+                    if ("Point" === t42.geometryType()) return function(t5, e22) {
+                      const r22 = [1 / 0, 1 / 0, -1 / 0, -1 / 0], n22 = [1 / 0, 1 / 0, -1 / 0, -1 / 0], i22 = t5.canonicalID();
+                      if ("Polygon" === e22.type) {
+                        const s22 = or(e22.coordinates, n22, i22), a22 = cr(t5.geometry(), r22, n22, i22);
+                        if (!We2(r22, n22)) return false;
+                        for (const t6 of a22) if (!rr(t6, s22)) return false;
+                      }
+                      if ("MultiPolygon" === e22.type) {
+                        const s22 = lr(e22.coordinates, n22, i22), a22 = cr(t5.geometry(), r22, n22, i22);
+                        if (!We2(r22, n22)) return false;
+                        for (const t6 of a22) if (!nr(t6, s22)) return false;
+                      }
+                      return true;
+                    }(t42, this.geometries);
+                    if ("LineString" === t42.geometryType()) return function(t5, e22) {
+                      const r22 = [1 / 0, 1 / 0, -1 / 0, -1 / 0], n22 = [1 / 0, 1 / 0, -1 / 0, -1 / 0], i22 = t5.canonicalID();
+                      if ("Polygon" === e22.type) {
+                        const s22 = or(e22.coordinates, n22, i22), a22 = hr(t5.geometry(), r22, n22, i22);
+                        if (!We2(r22, n22)) return false;
+                        for (const t6 of a22) if (!ir(t6, s22)) return false;
+                      }
+                      if ("MultiPolygon" === e22.type) {
+                        const s22 = lr(e22.coordinates, n22, i22), a22 = hr(t5.geometry(), r22, n22, i22);
+                        if (!We2(r22, n22)) return false;
+                        for (const t6 of a22) if (!sr(t6, s22)) return false;
+                      }
+                      return true;
+                    }(t42, this.geometries);
+                  }
+                  return false;
+                }
+                eachChild() {
+                }
+                outputDefined() {
+                  return true;
+                }
+              }
+              let fr = class {
+                constructor(t42 = [], e22 = (t5, e3) => t5 < e3 ? -1 : t5 > e3 ? 1 : 0) {
+                  if (this.data = t42, this.length = this.data.length, this.compare = e22, this.length > 0) for (let t5 = (this.length >> 1) - 1; t5 >= 0; t5--) this._down(t5);
+                }
+                push(t42) {
+                  this.data.push(t42), this._up(this.length++);
+                }
+                pop() {
+                  if (0 === this.length) return;
+                  const t42 = this.data[0], e22 = this.data.pop();
+                  return --this.length > 0 && (this.data[0] = e22, this._down(0)), t42;
+                }
+                peek() {
+                  return this.data[0];
+                }
+                _up(t42) {
+                  const { data: e22, compare: r22 } = this, n22 = e22[t42];
+                  for (; t42 > 0; ) {
+                    const i22 = t42 - 1 >> 1, s22 = e22[i22];
+                    if (r22(n22, s22) >= 0) break;
+                    e22[t42] = s22, t42 = i22;
+                  }
+                  e22[t42] = n22;
+                }
+                _down(t42) {
+                  const { data: e22, compare: r22 } = this, n22 = this.length >> 1, i22 = e22[t42];
+                  for (; t42 < n22; ) {
+                    let n3 = 1 + (t42 << 1);
+                    const s22 = n3 + 1;
+                    if (s22 < this.length && r22(e22[s22], e22[n3]) < 0 && (n3 = s22), r22(e22[n3], i22) >= 0) break;
+                    e22[t42] = e22[n3], t42 = n3;
+                  }
+                  e22[t42] = i22;
+                }
+              };
+              function dr(t42, e22, r22, n22, i22) {
+                yr(t42, e22, r22, n22 || t42.length - 1, i22 || gr);
+              }
+              function yr(t42, e22, r22, n22, i22) {
+                for (; n22 > r22; ) {
+                  if (n22 - r22 > 600) {
+                    var s22 = n22 - r22 + 1, a22 = e22 - r22 + 1, o22 = Math.log(s22), l22 = 0.5 * Math.exp(2 * o22 / 3), u22 = 0.5 * Math.sqrt(o22 * l22 * (s22 - l22) / s22) * (a22 - s22 / 2 < 0 ? -1 : 1);
+                    yr(t42, e22, Math.max(r22, Math.floor(e22 - a22 * l22 / s22 + u22)), Math.min(n22, Math.floor(e22 + (s22 - a22) * l22 / s22 + u22)), i22);
+                  }
+                  var c22 = t42[e22], h22 = r22, p22 = n22;
+                  for (mr(t42, r22, e22), i22(t42[n22], c22) > 0 && mr(t42, r22, n22); h22 < p22; ) {
+                    for (mr(t42, h22, p22), h22++, p22--; i22(t42[h22], c22) < 0; ) h22++;
+                    for (; i22(t42[p22], c22) > 0; ) p22--;
+                  }
+                  0 === i22(t42[r22], c22) ? mr(t42, r22, p22) : mr(t42, ++p22, n22), p22 <= e22 && (r22 = p22 + 1), e22 <= p22 && (n22 = p22 - 1);
+                }
+              }
+              function mr(t42, e22, r22) {
+                var n22 = t42[e22];
+                t42[e22] = t42[r22], t42[r22] = n22;
+              }
+              function gr(t42, e22) {
+                return t42 < e22 ? -1 : t42 > e22 ? 1 : 0;
+              }
+              function xr(t42, e22) {
+                if (t42.length <= 1) return [t42];
+                const r22 = [];
+                let n22, i22;
+                for (const e3 of t42) {
+                  const t5 = br(e3);
+                  0 !== t5 && (e3.area = Math.abs(t5), void 0 === i22 && (i22 = t5 < 0), i22 === t5 < 0 ? (n22 && r22.push(n22), n22 = [e3]) : n22.push(e3));
+                }
+                if (n22 && r22.push(n22), e22 > 1) for (let t5 = 0; t5 < r22.length; t5++) r22[t5].length <= e22 || (dr(r22[t5], e22, 1, r22[t5].length - 1, vr), r22[t5] = r22[t5].slice(0, e22));
+                return r22;
+              }
+              function vr(t42, e22) {
+                return e22.area - t42.area;
+              }
+              function br(t42) {
+                let e22 = 0;
+                for (let r22, n22, i22 = 0, s22 = t42.length, a22 = s22 - 1; i22 < s22; a22 = i22++) r22 = t42[i22], n22 = t42[a22], e22 += (n22.x - r22.x) * (r22.y + n22.y);
+                return e22;
+              }
+              const wr = 1 / 298.257223563, _r2 = wr * (2 - wr), Ar = Math.PI / 180;
+              class Sr {
+                constructor(t42) {
+                  const e22 = 6378.137 * Ar * 1e3, r22 = Math.cos(t42 * Ar), n22 = 1 / (1 - _r2 * (1 - r22 * r22)), i22 = Math.sqrt(n22);
+                  this.kx = e22 * i22 * r22, this.ky = e22 * i22 * n22 * (1 - _r2);
+                }
+                distance(t42, e22) {
+                  const r22 = this.wrap(t42[0] - e22[0]) * this.kx, n22 = (t42[1] - e22[1]) * this.ky;
+                  return Math.sqrt(r22 * r22 + n22 * n22);
+                }
+                pointOnLine(t42, e22) {
+                  let r22, n22, i22, s22, a22 = 1 / 0;
+                  for (let o22 = 0; o22 < t42.length - 1; o22++) {
+                    let l22 = t42[o22][0], u22 = t42[o22][1], c22 = this.wrap(t42[o22 + 1][0] - l22) * this.kx, h22 = (t42[o22 + 1][1] - u22) * this.ky, p22 = 0;
+                    0 === c22 && 0 === h22 || (p22 = (this.wrap(e22[0] - l22) * this.kx * c22 + (e22[1] - u22) * this.ky * h22) / (c22 * c22 + h22 * h22), p22 > 1 ? (l22 = t42[o22 + 1][0], u22 = t42[o22 + 1][1]) : p22 > 0 && (l22 += c22 / this.kx * p22, u22 += h22 / this.ky * p22)), c22 = this.wrap(e22[0] - l22) * this.kx, h22 = (e22[1] - u22) * this.ky;
+                    const f22 = c22 * c22 + h22 * h22;
+                    f22 < a22 && (a22 = f22, r22 = l22, n22 = u22, i22 = o22, s22 = p22);
+                  }
+                  return { point: [r22, n22], index: i22, t: Math.max(0, Math.min(1, s22)) };
+                }
+                wrap(t42) {
+                  for (; t42 < -180; ) t42 += 360;
+                  for (; t42 > 180; ) t42 -= 360;
+                  return t42;
+                }
+              }
+              function kr(t42, e22) {
+                return e22[0] - t42[0];
+              }
+              function Mr(t42) {
+                return t42[1] - t42[0] + 1;
+              }
+              function Ir(t42, e22) {
+                return t42[1] >= t42[0] && t42[1] < e22;
+              }
+              function zr(t42, e22) {
+                if (t42[0] > t42[1]) return [null, null];
+                const r22 = Mr(t42);
+                if (e22) {
+                  if (2 === r22) return [t42, null];
+                  const e3 = Math.floor(r22 / 2);
+                  return [[t42[0], t42[0] + e3], [t42[0] + e3, t42[1]]];
+                }
+                if (1 === r22) return [t42, null];
+                const n22 = Math.floor(r22 / 2) - 1;
+                return [[t42[0], t42[0] + n22], [t42[0] + n22 + 1, t42[1]]];
+              }
+              function Pr(t42, e22) {
+                if (!Ir(e22, t42.length)) return [1 / 0, 1 / 0, -1 / 0, -1 / 0];
+                const r22 = [1 / 0, 1 / 0, -1 / 0, -1 / 0];
+                for (let n22 = e22[0]; n22 <= e22[1]; ++n22) Je2(r22, t42[n22]);
+                return r22;
+              }
+              function Cr(t42) {
+                const e22 = [1 / 0, 1 / 0, -1 / 0, -1 / 0];
+                for (const r22 of t42) for (const t5 of r22) Je2(e22, t5);
+                return e22;
+              }
+              function Br(t42) {
+                return t42[0] !== -1 / 0 && t42[1] !== -1 / 0 && t42[2] !== 1 / 0 && t42[3] !== 1 / 0;
+              }
+              function Vr(t42, e22, r22) {
+                if (!Br(t42) || !Br(e22)) return NaN;
+                let n22 = 0, i22 = 0;
+                return t42[2] < e22[0] && (n22 = e22[0] - t42[2]), t42[0] > e22[2] && (n22 = t42[0] - e22[2]), t42[1] > e22[3] && (i22 = t42[1] - e22[3]), t42[3] < e22[1] && (i22 = e22[1] - t42[3]), r22.distance([0, 0], [n22, i22]);
+              }
+              function Er(t42, e22, r22) {
+                const n22 = r22.pointOnLine(e22, t42);
+                return r22.distance(t42, n22.point);
+              }
+              function Fr(t42, e22, r22, n22, i22) {
+                const s22 = Math.min(Er(t42, [r22, n22], i22), Er(e22, [r22, n22], i22)), a22 = Math.min(Er(r22, [t42, e22], i22), Er(n22, [t42, e22], i22));
+                return Math.min(s22, a22);
+              }
+              function Tr(t42, e22, r22, n22, i22) {
+                if (!Ir(e22, t42.length) || !Ir(n22, r22.length)) return 1 / 0;
+                let s22 = 1 / 0;
+                for (let a22 = e22[0]; a22 < e22[1]; ++a22) {
+                  const e3 = t42[a22], o22 = t42[a22 + 1];
+                  for (let t5 = n22[0]; t5 < n22[1]; ++t5) {
+                    const n3 = r22[t5], a3 = r22[t5 + 1];
+                    if (tr(e3, o22, n3, a3)) return 0;
+                    s22 = Math.min(s22, Fr(e3, o22, n3, a3, i22));
+                  }
+                }
+                return s22;
+              }
+              function $r(t42, e22, r22, n22, i22) {
+                if (!Ir(e22, t42.length) || !Ir(n22, r22.length)) return NaN;
+                let s22 = 1 / 0;
+                for (let a22 = e22[0]; a22 <= e22[1]; ++a22) for (let e3 = n22[0]; e3 <= n22[1]; ++e3) if (s22 = Math.min(s22, i22.distance(t42[a22], r22[e3])), 0 === s22) return s22;
+                return s22;
+              }
+              function Lr(t42, e22, r22) {
+                if (rr(t42, e22, true)) return 0;
+                let n22 = 1 / 0;
+                for (const i22 of e22) {
+                  const e3 = i22[0], s22 = i22[i22.length - 1];
+                  if (e3 !== s22 && (n22 = Math.min(n22, Er(t42, [s22, e3], r22)), 0 === n22)) return n22;
+                  const a22 = r22.pointOnLine(i22, t42);
+                  if (n22 = Math.min(n22, r22.distance(t42, a22.point)), 0 === n22) return n22;
+                }
+                return n22;
+              }
+              function Dr(t42, e22, r22, n22) {
+                if (!Ir(e22, t42.length)) return NaN;
+                for (let n3 = e22[0]; n3 <= e22[1]; ++n3) if (rr(t42[n3], r22, true)) return 0;
+                let i22 = 1 / 0;
+                for (let s22 = e22[0]; s22 < e22[1]; ++s22) {
+                  const e3 = t42[s22], a22 = t42[s22 + 1];
+                  for (const t5 of r22) for (let r3 = 0, s3 = t5.length, o22 = s3 - 1; r3 < s3; o22 = r3++) {
+                    const s4 = t5[o22], l22 = t5[r3];
+                    if (tr(e3, a22, s4, l22)) return 0;
+                    i22 = Math.min(i22, Fr(e3, a22, s4, l22, n22));
+                  }
+                }
+                return i22;
+              }
+              function Or(t42, e22) {
+                for (const r22 of t42) for (const t5 of r22) if (rr(t5, e22, true)) return true;
+                return false;
+              }
+              function jr(t42, e22, r22, n22 = 1 / 0) {
+                const i22 = Cr(t42), s22 = Cr(e22);
+                if (n22 !== 1 / 0 && Vr(i22, s22, r22) >= n22) return n22;
+                if (We2(i22, s22)) {
+                  if (Or(t42, e22)) return 0;
+                } else if (Or(e22, t42)) return 0;
+                let a22 = 1 / 0;
+                for (const n3 of t42) for (let t5 = 0, i3 = n3.length, s3 = i3 - 1; t5 < i3; s3 = t5++) {
+                  const i4 = n3[s3], o22 = n3[t5];
+                  for (const t6 of e22) for (let e3 = 0, n4 = t6.length, s4 = n4 - 1; e3 < n4; s4 = e3++) {
+                    const n5 = t6[s4], l22 = t6[e3];
+                    if (tr(i4, o22, n5, l22)) return 0;
+                    a22 = Math.min(a22, Fr(i4, o22, n5, l22, r22));
+                  }
+                }
+                return a22;
+              }
+              function Rr(t42, e22, r22, n22, i22, s22) {
+                if (!s22) return;
+                const a22 = Vr(Pr(n22, s22), i22, r22);
+                a22 < e22 && t42.push([a22, s22, [0, 0]]);
+              }
+              function Ur(t42, e22, r22, n22, i22, s22, a22) {
+                if (!s22 || !a22) return;
+                const o22 = Vr(Pr(n22, s22), Pr(i22, a22), r22);
+                o22 < e22 && t42.push([o22, s22, a22]);
+              }
+              function qr(t42, e22, r22, n22, i22 = 1 / 0) {
+                let s22 = Math.min(n22.distance(t42[0], r22[0][0]), i22);
+                if (0 === s22) return s22;
+                const a22 = new fr([[0, [0, t42.length - 1], [0, 0]]], kr), o22 = Cr(r22);
+                for (; a22.length > 0; ) {
+                  const i3 = a22.pop();
+                  if (i3[0] >= s22) continue;
+                  const l22 = i3[1], u22 = e22 ? 50 : 100;
+                  if (Mr(l22) <= u22) {
+                    if (!Ir(l22, t42.length)) return NaN;
+                    if (e22) {
+                      const e3 = Dr(t42, l22, r22, n22);
+                      if (isNaN(e3) || 0 === e3) return e3;
+                      s22 = Math.min(s22, e3);
+                    } else for (let e3 = l22[0]; e3 <= l22[1]; ++e3) {
+                      const i4 = Lr(t42[e3], r22, n22);
+                      if (s22 = Math.min(s22, i4), 0 === s22) return 0;
+                    }
+                  } else {
+                    const r3 = zr(l22, e22);
+                    Rr(a22, s22, n22, t42, o22, r3[0]), Rr(a22, s22, n22, t42, o22, r3[1]);
+                  }
+                }
+                return s22;
+              }
+              function Nr(t42, e22, r22, n22, i22, s22 = 1 / 0) {
+                let a22 = Math.min(s22, i22.distance(t42[0], r22[0]));
+                if (0 === a22) return a22;
+                const o22 = new fr([[0, [0, t42.length - 1], [0, r22.length - 1]]], kr);
+                for (; o22.length > 0; ) {
+                  const s3 = o22.pop();
+                  if (s3[0] >= a22) continue;
+                  const l22 = s3[1], u22 = s3[2], c22 = e22 ? 50 : 100, h22 = n22 ? 50 : 100;
+                  if (Mr(l22) <= c22 && Mr(u22) <= h22) {
+                    if (!Ir(l22, t42.length) && Ir(u22, r22.length)) return NaN;
+                    let s4;
+                    if (e22 && n22) s4 = Tr(t42, l22, r22, u22, i22), a22 = Math.min(a22, s4);
+                    else if (e22 && !n22) {
+                      const e3 = t42.slice(l22[0], l22[1] + 1);
+                      for (let t5 = u22[0]; t5 <= u22[1]; ++t5) if (s4 = Er(r22[t5], e3, i22), a22 = Math.min(a22, s4), 0 === a22) return a22;
+                    } else if (!e22 && n22) {
+                      const e3 = r22.slice(u22[0], u22[1] + 1);
+                      for (let r3 = l22[0]; r3 <= l22[1]; ++r3) if (s4 = Er(t42[r3], e3, i22), a22 = Math.min(a22, s4), 0 === a22) return a22;
+                    } else s4 = $r(t42, l22, r22, u22, i22), a22 = Math.min(a22, s4);
+                  } else {
+                    const s4 = zr(l22, e22), c3 = zr(u22, n22);
+                    Ur(o22, a22, i22, t42, r22, s4[0], c3[0]), Ur(o22, a22, i22, t42, r22, s4[0], c3[1]), Ur(o22, a22, i22, t42, r22, s4[1], c3[0]), Ur(o22, a22, i22, t42, r22, s4[1], c3[1]);
+                  }
+                }
+                return a22;
+              }
+              function Zr(t42) {
+                return "MultiPolygon" === t42.type ? t42.coordinates.map((t5) => ({ type: "Polygon", coordinates: t5 })) : "MultiLineString" === t42.type ? t42.coordinates.map((t5) => ({ type: "LineString", coordinates: t5 })) : "MultiPoint" === t42.type ? t42.coordinates.map((t5) => ({ type: "Point", coordinates: t5 })) : [t42];
+              }
+              class Gr {
+                constructor(t42, e22) {
+                  this.type = ut2, this.geojson = t42, this.geometries = e22;
+                }
+                static parse(t42, e22) {
+                  if (2 !== t42.length) return e22.error(`'distance' expression requires exactly one argument, but found ${t42.length - 1} instead.`);
+                  if (re2(t42[1])) {
+                    const e3 = t42[1];
+                    if ("FeatureCollection" === e3.type) return new Gr(e3, e3.features.map((t5) => Zr(t5.geometry)).flat());
+                    if ("Feature" === e3.type) return new Gr(e3, Zr(e3.geometry));
+                    if ("type" in e3 && "coordinates" in e3) return new Gr(e3, Zr(e3));
+                  }
+                  return e22.error("'distance' expression requires valid geojson object that contains polygon geometry type.");
+                }
+                evaluate(t42) {
+                  if (null != t42.geometry() && null != t42.canonicalID()) {
+                    if ("Point" === t42.geometryType()) return function(t5, e22) {
+                      const r22 = t5.geometry(), n22 = r22.flat().map((e3) => Ye2([e3.x, e3.y], t5.canonical));
+                      if (0 === r22.length) return NaN;
+                      const i22 = new Sr(n22[0][1]);
+                      let s22 = 1 / 0;
+                      for (const t6 of e22) {
+                        switch (t6.type) {
+                          case "Point":
+                            s22 = Math.min(s22, Nr(n22, false, [t6.coordinates], false, i22, s22));
+                            break;
+                          case "LineString":
+                            s22 = Math.min(s22, Nr(n22, false, t6.coordinates, true, i22, s22));
+                            break;
+                          case "Polygon":
+                            s22 = Math.min(s22, qr(n22, false, t6.coordinates, i22, s22));
+                        }
+                        if (0 === s22) return s22;
+                      }
+                      return s22;
+                    }(t42, this.geometries);
+                    if ("LineString" === t42.geometryType()) return function(t5, e22) {
+                      const r22 = t5.geometry(), n22 = r22.flat().map((e3) => Ye2([e3.x, e3.y], t5.canonical));
+                      if (0 === r22.length) return NaN;
+                      const i22 = new Sr(n22[0][1]);
+                      let s22 = 1 / 0;
+                      for (const t6 of e22) {
+                        switch (t6.type) {
+                          case "Point":
+                            s22 = Math.min(s22, Nr(n22, true, [t6.coordinates], false, i22, s22));
+                            break;
+                          case "LineString":
+                            s22 = Math.min(s22, Nr(n22, true, t6.coordinates, true, i22, s22));
+                            break;
+                          case "Polygon":
+                            s22 = Math.min(s22, qr(n22, true, t6.coordinates, i22, s22));
+                        }
+                        if (0 === s22) return s22;
+                      }
+                      return s22;
+                    }(t42, this.geometries);
+                    if ("Polygon" === t42.geometryType()) return function(t5, e22) {
+                      const r22 = t5.geometry();
+                      if (0 === r22.length || 0 === r22[0].length) return NaN;
+                      const n22 = xr(r22, 0).map((e3) => e3.map((e4) => e4.map((e5) => Ye2([e5.x, e5.y], t5.canonical)))), i22 = new Sr(n22[0][0][0][1]);
+                      let s22 = 1 / 0;
+                      for (const t6 of e22) for (const e3 of n22) {
+                        switch (t6.type) {
+                          case "Point":
+                            s22 = Math.min(s22, qr([t6.coordinates], false, e3, i22, s22));
+                            break;
+                          case "LineString":
+                            s22 = Math.min(s22, qr(t6.coordinates, true, e3, i22, s22));
+                            break;
+                          case "Polygon":
+                            s22 = Math.min(s22, jr(e3, t6.coordinates, i22, s22));
+                        }
+                        if (0 === s22) return s22;
+                      }
+                      return s22;
+                    }(t42, this.geometries);
+                  }
+                  return NaN;
+                }
+                eachChild() {
+                }
+                outputDefined() {
+                  return true;
+                }
+              }
+              const Kr = { "==": Le2, "!=": De2, ">": je2, "<": Oe2, ">=": Ue2, "<=": Re2, array: le2, at: me2, boolean: le2, case: be2, coalesce: Ee2, collator: qe2, format: Ze2, image: Ge2, in: ge2, "index-of": xe2, interpolate: Be2, "interpolate-hcl": Be2, "interpolate-lab": Be2, length: Ke2, let: de2, literal: se2, match: ve2, number: le2, "number-format": Ne2, object: le2, slice: we2, step: Ae2, string: le2, "to-boolean": ce2, "to-color": ce2, "to-number": ce2, "to-string": ce2, var: ye2, within: pr, distance: Gr };
+              class Xr {
+                constructor(t42, e22, r22, n22) {
+                  this.name = t42, this.type = e22, this._evaluate = r22, this.args = n22;
+                }
+                evaluate(t42) {
+                  return this._evaluate(t42, this.args);
+                }
+                eachChild(t42) {
+                  this.args.forEach(t42);
+                }
+                outputDefined() {
+                  return false;
+                }
+                static parse(t42, e22) {
+                  const r22 = t42[0], n22 = Xr.definitions[r22];
+                  if (!n22) return e22.error(`Unknown expression "${r22}". If you wanted a literal array, use ["literal", [...]].`, 0);
+                  const i22 = Array.isArray(n22) ? n22[0] : n22.type, s22 = Array.isArray(n22) ? [[n22[1], n22[2]]] : n22.overloads, a22 = s22.filter(([e3]) => !Array.isArray(e3) || e3.length === t42.length - 1);
+                  let o22 = null;
+                  for (const [n3, s3] of a22) {
+                    o22 = new fe2(e22.registry, Qr, e22.path, null, e22.scope);
+                    const a3 = [];
+                    let l22 = false;
+                    for (let e3 = 1; e3 < t42.length; e3++) {
+                      const r3 = t42[e3], i3 = Array.isArray(n3) ? n3[e3 - 1] : n3.type, s4 = o22.parse(r3, 1 + a3.length, i3);
+                      if (!s4) {
+                        l22 = true;
+                        break;
+                      }
+                      a3.push(s4);
+                    }
+                    if (!l22) if (Array.isArray(n3) && n3.length !== a3.length) o22.error(`Expected ${n3.length} arguments, but found ${a3.length} instead.`);
+                    else {
+                      for (let t5 = 0; t5 < a3.length; t5++) {
+                        const e3 = Array.isArray(n3) ? n3[t5] : n3.type, r3 = a3[t5];
+                        o22.concat(t5 + 1).checkSubtype(e3, r3.type);
+                      }
+                      if (0 === o22.errors.length) return new Xr(r22, i22, s3, a3);
+                    }
+                  }
+                  if (1 === a22.length) e22.errors.push(...o22.errors);
+                  else {
+                    const r3 = (a22.length ? a22 : s22).map(([t5]) => {
+                      return e3 = t5, Array.isArray(e3) ? `(${e3.map(wt).join(", ")})` : `(${wt(e3.type)}...)`;
+                      var e3;
+                    }).join(" | "), n3 = [];
+                    for (let r4 = 1; r4 < t42.length; r4++) {
+                      const i3 = e22.parse(t42[r4], 1 + n3.length);
+                      if (!i3) return null;
+                      n3.push(wt(i3.type));
+                    }
+                    e22.error(`Expected arguments of type ${r3}, but found (${n3.join(", ")}) instead.`);
+                  }
+                  return null;
+                }
+                static register(t42, e22) {
+                  Xr.definitions = e22;
+                  for (const r22 in e22) t42[r22] = Xr;
+                }
+              }
+              function Hr(t42, [e22, r22, n22, i22]) {
+                e22 = e22.evaluate(t42), r22 = r22.evaluate(t42), n22 = n22.evaluate(t42);
+                const s22 = i22 ? i22.evaluate(t42) : 1, a22 = ee2(e22, r22, n22, s22);
+                if (a22) throw new ae2(a22);
+                return new Kt(e22 / 255, r22 / 255, n22 / 255, s22, false);
+              }
+              function Yr(t42, e22) {
+                return t42 in e22;
+              }
+              function Jr(t42, e22) {
+                const r22 = e22[t42];
+                return void 0 === r22 ? null : r22;
+              }
+              function Wr(t42) {
+                return { type: t42 };
+              }
+              function Qr(t42) {
+                if (t42 instanceof ye2) return Qr(t42.boundExpression);
+                if (t42 instanceof Xr && "error" === t42.name) return false;
+                if (t42 instanceof qe2) return false;
+                if (t42 instanceof pr) return false;
+                if (t42 instanceof Gr) return false;
+                const e22 = t42 instanceof ce2 || t42 instanceof le2;
+                let r22 = true;
+                return t42.eachChild((t5) => {
+                  r22 = e22 ? r22 && Qr(t5) : r22 && t5 instanceof se2;
+                }), !!r22 && tn(t42) && rn(t42, ["zoom", "heatmap-density", "line-progress", "accumulated", "is-supported-script"]);
+              }
+              function tn(t42) {
+                if (t42 instanceof Xr) {
+                  if ("get" === t42.name && 1 === t42.args.length) return false;
+                  if ("feature-state" === t42.name) return false;
+                  if ("has" === t42.name && 1 === t42.args.length) return false;
+                  if ("properties" === t42.name || "geometry-type" === t42.name || "id" === t42.name) return false;
+                  if (/^filter-/.test(t42.name)) return false;
+                }
+                if (t42 instanceof pr) return false;
+                if (t42 instanceof Gr) return false;
+                let e22 = true;
+                return t42.eachChild((t5) => {
+                  e22 && !tn(t5) && (e22 = false);
+                }), e22;
+              }
+              function en(t42) {
+                if (t42 instanceof Xr && "feature-state" === t42.name) return false;
+                let e22 = true;
+                return t42.eachChild((t5) => {
+                  e22 && !en(t5) && (e22 = false);
+                }), e22;
+              }
+              function rn(t42, e22) {
+                if (t42 instanceof Xr && e22.indexOf(t42.name) >= 0) return false;
+                let r22 = true;
+                return t42.eachChild((t5) => {
+                  r22 && !rn(t5, e22) && (r22 = false);
+                }), r22;
+              }
+              function nn(t42) {
+                return { result: "success", value: t42 };
+              }
+              function sn(t42) {
+                return { result: "error", value: t42 };
+              }
+              function an(t42) {
+                return "data-driven" === t42["property-type"] || "cross-faded-data-driven" === t42["property-type"];
+              }
+              function on(t42) {
+                return !!t42.expression && t42.expression.parameters.indexOf("zoom") > -1;
+              }
+              function ln(t42) {
+                return !!t42.expression && t42.expression.interpolated;
+              }
+              function un(t42) {
+                return t42 instanceof Number ? "number" : t42 instanceof String ? "string" : t42 instanceof Boolean ? "boolean" : Array.isArray(t42) ? "array" : null === t42 ? "null" : typeof t42;
+              }
+              function cn(t42) {
+                return "object" == typeof t42 && null !== t42 && !Array.isArray(t42);
+              }
+              function hn(t42) {
+                return t42;
+              }
+              function pn(t42, e22) {
+                const r22 = "color" === e22.type, n22 = t42.stops && "object" == typeof t42.stops[0][0], i22 = n22 || !(n22 || void 0 !== t42.property), s22 = t42.type || (ln(e22) ? "exponential" : "interval");
+                if (r22 || "padding" === e22.type) {
+                  const n3 = r22 ? Kt.parse : Jt.parse;
+                  (t42 = st2({}, t42)).stops && (t42.stops = t42.stops.map((t5) => [t5[0], n3(t5[1])])), t42.default = n3(t42.default ? t42.default : e22.default);
+                }
+                if (t42.colorSpace && "rgb" !== (a22 = t42.colorSpace) && "hcl" !== a22 && "lab" !== a22) throw new Error(`Unknown color space: "${t42.colorSpace}"`);
+                var a22;
+                let o22, l22, u22;
+                if ("exponential" === s22) o22 = mn;
+                else if ("interval" === s22) o22 = yn;
+                else if ("categorical" === s22) {
+                  o22 = dn, l22 = /* @__PURE__ */ Object.create(null);
+                  for (const e3 of t42.stops) l22[e3[0]] = e3[1];
+                  u22 = typeof t42.stops[0][0];
+                } else {
+                  if ("identity" !== s22) throw new Error(`Unknown function type "${s22}"`);
+                  o22 = gn;
+                }
+                if (n22) {
+                  const r3 = {}, n3 = [];
+                  for (let e3 = 0; e3 < t42.stops.length; e3++) {
+                    const i4 = t42.stops[e3], s4 = i4[0].zoom;
+                    void 0 === r3[s4] && (r3[s4] = { zoom: s4, type: t42.type, property: t42.property, default: t42.default, stops: [] }, n3.push(s4)), r3[s4].stops.push([i4[0].value, i4[1]]);
+                  }
+                  const i3 = [];
+                  for (const t5 of n3) i3.push([r3[t5].zoom, pn(r3[t5], e22)]);
+                  const s3 = { name: "linear" };
+                  return { kind: "composite", interpolationType: s3, interpolationFactor: Be2.interpolationFactor.bind(void 0, s3), zoomStops: i3.map((t5) => t5[0]), evaluate: ({ zoom: r4 }, n4) => mn({ stops: i3, base: t42.base }, e22, r4).evaluate(r4, n4) };
+                }
+                if (i22) {
+                  const r3 = "exponential" === s22 ? { name: "exponential", base: void 0 !== t42.base ? t42.base : 1 } : null;
+                  return { kind: "camera", interpolationType: r3, interpolationFactor: Be2.interpolationFactor.bind(void 0, r3), zoomStops: t42.stops.map((t5) => t5[0]), evaluate: ({ zoom: r4 }) => o22(t42, e22, r4, l22, u22) };
+                }
+                return { kind: "source", evaluate(r3, n3) {
+                  const i3 = n3 && n3.properties ? n3.properties[t42.property] : void 0;
+                  return void 0 === i3 ? fn(t42.default, e22.default) : o22(t42, e22, i3, l22, u22);
+                } };
+              }
+              function fn(t42, e22, r22) {
+                return void 0 !== t42 ? t42 : void 0 !== e22 ? e22 : void 0 !== r22 ? r22 : void 0;
+              }
+              function dn(t42, e22, r22, n22, i22) {
+                return fn(typeof r22 === i22 ? n22[r22] : void 0, t42.default, e22.default);
+              }
+              function yn(t42, e22, r22) {
+                if ("number" !== un(r22)) return fn(t42.default, e22.default);
+                const n22 = t42.stops.length;
+                if (1 === n22) return t42.stops[0][1];
+                if (r22 <= t42.stops[0][0]) return t42.stops[0][1];
+                if (r22 >= t42.stops[n22 - 1][0]) return t42.stops[n22 - 1][1];
+                const i22 = _e2(t42.stops.map((t5) => t5[0]), r22);
+                return t42.stops[i22][1];
+              }
+              function mn(t42, e22, r22) {
+                const n22 = void 0 !== t42.base ? t42.base : 1;
+                if ("number" !== un(r22)) return fn(t42.default, e22.default);
+                const i22 = t42.stops.length;
+                if (1 === i22) return t42.stops[0][1];
+                if (r22 <= t42.stops[0][0]) return t42.stops[0][1];
+                if (r22 >= t42.stops[i22 - 1][0]) return t42.stops[i22 - 1][1];
+                const s22 = _e2(t42.stops.map((t5) => t5[0]), r22), a22 = function(t5, e3, r3, n3) {
+                  const i3 = n3 - r3, s3 = t5 - r3;
+                  return 0 === i3 ? 0 : 1 === e3 ? s3 / i3 : (Math.pow(e3, s3) - 1) / (Math.pow(e3, i3) - 1);
+                }(r22, n22, t42.stops[s22][0], t42.stops[s22 + 1][0]), o22 = t42.stops[s22][1], l22 = t42.stops[s22 + 1][1], u22 = Ce2[e22.type] || hn;
+                return "function" == typeof o22.evaluate ? { evaluate(...e3) {
+                  const r3 = o22.evaluate.apply(void 0, e3), n3 = l22.evaluate.apply(void 0, e3);
+                  if (void 0 !== r3 && void 0 !== n3) return u22(r3, n3, a22, t42.colorSpace);
+                } } : u22(o22, l22, a22, t42.colorSpace);
+              }
+              function gn(t42, e22, r22) {
+                switch (e22.type) {
+                  case "color":
+                    r22 = Kt.parse(r22);
+                    break;
+                  case "formatted":
+                    r22 = Yt.fromString(r22.toString());
+                    break;
+                  case "resolvedImage":
+                    r22 = te2.fromString(r22.toString());
+                    break;
+                  case "padding":
+                    r22 = Jt.parse(r22);
+                    break;
+                  default:
+                    un(r22) === e22.type || "enum" === e22.type && e22.values[r22] || (r22 = void 0);
+                }
+                return fn(r22, t42.default, e22.default);
+              }
+              Xr.register(Kr, { error: [{ kind: "error" }, [ct2], (t42, [e22]) => {
+                throw new ae2(e22.evaluate(t42));
+              }], typeof: [ct2, [dt2], (t42, [e22]) => wt(ne2(e22.evaluate(t42)))], "to-rgba": [bt(ut2, 4), [pt2], (t42, [e22]) => {
+                const [r22, n22, i22, s22] = e22.evaluate(t42).rgb;
+                return [255 * r22, 255 * n22, 255 * i22, s22];
+              }], rgb: [pt2, [ut2, ut2, ut2], Hr], rgba: [pt2, [ut2, ut2, ut2, ut2], Hr], has: { type: ht2, overloads: [[[ct2], (t42, [e22]) => Yr(e22.evaluate(t42), t42.properties())], [[ct2, ft2], (t42, [e22, r22]) => Yr(e22.evaluate(t42), r22.evaluate(t42))]] }, get: { type: dt2, overloads: [[[ct2], (t42, [e22]) => Jr(e22.evaluate(t42), t42.properties())], [[ct2, ft2], (t42, [e22, r22]) => Jr(e22.evaluate(t42), r22.evaluate(t42))]] }, "feature-state": [dt2, [ct2], (t42, [e22]) => Jr(e22.evaluate(t42), t42.featureState || {})], properties: [ft2, [], (t42) => t42.properties()], "geometry-type": [ct2, [], (t42) => t42.geometryType()], id: [dt2, [], (t42) => t42.id()], zoom: [ut2, [], (t42) => t42.globals.zoom], "heatmap-density": [ut2, [], (t42) => t42.globals.heatmapDensity || 0], "line-progress": [ut2, [], (t42) => t42.globals.lineProgress || 0], accumulated: [dt2, [], (t42) => void 0 === t42.globals.accumulated ? null : t42.globals.accumulated], "+": [ut2, Wr(ut2), (t42, e22) => {
+                let r22 = 0;
+                for (const n22 of e22) r22 += n22.evaluate(t42);
+                return r22;
+              }], "*": [ut2, Wr(ut2), (t42, e22) => {
+                let r22 = 1;
+                for (const n22 of e22) r22 *= n22.evaluate(t42);
+                return r22;
+              }], "-": { type: ut2, overloads: [[[ut2, ut2], (t42, [e22, r22]) => e22.evaluate(t42) - r22.evaluate(t42)], [[ut2], (t42, [e22]) => -e22.evaluate(t42)]] }, "/": [ut2, [ut2, ut2], (t42, [e22, r22]) => e22.evaluate(t42) / r22.evaluate(t42)], "%": [ut2, [ut2, ut2], (t42, [e22, r22]) => e22.evaluate(t42) % r22.evaluate(t42)], ln2: [ut2, [], () => Math.LN2], pi: [ut2, [], () => Math.PI], e: [ut2, [], () => Math.E], "^": [ut2, [ut2, ut2], (t42, [e22, r22]) => Math.pow(e22.evaluate(t42), r22.evaluate(t42))], sqrt: [ut2, [ut2], (t42, [e22]) => Math.sqrt(e22.evaluate(t42))], log10: [ut2, [ut2], (t42, [e22]) => Math.log(e22.evaluate(t42)) / Math.LN10], ln: [ut2, [ut2], (t42, [e22]) => Math.log(e22.evaluate(t42))], log2: [ut2, [ut2], (t42, [e22]) => Math.log(e22.evaluate(t42)) / Math.LN2], sin: [ut2, [ut2], (t42, [e22]) => Math.sin(e22.evaluate(t42))], cos: [ut2, [ut2], (t42, [e22]) => Math.cos(e22.evaluate(t42))], tan: [ut2, [ut2], (t42, [e22]) => Math.tan(e22.evaluate(t42))], asin: [ut2, [ut2], (t42, [e22]) => Math.asin(e22.evaluate(t42))], acos: [ut2, [ut2], (t42, [e22]) => Math.acos(e22.evaluate(t42))], atan: [ut2, [ut2], (t42, [e22]) => Math.atan(e22.evaluate(t42))], min: [ut2, Wr(ut2), (t42, e22) => Math.min(...e22.map((e3) => e3.evaluate(t42)))], max: [ut2, Wr(ut2), (t42, e22) => Math.max(...e22.map((e3) => e3.evaluate(t42)))], abs: [ut2, [ut2], (t42, [e22]) => Math.abs(e22.evaluate(t42))], round: [ut2, [ut2], (t42, [e22]) => {
+                const r22 = e22.evaluate(t42);
+                return r22 < 0 ? -Math.round(-r22) : Math.round(r22);
+              }], floor: [ut2, [ut2], (t42, [e22]) => Math.floor(e22.evaluate(t42))], ceil: [ut2, [ut2], (t42, [e22]) => Math.ceil(e22.evaluate(t42))], "filter-==": [ht2, [ct2, dt2], (t42, [e22, r22]) => t42.properties()[e22.value] === r22.value], "filter-id-==": [ht2, [dt2], (t42, [e22]) => t42.id() === e22.value], "filter-type-==": [ht2, [ct2], (t42, [e22]) => t42.geometryType() === e22.value], "filter-<": [ht2, [ct2, dt2], (t42, [e22, r22]) => {
+                const n22 = t42.properties()[e22.value], i22 = r22.value;
+                return typeof n22 == typeof i22 && n22 < i22;
+              }], "filter-id-<": [ht2, [dt2], (t42, [e22]) => {
+                const r22 = t42.id(), n22 = e22.value;
+                return typeof r22 == typeof n22 && r22 < n22;
+              }], "filter->": [ht2, [ct2, dt2], (t42, [e22, r22]) => {
+                const n22 = t42.properties()[e22.value], i22 = r22.value;
+                return typeof n22 == typeof i22 && n22 > i22;
+              }], "filter-id->": [ht2, [dt2], (t42, [e22]) => {
+                const r22 = t42.id(), n22 = e22.value;
+                return typeof r22 == typeof n22 && r22 > n22;
+              }], "filter-<=": [ht2, [ct2, dt2], (t42, [e22, r22]) => {
+                const n22 = t42.properties()[e22.value], i22 = r22.value;
+                return typeof n22 == typeof i22 && n22 <= i22;
+              }], "filter-id-<=": [ht2, [dt2], (t42, [e22]) => {
+                const r22 = t42.id(), n22 = e22.value;
+                return typeof r22 == typeof n22 && r22 <= n22;
+              }], "filter->=": [ht2, [ct2, dt2], (t42, [e22, r22]) => {
+                const n22 = t42.properties()[e22.value], i22 = r22.value;
+                return typeof n22 == typeof i22 && n22 >= i22;
+              }], "filter-id->=": [ht2, [dt2], (t42, [e22]) => {
+                const r22 = t42.id(), n22 = e22.value;
+                return typeof r22 == typeof n22 && r22 >= n22;
+              }], "filter-has": [ht2, [dt2], (t42, [e22]) => e22.value in t42.properties()], "filter-has-id": [ht2, [], (t42) => null !== t42.id() && void 0 !== t42.id()], "filter-type-in": [ht2, [bt(ct2)], (t42, [e22]) => e22.value.indexOf(t42.geometryType()) >= 0], "filter-id-in": [ht2, [bt(dt2)], (t42, [e22]) => e22.value.indexOf(t42.id()) >= 0], "filter-in-small": [ht2, [ct2, bt(dt2)], (t42, [e22, r22]) => r22.value.indexOf(t42.properties()[e22.value]) >= 0], "filter-in-large": [ht2, [ct2, bt(dt2)], (t42, [e22, r22]) => function(t5, e3, r3, n22) {
+                for (; r3 <= n22; ) {
+                  const i22 = r3 + n22 >> 1;
+                  if (e3[i22] === t5) return true;
+                  e3[i22] > t5 ? n22 = i22 - 1 : r3 = i22 + 1;
+                }
+                return false;
+              }(t42.properties()[e22.value], r22.value, 0, r22.value.length - 1)], all: { type: ht2, overloads: [[[ht2, ht2], (t42, [e22, r22]) => e22.evaluate(t42) && r22.evaluate(t42)], [Wr(ht2), (t42, e22) => {
+                for (const r22 of e22) if (!r22.evaluate(t42)) return false;
+                return true;
+              }]] }, any: { type: ht2, overloads: [[[ht2, ht2], (t42, [e22, r22]) => e22.evaluate(t42) || r22.evaluate(t42)], [Wr(ht2), (t42, e22) => {
+                for (const r22 of e22) if (r22.evaluate(t42)) return true;
+                return false;
+              }]] }, "!": [ht2, [ht2], (t42, [e22]) => !e22.evaluate(t42)], "is-supported-script": [ht2, [ct2], (t42, [e22]) => {
+                const r22 = t42.globals && t42.globals.isSupportedScript;
+                return !r22 || r22(e22.evaluate(t42));
+              }], upcase: [ct2, [ct2], (t42, [e22]) => e22.evaluate(t42).toUpperCase()], downcase: [ct2, [ct2], (t42, [e22]) => e22.evaluate(t42).toLowerCase()], concat: [ct2, Wr(dt2), (t42, e22) => e22.map((e3) => ie2(e3.evaluate(t42))).join("")], "resolved-locale": [ct2, [yt], (t42, [e22]) => e22.evaluate(t42).resolvedLocale()] });
+              class xn {
+                constructor(t42, e22) {
+                  var r22;
+                  this.expression = t42, this._warningHistory = {}, this._evaluator = new pe2(), this._defaultValue = e22 ? "color" === (r22 = e22).type && cn(r22.default) ? new Kt(0, 0, 0, 0) : "color" === r22.type ? Kt.parse(r22.default) || null : "padding" === r22.type ? Jt.parse(r22.default) || null : "variableAnchorOffsetCollection" === r22.type ? Qt.parse(r22.default) || null : void 0 === r22.default ? null : r22.default : null, this._enumValues = e22 && "enum" === e22.type ? e22.values : null;
+                }
+                evaluateWithoutErrorHandling(t42, e22, r22, n22, i22, s22) {
+                  return this._evaluator.globals = t42, this._evaluator.feature = e22, this._evaluator.featureState = r22, this._evaluator.canonical = n22, this._evaluator.availableImages = i22 || null, this._evaluator.formattedSection = s22, this.expression.evaluate(this._evaluator);
+                }
+                evaluate(t42, e22, r22, n22, i22, s22) {
+                  this._evaluator.globals = t42, this._evaluator.feature = e22 || null, this._evaluator.featureState = r22 || null, this._evaluator.canonical = n22, this._evaluator.availableImages = i22 || null, this._evaluator.formattedSection = s22 || null;
+                  try {
+                    const t5 = this.expression.evaluate(this._evaluator);
+                    if (null == t5 || "number" == typeof t5 && t5 != t5) return this._defaultValue;
+                    if (this._enumValues && !(t5 in this._enumValues)) throw new ae2(`Expected value to be one of ${Object.keys(this._enumValues).map((t6) => JSON.stringify(t6)).join(", ")}, but found ${JSON.stringify(t5)} instead.`);
+                    return t5;
+                  } catch (t5) {
+                    return this._warningHistory[t5.message] || (this._warningHistory[t5.message] = true, "undefined" != typeof console && console.warn(t5.message)), this._defaultValue;
+                  }
+                }
+              }
+              function vn(t42) {
+                return Array.isArray(t42) && t42.length > 0 && "string" == typeof t42[0] && t42[0] in Kr;
+              }
+              function bn(t42, e22) {
+                const r22 = new fe2(Kr, Qr, [], e22 ? function(t5) {
+                  const e3 = { color: pt2, string: ct2, number: ut2, enum: ct2, boolean: ht2, formatted: mt2, padding: gt2, resolvedImage: xt, variableAnchorOffsetCollection: vt };
+                  return "array" === t5.type ? bt(e3[t5.value] || dt2, t5.length) : e3[t5.type];
+                }(e22) : void 0), n22 = r22.parse(t42, void 0, void 0, void 0, e22 && "string" === e22.type ? { typeAnnotation: "coerce" } : void 0);
+                return n22 ? nn(new xn(n22, e22)) : sn(r22.errors);
+              }
+              class wn {
+                constructor(t42, e22) {
+                  this.kind = t42, this._styleExpression = e22, this.isStateDependent = "constant" !== t42 && !en(e22.expression);
+                }
+                evaluateWithoutErrorHandling(t42, e22, r22, n22, i22, s22) {
+                  return this._styleExpression.evaluateWithoutErrorHandling(t42, e22, r22, n22, i22, s22);
+                }
+                evaluate(t42, e22, r22, n22, i22, s22) {
+                  return this._styleExpression.evaluate(t42, e22, r22, n22, i22, s22);
+                }
+              }
+              class _n {
+                constructor(t42, e22, r22, n22) {
+                  this.kind = t42, this.zoomStops = r22, this._styleExpression = e22, this.isStateDependent = "camera" !== t42 && !en(e22.expression), this.interpolationType = n22;
+                }
+                evaluateWithoutErrorHandling(t42, e22, r22, n22, i22, s22) {
+                  return this._styleExpression.evaluateWithoutErrorHandling(t42, e22, r22, n22, i22, s22);
+                }
+                evaluate(t42, e22, r22, n22, i22, s22) {
+                  return this._styleExpression.evaluate(t42, e22, r22, n22, i22, s22);
+                }
+                interpolationFactor(t42, e22, r22) {
+                  return this.interpolationType ? Be2.interpolationFactor(this.interpolationType, t42, e22, r22) : 0;
+                }
+              }
+              function An(t42, e22) {
+                const r22 = bn(t42, e22);
+                if ("error" === r22.result) return r22;
+                const n22 = r22.value.expression, i22 = tn(n22);
+                if (!i22 && !an(e22)) return sn([new at2("", "data expressions not supported")]);
+                const s22 = rn(n22, ["zoom"]);
+                if (!s22 && !on(e22)) return sn([new at2("", "zoom expressions not supported")]);
+                const a22 = kn(n22);
+                return a22 || s22 ? a22 instanceof at2 ? sn([a22]) : a22 instanceof Be2 && !ln(e22) ? sn([new at2("", '"interpolate" expressions cannot be used with this property')]) : nn(a22 ? new _n(i22 ? "camera" : "composite", r22.value, a22.labels, a22 instanceof Be2 ? a22.interpolation : void 0) : new wn(i22 ? "constant" : "source", r22.value)) : sn([new at2("", '"zoom" expression may only be used as input to a top-level "step" or "interpolate" expression.')]);
+              }
+              class Sn {
+                constructor(t42, e22) {
+                  this._parameters = t42, this._specification = e22, st2(this, pn(this._parameters, this._specification));
+                }
+                static deserialize(t42) {
+                  return new Sn(t42._parameters, t42._specification);
+                }
+                static serialize(t42) {
+                  return { _parameters: t42._parameters, _specification: t42._specification };
+                }
+              }
+              function kn(t42) {
+                let e22 = null;
+                if (t42 instanceof de2) e22 = kn(t42.result);
+                else if (t42 instanceof Ee2) {
+                  for (const r22 of t42.args) if (e22 = kn(r22), e22) break;
+                } else (t42 instanceof Ae2 || t42 instanceof Be2) && t42.input instanceof Xr && "zoom" === t42.input.name && (e22 = t42);
+                return e22 instanceof at2 || t42.eachChild((t5) => {
+                  const r22 = kn(t5);
+                  r22 instanceof at2 ? e22 = r22 : !e22 && r22 ? e22 = new at2("", '"zoom" expression may only be used as input to a top-level "step" or "interpolate" expression.') : e22 && r22 && e22 !== r22 && (e22 = new at2("", 'Only one zoom-based "step" or "interpolate" subexpression may be used in an expression.'));
+                }), e22;
+              }
+              function Mn(t42) {
+                if (true === t42 || false === t42) return true;
+                if (!Array.isArray(t42) || 0 === t42.length) return false;
+                switch (t42[0]) {
+                  case "has":
+                    return t42.length >= 2 && "$id" !== t42[1] && "$type" !== t42[1];
+                  case "in":
+                    return t42.length >= 3 && ("string" != typeof t42[1] || Array.isArray(t42[2]));
+                  case "!in":
+                  case "!has":
+                  case "none":
+                    return false;
+                  case "==":
+                  case "!=":
+                  case ">":
+                  case ">=":
+                  case "<":
+                  case "<=":
+                    return 3 !== t42.length || Array.isArray(t42[1]) || Array.isArray(t42[2]);
+                  case "any":
+                  case "all":
+                    for (const e22 of t42.slice(1)) if (!Mn(e22) && "boolean" != typeof e22) return false;
+                    return true;
+                  default:
+                    return true;
+                }
+              }
+              const In = { type: "boolean", default: false, transition: false, "property-type": "data-driven", expression: { interpolated: false, parameters: ["zoom", "feature"] } };
+              function zn(t42) {
+                if (null == t42) return { filter: () => true, needGeometry: false };
+                Mn(t42) || (t42 = Bn(t42));
+                const e22 = bn(t42, In);
+                if ("error" === e22.result) throw new Error(e22.value.map((t5) => `${t5.key}: ${t5.message}`).join(", "));
+                return { filter: (t5, r22, n22) => e22.value.evaluate(t5, r22, {}, n22), needGeometry: Cn(t42) };
+              }
+              function Pn(t42, e22) {
+                return t42 < e22 ? -1 : t42 > e22 ? 1 : 0;
+              }
+              function Cn(t42) {
+                if (!Array.isArray(t42)) return false;
+                if ("within" === t42[0] || "distance" === t42[0]) return true;
+                for (let e22 = 1; e22 < t42.length; e22++) if (Cn(t42[e22])) return true;
+                return false;
+              }
+              function Bn(t42) {
+                if (!t42) return true;
+                const e22 = t42[0];
+                return t42.length <= 1 ? "any" !== e22 : "==" === e22 ? Vn(t42[1], t42[2], "==") : "!=" === e22 ? Tn(Vn(t42[1], t42[2], "==")) : "<" === e22 || ">" === e22 || "<=" === e22 || ">=" === e22 ? Vn(t42[1], t42[2], e22) : "any" === e22 ? (r22 = t42.slice(1), ["any"].concat(r22.map(Bn))) : "all" === e22 ? ["all"].concat(t42.slice(1).map(Bn)) : "none" === e22 ? ["all"].concat(t42.slice(1).map(Bn).map(Tn)) : "in" === e22 ? En(t42[1], t42.slice(2)) : "!in" === e22 ? Tn(En(t42[1], t42.slice(2))) : "has" === e22 ? Fn(t42[1]) : "!has" !== e22 || Tn(Fn(t42[1]));
+                var r22;
+              }
+              function Vn(t42, e22, r22) {
+                switch (t42) {
+                  case "$type":
+                    return [`filter-type-${r22}`, e22];
+                  case "$id":
+                    return [`filter-id-${r22}`, e22];
+                  default:
+                    return [`filter-${r22}`, t42, e22];
+                }
+              }
+              function En(t42, e22) {
+                if (0 === e22.length) return false;
+                switch (t42) {
+                  case "$type":
+                    return ["filter-type-in", ["literal", e22]];
+                  case "$id":
+                    return ["filter-id-in", ["literal", e22]];
+                  default:
+                    return e22.length > 200 && !e22.some((t5) => typeof t5 != typeof e22[0]) ? ["filter-in-large", t42, ["literal", e22.sort(Pn)]] : ["filter-in-small", t42, ["literal", e22]];
+                }
+              }
+              function Fn(t42) {
+                switch (t42) {
+                  case "$type":
+                    return true;
+                  case "$id":
+                    return ["filter-has-id"];
+                  default:
+                    return ["filter-has", t42];
+                }
+              }
+              function Tn(t42) {
+                return ["!", t42];
+              }
+              function $n(t42) {
+                const e22 = typeof t42;
+                if ("number" === e22 || "boolean" === e22 || "string" === e22 || null == t42) return JSON.stringify(t42);
+                if (Array.isArray(t42)) {
+                  let e3 = "[";
+                  for (const r3 of t42) e3 += `${$n(r3)},`;
+                  return `${e3}]`;
+                }
+                const r22 = Object.keys(t42).sort();
+                let n22 = "{";
+                for (let e3 = 0; e3 < r22.length; e3++) n22 += `${JSON.stringify(r22[e3])}:${$n(t42[r22[e3]])},`;
+                return `${n22}}`;
+              }
+              function Ln(t42) {
+                let e22 = "";
+                for (const r22 of K22) e22 += `/${$n(t42[r22])}`;
+                return e22;
+              }
+              function Dn(t42) {
+                const e22 = t42.value;
+                return e22 ? [new it2(t42.key, e22, "constants have been deprecated as of v8")] : [];
+              }
+              function On(t42) {
+                return t42 instanceof Number || t42 instanceof String || t42 instanceof Boolean ? t42.valueOf() : t42;
+              }
+              function jn(t42) {
+                if (Array.isArray(t42)) return t42.map(jn);
+                if (t42 instanceof Object && !(t42 instanceof Number || t42 instanceof String || t42 instanceof Boolean)) {
+                  const e22 = {};
+                  for (const r22 in t42) e22[r22] = jn(t42[r22]);
+                  return e22;
+                }
+                return On(t42);
+              }
+              function Rn(t42) {
+                const e22 = t42.key, r22 = t42.value, n22 = t42.valueSpec || {}, i22 = t42.objectElementValidators || {}, s22 = t42.style, a22 = t42.styleSpec, o22 = t42.validateSpec;
+                let l22 = [];
+                const u22 = un(r22);
+                if ("object" !== u22) return [new it2(e22, r22, `object expected, ${u22} found`)];
+                for (const t5 in r22) {
+                  const u3 = t5.split(".")[0], c22 = n22[u3] || n22["*"];
+                  let h22;
+                  if (i22[u3]) h22 = i22[u3];
+                  else if (n22[u3]) h22 = o22;
+                  else if (i22["*"]) h22 = i22["*"];
+                  else {
+                    if (!n22["*"]) {
+                      l22.push(new it2(e22, r22[t5], `unknown property "${t5}"`));
+                      continue;
+                    }
+                    h22 = o22;
+                  }
+                  l22 = l22.concat(h22({ key: (e22 ? `${e22}.` : e22) + t5, value: r22[t5], valueSpec: c22, style: s22, styleSpec: a22, object: r22, objectKey: t5, validateSpec: o22 }, r22));
+                }
+                for (const t5 in n22) i22[t5] || n22[t5].required && void 0 === n22[t5].default && void 0 === r22[t5] && l22.push(new it2(e22, r22, `missing required property "${t5}"`));
+                return l22;
+              }
+              function Un(t42) {
+                const e22 = t42.value, r22 = t42.valueSpec, n22 = t42.style, i22 = t42.styleSpec, s22 = t42.key, a22 = t42.arrayElementValidator || t42.validateSpec;
+                if ("array" !== un(e22)) return [new it2(s22, e22, `array expected, ${un(e22)} found`)];
+                if (r22.length && e22.length !== r22.length) return [new it2(s22, e22, `array length ${r22.length} expected, length ${e22.length} found`)];
+                if (r22["min-length"] && e22.length < r22["min-length"]) return [new it2(s22, e22, `array length at least ${r22["min-length"]} expected, length ${e22.length} found`)];
+                let o22 = { type: r22.value, values: r22.values };
+                i22.$version < 7 && (o22.function = r22.function), "object" === un(r22.value) && (o22 = r22.value);
+                let l22 = [];
+                for (let r3 = 0; r3 < e22.length; r3++) l22 = l22.concat(a22({ array: e22, arrayIndex: r3, value: e22[r3], valueSpec: o22, validateSpec: t42.validateSpec, style: n22, styleSpec: i22, key: `${s22}[${r3}]` }));
+                return l22;
+              }
+              function qn(t42) {
+                const e22 = t42.key, r22 = t42.value, n22 = t42.valueSpec;
+                let i22 = un(r22);
+                return "number" === i22 && r22 != r22 && (i22 = "NaN"), "number" !== i22 ? [new it2(e22, r22, `number expected, ${i22} found`)] : "minimum" in n22 && r22 < n22.minimum ? [new it2(e22, r22, `${r22} is less than the minimum value ${n22.minimum}`)] : "maximum" in n22 && r22 > n22.maximum ? [new it2(e22, r22, `${r22} is greater than the maximum value ${n22.maximum}`)] : [];
+              }
+              function Nn(t42) {
+                const e22 = t42.valueSpec, r22 = On(t42.value.type);
+                let n22, i22, s22, a22 = {};
+                const o22 = "categorical" !== r22 && void 0 === t42.value.property, l22 = !o22, u22 = "array" === un(t42.value.stops) && "array" === un(t42.value.stops[0]) && "object" === un(t42.value.stops[0][0]), c22 = Rn({ key: t42.key, value: t42.value, valueSpec: t42.styleSpec.function, validateSpec: t42.validateSpec, style: t42.style, styleSpec: t42.styleSpec, objectElementValidators: { stops: function(t5) {
+                  if ("identity" === r22) return [new it2(t5.key, t5.value, 'identity function may not have a "stops" property')];
+                  let e3 = [];
+                  const n3 = t5.value;
+                  return e3 = e3.concat(Un({ key: t5.key, value: n3, valueSpec: t5.valueSpec, validateSpec: t5.validateSpec, style: t5.style, styleSpec: t5.styleSpec, arrayElementValidator: h22 })), "array" === un(n3) && 0 === n3.length && e3.push(new it2(t5.key, n3, "array must have at least one stop")), e3;
+                }, default: function(t5) {
+                  return t5.validateSpec({ key: t5.key, value: t5.value, valueSpec: e22, validateSpec: t5.validateSpec, style: t5.style, styleSpec: t5.styleSpec });
+                } } });
+                return "identity" === r22 && o22 && c22.push(new it2(t42.key, t42.value, 'missing required property "property"')), "identity" === r22 || t42.value.stops || c22.push(new it2(t42.key, t42.value, 'missing required property "stops"')), "exponential" === r22 && t42.valueSpec.expression && !ln(t42.valueSpec) && c22.push(new it2(t42.key, t42.value, "exponential functions not supported")), t42.styleSpec.$version >= 8 && (l22 && !an(t42.valueSpec) ? c22.push(new it2(t42.key, t42.value, "property functions not supported")) : o22 && !on(t42.valueSpec) && c22.push(new it2(t42.key, t42.value, "zoom functions not supported"))), "categorical" !== r22 && !u22 || void 0 !== t42.value.property || c22.push(new it2(t42.key, t42.value, '"property" property is required')), c22;
+                function h22(t5) {
+                  let r3 = [];
+                  const n3 = t5.value, o3 = t5.key;
+                  if ("array" !== un(n3)) return [new it2(o3, n3, `array expected, ${un(n3)} found`)];
+                  if (2 !== n3.length) return [new it2(o3, n3, `array length 2 expected, length ${n3.length} found`)];
+                  if (u22) {
+                    if ("object" !== un(n3[0])) return [new it2(o3, n3, `object expected, ${un(n3[0])} found`)];
+                    if (void 0 === n3[0].zoom) return [new it2(o3, n3, "object stop key must have zoom")];
+                    if (void 0 === n3[0].value) return [new it2(o3, n3, "object stop key must have value")];
+                    if (s22 && s22 > On(n3[0].zoom)) return [new it2(o3, n3[0].zoom, "stop zoom values must appear in ascending order")];
+                    On(n3[0].zoom) !== s22 && (s22 = On(n3[0].zoom), i22 = void 0, a22 = {}), r3 = r3.concat(Rn({ key: `${o3}[0]`, value: n3[0], valueSpec: { zoom: {} }, validateSpec: t5.validateSpec, style: t5.style, styleSpec: t5.styleSpec, objectElementValidators: { zoom: qn, value: p22 } }));
+                  } else r3 = r3.concat(p22({ key: `${o3}[0]`, value: n3[0], validateSpec: t5.validateSpec, style: t5.style, styleSpec: t5.styleSpec }, n3));
+                  return vn(jn(n3[1])) ? r3.concat([new it2(`${o3}[1]`, n3[1], "expressions are not allowed in function stops.")]) : r3.concat(t5.validateSpec({ key: `${o3}[1]`, value: n3[1], valueSpec: e22, validateSpec: t5.validateSpec, style: t5.style, styleSpec: t5.styleSpec }));
+                }
+                function p22(t5, s3) {
+                  const o3 = un(t5.value), l3 = On(t5.value), u3 = null !== t5.value ? t5.value : s3;
+                  if (n22) {
+                    if (o3 !== n22) return [new it2(t5.key, u3, `${o3} stop domain type must match previous stop domain type ${n22}`)];
+                  } else n22 = o3;
+                  if ("number" !== o3 && "string" !== o3 && "boolean" !== o3) return [new it2(t5.key, u3, "stop domain value must be a number, string, or boolean")];
+                  if ("number" !== o3 && "categorical" !== r22) {
+                    let n3 = `number expected, ${o3} found`;
+                    return an(e22) && void 0 === r22 && (n3 += '\nIf you intended to use a categorical function, specify `"type": "categorical"`.'), [new it2(t5.key, u3, n3)];
+                  }
+                  return "categorical" !== r22 || "number" !== o3 || isFinite(l3) && Math.floor(l3) === l3 ? "categorical" !== r22 && "number" === o3 && void 0 !== i22 && l3 < i22 ? [new it2(t5.key, u3, "stop domain values must appear in ascending order")] : (i22 = l3, "categorical" === r22 && l3 in a22 ? [new it2(t5.key, u3, "stop domain values must be unique")] : (a22[l3] = true, [])) : [new it2(t5.key, u3, `integer expected, found ${l3}`)];
+                }
+              }
+              function Zn2(t42) {
+                const e22 = ("property" === t42.expressionContext ? An : bn)(jn(t42.value), t42.valueSpec);
+                if ("error" === e22.result) return e22.value.map((e3) => new it2(`${t42.key}${e3.key}`, t42.value, e3.message));
+                const r22 = e22.value.expression || e22.value._styleExpression.expression;
+                if ("property" === t42.expressionContext && "text-font" === t42.propertyKey && !r22.outputDefined()) return [new it2(t42.key, t42.value, `Invalid data expression for "${t42.propertyKey}". Output values must be contained as literals within the expression.`)];
+                if ("property" === t42.expressionContext && "layout" === t42.propertyType && !en(r22)) return [new it2(t42.key, t42.value, '"feature-state" data expressions are not supported with layout properties.')];
+                if ("filter" === t42.expressionContext && !en(r22)) return [new it2(t42.key, t42.value, '"feature-state" data expressions are not supported with filters.')];
+                if (t42.expressionContext && 0 === t42.expressionContext.indexOf("cluster")) {
+                  if (!rn(r22, ["zoom", "feature-state"])) return [new it2(t42.key, t42.value, '"zoom" and "feature-state" expressions are not supported with cluster properties.')];
+                  if ("cluster-initial" === t42.expressionContext && !tn(r22)) return [new it2(t42.key, t42.value, "Feature data expressions are not supported with initial expression part of cluster properties.")];
+                }
+                return [];
+              }
+              function Gn(t42) {
+                const e22 = t42.key, r22 = t42.value, n22 = t42.valueSpec, i22 = [];
+                return Array.isArray(n22.values) ? -1 === n22.values.indexOf(On(r22)) && i22.push(new it2(e22, r22, `expected one of [${n22.values.join(", ")}], ${JSON.stringify(r22)} found`)) : -1 === Object.keys(n22.values).indexOf(On(r22)) && i22.push(new it2(e22, r22, `expected one of [${Object.keys(n22.values).join(", ")}], ${JSON.stringify(r22)} found`)), i22;
+              }
+              function Kn(t42) {
+                return Mn(jn(t42.value)) ? Zn2(st2({}, t42, { expressionContext: "filter", valueSpec: { value: "boolean" } })) : Xn2(t42);
+              }
+              function Xn2(t42) {
+                const e22 = t42.value, r22 = t42.key;
+                if ("array" !== un(e22)) return [new it2(r22, e22, `array expected, ${un(e22)} found`)];
+                const n22 = t42.styleSpec;
+                let i22, s22 = [];
+                if (e22.length < 1) return [new it2(r22, e22, "filter array must have at least 1 element")];
+                switch (s22 = s22.concat(Gn({ key: `${r22}[0]`, value: e22[0], valueSpec: n22.filter_operator, style: t42.style, styleSpec: t42.styleSpec })), On(e22[0])) {
+                  case "<":
+                  case "<=":
+                  case ">":
+                  case ">=":
+                    e22.length >= 2 && "$type" === On(e22[1]) && s22.push(new it2(r22, e22, `"$type" cannot be use with operator "${e22[0]}"`));
+                  case "==":
+                  case "!=":
+                    3 !== e22.length && s22.push(new it2(r22, e22, `filter array for operator "${e22[0]}" must have 3 elements`));
+                  case "in":
+                  case "!in":
+                    e22.length >= 2 && (i22 = un(e22[1]), "string" !== i22 && s22.push(new it2(`${r22}[1]`, e22[1], `string expected, ${i22} found`)));
+                    for (let a22 = 2; a22 < e22.length; a22++) i22 = un(e22[a22]), "$type" === On(e22[1]) ? s22 = s22.concat(Gn({ key: `${r22}[${a22}]`, value: e22[a22], valueSpec: n22.geometry_type, style: t42.style, styleSpec: t42.styleSpec })) : "string" !== i22 && "number" !== i22 && "boolean" !== i22 && s22.push(new it2(`${r22}[${a22}]`, e22[a22], `string, number, or boolean expected, ${i22} found`));
+                    break;
+                  case "any":
+                  case "all":
+                  case "none":
+                    for (let n3 = 1; n3 < e22.length; n3++) s22 = s22.concat(Xn2({ key: `${r22}[${n3}]`, value: e22[n3], style: t42.style, styleSpec: t42.styleSpec }));
+                    break;
+                  case "has":
+                  case "!has":
+                    i22 = un(e22[1]), 2 !== e22.length ? s22.push(new it2(r22, e22, `filter array for "${e22[0]}" operator must have 2 elements`)) : "string" !== i22 && s22.push(new it2(`${r22}[1]`, e22[1], `string expected, ${i22} found`));
+                }
+                return s22;
+              }
+              function Hn(t42, e22) {
+                const r22 = t42.key, n22 = t42.validateSpec, i22 = t42.style, s22 = t42.styleSpec, a22 = t42.value, o22 = t42.objectKey, l22 = s22[`${e22}_${t42.layerType}`];
+                if (!l22) return [];
+                const u22 = o22.match(/^(.*)-transition$/);
+                if ("paint" === e22 && u22 && l22[u22[1]] && l22[u22[1]].transition) return n22({ key: r22, value: a22, valueSpec: s22.transition, style: i22, styleSpec: s22 });
+                const c22 = t42.valueSpec || l22[o22];
+                if (!c22) return [new it2(r22, a22, `unknown property "${o22}"`)];
+                let h22;
+                if ("string" === un(a22) && an(c22) && !c22.tokens && (h22 = /^{([^}]+)}$/.exec(a22))) return [new it2(r22, a22, `"${o22}" does not support interpolation syntax
+Use an identity property function instead: \`{ "type": "identity", "property": ${JSON.stringify(h22[1])} }\`.`)];
+                const p22 = [];
+                return "symbol" === t42.layerType && ("text-field" === o22 && i22 && !i22.glyphs && p22.push(new it2(r22, a22, 'use of "text-field" requires a style "glyphs" property')), "text-font" === o22 && cn(jn(a22)) && "identity" === On(a22.type) && p22.push(new it2(r22, a22, '"text-font" does not support identity functions'))), p22.concat(n22({ key: t42.key, value: a22, valueSpec: c22, style: i22, styleSpec: s22, expressionContext: "property", propertyType: e22, propertyKey: o22 }));
+              }
+              function Yn2(t42) {
+                return Hn(t42, "paint");
+              }
+              function Jn(t42) {
+                return Hn(t42, "layout");
+              }
+              function Wn(t42) {
+                let e22 = [];
+                const r22 = t42.value, n22 = t42.key, i22 = t42.style, s22 = t42.styleSpec;
+                r22.type || r22.ref || e22.push(new it2(n22, r22, 'either "type" or "ref" is required'));
+                let a22 = On(r22.type);
+                const o22 = On(r22.ref);
+                if (r22.id) {
+                  const s3 = On(r22.id);
+                  for (let a3 = 0; a3 < t42.arrayIndex; a3++) {
+                    const t5 = i22.layers[a3];
+                    On(t5.id) === s3 && e22.push(new it2(n22, r22.id, `duplicate layer id "${r22.id}", previously used at line ${t5.id.__line__}`));
+                  }
+                }
+                if ("ref" in r22) {
+                  let t5;
+                  ["type", "source", "source-layer", "filter", "layout"].forEach((t6) => {
+                    t6 in r22 && e22.push(new it2(n22, r22[t6], `"${t6}" is prohibited for ref layers`));
+                  }), i22.layers.forEach((e3) => {
+                    On(e3.id) === o22 && (t5 = e3);
+                  }), t5 ? t5.ref ? e22.push(new it2(n22, r22.ref, "ref cannot reference another ref layer")) : a22 = On(t5.type) : e22.push(new it2(n22, r22.ref, `ref layer "${o22}" not found`));
+                } else if ("background" !== a22) if (r22.source) {
+                  const t5 = i22.sources && i22.sources[r22.source], s3 = t5 && On(t5.type);
+                  t5 ? "vector" === s3 && "raster" === a22 ? e22.push(new it2(n22, r22.source, `layer "${r22.id}" requires a raster source`)) : "raster-dem" !== s3 && "hillshade" === a22 ? e22.push(new it2(n22, r22.source, `layer "${r22.id}" requires a raster-dem source`)) : "raster" === s3 && "raster" !== a22 ? e22.push(new it2(n22, r22.source, `layer "${r22.id}" requires a vector source`)) : "vector" !== s3 || r22["source-layer"] ? "raster-dem" === s3 && "hillshade" !== a22 ? e22.push(new it2(n22, r22.source, "raster-dem source can only be used with layer type 'hillshade'.")) : "line" !== a22 || !r22.paint || !r22.paint["line-gradient"] || "geojson" === s3 && t5.lineMetrics || e22.push(new it2(n22, r22, `layer "${r22.id}" specifies a line-gradient, which requires a GeoJSON source with \`lineMetrics\` enabled.`)) : e22.push(new it2(n22, r22, `layer "${r22.id}" must specify a "source-layer"`)) : e22.push(new it2(n22, r22.source, `source "${r22.source}" not found`));
+                } else e22.push(new it2(n22, r22, 'missing required property "source"'));
+                return e22 = e22.concat(Rn({ key: n22, value: r22, valueSpec: s22.layer, style: t42.style, styleSpec: t42.styleSpec, validateSpec: t42.validateSpec, objectElementValidators: { "*": () => [], type: () => t42.validateSpec({ key: `${n22}.type`, value: r22.type, valueSpec: s22.layer.type, style: t42.style, styleSpec: t42.styleSpec, validateSpec: t42.validateSpec, object: r22, objectKey: "type" }), filter: Kn, layout: (t5) => Rn({ layer: r22, key: t5.key, value: t5.value, style: t5.style, styleSpec: t5.styleSpec, validateSpec: t5.validateSpec, objectElementValidators: { "*": (t6) => Jn(st2({ layerType: a22 }, t6)) } }), paint: (t5) => Rn({ layer: r22, key: t5.key, value: t5.value, style: t5.style, styleSpec: t5.styleSpec, validateSpec: t5.validateSpec, objectElementValidators: { "*": (t6) => Yn2(st2({ layerType: a22 }, t6)) } }) } })), e22;
+              }
+              function Qn(t42) {
+                const e22 = t42.value, r22 = t42.key, n22 = un(e22);
+                return "string" !== n22 ? [new it2(r22, e22, `string expected, ${n22} found`)] : [];
+              }
+              const ti2 = { promoteId: function({ key: t42, value: e22 }) {
+                if ("string" === un(e22)) return Qn({ key: t42, value: e22 });
+                {
+                  const r22 = [];
+                  for (const n22 in e22) r22.push(...Qn({ key: `${t42}.${n22}`, value: e22[n22] }));
+                  return r22;
+                }
+              } };
+              function ei2(t42) {
+                const e22 = t42.value, r22 = t42.key, n22 = t42.styleSpec, i22 = t42.style, s22 = t42.validateSpec;
+                if (!e22.type) return [new it2(r22, e22, '"type" is required')];
+                const a22 = On(e22.type);
+                let o22;
+                switch (a22) {
+                  case "vector":
+                  case "raster":
+                    return o22 = Rn({ key: r22, value: e22, valueSpec: n22[`source_${a22.replace("-", "_")}`], style: t42.style, styleSpec: n22, objectElementValidators: ti2, validateSpec: s22 }), o22;
+                  case "raster-dem":
+                    return o22 = function(t5) {
+                      var e3;
+                      const r3 = null !== (e3 = t5.sourceName) && void 0 !== e3 ? e3 : "", n3 = t5.value, i3 = t5.styleSpec, s3 = i3.source_raster_dem, a3 = t5.style;
+                      let o3 = [];
+                      const l22 = un(n3);
+                      if (void 0 === n3) return o3;
+                      if ("object" !== l22) return o3.push(new it2("source_raster_dem", n3, `object expected, ${l22} found`)), o3;
+                      const u22 = "custom" === On(n3.encoding), c22 = ["redFactor", "greenFactor", "blueFactor", "baseShift"], h22 = t5.value.encoding ? `"${t5.value.encoding}"` : "Default";
+                      for (const e4 in n3) !u22 && c22.includes(e4) ? o3.push(new it2(e4, n3[e4], `In "${r3}": "${e4}" is only valid when "encoding" is set to "custom". ${h22} encoding found`)) : s3[e4] ? o3 = o3.concat(t5.validateSpec({ key: e4, value: n3[e4], valueSpec: s3[e4], validateSpec: t5.validateSpec, style: a3, styleSpec: i3 })) : o3.push(new it2(e4, n3[e4], `unknown property "${e4}"`));
+                      return o3;
+                    }({ sourceName: r22, value: e22, style: t42.style, styleSpec: n22, validateSpec: s22 }), o22;
+                  case "geojson":
+                    if (o22 = Rn({ key: r22, value: e22, valueSpec: n22.source_geojson, style: i22, styleSpec: n22, validateSpec: s22, objectElementValidators: ti2 }), e22.cluster) for (const t5 in e22.clusterProperties) {
+                      const [n3, i3] = e22.clusterProperties[t5], a3 = "string" == typeof n3 ? [n3, ["accumulated"], ["get", t5]] : n3;
+                      o22.push(...Zn2({ key: `${r22}.${t5}.map`, value: i3, expressionContext: "cluster-map" })), o22.push(...Zn2({ key: `${r22}.${t5}.reduce`, value: a3, expressionContext: "cluster-reduce" }));
+                    }
+                    return o22;
+                  case "video":
+                    return Rn({ key: r22, value: e22, valueSpec: n22.source_video, style: i22, validateSpec: s22, styleSpec: n22 });
+                  case "image":
+                    return Rn({ key: r22, value: e22, valueSpec: n22.source_image, style: i22, validateSpec: s22, styleSpec: n22 });
+                  case "canvas":
+                    return [new it2(r22, null, "Please use runtime APIs to add canvas sources, rather than including them in stylesheets.", "source.canvas")];
+                  default:
+                    return Gn({ key: `${r22}.type`, value: e22.type, valueSpec: { values: ["vector", "raster", "raster-dem", "geojson", "video", "image"] } });
+                }
+              }
+              function ri2(t42) {
+                const e22 = t42.value, r22 = t42.styleSpec, n22 = r22.light, i22 = t42.style;
+                let s22 = [];
+                const a22 = un(e22);
+                if (void 0 === e22) return s22;
+                if ("object" !== a22) return s22 = s22.concat([new it2("light", e22, `object expected, ${a22} found`)]), s22;
+                for (const a3 in e22) {
+                  const o22 = a3.match(/^(.*)-transition$/);
+                  s22 = s22.concat(o22 && n22[o22[1]] && n22[o22[1]].transition ? t42.validateSpec({ key: a3, value: e22[a3], valueSpec: r22.transition, validateSpec: t42.validateSpec, style: i22, styleSpec: r22 }) : n22[a3] ? t42.validateSpec({ key: a3, value: e22[a3], valueSpec: n22[a3], validateSpec: t42.validateSpec, style: i22, styleSpec: r22 }) : [new it2(a3, e22[a3], `unknown property "${a3}"`)]);
+                }
+                return s22;
+              }
+              function ni2(t42) {
+                const e22 = t42.value, r22 = t42.styleSpec, n22 = r22.sky, i22 = t42.style, s22 = un(e22);
+                if (void 0 === e22) return [];
+                if ("object" !== s22) return [new it2("sky", e22, `object expected, ${s22} found`)];
+                let a22 = [];
+                for (const s3 in e22) a22 = a22.concat(n22[s3] ? t42.validateSpec({ key: s3, value: e22[s3], valueSpec: n22[s3], style: i22, styleSpec: r22 }) : [new it2(s3, e22[s3], `unknown property "${s3}"`)]);
+                return a22;
+              }
+              function ii2(t42) {
+                const e22 = t42.value, r22 = t42.styleSpec, n22 = r22.terrain, i22 = t42.style;
+                let s22 = [];
+                const a22 = un(e22);
+                if (void 0 === e22) return s22;
+                if ("object" !== a22) return s22 = s22.concat([new it2("terrain", e22, `object expected, ${a22} found`)]), s22;
+                for (const a3 in e22) s22 = s22.concat(n22[a3] ? t42.validateSpec({ key: a3, value: e22[a3], valueSpec: n22[a3], validateSpec: t42.validateSpec, style: i22, styleSpec: r22 }) : [new it2(a3, e22[a3], `unknown property "${a3}"`)]);
+                return s22;
+              }
+              function si2(t42) {
+                let e22 = [];
+                const r22 = t42.value, n22 = t42.key;
+                if (Array.isArray(r22)) {
+                  const i22 = [], s22 = [];
+                  for (const a22 in r22) r22[a22].id && i22.includes(r22[a22].id) && e22.push(new it2(n22, r22, `all the sprites' ids must be unique, but ${r22[a22].id} is duplicated`)), i22.push(r22[a22].id), r22[a22].url && s22.includes(r22[a22].url) && e22.push(new it2(n22, r22, `all the sprites' URLs must be unique, but ${r22[a22].url} is duplicated`)), s22.push(r22[a22].url), e22 = e22.concat(Rn({ key: `${n22}[${a22}]`, value: r22[a22], valueSpec: { id: { type: "string", required: true }, url: { type: "string", required: true } }, validateSpec: t42.validateSpec }));
+                  return e22;
+                }
+                return Qn({ key: n22, value: r22 });
+              }
+              const ai2 = { "*": () => [], array: Un, boolean: function(t42) {
+                const e22 = t42.value, r22 = t42.key, n22 = un(e22);
+                return "boolean" !== n22 ? [new it2(r22, e22, `boolean expected, ${n22} found`)] : [];
+              }, number: qn, color: function(t42) {
+                const e22 = t42.key, r22 = t42.value, n22 = un(r22);
+                return "string" !== n22 ? [new it2(e22, r22, `color expected, ${n22} found`)] : Kt.parse(String(r22)) ? [] : [new it2(e22, r22, `color expected, "${r22}" found`)];
+              }, constants: Dn, enum: Gn, filter: Kn, function: Nn, layer: Wn, object: Rn, source: ei2, light: ri2, sky: ni2, terrain: ii2, projection: function(t42) {
+                const e22 = t42.value, r22 = t42.styleSpec, n22 = r22.projection, i22 = t42.style, s22 = un(e22);
+                if (void 0 === e22) return [];
+                if ("object" !== s22) return [new it2("projection", e22, `object expected, ${s22} found`)];
+                let a22 = [];
+                for (const s3 in e22) a22 = a22.concat(n22[s3] ? t42.validateSpec({ key: s3, value: e22[s3], valueSpec: n22[s3], style: i22, styleSpec: r22 }) : [new it2(s3, e22[s3], `unknown property "${s3}"`)]);
+                return a22;
+              }, string: Qn, formatted: function(t42) {
+                return 0 === Qn(t42).length ? [] : Zn2(t42);
+              }, resolvedImage: function(t42) {
+                return 0 === Qn(t42).length ? [] : Zn2(t42);
+              }, padding: function(t42) {
+                const e22 = t42.key, r22 = t42.value;
+                if ("array" === un(r22)) {
+                  if (r22.length < 1 || r22.length > 4) return [new it2(e22, r22, `padding requires 1 to 4 values; ${r22.length} values found`)];
+                  const n22 = { type: "number" };
+                  let i22 = [];
+                  for (let s22 = 0; s22 < r22.length; s22++) i22 = i22.concat(t42.validateSpec({ key: `${e22}[${s22}]`, value: r22[s22], validateSpec: t42.validateSpec, valueSpec: n22 }));
+                  return i22;
+                }
+                return qn({ key: e22, value: r22, valueSpec: {} });
+              }, variableAnchorOffsetCollection: function(t42) {
+                const e22 = t42.key, r22 = t42.value, n22 = un(r22), i22 = t42.styleSpec;
+                if ("array" !== n22 || r22.length < 1 || r22.length % 2 != 0) return [new it2(e22, r22, "variableAnchorOffsetCollection requires a non-empty array of even length")];
+                let s22 = [];
+                for (let n3 = 0; n3 < r22.length; n3 += 2) s22 = s22.concat(Gn({ key: `${e22}[${n3}]`, value: r22[n3], valueSpec: i22.layout_symbol["text-anchor"] })), s22 = s22.concat(Un({ key: `${e22}[${n3 + 1}]`, value: r22[n3 + 1], valueSpec: { length: 2, value: "number" }, validateSpec: t42.validateSpec, style: t42.style, styleSpec: i22 }));
+                return s22;
+              }, sprite: si2 };
+              function oi2(t42) {
+                const e22 = t42.value, r22 = t42.valueSpec, n22 = t42.styleSpec;
+                return t42.validateSpec = oi2, r22.expression && cn(On(e22)) ? Nn(t42) : r22.expression && vn(jn(e22)) ? Zn2(t42) : r22.type && ai2[r22.type] ? ai2[r22.type](t42) : Rn(st2({}, t42, { valueSpec: r22.type ? n22[r22.type] : r22 }));
+              }
+              function li2(t42) {
+                const e22 = t42.value, r22 = t42.key, n22 = Qn(t42);
+                return n22.length || (-1 === e22.indexOf("{fontstack}") && n22.push(new it2(r22, e22, '"glyphs" url must include a "{fontstack}" token')), -1 === e22.indexOf("{range}") && n22.push(new it2(r22, e22, '"glyphs" url must include a "{range}" token'))), n22;
+              }
+              function ui2(t42, e22 = G2) {
+                let r22 = [];
+                return r22 = r22.concat(oi2({ key: "", value: t42, valueSpec: e22.$root, styleSpec: e22, style: t42, validateSpec: oi2, objectElementValidators: { glyphs: li2, "*": () => [] } })), t42.constants && (r22 = r22.concat(Dn({ key: "constants", value: t42.constants }))), hi2(r22);
+              }
+              function ci2(t42) {
+                return function(e22) {
+                  return t42(__spreadProps(__spreadValues({}, e22), { validateSpec: oi2 }));
+                };
+              }
+              function hi2(t42) {
+                return [].concat(t42).sort((t5, e22) => t5.line - e22.line);
+              }
+              function pi2(t42) {
+                return function(...e22) {
+                  return hi2(t42.apply(this, e22));
+                };
+              }
+              ui2.source = pi2(ci2(ei2)), ui2.sprite = pi2(ci2(si2)), ui2.glyphs = pi2(ci2(li2)), ui2.light = pi2(ci2(ri2)), ui2.sky = pi2(ci2(ni2)), ui2.terrain = pi2(ci2(ii2)), ui2.layer = pi2(ci2(Wn)), ui2.filter = pi2(ci2(Kn)), ui2.paintProperty = pi2(ci2(Yn2)), ui2.layoutProperty = pi2(ci2(Jn));
+              const fi2 = ui2, di2 = fi2.light, yi2 = fi2.sky, mi2 = fi2.paintProperty, gi2 = fi2.layoutProperty;
+              function xi2(t42, e22) {
+                let r22 = false;
+                if (e22 && e22.length) for (const n22 of e22) t42.fire(new N2(new Error(n22.message))), r22 = true;
+                return r22;
+              }
+              class vi2 {
+                constructor(t42, e22, r22) {
+                  const n22 = this.cells = [];
+                  if (t42 instanceof ArrayBuffer) {
+                    this.arrayBuffer = t42;
+                    const i3 = new Int32Array(this.arrayBuffer);
+                    t42 = i3[0], this.d = (e22 = i3[1]) + 2 * (r22 = i3[2]);
+                    for (let t5 = 0; t5 < this.d * this.d; t5++) {
+                      const e3 = i3[3 + t5], r3 = i3[3 + t5 + 1];
+                      n22.push(e3 === r3 ? null : i3.subarray(e3, r3));
+                    }
+                    const s22 = i3[3 + n22.length + 1];
+                    this.keys = i3.subarray(i3[3 + n22.length], s22), this.bboxes = i3.subarray(s22), this.insert = this._insertReadonly;
+                  } else {
+                    this.d = e22 + 2 * r22;
+                    for (let t5 = 0; t5 < this.d * this.d; t5++) n22.push([]);
+                    this.keys = [], this.bboxes = [];
+                  }
+                  this.n = e22, this.extent = t42, this.padding = r22, this.scale = e22 / t42, this.uid = 0;
+                  const i22 = r22 / e22 * t42;
+                  this.min = -i22, this.max = t42 + i22;
+                }
+                insert(t42, e22, r22, n22, i22) {
+                  this._forEachCell(e22, r22, n22, i22, this._insertCell, this.uid++, void 0, void 0), this.keys.push(t42), this.bboxes.push(e22), this.bboxes.push(r22), this.bboxes.push(n22), this.bboxes.push(i22);
+                }
+                _insertReadonly() {
+                  throw new Error("Cannot insert into a GridIndex created from an ArrayBuffer.");
+                }
+                _insertCell(t42, e22, r22, n22, i22, s22) {
+                  this.cells[i22].push(s22);
+                }
+                query(t42, e22, r22, n22, i22) {
+                  const s22 = this.min, a22 = this.max;
+                  if (t42 <= s22 && e22 <= s22 && a22 <= r22 && a22 <= n22 && !i22) return Array.prototype.slice.call(this.keys);
+                  {
+                    const s3 = [];
+                    return this._forEachCell(t42, e22, r22, n22, this._queryCell, s3, {}, i22), s3;
+                  }
+                }
+                _queryCell(t42, e22, r22, n22, i22, s22, a22, o22) {
+                  const l22 = this.cells[i22];
+                  if (null !== l22) {
+                    const i3 = this.keys, u22 = this.bboxes;
+                    for (let c22 = 0; c22 < l22.length; c22++) {
+                      const h22 = l22[c22];
+                      if (void 0 === a22[h22]) {
+                        const l3 = 4 * h22;
+                        (o22 ? o22(u22[l3 + 0], u22[l3 + 1], u22[l3 + 2], u22[l3 + 3]) : t42 <= u22[l3 + 2] && e22 <= u22[l3 + 3] && r22 >= u22[l3 + 0] && n22 >= u22[l3 + 1]) ? (a22[h22] = true, s22.push(i3[h22])) : a22[h22] = false;
+                      }
+                    }
+                  }
+                }
+                _forEachCell(t42, e22, r22, n22, i22, s22, a22, o22) {
+                  const l22 = this._convertToCellCoord(t42), u22 = this._convertToCellCoord(e22), c22 = this._convertToCellCoord(r22), h22 = this._convertToCellCoord(n22);
+                  for (let p22 = l22; p22 <= c22; p22++) for (let l3 = u22; l3 <= h22; l3++) {
+                    const u3 = this.d * l3 + p22;
+                    if ((!o22 || o22(this._convertFromCellCoord(p22), this._convertFromCellCoord(l3), this._convertFromCellCoord(p22 + 1), this._convertFromCellCoord(l3 + 1))) && i22.call(this, t42, e22, r22, n22, u3, s22, a22, o22)) return;
+                  }
+                }
+                _convertFromCellCoord(t42) {
+                  return (t42 - this.padding) / this.scale;
+                }
+                _convertToCellCoord(t42) {
+                  return Math.max(0, Math.min(this.d - 1, Math.floor(t42 * this.scale) + this.padding));
+                }
+                toArrayBuffer() {
+                  if (this.arrayBuffer) return this.arrayBuffer;
+                  const t42 = this.cells, e22 = 3 + this.cells.length + 1 + 1;
+                  let r22 = 0;
+                  for (let t5 = 0; t5 < this.cells.length; t5++) r22 += this.cells[t5].length;
+                  const n22 = new Int32Array(e22 + r22 + this.keys.length + this.bboxes.length);
+                  n22[0] = this.extent, n22[1] = this.n, n22[2] = this.padding;
+                  let i22 = e22;
+                  for (let e3 = 0; e3 < t42.length; e3++) {
+                    const r3 = t42[e3];
+                    n22[3 + e3] = i22, n22.set(r3, i22), i22 += r3.length;
+                  }
+                  return n22[3 + t42.length] = i22, n22.set(this.keys, i22), i22 += this.keys.length, n22[3 + t42.length + 1] = i22, n22.set(this.bboxes, i22), i22 += this.bboxes.length, n22.buffer;
+                }
+                static serialize(t42, e22) {
+                  const r22 = t42.toArrayBuffer();
+                  return e22 && e22.push(r22), { buffer: r22 };
+                }
+                static deserialize(t42) {
+                  return new vi2(t42.buffer);
+                }
+              }
+              const bi2 = {};
+              function wi2(t42, e22, r22 = {}) {
+                if (bi2[t42]) throw new Error(`${t42} is already registered.`);
+                Object.defineProperty(e22, "_classRegistryKey", { value: t42, writeable: false }), bi2[t42] = { klass: e22, omit: r22.omit || [], shallow: r22.shallow || [] };
+              }
+              wi2("Object", Object), wi2("TransferableGridIndex", vi2), wi2("Color", Kt), wi2("Error", Error), wi2("AJAXError", L2), wi2("ResolvedImage", te2), wi2("StylePropertyFunction", Sn), wi2("StyleExpression", xn, { omit: ["_evaluator"] }), wi2("ZoomDependentExpression", _n), wi2("ZoomConstantExpression", wn), wi2("CompoundExpression", Xr, { omit: ["_evaluate"] });
+              for (const t42 in Kr) Kr[t42]._classRegistryKey || wi2(`Expression_${t42}`, Kr[t42]);
+              function _i(t42) {
+                return t42 && "undefined" != typeof ArrayBuffer && (t42 instanceof ArrayBuffer || t42.constructor && "ArrayBuffer" === t42.constructor.name);
+              }
+              function Ai2(t42) {
+                return t42.$name || t42.constructor._classRegistryKey;
+              }
+              function Si2(t42) {
+                return !function(t5) {
+                  if (null === t5 || "object" != typeof t5) return false;
+                  const e22 = Ai2(t5);
+                  return !(!e22 || "Object" === e22);
+                }(t42) && (null == t42 || "boolean" == typeof t42 || "number" == typeof t42 || "string" == typeof t42 || t42 instanceof Boolean || t42 instanceof Number || t42 instanceof String || t42 instanceof Date || t42 instanceof RegExp || t42 instanceof Blob || t42 instanceof Error || _i(t42) || I2(t42) || ArrayBuffer.isView(t42) || t42 instanceof ImageData);
+              }
+              function ki2(t42, e22) {
+                if (Si2(t42)) return (_i(t42) || I2(t42)) && e22 && e22.push(t42), ArrayBuffer.isView(t42) && e22 && e22.push(t42.buffer), t42 instanceof ImageData && e22 && e22.push(t42.data.buffer), t42;
+                if (Array.isArray(t42)) {
+                  const r3 = [];
+                  for (const n3 of t42) r3.push(ki2(n3, e22));
+                  return r3;
+                }
+                if ("object" != typeof t42) throw new Error("can't serialize object of type " + typeof t42);
+                const r22 = Ai2(t42);
+                if (!r22) throw new Error(`can't serialize object of unregistered class ${t42.constructor.name}`);
+                if (!bi2[r22]) throw new Error(`${r22} is not registered.`);
+                const { klass: n22 } = bi2[r22], i22 = n22.serialize ? n22.serialize(t42, e22) : {};
+                if (n22.serialize) {
+                  if (e22 && i22 === e22[e22.length - 1]) throw new Error("statically serialized object won't survive transfer of $name property");
+                } else {
+                  for (const n3 in t42) {
+                    if (!t42.hasOwnProperty(n3)) continue;
+                    if (bi2[r22].omit.indexOf(n3) >= 0) continue;
+                    const s22 = t42[n3];
+                    i22[n3] = bi2[r22].shallow.indexOf(n3) >= 0 ? s22 : ki2(s22, e22);
+                  }
+                  t42 instanceof Error && (i22.message = t42.message);
+                }
+                if (i22.$name) throw new Error("$name property is reserved for worker serialization logic.");
+                return "Object" !== r22 && (i22.$name = r22), i22;
+              }
+              function Mi2(t42) {
+                if (Si2(t42)) return t42;
+                if (Array.isArray(t42)) return t42.map(Mi2);
+                if ("object" != typeof t42) throw new Error("can't deserialize object of type " + typeof t42);
+                const e22 = Ai2(t42) || "Object";
+                if (!bi2[e22]) throw new Error(`can't deserialize unregistered class ${e22}`);
+                const { klass: r22 } = bi2[e22];
+                if (!r22) throw new Error(`can't deserialize unregistered class ${e22}`);
+                if (r22.deserialize) return r22.deserialize(t42);
+                const n22 = Object.create(r22.prototype);
+                for (const r3 of Object.keys(t42)) {
+                  if ("$name" === r3) continue;
+                  const i22 = t42[r3];
+                  n22[r3] = bi2[e22].shallow.indexOf(r3) >= 0 ? i22 : Mi2(i22);
+                }
+                return n22;
+              }
+              class Ii2 {
+                constructor() {
+                  this.first = true;
+                }
+                update(t42, e22) {
+                  const r22 = Math.floor(t42);
+                  return this.first ? (this.first = false, this.lastIntegerZoom = r22, this.lastIntegerZoomTime = 0, this.lastZoom = t42, this.lastFloorZoom = r22, true) : (this.lastFloorZoom > r22 ? (this.lastIntegerZoom = r22 + 1, this.lastIntegerZoomTime = e22) : this.lastFloorZoom < r22 && (this.lastIntegerZoom = r22, this.lastIntegerZoomTime = e22), t42 !== this.lastZoom && (this.lastZoom = t42, this.lastFloorZoom = r22, true));
+                }
+              }
+              const zi2 = { "Latin-1 Supplement": (t42) => t42 >= 128 && t42 <= 255, "Hangul Jamo": (t42) => t42 >= 4352 && t42 <= 4607, Khmer: (t42) => t42 >= 6016 && t42 <= 6143, "General Punctuation": (t42) => t42 >= 8192 && t42 <= 8303, "Letterlike Symbols": (t42) => t42 >= 8448 && t42 <= 8527, "Number Forms": (t42) => t42 >= 8528 && t42 <= 8591, "Miscellaneous Technical": (t42) => t42 >= 8960 && t42 <= 9215, "Control Pictures": (t42) => t42 >= 9216 && t42 <= 9279, "Optical Character Recognition": (t42) => t42 >= 9280 && t42 <= 9311, "Enclosed Alphanumerics": (t42) => t42 >= 9312 && t42 <= 9471, "Geometric Shapes": (t42) => t42 >= 9632 && t42 <= 9727, "Miscellaneous Symbols": (t42) => t42 >= 9728 && t42 <= 9983, "Miscellaneous Symbols and Arrows": (t42) => t42 >= 11008 && t42 <= 11263, "Ideographic Description Characters": (t42) => t42 >= 12272 && t42 <= 12287, "CJK Symbols and Punctuation": (t42) => t42 >= 12288 && t42 <= 12351, Katakana: (t42) => t42 >= 12448 && t42 <= 12543, Kanbun: (t42) => t42 >= 12688 && t42 <= 12703, "CJK Strokes": (t42) => t42 >= 12736 && t42 <= 12783, "Enclosed CJK Letters and Months": (t42) => t42 >= 12800 && t42 <= 13055, "CJK Compatibility": (t42) => t42 >= 13056 && t42 <= 13311, "Yijing Hexagram Symbols": (t42) => t42 >= 19904 && t42 <= 19967, "Private Use Area": (t42) => t42 >= 57344 && t42 <= 63743, "Vertical Forms": (t42) => t42 >= 65040 && t42 <= 65055, "CJK Compatibility Forms": (t42) => t42 >= 65072 && t42 <= 65103, "Small Form Variants": (t42) => t42 >= 65104 && t42 <= 65135, "Halfwidth and Fullwidth Forms": (t42) => t42 >= 65280 && t42 <= 65519 };
+              function Pi2(t42) {
+                for (const e22 of t42) if (Ti2(e22.charCodeAt(0))) return true;
+                return false;
+              }
+              function Ci2(t42) {
+                for (const e22 of t42) if (!Ei2(e22.charCodeAt(0))) return false;
+                return true;
+              }
+              function Bi2(t42) {
+                const e22 = t42.map((t5) => {
+                  try {
+                    return new RegExp(`\\p{sc=${t5}}`, "u").source;
+                  } catch (t6) {
+                    return null;
+                  }
+                }).filter((t5) => t5);
+                return new RegExp(e22.join("|"), "u");
+              }
+              const Vi2 = Bi2(["Arab", "Dupl", "Mong", "Ougr", "Syrc"]);
+              function Ei2(t42) {
+                return !Vi2.test(String.fromCodePoint(t42));
+              }
+              const Fi2 = Bi2(["Bopo", "Hani", "Hira", "Kana", "Kits", "Nshu", "Tang", "Yiii"]);
+              function Ti2(t42) {
+                return !(746 !== t42 && 747 !== t42 && (t42 < 4352 || !(zi2["CJK Compatibility Forms"](t42) && !(t42 >= 65097 && t42 <= 65103) || zi2["CJK Compatibility"](t42) || zi2["CJK Strokes"](t42) || !(!zi2["CJK Symbols and Punctuation"](t42) || t42 >= 12296 && t42 <= 12305 || t42 >= 12308 && t42 <= 12319 || 12336 === t42) || zi2["Enclosed CJK Letters and Months"](t42) || zi2["Ideographic Description Characters"](t42) || zi2.Kanbun(t42) || zi2.Katakana(t42) && 12540 !== t42 || !(!zi2["Halfwidth and Fullwidth Forms"](t42) || 65288 === t42 || 65289 === t42 || 65293 === t42 || t42 >= 65306 && t42 <= 65310 || 65339 === t42 || 65341 === t42 || 65343 === t42 || t42 >= 65371 && t42 <= 65503 || 65507 === t42 || t42 >= 65512 && t42 <= 65519) || !(!zi2["Small Form Variants"](t42) || t42 >= 65112 && t42 <= 65118 || t42 >= 65123 && t42 <= 65126) || zi2["Vertical Forms"](t42) || zi2["Yijing Hexagram Symbols"](t42) || new RegExp("\\p{sc=Cans}", "u").test(String.fromCodePoint(t42)) || new RegExp("\\p{sc=Hang}", "u").test(String.fromCodePoint(t42)) || Fi2.test(String.fromCodePoint(t42)))));
+              }
+              function $i2(t42) {
+                return !(Ti2(t42) || function(t5) {
+                  return !!(zi2["Latin-1 Supplement"](t5) && (167 === t5 || 169 === t5 || 174 === t5 || 177 === t5 || 188 === t5 || 189 === t5 || 190 === t5 || 215 === t5 || 247 === t5) || zi2["General Punctuation"](t5) && (8214 === t5 || 8224 === t5 || 8225 === t5 || 8240 === t5 || 8241 === t5 || 8251 === t5 || 8252 === t5 || 8258 === t5 || 8263 === t5 || 8264 === t5 || 8265 === t5 || 8273 === t5) || zi2["Letterlike Symbols"](t5) || zi2["Number Forms"](t5) || zi2["Miscellaneous Technical"](t5) && (t5 >= 8960 && t5 <= 8967 || t5 >= 8972 && t5 <= 8991 || t5 >= 8996 && t5 <= 9e3 || 9003 === t5 || t5 >= 9085 && t5 <= 9114 || t5 >= 9150 && t5 <= 9165 || 9167 === t5 || t5 >= 9169 && t5 <= 9179 || t5 >= 9186 && t5 <= 9215) || zi2["Control Pictures"](t5) && 9251 !== t5 || zi2["Optical Character Recognition"](t5) || zi2["Enclosed Alphanumerics"](t5) || zi2["Geometric Shapes"](t5) || zi2["Miscellaneous Symbols"](t5) && !(t5 >= 9754 && t5 <= 9759) || zi2["Miscellaneous Symbols and Arrows"](t5) && (t5 >= 11026 && t5 <= 11055 || t5 >= 11088 && t5 <= 11097 || t5 >= 11192 && t5 <= 11243) || zi2["CJK Symbols and Punctuation"](t5) || zi2.Katakana(t5) || zi2["Private Use Area"](t5) || zi2["CJK Compatibility Forms"](t5) || zi2["Small Form Variants"](t5) || zi2["Halfwidth and Fullwidth Forms"](t5) || 8734 === t5 || 8756 === t5 || 8757 === t5 || t5 >= 9984 && t5 <= 10087 || t5 >= 10102 && t5 <= 10131 || 65532 === t5 || 65533 === t5);
+                }(t42));
+              }
+              const Li2 = Bi2(["Adlm", "Arab", "Armi", "Avst", "Chrs", "Cprt", "Egyp", "Elym", "Gara", "Hatr", "Hebr", "Hung", "Khar", "Lydi", "Mand", "Mani", "Mend", "Merc", "Mero", "Narb", "Nbat", "Nkoo", "Orkh", "Palm", "Phli", "Phlp", "Phnx", "Prti", "Rohg", "Samr", "Sarb", "Sogo", "Syrc", "Thaa", "Todr", "Yezi"]);
+              function Di2(t42) {
+                return Li2.test(String.fromCodePoint(t42));
+              }
+              function Oi2(t42, e22) {
+                return !(!e22 && Di2(t42) || t42 >= 2304 && t42 <= 3583 || t42 >= 3840 && t42 <= 4255 || zi2.Khmer(t42));
+              }
+              function ji2(t42) {
+                for (const e22 of t42) if (Di2(e22.charCodeAt(0))) return true;
+                return false;
+              }
+              const Ri2 = new class {
+                constructor() {
+                  this.applyArabicShaping = null, this.processBidirectionalText = null, this.processStyledBidirectionalText = null, this.pluginStatus = "unavailable", this.pluginURL = null;
+                }
+                setState(t42) {
+                  this.pluginStatus = t42.pluginStatus, this.pluginURL = t42.pluginURL;
+                }
+                getState() {
+                  return { pluginStatus: this.pluginStatus, pluginURL: this.pluginURL };
+                }
+                setMethods(t42) {
+                  this.applyArabicShaping = t42.applyArabicShaping, this.processBidirectionalText = t42.processBidirectionalText, this.processStyledBidirectionalText = t42.processStyledBidirectionalText;
+                }
+                isParsed() {
+                  return null != this.applyArabicShaping && null != this.processBidirectionalText && null != this.processStyledBidirectionalText;
+                }
+                getPluginURL() {
+                  return this.pluginURL;
+                }
+                getRTLTextPluginStatus() {
+                  return this.pluginStatus;
+                }
+              }();
+              class Ui2 {
+                constructor(t42, e22) {
+                  this.zoom = t42, e22 ? (this.now = e22.now, this.fadeDuration = e22.fadeDuration, this.zoomHistory = e22.zoomHistory, this.transition = e22.transition) : (this.now = 0, this.fadeDuration = 0, this.zoomHistory = new Ii2(), this.transition = {});
+                }
+                isSupportedScript(t42) {
+                  return function(t5, e22) {
+                    for (const r22 of t5) if (!Oi2(r22.charCodeAt(0), e22)) return false;
+                    return true;
+                  }(t42, "loaded" === Ri2.getRTLTextPluginStatus());
+                }
+                crossFadingFactor() {
+                  return 0 === this.fadeDuration ? 1 : Math.min((this.now - this.zoomHistory.lastIntegerZoomTime) / this.fadeDuration, 1);
+                }
+                getCrossfadeParameters() {
+                  const t42 = this.zoom, e22 = t42 - Math.floor(t42), r22 = this.crossFadingFactor();
+                  return t42 > this.zoomHistory.lastIntegerZoom ? { fromScale: 2, toScale: 1, t: e22 + (1 - e22) * r22 } : { fromScale: 0.5, toScale: 1, t: 1 - (1 - r22) * e22 };
+                }
+              }
+              class qi2 {
+                constructor(t42, e22) {
+                  this.property = t42, this.value = e22, this.expression = function(t5, e3) {
+                    if (cn(t5)) return new Sn(t5, e3);
+                    if (vn(t5)) {
+                      const r22 = An(t5, e3);
+                      if ("error" === r22.result) throw new Error(r22.value.map((t6) => `${t6.key}: ${t6.message}`).join(", "));
+                      return r22.value;
+                    }
+                    {
+                      let r22 = t5;
+                      return "color" === e3.type && "string" == typeof t5 ? r22 = Kt.parse(t5) : "padding" !== e3.type || "number" != typeof t5 && !Array.isArray(t5) ? "variableAnchorOffsetCollection" === e3.type && Array.isArray(t5) && (r22 = Qt.parse(t5)) : r22 = Jt.parse(t5), { kind: "constant", evaluate: () => r22 };
+                    }
+                  }(void 0 === e22 ? t42.specification.default : e22, t42.specification);
+                }
+                isDataDriven() {
+                  return "source" === this.expression.kind || "composite" === this.expression.kind;
+                }
+                possiblyEvaluate(t42, e22, r22) {
+                  return this.property.possiblyEvaluate(this, t42, e22, r22);
+                }
+              }
+              class Ni2 {
+                constructor(t42) {
+                  this.property = t42, this.value = new qi2(t42, void 0);
+                }
+                transitioned(t42, e22) {
+                  return new Gi2(this.property, this.value, e22, g2({}, t42.transition, this.transition), t42.now);
+                }
+                untransitioned() {
+                  return new Gi2(this.property, this.value, null, {}, 0);
+                }
+              }
+              class Zi2 {
+                constructor(t42) {
+                  this._properties = t42, this._values = Object.create(t42.defaultTransitionablePropertyValues);
+                }
+                getValue(t42) {
+                  return w2(this._values[t42].value.value);
+                }
+                setValue(t42, e22) {
+                  Object.prototype.hasOwnProperty.call(this._values, t42) || (this._values[t42] = new Ni2(this._values[t42].property)), this._values[t42].value = new qi2(this._values[t42].property, null === e22 ? void 0 : w2(e22));
+                }
+                getTransition(t42) {
+                  return w2(this._values[t42].transition);
+                }
+                setTransition(t42, e22) {
+                  Object.prototype.hasOwnProperty.call(this._values, t42) || (this._values[t42] = new Ni2(this._values[t42].property)), this._values[t42].transition = w2(e22) || void 0;
+                }
+                serialize() {
+                  const t42 = {};
+                  for (const e22 of Object.keys(this._values)) {
+                    const r22 = this.getValue(e22);
+                    void 0 !== r22 && (t42[e22] = r22);
+                    const n22 = this.getTransition(e22);
+                    void 0 !== n22 && (t42[`${e22}-transition`] = n22);
+                  }
+                  return t42;
+                }
+                transitioned(t42, e22) {
+                  const r22 = new Ki2(this._properties);
+                  for (const n22 of Object.keys(this._values)) r22._values[n22] = this._values[n22].transitioned(t42, e22._values[n22]);
+                  return r22;
+                }
+                untransitioned() {
+                  const t42 = new Ki2(this._properties);
+                  for (const e22 of Object.keys(this._values)) t42._values[e22] = this._values[e22].untransitioned();
+                  return t42;
+                }
+              }
+              class Gi2 {
+                constructor(t42, e22, r22, n22, i22) {
+                  this.property = t42, this.value = e22, this.begin = i22 + n22.delay || 0, this.end = this.begin + n22.duration || 0, t42.specification.transition && (n22.delay || n22.duration) && (this.prior = r22);
+                }
+                possiblyEvaluate(t42, e22, r22) {
+                  const n22 = t42.now || 0, i22 = this.value.possiblyEvaluate(t42, e22, r22), s22 = this.prior;
+                  if (s22) {
+                    if (n22 > this.end) return this.prior = null, i22;
+                    if (this.value.isDataDriven()) return this.prior = null, i22;
+                    if (n22 < this.begin) return s22.possiblyEvaluate(t42, e22, r22);
+                    {
+                      const a22 = (n22 - this.begin) / (this.end - this.begin);
+                      return this.property.interpolate(s22.possiblyEvaluate(t42, e22, r22), i22, function(t5) {
+                        if (t5 <= 0) return 0;
+                        if (t5 >= 1) return 1;
+                        const e3 = t5 * t5, r3 = e3 * t5;
+                        return 4 * (t5 < 0.5 ? r3 : 3 * (t5 - e3) + r3 - 0.75);
+                      }(a22));
+                    }
+                  }
+                  return i22;
+                }
+              }
+              class Ki2 {
+                constructor(t42) {
+                  this._properties = t42, this._values = Object.create(t42.defaultTransitioningPropertyValues);
+                }
+                possiblyEvaluate(t42, e22, r22) {
+                  const n22 = new Yi2(this._properties);
+                  for (const i22 of Object.keys(this._values)) n22._values[i22] = this._values[i22].possiblyEvaluate(t42, e22, r22);
+                  return n22;
+                }
+                hasTransition() {
+                  for (const t42 of Object.keys(this._values)) if (this._values[t42].prior) return true;
+                  return false;
+                }
+              }
+              class Xi2 {
+                constructor(t42) {
+                  this._properties = t42, this._values = Object.create(t42.defaultPropertyValues);
+                }
+                hasValue(t42) {
+                  return void 0 !== this._values[t42].value;
+                }
+                getValue(t42) {
+                  return w2(this._values[t42].value);
+                }
+                setValue(t42, e22) {
+                  this._values[t42] = new qi2(this._values[t42].property, null === e22 ? void 0 : w2(e22));
+                }
+                serialize() {
+                  const t42 = {};
+                  for (const e22 of Object.keys(this._values)) {
+                    const r22 = this.getValue(e22);
+                    void 0 !== r22 && (t42[e22] = r22);
+                  }
+                  return t42;
+                }
+                possiblyEvaluate(t42, e22, r22) {
+                  const n22 = new Yi2(this._properties);
+                  for (const i22 of Object.keys(this._values)) n22._values[i22] = this._values[i22].possiblyEvaluate(t42, e22, r22);
+                  return n22;
+                }
+              }
+              class Hi2 {
+                constructor(t42, e22, r22) {
+                  this.property = t42, this.value = e22, this.parameters = r22;
+                }
+                isConstant() {
+                  return "constant" === this.value.kind;
+                }
+                constantOr(t42) {
+                  return "constant" === this.value.kind ? this.value.value : t42;
+                }
+                evaluate(t42, e22, r22, n22) {
+                  return this.property.evaluate(this.value, this.parameters, t42, e22, r22, n22);
+                }
+              }
+              class Yi2 {
+                constructor(t42) {
+                  this._properties = t42, this._values = Object.create(t42.defaultPossiblyEvaluatedValues);
+                }
+                get(t42) {
+                  return this._values[t42];
+                }
+              }
+              class Ji2 {
+                constructor(t42) {
+                  this.specification = t42;
+                }
+                possiblyEvaluate(t42, e22) {
+                  if (t42.isDataDriven()) throw new Error("Value should not be data driven");
+                  return t42.expression.evaluate(e22);
+                }
+                interpolate(t42, e22, r22) {
+                  const n22 = Ce2[this.specification.type];
+                  return n22 ? n22(t42, e22, r22) : t42;
+                }
+              }
+              class Wi2 {
+                constructor(t42, e22) {
+                  this.specification = t42, this.overrides = e22;
+                }
+                possiblyEvaluate(t42, e22, r22, n22) {
+                  return new Hi2(this, "constant" === t42.expression.kind || "camera" === t42.expression.kind ? { kind: "constant", value: t42.expression.evaluate(e22, null, {}, r22, n22) } : t42.expression, e22);
+                }
+                interpolate(t42, e22, r22) {
+                  if ("constant" !== t42.value.kind || "constant" !== e22.value.kind) return t42;
+                  if (void 0 === t42.value.value || void 0 === e22.value.value) return new Hi2(this, { kind: "constant", value: void 0 }, t42.parameters);
+                  const n22 = Ce2[this.specification.type];
+                  if (n22) {
+                    const i22 = n22(t42.value.value, e22.value.value, r22);
+                    return new Hi2(this, { kind: "constant", value: i22 }, t42.parameters);
+                  }
+                  return t42;
+                }
+                evaluate(t42, e22, r22, n22, i22, s22) {
+                  return "constant" === t42.kind ? t42.value : t42.evaluate(e22, r22, n22, i22, s22);
+                }
+              }
+              class Qi2 extends Wi2 {
+                possiblyEvaluate(t42, e22, r22, n22) {
+                  if (void 0 === t42.value) return new Hi2(this, { kind: "constant", value: void 0 }, e22);
+                  if ("constant" === t42.expression.kind) {
+                    const i22 = t42.expression.evaluate(e22, null, {}, r22, n22), s22 = "resolvedImage" === t42.property.specification.type && "string" != typeof i22 ? i22.name : i22, a22 = this._calculate(s22, s22, s22, e22);
+                    return new Hi2(this, { kind: "constant", value: a22 }, e22);
+                  }
+                  if ("camera" === t42.expression.kind) {
+                    const r3 = this._calculate(t42.expression.evaluate({ zoom: e22.zoom - 1 }), t42.expression.evaluate({ zoom: e22.zoom }), t42.expression.evaluate({ zoom: e22.zoom + 1 }), e22);
+                    return new Hi2(this, { kind: "constant", value: r3 }, e22);
+                  }
+                  return new Hi2(this, t42.expression, e22);
+                }
+                evaluate(t42, e22, r22, n22, i22, s22) {
+                  if ("source" === t42.kind) {
+                    const a22 = t42.evaluate(e22, r22, n22, i22, s22);
+                    return this._calculate(a22, a22, a22, e22);
+                  }
+                  return "composite" === t42.kind ? this._calculate(t42.evaluate({ zoom: Math.floor(e22.zoom) - 1 }, r22, n22), t42.evaluate({ zoom: Math.floor(e22.zoom) }, r22, n22), t42.evaluate({ zoom: Math.floor(e22.zoom) + 1 }, r22, n22), e22) : t42.value;
+                }
+                _calculate(t42, e22, r22, n22) {
+                  return n22.zoom > n22.zoomHistory.lastIntegerZoom ? { from: t42, to: e22 } : { from: r22, to: e22 };
+                }
+                interpolate(t42) {
+                  return t42;
+                }
+              }
+              class ts {
+                constructor(t42) {
+                  this.specification = t42;
+                }
+                possiblyEvaluate(t42, e22, r22, n22) {
+                  if (void 0 !== t42.value) {
+                    if ("constant" === t42.expression.kind) {
+                      const i22 = t42.expression.evaluate(e22, null, {}, r22, n22);
+                      return this._calculate(i22, i22, i22, e22);
+                    }
+                    return this._calculate(t42.expression.evaluate(new Ui2(Math.floor(e22.zoom - 1), e22)), t42.expression.evaluate(new Ui2(Math.floor(e22.zoom), e22)), t42.expression.evaluate(new Ui2(Math.floor(e22.zoom + 1), e22)), e22);
+                  }
+                }
+                _calculate(t42, e22, r22, n22) {
+                  return n22.zoom > n22.zoomHistory.lastIntegerZoom ? { from: t42, to: e22 } : { from: r22, to: e22 };
+                }
+                interpolate(t42) {
+                  return t42;
+                }
+              }
+              class es {
+                constructor(t42) {
+                  this.specification = t42;
+                }
+                possiblyEvaluate(t42, e22, r22, n22) {
+                  return !!t42.expression.evaluate(e22, null, {}, r22, n22);
+                }
+                interpolate() {
+                  return false;
+                }
+              }
+              class rs {
+                constructor(t42) {
+                  this.properties = t42, this.defaultPropertyValues = {}, this.defaultTransitionablePropertyValues = {}, this.defaultTransitioningPropertyValues = {}, this.defaultPossiblyEvaluatedValues = {}, this.overridableProperties = [];
+                  for (const e22 in t42) {
+                    const r22 = t42[e22];
+                    r22.specification.overridable && this.overridableProperties.push(e22);
+                    const n22 = this.defaultPropertyValues[e22] = new qi2(r22, void 0), i22 = this.defaultTransitionablePropertyValues[e22] = new Ni2(r22);
+                    this.defaultTransitioningPropertyValues[e22] = i22.untransitioned(), this.defaultPossiblyEvaluatedValues[e22] = n22.possiblyEvaluate({});
+                  }
+                }
+              }
+              wi2("DataDrivenProperty", Wi2), wi2("DataConstantProperty", Ji2), wi2("CrossFadedDataDrivenProperty", Qi2), wi2("CrossFadedProperty", ts), wi2("ColorRampProperty", es);
+              const ns = "-transition";
+              class is extends Z2 {
+                constructor(t42, e22) {
+                  if (super(), this.id = t42.id, this.type = t42.type, this._featureFilter = { filter: () => true, needGeometry: false }, "custom" !== t42.type && (this.metadata = t42.metadata, this.minzoom = t42.minzoom, this.maxzoom = t42.maxzoom, "background" !== t42.type && (this.source = t42.source, this.sourceLayer = t42["source-layer"], this.filter = t42.filter), e22.layout && (this._unevaluatedLayout = new Xi2(e22.layout)), e22.paint)) {
+                    this._transitionablePaint = new Zi2(e22.paint);
+                    for (const e3 in t42.paint) this.setPaintProperty(e3, t42.paint[e3], { validate: false });
+                    for (const e3 in t42.layout) this.setLayoutProperty(e3, t42.layout[e3], { validate: false });
+                    this._transitioningPaint = this._transitionablePaint.untransitioned(), this.paint = new Yi2(e22.paint);
+                  }
+                }
+                getCrossfadeParameters() {
+                  return this._crossfadeParameters;
+                }
+                getLayoutProperty(t42) {
+                  return "visibility" === t42 ? this.visibility : this._unevaluatedLayout.getValue(t42);
+                }
+                setLayoutProperty(t42, e22, r22 = {}) {
+                  null != e22 && this._validate(gi2, `layers.${this.id}.layout.${t42}`, t42, e22, r22) || ("visibility" !== t42 ? this._unevaluatedLayout.setValue(t42, e22) : this.visibility = e22);
+                }
+                getPaintProperty(t42) {
+                  return t42.endsWith(ns) ? this._transitionablePaint.getTransition(t42.slice(0, -11)) : this._transitionablePaint.getValue(t42);
+                }
+                setPaintProperty(t42, e22, r22 = {}) {
+                  if (null != e22 && this._validate(mi2, `layers.${this.id}.paint.${t42}`, t42, e22, r22)) return false;
+                  if (t42.endsWith(ns)) return this._transitionablePaint.setTransition(t42.slice(0, -11), e22 || void 0), false;
+                  {
+                    const r3 = this._transitionablePaint._values[t42], n22 = "cross-faded-data-driven" === r3.property.specification["property-type"], i22 = r3.value.isDataDriven(), s22 = r3.value;
+                    this._transitionablePaint.setValue(t42, e22), this._handleSpecialPaintPropertyUpdate(t42);
+                    const a22 = this._transitionablePaint._values[t42].value;
+                    return a22.isDataDriven() || i22 || n22 || this._handleOverridablePaintPropertyUpdate(t42, s22, a22);
+                  }
+                }
+                _handleSpecialPaintPropertyUpdate(t42) {
+                }
+                _handleOverridablePaintPropertyUpdate(t42, e22, r22) {
+                  return false;
+                }
+                isHidden(t42) {
+                  return !!(this.minzoom && t42 < this.minzoom) || !!(this.maxzoom && t42 >= this.maxzoom) || "none" === this.visibility;
+                }
+                updateTransitions(t42) {
+                  this._transitioningPaint = this._transitionablePaint.transitioned(t42, this._transitioningPaint);
+                }
+                hasTransition() {
+                  return this._transitioningPaint.hasTransition();
+                }
+                recalculate(t42, e22) {
+                  t42.getCrossfadeParameters && (this._crossfadeParameters = t42.getCrossfadeParameters()), this._unevaluatedLayout && (this.layout = this._unevaluatedLayout.possiblyEvaluate(t42, void 0, e22)), this.paint = this._transitioningPaint.possiblyEvaluate(t42, void 0, e22);
+                }
+                serialize() {
+                  const t42 = { id: this.id, type: this.type, source: this.source, "source-layer": this.sourceLayer, metadata: this.metadata, minzoom: this.minzoom, maxzoom: this.maxzoom, filter: this.filter, layout: this._unevaluatedLayout && this._unevaluatedLayout.serialize(), paint: this._transitionablePaint && this._transitionablePaint.serialize() };
+                  return this.visibility && (t42.layout = t42.layout || {}, t42.layout.visibility = this.visibility), b2(t42, (t5, e22) => !(void 0 === t5 || "layout" === e22 && !Object.keys(t5).length || "paint" === e22 && !Object.keys(t5).length));
+                }
+                _validate(t42, e22, r22, n22, i22 = {}) {
+                  return (!i22 || false !== i22.validate) && xi2(this, t42.call(fi2, { key: e22, layerType: this.type, objectKey: r22, value: n22, styleSpec: G2, style: { glyphs: true, sprite: true } }));
+                }
+                is3D() {
+                  return false;
+                }
+                isTileClipped() {
+                  return false;
+                }
+                hasOffscreenPass() {
+                  return false;
+                }
+                resize() {
+                }
+                isStateDependent() {
+                  for (const t42 in this.paint._values) {
+                    const e22 = this.paint.get(t42);
+                    if (e22 instanceof Hi2 && an(e22.property.specification) && ("source" === e22.value.kind || "composite" === e22.value.kind) && e22.value.isStateDependent) return true;
+                  }
+                  return false;
+                }
+              }
+              const ss = { Int8: Int8Array, Uint8: Uint8Array, Int16: Int16Array, Uint16: Uint16Array, Int32: Int32Array, Uint32: Uint32Array, Float32: Float32Array };
+              class as {
+                constructor(t42, e22) {
+                  this._structArray = t42, this._pos1 = e22 * this.size, this._pos2 = this._pos1 / 2, this._pos4 = this._pos1 / 4, this._pos8 = this._pos1 / 8;
+                }
+              }
+              class os {
+                constructor() {
+                  this.isTransferred = false, this.capacity = -1, this.resize(0);
+                }
+                static serialize(t42, e22) {
+                  return t42._trim(), e22 && (t42.isTransferred = true, e22.push(t42.arrayBuffer)), { length: t42.length, arrayBuffer: t42.arrayBuffer };
+                }
+                static deserialize(t42) {
+                  const e22 = Object.create(this.prototype);
+                  return e22.arrayBuffer = t42.arrayBuffer, e22.length = t42.length, e22.capacity = t42.arrayBuffer.byteLength / e22.bytesPerElement, e22._refreshViews(), e22;
+                }
+                _trim() {
+                  this.length !== this.capacity && (this.capacity = this.length, this.arrayBuffer = this.arrayBuffer.slice(0, this.length * this.bytesPerElement), this._refreshViews());
+                }
+                clear() {
+                  this.length = 0;
+                }
+                resize(t42) {
+                  this.reserve(t42), this.length = t42;
+                }
+                reserve(t42) {
+                  if (t42 > this.capacity) {
+                    this.capacity = Math.max(t42, Math.floor(5 * this.capacity), 128), this.arrayBuffer = new ArrayBuffer(this.capacity * this.bytesPerElement);
+                    const e22 = this.uint8;
+                    this._refreshViews(), e22 && this.uint8.set(e22);
+                  }
+                }
+                _refreshViews() {
+                  throw new Error("_refreshViews() must be implemented by each concrete StructArray layout");
+                }
+              }
+              function ls(t42, e22 = 1) {
+                let r22 = 0, n22 = 0;
+                return { members: t42.map((t5) => {
+                  const i22 = ss[t5.type].BYTES_PER_ELEMENT, s22 = r22 = us(r22, Math.max(e22, i22)), a22 = t5.components || 1;
+                  return n22 = Math.max(n22, i22), r22 += i22 * a22, { name: t5.name, type: t5.type, components: a22, offset: s22 };
+                }), size: us(r22, Math.max(n22, e22)), alignment: e22 };
+              }
+              function us(t42, e22) {
+                return Math.ceil(t42 / e22) * e22;
+              }
+              class cs extends os {
+                _refreshViews() {
+                  this.uint8 = new Uint8Array(this.arrayBuffer), this.int16 = new Int16Array(this.arrayBuffer);
+                }
+                emplaceBack(t42, e22) {
+                  const r22 = this.length;
+                  return this.resize(r22 + 1), this.emplace(r22, t42, e22);
+                }
+                emplace(t42, e22, r22) {
+                  const n22 = 2 * t42;
+                  return this.int16[n22 + 0] = e22, this.int16[n22 + 1] = r22, t42;
+                }
+              }
+              cs.prototype.bytesPerElement = 4, wi2("StructArrayLayout2i4", cs);
+              class hs extends os {
+                _refreshViews() {
+                  this.uint8 = new Uint8Array(this.arrayBuffer), this.int16 = new Int16Array(this.arrayBuffer);
+                }
+                emplaceBack(t42, e22, r22) {
+                  const n22 = this.length;
+                  return this.resize(n22 + 1), this.emplace(n22, t42, e22, r22);
+                }
+                emplace(t42, e22, r22, n22) {
+                  const i22 = 3 * t42;
+                  return this.int16[i22 + 0] = e22, this.int16[i22 + 1] = r22, this.int16[i22 + 2] = n22, t42;
+                }
+              }
+              hs.prototype.bytesPerElement = 6, wi2("StructArrayLayout3i6", hs);
+              class ps extends os {
+                _refreshViews() {
+                  this.uint8 = new Uint8Array(this.arrayBuffer), this.int16 = new Int16Array(this.arrayBuffer);
+                }
+                emplaceBack(t42, e22, r22, n22) {
+                  const i22 = this.length;
+                  return this.resize(i22 + 1), this.emplace(i22, t42, e22, r22, n22);
+                }
+                emplace(t42, e22, r22, n22, i22) {
+                  const s22 = 4 * t42;
+                  return this.int16[s22 + 0] = e22, this.int16[s22 + 1] = r22, this.int16[s22 + 2] = n22, this.int16[s22 + 3] = i22, t42;
+                }
+              }
+              ps.prototype.bytesPerElement = 8, wi2("StructArrayLayout4i8", ps);
+              class fs2 extends os {
+                _refreshViews() {
+                  this.uint8 = new Uint8Array(this.arrayBuffer), this.int16 = new Int16Array(this.arrayBuffer);
+                }
+                emplaceBack(t42, e22, r22, n22, i22, s22) {
+                  const a22 = this.length;
+                  return this.resize(a22 + 1), this.emplace(a22, t42, e22, r22, n22, i22, s22);
+                }
+                emplace(t42, e22, r22, n22, i22, s22, a22) {
+                  const o22 = 6 * t42;
+                  return this.int16[o22 + 0] = e22, this.int16[o22 + 1] = r22, this.int16[o22 + 2] = n22, this.int16[o22 + 3] = i22, this.int16[o22 + 4] = s22, this.int16[o22 + 5] = a22, t42;
+                }
+              }
+              fs2.prototype.bytesPerElement = 12, wi2("StructArrayLayout2i4i12", fs2);
+              class ds extends os {
+                _refreshViews() {
+                  this.uint8 = new Uint8Array(this.arrayBuffer), this.int16 = new Int16Array(this.arrayBuffer);
+                }
+                emplaceBack(t42, e22, r22, n22, i22, s22) {
+                  const a22 = this.length;
+                  return this.resize(a22 + 1), this.emplace(a22, t42, e22, r22, n22, i22, s22);
+                }
+                emplace(t42, e22, r22, n22, i22, s22, a22) {
+                  const o22 = 4 * t42, l22 = 8 * t42;
+                  return this.int16[o22 + 0] = e22, this.int16[o22 + 1] = r22, this.uint8[l22 + 4] = n22, this.uint8[l22 + 5] = i22, this.uint8[l22 + 6] = s22, this.uint8[l22 + 7] = a22, t42;
+                }
+              }
+              ds.prototype.bytesPerElement = 8, wi2("StructArrayLayout2i4ub8", ds);
+              class ys extends os {
+                _refreshViews() {
+                  this.uint8 = new Uint8Array(this.arrayBuffer), this.float32 = new Float32Array(this.arrayBuffer);
+                }
+                emplaceBack(t42, e22) {
+                  const r22 = this.length;
+                  return this.resize(r22 + 1), this.emplace(r22, t42, e22);
+                }
+                emplace(t42, e22, r22) {
+                  const n22 = 2 * t42;
+                  return this.float32[n22 + 0] = e22, this.float32[n22 + 1] = r22, t42;
+                }
+              }
+              ys.prototype.bytesPerElement = 8, wi2("StructArrayLayout2f8", ys);
+              class ms extends os {
+                _refreshViews() {
+                  this.uint8 = new Uint8Array(this.arrayBuffer), this.uint16 = new Uint16Array(this.arrayBuffer);
+                }
+                emplaceBack(t42, e22, r22, n22, i22, s22, a22, o22, l22, u22) {
+                  const c22 = this.length;
+                  return this.resize(c22 + 1), this.emplace(c22, t42, e22, r22, n22, i22, s22, a22, o22, l22, u22);
+                }
+                emplace(t42, e22, r22, n22, i22, s22, a22, o22, l22, u22, c22) {
+                  const h22 = 10 * t42;
+                  return this.uint16[h22 + 0] = e22, this.uint16[h22 + 1] = r22, this.uint16[h22 + 2] = n22, this.uint16[h22 + 3] = i22, this.uint16[h22 + 4] = s22, this.uint16[h22 + 5] = a22, this.uint16[h22 + 6] = o22, this.uint16[h22 + 7] = l22, this.uint16[h22 + 8] = u22, this.uint16[h22 + 9] = c22, t42;
+                }
+              }
+              ms.prototype.bytesPerElement = 20, wi2("StructArrayLayout10ui20", ms);
+              class gs extends os {
+                _refreshViews() {
+                  this.uint8 = new Uint8Array(this.arrayBuffer), this.int16 = new Int16Array(this.arrayBuffer), this.uint16 = new Uint16Array(this.arrayBuffer);
+                }
+                emplaceBack(t42, e22, r22, n22, i22, s22, a22, o22, l22, u22, c22, h22) {
+                  const p22 = this.length;
+                  return this.resize(p22 + 1), this.emplace(p22, t42, e22, r22, n22, i22, s22, a22, o22, l22, u22, c22, h22);
+                }
+                emplace(t42, e22, r22, n22, i22, s22, a22, o22, l22, u22, c22, h22, p22) {
+                  const f22 = 12 * t42;
+                  return this.int16[f22 + 0] = e22, this.int16[f22 + 1] = r22, this.int16[f22 + 2] = n22, this.int16[f22 + 3] = i22, this.uint16[f22 + 4] = s22, this.uint16[f22 + 5] = a22, this.uint16[f22 + 6] = o22, this.uint16[f22 + 7] = l22, this.int16[f22 + 8] = u22, this.int16[f22 + 9] = c22, this.int16[f22 + 10] = h22, this.int16[f22 + 11] = p22, t42;
+                }
+              }
+              gs.prototype.bytesPerElement = 24, wi2("StructArrayLayout4i4ui4i24", gs);
+              class xs extends os {
+                _refreshViews() {
+                  this.uint8 = new Uint8Array(this.arrayBuffer), this.float32 = new Float32Array(this.arrayBuffer);
+                }
+                emplaceBack(t42, e22, r22) {
+                  const n22 = this.length;
+                  return this.resize(n22 + 1), this.emplace(n22, t42, e22, r22);
+                }
+                emplace(t42, e22, r22, n22) {
+                  const i22 = 3 * t42;
+                  return this.float32[i22 + 0] = e22, this.float32[i22 + 1] = r22, this.float32[i22 + 2] = n22, t42;
+                }
+              }
+              xs.prototype.bytesPerElement = 12, wi2("StructArrayLayout3f12", xs);
+              class vs2 extends os {
+                _refreshViews() {
+                  this.uint8 = new Uint8Array(this.arrayBuffer), this.uint32 = new Uint32Array(this.arrayBuffer);
+                }
+                emplaceBack(t42) {
+                  const e22 = this.length;
+                  return this.resize(e22 + 1), this.emplace(e22, t42);
+                }
+                emplace(t42, e22) {
+                  return this.uint32[1 * t42 + 0] = e22, t42;
+                }
+              }
+              vs2.prototype.bytesPerElement = 4, wi2("StructArrayLayout1ul4", vs2);
+              class bs extends os {
+                _refreshViews() {
+                  this.uint8 = new Uint8Array(this.arrayBuffer), this.int16 = new Int16Array(this.arrayBuffer), this.uint32 = new Uint32Array(this.arrayBuffer), this.uint16 = new Uint16Array(this.arrayBuffer);
+                }
+                emplaceBack(t42, e22, r22, n22, i22, s22, a22, o22, l22) {
+                  const u22 = this.length;
+                  return this.resize(u22 + 1), this.emplace(u22, t42, e22, r22, n22, i22, s22, a22, o22, l22);
+                }
+                emplace(t42, e22, r22, n22, i22, s22, a22, o22, l22, u22) {
+                  const c22 = 10 * t42, h22 = 5 * t42;
+                  return this.int16[c22 + 0] = e22, this.int16[c22 + 1] = r22, this.int16[c22 + 2] = n22, this.int16[c22 + 3] = i22, this.int16[c22 + 4] = s22, this.int16[c22 + 5] = a22, this.uint32[h22 + 3] = o22, this.uint16[c22 + 8] = l22, this.uint16[c22 + 9] = u22, t42;
+                }
+              }
+              bs.prototype.bytesPerElement = 20, wi2("StructArrayLayout6i1ul2ui20", bs);
+              class ws extends os {
+                _refreshViews() {
+                  this.uint8 = new Uint8Array(this.arrayBuffer), this.int16 = new Int16Array(this.arrayBuffer);
+                }
+                emplaceBack(t42, e22, r22, n22, i22, s22) {
+                  const a22 = this.length;
+                  return this.resize(a22 + 1), this.emplace(a22, t42, e22, r22, n22, i22, s22);
+                }
+                emplace(t42, e22, r22, n22, i22, s22, a22) {
+                  const o22 = 6 * t42;
+                  return this.int16[o22 + 0] = e22, this.int16[o22 + 1] = r22, this.int16[o22 + 2] = n22, this.int16[o22 + 3] = i22, this.int16[o22 + 4] = s22, this.int16[o22 + 5] = a22, t42;
+                }
+              }
+              ws.prototype.bytesPerElement = 12, wi2("StructArrayLayout2i2i2i12", ws);
+              class _s2 extends os {
+                _refreshViews() {
+                  this.uint8 = new Uint8Array(this.arrayBuffer), this.float32 = new Float32Array(this.arrayBuffer), this.int16 = new Int16Array(this.arrayBuffer);
+                }
+                emplaceBack(t42, e22, r22, n22, i22) {
+                  const s22 = this.length;
+                  return this.resize(s22 + 1), this.emplace(s22, t42, e22, r22, n22, i22);
+                }
+                emplace(t42, e22, r22, n22, i22, s22) {
+                  const a22 = 4 * t42, o22 = 8 * t42;
+                  return this.float32[a22 + 0] = e22, this.float32[a22 + 1] = r22, this.float32[a22 + 2] = n22, this.int16[o22 + 6] = i22, this.int16[o22 + 7] = s22, t42;
+                }
+              }
+              _s2.prototype.bytesPerElement = 16, wi2("StructArrayLayout2f1f2i16", _s2);
+              class As extends os {
+                _refreshViews() {
+                  this.uint8 = new Uint8Array(this.arrayBuffer), this.float32 = new Float32Array(this.arrayBuffer), this.int16 = new Int16Array(this.arrayBuffer);
+                }
+                emplaceBack(t42, e22, r22, n22, i22, s22) {
+                  const a22 = this.length;
+                  return this.resize(a22 + 1), this.emplace(a22, t42, e22, r22, n22, i22, s22);
+                }
+                emplace(t42, e22, r22, n22, i22, s22, a22) {
+                  const o22 = 16 * t42, l22 = 4 * t42, u22 = 8 * t42;
+                  return this.uint8[o22 + 0] = e22, this.uint8[o22 + 1] = r22, this.float32[l22 + 1] = n22, this.float32[l22 + 2] = i22, this.int16[u22 + 6] = s22, this.int16[u22 + 7] = a22, t42;
+                }
+              }
+              As.prototype.bytesPerElement = 16, wi2("StructArrayLayout2ub2f2i16", As);
+              class Ss extends os {
+                _refreshViews() {
+                  this.uint8 = new Uint8Array(this.arrayBuffer), this.uint16 = new Uint16Array(this.arrayBuffer);
+                }
+                emplaceBack(t42, e22, r22) {
+                  const n22 = this.length;
+                  return this.resize(n22 + 1), this.emplace(n22, t42, e22, r22);
+                }
+                emplace(t42, e22, r22, n22) {
+                  const i22 = 3 * t42;
+                  return this.uint16[i22 + 0] = e22, this.uint16[i22 + 1] = r22, this.uint16[i22 + 2] = n22, t42;
+                }
+              }
+              Ss.prototype.bytesPerElement = 6, wi2("StructArrayLayout3ui6", Ss);
+              class ks extends os {
+                _refreshViews() {
+                  this.uint8 = new Uint8Array(this.arrayBuffer), this.int16 = new Int16Array(this.arrayBuffer), this.uint16 = new Uint16Array(this.arrayBuffer), this.uint32 = new Uint32Array(this.arrayBuffer), this.float32 = new Float32Array(this.arrayBuffer);
+                }
+                emplaceBack(t42, e22, r22, n22, i22, s22, a22, o22, l22, u22, c22, h22, p22, f22, d22, y22, m22) {
+                  const g22 = this.length;
+                  return this.resize(g22 + 1), this.emplace(g22, t42, e22, r22, n22, i22, s22, a22, o22, l22, u22, c22, h22, p22, f22, d22, y22, m22);
+                }
+                emplace(t42, e22, r22, n22, i22, s22, a22, o22, l22, u22, c22, h22, p22, f22, d22, y22, m22, g22) {
+                  const x22 = 24 * t42, v22 = 12 * t42, b22 = 48 * t42;
+                  return this.int16[x22 + 0] = e22, this.int16[x22 + 1] = r22, this.uint16[x22 + 2] = n22, this.uint16[x22 + 3] = i22, this.uint32[v22 + 2] = s22, this.uint32[v22 + 3] = a22, this.uint32[v22 + 4] = o22, this.uint16[x22 + 10] = l22, this.uint16[x22 + 11] = u22, this.uint16[x22 + 12] = c22, this.float32[v22 + 7] = h22, this.float32[v22 + 8] = p22, this.uint8[b22 + 36] = f22, this.uint8[b22 + 37] = d22, this.uint8[b22 + 38] = y22, this.uint32[v22 + 10] = m22, this.int16[x22 + 22] = g22, t42;
+                }
+              }
+              ks.prototype.bytesPerElement = 48, wi2("StructArrayLayout2i2ui3ul3ui2f3ub1ul1i48", ks);
+              class Ms extends os {
+                _refreshViews() {
+                  this.uint8 = new Uint8Array(this.arrayBuffer), this.int16 = new Int16Array(this.arrayBuffer), this.uint16 = new Uint16Array(this.arrayBuffer), this.uint32 = new Uint32Array(this.arrayBuffer), this.float32 = new Float32Array(this.arrayBuffer);
+                }
+                emplaceBack(t42, e22, r22, n22, i22, s22, a22, o22, l22, u22, c22, h22, p22, f22, d22, y22, m22, g22, x22, v22, b22, w22, _22, A3, S22, k22, M22, I22) {
+                  const z22 = this.length;
+                  return this.resize(z22 + 1), this.emplace(z22, t42, e22, r22, n22, i22, s22, a22, o22, l22, u22, c22, h22, p22, f22, d22, y22, m22, g22, x22, v22, b22, w22, _22, A3, S22, k22, M22, I22);
+                }
+                emplace(t42, e22, r22, n22, i22, s22, a22, o22, l22, u22, c22, h22, p22, f22, d22, y22, m22, g22, x22, v22, b22, w22, _22, A3, S22, k22, M22, I22, z22) {
+                  const P22 = 32 * t42, C3 = 16 * t42;
+                  return this.int16[P22 + 0] = e22, this.int16[P22 + 1] = r22, this.int16[P22 + 2] = n22, this.int16[P22 + 3] = i22, this.int16[P22 + 4] = s22, this.int16[P22 + 5] = a22, this.int16[P22 + 6] = o22, this.int16[P22 + 7] = l22, this.uint16[P22 + 8] = u22, this.uint16[P22 + 9] = c22, this.uint16[P22 + 10] = h22, this.uint16[P22 + 11] = p22, this.uint16[P22 + 12] = f22, this.uint16[P22 + 13] = d22, this.uint16[P22 + 14] = y22, this.uint16[P22 + 15] = m22, this.uint16[P22 + 16] = g22, this.uint16[P22 + 17] = x22, this.uint16[P22 + 18] = v22, this.uint16[P22 + 19] = b22, this.uint16[P22 + 20] = w22, this.uint16[P22 + 21] = _22, this.uint16[P22 + 22] = A3, this.uint32[C3 + 12] = S22, this.float32[C3 + 13] = k22, this.float32[C3 + 14] = M22, this.uint16[P22 + 30] = I22, this.uint16[P22 + 31] = z22, t42;
+                }
+              }
+              Ms.prototype.bytesPerElement = 64, wi2("StructArrayLayout8i15ui1ul2f2ui64", Ms);
+              class Is extends os {
+                _refreshViews() {
+                  this.uint8 = new Uint8Array(this.arrayBuffer), this.float32 = new Float32Array(this.arrayBuffer);
+                }
+                emplaceBack(t42) {
+                  const e22 = this.length;
+                  return this.resize(e22 + 1), this.emplace(e22, t42);
+                }
+                emplace(t42, e22) {
+                  return this.float32[1 * t42 + 0] = e22, t42;
+                }
+              }
+              Is.prototype.bytesPerElement = 4, wi2("StructArrayLayout1f4", Is);
+              class zs extends os {
+                _refreshViews() {
+                  this.uint8 = new Uint8Array(this.arrayBuffer), this.uint16 = new Uint16Array(this.arrayBuffer), this.float32 = new Float32Array(this.arrayBuffer);
+                }
+                emplaceBack(t42, e22, r22) {
+                  const n22 = this.length;
+                  return this.resize(n22 + 1), this.emplace(n22, t42, e22, r22);
+                }
+                emplace(t42, e22, r22, n22) {
+                  const i22 = 3 * t42;
+                  return this.uint16[6 * t42 + 0] = e22, this.float32[i22 + 1] = r22, this.float32[i22 + 2] = n22, t42;
+                }
+              }
+              zs.prototype.bytesPerElement = 12, wi2("StructArrayLayout1ui2f12", zs);
+              class Ps extends os {
+                _refreshViews() {
+                  this.uint8 = new Uint8Array(this.arrayBuffer), this.uint32 = new Uint32Array(this.arrayBuffer), this.uint16 = new Uint16Array(this.arrayBuffer);
+                }
+                emplaceBack(t42, e22, r22) {
+                  const n22 = this.length;
+                  return this.resize(n22 + 1), this.emplace(n22, t42, e22, r22);
+                }
+                emplace(t42, e22, r22, n22) {
+                  const i22 = 4 * t42;
+                  return this.uint32[2 * t42 + 0] = e22, this.uint16[i22 + 2] = r22, this.uint16[i22 + 3] = n22, t42;
+                }
+              }
+              Ps.prototype.bytesPerElement = 8, wi2("StructArrayLayout1ul2ui8", Ps);
+              class Cs extends os {
+                _refreshViews() {
+                  this.uint8 = new Uint8Array(this.arrayBuffer), this.uint16 = new Uint16Array(this.arrayBuffer);
+                }
+                emplaceBack(t42, e22) {
+                  const r22 = this.length;
+                  return this.resize(r22 + 1), this.emplace(r22, t42, e22);
+                }
+                emplace(t42, e22, r22) {
+                  const n22 = 2 * t42;
+                  return this.uint16[n22 + 0] = e22, this.uint16[n22 + 1] = r22, t42;
+                }
+              }
+              Cs.prototype.bytesPerElement = 4, wi2("StructArrayLayout2ui4", Cs);
+              class Bs extends os {
+                _refreshViews() {
+                  this.uint8 = new Uint8Array(this.arrayBuffer), this.uint16 = new Uint16Array(this.arrayBuffer);
+                }
+                emplaceBack(t42) {
+                  const e22 = this.length;
+                  return this.resize(e22 + 1), this.emplace(e22, t42);
+                }
+                emplace(t42, e22) {
+                  return this.uint16[1 * t42 + 0] = e22, t42;
+                }
+              }
+              Bs.prototype.bytesPerElement = 2, wi2("StructArrayLayout1ui2", Bs);
+              class Vs extends os {
+                _refreshViews() {
+                  this.uint8 = new Uint8Array(this.arrayBuffer), this.float32 = new Float32Array(this.arrayBuffer);
+                }
+                emplaceBack(t42, e22, r22, n22) {
+                  const i22 = this.length;
+                  return this.resize(i22 + 1), this.emplace(i22, t42, e22, r22, n22);
+                }
+                emplace(t42, e22, r22, n22, i22) {
+                  const s22 = 4 * t42;
+                  return this.float32[s22 + 0] = e22, this.float32[s22 + 1] = r22, this.float32[s22 + 2] = n22, this.float32[s22 + 3] = i22, t42;
+                }
+              }
+              Vs.prototype.bytesPerElement = 16, wi2("StructArrayLayout4f16", Vs);
+              class Es extends as {
+                get anchorPointX() {
+                  return this._structArray.int16[this._pos2 + 0];
+                }
+                get anchorPointY() {
+                  return this._structArray.int16[this._pos2 + 1];
+                }
+                get x1() {
+                  return this._structArray.int16[this._pos2 + 2];
+                }
+                get y1() {
+                  return this._structArray.int16[this._pos2 + 3];
+                }
+                get x2() {
+                  return this._structArray.int16[this._pos2 + 4];
+                }
+                get y2() {
+                  return this._structArray.int16[this._pos2 + 5];
+                }
+                get featureIndex() {
+                  return this._structArray.uint32[this._pos4 + 3];
+                }
+                get sourceLayerIndex() {
+                  return this._structArray.uint16[this._pos2 + 8];
+                }
+                get bucketIndex() {
+                  return this._structArray.uint16[this._pos2 + 9];
+                }
+                get anchorPoint() {
+                  return new s2(this.anchorPointX, this.anchorPointY);
+                }
+              }
+              Es.prototype.size = 20;
+              class Fs extends bs {
+                get(t42) {
+                  return new Es(this, t42);
+                }
+              }
+              wi2("CollisionBoxArray", Fs);
+              class Ts extends as {
+                get anchorX() {
+                  return this._structArray.int16[this._pos2 + 0];
+                }
+                get anchorY() {
+                  return this._structArray.int16[this._pos2 + 1];
+                }
+                get glyphStartIndex() {
+                  return this._structArray.uint16[this._pos2 + 2];
+                }
+                get numGlyphs() {
+                  return this._structArray.uint16[this._pos2 + 3];
+                }
+                get vertexStartIndex() {
+                  return this._structArray.uint32[this._pos4 + 2];
+                }
+                get lineStartIndex() {
+                  return this._structArray.uint32[this._pos4 + 3];
+                }
+                get lineLength() {
+                  return this._structArray.uint32[this._pos4 + 4];
+                }
+                get segment() {
+                  return this._structArray.uint16[this._pos2 + 10];
+                }
+                get lowerSize() {
+                  return this._structArray.uint16[this._pos2 + 11];
+                }
+                get upperSize() {
+                  return this._structArray.uint16[this._pos2 + 12];
+                }
+                get lineOffsetX() {
+                  return this._structArray.float32[this._pos4 + 7];
+                }
+                get lineOffsetY() {
+                  return this._structArray.float32[this._pos4 + 8];
+                }
+                get writingMode() {
+                  return this._structArray.uint8[this._pos1 + 36];
+                }
+                get placedOrientation() {
+                  return this._structArray.uint8[this._pos1 + 37];
+                }
+                set placedOrientation(t42) {
+                  this._structArray.uint8[this._pos1 + 37] = t42;
+                }
+                get hidden() {
+                  return this._structArray.uint8[this._pos1 + 38];
+                }
+                set hidden(t42) {
+                  this._structArray.uint8[this._pos1 + 38] = t42;
+                }
+                get crossTileID() {
+                  return this._structArray.uint32[this._pos4 + 10];
+                }
+                set crossTileID(t42) {
+                  this._structArray.uint32[this._pos4 + 10] = t42;
+                }
+                get associatedIconIndex() {
+                  return this._structArray.int16[this._pos2 + 22];
+                }
+              }
+              Ts.prototype.size = 48;
+              class $s extends ks {
+                get(t42) {
+                  return new Ts(this, t42);
+                }
+              }
+              wi2("PlacedSymbolArray", $s);
+              class Ls extends as {
+                get anchorX() {
+                  return this._structArray.int16[this._pos2 + 0];
+                }
+                get anchorY() {
+                  return this._structArray.int16[this._pos2 + 1];
+                }
+                get rightJustifiedTextSymbolIndex() {
+                  return this._structArray.int16[this._pos2 + 2];
+                }
+                get centerJustifiedTextSymbolIndex() {
+                  return this._structArray.int16[this._pos2 + 3];
+                }
+                get leftJustifiedTextSymbolIndex() {
+                  return this._structArray.int16[this._pos2 + 4];
+                }
+                get verticalPlacedTextSymbolIndex() {
+                  return this._structArray.int16[this._pos2 + 5];
+                }
+                get placedIconSymbolIndex() {
+                  return this._structArray.int16[this._pos2 + 6];
+                }
+                get verticalPlacedIconSymbolIndex() {
+                  return this._structArray.int16[this._pos2 + 7];
+                }
+                get key() {
+                  return this._structArray.uint16[this._pos2 + 8];
+                }
+                get textBoxStartIndex() {
+                  return this._structArray.uint16[this._pos2 + 9];
+                }
+                get textBoxEndIndex() {
+                  return this._structArray.uint16[this._pos2 + 10];
+                }
+                get verticalTextBoxStartIndex() {
+                  return this._structArray.uint16[this._pos2 + 11];
+                }
+                get verticalTextBoxEndIndex() {
+                  return this._structArray.uint16[this._pos2 + 12];
+                }
+                get iconBoxStartIndex() {
+                  return this._structArray.uint16[this._pos2 + 13];
+                }
+                get iconBoxEndIndex() {
+                  return this._structArray.uint16[this._pos2 + 14];
+                }
+                get verticalIconBoxStartIndex() {
+                  return this._structArray.uint16[this._pos2 + 15];
+                }
+                get verticalIconBoxEndIndex() {
+                  return this._structArray.uint16[this._pos2 + 16];
+                }
+                get featureIndex() {
+                  return this._structArray.uint16[this._pos2 + 17];
+                }
+                get numHorizontalGlyphVertices() {
+                  return this._structArray.uint16[this._pos2 + 18];
+                }
+                get numVerticalGlyphVertices() {
+                  return this._structArray.uint16[this._pos2 + 19];
+                }
+                get numIconVertices() {
+                  return this._structArray.uint16[this._pos2 + 20];
+                }
+                get numVerticalIconVertices() {
+                  return this._structArray.uint16[this._pos2 + 21];
+                }
+                get useRuntimeCollisionCircles() {
+                  return this._structArray.uint16[this._pos2 + 22];
+                }
+                get crossTileID() {
+                  return this._structArray.uint32[this._pos4 + 12];
+                }
+                set crossTileID(t42) {
+                  this._structArray.uint32[this._pos4 + 12] = t42;
+                }
+                get textBoxScale() {
+                  return this._structArray.float32[this._pos4 + 13];
+                }
+                get collisionCircleDiameter() {
+                  return this._structArray.float32[this._pos4 + 14];
+                }
+                get textAnchorOffsetStartIndex() {
+                  return this._structArray.uint16[this._pos2 + 30];
+                }
+                get textAnchorOffsetEndIndex() {
+                  return this._structArray.uint16[this._pos2 + 31];
+                }
+              }
+              Ls.prototype.size = 64;
+              class Ds extends Ms {
+                get(t42) {
+                  return new Ls(this, t42);
+                }
+              }
+              wi2("SymbolInstanceArray", Ds);
+              class Os extends Is {
+                getoffsetX(t42) {
+                  return this.float32[1 * t42 + 0];
+                }
+              }
+              wi2("GlyphOffsetArray", Os);
+              class js extends hs {
+                getx(t42) {
+                  return this.int16[3 * t42 + 0];
+                }
+                gety(t42) {
+                  return this.int16[3 * t42 + 1];
+                }
+                gettileUnitDistanceFromAnchor(t42) {
+                  return this.int16[3 * t42 + 2];
+                }
+              }
+              wi2("SymbolLineVertexArray", js);
+              class Rs extends as {
+                get textAnchor() {
+                  return this._structArray.uint16[this._pos2 + 0];
+                }
+                get textOffset0() {
+                  return this._structArray.float32[this._pos4 + 1];
+                }
+                get textOffset1() {
+                  return this._structArray.float32[this._pos4 + 2];
+                }
+              }
+              Rs.prototype.size = 12;
+              class Us extends zs {
+                get(t42) {
+                  return new Rs(this, t42);
+                }
+              }
+              wi2("TextAnchorOffsetArray", Us);
+              class qs extends as {
+                get featureIndex() {
+                  return this._structArray.uint32[this._pos4 + 0];
+                }
+                get sourceLayerIndex() {
+                  return this._structArray.uint16[this._pos2 + 2];
+                }
+                get bucketIndex() {
+                  return this._structArray.uint16[this._pos2 + 3];
+                }
+              }
+              qs.prototype.size = 8;
+              class Ns extends Ps {
+                get(t42) {
+                  return new qs(this, t42);
+                }
+              }
+              wi2("FeatureIndexArray", Ns);
+              class Zs extends cs {
+              }
+              class Gs extends cs {
+              }
+              class Ks extends cs {
+              }
+              class Xs extends fs2 {
+              }
+              class Hs extends ds {
+              }
+              class Ys extends ys {
+              }
+              class Js extends ms {
+              }
+              class Ws extends gs {
+              }
+              class Qs extends xs {
+              }
+              class ta2 extends vs2 {
+              }
+              class ea2 extends ws {
+              }
+              class ra2 extends As {
+              }
+              class na extends Ss {
+              }
+              class ia2 extends Cs {
+              }
+              const sa2 = ls([{ name: "a_pos", components: 2, type: "Int16" }], 4), { members: aa2 } = sa2;
+              class oa2 {
+                constructor(t42 = []) {
+                  this.segments = t42;
+                }
+                prepareSegment(t42, e22, r22, n22) {
+                  let i22 = this.segments[this.segments.length - 1];
+                  return t42 > oa2.MAX_VERTEX_ARRAY_LENGTH && A22(`Max vertices per segment is ${oa2.MAX_VERTEX_ARRAY_LENGTH}: bucket requested ${t42}`), (!i22 || i22.vertexLength + t42 > oa2.MAX_VERTEX_ARRAY_LENGTH || i22.sortKey !== n22) && (i22 = { vertexOffset: e22.length, primitiveOffset: r22.length, vertexLength: 0, primitiveLength: 0 }, void 0 !== n22 && (i22.sortKey = n22), this.segments.push(i22)), i22;
+                }
+                get() {
+                  return this.segments;
+                }
+                destroy() {
+                  for (const t42 of this.segments) for (const e22 in t42.vaos) t42.vaos[e22].destroy();
+                }
+                static simpleSegment(t42, e22, r22, n22) {
+                  return new oa2([{ vertexOffset: t42, primitiveOffset: e22, vertexLength: r22, primitiveLength: n22, vaos: {}, sortKey: 0 }]);
+                }
+              }
+              function la2(t42, e22) {
+                return 256 * (t42 = y2(Math.floor(t42), 0, 255)) + y2(Math.floor(e22), 0, 255);
+              }
+              oa2.MAX_VERTEX_ARRAY_LENGTH = Math.pow(2, 16) - 1, wi2("SegmentVector", oa2);
+              const ua2 = ls([{ name: "a_pattern_from", components: 4, type: "Uint16" }, { name: "a_pattern_to", components: 4, type: "Uint16" }, { name: "a_pixel_ratio_from", components: 1, type: "Uint16" }, { name: "a_pixel_ratio_to", components: 1, type: "Uint16" }]);
+              var ca2 = { exports: {} }, ha2 = { exports: {} };
+              ha2.exports = function(t42, e22) {
+                var r22, n22, i22, s22, a22, o22, l22, u22;
+                for (n22 = t42.length - (r22 = 3 & t42.length), i22 = e22, a22 = 3432918353, o22 = 461845907, u22 = 0; u22 < n22; ) l22 = 255 & t42.charCodeAt(u22) | (255 & t42.charCodeAt(++u22)) << 8 | (255 & t42.charCodeAt(++u22)) << 16 | (255 & t42.charCodeAt(++u22)) << 24, ++u22, i22 = 27492 + (65535 & (s22 = 5 * (65535 & (i22 = (i22 ^= l22 = (65535 & (l22 = (l22 = (65535 & l22) * a22 + (((l22 >>> 16) * a22 & 65535) << 16) & 4294967295) << 15 | l22 >>> 17)) * o22 + (((l22 >>> 16) * o22 & 65535) << 16) & 4294967295) << 13 | i22 >>> 19)) + ((5 * (i22 >>> 16) & 65535) << 16) & 4294967295)) + ((58964 + (s22 >>> 16) & 65535) << 16);
+                switch (l22 = 0, r22) {
+                  case 3:
+                    l22 ^= (255 & t42.charCodeAt(u22 + 2)) << 16;
+                  case 2:
+                    l22 ^= (255 & t42.charCodeAt(u22 + 1)) << 8;
+                  case 1:
+                    i22 ^= l22 = (65535 & (l22 = (l22 = (65535 & (l22 ^= 255 & t42.charCodeAt(u22))) * a22 + (((l22 >>> 16) * a22 & 65535) << 16) & 4294967295) << 15 | l22 >>> 17)) * o22 + (((l22 >>> 16) * o22 & 65535) << 16) & 4294967295;
+                }
+                return i22 ^= t42.length, i22 = 2246822507 * (65535 & (i22 ^= i22 >>> 16)) + ((2246822507 * (i22 >>> 16) & 65535) << 16) & 4294967295, i22 = 3266489909 * (65535 & (i22 ^= i22 >>> 13)) + ((3266489909 * (i22 >>> 16) & 65535) << 16) & 4294967295, (i22 ^= i22 >>> 16) >>> 0;
+              };
+              var pa2 = ha2.exports, fa2 = { exports: {} };
+              fa2.exports = function(t42, e22) {
+                for (var r22, n22 = t42.length, i22 = e22 ^ n22, s22 = 0; n22 >= 4; ) r22 = 1540483477 * (65535 & (r22 = 255 & t42.charCodeAt(s22) | (255 & t42.charCodeAt(++s22)) << 8 | (255 & t42.charCodeAt(++s22)) << 16 | (255 & t42.charCodeAt(++s22)) << 24)) + ((1540483477 * (r22 >>> 16) & 65535) << 16), i22 = 1540483477 * (65535 & i22) + ((1540483477 * (i22 >>> 16) & 65535) << 16) ^ (r22 = 1540483477 * (65535 & (r22 ^= r22 >>> 24)) + ((1540483477 * (r22 >>> 16) & 65535) << 16)), n22 -= 4, ++s22;
+                switch (n22) {
+                  case 3:
+                    i22 ^= (255 & t42.charCodeAt(s22 + 2)) << 16;
+                  case 2:
+                    i22 ^= (255 & t42.charCodeAt(s22 + 1)) << 8;
+                  case 1:
+                    i22 = 1540483477 * (65535 & (i22 ^= 255 & t42.charCodeAt(s22))) + ((1540483477 * (i22 >>> 16) & 65535) << 16);
+                }
+                return i22 = 1540483477 * (65535 & (i22 ^= i22 >>> 13)) + ((1540483477 * (i22 >>> 16) & 65535) << 16), (i22 ^= i22 >>> 15) >>> 0;
+              };
+              var da2 = pa2, ya2 = fa2.exports;
+              ca2.exports = da2, ca2.exports.murmur3 = da2, ca2.exports.murmur2 = ya2;
+              var ma2 = r2(ca2.exports);
+              class ga {
+                constructor() {
+                  this.ids = [], this.positions = [], this.indexed = false;
+                }
+                add(t42, e22, r22, n22) {
+                  this.ids.push(xa(t42)), this.positions.push(e22, r22, n22);
+                }
+                getPositions(t42) {
+                  if (!this.indexed) throw new Error("Trying to get index, but feature positions are not indexed");
+                  const e22 = xa(t42);
+                  let r22 = 0, n22 = this.ids.length - 1;
+                  for (; r22 < n22; ) {
+                    const t5 = r22 + n22 >> 1;
+                    this.ids[t5] >= e22 ? n22 = t5 : r22 = t5 + 1;
+                  }
+                  const i22 = [];
+                  for (; this.ids[r22] === e22; ) i22.push({ index: this.positions[3 * r22], start: this.positions[3 * r22 + 1], end: this.positions[3 * r22 + 2] }), r22++;
+                  return i22;
+                }
+                static serialize(t42, e22) {
+                  const r22 = new Float64Array(t42.ids), n22 = new Uint32Array(t42.positions);
+                  return va2(r22, n22, 0, r22.length - 1), e22 && e22.push(r22.buffer, n22.buffer), { ids: r22, positions: n22 };
+                }
+                static deserialize(t42) {
+                  const e22 = new ga();
+                  return e22.ids = t42.ids, e22.positions = t42.positions, e22.indexed = true, e22;
+                }
+              }
+              function xa(t42) {
+                const e22 = +t42;
+                return !isNaN(e22) && e22 <= Number.MAX_SAFE_INTEGER ? e22 : ma2(String(t42));
+              }
+              function va2(t42, e22, r22, n22) {
+                for (; r22 < n22; ) {
+                  const i22 = t42[r22 + n22 >> 1];
+                  let s22 = r22 - 1, a22 = n22 + 1;
+                  for (; ; ) {
+                    do {
+                      s22++;
+                    } while (t42[s22] < i22);
+                    do {
+                      a22--;
+                    } while (t42[a22] > i22);
+                    if (s22 >= a22) break;
+                    ba(t42, s22, a22), ba(e22, 3 * s22, 3 * a22), ba(e22, 3 * s22 + 1, 3 * a22 + 1), ba(e22, 3 * s22 + 2, 3 * a22 + 2);
+                  }
+                  a22 - r22 < n22 - a22 ? (va2(t42, e22, r22, a22), r22 = a22 + 1) : (va2(t42, e22, a22 + 1, n22), n22 = a22);
+                }
+              }
+              function ba(t42, e22, r22) {
+                const n22 = t42[e22];
+                t42[e22] = t42[r22], t42[r22] = n22;
+              }
+              wi2("FeaturePositionMap", ga);
+              class wa2 {
+                constructor(t42, e22) {
+                  this.gl = t42.gl, this.location = e22;
+                }
+              }
+              class _a3 extends wa2 {
+                constructor(t42, e22) {
+                  super(t42, e22), this.current = 0;
+                }
+                set(t42) {
+                  this.current !== t42 && (this.current = t42, this.gl.uniform1f(this.location, t42));
+                }
+              }
+              class Aa2 extends wa2 {
+                constructor(t42, e22) {
+                  super(t42, e22), this.current = [0, 0, 0, 0];
+                }
+                set(t42) {
+                  t42[0] === this.current[0] && t42[1] === this.current[1] && t42[2] === this.current[2] && t42[3] === this.current[3] || (this.current = t42, this.gl.uniform4f(this.location, t42[0], t42[1], t42[2], t42[3]));
+                }
+              }
+              class Sa2 extends wa2 {
+                constructor(t42, e22) {
+                  super(t42, e22), this.current = Kt.transparent;
+                }
+                set(t42) {
+                  t42.r === this.current.r && t42.g === this.current.g && t42.b === this.current.b && t42.a === this.current.a || (this.current = t42, this.gl.uniform4f(this.location, t42.r, t42.g, t42.b, t42.a));
+                }
+              }
+              const ka2 = new Float32Array(16);
+              function Ma2(t42) {
+                return [la2(255 * t42.r, 255 * t42.g), la2(255 * t42.b, 255 * t42.a)];
+              }
+              class Ia2 {
+                constructor(t42, e22, r22) {
+                  this.value = t42, this.uniformNames = e22.map((t5) => `u_${t5}`), this.type = r22;
+                }
+                setUniform(t42, e22, r22) {
+                  t42.set(r22.constantOr(this.value));
+                }
+                getBinding(t42, e22, r22) {
+                  return "color" === this.type ? new Sa2(t42, e22) : new _a3(t42, e22);
+                }
+              }
+              class za2 {
+                constructor(t42, e22) {
+                  this.uniformNames = e22.map((t5) => `u_${t5}`), this.patternFrom = null, this.patternTo = null, this.pixelRatioFrom = 1, this.pixelRatioTo = 1;
+                }
+                setConstantPatternPositions(t42, e22) {
+                  this.pixelRatioFrom = e22.pixelRatio, this.pixelRatioTo = t42.pixelRatio, this.patternFrom = e22.tlbr, this.patternTo = t42.tlbr;
+                }
+                setUniform(t42, e22, r22, n22) {
+                  const i22 = "u_pattern_to" === n22 ? this.patternTo : "u_pattern_from" === n22 ? this.patternFrom : "u_pixel_ratio_to" === n22 ? this.pixelRatioTo : "u_pixel_ratio_from" === n22 ? this.pixelRatioFrom : null;
+                  i22 && t42.set(i22);
+                }
+                getBinding(t42, e22, r22) {
+                  return "u_pattern" === r22.substr(0, 9) ? new Aa2(t42, e22) : new _a3(t42, e22);
+                }
+              }
+              class Pa2 {
+                constructor(t42, e22, r22, n22) {
+                  this.expression = t42, this.type = r22, this.maxValue = 0, this.paintVertexAttributes = e22.map((t5) => ({ name: `a_${t5}`, type: "Float32", components: "color" === r22 ? 2 : 1, offset: 0 })), this.paintVertexArray = new n22();
+                }
+                populatePaintArray(t42, e22, r22, n22, i22) {
+                  const s22 = this.paintVertexArray.length, a22 = this.expression.evaluate(new Ui2(0), e22, {}, n22, [], i22);
+                  this.paintVertexArray.resize(t42), this._setPaintValue(s22, t42, a22);
+                }
+                updatePaintArray(t42, e22, r22, n22) {
+                  const i22 = this.expression.evaluate({ zoom: 0 }, r22, n22);
+                  this._setPaintValue(t42, e22, i22);
+                }
+                _setPaintValue(t42, e22, r22) {
+                  if ("color" === this.type) {
+                    const n22 = Ma2(r22);
+                    for (let r3 = t42; r3 < e22; r3++) this.paintVertexArray.emplace(r3, n22[0], n22[1]);
+                  } else {
+                    for (let n22 = t42; n22 < e22; n22++) this.paintVertexArray.emplace(n22, r22);
+                    this.maxValue = Math.max(this.maxValue, Math.abs(r22));
+                  }
+                }
+                upload(t42) {
+                  this.paintVertexArray && this.paintVertexArray.arrayBuffer && (this.paintVertexBuffer && this.paintVertexBuffer.buffer ? this.paintVertexBuffer.updateData(this.paintVertexArray) : this.paintVertexBuffer = t42.createVertexBuffer(this.paintVertexArray, this.paintVertexAttributes, this.expression.isStateDependent));
+                }
+                destroy() {
+                  this.paintVertexBuffer && this.paintVertexBuffer.destroy();
+                }
+              }
+              class Ca2 {
+                constructor(t42, e22, r22, n22, i22, s22) {
+                  this.expression = t42, this.uniformNames = e22.map((t5) => `u_${t5}_t`), this.type = r22, this.useIntegerZoom = n22, this.zoom = i22, this.maxValue = 0, this.paintVertexAttributes = e22.map((t5) => ({ name: `a_${t5}`, type: "Float32", components: "color" === r22 ? 4 : 2, offset: 0 })), this.paintVertexArray = new s22();
+                }
+                populatePaintArray(t42, e22, r22, n22, i22) {
+                  const s22 = this.expression.evaluate(new Ui2(this.zoom), e22, {}, n22, [], i22), a22 = this.expression.evaluate(new Ui2(this.zoom + 1), e22, {}, n22, [], i22), o22 = this.paintVertexArray.length;
+                  this.paintVertexArray.resize(t42), this._setPaintValue(o22, t42, s22, a22);
+                }
+                updatePaintArray(t42, e22, r22, n22) {
+                  const i22 = this.expression.evaluate({ zoom: this.zoom }, r22, n22), s22 = this.expression.evaluate({ zoom: this.zoom + 1 }, r22, n22);
+                  this._setPaintValue(t42, e22, i22, s22);
+                }
+                _setPaintValue(t42, e22, r22, n22) {
+                  if ("color" === this.type) {
+                    const i22 = Ma2(r22), s22 = Ma2(n22);
+                    for (let r3 = t42; r3 < e22; r3++) this.paintVertexArray.emplace(r3, i22[0], i22[1], s22[0], s22[1]);
+                  } else {
+                    for (let i22 = t42; i22 < e22; i22++) this.paintVertexArray.emplace(i22, r22, n22);
+                    this.maxValue = Math.max(this.maxValue, Math.abs(r22), Math.abs(n22));
+                  }
+                }
+                upload(t42) {
+                  this.paintVertexArray && this.paintVertexArray.arrayBuffer && (this.paintVertexBuffer && this.paintVertexBuffer.buffer ? this.paintVertexBuffer.updateData(this.paintVertexArray) : this.paintVertexBuffer = t42.createVertexBuffer(this.paintVertexArray, this.paintVertexAttributes, this.expression.isStateDependent));
+                }
+                destroy() {
+                  this.paintVertexBuffer && this.paintVertexBuffer.destroy();
+                }
+                setUniform(t42, e22) {
+                  const r22 = this.useIntegerZoom ? Math.floor(e22.zoom) : e22.zoom, n22 = y2(this.expression.interpolationFactor(r22, this.zoom, this.zoom + 1), 0, 1);
+                  t42.set(n22);
+                }
+                getBinding(t42, e22, r22) {
+                  return new _a3(t42, e22);
+                }
+              }
+              class Ba2 {
+                constructor(t42, e22, r22, n22, i22, s22) {
+                  this.expression = t42, this.type = e22, this.useIntegerZoom = r22, this.zoom = n22, this.layerId = s22, this.zoomInPaintVertexArray = new i22(), this.zoomOutPaintVertexArray = new i22();
+                }
+                populatePaintArray(t42, e22, r22) {
+                  const n22 = this.zoomInPaintVertexArray.length;
+                  this.zoomInPaintVertexArray.resize(t42), this.zoomOutPaintVertexArray.resize(t42), this._setPaintValues(n22, t42, e22.patterns && e22.patterns[this.layerId], r22);
+                }
+                updatePaintArray(t42, e22, r22, n22, i22) {
+                  this._setPaintValues(t42, e22, r22.patterns && r22.patterns[this.layerId], i22);
+                }
+                _setPaintValues(t42, e22, r22, n22) {
+                  if (!n22 || !r22) return;
+                  const { min: i22, mid: s22, max: a22 } = r22, o22 = n22[i22], l22 = n22[s22], u22 = n22[a22];
+                  if (o22 && l22 && u22) for (let r3 = t42; r3 < e22; r3++) this.zoomInPaintVertexArray.emplace(r3, l22.tl[0], l22.tl[1], l22.br[0], l22.br[1], o22.tl[0], o22.tl[1], o22.br[0], o22.br[1], l22.pixelRatio, o22.pixelRatio), this.zoomOutPaintVertexArray.emplace(r3, l22.tl[0], l22.tl[1], l22.br[0], l22.br[1], u22.tl[0], u22.tl[1], u22.br[0], u22.br[1], l22.pixelRatio, u22.pixelRatio);
+                }
+                upload(t42) {
+                  this.zoomInPaintVertexArray && this.zoomInPaintVertexArray.arrayBuffer && this.zoomOutPaintVertexArray && this.zoomOutPaintVertexArray.arrayBuffer && (this.zoomInPaintVertexBuffer = t42.createVertexBuffer(this.zoomInPaintVertexArray, ua2.members, this.expression.isStateDependent), this.zoomOutPaintVertexBuffer = t42.createVertexBuffer(this.zoomOutPaintVertexArray, ua2.members, this.expression.isStateDependent));
+                }
+                destroy() {
+                  this.zoomOutPaintVertexBuffer && this.zoomOutPaintVertexBuffer.destroy(), this.zoomInPaintVertexBuffer && this.zoomInPaintVertexBuffer.destroy();
+                }
+              }
+              class Va2 {
+                constructor(t42, e22, r22) {
+                  this.binders = {}, this._buffers = [];
+                  const n22 = [];
+                  for (const i22 in t42.paint._values) {
+                    if (!r22(i22)) continue;
+                    const s22 = t42.paint.get(i22);
+                    if (!(s22 instanceof Hi2 && an(s22.property.specification))) continue;
+                    const a22 = Fa2(i22, t42.type), o22 = s22.value, l22 = s22.property.specification.type, u22 = s22.property.useIntegerZoom, c22 = s22.property.specification["property-type"], h22 = "cross-faded" === c22 || "cross-faded-data-driven" === c22;
+                    if ("constant" === o22.kind) this.binders[i22] = h22 ? new za2(o22.value, a22) : new Ia2(o22.value, a22, l22), n22.push(`/u_${i22}`);
+                    else if ("source" === o22.kind || h22) {
+                      const r3 = Ta2(i22, l22, "source");
+                      this.binders[i22] = h22 ? new Ba2(o22, l22, u22, e22, r3, t42.id) : new Pa2(o22, a22, l22, r3), n22.push(`/a_${i22}`);
+                    } else {
+                      const t5 = Ta2(i22, l22, "composite");
+                      this.binders[i22] = new Ca2(o22, a22, l22, u22, e22, t5), n22.push(`/z_${i22}`);
+                    }
+                  }
+                  this.cacheKey = n22.sort().join("");
+                }
+                getMaxValue(t42) {
+                  const e22 = this.binders[t42];
+                  return e22 instanceof Pa2 || e22 instanceof Ca2 ? e22.maxValue : 0;
+                }
+                populatePaintArrays(t42, e22, r22, n22, i22) {
+                  for (const s22 in this.binders) {
+                    const a22 = this.binders[s22];
+                    (a22 instanceof Pa2 || a22 instanceof Ca2 || a22 instanceof Ba2) && a22.populatePaintArray(t42, e22, r22, n22, i22);
+                  }
+                }
+                setConstantPatternPositions(t42, e22) {
+                  for (const r22 in this.binders) {
+                    const n22 = this.binders[r22];
+                    n22 instanceof za2 && n22.setConstantPatternPositions(t42, e22);
+                  }
+                }
+                updatePaintArrays(t42, e22, r22, n22, i22) {
+                  let s22 = false;
+                  for (const a22 in t42) {
+                    const o22 = e22.getPositions(a22);
+                    for (const e3 of o22) {
+                      const o3 = r22.feature(e3.index);
+                      for (const r3 in this.binders) {
+                        const l22 = this.binders[r3];
+                        if ((l22 instanceof Pa2 || l22 instanceof Ca2 || l22 instanceof Ba2) && true === l22.expression.isStateDependent) {
+                          const u22 = n22.paint.get(r3);
+                          l22.expression = u22.value, l22.updatePaintArray(e3.start, e3.end, o3, t42[a22], i22), s22 = true;
+                        }
+                      }
+                    }
+                  }
+                  return s22;
+                }
+                defines() {
+                  const t42 = [];
+                  for (const e22 in this.binders) {
+                    const r22 = this.binders[e22];
+                    (r22 instanceof Ia2 || r22 instanceof za2) && t42.push(...r22.uniformNames.map((t5) => `#define HAS_UNIFORM_${t5}`));
+                  }
+                  return t42;
+                }
+                getBinderAttributes() {
+                  const t42 = [];
+                  for (const e22 in this.binders) {
+                    const r22 = this.binders[e22];
+                    if (r22 instanceof Pa2 || r22 instanceof Ca2) for (let e3 = 0; e3 < r22.paintVertexAttributes.length; e3++) t42.push(r22.paintVertexAttributes[e3].name);
+                    else if (r22 instanceof Ba2) for (let e3 = 0; e3 < ua2.members.length; e3++) t42.push(ua2.members[e3].name);
+                  }
+                  return t42;
+                }
+                getBinderUniforms() {
+                  const t42 = [];
+                  for (const e22 in this.binders) {
+                    const r22 = this.binders[e22];
+                    if (r22 instanceof Ia2 || r22 instanceof za2 || r22 instanceof Ca2) for (const e3 of r22.uniformNames) t42.push(e3);
+                  }
+                  return t42;
+                }
+                getPaintVertexBuffers() {
+                  return this._buffers;
+                }
+                getUniforms(t42, e22) {
+                  const r22 = [];
+                  for (const n22 in this.binders) {
+                    const i22 = this.binders[n22];
+                    if (i22 instanceof Ia2 || i22 instanceof za2 || i22 instanceof Ca2) {
+                      for (const s22 of i22.uniformNames) if (e22[s22]) {
+                        const a22 = i22.getBinding(t42, e22[s22], s22);
+                        r22.push({ name: s22, property: n22, binding: a22 });
+                      }
+                    }
+                  }
+                  return r22;
+                }
+                setUniforms(t42, e22, r22, n22) {
+                  for (const { name: t5, property: i22, binding: s22 } of e22) this.binders[i22].setUniform(s22, n22, r22.get(i22), t5);
+                }
+                updatePaintBuffers(t42) {
+                  this._buffers = [];
+                  for (const e22 in this.binders) {
+                    const r22 = this.binders[e22];
+                    if (t42 && r22 instanceof Ba2) {
+                      const e3 = 2 === t42.fromScale ? r22.zoomInPaintVertexBuffer : r22.zoomOutPaintVertexBuffer;
+                      e3 && this._buffers.push(e3);
+                    } else (r22 instanceof Pa2 || r22 instanceof Ca2) && r22.paintVertexBuffer && this._buffers.push(r22.paintVertexBuffer);
+                  }
+                }
+                upload(t42) {
+                  for (const e22 in this.binders) {
+                    const r22 = this.binders[e22];
+                    (r22 instanceof Pa2 || r22 instanceof Ca2 || r22 instanceof Ba2) && r22.upload(t42);
+                  }
+                  this.updatePaintBuffers();
+                }
+                destroy() {
+                  for (const t42 in this.binders) {
+                    const e22 = this.binders[t42];
+                    (e22 instanceof Pa2 || e22 instanceof Ca2 || e22 instanceof Ba2) && e22.destroy();
+                  }
+                }
+              }
+              class Ea2 {
+                constructor(t42, e22, r22 = () => true) {
+                  this.programConfigurations = {};
+                  for (const n22 of t42) this.programConfigurations[n22.id] = new Va2(n22, e22, r22);
+                  this.needsUpload = false, this._featureMap = new ga(), this._bufferOffset = 0;
+                }
+                populatePaintArrays(t42, e22, r22, n22, i22, s22) {
+                  for (const r3 in this.programConfigurations) this.programConfigurations[r3].populatePaintArrays(t42, e22, n22, i22, s22);
+                  void 0 !== e22.id && this._featureMap.add(e22.id, r22, this._bufferOffset, t42), this._bufferOffset = t42, this.needsUpload = true;
+                }
+                updatePaintArrays(t42, e22, r22, n22) {
+                  for (const i22 of r22) this.needsUpload = this.programConfigurations[i22.id].updatePaintArrays(t42, this._featureMap, e22, i22, n22) || this.needsUpload;
+                }
+                get(t42) {
+                  return this.programConfigurations[t42];
+                }
+                upload(t42) {
+                  if (this.needsUpload) {
+                    for (const e22 in this.programConfigurations) this.programConfigurations[e22].upload(t42);
+                    this.needsUpload = false;
+                  }
+                }
+                destroy() {
+                  for (const t42 in this.programConfigurations) this.programConfigurations[t42].destroy();
+                }
+              }
+              function Fa2(t42, e22) {
+                return { "text-opacity": ["opacity"], "icon-opacity": ["opacity"], "text-color": ["fill_color"], "icon-color": ["fill_color"], "text-halo-color": ["halo_color"], "icon-halo-color": ["halo_color"], "text-halo-blur": ["halo_blur"], "icon-halo-blur": ["halo_blur"], "text-halo-width": ["halo_width"], "icon-halo-width": ["halo_width"], "line-gap-width": ["gapwidth"], "line-pattern": ["pattern_to", "pattern_from", "pixel_ratio_to", "pixel_ratio_from"], "fill-pattern": ["pattern_to", "pattern_from", "pixel_ratio_to", "pixel_ratio_from"], "fill-extrusion-pattern": ["pattern_to", "pattern_from", "pixel_ratio_to", "pixel_ratio_from"] }[t42] || [t42.replace(`${e22}-`, "").replace(/-/g, "_")];
+              }
+              function Ta2(t42, e22, r22) {
+                const n22 = { color: { source: ys, composite: Vs }, number: { source: Is, composite: ys } }, i22 = function(t5) {
+                  return { "line-pattern": { source: Js, composite: Js }, "fill-pattern": { source: Js, composite: Js }, "fill-extrusion-pattern": { source: Js, composite: Js } }[t5];
+                }(t42);
+                return i22 && i22[r22] || n22[e22][r22];
+              }
+              wi2("ConstantBinder", Ia2), wi2("CrossFadedConstantBinder", za2), wi2("SourceExpressionBinder", Pa2), wi2("CrossFadedCompositeBinder", Ba2), wi2("CompositeExpressionBinder", Ca2), wi2("ProgramConfiguration", Va2, { omit: ["_buffers"] }), wi2("ProgramConfigurationSet", Ea2);
+              const $a = 8192, La2 = Math.pow(2, 14) - 1, Da2 = -La2 - 1;
+              function Oa2(t42) {
+                const e22 = $a / t42.extent, r22 = t42.loadGeometry();
+                for (let t5 = 0; t5 < r22.length; t5++) {
+                  const n22 = r22[t5];
+                  for (let t6 = 0; t6 < n22.length; t6++) {
+                    const r3 = n22[t6], i22 = Math.round(r3.x * e22), s22 = Math.round(r3.y * e22);
+                    r3.x = y2(i22, Da2, La2), r3.y = y2(s22, Da2, La2), (i22 < r3.x || i22 > r3.x + 1 || s22 < r3.y || s22 > r3.y + 1) && A22("Geometry exceeds allowed extent, reduce your vector tile buffer size");
+                  }
+                }
+                return r22;
+              }
+              function ja2(t42, e22) {
+                return { type: t42.type, id: t42.id, properties: t42.properties, geometry: e22 ? Oa2(t42) : [] };
+              }
+              function Ra2(t42, e22, r22, n22, i22) {
+                t42.emplaceBack(2 * e22 + (n22 + 1) / 2, 2 * r22 + (i22 + 1) / 2);
+              }
+              class Ua2 {
+                constructor(t42) {
+                  this.zoom = t42.zoom, this.overscaling = t42.overscaling, this.layers = t42.layers, this.layerIds = this.layers.map((t5) => t5.id), this.index = t42.index, this.hasPattern = false, this.layoutVertexArray = new Gs(), this.indexArray = new na(), this.segments = new oa2(), this.programConfigurations = new Ea2(t42.layers, t42.zoom), this.stateDependentLayerIds = this.layers.filter((t5) => t5.isStateDependent()).map((t5) => t5.id);
+                }
+                populate(t42, e22, r22) {
+                  const n22 = this.layers[0], i22 = [];
+                  let s22 = null, a22 = false;
+                  "circle" === n22.type && (s22 = n22.layout.get("circle-sort-key"), a22 = !s22.isConstant());
+                  for (const { feature: e3, id: n3, index: o22, sourceLayerIndex: l22 } of t42) {
+                    const t5 = this.layers[0]._featureFilter.needGeometry, u22 = ja2(e3, t5);
+                    if (!this.layers[0]._featureFilter.filter(new Ui2(this.zoom), u22, r22)) continue;
+                    const c22 = a22 ? s22.evaluate(u22, {}, r22) : void 0, h22 = { id: n3, properties: e3.properties, type: e3.type, sourceLayerIndex: l22, index: o22, geometry: t5 ? u22.geometry : Oa2(e3), patterns: {}, sortKey: c22 };
+                    i22.push(h22);
+                  }
+                  a22 && i22.sort((t5, e3) => t5.sortKey - e3.sortKey);
+                  for (const n3 of i22) {
+                    const { geometry: i3, index: s3, sourceLayerIndex: a3 } = n3, o22 = t42[s3].feature;
+                    this.addFeature(n3, i3, s3, r22), e22.featureIndex.insert(o22, i3, s3, a3, this.index);
+                  }
+                }
+                update(t42, e22, r22) {
+                  this.stateDependentLayers.length && this.programConfigurations.updatePaintArrays(t42, e22, this.stateDependentLayers, r22);
+                }
+                isEmpty() {
+                  return 0 === this.layoutVertexArray.length;
+                }
+                uploadPending() {
+                  return !this.uploaded || this.programConfigurations.needsUpload;
+                }
+                upload(t42) {
+                  this.uploaded || (this.layoutVertexBuffer = t42.createVertexBuffer(this.layoutVertexArray, aa2), this.indexBuffer = t42.createIndexBuffer(this.indexArray)), this.programConfigurations.upload(t42), this.uploaded = true;
+                }
+                destroy() {
+                  this.layoutVertexBuffer && (this.layoutVertexBuffer.destroy(), this.indexBuffer.destroy(), this.programConfigurations.destroy(), this.segments.destroy());
+                }
+                addFeature(t42, e22, r22, n22) {
+                  for (const r3 of e22) for (const e3 of r3) {
+                    const r4 = e3.x, n3 = e3.y;
+                    if (r4 < 0 || r4 >= $a || n3 < 0 || n3 >= $a) continue;
+                    const i22 = this.segments.prepareSegment(4, this.layoutVertexArray, this.indexArray, t42.sortKey), s22 = i22.vertexLength;
+                    Ra2(this.layoutVertexArray, r4, n3, -1, -1), Ra2(this.layoutVertexArray, r4, n3, 1, -1), Ra2(this.layoutVertexArray, r4, n3, 1, 1), Ra2(this.layoutVertexArray, r4, n3, -1, 1), this.indexArray.emplaceBack(s22, s22 + 1, s22 + 2), this.indexArray.emplaceBack(s22, s22 + 3, s22 + 2), i22.vertexLength += 4, i22.primitiveLength += 2;
+                  }
+                  this.programConfigurations.populatePaintArrays(this.layoutVertexArray.length, t42, r22, {}, n22);
+                }
+              }
+              function qa2(t42, e22) {
+                for (let r22 = 0; r22 < t42.length; r22++) if (Wa2(e22, t42[r22])) return true;
+                for (let r22 = 0; r22 < e22.length; r22++) if (Wa2(t42, e22[r22])) return true;
+                return !!Ka2(t42, e22);
+              }
+              function Na2(t42, e22, r22) {
+                return !!Wa2(t42, e22) || !!Ha2(e22, t42, r22);
+              }
+              function Za2(t42, e22) {
+                if (1 === t42.length) return Ja2(e22, t42[0]);
+                for (let r22 = 0; r22 < e22.length; r22++) {
+                  const n22 = e22[r22];
+                  for (let e3 = 0; e3 < n22.length; e3++) if (Wa2(t42, n22[e3])) return true;
+                }
+                for (let r22 = 0; r22 < t42.length; r22++) if (Ja2(e22, t42[r22])) return true;
+                for (let r22 = 0; r22 < e22.length; r22++) if (Ka2(t42, e22[r22])) return true;
+                return false;
+              }
+              function Ga2(t42, e22, r22) {
+                if (t42.length > 1) {
+                  if (Ka2(t42, e22)) return true;
+                  for (let n22 = 0; n22 < e22.length; n22++) if (Ha2(e22[n22], t42, r22)) return true;
+                }
+                for (let n22 = 0; n22 < t42.length; n22++) if (Ha2(t42[n22], e22, r22)) return true;
+                return false;
+              }
+              function Ka2(t42, e22) {
+                if (0 === t42.length || 0 === e22.length) return false;
+                for (let r22 = 0; r22 < t42.length - 1; r22++) {
+                  const n22 = t42[r22], i22 = t42[r22 + 1];
+                  for (let t5 = 0; t5 < e22.length - 1; t5++) if (Xa2(n22, i22, e22[t5], e22[t5 + 1])) return true;
+                }
+                return false;
+              }
+              function Xa2(t42, e22, r22, n22) {
+                return S2(t42, r22, n22) !== S2(e22, r22, n22) && S2(t42, e22, r22) !== S2(t42, e22, n22);
+              }
+              function Ha2(t42, e22, r22) {
+                const n22 = r22 * r22;
+                if (1 === e22.length) return t42.distSqr(e22[0]) < n22;
+                for (let r3 = 1; r3 < e22.length; r3++) if (Ya2(t42, e22[r3 - 1], e22[r3]) < n22) return true;
+                return false;
+              }
+              function Ya2(t42, e22, r22) {
+                const n22 = e22.distSqr(r22);
+                if (0 === n22) return t42.distSqr(e22);
+                const i22 = ((t42.x - e22.x) * (r22.x - e22.x) + (t42.y - e22.y) * (r22.y - e22.y)) / n22;
+                return t42.distSqr(i22 < 0 ? e22 : i22 > 1 ? r22 : r22.sub(e22)._mult(i22)._add(e22));
+              }
+              function Ja2(t42, e22) {
+                let r22, n22, i22, s22 = false;
+                for (let a22 = 0; a22 < t42.length; a22++) {
+                  r22 = t42[a22];
+                  for (let t5 = 0, a3 = r22.length - 1; t5 < r22.length; a3 = t5++) n22 = r22[t5], i22 = r22[a3], n22.y > e22.y != i22.y > e22.y && e22.x < (i22.x - n22.x) * (e22.y - n22.y) / (i22.y - n22.y) + n22.x && (s22 = !s22);
+                }
+                return s22;
+              }
+              function Wa2(t42, e22) {
+                let r22 = false;
+                for (let n22 = 0, i22 = t42.length - 1; n22 < t42.length; i22 = n22++) {
+                  const s22 = t42[n22], a22 = t42[i22];
+                  s22.y > e22.y != a22.y > e22.y && e22.x < (a22.x - s22.x) * (e22.y - s22.y) / (a22.y - s22.y) + s22.x && (r22 = !r22);
+                }
+                return r22;
+              }
+              function Qa2(t42, e22, r22) {
+                const n22 = r22[0], i22 = r22[2];
+                if (t42.x < n22.x && e22.x < n22.x || t42.x > i22.x && e22.x > i22.x || t42.y < n22.y && e22.y < n22.y || t42.y > i22.y && e22.y > i22.y) return false;
+                const s22 = S2(t42, e22, r22[0]);
+                return s22 !== S2(t42, e22, r22[1]) || s22 !== S2(t42, e22, r22[2]) || s22 !== S2(t42, e22, r22[3]);
+              }
+              function to(t42, e22, r22) {
+                const n22 = e22.paint.get(t42).value;
+                return "constant" === n22.kind ? n22.value : r22.programConfigurations.get(e22.id).getMaxValue(t42);
+              }
+              function eo(t42) {
+                return Math.sqrt(t42[0] * t42[0] + t42[1] * t42[1]);
+              }
+              function ro(t42, e22, r22, n22, i22) {
+                if (!e22[0] && !e22[1]) return t42;
+                const a22 = s2.convert(e22)._mult(i22);
+                "viewport" === r22 && a22._rotate(-n22);
+                const o22 = [];
+                for (let e3 = 0; e3 < t42.length; e3++) o22.push(t42[e3].sub(a22));
+                return o22;
+              }
+              let no, io;
+              wi2("CircleBucket", Ua2, { omit: ["layers"] });
+              var so = { get paint() {
+                return io = io || new rs({ "circle-radius": new Wi2(G2.paint_circle["circle-radius"]), "circle-color": new Wi2(G2.paint_circle["circle-color"]), "circle-blur": new Wi2(G2.paint_circle["circle-blur"]), "circle-opacity": new Wi2(G2.paint_circle["circle-opacity"]), "circle-translate": new Ji2(G2.paint_circle["circle-translate"]), "circle-translate-anchor": new Ji2(G2.paint_circle["circle-translate-anchor"]), "circle-pitch-scale": new Ji2(G2.paint_circle["circle-pitch-scale"]), "circle-pitch-alignment": new Ji2(G2.paint_circle["circle-pitch-alignment"]), "circle-stroke-width": new Wi2(G2.paint_circle["circle-stroke-width"]), "circle-stroke-color": new Wi2(G2.paint_circle["circle-stroke-color"]), "circle-stroke-opacity": new Wi2(G2.paint_circle["circle-stroke-opacity"]) });
+              }, get layout() {
+                return no = no || new rs({ "circle-sort-key": new Wi2(G2.layout_circle["circle-sort-key"]) });
+              } }, ao = 1e-6, oo = "undefined" != typeof Float32Array ? Float32Array : Array;
+              function lo(t42) {
+                return t42[0] = 1, t42[1] = 0, t42[2] = 0, t42[3] = 0, t42[4] = 0, t42[5] = 1, t42[6] = 0, t42[7] = 0, t42[8] = 0, t42[9] = 0, t42[10] = 1, t42[11] = 0, t42[12] = 0, t42[13] = 0, t42[14] = 0, t42[15] = 1, t42;
+              }
+              function uo(t42, e22, r22) {
+                var n22 = e22[0], i22 = e22[1], s22 = e22[2], a22 = e22[3], o22 = e22[4], l22 = e22[5], u22 = e22[6], c22 = e22[7], h22 = e22[8], p22 = e22[9], f22 = e22[10], d22 = e22[11], y22 = e22[12], m22 = e22[13], g22 = e22[14], x22 = e22[15], v22 = r22[0], b22 = r22[1], w22 = r22[2], _22 = r22[3];
+                return t42[0] = v22 * n22 + b22 * o22 + w22 * h22 + _22 * y22, t42[1] = v22 * i22 + b22 * l22 + w22 * p22 + _22 * m22, t42[2] = v22 * s22 + b22 * u22 + w22 * f22 + _22 * g22, t42[3] = v22 * a22 + b22 * c22 + w22 * d22 + _22 * x22, t42[4] = (v22 = r22[4]) * n22 + (b22 = r22[5]) * o22 + (w22 = r22[6]) * h22 + (_22 = r22[7]) * y22, t42[5] = v22 * i22 + b22 * l22 + w22 * p22 + _22 * m22, t42[6] = v22 * s22 + b22 * u22 + w22 * f22 + _22 * g22, t42[7] = v22 * a22 + b22 * c22 + w22 * d22 + _22 * x22, t42[8] = (v22 = r22[8]) * n22 + (b22 = r22[9]) * o22 + (w22 = r22[10]) * h22 + (_22 = r22[11]) * y22, t42[9] = v22 * i22 + b22 * l22 + w22 * p22 + _22 * m22, t42[10] = v22 * s22 + b22 * u22 + w22 * f22 + _22 * g22, t42[11] = v22 * a22 + b22 * c22 + w22 * d22 + _22 * x22, t42[12] = (v22 = r22[12]) * n22 + (b22 = r22[13]) * o22 + (w22 = r22[14]) * h22 + (_22 = r22[15]) * y22, t42[13] = v22 * i22 + b22 * l22 + w22 * p22 + _22 * m22, t42[14] = v22 * s22 + b22 * u22 + w22 * f22 + _22 * g22, t42[15] = v22 * a22 + b22 * c22 + w22 * d22 + _22 * x22, t42;
+              }
+              Math.hypot || (Math.hypot = function() {
+                for (var t42 = 0, e22 = arguments.length; e22--; ) t42 += arguments[e22] * arguments[e22];
+                return Math.sqrt(t42);
+              });
+              var co, ho = uo;
+              function po(t42, e22, r22) {
+                var n22 = e22[0], i22 = e22[1], s22 = e22[2], a22 = e22[3];
+                return t42[0] = r22[0] * n22 + r22[4] * i22 + r22[8] * s22 + r22[12] * a22, t42[1] = r22[1] * n22 + r22[5] * i22 + r22[9] * s22 + r22[13] * a22, t42[2] = r22[2] * n22 + r22[6] * i22 + r22[10] * s22 + r22[14] * a22, t42[3] = r22[3] * n22 + r22[7] * i22 + r22[11] * s22 + r22[15] * a22, t42;
+              }
+              co = new oo(4), oo != Float32Array && (co[0] = 0, co[1] = 0, co[2] = 0, co[3] = 0);
+              class fo extends is {
+                constructor(t42) {
+                  super(t42, so);
+                }
+                createBucket(t42) {
+                  return new Ua2(t42);
+                }
+                queryRadius(t42) {
+                  const e22 = t42;
+                  return to("circle-radius", this, e22) + to("circle-stroke-width", this, e22) + eo(this.paint.get("circle-translate"));
+                }
+                queryIntersectsFeature(t42, e22, r22, n22, i22, s22, a22, o22) {
+                  const l22 = ro(t42, this.paint.get("circle-translate"), this.paint.get("circle-translate-anchor"), s22.angle, a22), u22 = this.paint.get("circle-radius").evaluate(e22, r22) + this.paint.get("circle-stroke-width").evaluate(e22, r22), c22 = "map" === this.paint.get("circle-pitch-alignment"), h22 = c22 ? l22 : function(t5, e3) {
+                    return t5.map((t6) => yo(t6, e3));
+                  }(l22, o22), p22 = c22 ? u22 * a22 : u22;
+                  for (const t5 of n22) for (const e3 of t5) {
+                    const t6 = c22 ? e3 : yo(e3, o22);
+                    let r3 = p22;
+                    const n3 = po([], [e3.x, e3.y, 0, 1], o22);
+                    if ("viewport" === this.paint.get("circle-pitch-scale") && "map" === this.paint.get("circle-pitch-alignment") ? r3 *= n3[3] / s22.cameraToCenterDistance : "map" === this.paint.get("circle-pitch-scale") && "viewport" === this.paint.get("circle-pitch-alignment") && (r3 *= s22.cameraToCenterDistance / n3[3]), Na2(h22, t6, r3)) return true;
+                  }
+                  return false;
+                }
+              }
+              function yo(t42, e22) {
+                const r22 = po([], [t42.x, t42.y, 0, 1], e22);
+                return new s2(r22[0] / r22[3], r22[1] / r22[3]);
+              }
+              class mo extends Ua2 {
+              }
+              let go;
+              wi2("HeatmapBucket", mo, { omit: ["layers"] });
+              var xo = { get paint() {
+                return go = go || new rs({ "heatmap-radius": new Wi2(G2.paint_heatmap["heatmap-radius"]), "heatmap-weight": new Wi2(G2.paint_heatmap["heatmap-weight"]), "heatmap-intensity": new Ji2(G2.paint_heatmap["heatmap-intensity"]), "heatmap-color": new es(G2.paint_heatmap["heatmap-color"]), "heatmap-opacity": new Ji2(G2.paint_heatmap["heatmap-opacity"]) });
+              } };
+              function vo(t42, { width: e22, height: r22 }, n22, i22) {
+                if (i22) {
+                  if (i22 instanceof Uint8ClampedArray) i22 = new Uint8Array(i22.buffer);
+                  else if (i22.length !== e22 * r22 * n22) throw new RangeError(`mismatched image size. expected: ${i22.length} but got: ${e22 * r22 * n22}`);
+                } else i22 = new Uint8Array(e22 * r22 * n22);
+                return t42.width = e22, t42.height = r22, t42.data = i22, t42;
+              }
+              function bo(t42, { width: e22, height: r22 }, n22) {
+                if (e22 === t42.width && r22 === t42.height) return;
+                const i22 = vo({}, { width: e22, height: r22 }, n22);
+                wo(t42, i22, { x: 0, y: 0 }, { x: 0, y: 0 }, { width: Math.min(t42.width, e22), height: Math.min(t42.height, r22) }, n22), t42.width = e22, t42.height = r22, t42.data = i22.data;
+              }
+              function wo(t42, e22, r22, n22, i22, s22) {
+                if (0 === i22.width || 0 === i22.height) return e22;
+                if (i22.width > t42.width || i22.height > t42.height || r22.x > t42.width - i22.width || r22.y > t42.height - i22.height) throw new RangeError("out of range source coordinates for image copy");
+                if (i22.width > e22.width || i22.height > e22.height || n22.x > e22.width - i22.width || n22.y > e22.height - i22.height) throw new RangeError("out of range destination coordinates for image copy");
+                const a22 = t42.data, o22 = e22.data;
+                if (a22 === o22) throw new Error("srcData equals dstData, so image is already copied");
+                for (let l22 = 0; l22 < i22.height; l22++) {
+                  const u22 = ((r22.y + l22) * t42.width + r22.x) * s22, c22 = ((n22.y + l22) * e22.width + n22.x) * s22;
+                  for (let t5 = 0; t5 < i22.width * s22; t5++) o22[c22 + t5] = a22[u22 + t5];
+                }
+                return e22;
+              }
+              class _o2 {
+                constructor(t42, e22) {
+                  vo(this, t42, 1, e22);
+                }
+                resize(t42) {
+                  bo(this, t42, 1);
+                }
+                clone() {
+                  return new _o2({ width: this.width, height: this.height }, new Uint8Array(this.data));
+                }
+                static copy(t42, e22, r22, n22, i22) {
+                  wo(t42, e22, r22, n22, i22, 1);
+                }
+              }
+              class Ao {
+                constructor(t42, e22) {
+                  vo(this, t42, 4, e22);
+                }
+                resize(t42) {
+                  bo(this, t42, 4);
+                }
+                replace(t42, e22) {
+                  e22 ? this.data.set(t42) : this.data = t42 instanceof Uint8ClampedArray ? new Uint8Array(t42.buffer) : t42;
+                }
+                clone() {
+                  return new Ao({ width: this.width, height: this.height }, new Uint8Array(this.data));
+                }
+                static copy(t42, e22, r22, n22, i22) {
+                  wo(t42, e22, r22, n22, i22, 4);
+                }
+              }
+              function So(t42) {
+                const e22 = {}, r22 = t42.resolution || 256, n22 = t42.clips ? t42.clips.length : 1, i22 = t42.image || new Ao({ width: r22, height: n22 });
+                if (Math.log(r22) / Math.LN2 % 1 != 0) throw new Error(`width is not a power of 2 - ${r22}`);
+                const s22 = (r3, n3, s3) => {
+                  e22[t42.evaluationKey] = s3;
+                  const a22 = t42.expression.evaluate(e22);
+                  i22.data[r3 + n3 + 0] = Math.floor(255 * a22.r / a22.a), i22.data[r3 + n3 + 1] = Math.floor(255 * a22.g / a22.a), i22.data[r3 + n3 + 2] = Math.floor(255 * a22.b / a22.a), i22.data[r3 + n3 + 3] = Math.floor(255 * a22.a);
+                };
+                if (t42.clips) for (let e3 = 0, i3 = 0; e3 < n22; ++e3, i3 += 4 * r22) for (let n3 = 0, a22 = 0; n3 < r22; n3++, a22 += 4) {
+                  const o22 = n3 / (r22 - 1), { start: l22, end: u22 } = t42.clips[e3];
+                  s22(i3, a22, l22 * (1 - o22) + u22 * o22);
+                }
+                else for (let t5 = 0, e3 = 0; t5 < r22; t5++, e3 += 4) s22(0, e3, t5 / (r22 - 1));
+                return i22;
+              }
+              wi2("AlphaImage", _o2), wi2("RGBAImage", Ao);
+              const ko = "big-fb";
+              class Mo extends is {
+                createBucket(t42) {
+                  return new mo(t42);
+                }
+                constructor(t42) {
+                  super(t42, xo), this.heatmapFbos = /* @__PURE__ */ new Map(), this._updateColorRamp();
+                }
+                _handleSpecialPaintPropertyUpdate(t42) {
+                  "heatmap-color" === t42 && this._updateColorRamp();
+                }
+                _updateColorRamp() {
+                  this.colorRamp = So({ expression: this._transitionablePaint._values["heatmap-color"].value.expression, evaluationKey: "heatmapDensity", image: this.colorRamp }), this.colorRampTexture = null;
+                }
+                resize() {
+                  this.heatmapFbos.has(ko) && this.heatmapFbos.delete(ko);
+                }
+                queryRadius() {
+                  return 0;
+                }
+                queryIntersectsFeature() {
+                  return false;
+                }
+                hasOffscreenPass() {
+                  return 0 !== this.paint.get("heatmap-opacity") && "none" !== this.visibility;
+                }
+              }
+              let Io;
+              var zo = { get paint() {
+                return Io = Io || new rs({ "hillshade-illumination-direction": new Ji2(G2.paint_hillshade["hillshade-illumination-direction"]), "hillshade-illumination-anchor": new Ji2(G2.paint_hillshade["hillshade-illumination-anchor"]), "hillshade-exaggeration": new Ji2(G2.paint_hillshade["hillshade-exaggeration"]), "hillshade-shadow-color": new Ji2(G2.paint_hillshade["hillshade-shadow-color"]), "hillshade-highlight-color": new Ji2(G2.paint_hillshade["hillshade-highlight-color"]), "hillshade-accent-color": new Ji2(G2.paint_hillshade["hillshade-accent-color"]) });
+              } };
+              class Po extends is {
+                constructor(t42) {
+                  super(t42, zo);
+                }
+                hasOffscreenPass() {
+                  return 0 !== this.paint.get("hillshade-exaggeration") && "none" !== this.visibility;
+                }
+              }
+              const Co = ls([{ name: "a_pos", components: 2, type: "Int16" }], 4), { members: Bo } = Co;
+              function Vo(t42, e22, r22 = 2) {
+                const n22 = e22 && e22.length, i22 = n22 ? e22[0] * r22 : t42.length;
+                let s22 = Eo(t42, 0, i22, r22, true);
+                const a22 = [];
+                if (!s22 || s22.next === s22.prev) return a22;
+                let o22, l22, u22;
+                if (n22 && (s22 = function(t5, e3, r3, n3) {
+                  const i3 = [];
+                  for (let r4 = 0, s3 = e3.length; r4 < s3; r4++) {
+                    const a3 = Eo(t5, e3[r4] * n3, r4 < s3 - 1 ? e3[r4 + 1] * n3 : t5.length, n3, false);
+                    a3 === a3.next && (a3.steiner = true), i3.push(No(a3));
+                  }
+                  i3.sort(jo);
+                  for (let t6 = 0; t6 < i3.length; t6++) r3 = Ro(i3[t6], r3);
+                  return r3;
+                }(t42, e22, s22, r22)), t42.length > 80 * r22) {
+                  o22 = 1 / 0, l22 = 1 / 0;
+                  let e3 = -1 / 0, n3 = -1 / 0;
+                  for (let s3 = r22; s3 < i22; s3 += r22) {
+                    const r3 = t42[s3], i3 = t42[s3 + 1];
+                    r3 < o22 && (o22 = r3), i3 < l22 && (l22 = i3), r3 > e3 && (e3 = r3), i3 > n3 && (n3 = i3);
+                  }
+                  u22 = Math.max(e3 - o22, n3 - l22), u22 = 0 !== u22 ? 32767 / u22 : 0;
+                }
+                return To(s22, a22, r22, o22, l22, u22, 0), a22;
+              }
+              function Eo(t42, e22, r22, n22, i22) {
+                let s22;
+                if (i22 === function(t5, e3, r3, n3) {
+                  let i3 = 0;
+                  for (let s3 = e3, a22 = r3 - n3; s3 < r3; s3 += n3) i3 += (t5[a22] - t5[s3]) * (t5[s3 + 1] + t5[a22 + 1]), a22 = s3;
+                  return i3;
+                }(t42, e22, r22, n22) > 0) for (let i3 = e22; i3 < r22; i3 += n22) s22 = tl2(i3 / n22 | 0, t42[i3], t42[i3 + 1], s22);
+                else for (let i3 = r22 - n22; i3 >= e22; i3 -= n22) s22 = tl2(i3 / n22 | 0, t42[i3], t42[i3 + 1], s22);
+                return s22 && Xo(s22, s22.next) && (el2(s22), s22 = s22.next), s22;
+              }
+              function Fo(t42, e22) {
+                if (!t42) return t42;
+                e22 || (e22 = t42);
+                let r22, n22 = t42;
+                do {
+                  if (r22 = false, n22.steiner || !Xo(n22, n22.next) && 0 !== Ko(n22.prev, n22, n22.next)) n22 = n22.next;
+                  else {
+                    if (el2(n22), n22 = e22 = n22.prev, n22 === n22.next) break;
+                    r22 = true;
+                  }
+                } while (r22 || n22 !== e22);
+                return e22;
+              }
+              function To(t42, e22, r22, n22, i22, s22, a22) {
+                if (!t42) return;
+                !a22 && s22 && function(t5, e3, r3, n3) {
+                  let i3 = t5;
+                  do {
+                    0 === i3.z && (i3.z = qo(i3.x, i3.y, e3, r3, n3)), i3.prevZ = i3.prev, i3.nextZ = i3.next, i3 = i3.next;
+                  } while (i3 !== t5);
+                  i3.prevZ.nextZ = null, i3.prevZ = null, function(t6) {
+                    let e4, r4 = 1;
+                    do {
+                      let n4, i4 = t6;
+                      t6 = null;
+                      let s3 = null;
+                      for (e4 = 0; i4; ) {
+                        e4++;
+                        let a3 = i4, o3 = 0;
+                        for (let t7 = 0; t7 < r4 && (o3++, a3 = a3.nextZ, a3); t7++) ;
+                        let l22 = r4;
+                        for (; o3 > 0 || l22 > 0 && a3; ) 0 !== o3 && (0 === l22 || !a3 || i4.z <= a3.z) ? (n4 = i4, i4 = i4.nextZ, o3--) : (n4 = a3, a3 = a3.nextZ, l22--), s3 ? s3.nextZ = n4 : t6 = n4, n4.prevZ = s3, s3 = n4;
+                        i4 = a3;
+                      }
+                      s3.nextZ = null, r4 *= 2;
+                    } while (e4 > 1);
+                  }(i3);
+                }(t42, n22, i22, s22);
+                let o22 = t42;
+                for (; t42.prev !== t42.next; ) {
+                  const l22 = t42.prev, u22 = t42.next;
+                  if (s22 ? Lo(t42, n22, i22, s22) : $o(t42)) e22.push(l22.i, t42.i, u22.i), el2(t42), t42 = u22.next, o22 = u22.next;
+                  else if ((t42 = u22) === o22) {
+                    a22 ? 1 === a22 ? To(t42 = Do(Fo(t42), e22), e22, r22, n22, i22, s22, 2) : 2 === a22 && Oo(t42, e22, r22, n22, i22, s22) : To(Fo(t42), e22, r22, n22, i22, s22, 1);
+                    break;
+                  }
+                }
+              }
+              function $o(t42) {
+                const e22 = t42.prev, r22 = t42, n22 = t42.next;
+                if (Ko(e22, r22, n22) >= 0) return false;
+                const i22 = e22.x, s22 = r22.x, a22 = n22.x, o22 = e22.y, l22 = r22.y, u22 = n22.y, c22 = i22 < s22 ? i22 < a22 ? i22 : a22 : s22 < a22 ? s22 : a22, h22 = o22 < l22 ? o22 < u22 ? o22 : u22 : l22 < u22 ? l22 : u22, p22 = i22 > s22 ? i22 > a22 ? i22 : a22 : s22 > a22 ? s22 : a22, f22 = o22 > l22 ? o22 > u22 ? o22 : u22 : l22 > u22 ? l22 : u22;
+                let d22 = n22.next;
+                for (; d22 !== e22; ) {
+                  if (d22.x >= c22 && d22.x <= p22 && d22.y >= h22 && d22.y <= f22 && Zo(i22, o22, s22, l22, a22, u22, d22.x, d22.y) && Ko(d22.prev, d22, d22.next) >= 0) return false;
+                  d22 = d22.next;
+                }
+                return true;
+              }
+              function Lo(t42, e22, r22, n22) {
+                const i22 = t42.prev, s22 = t42, a22 = t42.next;
+                if (Ko(i22, s22, a22) >= 0) return false;
+                const o22 = i22.x, l22 = s22.x, u22 = a22.x, c22 = i22.y, h22 = s22.y, p22 = a22.y, f22 = o22 < l22 ? o22 < u22 ? o22 : u22 : l22 < u22 ? l22 : u22, d22 = c22 < h22 ? c22 < p22 ? c22 : p22 : h22 < p22 ? h22 : p22, y22 = o22 > l22 ? o22 > u22 ? o22 : u22 : l22 > u22 ? l22 : u22, m22 = c22 > h22 ? c22 > p22 ? c22 : p22 : h22 > p22 ? h22 : p22, g22 = qo(f22, d22, e22, r22, n22), x22 = qo(y22, m22, e22, r22, n22);
+                let v22 = t42.prevZ, b22 = t42.nextZ;
+                for (; v22 && v22.z >= g22 && b22 && b22.z <= x22; ) {
+                  if (v22.x >= f22 && v22.x <= y22 && v22.y >= d22 && v22.y <= m22 && v22 !== i22 && v22 !== a22 && Zo(o22, c22, l22, h22, u22, p22, v22.x, v22.y) && Ko(v22.prev, v22, v22.next) >= 0) return false;
+                  if (v22 = v22.prevZ, b22.x >= f22 && b22.x <= y22 && b22.y >= d22 && b22.y <= m22 && b22 !== i22 && b22 !== a22 && Zo(o22, c22, l22, h22, u22, p22, b22.x, b22.y) && Ko(b22.prev, b22, b22.next) >= 0) return false;
+                  b22 = b22.nextZ;
+                }
+                for (; v22 && v22.z >= g22; ) {
+                  if (v22.x >= f22 && v22.x <= y22 && v22.y >= d22 && v22.y <= m22 && v22 !== i22 && v22 !== a22 && Zo(o22, c22, l22, h22, u22, p22, v22.x, v22.y) && Ko(v22.prev, v22, v22.next) >= 0) return false;
+                  v22 = v22.prevZ;
+                }
+                for (; b22 && b22.z <= x22; ) {
+                  if (b22.x >= f22 && b22.x <= y22 && b22.y >= d22 && b22.y <= m22 && b22 !== i22 && b22 !== a22 && Zo(o22, c22, l22, h22, u22, p22, b22.x, b22.y) && Ko(b22.prev, b22, b22.next) >= 0) return false;
+                  b22 = b22.nextZ;
+                }
+                return true;
+              }
+              function Do(t42, e22) {
+                let r22 = t42;
+                do {
+                  const n22 = r22.prev, i22 = r22.next.next;
+                  !Xo(n22, i22) && Ho(n22, r22, r22.next, i22) && Wo(n22, i22) && Wo(i22, n22) && (e22.push(n22.i, r22.i, i22.i), el2(r22), el2(r22.next), r22 = t42 = i22), r22 = r22.next;
+                } while (r22 !== t42);
+                return Fo(r22);
+              }
+              function Oo(t42, e22, r22, n22, i22, s22) {
+                let a22 = t42;
+                do {
+                  let t5 = a22.next.next;
+                  for (; t5 !== a22.prev; ) {
+                    if (a22.i !== t5.i && Go(a22, t5)) {
+                      let o22 = Qo(a22, t5);
+                      return a22 = Fo(a22, a22.next), o22 = Fo(o22, o22.next), To(a22, e22, r22, n22, i22, s22, 0), void To(o22, e22, r22, n22, i22, s22, 0);
+                    }
+                    t5 = t5.next;
+                  }
+                  a22 = a22.next;
+                } while (a22 !== t42);
+              }
+              function jo(t42, e22) {
+                return t42.x - e22.x;
+              }
+              function Ro(t42, e22) {
+                const r22 = function(t5, e3) {
+                  let r3 = e3;
+                  const n3 = t5.x, i22 = t5.y;
+                  let s22, a22 = -1 / 0;
+                  do {
+                    if (i22 <= r3.y && i22 >= r3.next.y && r3.next.y !== r3.y) {
+                      const t6 = r3.x + (i22 - r3.y) * (r3.next.x - r3.x) / (r3.next.y - r3.y);
+                      if (t6 <= n3 && t6 > a22 && (a22 = t6, s22 = r3.x < r3.next.x ? r3 : r3.next, t6 === n3)) return s22;
+                    }
+                    r3 = r3.next;
+                  } while (r3 !== e3);
+                  if (!s22) return null;
+                  const o22 = s22, l22 = s22.x, u22 = s22.y;
+                  let c22 = 1 / 0;
+                  r3 = s22;
+                  do {
+                    if (n3 >= r3.x && r3.x >= l22 && n3 !== r3.x && Zo(i22 < u22 ? n3 : a22, i22, l22, u22, i22 < u22 ? a22 : n3, i22, r3.x, r3.y)) {
+                      const e4 = Math.abs(i22 - r3.y) / (n3 - r3.x);
+                      Wo(r3, t5) && (e4 < c22 || e4 === c22 && (r3.x > s22.x || r3.x === s22.x && Uo(s22, r3))) && (s22 = r3, c22 = e4);
+                    }
+                    r3 = r3.next;
+                  } while (r3 !== o22);
+                  return s22;
+                }(t42, e22);
+                if (!r22) return e22;
+                const n22 = Qo(r22, t42);
+                return Fo(n22, n22.next), Fo(r22, r22.next);
+              }
+              function Uo(t42, e22) {
+                return Ko(t42.prev, t42, e22.prev) < 0 && Ko(e22.next, t42, t42.next) < 0;
+              }
+              function qo(t42, e22, r22, n22, i22) {
+                return (t42 = 1431655765 & ((t42 = 858993459 & ((t42 = 252645135 & ((t42 = 16711935 & ((t42 = (t42 - r22) * i22 | 0) | t42 << 8)) | t42 << 4)) | t42 << 2)) | t42 << 1)) | (e22 = 1431655765 & ((e22 = 858993459 & ((e22 = 252645135 & ((e22 = 16711935 & ((e22 = (e22 - n22) * i22 | 0) | e22 << 8)) | e22 << 4)) | e22 << 2)) | e22 << 1)) << 1;
+              }
+              function No(t42) {
+                let e22 = t42, r22 = t42;
+                do {
+                  (e22.x < r22.x || e22.x === r22.x && e22.y < r22.y) && (r22 = e22), e22 = e22.next;
+                } while (e22 !== t42);
+                return r22;
+              }
+              function Zo(t42, e22, r22, n22, i22, s22, a22, o22) {
+                return (i22 - a22) * (e22 - o22) >= (t42 - a22) * (s22 - o22) && (t42 - a22) * (n22 - o22) >= (r22 - a22) * (e22 - o22) && (r22 - a22) * (s22 - o22) >= (i22 - a22) * (n22 - o22);
+              }
+              function Go(t42, e22) {
+                return t42.next.i !== e22.i && t42.prev.i !== e22.i && !function(t5, e3) {
+                  let r22 = t5;
+                  do {
+                    if (r22.i !== t5.i && r22.next.i !== t5.i && r22.i !== e3.i && r22.next.i !== e3.i && Ho(r22, r22.next, t5, e3)) return true;
+                    r22 = r22.next;
+                  } while (r22 !== t5);
+                  return false;
+                }(t42, e22) && (Wo(t42, e22) && Wo(e22, t42) && function(t5, e3) {
+                  let r22 = t5, n22 = false;
+                  const i22 = (t5.x + e3.x) / 2, s22 = (t5.y + e3.y) / 2;
+                  do {
+                    r22.y > s22 != r22.next.y > s22 && r22.next.y !== r22.y && i22 < (r22.next.x - r22.x) * (s22 - r22.y) / (r22.next.y - r22.y) + r22.x && (n22 = !n22), r22 = r22.next;
+                  } while (r22 !== t5);
+                  return n22;
+                }(t42, e22) && (Ko(t42.prev, t42, e22.prev) || Ko(t42, e22.prev, e22)) || Xo(t42, e22) && Ko(t42.prev, t42, t42.next) > 0 && Ko(e22.prev, e22, e22.next) > 0);
+              }
+              function Ko(t42, e22, r22) {
+                return (e22.y - t42.y) * (r22.x - e22.x) - (e22.x - t42.x) * (r22.y - e22.y);
+              }
+              function Xo(t42, e22) {
+                return t42.x === e22.x && t42.y === e22.y;
+              }
+              function Ho(t42, e22, r22, n22) {
+                const i22 = Jo(Ko(t42, e22, r22)), s22 = Jo(Ko(t42, e22, n22)), a22 = Jo(Ko(r22, n22, t42)), o22 = Jo(Ko(r22, n22, e22));
+                return i22 !== s22 && a22 !== o22 || !(0 !== i22 || !Yo(t42, r22, e22)) || !(0 !== s22 || !Yo(t42, n22, e22)) || !(0 !== a22 || !Yo(r22, t42, n22)) || !(0 !== o22 || !Yo(r22, e22, n22));
+              }
+              function Yo(t42, e22, r22) {
+                return e22.x <= Math.max(t42.x, r22.x) && e22.x >= Math.min(t42.x, r22.x) && e22.y <= Math.max(t42.y, r22.y) && e22.y >= Math.min(t42.y, r22.y);
+              }
+              function Jo(t42) {
+                return t42 > 0 ? 1 : t42 < 0 ? -1 : 0;
+              }
+              function Wo(t42, e22) {
+                return Ko(t42.prev, t42, t42.next) < 0 ? Ko(t42, e22, t42.next) >= 0 && Ko(t42, t42.prev, e22) >= 0 : Ko(t42, e22, t42.prev) < 0 || Ko(t42, t42.next, e22) < 0;
+              }
+              function Qo(t42, e22) {
+                const r22 = rl2(t42.i, t42.x, t42.y), n22 = rl2(e22.i, e22.x, e22.y), i22 = t42.next, s22 = e22.prev;
+                return t42.next = e22, e22.prev = t42, r22.next = i22, i22.prev = r22, n22.next = r22, r22.prev = n22, s22.next = n22, n22.prev = s22, n22;
+              }
+              function tl2(t42, e22, r22, n22) {
+                const i22 = rl2(t42, e22, r22);
+                return n22 ? (i22.next = n22.next, i22.prev = n22, n22.next.prev = i22, n22.next = i22) : (i22.prev = i22, i22.next = i22), i22;
+              }
+              function el2(t42) {
+                t42.next.prev = t42.prev, t42.prev.next = t42.next, t42.prevZ && (t42.prevZ.nextZ = t42.nextZ), t42.nextZ && (t42.nextZ.prevZ = t42.prevZ);
+              }
+              function rl2(t42, e22, r22) {
+                return { i: t42, x: e22, y: r22, prev: null, next: null, z: 0, prevZ: null, nextZ: null, steiner: false };
+              }
+              function nl2(t42, e22, r22) {
+                const n22 = r22.patternDependencies;
+                let i22 = false;
+                for (const r3 of e22) {
+                  const e3 = r3.paint.get(`${t42}-pattern`);
+                  e3.isConstant() || (i22 = true);
+                  const s22 = e3.constantOr(null);
+                  s22 && (i22 = true, n22[s22.to] = true, n22[s22.from] = true);
+                }
+                return i22;
+              }
+              function il2(t42, e22, r22, n22, i22) {
+                const s22 = i22.patternDependencies;
+                for (const a22 of e22) {
+                  const e3 = a22.paint.get(`${t42}-pattern`).value;
+                  if ("constant" !== e3.kind) {
+                    let t5 = e3.evaluate({ zoom: n22 - 1 }, r22, {}, i22.availableImages), o22 = e3.evaluate({ zoom: n22 }, r22, {}, i22.availableImages), l22 = e3.evaluate({ zoom: n22 + 1 }, r22, {}, i22.availableImages);
+                    t5 = t5 && t5.name ? t5.name : t5, o22 = o22 && o22.name ? o22.name : o22, l22 = l22 && l22.name ? l22.name : l22, s22[t5] = true, s22[o22] = true, s22[l22] = true, r22.patterns[a22.id] = { min: t5, mid: o22, max: l22 };
+                  }
+                }
+                return r22;
+              }
+              class sl2 {
+                constructor(t42) {
+                  this.zoom = t42.zoom, this.overscaling = t42.overscaling, this.layers = t42.layers, this.layerIds = this.layers.map((t5) => t5.id), this.index = t42.index, this.hasPattern = false, this.patternFeatures = [], this.layoutVertexArray = new Ks(), this.indexArray = new na(), this.indexArray2 = new ia2(), this.programConfigurations = new Ea2(t42.layers, t42.zoom), this.segments = new oa2(), this.segments2 = new oa2(), this.stateDependentLayerIds = this.layers.filter((t5) => t5.isStateDependent()).map((t5) => t5.id);
+                }
+                populate(t42, e22, r22) {
+                  this.hasPattern = nl2("fill", this.layers, e22);
+                  const n22 = this.layers[0].layout.get("fill-sort-key"), i22 = !n22.isConstant(), s22 = [];
+                  for (const { feature: a22, id: o22, index: l22, sourceLayerIndex: u22 } of t42) {
+                    const t5 = this.layers[0]._featureFilter.needGeometry, c22 = ja2(a22, t5);
+                    if (!this.layers[0]._featureFilter.filter(new Ui2(this.zoom), c22, r22)) continue;
+                    const h22 = i22 ? n22.evaluate(c22, {}, r22, e22.availableImages) : void 0, p22 = { id: o22, properties: a22.properties, type: a22.type, sourceLayerIndex: u22, index: l22, geometry: t5 ? c22.geometry : Oa2(a22), patterns: {}, sortKey: h22 };
+                    s22.push(p22);
+                  }
+                  i22 && s22.sort((t5, e3) => t5.sortKey - e3.sortKey);
+                  for (const n3 of s22) {
+                    const { geometry: i3, index: s3, sourceLayerIndex: a22 } = n3;
+                    if (this.hasPattern) {
+                      const t5 = il2("fill", this.layers, n3, this.zoom, e22);
+                      this.patternFeatures.push(t5);
+                    } else this.addFeature(n3, i3, s3, r22, {});
+                    e22.featureIndex.insert(t42[s3].feature, i3, s3, a22, this.index);
+                  }
+                }
+                update(t42, e22, r22) {
+                  this.stateDependentLayers.length && this.programConfigurations.updatePaintArrays(t42, e22, this.stateDependentLayers, r22);
+                }
+                addFeatures(t42, e22, r22) {
+                  for (const t5 of this.patternFeatures) this.addFeature(t5, t5.geometry, t5.index, e22, r22);
+                }
+                isEmpty() {
+                  return 0 === this.layoutVertexArray.length;
+                }
+                uploadPending() {
+                  return !this.uploaded || this.programConfigurations.needsUpload;
+                }
+                upload(t42) {
+                  this.uploaded || (this.layoutVertexBuffer = t42.createVertexBuffer(this.layoutVertexArray, Bo), this.indexBuffer = t42.createIndexBuffer(this.indexArray), this.indexBuffer2 = t42.createIndexBuffer(this.indexArray2)), this.programConfigurations.upload(t42), this.uploaded = true;
+                }
+                destroy() {
+                  this.layoutVertexBuffer && (this.layoutVertexBuffer.destroy(), this.indexBuffer.destroy(), this.indexBuffer2.destroy(), this.programConfigurations.destroy(), this.segments.destroy(), this.segments2.destroy());
+                }
+                addFeature(t42, e22, r22, n22, i22) {
+                  for (const t5 of xr(e22, 500)) {
+                    let e3 = 0;
+                    for (const r4 of t5) e3 += r4.length;
+                    const r3 = this.segments.prepareSegment(e3, this.layoutVertexArray, this.indexArray), n3 = r3.vertexLength, i3 = [], s22 = [];
+                    for (const e4 of t5) {
+                      if (0 === e4.length) continue;
+                      e4 !== t5[0] && s22.push(i3.length / 2);
+                      const r4 = this.segments2.prepareSegment(e4.length, this.layoutVertexArray, this.indexArray2), n4 = r4.vertexLength;
+                      this.layoutVertexArray.emplaceBack(e4[0].x, e4[0].y), this.indexArray2.emplaceBack(n4 + e4.length - 1, n4), i3.push(e4[0].x), i3.push(e4[0].y);
+                      for (let t6 = 1; t6 < e4.length; t6++) this.layoutVertexArray.emplaceBack(e4[t6].x, e4[t6].y), this.indexArray2.emplaceBack(n4 + t6 - 1, n4 + t6), i3.push(e4[t6].x), i3.push(e4[t6].y);
+                      r4.vertexLength += e4.length, r4.primitiveLength += e4.length;
+                    }
+                    const a22 = Vo(i3, s22);
+                    for (let t6 = 0; t6 < a22.length; t6 += 3) this.indexArray.emplaceBack(n3 + a22[t6], n3 + a22[t6 + 1], n3 + a22[t6 + 2]);
+                    r3.vertexLength += e3, r3.primitiveLength += a22.length / 3;
+                  }
+                  this.programConfigurations.populatePaintArrays(this.layoutVertexArray.length, t42, r22, i22, n22);
+                }
+              }
+              let al2, ol2;
+              wi2("FillBucket", sl2, { omit: ["layers", "patternFeatures"] });
+              var ll2 = { get paint() {
+                return ol2 = ol2 || new rs({ "fill-antialias": new Ji2(G2.paint_fill["fill-antialias"]), "fill-opacity": new Wi2(G2.paint_fill["fill-opacity"]), "fill-color": new Wi2(G2.paint_fill["fill-color"]), "fill-outline-color": new Wi2(G2.paint_fill["fill-outline-color"]), "fill-translate": new Ji2(G2.paint_fill["fill-translate"]), "fill-translate-anchor": new Ji2(G2.paint_fill["fill-translate-anchor"]), "fill-pattern": new Qi2(G2.paint_fill["fill-pattern"]) });
+              }, get layout() {
+                return al2 = al2 || new rs({ "fill-sort-key": new Wi2(G2.layout_fill["fill-sort-key"]) });
+              } };
+              class ul2 extends is {
+                constructor(t42) {
+                  super(t42, ll2);
+                }
+                recalculate(t42, e22) {
+                  super.recalculate(t42, e22);
+                  const r22 = this.paint._values["fill-outline-color"];
+                  "constant" === r22.value.kind && void 0 === r22.value.value && (this.paint._values["fill-outline-color"] = this.paint._values["fill-color"]);
+                }
+                createBucket(t42) {
+                  return new sl2(t42);
+                }
+                queryRadius() {
+                  return eo(this.paint.get("fill-translate"));
+                }
+                queryIntersectsFeature(t42, e22, r22, n22, i22, s22, a22) {
+                  return Za2(ro(t42, this.paint.get("fill-translate"), this.paint.get("fill-translate-anchor"), s22.angle, a22), n22);
+                }
+                isTileClipped() {
+                  return true;
+                }
+              }
+              const cl2 = ls([{ name: "a_pos", components: 2, type: "Int16" }, { name: "a_normal_ed", components: 4, type: "Int16" }], 4), hl2 = ls([{ name: "a_centroid", components: 2, type: "Int16" }], 4), { members: pl2 } = cl2;
+              var fl2 = {}, dl2 = n2, yl = ml2;
+              function ml2(t42, e22, r22, n22, i22) {
+                this.properties = {}, this.extent = r22, this.type = 0, this._pbf = t42, this._geometry = -1, this._keys = n22, this._values = i22, t42.readFields(gl2, this, e22);
+              }
+              function gl2(t42, e22, r22) {
+                1 == t42 ? e22.id = r22.readVarint() : 2 == t42 ? function(t5, e3) {
+                  for (var r3 = t5.readVarint() + t5.pos; t5.pos < r3; ) {
+                    var n22 = e3._keys[t5.readVarint()], i22 = e3._values[t5.readVarint()];
+                    e3.properties[n22] = i22;
+                  }
+                }(r22, e22) : 3 == t42 ? e22.type = r22.readVarint() : 4 == t42 && (e22._geometry = r22.pos);
+              }
+              function xl(t42) {
+                for (var e22, r22, n22 = 0, i22 = 0, s22 = t42.length, a22 = s22 - 1; i22 < s22; a22 = i22++) n22 += ((r22 = t42[a22]).x - (e22 = t42[i22]).x) * (e22.y + r22.y);
+                return n22;
+              }
+              ml2.types = ["Unknown", "Point", "LineString", "Polygon"], ml2.prototype.loadGeometry = function() {
+                var t42 = this._pbf;
+                t42.pos = this._geometry;
+                for (var e22, r22 = t42.readVarint() + t42.pos, n22 = 1, i22 = 0, s22 = 0, a22 = 0, o22 = []; t42.pos < r22; ) {
+                  if (i22 <= 0) {
+                    var l22 = t42.readVarint();
+                    n22 = 7 & l22, i22 = l22 >> 3;
+                  }
+                  if (i22--, 1 === n22 || 2 === n22) s22 += t42.readSVarint(), a22 += t42.readSVarint(), 1 === n22 && (e22 && o22.push(e22), e22 = []), e22.push(new dl2(s22, a22));
+                  else {
+                    if (7 !== n22) throw new Error("unknown command " + n22);
+                    e22 && e22.push(e22[0].clone());
+                  }
+                }
+                return e22 && o22.push(e22), o22;
+              }, ml2.prototype.bbox = function() {
+                var t42 = this._pbf;
+                t42.pos = this._geometry;
+                for (var e22 = t42.readVarint() + t42.pos, r22 = 1, n22 = 0, i22 = 0, s22 = 0, a22 = 1 / 0, o22 = -1 / 0, l22 = 1 / 0, u22 = -1 / 0; t42.pos < e22; ) {
+                  if (n22 <= 0) {
+                    var c22 = t42.readVarint();
+                    r22 = 7 & c22, n22 = c22 >> 3;
+                  }
+                  if (n22--, 1 === r22 || 2 === r22) (i22 += t42.readSVarint()) < a22 && (a22 = i22), i22 > o22 && (o22 = i22), (s22 += t42.readSVarint()) < l22 && (l22 = s22), s22 > u22 && (u22 = s22);
+                  else if (7 !== r22) throw new Error("unknown command " + r22);
+                }
+                return [a22, l22, o22, u22];
+              }, ml2.prototype.toGeoJSON = function(t42, e22, r22) {
+                var n22, i22, s22 = this.extent * Math.pow(2, r22), a22 = this.extent * t42, o22 = this.extent * e22, l22 = this.loadGeometry(), u22 = ml2.types[this.type];
+                function c22(t5) {
+                  for (var e3 = 0; e3 < t5.length; e3++) {
+                    var r3 = t5[e3];
+                    t5[e3] = [360 * (r3.x + a22) / s22 - 180, 360 / Math.PI * Math.atan(Math.exp((180 - 360 * (r3.y + o22) / s22) * Math.PI / 180)) - 90];
+                  }
+                }
+                switch (this.type) {
+                  case 1:
+                    var h22 = [];
+                    for (n22 = 0; n22 < l22.length; n22++) h22[n22] = l22[n22][0];
+                    c22(l22 = h22);
+                    break;
+                  case 2:
+                    for (n22 = 0; n22 < l22.length; n22++) c22(l22[n22]);
+                    break;
+                  case 3:
+                    for (l22 = function(t5) {
+                      var e3 = t5.length;
+                      if (e3 <= 1) return [t5];
+                      for (var r3, n3, i3 = [], s3 = 0; s3 < e3; s3++) {
+                        var a3 = xl(t5[s3]);
+                        0 !== a3 && (void 0 === n3 && (n3 = a3 < 0), n3 === a3 < 0 ? (r3 && i3.push(r3), r3 = [t5[s3]]) : r3.push(t5[s3]));
+                      }
+                      return r3 && i3.push(r3), i3;
+                    }(l22), n22 = 0; n22 < l22.length; n22++) for (i22 = 0; i22 < l22[n22].length; i22++) c22(l22[n22][i22]);
+                }
+                1 === l22.length ? l22 = l22[0] : u22 = "Multi" + u22;
+                var p22 = { type: "Feature", geometry: { type: u22, coordinates: l22 }, properties: this.properties };
+                return "id" in this && (p22.id = this.id), p22;
+              };
+              var vl = yl, bl2 = wl;
+              function wl(t42, e22) {
+                this.version = 1, this.name = null, this.extent = 4096, this.length = 0, this._pbf = t42, this._keys = [], this._values = [], this._features = [], t42.readFields(_l2, this, e22), this.length = this._features.length;
+              }
+              function _l2(t42, e22, r22) {
+                15 === t42 ? e22.version = r22.readVarint() : 1 === t42 ? e22.name = r22.readString() : 5 === t42 ? e22.extent = r22.readVarint() : 2 === t42 ? e22._features.push(r22.pos) : 3 === t42 ? e22._keys.push(r22.readString()) : 4 === t42 && e22._values.push(function(t5) {
+                  for (var e3 = null, r3 = t5.readVarint() + t5.pos; t5.pos < r3; ) {
+                    var n22 = t5.readVarint() >> 3;
+                    e3 = 1 === n22 ? t5.readString() : 2 === n22 ? t5.readFloat() : 3 === n22 ? t5.readDouble() : 4 === n22 ? t5.readVarint64() : 5 === n22 ? t5.readVarint() : 6 === n22 ? t5.readSVarint() : 7 === n22 ? t5.readBoolean() : null;
+                  }
+                  return e3;
+                }(r22));
+              }
+              wl.prototype.feature = function(t42) {
+                if (t42 < 0 || t42 >= this._features.length) throw new Error("feature index out of bounds");
+                this._pbf.pos = this._features[t42];
+                var e22 = this._pbf.readVarint() + this._pbf.pos;
+                return new vl(this._pbf, e22, this.extent, this._keys, this._values);
+              };
+              var Al = bl2;
+              function Sl(t42, e22, r22) {
+                if (3 === t42) {
+                  var n22 = new Al(r22, r22.readVarint() + r22.pos);
+                  n22.length && (e22[n22.name] = n22);
+                }
+              }
+              fl2.VectorTile = function(t42, e22) {
+                this.layers = t42.readFields(Sl, {}, e22);
+              }, fl2.VectorTileFeature = yl, fl2.VectorTileLayer = bl2;
+              const kl2 = fl2.VectorTileFeature.types, Ml = Math.pow(2, 13);
+              function Il(t42, e22, r22, n22, i22, s22, a22, o22) {
+                t42.emplaceBack(e22, r22, 2 * Math.floor(n22 * Ml) + a22, i22 * Ml * 2, s22 * Ml * 2, Math.round(o22));
+              }
+              class zl {
+                constructor(t42) {
+                  this.zoom = t42.zoom, this.overscaling = t42.overscaling, this.layers = t42.layers, this.layerIds = this.layers.map((t5) => t5.id), this.index = t42.index, this.hasPattern = false, this.layoutVertexArray = new Xs(), this.centroidVertexArray = new Zs(), this.indexArray = new na(), this.programConfigurations = new Ea2(t42.layers, t42.zoom), this.segments = new oa2(), this.stateDependentLayerIds = this.layers.filter((t5) => t5.isStateDependent()).map((t5) => t5.id);
+                }
+                populate(t42, e22, r22) {
+                  this.features = [], this.hasPattern = nl2("fill-extrusion", this.layers, e22);
+                  for (const { feature: n22, id: i22, index: s22, sourceLayerIndex: a22 } of t42) {
+                    const t5 = this.layers[0]._featureFilter.needGeometry, o22 = ja2(n22, t5);
+                    if (!this.layers[0]._featureFilter.filter(new Ui2(this.zoom), o22, r22)) continue;
+                    const l22 = { id: i22, sourceLayerIndex: a22, index: s22, geometry: t5 ? o22.geometry : Oa2(n22), properties: n22.properties, type: n22.type, patterns: {} };
+                    this.hasPattern ? this.features.push(il2("fill-extrusion", this.layers, l22, this.zoom, e22)) : this.addFeature(l22, l22.geometry, s22, r22, {}), e22.featureIndex.insert(n22, l22.geometry, s22, a22, this.index, true);
+                  }
+                }
+                addFeatures(t42, e22, r22) {
+                  for (const t5 of this.features) {
+                    const { geometry: n22 } = t5;
+                    this.addFeature(t5, n22, t5.index, e22, r22);
+                  }
+                }
+                update(t42, e22, r22) {
+                  this.stateDependentLayers.length && this.programConfigurations.updatePaintArrays(t42, e22, this.stateDependentLayers, r22);
+                }
+                isEmpty() {
+                  return 0 === this.layoutVertexArray.length && 0 === this.centroidVertexArray.length;
+                }
+                uploadPending() {
+                  return !this.uploaded || this.programConfigurations.needsUpload;
+                }
+                upload(t42) {
+                  this.uploaded || (this.layoutVertexBuffer = t42.createVertexBuffer(this.layoutVertexArray, pl2), this.centroidVertexBuffer = t42.createVertexBuffer(this.centroidVertexArray, hl2.members, true), this.indexBuffer = t42.createIndexBuffer(this.indexArray)), this.programConfigurations.upload(t42), this.uploaded = true;
+                }
+                destroy() {
+                  this.layoutVertexBuffer && (this.layoutVertexBuffer.destroy(), this.indexBuffer.destroy(), this.programConfigurations.destroy(), this.segments.destroy(), this.centroidVertexBuffer.destroy());
+                }
+                addFeature(t42, e22, r22, n22, i22) {
+                  for (const r3 of xr(e22, 500)) {
+                    const e3 = { x: 0, y: 0, vertexCount: 0 };
+                    let n3 = 0;
+                    for (const t5 of r3) n3 += t5.length;
+                    let i3 = this.segments.prepareSegment(4, this.layoutVertexArray, this.indexArray);
+                    for (const t5 of r3) {
+                      if (0 === t5.length) continue;
+                      if (Cl(t5)) continue;
+                      let r4 = 0;
+                      for (let n4 = 0; n4 < t5.length; n4++) {
+                        const s3 = t5[n4];
+                        if (n4 >= 1) {
+                          const a3 = t5[n4 - 1];
+                          if (!Pl(s3, a3)) {
+                            i3.vertexLength + 4 > oa2.MAX_VERTEX_ARRAY_LENGTH && (i3 = this.segments.prepareSegment(4, this.layoutVertexArray, this.indexArray));
+                            const t6 = s3.sub(a3)._perp()._unit(), n5 = a3.dist(s3);
+                            r4 + n5 > 32768 && (r4 = 0), Il(this.layoutVertexArray, s3.x, s3.y, t6.x, t6.y, 0, 0, r4), Il(this.layoutVertexArray, s3.x, s3.y, t6.x, t6.y, 0, 1, r4), e3.x += 2 * s3.x, e3.y += 2 * s3.y, e3.vertexCount += 2, r4 += n5, Il(this.layoutVertexArray, a3.x, a3.y, t6.x, t6.y, 0, 0, r4), Il(this.layoutVertexArray, a3.x, a3.y, t6.x, t6.y, 0, 1, r4), e3.x += 2 * a3.x, e3.y += 2 * a3.y, e3.vertexCount += 2;
+                            const o3 = i3.vertexLength;
+                            this.indexArray.emplaceBack(o3, o3 + 2, o3 + 1), this.indexArray.emplaceBack(o3 + 1, o3 + 2, o3 + 3), i3.vertexLength += 4, i3.primitiveLength += 2;
+                          }
+                        }
+                      }
+                    }
+                    if (i3.vertexLength + n3 > oa2.MAX_VERTEX_ARRAY_LENGTH && (i3 = this.segments.prepareSegment(n3, this.layoutVertexArray, this.indexArray)), "Polygon" !== kl2[t42.type]) continue;
+                    const s22 = [], a22 = [], o22 = i3.vertexLength;
+                    for (const t5 of r3) if (0 !== t5.length) {
+                      t5 !== r3[0] && a22.push(s22.length / 2);
+                      for (let r4 = 0; r4 < t5.length; r4++) {
+                        const n4 = t5[r4];
+                        Il(this.layoutVertexArray, n4.x, n4.y, 0, 0, 1, 1, 0), e3.x += n4.x, e3.y += n4.y, e3.vertexCount += 1, s22.push(n4.x), s22.push(n4.y);
+                      }
+                    }
+                    const l22 = Vo(s22, a22);
+                    for (let t5 = 0; t5 < l22.length; t5 += 3) this.indexArray.emplaceBack(o22 + l22[t5], o22 + l22[t5 + 2], o22 + l22[t5 + 1]);
+                    i3.primitiveLength += l22.length / 3, i3.vertexLength += n3;
+                    for (let t5 = 0; t5 < e3.vertexCount; t5++) {
+                      const t6 = Math.floor(e3.x / e3.vertexCount), r4 = Math.floor(e3.y / e3.vertexCount);
+                      this.centroidVertexArray.emplaceBack(t6, r4);
+                    }
+                  }
+                  this.programConfigurations.populatePaintArrays(this.layoutVertexArray.length, t42, r22, i22, n22);
+                }
+              }
+              function Pl(t42, e22) {
+                return t42.x === e22.x && (t42.x < 0 || t42.x > $a) || t42.y === e22.y && (t42.y < 0 || t42.y > $a);
+              }
+              function Cl(t42) {
+                return t42.every((t5) => t5.x < 0) || t42.every((t5) => t5.x > $a) || t42.every((t5) => t5.y < 0) || t42.every((t5) => t5.y > $a);
+              }
+              let Bl;
+              wi2("FillExtrusionBucket", zl, { omit: ["layers", "features"] });
+              var Vl = { get paint() {
+                return Bl = Bl || new rs({ "fill-extrusion-opacity": new Ji2(G2["paint_fill-extrusion"]["fill-extrusion-opacity"]), "fill-extrusion-color": new Wi2(G2["paint_fill-extrusion"]["fill-extrusion-color"]), "fill-extrusion-translate": new Ji2(G2["paint_fill-extrusion"]["fill-extrusion-translate"]), "fill-extrusion-translate-anchor": new Ji2(G2["paint_fill-extrusion"]["fill-extrusion-translate-anchor"]), "fill-extrusion-pattern": new Qi2(G2["paint_fill-extrusion"]["fill-extrusion-pattern"]), "fill-extrusion-height": new Wi2(G2["paint_fill-extrusion"]["fill-extrusion-height"]), "fill-extrusion-base": new Wi2(G2["paint_fill-extrusion"]["fill-extrusion-base"]), "fill-extrusion-vertical-gradient": new Ji2(G2["paint_fill-extrusion"]["fill-extrusion-vertical-gradient"]) });
+              } };
+              class El extends is {
+                constructor(t42) {
+                  super(t42, Vl);
+                }
+                createBucket(t42) {
+                  return new zl(t42);
+                }
+                queryRadius() {
+                  return eo(this.paint.get("fill-extrusion-translate"));
+                }
+                is3D() {
+                  return true;
+                }
+                queryIntersectsFeature(t42, e22, r22, n22, i22, a22, o22, l22) {
+                  const u22 = ro(t42, this.paint.get("fill-extrusion-translate"), this.paint.get("fill-extrusion-translate-anchor"), a22.angle, o22), c22 = this.paint.get("fill-extrusion-height").evaluate(e22, r22), h22 = this.paint.get("fill-extrusion-base").evaluate(e22, r22), p22 = function(t5, e3, r3, n3) {
+                    const i3 = [];
+                    for (const r4 of t5) {
+                      const t6 = [r4.x, r4.y, 0, 1];
+                      po(t6, t6, e3), i3.push(new s2(t6[0] / t6[3], t6[1] / t6[3]));
+                    }
+                    return i3;
+                  }(u22, l22), f22 = function(t5, e3, r3, n3) {
+                    const i3 = [], a3 = [], o3 = n3[8] * e3, l3 = n3[9] * e3, u3 = n3[10] * e3, c3 = n3[11] * e3, h3 = n3[8] * r3, p3 = n3[9] * r3, f3 = n3[10] * r3, d22 = n3[11] * r3;
+                    for (const e4 of t5) {
+                      const t6 = [], r4 = [];
+                      for (const i4 of e4) {
+                        const e5 = i4.x, a4 = i4.y, y22 = n3[0] * e5 + n3[4] * a4 + n3[12], m22 = n3[1] * e5 + n3[5] * a4 + n3[13], g22 = n3[2] * e5 + n3[6] * a4 + n3[14], x22 = n3[3] * e5 + n3[7] * a4 + n3[15], v22 = g22 + u3, b22 = x22 + c3, w22 = y22 + h3, _22 = m22 + p3, A3 = g22 + f3, S22 = x22 + d22, k22 = new s2((y22 + o3) / b22, (m22 + l3) / b22);
+                        k22.z = v22 / b22, t6.push(k22);
+                        const M22 = new s2(w22 / S22, _22 / S22);
+                        M22.z = A3 / S22, r4.push(M22);
+                      }
+                      i3.push(t6), a3.push(r4);
+                    }
+                    return [i3, a3];
+                  }(n22, h22, c22, l22);
+                  return function(t5, e3, r3) {
+                    let n3 = 1 / 0;
+                    Za2(r3, e3) && (n3 = Tl(r3, e3[0]));
+                    for (let i3 = 0; i3 < e3.length; i3++) {
+                      const s22 = e3[i3], a3 = t5[i3];
+                      for (let t6 = 0; t6 < s22.length - 1; t6++) {
+                        const e4 = s22[t6], i4 = [e4, s22[t6 + 1], a3[t6 + 1], a3[t6], e4];
+                        qa2(r3, i4) && (n3 = Math.min(n3, Tl(r3, i4)));
+                      }
+                    }
+                    return n3 !== 1 / 0 && n3;
+                  }(f22[0], f22[1], p22);
+                }
+              }
+              function Fl(t42, e22) {
+                return t42.x * e22.x + t42.y * e22.y;
+              }
+              function Tl(t42, e22) {
+                if (1 === t42.length) {
+                  let r22 = 0;
+                  const n22 = e22[r22++];
+                  let i22;
+                  for (; !i22 || n22.equals(i22); ) if (i22 = e22[r22++], !i22) return 1 / 0;
+                  for (; r22 < e22.length; r22++) {
+                    const s22 = e22[r22], a22 = t42[0], o22 = i22.sub(n22), l22 = s22.sub(n22), u22 = a22.sub(n22), c22 = Fl(o22, o22), h22 = Fl(o22, l22), p22 = Fl(l22, l22), f22 = Fl(u22, o22), d22 = Fl(u22, l22), y22 = c22 * p22 - h22 * h22, m22 = (p22 * f22 - h22 * d22) / y22, g22 = (c22 * d22 - h22 * f22) / y22, x22 = n22.z * (1 - m22 - g22) + i22.z * m22 + s22.z * g22;
+                    if (isFinite(x22)) return x22;
+                  }
+                  return 1 / 0;
+                }
+                {
+                  let t5 = 1 / 0;
+                  for (const r22 of e22) t5 = Math.min(t5, r22.z);
+                  return t5;
+                }
+              }
+              const $l = ls([{ name: "a_pos_normal", components: 2, type: "Int16" }, { name: "a_data", components: 4, type: "Uint8" }], 4), { members: Ll } = $l, Dl = ls([{ name: "a_uv_x", components: 1, type: "Float32" }, { name: "a_split_index", components: 1, type: "Float32" }]), { members: Ol } = Dl, jl2 = fl2.VectorTileFeature.types, Rl = Math.cos(Math.PI / 180 * 37.5), Ul = Math.pow(2, 14) / 0.5;
+              class ql2 {
+                constructor(t42) {
+                  this.zoom = t42.zoom, this.overscaling = t42.overscaling, this.layers = t42.layers, this.layerIds = this.layers.map((t5) => t5.id), this.index = t42.index, this.hasPattern = false, this.patternFeatures = [], this.lineClipsArray = [], this.gradients = {}, this.layers.forEach((t5) => {
+                    this.gradients[t5.id] = {};
+                  }), this.layoutVertexArray = new Hs(), this.layoutVertexArray2 = new Ys(), this.indexArray = new na(), this.programConfigurations = new Ea2(t42.layers, t42.zoom), this.segments = new oa2(), this.maxLineLength = 0, this.stateDependentLayerIds = this.layers.filter((t5) => t5.isStateDependent()).map((t5) => t5.id);
+                }
+                populate(t42, e22, r22) {
+                  this.hasPattern = nl2("line", this.layers, e22);
+                  const n22 = this.layers[0].layout.get("line-sort-key"), i22 = !n22.isConstant(), s22 = [];
+                  for (const { feature: e3, id: a22, index: o22, sourceLayerIndex: l22 } of t42) {
+                    const t5 = this.layers[0]._featureFilter.needGeometry, u22 = ja2(e3, t5);
+                    if (!this.layers[0]._featureFilter.filter(new Ui2(this.zoom), u22, r22)) continue;
+                    const c22 = i22 ? n22.evaluate(u22, {}, r22) : void 0, h22 = { id: a22, properties: e3.properties, type: e3.type, sourceLayerIndex: l22, index: o22, geometry: t5 ? u22.geometry : Oa2(e3), patterns: {}, sortKey: c22 };
+                    s22.push(h22);
+                  }
+                  i22 && s22.sort((t5, e3) => t5.sortKey - e3.sortKey);
+                  for (const n3 of s22) {
+                    const { geometry: i3, index: s3, sourceLayerIndex: a22 } = n3;
+                    if (this.hasPattern) {
+                      const t5 = il2("line", this.layers, n3, this.zoom, e22);
+                      this.patternFeatures.push(t5);
+                    } else this.addFeature(n3, i3, s3, r22, {});
+                    e22.featureIndex.insert(t42[s3].feature, i3, s3, a22, this.index);
+                  }
+                }
+                update(t42, e22, r22) {
+                  this.stateDependentLayers.length && this.programConfigurations.updatePaintArrays(t42, e22, this.stateDependentLayers, r22);
+                }
+                addFeatures(t42, e22, r22) {
+                  for (const t5 of this.patternFeatures) this.addFeature(t5, t5.geometry, t5.index, e22, r22);
+                }
+                isEmpty() {
+                  return 0 === this.layoutVertexArray.length;
+                }
+                uploadPending() {
+                  return !this.uploaded || this.programConfigurations.needsUpload;
+                }
+                upload(t42) {
+                  this.uploaded || (0 !== this.layoutVertexArray2.length && (this.layoutVertexBuffer2 = t42.createVertexBuffer(this.layoutVertexArray2, Ol)), this.layoutVertexBuffer = t42.createVertexBuffer(this.layoutVertexArray, Ll), this.indexBuffer = t42.createIndexBuffer(this.indexArray)), this.programConfigurations.upload(t42), this.uploaded = true;
+                }
+                destroy() {
+                  this.layoutVertexBuffer && (this.layoutVertexBuffer.destroy(), this.indexBuffer.destroy(), this.programConfigurations.destroy(), this.segments.destroy());
+                }
+                lineFeatureClips(t42) {
+                  if (t42.properties && Object.prototype.hasOwnProperty.call(t42.properties, "mapbox_clip_start") && Object.prototype.hasOwnProperty.call(t42.properties, "mapbox_clip_end")) return { start: +t42.properties.mapbox_clip_start, end: +t42.properties.mapbox_clip_end };
+                }
+                addFeature(t42, e22, r22, n22, i22) {
+                  const s22 = this.layers[0].layout, a22 = s22.get("line-join").evaluate(t42, {}), o22 = s22.get("line-cap"), l22 = s22.get("line-miter-limit"), u22 = s22.get("line-round-limit");
+                  this.lineClips = this.lineFeatureClips(t42);
+                  for (const r3 of e22) this.addLine(r3, t42, a22, o22, l22, u22);
+                  this.programConfigurations.populatePaintArrays(this.layoutVertexArray.length, t42, r22, i22, n22);
+                }
+                addLine(t42, e22, r22, n22, i22, s22) {
+                  if (this.distance = 0, this.scaledDistance = 0, this.totalDistance = 0, this.lineClips) {
+                    this.lineClipsArray.push(this.lineClips);
+                    for (let e3 = 0; e3 < t42.length - 1; e3++) this.totalDistance += t42[e3].dist(t42[e3 + 1]);
+                    this.updateScaledDistance(), this.maxLineLength = Math.max(this.maxLineLength, this.totalDistance);
+                  }
+                  const a22 = "Polygon" === jl2[e22.type];
+                  let o22 = t42.length;
+                  for (; o22 >= 2 && t42[o22 - 1].equals(t42[o22 - 2]); ) o22--;
+                  let l22 = 0;
+                  for (; l22 < o22 - 1 && t42[l22].equals(t42[l22 + 1]); ) l22++;
+                  if (o22 < (a22 ? 3 : 2)) return;
+                  "bevel" === r22 && (i22 = 1.05);
+                  const u22 = this.overscaling <= 16 ? 15 * $a / (512 * this.overscaling) : 0, c22 = this.segments.prepareSegment(10 * o22, this.layoutVertexArray, this.indexArray);
+                  let h22, p22, f22, d22, y22;
+                  this.e1 = this.e2 = -1, a22 && (h22 = t42[o22 - 2], y22 = t42[l22].sub(h22)._unit()._perp());
+                  for (let e3 = l22; e3 < o22; e3++) {
+                    if (f22 = e3 === o22 - 1 ? a22 ? t42[l22 + 1] : void 0 : t42[e3 + 1], f22 && t42[e3].equals(f22)) continue;
+                    y22 && (d22 = y22), h22 && (p22 = h22), h22 = t42[e3], y22 = f22 ? f22.sub(h22)._unit()._perp() : d22, d22 = d22 || y22;
+                    let m22 = d22.add(y22);
+                    0 === m22.x && 0 === m22.y || m22._unit();
+                    const g22 = d22.x * y22.x + d22.y * y22.y, x22 = m22.x * y22.x + m22.y * y22.y, v22 = 0 !== x22 ? 1 / x22 : 1 / 0, b22 = 2 * Math.sqrt(2 - 2 * x22), w22 = x22 < Rl && p22 && f22, _22 = d22.x * y22.y - d22.y * y22.x > 0;
+                    if (w22 && e3 > l22) {
+                      const t5 = h22.dist(p22);
+                      if (t5 > 2 * u22) {
+                        const e4 = h22.sub(h22.sub(p22)._mult(u22 / t5)._round());
+                        this.updateDistance(p22, e4), this.addCurrentVertex(e4, d22, 0, 0, c22), p22 = e4;
+                      }
+                    }
+                    const A3 = p22 && f22;
+                    let S22 = A3 ? r22 : a22 ? "butt" : n22;
+                    if (A3 && "round" === S22 && (v22 < s22 ? S22 = "miter" : v22 <= 2 && (S22 = "fakeround")), "miter" === S22 && v22 > i22 && (S22 = "bevel"), "bevel" === S22 && (v22 > 2 && (S22 = "flipbevel"), v22 < i22 && (S22 = "miter")), p22 && this.updateDistance(p22, h22), "miter" === S22) m22._mult(v22), this.addCurrentVertex(h22, m22, 0, 0, c22);
+                    else if ("flipbevel" === S22) {
+                      if (v22 > 100) m22 = y22.mult(-1);
+                      else {
+                        const t5 = v22 * d22.add(y22).mag() / d22.sub(y22).mag();
+                        m22._perp()._mult(t5 * (_22 ? -1 : 1));
+                      }
+                      this.addCurrentVertex(h22, m22, 0, 0, c22), this.addCurrentVertex(h22, m22.mult(-1), 0, 0, c22);
+                    } else if ("bevel" === S22 || "fakeround" === S22) {
+                      const t5 = -Math.sqrt(v22 * v22 - 1), e4 = _22 ? t5 : 0, r3 = _22 ? 0 : t5;
+                      if (p22 && this.addCurrentVertex(h22, d22, e4, r3, c22), "fakeround" === S22) {
+                        const t6 = Math.round(180 * b22 / Math.PI / 20);
+                        for (let e5 = 1; e5 < t6; e5++) {
+                          let r4 = e5 / t6;
+                          if (0.5 !== r4) {
+                            const t7 = r4 - 0.5;
+                            r4 += r4 * t7 * (r4 - 1) * ((1.0904 + g22 * (g22 * (3.55645 - 1.43519 * g22) - 3.2452)) * t7 * t7 + (0.848013 + g22 * (0.215638 * g22 - 1.06021)));
+                          }
+                          const n3 = y22.sub(d22)._mult(r4)._add(d22)._unit()._mult(_22 ? -1 : 1);
+                          this.addHalfVertex(h22, n3.x, n3.y, false, _22, 0, c22);
+                        }
+                      }
+                      f22 && this.addCurrentVertex(h22, y22, -e4, -r3, c22);
+                    } else if ("butt" === S22) this.addCurrentVertex(h22, m22, 0, 0, c22);
+                    else if ("square" === S22) {
+                      const t5 = p22 ? 1 : -1;
+                      this.addCurrentVertex(h22, m22, t5, t5, c22);
+                    } else "round" === S22 && (p22 && (this.addCurrentVertex(h22, d22, 0, 0, c22), this.addCurrentVertex(h22, d22, 1, 1, c22, true)), f22 && (this.addCurrentVertex(h22, y22, -1, -1, c22, true), this.addCurrentVertex(h22, y22, 0, 0, c22)));
+                    if (w22 && e3 < o22 - 1) {
+                      const t5 = h22.dist(f22);
+                      if (t5 > 2 * u22) {
+                        const e4 = h22.add(f22.sub(h22)._mult(u22 / t5)._round());
+                        this.updateDistance(h22, e4), this.addCurrentVertex(e4, y22, 0, 0, c22), h22 = e4;
+                      }
+                    }
+                  }
+                }
+                addCurrentVertex(t42, e22, r22, n22, i22, s22 = false) {
+                  const a22 = e22.y * n22 - e22.x, o22 = -e22.y - e22.x * n22;
+                  this.addHalfVertex(t42, e22.x + e22.y * r22, e22.y - e22.x * r22, s22, false, r22, i22), this.addHalfVertex(t42, a22, o22, s22, true, -n22, i22), this.distance > Ul / 2 && 0 === this.totalDistance && (this.distance = 0, this.updateScaledDistance(), this.addCurrentVertex(t42, e22, r22, n22, i22, s22));
+                }
+                addHalfVertex({ x: t42, y: e22 }, r22, n22, i22, s22, a22, o22) {
+                  const l22 = 0.5 * (this.lineClips ? this.scaledDistance * (Ul - 1) : this.scaledDistance);
+                  this.layoutVertexArray.emplaceBack((t42 << 1) + (i22 ? 1 : 0), (e22 << 1) + (s22 ? 1 : 0), Math.round(63 * r22) + 128, Math.round(63 * n22) + 128, 1 + (0 === a22 ? 0 : a22 < 0 ? -1 : 1) | (63 & l22) << 2, l22 >> 6), this.lineClips && this.layoutVertexArray2.emplaceBack((this.scaledDistance - this.lineClips.start) / (this.lineClips.end - this.lineClips.start), this.lineClipsArray.length);
+                  const u22 = o22.vertexLength++;
+                  this.e1 >= 0 && this.e2 >= 0 && (this.indexArray.emplaceBack(this.e1, this.e2, u22), o22.primitiveLength++), s22 ? this.e2 = u22 : this.e1 = u22;
+                }
+                updateScaledDistance() {
+                  this.scaledDistance = this.lineClips ? this.lineClips.start + (this.lineClips.end - this.lineClips.start) * this.distance / this.totalDistance : this.distance;
+                }
+                updateDistance(t42, e22) {
+                  this.distance += t42.dist(e22), this.updateScaledDistance();
+                }
+              }
+              let Nl, Zl;
+              wi2("LineBucket", ql2, { omit: ["layers", "patternFeatures"] });
+              var Gl = { get paint() {
+                return Zl = Zl || new rs({ "line-opacity": new Wi2(G2.paint_line["line-opacity"]), "line-color": new Wi2(G2.paint_line["line-color"]), "line-translate": new Ji2(G2.paint_line["line-translate"]), "line-translate-anchor": new Ji2(G2.paint_line["line-translate-anchor"]), "line-width": new Wi2(G2.paint_line["line-width"]), "line-gap-width": new Wi2(G2.paint_line["line-gap-width"]), "line-offset": new Wi2(G2.paint_line["line-offset"]), "line-blur": new Wi2(G2.paint_line["line-blur"]), "line-dasharray": new ts(G2.paint_line["line-dasharray"]), "line-pattern": new Qi2(G2.paint_line["line-pattern"]), "line-gradient": new es(G2.paint_line["line-gradient"]) });
+              }, get layout() {
+                return Nl = Nl || new rs({ "line-cap": new Ji2(G2.layout_line["line-cap"]), "line-join": new Wi2(G2.layout_line["line-join"]), "line-miter-limit": new Ji2(G2.layout_line["line-miter-limit"]), "line-round-limit": new Ji2(G2.layout_line["line-round-limit"]), "line-sort-key": new Wi2(G2.layout_line["line-sort-key"]) });
+              } };
+              class Kl extends Wi2 {
+                possiblyEvaluate(t42, e22) {
+                  return e22 = new Ui2(Math.floor(e22.zoom), { now: e22.now, fadeDuration: e22.fadeDuration, zoomHistory: e22.zoomHistory, transition: e22.transition }), super.possiblyEvaluate(t42, e22);
+                }
+                evaluate(t42, e22, r22, n22) {
+                  return e22 = g2({}, e22, { zoom: Math.floor(e22.zoom) }), super.evaluate(t42, e22, r22, n22);
+                }
+              }
+              let Xl;
+              class Hl extends is {
+                constructor(t42) {
+                  super(t42, Gl), this.gradientVersion = 0, Xl || (Xl = new Kl(Gl.paint.properties["line-width"].specification), Xl.useIntegerZoom = true);
+                }
+                _handleSpecialPaintPropertyUpdate(t42) {
+                  if ("line-gradient" === t42) {
+                    const t5 = this.gradientExpression();
+                    this.stepInterpolant = !!function(t6) {
+                      return void 0 !== t6._styleExpression;
+                    }(t5) && t5._styleExpression.expression instanceof Ae2, this.gradientVersion = (this.gradientVersion + 1) % Number.MAX_SAFE_INTEGER;
+                  }
+                }
+                gradientExpression() {
+                  return this._transitionablePaint._values["line-gradient"].value.expression;
+                }
+                recalculate(t42, e22) {
+                  super.recalculate(t42, e22), this.paint._values["line-floorwidth"] = Xl.possiblyEvaluate(this._transitioningPaint._values["line-width"].value, t42);
+                }
+                createBucket(t42) {
+                  return new ql2(t42);
+                }
+                queryRadius(t42) {
+                  const e22 = t42, r22 = Yl(to("line-width", this, e22), to("line-gap-width", this, e22)), n22 = to("line-offset", this, e22);
+                  return r22 / 2 + Math.abs(n22) + eo(this.paint.get("line-translate"));
+                }
+                queryIntersectsFeature(t42, e22, r22, n22, i22, a22, o22) {
+                  const l22 = ro(t42, this.paint.get("line-translate"), this.paint.get("line-translate-anchor"), a22.angle, o22), u22 = o22 / 2 * Yl(this.paint.get("line-width").evaluate(e22, r22), this.paint.get("line-gap-width").evaluate(e22, r22)), c22 = this.paint.get("line-offset").evaluate(e22, r22);
+                  return c22 && (n22 = function(t5, e3) {
+                    const r3 = [];
+                    for (let n3 = 0; n3 < t5.length; n3++) {
+                      const i3 = t5[n3], a3 = [];
+                      for (let t6 = 0; t6 < i3.length; t6++) {
+                        const r4 = i3[t6 - 1], n4 = i3[t6], o3 = i3[t6 + 1], l3 = 0 === t6 ? new s2(0, 0) : n4.sub(r4)._unit()._perp(), u3 = t6 === i3.length - 1 ? new s2(0, 0) : o3.sub(n4)._unit()._perp(), c3 = l3._add(u3)._unit(), h22 = c3.x * u3.x + c3.y * u3.y;
+                        0 !== h22 && c3._mult(1 / h22), a3.push(c3._mult(e3)._add(n4));
+                      }
+                      r3.push(a3);
+                    }
+                    return r3;
+                  }(n22, c22 * o22)), function(t5, e3, r3) {
+                    for (let n3 = 0; n3 < e3.length; n3++) {
+                      const i3 = e3[n3];
+                      if (t5.length >= 3) {
+                        for (let e4 = 0; e4 < i3.length; e4++) if (Wa2(t5, i3[e4])) return true;
+                      }
+                      if (Ga2(t5, i3, r3)) return true;
+                    }
+                    return false;
+                  }(l22, n22, u22);
+                }
+                isTileClipped() {
+                  return true;
+                }
+              }
+              function Yl(t42, e22) {
+                return e22 > 0 ? e22 + 2 * t42 : t42;
+              }
+              const Jl = ls([{ name: "a_pos_offset", components: 4, type: "Int16" }, { name: "a_data", components: 4, type: "Uint16" }, { name: "a_pixeloffset", components: 4, type: "Int16" }], 4), Wl = ls([{ name: "a_projected_pos", components: 3, type: "Float32" }], 4);
+              ls([{ name: "a_fade_opacity", components: 1, type: "Uint32" }], 4);
+              const Ql = ls([{ name: "a_placed", components: 2, type: "Uint8" }, { name: "a_shift", components: 2, type: "Float32" }, { name: "a_box_real", components: 2, type: "Int16" }]);
+              ls([{ type: "Int16", name: "anchorPointX" }, { type: "Int16", name: "anchorPointY" }, { type: "Int16", name: "x1" }, { type: "Int16", name: "y1" }, { type: "Int16", name: "x2" }, { type: "Int16", name: "y2" }, { type: "Uint32", name: "featureIndex" }, { type: "Uint16", name: "sourceLayerIndex" }, { type: "Uint16", name: "bucketIndex" }]);
+              const tu = ls([{ name: "a_pos", components: 2, type: "Int16" }, { name: "a_anchor_pos", components: 2, type: "Int16" }, { name: "a_extrude", components: 2, type: "Int16" }], 4), eu = ls([{ name: "a_pos", components: 2, type: "Float32" }, { name: "a_radius", components: 1, type: "Float32" }, { name: "a_flags", components: 2, type: "Int16" }], 4);
+              function ru(t42, e22, r22) {
+                return t42.sections.forEach((t5) => {
+                  t5.text = function(t6, e3, r3) {
+                    const n22 = e3.layout.get("text-transform").evaluate(r3, {});
+                    return "uppercase" === n22 ? t6 = t6.toLocaleUpperCase() : "lowercase" === n22 && (t6 = t6.toLocaleLowerCase()), Ri2.applyArabicShaping && (t6 = Ri2.applyArabicShaping(t6)), t6;
+                  }(t5.text, e22, r22);
+                }), t42;
+              }
+              ls([{ name: "triangle", components: 3, type: "Uint16" }]), ls([{ type: "Int16", name: "anchorX" }, { type: "Int16", name: "anchorY" }, { type: "Uint16", name: "glyphStartIndex" }, { type: "Uint16", name: "numGlyphs" }, { type: "Uint32", name: "vertexStartIndex" }, { type: "Uint32", name: "lineStartIndex" }, { type: "Uint32", name: "lineLength" }, { type: "Uint16", name: "segment" }, { type: "Uint16", name: "lowerSize" }, { type: "Uint16", name: "upperSize" }, { type: "Float32", name: "lineOffsetX" }, { type: "Float32", name: "lineOffsetY" }, { type: "Uint8", name: "writingMode" }, { type: "Uint8", name: "placedOrientation" }, { type: "Uint8", name: "hidden" }, { type: "Uint32", name: "crossTileID" }, { type: "Int16", name: "associatedIconIndex" }]), ls([{ type: "Int16", name: "anchorX" }, { type: "Int16", name: "anchorY" }, { type: "Int16", name: "rightJustifiedTextSymbolIndex" }, { type: "Int16", name: "centerJustifiedTextSymbolIndex" }, { type: "Int16", name: "leftJustifiedTextSymbolIndex" }, { type: "Int16", name: "verticalPlacedTextSymbolIndex" }, { type: "Int16", name: "placedIconSymbolIndex" }, { type: "Int16", name: "verticalPlacedIconSymbolIndex" }, { type: "Uint16", name: "key" }, { type: "Uint16", name: "textBoxStartIndex" }, { type: "Uint16", name: "textBoxEndIndex" }, { type: "Uint16", name: "verticalTextBoxStartIndex" }, { type: "Uint16", name: "verticalTextBoxEndIndex" }, { type: "Uint16", name: "iconBoxStartIndex" }, { type: "Uint16", name: "iconBoxEndIndex" }, { type: "Uint16", name: "verticalIconBoxStartIndex" }, { type: "Uint16", name: "verticalIconBoxEndIndex" }, { type: "Uint16", name: "featureIndex" }, { type: "Uint16", name: "numHorizontalGlyphVertices" }, { type: "Uint16", name: "numVerticalGlyphVertices" }, { type: "Uint16", name: "numIconVertices" }, { type: "Uint16", name: "numVerticalIconVertices" }, { type: "Uint16", name: "useRuntimeCollisionCircles" }, { type: "Uint32", name: "crossTileID" }, { type: "Float32", name: "textBoxScale" }, { type: "Float32", name: "collisionCircleDiameter" }, { type: "Uint16", name: "textAnchorOffsetStartIndex" }, { type: "Uint16", name: "textAnchorOffsetEndIndex" }]), ls([{ type: "Float32", name: "offsetX" }]), ls([{ type: "Int16", name: "x" }, { type: "Int16", name: "y" }, { type: "Int16", name: "tileUnitDistanceFromAnchor" }]), ls([{ type: "Uint16", name: "textAnchor" }, { type: "Float32", components: 2, name: "textOffset" }]);
+              const nu = { "!": "︕", "#": "＃", $: "＄", "%": "％", "&": "＆", "(": "︵", ")": "︶", "*": "＊", "+": "＋", ",": "︐", "-": "︲", ".": "・", "/": "／", ":": "︓", ";": "︔", "<": "︿", "=": "＝", ">": "﹀", "?": "︖", "@": "＠", "[": "﹇", "\\": "＼", "]": "﹈", "^": "＾", _: "︳", "`": "｀", "{": "︷", "|": "―", "}": "︸", "~": "～", "¢": "￠", "£": "￡", "¥": "￥", "¦": "￤", "¬": "￢", "¯": "￣", "–": "︲", "—": "︱", "‘": "﹃", "’": "﹄", "“": "﹁", "”": "﹂", "…": "︙", "‧": "・", "₩": "￦", "、": "︑", "。": "︒", "〈": "︿", "〉": "﹀", "《": "︽", "》": "︾", "「": "﹁", "」": "﹂", "『": "﹃", "』": "﹄", "【": "︻", "】": "︼", "〔": "︹", "〕": "︺", "〖": "︗", "〗": "︘", "！": "︕", "（": "︵", "）": "︶", "，": "︐", "－": "︲", "．": "・", "：": "︓", "；": "︔", "＜": "︿", "＞": "﹀", "？": "︖", "［": "﹇", "］": "﹈", "＿": "︳", "｛": "︷", "｜": "―", "｝": "︸", "｟": "︵", "｠": "︶", "｡": "︒", "｢": "﹁", "｣": "﹂" };
+              var iu = 24, su = lu, au = function(t42, e22, r22, n22, i22) {
+                var s22, a22, o22 = 8 * i22 - n22 - 1, l22 = (1 << o22) - 1, u22 = l22 >> 1, c22 = -7, h22 = i22 - 1, p22 = -1, f22 = t42[e22 + h22];
+                for (h22 += p22, s22 = f22 & (1 << -c22) - 1, f22 >>= -c22, c22 += o22; c22 > 0; s22 = 256 * s22 + t42[e22 + h22], h22 += p22, c22 -= 8) ;
+                for (a22 = s22 & (1 << -c22) - 1, s22 >>= -c22, c22 += n22; c22 > 0; a22 = 256 * a22 + t42[e22 + h22], h22 += p22, c22 -= 8) ;
+                if (0 === s22) s22 = 1 - u22;
+                else {
+                  if (s22 === l22) return a22 ? NaN : 1 / 0 * (f22 ? -1 : 1);
+                  a22 += Math.pow(2, n22), s22 -= u22;
+                }
+                return (f22 ? -1 : 1) * a22 * Math.pow(2, s22 - n22);
+              }, ou = function(t42, e22, r22, n22, i22, s22) {
+                var a22, o22, l22, u22 = 8 * s22 - i22 - 1, c22 = (1 << u22) - 1, h22 = c22 >> 1, p22 = 23 === i22 ? Math.pow(2, -24) - Math.pow(2, -77) : 0, f22 = 0, d22 = 1, y22 = e22 < 0 || 0 === e22 && 1 / e22 < 0 ? 1 : 0;
+                for (e22 = Math.abs(e22), isNaN(e22) || e22 === 1 / 0 ? (o22 = isNaN(e22) ? 1 : 0, a22 = c22) : (a22 = Math.floor(Math.log(e22) / Math.LN2), e22 * (l22 = Math.pow(2, -a22)) < 1 && (a22--, l22 *= 2), (e22 += a22 + h22 >= 1 ? p22 / l22 : p22 * Math.pow(2, 1 - h22)) * l22 >= 2 && (a22++, l22 /= 2), a22 + h22 >= c22 ? (o22 = 0, a22 = c22) : a22 + h22 >= 1 ? (o22 = (e22 * l22 - 1) * Math.pow(2, i22), a22 += h22) : (o22 = e22 * Math.pow(2, h22 - 1) * Math.pow(2, i22), a22 = 0)); i22 >= 8; t42[r22 + f22] = 255 & o22, f22 += d22, o22 /= 256, i22 -= 8) ;
+                for (a22 = a22 << i22 | o22, u22 += i22; u22 > 0; t42[r22 + f22] = 255 & a22, f22 += d22, a22 /= 256, u22 -= 8) ;
+                t42[r22 + f22 - d22] |= 128 * y22;
+              };
+              function lu(t42) {
+                this.buf = ArrayBuffer.isView && ArrayBuffer.isView(t42) ? t42 : new Uint8Array(t42 || 0), this.pos = 0, this.type = 0, this.length = this.buf.length;
+              }
+              lu.Varint = 0, lu.Fixed64 = 1, lu.Bytes = 2, lu.Fixed32 = 5;
+              var uu = 4294967296, cu = 1 / uu, hu = "undefined" == typeof TextDecoder ? null : new TextDecoder("utf-8");
+              function pu(t42) {
+                return t42.type === lu.Bytes ? t42.readVarint() + t42.pos : t42.pos + 1;
+              }
+              function fu(t42, e22, r22) {
+                return r22 ? 4294967296 * e22 + (t42 >>> 0) : 4294967296 * (e22 >>> 0) + (t42 >>> 0);
+              }
+              function du(t42, e22, r22) {
+                var n22 = e22 <= 16383 ? 1 : e22 <= 2097151 ? 2 : e22 <= 268435455 ? 3 : Math.floor(Math.log(e22) / (7 * Math.LN2));
+                r22.realloc(n22);
+                for (var i22 = r22.pos - 1; i22 >= t42; i22--) r22.buf[i22 + n22] = r22.buf[i22];
+              }
+              function yu(t42, e22) {
+                for (var r22 = 0; r22 < t42.length; r22++) e22.writeVarint(t42[r22]);
+              }
+              function mu(t42, e22) {
+                for (var r22 = 0; r22 < t42.length; r22++) e22.writeSVarint(t42[r22]);
+              }
+              function gu(t42, e22) {
+                for (var r22 = 0; r22 < t42.length; r22++) e22.writeFloat(t42[r22]);
+              }
+              function xu(t42, e22) {
+                for (var r22 = 0; r22 < t42.length; r22++) e22.writeDouble(t42[r22]);
+              }
+              function vu(t42, e22) {
+                for (var r22 = 0; r22 < t42.length; r22++) e22.writeBoolean(t42[r22]);
+              }
+              function bu(t42, e22) {
+                for (var r22 = 0; r22 < t42.length; r22++) e22.writeFixed32(t42[r22]);
+              }
+              function wu(t42, e22) {
+                for (var r22 = 0; r22 < t42.length; r22++) e22.writeSFixed32(t42[r22]);
+              }
+              function _u2(t42, e22) {
+                for (var r22 = 0; r22 < t42.length; r22++) e22.writeFixed64(t42[r22]);
+              }
+              function Au(t42, e22) {
+                for (var r22 = 0; r22 < t42.length; r22++) e22.writeSFixed64(t42[r22]);
+              }
+              function Su(t42, e22) {
+                return (t42[e22] | t42[e22 + 1] << 8 | t42[e22 + 2] << 16) + 16777216 * t42[e22 + 3];
+              }
+              function ku(t42, e22, r22) {
+                t42[r22] = e22, t42[r22 + 1] = e22 >>> 8, t42[r22 + 2] = e22 >>> 16, t42[r22 + 3] = e22 >>> 24;
+              }
+              function Mu(t42, e22) {
+                return (t42[e22] | t42[e22 + 1] << 8 | t42[e22 + 2] << 16) + (t42[e22 + 3] << 24);
+              }
+              lu.prototype = { destroy: function() {
+                this.buf = null;
+              }, readFields: function(t42, e22, r22) {
+                for (r22 = r22 || this.length; this.pos < r22; ) {
+                  var n22 = this.readVarint(), i22 = n22 >> 3, s22 = this.pos;
+                  this.type = 7 & n22, t42(i22, e22, this), this.pos === s22 && this.skip(n22);
+                }
+                return e22;
+              }, readMessage: function(t42, e22) {
+                return this.readFields(t42, e22, this.readVarint() + this.pos);
+              }, readFixed32: function() {
+                var t42 = Su(this.buf, this.pos);
+                return this.pos += 4, t42;
+              }, readSFixed32: function() {
+                var t42 = Mu(this.buf, this.pos);
+                return this.pos += 4, t42;
+              }, readFixed64: function() {
+                var t42 = Su(this.buf, this.pos) + Su(this.buf, this.pos + 4) * uu;
+                return this.pos += 8, t42;
+              }, readSFixed64: function() {
+                var t42 = Su(this.buf, this.pos) + Mu(this.buf, this.pos + 4) * uu;
+                return this.pos += 8, t42;
+              }, readFloat: function() {
+                var t42 = au(this.buf, this.pos, true, 23, 4);
+                return this.pos += 4, t42;
+              }, readDouble: function() {
+                var t42 = au(this.buf, this.pos, true, 52, 8);
+                return this.pos += 8, t42;
+              }, readVarint: function(t42) {
+                var e22, r22, n22 = this.buf;
+                return e22 = 127 & (r22 = n22[this.pos++]), r22 < 128 ? e22 : (e22 |= (127 & (r22 = n22[this.pos++])) << 7, r22 < 128 ? e22 : (e22 |= (127 & (r22 = n22[this.pos++])) << 14, r22 < 128 ? e22 : (e22 |= (127 & (r22 = n22[this.pos++])) << 21, r22 < 128 ? e22 : function(t5, e3, r3) {
+                  var n3, i22, s22 = r3.buf;
+                  if (n3 = (112 & (i22 = s22[r3.pos++])) >> 4, i22 < 128) return fu(t5, n3, e3);
+                  if (n3 |= (127 & (i22 = s22[r3.pos++])) << 3, i22 < 128) return fu(t5, n3, e3);
+                  if (n3 |= (127 & (i22 = s22[r3.pos++])) << 10, i22 < 128) return fu(t5, n3, e3);
+                  if (n3 |= (127 & (i22 = s22[r3.pos++])) << 17, i22 < 128) return fu(t5, n3, e3);
+                  if (n3 |= (127 & (i22 = s22[r3.pos++])) << 24, i22 < 128) return fu(t5, n3, e3);
+                  if (n3 |= (1 & (i22 = s22[r3.pos++])) << 31, i22 < 128) return fu(t5, n3, e3);
+                  throw new Error("Expected varint not more than 10 bytes");
+                }(e22 |= (15 & (r22 = n22[this.pos])) << 28, t42, this))));
+              }, readVarint64: function() {
+                return this.readVarint(true);
+              }, readSVarint: function() {
+                var t42 = this.readVarint();
+                return t42 % 2 == 1 ? (t42 + 1) / -2 : t42 / 2;
+              }, readBoolean: function() {
+                return Boolean(this.readVarint());
+              }, readString: function() {
+                var t42 = this.readVarint() + this.pos, e22 = this.pos;
+                return this.pos = t42, t42 - e22 >= 12 && hu ? function(t5, e3, r22) {
+                  return hu.decode(t5.subarray(e3, r22));
+                }(this.buf, e22, t42) : function(t5, e3, r22) {
+                  for (var n22 = "", i22 = e3; i22 < r22; ) {
+                    var s22, a22, o22, l22 = t5[i22], u22 = null, c22 = l22 > 239 ? 4 : l22 > 223 ? 3 : l22 > 191 ? 2 : 1;
+                    if (i22 + c22 > r22) break;
+                    1 === c22 ? l22 < 128 && (u22 = l22) : 2 === c22 ? 128 == (192 & (s22 = t5[i22 + 1])) && (u22 = (31 & l22) << 6 | 63 & s22) <= 127 && (u22 = null) : 3 === c22 ? (a22 = t5[i22 + 2], 128 == (192 & (s22 = t5[i22 + 1])) && 128 == (192 & a22) && ((u22 = (15 & l22) << 12 | (63 & s22) << 6 | 63 & a22) <= 2047 || u22 >= 55296 && u22 <= 57343) && (u22 = null)) : 4 === c22 && (a22 = t5[i22 + 2], o22 = t5[i22 + 3], 128 == (192 & (s22 = t5[i22 + 1])) && 128 == (192 & a22) && 128 == (192 & o22) && ((u22 = (15 & l22) << 18 | (63 & s22) << 12 | (63 & a22) << 6 | 63 & o22) <= 65535 || u22 >= 1114112) && (u22 = null)), null === u22 ? (u22 = 65533, c22 = 1) : u22 > 65535 && (u22 -= 65536, n22 += String.fromCharCode(u22 >>> 10 & 1023 | 55296), u22 = 56320 | 1023 & u22), n22 += String.fromCharCode(u22), i22 += c22;
+                  }
+                  return n22;
+                }(this.buf, e22, t42);
+              }, readBytes: function() {
+                var t42 = this.readVarint() + this.pos, e22 = this.buf.subarray(this.pos, t42);
+                return this.pos = t42, e22;
+              }, readPackedVarint: function(t42, e22) {
+                if (this.type !== lu.Bytes) return t42.push(this.readVarint(e22));
+                var r22 = pu(this);
+                for (t42 = t42 || []; this.pos < r22; ) t42.push(this.readVarint(e22));
+                return t42;
+              }, readPackedSVarint: function(t42) {
+                if (this.type !== lu.Bytes) return t42.push(this.readSVarint());
+                var e22 = pu(this);
+                for (t42 = t42 || []; this.pos < e22; ) t42.push(this.readSVarint());
+                return t42;
+              }, readPackedBoolean: function(t42) {
+                if (this.type !== lu.Bytes) return t42.push(this.readBoolean());
+                var e22 = pu(this);
+                for (t42 = t42 || []; this.pos < e22; ) t42.push(this.readBoolean());
+                return t42;
+              }, readPackedFloat: function(t42) {
+                if (this.type !== lu.Bytes) return t42.push(this.readFloat());
+                var e22 = pu(this);
+                for (t42 = t42 || []; this.pos < e22; ) t42.push(this.readFloat());
+                return t42;
+              }, readPackedDouble: function(t42) {
+                if (this.type !== lu.Bytes) return t42.push(this.readDouble());
+                var e22 = pu(this);
+                for (t42 = t42 || []; this.pos < e22; ) t42.push(this.readDouble());
+                return t42;
+              }, readPackedFixed32: function(t42) {
+                if (this.type !== lu.Bytes) return t42.push(this.readFixed32());
+                var e22 = pu(this);
+                for (t42 = t42 || []; this.pos < e22; ) t42.push(this.readFixed32());
+                return t42;
+              }, readPackedSFixed32: function(t42) {
+                if (this.type !== lu.Bytes) return t42.push(this.readSFixed32());
+                var e22 = pu(this);
+                for (t42 = t42 || []; this.pos < e22; ) t42.push(this.readSFixed32());
+                return t42;
+              }, readPackedFixed64: function(t42) {
+                if (this.type !== lu.Bytes) return t42.push(this.readFixed64());
+                var e22 = pu(this);
+                for (t42 = t42 || []; this.pos < e22; ) t42.push(this.readFixed64());
+                return t42;
+              }, readPackedSFixed64: function(t42) {
+                if (this.type !== lu.Bytes) return t42.push(this.readSFixed64());
+                var e22 = pu(this);
+                for (t42 = t42 || []; this.pos < e22; ) t42.push(this.readSFixed64());
+                return t42;
+              }, skip: function(t42) {
+                var e22 = 7 & t42;
+                if (e22 === lu.Varint) for (; this.buf[this.pos++] > 127; ) ;
+                else if (e22 === lu.Bytes) this.pos = this.readVarint() + this.pos;
+                else if (e22 === lu.Fixed32) this.pos += 4;
+                else {
+                  if (e22 !== lu.Fixed64) throw new Error("Unimplemented type: " + e22);
+                  this.pos += 8;
+                }
+              }, writeTag: function(t42, e22) {
+                this.writeVarint(t42 << 3 | e22);
+              }, realloc: function(t42) {
+                for (var e22 = this.length || 16; e22 < this.pos + t42; ) e22 *= 2;
+                if (e22 !== this.length) {
+                  var r22 = new Uint8Array(e22);
+                  r22.set(this.buf), this.buf = r22, this.length = e22;
+                }
+              }, finish: function() {
+                return this.length = this.pos, this.pos = 0, this.buf.subarray(0, this.length);
+              }, writeFixed32: function(t42) {
+                this.realloc(4), ku(this.buf, t42, this.pos), this.pos += 4;
+              }, writeSFixed32: function(t42) {
+                this.realloc(4), ku(this.buf, t42, this.pos), this.pos += 4;
+              }, writeFixed64: function(t42) {
+                this.realloc(8), ku(this.buf, -1 & t42, this.pos), ku(this.buf, Math.floor(t42 * cu), this.pos + 4), this.pos += 8;
+              }, writeSFixed64: function(t42) {
+                this.realloc(8), ku(this.buf, -1 & t42, this.pos), ku(this.buf, Math.floor(t42 * cu), this.pos + 4), this.pos += 8;
+              }, writeVarint: function(t42) {
+                (t42 = +t42 || 0) > 268435455 || t42 < 0 ? function(t5, e22) {
+                  var r22, n22;
+                  if (t5 >= 0 ? (r22 = t5 % 4294967296 | 0, n22 = t5 / 4294967296 | 0) : (n22 = ~(-t5 / 4294967296), 4294967295 ^ (r22 = ~(-t5 % 4294967296)) ? r22 = r22 + 1 | 0 : (r22 = 0, n22 = n22 + 1 | 0)), t5 >= 18446744073709552e3 || t5 < -18446744073709552e3) throw new Error("Given varint doesn't fit into 10 bytes");
+                  e22.realloc(10), function(t6, e3, r3) {
+                    r3.buf[r3.pos++] = 127 & t6 | 128, t6 >>>= 7, r3.buf[r3.pos++] = 127 & t6 | 128, t6 >>>= 7, r3.buf[r3.pos++] = 127 & t6 | 128, t6 >>>= 7, r3.buf[r3.pos++] = 127 & t6 | 128, r3.buf[r3.pos] = 127 & (t6 >>>= 7);
+                  }(r22, 0, e22), function(t6, e3) {
+                    var r3 = (7 & t6) << 4;
+                    e3.buf[e3.pos++] |= r3 | ((t6 >>>= 3) ? 128 : 0), t6 && (e3.buf[e3.pos++] = 127 & t6 | ((t6 >>>= 7) ? 128 : 0), t6 && (e3.buf[e3.pos++] = 127 & t6 | ((t6 >>>= 7) ? 128 : 0), t6 && (e3.buf[e3.pos++] = 127 & t6 | ((t6 >>>= 7) ? 128 : 0), t6 && (e3.buf[e3.pos++] = 127 & t6 | ((t6 >>>= 7) ? 128 : 0), t6 && (e3.buf[e3.pos++] = 127 & t6)))));
+                  }(n22, e22);
+                }(t42, this) : (this.realloc(4), this.buf[this.pos++] = 127 & t42 | (t42 > 127 ? 128 : 0), t42 <= 127 || (this.buf[this.pos++] = 127 & (t42 >>>= 7) | (t42 > 127 ? 128 : 0), t42 <= 127 || (this.buf[this.pos++] = 127 & (t42 >>>= 7) | (t42 > 127 ? 128 : 0), t42 <= 127 || (this.buf[this.pos++] = t42 >>> 7 & 127))));
+              }, writeSVarint: function(t42) {
+                this.writeVarint(t42 < 0 ? 2 * -t42 - 1 : 2 * t42);
+              }, writeBoolean: function(t42) {
+                this.writeVarint(Boolean(t42));
+              }, writeString: function(t42) {
+                t42 = String(t42), this.realloc(4 * t42.length), this.pos++;
+                var e22 = this.pos;
+                this.pos = function(t5, e3, r3) {
+                  for (var n22, i22, s22 = 0; s22 < e3.length; s22++) {
+                    if ((n22 = e3.charCodeAt(s22)) > 55295 && n22 < 57344) {
+                      if (!i22) {
+                        n22 > 56319 || s22 + 1 === e3.length ? (t5[r3++] = 239, t5[r3++] = 191, t5[r3++] = 189) : i22 = n22;
+                        continue;
+                      }
+                      if (n22 < 56320) {
+                        t5[r3++] = 239, t5[r3++] = 191, t5[r3++] = 189, i22 = n22;
+                        continue;
+                      }
+                      n22 = i22 - 55296 << 10 | n22 - 56320 | 65536, i22 = null;
+                    } else i22 && (t5[r3++] = 239, t5[r3++] = 191, t5[r3++] = 189, i22 = null);
+                    n22 < 128 ? t5[r3++] = n22 : (n22 < 2048 ? t5[r3++] = n22 >> 6 | 192 : (n22 < 65536 ? t5[r3++] = n22 >> 12 | 224 : (t5[r3++] = n22 >> 18 | 240, t5[r3++] = n22 >> 12 & 63 | 128), t5[r3++] = n22 >> 6 & 63 | 128), t5[r3++] = 63 & n22 | 128);
+                  }
+                  return r3;
+                }(this.buf, t42, this.pos);
+                var r22 = this.pos - e22;
+                r22 >= 128 && du(e22, r22, this), this.pos = e22 - 1, this.writeVarint(r22), this.pos += r22;
+              }, writeFloat: function(t42) {
+                this.realloc(4), ou(this.buf, t42, this.pos, true, 23, 4), this.pos += 4;
+              }, writeDouble: function(t42) {
+                this.realloc(8), ou(this.buf, t42, this.pos, true, 52, 8), this.pos += 8;
+              }, writeBytes: function(t42) {
+                var e22 = t42.length;
+                this.writeVarint(e22), this.realloc(e22);
+                for (var r22 = 0; r22 < e22; r22++) this.buf[this.pos++] = t42[r22];
+              }, writeRawMessage: function(t42, e22) {
+                this.pos++;
+                var r22 = this.pos;
+                t42(e22, this);
+                var n22 = this.pos - r22;
+                n22 >= 128 && du(r22, n22, this), this.pos = r22 - 1, this.writeVarint(n22), this.pos += n22;
+              }, writeMessage: function(t42, e22, r22) {
+                this.writeTag(t42, lu.Bytes), this.writeRawMessage(e22, r22);
+              }, writePackedVarint: function(t42, e22) {
+                e22.length && this.writeMessage(t42, yu, e22);
+              }, writePackedSVarint: function(t42, e22) {
+                e22.length && this.writeMessage(t42, mu, e22);
+              }, writePackedBoolean: function(t42, e22) {
+                e22.length && this.writeMessage(t42, vu, e22);
+              }, writePackedFloat: function(t42, e22) {
+                e22.length && this.writeMessage(t42, gu, e22);
+              }, writePackedDouble: function(t42, e22) {
+                e22.length && this.writeMessage(t42, xu, e22);
+              }, writePackedFixed32: function(t42, e22) {
+                e22.length && this.writeMessage(t42, bu, e22);
+              }, writePackedSFixed32: function(t42, e22) {
+                e22.length && this.writeMessage(t42, wu, e22);
+              }, writePackedFixed64: function(t42, e22) {
+                e22.length && this.writeMessage(t42, _u2, e22);
+              }, writePackedSFixed64: function(t42, e22) {
+                e22.length && this.writeMessage(t42, Au, e22);
+              }, writeBytesField: function(t42, e22) {
+                this.writeTag(t42, lu.Bytes), this.writeBytes(e22);
+              }, writeFixed32Field: function(t42, e22) {
+                this.writeTag(t42, lu.Fixed32), this.writeFixed32(e22);
+              }, writeSFixed32Field: function(t42, e22) {
+                this.writeTag(t42, lu.Fixed32), this.writeSFixed32(e22);
+              }, writeFixed64Field: function(t42, e22) {
+                this.writeTag(t42, lu.Fixed64), this.writeFixed64(e22);
+              }, writeSFixed64Field: function(t42, e22) {
+                this.writeTag(t42, lu.Fixed64), this.writeSFixed64(e22);
+              }, writeVarintField: function(t42, e22) {
+                this.writeTag(t42, lu.Varint), this.writeVarint(e22);
+              }, writeSVarintField: function(t42, e22) {
+                this.writeTag(t42, lu.Varint), this.writeSVarint(e22);
+              }, writeStringField: function(t42, e22) {
+                this.writeTag(t42, lu.Bytes), this.writeString(e22);
+              }, writeFloatField: function(t42, e22) {
+                this.writeTag(t42, lu.Fixed32), this.writeFloat(e22);
+              }, writeDoubleField: function(t42, e22) {
+                this.writeTag(t42, lu.Fixed64), this.writeDouble(e22);
+              }, writeBooleanField: function(t42, e22) {
+                this.writeVarintField(t42, Boolean(e22));
+              } };
+              var Iu = r2(su);
+              const zu = 3;
+              function Pu(t42, e22, r22) {
+                1 === t42 && r22.readMessage(Cu, e22);
+              }
+              function Cu(t42, e22, r22) {
+                if (3 === t42) {
+                  const { id: t5, bitmap: n22, width: i22, height: s22, left: a22, top: o22, advance: l22 } = r22.readMessage(Bu, {});
+                  e22.push({ id: t5, bitmap: new _o2({ width: i22 + 2 * zu, height: s22 + 2 * zu }, n22), metrics: { width: i22, height: s22, left: a22, top: o22, advance: l22 } });
+                }
+              }
+              function Bu(t42, e22, r22) {
+                1 === t42 ? e22.id = r22.readVarint() : 2 === t42 ? e22.bitmap = r22.readBytes() : 3 === t42 ? e22.width = r22.readVarint() : 4 === t42 ? e22.height = r22.readVarint() : 5 === t42 ? e22.left = r22.readSVarint() : 6 === t42 ? e22.top = r22.readSVarint() : 7 === t42 && (e22.advance = r22.readVarint());
+              }
+              const Vu = zu;
+              function Eu(t42) {
+                let e22 = 0, r22 = 0;
+                for (const n3 of t42) e22 += n3.w * n3.h, r22 = Math.max(r22, n3.w);
+                t42.sort((t5, e3) => e3.h - t5.h);
+                const n22 = [{ x: 0, y: 0, w: Math.max(Math.ceil(Math.sqrt(e22 / 0.95)), r22), h: 1 / 0 }];
+                let i22 = 0, s22 = 0;
+                for (const e3 of t42) for (let t5 = n22.length - 1; t5 >= 0; t5--) {
+                  const r3 = n22[t5];
+                  if (!(e3.w > r3.w || e3.h > r3.h)) {
+                    if (e3.x = r3.x, e3.y = r3.y, s22 = Math.max(s22, e3.y + e3.h), i22 = Math.max(i22, e3.x + e3.w), e3.w === r3.w && e3.h === r3.h) {
+                      const e4 = n22.pop();
+                      t5 < n22.length && (n22[t5] = e4);
+                    } else e3.h === r3.h ? (r3.x += e3.w, r3.w -= e3.w) : e3.w === r3.w ? (r3.y += e3.h, r3.h -= e3.h) : (n22.push({ x: r3.x + e3.w, y: r3.y, w: r3.w - e3.w, h: e3.h }), r3.y += e3.h, r3.h -= e3.h);
+                    break;
+                  }
+                }
+                return { w: i22, h: s22, fill: e22 / (i22 * s22) || 0 };
+              }
+              const Fu = 1;
+              class Tu {
+                constructor(t42, { pixelRatio: e22, version: r22, stretchX: n22, stretchY: i22, content: s22, textFitWidth: a22, textFitHeight: o22 }) {
+                  this.paddedRect = t42, this.pixelRatio = e22, this.stretchX = n22, this.stretchY = i22, this.content = s22, this.version = r22, this.textFitWidth = a22, this.textFitHeight = o22;
+                }
+                get tl() {
+                  return [this.paddedRect.x + Fu, this.paddedRect.y + Fu];
+                }
+                get br() {
+                  return [this.paddedRect.x + this.paddedRect.w - Fu, this.paddedRect.y + this.paddedRect.h - Fu];
+                }
+                get tlbr() {
+                  return this.tl.concat(this.br);
+                }
+                get displaySize() {
+                  return [(this.paddedRect.w - 2 * Fu) / this.pixelRatio, (this.paddedRect.h - 2 * Fu) / this.pixelRatio];
+                }
+              }
+              class $u {
+                constructor(t42, e22) {
+                  const r22 = {}, n22 = {};
+                  this.haveRenderCallbacks = [];
+                  const i22 = [];
+                  this.addImages(t42, r22, i22), this.addImages(e22, n22, i22);
+                  const { w: s22, h: a22 } = Eu(i22), o22 = new Ao({ width: s22 || 1, height: a22 || 1 });
+                  for (const e3 in t42) {
+                    const n3 = t42[e3], i3 = r22[e3].paddedRect;
+                    Ao.copy(n3.data, o22, { x: 0, y: 0 }, { x: i3.x + Fu, y: i3.y + Fu }, n3.data);
+                  }
+                  for (const t5 in e22) {
+                    const r3 = e22[t5], i3 = n22[t5].paddedRect, s3 = i3.x + Fu, a3 = i3.y + Fu, l22 = r3.data.width, u22 = r3.data.height;
+                    Ao.copy(r3.data, o22, { x: 0, y: 0 }, { x: s3, y: a3 }, r3.data), Ao.copy(r3.data, o22, { x: 0, y: u22 - 1 }, { x: s3, y: a3 - 1 }, { width: l22, height: 1 }), Ao.copy(r3.data, o22, { x: 0, y: 0 }, { x: s3, y: a3 + u22 }, { width: l22, height: 1 }), Ao.copy(r3.data, o22, { x: l22 - 1, y: 0 }, { x: s3 - 1, y: a3 }, { width: 1, height: u22 }), Ao.copy(r3.data, o22, { x: 0, y: 0 }, { x: s3 + l22, y: a3 }, { width: 1, height: u22 });
+                  }
+                  this.image = o22, this.iconPositions = r22, this.patternPositions = n22;
+                }
+                addImages(t42, e22, r22) {
+                  for (const n22 in t42) {
+                    const i22 = t42[n22], s22 = { x: 0, y: 0, w: i22.data.width + 2 * Fu, h: i22.data.height + 2 * Fu };
+                    r22.push(s22), e22[n22] = new Tu(s22, i22), i22.hasRenderCallback && this.haveRenderCallbacks.push(n22);
+                  }
+                }
+                patchUpdatedImages(t42, e22) {
+                  t42.dispatchRenderCallbacks(this.haveRenderCallbacks);
+                  for (const r22 in t42.updatedImages) this.patchUpdatedImage(this.iconPositions[r22], t42.getImage(r22), e22), this.patchUpdatedImage(this.patternPositions[r22], t42.getImage(r22), e22);
+                }
+                patchUpdatedImage(t42, e22, r22) {
+                  if (!t42 || !e22) return;
+                  if (t42.version === e22.version) return;
+                  t42.version = e22.version;
+                  const [n22, i22] = t42.tl;
+                  r22.update(e22.data, void 0, { x: n22, y: i22 });
+                }
+              }
+              var Lu;
+              wi2("ImagePosition", Tu), wi2("ImageAtlas", $u), t4.ah = void 0, (Lu = t4.ah || (t4.ah = {}))[Lu.none = 0] = "none", Lu[Lu.horizontal = 1] = "horizontal", Lu[Lu.vertical = 2] = "vertical", Lu[Lu.horizontalOnly = 3] = "horizontalOnly";
+              const Du = -17;
+              class Ou {
+                constructor() {
+                  this.scale = 1, this.fontStack = "", this.imageName = null;
+                }
+                static forText(t42, e22) {
+                  const r22 = new Ou();
+                  return r22.scale = t42 || 1, r22.fontStack = e22, r22;
+                }
+                static forImage(t42) {
+                  const e22 = new Ou();
+                  return e22.imageName = t42, e22;
+                }
+              }
+              class ju {
+                constructor() {
+                  this.text = "", this.sectionIndex = [], this.sections = [], this.imageSectionID = null;
+                }
+                static fromFeature(t42, e22) {
+                  const r22 = new ju();
+                  for (let n22 = 0; n22 < t42.sections.length; n22++) {
+                    const i22 = t42.sections[n22];
+                    i22.image ? r22.addImageSection(i22) : r22.addTextSection(i22, e22);
+                  }
+                  return r22;
+                }
+                length() {
+                  return this.text.length;
+                }
+                getSection(t42) {
+                  return this.sections[this.sectionIndex[t42]];
+                }
+                getSectionIndex(t42) {
+                  return this.sectionIndex[t42];
+                }
+                getCharCode(t42) {
+                  return this.text.charCodeAt(t42);
+                }
+                verticalizePunctuation() {
+                  this.text = function(t42) {
+                    let e22 = "";
+                    for (let r22 = 0; r22 < t42.length; r22++) {
+                      const n22 = t42.charCodeAt(r22 + 1) || null, i22 = t42.charCodeAt(r22 - 1) || null;
+                      e22 += n22 && $i2(n22) && !nu[t42[r22 + 1]] || i22 && $i2(i22) && !nu[t42[r22 - 1]] || !nu[t42[r22]] ? t42[r22] : nu[t42[r22]];
+                    }
+                    return e22;
+                  }(this.text);
+                }
+                trim() {
+                  let t42 = 0;
+                  for (let e3 = 0; e3 < this.text.length && Uu[this.text.charCodeAt(e3)]; e3++) t42++;
+                  let e22 = this.text.length;
+                  for (let r22 = this.text.length - 1; r22 >= 0 && r22 >= t42 && Uu[this.text.charCodeAt(r22)]; r22--) e22--;
+                  this.text = this.text.substring(t42, e22), this.sectionIndex = this.sectionIndex.slice(t42, e22);
+                }
+                substring(t42, e22) {
+                  const r22 = new ju();
+                  return r22.text = this.text.substring(t42, e22), r22.sectionIndex = this.sectionIndex.slice(t42, e22), r22.sections = this.sections, r22;
+                }
+                toString() {
+                  return this.text;
+                }
+                getMaxScale() {
+                  return this.sectionIndex.reduce((t42, e22) => Math.max(t42, this.sections[e22].scale), 0);
+                }
+                addTextSection(t42, e22) {
+                  this.text += t42.text, this.sections.push(Ou.forText(t42.scale, t42.fontStack || e22));
+                  const r22 = this.sections.length - 1;
+                  for (let e3 = 0; e3 < t42.text.length; ++e3) this.sectionIndex.push(r22);
+                }
+                addImageSection(t42) {
+                  const e22 = t42.image ? t42.image.name : "";
+                  if (0 === e22.length) return void A22("Can't add FormattedSection with an empty image.");
+                  const r22 = this.getNextImageSectionCharCode();
+                  r22 ? (this.text += String.fromCharCode(r22), this.sections.push(Ou.forImage(e22)), this.sectionIndex.push(this.sections.length - 1)) : A22("Reached maximum number of images 6401");
+                }
+                getNextImageSectionCharCode() {
+                  return this.imageSectionID ? this.imageSectionID >= 63743 ? null : ++this.imageSectionID : (this.imageSectionID = 57344, this.imageSectionID);
+                }
+              }
+              function Ru(e22, r22, n22, i22, s22, a22, o22, l22, u22, c22, h22, p22, f22, d22, y22) {
+                const m22 = ju.fromFeature(e22, s22);
+                let g22;
+                p22 === t4.ah.vertical && m22.verticalizePunctuation();
+                const { processBidirectionalText: x22, processStyledBidirectionalText: v22 } = Ri2;
+                if (x22 && 1 === m22.sections.length) {
+                  g22 = [];
+                  const t42 = x22(m22.toString(), Yu(m22, c22, a22, r22, i22, d22));
+                  for (const e3 of t42) {
+                    const t5 = new ju();
+                    t5.text = e3, t5.sections = m22.sections;
+                    for (let r3 = 0; r3 < e3.length; r3++) t5.sectionIndex.push(0);
+                    g22.push(t5);
+                  }
+                } else if (v22) {
+                  g22 = [];
+                  const t42 = v22(m22.text, m22.sectionIndex, Yu(m22, c22, a22, r22, i22, d22));
+                  for (const e3 of t42) {
+                    const t5 = new ju();
+                    t5.text = e3[0], t5.sectionIndex = e3[1], t5.sections = m22.sections, g22.push(t5);
+                  }
+                } else g22 = function(t42, e3) {
+                  const r3 = [], n3 = t42.text;
+                  let i3 = 0;
+                  for (const n4 of e3) r3.push(t42.substring(i3, n4)), i3 = n4;
+                  return i3 < n3.length && r3.push(t42.substring(i3, n3.length)), r3;
+                }(m22, Yu(m22, c22, a22, r22, i22, d22));
+                const b22 = [], w22 = { positionedLines: b22, text: m22.toString(), top: h22[1], bottom: h22[1], left: h22[0], right: h22[0], writingMode: p22, iconsInText: false, verticalizable: false };
+                return function(e3, r3, n3, i3, s3, a3, o3, l3, u3, c3, h3, p3) {
+                  let f3 = 0, d3 = Du, y3 = 0, m3 = 0;
+                  const g3 = "right" === l3 ? 1 : "left" === l3 ? 0 : 0.5;
+                  let x3 = 0;
+                  for (const o4 of s3) {
+                    o4.trim();
+                    const s4 = o4.getMaxScale(), l4 = (s4 - 1) * iu, b4 = { positionedGlyphs: [], lineOffset: 0 };
+                    e3.positionedLines[x3] = b4;
+                    const w4 = b4.positionedGlyphs;
+                    let _3 = 0;
+                    if (!o4.length()) {
+                      d3 += a3, ++x3;
+                      continue;
+                    }
+                    for (let a4 = 0; a4 < o4.length(); a4++) {
+                      const y4 = o4.getSection(a4), m4 = o4.getSectionIndex(a4), g4 = o4.getCharCode(a4);
+                      let x4 = 0, b5 = null, A4 = null, S22 = null, k22 = iu;
+                      const M22 = !(u3 === t4.ah.horizontal || !h3 && !Ti2(g4) || h3 && (Uu[g4] || (v3 = g4, new RegExp("\\p{sc=Arab}", "u").test(String.fromCodePoint(v3)))));
+                      if (y4.imageName) {
+                        const t42 = i3[y4.imageName];
+                        if (!t42) continue;
+                        S22 = y4.imageName, e3.iconsInText = e3.iconsInText || true, A4 = t42.paddedRect;
+                        const r4 = t42.displaySize;
+                        y4.scale = y4.scale * iu / p3, b5 = { width: r4[0], height: r4[1], left: Fu, top: -3, advance: M22 ? r4[1] : r4[0] }, x4 = l4 + (iu - r4[1] * y4.scale), k22 = b5.advance;
+                        const n4 = M22 ? r4[0] * y4.scale - iu * s4 : r4[1] * y4.scale - iu * s4;
+                        n4 > 0 && n4 > _3 && (_3 = n4);
+                      } else {
+                        const t42 = n3[y4.fontStack], e4 = t42 && t42[g4];
+                        if (e4 && e4.rect) A4 = e4.rect, b5 = e4.metrics;
+                        else {
+                          const t5 = r3[y4.fontStack], e5 = t5 && t5[g4];
+                          if (!e5) continue;
+                          b5 = e5.metrics;
+                        }
+                        x4 = (s4 - y4.scale) * iu;
+                      }
+                      M22 ? (e3.verticalizable = true, w4.push({ glyph: g4, imageName: S22, x: f3, y: d3 + x4, vertical: M22, scale: y4.scale, fontStack: y4.fontStack, sectionIndex: m4, metrics: b5, rect: A4 }), f3 += k22 * y4.scale + c3) : (w4.push({ glyph: g4, imageName: S22, x: f3, y: d3 + x4, vertical: M22, scale: y4.scale, fontStack: y4.fontStack, sectionIndex: m4, metrics: b5, rect: A4 }), f3 += b5.advance * y4.scale + c3);
+                    }
+                    0 !== w4.length && (y3 = Math.max(f3 - c3, y3), Wu(w4, 0, w4.length - 1, g3, _3)), f3 = 0;
+                    const A3 = a3 * s4 + _3;
+                    b4.lineOffset = Math.max(_3, l4), d3 += A3, m3 = Math.max(A3, m3), ++x3;
+                  }
+                  var v3;
+                  const b3 = d3 - Du, { horizontalAlign: w3, verticalAlign: _22 } = Ju(o3);
+                  (function(t42, e4, r4, n4, i4, s4, a4, o4, l4) {
+                    const u4 = (e4 - r4) * i4;
+                    let c4 = 0;
+                    c4 = s4 !== a4 ? -o4 * n4 - Du : (-n4 * l4 + 0.5) * a4;
+                    for (const e5 of t42) for (const t5 of e5.positionedGlyphs) t5.x += u4, t5.y += c4;
+                  })(e3.positionedLines, g3, w3, _22, y3, m3, a3, b3, s3.length), e3.top += -_22 * b3, e3.bottom = e3.top + b3, e3.left += -w3 * y3, e3.right = e3.left + y3;
+                }(w22, r22, n22, i22, g22, o22, l22, u22, p22, c22, f22, y22), !function(t42) {
+                  for (const e3 of t42) if (0 !== e3.positionedGlyphs.length) return false;
+                  return true;
+                }(b22) && w22;
+              }
+              const Uu = { 9: true, 10: true, 11: true, 12: true, 13: true, 32: true }, qu = { 10: true, 32: true, 38: true, 41: true, 43: true, 45: true, 47: true, 173: true, 183: true, 8203: true, 8208: true, 8211: true, 8231: true }, Nu = { 40: true };
+              function Zu(t42, e22, r22, n22, i22, s22) {
+                if (e22.imageName) {
+                  const t5 = n22[e22.imageName];
+                  return t5 ? t5.displaySize[0] * e22.scale * iu / s22 + i22 : 0;
+                }
+                {
+                  const n3 = r22[e22.fontStack], s3 = n3 && n3[t42];
+                  return s3 ? s3.metrics.advance * e22.scale + i22 : 0;
+                }
+              }
+              function Gu(t42, e22, r22, n22) {
+                const i22 = Math.pow(t42 - e22, 2);
+                return n22 ? t42 < e22 ? i22 / 2 : 2 * i22 : i22 + Math.abs(r22) * r22;
+              }
+              function Ku(t42, e22, r22) {
+                let n22 = 0;
+                return 10 === t42 && (n22 -= 1e4), r22 && (n22 += 150), 40 !== t42 && 65288 !== t42 || (n22 += 50), 41 !== e22 && 65289 !== e22 || (n22 += 50), n22;
+              }
+              function Xu(t42, e22, r22, n22, i22, s22) {
+                let a22 = null, o22 = Gu(e22, r22, i22, s22);
+                for (const t5 of n22) {
+                  const n3 = Gu(e22 - t5.x, r22, i22, s22) + t5.badness;
+                  n3 <= o22 && (a22 = t5, o22 = n3);
+                }
+                return { index: t42, x: e22, priorBreak: a22, badness: o22 };
+              }
+              function Hu(t42) {
+                return t42 ? Hu(t42.priorBreak).concat(t42.index) : [];
+              }
+              function Yu(t42, e22, r22, n22, i22, s22) {
+                if (!t42) return [];
+                const a22 = [], o22 = function(t5, e3, r3, n3, i3, s3) {
+                  let a3 = 0;
+                  for (let r4 = 0; r4 < t5.length(); r4++) {
+                    const o3 = t5.getSection(r4);
+                    a3 += Zu(t5.getCharCode(r4), o3, n3, i3, e3, s3);
+                  }
+                  return a3 / Math.max(1, Math.ceil(a3 / r3));
+                }(t42, e22, r22, n22, i22, s22), l22 = t42.text.indexOf("​") >= 0;
+                let u22 = 0;
+                for (let r3 = 0; r3 < t42.length(); r3++) {
+                  const h22 = t42.getSection(r3), p22 = t42.getCharCode(r3);
+                  if (Uu[p22] || (u22 += Zu(p22, h22, n22, i22, e22, s22)), r3 < t42.length() - 1) {
+                    const e3 = !((c22 = p22) < 11904) && (!!zi2["CJK Compatibility Forms"](c22) || !!zi2["CJK Compatibility"](c22) || !!zi2["CJK Strokes"](c22) || !!zi2["CJK Symbols and Punctuation"](c22) || !!zi2["Enclosed CJK Letters and Months"](c22) || !!zi2["Halfwidth and Fullwidth Forms"](c22) || !!zi2["Ideographic Description Characters"](c22) || !!zi2["Vertical Forms"](c22) || Fi2.test(String.fromCodePoint(c22)));
+                    (qu[p22] || e3 || h22.imageName || r3 !== t42.length() - 2 && Nu[t42.getCharCode(r3 + 1)]) && a22.push(Xu(r3 + 1, u22, o22, a22, Ku(p22, t42.getCharCode(r3 + 1), e3 && l22), false));
+                  }
+                }
+                var c22;
+                return Hu(Xu(t42.length(), u22, o22, a22, 0, true));
+              }
+              function Ju(t42) {
+                let e22 = 0.5, r22 = 0.5;
+                switch (t42) {
+                  case "right":
+                  case "top-right":
+                  case "bottom-right":
+                    e22 = 1;
+                    break;
+                  case "left":
+                  case "top-left":
+                  case "bottom-left":
+                    e22 = 0;
+                }
+                switch (t42) {
+                  case "bottom":
+                  case "bottom-right":
+                  case "bottom-left":
+                    r22 = 1;
+                    break;
+                  case "top":
+                  case "top-right":
+                  case "top-left":
+                    r22 = 0;
+                }
+                return { horizontalAlign: e22, verticalAlign: r22 };
+              }
+              function Wu(t42, e22, r22, n22, i22) {
+                if (!n22 && !i22) return;
+                const s22 = t42[r22], a22 = (t42[r22].x + s22.metrics.advance * s22.scale) * n22;
+                for (let n3 = e22; n3 <= r22; n3++) t42[n3].x -= a22, t42[n3].y += i22;
+              }
+              function Qu(t42, e22, r22) {
+                const { horizontalAlign: n22, verticalAlign: i22 } = Ju(r22), s22 = e22[0] - t42.displaySize[0] * n22, a22 = e22[1] - t42.displaySize[1] * i22;
+                return { image: t42, top: a22, bottom: a22 + t42.displaySize[1], left: s22, right: s22 + t42.displaySize[0] };
+              }
+              function tc2(t42) {
+                var e22, r22;
+                let n22 = t42.left, i22 = t42.top, s22 = t42.right - n22, a22 = t42.bottom - i22;
+                const o22 = null !== (e22 = t42.image.textFitWidth) && void 0 !== e22 ? e22 : "stretchOrShrink", l22 = null !== (r22 = t42.image.textFitHeight) && void 0 !== r22 ? r22 : "stretchOrShrink", u22 = (t42.image.content[2] - t42.image.content[0]) / (t42.image.content[3] - t42.image.content[1]);
+                if ("proportional" === l22) {
+                  if ("stretchOnly" === o22 && s22 / a22 < u22 || "proportional" === o22) {
+                    const t5 = Math.ceil(a22 * u22);
+                    n22 *= t5 / s22, s22 = t5;
+                  }
+                } else if ("proportional" === o22 && "stretchOnly" === l22 && 0 !== u22 && s22 / a22 > u22) {
+                  const t5 = Math.ceil(s22 / u22);
+                  i22 *= t5 / a22, a22 = t5;
+                }
+                return { x1: n22, y1: i22, x2: n22 + s22, y2: i22 + a22 };
+              }
+              function ec2(t42, e22, r22, n22, i22, s22) {
+                const a22 = t42.image;
+                let o22;
+                if (a22.content) {
+                  const t5 = a22.content, e3 = a22.pixelRatio || 1;
+                  o22 = [t5[0] / e3, t5[1] / e3, a22.displaySize[0] - t5[2] / e3, a22.displaySize[1] - t5[3] / e3];
+                }
+                const l22 = e22.left * s22, u22 = e22.right * s22;
+                let c22, h22, p22, f22;
+                "width" === r22 || "both" === r22 ? (f22 = i22[0] + l22 - n22[3], h22 = i22[0] + u22 + n22[1]) : (f22 = i22[0] + (l22 + u22 - a22.displaySize[0]) / 2, h22 = f22 + a22.displaySize[0]);
+                const d22 = e22.top * s22, y22 = e22.bottom * s22;
+                return "height" === r22 || "both" === r22 ? (c22 = i22[1] + d22 - n22[0], p22 = i22[1] + y22 + n22[2]) : (c22 = i22[1] + (d22 + y22 - a22.displaySize[1]) / 2, p22 = c22 + a22.displaySize[1]), { image: a22, top: c22, right: h22, bottom: p22, left: f22, collisionPadding: o22 };
+              }
+              const rc2 = 255, nc2 = 128, ic2 = rc2 * nc2;
+              function sc2(t42, e22) {
+                const { expression: r22 } = e22;
+                if ("constant" === r22.kind) return { kind: "constant", layoutSize: r22.evaluate(new Ui2(t42 + 1)) };
+                if ("source" === r22.kind) return { kind: "source" };
+                {
+                  const { zoomStops: e3, interpolationType: n22 } = r22;
+                  let i22 = 0;
+                  for (; i22 < e3.length && e3[i22] <= t42; ) i22++;
+                  i22 = Math.max(0, i22 - 1);
+                  let s22 = i22;
+                  for (; s22 < e3.length && e3[s22] < t42 + 1; ) s22++;
+                  s22 = Math.min(e3.length - 1, s22);
+                  const a22 = e3[i22], o22 = e3[s22];
+                  return "composite" === r22.kind ? { kind: "composite", minZoom: a22, maxZoom: o22, interpolationType: n22 } : { kind: "camera", minZoom: a22, maxZoom: o22, minSize: r22.evaluate(new Ui2(a22)), maxSize: r22.evaluate(new Ui2(o22)), interpolationType: n22 };
+                }
+              }
+              function ac2(t42, e22, r22) {
+                let n22 = "never";
+                const i22 = t42.get(e22);
+                return i22 ? n22 = i22 : t42.get(r22) && (n22 = "always"), n22;
+              }
+              const oc2 = fl2.VectorTileFeature.types, lc2 = [{ name: "a_fade_opacity", components: 1, type: "Uint8", offset: 0 }];
+              function uc2(t42, e22, r22, n22, i22, s22, a22, o22, l22, u22, c22, h22, p22) {
+                const f22 = o22 ? Math.min(ic2, Math.round(o22[0])) : 0, d22 = o22 ? Math.min(ic2, Math.round(o22[1])) : 0;
+                t42.emplaceBack(e22, r22, Math.round(32 * n22), Math.round(32 * i22), s22, a22, (f22 << 1) + (l22 ? 1 : 0), d22, 16 * u22, 16 * c22, 256 * h22, 256 * p22);
+              }
+              function cc2(t42, e22, r22) {
+                t42.emplaceBack(e22.x, e22.y, r22), t42.emplaceBack(e22.x, e22.y, r22), t42.emplaceBack(e22.x, e22.y, r22), t42.emplaceBack(e22.x, e22.y, r22);
+              }
+              function hc2(t42) {
+                for (const e22 of t42.sections) if (ji2(e22.text)) return true;
+                return false;
+              }
+              class pc2 {
+                constructor(t42) {
+                  this.layoutVertexArray = new Ws(), this.indexArray = new na(), this.programConfigurations = t42, this.segments = new oa2(), this.dynamicLayoutVertexArray = new Qs(), this.opacityVertexArray = new ta2(), this.hasVisibleVertices = false, this.placedSymbolArray = new $s();
+                }
+                isEmpty() {
+                  return 0 === this.layoutVertexArray.length && 0 === this.indexArray.length && 0 === this.dynamicLayoutVertexArray.length && 0 === this.opacityVertexArray.length;
+                }
+                upload(t42, e22, r22, n22) {
+                  this.isEmpty() || (r22 && (this.layoutVertexBuffer = t42.createVertexBuffer(this.layoutVertexArray, Jl.members), this.indexBuffer = t42.createIndexBuffer(this.indexArray, e22), this.dynamicLayoutVertexBuffer = t42.createVertexBuffer(this.dynamicLayoutVertexArray, Wl.members, true), this.opacityVertexBuffer = t42.createVertexBuffer(this.opacityVertexArray, lc2, true), this.opacityVertexBuffer.itemSize = 1), (r22 || n22) && this.programConfigurations.upload(t42));
+                }
+                destroy() {
+                  this.layoutVertexBuffer && (this.layoutVertexBuffer.destroy(), this.indexBuffer.destroy(), this.programConfigurations.destroy(), this.segments.destroy(), this.dynamicLayoutVertexBuffer.destroy(), this.opacityVertexBuffer.destroy());
+                }
+              }
+              wi2("SymbolBuffers", pc2);
+              class fc2 {
+                constructor(t42, e22, r22) {
+                  this.layoutVertexArray = new t42(), this.layoutAttributes = e22, this.indexArray = new r22(), this.segments = new oa2(), this.collisionVertexArray = new ra2();
+                }
+                upload(t42) {
+                  this.layoutVertexBuffer = t42.createVertexBuffer(this.layoutVertexArray, this.layoutAttributes), this.indexBuffer = t42.createIndexBuffer(this.indexArray), this.collisionVertexBuffer = t42.createVertexBuffer(this.collisionVertexArray, Ql.members, true);
+                }
+                destroy() {
+                  this.layoutVertexBuffer && (this.layoutVertexBuffer.destroy(), this.indexBuffer.destroy(), this.segments.destroy(), this.collisionVertexBuffer.destroy());
+                }
+              }
+              wi2("CollisionBuffers", fc2);
+              class dc2 {
+                constructor(e22) {
+                  this.collisionBoxArray = e22.collisionBoxArray, this.zoom = e22.zoom, this.overscaling = e22.overscaling, this.layers = e22.layers, this.layerIds = this.layers.map((t42) => t42.id), this.index = e22.index, this.pixelRatio = e22.pixelRatio, this.sourceLayerIndex = e22.sourceLayerIndex, this.hasPattern = false, this.hasRTLText = false, this.sortKeyRanges = [], this.collisionCircleArray = [], this.placementInvProjMatrix = lo([]), this.placementViewportMatrix = lo([]);
+                  const r22 = this.layers[0]._unevaluatedLayout._values;
+                  this.textSizeData = sc2(this.zoom, r22["text-size"]), this.iconSizeData = sc2(this.zoom, r22["icon-size"]);
+                  const n22 = this.layers[0].layout, i22 = n22.get("symbol-sort-key"), s22 = n22.get("symbol-z-order");
+                  this.canOverlap = "never" !== ac2(n22, "text-overlap", "text-allow-overlap") || "never" !== ac2(n22, "icon-overlap", "icon-allow-overlap") || n22.get("text-ignore-placement") || n22.get("icon-ignore-placement"), this.sortFeaturesByKey = "viewport-y" !== s22 && !i22.isConstant(), this.sortFeaturesByY = ("viewport-y" === s22 || "auto" === s22 && !this.sortFeaturesByKey) && this.canOverlap, "point" === n22.get("symbol-placement") && (this.writingModes = n22.get("text-writing-mode").map((e3) => t4.ah[e3])), this.stateDependentLayerIds = this.layers.filter((t42) => t42.isStateDependent()).map((t42) => t42.id), this.sourceID = e22.sourceID;
+                }
+                createArrays() {
+                  this.text = new pc2(new Ea2(this.layers, this.zoom, (t42) => /^text/.test(t42))), this.icon = new pc2(new Ea2(this.layers, this.zoom, (t42) => /^icon/.test(t42))), this.glyphOffsetArray = new Os(), this.lineVertexArray = new js(), this.symbolInstances = new Ds(), this.textAnchorOffsets = new Us();
+                }
+                calculateGlyphDependencies(t42, e22, r22, n22, i22) {
+                  for (let s22 = 0; s22 < t42.length; s22++) if (e22[t42.charCodeAt(s22)] = true, (r22 || n22) && i22) {
+                    const r3 = nu[t42.charAt(s22)];
+                    r3 && (e22[r3.charCodeAt(0)] = true);
+                  }
+                }
+                populate(e22, r22, n22) {
+                  const i22 = this.layers[0], s22 = i22.layout, a22 = s22.get("text-font"), o22 = s22.get("text-field"), l22 = s22.get("icon-image"), u22 = ("constant" !== o22.value.kind || o22.value.value instanceof Yt && !o22.value.value.isEmpty() || o22.value.value.toString().length > 0) && ("constant" !== a22.value.kind || a22.value.value.length > 0), c22 = "constant" !== l22.value.kind || !!l22.value.value || Object.keys(l22.parameters).length > 0, h22 = s22.get("symbol-sort-key");
+                  if (this.features = [], !u22 && !c22) return;
+                  const p22 = r22.iconDependencies, f22 = r22.glyphDependencies, d22 = r22.availableImages, y22 = new Ui2(this.zoom);
+                  for (const { feature: r3, id: o3, index: l3, sourceLayerIndex: m22 } of e22) {
+                    const e3 = i22._featureFilter.needGeometry, g22 = ja2(r3, e3);
+                    if (!i22._featureFilter.filter(y22, g22, n22)) continue;
+                    let x22, v22;
+                    if (e3 || (g22.geometry = Oa2(r3)), u22) {
+                      const t42 = i22.getValueAndResolveTokens("text-field", g22, n22, d22), e4 = Yt.factory(t42), r4 = this.hasRTLText = this.hasRTLText || hc2(e4);
+                      (!r4 || "unavailable" === Ri2.getRTLTextPluginStatus() || r4 && Ri2.isParsed()) && (x22 = ru(e4, i22, g22));
+                    }
+                    if (c22) {
+                      const t42 = i22.getValueAndResolveTokens("icon-image", g22, n22, d22);
+                      v22 = t42 instanceof te2 ? t42 : te2.fromString(t42);
+                    }
+                    if (!x22 && !v22) continue;
+                    const b22 = this.sortFeaturesByKey ? h22.evaluate(g22, {}, n22) : void 0;
+                    if (this.features.push({ id: o3, text: x22, icon: v22, index: l3, sourceLayerIndex: m22, geometry: g22.geometry, properties: r3.properties, type: oc2[r3.type], sortKey: b22 }), v22 && (p22[v22.name] = true), x22) {
+                      const e4 = a22.evaluate(g22, {}, n22).join(","), r4 = "viewport" !== s22.get("text-rotation-alignment") && "point" !== s22.get("symbol-placement");
+                      this.allowVerticalPlacement = this.writingModes && this.writingModes.indexOf(t4.ah.vertical) >= 0;
+                      for (const t42 of x22.sections) if (t42.image) p22[t42.image.name] = true;
+                      else {
+                        const n3 = Pi2(x22.toString()), i3 = t42.fontStack || e4, s3 = f22[i3] = f22[i3] || {};
+                        this.calculateGlyphDependencies(t42.text, s3, r4, this.allowVerticalPlacement, n3);
+                      }
+                    }
+                  }
+                  "line" === s22.get("symbol-placement") && (this.features = function(t42) {
+                    const e3 = {}, r3 = {}, n3 = [];
+                    let i3 = 0;
+                    function s3(e4) {
+                      n3.push(t42[e4]), i3++;
+                    }
+                    function a3(t5, e4, i4) {
+                      const s4 = r3[t5];
+                      return delete r3[t5], r3[e4] = s4, n3[s4].geometry[0].pop(), n3[s4].geometry[0] = n3[s4].geometry[0].concat(i4[0]), s4;
+                    }
+                    function o3(t5, r4, i4) {
+                      const s4 = e3[r4];
+                      return delete e3[r4], e3[t5] = s4, n3[s4].geometry[0].shift(), n3[s4].geometry[0] = i4[0].concat(n3[s4].geometry[0]), s4;
+                    }
+                    function l3(t5, e4, r4) {
+                      const n4 = r4 ? e4[0][e4[0].length - 1] : e4[0][0];
+                      return `${t5}:${n4.x}:${n4.y}`;
+                    }
+                    for (let u3 = 0; u3 < t42.length; u3++) {
+                      const c3 = t42[u3], h3 = c3.geometry, p3 = c3.text ? c3.text.toString() : null;
+                      if (!p3) {
+                        s3(u3);
+                        continue;
+                      }
+                      const f3 = l3(p3, h3), d3 = l3(p3, h3, true);
+                      if (f3 in r3 && d3 in e3 && r3[f3] !== e3[d3]) {
+                        const t5 = o3(f3, d3, h3), i4 = a3(f3, d3, n3[t5].geometry);
+                        delete e3[f3], delete r3[d3], r3[l3(p3, n3[i4].geometry, true)] = i4, n3[t5].geometry = null;
+                      } else f3 in r3 ? a3(f3, d3, h3) : d3 in e3 ? o3(f3, d3, h3) : (s3(u3), e3[f3] = i3 - 1, r3[d3] = i3 - 1);
+                    }
+                    return n3.filter((t5) => t5.geometry);
+                  }(this.features)), this.sortFeaturesByKey && this.features.sort((t42, e3) => t42.sortKey - e3.sortKey);
+                }
+                update(t42, e22, r22) {
+                  this.stateDependentLayers.length && (this.text.programConfigurations.updatePaintArrays(t42, e22, this.layers, r22), this.icon.programConfigurations.updatePaintArrays(t42, e22, this.layers, r22));
+                }
+                isEmpty() {
+                  return 0 === this.symbolInstances.length && !this.hasRTLText;
+                }
+                uploadPending() {
+                  return !this.uploaded || this.text.programConfigurations.needsUpload || this.icon.programConfigurations.needsUpload;
+                }
+                upload(t42) {
+                  !this.uploaded && this.hasDebugData() && (this.textCollisionBox.upload(t42), this.iconCollisionBox.upload(t42)), this.text.upload(t42, this.sortFeaturesByY, !this.uploaded, this.text.programConfigurations.needsUpload), this.icon.upload(t42, this.sortFeaturesByY, !this.uploaded, this.icon.programConfigurations.needsUpload), this.uploaded = true;
+                }
+                destroyDebugData() {
+                  this.textCollisionBox.destroy(), this.iconCollisionBox.destroy();
+                }
+                destroy() {
+                  this.text.destroy(), this.icon.destroy(), this.hasDebugData() && this.destroyDebugData();
+                }
+                addToLineVertexArray(t42, e22) {
+                  const r22 = this.lineVertexArray.length;
+                  if (void 0 !== t42.segment) {
+                    let r3 = t42.dist(e22[t42.segment + 1]), n22 = t42.dist(e22[t42.segment]);
+                    const i22 = {};
+                    for (let n3 = t42.segment + 1; n3 < e22.length; n3++) i22[n3] = { x: e22[n3].x, y: e22[n3].y, tileUnitDistanceFromAnchor: r3 }, n3 < e22.length - 1 && (r3 += e22[n3 + 1].dist(e22[n3]));
+                    for (let r4 = t42.segment || 0; r4 >= 0; r4--) i22[r4] = { x: e22[r4].x, y: e22[r4].y, tileUnitDistanceFromAnchor: n22 }, r4 > 0 && (n22 += e22[r4 - 1].dist(e22[r4]));
+                    for (let t5 = 0; t5 < e22.length; t5++) {
+                      const e3 = i22[t5];
+                      this.lineVertexArray.emplaceBack(e3.x, e3.y, e3.tileUnitDistanceFromAnchor);
+                    }
+                  }
+                  return { lineStartIndex: r22, lineLength: this.lineVertexArray.length - r22 };
+                }
+                addSymbols(e22, r22, n22, i22, s22, a22, o22, l22, u22, c22, h22, p22) {
+                  const f22 = e22.indexArray, d22 = e22.layoutVertexArray, y22 = e22.segments.prepareSegment(4 * r22.length, d22, f22, this.canOverlap ? a22.sortKey : void 0), m22 = this.glyphOffsetArray.length, g22 = y22.vertexLength, x22 = this.allowVerticalPlacement && o22 === t4.ah.vertical ? Math.PI / 2 : 0, v22 = a22.text && a22.text.sections;
+                  for (let t42 = 0; t42 < r22.length; t42++) {
+                    const { tl: i3, tr: s3, bl: o3, br: u3, tex: c3, pixelOffsetTL: h3, pixelOffsetBR: m3, minFontScaleX: g3, minFontScaleY: b22, glyphOffset: w22, isSDF: _22, sectionIndex: A3 } = r22[t42], S22 = y22.vertexLength, k22 = w22[1];
+                    uc2(d22, l22.x, l22.y, i3.x, k22 + i3.y, c3.x, c3.y, n22, _22, h3.x, h3.y, g3, b22), uc2(d22, l22.x, l22.y, s3.x, k22 + s3.y, c3.x + c3.w, c3.y, n22, _22, m3.x, h3.y, g3, b22), uc2(d22, l22.x, l22.y, o3.x, k22 + o3.y, c3.x, c3.y + c3.h, n22, _22, h3.x, m3.y, g3, b22), uc2(d22, l22.x, l22.y, u3.x, k22 + u3.y, c3.x + c3.w, c3.y + c3.h, n22, _22, m3.x, m3.y, g3, b22), cc2(e22.dynamicLayoutVertexArray, l22, x22), f22.emplaceBack(S22, S22 + 1, S22 + 2), f22.emplaceBack(S22 + 1, S22 + 2, S22 + 3), y22.vertexLength += 4, y22.primitiveLength += 2, this.glyphOffsetArray.emplaceBack(w22[0]), t42 !== r22.length - 1 && A3 === r22[t42 + 1].sectionIndex || e22.programConfigurations.populatePaintArrays(d22.length, a22, a22.index, {}, p22, v22 && v22[A3]);
+                  }
+                  e22.placedSymbolArray.emplaceBack(l22.x, l22.y, m22, this.glyphOffsetArray.length - m22, g22, u22, c22, l22.segment, n22 ? n22[0] : 0, n22 ? n22[1] : 0, i22[0], i22[1], o22, 0, false, 0, h22);
+                }
+                _addCollisionDebugVertex(t42, e22, r22, n22, i22, s22) {
+                  return e22.emplaceBack(0, 0), t42.emplaceBack(r22.x, r22.y, n22, i22, Math.round(s22.x), Math.round(s22.y));
+                }
+                addCollisionDebugVertices(t42, e22, r22, n22, i22, a22, o22) {
+                  const l22 = i22.segments.prepareSegment(4, i22.layoutVertexArray, i22.indexArray), u22 = l22.vertexLength, c22 = i22.layoutVertexArray, h22 = i22.collisionVertexArray, p22 = o22.anchorX, f22 = o22.anchorY;
+                  this._addCollisionDebugVertex(c22, h22, a22, p22, f22, new s2(t42, e22)), this._addCollisionDebugVertex(c22, h22, a22, p22, f22, new s2(r22, e22)), this._addCollisionDebugVertex(c22, h22, a22, p22, f22, new s2(r22, n22)), this._addCollisionDebugVertex(c22, h22, a22, p22, f22, new s2(t42, n22)), l22.vertexLength += 4;
+                  const d22 = i22.indexArray;
+                  d22.emplaceBack(u22, u22 + 1), d22.emplaceBack(u22 + 1, u22 + 2), d22.emplaceBack(u22 + 2, u22 + 3), d22.emplaceBack(u22 + 3, u22), l22.primitiveLength += 4;
+                }
+                addDebugCollisionBoxes(t42, e22, r22, n22) {
+                  for (let i22 = t42; i22 < e22; i22++) {
+                    const t5 = this.collisionBoxArray.get(i22);
+                    this.addCollisionDebugVertices(t5.x1, t5.y1, t5.x2, t5.y2, n22 ? this.textCollisionBox : this.iconCollisionBox, t5.anchorPoint, r22);
+                  }
+                }
+                generateCollisionDebugBuffers() {
+                  this.hasDebugData() && this.destroyDebugData(), this.textCollisionBox = new fc2(ea2, tu.members, ia2), this.iconCollisionBox = new fc2(ea2, tu.members, ia2);
+                  for (let t42 = 0; t42 < this.symbolInstances.length; t42++) {
+                    const e22 = this.symbolInstances.get(t42);
+                    this.addDebugCollisionBoxes(e22.textBoxStartIndex, e22.textBoxEndIndex, e22, true), this.addDebugCollisionBoxes(e22.verticalTextBoxStartIndex, e22.verticalTextBoxEndIndex, e22, true), this.addDebugCollisionBoxes(e22.iconBoxStartIndex, e22.iconBoxEndIndex, e22, false), this.addDebugCollisionBoxes(e22.verticalIconBoxStartIndex, e22.verticalIconBoxEndIndex, e22, false);
+                  }
+                }
+                _deserializeCollisionBoxesForSymbol(t42, e22, r22, n22, i22, s22, a22, o22, l22) {
+                  const u22 = {};
+                  for (let n3 = e22; n3 < r22; n3++) {
+                    const e3 = t42.get(n3);
+                    u22.textBox = { x1: e3.x1, y1: e3.y1, x2: e3.x2, y2: e3.y2, anchorPointX: e3.anchorPointX, anchorPointY: e3.anchorPointY }, u22.textFeatureIndex = e3.featureIndex;
+                    break;
+                  }
+                  for (let e3 = n22; e3 < i22; e3++) {
+                    const r3 = t42.get(e3);
+                    u22.verticalTextBox = { x1: r3.x1, y1: r3.y1, x2: r3.x2, y2: r3.y2, anchorPointX: r3.anchorPointX, anchorPointY: r3.anchorPointY }, u22.verticalTextFeatureIndex = r3.featureIndex;
+                    break;
+                  }
+                  for (let e3 = s22; e3 < a22; e3++) {
+                    const r3 = t42.get(e3);
+                    u22.iconBox = { x1: r3.x1, y1: r3.y1, x2: r3.x2, y2: r3.y2, anchorPointX: r3.anchorPointX, anchorPointY: r3.anchorPointY }, u22.iconFeatureIndex = r3.featureIndex;
+                    break;
+                  }
+                  for (let e3 = o22; e3 < l22; e3++) {
+                    const r3 = t42.get(e3);
+                    u22.verticalIconBox = { x1: r3.x1, y1: r3.y1, x2: r3.x2, y2: r3.y2, anchorPointX: r3.anchorPointX, anchorPointY: r3.anchorPointY }, u22.verticalIconFeatureIndex = r3.featureIndex;
+                    break;
+                  }
+                  return u22;
+                }
+                deserializeCollisionBoxes(t42) {
+                  this.collisionArrays = [];
+                  for (let e22 = 0; e22 < this.symbolInstances.length; e22++) {
+                    const r22 = this.symbolInstances.get(e22);
+                    this.collisionArrays.push(this._deserializeCollisionBoxesForSymbol(t42, r22.textBoxStartIndex, r22.textBoxEndIndex, r22.verticalTextBoxStartIndex, r22.verticalTextBoxEndIndex, r22.iconBoxStartIndex, r22.iconBoxEndIndex, r22.verticalIconBoxStartIndex, r22.verticalIconBoxEndIndex));
+                  }
+                }
+                hasTextData() {
+                  return this.text.segments.get().length > 0;
+                }
+                hasIconData() {
+                  return this.icon.segments.get().length > 0;
+                }
+                hasDebugData() {
+                  return this.textCollisionBox && this.iconCollisionBox;
+                }
+                hasTextCollisionBoxData() {
+                  return this.hasDebugData() && this.textCollisionBox.segments.get().length > 0;
+                }
+                hasIconCollisionBoxData() {
+                  return this.hasDebugData() && this.iconCollisionBox.segments.get().length > 0;
+                }
+                addIndicesForPlacedSymbol(t42, e22) {
+                  const r22 = t42.placedSymbolArray.get(e22), n22 = r22.vertexStartIndex + 4 * r22.numGlyphs;
+                  for (let e3 = r22.vertexStartIndex; e3 < n22; e3 += 4) t42.indexArray.emplaceBack(e3, e3 + 1, e3 + 2), t42.indexArray.emplaceBack(e3 + 1, e3 + 2, e3 + 3);
+                }
+                getSortedSymbolIndexes(t42) {
+                  if (this.sortedAngle === t42 && void 0 !== this.symbolInstanceIndexes) return this.symbolInstanceIndexes;
+                  const e22 = Math.sin(t42), r22 = Math.cos(t42), n22 = [], i22 = [], s22 = [];
+                  for (let t5 = 0; t5 < this.symbolInstances.length; ++t5) {
+                    s22.push(t5);
+                    const a22 = this.symbolInstances.get(t5);
+                    n22.push(0 | Math.round(e22 * a22.anchorX + r22 * a22.anchorY)), i22.push(a22.featureIndex);
+                  }
+                  return s22.sort((t5, e3) => n22[t5] - n22[e3] || i22[e3] - i22[t5]), s22;
+                }
+                addToSortKeyRanges(t42, e22) {
+                  const r22 = this.sortKeyRanges[this.sortKeyRanges.length - 1];
+                  r22 && r22.sortKey === e22 ? r22.symbolInstanceEnd = t42 + 1 : this.sortKeyRanges.push({ sortKey: e22, symbolInstanceStart: t42, symbolInstanceEnd: t42 + 1 });
+                }
+                sortFeatures(t42) {
+                  if (this.sortFeaturesByY && this.sortedAngle !== t42 && !(this.text.segments.get().length > 1 || this.icon.segments.get().length > 1)) {
+                    this.symbolInstanceIndexes = this.getSortedSymbolIndexes(t42), this.sortedAngle = t42, this.text.indexArray.clear(), this.icon.indexArray.clear(), this.featureSortOrder = [];
+                    for (const t5 of this.symbolInstanceIndexes) {
+                      const e22 = this.symbolInstances.get(t5);
+                      this.featureSortOrder.push(e22.featureIndex), [e22.rightJustifiedTextSymbolIndex, e22.centerJustifiedTextSymbolIndex, e22.leftJustifiedTextSymbolIndex].forEach((t6, e3, r22) => {
+                        t6 >= 0 && r22.indexOf(t6) === e3 && this.addIndicesForPlacedSymbol(this.text, t6);
+                      }), e22.verticalPlacedTextSymbolIndex >= 0 && this.addIndicesForPlacedSymbol(this.text, e22.verticalPlacedTextSymbolIndex), e22.placedIconSymbolIndex >= 0 && this.addIndicesForPlacedSymbol(this.icon, e22.placedIconSymbolIndex), e22.verticalPlacedIconSymbolIndex >= 0 && this.addIndicesForPlacedSymbol(this.icon, e22.verticalPlacedIconSymbolIndex);
+                    }
+                    this.text.indexBuffer && this.text.indexBuffer.updateData(this.text.indexArray), this.icon.indexBuffer && this.icon.indexBuffer.updateData(this.icon.indexArray);
+                  }
+                }
+              }
+              let yc2, mc2;
+              wi2("SymbolBucket", dc2, { omit: ["layers", "collisionBoxArray", "features", "compareText"] }), dc2.MAX_GLYPHS = 65535, dc2.addDynamicAttributes = cc2;
+              var gc2 = { get paint() {
+                return mc2 = mc2 || new rs({ "icon-opacity": new Wi2(G2.paint_symbol["icon-opacity"]), "icon-color": new Wi2(G2.paint_symbol["icon-color"]), "icon-halo-color": new Wi2(G2.paint_symbol["icon-halo-color"]), "icon-halo-width": new Wi2(G2.paint_symbol["icon-halo-width"]), "icon-halo-blur": new Wi2(G2.paint_symbol["icon-halo-blur"]), "icon-translate": new Ji2(G2.paint_symbol["icon-translate"]), "icon-translate-anchor": new Ji2(G2.paint_symbol["icon-translate-anchor"]), "text-opacity": new Wi2(G2.paint_symbol["text-opacity"]), "text-color": new Wi2(G2.paint_symbol["text-color"], { runtimeType: pt2, getOverride: (t42) => t42.textColor, hasOverride: (t42) => !!t42.textColor }), "text-halo-color": new Wi2(G2.paint_symbol["text-halo-color"]), "text-halo-width": new Wi2(G2.paint_symbol["text-halo-width"]), "text-halo-blur": new Wi2(G2.paint_symbol["text-halo-blur"]), "text-translate": new Ji2(G2.paint_symbol["text-translate"]), "text-translate-anchor": new Ji2(G2.paint_symbol["text-translate-anchor"]) });
+              }, get layout() {
+                return yc2 = yc2 || new rs({ "symbol-placement": new Ji2(G2.layout_symbol["symbol-placement"]), "symbol-spacing": new Ji2(G2.layout_symbol["symbol-spacing"]), "symbol-avoid-edges": new Ji2(G2.layout_symbol["symbol-avoid-edges"]), "symbol-sort-key": new Wi2(G2.layout_symbol["symbol-sort-key"]), "symbol-z-order": new Ji2(G2.layout_symbol["symbol-z-order"]), "icon-allow-overlap": new Ji2(G2.layout_symbol["icon-allow-overlap"]), "icon-overlap": new Ji2(G2.layout_symbol["icon-overlap"]), "icon-ignore-placement": new Ji2(G2.layout_symbol["icon-ignore-placement"]), "icon-optional": new Ji2(G2.layout_symbol["icon-optional"]), "icon-rotation-alignment": new Ji2(G2.layout_symbol["icon-rotation-alignment"]), "icon-size": new Wi2(G2.layout_symbol["icon-size"]), "icon-text-fit": new Ji2(G2.layout_symbol["icon-text-fit"]), "icon-text-fit-padding": new Ji2(G2.layout_symbol["icon-text-fit-padding"]), "icon-image": new Wi2(G2.layout_symbol["icon-image"]), "icon-rotate": new Wi2(G2.layout_symbol["icon-rotate"]), "icon-padding": new Wi2(G2.layout_symbol["icon-padding"]), "icon-keep-upright": new Ji2(G2.layout_symbol["icon-keep-upright"]), "icon-offset": new Wi2(G2.layout_symbol["icon-offset"]), "icon-anchor": new Wi2(G2.layout_symbol["icon-anchor"]), "icon-pitch-alignment": new Ji2(G2.layout_symbol["icon-pitch-alignment"]), "text-pitch-alignment": new Ji2(G2.layout_symbol["text-pitch-alignment"]), "text-rotation-alignment": new Ji2(G2.layout_symbol["text-rotation-alignment"]), "text-field": new Wi2(G2.layout_symbol["text-field"]), "text-font": new Wi2(G2.layout_symbol["text-font"]), "text-size": new Wi2(G2.layout_symbol["text-size"]), "text-max-width": new Wi2(G2.layout_symbol["text-max-width"]), "text-line-height": new Ji2(G2.layout_symbol["text-line-height"]), "text-letter-spacing": new Wi2(G2.layout_symbol["text-letter-spacing"]), "text-justify": new Wi2(G2.layout_symbol["text-justify"]), "text-radial-offset": new Wi2(G2.layout_symbol["text-radial-offset"]), "text-variable-anchor": new Ji2(G2.layout_symbol["text-variable-anchor"]), "text-variable-anchor-offset": new Wi2(G2.layout_symbol["text-variable-anchor-offset"]), "text-anchor": new Wi2(G2.layout_symbol["text-anchor"]), "text-max-angle": new Ji2(G2.layout_symbol["text-max-angle"]), "text-writing-mode": new Ji2(G2.layout_symbol["text-writing-mode"]), "text-rotate": new Wi2(G2.layout_symbol["text-rotate"]), "text-padding": new Ji2(G2.layout_symbol["text-padding"]), "text-keep-upright": new Ji2(G2.layout_symbol["text-keep-upright"]), "text-transform": new Wi2(G2.layout_symbol["text-transform"]), "text-offset": new Wi2(G2.layout_symbol["text-offset"]), "text-allow-overlap": new Ji2(G2.layout_symbol["text-allow-overlap"]), "text-overlap": new Ji2(G2.layout_symbol["text-overlap"]), "text-ignore-placement": new Ji2(G2.layout_symbol["text-ignore-placement"]), "text-optional": new Ji2(G2.layout_symbol["text-optional"]) });
+              } };
+              class xc2 {
+                constructor(t42) {
+                  if (void 0 === t42.property.overrides) throw new Error("overrides must be provided to instantiate FormatSectionOverride class");
+                  this.type = t42.property.overrides ? t42.property.overrides.runtimeType : lt2, this.defaultValue = t42;
+                }
+                evaluate(t42) {
+                  if (t42.formattedSection) {
+                    const e22 = this.defaultValue.property.overrides;
+                    if (e22 && e22.hasOverride(t42.formattedSection)) return e22.getOverride(t42.formattedSection);
+                  }
+                  return t42.feature && t42.featureState ? this.defaultValue.evaluate(t42.feature, t42.featureState) : this.defaultValue.property.specification.default;
+                }
+                eachChild(t42) {
+                  this.defaultValue.isConstant() || t42(this.defaultValue.value._styleExpression.expression);
+                }
+                outputDefined() {
+                  return false;
+                }
+                serialize() {
+                  return null;
+                }
+              }
+              wi2("FormatSectionOverride", xc2, { omit: ["defaultValue"] });
+              class vc2 extends is {
+                constructor(t42) {
+                  super(t42, gc2);
+                }
+                recalculate(t42, e22) {
+                  if (super.recalculate(t42, e22), "auto" === this.layout.get("icon-rotation-alignment") && (this.layout._values["icon-rotation-alignment"] = "point" !== this.layout.get("symbol-placement") ? "map" : "viewport"), "auto" === this.layout.get("text-rotation-alignment") && (this.layout._values["text-rotation-alignment"] = "point" !== this.layout.get("symbol-placement") ? "map" : "viewport"), "auto" === this.layout.get("text-pitch-alignment") && (this.layout._values["text-pitch-alignment"] = "map" === this.layout.get("text-rotation-alignment") ? "map" : "viewport"), "auto" === this.layout.get("icon-pitch-alignment") && (this.layout._values["icon-pitch-alignment"] = this.layout.get("icon-rotation-alignment")), "point" === this.layout.get("symbol-placement")) {
+                    const t5 = this.layout.get("text-writing-mode");
+                    if (t5) {
+                      const e3 = [];
+                      for (const r22 of t5) e3.indexOf(r22) < 0 && e3.push(r22);
+                      this.layout._values["text-writing-mode"] = e3;
+                    } else this.layout._values["text-writing-mode"] = ["horizontal"];
+                  }
+                  this._setPaintOverrides();
+                }
+                getValueAndResolveTokens(t42, e22, r22, n22) {
+                  const i22 = this.layout.get(t42).evaluate(e22, {}, r22, n22), s22 = this._unevaluatedLayout._values[t42];
+                  return s22.isDataDriven() || vn(s22.value) || !i22 ? i22 : function(t5, e3) {
+                    return e3.replace(/{([^{}]+)}/g, (e4, r3) => t5 && r3 in t5 ? String(t5[r3]) : "");
+                  }(e22.properties, i22);
+                }
+                createBucket(t42) {
+                  return new dc2(t42);
+                }
+                queryRadius() {
+                  return 0;
+                }
+                queryIntersectsFeature() {
+                  throw new Error("Should take a different path in FeatureIndex");
+                }
+                _setPaintOverrides() {
+                  for (const t42 of gc2.paint.overridableProperties) {
+                    if (!vc2.hasPaintOverride(this.layout, t42)) continue;
+                    const e22 = this.paint.get(t42), r22 = new xc2(e22), n22 = new xn(r22, e22.property.specification);
+                    let i22 = null;
+                    i22 = "constant" === e22.value.kind || "source" === e22.value.kind ? new wn("source", n22) : new _n("composite", n22, e22.value.zoomStops), this.paint._values[t42] = new Hi2(e22.property, i22, e22.parameters);
+                  }
+                }
+                _handleOverridablePaintPropertyUpdate(t42, e22, r22) {
+                  return !(!this.layout || e22.isDataDriven() || r22.isDataDriven()) && vc2.hasPaintOverride(this.layout, t42);
+                }
+                static hasPaintOverride(t42, e22) {
+                  const r22 = t42.get("text-field"), n22 = gc2.paint.properties[e22];
+                  let i22 = false;
+                  const s22 = (t5) => {
+                    for (const e3 of t5) if (n22.overrides && n22.overrides.hasOverride(e3)) return void (i22 = true);
+                  };
+                  if ("constant" === r22.value.kind && r22.value.value instanceof Yt) s22(r22.value.value.sections);
+                  else if ("source" === r22.value.kind) {
+                    const t5 = (e4) => {
+                      i22 || (e4 instanceof se2 && ne2(e4.value) === mt2 ? s22(e4.value.sections) : e4 instanceof Ze2 ? s22(e4.sections) : e4.eachChild(t5));
+                    }, e3 = r22.value;
+                    e3._styleExpression && t5(e3._styleExpression.expression);
+                  }
+                  return i22;
+                }
+              }
+              let bc2;
+              var wc2 = { get paint() {
+                return bc2 = bc2 || new rs({ "background-color": new Ji2(G2.paint_background["background-color"]), "background-pattern": new ts(G2.paint_background["background-pattern"]), "background-opacity": new Ji2(G2.paint_background["background-opacity"]) });
+              } };
+              class _c3 extends is {
+                constructor(t42) {
+                  super(t42, wc2);
+                }
+              }
+              let Ac2;
+              var Sc2 = { get paint() {
+                return Ac2 = Ac2 || new rs({ "raster-opacity": new Ji2(G2.paint_raster["raster-opacity"]), "raster-hue-rotate": new Ji2(G2.paint_raster["raster-hue-rotate"]), "raster-brightness-min": new Ji2(G2.paint_raster["raster-brightness-min"]), "raster-brightness-max": new Ji2(G2.paint_raster["raster-brightness-max"]), "raster-saturation": new Ji2(G2.paint_raster["raster-saturation"]), "raster-contrast": new Ji2(G2.paint_raster["raster-contrast"]), "raster-resampling": new Ji2(G2.paint_raster["raster-resampling"]), "raster-fade-duration": new Ji2(G2.paint_raster["raster-fade-duration"]) });
+              } };
+              class kc2 extends is {
+                constructor(t42) {
+                  super(t42, Sc2);
+                }
+              }
+              class Mc2 extends is {
+                constructor(t42) {
+                  super(t42, {}), this.onAdd = (t5) => {
+                    this.implementation.onAdd && this.implementation.onAdd(t5, t5.painter.context.gl);
+                  }, this.onRemove = (t5) => {
+                    this.implementation.onRemove && this.implementation.onRemove(t5, t5.painter.context.gl);
+                  }, this.implementation = t42;
+                }
+                is3D() {
+                  return "3d" === this.implementation.renderingMode;
+                }
+                hasOffscreenPass() {
+                  return void 0 !== this.implementation.prerender;
+                }
+                recalculate() {
+                }
+                updateTransitions() {
+                }
+                hasTransition() {
+                  return false;
+                }
+                serialize() {
+                  throw new Error("Custom layers cannot be serialized");
+                }
+              }
+              class Ic2 {
+                constructor(t42) {
+                  this._methodToThrottle = t42, this._triggered = false, "undefined" != typeof MessageChannel && (this._channel = new MessageChannel(), this._channel.port2.onmessage = () => {
+                    this._triggered = false, this._methodToThrottle();
+                  });
+                }
+                trigger() {
+                  this._triggered || (this._triggered = true, this._channel ? this._channel.port1.postMessage(true) : setTimeout(() => {
+                    this._triggered = false, this._methodToThrottle();
+                  }, 0));
+                }
+                remove() {
+                  delete this._channel, this._methodToThrottle = () => {
+                  };
+                }
+              }
+              const zc2 = 63710088e-1;
+              class Pc2 {
+                constructor(t42, e22) {
+                  if (isNaN(t42) || isNaN(e22)) throw new Error(`Invalid LngLat object: (${t42}, ${e22})`);
+                  if (this.lng = +t42, this.lat = +e22, this.lat > 90 || this.lat < -90) throw new Error("Invalid LngLat latitude value: must be between -90 and 90");
+                }
+                wrap() {
+                  return new Pc2(m2(this.lng, -180, 180), this.lat);
+                }
+                toArray() {
+                  return [this.lng, this.lat];
+                }
+                toString() {
+                  return `LngLat(${this.lng}, ${this.lat})`;
+                }
+                distanceTo(t42) {
+                  const e22 = Math.PI / 180, r22 = this.lat * e22, n22 = t42.lat * e22, i22 = Math.sin(r22) * Math.sin(n22) + Math.cos(r22) * Math.cos(n22) * Math.cos((t42.lng - this.lng) * e22);
+                  return zc2 * Math.acos(Math.min(i22, 1));
+                }
+                static convert(t42) {
+                  if (t42 instanceof Pc2) return t42;
+                  if (Array.isArray(t42) && (2 === t42.length || 3 === t42.length)) return new Pc2(Number(t42[0]), Number(t42[1]));
+                  if (!Array.isArray(t42) && "object" == typeof t42 && null !== t42) return new Pc2(Number("lng" in t42 ? t42.lng : t42.lon), Number(t42.lat));
+                  throw new Error("`LngLatLike` argument must be specified as a LngLat instance, an object {lng: <lng>, lat: <lat>}, an object {lon: <lng>, lat: <lat>}, or an array of [<lng>, <lat>]");
+                }
+              }
+              const Cc2 = 2 * Math.PI * zc2;
+              function Bc2(t42) {
+                return Cc2 * Math.cos(t42 * Math.PI / 180);
+              }
+              function Vc2(t42) {
+                return (180 + t42) / 360;
+              }
+              function Ec2(t42) {
+                return (180 - 180 / Math.PI * Math.log(Math.tan(Math.PI / 4 + t42 * Math.PI / 360))) / 360;
+              }
+              function Fc2(t42, e22) {
+                return t42 / Bc2(e22);
+              }
+              function Tc2(t42) {
+                return 360 / Math.PI * Math.atan(Math.exp((180 - 360 * t42) * Math.PI / 180)) - 90;
+              }
+              class $c2 {
+                constructor(t42, e22, r22 = 0) {
+                  this.x = +t42, this.y = +e22, this.z = +r22;
+                }
+                static fromLngLat(t42, e22 = 0) {
+                  const r22 = Pc2.convert(t42);
+                  return new $c2(Vc2(r22.lng), Ec2(r22.lat), Fc2(e22, r22.lat));
+                }
+                toLngLat() {
+                  return new Pc2(360 * this.x - 180, Tc2(this.y));
+                }
+                toAltitude() {
+                  return this.z * Bc2(Tc2(this.y));
+                }
+                meterInMercatorCoordinateUnits() {
+                  return 1 / Cc2 * (t42 = Tc2(this.y), 1 / Math.cos(t42 * Math.PI / 180));
+                  var t42;
+                }
+              }
+              function Lc2(t42, e22, r22) {
+                var n22 = 2 * Math.PI * 6378137 / 256 / Math.pow(2, r22);
+                return [t42 * n22 - 2 * Math.PI * 6378137 / 2, e22 * n22 - 2 * Math.PI * 6378137 / 2];
+              }
+              class Dc2 {
+                constructor(t42, e22, r22) {
+                  if (!function(t5, e3, r3) {
+                    return !(t5 < 0 || t5 > 25 || r3 < 0 || r3 >= Math.pow(2, t5) || e3 < 0 || e3 >= Math.pow(2, t5));
+                  }(t42, e22, r22)) throw new Error(`x=${e22}, y=${r22}, z=${t42} outside of bounds. 0<=x<${Math.pow(2, t42)}, 0<=y<${Math.pow(2, t42)} 0<=z<=25 `);
+                  this.z = t42, this.x = e22, this.y = r22, this.key = Rc2(0, t42, t42, e22, r22);
+                }
+                equals(t42) {
+                  return this.z === t42.z && this.x === t42.x && this.y === t42.y;
+                }
+                url(t42, e22, r22) {
+                  const n22 = (s22 = this.y, a22 = this.z, o22 = Lc2(256 * (i22 = this.x), 256 * (s22 = Math.pow(2, a22) - s22 - 1), a22), l22 = Lc2(256 * (i22 + 1), 256 * (s22 + 1), a22), o22[0] + "," + o22[1] + "," + l22[0] + "," + l22[1]);
+                  var i22, s22, a22, o22, l22;
+                  const u22 = function(t5, e3, r3) {
+                    let n3, i3 = "";
+                    for (let s3 = t5; s3 > 0; s3--) n3 = 1 << s3 - 1, i3 += (e3 & n3 ? 1 : 0) + (r3 & n3 ? 2 : 0);
+                    return i3;
+                  }(this.z, this.x, this.y);
+                  return t42[(this.x + this.y) % t42.length].replace(/{prefix}/g, (this.x % 16).toString(16) + (this.y % 16).toString(16)).replace(/{z}/g, String(this.z)).replace(/{x}/g, String(this.x)).replace(/{y}/g, String("tms" === r22 ? Math.pow(2, this.z) - this.y - 1 : this.y)).replace(/{ratio}/g, e22 > 1 ? "@2x" : "").replace(/{quadkey}/g, u22).replace(/{bbox-epsg-3857}/g, n22);
+                }
+                isChildOf(t42) {
+                  const e22 = this.z - t42.z;
+                  return e22 > 0 && t42.x === this.x >> e22 && t42.y === this.y >> e22;
+                }
+                getTilePoint(t42) {
+                  const e22 = Math.pow(2, this.z);
+                  return new s2((t42.x * e22 - this.x) * $a, (t42.y * e22 - this.y) * $a);
+                }
+                toString() {
+                  return `${this.z}/${this.x}/${this.y}`;
+                }
+              }
+              class Oc2 {
+                constructor(t42, e22) {
+                  this.wrap = t42, this.canonical = e22, this.key = Rc2(t42, e22.z, e22.z, e22.x, e22.y);
+                }
+              }
+              class jc2 {
+                constructor(t42, e22, r22, n22, i22) {
+                  if (t42 < r22) throw new Error(`overscaledZ should be >= z; overscaledZ = ${t42}; z = ${r22}`);
+                  this.overscaledZ = t42, this.wrap = e22, this.canonical = new Dc2(r22, +n22, +i22), this.key = Rc2(e22, t42, r22, n22, i22);
+                }
+                clone() {
+                  return new jc2(this.overscaledZ, this.wrap, this.canonical.z, this.canonical.x, this.canonical.y);
+                }
+                equals(t42) {
+                  return this.overscaledZ === t42.overscaledZ && this.wrap === t42.wrap && this.canonical.equals(t42.canonical);
+                }
+                scaledTo(t42) {
+                  if (t42 > this.overscaledZ) throw new Error(`targetZ > this.overscaledZ; targetZ = ${t42}; overscaledZ = ${this.overscaledZ}`);
+                  const e22 = this.canonical.z - t42;
+                  return t42 > this.canonical.z ? new jc2(t42, this.wrap, this.canonical.z, this.canonical.x, this.canonical.y) : new jc2(t42, this.wrap, t42, this.canonical.x >> e22, this.canonical.y >> e22);
+                }
+                calculateScaledKey(t42, e22) {
+                  if (t42 > this.overscaledZ) throw new Error(`targetZ > this.overscaledZ; targetZ = ${t42}; overscaledZ = ${this.overscaledZ}`);
+                  const r22 = this.canonical.z - t42;
+                  return t42 > this.canonical.z ? Rc2(this.wrap * +e22, t42, this.canonical.z, this.canonical.x, this.canonical.y) : Rc2(this.wrap * +e22, t42, t42, this.canonical.x >> r22, this.canonical.y >> r22);
+                }
+                isChildOf(t42) {
+                  if (t42.wrap !== this.wrap) return false;
+                  const e22 = this.canonical.z - t42.canonical.z;
+                  return 0 === t42.overscaledZ || t42.overscaledZ < this.overscaledZ && t42.canonical.x === this.canonical.x >> e22 && t42.canonical.y === this.canonical.y >> e22;
+                }
+                children(t42) {
+                  if (this.overscaledZ >= t42) return [new jc2(this.overscaledZ + 1, this.wrap, this.canonical.z, this.canonical.x, this.canonical.y)];
+                  const e22 = this.canonical.z + 1, r22 = 2 * this.canonical.x, n22 = 2 * this.canonical.y;
+                  return [new jc2(e22, this.wrap, e22, r22, n22), new jc2(e22, this.wrap, e22, r22 + 1, n22), new jc2(e22, this.wrap, e22, r22, n22 + 1), new jc2(e22, this.wrap, e22, r22 + 1, n22 + 1)];
+                }
+                isLessThan(t42) {
+                  return this.wrap < t42.wrap || !(this.wrap > t42.wrap) && (this.overscaledZ < t42.overscaledZ || !(this.overscaledZ > t42.overscaledZ) && (this.canonical.x < t42.canonical.x || !(this.canonical.x > t42.canonical.x) && this.canonical.y < t42.canonical.y));
+                }
+                wrapped() {
+                  return new jc2(this.overscaledZ, 0, this.canonical.z, this.canonical.x, this.canonical.y);
+                }
+                unwrapTo(t42) {
+                  return new jc2(this.overscaledZ, t42, this.canonical.z, this.canonical.x, this.canonical.y);
+                }
+                overscaleFactor() {
+                  return Math.pow(2, this.overscaledZ - this.canonical.z);
+                }
+                toUnwrapped() {
+                  return new Oc2(this.wrap, this.canonical);
+                }
+                toString() {
+                  return `${this.overscaledZ}/${this.canonical.x}/${this.canonical.y}`;
+                }
+                getTilePoint(t42) {
+                  return this.canonical.getTilePoint(new $c2(t42.x - this.wrap, t42.y));
+                }
+              }
+              function Rc2(t42, e22, r22, n22, i22) {
+                (t42 *= 2) < 0 && (t42 = -1 * t42 - 1);
+                const s22 = 1 << r22;
+                return (s22 * s22 * t42 + s22 * i22 + n22).toString(36) + r22.toString(36) + e22.toString(36);
+              }
+              wi2("CanonicalTileID", Dc2), wi2("OverscaledTileID", jc2, { omit: ["posMatrix"] });
+              class Uc2 {
+                constructor(t42, e22, r22, n22 = 1, i22 = 1, s22 = 1, a22 = 0) {
+                  if (this.uid = t42, e22.height !== e22.width) throw new RangeError("DEM tiles must be square");
+                  if (r22 && !["mapbox", "terrarium", "custom"].includes(r22)) return void A22(`"${r22}" is not a valid encoding type. Valid types include "mapbox", "terrarium" and "custom".`);
+                  this.stride = e22.height;
+                  const o22 = this.dim = e22.height - 2;
+                  switch (this.data = new Uint32Array(e22.data.buffer), r22) {
+                    case "terrarium":
+                      this.redFactor = 256, this.greenFactor = 1, this.blueFactor = 1 / 256, this.baseShift = 32768;
+                      break;
+                    case "custom":
+                      this.redFactor = n22, this.greenFactor = i22, this.blueFactor = s22, this.baseShift = a22;
+                      break;
+                    default:
+                      this.redFactor = 6553.6, this.greenFactor = 25.6, this.blueFactor = 0.1, this.baseShift = 1e4;
+                  }
+                  for (let t5 = 0; t5 < o22; t5++) this.data[this._idx(-1, t5)] = this.data[this._idx(0, t5)], this.data[this._idx(o22, t5)] = this.data[this._idx(o22 - 1, t5)], this.data[this._idx(t5, -1)] = this.data[this._idx(t5, 0)], this.data[this._idx(t5, o22)] = this.data[this._idx(t5, o22 - 1)];
+                  this.data[this._idx(-1, -1)] = this.data[this._idx(0, 0)], this.data[this._idx(o22, -1)] = this.data[this._idx(o22 - 1, 0)], this.data[this._idx(-1, o22)] = this.data[this._idx(0, o22 - 1)], this.data[this._idx(o22, o22)] = this.data[this._idx(o22 - 1, o22 - 1)], this.min = Number.MAX_SAFE_INTEGER, this.max = Number.MIN_SAFE_INTEGER;
+                  for (let t5 = 0; t5 < o22; t5++) for (let e3 = 0; e3 < o22; e3++) {
+                    const r3 = this.get(t5, e3);
+                    r3 > this.max && (this.max = r3), r3 < this.min && (this.min = r3);
+                  }
+                }
+                get(t42, e22) {
+                  const r22 = new Uint8Array(this.data.buffer), n22 = 4 * this._idx(t42, e22);
+                  return this.unpack(r22[n22], r22[n22 + 1], r22[n22 + 2]);
+                }
+                getUnpackVector() {
+                  return [this.redFactor, this.greenFactor, this.blueFactor, this.baseShift];
+                }
+                _idx(t42, e22) {
+                  if (t42 < -1 || t42 >= this.dim + 1 || e22 < -1 || e22 >= this.dim + 1) throw new RangeError("out of range source coordinates for DEM data");
+                  return (e22 + 1) * this.stride + (t42 + 1);
+                }
+                unpack(t42, e22, r22) {
+                  return t42 * this.redFactor + e22 * this.greenFactor + r22 * this.blueFactor - this.baseShift;
+                }
+                getPixels() {
+                  return new Ao({ width: this.stride, height: this.stride }, new Uint8Array(this.data.buffer));
+                }
+                backfillBorder(t42, e22, r22) {
+                  if (this.dim !== t42.dim) throw new Error("dem dimension mismatch");
+                  let n22 = e22 * this.dim, i22 = e22 * this.dim + this.dim, s22 = r22 * this.dim, a22 = r22 * this.dim + this.dim;
+                  switch (e22) {
+                    case -1:
+                      n22 = i22 - 1;
+                      break;
+                    case 1:
+                      i22 = n22 + 1;
+                  }
+                  switch (r22) {
+                    case -1:
+                      s22 = a22 - 1;
+                      break;
+                    case 1:
+                      a22 = s22 + 1;
+                  }
+                  const o22 = -e22 * this.dim, l22 = -r22 * this.dim;
+                  for (let e3 = s22; e3 < a22; e3++) for (let r3 = n22; r3 < i22; r3++) this.data[this._idx(r3, e3)] = t42.data[this._idx(r3 + o22, e3 + l22)];
+                }
+              }
+              wi2("DEMData", Uc2);
+              class qc2 {
+                constructor(t42) {
+                  this._stringToNumber = {}, this._numberToString = [];
+                  for (let e22 = 0; e22 < t42.length; e22++) {
+                    const r22 = t42[e22];
+                    this._stringToNumber[r22] = e22, this._numberToString[e22] = r22;
+                  }
+                }
+                encode(t42) {
+                  return this._stringToNumber[t42];
+                }
+                decode(t42) {
+                  if (t42 >= this._numberToString.length) throw new Error(`Out of bounds. Index requested n=${t42} can't be >= this._numberToString.length ${this._numberToString.length}`);
+                  return this._numberToString[t42];
+                }
+              }
+              class Nc2 {
+                constructor(t42, e22, r22, n22, i22) {
+                  this.type = "Feature", this._vectorTileFeature = t42, t42._z = e22, t42._x = r22, t42._y = n22, this.properties = t42.properties, this.id = i22;
+                }
+                get geometry() {
+                  return void 0 === this._geometry && (this._geometry = this._vectorTileFeature.toGeoJSON(this._vectorTileFeature._x, this._vectorTileFeature._y, this._vectorTileFeature._z).geometry), this._geometry;
+                }
+                set geometry(t42) {
+                  this._geometry = t42;
+                }
+                toJSON() {
+                  const t42 = { geometry: this.geometry };
+                  for (const e22 in this) "_geometry" !== e22 && "_vectorTileFeature" !== e22 && (t42[e22] = this[e22]);
+                  return t42;
+                }
+              }
+              class Zc2 {
+                constructor(t42, e22) {
+                  this.tileID = t42, this.x = t42.canonical.x, this.y = t42.canonical.y, this.z = t42.canonical.z, this.grid = new vi2($a, 16, 0), this.grid3D = new vi2($a, 16, 0), this.featureIndexArray = new Ns(), this.promoteId = e22;
+                }
+                insert(t42, e22, r22, n22, i22, s22) {
+                  const a22 = this.featureIndexArray.length;
+                  this.featureIndexArray.emplaceBack(r22, n22, i22);
+                  const o22 = s22 ? this.grid3D : this.grid;
+                  for (let t5 = 0; t5 < e22.length; t5++) {
+                    const r3 = e22[t5], n3 = [1 / 0, 1 / 0, -1 / 0, -1 / 0];
+                    for (let t6 = 0; t6 < r3.length; t6++) {
+                      const e3 = r3[t6];
+                      n3[0] = Math.min(n3[0], e3.x), n3[1] = Math.min(n3[1], e3.y), n3[2] = Math.max(n3[2], e3.x), n3[3] = Math.max(n3[3], e3.y);
+                    }
+                    n3[0] < $a && n3[1] < $a && n3[2] >= 0 && n3[3] >= 0 && o22.insert(a22, n3[0], n3[1], n3[2], n3[3]);
+                  }
+                }
+                loadVTLayers() {
+                  return this.vtLayers || (this.vtLayers = new fl2.VectorTile(new Iu(this.rawTileData)).layers, this.sourceLayerCoder = new qc2(this.vtLayers ? Object.keys(this.vtLayers).sort() : ["_geojsonTileLayer"])), this.vtLayers;
+                }
+                query(t42, e22, r22, n22) {
+                  this.loadVTLayers();
+                  const i22 = t42.params || {}, a22 = $a / t42.tileSize / t42.scale, o22 = zn(i22.filter), l22 = t42.queryGeometry, u22 = t42.queryPadding * a22, c22 = Kc2(l22), h22 = this.grid.query(c22.minX - u22, c22.minY - u22, c22.maxX + u22, c22.maxY + u22), p22 = Kc2(t42.cameraQueryGeometry), f22 = this.grid3D.query(p22.minX - u22, p22.minY - u22, p22.maxX + u22, p22.maxY + u22, (e3, r3, n3, i3) => function(t5, e4, r4, n4, i4) {
+                    for (const s22 of t5) if (e4 <= s22.x && r4 <= s22.y && n4 >= s22.x && i4 >= s22.y) return true;
+                    const a3 = [new s2(e4, r4), new s2(e4, i4), new s2(n4, i4), new s2(n4, r4)];
+                    if (t5.length > 2) {
+                      for (const e5 of a3) if (Wa2(t5, e5)) return true;
+                    }
+                    for (let e5 = 0; e5 < t5.length - 1; e5++) if (Qa2(t5[e5], t5[e5 + 1], a3)) return true;
+                    return false;
+                  }(t42.cameraQueryGeometry, e3 - u22, r3 - u22, n3 + u22, i3 + u22));
+                  for (const t5 of f22) h22.push(t5);
+                  h22.sort(Xc2);
+                  const d22 = {};
+                  let y22;
+                  for (let s22 = 0; s22 < h22.length; s22++) {
+                    const u3 = h22[s22];
+                    if (u3 === y22) continue;
+                    y22 = u3;
+                    const c3 = this.featureIndexArray.get(u3);
+                    let p3 = null;
+                    this.loadMatchingFeature(d22, c3.bucketIndex, c3.sourceLayerIndex, c3.featureIndex, o22, i22.layers, i22.availableImages, e22, r22, n22, (e3, r3, n3) => (p3 || (p3 = Oa2(e3)), r3.queryIntersectsFeature(l22, e3, n3, p3, this.z, t42.transform, a22, t42.pixelPosMatrix)));
+                  }
+                  return d22;
+                }
+                loadMatchingFeature(t42, e22, r22, n22, i22, s22, a22, o22, l22, u22, c22) {
+                  const h22 = this.bucketLayerIDs[e22];
+                  if (s22 && !function(t5, e3) {
+                    for (let r3 = 0; r3 < t5.length; r3++) if (e3.indexOf(t5[r3]) >= 0) return true;
+                    return false;
+                  }(s22, h22)) return;
+                  const p22 = this.sourceLayerCoder.decode(r22), f22 = this.vtLayers[p22].feature(n22);
+                  if (i22.needGeometry) {
+                    const t5 = ja2(f22, true);
+                    if (!i22.filter(new Ui2(this.tileID.overscaledZ), t5, this.tileID.canonical)) return;
+                  } else if (!i22.filter(new Ui2(this.tileID.overscaledZ), f22)) return;
+                  const d22 = this.getId(f22, p22);
+                  for (let e3 = 0; e3 < h22.length; e3++) {
+                    const r3 = h22[e3];
+                    if (s22 && s22.indexOf(r3) < 0) continue;
+                    const i3 = o22[r3];
+                    if (!i3) continue;
+                    let p3 = {};
+                    d22 && u22 && (p3 = u22.getState(i3.sourceLayer || "_geojsonTileLayer", d22));
+                    const y22 = g2({}, l22[r3]);
+                    y22.paint = Gc2(y22.paint, i3.paint, f22, p3, a22), y22.layout = Gc2(y22.layout, i3.layout, f22, p3, a22);
+                    const m22 = !c22 || c22(f22, i3, p3);
+                    if (!m22) continue;
+                    const x22 = new Nc2(f22, this.z, this.x, this.y, d22);
+                    x22.layer = y22;
+                    let v22 = t42[r3];
+                    void 0 === v22 && (v22 = t42[r3] = []), v22.push({ featureIndex: n22, feature: x22, intersectionZ: m22 });
+                  }
+                }
+                lookupSymbolFeatures(t42, e22, r22, n22, i22, s22, a22, o22) {
+                  const l22 = {};
+                  this.loadVTLayers();
+                  const u22 = zn(i22);
+                  for (const i3 of t42) this.loadMatchingFeature(l22, r22, n22, i3, u22, s22, a22, o22, e22);
+                  return l22;
+                }
+                hasLayer(t42) {
+                  for (const e22 of this.bucketLayerIDs) for (const r22 of e22) if (t42 === r22) return true;
+                  return false;
+                }
+                getId(t42, e22) {
+                  let r22 = t42.id;
+                  return this.promoteId && (r22 = t42.properties["string" == typeof this.promoteId ? this.promoteId : this.promoteId[e22]], "boolean" == typeof r22 && (r22 = Number(r22))), r22;
+                }
+              }
+              function Gc2(t42, e22, r22, n22, i22) {
+                return v2(t42, (t5, s22) => {
+                  const a22 = e22 instanceof Yi2 ? e22.get(s22) : null;
+                  return a22 && a22.evaluate ? a22.evaluate(r22, n22, i22) : a22;
+                });
+              }
+              function Kc2(t42) {
+                let e22 = 1 / 0, r22 = 1 / 0, n22 = -1 / 0, i22 = -1 / 0;
+                for (const s22 of t42) e22 = Math.min(e22, s22.x), r22 = Math.min(r22, s22.y), n22 = Math.max(n22, s22.x), i22 = Math.max(i22, s22.y);
+                return { minX: e22, minY: r22, maxX: n22, maxY: i22 };
+              }
+              function Xc2(t42, e22) {
+                return e22 - t42;
+              }
+              function Hc2(t42, e22, r22, n22, i22) {
+                const a22 = [];
+                for (let o22 = 0; o22 < t42.length; o22++) {
+                  const l22 = t42[o22];
+                  let u22;
+                  for (let t5 = 0; t5 < l22.length - 1; t5++) {
+                    let o3 = l22[t5], c22 = l22[t5 + 1];
+                    o3.x < e22 && c22.x < e22 || (o3.x < e22 ? o3 = new s2(e22, o3.y + (e22 - o3.x) / (c22.x - o3.x) * (c22.y - o3.y))._round() : c22.x < e22 && (c22 = new s2(e22, o3.y + (e22 - o3.x) / (c22.x - o3.x) * (c22.y - o3.y))._round()), o3.y < r22 && c22.y < r22 || (o3.y < r22 ? o3 = new s2(o3.x + (r22 - o3.y) / (c22.y - o3.y) * (c22.x - o3.x), r22)._round() : c22.y < r22 && (c22 = new s2(o3.x + (r22 - o3.y) / (c22.y - o3.y) * (c22.x - o3.x), r22)._round()), o3.x >= n22 && c22.x >= n22 || (o3.x >= n22 ? o3 = new s2(n22, o3.y + (n22 - o3.x) / (c22.x - o3.x) * (c22.y - o3.y))._round() : c22.x >= n22 && (c22 = new s2(n22, o3.y + (n22 - o3.x) / (c22.x - o3.x) * (c22.y - o3.y))._round()), o3.y >= i22 && c22.y >= i22 || (o3.y >= i22 ? o3 = new s2(o3.x + (i22 - o3.y) / (c22.y - o3.y) * (c22.x - o3.x), i22)._round() : c22.y >= i22 && (c22 = new s2(o3.x + (i22 - o3.y) / (c22.y - o3.y) * (c22.x - o3.x), i22)._round()), u22 && o3.equals(u22[u22.length - 1]) || (u22 = [o3], a22.push(u22)), u22.push(c22)))));
+                  }
+                }
+                return a22;
+              }
+              wi2("FeatureIndex", Zc2, { omit: ["rawTileData", "sourceLayerCoder"] });
+              class Yc2 extends s2 {
+                constructor(t42, e22, r22, n22) {
+                  super(t42, e22), this.angle = r22, void 0 !== n22 && (this.segment = n22);
+                }
+                clone() {
+                  return new Yc2(this.x, this.y, this.angle, this.segment);
+                }
+              }
+              function Jc2(t42, e22, r22, n22, i22) {
+                if (void 0 === e22.segment || 0 === r22) return true;
+                let s22 = e22, a22 = e22.segment + 1, o22 = 0;
+                for (; o22 > -r22 / 2; ) {
+                  if (a22--, a22 < 0) return false;
+                  o22 -= t42[a22].dist(s22), s22 = t42[a22];
+                }
+                o22 += t42[a22].dist(t42[a22 + 1]), a22++;
+                const l22 = [];
+                let u22 = 0;
+                for (; o22 < r22 / 2; ) {
+                  const e3 = t42[a22], r3 = t42[a22 + 1];
+                  if (!r3) return false;
+                  let s3 = t42[a22 - 1].angleTo(e3) - e3.angleTo(r3);
+                  for (s3 = Math.abs((s3 + 3 * Math.PI) % (2 * Math.PI) - Math.PI), l22.push({ distance: o22, angleDelta: s3 }), u22 += s3; o22 - l22[0].distance > n22; ) u22 -= l22.shift().angleDelta;
+                  if (u22 > i22) return false;
+                  a22++, o22 += e3.dist(r3);
+                }
+                return true;
+              }
+              function Wc2(t42) {
+                let e22 = 0;
+                for (let r22 = 0; r22 < t42.length - 1; r22++) e22 += t42[r22].dist(t42[r22 + 1]);
+                return e22;
+              }
+              function Qc2(t42, e22, r22) {
+                return t42 ? 0.6 * e22 * r22 : 0;
+              }
+              function th2(t42, e22) {
+                return Math.max(t42 ? t42.right - t42.left : 0, e22 ? e22.right - e22.left : 0);
+              }
+              function eh2(t42, e22, r22, n22, i22, s22) {
+                const a22 = Qc2(r22, i22, s22), o22 = th2(r22, n22) * s22;
+                let l22 = 0;
+                const u22 = Wc2(t42) / 2;
+                for (let r3 = 0; r3 < t42.length - 1; r3++) {
+                  const n3 = t42[r3], i3 = t42[r3 + 1], s3 = n3.dist(i3);
+                  if (l22 + s3 > u22) {
+                    const c22 = (u22 - l22) / s3, h22 = Ce2.number(n3.x, i3.x, c22), p22 = Ce2.number(n3.y, i3.y, c22), f22 = new Yc2(h22, p22, i3.angleTo(n3), r3);
+                    return f22._round(), !a22 || Jc2(t42, f22, o22, a22, e22) ? f22 : void 0;
+                  }
+                  l22 += s3;
+                }
+              }
+              function rh2(t42, e22, r22, n22, i22, s22, a22, o22, l22) {
+                const u22 = Qc2(n22, s22, a22), c22 = th2(n22, i22), h22 = c22 * a22, p22 = 0 === t42[0].x || t42[0].x === l22 || 0 === t42[0].y || t42[0].y === l22;
+                return e22 - h22 < e22 / 4 && (e22 = h22 + e22 / 4), nh2(t42, p22 ? e22 / 2 * o22 % e22 : (c22 / 2 + 2 * s22) * a22 * o22 % e22, e22, u22, r22, h22, p22, false, l22);
+              }
+              function nh2(t42, e22, r22, n22, i22, s22, a22, o22, l22) {
+                const u22 = s22 / 2, c22 = Wc2(t42);
+                let h22 = 0, p22 = e22 - r22, f22 = [];
+                for (let e3 = 0; e3 < t42.length - 1; e3++) {
+                  const a3 = t42[e3], o3 = t42[e3 + 1], d22 = a3.dist(o3), y22 = o3.angleTo(a3);
+                  for (; p22 + r22 < h22 + d22; ) {
+                    p22 += r22;
+                    const m22 = (p22 - h22) / d22, g22 = Ce2.number(a3.x, o3.x, m22), x22 = Ce2.number(a3.y, o3.y, m22);
+                    if (g22 >= 0 && g22 < l22 && x22 >= 0 && x22 < l22 && p22 - u22 >= 0 && p22 + u22 <= c22) {
+                      const r3 = new Yc2(g22, x22, y22, e3);
+                      r3._round(), n22 && !Jc2(t42, r3, s22, n22, i22) || f22.push(r3);
+                    }
+                  }
+                  h22 += d22;
+                }
+                return o22 || f22.length || a22 || (f22 = nh2(t42, h22 / 2, r22, n22, i22, s22, a22, true, l22)), f22;
+              }
+              wi2("Anchor", Yc2);
+              const ih2 = Fu;
+              function sh2(t42, e22, r22, n22) {
+                const i22 = [], a22 = t42.image, o22 = a22.pixelRatio, l22 = a22.paddedRect.w - 2 * ih2, u22 = a22.paddedRect.h - 2 * ih2;
+                let c22 = { x1: t42.left, y1: t42.top, x2: t42.right, y2: t42.bottom };
+                const h22 = a22.stretchX || [[0, l22]], p22 = a22.stretchY || [[0, u22]], f22 = (t5, e3) => t5 + e3[1] - e3[0], d22 = h22.reduce(f22, 0), y22 = p22.reduce(f22, 0), m22 = l22 - d22, g22 = u22 - y22;
+                let x22 = 0, v22 = d22, b22 = 0, w22 = y22, _22 = 0, A3 = m22, S22 = 0, k22 = g22;
+                if (a22.content && n22) {
+                  const e3 = a22.content, r3 = e3[2] - e3[0], n3 = e3[3] - e3[1];
+                  (a22.textFitWidth || a22.textFitHeight) && (c22 = tc2(t42)), x22 = ah2(h22, 0, e3[0]), b22 = ah2(p22, 0, e3[1]), v22 = ah2(h22, e3[0], e3[2]), w22 = ah2(p22, e3[1], e3[3]), _22 = e3[0] - x22, S22 = e3[1] - b22, A3 = r3 - v22, k22 = n3 - w22;
+                }
+                const M22 = c22.x1, I22 = c22.y1, z22 = c22.x2 - M22, P22 = c22.y2 - I22, C3 = (t5, n3, i3, l3) => {
+                  const u3 = lh2(t5.stretch - x22, v22, z22, M22), c3 = uh2(t5.fixed - _22, A3, t5.stretch, d22), h3 = lh2(n3.stretch - b22, w22, P22, I22), p3 = uh2(n3.fixed - S22, k22, n3.stretch, y22), f3 = lh2(i3.stretch - x22, v22, z22, M22), m3 = uh2(i3.fixed - _22, A3, i3.stretch, d22), g3 = lh2(l3.stretch - b22, w22, P22, I22), C4 = uh2(l3.fixed - S22, k22, l3.stretch, y22), B3 = new s2(u3, h3), V22 = new s2(f3, h3), E3 = new s2(f3, g3), F22 = new s2(u3, g3), T22 = new s2(c3 / o22, p3 / o22), $22 = new s2(m3 / o22, C4 / o22), L22 = e22 * Math.PI / 180;
+                  if (L22) {
+                    const t6 = Math.sin(L22), e3 = Math.cos(L22), r3 = [e3, -t6, t6, e3];
+                    B3._matMult(r3), V22._matMult(r3), F22._matMult(r3), E3._matMult(r3);
+                  }
+                  const D3 = t5.stretch + t5.fixed, O22 = n3.stretch + n3.fixed;
+                  return { tl: B3, tr: V22, bl: F22, br: E3, tex: { x: a22.paddedRect.x + ih2 + D3, y: a22.paddedRect.y + ih2 + O22, w: i3.stretch + i3.fixed - D3, h: l3.stretch + l3.fixed - O22 }, writingMode: void 0, glyphOffset: [0, 0], sectionIndex: 0, pixelOffsetTL: T22, pixelOffsetBR: $22, minFontScaleX: A3 / o22 / z22, minFontScaleY: k22 / o22 / P22, isSDF: r22 };
+                };
+                if (n22 && (a22.stretchX || a22.stretchY)) {
+                  const t5 = oh2(h22, m22, d22), e3 = oh2(p22, g22, y22);
+                  for (let r3 = 0; r3 < t5.length - 1; r3++) {
+                    const n3 = t5[r3], s22 = t5[r3 + 1];
+                    for (let t6 = 0; t6 < e3.length - 1; t6++) i22.push(C3(n3, e3[t6], s22, e3[t6 + 1]));
+                  }
+                } else i22.push(C3({ fixed: 0, stretch: -1 }, { fixed: 0, stretch: -1 }, { fixed: 0, stretch: l22 + 1 }, { fixed: 0, stretch: u22 + 1 }));
+                return i22;
+              }
+              function ah2(t42, e22, r22) {
+                let n22 = 0;
+                for (const i22 of t42) n22 += Math.max(e22, Math.min(r22, i22[1])) - Math.max(e22, Math.min(r22, i22[0]));
+                return n22;
+              }
+              function oh2(t42, e22, r22) {
+                const n22 = [{ fixed: -1, stretch: 0 }];
+                for (const [e3, r3] of t42) {
+                  const t5 = n22[n22.length - 1];
+                  n22.push({ fixed: e3 - t5.stretch, stretch: t5.stretch }), n22.push({ fixed: e3 - t5.stretch, stretch: t5.stretch + (r3 - e3) });
+                }
+                return n22.push({ fixed: e22 + ih2, stretch: r22 }), n22;
+              }
+              function lh2(t42, e22, r22, n22) {
+                return t42 / e22 * r22 + n22;
+              }
+              function uh2(t42, e22, r22, n22) {
+                return t42 - e22 * r22 / n22;
+              }
+              class ch2 {
+                constructor(t42, e22, r22, n22, i22, a22, o22, l22, u22, c22) {
+                  var h22;
+                  if (this.boxStartIndex = t42.length, u22) {
+                    let t5 = a22.top, e3 = a22.bottom;
+                    const r3 = a22.collisionPadding;
+                    r3 && (t5 -= r3[1], e3 += r3[3]);
+                    let n3 = e3 - t5;
+                    n3 > 0 && (n3 = Math.max(10, n3), this.circleDiameter = n3);
+                  } else {
+                    const u3 = (null === (h22 = a22.image) || void 0 === h22 ? void 0 : h22.content) && (a22.image.textFitWidth || a22.image.textFitHeight) ? tc2(a22) : { x1: a22.left, y1: a22.top, x2: a22.right, y2: a22.bottom };
+                    u3.y1 = u3.y1 * o22 - l22[0], u3.y2 = u3.y2 * o22 + l22[2], u3.x1 = u3.x1 * o22 - l22[3], u3.x2 = u3.x2 * o22 + l22[1];
+                    const p22 = a22.collisionPadding;
+                    if (p22 && (u3.x1 -= p22[0] * o22, u3.y1 -= p22[1] * o22, u3.x2 += p22[2] * o22, u3.y2 += p22[3] * o22), c22) {
+                      const t5 = new s2(u3.x1, u3.y1), e3 = new s2(u3.x2, u3.y1), r3 = new s2(u3.x1, u3.y2), n3 = new s2(u3.x2, u3.y2), i3 = c22 * Math.PI / 180;
+                      t5._rotate(i3), e3._rotate(i3), r3._rotate(i3), n3._rotate(i3), u3.x1 = Math.min(t5.x, e3.x, r3.x, n3.x), u3.x2 = Math.max(t5.x, e3.x, r3.x, n3.x), u3.y1 = Math.min(t5.y, e3.y, r3.y, n3.y), u3.y2 = Math.max(t5.y, e3.y, r3.y, n3.y);
+                    }
+                    t42.emplaceBack(e22.x, e22.y, u3.x1, u3.y1, u3.x2, u3.y2, r22, n22, i22);
+                  }
+                  this.boxEndIndex = t42.length;
+                }
+              }
+              class hh2 {
+                constructor(t42 = [], e22 = (t5, e3) => t5 < e3 ? -1 : t5 > e3 ? 1 : 0) {
+                  if (this.data = t42, this.length = this.data.length, this.compare = e22, this.length > 0) for (let t5 = (this.length >> 1) - 1; t5 >= 0; t5--) this._down(t5);
+                }
+                push(t42) {
+                  this.data.push(t42), this._up(this.length++);
+                }
+                pop() {
+                  if (0 === this.length) return;
+                  const t42 = this.data[0], e22 = this.data.pop();
+                  return --this.length > 0 && (this.data[0] = e22, this._down(0)), t42;
+                }
+                peek() {
+                  return this.data[0];
+                }
+                _up(t42) {
+                  const { data: e22, compare: r22 } = this, n22 = e22[t42];
+                  for (; t42 > 0; ) {
+                    const i22 = t42 - 1 >> 1, s22 = e22[i22];
+                    if (r22(n22, s22) >= 0) break;
+                    e22[t42] = s22, t42 = i22;
+                  }
+                  e22[t42] = n22;
+                }
+                _down(t42) {
+                  const { data: e22, compare: r22 } = this, n22 = this.length >> 1, i22 = e22[t42];
+                  for (; t42 < n22; ) {
+                    let n3 = 1 + (t42 << 1);
+                    const s22 = n3 + 1;
+                    if (s22 < this.length && r22(e22[s22], e22[n3]) < 0 && (n3 = s22), r22(e22[n3], i22) >= 0) break;
+                    e22[t42] = e22[n3], t42 = n3;
+                  }
+                  e22[t42] = i22;
+                }
+              }
+              function ph2(t42, e22 = 1, r22 = false) {
+                let n22 = 1 / 0, i22 = 1 / 0, a22 = -1 / 0, o22 = -1 / 0;
+                const l22 = t42[0];
+                for (let t5 = 0; t5 < l22.length; t5++) {
+                  const e3 = l22[t5];
+                  (!t5 || e3.x < n22) && (n22 = e3.x), (!t5 || e3.y < i22) && (i22 = e3.y), (!t5 || e3.x > a22) && (a22 = e3.x), (!t5 || e3.y > o22) && (o22 = e3.y);
+                }
+                const u22 = Math.min(a22 - n22, o22 - i22);
+                let c22 = u22 / 2;
+                const h22 = new hh2([], fh2);
+                if (0 === u22) return new s2(n22, i22);
+                for (let e3 = n22; e3 < a22; e3 += u22) for (let r3 = i22; r3 < o22; r3 += u22) h22.push(new dh2(e3 + c22, r3 + c22, c22, t42));
+                let p22 = function(t5) {
+                  let e3 = 0, r3 = 0, n3 = 0;
+                  const i3 = t5[0];
+                  for (let t6 = 0, s22 = i3.length, a3 = s22 - 1; t6 < s22; a3 = t6++) {
+                    const s3 = i3[t6], o3 = i3[a3], l3 = s3.x * o3.y - o3.x * s3.y;
+                    r3 += (s3.x + o3.x) * l3, n3 += (s3.y + o3.y) * l3, e3 += 3 * l3;
+                  }
+                  return new dh2(r3 / e3, n3 / e3, 0, t5);
+                }(t42), f22 = h22.length;
+                for (; h22.length; ) {
+                  const n3 = h22.pop();
+                  (n3.d > p22.d || !p22.d) && (p22 = n3, r22 && console.log("found best %d after %d probes", Math.round(1e4 * n3.d) / 1e4, f22)), n3.max - p22.d <= e22 || (c22 = n3.h / 2, h22.push(new dh2(n3.p.x - c22, n3.p.y - c22, c22, t42)), h22.push(new dh2(n3.p.x + c22, n3.p.y - c22, c22, t42)), h22.push(new dh2(n3.p.x - c22, n3.p.y + c22, c22, t42)), h22.push(new dh2(n3.p.x + c22, n3.p.y + c22, c22, t42)), f22 += 4);
+                }
+                return r22 && (console.log(`num probes: ${f22}`), console.log(`best distance: ${p22.d}`)), p22.p;
+              }
+              function fh2(t42, e22) {
+                return e22.max - t42.max;
+              }
+              function dh2(t42, e22, r22, n22) {
+                this.p = new s2(t42, e22), this.h = r22, this.d = function(t5, e3) {
+                  let r3 = false, n3 = 1 / 0;
+                  for (let i22 = 0; i22 < e3.length; i22++) {
+                    const s22 = e3[i22];
+                    for (let e4 = 0, i3 = s22.length, a22 = i3 - 1; e4 < i3; a22 = e4++) {
+                      const i4 = s22[e4], o22 = s22[a22];
+                      i4.y > t5.y != o22.y > t5.y && t5.x < (o22.x - i4.x) * (t5.y - i4.y) / (o22.y - i4.y) + i4.x && (r3 = !r3), n3 = Math.min(n3, Ya2(t5, i4, o22));
+                    }
+                  }
+                  return (r3 ? 1 : -1) * Math.sqrt(n3);
+                }(this.p, n22), this.max = this.d + this.h * Math.SQRT2;
+              }
+              var yh2;
+              t4.aq = void 0, (yh2 = t4.aq || (t4.aq = {}))[yh2.center = 1] = "center", yh2[yh2.left = 2] = "left", yh2[yh2.right = 3] = "right", yh2[yh2.top = 4] = "top", yh2[yh2.bottom = 5] = "bottom", yh2[yh2["top-left"] = 6] = "top-left", yh2[yh2["top-right"] = 7] = "top-right", yh2[yh2["bottom-left"] = 8] = "bottom-left", yh2[yh2["bottom-right"] = 9] = "bottom-right";
+              const mh2 = 7, gh2 = Number.POSITIVE_INFINITY;
+              function xh2(t42, e22) {
+                return e22[1] !== gh2 ? function(t5, e3, r22) {
+                  let n22 = 0, i22 = 0;
+                  switch (e3 = Math.abs(e3), r22 = Math.abs(r22), t5) {
+                    case "top-right":
+                    case "top-left":
+                    case "top":
+                      i22 = r22 - mh2;
+                      break;
+                    case "bottom-right":
+                    case "bottom-left":
+                    case "bottom":
+                      i22 = -r22 + mh2;
+                  }
+                  switch (t5) {
+                    case "top-right":
+                    case "bottom-right":
+                    case "right":
+                      n22 = -e3;
+                      break;
+                    case "top-left":
+                    case "bottom-left":
+                    case "left":
+                      n22 = e3;
+                  }
+                  return [n22, i22];
+                }(t42, e22[0], e22[1]) : function(t5, e3) {
+                  let r22 = 0, n22 = 0;
+                  e3 < 0 && (e3 = 0);
+                  const i22 = e3 / Math.SQRT2;
+                  switch (t5) {
+                    case "top-right":
+                    case "top-left":
+                      n22 = i22 - mh2;
+                      break;
+                    case "bottom-right":
+                    case "bottom-left":
+                      n22 = -i22 + mh2;
+                      break;
+                    case "bottom":
+                      n22 = -e3 + mh2;
+                      break;
+                    case "top":
+                      n22 = e3 - mh2;
+                  }
+                  switch (t5) {
+                    case "top-right":
+                    case "bottom-right":
+                      r22 = -i22;
+                      break;
+                    case "top-left":
+                    case "bottom-left":
+                      r22 = i22;
+                      break;
+                    case "left":
+                      r22 = e3;
+                      break;
+                    case "right":
+                      r22 = -e3;
+                  }
+                  return [r22, n22];
+                }(t42, e22[0]);
+              }
+              function vh2(t42, e22, r22) {
+                var n22;
+                const i22 = t42.layout, s22 = null === (n22 = i22.get("text-variable-anchor-offset")) || void 0 === n22 ? void 0 : n22.evaluate(e22, {}, r22);
+                if (s22) {
+                  const t5 = s22.values, e3 = [];
+                  for (let r3 = 0; r3 < t5.length; r3 += 2) {
+                    const n3 = e3[r3] = t5[r3], i3 = t5[r3 + 1].map((t6) => t6 * iu);
+                    n3.startsWith("top") ? i3[1] -= mh2 : n3.startsWith("bottom") && (i3[1] += mh2), e3[r3 + 1] = i3;
+                  }
+                  return new Qt(e3);
+                }
+                const a22 = i22.get("text-variable-anchor");
+                if (a22) {
+                  let n3;
+                  n3 = void 0 !== t42._unevaluatedLayout.getValue("text-radial-offset") ? [i22.get("text-radial-offset").evaluate(e22, {}, r22) * iu, gh2] : i22.get("text-offset").evaluate(e22, {}, r22).map((t5) => t5 * iu);
+                  const s3 = [];
+                  for (const t5 of a22) s3.push(t5, xh2(t5, n3));
+                  return new Qt(s3);
+                }
+                return null;
+              }
+              function bh2(t42) {
+                switch (t42) {
+                  case "right":
+                  case "top-right":
+                  case "bottom-right":
+                    return "right";
+                  case "left":
+                  case "top-left":
+                  case "bottom-left":
+                    return "left";
+                }
+                return "center";
+              }
+              function wh2(e22, r22, n22, i22, s22, a22, o22, l22, u22, c22, h22) {
+                let p22 = a22.textMaxSize.evaluate(r22, {});
+                void 0 === p22 && (p22 = o22);
+                const f22 = e22.layers[0].layout, d22 = f22.get("icon-offset").evaluate(r22, {}, h22), y22 = Ah2(n22.horizontal), m22 = o22 / 24, g22 = e22.tilePixelRatio * m22, x22 = e22.tilePixelRatio * p22 / 24, v22 = e22.tilePixelRatio * l22, b22 = e22.tilePixelRatio * f22.get("symbol-spacing"), w22 = f22.get("text-padding") * e22.tilePixelRatio, _22 = function(t42, e3, r3, n3 = 1) {
+                  const i3 = t42.get("icon-padding").evaluate(e3, {}, r3), s3 = i3 && i3.values;
+                  return [s3[0] * n3, s3[1] * n3, s3[2] * n3, s3[3] * n3];
+                }(f22, r22, h22, e22.tilePixelRatio), S22 = f22.get("text-max-angle") / 180 * Math.PI, k22 = "viewport" !== f22.get("text-rotation-alignment") && "point" !== f22.get("symbol-placement"), M22 = "map" === f22.get("icon-rotation-alignment") && "point" !== f22.get("symbol-placement"), I22 = f22.get("symbol-placement"), z22 = b22 / 2, P22 = f22.get("icon-text-fit");
+                let C3;
+                i22 && "none" !== P22 && (e22.allowVerticalPlacement && n22.vertical && (C3 = ec2(i22, n22.vertical, P22, f22.get("icon-text-fit-padding"), d22, m22)), y22 && (i22 = ec2(i22, y22, P22, f22.get("icon-text-fit-padding"), d22, m22)));
+                const B3 = (l3, p3) => {
+                  p3.x < 0 || p3.x >= $a || p3.y < 0 || p3.y >= $a || function(e3, r3, n3, i3, s3, a3, o3, l4, u3, c3, h3, p4, f3, d3, y3, m3, g3, x3, v3, b3, w3, _3, S3, k3, M3) {
+                    const I3 = e3.addToLineVertexArray(r3, n3);
+                    let z3, P3, C4, B4, V22 = 0, E3 = 0, F22 = 0, T22 = 0, $22 = -1, L22 = -1;
+                    const D3 = {};
+                    let O22 = ma2("");
+                    if (e3.allowVerticalPlacement && i3.vertical) {
+                      const t42 = l4.layout.get("text-rotate").evaluate(w3, {}, k3) + 90;
+                      C4 = new ch2(u3, r3, c3, h3, p4, i3.vertical, f3, d3, y3, t42), o3 && (B4 = new ch2(u3, r3, c3, h3, p4, o3, g3, x3, y3, t42));
+                    }
+                    if (s3) {
+                      const n4 = l4.layout.get("icon-rotate").evaluate(w3, {}), i4 = "none" !== l4.layout.get("icon-text-fit"), a4 = sh2(s3, n4, S3, i4), f4 = o3 ? sh2(o3, n4, S3, i4) : void 0;
+                      P3 = new ch2(u3, r3, c3, h3, p4, s3, g3, x3, false, n4), V22 = 4 * a4.length;
+                      const d4 = e3.iconSizeData;
+                      let y4 = null;
+                      "source" === d4.kind ? (y4 = [nc2 * l4.layout.get("icon-size").evaluate(w3, {})], y4[0] > ic2 && A22(`${e3.layerIds[0]}: Value for "icon-size" is >= ${rc2}. Reduce your "icon-size".`)) : "composite" === d4.kind && (y4 = [nc2 * _3.compositeIconSizes[0].evaluate(w3, {}, k3), nc2 * _3.compositeIconSizes[1].evaluate(w3, {}, k3)], (y4[0] > ic2 || y4[1] > ic2) && A22(`${e3.layerIds[0]}: Value for "icon-size" is >= ${rc2}. Reduce your "icon-size".`)), e3.addSymbols(e3.icon, a4, y4, b3, v3, w3, t4.ah.none, r3, I3.lineStartIndex, I3.lineLength, -1, k3), $22 = e3.icon.placedSymbolArray.length - 1, f4 && (E3 = 4 * f4.length, e3.addSymbols(e3.icon, f4, y4, b3, v3, w3, t4.ah.vertical, r3, I3.lineStartIndex, I3.lineLength, -1, k3), L22 = e3.icon.placedSymbolArray.length - 1);
+                    }
+                    const j22 = Object.keys(i3.horizontal);
+                    for (const n4 of j22) {
+                      const s4 = i3.horizontal[n4];
+                      if (!z3) {
+                        O22 = ma2(s4.text);
+                        const t42 = l4.layout.get("text-rotate").evaluate(w3, {}, k3);
+                        z3 = new ch2(u3, r3, c3, h3, p4, s4, f3, d3, y3, t42);
+                      }
+                      const o4 = 1 === s4.positionedLines.length;
+                      if (F22 += _h2(e3, r3, s4, a3, l4, y3, w3, m3, I3, i3.vertical ? t4.ah.horizontal : t4.ah.horizontalOnly, o4 ? j22 : [n4], D3, $22, _3, k3), o4) break;
+                    }
+                    i3.vertical && (T22 += _h2(e3, r3, i3.vertical, a3, l4, y3, w3, m3, I3, t4.ah.vertical, ["vertical"], D3, L22, _3, k3));
+                    const R22 = z3 ? z3.boxStartIndex : e3.collisionBoxArray.length, U22 = z3 ? z3.boxEndIndex : e3.collisionBoxArray.length, q22 = C4 ? C4.boxStartIndex : e3.collisionBoxArray.length, N22 = C4 ? C4.boxEndIndex : e3.collisionBoxArray.length, Z22 = P3 ? P3.boxStartIndex : e3.collisionBoxArray.length, G22 = P3 ? P3.boxEndIndex : e3.collisionBoxArray.length, K3 = B4 ? B4.boxStartIndex : e3.collisionBoxArray.length, X22 = B4 ? B4.boxEndIndex : e3.collisionBoxArray.length;
+                    let H22 = -1;
+                    const Y22 = (t42, e4) => t42 && t42.circleDiameter ? Math.max(t42.circleDiameter, e4) : e4;
+                    H22 = Y22(z3, H22), H22 = Y22(C4, H22), H22 = Y22(P3, H22), H22 = Y22(B4, H22);
+                    const J22 = H22 > -1 ? 1 : 0;
+                    J22 && (H22 *= M3 / iu), e3.glyphOffsetArray.length >= dc2.MAX_GLYPHS && A22("Too many glyphs being rendered in a tile. See https://github.com/mapbox/mapbox-gl-js/issues/2907"), void 0 !== w3.sortKey && e3.addToSortKeyRanges(e3.symbolInstances.length, w3.sortKey);
+                    const W22 = vh2(l4, w3, k3), [Q22, tt22] = function(e4, r4) {
+                      const n4 = e4.length, i4 = null == r4 ? void 0 : r4.values;
+                      if ((null == i4 ? void 0 : i4.length) > 0) for (let r5 = 0; r5 < i4.length; r5 += 2) {
+                        const n5 = i4[r5 + 1];
+                        e4.emplaceBack(t4.aq[i4[r5]], n5[0], n5[1]);
+                      }
+                      return [n4, e4.length];
+                    }(e3.textAnchorOffsets, W22);
+                    e3.symbolInstances.emplaceBack(r3.x, r3.y, D3.right >= 0 ? D3.right : -1, D3.center >= 0 ? D3.center : -1, D3.left >= 0 ? D3.left : -1, D3.vertical || -1, $22, L22, O22, R22, U22, q22, N22, Z22, G22, K3, X22, c3, F22, T22, V22, E3, J22, 0, f3, H22, Q22, tt22);
+                  }(e22, p3, l3, n22, i22, s22, C3, e22.layers[0], e22.collisionBoxArray, r22.index, r22.sourceLayerIndex, e22.index, g22, [w22, w22, w22, w22], k22, u22, v22, _22, M22, d22, r22, a22, c22, h22, o22);
+                };
+                if ("line" === I22) for (const t42 of Hc2(r22.geometry, 0, 0, $a, $a)) {
+                  const r3 = rh2(t42, b22, S22, n22.vertical || y22, i22, 24, x22, e22.overscaling, $a);
+                  for (const n3 of r3) y22 && Sh2(e22, y22.text, z22, n3) || B3(t42, n3);
+                }
+                else if ("line-center" === I22) {
+                  for (const t42 of r22.geometry) if (t42.length > 1) {
+                    const e3 = eh2(t42, S22, n22.vertical || y22, i22, 24, x22);
+                    e3 && B3(t42, e3);
+                  }
+                } else if ("Polygon" === r22.type) for (const t42 of xr(r22.geometry, 0)) {
+                  const e3 = ph2(t42, 16);
+                  B3(t42[0], new Yc2(e3.x, e3.y, 0));
+                }
+                else if ("LineString" === r22.type) for (const t42 of r22.geometry) B3(t42, new Yc2(t42[0].x, t42[0].y, 0));
+                else if ("Point" === r22.type) for (const t42 of r22.geometry) for (const e3 of t42) B3([e3], new Yc2(e3.x, e3.y, 0));
+              }
+              function _h2(t42, e22, r22, n22, i22, a22, o22, l22, u22, c22, h22, p22, f22, d22, y22) {
+                const m22 = function(t5, e3, r3, n3, i3, a3, o3, l3) {
+                  const u3 = n3.layout.get("text-rotate").evaluate(a3, {}) * Math.PI / 180, c3 = [];
+                  for (const t6 of e3.positionedLines) for (const n4 of t6.positionedGlyphs) {
+                    if (!n4.rect) continue;
+                    const a4 = n4.rect || {};
+                    let h3 = Vu + 1, p3 = true, f3 = 1, d3 = 0;
+                    const y3 = (i3 || l3) && n4.vertical, m3 = n4.metrics.advance * n4.scale / 2;
+                    if (l3 && e3.verticalizable && (d3 = t6.lineOffset / 2 - (n4.imageName ? -(iu - n4.metrics.width * n4.scale) / 2 : (n4.scale - 1) * iu)), n4.imageName) {
+                      const t7 = o3[n4.imageName];
+                      p3 = t7.sdf, f3 = t7.pixelRatio, h3 = Fu / f3;
+                    }
+                    const g3 = i3 ? [n4.x + m3, n4.y] : [0, 0];
+                    let x3 = i3 ? [0, 0] : [n4.x + m3 + r3[0], n4.y + r3[1] - d3], v22 = [0, 0];
+                    y3 && (v22 = x3, x3 = [0, 0]);
+                    const b22 = n4.metrics.isDoubleResolution ? 2 : 1, w22 = (n4.metrics.left - h3) * n4.scale - m3 + x3[0], _22 = (-n4.metrics.top - h3) * n4.scale + x3[1], A3 = w22 + a4.w / b22 * n4.scale / f3, S22 = _22 + a4.h / b22 * n4.scale / f3, k22 = new s2(w22, _22), M22 = new s2(A3, _22), I22 = new s2(w22, S22), z22 = new s2(A3, S22);
+                    if (y3) {
+                      const t7 = new s2(-m3, m3 - Du), e4 = -Math.PI / 2, r4 = iu / 2 - m3, i4 = new s2(5 - Du - r4, -(n4.imageName ? r4 : 0)), a5 = new s2(...v22);
+                      k22._rotateAround(e4, t7)._add(i4)._add(a5), M22._rotateAround(e4, t7)._add(i4)._add(a5), I22._rotateAround(e4, t7)._add(i4)._add(a5), z22._rotateAround(e4, t7)._add(i4)._add(a5);
+                    }
+                    if (u3) {
+                      const t7 = Math.sin(u3), e4 = Math.cos(u3), r4 = [e4, -t7, t7, e4];
+                      k22._matMult(r4), M22._matMult(r4), I22._matMult(r4), z22._matMult(r4);
+                    }
+                    const P22 = new s2(0, 0), C3 = new s2(0, 0);
+                    c3.push({ tl: k22, tr: M22, bl: I22, br: z22, tex: a4, writingMode: e3.writingMode, glyphOffset: g3, sectionIndex: n4.sectionIndex, isSDF: p3, pixelOffsetTL: P22, pixelOffsetBR: C3, minFontScaleX: 0, minFontScaleY: 0 });
+                  }
+                  return c3;
+                }(0, r22, l22, i22, a22, o22, n22, t42.allowVerticalPlacement), g22 = t42.textSizeData;
+                let x22 = null;
+                "source" === g22.kind ? (x22 = [nc2 * i22.layout.get("text-size").evaluate(o22, {})], x22[0] > ic2 && A22(`${t42.layerIds[0]}: Value for "text-size" is >= ${rc2}. Reduce your "text-size".`)) : "composite" === g22.kind && (x22 = [nc2 * d22.compositeTextSizes[0].evaluate(o22, {}, y22), nc2 * d22.compositeTextSizes[1].evaluate(o22, {}, y22)], (x22[0] > ic2 || x22[1] > ic2) && A22(`${t42.layerIds[0]}: Value for "text-size" is >= ${rc2}. Reduce your "text-size".`)), t42.addSymbols(t42.text, m22, x22, l22, a22, o22, c22, e22, u22.lineStartIndex, u22.lineLength, f22, y22);
+                for (const e3 of h22) p22[e3] = t42.text.placedSymbolArray.length - 1;
+                return 4 * m22.length;
+              }
+              function Ah2(t42) {
+                for (const e22 in t42) return t42[e22];
+                return null;
+              }
+              function Sh2(t42, e22, r22, n22) {
+                const i22 = t42.compareText;
+                if (e22 in i22) {
+                  const t5 = i22[e22];
+                  for (let e3 = t5.length - 1; e3 >= 0; e3--) if (n22.dist(t5[e3]) < r22) return true;
+                } else i22[e22] = [];
+                return i22[e22].push(n22), false;
+              }
+              const kh2 = [Int8Array, Uint8Array, Uint8ClampedArray, Int16Array, Uint16Array, Int32Array, Uint32Array, Float32Array, Float64Array];
+              class Mh2 {
+                static from(t42) {
+                  if (!(t42 instanceof ArrayBuffer)) throw new Error("Data must be an instance of ArrayBuffer.");
+                  const [e22, r22] = new Uint8Array(t42, 0, 2);
+                  if (219 !== e22) throw new Error("Data does not appear to be in a KDBush format.");
+                  const n22 = r22 >> 4;
+                  if (1 !== n22) throw new Error(`Got v${n22} data when expected v1.`);
+                  const i22 = kh2[15 & r22];
+                  if (!i22) throw new Error("Unrecognized array type.");
+                  const [s22] = new Uint16Array(t42, 2, 1), [a22] = new Uint32Array(t42, 4, 1);
+                  return new Mh2(a22, s22, i22, t42);
+                }
+                constructor(t42, e22 = 64, r22 = Float64Array, n22) {
+                  if (isNaN(t42) || t42 < 0) throw new Error(`Unpexpected numItems value: ${t42}.`);
+                  this.numItems = +t42, this.nodeSize = Math.min(Math.max(+e22, 2), 65535), this.ArrayType = r22, this.IndexArrayType = t42 < 65536 ? Uint16Array : Uint32Array;
+                  const i22 = kh2.indexOf(this.ArrayType), s22 = 2 * t42 * this.ArrayType.BYTES_PER_ELEMENT, a22 = t42 * this.IndexArrayType.BYTES_PER_ELEMENT, o22 = (8 - a22 % 8) % 8;
+                  if (i22 < 0) throw new Error(`Unexpected typed array class: ${r22}.`);
+                  n22 && n22 instanceof ArrayBuffer ? (this.data = n22, this.ids = new this.IndexArrayType(this.data, 8, t42), this.coords = new this.ArrayType(this.data, 8 + a22 + o22, 2 * t42), this._pos = 2 * t42, this._finished = true) : (this.data = new ArrayBuffer(8 + s22 + a22 + o22), this.ids = new this.IndexArrayType(this.data, 8, t42), this.coords = new this.ArrayType(this.data, 8 + a22 + o22, 2 * t42), this._pos = 0, this._finished = false, new Uint8Array(this.data, 0, 2).set([219, 16 + i22]), new Uint16Array(this.data, 2, 1)[0] = e22, new Uint32Array(this.data, 4, 1)[0] = t42);
+                }
+                add(t42, e22) {
+                  const r22 = this._pos >> 1;
+                  return this.ids[r22] = r22, this.coords[this._pos++] = t42, this.coords[this._pos++] = e22, r22;
+                }
+                finish() {
+                  const t42 = this._pos >> 1;
+                  if (t42 !== this.numItems) throw new Error(`Added ${t42} items when expected ${this.numItems}.`);
+                  return Ih2(this.ids, this.coords, this.nodeSize, 0, this.numItems - 1, 0), this._finished = true, this;
+                }
+                range(t42, e22, r22, n22) {
+                  if (!this._finished) throw new Error("Data not yet indexed - call index.finish().");
+                  const { ids: i22, coords: s22, nodeSize: a22 } = this, o22 = [0, i22.length - 1, 0], l22 = [];
+                  for (; o22.length; ) {
+                    const u22 = o22.pop() || 0, c22 = o22.pop() || 0, h22 = o22.pop() || 0;
+                    if (c22 - h22 <= a22) {
+                      for (let a3 = h22; a3 <= c22; a3++) {
+                        const o3 = s22[2 * a3], u3 = s22[2 * a3 + 1];
+                        o3 >= t42 && o3 <= r22 && u3 >= e22 && u3 <= n22 && l22.push(i22[a3]);
+                      }
+                      continue;
+                    }
+                    const p22 = h22 + c22 >> 1, f22 = s22[2 * p22], d22 = s22[2 * p22 + 1];
+                    f22 >= t42 && f22 <= r22 && d22 >= e22 && d22 <= n22 && l22.push(i22[p22]), (0 === u22 ? t42 <= f22 : e22 <= d22) && (o22.push(h22), o22.push(p22 - 1), o22.push(1 - u22)), (0 === u22 ? r22 >= f22 : n22 >= d22) && (o22.push(p22 + 1), o22.push(c22), o22.push(1 - u22));
+                  }
+                  return l22;
+                }
+                within(t42, e22, r22) {
+                  if (!this._finished) throw new Error("Data not yet indexed - call index.finish().");
+                  const { ids: n22, coords: i22, nodeSize: s22 } = this, a22 = [0, n22.length - 1, 0], o22 = [], l22 = r22 * r22;
+                  for (; a22.length; ) {
+                    const u22 = a22.pop() || 0, c22 = a22.pop() || 0, h22 = a22.pop() || 0;
+                    if (c22 - h22 <= s22) {
+                      for (let r3 = h22; r3 <= c22; r3++) Bh2(i22[2 * r3], i22[2 * r3 + 1], t42, e22) <= l22 && o22.push(n22[r3]);
+                      continue;
+                    }
+                    const p22 = h22 + c22 >> 1, f22 = i22[2 * p22], d22 = i22[2 * p22 + 1];
+                    Bh2(f22, d22, t42, e22) <= l22 && o22.push(n22[p22]), (0 === u22 ? t42 - r22 <= f22 : e22 - r22 <= d22) && (a22.push(h22), a22.push(p22 - 1), a22.push(1 - u22)), (0 === u22 ? t42 + r22 >= f22 : e22 + r22 >= d22) && (a22.push(p22 + 1), a22.push(c22), a22.push(1 - u22));
+                  }
+                  return o22;
+                }
+              }
+              function Ih2(t42, e22, r22, n22, i22, s22) {
+                if (i22 - n22 <= r22) return;
+                const a22 = n22 + i22 >> 1;
+                zh2(t42, e22, a22, n22, i22, s22), Ih2(t42, e22, r22, n22, a22 - 1, 1 - s22), Ih2(t42, e22, r22, a22 + 1, i22, 1 - s22);
+              }
+              function zh2(t42, e22, r22, n22, i22, s22) {
+                for (; i22 > n22; ) {
+                  if (i22 - n22 > 600) {
+                    const a3 = i22 - n22 + 1, o3 = r22 - n22 + 1, l3 = Math.log(a3), u22 = 0.5 * Math.exp(2 * l3 / 3), c22 = 0.5 * Math.sqrt(l3 * u22 * (a3 - u22) / a3) * (o3 - a3 / 2 < 0 ? -1 : 1);
+                    zh2(t42, e22, r22, Math.max(n22, Math.floor(r22 - o3 * u22 / a3 + c22)), Math.min(i22, Math.floor(r22 + (a3 - o3) * u22 / a3 + c22)), s22);
+                  }
+                  const a22 = e22[2 * r22 + s22];
+                  let o22 = n22, l22 = i22;
+                  for (Ph2(t42, e22, n22, r22), e22[2 * i22 + s22] > a22 && Ph2(t42, e22, n22, i22); o22 < l22; ) {
+                    for (Ph2(t42, e22, o22, l22), o22++, l22--; e22[2 * o22 + s22] < a22; ) o22++;
+                    for (; e22[2 * l22 + s22] > a22; ) l22--;
+                  }
+                  e22[2 * n22 + s22] === a22 ? Ph2(t42, e22, n22, l22) : (l22++, Ph2(t42, e22, l22, i22)), l22 <= r22 && (n22 = l22 + 1), r22 <= l22 && (i22 = l22 - 1);
+                }
+              }
+              function Ph2(t42, e22, r22, n22) {
+                Ch2(t42, r22, n22), Ch2(e22, 2 * r22, 2 * n22), Ch2(e22, 2 * r22 + 1, 2 * n22 + 1);
+              }
+              function Ch2(t42, e22, r22) {
+                const n22 = t42[e22];
+                t42[e22] = t42[r22], t42[r22] = n22;
+              }
+              function Bh2(t42, e22, r22, n22) {
+                const i22 = t42 - r22, s22 = e22 - n22;
+                return i22 * i22 + s22 * s22;
+              }
+              var Vh2;
+              t4.bg = void 0, (Vh2 = t4.bg || (t4.bg = {})).create = "create", Vh2.load = "load", Vh2.fullLoad = "fullLoad";
+              let Eh2 = null, Fh2 = [];
+              const Th2 = 1e3 / 60, $h2 = "loadTime", Lh2 = "fullLoadTime", Dh2 = { mark(t42) {
+                performance.mark(t42);
+              }, frame(t42) {
+                const e22 = t42;
+                null != Eh2 && Fh2.push(e22 - Eh2), Eh2 = e22;
+              }, clearMetrics() {
+                Eh2 = null, Fh2 = [], performance.clearMeasures($h2), performance.clearMeasures(Lh2);
+                for (const e22 in t4.bg) performance.clearMarks(t4.bg[e22]);
+              }, getPerformanceMetrics() {
+                performance.measure($h2, t4.bg.create, t4.bg.load), performance.measure(Lh2, t4.bg.create, t4.bg.fullLoad);
+                const e22 = performance.getEntriesByName($h2)[0].duration, r22 = performance.getEntriesByName(Lh2)[0].duration, n22 = Fh2.length, i22 = 1 / (Fh2.reduce((t42, e3) => t42 + e3, 0) / n22 / 1e3), s22 = Fh2.filter((t42) => t42 > Th2).reduce((t42, e3) => t42 + (e3 - Th2) / Th2, 0);
+                return { loadTime: e22, fullLoadTime: r22, fps: i22, percentDroppedFrames: s22 / (n22 + s22) * 100, totalFrames: n22 };
+              } };
+              t4.$ = class extends ps {
+              }, t4.A = oo, t4.B = yi2, t4.C = function(t42) {
+                if (null == M2) {
+                  const e22 = t42.navigator ? t42.navigator.userAgent : null;
+                  M2 = !!t42.safari || !(!e22 || !(/\b(iPad|iPhone|iPod)\b/.test(e22) || e22.match("Safari") && !e22.match("Chrome")));
+                }
+                return M2;
+              }, t4.D = Ji2, t4.E = Z2, t4.F = class {
+                constructor(t42, e22) {
+                  this.target = t42, this.mapId = e22, this.resolveRejects = {}, this.tasks = {}, this.taskQueue = [], this.abortControllers = {}, this.messageHandlers = {}, this.invoker = new Ic2(() => this.process()), this.subscription = function(t5, e3, r22, n22) {
+                    return t5.addEventListener(e3, r22, false), { unsubscribe: () => {
+                      t5.removeEventListener(e3, r22, false);
+                    } };
+                  }(this.target, "message", (t5) => this.receive(t5)), this.globalScope = k2(self) ? t42 : window;
+                }
+                registerMessageHandler(t42, e22) {
+                  this.messageHandlers[t42] = e22;
+                }
+                sendAsync(t42, e22) {
+                  return new Promise((r22, n22) => {
+                    const i22 = Math.round(1e18 * Math.random()).toString(36).substring(0, 10);
+                    this.resolveRejects[i22] = { resolve: r22, reject: n22 }, e22 && e22.signal.addEventListener("abort", () => {
+                      delete this.resolveRejects[i22];
+                      const e3 = { id: i22, type: "<cancel>", origin: location.origin, targetMapId: t42.targetMapId, sourceMapId: this.mapId };
+                      this.target.postMessage(e3);
+                    }, { once: true });
+                    const s22 = [], a22 = Object.assign(Object.assign({}, t42), { id: i22, sourceMapId: this.mapId, origin: location.origin, data: ki2(t42.data, s22) });
+                    this.target.postMessage(a22, { transfer: s22 });
+                  });
+                }
+                receive(t42) {
+                  const e22 = t42.data, r22 = e22.id;
+                  if (!("file://" !== e22.origin && "file://" !== location.origin && "resource://android" !== e22.origin && "resource://android" !== location.origin && e22.origin !== location.origin || e22.targetMapId && this.mapId !== e22.targetMapId)) {
+                    if ("<cancel>" === e22.type) {
+                      delete this.tasks[r22];
+                      const t5 = this.abortControllers[r22];
+                      return delete this.abortControllers[r22], void (t5 && t5.abort());
+                    }
+                    if (k2(self) || e22.mustQueue) return this.tasks[r22] = e22, this.taskQueue.push(r22), void this.invoker.trigger();
+                    this.processTask(r22, e22);
+                  }
+                }
+                process() {
+                  if (0 === this.taskQueue.length) return;
+                  const t42 = this.taskQueue.shift(), e22 = this.tasks[t42];
+                  delete this.tasks[t42], this.taskQueue.length > 0 && this.invoker.trigger(), e22 && this.processTask(t42, e22);
+                }
+                processTask(t42, r22) {
+                  return e2(this, void 0, void 0, function* () {
+                    if ("<response>" === r22.type) {
+                      const e3 = this.resolveRejects[t42];
+                      if (delete this.resolveRejects[t42], !e3) return;
+                      return void (r22.error ? e3.reject(Mi2(r22.error)) : e3.resolve(Mi2(r22.data)));
+                    }
+                    if (!this.messageHandlers[r22.type]) return void this.completeTask(t42, new Error(`Could not find a registered handler for ${r22.type}, map ID: ${this.mapId}, available handlers: ${Object.keys(this.messageHandlers).join(", ")}`));
+                    const e22 = Mi2(r22.data), n22 = new AbortController();
+                    this.abortControllers[t42] = n22;
+                    try {
+                      const i22 = yield this.messageHandlers[r22.type](r22.sourceMapId, e22, n22);
+                      this.completeTask(t42, null, i22);
+                    } catch (e3) {
+                      this.completeTask(t42, e3);
+                    }
+                  });
+                }
+                completeTask(t42, e22, r22) {
+                  const n22 = [];
+                  delete this.abortControllers[t42];
+                  const i22 = { id: t42, type: "<response>", sourceMapId: this.mapId, origin: location.origin, error: e22 ? ki2(e22) : null, data: ki2(r22, n22) };
+                  this.target.postMessage(i22, { transfer: n22 });
+                }
+                remove() {
+                  this.invoker.remove(), this.subscription.unsubscribe();
+                }
+              }, t4.G = $2, t4.H = function() {
+                var t42 = new oo(16);
+                return oo != Float32Array && (t42[1] = 0, t42[2] = 0, t42[3] = 0, t42[4] = 0, t42[6] = 0, t42[7] = 0, t42[8] = 0, t42[9] = 0, t42[11] = 0, t42[12] = 0, t42[13] = 0, t42[14] = 0), t42[0] = 1, t42[5] = 1, t42[10] = 1, t42[15] = 1, t42;
+              }, t4.I = Tu, t4.J = function(t42, e22, r22) {
+                var n22, i22, s22, a22, o22, l22, u22, c22, h22, p22, f22, d22, y22 = r22[0], m22 = r22[1], g22 = r22[2];
+                return e22 === t42 ? (t42[12] = e22[0] * y22 + e22[4] * m22 + e22[8] * g22 + e22[12], t42[13] = e22[1] * y22 + e22[5] * m22 + e22[9] * g22 + e22[13], t42[14] = e22[2] * y22 + e22[6] * m22 + e22[10] * g22 + e22[14], t42[15] = e22[3] * y22 + e22[7] * m22 + e22[11] * g22 + e22[15]) : (i22 = e22[1], s22 = e22[2], a22 = e22[3], o22 = e22[4], l22 = e22[5], u22 = e22[6], c22 = e22[7], h22 = e22[8], p22 = e22[9], f22 = e22[10], d22 = e22[11], t42[0] = n22 = e22[0], t42[1] = i22, t42[2] = s22, t42[3] = a22, t42[4] = o22, t42[5] = l22, t42[6] = u22, t42[7] = c22, t42[8] = h22, t42[9] = p22, t42[10] = f22, t42[11] = d22, t42[12] = n22 * y22 + o22 * m22 + h22 * g22 + e22[12], t42[13] = i22 * y22 + l22 * m22 + p22 * g22 + e22[13], t42[14] = s22 * y22 + u22 * m22 + f22 * g22 + e22[14], t42[15] = a22 * y22 + c22 * m22 + d22 * g22 + e22[15]), t42;
+              }, t4.K = function(t42, e22, r22) {
+                var n22 = r22[0], i22 = r22[1], s22 = r22[2];
+                return t42[0] = e22[0] * n22, t42[1] = e22[1] * n22, t42[2] = e22[2] * n22, t42[3] = e22[3] * n22, t42[4] = e22[4] * i22, t42[5] = e22[5] * i22, t42[6] = e22[6] * i22, t42[7] = e22[7] * i22, t42[8] = e22[8] * s22, t42[9] = e22[9] * s22, t42[10] = e22[10] * s22, t42[11] = e22[11] * s22, t42[12] = e22[12], t42[13] = e22[13], t42[14] = e22[14], t42[15] = e22[15], t42;
+              }, t4.L = uo, t4.M = function(t42, e22) {
+                const r22 = {};
+                for (let n22 = 0; n22 < e22.length; n22++) {
+                  const i22 = e22[n22];
+                  i22 in t42 && (r22[i22] = t42[i22]);
+                }
+                return r22;
+              }, t4.N = Pc2, t4.O = Vc2, t4.P = s2, t4.Q = Ec2, t4.R = Ao, t4.S = jc2, t4.T = Zi2, t4.U = h2, t4.V = p2, t4.W = P2, t4.X = $a, t4.Y = ls, t4.Z = $c2, t4._ = e2, t4.a = F2, t4.a$ = function(t42, e22) {
+                var r22 = t42[0], n22 = t42[1], i22 = t42[2], s22 = t42[3], a22 = t42[4], o22 = t42[5], l22 = t42[6], u22 = t42[7], c22 = t42[8], h22 = t42[9], p22 = t42[10], f22 = t42[11], d22 = t42[12], y22 = t42[13], m22 = t42[14], g22 = t42[15], x22 = e22[0], v22 = e22[1], b22 = e22[2], w22 = e22[3], _22 = e22[4], A3 = e22[5], S22 = e22[6], k22 = e22[7], M22 = e22[8], I22 = e22[9], z22 = e22[10], P22 = e22[11], C3 = e22[12], B3 = e22[13], V22 = e22[14], E3 = e22[15];
+                return Math.abs(r22 - x22) <= ao * Math.max(1, Math.abs(r22), Math.abs(x22)) && Math.abs(n22 - v22) <= ao * Math.max(1, Math.abs(n22), Math.abs(v22)) && Math.abs(i22 - b22) <= ao * Math.max(1, Math.abs(i22), Math.abs(b22)) && Math.abs(s22 - w22) <= ao * Math.max(1, Math.abs(s22), Math.abs(w22)) && Math.abs(a22 - _22) <= ao * Math.max(1, Math.abs(a22), Math.abs(_22)) && Math.abs(o22 - A3) <= ao * Math.max(1, Math.abs(o22), Math.abs(A3)) && Math.abs(l22 - S22) <= ao * Math.max(1, Math.abs(l22), Math.abs(S22)) && Math.abs(u22 - k22) <= ao * Math.max(1, Math.abs(u22), Math.abs(k22)) && Math.abs(c22 - M22) <= ao * Math.max(1, Math.abs(c22), Math.abs(M22)) && Math.abs(h22 - I22) <= ao * Math.max(1, Math.abs(h22), Math.abs(I22)) && Math.abs(p22 - z22) <= ao * Math.max(1, Math.abs(p22), Math.abs(z22)) && Math.abs(f22 - P22) <= ao * Math.max(1, Math.abs(f22), Math.abs(P22)) && Math.abs(d22 - C3) <= ao * Math.max(1, Math.abs(d22), Math.abs(C3)) && Math.abs(y22 - B3) <= ao * Math.max(1, Math.abs(y22), Math.abs(B3)) && Math.abs(m22 - V22) <= ao * Math.max(1, Math.abs(m22), Math.abs(V22)) && Math.abs(g22 - E3) <= ao * Math.max(1, Math.abs(g22), Math.abs(E3));
+              }, t4.a0 = oa2, t4.a1 = Dc2, t4.a2 = it2, t4.a3 = (t42) => {
+                const e22 = window.document.createElement("video");
+                return e22.muted = true, new Promise((r22) => {
+                  e22.onloadstart = () => {
+                    r22(e22);
+                  };
+                  for (const r3 of t42) {
+                    const t5 = window.document.createElement("source");
+                    j2(r3) || (e22.crossOrigin = "Anonymous"), t5.src = r3, e22.appendChild(t5);
+                  }
+                });
+              }, t4.a4 = function() {
+                return x2++;
+              }, t4.a5 = Fs, t4.a6 = dc2, t4.a7 = zn, t4.a8 = ja2, t4.a9 = Nc2, t4.aA = function(t42) {
+                if ("custom" === t42.type) return new Mc2(t42);
+                switch (t42.type) {
+                  case "background":
+                    return new _c3(t42);
+                  case "circle":
+                    return new fo(t42);
+                  case "fill":
+                    return new ul2(t42);
+                  case "fill-extrusion":
+                    return new El(t42);
+                  case "heatmap":
+                    return new Mo(t42);
+                  case "hillshade":
+                    return new Po(t42);
+                  case "line":
+                    return new Hl(t42);
+                  case "raster":
+                    return new kc2(t42);
+                  case "symbol":
+                    return new vc2(t42);
+                }
+              }, t4.aB = w2, t4.aC = function(t42, e22) {
+                if (!t42) return [{ command: "setStyle", args: [e22] }];
+                let r22 = [];
+                try {
+                  if (!H2(t42.version, e22.version)) return [{ command: "setStyle", args: [e22] }];
+                  H2(t42.center, e22.center) || r22.push({ command: "setCenter", args: [e22.center] }), H2(t42.zoom, e22.zoom) || r22.push({ command: "setZoom", args: [e22.zoom] }), H2(t42.bearing, e22.bearing) || r22.push({ command: "setBearing", args: [e22.bearing] }), H2(t42.pitch, e22.pitch) || r22.push({ command: "setPitch", args: [e22.pitch] }), H2(t42.sprite, e22.sprite) || r22.push({ command: "setSprite", args: [e22.sprite] }), H2(t42.glyphs, e22.glyphs) || r22.push({ command: "setGlyphs", args: [e22.glyphs] }), H2(t42.transition, e22.transition) || r22.push({ command: "setTransition", args: [e22.transition] }), H2(t42.light, e22.light) || r22.push({ command: "setLight", args: [e22.light] }), H2(t42.terrain, e22.terrain) || r22.push({ command: "setTerrain", args: [e22.terrain] }), H2(t42.sky, e22.sky) || r22.push({ command: "setSky", args: [e22.sky] }), H2(t42.projection, e22.projection) || r22.push({ command: "setProjection", args: [e22.projection] });
+                  const n22 = {}, i22 = [];
+                  !function(t5, e3, r3, n3) {
+                    let i3;
+                    for (i3 in e3 = e3 || {}, t5 = t5 || {}) Object.prototype.hasOwnProperty.call(t5, i3) && (Object.prototype.hasOwnProperty.call(e3, i3) || W2(i3, r3, n3));
+                    for (i3 in e3) Object.prototype.hasOwnProperty.call(e3, i3) && (Object.prototype.hasOwnProperty.call(t5, i3) ? H2(t5[i3], e3[i3]) || ("geojson" === t5[i3].type && "geojson" === e3[i3].type && tt2(t5, e3, i3) ? Y2(r3, { command: "setGeoJSONSourceData", args: [i3, e3[i3].data] }) : Q2(i3, e3, r3, n3)) : J2(i3, e3, r3));
+                  }(t42.sources, e22.sources, i22, n22);
+                  const s22 = [];
+                  t42.layers && t42.layers.forEach((t5) => {
+                    "source" in t5 && n22[t5.source] ? r22.push({ command: "removeLayer", args: [t5.id] }) : s22.push(t5);
+                  }), r22 = r22.concat(i22), function(t5, e3, r3) {
+                    e3 = e3 || [];
+                    const n3 = (t5 = t5 || []).map(rt2), i3 = e3.map(rt2), s3 = t5.reduce(nt2, {}), a22 = e3.reduce(nt2, {}), o22 = n3.slice(), l22 = /* @__PURE__ */ Object.create(null);
+                    let u22, c22, h22, p22, f22;
+                    for (let t6 = 0, e4 = 0; t6 < n3.length; t6++) u22 = n3[t6], Object.prototype.hasOwnProperty.call(a22, u22) ? e4++ : (Y2(r3, { command: "removeLayer", args: [u22] }), o22.splice(o22.indexOf(u22, e4), 1));
+                    for (let t6 = 0, e4 = 0; t6 < i3.length; t6++) u22 = i3[i3.length - 1 - t6], o22[o22.length - 1 - t6] !== u22 && (Object.prototype.hasOwnProperty.call(s3, u22) ? (Y2(r3, { command: "removeLayer", args: [u22] }), o22.splice(o22.lastIndexOf(u22, o22.length - e4), 1)) : e4++, p22 = o22[o22.length - t6], Y2(r3, { command: "addLayer", args: [a22[u22], p22] }), o22.splice(o22.length - t6, 0, u22), l22[u22] = true);
+                    for (let t6 = 0; t6 < i3.length; t6++) if (u22 = i3[t6], c22 = s3[u22], h22 = a22[u22], !l22[u22] && !H2(c22, h22)) if (H2(c22.source, h22.source) && H2(c22["source-layer"], h22["source-layer"]) && H2(c22.type, h22.type)) {
+                      for (f22 in et2(c22.layout, h22.layout, r3, u22, null, "setLayoutProperty"), et2(c22.paint, h22.paint, r3, u22, null, "setPaintProperty"), H2(c22.filter, h22.filter) || Y2(r3, { command: "setFilter", args: [u22, h22.filter] }), H2(c22.minzoom, h22.minzoom) && H2(c22.maxzoom, h22.maxzoom) || Y2(r3, { command: "setLayerZoomRange", args: [u22, h22.minzoom, h22.maxzoom] }), c22) Object.prototype.hasOwnProperty.call(c22, f22) && "layout" !== f22 && "paint" !== f22 && "filter" !== f22 && "metadata" !== f22 && "minzoom" !== f22 && "maxzoom" !== f22 && (0 === f22.indexOf("paint.") ? et2(c22[f22], h22[f22], r3, u22, f22.slice(6), "setPaintProperty") : H2(c22[f22], h22[f22]) || Y2(r3, { command: "setLayerProperty", args: [u22, f22, h22[f22]] }));
+                      for (f22 in h22) Object.prototype.hasOwnProperty.call(h22, f22) && !Object.prototype.hasOwnProperty.call(c22, f22) && "layout" !== f22 && "paint" !== f22 && "filter" !== f22 && "metadata" !== f22 && "minzoom" !== f22 && "maxzoom" !== f22 && (0 === f22.indexOf("paint.") ? et2(c22[f22], h22[f22], r3, u22, f22.slice(6), "setPaintProperty") : H2(c22[f22], h22[f22]) || Y2(r3, { command: "setLayerProperty", args: [u22, f22, h22[f22]] }));
+                    } else Y2(r3, { command: "removeLayer", args: [u22] }), p22 = o22[o22.lastIndexOf(u22) + 1], Y2(r3, { command: "addLayer", args: [h22, p22] });
+                  }(s22, e22.layers, r22);
+                } catch (t5) {
+                  console.warn("Unable to compute style diff:", t5), r22 = [{ command: "setStyle", args: [e22] }];
+                }
+                return r22;
+              }, t4.aD = function(t42) {
+                const e22 = [], r22 = t42.id;
+                return void 0 === r22 && e22.push({ message: `layers.${r22}: missing required property "id"` }), void 0 === t42.render && e22.push({ message: `layers.${r22}: missing required method "render"` }), t42.renderingMode && "2d" !== t42.renderingMode && "3d" !== t42.renderingMode && e22.push({ message: `layers.${r22}: property "renderingMode" must be either "2d" or "3d"` }), e22;
+              }, t4.aE = function t42(e22, r22) {
+                if (Array.isArray(e22)) {
+                  if (!Array.isArray(r22) || e22.length !== r22.length) return false;
+                  for (let n22 = 0; n22 < e22.length; n22++) if (!t42(e22[n22], r22[n22])) return false;
+                  return true;
+                }
+                if ("object" == typeof e22 && null !== e22 && null !== r22) {
+                  if ("object" != typeof r22) return false;
+                  if (Object.keys(e22).length !== Object.keys(r22).length) return false;
+                  for (const n22 in e22) if (!t42(e22[n22], r22[n22])) return false;
+                  return true;
+                }
+                return e22 === r22;
+              }, t4.aF = v2, t4.aG = b2, t4.aH = class extends wa2 {
+                constructor(t42, e22) {
+                  super(t42, e22), this.current = 0;
+                }
+                set(t42) {
+                  this.current !== t42 && (this.current = t42, this.gl.uniform1i(this.location, t42));
+                }
+              }, t4.aI = _a3, t4.aJ = class extends wa2 {
+                constructor(t42, e22) {
+                  super(t42, e22), this.current = ka2;
+                }
+                set(t42) {
+                  if (t42[12] !== this.current[12] || t42[0] !== this.current[0]) return this.current = t42, void this.gl.uniformMatrix4fv(this.location, false, t42);
+                  for (let e22 = 1; e22 < 16; e22++) if (t42[e22] !== this.current[e22]) {
+                    this.current = t42, this.gl.uniformMatrix4fv(this.location, false, t42);
+                    break;
+                  }
+                }
+              }, t4.aK = Aa2, t4.aL = Sa2, t4.aM = Kt, t4.aN = class extends wa2 {
+                constructor(t42, e22) {
+                  super(t42, e22), this.current = [0, 0, 0];
+                }
+                set(t42) {
+                  t42[0] === this.current[0] && t42[1] === this.current[1] && t42[2] === this.current[2] || (this.current = t42, this.gl.uniform3f(this.location, t42[0], t42[1], t42[2]));
+                }
+              }, t4.aO = class extends wa2 {
+                constructor(t42, e22) {
+                  super(t42, e22), this.current = [0, 0];
+                }
+                set(t42) {
+                  t42[0] === this.current[0] && t42[1] === this.current[1] || (this.current = t42, this.gl.uniform2f(this.location, t42[0], t42[1]));
+                }
+              }, t4.aP = function(t42, e22, r22, n22, i22, s22, a22) {
+                var o22 = 1 / (e22 - r22), l22 = 1 / (n22 - i22), u22 = 1 / (s22 - a22);
+                return t42[0] = -2 * o22, t42[1] = 0, t42[2] = 0, t42[3] = 0, t42[4] = 0, t42[5] = -2 * l22, t42[6] = 0, t42[7] = 0, t42[8] = 0, t42[9] = 0, t42[10] = 2 * u22, t42[11] = 0, t42[12] = (e22 + r22) * o22, t42[13] = (i22 + n22) * l22, t42[14] = (a22 + s22) * u22, t42[15] = 1, t42;
+              }, t4.aQ = ho, t4.aR = class extends _s2 {
+              }, t4.aS = eu, t4.aT = class extends Ss {
+              }, t4.aU = ko, t4.aV = function(t42) {
+                return t42 <= 1 ? 1 : Math.pow(2, Math.ceil(Math.log(t42) / Math.LN2));
+              }, t4.aW = So, t4.aX = Zs, t4.aY = na, t4.aZ = class extends Bs {
+              }, t4.a_ = function(t42, e22) {
+                return t42[0] === e22[0] && t42[1] === e22[1] && t42[2] === e22[2] && t42[3] === e22[3] && t42[4] === e22[4] && t42[5] === e22[5] && t42[6] === e22[6] && t42[7] === e22[7] && t42[8] === e22[8] && t42[9] === e22[9] && t42[10] === e22[10] && t42[11] === e22[11] && t42[12] === e22[12] && t42[13] === e22[13] && t42[14] === e22[14] && t42[15] === e22[15];
+              }, t4.aa = function(t42) {
+                const e22 = {};
+                if (t42.replace(/(?:^|(?:\s*\,\s*))([^\x00-\x20\(\)<>@\,;\:\\"\/\[\]\?\=\{\}\x7F]+)(?:\=(?:([^\x00-\x20\(\)<>@\,;\:\\"\/\[\]\?\=\{\}\x7F]+)|(?:\"((?:[^"\\]|\\.)*)\")))?/g, (t5, r22, n22, i22) => {
+                  const s22 = n22 || i22;
+                  return e22[r22] = !s22 || s22.toLowerCase(), "";
+                }), e22["max-age"]) {
+                  const t5 = parseInt(e22["max-age"], 10);
+                  isNaN(t5) ? delete e22["max-age"] : e22["max-age"] = t5;
+                }
+                return e22;
+              }, t4.ab = function(t42, e22) {
+                const r22 = [];
+                for (const n22 in t42) n22 in e22 || r22.push(n22);
+                return r22;
+              }, t4.ac = y2, t4.ad = function(t42, e22, r22) {
+                var n22 = Math.sin(r22), i22 = Math.cos(r22), s22 = e22[0], a22 = e22[1], o22 = e22[2], l22 = e22[3], u22 = e22[4], c22 = e22[5], h22 = e22[6], p22 = e22[7];
+                return e22 !== t42 && (t42[8] = e22[8], t42[9] = e22[9], t42[10] = e22[10], t42[11] = e22[11], t42[12] = e22[12], t42[13] = e22[13], t42[14] = e22[14], t42[15] = e22[15]), t42[0] = s22 * i22 + u22 * n22, t42[1] = a22 * i22 + c22 * n22, t42[2] = o22 * i22 + h22 * n22, t42[3] = l22 * i22 + p22 * n22, t42[4] = u22 * i22 - s22 * n22, t42[5] = c22 * i22 - a22 * n22, t42[6] = h22 * i22 - o22 * n22, t42[7] = p22 * i22 - l22 * n22, t42;
+              }, t4.ae = function(t42) {
+                var e22 = new oo(16);
+                return e22[0] = t42[0], e22[1] = t42[1], e22[2] = t42[2], e22[3] = t42[3], e22[4] = t42[4], e22[5] = t42[5], e22[6] = t42[6], e22[7] = t42[7], e22[8] = t42[8], e22[9] = t42[9], e22[10] = t42[10], e22[11] = t42[11], e22[12] = t42[12], e22[13] = t42[13], e22[14] = t42[14], e22[15] = t42[15], e22;
+              }, t4.af = po, t4.ag = function(t42, e22) {
+                let r22 = 0, n22 = 0;
+                if ("constant" === t42.kind) n22 = t42.layoutSize;
+                else if ("source" !== t42.kind) {
+                  const { interpolationType: i22, minZoom: s22, maxZoom: a22 } = t42, o22 = i22 ? y2(Be2.interpolationFactor(i22, e22, s22, a22), 0, 1) : 0;
+                  "camera" === t42.kind ? n22 = Ce2.number(t42.minSize, t42.maxSize, o22) : r22 = o22;
+                }
+                return { uSizeT: r22, uSize: n22 };
+              }, t4.ai = function(t42, { uSize: e22, uSizeT: r22 }, { lowerSize: n22, upperSize: i22 }) {
+                return "source" === t42.kind ? n22 / nc2 : "composite" === t42.kind ? Ce2.number(n22 / nc2, i22 / nc2, r22) : e22;
+              }, t4.aj = cc2, t4.ak = function(t42, e22, r22, n22) {
+                const i22 = e22.y - t42.y, a22 = e22.x - t42.x, o22 = n22.y - r22.y, l22 = n22.x - r22.x, u22 = o22 * a22 - l22 * i22;
+                if (0 === u22) return null;
+                const c22 = (l22 * (t42.y - r22.y) - o22 * (t42.x - r22.x)) / u22;
+                return new s2(t42.x + c22 * a22, t42.y + c22 * i22);
+              }, t4.al = Hc2, t4.am = qa2, t4.an = lo, t4.ao = function(t42) {
+                let e22 = 1 / 0, r22 = 1 / 0, n22 = -1 / 0, i22 = -1 / 0;
+                for (const s22 of t42) e22 = Math.min(e22, s22.x), r22 = Math.min(r22, s22.y), n22 = Math.max(n22, s22.x), i22 = Math.max(i22, s22.y);
+                return [e22, r22, n22, i22];
+              }, t4.ap = iu, t4.ar = ac2, t4.as = function(t42, e22) {
+                var r22 = e22[0], n22 = e22[1], i22 = e22[2], s22 = e22[3], a22 = e22[4], o22 = e22[5], l22 = e22[6], u22 = e22[7], c22 = e22[8], h22 = e22[9], p22 = e22[10], f22 = e22[11], d22 = e22[12], y22 = e22[13], m22 = e22[14], g22 = e22[15], x22 = r22 * o22 - n22 * a22, v22 = r22 * l22 - i22 * a22, b22 = r22 * u22 - s22 * a22, w22 = n22 * l22 - i22 * o22, _22 = n22 * u22 - s22 * o22, A3 = i22 * u22 - s22 * l22, S22 = c22 * y22 - h22 * d22, k22 = c22 * m22 - p22 * d22, M22 = c22 * g22 - f22 * d22, I22 = h22 * m22 - p22 * y22, z22 = h22 * g22 - f22 * y22, P22 = p22 * g22 - f22 * m22, C3 = x22 * P22 - v22 * z22 + b22 * I22 + w22 * M22 - _22 * k22 + A3 * S22;
+                return C3 ? (t42[0] = (o22 * P22 - l22 * z22 + u22 * I22) * (C3 = 1 / C3), t42[1] = (i22 * z22 - n22 * P22 - s22 * I22) * C3, t42[2] = (y22 * A3 - m22 * _22 + g22 * w22) * C3, t42[3] = (p22 * _22 - h22 * A3 - f22 * w22) * C3, t42[4] = (l22 * M22 - a22 * P22 - u22 * k22) * C3, t42[5] = (r22 * P22 - i22 * M22 + s22 * k22) * C3, t42[6] = (m22 * b22 - d22 * A3 - g22 * v22) * C3, t42[7] = (c22 * A3 - p22 * b22 + f22 * v22) * C3, t42[8] = (a22 * z22 - o22 * M22 + u22 * S22) * C3, t42[9] = (n22 * M22 - r22 * z22 - s22 * S22) * C3, t42[10] = (d22 * _22 - y22 * b22 + g22 * x22) * C3, t42[11] = (h22 * b22 - c22 * _22 - f22 * x22) * C3, t42[12] = (o22 * k22 - a22 * I22 - l22 * S22) * C3, t42[13] = (r22 * I22 - n22 * k22 + i22 * S22) * C3, t42[14] = (y22 * v22 - d22 * w22 - m22 * x22) * C3, t42[15] = (c22 * w22 - h22 * v22 + p22 * x22) * C3, t42) : null;
+              }, t4.at = bh2, t4.au = Ju, t4.av = Mh2, t4.aw = function() {
+                const t42 = {}, e22 = G2.$version;
+                for (const r22 in G2.$root) {
+                  const n22 = G2.$root[r22];
+                  if (n22.required) {
+                    let i22 = null;
+                    i22 = "version" === r22 ? e22 : "array" === n22.type ? [] : {}, null != i22 && (t42[r22] = i22);
+                  }
+                }
+                return t42;
+              }, t4.ax = Ii2, t4.ay = D22, t4.az = function(t42) {
+                t42 = t42.slice();
+                const e22 = /* @__PURE__ */ Object.create(null);
+                for (let r22 = 0; r22 < t42.length; r22++) e22[t42[r22].id] = t42[r22];
+                for (let r22 = 0; r22 < t42.length; r22++) "ref" in t42[r22] && (t42[r22] = X2(t42[r22], e22[t42[r22].ref]));
+                return t42;
+              }, t4.b = I2, t4.b0 = function(t42, e22) {
+                return t42[0] = e22[0], t42[1] = e22[1], t42[2] = e22[2], t42[3] = e22[3], t42[4] = e22[4], t42[5] = e22[5], t42[6] = e22[6], t42[7] = e22[7], t42[8] = e22[8], t42[9] = e22[9], t42[10] = e22[10], t42[11] = e22[11], t42[12] = e22[12], t42[13] = e22[13], t42[14] = e22[14], t42[15] = e22[15], t42;
+              }, t4.b1 = function(t42, e22, r22) {
+                return t42[0] = e22[0] * r22[0], t42[1] = e22[1] * r22[1], t42[2] = e22[2] * r22[2], t42[3] = e22[3] * r22[3], t42;
+              }, t4.b2 = function(t42, e22) {
+                return t42[0] * e22[0] + t42[1] * e22[1] + t42[2] * e22[2] + t42[3] * e22[3];
+              }, t4.b3 = m2, t4.b4 = Oc2, t4.b5 = Fc2, t4.b6 = function(t42, e22, r22, n22, i22) {
+                var s22, a22 = 1 / Math.tan(e22 / 2);
+                return t42[0] = a22 / r22, t42[1] = 0, t42[2] = 0, t42[3] = 0, t42[4] = 0, t42[5] = a22, t42[6] = 0, t42[7] = 0, t42[8] = 0, t42[9] = 0, t42[11] = -1, t42[12] = 0, t42[13] = 0, t42[15] = 0, null != i22 && i22 !== 1 / 0 ? (t42[10] = (i22 + n22) * (s22 = 1 / (n22 - i22)), t42[14] = 2 * i22 * n22 * s22) : (t42[10] = -1, t42[14] = -2 * n22), t42;
+              }, t4.b7 = function(t42, e22, r22) {
+                var n22 = Math.sin(r22), i22 = Math.cos(r22), s22 = e22[4], a22 = e22[5], o22 = e22[6], l22 = e22[7], u22 = e22[8], c22 = e22[9], h22 = e22[10], p22 = e22[11];
+                return e22 !== t42 && (t42[0] = e22[0], t42[1] = e22[1], t42[2] = e22[2], t42[3] = e22[3], t42[12] = e22[12], t42[13] = e22[13], t42[14] = e22[14], t42[15] = e22[15]), t42[4] = s22 * i22 + u22 * n22, t42[5] = a22 * i22 + c22 * n22, t42[6] = o22 * i22 + h22 * n22, t42[7] = l22 * i22 + p22 * n22, t42[8] = u22 * i22 - s22 * n22, t42[9] = c22 * i22 - a22 * n22, t42[10] = h22 * i22 - o22 * n22, t42[11] = p22 * i22 - l22 * n22, t42;
+              }, t4.b8 = f2, t4.b9 = d2, t4.bA = su, t4.bB = function(t42) {
+                return t42.message === V2;
+              }, t4.bC = bn, t4.bD = Ri2, t4.ba = function(t42) {
+                return t42 * Math.PI / 180;
+              }, t4.bb = function(t42, e22) {
+                const { x: r22, y: n22 } = $c2.fromLngLat(e22);
+                return !(t42 < 0 || t42 > 25 || n22 < 0 || n22 >= 1 || r22 < 0 || r22 >= 1);
+              }, t4.bc = function(t42, e22) {
+                return t42[0] = e22[0], t42[1] = 0, t42[2] = 0, t42[3] = 0, t42[4] = 0, t42[5] = e22[1], t42[6] = 0, t42[7] = 0, t42[8] = 0, t42[9] = 0, t42[10] = e22[2], t42[11] = 0, t42[12] = 0, t42[13] = 0, t42[14] = 0, t42[15] = 1, t42;
+              }, t4.bd = class extends hs {
+              }, t4.be = zc2, t4.bf = Dh2, t4.bh = L2, t4.bi = function(t42, e22) {
+                F2.REGISTERED_PROTOCOLS[t42] = e22;
+              }, t4.bj = function(t42) {
+                delete F2.REGISTERED_PROTOCOLS[t42];
+              }, t4.bk = function(t42, e22) {
+                const r22 = {};
+                for (let n3 = 0; n3 < t42.length; n3++) {
+                  const i22 = e22 && e22[t42[n3].id] || Ln(t42[n3]);
+                  e22 && (e22[t42[n3].id] = i22);
+                  let s22 = r22[i22];
+                  s22 || (s22 = r22[i22] = []), s22.push(t42[n3]);
+                }
+                const n22 = [];
+                for (const t5 in r22) n22.push(r22[t5]);
+                return n22;
+              }, t4.bl = wi2, t4.bm = qc2, t4.bn = Zc2, t4.bo = $u, t4.bp = function(e22) {
+                e22.bucket.createArrays(), e22.bucket.tilePixelRatio = $a / (512 * e22.bucket.overscaling), e22.bucket.compareText = {}, e22.bucket.iconsNeedLinear = false;
+                const r22 = e22.bucket.layers[0], n22 = r22.layout, i22 = r22._unevaluatedLayout._values, s22 = { layoutIconSize: i22["icon-size"].possiblyEvaluate(new Ui2(e22.bucket.zoom + 1), e22.canonical), layoutTextSize: i22["text-size"].possiblyEvaluate(new Ui2(e22.bucket.zoom + 1), e22.canonical), textMaxSize: i22["text-size"].possiblyEvaluate(new Ui2(18)) };
+                if ("composite" === e22.bucket.textSizeData.kind) {
+                  const { minZoom: t42, maxZoom: r3 } = e22.bucket.textSizeData;
+                  s22.compositeTextSizes = [i22["text-size"].possiblyEvaluate(new Ui2(t42), e22.canonical), i22["text-size"].possiblyEvaluate(new Ui2(r3), e22.canonical)];
+                }
+                if ("composite" === e22.bucket.iconSizeData.kind) {
+                  const { minZoom: t42, maxZoom: r3 } = e22.bucket.iconSizeData;
+                  s22.compositeIconSizes = [i22["icon-size"].possiblyEvaluate(new Ui2(t42), e22.canonical), i22["icon-size"].possiblyEvaluate(new Ui2(r3), e22.canonical)];
+                }
+                const a22 = n22.get("text-line-height") * iu, o22 = "viewport" !== n22.get("text-rotation-alignment") && "point" !== n22.get("symbol-placement"), l22 = n22.get("text-keep-upright"), u22 = n22.get("text-size");
+                for (const i3 of e22.bucket.features) {
+                  const c22 = n22.get("text-font").evaluate(i3, {}, e22.canonical).join(","), h22 = u22.evaluate(i3, {}, e22.canonical), p22 = s22.layoutTextSize.evaluate(i3, {}, e22.canonical), f22 = s22.layoutIconSize.evaluate(i3, {}, e22.canonical), d22 = { horizontal: {}, vertical: void 0 }, y22 = i3.text;
+                  let m22, g22 = [0, 0];
+                  if (y22) {
+                    const s3 = y22.toString(), u3 = n22.get("text-letter-spacing").evaluate(i3, {}, e22.canonical) * iu, f3 = Ci2(s3) ? u3 : 0, m3 = n22.get("text-anchor").evaluate(i3, {}, e22.canonical), x3 = vh2(r22, i3, e22.canonical);
+                    if (!x3) {
+                      const t42 = n22.get("text-radial-offset").evaluate(i3, {}, e22.canonical);
+                      g22 = t42 ? xh2(m3, [t42 * iu, gh2]) : n22.get("text-offset").evaluate(i3, {}, e22.canonical).map((t5) => t5 * iu);
+                    }
+                    let v3 = o22 ? "center" : n22.get("text-justify").evaluate(i3, {}, e22.canonical);
+                    const b22 = "point" === n22.get("symbol-placement") ? n22.get("text-max-width").evaluate(i3, {}, e22.canonical) * iu : 1 / 0, w22 = () => {
+                      e22.bucket.allowVerticalPlacement && Pi2(s3) && (d22.vertical = Ru(y22, e22.glyphMap, e22.glyphPositions, e22.imagePositions, c22, b22, a22, m3, "left", f3, g22, t4.ah.vertical, true, p22, h22));
+                    };
+                    if (!o22 && x3) {
+                      const r3 = /* @__PURE__ */ new Set();
+                      if ("auto" === v3) for (let t42 = 0; t42 < x3.values.length; t42 += 2) r3.add(bh2(x3.values[t42]));
+                      else r3.add(v3);
+                      let n3 = false;
+                      for (const i4 of r3) if (!d22.horizontal[i4]) if (n3) d22.horizontal[i4] = d22.horizontal[0];
+                      else {
+                        const r4 = Ru(y22, e22.glyphMap, e22.glyphPositions, e22.imagePositions, c22, b22, a22, "center", i4, f3, g22, t4.ah.horizontal, false, p22, h22);
+                        r4 && (d22.horizontal[i4] = r4, n3 = 1 === r4.positionedLines.length);
+                      }
+                      w22();
+                    } else {
+                      "auto" === v3 && (v3 = bh2(m3));
+                      const r3 = Ru(y22, e22.glyphMap, e22.glyphPositions, e22.imagePositions, c22, b22, a22, m3, v3, f3, g22, t4.ah.horizontal, false, p22, h22);
+                      r3 && (d22.horizontal[v3] = r3), w22(), Pi2(s3) && o22 && l22 && (d22.vertical = Ru(y22, e22.glyphMap, e22.glyphPositions, e22.imagePositions, c22, b22, a22, m3, v3, f3, g22, t4.ah.vertical, false, p22, h22));
+                    }
+                  }
+                  let x22 = false;
+                  if (i3.icon && i3.icon.name) {
+                    const t42 = e22.imageMap[i3.icon.name];
+                    t42 && (m22 = Qu(e22.imagePositions[i3.icon.name], n22.get("icon-offset").evaluate(i3, {}, e22.canonical), n22.get("icon-anchor").evaluate(i3, {}, e22.canonical)), x22 = !!t42.sdf, void 0 === e22.bucket.sdfIcons ? e22.bucket.sdfIcons = x22 : e22.bucket.sdfIcons !== x22 && A22("Style sheet warning: Cannot mix SDF and non-SDF icons in one buffer"), (t42.pixelRatio !== e22.bucket.pixelRatio || 0 !== n22.get("icon-rotate").constantOr(1)) && (e22.bucket.iconsNeedLinear = true));
+                  }
+                  const v22 = Ah2(d22.horizontal) || d22.vertical;
+                  e22.bucket.iconsInText = !!v22 && v22.iconsInText, (v22 || m22) && wh2(e22.bucket, i3, d22, m22, e22.imageMap, s22, p22, f22, g22, x22, e22.canonical);
+                }
+                e22.showCollisionBoxes && e22.bucket.generateCollisionDebugBuffers();
+              }, t4.bq = ql2, t4.br = sl2, t4.bs = zl, t4.bt = fl2, t4.bu = Iu, t4.bv = class {
+                constructor(t42) {
+                  this._marks = { start: [t42.url, "start"].join("#"), end: [t42.url, "end"].join("#"), measure: t42.url.toString() }, performance.mark(this._marks.start);
+                }
+                finish() {
+                  performance.mark(this._marks.end);
+                  let t42 = performance.getEntriesByName(this._marks.measure);
+                  return 0 === t42.length && (performance.measure(this._marks.measure, this._marks.start, this._marks.end), t42 = performance.getEntriesByName(this._marks.measure), performance.clearMarks(this._marks.start), performance.clearMarks(this._marks.end), performance.clearMeasures(this._marks.measure)), t42;
+                }
+              }, t4.bw = function(t42, r22, n22, i22, s22) {
+                return e2(this, void 0, void 0, function* () {
+                  if (p2()) try {
+                    return yield P2(t42, r22, n22, i22, s22);
+                  } catch (t5) {
+                  }
+                  return function(t5, e22, r3, n3, i3) {
+                    const s3 = t5.width, a22 = t5.height;
+                    C22 && B22 || (C22 = new OffscreenCanvas(s3, a22), B22 = C22.getContext("2d", { willReadFrequently: true })), C22.width = s3, C22.height = a22, B22.drawImage(t5, 0, 0, s3, a22);
+                    const o22 = B22.getImageData(e22, r3, n3, i3);
+                    return B22.clearRect(0, 0, s3, a22), o22.data;
+                  }(t42, r22, n22, i22, s22);
+                });
+              }, t4.bx = Uc2, t4.by = r2, t4.bz = n2, t4.c = E22, t4.d = (t42) => e2(void 0, void 0, void 0, function* () {
+                if (0 === t42.byteLength) return createImageBitmap(new ImageData(1, 1));
+                const e22 = new Blob([new Uint8Array(t42)], { type: "image/png" });
+                try {
+                  return createImageBitmap(e22);
+                } catch (t5) {
+                  throw new Error(`Could not load image because of ${t5.message}. Please make sure to use a supported image type such as PNG or JPEG. Note that SVGs are not supported.`);
+                }
+              }), t4.e = g2, t4.f = (t42) => new Promise((e22, r22) => {
+                const n22 = new Image();
+                n22.onload = () => {
+                  e22(n22), URL.revokeObjectURL(n22.src), n22.onload = null, window.requestAnimationFrame(() => {
+                    n22.src = z2;
+                  });
+                }, n22.onerror = () => r22(new Error("Could not load image. Please make sure to use a supported image type such as PNG or JPEG. Note that SVGs are not supported."));
+                const i22 = new Blob([new Uint8Array(t42)], { type: "image/png" });
+                n22.src = t42.byteLength ? URL.createObjectURL(i22) : z2;
+              }), t4.g = T2, t4.h = (t42, e22) => O2(g2(t42, { type: "json" }), e22), t4.i = k2, t4.j = N2, t4.k = q2, t4.l = (t42, e22) => O2(g2(t42, { type: "arrayBuffer" }), e22), t4.m = O2, t4.n = function(t42) {
+                return new Iu(t42).readFields(Pu, []);
+              }, t4.o = _o2, t4.p = Eu, t4.q = rs, t4.r = di2, t4.s = j2, t4.t = xi2, t4.u = fi2, t4.v = G2, t4.w = A22, t4.x = function([t42, e22, r22]) {
+                return e22 += 90, e22 *= Math.PI / 180, r22 *= Math.PI / 180, { x: t42 * Math.cos(e22) * Math.sin(r22), y: t42 * Math.sin(e22) * Math.sin(r22), z: t42 * Math.cos(r22) };
+              }, t4.y = Ce2, t4.z = Ui2;
+            });
+            define2("worker", ["./shared"], function(e2) {
+              class t4 {
+                constructor(e22) {
+                  this.keyCache = {}, e22 && this.replace(e22);
+                }
+                replace(e22) {
+                  this._layerConfigs = {}, this._layers = {}, this.update(e22, []);
+                }
+                update(t42, o22) {
+                  for (const o3 of t42) {
+                    this._layerConfigs[o3.id] = o3;
+                    const t5 = this._layers[o3.id] = e2.aA(o3);
+                    t5._featureFilter = e2.a7(t5.filter), this.keyCache[o3.id] && delete this.keyCache[o3.id];
+                  }
+                  for (const e22 of o22) delete this.keyCache[e22], delete this._layerConfigs[e22], delete this._layers[e22];
+                  this.familiesBySource = {};
+                  const i22 = e2.bk(Object.values(this._layerConfigs), this.keyCache);
+                  for (const e22 of i22) {
+                    const t5 = e22.map((e3) => this._layers[e3.id]), o3 = t5[0];
+                    if ("none" === o3.visibility) continue;
+                    const i3 = o3.source || "";
+                    let s22 = this.familiesBySource[i3];
+                    s22 || (s22 = this.familiesBySource[i3] = {});
+                    const r22 = o3.sourceLayer || "_geojsonTileLayer";
+                    let n22 = s22[r22];
+                    n22 || (n22 = s22[r22] = []), n22.push(t5);
+                  }
+                }
+              }
+              class o2 {
+                constructor(t42) {
+                  const o22 = {}, i22 = [];
+                  for (const e22 in t42) {
+                    const s3 = t42[e22], r3 = o22[e22] = {};
+                    for (const e3 in s3) {
+                      const t5 = s3[+e3];
+                      if (!t5 || 0 === t5.bitmap.width || 0 === t5.bitmap.height) continue;
+                      const o3 = { x: 0, y: 0, w: t5.bitmap.width + 2, h: t5.bitmap.height + 2 };
+                      i22.push(o3), r3[e3] = { rect: o3, metrics: t5.metrics };
+                    }
+                  }
+                  const { w: s22, h: r22 } = e2.p(i22), n22 = new e2.o({ width: s22 || 1, height: r22 || 1 });
+                  for (const i3 in t42) {
+                    const s3 = t42[i3];
+                    for (const t5 in s3) {
+                      const r3 = s3[+t5];
+                      if (!r3 || 0 === r3.bitmap.width || 0 === r3.bitmap.height) continue;
+                      const a22 = o22[i3][t5].rect;
+                      e2.o.copy(r3.bitmap, n22, { x: 0, y: 0 }, { x: a22.x + 1, y: a22.y + 1 }, r3.bitmap);
+                    }
+                  }
+                  this.image = n22, this.positions = o22;
+                }
+              }
+              e2.bl("GlyphAtlas", o2);
+              class i2 {
+                constructor(t42) {
+                  this.tileID = new e2.S(t42.tileID.overscaledZ, t42.tileID.wrap, t42.tileID.canonical.z, t42.tileID.canonical.x, t42.tileID.canonical.y), this.uid = t42.uid, this.zoom = t42.zoom, this.pixelRatio = t42.pixelRatio, this.tileSize = t42.tileSize, this.source = t42.source, this.overscaling = this.tileID.overscaleFactor(), this.showCollisionBoxes = t42.showCollisionBoxes, this.collectResourceTiming = !!t42.collectResourceTiming, this.returnDependencies = !!t42.returnDependencies, this.promoteId = t42.promoteId, this.inFlightDependencies = [];
+                }
+                parse(t42, i22, r22, n22) {
+                  return e2._(this, void 0, void 0, function* () {
+                    this.status = "parsing", this.data = t42, this.collisionBoxArray = new e2.a5();
+                    const a22 = new e2.bm(Object.keys(t42.layers).sort()), l22 = new e2.bn(this.tileID, this.promoteId);
+                    l22.bucketLayerIDs = [];
+                    const c22 = {}, u22 = { featureIndex: l22, iconDependencies: {}, patternDependencies: {}, glyphDependencies: {}, availableImages: r22 }, h22 = i22.familiesBySource[this.source];
+                    for (const o22 in h22) {
+                      const i3 = t42.layers[o22];
+                      if (!i3) continue;
+                      1 === i3.version && e2.w(`Vector tile source "${this.source}" layer "${o22}" does not use vector tile spec v2 and therefore may have some rendering errors.`);
+                      const n3 = a22.encode(o22), d3 = [];
+                      for (let e22 = 0; e22 < i3.length; e22++) {
+                        const t5 = i3.feature(e22), s22 = l22.getId(t5, o22);
+                        d3.push({ feature: t5, id: s22, index: e22, sourceLayerIndex: n3 });
+                      }
+                      for (const t5 of h22[o22]) {
+                        const o3 = t5[0];
+                        o3.source !== this.source && e2.w(`layer.source = ${o3.source} does not equal this.source = ${this.source}`), o3.minzoom && this.zoom < Math.floor(o3.minzoom) || o3.maxzoom && this.zoom >= o3.maxzoom || "none" !== o3.visibility && (s2(t5, this.zoom, r22), (c22[o3.id] = o3.createBucket({ index: l22.bucketLayerIDs.length, layers: t5, zoom: this.zoom, pixelRatio: this.pixelRatio, overscaling: this.overscaling, collisionBoxArray: this.collisionBoxArray, sourceLayerIndex: n3, sourceID: this.source })).populate(d3, u22, this.tileID.canonical), l22.bucketLayerIDs.push(t5.map((e22) => e22.id)));
+                      }
+                    }
+                    const d22 = e2.aF(u22.glyphDependencies, (e22) => Object.keys(e22).map(Number));
+                    this.inFlightDependencies.forEach((e22) => null == e22 ? void 0 : e22.abort()), this.inFlightDependencies = [];
+                    let f22 = Promise.resolve({});
+                    if (Object.keys(d22).length) {
+                      const e22 = new AbortController();
+                      this.inFlightDependencies.push(e22), f22 = n22.sendAsync({ type: "GG", data: { stacks: d22, source: this.source, tileID: this.tileID, type: "glyphs" } }, e22);
+                    }
+                    const g22 = Object.keys(u22.iconDependencies);
+                    let p22 = Promise.resolve({});
+                    if (g22.length) {
+                      const e22 = new AbortController();
+                      this.inFlightDependencies.push(e22), p22 = n22.sendAsync({ type: "GI", data: { icons: g22, source: this.source, tileID: this.tileID, type: "icons" } }, e22);
+                    }
+                    const m22 = Object.keys(u22.patternDependencies);
+                    let y22 = Promise.resolve({});
+                    if (m22.length) {
+                      const e22 = new AbortController();
+                      this.inFlightDependencies.push(e22), y22 = n22.sendAsync({ type: "GI", data: { icons: m22, source: this.source, tileID: this.tileID, type: "patterns" } }, e22);
+                    }
+                    const [v22, w22, x22] = yield Promise.all([f22, p22, y22]), b22 = new o2(v22), S22 = new e2.bo(w22, x22);
+                    for (const t5 in c22) {
+                      const o22 = c22[t5];
+                      o22 instanceof e2.a6 ? (s2(o22.layers, this.zoom, r22), e2.bp({ bucket: o22, glyphMap: v22, glyphPositions: b22.positions, imageMap: w22, imagePositions: S22.iconPositions, showCollisionBoxes: this.showCollisionBoxes, canonical: this.tileID.canonical })) : o22.hasPattern && (o22 instanceof e2.bq || o22 instanceof e2.br || o22 instanceof e2.bs) && (s2(o22.layers, this.zoom, r22), o22.addFeatures(u22, this.tileID.canonical, S22.patternPositions));
+                    }
+                    return this.status = "done", { buckets: Object.values(c22).filter((e22) => !e22.isEmpty()), featureIndex: l22, collisionBoxArray: this.collisionBoxArray, glyphAtlasImage: b22.image, imageAtlas: S22, glyphMap: this.returnDependencies ? v22 : null, iconMap: this.returnDependencies ? w22 : null, glyphPositions: this.returnDependencies ? b22.positions : null };
+                  });
+                }
+              }
+              function s2(t42, o22, i22) {
+                const s22 = new e2.z(o22);
+                for (const e22 of t42) e22.recalculate(s22, i22);
+              }
+              class r2 {
+                constructor(e22, t42, o22) {
+                  this.actor = e22, this.layerIndex = t42, this.availableImages = o22, this.fetching = {}, this.loading = {}, this.loaded = {};
+                }
+                loadVectorTile(t42, o22) {
+                  return e2._(this, void 0, void 0, function* () {
+                    const i22 = yield e2.l(t42.request, o22);
+                    try {
+                      return { vectorTile: new e2.bt.VectorTile(new e2.bu(i22.data)), rawData: i22.data, cacheControl: i22.cacheControl, expires: i22.expires };
+                    } catch (e22) {
+                      const o3 = new Uint8Array(i22.data);
+                      let s22 = `Unable to parse the tile at ${t42.request.url}, `;
+                      throw s22 += 31 === o3[0] && 139 === o3[1] ? "please make sure the data is not gzipped and that you have configured the relevant header in the server" : `got error: ${e22.message}`, new Error(s22);
+                    }
+                  });
+                }
+                loadTile(t42) {
+                  return e2._(this, void 0, void 0, function* () {
+                    const o22 = t42.uid, s22 = !!(t42 && t42.request && t42.request.collectResourceTiming) && new e2.bv(t42.request), r22 = new i2(t42);
+                    this.loading[o22] = r22;
+                    const n22 = new AbortController();
+                    r22.abort = n22;
+                    try {
+                      const i22 = yield this.loadVectorTile(t42, n22);
+                      if (delete this.loading[o22], !i22) return null;
+                      const a22 = i22.rawData, l22 = {};
+                      i22.expires && (l22.expires = i22.expires), i22.cacheControl && (l22.cacheControl = i22.cacheControl);
+                      const c22 = {};
+                      if (s22) {
+                        const e22 = s22.finish();
+                        e22 && (c22.resourceTiming = JSON.parse(JSON.stringify(e22)));
+                      }
+                      r22.vectorTile = i22.vectorTile;
+                      const u22 = r22.parse(i22.vectorTile, this.layerIndex, this.availableImages, this.actor);
+                      this.loaded[o22] = r22, this.fetching[o22] = { rawTileData: a22, cacheControl: l22, resourceTiming: c22 };
+                      try {
+                        const t5 = yield u22;
+                        return e2.e({ rawTileData: a22.slice(0) }, t5, l22, c22);
+                      } finally {
+                        delete this.fetching[o22];
+                      }
+                    } catch (e22) {
+                      throw delete this.loading[o22], r22.status = "done", this.loaded[o22] = r22, e22;
+                    }
+                  });
+                }
+                reloadTile(t42) {
+                  return e2._(this, void 0, void 0, function* () {
+                    const o22 = t42.uid;
+                    if (!this.loaded || !this.loaded[o22]) throw new Error("Should not be trying to reload a tile that was never loaded or has been removed");
+                    const i22 = this.loaded[o22];
+                    if (i22.showCollisionBoxes = t42.showCollisionBoxes, "parsing" === i22.status) {
+                      const t5 = yield i22.parse(i22.vectorTile, this.layerIndex, this.availableImages, this.actor);
+                      let s22;
+                      if (this.fetching[o22]) {
+                        const { rawTileData: i3, cacheControl: r22, resourceTiming: n22 } = this.fetching[o22];
+                        delete this.fetching[o22], s22 = e2.e({ rawTileData: i3.slice(0) }, t5, r22, n22);
+                      } else s22 = t5;
+                      return s22;
+                    }
+                    if ("done" === i22.status && i22.vectorTile) return i22.parse(i22.vectorTile, this.layerIndex, this.availableImages, this.actor);
+                  });
+                }
+                abortTile(t42) {
+                  return e2._(this, void 0, void 0, function* () {
+                    const e22 = this.loading, o22 = t42.uid;
+                    e22 && e22[o22] && e22[o22].abort && (e22[o22].abort.abort(), delete e22[o22]);
+                  });
+                }
+                removeTile(t42) {
+                  return e2._(this, void 0, void 0, function* () {
+                    this.loaded && this.loaded[t42.uid] && delete this.loaded[t42.uid];
+                  });
+                }
+              }
+              class n2 {
+                constructor() {
+                  this.loaded = {};
+                }
+                loadTile(t42) {
+                  return e2._(this, void 0, void 0, function* () {
+                    const { uid: o22, encoding: i22, rawImageData: s22, redFactor: r22, greenFactor: n22, blueFactor: a22, baseShift: l22 } = t42, c22 = s22.width + 2, u22 = s22.height + 2, h22 = e2.b(s22) ? new e2.R({ width: c22, height: u22 }, yield e2.bw(s22, -1, -1, c22, u22)) : s22, d22 = new e2.bx(o22, h22, i22, r22, n22, a22, l22);
+                    return this.loaded = this.loaded || {}, this.loaded[o22] = d22, d22;
+                  });
+                }
+                removeTile(e22) {
+                  const t42 = this.loaded, o22 = e22.uid;
+                  t42 && t42[o22] && delete t42[o22];
+                }
+              }
+              function a2(e22, t42) {
+                if (0 !== e22.length) {
+                  l2(e22[0], t42);
+                  for (var o22 = 1; o22 < e22.length; o22++) l2(e22[o22], !t42);
+                }
+              }
+              function l2(e22, t42) {
+                for (var o22 = 0, i22 = 0, s22 = 0, r22 = e22.length, n22 = r22 - 1; s22 < r22; n22 = s22++) {
+                  var a22 = (e22[s22][0] - e22[n22][0]) * (e22[n22][1] + e22[s22][1]), l22 = o22 + a22;
+                  i22 += Math.abs(o22) >= Math.abs(a22) ? o22 - l22 + a22 : a22 - l22 + o22, o22 = l22;
+                }
+                o22 + i22 >= 0 != !!t42 && e22.reverse();
+              }
+              var c2 = e2.by(function e22(t42, o22) {
+                var i22, s22 = t42 && t42.type;
+                if ("FeatureCollection" === s22) for (i22 = 0; i22 < t42.features.length; i22++) e22(t42.features[i22], o22);
+                else if ("GeometryCollection" === s22) for (i22 = 0; i22 < t42.geometries.length; i22++) e22(t42.geometries[i22], o22);
+                else if ("Feature" === s22) e22(t42.geometry, o22);
+                else if ("Polygon" === s22) a2(t42.coordinates, o22);
+                else if ("MultiPolygon" === s22) for (i22 = 0; i22 < t42.coordinates.length; i22++) a2(t42.coordinates[i22], o22);
+                return t42;
+              });
+              const u2 = e2.bt.VectorTileFeature.prototype.toGeoJSON;
+              var h2 = { exports: {} }, d2 = e2.bz, f2 = e2.bt.VectorTileFeature, g2 = p2;
+              function p2(e22, t42) {
+                this.options = t42 || {}, this.features = e22, this.length = e22.length;
+              }
+              function m2(e22, t42) {
+                this.id = "number" == typeof e22.id ? e22.id : void 0, this.type = e22.type, this.rawGeometry = 1 === e22.type ? [e22.geometry] : e22.geometry, this.properties = e22.tags, this.extent = t42 || 4096;
+              }
+              p2.prototype.feature = function(e22) {
+                return new m2(this.features[e22], this.options.extent);
+              }, m2.prototype.loadGeometry = function() {
+                var e22 = this.rawGeometry;
+                this.geometry = [];
+                for (var t42 = 0; t42 < e22.length; t42++) {
+                  for (var o22 = e22[t42], i22 = [], s22 = 0; s22 < o22.length; s22++) i22.push(new d2(o22[s22][0], o22[s22][1]));
+                  this.geometry.push(i22);
+                }
+                return this.geometry;
+              }, m2.prototype.bbox = function() {
+                this.geometry || this.loadGeometry();
+                for (var e22 = this.geometry, t42 = 1 / 0, o22 = -1 / 0, i22 = 1 / 0, s22 = -1 / 0, r22 = 0; r22 < e22.length; r22++) for (var n22 = e22[r22], a22 = 0; a22 < n22.length; a22++) {
+                  var l22 = n22[a22];
+                  t42 = Math.min(t42, l22.x), o22 = Math.max(o22, l22.x), i22 = Math.min(i22, l22.y), s22 = Math.max(s22, l22.y);
+                }
+                return [t42, i22, o22, s22];
+              }, m2.prototype.toGeoJSON = f2.prototype.toGeoJSON;
+              var y2 = e2.bA, v2 = g2;
+              function w2(e22) {
+                var t42 = new y2();
+                return function(e3, t5) {
+                  for (var o22 in e3.layers) t5.writeMessage(3, x2, e3.layers[o22]);
+                }(e22, t42), t42.finish();
+              }
+              function x2(e22, t42) {
+                var o22;
+                t42.writeVarintField(15, e22.version || 1), t42.writeStringField(1, e22.name || ""), t42.writeVarintField(5, e22.extent || 4096);
+                var i22 = { keys: [], values: [], keycache: {}, valuecache: {} };
+                for (o22 = 0; o22 < e22.length; o22++) i22.feature = e22.feature(o22), t42.writeMessage(2, b2, i22);
+                var s22 = i22.keys;
+                for (o22 = 0; o22 < s22.length; o22++) t42.writeStringField(3, s22[o22]);
+                var r22 = i22.values;
+                for (o22 = 0; o22 < r22.length; o22++) t42.writeMessage(4, P2, r22[o22]);
+              }
+              function b2(e22, t42) {
+                var o22 = e22.feature;
+                void 0 !== o22.id && t42.writeVarintField(1, o22.id), t42.writeMessage(2, S2, e22), t42.writeVarintField(3, o22.type), t42.writeMessage(4, I2, o22);
+              }
+              function S2(e22, t42) {
+                var o22 = e22.feature, i22 = e22.keys, s22 = e22.values, r22 = e22.keycache, n22 = e22.valuecache;
+                for (var a22 in o22.properties) {
+                  var l22 = o22.properties[a22], c22 = r22[a22];
+                  if (null !== l22) {
+                    void 0 === c22 && (i22.push(a22), r22[a22] = c22 = i22.length - 1), t42.writeVarint(c22);
+                    var u22 = typeof l22;
+                    "string" !== u22 && "boolean" !== u22 && "number" !== u22 && (l22 = JSON.stringify(l22));
+                    var h22 = u22 + ":" + l22, d22 = n22[h22];
+                    void 0 === d22 && (s22.push(l22), n22[h22] = d22 = s22.length - 1), t42.writeVarint(d22);
+                  }
+                }
+              }
+              function _2(e22, t42) {
+                return (t42 << 3) + (7 & e22);
+              }
+              function M2(e22) {
+                return e22 << 1 ^ e22 >> 31;
+              }
+              function I2(e22, t42) {
+                for (var o22 = e22.loadGeometry(), i22 = e22.type, s22 = 0, r22 = 0, n22 = o22.length, a22 = 0; a22 < n22; a22++) {
+                  var l22 = o22[a22], c22 = 1;
+                  1 === i22 && (c22 = l22.length), t42.writeVarint(_2(1, c22));
+                  for (var u22 = 3 === i22 ? l22.length - 1 : l22.length, h22 = 0; h22 < u22; h22++) {
+                    1 === h22 && 1 !== i22 && t42.writeVarint(_2(2, u22 - 1));
+                    var d22 = l22[h22].x - s22, f22 = l22[h22].y - r22;
+                    t42.writeVarint(M2(d22)), t42.writeVarint(M2(f22)), s22 += d22, r22 += f22;
+                  }
+                  3 === i22 && t42.writeVarint(_2(7, 1));
+                }
+              }
+              function P2(e22, t42) {
+                var o22 = typeof e22;
+                "string" === o22 ? t42.writeStringField(1, e22) : "boolean" === o22 ? t42.writeBooleanField(7, e22) : "number" === o22 && (e22 % 1 != 0 ? t42.writeDoubleField(3, e22) : e22 < 0 ? t42.writeSVarintField(6, e22) : t42.writeVarintField(5, e22));
+              }
+              h2.exports = w2, h2.exports.fromVectorTileJs = w2, h2.exports.fromGeojsonVt = function(e22, t42) {
+                t42 = t42 || {};
+                var o22 = {};
+                for (var i22 in e22) o22[i22] = new v2(e22[i22].features, t42), o22[i22].name = i22, o22[i22].version = t42.version, o22[i22].extent = t42.extent;
+                return w2({ layers: o22 });
+              }, h2.exports.GeoJSONWrapper = v2;
+              var k2 = e2.by(h2.exports);
+              const T2 = { minZoom: 0, maxZoom: 16, minPoints: 2, radius: 40, extent: 512, nodeSize: 64, log: false, generateId: false, reduce: null, map: (e22) => e22 }, D22 = Math.fround || (C22 = new Float32Array(1), (e22) => (C22[0] = +e22, C22[0]));
+              var C22;
+              const L2 = 3, O2 = 5, F2 = 6;
+              class z2 {
+                constructor(e22) {
+                  this.options = Object.assign(Object.create(T2), e22), this.trees = new Array(this.options.maxZoom + 1), this.stride = this.options.reduce ? 7 : 6, this.clusterProps = [];
+                }
+                load(e22) {
+                  const { log: t42, minZoom: o22, maxZoom: i22 } = this.options;
+                  t42 && console.time("total time");
+                  const s22 = `prepare ${e22.length} points`;
+                  t42 && console.time(s22), this.points = e22;
+                  const r22 = [];
+                  for (let t5 = 0; t5 < e22.length; t5++) {
+                    const o3 = e22[t5];
+                    if (!o3.geometry) continue;
+                    const [i3, s3] = o3.geometry.coordinates, n3 = D22(G2(i3)), a22 = D22(j2(s3));
+                    r22.push(n3, a22, 1 / 0, t5, -1, 1), this.options.reduce && r22.push(0);
+                  }
+                  let n22 = this.trees[i22 + 1] = this._createTree(r22);
+                  t42 && console.timeEnd(s22);
+                  for (let e3 = i22; e3 >= o22; e3--) {
+                    const o3 = +Date.now();
+                    n22 = this.trees[e3] = this._createTree(this._cluster(n22, e3)), t42 && console.log("z%d: %d clusters in %dms", e3, n22.numItems, +Date.now() - o3);
+                  }
+                  return t42 && console.timeEnd("total time"), this;
+                }
+                getClusters(e22, t42) {
+                  let o22 = ((e22[0] + 180) % 360 + 360) % 360 - 180;
+                  const i22 = Math.max(-90, Math.min(90, e22[1]));
+                  let s22 = 180 === e22[2] ? 180 : ((e22[2] + 180) % 360 + 360) % 360 - 180;
+                  const r22 = Math.max(-90, Math.min(90, e22[3]));
+                  if (e22[2] - e22[0] >= 360) o22 = -180, s22 = 180;
+                  else if (o22 > s22) {
+                    const e3 = this.getClusters([o22, i22, 180, r22], t42), n3 = this.getClusters([-180, i22, s22, r22], t42);
+                    return e3.concat(n3);
+                  }
+                  const n22 = this.trees[this._limitZoom(t42)], a22 = n22.range(G2(o22), j2(r22), G2(s22), j2(i22)), l22 = n22.data, c22 = [];
+                  for (const e3 of a22) {
+                    const t5 = this.stride * e3;
+                    c22.push(l22[t5 + O2] > 1 ? A22(l22, t5, this.clusterProps) : this.points[l22[t5 + L2]]);
+                  }
+                  return c22;
+                }
+                getChildren(e22) {
+                  const t42 = this._getOriginId(e22), o22 = this._getOriginZoom(e22), i22 = "No cluster with the specified id.", s22 = this.trees[o22];
+                  if (!s22) throw new Error(i22);
+                  const r22 = s22.data;
+                  if (t42 * this.stride >= r22.length) throw new Error(i22);
+                  const n22 = this.options.radius / (this.options.extent * Math.pow(2, o22 - 1)), a22 = s22.within(r22[t42 * this.stride], r22[t42 * this.stride + 1], n22), l22 = [];
+                  for (const t5 of a22) {
+                    const o3 = t5 * this.stride;
+                    r22[o3 + 4] === e22 && l22.push(r22[o3 + O2] > 1 ? A22(r22, o3, this.clusterProps) : this.points[r22[o3 + L2]]);
+                  }
+                  if (0 === l22.length) throw new Error(i22);
+                  return l22;
+                }
+                getLeaves(e22, t42, o22) {
+                  const i22 = [];
+                  return this._appendLeaves(i22, e22, t42 = t42 || 10, o22 = o22 || 0, 0), i22;
+                }
+                getTile(e22, t42, o22) {
+                  const i22 = this.trees[this._limitZoom(e22)], s22 = Math.pow(2, e22), { extent: r22, radius: n22 } = this.options, a22 = n22 / r22, l22 = (o22 - a22) / s22, c22 = (o22 + 1 + a22) / s22, u22 = { features: [] };
+                  return this._addTileFeatures(i22.range((t42 - a22) / s22, l22, (t42 + 1 + a22) / s22, c22), i22.data, t42, o22, s22, u22), 0 === t42 && this._addTileFeatures(i22.range(1 - a22 / s22, l22, 1, c22), i22.data, s22, o22, s22, u22), t42 === s22 - 1 && this._addTileFeatures(i22.range(0, l22, a22 / s22, c22), i22.data, -1, o22, s22, u22), u22.features.length ? u22 : null;
+                }
+                getClusterExpansionZoom(e22) {
+                  let t42 = this._getOriginZoom(e22) - 1;
+                  for (; t42 <= this.options.maxZoom; ) {
+                    const o22 = this.getChildren(e22);
+                    if (t42++, 1 !== o22.length) break;
+                    e22 = o22[0].properties.cluster_id;
+                  }
+                  return t42;
+                }
+                _appendLeaves(e22, t42, o22, i22, s22) {
+                  const r22 = this.getChildren(t42);
+                  for (const t5 of r22) {
+                    const r3 = t5.properties;
+                    if (r3 && r3.cluster ? s22 + r3.point_count <= i22 ? s22 += r3.point_count : s22 = this._appendLeaves(e22, r3.cluster_id, o22, i22, s22) : s22 < i22 ? s22++ : e22.push(t5), e22.length === o22) break;
+                  }
+                  return s22;
+                }
+                _createTree(t42) {
+                  const o22 = new e2.av(t42.length / this.stride | 0, this.options.nodeSize, Float32Array);
+                  for (let e22 = 0; e22 < t42.length; e22 += this.stride) o22.add(t42[e22], t42[e22 + 1]);
+                  return o22.finish(), o22.data = t42, o22;
+                }
+                _addTileFeatures(e22, t42, o22, i22, s22, r22) {
+                  for (const n22 of e22) {
+                    const e3 = n22 * this.stride, a22 = t42[e3 + O2] > 1;
+                    let l22, c22, u22;
+                    if (a22) l22 = E22(t42, e3, this.clusterProps), c22 = t42[e3], u22 = t42[e3 + 1];
+                    else {
+                      const o3 = this.points[t42[e3 + L2]];
+                      l22 = o3.properties;
+                      const [i3, s3] = o3.geometry.coordinates;
+                      c22 = G2(i3), u22 = j2(s3);
+                    }
+                    const h22 = { type: 1, geometry: [[Math.round(this.options.extent * (c22 * s22 - o22)), Math.round(this.options.extent * (u22 * s22 - i22))]], tags: l22 };
+                    let d22;
+                    d22 = a22 || this.options.generateId ? t42[e3 + L2] : this.points[t42[e3 + L2]].id, void 0 !== d22 && (h22.id = d22), r22.features.push(h22);
+                  }
+                }
+                _limitZoom(e22) {
+                  return Math.max(this.options.minZoom, Math.min(Math.floor(+e22), this.options.maxZoom + 1));
+                }
+                _cluster(e22, t42) {
+                  const { radius: o22, extent: i22, reduce: s22, minPoints: r22 } = this.options, n22 = o22 / (i22 * Math.pow(2, t42)), a22 = e22.data, l22 = [], c22 = this.stride;
+                  for (let o3 = 0; o3 < a22.length; o3 += c22) {
+                    if (a22[o3 + 2] <= t42) continue;
+                    a22[o3 + 2] = t42;
+                    const i3 = a22[o3], u22 = a22[o3 + 1], h22 = e22.within(a22[o3], a22[o3 + 1], n22), d22 = a22[o3 + O2];
+                    let f22 = d22;
+                    for (const e3 of h22) {
+                      const o4 = e3 * c22;
+                      a22[o4 + 2] > t42 && (f22 += a22[o4 + O2]);
+                    }
+                    if (f22 > d22 && f22 >= r22) {
+                      let e3, r3 = i3 * d22, n3 = u22 * d22, g22 = -1;
+                      const p22 = ((o3 / c22 | 0) << 5) + (t42 + 1) + this.points.length;
+                      for (const i4 of h22) {
+                        const l3 = i4 * c22;
+                        if (a22[l3 + 2] <= t42) continue;
+                        a22[l3 + 2] = t42;
+                        const u3 = a22[l3 + O2];
+                        r3 += a22[l3] * u3, n3 += a22[l3 + 1] * u3, a22[l3 + 4] = p22, s22 && (e3 || (e3 = this._map(a22, o3, true), g22 = this.clusterProps.length, this.clusterProps.push(e3)), s22(e3, this._map(a22, l3)));
+                      }
+                      a22[o3 + 4] = p22, l22.push(r3 / f22, n3 / f22, 1 / 0, p22, -1, f22), s22 && l22.push(g22);
+                    } else {
+                      for (let e3 = 0; e3 < c22; e3++) l22.push(a22[o3 + e3]);
+                      if (f22 > 1) for (const e3 of h22) {
+                        const o4 = e3 * c22;
+                        if (!(a22[o4 + 2] <= t42)) {
+                          a22[o4 + 2] = t42;
+                          for (let e4 = 0; e4 < c22; e4++) l22.push(a22[o4 + e4]);
+                        }
+                      }
+                    }
+                  }
+                  return l22;
+                }
+                _getOriginId(e22) {
+                  return e22 - this.points.length >> 5;
+                }
+                _getOriginZoom(e22) {
+                  return (e22 - this.points.length) % 32;
+                }
+                _map(e22, t42, o22) {
+                  if (e22[t42 + O2] > 1) {
+                    const i3 = this.clusterProps[e22[t42 + F2]];
+                    return o22 ? Object.assign({}, i3) : i3;
+                  }
+                  const i22 = this.points[e22[t42 + L2]].properties, s22 = this.options.map(i22);
+                  return o22 && s22 === i22 ? Object.assign({}, s22) : s22;
+                }
+              }
+              function A22(e22, t42, o22) {
+                return { type: "Feature", id: e22[t42 + L2], properties: E22(e22, t42, o22), geometry: { type: "Point", coordinates: [(i22 = e22[t42], 360 * (i22 - 0.5)), R2(e22[t42 + 1])] } };
+                var i22;
+              }
+              function E22(e22, t42, o22) {
+                const i22 = e22[t42 + O2], s22 = i22 >= 1e4 ? `${Math.round(i22 / 1e3)}k` : i22 >= 1e3 ? Math.round(i22 / 100) / 10 + "k" : i22, r22 = e22[t42 + F2], n22 = -1 === r22 ? {} : Object.assign({}, o22[r22]);
+                return Object.assign(n22, { cluster: true, cluster_id: e22[t42 + L2], point_count: i22, point_count_abbreviated: s22 });
+              }
+              function G2(e22) {
+                return e22 / 360 + 0.5;
+              }
+              function j2(e22) {
+                const t42 = Math.sin(e22 * Math.PI / 180), o22 = 0.5 - 0.25 * Math.log((1 + t42) / (1 - t42)) / Math.PI;
+                return o22 < 0 ? 0 : o22 > 1 ? 1 : o22;
+              }
+              function R2(e22) {
+                const t42 = (180 - 360 * e22) * Math.PI / 180;
+                return 360 * Math.atan(Math.exp(t42)) / Math.PI - 90;
+              }
+              function Z2(e22, t42, o22, i22) {
+                let s22 = i22;
+                const r22 = t42 + (o22 - t42 >> 1);
+                let n22, a22 = o22 - t42;
+                const l22 = e22[t42], c22 = e22[t42 + 1], u22 = e22[o22], h22 = e22[o22 + 1];
+                for (let i3 = t42 + 3; i3 < o22; i3 += 3) {
+                  const t5 = N2(e22[i3], e22[i3 + 1], l22, c22, u22, h22);
+                  if (t5 > s22) n22 = i3, s22 = t5;
+                  else if (t5 === s22) {
+                    const e3 = Math.abs(i3 - r22);
+                    e3 < a22 && (n22 = i3, a22 = e3);
+                  }
+                }
+                s22 > i22 && (n22 - t42 > 3 && Z2(e22, t42, n22, i22), e22[n22 + 2] = s22, o22 - n22 > 3 && Z2(e22, n22, o22, i22));
+              }
+              function N2(e22, t42, o22, i22, s22, r22) {
+                let n22 = s22 - o22, a22 = r22 - i22;
+                if (0 !== n22 || 0 !== a22) {
+                  const l22 = ((e22 - o22) * n22 + (t42 - i22) * a22) / (n22 * n22 + a22 * a22);
+                  l22 > 1 ? (o22 = s22, i22 = r22) : l22 > 0 && (o22 += n22 * l22, i22 += a22 * l22);
+                }
+                return n22 = e22 - o22, a22 = t42 - i22, n22 * n22 + a22 * a22;
+              }
+              function J2(e22, t42, o22, i22) {
+                const s22 = { id: null == e22 ? null : e22, type: t42, geometry: o22, tags: i22, minX: 1 / 0, minY: 1 / 0, maxX: -1 / 0, maxY: -1 / 0 };
+                if ("Point" === t42 || "MultiPoint" === t42 || "LineString" === t42) W2(s22, o22);
+                else if ("Polygon" === t42) W2(s22, o22[0]);
+                else if ("MultiLineString" === t42) for (const e3 of o22) W2(s22, e3);
+                else if ("MultiPolygon" === t42) for (const e3 of o22) W2(s22, e3[0]);
+                return s22;
+              }
+              function W2(e22, t42) {
+                for (let o22 = 0; o22 < t42.length; o22 += 3) e22.minX = Math.min(e22.minX, t42[o22]), e22.minY = Math.min(e22.minY, t42[o22 + 1]), e22.maxX = Math.max(e22.maxX, t42[o22]), e22.maxY = Math.max(e22.maxY, t42[o22 + 1]);
+              }
+              function Y2(e22, t42, o22, i22) {
+                if (!t42.geometry) return;
+                const s22 = t42.geometry.coordinates;
+                if (s22 && 0 === s22.length) return;
+                const r22 = t42.geometry.type, n22 = Math.pow(o22.tolerance / ((1 << o22.maxZoom) * o22.extent), 2);
+                let a22 = [], l22 = t42.id;
+                if (o22.promoteId ? l22 = t42.properties[o22.promoteId] : o22.generateId && (l22 = i22 || 0), "Point" === r22) V2(s22, a22);
+                else if ("MultiPoint" === r22) for (const e3 of s22) V2(e3, a22);
+                else if ("LineString" === r22) X2(s22, a22, n22, false);
+                else if ("MultiLineString" === r22) {
+                  if (o22.lineMetrics) {
+                    for (const o3 of s22) a22 = [], X2(o3, a22, n22, false), e22.push(J2(l22, "LineString", a22, t42.properties));
+                    return;
+                  }
+                  q2(s22, a22, n22, false);
+                } else if ("Polygon" === r22) q2(s22, a22, n22, true);
+                else {
+                  if ("MultiPolygon" !== r22) {
+                    if ("GeometryCollection" === r22) {
+                      for (const s3 of t42.geometry.geometries) Y2(e22, { id: l22, geometry: s3, properties: t42.properties }, o22, i22);
+                      return;
+                    }
+                    throw new Error("Input data is not a valid GeoJSON object.");
+                  }
+                  for (const e3 of s22) {
+                    const t5 = [];
+                    q2(e3, t5, n22, true), a22.push(t5);
+                  }
+                }
+                e22.push(J2(l22, r22, a22, t42.properties));
+              }
+              function V2(e22, t42) {
+                t42.push(H2(e22[0]), B22(e22[1]), 0);
+              }
+              function X2(e22, t42, o22, i22) {
+                let s22, r22, n22 = 0;
+                for (let o3 = 0; o3 < e22.length; o3++) {
+                  const a3 = H2(e22[o3][0]), l22 = B22(e22[o3][1]);
+                  t42.push(a3, l22, 0), o3 > 0 && (n22 += i22 ? (s22 * l22 - a3 * r22) / 2 : Math.sqrt(Math.pow(a3 - s22, 2) + Math.pow(l22 - r22, 2))), s22 = a3, r22 = l22;
+                }
+                const a22 = t42.length - 3;
+                t42[2] = 1, Z2(t42, 0, a22, o22), t42[a22 + 2] = 1, t42.size = Math.abs(n22), t42.start = 0, t42.end = t42.size;
+              }
+              function q2(e22, t42, o22, i22) {
+                for (let s22 = 0; s22 < e22.length; s22++) {
+                  const r22 = [];
+                  X2(e22[s22], r22, o22, i22), t42.push(r22);
+                }
+              }
+              function H2(e22) {
+                return e22 / 360 + 0.5;
+              }
+              function B22(e22) {
+                const t42 = Math.sin(e22 * Math.PI / 180), o22 = 0.5 - 0.25 * Math.log((1 + t42) / (1 - t42)) / Math.PI;
+                return o22 < 0 ? 0 : o22 > 1 ? 1 : o22;
+              }
+              function U2(e22, t42, o22, i22, s22, r22, n22, a22) {
+                if (i22 /= t42, r22 >= (o22 /= t42) && n22 < i22) return e22;
+                if (n22 < o22 || r22 >= i22) return null;
+                const l22 = [];
+                for (const t5 of e22) {
+                  const e3 = t5.geometry;
+                  let r3 = t5.type;
+                  const n3 = 0 === s22 ? t5.minX : t5.minY, c22 = 0 === s22 ? t5.maxX : t5.maxY;
+                  if (n3 >= o22 && c22 < i22) {
+                    l22.push(t5);
+                    continue;
+                  }
+                  if (c22 < o22 || n3 >= i22) continue;
+                  let u22 = [];
+                  if ("Point" === r3 || "MultiPoint" === r3) $2(e3, u22, o22, i22, s22);
+                  else if ("LineString" === r3) K22(e3, u22, o22, i22, s22, false, a22.lineMetrics);
+                  else if ("MultiLineString" === r3) ee2(e3, u22, o22, i22, s22, false);
+                  else if ("Polygon" === r3) ee2(e3, u22, o22, i22, s22, true);
+                  else if ("MultiPolygon" === r3) for (const t6 of e3) {
+                    const e4 = [];
+                    ee2(t6, e4, o22, i22, s22, true), e4.length && u22.push(e4);
+                  }
+                  if (u22.length) {
+                    if (a22.lineMetrics && "LineString" === r3) {
+                      for (const e4 of u22) l22.push(J2(t5.id, r3, e4, t5.tags));
+                      continue;
+                    }
+                    "LineString" !== r3 && "MultiLineString" !== r3 || (1 === u22.length ? (r3 = "LineString", u22 = u22[0]) : r3 = "MultiLineString"), "Point" !== r3 && "MultiPoint" !== r3 || (r3 = 3 === u22.length ? "Point" : "MultiPoint"), l22.push(J2(t5.id, r3, u22, t5.tags));
+                  }
+                }
+                return l22.length ? l22 : null;
+              }
+              function $2(e22, t42, o22, i22, s22) {
+                for (let r22 = 0; r22 < e22.length; r22 += 3) {
+                  const n22 = e22[r22 + s22];
+                  n22 >= o22 && n22 <= i22 && te2(t42, e22[r22], e22[r22 + 1], e22[r22 + 2]);
+                }
+              }
+              function K22(e22, t42, o22, i22, s22, r22, n22) {
+                let a22 = Q2(e22);
+                const l22 = 0 === s22 ? oe2 : ie2;
+                let c22, u22, h22 = e22.start;
+                for (let d3 = 0; d3 < e22.length - 3; d3 += 3) {
+                  const f3 = e22[d3], g3 = e22[d3 + 1], p3 = e22[d3 + 2], m22 = e22[d3 + 3], y22 = e22[d3 + 4], v22 = 0 === s22 ? f3 : g3, w22 = 0 === s22 ? m22 : y22;
+                  let x22 = false;
+                  n22 && (c22 = Math.sqrt(Math.pow(f3 - m22, 2) + Math.pow(g3 - y22, 2))), v22 < o22 ? w22 > o22 && (u22 = l22(a22, f3, g3, m22, y22, o22), n22 && (a22.start = h22 + c22 * u22)) : v22 > i22 ? w22 < i22 && (u22 = l22(a22, f3, g3, m22, y22, i22), n22 && (a22.start = h22 + c22 * u22)) : te2(a22, f3, g3, p3), w22 < o22 && v22 >= o22 && (u22 = l22(a22, f3, g3, m22, y22, o22), x22 = true), w22 > i22 && v22 <= i22 && (u22 = l22(a22, f3, g3, m22, y22, i22), x22 = true), !r22 && x22 && (n22 && (a22.end = h22 + c22 * u22), t42.push(a22), a22 = Q2(e22)), n22 && (h22 += c22);
+                }
+                let d22 = e22.length - 3;
+                const f22 = e22[d22], g22 = e22[d22 + 1], p22 = 0 === s22 ? f22 : g22;
+                p22 >= o22 && p22 <= i22 && te2(a22, f22, g22, e22[d22 + 2]), d22 = a22.length - 3, r22 && d22 >= 3 && (a22[d22] !== a22[0] || a22[d22 + 1] !== a22[1]) && te2(a22, a22[0], a22[1], a22[2]), a22.length && t42.push(a22);
+              }
+              function Q2(e22) {
+                const t42 = [];
+                return t42.size = e22.size, t42.start = e22.start, t42.end = e22.end, t42;
+              }
+              function ee2(e22, t42, o22, i22, s22, r22) {
+                for (const n22 of e22) K22(n22, t42, o22, i22, s22, r22, false);
+              }
+              function te2(e22, t42, o22, i22) {
+                e22.push(t42, o22, i22);
+              }
+              function oe2(e22, t42, o22, i22, s22, r22) {
+                const n22 = (r22 - t42) / (i22 - t42);
+                return te2(e22, r22, o22 + (s22 - o22) * n22, 1), n22;
+              }
+              function ie2(e22, t42, o22, i22, s22, r22) {
+                const n22 = (r22 - o22) / (s22 - o22);
+                return te2(e22, t42 + (i22 - t42) * n22, r22, 1), n22;
+              }
+              function se2(e22, t42) {
+                const o22 = [];
+                for (let i22 = 0; i22 < e22.length; i22++) {
+                  const s22 = e22[i22], r22 = s22.type;
+                  let n22;
+                  if ("Point" === r22 || "MultiPoint" === r22 || "LineString" === r22) n22 = re2(s22.geometry, t42);
+                  else if ("MultiLineString" === r22 || "Polygon" === r22) {
+                    n22 = [];
+                    for (const e3 of s22.geometry) n22.push(re2(e3, t42));
+                  } else if ("MultiPolygon" === r22) {
+                    n22 = [];
+                    for (const e3 of s22.geometry) {
+                      const o3 = [];
+                      for (const i3 of e3) o3.push(re2(i3, t42));
+                      n22.push(o3);
+                    }
+                  }
+                  o22.push(J2(s22.id, r22, n22, s22.tags));
+                }
+                return o22;
+              }
+              function re2(e22, t42) {
+                const o22 = [];
+                o22.size = e22.size, void 0 !== e22.start && (o22.start = e22.start, o22.end = e22.end);
+                for (let i22 = 0; i22 < e22.length; i22 += 3) o22.push(e22[i22] + t42, e22[i22 + 1], e22[i22 + 2]);
+                return o22;
+              }
+              function ne2(e22, t42) {
+                if (e22.transformed) return e22;
+                const o22 = 1 << e22.z, i22 = e22.x, s22 = e22.y;
+                for (const r22 of e22.features) {
+                  const e3 = r22.geometry, n22 = r22.type;
+                  if (r22.geometry = [], 1 === n22) for (let n3 = 0; n3 < e3.length; n3 += 2) r22.geometry.push(ae2(e3[n3], e3[n3 + 1], t42, o22, i22, s22));
+                  else for (let n3 = 0; n3 < e3.length; n3++) {
+                    const a22 = [];
+                    for (let r3 = 0; r3 < e3[n3].length; r3 += 2) a22.push(ae2(e3[n3][r3], e3[n3][r3 + 1], t42, o22, i22, s22));
+                    r22.geometry.push(a22);
+                  }
+                }
+                return e22.transformed = true, e22;
+              }
+              function ae2(e22, t42, o22, i22, s22, r22) {
+                return [Math.round(o22 * (e22 * i22 - s22)), Math.round(o22 * (t42 * i22 - r22))];
+              }
+              function le2(e22, t42, o22, i22, s22) {
+                const r22 = t42 === s22.maxZoom ? 0 : s22.tolerance / ((1 << t42) * s22.extent), n22 = { features: [], numPoints: 0, numSimplified: 0, numFeatures: e22.length, source: null, x: o22, y: i22, z: t42, transformed: false, minX: 2, minY: 1, maxX: -1, maxY: 0 };
+                for (const t5 of e22) ce2(n22, t5, r22, s22);
+                return n22;
+              }
+              function ce2(e22, t42, o22, i22) {
+                const s22 = t42.geometry, r22 = t42.type, n22 = [];
+                if (e22.minX = Math.min(e22.minX, t42.minX), e22.minY = Math.min(e22.minY, t42.minY), e22.maxX = Math.max(e22.maxX, t42.maxX), e22.maxY = Math.max(e22.maxY, t42.maxY), "Point" === r22 || "MultiPoint" === r22) for (let t5 = 0; t5 < s22.length; t5 += 3) n22.push(s22[t5], s22[t5 + 1]), e22.numPoints++, e22.numSimplified++;
+                else if ("LineString" === r22) ue2(n22, s22, e22, o22, false, false);
+                else if ("MultiLineString" === r22 || "Polygon" === r22) for (let t5 = 0; t5 < s22.length; t5++) ue2(n22, s22[t5], e22, o22, "Polygon" === r22, 0 === t5);
+                else if ("MultiPolygon" === r22) for (let t5 = 0; t5 < s22.length; t5++) {
+                  const i3 = s22[t5];
+                  for (let t6 = 0; t6 < i3.length; t6++) ue2(n22, i3[t6], e22, o22, true, 0 === t6);
+                }
+                if (n22.length) {
+                  let o3 = t42.tags || null;
+                  if ("LineString" === r22 && i22.lineMetrics) {
+                    o3 = {};
+                    for (const e3 in t42.tags) o3[e3] = t42.tags[e3];
+                    o3.mapbox_clip_start = s22.start / s22.size, o3.mapbox_clip_end = s22.end / s22.size;
+                  }
+                  const a22 = { geometry: n22, type: "Polygon" === r22 || "MultiPolygon" === r22 ? 3 : "LineString" === r22 || "MultiLineString" === r22 ? 2 : 1, tags: o3 };
+                  null !== t42.id && (a22.id = t42.id), e22.features.push(a22);
+                }
+              }
+              function ue2(e22, t42, o22, i22, s22, r22) {
+                const n22 = i22 * i22;
+                if (i22 > 0 && t42.size < (s22 ? n22 : i22)) return void (o22.numPoints += t42.length / 3);
+                const a22 = [];
+                for (let e3 = 0; e3 < t42.length; e3 += 3) (0 === i22 || t42[e3 + 2] > n22) && (o22.numSimplified++, a22.push(t42[e3], t42[e3 + 1])), o22.numPoints++;
+                s22 && function(e3, t5) {
+                  let o3 = 0;
+                  for (let t6 = 0, i3 = e3.length, s3 = i3 - 2; t6 < i3; s3 = t6, t6 += 2) o3 += (e3[t6] - e3[s3]) * (e3[t6 + 1] + e3[s3 + 1]);
+                  if (o3 > 0 === t5) for (let t6 = 0, o4 = e3.length; t6 < o4 / 2; t6 += 2) {
+                    const i3 = e3[t6], s3 = e3[t6 + 1];
+                    e3[t6] = e3[o4 - 2 - t6], e3[t6 + 1] = e3[o4 - 1 - t6], e3[o4 - 2 - t6] = i3, e3[o4 - 1 - t6] = s3;
+                  }
+                }(a22, r22), e22.push(a22);
+              }
+              const he2 = { maxZoom: 14, indexMaxZoom: 5, indexMaxPoints: 1e5, tolerance: 3, extent: 4096, buffer: 64, lineMetrics: false, promoteId: null, generateId: false, debug: 0 };
+              class de2 {
+                constructor(e22, t42) {
+                  const o22 = (t42 = this.options = function(e3, t5) {
+                    for (const o3 in t5) e3[o3] = t5[o3];
+                    return e3;
+                  }(Object.create(he2), t42)).debug;
+                  if (o22 && console.time("preprocess data"), t42.maxZoom < 0 || t42.maxZoom > 24) throw new Error("maxZoom should be in the 0-24 range");
+                  if (t42.promoteId && t42.generateId) throw new Error("promoteId and generateId cannot be used together.");
+                  let i22 = function(e3, t5) {
+                    const o3 = [];
+                    if ("FeatureCollection" === e3.type) for (let i3 = 0; i3 < e3.features.length; i3++) Y2(o3, e3.features[i3], t5, i3);
+                    else Y2(o3, "Feature" === e3.type ? e3 : { geometry: e3 }, t5);
+                    return o3;
+                  }(e22, t42);
+                  this.tiles = {}, this.tileCoords = [], o22 && (console.timeEnd("preprocess data"), console.log("index: maxZoom: %d, maxPoints: %d", t42.indexMaxZoom, t42.indexMaxPoints), console.time("generate tiles"), this.stats = {}, this.total = 0), i22 = function(e3, t5) {
+                    const o3 = t5.buffer / t5.extent;
+                    let i3 = e3;
+                    const s22 = U2(e3, 1, -1 - o3, o3, 0, -1, 2, t5), r22 = U2(e3, 1, 1 - o3, 2 + o3, 0, -1, 2, t5);
+                    return (s22 || r22) && (i3 = U2(e3, 1, -o3, 1 + o3, 0, -1, 2, t5) || [], s22 && (i3 = se2(s22, 1).concat(i3)), r22 && (i3 = i3.concat(se2(r22, -1)))), i3;
+                  }(i22, t42), i22.length && this.splitTile(i22, 0, 0, 0), o22 && (i22.length && console.log("features: %d, points: %d", this.tiles[0].numFeatures, this.tiles[0].numPoints), console.timeEnd("generate tiles"), console.log("tiles generated:", this.total, JSON.stringify(this.stats)));
+                }
+                splitTile(e22, t42, o22, i22, s22, r22, n22) {
+                  const a22 = [e22, t42, o22, i22], l22 = this.options, c22 = l22.debug;
+                  for (; a22.length; ) {
+                    i22 = a22.pop(), o22 = a22.pop(), t42 = a22.pop(), e22 = a22.pop();
+                    const u22 = 1 << t42, h22 = fe2(t42, o22, i22);
+                    let d22 = this.tiles[h22];
+                    if (!d22 && (c22 > 1 && console.time("creation"), d22 = this.tiles[h22] = le2(e22, t42, o22, i22, l22), this.tileCoords.push({ z: t42, x: o22, y: i22 }), c22)) {
+                      c22 > 1 && (console.log("tile z%d-%d-%d (features: %d, points: %d, simplified: %d)", t42, o22, i22, d22.numFeatures, d22.numPoints, d22.numSimplified), console.timeEnd("creation"));
+                      const e3 = `z${t42}`;
+                      this.stats[e3] = (this.stats[e3] || 0) + 1, this.total++;
+                    }
+                    if (d22.source = e22, null == s22) {
+                      if (t42 === l22.indexMaxZoom || d22.numPoints <= l22.indexMaxPoints) continue;
+                    } else {
+                      if (t42 === l22.maxZoom || t42 === s22) continue;
+                      if (null != s22) {
+                        const e3 = s22 - t42;
+                        if (o22 !== r22 >> e3 || i22 !== n22 >> e3) continue;
+                      }
+                    }
+                    if (d22.source = null, 0 === e22.length) continue;
+                    c22 > 1 && console.time("clipping");
+                    const f22 = 0.5 * l22.buffer / l22.extent, g22 = 0.5 - f22, p22 = 0.5 + f22, m22 = 1 + f22;
+                    let y22 = null, v22 = null, w22 = null, x22 = null, b22 = U2(e22, u22, o22 - f22, o22 + p22, 0, d22.minX, d22.maxX, l22), S22 = U2(e22, u22, o22 + g22, o22 + m22, 0, d22.minX, d22.maxX, l22);
+                    e22 = null, b22 && (y22 = U2(b22, u22, i22 - f22, i22 + p22, 1, d22.minY, d22.maxY, l22), v22 = U2(b22, u22, i22 + g22, i22 + m22, 1, d22.minY, d22.maxY, l22), b22 = null), S22 && (w22 = U2(S22, u22, i22 - f22, i22 + p22, 1, d22.minY, d22.maxY, l22), x22 = U2(S22, u22, i22 + g22, i22 + m22, 1, d22.minY, d22.maxY, l22), S22 = null), c22 > 1 && console.timeEnd("clipping"), a22.push(y22 || [], t42 + 1, 2 * o22, 2 * i22), a22.push(v22 || [], t42 + 1, 2 * o22, 2 * i22 + 1), a22.push(w22 || [], t42 + 1, 2 * o22 + 1, 2 * i22), a22.push(x22 || [], t42 + 1, 2 * o22 + 1, 2 * i22 + 1);
+                  }
+                }
+                getTile(e22, t42, o22) {
+                  e22 = +e22, t42 = +t42, o22 = +o22;
+                  const i22 = this.options, { extent: s22, debug: r22 } = i22;
+                  if (e22 < 0 || e22 > 24) return null;
+                  const n22 = 1 << e22, a22 = fe2(e22, t42 = t42 + n22 & n22 - 1, o22);
+                  if (this.tiles[a22]) return ne2(this.tiles[a22], s22);
+                  r22 > 1 && console.log("drilling down to z%d-%d-%d", e22, t42, o22);
+                  let l22, c22 = e22, u22 = t42, h22 = o22;
+                  for (; !l22 && c22 > 0; ) c22--, u22 >>= 1, h22 >>= 1, l22 = this.tiles[fe2(c22, u22, h22)];
+                  return l22 && l22.source ? (r22 > 1 && (console.log("found parent tile z%d-%d-%d", c22, u22, h22), console.time("drilling down")), this.splitTile(l22.source, c22, u22, h22, e22, t42, o22), r22 > 1 && console.timeEnd("drilling down"), this.tiles[a22] ? ne2(this.tiles[a22], s22) : null) : null;
+                }
+              }
+              function fe2(e22, t42, o22) {
+                return 32 * ((1 << e22) * o22 + t42) + e22;
+              }
+              function ge2(e22, t42) {
+                return t42 ? e22.properties[t42] : e22.id;
+              }
+              function pe2(e22, t42) {
+                if (null == e22) return true;
+                if ("Feature" === e22.type) return null != ge2(e22, t42);
+                if ("FeatureCollection" === e22.type) {
+                  const o22 = /* @__PURE__ */ new Set();
+                  for (const i22 of e22.features) {
+                    const e3 = ge2(i22, t42);
+                    if (null == e3) return false;
+                    if (o22.has(e3)) return false;
+                    o22.add(e3);
+                  }
+                  return true;
+                }
+                return false;
+              }
+              function me2(e22, t42) {
+                const o22 = /* @__PURE__ */ new Map();
+                if (null == e22) ;
+                else if ("Feature" === e22.type) o22.set(ge2(e22, t42), e22);
+                else for (const i22 of e22.features) o22.set(ge2(i22, t42), i22);
+                return o22;
+              }
+              class ye2 extends r2 {
+                constructor() {
+                  super(...arguments), this._dataUpdateable = /* @__PURE__ */ new Map();
+                }
+                loadVectorTile(t42, o22) {
+                  return e2._(this, void 0, void 0, function* () {
+                    const o3 = t42.tileID.canonical;
+                    if (!this._geoJSONIndex) throw new Error("Unable to parse the data into a cluster or geojson");
+                    const i22 = this._geoJSONIndex.getTile(o3.z, o3.x, o3.y);
+                    if (!i22) return null;
+                    const s22 = new class {
+                      constructor(t5) {
+                        this.layers = { _geojsonTileLayer: this }, this.name = "_geojsonTileLayer", this.extent = e2.X, this.length = t5.length, this._features = t5;
+                      }
+                      feature(t5) {
+                        return new class {
+                          constructor(t6) {
+                            this._feature = t6, this.extent = e2.X, this.type = t6.type, this.properties = t6.tags, "id" in t6 && !isNaN(t6.id) && (this.id = parseInt(t6.id, 10));
+                          }
+                          loadGeometry() {
+                            if (1 === this._feature.type) {
+                              const t6 = [];
+                              for (const o4 of this._feature.geometry) t6.push([new e2.P(o4[0], o4[1])]);
+                              return t6;
+                            }
+                            {
+                              const t6 = [];
+                              for (const o4 of this._feature.geometry) {
+                                const i3 = [];
+                                for (const t7 of o4) i3.push(new e2.P(t7[0], t7[1]));
+                                t6.push(i3);
+                              }
+                              return t6;
+                            }
+                          }
+                          toGeoJSON(e22, t6, o4) {
+                            return u2.call(this, e22, t6, o4);
+                          }
+                        }(this._features[t5]);
+                      }
+                    }(i22.features);
+                    let r22 = k2(s22);
+                    return 0 === r22.byteOffset && r22.byteLength === r22.buffer.byteLength || (r22 = new Uint8Array(r22)), { vectorTile: s22, rawData: r22.buffer };
+                  });
+                }
+                loadData(t42) {
+                  return e2._(this, void 0, void 0, function* () {
+                    var o22;
+                    null === (o22 = this._pendingRequest) || void 0 === o22 || o22.abort();
+                    const i22 = !!(t42 && t42.request && t42.request.collectResourceTiming) && new e2.bv(t42.request);
+                    this._pendingRequest = new AbortController();
+                    try {
+                      this._pendingData = this.loadAndProcessGeoJSON(t42, this._pendingRequest), this._geoJSONIndex = t42.cluster ? new z2(function({ superclusterOptions: t5, clusterProperties: o4 }) {
+                        if (!o4 || !t5) return t5;
+                        const i3 = {}, s3 = {}, r22 = { accumulated: null, zoom: 0 }, n22 = { properties: null }, a22 = Object.keys(o4);
+                        for (const t6 of a22) {
+                          const [r3, n3] = o4[t6], a3 = e2.bC(n3), l22 = e2.bC("string" == typeof r3 ? [r3, ["accumulated"], ["get", t6]] : r3);
+                          i3[t6] = a3.value, s3[t6] = l22.value;
+                        }
+                        return t5.map = (e22) => {
+                          n22.properties = e22;
+                          const t6 = {};
+                          for (const e3 of a22) t6[e3] = i3[e3].evaluate(r22, n22);
+                          return t6;
+                        }, t5.reduce = (e22, t6) => {
+                          n22.properties = t6;
+                          for (const t7 of a22) r22.accumulated = e22[t7], e22[t7] = s3[t7].evaluate(r22, n22);
+                        }, t5;
+                      }(t42)).load((yield this._pendingData).features) : (s22 = yield this._pendingData, new de2(s22, t42.geojsonVtOptions)), this.loaded = {};
+                      const o3 = {};
+                      if (i22) {
+                        const e22 = i22.finish();
+                        e22 && (o3.resourceTiming = {}, o3.resourceTiming[t42.source] = JSON.parse(JSON.stringify(e22)));
+                      }
+                      return o3;
+                    } catch (t5) {
+                      if (delete this._pendingRequest, e2.bB(t5)) return { abandoned: true };
+                      throw t5;
+                    }
+                    var s22;
+                  });
+                }
+                getData() {
+                  return e2._(this, void 0, void 0, function* () {
+                    return this._pendingData;
+                  });
+                }
+                reloadTile(e22) {
+                  const t42 = this.loaded;
+                  return t42 && t42[e22.uid] ? super.reloadTile(e22) : this.loadTile(e22);
+                }
+                loadAndProcessGeoJSON(t42, o22) {
+                  return e2._(this, void 0, void 0, function* () {
+                    let i22 = yield this.loadGeoJSON(t42, o22);
+                    if (delete this._pendingRequest, "object" != typeof i22) throw new Error(`Input data given to '${t42.source}' is not a valid GeoJSON object.`);
+                    if (c2(i22, true), t42.filter) {
+                      const o3 = e2.bC(t42.filter, { type: "boolean", "property-type": "data-driven", overridable: false, transition: false });
+                      if ("error" === o3.result) throw new Error(o3.value.map((e22) => `${e22.key}: ${e22.message}`).join(", "));
+                      const s22 = i22.features.filter((e22) => o3.value.evaluate({ zoom: 0 }, e22));
+                      i22 = { type: "FeatureCollection", features: s22 };
+                    }
+                    return i22;
+                  });
+                }
+                loadGeoJSON(t42, o22) {
+                  return e2._(this, void 0, void 0, function* () {
+                    const { promoteId: i22 } = t42;
+                    if (t42.request) {
+                      const s22 = yield e2.h(t42.request, o22);
+                      return this._dataUpdateable = pe2(s22.data, i22) ? me2(s22.data, i22) : void 0, s22.data;
+                    }
+                    if ("string" == typeof t42.data) try {
+                      const e22 = JSON.parse(t42.data);
+                      return this._dataUpdateable = pe2(e22, i22) ? me2(e22, i22) : void 0, e22;
+                    } catch (e22) {
+                      throw new Error(`Input data given to '${t42.source}' is not a valid GeoJSON object.`);
+                    }
+                    if (!t42.dataDiff) throw new Error(`Input data given to '${t42.source}' is not a valid GeoJSON object.`);
+                    if (!this._dataUpdateable) throw new Error(`Cannot update existing geojson data in ${t42.source}`);
+                    return function(e22, t5, o3) {
+                      var i3, s22, r22, n22;
+                      if (t5.removeAll && e22.clear(), t5.remove) for (const o4 of t5.remove) e22.delete(o4);
+                      if (t5.add) for (const i4 of t5.add) {
+                        const t6 = ge2(i4, o3);
+                        null != t6 && e22.set(t6, i4);
+                      }
+                      if (t5.update) for (const o4 of t5.update) {
+                        let t6 = e22.get(o4.id);
+                        if (null == t6) continue;
+                        const a22 = !o4.removeAllProperties && ((null === (i3 = o4.removeProperties) || void 0 === i3 ? void 0 : i3.length) > 0 || (null === (s22 = o4.addOrUpdateProperties) || void 0 === s22 ? void 0 : s22.length) > 0);
+                        if ((o4.newGeometry || o4.removeAllProperties || a22) && (t6 = Object.assign({}, t6), e22.set(o4.id, t6), a22 && (t6.properties = Object.assign({}, t6.properties))), o4.newGeometry && (t6.geometry = o4.newGeometry), o4.removeAllProperties) t6.properties = {};
+                        else if ((null === (r22 = o4.removeProperties) || void 0 === r22 ? void 0 : r22.length) > 0) for (const e3 of o4.removeProperties) Object.prototype.hasOwnProperty.call(t6.properties, e3) && delete t6.properties[e3];
+                        if ((null === (n22 = o4.addOrUpdateProperties) || void 0 === n22 ? void 0 : n22.length) > 0) for (const { key: e3, value: i4 } of o4.addOrUpdateProperties) t6.properties[e3] = i4;
+                      }
+                    }(this._dataUpdateable, t42.dataDiff, i22), { type: "FeatureCollection", features: Array.from(this._dataUpdateable.values()) };
+                  });
+                }
+                removeSource(t42) {
+                  return e2._(this, void 0, void 0, function* () {
+                    this._pendingRequest && this._pendingRequest.abort();
+                  });
+                }
+                getClusterExpansionZoom(e22) {
+                  return this._geoJSONIndex.getClusterExpansionZoom(e22.clusterId);
+                }
+                getClusterChildren(e22) {
+                  return this._geoJSONIndex.getChildren(e22.clusterId);
+                }
+                getClusterLeaves(e22) {
+                  return this._geoJSONIndex.getLeaves(e22.clusterId, e22.limit, e22.offset);
+                }
+              }
+              class ve2 {
+                constructor(t42) {
+                  this.self = t42, this.actor = new e2.F(t42), this.layerIndexes = {}, this.availableImages = {}, this.workerSources = {}, this.demWorkerSources = {}, this.externalWorkerSourceTypes = {}, this.self.registerWorkerSource = (e22, t5) => {
+                    if (this.externalWorkerSourceTypes[e22]) throw new Error(`Worker source with name "${e22}" already registered.`);
+                    this.externalWorkerSourceTypes[e22] = t5;
+                  }, this.self.addProtocol = e2.bi, this.self.removeProtocol = e2.bj, this.self.registerRTLTextPlugin = (t5) => {
+                    if (e2.bD.isParsed()) throw new Error("RTL text plugin already registered.");
+                    e2.bD.setMethods(t5);
+                  }, this.actor.registerMessageHandler("LDT", (e22, t5) => this._getDEMWorkerSource(e22, t5.source).loadTile(t5)), this.actor.registerMessageHandler("RDT", (t5, o22) => e2._(this, void 0, void 0, function* () {
+                    this._getDEMWorkerSource(t5, o22.source).removeTile(o22);
+                  })), this.actor.registerMessageHandler("GCEZ", (t5, o22) => e2._(this, void 0, void 0, function* () {
+                    return this._getWorkerSource(t5, o22.type, o22.source).getClusterExpansionZoom(o22);
+                  })), this.actor.registerMessageHandler("GCC", (t5, o22) => e2._(this, void 0, void 0, function* () {
+                    return this._getWorkerSource(t5, o22.type, o22.source).getClusterChildren(o22);
+                  })), this.actor.registerMessageHandler("GCL", (t5, o22) => e2._(this, void 0, void 0, function* () {
+                    return this._getWorkerSource(t5, o22.type, o22.source).getClusterLeaves(o22);
+                  })), this.actor.registerMessageHandler("LD", (e22, t5) => this._getWorkerSource(e22, t5.type, t5.source).loadData(t5)), this.actor.registerMessageHandler("GD", (e22, t5) => this._getWorkerSource(e22, t5.type, t5.source).getData()), this.actor.registerMessageHandler("LT", (e22, t5) => this._getWorkerSource(e22, t5.type, t5.source).loadTile(t5)), this.actor.registerMessageHandler("RT", (e22, t5) => this._getWorkerSource(e22, t5.type, t5.source).reloadTile(t5)), this.actor.registerMessageHandler("AT", (e22, t5) => this._getWorkerSource(e22, t5.type, t5.source).abortTile(t5)), this.actor.registerMessageHandler("RMT", (e22, t5) => this._getWorkerSource(e22, t5.type, t5.source).removeTile(t5)), this.actor.registerMessageHandler("RS", (t5, o22) => e2._(this, void 0, void 0, function* () {
+                    if (!this.workerSources[t5] || !this.workerSources[t5][o22.type] || !this.workerSources[t5][o22.type][o22.source]) return;
+                    const e22 = this.workerSources[t5][o22.type][o22.source];
+                    delete this.workerSources[t5][o22.type][o22.source], void 0 !== e22.removeSource && e22.removeSource(o22);
+                  })), this.actor.registerMessageHandler("RM", (t5) => e2._(this, void 0, void 0, function* () {
+                    delete this.layerIndexes[t5], delete this.availableImages[t5], delete this.workerSources[t5], delete this.demWorkerSources[t5];
+                  })), this.actor.registerMessageHandler("SR", (t5, o22) => e2._(this, void 0, void 0, function* () {
+                    this.referrer = o22;
+                  })), this.actor.registerMessageHandler("SRPS", (e22, t5) => this._syncRTLPluginState(e22, t5)), this.actor.registerMessageHandler("IS", (t5, o22) => e2._(this, void 0, void 0, function* () {
+                    this.self.importScripts(o22);
+                  })), this.actor.registerMessageHandler("SI", (e22, t5) => this._setImages(e22, t5)), this.actor.registerMessageHandler("UL", (t5, o22) => e2._(this, void 0, void 0, function* () {
+                    this._getLayerIndex(t5).update(o22.layers, o22.removedIds);
+                  })), this.actor.registerMessageHandler("SL", (t5, o22) => e2._(this, void 0, void 0, function* () {
+                    this._getLayerIndex(t5).replace(o22);
+                  }));
+                }
+                _setImages(t42, o22) {
+                  return e2._(this, void 0, void 0, function* () {
+                    this.availableImages[t42] = o22;
+                    for (const e22 in this.workerSources[t42]) {
+                      const i22 = this.workerSources[t42][e22];
+                      for (const e3 in i22) i22[e3].availableImages = o22;
+                    }
+                  });
+                }
+                _syncRTLPluginState(t42, o22) {
+                  return e2._(this, void 0, void 0, function* () {
+                    if (e2.bD.isParsed()) return e2.bD.getState();
+                    if ("loading" !== o22.pluginStatus) return e2.bD.setState(o22), o22;
+                    const t5 = o22.pluginURL;
+                    if (this.self.importScripts(t5), e2.bD.isParsed()) {
+                      const o3 = { pluginStatus: "loaded", pluginURL: t5 };
+                      return e2.bD.setState(o3), o3;
+                    }
+                    throw e2.bD.setState({ pluginStatus: "error", pluginURL: "" }), new Error(`RTL Text Plugin failed to import scripts from ${t5}`);
+                  });
+                }
+                _getAvailableImages(e22) {
+                  let t42 = this.availableImages[e22];
+                  return t42 || (t42 = []), t42;
+                }
+                _getLayerIndex(e22) {
+                  let o22 = this.layerIndexes[e22];
+                  return o22 || (o22 = this.layerIndexes[e22] = new t4()), o22;
+                }
+                _getWorkerSource(e22, t42, o22) {
+                  if (this.workerSources[e22] || (this.workerSources[e22] = {}), this.workerSources[e22][t42] || (this.workerSources[e22][t42] = {}), !this.workerSources[e22][t42][o22]) {
+                    const i22 = { sendAsync: (t5, o3) => (t5.targetMapId = e22, this.actor.sendAsync(t5, o3)) };
+                    switch (t42) {
+                      case "vector":
+                        this.workerSources[e22][t42][o22] = new r2(i22, this._getLayerIndex(e22), this._getAvailableImages(e22));
+                        break;
+                      case "geojson":
+                        this.workerSources[e22][t42][o22] = new ye2(i22, this._getLayerIndex(e22), this._getAvailableImages(e22));
+                        break;
+                      default:
+                        this.workerSources[e22][t42][o22] = new this.externalWorkerSourceTypes[t42](i22, this._getLayerIndex(e22), this._getAvailableImages(e22));
+                    }
+                  }
+                  return this.workerSources[e22][t42][o22];
+                }
+                _getDEMWorkerSource(e22, t42) {
+                  return this.demWorkerSources[e22] || (this.demWorkerSources[e22] = {}), this.demWorkerSources[e22][t42] || (this.demWorkerSources[e22][t42] = new n2()), this.demWorkerSources[e22][t42];
+                }
+              }
+              return e2.i(self) && (self.worker = new ve2(self)), ve2;
+            });
+            define2("index", ["exports", "./shared"], function(t4, e2) {
+              var i2 = "4.7.1";
+              let a2, s2;
+              const o2 = { now: "undefined" != typeof performance && performance && performance.now ? performance.now.bind(performance) : Date.now.bind(Date), frameAsync: (t42) => new Promise((i22, a22) => {
+                const s22 = requestAnimationFrame(i22);
+                t42.signal.addEventListener("abort", () => {
+                  cancelAnimationFrame(s22), a22(e2.c());
+                });
+              }), getImageData(t42, e22 = 0) {
+                return this.getImageCanvasContext(t42).getImageData(-e22, -e22, t42.width + 2 * e22, t42.height + 2 * e22);
+              }, getImageCanvasContext(t42) {
+                const e22 = window.document.createElement("canvas"), i22 = e22.getContext("2d", { willReadFrequently: true });
+                if (!i22) throw new Error("failed to create canvas 2d context");
+                return e22.width = t42.width, e22.height = t42.height, i22.drawImage(t42, 0, 0, t42.width, t42.height), i22;
+              }, resolveURL: (t42) => (a2 || (a2 = document.createElement("a")), a2.href = t42, a2.href), hardwareConcurrency: "undefined" != typeof navigator && navigator.hardwareConcurrency || 4, get prefersReducedMotion() {
+                return !!matchMedia && (null == s2 && (s2 = matchMedia("(prefers-reduced-motion: reduce)")), s2.matches);
+              } };
+              class r2 {
+                static testProp(t42) {
+                  if (!r2.docStyle) return t42[0];
+                  for (let e22 = 0; e22 < t42.length; e22++) if (t42[e22] in r2.docStyle) return t42[e22];
+                  return t42[0];
+                }
+                static create(t42, e22, i22) {
+                  const a22 = window.document.createElement(t42);
+                  return void 0 !== e22 && (a22.className = e22), i22 && i22.appendChild(a22), a22;
+                }
+                static createNS(t42, e22) {
+                  return window.document.createElementNS(t42, e22);
+                }
+                static disableDrag() {
+                  r2.docStyle && r2.selectProp && (r2.userSelect = r2.docStyle[r2.selectProp], r2.docStyle[r2.selectProp] = "none");
+                }
+                static enableDrag() {
+                  r2.docStyle && r2.selectProp && (r2.docStyle[r2.selectProp] = r2.userSelect);
+                }
+                static setTransform(t42, e22) {
+                  t42.style[r2.transformProp] = e22;
+                }
+                static addEventListener(t42, e22, i22, a22 = {}) {
+                  t42.addEventListener(e22, i22, "passive" in a22 ? a22 : a22.capture);
+                }
+                static removeEventListener(t42, e22, i22, a22 = {}) {
+                  t42.removeEventListener(e22, i22, "passive" in a22 ? a22 : a22.capture);
+                }
+                static suppressClickInternal(t42) {
+                  t42.preventDefault(), t42.stopPropagation(), window.removeEventListener("click", r2.suppressClickInternal, true);
+                }
+                static suppressClick() {
+                  window.addEventListener("click", r2.suppressClickInternal, true), window.setTimeout(() => {
+                    window.removeEventListener("click", r2.suppressClickInternal, true);
+                  }, 0);
+                }
+                static getScale(t42) {
+                  const e22 = t42.getBoundingClientRect();
+                  return { x: e22.width / t42.offsetWidth || 1, y: e22.height / t42.offsetHeight || 1, boundingClientRect: e22 };
+                }
+                static getPoint(t42, i22, a22) {
+                  const s22 = i22.boundingClientRect;
+                  return new e2.P((a22.clientX - s22.left) / i22.x - t42.clientLeft, (a22.clientY - s22.top) / i22.y - t42.clientTop);
+                }
+                static mousePos(t42, e22) {
+                  const i22 = r2.getScale(t42);
+                  return r2.getPoint(t42, i22, e22);
+                }
+                static touchPos(t42, e22) {
+                  const i22 = [], a22 = r2.getScale(t42);
+                  for (let s22 = 0; s22 < e22.length; s22++) i22.push(r2.getPoint(t42, a22, e22[s22]));
+                  return i22;
+                }
+                static mouseButton(t42) {
+                  return t42.button;
+                }
+                static remove(t42) {
+                  t42.parentNode && t42.parentNode.removeChild(t42);
+                }
+              }
+              r2.docStyle = "undefined" != typeof window && window.document && window.document.documentElement.style, r2.selectProp = r2.testProp(["userSelect", "MozUserSelect", "WebkitUserSelect", "msUserSelect"]), r2.transformProp = r2.testProp(["transform", "WebkitTransform"]);
+              const n2 = { supported: false, testSupport: function(t42) {
+                !c2 && h2 && (u2 ? d2(t42) : l2 = t42);
+              } };
+              let l2, h2, c2 = false, u2 = false;
+              function d2(t42) {
+                const e22 = t42.createTexture();
+                t42.bindTexture(t42.TEXTURE_2D, e22);
+                try {
+                  if (t42.texImage2D(t42.TEXTURE_2D, 0, t42.RGBA, t42.RGBA, t42.UNSIGNED_BYTE, h2), t42.isContextLost()) return;
+                  n2.supported = true;
+                } catch (t5) {
+                }
+                t42.deleteTexture(e22), c2 = true;
+              }
+              var _2;
+              "undefined" != typeof document && (h2 = document.createElement("img"), h2.onload = () => {
+                l2 && d2(l2), l2 = null, u2 = true;
+              }, h2.onerror = () => {
+                c2 = true, l2 = null;
+              }, h2.src = "data:image/webp;base64,UklGRh4AAABXRUJQVlA4TBEAAAAvAQAAAAfQ//73v/+BiOh/AAA="), function(t42) {
+                let i22, a22, s22, o22;
+                t42.resetRequestQueue = () => {
+                  i22 = [], a22 = 0, s22 = 0, o22 = {};
+                }, t42.addThrottleControl = (t5) => {
+                  const e22 = s22++;
+                  return o22[e22] = t5, e22;
+                }, t42.removeThrottleControl = (t5) => {
+                  delete o22[t5], l22();
+                }, t42.getImage = (t5, a3, s3 = true) => new Promise((o3, r3) => {
+                  n2.supported && (t5.headers || (t5.headers = {}), t5.headers.accept = "image/webp,*/*"), e2.e(t5, { type: "image" }), i22.push({ abortController: a3, requestParameters: t5, supportImageRefresh: s3, state: "queued", onError: (t6) => {
+                    r3(t6);
+                  }, onSuccess: (t6) => {
+                    o3(t6);
+                  } }), l22();
+                });
+                const r22 = (t5) => e2._(this, void 0, void 0, function* () {
+                  t5.state = "running";
+                  const { requestParameters: i3, supportImageRefresh: s3, onError: o3, onSuccess: r3, abortController: n22 } = t5, c22 = false === s3 && !e2.i(self) && !e2.g(i3.url) && (!i3.headers || Object.keys(i3.headers).reduce((t6, e22) => t6 && "accept" === e22, true));
+                  a22++;
+                  const u22 = c22 ? h22(i3, n22) : e2.m(i3, n22);
+                  try {
+                    const i4 = yield u22;
+                    delete t5.abortController, t5.state = "completed", i4.data instanceof HTMLImageElement || e2.b(i4.data) ? r3(i4) : i4.data && r3({ data: yield (d22 = i4.data, "function" == typeof createImageBitmap ? e2.d(d22) : e2.f(d22)), cacheControl: i4.cacheControl, expires: i4.expires });
+                  } catch (e22) {
+                    delete t5.abortController, o3(e22);
+                  } finally {
+                    a22--, l22();
+                  }
+                  var d22;
+                }), l22 = () => {
+                  const t5 = (() => {
+                    for (const t6 of Object.keys(o22)) if (o22[t6]()) return true;
+                    return false;
+                  })() ? e2.a.MAX_PARALLEL_IMAGE_REQUESTS_PER_FRAME : e2.a.MAX_PARALLEL_IMAGE_REQUESTS;
+                  for (let e22 = a22; e22 < t5 && i22.length > 0; e22++) {
+                    const t6 = i22.shift();
+                    t6.abortController.signal.aborted ? e22-- : r22(t6);
+                  }
+                }, h22 = (t5, i3) => new Promise((a3, s3) => {
+                  const o3 = new Image(), r3 = t5.url, n22 = t5.credentials;
+                  n22 && "include" === n22 ? o3.crossOrigin = "use-credentials" : (n22 && "same-origin" === n22 || !e2.s(r3)) && (o3.crossOrigin = "anonymous"), i3.signal.addEventListener("abort", () => {
+                    o3.src = "", s3(e2.c());
+                  }), o3.fetchPriority = "high", o3.onload = () => {
+                    o3.onerror = o3.onload = null, a3({ data: o3 });
+                  }, o3.onerror = () => {
+                    o3.onerror = o3.onload = null, i3.signal.aborted || s3(new Error("Could not load image. Please make sure to use a supported image type such as PNG or JPEG. Note that SVGs are not supported."));
+                  }, o3.src = r3;
+                });
+              }(_2 || (_2 = {})), _2.resetRequestQueue();
+              class p2 {
+                constructor(t42) {
+                  this._transformRequestFn = t42;
+                }
+                transformRequest(t42, e22) {
+                  return this._transformRequestFn && this._transformRequestFn(t42, e22) || { url: t42 };
+                }
+                setTransformRequest(t42) {
+                  this._transformRequestFn = t42;
+                }
+              }
+              function m2(t42) {
+                var i22 = new e2.A(3);
+                return i22[0] = t42[0], i22[1] = t42[1], i22[2] = t42[2], i22;
+              }
+              var f2, g2 = function(t42, e22, i22) {
+                return t42[0] = e22[0] - i22[0], t42[1] = e22[1] - i22[1], t42[2] = e22[2] - i22[2], t42;
+              };
+              f2 = new e2.A(3), e2.A != Float32Array && (f2[0] = 0, f2[1] = 0, f2[2] = 0);
+              var v2 = function(t42) {
+                var e22 = t42[0], i22 = t42[1];
+                return e22 * e22 + i22 * i22;
+              };
+              function x2(t42) {
+                const e22 = [];
+                if ("string" == typeof t42) e22.push({ id: "default", url: t42 });
+                else if (t42 && t42.length > 0) {
+                  const i22 = [];
+                  for (const { id: a22, url: s22 } of t42) {
+                    const t5 = `${a22}${s22}`;
+                    -1 === i22.indexOf(t5) && (i22.push(t5), e22.push({ id: a22, url: s22 }));
+                  }
+                }
+                return e22;
+              }
+              function y2(t42, e22, i22) {
+                const a22 = t42.split("?");
+                return a22[0] += `${e22}${i22}`, a22.join("?");
+              }
+              !function() {
+                var t42 = new e2.A(2);
+                e2.A != Float32Array && (t42[0] = 0, t42[1] = 0);
+              }();
+              class b2 {
+                constructor(t42, e22, i22, a22) {
+                  this.context = t42, this.format = i22, this.texture = t42.gl.createTexture(), this.update(e22, a22);
+                }
+                update(t42, i22, a22) {
+                  const { width: s22, height: o22 } = t42, r22 = !(this.size && this.size[0] === s22 && this.size[1] === o22 || a22), { context: n22 } = this, { gl: l22 } = n22;
+                  if (this.useMipmap = Boolean(i22 && i22.useMipmap), l22.bindTexture(l22.TEXTURE_2D, this.texture), n22.pixelStoreUnpackFlipY.set(false), n22.pixelStoreUnpack.set(1), n22.pixelStoreUnpackPremultiplyAlpha.set(this.format === l22.RGBA && (!i22 || false !== i22.premultiply)), r22) this.size = [s22, o22], t42 instanceof HTMLImageElement || t42 instanceof HTMLCanvasElement || t42 instanceof HTMLVideoElement || t42 instanceof ImageData || e2.b(t42) ? l22.texImage2D(l22.TEXTURE_2D, 0, this.format, this.format, l22.UNSIGNED_BYTE, t42) : l22.texImage2D(l22.TEXTURE_2D, 0, this.format, s22, o22, 0, this.format, l22.UNSIGNED_BYTE, t42.data);
+                  else {
+                    const { x: i3, y: r3 } = a22 || { x: 0, y: 0 };
+                    t42 instanceof HTMLImageElement || t42 instanceof HTMLCanvasElement || t42 instanceof HTMLVideoElement || t42 instanceof ImageData || e2.b(t42) ? l22.texSubImage2D(l22.TEXTURE_2D, 0, i3, r3, l22.RGBA, l22.UNSIGNED_BYTE, t42) : l22.texSubImage2D(l22.TEXTURE_2D, 0, i3, r3, s22, o22, l22.RGBA, l22.UNSIGNED_BYTE, t42.data);
+                  }
+                  this.useMipmap && this.isSizePowerOfTwo() && l22.generateMipmap(l22.TEXTURE_2D);
+                }
+                bind(t42, e22, i22) {
+                  const { context: a22 } = this, { gl: s22 } = a22;
+                  s22.bindTexture(s22.TEXTURE_2D, this.texture), i22 !== s22.LINEAR_MIPMAP_NEAREST || this.isSizePowerOfTwo() || (i22 = s22.LINEAR), t42 !== this.filter && (s22.texParameteri(s22.TEXTURE_2D, s22.TEXTURE_MAG_FILTER, t42), s22.texParameteri(s22.TEXTURE_2D, s22.TEXTURE_MIN_FILTER, i22 || t42), this.filter = t42), e22 !== this.wrap && (s22.texParameteri(s22.TEXTURE_2D, s22.TEXTURE_WRAP_S, e22), s22.texParameteri(s22.TEXTURE_2D, s22.TEXTURE_WRAP_T, e22), this.wrap = e22);
+                }
+                isSizePowerOfTwo() {
+                  return this.size[0] === this.size[1] && Math.log(this.size[0]) / Math.LN2 % 1 == 0;
+                }
+                destroy() {
+                  const { gl: t42 } = this.context;
+                  t42.deleteTexture(this.texture), this.texture = null;
+                }
+              }
+              function w2(t42) {
+                const { userImage: e22 } = t42;
+                return !!(e22 && e22.render && e22.render()) && (t42.data.replace(new Uint8Array(e22.data.buffer)), true);
+              }
+              class T2 extends e2.E {
+                constructor() {
+                  super(), this.images = {}, this.updatedImages = {}, this.callbackDispatchedThisFrame = {}, this.loaded = false, this.requestors = [], this.patterns = {}, this.atlasImage = new e2.R({ width: 1, height: 1 }), this.dirty = true;
+                }
+                isLoaded() {
+                  return this.loaded;
+                }
+                setLoaded(t42) {
+                  if (this.loaded !== t42 && (this.loaded = t42, t42)) {
+                    for (const { ids: t5, promiseResolve: e22 } of this.requestors) e22(this._getImagesForIds(t5));
+                    this.requestors = [];
+                  }
+                }
+                getImage(t42) {
+                  const i22 = this.images[t42];
+                  if (i22 && !i22.data && i22.spriteData) {
+                    const t5 = i22.spriteData;
+                    i22.data = new e2.R({ width: t5.width, height: t5.height }, t5.context.getImageData(t5.x, t5.y, t5.width, t5.height).data), i22.spriteData = null;
+                  }
+                  return i22;
+                }
+                addImage(t42, e22) {
+                  if (this.images[t42]) throw new Error(`Image id ${t42} already exist, use updateImage instead`);
+                  this._validate(t42, e22) && (this.images[t42] = e22);
+                }
+                _validate(t42, i22) {
+                  let a22 = true;
+                  const s22 = i22.data || i22.spriteData;
+                  return this._validateStretch(i22.stretchX, s22 && s22.width) || (this.fire(new e2.j(new Error(`Image "${t42}" has invalid "stretchX" value`))), a22 = false), this._validateStretch(i22.stretchY, s22 && s22.height) || (this.fire(new e2.j(new Error(`Image "${t42}" has invalid "stretchY" value`))), a22 = false), this._validateContent(i22.content, i22) || (this.fire(new e2.j(new Error(`Image "${t42}" has invalid "content" value`))), a22 = false), a22;
+                }
+                _validateStretch(t42, e22) {
+                  if (!t42) return true;
+                  let i22 = 0;
+                  for (const a22 of t42) {
+                    if (a22[0] < i22 || a22[1] < a22[0] || e22 < a22[1]) return false;
+                    i22 = a22[1];
+                  }
+                  return true;
+                }
+                _validateContent(t42, e22) {
+                  if (!t42) return true;
+                  if (4 !== t42.length) return false;
+                  const i22 = e22.spriteData, a22 = i22 && i22.width || e22.data.width, s22 = i22 && i22.height || e22.data.height;
+                  return !(t42[0] < 0 || a22 < t42[0] || t42[1] < 0 || s22 < t42[1] || t42[2] < 0 || a22 < t42[2] || t42[3] < 0 || s22 < t42[3] || t42[2] < t42[0] || t42[3] < t42[1]);
+                }
+                updateImage(t42, e22, i22 = true) {
+                  const a22 = this.getImage(t42);
+                  if (i22 && (a22.data.width !== e22.data.width || a22.data.height !== e22.data.height)) throw new Error(`size mismatch between old image (${a22.data.width}x${a22.data.height}) and new image (${e22.data.width}x${e22.data.height}).`);
+                  e22.version = a22.version + 1, this.images[t42] = e22, this.updatedImages[t42] = true;
+                }
+                removeImage(t42) {
+                  const e22 = this.images[t42];
+                  delete this.images[t42], delete this.patterns[t42], e22.userImage && e22.userImage.onRemove && e22.userImage.onRemove();
+                }
+                listImages() {
+                  return Object.keys(this.images);
+                }
+                getImages(t42) {
+                  return new Promise((e22, i22) => {
+                    let a22 = true;
+                    if (!this.isLoaded()) for (const e3 of t42) this.images[e3] || (a22 = false);
+                    this.isLoaded() || a22 ? e22(this._getImagesForIds(t42)) : this.requestors.push({ ids: t42, promiseResolve: e22 });
+                  });
+                }
+                _getImagesForIds(t42) {
+                  const i22 = {};
+                  for (const a22 of t42) {
+                    let t5 = this.getImage(a22);
+                    t5 || (this.fire(new e2.k("styleimagemissing", { id: a22 })), t5 = this.getImage(a22)), t5 ? i22[a22] = { data: t5.data.clone(), pixelRatio: t5.pixelRatio, sdf: t5.sdf, version: t5.version, stretchX: t5.stretchX, stretchY: t5.stretchY, content: t5.content, textFitWidth: t5.textFitWidth, textFitHeight: t5.textFitHeight, hasRenderCallback: Boolean(t5.userImage && t5.userImage.render) } : e2.w(`Image "${a22}" could not be loaded. Please make sure you have added the image with map.addImage() or a "sprite" property in your style. You can provide missing images by listening for the "styleimagemissing" map event.`);
+                  }
+                  return i22;
+                }
+                getPixelSize() {
+                  const { width: t42, height: e22 } = this.atlasImage;
+                  return { width: t42, height: e22 };
+                }
+                getPattern(t42) {
+                  const i22 = this.patterns[t42], a22 = this.getImage(t42);
+                  if (!a22) return null;
+                  if (i22 && i22.position.version === a22.version) return i22.position;
+                  if (i22) i22.position.version = a22.version;
+                  else {
+                    const i3 = { w: a22.data.width + 2, h: a22.data.height + 2, x: 0, y: 0 }, s22 = new e2.I(i3, a22);
+                    this.patterns[t42] = { bin: i3, position: s22 };
+                  }
+                  return this._updatePatternAtlas(), this.patterns[t42].position;
+                }
+                bind(t42) {
+                  const e22 = t42.gl;
+                  this.atlasTexture ? this.dirty && (this.atlasTexture.update(this.atlasImage), this.dirty = false) : this.atlasTexture = new b2(t42, this.atlasImage, e22.RGBA), this.atlasTexture.bind(e22.LINEAR, e22.CLAMP_TO_EDGE);
+                }
+                _updatePatternAtlas() {
+                  const t42 = [];
+                  for (const e22 in this.patterns) t42.push(this.patterns[e22].bin);
+                  const { w: i22, h: a22 } = e2.p(t42), s22 = this.atlasImage;
+                  s22.resize({ width: i22 || 1, height: a22 || 1 });
+                  for (const t5 in this.patterns) {
+                    const { bin: i3 } = this.patterns[t5], a3 = i3.x + 1, o22 = i3.y + 1, r22 = this.getImage(t5).data, n22 = r22.width, l22 = r22.height;
+                    e2.R.copy(r22, s22, { x: 0, y: 0 }, { x: a3, y: o22 }, { width: n22, height: l22 }), e2.R.copy(r22, s22, { x: 0, y: l22 - 1 }, { x: a3, y: o22 - 1 }, { width: n22, height: 1 }), e2.R.copy(r22, s22, { x: 0, y: 0 }, { x: a3, y: o22 + l22 }, { width: n22, height: 1 }), e2.R.copy(r22, s22, { x: n22 - 1, y: 0 }, { x: a3 - 1, y: o22 }, { width: 1, height: l22 }), e2.R.copy(r22, s22, { x: 0, y: 0 }, { x: a3 + n22, y: o22 }, { width: 1, height: l22 });
+                  }
+                  this.dirty = true;
+                }
+                beginFrame() {
+                  this.callbackDispatchedThisFrame = {};
+                }
+                dispatchRenderCallbacks(t42) {
+                  for (const i22 of t42) {
+                    if (this.callbackDispatchedThisFrame[i22]) continue;
+                    this.callbackDispatchedThisFrame[i22] = true;
+                    const t5 = this.getImage(i22);
+                    t5 || e2.w(`Image with ID: "${i22}" was not found`), w2(t5) && this.updateImage(i22, t5);
+                  }
+                }
+              }
+              const I2 = 1e20;
+              function E22(t42, e22, i22, a22, s22, o22, r22, n22, l22) {
+                for (let h22 = e22; h22 < e22 + a22; h22++) P2(t42, i22 * o22 + h22, o22, s22, r22, n22, l22);
+                for (let h22 = i22; h22 < i22 + s22; h22++) P2(t42, h22 * o22 + e22, 1, a22, r22, n22, l22);
+              }
+              function P2(t42, e22, i22, a22, s22, o22, r22) {
+                o22[0] = 0, r22[0] = -1e20, r22[1] = I2, s22[0] = t42[e22];
+                for (let n22 = 1, l22 = 0, h22 = 0; n22 < a22; n22++) {
+                  s22[n22] = t42[e22 + n22 * i22];
+                  const a3 = n22 * n22;
+                  do {
+                    const t5 = o22[l22];
+                    h22 = (s22[n22] - s22[t5] + a3 - t5 * t5) / (n22 - t5) / 2;
+                  } while (h22 <= r22[l22] && --l22 > -1);
+                  l22++, o22[l22] = n22, r22[l22] = h22, r22[l22 + 1] = I2;
+                }
+                for (let n22 = 0, l22 = 0; n22 < a22; n22++) {
+                  for (; r22[l22 + 1] < n22; ) l22++;
+                  const a3 = o22[l22], h22 = n22 - a3;
+                  t42[e22 + n22 * i22] = s22[a3] + h22 * h22;
+                }
+              }
+              class C22 {
+                constructor(t42, e22) {
+                  this.requestManager = t42, this.localIdeographFontFamily = e22, this.entries = {};
+                }
+                setURL(t42) {
+                  this.url = t42;
+                }
+                getGlyphs(t42) {
+                  return e2._(this, void 0, void 0, function* () {
+                    const e22 = [];
+                    for (const i3 in t42) for (const a3 of t42[i3]) e22.push(this._getAndCacheGlyphsPromise(i3, a3));
+                    const i22 = yield Promise.all(e22), a22 = {};
+                    for (const { stack: t5, id: e3, glyph: s22 } of i22) a22[t5] || (a22[t5] = {}), a22[t5][e3] = s22 && { id: s22.id, bitmap: s22.bitmap.clone(), metrics: s22.metrics };
+                    return a22;
+                  });
+                }
+                _getAndCacheGlyphsPromise(t42, i22) {
+                  return e2._(this, void 0, void 0, function* () {
+                    let e22 = this.entries[t42];
+                    e22 || (e22 = this.entries[t42] = { glyphs: {}, requests: {}, ranges: {} });
+                    let a22 = e22.glyphs[i22];
+                    if (void 0 !== a22) return { stack: t42, id: i22, glyph: a22 };
+                    if (a22 = this._tinySDF(e22, t42, i22), a22) return e22.glyphs[i22] = a22, { stack: t42, id: i22, glyph: a22 };
+                    const s22 = Math.floor(i22 / 256);
+                    if (256 * s22 > 65535) throw new Error("glyphs > 65535 not supported");
+                    if (e22.ranges[s22]) return { stack: t42, id: i22, glyph: a22 };
+                    if (!this.url) throw new Error("glyphsUrl is not set");
+                    if (!e22.requests[s22]) {
+                      const i3 = C22.loadGlyphRange(t42, s22, this.url, this.requestManager);
+                      e22.requests[s22] = i3;
+                    }
+                    const o22 = yield e22.requests[s22];
+                    for (const t5 in o22) this._doesCharSupportLocalGlyph(+t5) || (e22.glyphs[+t5] = o22[+t5]);
+                    return e22.ranges[s22] = true, { stack: t42, id: i22, glyph: o22[i22] || null };
+                  });
+                }
+                _doesCharSupportLocalGlyph(t42) {
+                  return !!this.localIdeographFontFamily && new RegExp("\\p{Ideo}|\\p{sc=Hang}|\\p{sc=Hira}|\\p{sc=Kana}", "u").test(String.fromCodePoint(t42));
+                }
+                _tinySDF(t42, i22, a22) {
+                  const s22 = this.localIdeographFontFamily;
+                  if (!s22) return;
+                  if (!this._doesCharSupportLocalGlyph(a22)) return;
+                  let o22 = t42.tinySDF;
+                  if (!o22) {
+                    let e22 = "400";
+                    /bold/i.test(i22) ? e22 = "900" : /medium/i.test(i22) ? e22 = "500" : /light/i.test(i22) && (e22 = "200"), o22 = t42.tinySDF = new C22.TinySDF({ fontSize: 48, buffer: 6, radius: 16, cutoff: 0.25, fontFamily: s22, fontWeight: e22 });
+                  }
+                  const r22 = o22.draw(String.fromCharCode(a22));
+                  return { id: a22, bitmap: new e2.o({ width: r22.width || 60, height: r22.height || 60 }, r22.data), metrics: { width: r22.glyphWidth / 2 || 24, height: r22.glyphHeight / 2 || 24, left: r22.glyphLeft / 2 + 0.5 || 0, top: r22.glyphTop / 2 - 27.5 || -8, advance: r22.glyphAdvance / 2 || 24, isDoubleResolution: true } };
+                }
+              }
+              C22.loadGlyphRange = function(t42, i22, a22, s22) {
+                return e2._(this, void 0, void 0, function* () {
+                  const o22 = 256 * i22, r22 = o22 + 255, n22 = s22.transformRequest(a22.replace("{fontstack}", t42).replace("{range}", `${o22}-${r22}`), "Glyphs"), l22 = yield e2.l(n22, new AbortController());
+                  if (!l22 || !l22.data) throw new Error(`Could not load glyph range. range: ${i22}, ${o22}-${r22}`);
+                  const h22 = {};
+                  for (const t5 of e2.n(l22.data)) h22[t5.id] = t5;
+                  return h22;
+                });
+              }, C22.TinySDF = class {
+                constructor({ fontSize: t42 = 24, buffer: e22 = 3, radius: i22 = 8, cutoff: a22 = 0.25, fontFamily: s22 = "sans-serif", fontWeight: o22 = "normal", fontStyle: r22 = "normal" } = {}) {
+                  this.buffer = e22, this.cutoff = a22, this.radius = i22;
+                  const n22 = this.size = t42 + 4 * e22, l22 = this._createCanvas(n22), h22 = this.ctx = l22.getContext("2d", { willReadFrequently: true });
+                  h22.font = `${r22} ${o22} ${t42}px ${s22}`, h22.textBaseline = "alphabetic", h22.textAlign = "left", h22.fillStyle = "black", this.gridOuter = new Float64Array(n22 * n22), this.gridInner = new Float64Array(n22 * n22), this.f = new Float64Array(n22), this.z = new Float64Array(n22 + 1), this.v = new Uint16Array(n22);
+                }
+                _createCanvas(t42) {
+                  const e22 = document.createElement("canvas");
+                  return e22.width = e22.height = t42, e22;
+                }
+                draw(t42) {
+                  const { width: e22, actualBoundingBoxAscent: i22, actualBoundingBoxDescent: a22, actualBoundingBoxLeft: s22, actualBoundingBoxRight: o22 } = this.ctx.measureText(t42), r22 = Math.ceil(i22), n22 = Math.max(0, Math.min(this.size - this.buffer, Math.ceil(o22 - s22))), l22 = Math.min(this.size - this.buffer, r22 + Math.ceil(a22)), h22 = n22 + 2 * this.buffer, c22 = l22 + 2 * this.buffer, u22 = Math.max(h22 * c22, 0), d22 = new Uint8ClampedArray(u22), _22 = { data: d22, width: h22, height: c22, glyphWidth: n22, glyphHeight: l22, glyphTop: r22, glyphLeft: 0, glyphAdvance: e22 };
+                  if (0 === n22 || 0 === l22) return _22;
+                  const { ctx: p22, buffer: m22, gridInner: f22, gridOuter: g22 } = this;
+                  p22.clearRect(m22, m22, n22, l22), p22.fillText(t42, m22, m22 + r22);
+                  const v22 = p22.getImageData(m22, m22, n22, l22);
+                  g22.fill(I2, 0, u22), f22.fill(0, 0, u22);
+                  for (let t5 = 0; t5 < l22; t5++) for (let e3 = 0; e3 < n22; e3++) {
+                    const i3 = v22.data[4 * (t5 * n22 + e3) + 3] / 255;
+                    if (0 === i3) continue;
+                    const a3 = (t5 + m22) * h22 + e3 + m22;
+                    if (1 === i3) g22[a3] = 0, f22[a3] = I2;
+                    else {
+                      const t6 = 0.5 - i3;
+                      g22[a3] = t6 > 0 ? t6 * t6 : 0, f22[a3] = t6 < 0 ? t6 * t6 : 0;
+                    }
+                  }
+                  E22(g22, 0, 0, h22, c22, h22, this.f, this.v, this.z), E22(f22, m22, m22, n22, l22, h22, this.f, this.v, this.z);
+                  for (let t5 = 0; t5 < u22; t5++) {
+                    const e3 = Math.sqrt(g22[t5]) - Math.sqrt(f22[t5]);
+                    d22[t5] = Math.round(255 - 255 * (e3 / this.radius + this.cutoff));
+                  }
+                  return _22;
+                }
+              };
+              class S2 {
+                constructor() {
+                  this.specification = e2.v.light.position;
+                }
+                possiblyEvaluate(t42, i22) {
+                  return e2.x(t42.expression.evaluate(i22));
+                }
+                interpolate(t42, i22, a22) {
+                  return { x: e2.y.number(t42.x, i22.x, a22), y: e2.y.number(t42.y, i22.y, a22), z: e2.y.number(t42.z, i22.z, a22) };
+                }
+              }
+              let z2;
+              class D22 extends e2.E {
+                constructor(t42) {
+                  super(), z2 = z2 || new e2.q({ anchor: new e2.D(e2.v.light.anchor), position: new S2(), color: new e2.D(e2.v.light.color), intensity: new e2.D(e2.v.light.intensity) }), this._transitionable = new e2.T(z2), this.setLight(t42), this._transitioning = this._transitionable.untransitioned();
+                }
+                getLight() {
+                  return this._transitionable.serialize();
+                }
+                setLight(t42, i22 = {}) {
+                  if (!this._validate(e2.r, t42, i22)) for (const e22 in t42) {
+                    const i3 = t42[e22];
+                    e22.endsWith("-transition") ? this._transitionable.setTransition(e22.slice(0, -11), i3) : this._transitionable.setValue(e22, i3);
+                  }
+                }
+                updateTransitions(t42) {
+                  this._transitioning = this._transitionable.transitioned(t42, this._transitioning);
+                }
+                hasTransition() {
+                  return this._transitioning.hasTransition();
+                }
+                recalculate(t42) {
+                  this.properties = this._transitioning.possiblyEvaluate(t42);
+                }
+                _validate(t42, i22, a22) {
+                  return (!a22 || false !== a22.validate) && e2.t(this, t42.call(e2.u, { value: i22, style: { glyphs: true, sprite: true }, styleSpec: e2.v }));
+                }
+              }
+              const M2 = new e2.q({ "sky-color": new e2.D(e2.v.sky["sky-color"]), "horizon-color": new e2.D(e2.v.sky["horizon-color"]), "fog-color": new e2.D(e2.v.sky["fog-color"]), "fog-ground-blend": new e2.D(e2.v.sky["fog-ground-blend"]), "horizon-fog-blend": new e2.D(e2.v.sky["horizon-fog-blend"]), "sky-horizon-blend": new e2.D(e2.v.sky["sky-horizon-blend"]), "atmosphere-blend": new e2.D(e2.v.sky["atmosphere-blend"]) });
+              class A22 extends e2.E {
+                constructor(t42) {
+                  super(), this._transitionable = new e2.T(M2), this.setSky(t42), this._transitioning = this._transitionable.untransitioned(), this.recalculate(new e2.z(0));
+                }
+                setSky(t42, i22 = {}) {
+                  if (!this._validate(e2.B, t42, i22)) {
+                    t42 || (t42 = { "sky-color": "transparent", "horizon-color": "transparent", "fog-color": "transparent", "fog-ground-blend": 1, "atmosphere-blend": 0 });
+                    for (const e22 in t42) {
+                      const i3 = t42[e22];
+                      e22.endsWith("-transition") ? this._transitionable.setTransition(e22.slice(0, -11), i3) : this._transitionable.setValue(e22, i3);
+                    }
+                  }
+                }
+                getSky() {
+                  return this._transitionable.serialize();
+                }
+                updateTransitions(t42) {
+                  this._transitioning = this._transitionable.transitioned(t42, this._transitioning);
+                }
+                hasTransition() {
+                  return this._transitioning.hasTransition();
+                }
+                recalculate(t42) {
+                  this.properties = this._transitioning.possiblyEvaluate(t42);
+                }
+                _validate(t42, i22, a22 = {}) {
+                  return false !== (null == a22 ? void 0 : a22.validate) && e2.t(this, t42.call(e2.u, e2.e({ value: i22, style: { glyphs: true, sprite: true }, styleSpec: e2.v })));
+                }
+                calculateFogBlendOpacity(t42) {
+                  return t42 < 60 ? 0 : t42 < 70 ? (t42 - 60) / 10 : 1;
+                }
+              }
+              class R2 {
+                constructor(t42, e22) {
+                  this.width = t42, this.height = e22, this.nextRow = 0, this.data = new Uint8Array(this.width * this.height), this.dashEntry = {};
+                }
+                getDash(t42, e22) {
+                  const i22 = t42.join(",") + String(e22);
+                  return this.dashEntry[i22] || (this.dashEntry[i22] = this.addDash(t42, e22)), this.dashEntry[i22];
+                }
+                getDashRanges(t42, e22, i22) {
+                  const a22 = [];
+                  let s22 = t42.length % 2 == 1 ? -t42[t42.length - 1] * i22 : 0, o22 = t42[0] * i22, r22 = true;
+                  a22.push({ left: s22, right: o22, isDash: r22, zeroLength: 0 === t42[0] });
+                  let n22 = t42[0];
+                  for (let e3 = 1; e3 < t42.length; e3++) {
+                    r22 = !r22;
+                    const l22 = t42[e3];
+                    s22 = n22 * i22, n22 += l22, o22 = n22 * i22, a22.push({ left: s22, right: o22, isDash: r22, zeroLength: 0 === l22 });
+                  }
+                  return a22;
+                }
+                addRoundDash(t42, e22, i22) {
+                  const a22 = e22 / 2;
+                  for (let e3 = -i22; e3 <= i22; e3++) {
+                    const s22 = this.width * (this.nextRow + i22 + e3);
+                    let o22 = 0, r22 = t42[o22];
+                    for (let n22 = 0; n22 < this.width; n22++) {
+                      n22 / r22.right > 1 && (r22 = t42[++o22]);
+                      const l22 = Math.abs(n22 - r22.left), h22 = Math.abs(n22 - r22.right), c22 = Math.min(l22, h22);
+                      let u22;
+                      const d22 = e3 / i22 * (a22 + 1);
+                      if (r22.isDash) {
+                        const t5 = a22 - Math.abs(d22);
+                        u22 = Math.sqrt(c22 * c22 + t5 * t5);
+                      } else u22 = a22 - Math.sqrt(c22 * c22 + d22 * d22);
+                      this.data[s22 + n22] = Math.max(0, Math.min(255, u22 + 128));
+                    }
+                  }
+                }
+                addRegularDash(t42) {
+                  for (let e3 = t42.length - 1; e3 >= 0; --e3) {
+                    const i3 = t42[e3], a3 = t42[e3 + 1];
+                    i3.zeroLength ? t42.splice(e3, 1) : a3 && a3.isDash === i3.isDash && (a3.left = i3.left, t42.splice(e3, 1));
+                  }
+                  const e22 = t42[0], i22 = t42[t42.length - 1];
+                  e22.isDash === i22.isDash && (e22.left = i22.left - this.width, i22.right = e22.right + this.width);
+                  const a22 = this.width * this.nextRow;
+                  let s22 = 0, o22 = t42[s22];
+                  for (let e3 = 0; e3 < this.width; e3++) {
+                    e3 / o22.right > 1 && (o22 = t42[++s22]);
+                    const i3 = Math.abs(e3 - o22.left), r22 = Math.abs(e3 - o22.right), n22 = Math.min(i3, r22);
+                    this.data[a22 + e3] = Math.max(0, Math.min(255, (o22.isDash ? n22 : -n22) + 128));
+                  }
+                }
+                addDash(t42, i22) {
+                  const a22 = i22 ? 7 : 0, s22 = 2 * a22 + 1;
+                  if (this.nextRow + s22 > this.height) return e2.w("LineAtlas out of space"), null;
+                  let o22 = 0;
+                  for (let e22 = 0; e22 < t42.length; e22++) o22 += t42[e22];
+                  if (0 !== o22) {
+                    const e22 = this.width / o22, s3 = this.getDashRanges(t42, this.width, e22);
+                    i22 ? this.addRoundDash(s3, e22, a22) : this.addRegularDash(s3);
+                  }
+                  const r22 = { y: (this.nextRow + a22 + 0.5) / this.height, height: 2 * a22 / this.height, width: o22 };
+                  return this.nextRow += s22, this.dirty = true, r22;
+                }
+                bind(t42) {
+                  const e22 = t42.gl;
+                  this.texture ? (e22.bindTexture(e22.TEXTURE_2D, this.texture), this.dirty && (this.dirty = false, e22.texSubImage2D(e22.TEXTURE_2D, 0, 0, 0, this.width, this.height, e22.ALPHA, e22.UNSIGNED_BYTE, this.data))) : (this.texture = e22.createTexture(), e22.bindTexture(e22.TEXTURE_2D, this.texture), e22.texParameteri(e22.TEXTURE_2D, e22.TEXTURE_WRAP_S, e22.REPEAT), e22.texParameteri(e22.TEXTURE_2D, e22.TEXTURE_WRAP_T, e22.REPEAT), e22.texParameteri(e22.TEXTURE_2D, e22.TEXTURE_MIN_FILTER, e22.LINEAR), e22.texParameteri(e22.TEXTURE_2D, e22.TEXTURE_MAG_FILTER, e22.LINEAR), e22.texImage2D(e22.TEXTURE_2D, 0, e22.ALPHA, this.width, this.height, 0, e22.ALPHA, e22.UNSIGNED_BYTE, this.data));
+                }
+              }
+              const k2 = "maplibre_preloaded_worker_pool";
+              class L2 {
+                constructor() {
+                  this.active = {};
+                }
+                acquire(t42) {
+                  if (!this.workers) for (this.workers = []; this.workers.length < L2.workerCount; ) this.workers.push(new Worker(e2.a.WORKER_URL));
+                  return this.active[t42] = true, this.workers.slice();
+                }
+                release(t42) {
+                  delete this.active[t42], 0 === this.numActive() && (this.workers.forEach((t5) => {
+                    t5.terminate();
+                  }), this.workers = null);
+                }
+                isPreloaded() {
+                  return !!this.active[k2];
+                }
+                numActive() {
+                  return Object.keys(this.active).length;
+                }
+              }
+              const F2 = Math.floor(o2.hardwareConcurrency / 2);
+              let B22, O2;
+              function N2() {
+                return B22 || (B22 = new L2()), B22;
+              }
+              L2.workerCount = e2.C(globalThis) ? Math.max(Math.min(F2, 3), 1) : 1;
+              class U2 {
+                constructor(t42, i22) {
+                  this.workerPool = t42, this.actors = [], this.currentActor = 0, this.id = i22;
+                  const a22 = this.workerPool.acquire(i22);
+                  for (let t5 = 0; t5 < a22.length; t5++) {
+                    const s22 = new e2.F(a22[t5], i22);
+                    s22.name = `Worker ${t5}`, this.actors.push(s22);
+                  }
+                  if (!this.actors.length) throw new Error("No actors found");
+                }
+                broadcast(t42, e22) {
+                  const i22 = [];
+                  for (const a22 of this.actors) i22.push(a22.sendAsync({ type: t42, data: e22 }));
+                  return Promise.all(i22);
+                }
+                getActor() {
+                  return this.currentActor = (this.currentActor + 1) % this.actors.length, this.actors[this.currentActor];
+                }
+                remove(t42 = true) {
+                  this.actors.forEach((t5) => {
+                    t5.remove();
+                  }), this.actors = [], t42 && this.workerPool.release(this.id);
+                }
+                registerMessageHandler(t42, e22) {
+                  for (const i22 of this.actors) i22.registerMessageHandler(t42, e22);
+                }
+              }
+              function j2() {
+                return O2 || (O2 = new U2(N2(), e2.G), O2.registerMessageHandler("GR", (t42, i22, a22) => e2.m(i22, a22))), O2;
+              }
+              function Z2(t42, i22) {
+                const a22 = e2.H();
+                return e2.J(a22, a22, [1, 1, 0]), e2.K(a22, a22, [0.5 * t42.width, 0.5 * t42.height, 1]), e2.L(a22, a22, t42.calculatePosMatrix(i22.toUnwrapped()));
+              }
+              function q2(t42, e22, i22, a22, s22, o22) {
+                const r22 = function(t5, e3, i3) {
+                  if (t5) for (const a3 of t5) {
+                    const t6 = e3[a3];
+                    if (t6 && t6.source === i3 && "fill-extrusion" === t6.type) return true;
+                  }
+                  else for (const t6 in e3) {
+                    const a3 = e3[t6];
+                    if (a3.source === i3 && "fill-extrusion" === a3.type) return true;
+                  }
+                  return false;
+                }(s22 && s22.layers, e22, t42.id), n22 = o22.maxPitchScaleFactor(), l22 = t42.tilesIn(a22, n22, r22);
+                l22.sort(V2);
+                const h22 = [];
+                for (const a3 of l22) h22.push({ wrappedTileID: a3.tileID.wrapped().key, queryResults: a3.tile.queryRenderedFeatures(e22, i22, t42._state, a3.queryGeometry, a3.cameraQueryGeometry, a3.scale, s22, o22, n22, Z2(t42.transform, a3.tileID)) });
+                const c22 = function(t5) {
+                  const e3 = {}, i3 = {};
+                  for (const a3 of t5) {
+                    const t6 = a3.queryResults, s3 = a3.wrappedTileID, o3 = i3[s3] = i3[s3] || {};
+                    for (const i4 in t6) {
+                      const a4 = t6[i4], s4 = o3[i4] = o3[i4] || {}, r3 = e3[i4] = e3[i4] || [];
+                      for (const t7 of a4) s4[t7.featureIndex] || (s4[t7.featureIndex] = true, r3.push(t7));
+                    }
+                  }
+                  return e3;
+                }(h22);
+                for (const e3 in c22) c22[e3].forEach((e4) => {
+                  const i3 = e4.feature, a3 = t42.getFeatureState(i3.layer["source-layer"], i3.id);
+                  i3.source = i3.layer.source, i3.layer["source-layer"] && (i3.sourceLayer = i3.layer["source-layer"]), i3.state = a3;
+                });
+                return c22;
+              }
+              function V2(t42, e22) {
+                const i22 = t42.tileID, a22 = e22.tileID;
+                return i22.overscaledZ - a22.overscaledZ || i22.canonical.y - a22.canonical.y || i22.wrap - a22.wrap || i22.canonical.x - a22.canonical.x;
+              }
+              function G2(t42, i22, a22) {
+                return e2._(this, void 0, void 0, function* () {
+                  let s22 = t42;
+                  if (t42.url ? s22 = (yield e2.h(i22.transformRequest(t42.url, "Source"), a22)).data : yield o2.frameAsync(a22), !s22) return null;
+                  const r22 = e2.M(e2.e(s22, t42), ["tiles", "minzoom", "maxzoom", "attribution", "bounds", "scheme", "tileSize", "encoding"]);
+                  return "vector_layers" in s22 && s22.vector_layers && (r22.vectorLayerIds = s22.vector_layers.map((t5) => t5.id)), r22;
+                });
+              }
+              class H2 {
+                constructor(t42, e22) {
+                  t42 && (e22 ? this.setSouthWest(t42).setNorthEast(e22) : Array.isArray(t42) && (4 === t42.length ? this.setSouthWest([t42[0], t42[1]]).setNorthEast([t42[2], t42[3]]) : this.setSouthWest(t42[0]).setNorthEast(t42[1])));
+                }
+                setNorthEast(t42) {
+                  return this._ne = t42 instanceof e2.N ? new e2.N(t42.lng, t42.lat) : e2.N.convert(t42), this;
+                }
+                setSouthWest(t42) {
+                  return this._sw = t42 instanceof e2.N ? new e2.N(t42.lng, t42.lat) : e2.N.convert(t42), this;
+                }
+                extend(t42) {
+                  const i22 = this._sw, a22 = this._ne;
+                  let s22, o22;
+                  if (t42 instanceof e2.N) s22 = t42, o22 = t42;
+                  else {
+                    if (!(t42 instanceof H2)) return Array.isArray(t42) ? 4 === t42.length || t42.every(Array.isArray) ? this.extend(H2.convert(t42)) : this.extend(e2.N.convert(t42)) : t42 && ("lng" in t42 || "lon" in t42) && "lat" in t42 ? this.extend(e2.N.convert(t42)) : this;
+                    if (s22 = t42._sw, o22 = t42._ne, !s22 || !o22) return this;
+                  }
+                  return i22 || a22 ? (i22.lng = Math.min(s22.lng, i22.lng), i22.lat = Math.min(s22.lat, i22.lat), a22.lng = Math.max(o22.lng, a22.lng), a22.lat = Math.max(o22.lat, a22.lat)) : (this._sw = new e2.N(s22.lng, s22.lat), this._ne = new e2.N(o22.lng, o22.lat)), this;
+                }
+                getCenter() {
+                  return new e2.N((this._sw.lng + this._ne.lng) / 2, (this._sw.lat + this._ne.lat) / 2);
+                }
+                getSouthWest() {
+                  return this._sw;
+                }
+                getNorthEast() {
+                  return this._ne;
+                }
+                getNorthWest() {
+                  return new e2.N(this.getWest(), this.getNorth());
+                }
+                getSouthEast() {
+                  return new e2.N(this.getEast(), this.getSouth());
+                }
+                getWest() {
+                  return this._sw.lng;
+                }
+                getSouth() {
+                  return this._sw.lat;
+                }
+                getEast() {
+                  return this._ne.lng;
+                }
+                getNorth() {
+                  return this._ne.lat;
+                }
+                toArray() {
+                  return [this._sw.toArray(), this._ne.toArray()];
+                }
+                toString() {
+                  return `LngLatBounds(${this._sw.toString()}, ${this._ne.toString()})`;
+                }
+                isEmpty() {
+                  return !(this._sw && this._ne);
+                }
+                contains(t42) {
+                  const { lng: i22, lat: a22 } = e2.N.convert(t42);
+                  let s22 = this._sw.lng <= i22 && i22 <= this._ne.lng;
+                  return this._sw.lng > this._ne.lng && (s22 = this._sw.lng >= i22 && i22 >= this._ne.lng), this._sw.lat <= a22 && a22 <= this._ne.lat && s22;
+                }
+                static convert(t42) {
+                  return t42 instanceof H2 ? t42 : t42 ? new H2(t42) : t42;
+                }
+                static fromLngLat(t42, i22 = 0) {
+                  const a22 = 360 * i22 / 40075017, s22 = a22 / Math.cos(Math.PI / 180 * t42.lat);
+                  return new H2(new e2.N(t42.lng - s22, t42.lat - a22), new e2.N(t42.lng + s22, t42.lat + a22));
+                }
+                adjustAntiMeridian() {
+                  const t42 = new e2.N(this._sw.lng, this._sw.lat), i22 = new e2.N(this._ne.lng, this._ne.lat);
+                  return new H2(t42, t42.lng > i22.lng ? new e2.N(i22.lng + 360, i22.lat) : i22);
+                }
+              }
+              class W2 {
+                constructor(t42, e22, i22) {
+                  this.bounds = H2.convert(this.validateBounds(t42)), this.minzoom = e22 || 0, this.maxzoom = i22 || 24;
+                }
+                validateBounds(t42) {
+                  return Array.isArray(t42) && 4 === t42.length ? [Math.max(-180, t42[0]), Math.max(-90, t42[1]), Math.min(180, t42[2]), Math.min(90, t42[3])] : [-180, -90, 180, 90];
+                }
+                contains(t42) {
+                  const i22 = Math.pow(2, t42.z), a22 = Math.floor(e2.O(this.bounds.getWest()) * i22), s22 = Math.floor(e2.Q(this.bounds.getNorth()) * i22), o22 = Math.ceil(e2.O(this.bounds.getEast()) * i22), r22 = Math.ceil(e2.Q(this.bounds.getSouth()) * i22);
+                  return t42.x >= a22 && t42.x < o22 && t42.y >= s22 && t42.y < r22;
+                }
+              }
+              class $2 extends e2.E {
+                constructor(t42, i22, a22, s22) {
+                  if (super(), this.id = t42, this.dispatcher = a22, this.type = "vector", this.minzoom = 0, this.maxzoom = 22, this.scheme = "xyz", this.tileSize = 512, this.reparseOverscaled = true, this.isTileClipped = true, this._loaded = false, e2.e(this, e2.M(i22, ["url", "scheme", "tileSize", "promoteId"])), this._options = e2.e({ type: "vector" }, i22), this._collectResourceTiming = i22.collectResourceTiming, 512 !== this.tileSize) throw new Error("vector tile sources must have a tileSize of 512");
+                  this.setEventedParent(s22);
+                }
+                load() {
+                  return e2._(this, void 0, void 0, function* () {
+                    this._loaded = false, this.fire(new e2.k("dataloading", { dataType: "source" })), this._tileJSONRequest = new AbortController();
+                    try {
+                      const t42 = yield G2(this._options, this.map._requestManager, this._tileJSONRequest);
+                      this._tileJSONRequest = null, this._loaded = true, this.map.style.sourceCaches[this.id].clearTiles(), t42 && (e2.e(this, t42), t42.bounds && (this.tileBounds = new W2(t42.bounds, this.minzoom, this.maxzoom)), this.fire(new e2.k("data", { dataType: "source", sourceDataType: "metadata" })), this.fire(new e2.k("data", { dataType: "source", sourceDataType: "content" })));
+                    } catch (t42) {
+                      this._tileJSONRequest = null, this.fire(new e2.j(t42));
+                    }
+                  });
+                }
+                loaded() {
+                  return this._loaded;
+                }
+                hasTile(t42) {
+                  return !this.tileBounds || this.tileBounds.contains(t42.canonical);
+                }
+                onAdd(t42) {
+                  this.map = t42, this.load();
+                }
+                setSourceProperty(t42) {
+                  this._tileJSONRequest && this._tileJSONRequest.abort(), t42(), this.load();
+                }
+                setTiles(t42) {
+                  return this.setSourceProperty(() => {
+                    this._options.tiles = t42;
+                  }), this;
+                }
+                setUrl(t42) {
+                  return this.setSourceProperty(() => {
+                    this.url = t42, this._options.url = t42;
+                  }), this;
+                }
+                onRemove() {
+                  this._tileJSONRequest && (this._tileJSONRequest.abort(), this._tileJSONRequest = null);
+                }
+                serialize() {
+                  return e2.e({}, this._options);
+                }
+                loadTile(t42) {
+                  return e2._(this, void 0, void 0, function* () {
+                    const e22 = t42.tileID.canonical.url(this.tiles, this.map.getPixelRatio(), this.scheme), i22 = { request: this.map._requestManager.transformRequest(e22, "Tile"), uid: t42.uid, tileID: t42.tileID, zoom: t42.tileID.overscaledZ, tileSize: this.tileSize * t42.tileID.overscaleFactor(), type: this.type, source: this.id, pixelRatio: this.map.getPixelRatio(), showCollisionBoxes: this.map.showCollisionBoxes, promoteId: this.promoteId };
+                    i22.request.collectResourceTiming = this._collectResourceTiming;
+                    let a22 = "RT";
+                    if (t42.actor && "expired" !== t42.state) {
+                      if ("loading" === t42.state) return new Promise((e3, i3) => {
+                        t42.reloadPromise = { resolve: e3, reject: i3 };
+                      });
+                    } else t42.actor = this.dispatcher.getActor(), a22 = "LT";
+                    t42.abortController = new AbortController();
+                    try {
+                      const e3 = yield t42.actor.sendAsync({ type: a22, data: i22 }, t42.abortController);
+                      if (delete t42.abortController, t42.aborted) return;
+                      this._afterTileLoadWorkerResponse(t42, e3);
+                    } catch (e3) {
+                      if (delete t42.abortController, t42.aborted) return;
+                      if (e3 && 404 !== e3.status) throw e3;
+                      this._afterTileLoadWorkerResponse(t42, null);
+                    }
+                  });
+                }
+                _afterTileLoadWorkerResponse(t42, e22) {
+                  if (e22 && e22.resourceTiming && (t42.resourceTiming = e22.resourceTiming), e22 && this.map._refreshExpiredTiles && t42.setExpiryData(e22), t42.loadVectorData(e22, this.map.painter), t42.reloadPromise) {
+                    const e3 = t42.reloadPromise;
+                    t42.reloadPromise = null, this.loadTile(t42).then(e3.resolve).catch(e3.reject);
+                  }
+                }
+                abortTile(t42) {
+                  return e2._(this, void 0, void 0, function* () {
+                    t42.abortController && (t42.abortController.abort(), delete t42.abortController), t42.actor && (yield t42.actor.sendAsync({ type: "AT", data: { uid: t42.uid, type: this.type, source: this.id } }));
+                  });
+                }
+                unloadTile(t42) {
+                  return e2._(this, void 0, void 0, function* () {
+                    t42.unloadVectorData(), t42.actor && (yield t42.actor.sendAsync({ type: "RMT", data: { uid: t42.uid, type: this.type, source: this.id } }));
+                  });
+                }
+                hasTransition() {
+                  return false;
+                }
+              }
+              class X2 extends e2.E {
+                constructor(t42, i22, a22, s22) {
+                  super(), this.id = t42, this.dispatcher = a22, this.setEventedParent(s22), this.type = "raster", this.minzoom = 0, this.maxzoom = 22, this.roundZoom = true, this.scheme = "xyz", this.tileSize = 512, this._loaded = false, this._options = e2.e({ type: "raster" }, i22), e2.e(this, e2.M(i22, ["url", "scheme", "tileSize"]));
+                }
+                load() {
+                  return e2._(this, void 0, void 0, function* () {
+                    this._loaded = false, this.fire(new e2.k("dataloading", { dataType: "source" })), this._tileJSONRequest = new AbortController();
+                    try {
+                      const t42 = yield G2(this._options, this.map._requestManager, this._tileJSONRequest);
+                      this._tileJSONRequest = null, this._loaded = true, t42 && (e2.e(this, t42), t42.bounds && (this.tileBounds = new W2(t42.bounds, this.minzoom, this.maxzoom)), this.fire(new e2.k("data", { dataType: "source", sourceDataType: "metadata" })), this.fire(new e2.k("data", { dataType: "source", sourceDataType: "content" })));
+                    } catch (t42) {
+                      this._tileJSONRequest = null, this.fire(new e2.j(t42));
+                    }
+                  });
+                }
+                loaded() {
+                  return this._loaded;
+                }
+                onAdd(t42) {
+                  this.map = t42, this.load();
+                }
+                onRemove() {
+                  this._tileJSONRequest && (this._tileJSONRequest.abort(), this._tileJSONRequest = null);
+                }
+                setSourceProperty(t42) {
+                  this._tileJSONRequest && (this._tileJSONRequest.abort(), this._tileJSONRequest = null), t42(), this.load();
+                }
+                setTiles(t42) {
+                  return this.setSourceProperty(() => {
+                    this._options.tiles = t42;
+                  }), this;
+                }
+                setUrl(t42) {
+                  return this.setSourceProperty(() => {
+                    this.url = t42, this._options.url = t42;
+                  }), this;
+                }
+                serialize() {
+                  return e2.e({}, this._options);
+                }
+                hasTile(t42) {
+                  return !this.tileBounds || this.tileBounds.contains(t42.canonical);
+                }
+                loadTile(t42) {
+                  return e2._(this, void 0, void 0, function* () {
+                    const e22 = t42.tileID.canonical.url(this.tiles, this.map.getPixelRatio(), this.scheme);
+                    t42.abortController = new AbortController();
+                    try {
+                      const i22 = yield _2.getImage(this.map._requestManager.transformRequest(e22, "Tile"), t42.abortController, this.map._refreshExpiredTiles);
+                      if (delete t42.abortController, t42.aborted) return void (t42.state = "unloaded");
+                      if (i22 && i22.data) {
+                        this.map._refreshExpiredTiles && i22.cacheControl && i22.expires && t42.setExpiryData({ cacheControl: i22.cacheControl, expires: i22.expires });
+                        const e3 = this.map.painter.context, a22 = e3.gl, s22 = i22.data;
+                        t42.texture = this.map.painter.getTileTexture(s22.width), t42.texture ? t42.texture.update(s22, { useMipmap: true }) : (t42.texture = new b2(e3, s22, a22.RGBA, { useMipmap: true }), t42.texture.bind(a22.LINEAR, a22.CLAMP_TO_EDGE, a22.LINEAR_MIPMAP_NEAREST)), t42.state = "loaded";
+                      }
+                    } catch (e3) {
+                      if (delete t42.abortController, t42.aborted) t42.state = "unloaded";
+                      else if (e3) throw t42.state = "errored", e3;
+                    }
+                  });
+                }
+                abortTile(t42) {
+                  return e2._(this, void 0, void 0, function* () {
+                    t42.abortController && (t42.abortController.abort(), delete t42.abortController);
+                  });
+                }
+                unloadTile(t42) {
+                  return e2._(this, void 0, void 0, function* () {
+                    t42.texture && this.map.painter.saveTileTexture(t42.texture);
+                  });
+                }
+                hasTransition() {
+                  return false;
+                }
+              }
+              class K22 extends X2 {
+                constructor(t42, i22, a22, s22) {
+                  super(t42, i22, a22, s22), this.type = "raster-dem", this.maxzoom = 22, this._options = e2.e({ type: "raster-dem" }, i22), this.encoding = i22.encoding || "mapbox", this.redFactor = i22.redFactor, this.greenFactor = i22.greenFactor, this.blueFactor = i22.blueFactor, this.baseShift = i22.baseShift;
+                }
+                loadTile(t42) {
+                  return e2._(this, void 0, void 0, function* () {
+                    const i22 = t42.tileID.canonical.url(this.tiles, this.map.getPixelRatio(), this.scheme), a22 = this.map._requestManager.transformRequest(i22, "Tile");
+                    t42.neighboringTiles = this._getNeighboringTiles(t42.tileID), t42.abortController = new AbortController();
+                    try {
+                      const i3 = yield _2.getImage(a22, t42.abortController, this.map._refreshExpiredTiles);
+                      if (delete t42.abortController, t42.aborted) return void (t42.state = "unloaded");
+                      if (i3 && i3.data) {
+                        const a3 = i3.data;
+                        this.map._refreshExpiredTiles && i3.cacheControl && i3.expires && t42.setExpiryData({ cacheControl: i3.cacheControl, expires: i3.expires });
+                        const s22 = e2.b(a3) && e2.U() ? a3 : yield this.readImageNow(a3), o22 = { type: this.type, uid: t42.uid, source: this.id, rawImageData: s22, encoding: this.encoding, redFactor: this.redFactor, greenFactor: this.greenFactor, blueFactor: this.blueFactor, baseShift: this.baseShift };
+                        if (!t42.actor || "expired" === t42.state) {
+                          t42.actor = this.dispatcher.getActor();
+                          const e22 = yield t42.actor.sendAsync({ type: "LDT", data: o22 });
+                          t42.dem = e22, t42.needsHillshadePrepare = true, t42.needsTerrainPrepare = true, t42.state = "loaded";
+                        }
+                      }
+                    } catch (e22) {
+                      if (delete t42.abortController, t42.aborted) t42.state = "unloaded";
+                      else if (e22) throw t42.state = "errored", e22;
+                    }
+                  });
+                }
+                readImageNow(t42) {
+                  return e2._(this, void 0, void 0, function* () {
+                    if ("undefined" != typeof VideoFrame && e2.V()) {
+                      const i22 = t42.width + 2, a22 = t42.height + 2;
+                      try {
+                        return new e2.R({ width: i22, height: a22 }, yield e2.W(t42, -1, -1, i22, a22));
+                      } catch (t5) {
+                      }
+                    }
+                    return o2.getImageData(t42, 1);
+                  });
+                }
+                _getNeighboringTiles(t42) {
+                  const i22 = t42.canonical, a22 = Math.pow(2, i22.z), s22 = (i22.x - 1 + a22) % a22, o22 = 0 === i22.x ? t42.wrap - 1 : t42.wrap, r22 = (i22.x + 1 + a22) % a22, n22 = i22.x + 1 === a22 ? t42.wrap + 1 : t42.wrap, l22 = {};
+                  return l22[new e2.S(t42.overscaledZ, o22, i22.z, s22, i22.y).key] = { backfilled: false }, l22[new e2.S(t42.overscaledZ, n22, i22.z, r22, i22.y).key] = { backfilled: false }, i22.y > 0 && (l22[new e2.S(t42.overscaledZ, o22, i22.z, s22, i22.y - 1).key] = { backfilled: false }, l22[new e2.S(t42.overscaledZ, t42.wrap, i22.z, i22.x, i22.y - 1).key] = { backfilled: false }, l22[new e2.S(t42.overscaledZ, n22, i22.z, r22, i22.y - 1).key] = { backfilled: false }), i22.y + 1 < a22 && (l22[new e2.S(t42.overscaledZ, o22, i22.z, s22, i22.y + 1).key] = { backfilled: false }, l22[new e2.S(t42.overscaledZ, t42.wrap, i22.z, i22.x, i22.y + 1).key] = { backfilled: false }, l22[new e2.S(t42.overscaledZ, n22, i22.z, r22, i22.y + 1).key] = { backfilled: false }), l22;
+                }
+                unloadTile(t42) {
+                  return e2._(this, void 0, void 0, function* () {
+                    t42.demTexture && this.map.painter.saveTileTexture(t42.demTexture), t42.fbo && (t42.fbo.destroy(), delete t42.fbo), t42.dem && delete t42.dem, delete t42.neighboringTiles, t42.state = "unloaded", t42.actor && (yield t42.actor.sendAsync({ type: "RDT", data: { type: this.type, uid: t42.uid, source: this.id } }));
+                  });
+                }
+              }
+              class J2 extends e2.E {
+                constructor(t42, i22, a22, s22) {
+                  super(), this.id = t42, this.type = "geojson", this.minzoom = 0, this.maxzoom = 18, this.tileSize = 512, this.isTileClipped = true, this.reparseOverscaled = true, this._removed = false, this._pendingLoads = 0, this.actor = a22.getActor(), this.setEventedParent(s22), this._data = i22.data, this._options = e2.e({}, i22), this._collectResourceTiming = i22.collectResourceTiming, void 0 !== i22.maxzoom && (this.maxzoom = i22.maxzoom), i22.type && (this.type = i22.type), i22.attribution && (this.attribution = i22.attribution), this.promoteId = i22.promoteId;
+                  const o22 = e2.X / this.tileSize;
+                  void 0 !== i22.clusterMaxZoom && this.maxzoom <= i22.clusterMaxZoom && e2.w(`The maxzoom value "${this.maxzoom}" is expected to be greater than the clusterMaxZoom value "${i22.clusterMaxZoom}".`), this.workerOptions = e2.e({ source: this.id, cluster: i22.cluster || false, geojsonVtOptions: { buffer: (void 0 !== i22.buffer ? i22.buffer : 128) * o22, tolerance: (void 0 !== i22.tolerance ? i22.tolerance : 0.375) * o22, extent: e2.X, maxZoom: this.maxzoom, lineMetrics: i22.lineMetrics || false, generateId: i22.generateId || false }, superclusterOptions: { maxZoom: void 0 !== i22.clusterMaxZoom ? i22.clusterMaxZoom : this.maxzoom - 1, minPoints: Math.max(2, i22.clusterMinPoints || 2), extent: e2.X, radius: (i22.clusterRadius || 50) * o22, log: false, generateId: i22.generateId || false }, clusterProperties: i22.clusterProperties, filter: i22.filter }, i22.workerOptions), "string" == typeof this.promoteId && (this.workerOptions.promoteId = this.promoteId);
+                }
+                load() {
+                  return e2._(this, void 0, void 0, function* () {
+                    yield this._updateWorkerData();
+                  });
+                }
+                onAdd(t42) {
+                  this.map = t42, this.load();
+                }
+                setData(t42) {
+                  return this._data = t42, this._updateWorkerData(), this;
+                }
+                updateData(t42) {
+                  return this._updateWorkerData(t42), this;
+                }
+                getData() {
+                  return e2._(this, void 0, void 0, function* () {
+                    const t42 = e2.e({ type: this.type }, this.workerOptions);
+                    return this.actor.sendAsync({ type: "GD", data: t42 });
+                  });
+                }
+                setClusterOptions(t42) {
+                  return this.workerOptions.cluster = t42.cluster, t42 && (void 0 !== t42.clusterRadius && (this.workerOptions.superclusterOptions.radius = t42.clusterRadius), void 0 !== t42.clusterMaxZoom && (this.workerOptions.superclusterOptions.maxZoom = t42.clusterMaxZoom)), this._updateWorkerData(), this;
+                }
+                getClusterExpansionZoom(t42) {
+                  return this.actor.sendAsync({ type: "GCEZ", data: { type: this.type, clusterId: t42, source: this.id } });
+                }
+                getClusterChildren(t42) {
+                  return this.actor.sendAsync({ type: "GCC", data: { type: this.type, clusterId: t42, source: this.id } });
+                }
+                getClusterLeaves(t42, e22, i22) {
+                  return this.actor.sendAsync({ type: "GCL", data: { type: this.type, source: this.id, clusterId: t42, limit: e22, offset: i22 } });
+                }
+                _updateWorkerData(t42) {
+                  return e2._(this, void 0, void 0, function* () {
+                    const i22 = e2.e({ type: this.type }, this.workerOptions);
+                    t42 ? i22.dataDiff = t42 : "string" == typeof this._data ? (i22.request = this.map._requestManager.transformRequest(o2.resolveURL(this._data), "Source"), i22.request.collectResourceTiming = this._collectResourceTiming) : i22.data = JSON.stringify(this._data), this._pendingLoads++, this.fire(new e2.k("dataloading", { dataType: "source" }));
+                    try {
+                      const t5 = yield this.actor.sendAsync({ type: "LD", data: i22 });
+                      if (this._pendingLoads--, this._removed || t5.abandoned) return void this.fire(new e2.k("dataabort", { dataType: "source" }));
+                      let a22 = null;
+                      t5.resourceTiming && t5.resourceTiming[this.id] && (a22 = t5.resourceTiming[this.id].slice(0));
+                      const s22 = { dataType: "source" };
+                      this._collectResourceTiming && a22 && a22.length > 0 && e2.e(s22, { resourceTiming: a22 }), this.fire(new e2.k("data", Object.assign(Object.assign({}, s22), { sourceDataType: "metadata" }))), this.fire(new e2.k("data", Object.assign(Object.assign({}, s22), { sourceDataType: "content" })));
+                    } catch (t5) {
+                      if (this._pendingLoads--, this._removed) return void this.fire(new e2.k("dataabort", { dataType: "source" }));
+                      this.fire(new e2.j(t5));
+                    }
+                  });
+                }
+                loaded() {
+                  return 0 === this._pendingLoads;
+                }
+                loadTile(t42) {
+                  return e2._(this, void 0, void 0, function* () {
+                    const e22 = t42.actor ? "RT" : "LT";
+                    t42.actor = this.actor;
+                    const i22 = { type: this.type, uid: t42.uid, tileID: t42.tileID, zoom: t42.tileID.overscaledZ, maxZoom: this.maxzoom, tileSize: this.tileSize, source: this.id, pixelRatio: this.map.getPixelRatio(), showCollisionBoxes: this.map.showCollisionBoxes, promoteId: this.promoteId };
+                    t42.abortController = new AbortController();
+                    const a22 = yield this.actor.sendAsync({ type: e22, data: i22 }, t42.abortController);
+                    delete t42.abortController, t42.unloadVectorData(), t42.aborted || t42.loadVectorData(a22, this.map.painter, "RT" === e22);
+                  });
+                }
+                abortTile(t42) {
+                  return e2._(this, void 0, void 0, function* () {
+                    t42.abortController && (t42.abortController.abort(), delete t42.abortController), t42.aborted = true;
+                  });
+                }
+                unloadTile(t42) {
+                  return e2._(this, void 0, void 0, function* () {
+                    t42.unloadVectorData(), yield this.actor.sendAsync({ type: "RMT", data: { uid: t42.uid, type: this.type, source: this.id } });
+                  });
+                }
+                onRemove() {
+                  this._removed = true, this.actor.sendAsync({ type: "RS", data: { type: this.type, source: this.id } });
+                }
+                serialize() {
+                  return e2.e({}, this._options, { type: this.type, data: this._data });
+                }
+                hasTransition() {
+                  return false;
+                }
+              }
+              var Y2 = e2.Y([{ name: "a_pos", type: "Int16", components: 2 }, { name: "a_texture_pos", type: "Int16", components: 2 }]);
+              class Q2 extends e2.E {
+                constructor(t42, e22, i22, a22) {
+                  super(), this.id = t42, this.dispatcher = i22, this.coordinates = e22.coordinates, this.type = "image", this.minzoom = 0, this.maxzoom = 22, this.tileSize = 512, this.tiles = {}, this._loaded = false, this.setEventedParent(a22), this.options = e22;
+                }
+                load(t42) {
+                  return e2._(this, void 0, void 0, function* () {
+                    this._loaded = false, this.fire(new e2.k("dataloading", { dataType: "source" })), this.url = this.options.url, this._request = new AbortController();
+                    try {
+                      const e22 = yield _2.getImage(this.map._requestManager.transformRequest(this.url, "Image"), this._request);
+                      this._request = null, this._loaded = true, e22 && e22.data && (this.image = e22.data, t42 && (this.coordinates = t42), this._finishLoading());
+                    } catch (t5) {
+                      this._request = null, this._loaded = true, this.fire(new e2.j(t5));
+                    }
+                  });
+                }
+                loaded() {
+                  return this._loaded;
+                }
+                updateImage(t42) {
+                  return t42.url ? (this._request && (this._request.abort(), this._request = null), this.options.url = t42.url, this.load(t42.coordinates).finally(() => {
+                    this.texture = null;
+                  }), this) : this;
+                }
+                _finishLoading() {
+                  this.map && (this.setCoordinates(this.coordinates), this.fire(new e2.k("data", { dataType: "source", sourceDataType: "metadata" })));
+                }
+                onAdd(t42) {
+                  this.map = t42, this.load();
+                }
+                onRemove() {
+                  this._request && (this._request.abort(), this._request = null);
+                }
+                setCoordinates(t42) {
+                  this.coordinates = t42;
+                  const i22 = t42.map(e2.Z.fromLngLat);
+                  this.tileID = function(t5) {
+                    let i3 = 1 / 0, a3 = 1 / 0, s22 = -1 / 0, o22 = -1 / 0;
+                    for (const e22 of t5) i3 = Math.min(i3, e22.x), a3 = Math.min(a3, e22.y), s22 = Math.max(s22, e22.x), o22 = Math.max(o22, e22.y);
+                    const r22 = Math.max(s22 - i3, o22 - a3), n22 = Math.max(0, Math.floor(-Math.log(r22) / Math.LN2)), l22 = Math.pow(2, n22);
+                    return new e2.a1(n22, Math.floor((i3 + s22) / 2 * l22), Math.floor((a3 + o22) / 2 * l22));
+                  }(i22), this.minzoom = this.maxzoom = this.tileID.z;
+                  const a22 = i22.map((t5) => this.tileID.getTilePoint(t5)._round());
+                  return this._boundsArray = new e2.$(), this._boundsArray.emplaceBack(a22[0].x, a22[0].y, 0, 0), this._boundsArray.emplaceBack(a22[1].x, a22[1].y, e2.X, 0), this._boundsArray.emplaceBack(a22[3].x, a22[3].y, 0, e2.X), this._boundsArray.emplaceBack(a22[2].x, a22[2].y, e2.X, e2.X), this.boundsBuffer && (this.boundsBuffer.destroy(), delete this.boundsBuffer), this.fire(new e2.k("data", { dataType: "source", sourceDataType: "content" })), this;
+                }
+                prepare() {
+                  if (0 === Object.keys(this.tiles).length || !this.image) return;
+                  const t42 = this.map.painter.context, i22 = t42.gl;
+                  this.boundsBuffer || (this.boundsBuffer = t42.createVertexBuffer(this._boundsArray, Y2.members)), this.boundsSegments || (this.boundsSegments = e2.a0.simpleSegment(0, 0, 4, 2)), this.texture || (this.texture = new b2(t42, this.image, i22.RGBA), this.texture.bind(i22.LINEAR, i22.CLAMP_TO_EDGE));
+                  let a22 = false;
+                  for (const t5 in this.tiles) {
+                    const e22 = this.tiles[t5];
+                    "loaded" !== e22.state && (e22.state = "loaded", e22.texture = this.texture, a22 = true);
+                  }
+                  a22 && this.fire(new e2.k("data", { dataType: "source", sourceDataType: "idle", sourceId: this.id }));
+                }
+                loadTile(t42) {
+                  return e2._(this, void 0, void 0, function* () {
+                    this.tileID && this.tileID.equals(t42.tileID.canonical) ? (this.tiles[String(t42.tileID.wrap)] = t42, t42.buckets = {}) : t42.state = "errored";
+                  });
+                }
+                serialize() {
+                  return { type: "image", url: this.options.url, coordinates: this.coordinates };
+                }
+                hasTransition() {
+                  return false;
+                }
+              }
+              class tt2 extends Q2 {
+                constructor(t42, e22, i22, a22) {
+                  super(t42, e22, i22, a22), this.roundZoom = true, this.type = "video", this.options = e22;
+                }
+                load() {
+                  return e2._(this, void 0, void 0, function* () {
+                    this._loaded = false;
+                    const t42 = this.options;
+                    this.urls = [];
+                    for (const e22 of t42.urls) this.urls.push(this.map._requestManager.transformRequest(e22, "Source").url);
+                    try {
+                      const t5 = yield e2.a3(this.urls);
+                      if (this._loaded = true, !t5) return;
+                      this.video = t5, this.video.loop = true, this.video.addEventListener("playing", () => {
+                        this.map.triggerRepaint();
+                      }), this.map && this.video.play(), this._finishLoading();
+                    } catch (t5) {
+                      this.fire(new e2.j(t5));
+                    }
+                  });
+                }
+                pause() {
+                  this.video && this.video.pause();
+                }
+                play() {
+                  this.video && this.video.play();
+                }
+                seek(t42) {
+                  if (this.video) {
+                    const i22 = this.video.seekable;
+                    t42 < i22.start(0) || t42 > i22.end(0) ? this.fire(new e2.j(new e2.a2(`sources.${this.id}`, null, `Playback for this video can be set only between the ${i22.start(0)} and ${i22.end(0)}-second mark.`))) : this.video.currentTime = t42;
+                  }
+                }
+                getVideo() {
+                  return this.video;
+                }
+                onAdd(t42) {
+                  this.map || (this.map = t42, this.load(), this.video && (this.video.play(), this.setCoordinates(this.coordinates)));
+                }
+                prepare() {
+                  if (0 === Object.keys(this.tiles).length || this.video.readyState < 2) return;
+                  const t42 = this.map.painter.context, i22 = t42.gl;
+                  this.boundsBuffer || (this.boundsBuffer = t42.createVertexBuffer(this._boundsArray, Y2.members)), this.boundsSegments || (this.boundsSegments = e2.a0.simpleSegment(0, 0, 4, 2)), this.texture ? this.video.paused || (this.texture.bind(i22.LINEAR, i22.CLAMP_TO_EDGE), i22.texSubImage2D(i22.TEXTURE_2D, 0, 0, 0, i22.RGBA, i22.UNSIGNED_BYTE, this.video)) : (this.texture = new b2(t42, this.video, i22.RGBA), this.texture.bind(i22.LINEAR, i22.CLAMP_TO_EDGE));
+                  let a22 = false;
+                  for (const t5 in this.tiles) {
+                    const e22 = this.tiles[t5];
+                    "loaded" !== e22.state && (e22.state = "loaded", e22.texture = this.texture, a22 = true);
+                  }
+                  a22 && this.fire(new e2.k("data", { dataType: "source", sourceDataType: "idle", sourceId: this.id }));
+                }
+                serialize() {
+                  return { type: "video", urls: this.urls, coordinates: this.coordinates };
+                }
+                hasTransition() {
+                  return this.video && !this.video.paused;
+                }
+              }
+              class et2 extends Q2 {
+                constructor(t42, i22, a22, s22) {
+                  super(t42, i22, a22, s22), i22.coordinates ? Array.isArray(i22.coordinates) && 4 === i22.coordinates.length && !i22.coordinates.some((t5) => !Array.isArray(t5) || 2 !== t5.length || t5.some((t6) => "number" != typeof t6)) || this.fire(new e2.j(new e2.a2(`sources.${t42}`, null, '"coordinates" property must be an array of 4 longitude/latitude array pairs'))) : this.fire(new e2.j(new e2.a2(`sources.${t42}`, null, 'missing required property "coordinates"'))), i22.animate && "boolean" != typeof i22.animate && this.fire(new e2.j(new e2.a2(`sources.${t42}`, null, 'optional "animate" property must be a boolean value'))), i22.canvas ? "string" == typeof i22.canvas || i22.canvas instanceof HTMLCanvasElement || this.fire(new e2.j(new e2.a2(`sources.${t42}`, null, '"canvas" must be either a string representing the ID of the canvas element from which to read, or an HTMLCanvasElement instance'))) : this.fire(new e2.j(new e2.a2(`sources.${t42}`, null, 'missing required property "canvas"'))), this.options = i22, this.animate = void 0 === i22.animate || i22.animate;
+                }
+                load() {
+                  return e2._(this, void 0, void 0, function* () {
+                    this._loaded = true, this.canvas || (this.canvas = this.options.canvas instanceof HTMLCanvasElement ? this.options.canvas : document.getElementById(this.options.canvas)), this.width = this.canvas.width, this.height = this.canvas.height, this._hasInvalidDimensions() ? this.fire(new e2.j(new Error("Canvas dimensions cannot be less than or equal to zero."))) : (this.play = function() {
+                      this._playing = true, this.map.triggerRepaint();
+                    }, this.pause = function() {
+                      this._playing && (this.prepare(), this._playing = false);
+                    }, this._finishLoading());
+                  });
+                }
+                getCanvas() {
+                  return this.canvas;
+                }
+                onAdd(t42) {
+                  this.map = t42, this.load(), this.canvas && this.animate && this.play();
+                }
+                onRemove() {
+                  this.pause();
+                }
+                prepare() {
+                  let t42 = false;
+                  if (this.canvas.width !== this.width && (this.width = this.canvas.width, t42 = true), this.canvas.height !== this.height && (this.height = this.canvas.height, t42 = true), this._hasInvalidDimensions()) return;
+                  if (0 === Object.keys(this.tiles).length) return;
+                  const i22 = this.map.painter.context, a22 = i22.gl;
+                  this.boundsBuffer || (this.boundsBuffer = i22.createVertexBuffer(this._boundsArray, Y2.members)), this.boundsSegments || (this.boundsSegments = e2.a0.simpleSegment(0, 0, 4, 2)), this.texture ? (t42 || this._playing) && this.texture.update(this.canvas, { premultiply: true }) : this.texture = new b2(i22, this.canvas, a22.RGBA, { premultiply: true });
+                  let s22 = false;
+                  for (const t5 in this.tiles) {
+                    const e22 = this.tiles[t5];
+                    "loaded" !== e22.state && (e22.state = "loaded", e22.texture = this.texture, s22 = true);
+                  }
+                  s22 && this.fire(new e2.k("data", { dataType: "source", sourceDataType: "idle", sourceId: this.id }));
+                }
+                serialize() {
+                  return { type: "canvas", coordinates: this.coordinates };
+                }
+                hasTransition() {
+                  return this._playing;
+                }
+                _hasInvalidDimensions() {
+                  for (const t42 of [this.canvas.width, this.canvas.height]) if (isNaN(t42) || t42 <= 0) return true;
+                  return false;
+                }
+              }
+              const it2 = {}, at2 = (t42) => {
+                switch (t42) {
+                  case "geojson":
+                    return J2;
+                  case "image":
+                    return Q2;
+                  case "raster":
+                    return X2;
+                  case "raster-dem":
+                    return K22;
+                  case "vector":
+                    return $2;
+                  case "video":
+                    return tt2;
+                  case "canvas":
+                    return et2;
+                }
+                return it2[t42];
+              }, st2 = "RTLPluginLoaded";
+              class ot2 extends e2.E {
+                constructor() {
+                  super(...arguments), this.status = "unavailable", this.url = null, this.dispatcher = j2();
+                }
+                _syncState(t42) {
+                  return this.status = t42, this.dispatcher.broadcast("SRPS", { pluginStatus: t42, pluginURL: this.url }).catch((t5) => {
+                    throw this.status = "error", t5;
+                  });
+                }
+                getRTLTextPluginStatus() {
+                  return this.status;
+                }
+                clearRTLTextPlugin() {
+                  this.status = "unavailable", this.url = null;
+                }
+                setRTLTextPlugin(t42) {
+                  return e2._(this, arguments, void 0, function* (t5, e22 = false) {
+                    if (this.url) throw new Error("setRTLTextPlugin cannot be called multiple times.");
+                    if (this.url = o2.resolveURL(t5), !this.url) throw new Error(`requested url ${t5} is invalid`);
+                    if ("unavailable" === this.status) {
+                      if (!e22) return this._requestImport();
+                      this.status = "deferred", this._syncState(this.status);
+                    } else if ("requested" === this.status) return this._requestImport();
+                  });
+                }
+                _requestImport() {
+                  return e2._(this, void 0, void 0, function* () {
+                    yield this._syncState("loading"), this.status = "loaded", this.fire(new e2.k(st2));
+                  });
+                }
+                lazyLoad() {
+                  "unavailable" === this.status ? this.status = "requested" : "deferred" === this.status && this._requestImport();
+                }
+              }
+              let rt2 = null;
+              function nt2() {
+                return rt2 || (rt2 = new ot2()), rt2;
+              }
+              class lt2 {
+                constructor(t42, i22) {
+                  this.timeAdded = 0, this.fadeEndTime = 0, this.tileID = t42, this.uid = e2.a4(), this.uses = 0, this.tileSize = i22, this.buckets = {}, this.expirationTime = null, this.queryPadding = 0, this.hasSymbolBuckets = false, this.hasRTLText = false, this.dependencies = {}, this.rtt = [], this.rttCoords = {}, this.expiredRequestCount = 0, this.state = "loading";
+                }
+                registerFadeDuration(t42) {
+                  const e22 = t42 + this.timeAdded;
+                  e22 < this.fadeEndTime || (this.fadeEndTime = e22);
+                }
+                wasRequested() {
+                  return "errored" === this.state || "loaded" === this.state || "reloading" === this.state;
+                }
+                clearTextures(t42) {
+                  this.demTexture && t42.saveTileTexture(this.demTexture), this.demTexture = null;
+                }
+                loadVectorData(t42, i22, a22) {
+                  if (this.hasData() && this.unloadVectorData(), this.state = "loaded", t42) {
+                    t42.featureIndex && (this.latestFeatureIndex = t42.featureIndex, t42.rawTileData ? (this.latestRawTileData = t42.rawTileData, this.latestFeatureIndex.rawTileData = t42.rawTileData) : this.latestRawTileData && (this.latestFeatureIndex.rawTileData = this.latestRawTileData)), this.collisionBoxArray = t42.collisionBoxArray, this.buckets = function(t5, e22) {
+                      const i3 = {};
+                      if (!e22) return i3;
+                      for (const a3 of t5) {
+                        const t6 = a3.layerIds.map((t7) => e22.getLayer(t7)).filter(Boolean);
+                        if (0 !== t6.length) {
+                          a3.layers = t6, a3.stateDependentLayerIds && (a3.stateDependentLayers = a3.stateDependentLayerIds.map((e3) => t6.filter((t7) => t7.id === e3)[0]));
+                          for (const e3 of t6) i3[e3.id] = a3;
+                        }
+                      }
+                      return i3;
+                    }(t42.buckets, i22.style), this.hasSymbolBuckets = false;
+                    for (const t5 in this.buckets) {
+                      const i3 = this.buckets[t5];
+                      if (i3 instanceof e2.a6) {
+                        if (this.hasSymbolBuckets = true, !a22) break;
+                        i3.justReloaded = true;
+                      }
+                    }
+                    if (this.hasRTLText = false, this.hasSymbolBuckets) for (const t5 in this.buckets) {
+                      const i3 = this.buckets[t5];
+                      if (i3 instanceof e2.a6 && i3.hasRTLText) {
+                        this.hasRTLText = true, nt2().lazyLoad();
+                        break;
+                      }
+                    }
+                    this.queryPadding = 0;
+                    for (const t5 in this.buckets) {
+                      const e22 = this.buckets[t5];
+                      this.queryPadding = Math.max(this.queryPadding, i22.style.getLayer(t5).queryRadius(e22));
+                    }
+                    t42.imageAtlas && (this.imageAtlas = t42.imageAtlas), t42.glyphAtlasImage && (this.glyphAtlasImage = t42.glyphAtlasImage);
+                  } else this.collisionBoxArray = new e2.a5();
+                }
+                unloadVectorData() {
+                  for (const t42 in this.buckets) this.buckets[t42].destroy();
+                  this.buckets = {}, this.imageAtlasTexture && this.imageAtlasTexture.destroy(), this.imageAtlas && (this.imageAtlas = null), this.glyphAtlasTexture && this.glyphAtlasTexture.destroy(), this.latestFeatureIndex = null, this.state = "unloaded";
+                }
+                getBucket(t42) {
+                  return this.buckets[t42.id];
+                }
+                upload(t42) {
+                  for (const e3 in this.buckets) {
+                    const i22 = this.buckets[e3];
+                    i22.uploadPending() && i22.upload(t42);
+                  }
+                  const e22 = t42.gl;
+                  this.imageAtlas && !this.imageAtlas.uploaded && (this.imageAtlasTexture = new b2(t42, this.imageAtlas.image, e22.RGBA), this.imageAtlas.uploaded = true), this.glyphAtlasImage && (this.glyphAtlasTexture = new b2(t42, this.glyphAtlasImage, e22.ALPHA), this.glyphAtlasImage = null);
+                }
+                prepare(t42) {
+                  this.imageAtlas && this.imageAtlas.patchUpdatedImages(t42, this.imageAtlasTexture);
+                }
+                queryRenderedFeatures(t42, e22, i22, a22, s22, o22, r22, n22, l22, h22) {
+                  return this.latestFeatureIndex && this.latestFeatureIndex.rawTileData ? this.latestFeatureIndex.query({ queryGeometry: a22, cameraQueryGeometry: s22, scale: o22, tileSize: this.tileSize, pixelPosMatrix: h22, transform: n22, params: r22, queryPadding: this.queryPadding * l22 }, t42, e22, i22) : {};
+                }
+                querySourceFeatures(t42, i22) {
+                  const a22 = this.latestFeatureIndex;
+                  if (!a22 || !a22.rawTileData) return;
+                  const s22 = a22.loadVTLayers(), o22 = i22 && i22.sourceLayer ? i22.sourceLayer : "", r22 = s22._geojsonTileLayer || s22[o22];
+                  if (!r22) return;
+                  const n22 = e2.a7(i22 && i22.filter), { z: l22, x: h22, y: c22 } = this.tileID.canonical, u22 = { z: l22, x: h22, y: c22 };
+                  for (let i3 = 0; i3 < r22.length; i3++) {
+                    const s3 = r22.feature(i3);
+                    if (n22.needGeometry) {
+                      const t5 = e2.a8(s3, true);
+                      if (!n22.filter(new e2.z(this.tileID.overscaledZ), t5, this.tileID.canonical)) continue;
+                    } else if (!n22.filter(new e2.z(this.tileID.overscaledZ), s3)) continue;
+                    const d22 = a22.getId(s3, o22), _22 = new e2.a9(s3, l22, h22, c22, d22);
+                    _22.tile = u22, t42.push(_22);
+                  }
+                }
+                hasData() {
+                  return "loaded" === this.state || "reloading" === this.state || "expired" === this.state;
+                }
+                patternsLoaded() {
+                  return this.imageAtlas && !!Object.keys(this.imageAtlas.patternPositions).length;
+                }
+                setExpiryData(t42) {
+                  const i22 = this.expirationTime;
+                  if (t42.cacheControl) {
+                    const i3 = e2.aa(t42.cacheControl);
+                    i3["max-age"] && (this.expirationTime = Date.now() + 1e3 * i3["max-age"]);
+                  } else t42.expires && (this.expirationTime = new Date(t42.expires).getTime());
+                  if (this.expirationTime) {
+                    const t5 = Date.now();
+                    let e22 = false;
+                    if (this.expirationTime > t5) e22 = false;
+                    else if (i22) if (this.expirationTime < i22) e22 = true;
+                    else {
+                      const a22 = this.expirationTime - i22;
+                      a22 ? this.expirationTime = t5 + Math.max(a22, 3e4) : e22 = true;
+                    }
+                    else e22 = true;
+                    e22 ? (this.expiredRequestCount++, this.state = "expired") : this.expiredRequestCount = 0;
+                  }
+                }
+                getExpiryTimeout() {
+                  if (this.expirationTime) return this.expiredRequestCount ? 1e3 * (1 << Math.min(this.expiredRequestCount - 1, 31)) : Math.min(this.expirationTime - (/* @__PURE__ */ new Date()).getTime(), Math.pow(2, 31) - 1);
+                }
+                setFeatureState(t42, e22) {
+                  if (!this.latestFeatureIndex || !this.latestFeatureIndex.rawTileData || 0 === Object.keys(t42).length) return;
+                  const i22 = this.latestFeatureIndex.loadVTLayers();
+                  for (const a22 in this.buckets) {
+                    if (!e22.style.hasLayer(a22)) continue;
+                    const s22 = this.buckets[a22], o22 = s22.layers[0].sourceLayer || "_geojsonTileLayer", r22 = i22[o22], n22 = t42[o22];
+                    if (!r22 || !n22 || 0 === Object.keys(n22).length) continue;
+                    s22.update(n22, r22, this.imageAtlas && this.imageAtlas.patternPositions || {});
+                    const l22 = e22 && e22.style && e22.style.getLayer(a22);
+                    l22 && (this.queryPadding = Math.max(this.queryPadding, l22.queryRadius(s22)));
+                  }
+                }
+                holdingForFade() {
+                  return void 0 !== this.symbolFadeHoldUntil;
+                }
+                symbolFadeFinished() {
+                  return !this.symbolFadeHoldUntil || this.symbolFadeHoldUntil < o2.now();
+                }
+                clearFadeHold() {
+                  this.symbolFadeHoldUntil = void 0;
+                }
+                setHoldDuration(t42) {
+                  this.symbolFadeHoldUntil = o2.now() + t42;
+                }
+                setDependencies(t42, e22) {
+                  const i22 = {};
+                  for (const t5 of e22) i22[t5] = true;
+                  this.dependencies[t42] = i22;
+                }
+                hasDependency(t42, e22) {
+                  for (const i22 of t42) {
+                    const t5 = this.dependencies[i22];
+                    if (t5) {
+                      for (const i3 of e22) if (t5[i3]) return true;
+                    }
+                  }
+                  return false;
+                }
+              }
+              class ht2 {
+                constructor(t42, e22) {
+                  this.max = t42, this.onRemove = e22, this.reset();
+                }
+                reset() {
+                  for (const t42 in this.data) for (const e22 of this.data[t42]) e22.timeout && clearTimeout(e22.timeout), this.onRemove(e22.value);
+                  return this.data = {}, this.order = [], this;
+                }
+                add(t42, e22, i22) {
+                  const a22 = t42.wrapped().key;
+                  void 0 === this.data[a22] && (this.data[a22] = []);
+                  const s22 = { value: e22, timeout: void 0 };
+                  if (void 0 !== i22 && (s22.timeout = setTimeout(() => {
+                    this.remove(t42, s22);
+                  }, i22)), this.data[a22].push(s22), this.order.push(a22), this.order.length > this.max) {
+                    const t5 = this._getAndRemoveByKey(this.order[0]);
+                    t5 && this.onRemove(t5);
+                  }
+                  return this;
+                }
+                has(t42) {
+                  return t42.wrapped().key in this.data;
+                }
+                getAndRemove(t42) {
+                  return this.has(t42) ? this._getAndRemoveByKey(t42.wrapped().key) : null;
+                }
+                _getAndRemoveByKey(t42) {
+                  const e22 = this.data[t42].shift();
+                  return e22.timeout && clearTimeout(e22.timeout), 0 === this.data[t42].length && delete this.data[t42], this.order.splice(this.order.indexOf(t42), 1), e22.value;
+                }
+                getByKey(t42) {
+                  const e22 = this.data[t42];
+                  return e22 ? e22[0].value : null;
+                }
+                get(t42) {
+                  return this.has(t42) ? this.data[t42.wrapped().key][0].value : null;
+                }
+                remove(t42, e22) {
+                  if (!this.has(t42)) return this;
+                  const i22 = t42.wrapped().key, a22 = void 0 === e22 ? 0 : this.data[i22].indexOf(e22), s22 = this.data[i22][a22];
+                  return this.data[i22].splice(a22, 1), s22.timeout && clearTimeout(s22.timeout), 0 === this.data[i22].length && delete this.data[i22], this.onRemove(s22.value), this.order.splice(this.order.indexOf(i22), 1), this;
+                }
+                setMaxSize(t42) {
+                  for (this.max = t42; this.order.length > this.max; ) {
+                    const t5 = this._getAndRemoveByKey(this.order[0]);
+                    t5 && this.onRemove(t5);
+                  }
+                  return this;
+                }
+                filter(t42) {
+                  const e22 = [];
+                  for (const i22 in this.data) for (const a22 of this.data[i22]) t42(a22.value) || e22.push(a22);
+                  for (const t5 of e22) this.remove(t5.value.tileID, t5);
+                }
+              }
+              class ct2 {
+                constructor() {
+                  this.state = {}, this.stateChanges = {}, this.deletedStates = {};
+                }
+                updateState(t42, i22, a22) {
+                  const s22 = String(i22);
+                  if (this.stateChanges[t42] = this.stateChanges[t42] || {}, this.stateChanges[t42][s22] = this.stateChanges[t42][s22] || {}, e2.e(this.stateChanges[t42][s22], a22), null === this.deletedStates[t42]) {
+                    this.deletedStates[t42] = {};
+                    for (const e22 in this.state[t42]) e22 !== s22 && (this.deletedStates[t42][e22] = null);
+                  } else if (this.deletedStates[t42] && null === this.deletedStates[t42][s22]) {
+                    this.deletedStates[t42][s22] = {};
+                    for (const e22 in this.state[t42][s22]) a22[e22] || (this.deletedStates[t42][s22][e22] = null);
+                  } else for (const e22 in a22) this.deletedStates[t42] && this.deletedStates[t42][s22] && null === this.deletedStates[t42][s22][e22] && delete this.deletedStates[t42][s22][e22];
+                }
+                removeFeatureState(t42, e22, i22) {
+                  if (null === this.deletedStates[t42]) return;
+                  const a22 = String(e22);
+                  if (this.deletedStates[t42] = this.deletedStates[t42] || {}, i22 && void 0 !== e22) null !== this.deletedStates[t42][a22] && (this.deletedStates[t42][a22] = this.deletedStates[t42][a22] || {}, this.deletedStates[t42][a22][i22] = null);
+                  else if (void 0 !== e22) if (this.stateChanges[t42] && this.stateChanges[t42][a22]) for (i22 in this.deletedStates[t42][a22] = {}, this.stateChanges[t42][a22]) this.deletedStates[t42][a22][i22] = null;
+                  else this.deletedStates[t42][a22] = null;
+                  else this.deletedStates[t42] = null;
+                }
+                getState(t42, i22) {
+                  const a22 = String(i22), s22 = e2.e({}, (this.state[t42] || {})[a22], (this.stateChanges[t42] || {})[a22]);
+                  if (null === this.deletedStates[t42]) return {};
+                  if (this.deletedStates[t42]) {
+                    const e22 = this.deletedStates[t42][i22];
+                    if (null === e22) return {};
+                    for (const t5 in e22) delete s22[t5];
+                  }
+                  return s22;
+                }
+                initializeTileState(t42, e22) {
+                  t42.setFeatureState(this.state, e22);
+                }
+                coalesceChanges(t42, i22) {
+                  const a22 = {};
+                  for (const t5 in this.stateChanges) {
+                    this.state[t5] = this.state[t5] || {};
+                    const i3 = {};
+                    for (const a3 in this.stateChanges[t5]) this.state[t5][a3] || (this.state[t5][a3] = {}), e2.e(this.state[t5][a3], this.stateChanges[t5][a3]), i3[a3] = this.state[t5][a3];
+                    a22[t5] = i3;
+                  }
+                  for (const t5 in this.deletedStates) {
+                    this.state[t5] = this.state[t5] || {};
+                    const i3 = {};
+                    if (null === this.deletedStates[t5]) for (const e22 in this.state[t5]) i3[e22] = {}, this.state[t5][e22] = {};
+                    else for (const e22 in this.deletedStates[t5]) {
+                      if (null === this.deletedStates[t5][e22]) this.state[t5][e22] = {};
+                      else for (const i4 of Object.keys(this.deletedStates[t5][e22])) delete this.state[t5][e22][i4];
+                      i3[e22] = this.state[t5][e22];
+                    }
+                    a22[t5] = a22[t5] || {}, e2.e(a22[t5], i3);
+                  }
+                  if (this.stateChanges = {}, this.deletedStates = {}, 0 !== Object.keys(a22).length) for (const e22 in t42) t42[e22].setFeatureState(a22, i22);
+                }
+              }
+              class ut2 extends e2.E {
+                constructor(t42, e22, i22) {
+                  super(), this.id = t42, this.dispatcher = i22, this.on("data", (t5) => this._dataHandler(t5)), this.on("dataloading", () => {
+                    this._sourceErrored = false;
+                  }), this.on("error", () => {
+                    this._sourceErrored = this._source.loaded();
+                  }), this._source = ((t5, e3, i3, a22) => {
+                    const s22 = new (at2(e3.type))(t5, e3, i3, a22);
+                    if (s22.id !== t5) throw new Error(`Expected Source id to be ${t5} instead of ${s22.id}`);
+                    return s22;
+                  })(t42, e22, i22, this), this._tiles = {}, this._cache = new ht2(0, (t5) => this._unloadTile(t5)), this._timers = {}, this._cacheTimers = {}, this._maxTileCacheSize = null, this._maxTileCacheZoomLevels = null, this._loadedParentTiles = {}, this._coveredTiles = {}, this._state = new ct2(), this._didEmitContent = false, this._updated = false;
+                }
+                onAdd(t42) {
+                  this.map = t42, this._maxTileCacheSize = t42 ? t42._maxTileCacheSize : null, this._maxTileCacheZoomLevels = t42 ? t42._maxTileCacheZoomLevels : null, this._source && this._source.onAdd && this._source.onAdd(t42);
+                }
+                onRemove(t42) {
+                  this.clearTiles(), this._source && this._source.onRemove && this._source.onRemove(t42);
+                }
+                loaded() {
+                  if (this._sourceErrored) return true;
+                  if (!this._sourceLoaded) return false;
+                  if (!this._source.loaded()) return false;
+                  if (!(void 0 === this.used && void 0 === this.usedForTerrain || this.used || this.usedForTerrain)) return true;
+                  if (!this._updated) return false;
+                  for (const t42 in this._tiles) {
+                    const e22 = this._tiles[t42];
+                    if ("loaded" !== e22.state && "errored" !== e22.state) return false;
+                  }
+                  return true;
+                }
+                getSource() {
+                  return this._source;
+                }
+                pause() {
+                  this._paused = true;
+                }
+                resume() {
+                  if (!this._paused) return;
+                  const t42 = this._shouldReloadOnResume;
+                  this._paused = false, this._shouldReloadOnResume = false, t42 && this.reload(), this.transform && this.update(this.transform, this.terrain);
+                }
+                _loadTile(t42, i22, a22) {
+                  return e2._(this, void 0, void 0, function* () {
+                    try {
+                      yield this._source.loadTile(t42), this._tileLoaded(t42, i22, a22);
+                    } catch (i3) {
+                      t42.state = "errored", 404 !== i3.status ? this._source.fire(new e2.j(i3, { tile: t42 })) : this.update(this.transform, this.terrain);
+                    }
+                  });
+                }
+                _unloadTile(t42) {
+                  this._source.unloadTile && this._source.unloadTile(t42);
+                }
+                _abortTile(t42) {
+                  this._source.abortTile && this._source.abortTile(t42), this._source.fire(new e2.k("dataabort", { tile: t42, coord: t42.tileID, dataType: "source" }));
+                }
+                serialize() {
+                  return this._source.serialize();
+                }
+                prepare(t42) {
+                  this._source.prepare && this._source.prepare(), this._state.coalesceChanges(this._tiles, this.map ? this.map.painter : null);
+                  for (const e22 in this._tiles) {
+                    const i22 = this._tiles[e22];
+                    i22.upload(t42), i22.prepare(this.map.style.imageManager);
+                  }
+                }
+                getIds() {
+                  return Object.values(this._tiles).map((t42) => t42.tileID).sort(dt2).map((t42) => t42.key);
+                }
+                getRenderableIds(t42) {
+                  const i22 = [];
+                  for (const e22 in this._tiles) this._isIdRenderable(e22, t42) && i22.push(this._tiles[e22]);
+                  return t42 ? i22.sort((t5, i3) => {
+                    const a22 = t5.tileID, s22 = i3.tileID, o22 = new e2.P(a22.canonical.x, a22.canonical.y)._rotate(this.transform.angle), r22 = new e2.P(s22.canonical.x, s22.canonical.y)._rotate(this.transform.angle);
+                    return a22.overscaledZ - s22.overscaledZ || r22.y - o22.y || r22.x - o22.x;
+                  }).map((t5) => t5.tileID.key) : i22.map((t5) => t5.tileID).sort(dt2).map((t5) => t5.key);
+                }
+                hasRenderableParent(t42) {
+                  const e22 = this.findLoadedParent(t42, 0);
+                  return !!e22 && this._isIdRenderable(e22.tileID.key);
+                }
+                _isIdRenderable(t42, e22) {
+                  return this._tiles[t42] && this._tiles[t42].hasData() && !this._coveredTiles[t42] && (e22 || !this._tiles[t42].holdingForFade());
+                }
+                reload() {
+                  if (this._paused) this._shouldReloadOnResume = true;
+                  else {
+                    this._cache.reset();
+                    for (const t42 in this._tiles) "errored" !== this._tiles[t42].state && this._reloadTile(t42, "reloading");
+                  }
+                }
+                _reloadTile(t42, i22) {
+                  return e2._(this, void 0, void 0, function* () {
+                    const e22 = this._tiles[t42];
+                    e22 && ("loading" !== e22.state && (e22.state = i22), yield this._loadTile(e22, t42, i22));
+                  });
+                }
+                _tileLoaded(t42, i22, a22) {
+                  t42.timeAdded = o2.now(), "expired" === a22 && (t42.refreshedUponExpiration = true), this._setTileReloadTimer(i22, t42), "raster-dem" === this.getSource().type && t42.dem && this._backfillDEM(t42), this._state.initializeTileState(t42, this.map ? this.map.painter : null), t42.aborted || this._source.fire(new e2.k("data", { dataType: "source", tile: t42, coord: t42.tileID }));
+                }
+                _backfillDEM(t42) {
+                  const e22 = this.getRenderableIds();
+                  for (let a22 = 0; a22 < e22.length; a22++) {
+                    const s22 = e22[a22];
+                    if (t42.neighboringTiles && t42.neighboringTiles[s22]) {
+                      const e3 = this.getTileByID(s22);
+                      i22(t42, e3), i22(e3, t42);
+                    }
+                  }
+                  function i22(t5, e3) {
+                    t5.needsHillshadePrepare = true, t5.needsTerrainPrepare = true;
+                    let i3 = e3.tileID.canonical.x - t5.tileID.canonical.x;
+                    const a22 = e3.tileID.canonical.y - t5.tileID.canonical.y, s22 = Math.pow(2, t5.tileID.canonical.z), o22 = e3.tileID.key;
+                    0 === i3 && 0 === a22 || Math.abs(a22) > 1 || (Math.abs(i3) > 1 && (1 === Math.abs(i3 + s22) ? i3 += s22 : 1 === Math.abs(i3 - s22) && (i3 -= s22)), e3.dem && t5.dem && (t5.dem.backfillBorder(e3.dem, i3, a22), t5.neighboringTiles && t5.neighboringTiles[o22] && (t5.neighboringTiles[o22].backfilled = true)));
+                  }
+                }
+                getTile(t42) {
+                  return this.getTileByID(t42.key);
+                }
+                getTileByID(t42) {
+                  return this._tiles[t42];
+                }
+                _retainLoadedChildren(t42, e22, i22, a22) {
+                  for (const s22 in this._tiles) {
+                    let o22 = this._tiles[s22];
+                    if (a22[s22] || !o22.hasData() || o22.tileID.overscaledZ <= e22 || o22.tileID.overscaledZ > i22) continue;
+                    let r22 = o22.tileID;
+                    for (; o22 && o22.tileID.overscaledZ > e22 + 1; ) {
+                      const t5 = o22.tileID.scaledTo(o22.tileID.overscaledZ - 1);
+                      o22 = this._tiles[t5.key], o22 && o22.hasData() && (r22 = t5);
+                    }
+                    let n22 = r22;
+                    for (; n22.overscaledZ > e22; ) if (n22 = n22.scaledTo(n22.overscaledZ - 1), t42[n22.key]) {
+                      a22[r22.key] = r22;
+                      break;
+                    }
+                  }
+                }
+                findLoadedParent(t42, e22) {
+                  if (t42.key in this._loadedParentTiles) {
+                    const i22 = this._loadedParentTiles[t42.key];
+                    return i22 && i22.tileID.overscaledZ >= e22 ? i22 : null;
+                  }
+                  for (let i22 = t42.overscaledZ - 1; i22 >= e22; i22--) {
+                    const e3 = t42.scaledTo(i22), a22 = this._getLoadedTile(e3);
+                    if (a22) return a22;
+                  }
+                }
+                findLoadedSibling(t42) {
+                  return this._getLoadedTile(t42);
+                }
+                _getLoadedTile(t42) {
+                  const e22 = this._tiles[t42.key];
+                  return e22 && e22.hasData() ? e22 : this._cache.getByKey(t42.wrapped().key);
+                }
+                updateCacheSize(t42) {
+                  const i22 = Math.ceil(t42.width / this._source.tileSize) + 1, a22 = Math.ceil(t42.height / this._source.tileSize) + 1, s22 = Math.floor(i22 * a22 * (null === this._maxTileCacheZoomLevels ? e2.a.MAX_TILE_CACHE_ZOOM_LEVELS : this._maxTileCacheZoomLevels)), o22 = "number" == typeof this._maxTileCacheSize ? Math.min(this._maxTileCacheSize, s22) : s22;
+                  this._cache.setMaxSize(o22);
+                }
+                handleWrapJump(t42) {
+                  const e22 = Math.round((t42 - (void 0 === this._prevLng ? t42 : this._prevLng)) / 360);
+                  if (this._prevLng = t42, e22) {
+                    const t5 = {};
+                    for (const i22 in this._tiles) {
+                      const a22 = this._tiles[i22];
+                      a22.tileID = a22.tileID.unwrapTo(a22.tileID.wrap + e22), t5[a22.tileID.key] = a22;
+                    }
+                    this._tiles = t5;
+                    for (const t6 in this._timers) clearTimeout(this._timers[t6]), delete this._timers[t6];
+                    for (const t6 in this._tiles) this._setTileReloadTimer(t6, this._tiles[t6]);
+                  }
+                }
+                _updateCoveredAndRetainedTiles(t42, e22, i22, a22, s22, r22) {
+                  const n22 = {}, l22 = {}, h22 = Object.keys(t42), c22 = o2.now();
+                  for (const i3 of h22) {
+                    const a3 = t42[i3], s3 = this._tiles[i3];
+                    if (!s3 || 0 !== s3.fadeEndTime && s3.fadeEndTime <= c22) continue;
+                    const o22 = this.findLoadedParent(a3, e22), r3 = this.findLoadedSibling(a3), h3 = o22 || r3 || null;
+                    h3 && (this._addTile(h3.tileID), n22[h3.tileID.key] = h3.tileID), l22[i3] = a3;
+                  }
+                  this._retainLoadedChildren(l22, a22, i22, t42);
+                  for (const e3 in n22) t42[e3] || (this._coveredTiles[e3] = true, t42[e3] = n22[e3]);
+                  if (r22) {
+                    const e3 = {}, i3 = {};
+                    for (const t5 of s22) this._tiles[t5.key].hasData() ? e3[t5.key] = t5 : i3[t5.key] = t5;
+                    for (const a3 in i3) {
+                      const s3 = i3[a3].children(this._source.maxzoom);
+                      this._tiles[s3[0].key] && this._tiles[s3[1].key] && this._tiles[s3[2].key] && this._tiles[s3[3].key] && (e3[s3[0].key] = t42[s3[0].key] = s3[0], e3[s3[1].key] = t42[s3[1].key] = s3[1], e3[s3[2].key] = t42[s3[2].key] = s3[2], e3[s3[3].key] = t42[s3[3].key] = s3[3], delete i3[a3]);
+                    }
+                    for (const a3 in i3) {
+                      const s3 = i3[a3], o22 = this.findLoadedParent(s3, this._source.minzoom), r3 = this.findLoadedSibling(s3), n3 = o22 || r3 || null;
+                      if (n3) {
+                        e3[n3.tileID.key] = t42[n3.tileID.key] = n3.tileID;
+                        for (const t5 in e3) e3[t5].isChildOf(n3.tileID) && delete e3[t5];
+                      }
+                    }
+                    for (const t5 in this._tiles) e3[t5] || (this._coveredTiles[t5] = true);
+                  }
+                }
+                update(t42, i22) {
+                  if (!this._sourceLoaded || this._paused) return;
+                  let a22;
+                  this.transform = t42, this.terrain = i22, this.updateCacheSize(t42), this.handleWrapJump(this.transform.center.lng), this._coveredTiles = {}, this.used || this.usedForTerrain ? this._source.tileID ? a22 = t42.getVisibleUnwrappedCoordinates(this._source.tileID).map((t5) => new e2.S(t5.canonical.z, t5.wrap, t5.canonical.z, t5.canonical.x, t5.canonical.y)) : (a22 = t42.coveringTiles({ tileSize: this.usedForTerrain ? this.tileSize : this._source.tileSize, minzoom: this._source.minzoom, maxzoom: this._source.maxzoom, roundZoom: !this.usedForTerrain && this._source.roundZoom, reparseOverscaled: this._source.reparseOverscaled, terrain: i22 }), this._source.hasTile && (a22 = a22.filter((t5) => this._source.hasTile(t5)))) : a22 = [];
+                  const s22 = t42.coveringZoomLevel(this._source), o22 = Math.max(s22 - ut2.maxOverzooming, this._source.minzoom), r22 = Math.max(s22 + ut2.maxUnderzooming, this._source.minzoom);
+                  if (this.usedForTerrain) {
+                    const t5 = {};
+                    for (const e22 of a22) if (e22.canonical.z > this._source.minzoom) {
+                      const i3 = e22.scaledTo(e22.canonical.z - 1);
+                      t5[i3.key] = i3;
+                      const a3 = e22.scaledTo(Math.max(this._source.minzoom, Math.min(e22.canonical.z, 5)));
+                      t5[a3.key] = a3;
+                    }
+                    a22 = a22.concat(Object.values(t5));
+                  }
+                  const n22 = 0 === a22.length && !this._updated && this._didEmitContent;
+                  this._updated = true, n22 && this.fire(new e2.k("data", { sourceDataType: "idle", dataType: "source", sourceId: this.id }));
+                  const l22 = this._updateRetainedTiles(a22, s22);
+                  _t2(this._source.type) && this._updateCoveredAndRetainedTiles(l22, o22, r22, s22, a22, i22);
+                  for (const t5 in l22) this._tiles[t5].clearFadeHold();
+                  const h22 = e2.ab(this._tiles, l22);
+                  for (const t5 of h22) {
+                    const e22 = this._tiles[t5];
+                    e22.hasSymbolBuckets && !e22.holdingForFade() ? e22.setHoldDuration(this.map._fadeDuration) : e22.hasSymbolBuckets && !e22.symbolFadeFinished() || this._removeTile(t5);
+                  }
+                  this._updateLoadedParentTileCache(), this._updateLoadedSiblingTileCache();
+                }
+                releaseSymbolFadeTiles() {
+                  for (const t42 in this._tiles) this._tiles[t42].holdingForFade() && this._removeTile(t42);
+                }
+                _updateRetainedTiles(t42, e22) {
+                  var i22;
+                  const a22 = {}, s22 = {}, o22 = Math.max(e22 - ut2.maxOverzooming, this._source.minzoom), r22 = Math.max(e22 + ut2.maxUnderzooming, this._source.minzoom), n22 = {};
+                  for (const i3 of t42) {
+                    const t5 = this._addTile(i3);
+                    a22[i3.key] = i3, t5.hasData() || e22 < this._source.maxzoom && (n22[i3.key] = i3);
+                  }
+                  this._retainLoadedChildren(n22, e22, r22, a22);
+                  for (const r3 of t42) {
+                    let t5 = this._tiles[r3.key];
+                    if (t5.hasData()) continue;
+                    if (e22 + 1 > this._source.maxzoom) {
+                      const t6 = r3.children(this._source.maxzoom)[0], e3 = this.getTile(t6);
+                      if (e3 && e3.hasData()) {
+                        a22[t6.key] = t6;
+                        continue;
+                      }
+                    } else {
+                      const t6 = r3.children(this._source.maxzoom);
+                      if (a22[t6[0].key] && a22[t6[1].key] && a22[t6[2].key] && a22[t6[3].key]) continue;
+                    }
+                    let n3 = t5.wasRequested();
+                    for (let e3 = r3.overscaledZ - 1; e3 >= o22; --e3) {
+                      const o3 = r3.scaledTo(e3);
+                      if (s22[o3.key]) break;
+                      if (s22[o3.key] = true, t5 = this.getTile(o3), !t5 && n3 && (t5 = this._addTile(o3)), t5) {
+                        const e4 = t5.hasData();
+                        if ((e4 || !(null === (i22 = this.map) || void 0 === i22 ? void 0 : i22.cancelPendingTileRequestsWhileZooming) || n3) && (a22[o3.key] = o3), n3 = t5.wasRequested(), e4) break;
+                      }
+                    }
+                  }
+                  return a22;
+                }
+                _updateLoadedParentTileCache() {
+                  this._loadedParentTiles = {};
+                  for (const t42 in this._tiles) {
+                    const e22 = [];
+                    let i22, a22 = this._tiles[t42].tileID;
+                    for (; a22.overscaledZ > 0; ) {
+                      if (a22.key in this._loadedParentTiles) {
+                        i22 = this._loadedParentTiles[a22.key];
+                        break;
+                      }
+                      e22.push(a22.key);
+                      const t5 = a22.scaledTo(a22.overscaledZ - 1);
+                      if (i22 = this._getLoadedTile(t5), i22) break;
+                      a22 = t5;
+                    }
+                    for (const t5 of e22) this._loadedParentTiles[t5] = i22;
+                  }
+                }
+                _updateLoadedSiblingTileCache() {
+                  this._loadedSiblingTiles = {};
+                  for (const t42 in this._tiles) {
+                    const e22 = this._tiles[t42].tileID, i22 = this._getLoadedTile(e22);
+                    this._loadedSiblingTiles[e22.key] = i22;
+                  }
+                }
+                _addTile(t42) {
+                  let i22 = this._tiles[t42.key];
+                  if (i22) return i22;
+                  i22 = this._cache.getAndRemove(t42), i22 && (this._setTileReloadTimer(t42.key, i22), i22.tileID = t42, this._state.initializeTileState(i22, this.map ? this.map.painter : null), this._cacheTimers[t42.key] && (clearTimeout(this._cacheTimers[t42.key]), delete this._cacheTimers[t42.key], this._setTileReloadTimer(t42.key, i22)));
+                  const a22 = i22;
+                  return i22 || (i22 = new lt2(t42, this._source.tileSize * t42.overscaleFactor()), this._loadTile(i22, t42.key, i22.state)), i22.uses++, this._tiles[t42.key] = i22, a22 || this._source.fire(new e2.k("dataloading", { tile: i22, coord: i22.tileID, dataType: "source" })), i22;
+                }
+                _setTileReloadTimer(t42, e22) {
+                  t42 in this._timers && (clearTimeout(this._timers[t42]), delete this._timers[t42]);
+                  const i22 = e22.getExpiryTimeout();
+                  i22 && (this._timers[t42] = setTimeout(() => {
+                    this._reloadTile(t42, "expired"), delete this._timers[t42];
+                  }, i22));
+                }
+                _removeTile(t42) {
+                  const e22 = this._tiles[t42];
+                  e22 && (e22.uses--, delete this._tiles[t42], this._timers[t42] && (clearTimeout(this._timers[t42]), delete this._timers[t42]), e22.uses > 0 || (e22.hasData() && "reloading" !== e22.state ? this._cache.add(e22.tileID, e22, e22.getExpiryTimeout()) : (e22.aborted = true, this._abortTile(e22), this._unloadTile(e22))));
+                }
+                _dataHandler(t42) {
+                  const e22 = t42.sourceDataType;
+                  "source" === t42.dataType && "metadata" === e22 && (this._sourceLoaded = true), this._sourceLoaded && !this._paused && "source" === t42.dataType && "content" === e22 && (this.reload(), this.transform && this.update(this.transform, this.terrain), this._didEmitContent = true);
+                }
+                clearTiles() {
+                  this._shouldReloadOnResume = false, this._paused = false;
+                  for (const t42 in this._tiles) this._removeTile(t42);
+                  this._cache.reset();
+                }
+                tilesIn(t42, i22, a22) {
+                  const s22 = [], o22 = this.transform;
+                  if (!o22) return s22;
+                  const r22 = a22 ? o22.getCameraQueryGeometry(t42) : t42, n22 = t42.map((t5) => o22.pointCoordinate(t5, this.terrain)), l22 = r22.map((t5) => o22.pointCoordinate(t5, this.terrain)), h22 = this.getIds();
+                  let c22 = 1 / 0, u22 = 1 / 0, d22 = -1 / 0, _22 = -1 / 0;
+                  for (const t5 of l22) c22 = Math.min(c22, t5.x), u22 = Math.min(u22, t5.y), d22 = Math.max(d22, t5.x), _22 = Math.max(_22, t5.y);
+                  for (let t5 = 0; t5 < h22.length; t5++) {
+                    const a3 = this._tiles[h22[t5]];
+                    if (a3.holdingForFade()) continue;
+                    const r3 = a3.tileID, p22 = Math.pow(2, o22.zoom - a3.tileID.overscaledZ), m22 = i22 * a3.queryPadding * e2.X / a3.tileSize / p22, f22 = [r3.getTilePoint(new e2.Z(c22, u22)), r3.getTilePoint(new e2.Z(d22, _22))];
+                    if (f22[0].x - m22 < e2.X && f22[0].y - m22 < e2.X && f22[1].x + m22 >= 0 && f22[1].y + m22 >= 0) {
+                      const t6 = n22.map((t7) => r3.getTilePoint(t7)), e22 = l22.map((t7) => r3.getTilePoint(t7));
+                      s22.push({ tile: a3, tileID: r3, queryGeometry: t6, cameraQueryGeometry: e22, scale: p22 });
+                    }
+                  }
+                  return s22;
+                }
+                getVisibleCoordinates(t42) {
+                  const e22 = this.getRenderableIds(t42).map((t5) => this._tiles[t5].tileID);
+                  for (const t5 of e22) t5.posMatrix = this.transform.calculatePosMatrix(t5.toUnwrapped());
+                  return e22;
+                }
+                hasTransition() {
+                  if (this._source.hasTransition()) return true;
+                  if (_t2(this._source.type)) {
+                    const t42 = o2.now();
+                    for (const e22 in this._tiles) if (this._tiles[e22].fadeEndTime >= t42) return true;
+                  }
+                  return false;
+                }
+                setFeatureState(t42, e22, i22) {
+                  this._state.updateState(t42 = t42 || "_geojsonTileLayer", e22, i22);
+                }
+                removeFeatureState(t42, e22, i22) {
+                  this._state.removeFeatureState(t42 = t42 || "_geojsonTileLayer", e22, i22);
+                }
+                getFeatureState(t42, e22) {
+                  return this._state.getState(t42 = t42 || "_geojsonTileLayer", e22);
+                }
+                setDependencies(t42, e22, i22) {
+                  const a22 = this._tiles[t42];
+                  a22 && a22.setDependencies(e22, i22);
+                }
+                reloadTilesForDependencies(t42, e22) {
+                  for (const i22 in this._tiles) this._tiles[i22].hasDependency(t42, e22) && this._reloadTile(i22, "reloading");
+                  this._cache.filter((i22) => !i22.hasDependency(t42, e22));
+                }
+              }
+              function dt2(t42, e22) {
+                const i22 = Math.abs(2 * t42.wrap) - +(t42.wrap < 0), a22 = Math.abs(2 * e22.wrap) - +(e22.wrap < 0);
+                return t42.overscaledZ - e22.overscaledZ || a22 - i22 || e22.canonical.y - t42.canonical.y || e22.canonical.x - t42.canonical.x;
+              }
+              function _t2(t42) {
+                return "raster" === t42 || "image" === t42 || "video" === t42;
+              }
+              ut2.maxOverzooming = 10, ut2.maxUnderzooming = 3;
+              class pt2 {
+                constructor(t42, e22) {
+                  this.reset(t42, e22);
+                }
+                reset(t42, e22) {
+                  this.points = t42 || [], this._distances = [0];
+                  for (let t5 = 1; t5 < this.points.length; t5++) this._distances[t5] = this._distances[t5 - 1] + this.points[t5].dist(this.points[t5 - 1]);
+                  this.length = this._distances[this._distances.length - 1], this.padding = Math.min(e22 || 0, 0.5 * this.length), this.paddedLength = this.length - 2 * this.padding;
+                }
+                lerp(t42) {
+                  if (1 === this.points.length) return this.points[0];
+                  t42 = e2.ac(t42, 0, 1);
+                  let i22 = 1, a22 = this._distances[i22];
+                  const s22 = t42 * this.paddedLength + this.padding;
+                  for (; a22 < s22 && i22 < this._distances.length; ) a22 = this._distances[++i22];
+                  const o22 = i22 - 1, r22 = this._distances[o22], n22 = a22 - r22, l22 = n22 > 0 ? (s22 - r22) / n22 : 0;
+                  return this.points[o22].mult(1 - l22).add(this.points[i22].mult(l22));
+                }
+              }
+              function mt2(t42, e22) {
+                let i22 = true;
+                return "always" === t42 || "never" !== t42 && "never" !== e22 || (i22 = false), i22;
+              }
+              class ft2 {
+                constructor(t42, e22, i22) {
+                  const a22 = this.boxCells = [], s22 = this.circleCells = [];
+                  this.xCellCount = Math.ceil(t42 / i22), this.yCellCount = Math.ceil(e22 / i22);
+                  for (let t5 = 0; t5 < this.xCellCount * this.yCellCount; t5++) a22.push([]), s22.push([]);
+                  this.circleKeys = [], this.boxKeys = [], this.bboxes = [], this.circles = [], this.width = t42, this.height = e22, this.xScale = this.xCellCount / t42, this.yScale = this.yCellCount / e22, this.boxUid = 0, this.circleUid = 0;
+                }
+                keysLength() {
+                  return this.boxKeys.length + this.circleKeys.length;
+                }
+                insert(t42, e22, i22, a22, s22) {
+                  this._forEachCell(e22, i22, a22, s22, this._insertBoxCell, this.boxUid++), this.boxKeys.push(t42), this.bboxes.push(e22), this.bboxes.push(i22), this.bboxes.push(a22), this.bboxes.push(s22);
+                }
+                insertCircle(t42, e22, i22, a22) {
+                  this._forEachCell(e22 - a22, i22 - a22, e22 + a22, i22 + a22, this._insertCircleCell, this.circleUid++), this.circleKeys.push(t42), this.circles.push(e22), this.circles.push(i22), this.circles.push(a22);
+                }
+                _insertBoxCell(t42, e22, i22, a22, s22, o22) {
+                  this.boxCells[s22].push(o22);
+                }
+                _insertCircleCell(t42, e22, i22, a22, s22, o22) {
+                  this.circleCells[s22].push(o22);
+                }
+                _query(t42, e22, i22, a22, s22, o22, r22) {
+                  if (i22 < 0 || t42 > this.width || a22 < 0 || e22 > this.height) return [];
+                  const n22 = [];
+                  if (t42 <= 0 && e22 <= 0 && this.width <= i22 && this.height <= a22) {
+                    if (s22) return [{ key: null, x1: t42, y1: e22, x2: i22, y2: a22 }];
+                    for (let t5 = 0; t5 < this.boxKeys.length; t5++) n22.push({ key: this.boxKeys[t5], x1: this.bboxes[4 * t5], y1: this.bboxes[4 * t5 + 1], x2: this.bboxes[4 * t5 + 2], y2: this.bboxes[4 * t5 + 3] });
+                    for (let t5 = 0; t5 < this.circleKeys.length; t5++) {
+                      const e3 = this.circles[3 * t5], i3 = this.circles[3 * t5 + 1], a3 = this.circles[3 * t5 + 2];
+                      n22.push({ key: this.circleKeys[t5], x1: e3 - a3, y1: i3 - a3, x2: e3 + a3, y2: i3 + a3 });
+                    }
+                  } else this._forEachCell(t42, e22, i22, a22, this._queryCell, n22, { hitTest: s22, overlapMode: o22, seenUids: { box: {}, circle: {} } }, r22);
+                  return n22;
+                }
+                query(t42, e22, i22, a22) {
+                  return this._query(t42, e22, i22, a22, false, null);
+                }
+                hitTest(t42, e22, i22, a22, s22, o22) {
+                  return this._query(t42, e22, i22, a22, true, s22, o22).length > 0;
+                }
+                hitTestCircle(t42, e22, i22, a22, s22) {
+                  const o22 = t42 - i22, r22 = t42 + i22, n22 = e22 - i22, l22 = e22 + i22;
+                  if (r22 < 0 || o22 > this.width || l22 < 0 || n22 > this.height) return false;
+                  const h22 = [];
+                  return this._forEachCell(o22, n22, r22, l22, this._queryCellCircle, h22, { hitTest: true, overlapMode: a22, circle: { x: t42, y: e22, radius: i22 }, seenUids: { box: {}, circle: {} } }, s22), h22.length > 0;
+                }
+                _queryCell(t42, e22, i22, a22, s22, o22, r22, n22) {
+                  const { seenUids: l22, hitTest: h22, overlapMode: c22 } = r22, u22 = this.boxCells[s22];
+                  if (null !== u22) {
+                    const s3 = this.bboxes;
+                    for (const r3 of u22) if (!l22.box[r3]) {
+                      l22.box[r3] = true;
+                      const u3 = 4 * r3, d3 = this.boxKeys[r3];
+                      if (t42 <= s3[u3 + 2] && e22 <= s3[u3 + 3] && i22 >= s3[u3 + 0] && a22 >= s3[u3 + 1] && (!n22 || n22(d3)) && (!h22 || !mt2(c22, d3.overlapMode)) && (o22.push({ key: d3, x1: s3[u3], y1: s3[u3 + 1], x2: s3[u3 + 2], y2: s3[u3 + 3] }), h22)) return true;
+                    }
+                  }
+                  const d22 = this.circleCells[s22];
+                  if (null !== d22) {
+                    const s3 = this.circles;
+                    for (const r3 of d22) if (!l22.circle[r3]) {
+                      l22.circle[r3] = true;
+                      const u3 = 3 * r3, d3 = this.circleKeys[r3];
+                      if (this._circleAndRectCollide(s3[u3], s3[u3 + 1], s3[u3 + 2], t42, e22, i22, a22) && (!n22 || n22(d3)) && (!h22 || !mt2(c22, d3.overlapMode))) {
+                        const t5 = s3[u3], e3 = s3[u3 + 1], i3 = s3[u3 + 2];
+                        if (o22.push({ key: d3, x1: t5 - i3, y1: e3 - i3, x2: t5 + i3, y2: e3 + i3 }), h22) return true;
+                      }
+                    }
+                  }
+                  return false;
+                }
+                _queryCellCircle(t42, e22, i22, a22, s22, o22, r22, n22) {
+                  const { circle: l22, seenUids: h22, overlapMode: c22 } = r22, u22 = this.boxCells[s22];
+                  if (null !== u22) {
+                    const t5 = this.bboxes;
+                    for (const e3 of u22) if (!h22.box[e3]) {
+                      h22.box[e3] = true;
+                      const i3 = 4 * e3, a3 = this.boxKeys[e3];
+                      if (this._circleAndRectCollide(l22.x, l22.y, l22.radius, t5[i3 + 0], t5[i3 + 1], t5[i3 + 2], t5[i3 + 3]) && (!n22 || n22(a3)) && !mt2(c22, a3.overlapMode)) return o22.push(true), true;
+                    }
+                  }
+                  const d22 = this.circleCells[s22];
+                  if (null !== d22) {
+                    const t5 = this.circles;
+                    for (const e3 of d22) if (!h22.circle[e3]) {
+                      h22.circle[e3] = true;
+                      const i3 = 3 * e3, a3 = this.circleKeys[e3];
+                      if (this._circlesCollide(t5[i3], t5[i3 + 1], t5[i3 + 2], l22.x, l22.y, l22.radius) && (!n22 || n22(a3)) && !mt2(c22, a3.overlapMode)) return o22.push(true), true;
+                    }
+                  }
+                }
+                _forEachCell(t42, e22, i22, a22, s22, o22, r22, n22) {
+                  const l22 = this._convertToXCellCoord(t42), h22 = this._convertToYCellCoord(e22), c22 = this._convertToXCellCoord(i22), u22 = this._convertToYCellCoord(a22);
+                  for (let d22 = l22; d22 <= c22; d22++) for (let l3 = h22; l3 <= u22; l3++) if (s22.call(this, t42, e22, i22, a22, this.xCellCount * l3 + d22, o22, r22, n22)) return;
+                }
+                _convertToXCellCoord(t42) {
+                  return Math.max(0, Math.min(this.xCellCount - 1, Math.floor(t42 * this.xScale)));
+                }
+                _convertToYCellCoord(t42) {
+                  return Math.max(0, Math.min(this.yCellCount - 1, Math.floor(t42 * this.yScale)));
+                }
+                _circlesCollide(t42, e22, i22, a22, s22, o22) {
+                  const r22 = a22 - t42, n22 = s22 - e22, l22 = i22 + o22;
+                  return l22 * l22 > r22 * r22 + n22 * n22;
+                }
+                _circleAndRectCollide(t42, e22, i22, a22, s22, o22, r22) {
+                  const n22 = (o22 - a22) / 2, l22 = Math.abs(t42 - (a22 + n22));
+                  if (l22 > n22 + i22) return false;
+                  const h22 = (r22 - s22) / 2, c22 = Math.abs(e22 - (s22 + h22));
+                  if (c22 > h22 + i22) return false;
+                  if (l22 <= n22 || c22 <= h22) return true;
+                  const u22 = l22 - n22, d22 = c22 - h22;
+                  return u22 * u22 + d22 * d22 <= i22 * i22;
+                }
+              }
+              function gt2(t42, i22, a22, s22, o22) {
+                const r22 = e2.H();
+                return i22 ? (e2.K(r22, r22, [1 / o22, 1 / o22, 1]), a22 || e2.ad(r22, r22, s22.angle)) : e2.L(r22, s22.labelPlaneMatrix, t42), r22;
+              }
+              function vt(t42, i22, a22, s22, o22) {
+                if (i22) {
+                  const i3 = e2.ae(t42);
+                  return e2.K(i3, i3, [o22, o22, 1]), a22 || e2.ad(i3, i3, -s22.angle), i3;
+                }
+                return s22.glCoordMatrix;
+              }
+              function xt(t42, i22, a22, s22) {
+                let o22;
+                s22 ? (o22 = [t42, i22, s22(t42, i22), 1], e2.af(o22, o22, a22)) : (o22 = [t42, i22, 0, 1], kt(o22, o22, a22));
+                const r22 = o22[3];
+                return { point: new e2.P(o22[0] / r22, o22[1] / r22), signedDistanceFromCamera: r22, isOccluded: false };
+              }
+              function yt(t42, e22) {
+                return 0.5 + t42 / e22 * 0.5;
+              }
+              function bt(t42, e22) {
+                return t42.x >= -e22[0] && t42.x <= e22[0] && t42.y >= -e22[1] && t42.y <= e22[1];
+              }
+              function wt(t42, i22, a22, s22, o22, r22, n22, l22, h22, c22, u22, d22, _22, p22, m22) {
+                const f22 = s22 ? t42.textSizeData : t42.iconSizeData, g22 = e2.ag(f22, a22.transform.zoom), v22 = [256 / a22.width * 2 + 1, 256 / a22.height * 2 + 1], x22 = s22 ? t42.text.dynamicLayoutVertexArray : t42.icon.dynamicLayoutVertexArray;
+                x22.clear();
+                const y22 = t42.lineVertexArray, b22 = s22 ? t42.text.placedSymbolArray : t42.icon.placedSymbolArray, w22 = a22.transform.width / a22.transform.height;
+                let T22 = false;
+                for (let s3 = 0; s3 < b22.length; s3++) {
+                  const I22 = b22.get(s3);
+                  if (I22.hidden || I22.writingMode === e2.ah.vertical && !T22) {
+                    Rt(I22.numGlyphs, x22);
+                    continue;
+                  }
+                  T22 = false;
+                  const E3 = xt(I22.anchorX, I22.anchorY, i22, m22);
+                  if (!bt(E3.point, v22)) {
+                    Rt(I22.numGlyphs, x22);
+                    continue;
+                  }
+                  const P22 = yt(a22.transform.cameraToCenterDistance, E3.signedDistanceFromCamera), C3 = e2.ai(f22, g22, I22), S22 = n22 ? C3 / P22 : C3 * P22, z22 = { getElevation: m22, labelPlaneMatrix: o22, lineVertexArray: y22, pitchWithMap: n22, projectionCache: { projections: {}, offsets: {}, cachedAnchorPoint: void 0, anyProjectionOccluded: false }, projection: c22, tileAnchorPoint: new e2.P(I22.anchorX, I22.anchorY), unwrappedTileID: u22, width: d22, height: _22, translation: p22 }, D3 = Et(z22, I22, S22, false, l22, i22, r22, t42.glyphOffsetArray, x22, w22, h22);
+                  T22 = D3.useVertical, (D3.notEnoughRoom || T22 || D3.needsFlipping && Et(z22, I22, S22, true, l22, i22, r22, t42.glyphOffsetArray, x22, w22, h22).notEnoughRoom) && Rt(I22.numGlyphs, x22);
+                }
+                s22 ? t42.text.dynamicLayoutVertexBuffer.updateData(x22) : t42.icon.dynamicLayoutVertexBuffer.updateData(x22);
+              }
+              function Tt(t42, e22, i22, a22, s22, o22, r22, n22) {
+                const l22 = o22.glyphStartIndex + o22.numGlyphs, h22 = o22.lineStartIndex, c22 = o22.lineStartIndex + o22.lineLength, u22 = e22.getoffsetX(o22.glyphStartIndex), d22 = e22.getoffsetX(l22 - 1), _22 = Mt(t42 * u22, i22, a22, s22, o22.segment, h22, c22, n22, r22);
+                if (!_22) return null;
+                const p22 = Mt(t42 * d22, i22, a22, s22, o22.segment, h22, c22, n22, r22);
+                return p22 ? n22.projectionCache.anyProjectionOccluded ? null : { first: _22, last: p22 } : null;
+              }
+              function It(t42, i22, a22, s22) {
+                return t42 === e2.ah.horizontal && Math.abs(a22.y - i22.y) > Math.abs(a22.x - i22.x) * s22 ? { useVertical: true } : (t42 === e2.ah.vertical ? i22.y < a22.y : i22.x > a22.x) ? { needsFlipping: true } : null;
+              }
+              function Et(t42, i22, a22, s22, o22, r22, n22, l22, h22, c22, u22) {
+                const d22 = a22 / 24, _22 = i22.lineOffsetX * d22, p22 = i22.lineOffsetY * d22;
+                let m22;
+                if (i22.numGlyphs > 1) {
+                  const e22 = i22.glyphStartIndex + i22.numGlyphs, a3 = i22.lineStartIndex, r3 = i22.lineStartIndex + i22.lineLength, h3 = Tt(d22, l22, _22, p22, s22, i22, u22, t42);
+                  if (!h3) return { notEnoughRoom: true };
+                  const f22 = xt(h3.first.point.x, h3.first.point.y, n22, t42.getElevation).point, g22 = xt(h3.last.point.x, h3.last.point.y, n22, t42.getElevation).point;
+                  if (o22 && !s22) {
+                    const t5 = It(i22.writingMode, f22, g22, c22);
+                    if (t5) return t5;
+                  }
+                  m22 = [h3.first];
+                  for (let o3 = i22.glyphStartIndex + 1; o3 < e22 - 1; o3++) m22.push(Mt(d22 * l22.getoffsetX(o3), _22, p22, s22, i22.segment, a3, r3, t42, u22));
+                  m22.push(h3.last);
+                } else {
+                  if (o22 && !s22) {
+                    const a4 = xt(t42.tileAnchorPoint.x, t42.tileAnchorPoint.y, r22, t42.getElevation).point, s3 = i22.lineStartIndex + i22.segment + 1, o3 = new e2.P(t42.lineVertexArray.getx(s3), t42.lineVertexArray.gety(s3)), n3 = xt(o3.x, o3.y, r22, t42.getElevation), l3 = n3.signedDistanceFromCamera > 0 ? n3.point : function(t5, e22, i3, a5, s4, o4) {
+                      return Pt(t5, e22, i3, 1, s4, o4);
+                    }(t42.tileAnchorPoint, o3, a4, 0, r22, t42), h3 = It(i22.writingMode, a4, l3, c22);
+                    if (h3) return h3;
+                  }
+                  const a3 = Mt(d22 * l22.getoffsetX(i22.glyphStartIndex), _22, p22, s22, i22.segment, i22.lineStartIndex, i22.lineStartIndex + i22.lineLength, t42, u22);
+                  if (!a3 || t42.projectionCache.anyProjectionOccluded) return { notEnoughRoom: true };
+                  m22 = [a3];
+                }
+                for (const t5 of m22) e2.aj(h22, t5.point, t5.angle);
+                return {};
+              }
+              function Pt(t42, e22, i22, a22, s22, o22) {
+                const r22 = t42.add(t42.sub(e22)._unit()), n22 = void 0 !== s22 ? xt(r22.x, r22.y, s22, o22.getElevation).point : St(r22.x, r22.y, o22).point, l22 = i22.sub(n22);
+                return i22.add(l22._mult(a22 / l22.mag()));
+              }
+              function Ct(t42, i22, a22) {
+                const s22 = i22.projectionCache;
+                if (s22.projections[t42]) return s22.projections[t42];
+                const o22 = new e2.P(i22.lineVertexArray.getx(t42), i22.lineVertexArray.gety(t42)), r22 = St(o22.x, o22.y, i22);
+                if (r22.signedDistanceFromCamera > 0) return s22.projections[t42] = r22.point, s22.anyProjectionOccluded = s22.anyProjectionOccluded || r22.isOccluded, r22.point;
+                const n22 = t42 - a22.direction;
+                return function(t5, e22, i3, a3, s3) {
+                  return Pt(t5, e22, i3, a3, void 0, s3);
+                }(0 === a22.distanceFromAnchor ? i22.tileAnchorPoint : new e2.P(i22.lineVertexArray.getx(n22), i22.lineVertexArray.gety(n22)), o22, a22.previousVertex, a22.absOffsetX - a22.distanceFromAnchor + 1, i22);
+              }
+              function St(t42, e22, i22) {
+                const a22 = t42 + i22.translation[0], s22 = e22 + i22.translation[1];
+                let o22;
+                return !i22.pitchWithMap && i22.projection.useSpecialProjectionForSymbols ? (o22 = i22.projection.projectTileCoordinates(a22, s22, i22.unwrappedTileID, i22.getElevation), o22.point.x = (0.5 * o22.point.x + 0.5) * i22.width, o22.point.y = (0.5 * -o22.point.y + 0.5) * i22.height) : (o22 = xt(a22, s22, i22.labelPlaneMatrix, i22.getElevation), o22.isOccluded = false), o22;
+              }
+              function zt(t42, e22, i22) {
+                return t42._unit()._perp()._mult(e22 * i22);
+              }
+              function Dt(t42, i22, a22, s22, o22, r22, n22, l22, h22) {
+                if (l22.projectionCache.offsets[t42]) return l22.projectionCache.offsets[t42];
+                const c22 = a22.add(i22);
+                if (t42 + h22.direction < s22 || t42 + h22.direction >= o22) return l22.projectionCache.offsets[t42] = c22, c22;
+                const u22 = Ct(t42 + h22.direction, l22, h22), d22 = zt(u22.sub(a22), n22, h22.direction), _22 = a22.add(d22), p22 = u22.add(d22);
+                return l22.projectionCache.offsets[t42] = e2.ak(r22, c22, _22, p22) || c22, l22.projectionCache.offsets[t42];
+              }
+              function Mt(t42, e22, i22, a22, s22, o22, r22, n22, l22) {
+                const h22 = a22 ? t42 - e22 : t42 + e22;
+                let c22 = h22 > 0 ? 1 : -1, u22 = 0;
+                a22 && (c22 *= -1, u22 = Math.PI), c22 < 0 && (u22 += Math.PI);
+                let d22, _22 = c22 > 0 ? o22 + s22 : o22 + s22 + 1;
+                n22.projectionCache.cachedAnchorPoint ? d22 = n22.projectionCache.cachedAnchorPoint : (d22 = St(n22.tileAnchorPoint.x, n22.tileAnchorPoint.y, n22).point, n22.projectionCache.cachedAnchorPoint = d22);
+                let p22, m22, f22 = d22, g22 = d22, v22 = 0, x22 = 0;
+                const y22 = Math.abs(h22), b22 = [];
+                let w22;
+                for (; v22 + x22 <= y22; ) {
+                  if (_22 += c22, _22 < o22 || _22 >= r22) return null;
+                  v22 += x22, g22 = f22, m22 = p22;
+                  const t5 = { absOffsetX: y22, direction: c22, distanceFromAnchor: v22, previousVertex: g22 };
+                  if (f22 = Ct(_22, n22, t5), 0 === i22) b22.push(g22), w22 = f22.sub(g22);
+                  else {
+                    let e3;
+                    const a3 = f22.sub(g22);
+                    e3 = 0 === a3.mag() ? zt(Ct(_22 + c22, n22, t5).sub(f22), i22, c22) : zt(a3, i22, c22), m22 || (m22 = g22.add(e3)), p22 = Dt(_22, e3, f22, o22, r22, m22, i22, n22, t5), b22.push(m22), w22 = p22.sub(m22);
+                  }
+                  x22 = w22.mag();
+                }
+                const T22 = w22._mult((y22 - v22) / x22)._add(m22 || g22), I22 = u22 + Math.atan2(f22.y - g22.y, f22.x - g22.x);
+                return b22.push(T22), { point: T22, angle: l22 ? I22 : 0, path: b22 };
+              }
+              const At = new Float32Array([-1 / 0, -1 / 0, 0, -1 / 0, -1 / 0, 0, -1 / 0, -1 / 0, 0, -1 / 0, -1 / 0, 0]);
+              function Rt(t42, e22) {
+                for (let i22 = 0; i22 < t42; i22++) {
+                  const t5 = e22.length;
+                  e22.resize(t5 + 4), e22.float32.set(At, 3 * t5);
+                }
+              }
+              function kt(t42, e22, i22) {
+                const a22 = e22[0], s22 = e22[1];
+                return t42[0] = i22[0] * a22 + i22[4] * s22 + i22[12], t42[1] = i22[1] * a22 + i22[5] * s22 + i22[13], t42[3] = i22[3] * a22 + i22[7] * s22 + i22[15], t42;
+              }
+              const Lt = 100;
+              class Ft {
+                constructor(t42, e22, i22 = new ft2(t42.width + 200, t42.height + 200, 25), a22 = new ft2(t42.width + 200, t42.height + 200, 25)) {
+                  this.transform = t42, this.mapProjection = e22, this.grid = i22, this.ignoredGrid = a22, this.pitchFactor = Math.cos(t42._pitch) * t42.cameraToCenterDistance, this.screenRightBoundary = t42.width + Lt, this.screenBottomBoundary = t42.height + Lt, this.gridRightBoundary = t42.width + 200, this.gridBottomBoundary = t42.height + 200, this.perspectiveRatioCutoff = 0.6;
+                }
+                placeCollisionBox(t42, e22, i22, a22, s22, o22, r22, n22, l22, h22, c22) {
+                  const u22 = t42.anchorPointX + n22[0], d22 = t42.anchorPointY + n22[1], _22 = this.projectAndGetPerspectiveRatio(a22, u22, d22, s22, h22), p22 = i22 * _22.perspectiveRatio;
+                  let m22;
+                  if (o22 || r22) m22 = this._projectCollisionBox(t42, p22, a22, s22, o22, r22, n22, _22, h22, c22);
+                  else {
+                    const e3 = _22.point.x + (c22 ? c22.x * p22 : 0), i3 = _22.point.y + (c22 ? c22.y * p22 : 0);
+                    m22 = { allPointsOccluded: false, box: [e3 + t42.x1 * p22, i3 + t42.y1 * p22, e3 + t42.x2 * p22, i3 + t42.y2 * p22] };
+                  }
+                  const [f22, g22, v22, x22] = m22.box;
+                  return this.mapProjection.useSpecialProjectionForSymbols && (o22 ? m22.allPointsOccluded : this.mapProjection.isOccluded(u22, d22, s22)) || _22.perspectiveRatio < this.perspectiveRatioCutoff || !this.isInsideGrid(f22, g22, v22, x22) || "always" !== e22 && this.grid.hitTest(f22, g22, v22, x22, e22, l22) ? { box: [f22, g22, v22, x22], placeable: false, offscreen: false } : { box: [f22, g22, v22, x22], placeable: true, offscreen: this.isOffscreen(f22, g22, v22, x22) };
+                }
+                placeCollisionCircles(t42, i22, a22, s22, o22, r22, n22, l22, h22, c22, u22, d22, _22, p22, m22, f22) {
+                  const g22 = [], v22 = new e2.P(i22.anchorX, i22.anchorY), x22 = this.getPerspectiveRatio(r22, v22.x, v22.y, n22, f22), y22 = (u22 ? o22 / x22 : o22 * x22) / e2.ap, b22 = { getElevation: f22, labelPlaneMatrix: l22, lineVertexArray: a22, pitchWithMap: u22, projectionCache: { projections: {}, offsets: {}, cachedAnchorPoint: void 0, anyProjectionOccluded: false }, projection: this.mapProjection, tileAnchorPoint: v22, unwrappedTileID: n22, width: this.transform.width, height: this.transform.height, translation: m22 }, w22 = Tt(y22, s22, i22.lineOffsetX * y22, i22.lineOffsetY * y22, false, i22, false, b22);
+                  let T22 = false, I22 = false, E3 = true;
+                  if (w22) {
+                    const i3 = 0.5 * _22 * x22 + p22, a3 = new e2.P(-100, -100), s3 = new e2.P(this.screenRightBoundary, this.screenBottomBoundary), o3 = new pt2(), r3 = w22.first, n3 = w22.last;
+                    let l3 = [];
+                    for (let t5 = r3.path.length - 1; t5 >= 1; t5--) l3.push(r3.path[t5]);
+                    for (let t5 = 1; t5 < n3.path.length; t5++) l3.push(n3.path[t5]);
+                    const u3 = 2.5 * i3;
+                    if (h22) {
+                      const t5 = this.projectPathToScreenSpace(l3, b22, h22);
+                      l3 = t5.some((t6) => t6.signedDistanceFromCamera <= 0) ? [] : t5.map((t6) => t6.point);
+                    }
+                    let m3 = [];
+                    if (l3.length > 0) {
+                      const t5 = l3[0].clone(), i4 = l3[0].clone();
+                      for (let e22 = 1; e22 < l3.length; e22++) t5.x = Math.min(t5.x, l3[e22].x), t5.y = Math.min(t5.y, l3[e22].y), i4.x = Math.max(i4.x, l3[e22].x), i4.y = Math.max(i4.y, l3[e22].y);
+                      m3 = t5.x >= a3.x && i4.x <= s3.x && t5.y >= a3.y && i4.y <= s3.y ? [l3] : i4.x < a3.x || t5.x > s3.x || i4.y < a3.y || t5.y > s3.y ? [] : e2.al([l3], a3.x, a3.y, s3.x, s3.y);
+                    }
+                    for (const e22 of m3) {
+                      o3.reset(e22, 0.25 * i3);
+                      let a4 = 0;
+                      a4 = o3.length <= 0.5 * i3 ? 1 : Math.ceil(o3.paddedLength / u3) + 1;
+                      for (let e3 = 0; e3 < a4; e3++) {
+                        const s4 = e3 / Math.max(a4 - 1, 1), r4 = o3.lerp(s4), n4 = r4.x + Lt, l4 = r4.y + Lt;
+                        g22.push(n4, l4, i3, 0);
+                        const h3 = n4 - i3, u4 = l4 - i3, _3 = n4 + i3, p3 = l4 + i3;
+                        if (E3 = E3 && this.isOffscreen(h3, u4, _3, p3), I22 = I22 || this.isInsideGrid(h3, u4, _3, p3), "always" !== t42 && this.grid.hitTestCircle(n4, l4, i3, t42, d22) && (T22 = true, !c22)) return { circles: [], offscreen: false, collisionDetected: T22 };
+                      }
+                    }
+                  }
+                  return { circles: !c22 && T22 || !I22 || x22 < this.perspectiveRatioCutoff ? [] : g22, offscreen: E3, collisionDetected: T22 };
+                }
+                projectPathToScreenSpace(t42, e22, i22) {
+                  return t42.map((t5) => xt(t5.x, t5.y, i22, e22.getElevation));
+                }
+                queryRenderedSymbols(t42) {
+                  if (0 === t42.length || 0 === this.grid.keysLength() && 0 === this.ignoredGrid.keysLength()) return {};
+                  const i22 = [];
+                  let a22 = 1 / 0, s22 = 1 / 0, o22 = -1 / 0, r22 = -1 / 0;
+                  for (const n3 of t42) {
+                    const t5 = new e2.P(n3.x + Lt, n3.y + Lt);
+                    a22 = Math.min(a22, t5.x), s22 = Math.min(s22, t5.y), o22 = Math.max(o22, t5.x), r22 = Math.max(r22, t5.y), i22.push(t5);
+                  }
+                  const n22 = this.grid.query(a22, s22, o22, r22).concat(this.ignoredGrid.query(a22, s22, o22, r22)), l22 = {}, h22 = {};
+                  for (const t5 of n22) {
+                    const a3 = t5.key;
+                    if (void 0 === l22[a3.bucketInstanceId] && (l22[a3.bucketInstanceId] = {}), l22[a3.bucketInstanceId][a3.featureIndex]) continue;
+                    const s3 = [new e2.P(t5.x1, t5.y1), new e2.P(t5.x2, t5.y1), new e2.P(t5.x2, t5.y2), new e2.P(t5.x1, t5.y2)];
+                    e2.am(i22, s3) && (l22[a3.bucketInstanceId][a3.featureIndex] = true, void 0 === h22[a3.bucketInstanceId] && (h22[a3.bucketInstanceId] = []), h22[a3.bucketInstanceId].push(a3.featureIndex));
+                  }
+                  return h22;
+                }
+                insertCollisionBox(t42, e22, i22, a22, s22, o22) {
+                  (i22 ? this.ignoredGrid : this.grid).insert({ bucketInstanceId: a22, featureIndex: s22, collisionGroupID: o22, overlapMode: e22 }, t42[0], t42[1], t42[2], t42[3]);
+                }
+                insertCollisionCircles(t42, e22, i22, a22, s22, o22) {
+                  const r22 = i22 ? this.ignoredGrid : this.grid, n22 = { bucketInstanceId: a22, featureIndex: s22, collisionGroupID: o22, overlapMode: e22 };
+                  for (let e3 = 0; e3 < t42.length; e3 += 4) r22.insertCircle(n22, t42[e3], t42[e3 + 1], t42[e3 + 2]);
+                }
+                projectAndGetPerspectiveRatio(t42, i22, a22, s22, o22) {
+                  let r22;
+                  o22 ? (r22 = [i22, a22, o22(i22, a22), 1], e2.af(r22, r22, t42)) : (r22 = [i22, a22, 0, 1], kt(r22, r22, t42));
+                  const n22 = r22[3];
+                  return { point: new e2.P((r22[0] / n22 + 1) / 2 * this.transform.width + Lt, (-r22[1] / n22 + 1) / 2 * this.transform.height + Lt), perspectiveRatio: 0.5 + this.transform.cameraToCenterDistance / n22 * 0.5, isOccluded: false, signedDistanceFromCamera: n22 };
+                }
+                getPerspectiveRatio(t42, e22, i22, a22, s22) {
+                  const o22 = this.mapProjection.useSpecialProjectionForSymbols ? this.mapProjection.projectTileCoordinates(e22, i22, a22, s22) : xt(e22, i22, t42, s22);
+                  return 0.5 + this.transform.cameraToCenterDistance / o22.signedDistanceFromCamera * 0.5;
+                }
+                isOffscreen(t42, e22, i22, a22) {
+                  return i22 < Lt || t42 >= this.screenRightBoundary || a22 < Lt || e22 > this.screenBottomBoundary;
+                }
+                isInsideGrid(t42, e22, i22, a22) {
+                  return i22 >= 0 && t42 < this.gridRightBoundary && a22 >= 0 && e22 < this.gridBottomBoundary;
+                }
+                getViewportMatrix() {
+                  const t42 = e2.an([]);
+                  return e2.J(t42, t42, [-100, -100, 0]), t42;
+                }
+                _projectCollisionBox(t42, i22, a22, s22, o22, r22, n22, l22, h22, c22) {
+                  let u22 = new e2.P(1, 0), d22 = new e2.P(0, 1);
+                  const _22 = new e2.P(t42.anchorPointX + n22[0], t42.anchorPointY + n22[1]);
+                  if (r22 && !o22) {
+                    const t5 = this.projectAndGetPerspectiveRatio(a22, _22.x + 1, _22.y, s22, h22).point.sub(l22.point).unit(), i3 = Math.atan(t5.y / t5.x) + (t5.x < 0 ? Math.PI : 0), o3 = Math.sin(i3), r3 = Math.cos(i3);
+                    u22 = new e2.P(r3, o3), d22 = new e2.P(-o3, r3);
+                  } else if (!r22 && o22) {
+                    const t5 = -this.transform.angle, i3 = Math.sin(t5), a3 = Math.cos(t5);
+                    u22 = new e2.P(a3, i3), d22 = new e2.P(-i3, a3);
+                  }
+                  let p22 = l22.point, m22 = i22;
+                  if (o22) {
+                    p22 = _22;
+                    const t5 = this.transform.zoom - Math.floor(this.transform.zoom);
+                    m22 = Math.pow(2, -t5), m22 *= this.mapProjection.getPitchedTextCorrection(this.transform, _22, s22), c22 || (m22 *= e2.ac(0.5 + l22.signedDistanceFromCamera / this.transform.cameraToCenterDistance * 0.5, 0, 4));
+                  }
+                  c22 && (p22 = p22.add(u22.mult(c22.x * m22)).add(d22.mult(c22.y * m22)));
+                  const f22 = t42.x1 * m22, g22 = t42.x2 * m22, v22 = (f22 + g22) / 2, x22 = t42.y1 * m22, y22 = t42.y2 * m22, b22 = (x22 + y22) / 2, w22 = [{ offsetX: f22, offsetY: x22 }, { offsetX: v22, offsetY: x22 }, { offsetX: g22, offsetY: x22 }, { offsetX: g22, offsetY: b22 }, { offsetX: g22, offsetY: y22 }, { offsetX: v22, offsetY: y22 }, { offsetX: f22, offsetY: y22 }, { offsetX: f22, offsetY: b22 }];
+                  let T22 = [];
+                  for (const { offsetX: t5, offsetY: i3 } of w22) T22.push(new e2.P(p22.x + u22.x * t5 + d22.x * i3, p22.y + u22.y * t5 + d22.y * i3));
+                  let I22 = false;
+                  if (o22) {
+                    const t5 = T22.map((t6) => this.projectAndGetPerspectiveRatio(a22, t6.x, t6.y, s22, h22));
+                    I22 = t5.some((t6) => !t6.isOccluded), T22 = t5.map((t6) => t6.point);
+                  } else I22 = true;
+                  return { box: e2.ao(T22), allPointsOccluded: !I22 };
+                }
+              }
+              function Bt(t42, i22, a22) {
+                return i22 * (e2.X / (t42.tileSize * Math.pow(2, a22 - t42.tileID.overscaledZ)));
+              }
+              class Ot {
+                constructor(t42, e22, i22, a22) {
+                  this.opacity = t42 ? Math.max(0, Math.min(1, t42.opacity + (t42.placed ? e22 : -e22))) : a22 && i22 ? 1 : 0, this.placed = i22;
+                }
+                isHidden() {
+                  return 0 === this.opacity && !this.placed;
+                }
+              }
+              class Nt {
+                constructor(t42, e22, i22, a22, s22) {
+                  this.text = new Ot(t42 ? t42.text : null, e22, i22, s22), this.icon = new Ot(t42 ? t42.icon : null, e22, a22, s22);
+                }
+                isHidden() {
+                  return this.text.isHidden() && this.icon.isHidden();
+                }
+              }
+              class Ut {
+                constructor(t42, e22, i22) {
+                  this.text = t42, this.icon = e22, this.skipFade = i22;
+                }
+              }
+              class jt {
+                constructor() {
+                  this.invProjMatrix = e2.H(), this.viewportMatrix = e2.H(), this.circles = [];
+                }
+              }
+              class Zt {
+                constructor(t42, e22, i22, a22, s22) {
+                  this.bucketInstanceId = t42, this.featureIndex = e22, this.sourceLayerIndex = i22, this.bucketIndex = a22, this.tileID = s22;
+                }
+              }
+              class qt {
+                constructor(t42) {
+                  this.crossSourceCollisions = t42, this.maxGroupID = 0, this.collisionGroups = {};
+                }
+                get(t42) {
+                  if (this.crossSourceCollisions) return { ID: 0, predicate: null };
+                  if (!this.collisionGroups[t42]) {
+                    const e22 = ++this.maxGroupID;
+                    this.collisionGroups[t42] = { ID: e22, predicate: (t5) => t5.collisionGroupID === e22 };
+                  }
+                  return this.collisionGroups[t42];
+                }
+              }
+              function Vt(t42, i22, a22, s22, o22) {
+                const { horizontalAlign: r22, verticalAlign: n22 } = e2.au(t42);
+                return new e2.P(-(r22 - 0.5) * i22 + s22[0] * o22, -(n22 - 0.5) * a22 + s22[1] * o22);
+              }
+              class Gt {
+                constructor(t42, e22, i22, a22, s22, o22) {
+                  this.transform = t42.clone(), this.terrain = i22, this.collisionIndex = new Ft(this.transform, e22), this.placements = {}, this.opacities = {}, this.variableOffsets = {}, this.stale = false, this.commitTime = 0, this.fadeDuration = a22, this.retainedQueryData = {}, this.collisionGroups = new qt(s22), this.collisionCircleArrays = {}, this.collisionBoxArrays = /* @__PURE__ */ new Map(), this.prevPlacement = o22, o22 && (o22.prevPlacement = void 0), this.placedOrientations = {};
+                }
+                _getTerrainElevationFunc(t42) {
+                  const e22 = this.terrain;
+                  return e22 ? (i22, a22) => e22.getElevation(t42, i22, a22) : null;
+                }
+                getBucketParts(t42, i22, a22, s22) {
+                  const o22 = a22.getBucket(i22), r22 = a22.latestFeatureIndex;
+                  if (!o22 || !r22 || i22.id !== o22.layerIds[0]) return;
+                  const n22 = a22.collisionBoxArray, l22 = o22.layers[0].layout, h22 = o22.layers[0].paint, c22 = Math.pow(2, this.transform.zoom - a22.tileID.overscaledZ), u22 = a22.tileSize / e2.X, d22 = a22.tileID.toUnwrapped(), _22 = this.transform.calculatePosMatrix(d22), p22 = "map" === l22.get("text-pitch-alignment"), m22 = "map" === l22.get("text-rotation-alignment"), f22 = Bt(a22, 1, this.transform.zoom), g22 = this.collisionIndex.mapProjection.translatePosition(this.transform, a22, h22.get("text-translate"), h22.get("text-translate-anchor")), v22 = this.collisionIndex.mapProjection.translatePosition(this.transform, a22, h22.get("icon-translate"), h22.get("icon-translate-anchor")), x22 = gt2(_22, p22, m22, this.transform, f22);
+                  let y22 = null;
+                  if (p22) {
+                    const t5 = vt(_22, p22, m22, this.transform, f22);
+                    y22 = e2.L([], this.transform.labelPlaneMatrix, t5);
+                  }
+                  this.retainedQueryData[o22.bucketInstanceId] = new Zt(o22.bucketInstanceId, r22, o22.sourceLayerIndex, o22.index, a22.tileID);
+                  const b22 = { bucket: o22, layout: l22, translationText: g22, translationIcon: v22, posMatrix: _22, unwrappedTileID: d22, textLabelPlaneMatrix: x22, labelToScreenMatrix: y22, scale: c22, textPixelRatio: u22, holdingForFade: a22.holdingForFade(), collisionBoxArray: n22, partiallyEvaluatedTextSize: e2.ag(o22.textSizeData, this.transform.zoom), collisionGroup: this.collisionGroups.get(o22.sourceID) };
+                  if (s22) for (const e22 of o22.sortKeyRanges) {
+                    const { sortKey: i3, symbolInstanceStart: a3, symbolInstanceEnd: s3 } = e22;
+                    t42.push({ sortKey: i3, symbolInstanceStart: a3, symbolInstanceEnd: s3, parameters: b22 });
+                  }
+                  else t42.push({ symbolInstanceStart: 0, symbolInstanceEnd: o22.symbolInstances.length, parameters: b22 });
+                }
+                attemptAnchorPlacement(t42, i22, a22, s22, o22, r22, n22, l22, h22, c22, u22, d22, _22, p22, m22, f22, g22, v22, x22) {
+                  const y22 = e2.aq[t42.textAnchor], b22 = [t42.textOffset0, t42.textOffset1], w22 = Vt(y22, a22, s22, b22, o22), T22 = this.collisionIndex.placeCollisionBox(i22, d22, l22, h22, c22, n22, r22, f22, u22.predicate, x22, w22);
+                  if ((!v22 || this.collisionIndex.placeCollisionBox(v22, d22, l22, h22, c22, n22, r22, g22, u22.predicate, x22, w22).placeable) && T22.placeable) {
+                    let t5;
+                    if (this.prevPlacement && this.prevPlacement.variableOffsets[_22.crossTileID] && this.prevPlacement.placements[_22.crossTileID] && this.prevPlacement.placements[_22.crossTileID].text && (t5 = this.prevPlacement.variableOffsets[_22.crossTileID].anchor), 0 === _22.crossTileID) throw new Error("symbolInstance.crossTileID can't be 0");
+                    return this.variableOffsets[_22.crossTileID] = { textOffset: b22, width: a22, height: s22, anchor: y22, textBoxScale: o22, prevAnchor: t5 }, this.markUsedJustification(p22, y22, _22, m22), p22.allowVerticalPlacement && (this.markUsedOrientation(p22, m22, _22), this.placedOrientations[_22.crossTileID] = m22), { shift: w22, placedGlyphBoxes: T22 };
+                  }
+                }
+                placeLayerBucketPart(t42, i22, a22) {
+                  const { bucket: s22, layout: o22, translationText: r22, translationIcon: n22, posMatrix: l22, unwrappedTileID: h22, textLabelPlaneMatrix: c22, labelToScreenMatrix: u22, textPixelRatio: d22, holdingForFade: _22, collisionBoxArray: p22, partiallyEvaluatedTextSize: m22, collisionGroup: f22 } = t42.parameters, g22 = o22.get("text-optional"), v22 = o22.get("icon-optional"), x22 = e2.ar(o22, "text-overlap", "text-allow-overlap"), y22 = "always" === x22, b22 = e2.ar(o22, "icon-overlap", "icon-allow-overlap"), w22 = "always" === b22, T22 = "map" === o22.get("text-rotation-alignment"), I22 = "map" === o22.get("text-pitch-alignment"), E3 = "none" !== o22.get("icon-text-fit"), P22 = "viewport-y" === o22.get("symbol-z-order"), C3 = y22 && (w22 || !s22.hasIconData() || v22), S22 = w22 && (y22 || !s22.hasTextData() || g22);
+                  !s22.collisionArrays && p22 && s22.deserializeCollisionBoxes(p22);
+                  const z22 = this._getTerrainElevationFunc(this.retainedQueryData[s22.bucketInstanceId].tileID), D3 = (t5, p3, w3) => {
+                    var P3, D4;
+                    if (i22[t5.crossTileID]) return;
+                    if (_22) return void (this.placements[t5.crossTileID] = new Ut(false, false, false));
+                    let M22 = false, A3 = false, R22 = true, k22 = null, L22 = { box: null, placeable: false, offscreen: null }, F22 = { placeable: false }, B3 = null, O22 = null, N22 = null, U22 = 0, j22 = 0, Z22 = 0;
+                    p3.textFeatureIndex ? U22 = p3.textFeatureIndex : t5.useRuntimeCollisionCircles && (U22 = t5.featureIndex), p3.verticalTextFeatureIndex && (j22 = p3.verticalTextFeatureIndex);
+                    const q22 = p3.textBox;
+                    if (q22) {
+                      const i3 = (i4) => {
+                        let a3 = e2.ah.horizontal;
+                        if (s22.allowVerticalPlacement && !i4 && this.prevPlacement) {
+                          const e22 = this.prevPlacement.placedOrientations[t5.crossTileID];
+                          e22 && (this.placedOrientations[t5.crossTileID] = e22, a3 = e22, this.markUsedOrientation(s22, a3, t5));
+                        }
+                        return a3;
+                      }, o3 = (i4, a3) => {
+                        if (s22.allowVerticalPlacement && t5.numVerticalGlyphVertices > 0 && p3.verticalTextBox) {
+                          for (const t6 of s22.writingModes) if (t6 === e2.ah.vertical ? (L22 = a3(), F22 = L22) : L22 = i4(), L22 && L22.placeable) break;
+                        } else L22 = i4();
+                      }, c3 = t5.textAnchorOffsetStartIndex, u3 = t5.textAnchorOffsetEndIndex;
+                      if (u3 === c3) {
+                        const a3 = (e22, i4) => {
+                          const a4 = this.collisionIndex.placeCollisionBox(e22, x22, d22, l22, h22, I22, T22, r22, f22.predicate, z22);
+                          return a4 && a4.placeable && (this.markUsedOrientation(s22, i4, t5), this.placedOrientations[t5.crossTileID] = i4), a4;
+                        };
+                        o3(() => a3(q22, e2.ah.horizontal), () => {
+                          const i4 = p3.verticalTextBox;
+                          return s22.allowVerticalPlacement && t5.numVerticalGlyphVertices > 0 && i4 ? a3(i4, e2.ah.vertical) : { box: null, offscreen: null };
+                        }), i3(L22 && L22.placeable);
+                      } else {
+                        let _3 = e2.aq[null === (D4 = null === (P3 = this.prevPlacement) || void 0 === P3 ? void 0 : P3.variableOffsets[t5.crossTileID]) || void 0 === D4 ? void 0 : D4.anchor];
+                        const m3 = (i4, o4, p4) => {
+                          const m4 = i4.x2 - i4.x1, g4 = i4.y2 - i4.y1, v3 = t5.textBoxScale, y3 = E3 && "never" === b22 ? o4 : null;
+                          let w4 = null, P4 = "never" === x22 ? 1 : 2, C4 = "never";
+                          _3 && P4++;
+                          for (let e22 = 0; e22 < P4; e22++) {
+                            for (let e3 = c3; e3 < u3; e3++) {
+                              const a3 = s22.textAnchorOffsets.get(e3);
+                              if (_3 && a3.textAnchor !== _3) continue;
+                              const o5 = this.attemptAnchorPlacement(a3, i4, m4, g4, v3, T22, I22, d22, l22, h22, f22, C4, t5, s22, p4, r22, n22, y3, z22);
+                              if (o5 && (w4 = o5.placedGlyphBoxes, w4 && w4.placeable)) return M22 = true, k22 = o5.shift, w4;
+                            }
+                            _3 ? _3 = null : C4 = x22;
+                          }
+                          return a22 && !w4 && (w4 = { box: this.collisionIndex.placeCollisionBox(q22, "always", d22, l22, h22, I22, T22, r22, f22.predicate, z22, new e2.P(0, 0)).box, offscreen: false, placeable: false }), w4;
+                        };
+                        o3(() => m3(q22, p3.iconBox, e2.ah.horizontal), () => {
+                          const i4 = p3.verticalTextBox;
+                          return s22.allowVerticalPlacement && (!L22 || !L22.placeable) && t5.numVerticalGlyphVertices > 0 && i4 ? m3(i4, p3.verticalIconBox, e2.ah.vertical) : { box: null, occluded: true, offscreen: null };
+                        }), L22 && (M22 = L22.placeable, R22 = L22.offscreen);
+                        const g3 = i3(L22 && L22.placeable);
+                        if (!M22 && this.prevPlacement) {
+                          const e22 = this.prevPlacement.variableOffsets[t5.crossTileID];
+                          e22 && (this.variableOffsets[t5.crossTileID] = e22, this.markUsedJustification(s22, e22.anchor, t5, g3));
+                        }
+                      }
+                    }
+                    if (B3 = L22, M22 = B3 && B3.placeable, R22 = B3 && B3.offscreen, t5.useRuntimeCollisionCircles) {
+                      const i3 = s22.text.placedSymbolArray.get(t5.centerJustifiedTextSymbolIndex), n3 = e2.ai(s22.textSizeData, m22, i3), d3 = o22.get("text-padding");
+                      O22 = this.collisionIndex.placeCollisionCircles(x22, i3, s22.lineVertexArray, s22.glyphOffsetArray, n3, l22, h22, c22, u22, a22, I22, f22.predicate, t5.collisionCircleDiameter, d3, r22, z22), O22.circles.length && O22.collisionDetected && !a22 && e2.w("Collisions detected, but collision boxes are not shown"), M22 = y22 || O22.circles.length > 0 && !O22.collisionDetected, R22 = R22 && O22.offscreen;
+                    }
+                    if (p3.iconFeatureIndex && (Z22 = p3.iconFeatureIndex), p3.iconBox) {
+                      const t6 = (t7) => this.collisionIndex.placeCollisionBox(t7, b22, d22, l22, h22, I22, T22, n22, f22.predicate, z22, E3 && k22 ? k22 : void 0);
+                      F22 && F22.placeable && p3.verticalIconBox ? (N22 = t6(p3.verticalIconBox), A3 = N22.placeable) : (N22 = t6(p3.iconBox), A3 = N22.placeable), R22 = R22 && N22.offscreen;
+                    }
+                    const V22 = g22 || 0 === t5.numHorizontalGlyphVertices && 0 === t5.numVerticalGlyphVertices, G22 = v22 || 0 === t5.numIconVertices;
+                    V22 || G22 ? G22 ? V22 || (A3 = A3 && M22) : M22 = A3 && M22 : A3 = M22 = A3 && M22;
+                    const H22 = A3 && N22.placeable;
+                    if (M22 && B3.placeable && this.collisionIndex.insertCollisionBox(B3.box, x22, o22.get("text-ignore-placement"), s22.bucketInstanceId, F22 && F22.placeable && j22 ? j22 : U22, f22.ID), H22 && this.collisionIndex.insertCollisionBox(N22.box, b22, o22.get("icon-ignore-placement"), s22.bucketInstanceId, Z22, f22.ID), O22 && M22 && this.collisionIndex.insertCollisionCircles(O22.circles, x22, o22.get("text-ignore-placement"), s22.bucketInstanceId, U22, f22.ID), a22 && this.storeCollisionData(s22.bucketInstanceId, w3, p3, B3, N22, O22), 0 === t5.crossTileID) throw new Error("symbolInstance.crossTileID can't be 0");
+                    if (0 === s22.bucketInstanceId) throw new Error("bucket.bucketInstanceId can't be 0");
+                    this.placements[t5.crossTileID] = new Ut(M22 || C3, A3 || S22, R22 || s22.justReloaded), i22[t5.crossTileID] = true;
+                  };
+                  if (P22) {
+                    if (0 !== t42.symbolInstanceStart) throw new Error("bucket.bucketInstanceId should be 0");
+                    const e22 = s22.getSortedSymbolIndexes(this.transform.angle);
+                    for (let t5 = e22.length - 1; t5 >= 0; --t5) {
+                      const i3 = e22[t5];
+                      D3(s22.symbolInstances.get(i3), s22.collisionArrays[i3], i3);
+                    }
+                  } else for (let e22 = t42.symbolInstanceStart; e22 < t42.symbolInstanceEnd; e22++) D3(s22.symbolInstances.get(e22), s22.collisionArrays[e22], e22);
+                  if (a22 && s22.bucketInstanceId in this.collisionCircleArrays) {
+                    const t5 = this.collisionCircleArrays[s22.bucketInstanceId];
+                    e2.as(t5.invProjMatrix, l22), t5.viewportMatrix = this.collisionIndex.getViewportMatrix();
+                  }
+                  s22.justReloaded = false;
+                }
+                storeCollisionData(t42, e22, i22, a22, s22, o22) {
+                  if (i22.textBox || i22.iconBox) {
+                    let o3, r22;
+                    this.collisionBoxArrays.has(t42) ? o3 = this.collisionBoxArrays.get(t42) : (o3 = /* @__PURE__ */ new Map(), this.collisionBoxArrays.set(t42, o3)), o3.has(e22) ? r22 = o3.get(e22) : (r22 = { text: null, icon: null }, o3.set(e22, r22)), i22.textBox && (r22.text = a22.box), i22.iconBox && (r22.icon = s22.box);
+                  }
+                  if (o22) {
+                    let e3 = this.collisionCircleArrays[t42];
+                    void 0 === e3 && (e3 = this.collisionCircleArrays[t42] = new jt());
+                    for (let t5 = 0; t5 < o22.circles.length; t5 += 4) e3.circles.push(o22.circles[t5 + 0]), e3.circles.push(o22.circles[t5 + 1]), e3.circles.push(o22.circles[t5 + 2]), e3.circles.push(o22.collisionDetected ? 1 : 0);
+                  }
+                }
+                markUsedJustification(t42, i22, a22, s22) {
+                  let o22;
+                  o22 = s22 === e2.ah.vertical ? a22.verticalPlacedTextSymbolIndex : { left: a22.leftJustifiedTextSymbolIndex, center: a22.centerJustifiedTextSymbolIndex, right: a22.rightJustifiedTextSymbolIndex }[e2.at(i22)];
+                  const r22 = [a22.leftJustifiedTextSymbolIndex, a22.centerJustifiedTextSymbolIndex, a22.rightJustifiedTextSymbolIndex, a22.verticalPlacedTextSymbolIndex];
+                  for (const e22 of r22) e22 >= 0 && (t42.text.placedSymbolArray.get(e22).crossTileID = o22 >= 0 && e22 !== o22 ? 0 : a22.crossTileID);
+                }
+                markUsedOrientation(t42, i22, a22) {
+                  const s22 = i22 === e2.ah.horizontal || i22 === e2.ah.horizontalOnly ? i22 : 0, o22 = i22 === e2.ah.vertical ? i22 : 0, r22 = [a22.leftJustifiedTextSymbolIndex, a22.centerJustifiedTextSymbolIndex, a22.rightJustifiedTextSymbolIndex];
+                  for (const e22 of r22) t42.text.placedSymbolArray.get(e22).placedOrientation = s22;
+                  a22.verticalPlacedTextSymbolIndex && (t42.text.placedSymbolArray.get(a22.verticalPlacedTextSymbolIndex).placedOrientation = o22);
+                }
+                commit(t42) {
+                  this.commitTime = t42, this.zoomAtLastRecencyCheck = this.transform.zoom;
+                  const e22 = this.prevPlacement;
+                  let i22 = false;
+                  this.prevZoomAdjustment = e22 ? e22.zoomAdjustment(this.transform.zoom) : 0;
+                  const a22 = e22 ? e22.symbolFadeChange(t42) : 1, s22 = e22 ? e22.opacities : {}, o22 = e22 ? e22.variableOffsets : {}, r22 = e22 ? e22.placedOrientations : {};
+                  for (const t5 in this.placements) {
+                    const e3 = this.placements[t5], o3 = s22[t5];
+                    o3 ? (this.opacities[t5] = new Nt(o3, a22, e3.text, e3.icon), i22 = i22 || e3.text !== o3.text.placed || e3.icon !== o3.icon.placed) : (this.opacities[t5] = new Nt(null, a22, e3.text, e3.icon, e3.skipFade), i22 = i22 || e3.text || e3.icon);
+                  }
+                  for (const t5 in s22) {
+                    const e3 = s22[t5];
+                    if (!this.opacities[t5]) {
+                      const s3 = new Nt(e3, a22, false, false);
+                      s3.isHidden() || (this.opacities[t5] = s3, i22 = i22 || e3.text.placed || e3.icon.placed);
+                    }
+                  }
+                  for (const t5 in o22) this.variableOffsets[t5] || !this.opacities[t5] || this.opacities[t5].isHidden() || (this.variableOffsets[t5] = o22[t5]);
+                  for (const t5 in r22) this.placedOrientations[t5] || !this.opacities[t5] || this.opacities[t5].isHidden() || (this.placedOrientations[t5] = r22[t5]);
+                  if (e22 && void 0 === e22.lastPlacementChangeTime) throw new Error("Last placement time for previous placement is not defined");
+                  i22 ? this.lastPlacementChangeTime = t42 : "number" != typeof this.lastPlacementChangeTime && (this.lastPlacementChangeTime = e22 ? e22.lastPlacementChangeTime : t42);
+                }
+                updateLayerOpacities(t42, e22) {
+                  const i22 = {};
+                  for (const a22 of e22) {
+                    const e3 = a22.getBucket(t42);
+                    e3 && a22.latestFeatureIndex && t42.id === e3.layerIds[0] && this.updateBucketOpacities(e3, a22.tileID, i22, a22.collisionBoxArray);
+                  }
+                }
+                updateBucketOpacities(t42, i22, a22, s22) {
+                  t42.hasTextData() && (t42.text.opacityVertexArray.clear(), t42.text.hasVisibleVertices = false), t42.hasIconData() && (t42.icon.opacityVertexArray.clear(), t42.icon.hasVisibleVertices = false), t42.hasIconCollisionBoxData() && t42.iconCollisionBox.collisionVertexArray.clear(), t42.hasTextCollisionBoxData() && t42.textCollisionBox.collisionVertexArray.clear();
+                  const o22 = t42.layers[0], r22 = o22.layout, n22 = new Nt(null, 0, false, false, true), l22 = r22.get("text-allow-overlap"), h22 = r22.get("icon-allow-overlap"), c22 = o22._unevaluatedLayout.hasValue("text-variable-anchor") || o22._unevaluatedLayout.hasValue("text-variable-anchor-offset"), u22 = "map" === r22.get("text-rotation-alignment"), d22 = "map" === r22.get("text-pitch-alignment"), _22 = "none" !== r22.get("icon-text-fit"), p22 = new Nt(null, 0, l22 && (h22 || !t42.hasIconData() || r22.get("icon-optional")), h22 && (l22 || !t42.hasTextData() || r22.get("text-optional")), true);
+                  !t42.collisionArrays && s22 && (t42.hasIconCollisionBoxData() || t42.hasTextCollisionBoxData()) && t42.deserializeCollisionBoxes(s22);
+                  const m22 = (t5, e22, i3) => {
+                    for (let a3 = 0; a3 < e22 / 4; a3++) t5.opacityVertexArray.emplaceBack(i3);
+                    t5.hasVisibleVertices = t5.hasVisibleVertices || i3 !== ee2;
+                  }, f22 = this.collisionBoxArrays.get(t42.bucketInstanceId);
+                  for (let i3 = 0; i3 < t42.symbolInstances.length; i3++) {
+                    const s3 = t42.symbolInstances.get(i3), { numHorizontalGlyphVertices: o3, numVerticalGlyphVertices: r3, crossTileID: l3 } = s3;
+                    let h3 = this.opacities[l3];
+                    a22[l3] ? h3 = n22 : h3 || (h3 = p22, this.opacities[l3] = h3), a22[l3] = true;
+                    const g22 = s3.numIconVertices > 0, v22 = this.placedOrientations[s3.crossTileID], x22 = v22 === e2.ah.vertical, y22 = v22 === e2.ah.horizontal || v22 === e2.ah.horizontalOnly;
+                    if (o3 > 0 || r3 > 0) {
+                      const e22 = te2(h3.text);
+                      m22(t42.text, o3, x22 ? ee2 : e22), m22(t42.text, r3, y22 ? ee2 : e22);
+                      const i4 = h3.text.isHidden();
+                      [s3.rightJustifiedTextSymbolIndex, s3.centerJustifiedTextSymbolIndex, s3.leftJustifiedTextSymbolIndex].forEach((e3) => {
+                        e3 >= 0 && (t42.text.placedSymbolArray.get(e3).hidden = i4 || x22 ? 1 : 0);
+                      }), s3.verticalPlacedTextSymbolIndex >= 0 && (t42.text.placedSymbolArray.get(s3.verticalPlacedTextSymbolIndex).hidden = i4 || y22 ? 1 : 0);
+                      const a3 = this.variableOffsets[s3.crossTileID];
+                      a3 && this.markUsedJustification(t42, a3.anchor, s3, v22);
+                      const n3 = this.placedOrientations[s3.crossTileID];
+                      n3 && (this.markUsedJustification(t42, "left", s3, n3), this.markUsedOrientation(t42, n3, s3));
+                    }
+                    if (g22) {
+                      const e22 = te2(h3.icon), i4 = !(_22 && s3.verticalPlacedIconSymbolIndex && x22);
+                      s3.placedIconSymbolIndex >= 0 && (m22(t42.icon, s3.numIconVertices, i4 ? e22 : ee2), t42.icon.placedSymbolArray.get(s3.placedIconSymbolIndex).hidden = h3.icon.isHidden()), s3.verticalPlacedIconSymbolIndex >= 0 && (m22(t42.icon, s3.numVerticalIconVertices, i4 ? ee2 : e22), t42.icon.placedSymbolArray.get(s3.verticalPlacedIconSymbolIndex).hidden = h3.icon.isHidden());
+                    }
+                    const b22 = f22 && f22.has(i3) ? f22.get(i3) : { text: null, icon: null };
+                    if (t42.hasIconCollisionBoxData() || t42.hasTextCollisionBoxData()) {
+                      const a3 = t42.collisionArrays[i3];
+                      if (a3) {
+                        let i4 = new e2.P(0, 0);
+                        if (a3.textBox || a3.verticalTextBox) {
+                          let e22 = true;
+                          if (c22) {
+                            const t5 = this.variableOffsets[l3];
+                            t5 ? (i4 = Vt(t5.anchor, t5.width, t5.height, t5.textOffset, t5.textBoxScale), u22 && i4._rotate(d22 ? this.transform.angle : -this.transform.angle)) : e22 = false;
+                          }
+                          if (a3.textBox || a3.verticalTextBox) {
+                            let s4;
+                            a3.textBox && (s4 = x22), a3.verticalTextBox && (s4 = y22), Ht(t42.textCollisionBox.collisionVertexArray, h3.text.placed, !e22 || s4, b22.text, i4.x, i4.y);
+                          }
+                        }
+                        if (a3.iconBox || a3.verticalIconBox) {
+                          const e22 = Boolean(!y22 && a3.verticalIconBox);
+                          let s4;
+                          a3.iconBox && (s4 = e22), a3.verticalIconBox && (s4 = !e22), Ht(t42.iconCollisionBox.collisionVertexArray, h3.icon.placed, s4, b22.icon, _22 ? i4.x : 0, _22 ? i4.y : 0);
+                        }
+                      }
+                    }
+                  }
+                  if (t42.sortFeatures(this.transform.angle), this.retainedQueryData[t42.bucketInstanceId] && (this.retainedQueryData[t42.bucketInstanceId].featureSortOrder = t42.featureSortOrder), t42.hasTextData() && t42.text.opacityVertexBuffer && t42.text.opacityVertexBuffer.updateData(t42.text.opacityVertexArray), t42.hasIconData() && t42.icon.opacityVertexBuffer && t42.icon.opacityVertexBuffer.updateData(t42.icon.opacityVertexArray), t42.hasIconCollisionBoxData() && t42.iconCollisionBox.collisionVertexBuffer && t42.iconCollisionBox.collisionVertexBuffer.updateData(t42.iconCollisionBox.collisionVertexArray), t42.hasTextCollisionBoxData() && t42.textCollisionBox.collisionVertexBuffer && t42.textCollisionBox.collisionVertexBuffer.updateData(t42.textCollisionBox.collisionVertexArray), t42.text.opacityVertexArray.length !== t42.text.layoutVertexArray.length / 4) throw new Error(`bucket.text.opacityVertexArray.length (= ${t42.text.opacityVertexArray.length}) !== bucket.text.layoutVertexArray.length (= ${t42.text.layoutVertexArray.length}) / 4`);
+                  if (t42.icon.opacityVertexArray.length !== t42.icon.layoutVertexArray.length / 4) throw new Error(`bucket.icon.opacityVertexArray.length (= ${t42.icon.opacityVertexArray.length}) !== bucket.icon.layoutVertexArray.length (= ${t42.icon.layoutVertexArray.length}) / 4`);
+                  if (t42.bucketInstanceId in this.collisionCircleArrays) {
+                    const e22 = this.collisionCircleArrays[t42.bucketInstanceId];
+                    t42.placementInvProjMatrix = e22.invProjMatrix, t42.placementViewportMatrix = e22.viewportMatrix, t42.collisionCircleArray = e22.circles, delete this.collisionCircleArrays[t42.bucketInstanceId];
+                  }
+                }
+                symbolFadeChange(t42) {
+                  return 0 === this.fadeDuration ? 1 : (t42 - this.commitTime) / this.fadeDuration + this.prevZoomAdjustment;
+                }
+                zoomAdjustment(t42) {
+                  return Math.max(0, (this.transform.zoom - t42) / 1.5);
+                }
+                hasTransitions(t42) {
+                  return this.stale || t42 - this.lastPlacementChangeTime < this.fadeDuration;
+                }
+                stillRecent(t42, e22) {
+                  const i22 = this.zoomAtLastRecencyCheck === e22 ? 1 - this.zoomAdjustment(e22) : 1;
+                  return this.zoomAtLastRecencyCheck = e22, this.commitTime + this.fadeDuration * i22 > t42;
+                }
+                setStale() {
+                  this.stale = true;
+                }
+              }
+              function Ht(t42, e22, i22, a22, s22, o22) {
+                a22 && 0 !== a22.length || (a22 = [0, 0, 0, 0]);
+                const r22 = a22[0] - Lt, n22 = a22[1] - Lt, l22 = a22[2] - Lt, h22 = a22[3] - Lt;
+                t42.emplaceBack(e22 ? 1 : 0, i22 ? 1 : 0, s22 || 0, o22 || 0, r22, n22), t42.emplaceBack(e22 ? 1 : 0, i22 ? 1 : 0, s22 || 0, o22 || 0, l22, n22), t42.emplaceBack(e22 ? 1 : 0, i22 ? 1 : 0, s22 || 0, o22 || 0, l22, h22), t42.emplaceBack(e22 ? 1 : 0, i22 ? 1 : 0, s22 || 0, o22 || 0, r22, h22);
+              }
+              const Wt = Math.pow(2, 25), $t = Math.pow(2, 24), Xt = Math.pow(2, 17), Kt = Math.pow(2, 16), Jt = Math.pow(2, 9), Yt = Math.pow(2, 8), Qt = Math.pow(2, 1);
+              function te2(t42) {
+                if (0 === t42.opacity && !t42.placed) return 0;
+                if (1 === t42.opacity && t42.placed) return 4294967295;
+                const e22 = t42.placed ? 1 : 0, i22 = Math.floor(127 * t42.opacity);
+                return i22 * Wt + e22 * $t + i22 * Xt + e22 * Kt + i22 * Jt + e22 * Yt + i22 * Qt + e22;
+              }
+              const ee2 = 0;
+              function ie2() {
+                return { isOccluded: (t42, e22, i22) => false, getPitchedTextCorrection: (t42, e22, i22) => 1, get useSpecialProjectionForSymbols() {
+                  return false;
+                }, projectTileCoordinates(t42, e22, i22, a22) {
+                  throw new Error("Not implemented.");
+                }, translatePosition: (t42, e22, i22, a22) => function(t5, e3, i3, a3, s22 = false) {
+                  if (!i3[0] && !i3[1]) return [0, 0];
+                  const o22 = s22 ? "map" === a3 ? t5.angle : 0 : "viewport" === a3 ? -t5.angle : 0;
+                  if (o22) {
+                    const t6 = Math.sin(o22), e4 = Math.cos(o22);
+                    i3 = [i3[0] * e4 - i3[1] * t6, i3[0] * t6 + i3[1] * e4];
+                  }
+                  return [s22 ? i3[0] : Bt(e3, i3[0], t5.zoom), s22 ? i3[1] : Bt(e3, i3[1], t5.zoom)];
+                }(t42, e22, i22, a22), getCircleRadiusCorrection: (t42) => 1 };
+              }
+              class ae2 {
+                constructor(t42) {
+                  this._sortAcrossTiles = "viewport-y" !== t42.layout.get("symbol-z-order") && !t42.layout.get("symbol-sort-key").isConstant(), this._currentTileIndex = 0, this._currentPartIndex = 0, this._seenCrossTileIDs = {}, this._bucketParts = [];
+                }
+                continuePlacement(t42, e22, i22, a22, s22) {
+                  const o22 = this._bucketParts;
+                  for (; this._currentTileIndex < t42.length; ) if (e22.getBucketParts(o22, a22, t42[this._currentTileIndex], this._sortAcrossTiles), this._currentTileIndex++, s22()) return true;
+                  for (this._sortAcrossTiles && (this._sortAcrossTiles = false, o22.sort((t5, e3) => t5.sortKey - e3.sortKey)); this._currentPartIndex < o22.length; ) if (e22.placeLayerBucketPart(o22[this._currentPartIndex], this._seenCrossTileIDs, i22), this._currentPartIndex++, s22()) return true;
+                  return false;
+                }
+              }
+              class se2 {
+                constructor(t42, e22, i22, a22, s22, o22, r22, n22) {
+                  this.placement = new Gt(t42, ie2(), e22, o22, r22, n22), this._currentPlacementIndex = i22.length - 1, this._forceFullPlacement = a22, this._showCollisionBoxes = s22, this._done = false;
+                }
+                isDone() {
+                  return this._done;
+                }
+                continuePlacement(t42, e22, i22) {
+                  const a22 = o2.now(), s22 = () => !this._forceFullPlacement && o2.now() - a22 > 2;
+                  for (; this._currentPlacementIndex >= 0; ) {
+                    const a3 = e22[t42[this._currentPlacementIndex]], o22 = this.placement.collisionIndex.transform.zoom;
+                    if ("symbol" === a3.type && (!a3.minzoom || a3.minzoom <= o22) && (!a3.maxzoom || a3.maxzoom > o22)) {
+                      if (this._inProgressLayer || (this._inProgressLayer = new ae2(a3)), this._inProgressLayer.continuePlacement(i22[a3.source], this.placement, this._showCollisionBoxes, a3, s22)) return;
+                      delete this._inProgressLayer;
+                    }
+                    this._currentPlacementIndex--;
+                  }
+                  this._done = true;
+                }
+                commit(t42) {
+                  return this.placement.commit(t42), this.placement;
+                }
+              }
+              const oe2 = 512 / e2.X / 2;
+              class re2 {
+                constructor(t42, i22, a22) {
+                  this.tileID = t42, this.bucketInstanceId = a22, this._symbolsByKey = {};
+                  const s22 = /* @__PURE__ */ new Map();
+                  for (let t5 = 0; t5 < i22.length; t5++) {
+                    const e22 = i22.get(t5), a3 = e22.key, o22 = s22.get(a3);
+                    o22 ? o22.push(e22) : s22.set(a3, [e22]);
+                  }
+                  for (const [t5, i3] of s22) {
+                    const a3 = { positions: i3.map((t6) => ({ x: Math.floor(t6.anchorX * oe2), y: Math.floor(t6.anchorY * oe2) })), crossTileIDs: i3.map((t6) => t6.crossTileID) };
+                    if (a3.positions.length > 128) {
+                      const t6 = new e2.av(a3.positions.length, 16, Uint16Array);
+                      for (const { x: e22, y: i4 } of a3.positions) t6.add(e22, i4);
+                      t6.finish(), delete a3.positions, a3.index = t6;
+                    }
+                    this._symbolsByKey[t5] = a3;
+                  }
+                }
+                getScaledCoordinates(t42, i22) {
+                  const { x: a22, y: s22, z: o22 } = this.tileID.canonical, { x: r22, y: n22, z: l22 } = i22.canonical, h22 = oe2 / Math.pow(2, l22 - o22), c22 = (n22 * e2.X + t42.anchorY) * h22, u22 = s22 * e2.X * oe2;
+                  return { x: Math.floor((r22 * e2.X + t42.anchorX) * h22 - a22 * e2.X * oe2), y: Math.floor(c22 - u22) };
+                }
+                findMatches(t42, e22, i22) {
+                  const a22 = this.tileID.canonical.z < e22.canonical.z ? 1 : Math.pow(2, this.tileID.canonical.z - e22.canonical.z);
+                  for (let s22 = 0; s22 < t42.length; s22++) {
+                    const o22 = t42.get(s22);
+                    if (o22.crossTileID) continue;
+                    const r22 = this._symbolsByKey[o22.key];
+                    if (!r22) continue;
+                    const n22 = this.getScaledCoordinates(o22, e22);
+                    if (r22.index) {
+                      const t5 = r22.index.range(n22.x - a22, n22.y - a22, n22.x + a22, n22.y + a22).sort();
+                      for (const e3 of t5) {
+                        const t6 = r22.crossTileIDs[e3];
+                        if (!i22[t6]) {
+                          i22[t6] = true, o22.crossTileID = t6;
+                          break;
+                        }
+                      }
+                    } else if (r22.positions) for (let t5 = 0; t5 < r22.positions.length; t5++) {
+                      const e3 = r22.positions[t5], s3 = r22.crossTileIDs[t5];
+                      if (Math.abs(e3.x - n22.x) <= a22 && Math.abs(e3.y - n22.y) <= a22 && !i22[s3]) {
+                        i22[s3] = true, o22.crossTileID = s3;
+                        break;
+                      }
+                    }
+                  }
+                }
+                getCrossTileIDsLists() {
+                  return Object.values(this._symbolsByKey).map(({ crossTileIDs: t42 }) => t42);
+                }
+              }
+              class ne2 {
+                constructor() {
+                  this.maxCrossTileID = 0;
+                }
+                generate() {
+                  return ++this.maxCrossTileID;
+                }
+              }
+              class le2 {
+                constructor() {
+                  this.indexes = {}, this.usedCrossTileIDs = {}, this.lng = 0;
+                }
+                handleWrapJump(t42) {
+                  const e22 = Math.round((t42 - this.lng) / 360);
+                  if (0 !== e22) for (const t5 in this.indexes) {
+                    const i22 = this.indexes[t5], a22 = {};
+                    for (const t6 in i22) {
+                      const s22 = i22[t6];
+                      s22.tileID = s22.tileID.unwrapTo(s22.tileID.wrap + e22), a22[s22.tileID.key] = s22;
+                    }
+                    this.indexes[t5] = a22;
+                  }
+                  this.lng = t42;
+                }
+                addBucket(t42, e22, i22) {
+                  if (this.indexes[t42.overscaledZ] && this.indexes[t42.overscaledZ][t42.key]) {
+                    if (this.indexes[t42.overscaledZ][t42.key].bucketInstanceId === e22.bucketInstanceId) return false;
+                    this.removeBucketCrossTileIDs(t42.overscaledZ, this.indexes[t42.overscaledZ][t42.key]);
+                  }
+                  for (let t5 = 0; t5 < e22.symbolInstances.length; t5++) e22.symbolInstances.get(t5).crossTileID = 0;
+                  this.usedCrossTileIDs[t42.overscaledZ] || (this.usedCrossTileIDs[t42.overscaledZ] = {});
+                  const a22 = this.usedCrossTileIDs[t42.overscaledZ];
+                  for (const i3 in this.indexes) {
+                    const s22 = this.indexes[i3];
+                    if (Number(i3) > t42.overscaledZ) for (const i4 in s22) {
+                      const o22 = s22[i4];
+                      o22.tileID.isChildOf(t42) && o22.findMatches(e22.symbolInstances, t42, a22);
+                    }
+                    else {
+                      const o22 = s22[t42.scaledTo(Number(i3)).key];
+                      o22 && o22.findMatches(e22.symbolInstances, t42, a22);
+                    }
+                  }
+                  for (let t5 = 0; t5 < e22.symbolInstances.length; t5++) {
+                    const s22 = e22.symbolInstances.get(t5);
+                    s22.crossTileID || (s22.crossTileID = i22.generate(), a22[s22.crossTileID] = true);
+                  }
+                  return void 0 === this.indexes[t42.overscaledZ] && (this.indexes[t42.overscaledZ] = {}), this.indexes[t42.overscaledZ][t42.key] = new re2(t42, e22.symbolInstances, e22.bucketInstanceId), true;
+                }
+                removeBucketCrossTileIDs(t42, e22) {
+                  for (const i22 of e22.getCrossTileIDsLists()) for (const e3 of i22) delete this.usedCrossTileIDs[t42][e3];
+                }
+                removeStaleBuckets(t42) {
+                  let e22 = false;
+                  for (const i22 in this.indexes) {
+                    const a22 = this.indexes[i22];
+                    for (const s22 in a22) t42[a22[s22].bucketInstanceId] || (this.removeBucketCrossTileIDs(i22, a22[s22]), delete a22[s22], e22 = true);
+                  }
+                  return e22;
+                }
+              }
+              class he2 {
+                constructor() {
+                  this.layerIndexes = {}, this.crossTileIDs = new ne2(), this.maxBucketInstanceId = 0, this.bucketsInCurrentPlacement = {};
+                }
+                addLayer(t42, e22, i22) {
+                  let a22 = this.layerIndexes[t42.id];
+                  void 0 === a22 && (a22 = this.layerIndexes[t42.id] = new le2());
+                  let s22 = false;
+                  const o22 = {};
+                  a22.handleWrapJump(i22);
+                  for (const i3 of e22) {
+                    const e3 = i3.getBucket(t42);
+                    e3 && t42.id === e3.layerIds[0] && (e3.bucketInstanceId || (e3.bucketInstanceId = ++this.maxBucketInstanceId), a22.addBucket(i3.tileID, e3, this.crossTileIDs) && (s22 = true), o22[e3.bucketInstanceId] = true);
+                  }
+                  return a22.removeStaleBuckets(o22) && (s22 = true), s22;
+                }
+                pruneUnusedLayers(t42) {
+                  const e22 = {};
+                  t42.forEach((t5) => {
+                    e22[t5] = true;
+                  });
+                  for (const t5 in this.layerIndexes) e22[t5] || delete this.layerIndexes[t5];
+                }
+              }
+              const ce2 = (t42, i22) => e2.t(t42, i22 && i22.filter((t5) => "source.canvas" !== t5.identifier)), ue2 = e2.aw();
+              class de2 extends e2.E {
+                constructor(t42, i22 = {}) {
+                  super(), this._rtlPluginLoaded = () => {
+                    for (const t5 in this.sourceCaches) {
+                      const e22 = this.sourceCaches[t5].getSource().type;
+                      "vector" !== e22 && "geojson" !== e22 || this.sourceCaches[t5].reload();
+                    }
+                  }, this.map = t42, this.dispatcher = new U2(N2(), t42._getMapId()), this.dispatcher.registerMessageHandler("GG", (t5, e22) => this.getGlyphs(t5, e22)), this.dispatcher.registerMessageHandler("GI", (t5, e22) => this.getImages(t5, e22)), this.imageManager = new T2(), this.imageManager.setEventedParent(this), this.glyphManager = new C22(t42._requestManager, i22.localIdeographFontFamily), this.lineAtlas = new R2(256, 512), this.crossTileSymbolIndex = new he2(), this._spritesImagesIds = {}, this._layers = {}, this._order = [], this.sourceCaches = {}, this.zoomHistory = new e2.ax(), this._loaded = false, this._availableImages = [], this._resetUpdates(), this.dispatcher.broadcast("SR", e2.ay()), nt2().on(st2, this._rtlPluginLoaded), this.on("data", (t5) => {
+                    if ("source" !== t5.dataType || "metadata" !== t5.sourceDataType) return;
+                    const e22 = this.sourceCaches[t5.sourceId];
+                    if (!e22) return;
+                    const i3 = e22.getSource();
+                    if (i3 && i3.vectorLayerIds) for (const t6 in this._layers) {
+                      const e3 = this._layers[t6];
+                      e3.source === i3.id && this._validateLayer(e3);
+                    }
+                  });
+                }
+                loadURL(t42, i22 = {}, a22) {
+                  this.fire(new e2.k("dataloading", { dataType: "style" })), i22.validate = "boolean" != typeof i22.validate || i22.validate;
+                  const s22 = this.map._requestManager.transformRequest(t42, "Style");
+                  this._loadStyleRequest = new AbortController();
+                  const o22 = this._loadStyleRequest;
+                  e2.h(s22, this._loadStyleRequest).then((t5) => {
+                    this._loadStyleRequest = null, this._load(t5.data, i22, a22);
+                  }).catch((t5) => {
+                    this._loadStyleRequest = null, t5 && !o22.signal.aborted && this.fire(new e2.j(t5));
+                  });
+                }
+                loadJSON(t42, i22 = {}, a22) {
+                  this.fire(new e2.k("dataloading", { dataType: "style" })), this._frameRequest = new AbortController(), o2.frameAsync(this._frameRequest).then(() => {
+                    this._frameRequest = null, i22.validate = false !== i22.validate, this._load(t42, i22, a22);
+                  }).catch(() => {
+                  });
+                }
+                loadEmpty() {
+                  this.fire(new e2.k("dataloading", { dataType: "style" })), this._load(ue2, { validate: false });
+                }
+                _load(t42, i22, a22) {
+                  var s22;
+                  const o22 = i22.transformStyle ? i22.transformStyle(a22, t42) : t42;
+                  if (!i22.validate || !ce2(this, e2.u(o22))) {
+                    this._loaded = true, this.stylesheet = o22;
+                    for (const t5 in o22.sources) this.addSource(t5, o22.sources[t5], { validate: false });
+                    o22.sprite ? this._loadSprite(o22.sprite) : this.imageManager.setLoaded(true), this.glyphManager.setURL(o22.glyphs), this._createLayers(), this.light = new D22(this.stylesheet.light), this.sky = new A22(this.stylesheet.sky), this.map.setTerrain(null !== (s22 = this.stylesheet.terrain) && void 0 !== s22 ? s22 : null), this.fire(new e2.k("data", { dataType: "style" })), this.fire(new e2.k("style.load"));
+                  }
+                }
+                _createLayers() {
+                  const t42 = e2.az(this.stylesheet.layers);
+                  this.dispatcher.broadcast("SL", t42), this._order = t42.map((t5) => t5.id), this._layers = {}, this._serializedLayers = null;
+                  for (const i22 of t42) {
+                    const t5 = e2.aA(i22);
+                    t5.setEventedParent(this, { layer: { id: i22.id } }), this._layers[i22.id] = t5;
+                  }
+                }
+                _loadSprite(t42, i22 = false, a22 = void 0) {
+                  let s22;
+                  this.imageManager.setLoaded(false), this._spriteRequest = new AbortController(), function(t5, i3, a3, s3) {
+                    return e2._(this, void 0, void 0, function* () {
+                      const r22 = x2(t5), n22 = a3 > 1 ? "@2x" : "", l22 = {}, h22 = {};
+                      for (const { id: t6, url: a4 } of r22) {
+                        const o22 = i3.transformRequest(y2(a4, n22, ".json"), "SpriteJSON");
+                        l22[t6] = e2.h(o22, s3);
+                        const r3 = i3.transformRequest(y2(a4, n22, ".png"), "SpriteImage");
+                        h22[t6] = _2.getImage(r3, s3);
+                      }
+                      return yield Promise.all([...Object.values(l22), ...Object.values(h22)]), function(t6, i4) {
+                        return e2._(this, void 0, void 0, function* () {
+                          const e22 = {};
+                          for (const a4 in t6) {
+                            e22[a4] = {};
+                            const s4 = o2.getImageCanvasContext((yield i4[a4]).data), r3 = (yield t6[a4]).data;
+                            for (const t7 in r3) {
+                              const { width: i5, height: o22, x: n3, y: l3, sdf: h3, pixelRatio: c22, stretchX: u22, stretchY: d22, content: _22, textFitWidth: p22, textFitHeight: m22 } = r3[t7];
+                              e22[a4][t7] = { data: null, pixelRatio: c22, sdf: h3, stretchX: u22, stretchY: d22, content: _22, textFitWidth: p22, textFitHeight: m22, spriteData: { width: i5, height: o22, x: n3, y: l3, context: s4 } };
+                            }
+                          }
+                          return e22;
+                        });
+                      }(l22, h22);
+                    });
+                  }(t42, this.map._requestManager, this.map.getPixelRatio(), this._spriteRequest).then((t5) => {
+                    if (this._spriteRequest = null, t5) for (const e22 in t5) {
+                      this._spritesImagesIds[e22] = [];
+                      const a3 = this._spritesImagesIds[e22] ? this._spritesImagesIds[e22].filter((e3) => !(e3 in t5)) : [];
+                      for (const t6 of a3) this.imageManager.removeImage(t6), this._changedImages[t6] = true;
+                      for (const a4 in t5[e22]) {
+                        const s3 = "default" === e22 ? a4 : `${e22}:${a4}`;
+                        this._spritesImagesIds[e22].push(s3), s3 in this.imageManager.images ? this.imageManager.updateImage(s3, t5[e22][a4], false) : this.imageManager.addImage(s3, t5[e22][a4]), i22 && (this._changedImages[s3] = true);
+                      }
+                    }
+                  }).catch((t5) => {
+                    this._spriteRequest = null, s22 = t5, this.fire(new e2.j(s22));
+                  }).finally(() => {
+                    this.imageManager.setLoaded(true), this._availableImages = this.imageManager.listImages(), i22 && (this._changed = true), this.dispatcher.broadcast("SI", this._availableImages), this.fire(new e2.k("data", { dataType: "style" })), a22 && a22(s22);
+                  });
+                }
+                _unloadSprite() {
+                  for (const t42 of Object.values(this._spritesImagesIds).flat()) this.imageManager.removeImage(t42), this._changedImages[t42] = true;
+                  this._spritesImagesIds = {}, this._availableImages = this.imageManager.listImages(), this._changed = true, this.dispatcher.broadcast("SI", this._availableImages), this.fire(new e2.k("data", { dataType: "style" }));
+                }
+                _validateLayer(t42) {
+                  const i22 = this.sourceCaches[t42.source];
+                  if (!i22) return;
+                  const a22 = t42.sourceLayer;
+                  if (!a22) return;
+                  const s22 = i22.getSource();
+                  ("geojson" === s22.type || s22.vectorLayerIds && -1 === s22.vectorLayerIds.indexOf(a22)) && this.fire(new e2.j(new Error(`Source layer "${a22}" does not exist on source "${s22.id}" as specified by style layer "${t42.id}".`)));
+                }
+                loaded() {
+                  if (!this._loaded) return false;
+                  if (Object.keys(this._updatedSources).length) return false;
+                  for (const t42 in this.sourceCaches) if (!this.sourceCaches[t42].loaded()) return false;
+                  return !!this.imageManager.isLoaded();
+                }
+                _serializeByIds(t42, i22 = false) {
+                  const a22 = this._serializedAllLayers();
+                  if (!t42 || 0 === t42.length) return Object.values(i22 ? e2.aB(a22) : a22);
+                  const s22 = [];
+                  for (const o22 of t42) if (a22[o22]) {
+                    const t5 = i22 ? e2.aB(a22[o22]) : a22[o22];
+                    s22.push(t5);
+                  }
+                  return s22;
+                }
+                _serializedAllLayers() {
+                  let t42 = this._serializedLayers;
+                  if (t42) return t42;
+                  t42 = this._serializedLayers = {};
+                  const e22 = Object.keys(this._layers);
+                  for (const i22 of e22) {
+                    const e3 = this._layers[i22];
+                    "custom" !== e3.type && (t42[i22] = e3.serialize());
+                  }
+                  return t42;
+                }
+                hasTransitions() {
+                  if (this.light && this.light.hasTransition()) return true;
+                  if (this.sky && this.sky.hasTransition()) return true;
+                  for (const t42 in this.sourceCaches) if (this.sourceCaches[t42].hasTransition()) return true;
+                  for (const t42 in this._layers) if (this._layers[t42].hasTransition()) return true;
+                  return false;
+                }
+                _checkLoaded() {
+                  if (!this._loaded) throw new Error("Style is not done loading.");
+                }
+                update(t42) {
+                  if (!this._loaded) return;
+                  const i22 = this._changed;
+                  if (i22) {
+                    const e22 = Object.keys(this._updatedLayers), i3 = Object.keys(this._removedLayers);
+                    (e22.length || i3.length) && this._updateWorkerLayers(e22, i3);
+                    for (const t5 in this._updatedSources) {
+                      const e3 = this._updatedSources[t5];
+                      if ("reload" === e3) this._reloadSource(t5);
+                      else {
+                        if ("clear" !== e3) throw new Error(`Invalid action ${e3}`);
+                        this._clearSource(t5);
+                      }
+                    }
+                    this._updateTilesForChangedImages(), this._updateTilesForChangedGlyphs();
+                    for (const e3 in this._updatedPaintProps) this._layers[e3].updateTransitions(t42);
+                    this.light.updateTransitions(t42), this.sky.updateTransitions(t42), this._resetUpdates();
+                  }
+                  const a22 = {};
+                  for (const t5 in this.sourceCaches) {
+                    const e22 = this.sourceCaches[t5];
+                    a22[t5] = e22.used, e22.used = false;
+                  }
+                  for (const e22 of this._order) {
+                    const i3 = this._layers[e22];
+                    i3.recalculate(t42, this._availableImages), !i3.isHidden(t42.zoom) && i3.source && (this.sourceCaches[i3.source].used = true);
+                  }
+                  for (const t5 in a22) {
+                    const i3 = this.sourceCaches[t5];
+                    !!a22[t5] != !!i3.used && i3.fire(new e2.k("data", { sourceDataType: "visibility", dataType: "source", sourceId: t5 }));
+                  }
+                  this.light.recalculate(t42), this.sky.recalculate(t42), this.z = t42.zoom, i22 && this.fire(new e2.k("data", { dataType: "style" }));
+                }
+                _updateTilesForChangedImages() {
+                  const t42 = Object.keys(this._changedImages);
+                  if (t42.length) {
+                    for (const e22 in this.sourceCaches) this.sourceCaches[e22].reloadTilesForDependencies(["icons", "patterns"], t42);
+                    this._changedImages = {};
+                  }
+                }
+                _updateTilesForChangedGlyphs() {
+                  if (this._glyphsDidChange) {
+                    for (const t42 in this.sourceCaches) this.sourceCaches[t42].reloadTilesForDependencies(["glyphs"], [""]);
+                    this._glyphsDidChange = false;
+                  }
+                }
+                _updateWorkerLayers(t42, e22) {
+                  this.dispatcher.broadcast("UL", { layers: this._serializeByIds(t42, false), removedIds: e22 });
+                }
+                _resetUpdates() {
+                  this._changed = false, this._updatedLayers = {}, this._removedLayers = {}, this._updatedSources = {}, this._updatedPaintProps = {}, this._changedImages = {}, this._glyphsDidChange = false;
+                }
+                setState(t42, i22 = {}) {
+                  var a22;
+                  this._checkLoaded();
+                  const s22 = this.serialize();
+                  if (t42 = i22.transformStyle ? i22.transformStyle(s22, t42) : t42, (null === (a22 = i22.validate) || void 0 === a22 || a22) && ce2(this, e2.u(t42))) return false;
+                  (t42 = e2.aB(t42)).layers = e2.az(t42.layers);
+                  const o22 = e2.aC(s22, t42), r22 = this._getOperationsToPerform(o22);
+                  if (r22.unimplemented.length > 0) throw new Error(`Unimplemented: ${r22.unimplemented.join(", ")}.`);
+                  if (0 === r22.operations.length) return false;
+                  for (const t5 of r22.operations) t5();
+                  return this.stylesheet = t42, this._serializedLayers = null, true;
+                }
+                _getOperationsToPerform(t42) {
+                  const e22 = [], i22 = [];
+                  for (const a22 of t42) switch (a22.command) {
+                    case "setCenter":
+                    case "setZoom":
+                    case "setBearing":
+                    case "setPitch":
+                      continue;
+                    case "addLayer":
+                      e22.push(() => this.addLayer.apply(this, a22.args));
+                      break;
+                    case "removeLayer":
+                      e22.push(() => this.removeLayer.apply(this, a22.args));
+                      break;
+                    case "setPaintProperty":
+                      e22.push(() => this.setPaintProperty.apply(this, a22.args));
+                      break;
+                    case "setLayoutProperty":
+                      e22.push(() => this.setLayoutProperty.apply(this, a22.args));
+                      break;
+                    case "setFilter":
+                      e22.push(() => this.setFilter.apply(this, a22.args));
+                      break;
+                    case "addSource":
+                      e22.push(() => this.addSource.apply(this, a22.args));
+                      break;
+                    case "removeSource":
+                      e22.push(() => this.removeSource.apply(this, a22.args));
+                      break;
+                    case "setLayerZoomRange":
+                      e22.push(() => this.setLayerZoomRange.apply(this, a22.args));
+                      break;
+                    case "setLight":
+                      e22.push(() => this.setLight.apply(this, a22.args));
+                      break;
+                    case "setGeoJSONSourceData":
+                      e22.push(() => this.setGeoJSONSourceData.apply(this, a22.args));
+                      break;
+                    case "setGlyphs":
+                      e22.push(() => this.setGlyphs.apply(this, a22.args));
+                      break;
+                    case "setSprite":
+                      e22.push(() => this.setSprite.apply(this, a22.args));
+                      break;
+                    case "setSky":
+                      e22.push(() => this.setSky.apply(this, a22.args));
+                      break;
+                    case "setTerrain":
+                      e22.push(() => this.map.setTerrain.apply(this, a22.args));
+                      break;
+                    case "setTransition":
+                      e22.push(() => {
+                      });
+                      break;
+                    default:
+                      i22.push(a22.command);
+                  }
+                  return { operations: e22, unimplemented: i22 };
+                }
+                addImage(t42, i22) {
+                  if (this.getImage(t42)) return this.fire(new e2.j(new Error(`An image named "${t42}" already exists.`)));
+                  this.imageManager.addImage(t42, i22), this._afterImageUpdated(t42);
+                }
+                updateImage(t42, e22) {
+                  this.imageManager.updateImage(t42, e22);
+                }
+                getImage(t42) {
+                  return this.imageManager.getImage(t42);
+                }
+                removeImage(t42) {
+                  if (!this.getImage(t42)) return this.fire(new e2.j(new Error(`An image named "${t42}" does not exist.`)));
+                  this.imageManager.removeImage(t42), this._afterImageUpdated(t42);
+                }
+                _afterImageUpdated(t42) {
+                  this._availableImages = this.imageManager.listImages(), this._changedImages[t42] = true, this._changed = true, this.dispatcher.broadcast("SI", this._availableImages), this.fire(new e2.k("data", { dataType: "style" }));
+                }
+                listImages() {
+                  return this._checkLoaded(), this.imageManager.listImages();
+                }
+                addSource(t42, i22, a22 = {}) {
+                  if (this._checkLoaded(), void 0 !== this.sourceCaches[t42]) throw new Error(`Source "${t42}" already exists.`);
+                  if (!i22.type) throw new Error(`The type property must be defined, but only the following properties were given: ${Object.keys(i22).join(", ")}.`);
+                  if (["vector", "raster", "geojson", "video", "image"].indexOf(i22.type) >= 0 && this._validate(e2.u.source, `sources.${t42}`, i22, null, a22)) return;
+                  this.map && this.map._collectResourceTiming && (i22.collectResourceTiming = true);
+                  const s22 = this.sourceCaches[t42] = new ut2(t42, i22, this.dispatcher);
+                  s22.style = this, s22.setEventedParent(this, () => ({ isSourceLoaded: s22.loaded(), source: s22.serialize(), sourceId: t42 })), s22.onAdd(this.map), this._changed = true;
+                }
+                removeSource(t42) {
+                  if (this._checkLoaded(), void 0 === this.sourceCaches[t42]) throw new Error("There is no source with this ID");
+                  for (const i3 in this._layers) if (this._layers[i3].source === t42) return this.fire(new e2.j(new Error(`Source "${t42}" cannot be removed while layer "${i3}" is using it.`)));
+                  const i22 = this.sourceCaches[t42];
+                  delete this.sourceCaches[t42], delete this._updatedSources[t42], i22.fire(new e2.k("data", { sourceDataType: "metadata", dataType: "source", sourceId: t42 })), i22.setEventedParent(null), i22.onRemove(this.map), this._changed = true;
+                }
+                setGeoJSONSourceData(t42, e22) {
+                  if (this._checkLoaded(), void 0 === this.sourceCaches[t42]) throw new Error(`There is no source with this ID=${t42}`);
+                  const i22 = this.sourceCaches[t42].getSource();
+                  if ("geojson" !== i22.type) throw new Error(`geojsonSource.type is ${i22.type}, which is !== 'geojson`);
+                  i22.setData(e22), this._changed = true;
+                }
+                getSource(t42) {
+                  return this.sourceCaches[t42] && this.sourceCaches[t42].getSource();
+                }
+                addLayer(t42, i22, a22 = {}) {
+                  this._checkLoaded();
+                  const s22 = t42.id;
+                  if (this.getLayer(s22)) return void this.fire(new e2.j(new Error(`Layer "${s22}" already exists on this map.`)));
+                  let o22;
+                  if ("custom" === t42.type) {
+                    if (ce2(this, e2.aD(t42))) return;
+                    o22 = e2.aA(t42);
+                  } else {
+                    if ("source" in t42 && "object" == typeof t42.source && (this.addSource(s22, t42.source), t42 = e2.aB(t42), t42 = e2.e(t42, { source: s22 })), this._validate(e2.u.layer, `layers.${s22}`, t42, { arrayIndex: -1 }, a22)) return;
+                    o22 = e2.aA(t42), this._validateLayer(o22), o22.setEventedParent(this, { layer: { id: s22 } });
+                  }
+                  const r22 = i22 ? this._order.indexOf(i22) : this._order.length;
+                  if (i22 && -1 === r22) this.fire(new e2.j(new Error(`Cannot add layer "${s22}" before non-existing layer "${i22}".`)));
+                  else {
+                    if (this._order.splice(r22, 0, s22), this._layerOrderChanged = true, this._layers[s22] = o22, this._removedLayers[s22] && o22.source && "custom" !== o22.type) {
+                      const t5 = this._removedLayers[s22];
+                      delete this._removedLayers[s22], t5.type !== o22.type ? this._updatedSources[o22.source] = "clear" : (this._updatedSources[o22.source] = "reload", this.sourceCaches[o22.source].pause());
+                    }
+                    this._updateLayer(o22), o22.onAdd && o22.onAdd(this.map);
+                  }
+                }
+                moveLayer(t42, i22) {
+                  if (this._checkLoaded(), this._changed = true, !this._layers[t42]) return void this.fire(new e2.j(new Error(`The layer '${t42}' does not exist in the map's style and cannot be moved.`)));
+                  if (t42 === i22) return;
+                  const a22 = this._order.indexOf(t42);
+                  this._order.splice(a22, 1);
+                  const s22 = i22 ? this._order.indexOf(i22) : this._order.length;
+                  i22 && -1 === s22 ? this.fire(new e2.j(new Error(`Cannot move layer "${t42}" before non-existing layer "${i22}".`))) : (this._order.splice(s22, 0, t42), this._layerOrderChanged = true);
+                }
+                removeLayer(t42) {
+                  this._checkLoaded();
+                  const i22 = this._layers[t42];
+                  if (!i22) return void this.fire(new e2.j(new Error(`Cannot remove non-existing layer "${t42}".`)));
+                  i22.setEventedParent(null);
+                  const a22 = this._order.indexOf(t42);
+                  this._order.splice(a22, 1), this._layerOrderChanged = true, this._changed = true, this._removedLayers[t42] = i22, delete this._layers[t42], this._serializedLayers && delete this._serializedLayers[t42], delete this._updatedLayers[t42], delete this._updatedPaintProps[t42], i22.onRemove && i22.onRemove(this.map);
+                }
+                getLayer(t42) {
+                  return this._layers[t42];
+                }
+                getLayersOrder() {
+                  return [...this._order];
+                }
+                hasLayer(t42) {
+                  return t42 in this._layers;
+                }
+                setLayerZoomRange(t42, i22, a22) {
+                  this._checkLoaded();
+                  const s22 = this.getLayer(t42);
+                  s22 ? s22.minzoom === i22 && s22.maxzoom === a22 || (null != i22 && (s22.minzoom = i22), null != a22 && (s22.maxzoom = a22), this._updateLayer(s22)) : this.fire(new e2.j(new Error(`Cannot set the zoom range of non-existing layer "${t42}".`)));
+                }
+                setFilter(t42, i22, a22 = {}) {
+                  this._checkLoaded();
+                  const s22 = this.getLayer(t42);
+                  if (s22) {
+                    if (!e2.aE(s22.filter, i22)) return null == i22 ? (s22.filter = void 0, void this._updateLayer(s22)) : void (this._validate(e2.u.filter, `layers.${s22.id}.filter`, i22, null, a22) || (s22.filter = e2.aB(i22), this._updateLayer(s22)));
+                  } else this.fire(new e2.j(new Error(`Cannot filter non-existing layer "${t42}".`)));
+                }
+                getFilter(t42) {
+                  return e2.aB(this.getLayer(t42).filter);
+                }
+                setLayoutProperty(t42, i22, a22, s22 = {}) {
+                  this._checkLoaded();
+                  const o22 = this.getLayer(t42);
+                  o22 ? e2.aE(o22.getLayoutProperty(i22), a22) || (o22.setLayoutProperty(i22, a22, s22), this._updateLayer(o22)) : this.fire(new e2.j(new Error(`Cannot style non-existing layer "${t42}".`)));
+                }
+                getLayoutProperty(t42, i22) {
+                  const a22 = this.getLayer(t42);
+                  if (a22) return a22.getLayoutProperty(i22);
+                  this.fire(new e2.j(new Error(`Cannot get style of non-existing layer "${t42}".`)));
+                }
+                setPaintProperty(t42, i22, a22, s22 = {}) {
+                  this._checkLoaded();
+                  const o22 = this.getLayer(t42);
+                  o22 ? e2.aE(o22.getPaintProperty(i22), a22) || (o22.setPaintProperty(i22, a22, s22) && this._updateLayer(o22), this._changed = true, this._updatedPaintProps[t42] = true, this._serializedLayers = null) : this.fire(new e2.j(new Error(`Cannot style non-existing layer "${t42}".`)));
+                }
+                getPaintProperty(t42, e22) {
+                  return this.getLayer(t42).getPaintProperty(e22);
+                }
+                setFeatureState(t42, i22) {
+                  this._checkLoaded();
+                  const a22 = t42.source, s22 = t42.sourceLayer, o22 = this.sourceCaches[a22];
+                  if (void 0 === o22) return void this.fire(new e2.j(new Error(`The source '${a22}' does not exist in the map's style.`)));
+                  const r22 = o22.getSource().type;
+                  "geojson" === r22 && s22 ? this.fire(new e2.j(new Error("GeoJSON sources cannot have a sourceLayer parameter."))) : "vector" !== r22 || s22 ? (void 0 === t42.id && this.fire(new e2.j(new Error("The feature id parameter must be provided."))), o22.setFeatureState(s22, t42.id, i22)) : this.fire(new e2.j(new Error("The sourceLayer parameter must be provided for vector source types.")));
+                }
+                removeFeatureState(t42, i22) {
+                  this._checkLoaded();
+                  const a22 = t42.source, s22 = this.sourceCaches[a22];
+                  if (void 0 === s22) return void this.fire(new e2.j(new Error(`The source '${a22}' does not exist in the map's style.`)));
+                  const o22 = s22.getSource().type, r22 = "vector" === o22 ? t42.sourceLayer : void 0;
+                  "vector" !== o22 || r22 ? i22 && "string" != typeof t42.id && "number" != typeof t42.id ? this.fire(new e2.j(new Error("A feature id is required to remove its specific state property."))) : s22.removeFeatureState(r22, t42.id, i22) : this.fire(new e2.j(new Error("The sourceLayer parameter must be provided for vector source types.")));
+                }
+                getFeatureState(t42) {
+                  this._checkLoaded();
+                  const i22 = t42.source, a22 = t42.sourceLayer, s22 = this.sourceCaches[i22];
+                  if (void 0 !== s22) return "vector" !== s22.getSource().type || a22 ? (void 0 === t42.id && this.fire(new e2.j(new Error("The feature id parameter must be provided."))), s22.getFeatureState(a22, t42.id)) : void this.fire(new e2.j(new Error("The sourceLayer parameter must be provided for vector source types.")));
+                  this.fire(new e2.j(new Error(`The source '${i22}' does not exist in the map's style.`)));
+                }
+                getTransition() {
+                  return e2.e({ duration: 300, delay: 0 }, this.stylesheet && this.stylesheet.transition);
+                }
+                serialize() {
+                  if (!this._loaded) return;
+                  const t42 = e2.aF(this.sourceCaches, (t5) => t5.serialize()), i22 = this._serializeByIds(this._order, true), a22 = this.map.getTerrain() || void 0, s22 = this.stylesheet;
+                  return e2.aG({ version: s22.version, name: s22.name, metadata: s22.metadata, light: s22.light, sky: s22.sky, center: s22.center, zoom: s22.zoom, bearing: s22.bearing, pitch: s22.pitch, sprite: s22.sprite, glyphs: s22.glyphs, transition: s22.transition, sources: t42, layers: i22, terrain: a22 }, (t5) => void 0 !== t5);
+                }
+                _updateLayer(t42) {
+                  this._updatedLayers[t42.id] = true, t42.source && !this._updatedSources[t42.source] && "raster" !== this.sourceCaches[t42.source].getSource().type && (this._updatedSources[t42.source] = "reload", this.sourceCaches[t42.source].pause()), this._serializedLayers = null, this._changed = true;
+                }
+                _flattenAndSortRenderedFeatures(t42) {
+                  const e22 = (t5) => "fill-extrusion" === this._layers[t5].type, i22 = {}, a22 = [];
+                  for (let s3 = this._order.length - 1; s3 >= 0; s3--) {
+                    const o22 = this._order[s3];
+                    if (e22(o22)) {
+                      i22[o22] = s3;
+                      for (const e3 of t42) {
+                        const t5 = e3[o22];
+                        if (t5) for (const e4 of t5) a22.push(e4);
+                      }
+                    }
+                  }
+                  a22.sort((t5, e3) => e3.intersectionZ - t5.intersectionZ);
+                  const s22 = [];
+                  for (let o22 = this._order.length - 1; o22 >= 0; o22--) {
+                    const r22 = this._order[o22];
+                    if (e22(r22)) for (let t5 = a22.length - 1; t5 >= 0; t5--) {
+                      const e3 = a22[t5].feature;
+                      if (i22[e3.layer.id] < o22) break;
+                      s22.push(e3), a22.pop();
+                    }
+                    else for (const e3 of t42) {
+                      const t5 = e3[r22];
+                      if (t5) for (const e4 of t5) s22.push(e4.feature);
+                    }
+                  }
+                  return s22;
+                }
+                queryRenderedFeatures(t42, i22, a22) {
+                  i22 && i22.filter && this._validate(e2.u.filter, "queryRenderedFeatures.filter", i22.filter, null, i22);
+                  const s22 = {};
+                  if (i22 && i22.layers) {
+                    if (!Array.isArray(i22.layers)) return this.fire(new e2.j(new Error("parameters.layers must be an Array."))), [];
+                    for (const t5 of i22.layers) {
+                      const i3 = this._layers[t5];
+                      if (!i3) return this.fire(new e2.j(new Error(`The layer '${t5}' does not exist in the map's style and cannot be queried for features.`))), [];
+                      s22[i3.source] = true;
+                    }
+                  }
+                  const o22 = [];
+                  i22.availableImages = this._availableImages;
+                  const r22 = this._serializedAllLayers();
+                  for (const e22 in this.sourceCaches) i22.layers && !s22[e22] || o22.push(q2(this.sourceCaches[e22], this._layers, r22, t42, i22, a22));
+                  return this.placement && o22.push(function(t5, e22, i3, a3, s3, o3, r3) {
+                    const n22 = {}, l22 = o3.queryRenderedSymbols(a3), h22 = [];
+                    for (const t6 of Object.keys(l22).map(Number)) h22.push(r3[t6]);
+                    h22.sort(V2);
+                    for (const i4 of h22) {
+                      const a4 = i4.featureIndex.lookupSymbolFeatures(l22[i4.bucketInstanceId], e22, i4.bucketIndex, i4.sourceLayerIndex, s3.filter, s3.layers, s3.availableImages, t5);
+                      for (const t6 in a4) {
+                        const e3 = n22[t6] = n22[t6] || [], s4 = a4[t6];
+                        s4.sort((t7, e4) => {
+                          const a5 = i4.featureSortOrder;
+                          if (a5) {
+                            const i5 = a5.indexOf(t7.featureIndex);
+                            return a5.indexOf(e4.featureIndex) - i5;
+                          }
+                          return e4.featureIndex - t7.featureIndex;
+                        });
+                        for (const t7 of s4) e3.push(t7);
+                      }
+                    }
+                    for (const e3 in n22) n22[e3].forEach((a4) => {
+                      const s4 = a4.feature, o4 = i3[t5[e3].source].getFeatureState(s4.layer["source-layer"], s4.id);
+                      s4.source = s4.layer.source, s4.layer["source-layer"] && (s4.sourceLayer = s4.layer["source-layer"]), s4.state = o4;
+                    });
+                    return n22;
+                  }(this._layers, r22, this.sourceCaches, t42, i22, this.placement.collisionIndex, this.placement.retainedQueryData)), this._flattenAndSortRenderedFeatures(o22);
+                }
+                querySourceFeatures(t42, i22) {
+                  i22 && i22.filter && this._validate(e2.u.filter, "querySourceFeatures.filter", i22.filter, null, i22);
+                  const a22 = this.sourceCaches[t42];
+                  return a22 ? function(t5, e22) {
+                    const i3 = t5.getRenderableIds().map((e3) => t5.getTileByID(e3)), a3 = [], s22 = {};
+                    for (let t6 = 0; t6 < i3.length; t6++) {
+                      const o22 = i3[t6], r22 = o22.tileID.canonical.key;
+                      s22[r22] || (s22[r22] = true, o22.querySourceFeatures(a3, e22));
+                    }
+                    return a3;
+                  }(a22, i22) : [];
+                }
+                getLight() {
+                  return this.light.getLight();
+                }
+                setLight(t42, i22 = {}) {
+                  this._checkLoaded();
+                  const a22 = this.light.getLight();
+                  let s22 = false;
+                  for (const i3 in t42) if (!e2.aE(t42[i3], a22[i3])) {
+                    s22 = true;
+                    break;
+                  }
+                  if (!s22) return;
+                  const r22 = { now: o2.now(), transition: e2.e({ duration: 300, delay: 0 }, this.stylesheet.transition) };
+                  this.light.setLight(t42, i22), this.light.updateTransitions(r22);
+                }
+                getSky() {
+                  var t42;
+                  return null === (t42 = this.stylesheet) || void 0 === t42 ? void 0 : t42.sky;
+                }
+                setSky(t42, i22 = {}) {
+                  const a22 = this.getSky();
+                  let s22 = false;
+                  if (!t42 && !a22) return;
+                  if (t42 && !a22) s22 = true;
+                  else if (!t42 && a22) s22 = true;
+                  else for (const i3 in t42) if (!e2.aE(t42[i3], a22[i3])) {
+                    s22 = true;
+                    break;
+                  }
+                  if (!s22) return;
+                  const r22 = { now: o2.now(), transition: e2.e({ duration: 300, delay: 0 }, this.stylesheet.transition) };
+                  this.stylesheet.sky = t42, this.sky.setSky(t42, i22), this.sky.updateTransitions(r22);
+                }
+                _validate(t42, i22, a22, s22, o22 = {}) {
+                  return (!o22 || false !== o22.validate) && ce2(this, t42.call(e2.u, e2.e({ key: i22, style: this.serialize(), value: a22, styleSpec: e2.v }, s22)));
+                }
+                _remove(t42 = true) {
+                  this._frameRequest && (this._frameRequest.abort(), this._frameRequest = null), this._loadStyleRequest && (this._loadStyleRequest.abort(), this._loadStyleRequest = null), this._spriteRequest && (this._spriteRequest.abort(), this._spriteRequest = null), nt2().off(st2, this._rtlPluginLoaded);
+                  for (const t5 in this._layers) this._layers[t5].setEventedParent(null);
+                  for (const t5 in this.sourceCaches) {
+                    const e22 = this.sourceCaches[t5];
+                    e22.setEventedParent(null), e22.onRemove(this.map);
+                  }
+                  this.imageManager.setEventedParent(null), this.setEventedParent(null), t42 && this.dispatcher.broadcast("RM", void 0), this.dispatcher.remove(t42);
+                }
+                _clearSource(t42) {
+                  this.sourceCaches[t42].clearTiles();
+                }
+                _reloadSource(t42) {
+                  this.sourceCaches[t42].resume(), this.sourceCaches[t42].reload();
+                }
+                _updateSources(t42) {
+                  for (const e22 in this.sourceCaches) this.sourceCaches[e22].update(t42, this.map.terrain);
+                }
+                _generateCollisionBoxes() {
+                  for (const t42 in this.sourceCaches) this._reloadSource(t42);
+                }
+                _updatePlacement(t42, e22, i22, a22, s22 = false) {
+                  let r22 = false, n22 = false;
+                  const l22 = {};
+                  for (const e3 of this._order) {
+                    const i3 = this._layers[e3];
+                    if ("symbol" !== i3.type) continue;
+                    if (!l22[i3.source]) {
+                      const t5 = this.sourceCaches[i3.source];
+                      l22[i3.source] = t5.getRenderableIds(true).map((e4) => t5.getTileByID(e4)).sort((t6, e4) => e4.tileID.overscaledZ - t6.tileID.overscaledZ || (t6.tileID.isLessThan(e4.tileID) ? -1 : 1));
+                    }
+                    const a3 = this.crossTileSymbolIndex.addLayer(i3, l22[i3.source], t42.center.lng);
+                    r22 = r22 || a3;
+                  }
+                  if (this.crossTileSymbolIndex.pruneUnusedLayers(this._order), ((s22 = s22 || this._layerOrderChanged || 0 === i22) || !this.pauseablePlacement || this.pauseablePlacement.isDone() && !this.placement.stillRecent(o2.now(), t42.zoom)) && (this.pauseablePlacement = new se2(t42, this.map.terrain, this._order, s22, e22, i22, a22, this.placement), this._layerOrderChanged = false), this.pauseablePlacement.isDone() ? this.placement.setStale() : (this.pauseablePlacement.continuePlacement(this._order, this._layers, l22), this.pauseablePlacement.isDone() && (this.placement = this.pauseablePlacement.commit(o2.now()), n22 = true), r22 && this.pauseablePlacement.placement.setStale()), n22 || r22) for (const t5 of this._order) {
+                    const e3 = this._layers[t5];
+                    "symbol" === e3.type && this.placement.updateLayerOpacities(e3, l22[e3.source]);
+                  }
+                  return !this.pauseablePlacement.isDone() || this.placement.hasTransitions(o2.now());
+                }
+                _releaseSymbolFadeTiles() {
+                  for (const t42 in this.sourceCaches) this.sourceCaches[t42].releaseSymbolFadeTiles();
+                }
+                getImages(t42, i22) {
+                  return e2._(this, void 0, void 0, function* () {
+                    const t5 = yield this.imageManager.getImages(i22.icons);
+                    this._updateTilesForChangedImages();
+                    const e22 = this.sourceCaches[i22.source];
+                    return e22 && e22.setDependencies(i22.tileID.key, i22.type, i22.icons), t5;
+                  });
+                }
+                getGlyphs(t42, i22) {
+                  return e2._(this, void 0, void 0, function* () {
+                    const t5 = yield this.glyphManager.getGlyphs(i22.stacks), e22 = this.sourceCaches[i22.source];
+                    return e22 && e22.setDependencies(i22.tileID.key, i22.type, [""]), t5;
+                  });
+                }
+                getGlyphsUrl() {
+                  return this.stylesheet.glyphs || null;
+                }
+                setGlyphs(t42, i22 = {}) {
+                  this._checkLoaded(), t42 && this._validate(e2.u.glyphs, "glyphs", t42, null, i22) || (this._glyphsDidChange = true, this.stylesheet.glyphs = t42, this.glyphManager.entries = {}, this.glyphManager.setURL(t42));
+                }
+                addSprite(t42, i22, a22 = {}, s22) {
+                  this._checkLoaded();
+                  const o22 = [{ id: t42, url: i22 }], r22 = [...x2(this.stylesheet.sprite), ...o22];
+                  this._validate(e2.u.sprite, "sprite", r22, null, a22) || (this.stylesheet.sprite = r22, this._loadSprite(o22, true, s22));
+                }
+                removeSprite(t42) {
+                  this._checkLoaded();
+                  const i22 = x2(this.stylesheet.sprite);
+                  if (i22.find((e22) => e22.id === t42)) {
+                    if (this._spritesImagesIds[t42]) for (const e22 of this._spritesImagesIds[t42]) this.imageManager.removeImage(e22), this._changedImages[e22] = true;
+                    i22.splice(i22.findIndex((e22) => e22.id === t42), 1), this.stylesheet.sprite = i22.length > 0 ? i22 : void 0, delete this._spritesImagesIds[t42], this._availableImages = this.imageManager.listImages(), this._changed = true, this.dispatcher.broadcast("SI", this._availableImages), this.fire(new e2.k("data", { dataType: "style" }));
+                  } else this.fire(new e2.j(new Error(`Sprite "${t42}" doesn't exists on this map.`)));
+                }
+                getSprite() {
+                  return x2(this.stylesheet.sprite);
+                }
+                setSprite(t42, i22 = {}, a22) {
+                  this._checkLoaded(), t42 && this._validate(e2.u.sprite, "sprite", t42, null, i22) || (this.stylesheet.sprite = t42, t42 ? this._loadSprite(t42, true, a22) : (this._unloadSprite(), a22 && a22(null)));
+                }
+              }
+              var _e2 = e2.Y([{ name: "a_pos", type: "Int16", components: 2 }]);
+              const pe2 = { prelude: me2("#ifdef GL_ES\nprecision mediump float;\n#else\n#if !defined(lowp)\n#define lowp\n#endif\n#if !defined(mediump)\n#define mediump\n#endif\n#if !defined(highp)\n#define highp\n#endif\n#endif\n", "#ifdef GL_ES\nprecision highp float;\n#else\n#if !defined(lowp)\n#define lowp\n#endif\n#if !defined(mediump)\n#define mediump\n#endif\n#if !defined(highp)\n#define highp\n#endif\n#endif\nvec2 unpack_float(const float packedValue) {int packedIntValue=int(packedValue);int v0=packedIntValue/256;return vec2(v0,packedIntValue-v0*256);}vec2 unpack_opacity(const float packedOpacity) {int intOpacity=int(packedOpacity)/2;return vec2(float(intOpacity)/127.0,mod(packedOpacity,2.0));}vec4 decode_color(const vec2 encodedColor) {return vec4(unpack_float(encodedColor[0])/255.0,unpack_float(encodedColor[1])/255.0\n);}float unpack_mix_vec2(const vec2 packedValue,const float t) {return mix(packedValue[0],packedValue[1],t);}vec4 unpack_mix_color(const vec4 packedColors,const float t) {vec4 minColor=decode_color(vec2(packedColors[0],packedColors[1]));vec4 maxColor=decode_color(vec2(packedColors[2],packedColors[3]));return mix(minColor,maxColor,t);}vec2 get_pattern_pos(const vec2 pixel_coord_upper,const vec2 pixel_coord_lower,const vec2 pattern_size,const float tile_units_to_pixels,const vec2 pos) {vec2 offset=mod(mod(mod(pixel_coord_upper,pattern_size)*256.0,pattern_size)*256.0+pixel_coord_lower,pattern_size);return (tile_units_to_pixels*pos+offset)/pattern_size;}\n#ifdef TERRAIN3D\nuniform sampler2D u_terrain;uniform float u_terrain_dim;uniform mat4 u_terrain_matrix;uniform vec4 u_terrain_unpack;uniform float u_terrain_exaggeration;uniform highp sampler2D u_depth;\n#endif\nconst highp vec4 bitSh=vec4(256.*256.*256.,256.*256.,256.,1.);const highp vec4 bitShifts=vec4(1.)/bitSh;highp float unpack(highp vec4 color) {return dot(color,bitShifts);}highp float depthOpacity(vec3 frag) {\n#ifdef TERRAIN3D\nhighp float d=unpack(texture2D(u_depth,frag.xy*0.5+0.5))+0.0001-frag.z;return 1.0-max(0.0,min(1.0,-d*500.0));\n#else\nreturn 1.0;\n#endif\n}float calculate_visibility(vec4 pos) {\n#ifdef TERRAIN3D\nvec3 frag=pos.xyz/pos.w;highp float d=depthOpacity(frag);if (d > 0.95) return 1.0;return (d+depthOpacity(frag+vec3(0.0,0.01,0.0)))/2.0;\n#else\nreturn 1.0;\n#endif\n}float ele(vec2 pos) {\n#ifdef TERRAIN3D\nvec4 rgb=(texture2D(u_terrain,pos)*255.0)*u_terrain_unpack;return rgb.r+rgb.g+rgb.b-u_terrain_unpack.a;\n#else\nreturn 0.0;\n#endif\n}float get_elevation(vec2 pos) {\n#ifdef TERRAIN3D\nvec2 coord=(u_terrain_matrix*vec4(pos,0.0,1.0)).xy*u_terrain_dim+1.0;vec2 f=fract(coord);vec2 c=(floor(coord)+0.5)/(u_terrain_dim+2.0);float d=1.0/(u_terrain_dim+2.0);float tl=ele(c);float tr=ele(c+vec2(d,0.0));float bl=ele(c+vec2(0.0,d));float br=ele(c+vec2(d,d));float elevation=mix(mix(tl,tr,f.x),mix(bl,br,f.x),f.y);return elevation*u_terrain_exaggeration;\n#else\nreturn 0.0;\n#endif\n}"), background: me2("uniform vec4 u_color;uniform float u_opacity;void main() {gl_FragColor=u_color*u_opacity;\n#ifdef OVERDRAW_INSPECTOR\ngl_FragColor=vec4(1.0);\n#endif\n}", "attribute vec2 a_pos;uniform mat4 u_matrix;void main() {gl_Position=u_matrix*vec4(a_pos,0,1);}"), backgroundPattern: me2("uniform vec2 u_pattern_tl_a;uniform vec2 u_pattern_br_a;uniform vec2 u_pattern_tl_b;uniform vec2 u_pattern_br_b;uniform vec2 u_texsize;uniform float u_mix;uniform float u_opacity;uniform sampler2D u_image;varying vec2 v_pos_a;varying vec2 v_pos_b;void main() {vec2 imagecoord=mod(v_pos_a,1.0);vec2 pos=mix(u_pattern_tl_a/u_texsize,u_pattern_br_a/u_texsize,imagecoord);vec4 color1=texture2D(u_image,pos);vec2 imagecoord_b=mod(v_pos_b,1.0);vec2 pos2=mix(u_pattern_tl_b/u_texsize,u_pattern_br_b/u_texsize,imagecoord_b);vec4 color2=texture2D(u_image,pos2);gl_FragColor=mix(color1,color2,u_mix)*u_opacity;\n#ifdef OVERDRAW_INSPECTOR\ngl_FragColor=vec4(1.0);\n#endif\n}", "uniform mat4 u_matrix;uniform vec2 u_pattern_size_a;uniform vec2 u_pattern_size_b;uniform vec2 u_pixel_coord_upper;uniform vec2 u_pixel_coord_lower;uniform float u_scale_a;uniform float u_scale_b;uniform float u_tile_units_to_pixels;attribute vec2 a_pos;varying vec2 v_pos_a;varying vec2 v_pos_b;void main() {gl_Position=u_matrix*vec4(a_pos,0,1);v_pos_a=get_pattern_pos(u_pixel_coord_upper,u_pixel_coord_lower,u_scale_a*u_pattern_size_a,u_tile_units_to_pixels,a_pos);v_pos_b=get_pattern_pos(u_pixel_coord_upper,u_pixel_coord_lower,u_scale_b*u_pattern_size_b,u_tile_units_to_pixels,a_pos);}"), circle: me2("varying vec3 v_data;varying float v_visibility;\n#pragma mapbox: define highp vec4 color\n#pragma mapbox: define mediump float radius\n#pragma mapbox: define lowp float blur\n#pragma mapbox: define lowp float opacity\n#pragma mapbox: define highp vec4 stroke_color\n#pragma mapbox: define mediump float stroke_width\n#pragma mapbox: define lowp float stroke_opacity\nvoid main() {\n#pragma mapbox: initialize highp vec4 color\n#pragma mapbox: initialize mediump float radius\n#pragma mapbox: initialize lowp float blur\n#pragma mapbox: initialize lowp float opacity\n#pragma mapbox: initialize highp vec4 stroke_color\n#pragma mapbox: initialize mediump float stroke_width\n#pragma mapbox: initialize lowp float stroke_opacity\nvec2 extrude=v_data.xy;float extrude_length=length(extrude);float antialiased_blur=v_data.z;float opacity_t=smoothstep(0.0,antialiased_blur,extrude_length-1.0);float color_t=stroke_width < 0.01 ? 0.0 : smoothstep(antialiased_blur,0.0,extrude_length-radius/(radius+stroke_width));gl_FragColor=v_visibility*opacity_t*mix(color*opacity,stroke_color*stroke_opacity,color_t);\n#ifdef OVERDRAW_INSPECTOR\ngl_FragColor=vec4(1.0);\n#endif\n}", "uniform mat4 u_matrix;uniform bool u_scale_with_map;uniform bool u_pitch_with_map;uniform vec2 u_extrude_scale;uniform lowp float u_device_pixel_ratio;uniform highp float u_camera_to_center_distance;attribute vec2 a_pos;varying vec3 v_data;varying float v_visibility;\n#pragma mapbox: define highp vec4 color\n#pragma mapbox: define mediump float radius\n#pragma mapbox: define lowp float blur\n#pragma mapbox: define lowp float opacity\n#pragma mapbox: define highp vec4 stroke_color\n#pragma mapbox: define mediump float stroke_width\n#pragma mapbox: define lowp float stroke_opacity\nvoid main(void) {\n#pragma mapbox: initialize highp vec4 color\n#pragma mapbox: initialize mediump float radius\n#pragma mapbox: initialize lowp float blur\n#pragma mapbox: initialize lowp float opacity\n#pragma mapbox: initialize highp vec4 stroke_color\n#pragma mapbox: initialize mediump float stroke_width\n#pragma mapbox: initialize lowp float stroke_opacity\nvec2 extrude=vec2(mod(a_pos,2.0)*2.0-1.0);vec2 circle_center=floor(a_pos*0.5);float ele=get_elevation(circle_center);v_visibility=calculate_visibility(u_matrix*vec4(circle_center,ele,1.0));if (u_pitch_with_map) {vec2 corner_position=circle_center;if (u_scale_with_map) {corner_position+=extrude*(radius+stroke_width)*u_extrude_scale;} else {vec4 projected_center=u_matrix*vec4(circle_center,0,1);corner_position+=extrude*(radius+stroke_width)*u_extrude_scale*(projected_center.w/u_camera_to_center_distance);}gl_Position=u_matrix*vec4(corner_position,ele,1);} else {gl_Position=u_matrix*vec4(circle_center,ele,1);if (u_scale_with_map) {gl_Position.xy+=extrude*(radius+stroke_width)*u_extrude_scale*u_camera_to_center_distance;} else {gl_Position.xy+=extrude*(radius+stroke_width)*u_extrude_scale*gl_Position.w;}}float antialiasblur=-max(1.0/u_device_pixel_ratio/(radius+stroke_width),blur);v_data=vec3(extrude.x,extrude.y,antialiasblur);}"), clippingMask: me2("void main() {gl_FragColor=vec4(1.0);}", "attribute vec2 a_pos;uniform mat4 u_matrix;void main() {gl_Position=u_matrix*vec4(a_pos,0,1);}"), heatmap: me2("uniform highp float u_intensity;varying vec2 v_extrude;\n#pragma mapbox: define highp float weight\n#define GAUSS_COEF 0.3989422804014327\nvoid main() {\n#pragma mapbox: initialize highp float weight\nfloat d=-0.5*3.0*3.0*dot(v_extrude,v_extrude);float val=weight*u_intensity*GAUSS_COEF*exp(d);gl_FragColor=vec4(val,1.0,1.0,1.0);\n#ifdef OVERDRAW_INSPECTOR\ngl_FragColor=vec4(1.0);\n#endif\n}", "uniform mat4 u_matrix;uniform float u_extrude_scale;uniform float u_opacity;uniform float u_intensity;attribute vec2 a_pos;varying vec2 v_extrude;\n#pragma mapbox: define highp float weight\n#pragma mapbox: define mediump float radius\nconst highp float ZERO=1.0/255.0/16.0;\n#define GAUSS_COEF 0.3989422804014327\nvoid main(void) {\n#pragma mapbox: initialize highp float weight\n#pragma mapbox: initialize mediump float radius\nvec2 unscaled_extrude=vec2(mod(a_pos,2.0)*2.0-1.0);float S=sqrt(-2.0*log(ZERO/weight/u_intensity/GAUSS_COEF))/3.0;v_extrude=S*unscaled_extrude;vec2 extrude=v_extrude*radius*u_extrude_scale;vec4 pos=vec4(floor(a_pos*0.5)+extrude,get_elevation(floor(a_pos*0.5)),1);gl_Position=u_matrix*pos;}"), heatmapTexture: me2("uniform sampler2D u_image;uniform sampler2D u_color_ramp;uniform float u_opacity;varying vec2 v_pos;void main() {float t=texture2D(u_image,v_pos).r;vec4 color=texture2D(u_color_ramp,vec2(t,0.5));gl_FragColor=color*u_opacity;\n#ifdef OVERDRAW_INSPECTOR\ngl_FragColor=vec4(0.0);\n#endif\n}", "uniform mat4 u_matrix;uniform vec2 u_world;attribute vec2 a_pos;varying vec2 v_pos;void main() {gl_Position=u_matrix*vec4(a_pos*u_world,0,1);v_pos.x=a_pos.x;v_pos.y=1.0-a_pos.y;}"), collisionBox: me2("varying float v_placed;varying float v_notUsed;void main() {float alpha=0.5;gl_FragColor=vec4(1.0,0.0,0.0,1.0)*alpha;if (v_placed > 0.5) {gl_FragColor=vec4(0.0,0.0,1.0,0.5)*alpha;}if (v_notUsed > 0.5) {gl_FragColor*=.1;}}", "attribute vec2 a_anchor_pos;attribute vec2 a_placed;attribute vec2 a_box_real;uniform mat4 u_matrix;uniform vec2 u_pixel_extrude_scale;varying float v_placed;varying float v_notUsed;vec4 projectTileWithElevation(vec2 posInTile,float elevation) {return u_matrix*vec4(posInTile,elevation,1.0);}void main() {gl_Position=projectTileWithElevation(a_anchor_pos,get_elevation(a_anchor_pos));gl_Position.xy=((a_box_real+0.5)*u_pixel_extrude_scale*2.0-1.0)*vec2(1.0,-1.0)*gl_Position.w;if (gl_Position.z/gl_Position.w < 1.1) {gl_Position.z=0.5;}v_placed=a_placed.x;v_notUsed=a_placed.y;}"), collisionCircle: me2("varying float v_radius;varying vec2 v_extrude;varying float v_perspective_ratio;varying float v_collision;void main() {float alpha=0.5*min(v_perspective_ratio,1.0);float stroke_radius=0.9*max(v_perspective_ratio,1.0);float distance_to_center=length(v_extrude);float distance_to_edge=abs(distance_to_center-v_radius);float opacity_t=smoothstep(-stroke_radius,0.0,-distance_to_edge);vec4 color=mix(vec4(0.0,0.0,1.0,0.5),vec4(1.0,0.0,0.0,1.0),v_collision);gl_FragColor=color*alpha*opacity_t;}", "attribute vec2 a_pos;attribute float a_radius;attribute vec2 a_flags;uniform mat4 u_matrix;uniform mat4 u_inv_matrix;uniform vec2 u_viewport_size;uniform float u_camera_to_center_distance;varying float v_radius;varying vec2 v_extrude;varying float v_perspective_ratio;varying float v_collision;vec3 toTilePosition(vec2 screenPos) {vec4 rayStart=u_inv_matrix*vec4(screenPos,-1.0,1.0);vec4 rayEnd  =u_inv_matrix*vec4(screenPos, 1.0,1.0);rayStart.xyz/=rayStart.w;rayEnd.xyz  /=rayEnd.w;highp float t=(0.0-rayStart.z)/(rayEnd.z-rayStart.z);return mix(rayStart.xyz,rayEnd.xyz,t);}void main() {vec2 quadCenterPos=a_pos;float radius=a_radius;float collision=a_flags.x;float vertexIdx=a_flags.y;vec2 quadVertexOffset=vec2(mix(-1.0,1.0,float(vertexIdx >=2.0)),mix(-1.0,1.0,float(vertexIdx >=1.0 && vertexIdx <=2.0)));vec2 quadVertexExtent=quadVertexOffset*radius;vec3 tilePos=toTilePosition(quadCenterPos);vec4 clipPos=u_matrix*vec4(tilePos,1.0);highp float camera_to_anchor_distance=clipPos.w;highp float collision_perspective_ratio=clamp(0.5+0.5*(u_camera_to_center_distance/camera_to_anchor_distance),0.0,4.0);float padding_factor=1.2;v_radius=radius;v_extrude=quadVertexExtent*padding_factor;v_perspective_ratio=collision_perspective_ratio;v_collision=collision;gl_Position=vec4(clipPos.xyz/clipPos.w,1.0)+vec4(quadVertexExtent*padding_factor/u_viewport_size*2.0,0.0,0.0);}"), debug: me2("uniform highp vec4 u_color;uniform sampler2D u_overlay;varying vec2 v_uv;void main() {vec4 overlay_color=texture2D(u_overlay,v_uv);gl_FragColor=mix(u_color,overlay_color,overlay_color.a);}", "attribute vec2 a_pos;varying vec2 v_uv;uniform mat4 u_matrix;uniform float u_overlay_scale;void main() {v_uv=a_pos/8192.0;gl_Position=u_matrix*vec4(a_pos*u_overlay_scale,get_elevation(a_pos),1);}"), fill: me2("#pragma mapbox: define highp vec4 color\n#pragma mapbox: define lowp float opacity\nvoid main() {\n#pragma mapbox: initialize highp vec4 color\n#pragma mapbox: initialize lowp float opacity\ngl_FragColor=color*opacity;\n#ifdef OVERDRAW_INSPECTOR\ngl_FragColor=vec4(1.0);\n#endif\n}", "attribute vec2 a_pos;uniform mat4 u_matrix;\n#pragma mapbox: define highp vec4 color\n#pragma mapbox: define lowp float opacity\nvoid main() {\n#pragma mapbox: initialize highp vec4 color\n#pragma mapbox: initialize lowp float opacity\ngl_Position=u_matrix*vec4(a_pos,0,1);}"), fillOutline: me2("varying vec2 v_pos;\n#pragma mapbox: define highp vec4 outline_color\n#pragma mapbox: define lowp float opacity\nvoid main() {\n#pragma mapbox: initialize highp vec4 outline_color\n#pragma mapbox: initialize lowp float opacity\nfloat dist=length(v_pos-gl_FragCoord.xy);float alpha=1.0-smoothstep(0.0,1.0,dist);gl_FragColor=outline_color*(alpha*opacity);\n#ifdef OVERDRAW_INSPECTOR\ngl_FragColor=vec4(1.0);\n#endif\n}", "attribute vec2 a_pos;uniform mat4 u_matrix;uniform vec2 u_world;varying vec2 v_pos;\n#pragma mapbox: define highp vec4 outline_color\n#pragma mapbox: define lowp float opacity\nvoid main() {\n#pragma mapbox: initialize highp vec4 outline_color\n#pragma mapbox: initialize lowp float opacity\ngl_Position=u_matrix*vec4(a_pos,0,1);v_pos=(gl_Position.xy/gl_Position.w+1.0)/2.0*u_world;}"), fillOutlinePattern: me2("uniform vec2 u_texsize;uniform sampler2D u_image;uniform float u_fade;varying vec2 v_pos_a;varying vec2 v_pos_b;varying vec2 v_pos;\n#pragma mapbox: define lowp float opacity\n#pragma mapbox: define lowp vec4 pattern_from\n#pragma mapbox: define lowp vec4 pattern_to\nvoid main() {\n#pragma mapbox: initialize lowp float opacity\n#pragma mapbox: initialize mediump vec4 pattern_from\n#pragma mapbox: initialize mediump vec4 pattern_to\nvec2 pattern_tl_a=pattern_from.xy;vec2 pattern_br_a=pattern_from.zw;vec2 pattern_tl_b=pattern_to.xy;vec2 pattern_br_b=pattern_to.zw;vec2 imagecoord=mod(v_pos_a,1.0);vec2 pos=mix(pattern_tl_a/u_texsize,pattern_br_a/u_texsize,imagecoord);vec4 color1=texture2D(u_image,pos);vec2 imagecoord_b=mod(v_pos_b,1.0);vec2 pos2=mix(pattern_tl_b/u_texsize,pattern_br_b/u_texsize,imagecoord_b);vec4 color2=texture2D(u_image,pos2);float dist=length(v_pos-gl_FragCoord.xy);float alpha=1.0-smoothstep(0.0,1.0,dist);gl_FragColor=mix(color1,color2,u_fade)*alpha*opacity;\n#ifdef OVERDRAW_INSPECTOR\ngl_FragColor=vec4(1.0);\n#endif\n}", "uniform mat4 u_matrix;uniform vec2 u_world;uniform vec2 u_pixel_coord_upper;uniform vec2 u_pixel_coord_lower;uniform vec3 u_scale;attribute vec2 a_pos;varying vec2 v_pos_a;varying vec2 v_pos_b;varying vec2 v_pos;\n#pragma mapbox: define lowp float opacity\n#pragma mapbox: define lowp vec4 pattern_from\n#pragma mapbox: define lowp vec4 pattern_to\n#pragma mapbox: define lowp float pixel_ratio_from\n#pragma mapbox: define lowp float pixel_ratio_to\nvoid main() {\n#pragma mapbox: initialize lowp float opacity\n#pragma mapbox: initialize mediump vec4 pattern_from\n#pragma mapbox: initialize mediump vec4 pattern_to\n#pragma mapbox: initialize lowp float pixel_ratio_from\n#pragma mapbox: initialize lowp float pixel_ratio_to\nvec2 pattern_tl_a=pattern_from.xy;vec2 pattern_br_a=pattern_from.zw;vec2 pattern_tl_b=pattern_to.xy;vec2 pattern_br_b=pattern_to.zw;float tileRatio=u_scale.x;float fromScale=u_scale.y;float toScale=u_scale.z;gl_Position=u_matrix*vec4(a_pos,0,1);vec2 display_size_a=(pattern_br_a-pattern_tl_a)/pixel_ratio_from;vec2 display_size_b=(pattern_br_b-pattern_tl_b)/pixel_ratio_to;v_pos_a=get_pattern_pos(u_pixel_coord_upper,u_pixel_coord_lower,fromScale*display_size_a,tileRatio,a_pos);v_pos_b=get_pattern_pos(u_pixel_coord_upper,u_pixel_coord_lower,toScale*display_size_b,tileRatio,a_pos);v_pos=(gl_Position.xy/gl_Position.w+1.0)/2.0*u_world;}"), fillPattern: me2("#ifdef GL_ES\nprecision highp float;\n#endif\nuniform vec2 u_texsize;uniform float u_fade;uniform sampler2D u_image;varying vec2 v_pos_a;varying vec2 v_pos_b;\n#pragma mapbox: define lowp float opacity\n#pragma mapbox: define lowp vec4 pattern_from\n#pragma mapbox: define lowp vec4 pattern_to\nvoid main() {\n#pragma mapbox: initialize lowp float opacity\n#pragma mapbox: initialize mediump vec4 pattern_from\n#pragma mapbox: initialize mediump vec4 pattern_to\nvec2 pattern_tl_a=pattern_from.xy;vec2 pattern_br_a=pattern_from.zw;vec2 pattern_tl_b=pattern_to.xy;vec2 pattern_br_b=pattern_to.zw;vec2 imagecoord=mod(v_pos_a,1.0);vec2 pos=mix(pattern_tl_a/u_texsize,pattern_br_a/u_texsize,imagecoord);vec4 color1=texture2D(u_image,pos);vec2 imagecoord_b=mod(v_pos_b,1.0);vec2 pos2=mix(pattern_tl_b/u_texsize,pattern_br_b/u_texsize,imagecoord_b);vec4 color2=texture2D(u_image,pos2);gl_FragColor=mix(color1,color2,u_fade)*opacity;\n#ifdef OVERDRAW_INSPECTOR\ngl_FragColor=vec4(1.0);\n#endif\n}", "uniform mat4 u_matrix;uniform vec2 u_pixel_coord_upper;uniform vec2 u_pixel_coord_lower;uniform vec3 u_scale;attribute vec2 a_pos;varying vec2 v_pos_a;varying vec2 v_pos_b;\n#pragma mapbox: define lowp float opacity\n#pragma mapbox: define lowp vec4 pattern_from\n#pragma mapbox: define lowp vec4 pattern_to\n#pragma mapbox: define lowp float pixel_ratio_from\n#pragma mapbox: define lowp float pixel_ratio_to\nvoid main() {\n#pragma mapbox: initialize lowp float opacity\n#pragma mapbox: initialize mediump vec4 pattern_from\n#pragma mapbox: initialize mediump vec4 pattern_to\n#pragma mapbox: initialize lowp float pixel_ratio_from\n#pragma mapbox: initialize lowp float pixel_ratio_to\nvec2 pattern_tl_a=pattern_from.xy;vec2 pattern_br_a=pattern_from.zw;vec2 pattern_tl_b=pattern_to.xy;vec2 pattern_br_b=pattern_to.zw;float tileZoomRatio=u_scale.x;float fromScale=u_scale.y;float toScale=u_scale.z;vec2 display_size_a=(pattern_br_a-pattern_tl_a)/pixel_ratio_from;vec2 display_size_b=(pattern_br_b-pattern_tl_b)/pixel_ratio_to;gl_Position=u_matrix*vec4(a_pos,0,1);v_pos_a=get_pattern_pos(u_pixel_coord_upper,u_pixel_coord_lower,fromScale*display_size_a,tileZoomRatio,a_pos);v_pos_b=get_pattern_pos(u_pixel_coord_upper,u_pixel_coord_lower,toScale*display_size_b,tileZoomRatio,a_pos);}"), fillExtrusion: me2("varying vec4 v_color;void main() {gl_FragColor=v_color;\n#ifdef OVERDRAW_INSPECTOR\ngl_FragColor=vec4(1.0);\n#endif\n}", "uniform mat4 u_matrix;uniform vec3 u_lightcolor;uniform lowp vec3 u_lightpos;uniform lowp float u_lightintensity;uniform float u_vertical_gradient;uniform lowp float u_opacity;attribute vec2 a_pos;attribute vec4 a_normal_ed;\n#ifdef TERRAIN3D\nattribute vec2 a_centroid;\n#endif\nvarying vec4 v_color;\n#pragma mapbox: define highp float base\n#pragma mapbox: define highp float height\n#pragma mapbox: define highp vec4 color\nvoid main() {\n#pragma mapbox: initialize highp float base\n#pragma mapbox: initialize highp float height\n#pragma mapbox: initialize highp vec4 color\nvec3 normal=a_normal_ed.xyz;\n#ifdef TERRAIN3D\nfloat height_terrain3d_offset=get_elevation(a_centroid);float base_terrain3d_offset=height_terrain3d_offset-(base > 0.0 ? 0.0 : 10.0);\n#else\nfloat height_terrain3d_offset=0.0;float base_terrain3d_offset=0.0;\n#endif\nbase=max(0.0,base)+base_terrain3d_offset;height=max(0.0,height)+height_terrain3d_offset;float t=mod(normal.x,2.0);gl_Position=u_matrix*vec4(a_pos,t > 0.0 ? height : base,1);float colorvalue=color.r*0.2126+color.g*0.7152+color.b*0.0722;v_color=vec4(0.0,0.0,0.0,1.0);vec4 ambientlight=vec4(0.03,0.03,0.03,1.0);color+=ambientlight;float directional=clamp(dot(normal/16384.0,u_lightpos),0.0,1.0);directional=mix((1.0-u_lightintensity),max((1.0-colorvalue+u_lightintensity),1.0),directional);if (normal.y !=0.0) {directional*=((1.0-u_vertical_gradient)+(u_vertical_gradient*clamp((t+base)*pow(height/150.0,0.5),mix(0.7,0.98,1.0-u_lightintensity),1.0)));}v_color.r+=clamp(color.r*directional*u_lightcolor.r,mix(0.0,0.3,1.0-u_lightcolor.r),1.0);v_color.g+=clamp(color.g*directional*u_lightcolor.g,mix(0.0,0.3,1.0-u_lightcolor.g),1.0);v_color.b+=clamp(color.b*directional*u_lightcolor.b,mix(0.0,0.3,1.0-u_lightcolor.b),1.0);v_color*=u_opacity;}"), fillExtrusionPattern: me2("uniform vec2 u_texsize;uniform float u_fade;uniform sampler2D u_image;varying vec2 v_pos_a;varying vec2 v_pos_b;varying vec4 v_lighting;\n#pragma mapbox: define lowp float base\n#pragma mapbox: define lowp float height\n#pragma mapbox: define lowp vec4 pattern_from\n#pragma mapbox: define lowp vec4 pattern_to\n#pragma mapbox: define lowp float pixel_ratio_from\n#pragma mapbox: define lowp float pixel_ratio_to\nvoid main() {\n#pragma mapbox: initialize lowp float base\n#pragma mapbox: initialize lowp float height\n#pragma mapbox: initialize mediump vec4 pattern_from\n#pragma mapbox: initialize mediump vec4 pattern_to\n#pragma mapbox: initialize lowp float pixel_ratio_from\n#pragma mapbox: initialize lowp float pixel_ratio_to\nvec2 pattern_tl_a=pattern_from.xy;vec2 pattern_br_a=pattern_from.zw;vec2 pattern_tl_b=pattern_to.xy;vec2 pattern_br_b=pattern_to.zw;vec2 imagecoord=mod(v_pos_a,1.0);vec2 pos=mix(pattern_tl_a/u_texsize,pattern_br_a/u_texsize,imagecoord);vec4 color1=texture2D(u_image,pos);vec2 imagecoord_b=mod(v_pos_b,1.0);vec2 pos2=mix(pattern_tl_b/u_texsize,pattern_br_b/u_texsize,imagecoord_b);vec4 color2=texture2D(u_image,pos2);vec4 mixedColor=mix(color1,color2,u_fade);gl_FragColor=mixedColor*v_lighting;\n#ifdef OVERDRAW_INSPECTOR\ngl_FragColor=vec4(1.0);\n#endif\n}", "uniform mat4 u_matrix;uniform vec2 u_pixel_coord_upper;uniform vec2 u_pixel_coord_lower;uniform float u_height_factor;uniform vec3 u_scale;uniform float u_vertical_gradient;uniform lowp float u_opacity;uniform vec3 u_lightcolor;uniform lowp vec3 u_lightpos;uniform lowp float u_lightintensity;attribute vec2 a_pos;attribute vec4 a_normal_ed;\n#ifdef TERRAIN3D\nattribute vec2 a_centroid;\n#endif\nvarying vec2 v_pos_a;varying vec2 v_pos_b;varying vec4 v_lighting;\n#pragma mapbox: define lowp float base\n#pragma mapbox: define lowp float height\n#pragma mapbox: define lowp vec4 pattern_from\n#pragma mapbox: define lowp vec4 pattern_to\n#pragma mapbox: define lowp float pixel_ratio_from\n#pragma mapbox: define lowp float pixel_ratio_to\nvoid main() {\n#pragma mapbox: initialize lowp float base\n#pragma mapbox: initialize lowp float height\n#pragma mapbox: initialize mediump vec4 pattern_from\n#pragma mapbox: initialize mediump vec4 pattern_to\n#pragma mapbox: initialize lowp float pixel_ratio_from\n#pragma mapbox: initialize lowp float pixel_ratio_to\nvec2 pattern_tl_a=pattern_from.xy;vec2 pattern_br_a=pattern_from.zw;vec2 pattern_tl_b=pattern_to.xy;vec2 pattern_br_b=pattern_to.zw;float tileRatio=u_scale.x;float fromScale=u_scale.y;float toScale=u_scale.z;vec3 normal=a_normal_ed.xyz;float edgedistance=a_normal_ed.w;vec2 display_size_a=(pattern_br_a-pattern_tl_a)/pixel_ratio_from;vec2 display_size_b=(pattern_br_b-pattern_tl_b)/pixel_ratio_to;\n#ifdef TERRAIN3D\nfloat height_terrain3d_offset=get_elevation(a_centroid);float base_terrain3d_offset=height_terrain3d_offset-(base > 0.0 ? 0.0 : 10.0);\n#else\nfloat height_terrain3d_offset=0.0;float base_terrain3d_offset=0.0;\n#endif\nbase=max(0.0,base)+base_terrain3d_offset;height=max(0.0,height)+height_terrain3d_offset;float t=mod(normal.x,2.0);float z=t > 0.0 ? height : base;gl_Position=u_matrix*vec4(a_pos,z,1);vec2 pos=normal.x==1.0 && normal.y==0.0 && normal.z==16384.0\n? a_pos\n: vec2(edgedistance,z*u_height_factor);v_pos_a=get_pattern_pos(u_pixel_coord_upper,u_pixel_coord_lower,fromScale*display_size_a,tileRatio,pos);v_pos_b=get_pattern_pos(u_pixel_coord_upper,u_pixel_coord_lower,toScale*display_size_b,tileRatio,pos);v_lighting=vec4(0.0,0.0,0.0,1.0);float directional=clamp(dot(normal/16383.0,u_lightpos),0.0,1.0);directional=mix((1.0-u_lightintensity),max((0.5+u_lightintensity),1.0),directional);if (normal.y !=0.0) {directional*=((1.0-u_vertical_gradient)+(u_vertical_gradient*clamp((t+base)*pow(height/150.0,0.5),mix(0.7,0.98,1.0-u_lightintensity),1.0)));}v_lighting.rgb+=clamp(directional*u_lightcolor,mix(vec3(0.0),vec3(0.3),1.0-u_lightcolor),vec3(1.0));v_lighting*=u_opacity;}"), hillshadePrepare: me2("#ifdef GL_ES\nprecision highp float;\n#endif\nuniform sampler2D u_image;varying vec2 v_pos;uniform vec2 u_dimension;uniform float u_zoom;uniform vec4 u_unpack;float getElevation(vec2 coord,float bias) {vec4 data=texture2D(u_image,coord)*255.0;data.a=-1.0;return dot(data,u_unpack)/4.0;}void main() {vec2 epsilon=1.0/u_dimension;float a=getElevation(v_pos+vec2(-epsilon.x,-epsilon.y),0.0);float b=getElevation(v_pos+vec2(0,-epsilon.y),0.0);float c=getElevation(v_pos+vec2(epsilon.x,-epsilon.y),0.0);float d=getElevation(v_pos+vec2(-epsilon.x,0),0.0);float e=getElevation(v_pos,0.0);float f=getElevation(v_pos+vec2(epsilon.x,0),0.0);float g=getElevation(v_pos+vec2(-epsilon.x,epsilon.y),0.0);float h=getElevation(v_pos+vec2(0,epsilon.y),0.0);float i=getElevation(v_pos+vec2(epsilon.x,epsilon.y),0.0);float exaggerationFactor=u_zoom < 2.0 ? 0.4 : u_zoom < 4.5 ? 0.35 : 0.3;float exaggeration=u_zoom < 15.0 ? (u_zoom-15.0)*exaggerationFactor : 0.0;vec2 deriv=vec2((c+f+f+i)-(a+d+d+g),(g+h+h+i)-(a+b+b+c))/pow(2.0,exaggeration+(19.2562-u_zoom));gl_FragColor=clamp(vec4(deriv.x/2.0+0.5,deriv.y/2.0+0.5,1.0,1.0),0.0,1.0);\n#ifdef OVERDRAW_INSPECTOR\ngl_FragColor=vec4(1.0);\n#endif\n}", "uniform mat4 u_matrix;uniform vec2 u_dimension;attribute vec2 a_pos;attribute vec2 a_texture_pos;varying vec2 v_pos;void main() {gl_Position=u_matrix*vec4(a_pos,0,1);highp vec2 epsilon=1.0/u_dimension;float scale=(u_dimension.x-2.0)/u_dimension.x;v_pos=(a_texture_pos/8192.0)*scale+epsilon;}"), hillshade: me2("uniform sampler2D u_image;varying vec2 v_pos;uniform vec2 u_latrange;uniform vec2 u_light;uniform vec4 u_shadow;uniform vec4 u_highlight;uniform vec4 u_accent;\n#define PI 3.141592653589793\nvoid main() {vec4 pixel=texture2D(u_image,v_pos);vec2 deriv=((pixel.rg*2.0)-1.0);float scaleFactor=cos(radians((u_latrange[0]-u_latrange[1])*(1.0-v_pos.y)+u_latrange[1]));float slope=atan(1.25*length(deriv)/scaleFactor);float aspect=deriv.x !=0.0 ? atan(deriv.y,-deriv.x) : PI/2.0*(deriv.y > 0.0 ? 1.0 :-1.0);float intensity=u_light.x;float azimuth=u_light.y+PI;float base=1.875-intensity*1.75;float maxValue=0.5*PI;float scaledSlope=intensity !=0.5 ? ((pow(base,slope)-1.0)/(pow(base,maxValue)-1.0))*maxValue : slope;float accent=cos(scaledSlope);vec4 accent_color=(1.0-accent)*u_accent*clamp(intensity*2.0,0.0,1.0);float shade=abs(mod((aspect+azimuth)/PI+0.5,2.0)-1.0);vec4 shade_color=mix(u_shadow,u_highlight,shade)*sin(scaledSlope)*clamp(intensity*2.0,0.0,1.0);gl_FragColor=accent_color*(1.0-shade_color.a)+shade_color;\n#ifdef OVERDRAW_INSPECTOR\ngl_FragColor=vec4(1.0);\n#endif\n}", "uniform mat4 u_matrix;attribute vec2 a_pos;attribute vec2 a_texture_pos;varying vec2 v_pos;void main() {gl_Position=u_matrix*vec4(a_pos,0,1);v_pos=a_texture_pos/8192.0;}"), line: me2("uniform lowp float u_device_pixel_ratio;varying vec2 v_width2;varying vec2 v_normal;varying float v_gamma_scale;\n#pragma mapbox: define highp vec4 color\n#pragma mapbox: define lowp float blur\n#pragma mapbox: define lowp float opacity\nvoid main() {\n#pragma mapbox: initialize highp vec4 color\n#pragma mapbox: initialize lowp float blur\n#pragma mapbox: initialize lowp float opacity\nfloat dist=length(v_normal)*v_width2.s;float blur2=(blur+1.0/u_device_pixel_ratio)*v_gamma_scale;float alpha=clamp(min(dist-(v_width2.t-blur2),v_width2.s-dist)/blur2,0.0,1.0);gl_FragColor=color*(alpha*opacity);\n#ifdef OVERDRAW_INSPECTOR\ngl_FragColor=vec4(1.0);\n#endif\n}", "\n#define scale 0.015873016\nattribute vec2 a_pos_normal;attribute vec4 a_data;uniform mat4 u_matrix;uniform mediump float u_ratio;uniform vec2 u_units_to_pixels;uniform lowp float u_device_pixel_ratio;varying vec2 v_normal;varying vec2 v_width2;varying float v_gamma_scale;varying highp float v_linesofar;\n#pragma mapbox: define highp vec4 color\n#pragma mapbox: define lowp float blur\n#pragma mapbox: define lowp float opacity\n#pragma mapbox: define mediump float gapwidth\n#pragma mapbox: define lowp float offset\n#pragma mapbox: define mediump float width\nvoid main() {\n#pragma mapbox: initialize highp vec4 color\n#pragma mapbox: initialize lowp float blur\n#pragma mapbox: initialize lowp float opacity\n#pragma mapbox: initialize mediump float gapwidth\n#pragma mapbox: initialize lowp float offset\n#pragma mapbox: initialize mediump float width\nfloat ANTIALIASING=1.0/u_device_pixel_ratio/2.0;vec2 a_extrude=a_data.xy-128.0;float a_direction=mod(a_data.z,4.0)-1.0;v_linesofar=(floor(a_data.z/4.0)+a_data.w*64.0)*2.0;vec2 pos=floor(a_pos_normal*0.5);mediump vec2 normal=a_pos_normal-2.0*pos;normal.y=normal.y*2.0-1.0;v_normal=normal;gapwidth=gapwidth/2.0;float halfwidth=width/2.0;offset=-1.0*offset;float inset=gapwidth+(gapwidth > 0.0 ? ANTIALIASING : 0.0);float outset=gapwidth+halfwidth*(gapwidth > 0.0 ? 2.0 : 1.0)+(halfwidth==0.0 ? 0.0 : ANTIALIASING);mediump vec2 dist=outset*a_extrude*scale;mediump float u=0.5*a_direction;mediump float t=1.0-abs(u);mediump vec2 offset2=offset*a_extrude*scale*normal.y*mat2(t,-u,u,t);vec4 projected_extrude=u_matrix*vec4(dist/u_ratio,0.0,0.0);gl_Position=u_matrix*vec4(pos+offset2/u_ratio,0.0,1.0)+projected_extrude;\n#ifdef TERRAIN3D\nv_gamma_scale=1.0;\n#else\nfloat extrude_length_without_perspective=length(dist);float extrude_length_with_perspective=length(projected_extrude.xy/gl_Position.w*u_units_to_pixels);v_gamma_scale=extrude_length_without_perspective/extrude_length_with_perspective;\n#endif\nv_width2=vec2(outset,inset);}"), lineGradient: me2("uniform lowp float u_device_pixel_ratio;uniform sampler2D u_image;varying vec2 v_width2;varying vec2 v_normal;varying float v_gamma_scale;varying highp vec2 v_uv;\n#pragma mapbox: define lowp float blur\n#pragma mapbox: define lowp float opacity\nvoid main() {\n#pragma mapbox: initialize lowp float blur\n#pragma mapbox: initialize lowp float opacity\nfloat dist=length(v_normal)*v_width2.s;float blur2=(blur+1.0/u_device_pixel_ratio)*v_gamma_scale;float alpha=clamp(min(dist-(v_width2.t-blur2),v_width2.s-dist)/blur2,0.0,1.0);vec4 color=texture2D(u_image,v_uv);gl_FragColor=color*(alpha*opacity);\n#ifdef OVERDRAW_INSPECTOR\ngl_FragColor=vec4(1.0);\n#endif\n}", "\n#define scale 0.015873016\nattribute vec2 a_pos_normal;attribute vec4 a_data;attribute float a_uv_x;attribute float a_split_index;uniform mat4 u_matrix;uniform mediump float u_ratio;uniform lowp float u_device_pixel_ratio;uniform vec2 u_units_to_pixels;uniform float u_image_height;varying vec2 v_normal;varying vec2 v_width2;varying float v_gamma_scale;varying highp vec2 v_uv;\n#pragma mapbox: define lowp float blur\n#pragma mapbox: define lowp float opacity\n#pragma mapbox: define mediump float gapwidth\n#pragma mapbox: define lowp float offset\n#pragma mapbox: define mediump float width\nvoid main() {\n#pragma mapbox: initialize lowp float blur\n#pragma mapbox: initialize lowp float opacity\n#pragma mapbox: initialize mediump float gapwidth\n#pragma mapbox: initialize lowp float offset\n#pragma mapbox: initialize mediump float width\nfloat ANTIALIASING=1.0/u_device_pixel_ratio/2.0;vec2 a_extrude=a_data.xy-128.0;float a_direction=mod(a_data.z,4.0)-1.0;highp float texel_height=1.0/u_image_height;highp float half_texel_height=0.5*texel_height;v_uv=vec2(a_uv_x,a_split_index*texel_height-half_texel_height);vec2 pos=floor(a_pos_normal*0.5);mediump vec2 normal=a_pos_normal-2.0*pos;normal.y=normal.y*2.0-1.0;v_normal=normal;gapwidth=gapwidth/2.0;float halfwidth=width/2.0;offset=-1.0*offset;float inset=gapwidth+(gapwidth > 0.0 ? ANTIALIASING : 0.0);float outset=gapwidth+halfwidth*(gapwidth > 0.0 ? 2.0 : 1.0)+(halfwidth==0.0 ? 0.0 : ANTIALIASING);mediump vec2 dist=outset*a_extrude*scale;mediump float u=0.5*a_direction;mediump float t=1.0-abs(u);mediump vec2 offset2=offset*a_extrude*scale*normal.y*mat2(t,-u,u,t);vec4 projected_extrude=u_matrix*vec4(dist/u_ratio,0.0,0.0);gl_Position=u_matrix*vec4(pos+offset2/u_ratio,0.0,1.0)+projected_extrude;\n#ifdef TERRAIN3D\nv_gamma_scale=1.0;\n#else\nfloat extrude_length_without_perspective=length(dist);float extrude_length_with_perspective=length(projected_extrude.xy/gl_Position.w*u_units_to_pixels);v_gamma_scale=extrude_length_without_perspective/extrude_length_with_perspective;\n#endif\nv_width2=vec2(outset,inset);}"), linePattern: me2("#ifdef GL_ES\nprecision highp float;\n#endif\nuniform lowp float u_device_pixel_ratio;uniform vec2 u_texsize;uniform float u_fade;uniform mediump vec3 u_scale;uniform sampler2D u_image;varying vec2 v_normal;varying vec2 v_width2;varying float v_linesofar;varying float v_gamma_scale;varying float v_width;\n#pragma mapbox: define lowp vec4 pattern_from\n#pragma mapbox: define lowp vec4 pattern_to\n#pragma mapbox: define lowp float pixel_ratio_from\n#pragma mapbox: define lowp float pixel_ratio_to\n#pragma mapbox: define lowp float blur\n#pragma mapbox: define lowp float opacity\nvoid main() {\n#pragma mapbox: initialize mediump vec4 pattern_from\n#pragma mapbox: initialize mediump vec4 pattern_to\n#pragma mapbox: initialize lowp float pixel_ratio_from\n#pragma mapbox: initialize lowp float pixel_ratio_to\n#pragma mapbox: initialize lowp float blur\n#pragma mapbox: initialize lowp float opacity\nvec2 pattern_tl_a=pattern_from.xy;vec2 pattern_br_a=pattern_from.zw;vec2 pattern_tl_b=pattern_to.xy;vec2 pattern_br_b=pattern_to.zw;float tileZoomRatio=u_scale.x;float fromScale=u_scale.y;float toScale=u_scale.z;vec2 display_size_a=(pattern_br_a-pattern_tl_a)/pixel_ratio_from;vec2 display_size_b=(pattern_br_b-pattern_tl_b)/pixel_ratio_to;vec2 pattern_size_a=vec2(display_size_a.x*fromScale/tileZoomRatio,display_size_a.y);vec2 pattern_size_b=vec2(display_size_b.x*toScale/tileZoomRatio,display_size_b.y);float aspect_a=display_size_a.y/v_width;float aspect_b=display_size_b.y/v_width;float dist=length(v_normal)*v_width2.s;float blur2=(blur+1.0/u_device_pixel_ratio)*v_gamma_scale;float alpha=clamp(min(dist-(v_width2.t-blur2),v_width2.s-dist)/blur2,0.0,1.0);float x_a=mod(v_linesofar/pattern_size_a.x*aspect_a,1.0);float x_b=mod(v_linesofar/pattern_size_b.x*aspect_b,1.0);float y=0.5*v_normal.y+0.5;vec2 texel_size=1.0/u_texsize;vec2 pos_a=mix(pattern_tl_a*texel_size-texel_size,pattern_br_a*texel_size+texel_size,vec2(x_a,y));vec2 pos_b=mix(pattern_tl_b*texel_size-texel_size,pattern_br_b*texel_size+texel_size,vec2(x_b,y));vec4 color=mix(texture2D(u_image,pos_a),texture2D(u_image,pos_b),u_fade);gl_FragColor=color*alpha*opacity;\n#ifdef OVERDRAW_INSPECTOR\ngl_FragColor=vec4(1.0);\n#endif\n}", "\n#define scale 0.015873016\n#define LINE_DISTANCE_SCALE 2.0\nattribute vec2 a_pos_normal;attribute vec4 a_data;uniform mat4 u_matrix;uniform vec2 u_units_to_pixels;uniform mediump float u_ratio;uniform lowp float u_device_pixel_ratio;varying vec2 v_normal;varying vec2 v_width2;varying float v_linesofar;varying float v_gamma_scale;varying float v_width;\n#pragma mapbox: define lowp float blur\n#pragma mapbox: define lowp float opacity\n#pragma mapbox: define lowp float offset\n#pragma mapbox: define mediump float gapwidth\n#pragma mapbox: define mediump float width\n#pragma mapbox: define lowp float floorwidth\n#pragma mapbox: define lowp vec4 pattern_from\n#pragma mapbox: define lowp vec4 pattern_to\n#pragma mapbox: define lowp float pixel_ratio_from\n#pragma mapbox: define lowp float pixel_ratio_to\nvoid main() {\n#pragma mapbox: initialize lowp float blur\n#pragma mapbox: initialize lowp float opacity\n#pragma mapbox: initialize lowp float offset\n#pragma mapbox: initialize mediump float gapwidth\n#pragma mapbox: initialize mediump float width\n#pragma mapbox: initialize lowp float floorwidth\n#pragma mapbox: initialize mediump vec4 pattern_from\n#pragma mapbox: initialize mediump vec4 pattern_to\n#pragma mapbox: initialize lowp float pixel_ratio_from\n#pragma mapbox: initialize lowp float pixel_ratio_to\nfloat ANTIALIASING=1.0/u_device_pixel_ratio/2.0;vec2 a_extrude=a_data.xy-128.0;float a_direction=mod(a_data.z,4.0)-1.0;float a_linesofar=(floor(a_data.z/4.0)+a_data.w*64.0)*LINE_DISTANCE_SCALE;vec2 pos=floor(a_pos_normal*0.5);mediump vec2 normal=a_pos_normal-2.0*pos;normal.y=normal.y*2.0-1.0;v_normal=normal;gapwidth=gapwidth/2.0;float halfwidth=width/2.0;offset=-1.0*offset;float inset=gapwidth+(gapwidth > 0.0 ? ANTIALIASING : 0.0);float outset=gapwidth+halfwidth*(gapwidth > 0.0 ? 2.0 : 1.0)+(halfwidth==0.0 ? 0.0 : ANTIALIASING);mediump vec2 dist=outset*a_extrude*scale;mediump float u=0.5*a_direction;mediump float t=1.0-abs(u);mediump vec2 offset2=offset*a_extrude*scale*normal.y*mat2(t,-u,u,t);vec4 projected_extrude=u_matrix*vec4(dist/u_ratio,0.0,0.0);gl_Position=u_matrix*vec4(pos+offset2/u_ratio,0.0,1.0)+projected_extrude;\n#ifdef TERRAIN3D\nv_gamma_scale=1.0;\n#else\nfloat extrude_length_without_perspective=length(dist);float extrude_length_with_perspective=length(projected_extrude.xy/gl_Position.w*u_units_to_pixels);v_gamma_scale=extrude_length_without_perspective/extrude_length_with_perspective;\n#endif\nv_linesofar=a_linesofar;v_width2=vec2(outset,inset);v_width=floorwidth;}"), lineSDF: me2("uniform lowp float u_device_pixel_ratio;uniform sampler2D u_image;uniform float u_sdfgamma;uniform float u_mix;varying vec2 v_normal;varying vec2 v_width2;varying vec2 v_tex_a;varying vec2 v_tex_b;varying float v_gamma_scale;\n#pragma mapbox: define highp vec4 color\n#pragma mapbox: define lowp float blur\n#pragma mapbox: define lowp float opacity\n#pragma mapbox: define mediump float width\n#pragma mapbox: define lowp float floorwidth\nvoid main() {\n#pragma mapbox: initialize highp vec4 color\n#pragma mapbox: initialize lowp float blur\n#pragma mapbox: initialize lowp float opacity\n#pragma mapbox: initialize mediump float width\n#pragma mapbox: initialize lowp float floorwidth\nfloat dist=length(v_normal)*v_width2.s;float blur2=(blur+1.0/u_device_pixel_ratio)*v_gamma_scale;float alpha=clamp(min(dist-(v_width2.t-blur2),v_width2.s-dist)/blur2,0.0,1.0);float sdfdist_a=texture2D(u_image,v_tex_a).a;float sdfdist_b=texture2D(u_image,v_tex_b).a;float sdfdist=mix(sdfdist_a,sdfdist_b,u_mix);alpha*=smoothstep(0.5-u_sdfgamma/floorwidth,0.5+u_sdfgamma/floorwidth,sdfdist);gl_FragColor=color*(alpha*opacity);\n#ifdef OVERDRAW_INSPECTOR\ngl_FragColor=vec4(1.0);\n#endif\n}", "\n#define scale 0.015873016\n#define LINE_DISTANCE_SCALE 2.0\nattribute vec2 a_pos_normal;attribute vec4 a_data;uniform mat4 u_matrix;uniform mediump float u_ratio;uniform lowp float u_device_pixel_ratio;uniform vec2 u_patternscale_a;uniform float u_tex_y_a;uniform vec2 u_patternscale_b;uniform float u_tex_y_b;uniform vec2 u_units_to_pixels;varying vec2 v_normal;varying vec2 v_width2;varying vec2 v_tex_a;varying vec2 v_tex_b;varying float v_gamma_scale;\n#pragma mapbox: define highp vec4 color\n#pragma mapbox: define lowp float blur\n#pragma mapbox: define lowp float opacity\n#pragma mapbox: define mediump float gapwidth\n#pragma mapbox: define lowp float offset\n#pragma mapbox: define mediump float width\n#pragma mapbox: define lowp float floorwidth\nvoid main() {\n#pragma mapbox: initialize highp vec4 color\n#pragma mapbox: initialize lowp float blur\n#pragma mapbox: initialize lowp float opacity\n#pragma mapbox: initialize mediump float gapwidth\n#pragma mapbox: initialize lowp float offset\n#pragma mapbox: initialize mediump float width\n#pragma mapbox: initialize lowp float floorwidth\nfloat ANTIALIASING=1.0/u_device_pixel_ratio/2.0;vec2 a_extrude=a_data.xy-128.0;float a_direction=mod(a_data.z,4.0)-1.0;float a_linesofar=(floor(a_data.z/4.0)+a_data.w*64.0)*LINE_DISTANCE_SCALE;vec2 pos=floor(a_pos_normal*0.5);mediump vec2 normal=a_pos_normal-2.0*pos;normal.y=normal.y*2.0-1.0;v_normal=normal;gapwidth=gapwidth/2.0;float halfwidth=width/2.0;offset=-1.0*offset;float inset=gapwidth+(gapwidth > 0.0 ? ANTIALIASING : 0.0);float outset=gapwidth+halfwidth*(gapwidth > 0.0 ? 2.0 : 1.0)+(halfwidth==0.0 ? 0.0 : ANTIALIASING);mediump vec2 dist=outset*a_extrude*scale;mediump float u=0.5*a_direction;mediump float t=1.0-abs(u);mediump vec2 offset2=offset*a_extrude*scale*normal.y*mat2(t,-u,u,t);vec4 projected_extrude=u_matrix*vec4(dist/u_ratio,0.0,0.0);gl_Position=u_matrix*vec4(pos+offset2/u_ratio,0.0,1.0)+projected_extrude;\n#ifdef TERRAIN3D\nv_gamma_scale=1.0;\n#else\nfloat extrude_length_without_perspective=length(dist);float extrude_length_with_perspective=length(projected_extrude.xy/gl_Position.w*u_units_to_pixels);v_gamma_scale=extrude_length_without_perspective/extrude_length_with_perspective;\n#endif\nv_tex_a=vec2(a_linesofar*u_patternscale_a.x/floorwidth,normal.y*u_patternscale_a.y+u_tex_y_a);v_tex_b=vec2(a_linesofar*u_patternscale_b.x/floorwidth,normal.y*u_patternscale_b.y+u_tex_y_b);v_width2=vec2(outset,inset);}"), raster: me2("uniform float u_fade_t;uniform float u_opacity;uniform sampler2D u_image0;uniform sampler2D u_image1;varying vec2 v_pos0;varying vec2 v_pos1;uniform float u_brightness_low;uniform float u_brightness_high;uniform float u_saturation_factor;uniform float u_contrast_factor;uniform vec3 u_spin_weights;void main() {vec4 color0=texture2D(u_image0,v_pos0);vec4 color1=texture2D(u_image1,v_pos1);if (color0.a > 0.0) {color0.rgb=color0.rgb/color0.a;}if (color1.a > 0.0) {color1.rgb=color1.rgb/color1.a;}vec4 color=mix(color0,color1,u_fade_t);color.a*=u_opacity;vec3 rgb=color.rgb;rgb=vec3(dot(rgb,u_spin_weights.xyz),dot(rgb,u_spin_weights.zxy),dot(rgb,u_spin_weights.yzx));float average=(color.r+color.g+color.b)/3.0;rgb+=(average-rgb)*u_saturation_factor;rgb=(rgb-0.5)*u_contrast_factor+0.5;vec3 u_high_vec=vec3(u_brightness_low,u_brightness_low,u_brightness_low);vec3 u_low_vec=vec3(u_brightness_high,u_brightness_high,u_brightness_high);gl_FragColor=vec4(mix(u_high_vec,u_low_vec,rgb)*color.a,color.a);\n#ifdef OVERDRAW_INSPECTOR\ngl_FragColor=vec4(1.0);\n#endif\n}", "uniform mat4 u_matrix;uniform vec2 u_tl_parent;uniform float u_scale_parent;uniform float u_buffer_scale;attribute vec2 a_pos;attribute vec2 a_texture_pos;varying vec2 v_pos0;varying vec2 v_pos1;void main() {gl_Position=u_matrix*vec4(a_pos,0,1);v_pos0=(((a_texture_pos/8192.0)-0.5)/u_buffer_scale )+0.5;v_pos1=(v_pos0*u_scale_parent)+u_tl_parent;}"), symbolIcon: me2("uniform sampler2D u_texture;varying vec2 v_tex;varying float v_fade_opacity;\n#pragma mapbox: define lowp float opacity\nvoid main() {\n#pragma mapbox: initialize lowp float opacity\nlowp float alpha=opacity*v_fade_opacity;gl_FragColor=texture2D(u_texture,v_tex)*alpha;\n#ifdef OVERDRAW_INSPECTOR\ngl_FragColor=vec4(1.0);\n#endif\n}", "attribute vec4 a_pos_offset;attribute vec4 a_data;attribute vec4 a_pixeloffset;attribute vec3 a_projected_pos;attribute float a_fade_opacity;uniform bool u_is_size_zoom_constant;uniform bool u_is_size_feature_constant;uniform highp float u_size_t;uniform highp float u_size;uniform highp float u_camera_to_center_distance;uniform highp float u_pitch;uniform bool u_rotate_symbol;uniform highp float u_aspect_ratio;uniform float u_fade_change;uniform mat4 u_matrix;uniform mat4 u_label_plane_matrix;uniform mat4 u_coord_matrix;uniform bool u_is_text;uniform bool u_pitch_with_map;uniform vec2 u_texsize;uniform bool u_is_along_line;uniform bool u_is_variable_anchor;uniform vec2 u_translation;uniform float u_pitched_scale;varying vec2 v_tex;varying float v_fade_opacity;vec4 projectTileWithElevation(vec2 posInTile,float elevation) {return u_matrix*vec4(posInTile,elevation,1.0);}\n#pragma mapbox: define lowp float opacity\nvoid main() {\n#pragma mapbox: initialize lowp float opacity\nvec2 a_pos=a_pos_offset.xy;vec2 a_offset=a_pos_offset.zw;vec2 a_tex=a_data.xy;vec2 a_size=a_data.zw;float a_size_min=floor(a_size[0]*0.5);vec2 a_pxoffset=a_pixeloffset.xy;vec2 a_minFontScale=a_pixeloffset.zw/256.0;float ele=get_elevation(a_pos);highp float segment_angle=-a_projected_pos[2];float size;if (!u_is_size_zoom_constant && !u_is_size_feature_constant) {size=mix(a_size_min,a_size[1],u_size_t)/128.0;} else if (u_is_size_zoom_constant && !u_is_size_feature_constant) {size=a_size_min/128.0;} else {size=u_size;}vec2 translated_a_pos=a_pos+u_translation;vec4 projectedPoint=projectTileWithElevation(translated_a_pos,ele);highp float camera_to_anchor_distance=projectedPoint.w;highp float distance_ratio=u_pitch_with_map ?\ncamera_to_anchor_distance/u_camera_to_center_distance :\nu_camera_to_center_distance/camera_to_anchor_distance;highp float perspective_ratio=clamp(0.5+0.5*distance_ratio,0.0,4.0);size*=perspective_ratio;float fontScale=u_is_text ? size/24.0 : size;highp float symbol_rotation=0.0;if (u_rotate_symbol) {vec4 offsetProjectedPoint=projectTileWithElevation(translated_a_pos+vec2(1,0),ele);vec2 a=projectedPoint.xy/projectedPoint.w;vec2 b=offsetProjectedPoint.xy/offsetProjectedPoint.w;symbol_rotation=atan((b.y-a.y)/u_aspect_ratio,b.x-a.x);}highp float angle_sin=sin(segment_angle+symbol_rotation);highp float angle_cos=cos(segment_angle+symbol_rotation);mat2 rotation_matrix=mat2(angle_cos,-1.0*angle_sin,angle_sin,angle_cos);vec4 projected_pos;if (u_is_along_line || u_is_variable_anchor) {projected_pos=vec4(a_projected_pos.xy,ele,1.0);} else if (u_pitch_with_map) {projected_pos=u_label_plane_matrix*vec4(a_projected_pos.xy+u_translation,ele,1.0);} else {projected_pos=u_label_plane_matrix*projectTileWithElevation(a_projected_pos.xy+u_translation,ele);}float z=float(u_pitch_with_map)*projected_pos.z/projected_pos.w;float projectionScaling=1.0;vec4 finalPos=u_coord_matrix*vec4(projected_pos.xy/projected_pos.w+rotation_matrix*(a_offset/32.0*max(a_minFontScale,fontScale)+a_pxoffset/16.0)*projectionScaling,z,1.0);if(u_pitch_with_map) {finalPos=projectTileWithElevation(finalPos.xy,finalPos.z);}gl_Position=finalPos;v_tex=a_tex/u_texsize;vec2 fade_opacity=unpack_opacity(a_fade_opacity);float fade_change=fade_opacity[1] > 0.5 ? u_fade_change :-u_fade_change;float visibility=calculate_visibility(projectedPoint);v_fade_opacity=max(0.0,min(visibility,fade_opacity[0]+fade_change));}"), symbolSDF: me2("#define SDF_PX 8.0\nuniform bool u_is_halo;uniform sampler2D u_texture;uniform highp float u_gamma_scale;uniform lowp float u_device_pixel_ratio;uniform bool u_is_text;varying vec2 v_data0;varying vec3 v_data1;\n#pragma mapbox: define highp vec4 fill_color\n#pragma mapbox: define highp vec4 halo_color\n#pragma mapbox: define lowp float opacity\n#pragma mapbox: define lowp float halo_width\n#pragma mapbox: define lowp float halo_blur\nvoid main() {\n#pragma mapbox: initialize highp vec4 fill_color\n#pragma mapbox: initialize highp vec4 halo_color\n#pragma mapbox: initialize lowp float opacity\n#pragma mapbox: initialize lowp float halo_width\n#pragma mapbox: initialize lowp float halo_blur\nfloat EDGE_GAMMA=0.105/u_device_pixel_ratio;vec2 tex=v_data0.xy;float gamma_scale=v_data1.x;float size=v_data1.y;float fade_opacity=v_data1[2];float fontScale=u_is_text ? size/24.0 : size;lowp vec4 color=fill_color;highp float gamma=EDGE_GAMMA/(fontScale*u_gamma_scale);lowp float inner_edge=(256.0-64.0)/256.0;if (u_is_halo) {color=halo_color;gamma=(halo_blur*1.19/SDF_PX+EDGE_GAMMA)/(fontScale*u_gamma_scale);inner_edge=inner_edge+gamma*gamma_scale;}lowp float dist=texture2D(u_texture,tex).a;highp float gamma_scaled=gamma*gamma_scale;highp float alpha=smoothstep(inner_edge-gamma_scaled,inner_edge+gamma_scaled,dist);if (u_is_halo) {lowp float halo_edge=(6.0-halo_width/fontScale)/SDF_PX;alpha=min(smoothstep(halo_edge-gamma_scaled,halo_edge+gamma_scaled,dist),1.0-alpha);}gl_FragColor=color*(alpha*opacity*fade_opacity);\n#ifdef OVERDRAW_INSPECTOR\ngl_FragColor=vec4(1.0);\n#endif\n}", "attribute vec4 a_pos_offset;attribute vec4 a_data;attribute vec4 a_pixeloffset;attribute vec3 a_projected_pos;attribute float a_fade_opacity;uniform bool u_is_size_zoom_constant;uniform bool u_is_size_feature_constant;uniform highp float u_size_t;uniform highp float u_size;uniform mat4 u_matrix;uniform mat4 u_label_plane_matrix;uniform mat4 u_coord_matrix;uniform bool u_is_text;uniform bool u_pitch_with_map;uniform bool u_is_along_line;uniform bool u_is_variable_anchor;uniform highp float u_pitch;uniform bool u_rotate_symbol;uniform highp float u_aspect_ratio;uniform highp float u_camera_to_center_distance;uniform float u_fade_change;uniform vec2 u_texsize;uniform vec2 u_translation;uniform float u_pitched_scale;varying vec2 v_data0;varying vec3 v_data1;vec4 projectTileWithElevation(vec2 posInTile,float elevation) {return u_matrix*vec4(posInTile,elevation,1.0);}\n#pragma mapbox: define highp vec4 fill_color\n#pragma mapbox: define highp vec4 halo_color\n#pragma mapbox: define lowp float opacity\n#pragma mapbox: define lowp float halo_width\n#pragma mapbox: define lowp float halo_blur\nvoid main() {\n#pragma mapbox: initialize highp vec4 fill_color\n#pragma mapbox: initialize highp vec4 halo_color\n#pragma mapbox: initialize lowp float opacity\n#pragma mapbox: initialize lowp float halo_width\n#pragma mapbox: initialize lowp float halo_blur\nvec2 a_pos=a_pos_offset.xy;vec2 a_offset=a_pos_offset.zw;vec2 a_tex=a_data.xy;vec2 a_size=a_data.zw;float a_size_min=floor(a_size[0]*0.5);vec2 a_pxoffset=a_pixeloffset.xy;float ele=get_elevation(a_pos);highp float segment_angle=-a_projected_pos[2];float size;if (!u_is_size_zoom_constant && !u_is_size_feature_constant) {size=mix(a_size_min,a_size[1],u_size_t)/128.0;} else if (u_is_size_zoom_constant && !u_is_size_feature_constant) {size=a_size_min/128.0;} else {size=u_size;}vec2 translated_a_pos=a_pos+u_translation;vec4 projectedPoint=projectTileWithElevation(translated_a_pos,ele);highp float camera_to_anchor_distance=projectedPoint.w;highp float distance_ratio=u_pitch_with_map ?\ncamera_to_anchor_distance/u_camera_to_center_distance :\nu_camera_to_center_distance/camera_to_anchor_distance;highp float perspective_ratio=clamp(0.5+0.5*distance_ratio,0.0,4.0);size*=perspective_ratio;float fontScale=u_is_text ? size/24.0 : size;highp float symbol_rotation=0.0;if (u_rotate_symbol) {vec4 offsetProjectedPoint=projectTileWithElevation(translated_a_pos+vec2(1,0),ele);vec2 a=projectedPoint.xy/projectedPoint.w;vec2 b=offsetProjectedPoint.xy/offsetProjectedPoint.w;symbol_rotation=atan((b.y-a.y)/u_aspect_ratio,b.x-a.x);}highp float angle_sin=sin(segment_angle+symbol_rotation);highp float angle_cos=cos(segment_angle+symbol_rotation);mat2 rotation_matrix=mat2(angle_cos,-1.0*angle_sin,angle_sin,angle_cos);vec4 projected_pos;if (u_is_along_line || u_is_variable_anchor) {projected_pos=vec4(a_projected_pos.xy,ele,1.0);} else if (u_pitch_with_map) {projected_pos=u_label_plane_matrix*vec4(a_projected_pos.xy+u_translation,ele,1.0);} else {projected_pos=u_label_plane_matrix*projectTileWithElevation(a_projected_pos.xy+u_translation,ele);}float z=float(u_pitch_with_map)*projected_pos.z/projected_pos.w;float projectionScaling=1.0;vec4 finalPos=u_coord_matrix*vec4(projected_pos.xy/projected_pos.w+rotation_matrix*(a_offset/32.0*fontScale+a_pxoffset)*projectionScaling,z,1.0);if(u_pitch_with_map) {finalPos=projectTileWithElevation(finalPos.xy,finalPos.z);}float gamma_scale=finalPos.w;gl_Position=finalPos;vec2 fade_opacity=unpack_opacity(a_fade_opacity);float visibility=calculate_visibility(projectedPoint);float fade_change=fade_opacity[1] > 0.5 ? u_fade_change :-u_fade_change;float interpolated_fade_opacity=max(0.0,min(visibility,fade_opacity[0]+fade_change));v_data0=a_tex/u_texsize;v_data1=vec3(gamma_scale,size,interpolated_fade_opacity);}"), symbolTextAndIcon: me2("#define SDF_PX 8.0\n#define SDF 1.0\n#define ICON 0.0\nuniform bool u_is_halo;uniform sampler2D u_texture;uniform sampler2D u_texture_icon;uniform highp float u_gamma_scale;uniform lowp float u_device_pixel_ratio;varying vec4 v_data0;varying vec4 v_data1;\n#pragma mapbox: define highp vec4 fill_color\n#pragma mapbox: define highp vec4 halo_color\n#pragma mapbox: define lowp float opacity\n#pragma mapbox: define lowp float halo_width\n#pragma mapbox: define lowp float halo_blur\nvoid main() {\n#pragma mapbox: initialize highp vec4 fill_color\n#pragma mapbox: initialize highp vec4 halo_color\n#pragma mapbox: initialize lowp float opacity\n#pragma mapbox: initialize lowp float halo_width\n#pragma mapbox: initialize lowp float halo_blur\nfloat fade_opacity=v_data1[2];if (v_data1.w==ICON) {vec2 tex_icon=v_data0.zw;lowp float alpha=opacity*fade_opacity;gl_FragColor=texture2D(u_texture_icon,tex_icon)*alpha;\n#ifdef OVERDRAW_INSPECTOR\ngl_FragColor=vec4(1.0);\n#endif\nreturn;}vec2 tex=v_data0.xy;float EDGE_GAMMA=0.105/u_device_pixel_ratio;float gamma_scale=v_data1.x;float size=v_data1.y;float fontScale=size/24.0;lowp vec4 color=fill_color;highp float gamma=EDGE_GAMMA/(fontScale*u_gamma_scale);lowp float buff=(256.0-64.0)/256.0;if (u_is_halo) {color=halo_color;gamma=(halo_blur*1.19/SDF_PX+EDGE_GAMMA)/(fontScale*u_gamma_scale);buff=(6.0-halo_width/fontScale)/SDF_PX;}lowp float dist=texture2D(u_texture,tex).a;highp float gamma_scaled=gamma*gamma_scale;highp float alpha=smoothstep(buff-gamma_scaled,buff+gamma_scaled,dist);gl_FragColor=color*(alpha*opacity*fade_opacity);\n#ifdef OVERDRAW_INSPECTOR\ngl_FragColor=vec4(1.0);\n#endif\n}", "attribute vec4 a_pos_offset;attribute vec4 a_data;attribute vec3 a_projected_pos;attribute float a_fade_opacity;uniform bool u_is_size_zoom_constant;uniform bool u_is_size_feature_constant;uniform highp float u_size_t;uniform highp float u_size;uniform mat4 u_matrix;uniform mat4 u_label_plane_matrix;uniform mat4 u_coord_matrix;uniform bool u_is_text;uniform bool u_pitch_with_map;uniform highp float u_pitch;uniform bool u_rotate_symbol;uniform highp float u_aspect_ratio;uniform highp float u_camera_to_center_distance;uniform float u_fade_change;uniform vec2 u_texsize;uniform vec2 u_texsize_icon;uniform bool u_is_along_line;uniform bool u_is_variable_anchor;uniform vec2 u_translation;uniform float u_pitched_scale;varying vec4 v_data0;varying vec4 v_data1;vec4 projectTileWithElevation(vec2 posInTile,float elevation) {return u_matrix*vec4(posInTile,elevation,1.0);}\n#pragma mapbox: define highp vec4 fill_color\n#pragma mapbox: define highp vec4 halo_color\n#pragma mapbox: define lowp float opacity\n#pragma mapbox: define lowp float halo_width\n#pragma mapbox: define lowp float halo_blur\nvoid main() {\n#pragma mapbox: initialize highp vec4 fill_color\n#pragma mapbox: initialize highp vec4 halo_color\n#pragma mapbox: initialize lowp float opacity\n#pragma mapbox: initialize lowp float halo_width\n#pragma mapbox: initialize lowp float halo_blur\nvec2 a_pos=a_pos_offset.xy;vec2 a_offset=a_pos_offset.zw;vec2 a_tex=a_data.xy;vec2 a_size=a_data.zw;float a_size_min=floor(a_size[0]*0.5);float is_sdf=a_size[0]-2.0*a_size_min;float ele=get_elevation(a_pos);highp float segment_angle=-a_projected_pos[2];float size;if (!u_is_size_zoom_constant && !u_is_size_feature_constant) {size=mix(a_size_min,a_size[1],u_size_t)/128.0;} else if (u_is_size_zoom_constant && !u_is_size_feature_constant) {size=a_size_min/128.0;} else {size=u_size;}vec2 translated_a_pos=a_pos+u_translation;vec4 projectedPoint=projectTileWithElevation(translated_a_pos,ele);highp float camera_to_anchor_distance=projectedPoint.w;highp float distance_ratio=u_pitch_with_map ?\ncamera_to_anchor_distance/u_camera_to_center_distance :\nu_camera_to_center_distance/camera_to_anchor_distance;highp float perspective_ratio=clamp(0.5+0.5*distance_ratio,0.0,4.0);size*=perspective_ratio;float fontScale=size/24.0;highp float symbol_rotation=0.0;if (u_rotate_symbol) {vec4 offsetProjectedPoint=projectTileWithElevation(translated_a_pos+vec2(1,0),ele);vec2 a=projectedPoint.xy/projectedPoint.w;vec2 b=offsetProjectedPoint.xy/offsetProjectedPoint.w;symbol_rotation=atan((b.y-a.y)/u_aspect_ratio,b.x-a.x);}highp float angle_sin=sin(segment_angle+symbol_rotation);highp float angle_cos=cos(segment_angle+symbol_rotation);mat2 rotation_matrix=mat2(angle_cos,-1.0*angle_sin,angle_sin,angle_cos);vec4 projected_pos;if (u_is_along_line || u_is_variable_anchor) {projected_pos=vec4(a_projected_pos.xy,ele,1.0);} else if (u_pitch_with_map) {projected_pos=u_label_plane_matrix*vec4(a_projected_pos.xy+u_translation,ele,1.0);} else {projected_pos=u_label_plane_matrix*projectTileWithElevation(a_projected_pos.xy+u_translation,ele);}float z=float(u_pitch_with_map)*projected_pos.z/projected_pos.w;float projectionScaling=1.0;vec4 finalPos=u_coord_matrix*vec4(projected_pos.xy/projected_pos.w+rotation_matrix*(a_offset/32.0*fontScale)*projectionScaling,z,1.0);if(u_pitch_with_map) {finalPos=projectTileWithElevation(finalPos.xy,finalPos.z);}float gamma_scale=finalPos.w;gl_Position=finalPos;vec2 fade_opacity=unpack_opacity(a_fade_opacity);float visibility=calculate_visibility(projectedPoint);float fade_change=fade_opacity[1] > 0.5 ? u_fade_change :-u_fade_change;float interpolated_fade_opacity=max(0.0,min(visibility,fade_opacity[0]+fade_change));v_data0.xy=a_tex/u_texsize;v_data0.zw=a_tex/u_texsize_icon;v_data1=vec4(gamma_scale,size,interpolated_fade_opacity,is_sdf);}"), terrain: me2("uniform sampler2D u_texture;uniform vec4 u_fog_color;uniform vec4 u_horizon_color;uniform float u_fog_ground_blend;uniform float u_fog_ground_blend_opacity;uniform float u_horizon_fog_blend;varying vec2 v_texture_pos;varying float v_fog_depth;const float gamma=2.2;vec4 gammaToLinear(vec4 color) {return pow(color,vec4(gamma));}vec4 linearToGamma(vec4 color) {return pow(color,vec4(1.0/gamma));}void main() {vec4 surface_color=texture2D(u_texture,v_texture_pos);if (v_fog_depth > u_fog_ground_blend) {vec4 surface_color_linear=gammaToLinear(surface_color);float blend_color=smoothstep(0.0,1.0,max((v_fog_depth-u_horizon_fog_blend)/(1.0-u_horizon_fog_blend),0.0));vec4 fog_horizon_color_linear=mix(gammaToLinear(u_fog_color),gammaToLinear(u_horizon_color),blend_color);float factor_fog=max(v_fog_depth-u_fog_ground_blend,0.0)/(1.0-u_fog_ground_blend);gl_FragColor=linearToGamma(mix(surface_color_linear,fog_horizon_color_linear,pow(factor_fog,2.0)*u_fog_ground_blend_opacity));} else {gl_FragColor=surface_color;}}", "attribute vec3 a_pos3d;uniform mat4 u_matrix;uniform mat4 u_fog_matrix;uniform float u_ele_delta;varying vec2 v_texture_pos;varying float v_fog_depth;void main() {float ele=get_elevation(a_pos3d.xy);float ele_delta=a_pos3d.z==1.0 ? u_ele_delta : 0.0;v_texture_pos=a_pos3d.xy/8192.0;gl_Position=u_matrix*vec4(a_pos3d.xy,ele-ele_delta,1.0);vec4 pos=u_fog_matrix*vec4(a_pos3d.xy,ele,1.0);v_fog_depth=pos.z/pos.w*0.5+0.5;}"), terrainDepth: me2("varying float v_depth;const highp vec4 bitSh=vec4(256.*256.*256.,256.*256.,256.,1.);const highp vec4 bitMsk=vec4(0.,vec3(1./256.0));highp vec4 pack(highp float value) {highp vec4 comp=fract(value*bitSh);comp-=comp.xxyz*bitMsk;return comp;}void main() {gl_FragColor=pack(v_depth);}", "attribute vec3 a_pos3d;uniform mat4 u_matrix;uniform float u_ele_delta;varying float v_depth;void main() {float ele=get_elevation(a_pos3d.xy);float ele_delta=a_pos3d.z==1.0 ? u_ele_delta : 0.0;gl_Position=u_matrix*vec4(a_pos3d.xy,ele-ele_delta,1.0);v_depth=gl_Position.z/gl_Position.w;}"), terrainCoords: me2("precision mediump float;uniform sampler2D u_texture;uniform float u_terrain_coords_id;varying vec2 v_texture_pos;void main() {vec4 rgba=texture2D(u_texture,v_texture_pos);gl_FragColor=vec4(rgba.r,rgba.g,rgba.b,u_terrain_coords_id);}", "attribute vec3 a_pos3d;uniform mat4 u_matrix;uniform float u_ele_delta;varying vec2 v_texture_pos;void main() {float ele=get_elevation(a_pos3d.xy);float ele_delta=a_pos3d.z==1.0 ? u_ele_delta : 0.0;v_texture_pos=a_pos3d.xy/8192.0;gl_Position=u_matrix*vec4(a_pos3d.xy,ele-ele_delta,1.0);}"), sky: me2("uniform vec4 u_sky_color;uniform vec4 u_horizon_color;uniform float u_horizon;uniform float u_sky_horizon_blend;void main() {float y=gl_FragCoord.y;if (y > u_horizon) {float blend=y-u_horizon;if (blend < u_sky_horizon_blend) {gl_FragColor=mix(u_sky_color,u_horizon_color,pow(1.0-blend/u_sky_horizon_blend,2.0));} else {gl_FragColor=u_sky_color;}}}", "attribute vec2 a_pos;void main() {gl_Position=vec4(a_pos,1.0,1.0);}") };
+              function me2(t42, e22) {
+                const i22 = /#pragma mapbox: ([\w]+) ([\w]+) ([\w]+) ([\w]+)/g, a22 = e22.match(/attribute ([\w]+) ([\w]+)/g), s22 = t42.match(/uniform ([\w]+) ([\w]+)([\s]*)([\w]*)/g), o22 = e22.match(/uniform ([\w]+) ([\w]+)([\s]*)([\w]*)/g), r22 = o22 ? o22.concat(s22) : s22, n22 = {};
+                return { fragmentSource: t42 = t42.replace(i22, (t5, e3, i3, a3, s3) => (n22[s3] = true, "define" === e3 ? `
+#ifndef HAS_UNIFORM_u_${s3}
+varying ${i3} ${a3} ${s3};
+#else
+uniform ${i3} ${a3} u_${s3};
+#endif
+` : `
+#ifdef HAS_UNIFORM_u_${s3}
+    ${i3} ${a3} ${s3} = u_${s3};
+#endif
+`)), vertexSource: e22 = e22.replace(i22, (t5, e3, i3, a3, s3) => {
+                  const o3 = "float" === a3 ? "vec2" : "vec4", r3 = s3.match(/color/) ? "color" : o3;
+                  return n22[s3] ? "define" === e3 ? `
+#ifndef HAS_UNIFORM_u_${s3}
+uniform lowp float u_${s3}_t;
+attribute ${i3} ${o3} a_${s3};
+varying ${i3} ${a3} ${s3};
+#else
+uniform ${i3} ${a3} u_${s3};
+#endif
+` : "vec4" === r3 ? `
+#ifndef HAS_UNIFORM_u_${s3}
+    ${s3} = a_${s3};
+#else
+    ${i3} ${a3} ${s3} = u_${s3};
+#endif
+` : `
+#ifndef HAS_UNIFORM_u_${s3}
+    ${s3} = unpack_mix_${r3}(a_${s3}, u_${s3}_t);
+#else
+    ${i3} ${a3} ${s3} = u_${s3};
+#endif
+` : "define" === e3 ? `
+#ifndef HAS_UNIFORM_u_${s3}
+uniform lowp float u_${s3}_t;
+attribute ${i3} ${o3} a_${s3};
+#else
+uniform ${i3} ${a3} u_${s3};
+#endif
+` : "vec4" === r3 ? `
+#ifndef HAS_UNIFORM_u_${s3}
+    ${i3} ${a3} ${s3} = a_${s3};
+#else
+    ${i3} ${a3} ${s3} = u_${s3};
+#endif
+` : `
+#ifndef HAS_UNIFORM_u_${s3}
+    ${i3} ${a3} ${s3} = unpack_mix_${r3}(a_${s3}, u_${s3}_t);
+#else
+    ${i3} ${a3} ${s3} = u_${s3};
+#endif
+`;
+                }), staticAttributes: a22, staticUniforms: r22 };
+              }
+              class fe2 {
+                constructor() {
+                  this.boundProgram = null, this.boundLayoutVertexBuffer = null, this.boundPaintVertexBuffers = [], this.boundIndexBuffer = null, this.boundVertexOffset = null, this.boundDynamicVertexBuffer = null, this.vao = null;
+                }
+                bind(t42, e22, i22, a22, s22, o22, r22, n22, l22) {
+                  this.context = t42;
+                  let h22 = this.boundPaintVertexBuffers.length !== a22.length;
+                  for (let t5 = 0; !h22 && t5 < a22.length; t5++) this.boundPaintVertexBuffers[t5] !== a22[t5] && (h22 = true);
+                  !this.vao || this.boundProgram !== e22 || this.boundLayoutVertexBuffer !== i22 || h22 || this.boundIndexBuffer !== s22 || this.boundVertexOffset !== o22 || this.boundDynamicVertexBuffer !== r22 || this.boundDynamicVertexBuffer2 !== n22 || this.boundDynamicVertexBuffer3 !== l22 ? this.freshBind(e22, i22, a22, s22, o22, r22, n22, l22) : (t42.bindVertexArray.set(this.vao), r22 && r22.bind(), s22 && s22.dynamicDraw && s22.bind(), n22 && n22.bind(), l22 && l22.bind());
+                }
+                freshBind(t42, e22, i22, a22, s22, o22, r22, n22) {
+                  const l22 = t42.numAttributes, h22 = this.context, c22 = h22.gl;
+                  this.vao && this.destroy(), this.vao = h22.createVertexArray(), h22.bindVertexArray.set(this.vao), this.boundProgram = t42, this.boundLayoutVertexBuffer = e22, this.boundPaintVertexBuffers = i22, this.boundIndexBuffer = a22, this.boundVertexOffset = s22, this.boundDynamicVertexBuffer = o22, this.boundDynamicVertexBuffer2 = r22, this.boundDynamicVertexBuffer3 = n22, e22.enableAttributes(c22, t42);
+                  for (const e3 of i22) e3.enableAttributes(c22, t42);
+                  o22 && o22.enableAttributes(c22, t42), r22 && r22.enableAttributes(c22, t42), n22 && n22.enableAttributes(c22, t42), e22.bind(), e22.setVertexAttribPointers(c22, t42, s22);
+                  for (const e3 of i22) e3.bind(), e3.setVertexAttribPointers(c22, t42, s22);
+                  o22 && (o22.bind(), o22.setVertexAttribPointers(c22, t42, s22)), a22 && a22.bind(), r22 && (r22.bind(), r22.setVertexAttribPointers(c22, t42, s22)), n22 && (n22.bind(), n22.setVertexAttribPointers(c22, t42, s22)), h22.currentNumAttributes = l22;
+                }
+                destroy() {
+                  this.vao && (this.context.deleteVertexArray(this.vao), this.vao = null);
+                }
+              }
+              const ge2 = (t42, i22, a22, s22, o22) => ({ u_matrix: t42, u_texture: 0, u_ele_delta: i22, u_fog_matrix: a22, u_fog_color: s22 ? s22.properties.get("fog-color") : e2.aM.white, u_fog_ground_blend: s22 ? s22.properties.get("fog-ground-blend") : 1, u_fog_ground_blend_opacity: s22 ? s22.calculateFogBlendOpacity(o22) : 0, u_horizon_color: s22 ? s22.properties.get("horizon-color") : e2.aM.white, u_horizon_fog_blend: s22 ? s22.properties.get("horizon-fog-blend") : 1 });
+              function ve2(t42) {
+                const e22 = [];
+                for (let i22 = 0; i22 < t42.length; i22++) {
+                  if (null === t42[i22]) continue;
+                  const a22 = t42[i22].split(" ");
+                  e22.push(a22.pop());
+                }
+                return e22;
+              }
+              class xe2 {
+                constructor(t42, i22, a22, s22, o22, r22) {
+                  const n22 = t42.gl;
+                  this.program = n22.createProgram();
+                  const l22 = ve2(i22.staticAttributes), h22 = a22 ? a22.getBinderAttributes() : [], c22 = l22.concat(h22), u22 = pe2.prelude.staticUniforms ? ve2(pe2.prelude.staticUniforms) : [], d22 = i22.staticUniforms ? ve2(i22.staticUniforms) : [], _22 = a22 ? a22.getBinderUniforms() : [], p22 = u22.concat(d22).concat(_22), m22 = [];
+                  for (const t5 of p22) m22.indexOf(t5) < 0 && m22.push(t5);
+                  const f22 = a22 ? a22.defines() : [];
+                  o22 && f22.push("#define OVERDRAW_INSPECTOR;"), r22 && f22.push("#define TERRAIN3D;");
+                  const g22 = f22.concat(pe2.prelude.fragmentSource, i22.fragmentSource).join("\n"), v22 = f22.concat(pe2.prelude.vertexSource, i22.vertexSource).join("\n"), x22 = n22.createShader(n22.FRAGMENT_SHADER);
+                  if (n22.isContextLost()) return void (this.failedToCreate = true);
+                  if (n22.shaderSource(x22, g22), n22.compileShader(x22), !n22.getShaderParameter(x22, n22.COMPILE_STATUS)) throw new Error(`Could not compile fragment shader: ${n22.getShaderInfoLog(x22)}`);
+                  n22.attachShader(this.program, x22);
+                  const y22 = n22.createShader(n22.VERTEX_SHADER);
+                  if (n22.isContextLost()) return void (this.failedToCreate = true);
+                  if (n22.shaderSource(y22, v22), n22.compileShader(y22), !n22.getShaderParameter(y22, n22.COMPILE_STATUS)) throw new Error(`Could not compile vertex shader: ${n22.getShaderInfoLog(y22)}`);
+                  n22.attachShader(this.program, y22), this.attributes = {};
+                  const b22 = {};
+                  this.numAttributes = c22.length;
+                  for (let t5 = 0; t5 < this.numAttributes; t5++) c22[t5] && (n22.bindAttribLocation(this.program, t5, c22[t5]), this.attributes[c22[t5]] = t5);
+                  if (n22.linkProgram(this.program), !n22.getProgramParameter(this.program, n22.LINK_STATUS)) throw new Error(`Program failed to link: ${n22.getProgramInfoLog(this.program)}`);
+                  n22.deleteShader(y22), n22.deleteShader(x22);
+                  for (let t5 = 0; t5 < m22.length; t5++) {
+                    const e22 = m22[t5];
+                    if (e22 && !b22[e22]) {
+                      const t6 = n22.getUniformLocation(this.program, e22);
+                      t6 && (b22[e22] = t6);
+                    }
+                  }
+                  this.fixedUniforms = s22(t42, b22), this.terrainUniforms = ((t5, i3) => ({ u_depth: new e2.aH(t5, i3.u_depth), u_terrain: new e2.aH(t5, i3.u_terrain), u_terrain_dim: new e2.aI(t5, i3.u_terrain_dim), u_terrain_matrix: new e2.aJ(t5, i3.u_terrain_matrix), u_terrain_unpack: new e2.aK(t5, i3.u_terrain_unpack), u_terrain_exaggeration: new e2.aI(t5, i3.u_terrain_exaggeration) }))(t42, b22), this.binderUniforms = a22 ? a22.getUniforms(t42, b22) : [];
+                }
+                draw(t42, e22, i22, a22, s22, o22, r22, n22, l22, h22, c22, u22, d22, _22, p22, m22, f22, g22) {
+                  const v22 = t42.gl;
+                  if (this.failedToCreate) return;
+                  if (t42.program.set(this.program), t42.setDepthMode(i22), t42.setStencilMode(a22), t42.setColorMode(s22), t42.setCullFace(o22), n22) {
+                    t42.activeTexture.set(v22.TEXTURE2), v22.bindTexture(v22.TEXTURE_2D, n22.depthTexture), t42.activeTexture.set(v22.TEXTURE3), v22.bindTexture(v22.TEXTURE_2D, n22.texture);
+                    for (const t5 in this.terrainUniforms) this.terrainUniforms[t5].set(n22[t5]);
+                  }
+                  for (const t5 in this.fixedUniforms) this.fixedUniforms[t5].set(r22[t5]);
+                  p22 && p22.setUniforms(t42, this.binderUniforms, d22, { zoom: _22 });
+                  let x22 = 0;
+                  switch (e22) {
+                    case v22.LINES:
+                      x22 = 2;
+                      break;
+                    case v22.TRIANGLES:
+                      x22 = 3;
+                      break;
+                    case v22.LINE_STRIP:
+                      x22 = 1;
+                  }
+                  for (const i3 of u22.get()) {
+                    const a3 = i3.vaos || (i3.vaos = {});
+                    (a3[l22] || (a3[l22] = new fe2())).bind(t42, this, h22, p22 ? p22.getPaintVertexBuffers() : [], c22, i3.vertexOffset, m22, f22, g22), v22.drawElements(e22, i3.primitiveLength * x22, v22.UNSIGNED_SHORT, i3.primitiveOffset * x22 * 2);
+                  }
+                }
+              }
+              function ye2(t42, e22, i22) {
+                const a22 = 1 / Bt(i22, 1, e22.transform.tileZoom), s22 = Math.pow(2, i22.tileID.overscaledZ), o22 = i22.tileSize * Math.pow(2, e22.transform.tileZoom) / s22, r22 = o22 * (i22.tileID.canonical.x + i22.tileID.wrap * s22), n22 = o22 * i22.tileID.canonical.y;
+                return { u_image: 0, u_texsize: i22.imageAtlasTexture.size, u_scale: [a22, t42.fromScale, t42.toScale], u_fade: t42.t, u_pixel_coord_upper: [r22 >> 16, n22 >> 16], u_pixel_coord_lower: [65535 & r22, 65535 & n22] };
+              }
+              const be2 = (t42, i22, a22, s22) => {
+                const o22 = i22.style.light, r22 = o22.properties.get("position"), n22 = [r22.x, r22.y, r22.z], l22 = function() {
+                  var t5 = new e2.A(9);
+                  return e2.A != Float32Array && (t5[1] = 0, t5[2] = 0, t5[3] = 0, t5[5] = 0, t5[6] = 0, t5[7] = 0), t5[0] = 1, t5[4] = 1, t5[8] = 1, t5;
+                }();
+                "viewport" === o22.properties.get("anchor") && function(t5, e22) {
+                  var i3 = Math.sin(e22), a3 = Math.cos(e22);
+                  t5[0] = a3, t5[1] = i3, t5[2] = 0, t5[3] = -i3, t5[4] = a3, t5[5] = 0, t5[6] = 0, t5[7] = 0, t5[8] = 1;
+                }(l22, -i22.transform.angle), function(t5, e22, i3) {
+                  var a3 = e22[0], s3 = e22[1], o3 = e22[2];
+                  t5[0] = a3 * i3[0] + s3 * i3[3] + o3 * i3[6], t5[1] = a3 * i3[1] + s3 * i3[4] + o3 * i3[7], t5[2] = a3 * i3[2] + s3 * i3[5] + o3 * i3[8];
+                }(n22, n22, l22);
+                const h22 = o22.properties.get("color");
+                return { u_matrix: t42, u_lightpos: n22, u_lightintensity: o22.properties.get("intensity"), u_lightcolor: [h22.r, h22.g, h22.b], u_vertical_gradient: +a22, u_opacity: s22 };
+              }, we2 = (t42, i22, a22, s22, o22, r22, n22) => e2.e(be2(t42, i22, a22, s22), ye2(r22, i22, n22), { u_height_factor: -Math.pow(2, o22.overscaledZ) / n22.tileSize / 8 }), Te2 = (t42) => ({ u_matrix: t42 }), Ie2 = (t42, i22, a22, s22) => e2.e(Te2(t42), ye2(a22, i22, s22)), Ee2 = (t42, e22) => ({ u_matrix: t42, u_world: e22 }), Pe2 = (t42, i22, a22, s22, o22) => e2.e(Ie2(t42, i22, a22, s22), { u_world: o22 }), Ce2 = (t42, e22, i22, a22) => {
+                const s22 = t42.transform;
+                let o22, r22;
+                if ("map" === a22.paint.get("circle-pitch-alignment")) {
+                  const t5 = Bt(i22, 1, s22.zoom);
+                  o22 = true, r22 = [t5, t5];
+                } else o22 = false, r22 = s22.pixelsToGLUnits;
+                return { u_camera_to_center_distance: s22.cameraToCenterDistance, u_scale_with_map: +("map" === a22.paint.get("circle-pitch-scale")), u_matrix: t42.translatePosMatrix(e22.posMatrix, i22, a22.paint.get("circle-translate"), a22.paint.get("circle-translate-anchor")), u_pitch_with_map: +o22, u_device_pixel_ratio: t42.pixelRatio, u_extrude_scale: r22 };
+              }, Se2 = (t42, e22, i22) => ({ u_matrix: t42, u_inv_matrix: e22, u_camera_to_center_distance: i22.cameraToCenterDistance, u_viewport_size: [i22.width, i22.height] }), ze2 = (t42, e22, i22 = 1) => ({ u_matrix: t42, u_color: e22, u_overlay: 0, u_overlay_scale: i22 }), De2 = (t42) => ({ u_matrix: t42 }), Me2 = (t42, e22, i22, a22) => ({ u_matrix: t42, u_extrude_scale: Bt(e22, 1, i22), u_intensity: a22 }), Ae2 = (t42, i22, a22, s22) => {
+                const o22 = e2.H();
+                e2.aP(o22, 0, t42.width, t42.height, 0, 0, 1);
+                const r22 = t42.context.gl;
+                return { u_matrix: o22, u_world: [r22.drawingBufferWidth, r22.drawingBufferHeight], u_image: a22, u_color_ramp: s22, u_opacity: i22.paint.get("heatmap-opacity") };
+              };
+              function Re2(t42, i22) {
+                const a22 = Math.pow(2, i22.canonical.z), s22 = i22.canonical.y;
+                return [new e2.Z(0, s22 / a22).toLngLat().lat, new e2.Z(0, (s22 + 1) / a22).toLngLat().lat];
+              }
+              const ke2 = (t42, e22, i22, a22) => {
+                const s22 = t42.transform;
+                return { u_matrix: Ne2(t42, e22, i22, a22), u_ratio: 1 / Bt(e22, 1, s22.zoom), u_device_pixel_ratio: t42.pixelRatio, u_units_to_pixels: [1 / s22.pixelsToGLUnits[0], 1 / s22.pixelsToGLUnits[1]] };
+              }, Le2 = (t42, i22, a22, s22, o22) => e2.e(ke2(t42, i22, a22, o22), { u_image: 0, u_image_height: s22 }), Fe2 = (t42, e22, i22, a22, s22) => {
+                const o22 = t42.transform, r22 = Oe2(e22, o22);
+                return { u_matrix: Ne2(t42, e22, i22, s22), u_texsize: e22.imageAtlasTexture.size, u_ratio: 1 / Bt(e22, 1, o22.zoom), u_device_pixel_ratio: t42.pixelRatio, u_image: 0, u_scale: [r22, a22.fromScale, a22.toScale], u_fade: a22.t, u_units_to_pixels: [1 / o22.pixelsToGLUnits[0], 1 / o22.pixelsToGLUnits[1]] };
+              }, Be2 = (t42, i22, a22, s22, o22, r22) => {
+                const n22 = t42.lineAtlas, l22 = Oe2(i22, t42.transform), h22 = "round" === a22.layout.get("line-cap"), c22 = n22.getDash(s22.from, h22), u22 = n22.getDash(s22.to, h22), d22 = c22.width * o22.fromScale, _22 = u22.width * o22.toScale;
+                return e2.e(ke2(t42, i22, a22, r22), { u_patternscale_a: [l22 / d22, -c22.height / 2], u_patternscale_b: [l22 / _22, -u22.height / 2], u_sdfgamma: n22.width / (256 * Math.min(d22, _22) * t42.pixelRatio) / 2, u_image: 0, u_tex_y_a: c22.y, u_tex_y_b: u22.y, u_mix: o22.t });
+              };
+              function Oe2(t42, e22) {
+                return 1 / Bt(t42, 1, e22.tileZoom);
+              }
+              function Ne2(t42, e22, i22, a22) {
+                return t42.translatePosMatrix(a22 ? a22.posMatrix : e22.tileID.posMatrix, e22, i22.paint.get("line-translate"), i22.paint.get("line-translate-anchor"));
+              }
+              const Ue2 = (t42, e22, i22, a22, s22) => {
+                return { u_matrix: t42, u_tl_parent: e22, u_scale_parent: i22, u_buffer_scale: 1, u_fade_t: a22.mix, u_opacity: a22.opacity * s22.paint.get("raster-opacity"), u_image0: 0, u_image1: 1, u_brightness_low: s22.paint.get("raster-brightness-min"), u_brightness_high: s22.paint.get("raster-brightness-max"), u_saturation_factor: (r22 = s22.paint.get("raster-saturation"), r22 > 0 ? 1 - 1 / (1.001 - r22) : -r22), u_contrast_factor: (o22 = s22.paint.get("raster-contrast"), o22 > 0 ? 1 / (1 - o22) : 1 + o22), u_spin_weights: je2(s22.paint.get("raster-hue-rotate")) };
+                var o22, r22;
+              };
+              function je2(t42) {
+                t42 *= Math.PI / 180;
+                const e22 = Math.sin(t42), i22 = Math.cos(t42);
+                return [(2 * i22 + 1) / 3, (-Math.sqrt(3) * e22 - i22 + 1) / 3, (Math.sqrt(3) * e22 - i22 + 1) / 3];
+              }
+              const Ze2 = (t42, e22, i22, a22, s22, o22, r22, n22, l22, h22, c22, u22, d22, _22) => {
+                const p22 = r22.transform;
+                return { u_is_size_zoom_constant: +("constant" === t42 || "source" === t42), u_is_size_feature_constant: +("constant" === t42 || "camera" === t42), u_size_t: e22 ? e22.uSizeT : 0, u_size: e22 ? e22.uSize : 0, u_camera_to_center_distance: p22.cameraToCenterDistance, u_pitch: p22.pitch / 360 * 2 * Math.PI, u_rotate_symbol: +i22, u_aspect_ratio: p22.width / p22.height, u_fade_change: r22.options.fadeDuration ? r22.symbolFadeChange : 1, u_matrix: n22, u_label_plane_matrix: l22, u_coord_matrix: h22, u_is_text: +u22, u_pitch_with_map: +a22, u_is_along_line: s22, u_is_variable_anchor: o22, u_texsize: d22, u_texture: 0, u_translation: c22, u_pitched_scale: _22 };
+              }, qe2 = (t42, i22, a22, s22, o22, r22, n22, l22, h22, c22, u22, d22, _22, p22, m22) => {
+                const f22 = n22.transform;
+                return e2.e(Ze2(t42, i22, a22, s22, o22, r22, n22, l22, h22, c22, u22, d22, _22, m22), { u_gamma_scale: s22 ? Math.cos(f22._pitch) * f22.cameraToCenterDistance : 1, u_device_pixel_ratio: n22.pixelRatio, u_is_halo: 1 });
+              }, Ve2 = (t42, i22, a22, s22, o22, r22, n22, l22, h22, c22, u22, d22, _22, p22) => e2.e(qe2(t42, i22, a22, s22, o22, r22, n22, l22, h22, c22, u22, true, d22, true, p22), { u_texsize_icon: _22, u_texture_icon: 1 }), Ge2 = (t42, e22, i22) => ({ u_matrix: t42, u_opacity: e22, u_color: i22 }), He2 = (t42, i22, a22, s22, o22, r22) => e2.e(function(t5, e22, i3, a3) {
+                const s3 = i3.imageManager.getPattern(t5.from.toString()), o3 = i3.imageManager.getPattern(t5.to.toString()), { width: r3, height: n22 } = i3.imageManager.getPixelSize(), l22 = Math.pow(2, a3.tileID.overscaledZ), h22 = a3.tileSize * Math.pow(2, i3.transform.tileZoom) / l22, c22 = h22 * (a3.tileID.canonical.x + a3.tileID.wrap * l22), u22 = h22 * a3.tileID.canonical.y;
+                return { u_image: 0, u_pattern_tl_a: s3.tl, u_pattern_br_a: s3.br, u_pattern_tl_b: o3.tl, u_pattern_br_b: o3.br, u_texsize: [r3, n22], u_mix: e22.t, u_pattern_size_a: s3.displaySize, u_pattern_size_b: o3.displaySize, u_scale_a: e22.fromScale, u_scale_b: e22.toScale, u_tile_units_to_pixels: 1 / Bt(a3, 1, i3.transform.tileZoom), u_pixel_coord_upper: [c22 >> 16, u22 >> 16], u_pixel_coord_lower: [65535 & c22, 65535 & u22] };
+              }(s22, r22, a22, o22), { u_matrix: t42, u_opacity: i22 }), We2 = { fillExtrusion: (t42, i22) => ({ u_matrix: new e2.aJ(t42, i22.u_matrix), u_lightpos: new e2.aN(t42, i22.u_lightpos), u_lightintensity: new e2.aI(t42, i22.u_lightintensity), u_lightcolor: new e2.aN(t42, i22.u_lightcolor), u_vertical_gradient: new e2.aI(t42, i22.u_vertical_gradient), u_opacity: new e2.aI(t42, i22.u_opacity) }), fillExtrusionPattern: (t42, i22) => ({ u_matrix: new e2.aJ(t42, i22.u_matrix), u_lightpos: new e2.aN(t42, i22.u_lightpos), u_lightintensity: new e2.aI(t42, i22.u_lightintensity), u_lightcolor: new e2.aN(t42, i22.u_lightcolor), u_vertical_gradient: new e2.aI(t42, i22.u_vertical_gradient), u_height_factor: new e2.aI(t42, i22.u_height_factor), u_image: new e2.aH(t42, i22.u_image), u_texsize: new e2.aO(t42, i22.u_texsize), u_pixel_coord_upper: new e2.aO(t42, i22.u_pixel_coord_upper), u_pixel_coord_lower: new e2.aO(t42, i22.u_pixel_coord_lower), u_scale: new e2.aN(t42, i22.u_scale), u_fade: new e2.aI(t42, i22.u_fade), u_opacity: new e2.aI(t42, i22.u_opacity) }), fill: (t42, i22) => ({ u_matrix: new e2.aJ(t42, i22.u_matrix) }), fillPattern: (t42, i22) => ({ u_matrix: new e2.aJ(t42, i22.u_matrix), u_image: new e2.aH(t42, i22.u_image), u_texsize: new e2.aO(t42, i22.u_texsize), u_pixel_coord_upper: new e2.aO(t42, i22.u_pixel_coord_upper), u_pixel_coord_lower: new e2.aO(t42, i22.u_pixel_coord_lower), u_scale: new e2.aN(t42, i22.u_scale), u_fade: new e2.aI(t42, i22.u_fade) }), fillOutline: (t42, i22) => ({ u_matrix: new e2.aJ(t42, i22.u_matrix), u_world: new e2.aO(t42, i22.u_world) }), fillOutlinePattern: (t42, i22) => ({ u_matrix: new e2.aJ(t42, i22.u_matrix), u_world: new e2.aO(t42, i22.u_world), u_image: new e2.aH(t42, i22.u_image), u_texsize: new e2.aO(t42, i22.u_texsize), u_pixel_coord_upper: new e2.aO(t42, i22.u_pixel_coord_upper), u_pixel_coord_lower: new e2.aO(t42, i22.u_pixel_coord_lower), u_scale: new e2.aN(t42, i22.u_scale), u_fade: new e2.aI(t42, i22.u_fade) }), circle: (t42, i22) => ({ u_camera_to_center_distance: new e2.aI(t42, i22.u_camera_to_center_distance), u_scale_with_map: new e2.aH(t42, i22.u_scale_with_map), u_pitch_with_map: new e2.aH(t42, i22.u_pitch_with_map), u_extrude_scale: new e2.aO(t42, i22.u_extrude_scale), u_device_pixel_ratio: new e2.aI(t42, i22.u_device_pixel_ratio), u_matrix: new e2.aJ(t42, i22.u_matrix) }), collisionBox: (t42, i22) => ({ u_matrix: new e2.aJ(t42, i22.u_matrix), u_pixel_extrude_scale: new e2.aO(t42, i22.u_pixel_extrude_scale) }), collisionCircle: (t42, i22) => ({ u_matrix: new e2.aJ(t42, i22.u_matrix), u_inv_matrix: new e2.aJ(t42, i22.u_inv_matrix), u_camera_to_center_distance: new e2.aI(t42, i22.u_camera_to_center_distance), u_viewport_size: new e2.aO(t42, i22.u_viewport_size) }), debug: (t42, i22) => ({ u_color: new e2.aL(t42, i22.u_color), u_matrix: new e2.aJ(t42, i22.u_matrix), u_overlay: new e2.aH(t42, i22.u_overlay), u_overlay_scale: new e2.aI(t42, i22.u_overlay_scale) }), clippingMask: (t42, i22) => ({ u_matrix: new e2.aJ(t42, i22.u_matrix) }), heatmap: (t42, i22) => ({ u_extrude_scale: new e2.aI(t42, i22.u_extrude_scale), u_intensity: new e2.aI(t42, i22.u_intensity), u_matrix: new e2.aJ(t42, i22.u_matrix) }), heatmapTexture: (t42, i22) => ({ u_matrix: new e2.aJ(t42, i22.u_matrix), u_world: new e2.aO(t42, i22.u_world), u_image: new e2.aH(t42, i22.u_image), u_color_ramp: new e2.aH(t42, i22.u_color_ramp), u_opacity: new e2.aI(t42, i22.u_opacity) }), hillshade: (t42, i22) => ({ u_matrix: new e2.aJ(t42, i22.u_matrix), u_image: new e2.aH(t42, i22.u_image), u_latrange: new e2.aO(t42, i22.u_latrange), u_light: new e2.aO(t42, i22.u_light), u_shadow: new e2.aL(t42, i22.u_shadow), u_highlight: new e2.aL(t42, i22.u_highlight), u_accent: new e2.aL(t42, i22.u_accent) }), hillshadePrepare: (t42, i22) => ({ u_matrix: new e2.aJ(t42, i22.u_matrix), u_image: new e2.aH(t42, i22.u_image), u_dimension: new e2.aO(t42, i22.u_dimension), u_zoom: new e2.aI(t42, i22.u_zoom), u_unpack: new e2.aK(t42, i22.u_unpack) }), line: (t42, i22) => ({ u_matrix: new e2.aJ(t42, i22.u_matrix), u_ratio: new e2.aI(t42, i22.u_ratio), u_device_pixel_ratio: new e2.aI(t42, i22.u_device_pixel_ratio), u_units_to_pixels: new e2.aO(t42, i22.u_units_to_pixels) }), lineGradient: (t42, i22) => ({ u_matrix: new e2.aJ(t42, i22.u_matrix), u_ratio: new e2.aI(t42, i22.u_ratio), u_device_pixel_ratio: new e2.aI(t42, i22.u_device_pixel_ratio), u_units_to_pixels: new e2.aO(t42, i22.u_units_to_pixels), u_image: new e2.aH(t42, i22.u_image), u_image_height: new e2.aI(t42, i22.u_image_height) }), linePattern: (t42, i22) => ({ u_matrix: new e2.aJ(t42, i22.u_matrix), u_texsize: new e2.aO(t42, i22.u_texsize), u_ratio: new e2.aI(t42, i22.u_ratio), u_device_pixel_ratio: new e2.aI(t42, i22.u_device_pixel_ratio), u_image: new e2.aH(t42, i22.u_image), u_units_to_pixels: new e2.aO(t42, i22.u_units_to_pixels), u_scale: new e2.aN(t42, i22.u_scale), u_fade: new e2.aI(t42, i22.u_fade) }), lineSDF: (t42, i22) => ({ u_matrix: new e2.aJ(t42, i22.u_matrix), u_ratio: new e2.aI(t42, i22.u_ratio), u_device_pixel_ratio: new e2.aI(t42, i22.u_device_pixel_ratio), u_units_to_pixels: new e2.aO(t42, i22.u_units_to_pixels), u_patternscale_a: new e2.aO(t42, i22.u_patternscale_a), u_patternscale_b: new e2.aO(t42, i22.u_patternscale_b), u_sdfgamma: new e2.aI(t42, i22.u_sdfgamma), u_image: new e2.aH(t42, i22.u_image), u_tex_y_a: new e2.aI(t42, i22.u_tex_y_a), u_tex_y_b: new e2.aI(t42, i22.u_tex_y_b), u_mix: new e2.aI(t42, i22.u_mix) }), raster: (t42, i22) => ({ u_matrix: new e2.aJ(t42, i22.u_matrix), u_tl_parent: new e2.aO(t42, i22.u_tl_parent), u_scale_parent: new e2.aI(t42, i22.u_scale_parent), u_buffer_scale: new e2.aI(t42, i22.u_buffer_scale), u_fade_t: new e2.aI(t42, i22.u_fade_t), u_opacity: new e2.aI(t42, i22.u_opacity), u_image0: new e2.aH(t42, i22.u_image0), u_image1: new e2.aH(t42, i22.u_image1), u_brightness_low: new e2.aI(t42, i22.u_brightness_low), u_brightness_high: new e2.aI(t42, i22.u_brightness_high), u_saturation_factor: new e2.aI(t42, i22.u_saturation_factor), u_contrast_factor: new e2.aI(t42, i22.u_contrast_factor), u_spin_weights: new e2.aN(t42, i22.u_spin_weights) }), symbolIcon: (t42, i22) => ({ u_is_size_zoom_constant: new e2.aH(t42, i22.u_is_size_zoom_constant), u_is_size_feature_constant: new e2.aH(t42, i22.u_is_size_feature_constant), u_size_t: new e2.aI(t42, i22.u_size_t), u_size: new e2.aI(t42, i22.u_size), u_camera_to_center_distance: new e2.aI(t42, i22.u_camera_to_center_distance), u_pitch: new e2.aI(t42, i22.u_pitch), u_rotate_symbol: new e2.aH(t42, i22.u_rotate_symbol), u_aspect_ratio: new e2.aI(t42, i22.u_aspect_ratio), u_fade_change: new e2.aI(t42, i22.u_fade_change), u_matrix: new e2.aJ(t42, i22.u_matrix), u_label_plane_matrix: new e2.aJ(t42, i22.u_label_plane_matrix), u_coord_matrix: new e2.aJ(t42, i22.u_coord_matrix), u_is_text: new e2.aH(t42, i22.u_is_text), u_pitch_with_map: new e2.aH(t42, i22.u_pitch_with_map), u_is_along_line: new e2.aH(t42, i22.u_is_along_line), u_is_variable_anchor: new e2.aH(t42, i22.u_is_variable_anchor), u_texsize: new e2.aO(t42, i22.u_texsize), u_texture: new e2.aH(t42, i22.u_texture), u_translation: new e2.aO(t42, i22.u_translation), u_pitched_scale: new e2.aI(t42, i22.u_pitched_scale) }), symbolSDF: (t42, i22) => ({ u_is_size_zoom_constant: new e2.aH(t42, i22.u_is_size_zoom_constant), u_is_size_feature_constant: new e2.aH(t42, i22.u_is_size_feature_constant), u_size_t: new e2.aI(t42, i22.u_size_t), u_size: new e2.aI(t42, i22.u_size), u_camera_to_center_distance: new e2.aI(t42, i22.u_camera_to_center_distance), u_pitch: new e2.aI(t42, i22.u_pitch), u_rotate_symbol: new e2.aH(t42, i22.u_rotate_symbol), u_aspect_ratio: new e2.aI(t42, i22.u_aspect_ratio), u_fade_change: new e2.aI(t42, i22.u_fade_change), u_matrix: new e2.aJ(t42, i22.u_matrix), u_label_plane_matrix: new e2.aJ(t42, i22.u_label_plane_matrix), u_coord_matrix: new e2.aJ(t42, i22.u_coord_matrix), u_is_text: new e2.aH(t42, i22.u_is_text), u_pitch_with_map: new e2.aH(t42, i22.u_pitch_with_map), u_is_along_line: new e2.aH(t42, i22.u_is_along_line), u_is_variable_anchor: new e2.aH(t42, i22.u_is_variable_anchor), u_texsize: new e2.aO(t42, i22.u_texsize), u_texture: new e2.aH(t42, i22.u_texture), u_gamma_scale: new e2.aI(t42, i22.u_gamma_scale), u_device_pixel_ratio: new e2.aI(t42, i22.u_device_pixel_ratio), u_is_halo: new e2.aH(t42, i22.u_is_halo), u_translation: new e2.aO(t42, i22.u_translation), u_pitched_scale: new e2.aI(t42, i22.u_pitched_scale) }), symbolTextAndIcon: (t42, i22) => ({ u_is_size_zoom_constant: new e2.aH(t42, i22.u_is_size_zoom_constant), u_is_size_feature_constant: new e2.aH(t42, i22.u_is_size_feature_constant), u_size_t: new e2.aI(t42, i22.u_size_t), u_size: new e2.aI(t42, i22.u_size), u_camera_to_center_distance: new e2.aI(t42, i22.u_camera_to_center_distance), u_pitch: new e2.aI(t42, i22.u_pitch), u_rotate_symbol: new e2.aH(t42, i22.u_rotate_symbol), u_aspect_ratio: new e2.aI(t42, i22.u_aspect_ratio), u_fade_change: new e2.aI(t42, i22.u_fade_change), u_matrix: new e2.aJ(t42, i22.u_matrix), u_label_plane_matrix: new e2.aJ(t42, i22.u_label_plane_matrix), u_coord_matrix: new e2.aJ(t42, i22.u_coord_matrix), u_is_text: new e2.aH(t42, i22.u_is_text), u_pitch_with_map: new e2.aH(t42, i22.u_pitch_with_map), u_is_along_line: new e2.aH(t42, i22.u_is_along_line), u_is_variable_anchor: new e2.aH(t42, i22.u_is_variable_anchor), u_texsize: new e2.aO(t42, i22.u_texsize), u_texsize_icon: new e2.aO(t42, i22.u_texsize_icon), u_texture: new e2.aH(t42, i22.u_texture), u_texture_icon: new e2.aH(t42, i22.u_texture_icon), u_gamma_scale: new e2.aI(t42, i22.u_gamma_scale), u_device_pixel_ratio: new e2.aI(t42, i22.u_device_pixel_ratio), u_is_halo: new e2.aH(t42, i22.u_is_halo), u_translation: new e2.aO(t42, i22.u_translation), u_pitched_scale: new e2.aI(t42, i22.u_pitched_scale) }), background: (t42, i22) => ({ u_matrix: new e2.aJ(t42, i22.u_matrix), u_opacity: new e2.aI(t42, i22.u_opacity), u_color: new e2.aL(t42, i22.u_color) }), backgroundPattern: (t42, i22) => ({ u_matrix: new e2.aJ(t42, i22.u_matrix), u_opacity: new e2.aI(t42, i22.u_opacity), u_image: new e2.aH(t42, i22.u_image), u_pattern_tl_a: new e2.aO(t42, i22.u_pattern_tl_a), u_pattern_br_a: new e2.aO(t42, i22.u_pattern_br_a), u_pattern_tl_b: new e2.aO(t42, i22.u_pattern_tl_b), u_pattern_br_b: new e2.aO(t42, i22.u_pattern_br_b), u_texsize: new e2.aO(t42, i22.u_texsize), u_mix: new e2.aI(t42, i22.u_mix), u_pattern_size_a: new e2.aO(t42, i22.u_pattern_size_a), u_pattern_size_b: new e2.aO(t42, i22.u_pattern_size_b), u_scale_a: new e2.aI(t42, i22.u_scale_a), u_scale_b: new e2.aI(t42, i22.u_scale_b), u_pixel_coord_upper: new e2.aO(t42, i22.u_pixel_coord_upper), u_pixel_coord_lower: new e2.aO(t42, i22.u_pixel_coord_lower), u_tile_units_to_pixels: new e2.aI(t42, i22.u_tile_units_to_pixels) }), terrain: (t42, i22) => ({ u_matrix: new e2.aJ(t42, i22.u_matrix), u_texture: new e2.aH(t42, i22.u_texture), u_ele_delta: new e2.aI(t42, i22.u_ele_delta), u_fog_matrix: new e2.aJ(t42, i22.u_fog_matrix), u_fog_color: new e2.aL(t42, i22.u_fog_color), u_fog_ground_blend: new e2.aI(t42, i22.u_fog_ground_blend), u_fog_ground_blend_opacity: new e2.aI(t42, i22.u_fog_ground_blend_opacity), u_horizon_color: new e2.aL(t42, i22.u_horizon_color), u_horizon_fog_blend: new e2.aI(t42, i22.u_horizon_fog_blend) }), terrainDepth: (t42, i22) => ({ u_matrix: new e2.aJ(t42, i22.u_matrix), u_ele_delta: new e2.aI(t42, i22.u_ele_delta) }), terrainCoords: (t42, i22) => ({ u_matrix: new e2.aJ(t42, i22.u_matrix), u_texture: new e2.aH(t42, i22.u_texture), u_terrain_coords_id: new e2.aI(t42, i22.u_terrain_coords_id), u_ele_delta: new e2.aI(t42, i22.u_ele_delta) }), sky: (t42, i22) => ({ u_sky_color: new e2.aL(t42, i22.u_sky_color), u_horizon_color: new e2.aL(t42, i22.u_horizon_color), u_horizon: new e2.aI(t42, i22.u_horizon), u_sky_horizon_blend: new e2.aI(t42, i22.u_sky_horizon_blend) }) };
+              class $e2 {
+                constructor(t42, e22, i22) {
+                  this.context = t42;
+                  const a22 = t42.gl;
+                  this.buffer = a22.createBuffer(), this.dynamicDraw = Boolean(i22), this.context.unbindVAO(), t42.bindElementBuffer.set(this.buffer), a22.bufferData(a22.ELEMENT_ARRAY_BUFFER, e22.arrayBuffer, this.dynamicDraw ? a22.DYNAMIC_DRAW : a22.STATIC_DRAW), this.dynamicDraw || delete e22.arrayBuffer;
+                }
+                bind() {
+                  this.context.bindElementBuffer.set(this.buffer);
+                }
+                updateData(t42) {
+                  const e22 = this.context.gl;
+                  if (!this.dynamicDraw) throw new Error("Attempted to update data while not in dynamic mode.");
+                  this.context.unbindVAO(), this.bind(), e22.bufferSubData(e22.ELEMENT_ARRAY_BUFFER, 0, t42.arrayBuffer);
+                }
+                destroy() {
+                  this.buffer && (this.context.gl.deleteBuffer(this.buffer), delete this.buffer);
+                }
+              }
+              const Xe2 = { Int8: "BYTE", Uint8: "UNSIGNED_BYTE", Int16: "SHORT", Uint16: "UNSIGNED_SHORT", Int32: "INT", Uint32: "UNSIGNED_INT", Float32: "FLOAT" };
+              class Ke2 {
+                constructor(t42, e22, i22, a22) {
+                  this.length = e22.length, this.attributes = i22, this.itemSize = e22.bytesPerElement, this.dynamicDraw = a22, this.context = t42;
+                  const s22 = t42.gl;
+                  this.buffer = s22.createBuffer(), t42.bindVertexBuffer.set(this.buffer), s22.bufferData(s22.ARRAY_BUFFER, e22.arrayBuffer, this.dynamicDraw ? s22.DYNAMIC_DRAW : s22.STATIC_DRAW), this.dynamicDraw || delete e22.arrayBuffer;
+                }
+                bind() {
+                  this.context.bindVertexBuffer.set(this.buffer);
+                }
+                updateData(t42) {
+                  if (t42.length !== this.length) throw new Error(`Length of new data is ${t42.length}, which doesn't match current length of ${this.length}`);
+                  const e22 = this.context.gl;
+                  this.bind(), e22.bufferSubData(e22.ARRAY_BUFFER, 0, t42.arrayBuffer);
+                }
+                enableAttributes(t42, e22) {
+                  for (let i22 = 0; i22 < this.attributes.length; i22++) {
+                    const a22 = e22.attributes[this.attributes[i22].name];
+                    void 0 !== a22 && t42.enableVertexAttribArray(a22);
+                  }
+                }
+                setVertexAttribPointers(t42, e22, i22) {
+                  for (let a22 = 0; a22 < this.attributes.length; a22++) {
+                    const s22 = this.attributes[a22], o22 = e22.attributes[s22.name];
+                    void 0 !== o22 && t42.vertexAttribPointer(o22, s22.components, t42[Xe2[s22.type]], false, this.itemSize, s22.offset + this.itemSize * (i22 || 0));
+                  }
+                }
+                destroy() {
+                  this.buffer && (this.context.gl.deleteBuffer(this.buffer), delete this.buffer);
+                }
+              }
+              const Je2 = /* @__PURE__ */ new WeakMap();
+              function Ye2(t42) {
+                var e22;
+                if (Je2.has(t42)) return Je2.get(t42);
+                {
+                  const i22 = null === (e22 = t42.getParameter(t42.VERSION)) || void 0 === e22 ? void 0 : e22.startsWith("WebGL 2.0");
+                  return Je2.set(t42, i22), i22;
+                }
+              }
+              class Qe2 {
+                constructor(t42) {
+                  this.gl = t42.gl, this.default = this.getDefault(), this.current = this.default, this.dirty = false;
+                }
+                get() {
+                  return this.current;
+                }
+                set(t42) {
+                }
+                getDefault() {
+                  return this.default;
+                }
+                setDefault() {
+                  this.set(this.default);
+                }
+              }
+              class ti2 extends Qe2 {
+                getDefault() {
+                  return e2.aM.transparent;
+                }
+                set(t42) {
+                  const e22 = this.current;
+                  (t42.r !== e22.r || t42.g !== e22.g || t42.b !== e22.b || t42.a !== e22.a || this.dirty) && (this.gl.clearColor(t42.r, t42.g, t42.b, t42.a), this.current = t42, this.dirty = false);
+                }
+              }
+              class ei2 extends Qe2 {
+                getDefault() {
+                  return 1;
+                }
+                set(t42) {
+                  (t42 !== this.current || this.dirty) && (this.gl.clearDepth(t42), this.current = t42, this.dirty = false);
+                }
+              }
+              class ii2 extends Qe2 {
+                getDefault() {
+                  return 0;
+                }
+                set(t42) {
+                  (t42 !== this.current || this.dirty) && (this.gl.clearStencil(t42), this.current = t42, this.dirty = false);
+                }
+              }
+              class ai2 extends Qe2 {
+                getDefault() {
+                  return [true, true, true, true];
+                }
+                set(t42) {
+                  const e22 = this.current;
+                  (t42[0] !== e22[0] || t42[1] !== e22[1] || t42[2] !== e22[2] || t42[3] !== e22[3] || this.dirty) && (this.gl.colorMask(t42[0], t42[1], t42[2], t42[3]), this.current = t42, this.dirty = false);
+                }
+              }
+              class si2 extends Qe2 {
+                getDefault() {
+                  return true;
+                }
+                set(t42) {
+                  (t42 !== this.current || this.dirty) && (this.gl.depthMask(t42), this.current = t42, this.dirty = false);
+                }
+              }
+              class oi2 extends Qe2 {
+                getDefault() {
+                  return 255;
+                }
+                set(t42) {
+                  (t42 !== this.current || this.dirty) && (this.gl.stencilMask(t42), this.current = t42, this.dirty = false);
+                }
+              }
+              class ri2 extends Qe2 {
+                getDefault() {
+                  return { func: this.gl.ALWAYS, ref: 0, mask: 255 };
+                }
+                set(t42) {
+                  const e22 = this.current;
+                  (t42.func !== e22.func || t42.ref !== e22.ref || t42.mask !== e22.mask || this.dirty) && (this.gl.stencilFunc(t42.func, t42.ref, t42.mask), this.current = t42, this.dirty = false);
+                }
+              }
+              class ni2 extends Qe2 {
+                getDefault() {
+                  const t42 = this.gl;
+                  return [t42.KEEP, t42.KEEP, t42.KEEP];
+                }
+                set(t42) {
+                  const e22 = this.current;
+                  (t42[0] !== e22[0] || t42[1] !== e22[1] || t42[2] !== e22[2] || this.dirty) && (this.gl.stencilOp(t42[0], t42[1], t42[2]), this.current = t42, this.dirty = false);
+                }
+              }
+              class li2 extends Qe2 {
+                getDefault() {
+                  return false;
+                }
+                set(t42) {
+                  if (t42 === this.current && !this.dirty) return;
+                  const e22 = this.gl;
+                  t42 ? e22.enable(e22.STENCIL_TEST) : e22.disable(e22.STENCIL_TEST), this.current = t42, this.dirty = false;
+                }
+              }
+              class hi2 extends Qe2 {
+                getDefault() {
+                  return [0, 1];
+                }
+                set(t42) {
+                  const e22 = this.current;
+                  (t42[0] !== e22[0] || t42[1] !== e22[1] || this.dirty) && (this.gl.depthRange(t42[0], t42[1]), this.current = t42, this.dirty = false);
+                }
+              }
+              class ci2 extends Qe2 {
+                getDefault() {
+                  return false;
+                }
+                set(t42) {
+                  if (t42 === this.current && !this.dirty) return;
+                  const e22 = this.gl;
+                  t42 ? e22.enable(e22.DEPTH_TEST) : e22.disable(e22.DEPTH_TEST), this.current = t42, this.dirty = false;
+                }
+              }
+              class ui2 extends Qe2 {
+                getDefault() {
+                  return this.gl.LESS;
+                }
+                set(t42) {
+                  (t42 !== this.current || this.dirty) && (this.gl.depthFunc(t42), this.current = t42, this.dirty = false);
+                }
+              }
+              class di2 extends Qe2 {
+                getDefault() {
+                  return false;
+                }
+                set(t42) {
+                  if (t42 === this.current && !this.dirty) return;
+                  const e22 = this.gl;
+                  t42 ? e22.enable(e22.BLEND) : e22.disable(e22.BLEND), this.current = t42, this.dirty = false;
+                }
+              }
+              class _i extends Qe2 {
+                getDefault() {
+                  const t42 = this.gl;
+                  return [t42.ONE, t42.ZERO];
+                }
+                set(t42) {
+                  const e22 = this.current;
+                  (t42[0] !== e22[0] || t42[1] !== e22[1] || this.dirty) && (this.gl.blendFunc(t42[0], t42[1]), this.current = t42, this.dirty = false);
+                }
+              }
+              class pi2 extends Qe2 {
+                getDefault() {
+                  return e2.aM.transparent;
+                }
+                set(t42) {
+                  const e22 = this.current;
+                  (t42.r !== e22.r || t42.g !== e22.g || t42.b !== e22.b || t42.a !== e22.a || this.dirty) && (this.gl.blendColor(t42.r, t42.g, t42.b, t42.a), this.current = t42, this.dirty = false);
+                }
+              }
+              class mi2 extends Qe2 {
+                getDefault() {
+                  return this.gl.FUNC_ADD;
+                }
+                set(t42) {
+                  (t42 !== this.current || this.dirty) && (this.gl.blendEquation(t42), this.current = t42, this.dirty = false);
+                }
+              }
+              class fi2 extends Qe2 {
+                getDefault() {
+                  return false;
+                }
+                set(t42) {
+                  if (t42 === this.current && !this.dirty) return;
+                  const e22 = this.gl;
+                  t42 ? e22.enable(e22.CULL_FACE) : e22.disable(e22.CULL_FACE), this.current = t42, this.dirty = false;
+                }
+              }
+              class gi2 extends Qe2 {
+                getDefault() {
+                  return this.gl.BACK;
+                }
+                set(t42) {
+                  (t42 !== this.current || this.dirty) && (this.gl.cullFace(t42), this.current = t42, this.dirty = false);
+                }
+              }
+              class vi2 extends Qe2 {
+                getDefault() {
+                  return this.gl.CCW;
+                }
+                set(t42) {
+                  (t42 !== this.current || this.dirty) && (this.gl.frontFace(t42), this.current = t42, this.dirty = false);
+                }
+              }
+              class xi2 extends Qe2 {
+                getDefault() {
+                  return null;
+                }
+                set(t42) {
+                  (t42 !== this.current || this.dirty) && (this.gl.useProgram(t42), this.current = t42, this.dirty = false);
+                }
+              }
+              class yi2 extends Qe2 {
+                getDefault() {
+                  return this.gl.TEXTURE0;
+                }
+                set(t42) {
+                  (t42 !== this.current || this.dirty) && (this.gl.activeTexture(t42), this.current = t42, this.dirty = false);
+                }
+              }
+              class bi2 extends Qe2 {
+                getDefault() {
+                  const t42 = this.gl;
+                  return [0, 0, t42.drawingBufferWidth, t42.drawingBufferHeight];
+                }
+                set(t42) {
+                  const e22 = this.current;
+                  (t42[0] !== e22[0] || t42[1] !== e22[1] || t42[2] !== e22[2] || t42[3] !== e22[3] || this.dirty) && (this.gl.viewport(t42[0], t42[1], t42[2], t42[3]), this.current = t42, this.dirty = false);
+                }
+              }
+              class wi2 extends Qe2 {
+                getDefault() {
+                  return null;
+                }
+                set(t42) {
+                  if (t42 === this.current && !this.dirty) return;
+                  const e22 = this.gl;
+                  e22.bindFramebuffer(e22.FRAMEBUFFER, t42), this.current = t42, this.dirty = false;
+                }
+              }
+              class Ti2 extends Qe2 {
+                getDefault() {
+                  return null;
+                }
+                set(t42) {
+                  if (t42 === this.current && !this.dirty) return;
+                  const e22 = this.gl;
+                  e22.bindRenderbuffer(e22.RENDERBUFFER, t42), this.current = t42, this.dirty = false;
+                }
+              }
+              class Ii2 extends Qe2 {
+                getDefault() {
+                  return null;
+                }
+                set(t42) {
+                  if (t42 === this.current && !this.dirty) return;
+                  const e22 = this.gl;
+                  e22.bindTexture(e22.TEXTURE_2D, t42), this.current = t42, this.dirty = false;
+                }
+              }
+              class Ei2 extends Qe2 {
+                getDefault() {
+                  return null;
+                }
+                set(t42) {
+                  if (t42 === this.current && !this.dirty) return;
+                  const e22 = this.gl;
+                  e22.bindBuffer(e22.ARRAY_BUFFER, t42), this.current = t42, this.dirty = false;
+                }
+              }
+              class Pi2 extends Qe2 {
+                getDefault() {
+                  return null;
+                }
+                set(t42) {
+                  const e22 = this.gl;
+                  e22.bindBuffer(e22.ELEMENT_ARRAY_BUFFER, t42), this.current = t42, this.dirty = false;
+                }
+              }
+              class Ci2 extends Qe2 {
+                getDefault() {
+                  return null;
+                }
+                set(t42) {
+                  var e22;
+                  if (t42 === this.current && !this.dirty) return;
+                  const i22 = this.gl;
+                  Ye2(i22) ? i22.bindVertexArray(t42) : null === (e22 = i22.getExtension("OES_vertex_array_object")) || void 0 === e22 || e22.bindVertexArrayOES(t42), this.current = t42, this.dirty = false;
+                }
+              }
+              class Si2 extends Qe2 {
+                getDefault() {
+                  return 4;
+                }
+                set(t42) {
+                  if (t42 === this.current && !this.dirty) return;
+                  const e22 = this.gl;
+                  e22.pixelStorei(e22.UNPACK_ALIGNMENT, t42), this.current = t42, this.dirty = false;
+                }
+              }
+              class zi2 extends Qe2 {
+                getDefault() {
+                  return false;
+                }
+                set(t42) {
+                  if (t42 === this.current && !this.dirty) return;
+                  const e22 = this.gl;
+                  e22.pixelStorei(e22.UNPACK_PREMULTIPLY_ALPHA_WEBGL, t42), this.current = t42, this.dirty = false;
+                }
+              }
+              class Di2 extends Qe2 {
+                getDefault() {
+                  return false;
+                }
+                set(t42) {
+                  if (t42 === this.current && !this.dirty) return;
+                  const e22 = this.gl;
+                  e22.pixelStorei(e22.UNPACK_FLIP_Y_WEBGL, t42), this.current = t42, this.dirty = false;
+                }
+              }
+              class Mi2 extends Qe2 {
+                constructor(t42, e22) {
+                  super(t42), this.context = t42, this.parent = e22;
+                }
+                getDefault() {
+                  return null;
+                }
+              }
+              class Ai2 extends Mi2 {
+                setDirty() {
+                  this.dirty = true;
+                }
+                set(t42) {
+                  if (t42 === this.current && !this.dirty) return;
+                  this.context.bindFramebuffer.set(this.parent);
+                  const e22 = this.gl;
+                  e22.framebufferTexture2D(e22.FRAMEBUFFER, e22.COLOR_ATTACHMENT0, e22.TEXTURE_2D, t42, 0), this.current = t42, this.dirty = false;
+                }
+              }
+              class Ri2 extends Mi2 {
+                set(t42) {
+                  if (t42 === this.current && !this.dirty) return;
+                  this.context.bindFramebuffer.set(this.parent);
+                  const e22 = this.gl;
+                  e22.framebufferRenderbuffer(e22.FRAMEBUFFER, e22.DEPTH_ATTACHMENT, e22.RENDERBUFFER, t42), this.current = t42, this.dirty = false;
+                }
+              }
+              class ki2 extends Mi2 {
+                set(t42) {
+                  if (t42 === this.current && !this.dirty) return;
+                  this.context.bindFramebuffer.set(this.parent);
+                  const e22 = this.gl;
+                  e22.framebufferRenderbuffer(e22.FRAMEBUFFER, e22.DEPTH_STENCIL_ATTACHMENT, e22.RENDERBUFFER, t42), this.current = t42, this.dirty = false;
+                }
+              }
+              class Li2 {
+                constructor(t42, e22, i22, a22, s22) {
+                  this.context = t42, this.width = e22, this.height = i22;
+                  const o22 = t42.gl, r22 = this.framebuffer = o22.createFramebuffer();
+                  if (this.colorAttachment = new Ai2(t42, r22), a22) this.depthAttachment = s22 ? new ki2(t42, r22) : new Ri2(t42, r22);
+                  else if (s22) throw new Error("Stencil cannot be set without depth");
+                  if (o22.checkFramebufferStatus(o22.FRAMEBUFFER) !== o22.FRAMEBUFFER_COMPLETE) throw new Error("Framebuffer is not complete");
+                }
+                destroy() {
+                  const t42 = this.context.gl, e22 = this.colorAttachment.get();
+                  if (e22 && t42.deleteTexture(e22), this.depthAttachment) {
+                    const e3 = this.depthAttachment.get();
+                    e3 && t42.deleteRenderbuffer(e3);
+                  }
+                  t42.deleteFramebuffer(this.framebuffer);
+                }
+              }
+              class Fi2 {
+                constructor(t42, e22, i22) {
+                  this.blendFunction = t42, this.blendColor = e22, this.mask = i22;
+                }
+              }
+              Fi2.Replace = [1, 0], Fi2.disabled = new Fi2(Fi2.Replace, e2.aM.transparent, [false, false, false, false]), Fi2.unblended = new Fi2(Fi2.Replace, e2.aM.transparent, [true, true, true, true]), Fi2.alphaBlended = new Fi2([1, 771], e2.aM.transparent, [true, true, true, true]);
+              class Bi2 {
+                constructor(t42) {
+                  var e22, i22;
+                  if (this.gl = t42, this.clearColor = new ti2(this), this.clearDepth = new ei2(this), this.clearStencil = new ii2(this), this.colorMask = new ai2(this), this.depthMask = new si2(this), this.stencilMask = new oi2(this), this.stencilFunc = new ri2(this), this.stencilOp = new ni2(this), this.stencilTest = new li2(this), this.depthRange = new hi2(this), this.depthTest = new ci2(this), this.depthFunc = new ui2(this), this.blend = new di2(this), this.blendFunc = new _i(this), this.blendColor = new pi2(this), this.blendEquation = new mi2(this), this.cullFace = new fi2(this), this.cullFaceSide = new gi2(this), this.frontFace = new vi2(this), this.program = new xi2(this), this.activeTexture = new yi2(this), this.viewport = new bi2(this), this.bindFramebuffer = new wi2(this), this.bindRenderbuffer = new Ti2(this), this.bindTexture = new Ii2(this), this.bindVertexBuffer = new Ei2(this), this.bindElementBuffer = new Pi2(this), this.bindVertexArray = new Ci2(this), this.pixelStoreUnpack = new Si2(this), this.pixelStoreUnpackPremultiplyAlpha = new zi2(this), this.pixelStoreUnpackFlipY = new Di2(this), this.extTextureFilterAnisotropic = t42.getExtension("EXT_texture_filter_anisotropic") || t42.getExtension("MOZ_EXT_texture_filter_anisotropic") || t42.getExtension("WEBKIT_EXT_texture_filter_anisotropic"), this.extTextureFilterAnisotropic && (this.extTextureFilterAnisotropicMax = t42.getParameter(this.extTextureFilterAnisotropic.MAX_TEXTURE_MAX_ANISOTROPY_EXT)), this.maxTextureSize = t42.getParameter(t42.MAX_TEXTURE_SIZE), Ye2(t42)) {
+                    this.HALF_FLOAT = t42.HALF_FLOAT;
+                    const a22 = t42.getExtension("EXT_color_buffer_half_float");
+                    this.RGBA16F = null !== (e22 = t42.RGBA16F) && void 0 !== e22 ? e22 : null == a22 ? void 0 : a22.RGBA16F_EXT, this.RGB16F = null !== (i22 = t42.RGB16F) && void 0 !== i22 ? i22 : null == a22 ? void 0 : a22.RGB16F_EXT, t42.getExtension("EXT_color_buffer_float");
+                  } else {
+                    t42.getExtension("EXT_color_buffer_half_float"), t42.getExtension("OES_texture_half_float_linear");
+                    const e3 = t42.getExtension("OES_texture_half_float");
+                    this.HALF_FLOAT = null == e3 ? void 0 : e3.HALF_FLOAT_OES;
+                  }
+                }
+                setDefault() {
+                  this.unbindVAO(), this.clearColor.setDefault(), this.clearDepth.setDefault(), this.clearStencil.setDefault(), this.colorMask.setDefault(), this.depthMask.setDefault(), this.stencilMask.setDefault(), this.stencilFunc.setDefault(), this.stencilOp.setDefault(), this.stencilTest.setDefault(), this.depthRange.setDefault(), this.depthTest.setDefault(), this.depthFunc.setDefault(), this.blend.setDefault(), this.blendFunc.setDefault(), this.blendColor.setDefault(), this.blendEquation.setDefault(), this.cullFace.setDefault(), this.cullFaceSide.setDefault(), this.frontFace.setDefault(), this.program.setDefault(), this.activeTexture.setDefault(), this.bindFramebuffer.setDefault(), this.pixelStoreUnpack.setDefault(), this.pixelStoreUnpackPremultiplyAlpha.setDefault(), this.pixelStoreUnpackFlipY.setDefault();
+                }
+                setDirty() {
+                  this.clearColor.dirty = true, this.clearDepth.dirty = true, this.clearStencil.dirty = true, this.colorMask.dirty = true, this.depthMask.dirty = true, this.stencilMask.dirty = true, this.stencilFunc.dirty = true, this.stencilOp.dirty = true, this.stencilTest.dirty = true, this.depthRange.dirty = true, this.depthTest.dirty = true, this.depthFunc.dirty = true, this.blend.dirty = true, this.blendFunc.dirty = true, this.blendColor.dirty = true, this.blendEquation.dirty = true, this.cullFace.dirty = true, this.cullFaceSide.dirty = true, this.frontFace.dirty = true, this.program.dirty = true, this.activeTexture.dirty = true, this.viewport.dirty = true, this.bindFramebuffer.dirty = true, this.bindRenderbuffer.dirty = true, this.bindTexture.dirty = true, this.bindVertexBuffer.dirty = true, this.bindElementBuffer.dirty = true, this.bindVertexArray.dirty = true, this.pixelStoreUnpack.dirty = true, this.pixelStoreUnpackPremultiplyAlpha.dirty = true, this.pixelStoreUnpackFlipY.dirty = true;
+                }
+                createIndexBuffer(t42, e22) {
+                  return new $e2(this, t42, e22);
+                }
+                createVertexBuffer(t42, e22, i22) {
+                  return new Ke2(this, t42, e22, i22);
+                }
+                createRenderbuffer(t42, e22, i22) {
+                  const a22 = this.gl, s22 = a22.createRenderbuffer();
+                  return this.bindRenderbuffer.set(s22), a22.renderbufferStorage(a22.RENDERBUFFER, t42, e22, i22), this.bindRenderbuffer.set(null), s22;
+                }
+                createFramebuffer(t42, e22, i22, a22) {
+                  return new Li2(this, t42, e22, i22, a22);
+                }
+                clear({ color: t42, depth: e22, stencil: i22 }) {
+                  const a22 = this.gl;
+                  let s22 = 0;
+                  t42 && (s22 |= a22.COLOR_BUFFER_BIT, this.clearColor.set(t42), this.colorMask.set([true, true, true, true])), void 0 !== e22 && (s22 |= a22.DEPTH_BUFFER_BIT, this.depthRange.set([0, 1]), this.clearDepth.set(e22), this.depthMask.set(true)), void 0 !== i22 && (s22 |= a22.STENCIL_BUFFER_BIT, this.clearStencil.set(i22), this.stencilMask.set(255)), a22.clear(s22);
+                }
+                setCullFace(t42) {
+                  false === t42.enable ? this.cullFace.set(false) : (this.cullFace.set(true), this.cullFaceSide.set(t42.mode), this.frontFace.set(t42.frontFace));
+                }
+                setDepthMode(t42) {
+                  t42.func !== this.gl.ALWAYS || t42.mask ? (this.depthTest.set(true), this.depthFunc.set(t42.func), this.depthMask.set(t42.mask), this.depthRange.set(t42.range)) : this.depthTest.set(false);
+                }
+                setStencilMode(t42) {
+                  t42.test.func !== this.gl.ALWAYS || t42.mask ? (this.stencilTest.set(true), this.stencilMask.set(t42.mask), this.stencilOp.set([t42.fail, t42.depthFail, t42.pass]), this.stencilFunc.set({ func: t42.test.func, ref: t42.ref, mask: t42.test.mask })) : this.stencilTest.set(false);
+                }
+                setColorMode(t42) {
+                  e2.aE(t42.blendFunction, Fi2.Replace) ? this.blend.set(false) : (this.blend.set(true), this.blendFunc.set(t42.blendFunction), this.blendColor.set(t42.blendColor)), this.colorMask.set(t42.mask);
+                }
+                createVertexArray() {
+                  var t42;
+                  return Ye2(this.gl) ? this.gl.createVertexArray() : null === (t42 = this.gl.getExtension("OES_vertex_array_object")) || void 0 === t42 ? void 0 : t42.createVertexArrayOES();
+                }
+                deleteVertexArray(t42) {
+                  var e22;
+                  return Ye2(this.gl) ? this.gl.deleteVertexArray(t42) : null === (e22 = this.gl.getExtension("OES_vertex_array_object")) || void 0 === e22 ? void 0 : e22.deleteVertexArrayOES(t42);
+                }
+                unbindVAO() {
+                  this.bindVertexArray.set(null);
+                }
+              }
+              class Oi2 {
+                constructor(t42, e22, i22) {
+                  this.func = t42, this.mask = e22, this.range = i22;
+                }
+              }
+              Oi2.ReadOnly = false, Oi2.ReadWrite = true, Oi2.disabled = new Oi2(519, Oi2.ReadOnly, [0, 1]);
+              const Ni2 = 7680;
+              class Ui2 {
+                constructor(t42, e22, i22, a22, s22, o22) {
+                  this.test = t42, this.ref = e22, this.mask = i22, this.fail = a22, this.depthFail = s22, this.pass = o22;
+                }
+              }
+              Ui2.disabled = new Ui2({ func: 519, mask: 0 }, 0, 0, Ni2, Ni2, Ni2);
+              class ji2 {
+                constructor(t42, e22, i22) {
+                  this.enable = t42, this.mode = e22, this.frontFace = i22;
+                }
+              }
+              let Zi2;
+              function qi2(t42, i22, a22, s22, o22) {
+                const r22 = t42.context, n22 = r22.gl, l22 = t42.useProgram("collisionBox"), h22 = [];
+                let c22 = 0, u22 = 0;
+                for (let _3 = 0; _3 < s22.length; _3++) {
+                  const p3 = s22[_3], m3 = i22.getTile(p3).getBucket(a22);
+                  if (!m3) continue;
+                  const f3 = o22 ? m3.textCollisionBox : m3.iconCollisionBox, g3 = m3.collisionCircleArray;
+                  if (g3.length > 0) {
+                    const i3 = e2.H();
+                    e2.aQ(i3, m3.placementInvProjMatrix, t42.transform.glCoordMatrix), e2.aQ(i3, i3, m3.placementViewportMatrix), h22.push({ circleArray: g3, circleOffset: u22, transform: p3.posMatrix, invTransform: i3, coord: p3 }), c22 += g3.length / 4, u22 = c22;
+                  }
+                  f3 && l22.draw(r22, n22.LINES, Oi2.disabled, Ui2.disabled, t42.colorModeForRenderPass(), ji2.disabled, { u_matrix: p3.posMatrix, u_pixel_extrude_scale: [1 / (d22 = t42.transform).width, 1 / d22.height] }, t42.style.map.terrain && t42.style.map.terrain.getTerrainData(p3), a22.id, f3.layoutVertexBuffer, f3.indexBuffer, f3.segments, null, t42.transform.zoom, null, null, f3.collisionVertexBuffer);
+                }
+                var d22;
+                if (!o22 || !h22.length) return;
+                const _22 = t42.useProgram("collisionCircle"), p22 = new e2.aR();
+                p22.resize(4 * c22), p22._trim();
+                let m22 = 0;
+                for (const t5 of h22) for (let e22 = 0; e22 < t5.circleArray.length / 4; e22++) {
+                  const i3 = 4 * e22, a3 = t5.circleArray[i3 + 0], s3 = t5.circleArray[i3 + 1], o3 = t5.circleArray[i3 + 2], r3 = t5.circleArray[i3 + 3];
+                  p22.emplace(m22++, a3, s3, o3, r3, 0), p22.emplace(m22++, a3, s3, o3, r3, 1), p22.emplace(m22++, a3, s3, o3, r3, 2), p22.emplace(m22++, a3, s3, o3, r3, 3);
+                }
+                (!Zi2 || Zi2.length < 2 * c22) && (Zi2 = function(t5) {
+                  const i3 = 2 * t5, a3 = new e2.aT();
+                  a3.resize(i3), a3._trim();
+                  for (let t6 = 0; t6 < i3; t6++) {
+                    const e22 = 6 * t6;
+                    a3.uint16[e22 + 0] = 4 * t6 + 0, a3.uint16[e22 + 1] = 4 * t6 + 1, a3.uint16[e22 + 2] = 4 * t6 + 2, a3.uint16[e22 + 3] = 4 * t6 + 2, a3.uint16[e22 + 4] = 4 * t6 + 3, a3.uint16[e22 + 5] = 4 * t6 + 0;
+                  }
+                  return a3;
+                }(c22));
+                const f22 = r22.createIndexBuffer(Zi2, true), g22 = r22.createVertexBuffer(p22, e2.aS.members, true);
+                for (const i3 of h22) {
+                  const s3 = Se2(i3.transform, i3.invTransform, t42.transform);
+                  _22.draw(r22, n22.TRIANGLES, Oi2.disabled, Ui2.disabled, t42.colorModeForRenderPass(), ji2.disabled, s3, t42.style.map.terrain && t42.style.map.terrain.getTerrainData(i3.coord), a22.id, g22, f22, e2.a0.simpleSegment(0, 2 * i3.circleOffset, i3.circleArray.length, i3.circleArray.length / 2), null, t42.transform.zoom, null, null, null);
+                }
+                g22.destroy(), f22.destroy();
+              }
+              ji2.disabled = new ji2(false, 1029, 2305), ji2.backCCW = new ji2(true, 1029, 2305);
+              const Vi2 = e2.an(new Float32Array(16));
+              function Gi2(t42, i22, a22, s22, o22, r22) {
+                const { horizontalAlign: n22, verticalAlign: l22 } = e2.au(t42);
+                return new e2.P((-(n22 - 0.5) * i22 / o22 + s22[0]) * r22, (-(l22 - 0.5) * a22 / o22 + s22[1]) * r22);
+              }
+              function Hi2(t42, i22, a22, s22, o22, r22) {
+                const n22 = i22.tileAnchorPoint.add(new e2.P(i22.translation[0], i22.translation[1]));
+                if (i22.pitchWithMap) {
+                  let t5 = s22.mult(r22);
+                  a22 || (t5 = t5.rotate(-o22));
+                  const e22 = n22.add(t5);
+                  return xt(e22.x, e22.y, i22.labelPlaneMatrix, i22.getElevation).point;
+                }
+                if (a22) {
+                  const e22 = St(i22.tileAnchorPoint.x + 1, i22.tileAnchorPoint.y, i22).point.sub(t42), a3 = Math.atan(e22.y / e22.x) + (e22.x < 0 ? Math.PI : 0);
+                  return t42.add(s22.rotate(a3));
+                }
+                return t42.add(s22);
+              }
+              function Wi2(t42, i22, a22, s22, o22, r22, n22, l22, h22, c22, u22, d22, _22, p22) {
+                const m22 = t42.text.placedSymbolArray, f22 = t42.text.dynamicLayoutVertexArray, g22 = t42.icon.dynamicLayoutVertexArray, v22 = {};
+                f22.clear();
+                for (let g3 = 0; g3 < m22.length; g3++) {
+                  const x22 = m22.get(g3), y22 = x22.hidden || !x22.crossTileID || t42.allowVerticalPlacement && !x22.placedOrientation ? null : s22[x22.crossTileID];
+                  if (y22) {
+                    const s3 = new e2.P(x22.anchorX, x22.anchorY), m3 = { getElevation: p22, width: o22.width, height: o22.height, labelPlaneMatrix: r22, pitchWithMap: a22, projection: u22, tileAnchorPoint: s3, translation: d22, unwrappedTileID: _22 }, g4 = a22 ? xt(s3.x, s3.y, n22, p22) : St(s3.x, s3.y, m3), b22 = yt(o22.cameraToCenterDistance, g4.signedDistanceFromCamera);
+                    let w22 = e2.ai(t42.textSizeData, h22, x22) * b22 / e2.ap;
+                    a22 && (w22 *= t42.tilePixelRatio / l22);
+                    const { width: T22, height: I22, anchor: E3, textOffset: P22, textBoxScale: C3 } = y22, S22 = Gi2(E3, T22, I22, P22, C3, w22), z22 = u22.getPitchedTextCorrection(o22, s3.add(new e2.P(d22[0], d22[1])), _22), D3 = Hi2(g4.point, m3, i22, S22, o22.angle, z22), M22 = t42.allowVerticalPlacement && x22.placedOrientation === e2.ah.vertical ? Math.PI / 2 : 0;
+                    for (let t5 = 0; t5 < x22.numGlyphs; t5++) e2.aj(f22, D3, M22);
+                    c22 && x22.associatedIconIndex >= 0 && (v22[x22.associatedIconIndex] = { shiftedAnchor: D3, angle: M22 });
+                  } else Rt(x22.numGlyphs, f22);
+                }
+                if (c22) {
+                  g22.clear();
+                  const i3 = t42.icon.placedSymbolArray;
+                  for (let t5 = 0; t5 < i3.length; t5++) {
+                    const a3 = i3.get(t5);
+                    if (a3.hidden) Rt(a3.numGlyphs, g22);
+                    else {
+                      const i4 = v22[t5];
+                      if (i4) for (let t6 = 0; t6 < a3.numGlyphs; t6++) e2.aj(g22, i4.shiftedAnchor, i4.angle);
+                      else Rt(a3.numGlyphs, g22);
+                    }
+                  }
+                  t42.icon.dynamicLayoutVertexBuffer.updateData(g22);
+                }
+                t42.text.dynamicLayoutVertexBuffer.updateData(f22);
+              }
+              function $i2(t42, e22, i22) {
+                return i22.iconsInText && e22 ? "symbolTextAndIcon" : t42 ? "symbolSDF" : "symbolIcon";
+              }
+              function Xi2(t42, i22, a22, s22, o22, r22, n22, l22, h22, c22, u22, d22) {
+                const _22 = t42.context, p22 = _22.gl, m22 = t42.transform, f22 = ie2(), g22 = "map" === l22, v22 = "map" === h22, x22 = "viewport" !== l22 && "point" !== a22.layout.get("symbol-placement"), y22 = g22 && !v22 && !x22, b22 = !v22 && x22, w22 = !a22.layout.get("symbol-sort-key").isConstant();
+                let T22 = false;
+                const I22 = t42.depthModeForSublayer(0, Oi2.ReadOnly), E3 = a22._unevaluatedLayout.hasValue("text-variable-anchor") || a22._unevaluatedLayout.hasValue("text-variable-anchor-offset"), P22 = [], C3 = f22.getCircleRadiusCorrection(m22);
+                for (const l3 of s22) {
+                  const s3 = i22.getTile(l3), h3 = s3.getBucket(a22);
+                  if (!h3) continue;
+                  const u3 = o22 ? h3.text : h3.icon;
+                  if (!u3 || !u3.segments.get().length || !u3.hasVisibleVertices) continue;
+                  const d3 = u3.programConfigurations.get(a22.id), _3 = o22 || h3.sdfIcons, I3 = o22 ? h3.textSizeData : h3.iconSizeData, S22 = v22 || 0 !== m22.pitch, z22 = t42.useProgram($i2(_3, o22, h3), d3), D3 = e2.ag(I3, m22.zoom), M22 = t42.style.map.terrain && t42.style.map.terrain.getTerrainData(l3);
+                  let A3, R22, k22, L22, F22 = [0, 0], B3 = null;
+                  if (o22) R22 = s3.glyphAtlasTexture, k22 = p22.LINEAR, A3 = s3.glyphAtlasTexture.size, h3.iconsInText && (F22 = s3.imageAtlasTexture.size, B3 = s3.imageAtlasTexture, L22 = S22 || t42.options.rotating || t42.options.zooming || "composite" === I3.kind || "camera" === I3.kind ? p22.LINEAR : p22.NEAREST);
+                  else {
+                    const e22 = 1 !== a22.layout.get("icon-size").constantOr(0) || h3.iconsNeedLinear;
+                    R22 = s3.imageAtlasTexture, k22 = _3 || t42.options.rotating || t42.options.zooming || e22 || S22 ? p22.LINEAR : p22.NEAREST, A3 = s3.imageAtlasTexture.size;
+                  }
+                  const O22 = Bt(s3, 1, t42.transform.zoom), N22 = b22 ? l3.posMatrix : Vi2, U22 = gt2(N22, v22, g22, t42.transform, O22), j22 = vt(N22, v22, g22, t42.transform, O22), Z22 = vt(l3.posMatrix, v22, g22, t42.transform, O22), q22 = f22.translatePosition(t42.transform, s3, r22, n22), V22 = E3 && h3.hasTextData(), G22 = "none" !== a22.layout.get("icon-text-fit") && V22 && h3.hasIconData();
+                  if (x22) {
+                    const e22 = t42.style.map.terrain ? (e3, i4) => t42.style.map.terrain.getElevation(l3, e3, i4) : null, i3 = "map" === a22.layout.get("text-rotation-alignment");
+                    wt(h3, l3.posMatrix, t42, o22, U22, Z22, v22, c22, i3, f22, l3.toUnwrapped(), m22.width, m22.height, q22, e22);
+                  }
+                  const H22 = l3.posMatrix, W22 = o22 && E3 || G22, $22 = x22 || W22 ? Vi2 : U22, X22 = j22, K3 = _3 && 0 !== a22.paint.get(o22 ? "text-halo-width" : "icon-halo-width").constantOr(1);
+                  let J22;
+                  J22 = _3 ? h3.iconsInText ? Ve2(I3.kind, D3, y22, v22, x22, W22, t42, H22, $22, X22, q22, A3, F22, C3) : qe2(I3.kind, D3, y22, v22, x22, W22, t42, H22, $22, X22, q22, o22, A3, true, C3) : Ze2(I3.kind, D3, y22, v22, x22, W22, t42, H22, $22, X22, q22, o22, A3, C3);
+                  const Y22 = { program: z22, buffers: u3, uniformValues: J22, atlasTexture: R22, atlasTextureIcon: B3, atlasInterpolation: k22, atlasInterpolationIcon: L22, isSDF: _3, hasHalo: K3 };
+                  if (w22 && h3.canOverlap) {
+                    T22 = true;
+                    const t5 = u3.segments.get();
+                    for (const i3 of t5) P22.push({ segments: new e2.a0([i3]), sortKey: i3.sortKey, state: Y22, terrainData: M22 });
+                  } else P22.push({ segments: u3.segments, sortKey: 0, state: Y22, terrainData: M22 });
+                }
+                T22 && P22.sort((t5, e22) => t5.sortKey - e22.sortKey);
+                for (const e22 of P22) {
+                  const i3 = e22.state;
+                  if (_22.activeTexture.set(p22.TEXTURE0), i3.atlasTexture.bind(i3.atlasInterpolation, p22.CLAMP_TO_EDGE), i3.atlasTextureIcon && (_22.activeTexture.set(p22.TEXTURE1), i3.atlasTextureIcon && i3.atlasTextureIcon.bind(i3.atlasInterpolationIcon, p22.CLAMP_TO_EDGE)), i3.isSDF) {
+                    const s3 = i3.uniformValues;
+                    i3.hasHalo && (s3.u_is_halo = 1, Ki2(i3.buffers, e22.segments, a22, t42, i3.program, I22, u22, d22, s3, e22.terrainData)), s3.u_is_halo = 0;
+                  }
+                  Ki2(i3.buffers, e22.segments, a22, t42, i3.program, I22, u22, d22, i3.uniformValues, e22.terrainData);
+                }
+              }
+              function Ki2(t42, e22, i22, a22, s22, o22, r22, n22, l22, h22) {
+                const c22 = a22.context;
+                s22.draw(c22, c22.gl.TRIANGLES, o22, r22, n22, ji2.disabled, l22, h22, i22.id, t42.layoutVertexBuffer, t42.indexBuffer, e22, i22.paint, a22.transform.zoom, t42.programConfigurations.get(i22.id), t42.dynamicLayoutVertexBuffer, t42.opacityVertexBuffer);
+              }
+              function Ji2(t42, i22, a22, s22) {
+                const o22 = t42.context, r22 = o22.gl, n22 = Ui2.disabled, l22 = new Fi2([r22.ONE, r22.ONE], e2.aM.transparent, [true, true, true, true]), h22 = i22.getBucket(a22);
+                if (!h22) return;
+                const c22 = s22.key;
+                let u22 = a22.heatmapFbos.get(c22);
+                u22 || (u22 = Qi2(o22, i22.tileSize, i22.tileSize), a22.heatmapFbos.set(c22, u22)), o22.bindFramebuffer.set(u22.framebuffer), o22.viewport.set([0, 0, i22.tileSize, i22.tileSize]), o22.clear({ color: e2.aM.transparent });
+                const d22 = h22.programConfigurations.get(a22.id), _22 = t42.useProgram("heatmap", d22), p22 = t42.style.map.terrain.getTerrainData(s22);
+                _22.draw(o22, r22.TRIANGLES, Oi2.disabled, n22, l22, ji2.disabled, Me2(s22.posMatrix, i22, t42.transform.zoom, a22.paint.get("heatmap-intensity")), p22, a22.id, h22.layoutVertexBuffer, h22.indexBuffer, h22.segments, a22.paint, t42.transform.zoom, d22);
+              }
+              function Yi2(t42, e22, i22) {
+                const a22 = t42.context, s22 = a22.gl;
+                a22.setColorMode(t42.colorModeForRenderPass());
+                const o22 = ta2(a22, e22), r22 = i22.key, n22 = e22.heatmapFbos.get(r22);
+                n22 && (a22.activeTexture.set(s22.TEXTURE0), s22.bindTexture(s22.TEXTURE_2D, n22.colorAttachment.get()), a22.activeTexture.set(s22.TEXTURE1), o22.bind(s22.LINEAR, s22.CLAMP_TO_EDGE), t42.useProgram("heatmapTexture").draw(a22, s22.TRIANGLES, Oi2.disabled, Ui2.disabled, t42.colorModeForRenderPass(), ji2.disabled, Ae2(t42, e22, 0, 1), null, e22.id, t42.rasterBoundsBuffer, t42.quadTriangleIndexBuffer, t42.rasterBoundsSegments, e22.paint, t42.transform.zoom), n22.destroy(), e22.heatmapFbos.delete(r22));
+              }
+              function Qi2(t42, e22, i22) {
+                var a22, s22;
+                const o22 = t42.gl, r22 = o22.createTexture();
+                o22.bindTexture(o22.TEXTURE_2D, r22), o22.texParameteri(o22.TEXTURE_2D, o22.TEXTURE_WRAP_S, o22.CLAMP_TO_EDGE), o22.texParameteri(o22.TEXTURE_2D, o22.TEXTURE_WRAP_T, o22.CLAMP_TO_EDGE), o22.texParameteri(o22.TEXTURE_2D, o22.TEXTURE_MIN_FILTER, o22.LINEAR), o22.texParameteri(o22.TEXTURE_2D, o22.TEXTURE_MAG_FILTER, o22.LINEAR);
+                const n22 = null !== (a22 = t42.HALF_FLOAT) && void 0 !== a22 ? a22 : o22.UNSIGNED_BYTE, l22 = null !== (s22 = t42.RGBA16F) && void 0 !== s22 ? s22 : o22.RGBA;
+                o22.texImage2D(o22.TEXTURE_2D, 0, l22, e22, i22, 0, o22.RGBA, n22, null);
+                const h22 = t42.createFramebuffer(e22, i22, false, false);
+                return h22.colorAttachment.set(r22), h22;
+              }
+              function ta2(t42, e22) {
+                return e22.colorRampTexture || (e22.colorRampTexture = new b2(t42, e22.colorRamp, t42.gl.RGBA)), e22.colorRampTexture;
+              }
+              function ea2(t42, e22, i22, a22, s22) {
+                if (!i22 || !a22 || !a22.imageAtlas) return;
+                const o22 = a22.imageAtlas.patternPositions;
+                let r22 = o22[i22.to.toString()], n22 = o22[i22.from.toString()];
+                if (!r22 && n22 && (r22 = n22), !n22 && r22 && (n22 = r22), !r22 || !n22) {
+                  const t5 = s22.getPaintProperty(e22);
+                  r22 = o22[t5], n22 = o22[t5];
+                }
+                r22 && n22 && t42.setConstantPatternPositions(r22, n22);
+              }
+              function ia2(t42, e22, i22, a22, s22, o22, r22) {
+                const n22 = t42.context.gl, l22 = "fill-pattern", h22 = i22.paint.get(l22), c22 = h22 && h22.constantOr(1), u22 = i22.getCrossfadeParameters();
+                let d22, _22, p22, m22, f22;
+                r22 ? (_22 = c22 && !i22.getPaintProperty("fill-outline-color") ? "fillOutlinePattern" : "fillOutline", d22 = n22.LINES) : (_22 = c22 ? "fillPattern" : "fill", d22 = n22.TRIANGLES);
+                const g22 = h22.constantOr(null);
+                for (const h3 of a22) {
+                  const a3 = e22.getTile(h3);
+                  if (c22 && !a3.patternsLoaded()) continue;
+                  const v22 = a3.getBucket(i22);
+                  if (!v22) continue;
+                  const x22 = v22.programConfigurations.get(i22.id), y22 = t42.useProgram(_22, x22), b22 = t42.style.map.terrain && t42.style.map.terrain.getTerrainData(h3);
+                  c22 && (t42.context.activeTexture.set(n22.TEXTURE0), a3.imageAtlasTexture.bind(n22.LINEAR, n22.CLAMP_TO_EDGE), x22.updatePaintBuffers(u22)), ea2(x22, l22, g22, a3, i22);
+                  const w22 = b22 ? h3 : null, T22 = t42.translatePosMatrix(w22 ? w22.posMatrix : h3.posMatrix, a3, i22.paint.get("fill-translate"), i22.paint.get("fill-translate-anchor"));
+                  if (r22) {
+                    m22 = v22.indexBuffer2, f22 = v22.segments2;
+                    const e3 = [n22.drawingBufferWidth, n22.drawingBufferHeight];
+                    p22 = "fillOutlinePattern" === _22 && c22 ? Pe2(T22, t42, u22, a3, e3) : Ee2(T22, e3);
+                  } else m22 = v22.indexBuffer, f22 = v22.segments, p22 = c22 ? Ie2(T22, t42, u22, a3) : Te2(T22);
+                  y22.draw(t42.context, d22, s22, t42.stencilModeForClipping(h3), o22, ji2.disabled, p22, b22, i22.id, v22.layoutVertexBuffer, m22, f22, i22.paint, t42.transform.zoom, x22);
+                }
+              }
+              function aa2(t42, e22, i22, a22, s22, o22, r22) {
+                const n22 = t42.context, l22 = n22.gl, h22 = "fill-extrusion-pattern", c22 = i22.paint.get(h22), u22 = c22.constantOr(1), d22 = i22.getCrossfadeParameters(), _22 = i22.paint.get("fill-extrusion-opacity"), p22 = c22.constantOr(null);
+                for (const c3 of a22) {
+                  const a3 = e22.getTile(c3), m22 = a3.getBucket(i22);
+                  if (!m22) continue;
+                  const f22 = t42.style.map.terrain && t42.style.map.terrain.getTerrainData(c3), g22 = m22.programConfigurations.get(i22.id), v22 = t42.useProgram(u22 ? "fillExtrusionPattern" : "fillExtrusion", g22);
+                  u22 && (t42.context.activeTexture.set(l22.TEXTURE0), a3.imageAtlasTexture.bind(l22.LINEAR, l22.CLAMP_TO_EDGE), g22.updatePaintBuffers(d22)), ea2(g22, h22, p22, a3, i22);
+                  const x22 = t42.translatePosMatrix(c3.posMatrix, a3, i22.paint.get("fill-extrusion-translate"), i22.paint.get("fill-extrusion-translate-anchor")), y22 = i22.paint.get("fill-extrusion-vertical-gradient"), b22 = u22 ? we2(x22, t42, y22, _22, c3, d22, a3) : be2(x22, t42, y22, _22);
+                  v22.draw(n22, n22.gl.TRIANGLES, s22, o22, r22, ji2.backCCW, b22, f22, i22.id, m22.layoutVertexBuffer, m22.indexBuffer, m22.segments, i22.paint, t42.transform.zoom, g22, t42.style.map.terrain && m22.centroidVertexBuffer);
+                }
+              }
+              function sa2(t42, e22, i22, a22, s22, o22, r22) {
+                const n22 = t42.context, l22 = n22.gl, h22 = i22.fbo;
+                if (!h22) return;
+                const c22 = t42.useProgram("hillshade"), u22 = t42.style.map.terrain && t42.style.map.terrain.getTerrainData(e22);
+                n22.activeTexture.set(l22.TEXTURE0), l22.bindTexture(l22.TEXTURE_2D, h22.colorAttachment.get()), c22.draw(n22, l22.TRIANGLES, s22, o22, r22, ji2.disabled, ((t5, e3, i3, a3) => {
+                  const s3 = i3.paint.get("hillshade-shadow-color"), o3 = i3.paint.get("hillshade-highlight-color"), r3 = i3.paint.get("hillshade-accent-color");
+                  let n3 = i3.paint.get("hillshade-illumination-direction") * (Math.PI / 180);
+                  "viewport" === i3.paint.get("hillshade-illumination-anchor") && (n3 -= t5.transform.angle);
+                  const l3 = !t5.options.moving;
+                  return { u_matrix: a3 ? a3.posMatrix : t5.transform.calculatePosMatrix(e3.tileID.toUnwrapped(), l3), u_image: 0, u_latrange: Re2(0, e3.tileID), u_light: [i3.paint.get("hillshade-exaggeration"), n3], u_shadow: s3, u_highlight: o3, u_accent: r3 };
+                })(t42, i22, a22, u22 ? e22 : null), u22, a22.id, t42.rasterBoundsBuffer, t42.quadTriangleIndexBuffer, t42.rasterBoundsSegments);
+              }
+              function oa2(t42, i22, a22, s22, o22, r22) {
+                const n22 = t42.context, l22 = n22.gl, h22 = i22.dem;
+                if (h22 && h22.data) {
+                  const c22 = h22.dim, u22 = h22.stride, d22 = h22.getPixels();
+                  if (n22.activeTexture.set(l22.TEXTURE1), n22.pixelStoreUnpackPremultiplyAlpha.set(false), i22.demTexture = i22.demTexture || t42.getTileTexture(u22), i22.demTexture) {
+                    const t5 = i22.demTexture;
+                    t5.update(d22, { premultiply: false }), t5.bind(l22.NEAREST, l22.CLAMP_TO_EDGE);
+                  } else i22.demTexture = new b2(n22, d22, l22.RGBA, { premultiply: false }), i22.demTexture.bind(l22.NEAREST, l22.CLAMP_TO_EDGE);
+                  n22.activeTexture.set(l22.TEXTURE0);
+                  let _22 = i22.fbo;
+                  if (!_22) {
+                    const t5 = new b2(n22, { width: c22, height: c22, data: null }, l22.RGBA);
+                    t5.bind(l22.LINEAR, l22.CLAMP_TO_EDGE), _22 = i22.fbo = n22.createFramebuffer(c22, c22, true, false), _22.colorAttachment.set(t5.texture);
+                  }
+                  n22.bindFramebuffer.set(_22.framebuffer), n22.viewport.set([0, 0, c22, c22]), t42.useProgram("hillshadePrepare").draw(n22, l22.TRIANGLES, s22, o22, r22, ji2.disabled, ((t5, i3) => {
+                    const a3 = i3.stride, s3 = e2.H();
+                    return e2.aP(s3, 0, e2.X, -e2.X, 0, 0, 1), e2.J(s3, s3, [0, -e2.X, 0]), { u_matrix: s3, u_image: 1, u_dimension: [a3, a3], u_zoom: t5.overscaledZ, u_unpack: i3.getUnpackVector() };
+                  })(i22.tileID, h22), null, a22.id, t42.rasterBoundsBuffer, t42.quadTriangleIndexBuffer, t42.rasterBoundsSegments), i22.needsHillshadePrepare = false;
+                }
+              }
+              function ra2(t42, i22, a22, s22, r22, n22) {
+                const l22 = s22.paint.get("raster-fade-duration");
+                if (!n22 && l22 > 0) {
+                  const s3 = o2.now(), n3 = (s3 - t42.timeAdded) / l22, h22 = i22 ? (s3 - i22.timeAdded) / l22 : -1, c22 = a22.getSource(), u22 = r22.coveringZoomLevel({ tileSize: c22.tileSize, roundZoom: c22.roundZoom }), d22 = !i22 || Math.abs(i22.tileID.overscaledZ - u22) > Math.abs(t42.tileID.overscaledZ - u22), _22 = d22 && t42.refreshedUponExpiration ? 1 : e2.ac(d22 ? n3 : 1 - h22, 0, 1);
+                  return t42.refreshedUponExpiration && n3 >= 1 && (t42.refreshedUponExpiration = false), i22 ? { opacity: 1, mix: 1 - _22 } : { opacity: _22, mix: 0 };
+                }
+                return { opacity: 1, mix: 0 };
+              }
+              const na = new e2.aM(1, 0, 0, 1), la2 = new e2.aM(0, 1, 0, 1), ha2 = new e2.aM(0, 0, 1, 1), ca2 = new e2.aM(1, 0, 1, 1), ua2 = new e2.aM(0, 1, 1, 1);
+              function da2(t42, e22, i22, a22) {
+                pa2(t42, 0, e22 + i22 / 2, t42.transform.width, i22, a22);
+              }
+              function _a3(t42, e22, i22, a22) {
+                pa2(t42, e22 - i22 / 2, 0, i22, t42.transform.height, a22);
+              }
+              function pa2(t42, e22, i22, a22, s22, o22) {
+                const r22 = t42.context, n22 = r22.gl;
+                n22.enable(n22.SCISSOR_TEST), n22.scissor(e22 * t42.pixelRatio, i22 * t42.pixelRatio, a22 * t42.pixelRatio, s22 * t42.pixelRatio), r22.clear({ color: o22 }), n22.disable(n22.SCISSOR_TEST);
+              }
+              function ma2(t42, i22, a22) {
+                const s22 = t42.context, o22 = s22.gl, r22 = a22.posMatrix, n22 = t42.useProgram("debug"), l22 = Oi2.disabled, h22 = Ui2.disabled, c22 = t42.colorModeForRenderPass(), u22 = "$debug", d22 = t42.style.map.terrain && t42.style.map.terrain.getTerrainData(a22);
+                s22.activeTexture.set(o22.TEXTURE0);
+                const _22 = i22.getTileByID(a22.key).latestRawTileData, p22 = Math.floor((_22 && _22.byteLength || 0) / 1024), m22 = i22.getTile(a22).tileSize, f22 = 512 / Math.min(m22, 512) * (a22.overscaledZ / t42.transform.zoom) * 0.5;
+                let g22 = a22.canonical.toString();
+                a22.overscaledZ !== a22.canonical.z && (g22 += ` => ${a22.overscaledZ}`), function(t5, e22) {
+                  t5.initDebugOverlayCanvas();
+                  const i3 = t5.debugOverlayCanvas, a3 = t5.context.gl, s3 = t5.debugOverlayCanvas.getContext("2d");
+                  s3.clearRect(0, 0, i3.width, i3.height), s3.shadowColor = "white", s3.shadowBlur = 2, s3.lineWidth = 1.5, s3.strokeStyle = "white", s3.textBaseline = "top", s3.font = "bold 36px Open Sans, sans-serif", s3.fillText(e22, 5, 5), s3.strokeText(e22, 5, 5), t5.debugOverlayTexture.update(i3), t5.debugOverlayTexture.bind(a3.LINEAR, a3.CLAMP_TO_EDGE);
+                }(t42, `${g22} ${p22}kB`), n22.draw(s22, o22.TRIANGLES, l22, h22, Fi2.alphaBlended, ji2.disabled, ze2(r22, e2.aM.transparent, f22), null, u22, t42.debugBuffer, t42.quadTriangleIndexBuffer, t42.debugSegments), n22.draw(s22, o22.LINE_STRIP, l22, h22, c22, ji2.disabled, ze2(r22, e2.aM.red), d22, u22, t42.debugBuffer, t42.tileBorderIndexBuffer, t42.debugSegments);
+              }
+              function fa2(t42, e22, i22) {
+                const a22 = t42.context, s22 = a22.gl, o22 = t42.colorModeForRenderPass(), r22 = new Oi2(s22.LEQUAL, Oi2.ReadWrite, t42.depthRangeFor3D), n22 = t42.useProgram("terrain"), l22 = e22.getTerrainMesh();
+                a22.bindFramebuffer.set(null), a22.viewport.set([0, 0, t42.width, t42.height]);
+                for (const h22 of i22) {
+                  const i3 = t42.renderToTexture.getTexture(h22), c22 = e22.getTerrainData(h22.tileID);
+                  a22.activeTexture.set(s22.TEXTURE0), s22.bindTexture(s22.TEXTURE_2D, i3.texture);
+                  const u22 = t42.transform.calculatePosMatrix(h22.tileID.toUnwrapped()), d22 = e22.getMeshFrameDelta(t42.transform.zoom), _22 = t42.transform.calculateFogMatrix(h22.tileID.toUnwrapped()), p22 = ge2(u22, d22, _22, t42.style.sky, t42.transform.pitch);
+                  n22.draw(a22, s22.TRIANGLES, r22, Ui2.disabled, o22, ji2.backCCW, p22, c22, "terrain", l22.vertexBuffer, l22.indexBuffer, l22.segments);
+                }
+              }
+              class ga {
+                constructor(t42, e22, i22) {
+                  this.vertexBuffer = t42, this.indexBuffer = e22, this.segments = i22;
+                }
+                destroy() {
+                  this.vertexBuffer.destroy(), this.indexBuffer.destroy(), this.segments.destroy(), this.vertexBuffer = null, this.indexBuffer = null, this.segments = null;
+                }
+              }
+              class va2 {
+                constructor(t42, i22) {
+                  this.context = new Bi2(t42), this.transform = i22, this._tileTextures = {}, this.terrainFacilitator = { dirty: true, matrix: e2.an(new Float64Array(16)), renderTime: 0 }, this.setup(), this.numSublayers = ut2.maxUnderzooming + ut2.maxOverzooming + 1, this.depthEpsilon = 1 / Math.pow(2, 16), this.crossTileSymbolIndex = new he2();
+                }
+                resize(t42, e22, i22) {
+                  if (this.width = Math.floor(t42 * i22), this.height = Math.floor(e22 * i22), this.pixelRatio = i22, this.context.viewport.set([0, 0, this.width, this.height]), this.style) for (const t5 of this.style._order) this.style._layers[t5].resize();
+                }
+                setup() {
+                  const t42 = this.context, i22 = new e2.aX();
+                  i22.emplaceBack(0, 0), i22.emplaceBack(e2.X, 0), i22.emplaceBack(0, e2.X), i22.emplaceBack(e2.X, e2.X), this.tileExtentBuffer = t42.createVertexBuffer(i22, _e2.members), this.tileExtentSegments = e2.a0.simpleSegment(0, 0, 4, 2);
+                  const a22 = new e2.aX();
+                  a22.emplaceBack(0, 0), a22.emplaceBack(e2.X, 0), a22.emplaceBack(0, e2.X), a22.emplaceBack(e2.X, e2.X), this.debugBuffer = t42.createVertexBuffer(a22, _e2.members), this.debugSegments = e2.a0.simpleSegment(0, 0, 4, 5);
+                  const s22 = new e2.$();
+                  s22.emplaceBack(0, 0, 0, 0), s22.emplaceBack(e2.X, 0, e2.X, 0), s22.emplaceBack(0, e2.X, 0, e2.X), s22.emplaceBack(e2.X, e2.X, e2.X, e2.X), this.rasterBoundsBuffer = t42.createVertexBuffer(s22, Y2.members), this.rasterBoundsSegments = e2.a0.simpleSegment(0, 0, 4, 2);
+                  const o22 = new e2.aX();
+                  o22.emplaceBack(0, 0), o22.emplaceBack(1, 0), o22.emplaceBack(0, 1), o22.emplaceBack(1, 1), this.viewportBuffer = t42.createVertexBuffer(o22, _e2.members), this.viewportSegments = e2.a0.simpleSegment(0, 0, 4, 2);
+                  const r22 = new e2.aZ();
+                  r22.emplaceBack(0), r22.emplaceBack(1), r22.emplaceBack(3), r22.emplaceBack(2), r22.emplaceBack(0), this.tileBorderIndexBuffer = t42.createIndexBuffer(r22);
+                  const n22 = new e2.aY();
+                  n22.emplaceBack(0, 1, 2), n22.emplaceBack(2, 1, 3), this.quadTriangleIndexBuffer = t42.createIndexBuffer(n22);
+                  const l22 = this.context.gl;
+                  this.stencilClearMode = new Ui2({ func: l22.ALWAYS, mask: 0 }, 0, 255, l22.ZERO, l22.ZERO, l22.ZERO);
+                }
+                clearStencil() {
+                  const t42 = this.context, i22 = t42.gl;
+                  this.nextStencilID = 1, this.currentStencilSource = void 0;
+                  const a22 = e2.H();
+                  e2.aP(a22, 0, this.width, this.height, 0, 0, 1), e2.K(a22, a22, [i22.drawingBufferWidth, i22.drawingBufferHeight, 0]), this.useProgram("clippingMask").draw(t42, i22.TRIANGLES, Oi2.disabled, this.stencilClearMode, Fi2.disabled, ji2.disabled, De2(a22), null, "$clipping", this.viewportBuffer, this.quadTriangleIndexBuffer, this.viewportSegments);
+                }
+                _renderTileClippingMasks(t42, e22) {
+                  if (this.currentStencilSource === t42.source || !t42.isTileClipped() || !e22 || !e22.length) return;
+                  this.currentStencilSource = t42.source;
+                  const i22 = this.context, a22 = i22.gl;
+                  this.nextStencilID + e22.length > 256 && this.clearStencil(), i22.setColorMode(Fi2.disabled), i22.setDepthMode(Oi2.disabled);
+                  const s22 = this.useProgram("clippingMask");
+                  this._tileClippingMaskIDs = {};
+                  for (const t5 of e22) {
+                    const e3 = this._tileClippingMaskIDs[t5.key] = this.nextStencilID++, o22 = this.style.map.terrain && this.style.map.terrain.getTerrainData(t5);
+                    s22.draw(i22, a22.TRIANGLES, Oi2.disabled, new Ui2({ func: a22.ALWAYS, mask: 0 }, e3, 255, a22.KEEP, a22.KEEP, a22.REPLACE), Fi2.disabled, ji2.disabled, De2(t5.posMatrix), o22, "$clipping", this.tileExtentBuffer, this.quadTriangleIndexBuffer, this.tileExtentSegments);
+                  }
+                }
+                stencilModeFor3D() {
+                  this.currentStencilSource = void 0, this.nextStencilID + 1 > 256 && this.clearStencil();
+                  const t42 = this.nextStencilID++, e22 = this.context.gl;
+                  return new Ui2({ func: e22.NOTEQUAL, mask: 255 }, t42, 255, e22.KEEP, e22.KEEP, e22.REPLACE);
+                }
+                stencilModeForClipping(t42) {
+                  const e22 = this.context.gl;
+                  return new Ui2({ func: e22.EQUAL, mask: 255 }, this._tileClippingMaskIDs[t42.key], 0, e22.KEEP, e22.KEEP, e22.REPLACE);
+                }
+                stencilConfigForOverlap(t42) {
+                  const e22 = this.context.gl, i22 = t42.sort((t5, e3) => e3.overscaledZ - t5.overscaledZ), a22 = i22[i22.length - 1].overscaledZ, s22 = i22[0].overscaledZ - a22 + 1;
+                  if (s22 > 1) {
+                    this.currentStencilSource = void 0, this.nextStencilID + s22 > 256 && this.clearStencil();
+                    const t5 = {};
+                    for (let i3 = 0; i3 < s22; i3++) t5[i3 + a22] = new Ui2({ func: e22.GEQUAL, mask: 255 }, i3 + this.nextStencilID, 255, e22.KEEP, e22.KEEP, e22.REPLACE);
+                    return this.nextStencilID += s22, [t5, i22];
+                  }
+                  return [{ [a22]: Ui2.disabled }, i22];
+                }
+                colorModeForRenderPass() {
+                  const t42 = this.context.gl;
+                  if (this._showOverdrawInspector) {
+                    const i22 = 1 / 8;
+                    return new Fi2([t42.CONSTANT_COLOR, t42.ONE], new e2.aM(i22, i22, i22, 0), [true, true, true, true]);
+                  }
+                  return "opaque" === this.renderPass ? Fi2.unblended : Fi2.alphaBlended;
+                }
+                depthModeForSublayer(t42, e22, i22) {
+                  if (!this.opaquePassEnabledForLayer()) return Oi2.disabled;
+                  const a22 = 1 - ((1 + this.currentLayer) * this.numSublayers + t42) * this.depthEpsilon;
+                  return new Oi2(i22 || this.context.gl.LEQUAL, e22, [a22, a22]);
+                }
+                opaquePassEnabledForLayer() {
+                  return this.currentLayer < this.opaquePassCutoff;
+                }
+                render(t42, i22) {
+                  this.style = t42, this.options = i22, this.lineAtlas = t42.lineAtlas, this.imageManager = t42.imageManager, this.glyphManager = t42.glyphManager, this.symbolFadeChange = t42.placement.symbolFadeChange(o2.now()), this.imageManager.beginFrame();
+                  const a22 = this.style._order, s22 = this.style.sourceCaches, r22 = {}, n22 = {}, l22 = {};
+                  for (const t5 in s22) {
+                    const e22 = s22[t5];
+                    e22.used && e22.prepare(this.context), r22[t5] = e22.getVisibleCoordinates(), n22[t5] = r22[t5].slice().reverse(), l22[t5] = e22.getVisibleCoordinates(true).reverse();
+                  }
+                  this.opaquePassCutoff = 1 / 0;
+                  for (let t5 = 0; t5 < a22.length; t5++) if (this.style._layers[a22[t5]].is3D()) {
+                    this.opaquePassCutoff = t5;
+                    break;
+                  }
+                  this.maybeDrawDepthAndCoords(false), this.renderToTexture && (this.renderToTexture.prepareForRender(this.style, this.transform.zoom), this.opaquePassCutoff = 0), this.renderPass = "offscreen";
+                  for (const t5 of a22) {
+                    const e22 = this.style._layers[t5];
+                    if (!e22.hasOffscreenPass() || e22.isHidden(this.transform.zoom)) continue;
+                    const i3 = n22[e22.source];
+                    ("custom" === e22.type || i3.length) && this.renderLayer(this, s22[e22.source], e22, i3);
+                  }
+                  if (this.context.bindFramebuffer.set(null), this.context.clear({ color: i22.showOverdrawInspector ? e2.aM.black : e2.aM.transparent, depth: 1 }), this.clearStencil(), this.style.sky && function(t5, i3) {
+                    const a3 = t5.context, s3 = a3.gl, o22 = ((t6, e22, i4) => ({ u_sky_color: t6.properties.get("sky-color"), u_horizon_color: t6.properties.get("horizon-color"), u_horizon: (e22.height / 2 + e22.getHorizon()) * i4, u_sky_horizon_blend: t6.properties.get("sky-horizon-blend") * e22.height / 2 * i4 }))(i3, t5.style.map.transform, t5.pixelRatio), r3 = new Oi2(s3.LEQUAL, Oi2.ReadWrite, [0, 1]), n3 = Ui2.disabled, l3 = t5.colorModeForRenderPass(), h22 = t5.useProgram("sky");
+                    if (!i3.mesh) {
+                      const t6 = new e2.aX();
+                      t6.emplaceBack(-1, -1), t6.emplaceBack(1, -1), t6.emplaceBack(1, 1), t6.emplaceBack(-1, 1);
+                      const s4 = new e2.aY();
+                      s4.emplaceBack(0, 1, 2), s4.emplaceBack(0, 2, 3), i3.mesh = new ga(a3.createVertexBuffer(t6, _e2.members), a3.createIndexBuffer(s4), e2.a0.simpleSegment(0, 0, t6.length, s4.length));
+                    }
+                    h22.draw(a3, s3.TRIANGLES, r3, n3, l3, ji2.disabled, o22, void 0, "sky", i3.mesh.vertexBuffer, i3.mesh.indexBuffer, i3.mesh.segments);
+                  }(this, this.style.sky), this._showOverdrawInspector = i22.showOverdrawInspector, this.depthRangeFor3D = [0, 1 - (t42._order.length + 2) * this.numSublayers * this.depthEpsilon], !this.renderToTexture) for (this.renderPass = "opaque", this.currentLayer = a22.length - 1; this.currentLayer >= 0; this.currentLayer--) {
+                    const t5 = this.style._layers[a22[this.currentLayer]], e22 = s22[t5.source], i3 = r22[t5.source];
+                    this._renderTileClippingMasks(t5, i3), this.renderLayer(this, e22, t5, i3);
+                  }
+                  for (this.renderPass = "translucent", this.currentLayer = 0; this.currentLayer < a22.length; this.currentLayer++) {
+                    const t5 = this.style._layers[a22[this.currentLayer]], e22 = s22[t5.source];
+                    if (this.renderToTexture && this.renderToTexture.renderLayer(t5)) continue;
+                    const i3 = ("symbol" === t5.type ? l22 : n22)[t5.source];
+                    this._renderTileClippingMasks(t5, r22[t5.source]), this.renderLayer(this, e22, t5, i3);
+                  }
+                  if (this.options.showTileBoundaries) {
+                    const t5 = function(t6, e22) {
+                      let i3 = null;
+                      const a3 = Object.values(t6._layers).flatMap((i4) => i4.source && !i4.isHidden(e22) ? [t6.sourceCaches[i4.source]] : []), s3 = a3.filter((t7) => "vector" === t7.getSource().type), o22 = a3.filter((t7) => "vector" !== t7.getSource().type), r3 = (t7) => {
+                        (!i3 || i3.getSource().maxzoom < t7.getSource().maxzoom) && (i3 = t7);
+                      };
+                      return s3.forEach((t7) => r3(t7)), i3 || o22.forEach((t7) => r3(t7)), i3;
+                    }(this.style, this.transform.zoom);
+                    t5 && function(t6, e22, i3) {
+                      for (let a3 = 0; a3 < i3.length; a3++) ma2(t6, e22, i3[a3]);
+                    }(this, t5, t5.getVisibleCoordinates());
+                  }
+                  this.options.showPadding && function(t5) {
+                    const e22 = t5.transform.padding;
+                    da2(t5, t5.transform.height - (e22.top || 0), 3, na), da2(t5, e22.bottom || 0, 3, la2), _a3(t5, e22.left || 0, 3, ha2), _a3(t5, t5.transform.width - (e22.right || 0), 3, ca2);
+                    const i3 = t5.transform.centerPoint;
+                    !function(t6, e3, i4, a3) {
+                      pa2(t6, e3 - 1, i4 - 10, 2, 20, a3), pa2(t6, e3 - 10, i4 - 1, 20, 2, a3);
+                    }(t5, i3.x, t5.transform.height - i3.y, ua2);
+                  }(this), this.context.setDefault();
+                }
+                maybeDrawDepthAndCoords(t42) {
+                  if (!this.style || !this.style.map || !this.style.map.terrain) return;
+                  const i22 = this.terrainFacilitator.matrix, a22 = this.transform.modelViewProjectionMatrix;
+                  let s22 = this.terrainFacilitator.dirty;
+                  s22 || (s22 = t42 ? !e2.a_(i22, a22) : !e2.a$(i22, a22)), s22 || (s22 = this.style.map.terrain.sourceCache.tilesAfterTime(this.terrainFacilitator.renderTime).length > 0), s22 && (e2.b0(i22, a22), this.terrainFacilitator.renderTime = Date.now(), this.terrainFacilitator.dirty = false, function(t5, i3) {
+                    const a3 = t5.context, s3 = a3.gl, o22 = Fi2.unblended, r22 = new Oi2(s3.LEQUAL, Oi2.ReadWrite, [0, 1]), n22 = i3.getTerrainMesh(), l22 = i3.sourceCache.getRenderableTiles(), h22 = t5.useProgram("terrainDepth");
+                    a3.bindFramebuffer.set(i3.getFramebuffer("depth").framebuffer), a3.viewport.set([0, 0, t5.width / devicePixelRatio, t5.height / devicePixelRatio]), a3.clear({ color: e2.aM.transparent, depth: 1 });
+                    for (const e22 of l22) {
+                      const l3 = i3.getTerrainData(e22.tileID), c22 = { u_matrix: t5.transform.calculatePosMatrix(e22.tileID.toUnwrapped()), u_ele_delta: i3.getMeshFrameDelta(t5.transform.zoom) };
+                      h22.draw(a3, s3.TRIANGLES, r22, Ui2.disabled, o22, ji2.backCCW, c22, l3, "terrain", n22.vertexBuffer, n22.indexBuffer, n22.segments);
+                    }
+                    a3.bindFramebuffer.set(null), a3.viewport.set([0, 0, t5.width, t5.height]);
+                  }(this, this.style.map.terrain), function(t5, i3) {
+                    const a3 = t5.context, s3 = a3.gl, o22 = Fi2.unblended, r22 = new Oi2(s3.LEQUAL, Oi2.ReadWrite, [0, 1]), n22 = i3.getTerrainMesh(), l22 = i3.getCoordsTexture(), h22 = i3.sourceCache.getRenderableTiles(), c22 = t5.useProgram("terrainCoords");
+                    a3.bindFramebuffer.set(i3.getFramebuffer("coords").framebuffer), a3.viewport.set([0, 0, t5.width / devicePixelRatio, t5.height / devicePixelRatio]), a3.clear({ color: e2.aM.transparent, depth: 1 }), i3.coordsIndex = [];
+                    for (const e22 of h22) {
+                      const h3 = i3.getTerrainData(e22.tileID);
+                      a3.activeTexture.set(s3.TEXTURE0), s3.bindTexture(s3.TEXTURE_2D, l22.texture);
+                      const u22 = { u_matrix: t5.transform.calculatePosMatrix(e22.tileID.toUnwrapped()), u_terrain_coords_id: (255 - i3.coordsIndex.length) / 255, u_texture: 0, u_ele_delta: i3.getMeshFrameDelta(t5.transform.zoom) };
+                      c22.draw(a3, s3.TRIANGLES, r22, Ui2.disabled, o22, ji2.backCCW, u22, h3, "terrain", n22.vertexBuffer, n22.indexBuffer, n22.segments), i3.coordsIndex.push(e22.tileID.key);
+                    }
+                    a3.bindFramebuffer.set(null), a3.viewport.set([0, 0, t5.width, t5.height]);
+                  }(this, this.style.map.terrain));
+                }
+                renderLayer(t42, i22, a22, s22) {
+                  if (!a22.isHidden(this.transform.zoom) && ("background" === a22.type || "custom" === a22.type || (s22 || []).length)) switch (this.id = a22.id, a22.type) {
+                    case "symbol":
+                      !function(t5, i3, a3, s3, o22) {
+                        if ("translucent" !== t5.renderPass) return;
+                        const r22 = Ui2.disabled, n22 = t5.colorModeForRenderPass();
+                        (a3._unevaluatedLayout.hasValue("text-variable-anchor") || a3._unevaluatedLayout.hasValue("text-variable-anchor-offset")) && function(t6, i4, a4, s4, o3, r3, n3, l22, h22) {
+                          const c22 = i4.transform, u22 = ie2(), d22 = "map" === o3, _22 = "map" === r3;
+                          for (const o4 of t6) {
+                            const t7 = s4.getTile(o4), r4 = t7.getBucket(a4);
+                            if (!r4 || !r4.text || !r4.text.segments.get().length) continue;
+                            const p22 = e2.ag(r4.textSizeData, c22.zoom), m22 = Bt(t7, 1, i4.transform.zoom), f22 = gt2(o4.posMatrix, _22, d22, i4.transform, m22), g22 = "none" !== a4.layout.get("icon-text-fit") && r4.hasIconData();
+                            if (p22) {
+                              const e22 = Math.pow(2, c22.zoom - t7.tileID.overscaledZ), a5 = i4.style.map.terrain ? (t8, e3) => i4.style.map.terrain.getElevation(o4, t8, e3) : null, s5 = u22.translatePosition(c22, t7, n3, l22);
+                              Wi2(r4, d22, _22, h22, c22, f22, o4.posMatrix, e22, p22, g22, u22, s5, o4.toUnwrapped(), a5);
+                            }
+                          }
+                        }(s3, t5, a3, i3, a3.layout.get("text-rotation-alignment"), a3.layout.get("text-pitch-alignment"), a3.paint.get("text-translate"), a3.paint.get("text-translate-anchor"), o22), 0 !== a3.paint.get("icon-opacity").constantOr(1) && Xi2(t5, i3, a3, s3, false, a3.paint.get("icon-translate"), a3.paint.get("icon-translate-anchor"), a3.layout.get("icon-rotation-alignment"), a3.layout.get("icon-pitch-alignment"), a3.layout.get("icon-keep-upright"), r22, n22), 0 !== a3.paint.get("text-opacity").constantOr(1) && Xi2(t5, i3, a3, s3, true, a3.paint.get("text-translate"), a3.paint.get("text-translate-anchor"), a3.layout.get("text-rotation-alignment"), a3.layout.get("text-pitch-alignment"), a3.layout.get("text-keep-upright"), r22, n22), i3.map.showCollisionBoxes && (qi2(t5, i3, a3, s3, true), qi2(t5, i3, a3, s3, false));
+                      }(t42, i22, a22, s22, this.style.placement.variableOffsets);
+                      break;
+                    case "circle":
+                      !function(t5, i3, a3, s3) {
+                        if ("translucent" !== t5.renderPass) return;
+                        const o22 = a3.paint.get("circle-opacity"), r22 = a3.paint.get("circle-stroke-width"), n22 = a3.paint.get("circle-stroke-opacity"), l22 = !a3.layout.get("circle-sort-key").isConstant();
+                        if (0 === o22.constantOr(1) && (0 === r22.constantOr(1) || 0 === n22.constantOr(1))) return;
+                        const h22 = t5.context, c22 = h22.gl, u22 = t5.depthModeForSublayer(0, Oi2.ReadOnly), d22 = Ui2.disabled, _22 = t5.colorModeForRenderPass(), p22 = [];
+                        for (let o3 = 0; o3 < s3.length; o3++) {
+                          const r3 = s3[o3], n3 = i3.getTile(r3), h3 = n3.getBucket(a3);
+                          if (!h3) continue;
+                          const c3 = h3.programConfigurations.get(a3.id), u3 = t5.useProgram("circle", c3), d3 = h3.layoutVertexBuffer, _3 = h3.indexBuffer, m22 = t5.style.map.terrain && t5.style.map.terrain.getTerrainData(r3), f22 = { programConfiguration: c3, program: u3, layoutVertexBuffer: d3, indexBuffer: _3, uniformValues: Ce2(t5, r3, n3, a3), terrainData: m22 };
+                          if (l22) {
+                            const t6 = h3.segments.get();
+                            for (const i4 of t6) p22.push({ segments: new e2.a0([i4]), sortKey: i4.sortKey, state: f22 });
+                          } else p22.push({ segments: h3.segments, sortKey: 0, state: f22 });
+                        }
+                        l22 && p22.sort((t6, e22) => t6.sortKey - e22.sortKey);
+                        for (const e22 of p22) {
+                          const { programConfiguration: i4, program: s4, layoutVertexBuffer: o3, indexBuffer: r3, uniformValues: n3, terrainData: l3 } = e22.state;
+                          s4.draw(h22, c22.TRIANGLES, u22, d22, _22, ji2.disabled, n3, l3, a3.id, o3, r3, e22.segments, a3.paint, t5.transform.zoom, i4);
+                        }
+                      }(t42, i22, a22, s22);
+                      break;
+                    case "heatmap":
+                      !function(t5, i3, a3, s3) {
+                        if (0 === a3.paint.get("heatmap-opacity")) return;
+                        const o22 = t5.context;
+                        if (t5.style.map.terrain) {
+                          for (const e22 of s3) {
+                            const s4 = i3.getTile(e22);
+                            i3.hasRenderableParent(e22) || ("offscreen" === t5.renderPass ? Ji2(t5, s4, a3, e22) : "translucent" === t5.renderPass && Yi2(t5, a3, e22));
+                          }
+                          o22.viewport.set([0, 0, t5.width, t5.height]);
+                        } else "offscreen" === t5.renderPass ? function(t6, i4, a4, s4) {
+                          const o3 = t6.context, r22 = o3.gl, n22 = Ui2.disabled, l22 = new Fi2([r22.ONE, r22.ONE], e2.aM.transparent, [true, true, true, true]);
+                          (function(t7, i5, a5) {
+                            const s5 = t7.gl;
+                            t7.activeTexture.set(s5.TEXTURE1), t7.viewport.set([0, 0, i5.width / 4, i5.height / 4]);
+                            let o4 = a5.heatmapFbos.get(e2.aU);
+                            o4 ? (s5.bindTexture(s5.TEXTURE_2D, o4.colorAttachment.get()), t7.bindFramebuffer.set(o4.framebuffer)) : (o4 = Qi2(t7, i5.width / 4, i5.height / 4), a5.heatmapFbos.set(e2.aU, o4));
+                          })(o3, t6, a4), o3.clear({ color: e2.aM.transparent });
+                          for (let e22 = 0; e22 < s4.length; e22++) {
+                            const h22 = s4[e22];
+                            if (i4.hasRenderableParent(h22)) continue;
+                            const c22 = i4.getTile(h22), u22 = c22.getBucket(a4);
+                            if (!u22) continue;
+                            const d22 = u22.programConfigurations.get(a4.id), _22 = t6.useProgram("heatmap", d22), { zoom: p22 } = t6.transform;
+                            _22.draw(o3, r22.TRIANGLES, Oi2.disabled, n22, l22, ji2.disabled, Me2(h22.posMatrix, c22, p22, a4.paint.get("heatmap-intensity")), null, a4.id, u22.layoutVertexBuffer, u22.indexBuffer, u22.segments, a4.paint, t6.transform.zoom, d22);
+                          }
+                          o3.viewport.set([0, 0, t6.width, t6.height]);
+                        }(t5, i3, a3, s3) : "translucent" === t5.renderPass && function(t6, i4) {
+                          const a4 = t6.context, s4 = a4.gl;
+                          a4.setColorMode(t6.colorModeForRenderPass());
+                          const o3 = i4.heatmapFbos.get(e2.aU);
+                          o3 && (a4.activeTexture.set(s4.TEXTURE0), s4.bindTexture(s4.TEXTURE_2D, o3.colorAttachment.get()), a4.activeTexture.set(s4.TEXTURE1), ta2(a4, i4).bind(s4.LINEAR, s4.CLAMP_TO_EDGE), t6.useProgram("heatmapTexture").draw(a4, s4.TRIANGLES, Oi2.disabled, Ui2.disabled, t6.colorModeForRenderPass(), ji2.disabled, Ae2(t6, i4, 0, 1), null, i4.id, t6.viewportBuffer, t6.quadTriangleIndexBuffer, t6.viewportSegments, i4.paint, t6.transform.zoom));
+                        }(t5, a3);
+                      }(t42, i22, a22, s22);
+                      break;
+                    case "line":
+                      !function(t5, i3, a3, s3) {
+                        if ("translucent" !== t5.renderPass) return;
+                        const o22 = a3.paint.get("line-opacity"), r22 = a3.paint.get("line-width");
+                        if (0 === o22.constantOr(1) || 0 === r22.constantOr(1)) return;
+                        const n22 = t5.depthModeForSublayer(0, Oi2.ReadOnly), l22 = t5.colorModeForRenderPass(), h22 = a3.paint.get("line-dasharray"), c22 = a3.paint.get("line-pattern"), u22 = c22.constantOr(1), d22 = a3.paint.get("line-gradient"), _22 = a3.getCrossfadeParameters(), p22 = u22 ? "linePattern" : h22 ? "lineSDF" : d22 ? "lineGradient" : "line", m22 = t5.context, f22 = m22.gl;
+                        let g22 = true;
+                        for (const o3 of s3) {
+                          const s4 = i3.getTile(o3);
+                          if (u22 && !s4.patternsLoaded()) continue;
+                          const r3 = s4.getBucket(a3);
+                          if (!r3) continue;
+                          const v22 = r3.programConfigurations.get(a3.id), x22 = t5.context.program.get(), y22 = t5.useProgram(p22, v22), w22 = g22 || y22.program !== x22, T22 = t5.style.map.terrain && t5.style.map.terrain.getTerrainData(o3), I22 = c22.constantOr(null);
+                          if (I22 && s4.imageAtlas) {
+                            const t6 = s4.imageAtlas, e22 = t6.patternPositions[I22.to.toString()], i4 = t6.patternPositions[I22.from.toString()];
+                            e22 && i4 && v22.setConstantPatternPositions(e22, i4);
+                          }
+                          const E3 = T22 ? o3 : null, P22 = u22 ? Fe2(t5, s4, a3, _22, E3) : h22 ? Be2(t5, s4, a3, h22, _22, E3) : d22 ? Le2(t5, s4, a3, r3.lineClipsArray.length, E3) : ke2(t5, s4, a3, E3);
+                          if (u22) m22.activeTexture.set(f22.TEXTURE0), s4.imageAtlasTexture.bind(f22.LINEAR, f22.CLAMP_TO_EDGE), v22.updatePaintBuffers(_22);
+                          else if (h22 && (w22 || t5.lineAtlas.dirty)) m22.activeTexture.set(f22.TEXTURE0), t5.lineAtlas.bind(m22);
+                          else if (d22) {
+                            const s5 = r3.gradients[a3.id];
+                            let n3 = s5.texture;
+                            if (a3.gradientVersion !== s5.version) {
+                              let l3 = 256;
+                              if (a3.stepInterpolant) {
+                                const a4 = i3.getSource().maxzoom, s6 = o3.canonical.z === a4 ? Math.ceil(1 << t5.transform.maxZoom - o3.canonical.z) : 1;
+                                l3 = e2.ac(e2.aV(r3.maxLineLength / e2.X * 1024 * s6), 256, m22.maxTextureSize);
+                              }
+                              s5.gradient = e2.aW({ expression: a3.gradientExpression(), evaluationKey: "lineProgress", resolution: l3, image: s5.gradient || void 0, clips: r3.lineClipsArray }), s5.texture ? s5.texture.update(s5.gradient) : s5.texture = new b2(m22, s5.gradient, f22.RGBA), s5.version = a3.gradientVersion, n3 = s5.texture;
+                            }
+                            m22.activeTexture.set(f22.TEXTURE0), n3.bind(a3.stepInterpolant ? f22.NEAREST : f22.LINEAR, f22.CLAMP_TO_EDGE);
+                          }
+                          y22.draw(m22, f22.TRIANGLES, n22, t5.stencilModeForClipping(o3), l22, ji2.disabled, P22, T22, a3.id, r3.layoutVertexBuffer, r3.indexBuffer, r3.segments, a3.paint, t5.transform.zoom, v22, r3.layoutVertexBuffer2), g22 = false;
+                        }
+                      }(t42, i22, a22, s22);
+                      break;
+                    case "fill":
+                      !function(t5, i3, a3, s3) {
+                        const o22 = a3.paint.get("fill-color"), r22 = a3.paint.get("fill-opacity");
+                        if (0 === r22.constantOr(1)) return;
+                        const n22 = t5.colorModeForRenderPass(), l22 = a3.paint.get("fill-pattern"), h22 = t5.opaquePassEnabledForLayer() && !l22.constantOr(1) && 1 === o22.constantOr(e2.aM.transparent).a && 1 === r22.constantOr(0) ? "opaque" : "translucent";
+                        if (t5.renderPass === h22) {
+                          const e22 = t5.depthModeForSublayer(1, "opaque" === t5.renderPass ? Oi2.ReadWrite : Oi2.ReadOnly);
+                          ia2(t5, i3, a3, s3, e22, n22, false);
+                        }
+                        if ("translucent" === t5.renderPass && a3.paint.get("fill-antialias")) {
+                          const e22 = t5.depthModeForSublayer(a3.getPaintProperty("fill-outline-color") ? 2 : 0, Oi2.ReadOnly);
+                          ia2(t5, i3, a3, s3, e22, n22, true);
+                        }
+                      }(t42, i22, a22, s22);
+                      break;
+                    case "fill-extrusion":
+                      !function(t5, e22, i3, a3) {
+                        const s3 = i3.paint.get("fill-extrusion-opacity");
+                        if (0 !== s3 && "translucent" === t5.renderPass) {
+                          const o22 = new Oi2(t5.context.gl.LEQUAL, Oi2.ReadWrite, t5.depthRangeFor3D);
+                          if (1 !== s3 || i3.paint.get("fill-extrusion-pattern").constantOr(1)) aa2(t5, e22, i3, a3, o22, Ui2.disabled, Fi2.disabled), aa2(t5, e22, i3, a3, o22, t5.stencilModeFor3D(), t5.colorModeForRenderPass());
+                          else {
+                            const s4 = t5.colorModeForRenderPass();
+                            aa2(t5, e22, i3, a3, o22, Ui2.disabled, s4);
+                          }
+                        }
+                      }(t42, i22, a22, s22);
+                      break;
+                    case "hillshade":
+                      !function(t5, e22, i3, a3) {
+                        if ("offscreen" !== t5.renderPass && "translucent" !== t5.renderPass) return;
+                        const s3 = t5.context, o22 = t5.depthModeForSublayer(0, Oi2.ReadOnly), r22 = t5.colorModeForRenderPass(), [n22, l22] = "translucent" === t5.renderPass ? t5.stencilConfigForOverlap(a3) : [{}, a3];
+                        for (const a4 of l22) {
+                          const s4 = e22.getTile(a4);
+                          void 0 !== s4.needsHillshadePrepare && s4.needsHillshadePrepare && "offscreen" === t5.renderPass ? oa2(t5, s4, i3, o22, Ui2.disabled, r22) : "translucent" === t5.renderPass && sa2(t5, a4, s4, i3, o22, n22[a4.overscaledZ], r22);
+                        }
+                        s3.viewport.set([0, 0, t5.width, t5.height]);
+                      }(t42, i22, a22, s22);
+                      break;
+                    case "raster":
+                      !function(t5, e22, i3, a3) {
+                        if ("translucent" !== t5.renderPass) return;
+                        if (0 === i3.paint.get("raster-opacity")) return;
+                        if (!a3.length) return;
+                        const s3 = t5.context, o22 = s3.gl, r22 = e22.getSource(), n22 = t5.useProgram("raster"), l22 = t5.colorModeForRenderPass(), [h22, c22] = r22 instanceof Q2 ? [{}, a3] : t5.stencilConfigForOverlap(a3), u22 = c22[c22.length - 1].overscaledZ, d22 = !t5.options.moving;
+                        for (const a4 of c22) {
+                          const c3 = t5.depthModeForSublayer(a4.overscaledZ - u22, 1 === i3.paint.get("raster-opacity") ? Oi2.ReadWrite : Oi2.ReadOnly, o22.LESS), _22 = e22.getTile(a4);
+                          _22.registerFadeDuration(i3.paint.get("raster-fade-duration"));
+                          const p22 = e22.findLoadedParent(a4, 0), m22 = e22.findLoadedSibling(a4), f22 = ra2(_22, p22 || m22 || null, e22, i3, t5.transform, t5.style.map.terrain);
+                          let g22, v22;
+                          const x22 = "nearest" === i3.paint.get("raster-resampling") ? o22.NEAREST : o22.LINEAR;
+                          s3.activeTexture.set(o22.TEXTURE0), _22.texture.bind(x22, o22.CLAMP_TO_EDGE, o22.LINEAR_MIPMAP_NEAREST), s3.activeTexture.set(o22.TEXTURE1), p22 ? (p22.texture.bind(x22, o22.CLAMP_TO_EDGE, o22.LINEAR_MIPMAP_NEAREST), g22 = Math.pow(2, p22.tileID.overscaledZ - _22.tileID.overscaledZ), v22 = [_22.tileID.canonical.x * g22 % 1, _22.tileID.canonical.y * g22 % 1]) : _22.texture.bind(x22, o22.CLAMP_TO_EDGE, o22.LINEAR_MIPMAP_NEAREST), _22.texture.useMipmap && s3.extTextureFilterAnisotropic && t5.transform.pitch > 20 && o22.texParameterf(o22.TEXTURE_2D, s3.extTextureFilterAnisotropic.TEXTURE_MAX_ANISOTROPY_EXT, s3.extTextureFilterAnisotropicMax);
+                          const y22 = t5.style.map.terrain && t5.style.map.terrain.getTerrainData(a4), b22 = y22 ? a4 : null, w22 = b22 ? b22.posMatrix : t5.transform.calculatePosMatrix(a4.toUnwrapped(), d22), T22 = Ue2(w22, v22 || [0, 0], g22 || 1, f22, i3);
+                          r22 instanceof Q2 ? n22.draw(s3, o22.TRIANGLES, c3, Ui2.disabled, l22, ji2.disabled, T22, y22, i3.id, r22.boundsBuffer, t5.quadTriangleIndexBuffer, r22.boundsSegments) : n22.draw(s3, o22.TRIANGLES, c3, h22[a4.overscaledZ], l22, ji2.disabled, T22, y22, i3.id, t5.rasterBoundsBuffer, t5.quadTriangleIndexBuffer, t5.rasterBoundsSegments);
+                        }
+                      }(t42, i22, a22, s22);
+                      break;
+                    case "background":
+                      !function(t5, e22, i3, a3) {
+                        const s3 = i3.paint.get("background-color"), o22 = i3.paint.get("background-opacity");
+                        if (0 === o22) return;
+                        const r22 = t5.context, n22 = r22.gl, l22 = t5.transform, h22 = l22.tileSize, c22 = i3.paint.get("background-pattern");
+                        if (t5.isPatternMissing(c22)) return;
+                        const u22 = !c22 && 1 === s3.a && 1 === o22 && t5.opaquePassEnabledForLayer() ? "opaque" : "translucent";
+                        if (t5.renderPass !== u22) return;
+                        const d22 = Ui2.disabled, _22 = t5.depthModeForSublayer(0, "opaque" === u22 ? Oi2.ReadWrite : Oi2.ReadOnly), p22 = t5.colorModeForRenderPass(), m22 = t5.useProgram(c22 ? "backgroundPattern" : "background"), f22 = a3 || l22.coveringTiles({ tileSize: h22, terrain: t5.style.map.terrain });
+                        c22 && (r22.activeTexture.set(n22.TEXTURE0), t5.imageManager.bind(t5.context));
+                        const g22 = i3.getCrossfadeParameters();
+                        for (const e3 of f22) {
+                          const l3 = a3 ? e3.posMatrix : t5.transform.calculatePosMatrix(e3.toUnwrapped()), u3 = c22 ? He2(l3, o22, t5, c22, { tileID: e3, tileSize: h22 }, g22) : Ge2(l3, o22, s3), f3 = t5.style.map.terrain && t5.style.map.terrain.getTerrainData(e3);
+                          m22.draw(r22, n22.TRIANGLES, _22, d22, p22, ji2.disabled, u3, f3, i3.id, t5.tileExtentBuffer, t5.quadTriangleIndexBuffer, t5.tileExtentSegments);
+                        }
+                      }(t42, 0, a22, s22);
+                      break;
+                    case "custom":
+                      !function(t5, e22, i3) {
+                        const a3 = t5.context, s3 = i3.implementation;
+                        if ("offscreen" === t5.renderPass) {
+                          const e3 = s3.prerender;
+                          e3 && (t5.setCustomLayerDefaults(), a3.setColorMode(t5.colorModeForRenderPass()), e3.call(s3, a3.gl, t5.transform.customLayerMatrix()), a3.setDirty(), t5.setBaseState());
+                        } else if ("translucent" === t5.renderPass) {
+                          t5.setCustomLayerDefaults(), a3.setColorMode(t5.colorModeForRenderPass()), a3.setStencilMode(Ui2.disabled);
+                          const e3 = "3d" === s3.renderingMode ? new Oi2(t5.context.gl.LEQUAL, Oi2.ReadWrite, t5.depthRangeFor3D) : t5.depthModeForSublayer(0, Oi2.ReadOnly);
+                          a3.setDepthMode(e3), s3.render(a3.gl, t5.transform.customLayerMatrix(), { farZ: t5.transform.farZ, nearZ: t5.transform.nearZ, fov: t5.transform._fov, modelViewProjectionMatrix: t5.transform.modelViewProjectionMatrix, projectionMatrix: t5.transform.projectionMatrix }), a3.setDirty(), t5.setBaseState(), a3.bindFramebuffer.set(null);
+                        }
+                      }(t42, 0, a22);
+                  }
+                }
+                translatePosMatrix(t42, i22, a22, s22, o22) {
+                  if (!a22[0] && !a22[1]) return t42;
+                  const r22 = o22 ? "map" === s22 ? this.transform.angle : 0 : "viewport" === s22 ? -this.transform.angle : 0;
+                  if (r22) {
+                    const t5 = Math.sin(r22), e22 = Math.cos(r22);
+                    a22 = [a22[0] * e22 - a22[1] * t5, a22[0] * t5 + a22[1] * e22];
+                  }
+                  const n22 = [o22 ? a22[0] : Bt(i22, a22[0], this.transform.zoom), o22 ? a22[1] : Bt(i22, a22[1], this.transform.zoom), 0], l22 = new Float32Array(16);
+                  return e2.J(l22, t42, n22), l22;
+                }
+                saveTileTexture(t42) {
+                  const e22 = this._tileTextures[t42.size[0]];
+                  e22 ? e22.push(t42) : this._tileTextures[t42.size[0]] = [t42];
+                }
+                getTileTexture(t42) {
+                  const e22 = this._tileTextures[t42];
+                  return e22 && e22.length > 0 ? e22.pop() : null;
+                }
+                isPatternMissing(t42) {
+                  if (!t42) return false;
+                  if (!t42.from || !t42.to) return true;
+                  const e22 = this.imageManager.getPattern(t42.from.toString()), i22 = this.imageManager.getPattern(t42.to.toString());
+                  return !e22 || !i22;
+                }
+                useProgram(t42, e22) {
+                  this.cache = this.cache || {};
+                  const i22 = t42 + (e22 ? e22.cacheKey : "") + (this._showOverdrawInspector ? "/overdraw" : "") + (this.style.map.terrain ? "/terrain" : "");
+                  return this.cache[i22] || (this.cache[i22] = new xe2(this.context, pe2[t42], e22, We2[t42], this._showOverdrawInspector, this.style.map.terrain)), this.cache[i22];
+                }
+                setCustomLayerDefaults() {
+                  this.context.unbindVAO(), this.context.cullFace.setDefault(), this.context.activeTexture.setDefault(), this.context.pixelStoreUnpack.setDefault(), this.context.pixelStoreUnpackPremultiplyAlpha.setDefault(), this.context.pixelStoreUnpackFlipY.setDefault();
+                }
+                setBaseState() {
+                  const t42 = this.context.gl;
+                  this.context.cullFace.set(false), this.context.viewport.set([0, 0, this.width, this.height]), this.context.blendEquation.set(t42.FUNC_ADD);
+                }
+                initDebugOverlayCanvas() {
+                  null == this.debugOverlayCanvas && (this.debugOverlayCanvas = document.createElement("canvas"), this.debugOverlayCanvas.width = 512, this.debugOverlayCanvas.height = 512, this.debugOverlayTexture = new b2(this.context, this.debugOverlayCanvas, this.context.gl.RGBA));
+                }
+                destroy() {
+                  this.debugOverlayTexture && this.debugOverlayTexture.destroy();
+                }
+                overLimit() {
+                  const { drawingBufferWidth: t42, drawingBufferHeight: e22 } = this.context.gl;
+                  return this.width !== t42 || this.height !== e22;
+                }
+              }
+              class xa {
+                constructor(t42, e22) {
+                  this.points = t42, this.planes = e22;
+                }
+                static fromInvProjectionMatrix(t42, i22, a22) {
+                  const s22 = Math.pow(2, a22), o22 = [[-1, 1, -1, 1], [1, 1, -1, 1], [1, -1, -1, 1], [-1, -1, -1, 1], [-1, 1, 1, 1], [1, 1, 1, 1], [1, -1, 1, 1], [-1, -1, 1, 1]].map((a3) => {
+                    const o3 = 1 / (a3 = e2.af([], a3, t42))[3] / i22 * s22;
+                    return e2.b1(a3, a3, [o3, o3, 1 / a3[3], o3]);
+                  }), r22 = [[0, 1, 2], [6, 5, 4], [0, 3, 7], [2, 1, 5], [3, 2, 6], [0, 4, 5]].map((t5) => {
+                    const e22 = function(t6, e3) {
+                      var i4 = e3[0], a4 = e3[1], s4 = e3[2], o3 = i4 * i4 + a4 * a4 + s4 * s4;
+                      return o3 > 0 && (o3 = 1 / Math.sqrt(o3)), t6[0] = e3[0] * o3, t6[1] = e3[1] * o3, t6[2] = e3[2] * o3, t6;
+                    }([], function(t6, e3, i4) {
+                      var a4 = e3[0], s4 = e3[1], o3 = e3[2], r3 = i4[0], n22 = i4[1], l22 = i4[2];
+                      return t6[0] = s4 * l22 - o3 * n22, t6[1] = o3 * r3 - a4 * l22, t6[2] = a4 * n22 - s4 * r3, t6;
+                    }([], g2([], o22[t5[0]], o22[t5[1]]), g2([], o22[t5[2]], o22[t5[1]]))), i3 = -((a3 = e22)[0] * (s3 = o22[t5[1]])[0] + a3[1] * s3[1] + a3[2] * s3[2]);
+                    var a3, s3;
+                    return e22.concat(i3);
+                  });
+                  return new xa(o22, r22);
+                }
+              }
+              class ya2 {
+                constructor(t42, e22) {
+                  this.min = t42, this.max = e22, this.center = function(t5, e3, i22) {
+                    return t5[0] = 0.5 * e3[0], t5[1] = 0.5 * e3[1], t5[2] = 0.5 * e3[2], t5;
+                  }([], function(t5, e3, i22) {
+                    return t5[0] = e3[0] + i22[0], t5[1] = e3[1] + i22[1], t5[2] = e3[2] + i22[2], t5;
+                  }([], this.min, this.max));
+                }
+                quadrant(t42) {
+                  const e22 = [t42 % 2 == 0, t42 < 2], i22 = m2(this.min), a22 = m2(this.max);
+                  for (let t5 = 0; t5 < e22.length; t5++) i22[t5] = e22[t5] ? this.min[t5] : this.center[t5], a22[t5] = e22[t5] ? this.center[t5] : this.max[t5];
+                  return a22[2] = this.max[2], new ya2(i22, a22);
+                }
+                distanceX(t42) {
+                  return Math.max(Math.min(this.max[0], t42[0]), this.min[0]) - t42[0];
+                }
+                distanceY(t42) {
+                  return Math.max(Math.min(this.max[1], t42[1]), this.min[1]) - t42[1];
+                }
+                intersects(t42) {
+                  const i22 = [[this.min[0], this.min[1], this.min[2], 1], [this.max[0], this.min[1], this.min[2], 1], [this.max[0], this.max[1], this.min[2], 1], [this.min[0], this.max[1], this.min[2], 1], [this.min[0], this.min[1], this.max[2], 1], [this.max[0], this.min[1], this.max[2], 1], [this.max[0], this.max[1], this.max[2], 1], [this.min[0], this.max[1], this.max[2], 1]];
+                  let a22 = true;
+                  for (let s22 = 0; s22 < t42.planes.length; s22++) {
+                    const o22 = t42.planes[s22];
+                    let r22 = 0;
+                    for (let t5 = 0; t5 < i22.length; t5++) e2.b2(o22, i22[t5]) >= 0 && r22++;
+                    if (0 === r22) return 0;
+                    r22 !== i22.length && (a22 = false);
+                  }
+                  if (a22) return 2;
+                  for (let e22 = 0; e22 < 3; e22++) {
+                    let i3 = Number.MAX_VALUE, a3 = -Number.MAX_VALUE;
+                    for (let s22 = 0; s22 < t42.points.length; s22++) {
+                      const o22 = t42.points[s22][e22] - this.min[e22];
+                      i3 = Math.min(i3, o22), a3 = Math.max(a3, o22);
+                    }
+                    if (a3 < 0 || i3 > this.max[e22] - this.min[e22]) return 0;
+                  }
+                  return 1;
+                }
+              }
+              class ba {
+                constructor(t42 = 0, e22 = 0, i22 = 0, a22 = 0) {
+                  if (isNaN(t42) || t42 < 0 || isNaN(e22) || e22 < 0 || isNaN(i22) || i22 < 0 || isNaN(a22) || a22 < 0) throw new Error("Invalid value for edge-insets, top, bottom, left and right must all be numbers");
+                  this.top = t42, this.bottom = e22, this.left = i22, this.right = a22;
+                }
+                interpolate(t42, i22, a22) {
+                  return null != i22.top && null != t42.top && (this.top = e2.y.number(t42.top, i22.top, a22)), null != i22.bottom && null != t42.bottom && (this.bottom = e2.y.number(t42.bottom, i22.bottom, a22)), null != i22.left && null != t42.left && (this.left = e2.y.number(t42.left, i22.left, a22)), null != i22.right && null != t42.right && (this.right = e2.y.number(t42.right, i22.right, a22)), this;
+                }
+                getCenter(t42, i22) {
+                  const a22 = e2.ac((this.left + t42 - this.right) / 2, 0, t42), s22 = e2.ac((this.top + i22 - this.bottom) / 2, 0, i22);
+                  return new e2.P(a22, s22);
+                }
+                equals(t42) {
+                  return this.top === t42.top && this.bottom === t42.bottom && this.left === t42.left && this.right === t42.right;
+                }
+                clone() {
+                  return new ba(this.top, this.bottom, this.left, this.right);
+                }
+                toJSON() {
+                  return { top: this.top, bottom: this.bottom, left: this.left, right: this.right };
+                }
+              }
+              const wa2 = 85.051129;
+              class Ta2 {
+                constructor(t42, i22, a22, s22, o22) {
+                  this.tileSize = 512, this._renderWorldCopies = void 0 === o22 || !!o22, this._minZoom = t42 || 0, this._maxZoom = i22 || 22, this._minPitch = null == a22 ? 0 : a22, this._maxPitch = null == s22 ? 60 : s22, this.setMaxBounds(), this.width = 0, this.height = 0, this._center = new e2.N(0, 0), this._elevation = 0, this.zoom = 0, this.angle = 0, this._fov = 0.6435011087932844, this._pitch = 0, this._unmodified = true, this._edgeInsets = new ba(), this._posMatrixCache = {}, this._alignedPosMatrixCache = {}, this._fogMatrixCache = {}, this.minElevationForCurrentTile = 0;
+                }
+                clone() {
+                  const t42 = new Ta2(this._minZoom, this._maxZoom, this._minPitch, this.maxPitch, this._renderWorldCopies);
+                  return t42.apply(this), t42;
+                }
+                apply(t42) {
+                  this.tileSize = t42.tileSize, this.latRange = t42.latRange, this.lngRange = t42.lngRange, this.width = t42.width, this.height = t42.height, this._center = t42._center, this._elevation = t42._elevation, this.minElevationForCurrentTile = t42.minElevationForCurrentTile, this.zoom = t42.zoom, this.angle = t42.angle, this._fov = t42._fov, this._pitch = t42._pitch, this._unmodified = t42._unmodified, this._edgeInsets = t42._edgeInsets.clone(), this._calcMatrices();
+                }
+                get minZoom() {
+                  return this._minZoom;
+                }
+                set minZoom(t42) {
+                  this._minZoom !== t42 && (this._minZoom = t42, this.zoom = Math.max(this.zoom, t42));
+                }
+                get maxZoom() {
+                  return this._maxZoom;
+                }
+                set maxZoom(t42) {
+                  this._maxZoom !== t42 && (this._maxZoom = t42, this.zoom = Math.min(this.zoom, t42));
+                }
+                get minPitch() {
+                  return this._minPitch;
+                }
+                set minPitch(t42) {
+                  this._minPitch !== t42 && (this._minPitch = t42, this.pitch = Math.max(this.pitch, t42));
+                }
+                get maxPitch() {
+                  return this._maxPitch;
+                }
+                set maxPitch(t42) {
+                  this._maxPitch !== t42 && (this._maxPitch = t42, this.pitch = Math.min(this.pitch, t42));
+                }
+                get renderWorldCopies() {
+                  return this._renderWorldCopies;
+                }
+                set renderWorldCopies(t42) {
+                  void 0 === t42 ? t42 = true : null === t42 && (t42 = false), this._renderWorldCopies = t42;
+                }
+                get worldSize() {
+                  return this.tileSize * this.scale;
+                }
+                get centerOffset() {
+                  return this.centerPoint._sub(this.size._div(2));
+                }
+                get size() {
+                  return new e2.P(this.width, this.height);
+                }
+                get bearing() {
+                  return -this.angle / Math.PI * 180;
+                }
+                set bearing(t42) {
+                  const i22 = -e2.b3(t42, -180, 180) * Math.PI / 180;
+                  this.angle !== i22 && (this._unmodified = false, this.angle = i22, this._calcMatrices(), this.rotationMatrix = function() {
+                    var t5 = new e2.A(4);
+                    return e2.A != Float32Array && (t5[1] = 0, t5[2] = 0), t5[0] = 1, t5[3] = 1, t5;
+                  }(), function(t5, e22, i3) {
+                    var a22 = e22[0], s22 = e22[1], o22 = e22[2], r22 = e22[3], n22 = Math.sin(i3), l22 = Math.cos(i3);
+                    t5[0] = a22 * l22 + o22 * n22, t5[1] = s22 * l22 + r22 * n22, t5[2] = a22 * -n22 + o22 * l22, t5[3] = s22 * -n22 + r22 * l22;
+                  }(this.rotationMatrix, this.rotationMatrix, this.angle));
+                }
+                get pitch() {
+                  return this._pitch / Math.PI * 180;
+                }
+                set pitch(t42) {
+                  const i22 = e2.ac(t42, this.minPitch, this.maxPitch) / 180 * Math.PI;
+                  this._pitch !== i22 && (this._unmodified = false, this._pitch = i22, this._calcMatrices());
+                }
+                get fov() {
+                  return this._fov / Math.PI * 180;
+                }
+                set fov(t42) {
+                  t42 = Math.max(0.01, Math.min(60, t42)), this._fov !== t42 && (this._unmodified = false, this._fov = t42 / 180 * Math.PI, this._calcMatrices());
+                }
+                get zoom() {
+                  return this._zoom;
+                }
+                set zoom(t42) {
+                  const e22 = Math.min(Math.max(t42, this.minZoom), this.maxZoom);
+                  this._zoom !== e22 && (this._unmodified = false, this._zoom = e22, this.tileZoom = Math.max(0, Math.floor(e22)), this.scale = this.zoomScale(e22), this._constrain(), this._calcMatrices());
+                }
+                get center() {
+                  return this._center;
+                }
+                set center(t42) {
+                  t42.lat === this._center.lat && t42.lng === this._center.lng || (this._unmodified = false, this._center = t42, this._constrain(), this._calcMatrices());
+                }
+                get elevation() {
+                  return this._elevation;
+                }
+                set elevation(t42) {
+                  t42 !== this._elevation && (this._elevation = t42, this._constrain(), this._calcMatrices());
+                }
+                get padding() {
+                  return this._edgeInsets.toJSON();
+                }
+                set padding(t42) {
+                  this._edgeInsets.equals(t42) || (this._unmodified = false, this._edgeInsets.interpolate(this._edgeInsets, t42, 1), this._calcMatrices());
+                }
+                get centerPoint() {
+                  return this._edgeInsets.getCenter(this.width, this.height);
+                }
+                isPaddingEqual(t42) {
+                  return this._edgeInsets.equals(t42);
+                }
+                interpolatePadding(t42, e22, i22) {
+                  this._unmodified = false, this._edgeInsets.interpolate(t42, e22, i22), this._constrain(), this._calcMatrices();
+                }
+                coveringZoomLevel(t42) {
+                  const e22 = (t42.roundZoom ? Math.round : Math.floor)(this.zoom + this.scaleZoom(this.tileSize / t42.tileSize));
+                  return Math.max(0, e22);
+                }
+                getVisibleUnwrappedCoordinates(t42) {
+                  const i22 = [new e2.b4(0, t42)];
+                  if (this._renderWorldCopies) {
+                    const a22 = this.pointCoordinate(new e2.P(0, 0)), s22 = this.pointCoordinate(new e2.P(this.width, 0)), o22 = this.pointCoordinate(new e2.P(this.width, this.height)), r22 = this.pointCoordinate(new e2.P(0, this.height)), n22 = Math.floor(Math.min(a22.x, s22.x, o22.x, r22.x)), l22 = Math.floor(Math.max(a22.x, s22.x, o22.x, r22.x)), h22 = 1;
+                    for (let a3 = n22 - h22; a3 <= l22 + h22; a3++) 0 !== a3 && i22.push(new e2.b4(a3, t42));
+                  }
+                  return i22;
+                }
+                coveringTiles(t42) {
+                  var i22, a22;
+                  let s22 = this.coveringZoomLevel(t42);
+                  const o22 = s22;
+                  if (void 0 !== t42.minzoom && s22 < t42.minzoom) return [];
+                  void 0 !== t42.maxzoom && s22 > t42.maxzoom && (s22 = t42.maxzoom);
+                  const r22 = this.pointCoordinate(this.getCameraPoint()), n22 = e2.Z.fromLngLat(this.center), l22 = Math.pow(2, s22), h22 = [l22 * r22.x, l22 * r22.y, 0], c22 = [l22 * n22.x, l22 * n22.y, 0], u22 = xa.fromInvProjectionMatrix(this.invModelViewProjectionMatrix, this.worldSize, s22);
+                  let d22 = t42.minzoom || 0;
+                  !t42.terrain && this.pitch <= 60 && this._edgeInsets.top < 0.1 && (d22 = s22);
+                  const _22 = t42.terrain ? 2 / Math.min(this.tileSize, t42.tileSize) * this.tileSize : 3, p22 = (t5) => ({ aabb: new ya2([t5 * l22, 0, 0], [(t5 + 1) * l22, l22, 0]), zoom: 0, x: 0, y: 0, wrap: t5, fullyVisible: false }), m22 = [], f22 = [], g22 = s22, x22 = t42.reparseOverscaled ? o22 : s22;
+                  if (this._renderWorldCopies) for (let t5 = 1; t5 <= 3; t5++) m22.push(p22(-t5)), m22.push(p22(t5));
+                  for (m22.push(p22(0)); m22.length > 0; ) {
+                    const s3 = m22.pop(), o3 = s3.x, r3 = s3.y;
+                    let n3 = s3.fullyVisible;
+                    if (!n3) {
+                      const t5 = s3.aabb.intersects(u22);
+                      if (0 === t5) continue;
+                      n3 = 2 === t5;
+                    }
+                    const l3 = t42.terrain ? h22 : c22, p3 = s3.aabb.distanceX(l3), y22 = s3.aabb.distanceY(l3), b22 = Math.max(Math.abs(p3), Math.abs(y22));
+                    if (s3.zoom === g22 || b22 > _22 + (1 << g22 - s3.zoom) - 2 && s3.zoom >= d22) {
+                      const t5 = g22 - s3.zoom, i3 = h22[0] - 0.5 - (o3 << t5), a3 = h22[1] - 0.5 - (r3 << t5);
+                      f22.push({ tileID: new e2.S(s3.zoom === g22 ? x22 : s3.zoom, s3.wrap, s3.zoom, o3, r3), distanceSq: v2([c22[0] - 0.5 - o3, c22[1] - 0.5 - r3]), tileDistanceToCamera: Math.sqrt(i3 * i3 + a3 * a3) });
+                    } else for (let l4 = 0; l4 < 4; l4++) {
+                      const h3 = (o3 << 1) + l4 % 2, c3 = (r3 << 1) + (l4 >> 1), u3 = s3.zoom + 1;
+                      let d3 = s3.aabb.quadrant(l4);
+                      if (t42.terrain) {
+                        const o4 = new e2.S(u3, s3.wrap, u3, h3, c3), r4 = t42.terrain.getMinMaxElevation(o4), n4 = null !== (i22 = r4.minElevation) && void 0 !== i22 ? i22 : this.elevation, l5 = null !== (a22 = r4.maxElevation) && void 0 !== a22 ? a22 : this.elevation;
+                        d3 = new ya2([d3.min[0], d3.min[1], n4], [d3.max[0], d3.max[1], l5]);
+                      }
+                      m22.push({ aabb: d3, zoom: u3, x: h3, y: c3, wrap: s3.wrap, fullyVisible: n3 });
+                    }
+                  }
+                  return f22.sort((t5, e22) => t5.distanceSq - e22.distanceSq).map((t5) => t5.tileID);
+                }
+                resize(t42, e22) {
+                  this.width = t42, this.height = e22, this.pixelsToGLUnits = [2 / t42, -2 / e22], this._constrain(), this._calcMatrices();
+                }
+                get unmodified() {
+                  return this._unmodified;
+                }
+                zoomScale(t42) {
+                  return Math.pow(2, t42);
+                }
+                scaleZoom(t42) {
+                  return Math.log(t42) / Math.LN2;
+                }
+                project(t42) {
+                  const i22 = e2.ac(t42.lat, -85.051129, wa2);
+                  return new e2.P(e2.O(t42.lng) * this.worldSize, e2.Q(i22) * this.worldSize);
+                }
+                unproject(t42) {
+                  return new e2.Z(t42.x / this.worldSize, t42.y / this.worldSize).toLngLat();
+                }
+                get point() {
+                  return this.project(this.center);
+                }
+                getCameraPosition() {
+                  return { lngLat: this.pointLocation(this.getCameraPoint()), altitude: Math.cos(this._pitch) * this.cameraToCenterDistance / this._pixelPerMeter + this.elevation };
+                }
+                recalculateZoom(t42) {
+                  const i22 = this.elevation, a22 = Math.cos(this._pitch) * this.cameraToCenterDistance / this._pixelPerMeter, s22 = this.pointLocation(this.centerPoint, t42), o22 = t42.getElevationForLngLatZoom(s22, this.tileZoom);
+                  if (!(this.elevation - o22)) return;
+                  const r22 = a22 + i22 - o22, n22 = Math.cos(this._pitch) * this.cameraToCenterDistance / r22 / e2.b5(1, s22.lat), l22 = this.scaleZoom(n22 / this.tileSize);
+                  this._elevation = o22, this._center = s22, this.zoom = l22;
+                }
+                setLocationAtPoint(t42, i22) {
+                  const a22 = this.pointCoordinate(i22), s22 = this.pointCoordinate(this.centerPoint), o22 = this.locationCoordinate(t42), r22 = new e2.Z(o22.x - (a22.x - s22.x), o22.y - (a22.y - s22.y));
+                  this.center = this.coordinateLocation(r22), this._renderWorldCopies && (this.center = this.center.wrap());
+                }
+                locationPoint(t42, e22) {
+                  return e22 ? this.coordinatePoint(this.locationCoordinate(t42), e22.getElevationForLngLatZoom(t42, this.tileZoom), this.pixelMatrix3D) : this.coordinatePoint(this.locationCoordinate(t42));
+                }
+                pointLocation(t42, e22) {
+                  return this.coordinateLocation(this.pointCoordinate(t42, e22));
+                }
+                locationCoordinate(t42) {
+                  return e2.Z.fromLngLat(t42);
+                }
+                coordinateLocation(t42) {
+                  return t42 && t42.toLngLat();
+                }
+                pointCoordinate(t42, i22) {
+                  if (i22) {
+                    const e22 = i22.pointCoordinate(t42);
+                    if (null != e22) return e22;
+                  }
+                  const a22 = [t42.x, t42.y, 0, 1], s22 = [t42.x, t42.y, 1, 1];
+                  e2.af(a22, a22, this.pixelMatrixInverse), e2.af(s22, s22, this.pixelMatrixInverse);
+                  const o22 = a22[3], r22 = s22[3], n22 = a22[1] / o22, l22 = s22[1] / r22, h22 = a22[2] / o22, c22 = s22[2] / r22, u22 = h22 === c22 ? 0 : (0 - h22) / (c22 - h22);
+                  return new e2.Z(e2.y.number(a22[0] / o22, s22[0] / r22, u22) / this.worldSize, e2.y.number(n22, l22, u22) / this.worldSize);
+                }
+                coordinatePoint(t42, i22 = 0, a22 = this.pixelMatrix) {
+                  const s22 = [t42.x * this.worldSize, t42.y * this.worldSize, i22, 1];
+                  return e2.af(s22, s22, a22), new e2.P(s22[0] / s22[3], s22[1] / s22[3]);
+                }
+                getBounds() {
+                  const t42 = Math.max(0, this.height / 2 - this.getHorizon());
+                  return new H2().extend(this.pointLocation(new e2.P(0, t42))).extend(this.pointLocation(new e2.P(this.width, t42))).extend(this.pointLocation(new e2.P(this.width, this.height))).extend(this.pointLocation(new e2.P(0, this.height)));
+                }
+                getMaxBounds() {
+                  return this.latRange && 2 === this.latRange.length && this.lngRange && 2 === this.lngRange.length ? new H2([this.lngRange[0], this.latRange[0]], [this.lngRange[1], this.latRange[1]]) : null;
+                }
+                getHorizon() {
+                  return Math.tan(Math.PI / 2 - this._pitch) * this.cameraToCenterDistance * 0.85;
+                }
+                setMaxBounds(t42) {
+                  t42 ? (this.lngRange = [t42.getWest(), t42.getEast()], this.latRange = [t42.getSouth(), t42.getNorth()], this._constrain()) : (this.lngRange = null, this.latRange = [-85.051129, wa2]);
+                }
+                calculateTileMatrix(t42) {
+                  const i22 = t42.canonical, a22 = this.worldSize / this.zoomScale(i22.z), s22 = i22.x + Math.pow(2, i22.z) * t42.wrap, o22 = e2.an(new Float64Array(16));
+                  return e2.J(o22, o22, [s22 * a22, i22.y * a22, 0]), e2.K(o22, o22, [a22 / e2.X, a22 / e2.X, 1]), o22;
+                }
+                calculatePosMatrix(t42, i22 = false) {
+                  const a22 = t42.key, s22 = i22 ? this._alignedPosMatrixCache : this._posMatrixCache;
+                  if (s22[a22]) return s22[a22];
+                  const o22 = this.calculateTileMatrix(t42);
+                  return e2.L(o22, i22 ? this.alignedModelViewProjectionMatrix : this.modelViewProjectionMatrix, o22), s22[a22] = new Float32Array(o22), s22[a22];
+                }
+                calculateFogMatrix(t42) {
+                  const i22 = t42.key, a22 = this._fogMatrixCache;
+                  if (a22[i22]) return a22[i22];
+                  const s22 = this.calculateTileMatrix(t42);
+                  return e2.L(s22, this.fogMatrix, s22), a22[i22] = new Float32Array(s22), a22[i22];
+                }
+                customLayerMatrix() {
+                  return this.mercatorMatrix.slice();
+                }
+                getConstrained(t42, i22) {
+                  i22 = e2.ac(+i22, this.minZoom, this.maxZoom);
+                  const a22 = { center: new e2.N(t42.lng, t42.lat), zoom: i22 };
+                  let s22 = this.lngRange;
+                  if (!this._renderWorldCopies && null === s22) {
+                    const t5 = 180 - 1e-10;
+                    s22 = [-179.9999999999, t5];
+                  }
+                  const o22 = this.tileSize * this.zoomScale(a22.zoom);
+                  let r22 = 0, n22 = o22, l22 = 0, h22 = o22, c22 = 0, u22 = 0;
+                  const { x: d22, y: _22 } = this.size;
+                  if (this.latRange) {
+                    const t5 = this.latRange;
+                    r22 = e2.Q(t5[1]) * o22, n22 = e2.Q(t5[0]) * o22, n22 - r22 < _22 && (c22 = _22 / (n22 - r22));
+                  }
+                  s22 && (l22 = e2.b3(e2.O(s22[0]) * o22, 0, o22), h22 = e2.b3(e2.O(s22[1]) * o22, 0, o22), h22 < l22 && (h22 += o22), h22 - l22 < d22 && (u22 = d22 / (h22 - l22)));
+                  const { x: p22, y: m22 } = this.project.call({ worldSize: o22 }, t42);
+                  let f22, g22;
+                  const v22 = Math.max(u22 || 0, c22 || 0);
+                  if (v22) {
+                    const t5 = new e2.P(u22 ? (h22 + l22) / 2 : p22, c22 ? (n22 + r22) / 2 : m22);
+                    return a22.center = this.unproject.call({ worldSize: o22 }, t5).wrap(), a22.zoom += this.scaleZoom(v22), a22;
+                  }
+                  if (this.latRange) {
+                    const t5 = _22 / 2;
+                    m22 - t5 < r22 && (g22 = r22 + t5), m22 + t5 > n22 && (g22 = n22 - t5);
+                  }
+                  if (s22) {
+                    const t5 = (l22 + h22) / 2;
+                    let i3 = p22;
+                    this._renderWorldCopies && (i3 = e2.b3(p22, t5 - o22 / 2, t5 + o22 / 2));
+                    const a3 = d22 / 2;
+                    i3 - a3 < l22 && (f22 = l22 + a3), i3 + a3 > h22 && (f22 = h22 - a3);
+                  }
+                  if (void 0 !== f22 || void 0 !== g22) {
+                    const t5 = new e2.P(null != f22 ? f22 : p22, null != g22 ? g22 : m22);
+                    a22.center = this.unproject.call({ worldSize: o22 }, t5).wrap();
+                  }
+                  return a22;
+                }
+                _constrain() {
+                  if (!this.center || !this.width || !this.height || this._constraining) return;
+                  this._constraining = true;
+                  const t42 = this._unmodified, { center: e22, zoom: i22 } = this.getConstrained(this.center, this.zoom);
+                  this.center = e22, this.zoom = i22, this._unmodified = t42, this._constraining = false;
+                }
+                _calcMatrices() {
+                  if (!this.height) return;
+                  const t42 = this.centerOffset, i22 = this.point.x, a22 = this.point.y;
+                  this.cameraToCenterDistance = 0.5 / Math.tan(this._fov / 2) * this.height, this._pixelPerMeter = e2.b5(1, this.center.lat) * this.worldSize;
+                  let s22 = e2.an(new Float64Array(16));
+                  e2.K(s22, s22, [this.width / 2, -this.height / 2, 1]), e2.J(s22, s22, [1, -1, 0]), this.labelPlaneMatrix = s22, s22 = e2.an(new Float64Array(16)), e2.K(s22, s22, [1, -1, 1]), e2.J(s22, s22, [-1, -1, 0]), e2.K(s22, s22, [2 / this.width, 2 / this.height, 1]), this.glCoordMatrix = s22;
+                  const o22 = this.cameraToCenterDistance + this._elevation * this._pixelPerMeter / Math.cos(this._pitch), r22 = Math.min(this.elevation, this.minElevationForCurrentTile), n22 = o22 - r22 * this._pixelPerMeter / Math.cos(this._pitch), l22 = r22 < 0 ? n22 : o22, h22 = Math.PI / 2 + this._pitch, c22 = this._fov * (0.5 + t42.y / this.height), u22 = Math.sin(c22) * l22 / Math.sin(e2.ac(Math.PI - h22 - c22, 0.01, Math.PI - 0.01)), d22 = this.getHorizon(), _22 = 2 * Math.atan(d22 / this.cameraToCenterDistance) * (0.5 + t42.y / (2 * d22)), p22 = Math.sin(_22) * l22 / Math.sin(e2.ac(Math.PI - h22 - _22, 0.01, Math.PI - 0.01)), m22 = Math.min(u22, p22);
+                  this.farZ = 1.01 * (Math.cos(Math.PI / 2 - this._pitch) * m22 + l22), this.nearZ = this.height / 50, s22 = new Float64Array(16), e2.b6(s22, this._fov, this.width / this.height, this.nearZ, this.farZ), s22[8] = 2 * -t42.x / this.width, s22[9] = 2 * t42.y / this.height, this.projectionMatrix = e2.ae(s22), e2.K(s22, s22, [1, -1, 1]), e2.J(s22, s22, [0, 0, -this.cameraToCenterDistance]), e2.b7(s22, s22, this._pitch), e2.ad(s22, s22, this.angle), e2.J(s22, s22, [-i22, -a22, 0]), this.mercatorMatrix = e2.K([], s22, [this.worldSize, this.worldSize, this.worldSize]), e2.K(s22, s22, [1, 1, this._pixelPerMeter]), this.pixelMatrix = e2.L(new Float64Array(16), this.labelPlaneMatrix, s22), e2.J(s22, s22, [0, 0, -this.elevation]), this.modelViewProjectionMatrix = s22, this.invModelViewProjectionMatrix = e2.as([], s22), this.fogMatrix = new Float64Array(16), e2.b6(this.fogMatrix, this._fov, this.width / this.height, o22, this.farZ), this.fogMatrix[8] = 2 * -t42.x / this.width, this.fogMatrix[9] = 2 * t42.y / this.height, e2.K(this.fogMatrix, this.fogMatrix, [1, -1, 1]), e2.J(this.fogMatrix, this.fogMatrix, [0, 0, -this.cameraToCenterDistance]), e2.b7(this.fogMatrix, this.fogMatrix, this._pitch), e2.ad(this.fogMatrix, this.fogMatrix, this.angle), e2.J(this.fogMatrix, this.fogMatrix, [-i22, -a22, 0]), e2.K(this.fogMatrix, this.fogMatrix, [1, 1, this._pixelPerMeter]), e2.J(this.fogMatrix, this.fogMatrix, [0, 0, -this.elevation]), this.pixelMatrix3D = e2.L(new Float64Array(16), this.labelPlaneMatrix, s22);
+                  const f22 = this.width % 2 / 2, g22 = this.height % 2 / 2, v22 = Math.cos(this.angle), x22 = Math.sin(this.angle), y22 = i22 - Math.round(i22) + v22 * f22 + x22 * g22, b22 = a22 - Math.round(a22) + v22 * g22 + x22 * f22, w22 = new Float64Array(s22);
+                  if (e2.J(w22, w22, [y22 > 0.5 ? y22 - 1 : y22, b22 > 0.5 ? b22 - 1 : b22, 0]), this.alignedModelViewProjectionMatrix = w22, s22 = e2.as(new Float64Array(16), this.pixelMatrix), !s22) throw new Error("failed to invert matrix");
+                  this.pixelMatrixInverse = s22, this._posMatrixCache = {}, this._alignedPosMatrixCache = {}, this._fogMatrixCache = {};
+                }
+                maxPitchScaleFactor() {
+                  if (!this.pixelMatrixInverse) return 1;
+                  const t42 = this.pointCoordinate(new e2.P(0, 0)), i22 = [t42.x * this.worldSize, t42.y * this.worldSize, 0, 1];
+                  return e2.af(i22, i22, this.pixelMatrix)[3] / this.cameraToCenterDistance;
+                }
+                getCameraPoint() {
+                  const t42 = Math.tan(this._pitch) * (this.cameraToCenterDistance || 1);
+                  return this.centerPoint.add(new e2.P(0, t42));
+                }
+                getCameraQueryGeometry(t42) {
+                  const i22 = this.getCameraPoint();
+                  if (1 === t42.length) return [t42[0], i22];
+                  {
+                    let a22 = i22.x, s22 = i22.y, o22 = i22.x, r22 = i22.y;
+                    for (const e22 of t42) a22 = Math.min(a22, e22.x), s22 = Math.min(s22, e22.y), o22 = Math.max(o22, e22.x), r22 = Math.max(r22, e22.y);
+                    return [new e2.P(a22, s22), new e2.P(o22, s22), new e2.P(o22, r22), new e2.P(a22, r22), new e2.P(a22, s22)];
+                  }
+                }
+                lngLatToCameraDepth(t42, i22) {
+                  const a22 = this.locationCoordinate(t42), s22 = [a22.x * this.worldSize, a22.y * this.worldSize, i22, 1];
+                  return e2.af(s22, s22, this.modelViewProjectionMatrix), s22[2] / s22[3];
+                }
+              }
+              function Ia2(t42, e22) {
+                let i22, a22 = false, s22 = null, o22 = null;
+                const r22 = () => {
+                  s22 = null, a22 && (t42.apply(o22, i22), s22 = setTimeout(r22, e22), a22 = false);
+                };
+                return (...t5) => (a22 = true, o22 = this, i22 = t5, s22 || r22(), s22);
+              }
+              class Ea2 {
+                constructor(t42) {
+                  this._getCurrentHash = () => {
+                    const t5 = window.location.hash.replace("#", "");
+                    if (this._hashName) {
+                      let e22;
+                      return t5.split("&").map((t6) => t6.split("=")).forEach((t6) => {
+                        t6[0] === this._hashName && (e22 = t6);
+                      }), (e22 && e22[1] || "").split("/");
+                    }
+                    return t5.split("/");
+                  }, this._onHashChange = () => {
+                    const t5 = this._getCurrentHash();
+                    if (t5.length >= 3 && !t5.some((t6) => isNaN(t6))) {
+                      const e22 = this._map.dragRotate.isEnabled() && this._map.touchZoomRotate.isEnabled() ? +(t5[3] || 0) : this._map.getBearing();
+                      return this._map.jumpTo({ center: [+t5[2], +t5[1]], zoom: +t5[0], bearing: e22, pitch: +(t5[4] || 0) }), true;
+                    }
+                    return false;
+                  }, this._updateHashUnthrottled = () => {
+                    const t5 = window.location.href.replace(/(#.*)?$/, this.getHashString());
+                    window.history.replaceState(window.history.state, null, t5);
+                  }, this._removeHash = () => {
+                    const t5 = this._getCurrentHash();
+                    if (0 === t5.length) return;
+                    const e22 = t5.join("/");
+                    let i22 = e22;
+                    i22.split("&").length > 0 && (i22 = i22.split("&")[0]), this._hashName && (i22 = `${this._hashName}=${e22}`);
+                    let a22 = window.location.hash.replace(i22, "");
+                    a22.startsWith("#&") ? a22 = a22.slice(0, 1) + a22.slice(2) : "#" === a22 && (a22 = "");
+                    let s22 = window.location.href.replace(/(#.+)?$/, a22);
+                    s22 = s22.replace("&&", "&"), window.history.replaceState(window.history.state, null, s22);
+                  }, this._updateHash = Ia2(this._updateHashUnthrottled, 300), this._hashName = t42 && encodeURIComponent(t42);
+                }
+                addTo(t42) {
+                  return this._map = t42, addEventListener("hashchange", this._onHashChange, false), this._map.on("moveend", this._updateHash), this;
+                }
+                remove() {
+                  return removeEventListener("hashchange", this._onHashChange, false), this._map.off("moveend", this._updateHash), clearTimeout(this._updateHash()), this._removeHash(), delete this._map, this;
+                }
+                getHashString(t42) {
+                  const e22 = this._map.getCenter(), i22 = Math.round(100 * this._map.getZoom()) / 100, a22 = Math.ceil((i22 * Math.LN2 + Math.log(512 / 360 / 0.5)) / Math.LN10), s22 = Math.pow(10, a22), o22 = Math.round(e22.lng * s22) / s22, r22 = Math.round(e22.lat * s22) / s22, n22 = this._map.getBearing(), l22 = this._map.getPitch();
+                  let h22 = "";
+                  if (h22 += t42 ? `/${o22}/${r22}/${i22}` : `${i22}/${r22}/${o22}`, (n22 || l22) && (h22 += "/" + Math.round(10 * n22) / 10), l22 && (h22 += `/${Math.round(l22)}`), this._hashName) {
+                    const t5 = this._hashName;
+                    let e3 = false;
+                    const i3 = window.location.hash.slice(1).split("&").map((i4) => {
+                      const a3 = i4.split("=")[0];
+                      return a3 === t5 ? (e3 = true, `${a3}=${h22}`) : i4;
+                    }).filter((t6) => t6);
+                    return e3 || i3.push(`${t5}=${h22}`), `#${i3.join("&")}`;
+                  }
+                  return `#${h22}`;
+                }
+              }
+              const Pa2 = { linearity: 0.3, easing: e2.b8(0, 0, 0.3, 1) }, Ca2 = e2.e({ deceleration: 2500, maxSpeed: 1400 }, Pa2), Sa2 = e2.e({ deceleration: 20, maxSpeed: 1400 }, Pa2), za2 = e2.e({ deceleration: 1e3, maxSpeed: 360 }, Pa2), Da2 = e2.e({ deceleration: 1e3, maxSpeed: 90 }, Pa2);
+              class Ma2 {
+                constructor(t42) {
+                  this._map = t42, this.clear();
+                }
+                clear() {
+                  this._inertiaBuffer = [];
+                }
+                record(t42) {
+                  this._drainInertiaBuffer(), this._inertiaBuffer.push({ time: o2.now(), settings: t42 });
+                }
+                _drainInertiaBuffer() {
+                  const t42 = this._inertiaBuffer, e22 = o2.now();
+                  for (; t42.length > 0 && e22 - t42[0].time > 160; ) t42.shift();
+                }
+                _onMoveEnd(t42) {
+                  if (this._drainInertiaBuffer(), this._inertiaBuffer.length < 2) return;
+                  const i22 = { zoom: 0, bearing: 0, pitch: 0, pan: new e2.P(0, 0), pinchAround: void 0, around: void 0 };
+                  for (const { settings: t5 } of this._inertiaBuffer) i22.zoom += t5.zoomDelta || 0, i22.bearing += t5.bearingDelta || 0, i22.pitch += t5.pitchDelta || 0, t5.panDelta && i22.pan._add(t5.panDelta), t5.around && (i22.around = t5.around), t5.pinchAround && (i22.pinchAround = t5.pinchAround);
+                  const a22 = this._inertiaBuffer[this._inertiaBuffer.length - 1].time - this._inertiaBuffer[0].time, s22 = {};
+                  if (i22.pan.mag()) {
+                    const o22 = Ra2(i22.pan.mag(), a22, e2.e({}, Ca2, t42 || {}));
+                    s22.offset = i22.pan.mult(o22.amount / i22.pan.mag()), s22.center = this._map.transform.center, Aa2(s22, o22);
+                  }
+                  if (i22.zoom) {
+                    const t5 = Ra2(i22.zoom, a22, Sa2);
+                    s22.zoom = this._map.transform.zoom + t5.amount, Aa2(s22, t5);
+                  }
+                  if (i22.bearing) {
+                    const t5 = Ra2(i22.bearing, a22, za2);
+                    s22.bearing = this._map.transform.bearing + e2.ac(t5.amount, -179, 179), Aa2(s22, t5);
+                  }
+                  if (i22.pitch) {
+                    const t5 = Ra2(i22.pitch, a22, Da2);
+                    s22.pitch = this._map.transform.pitch + t5.amount, Aa2(s22, t5);
+                  }
+                  if (s22.zoom || s22.bearing) {
+                    const t5 = void 0 === i22.pinchAround ? i22.around : i22.pinchAround;
+                    s22.around = t5 ? this._map.unproject(t5) : this._map.getCenter();
+                  }
+                  return this.clear(), e2.e(s22, { noMoveStart: true });
+                }
+              }
+              function Aa2(t42, e22) {
+                (!t42.duration || t42.duration < e22.duration) && (t42.duration = e22.duration, t42.easing = e22.easing);
+              }
+              function Ra2(t42, i22, a22) {
+                const { maxSpeed: s22, linearity: o22, deceleration: r22 } = a22, n22 = e2.ac(t42 * o22 / (i22 / 1e3), -s22, s22), l22 = Math.abs(n22) / (r22 * o22);
+                return { easing: a22.easing, duration: 1e3 * l22, amount: n22 * (l22 / 2) };
+              }
+              class ka2 extends e2.k {
+                preventDefault() {
+                  this._defaultPrevented = true;
+                }
+                get defaultPrevented() {
+                  return this._defaultPrevented;
+                }
+                constructor(t42, i22, a22, s22 = {}) {
+                  const o22 = r2.mousePos(i22.getCanvas(), a22), n22 = i22.unproject(o22);
+                  super(t42, e2.e({ point: o22, lngLat: n22, originalEvent: a22 }, s22)), this._defaultPrevented = false, this.target = i22;
+                }
+              }
+              class La2 extends e2.k {
+                preventDefault() {
+                  this._defaultPrevented = true;
+                }
+                get defaultPrevented() {
+                  return this._defaultPrevented;
+                }
+                constructor(t42, i22, a22) {
+                  const s22 = "touchend" === t42 ? a22.changedTouches : a22.touches, o22 = r2.touchPos(i22.getCanvasContainer(), s22), n22 = o22.map((t5) => i22.unproject(t5)), l22 = o22.reduce((t5, e22, i3, a3) => t5.add(e22.div(a3.length)), new e2.P(0, 0));
+                  super(t42, { points: o22, point: l22, lngLats: n22, lngLat: i22.unproject(l22), originalEvent: a22 }), this._defaultPrevented = false;
+                }
+              }
+              class Fa2 extends e2.k {
+                preventDefault() {
+                  this._defaultPrevented = true;
+                }
+                get defaultPrevented() {
+                  return this._defaultPrevented;
+                }
+                constructor(t42, e22, i22) {
+                  super(t42, { originalEvent: i22 }), this._defaultPrevented = false;
+                }
+              }
+              class Ba2 {
+                constructor(t42, e22) {
+                  this._map = t42, this._clickTolerance = e22.clickTolerance;
+                }
+                reset() {
+                  delete this._mousedownPos;
+                }
+                wheel(t42) {
+                  return this._firePreventable(new Fa2(t42.type, this._map, t42));
+                }
+                mousedown(t42, e22) {
+                  return this._mousedownPos = e22, this._firePreventable(new ka2(t42.type, this._map, t42));
+                }
+                mouseup(t42) {
+                  this._map.fire(new ka2(t42.type, this._map, t42));
+                }
+                click(t42, e22) {
+                  this._mousedownPos && this._mousedownPos.dist(e22) >= this._clickTolerance || this._map.fire(new ka2(t42.type, this._map, t42));
+                }
+                dblclick(t42) {
+                  return this._firePreventable(new ka2(t42.type, this._map, t42));
+                }
+                mouseover(t42) {
+                  this._map.fire(new ka2(t42.type, this._map, t42));
+                }
+                mouseout(t42) {
+                  this._map.fire(new ka2(t42.type, this._map, t42));
+                }
+                touchstart(t42) {
+                  return this._firePreventable(new La2(t42.type, this._map, t42));
+                }
+                touchmove(t42) {
+                  this._map.fire(new La2(t42.type, this._map, t42));
+                }
+                touchend(t42) {
+                  this._map.fire(new La2(t42.type, this._map, t42));
+                }
+                touchcancel(t42) {
+                  this._map.fire(new La2(t42.type, this._map, t42));
+                }
+                _firePreventable(t42) {
+                  if (this._map.fire(t42), t42.defaultPrevented) return {};
+                }
+                isEnabled() {
+                  return true;
+                }
+                isActive() {
+                  return false;
+                }
+                enable() {
+                }
+                disable() {
+                }
+              }
+              class Oa2 {
+                constructor(t42) {
+                  this._map = t42;
+                }
+                reset() {
+                  this._delayContextMenu = false, this._ignoreContextMenu = true, delete this._contextMenuEvent;
+                }
+                mousemove(t42) {
+                  this._map.fire(new ka2(t42.type, this._map, t42));
+                }
+                mousedown() {
+                  this._delayContextMenu = true, this._ignoreContextMenu = false;
+                }
+                mouseup() {
+                  this._delayContextMenu = false, this._contextMenuEvent && (this._map.fire(new ka2("contextmenu", this._map, this._contextMenuEvent)), delete this._contextMenuEvent);
+                }
+                contextmenu(t42) {
+                  this._delayContextMenu ? this._contextMenuEvent = t42 : this._ignoreContextMenu || this._map.fire(new ka2(t42.type, this._map, t42)), this._map.listens("contextmenu") && t42.preventDefault();
+                }
+                isEnabled() {
+                  return true;
+                }
+                isActive() {
+                  return false;
+                }
+                enable() {
+                }
+                disable() {
+                }
+              }
+              class Na2 {
+                constructor(t42) {
+                  this._map = t42;
+                }
+                get transform() {
+                  return this._map._requestedCameraState || this._map.transform;
+                }
+                get center() {
+                  return { lng: this.transform.center.lng, lat: this.transform.center.lat };
+                }
+                get zoom() {
+                  return this.transform.zoom;
+                }
+                get pitch() {
+                  return this.transform.pitch;
+                }
+                get bearing() {
+                  return this.transform.bearing;
+                }
+                unproject(t42) {
+                  return this.transform.pointLocation(e2.P.convert(t42), this._map.terrain);
+                }
+              }
+              class Ua2 {
+                constructor(t42, e22) {
+                  this._map = t42, this._tr = new Na2(t42), this._el = t42.getCanvasContainer(), this._container = t42.getContainer(), this._clickTolerance = e22.clickTolerance || 1;
+                }
+                isEnabled() {
+                  return !!this._enabled;
+                }
+                isActive() {
+                  return !!this._active;
+                }
+                enable() {
+                  this.isEnabled() || (this._enabled = true);
+                }
+                disable() {
+                  this.isEnabled() && (this._enabled = false);
+                }
+                mousedown(t42, e22) {
+                  this.isEnabled() && t42.shiftKey && 0 === t42.button && (r2.disableDrag(), this._startPos = this._lastPos = e22, this._active = true);
+                }
+                mousemoveWindow(t42, e22) {
+                  if (!this._active) return;
+                  const i22 = e22;
+                  if (this._lastPos.equals(i22) || !this._box && i22.dist(this._startPos) < this._clickTolerance) return;
+                  const a22 = this._startPos;
+                  this._lastPos = i22, this._box || (this._box = r2.create("div", "maplibregl-boxzoom", this._container), this._container.classList.add("maplibregl-crosshair"), this._fireEvent("boxzoomstart", t42));
+                  const s22 = Math.min(a22.x, i22.x), o22 = Math.max(a22.x, i22.x), n22 = Math.min(a22.y, i22.y), l22 = Math.max(a22.y, i22.y);
+                  r2.setTransform(this._box, `translate(${s22}px,${n22}px)`), this._box.style.width = o22 - s22 + "px", this._box.style.height = l22 - n22 + "px";
+                }
+                mouseupWindow(t42, i22) {
+                  if (!this._active) return;
+                  if (0 !== t42.button) return;
+                  const a22 = this._startPos, s22 = i22;
+                  if (this.reset(), r2.suppressClick(), a22.x !== s22.x || a22.y !== s22.y) return this._map.fire(new e2.k("boxzoomend", { originalEvent: t42 })), { cameraAnimation: (t5) => t5.fitScreenCoordinates(a22, s22, this._tr.bearing, { linear: true }) };
+                  this._fireEvent("boxzoomcancel", t42);
+                }
+                keydown(t42) {
+                  this._active && 27 === t42.keyCode && (this.reset(), this._fireEvent("boxzoomcancel", t42));
+                }
+                reset() {
+                  this._active = false, this._container.classList.remove("maplibregl-crosshair"), this._box && (r2.remove(this._box), this._box = null), r2.enableDrag(), delete this._startPos, delete this._lastPos;
+                }
+                _fireEvent(t42, i22) {
+                  return this._map.fire(new e2.k(t42, { originalEvent: i22 }));
+                }
+              }
+              function ja2(t42, e22) {
+                if (t42.length !== e22.length) throw new Error(`The number of touches and points are not equal - touches ${t42.length}, points ${e22.length}`);
+                const i22 = {};
+                for (let a22 = 0; a22 < t42.length; a22++) i22[t42[a22].identifier] = e22[a22];
+                return i22;
+              }
+              class Za2 {
+                constructor(t42) {
+                  this.reset(), this.numTouches = t42.numTouches;
+                }
+                reset() {
+                  delete this.centroid, delete this.startTime, delete this.touches, this.aborted = false;
+                }
+                touchstart(t42, i22, a22) {
+                  (this.centroid || a22.length > this.numTouches) && (this.aborted = true), this.aborted || (void 0 === this.startTime && (this.startTime = t42.timeStamp), a22.length === this.numTouches && (this.centroid = function(t5) {
+                    const i3 = new e2.P(0, 0);
+                    for (const e22 of t5) i3._add(e22);
+                    return i3.div(t5.length);
+                  }(i22), this.touches = ja2(a22, i22)));
+                }
+                touchmove(t42, e22, i22) {
+                  if (this.aborted || !this.centroid) return;
+                  const a22 = ja2(i22, e22);
+                  for (const t5 in this.touches) {
+                    const e3 = a22[t5];
+                    (!e3 || e3.dist(this.touches[t5]) > 30) && (this.aborted = true);
+                  }
+                }
+                touchend(t42, e22, i22) {
+                  if ((!this.centroid || t42.timeStamp - this.startTime > 500) && (this.aborted = true), 0 === i22.length) {
+                    const t5 = !this.aborted && this.centroid;
+                    if (this.reset(), t5) return t5;
+                  }
+                }
+              }
+              class qa2 {
+                constructor(t42) {
+                  this.singleTap = new Za2(t42), this.numTaps = t42.numTaps, this.reset();
+                }
+                reset() {
+                  this.lastTime = 1 / 0, delete this.lastTap, this.count = 0, this.singleTap.reset();
+                }
+                touchstart(t42, e22, i22) {
+                  this.singleTap.touchstart(t42, e22, i22);
+                }
+                touchmove(t42, e22, i22) {
+                  this.singleTap.touchmove(t42, e22, i22);
+                }
+                touchend(t42, e22, i22) {
+                  const a22 = this.singleTap.touchend(t42, e22, i22);
+                  if (a22) {
+                    const e3 = t42.timeStamp - this.lastTime < 500, i3 = !this.lastTap || this.lastTap.dist(a22) < 30;
+                    if (e3 && i3 || this.reset(), this.count++, this.lastTime = t42.timeStamp, this.lastTap = a22, this.count === this.numTaps) return this.reset(), a22;
+                  }
+                }
+              }
+              class Va2 {
+                constructor(t42) {
+                  this._tr = new Na2(t42), this._zoomIn = new qa2({ numTouches: 1, numTaps: 2 }), this._zoomOut = new qa2({ numTouches: 2, numTaps: 1 }), this.reset();
+                }
+                reset() {
+                  this._active = false, this._zoomIn.reset(), this._zoomOut.reset();
+                }
+                touchstart(t42, e22, i22) {
+                  this._zoomIn.touchstart(t42, e22, i22), this._zoomOut.touchstart(t42, e22, i22);
+                }
+                touchmove(t42, e22, i22) {
+                  this._zoomIn.touchmove(t42, e22, i22), this._zoomOut.touchmove(t42, e22, i22);
+                }
+                touchend(t42, e22, i22) {
+                  const a22 = this._zoomIn.touchend(t42, e22, i22), s22 = this._zoomOut.touchend(t42, e22, i22), o22 = this._tr;
+                  return a22 ? (this._active = true, t42.preventDefault(), setTimeout(() => this.reset(), 0), { cameraAnimation: (e3) => e3.easeTo({ duration: 300, zoom: o22.zoom + 1, around: o22.unproject(a22) }, { originalEvent: t42 }) }) : s22 ? (this._active = true, t42.preventDefault(), setTimeout(() => this.reset(), 0), { cameraAnimation: (e3) => e3.easeTo({ duration: 300, zoom: o22.zoom - 1, around: o22.unproject(s22) }, { originalEvent: t42 }) }) : void 0;
+                }
+                touchcancel() {
+                  this.reset();
+                }
+                enable() {
+                  this._enabled = true;
+                }
+                disable() {
+                  this._enabled = false, this.reset();
+                }
+                isEnabled() {
+                  return this._enabled;
+                }
+                isActive() {
+                  return this._active;
+                }
+              }
+              class Ga2 {
+                constructor(t42) {
+                  this._enabled = !!t42.enable, this._moveStateManager = t42.moveStateManager, this._clickTolerance = t42.clickTolerance || 1, this._moveFunction = t42.move, this._activateOnStart = !!t42.activateOnStart, t42.assignEvents(this), this.reset();
+                }
+                reset(t42) {
+                  this._active = false, this._moved = false, delete this._lastPoint, this._moveStateManager.endMove(t42);
+                }
+                _move(...t42) {
+                  const e22 = this._moveFunction(...t42);
+                  if (e22.bearingDelta || e22.pitchDelta || e22.around || e22.panDelta) return this._active = true, e22;
+                }
+                dragStart(t42, e22) {
+                  this.isEnabled() && !this._lastPoint && this._moveStateManager.isValidStartEvent(t42) && (this._moveStateManager.startMove(t42), this._lastPoint = e22.length ? e22[0] : e22, this._activateOnStart && this._lastPoint && (this._active = true));
+                }
+                dragMove(t42, e22) {
+                  if (!this.isEnabled()) return;
+                  const i22 = this._lastPoint;
+                  if (!i22) return;
+                  if (t42.preventDefault(), !this._moveStateManager.isValidMoveEvent(t42)) return void this.reset(t42);
+                  const a22 = e22.length ? e22[0] : e22;
+                  return !this._moved && a22.dist(i22) < this._clickTolerance ? void 0 : (this._moved = true, this._lastPoint = a22, this._move(i22, a22));
+                }
+                dragEnd(t42) {
+                  this.isEnabled() && this._lastPoint && this._moveStateManager.isValidEndEvent(t42) && (this._moved && r2.suppressClick(), this.reset(t42));
+                }
+                enable() {
+                  this._enabled = true;
+                }
+                disable() {
+                  this._enabled = false, this.reset();
+                }
+                isEnabled() {
+                  return this._enabled;
+                }
+                isActive() {
+                  return this._active;
+                }
+                getClickTolerance() {
+                  return this._clickTolerance;
+                }
+              }
+              const Ha2 = { 0: 1, 2: 2 };
+              class Wa2 {
+                constructor(t42) {
+                  this._correctEvent = t42.checkCorrectEvent;
+                }
+                startMove(t42) {
+                  const e22 = r2.mouseButton(t42);
+                  this._eventButton = e22;
+                }
+                endMove(t42) {
+                  delete this._eventButton;
+                }
+                isValidStartEvent(t42) {
+                  return this._correctEvent(t42);
+                }
+                isValidMoveEvent(t42) {
+                  return !function(t5, e22) {
+                    const i22 = Ha2[e22];
+                    return void 0 === t5.buttons || (t5.buttons & i22) !== i22;
+                  }(t42, this._eventButton);
+                }
+                isValidEndEvent(t42) {
+                  return r2.mouseButton(t42) === this._eventButton;
+                }
+              }
+              class $a {
+                constructor() {
+                  this._firstTouch = void 0;
+                }
+                _isOneFingerTouch(t42) {
+                  return 1 === t42.targetTouches.length;
+                }
+                _isSameTouchEvent(t42) {
+                  return t42.targetTouches[0].identifier === this._firstTouch;
+                }
+                startMove(t42) {
+                  this._firstTouch = t42.targetTouches[0].identifier;
+                }
+                endMove(t42) {
+                  delete this._firstTouch;
+                }
+                isValidStartEvent(t42) {
+                  return this._isOneFingerTouch(t42);
+                }
+                isValidMoveEvent(t42) {
+                  return this._isOneFingerTouch(t42) && this._isSameTouchEvent(t42);
+                }
+                isValidEndEvent(t42) {
+                  return this._isOneFingerTouch(t42) && this._isSameTouchEvent(t42);
+                }
+              }
+              const Xa2 = (t42) => {
+                t42.mousedown = t42.dragStart, t42.mousemoveWindow = t42.dragMove, t42.mouseup = t42.dragEnd, t42.contextmenu = (t5) => {
+                  t5.preventDefault();
+                };
+              }, Ka2 = ({ enable: t42, clickTolerance: e22, bearingDegreesPerPixelMoved: i22 = 0.8 }) => {
+                const a22 = new Wa2({ checkCorrectEvent: (t5) => 0 === r2.mouseButton(t5) && t5.ctrlKey || 2 === r2.mouseButton(t5) });
+                return new Ga2({ clickTolerance: e22, move: (t5, e3) => ({ bearingDelta: (e3.x - t5.x) * i22 }), moveStateManager: a22, enable: t42, assignEvents: Xa2 });
+              }, Ja2 = ({ enable: t42, clickTolerance: e22, pitchDegreesPerPixelMoved: i22 = -0.5 }) => {
+                const a22 = new Wa2({ checkCorrectEvent: (t5) => 0 === r2.mouseButton(t5) && t5.ctrlKey || 2 === r2.mouseButton(t5) });
+                return new Ga2({ clickTolerance: e22, move: (t5, e3) => ({ pitchDelta: (e3.y - t5.y) * i22 }), moveStateManager: a22, enable: t42, assignEvents: Xa2 });
+              };
+              class Ya2 {
+                constructor(t42, e22) {
+                  this._clickTolerance = t42.clickTolerance || 1, this._map = e22, this.reset();
+                }
+                reset() {
+                  this._active = false, this._touches = {}, this._sum = new e2.P(0, 0);
+                }
+                _shouldBePrevented(t42) {
+                  return t42 < (this._map.cooperativeGestures.isEnabled() ? 2 : 1);
+                }
+                touchstart(t42, e22, i22) {
+                  return this._calculateTransform(t42, e22, i22);
+                }
+                touchmove(t42, e22, i22) {
+                  if (this._active) {
+                    if (!this._shouldBePrevented(i22.length)) return t42.preventDefault(), this._calculateTransform(t42, e22, i22);
+                    this._map.cooperativeGestures.notifyGestureBlocked("touch_pan", t42);
+                  }
+                }
+                touchend(t42, e22, i22) {
+                  this._calculateTransform(t42, e22, i22), this._active && this._shouldBePrevented(i22.length) && this.reset();
+                }
+                touchcancel() {
+                  this.reset();
+                }
+                _calculateTransform(t42, i22, a22) {
+                  a22.length > 0 && (this._active = true);
+                  const s22 = ja2(a22, i22), o22 = new e2.P(0, 0), r22 = new e2.P(0, 0);
+                  let n22 = 0;
+                  for (const t5 in s22) {
+                    const e22 = s22[t5], i3 = this._touches[t5];
+                    i3 && (o22._add(e22), r22._add(e22.sub(i3)), n22++, s22[t5] = e22);
+                  }
+                  if (this._touches = s22, this._shouldBePrevented(n22) || !r22.mag()) return;
+                  const l22 = r22.div(n22);
+                  return this._sum._add(l22), this._sum.mag() < this._clickTolerance ? void 0 : { around: o22.div(n22), panDelta: l22 };
+                }
+                enable() {
+                  this._enabled = true;
+                }
+                disable() {
+                  this._enabled = false, this.reset();
+                }
+                isEnabled() {
+                  return this._enabled;
+                }
+                isActive() {
+                  return this._active;
+                }
+              }
+              class Qa2 {
+                constructor() {
+                  this.reset();
+                }
+                reset() {
+                  this._active = false, delete this._firstTwoTouches;
+                }
+                touchstart(t42, e22, i22) {
+                  this._firstTwoTouches || i22.length < 2 || (this._firstTwoTouches = [i22[0].identifier, i22[1].identifier], this._start([e22[0], e22[1]]));
+                }
+                touchmove(t42, e22, i22) {
+                  if (!this._firstTwoTouches) return;
+                  t42.preventDefault();
+                  const [a22, s22] = this._firstTwoTouches, o22 = ts(i22, e22, a22), r22 = ts(i22, e22, s22);
+                  if (!o22 || !r22) return;
+                  const n22 = this._aroundCenter ? null : o22.add(r22).div(2);
+                  return this._move([o22, r22], n22, t42);
+                }
+                touchend(t42, e22, i22) {
+                  if (!this._firstTwoTouches) return;
+                  const [a22, s22] = this._firstTwoTouches, o22 = ts(i22, e22, a22), n22 = ts(i22, e22, s22);
+                  o22 && n22 || (this._active && r2.suppressClick(), this.reset());
+                }
+                touchcancel() {
+                  this.reset();
+                }
+                enable(t42) {
+                  this._enabled = true, this._aroundCenter = !!t42 && "center" === t42.around;
+                }
+                disable() {
+                  this._enabled = false, this.reset();
+                }
+                isEnabled() {
+                  return !!this._enabled;
+                }
+                isActive() {
+                  return !!this._active;
+                }
+              }
+              function ts(t42, e22, i22) {
+                for (let a22 = 0; a22 < t42.length; a22++) if (t42[a22].identifier === i22) return e22[a22];
+              }
+              function es(t42, e22) {
+                return Math.log(t42 / e22) / Math.LN2;
+              }
+              class is extends Qa2 {
+                reset() {
+                  super.reset(), delete this._distance, delete this._startDistance;
+                }
+                _start(t42) {
+                  this._startDistance = this._distance = t42[0].dist(t42[1]);
+                }
+                _move(t42, e22) {
+                  const i22 = this._distance;
+                  if (this._distance = t42[0].dist(t42[1]), this._active || !(Math.abs(es(this._distance, this._startDistance)) < 0.1)) return this._active = true, { zoomDelta: es(this._distance, i22), pinchAround: e22 };
+                }
+              }
+              function as(t42, e22) {
+                return 180 * t42.angleWith(e22) / Math.PI;
+              }
+              class ss extends Qa2 {
+                reset() {
+                  super.reset(), delete this._minDiameter, delete this._startVector, delete this._vector;
+                }
+                _start(t42) {
+                  this._startVector = this._vector = t42[0].sub(t42[1]), this._minDiameter = t42[0].dist(t42[1]);
+                }
+                _move(t42, e22, i22) {
+                  const a22 = this._vector;
+                  if (this._vector = t42[0].sub(t42[1]), this._active || !this._isBelowThreshold(this._vector)) return this._active = true, { bearingDelta: as(this._vector, a22), pinchAround: e22 };
+                }
+                _isBelowThreshold(t42) {
+                  this._minDiameter = Math.min(this._minDiameter, t42.mag());
+                  const e22 = 25 / (Math.PI * this._minDiameter) * 360, i22 = as(t42, this._startVector);
+                  return Math.abs(i22) < e22;
+                }
+              }
+              function os(t42) {
+                return Math.abs(t42.y) > Math.abs(t42.x);
+              }
+              class rs extends Qa2 {
+                constructor(t42) {
+                  super(), this._currentTouchCount = 0, this._map = t42;
+                }
+                reset() {
+                  super.reset(), this._valid = void 0, delete this._firstMove, delete this._lastPoints;
+                }
+                touchstart(t42, e22, i22) {
+                  super.touchstart(t42, e22, i22), this._currentTouchCount = i22.length;
+                }
+                _start(t42) {
+                  this._lastPoints = t42, os(t42[0].sub(t42[1])) && (this._valid = false);
+                }
+                _move(t42, e22, i22) {
+                  if (this._map.cooperativeGestures.isEnabled() && this._currentTouchCount < 3) return;
+                  const a22 = t42[0].sub(this._lastPoints[0]), s22 = t42[1].sub(this._lastPoints[1]);
+                  return this._valid = this.gestureBeginsVertically(a22, s22, i22.timeStamp), this._valid ? (this._lastPoints = t42, this._active = true, { pitchDelta: (a22.y + s22.y) / 2 * -0.5 }) : void 0;
+                }
+                gestureBeginsVertically(t42, e22, i22) {
+                  if (void 0 !== this._valid) return this._valid;
+                  const a22 = t42.mag() >= 2, s22 = e22.mag() >= 2;
+                  if (!a22 && !s22) return;
+                  if (!a22 || !s22) return void 0 === this._firstMove && (this._firstMove = i22), i22 - this._firstMove < 100 && void 0;
+                  const o22 = t42.y > 0 == e22.y > 0;
+                  return os(t42) && os(e22) && o22;
+                }
+              }
+              const ns = { panStep: 100, bearingStep: 15, pitchStep: 10 };
+              class ls {
+                constructor(t42) {
+                  this._tr = new Na2(t42);
+                  const e22 = ns;
+                  this._panStep = e22.panStep, this._bearingStep = e22.bearingStep, this._pitchStep = e22.pitchStep, this._rotationDisabled = false;
+                }
+                reset() {
+                  this._active = false;
+                }
+                keydown(t42) {
+                  if (t42.altKey || t42.ctrlKey || t42.metaKey) return;
+                  let e22 = 0, i22 = 0, a22 = 0, s22 = 0, o22 = 0;
+                  switch (t42.keyCode) {
+                    case 61:
+                    case 107:
+                    case 171:
+                    case 187:
+                      e22 = 1;
+                      break;
+                    case 189:
+                    case 109:
+                    case 173:
+                      e22 = -1;
+                      break;
+                    case 37:
+                      t42.shiftKey ? i22 = -1 : (t42.preventDefault(), s22 = -1);
+                      break;
+                    case 39:
+                      t42.shiftKey ? i22 = 1 : (t42.preventDefault(), s22 = 1);
+                      break;
+                    case 38:
+                      t42.shiftKey ? a22 = 1 : (t42.preventDefault(), o22 = -1);
+                      break;
+                    case 40:
+                      t42.shiftKey ? a22 = -1 : (t42.preventDefault(), o22 = 1);
+                      break;
+                    default:
+                      return;
+                  }
+                  return this._rotationDisabled && (i22 = 0, a22 = 0), { cameraAnimation: (r22) => {
+                    const n22 = this._tr;
+                    r22.easeTo({ duration: 300, easeId: "keyboardHandler", easing: hs, zoom: e22 ? Math.round(n22.zoom) + e22 * (t42.shiftKey ? 2 : 1) : n22.zoom, bearing: n22.bearing + i22 * this._bearingStep, pitch: n22.pitch + a22 * this._pitchStep, offset: [-s22 * this._panStep, -o22 * this._panStep], center: n22.center }, { originalEvent: t42 });
+                  } };
+                }
+                enable() {
+                  this._enabled = true;
+                }
+                disable() {
+                  this._enabled = false, this.reset();
+                }
+                isEnabled() {
+                  return this._enabled;
+                }
+                isActive() {
+                  return this._active;
+                }
+                disableRotation() {
+                  this._rotationDisabled = true;
+                }
+                enableRotation() {
+                  this._rotationDisabled = false;
+                }
+              }
+              function hs(t42) {
+                return t42 * (2 - t42);
+              }
+              const cs = 4.000244140625;
+              class us {
+                constructor(t42, e22) {
+                  this._onTimeout = (t5) => {
+                    this._type = "wheel", this._delta -= this._lastValue, this._active || this._start(t5);
+                  }, this._map = t42, this._tr = new Na2(t42), this._triggerRenderFrame = e22, this._delta = 0, this._defaultZoomRate = 0.01, this._wheelZoomRate = 0.0022222222222222222;
+                }
+                setZoomRate(t42) {
+                  this._defaultZoomRate = t42;
+                }
+                setWheelZoomRate(t42) {
+                  this._wheelZoomRate = t42;
+                }
+                isEnabled() {
+                  return !!this._enabled;
+                }
+                isActive() {
+                  return !!this._active || void 0 !== this._finishTimeout;
+                }
+                isZooming() {
+                  return !!this._zooming;
+                }
+                enable(t42) {
+                  this.isEnabled() || (this._enabled = true, this._aroundCenter = !!t42 && "center" === t42.around);
+                }
+                disable() {
+                  this.isEnabled() && (this._enabled = false);
+                }
+                _shouldBePrevented(t42) {
+                  return !!this._map.cooperativeGestures.isEnabled() && !(t42.ctrlKey || this._map.cooperativeGestures.isBypassed(t42));
+                }
+                wheel(t42) {
+                  if (!this.isEnabled()) return;
+                  if (this._shouldBePrevented(t42)) return void this._map.cooperativeGestures.notifyGestureBlocked("wheel_zoom", t42);
+                  let e22 = t42.deltaMode === WheelEvent.DOM_DELTA_LINE ? 40 * t42.deltaY : t42.deltaY;
+                  const i22 = o2.now(), a22 = i22 - (this._lastWheelEventTime || 0);
+                  this._lastWheelEventTime = i22, 0 !== e22 && e22 % cs == 0 ? this._type = "wheel" : 0 !== e22 && Math.abs(e22) < 4 ? this._type = "trackpad" : a22 > 400 ? (this._type = null, this._lastValue = e22, this._timeout = setTimeout(this._onTimeout, 40, t42)) : this._type || (this._type = Math.abs(a22 * e22) < 200 ? "trackpad" : "wheel", this._timeout && (clearTimeout(this._timeout), this._timeout = null, e22 += this._lastValue)), t42.shiftKey && e22 && (e22 /= 4), this._type && (this._lastWheelEvent = t42, this._delta -= e22, this._active || this._start(t42)), t42.preventDefault();
+                }
+                _start(t42) {
+                  if (!this._delta) return;
+                  this._frameId && (this._frameId = null), this._active = true, this.isZooming() || (this._zooming = true), this._finishTimeout && (clearTimeout(this._finishTimeout), delete this._finishTimeout);
+                  const i22 = r2.mousePos(this._map.getCanvas(), t42), a22 = this._tr;
+                  this._around = i22.y > a22.transform.height / 2 - a22.transform.getHorizon() ? e2.N.convert(this._aroundCenter ? a22.center : a22.unproject(i22)) : e2.N.convert(a22.center), this._aroundPoint = a22.transform.locationPoint(this._around), this._frameId || (this._frameId = true, this._triggerRenderFrame());
+                }
+                renderFrame() {
+                  if (!this._frameId) return;
+                  if (this._frameId = null, !this.isActive()) return;
+                  const t42 = this._tr.transform;
+                  if (0 !== this._delta) {
+                    const e22 = "wheel" === this._type && Math.abs(this._delta) > cs ? this._wheelZoomRate : this._defaultZoomRate;
+                    let i3 = 2 / (1 + Math.exp(-Math.abs(this._delta * e22)));
+                    this._delta < 0 && 0 !== i3 && (i3 = 1 / i3);
+                    const a3 = "number" == typeof this._targetZoom ? t42.zoomScale(this._targetZoom) : t42.scale;
+                    this._targetZoom = Math.min(t42.maxZoom, Math.max(t42.minZoom, t42.scaleZoom(a3 * i3))), "wheel" === this._type && (this._startZoom = t42.zoom, this._easing = this._smoothOutEasing(200)), this._delta = 0;
+                  }
+                  const i22 = "number" == typeof this._targetZoom ? this._targetZoom : t42.zoom, a22 = this._startZoom, s22 = this._easing;
+                  let r22, n22 = false;
+                  const l22 = o2.now() - this._lastWheelEventTime;
+                  if ("wheel" === this._type && a22 && s22 && l22) {
+                    const t5 = Math.min(l22 / 200, 1), o22 = s22(t5);
+                    r22 = e2.y.number(a22, i22, o22), t5 < 1 ? this._frameId || (this._frameId = true) : n22 = true;
+                  } else r22 = i22, n22 = true;
+                  return this._active = true, n22 && (this._active = false, this._finishTimeout = setTimeout(() => {
+                    this._zooming = false, this._triggerRenderFrame(), delete this._targetZoom, delete this._finishTimeout;
+                  }, 200)), { noInertia: true, needsRenderFrame: !n22, zoomDelta: r22 - t42.zoom, around: this._aroundPoint, originalEvent: this._lastWheelEvent };
+                }
+                _smoothOutEasing(t42) {
+                  let i22 = e2.b9;
+                  if (this._prevEase) {
+                    const t5 = this._prevEase, a22 = (o2.now() - t5.start) / t5.duration, s22 = t5.easing(a22 + 0.01) - t5.easing(a22), r22 = 0.27 / Math.sqrt(s22 * s22 + 1e-4) * 0.01, n22 = Math.sqrt(0.0729 - r22 * r22);
+                    i22 = e2.b8(r22, n22, 0.25, 1);
+                  }
+                  return this._prevEase = { start: o2.now(), duration: t42, easing: i22 }, i22;
+                }
+                reset() {
+                  this._active = false, this._zooming = false, delete this._targetZoom, this._finishTimeout && (clearTimeout(this._finishTimeout), delete this._finishTimeout);
+                }
+              }
+              class ds {
+                constructor(t42, e22) {
+                  this._clickZoom = t42, this._tapZoom = e22;
+                }
+                enable() {
+                  this._clickZoom.enable(), this._tapZoom.enable();
+                }
+                disable() {
+                  this._clickZoom.disable(), this._tapZoom.disable();
+                }
+                isEnabled() {
+                  return this._clickZoom.isEnabled() && this._tapZoom.isEnabled();
+                }
+                isActive() {
+                  return this._clickZoom.isActive() || this._tapZoom.isActive();
+                }
+              }
+              class _s2 {
+                constructor(t42) {
+                  this._tr = new Na2(t42), this.reset();
+                }
+                reset() {
+                  this._active = false;
+                }
+                dblclick(t42, e22) {
+                  return t42.preventDefault(), { cameraAnimation: (i22) => {
+                    i22.easeTo({ duration: 300, zoom: this._tr.zoom + (t42.shiftKey ? -1 : 1), around: this._tr.unproject(e22) }, { originalEvent: t42 });
+                  } };
+                }
+                enable() {
+                  this._enabled = true;
+                }
+                disable() {
+                  this._enabled = false, this.reset();
+                }
+                isEnabled() {
+                  return this._enabled;
+                }
+                isActive() {
+                  return this._active;
+                }
+              }
+              class ps {
+                constructor() {
+                  this._tap = new qa2({ numTouches: 1, numTaps: 1 }), this.reset();
+                }
+                reset() {
+                  this._active = false, delete this._swipePoint, delete this._swipeTouch, delete this._tapTime, delete this._tapPoint, this._tap.reset();
+                }
+                touchstart(t42, e22, i22) {
+                  if (!this._swipePoint) if (this._tapTime) {
+                    const a22 = e22[0], s22 = t42.timeStamp - this._tapTime < 500, o22 = this._tapPoint.dist(a22) < 30;
+                    s22 && o22 ? i22.length > 0 && (this._swipePoint = a22, this._swipeTouch = i22[0].identifier) : this.reset();
+                  } else this._tap.touchstart(t42, e22, i22);
+                }
+                touchmove(t42, e22, i22) {
+                  if (this._tapTime) {
+                    if (this._swipePoint) {
+                      if (i22[0].identifier !== this._swipeTouch) return;
+                      const a22 = e22[0], s22 = a22.y - this._swipePoint.y;
+                      return this._swipePoint = a22, t42.preventDefault(), this._active = true, { zoomDelta: s22 / 128 };
+                    }
+                  } else this._tap.touchmove(t42, e22, i22);
+                }
+                touchend(t42, e22, i22) {
+                  if (this._tapTime) this._swipePoint && 0 === i22.length && this.reset();
+                  else {
+                    const a22 = this._tap.touchend(t42, e22, i22);
+                    a22 && (this._tapTime = t42.timeStamp, this._tapPoint = a22);
+                  }
+                }
+                touchcancel() {
+                  this.reset();
+                }
+                enable() {
+                  this._enabled = true;
+                }
+                disable() {
+                  this._enabled = false, this.reset();
+                }
+                isEnabled() {
+                  return this._enabled;
+                }
+                isActive() {
+                  return this._active;
+                }
+              }
+              class ms {
+                constructor(t42, e22, i22) {
+                  this._el = t42, this._mousePan = e22, this._touchPan = i22;
+                }
+                enable(t42) {
+                  this._inertiaOptions = t42 || {}, this._mousePan.enable(), this._touchPan.enable(), this._el.classList.add("maplibregl-touch-drag-pan");
+                }
+                disable() {
+                  this._mousePan.disable(), this._touchPan.disable(), this._el.classList.remove("maplibregl-touch-drag-pan");
+                }
+                isEnabled() {
+                  return this._mousePan.isEnabled() && this._touchPan.isEnabled();
+                }
+                isActive() {
+                  return this._mousePan.isActive() || this._touchPan.isActive();
+                }
+              }
+              class fs2 {
+                constructor(t42, e22, i22) {
+                  this._pitchWithRotate = t42.pitchWithRotate, this._mouseRotate = e22, this._mousePitch = i22;
+                }
+                enable() {
+                  this._mouseRotate.enable(), this._pitchWithRotate && this._mousePitch.enable();
+                }
+                disable() {
+                  this._mouseRotate.disable(), this._mousePitch.disable();
+                }
+                isEnabled() {
+                  return this._mouseRotate.isEnabled() && (!this._pitchWithRotate || this._mousePitch.isEnabled());
+                }
+                isActive() {
+                  return this._mouseRotate.isActive() || this._mousePitch.isActive();
+                }
+              }
+              class gs {
+                constructor(t42, e22, i22, a22) {
+                  this._el = t42, this._touchZoom = e22, this._touchRotate = i22, this._tapDragZoom = a22, this._rotationDisabled = false, this._enabled = true;
+                }
+                enable(t42) {
+                  this._touchZoom.enable(t42), this._rotationDisabled || this._touchRotate.enable(t42), this._tapDragZoom.enable(), this._el.classList.add("maplibregl-touch-zoom-rotate");
+                }
+                disable() {
+                  this._touchZoom.disable(), this._touchRotate.disable(), this._tapDragZoom.disable(), this._el.classList.remove("maplibregl-touch-zoom-rotate");
+                }
+                isEnabled() {
+                  return this._touchZoom.isEnabled() && (this._rotationDisabled || this._touchRotate.isEnabled()) && this._tapDragZoom.isEnabled();
+                }
+                isActive() {
+                  return this._touchZoom.isActive() || this._touchRotate.isActive() || this._tapDragZoom.isActive();
+                }
+                disableRotation() {
+                  this._rotationDisabled = true, this._touchRotate.disable();
+                }
+                enableRotation() {
+                  this._rotationDisabled = false, this._touchZoom.isEnabled() && this._touchRotate.enable();
+                }
+              }
+              class vs2 {
+                constructor(t42, e22) {
+                  this._bypassKey = -1 !== navigator.userAgent.indexOf("Mac") ? "metaKey" : "ctrlKey", this._map = t42, this._options = e22, this._enabled = false;
+                }
+                isActive() {
+                  return false;
+                }
+                reset() {
+                }
+                _setupUI() {
+                  if (this._container) return;
+                  const t42 = this._map.getCanvasContainer();
+                  t42.classList.add("maplibregl-cooperative-gestures"), this._container = r2.create("div", "maplibregl-cooperative-gesture-screen", t42);
+                  let e22 = this._map._getUIString("CooperativeGesturesHandler.WindowsHelpText");
+                  "metaKey" === this._bypassKey && (e22 = this._map._getUIString("CooperativeGesturesHandler.MacHelpText"));
+                  const i22 = this._map._getUIString("CooperativeGesturesHandler.MobileHelpText"), a22 = document.createElement("div");
+                  a22.className = "maplibregl-desktop-message", a22.textContent = e22, this._container.appendChild(a22);
+                  const s22 = document.createElement("div");
+                  s22.className = "maplibregl-mobile-message", s22.textContent = i22, this._container.appendChild(s22), this._container.setAttribute("aria-hidden", "true");
+                }
+                _destroyUI() {
+                  this._container && (r2.remove(this._container), this._map.getCanvasContainer().classList.remove("maplibregl-cooperative-gestures")), delete this._container;
+                }
+                enable() {
+                  this._setupUI(), this._enabled = true;
+                }
+                disable() {
+                  this._enabled = false, this._destroyUI();
+                }
+                isEnabled() {
+                  return this._enabled;
+                }
+                isBypassed(t42) {
+                  return t42[this._bypassKey];
+                }
+                notifyGestureBlocked(t42, i22) {
+                  this._enabled && (this._map.fire(new e2.k("cooperativegestureprevented", { gestureType: t42, originalEvent: i22 })), this._container.classList.add("maplibregl-show"), setTimeout(() => {
+                    this._container.classList.remove("maplibregl-show");
+                  }, 100));
+                }
+              }
+              const xs = (t42) => t42.zoom || t42.drag || t42.pitch || t42.rotate;
+              class ys extends e2.k {
+              }
+              function bs(t42) {
+                return t42.panDelta && t42.panDelta.mag() || t42.zoomDelta || t42.bearingDelta || t42.pitchDelta;
+              }
+              class ws {
+                constructor(t42, e22) {
+                  this.handleWindowEvent = (t5) => {
+                    this.handleEvent(t5, `${t5.type}Window`);
+                  }, this.handleEvent = (t5, e3) => {
+                    if ("blur" === t5.type) return void this.stop(true);
+                    this._updatingCamera = true;
+                    const i3 = "renderFrame" === t5.type ? void 0 : t5, a22 = { needsRenderFrame: false }, s22 = {}, o22 = {}, n22 = t5.touches, l22 = n22 ? this._getMapTouches(n22) : void 0, h22 = l22 ? r2.touchPos(this._map.getCanvas(), l22) : r2.mousePos(this._map.getCanvas(), t5);
+                    for (const { handlerName: r22, handler: n3, allowed: c3 } of this._handlers) {
+                      if (!n3.isEnabled()) continue;
+                      let u3;
+                      this._blockedByActive(o22, c3, r22) ? n3.reset() : n3[e3 || t5.type] && (u3 = n3[e3 || t5.type](t5, h22, l22), this.mergeHandlerResult(a22, s22, u3, r22, i3), u3 && u3.needsRenderFrame && this._triggerRenderFrame()), (u3 || n3.isActive()) && (o22[r22] = n3);
+                    }
+                    const c22 = {};
+                    for (const t6 in this._previousActiveHandlers) o22[t6] || (c22[t6] = i3);
+                    this._previousActiveHandlers = o22, (Object.keys(c22).length || bs(a22)) && (this._changes.push([a22, s22, c22]), this._triggerRenderFrame()), (Object.keys(o22).length || bs(a22)) && this._map._stop(true), this._updatingCamera = false;
+                    const { cameraAnimation: u22 } = a22;
+                    u22 && (this._inertia.clear(), this._fireEvents({}, {}, true), this._changes = [], u22(this._map));
+                  }, this._map = t42, this._el = this._map.getCanvasContainer(), this._handlers = [], this._handlersById = {}, this._changes = [], this._inertia = new Ma2(t42), this._bearingSnap = e22.bearingSnap, this._previousActiveHandlers = {}, this._eventsInProgress = {}, this._addDefaultHandlers(e22);
+                  const i22 = this._el;
+                  this._listeners = [[i22, "touchstart", { passive: true }], [i22, "touchmove", { passive: false }], [i22, "touchend", void 0], [i22, "touchcancel", void 0], [i22, "mousedown", void 0], [i22, "mousemove", void 0], [i22, "mouseup", void 0], [document, "mousemove", { capture: true }], [document, "mouseup", void 0], [i22, "mouseover", void 0], [i22, "mouseout", void 0], [i22, "dblclick", void 0], [i22, "click", void 0], [i22, "keydown", { capture: false }], [i22, "keyup", void 0], [i22, "wheel", { passive: false }], [i22, "contextmenu", void 0], [window, "blur", void 0]];
+                  for (const [t5, e3, i3] of this._listeners) r2.addEventListener(t5, e3, t5 === document ? this.handleWindowEvent : this.handleEvent, i3);
+                }
+                destroy() {
+                  for (const [t42, e22, i22] of this._listeners) r2.removeEventListener(t42, e22, t42 === document ? this.handleWindowEvent : this.handleEvent, i22);
+                }
+                _addDefaultHandlers(t42) {
+                  const e22 = this._map, i22 = e22.getCanvasContainer();
+                  this._add("mapEvent", new Ba2(e22, t42));
+                  const a22 = e22.boxZoom = new Ua2(e22, t42);
+                  this._add("boxZoom", a22), t42.interactive && t42.boxZoom && a22.enable();
+                  const s22 = e22.cooperativeGestures = new vs2(e22, t42.cooperativeGestures);
+                  this._add("cooperativeGestures", s22), t42.cooperativeGestures && s22.enable();
+                  const o22 = new Va2(e22), n22 = new _s2(e22);
+                  e22.doubleClickZoom = new ds(n22, o22), this._add("tapZoom", o22), this._add("clickZoom", n22), t42.interactive && t42.doubleClickZoom && e22.doubleClickZoom.enable();
+                  const l22 = new ps();
+                  this._add("tapDragZoom", l22);
+                  const h22 = e22.touchPitch = new rs(e22);
+                  this._add("touchPitch", h22), t42.interactive && t42.touchPitch && e22.touchPitch.enable(t42.touchPitch);
+                  const c22 = Ka2(t42), u22 = Ja2(t42);
+                  e22.dragRotate = new fs2(t42, c22, u22), this._add("mouseRotate", c22, ["mousePitch"]), this._add("mousePitch", u22, ["mouseRotate"]), t42.interactive && t42.dragRotate && e22.dragRotate.enable();
+                  const d22 = (({ enable: t5, clickTolerance: e3 }) => {
+                    const i3 = new Wa2({ checkCorrectEvent: (t6) => 0 === r2.mouseButton(t6) && !t6.ctrlKey });
+                    return new Ga2({ clickTolerance: e3, move: (t6, e4) => ({ around: e4, panDelta: e4.sub(t6) }), activateOnStart: true, moveStateManager: i3, enable: t5, assignEvents: Xa2 });
+                  })(t42), _22 = new Ya2(t42, e22);
+                  e22.dragPan = new ms(i22, d22, _22), this._add("mousePan", d22), this._add("touchPan", _22, ["touchZoom", "touchRotate"]), t42.interactive && t42.dragPan && e22.dragPan.enable(t42.dragPan);
+                  const p22 = new ss(), m22 = new is();
+                  e22.touchZoomRotate = new gs(i22, m22, p22, l22), this._add("touchRotate", p22, ["touchPan", "touchZoom"]), this._add("touchZoom", m22, ["touchPan", "touchRotate"]), t42.interactive && t42.touchZoomRotate && e22.touchZoomRotate.enable(t42.touchZoomRotate);
+                  const f22 = e22.scrollZoom = new us(e22, () => this._triggerRenderFrame());
+                  this._add("scrollZoom", f22, ["mousePan"]), t42.interactive && t42.scrollZoom && e22.scrollZoom.enable(t42.scrollZoom);
+                  const g22 = e22.keyboard = new ls(e22);
+                  this._add("keyboard", g22), t42.interactive && t42.keyboard && e22.keyboard.enable(), this._add("blockableMapEvent", new Oa2(e22));
+                }
+                _add(t42, e22, i22) {
+                  this._handlers.push({ handlerName: t42, handler: e22, allowed: i22 }), this._handlersById[t42] = e22;
+                }
+                stop(t42) {
+                  if (!this._updatingCamera) {
+                    for (const { handler: t5 } of this._handlers) t5.reset();
+                    this._inertia.clear(), this._fireEvents({}, {}, t42), this._changes = [];
+                  }
+                }
+                isActive() {
+                  for (const { handler: t42 } of this._handlers) if (t42.isActive()) return true;
+                  return false;
+                }
+                isZooming() {
+                  return !!this._eventsInProgress.zoom || this._map.scrollZoom.isZooming();
+                }
+                isRotating() {
+                  return !!this._eventsInProgress.rotate;
+                }
+                isMoving() {
+                  return Boolean(xs(this._eventsInProgress)) || this.isZooming();
+                }
+                _blockedByActive(t42, e22, i22) {
+                  for (const a22 in t42) if (a22 !== i22 && (!e22 || e22.indexOf(a22) < 0)) return true;
+                  return false;
+                }
+                _getMapTouches(t42) {
+                  const e22 = [];
+                  for (const i22 of t42) this._el.contains(i22.target) && e22.push(i22);
+                  return e22;
+                }
+                mergeHandlerResult(t42, i22, a22, s22, o22) {
+                  if (!a22) return;
+                  e2.e(t42, a22);
+                  const r22 = { handlerName: s22, originalEvent: a22.originalEvent || o22 };
+                  void 0 !== a22.zoomDelta && (i22.zoom = r22), void 0 !== a22.panDelta && (i22.drag = r22), void 0 !== a22.pitchDelta && (i22.pitch = r22), void 0 !== a22.bearingDelta && (i22.rotate = r22);
+                }
+                _applyChanges() {
+                  const t42 = {}, i22 = {}, a22 = {};
+                  for (const [s22, o22, r22] of this._changes) s22.panDelta && (t42.panDelta = (t42.panDelta || new e2.P(0, 0))._add(s22.panDelta)), s22.zoomDelta && (t42.zoomDelta = (t42.zoomDelta || 0) + s22.zoomDelta), s22.bearingDelta && (t42.bearingDelta = (t42.bearingDelta || 0) + s22.bearingDelta), s22.pitchDelta && (t42.pitchDelta = (t42.pitchDelta || 0) + s22.pitchDelta), void 0 !== s22.around && (t42.around = s22.around), void 0 !== s22.pinchAround && (t42.pinchAround = s22.pinchAround), s22.noInertia && (t42.noInertia = s22.noInertia), e2.e(i22, o22), e2.e(a22, r22);
+                  this._updateMapTransform(t42, i22, a22), this._changes = [];
+                }
+                _updateMapTransform(t42, e22, i22) {
+                  const a22 = this._map, s22 = a22._getTransformForUpdate(), o22 = a22.terrain;
+                  if (!(bs(t42) || o22 && this._terrainMovement)) return this._fireEvents(e22, i22, true);
+                  let { panDelta: r22, zoomDelta: n22, bearingDelta: l22, pitchDelta: h22, around: c22, pinchAround: u22 } = t42;
+                  void 0 !== u22 && (c22 = u22), a22._stop(true), c22 = c22 || a22.transform.centerPoint;
+                  const d22 = s22.pointLocation(r22 ? c22.sub(r22) : c22);
+                  l22 && (s22.bearing += l22), h22 && (s22.pitch += h22), n22 && (s22.zoom += n22), o22 ? this._terrainMovement || !e22.drag && !e22.zoom ? e22.drag && this._terrainMovement ? s22.center = s22.pointLocation(s22.centerPoint.sub(r22)) : s22.setLocationAtPoint(d22, c22) : (this._terrainMovement = true, this._map._elevationFreeze = true, s22.setLocationAtPoint(d22, c22)) : s22.setLocationAtPoint(d22, c22), a22._applyUpdatedTransform(s22), this._map._update(), t42.noInertia || this._inertia.record(t42), this._fireEvents(e22, i22, true);
+                }
+                _fireEvents(t42, i22, a22) {
+                  const s22 = xs(this._eventsInProgress), r22 = xs(t42), n22 = {};
+                  for (const e22 in t42) {
+                    const { originalEvent: i3 } = t42[e22];
+                    this._eventsInProgress[e22] || (n22[`${e22}start`] = i3), this._eventsInProgress[e22] = t42[e22];
+                  }
+                  !s22 && r22 && this._fireEvent("movestart", r22.originalEvent);
+                  for (const t5 in n22) this._fireEvent(t5, n22[t5]);
+                  r22 && this._fireEvent("move", r22.originalEvent);
+                  for (const e22 in t42) {
+                    const { originalEvent: i3 } = t42[e22];
+                    this._fireEvent(e22, i3);
+                  }
+                  const l22 = {};
+                  let h22;
+                  for (const t5 in this._eventsInProgress) {
+                    const { handlerName: e22, originalEvent: a3 } = this._eventsInProgress[t5];
+                    this._handlersById[e22].isActive() || (delete this._eventsInProgress[t5], h22 = i22[e22] || a3, l22[`${t5}end`] = h22);
+                  }
+                  for (const t5 in l22) this._fireEvent(t5, l22[t5]);
+                  const c22 = xs(this._eventsInProgress), u22 = (s22 || r22) && !c22;
+                  if (u22 && this._terrainMovement) {
+                    this._map._elevationFreeze = false, this._terrainMovement = false;
+                    const t5 = this._map._getTransformForUpdate();
+                    t5.recalculateZoom(this._map.terrain), this._map._applyUpdatedTransform(t5);
+                  }
+                  if (a22 && u22) {
+                    this._updatingCamera = true;
+                    const t5 = this._inertia._onMoveEnd(this._map.dragPan._inertiaOptions), i3 = (t6) => 0 !== t6 && -this._bearingSnap < t6 && t6 < this._bearingSnap;
+                    !t5 || !t5.essential && o2.prefersReducedMotion ? (this._map.fire(new e2.k("moveend", { originalEvent: h22 })), i3(this._map.getBearing()) && this._map.resetNorth()) : (i3(t5.bearing || this._map.getBearing()) && (t5.bearing = 0), t5.freezeElevation = true, this._map.easeTo(t5, { originalEvent: h22 })), this._updatingCamera = false;
+                  }
+                }
+                _fireEvent(t42, i22) {
+                  this._map.fire(new e2.k(t42, i22 ? { originalEvent: i22 } : {}));
+                }
+                _requestFrame() {
+                  return this._map.triggerRepaint(), this._map._renderTaskQueue.add((t42) => {
+                    delete this._frameId, this.handleEvent(new ys("renderFrame", { timeStamp: t42 })), this._applyChanges();
+                  });
+                }
+                _triggerRenderFrame() {
+                  void 0 === this._frameId && (this._frameId = this._requestFrame());
+                }
+              }
+              class Ts extends e2.E {
+                constructor(t42, e22) {
+                  super(), this._renderFrameCallback = () => {
+                    const t5 = Math.min((o2.now() - this._easeStart) / this._easeOptions.duration, 1);
+                    this._onEaseFrame(this._easeOptions.easing(t5)), t5 < 1 && this._easeFrameId ? this._easeFrameId = this._requestRenderFrame(this._renderFrameCallback) : this.stop();
+                  }, this._moving = false, this._zooming = false, this.transform = t42, this._bearingSnap = e22.bearingSnap, this.on("moveend", () => {
+                    delete this._requestedCameraState;
+                  });
+                }
+                getCenter() {
+                  return new e2.N(this.transform.center.lng, this.transform.center.lat);
+                }
+                setCenter(t42, e22) {
+                  return this.jumpTo({ center: t42 }, e22);
+                }
+                panBy(t42, i22, a22) {
+                  return t42 = e2.P.convert(t42).mult(-1), this.panTo(this.transform.center, e2.e({ offset: t42 }, i22), a22);
+                }
+                panTo(t42, i22, a22) {
+                  return this.easeTo(e2.e({ center: t42 }, i22), a22);
+                }
+                getZoom() {
+                  return this.transform.zoom;
+                }
+                setZoom(t42, e22) {
+                  return this.jumpTo({ zoom: t42 }, e22), this;
+                }
+                zoomTo(t42, i22, a22) {
+                  return this.easeTo(e2.e({ zoom: t42 }, i22), a22);
+                }
+                zoomIn(t42, e22) {
+                  return this.zoomTo(this.getZoom() + 1, t42, e22), this;
+                }
+                zoomOut(t42, e22) {
+                  return this.zoomTo(this.getZoom() - 1, t42, e22), this;
+                }
+                getBearing() {
+                  return this.transform.bearing;
+                }
+                setBearing(t42, e22) {
+                  return this.jumpTo({ bearing: t42 }, e22), this;
+                }
+                getPadding() {
+                  return this.transform.padding;
+                }
+                setPadding(t42, e22) {
+                  return this.jumpTo({ padding: t42 }, e22), this;
+                }
+                rotateTo(t42, i22, a22) {
+                  return this.easeTo(e2.e({ bearing: t42 }, i22), a22);
+                }
+                resetNorth(t42, i22) {
+                  return this.rotateTo(0, e2.e({ duration: 1e3 }, t42), i22), this;
+                }
+                resetNorthPitch(t42, i22) {
+                  return this.easeTo(e2.e({ bearing: 0, pitch: 0, duration: 1e3 }, t42), i22), this;
+                }
+                snapToNorth(t42, e22) {
+                  return Math.abs(this.getBearing()) < this._bearingSnap ? this.resetNorth(t42, e22) : this;
+                }
+                getPitch() {
+                  return this.transform.pitch;
+                }
+                setPitch(t42, e22) {
+                  return this.jumpTo({ pitch: t42 }, e22), this;
+                }
+                cameraForBounds(t42, e22) {
+                  t42 = H2.convert(t42).adjustAntiMeridian();
+                  const i22 = e22 && e22.bearing || 0;
+                  return this._cameraForBoxAndBearing(t42.getNorthWest(), t42.getSouthEast(), i22, e22);
+                }
+                _cameraForBoxAndBearing(t42, i22, a22, s22) {
+                  const o22 = { top: 0, bottom: 0, right: 0, left: 0 };
+                  if ("number" == typeof (s22 = e2.e({ padding: o22, offset: [0, 0], maxZoom: this.transform.maxZoom }, s22)).padding) {
+                    const t5 = s22.padding;
+                    s22.padding = { top: t5, bottom: t5, right: t5, left: t5 };
+                  }
+                  s22.padding = e2.e(o22, s22.padding);
+                  const r22 = this.transform, n22 = r22.padding, l22 = new H2(t42, i22), h22 = r22.project(l22.getNorthWest()), c22 = r22.project(l22.getNorthEast()), u22 = r22.project(l22.getSouthEast()), d22 = r22.project(l22.getSouthWest()), _22 = e2.ba(-a22), p22 = h22.rotate(_22), m22 = c22.rotate(_22), f22 = u22.rotate(_22), g22 = d22.rotate(_22), v22 = new e2.P(Math.max(p22.x, m22.x, g22.x, f22.x), Math.max(p22.y, m22.y, g22.y, f22.y)), x22 = new e2.P(Math.min(p22.x, m22.x, g22.x, f22.x), Math.min(p22.y, m22.y, g22.y, f22.y)), y22 = v22.sub(x22), b22 = (r22.width - (n22.left + n22.right + s22.padding.left + s22.padding.right)) / y22.x, w22 = (r22.height - (n22.top + n22.bottom + s22.padding.top + s22.padding.bottom)) / y22.y;
+                  if (w22 < 0 || b22 < 0) return void e2.w("Map cannot fit within canvas with the given bounds, padding, and/or offset.");
+                  const T22 = Math.min(r22.scaleZoom(r22.scale * Math.min(b22, w22)), s22.maxZoom), I22 = e2.P.convert(s22.offset), E3 = new e2.P((s22.padding.left - s22.padding.right) / 2, (s22.padding.top - s22.padding.bottom) / 2).rotate(e2.ba(a22)), P22 = I22.add(E3).mult(r22.scale / r22.zoomScale(T22));
+                  return { center: r22.unproject(h22.add(u22).div(2).sub(P22)), zoom: T22, bearing: a22 };
+                }
+                fitBounds(t42, e22, i22) {
+                  return this._fitInternal(this.cameraForBounds(t42, e22), e22, i22);
+                }
+                fitScreenCoordinates(t42, i22, a22, s22, o22) {
+                  return this._fitInternal(this._cameraForBoxAndBearing(this.transform.pointLocation(e2.P.convert(t42)), this.transform.pointLocation(e2.P.convert(i22)), a22, s22), s22, o22);
+                }
+                _fitInternal(t42, i22, a22) {
+                  return t42 ? (delete (i22 = e2.e(t42, i22)).padding, i22.linear ? this.easeTo(i22, a22) : this.flyTo(i22, a22)) : this;
+                }
+                jumpTo(t42, i22) {
+                  this.stop();
+                  const a22 = this._getTransformForUpdate();
+                  let s22 = false, o22 = false, r22 = false;
+                  return "zoom" in t42 && a22.zoom !== +t42.zoom && (s22 = true, a22.zoom = +t42.zoom), void 0 !== t42.center && (a22.center = e2.N.convert(t42.center)), "bearing" in t42 && a22.bearing !== +t42.bearing && (o22 = true, a22.bearing = +t42.bearing), "pitch" in t42 && a22.pitch !== +t42.pitch && (r22 = true, a22.pitch = +t42.pitch), null == t42.padding || a22.isPaddingEqual(t42.padding) || (a22.padding = t42.padding), this._applyUpdatedTransform(a22), this.fire(new e2.k("movestart", i22)).fire(new e2.k("move", i22)), s22 && this.fire(new e2.k("zoomstart", i22)).fire(new e2.k("zoom", i22)).fire(new e2.k("zoomend", i22)), o22 && this.fire(new e2.k("rotatestart", i22)).fire(new e2.k("rotate", i22)).fire(new e2.k("rotateend", i22)), r22 && this.fire(new e2.k("pitchstart", i22)).fire(new e2.k("pitch", i22)).fire(new e2.k("pitchend", i22)), this.fire(new e2.k("moveend", i22));
+                }
+                calculateCameraOptionsFromTo(t42, i22, a22, s22 = 0) {
+                  const o22 = e2.Z.fromLngLat(t42, i22), r22 = e2.Z.fromLngLat(a22, s22), n22 = r22.x - o22.x, l22 = r22.y - o22.y, h22 = r22.z - o22.z, c22 = Math.hypot(n22, l22, h22);
+                  if (0 === c22) throw new Error("Can't calculate camera options with same From and To");
+                  const u22 = Math.hypot(n22, l22), d22 = this.transform.scaleZoom(this.transform.cameraToCenterDistance / c22 / this.transform.tileSize), _22 = 180 * Math.atan2(n22, -l22) / Math.PI;
+                  let p22 = 180 * Math.acos(u22 / c22) / Math.PI;
+                  return p22 = h22 < 0 ? 90 - p22 : 90 + p22, { center: r22.toLngLat(), zoom: d22, pitch: p22, bearing: _22 };
+                }
+                easeTo(t42, i22) {
+                  var a22;
+                  this._stop(false, t42.easeId), (false === (t42 = e2.e({ offset: [0, 0], duration: 500, easing: e2.b9 }, t42)).animate || !t42.essential && o2.prefersReducedMotion) && (t42.duration = 0);
+                  const s22 = this._getTransformForUpdate(), r22 = s22.zoom, n22 = s22.bearing, l22 = s22.pitch, h22 = s22.padding, c22 = "bearing" in t42 ? this._normalizeBearing(t42.bearing, n22) : n22, u22 = "pitch" in t42 ? +t42.pitch : l22, d22 = "padding" in t42 ? t42.padding : s22.padding, _22 = e2.P.convert(t42.offset);
+                  let p22 = s22.centerPoint.add(_22);
+                  const m22 = s22.pointLocation(p22), { center: f22, zoom: g22 } = s22.getConstrained(e2.N.convert(t42.center || m22), null !== (a22 = t42.zoom) && void 0 !== a22 ? a22 : r22);
+                  this._normalizeCenter(f22, s22);
+                  const v22 = s22.project(m22), x22 = s22.project(f22).sub(v22), y22 = s22.zoomScale(g22 - r22);
+                  let b22, w22;
+                  t42.around && (b22 = e2.N.convert(t42.around), w22 = s22.locationPoint(b22));
+                  const T22 = { moving: this._moving, zooming: this._zooming, rotating: this._rotating, pitching: this._pitching };
+                  return this._zooming = this._zooming || g22 !== r22, this._rotating = this._rotating || n22 !== c22, this._pitching = this._pitching || u22 !== l22, this._padding = !s22.isPaddingEqual(d22), this._easeId = t42.easeId, this._prepareEase(i22, t42.noMoveStart, T22), this.terrain && this._prepareElevation(f22), this._ease((a3) => {
+                    if (this._zooming && (s22.zoom = e2.y.number(r22, g22, a3)), this._rotating && (s22.bearing = e2.y.number(n22, c22, a3)), this._pitching && (s22.pitch = e2.y.number(l22, u22, a3)), this._padding && (s22.interpolatePadding(h22, d22, a3), p22 = s22.centerPoint.add(_22)), this.terrain && !t42.freezeElevation && this._updateElevation(a3), b22) s22.setLocationAtPoint(b22, w22);
+                    else {
+                      const t5 = s22.zoomScale(s22.zoom - r22), e22 = g22 > r22 ? Math.min(2, y22) : Math.max(0.5, y22), i3 = Math.pow(e22, 1 - a3), o22 = s22.unproject(v22.add(x22.mult(a3 * i3)).mult(t5));
+                      s22.setLocationAtPoint(s22.renderWorldCopies ? o22.wrap() : o22, p22);
+                    }
+                    this._applyUpdatedTransform(s22), this._fireMoveEvents(i22);
+                  }, (e22) => {
+                    this.terrain && t42.freezeElevation && this._finalizeElevation(), this._afterEase(i22, e22);
+                  }, t42), this;
+                }
+                _prepareEase(t42, i22, a22 = {}) {
+                  this._moving = true, i22 || a22.moving || this.fire(new e2.k("movestart", t42)), this._zooming && !a22.zooming && this.fire(new e2.k("zoomstart", t42)), this._rotating && !a22.rotating && this.fire(new e2.k("rotatestart", t42)), this._pitching && !a22.pitching && this.fire(new e2.k("pitchstart", t42));
+                }
+                _prepareElevation(t42) {
+                  this._elevationCenter = t42, this._elevationStart = this.transform.elevation, this._elevationTarget = this.terrain.getElevationForLngLatZoom(t42, this.transform.tileZoom), this._elevationFreeze = true;
+                }
+                _updateElevation(t42) {
+                  this.transform.minElevationForCurrentTile = this.terrain.getMinTileElevationForLngLatZoom(this._elevationCenter, this.transform.tileZoom);
+                  const i22 = this.terrain.getElevationForLngLatZoom(this._elevationCenter, this.transform.tileZoom);
+                  if (t42 < 1 && i22 !== this._elevationTarget) {
+                    const e22 = this._elevationTarget - this._elevationStart;
+                    this._elevationStart += t42 * (e22 - (i22 - (e22 * t42 + this._elevationStart)) / (1 - t42)), this._elevationTarget = i22;
+                  }
+                  this.transform.elevation = e2.y.number(this._elevationStart, this._elevationTarget, t42);
+                }
+                _finalizeElevation() {
+                  this._elevationFreeze = false, this.transform.recalculateZoom(this.terrain);
+                }
+                _getTransformForUpdate() {
+                  return this.transformCameraUpdate || this.terrain ? (this._requestedCameraState || (this._requestedCameraState = this.transform.clone()), this._requestedCameraState) : this.transform;
+                }
+                _elevateCameraIfInsideTerrain(t42) {
+                  const e22 = t42.getCameraPosition(), i22 = this.terrain.getElevationForLngLatZoom(e22.lngLat, t42.zoom);
+                  if (e22.altitude < i22) {
+                    const a22 = this.calculateCameraOptionsFromTo(e22.lngLat, i22, t42.center, t42.elevation);
+                    return { pitch: a22.pitch, zoom: a22.zoom };
+                  }
+                  return {};
+                }
+                _applyUpdatedTransform(t42) {
+                  const e22 = [];
+                  if (this.terrain && e22.push((t5) => this._elevateCameraIfInsideTerrain(t5)), this.transformCameraUpdate && e22.push((t5) => this.transformCameraUpdate(t5)), !e22.length) return;
+                  const i22 = t42.clone();
+                  for (const t5 of e22) {
+                    const e3 = i22.clone(), { center: a22, zoom: s22, pitch: o22, bearing: r22, elevation: n22 } = t5(e3);
+                    a22 && (e3.center = a22), void 0 !== s22 && (e3.zoom = s22), void 0 !== o22 && (e3.pitch = o22), void 0 !== r22 && (e3.bearing = r22), void 0 !== n22 && (e3.elevation = n22), i22.apply(e3);
+                  }
+                  this.transform.apply(i22);
+                }
+                _fireMoveEvents(t42) {
+                  this.fire(new e2.k("move", t42)), this._zooming && this.fire(new e2.k("zoom", t42)), this._rotating && this.fire(new e2.k("rotate", t42)), this._pitching && this.fire(new e2.k("pitch", t42));
+                }
+                _afterEase(t42, i22) {
+                  if (this._easeId && i22 && this._easeId === i22) return;
+                  delete this._easeId;
+                  const a22 = this._zooming, s22 = this._rotating, o22 = this._pitching;
+                  this._moving = false, this._zooming = false, this._rotating = false, this._pitching = false, this._padding = false, a22 && this.fire(new e2.k("zoomend", t42)), s22 && this.fire(new e2.k("rotateend", t42)), o22 && this.fire(new e2.k("pitchend", t42)), this.fire(new e2.k("moveend", t42));
+                }
+                flyTo(t42, i22) {
+                  var a22;
+                  if (!t42.essential && o2.prefersReducedMotion) {
+                    const a3 = e2.M(t42, ["center", "zoom", "bearing", "pitch", "around"]);
+                    return this.jumpTo(a3, i22);
+                  }
+                  this.stop(), t42 = e2.e({ offset: [0, 0], speed: 1.2, curve: 1.42, easing: e2.b9 }, t42);
+                  const s22 = this._getTransformForUpdate(), r22 = s22.zoom, n22 = s22.bearing, l22 = s22.pitch, h22 = s22.padding, c22 = "bearing" in t42 ? this._normalizeBearing(t42.bearing, n22) : n22, u22 = "pitch" in t42 ? +t42.pitch : l22, d22 = "padding" in t42 ? t42.padding : s22.padding, _22 = e2.P.convert(t42.offset);
+                  let p22 = s22.centerPoint.add(_22);
+                  const m22 = s22.pointLocation(p22), { center: f22, zoom: g22 } = s22.getConstrained(e2.N.convert(t42.center || m22), null !== (a22 = t42.zoom) && void 0 !== a22 ? a22 : r22);
+                  this._normalizeCenter(f22, s22);
+                  const v22 = s22.zoomScale(g22 - r22), x22 = s22.project(m22), y22 = s22.project(f22).sub(x22);
+                  let b22 = t42.curve;
+                  const w22 = Math.max(s22.width, s22.height), T22 = w22 / v22, I22 = y22.mag();
+                  if ("minZoom" in t42) {
+                    const i3 = e2.ac(Math.min(t42.minZoom, r22, g22), s22.minZoom, s22.maxZoom), a3 = w22 / s22.zoomScale(i3 - r22);
+                    b22 = Math.sqrt(a3 / I22 * 2);
+                  }
+                  const E3 = b22 * b22;
+                  function P22(t5) {
+                    const e22 = (T22 * T22 - w22 * w22 + (t5 ? -1 : 1) * E3 * E3 * I22 * I22) / (2 * (t5 ? T22 : w22) * E3 * I22);
+                    return Math.log(Math.sqrt(e22 * e22 + 1) - e22);
+                  }
+                  function C3(t5) {
+                    return (Math.exp(t5) - Math.exp(-t5)) / 2;
+                  }
+                  function S22(t5) {
+                    return (Math.exp(t5) + Math.exp(-t5)) / 2;
+                  }
+                  const z22 = P22(false);
+                  let D3 = function(t5) {
+                    return S22(z22) / S22(z22 + b22 * t5);
+                  }, M22 = function(t5) {
+                    return w22 * ((S22(z22) * (C3(e22 = z22 + b22 * t5) / S22(e22)) - C3(z22)) / E3) / I22;
+                    var e22;
+                  }, A3 = (P22(true) - z22) / b22;
+                  if (Math.abs(I22) < 1e-6 || !isFinite(A3)) {
+                    if (Math.abs(w22 - T22) < 1e-6) return this.easeTo(t42, i22);
+                    const e22 = T22 < w22 ? -1 : 1;
+                    A3 = Math.abs(Math.log(T22 / w22)) / b22, M22 = () => 0, D3 = (t5) => Math.exp(e22 * b22 * t5);
+                  }
+                  return t42.duration = "duration" in t42 ? +t42.duration : 1e3 * A3 / ("screenSpeed" in t42 ? +t42.screenSpeed / b22 : +t42.speed), t42.maxDuration && t42.duration > t42.maxDuration && (t42.duration = 0), this._zooming = true, this._rotating = n22 !== c22, this._pitching = u22 !== l22, this._padding = !s22.isPaddingEqual(d22), this._prepareEase(i22, false), this.terrain && this._prepareElevation(f22), this._ease((a3) => {
+                    const o22 = a3 * A3, m3 = 1 / D3(o22);
+                    s22.zoom = 1 === a3 ? g22 : r22 + s22.scaleZoom(m3), this._rotating && (s22.bearing = e2.y.number(n22, c22, a3)), this._pitching && (s22.pitch = e2.y.number(l22, u22, a3)), this._padding && (s22.interpolatePadding(h22, d22, a3), p22 = s22.centerPoint.add(_22)), this.terrain && !t42.freezeElevation && this._updateElevation(a3);
+                    const v3 = 1 === a3 ? f22 : s22.unproject(x22.add(y22.mult(M22(o22))).mult(m3));
+                    s22.setLocationAtPoint(s22.renderWorldCopies ? v3.wrap() : v3, p22), this._applyUpdatedTransform(s22), this._fireMoveEvents(i22);
+                  }, () => {
+                    this.terrain && t42.freezeElevation && this._finalizeElevation(), this._afterEase(i22);
+                  }, t42), this;
+                }
+                isEasing() {
+                  return !!this._easeFrameId;
+                }
+                stop() {
+                  return this._stop();
+                }
+                _stop(t42, e22) {
+                  var i22;
+                  if (this._easeFrameId && (this._cancelRenderFrame(this._easeFrameId), delete this._easeFrameId, delete this._onEaseFrame), this._onEaseEnd) {
+                    const t5 = this._onEaseEnd;
+                    delete this._onEaseEnd, t5.call(this, e22);
+                  }
+                  return t42 || null === (i22 = this.handlers) || void 0 === i22 || i22.stop(false), this;
+                }
+                _ease(t42, e22, i22) {
+                  false === i22.animate || 0 === i22.duration ? (t42(1), e22()) : (this._easeStart = o2.now(), this._easeOptions = i22, this._onEaseFrame = t42, this._onEaseEnd = e22, this._easeFrameId = this._requestRenderFrame(this._renderFrameCallback));
+                }
+                _normalizeBearing(t42, i22) {
+                  t42 = e2.b3(t42, -180, 180);
+                  const a22 = Math.abs(t42 - i22);
+                  return Math.abs(t42 - 360 - i22) < a22 && (t42 -= 360), Math.abs(t42 + 360 - i22) < a22 && (t42 += 360), t42;
+                }
+                _normalizeCenter(t42, e22) {
+                  if (!e22.renderWorldCopies || e22.lngRange) return;
+                  const i22 = t42.lng - e22.center.lng;
+                  t42.lng += i22 > 180 ? -360 : i22 < -180 ? 360 : 0;
+                }
+                queryTerrainElevation(t42) {
+                  return this.terrain ? this.terrain.getElevationForLngLatZoom(e2.N.convert(t42), this.transform.tileZoom) - this.transform.elevation : null;
+                }
+              }
+              const Is = { compact: true, customAttribution: '<a href="https://maplibre.org/" target="_blank">MapLibre</a>' };
+              class Es {
+                constructor(t42 = Is) {
+                  this._toggleAttribution = () => {
+                    this._container.classList.contains("maplibregl-compact") && (this._container.classList.contains("maplibregl-compact-show") ? (this._container.setAttribute("open", ""), this._container.classList.remove("maplibregl-compact-show")) : (this._container.classList.add("maplibregl-compact-show"), this._container.removeAttribute("open")));
+                  }, this._updateData = (t5) => {
+                    !t5 || "metadata" !== t5.sourceDataType && "visibility" !== t5.sourceDataType && "style" !== t5.dataType && "terrain" !== t5.type || this._updateAttributions();
+                  }, this._updateCompact = () => {
+                    this._map.getCanvasContainer().offsetWidth <= 640 || this._compact ? false === this._compact ? this._container.setAttribute("open", "") : this._container.classList.contains("maplibregl-compact") || this._container.classList.contains("maplibregl-attrib-empty") || (this._container.setAttribute("open", ""), this._container.classList.add("maplibregl-compact", "maplibregl-compact-show")) : (this._container.setAttribute("open", ""), this._container.classList.contains("maplibregl-compact") && this._container.classList.remove("maplibregl-compact", "maplibregl-compact-show"));
+                  }, this._updateCompactMinimize = () => {
+                    this._container.classList.contains("maplibregl-compact") && this._container.classList.contains("maplibregl-compact-show") && this._container.classList.remove("maplibregl-compact-show");
+                  }, this.options = t42;
+                }
+                getDefaultPosition() {
+                  return "bottom-right";
+                }
+                onAdd(t42) {
+                  return this._map = t42, this._compact = this.options.compact, this._container = r2.create("details", "maplibregl-ctrl maplibregl-ctrl-attrib"), this._compactButton = r2.create("summary", "maplibregl-ctrl-attrib-button", this._container), this._compactButton.addEventListener("click", this._toggleAttribution), this._setElementTitle(this._compactButton, "ToggleAttribution"), this._innerContainer = r2.create("div", "maplibregl-ctrl-attrib-inner", this._container), this._updateAttributions(), this._updateCompact(), this._map.on("styledata", this._updateData), this._map.on("sourcedata", this._updateData), this._map.on("terrain", this._updateData), this._map.on("resize", this._updateCompact), this._map.on("drag", this._updateCompactMinimize), this._container;
+                }
+                onRemove() {
+                  r2.remove(this._container), this._map.off("styledata", this._updateData), this._map.off("sourcedata", this._updateData), this._map.off("terrain", this._updateData), this._map.off("resize", this._updateCompact), this._map.off("drag", this._updateCompactMinimize), this._map = void 0, this._compact = void 0, this._attribHTML = void 0;
+                }
+                _setElementTitle(t42, e22) {
+                  const i22 = this._map._getUIString(`AttributionControl.${e22}`);
+                  t42.title = i22, t42.setAttribute("aria-label", i22);
+                }
+                _updateAttributions() {
+                  if (!this._map.style) return;
+                  let t42 = [];
+                  if (this.options.customAttribution && (Array.isArray(this.options.customAttribution) ? t42 = t42.concat(this.options.customAttribution.map((t5) => "string" != typeof t5 ? "" : t5)) : "string" == typeof this.options.customAttribution && t42.push(this.options.customAttribution)), this._map.style.stylesheet) {
+                    const t5 = this._map.style.stylesheet;
+                    this.styleOwner = t5.owner, this.styleId = t5.id;
+                  }
+                  const e22 = this._map.style.sourceCaches;
+                  for (const i3 in e22) {
+                    const a22 = e22[i3];
+                    if (a22.used || a22.usedForTerrain) {
+                      const e3 = a22.getSource();
+                      e3.attribution && t42.indexOf(e3.attribution) < 0 && t42.push(e3.attribution);
+                    }
+                  }
+                  t42 = t42.filter((t5) => String(t5).trim()), t42.sort((t5, e3) => t5.length - e3.length), t42 = t42.filter((e3, i3) => {
+                    for (let a22 = i3 + 1; a22 < t42.length; a22++) if (t42[a22].indexOf(e3) >= 0) return false;
+                    return true;
+                  });
+                  const i22 = t42.join(" | ");
+                  i22 !== this._attribHTML && (this._attribHTML = i22, t42.length ? (this._innerContainer.innerHTML = i22, this._container.classList.remove("maplibregl-attrib-empty")) : this._container.classList.add("maplibregl-attrib-empty"), this._updateCompact(), this._editLink = null);
+                }
+              }
+              class Ps {
+                constructor(t42 = {}) {
+                  this._updateCompact = () => {
+                    const t5 = this._container.children;
+                    if (t5.length) {
+                      const e22 = t5[0];
+                      this._map.getCanvasContainer().offsetWidth <= 640 || this._compact ? false !== this._compact && e22.classList.add("maplibregl-compact") : e22.classList.remove("maplibregl-compact");
+                    }
+                  }, this.options = t42;
+                }
+                getDefaultPosition() {
+                  return "bottom-left";
+                }
+                onAdd(t42) {
+                  this._map = t42, this._compact = this.options && this.options.compact, this._container = r2.create("div", "maplibregl-ctrl");
+                  const e22 = r2.create("a", "maplibregl-ctrl-logo");
+                  return e22.target = "_blank", e22.rel = "noopener nofollow", e22.href = "https://maplibre.org/", e22.setAttribute("aria-label", this._map._getUIString("LogoControl.Title")), e22.setAttribute("rel", "noopener nofollow"), this._container.appendChild(e22), this._container.style.display = "block", this._map.on("resize", this._updateCompact), this._updateCompact(), this._container;
+                }
+                onRemove() {
+                  r2.remove(this._container), this._map.off("resize", this._updateCompact), this._map = void 0, this._compact = void 0;
+                }
+              }
+              class Cs {
+                constructor() {
+                  this._queue = [], this._id = 0, this._cleared = false, this._currentlyRunning = false;
+                }
+                add(t42) {
+                  const e22 = ++this._id;
+                  return this._queue.push({ callback: t42, id: e22, cancelled: false }), e22;
+                }
+                remove(t42) {
+                  const e22 = this._currentlyRunning, i22 = e22 ? this._queue.concat(e22) : this._queue;
+                  for (const e3 of i22) if (e3.id === t42) return void (e3.cancelled = true);
+                }
+                run(t42 = 0) {
+                  if (this._currentlyRunning) throw new Error("Attempting to run(), but is already running.");
+                  const e22 = this._currentlyRunning = this._queue;
+                  this._queue = [];
+                  for (const i22 of e22) if (!i22.cancelled && (i22.callback(t42), this._cleared)) break;
+                  this._cleared = false, this._currentlyRunning = false;
+                }
+                clear() {
+                  this._currentlyRunning && (this._cleared = true), this._queue = [];
+                }
+              }
+              var Ss = e2.Y([{ name: "a_pos3d", type: "Int16", components: 3 }]);
+              class zs extends e2.E {
+                constructor(t42) {
+                  super(), this.sourceCache = t42, this._tiles = {}, this._renderableTilesKeys = [], this._sourceTileCache = {}, this.minzoom = 0, this.maxzoom = 22, this.tileSize = 512, this.deltaZoom = 1, t42.usedForTerrain = true, t42.tileSize = this.tileSize * 2 ** this.deltaZoom;
+                }
+                destruct() {
+                  this.sourceCache.usedForTerrain = false, this.sourceCache.tileSize = null;
+                }
+                update(t42, i22) {
+                  this.sourceCache.update(t42, i22), this._renderableTilesKeys = [];
+                  const a22 = {};
+                  for (const s22 of t42.coveringTiles({ tileSize: this.tileSize, minzoom: this.minzoom, maxzoom: this.maxzoom, reparseOverscaled: false, terrain: i22 })) a22[s22.key] = true, this._renderableTilesKeys.push(s22.key), this._tiles[s22.key] || (s22.posMatrix = new Float64Array(16), e2.aP(s22.posMatrix, 0, e2.X, 0, e2.X, 0, 1), this._tiles[s22.key] = new lt2(s22, this.tileSize));
+                  for (const t5 in this._tiles) a22[t5] || delete this._tiles[t5];
+                }
+                freeRtt(t42) {
+                  for (const e22 in this._tiles) {
+                    const i22 = this._tiles[e22];
+                    (!t42 || i22.tileID.equals(t42) || i22.tileID.isChildOf(t42) || t42.isChildOf(i22.tileID)) && (i22.rtt = []);
+                  }
+                }
+                getRenderableTiles() {
+                  return this._renderableTilesKeys.map((t42) => this.getTileByID(t42));
+                }
+                getTileByID(t42) {
+                  return this._tiles[t42];
+                }
+                getTerrainCoords(t42) {
+                  const i22 = {};
+                  for (const a22 of this._renderableTilesKeys) {
+                    const s22 = this._tiles[a22].tileID;
+                    if (s22.canonical.equals(t42.canonical)) {
+                      const s3 = t42.clone();
+                      s3.posMatrix = new Float64Array(16), e2.aP(s3.posMatrix, 0, e2.X, 0, e2.X, 0, 1), i22[a22] = s3;
+                    } else if (s22.canonical.isChildOf(t42.canonical)) {
+                      const o22 = t42.clone();
+                      o22.posMatrix = new Float64Array(16);
+                      const r22 = s22.canonical.z - t42.canonical.z, n22 = s22.canonical.x - (s22.canonical.x >> r22 << r22), l22 = s22.canonical.y - (s22.canonical.y >> r22 << r22), h22 = e2.X >> r22;
+                      e2.aP(o22.posMatrix, 0, h22, 0, h22, 0, 1), e2.J(o22.posMatrix, o22.posMatrix, [-n22 * h22, -l22 * h22, 0]), i22[a22] = o22;
+                    } else if (t42.canonical.isChildOf(s22.canonical)) {
+                      const o22 = t42.clone();
+                      o22.posMatrix = new Float64Array(16);
+                      const r22 = t42.canonical.z - s22.canonical.z, n22 = t42.canonical.x - (t42.canonical.x >> r22 << r22), l22 = t42.canonical.y - (t42.canonical.y >> r22 << r22), h22 = e2.X >> r22;
+                      e2.aP(o22.posMatrix, 0, e2.X, 0, e2.X, 0, 1), e2.J(o22.posMatrix, o22.posMatrix, [n22 * h22, l22 * h22, 0]), e2.K(o22.posMatrix, o22.posMatrix, [1 / 2 ** r22, 1 / 2 ** r22, 0]), i22[a22] = o22;
+                    }
+                  }
+                  return i22;
+                }
+                getSourceTile(t42, e22) {
+                  const i22 = this.sourceCache._source;
+                  let a22 = t42.overscaledZ - this.deltaZoom;
+                  if (a22 > i22.maxzoom && (a22 = i22.maxzoom), a22 < i22.minzoom) return null;
+                  this._sourceTileCache[t42.key] || (this._sourceTileCache[t42.key] = t42.scaledTo(a22).key);
+                  let s22 = this.sourceCache.getTileByID(this._sourceTileCache[t42.key]);
+                  if ((!s22 || !s22.dem) && e22) for (; a22 >= i22.minzoom && (!s22 || !s22.dem); ) s22 = this.sourceCache.getTileByID(t42.scaledTo(a22--).key);
+                  return s22;
+                }
+                tilesAfterTime(t42 = Date.now()) {
+                  return Object.values(this._tiles).filter((e22) => e22.timeAdded >= t42);
+                }
+              }
+              class Ds {
+                constructor(t42, e22, i22) {
+                  this.painter = t42, this.sourceCache = new zs(e22), this.options = i22, this.exaggeration = "number" == typeof i22.exaggeration ? i22.exaggeration : 1, this.qualityFactor = 2, this.meshSize = 128, this._demMatrixCache = {}, this.coordsIndex = [], this._coordsTextureSize = 1024;
+                }
+                getDEMElevation(t42, i22, a22, s22 = e2.X) {
+                  var o22;
+                  if (!(i22 >= 0 && i22 < s22 && a22 >= 0 && a22 < s22)) return 0;
+                  const r22 = this.getTerrainData(t42), n22 = null === (o22 = r22.tile) || void 0 === o22 ? void 0 : o22.dem;
+                  if (!n22) return 0;
+                  const l22 = function(t5, e22, i3) {
+                    var a3 = e22[0], s3 = e22[1];
+                    return t5[0] = i3[0] * a3 + i3[4] * s3 + i3[12], t5[1] = i3[1] * a3 + i3[5] * s3 + i3[13], t5;
+                  }([], [i22 / s22 * e2.X, a22 / s22 * e2.X], r22.u_terrain_matrix), h22 = [l22[0] * n22.dim, l22[1] * n22.dim], c22 = Math.floor(h22[0]), u22 = Math.floor(h22[1]), d22 = h22[0] - c22, _22 = h22[1] - u22;
+                  return n22.get(c22, u22) * (1 - d22) * (1 - _22) + n22.get(c22 + 1, u22) * d22 * (1 - _22) + n22.get(c22, u22 + 1) * (1 - d22) * _22 + n22.get(c22 + 1, u22 + 1) * d22 * _22;
+                }
+                getElevationForLngLatZoom(t42, i22) {
+                  if (!e2.bb(i22, t42.wrap())) return 0;
+                  const { tileID: a22, mercatorX: s22, mercatorY: o22 } = this._getOverscaledTileIDFromLngLatZoom(t42, i22);
+                  return this.getElevation(a22, s22 % e2.X, o22 % e2.X, e2.X);
+                }
+                getElevation(t42, i22, a22, s22 = e2.X) {
+                  return this.getDEMElevation(t42, i22, a22, s22) * this.exaggeration;
+                }
+                getTerrainData(t42) {
+                  if (!this._emptyDemTexture) {
+                    const t5 = this.painter.context, i3 = new e2.R({ width: 1, height: 1 }, new Uint8Array(4));
+                    this._emptyDepthTexture = new b2(t5, i3, t5.gl.RGBA, { premultiply: false }), this._emptyDemUnpack = [0, 0, 0, 0], this._emptyDemTexture = new b2(t5, new e2.R({ width: 1, height: 1 }), t5.gl.RGBA, { premultiply: false }), this._emptyDemTexture.bind(t5.gl.NEAREST, t5.gl.CLAMP_TO_EDGE), this._emptyDemMatrix = e2.an([]);
+                  }
+                  const i22 = this.sourceCache.getSourceTile(t42, true);
+                  if (i22 && i22.dem && (!i22.demTexture || i22.needsTerrainPrepare)) {
+                    const t5 = this.painter.context;
+                    i22.demTexture = this.painter.getTileTexture(i22.dem.stride), i22.demTexture ? i22.demTexture.update(i22.dem.getPixels(), { premultiply: false }) : i22.demTexture = new b2(t5, i22.dem.getPixels(), t5.gl.RGBA, { premultiply: false }), i22.demTexture.bind(t5.gl.NEAREST, t5.gl.CLAMP_TO_EDGE), i22.needsTerrainPrepare = false;
+                  }
+                  const a22 = i22 && i22 + i22.tileID.key + t42.key;
+                  if (a22 && !this._demMatrixCache[a22]) {
+                    const a3 = this.sourceCache.sourceCache._source.maxzoom;
+                    let s22 = t42.canonical.z - i22.tileID.canonical.z;
+                    t42.overscaledZ > t42.canonical.z && (t42.canonical.z >= a3 ? s22 = t42.canonical.z - a3 : e2.w("cannot calculate elevation if elevation maxzoom > source.maxzoom"));
+                    const o22 = t42.canonical.x - (t42.canonical.x >> s22 << s22), r22 = t42.canonical.y - (t42.canonical.y >> s22 << s22), n22 = e2.bc(new Float64Array(16), [1 / (e2.X << s22), 1 / (e2.X << s22), 0]);
+                    e2.J(n22, n22, [o22 * e2.X, r22 * e2.X, 0]), this._demMatrixCache[t42.key] = { matrix: n22, coord: t42 };
+                  }
+                  return { u_depth: 2, u_terrain: 3, u_terrain_dim: i22 && i22.dem && i22.dem.dim || 1, u_terrain_matrix: a22 ? this._demMatrixCache[t42.key].matrix : this._emptyDemMatrix, u_terrain_unpack: i22 && i22.dem && i22.dem.getUnpackVector() || this._emptyDemUnpack, u_terrain_exaggeration: this.exaggeration, texture: (i22 && i22.demTexture || this._emptyDemTexture).texture, depthTexture: (this._fboDepthTexture || this._emptyDepthTexture).texture, tile: i22 };
+                }
+                getFramebuffer(t42) {
+                  const e22 = this.painter, i22 = e22.width / devicePixelRatio, a22 = e22.height / devicePixelRatio;
+                  return !this._fbo || this._fbo.width === i22 && this._fbo.height === a22 || (this._fbo.destroy(), this._fboCoordsTexture.destroy(), this._fboDepthTexture.destroy(), delete this._fbo, delete this._fboDepthTexture, delete this._fboCoordsTexture), this._fboCoordsTexture || (this._fboCoordsTexture = new b2(e22.context, { width: i22, height: a22, data: null }, e22.context.gl.RGBA, { premultiply: false }), this._fboCoordsTexture.bind(e22.context.gl.NEAREST, e22.context.gl.CLAMP_TO_EDGE)), this._fboDepthTexture || (this._fboDepthTexture = new b2(e22.context, { width: i22, height: a22, data: null }, e22.context.gl.RGBA, { premultiply: false }), this._fboDepthTexture.bind(e22.context.gl.NEAREST, e22.context.gl.CLAMP_TO_EDGE)), this._fbo || (this._fbo = e22.context.createFramebuffer(i22, a22, true, false), this._fbo.depthAttachment.set(e22.context.createRenderbuffer(e22.context.gl.DEPTH_COMPONENT16, i22, a22))), this._fbo.colorAttachment.set("coords" === t42 ? this._fboCoordsTexture.texture : this._fboDepthTexture.texture), this._fbo;
+                }
+                getCoordsTexture() {
+                  const t42 = this.painter.context;
+                  if (this._coordsTexture) return this._coordsTexture;
+                  const i22 = new Uint8Array(this._coordsTextureSize * this._coordsTextureSize * 4);
+                  for (let t5 = 0, e22 = 0; t5 < this._coordsTextureSize; t5++) for (let a3 = 0; a3 < this._coordsTextureSize; a3++, e22 += 4) i22[e22 + 0] = 255 & a3, i22[e22 + 1] = 255 & t5, i22[e22 + 2] = a3 >> 8 << 4 | t5 >> 8, i22[e22 + 3] = 0;
+                  const a22 = new e2.R({ width: this._coordsTextureSize, height: this._coordsTextureSize }, new Uint8Array(i22.buffer)), s22 = new b2(t42, a22, t42.gl.RGBA, { premultiply: false });
+                  return s22.bind(t42.gl.NEAREST, t42.gl.CLAMP_TO_EDGE), this._coordsTexture = s22, s22;
+                }
+                pointCoordinate(t42) {
+                  this.painter.maybeDrawDepthAndCoords(true);
+                  const i22 = new Uint8Array(4), a22 = this.painter.context, s22 = a22.gl, o22 = Math.round(t42.x * this.painter.pixelRatio / devicePixelRatio), r22 = Math.round(t42.y * this.painter.pixelRatio / devicePixelRatio), n22 = Math.round(this.painter.height / devicePixelRatio);
+                  a22.bindFramebuffer.set(this.getFramebuffer("coords").framebuffer), s22.readPixels(o22, n22 - r22 - 1, 1, 1, s22.RGBA, s22.UNSIGNED_BYTE, i22), a22.bindFramebuffer.set(null);
+                  const l22 = i22[0] + (i22[2] >> 4 << 8), h22 = i22[1] + ((15 & i22[2]) << 8), c22 = this.coordsIndex[255 - i22[3]], u22 = c22 && this.sourceCache.getTileByID(c22);
+                  if (!u22) return null;
+                  const d22 = this._coordsTextureSize, _22 = (1 << u22.tileID.canonical.z) * d22;
+                  return new e2.Z((u22.tileID.canonical.x * d22 + l22) / _22 + u22.tileID.wrap, (u22.tileID.canonical.y * d22 + h22) / _22, this.getElevation(u22.tileID, l22, h22, d22));
+                }
+                depthAtPoint(t42) {
+                  const e22 = new Uint8Array(4), i22 = this.painter.context, a22 = i22.gl;
+                  return i22.bindFramebuffer.set(this.getFramebuffer("depth").framebuffer), a22.readPixels(t42.x, this.painter.height / devicePixelRatio - t42.y - 1, 1, 1, a22.RGBA, a22.UNSIGNED_BYTE, e22), i22.bindFramebuffer.set(null), (e22[0] / 16777216 + e22[1] / 65536 + e22[2] / 256 + e22[3]) / 256;
+                }
+                getTerrainMesh() {
+                  if (this._mesh) return this._mesh;
+                  const t42 = this.painter.context, i22 = new e2.bd(), a22 = new e2.aY(), s22 = this.meshSize, o22 = e2.X / s22, r22 = s22 * s22;
+                  for (let t5 = 0; t5 <= s22; t5++) for (let e22 = 0; e22 <= s22; e22++) i22.emplaceBack(e22 * o22, t5 * o22, 0);
+                  for (let t5 = 0; t5 < r22; t5 += s22 + 1) for (let e22 = 0; e22 < s22; e22++) a22.emplaceBack(e22 + t5, s22 + e22 + t5 + 1, s22 + e22 + t5 + 2), a22.emplaceBack(e22 + t5, s22 + e22 + t5 + 2, e22 + t5 + 1);
+                  const n22 = i22.length, l22 = n22 + 2 * (s22 + 1);
+                  for (const t5 of [0, 1]) for (let a3 = 0; a3 <= s22; a3++) for (const s3 of [0, 1]) i22.emplaceBack(a3 * o22, t5 * e2.X, s3);
+                  for (let t5 = 0; t5 < 2 * s22; t5 += 2) a22.emplaceBack(l22 + t5, l22 + t5 + 1, l22 + t5 + 3), a22.emplaceBack(l22 + t5, l22 + t5 + 3, l22 + t5 + 2), a22.emplaceBack(n22 + t5, n22 + t5 + 3, n22 + t5 + 1), a22.emplaceBack(n22 + t5, n22 + t5 + 2, n22 + t5 + 3);
+                  const h22 = i22.length, c22 = h22 + 2 * (s22 + 1);
+                  for (const t5 of [0, 1]) for (let a3 = 0; a3 <= s22; a3++) for (const s3 of [0, 1]) i22.emplaceBack(t5 * e2.X, a3 * o22, s3);
+                  for (let t5 = 0; t5 < 2 * s22; t5 += 2) a22.emplaceBack(h22 + t5, h22 + t5 + 1, h22 + t5 + 3), a22.emplaceBack(h22 + t5, h22 + t5 + 3, h22 + t5 + 2), a22.emplaceBack(c22 + t5, c22 + t5 + 3, c22 + t5 + 1), a22.emplaceBack(c22 + t5, c22 + t5 + 2, c22 + t5 + 3);
+                  return this._mesh = new ga(t42.createVertexBuffer(i22, Ss.members), t42.createIndexBuffer(a22), e2.a0.simpleSegment(0, 0, i22.length, a22.length)), this._mesh;
+                }
+                getMeshFrameDelta(t42) {
+                  return 2 * Math.PI * e2.be / Math.pow(2, t42) / 5;
+                }
+                getMinTileElevationForLngLatZoom(t42, e22) {
+                  var i22;
+                  const { tileID: a22 } = this._getOverscaledTileIDFromLngLatZoom(t42, e22);
+                  return null !== (i22 = this.getMinMaxElevation(a22).minElevation) && void 0 !== i22 ? i22 : 0;
+                }
+                getMinMaxElevation(t42) {
+                  const e22 = this.getTerrainData(t42).tile, i22 = { minElevation: null, maxElevation: null };
+                  return e22 && e22.dem && (i22.minElevation = e22.dem.min * this.exaggeration, i22.maxElevation = e22.dem.max * this.exaggeration), i22;
+                }
+                _getOverscaledTileIDFromLngLatZoom(t42, i22) {
+                  const a22 = e2.Z.fromLngLat(t42.wrap()), s22 = (1 << i22) * e2.X, o22 = a22.x * s22, r22 = a22.y * s22, n22 = Math.floor(o22 / e2.X), l22 = Math.floor(r22 / e2.X);
+                  return { tileID: new e2.S(i22, 0, i22, n22, l22), mercatorX: o22, mercatorY: r22 };
+                }
+              }
+              class Ms {
+                constructor(t42, e22, i22) {
+                  this._context = t42, this._size = e22, this._tileSize = i22, this._objects = [], this._recentlyUsed = [], this._stamp = 0;
+                }
+                destruct() {
+                  for (const t42 of this._objects) t42.texture.destroy(), t42.fbo.destroy();
+                }
+                _createObject(t42) {
+                  const e22 = this._context.createFramebuffer(this._tileSize, this._tileSize, true, true), i22 = new b2(this._context, { width: this._tileSize, height: this._tileSize, data: null }, this._context.gl.RGBA);
+                  return i22.bind(this._context.gl.LINEAR, this._context.gl.CLAMP_TO_EDGE), e22.depthAttachment.set(this._context.createRenderbuffer(this._context.gl.DEPTH_STENCIL, this._tileSize, this._tileSize)), e22.colorAttachment.set(i22.texture), { id: t42, fbo: e22, texture: i22, stamp: -1, inUse: false };
+                }
+                getObjectForId(t42) {
+                  return this._objects[t42];
+                }
+                useObject(t42) {
+                  t42.inUse = true, this._recentlyUsed = this._recentlyUsed.filter((e22) => t42.id !== e22), this._recentlyUsed.push(t42.id);
+                }
+                stampObject(t42) {
+                  t42.stamp = ++this._stamp;
+                }
+                getOrCreateFreeObject() {
+                  for (const t5 of this._recentlyUsed) if (!this._objects[t5].inUse) return this._objects[t5];
+                  if (this._objects.length >= this._size) throw new Error("No free RenderPool available, call freeAllObjects() required!");
+                  const t42 = this._createObject(this._objects.length);
+                  return this._objects.push(t42), t42;
+                }
+                freeObject(t42) {
+                  t42.inUse = false;
+                }
+                freeAllObjects() {
+                  for (const t42 of this._objects) this.freeObject(t42);
+                }
+                isFull() {
+                  return !(this._objects.length < this._size) && false === this._objects.some((t42) => !t42.inUse);
+                }
+              }
+              const As = { background: true, fill: true, line: true, raster: true, hillshade: true };
+              class Rs {
+                constructor(t42, e22) {
+                  this.painter = t42, this.terrain = e22, this.pool = new Ms(t42.context, 30, e22.sourceCache.tileSize * e22.qualityFactor);
+                }
+                destruct() {
+                  this.pool.destruct();
+                }
+                getTexture(t42) {
+                  return this.pool.getObjectForId(t42.rtt[this._stacks.length - 1].id).texture;
+                }
+                prepareForRender(t42, e22) {
+                  this._stacks = [], this._prevType = null, this._rttTiles = [], this._renderableTiles = this.terrain.sourceCache.getRenderableTiles(), this._renderableLayerIds = t42._order.filter((i22) => !t42._layers[i22].isHidden(e22)), this._coordsDescendingInv = {};
+                  for (const e3 in t42.sourceCaches) {
+                    this._coordsDescendingInv[e3] = {};
+                    const i22 = t42.sourceCaches[e3].getVisibleCoordinates();
+                    for (const t5 of i22) {
+                      const i3 = this.terrain.sourceCache.getTerrainCoords(t5);
+                      for (const t6 in i3) this._coordsDescendingInv[e3][t6] || (this._coordsDescendingInv[e3][t6] = []), this._coordsDescendingInv[e3][t6].push(i3[t6]);
+                    }
+                  }
+                  this._coordsDescendingInvStr = {};
+                  for (const e3 of t42._order) {
+                    const i22 = t42._layers[e3], a22 = i22.source;
+                    if (As[i22.type] && !this._coordsDescendingInvStr[a22]) {
+                      this._coordsDescendingInvStr[a22] = {};
+                      for (const t5 in this._coordsDescendingInv[a22]) this._coordsDescendingInvStr[a22][t5] = this._coordsDescendingInv[a22][t5].map((t6) => t6.key).sort().join();
+                    }
+                  }
+                  for (const t5 of this._renderableTiles) for (const e3 in this._coordsDescendingInvStr) {
+                    const i22 = this._coordsDescendingInvStr[e3][t5.tileID.key];
+                    i22 && i22 !== t5.rttCoords[e3] && (t5.rtt = []);
+                  }
+                }
+                renderLayer(t42) {
+                  if (t42.isHidden(this.painter.transform.zoom)) return false;
+                  const i22 = t42.type, a22 = this.painter, s22 = this._renderableLayerIds[this._renderableLayerIds.length - 1] === t42.id;
+                  if (As[i22] && (this._prevType && As[this._prevType] || this._stacks.push([]), this._prevType = i22, this._stacks[this._stacks.length - 1].push(t42.id), !s22)) return true;
+                  if (As[this._prevType] || As[i22] && s22) {
+                    this._prevType = i22;
+                    const t5 = this._stacks.length - 1, s3 = this._stacks[t5] || [];
+                    for (const i3 of this._renderableTiles) {
+                      if (this.pool.isFull() && (fa2(this.painter, this.terrain, this._rttTiles), this._rttTiles = [], this.pool.freeAllObjects()), this._rttTiles.push(i3), i3.rtt[t5]) {
+                        const e22 = this.pool.getObjectForId(i3.rtt[t5].id);
+                        if (e22.stamp === i3.rtt[t5].stamp) {
+                          this.pool.useObject(e22);
+                          continue;
+                        }
+                      }
+                      const o22 = this.pool.getOrCreateFreeObject();
+                      this.pool.useObject(o22), this.pool.stampObject(o22), i3.rtt[t5] = { id: o22.id, stamp: o22.stamp }, a22.context.bindFramebuffer.set(o22.fbo.framebuffer), a22.context.clear({ color: e2.aM.transparent, stencil: 0 }), a22.currentStencilSource = void 0;
+                      for (let t6 = 0; t6 < s3.length; t6++) {
+                        const e22 = a22.style._layers[s3[t6]], r22 = e22.source ? this._coordsDescendingInv[e22.source][i3.tileID.key] : [i3.tileID];
+                        a22.context.viewport.set([0, 0, o22.fbo.width, o22.fbo.height]), a22._renderTileClippingMasks(e22, r22), a22.renderLayer(a22, a22.style.sourceCaches[e22.source], e22, r22), e22.source && (i3.rttCoords[e22.source] = this._coordsDescendingInvStr[e22.source][i3.tileID.key]);
+                      }
+                    }
+                    return fa2(this.painter, this.terrain, this._rttTiles), this._rttTiles = [], this.pool.freeAllObjects(), As[i22];
+                  }
+                  return false;
+                }
+              }
+              const ks = { "AttributionControl.ToggleAttribution": "Toggle attribution", "AttributionControl.MapFeedback": "Map feedback", "FullscreenControl.Enter": "Enter fullscreen", "FullscreenControl.Exit": "Exit fullscreen", "GeolocateControl.FindMyLocation": "Find my location", "GeolocateControl.LocationNotAvailable": "Location not available", "LogoControl.Title": "MapLibre logo", "Map.Title": "Map", "Marker.Title": "Map marker", "NavigationControl.ResetBearing": "Reset bearing to north", "NavigationControl.ZoomIn": "Zoom in", "NavigationControl.ZoomOut": "Zoom out", "Popup.Close": "Close popup", "ScaleControl.Feet": "ft", "ScaleControl.Meters": "m", "ScaleControl.Kilometers": "km", "ScaleControl.Miles": "mi", "ScaleControl.NauticalMiles": "nm", "TerrainControl.Enable": "Enable terrain", "TerrainControl.Disable": "Disable terrain", "CooperativeGesturesHandler.WindowsHelpText": "Use Ctrl + scroll to zoom the map", "CooperativeGesturesHandler.MacHelpText": "Use ⌘ + scroll to zoom the map", "CooperativeGesturesHandler.MobileHelpText": "Use two fingers to move the map" }, Ls = i2, Fs = { hash: false, interactive: true, bearingSnap: 7, attributionControl: Is, maplibreLogo: false, failIfMajorPerformanceCaveat: false, preserveDrawingBuffer: false, refreshExpiredTiles: true, scrollZoom: true, minZoom: -2, maxZoom: 22, minPitch: 0, maxPitch: 60, boxZoom: true, dragRotate: true, dragPan: true, keyboard: true, doubleClickZoom: true, touchZoomRotate: true, touchPitch: true, cooperativeGestures: false, trackResize: true, center: [0, 0], zoom: 0, bearing: 0, pitch: 0, renderWorldCopies: true, maxTileCacheSize: null, maxTileCacheZoomLevels: e2.a.MAX_TILE_CACHE_ZOOM_LEVELS, transformRequest: null, transformCameraUpdate: null, fadeDuration: 300, crossSourceCollisions: true, clickTolerance: 3, localIdeographFontFamily: "sans-serif", pitchWithRotate: true, validateStyle: true, maxCanvasSize: [4096, 4096], cancelPendingTileRequestsWhileZooming: true }, Bs = (t42) => {
+                t42.touchstart = t42.dragStart, t42.touchmoveWindow = t42.dragMove, t42.touchend = t42.dragEnd;
+              }, Os = { showCompass: true, showZoom: true, visualizePitch: false };
+              class Ns {
+                constructor(t42, i22, a22 = false) {
+                  this.mousedown = (t5) => {
+                    this.startMouse(e2.e({}, t5, { ctrlKey: true, preventDefault: () => t5.preventDefault() }), r2.mousePos(this.element, t5)), r2.addEventListener(window, "mousemove", this.mousemove), r2.addEventListener(window, "mouseup", this.mouseup);
+                  }, this.mousemove = (t5) => {
+                    this.moveMouse(t5, r2.mousePos(this.element, t5));
+                  }, this.mouseup = (t5) => {
+                    this.mouseRotate.dragEnd(t5), this.mousePitch && this.mousePitch.dragEnd(t5), this.offTemp();
+                  }, this.touchstart = (t5) => {
+                    1 !== t5.targetTouches.length ? this.reset() : (this._startPos = this._lastPos = r2.touchPos(this.element, t5.targetTouches)[0], this.startTouch(t5, this._startPos), r2.addEventListener(window, "touchmove", this.touchmove, { passive: false }), r2.addEventListener(window, "touchend", this.touchend));
+                  }, this.touchmove = (t5) => {
+                    1 !== t5.targetTouches.length ? this.reset() : (this._lastPos = r2.touchPos(this.element, t5.targetTouches)[0], this.moveTouch(t5, this._lastPos));
+                  }, this.touchend = (t5) => {
+                    0 === t5.targetTouches.length && this._startPos && this._lastPos && this._startPos.dist(this._lastPos) < this._clickTolerance && this.element.click(), delete this._startPos, delete this._lastPos, this.offTemp();
+                  }, this.reset = () => {
+                    this.mouseRotate.reset(), this.mousePitch && this.mousePitch.reset(), this.touchRotate.reset(), this.touchPitch && this.touchPitch.reset(), delete this._startPos, delete this._lastPos, this.offTemp();
+                  }, this._clickTolerance = 10;
+                  const s22 = t42.dragRotate._mouseRotate.getClickTolerance(), o22 = t42.dragRotate._mousePitch.getClickTolerance();
+                  this.element = i22, this.mouseRotate = Ka2({ clickTolerance: s22, enable: true }), this.touchRotate = (({ enable: t5, clickTolerance: e22, bearingDegreesPerPixelMoved: i3 = 0.8 }) => {
+                    const a3 = new $a();
+                    return new Ga2({ clickTolerance: e22, move: (t6, e3) => ({ bearingDelta: (e3.x - t6.x) * i3 }), moveStateManager: a3, enable: t5, assignEvents: Bs });
+                  })({ clickTolerance: s22, enable: true }), this.map = t42, a22 && (this.mousePitch = Ja2({ clickTolerance: o22, enable: true }), this.touchPitch = (({ enable: t5, clickTolerance: e22, pitchDegreesPerPixelMoved: i3 = -0.5 }) => {
+                    const a3 = new $a();
+                    return new Ga2({ clickTolerance: e22, move: (t6, e3) => ({ pitchDelta: (e3.y - t6.y) * i3 }), moveStateManager: a3, enable: t5, assignEvents: Bs });
+                  })({ clickTolerance: o22, enable: true })), r2.addEventListener(i22, "mousedown", this.mousedown), r2.addEventListener(i22, "touchstart", this.touchstart, { passive: false }), r2.addEventListener(i22, "touchcancel", this.reset);
+                }
+                startMouse(t42, e22) {
+                  this.mouseRotate.dragStart(t42, e22), this.mousePitch && this.mousePitch.dragStart(t42, e22), r2.disableDrag();
+                }
+                startTouch(t42, e22) {
+                  this.touchRotate.dragStart(t42, e22), this.touchPitch && this.touchPitch.dragStart(t42, e22), r2.disableDrag();
+                }
+                moveMouse(t42, e22) {
+                  const i22 = this.map, { bearingDelta: a22 } = this.mouseRotate.dragMove(t42, e22) || {};
+                  if (a22 && i22.setBearing(i22.getBearing() + a22), this.mousePitch) {
+                    const { pitchDelta: a3 } = this.mousePitch.dragMove(t42, e22) || {};
+                    a3 && i22.setPitch(i22.getPitch() + a3);
+                  }
+                }
+                moveTouch(t42, e22) {
+                  const i22 = this.map, { bearingDelta: a22 } = this.touchRotate.dragMove(t42, e22) || {};
+                  if (a22 && i22.setBearing(i22.getBearing() + a22), this.touchPitch) {
+                    const { pitchDelta: a3 } = this.touchPitch.dragMove(t42, e22) || {};
+                    a3 && i22.setPitch(i22.getPitch() + a3);
+                  }
+                }
+                off() {
+                  const t42 = this.element;
+                  r2.removeEventListener(t42, "mousedown", this.mousedown), r2.removeEventListener(t42, "touchstart", this.touchstart, { passive: false }), r2.removeEventListener(window, "touchmove", this.touchmove, { passive: false }), r2.removeEventListener(window, "touchend", this.touchend), r2.removeEventListener(t42, "touchcancel", this.reset), this.offTemp();
+                }
+                offTemp() {
+                  r2.enableDrag(), r2.removeEventListener(window, "mousemove", this.mousemove), r2.removeEventListener(window, "mouseup", this.mouseup), r2.removeEventListener(window, "touchmove", this.touchmove, { passive: false }), r2.removeEventListener(window, "touchend", this.touchend);
+                }
+              }
+              let Us;
+              function js(t42, i22, a22) {
+                const s22 = new e2.N(t42.lng, t42.lat);
+                if (t42 = new e2.N(t42.lng, t42.lat), i22) {
+                  const s3 = new e2.N(t42.lng - 360, t42.lat), o22 = new e2.N(t42.lng + 360, t42.lat), r22 = a22.locationPoint(t42).distSqr(i22);
+                  a22.locationPoint(s3).distSqr(i22) < r22 ? t42 = s3 : a22.locationPoint(o22).distSqr(i22) < r22 && (t42 = o22);
+                }
+                for (; Math.abs(t42.lng - a22.center.lng) > 180; ) {
+                  const e22 = a22.locationPoint(t42);
+                  if (e22.x >= 0 && e22.y >= 0 && e22.x <= a22.width && e22.y <= a22.height) break;
+                  t42.lng > a22.center.lng ? t42.lng -= 360 : t42.lng += 360;
+                }
+                return t42.lng !== s22.lng && a22.locationPoint(t42).y > a22.height / 2 - a22.getHorizon() ? t42 : s22;
+              }
+              const Zs = { center: "translate(-50%,-50%)", top: "translate(-50%,0)", "top-left": "translate(0,0)", "top-right": "translate(-100%,0)", bottom: "translate(-50%,-100%)", "bottom-left": "translate(0,-100%)", "bottom-right": "translate(-100%,-100%)", left: "translate(0,-50%)", right: "translate(-100%,-50%)" };
+              function qs(t42, e22, i22) {
+                const a22 = t42.classList;
+                for (const t5 in Zs) a22.remove(`maplibregl-${i22}-anchor-${t5}`);
+                a22.add(`maplibregl-${i22}-anchor-${e22}`);
+              }
+              class Vs extends e2.E {
+                constructor(t42) {
+                  if (super(), this._onKeyPress = (t5) => {
+                    const e22 = t5.code, i22 = t5.charCode || t5.keyCode;
+                    "Space" !== e22 && "Enter" !== e22 && 32 !== i22 && 13 !== i22 || this.togglePopup();
+                  }, this._onMapClick = (t5) => {
+                    const e22 = t5.originalEvent.target, i22 = this._element;
+                    this._popup && (e22 === i22 || i22.contains(e22)) && this.togglePopup();
+                  }, this._update = (t5) => {
+                    var e22;
+                    if (!this._map) return;
+                    const i22 = this._map.loaded() && !this._map.isMoving();
+                    ("terrain" === (null == t5 ? void 0 : t5.type) || "render" === (null == t5 ? void 0 : t5.type) && !i22) && this._map.once("render", this._update), this._lngLat = this._map.transform.renderWorldCopies ? js(this._lngLat, this._flatPos, this._map.transform) : null === (e22 = this._lngLat) || void 0 === e22 ? void 0 : e22.wrap(), this._flatPos = this._pos = this._map.project(this._lngLat)._add(this._offset), this._map.terrain && (this._flatPos = this._map.transform.locationPoint(this._lngLat)._add(this._offset));
+                    let a22 = "";
+                    "viewport" === this._rotationAlignment || "auto" === this._rotationAlignment ? a22 = `rotateZ(${this._rotation}deg)` : "map" === this._rotationAlignment && (a22 = `rotateZ(${this._rotation - this._map.getBearing()}deg)`);
+                    let s22 = "";
+                    "viewport" === this._pitchAlignment || "auto" === this._pitchAlignment ? s22 = "rotateX(0deg)" : "map" === this._pitchAlignment && (s22 = `rotateX(${this._map.getPitch()}deg)`), this._subpixelPositioning || t5 && "moveend" !== t5.type || (this._pos = this._pos.round()), r2.setTransform(this._element, `${Zs[this._anchor]} translate(${this._pos.x}px, ${this._pos.y}px) ${s22} ${a22}`), o2.frameAsync(new AbortController()).then(() => {
+                      this._updateOpacity(t5 && "moveend" === t5.type);
+                    }).catch(() => {
+                    });
+                  }, this._onMove = (t5) => {
+                    if (!this._isDragging) {
+                      const e22 = this._clickTolerance || this._map._clickTolerance;
+                      this._isDragging = t5.point.dist(this._pointerdownPos) >= e22;
+                    }
+                    this._isDragging && (this._pos = t5.point.sub(this._positionDelta), this._lngLat = this._map.unproject(this._pos), this.setLngLat(this._lngLat), this._element.style.pointerEvents = "none", "pending" === this._state && (this._state = "active", this.fire(new e2.k("dragstart"))), this.fire(new e2.k("drag")));
+                  }, this._onUp = () => {
+                    this._element.style.pointerEvents = "auto", this._positionDelta = null, this._pointerdownPos = null, this._isDragging = false, this._map.off("mousemove", this._onMove), this._map.off("touchmove", this._onMove), "active" === this._state && this.fire(new e2.k("dragend")), this._state = "inactive";
+                  }, this._addDragHandler = (t5) => {
+                    this._element.contains(t5.originalEvent.target) && (t5.preventDefault(), this._positionDelta = t5.point.sub(this._pos).add(this._offset), this._pointerdownPos = t5.point, this._state = "pending", this._map.on("mousemove", this._onMove), this._map.on("touchmove", this._onMove), this._map.once("mouseup", this._onUp), this._map.once("touchend", this._onUp));
+                  }, this._anchor = t42 && t42.anchor || "center", this._color = t42 && t42.color || "#3FB1CE", this._scale = t42 && t42.scale || 1, this._draggable = t42 && t42.draggable || false, this._clickTolerance = t42 && t42.clickTolerance || 0, this._subpixelPositioning = t42 && t42.subpixelPositioning || false, this._isDragging = false, this._state = "inactive", this._rotation = t42 && t42.rotation || 0, this._rotationAlignment = t42 && t42.rotationAlignment || "auto", this._pitchAlignment = t42 && t42.pitchAlignment && "auto" !== t42.pitchAlignment ? t42.pitchAlignment : this._rotationAlignment, this.setOpacity(), this.setOpacity(null == t42 ? void 0 : t42.opacity, null == t42 ? void 0 : t42.opacityWhenCovered), t42 && t42.element) this._element = t42.element, this._offset = e2.P.convert(t42 && t42.offset || [0, 0]);
+                  else {
+                    this._defaultMarker = true, this._element = r2.create("div");
+                    const i22 = r2.createNS("http://www.w3.org/2000/svg", "svg"), a22 = 41, s22 = 27;
+                    i22.setAttributeNS(null, "display", "block"), i22.setAttributeNS(null, "height", `${a22}px`), i22.setAttributeNS(null, "width", `${s22}px`), i22.setAttributeNS(null, "viewBox", `0 0 ${s22} ${a22}`);
+                    const o22 = r2.createNS("http://www.w3.org/2000/svg", "g");
+                    o22.setAttributeNS(null, "stroke", "none"), o22.setAttributeNS(null, "stroke-width", "1"), o22.setAttributeNS(null, "fill", "none"), o22.setAttributeNS(null, "fill-rule", "evenodd");
+                    const n22 = r2.createNS("http://www.w3.org/2000/svg", "g");
+                    n22.setAttributeNS(null, "fill-rule", "nonzero");
+                    const l22 = r2.createNS("http://www.w3.org/2000/svg", "g");
+                    l22.setAttributeNS(null, "transform", "translate(3.0, 29.0)"), l22.setAttributeNS(null, "fill", "#000000");
+                    const h22 = [{ rx: "10.5", ry: "5.25002273" }, { rx: "10.5", ry: "5.25002273" }, { rx: "9.5", ry: "4.77275007" }, { rx: "8.5", ry: "4.29549936" }, { rx: "7.5", ry: "3.81822308" }, { rx: "6.5", ry: "3.34094679" }, { rx: "5.5", ry: "2.86367051" }, { rx: "4.5", ry: "2.38636864" }];
+                    for (const t5 of h22) {
+                      const e22 = r2.createNS("http://www.w3.org/2000/svg", "ellipse");
+                      e22.setAttributeNS(null, "opacity", "0.04"), e22.setAttributeNS(null, "cx", "10.5"), e22.setAttributeNS(null, "cy", "5.80029008"), e22.setAttributeNS(null, "rx", t5.rx), e22.setAttributeNS(null, "ry", t5.ry), l22.appendChild(e22);
+                    }
+                    const c22 = r2.createNS("http://www.w3.org/2000/svg", "g");
+                    c22.setAttributeNS(null, "fill", this._color);
+                    const u22 = r2.createNS("http://www.w3.org/2000/svg", "path");
+                    u22.setAttributeNS(null, "d", "M27,13.5 C27,19.074644 20.250001,27.000002 14.75,34.500002 C14.016665,35.500004 12.983335,35.500004 12.25,34.500002 C6.7499993,27.000002 0,19.222562 0,13.5 C0,6.0441559 6.0441559,0 13.5,0 C20.955844,0 27,6.0441559 27,13.5 Z"), c22.appendChild(u22);
+                    const d22 = r2.createNS("http://www.w3.org/2000/svg", "g");
+                    d22.setAttributeNS(null, "opacity", "0.25"), d22.setAttributeNS(null, "fill", "#000000");
+                    const _22 = r2.createNS("http://www.w3.org/2000/svg", "path");
+                    _22.setAttributeNS(null, "d", "M13.5,0 C6.0441559,0 0,6.0441559 0,13.5 C0,19.222562 6.7499993,27 12.25,34.5 C13,35.522727 14.016664,35.500004 14.75,34.5 C20.250001,27 27,19.074644 27,13.5 C27,6.0441559 20.955844,0 13.5,0 Z M13.5,1 C20.415404,1 26,6.584596 26,13.5 C26,15.898657 24.495584,19.181431 22.220703,22.738281 C19.945823,26.295132 16.705119,30.142167 13.943359,33.908203 C13.743445,34.180814 13.612715,34.322738 13.5,34.441406 C13.387285,34.322738 13.256555,34.180814 13.056641,33.908203 C10.284481,30.127985 7.4148684,26.314159 5.015625,22.773438 C2.6163816,19.232715 1,15.953538 1,13.5 C1,6.584596 6.584596,1 13.5,1 Z"), d22.appendChild(_22);
+                    const p22 = r2.createNS("http://www.w3.org/2000/svg", "g");
+                    p22.setAttributeNS(null, "transform", "translate(6.0, 7.0)"), p22.setAttributeNS(null, "fill", "#FFFFFF");
+                    const m22 = r2.createNS("http://www.w3.org/2000/svg", "g");
+                    m22.setAttributeNS(null, "transform", "translate(8.0, 8.0)");
+                    const f22 = r2.createNS("http://www.w3.org/2000/svg", "circle");
+                    f22.setAttributeNS(null, "fill", "#000000"), f22.setAttributeNS(null, "opacity", "0.25"), f22.setAttributeNS(null, "cx", "5.5"), f22.setAttributeNS(null, "cy", "5.5"), f22.setAttributeNS(null, "r", "5.4999962");
+                    const g22 = r2.createNS("http://www.w3.org/2000/svg", "circle");
+                    g22.setAttributeNS(null, "fill", "#FFFFFF"), g22.setAttributeNS(null, "cx", "5.5"), g22.setAttributeNS(null, "cy", "5.5"), g22.setAttributeNS(null, "r", "5.4999962"), m22.appendChild(f22), m22.appendChild(g22), n22.appendChild(l22), n22.appendChild(c22), n22.appendChild(d22), n22.appendChild(p22), n22.appendChild(m22), i22.appendChild(n22), i22.setAttributeNS(null, "height", a22 * this._scale + "px"), i22.setAttributeNS(null, "width", s22 * this._scale + "px"), this._element.appendChild(i22), this._offset = e2.P.convert(t42 && t42.offset || [0, -14]);
+                  }
+                  if (this._element.classList.add("maplibregl-marker"), this._element.addEventListener("dragstart", (t5) => {
+                    t5.preventDefault();
+                  }), this._element.addEventListener("mousedown", (t5) => {
+                    t5.preventDefault();
+                  }), qs(this._element, this._anchor, "marker"), t42 && t42.className) for (const e22 of t42.className.split(" ")) this._element.classList.add(e22);
+                  this._popup = null;
+                }
+                addTo(t42) {
+                  return this.remove(), this._map = t42, this._element.setAttribute("aria-label", t42._getUIString("Marker.Title")), t42.getCanvasContainer().appendChild(this._element), t42.on("move", this._update), t42.on("moveend", this._update), t42.on("terrain", this._update), this.setDraggable(this._draggable), this._update(), this._map.on("click", this._onMapClick), this;
+                }
+                remove() {
+                  return this._opacityTimeout && (clearTimeout(this._opacityTimeout), delete this._opacityTimeout), this._map && (this._map.off("click", this._onMapClick), this._map.off("move", this._update), this._map.off("moveend", this._update), this._map.off("terrain", this._update), this._map.off("mousedown", this._addDragHandler), this._map.off("touchstart", this._addDragHandler), this._map.off("mouseup", this._onUp), this._map.off("touchend", this._onUp), this._map.off("mousemove", this._onMove), this._map.off("touchmove", this._onMove), delete this._map), r2.remove(this._element), this._popup && this._popup.remove(), this;
+                }
+                getLngLat() {
+                  return this._lngLat;
+                }
+                setLngLat(t42) {
+                  return this._lngLat = e2.N.convert(t42), this._pos = null, this._popup && this._popup.setLngLat(this._lngLat), this._update(), this;
+                }
+                getElement() {
+                  return this._element;
+                }
+                setPopup(t42) {
+                  if (this._popup && (this._popup.remove(), this._popup = null, this._element.removeEventListener("keypress", this._onKeyPress), this._originalTabIndex || this._element.removeAttribute("tabindex")), t42) {
+                    if (!("offset" in t42.options)) {
+                      const e22 = 38.1, i22 = 13.5, a22 = Math.abs(i22) / Math.SQRT2;
+                      t42.options.offset = this._defaultMarker ? { top: [0, 0], "top-left": [0, 0], "top-right": [0, 0], bottom: [0, -38.1], "bottom-left": [a22, -1 * (e22 - i22 + a22)], "bottom-right": [-a22, -1 * (e22 - i22 + a22)], left: [i22, -1 * (e22 - i22)], right: [-13.5, -1 * (e22 - i22)] } : this._offset;
+                    }
+                    this._popup = t42, this._originalTabIndex = this._element.getAttribute("tabindex"), this._originalTabIndex || this._element.setAttribute("tabindex", "0"), this._element.addEventListener("keypress", this._onKeyPress);
+                  }
+                  return this;
+                }
+                setSubpixelPositioning(t42) {
+                  return this._subpixelPositioning = t42, this;
+                }
+                getPopup() {
+                  return this._popup;
+                }
+                togglePopup() {
+                  const t42 = this._popup;
+                  return this._element.style.opacity === this._opacityWhenCovered ? this : t42 ? (t42.isOpen() ? t42.remove() : (t42.setLngLat(this._lngLat), t42.addTo(this._map)), this) : this;
+                }
+                _updateOpacity(t42 = false) {
+                  var i22, a22;
+                  if (!(null === (i22 = this._map) || void 0 === i22 ? void 0 : i22.terrain)) return void (this._element.style.opacity !== this._opacity && (this._element.style.opacity = this._opacity));
+                  if (t42) this._opacityTimeout = null;
+                  else {
+                    if (this._opacityTimeout) return;
+                    this._opacityTimeout = setTimeout(() => {
+                      this._opacityTimeout = null;
+                    }, 100);
+                  }
+                  const s22 = this._map, o22 = s22.terrain.depthAtPoint(this._pos), r22 = s22.terrain.getElevationForLngLatZoom(this._lngLat, s22.transform.tileZoom);
+                  if (s22.transform.lngLatToCameraDepth(this._lngLat, r22) - o22 < 6e-3) return void (this._element.style.opacity = this._opacity);
+                  const n22 = -this._offset.y / s22.transform._pixelPerMeter, l22 = Math.sin(s22.getPitch() * Math.PI / 180) * n22, h22 = s22.terrain.depthAtPoint(new e2.P(this._pos.x, this._pos.y - this._offset.y)), c22 = s22.transform.lngLatToCameraDepth(this._lngLat, r22 + l22) - h22 > 6e-3;
+                  (null === (a22 = this._popup) || void 0 === a22 ? void 0 : a22.isOpen()) && c22 && this._popup.remove(), this._element.style.opacity = c22 ? this._opacityWhenCovered : this._opacity;
+                }
+                getOffset() {
+                  return this._offset;
+                }
+                setOffset(t42) {
+                  return this._offset = e2.P.convert(t42), this._update(), this;
+                }
+                addClassName(t42) {
+                  this._element.classList.add(t42);
+                }
+                removeClassName(t42) {
+                  this._element.classList.remove(t42);
+                }
+                toggleClassName(t42) {
+                  return this._element.classList.toggle(t42);
+                }
+                setDraggable(t42) {
+                  return this._draggable = !!t42, this._map && (t42 ? (this._map.on("mousedown", this._addDragHandler), this._map.on("touchstart", this._addDragHandler)) : (this._map.off("mousedown", this._addDragHandler), this._map.off("touchstart", this._addDragHandler))), this;
+                }
+                isDraggable() {
+                  return this._draggable;
+                }
+                setRotation(t42) {
+                  return this._rotation = t42 || 0, this._update(), this;
+                }
+                getRotation() {
+                  return this._rotation;
+                }
+                setRotationAlignment(t42) {
+                  return this._rotationAlignment = t42 || "auto", this._update(), this;
+                }
+                getRotationAlignment() {
+                  return this._rotationAlignment;
+                }
+                setPitchAlignment(t42) {
+                  return this._pitchAlignment = t42 && "auto" !== t42 ? t42 : this._rotationAlignment, this._update(), this;
+                }
+                getPitchAlignment() {
+                  return this._pitchAlignment;
+                }
+                setOpacity(t42, e22) {
+                  return void 0 === t42 && void 0 === e22 && (this._opacity = "1", this._opacityWhenCovered = "0.2"), void 0 !== t42 && (this._opacity = t42), void 0 !== e22 && (this._opacityWhenCovered = e22), this._map && this._updateOpacity(true), this;
+                }
+              }
+              const Gs = { positionOptions: { enableHighAccuracy: false, maximumAge: 0, timeout: 6e3 }, fitBoundsOptions: { maxZoom: 15 }, trackUserLocation: false, showAccuracyCircle: true, showUserLocation: true };
+              let Hs = 0, Ws = false;
+              const $s = { maxWidth: 100, unit: "metric" };
+              function Xs(t42, e22, i22) {
+                const a22 = i22 && i22.maxWidth || 100, s22 = t42._container.clientHeight / 2, o22 = t42.unproject([0, s22]), r22 = t42.unproject([a22, s22]), n22 = o22.distanceTo(r22);
+                if (i22 && "imperial" === i22.unit) {
+                  const i3 = 3.2808 * n22;
+                  i3 > 5280 ? Ks(e22, a22, i3 / 5280, t42._getUIString("ScaleControl.Miles")) : Ks(e22, a22, i3, t42._getUIString("ScaleControl.Feet"));
+                } else i22 && "nautical" === i22.unit ? Ks(e22, a22, n22 / 1852, t42._getUIString("ScaleControl.NauticalMiles")) : n22 >= 1e3 ? Ks(e22, a22, n22 / 1e3, t42._getUIString("ScaleControl.Kilometers")) : Ks(e22, a22, n22, t42._getUIString("ScaleControl.Meters"));
+              }
+              function Ks(t42, e22, i22, a22) {
+                const s22 = function(t5) {
+                  const e3 = Math.pow(10, `${Math.floor(t5)}`.length - 1);
+                  let i3 = t5 / e3;
+                  return i3 = i3 >= 10 ? 10 : i3 >= 5 ? 5 : i3 >= 3 ? 3 : i3 >= 2 ? 2 : i3 >= 1 ? 1 : function(t6) {
+                    const e4 = Math.pow(10, Math.ceil(-Math.log(t6) / Math.LN10));
+                    return Math.round(t6 * e4) / e4;
+                  }(i3), e3 * i3;
+                }(i22);
+                t42.style.width = e22 * (s22 / i22) + "px", t42.innerHTML = `${s22}&nbsp;${a22}`;
+              }
+              const Js = { closeButton: true, closeOnClick: true, focusAfterOpen: true, className: "", maxWidth: "240px", subpixelPositioning: false }, Ys = ["a[href]", "[tabindex]:not([tabindex='-1'])", "[contenteditable]:not([contenteditable='false'])", "button:not([disabled])", "input:not([disabled])", "select:not([disabled])", "textarea:not([disabled])"].join(", ");
+              function Qs(t42) {
+                if (t42) {
+                  if ("number" == typeof t42) {
+                    const i22 = Math.round(Math.abs(t42) / Math.SQRT2);
+                    return { center: new e2.P(0, 0), top: new e2.P(0, t42), "top-left": new e2.P(i22, i22), "top-right": new e2.P(-i22, i22), bottom: new e2.P(0, -t42), "bottom-left": new e2.P(i22, -i22), "bottom-right": new e2.P(-i22, -i22), left: new e2.P(t42, 0), right: new e2.P(-t42, 0) };
+                  }
+                  if (t42 instanceof e2.P || Array.isArray(t42)) {
+                    const i22 = e2.P.convert(t42);
+                    return { center: i22, top: i22, "top-left": i22, "top-right": i22, bottom: i22, "bottom-left": i22, "bottom-right": i22, left: i22, right: i22 };
+                  }
+                  return { center: e2.P.convert(t42.center || [0, 0]), top: e2.P.convert(t42.top || [0, 0]), "top-left": e2.P.convert(t42["top-left"] || [0, 0]), "top-right": e2.P.convert(t42["top-right"] || [0, 0]), bottom: e2.P.convert(t42.bottom || [0, 0]), "bottom-left": e2.P.convert(t42["bottom-left"] || [0, 0]), "bottom-right": e2.P.convert(t42["bottom-right"] || [0, 0]), left: e2.P.convert(t42.left || [0, 0]), right: e2.P.convert(t42.right || [0, 0]) };
+                }
+                return Qs(new e2.P(0, 0));
+              }
+              const to = i2;
+              t4.AJAXError = e2.bh, t4.Evented = e2.E, t4.LngLat = e2.N, t4.MercatorCoordinate = e2.Z, t4.Point = e2.P, t4.addProtocol = e2.bi, t4.config = e2.a, t4.removeProtocol = e2.bj, t4.AttributionControl = Es, t4.BoxZoomHandler = Ua2, t4.CanvasSource = et2, t4.CooperativeGesturesHandler = vs2, t4.DoubleClickZoomHandler = ds, t4.DragPanHandler = ms, t4.DragRotateHandler = fs2, t4.EdgeInsets = ba, t4.FullscreenControl = class extends e2.E {
+                constructor(t42 = {}) {
+                  super(), this._onFullscreenChange = () => {
+                    var t5;
+                    let e22 = window.document.fullscreenElement || window.document.mozFullScreenElement || window.document.webkitFullscreenElement || window.document.msFullscreenElement;
+                    for (; null === (t5 = null == e22 ? void 0 : e22.shadowRoot) || void 0 === t5 ? void 0 : t5.fullscreenElement; ) e22 = e22.shadowRoot.fullscreenElement;
+                    e22 === this._container !== this._fullscreen && this._handleFullscreenChange();
+                  }, this._onClickFullscreen = () => {
+                    this._isFullscreen() ? this._exitFullscreen() : this._requestFullscreen();
+                  }, this._fullscreen = false, t42 && t42.container && (t42.container instanceof HTMLElement ? this._container = t42.container : e2.w("Full screen control 'container' must be a DOM element.")), "onfullscreenchange" in document ? this._fullscreenchange = "fullscreenchange" : "onmozfullscreenchange" in document ? this._fullscreenchange = "mozfullscreenchange" : "onwebkitfullscreenchange" in document ? this._fullscreenchange = "webkitfullscreenchange" : "onmsfullscreenchange" in document && (this._fullscreenchange = "MSFullscreenChange");
+                }
+                onAdd(t42) {
+                  return this._map = t42, this._container || (this._container = this._map.getContainer()), this._controlContainer = r2.create("div", "maplibregl-ctrl maplibregl-ctrl-group"), this._setupUI(), this._controlContainer;
+                }
+                onRemove() {
+                  r2.remove(this._controlContainer), this._map = null, window.document.removeEventListener(this._fullscreenchange, this._onFullscreenChange);
+                }
+                _setupUI() {
+                  const t42 = this._fullscreenButton = r2.create("button", "maplibregl-ctrl-fullscreen", this._controlContainer);
+                  r2.create("span", "maplibregl-ctrl-icon", t42).setAttribute("aria-hidden", "true"), t42.type = "button", this._updateTitle(), this._fullscreenButton.addEventListener("click", this._onClickFullscreen), window.document.addEventListener(this._fullscreenchange, this._onFullscreenChange);
+                }
+                _updateTitle() {
+                  const t42 = this._getTitle();
+                  this._fullscreenButton.setAttribute("aria-label", t42), this._fullscreenButton.title = t42;
+                }
+                _getTitle() {
+                  return this._map._getUIString(this._isFullscreen() ? "FullscreenControl.Exit" : "FullscreenControl.Enter");
+                }
+                _isFullscreen() {
+                  return this._fullscreen;
+                }
+                _handleFullscreenChange() {
+                  this._fullscreen = !this._fullscreen, this._fullscreenButton.classList.toggle("maplibregl-ctrl-shrink"), this._fullscreenButton.classList.toggle("maplibregl-ctrl-fullscreen"), this._updateTitle(), this._fullscreen ? (this.fire(new e2.k("fullscreenstart")), this._prevCooperativeGesturesEnabled = this._map.cooperativeGestures.isEnabled(), this._map.cooperativeGestures.disable()) : (this.fire(new e2.k("fullscreenend")), this._prevCooperativeGesturesEnabled && this._map.cooperativeGestures.enable());
+                }
+                _exitFullscreen() {
+                  window.document.exitFullscreen ? window.document.exitFullscreen() : window.document.mozCancelFullScreen ? window.document.mozCancelFullScreen() : window.document.msExitFullscreen ? window.document.msExitFullscreen() : window.document.webkitCancelFullScreen ? window.document.webkitCancelFullScreen() : this._togglePseudoFullScreen();
+                }
+                _requestFullscreen() {
+                  this._container.requestFullscreen ? this._container.requestFullscreen() : this._container.mozRequestFullScreen ? this._container.mozRequestFullScreen() : this._container.msRequestFullscreen ? this._container.msRequestFullscreen() : this._container.webkitRequestFullscreen ? this._container.webkitRequestFullscreen() : this._togglePseudoFullScreen();
+                }
+                _togglePseudoFullScreen() {
+                  this._container.classList.toggle("maplibregl-pseudo-fullscreen"), this._handleFullscreenChange(), this._map.resize();
+                }
+              }, t4.GeoJSONSource = J2, t4.GeolocateControl = class extends e2.E {
+                constructor(t42) {
+                  super(), this._onSuccess = (t5) => {
+                    if (this._map) {
+                      if (this._isOutOfMapMaxBounds(t5)) return this._setErrorState(), this.fire(new e2.k("outofmaxbounds", t5)), this._updateMarker(), void this._finish();
+                      if (this.options.trackUserLocation) switch (this._lastKnownPosition = t5, this._watchState) {
+                        case "WAITING_ACTIVE":
+                        case "ACTIVE_LOCK":
+                        case "ACTIVE_ERROR":
+                          this._watchState = "ACTIVE_LOCK", this._geolocateButton.classList.remove("maplibregl-ctrl-geolocate-waiting"), this._geolocateButton.classList.remove("maplibregl-ctrl-geolocate-active-error"), this._geolocateButton.classList.add("maplibregl-ctrl-geolocate-active");
+                          break;
+                        case "BACKGROUND":
+                        case "BACKGROUND_ERROR":
+                          this._watchState = "BACKGROUND", this._geolocateButton.classList.remove("maplibregl-ctrl-geolocate-waiting"), this._geolocateButton.classList.remove("maplibregl-ctrl-geolocate-background-error"), this._geolocateButton.classList.add("maplibregl-ctrl-geolocate-background");
+                          break;
+                        default:
+                          throw new Error(`Unexpected watchState ${this._watchState}`);
+                      }
+                      this.options.showUserLocation && "OFF" !== this._watchState && this._updateMarker(t5), this.options.trackUserLocation && "ACTIVE_LOCK" !== this._watchState || this._updateCamera(t5), this.options.showUserLocation && this._dotElement.classList.remove("maplibregl-user-location-dot-stale"), this.fire(new e2.k("geolocate", t5)), this._finish();
+                    }
+                  }, this._updateCamera = (t5) => {
+                    const i22 = new e2.N(t5.coords.longitude, t5.coords.latitude), a22 = t5.coords.accuracy, s22 = this._map.getBearing(), o22 = e2.e({ bearing: s22 }, this.options.fitBoundsOptions), r22 = H2.fromLngLat(i22, a22);
+                    this._map.fitBounds(r22, o22, { geolocateSource: true });
+                  }, this._updateMarker = (t5) => {
+                    if (t5) {
+                      const i22 = new e2.N(t5.coords.longitude, t5.coords.latitude);
+                      this._accuracyCircleMarker.setLngLat(i22).addTo(this._map), this._userLocationDotMarker.setLngLat(i22).addTo(this._map), this._accuracy = t5.coords.accuracy, this.options.showUserLocation && this.options.showAccuracyCircle && this._updateCircleRadius();
+                    } else this._userLocationDotMarker.remove(), this._accuracyCircleMarker.remove();
+                  }, this._onZoom = () => {
+                    this.options.showUserLocation && this.options.showAccuracyCircle && this._updateCircleRadius();
+                  }, this._onError = (t5) => {
+                    if (this._map) {
+                      if (this.options.trackUserLocation) if (1 === t5.code) {
+                        this._watchState = "OFF", this._geolocateButton.classList.remove("maplibregl-ctrl-geolocate-waiting"), this._geolocateButton.classList.remove("maplibregl-ctrl-geolocate-active"), this._geolocateButton.classList.remove("maplibregl-ctrl-geolocate-active-error"), this._geolocateButton.classList.remove("maplibregl-ctrl-geolocate-background"), this._geolocateButton.classList.remove("maplibregl-ctrl-geolocate-background-error"), this._geolocateButton.disabled = true;
+                        const t6 = this._map._getUIString("GeolocateControl.LocationNotAvailable");
+                        this._geolocateButton.title = t6, this._geolocateButton.setAttribute("aria-label", t6), void 0 !== this._geolocationWatchID && this._clearWatch();
+                      } else {
+                        if (3 === t5.code && Ws) return;
+                        this._setErrorState();
+                      }
+                      "OFF" !== this._watchState && this.options.showUserLocation && this._dotElement.classList.add("maplibregl-user-location-dot-stale"), this.fire(new e2.k("error", t5)), this._finish();
+                    }
+                  }, this._finish = () => {
+                    this._timeoutId && clearTimeout(this._timeoutId), this._timeoutId = void 0;
+                  }, this._setupUI = () => {
+                    this._map && (this._container.addEventListener("contextmenu", (t5) => t5.preventDefault()), this._geolocateButton = r2.create("button", "maplibregl-ctrl-geolocate", this._container), r2.create("span", "maplibregl-ctrl-icon", this._geolocateButton).setAttribute("aria-hidden", "true"), this._geolocateButton.type = "button", this._geolocateButton.disabled = true);
+                  }, this._finishSetupUI = (t5) => {
+                    if (this._map) {
+                      if (false === t5) {
+                        e2.w("Geolocation support is not available so the GeolocateControl will be disabled.");
+                        const t6 = this._map._getUIString("GeolocateControl.LocationNotAvailable");
+                        this._geolocateButton.disabled = true, this._geolocateButton.title = t6, this._geolocateButton.setAttribute("aria-label", t6);
+                      } else {
+                        const t6 = this._map._getUIString("GeolocateControl.FindMyLocation");
+                        this._geolocateButton.disabled = false, this._geolocateButton.title = t6, this._geolocateButton.setAttribute("aria-label", t6);
+                      }
+                      this.options.trackUserLocation && (this._geolocateButton.setAttribute("aria-pressed", "false"), this._watchState = "OFF"), this.options.showUserLocation && (this._dotElement = r2.create("div", "maplibregl-user-location-dot"), this._userLocationDotMarker = new Vs({ element: this._dotElement }), this._circleElement = r2.create("div", "maplibregl-user-location-accuracy-circle"), this._accuracyCircleMarker = new Vs({ element: this._circleElement, pitchAlignment: "map" }), this.options.trackUserLocation && (this._watchState = "OFF"), this._map.on("zoom", this._onZoom)), this._geolocateButton.addEventListener("click", () => this.trigger()), this._setup = true, this.options.trackUserLocation && this._map.on("movestart", (t6) => {
+                        t6.geolocateSource || "ACTIVE_LOCK" !== this._watchState || t6.originalEvent && "resize" === t6.originalEvent.type || (this._watchState = "BACKGROUND", this._geolocateButton.classList.add("maplibregl-ctrl-geolocate-background"), this._geolocateButton.classList.remove("maplibregl-ctrl-geolocate-active"), this.fire(new e2.k("trackuserlocationend")), this.fire(new e2.k("userlocationlostfocus")));
+                      });
+                    }
+                  }, this.options = e2.e({}, Gs, t42);
+                }
+                onAdd(t42) {
+                  return this._map = t42, this._container = r2.create("div", "maplibregl-ctrl maplibregl-ctrl-group"), this._setupUI(), function() {
+                    return e2._(this, arguments, void 0, function* (t5 = false) {
+                      if (void 0 !== Us && !t5) return Us;
+                      if (void 0 === window.navigator.permissions) return Us = !!window.navigator.geolocation, Us;
+                      try {
+                        const t6 = yield window.navigator.permissions.query({ name: "geolocation" });
+                        Us = "denied" !== t6.state;
+                      } catch (t6) {
+                        Us = !!window.navigator.geolocation;
+                      }
+                      return Us;
+                    });
+                  }().then((t5) => this._finishSetupUI(t5)), this._container;
+                }
+                onRemove() {
+                  void 0 !== this._geolocationWatchID && (window.navigator.geolocation.clearWatch(this._geolocationWatchID), this._geolocationWatchID = void 0), this.options.showUserLocation && this._userLocationDotMarker && this._userLocationDotMarker.remove(), this.options.showAccuracyCircle && this._accuracyCircleMarker && this._accuracyCircleMarker.remove(), r2.remove(this._container), this._map.off("zoom", this._onZoom), this._map = void 0, Hs = 0, Ws = false;
+                }
+                _isOutOfMapMaxBounds(t42) {
+                  const e22 = this._map.getMaxBounds(), i22 = t42.coords;
+                  return e22 && (i22.longitude < e22.getWest() || i22.longitude > e22.getEast() || i22.latitude < e22.getSouth() || i22.latitude > e22.getNorth());
+                }
+                _setErrorState() {
+                  switch (this._watchState) {
+                    case "WAITING_ACTIVE":
+                      this._watchState = "ACTIVE_ERROR", this._geolocateButton.classList.remove("maplibregl-ctrl-geolocate-active"), this._geolocateButton.classList.add("maplibregl-ctrl-geolocate-active-error");
+                      break;
+                    case "ACTIVE_LOCK":
+                      this._watchState = "ACTIVE_ERROR", this._geolocateButton.classList.remove("maplibregl-ctrl-geolocate-active"), this._geolocateButton.classList.add("maplibregl-ctrl-geolocate-active-error"), this._geolocateButton.classList.add("maplibregl-ctrl-geolocate-waiting");
+                      break;
+                    case "BACKGROUND":
+                      this._watchState = "BACKGROUND_ERROR", this._geolocateButton.classList.remove("maplibregl-ctrl-geolocate-background"), this._geolocateButton.classList.add("maplibregl-ctrl-geolocate-background-error"), this._geolocateButton.classList.add("maplibregl-ctrl-geolocate-waiting");
+                      break;
+                    case "ACTIVE_ERROR":
+                      break;
+                    default:
+                      throw new Error(`Unexpected watchState ${this._watchState}`);
+                  }
+                }
+                _updateCircleRadius() {
+                  const t42 = this._map.getBounds(), e22 = t42.getSouthEast(), i22 = t42.getNorthEast(), a22 = e22.distanceTo(i22), s22 = Math.ceil(this._accuracy / (a22 / this._map._container.clientHeight) * 2);
+                  this._circleElement.style.width = `${s22}px`, this._circleElement.style.height = `${s22}px`;
+                }
+                trigger() {
+                  if (!this._setup) return e2.w("Geolocate control triggered before added to a map"), false;
+                  if (this.options.trackUserLocation) {
+                    switch (this._watchState) {
+                      case "OFF":
+                        this._watchState = "WAITING_ACTIVE", this.fire(new e2.k("trackuserlocationstart"));
+                        break;
+                      case "WAITING_ACTIVE":
+                      case "ACTIVE_LOCK":
+                      case "ACTIVE_ERROR":
+                      case "BACKGROUND_ERROR":
+                        Hs--, Ws = false, this._watchState = "OFF", this._geolocateButton.classList.remove("maplibregl-ctrl-geolocate-waiting"), this._geolocateButton.classList.remove("maplibregl-ctrl-geolocate-active"), this._geolocateButton.classList.remove("maplibregl-ctrl-geolocate-active-error"), this._geolocateButton.classList.remove("maplibregl-ctrl-geolocate-background"), this._geolocateButton.classList.remove("maplibregl-ctrl-geolocate-background-error"), this.fire(new e2.k("trackuserlocationend"));
+                        break;
+                      case "BACKGROUND":
+                        this._watchState = "ACTIVE_LOCK", this._geolocateButton.classList.remove("maplibregl-ctrl-geolocate-background"), this._lastKnownPosition && this._updateCamera(this._lastKnownPosition), this.fire(new e2.k("trackuserlocationstart")), this.fire(new e2.k("userlocationfocus"));
+                        break;
+                      default:
+                        throw new Error(`Unexpected watchState ${this._watchState}`);
+                    }
+                    switch (this._watchState) {
+                      case "WAITING_ACTIVE":
+                        this._geolocateButton.classList.add("maplibregl-ctrl-geolocate-waiting"), this._geolocateButton.classList.add("maplibregl-ctrl-geolocate-active");
+                        break;
+                      case "ACTIVE_LOCK":
+                        this._geolocateButton.classList.add("maplibregl-ctrl-geolocate-active");
+                        break;
+                      case "OFF":
+                        break;
+                      default:
+                        throw new Error(`Unexpected watchState ${this._watchState}`);
+                    }
+                    if ("OFF" === this._watchState && void 0 !== this._geolocationWatchID) this._clearWatch();
+                    else if (void 0 === this._geolocationWatchID) {
+                      let t42;
+                      this._geolocateButton.classList.add("maplibregl-ctrl-geolocate-waiting"), this._geolocateButton.setAttribute("aria-pressed", "true"), Hs++, Hs > 1 ? (t42 = { maximumAge: 6e5, timeout: 0 }, Ws = true) : (t42 = this.options.positionOptions, Ws = false), this._geolocationWatchID = window.navigator.geolocation.watchPosition(this._onSuccess, this._onError, t42);
+                    }
+                  } else window.navigator.geolocation.getCurrentPosition(this._onSuccess, this._onError, this.options.positionOptions), this._timeoutId = setTimeout(this._finish, 1e4);
+                  return true;
+                }
+                _clearWatch() {
+                  window.navigator.geolocation.clearWatch(this._geolocationWatchID), this._geolocationWatchID = void 0, this._geolocateButton.classList.remove("maplibregl-ctrl-geolocate-waiting"), this._geolocateButton.setAttribute("aria-pressed", "false"), this.options.showUserLocation && this._updateMarker(null);
+                }
+              }, t4.Hash = Ea2, t4.ImageSource = Q2, t4.KeyboardHandler = ls, t4.LngLatBounds = H2, t4.LogoControl = Ps, t4.Map = class extends Ts {
+                constructor(t42) {
+                  e2.bf.mark(e2.bg.create);
+                  const i22 = Object.assign(Object.assign({}, Fs), t42);
+                  if (null != i22.minZoom && null != i22.maxZoom && i22.minZoom > i22.maxZoom) throw new Error("maxZoom must be greater than or equal to minZoom");
+                  if (null != i22.minPitch && null != i22.maxPitch && i22.minPitch > i22.maxPitch) throw new Error("maxPitch must be greater than or equal to minPitch");
+                  if (null != i22.minPitch && i22.minPitch < 0) throw new Error("minPitch must be greater than or equal to 0");
+                  if (null != i22.maxPitch && i22.maxPitch > 85) throw new Error("maxPitch must be less than or equal to 85");
+                  if (super(new Ta2(i22.minZoom, i22.maxZoom, i22.minPitch, i22.maxPitch, i22.renderWorldCopies), { bearingSnap: i22.bearingSnap }), this._idleTriggered = false, this._crossFadingFactor = 1, this._renderTaskQueue = new Cs(), this._controls = [], this._mapId = e2.a4(), this._contextLost = (t5) => {
+                    t5.preventDefault(), this._frameRequest && (this._frameRequest.abort(), this._frameRequest = null), this.fire(new e2.k("webglcontextlost", { originalEvent: t5 }));
+                  }, this._contextRestored = (t5) => {
+                    this._setupPainter(), this.resize(), this._update(), this.fire(new e2.k("webglcontextrestored", { originalEvent: t5 }));
+                  }, this._onMapScroll = (t5) => {
+                    if (t5.target === this._container) return this._container.scrollTop = 0, this._container.scrollLeft = 0, false;
+                  }, this._onWindowOnline = () => {
+                    this._update();
+                  }, this._interactive = i22.interactive, this._maxTileCacheSize = i22.maxTileCacheSize, this._maxTileCacheZoomLevels = i22.maxTileCacheZoomLevels, this._failIfMajorPerformanceCaveat = true === i22.failIfMajorPerformanceCaveat, this._preserveDrawingBuffer = true === i22.preserveDrawingBuffer, this._antialias = true === i22.antialias, this._trackResize = true === i22.trackResize, this._bearingSnap = i22.bearingSnap, this._refreshExpiredTiles = true === i22.refreshExpiredTiles, this._fadeDuration = i22.fadeDuration, this._crossSourceCollisions = true === i22.crossSourceCollisions, this._collectResourceTiming = true === i22.collectResourceTiming, this._locale = Object.assign(Object.assign({}, ks), i22.locale), this._clickTolerance = i22.clickTolerance, this._overridePixelRatio = i22.pixelRatio, this._maxCanvasSize = i22.maxCanvasSize, this.transformCameraUpdate = i22.transformCameraUpdate, this.cancelPendingTileRequestsWhileZooming = true === i22.cancelPendingTileRequestsWhileZooming, this._imageQueueHandle = _2.addThrottleControl(() => this.isMoving()), this._requestManager = new p2(i22.transformRequest), "string" == typeof i22.container) {
+                    if (this._container = document.getElementById(i22.container), !this._container) throw new Error(`Container '${i22.container}' not found.`);
+                  } else {
+                    if (!(i22.container instanceof HTMLElement)) throw new Error("Invalid type: 'container' must be a String or HTMLElement.");
+                    this._container = i22.container;
+                  }
+                  if (i22.maxBounds && this.setMaxBounds(i22.maxBounds), this._setupContainer(), this._setupPainter(), this.on("move", () => this._update(false)).on("moveend", () => this._update(false)).on("zoom", () => this._update(true)).on("terrain", () => {
+                    this.painter.terrainFacilitator.dirty = true, this._update(true);
+                  }).once("idle", () => {
+                    this._idleTriggered = true;
+                  }), "undefined" != typeof window) {
+                    addEventListener("online", this._onWindowOnline, false);
+                    let t5 = false;
+                    const e22 = Ia2((t6) => {
+                      this._trackResize && !this._removed && (this.resize(t6), this.redraw());
+                    }, 50);
+                    this._resizeObserver = new ResizeObserver((i3) => {
+                      t5 ? e22(i3) : t5 = true;
+                    }), this._resizeObserver.observe(this._container);
+                  }
+                  this.handlers = new ws(this, i22), this._hash = i22.hash && new Ea2("string" == typeof i22.hash && i22.hash || void 0).addTo(this), this._hash && this._hash._onHashChange() || (this.jumpTo({ center: i22.center, zoom: i22.zoom, bearing: i22.bearing, pitch: i22.pitch }), i22.bounds && (this.resize(), this.fitBounds(i22.bounds, e2.e({}, i22.fitBoundsOptions, { duration: 0 })))), this.resize(), this._localIdeographFontFamily = i22.localIdeographFontFamily, this._validateStyle = i22.validateStyle, i22.style && this.setStyle(i22.style, { localIdeographFontFamily: i22.localIdeographFontFamily }), i22.attributionControl && this.addControl(new Es("boolean" == typeof i22.attributionControl ? void 0 : i22.attributionControl)), i22.maplibreLogo && this.addControl(new Ps(), i22.logoPosition), this.on("style.load", () => {
+                    this.transform.unmodified && this.jumpTo(this.style.stylesheet);
+                  }), this.on("data", (t5) => {
+                    this._update("style" === t5.dataType), this.fire(new e2.k(`${t5.dataType}data`, t5));
+                  }), this.on("dataloading", (t5) => {
+                    this.fire(new e2.k(`${t5.dataType}dataloading`, t5));
+                  }), this.on("dataabort", (t5) => {
+                    this.fire(new e2.k("sourcedataabort", t5));
+                  });
+                }
+                _getMapId() {
+                  return this._mapId;
+                }
+                addControl(t42, i22) {
+                  if (void 0 === i22 && (i22 = t42.getDefaultPosition ? t42.getDefaultPosition() : "top-right"), !t42 || !t42.onAdd) return this.fire(new e2.j(new Error("Invalid argument to map.addControl(). Argument must be a control with onAdd and onRemove methods.")));
+                  const a22 = t42.onAdd(this);
+                  this._controls.push(t42);
+                  const s22 = this._controlPositions[i22];
+                  return -1 !== i22.indexOf("bottom") ? s22.insertBefore(a22, s22.firstChild) : s22.appendChild(a22), this;
+                }
+                removeControl(t42) {
+                  if (!t42 || !t42.onRemove) return this.fire(new e2.j(new Error("Invalid argument to map.removeControl(). Argument must be a control with onAdd and onRemove methods.")));
+                  const i22 = this._controls.indexOf(t42);
+                  return i22 > -1 && this._controls.splice(i22, 1), t42.onRemove(this), this;
+                }
+                hasControl(t42) {
+                  return this._controls.indexOf(t42) > -1;
+                }
+                calculateCameraOptionsFromTo(t42, e22, i22, a22) {
+                  return null == a22 && this.terrain && (a22 = this.terrain.getElevationForLngLatZoom(i22, this.transform.tileZoom)), super.calculateCameraOptionsFromTo(t42, e22, i22, a22);
+                }
+                resize(t42) {
+                  var i22;
+                  const a22 = this._containerDimensions(), s22 = a22[0], o22 = a22[1], r22 = this._getClampedPixelRatio(s22, o22);
+                  if (this._resizeCanvas(s22, o22, r22), this.painter.resize(s22, o22, r22), this.painter.overLimit()) {
+                    const t5 = this.painter.context.gl;
+                    this._maxCanvasSize = [t5.drawingBufferWidth, t5.drawingBufferHeight];
+                    const e22 = this._getClampedPixelRatio(s22, o22);
+                    this._resizeCanvas(s22, o22, e22), this.painter.resize(s22, o22, e22);
+                  }
+                  this.transform.resize(s22, o22), null === (i22 = this._requestedCameraState) || void 0 === i22 || i22.resize(s22, o22);
+                  const n22 = !this._moving;
+                  return n22 && (this.stop(), this.fire(new e2.k("movestart", t42)).fire(new e2.k("move", t42))), this.fire(new e2.k("resize", t42)), n22 && this.fire(new e2.k("moveend", t42)), this;
+                }
+                _getClampedPixelRatio(t42, e22) {
+                  const { 0: i22, 1: a22 } = this._maxCanvasSize, s22 = this.getPixelRatio(), o22 = t42 * s22, r22 = e22 * s22;
+                  return Math.min(o22 > i22 ? i22 / o22 : 1, r22 > a22 ? a22 / r22 : 1) * s22;
+                }
+                getPixelRatio() {
+                  var t42;
+                  return null !== (t42 = this._overridePixelRatio) && void 0 !== t42 ? t42 : devicePixelRatio;
+                }
+                setPixelRatio(t42) {
+                  this._overridePixelRatio = t42, this.resize();
+                }
+                getBounds() {
+                  return this.transform.getBounds();
+                }
+                getMaxBounds() {
+                  return this.transform.getMaxBounds();
+                }
+                setMaxBounds(t42) {
+                  return this.transform.setMaxBounds(H2.convert(t42)), this._update();
+                }
+                setMinZoom(t42) {
+                  if ((t42 = null == t42 ? -2 : t42) >= -2 && t42 <= this.transform.maxZoom) return this.transform.minZoom = t42, this._update(), this.getZoom() < t42 && this.setZoom(t42), this;
+                  throw new Error("minZoom must be between -2 and the current maxZoom, inclusive");
+                }
+                getMinZoom() {
+                  return this.transform.minZoom;
+                }
+                setMaxZoom(t42) {
+                  if ((t42 = null == t42 ? 22 : t42) >= this.transform.minZoom) return this.transform.maxZoom = t42, this._update(), this.getZoom() > t42 && this.setZoom(t42), this;
+                  throw new Error("maxZoom must be greater than the current minZoom");
+                }
+                getMaxZoom() {
+                  return this.transform.maxZoom;
+                }
+                setMinPitch(t42) {
+                  if ((t42 = null == t42 ? 0 : t42) < 0) throw new Error("minPitch must be greater than or equal to 0");
+                  if (t42 >= 0 && t42 <= this.transform.maxPitch) return this.transform.minPitch = t42, this._update(), this.getPitch() < t42 && this.setPitch(t42), this;
+                  throw new Error("minPitch must be between 0 and the current maxPitch, inclusive");
+                }
+                getMinPitch() {
+                  return this.transform.minPitch;
+                }
+                setMaxPitch(t42) {
+                  if ((t42 = null == t42 ? 60 : t42) > 85) throw new Error("maxPitch must be less than or equal to 85");
+                  if (t42 >= this.transform.minPitch) return this.transform.maxPitch = t42, this._update(), this.getPitch() > t42 && this.setPitch(t42), this;
+                  throw new Error("maxPitch must be greater than the current minPitch");
+                }
+                getMaxPitch() {
+                  return this.transform.maxPitch;
+                }
+                getRenderWorldCopies() {
+                  return this.transform.renderWorldCopies;
+                }
+                setRenderWorldCopies(t42) {
+                  return this.transform.renderWorldCopies = t42, this._update();
+                }
+                project(t42) {
+                  return this.transform.locationPoint(e2.N.convert(t42), this.style && this.terrain);
+                }
+                unproject(t42) {
+                  return this.transform.pointLocation(e2.P.convert(t42), this.terrain);
+                }
+                isMoving() {
+                  var t42;
+                  return this._moving || (null === (t42 = this.handlers) || void 0 === t42 ? void 0 : t42.isMoving());
+                }
+                isZooming() {
+                  var t42;
+                  return this._zooming || (null === (t42 = this.handlers) || void 0 === t42 ? void 0 : t42.isZooming());
+                }
+                isRotating() {
+                  var t42;
+                  return this._rotating || (null === (t42 = this.handlers) || void 0 === t42 ? void 0 : t42.isRotating());
+                }
+                _createDelegatedListener(t42, e22, i22) {
+                  if ("mouseenter" === t42 || "mouseover" === t42) {
+                    let a22 = false;
+                    const s22 = (s3) => {
+                      const o22 = e22.filter((t5) => this.getLayer(t5)), r22 = 0 !== o22.length ? this.queryRenderedFeatures(s3.point, { layers: o22 }) : [];
+                      r22.length ? a22 || (a22 = true, i22.call(this, new ka2(t42, this, s3.originalEvent, { features: r22 }))) : a22 = false;
+                    };
+                    return { layers: e22, listener: i22, delegates: { mousemove: s22, mouseout: () => {
+                      a22 = false;
+                    } } };
+                  }
+                  if ("mouseleave" === t42 || "mouseout" === t42) {
+                    let a22 = false;
+                    const s22 = (s3) => {
+                      const o3 = e22.filter((t5) => this.getLayer(t5));
+                      (0 !== o3.length ? this.queryRenderedFeatures(s3.point, { layers: o3 }) : []).length ? a22 = true : a22 && (a22 = false, i22.call(this, new ka2(t42, this, s3.originalEvent)));
+                    }, o22 = (e3) => {
+                      a22 && (a22 = false, i22.call(this, new ka2(t42, this, e3.originalEvent)));
+                    };
+                    return { layers: e22, listener: i22, delegates: { mousemove: s22, mouseout: o22 } };
+                  }
+                  {
+                    const a22 = (t5) => {
+                      const a3 = e22.filter((t6) => this.getLayer(t6)), s22 = 0 !== a3.length ? this.queryRenderedFeatures(t5.point, { layers: a3 }) : [];
+                      s22.length && (t5.features = s22, i22.call(this, t5), delete t5.features);
+                    };
+                    return { layers: e22, listener: i22, delegates: { [t42]: a22 } };
+                  }
+                }
+                _saveDelegatedListener(t42, e22) {
+                  this._delegatedListeners = this._delegatedListeners || {}, this._delegatedListeners[t42] = this._delegatedListeners[t42] || [], this._delegatedListeners[t42].push(e22);
+                }
+                _removeDelegatedListener(t42, e22, i22) {
+                  if (!this._delegatedListeners || !this._delegatedListeners[t42]) return;
+                  const a22 = this._delegatedListeners[t42];
+                  for (let t5 = 0; t5 < a22.length; t5++) {
+                    const s22 = a22[t5];
+                    if (s22.listener === i22 && s22.layers.length === e22.length && s22.layers.every((t6) => e22.includes(t6))) {
+                      for (const t6 in s22.delegates) this.off(t6, s22.delegates[t6]);
+                      return void a22.splice(t5, 1);
+                    }
+                  }
+                }
+                on(t42, e22, i22) {
+                  if (void 0 === i22) return super.on(t42, e22);
+                  const a22 = this._createDelegatedListener(t42, "string" == typeof e22 ? [e22] : e22, i22);
+                  this._saveDelegatedListener(t42, a22);
+                  for (const t5 in a22.delegates) this.on(t5, a22.delegates[t5]);
+                  return this;
+                }
+                once(t42, e22, i22) {
+                  if (void 0 === i22) return super.once(t42, e22);
+                  const a22 = "string" == typeof e22 ? [e22] : e22, s22 = this._createDelegatedListener(t42, a22, i22);
+                  for (const e3 in s22.delegates) {
+                    const o22 = s22.delegates[e3];
+                    s22.delegates[e3] = (...e4) => {
+                      this._removeDelegatedListener(t42, a22, i22), o22(...e4);
+                    };
+                  }
+                  this._saveDelegatedListener(t42, s22);
+                  for (const t5 in s22.delegates) this.once(t5, s22.delegates[t5]);
+                  return this;
+                }
+                off(t42, e22, i22) {
+                  return void 0 === i22 ? super.off(t42, e22) : (this._removeDelegatedListener(t42, "string" == typeof e22 ? [e22] : e22, i22), this);
+                }
+                queryRenderedFeatures(t42, i22) {
+                  if (!this.style) return [];
+                  let a22;
+                  const s22 = t42 instanceof e2.P || Array.isArray(t42), o22 = s22 ? t42 : [[0, 0], [this.transform.width, this.transform.height]];
+                  if (i22 = i22 || (s22 ? {} : t42) || {}, o22 instanceof e2.P || "number" == typeof o22[0]) a22 = [e2.P.convert(o22)];
+                  else {
+                    const t5 = e2.P.convert(o22[0]), i3 = e2.P.convert(o22[1]);
+                    a22 = [t5, new e2.P(i3.x, t5.y), i3, new e2.P(t5.x, i3.y), t5];
+                  }
+                  return this.style.queryRenderedFeatures(a22, i22, this.transform);
+                }
+                querySourceFeatures(t42, e22) {
+                  return this.style.querySourceFeatures(t42, e22);
+                }
+                setStyle(t42, i22) {
+                  return false !== (i22 = e2.e({}, { localIdeographFontFamily: this._localIdeographFontFamily, validate: this._validateStyle }, i22)).diff && i22.localIdeographFontFamily === this._localIdeographFontFamily && this.style && t42 ? (this._diffStyle(t42, i22), this) : (this._localIdeographFontFamily = i22.localIdeographFontFamily, this._updateStyle(t42, i22));
+                }
+                setTransformRequest(t42) {
+                  return this._requestManager.setTransformRequest(t42), this;
+                }
+                _getUIString(t42) {
+                  const e22 = this._locale[t42];
+                  if (null == e22) throw new Error(`Missing UI string '${t42}'`);
+                  return e22;
+                }
+                _updateStyle(t42, e22) {
+                  if (e22.transformStyle && this.style && !this.style._loaded) return void this.style.once("style.load", () => this._updateStyle(t42, e22));
+                  const i22 = this.style && e22.transformStyle ? this.style.serialize() : void 0;
+                  return this.style && (this.style.setEventedParent(null), this.style._remove(!t42)), t42 ? (this.style = new de2(this, e22 || {}), this.style.setEventedParent(this, { style: this.style }), "string" == typeof t42 ? this.style.loadURL(t42, e22, i22) : this.style.loadJSON(t42, e22, i22), this) : (delete this.style, this);
+                }
+                _lazyInitEmptyStyle() {
+                  this.style || (this.style = new de2(this, {}), this.style.setEventedParent(this, { style: this.style }), this.style.loadEmpty());
+                }
+                _diffStyle(t42, i22) {
+                  if ("string" == typeof t42) {
+                    const a22 = this._requestManager.transformRequest(t42, "Style");
+                    e2.h(a22, new AbortController()).then((t5) => {
+                      this._updateDiff(t5.data, i22);
+                    }).catch((t5) => {
+                      t5 && this.fire(new e2.j(t5));
+                    });
+                  } else "object" == typeof t42 && this._updateDiff(t42, i22);
+                }
+                _updateDiff(t42, i22) {
+                  try {
+                    this.style.setState(t42, i22) && this._update(true);
+                  } catch (a22) {
+                    e2.w(`Unable to perform style diff: ${a22.message || a22.error || a22}.  Rebuilding the style from scratch.`), this._updateStyle(t42, i22);
+                  }
+                }
+                getStyle() {
+                  if (this.style) return this.style.serialize();
+                }
+                isStyleLoaded() {
+                  return this.style ? this.style.loaded() : e2.w("There is no style added to the map.");
+                }
+                addSource(t42, e22) {
+                  return this._lazyInitEmptyStyle(), this.style.addSource(t42, e22), this._update(true);
+                }
+                isSourceLoaded(t42) {
+                  const i22 = this.style && this.style.sourceCaches[t42];
+                  if (void 0 !== i22) return i22.loaded();
+                  this.fire(new e2.j(new Error(`There is no source with ID '${t42}'`)));
+                }
+                setTerrain(t42) {
+                  if (this.style._checkLoaded(), this._terrainDataCallback && this.style.off("data", this._terrainDataCallback), t42) {
+                    const i22 = this.style.sourceCaches[t42.source];
+                    if (!i22) throw new Error(`cannot load terrain, because there exists no source with ID: ${t42.source}`);
+                    null === this.terrain && i22.reload();
+                    for (const i3 in this.style._layers) {
+                      const a22 = this.style._layers[i3];
+                      "hillshade" === a22.type && a22.source === t42.source && e2.w("You are using the same source for a hillshade layer and for 3D terrain. Please consider using two separate sources to improve rendering quality.");
+                    }
+                    this.terrain = new Ds(this.painter, i22, t42), this.painter.renderToTexture = new Rs(this.painter, this.terrain), this.transform.minElevationForCurrentTile = this.terrain.getMinTileElevationForLngLatZoom(this.transform.center, this.transform.tileZoom), this.transform.elevation = this.terrain.getElevationForLngLatZoom(this.transform.center, this.transform.tileZoom), this._terrainDataCallback = (e22) => {
+                      "style" === e22.dataType ? this.terrain.sourceCache.freeRtt() : "source" === e22.dataType && e22.tile && (e22.sourceId !== t42.source || this._elevationFreeze || (this.transform.minElevationForCurrentTile = this.terrain.getMinTileElevationForLngLatZoom(this.transform.center, this.transform.tileZoom), this.transform.elevation = this.terrain.getElevationForLngLatZoom(this.transform.center, this.transform.tileZoom)), this.terrain.sourceCache.freeRtt(e22.tile.tileID));
+                    }, this.style.on("data", this._terrainDataCallback);
+                  } else this.terrain && this.terrain.sourceCache.destruct(), this.terrain = null, this.painter.renderToTexture && this.painter.renderToTexture.destruct(), this.painter.renderToTexture = null, this.transform.minElevationForCurrentTile = 0, this.transform.elevation = 0;
+                  return this.fire(new e2.k("terrain", { terrain: t42 })), this;
+                }
+                getTerrain() {
+                  var t42, e22;
+                  return null !== (e22 = null === (t42 = this.terrain) || void 0 === t42 ? void 0 : t42.options) && void 0 !== e22 ? e22 : null;
+                }
+                areTilesLoaded() {
+                  const t42 = this.style && this.style.sourceCaches;
+                  for (const e22 in t42) {
+                    const i22 = t42[e22]._tiles;
+                    for (const t5 in i22) {
+                      const e3 = i22[t5];
+                      if ("loaded" !== e3.state && "errored" !== e3.state) return false;
+                    }
+                  }
+                  return true;
+                }
+                removeSource(t42) {
+                  return this.style.removeSource(t42), this._update(true);
+                }
+                getSource(t42) {
+                  return this.style.getSource(t42);
+                }
+                addImage(t42, i22, a22 = {}) {
+                  const { pixelRatio: s22 = 1, sdf: r22 = false, stretchX: n22, stretchY: l22, content: h22, textFitWidth: c22, textFitHeight: u22 } = a22;
+                  if (this._lazyInitEmptyStyle(), !(i22 instanceof HTMLImageElement || e2.b(i22))) {
+                    if (void 0 === i22.width || void 0 === i22.height) return this.fire(new e2.j(new Error("Invalid arguments to map.addImage(). The second argument must be an `HTMLImageElement`, `ImageData`, `ImageBitmap`, or object with `width`, `height`, and `data` properties with the same format as `ImageData`")));
+                    {
+                      const { width: a3, height: o22, data: d22 } = i22, _22 = i22;
+                      return this.style.addImage(t42, { data: new e2.R({ width: a3, height: o22 }, new Uint8Array(d22)), pixelRatio: s22, stretchX: n22, stretchY: l22, content: h22, textFitWidth: c22, textFitHeight: u22, sdf: r22, version: 0, userImage: _22 }), _22.onAdd && _22.onAdd(this, t42), this;
+                    }
+                  }
+                  {
+                    const { width: a3, height: d22, data: _22 } = o2.getImageData(i22);
+                    this.style.addImage(t42, { data: new e2.R({ width: a3, height: d22 }, _22), pixelRatio: s22, stretchX: n22, stretchY: l22, content: h22, textFitWidth: c22, textFitHeight: u22, sdf: r22, version: 0 });
+                  }
+                }
+                updateImage(t42, i22) {
+                  const a22 = this.style.getImage(t42);
+                  if (!a22) return this.fire(new e2.j(new Error("The map has no image with that id. If you are adding a new image use `map.addImage(...)` instead.")));
+                  const s22 = i22 instanceof HTMLImageElement || e2.b(i22) ? o2.getImageData(i22) : i22, { width: r22, height: n22, data: l22 } = s22;
+                  if (void 0 === r22 || void 0 === n22) return this.fire(new e2.j(new Error("Invalid arguments to map.updateImage(). The second argument must be an `HTMLImageElement`, `ImageData`, `ImageBitmap`, or object with `width`, `height`, and `data` properties with the same format as `ImageData`")));
+                  if (r22 !== a22.data.width || n22 !== a22.data.height) return this.fire(new e2.j(new Error("The width and height of the updated image must be that same as the previous version of the image")));
+                  const h22 = !(i22 instanceof HTMLImageElement || e2.b(i22));
+                  return a22.data.replace(l22, h22), this.style.updateImage(t42, a22), this;
+                }
+                getImage(t42) {
+                  return this.style.getImage(t42);
+                }
+                hasImage(t42) {
+                  return t42 ? !!this.style.getImage(t42) : (this.fire(new e2.j(new Error("Missing required image id"))), false);
+                }
+                removeImage(t42) {
+                  this.style.removeImage(t42);
+                }
+                loadImage(t42) {
+                  return _2.getImage(this._requestManager.transformRequest(t42, "Image"), new AbortController());
+                }
+                listImages() {
+                  return this.style.listImages();
+                }
+                addLayer(t42, e22) {
+                  return this._lazyInitEmptyStyle(), this.style.addLayer(t42, e22), this._update(true);
+                }
+                moveLayer(t42, e22) {
+                  return this.style.moveLayer(t42, e22), this._update(true);
+                }
+                removeLayer(t42) {
+                  return this.style.removeLayer(t42), this._update(true);
+                }
+                getLayer(t42) {
+                  return this.style.getLayer(t42);
+                }
+                getLayersOrder() {
+                  return this.style.getLayersOrder();
+                }
+                setLayerZoomRange(t42, e22, i22) {
+                  return this.style.setLayerZoomRange(t42, e22, i22), this._update(true);
+                }
+                setFilter(t42, e22, i22 = {}) {
+                  return this.style.setFilter(t42, e22, i22), this._update(true);
+                }
+                getFilter(t42) {
+                  return this.style.getFilter(t42);
+                }
+                setPaintProperty(t42, e22, i22, a22 = {}) {
+                  return this.style.setPaintProperty(t42, e22, i22, a22), this._update(true);
+                }
+                getPaintProperty(t42, e22) {
+                  return this.style.getPaintProperty(t42, e22);
+                }
+                setLayoutProperty(t42, e22, i22, a22 = {}) {
+                  return this.style.setLayoutProperty(t42, e22, i22, a22), this._update(true);
+                }
+                getLayoutProperty(t42, e22) {
+                  return this.style.getLayoutProperty(t42, e22);
+                }
+                setGlyphs(t42, e22 = {}) {
+                  return this._lazyInitEmptyStyle(), this.style.setGlyphs(t42, e22), this._update(true);
+                }
+                getGlyphs() {
+                  return this.style.getGlyphsUrl();
+                }
+                addSprite(t42, e22, i22 = {}) {
+                  return this._lazyInitEmptyStyle(), this.style.addSprite(t42, e22, i22, (t5) => {
+                    t5 || this._update(true);
+                  }), this;
+                }
+                removeSprite(t42) {
+                  return this._lazyInitEmptyStyle(), this.style.removeSprite(t42), this._update(true);
+                }
+                getSprite() {
+                  return this.style.getSprite();
+                }
+                setSprite(t42, e22 = {}) {
+                  return this._lazyInitEmptyStyle(), this.style.setSprite(t42, e22, (t5) => {
+                    t5 || this._update(true);
+                  }), this;
+                }
+                setLight(t42, e22 = {}) {
+                  return this._lazyInitEmptyStyle(), this.style.setLight(t42, e22), this._update(true);
+                }
+                getLight() {
+                  return this.style.getLight();
+                }
+                setSky(t42) {
+                  return this._lazyInitEmptyStyle(), this.style.setSky(t42), this._update(true);
+                }
+                getSky() {
+                  return this.style.getSky();
+                }
+                setFeatureState(t42, e22) {
+                  return this.style.setFeatureState(t42, e22), this._update();
+                }
+                removeFeatureState(t42, e22) {
+                  return this.style.removeFeatureState(t42, e22), this._update();
+                }
+                getFeatureState(t42) {
+                  return this.style.getFeatureState(t42);
+                }
+                getContainer() {
+                  return this._container;
+                }
+                getCanvasContainer() {
+                  return this._canvasContainer;
+                }
+                getCanvas() {
+                  return this._canvas;
+                }
+                _containerDimensions() {
+                  let t42 = 0, e22 = 0;
+                  return this._container && (t42 = this._container.clientWidth || 400, e22 = this._container.clientHeight || 300), [t42, e22];
+                }
+                _setupContainer() {
+                  const t42 = this._container;
+                  t42.classList.add("maplibregl-map");
+                  const e22 = this._canvasContainer = r2.create("div", "maplibregl-canvas-container", t42);
+                  this._interactive && e22.classList.add("maplibregl-interactive"), this._canvas = r2.create("canvas", "maplibregl-canvas", e22), this._canvas.addEventListener("webglcontextlost", this._contextLost, false), this._canvas.addEventListener("webglcontextrestored", this._contextRestored, false), this._canvas.setAttribute("tabindex", this._interactive ? "0" : "-1"), this._canvas.setAttribute("aria-label", this._getUIString("Map.Title")), this._canvas.setAttribute("role", "region");
+                  const i22 = this._containerDimensions(), a22 = this._getClampedPixelRatio(i22[0], i22[1]);
+                  this._resizeCanvas(i22[0], i22[1], a22);
+                  const s22 = this._controlContainer = r2.create("div", "maplibregl-control-container", t42), o22 = this._controlPositions = {};
+                  ["top-left", "top-right", "bottom-left", "bottom-right"].forEach((t5) => {
+                    o22[t5] = r2.create("div", `maplibregl-ctrl-${t5} `, s22);
+                  }), this._container.addEventListener("scroll", this._onMapScroll, false);
+                }
+                _resizeCanvas(t42, e22, i22) {
+                  this._canvas.width = Math.floor(i22 * t42), this._canvas.height = Math.floor(i22 * e22), this._canvas.style.width = `${t42}px`, this._canvas.style.height = `${e22}px`;
+                }
+                _setupPainter() {
+                  const t42 = { alpha: true, stencil: true, depth: true, failIfMajorPerformanceCaveat: this._failIfMajorPerformanceCaveat, preserveDrawingBuffer: this._preserveDrawingBuffer, antialias: this._antialias || false };
+                  let e22 = null;
+                  this._canvas.addEventListener("webglcontextcreationerror", (i3) => {
+                    e22 = { requestedAttributes: t42 }, i3 && (e22.statusMessage = i3.statusMessage, e22.type = i3.type);
+                  }, { once: true });
+                  const i22 = this._canvas.getContext("webgl2", t42) || this._canvas.getContext("webgl", t42);
+                  if (!i22) {
+                    const t5 = "Failed to initialize WebGL";
+                    throw e22 ? (e22.message = t5, new Error(JSON.stringify(e22))) : new Error(t5);
+                  }
+                  this.painter = new va2(i22, this.transform), n2.testSupport(i22);
+                }
+                loaded() {
+                  return !this._styleDirty && !this._sourcesDirty && !!this.style && this.style.loaded();
+                }
+                _update(t42) {
+                  return this.style && this.style._loaded ? (this._styleDirty = this._styleDirty || t42, this._sourcesDirty = true, this.triggerRepaint(), this) : this;
+                }
+                _requestRenderFrame(t42) {
+                  return this._update(), this._renderTaskQueue.add(t42);
+                }
+                _cancelRenderFrame(t42) {
+                  this._renderTaskQueue.remove(t42);
+                }
+                _render(t42) {
+                  const i22 = this._idleTriggered ? this._fadeDuration : 0;
+                  if (this.painter.context.setDirty(), this.painter.setBaseState(), this._renderTaskQueue.run(t42), this._removed) return;
+                  let a22 = false;
+                  if (this.style && this._styleDirty) {
+                    this._styleDirty = false;
+                    const t5 = this.transform.zoom, s3 = o2.now();
+                    this.style.zoomHistory.update(t5, s3);
+                    const r22 = new e2.z(t5, { now: s3, fadeDuration: i22, zoomHistory: this.style.zoomHistory, transition: this.style.getTransition() }), n22 = r22.crossFadingFactor();
+                    1 === n22 && n22 === this._crossFadingFactor || (a22 = true, this._crossFadingFactor = n22), this.style.update(r22);
+                  }
+                  this.style && this._sourcesDirty && (this._sourcesDirty = false, this.style._updateSources(this.transform)), this.terrain ? (this.terrain.sourceCache.update(this.transform, this.terrain), this.transform.minElevationForCurrentTile = this.terrain.getMinTileElevationForLngLatZoom(this.transform.center, this.transform.tileZoom), this._elevationFreeze || (this.transform.elevation = this.terrain.getElevationForLngLatZoom(this.transform.center, this.transform.tileZoom))) : (this.transform.minElevationForCurrentTile = 0, this.transform.elevation = 0), this._placementDirty = this.style && this.style._updatePlacement(this.painter.transform, this.showCollisionBoxes, i22, this._crossSourceCollisions), this.painter.render(this.style, { showTileBoundaries: this.showTileBoundaries, showOverdrawInspector: this._showOverdrawInspector, rotating: this.isRotating(), zooming: this.isZooming(), moving: this.isMoving(), fadeDuration: i22, showPadding: this.showPadding }), this.fire(new e2.k("render")), this.loaded() && !this._loaded && (this._loaded = true, e2.bf.mark(e2.bg.load), this.fire(new e2.k("load"))), this.style && (this.style.hasTransitions() || a22) && (this._styleDirty = true), this.style && !this._placementDirty && this.style._releaseSymbolFadeTiles();
+                  const s22 = this._sourcesDirty || this._styleDirty || this._placementDirty;
+                  return s22 || this._repaint ? this.triggerRepaint() : !this.isMoving() && this.loaded() && this.fire(new e2.k("idle")), !this._loaded || this._fullyLoaded || s22 || (this._fullyLoaded = true, e2.bf.mark(e2.bg.fullLoad)), this;
+                }
+                redraw() {
+                  return this.style && (this._frameRequest && (this._frameRequest.abort(), this._frameRequest = null), this._render(0)), this;
+                }
+                remove() {
+                  var t42;
+                  this._hash && this._hash.remove();
+                  for (const t5 of this._controls) t5.onRemove(this);
+                  this._controls = [], this._frameRequest && (this._frameRequest.abort(), this._frameRequest = null), this._renderTaskQueue.clear(), this.painter.destroy(), this.handlers.destroy(), delete this.handlers, this.setStyle(null), "undefined" != typeof window && removeEventListener("online", this._onWindowOnline, false), _2.removeThrottleControl(this._imageQueueHandle), null === (t42 = this._resizeObserver) || void 0 === t42 || t42.disconnect();
+                  const i22 = this.painter.context.gl.getExtension("WEBGL_lose_context");
+                  (null == i22 ? void 0 : i22.loseContext) && i22.loseContext(), this._canvas.removeEventListener("webglcontextrestored", this._contextRestored, false), this._canvas.removeEventListener("webglcontextlost", this._contextLost, false), r2.remove(this._canvasContainer), r2.remove(this._controlContainer), this._container.classList.remove("maplibregl-map"), e2.bf.clearMetrics(), this._removed = true, this.fire(new e2.k("remove"));
+                }
+                triggerRepaint() {
+                  this.style && !this._frameRequest && (this._frameRequest = new AbortController(), o2.frameAsync(this._frameRequest).then((t42) => {
+                    e2.bf.frame(t42), this._frameRequest = null, this._render(t42);
+                  }).catch(() => {
+                  }));
+                }
+                get showTileBoundaries() {
+                  return !!this._showTileBoundaries;
+                }
+                set showTileBoundaries(t42) {
+                  this._showTileBoundaries !== t42 && (this._showTileBoundaries = t42, this._update());
+                }
+                get showPadding() {
+                  return !!this._showPadding;
+                }
+                set showPadding(t42) {
+                  this._showPadding !== t42 && (this._showPadding = t42, this._update());
+                }
+                get showCollisionBoxes() {
+                  return !!this._showCollisionBoxes;
+                }
+                set showCollisionBoxes(t42) {
+                  this._showCollisionBoxes !== t42 && (this._showCollisionBoxes = t42, t42 ? this.style._generateCollisionBoxes() : this._update());
+                }
+                get showOverdrawInspector() {
+                  return !!this._showOverdrawInspector;
+                }
+                set showOverdrawInspector(t42) {
+                  this._showOverdrawInspector !== t42 && (this._showOverdrawInspector = t42, this._update());
+                }
+                get repaint() {
+                  return !!this._repaint;
+                }
+                set repaint(t42) {
+                  this._repaint !== t42 && (this._repaint = t42, this.triggerRepaint());
+                }
+                get vertices() {
+                  return !!this._vertices;
+                }
+                set vertices(t42) {
+                  this._vertices = t42, this._update();
+                }
+                get version() {
+                  return Ls;
+                }
+                getCameraTargetElevation() {
+                  return this.transform.elevation;
+                }
+              }, t4.MapMouseEvent = ka2, t4.MapTouchEvent = La2, t4.MapWheelEvent = Fa2, t4.Marker = Vs, t4.NavigationControl = class {
+                constructor(t42) {
+                  this._updateZoomButtons = () => {
+                    const t5 = this._map.getZoom(), e22 = t5 === this._map.getMaxZoom(), i22 = t5 === this._map.getMinZoom();
+                    this._zoomInButton.disabled = e22, this._zoomOutButton.disabled = i22, this._zoomInButton.setAttribute("aria-disabled", e22.toString()), this._zoomOutButton.setAttribute("aria-disabled", i22.toString());
+                  }, this._rotateCompassArrow = () => {
+                    const t5 = this.options.visualizePitch ? `scale(${1 / Math.pow(Math.cos(this._map.transform.pitch * (Math.PI / 180)), 0.5)}) rotateX(${this._map.transform.pitch}deg) rotateZ(${this._map.transform.angle * (180 / Math.PI)}deg)` : `rotate(${this._map.transform.angle * (180 / Math.PI)}deg)`;
+                    this._compassIcon.style.transform = t5;
+                  }, this._setButtonTitle = (t5, e22) => {
+                    const i22 = this._map._getUIString(`NavigationControl.${e22}`);
+                    t5.title = i22, t5.setAttribute("aria-label", i22);
+                  }, this.options = e2.e({}, Os, t42), this._container = r2.create("div", "maplibregl-ctrl maplibregl-ctrl-group"), this._container.addEventListener("contextmenu", (t5) => t5.preventDefault()), this.options.showZoom && (this._zoomInButton = this._createButton("maplibregl-ctrl-zoom-in", (t5) => this._map.zoomIn({}, { originalEvent: t5 })), r2.create("span", "maplibregl-ctrl-icon", this._zoomInButton).setAttribute("aria-hidden", "true"), this._zoomOutButton = this._createButton("maplibregl-ctrl-zoom-out", (t5) => this._map.zoomOut({}, { originalEvent: t5 })), r2.create("span", "maplibregl-ctrl-icon", this._zoomOutButton).setAttribute("aria-hidden", "true")), this.options.showCompass && (this._compass = this._createButton("maplibregl-ctrl-compass", (t5) => {
+                    this.options.visualizePitch ? this._map.resetNorthPitch({}, { originalEvent: t5 }) : this._map.resetNorth({}, { originalEvent: t5 });
+                  }), this._compassIcon = r2.create("span", "maplibregl-ctrl-icon", this._compass), this._compassIcon.setAttribute("aria-hidden", "true"));
+                }
+                onAdd(t42) {
+                  return this._map = t42, this.options.showZoom && (this._setButtonTitle(this._zoomInButton, "ZoomIn"), this._setButtonTitle(this._zoomOutButton, "ZoomOut"), this._map.on("zoom", this._updateZoomButtons), this._updateZoomButtons()), this.options.showCompass && (this._setButtonTitle(this._compass, "ResetBearing"), this.options.visualizePitch && this._map.on("pitch", this._rotateCompassArrow), this._map.on("rotate", this._rotateCompassArrow), this._rotateCompassArrow(), this._handler = new Ns(this._map, this._compass, this.options.visualizePitch)), this._container;
+                }
+                onRemove() {
+                  r2.remove(this._container), this.options.showZoom && this._map.off("zoom", this._updateZoomButtons), this.options.showCompass && (this.options.visualizePitch && this._map.off("pitch", this._rotateCompassArrow), this._map.off("rotate", this._rotateCompassArrow), this._handler.off(), delete this._handler), delete this._map;
+                }
+                _createButton(t42, e22) {
+                  const i22 = r2.create("button", t42, this._container);
+                  return i22.type = "button", i22.addEventListener("click", e22), i22;
+                }
+              }, t4.Popup = class extends e2.E {
+                constructor(t42) {
+                  super(), this.remove = () => (this._content && r2.remove(this._content), this._container && (r2.remove(this._container), delete this._container), this._map && (this._map.off("move", this._update), this._map.off("move", this._onClose), this._map.off("click", this._onClose), this._map.off("remove", this.remove), this._map.off("mousemove", this._onMouseMove), this._map.off("mouseup", this._onMouseUp), this._map.off("drag", this._onDrag), this._map._canvasContainer.classList.remove("maplibregl-track-pointer"), delete this._map, this.fire(new e2.k("close"))), this), this._onMouseUp = (t5) => {
+                    this._update(t5.point);
+                  }, this._onMouseMove = (t5) => {
+                    this._update(t5.point);
+                  }, this._onDrag = (t5) => {
+                    this._update(t5.point);
+                  }, this._update = (t5) => {
+                    var e22;
+                    if (!this._map || !this._lngLat && !this._trackPointer || !this._content) return;
+                    if (!this._container) {
+                      if (this._container = r2.create("div", "maplibregl-popup", this._map.getContainer()), this._tip = r2.create("div", "maplibregl-popup-tip", this._container), this._container.appendChild(this._content), this.options.className) for (const t6 of this.options.className.split(" ")) this._container.classList.add(t6);
+                      this._closeButton && this._closeButton.setAttribute("aria-label", this._map._getUIString("Popup.Close")), this._trackPointer && this._container.classList.add("maplibregl-popup-track-pointer");
+                    }
+                    if (this.options.maxWidth && this._container.style.maxWidth !== this.options.maxWidth && (this._container.style.maxWidth = this.options.maxWidth), this._lngLat = this._map.transform.renderWorldCopies && !this._trackPointer ? js(this._lngLat, this._flatPos, this._map.transform) : null === (e22 = this._lngLat) || void 0 === e22 ? void 0 : e22.wrap(), this._trackPointer && !t5) return;
+                    const i22 = this._flatPos = this._pos = this._trackPointer && t5 ? t5 : this._map.project(this._lngLat);
+                    this._map.terrain && (this._flatPos = this._trackPointer && t5 ? t5 : this._map.transform.locationPoint(this._lngLat));
+                    let a22 = this.options.anchor;
+                    const s22 = Qs(this.options.offset);
+                    if (!a22) {
+                      const t6 = this._container.offsetWidth, e3 = this._container.offsetHeight;
+                      let o3;
+                      o3 = i22.y + s22.bottom.y < e3 ? ["top"] : i22.y > this._map.transform.height - e3 ? ["bottom"] : [], i22.x < t6 / 2 ? o3.push("left") : i22.x > this._map.transform.width - t6 / 2 && o3.push("right"), a22 = 0 === o3.length ? "bottom" : o3.join("-");
+                    }
+                    let o22 = i22.add(s22[a22]);
+                    this.options.subpixelPositioning || (o22 = o22.round()), r2.setTransform(this._container, `${Zs[a22]} translate(${o22.x}px,${o22.y}px)`), qs(this._container, a22, "popup");
+                  }, this._onClose = () => {
+                    this.remove();
+                  }, this.options = e2.e(Object.create(Js), t42);
+                }
+                addTo(t42) {
+                  return this._map && this.remove(), this._map = t42, this.options.closeOnClick && this._map.on("click", this._onClose), this.options.closeOnMove && this._map.on("move", this._onClose), this._map.on("remove", this.remove), this._update(), this._focusFirstElement(), this._trackPointer ? (this._map.on("mousemove", this._onMouseMove), this._map.on("mouseup", this._onMouseUp), this._container && this._container.classList.add("maplibregl-popup-track-pointer"), this._map._canvasContainer.classList.add("maplibregl-track-pointer")) : this._map.on("move", this._update), this.fire(new e2.k("open")), this;
+                }
+                isOpen() {
+                  return !!this._map;
+                }
+                getLngLat() {
+                  return this._lngLat;
+                }
+                setLngLat(t42) {
+                  return this._lngLat = e2.N.convert(t42), this._pos = null, this._flatPos = null, this._trackPointer = false, this._update(), this._map && (this._map.on("move", this._update), this._map.off("mousemove", this._onMouseMove), this._container && this._container.classList.remove("maplibregl-popup-track-pointer"), this._map._canvasContainer.classList.remove("maplibregl-track-pointer")), this;
+                }
+                trackPointer() {
+                  return this._trackPointer = true, this._pos = null, this._flatPos = null, this._update(), this._map && (this._map.off("move", this._update), this._map.on("mousemove", this._onMouseMove), this._map.on("drag", this._onDrag), this._container && this._container.classList.add("maplibregl-popup-track-pointer"), this._map._canvasContainer.classList.add("maplibregl-track-pointer")), this;
+                }
+                getElement() {
+                  return this._container;
+                }
+                setText(t42) {
+                  return this.setDOMContent(document.createTextNode(t42));
+                }
+                setHTML(t42) {
+                  const e22 = document.createDocumentFragment(), i22 = document.createElement("body");
+                  let a22;
+                  for (i22.innerHTML = t42; a22 = i22.firstChild, a22; ) e22.appendChild(a22);
+                  return this.setDOMContent(e22);
+                }
+                getMaxWidth() {
+                  var t42;
+                  return null === (t42 = this._container) || void 0 === t42 ? void 0 : t42.style.maxWidth;
+                }
+                setMaxWidth(t42) {
+                  return this.options.maxWidth = t42, this._update(), this;
+                }
+                setDOMContent(t42) {
+                  if (this._content) for (; this._content.hasChildNodes(); ) this._content.firstChild && this._content.removeChild(this._content.firstChild);
+                  else this._content = r2.create("div", "maplibregl-popup-content", this._container);
+                  return this._content.appendChild(t42), this._createCloseButton(), this._update(), this._focusFirstElement(), this;
+                }
+                addClassName(t42) {
+                  return this._container && this._container.classList.add(t42), this;
+                }
+                removeClassName(t42) {
+                  return this._container && this._container.classList.remove(t42), this;
+                }
+                setOffset(t42) {
+                  return this.options.offset = t42, this._update(), this;
+                }
+                toggleClassName(t42) {
+                  if (this._container) return this._container.classList.toggle(t42);
+                }
+                setSubpixelPositioning(t42) {
+                  this.options.subpixelPositioning = t42;
+                }
+                _createCloseButton() {
+                  this.options.closeButton && (this._closeButton = r2.create("button", "maplibregl-popup-close-button", this._content), this._closeButton.type = "button", this._closeButton.innerHTML = "&#215;", this._closeButton.addEventListener("click", this._onClose));
+                }
+                _focusFirstElement() {
+                  if (!this.options.focusAfterOpen || !this._container) return;
+                  const t42 = this._container.querySelector(Ys);
+                  t42 && t42.focus();
+                }
+              }, t4.RasterDEMTileSource = K22, t4.RasterTileSource = X2, t4.ScaleControl = class {
+                constructor(t42) {
+                  this._onMove = () => {
+                    Xs(this._map, this._container, this.options);
+                  }, this.setUnit = (t5) => {
+                    this.options.unit = t5, Xs(this._map, this._container, this.options);
+                  }, this.options = Object.assign(Object.assign({}, $s), t42);
+                }
+                getDefaultPosition() {
+                  return "bottom-left";
+                }
+                onAdd(t42) {
+                  return this._map = t42, this._container = r2.create("div", "maplibregl-ctrl maplibregl-ctrl-scale", t42.getContainer()), this._map.on("move", this._onMove), this._onMove(), this._container;
+                }
+                onRemove() {
+                  r2.remove(this._container), this._map.off("move", this._onMove), this._map = void 0;
+                }
+              }, t4.ScrollZoomHandler = us, t4.Style = de2, t4.TerrainControl = class {
+                constructor(t42) {
+                  this._toggleTerrain = () => {
+                    this._map.getTerrain() ? this._map.setTerrain(null) : this._map.setTerrain(this.options), this._updateTerrainIcon();
+                  }, this._updateTerrainIcon = () => {
+                    this._terrainButton.classList.remove("maplibregl-ctrl-terrain"), this._terrainButton.classList.remove("maplibregl-ctrl-terrain-enabled"), this._map.terrain ? (this._terrainButton.classList.add("maplibregl-ctrl-terrain-enabled"), this._terrainButton.title = this._map._getUIString("TerrainControl.Disable")) : (this._terrainButton.classList.add("maplibregl-ctrl-terrain"), this._terrainButton.title = this._map._getUIString("TerrainControl.Enable"));
+                  }, this.options = t42;
+                }
+                onAdd(t42) {
+                  return this._map = t42, this._container = r2.create("div", "maplibregl-ctrl maplibregl-ctrl-group"), this._terrainButton = r2.create("button", "maplibregl-ctrl-terrain", this._container), r2.create("span", "maplibregl-ctrl-icon", this._terrainButton).setAttribute("aria-hidden", "true"), this._terrainButton.type = "button", this._terrainButton.addEventListener("click", this._toggleTerrain), this._updateTerrainIcon(), this._map.on("terrain", this._updateTerrainIcon), this._container;
+                }
+                onRemove() {
+                  r2.remove(this._container), this._map.off("terrain", this._updateTerrainIcon), this._map = void 0;
+                }
+              }, t4.TwoFingersTouchPitchHandler = rs, t4.TwoFingersTouchRotateHandler = ss, t4.TwoFingersTouchZoomHandler = is, t4.TwoFingersTouchZoomRotateHandler = gs, t4.VectorTileSource = $2, t4.VideoSource = tt2, t4.addSourceType = (t42, i22) => e2._(void 0, void 0, void 0, function* () {
+                if (at2(t42)) throw new Error(`A source type called "${t42}" already exists.`);
+                ((t5, e22) => {
+                  it2[t5] = e22;
+                })(t42, i22);
+              }), t4.clearPrewarmedResources = function() {
+                const t42 = B22;
+                t42 && (t42.isPreloaded() && 1 === t42.numActive() ? (t42.release(k2), B22 = null) : console.warn("Could not clear WebWorkers since there are active Map instances that still reference it. The pre-warmed WebWorker pool can only be cleared when all map instances have been removed with map.remove()"));
+              }, t4.getMaxParallelImageRequests = function() {
+                return e2.a.MAX_PARALLEL_IMAGE_REQUESTS;
+              }, t4.getRTLTextPluginStatus = function() {
+                return nt2().getRTLTextPluginStatus();
+              }, t4.getVersion = function() {
+                return to;
+              }, t4.getWorkerCount = function() {
+                return L2.workerCount;
+              }, t4.getWorkerUrl = function() {
+                return e2.a.WORKER_URL;
+              }, t4.importScriptInWorkers = function(t42) {
+                return j2().broadcast("IS", t42);
+              }, t4.prewarm = function() {
+                N2().acquire(k2);
+              }, t4.setMaxParallelImageRequests = function(t42) {
+                e2.a.MAX_PARALLEL_IMAGE_REQUESTS = t42;
+              }, t4.setRTLTextPlugin = function(t42, e22) {
+                return nt2().setRTLTextPlugin(t42, e22);
+              }, t4.setWorkerCount = function(t42) {
+                L2.workerCount = t42;
+              }, t4.setWorkerUrl = function(t42) {
+                e2.a.WORKER_URL = t42;
+              };
+            });
+            var maplibregl$1 = maplibregl2;
+            return maplibregl$1;
+          });
+        }
+      });
+      var require_layers2 = __commonJS({
+        "src/plots/map/layers.js"(exports, module2) {
+          var Lib = require_lib();
+          var sanitizeHTML = require_svg_text_utils().sanitizeHTML;
+          var convertTextOpts = require_convert_text_opts2();
+          var constants = require_constants27();
+          function MapLayer(subplot, index) {
+            this.subplot = subplot;
+            this.uid = subplot.uid + "-" + index;
+            this.index = index;
+            this.idSource = "source-" + this.uid;
+            this.idLayer = constants.layoutLayerPrefix + this.uid;
+            this.sourceType = null;
+            this.source = null;
+            this.layerType = null;
+            this.below = null;
+            this.visible = false;
+          }
+          var proto = MapLayer.prototype;
+          proto.update = function update(opts) {
+            if (!this.visible) {
+              this.updateSource(opts);
+              this.updateLayer(opts);
+            } else if (this.needsNewImage(opts)) {
+              this.updateImage(opts);
+            } else if (this.needsNewSource(opts)) {
+              this.removeLayer();
+              this.updateSource(opts);
+              this.updateLayer(opts);
+            } else if (this.needsNewLayer(opts)) {
+              this.updateLayer(opts);
+            } else {
+              this.updateStyle(opts);
+            }
+            this.visible = isVisible(opts);
+          };
+          proto.needsNewImage = function(opts) {
+            var map2 = this.subplot.map;
+            return map2.getSource(this.idSource) && this.sourceType === "image" && opts.sourcetype === "image" && (this.source !== opts.source || JSON.stringify(this.coordinates) !== JSON.stringify(opts.coordinates));
+          };
+          proto.needsNewSource = function(opts) {
+            return this.sourceType !== opts.sourcetype || JSON.stringify(this.source) !== JSON.stringify(opts.source) || this.layerType !== opts.type;
+          };
+          proto.needsNewLayer = function(opts) {
+            return this.layerType !== opts.type || this.below !== this.subplot.belowLookup["layout-" + this.index];
+          };
+          proto.lookupBelow = function() {
+            return this.subplot.belowLookup["layout-" + this.index];
+          };
+          proto.updateImage = function(opts) {
+            var map2 = this.subplot.map;
+            map2.getSource(this.idSource).updateImage({
+              url: opts.source,
+              coordinates: opts.coordinates
+            });
+            var _below = this.findFollowingMapLayerId(this.lookupBelow());
+            if (_below !== null) {
+              this.subplot.map.moveLayer(this.idLayer, _below);
+            }
+          };
+          proto.updateSource = function(opts) {
+            var map2 = this.subplot.map;
+            if (map2.getSource(this.idSource)) map2.removeSource(this.idSource);
+            this.sourceType = opts.sourcetype;
+            this.source = opts.source;
+            if (!isVisible(opts)) return;
+            var sourceOpts = convertSourceOpts(opts);
+            map2.addSource(this.idSource, sourceOpts);
+          };
+          proto.findFollowingMapLayerId = function(below) {
+            if (below === "traces") {
+              var mapLayers = this.subplot.getMapLayers();
+              for (var i2 = 0; i2 < mapLayers.length; i2++) {
+                var layerId = mapLayers[i2].id;
+                if (typeof layerId === "string" && layerId.indexOf(constants.traceLayerPrefix) === 0) {
+                  below = layerId;
+                  break;
+                }
+              }
+            }
+            return below;
+          };
+          proto.updateLayer = function(opts) {
+            var subplot = this.subplot;
+            var convertedOpts = convertOpts(opts);
+            var below = this.lookupBelow();
+            var _below = this.findFollowingMapLayerId(below);
+            this.removeLayer();
+            if (isVisible(opts)) {
+              subplot.addLayer({
+                id: this.idLayer,
+                source: this.idSource,
+                "source-layer": opts.sourcelayer || "",
+                type: opts.type,
+                minzoom: opts.minzoom,
+                maxzoom: opts.maxzoom,
+                layout: convertedOpts.layout,
+                paint: convertedOpts.paint
+              }, _below);
+            }
+            this.layerType = opts.type;
+            this.below = below;
+          };
+          proto.updateStyle = function(opts) {
+            if (isVisible(opts)) {
+              var convertedOpts = convertOpts(opts);
+              this.subplot.setOptions(this.idLayer, "setLayoutProperty", convertedOpts.layout);
+              this.subplot.setOptions(this.idLayer, "setPaintProperty", convertedOpts.paint);
+            }
+          };
+          proto.removeLayer = function() {
+            var map2 = this.subplot.map;
+            if (map2.getLayer(this.idLayer)) {
+              map2.removeLayer(this.idLayer);
+            }
+          };
+          proto.dispose = function() {
+            var map2 = this.subplot.map;
+            if (map2.getLayer(this.idLayer)) map2.removeLayer(this.idLayer);
+            if (map2.getSource(this.idSource)) map2.removeSource(this.idSource);
+          };
+          function isVisible(opts) {
+            if (!opts.visible) return false;
+            var source2 = opts.source;
+            if (Array.isArray(source2) && source2.length > 0) {
+              for (var i2 = 0; i2 < source2.length; i2++) {
+                if (typeof source2[i2] !== "string" || source2[i2].length === 0) {
+                  return false;
+                }
+              }
+              return true;
+            }
+            return Lib.isPlainObject(source2) || typeof source2 === "string" && source2.length > 0;
+          }
+          function convertOpts(opts) {
+            var layout = {};
+            var paint = {};
+            switch (opts.type) {
+              case "circle":
+                Lib.extendFlat(paint, {
+                  "circle-radius": opts.circle.radius,
+                  "circle-color": opts.color,
+                  "circle-opacity": opts.opacity
+                });
+                break;
+              case "line":
+                Lib.extendFlat(paint, {
+                  "line-width": opts.line.width,
+                  "line-color": opts.color,
+                  "line-opacity": opts.opacity,
+                  "line-dasharray": opts.line.dash
+                });
+                break;
+              case "fill":
+                Lib.extendFlat(paint, {
+                  "fill-color": opts.color,
+                  "fill-outline-color": opts.fill.outlinecolor,
+                  "fill-opacity": opts.opacity
+                  // no way to pass specify outline width at the moment
+                });
+                break;
+              case "symbol":
+                var symbol = opts.symbol;
+                var textOpts = convertTextOpts(symbol.textposition, symbol.iconsize);
+                Lib.extendFlat(layout, {
+                  "icon-image": symbol.icon + "-15",
+                  "icon-size": symbol.iconsize / 10,
+                  "text-field": symbol.text,
+                  "text-size": symbol.textfont.size,
+                  "text-anchor": textOpts.anchor,
+                  "text-offset": textOpts.offset,
+                  "symbol-placement": symbol.placement
+                  // TODO font family
+                  // 'text-font': symbol.textfont.family.split(', '),
+                });
+                Lib.extendFlat(paint, {
+                  "icon-color": opts.color,
+                  "text-color": symbol.textfont.color,
+                  "text-opacity": opts.opacity
+                });
+                break;
+              case "raster":
+                Lib.extendFlat(paint, {
+                  "raster-fade-duration": 0,
+                  "raster-opacity": opts.opacity
+                });
+                break;
+            }
+            return {
+              layout,
+              paint
+            };
+          }
+          function convertSourceOpts(opts) {
+            var sourceType = opts.sourcetype;
+            var source2 = opts.source;
+            var sourceOpts = { type: sourceType };
+            var field;
+            if (sourceType === "geojson") {
+              field = "data";
+            } else if (sourceType === "vector") {
+              field = typeof source2 === "string" ? "url" : "tiles";
+            } else if (sourceType === "raster") {
+              field = "tiles";
+              sourceOpts.tileSize = 256;
+            } else if (sourceType === "image") {
+              field = "url";
+              sourceOpts.coordinates = opts.coordinates;
+            }
+            sourceOpts[field] = source2;
+            if (opts.sourceattribution) {
+              sourceOpts.attribution = sanitizeHTML(opts.sourceattribution);
+            }
+            return sourceOpts;
+          }
+          module2.exports = function createMapLayer(subplot, index, opts) {
+            var mapLayer = new MapLayer(subplot, index);
+            mapLayer.update(opts);
+            return mapLayer;
+          };
+        }
+      });
+      var require_map2 = __commonJS({
+        "src/plots/map/map.js"(exports, module2) {
+          var maplibregl2 = require_maplibre_gl2();
+          var Lib = require_lib();
+          var geoUtils = require_geo_location_utils();
+          var Registry = require_registry();
+          var Axes = require_axes();
+          var dragElement = require_dragelement();
+          var Fx = require_fx();
+          var dragHelpers = require_helpers5();
+          var drawMode = dragHelpers.drawMode;
+          var selectMode = dragHelpers.selectMode;
+          var prepSelect = require_selections().prepSelect;
+          var clearOutline = require_selections().clearOutline;
+          var clearSelectionsCache = require_selections().clearSelectionsCache;
+          var selectOnClick = require_selections().selectOnClick;
+          var constants = require_constants27();
+          var createMapLayer = require_layers2();
+          function Map22(gd2, id2) {
+            this.id = id2;
+            this.gd = gd2;
+            var fullLayout = gd2._fullLayout;
+            var context = gd2._context;
+            this.container = fullLayout._glcontainer.node();
+            this.isStatic = context.staticPlot;
+            this.uid = fullLayout._uid + "-" + this.id;
+            this.div = null;
+            this.xaxis = null;
+            this.yaxis = null;
+            this.createFramework(fullLayout);
+            this.map = null;
+            this.styleObj = null;
+            this.traceHash = {};
+            this.layerList = [];
+            this.belowLookup = {};
+            this.dragging = false;
+            this.wheeling = false;
+          }
+          var proto = Map22.prototype;
+          proto.plot = function(calcData, fullLayout, promises) {
+            var self2 = this;
+            var promise;
+            if (!self2.map) {
+              promise = new Promise(function(resolve, reject) {
+                self2.createMap(calcData, fullLayout, resolve, reject);
+              });
+            } else {
+              promise = new Promise(function(resolve, reject) {
+                self2.updateMap(calcData, fullLayout, resolve, reject);
+              });
+            }
+            promises.push(promise);
+          };
+          proto.createMap = function(calcData, fullLayout, resolve, reject) {
+            var self2 = this;
+            var opts = fullLayout[self2.id];
+            var styleObj = self2.styleObj = getStyleObj(opts.style);
+            var bounds = opts.bounds;
+            var maxBounds = bounds ? [[bounds.west, bounds.south], [bounds.east, bounds.north]] : null;
+            var map2 = self2.map = new maplibregl2.Map({
+              container: self2.div,
+              style: styleObj.style,
+              center: convertCenter(opts.center),
+              zoom: opts.zoom,
+              bearing: opts.bearing,
+              pitch: opts.pitch,
+              maxBounds,
+              interactive: !self2.isStatic,
+              preserveDrawingBuffer: self2.isStatic,
+              doubleClickZoom: false,
+              boxZoom: false,
+              attributionControl: false
+            }).addControl(new maplibregl2.AttributionControl({
+              compact: true
+            }));
+            var requestedIcons = {};
+            map2.on("styleimagemissing", function(e2) {
+              var id2 = e2.id;
+              if (!requestedIcons[id2] && id2.includes("-15")) {
+                requestedIcons[id2] = true;
+                var img = new Image(15, 15);
+                img.onload = function() {
+                  map2.addImage(id2, img);
+                };
+                img.crossOrigin = "Anonymous";
+                img.src = "https://unpkg.com/maki@2.1.0/icons/" + id2 + ".svg";
+              }
+            });
+            map2.setTransformRequest(function(url) {
+              url = url.replace("https://fonts.openmaptiles.org/Open Sans Extrabold", "https://fonts.openmaptiles.org/Open Sans Extra Bold");
+              url = url.replace("https://tiles.basemaps.cartocdn.com/fonts/Open Sans Extrabold", "https://fonts.openmaptiles.org/Open Sans Extra Bold");
+              url = url.replace("https://fonts.openmaptiles.org/Open Sans Regular,Arial Unicode MS Regular", "https://fonts.openmaptiles.org/Klokantech Noto Sans Regular");
+              return {
+                url
+              };
+            });
+            map2._canvas.style.left = "0px";
+            map2._canvas.style.top = "0px";
+            self2.rejectOnError(reject);
+            if (!self2.isStatic) {
+              self2.initFx(calcData, fullLayout);
+            }
+            var promises = [];
+            promises.push(new Promise(function(resolve2) {
+              map2.once("load", resolve2);
+            }));
+            promises = promises.concat(geoUtils.fetchTraceGeoData(calcData));
+            Promise.all(promises).then(function() {
+              self2.fillBelowLookup(calcData, fullLayout);
+              self2.updateData(calcData);
+              self2.updateLayout(fullLayout);
+              self2.resolveOnRender(resolve);
+            }).catch(reject);
+          };
+          proto.updateMap = function(calcData, fullLayout, resolve, reject) {
+            var self2 = this;
+            var map2 = self2.map;
+            var opts = fullLayout[this.id];
+            self2.rejectOnError(reject);
+            var promises = [];
+            var styleObj = getStyleObj(opts.style);
+            if (JSON.stringify(self2.styleObj) !== JSON.stringify(styleObj)) {
+              self2.styleObj = styleObj;
+              map2.setStyle(styleObj.style);
+              self2.traceHash = {};
+              promises.push(new Promise(function(resolve2) {
+                map2.once("styledata", resolve2);
+              }));
+            }
+            promises = promises.concat(geoUtils.fetchTraceGeoData(calcData));
+            Promise.all(promises).then(function() {
+              self2.fillBelowLookup(calcData, fullLayout);
+              self2.updateData(calcData);
+              self2.updateLayout(fullLayout);
+              self2.resolveOnRender(resolve);
+            }).catch(reject);
+          };
+          proto.fillBelowLookup = function(calcData, fullLayout) {
+            var opts = fullLayout[this.id];
+            var layers = opts.layers;
+            var i2, val;
+            var belowLookup = this.belowLookup = {};
+            var hasTraceAtTop = false;
+            for (i2 = 0; i2 < calcData.length; i2++) {
+              var trace = calcData[i2][0].trace;
+              var _module = trace._module;
+              if (typeof trace.below === "string") {
+                val = trace.below;
+              } else if (_module.getBelow) {
+                val = _module.getBelow(trace, this);
+              }
+              if (val === "") {
+                hasTraceAtTop = true;
+              }
+              belowLookup["trace-" + trace.uid] = val || "";
+            }
+            for (i2 = 0; i2 < layers.length; i2++) {
+              var item = layers[i2];
+              if (typeof item.below === "string") {
+                val = item.below;
+              } else if (hasTraceAtTop) {
+                val = "traces";
+              } else {
+                val = "";
+              }
+              belowLookup["layout-" + i2] = val;
+            }
+            var val2list = {};
+            var k2, id2;
+            for (k2 in belowLookup) {
+              val = belowLookup[k2];
+              if (val2list[val]) {
+                val2list[val].push(k2);
+              } else {
+                val2list[val] = [k2];
+              }
+            }
+            for (val in val2list) {
+              var list = val2list[val];
+              if (list.length > 1) {
+                for (i2 = 0; i2 < list.length; i2++) {
+                  k2 = list[i2];
+                  if (k2.indexOf("trace-") === 0) {
+                    id2 = k2.split("trace-")[1];
+                    if (this.traceHash[id2]) {
+                      this.traceHash[id2].below = null;
+                    }
+                  } else if (k2.indexOf("layout-") === 0) {
+                    id2 = k2.split("layout-")[1];
+                    if (this.layerList[id2]) {
+                      this.layerList[id2].below = null;
+                    }
+                  }
+                }
+              }
+            }
+          };
+          var traceType2orderIndex = {
+            choroplethmap: 0,
+            densitymap: 1,
+            scattermap: 2
+          };
+          proto.updateData = function(calcData) {
+            var traceHash = this.traceHash;
+            var traceObj, trace, i2, j2;
+            var calcDataSorted = calcData.slice().sort(function(a2, b2) {
+              return traceType2orderIndex[a2[0].trace.type] - traceType2orderIndex[b2[0].trace.type];
+            });
+            for (i2 = 0; i2 < calcDataSorted.length; i2++) {
+              var calcTrace = calcDataSorted[i2];
+              trace = calcTrace[0].trace;
+              traceObj = traceHash[trace.uid];
+              var didUpdate = false;
+              if (traceObj) {
+                if (traceObj.type === trace.type) {
+                  traceObj.update(calcTrace);
+                  didUpdate = true;
+                } else {
+                  traceObj.dispose();
+                }
+              }
+              if (!didUpdate && trace._module) {
+                traceHash[trace.uid] = trace._module.plot(this, calcTrace);
+              }
+            }
+            var ids = Object.keys(traceHash);
+            idLoop:
+              for (i2 = 0; i2 < ids.length; i2++) {
+                var id2 = ids[i2];
+                for (j2 = 0; j2 < calcData.length; j2++) {
+                  trace = calcData[j2][0].trace;
+                  if (id2 === trace.uid) continue idLoop;
+                }
+                traceObj = traceHash[id2];
+                traceObj.dispose();
+                delete traceHash[id2];
+              }
+          };
+          proto.updateLayout = function(fullLayout) {
+            var map2 = this.map;
+            var opts = fullLayout[this.id];
+            if (!this.dragging && !this.wheeling) {
+              map2.setCenter(convertCenter(opts.center));
+              map2.setZoom(opts.zoom);
+              map2.setBearing(opts.bearing);
+              map2.setPitch(opts.pitch);
+            }
+            this.updateLayers(fullLayout);
+            this.updateFramework(fullLayout);
+            this.updateFx(fullLayout);
+            this.map.resize();
+            if (this.gd._context._scrollZoom.map) {
+              map2.scrollZoom.enable();
+            } else {
+              map2.scrollZoom.disable();
+            }
+          };
+          proto.resolveOnRender = function(resolve) {
+            var map2 = this.map;
+            map2.on("render", function onRender() {
+              if (map2.loaded()) {
+                map2.off("render", onRender);
+                setTimeout(resolve, 10);
+              }
+            });
+          };
+          proto.rejectOnError = function(reject) {
+            var map2 = this.map;
+            function handler() {
+              reject(new Error(constants.mapOnErrorMsg));
+            }
+            map2.once("error", handler);
+            map2.once("style.error", handler);
+            map2.once("source.error", handler);
+            map2.once("tile.error", handler);
+            map2.once("layer.error", handler);
+          };
+          proto.createFramework = function(fullLayout) {
+            var self2 = this;
+            var div = self2.div = document.createElement("div");
+            div.id = self2.uid;
+            div.style.position = "absolute";
+            self2.container.appendChild(div);
+            self2.xaxis = {
+              _id: "x",
+              c2p: function(v2) {
+                return self2.project(v2).x;
+              }
+            };
+            self2.yaxis = {
+              _id: "y",
+              c2p: function(v2) {
+                return self2.project(v2).y;
+              }
+            };
+            self2.updateFramework(fullLayout);
+            self2.mockAxis = {
+              type: "linear",
+              showexponent: "all",
+              exponentformat: "B"
+            };
+            Axes.setConvert(self2.mockAxis, fullLayout);
+          };
+          proto.initFx = function(calcData, fullLayout) {
+            var self2 = this;
+            var gd2 = self2.gd;
+            var map2 = self2.map;
+            map2.on("moveend", function(evt) {
+              if (!self2.map) return;
+              var fullLayoutNow = gd2._fullLayout;
+              if (evt.originalEvent || self2.wheeling) {
+                var optsNow = fullLayoutNow[self2.id];
+                Registry.call("_storeDirectGUIEdit", gd2.layout, fullLayoutNow._preGUI, self2.getViewEdits(optsNow));
+                var viewNow = self2.getView();
+                optsNow._input.center = optsNow.center = viewNow.center;
+                optsNow._input.zoom = optsNow.zoom = viewNow.zoom;
+                optsNow._input.bearing = optsNow.bearing = viewNow.bearing;
+                optsNow._input.pitch = optsNow.pitch = viewNow.pitch;
+                gd2.emit("plotly_relayout", self2.getViewEditsWithDerived(viewNow));
+              }
+              if (evt.originalEvent && evt.originalEvent.type === "mouseup") {
+                self2.dragging = false;
+              } else if (self2.wheeling) {
+                self2.wheeling = false;
+              }
+              if (fullLayoutNow && fullLayoutNow._rehover) {
+                fullLayoutNow._rehover();
+              }
+            });
+            map2.on("wheel", function() {
+              self2.wheeling = true;
+            });
+            map2.on("mousemove", function(evt) {
+              var bb2 = self2.div.getBoundingClientRect();
+              var xy = [
+                evt.originalEvent.offsetX,
+                evt.originalEvent.offsetY
+              ];
+              evt.target.getBoundingClientRect = function() {
+                return bb2;
+              };
+              self2.xaxis.p2c = function() {
+                return map2.unproject(xy).lng;
+              };
+              self2.yaxis.p2c = function() {
+                return map2.unproject(xy).lat;
+              };
+              gd2._fullLayout._rehover = function() {
+                if (gd2._fullLayout._hoversubplot === self2.id && gd2._fullLayout[self2.id]) {
+                  Fx.hover(gd2, evt, self2.id);
+                }
+              };
+              Fx.hover(gd2, evt, self2.id);
+              gd2._fullLayout._hoversubplot = self2.id;
+            });
+            function unhover() {
+              Fx.loneUnhover(fullLayout._hoverlayer);
+            }
+            map2.on("dragstart", function() {
+              self2.dragging = true;
+              unhover();
+            });
+            map2.on("zoomstart", unhover);
+            map2.on("mouseout", function() {
+              gd2._fullLayout._hoversubplot = null;
+            });
+            function emitUpdate() {
+              var viewNow = self2.getView();
+              gd2.emit("plotly_relayouting", self2.getViewEditsWithDerived(viewNow));
+            }
+            map2.on("drag", emitUpdate);
+            map2.on("zoom", emitUpdate);
+            map2.on("dblclick", function() {
+              var optsNow = gd2._fullLayout[self2.id];
+              Registry.call("_storeDirectGUIEdit", gd2.layout, gd2._fullLayout._preGUI, self2.getViewEdits(optsNow));
+              var viewInitial = self2.viewInitial;
+              map2.setCenter(convertCenter(viewInitial.center));
+              map2.setZoom(viewInitial.zoom);
+              map2.setBearing(viewInitial.bearing);
+              map2.setPitch(viewInitial.pitch);
+              var viewNow = self2.getView();
+              optsNow._input.center = optsNow.center = viewNow.center;
+              optsNow._input.zoom = optsNow.zoom = viewNow.zoom;
+              optsNow._input.bearing = optsNow.bearing = viewNow.bearing;
+              optsNow._input.pitch = optsNow.pitch = viewNow.pitch;
+              gd2.emit("plotly_doubleclick", null);
+              gd2.emit("plotly_relayout", self2.getViewEditsWithDerived(viewNow));
+            });
+            self2.clearOutline = function() {
+              clearSelectionsCache(self2.dragOptions);
+              clearOutline(self2.dragOptions.gd);
+            };
+            self2.onClickInPanFn = function(dragOptions) {
+              return function(evt) {
+                var clickMode = gd2._fullLayout.clickmode;
+                if (clickMode.indexOf("select") > -1) {
+                  selectOnClick(evt.originalEvent, gd2, [self2.xaxis], [self2.yaxis], self2.id, dragOptions);
+                }
+                if (clickMode.indexOf("event") > -1) {
+                  Fx.click(gd2, evt.originalEvent);
+                }
+              };
+            };
+          };
+          proto.updateFx = function(fullLayout) {
+            var self2 = this;
+            var map2 = self2.map;
+            var gd2 = self2.gd;
+            if (self2.isStatic) return;
+            function invert2(pxpy) {
+              var obj = self2.map.unproject(pxpy);
+              return [obj.lng, obj.lat];
+            }
+            var dragMode = fullLayout.dragmode;
+            var fillRangeItems;
+            fillRangeItems = function(eventData, poly) {
+              if (poly.isRect) {
+                var ranges = eventData.range = {};
+                ranges[self2.id] = [
+                  invert2([poly.xmin, poly.ymin]),
+                  invert2([poly.xmax, poly.ymax])
+                ];
+              } else {
+                var dataPts = eventData.lassoPoints = {};
+                dataPts[self2.id] = poly.map(invert2);
+              }
+            };
+            var oldDragOptions = self2.dragOptions;
+            self2.dragOptions = Lib.extendDeep(oldDragOptions || {}, {
+              dragmode: fullLayout.dragmode,
+              element: self2.div,
+              gd: gd2,
+              plotinfo: {
+                id: self2.id,
+                domain: fullLayout[self2.id].domain,
+                xaxis: self2.xaxis,
+                yaxis: self2.yaxis,
+                fillRangeItems
+              },
+              xaxes: [self2.xaxis],
+              yaxes: [self2.yaxis],
+              subplot: self2.id
+            });
+            map2.off("click", self2.onClickInPanHandler);
+            if (selectMode(dragMode) || drawMode(dragMode)) {
+              map2.dragPan.disable();
+              map2.on("zoomstart", self2.clearOutline);
+              self2.dragOptions.prepFn = function(e2, startX, startY) {
+                prepSelect(e2, startX, startY, self2.dragOptions, dragMode);
+              };
+              dragElement.init(self2.dragOptions);
+            } else {
+              map2.dragPan.enable();
+              map2.off("zoomstart", self2.clearOutline);
+              self2.div.onmousedown = null;
+              self2.div.ontouchstart = null;
+              self2.div.removeEventListener("touchstart", self2.div._ontouchstart);
+              self2.onClickInPanHandler = self2.onClickInPanFn(self2.dragOptions);
+              map2.on("click", self2.onClickInPanHandler);
+            }
+          };
+          proto.updateFramework = function(fullLayout) {
+            var domain = fullLayout[this.id].domain;
+            var size = fullLayout._size;
+            var style = this.div.style;
+            style.width = size.w * (domain.x[1] - domain.x[0]) + "px";
+            style.height = size.h * (domain.y[1] - domain.y[0]) + "px";
+            style.left = size.l + domain.x[0] * size.w + "px";
+            style.top = size.t + (1 - domain.y[1]) * size.h + "px";
+            this.xaxis._offset = size.l + domain.x[0] * size.w;
+            this.xaxis._length = size.w * (domain.x[1] - domain.x[0]);
+            this.yaxis._offset = size.t + (1 - domain.y[1]) * size.h;
+            this.yaxis._length = size.h * (domain.y[1] - domain.y[0]);
+          };
+          proto.updateLayers = function(fullLayout) {
+            var opts = fullLayout[this.id];
+            var layers = opts.layers;
+            var layerList = this.layerList;
+            var i2;
+            if (layers.length !== layerList.length) {
+              for (i2 = 0; i2 < layerList.length; i2++) {
+                layerList[i2].dispose();
+              }
+              layerList = this.layerList = [];
+              for (i2 = 0; i2 < layers.length; i2++) {
+                layerList.push(createMapLayer(this, i2, layers[i2]));
+              }
+            } else {
+              for (i2 = 0; i2 < layers.length; i2++) {
+                layerList[i2].update(layers[i2]);
+              }
+            }
+          };
+          proto.destroy = function() {
+            if (this.map) {
+              this.map.remove();
+              this.map = null;
+              this.container.removeChild(this.div);
+            }
+          };
+          proto.toImage = function() {
+            this.map.stop();
+            return this.map.getCanvas().toDataURL();
+          };
+          proto.setOptions = function(id2, methodName, opts) {
+            for (var k2 in opts) {
+              this.map[methodName](id2, k2, opts[k2]);
+            }
+          };
+          proto.getMapLayers = function() {
+            return this.map.getStyle().layers;
+          };
+          proto.addLayer = function(opts, below) {
+            var map2 = this.map;
+            if (typeof below === "string") {
+              if (below === "") {
+                map2.addLayer(opts, below);
+                return;
+              }
+              var mapLayers = this.getMapLayers();
+              for (var i2 = 0; i2 < mapLayers.length; i2++) {
+                if (below === mapLayers[i2].id) {
+                  map2.addLayer(opts, below);
+                  return;
+                }
+              }
+              Lib.warn([
+                "Trying to add layer with *below* value",
+                below,
+                "referencing a layer that does not exist",
+                "or that does not yet exist."
+              ].join(" "));
+            }
+            map2.addLayer(opts);
+          };
+          proto.project = function(v2) {
+            return this.map.project(new maplibregl2.LngLat(v2[0], v2[1]));
+          };
+          proto.getView = function() {
+            var map2 = this.map;
+            var mapCenter = map2.getCenter();
+            var lon = mapCenter.lng;
+            var lat = mapCenter.lat;
+            var center = { lon, lat };
+            var canvas2 = map2.getCanvas();
+            var w2 = parseInt(canvas2.style.width);
+            var h2 = parseInt(canvas2.style.height);
+            return {
+              center,
+              zoom: map2.getZoom(),
+              bearing: map2.getBearing(),
+              pitch: map2.getPitch(),
+              _derived: {
+                coordinates: [
+                  map2.unproject([0, 0]).toArray(),
+                  map2.unproject([w2, 0]).toArray(),
+                  map2.unproject([w2, h2]).toArray(),
+                  map2.unproject([0, h2]).toArray()
+                ]
+              }
+            };
+          };
+          proto.getViewEdits = function(cont) {
+            var id2 = this.id;
+            var keys = ["center", "zoom", "bearing", "pitch"];
+            var obj = {};
+            for (var i2 = 0; i2 < keys.length; i2++) {
+              var k2 = keys[i2];
+              obj[id2 + "." + k2] = cont[k2];
+            }
+            return obj;
+          };
+          proto.getViewEditsWithDerived = function(cont) {
+            var id2 = this.id;
+            var obj = this.getViewEdits(cont);
+            obj[id2 + "._derived"] = cont._derived;
+            return obj;
+          };
+          function getStyleObj(val) {
+            var styleObj = {};
+            if (Lib.isPlainObject(val)) {
+              styleObj.id = val.id;
+              styleObj.style = val;
+            } else if (typeof val === "string") {
+              styleObj.id = val;
+              if (constants.stylesMap[val]) {
+                styleObj.style = constants.stylesMap[val];
+              } else {
+                styleObj.style = val;
+              }
+            } else {
+              styleObj.id = constants.styleValueDflt;
+              styleObj.style = convertStyleVal(constants.styleValueDflt);
+            }
+            styleObj.transition = { duration: 0, delay: 0 };
+            return styleObj;
+          }
+          function convertStyleVal(val) {
+            return constants.styleUrlPrefix + val + "-" + constants.styleUrlSuffix;
+          }
+          function convertCenter(center) {
+            return [center.lon, center.lat];
+          }
+          module2.exports = Map22;
+        }
+      });
+      var require_layout_defaults18 = __commonJS({
+        "src/plots/map/layout_defaults.js"(exports, module2) {
+          var Lib = require_lib();
+          var handleSubplotDefaults = require_subplot_defaults();
+          var handleArrayContainerDefaults = require_array_container_defaults();
+          var layoutAttributes = require_layout_attributes20();
+          module2.exports = function supplyLayoutDefaults(layoutIn, layoutOut, fullData) {
+            handleSubplotDefaults(layoutIn, layoutOut, fullData, {
+              type: "map",
+              attributes: layoutAttributes,
+              handleDefaults,
+              partition: "y"
+            });
+          };
+          function handleDefaults(containerIn, containerOut, coerce) {
+            coerce("style");
+            coerce("center.lon");
+            coerce("center.lat");
+            coerce("zoom");
+            coerce("bearing");
+            coerce("pitch");
+            var west = coerce("bounds.west");
+            var east = coerce("bounds.east");
+            var south = coerce("bounds.south");
+            var north = coerce("bounds.north");
+            if (west === void 0 || east === void 0 || south === void 0 || north === void 0) {
+              delete containerOut.bounds;
+            }
+            handleArrayContainerDefaults(containerIn, containerOut, {
+              name: "layers",
+              handleItemDefaults: handleLayerDefaults
+            });
+            containerOut._input = containerIn;
+          }
+          function handleLayerDefaults(layerIn, layerOut) {
+            function coerce(attr, dflt) {
+              return Lib.coerce(layerIn, layerOut, layoutAttributes.layers, attr, dflt);
+            }
+            var visible = coerce("visible");
+            if (visible) {
+              var sourceType = coerce("sourcetype");
+              var mustBeRasterLayer = sourceType === "raster" || sourceType === "image";
+              coerce("source");
+              coerce("sourceattribution");
+              if (sourceType === "vector") {
+                coerce("sourcelayer");
+              }
+              if (sourceType === "image") {
+                coerce("coordinates");
+              }
+              var typeDflt;
+              if (mustBeRasterLayer) typeDflt = "raster";
+              var type = coerce("type", typeDflt);
+              if (mustBeRasterLayer && type !== "raster") {
+                type = layerOut.type = "raster";
+                Lib.log("Source types *raster* and *image* must drawn *raster* layer type.");
+              }
+              coerce("below");
+              coerce("color");
+              coerce("opacity");
+              coerce("minzoom");
+              coerce("maxzoom");
+              if (type === "circle") {
+                coerce("circle.radius");
+              }
+              if (type === "line") {
+                coerce("line.width");
+                coerce("line.dash");
+              }
+              if (type === "fill") {
+                coerce("fill.outlinecolor");
+              }
+              if (type === "symbol") {
+                coerce("symbol.icon");
+                coerce("symbol.iconsize");
+                coerce("symbol.text");
+                Lib.coerceFont(coerce, "symbol.textfont", void 0, {
+                  noFontVariant: true,
+                  noFontShadow: true,
+                  noFontLineposition: true,
+                  noFontTextcase: true
+                });
+                coerce("symbol.textposition");
+                coerce("symbol.placement");
+              }
+            }
+          }
+        }
+      });
+      var require_map3 = __commonJS({
+        "src/plots/map/index.js"(exports) {
+          var Lib = require_lib();
+          var strTranslate = Lib.strTranslate;
+          var strScale = Lib.strScale;
+          var getSubplotCalcData = require_get_data().getSubplotCalcData;
+          var xmlnsNamespaces = require_xmlns_namespaces();
+          var d3 = require_d3();
+          var Drawing = require_drawing();
+          var svgTextUtils = require_svg_text_utils();
+          var Map22 = require_map2();
+          var MAP = "map";
+          exports.name = MAP;
+          exports.attr = "subplot";
+          exports.idRoot = MAP;
+          exports.idRegex = exports.attrRegex = Lib.counterRegex(MAP);
+          exports.attributes = {
+            subplot: {
+              valType: "subplotid",
+              dflt: "map",
+              editType: "calc"
+            }
+          };
+          exports.layoutAttributes = require_layout_attributes20();
+          exports.supplyLayoutDefaults = require_layout_defaults18();
+          exports.plot = function plot(gd2) {
+            var fullLayout = gd2._fullLayout;
+            var calcData = gd2.calcdata;
+            var mapIds = fullLayout._subplots[MAP];
+            for (var i2 = 0; i2 < mapIds.length; i2++) {
+              var id2 = mapIds[i2];
+              var subplotCalcData = getSubplotCalcData(calcData, MAP, id2);
+              var opts = fullLayout[id2];
+              var map2 = opts._subplot;
+              if (!map2) {
+                map2 = new Map22(gd2, id2);
+                fullLayout[id2]._subplot = map2;
+              }
+              if (!map2.viewInitial) {
+                map2.viewInitial = {
+                  center: Lib.extendFlat({}, opts.center),
+                  zoom: opts.zoom,
+                  bearing: opts.bearing,
+                  pitch: opts.pitch
+                };
+              }
+              map2.plot(subplotCalcData, fullLayout, gd2._promises);
+            }
+          };
+          exports.clean = function(newFullData, newFullLayout, oldFullData, oldFullLayout) {
+            var oldMapKeys = oldFullLayout._subplots[MAP] || [];
+            for (var i2 = 0; i2 < oldMapKeys.length; i2++) {
+              var oldMapKey = oldMapKeys[i2];
+              if (!newFullLayout[oldMapKey] && !!oldFullLayout[oldMapKey]._subplot) {
+                oldFullLayout[oldMapKey]._subplot.destroy();
+              }
+            }
+          };
+          exports.toSVG = function(gd2) {
+            var fullLayout = gd2._fullLayout;
+            var subplotIds = fullLayout._subplots[MAP];
+            var size = fullLayout._size;
+            for (var i2 = 0; i2 < subplotIds.length; i2++) {
+              var opts = fullLayout[subplotIds[i2]];
+              var domain = opts.domain;
+              var map2 = opts._subplot;
+              var imageData = map2.toImage("png");
+              var image = fullLayout._glimages.append("svg:image");
+              image.attr({
+                xmlns: xmlnsNamespaces.svg,
+                "xlink:href": imageData,
+                x: size.l + size.w * domain.x[0],
+                y: size.t + size.h * (1 - domain.y[1]),
+                width: size.w * (domain.x[1] - domain.x[0]),
+                height: size.h * (domain.y[1] - domain.y[0]),
+                preserveAspectRatio: "none"
+              });
+              var subplotDiv = d3.select(opts._subplot.div);
+              var attributions = subplotDiv.select(".maplibregl-ctrl-attrib").text().replace("Improve this map", "");
+              var attributionGroup = fullLayout._glimages.append("g");
+              var attributionText = attributionGroup.append("text");
+              attributionText.text(attributions).classed("static-attribution", true).attr({
+                "font-size": 12,
+                "font-family": "Arial",
+                color: "rgba(0, 0, 0, 0.75)",
+                "text-anchor": "end",
+                "data-unformatted": attributions
+              });
+              var bBox = Drawing.bBox(attributionText.node());
+              var maxWidth = size.w * (domain.x[1] - domain.x[0]);
+              if (bBox.width > maxWidth / 2) {
+                var multilineAttributions = attributions.split("|").join("<br>");
+                attributionText.text(multilineAttributions).attr("data-unformatted", multilineAttributions).call(svgTextUtils.convertToTspans, gd2);
+                bBox = Drawing.bBox(attributionText.node());
+              }
+              attributionText.attr("transform", strTranslate(-3, -bBox.height + 8));
+              attributionGroup.insert("rect", ".static-attribution").attr({
+                x: -bBox.width - 6,
+                y: -bBox.height - 3,
+                width: bBox.width + 6,
+                height: bBox.height + 3,
+                fill: "rgba(255, 255, 255, 0.75)"
+              });
+              var scaleRatio = 1;
+              if (bBox.width + 6 > maxWidth) scaleRatio = maxWidth / (bBox.width + 6);
+              var offset = [size.l + size.w * domain.x[1], size.t + size.h * (1 - domain.y[0])];
+              attributionGroup.attr("transform", strTranslate(offset[0], offset[1]) + strScale(scaleRatio));
+            }
+          };
+          exports.updateFx = function(gd2) {
+            var fullLayout = gd2._fullLayout;
+            var subplotIds = fullLayout._subplots[MAP];
+            for (var i2 = 0; i2 < subplotIds.length; i2++) {
+              var subplotObj = fullLayout[subplotIds[i2]]._subplot;
+              subplotObj.updateFx(fullLayout);
+            }
+          };
+        }
+      });
+      var require_scattermap = __commonJS({
+        "src/traces/scattermap/index.js"(exports, module2) {
+          module2.exports = {
+            attributes: require_attributes57(),
+            supplyDefaults: require_defaults53(),
+            colorbar: require_marker_colorbar(),
+            formatLabels: require_format_labels6(),
+            calc: require_calc27(),
+            plot: require_plot26(),
+            hoverPoints: require_hover20().hoverPoints,
+            eventData: require_event_data13(),
+            selectPoints: require_select10(),
+            styleOnSelect: function(_2, cd2) {
+              if (cd2) {
+                var trace = cd2[0].trace;
+                trace._glTrace.update(cd2);
+              }
+            },
+            moduleType: "trace",
+            name: "scattermap",
+            basePlotModule: require_map3(),
+            categories: ["map", "gl", "symbols", "showLegend", "scatter-like"],
+            meta: {}
+          };
+        }
+      });
+      var require_scattermap2 = __commonJS({
+        "lib/scattermap.js"(exports, module2) {
+          module2.exports = require_scattermap();
+        }
+      });
+      var require_attributes58 = __commonJS({
+        "src/traces/choroplethmap/attributes.js"(exports, module2) {
+          var choroplethAttrs = require_attributes49();
+          var colorScaleAttrs = require_attributes8();
+          var { hovertemplateAttrs, templatefallbackAttrs } = require_template_attributes();
+          var baseAttrs = require_attributes2();
+          var extendFlat = require_extend().extendFlat;
+          module2.exports = extendFlat(
+            {
+              locations: {
+                valType: "data_array",
+                editType: "calc"
+              },
+              // TODO
+              // Maybe start with only one value (that we could name e.g. 'geojson-id'),
+              // but eventually:
+              // - we could also support for our own dist/topojson/*
+              //   .. and locationmode: choroplethAttrs.locationmode,
+              z: {
+                valType: "data_array",
+                editType: "calc"
+              },
+              // TODO maybe we could also set a "key" to dig out values out of the
+              // GeoJSON feature `properties` fields?
+              geojson: {
+                valType: "any",
+                editType: "calc"
+              },
+              featureidkey: extendFlat({}, choroplethAttrs.featureidkey, {}),
+              // TODO agree on name / behaviour
+              //
+              // 'below' is used currently for layout.map.layers,
+              // even though it's not very plotly-esque.
+              //
+              // Note also, that the map-gl style don't all have the same layers,
+              // see https://codepen.io/etpinard/pen/ydVMwM for full list
+              below: {
+                valType: "string",
+                editType: "plot"
+              },
+              text: choroplethAttrs.text,
+              hovertext: choroplethAttrs.hovertext,
+              marker: {
+                line: {
+                  color: extendFlat({}, choroplethAttrs.marker.line.color, { editType: "plot" }),
+                  width: extendFlat({}, choroplethAttrs.marker.line.width, { editType: "plot" }),
+                  editType: "calc"
+                },
+                // TODO maybe having a dflt less than 1, together with `below:''` would be better?
+                opacity: extendFlat({}, choroplethAttrs.marker.opacity, { editType: "plot" }),
+                editType: "calc"
+              },
+              selected: {
+                marker: {
+                  opacity: extendFlat({}, choroplethAttrs.selected.marker.opacity, { editType: "plot" }),
+                  editType: "plot"
+                },
+                editType: "plot"
+              },
+              unselected: {
+                marker: {
+                  opacity: extendFlat({}, choroplethAttrs.unselected.marker.opacity, { editType: "plot" }),
+                  editType: "plot"
+                },
+                editType: "plot"
+              },
+              hoverinfo: choroplethAttrs.hoverinfo,
+              hovertemplate: hovertemplateAttrs({}, { keys: ["properties"] }),
+              hovertemplatefallback: templatefallbackAttrs(),
+              showlegend: extendFlat({}, baseAttrs.showlegend, { dflt: false })
+            },
+            colorScaleAttrs("", {
+              cLetter: "z",
+              editTypeOverride: "calc"
+            })
+          );
+        }
+      });
+      var require_defaults54 = __commonJS({
+        "src/traces/choroplethmap/defaults.js"(exports, module2) {
+          var Lib = require_lib();
+          var colorscaleDefaults = require_defaults2();
+          var attributes = require_attributes58();
+          module2.exports = function supplyDefaults(traceIn, traceOut, defaultColor, layout) {
+            function coerce(attr, dflt) {
+              return Lib.coerce(traceIn, traceOut, attributes, attr, dflt);
+            }
+            var locations = coerce("locations");
+            var z2 = coerce("z");
+            var geojson = coerce("geojson");
+            if (!Lib.isArrayOrTypedArray(locations) || !locations.length || !Lib.isArrayOrTypedArray(z2) || !z2.length || !(typeof geojson === "string" && geojson !== "" || Lib.isPlainObject(geojson))) {
+              traceOut.visible = false;
+              return;
+            }
+            coerce("featureidkey");
+            traceOut._length = Math.min(locations.length, z2.length);
+            coerce("below");
+            coerce("text");
+            coerce("hovertext");
+            coerce("hovertemplate");
+            coerce("hovertemplatefallback");
+            var mlw = coerce("marker.line.width");
+            if (mlw) coerce("marker.line.color");
+            coerce("marker.opacity");
+            colorscaleDefaults(traceIn, traceOut, layout, coerce, { prefix: "", cLetter: "z" });
+            Lib.coerceSelectionMarkerOpacity(traceOut, coerce);
+          };
+        }
+      });
+      var require_convert15 = __commonJS({
+        "src/traces/choroplethmap/convert.js"(exports, module2) {
+          var isNumeric = require_fast_isnumeric();
+          var Lib = require_lib();
+          var Colorscale = require_colorscale();
+          var Drawing = require_drawing();
+          var makeBlank = require_geojson_utils().makeBlank;
+          var geoUtils = require_geo_location_utils();
+          function convert(calcTrace) {
+            var trace = calcTrace[0].trace;
+            var isVisible = trace.visible === true && trace._length !== 0;
+            var fill = {
+              layout: { visibility: "none" },
+              paint: {}
+            };
+            var line = {
+              layout: { visibility: "none" },
+              paint: {}
+            };
+            var opts = trace._opts = {
+              fill,
+              line,
+              geojson: makeBlank()
+            };
+            if (!isVisible) return opts;
+            var features = geoUtils.extractTraceFeature(calcTrace);
+            if (!features) return opts;
+            var sclFunc = Colorscale.makeColorScaleFuncFromTrace(trace);
+            var marker = trace.marker;
+            var markerLine = marker.line || {};
+            var opacityFn;
+            if (Lib.isArrayOrTypedArray(marker.opacity)) {
+              opacityFn = function(d2) {
+                var mo = d2.mo;
+                return isNumeric(mo) ? +Lib.constrain(mo, 0, 1) : 0;
+              };
+            }
+            var lineColorFn;
+            if (Lib.isArrayOrTypedArray(markerLine.color)) {
+              lineColorFn = function(d2) {
+                return d2.mlc;
+              };
+            }
+            var lineWidthFn;
+            if (Lib.isArrayOrTypedArray(markerLine.width)) {
+              lineWidthFn = function(d2) {
+                return d2.mlw;
+              };
+            }
+            for (var i2 = 0; i2 < calcTrace.length; i2++) {
+              var cdi = calcTrace[i2];
+              var fOut = cdi.fOut;
+              if (fOut) {
+                var props = fOut.properties;
+                props.fc = sclFunc(cdi.z);
+                if (opacityFn) props.mo = opacityFn(cdi);
+                if (lineColorFn) props.mlc = lineColorFn(cdi);
+                if (lineWidthFn) props.mlw = lineWidthFn(cdi);
+                cdi.ct = props.ct;
+                cdi._polygons = geoUtils.feature2polygons(fOut);
+              }
+            }
+            var opacitySetting = opacityFn ? { type: "identity", property: "mo" } : marker.opacity;
+            Lib.extendFlat(fill.paint, {
+              "fill-color": { type: "identity", property: "fc" },
+              "fill-opacity": opacitySetting
+            });
+            Lib.extendFlat(line.paint, {
+              "line-color": lineColorFn ? { type: "identity", property: "mlc" } : markerLine.color,
+              "line-width": lineWidthFn ? { type: "identity", property: "mlw" } : markerLine.width,
+              "line-opacity": opacitySetting
+            });
+            fill.layout.visibility = "visible";
+            line.layout.visibility = "visible";
+            opts.geojson = { type: "FeatureCollection", features };
+            convertOnSelect(calcTrace);
+            return opts;
+          }
+          function convertOnSelect(calcTrace) {
+            var trace = calcTrace[0].trace;
+            var opts = trace._opts;
+            var opacitySetting;
+            if (trace.selectedpoints) {
+              var fns = Drawing.makeSelectedPointStyleFns(trace);
+              for (var i2 = 0; i2 < calcTrace.length; i2++) {
+                var cdi = calcTrace[i2];
+                if (cdi.fOut) {
+                  cdi.fOut.properties.mo2 = fns.selectedOpacityFn(cdi);
+                }
+              }
+              opacitySetting = { type: "identity", property: "mo2" };
+            } else {
+              opacitySetting = Lib.isArrayOrTypedArray(trace.marker.opacity) ? { type: "identity", property: "mo" } : trace.marker.opacity;
+            }
+            Lib.extendFlat(opts.fill.paint, { "fill-opacity": opacitySetting });
+            Lib.extendFlat(opts.line.paint, { "line-opacity": opacitySetting });
+            return opts;
+          }
+          module2.exports = {
+            convert,
+            convertOnSelect
+          };
+        }
+      });
+      var require_plot27 = __commonJS({
+        "src/traces/choroplethmap/plot.js"(exports, module2) {
+          var convert = require_convert15().convert;
+          var convertOnSelect = require_convert15().convertOnSelect;
+          var LAYER_PREFIX = require_constants27().traceLayerPrefix;
+          function ChoroplethMap(subplot, uid2) {
+            this.type = "choroplethmap";
+            this.subplot = subplot;
+            this.uid = uid2;
+            this.sourceId = "source-" + uid2;
+            this.layerList = [
+              ["fill", LAYER_PREFIX + uid2 + "-fill"],
+              ["line", LAYER_PREFIX + uid2 + "-line"]
+            ];
+            this.below = null;
+          }
+          var proto = ChoroplethMap.prototype;
+          proto.update = function(calcTrace) {
+            this._update(convert(calcTrace));
+            calcTrace[0].trace._glTrace = this;
+          };
+          proto.updateOnSelect = function(calcTrace) {
+            this._update(convertOnSelect(calcTrace));
+          };
+          proto._update = function(optsAll) {
+            var subplot = this.subplot;
+            var layerList = this.layerList;
+            var below = subplot.belowLookup["trace-" + this.uid];
+            subplot.map.getSource(this.sourceId).setData(optsAll.geojson);
+            if (below !== this.below) {
+              this._removeLayers();
+              this._addLayers(optsAll, below);
+              this.below = below;
+            }
+            for (var i2 = 0; i2 < layerList.length; i2++) {
+              var item = layerList[i2];
+              var k2 = item[0];
+              var id2 = item[1];
+              var opts = optsAll[k2];
+              subplot.setOptions(id2, "setLayoutProperty", opts.layout);
+              if (opts.layout.visibility === "visible") {
+                subplot.setOptions(id2, "setPaintProperty", opts.paint);
+              }
+            }
+          };
+          proto._addLayers = function(optsAll, below) {
+            var subplot = this.subplot;
+            var layerList = this.layerList;
+            var sourceId = this.sourceId;
+            for (var i2 = 0; i2 < layerList.length; i2++) {
+              var item = layerList[i2];
+              var k2 = item[0];
+              var opts = optsAll[k2];
+              subplot.addLayer({
+                type: k2,
+                id: item[1],
+                source: sourceId,
+                layout: opts.layout,
+                paint: opts.paint
+              }, below);
+            }
+          };
+          proto._removeLayers = function() {
+            var map2 = this.subplot.map;
+            var layerList = this.layerList;
+            for (var i2 = layerList.length - 1; i2 >= 0; i2--) {
+              map2.removeLayer(layerList[i2][1]);
+            }
+          };
+          proto.dispose = function() {
+            var map2 = this.subplot.map;
+            this._removeLayers();
+            map2.removeSource(this.sourceId);
+          };
+          module2.exports = function createChoroplethMap(subplot, calcTrace) {
+            var trace = calcTrace[0].trace;
+            var choroplethMap = new ChoroplethMap(subplot, trace.uid);
+            var sourceId = choroplethMap.sourceId;
+            var optsAll = convert(calcTrace);
+            var below = choroplethMap.below = subplot.belowLookup["trace-" + trace.uid];
+            subplot.map.addSource(sourceId, {
+              type: "geojson",
+              data: optsAll.geojson
+            });
+            choroplethMap._addLayers(optsAll, below);
+            calcTrace[0].trace._glTrace = choroplethMap;
+            return choroplethMap;
+          };
+        }
+      });
+      var require_choroplethmap = __commonJS({
+        "src/traces/choroplethmap/index.js"(exports, module2) {
+          module2.exports = {
+            attributes: require_attributes58(),
+            supplyDefaults: require_defaults54(),
+            colorbar: require_colorbar2(),
+            calc: require_calc28(),
+            plot: require_plot27(),
+            hoverPoints: require_hover15(),
+            eventData: require_event_data10(),
+            selectPoints: require_select6(),
+            styleOnSelect: function(_2, cd2) {
+              if (cd2) {
+                var trace = cd2[0].trace;
+                trace._glTrace.updateOnSelect(cd2);
+              }
+            },
+            getBelow: function(trace, subplot) {
+              var mapLayers = subplot.getMapLayers();
+              for (var i2 = mapLayers.length - 2; i2 >= 0; i2--) {
+                var layerId = mapLayers[i2].id;
+                if (typeof layerId === "string" && layerId.indexOf("water") === 0) {
+                  for (var j2 = i2 + 1; j2 < mapLayers.length; j2++) {
+                    layerId = mapLayers[j2].id;
+                    if (typeof layerId === "string" && layerId.indexOf("plotly-") === -1) {
+                      return layerId;
+                    }
+                  }
+                }
+              }
+            },
+            moduleType: "trace",
+            name: "choroplethmap",
+            basePlotModule: require_map3(),
+            categories: ["map", "gl", "noOpacity", "showLegend"],
+            meta: {
+              hr_name: "choropleth_map"
+            }
+          };
+        }
+      });
+      var require_choroplethmap2 = __commonJS({
+        "lib/choroplethmap.js"(exports, module2) {
+          module2.exports = require_choroplethmap();
+        }
+      });
+      var require_attributes59 = __commonJS({
+        "src/traces/densitymap/attributes.js"(exports, module2) {
+          var colorScaleAttrs = require_attributes8();
+          var { hovertemplateAttrs, templatefallbackAttrs } = require_template_attributes();
+          var baseAttrs = require_attributes2();
+          var scatterMapAttrs = require_attributes57();
+          var extendFlat = require_extend().extendFlat;
+          module2.exports = extendFlat(
+            {
+              lon: scatterMapAttrs.lon,
+              lat: scatterMapAttrs.lat,
+              z: {
+                valType: "data_array",
+                editType: "calc"
+              },
+              radius: {
+                valType: "number",
+                editType: "plot",
+                arrayOk: true,
+                min: 1,
+                dflt: 30
+              },
+              below: {
+                valType: "string",
+                editType: "plot"
+              },
+              text: scatterMapAttrs.text,
+              hovertext: scatterMapAttrs.hovertext,
+              hoverinfo: extendFlat({}, baseAttrs.hoverinfo, {
+                flags: ["lon", "lat", "z", "text", "name"]
+              }),
+              hovertemplate: hovertemplateAttrs(),
+              hovertemplatefallback: templatefallbackAttrs(),
+              showlegend: extendFlat({}, baseAttrs.showlegend, { dflt: false })
+            },
+            colorScaleAttrs("", {
+              cLetter: "z",
+              editTypeOverride: "calc"
+            })
+          );
+        }
+      });
+      var require_defaults55 = __commonJS({
+        "src/traces/densitymap/defaults.js"(exports, module2) {
+          var Lib = require_lib();
+          var colorscaleDefaults = require_defaults2();
+          var attributes = require_attributes59();
+          module2.exports = function supplyDefaults(traceIn, traceOut, defaultColor, layout) {
+            function coerce(attr, dflt) {
+              return Lib.coerce(traceIn, traceOut, attributes, attr, dflt);
+            }
+            var lon = coerce("lon") || [];
+            var lat = coerce("lat") || [];
+            var len2 = Math.min(lon.length, lat.length);
+            if (!len2) {
+              traceOut.visible = false;
+              return;
+            }
+            traceOut._length = len2;
+            coerce("z");
+            coerce("radius");
+            coerce("below");
+            coerce("text");
+            coerce("hovertext");
+            coerce("hovertemplate");
+            coerce("hovertemplatefallback");
+            colorscaleDefaults(traceIn, traceOut, layout, coerce, { prefix: "", cLetter: "z" });
+          };
+        }
+      });
+      var require_calc34 = __commonJS({
+        "src/traces/densitymap/calc.js"(exports, module2) {
+          var isNumeric = require_fast_isnumeric();
+          var isArrayOrTypedArray = require_lib().isArrayOrTypedArray;
+          var BADNUM = require_numerical().BADNUM;
+          var colorscaleCalc = require_calc();
+          var _2 = require_lib()._;
+          module2.exports = function calc(gd2, trace) {
+            var len2 = trace._length;
+            var calcTrace = new Array(len2);
+            var z2 = trace.z;
+            var hasZ = isArrayOrTypedArray(z2) && z2.length;
+            for (var i2 = 0; i2 < len2; i2++) {
+              var cdi = calcTrace[i2] = {};
+              var lon = trace.lon[i2];
+              var lat = trace.lat[i2];
+              cdi.lonlat = isNumeric(lon) && isNumeric(lat) ? [+lon, +lat] : [BADNUM, BADNUM];
+              if (hasZ) {
+                var zi2 = z2[i2];
+                cdi.z = isNumeric(zi2) ? zi2 : BADNUM;
+              }
+            }
+            colorscaleCalc(gd2, trace, {
+              vals: hasZ ? z2 : [0, 1],
+              containerStr: "",
+              cLetter: "z"
+            });
+            if (len2) {
+              calcTrace[0].t = {
+                labels: {
+                  lat: _2(gd2, "lat:") + " ",
+                  lon: _2(gd2, "lon:") + " "
+                }
+              };
+            }
+            return calcTrace;
+          };
+        }
+      });
+      var require_convert16 = __commonJS({
+        "src/traces/densitymap/convert.js"(exports, module2) {
+          var isNumeric = require_fast_isnumeric();
+          var Lib = require_lib();
+          var Color2 = require_color();
+          var Colorscale = require_colorscale();
+          var BADNUM = require_numerical().BADNUM;
+          var makeBlank = require_geojson_utils().makeBlank;
+          module2.exports = function convert(calcTrace) {
+            var trace = calcTrace[0].trace;
+            var isVisible = trace.visible === true && trace._length !== 0;
+            var heatmap = {
+              layout: { visibility: "none" },
+              paint: {}
+            };
+            var opts = trace._opts = {
+              heatmap,
+              geojson: makeBlank()
+            };
+            if (!isVisible) return opts;
+            var features = [];
+            var i2;
+            var z2 = trace.z;
+            var radius = trace.radius;
+            var hasZ = Lib.isArrayOrTypedArray(z2) && z2.length;
+            var hasArrayRadius = Lib.isArrayOrTypedArray(radius);
+            for (i2 = 0; i2 < calcTrace.length; i2++) {
+              var cdi = calcTrace[i2];
+              var lonlat = cdi.lonlat;
+              if (lonlat[0] !== BADNUM) {
+                var props = {};
+                if (hasZ) {
+                  var zi2 = cdi.z;
+                  props.z = zi2 !== BADNUM ? zi2 : 0;
+                }
+                if (hasArrayRadius) {
+                  props.r = isNumeric(radius[i2]) && radius[i2] > 0 ? +radius[i2] : 0;
+                }
+                features.push({
+                  type: "Feature",
+                  geometry: { type: "Point", coordinates: lonlat },
+                  properties: props
+                });
+              }
+            }
+            var cOpts = Colorscale.extractOpts(trace);
+            var scl = cOpts.reversescale ? Colorscale.flipScale(cOpts.colorscale) : cOpts.colorscale;
+            var scl01 = scl[0][1];
+            var color0 = Color2.opacity(scl01) < 1 ? scl01 : Color2.addOpacity(scl01, 0);
+            var heatmapColor = [
+              "interpolate",
+              ["linear"],
+              ["heatmap-density"],
+              0,
+              color0
+            ];
+            for (i2 = 1; i2 < scl.length; i2++) {
+              heatmapColor.push(scl[i2][0], scl[i2][1]);
+            }
+            var zExp = [
+              "interpolate",
+              ["linear"],
+              ["get", "z"],
+              cOpts.min,
+              0,
+              cOpts.max,
+              1
+            ];
+            Lib.extendFlat(opts.heatmap.paint, {
+              "heatmap-weight": hasZ ? zExp : 1 / (cOpts.max - cOpts.min),
+              "heatmap-color": heatmapColor,
+              "heatmap-radius": hasArrayRadius ? { type: "identity", property: "r" } : trace.radius,
+              "heatmap-opacity": trace.opacity
+            });
+            opts.geojson = { type: "FeatureCollection", features };
+            opts.heatmap.layout.visibility = "visible";
+            return opts;
+          };
+        }
+      });
+      var require_plot28 = __commonJS({
+        "src/traces/densitymap/plot.js"(exports, module2) {
+          var convert = require_convert16();
+          var LAYER_PREFIX = require_constants27().traceLayerPrefix;
+          function DensityMap(subplot, uid2) {
+            this.type = "densitymap";
+            this.subplot = subplot;
+            this.uid = uid2;
+            this.sourceId = "source-" + uid2;
+            this.layerList = [
+              ["heatmap", LAYER_PREFIX + uid2 + "-heatmap"]
+            ];
+            this.below = null;
+          }
+          var proto = DensityMap.prototype;
+          proto.update = function(calcTrace) {
+            var subplot = this.subplot;
+            var layerList = this.layerList;
+            var optsAll = convert(calcTrace);
+            var below = subplot.belowLookup["trace-" + this.uid];
+            subplot.map.getSource(this.sourceId).setData(optsAll.geojson);
+            if (below !== this.below) {
+              this._removeLayers();
+              this._addLayers(optsAll, below);
+              this.below = below;
+            }
+            for (var i2 = 0; i2 < layerList.length; i2++) {
+              var item = layerList[i2];
+              var k2 = item[0];
+              var id2 = item[1];
+              var opts = optsAll[k2];
+              subplot.setOptions(id2, "setLayoutProperty", opts.layout);
+              if (opts.layout.visibility === "visible") {
+                subplot.setOptions(id2, "setPaintProperty", opts.paint);
+              }
+            }
+          };
+          proto._addLayers = function(optsAll, below) {
+            var subplot = this.subplot;
+            var layerList = this.layerList;
+            var sourceId = this.sourceId;
+            for (var i2 = 0; i2 < layerList.length; i2++) {
+              var item = layerList[i2];
+              var k2 = item[0];
+              var opts = optsAll[k2];
+              subplot.addLayer({
+                type: k2,
+                id: item[1],
+                source: sourceId,
+                layout: opts.layout,
+                paint: opts.paint
+              }, below);
+            }
+          };
+          proto._removeLayers = function() {
+            var map2 = this.subplot.map;
+            var layerList = this.layerList;
+            for (var i2 = layerList.length - 1; i2 >= 0; i2--) {
+              map2.removeLayer(layerList[i2][1]);
+            }
+          };
+          proto.dispose = function() {
+            var map2 = this.subplot.map;
+            this._removeLayers();
+            map2.removeSource(this.sourceId);
+          };
+          module2.exports = function createDensityMap(subplot, calcTrace) {
+            var trace = calcTrace[0].trace;
+            var densityMap = new DensityMap(subplot, trace.uid);
+            var sourceId = densityMap.sourceId;
+            var optsAll = convert(calcTrace);
+            var below = densityMap.below = subplot.belowLookup["trace-" + trace.uid];
+            subplot.map.addSource(sourceId, {
+              type: "geojson",
+              data: optsAll.geojson
+            });
+            densityMap._addLayers(optsAll, below);
+            return densityMap;
+          };
+        }
+      });
+      var require_hover21 = __commonJS({
+        "src/traces/densitymap/hover.js"(exports, module2) {
+          var Axes = require_axes();
+          var scatterMapHoverPoints = require_hover20().hoverPoints;
+          var getExtraText = require_hover20().getExtraText;
+          module2.exports = function hoverPoints(pointData, xval, yval) {
+            var pts = scatterMapHoverPoints(pointData, xval, yval);
+            if (!pts) return;
+            var newPointData = pts[0];
+            var cd2 = newPointData.cd;
+            var trace = cd2[0].trace;
+            var di2 = cd2[newPointData.index];
+            delete newPointData.color;
+            if ("z" in di2) {
+              var ax = newPointData.subplot.mockAxis;
+              newPointData.z = di2.z;
+              newPointData.zLabel = Axes.tickText(ax, ax.c2l(di2.z), "hover").text;
+            }
+            newPointData.extraText = getExtraText(trace, di2, cd2[0].t.labels);
+            return [newPointData];
+          };
+        }
+      });
+      var require_event_data14 = __commonJS({
+        "src/traces/densitymap/event_data.js"(exports, module2) {
+          module2.exports = function eventData(out, pt2) {
+            out.lon = pt2.lon;
+            out.lat = pt2.lat;
+            out.z = pt2.z;
+            return out;
+          };
+        }
+      });
+      var require_densitymap = __commonJS({
+        "src/traces/densitymap/index.js"(exports, module2) {
+          module2.exports = {
+            attributes: require_attributes59(),
+            supplyDefaults: require_defaults55(),
+            colorbar: require_colorbar2(),
+            formatLabels: require_format_labels6(),
+            calc: require_calc34(),
+            plot: require_plot28(),
+            hoverPoints: require_hover21(),
+            eventData: require_event_data14(),
+            getBelow: function(trace, subplot) {
+              var mapLayers = subplot.getMapLayers();
+              for (var i2 = 0; i2 < mapLayers.length; i2++) {
+                var layer = mapLayers[i2];
+                var layerId = layer.id;
+                if (layer.type === "symbol" && typeof layerId === "string" && layerId.indexOf("plotly-") === -1) {
+                  return layerId;
+                }
+              }
+            },
+            moduleType: "trace",
+            name: "densitymap",
+            basePlotModule: require_map3(),
+            categories: ["map", "gl", "showLegend"],
+            meta: {
+              hr_name: "density_map"
+            }
+          };
+        }
+      });
+      var require_densitymap2 = __commonJS({
+        "lib/densitymap.js"(exports, module2) {
+          module2.exports = require_densitymap();
+        }
+      });
+      var require_attributes60 = __commonJS({
+        "src/traces/sankey/attributes.js"(exports, module2) {
+          var fontAttrs = require_font_attributes();
+          var baseAttrs = require_attributes2();
+          var colorAttrs = require_attributes3();
+          var fxAttrs = require_attributes();
+          var domainAttrs = require_domain().attributes;
+          var { hovertemplateAttrs, templatefallbackAttrs } = require_template_attributes();
+          var colorAttributes = require_attributes8();
+          var templatedArray = require_plot_template().templatedArray;
+          var descriptionOnlyNumbers = require_axis_format_attributes().descriptionOnlyNumbers;
+          var extendFlat = require_extend().extendFlat;
+          var overrideAll = require_edit_types().overrideAll;
+          module2.exports = overrideAll(
+            {
+              hoverinfo: extendFlat({}, baseAttrs.hoverinfo, {
+                flags: [],
+                arrayOk: false
+              }),
+              hoverlabel: fxAttrs.hoverlabel,
+              domain: domainAttrs({ name: "sankey", trace: true }),
+              orientation: {
+                valType: "enumerated",
+                values: ["v", "h"],
+                dflt: "h"
+              },
+              valueformat: {
+                valType: "string",
+                dflt: ".3s",
+                description: descriptionOnlyNumbers("value")
+              },
+              valuesuffix: {
+                valType: "string",
+                dflt: ""
+              },
+              arrangement: {
+                valType: "enumerated",
+                values: ["snap", "perpendicular", "freeform", "fixed"],
+                dflt: "snap"
+              },
+              textfont: fontAttrs({
+                autoShadowDflt: true
+              }),
+              // Remove top-level customdata
+              customdata: void 0,
+              node: {
+                label: {
+                  valType: "data_array",
+                  dflt: []
+                },
+                groups: {
+                  valType: "info_array",
+                  impliedEdits: { x: [], y: [] },
+                  dimensions: 2,
+                  freeLength: true,
+                  dflt: [],
+                  items: { valType: "number", editType: "calc" }
+                },
+                x: {
+                  valType: "data_array",
+                  dflt: []
+                },
+                y: {
+                  valType: "data_array",
+                  dflt: []
+                },
+                color: {
+                  valType: "color",
+                  arrayOk: true
+                },
+                customdata: {
+                  valType: "data_array",
+                  editType: "calc"
+                },
+                line: {
+                  color: {
+                    valType: "color",
+                    dflt: colorAttrs.defaultLine,
+                    arrayOk: true
+                  },
+                  width: {
+                    valType: "number",
+                    min: 0,
+                    dflt: 0.5,
+                    arrayOk: true
+                  }
+                },
+                pad: {
+                  valType: "number",
+                  arrayOk: false,
+                  min: 0,
+                  dflt: 20
+                },
+                thickness: {
+                  valType: "number",
+                  arrayOk: false,
+                  min: 1,
+                  dflt: 20
+                },
+                hoverinfo: {
+                  valType: "enumerated",
+                  values: ["all", "none", "skip"],
+                  dflt: "all"
+                },
+                hoverlabel: fxAttrs.hoverlabel,
+                // needs editType override,
+                hovertemplate: hovertemplateAttrs(
+                  {},
+                  {
+                    keys: ["value", "label"]
+                  }
+                ),
+                hovertemplatefallback: templatefallbackAttrs(),
+                align: {
+                  valType: "enumerated",
+                  values: ["justify", "left", "right", "center"],
+                  dflt: "justify"
+                }
+              },
+              link: {
+                arrowlen: {
+                  valType: "number",
+                  min: 0,
+                  dflt: 0
+                },
+                label: {
+                  valType: "data_array",
+                  dflt: []
+                },
+                color: {
+                  valType: "color",
+                  arrayOk: true
+                },
+                hovercolor: {
+                  valType: "color",
+                  arrayOk: true
+                },
+                customdata: {
+                  valType: "data_array",
+                  editType: "calc"
+                },
+                line: {
+                  color: {
+                    valType: "color",
+                    dflt: colorAttrs.defaultLine,
+                    arrayOk: true
+                  },
+                  width: {
+                    valType: "number",
+                    min: 0,
+                    dflt: 0,
+                    arrayOk: true
+                  }
+                },
+                source: {
+                  valType: "data_array",
+                  dflt: []
+                },
+                target: {
+                  valType: "data_array",
+                  dflt: []
+                },
+                value: {
+                  valType: "data_array",
+                  dflt: []
+                },
+                hoverinfo: {
+                  valType: "enumerated",
+                  values: ["all", "none", "skip"],
+                  dflt: "all"
+                },
+                hoverlabel: fxAttrs.hoverlabel,
+                // needs editType override,
+                hovertemplate: hovertemplateAttrs(
+                  {},
+                  {
+                    keys: ["value", "label"]
+                  }
+                ),
+                hovertemplatefallback: templatefallbackAttrs(),
+                colorscales: templatedArray("concentrationscales", {
+                  editType: "calc",
+                  label: {
+                    valType: "string",
+                    editType: "calc",
+                    dflt: ""
+                  },
+                  cmax: {
+                    valType: "number",
+                    editType: "calc",
+                    dflt: 1
+                  },
+                  cmin: {
+                    valType: "number",
+                    editType: "calc",
+                    dflt: 0
+                  },
+                  colorscale: extendFlat(colorAttributes().colorscale, {
+                    dflt: [
+                      [0, "white"],
+                      [1, "black"]
+                    ]
+                  })
+                })
+              }
+            },
+            "calc",
+            "nested"
+          );
+        }
+      });
+      var require_defaults56 = __commonJS({
+        "src/traces/sankey/defaults.js"(exports, module2) {
+          var Lib = require_lib();
+          var attributes = require_attributes60();
+          var Color2 = require_color();
+          var tinycolor = require_tinycolor();
+          var handleDomainDefaults = require_domain().defaults;
+          var handleHoverLabelDefaults = require_hoverlabel_defaults();
+          var Template = require_plot_template();
+          var handleArrayContainerDefaults = require_array_container_defaults();
+          module2.exports = function supplyDefaults(traceIn, traceOut, defaultColor, layout) {
+            function coerce(attr, dflt) {
+              return Lib.coerce(traceIn, traceOut, attributes, attr, dflt);
+            }
+            var hoverlabelDefault = Lib.extendDeep(layout.hoverlabel, traceIn.hoverlabel);
+            var nodeIn = traceIn.node;
+            var nodeOut = Template.newContainer(traceOut, "node");
+            function coerceNode(attr, dflt) {
+              return Lib.coerce(nodeIn, nodeOut, attributes.node, attr, dflt);
+            }
+            coerceNode("label");
+            coerceNode("groups");
+            coerceNode("x");
+            coerceNode("y");
+            coerceNode("pad");
+            coerceNode("thickness");
+            coerceNode("line.color");
+            coerceNode("line.width");
+            coerceNode("hoverinfo", traceIn.hoverinfo);
+            handleHoverLabelDefaults(nodeIn, nodeOut, coerceNode, hoverlabelDefault);
+            coerceNode("hovertemplate");
+            coerceNode("align");
+            var colors = layout.colorway;
+            var defaultNodePalette = function(i2) {
+              return colors[i2 % colors.length];
+            };
+            coerceNode("color", nodeOut.label.map(function(d2, i2) {
+              return Color2.addOpacity(defaultNodePalette(i2), 0.8);
+            }));
+            coerceNode("customdata");
+            var linkIn = traceIn.link || {};
+            var linkOut = Template.newContainer(traceOut, "link");
+            function coerceLink(attr, dflt) {
+              return Lib.coerce(linkIn, linkOut, attributes.link, attr, dflt);
+            }
+            coerceLink("label");
+            coerceLink("arrowlen");
+            coerceLink("source");
+            coerceLink("target");
+            coerceLink("value");
+            coerceLink("line.color");
+            coerceLink("line.width");
+            coerceLink("hoverinfo", traceIn.hoverinfo);
+            handleHoverLabelDefaults(linkIn, linkOut, coerceLink, hoverlabelDefault);
+            coerceLink("hovertemplate");
+            var darkBG = tinycolor(layout.paper_bgcolor).getLuminance() < 0.333;
+            var defaultLinkColor = darkBG ? "rgba(255, 255, 255, 0.6)" : "rgba(0, 0, 0, 0.2)";
+            var linkColor = coerceLink("color", defaultLinkColor);
+            function makeDefaultHoverColor(_linkColor) {
+              var tc2 = tinycolor(_linkColor);
+              if (!tc2.isValid()) {
+                return _linkColor;
+              }
+              var alpha = tc2.getAlpha();
+              if (alpha <= 0.8) {
+                tc2.setAlpha(alpha + 0.2);
+              } else {
+                tc2 = darkBG ? tc2.brighten() : tc2.darken();
+              }
+              return tc2.toRgbString();
+            }
+            coerceLink(
+              "hovercolor",
+              Array.isArray(linkColor) ? linkColor.map(makeDefaultHoverColor) : makeDefaultHoverColor(linkColor)
+            );
+            coerceLink("customdata");
+            handleArrayContainerDefaults(linkIn, linkOut, {
+              name: "colorscales",
+              handleItemDefaults: concentrationscalesDefaults
+            });
+            handleDomainDefaults(traceOut, layout, coerce);
+            coerce("orientation");
+            coerce("valueformat");
+            coerce("valuesuffix");
+            var dfltArrangement;
+            if (nodeOut.x.length && nodeOut.y.length) {
+              dfltArrangement = "freeform";
+            }
+            coerce("arrangement", dfltArrangement);
+            Lib.coerceFont(coerce, "textfont", layout.font, { autoShadowDflt: true });
+            traceOut._length = null;
+          };
+          function concentrationscalesDefaults(In, Out) {
+            function coerce(attr, dflt) {
+              return Lib.coerce(In, Out, attributes.link.colorscales, attr, dflt);
+            }
+            coerce("label");
+            coerce("cmin");
+            coerce("cmax");
+            coerce("colorscale");
+          }
+        }
+      });
+      var require_scc = __commonJS({
+        "node_modules/strongly-connected-components/scc.js"(exports, module2) {
+          module2.exports = stronglyConnectedComponents;
+          function stronglyConnectedComponents(adjList) {
+            var numVertices = adjList.length;
+            var index = new Array(numVertices);
+            var lowValue = new Array(numVertices);
+            var active = new Array(numVertices);
+            var child = new Array(numVertices);
+            var scc = new Array(numVertices);
+            var sccLinks = new Array(numVertices);
+            for (var i2 = 0; i2 < numVertices; ++i2) {
+              index[i2] = -1;
+              lowValue[i2] = 0;
+              active[i2] = false;
+              child[i2] = 0;
+              scc[i2] = -1;
+              sccLinks[i2] = [];
+            }
+            var count2 = 0;
+            var components = [];
+            var sccAdjList = [];
+            function strongConnect(v2) {
+              var S2 = [v2], T2 = [v2];
+              index[v2] = lowValue[v2] = count2;
+              active[v2] = true;
+              count2 += 1;
+              while (T2.length > 0) {
+                v2 = T2[T2.length - 1];
+                var e22 = adjList[v2];
+                if (child[v2] < e22.length) {
+                  for (var i22 = child[v2]; i22 < e22.length; ++i22) {
+                    var u2 = e22[i22];
+                    if (index[u2] < 0) {
+                      index[u2] = lowValue[u2] = count2;
+                      active[u2] = true;
+                      count2 += 1;
+                      S2.push(u2);
+                      T2.push(u2);
+                      break;
+                    } else if (active[u2]) {
+                      lowValue[v2] = Math.min(lowValue[v2], lowValue[u2]) | 0;
+                    }
+                    if (scc[u2] >= 0) {
+                      sccLinks[v2].push(scc[u2]);
+                    }
+                  }
+                  child[v2] = i22;
+                } else {
+                  if (lowValue[v2] === index[v2]) {
+                    var component = [];
+                    var links = [], linkCount = 0;
+                    for (var i22 = S2.length - 1; i22 >= 0; --i22) {
+                      var w2 = S2[i22];
+                      active[w2] = false;
+                      component.push(w2);
+                      links.push(sccLinks[w2]);
+                      linkCount += sccLinks[w2].length;
+                      scc[w2] = components.length;
+                      if (w2 === v2) {
+                        S2.length = i22;
+                        break;
+                      }
+                    }
+                    components.push(component);
+                    var allLinks = new Array(linkCount);
+                    for (var i22 = 0; i22 < links.length; i22++) {
+                      for (var j22 = 0; j22 < links[i22].length; j22++) {
+                        allLinks[--linkCount] = links[i22][j22];
+                      }
+                    }
+                    sccAdjList.push(allLinks);
+                  }
+                  T2.pop();
+                }
+              }
+            }
+            for (var i2 = 0; i2 < numVertices; ++i2) {
+              if (index[i2] < 0) {
+                strongConnect(i2);
+              }
+            }
+            var newE;
+            for (var i2 = 0; i2 < sccAdjList.length; i2++) {
+              var e2 = sccAdjList[i2];
+              if (e2.length === 0) continue;
+              e2.sort(function(a2, b2) {
+                return a2 - b2;
+              });
+              newE = [e2[0]];
+              for (var j2 = 1; j2 < e2.length; j2++) {
+                if (e2[j2] !== e2[j2 - 1]) {
+                  newE.push(e2[j2]);
+                }
+              }
+              sccAdjList[i2] = newE;
+            }
+            return { components, adjacencyList: sccAdjList };
+          }
+        }
+      });
+      var require_calc35 = __commonJS({
+        "src/traces/sankey/calc.js"(exports, module2) {
+          var tarjan = require_scc();
+          var Lib = require_lib();
+          var wrap = require_gup().wrap;
+          var isArrayOrTypedArray = Lib.isArrayOrTypedArray;
+          var isIndex2 = Lib.isIndex;
+          var Colorscale = require_colorscale();
+          function convertToD3Sankey(trace) {
+            var nodeSpec = trace.node;
+            var linkSpec = trace.link;
+            var links = [];
+            var hasLinkColorArray = isArrayOrTypedArray(linkSpec.color);
+            var hasLinkHoverColorArray = isArrayOrTypedArray(linkSpec.hovercolor);
+            var hasLinkCustomdataArray = isArrayOrTypedArray(linkSpec.customdata);
+            var linkedNodes = {};
+            var components = {};
+            var componentCount = linkSpec.colorscales.length;
+            var i2;
+            for (i2 = 0; i2 < componentCount; i2++) {
+              var cscale = linkSpec.colorscales[i2];
+              var specs = Colorscale.extractScale(cscale, { cLetter: "c" });
+              var scale2 = Colorscale.makeColorScaleFunc(specs);
+              components[cscale.label] = scale2;
+            }
+            var maxNodeId = 0;
+            for (i2 = 0; i2 < linkSpec.value.length; i2++) {
+              if (linkSpec.source[i2] > maxNodeId) maxNodeId = linkSpec.source[i2];
+              if (linkSpec.target[i2] > maxNodeId) maxNodeId = linkSpec.target[i2];
+            }
+            var nodeCount = maxNodeId + 1;
+            trace.node._count = nodeCount;
+            var j2;
+            var groups = trace.node.groups;
+            var groupLookup = {};
+            for (i2 = 0; i2 < groups.length; i2++) {
+              var group = groups[i2];
+              for (j2 = 0; j2 < group.length; j2++) {
+                var nodeIndex = group[j2];
+                var groupIndex = nodeCount + i2;
+                if (groupLookup.hasOwnProperty(nodeIndex)) {
+                  Lib.warn("Node " + nodeIndex + " is already part of a group.");
+                } else {
+                  groupLookup[nodeIndex] = groupIndex;
+                }
+              }
+            }
+            var groupedLinks = {
+              source: [],
+              target: []
+            };
+            for (i2 = 0; i2 < linkSpec.value.length; i2++) {
+              var val = linkSpec.value[i2];
+              var source2 = linkSpec.source[i2];
+              var target = linkSpec.target[i2];
+              if (!(val > 0 && isIndex2(source2, nodeCount) && isIndex2(target, nodeCount))) {
+                continue;
+              }
+              if (groupLookup.hasOwnProperty(source2) && groupLookup.hasOwnProperty(target) && groupLookup[source2] === groupLookup[target]) {
+                continue;
+              }
+              if (groupLookup.hasOwnProperty(target)) {
+                target = groupLookup[target];
+              }
+              if (groupLookup.hasOwnProperty(source2)) {
+                source2 = groupLookup[source2];
+              }
+              source2 = +source2;
+              target = +target;
+              linkedNodes[source2] = linkedNodes[target] = true;
+              var label = "";
+              if (linkSpec.label && linkSpec.label[i2]) label = linkSpec.label[i2];
+              var concentrationscale = null;
+              if (label && components.hasOwnProperty(label)) concentrationscale = components[label];
+              links.push({
+                pointNumber: i2,
+                label,
+                color: hasLinkColorArray ? linkSpec.color[i2] : linkSpec.color,
+                hovercolor: hasLinkHoverColorArray ? linkSpec.hovercolor[i2] : linkSpec.hovercolor,
+                customdata: hasLinkCustomdataArray ? linkSpec.customdata[i2] : linkSpec.customdata,
+                concentrationscale,
+                source: source2,
+                target,
+                value: +val
+              });
+              groupedLinks.source.push(source2);
+              groupedLinks.target.push(target);
+            }
+            var totalCount = nodeCount + groups.length;
+            var hasNodeColorArray = isArrayOrTypedArray(nodeSpec.color);
+            var hasNodeCustomdataArray = isArrayOrTypedArray(nodeSpec.customdata);
+            var nodes = [];
+            for (i2 = 0; i2 < totalCount; i2++) {
+              if (!linkedNodes[i2]) continue;
+              var l2 = nodeSpec.label[i2];
+              nodes.push({
+                group: i2 > nodeCount - 1,
+                childrenNodes: [],
+                pointNumber: i2,
+                label: l2,
+                color: hasNodeColorArray ? nodeSpec.color[i2] : nodeSpec.color,
+                customdata: hasNodeCustomdataArray ? nodeSpec.customdata[i2] : nodeSpec.customdata
+              });
+            }
+            var circular = false;
+            if (circularityPresent(totalCount, groupedLinks.source, groupedLinks.target)) {
+              circular = true;
+            }
+            return {
+              circular,
+              links,
+              nodes,
+              // Data structure for groups
+              groups,
+              groupLookup
+            };
+          }
+          function circularityPresent(nodeLen, sources, targets) {
+            var nodes = Lib.init2dArray(nodeLen, 0);
+            for (var i2 = 0; i2 < Math.min(sources.length, targets.length); i2++) {
+              if (Lib.isIndex(sources[i2], nodeLen) && Lib.isIndex(targets[i2], nodeLen)) {
+                if (sources[i2] === targets[i2]) {
+                  return true;
+                }
+                nodes[sources[i2]].push(targets[i2]);
+              }
+            }
+            var scc = tarjan(nodes);
+            return scc.components.some(function(c2) {
+              return c2.length > 1;
+            });
+          }
+          module2.exports = function calc(gd2, trace) {
+            var result = convertToD3Sankey(trace);
+            return wrap({
+              circular: result.circular,
+              _nodes: result.nodes,
+              _links: result.links,
+              // Data structure for grouping
+              _groups: result.groups,
+              _groupLookup: result.groupLookup
+            });
+          };
+        }
+      });
+      var require_d3_quadtree = __commonJS({
+        "node_modules/d3-quadtree/dist/d3-quadtree.js"(exports, module2) {
+          (function(global2, factory2) {
+            typeof exports === "object" && typeof module2 !== "undefined" ? factory2(exports) : (global2 = global2 || self, factory2(global2.d3 = global2.d3 || {}));
+          })(exports, function(exports2) {
+            function tree_add(d2) {
+              var x2 = +this._x.call(null, d2), y2 = +this._y.call(null, d2);
+              return add2(this.cover(x2, y2), x2, y2, d2);
+            }
+            function add2(tree, x2, y2, d2) {
+              if (isNaN(x2) || isNaN(y2)) return tree;
+              var parent, node = tree._root, leaf = { data: d2 }, x0 = tree._x0, y0 = tree._y0, x1 = tree._x1, y1 = tree._y1, xm, ym, xp, yp, right, bottom, i2, j2;
+              if (!node) return tree._root = leaf, tree;
+              while (node.length) {
+                if (right = x2 >= (xm = (x0 + x1) / 2)) x0 = xm;
+                else x1 = xm;
+                if (bottom = y2 >= (ym = (y0 + y1) / 2)) y0 = ym;
+                else y1 = ym;
+                if (parent = node, !(node = node[i2 = bottom << 1 | right])) return parent[i2] = leaf, tree;
+              }
+              xp = +tree._x.call(null, node.data);
+              yp = +tree._y.call(null, node.data);
+              if (x2 === xp && y2 === yp) return leaf.next = node, parent ? parent[i2] = leaf : tree._root = leaf, tree;
+              do {
+                parent = parent ? parent[i2] = new Array(4) : tree._root = new Array(4);
+                if (right = x2 >= (xm = (x0 + x1) / 2)) x0 = xm;
+                else x1 = xm;
+                if (bottom = y2 >= (ym = (y0 + y1) / 2)) y0 = ym;
+                else y1 = ym;
+              } while ((i2 = bottom << 1 | right) === (j2 = (yp >= ym) << 1 | xp >= xm));
+              return parent[j2] = node, parent[i2] = leaf, tree;
+            }
+            function addAll(data) {
+              var d2, i2, n2 = data.length, x2, y2, xz = new Array(n2), yz = new Array(n2), x0 = Infinity, y0 = Infinity, x1 = -Infinity, y1 = -Infinity;
+              for (i2 = 0; i2 < n2; ++i2) {
+                if (isNaN(x2 = +this._x.call(null, d2 = data[i2])) || isNaN(y2 = +this._y.call(null, d2))) continue;
+                xz[i2] = x2;
+                yz[i2] = y2;
+                if (x2 < x0) x0 = x2;
+                if (x2 > x1) x1 = x2;
+                if (y2 < y0) y0 = y2;
+                if (y2 > y1) y1 = y2;
+              }
+              if (x0 > x1 || y0 > y1) return this;
+              this.cover(x0, y0).cover(x1, y1);
+              for (i2 = 0; i2 < n2; ++i2) {
+                add2(this, xz[i2], yz[i2], data[i2]);
+              }
+              return this;
+            }
+            function tree_cover(x2, y2) {
+              if (isNaN(x2 = +x2) || isNaN(y2 = +y2)) return this;
+              var x0 = this._x0, y0 = this._y0, x1 = this._x1, y1 = this._y1;
+              if (isNaN(x0)) {
+                x1 = (x0 = Math.floor(x2)) + 1;
+                y1 = (y0 = Math.floor(y2)) + 1;
+              } else {
+                var z2 = x1 - x0, node = this._root, parent, i2;
+                while (x0 > x2 || x2 >= x1 || y0 > y2 || y2 >= y1) {
+                  i2 = (y2 < y0) << 1 | x2 < x0;
+                  parent = new Array(4), parent[i2] = node, node = parent, z2 *= 2;
+                  switch (i2) {
+                    case 0:
+                      x1 = x0 + z2, y1 = y0 + z2;
+                      break;
+                    case 1:
+                      x0 = x1 - z2, y1 = y0 + z2;
+                      break;
+                    case 2:
+                      x1 = x0 + z2, y0 = y1 - z2;
+                      break;
+                    case 3:
+                      x0 = x1 - z2, y0 = y1 - z2;
+                      break;
+                  }
+                }
+                if (this._root && this._root.length) this._root = node;
+              }
+              this._x0 = x0;
+              this._y0 = y0;
+              this._x1 = x1;
+              this._y1 = y1;
+              return this;
+            }
+            function tree_data() {
+              var data = [];
+              this.visit(function(node) {
+                if (!node.length) do
+                  data.push(node.data);
+                while (node = node.next);
+              });
+              return data;
+            }
+            function tree_extent(_2) {
+              return arguments.length ? this.cover(+_2[0][0], +_2[0][1]).cover(+_2[1][0], +_2[1][1]) : isNaN(this._x0) ? void 0 : [[this._x0, this._y0], [this._x1, this._y1]];
+            }
+            function Quad(node, x0, y0, x1, y1) {
+              this.node = node;
+              this.x0 = x0;
+              this.y0 = y0;
+              this.x1 = x1;
+              this.y1 = y1;
+            }
+            function tree_find(x2, y2, radius) {
+              var data, x0 = this._x0, y0 = this._y0, x1, y1, x22, y22, x3 = this._x1, y3 = this._y1, quads = [], node = this._root, q2, i2;
+              if (node) quads.push(new Quad(node, x0, y0, x3, y3));
+              if (radius == null) radius = Infinity;
+              else {
+                x0 = x2 - radius, y0 = y2 - radius;
+                x3 = x2 + radius, y3 = y2 + radius;
+                radius *= radius;
+              }
+              while (q2 = quads.pop()) {
+                if (!(node = q2.node) || (x1 = q2.x0) > x3 || (y1 = q2.y0) > y3 || (x22 = q2.x1) < x0 || (y22 = q2.y1) < y0) continue;
+                if (node.length) {
+                  var xm = (x1 + x22) / 2, ym = (y1 + y22) / 2;
+                  quads.push(
+                    new Quad(node[3], xm, ym, x22, y22),
+                    new Quad(node[2], x1, ym, xm, y22),
+                    new Quad(node[1], xm, y1, x22, ym),
+                    new Quad(node[0], x1, y1, xm, ym)
+                  );
+                  if (i2 = (y2 >= ym) << 1 | x2 >= xm) {
+                    q2 = quads[quads.length - 1];
+                    quads[quads.length - 1] = quads[quads.length - 1 - i2];
+                    quads[quads.length - 1 - i2] = q2;
+                  }
+                } else {
+                  var dx = x2 - +this._x.call(null, node.data), dy = y2 - +this._y.call(null, node.data), d2 = dx * dx + dy * dy;
+                  if (d2 < radius) {
+                    var d3 = Math.sqrt(radius = d2);
+                    x0 = x2 - d3, y0 = y2 - d3;
+                    x3 = x2 + d3, y3 = y2 + d3;
+                    data = node.data;
+                  }
+                }
+              }
+              return data;
+            }
+            function tree_remove(d2) {
+              if (isNaN(x2 = +this._x.call(null, d2)) || isNaN(y2 = +this._y.call(null, d2))) return this;
+              var parent, node = this._root, retainer, previous, next, x0 = this._x0, y0 = this._y0, x1 = this._x1, y1 = this._y1, x2, y2, xm, ym, right, bottom, i2, j2;
+              if (!node) return this;
+              if (node.length) while (true) {
+                if (right = x2 >= (xm = (x0 + x1) / 2)) x0 = xm;
+                else x1 = xm;
+                if (bottom = y2 >= (ym = (y0 + y1) / 2)) y0 = ym;
+                else y1 = ym;
+                if (!(parent = node, node = node[i2 = bottom << 1 | right])) return this;
+                if (!node.length) break;
+                if (parent[i2 + 1 & 3] || parent[i2 + 2 & 3] || parent[i2 + 3 & 3]) retainer = parent, j2 = i2;
+              }
+              while (node.data !== d2) if (!(previous = node, node = node.next)) return this;
+              if (next = node.next) delete node.next;
+              if (previous) return next ? previous.next = next : delete previous.next, this;
+              if (!parent) return this._root = next, this;
+              next ? parent[i2] = next : delete parent[i2];
+              if ((node = parent[0] || parent[1] || parent[2] || parent[3]) && node === (parent[3] || parent[2] || parent[1] || parent[0]) && !node.length) {
+                if (retainer) retainer[j2] = node;
+                else this._root = node;
+              }
+              return this;
+            }
+            function removeAll(data) {
+              for (var i2 = 0, n2 = data.length; i2 < n2; ++i2) this.remove(data[i2]);
+              return this;
+            }
+            function tree_root() {
+              return this._root;
+            }
+            function tree_size() {
+              var size = 0;
+              this.visit(function(node) {
+                if (!node.length) do
+                  ++size;
+                while (node = node.next);
+              });
+              return size;
+            }
+            function tree_visit(callback) {
+              var quads = [], q2, node = this._root, child, x0, y0, x1, y1;
+              if (node) quads.push(new Quad(node, this._x0, this._y0, this._x1, this._y1));
+              while (q2 = quads.pop()) {
+                if (!callback(node = q2.node, x0 = q2.x0, y0 = q2.y0, x1 = q2.x1, y1 = q2.y1) && node.length) {
+                  var xm = (x0 + x1) / 2, ym = (y0 + y1) / 2;
+                  if (child = node[3]) quads.push(new Quad(child, xm, ym, x1, y1));
+                  if (child = node[2]) quads.push(new Quad(child, x0, ym, xm, y1));
+                  if (child = node[1]) quads.push(new Quad(child, xm, y0, x1, ym));
+                  if (child = node[0]) quads.push(new Quad(child, x0, y0, xm, ym));
+                }
+              }
+              return this;
+            }
+            function tree_visitAfter(callback) {
+              var quads = [], next = [], q2;
+              if (this._root) quads.push(new Quad(this._root, this._x0, this._y0, this._x1, this._y1));
+              while (q2 = quads.pop()) {
+                var node = q2.node;
+                if (node.length) {
+                  var child, x0 = q2.x0, y0 = q2.y0, x1 = q2.x1, y1 = q2.y1, xm = (x0 + x1) / 2, ym = (y0 + y1) / 2;
+                  if (child = node[0]) quads.push(new Quad(child, x0, y0, xm, ym));
+                  if (child = node[1]) quads.push(new Quad(child, xm, y0, x1, ym));
+                  if (child = node[2]) quads.push(new Quad(child, x0, ym, xm, y1));
+                  if (child = node[3]) quads.push(new Quad(child, xm, ym, x1, y1));
+                }
+                next.push(q2);
+              }
+              while (q2 = next.pop()) {
+                callback(q2.node, q2.x0, q2.y0, q2.x1, q2.y1);
+              }
+              return this;
+            }
+            function defaultX(d2) {
+              return d2[0];
+            }
+            function tree_x(_2) {
+              return arguments.length ? (this._x = _2, this) : this._x;
+            }
+            function defaultY(d2) {
+              return d2[1];
+            }
+            function tree_y(_2) {
+              return arguments.length ? (this._y = _2, this) : this._y;
+            }
+            function quadtree(nodes, x2, y2) {
+              var tree = new Quadtree(x2 == null ? defaultX : x2, y2 == null ? defaultY : y2, NaN, NaN, NaN, NaN);
+              return nodes == null ? tree : tree.addAll(nodes);
+            }
+            function Quadtree(x2, y2, x0, y0, x1, y1) {
+              this._x = x2;
+              this._y = y2;
+              this._x0 = x0;
+              this._y0 = y0;
+              this._x1 = x1;
+              this._y1 = y1;
+              this._root = void 0;
+            }
+            function leaf_copy(leaf) {
+              var copy = { data: leaf.data }, next = copy;
+              while (leaf = leaf.next) next = next.next = { data: leaf.data };
+              return copy;
+            }
+            var treeProto = quadtree.prototype = Quadtree.prototype;
+            treeProto.copy = function() {
+              var copy = new Quadtree(this._x, this._y, this._x0, this._y0, this._x1, this._y1), node = this._root, nodes, child;
+              if (!node) return copy;
+              if (!node.length) return copy._root = leaf_copy(node), copy;
+              nodes = [{ source: node, target: copy._root = new Array(4) }];
+              while (node = nodes.pop()) {
+                for (var i2 = 0; i2 < 4; ++i2) {
+                  if (child = node.source[i2]) {
+                    if (child.length) nodes.push({ source: child, target: node.target[i2] = new Array(4) });
+                    else node.target[i2] = leaf_copy(child);
+                  }
+                }
+              }
+              return copy;
+            };
+            treeProto.add = tree_add;
+            treeProto.addAll = addAll;
+            treeProto.cover = tree_cover;
+            treeProto.data = tree_data;
+            treeProto.extent = tree_extent;
+            treeProto.find = tree_find;
+            treeProto.remove = tree_remove;
+            treeProto.removeAll = removeAll;
+            treeProto.root = tree_root;
+            treeProto.size = tree_size;
+            treeProto.visit = tree_visit;
+            treeProto.visitAfter = tree_visitAfter;
+            treeProto.x = tree_x;
+            treeProto.y = tree_y;
+            exports2.quadtree = quadtree;
+            Object.defineProperty(exports2, "__esModule", { value: true });
+          });
+        }
+      });
+      var require_d3_collection = __commonJS({
+        "node_modules/d3-collection/dist/d3-collection.js"(exports, module2) {
+          (function(global2, factory2) {
+            typeof exports === "object" && typeof module2 !== "undefined" ? factory2(exports) : factory2(global2.d3 = global2.d3 || {});
+          })(exports, function(exports2) {
+            var prefix = "$";
+            function Map22() {
+            }
+            Map22.prototype = map2.prototype = {
+              constructor: Map22,
+              has: function(key) {
+                return prefix + key in this;
+              },
+              get: function(key) {
+                return this[prefix + key];
+              },
+              set: function(key, value) {
+                this[prefix + key] = value;
+                return this;
+              },
+              remove: function(key) {
+                var property = prefix + key;
+                return property in this && delete this[property];
+              },
+              clear: function() {
+                for (var property in this) if (property[0] === prefix) delete this[property];
+              },
+              keys: function() {
+                var keys2 = [];
+                for (var property in this) if (property[0] === prefix) keys2.push(property.slice(1));
+                return keys2;
+              },
+              values: function() {
+                var values2 = [];
+                for (var property in this) if (property[0] === prefix) values2.push(this[property]);
+                return values2;
+              },
+              entries: function() {
+                var entries2 = [];
+                for (var property in this) if (property[0] === prefix) entries2.push({ key: property.slice(1), value: this[property] });
+                return entries2;
+              },
+              size: function() {
+                var size = 0;
+                for (var property in this) if (property[0] === prefix) ++size;
+                return size;
+              },
+              empty: function() {
+                for (var property in this) if (property[0] === prefix) return false;
+                return true;
+              },
+              each: function(f2) {
+                for (var property in this) if (property[0] === prefix) f2(this[property], property.slice(1), this);
+              }
+            };
+            function map2(object, f2) {
+              var map22 = new Map22();
+              if (object instanceof Map22) object.each(function(value, key2) {
+                map22.set(key2, value);
+              });
+              else if (Array.isArray(object)) {
+                var i2 = -1, n2 = object.length, o2;
+                if (f2 == null) while (++i2 < n2) map22.set(i2, object[i2]);
+                else while (++i2 < n2) map22.set(f2(o2 = object[i2], i2, object), o2);
+              } else if (object) for (var key in object) map22.set(key, object[key]);
+              return map22;
+            }
+            function nest() {
+              var keys2 = [], sortKeys = [], sortValues, rollup, nest2;
+              function apply(array, depth, createResult, setResult) {
+                if (depth >= keys2.length) {
+                  if (sortValues != null) array.sort(sortValues);
+                  return rollup != null ? rollup(array) : array;
+                }
+                var i2 = -1, n2 = array.length, key = keys2[depth++], keyValue, value, valuesByKey = map2(), values2, result = createResult();
+                while (++i2 < n2) {
+                  if (values2 = valuesByKey.get(keyValue = key(value = array[i2]) + "")) {
+                    values2.push(value);
+                  } else {
+                    valuesByKey.set(keyValue, [value]);
+                  }
+                }
+                valuesByKey.each(function(values3, key2) {
+                  setResult(result, key2, apply(values3, depth, createResult, setResult));
+                });
+                return result;
+              }
+              function entries2(map$$1, depth) {
+                if (++depth > keys2.length) return map$$1;
+                var array, sortKey = sortKeys[depth - 1];
+                if (rollup != null && depth >= keys2.length) array = map$$1.entries();
+                else array = [], map$$1.each(function(v2, k2) {
+                  array.push({ key: k2, values: entries2(v2, depth) });
+                });
+                return sortKey != null ? array.sort(function(a2, b2) {
+                  return sortKey(a2.key, b2.key);
+                }) : array;
+              }
+              return nest2 = {
+                object: function(array) {
+                  return apply(array, 0, createObject, setObject);
+                },
+                map: function(array) {
+                  return apply(array, 0, createMap, setMap2);
+                },
+                entries: function(array) {
+                  return entries2(apply(array, 0, createMap, setMap2), 0);
+                },
+                key: function(d2) {
+                  keys2.push(d2);
+                  return nest2;
+                },
+                sortKeys: function(order) {
+                  sortKeys[keys2.length - 1] = order;
+                  return nest2;
+                },
+                sortValues: function(order) {
+                  sortValues = order;
+                  return nest2;
+                },
+                rollup: function(f2) {
+                  rollup = f2;
+                  return nest2;
+                }
+              };
+            }
+            function createObject() {
+              return {};
+            }
+            function setObject(object, key, value) {
+              object[key] = value;
+            }
+            function createMap() {
+              return map2();
+            }
+            function setMap2(map$$1, key, value) {
+              map$$1.set(key, value);
+            }
+            function Set2() {
+            }
+            var proto = map2.prototype;
+            Set2.prototype = set.prototype = {
+              constructor: Set2,
+              has: proto.has,
+              add: function(value) {
+                value += "";
+                this[prefix + value] = value;
+                return this;
+              },
+              remove: proto.remove,
+              clear: proto.clear,
+              values: proto.keys,
+              size: proto.size,
+              empty: proto.empty,
+              each: proto.each
+            };
+            function set(object, f2) {
+              var set2 = new Set2();
+              if (object instanceof Set2) object.each(function(value) {
+                set2.add(value);
+              });
+              else if (object) {
+                var i2 = -1, n2 = object.length;
+                if (f2 == null) while (++i2 < n2) set2.add(object[i2]);
+                else while (++i2 < n2) set2.add(f2(object[i2], i2, object));
+              }
+              return set2;
+            }
+            function keys(map22) {
+              var keys2 = [];
+              for (var key in map22) keys2.push(key);
+              return keys2;
+            }
+            function values(map22) {
+              var values2 = [];
+              for (var key in map22) values2.push(map22[key]);
+              return values2;
+            }
+            function entries(map22) {
+              var entries2 = [];
+              for (var key in map22) entries2.push({ key, value: map22[key] });
+              return entries2;
+            }
+            exports2.nest = nest;
+            exports2.set = set;
+            exports2.map = map2;
+            exports2.keys = keys;
+            exports2.values = values;
+            exports2.entries = entries;
+            Object.defineProperty(exports2, "__esModule", { value: true });
+          });
+        }
+      });
+      var require_d3_dispatch = __commonJS({
+        "node_modules/d3-dispatch/dist/d3-dispatch.js"(exports, module2) {
+          (function(global2, factory2) {
+            typeof exports === "object" && typeof module2 !== "undefined" ? factory2(exports) : (global2 = global2 || self, factory2(global2.d3 = global2.d3 || {}));
+          })(exports, function(exports2) {
+            var noop2 = { value: function() {
+            } };
+            function dispatch() {
+              for (var i2 = 0, n2 = arguments.length, _2 = {}, t4; i2 < n2; ++i2) {
+                if (!(t4 = arguments[i2] + "") || t4 in _2 || /[\s.]/.test(t4)) throw new Error("illegal type: " + t4);
+                _2[t4] = [];
+              }
+              return new Dispatch(_2);
+            }
+            function Dispatch(_2) {
+              this._ = _2;
+            }
+            function parseTypenames(typenames, types) {
+              return typenames.trim().split(/^|\s+/).map(function(t4) {
+                var name2 = "", i2 = t4.indexOf(".");
+                if (i2 >= 0) name2 = t4.slice(i2 + 1), t4 = t4.slice(0, i2);
+                if (t4 && !types.hasOwnProperty(t4)) throw new Error("unknown type: " + t4);
+                return { type: t4, name: name2 };
+              });
+            }
+            Dispatch.prototype = dispatch.prototype = {
+              constructor: Dispatch,
+              on: function(typename, callback) {
+                var _2 = this._, T2 = parseTypenames(typename + "", _2), t4, i2 = -1, n2 = T2.length;
+                if (arguments.length < 2) {
+                  while (++i2 < n2) if ((t4 = (typename = T2[i2]).type) && (t4 = get(_2[t4], typename.name))) return t4;
+                  return;
+                }
+                if (callback != null && typeof callback !== "function") throw new Error("invalid callback: " + callback);
+                while (++i2 < n2) {
+                  if (t4 = (typename = T2[i2]).type) _2[t4] = set(_2[t4], typename.name, callback);
+                  else if (callback == null) for (t4 in _2) _2[t4] = set(_2[t4], typename.name, null);
+                }
+                return this;
+              },
+              copy: function() {
+                var copy = {}, _2 = this._;
+                for (var t4 in _2) copy[t4] = _2[t4].slice();
+                return new Dispatch(copy);
+              },
+              call: function(type, that) {
+                if ((n2 = arguments.length - 2) > 0) for (var args = new Array(n2), i2 = 0, n2, t4; i2 < n2; ++i2) args[i2] = arguments[i2 + 2];
+                if (!this._.hasOwnProperty(type)) throw new Error("unknown type: " + type);
+                for (t4 = this._[type], i2 = 0, n2 = t4.length; i2 < n2; ++i2) t4[i2].value.apply(that, args);
+              },
+              apply: function(type, that, args) {
+                if (!this._.hasOwnProperty(type)) throw new Error("unknown type: " + type);
+                for (var t4 = this._[type], i2 = 0, n2 = t4.length; i2 < n2; ++i2) t4[i2].value.apply(that, args);
+              }
+            };
+            function get(type, name2) {
+              for (var i2 = 0, n2 = type.length, c2; i2 < n2; ++i2) {
+                if ((c2 = type[i2]).name === name2) {
+                  return c2.value;
+                }
+              }
+            }
+            function set(type, name2, callback) {
+              for (var i2 = 0, n2 = type.length; i2 < n2; ++i2) {
+                if (type[i2].name === name2) {
+                  type[i2] = noop2, type = type.slice(0, i2).concat(type.slice(i2 + 1));
+                  break;
+                }
+              }
+              if (callback != null) type.push({ name: name2, value: callback });
+              return type;
+            }
+            exports2.dispatch = dispatch;
+            Object.defineProperty(exports2, "__esModule", { value: true });
+          });
+        }
+      });
+      var require_d3_timer = __commonJS({
+        "node_modules/d3-timer/dist/d3-timer.js"(exports, module2) {
+          (function(global2, factory2) {
+            typeof exports === "object" && typeof module2 !== "undefined" ? factory2(exports) : (global2 = global2 || self, factory2(global2.d3 = global2.d3 || {}));
+          })(exports, function(exports2) {
+            var frame = 0, timeout = 0, interval = 0, pokeDelay = 1e3, taskHead, taskTail, clockLast = 0, clockNow = 0, clockSkew = 0, clock = typeof performance === "object" && performance.now ? performance : Date, setFrame = typeof window === "object" && window.requestAnimationFrame ? window.requestAnimationFrame.bind(window) : function(f2) {
+              setTimeout(f2, 17);
+            };
+            function now() {
+              return clockNow || (setFrame(clearNow), clockNow = clock.now() + clockSkew);
+            }
+            function clearNow() {
+              clockNow = 0;
+            }
+            function Timer() {
+              this._call = this._time = this._next = null;
+            }
+            Timer.prototype = timer.prototype = {
+              constructor: Timer,
+              restart: function(callback, delay, time) {
+                if (typeof callback !== "function") throw new TypeError("callback is not a function");
+                time = (time == null ? now() : +time) + (delay == null ? 0 : +delay);
+                if (!this._next && taskTail !== this) {
+                  if (taskTail) taskTail._next = this;
+                  else taskHead = this;
+                  taskTail = this;
+                }
+                this._call = callback;
+                this._time = time;
+                sleep();
+              },
+              stop: function() {
+                if (this._call) {
+                  this._call = null;
+                  this._time = Infinity;
+                  sleep();
+                }
+              }
+            };
+            function timer(callback, delay, time) {
+              var t4 = new Timer();
+              t4.restart(callback, delay, time);
+              return t4;
+            }
+            function timerFlush() {
+              now();
+              ++frame;
+              var t4 = taskHead, e2;
+              while (t4) {
+                if ((e2 = clockNow - t4._time) >= 0) t4._call.call(null, e2);
+                t4 = t4._next;
+              }
+              --frame;
+            }
+            function wake() {
+              clockNow = (clockLast = clock.now()) + clockSkew;
+              frame = timeout = 0;
+              try {
+                timerFlush();
+              } finally {
+                frame = 0;
+                nap();
+                clockNow = 0;
+              }
+            }
+            function poke() {
+              var now2 = clock.now(), delay = now2 - clockLast;
+              if (delay > pokeDelay) clockSkew -= delay, clockLast = now2;
+            }
+            function nap() {
+              var t02, t12 = taskHead, t22, time = Infinity;
+              while (t12) {
+                if (t12._call) {
+                  if (time > t12._time) time = t12._time;
+                  t02 = t12, t12 = t12._next;
+                } else {
+                  t22 = t12._next, t12._next = null;
+                  t12 = t02 ? t02._next = t22 : taskHead = t22;
+                }
+              }
+              taskTail = t02;
+              sleep(time);
+            }
+            function sleep(time) {
+              if (frame) return;
+              if (timeout) timeout = clearTimeout(timeout);
+              var delay = time - clockNow;
+              if (delay > 24) {
+                if (time < Infinity) timeout = setTimeout(wake, time - clock.now() - clockSkew);
+                if (interval) interval = clearInterval(interval);
+              } else {
+                if (!interval) clockLast = clock.now(), interval = setInterval(poke, pokeDelay);
+                frame = 1, setFrame(wake);
+              }
+            }
+            function timeout$1(callback, delay, time) {
+              var t4 = new Timer();
+              delay = delay == null ? 0 : +delay;
+              t4.restart(function(elapsed) {
+                t4.stop();
+                callback(elapsed + delay);
+              }, delay, time);
+              return t4;
+            }
+            function interval$1(callback, delay, time) {
+              var t4 = new Timer(), total = delay;
+              if (delay == null) return t4.restart(callback, delay, time), t4;
+              delay = +delay, time = time == null ? now() : +time;
+              t4.restart(function tick(elapsed) {
+                elapsed += total;
+                t4.restart(tick, total += delay, time);
+                callback(elapsed);
+              }, delay, time);
+              return t4;
+            }
+            exports2.interval = interval$1;
+            exports2.now = now;
+            exports2.timeout = timeout$1;
+            exports2.timer = timer;
+            exports2.timerFlush = timerFlush;
+            Object.defineProperty(exports2, "__esModule", { value: true });
+          });
+        }
+      });
+      var require_d3_force = __commonJS({
+        "node_modules/d3-force/dist/d3-force.js"(exports, module2) {
+          (function(global2, factory2) {
+            typeof exports === "object" && typeof module2 !== "undefined" ? factory2(exports, require_d3_quadtree(), require_d3_collection(), require_d3_dispatch(), require_d3_timer()) : factory2(global2.d3 = global2.d3 || {}, global2.d3, global2.d3, global2.d3, global2.d3);
+          })(exports, function(exports2, d3Quadtree, d3Collection, d3Dispatch, d3Timer) {
+            function center(x22, y22) {
+              var nodes;
+              if (x22 == null) x22 = 0;
+              if (y22 == null) y22 = 0;
+              function force() {
+                var i2, n2 = nodes.length, node, sx = 0, sy = 0;
+                for (i2 = 0; i2 < n2; ++i2) {
+                  node = nodes[i2], sx += node.x, sy += node.y;
+                }
+                for (sx = sx / n2 - x22, sy = sy / n2 - y22, i2 = 0; i2 < n2; ++i2) {
+                  node = nodes[i2], node.x -= sx, node.y -= sy;
+                }
+              }
+              force.initialize = function(_2) {
+                nodes = _2;
+              };
+              force.x = function(_2) {
+                return arguments.length ? (x22 = +_2, force) : x22;
+              };
+              force.y = function(_2) {
+                return arguments.length ? (y22 = +_2, force) : y22;
+              };
+              return force;
+            }
+            function constant(x22) {
+              return function() {
+                return x22;
+              };
+            }
+            function jiggle() {
+              return (Math.random() - 0.5) * 1e-6;
+            }
+            function x2(d2) {
+              return d2.x + d2.vx;
+            }
+            function y2(d2) {
+              return d2.y + d2.vy;
+            }
+            function collide(radius) {
+              var nodes, radii, strength = 1, iterations = 1;
+              if (typeof radius !== "function") radius = constant(radius == null ? 1 : +radius);
+              function force() {
+                var i2, n2 = nodes.length, tree, node, xi2, yi2, ri2, ri22;
+                for (var k2 = 0; k2 < iterations; ++k2) {
+                  tree = d3Quadtree.quadtree(nodes, x2, y2).visitAfter(prepare);
+                  for (i2 = 0; i2 < n2; ++i2) {
+                    node = nodes[i2];
+                    ri2 = radii[node.index], ri22 = ri2 * ri2;
+                    xi2 = node.x + node.vx;
+                    yi2 = node.y + node.vy;
+                    tree.visit(apply);
+                  }
+                }
+                function apply(quad, x0, y0, x1, y1) {
+                  var data = quad.data, rj2 = quad.r, r2 = ri2 + rj2;
+                  if (data) {
+                    if (data.index > node.index) {
+                      var x22 = xi2 - data.x - data.vx, y22 = yi2 - data.y - data.vy, l2 = x22 * x22 + y22 * y22;
+                      if (l2 < r2 * r2) {
+                        if (x22 === 0) x22 = jiggle(), l2 += x22 * x22;
+                        if (y22 === 0) y22 = jiggle(), l2 += y22 * y22;
+                        l2 = (r2 - (l2 = Math.sqrt(l2))) / l2 * strength;
+                        node.vx += (x22 *= l2) * (r2 = (rj2 *= rj2) / (ri22 + rj2));
+                        node.vy += (y22 *= l2) * r2;
+                        data.vx -= x22 * (r2 = 1 - r2);
+                        data.vy -= y22 * r2;
+                      }
+                    }
+                    return;
+                  }
+                  return x0 > xi2 + r2 || x1 < xi2 - r2 || y0 > yi2 + r2 || y1 < yi2 - r2;
+                }
+              }
+              function prepare(quad) {
+                if (quad.data) return quad.r = radii[quad.data.index];
+                for (var i2 = quad.r = 0; i2 < 4; ++i2) {
+                  if (quad[i2] && quad[i2].r > quad.r) {
+                    quad.r = quad[i2].r;
+                  }
+                }
+              }
+              function initialize() {
+                if (!nodes) return;
+                var i2, n2 = nodes.length, node;
+                radii = new Array(n2);
+                for (i2 = 0; i2 < n2; ++i2) node = nodes[i2], radii[node.index] = +radius(node, i2, nodes);
+              }
+              force.initialize = function(_2) {
+                nodes = _2;
+                initialize();
+              };
+              force.iterations = function(_2) {
+                return arguments.length ? (iterations = +_2, force) : iterations;
+              };
+              force.strength = function(_2) {
+                return arguments.length ? (strength = +_2, force) : strength;
+              };
+              force.radius = function(_2) {
+                return arguments.length ? (radius = typeof _2 === "function" ? _2 : constant(+_2), initialize(), force) : radius;
+              };
+              return force;
+            }
+            function index(d2) {
+              return d2.index;
+            }
+            function find(nodeById, nodeId) {
+              var node = nodeById.get(nodeId);
+              if (!node) throw new Error("missing: " + nodeId);
+              return node;
+            }
+            function link(links) {
+              var id2 = index, strength = defaultStrength, strengths, distance2 = constant(30), distances, nodes, count2, bias, iterations = 1;
+              if (links == null) links = [];
+              function defaultStrength(link2) {
+                return 1 / Math.min(count2[link2.source.index], count2[link2.target.index]);
+              }
+              function force(alpha) {
+                for (var k2 = 0, n2 = links.length; k2 < iterations; ++k2) {
+                  for (var i2 = 0, link2, source2, target, x22, y22, l2, b2; i2 < n2; ++i2) {
+                    link2 = links[i2], source2 = link2.source, target = link2.target;
+                    x22 = target.x + target.vx - source2.x - source2.vx || jiggle();
+                    y22 = target.y + target.vy - source2.y - source2.vy || jiggle();
+                    l2 = Math.sqrt(x22 * x22 + y22 * y22);
+                    l2 = (l2 - distances[i2]) / l2 * alpha * strengths[i2];
+                    x22 *= l2, y22 *= l2;
+                    target.vx -= x22 * (b2 = bias[i2]);
+                    target.vy -= y22 * b2;
+                    source2.vx += x22 * (b2 = 1 - b2);
+                    source2.vy += y22 * b2;
+                  }
+                }
+              }
+              function initialize() {
+                if (!nodes) return;
+                var i2, n2 = nodes.length, m2 = links.length, nodeById = d3Collection.map(nodes, id2), link2;
+                for (i2 = 0, count2 = new Array(n2); i2 < m2; ++i2) {
+                  link2 = links[i2], link2.index = i2;
+                  if (typeof link2.source !== "object") link2.source = find(nodeById, link2.source);
+                  if (typeof link2.target !== "object") link2.target = find(nodeById, link2.target);
+                  count2[link2.source.index] = (count2[link2.source.index] || 0) + 1;
+                  count2[link2.target.index] = (count2[link2.target.index] || 0) + 1;
+                }
+                for (i2 = 0, bias = new Array(m2); i2 < m2; ++i2) {
+                  link2 = links[i2], bias[i2] = count2[link2.source.index] / (count2[link2.source.index] + count2[link2.target.index]);
+                }
+                strengths = new Array(m2), initializeStrength();
+                distances = new Array(m2), initializeDistance();
+              }
+              function initializeStrength() {
+                if (!nodes) return;
+                for (var i2 = 0, n2 = links.length; i2 < n2; ++i2) {
+                  strengths[i2] = +strength(links[i2], i2, links);
+                }
+              }
+              function initializeDistance() {
+                if (!nodes) return;
+                for (var i2 = 0, n2 = links.length; i2 < n2; ++i2) {
+                  distances[i2] = +distance2(links[i2], i2, links);
+                }
+              }
+              force.initialize = function(_2) {
+                nodes = _2;
+                initialize();
+              };
+              force.links = function(_2) {
+                return arguments.length ? (links = _2, initialize(), force) : links;
+              };
+              force.id = function(_2) {
+                return arguments.length ? (id2 = _2, force) : id2;
+              };
+              force.iterations = function(_2) {
+                return arguments.length ? (iterations = +_2, force) : iterations;
+              };
+              force.strength = function(_2) {
+                return arguments.length ? (strength = typeof _2 === "function" ? _2 : constant(+_2), initializeStrength(), force) : strength;
+              };
+              force.distance = function(_2) {
+                return arguments.length ? (distance2 = typeof _2 === "function" ? _2 : constant(+_2), initializeDistance(), force) : distance2;
+              };
+              return force;
+            }
+            function x$12(d2) {
+              return d2.x;
+            }
+            function y$12(d2) {
+              return d2.y;
+            }
+            var initialRadius = 10, initialAngle = Math.PI * (3 - Math.sqrt(5));
+            function simulation(nodes) {
+              var simulation2, alpha = 1, alphaMin = 1e-3, alphaDecay = 1 - Math.pow(alphaMin, 1 / 300), alphaTarget = 0, velocityDecay = 0.6, forces = d3Collection.map(), stepper = d3Timer.timer(step), event = d3Dispatch.dispatch("tick", "end");
+              if (nodes == null) nodes = [];
+              function step() {
+                tick();
+                event.call("tick", simulation2);
+                if (alpha < alphaMin) {
+                  stepper.stop();
+                  event.call("end", simulation2);
+                }
+              }
+              function tick(iterations) {
+                var i2, n2 = nodes.length, node;
+                if (iterations === void 0) iterations = 1;
+                for (var k2 = 0; k2 < iterations; ++k2) {
+                  alpha += (alphaTarget - alpha) * alphaDecay;
+                  forces.each(function(force) {
+                    force(alpha);
+                  });
+                  for (i2 = 0; i2 < n2; ++i2) {
+                    node = nodes[i2];
+                    if (node.fx == null) node.x += node.vx *= velocityDecay;
+                    else node.x = node.fx, node.vx = 0;
+                    if (node.fy == null) node.y += node.vy *= velocityDecay;
+                    else node.y = node.fy, node.vy = 0;
+                  }
+                }
+                return simulation2;
+              }
+              function initializeNodes() {
+                for (var i2 = 0, n2 = nodes.length, node; i2 < n2; ++i2) {
+                  node = nodes[i2], node.index = i2;
+                  if (node.fx != null) node.x = node.fx;
+                  if (node.fy != null) node.y = node.fy;
+                  if (isNaN(node.x) || isNaN(node.y)) {
+                    var radius = initialRadius * Math.sqrt(i2), angle2 = i2 * initialAngle;
+                    node.x = radius * Math.cos(angle2);
+                    node.y = radius * Math.sin(angle2);
+                  }
+                  if (isNaN(node.vx) || isNaN(node.vy)) {
+                    node.vx = node.vy = 0;
+                  }
+                }
+              }
+              function initializeForce(force) {
+                if (force.initialize) force.initialize(nodes);
+                return force;
+              }
+              initializeNodes();
+              return simulation2 = {
+                tick,
+                restart: function() {
+                  return stepper.restart(step), simulation2;
+                },
+                stop: function() {
+                  return stepper.stop(), simulation2;
+                },
+                nodes: function(_2) {
+                  return arguments.length ? (nodes = _2, initializeNodes(), forces.each(initializeForce), simulation2) : nodes;
+                },
+                alpha: function(_2) {
+                  return arguments.length ? (alpha = +_2, simulation2) : alpha;
+                },
+                alphaMin: function(_2) {
+                  return arguments.length ? (alphaMin = +_2, simulation2) : alphaMin;
+                },
+                alphaDecay: function(_2) {
+                  return arguments.length ? (alphaDecay = +_2, simulation2) : +alphaDecay;
+                },
+                alphaTarget: function(_2) {
+                  return arguments.length ? (alphaTarget = +_2, simulation2) : alphaTarget;
+                },
+                velocityDecay: function(_2) {
+                  return arguments.length ? (velocityDecay = 1 - _2, simulation2) : 1 - velocityDecay;
+                },
+                force: function(name2, _2) {
+                  return arguments.length > 1 ? (_2 == null ? forces.remove(name2) : forces.set(name2, initializeForce(_2)), simulation2) : forces.get(name2);
+                },
+                find: function(x22, y22, radius) {
+                  var i2 = 0, n2 = nodes.length, dx, dy, d2, node, closest;
+                  if (radius == null) radius = Infinity;
+                  else radius *= radius;
+                  for (i2 = 0; i2 < n2; ++i2) {
+                    node = nodes[i2];
+                    dx = x22 - node.x;
+                    dy = y22 - node.y;
+                    d2 = dx * dx + dy * dy;
+                    if (d2 < radius) closest = node, radius = d2;
+                  }
+                  return closest;
+                },
+                on: function(name2, _2) {
+                  return arguments.length > 1 ? (event.on(name2, _2), simulation2) : event.on(name2);
+                }
+              };
+            }
+            function manyBody() {
+              var nodes, node, alpha, strength = constant(-30), strengths, distanceMin2 = 1, distanceMax2 = Infinity, theta2 = 0.81;
+              function force(_2) {
+                var i2, n2 = nodes.length, tree = d3Quadtree.quadtree(nodes, x$12, y$12).visitAfter(accumulate);
+                for (alpha = _2, i2 = 0; i2 < n2; ++i2) node = nodes[i2], tree.visit(apply);
+              }
+              function initialize() {
+                if (!nodes) return;
+                var i2, n2 = nodes.length, node2;
+                strengths = new Array(n2);
+                for (i2 = 0; i2 < n2; ++i2) node2 = nodes[i2], strengths[node2.index] = +strength(node2, i2, nodes);
+              }
+              function accumulate(quad) {
+                var strength2 = 0, q2, c2, weight = 0, x22, y22, i2;
+                if (quad.length) {
+                  for (x22 = y22 = i2 = 0; i2 < 4; ++i2) {
+                    if ((q2 = quad[i2]) && (c2 = Math.abs(q2.value))) {
+                      strength2 += q2.value, weight += c2, x22 += c2 * q2.x, y22 += c2 * q2.y;
+                    }
+                  }
+                  quad.x = x22 / weight;
+                  quad.y = y22 / weight;
+                } else {
+                  q2 = quad;
+                  q2.x = q2.data.x;
+                  q2.y = q2.data.y;
+                  do
+                    strength2 += strengths[q2.data.index];
+                  while (q2 = q2.next);
+                }
+                quad.value = strength2;
+              }
+              function apply(quad, x1, _2, x22) {
+                if (!quad.value) return true;
+                var x3 = quad.x - node.x, y22 = quad.y - node.y, w2 = x22 - x1, l2 = x3 * x3 + y22 * y22;
+                if (w2 * w2 / theta2 < l2) {
+                  if (l2 < distanceMax2) {
+                    if (x3 === 0) x3 = jiggle(), l2 += x3 * x3;
+                    if (y22 === 0) y22 = jiggle(), l2 += y22 * y22;
+                    if (l2 < distanceMin2) l2 = Math.sqrt(distanceMin2 * l2);
+                    node.vx += x3 * quad.value * alpha / l2;
+                    node.vy += y22 * quad.value * alpha / l2;
+                  }
+                  return true;
+                } else if (quad.length || l2 >= distanceMax2) return;
+                if (quad.data !== node || quad.next) {
+                  if (x3 === 0) x3 = jiggle(), l2 += x3 * x3;
+                  if (y22 === 0) y22 = jiggle(), l2 += y22 * y22;
+                  if (l2 < distanceMin2) l2 = Math.sqrt(distanceMin2 * l2);
+                }
+                do
+                  if (quad.data !== node) {
+                    w2 = strengths[quad.data.index] * alpha / l2;
+                    node.vx += x3 * w2;
+                    node.vy += y22 * w2;
+                  }
+                while (quad = quad.next);
+              }
+              force.initialize = function(_2) {
+                nodes = _2;
+                initialize();
+              };
+              force.strength = function(_2) {
+                return arguments.length ? (strength = typeof _2 === "function" ? _2 : constant(+_2), initialize(), force) : strength;
+              };
+              force.distanceMin = function(_2) {
+                return arguments.length ? (distanceMin2 = _2 * _2, force) : Math.sqrt(distanceMin2);
+              };
+              force.distanceMax = function(_2) {
+                return arguments.length ? (distanceMax2 = _2 * _2, force) : Math.sqrt(distanceMax2);
+              };
+              force.theta = function(_2) {
+                return arguments.length ? (theta2 = _2 * _2, force) : Math.sqrt(theta2);
+              };
+              return force;
+            }
+            function radial(radius, x22, y22) {
+              var nodes, strength = constant(0.1), strengths, radiuses;
+              if (typeof radius !== "function") radius = constant(+radius);
+              if (x22 == null) x22 = 0;
+              if (y22 == null) y22 = 0;
+              function force(alpha) {
+                for (var i2 = 0, n2 = nodes.length; i2 < n2; ++i2) {
+                  var node = nodes[i2], dx = node.x - x22 || 1e-6, dy = node.y - y22 || 1e-6, r2 = Math.sqrt(dx * dx + dy * dy), k2 = (radiuses[i2] - r2) * strengths[i2] * alpha / r2;
+                  node.vx += dx * k2;
+                  node.vy += dy * k2;
+                }
+              }
+              function initialize() {
+                if (!nodes) return;
+                var i2, n2 = nodes.length;
+                strengths = new Array(n2);
+                radiuses = new Array(n2);
+                for (i2 = 0; i2 < n2; ++i2) {
+                  radiuses[i2] = +radius(nodes[i2], i2, nodes);
+                  strengths[i2] = isNaN(radiuses[i2]) ? 0 : +strength(nodes[i2], i2, nodes);
+                }
+              }
+              force.initialize = function(_2) {
+                nodes = _2, initialize();
+              };
+              force.strength = function(_2) {
+                return arguments.length ? (strength = typeof _2 === "function" ? _2 : constant(+_2), initialize(), force) : strength;
+              };
+              force.radius = function(_2) {
+                return arguments.length ? (radius = typeof _2 === "function" ? _2 : constant(+_2), initialize(), force) : radius;
+              };
+              force.x = function(_2) {
+                return arguments.length ? (x22 = +_2, force) : x22;
+              };
+              force.y = function(_2) {
+                return arguments.length ? (y22 = +_2, force) : y22;
+              };
+              return force;
+            }
+            function x$2(x22) {
+              var strength = constant(0.1), nodes, strengths, xz;
+              if (typeof x22 !== "function") x22 = constant(x22 == null ? 0 : +x22);
+              function force(alpha) {
+                for (var i2 = 0, n2 = nodes.length, node; i2 < n2; ++i2) {
+                  node = nodes[i2], node.vx += (xz[i2] - node.x) * strengths[i2] * alpha;
+                }
+              }
+              function initialize() {
+                if (!nodes) return;
+                var i2, n2 = nodes.length;
+                strengths = new Array(n2);
+                xz = new Array(n2);
+                for (i2 = 0; i2 < n2; ++i2) {
+                  strengths[i2] = isNaN(xz[i2] = +x22(nodes[i2], i2, nodes)) ? 0 : +strength(nodes[i2], i2, nodes);
+                }
+              }
+              force.initialize = function(_2) {
+                nodes = _2;
+                initialize();
+              };
+              force.strength = function(_2) {
+                return arguments.length ? (strength = typeof _2 === "function" ? _2 : constant(+_2), initialize(), force) : strength;
+              };
+              force.x = function(_2) {
+                return arguments.length ? (x22 = typeof _2 === "function" ? _2 : constant(+_2), initialize(), force) : x22;
+              };
+              return force;
+            }
+            function y$2(y22) {
+              var strength = constant(0.1), nodes, strengths, yz;
+              if (typeof y22 !== "function") y22 = constant(y22 == null ? 0 : +y22);
+              function force(alpha) {
+                for (var i2 = 0, n2 = nodes.length, node; i2 < n2; ++i2) {
+                  node = nodes[i2], node.vy += (yz[i2] - node.y) * strengths[i2] * alpha;
+                }
+              }
+              function initialize() {
+                if (!nodes) return;
+                var i2, n2 = nodes.length;
+                strengths = new Array(n2);
+                yz = new Array(n2);
+                for (i2 = 0; i2 < n2; ++i2) {
+                  strengths[i2] = isNaN(yz[i2] = +y22(nodes[i2], i2, nodes)) ? 0 : +strength(nodes[i2], i2, nodes);
+                }
+              }
+              force.initialize = function(_2) {
+                nodes = _2;
+                initialize();
+              };
+              force.strength = function(_2) {
+                return arguments.length ? (strength = typeof _2 === "function" ? _2 : constant(+_2), initialize(), force) : strength;
+              };
+              force.y = function(_2) {
+                return arguments.length ? (y22 = typeof _2 === "function" ? _2 : constant(+_2), initialize(), force) : y22;
+              };
+              return force;
+            }
+            exports2.forceCenter = center;
+            exports2.forceCollide = collide;
+            exports2.forceLink = link;
+            exports2.forceManyBody = manyBody;
+            exports2.forceRadial = radial;
+            exports2.forceSimulation = simulation;
+            exports2.forceX = x$2;
+            exports2.forceY = y$2;
+            Object.defineProperty(exports2, "__esModule", { value: true });
+          });
+        }
+      });
+      var require_d3_path = __commonJS({
+        "node_modules/d3-path/dist/d3-path.js"(exports, module2) {
+          (function(global2, factory2) {
+            typeof exports === "object" && typeof module2 !== "undefined" ? factory2(exports) : (global2 = global2 || self, factory2(global2.d3 = global2.d3 || {}));
+          })(exports, function(exports2) {
+            var pi2 = Math.PI, tau = 2 * pi2, epsilon = 1e-6, tauEpsilon = tau - epsilon;
+            function Path() {
+              this._x0 = this._y0 = // start of current subpath
+              this._x1 = this._y1 = null;
+              this._ = "";
+            }
+            function path() {
+              return new Path();
+            }
+            Path.prototype = path.prototype = {
+              constructor: Path,
+              moveTo: function(x2, y2) {
+                this._ += "M" + (this._x0 = this._x1 = +x2) + "," + (this._y0 = this._y1 = +y2);
+              },
+              closePath: function() {
+                if (this._x1 !== null) {
+                  this._x1 = this._x0, this._y1 = this._y0;
+                  this._ += "Z";
+                }
+              },
+              lineTo: function(x2, y2) {
+                this._ += "L" + (this._x1 = +x2) + "," + (this._y1 = +y2);
+              },
+              quadraticCurveTo: function(x1, y1, x2, y2) {
+                this._ += "Q" + +x1 + "," + +y1 + "," + (this._x1 = +x2) + "," + (this._y1 = +y2);
+              },
+              bezierCurveTo: function(x1, y1, x2, y2, x3, y3) {
+                this._ += "C" + +x1 + "," + +y1 + "," + +x2 + "," + +y2 + "," + (this._x1 = +x3) + "," + (this._y1 = +y3);
+              },
+              arcTo: function(x1, y1, x2, y2, r2) {
+                x1 = +x1, y1 = +y1, x2 = +x2, y2 = +y2, r2 = +r2;
+                var x0 = this._x1, y0 = this._y1, x21 = x2 - x1, y21 = y2 - y1, x01 = x0 - x1, y01 = y0 - y1, l01_2 = x01 * x01 + y01 * y01;
+                if (r2 < 0) throw new Error("negative radius: " + r2);
+                if (this._x1 === null) {
+                  this._ += "M" + (this._x1 = x1) + "," + (this._y1 = y1);
+                } else if (!(l01_2 > epsilon)) ;
+                else if (!(Math.abs(y01 * x21 - y21 * x01) > epsilon) || !r2) {
+                  this._ += "L" + (this._x1 = x1) + "," + (this._y1 = y1);
+                } else {
+                  var x20 = x2 - x0, y20 = y2 - y0, l21_2 = x21 * x21 + y21 * y21, l20_2 = x20 * x20 + y20 * y20, l21 = Math.sqrt(l21_2), l01 = Math.sqrt(l01_2), l2 = r2 * Math.tan((pi2 - Math.acos((l21_2 + l01_2 - l20_2) / (2 * l21 * l01))) / 2), t01 = l2 / l01, t21 = l2 / l21;
+                  if (Math.abs(t01 - 1) > epsilon) {
+                    this._ += "L" + (x1 + t01 * x01) + "," + (y1 + t01 * y01);
+                  }
+                  this._ += "A" + r2 + "," + r2 + ",0,0," + +(y01 * x20 > x01 * y20) + "," + (this._x1 = x1 + t21 * x21) + "," + (this._y1 = y1 + t21 * y21);
+                }
+              },
+              arc: function(x2, y2, r2, a0, a1, ccw) {
+                x2 = +x2, y2 = +y2, r2 = +r2, ccw = !!ccw;
+                var dx = r2 * Math.cos(a0), dy = r2 * Math.sin(a0), x0 = x2 + dx, y0 = y2 + dy, cw = 1 ^ ccw, da2 = ccw ? a0 - a1 : a1 - a0;
+                if (r2 < 0) throw new Error("negative radius: " + r2);
+                if (this._x1 === null) {
+                  this._ += "M" + x0 + "," + y0;
+                } else if (Math.abs(this._x1 - x0) > epsilon || Math.abs(this._y1 - y0) > epsilon) {
+                  this._ += "L" + x0 + "," + y0;
+                }
+                if (!r2) return;
+                if (da2 < 0) da2 = da2 % tau + tau;
+                if (da2 > tauEpsilon) {
+                  this._ += "A" + r2 + "," + r2 + ",0,1," + cw + "," + (x2 - dx) + "," + (y2 - dy) + "A" + r2 + "," + r2 + ",0,1," + cw + "," + (this._x1 = x0) + "," + (this._y1 = y0);
+                } else if (da2 > epsilon) {
+                  this._ += "A" + r2 + "," + r2 + ",0," + +(da2 >= pi2) + "," + cw + "," + (this._x1 = x2 + r2 * Math.cos(a1)) + "," + (this._y1 = y2 + r2 * Math.sin(a1));
+                }
+              },
+              rect: function(x2, y2, w2, h2) {
+                this._ += "M" + (this._x0 = this._x1 = +x2) + "," + (this._y0 = this._y1 = +y2) + "h" + +w2 + "v" + +h2 + "h" + -w2 + "Z";
+              },
+              toString: function() {
+                return this._;
+              }
+            };
+            exports2.path = path;
+            Object.defineProperty(exports2, "__esModule", { value: true });
+          });
+        }
+      });
+      var require_d3_shape = __commonJS({
+        "node_modules/d3-shape/dist/d3-shape.js"(exports, module2) {
+          (function(global2, factory2) {
+            typeof exports === "object" && typeof module2 !== "undefined" ? factory2(exports, require_d3_path()) : (global2 = global2 || self, factory2(global2.d3 = global2.d3 || {}, global2.d3));
+          })(exports, function(exports2, d3Path) {
+            function constant(x22) {
+              return function constant2() {
+                return x22;
+              };
+            }
+            var abs = Math.abs;
+            var atan2 = Math.atan2;
+            var cos = Math.cos;
+            var max = Math.max;
+            var min = Math.min;
+            var sin = Math.sin;
+            var sqrt = Math.sqrt;
+            var epsilon = 1e-12;
+            var pi2 = Math.PI;
+            var halfPi = pi2 / 2;
+            var tau = 2 * pi2;
+            function acos(x22) {
+              return x22 > 1 ? 0 : x22 < -1 ? pi2 : Math.acos(x22);
+            }
+            function asin(x22) {
+              return x22 >= 1 ? halfPi : x22 <= -1 ? -halfPi : Math.asin(x22);
+            }
+            function arcInnerRadius(d2) {
+              return d2.innerRadius;
+            }
+            function arcOuterRadius(d2) {
+              return d2.outerRadius;
+            }
+            function arcStartAngle(d2) {
+              return d2.startAngle;
+            }
+            function arcEndAngle(d2) {
+              return d2.endAngle;
+            }
+            function arcPadAngle(d2) {
+              return d2 && d2.padAngle;
+            }
+            function intersect(x0, y0, x1, y1, x22, y22, x3, y3) {
+              var x10 = x1 - x0, y10 = y1 - y0, x32 = x3 - x22, y32 = y3 - y22, t4 = y32 * x10 - x32 * y10;
+              if (t4 * t4 < epsilon) return;
+              t4 = (x32 * (y0 - y22) - y32 * (x0 - x22)) / t4;
+              return [x0 + t4 * x10, y0 + t4 * y10];
+            }
+            function cornerTangents(x0, y0, x1, y1, r1, rc2, cw) {
+              var x01 = x0 - x1, y01 = y0 - y1, lo = (cw ? rc2 : -rc2) / sqrt(x01 * x01 + y01 * y01), ox = lo * y01, oy = -lo * x01, x11 = x0 + ox, y11 = y0 + oy, x10 = x1 + ox, y10 = y1 + oy, x00 = (x11 + x10) / 2, y00 = (y11 + y10) / 2, dx = x10 - x11, dy = y10 - y11, d2 = dx * dx + dy * dy, r2 = r1 - rc2, D22 = x11 * y10 - x10 * y11, d3 = (dy < 0 ? -1 : 1) * sqrt(max(0, r2 * r2 * d2 - D22 * D22)), cx0 = (D22 * dy - dx * d3) / d2, cy0 = (-D22 * dx - dy * d3) / d2, cx1 = (D22 * dy + dx * d3) / d2, cy1 = (-D22 * dx + dy * d3) / d2, dx0 = cx0 - x00, dy0 = cy0 - y00, dx1 = cx1 - x00, dy1 = cy1 - y00;
+              if (dx0 * dx0 + dy0 * dy0 > dx1 * dx1 + dy1 * dy1) cx0 = cx1, cy0 = cy1;
+              return {
+                cx: cx0,
+                cy: cy0,
+                x01: -ox,
+                y01: -oy,
+                x11: cx0 * (r1 / r2 - 1),
+                y11: cy0 * (r1 / r2 - 1)
+              };
+            }
+            function arc() {
+              var innerRadius = arcInnerRadius, outerRadius = arcOuterRadius, cornerRadius = constant(0), padRadius = null, startAngle = arcStartAngle, endAngle = arcEndAngle, padAngle = arcPadAngle, context = null;
+              function arc2() {
+                var buffer, r2, r0 = +innerRadius.apply(this, arguments), r1 = +outerRadius.apply(this, arguments), a0 = startAngle.apply(this, arguments) - halfPi, a1 = endAngle.apply(this, arguments) - halfPi, da2 = abs(a1 - a0), cw = a1 > a0;
+                if (!context) context = buffer = d3Path.path();
+                if (r1 < r0) r2 = r1, r1 = r0, r0 = r2;
+                if (!(r1 > epsilon)) context.moveTo(0, 0);
+                else if (da2 > tau - epsilon) {
+                  context.moveTo(r1 * cos(a0), r1 * sin(a0));
+                  context.arc(0, 0, r1, a0, a1, !cw);
+                  if (r0 > epsilon) {
+                    context.moveTo(r0 * cos(a1), r0 * sin(a1));
+                    context.arc(0, 0, r0, a1, a0, cw);
+                  }
+                } else {
+                  var a01 = a0, a11 = a1, a00 = a0, a10 = a1, da0 = da2, da1 = da2, ap = padAngle.apply(this, arguments) / 2, rp = ap > epsilon && (padRadius ? +padRadius.apply(this, arguments) : sqrt(r0 * r0 + r1 * r1)), rc2 = min(abs(r1 - r0) / 2, +cornerRadius.apply(this, arguments)), rc0 = rc2, rc1 = rc2, t02, t12;
+                  if (rp > epsilon) {
+                    var p0 = asin(rp / r0 * sin(ap)), p1 = asin(rp / r1 * sin(ap));
+                    if ((da0 -= p0 * 2) > epsilon) p0 *= cw ? 1 : -1, a00 += p0, a10 -= p0;
+                    else da0 = 0, a00 = a10 = (a0 + a1) / 2;
+                    if ((da1 -= p1 * 2) > epsilon) p1 *= cw ? 1 : -1, a01 += p1, a11 -= p1;
+                    else da1 = 0, a01 = a11 = (a0 + a1) / 2;
+                  }
+                  var x01 = r1 * cos(a01), y01 = r1 * sin(a01), x10 = r0 * cos(a10), y10 = r0 * sin(a10);
+                  if (rc2 > epsilon) {
+                    var x11 = r1 * cos(a11), y11 = r1 * sin(a11), x00 = r0 * cos(a00), y00 = r0 * sin(a00), oc2;
+                    if (da2 < pi2 && (oc2 = intersect(x01, y01, x00, y00, x11, y11, x10, y10))) {
+                      var ax = x01 - oc2[0], ay = y01 - oc2[1], bx = x11 - oc2[0], by = y11 - oc2[1], kc2 = 1 / sin(acos((ax * bx + ay * by) / (sqrt(ax * ax + ay * ay) * sqrt(bx * bx + by * by))) / 2), lc2 = sqrt(oc2[0] * oc2[0] + oc2[1] * oc2[1]);
+                      rc0 = min(rc2, (r0 - lc2) / (kc2 - 1));
+                      rc1 = min(rc2, (r1 - lc2) / (kc2 + 1));
+                    }
+                  }
+                  if (!(da1 > epsilon)) context.moveTo(x01, y01);
+                  else if (rc1 > epsilon) {
+                    t02 = cornerTangents(x00, y00, x01, y01, r1, rc1, cw);
+                    t12 = cornerTangents(x11, y11, x10, y10, r1, rc1, cw);
+                    context.moveTo(t02.cx + t02.x01, t02.cy + t02.y01);
+                    if (rc1 < rc2) context.arc(t02.cx, t02.cy, rc1, atan2(t02.y01, t02.x01), atan2(t12.y01, t12.x01), !cw);
+                    else {
+                      context.arc(t02.cx, t02.cy, rc1, atan2(t02.y01, t02.x01), atan2(t02.y11, t02.x11), !cw);
+                      context.arc(0, 0, r1, atan2(t02.cy + t02.y11, t02.cx + t02.x11), atan2(t12.cy + t12.y11, t12.cx + t12.x11), !cw);
+                      context.arc(t12.cx, t12.cy, rc1, atan2(t12.y11, t12.x11), atan2(t12.y01, t12.x01), !cw);
+                    }
+                  } else context.moveTo(x01, y01), context.arc(0, 0, r1, a01, a11, !cw);
+                  if (!(r0 > epsilon) || !(da0 > epsilon)) context.lineTo(x10, y10);
+                  else if (rc0 > epsilon) {
+                    t02 = cornerTangents(x10, y10, x11, y11, r0, -rc0, cw);
+                    t12 = cornerTangents(x01, y01, x00, y00, r0, -rc0, cw);
+                    context.lineTo(t02.cx + t02.x01, t02.cy + t02.y01);
+                    if (rc0 < rc2) context.arc(t02.cx, t02.cy, rc0, atan2(t02.y01, t02.x01), atan2(t12.y01, t12.x01), !cw);
+                    else {
+                      context.arc(t02.cx, t02.cy, rc0, atan2(t02.y01, t02.x01), atan2(t02.y11, t02.x11), !cw);
+                      context.arc(0, 0, r0, atan2(t02.cy + t02.y11, t02.cx + t02.x11), atan2(t12.cy + t12.y11, t12.cx + t12.x11), cw);
+                      context.arc(t12.cx, t12.cy, rc0, atan2(t12.y11, t12.x11), atan2(t12.y01, t12.x01), !cw);
+                    }
+                  } else context.arc(0, 0, r0, a10, a00, cw);
+                }
+                context.closePath();
+                if (buffer) return context = null, buffer + "" || null;
+              }
+              arc2.centroid = function() {
+                var r2 = (+innerRadius.apply(this, arguments) + +outerRadius.apply(this, arguments)) / 2, a22 = (+startAngle.apply(this, arguments) + +endAngle.apply(this, arguments)) / 2 - pi2 / 2;
+                return [cos(a22) * r2, sin(a22) * r2];
+              };
+              arc2.innerRadius = function(_2) {
+                return arguments.length ? (innerRadius = typeof _2 === "function" ? _2 : constant(+_2), arc2) : innerRadius;
+              };
+              arc2.outerRadius = function(_2) {
+                return arguments.length ? (outerRadius = typeof _2 === "function" ? _2 : constant(+_2), arc2) : outerRadius;
+              };
+              arc2.cornerRadius = function(_2) {
+                return arguments.length ? (cornerRadius = typeof _2 === "function" ? _2 : constant(+_2), arc2) : cornerRadius;
+              };
+              arc2.padRadius = function(_2) {
+                return arguments.length ? (padRadius = _2 == null ? null : typeof _2 === "function" ? _2 : constant(+_2), arc2) : padRadius;
+              };
+              arc2.startAngle = function(_2) {
+                return arguments.length ? (startAngle = typeof _2 === "function" ? _2 : constant(+_2), arc2) : startAngle;
+              };
+              arc2.endAngle = function(_2) {
+                return arguments.length ? (endAngle = typeof _2 === "function" ? _2 : constant(+_2), arc2) : endAngle;
+              };
+              arc2.padAngle = function(_2) {
+                return arguments.length ? (padAngle = typeof _2 === "function" ? _2 : constant(+_2), arc2) : padAngle;
+              };
+              arc2.context = function(_2) {
+                return arguments.length ? (context = _2 == null ? null : _2, arc2) : context;
+              };
+              return arc2;
+            }
+            function Linear(context) {
+              this._context = context;
+            }
+            Linear.prototype = {
+              areaStart: function() {
+                this._line = 0;
+              },
+              areaEnd: function() {
+                this._line = NaN;
+              },
+              lineStart: function() {
+                this._point = 0;
+              },
+              lineEnd: function() {
+                if (this._line || this._line !== 0 && this._point === 1) this._context.closePath();
+                this._line = 1 - this._line;
+              },
+              point: function(x22, y22) {
+                x22 = +x22, y22 = +y22;
+                switch (this._point) {
+                  case 0:
+                    this._point = 1;
+                    this._line ? this._context.lineTo(x22, y22) : this._context.moveTo(x22, y22);
+                    break;
+                  case 1:
+                    this._point = 2;
+                  default:
+                    this._context.lineTo(x22, y22);
+                    break;
+                }
+              }
+            };
+            function curveLinear(context) {
+              return new Linear(context);
+            }
+            function x2(p2) {
+              return p2[0];
+            }
+            function y2(p2) {
+              return p2[1];
+            }
+            function line() {
+              var x$12 = x2, y$12 = y2, defined = constant(true), context = null, curve = curveLinear, output = null;
+              function line2(data) {
+                var i2, n2 = data.length, d2, defined0 = false, buffer;
+                if (context == null) output = curve(buffer = d3Path.path());
+                for (i2 = 0; i2 <= n2; ++i2) {
+                  if (!(i2 < n2 && defined(d2 = data[i2], i2, data)) === defined0) {
+                    if (defined0 = !defined0) output.lineStart();
+                    else output.lineEnd();
+                  }
+                  if (defined0) output.point(+x$12(d2, i2, data), +y$12(d2, i2, data));
+                }
+                if (buffer) return output = null, buffer + "" || null;
+              }
+              line2.x = function(_2) {
+                return arguments.length ? (x$12 = typeof _2 === "function" ? _2 : constant(+_2), line2) : x$12;
+              };
+              line2.y = function(_2) {
+                return arguments.length ? (y$12 = typeof _2 === "function" ? _2 : constant(+_2), line2) : y$12;
+              };
+              line2.defined = function(_2) {
+                return arguments.length ? (defined = typeof _2 === "function" ? _2 : constant(!!_2), line2) : defined;
+              };
+              line2.curve = function(_2) {
+                return arguments.length ? (curve = _2, context != null && (output = curve(context)), line2) : curve;
+              };
+              line2.context = function(_2) {
+                return arguments.length ? (_2 == null ? context = output = null : output = curve(context = _2), line2) : context;
+              };
+              return line2;
+            }
+            function area() {
+              var x0 = x2, x1 = null, y0 = constant(0), y1 = y2, defined = constant(true), context = null, curve = curveLinear, output = null;
+              function area2(data) {
+                var i2, j2, k22, n2 = data.length, d2, defined0 = false, buffer, x0z = new Array(n2), y0z = new Array(n2);
+                if (context == null) output = curve(buffer = d3Path.path());
+                for (i2 = 0; i2 <= n2; ++i2) {
+                  if (!(i2 < n2 && defined(d2 = data[i2], i2, data)) === defined0) {
+                    if (defined0 = !defined0) {
+                      j2 = i2;
+                      output.areaStart();
+                      output.lineStart();
+                    } else {
+                      output.lineEnd();
+                      output.lineStart();
+                      for (k22 = i2 - 1; k22 >= j2; --k22) {
+                        output.point(x0z[k22], y0z[k22]);
+                      }
+                      output.lineEnd();
+                      output.areaEnd();
+                    }
+                  }
+                  if (defined0) {
+                    x0z[i2] = +x0(d2, i2, data), y0z[i2] = +y0(d2, i2, data);
+                    output.point(x1 ? +x1(d2, i2, data) : x0z[i2], y1 ? +y1(d2, i2, data) : y0z[i2]);
+                  }
+                }
+                if (buffer) return output = null, buffer + "" || null;
+              }
+              function arealine() {
+                return line().defined(defined).curve(curve).context(context);
+              }
+              area2.x = function(_2) {
+                return arguments.length ? (x0 = typeof _2 === "function" ? _2 : constant(+_2), x1 = null, area2) : x0;
+              };
+              area2.x0 = function(_2) {
+                return arguments.length ? (x0 = typeof _2 === "function" ? _2 : constant(+_2), area2) : x0;
+              };
+              area2.x1 = function(_2) {
+                return arguments.length ? (x1 = _2 == null ? null : typeof _2 === "function" ? _2 : constant(+_2), area2) : x1;
+              };
+              area2.y = function(_2) {
+                return arguments.length ? (y0 = typeof _2 === "function" ? _2 : constant(+_2), y1 = null, area2) : y0;
+              };
+              area2.y0 = function(_2) {
+                return arguments.length ? (y0 = typeof _2 === "function" ? _2 : constant(+_2), area2) : y0;
+              };
+              area2.y1 = function(_2) {
+                return arguments.length ? (y1 = _2 == null ? null : typeof _2 === "function" ? _2 : constant(+_2), area2) : y1;
+              };
+              area2.lineX0 = area2.lineY0 = function() {
+                return arealine().x(x0).y(y0);
+              };
+              area2.lineY1 = function() {
+                return arealine().x(x0).y(y1);
+              };
+              area2.lineX1 = function() {
+                return arealine().x(x1).y(y0);
+              };
+              area2.defined = function(_2) {
+                return arguments.length ? (defined = typeof _2 === "function" ? _2 : constant(!!_2), area2) : defined;
+              };
+              area2.curve = function(_2) {
+                return arguments.length ? (curve = _2, context != null && (output = curve(context)), area2) : curve;
+              };
+              area2.context = function(_2) {
+                return arguments.length ? (_2 == null ? context = output = null : output = curve(context = _2), area2) : context;
+              };
+              return area2;
+            }
+            function descending(a22, b2) {
+              return b2 < a22 ? -1 : b2 > a22 ? 1 : b2 >= a22 ? 0 : NaN;
+            }
+            function identity22(d2) {
+              return d2;
+            }
+            function pie() {
+              var value = identity22, sortValues = descending, sort = null, startAngle = constant(0), endAngle = constant(tau), padAngle = constant(0);
+              function pie2(data) {
+                var i2, n2 = data.length, j2, k22, sum2 = 0, index = new Array(n2), arcs = new Array(n2), a0 = +startAngle.apply(this, arguments), da2 = Math.min(tau, Math.max(-tau, endAngle.apply(this, arguments) - a0)), a1, p2 = Math.min(Math.abs(da2) / n2, padAngle.apply(this, arguments)), pa2 = p2 * (da2 < 0 ? -1 : 1), v2;
+                for (i2 = 0; i2 < n2; ++i2) {
+                  if ((v2 = arcs[index[i2] = i2] = +value(data[i2], i2, data)) > 0) {
+                    sum2 += v2;
+                  }
+                }
+                if (sortValues != null) index.sort(function(i22, j22) {
+                  return sortValues(arcs[i22], arcs[j22]);
+                });
+                else if (sort != null) index.sort(function(i22, j22) {
+                  return sort(data[i22], data[j22]);
+                });
+                for (i2 = 0, k22 = sum2 ? (da2 - n2 * pa2) / sum2 : 0; i2 < n2; ++i2, a0 = a1) {
+                  j2 = index[i2], v2 = arcs[j2], a1 = a0 + (v2 > 0 ? v2 * k22 : 0) + pa2, arcs[j2] = {
+                    data: data[j2],
+                    index: i2,
+                    value: v2,
+                    startAngle: a0,
+                    endAngle: a1,
+                    padAngle: p2
+                  };
+                }
+                return arcs;
+              }
+              pie2.value = function(_2) {
+                return arguments.length ? (value = typeof _2 === "function" ? _2 : constant(+_2), pie2) : value;
+              };
+              pie2.sortValues = function(_2) {
+                return arguments.length ? (sortValues = _2, sort = null, pie2) : sortValues;
+              };
+              pie2.sort = function(_2) {
+                return arguments.length ? (sort = _2, sortValues = null, pie2) : sort;
+              };
+              pie2.startAngle = function(_2) {
+                return arguments.length ? (startAngle = typeof _2 === "function" ? _2 : constant(+_2), pie2) : startAngle;
+              };
+              pie2.endAngle = function(_2) {
+                return arguments.length ? (endAngle = typeof _2 === "function" ? _2 : constant(+_2), pie2) : endAngle;
+              };
+              pie2.padAngle = function(_2) {
+                return arguments.length ? (padAngle = typeof _2 === "function" ? _2 : constant(+_2), pie2) : padAngle;
+              };
+              return pie2;
+            }
+            var curveRadialLinear = curveRadial(curveLinear);
+            function Radial(curve) {
+              this._curve = curve;
+            }
+            Radial.prototype = {
+              areaStart: function() {
+                this._curve.areaStart();
+              },
+              areaEnd: function() {
+                this._curve.areaEnd();
+              },
+              lineStart: function() {
+                this._curve.lineStart();
+              },
+              lineEnd: function() {
+                this._curve.lineEnd();
+              },
+              point: function(a22, r2) {
+                this._curve.point(r2 * Math.sin(a22), r2 * -Math.cos(a22));
+              }
+            };
+            function curveRadial(curve) {
+              function radial(context) {
+                return new Radial(curve(context));
+              }
+              radial._curve = curve;
+              return radial;
+            }
+            function lineRadial(l2) {
+              var c22 = l2.curve;
+              l2.angle = l2.x, delete l2.x;
+              l2.radius = l2.y, delete l2.y;
+              l2.curve = function(_2) {
+                return arguments.length ? c22(curveRadial(_2)) : c22()._curve;
+              };
+              return l2;
+            }
+            function lineRadial$1() {
+              return lineRadial(line().curve(curveRadialLinear));
+            }
+            function areaRadial() {
+              var a22 = area().curve(curveRadialLinear), c22 = a22.curve, x0 = a22.lineX0, x1 = a22.lineX1, y0 = a22.lineY0, y1 = a22.lineY1;
+              a22.angle = a22.x, delete a22.x;
+              a22.startAngle = a22.x0, delete a22.x0;
+              a22.endAngle = a22.x1, delete a22.x1;
+              a22.radius = a22.y, delete a22.y;
+              a22.innerRadius = a22.y0, delete a22.y0;
+              a22.outerRadius = a22.y1, delete a22.y1;
+              a22.lineStartAngle = function() {
+                return lineRadial(x0());
+              }, delete a22.lineX0;
+              a22.lineEndAngle = function() {
+                return lineRadial(x1());
+              }, delete a22.lineX1;
+              a22.lineInnerRadius = function() {
+                return lineRadial(y0());
+              }, delete a22.lineY0;
+              a22.lineOuterRadius = function() {
+                return lineRadial(y1());
+              }, delete a22.lineY1;
+              a22.curve = function(_2) {
+                return arguments.length ? c22(curveRadial(_2)) : c22()._curve;
+              };
+              return a22;
+            }
+            function pointRadial(x22, y22) {
+              return [(y22 = +y22) * Math.cos(x22 -= Math.PI / 2), y22 * Math.sin(x22)];
+            }
+            var slice = Array.prototype.slice;
+            function linkSource(d2) {
+              return d2.source;
+            }
+            function linkTarget(d2) {
+              return d2.target;
+            }
+            function link(curve) {
+              var source2 = linkSource, target = linkTarget, x$12 = x2, y$12 = y2, context = null;
+              function link2() {
+                var buffer, argv = slice.call(arguments), s22 = source2.apply(this, argv), t4 = target.apply(this, argv);
+                if (!context) context = buffer = d3Path.path();
+                curve(context, +x$12.apply(this, (argv[0] = s22, argv)), +y$12.apply(this, argv), +x$12.apply(this, (argv[0] = t4, argv)), +y$12.apply(this, argv));
+                if (buffer) return context = null, buffer + "" || null;
+              }
+              link2.source = function(_2) {
+                return arguments.length ? (source2 = _2, link2) : source2;
+              };
+              link2.target = function(_2) {
+                return arguments.length ? (target = _2, link2) : target;
+              };
+              link2.x = function(_2) {
+                return arguments.length ? (x$12 = typeof _2 === "function" ? _2 : constant(+_2), link2) : x$12;
+              };
+              link2.y = function(_2) {
+                return arguments.length ? (y$12 = typeof _2 === "function" ? _2 : constant(+_2), link2) : y$12;
+              };
+              link2.context = function(_2) {
+                return arguments.length ? (context = _2 == null ? null : _2, link2) : context;
+              };
+              return link2;
+            }
+            function curveHorizontal(context, x0, y0, x1, y1) {
+              context.moveTo(x0, y0);
+              context.bezierCurveTo(x0 = (x0 + x1) / 2, y0, x0, y1, x1, y1);
+            }
+            function curveVertical(context, x0, y0, x1, y1) {
+              context.moveTo(x0, y0);
+              context.bezierCurveTo(x0, y0 = (y0 + y1) / 2, x1, y0, x1, y1);
+            }
+            function curveRadial$1(context, x0, y0, x1, y1) {
+              var p0 = pointRadial(x0, y0), p1 = pointRadial(x0, y0 = (y0 + y1) / 2), p2 = pointRadial(x1, y0), p3 = pointRadial(x1, y1);
+              context.moveTo(p0[0], p0[1]);
+              context.bezierCurveTo(p1[0], p1[1], p2[0], p2[1], p3[0], p3[1]);
+            }
+            function linkHorizontal() {
+              return link(curveHorizontal);
+            }
+            function linkVertical() {
+              return link(curveVertical);
+            }
+            function linkRadial() {
+              var l2 = link(curveRadial$1);
+              l2.angle = l2.x, delete l2.x;
+              l2.radius = l2.y, delete l2.y;
+              return l2;
+            }
+            var circle = {
+              draw: function(context, size) {
+                var r2 = Math.sqrt(size / pi2);
+                context.moveTo(r2, 0);
+                context.arc(0, 0, r2, 0, tau);
+              }
+            };
+            var cross2 = {
+              draw: function(context, size) {
+                var r2 = Math.sqrt(size / 5) / 2;
+                context.moveTo(-3 * r2, -r2);
+                context.lineTo(-r2, -r2);
+                context.lineTo(-r2, -3 * r2);
+                context.lineTo(r2, -3 * r2);
+                context.lineTo(r2, -r2);
+                context.lineTo(3 * r2, -r2);
+                context.lineTo(3 * r2, r2);
+                context.lineTo(r2, r2);
+                context.lineTo(r2, 3 * r2);
+                context.lineTo(-r2, 3 * r2);
+                context.lineTo(-r2, r2);
+                context.lineTo(-3 * r2, r2);
+                context.closePath();
+              }
+            };
+            var tan30 = Math.sqrt(1 / 3), tan30_2 = tan30 * 2;
+            var diamond = {
+              draw: function(context, size) {
+                var y22 = Math.sqrt(size / tan30_2), x22 = y22 * tan30;
+                context.moveTo(0, -y22);
+                context.lineTo(x22, 0);
+                context.lineTo(0, y22);
+                context.lineTo(-x22, 0);
+                context.closePath();
+              }
+            };
+            var ka2 = 0.8908130915292852, kr = Math.sin(pi2 / 10) / Math.sin(7 * pi2 / 10), kx = Math.sin(tau / 10) * kr, ky = -Math.cos(tau / 10) * kr;
+            var star = {
+              draw: function(context, size) {
+                var r2 = Math.sqrt(size * ka2), x22 = kx * r2, y22 = ky * r2;
+                context.moveTo(0, -r2);
+                context.lineTo(x22, y22);
+                for (var i2 = 1; i2 < 5; ++i2) {
+                  var a22 = tau * i2 / 5, c22 = Math.cos(a22), s22 = Math.sin(a22);
+                  context.lineTo(s22 * r2, -c22 * r2);
+                  context.lineTo(c22 * x22 - s22 * y22, s22 * x22 + c22 * y22);
+                }
+                context.closePath();
+              }
+            };
+            var square = {
+              draw: function(context, size) {
+                var w2 = Math.sqrt(size), x22 = -w2 / 2;
+                context.rect(x22, x22, w2, w2);
+              }
+            };
+            var sqrt3 = Math.sqrt(3);
+            var triangle = {
+              draw: function(context, size) {
+                var y22 = -Math.sqrt(size / (sqrt3 * 3));
+                context.moveTo(0, y22 * 2);
+                context.lineTo(-sqrt3 * y22, -y22);
+                context.lineTo(sqrt3 * y22, -y22);
+                context.closePath();
+              }
+            };
+            var c2 = -0.5, s2 = Math.sqrt(3) / 2, k2 = 1 / Math.sqrt(12), a2 = (k2 / 2 + 1) * 3;
+            var wye = {
+              draw: function(context, size) {
+                var r2 = Math.sqrt(size / a2), x0 = r2 / 2, y0 = r2 * k2, x1 = x0, y1 = r2 * k2 + r2, x22 = -x1, y22 = y1;
+                context.moveTo(x0, y0);
+                context.lineTo(x1, y1);
+                context.lineTo(x22, y22);
+                context.lineTo(c2 * x0 - s2 * y0, s2 * x0 + c2 * y0);
+                context.lineTo(c2 * x1 - s2 * y1, s2 * x1 + c2 * y1);
+                context.lineTo(c2 * x22 - s2 * y22, s2 * x22 + c2 * y22);
+                context.lineTo(c2 * x0 + s2 * y0, c2 * y0 - s2 * x0);
+                context.lineTo(c2 * x1 + s2 * y1, c2 * y1 - s2 * x1);
+                context.lineTo(c2 * x22 + s2 * y22, c2 * y22 - s2 * x22);
+                context.closePath();
+              }
+            };
+            var symbols = [
+              circle,
+              cross2,
+              diamond,
+              square,
+              star,
+              triangle,
+              wye
+            ];
+            function symbol() {
+              var type = constant(circle), size = constant(64), context = null;
+              function symbol2() {
+                var buffer;
+                if (!context) context = buffer = d3Path.path();
+                type.apply(this, arguments).draw(context, +size.apply(this, arguments));
+                if (buffer) return context = null, buffer + "" || null;
+              }
+              symbol2.type = function(_2) {
+                return arguments.length ? (type = typeof _2 === "function" ? _2 : constant(_2), symbol2) : type;
+              };
+              symbol2.size = function(_2) {
+                return arguments.length ? (size = typeof _2 === "function" ? _2 : constant(+_2), symbol2) : size;
+              };
+              symbol2.context = function(_2) {
+                return arguments.length ? (context = _2 == null ? null : _2, symbol2) : context;
+              };
+              return symbol2;
+            }
+            function noop2() {
+            }
+            function point(that, x22, y22) {
+              that._context.bezierCurveTo(
+                (2 * that._x0 + that._x1) / 3,
+                (2 * that._y0 + that._y1) / 3,
+                (that._x0 + 2 * that._x1) / 3,
+                (that._y0 + 2 * that._y1) / 3,
+                (that._x0 + 4 * that._x1 + x22) / 6,
+                (that._y0 + 4 * that._y1 + y22) / 6
+              );
+            }
+            function Basis(context) {
+              this._context = context;
+            }
+            Basis.prototype = {
+              areaStart: function() {
+                this._line = 0;
+              },
+              areaEnd: function() {
+                this._line = NaN;
+              },
+              lineStart: function() {
+                this._x0 = this._x1 = this._y0 = this._y1 = NaN;
+                this._point = 0;
+              },
+              lineEnd: function() {
+                switch (this._point) {
+                  case 3:
+                    point(this, this._x1, this._y1);
+                  case 2:
+                    this._context.lineTo(this._x1, this._y1);
+                    break;
+                }
+                if (this._line || this._line !== 0 && this._point === 1) this._context.closePath();
+                this._line = 1 - this._line;
+              },
+              point: function(x22, y22) {
+                x22 = +x22, y22 = +y22;
+                switch (this._point) {
+                  case 0:
+                    this._point = 1;
+                    this._line ? this._context.lineTo(x22, y22) : this._context.moveTo(x22, y22);
+                    break;
+                  case 1:
+                    this._point = 2;
+                    break;
+                  case 2:
+                    this._point = 3;
+                    this._context.lineTo((5 * this._x0 + this._x1) / 6, (5 * this._y0 + this._y1) / 6);
+                  default:
+                    point(this, x22, y22);
+                    break;
+                }
+                this._x0 = this._x1, this._x1 = x22;
+                this._y0 = this._y1, this._y1 = y22;
+              }
+            };
+            function basis2(context) {
+              return new Basis(context);
+            }
+            function BasisClosed(context) {
+              this._context = context;
+            }
+            BasisClosed.prototype = {
+              areaStart: noop2,
+              areaEnd: noop2,
+              lineStart: function() {
+                this._x0 = this._x1 = this._x2 = this._x3 = this._x4 = this._y0 = this._y1 = this._y2 = this._y3 = this._y4 = NaN;
+                this._point = 0;
+              },
+              lineEnd: function() {
+                switch (this._point) {
+                  case 1: {
+                    this._context.moveTo(this._x2, this._y2);
+                    this._context.closePath();
+                    break;
+                  }
+                  case 2: {
+                    this._context.moveTo((this._x2 + 2 * this._x3) / 3, (this._y2 + 2 * this._y3) / 3);
+                    this._context.lineTo((this._x3 + 2 * this._x2) / 3, (this._y3 + 2 * this._y2) / 3);
+                    this._context.closePath();
+                    break;
+                  }
+                  case 3: {
+                    this.point(this._x2, this._y2);
+                    this.point(this._x3, this._y3);
+                    this.point(this._x4, this._y4);
+                    break;
+                  }
+                }
+              },
+              point: function(x22, y22) {
+                x22 = +x22, y22 = +y22;
+                switch (this._point) {
+                  case 0:
+                    this._point = 1;
+                    this._x2 = x22, this._y2 = y22;
+                    break;
+                  case 1:
+                    this._point = 2;
+                    this._x3 = x22, this._y3 = y22;
+                    break;
+                  case 2:
+                    this._point = 3;
+                    this._x4 = x22, this._y4 = y22;
+                    this._context.moveTo((this._x0 + 4 * this._x1 + x22) / 6, (this._y0 + 4 * this._y1 + y22) / 6);
+                    break;
+                  default:
+                    point(this, x22, y22);
+                    break;
+                }
+                this._x0 = this._x1, this._x1 = x22;
+                this._y0 = this._y1, this._y1 = y22;
+              }
+            };
+            function basisClosed(context) {
+              return new BasisClosed(context);
+            }
+            function BasisOpen(context) {
+              this._context = context;
+            }
+            BasisOpen.prototype = {
+              areaStart: function() {
+                this._line = 0;
+              },
+              areaEnd: function() {
+                this._line = NaN;
+              },
+              lineStart: function() {
+                this._x0 = this._x1 = this._y0 = this._y1 = NaN;
+                this._point = 0;
+              },
+              lineEnd: function() {
+                if (this._line || this._line !== 0 && this._point === 3) this._context.closePath();
+                this._line = 1 - this._line;
+              },
+              point: function(x22, y22) {
+                x22 = +x22, y22 = +y22;
+                switch (this._point) {
+                  case 0:
+                    this._point = 1;
+                    break;
+                  case 1:
+                    this._point = 2;
+                    break;
+                  case 2:
+                    this._point = 3;
+                    var x0 = (this._x0 + 4 * this._x1 + x22) / 6, y0 = (this._y0 + 4 * this._y1 + y22) / 6;
+                    this._line ? this._context.lineTo(x0, y0) : this._context.moveTo(x0, y0);
+                    break;
+                  case 3:
+                    this._point = 4;
+                  default:
+                    point(this, x22, y22);
+                    break;
+                }
+                this._x0 = this._x1, this._x1 = x22;
+                this._y0 = this._y1, this._y1 = y22;
+              }
+            };
+            function basisOpen(context) {
+              return new BasisOpen(context);
+            }
+            function Bundle(context, beta) {
+              this._basis = new Basis(context);
+              this._beta = beta;
+            }
+            Bundle.prototype = {
+              lineStart: function() {
+                this._x = [];
+                this._y = [];
+                this._basis.lineStart();
+              },
+              lineEnd: function() {
+                var x22 = this._x, y22 = this._y, j2 = x22.length - 1;
+                if (j2 > 0) {
+                  var x0 = x22[0], y0 = y22[0], dx = x22[j2] - x0, dy = y22[j2] - y0, i2 = -1, t4;
+                  while (++i2 <= j2) {
+                    t4 = i2 / j2;
+                    this._basis.point(
+                      this._beta * x22[i2] + (1 - this._beta) * (x0 + t4 * dx),
+                      this._beta * y22[i2] + (1 - this._beta) * (y0 + t4 * dy)
+                    );
+                  }
+                }
+                this._x = this._y = null;
+                this._basis.lineEnd();
+              },
+              point: function(x22, y22) {
+                this._x.push(+x22);
+                this._y.push(+y22);
+              }
+            };
+            var bundle = function custom(beta) {
+              function bundle2(context) {
+                return beta === 1 ? new Basis(context) : new Bundle(context, beta);
+              }
+              bundle2.beta = function(beta2) {
+                return custom(+beta2);
+              };
+              return bundle2;
+            }(0.85);
+            function point$1(that, x22, y22) {
+              that._context.bezierCurveTo(
+                that._x1 + that._k * (that._x2 - that._x0),
+                that._y1 + that._k * (that._y2 - that._y0),
+                that._x2 + that._k * (that._x1 - x22),
+                that._y2 + that._k * (that._y1 - y22),
+                that._x2,
+                that._y2
+              );
+            }
+            function Cardinal(context, tension) {
+              this._context = context;
+              this._k = (1 - tension) / 6;
+            }
+            Cardinal.prototype = {
+              areaStart: function() {
+                this._line = 0;
+              },
+              areaEnd: function() {
+                this._line = NaN;
+              },
+              lineStart: function() {
+                this._x0 = this._x1 = this._x2 = this._y0 = this._y1 = this._y2 = NaN;
+                this._point = 0;
+              },
+              lineEnd: function() {
+                switch (this._point) {
+                  case 2:
+                    this._context.lineTo(this._x2, this._y2);
+                    break;
+                  case 3:
+                    point$1(this, this._x1, this._y1);
+                    break;
+                }
+                if (this._line || this._line !== 0 && this._point === 1) this._context.closePath();
+                this._line = 1 - this._line;
+              },
+              point: function(x22, y22) {
+                x22 = +x22, y22 = +y22;
+                switch (this._point) {
+                  case 0:
+                    this._point = 1;
+                    this._line ? this._context.lineTo(x22, y22) : this._context.moveTo(x22, y22);
+                    break;
+                  case 1:
+                    this._point = 2;
+                    this._x1 = x22, this._y1 = y22;
+                    break;
+                  case 2:
+                    this._point = 3;
+                  default:
+                    point$1(this, x22, y22);
+                    break;
+                }
+                this._x0 = this._x1, this._x1 = this._x2, this._x2 = x22;
+                this._y0 = this._y1, this._y1 = this._y2, this._y2 = y22;
+              }
+            };
+            var cardinal = function custom(tension) {
+              function cardinal2(context) {
+                return new Cardinal(context, tension);
+              }
+              cardinal2.tension = function(tension2) {
+                return custom(+tension2);
+              };
+              return cardinal2;
+            }(0);
+            function CardinalClosed(context, tension) {
+              this._context = context;
+              this._k = (1 - tension) / 6;
+            }
+            CardinalClosed.prototype = {
+              areaStart: noop2,
+              areaEnd: noop2,
+              lineStart: function() {
+                this._x0 = this._x1 = this._x2 = this._x3 = this._x4 = this._x5 = this._y0 = this._y1 = this._y2 = this._y3 = this._y4 = this._y5 = NaN;
+                this._point = 0;
+              },
+              lineEnd: function() {
+                switch (this._point) {
+                  case 1: {
+                    this._context.moveTo(this._x3, this._y3);
+                    this._context.closePath();
+                    break;
+                  }
+                  case 2: {
+                    this._context.lineTo(this._x3, this._y3);
+                    this._context.closePath();
+                    break;
+                  }
+                  case 3: {
+                    this.point(this._x3, this._y3);
+                    this.point(this._x4, this._y4);
+                    this.point(this._x5, this._y5);
+                    break;
+                  }
+                }
+              },
+              point: function(x22, y22) {
+                x22 = +x22, y22 = +y22;
+                switch (this._point) {
+                  case 0:
+                    this._point = 1;
+                    this._x3 = x22, this._y3 = y22;
+                    break;
+                  case 1:
+                    this._point = 2;
+                    this._context.moveTo(this._x4 = x22, this._y4 = y22);
+                    break;
+                  case 2:
+                    this._point = 3;
+                    this._x5 = x22, this._y5 = y22;
+                    break;
+                  default:
+                    point$1(this, x22, y22);
+                    break;
+                }
+                this._x0 = this._x1, this._x1 = this._x2, this._x2 = x22;
+                this._y0 = this._y1, this._y1 = this._y2, this._y2 = y22;
+              }
+            };
+            var cardinalClosed = function custom(tension) {
+              function cardinal2(context) {
+                return new CardinalClosed(context, tension);
+              }
+              cardinal2.tension = function(tension2) {
+                return custom(+tension2);
+              };
+              return cardinal2;
+            }(0);
+            function CardinalOpen(context, tension) {
+              this._context = context;
+              this._k = (1 - tension) / 6;
+            }
+            CardinalOpen.prototype = {
+              areaStart: function() {
+                this._line = 0;
+              },
+              areaEnd: function() {
+                this._line = NaN;
+              },
+              lineStart: function() {
+                this._x0 = this._x1 = this._x2 = this._y0 = this._y1 = this._y2 = NaN;
+                this._point = 0;
+              },
+              lineEnd: function() {
+                if (this._line || this._line !== 0 && this._point === 3) this._context.closePath();
+                this._line = 1 - this._line;
+              },
+              point: function(x22, y22) {
+                x22 = +x22, y22 = +y22;
+                switch (this._point) {
+                  case 0:
+                    this._point = 1;
+                    break;
+                  case 1:
+                    this._point = 2;
+                    break;
+                  case 2:
+                    this._point = 3;
+                    this._line ? this._context.lineTo(this._x2, this._y2) : this._context.moveTo(this._x2, this._y2);
+                    break;
+                  case 3:
+                    this._point = 4;
+                  default:
+                    point$1(this, x22, y22);
+                    break;
+                }
+                this._x0 = this._x1, this._x1 = this._x2, this._x2 = x22;
+                this._y0 = this._y1, this._y1 = this._y2, this._y2 = y22;
+              }
+            };
+            var cardinalOpen = function custom(tension) {
+              function cardinal2(context) {
+                return new CardinalOpen(context, tension);
+              }
+              cardinal2.tension = function(tension2) {
+                return custom(+tension2);
+              };
+              return cardinal2;
+            }(0);
+            function point$2(that, x22, y22) {
+              var x1 = that._x1, y1 = that._y1, x222 = that._x2, y222 = that._y2;
+              if (that._l01_a > epsilon) {
+                var a22 = 2 * that._l01_2a + 3 * that._l01_a * that._l12_a + that._l12_2a, n2 = 3 * that._l01_a * (that._l01_a + that._l12_a);
+                x1 = (x1 * a22 - that._x0 * that._l12_2a + that._x2 * that._l01_2a) / n2;
+                y1 = (y1 * a22 - that._y0 * that._l12_2a + that._y2 * that._l01_2a) / n2;
+              }
+              if (that._l23_a > epsilon) {
+                var b2 = 2 * that._l23_2a + 3 * that._l23_a * that._l12_a + that._l12_2a, m2 = 3 * that._l23_a * (that._l23_a + that._l12_a);
+                x222 = (x222 * b2 + that._x1 * that._l23_2a - x22 * that._l12_2a) / m2;
+                y222 = (y222 * b2 + that._y1 * that._l23_2a - y22 * that._l12_2a) / m2;
+              }
+              that._context.bezierCurveTo(x1, y1, x222, y222, that._x2, that._y2);
+            }
+            function CatmullRom(context, alpha) {
+              this._context = context;
+              this._alpha = alpha;
+            }
+            CatmullRom.prototype = {
+              areaStart: function() {
+                this._line = 0;
+              },
+              areaEnd: function() {
+                this._line = NaN;
+              },
+              lineStart: function() {
+                this._x0 = this._x1 = this._x2 = this._y0 = this._y1 = this._y2 = NaN;
+                this._l01_a = this._l12_a = this._l23_a = this._l01_2a = this._l12_2a = this._l23_2a = this._point = 0;
+              },
+              lineEnd: function() {
+                switch (this._point) {
+                  case 2:
+                    this._context.lineTo(this._x2, this._y2);
+                    break;
+                  case 3:
+                    this.point(this._x2, this._y2);
+                    break;
+                }
+                if (this._line || this._line !== 0 && this._point === 1) this._context.closePath();
+                this._line = 1 - this._line;
+              },
+              point: function(x22, y22) {
+                x22 = +x22, y22 = +y22;
+                if (this._point) {
+                  var x23 = this._x2 - x22, y23 = this._y2 - y22;
+                  this._l23_a = Math.sqrt(this._l23_2a = Math.pow(x23 * x23 + y23 * y23, this._alpha));
+                }
+                switch (this._point) {
+                  case 0:
+                    this._point = 1;
+                    this._line ? this._context.lineTo(x22, y22) : this._context.moveTo(x22, y22);
+                    break;
+                  case 1:
+                    this._point = 2;
+                    break;
+                  case 2:
+                    this._point = 3;
+                  default:
+                    point$2(this, x22, y22);
+                    break;
+                }
+                this._l01_a = this._l12_a, this._l12_a = this._l23_a;
+                this._l01_2a = this._l12_2a, this._l12_2a = this._l23_2a;
+                this._x0 = this._x1, this._x1 = this._x2, this._x2 = x22;
+                this._y0 = this._y1, this._y1 = this._y2, this._y2 = y22;
+              }
+            };
+            var catmullRom = function custom(alpha) {
+              function catmullRom2(context) {
+                return alpha ? new CatmullRom(context, alpha) : new Cardinal(context, 0);
+              }
+              catmullRom2.alpha = function(alpha2) {
+                return custom(+alpha2);
+              };
+              return catmullRom2;
+            }(0.5);
+            function CatmullRomClosed(context, alpha) {
+              this._context = context;
+              this._alpha = alpha;
+            }
+            CatmullRomClosed.prototype = {
+              areaStart: noop2,
+              areaEnd: noop2,
+              lineStart: function() {
+                this._x0 = this._x1 = this._x2 = this._x3 = this._x4 = this._x5 = this._y0 = this._y1 = this._y2 = this._y3 = this._y4 = this._y5 = NaN;
+                this._l01_a = this._l12_a = this._l23_a = this._l01_2a = this._l12_2a = this._l23_2a = this._point = 0;
+              },
+              lineEnd: function() {
+                switch (this._point) {
+                  case 1: {
+                    this._context.moveTo(this._x3, this._y3);
+                    this._context.closePath();
+                    break;
+                  }
+                  case 2: {
+                    this._context.lineTo(this._x3, this._y3);
+                    this._context.closePath();
+                    break;
+                  }
+                  case 3: {
+                    this.point(this._x3, this._y3);
+                    this.point(this._x4, this._y4);
+                    this.point(this._x5, this._y5);
+                    break;
+                  }
+                }
+              },
+              point: function(x22, y22) {
+                x22 = +x22, y22 = +y22;
+                if (this._point) {
+                  var x23 = this._x2 - x22, y23 = this._y2 - y22;
+                  this._l23_a = Math.sqrt(this._l23_2a = Math.pow(x23 * x23 + y23 * y23, this._alpha));
+                }
+                switch (this._point) {
+                  case 0:
+                    this._point = 1;
+                    this._x3 = x22, this._y3 = y22;
+                    break;
+                  case 1:
+                    this._point = 2;
+                    this._context.moveTo(this._x4 = x22, this._y4 = y22);
+                    break;
+                  case 2:
+                    this._point = 3;
+                    this._x5 = x22, this._y5 = y22;
+                    break;
+                  default:
+                    point$2(this, x22, y22);
+                    break;
+                }
+                this._l01_a = this._l12_a, this._l12_a = this._l23_a;
+                this._l01_2a = this._l12_2a, this._l12_2a = this._l23_2a;
+                this._x0 = this._x1, this._x1 = this._x2, this._x2 = x22;
+                this._y0 = this._y1, this._y1 = this._y2, this._y2 = y22;
+              }
+            };
+            var catmullRomClosed = function custom(alpha) {
+              function catmullRom2(context) {
+                return alpha ? new CatmullRomClosed(context, alpha) : new CardinalClosed(context, 0);
+              }
+              catmullRom2.alpha = function(alpha2) {
+                return custom(+alpha2);
+              };
+              return catmullRom2;
+            }(0.5);
+            function CatmullRomOpen(context, alpha) {
+              this._context = context;
+              this._alpha = alpha;
+            }
+            CatmullRomOpen.prototype = {
+              areaStart: function() {
+                this._line = 0;
+              },
+              areaEnd: function() {
+                this._line = NaN;
+              },
+              lineStart: function() {
+                this._x0 = this._x1 = this._x2 = this._y0 = this._y1 = this._y2 = NaN;
+                this._l01_a = this._l12_a = this._l23_a = this._l01_2a = this._l12_2a = this._l23_2a = this._point = 0;
+              },
+              lineEnd: function() {
+                if (this._line || this._line !== 0 && this._point === 3) this._context.closePath();
+                this._line = 1 - this._line;
+              },
+              point: function(x22, y22) {
+                x22 = +x22, y22 = +y22;
+                if (this._point) {
+                  var x23 = this._x2 - x22, y23 = this._y2 - y22;
+                  this._l23_a = Math.sqrt(this._l23_2a = Math.pow(x23 * x23 + y23 * y23, this._alpha));
+                }
+                switch (this._point) {
+                  case 0:
+                    this._point = 1;
+                    break;
+                  case 1:
+                    this._point = 2;
+                    break;
+                  case 2:
+                    this._point = 3;
+                    this._line ? this._context.lineTo(this._x2, this._y2) : this._context.moveTo(this._x2, this._y2);
+                    break;
+                  case 3:
+                    this._point = 4;
+                  default:
+                    point$2(this, x22, y22);
+                    break;
+                }
+                this._l01_a = this._l12_a, this._l12_a = this._l23_a;
+                this._l01_2a = this._l12_2a, this._l12_2a = this._l23_2a;
+                this._x0 = this._x1, this._x1 = this._x2, this._x2 = x22;
+                this._y0 = this._y1, this._y1 = this._y2, this._y2 = y22;
+              }
+            };
+            var catmullRomOpen = function custom(alpha) {
+              function catmullRom2(context) {
+                return alpha ? new CatmullRomOpen(context, alpha) : new CardinalOpen(context, 0);
+              }
+              catmullRom2.alpha = function(alpha2) {
+                return custom(+alpha2);
+              };
+              return catmullRom2;
+            }(0.5);
+            function LinearClosed(context) {
+              this._context = context;
+            }
+            LinearClosed.prototype = {
+              areaStart: noop2,
+              areaEnd: noop2,
+              lineStart: function() {
+                this._point = 0;
+              },
+              lineEnd: function() {
+                if (this._point) this._context.closePath();
+              },
+              point: function(x22, y22) {
+                x22 = +x22, y22 = +y22;
+                if (this._point) this._context.lineTo(x22, y22);
+                else this._point = 1, this._context.moveTo(x22, y22);
+              }
+            };
+            function linearClosed(context) {
+              return new LinearClosed(context);
+            }
+            function sign(x22) {
+              return x22 < 0 ? -1 : 1;
+            }
+            function slope3(that, x22, y22) {
+              var h0 = that._x1 - that._x0, h1 = x22 - that._x1, s0 = (that._y1 - that._y0) / (h0 || h1 < 0 && -0), s1 = (y22 - that._y1) / (h1 || h0 < 0 && -0), p2 = (s0 * h1 + s1 * h0) / (h0 + h1);
+              return (sign(s0) + sign(s1)) * Math.min(Math.abs(s0), Math.abs(s1), 0.5 * Math.abs(p2)) || 0;
+            }
+            function slope2(that, t4) {
+              var h2 = that._x1 - that._x0;
+              return h2 ? (3 * (that._y1 - that._y0) / h2 - t4) / 2 : t4;
+            }
+            function point$3(that, t02, t12) {
+              var x0 = that._x0, y0 = that._y0, x1 = that._x1, y1 = that._y1, dx = (x1 - x0) / 3;
+              that._context.bezierCurveTo(x0 + dx, y0 + dx * t02, x1 - dx, y1 - dx * t12, x1, y1);
+            }
+            function MonotoneX(context) {
+              this._context = context;
+            }
+            MonotoneX.prototype = {
+              areaStart: function() {
+                this._line = 0;
+              },
+              areaEnd: function() {
+                this._line = NaN;
+              },
+              lineStart: function() {
+                this._x0 = this._x1 = this._y0 = this._y1 = this._t0 = NaN;
+                this._point = 0;
+              },
+              lineEnd: function() {
+                switch (this._point) {
+                  case 2:
+                    this._context.lineTo(this._x1, this._y1);
+                    break;
+                  case 3:
+                    point$3(this, this._t0, slope2(this, this._t0));
+                    break;
+                }
+                if (this._line || this._line !== 0 && this._point === 1) this._context.closePath();
+                this._line = 1 - this._line;
+              },
+              point: function(x22, y22) {
+                var t12 = NaN;
+                x22 = +x22, y22 = +y22;
+                if (x22 === this._x1 && y22 === this._y1) return;
+                switch (this._point) {
+                  case 0:
+                    this._point = 1;
+                    this._line ? this._context.lineTo(x22, y22) : this._context.moveTo(x22, y22);
+                    break;
+                  case 1:
+                    this._point = 2;
+                    break;
+                  case 2:
+                    this._point = 3;
+                    point$3(this, slope2(this, t12 = slope3(this, x22, y22)), t12);
+                    break;
+                  default:
+                    point$3(this, this._t0, t12 = slope3(this, x22, y22));
+                    break;
+                }
+                this._x0 = this._x1, this._x1 = x22;
+                this._y0 = this._y1, this._y1 = y22;
+                this._t0 = t12;
+              }
+            };
+            function MonotoneY(context) {
+              this._context = new ReflectContext(context);
+            }
+            (MonotoneY.prototype = Object.create(MonotoneX.prototype)).point = function(x22, y22) {
+              MonotoneX.prototype.point.call(this, y22, x22);
+            };
+            function ReflectContext(context) {
+              this._context = context;
+            }
+            ReflectContext.prototype = {
+              moveTo: function(x22, y22) {
+                this._context.moveTo(y22, x22);
+              },
+              closePath: function() {
+                this._context.closePath();
+              },
+              lineTo: function(x22, y22) {
+                this._context.lineTo(y22, x22);
+              },
+              bezierCurveTo: function(x1, y1, x22, y22, x3, y3) {
+                this._context.bezierCurveTo(y1, x1, y22, x22, y3, x3);
+              }
+            };
+            function monotoneX(context) {
+              return new MonotoneX(context);
+            }
+            function monotoneY(context) {
+              return new MonotoneY(context);
+            }
+            function Natural(context) {
+              this._context = context;
+            }
+            Natural.prototype = {
+              areaStart: function() {
+                this._line = 0;
+              },
+              areaEnd: function() {
+                this._line = NaN;
+              },
+              lineStart: function() {
+                this._x = [];
+                this._y = [];
+              },
+              lineEnd: function() {
+                var x22 = this._x, y22 = this._y, n2 = x22.length;
+                if (n2) {
+                  this._line ? this._context.lineTo(x22[0], y22[0]) : this._context.moveTo(x22[0], y22[0]);
+                  if (n2 === 2) {
+                    this._context.lineTo(x22[1], y22[1]);
+                  } else {
+                    var px = controlPoints(x22), py = controlPoints(y22);
+                    for (var i0 = 0, i1 = 1; i1 < n2; ++i0, ++i1) {
+                      this._context.bezierCurveTo(px[0][i0], py[0][i0], px[1][i0], py[1][i0], x22[i1], y22[i1]);
+                    }
+                  }
+                }
+                if (this._line || this._line !== 0 && n2 === 1) this._context.closePath();
+                this._line = 1 - this._line;
+                this._x = this._y = null;
+              },
+              point: function(x22, y22) {
+                this._x.push(+x22);
+                this._y.push(+y22);
+              }
+            };
+            function controlPoints(x22) {
+              var i2, n2 = x22.length - 1, m2, a22 = new Array(n2), b2 = new Array(n2), r2 = new Array(n2);
+              a22[0] = 0, b2[0] = 2, r2[0] = x22[0] + 2 * x22[1];
+              for (i2 = 1; i2 < n2 - 1; ++i2) a22[i2] = 1, b2[i2] = 4, r2[i2] = 4 * x22[i2] + 2 * x22[i2 + 1];
+              a22[n2 - 1] = 2, b2[n2 - 1] = 7, r2[n2 - 1] = 8 * x22[n2 - 1] + x22[n2];
+              for (i2 = 1; i2 < n2; ++i2) m2 = a22[i2] / b2[i2 - 1], b2[i2] -= m2, r2[i2] -= m2 * r2[i2 - 1];
+              a22[n2 - 1] = r2[n2 - 1] / b2[n2 - 1];
+              for (i2 = n2 - 2; i2 >= 0; --i2) a22[i2] = (r2[i2] - a22[i2 + 1]) / b2[i2];
+              b2[n2 - 1] = (x22[n2] + a22[n2 - 1]) / 2;
+              for (i2 = 0; i2 < n2 - 1; ++i2) b2[i2] = 2 * x22[i2 + 1] - a22[i2 + 1];
+              return [a22, b2];
+            }
+            function natural(context) {
+              return new Natural(context);
+            }
+            function Step(context, t4) {
+              this._context = context;
+              this._t = t4;
+            }
+            Step.prototype = {
+              areaStart: function() {
+                this._line = 0;
+              },
+              areaEnd: function() {
+                this._line = NaN;
+              },
+              lineStart: function() {
+                this._x = this._y = NaN;
+                this._point = 0;
+              },
+              lineEnd: function() {
+                if (0 < this._t && this._t < 1 && this._point === 2) this._context.lineTo(this._x, this._y);
+                if (this._line || this._line !== 0 && this._point === 1) this._context.closePath();
+                if (this._line >= 0) this._t = 1 - this._t, this._line = 1 - this._line;
+              },
+              point: function(x22, y22) {
+                x22 = +x22, y22 = +y22;
+                switch (this._point) {
+                  case 0:
+                    this._point = 1;
+                    this._line ? this._context.lineTo(x22, y22) : this._context.moveTo(x22, y22);
+                    break;
+                  case 1:
+                    this._point = 2;
+                  default: {
+                    if (this._t <= 0) {
+                      this._context.lineTo(this._x, y22);
+                      this._context.lineTo(x22, y22);
+                    } else {
+                      var x1 = this._x * (1 - this._t) + x22 * this._t;
+                      this._context.lineTo(x1, this._y);
+                      this._context.lineTo(x1, y22);
+                    }
+                    break;
+                  }
+                }
+                this._x = x22, this._y = y22;
+              }
+            };
+            function step(context) {
+              return new Step(context, 0.5);
+            }
+            function stepBefore(context) {
+              return new Step(context, 0);
+            }
+            function stepAfter(context) {
+              return new Step(context, 1);
+            }
+            function none(series, order) {
+              if (!((n2 = series.length) > 1)) return;
+              for (var i2 = 1, j2, s0, s1 = series[order[0]], n2, m2 = s1.length; i2 < n2; ++i2) {
+                s0 = s1, s1 = series[order[i2]];
+                for (j2 = 0; j2 < m2; ++j2) {
+                  s1[j2][1] += s1[j2][0] = isNaN(s0[j2][1]) ? s0[j2][0] : s0[j2][1];
+                }
+              }
+            }
+            function none$1(series) {
+              var n2 = series.length, o2 = new Array(n2);
+              while (--n2 >= 0) o2[n2] = n2;
+              return o2;
+            }
+            function stackValue(d2, key) {
+              return d2[key];
+            }
+            function stack() {
+              var keys = constant([]), order = none$1, offset = none, value = stackValue;
+              function stack2(data) {
+                var kz = keys.apply(this, arguments), i2, m2 = data.length, n2 = kz.length, sz = new Array(n2), oz;
+                for (i2 = 0; i2 < n2; ++i2) {
+                  for (var ki2 = kz[i2], si2 = sz[i2] = new Array(m2), j2 = 0, sij; j2 < m2; ++j2) {
+                    si2[j2] = sij = [0, +value(data[j2], ki2, j2, data)];
+                    sij.data = data[j2];
+                  }
+                  si2.key = ki2;
+                }
+                for (i2 = 0, oz = order(sz); i2 < n2; ++i2) {
+                  sz[oz[i2]].index = i2;
+                }
+                offset(sz, oz);
+                return sz;
+              }
+              stack2.keys = function(_2) {
+                return arguments.length ? (keys = typeof _2 === "function" ? _2 : constant(slice.call(_2)), stack2) : keys;
+              };
+              stack2.value = function(_2) {
+                return arguments.length ? (value = typeof _2 === "function" ? _2 : constant(+_2), stack2) : value;
+              };
+              stack2.order = function(_2) {
+                return arguments.length ? (order = _2 == null ? none$1 : typeof _2 === "function" ? _2 : constant(slice.call(_2)), stack2) : order;
+              };
+              stack2.offset = function(_2) {
+                return arguments.length ? (offset = _2 == null ? none : _2, stack2) : offset;
+              };
+              return stack2;
+            }
+            function expand(series, order) {
+              if (!((n2 = series.length) > 0)) return;
+              for (var i2, n2, j2 = 0, m2 = series[0].length, y22; j2 < m2; ++j2) {
+                for (y22 = i2 = 0; i2 < n2; ++i2) y22 += series[i2][j2][1] || 0;
+                if (y22) for (i2 = 0; i2 < n2; ++i2) series[i2][j2][1] /= y22;
+              }
+              none(series, order);
+            }
+            function diverging(series, order) {
+              if (!((n2 = series.length) > 0)) return;
+              for (var i2, j2 = 0, d2, dy, yp, yn, n2, m2 = series[order[0]].length; j2 < m2; ++j2) {
+                for (yp = yn = 0, i2 = 0; i2 < n2; ++i2) {
+                  if ((dy = (d2 = series[order[i2]][j2])[1] - d2[0]) > 0) {
+                    d2[0] = yp, d2[1] = yp += dy;
+                  } else if (dy < 0) {
+                    d2[1] = yn, d2[0] = yn += dy;
+                  } else {
+                    d2[0] = 0, d2[1] = dy;
+                  }
+                }
+              }
+            }
+            function silhouette(series, order) {
+              if (!((n2 = series.length) > 0)) return;
+              for (var j2 = 0, s0 = series[order[0]], n2, m2 = s0.length; j2 < m2; ++j2) {
+                for (var i2 = 0, y22 = 0; i2 < n2; ++i2) y22 += series[i2][j2][1] || 0;
+                s0[j2][1] += s0[j2][0] = -y22 / 2;
+              }
+              none(series, order);
+            }
+            function wiggle(series, order) {
+              if (!((n2 = series.length) > 0) || !((m2 = (s0 = series[order[0]]).length) > 0)) return;
+              for (var y22 = 0, j2 = 1, s0, m2, n2; j2 < m2; ++j2) {
+                for (var i2 = 0, s1 = 0, s22 = 0; i2 < n2; ++i2) {
+                  var si2 = series[order[i2]], sij0 = si2[j2][1] || 0, sij1 = si2[j2 - 1][1] || 0, s3 = (sij0 - sij1) / 2;
+                  for (var k22 = 0; k22 < i2; ++k22) {
+                    var sk2 = series[order[k22]], skj0 = sk2[j2][1] || 0, skj1 = sk2[j2 - 1][1] || 0;
+                    s3 += skj0 - skj1;
+                  }
+                  s1 += sij0, s22 += s3 * sij0;
+                }
+                s0[j2 - 1][1] += s0[j2 - 1][0] = y22;
+                if (s1) y22 -= s22 / s1;
+              }
+              s0[j2 - 1][1] += s0[j2 - 1][0] = y22;
+              none(series, order);
+            }
+            function appearance(series) {
+              var peaks = series.map(peak);
+              return none$1(series).sort(function(a22, b2) {
+                return peaks[a22] - peaks[b2];
+              });
+            }
+            function peak(series) {
+              var i2 = -1, j2 = 0, n2 = series.length, vi2, vj2 = -Infinity;
+              while (++i2 < n2) if ((vi2 = +series[i2][1]) > vj2) vj2 = vi2, j2 = i2;
+              return j2;
+            }
+            function ascending(series) {
+              var sums = series.map(sum);
+              return none$1(series).sort(function(a22, b2) {
+                return sums[a22] - sums[b2];
+              });
+            }
+            function sum(series) {
+              var s22 = 0, i2 = -1, n2 = series.length, v2;
+              while (++i2 < n2) if (v2 = +series[i2][1]) s22 += v2;
+              return s22;
+            }
+            function descending$1(series) {
+              return ascending(series).reverse();
+            }
+            function insideOut(series) {
+              var n2 = series.length, i2, j2, sums = series.map(sum), order = appearance(series), top = 0, bottom = 0, tops = [], bottoms = [];
+              for (i2 = 0; i2 < n2; ++i2) {
+                j2 = order[i2];
+                if (top < bottom) {
+                  top += sums[j2];
+                  tops.push(j2);
+                } else {
+                  bottom += sums[j2];
+                  bottoms.push(j2);
+                }
+              }
+              return bottoms.reverse().concat(tops);
+            }
+            function reverse(series) {
+              return none$1(series).reverse();
+            }
+            exports2.arc = arc;
+            exports2.area = area;
+            exports2.areaRadial = areaRadial;
+            exports2.curveBasis = basis2;
+            exports2.curveBasisClosed = basisClosed;
+            exports2.curveBasisOpen = basisOpen;
+            exports2.curveBundle = bundle;
+            exports2.curveCardinal = cardinal;
+            exports2.curveCardinalClosed = cardinalClosed;
+            exports2.curveCardinalOpen = cardinalOpen;
+            exports2.curveCatmullRom = catmullRom;
+            exports2.curveCatmullRomClosed = catmullRomClosed;
+            exports2.curveCatmullRomOpen = catmullRomOpen;
+            exports2.curveLinear = curveLinear;
+            exports2.curveLinearClosed = linearClosed;
+            exports2.curveMonotoneX = monotoneX;
+            exports2.curveMonotoneY = monotoneY;
+            exports2.curveNatural = natural;
+            exports2.curveStep = step;
+            exports2.curveStepAfter = stepAfter;
+            exports2.curveStepBefore = stepBefore;
+            exports2.line = line;
+            exports2.lineRadial = lineRadial$1;
+            exports2.linkHorizontal = linkHorizontal;
+            exports2.linkRadial = linkRadial;
+            exports2.linkVertical = linkVertical;
+            exports2.pie = pie;
+            exports2.pointRadial = pointRadial;
+            exports2.radialArea = areaRadial;
+            exports2.radialLine = lineRadial$1;
+            exports2.stack = stack;
+            exports2.stackOffsetDiverging = diverging;
+            exports2.stackOffsetExpand = expand;
+            exports2.stackOffsetNone = none;
+            exports2.stackOffsetSilhouette = silhouette;
+            exports2.stackOffsetWiggle = wiggle;
+            exports2.stackOrderAppearance = appearance;
+            exports2.stackOrderAscending = ascending;
+            exports2.stackOrderDescending = descending$1;
+            exports2.stackOrderInsideOut = insideOut;
+            exports2.stackOrderNone = none$1;
+            exports2.stackOrderReverse = reverse;
+            exports2.symbol = symbol;
+            exports2.symbolCircle = circle;
+            exports2.symbolCross = cross2;
+            exports2.symbolDiamond = diamond;
+            exports2.symbolSquare = square;
+            exports2.symbolStar = star;
+            exports2.symbolTriangle = triangle;
+            exports2.symbolWye = wye;
+            exports2.symbols = symbols;
+            Object.defineProperty(exports2, "__esModule", { value: true });
+          });
+        }
+      });
+      var require_d3_sankey = __commonJS({
+        "node_modules/@plotly/d3-sankey/build/d3-sankey.js"(exports, module2) {
+          (function(global2, factory2) {
+            typeof exports === "object" && typeof module2 !== "undefined" ? factory2(exports, require_d3_array(), require_d3_collection(), require_d3_shape()) : factory2(global2.d3 = global2.d3 || {}, global2.d3, global2.d3, global2.d3);
+          })(exports, function(exports2, d3Array, d3Collection, d3Shape) {
+            function targetDepth(d2) {
+              return d2.target.depth;
+            }
+            function left(node) {
+              return node.depth;
+            }
+            function right(node, n2) {
+              return n2 - 1 - node.height;
+            }
+            function justify(node, n2) {
+              return node.sourceLinks.length ? node.depth : n2 - 1;
+            }
+            function center(node) {
+              return node.targetLinks.length ? node.depth : node.sourceLinks.length ? d3Array.min(node.sourceLinks, targetDepth) - 1 : 0;
+            }
+            function constant(x2) {
+              return function() {
+                return x2;
+              };
+            }
+            function ascendingSourceBreadth(a2, b2) {
+              return ascendingBreadth(a2.source, b2.source) || a2.index - b2.index;
+            }
+            function ascendingTargetBreadth(a2, b2) {
+              return ascendingBreadth(a2.target, b2.target) || a2.index - b2.index;
+            }
+            function ascendingBreadth(a2, b2) {
+              return a2.y0 - b2.y0;
+            }
+            function value(d2) {
+              return d2.value;
+            }
+            function nodeCenter(node) {
+              return (node.y0 + node.y1) / 2;
+            }
+            function weightedSource(link) {
+              return nodeCenter(link.source) * link.value;
+            }
+            function weightedTarget(link) {
+              return nodeCenter(link.target) * link.value;
+            }
+            function defaultId(d2) {
+              return d2.index;
+            }
+            function defaultNodes(graph) {
+              return graph.nodes;
+            }
+            function defaultLinks(graph) {
+              return graph.links;
+            }
+            function find(nodeById, id2) {
+              var node = nodeById.get(id2);
+              if (!node) throw new Error("missing: " + id2);
+              return node;
+            }
+            var sankey = function() {
+              var x0 = 0, y0 = 0, x1 = 1, y1 = 1, dx = 24, py = 8, id2 = defaultId, align = justify, nodes = defaultNodes, links = defaultLinks, iterations = 32, maxPaddedSpace = 2 / 3;
+              function sankey2() {
+                var graph = { nodes: nodes.apply(null, arguments), links: links.apply(null, arguments) };
+                computeNodeLinks(graph);
+                computeNodeValues(graph);
+                computeNodeDepths(graph);
+                computeNodeBreadths(graph);
+                computeLinkBreadths(graph);
+                return graph;
+              }
+              sankey2.update = function(graph) {
+                computeLinkBreadths(graph);
+                return graph;
+              };
+              sankey2.nodeId = function(_2) {
+                return arguments.length ? (id2 = typeof _2 === "function" ? _2 : constant(_2), sankey2) : id2;
+              };
+              sankey2.nodeAlign = function(_2) {
+                return arguments.length ? (align = typeof _2 === "function" ? _2 : constant(_2), sankey2) : align;
+              };
+              sankey2.nodeWidth = function(_2) {
+                return arguments.length ? (dx = +_2, sankey2) : dx;
+              };
+              sankey2.nodePadding = function(_2) {
+                return arguments.length ? (py = +_2, sankey2) : py;
+              };
+              sankey2.nodes = function(_2) {
+                return arguments.length ? (nodes = typeof _2 === "function" ? _2 : constant(_2), sankey2) : nodes;
+              };
+              sankey2.links = function(_2) {
+                return arguments.length ? (links = typeof _2 === "function" ? _2 : constant(_2), sankey2) : links;
+              };
+              sankey2.size = function(_2) {
+                return arguments.length ? (x0 = y0 = 0, x1 = +_2[0], y1 = +_2[1], sankey2) : [x1 - x0, y1 - y0];
+              };
+              sankey2.extent = function(_2) {
+                return arguments.length ? (x0 = +_2[0][0], x1 = +_2[1][0], y0 = +_2[0][1], y1 = +_2[1][1], sankey2) : [[x0, y0], [x1, y1]];
+              };
+              sankey2.iterations = function(_2) {
+                return arguments.length ? (iterations = +_2, sankey2) : iterations;
+              };
+              function computeNodeLinks(graph) {
+                graph.nodes.forEach(function(node, i2) {
+                  node.index = i2;
+                  node.sourceLinks = [];
+                  node.targetLinks = [];
+                });
+                var nodeById = d3Collection.map(graph.nodes, id2);
+                graph.links.forEach(function(link, i2) {
+                  link.index = i2;
+                  var source2 = link.source, target = link.target;
+                  if (typeof source2 !== "object") source2 = link.source = find(nodeById, source2);
+                  if (typeof target !== "object") target = link.target = find(nodeById, target);
+                  source2.sourceLinks.push(link);
+                  target.targetLinks.push(link);
+                });
+              }
+              function computeNodeValues(graph) {
+                graph.nodes.forEach(function(node) {
+                  node.value = Math.max(
+                    d3Array.sum(node.sourceLinks, value),
+                    d3Array.sum(node.targetLinks, value)
+                  );
+                });
+              }
+              function computeNodeDepths(graph) {
+                var nodes2, next, x2;
+                for (nodes2 = graph.nodes, next = [], x2 = 0; nodes2.length; ++x2, nodes2 = next, next = []) {
+                  nodes2.forEach(function(node) {
+                    node.depth = x2;
+                    node.sourceLinks.forEach(function(link) {
+                      if (next.indexOf(link.target) < 0) {
+                        next.push(link.target);
+                      }
+                    });
+                  });
+                }
+                for (nodes2 = graph.nodes, next = [], x2 = 0; nodes2.length; ++x2, nodes2 = next, next = []) {
+                  nodes2.forEach(function(node) {
+                    node.height = x2;
+                    node.targetLinks.forEach(function(link) {
+                      if (next.indexOf(link.source) < 0) {
+                        next.push(link.source);
+                      }
+                    });
+                  });
+                }
+                var kx = (x1 - x0 - dx) / (x2 - 1);
+                graph.nodes.forEach(function(node) {
+                  node.x1 = (node.x0 = x0 + Math.max(0, Math.min(x2 - 1, Math.floor(align.call(null, node, x2)))) * kx) + dx;
+                });
+              }
+              function computeNodeBreadths(graph) {
+                var columns = d3Collection.nest().key(function(d2) {
+                  return d2.x0;
+                }).sortKeys(d3Array.ascending).entries(graph.nodes).map(function(d2) {
+                  return d2.values;
+                });
+                initializeNodeBreadth();
+                resolveCollisions();
+                for (var alpha = 1, n2 = iterations; n2 > 0; --n2) {
+                  relaxRightToLeft(alpha *= 0.99);
+                  resolveCollisions();
+                  relaxLeftToRight(alpha);
+                  resolveCollisions();
+                }
+                function initializeNodeBreadth() {
+                  var L2 = d3Array.max(columns, function(nodes2) {
+                    return nodes2.length;
+                  });
+                  var maxNodePadding = maxPaddedSpace * (y1 - y0) / (L2 - 1);
+                  if (py > maxNodePadding) py = maxNodePadding;
+                  var ky = d3Array.min(columns, function(nodes2) {
+                    return (y1 - y0 - (nodes2.length - 1) * py) / d3Array.sum(nodes2, value);
+                  });
+                  columns.forEach(function(nodes2) {
+                    nodes2.forEach(function(node, i2) {
+                      node.y1 = (node.y0 = i2) + node.value * ky;
+                    });
+                  });
+                  graph.links.forEach(function(link) {
+                    link.width = link.value * ky;
+                  });
+                }
+                function relaxLeftToRight(alpha2) {
+                  columns.forEach(function(nodes2) {
+                    nodes2.forEach(function(node) {
+                      if (node.targetLinks.length) {
+                        var dy = (d3Array.sum(node.targetLinks, weightedSource) / d3Array.sum(node.targetLinks, value) - nodeCenter(node)) * alpha2;
+                        node.y0 += dy, node.y1 += dy;
+                      }
+                    });
+                  });
+                }
+                function relaxRightToLeft(alpha2) {
+                  columns.slice().reverse().forEach(function(nodes2) {
+                    nodes2.forEach(function(node) {
+                      if (node.sourceLinks.length) {
+                        var dy = (d3Array.sum(node.sourceLinks, weightedTarget) / d3Array.sum(node.sourceLinks, value) - nodeCenter(node)) * alpha2;
+                        node.y0 += dy, node.y1 += dy;
+                      }
+                    });
+                  });
+                }
+                function resolveCollisions() {
+                  columns.forEach(function(nodes2) {
+                    var node, dy, y2 = y0, n22 = nodes2.length, i2;
+                    nodes2.sort(ascendingBreadth);
+                    for (i2 = 0; i2 < n22; ++i2) {
+                      node = nodes2[i2];
+                      dy = y2 - node.y0;
+                      if (dy > 0) node.y0 += dy, node.y1 += dy;
+                      y2 = node.y1 + py;
+                    }
+                    dy = y2 - py - y1;
+                    if (dy > 0) {
+                      y2 = node.y0 -= dy, node.y1 -= dy;
+                      for (i2 = n22 - 2; i2 >= 0; --i2) {
+                        node = nodes2[i2];
+                        dy = node.y1 + py - y2;
+                        if (dy > 0) node.y0 -= dy, node.y1 -= dy;
+                        y2 = node.y0;
+                      }
+                    }
+                  });
+                }
+              }
+              function computeLinkBreadths(graph) {
+                graph.nodes.forEach(function(node) {
+                  node.sourceLinks.sort(ascendingTargetBreadth);
+                  node.targetLinks.sort(ascendingSourceBreadth);
+                });
+                graph.nodes.forEach(function(node) {
+                  var y02 = node.y0, y12 = y02;
+                  node.sourceLinks.forEach(function(link) {
+                    link.y0 = y02 + link.width / 2, y02 += link.width;
+                  });
+                  node.targetLinks.forEach(function(link) {
+                    link.y1 = y12 + link.width / 2, y12 += link.width;
+                  });
+                });
+              }
+              return sankey2;
+            };
+            function horizontalSource(d2) {
+              return [d2.source.x1, d2.y0];
+            }
+            function horizontalTarget(d2) {
+              return [d2.target.x0, d2.y1];
+            }
+            var sankeyLinkHorizontal = function() {
+              return d3Shape.linkHorizontal().source(horizontalSource).target(horizontalTarget);
+            };
+            exports2.sankey = sankey;
+            exports2.sankeyCenter = center;
+            exports2.sankeyLeft = left;
+            exports2.sankeyRight = right;
+            exports2.sankeyJustify = justify;
+            exports2.sankeyLinkHorizontal = sankeyLinkHorizontal;
+            Object.defineProperty(exports2, "__esModule", { value: true });
+          });
+        }
+      });
+      var require_johnson = __commonJS({
+        "node_modules/elementary-circuits-directed-graph/johnson.js"(exports, module2) {
+          var tarjan = require_scc();
+          module2.exports = function findCircuits(edges, cb2) {
+            var circuits = [];
+            var stack = [];
+            var blocked = [];
+            var B22 = {};
+            var Ak2 = [];
+            var s2;
+            function unblock(u2) {
+              blocked[u2] = false;
+              if (B22.hasOwnProperty(u2)) {
+                Object.keys(B22[u2]).forEach(function(w2) {
+                  delete B22[u2][w2];
+                  if (blocked[w2]) {
+                    unblock(w2);
+                  }
+                });
+              }
+            }
+            function circuit(v2) {
+              var found = false;
+              stack.push(v2);
+              blocked[v2] = true;
+              var i22;
+              var w2;
+              for (i22 = 0; i22 < Ak2[v2].length; i22++) {
+                w2 = Ak2[v2][i22];
+                if (w2 === s2) {
+                  output(s2, stack);
+                  found = true;
+                } else if (!blocked[w2]) {
+                  found = circuit(w2);
+                }
+              }
+              if (found) {
+                unblock(v2);
+              } else {
+                for (i22 = 0; i22 < Ak2[v2].length; i22++) {
+                  w2 = Ak2[v2][i22];
+                  var entry = B22[w2];
+                  if (!entry) {
+                    entry = {};
+                    B22[w2] = entry;
+                  }
+                  entry[w2] = true;
+                }
+              }
+              stack.pop();
+              return found;
+            }
+            function output(start, stack2) {
+              var cycle = [].concat(stack2).concat(start);
+              if (cb2) {
+                cb2(circuit);
+              } else {
+                circuits.push(cycle);
+              }
+            }
+            function subgraph(minId) {
+              for (var i22 = 0; i22 < edges.length; i22++) {
+                if (i22 < minId) edges[i22] = [];
+                edges[i22] = edges[i22].filter(function(i3) {
+                  return i3 >= minId;
+                });
+              }
+            }
+            function adjacencyStructureSCC(from) {
+              subgraph(from);
+              var g2 = edges;
+              var sccs = tarjan(g2);
+              var ccs = sccs.components.filter(function(scc) {
+                return scc.length > 1;
+              });
+              var leastVertex = Infinity;
+              var leastVertexComponent;
+              for (var i22 = 0; i22 < ccs.length; i22++) {
+                for (var j22 = 0; j22 < ccs[i22].length; j22++) {
+                  if (ccs[i22][j22] < leastVertex) {
+                    leastVertex = ccs[i22][j22];
+                    leastVertexComponent = i22;
+                  }
+                }
+              }
+              var cc2 = ccs[leastVertexComponent];
+              if (!cc2) return false;
+              var adjList = edges.map(function(l2, index) {
+                if (cc2.indexOf(index) === -1) return [];
+                return l2.filter(function(i3) {
+                  return cc2.indexOf(i3) !== -1;
+                });
+              });
+              return {
+                leastVertex,
+                adjList
+              };
+            }
+            s2 = 0;
+            var n2 = edges.length;
+            while (s2 < n2) {
+              var p2 = adjacencyStructureSCC(s2);
+              s2 = p2.leastVertex;
+              Ak2 = p2.adjList;
+              if (Ak2) {
+                for (var i2 = 0; i2 < Ak2.length; i2++) {
+                  for (var j2 = 0; j2 < Ak2[i2].length; j2++) {
+                    var vertexId = Ak2[i2][j2];
+                    blocked[+vertexId] = false;
+                    B22[vertexId] = {};
+                  }
+                }
+                circuit(s2);
+                s2 = s2 + 1;
+              } else {
+                s2 = n2;
+              }
+            }
+            if (cb2) {
+              return;
+            } else {
+              return circuits;
+            }
+          };
+        }
+      });
+      var require_d3_sankey_circular = __commonJS({
+        "node_modules/@plotly/d3-sankey-circular/dist/d3-sankey-circular.js"(exports, module2) {
+          (function(global2, factory2) {
+            typeof exports === "object" && typeof module2 !== "undefined" ? factory2(exports, require_d3_array(), require_d3_collection(), require_d3_shape(), require_johnson()) : factory2(global2.d3 = global2.d3 || {}, global2.d3, global2.d3, global2.d3, null);
+          })(exports, function(exports2, d3Array, d3Collection, d3Shape, findCircuits) {
+            findCircuits = findCircuits && findCircuits.hasOwnProperty("default") ? findCircuits["default"] : findCircuits;
+            function targetDepth(d2) {
+              return d2.target.depth;
+            }
+            function left(node) {
+              return node.depth;
+            }
+            function right(node, n2) {
+              return n2 - 1 - node.height;
+            }
+            function justify(node, n2) {
+              return node.sourceLinks.length ? node.depth : n2 - 1;
+            }
+            function center(node) {
+              return node.targetLinks.length ? node.depth : node.sourceLinks.length ? d3Array.min(node.sourceLinks, targetDepth) - 1 : 0;
+            }
+            function constant(x2) {
+              return function() {
+                return x2;
+              };
+            }
+            var _typeof = typeof Symbol === "function" && typeof Symbol.iterator === "symbol" ? function(obj) {
+              return typeof obj;
+            } : function(obj) {
+              return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj;
+            };
+            function ascendingSourceBreadth(a2, b2) {
+              return ascendingBreadth(a2.source, b2.source) || a2.index - b2.index;
+            }
+            function ascendingTargetBreadth(a2, b2) {
+              return ascendingBreadth(a2.target, b2.target) || a2.index - b2.index;
+            }
+            function ascendingBreadth(a2, b2) {
+              if (a2.partOfCycle === b2.partOfCycle) {
+                return a2.y0 - b2.y0;
+              } else {
+                if (a2.circularLinkType === "top" || b2.circularLinkType === "bottom") {
+                  return -1;
+                } else {
+                  return 1;
+                }
+              }
+            }
+            function value(d2) {
+              return d2.value;
+            }
+            function nodeCenter(node) {
+              return (node.y0 + node.y1) / 2;
+            }
+            function linkSourceCenter(link) {
+              return nodeCenter(link.source);
+            }
+            function linkTargetCenter(link) {
+              return nodeCenter(link.target);
+            }
+            function defaultId(d2) {
+              return d2.index;
+            }
+            function defaultNodes(graph) {
+              return graph.nodes;
+            }
+            function defaultLinks(graph) {
+              return graph.links;
+            }
+            function find(nodeById, id2) {
+              var node = nodeById.get(id2);
+              if (!node) throw new Error("missing: " + id2);
+              return node;
+            }
+            function getNodeID(node, id2) {
+              return id2(node);
+            }
+            var verticalMargin = 25;
+            var baseRadius = 10;
+            var scale2 = 0.3;
+            function sankeyCircular() {
+              var x0 = 0, y0 = 0, x1 = 1, y1 = 1, dx = 24, py, id2 = defaultId, align = justify, nodes = defaultNodes, links = defaultLinks, iterations = 32, circularLinkGap = 2, paddingRatio, sortNodes = null;
+              function sankeyCircular2() {
+                var graph = {
+                  nodes: nodes.apply(null, arguments),
+                  links: links.apply(null, arguments)
+                  // Process the graph's nodes and links, setting their positions
+                  // 1.  Associate the nodes with their respective links, and vice versa
+                };
+                computeNodeLinks(graph);
+                identifyCircles(graph, id2, sortNodes);
+                computeNodeValues(graph);
+                computeNodeDepths(graph);
+                selectCircularLinkTypes(graph, id2);
+                computeNodeBreadths(graph, iterations, id2);
+                computeLinkBreadths(graph);
+                var linkSortingIterations = 4;
+                for (var iteration = 0; iteration < linkSortingIterations; iteration++) {
+                  sortSourceLinks(graph, y1, id2);
+                  sortTargetLinks(graph, y1, id2);
+                  resolveNodeLinkOverlaps(graph, y0, y1, id2);
+                  sortSourceLinks(graph, y1, id2);
+                  sortTargetLinks(graph, y1, id2);
+                }
+                fillHeight(graph, y0, y1);
+                addCircularPathData(graph, circularLinkGap, y1, id2);
+                return graph;
+              }
+              sankeyCircular2.nodeId = function(_2) {
+                return arguments.length ? (id2 = typeof _2 === "function" ? _2 : constant(_2), sankeyCircular2) : id2;
+              };
+              sankeyCircular2.nodeAlign = function(_2) {
+                return arguments.length ? (align = typeof _2 === "function" ? _2 : constant(_2), sankeyCircular2) : align;
+              };
+              sankeyCircular2.nodeWidth = function(_2) {
+                return arguments.length ? (dx = +_2, sankeyCircular2) : dx;
+              };
+              sankeyCircular2.nodePadding = function(_2) {
+                return arguments.length ? (py = +_2, sankeyCircular2) : py;
+              };
+              sankeyCircular2.nodes = function(_2) {
+                return arguments.length ? (nodes = typeof _2 === "function" ? _2 : constant(_2), sankeyCircular2) : nodes;
+              };
+              sankeyCircular2.links = function(_2) {
+                return arguments.length ? (links = typeof _2 === "function" ? _2 : constant(_2), sankeyCircular2) : links;
+              };
+              sankeyCircular2.size = function(_2) {
+                return arguments.length ? (x0 = y0 = 0, x1 = +_2[0], y1 = +_2[1], sankeyCircular2) : [x1 - x0, y1 - y0];
+              };
+              sankeyCircular2.extent = function(_2) {
+                return arguments.length ? (x0 = +_2[0][0], x1 = +_2[1][0], y0 = +_2[0][1], y1 = +_2[1][1], sankeyCircular2) : [[x0, y0], [x1, y1]];
+              };
+              sankeyCircular2.iterations = function(_2) {
+                return arguments.length ? (iterations = +_2, sankeyCircular2) : iterations;
+              };
+              sankeyCircular2.circularLinkGap = function(_2) {
+                return arguments.length ? (circularLinkGap = +_2, sankeyCircular2) : circularLinkGap;
+              };
+              sankeyCircular2.nodePaddingRatio = function(_2) {
+                return arguments.length ? (paddingRatio = +_2, sankeyCircular2) : paddingRatio;
+              };
+              sankeyCircular2.sortNodes = function(_2) {
+                return arguments.length ? (sortNodes = _2, sankeyCircular2) : sortNodes;
+              };
+              sankeyCircular2.update = function(graph) {
+                selectCircularLinkTypes(graph, id2);
+                computeLinkBreadths(graph);
+                graph.links.forEach(function(link) {
+                  if (link.circular) {
+                    link.circularLinkType = link.y0 + link.y1 < y1 ? "top" : "bottom";
+                    link.source.circularLinkType = link.circularLinkType;
+                    link.target.circularLinkType = link.circularLinkType;
+                  }
+                });
+                sortSourceLinks(graph, y1, id2, false);
+                sortTargetLinks(graph, y1, id2);
+                addCircularPathData(graph, circularLinkGap, y1, id2);
+                return graph;
+              };
+              function computeNodeLinks(graph) {
+                graph.nodes.forEach(function(node, i2) {
+                  node.index = i2;
+                  node.sourceLinks = [];
+                  node.targetLinks = [];
+                });
+                var nodeById = d3Collection.map(graph.nodes, id2);
+                graph.links.forEach(function(link, i2) {
+                  link.index = i2;
+                  var source2 = link.source;
+                  var target = link.target;
+                  if ((typeof source2 === "undefined" ? "undefined" : _typeof(source2)) !== "object") {
+                    source2 = link.source = find(nodeById, source2);
+                  }
+                  if ((typeof target === "undefined" ? "undefined" : _typeof(target)) !== "object") {
+                    target = link.target = find(nodeById, target);
+                  }
+                  source2.sourceLinks.push(link);
+                  target.targetLinks.push(link);
+                });
+                return graph;
+              }
+              function computeNodeValues(graph) {
+                graph.nodes.forEach(function(node) {
+                  node.partOfCycle = false;
+                  node.value = Math.max(d3Array.sum(node.sourceLinks, value), d3Array.sum(node.targetLinks, value));
+                  node.sourceLinks.forEach(function(link) {
+                    if (link.circular) {
+                      node.partOfCycle = true;
+                      node.circularLinkType = link.circularLinkType;
+                    }
+                  });
+                  node.targetLinks.forEach(function(link) {
+                    if (link.circular) {
+                      node.partOfCycle = true;
+                      node.circularLinkType = link.circularLinkType;
+                    }
+                  });
+                });
+              }
+              function getCircleMargins(graph) {
+                var totalTopLinksWidth = 0, totalBottomLinksWidth = 0, totalRightLinksWidth = 0, totalLeftLinksWidth = 0;
+                var maxColumn = d3Array.max(graph.nodes, function(node) {
+                  return node.column;
+                });
+                graph.links.forEach(function(link) {
+                  if (link.circular) {
+                    if (link.circularLinkType == "top") {
+                      totalTopLinksWidth = totalTopLinksWidth + link.width;
+                    } else {
+                      totalBottomLinksWidth = totalBottomLinksWidth + link.width;
+                    }
+                    if (link.target.column == 0) {
+                      totalLeftLinksWidth = totalLeftLinksWidth + link.width;
+                    }
+                    if (link.source.column == maxColumn) {
+                      totalRightLinksWidth = totalRightLinksWidth + link.width;
+                    }
+                  }
+                });
+                totalTopLinksWidth = totalTopLinksWidth > 0 ? totalTopLinksWidth + verticalMargin + baseRadius : totalTopLinksWidth;
+                totalBottomLinksWidth = totalBottomLinksWidth > 0 ? totalBottomLinksWidth + verticalMargin + baseRadius : totalBottomLinksWidth;
+                totalRightLinksWidth = totalRightLinksWidth > 0 ? totalRightLinksWidth + verticalMargin + baseRadius : totalRightLinksWidth;
+                totalLeftLinksWidth = totalLeftLinksWidth > 0 ? totalLeftLinksWidth + verticalMargin + baseRadius : totalLeftLinksWidth;
+                return { "top": totalTopLinksWidth, "bottom": totalBottomLinksWidth, "left": totalLeftLinksWidth, "right": totalRightLinksWidth };
+              }
+              function scaleSankeySize(graph, margin) {
+                var maxColumn = d3Array.max(graph.nodes, function(node) {
+                  return node.column;
+                });
+                var currentWidth = x1 - x0;
+                var currentHeight = y1 - y0;
+                var newWidth = currentWidth + margin.right + margin.left;
+                var newHeight = currentHeight + margin.top + margin.bottom;
+                var scaleX2 = currentWidth / newWidth;
+                var scaleY2 = currentHeight / newHeight;
+                x0 = x0 * scaleX2 + margin.left;
+                x1 = margin.right == 0 ? x1 : x1 * scaleX2;
+                y0 = y0 * scaleY2 + margin.top;
+                y1 = y1 * scaleY2;
+                graph.nodes.forEach(function(node) {
+                  node.x0 = x0 + node.column * ((x1 - x0 - dx) / maxColumn);
+                  node.x1 = node.x0 + dx;
+                });
+                return scaleY2;
+              }
+              function computeNodeDepths(graph) {
+                var nodes2, next, x2;
+                for (nodes2 = graph.nodes, next = [], x2 = 0; nodes2.length; ++x2, nodes2 = next, next = []) {
+                  nodes2.forEach(function(node) {
+                    node.depth = x2;
+                    node.sourceLinks.forEach(function(link) {
+                      if (next.indexOf(link.target) < 0 && !link.circular) {
+                        next.push(link.target);
+                      }
+                    });
+                  });
+                }
+                for (nodes2 = graph.nodes, next = [], x2 = 0; nodes2.length; ++x2, nodes2 = next, next = []) {
+                  nodes2.forEach(function(node) {
+                    node.height = x2;
+                    node.targetLinks.forEach(function(link) {
+                      if (next.indexOf(link.source) < 0 && !link.circular) {
+                        next.push(link.source);
+                      }
+                    });
+                  });
+                }
+                graph.nodes.forEach(function(node) {
+                  node.column = Math.floor(align.call(null, node, x2));
+                });
+              }
+              function computeNodeBreadths(graph, iterations2, id22) {
+                var columns = d3Collection.nest().key(function(d2) {
+                  return d2.column;
+                }).sortKeys(d3Array.ascending).entries(graph.nodes).map(function(d2) {
+                  return d2.values;
+                });
+                initializeNodeBreadth(id22);
+                resolveCollisions();
+                for (var alpha = 1, n2 = iterations2; n2 > 0; --n2) {
+                  relaxLeftAndRight(alpha *= 0.99, id22);
+                  resolveCollisions();
+                }
+                function initializeNodeBreadth(id3) {
+                  if (paddingRatio) {
+                    var padding = Infinity;
+                    columns.forEach(function(nodes2) {
+                      var thisPadding = y1 * paddingRatio / (nodes2.length + 1);
+                      padding = thisPadding < padding ? thisPadding : padding;
+                    });
+                    py = padding;
+                  }
+                  var ky = d3Array.min(columns, function(nodes2) {
+                    return (y1 - y0 - (nodes2.length - 1) * py) / d3Array.sum(nodes2, value);
+                  });
+                  ky = ky * scale2;
+                  graph.links.forEach(function(link) {
+                    link.width = link.value * ky;
+                  });
+                  var margin = getCircleMargins(graph);
+                  var ratio = scaleSankeySize(graph, margin);
+                  ky = ky * ratio;
+                  graph.links.forEach(function(link) {
+                    link.width = link.value * ky;
+                  });
+                  columns.forEach(function(nodes2) {
+                    var nodesLength = nodes2.length;
+                    nodes2.forEach(function(node, i2) {
+                      if (node.depth == columns.length - 1 && nodesLength == 1) {
+                        node.y0 = y1 / 2 - node.value * ky;
+                        node.y1 = node.y0 + node.value * ky;
+                      } else if (node.depth == 0 && nodesLength == 1) {
+                        node.y0 = y1 / 2 - node.value * ky;
+                        node.y1 = node.y0 + node.value * ky;
+                      } else if (node.partOfCycle) {
+                        if (numberOfNonSelfLinkingCycles(node, id3) == 0) {
+                          node.y0 = y1 / 2 + i2;
+                          node.y1 = node.y0 + node.value * ky;
+                        } else if (node.circularLinkType == "top") {
+                          node.y0 = y0 + i2;
+                          node.y1 = node.y0 + node.value * ky;
+                        } else {
+                          node.y0 = y1 - node.value * ky - i2;
+                          node.y1 = node.y0 + node.value * ky;
+                        }
+                      } else {
+                        if (margin.top == 0 || margin.bottom == 0) {
+                          node.y0 = (y1 - y0) / nodesLength * i2;
+                          node.y1 = node.y0 + node.value * ky;
+                        } else {
+                          node.y0 = (y1 - y0) / 2 - nodesLength / 2 + i2;
+                          node.y1 = node.y0 + node.value * ky;
+                        }
+                      }
+                    });
+                  });
+                }
+                function relaxLeftAndRight(alpha2, id3) {
+                  var columnsLength = columns.length;
+                  columns.forEach(function(nodes2) {
+                    var n22 = nodes2.length;
+                    var depth = nodes2[0].depth;
+                    nodes2.forEach(function(node) {
+                      var nodeHeight;
+                      if (node.sourceLinks.length || node.targetLinks.length) {
+                        if (node.partOfCycle && numberOfNonSelfLinkingCycles(node, id3) > 0) ;
+                        else if (depth == 0 && n22 == 1) {
+                          nodeHeight = node.y1 - node.y0;
+                          node.y0 = y1 / 2 - nodeHeight / 2;
+                          node.y1 = y1 / 2 + nodeHeight / 2;
+                        } else if (depth == columnsLength - 1 && n22 == 1) {
+                          nodeHeight = node.y1 - node.y0;
+                          node.y0 = y1 / 2 - nodeHeight / 2;
+                          node.y1 = y1 / 2 + nodeHeight / 2;
+                        } else {
+                          var avg = 0;
+                          var avgTargetY = d3Array.mean(node.sourceLinks, linkTargetCenter);
+                          var avgSourceY = d3Array.mean(node.targetLinks, linkSourceCenter);
+                          if (avgTargetY && avgSourceY) {
+                            avg = (avgTargetY + avgSourceY) / 2;
+                          } else {
+                            avg = avgTargetY || avgSourceY;
+                          }
+                          var dy = (avg - nodeCenter(node)) * alpha2;
+                          node.y0 += dy;
+                          node.y1 += dy;
+                        }
+                      }
+                    });
+                  });
+                }
+                function resolveCollisions() {
+                  columns.forEach(function(nodes2) {
+                    var node, dy, y2 = y0, n22 = nodes2.length, i2;
+                    nodes2.sort(ascendingBreadth);
+                    for (i2 = 0; i2 < n22; ++i2) {
+                      node = nodes2[i2];
+                      dy = y2 - node.y0;
+                      if (dy > 0) {
+                        node.y0 += dy;
+                        node.y1 += dy;
+                      }
+                      y2 = node.y1 + py;
+                    }
+                    dy = y2 - py - y1;
+                    if (dy > 0) {
+                      y2 = node.y0 -= dy, node.y1 -= dy;
+                      for (i2 = n22 - 2; i2 >= 0; --i2) {
+                        node = nodes2[i2];
+                        dy = node.y1 + py - y2;
+                        if (dy > 0) node.y0 -= dy, node.y1 -= dy;
+                        y2 = node.y0;
+                      }
+                    }
+                  });
+                }
+              }
+              function computeLinkBreadths(graph) {
+                graph.nodes.forEach(function(node) {
+                  node.sourceLinks.sort(ascendingTargetBreadth);
+                  node.targetLinks.sort(ascendingSourceBreadth);
+                });
+                graph.nodes.forEach(function(node) {
+                  var y02 = node.y0;
+                  var y12 = y02;
+                  var y0cycle = node.y1;
+                  var y1cycle = y0cycle;
+                  node.sourceLinks.forEach(function(link) {
+                    if (link.circular) {
+                      link.y0 = y0cycle - link.width / 2;
+                      y0cycle = y0cycle - link.width;
+                    } else {
+                      link.y0 = y02 + link.width / 2;
+                      y02 += link.width;
+                    }
+                  });
+                  node.targetLinks.forEach(function(link) {
+                    if (link.circular) {
+                      link.y1 = y1cycle - link.width / 2;
+                      y1cycle = y1cycle - link.width;
+                    } else {
+                      link.y1 = y12 + link.width / 2;
+                      y12 += link.width;
+                    }
+                  });
+                });
+              }
+              return sankeyCircular2;
+            }
+            function identifyCircles(graph, id2, sortNodes) {
+              var circularLinkID = 0;
+              if (sortNodes === null) {
+                var adjList = [];
+                for (var i2 = 0; i2 < graph.links.length; i2++) {
+                  var link = graph.links[i2];
+                  var source2 = link.source.index;
+                  var target = link.target.index;
+                  if (!adjList[source2]) adjList[source2] = [];
+                  if (!adjList[target]) adjList[target] = [];
+                  if (adjList[source2].indexOf(target) === -1) adjList[source2].push(target);
+                }
+                var cycles = findCircuits(adjList);
+                cycles.sort(function(a2, b2) {
+                  return a2.length - b2.length;
+                });
+                var circularLinks = {};
+                for (i2 = 0; i2 < cycles.length; i2++) {
+                  var cycle = cycles[i2];
+                  var last = cycle.slice(-2);
+                  if (!circularLinks[last[0]]) circularLinks[last[0]] = {};
+                  circularLinks[last[0]][last[1]] = true;
+                }
+                graph.links.forEach(function(link2) {
+                  var target2 = link2.target.index;
+                  var source22 = link2.source.index;
+                  if (target2 === source22 || circularLinks[source22] && circularLinks[source22][target2]) {
+                    link2.circular = true;
+                    link2.circularLinkID = circularLinkID;
+                    circularLinkID = circularLinkID + 1;
+                  } else {
+                    link2.circular = false;
+                  }
+                });
+              } else {
+                graph.links.forEach(function(link2) {
+                  if (link2.source[sortNodes] < link2.target[sortNodes]) {
+                    link2.circular = false;
+                  } else {
+                    link2.circular = true;
+                    link2.circularLinkID = circularLinkID;
+                    circularLinkID = circularLinkID + 1;
+                  }
+                });
+              }
+            }
+            function selectCircularLinkTypes(graph, id2) {
+              var numberOfTops = 0;
+              var numberOfBottoms = 0;
+              graph.links.forEach(function(link) {
+                if (link.circular) {
+                  if (link.source.circularLinkType || link.target.circularLinkType) {
+                    link.circularLinkType = link.source.circularLinkType ? link.source.circularLinkType : link.target.circularLinkType;
+                  } else {
+                    link.circularLinkType = numberOfTops < numberOfBottoms ? "top" : "bottom";
+                  }
+                  if (link.circularLinkType == "top") {
+                    numberOfTops = numberOfTops + 1;
+                  } else {
+                    numberOfBottoms = numberOfBottoms + 1;
+                  }
+                  graph.nodes.forEach(function(node) {
+                    if (getNodeID(node, id2) == getNodeID(link.source, id2) || getNodeID(node, id2) == getNodeID(link.target, id2)) {
+                      node.circularLinkType = link.circularLinkType;
+                    }
+                  });
+                }
+              });
+              graph.links.forEach(function(link) {
+                if (link.circular) {
+                  if (link.source.circularLinkType == link.target.circularLinkType) {
+                    link.circularLinkType = link.source.circularLinkType;
+                  }
+                  if (selfLinking(link, id2)) {
+                    link.circularLinkType = link.source.circularLinkType;
+                  }
+                }
+              });
+            }
+            function linkAngle(link) {
+              var adjacent = Math.abs(link.y1 - link.y0);
+              var opposite = Math.abs(link.target.x0 - link.source.x1);
+              return Math.atan(opposite / adjacent);
+            }
+            function circularLinksCross(link1, link2) {
+              if (link1.source.column < link2.target.column) {
+                return false;
+              } else if (link1.target.column > link2.source.column) {
+                return false;
+              } else {
+                return true;
+              }
+            }
+            function numberOfNonSelfLinkingCycles(node, id2) {
+              var sourceCount = 0;
+              node.sourceLinks.forEach(function(l2) {
+                sourceCount = l2.circular && !selfLinking(l2, id2) ? sourceCount + 1 : sourceCount;
+              });
+              var targetCount = 0;
+              node.targetLinks.forEach(function(l2) {
+                targetCount = l2.circular && !selfLinking(l2, id2) ? targetCount + 1 : targetCount;
+              });
+              return sourceCount + targetCount;
+            }
+            function onlyCircularLink(link) {
+              var nodeSourceLinks = link.source.sourceLinks;
+              var sourceCount = 0;
+              nodeSourceLinks.forEach(function(l2) {
+                sourceCount = l2.circular ? sourceCount + 1 : sourceCount;
+              });
+              var nodeTargetLinks = link.target.targetLinks;
+              var targetCount = 0;
+              nodeTargetLinks.forEach(function(l2) {
+                targetCount = l2.circular ? targetCount + 1 : targetCount;
+              });
+              if (sourceCount > 1 || targetCount > 1) {
+                return false;
+              } else {
+                return true;
+              }
+            }
+            function calcVerticalBuffer(links, circularLinkGap, id2) {
+              links.sort(sortLinkColumnAscending);
+              links.forEach(function(link, i2) {
+                var buffer = 0;
+                if (selfLinking(link, id2) && onlyCircularLink(link)) {
+                  link.circularPathData.verticalBuffer = buffer + link.width / 2;
+                } else {
+                  var j2 = 0;
+                  for (j2; j2 < i2; j2++) {
+                    if (circularLinksCross(links[i2], links[j2])) {
+                      var bufferOverThisLink = links[j2].circularPathData.verticalBuffer + links[j2].width / 2 + circularLinkGap;
+                      buffer = bufferOverThisLink > buffer ? bufferOverThisLink : buffer;
+                    }
+                  }
+                  link.circularPathData.verticalBuffer = buffer + link.width / 2;
+                }
+              });
+              return links;
+            }
+            function addCircularPathData(graph, circularLinkGap, y1, id2) {
+              var buffer = 5;
+              var minY = d3Array.min(graph.links, function(link) {
+                return link.source.y0;
+              });
+              graph.links.forEach(function(link) {
+                if (link.circular) {
+                  link.circularPathData = {};
+                }
+              });
+              var topLinks = graph.links.filter(function(l2) {
+                return l2.circularLinkType == "top";
+              });
+              calcVerticalBuffer(topLinks, circularLinkGap, id2);
+              var bottomLinks = graph.links.filter(function(l2) {
+                return l2.circularLinkType == "bottom";
+              });
+              calcVerticalBuffer(bottomLinks, circularLinkGap, id2);
+              graph.links.forEach(function(link) {
+                if (link.circular) {
+                  link.circularPathData.arcRadius = link.width + baseRadius;
+                  link.circularPathData.leftNodeBuffer = buffer;
+                  link.circularPathData.rightNodeBuffer = buffer;
+                  link.circularPathData.sourceWidth = link.source.x1 - link.source.x0;
+                  link.circularPathData.sourceX = link.source.x0 + link.circularPathData.sourceWidth;
+                  link.circularPathData.targetX = link.target.x0;
+                  link.circularPathData.sourceY = link.y0;
+                  link.circularPathData.targetY = link.y1;
+                  if (selfLinking(link, id2) && onlyCircularLink(link)) {
+                    link.circularPathData.leftSmallArcRadius = baseRadius + link.width / 2;
+                    link.circularPathData.leftLargeArcRadius = baseRadius + link.width / 2;
+                    link.circularPathData.rightSmallArcRadius = baseRadius + link.width / 2;
+                    link.circularPathData.rightLargeArcRadius = baseRadius + link.width / 2;
+                    if (link.circularLinkType == "bottom") {
+                      link.circularPathData.verticalFullExtent = link.source.y1 + verticalMargin + link.circularPathData.verticalBuffer;
+                      link.circularPathData.verticalLeftInnerExtent = link.circularPathData.verticalFullExtent - link.circularPathData.leftLargeArcRadius;
+                      link.circularPathData.verticalRightInnerExtent = link.circularPathData.verticalFullExtent - link.circularPathData.rightLargeArcRadius;
+                    } else {
+                      link.circularPathData.verticalFullExtent = link.source.y0 - verticalMargin - link.circularPathData.verticalBuffer;
+                      link.circularPathData.verticalLeftInnerExtent = link.circularPathData.verticalFullExtent + link.circularPathData.leftLargeArcRadius;
+                      link.circularPathData.verticalRightInnerExtent = link.circularPathData.verticalFullExtent + link.circularPathData.rightLargeArcRadius;
+                    }
+                  } else {
+                    var thisColumn = link.source.column;
+                    var thisCircularLinkType = link.circularLinkType;
+                    var sameColumnLinks = graph.links.filter(function(l2) {
+                      return l2.source.column == thisColumn && l2.circularLinkType == thisCircularLinkType;
+                    });
+                    if (link.circularLinkType == "bottom") {
+                      sameColumnLinks.sort(sortLinkSourceYDescending);
+                    } else {
+                      sameColumnLinks.sort(sortLinkSourceYAscending);
+                    }
+                    var radiusOffset = 0;
+                    sameColumnLinks.forEach(function(l2, i2) {
+                      if (l2.circularLinkID == link.circularLinkID) {
+                        link.circularPathData.leftSmallArcRadius = baseRadius + link.width / 2 + radiusOffset;
+                        link.circularPathData.leftLargeArcRadius = baseRadius + link.width / 2 + i2 * circularLinkGap + radiusOffset;
+                      }
+                      radiusOffset = radiusOffset + l2.width;
+                    });
+                    thisColumn = link.target.column;
+                    sameColumnLinks = graph.links.filter(function(l2) {
+                      return l2.target.column == thisColumn && l2.circularLinkType == thisCircularLinkType;
+                    });
+                    if (link.circularLinkType == "bottom") {
+                      sameColumnLinks.sort(sortLinkTargetYDescending);
+                    } else {
+                      sameColumnLinks.sort(sortLinkTargetYAscending);
+                    }
+                    radiusOffset = 0;
+                    sameColumnLinks.forEach(function(l2, i2) {
+                      if (l2.circularLinkID == link.circularLinkID) {
+                        link.circularPathData.rightSmallArcRadius = baseRadius + link.width / 2 + radiusOffset;
+                        link.circularPathData.rightLargeArcRadius = baseRadius + link.width / 2 + i2 * circularLinkGap + radiusOffset;
+                      }
+                      radiusOffset = radiusOffset + l2.width;
+                    });
+                    if (link.circularLinkType == "bottom") {
+                      link.circularPathData.verticalFullExtent = Math.max(y1, link.source.y1, link.target.y1) + verticalMargin + link.circularPathData.verticalBuffer;
+                      link.circularPathData.verticalLeftInnerExtent = link.circularPathData.verticalFullExtent - link.circularPathData.leftLargeArcRadius;
+                      link.circularPathData.verticalRightInnerExtent = link.circularPathData.verticalFullExtent - link.circularPathData.rightLargeArcRadius;
+                    } else {
+                      link.circularPathData.verticalFullExtent = minY - verticalMargin - link.circularPathData.verticalBuffer;
+                      link.circularPathData.verticalLeftInnerExtent = link.circularPathData.verticalFullExtent + link.circularPathData.leftLargeArcRadius;
+                      link.circularPathData.verticalRightInnerExtent = link.circularPathData.verticalFullExtent + link.circularPathData.rightLargeArcRadius;
+                    }
+                  }
+                  link.circularPathData.leftInnerExtent = link.circularPathData.sourceX + link.circularPathData.leftNodeBuffer;
+                  link.circularPathData.rightInnerExtent = link.circularPathData.targetX - link.circularPathData.rightNodeBuffer;
+                  link.circularPathData.leftFullExtent = link.circularPathData.sourceX + link.circularPathData.leftLargeArcRadius + link.circularPathData.leftNodeBuffer;
+                  link.circularPathData.rightFullExtent = link.circularPathData.targetX - link.circularPathData.rightLargeArcRadius - link.circularPathData.rightNodeBuffer;
+                }
+                if (link.circular) {
+                  link.path = createCircularPathString(link);
+                } else {
+                  var normalPath = d3Shape.linkHorizontal().source(function(d2) {
+                    var x2 = d2.source.x0 + (d2.source.x1 - d2.source.x0);
+                    var y2 = d2.y0;
+                    return [x2, y2];
+                  }).target(function(d2) {
+                    var x2 = d2.target.x0;
+                    var y2 = d2.y1;
+                    return [x2, y2];
+                  });
+                  link.path = normalPath(link);
+                }
+              });
+            }
+            function createCircularPathString(link) {
+              var pathString = "";
+              if (link.circularLinkType == "top") {
+                pathString = // start at the right of the source node
+                "M" + link.circularPathData.sourceX + " " + link.circularPathData.sourceY + " L" + link.circularPathData.leftInnerExtent + " " + link.circularPathData.sourceY + " A" + link.circularPathData.leftLargeArcRadius + " " + link.circularPathData.leftSmallArcRadius + " 0 0 0 " + // End of arc X //End of arc Y
+                link.circularPathData.leftFullExtent + " " + (link.circularPathData.sourceY - link.circularPathData.leftSmallArcRadius) + " L" + link.circularPathData.leftFullExtent + " " + link.circularPathData.verticalLeftInnerExtent + " A" + link.circularPathData.leftLargeArcRadius + " " + link.circularPathData.leftLargeArcRadius + " 0 0 0 " + // End of arc X //End of arc Y
+                link.circularPathData.leftInnerExtent + " " + link.circularPathData.verticalFullExtent + " L" + link.circularPathData.rightInnerExtent + " " + link.circularPathData.verticalFullExtent + " A" + link.circularPathData.rightLargeArcRadius + " " + link.circularPathData.rightLargeArcRadius + " 0 0 0 " + // End of arc X //End of arc Y
+                link.circularPathData.rightFullExtent + " " + link.circularPathData.verticalRightInnerExtent + " L" + link.circularPathData.rightFullExtent + " " + (link.circularPathData.targetY - link.circularPathData.rightSmallArcRadius) + " A" + link.circularPathData.rightLargeArcRadius + " " + link.circularPathData.rightSmallArcRadius + " 0 0 0 " + // End of arc X //End of arc Y
+                link.circularPathData.rightInnerExtent + " " + link.circularPathData.targetY + " L" + link.circularPathData.targetX + " " + link.circularPathData.targetY;
+              } else {
+                pathString = // start at the right of the source node
+                "M" + link.circularPathData.sourceX + " " + link.circularPathData.sourceY + " L" + link.circularPathData.leftInnerExtent + " " + link.circularPathData.sourceY + " A" + link.circularPathData.leftLargeArcRadius + " " + link.circularPathData.leftSmallArcRadius + " 0 0 1 " + // End of arc X //End of arc Y
+                link.circularPathData.leftFullExtent + " " + (link.circularPathData.sourceY + link.circularPathData.leftSmallArcRadius) + " L" + link.circularPathData.leftFullExtent + " " + link.circularPathData.verticalLeftInnerExtent + " A" + link.circularPathData.leftLargeArcRadius + " " + link.circularPathData.leftLargeArcRadius + " 0 0 1 " + // End of arc X //End of arc Y
+                link.circularPathData.leftInnerExtent + " " + link.circularPathData.verticalFullExtent + " L" + link.circularPathData.rightInnerExtent + " " + link.circularPathData.verticalFullExtent + " A" + link.circularPathData.rightLargeArcRadius + " " + link.circularPathData.rightLargeArcRadius + " 0 0 1 " + // End of arc X //End of arc Y
+                link.circularPathData.rightFullExtent + " " + link.circularPathData.verticalRightInnerExtent + " L" + link.circularPathData.rightFullExtent + " " + (link.circularPathData.targetY + link.circularPathData.rightSmallArcRadius) + " A" + link.circularPathData.rightLargeArcRadius + " " + link.circularPathData.rightSmallArcRadius + " 0 0 1 " + // End of arc X //End of arc Y
+                link.circularPathData.rightInnerExtent + " " + link.circularPathData.targetY + " L" + link.circularPathData.targetX + " " + link.circularPathData.targetY;
+              }
+              return pathString;
+            }
+            function sortLinkColumnAscending(link1, link2) {
+              if (linkColumnDistance(link1) == linkColumnDistance(link2)) {
+                return link1.circularLinkType == "bottom" ? sortLinkSourceYDescending(link1, link2) : sortLinkSourceYAscending(link1, link2);
+              } else {
+                return linkColumnDistance(link2) - linkColumnDistance(link1);
+              }
+            }
+            function sortLinkSourceYAscending(link1, link2) {
+              return link1.y0 - link2.y0;
+            }
+            function sortLinkSourceYDescending(link1, link2) {
+              return link2.y0 - link1.y0;
+            }
+            function sortLinkTargetYAscending(link1, link2) {
+              return link1.y1 - link2.y1;
+            }
+            function sortLinkTargetYDescending(link1, link2) {
+              return link2.y1 - link1.y1;
+            }
+            function linkColumnDistance(link) {
+              return link.target.column - link.source.column;
+            }
+            function linkXLength(link) {
+              return link.target.x0 - link.source.x1;
+            }
+            function linkPerpendicularYToLinkSource(longerLink, shorterLink) {
+              var angle2 = linkAngle(longerLink);
+              var heightFromY1ToPependicular = linkXLength(shorterLink) / Math.tan(angle2);
+              var yPerpendicular = incline(longerLink) == "up" ? longerLink.y1 + heightFromY1ToPependicular : longerLink.y1 - heightFromY1ToPependicular;
+              return yPerpendicular;
+            }
+            function linkPerpendicularYToLinkTarget(longerLink, shorterLink) {
+              var angle2 = linkAngle(longerLink);
+              var heightFromY1ToPependicular = linkXLength(shorterLink) / Math.tan(angle2);
+              var yPerpendicular = incline(longerLink) == "up" ? longerLink.y1 - heightFromY1ToPependicular : longerLink.y1 + heightFromY1ToPependicular;
+              return yPerpendicular;
+            }
+            function resolveNodeLinkOverlaps(graph, y0, y1, id2) {
+              graph.links.forEach(function(link) {
+                if (link.circular) {
+                  return;
+                }
+                if (link.target.column - link.source.column > 1) {
+                  var columnToTest = link.source.column + 1;
+                  var maxColumnToTest = link.target.column - 1;
+                  var i2 = 1;
+                  var numberOfColumnsToTest = maxColumnToTest - columnToTest + 1;
+                  for (i2 = 1; columnToTest <= maxColumnToTest; columnToTest++, i2++) {
+                    graph.nodes.forEach(function(node) {
+                      if (node.column == columnToTest) {
+                        var t4 = i2 / (numberOfColumnsToTest + 1);
+                        var B0_t = Math.pow(1 - t4, 3);
+                        var B1_t = 3 * t4 * Math.pow(1 - t4, 2);
+                        var B2_t = 3 * Math.pow(t4, 2) * (1 - t4);
+                        var B3_t = Math.pow(t4, 3);
+                        var py_t = B0_t * link.y0 + B1_t * link.y0 + B2_t * link.y1 + B3_t * link.y1;
+                        var linkY0AtColumn = py_t - link.width / 2;
+                        var linkY1AtColumn = py_t + link.width / 2;
+                        var dy;
+                        if (linkY0AtColumn > node.y0 && linkY0AtColumn < node.y1) {
+                          dy = node.y1 - linkY0AtColumn + 10;
+                          dy = node.circularLinkType == "bottom" ? dy : -dy;
+                          node = adjustNodeHeight(node, dy, y0, y1);
+                          graph.nodes.forEach(function(otherNode) {
+                            if (getNodeID(otherNode, id2) == getNodeID(node, id2) || otherNode.column != node.column) {
+                              return;
+                            }
+                            if (nodesOverlap(node, otherNode)) {
+                              adjustNodeHeight(otherNode, dy, y0, y1);
+                            }
+                          });
+                        } else if (linkY1AtColumn > node.y0 && linkY1AtColumn < node.y1) {
+                          dy = linkY1AtColumn - node.y0 + 10;
+                          node = adjustNodeHeight(node, dy, y0, y1);
+                          graph.nodes.forEach(function(otherNode) {
+                            if (getNodeID(otherNode, id2) == getNodeID(node, id2) || otherNode.column != node.column) {
+                              return;
+                            }
+                            if (otherNode.y0 < node.y1 && otherNode.y1 > node.y1) {
+                              adjustNodeHeight(otherNode, dy, y0, y1);
+                            }
+                          });
+                        } else if (linkY0AtColumn < node.y0 && linkY1AtColumn > node.y1) {
+                          dy = linkY1AtColumn - node.y0 + 10;
+                          node = adjustNodeHeight(node, dy, y0, y1);
+                          graph.nodes.forEach(function(otherNode) {
+                            if (getNodeID(otherNode, id2) == getNodeID(node, id2) || otherNode.column != node.column) {
+                              return;
+                            }
+                            if (otherNode.y0 < node.y1 && otherNode.y1 > node.y1) {
+                              adjustNodeHeight(otherNode, dy, y0, y1);
+                            }
+                          });
+                        }
+                      }
+                    });
+                  }
+                }
+              });
+            }
+            function nodesOverlap(nodeA, nodeB) {
+              if (nodeA.y0 > nodeB.y0 && nodeA.y0 < nodeB.y1) {
+                return true;
+              } else if (nodeA.y1 > nodeB.y0 && nodeA.y1 < nodeB.y1) {
+                return true;
+              } else if (nodeA.y0 < nodeB.y0 && nodeA.y1 > nodeB.y1) {
+                return true;
+              } else {
+                return false;
+              }
+            }
+            function adjustNodeHeight(node, dy, sankeyY0, sankeyY1) {
+              if (node.y0 + dy >= sankeyY0 && node.y1 + dy <= sankeyY1) {
+                node.y0 = node.y0 + dy;
+                node.y1 = node.y1 + dy;
+                node.targetLinks.forEach(function(l2) {
+                  l2.y1 = l2.y1 + dy;
+                });
+                node.sourceLinks.forEach(function(l2) {
+                  l2.y0 = l2.y0 + dy;
+                });
+              }
+              return node;
+            }
+            function sortSourceLinks(graph, y1, id2, moveNodes) {
+              graph.nodes.forEach(function(node) {
+                if (moveNodes && node.y + (node.y1 - node.y0) > y1) {
+                  node.y = node.y - (node.y + (node.y1 - node.y0) - y1);
+                }
+                var nodesSourceLinks = graph.links.filter(function(l2) {
+                  return getNodeID(l2.source, id2) == getNodeID(node, id2);
+                });
+                var nodeSourceLinksLength = nodesSourceLinks.length;
+                if (nodeSourceLinksLength > 1) {
+                  nodesSourceLinks.sort(function(link1, link2) {
+                    if (!link1.circular && !link2.circular) {
+                      if (link1.target.column == link2.target.column) {
+                        return link1.y1 - link2.y1;
+                      } else if (!sameInclines(link1, link2)) {
+                        return link1.y1 - link2.y1;
+                      } else {
+                        if (link1.target.column > link2.target.column) {
+                          var link2Adj = linkPerpendicularYToLinkTarget(link2, link1);
+                          return link1.y1 - link2Adj;
+                        }
+                        if (link2.target.column > link1.target.column) {
+                          var link1Adj = linkPerpendicularYToLinkTarget(link1, link2);
+                          return link1Adj - link2.y1;
+                        }
+                      }
+                    }
+                    if (link1.circular && !link2.circular) {
+                      return link1.circularLinkType == "top" ? -1 : 1;
+                    } else if (link2.circular && !link1.circular) {
+                      return link2.circularLinkType == "top" ? 1 : -1;
+                    }
+                    if (link1.circular && link2.circular) {
+                      if (link1.circularLinkType === link2.circularLinkType && link1.circularLinkType == "top") {
+                        if (link1.target.column === link2.target.column) {
+                          return link1.target.y1 - link2.target.y1;
+                        } else {
+                          return link2.target.column - link1.target.column;
+                        }
+                      } else if (link1.circularLinkType === link2.circularLinkType && link1.circularLinkType == "bottom") {
+                        if (link1.target.column === link2.target.column) {
+                          return link2.target.y1 - link1.target.y1;
+                        } else {
+                          return link1.target.column - link2.target.column;
+                        }
+                      } else {
+                        return link1.circularLinkType == "top" ? -1 : 1;
+                      }
+                    }
+                  });
+                }
+                var ySourceOffset = node.y0;
+                nodesSourceLinks.forEach(function(link) {
+                  link.y0 = ySourceOffset + link.width / 2;
+                  ySourceOffset = ySourceOffset + link.width;
+                });
+                nodesSourceLinks.forEach(function(link, i2) {
+                  if (link.circularLinkType == "bottom") {
+                    var j2 = i2 + 1;
+                    var offsetFromBottom = 0;
+                    for (j2; j2 < nodeSourceLinksLength; j2++) {
+                      offsetFromBottom = offsetFromBottom + nodesSourceLinks[j2].width;
+                    }
+                    link.y0 = node.y1 - offsetFromBottom - link.width / 2;
+                  }
+                });
+              });
+            }
+            function sortTargetLinks(graph, y1, id2) {
+              graph.nodes.forEach(function(node) {
+                var nodesTargetLinks = graph.links.filter(function(l2) {
+                  return getNodeID(l2.target, id2) == getNodeID(node, id2);
+                });
+                var nodesTargetLinksLength = nodesTargetLinks.length;
+                if (nodesTargetLinksLength > 1) {
+                  nodesTargetLinks.sort(function(link1, link2) {
+                    if (!link1.circular && !link2.circular) {
+                      if (link1.source.column == link2.source.column) {
+                        return link1.y0 - link2.y0;
+                      } else if (!sameInclines(link1, link2)) {
+                        return link1.y0 - link2.y0;
+                      } else {
+                        if (link2.source.column < link1.source.column) {
+                          var link2Adj = linkPerpendicularYToLinkSource(link2, link1);
+                          return link1.y0 - link2Adj;
+                        }
+                        if (link1.source.column < link2.source.column) {
+                          var link1Adj = linkPerpendicularYToLinkSource(link1, link2);
+                          return link1Adj - link2.y0;
+                        }
+                      }
+                    }
+                    if (link1.circular && !link2.circular) {
+                      return link1.circularLinkType == "top" ? -1 : 1;
+                    } else if (link2.circular && !link1.circular) {
+                      return link2.circularLinkType == "top" ? 1 : -1;
+                    }
+                    if (link1.circular && link2.circular) {
+                      if (link1.circularLinkType === link2.circularLinkType && link1.circularLinkType == "top") {
+                        if (link1.source.column === link2.source.column) {
+                          return link1.source.y1 - link2.source.y1;
+                        } else {
+                          return link1.source.column - link2.source.column;
+                        }
+                      } else if (link1.circularLinkType === link2.circularLinkType && link1.circularLinkType == "bottom") {
+                        if (link1.source.column === link2.source.column) {
+                          return link1.source.y1 - link2.source.y1;
+                        } else {
+                          return link2.source.column - link1.source.column;
+                        }
+                      } else {
+                        return link1.circularLinkType == "top" ? -1 : 1;
+                      }
+                    }
+                  });
+                }
+                var yTargetOffset = node.y0;
+                nodesTargetLinks.forEach(function(link) {
+                  link.y1 = yTargetOffset + link.width / 2;
+                  yTargetOffset = yTargetOffset + link.width;
+                });
+                nodesTargetLinks.forEach(function(link, i2) {
+                  if (link.circularLinkType == "bottom") {
+                    var j2 = i2 + 1;
+                    var offsetFromBottom = 0;
+                    for (j2; j2 < nodesTargetLinksLength; j2++) {
+                      offsetFromBottom = offsetFromBottom + nodesTargetLinks[j2].width;
+                    }
+                    link.y1 = node.y1 - offsetFromBottom - link.width / 2;
+                  }
+                });
+              });
+            }
+            function sameInclines(link1, link2) {
+              return incline(link1) == incline(link2);
+            }
+            function incline(link) {
+              return link.y0 - link.y1 > 0 ? "up" : "down";
+            }
+            function selfLinking(link, id2) {
+              return getNodeID(link.source, id2) == getNodeID(link.target, id2);
+            }
+            function fillHeight(graph, y0, y1) {
+              var nodes = graph.nodes;
+              var links = graph.links;
+              var top = false;
+              var bottom = false;
+              links.forEach(function(link) {
+                if (link.circularLinkType == "top") {
+                  top = true;
+                } else if (link.circularLinkType == "bottom") {
+                  bottom = true;
+                }
+              });
+              if (top == false || bottom == false) {
+                var minY0 = d3Array.min(nodes, function(node) {
+                  return node.y0;
+                });
+                var maxY1 = d3Array.max(nodes, function(node) {
+                  return node.y1;
+                });
+                var currentHeight = maxY1 - minY0;
+                var chartHeight = y1 - y0;
+                var ratio = chartHeight / currentHeight;
+                nodes.forEach(function(node) {
+                  var nodeHeight = (node.y1 - node.y0) * ratio;
+                  node.y0 = (node.y0 - minY0) * ratio;
+                  node.y1 = node.y0 + nodeHeight;
+                });
+                links.forEach(function(link) {
+                  link.y0 = (link.y0 - minY0) * ratio;
+                  link.y1 = (link.y1 - minY0) * ratio;
+                  link.width = link.width * ratio;
+                });
+              }
+            }
+            exports2.sankeyCircular = sankeyCircular;
+            exports2.sankeyCenter = center;
+            exports2.sankeyLeft = left;
+            exports2.sankeyRight = right;
+            exports2.sankeyJustify = justify;
+            Object.defineProperty(exports2, "__esModule", { value: true });
+          });
+        }
+      });
+      var require_constants29 = __commonJS({
+        "src/traces/sankey/constants.js"(exports, module2) {
+          module2.exports = {
+            nodeTextOffsetHorizontal: 4,
+            nodeTextOffsetVertical: 3,
+            nodePadAcross: 10,
+            sankeyIterations: 50,
+            forceIterations: 5,
+            forceTicksPerFrame: 10,
+            duration: 500,
+            ease: "linear",
+            cn: {
+              sankey: "sankey",
+              sankeyLinks: "sankey-links",
+              sankeyLink: "sankey-link",
+              sankeyNodeSet: "sankey-node-set",
+              sankeyNode: "sankey-node",
+              nodeRect: "node-rect",
+              nodeLabel: "node-label"
+            }
+          };
+        }
+      });
+      var require_render = __commonJS({
+        "src/traces/sankey/render.js"(exports, module2) {
+          var d3Force = require_d3_force();
+          var interpolateNumber = (init_src2(), __toCommonJS(src_exports)).interpolateNumber;
+          var d3 = require_d3();
+          var d3Sankey = require_d3_sankey();
+          var d3SankeyCircular = require_d3_sankey_circular();
+          var c2 = require_constants29();
+          var tinycolor = require_tinycolor();
+          var Color2 = require_color();
+          var Drawing = require_drawing();
+          var Lib = require_lib();
+          var strTranslate = Lib.strTranslate;
+          var strRotate = Lib.strRotate;
+          var gup = require_gup();
+          var keyFun = gup.keyFun;
+          var repeat = gup.repeat;
+          var unwrap = gup.unwrap;
+          var svgTextUtils = require_svg_text_utils();
+          var Registry = require_registry();
+          var alignmentConstants = require_alignment();
+          var CAP_SHIFT = alignmentConstants.CAP_SHIFT;
+          var LINE_SPACING = alignmentConstants.LINE_SPACING;
+          var TEXTPAD = 3;
+          function sankeyModel(layout, d2, traceIndex) {
+            var calcData = unwrap(d2);
+            var trace = calcData.trace;
+            var domain = trace.domain;
+            var horizontal = trace.orientation === "h";
+            var nodePad = trace.node.pad;
+            var nodeThickness = trace.node.thickness;
+            var nodeAlign = {
+              justify: d3Sankey.sankeyJustify,
+              left: d3Sankey.sankeyLeft,
+              right: d3Sankey.sankeyRight,
+              center: d3Sankey.sankeyCenter
+            }[trace.node.align];
+            var width = layout.width * (domain.x[1] - domain.x[0]);
+            var height = layout.height * (domain.y[1] - domain.y[0]);
+            var nodes = calcData._nodes;
+            var links = calcData._links;
+            var circular = calcData.circular;
+            var sankey;
+            if (circular) {
+              sankey = d3SankeyCircular.sankeyCircular().circularLinkGap(0);
+            } else {
+              sankey = d3Sankey.sankey();
+            }
+            sankey.iterations(c2.sankeyIterations).size(horizontal ? [width, height] : [height, width]).nodeWidth(nodeThickness).nodePadding(nodePad).nodeId(function(d22) {
+              return d22.pointNumber;
+            }).nodeAlign(nodeAlign).nodes(nodes).links(links);
+            var graph = sankey();
+            if (sankey.nodePadding() < nodePad) {
+              Lib.warn("node.pad was reduced to ", sankey.nodePadding(), " to fit within the figure.");
+            }
+            var i2, j2, k2;
+            for (var nodePointNumber in calcData._groupLookup) {
+              var groupIndex = parseInt(calcData._groupLookup[nodePointNumber]);
+              var groupingNode;
+              for (i2 = 0; i2 < graph.nodes.length; i2++) {
+                if (graph.nodes[i2].pointNumber === groupIndex) {
+                  groupingNode = graph.nodes[i2];
+                  break;
+                }
+              }
+              if (!groupingNode) continue;
+              var child = {
+                pointNumber: parseInt(nodePointNumber),
+                x0: groupingNode.x0,
+                x1: groupingNode.x1,
+                y0: groupingNode.y0,
+                y1: groupingNode.y1,
+                partOfGroup: true,
+                sourceLinks: [],
+                targetLinks: []
+              };
+              graph.nodes.unshift(child);
+              groupingNode.childrenNodes.unshift(child);
+            }
+            function computeLinkConcentrations() {
+              for (i2 = 0; i2 < graph.nodes.length; i2++) {
+                var node = graph.nodes[i2];
+                var flows = {};
+                var flowKey;
+                var link;
+                for (j2 = 0; j2 < node.targetLinks.length; j2++) {
+                  link = node.targetLinks[j2];
+                  flowKey = link.source.pointNumber + ":" + link.target.pointNumber;
+                  if (!flows.hasOwnProperty(flowKey)) flows[flowKey] = [];
+                  flows[flowKey].push(link);
+                }
+                var keys = Object.keys(flows);
+                for (j2 = 0; j2 < keys.length; j2++) {
+                  flowKey = keys[j2];
+                  var flowLinks = flows[flowKey];
+                  var total = 0;
+                  var totalPerLabel = {};
+                  for (k2 = 0; k2 < flowLinks.length; k2++) {
+                    link = flowLinks[k2];
+                    if (!totalPerLabel[link.label]) totalPerLabel[link.label] = 0;
+                    totalPerLabel[link.label] += link.value;
+                    total += link.value;
+                  }
+                  for (k2 = 0; k2 < flowLinks.length; k2++) {
+                    link = flowLinks[k2];
+                    link.flow = {
+                      value: total,
+                      labelConcentration: totalPerLabel[link.label] / total,
+                      concentration: link.value / total,
+                      links: flowLinks
+                    };
+                    if (link.concentrationscale) {
+                      link.color = tinycolor(link.concentrationscale(link.flow.labelConcentration));
+                    }
+                  }
+                }
+                var totalOutflow = 0;
+                for (j2 = 0; j2 < node.sourceLinks.length; j2++) {
+                  totalOutflow += node.sourceLinks[j2].value;
+                }
+                for (j2 = 0; j2 < node.sourceLinks.length; j2++) {
+                  link = node.sourceLinks[j2];
+                  link.concentrationOut = link.value / totalOutflow;
+                }
+                var totalInflow = 0;
+                for (j2 = 0; j2 < node.targetLinks.length; j2++) {
+                  totalInflow += node.targetLinks[j2].value;
+                }
+                for (j2 = 0; j2 < node.targetLinks.length; j2++) {
+                  link = node.targetLinks[j2];
+                  link.concenrationIn = link.value / totalInflow;
+                }
+              }
+            }
+            computeLinkConcentrations();
+            function resolveCollisionsTopToBottom(columns2) {
+              columns2.forEach(function(nodes2) {
+                var node;
+                var dy;
+                var y2 = 0;
+                var n2 = nodes2.length;
+                var i22;
+                nodes2.sort(function(a2, b2) {
+                  return a2.y0 - b2.y0;
+                });
+                for (i22 = 0; i22 < n2; ++i22) {
+                  node = nodes2[i22];
+                  if (node.y0 >= y2) ;
+                  else {
+                    dy = y2 - node.y0;
+                    if (dy > 1e-6) node.y0 += dy, node.y1 += dy;
+                  }
+                  y2 = node.y1 + nodePad;
+                }
+              });
+            }
+            function snapToColumns(nodes2) {
+              var orderedNodes = nodes2.map(function(n2, i22) {
+                return {
+                  x0: n2.x0,
+                  index: i22
+                };
+              }).sort(function(a2, b2) {
+                return a2.x0 - b2.x0;
+              });
+              var columns2 = [];
+              var colNumber = -1;
+              var colX;
+              var lastX = -Infinity;
+              var dx;
+              for (i2 = 0; i2 < orderedNodes.length; i2++) {
+                var node = nodes2[orderedNodes[i2].index];
+                if (node.x0 > lastX + nodeThickness) {
+                  colNumber += 1;
+                  colX = node.x0;
+                }
+                lastX = node.x0;
+                if (!columns2[colNumber]) columns2[colNumber] = [];
+                columns2[colNumber].push(node);
+                dx = colX - node.x0;
+                node.x0 += dx, node.x1 += dx;
+              }
+              return columns2;
+            }
+            if (trace.node.x.length && trace.node.y.length) {
+              for (i2 = 0; i2 < Math.min(trace.node.x.length, trace.node.y.length, graph.nodes.length); i2++) {
+                if (trace.node.x[i2] && trace.node.y[i2]) {
+                  var pos = [trace.node.x[i2] * width, trace.node.y[i2] * height];
+                  graph.nodes[i2].x0 = pos[0] - nodeThickness / 2;
+                  graph.nodes[i2].x1 = pos[0] + nodeThickness / 2;
+                  var nodeHeight = graph.nodes[i2].y1 - graph.nodes[i2].y0;
+                  graph.nodes[i2].y0 = pos[1] - nodeHeight / 2;
+                  graph.nodes[i2].y1 = pos[1] + nodeHeight / 2;
+                }
+              }
+              if (trace.arrangement === "snap") {
+                nodes = graph.nodes;
+                var columns = snapToColumns(nodes);
+                resolveCollisionsTopToBottom(columns);
+              }
+              sankey.update(graph);
+            }
+            return {
+              circular,
+              key: traceIndex,
+              trace,
+              guid: Lib.randstr(),
+              horizontal,
+              width,
+              height,
+              nodePad: trace.node.pad,
+              nodeLineColor: trace.node.line.color,
+              nodeLineWidth: trace.node.line.width,
+              linkLineColor: trace.link.line.color,
+              linkLineWidth: trace.link.line.width,
+              linkArrowLength: trace.link.arrowlen,
+              valueFormat: trace.valueformat,
+              valueSuffix: trace.valuesuffix,
+              textFont: trace.textfont,
+              translateX: domain.x[0] * layout.width + layout.margin.l,
+              translateY: layout.height - domain.y[1] * layout.height + layout.margin.t,
+              dragParallel: horizontal ? height : width,
+              dragPerpendicular: horizontal ? width : height,
+              arrangement: trace.arrangement,
+              sankey,
+              graph,
+              forceLayouts: {},
+              interactionState: {
+                dragInProgress: false,
+                hovered: false
+              }
+            };
+          }
+          function linkModel(d2, l2, i2) {
+            var tc2 = tinycolor(l2.color);
+            var htc = tinycolor(l2.hovercolor);
+            var basicKey = l2.source.label + "|" + l2.target.label;
+            var key = basicKey + "__" + i2;
+            l2.trace = d2.trace;
+            l2.curveNumber = d2.trace.index;
+            return {
+              circular: d2.circular,
+              key,
+              traceId: d2.key,
+              pointNumber: l2.pointNumber,
+              link: l2,
+              tinyColorHue: Color2.tinyRGB(tc2),
+              tinyColorAlpha: tc2.getAlpha(),
+              tinyColorHoverHue: Color2.tinyRGB(htc),
+              tinyColorHoverAlpha: htc.getAlpha(),
+              linkPath,
+              linkLineColor: d2.linkLineColor,
+              linkLineWidth: d2.linkLineWidth,
+              linkArrowLength: d2.linkArrowLength,
+              valueFormat: d2.valueFormat,
+              valueSuffix: d2.valueSuffix,
+              sankey: d2.sankey,
+              parent: d2,
+              interactionState: d2.interactionState,
+              flow: l2.flow
+            };
+          }
+          function createCircularClosedPathString(link, arrowLen) {
+            var pathString = "";
+            var offset = link.width / 2;
+            var coords = link.circularPathData;
+            var isSourceBeforeTarget = coords.sourceX + coords.verticalBuffer < coords.targetX;
+            var isPathOverlapped = coords.rightFullExtent - coords.rightLargeArcRadius - arrowLen <= coords.leftFullExtent - offset;
+            Math.abs(coords.rightFullExtent - coords.leftFullExtent - offset) < offset;
+            if (link.circularLinkType === "top") {
+              pathString = // start at the left of the target node
+              "M " + (coords.targetX - arrowLen) + " " + (coords.targetY + offset) + " L " + (coords.rightInnerExtent - arrowLen) + " " + (coords.targetY + offset) + "A " + (coords.rightLargeArcRadius + offset) + " " + (coords.rightSmallArcRadius + offset) + " 0 0 1 " + (coords.rightFullExtent - offset - arrowLen) + " " + (coords.targetY - coords.rightSmallArcRadius) + "L " + (coords.rightFullExtent - offset - arrowLen) + " " + coords.verticalRightInnerExtent;
+              if (isSourceBeforeTarget && isPathOverlapped) {
+                pathString += " A " + (coords.rightLargeArcRadius + offset) + " " + (coords.rightLargeArcRadius + offset) + " 0 0 1 " + (coords.rightFullExtent + offset - arrowLen - (coords.rightLargeArcRadius - offset)) + " " + (coords.verticalRightInnerExtent - (coords.rightLargeArcRadius + offset)) + " L " + (coords.rightFullExtent + offset - (coords.rightLargeArcRadius - offset) - arrowLen) + " " + (coords.verticalRightInnerExtent - (coords.rightLargeArcRadius + offset)) + " A " + (coords.leftLargeArcRadius + offset) + " " + (coords.leftLargeArcRadius + offset) + " 0 0 1 " + (coords.leftFullExtent + offset) + " " + coords.verticalRightInnerExtent;
+              } else if (isSourceBeforeTarget) {
+                pathString += " A " + (coords.rightLargeArcRadius - offset) + " " + (coords.rightLargeArcRadius - offset) + " 0 0 0 " + (coords.rightFullExtent - offset - arrowLen - (coords.rightLargeArcRadius - offset)) + " " + (coords.verticalRightInnerExtent - (coords.rightLargeArcRadius - offset)) + " L " + (coords.leftFullExtent + offset + (coords.rightLargeArcRadius - offset)) + " " + (coords.verticalRightInnerExtent - (coords.rightLargeArcRadius - offset)) + " A " + (coords.leftLargeArcRadius - offset) + " " + (coords.leftLargeArcRadius - offset) + " 0 0 0 " + (coords.leftFullExtent + offset) + " " + coords.verticalLeftInnerExtent;
+              } else {
+                pathString += " A " + (coords.rightLargeArcRadius + offset) + " " + (coords.rightLargeArcRadius + offset) + " 0 0 1 " + (coords.rightInnerExtent - arrowLen) + " " + (coords.verticalFullExtent - offset) + " L " + coords.leftInnerExtent + " " + (coords.verticalFullExtent - offset) + " A " + (coords.leftLargeArcRadius + offset) + " " + (coords.leftLargeArcRadius + offset) + " 0 0 1 " + (coords.leftFullExtent + offset) + " " + coords.verticalLeftInnerExtent;
+              }
+              pathString += " L " + (coords.leftFullExtent + offset) + " " + (coords.sourceY - coords.leftSmallArcRadius) + " A " + (coords.leftLargeArcRadius + offset) + " " + (coords.leftSmallArcRadius + offset) + " 0 0 1 " + coords.leftInnerExtent + " " + (coords.sourceY + offset) + " L " + coords.sourceX + " " + (coords.sourceY + offset) + // Walking back
+              " L " + coords.sourceX + " " + (coords.sourceY - offset) + " L " + coords.leftInnerExtent + " " + (coords.sourceY - offset) + " A " + (coords.leftLargeArcRadius - offset) + " " + (coords.leftSmallArcRadius - offset) + " 0 0 0 " + (coords.leftFullExtent - offset) + " " + (coords.sourceY - coords.leftSmallArcRadius) + " L " + (coords.leftFullExtent - offset) + " " + coords.verticalLeftInnerExtent;
+              if (isSourceBeforeTarget && isPathOverlapped) {
+                pathString += " A " + (coords.leftLargeArcRadius + offset) + " " + (coords.leftSmallArcRadius + offset) + " 0 0 0 " + (coords.leftFullExtent - offset) + " " + (coords.verticalFullExtent + offset) + "L" + (coords.rightFullExtent + offset - arrowLen) + " " + (coords.verticalFullExtent + offset) + " A " + (coords.leftLargeArcRadius + offset) + " " + (coords.leftSmallArcRadius + offset) + " 0 0 0 " + (coords.rightFullExtent + offset - arrowLen) + " " + coords.verticalRightInnerExtent;
+              } else if (isSourceBeforeTarget) {
+                pathString += " A " + (coords.leftLargeArcRadius + offset) + " " + (coords.leftSmallArcRadius + offset) + " 0 0 1 " + (coords.leftFullExtent + offset) + " " + (coords.verticalFullExtent - offset) + " L " + (coords.rightFullExtent - offset - arrowLen) + " " + (coords.verticalFullExtent - offset) + " A " + (coords.leftLargeArcRadius + offset) + " " + (coords.leftSmallArcRadius + offset) + " 0 0 1 " + (coords.rightFullExtent + offset - arrowLen) + " " + coords.verticalRightInnerExtent;
+              } else {
+                pathString += " A " + (coords.leftLargeArcRadius - offset) + " " + (coords.leftLargeArcRadius - offset) + " 0 0 0 " + coords.leftInnerExtent + " " + (coords.verticalFullExtent + offset) + " L " + (coords.rightInnerExtent - arrowLen) + " " + (coords.verticalFullExtent + offset) + " A " + (coords.rightLargeArcRadius - offset) + " " + (coords.rightLargeArcRadius - offset) + " 0 0 0 " + (coords.rightFullExtent + offset - arrowLen) + " " + coords.verticalRightInnerExtent;
+              }
+              pathString += " L " + (coords.rightFullExtent + offset - arrowLen) + " " + (coords.targetY - coords.rightSmallArcRadius) + " A " + (coords.rightLargeArcRadius - offset) + " " + (coords.rightSmallArcRadius - offset) + " 0 0 0 " + (coords.rightInnerExtent - arrowLen) + " " + (coords.targetY - offset) + " L " + (coords.targetX - arrowLen) + " " + (coords.targetY - offset) + (arrowLen > 0 ? " L " + coords.targetX + " " + coords.targetY : "") + "Z";
+            } else {
+              pathString = "M " + (coords.targetX - arrowLen) + " " + (coords.targetY - offset) + "  L " + (coords.rightInnerExtent - arrowLen) + " " + (coords.targetY - offset) + " A " + (coords.rightLargeArcRadius + offset) + " " + (coords.rightSmallArcRadius + offset) + " 0 0 0 " + (coords.rightFullExtent - offset - arrowLen) + " " + (coords.targetY + coords.rightSmallArcRadius) + " L " + (coords.rightFullExtent - offset - arrowLen) + " " + coords.verticalRightInnerExtent;
+              if (isSourceBeforeTarget && isPathOverlapped) {
+                pathString += " A " + (coords.rightLargeArcRadius + offset) + " " + (coords.rightLargeArcRadius + offset) + " 0 0 0 " + (coords.rightInnerExtent - offset - arrowLen) + " " + (coords.verticalFullExtent + offset) + " L " + (coords.rightFullExtent + offset - arrowLen - (coords.rightLargeArcRadius - offset)) + " " + (coords.verticalFullExtent + offset) + " A " + (coords.rightLargeArcRadius + offset) + " " + (coords.rightLargeArcRadius + offset) + " 0 0 0 " + (coords.leftFullExtent + offset) + " " + coords.verticalLeftInnerExtent;
+              } else if (isSourceBeforeTarget) {
+                pathString += " A " + (coords.rightLargeArcRadius - offset) + " " + (coords.rightSmallArcRadius - offset) + " 0 0 1 " + (coords.rightFullExtent - arrowLen - offset - (coords.rightLargeArcRadius - offset)) + " " + (coords.verticalFullExtent - offset) + " L " + (coords.leftFullExtent + offset + (coords.rightLargeArcRadius - offset)) + " " + (coords.verticalFullExtent - offset) + " A " + (coords.rightLargeArcRadius - offset) + " " + (coords.rightSmallArcRadius - offset) + " 0 0 1 " + (coords.leftFullExtent + offset) + " " + coords.verticalLeftInnerExtent;
+              } else {
+                pathString += " A " + (coords.rightLargeArcRadius + offset) + " " + (coords.rightLargeArcRadius + offset) + " 0 0 0 " + (coords.rightInnerExtent - arrowLen) + " " + (coords.verticalFullExtent + offset) + " L " + coords.leftInnerExtent + " " + (coords.verticalFullExtent + offset) + " A " + (coords.leftLargeArcRadius + offset) + " " + (coords.leftLargeArcRadius + offset) + " 0 0 0 " + (coords.leftFullExtent + offset) + " " + coords.verticalLeftInnerExtent;
+              }
+              pathString += " L " + (coords.leftFullExtent + offset) + " " + (coords.sourceY + coords.leftSmallArcRadius) + " A " + (coords.leftLargeArcRadius + offset) + " " + (coords.leftSmallArcRadius + offset) + " 0 0 0 " + coords.leftInnerExtent + " " + (coords.sourceY - offset) + " L " + coords.sourceX + " " + (coords.sourceY - offset) + // Walking back
+              " L " + coords.sourceX + " " + (coords.sourceY + offset) + " L " + coords.leftInnerExtent + " " + (coords.sourceY + offset) + " A " + (coords.leftLargeArcRadius - offset) + " " + (coords.leftSmallArcRadius - offset) + " 0 0 1 " + (coords.leftFullExtent - offset) + " " + (coords.sourceY + coords.leftSmallArcRadius) + " L " + (coords.leftFullExtent - offset) + " " + coords.verticalLeftInnerExtent;
+              if (isSourceBeforeTarget && isPathOverlapped) {
+                pathString += " A " + (coords.rightLargeArcRadius - offset) + " " + (coords.rightSmallArcRadius - offset) + " 0 0 1 " + (coords.leftFullExtent - offset - (coords.rightLargeArcRadius - offset)) + " " + (coords.verticalFullExtent - offset) + " L " + (coords.rightFullExtent + offset - arrowLen + (coords.rightLargeArcRadius - offset)) + " " + (coords.verticalFullExtent - offset) + " A " + (coords.rightLargeArcRadius - offset) + " " + (coords.rightSmallArcRadius - offset) + " 0 0 1 " + (coords.rightFullExtent + offset - arrowLen) + " " + coords.verticalRightInnerExtent;
+              } else if (isSourceBeforeTarget) {
+                pathString += " A " + (coords.rightLargeArcRadius + offset) + " " + (coords.rightLargeArcRadius + offset) + " 0 0 0 " + (coords.leftFullExtent + offset) + " " + (coords.verticalFullExtent + offset) + " L " + (coords.rightFullExtent - arrowLen - offset) + " " + (coords.verticalFullExtent + offset) + " A " + (coords.rightLargeArcRadius + offset) + " " + (coords.rightLargeArcRadius + offset) + " 0 0 0 " + (coords.rightFullExtent + offset - arrowLen) + " " + coords.verticalRightInnerExtent;
+              } else {
+                pathString += " A " + (coords.leftLargeArcRadius - offset) + " " + (coords.leftLargeArcRadius - offset) + " 0 0 1 " + coords.leftInnerExtent + " " + (coords.verticalFullExtent - offset) + " L " + (coords.rightInnerExtent - arrowLen) + " " + (coords.verticalFullExtent - offset) + " A " + (coords.rightLargeArcRadius - offset) + " " + (coords.rightLargeArcRadius - offset) + " 0 0 1 " + (coords.rightFullExtent + offset - arrowLen) + " " + coords.verticalRightInnerExtent;
+              }
+              pathString += " L " + (coords.rightFullExtent + offset - arrowLen) + " " + (coords.targetY + coords.rightSmallArcRadius) + " A " + (coords.rightLargeArcRadius - offset) + " " + (coords.rightSmallArcRadius - offset) + " 0 0 1 " + (coords.rightInnerExtent - arrowLen) + " " + (coords.targetY + offset) + " L " + (coords.targetX - arrowLen) + " " + (coords.targetY + offset) + (arrowLen > 0 ? " L " + coords.targetX + " " + coords.targetY : "") + "Z";
+            }
+            return pathString;
+          }
+          function linkPath() {
+            var curvature = 0.5;
+            function path(d2) {
+              var arrowLen = d2.linkArrowLength;
+              if (d2.link.circular) {
+                return createCircularClosedPathString(d2.link, arrowLen);
+              } else {
+                var maxArrowLength = Math.abs((d2.link.target.x0 - d2.link.source.x1) / 2);
+                if (arrowLen > maxArrowLength) {
+                  arrowLen = maxArrowLength;
+                }
+                var x0 = d2.link.source.x1;
+                var x1 = d2.link.target.x0 - arrowLen;
+                var xi2 = interpolateNumber(x0, x1);
+                var x2 = xi2(curvature);
+                var x3 = xi2(1 - curvature);
+                var y0a = d2.link.y0 - d2.link.width / 2;
+                var y0b = d2.link.y0 + d2.link.width / 2;
+                var y1a = d2.link.y1 - d2.link.width / 2;
+                var y1b = d2.link.y1 + d2.link.width / 2;
+                var start = "M" + x0 + "," + y0a;
+                var upperCurve = "C" + x2 + "," + y0a + " " + x3 + "," + y1a + " " + x1 + "," + y1a;
+                var lowerCurve = "C" + x3 + "," + y1b + " " + x2 + "," + y0b + " " + x0 + "," + y0b;
+                var rightEnd = arrowLen > 0 ? "L" + (x1 + arrowLen) + "," + (y1a + d2.link.width / 2) : "";
+                rightEnd += "L" + x1 + "," + y1b;
+                return start + upperCurve + rightEnd + lowerCurve + "Z";
+              }
+            }
+            return path;
+          }
+          function nodeModel(d2, n2) {
+            var tc2 = tinycolor(n2.color);
+            var zoneThicknessPad = c2.nodePadAcross;
+            var zoneLengthPad = d2.nodePad / 2;
+            n2.dx = n2.x1 - n2.x0;
+            n2.dy = n2.y1 - n2.y0;
+            var visibleThickness = n2.dx;
+            var visibleLength = Math.max(0.5, n2.dy);
+            var key = "node_" + n2.pointNumber;
+            if (n2.group) {
+              key = Lib.randstr();
+            }
+            n2.trace = d2.trace;
+            n2.curveNumber = d2.trace.index;
+            return {
+              index: n2.pointNumber,
+              key,
+              partOfGroup: n2.partOfGroup || false,
+              group: n2.group,
+              traceId: d2.key,
+              trace: d2.trace,
+              node: n2,
+              nodePad: d2.nodePad,
+              nodeLineColor: d2.nodeLineColor,
+              nodeLineWidth: d2.nodeLineWidth,
+              textFont: d2.textFont,
+              size: d2.horizontal ? d2.height : d2.width,
+              visibleWidth: Math.ceil(visibleThickness),
+              visibleHeight: visibleLength,
+              zoneX: -zoneThicknessPad,
+              zoneY: -zoneLengthPad,
+              zoneWidth: visibleThickness + 2 * zoneThicknessPad,
+              zoneHeight: visibleLength + 2 * zoneLengthPad,
+              labelY: d2.horizontal ? n2.dy / 2 + 1 : n2.dx / 2 + 1,
+              left: n2.originalLayer === 1,
+              sizeAcross: d2.width,
+              forceLayouts: d2.forceLayouts,
+              horizontal: d2.horizontal,
+              darkBackground: tc2.getBrightness() <= 128,
+              tinyColorHue: Color2.tinyRGB(tc2),
+              tinyColorAlpha: tc2.getAlpha(),
+              valueFormat: d2.valueFormat,
+              valueSuffix: d2.valueSuffix,
+              sankey: d2.sankey,
+              graph: d2.graph,
+              arrangement: d2.arrangement,
+              uniqueNodeLabelPathId: [d2.guid, d2.key, key].join("_"),
+              interactionState: d2.interactionState,
+              figure: d2
+            };
+          }
+          function updateNodePositions(sankeyNode) {
+            sankeyNode.attr("transform", function(d2) {
+              return strTranslate(d2.node.x0.toFixed(3), d2.node.y0.toFixed(3));
+            });
+          }
+          function updateNodeShapes(sankeyNode) {
+            sankeyNode.call(updateNodePositions);
+          }
+          function updateShapes(sankeyNode, sankeyLink) {
+            sankeyNode.call(updateNodeShapes);
+            sankeyLink.attr("d", linkPath());
+          }
+          function sizeNode(rect) {
+            rect.attr("width", function(d2) {
+              return d2.node.x1 - d2.node.x0;
+            }).attr("height", function(d2) {
+              return d2.visibleHeight;
+            });
+          }
+          function salientEnough(d2) {
+            return d2.link.width > 1 || d2.linkLineWidth > 0;
+          }
+          function sankeyTransform(d2) {
+            var offset = strTranslate(d2.translateX, d2.translateY);
+            return offset + (d2.horizontal ? "matrix(1 0 0 1 0 0)" : "matrix(0 1 1 0 0 0)");
+          }
+          function attachPointerEvents(selection, sankey, eventSet) {
+            selection.on(".basic", null).on("mouseover.basic", function(d2) {
+              if (!d2.interactionState.dragInProgress && !d2.partOfGroup) {
+                eventSet.hover(this, d2, sankey);
+                d2.interactionState.hovered = [this, d2];
+              }
+            }).on("mousemove.basic", function(d2) {
+              if (!d2.interactionState.dragInProgress && !d2.partOfGroup) {
+                eventSet.follow(this, d2);
+                d2.interactionState.hovered = [this, d2];
+              }
+            }).on("mouseout.basic", function(d2) {
+              if (!d2.interactionState.dragInProgress && !d2.partOfGroup) {
+                eventSet.unhover(this, d2, sankey);
+                d2.interactionState.hovered = false;
+              }
+            }).on("click.basic", function(d2) {
+              if (d2.interactionState.hovered) {
+                eventSet.unhover(this, d2, sankey);
+                d2.interactionState.hovered = false;
+              }
+              if (!d2.interactionState.dragInProgress && !d2.partOfGroup) {
+                eventSet.select(this, d2, sankey);
+              }
+            });
+          }
+          function attachDragHandler(sankeyNode, sankeyLink, callbacks, gd2) {
+            var dragBehavior = d3.behavior.drag().origin(function(d2) {
+              return {
+                x: d2.node.x0 + d2.visibleWidth / 2,
+                y: d2.node.y0 + d2.visibleHeight / 2
+              };
+            }).on("dragstart", function(d2) {
+              if (d2.arrangement === "fixed") return;
+              Lib.ensureSingle(gd2._fullLayout._infolayer, "g", "dragcover", function(s2) {
+                gd2._fullLayout._dragCover = s2;
+              });
+              Lib.raiseToTop(this);
+              d2.interactionState.dragInProgress = d2.node;
+              saveCurrentDragPosition(d2.node);
+              if (d2.interactionState.hovered) {
+                callbacks.nodeEvents.unhover.apply(0, d2.interactionState.hovered);
+                d2.interactionState.hovered = false;
+              }
+              if (d2.arrangement === "snap") {
+                var forceKey = d2.traceId + "|" + d2.key;
+                if (d2.forceLayouts[forceKey]) {
+                  d2.forceLayouts[forceKey].alpha(1);
+                } else {
+                  attachForce(sankeyNode, forceKey, d2);
+                }
+                startForce(sankeyNode, sankeyLink, d2, forceKey, gd2);
+              }
+            }).on("drag", function(d2) {
+              if (d2.arrangement === "fixed") return;
+              var x2 = d3.event.x;
+              var y2 = d3.event.y;
+              if (d2.arrangement === "snap") {
+                d2.node.x0 = x2 - d2.visibleWidth / 2;
+                d2.node.x1 = x2 + d2.visibleWidth / 2;
+                d2.node.y0 = y2 - d2.visibleHeight / 2;
+                d2.node.y1 = y2 + d2.visibleHeight / 2;
+              } else {
+                if (d2.arrangement === "freeform") {
+                  d2.node.x0 = x2 - d2.visibleWidth / 2;
+                  d2.node.x1 = x2 + d2.visibleWidth / 2;
+                }
+                y2 = Math.max(0, Math.min(d2.size - d2.visibleHeight / 2, y2));
+                d2.node.y0 = y2 - d2.visibleHeight / 2;
+                d2.node.y1 = y2 + d2.visibleHeight / 2;
+              }
+              saveCurrentDragPosition(d2.node);
+              if (d2.arrangement !== "snap") {
+                d2.sankey.update(d2.graph);
+                updateShapes(sankeyNode.filter(sameLayer(d2)), sankeyLink);
+              }
+            }).on("dragend", function(d2) {
+              if (d2.arrangement === "fixed") return;
+              d2.interactionState.dragInProgress = false;
+              for (var i2 = 0; i2 < d2.node.childrenNodes.length; i2++) {
+                d2.node.childrenNodes[i2].x = d2.node.x;
+                d2.node.childrenNodes[i2].y = d2.node.y;
+              }
+              if (d2.arrangement !== "snap") persistFinalNodePositions(d2, gd2);
+            });
+            sankeyNode.on(".drag", null).call(dragBehavior);
+          }
+          function attachForce(sankeyNode, forceKey, d2, gd2) {
+            switchToForceFormat(d2.graph.nodes);
+            var nodes = d2.graph.nodes.filter(function(n2) {
+              return n2.originalX === d2.node.originalX;
+            }).filter(function(n2) {
+              return !n2.partOfGroup;
+            });
+            d2.forceLayouts[forceKey] = d3Force.forceSimulation(nodes).alphaDecay(0).force("collide", d3Force.forceCollide().radius(function(n2) {
+              return n2.dy / 2 + d2.nodePad / 2;
+            }).strength(1).iterations(c2.forceIterations)).force("constrain", snappingForce(sankeyNode, forceKey, nodes, d2)).stop();
+          }
+          function startForce(sankeyNode, sankeyLink, d2, forceKey, gd2) {
+            window.requestAnimationFrame(function faster() {
+              var i2;
+              for (i2 = 0; i2 < c2.forceTicksPerFrame; i2++) {
+                d2.forceLayouts[forceKey].tick();
+              }
+              var nodes = d2.graph.nodes;
+              switchToSankeyFormat(nodes);
+              d2.sankey.update(d2.graph);
+              updateShapes(sankeyNode.filter(sameLayer(d2)), sankeyLink);
+              if (d2.forceLayouts[forceKey].alpha() > 0) {
+                window.requestAnimationFrame(faster);
+              } else {
+                var x2 = d2.node.originalX;
+                d2.node.x0 = x2 - d2.visibleWidth / 2;
+                d2.node.x1 = x2 + d2.visibleWidth / 2;
+                persistFinalNodePositions(d2, gd2);
+              }
+            });
+          }
+          function snappingForce(sankeyNode, forceKey, nodes, d2) {
+            return function _snappingForce() {
+              var maxVelocity = 0;
+              for (var i2 = 0; i2 < nodes.length; i2++) {
+                var n2 = nodes[i2];
+                if (n2 === d2.interactionState.dragInProgress) {
+                  n2.x = n2.lastDraggedX;
+                  n2.y = n2.lastDraggedY;
+                } else {
+                  n2.vx = (n2.originalX - n2.x) / c2.forceTicksPerFrame;
+                  n2.y = Math.min(d2.size - n2.dy / 2, Math.max(n2.dy / 2, n2.y));
+                }
+                maxVelocity = Math.max(maxVelocity, Math.abs(n2.vx), Math.abs(n2.vy));
+              }
+              if (!d2.interactionState.dragInProgress && maxVelocity < 0.1 && d2.forceLayouts[forceKey].alpha() > 0) {
+                d2.forceLayouts[forceKey].alpha(0);
+              }
+            };
+          }
+          function persistFinalNodePositions(d2, gd2) {
+            var x2 = [];
+            var y2 = [];
+            for (var i2 = 0; i2 < d2.graph.nodes.length; i2++) {
+              var nodeX = (d2.graph.nodes[i2].x0 + d2.graph.nodes[i2].x1) / 2;
+              var nodeY = (d2.graph.nodes[i2].y0 + d2.graph.nodes[i2].y1) / 2;
+              x2.push(nodeX / d2.figure.width);
+              y2.push(nodeY / d2.figure.height);
+            }
+            Registry.call("_guiRestyle", gd2, {
+              "node.x": [x2],
+              "node.y": [y2]
+            }, d2.trace.index).then(function() {
+              if (gd2._fullLayout._dragCover) gd2._fullLayout._dragCover.remove();
+            });
+          }
+          function persistOriginalPlace(nodes) {
+            var distinctLayerPositions = [];
+            var i2;
+            for (i2 = 0; i2 < nodes.length; i2++) {
+              nodes[i2].originalX = (nodes[i2].x0 + nodes[i2].x1) / 2;
+              nodes[i2].originalY = (nodes[i2].y0 + nodes[i2].y1) / 2;
+              if (distinctLayerPositions.indexOf(nodes[i2].originalX) === -1) {
+                distinctLayerPositions.push(nodes[i2].originalX);
+              }
+            }
+            distinctLayerPositions.sort(function(a2, b2) {
+              return a2 - b2;
+            });
+            for (i2 = 0; i2 < nodes.length; i2++) {
+              nodes[i2].originalLayerIndex = distinctLayerPositions.indexOf(nodes[i2].originalX);
+              nodes[i2].originalLayer = nodes[i2].originalLayerIndex / (distinctLayerPositions.length - 1);
+            }
+          }
+          function saveCurrentDragPosition(d2) {
+            d2.lastDraggedX = d2.x0 + d2.dx / 2;
+            d2.lastDraggedY = d2.y0 + d2.dy / 2;
+          }
+          function sameLayer(d2) {
+            return function(n2) {
+              return n2.node.originalX === d2.node.originalX;
+            };
+          }
+          function switchToForceFormat(nodes) {
+            for (var i2 = 0; i2 < nodes.length; i2++) {
+              nodes[i2].y = (nodes[i2].y0 + nodes[i2].y1) / 2;
+              nodes[i2].x = (nodes[i2].x0 + nodes[i2].x1) / 2;
+            }
+          }
+          function switchToSankeyFormat(nodes) {
+            for (var i2 = 0; i2 < nodes.length; i2++) {
+              nodes[i2].y0 = nodes[i2].y - nodes[i2].dy / 2;
+              nodes[i2].y1 = nodes[i2].y0 + nodes[i2].dy;
+              nodes[i2].x0 = nodes[i2].x - nodes[i2].dx / 2;
+              nodes[i2].x1 = nodes[i2].x0 + nodes[i2].dx;
+            }
+          }
+          module2.exports = function(gd2, svg, calcData, layout, callbacks) {
+            var isStatic = gd2._context.staticPlot;
+            var firstRender = false;
+            Lib.ensureSingle(gd2._fullLayout._infolayer, "g", "first-render", function() {
+              firstRender = true;
+            });
+            var dragcover = gd2._fullLayout._dragCover;
+            var styledData = calcData.filter(function(d2) {
+              return unwrap(d2).trace.visible;
+            }).map(sankeyModel.bind(null, layout));
+            var sankey = svg.selectAll("." + c2.cn.sankey).data(styledData, keyFun);
+            sankey.exit().remove();
+            sankey.enter().append("g").classed(c2.cn.sankey, true).style("box-sizing", "content-box").style("position", "absolute").style("left", 0).style("shape-rendering", "geometricPrecision").style("pointer-events", isStatic ? "none" : "auto").attr("transform", sankeyTransform);
+            sankey.each(function(d2, i2) {
+              gd2._fullData[i2]._sankey = d2;
+              var dragboxClassName = "bgsankey-" + d2.trace.uid + "-" + i2;
+              Lib.ensureSingle(gd2._fullLayout._draggers, "rect", dragboxClassName);
+              gd2._fullData[i2]._bgRect = d3.select("." + dragboxClassName);
+              gd2._fullData[i2]._bgRect.style("pointer-events", isStatic ? "none" : "all").attr("width", d2.width).attr("height", d2.height).attr("x", d2.translateX).attr("y", d2.translateY).classed("bgsankey", true).style({ fill: "transparent", "stroke-width": 0 });
+            });
+            sankey.transition().ease(c2.ease).duration(c2.duration).attr("transform", sankeyTransform);
+            var sankeyLinks = sankey.selectAll("." + c2.cn.sankeyLinks).data(repeat, keyFun);
+            sankeyLinks.enter().append("g").classed(c2.cn.sankeyLinks, true).style("fill", "none");
+            var sankeyLink = sankeyLinks.selectAll("." + c2.cn.sankeyLink).data(function(d2) {
+              var links = d2.graph.links;
+              return links.filter(function(l2) {
+                return l2.value;
+              }).map(linkModel.bind(null, d2));
+            }, keyFun);
+            sankeyLink.enter().append("path").classed(c2.cn.sankeyLink, true).call(attachPointerEvents, sankey, callbacks.linkEvents);
+            sankeyLink.style("stroke", function(d2) {
+              return salientEnough(d2) ? Color2.tinyRGB(tinycolor(d2.linkLineColor)) : d2.tinyColorHue;
+            }).style("stroke-opacity", function(d2) {
+              return salientEnough(d2) ? Color2.opacity(d2.linkLineColor) : d2.tinyColorAlpha;
+            }).style("fill", function(d2) {
+              return d2.tinyColorHue;
+            }).style("fill-opacity", function(d2) {
+              return d2.tinyColorAlpha;
+            }).style("stroke-width", function(d2) {
+              return salientEnough(d2) ? d2.linkLineWidth : 1;
+            }).attr("d", linkPath());
+            sankeyLink.style("opacity", function() {
+              return gd2._context.staticPlot || firstRender || dragcover ? 1 : 0;
+            }).transition().ease(c2.ease).duration(c2.duration).style("opacity", 1);
+            sankeyLink.exit().transition().ease(c2.ease).duration(c2.duration).style("opacity", 0).remove();
+            var sankeyNodeSet = sankey.selectAll("." + c2.cn.sankeyNodeSet).data(repeat, keyFun);
+            sankeyNodeSet.enter().append("g").classed(c2.cn.sankeyNodeSet, true);
+            sankeyNodeSet.style("cursor", function(d2) {
+              switch (d2.arrangement) {
+                case "fixed":
+                  return "default";
+                case "perpendicular":
+                  return "ns-resize";
+                default:
+                  return "move";
+              }
+            });
+            var sankeyNode = sankeyNodeSet.selectAll("." + c2.cn.sankeyNode).data(function(d2) {
+              var nodes = d2.graph.nodes;
+              persistOriginalPlace(nodes);
+              return nodes.map(nodeModel.bind(null, d2));
+            }, keyFun);
+            sankeyNode.enter().append("g").classed(c2.cn.sankeyNode, true).call(updateNodePositions).style("opacity", function(n2) {
+              return (gd2._context.staticPlot || firstRender) && !n2.partOfGroup ? 1 : 0;
+            });
+            sankeyNode.call(attachPointerEvents, sankey, callbacks.nodeEvents).call(attachDragHandler, sankeyLink, callbacks, gd2);
+            sankeyNode.transition().ease(c2.ease).duration(c2.duration).call(updateNodePositions).style("opacity", function(n2) {
+              return n2.partOfGroup ? 0 : 1;
+            });
+            sankeyNode.exit().transition().ease(c2.ease).duration(c2.duration).style("opacity", 0).remove();
+            var nodeRect = sankeyNode.selectAll("." + c2.cn.nodeRect).data(repeat);
+            nodeRect.enter().append("rect").classed(c2.cn.nodeRect, true).call(sizeNode);
+            nodeRect.style("stroke-width", function(d2) {
+              return d2.nodeLineWidth;
+            }).style("stroke", function(d2) {
+              return Color2.tinyRGB(tinycolor(d2.nodeLineColor));
+            }).style("stroke-opacity", function(d2) {
+              return Color2.opacity(d2.nodeLineColor);
+            }).style("fill", function(d2) {
+              return d2.tinyColorHue;
+            }).style("fill-opacity", function(d2) {
+              return d2.tinyColorAlpha;
+            });
+            nodeRect.transition().ease(c2.ease).duration(c2.duration).call(sizeNode);
+            var nodeLabel = sankeyNode.selectAll("." + c2.cn.nodeLabel).data(repeat);
+            nodeLabel.enter().append("text").classed(c2.cn.nodeLabel, true).style("cursor", "default");
+            nodeLabel.attr("data-notex", 1).text(function(d2) {
+              return d2.node.label;
+            }).each(function(d2) {
+              var e2 = d3.select(this);
+              Drawing.font(e2, d2.textFont);
+              svgTextUtils.convertToTspans(e2, gd2);
+            }).attr("text-anchor", function(d2) {
+              return d2.horizontal && d2.left ? "end" : "start";
+            }).attr("transform", function(d2) {
+              var e2 = d3.select(this);
+              var nLines = svgTextUtils.lineCount(e2);
+              var blockHeight = d2.textFont.size * ((nLines - 1) * LINE_SPACING - CAP_SHIFT);
+              var posX = d2.nodeLineWidth / 2 + TEXTPAD;
+              var posY = ((d2.horizontal ? d2.visibleHeight : d2.visibleWidth) - blockHeight) / 2;
+              if (d2.horizontal) {
+                if (d2.left) {
+                  posX = -posX;
+                } else {
+                  posX += d2.visibleWidth;
+                }
+              }
+              var flipText = d2.horizontal ? "" : "scale(-1,1)" + strRotate(90);
+              return strTranslate(
+                d2.horizontal ? posX : posY,
+                d2.horizontal ? posY : posX
+              ) + flipText;
+            });
+            nodeLabel.transition().ease(c2.ease).duration(c2.duration);
+          };
+        }
+      });
+      var require_plot29 = __commonJS({
+        "src/traces/sankey/plot.js"(exports, module2) {
+          var d3 = require_d3();
+          var Lib = require_lib();
+          var numberFormat = Lib.numberFormat;
+          var render = require_render();
+          var Fx = require_fx();
+          var Color2 = require_color();
+          var cn = require_constants29().cn;
+          var _2 = Lib._;
+          function renderableValuePresent(d2) {
+            return d2 !== "";
+          }
+          function ownTrace(selection, d2) {
+            return selection.filter(function(s2) {
+              return s2.key === d2.traceId;
+            });
+          }
+          function makeTranslucent(element, alpha) {
+            d3.select(element).select("path").style("fill-opacity", alpha);
+            d3.select(element).select("rect").style("fill-opacity", alpha);
+          }
+          function makeTextContrasty(element) {
+            d3.select(element).select("text.name").style("fill", "black");
+          }
+          function relatedLinks(d2) {
+            return function(l2) {
+              return d2.node.sourceLinks.indexOf(l2.link) !== -1 || d2.node.targetLinks.indexOf(l2.link) !== -1;
+            };
+          }
+          function relatedNodes(l2) {
+            return function(d2) {
+              return d2.node.sourceLinks.indexOf(l2.link) !== -1 || d2.node.targetLinks.indexOf(l2.link) !== -1;
+            };
+          }
+          function nodeHoveredStyle(sankeyNode, d2, sankey) {
+            if (d2 && sankey) {
+              ownTrace(sankey, d2).selectAll("." + cn.sankeyLink).filter(relatedLinks(d2)).call(linkHoveredStyle.bind(0, d2, sankey, false));
+            }
+          }
+          function nodeNonHoveredStyle(sankeyNode, d2, sankey) {
+            if (d2 && sankey) {
+              ownTrace(sankey, d2).selectAll("." + cn.sankeyLink).filter(relatedLinks(d2)).call(linkNonHoveredStyle.bind(0, d2, sankey, false));
+            }
+          }
+          function linkHoveredStyle(d2, sankey, visitNodes, sankeyLink) {
+            sankeyLink.style("fill", function(l2) {
+              if (!l2.link.concentrationscale) {
+                return l2.tinyColorHoverHue;
+              }
+            }).style("fill-opacity", function(l2) {
+              if (!l2.link.concentrationscale) {
+                return l2.tinyColorHoverAlpha;
+              }
+            });
+            sankeyLink.each(function(curLink) {
+              var label = curLink.link.label;
+              if (label !== "") {
+                ownTrace(sankey, d2).selectAll("." + cn.sankeyLink).filter(function(l2) {
+                  return l2.link.label === label;
+                }).style("fill", function(l2) {
+                  if (!l2.link.concentrationscale) {
+                    return l2.tinyColorHoverHue;
+                  }
+                }).style("fill-opacity", function(l2) {
+                  if (!l2.link.concentrationscale) {
+                    return l2.tinyColorHoverAlpha;
+                  }
+                });
+              }
+            });
+            if (visitNodes) {
+              ownTrace(sankey, d2).selectAll("." + cn.sankeyNode).filter(relatedNodes(d2)).call(nodeHoveredStyle);
+            }
+          }
+          function linkNonHoveredStyle(d2, sankey, visitNodes, sankeyLink) {
+            sankeyLink.style("fill", function(l2) {
+              return l2.tinyColorHue;
+            }).style("fill-opacity", function(l2) {
+              return l2.tinyColorAlpha;
+            });
+            sankeyLink.each(function(curLink) {
+              var label = curLink.link.label;
+              if (label !== "") {
+                ownTrace(sankey, d2).selectAll("." + cn.sankeyLink).filter(function(l2) {
+                  return l2.link.label === label;
+                }).style("fill", function(l2) {
+                  return l2.tinyColorHue;
+                }).style("fill-opacity", function(l2) {
+                  return l2.tinyColorAlpha;
+                });
+              }
+            });
+            if (visitNodes) {
+              ownTrace(sankey, d2).selectAll(cn.sankeyNode).filter(relatedNodes(d2)).call(nodeNonHoveredStyle);
+            }
+          }
+          function castHoverOption(trace, attr) {
+            var labelOpts = trace.hoverlabel || {};
+            var val = Lib.nestedProperty(labelOpts, attr).get();
+            return Array.isArray(val) ? false : val;
+          }
+          module2.exports = function plot(gd2, calcData) {
+            var fullLayout = gd2._fullLayout;
+            var svg = fullLayout._paper;
+            var size = fullLayout._size;
+            for (var i2 = 0; i2 < gd2._fullData.length; i2++) {
+              if (!gd2._fullData[i2].visible) continue;
+              if (gd2._fullData[i2].type !== cn.sankey) continue;
+              if (!gd2._fullData[i2]._viewInitial) {
+                var node = gd2._fullData[i2].node;
+                gd2._fullData[i2]._viewInitial = {
+                  node: {
+                    groups: node.groups.slice(),
+                    x: node.x.slice(),
+                    y: node.y.slice()
+                  }
+                };
+              }
+            }
+            var linkSelect = function(element, d2) {
+              var evt = d2.link;
+              evt.originalEvent = d3.event;
+              gd2._hoverdata = [evt];
+              Fx.click(gd2, { target: true });
+            };
+            var linkHover = function(element, d2, sankey) {
+              if (gd2._fullLayout.hovermode === false) return;
+              d3.select(element).call(linkHoveredStyle.bind(0, d2, sankey, true));
+              if (d2.link.trace.link.hoverinfo !== "skip") {
+                d2.link.fullData = d2.link.trace;
+                gd2.emit("plotly_hover", {
+                  event: d3.event,
+                  points: [d2.link]
+                });
+              }
+            };
+            var sourceLabel = _2(gd2, "source:") + " ";
+            var targetLabel = _2(gd2, "target:") + " ";
+            var concentrationLabel = _2(gd2, "concentration:") + " ";
+            var incomingLabel = _2(gd2, "incoming flow count:") + " ";
+            var outgoingLabel = _2(gd2, "outgoing flow count:") + " ";
+            var linkHoverFollow = function(element, d2) {
+              if (gd2._fullLayout.hovermode === false) return;
+              var obj = d2.link.trace.link;
+              if (obj.hoverinfo === "none" || obj.hoverinfo === "skip") return;
+              var hoverItems = [];
+              function hoverCenterPosition(link2) {
+                var hoverCenterX, hoverCenterY;
+                if (link2.circular) {
+                  hoverCenterX = (link2.circularPathData.leftInnerExtent + link2.circularPathData.rightInnerExtent) / 2;
+                  hoverCenterY = link2.circularPathData.verticalFullExtent;
+                } else {
+                  hoverCenterX = (link2.source.x1 + link2.target.x0) / 2;
+                  hoverCenterY = (link2.y0 + link2.y1) / 2;
+                }
+                var center = [hoverCenterX, hoverCenterY];
+                if (link2.trace.orientation === "v") center.reverse();
+                center[0] += d2.parent.translateX;
+                center[1] += d2.parent.translateY;
+                return center;
+              }
+              var anchorIndex = 0;
+              for (var i22 = 0; i22 < d2.flow.links.length; i22++) {
+                var link = d2.flow.links[i22];
+                if (gd2._fullLayout.hovermode === "closest" && d2.link.pointNumber !== link.pointNumber) continue;
+                if (d2.link.pointNumber === link.pointNumber) anchorIndex = i22;
+                link.fullData = link.trace;
+                obj = d2.link.trace.link;
+                var hoverCenter = hoverCenterPosition(link);
+                var hovertemplateLabels = { valueLabel: numberFormat(d2.valueFormat)(link.value) + d2.valueSuffix };
+                hoverItems.push({
+                  x: hoverCenter[0],
+                  y: hoverCenter[1],
+                  name: hovertemplateLabels.valueLabel,
+                  text: [
+                    link.label || "",
+                    sourceLabel + link.source.label,
+                    targetLabel + link.target.label,
+                    link.concentrationscale ? concentrationLabel + numberFormat("%0.2f")(link.flow.labelConcentration) : ""
+                  ].filter(renderableValuePresent).join("<br>"),
+                  color: castHoverOption(obj, "bgcolor") || Color2.addOpacity(link.color, 1),
+                  borderColor: castHoverOption(obj, "bordercolor"),
+                  fontFamily: castHoverOption(obj, "font.family"),
+                  fontSize: castHoverOption(obj, "font.size"),
+                  fontColor: castHoverOption(obj, "font.color"),
+                  fontWeight: castHoverOption(obj, "font.weight"),
+                  fontStyle: castHoverOption(obj, "font.style"),
+                  fontVariant: castHoverOption(obj, "font.variant"),
+                  fontTextcase: castHoverOption(obj, "font.textcase"),
+                  fontLineposition: castHoverOption(obj, "font.lineposition"),
+                  fontShadow: castHoverOption(obj, "font.shadow"),
+                  nameLength: castHoverOption(obj, "namelength"),
+                  textAlign: castHoverOption(obj, "align"),
+                  idealAlign: d3.event.x < hoverCenter[0] ? "right" : "left",
+                  hovertemplate: obj.hovertemplate,
+                  hovertemplateLabels,
+                  eventData: [link]
+                });
+              }
+              var tooltips = Fx.loneHover(hoverItems, {
+                container: fullLayout._hoverlayer.node(),
+                outerContainer: fullLayout._paper.node(),
+                gd: gd2,
+                anchorIndex
+              });
+              tooltips.each(function() {
+                var tooltip = this;
+                if (!d2.link.concentrationscale) {
+                  makeTranslucent(tooltip, 0.65);
+                }
+                makeTextContrasty(tooltip);
+              });
+            };
+            var linkUnhover = function(element, d2, sankey) {
+              if (gd2._fullLayout.hovermode === false) return;
+              d3.select(element).call(linkNonHoveredStyle.bind(0, d2, sankey, true));
+              if (d2.link.trace.link.hoverinfo !== "skip") {
+                d2.link.fullData = d2.link.trace;
+                gd2.emit("plotly_unhover", {
+                  event: d3.event,
+                  points: [d2.link]
+                });
+              }
+              Fx.loneUnhover(fullLayout._hoverlayer.node());
+            };
+            var nodeSelect = function(element, d2, sankey) {
+              var evt = d2.node;
+              evt.originalEvent = d3.event;
+              gd2._hoverdata = [evt];
+              d3.select(element).call(nodeNonHoveredStyle, d2, sankey);
+              Fx.click(gd2, { target: true });
+            };
+            var nodeHover = function(element, d2, sankey) {
+              if (gd2._fullLayout.hovermode === false) return;
+              d3.select(element).call(nodeHoveredStyle, d2, sankey);
+              if (d2.node.trace.node.hoverinfo !== "skip") {
+                d2.node.fullData = d2.node.trace;
+                gd2.emit("plotly_hover", {
+                  event: d3.event,
+                  points: [d2.node]
+                });
+              }
+            };
+            var nodeHoverFollow = function(element, d2) {
+              if (gd2._fullLayout.hovermode === false) return;
+              var obj = d2.node.trace.node;
+              if (obj.hoverinfo === "none" || obj.hoverinfo === "skip") return;
+              var nodeRect = d3.select(element).select("." + cn.nodeRect);
+              var rootBBox = gd2._fullLayout._paperdiv.node().getBoundingClientRect();
+              var boundingBox = nodeRect.node().getBoundingClientRect();
+              var hoverCenterX0 = boundingBox.left - 2 - rootBBox.left;
+              var hoverCenterX1 = boundingBox.right + 2 - rootBBox.left;
+              var hoverCenterY = boundingBox.top + boundingBox.height / 4 - rootBBox.top;
+              var hovertemplateLabels = { valueLabel: numberFormat(d2.valueFormat)(d2.node.value) + d2.valueSuffix };
+              d2.node.fullData = d2.node.trace;
+              gd2._fullLayout._calcInverseTransform(gd2);
+              var scaleX2 = gd2._fullLayout._invScaleX;
+              var scaleY2 = gd2._fullLayout._invScaleY;
+              var tooltip = Fx.loneHover({
+                x0: scaleX2 * hoverCenterX0,
+                x1: scaleX2 * hoverCenterX1,
+                y: scaleY2 * hoverCenterY,
+                name: numberFormat(d2.valueFormat)(d2.node.value) + d2.valueSuffix,
+                text: [
+                  d2.node.label,
+                  incomingLabel + d2.node.targetLinks.length,
+                  outgoingLabel + d2.node.sourceLinks.length
+                ].filter(renderableValuePresent).join("<br>"),
+                color: castHoverOption(obj, "bgcolor") || d2.tinyColorHue,
+                borderColor: castHoverOption(obj, "bordercolor"),
+                fontFamily: castHoverOption(obj, "font.family"),
+                fontSize: castHoverOption(obj, "font.size"),
+                fontColor: castHoverOption(obj, "font.color"),
+                fontWeight: castHoverOption(obj, "font.weight"),
+                fontStyle: castHoverOption(obj, "font.style"),
+                fontVariant: castHoverOption(obj, "font.variant"),
+                fontTextcase: castHoverOption(obj, "font.textcase"),
+                fontLineposition: castHoverOption(obj, "font.lineposition"),
+                fontShadow: castHoverOption(obj, "font.shadow"),
+                nameLength: castHoverOption(obj, "namelength"),
+                textAlign: castHoverOption(obj, "align"),
+                idealAlign: "left",
+                hovertemplate: obj.hovertemplate,
+                hovertemplateLabels,
+                eventData: [d2.node]
+              }, {
+                container: fullLayout._hoverlayer.node(),
+                outerContainer: fullLayout._paper.node(),
+                gd: gd2
+              });
+              makeTranslucent(tooltip, 0.85);
+              makeTextContrasty(tooltip);
+            };
+            var nodeUnhover = function(element, d2, sankey) {
+              if (gd2._fullLayout.hovermode === false) return;
+              d3.select(element).call(nodeNonHoveredStyle, d2, sankey);
+              if (d2.node.trace.node.hoverinfo !== "skip") {
+                d2.node.fullData = d2.node.trace;
+                gd2.emit("plotly_unhover", {
+                  event: d3.event,
+                  points: [d2.node]
+                });
+              }
+              Fx.loneUnhover(fullLayout._hoverlayer.node());
+            };
+            render(
+              gd2,
+              svg,
+              calcData,
+              {
+                width: size.w,
+                height: size.h,
+                margin: {
+                  t: size.t,
+                  r: size.r,
+                  b: size.b,
+                  l: size.l
+                }
+              },
+              {
+                linkEvents: {
+                  hover: linkHover,
+                  follow: linkHoverFollow,
+                  unhover: linkUnhover,
+                  select: linkSelect
+                },
+                nodeEvents: {
+                  hover: nodeHover,
+                  follow: nodeHoverFollow,
+                  unhover: nodeUnhover,
+                  select: nodeSelect
+                }
+              }
+            );
+          };
+        }
+      });
+      var require_base_plot9 = __commonJS({
+        "src/traces/sankey/base_plot.js"(exports) {
+          var overrideAll = require_edit_types().overrideAll;
+          var getModuleCalcData = require_get_data().getModuleCalcData;
+          var plot = require_plot29();
+          var fxAttrs = require_layout_attributes();
+          var setCursor = require_setcursor();
+          var dragElement = require_dragelement();
+          var prepSelect = require_selections().prepSelect;
+          var Lib = require_lib();
+          var Registry = require_registry();
+          var SANKEY = "sankey";
+          exports.name = SANKEY;
+          exports.baseLayoutAttrOverrides = overrideAll({
+            hoverlabel: fxAttrs.hoverlabel
+          }, "plot", "nested");
+          exports.plot = function(gd2) {
+            var calcData = getModuleCalcData(gd2.calcdata, SANKEY)[0];
+            plot(gd2, calcData);
+            exports.updateFx(gd2);
+          };
+          exports.clean = function(newFullData, newFullLayout, oldFullData, oldFullLayout) {
+            var hadPlot = oldFullLayout._has && oldFullLayout._has(SANKEY);
+            var hasPlot = newFullLayout._has && newFullLayout._has(SANKEY);
+            if (hadPlot && !hasPlot) {
+              oldFullLayout._paperdiv.selectAll(".sankey").remove();
+              oldFullLayout._paperdiv.selectAll(".bgsankey").remove();
+            }
+          };
+          exports.updateFx = function(gd2) {
+            for (var i2 = 0; i2 < gd2._fullData.length; i2++) {
+              subplotUpdateFx(gd2, i2);
+            }
+          };
+          function subplotUpdateFx(gd2, index) {
+            var trace = gd2._fullData[index];
+            var fullLayout = gd2._fullLayout;
+            var dragMode = fullLayout.dragmode;
+            var cursor = fullLayout.dragmode === "pan" ? "move" : "crosshair";
+            var bgRect = trace._bgRect;
+            if (!bgRect) return;
+            if (dragMode === "pan" || dragMode === "zoom") return;
+            setCursor(bgRect, cursor);
+            var xaxis = {
+              _id: "x",
+              c2p: Lib.identity,
+              _offset: trace._sankey.translateX,
+              _length: trace._sankey.width
+            };
+            var yaxis = {
+              _id: "y",
+              c2p: Lib.identity,
+              _offset: trace._sankey.translateY,
+              _length: trace._sankey.height
+            };
+            var dragOptions = {
+              gd: gd2,
+              element: bgRect.node(),
+              plotinfo: {
+                id: index,
+                xaxis,
+                yaxis,
+                fillRangeItems: Lib.noop
+              },
+              subplot: index,
+              // create mock x/y axes for hover routine
+              xaxes: [xaxis],
+              yaxes: [yaxis],
+              doneFnCompleted: function(selection) {
+                var traceNow = gd2._fullData[index];
+                var newGroups;
+                var oldGroups = traceNow.node.groups.slice();
+                var newGroup = [];
+                function findNode(pt2) {
+                  var nodes = traceNow._sankey.graph.nodes;
+                  for (var i2 = 0; i2 < nodes.length; i2++) {
+                    if (nodes[i2].pointNumber === pt2) return nodes[i2];
+                  }
+                }
+                for (var j2 = 0; j2 < selection.length; j2++) {
+                  var node = findNode(selection[j2].pointNumber);
+                  if (!node) continue;
+                  if (node.group) {
+                    for (var k2 = 0; k2 < node.childrenNodes.length; k2++) {
+                      newGroup.push(node.childrenNodes[k2].pointNumber);
+                    }
+                    oldGroups[node.pointNumber - traceNow.node._count] = false;
+                  } else {
+                    newGroup.push(node.pointNumber);
+                  }
+                }
+                newGroups = oldGroups.filter(Boolean).concat([newGroup]);
+                Registry.call("_guiRestyle", gd2, {
+                  "node.groups": [newGroups]
+                }, index);
+              }
+            };
+            dragOptions.prepFn = function(e2, startX, startY) {
+              prepSelect(e2, startX, startY, dragOptions, dragMode);
+            };
+            dragElement.init(dragOptions);
+          }
+        }
+      });
+      var require_select11 = __commonJS({
+        "src/traces/sankey/select.js"(exports, module2) {
+          module2.exports = function selectPoints(searchInfo, selectionTester) {
+            var cd2 = searchInfo.cd;
+            var selection = [];
+            var fullData = cd2[0].trace;
+            var nodes = fullData._sankey.graph.nodes;
+            for (var i2 = 0; i2 < nodes.length; i2++) {
+              var node = nodes[i2];
+              if (node.partOfGroup) continue;
+              var pos = [(node.x0 + node.x1) / 2, (node.y0 + node.y1) / 2];
+              if (fullData.orientation === "v") pos.reverse();
+              if (selectionTester && selectionTester.contains(pos, false, i2, searchInfo)) {
+                selection.push({
+                  pointNumber: node.pointNumber
+                  // TODO: add eventData
+                });
+              }
+            }
+            return selection;
+          };
+        }
+      });
+      var require_sankey = __commonJS({
+        "src/traces/sankey/index.js"(exports, module2) {
+          module2.exports = {
+            attributes: require_attributes60(),
+            supplyDefaults: require_defaults56(),
+            calc: require_calc35(),
+            plot: require_plot29(),
+            moduleType: "trace",
+            name: "sankey",
+            basePlotModule: require_base_plot9(),
+            selectPoints: require_select11(),
+            categories: ["noOpacity"],
+            meta: {}
+          };
+        }
+      });
+      var require_sankey2 = __commonJS({
+        "lib/sankey.js"(exports, module2) {
+          module2.exports = require_sankey();
+        }
+      });
+      var require_base_plot10 = __commonJS({
+        "src/traces/indicator/base_plot.js"(exports) {
+          var plots = require_plots();
+          exports.name = "indicator";
+          exports.plot = function(gd2, traces, transitionOpts, makeOnCompleteCallback) {
+            plots.plotBasePlot(exports.name, gd2, traces, transitionOpts, makeOnCompleteCallback);
+          };
+          exports.clean = function(newFullData, newFullLayout, oldFullData, oldFullLayout) {
+            plots.cleanBasePlot(exports.name, newFullData, newFullLayout, oldFullData, oldFullLayout);
+          };
+        }
+      });
+      var require_attributes61 = __commonJS({
+        "src/traces/indicator/attributes.js"(exports, module2) {
+          var extendFlat = require_extend().extendFlat;
+          var extendDeep = require_extend().extendDeep;
+          var overrideAll = require_edit_types().overrideAll;
+          var fontAttrs = require_font_attributes();
+          var colorAttrs = require_attributes3();
+          var domainAttrs = require_domain().attributes;
+          var axesAttrs = require_layout_attributes4();
+          var templatedArray = require_plot_template().templatedArray;
+          var delta = require_delta();
+          var descriptionOnlyNumbers = require_axis_format_attributes().descriptionOnlyNumbers;
+          var textFontAttrs = fontAttrs({
+            editType: "plot",
+            colorEditType: "plot"
+          });
+          var gaugeBarAttrs = {
+            color: {
+              valType: "color",
+              editType: "plot"
+            },
+            line: {
+              color: {
+                valType: "color",
+                dflt: colorAttrs.defaultLine,
+                editType: "plot"
+              },
+              width: {
+                valType: "number",
+                min: 0,
+                dflt: 0,
+                editType: "plot"
+              },
+              editType: "calc"
+            },
+            thickness: {
+              valType: "number",
+              min: 0,
+              max: 1,
+              dflt: 1,
+              editType: "plot"
+            },
+            editType: "calc"
+          };
+          var rangeAttr = {
+            valType: "info_array",
+            items: [
+              { valType: "number", editType: "plot" },
+              { valType: "number", editType: "plot" }
+            ],
+            editType: "plot"
+          };
+          var stepsAttrs = templatedArray("step", extendDeep({}, gaugeBarAttrs, {
+            range: rangeAttr
+          }));
+          module2.exports = {
+            mode: {
+              valType: "flaglist",
+              editType: "calc",
+              flags: ["number", "delta", "gauge"],
+              dflt: "number"
+            },
+            value: {
+              valType: "number",
+              editType: "calc",
+              anim: true
+            },
+            align: {
+              valType: "enumerated",
+              values: ["left", "center", "right"],
+              editType: "plot"
+            },
+            // position
+            domain: domainAttrs({ name: "indicator", trace: true, editType: "calc" }),
+            title: {
+              text: {
+                valType: "string",
+                editType: "plot"
+              },
+              align: {
+                valType: "enumerated",
+                values: ["left", "center", "right"],
+                editType: "plot"
+              },
+              font: extendFlat({}, textFontAttrs, {}),
+              editType: "plot"
+            },
+            number: {
+              valueformat: {
+                valType: "string",
+                dflt: "",
+                editType: "plot",
+                description: descriptionOnlyNumbers("value")
+              },
+              font: extendFlat({}, textFontAttrs, {}),
+              prefix: {
+                valType: "string",
+                dflt: "",
+                editType: "plot"
+              },
+              suffix: {
+                valType: "string",
+                dflt: "",
+                editType: "plot"
+              },
+              editType: "plot"
+            },
+            delta: {
+              reference: {
+                valType: "number",
+                editType: "calc"
+              },
+              position: {
+                valType: "enumerated",
+                values: ["top", "bottom", "left", "right"],
+                dflt: "bottom",
+                editType: "plot"
+              },
+              relative: {
+                valType: "boolean",
+                editType: "plot",
+                dflt: false
+              },
+              valueformat: {
+                valType: "string",
+                editType: "plot",
+                description: descriptionOnlyNumbers("value")
+              },
+              increasing: {
+                symbol: {
+                  valType: "string",
+                  dflt: delta.INCREASING.SYMBOL,
+                  editType: "plot"
+                },
+                color: {
+                  valType: "color",
+                  dflt: delta.INCREASING.COLOR,
+                  editType: "plot"
+                },
+                // TODO: add attribute to show sign
+                editType: "plot"
+              },
+              decreasing: {
+                symbol: {
+                  valType: "string",
+                  dflt: delta.DECREASING.SYMBOL,
+                  editType: "plot"
+                },
+                color: {
+                  valType: "color",
+                  dflt: delta.DECREASING.COLOR,
+                  editType: "plot"
+                },
+                // TODO: add attribute to hide sign
+                editType: "plot"
+              },
+              font: extendFlat({}, textFontAttrs, {}),
+              prefix: {
+                valType: "string",
+                dflt: "",
+                editType: "plot"
+              },
+              suffix: {
+                valType: "string",
+                dflt: "",
+                editType: "plot"
+              },
+              editType: "calc"
+            },
+            gauge: {
+              shape: {
+                valType: "enumerated",
+                editType: "plot",
+                dflt: "angular",
+                values: ["angular", "bullet"]
+              },
+              bar: extendDeep({}, gaugeBarAttrs, {
+                color: { dflt: "green" }
+              }),
+              // Background of the gauge
+              bgcolor: {
+                valType: "color",
+                editType: "plot"
+              },
+              bordercolor: {
+                valType: "color",
+                dflt: colorAttrs.defaultLine,
+                editType: "plot"
+              },
+              borderwidth: {
+                valType: "number",
+                min: 0,
+                dflt: 1,
+                editType: "plot"
+              },
+              axis: overrideAll({
+                range: rangeAttr,
+                visible: extendFlat({}, axesAttrs.visible, {
+                  dflt: true
+                }),
+                // tick and title properties named and function exactly as in axes
+                tickmode: axesAttrs.minor.tickmode,
+                nticks: axesAttrs.nticks,
+                tick0: axesAttrs.tick0,
+                dtick: axesAttrs.dtick,
+                tickvals: axesAttrs.tickvals,
+                ticktext: axesAttrs.ticktext,
+                ticks: extendFlat({}, axesAttrs.ticks, { dflt: "outside" }),
+                ticklen: axesAttrs.ticklen,
+                tickwidth: axesAttrs.tickwidth,
+                tickcolor: axesAttrs.tickcolor,
+                ticklabelstep: axesAttrs.ticklabelstep,
+                showticklabels: axesAttrs.showticklabels,
+                labelalias: axesAttrs.labelalias,
+                tickfont: fontAttrs({}),
+                tickangle: axesAttrs.tickangle,
+                tickformat: axesAttrs.tickformat,
+                tickformatstops: axesAttrs.tickformatstops,
+                tickprefix: axesAttrs.tickprefix,
+                showtickprefix: axesAttrs.showtickprefix,
+                ticksuffix: axesAttrs.ticksuffix,
+                showticksuffix: axesAttrs.showticksuffix,
+                separatethousands: axesAttrs.separatethousands,
+                exponentformat: axesAttrs.exponentformat,
+                minexponent: axesAttrs.minexponent,
+                showexponent: axesAttrs.showexponent,
+                editType: "plot"
+              }, "plot"),
+              // Steps (or ranges) and thresholds
+              steps: stepsAttrs,
+              threshold: {
+                line: {
+                  color: extendFlat({}, gaugeBarAttrs.line.color, {}),
+                  width: extendFlat({}, gaugeBarAttrs.line.width, {
+                    dflt: 1
+                  }),
+                  editType: "plot"
+                },
+                thickness: extendFlat({}, gaugeBarAttrs.thickness, {
+                  dflt: 0.85
+                }),
+                value: {
+                  valType: "number",
+                  editType: "calc",
+                  dflt: false
+                },
+                editType: "plot"
+              },
+              editType: "plot"
+              // TODO: in future version, add marker: (bar|needle)
+            }
+          };
+        }
+      });
+      var require_constants30 = __commonJS({
+        "src/traces/indicator/constants.js"(exports, module2) {
+          module2.exports = {
+            // Defaults for delta
+            defaultNumberFontSize: 80,
+            bulletNumberDomainSize: 0.25,
+            bulletPadding: 0.025,
+            innerRadius: 0.75,
+            valueThickness: 0.5,
+            // thickness of value bars relative to full thickness,
+            titlePadding: 5,
+            horizontalPadding: 10
+          };
+        }
+      });
+      var require_defaults57 = __commonJS({
+        "src/traces/indicator/defaults.js"(exports, module2) {
+          var Lib = require_lib();
+          var attributes = require_attributes61();
+          var handleDomainDefaults = require_domain().defaults;
+          var Template = require_plot_template();
+          var handleArrayContainerDefaults = require_array_container_defaults();
+          var cn = require_constants30();
+          var handleTickValueDefaults = require_tick_value_defaults();
+          var handleTickMarkDefaults = require_tick_mark_defaults();
+          var handleTickLabelDefaults = require_tick_label_defaults();
+          var handlePrefixSuffixDefaults = require_prefix_suffix_defaults();
+          function supplyDefaults(traceIn, traceOut, defaultColor, layout) {
+            function coerce(attr, dflt) {
+              return Lib.coerce(traceIn, traceOut, attributes, attr, dflt);
+            }
+            handleDomainDefaults(traceOut, layout, coerce);
+            coerce("mode");
+            traceOut._hasNumber = traceOut.mode.indexOf("number") !== -1;
+            traceOut._hasDelta = traceOut.mode.indexOf("delta") !== -1;
+            traceOut._hasGauge = traceOut.mode.indexOf("gauge") !== -1;
+            var value = coerce("value");
+            traceOut._range = [0, typeof value === "number" ? 1.5 * value : 1];
+            var auto = new Array(2);
+            var bignumberFontSize;
+            if (traceOut._hasNumber) {
+              coerce("number.valueformat");
+              var numberFontDflt = Lib.extendFlat({}, layout.font);
+              numberFontDflt.size = void 0;
+              Lib.coerceFont(coerce, "number.font", numberFontDflt);
+              if (traceOut.number.font.size === void 0) {
+                traceOut.number.font.size = cn.defaultNumberFontSize;
+                auto[0] = true;
+              }
+              coerce("number.prefix");
+              coerce("number.suffix");
+              bignumberFontSize = traceOut.number.font.size;
+            }
+            var deltaFontSize;
+            if (traceOut._hasDelta) {
+              var deltaFontDflt = Lib.extendFlat({}, layout.font);
+              deltaFontDflt.size = void 0;
+              Lib.coerceFont(coerce, "delta.font", deltaFontDflt);
+              if (traceOut.delta.font.size === void 0) {
+                traceOut.delta.font.size = (traceOut._hasNumber ? 0.5 : 1) * (bignumberFontSize || cn.defaultNumberFontSize);
+                auto[1] = true;
+              }
+              coerce("delta.reference", traceOut.value);
+              coerce("delta.relative");
+              coerce("delta.valueformat", traceOut.delta.relative ? "2%" : "");
+              coerce("delta.increasing.symbol");
+              coerce("delta.increasing.color");
+              coerce("delta.decreasing.symbol");
+              coerce("delta.decreasing.color");
+              coerce("delta.position");
+              coerce("delta.prefix");
+              coerce("delta.suffix");
+              deltaFontSize = traceOut.delta.font.size;
+            }
+            traceOut._scaleNumbers = (!traceOut._hasNumber || auto[0]) && (!traceOut._hasDelta || auto[1]) || false;
+            var titleFontDflt = Lib.extendFlat({}, layout.font);
+            titleFontDflt.size = 0.25 * (bignumberFontSize || deltaFontSize || cn.defaultNumberFontSize);
+            Lib.coerceFont(coerce, "title.font", titleFontDflt);
+            coerce("title.text");
+            var gaugeIn, gaugeOut, axisIn, axisOut;
+            function coerceGauge(attr, dflt) {
+              return Lib.coerce(gaugeIn, gaugeOut, attributes.gauge, attr, dflt);
+            }
+            function coerceGaugeAxis(attr, dflt) {
+              return Lib.coerce(axisIn, axisOut, attributes.gauge.axis, attr, dflt);
+            }
+            if (traceOut._hasGauge) {
+              gaugeIn = traceIn.gauge;
+              if (!gaugeIn) gaugeIn = {};
+              gaugeOut = Template.newContainer(traceOut, "gauge");
+              coerceGauge("shape");
+              var isBullet = traceOut._isBullet = traceOut.gauge.shape === "bullet";
+              if (!isBullet) {
+                coerce("title.align", "center");
+              }
+              var isAngular = traceOut._isAngular = traceOut.gauge.shape === "angular";
+              if (!isAngular) {
+                coerce("align", "center");
+              }
+              coerceGauge("bgcolor", layout.paper_bgcolor);
+              coerceGauge("borderwidth");
+              coerceGauge("bordercolor");
+              coerceGauge("bar.color");
+              coerceGauge("bar.line.color");
+              coerceGauge("bar.line.width");
+              var defaultBarThickness = cn.valueThickness * (traceOut.gauge.shape === "bullet" ? 0.5 : 1);
+              coerceGauge("bar.thickness", defaultBarThickness);
+              handleArrayContainerDefaults(gaugeIn, gaugeOut, {
+                name: "steps",
+                handleItemDefaults: stepDefaults
+              });
+              coerceGauge("threshold.value");
+              coerceGauge("threshold.thickness");
+              coerceGauge("threshold.line.width");
+              coerceGauge("threshold.line.color");
+              axisIn = {};
+              if (gaugeIn) axisIn = gaugeIn.axis || {};
+              axisOut = Template.newContainer(gaugeOut, "axis");
+              coerceGaugeAxis("visible");
+              traceOut._range = coerceGaugeAxis("range", traceOut._range);
+              var opts = {
+                font: layout.font,
+                noAutotickangles: true,
+                outerTicks: true,
+                noTicklabelshift: true,
+                noTicklabelstandoff: true
+              };
+              handleTickValueDefaults(axisIn, axisOut, coerceGaugeAxis, "linear");
+              handlePrefixSuffixDefaults(axisIn, axisOut, coerceGaugeAxis, "linear", opts);
+              handleTickLabelDefaults(axisIn, axisOut, coerceGaugeAxis, "linear", opts);
+              handleTickMarkDefaults(axisIn, axisOut, coerceGaugeAxis, opts);
+            } else {
+              coerce("title.align", "center");
+              coerce("align", "center");
+              traceOut._isAngular = traceOut._isBullet = false;
+            }
+            traceOut._length = null;
+          }
+          function stepDefaults(stepIn, stepOut) {
+            function coerce(attr, dflt) {
+              return Lib.coerce(stepIn, stepOut, attributes.gauge.steps, attr, dflt);
+            }
+            coerce("color");
+            coerce("line.color");
+            coerce("line.width");
+            coerce("range");
+            coerce("thickness");
+          }
+          module2.exports = {
+            supplyDefaults
+          };
+        }
+      });
+      var require_calc36 = __commonJS({
+        "src/traces/indicator/calc.js"(exports, module2) {
+          function calc(gd2, trace) {
+            var cd2 = [];
+            var lastReading = trace.value;
+            if (!(typeof trace._lastValue === "number")) trace._lastValue = trace.value;
+            var secondLastReading = trace._lastValue;
+            var deltaRef = secondLastReading;
+            if (trace._hasDelta && typeof trace.delta.reference === "number") {
+              deltaRef = trace.delta.reference;
+            }
+            cd2[0] = {
+              y: lastReading,
+              lastY: secondLastReading,
+              delta: lastReading - deltaRef,
+              relativeDelta: (lastReading - deltaRef) / deltaRef
+            };
+            return cd2;
+          }
+          module2.exports = {
+            calc
+          };
+        }
+      });
+      var require_plot30 = __commonJS({
+        "src/traces/indicator/plot.js"(exports, module2) {
+          var d3 = require_d3();
+          var interpolate = (init_src2(), __toCommonJS(src_exports)).interpolate;
+          var interpolateNumber = (init_src2(), __toCommonJS(src_exports)).interpolateNumber;
+          var Lib = require_lib();
+          var strScale = Lib.strScale;
+          var strTranslate = Lib.strTranslate;
+          var rad2deg = Lib.rad2deg;
+          var MID_SHIFT = require_alignment().MID_SHIFT;
+          var Drawing = require_drawing();
+          var cn = require_constants30();
+          var svgTextUtils = require_svg_text_utils();
+          var Axes = require_axes();
+          var handleAxisDefaults = require_axis_defaults();
+          var handleAxisPositionDefaults = require_position_defaults();
+          var axisLayoutAttrs = require_layout_attributes4();
+          var Color2 = require_color();
+          var anchor = {
+            left: "start",
+            center: "middle",
+            right: "end"
+          };
+          var position = {
+            left: 0,
+            center: 0.5,
+            right: 1
+          };
+          var SI_PREFIX = /[yzafpnµmkMGTPEZY]/;
+          function hasTransition(transitionOpts) {
+            return transitionOpts && transitionOpts.duration > 0;
+          }
+          module2.exports = function plot(gd2, cdModule, transitionOpts, makeOnCompleteCallback) {
+            var fullLayout = gd2._fullLayout;
+            var onComplete;
+            if (hasTransition(transitionOpts)) {
+              if (makeOnCompleteCallback) {
+                onComplete = makeOnCompleteCallback();
+              }
+            }
+            Lib.makeTraceGroups(fullLayout._indicatorlayer, cdModule, "trace").each(function(cd2) {
+              var cd0 = cd2[0];
+              var trace = cd0.trace;
+              var plotGroup = d3.select(this);
+              var hasGauge = trace._hasGauge;
+              var isAngular = trace._isAngular;
+              var isBullet = trace._isBullet;
+              var domain = trace.domain;
+              var size = {
+                w: fullLayout._size.w * (domain.x[1] - domain.x[0]),
+                h: fullLayout._size.h * (domain.y[1] - domain.y[0]),
+                l: fullLayout._size.l + fullLayout._size.w * domain.x[0],
+                r: fullLayout._size.r + fullLayout._size.w * (1 - domain.x[1]),
+                t: fullLayout._size.t + fullLayout._size.h * (1 - domain.y[1]),
+                b: fullLayout._size.b + fullLayout._size.h * domain.y[0]
+              };
+              var centerX = size.l + size.w / 2;
+              var centerY = size.t + size.h / 2;
+              var radius = Math.min(size.w / 2, size.h);
+              var innerRadius = cn.innerRadius * radius;
+              var numbersX, numbersY, numbersScaler;
+              var numbersAlign = trace.align || "center";
+              numbersY = centerY;
+              if (!hasGauge) {
+                numbersX = size.l + position[numbersAlign] * size.w;
+                numbersScaler = function(el2) {
+                  return fitTextInsideBox(el2, size.w, size.h);
+                };
+              } else {
+                if (isAngular) {
+                  numbersX = centerX;
+                  numbersY = centerY + radius / 2;
+                  numbersScaler = function(el2) {
+                    return fitTextInsideCircle(el2, 0.9 * innerRadius);
+                  };
+                }
+                if (isBullet) {
+                  var padding = cn.bulletPadding;
+                  var p2 = 1 - cn.bulletNumberDomainSize + padding;
+                  numbersX = size.l + (p2 + (1 - p2) * position[numbersAlign]) * size.w;
+                  numbersScaler = function(el2) {
+                    return fitTextInsideBox(el2, (cn.bulletNumberDomainSize - padding) * size.w, size.h);
+                  };
+                }
+              }
+              drawNumbers(gd2, plotGroup, cd2, {
+                numbersX,
+                numbersY,
+                numbersScaler,
+                transitionOpts,
+                onComplete
+              });
+              var gaugeBg, gaugeOutline;
+              if (hasGauge) {
+                gaugeBg = {
+                  range: trace.gauge.axis.range,
+                  color: trace.gauge.bgcolor,
+                  line: {
+                    color: trace.gauge.bordercolor,
+                    width: 0
+                  },
+                  thickness: 1
+                };
+                gaugeOutline = {
+                  range: trace.gauge.axis.range,
+                  color: "rgba(0, 0, 0, 0)",
+                  line: {
+                    color: trace.gauge.bordercolor,
+                    width: trace.gauge.borderwidth
+                  },
+                  thickness: 1
+                };
+              }
+              var angularGauge = plotGroup.selectAll("g.angular").data(isAngular ? cd2 : []);
+              angularGauge.exit().remove();
+              var angularaxisLayer = plotGroup.selectAll("g.angularaxis").data(isAngular ? cd2 : []);
+              angularaxisLayer.exit().remove();
+              if (isAngular) {
+                drawAngularGauge(gd2, plotGroup, cd2, {
+                  radius,
+                  innerRadius,
+                  gauge: angularGauge,
+                  layer: angularaxisLayer,
+                  size,
+                  gaugeBg,
+                  gaugeOutline,
+                  transitionOpts,
+                  onComplete
+                });
+              }
+              var bulletGauge = plotGroup.selectAll("g.bullet").data(isBullet ? cd2 : []);
+              bulletGauge.exit().remove();
+              var bulletaxisLayer = plotGroup.selectAll("g.bulletaxis").data(isBullet ? cd2 : []);
+              bulletaxisLayer.exit().remove();
+              if (isBullet) {
+                drawBulletGauge(gd2, plotGroup, cd2, {
+                  gauge: bulletGauge,
+                  layer: bulletaxisLayer,
+                  size,
+                  gaugeBg,
+                  gaugeOutline,
+                  transitionOpts,
+                  onComplete
+                });
+              }
+              var title = plotGroup.selectAll("text.title").data(cd2);
+              title.exit().remove();
+              title.enter().append("text").classed("title", true);
+              title.attr("text-anchor", function() {
+                return isBullet ? anchor.right : anchor[trace.title.align];
+              }).text(trace.title.text).call(Drawing.font, trace.title.font).call(svgTextUtils.convertToTspans, gd2);
+              title.attr("transform", function() {
+                var titleX = size.l + size.w * position[trace.title.align];
+                var titleY;
+                var titlePadding = cn.titlePadding;
+                var titlebBox = Drawing.bBox(title.node());
+                if (hasGauge) {
+                  if (isAngular) {
+                    if (trace.gauge.axis.visible) {
+                      var bBox = Drawing.bBox(angularaxisLayer.node());
+                      titleY = bBox.top - titlePadding - titlebBox.bottom;
+                    } else {
+                      titleY = size.t + size.h / 2 - radius / 2 - titlebBox.bottom - titlePadding;
+                    }
+                  }
+                  if (isBullet) {
+                    titleY = numbersY - (titlebBox.top + titlebBox.bottom) / 2;
+                    titleX = size.l - cn.bulletPadding * size.w;
+                  }
+                } else {
+                  titleY = trace._numbersTop - titlePadding - titlebBox.bottom;
+                }
+                return strTranslate(titleX, titleY);
+              });
+            });
+          };
+          function drawBulletGauge(gd2, plotGroup, cd2, opts) {
+            var trace = cd2[0].trace;
+            var bullet = opts.gauge;
+            var axisLayer = opts.layer;
+            var gaugeBg = opts.gaugeBg;
+            var gaugeOutline = opts.gaugeOutline;
+            var size = opts.size;
+            var domain = trace.domain;
+            var transitionOpts = opts.transitionOpts;
+            var onComplete = opts.onComplete;
+            var ax, vals, transFn, tickSign, shift;
+            bullet.enter().append("g").classed("bullet", true);
+            bullet.attr("transform", strTranslate(size.l, size.t));
+            axisLayer.enter().append("g").classed("bulletaxis", true).classed("crisp", true);
+            axisLayer.selectAll("g.xbulletaxistick,path,text").remove();
+            var bulletHeight = size.h;
+            var innerBulletHeight = trace.gauge.bar.thickness * bulletHeight;
+            var bulletLeft = domain.x[0];
+            var bulletRight = domain.x[0] + (domain.x[1] - domain.x[0]) * (trace._hasNumber || trace._hasDelta ? 1 - cn.bulletNumberDomainSize : 1);
+            ax = mockAxis(gd2, trace.gauge.axis);
+            ax._id = "xbulletaxis";
+            ax.domain = [bulletLeft, bulletRight];
+            ax.setScale();
+            vals = Axes.calcTicks(ax);
+            transFn = Axes.makeTransTickFn(ax);
+            tickSign = Axes.getTickSigns(ax)[2];
+            shift = size.t + size.h;
+            if (ax.visible) {
+              Axes.drawTicks(gd2, ax, {
+                vals: ax.ticks === "inside" ? Axes.clipEnds(ax, vals) : vals,
+                layer: axisLayer,
+                path: Axes.makeTickPath(ax, shift, tickSign),
+                transFn
+              });
+              Axes.drawLabels(gd2, ax, {
+                vals,
+                layer: axisLayer,
+                transFn,
+                labelFns: Axes.makeLabelFns(ax, shift)
+              });
+            }
+            function drawRect(s2) {
+              s2.attr("width", function(d2) {
+                return Math.max(0, ax.c2p(d2.range[1]) - ax.c2p(d2.range[0]));
+              }).attr("x", function(d2) {
+                return ax.c2p(d2.range[0]);
+              }).attr("y", function(d2) {
+                return 0.5 * (1 - d2.thickness) * bulletHeight;
+              }).attr("height", function(d2) {
+                return d2.thickness * bulletHeight;
+              });
+            }
+            var boxes = [gaugeBg].concat(trace.gauge.steps);
+            var bgBullet = bullet.selectAll("g.bg-bullet").data(boxes);
+            bgBullet.enter().append("g").classed("bg-bullet", true).append("rect");
+            bgBullet.select("rect").call(drawRect).call(styleShape);
+            bgBullet.exit().remove();
+            var fgBullet = bullet.selectAll("g.value-bullet").data([trace.gauge.bar]);
+            fgBullet.enter().append("g").classed("value-bullet", true).append("rect");
+            fgBullet.select("rect").attr("height", innerBulletHeight).attr("y", (bulletHeight - innerBulletHeight) / 2).call(styleShape);
+            if (hasTransition(transitionOpts)) {
+              fgBullet.select("rect").transition().duration(transitionOpts.duration).ease(transitionOpts.easing).each("end", function() {
+                onComplete && onComplete();
+              }).each("interrupt", function() {
+                onComplete && onComplete();
+              }).attr("width", Math.max(0, ax.c2p(Math.min(trace.gauge.axis.range[1], cd2[0].y))));
+            } else {
+              fgBullet.select("rect").attr("width", typeof cd2[0].y === "number" ? Math.max(0, ax.c2p(Math.min(trace.gauge.axis.range[1], cd2[0].y))) : 0);
+            }
+            fgBullet.exit().remove();
+            var data = cd2.filter(function() {
+              return trace.gauge.threshold.value || trace.gauge.threshold.value === 0;
+            });
+            var threshold = bullet.selectAll("g.threshold-bullet").data(data);
+            threshold.enter().append("g").classed("threshold-bullet", true).append("line");
+            threshold.select("line").attr("x1", ax.c2p(trace.gauge.threshold.value)).attr("x2", ax.c2p(trace.gauge.threshold.value)).attr("y1", (1 - trace.gauge.threshold.thickness) / 2 * bulletHeight).attr("y2", (1 - (1 - trace.gauge.threshold.thickness) / 2) * bulletHeight).call(Color2.stroke, trace.gauge.threshold.line.color).style("stroke-width", trace.gauge.threshold.line.width);
+            threshold.exit().remove();
+            var bulletOutline = bullet.selectAll("g.gauge-outline").data([gaugeOutline]);
+            bulletOutline.enter().append("g").classed("gauge-outline", true).append("rect");
+            bulletOutline.select("rect").call(drawRect).call(styleShape);
+            bulletOutline.exit().remove();
+          }
+          function drawAngularGauge(gd2, plotGroup, cd2, opts) {
+            var trace = cd2[0].trace;
+            var size = opts.size;
+            var radius = opts.radius;
+            var innerRadius = opts.innerRadius;
+            var gaugeBg = opts.gaugeBg;
+            var gaugeOutline = opts.gaugeOutline;
+            var gaugePosition = [size.l + size.w / 2, size.t + size.h / 2 + radius / 2];
+            var gauge = opts.gauge;
+            var axisLayer = opts.layer;
+            var transitionOpts = opts.transitionOpts;
+            var onComplete = opts.onComplete;
+            var theta = Math.PI / 2;
+            function valueToAngle(v22) {
+              var min = trace.gauge.axis.range[0];
+              var max = trace.gauge.axis.range[1];
+              var angle2 = (v22 - min) / (max - min) * Math.PI - theta;
+              if (angle2 < -theta) return -theta;
+              if (angle2 > theta) return theta;
+              return angle2;
+            }
+            function arcPathGenerator(size2) {
+              return d3.svg.arc().innerRadius((innerRadius + radius) / 2 - size2 / 2 * (radius - innerRadius)).outerRadius((innerRadius + radius) / 2 + size2 / 2 * (radius - innerRadius)).startAngle(-theta);
+            }
+            function drawArc(p2) {
+              p2.attr("d", function(d2) {
+                return arcPathGenerator(d2.thickness).startAngle(valueToAngle(d2.range[0])).endAngle(valueToAngle(d2.range[1]))();
+              });
+            }
+            var ax, vals, transFn, tickSign;
+            gauge.enter().append("g").classed("angular", true);
+            gauge.attr("transform", strTranslate(gaugePosition[0], gaugePosition[1]));
+            axisLayer.enter().append("g").classed("angularaxis", true).classed("crisp", true);
+            axisLayer.selectAll("g.xangularaxistick,path,text").remove();
+            ax = mockAxis(gd2, trace.gauge.axis);
+            ax.type = "linear";
+            ax.range = trace.gauge.axis.range;
+            ax._id = "xangularaxis";
+            ax.ticklabeloverflow = "allow";
+            ax.setScale();
+            var t2g = function(d2) {
+              return (ax.range[0] - d2.x) / (ax.range[1] - ax.range[0]) * Math.PI + Math.PI;
+            };
+            var labelFns = {};
+            var out = Axes.makeLabelFns(ax, 0);
+            var labelStandoff = out.labelStandoff;
+            labelFns.xFn = function(d2) {
+              var rad = t2g(d2);
+              return Math.cos(rad) * labelStandoff;
+            };
+            labelFns.yFn = function(d2) {
+              var rad = t2g(d2);
+              var ff2 = Math.sin(rad) > 0 ? 0.2 : 1;
+              return -Math.sin(rad) * (labelStandoff + d2.fontSize * ff2) + Math.abs(Math.cos(rad)) * (d2.fontSize * MID_SHIFT);
+            };
+            labelFns.anchorFn = function(d2) {
+              var rad = t2g(d2);
+              var cos = Math.cos(rad);
+              return Math.abs(cos) < 0.1 ? "middle" : cos > 0 ? "start" : "end";
+            };
+            labelFns.heightFn = function(d2, a2, h2) {
+              var rad = t2g(d2);
+              return -0.5 * (1 + Math.sin(rad)) * h2;
+            };
+            var _transFn = function(rad) {
+              return strTranslate(
+                gaugePosition[0] + radius * Math.cos(rad),
+                gaugePosition[1] - radius * Math.sin(rad)
+              );
+            };
+            transFn = function(d2) {
+              return _transFn(t2g(d2));
+            };
+            var transFn2 = function(d2) {
+              var rad = t2g(d2);
+              return _transFn(rad) + "rotate(" + -rad2deg(rad) + ")";
+            };
+            vals = Axes.calcTicks(ax);
+            tickSign = Axes.getTickSigns(ax)[2];
+            if (ax.visible) {
+              tickSign = ax.ticks === "inside" ? -1 : 1;
+              var pad = (ax.linewidth || 1) / 2;
+              Axes.drawTicks(gd2, ax, {
+                vals,
+                layer: axisLayer,
+                path: "M" + tickSign * pad + ",0h" + tickSign * ax.ticklen,
+                transFn: transFn2
+              });
+              Axes.drawLabels(gd2, ax, {
+                vals,
+                layer: axisLayer,
+                transFn,
+                labelFns
+              });
+            }
+            var arcs = [gaugeBg].concat(trace.gauge.steps);
+            var bgArc = gauge.selectAll("g.bg-arc").data(arcs);
+            bgArc.enter().append("g").classed("bg-arc", true).append("path");
+            bgArc.select("path").call(drawArc).call(styleShape);
+            bgArc.exit().remove();
+            var valueArcPathGenerator = arcPathGenerator(trace.gauge.bar.thickness);
+            var valueArc = gauge.selectAll("g.value-arc").data([trace.gauge.bar]);
+            valueArc.enter().append("g").classed("value-arc", true).append("path");
+            var valueArcPath = valueArc.select("path");
+            if (hasTransition(transitionOpts)) {
+              valueArcPath.transition().duration(transitionOpts.duration).ease(transitionOpts.easing).each("end", function() {
+                onComplete && onComplete();
+              }).each("interrupt", function() {
+                onComplete && onComplete();
+              }).attrTween("d", arcTween(valueArcPathGenerator, valueToAngle(cd2[0].lastY), valueToAngle(cd2[0].y)));
+              trace._lastValue = cd2[0].y;
+            } else {
+              valueArcPath.attr("d", typeof cd2[0].y === "number" ? valueArcPathGenerator.endAngle(valueToAngle(cd2[0].y)) : "M0,0Z");
+            }
+            valueArcPath.call(styleShape);
+            valueArc.exit().remove();
+            arcs = [];
+            var v2 = trace.gauge.threshold.value;
+            if (v2 || v2 === 0) {
+              arcs.push({
+                range: [v2, v2],
+                color: trace.gauge.threshold.color,
+                line: {
+                  color: trace.gauge.threshold.line.color,
+                  width: trace.gauge.threshold.line.width
+                },
+                thickness: trace.gauge.threshold.thickness
+              });
+            }
+            var thresholdArc = gauge.selectAll("g.threshold-arc").data(arcs);
+            thresholdArc.enter().append("g").classed("threshold-arc", true).append("path");
+            thresholdArc.select("path").call(drawArc).call(styleShape);
+            thresholdArc.exit().remove();
+            var gaugeBorder = gauge.selectAll("g.gauge-outline").data([gaugeOutline]);
+            gaugeBorder.enter().append("g").classed("gauge-outline", true).append("path");
+            gaugeBorder.select("path").call(drawArc).call(styleShape);
+            gaugeBorder.exit().remove();
+          }
+          function drawNumbers(gd2, plotGroup, cd2, opts) {
+            var trace = cd2[0].trace;
+            var numbersX = opts.numbersX;
+            var numbersY = opts.numbersY;
+            var numbersAlign = trace.align || "center";
+            var numbersAnchor = anchor[numbersAlign];
+            var transitionOpts = opts.transitionOpts;
+            var onComplete = opts.onComplete;
+            var numbers = Lib.ensureSingle(plotGroup, "g", "numbers");
+            var bignumberbBox, deltabBox;
+            var numbersbBox;
+            var data = [];
+            if (trace._hasNumber) data.push("number");
+            if (trace._hasDelta) {
+              data.push("delta");
+              if (trace.delta.position === "left") data.reverse();
+            }
+            var sel = numbers.selectAll("text").data(data);
+            sel.enter().append("text");
+            sel.attr("text-anchor", function() {
+              return numbersAnchor;
+            }).attr("class", function(d2) {
+              return d2;
+            }).attr("x", null).attr("y", null).attr("dx", null).attr("dy", null);
+            sel.exit().remove();
+            function transitionFormat(valueformat, fmt, from, to) {
+              if (valueformat.match("s") && // If using SI prefix
+              from >= 0 !== to >= 0 && // If sign change
+              (!fmt(from).slice(-1).match(SI_PREFIX) && !fmt(to).slice(-1).match(SI_PREFIX))) {
+                var transitionValueFormat = valueformat.slice().replace("s", "f").replace(/\d+/, function(m2) {
+                  return parseInt(m2) - 1;
+                });
+                var transitionAx = mockAxis(gd2, { tickformat: transitionValueFormat });
+                return function(v2) {
+                  if (Math.abs(v2) < 1) return Axes.tickText(transitionAx, v2).text;
+                  return fmt(v2);
+                };
+              } else {
+                return fmt;
+              }
+            }
+            function drawBignumber() {
+              var bignumberAx = mockAxis(gd2, { tickformat: trace.number.valueformat }, trace._range);
+              bignumberAx.setScale();
+              Axes.prepTicks(bignumberAx);
+              var bignumberFmt = function(v2) {
+                return Axes.tickText(bignumberAx, v2).text;
+              };
+              var bignumberSuffix = trace.number.suffix;
+              var bignumberPrefix = trace.number.prefix;
+              var number = numbers.select("text.number");
+              function writeNumber() {
+                var txt = typeof cd2[0].y === "number" ? bignumberPrefix + bignumberFmt(cd2[0].y) + bignumberSuffix : "-";
+                number.text(txt).call(Drawing.font, trace.number.font).call(svgTextUtils.convertToTspans, gd2);
+              }
+              if (hasTransition(transitionOpts)) {
+                number.transition().duration(transitionOpts.duration).ease(transitionOpts.easing).each("end", function() {
+                  writeNumber();
+                  onComplete && onComplete();
+                }).each("interrupt", function() {
+                  writeNumber();
+                  onComplete && onComplete();
+                }).attrTween("text", function() {
+                  var that = d3.select(this);
+                  var interpolator = interpolateNumber(cd2[0].lastY, cd2[0].y);
+                  trace._lastValue = cd2[0].y;
+                  var transitionFmt = transitionFormat(trace.number.valueformat, bignumberFmt, cd2[0].lastY, cd2[0].y);
+                  return function(t4) {
+                    that.text(bignumberPrefix + transitionFmt(interpolator(t4)) + bignumberSuffix);
+                  };
+                });
+              } else {
+                writeNumber();
+              }
+              bignumberbBox = measureText(bignumberPrefix + bignumberFmt(cd2[0].y) + bignumberSuffix, trace.number.font, numbersAnchor, gd2);
+              return number;
+            }
+            function drawDelta() {
+              var deltaAx = mockAxis(gd2, { tickformat: trace.delta.valueformat }, trace._range);
+              deltaAx.setScale();
+              Axes.prepTicks(deltaAx);
+              var deltaFmt = function(v2) {
+                return Axes.tickText(deltaAx, v2).text;
+              };
+              var deltaSuffix = trace.delta.suffix;
+              var deltaPrefix = trace.delta.prefix;
+              var deltaValue = function(d2) {
+                var value = trace.delta.relative ? d2.relativeDelta : d2.delta;
+                return value;
+              };
+              var deltaFormatText = function(value, numberFmt) {
+                if (value === 0 || typeof value !== "number" || isNaN(value)) return "-";
+                return (value > 0 ? trace.delta.increasing.symbol : trace.delta.decreasing.symbol) + deltaPrefix + numberFmt(value) + deltaSuffix;
+              };
+              var deltaFill = function(d2) {
+                return d2.delta >= 0 ? trace.delta.increasing.color : trace.delta.decreasing.color;
+              };
+              if (trace._deltaLastValue === void 0) {
+                trace._deltaLastValue = deltaValue(cd2[0]);
+              }
+              var delta2 = numbers.select("text.delta");
+              delta2.call(Drawing.font, trace.delta.font).call(Color2.fill, deltaFill({ delta: trace._deltaLastValue }));
+              function writeDelta() {
+                delta2.text(deltaFormatText(deltaValue(cd2[0]), deltaFmt)).call(Color2.fill, deltaFill(cd2[0])).call(svgTextUtils.convertToTspans, gd2);
+              }
+              if (hasTransition(transitionOpts)) {
+                delta2.transition().duration(transitionOpts.duration).ease(transitionOpts.easing).tween("text", function() {
+                  var that = d3.select(this);
+                  var to = deltaValue(cd2[0]);
+                  var from = trace._deltaLastValue;
+                  var transitionFmt = transitionFormat(trace.delta.valueformat, deltaFmt, from, to);
+                  var interpolator = interpolateNumber(from, to);
+                  trace._deltaLastValue = to;
+                  return function(t4) {
+                    that.text(deltaFormatText(interpolator(t4), transitionFmt));
+                    that.call(Color2.fill, deltaFill({ delta: interpolator(t4) }));
+                  };
+                }).each("end", function() {
+                  writeDelta();
+                  onComplete && onComplete();
+                }).each("interrupt", function() {
+                  writeDelta();
+                  onComplete && onComplete();
+                });
+              } else {
+                writeDelta();
+              }
+              deltabBox = measureText(deltaFormatText(deltaValue(cd2[0]), deltaFmt), trace.delta.font, numbersAnchor, gd2);
+              return delta2;
+            }
+            var key = trace.mode + trace.align;
+            var delta;
+            if (trace._hasDelta) {
+              delta = drawDelta();
+              key += trace.delta.position + trace.delta.font.size + trace.delta.font.family + trace.delta.valueformat;
+              key += trace.delta.increasing.symbol + trace.delta.decreasing.symbol;
+              numbersbBox = deltabBox;
+            }
+            if (trace._hasNumber) {
+              drawBignumber();
+              key += trace.number.font.size + trace.number.font.family + trace.number.valueformat + trace.number.suffix + trace.number.prefix;
+              numbersbBox = bignumberbBox;
+            }
+            if (trace._hasDelta && trace._hasNumber) {
+              var bignumberCenter = [
+                (bignumberbBox.left + bignumberbBox.right) / 2,
+                (bignumberbBox.top + bignumberbBox.bottom) / 2
+              ];
+              var deltaCenter = [
+                (deltabBox.left + deltabBox.right) / 2,
+                (deltabBox.top + deltabBox.bottom) / 2
+              ];
+              var dx, dy;
+              var padding = 0.75 * trace.delta.font.size;
+              if (trace.delta.position === "left") {
+                dx = cache(trace, "deltaPos", 0, -1 * (bignumberbBox.width * position[trace.align] + deltabBox.width * (1 - position[trace.align]) + padding), key, Math.min);
+                dy = bignumberCenter[1] - deltaCenter[1];
+                numbersbBox = {
+                  width: bignumberbBox.width + deltabBox.width + padding,
+                  height: Math.max(bignumberbBox.height, deltabBox.height),
+                  left: deltabBox.left + dx,
+                  right: bignumberbBox.right,
+                  top: Math.min(bignumberbBox.top, deltabBox.top + dy),
+                  bottom: Math.max(bignumberbBox.bottom, deltabBox.bottom + dy)
+                };
+              }
+              if (trace.delta.position === "right") {
+                dx = cache(trace, "deltaPos", 0, bignumberbBox.width * (1 - position[trace.align]) + deltabBox.width * position[trace.align] + padding, key, Math.max);
+                dy = bignumberCenter[1] - deltaCenter[1];
+                numbersbBox = {
+                  width: bignumberbBox.width + deltabBox.width + padding,
+                  height: Math.max(bignumberbBox.height, deltabBox.height),
+                  left: bignumberbBox.left,
+                  right: deltabBox.right + dx,
+                  top: Math.min(bignumberbBox.top, deltabBox.top + dy),
+                  bottom: Math.max(bignumberbBox.bottom, deltabBox.bottom + dy)
+                };
+              }
+              if (trace.delta.position === "bottom") {
+                dx = null;
+                dy = deltabBox.height;
+                numbersbBox = {
+                  width: Math.max(bignumberbBox.width, deltabBox.width),
+                  height: bignumberbBox.height + deltabBox.height,
+                  left: Math.min(bignumberbBox.left, deltabBox.left),
+                  right: Math.max(bignumberbBox.right, deltabBox.right),
+                  top: bignumberbBox.bottom - bignumberbBox.height,
+                  bottom: bignumberbBox.bottom + deltabBox.height
+                };
+              }
+              if (trace.delta.position === "top") {
+                dx = null;
+                dy = bignumberbBox.top;
+                numbersbBox = {
+                  width: Math.max(bignumberbBox.width, deltabBox.width),
+                  height: bignumberbBox.height + deltabBox.height,
+                  left: Math.min(bignumberbBox.left, deltabBox.left),
+                  right: Math.max(bignumberbBox.right, deltabBox.right),
+                  top: bignumberbBox.bottom - bignumberbBox.height - deltabBox.height,
+                  bottom: bignumberbBox.bottom
+                };
+              }
+              delta.attr({ dx, dy });
+            }
+            if (trace._hasNumber || trace._hasDelta) {
+              numbers.attr("transform", function() {
+                var m2 = opts.numbersScaler(numbersbBox);
+                key += m2[2];
+                var scaleRatio = cache(trace, "numbersScale", 1, m2[0], key, Math.min);
+                var translateY;
+                if (!trace._scaleNumbers) scaleRatio = 1;
+                if (trace._isAngular) {
+                  translateY = numbersY - scaleRatio * numbersbBox.bottom;
+                } else {
+                  translateY = numbersY - scaleRatio * (numbersbBox.top + numbersbBox.bottom) / 2;
+                }
+                trace._numbersTop = scaleRatio * numbersbBox.top + translateY;
+                var ref = numbersbBox[numbersAlign];
+                if (numbersAlign === "center") ref = (numbersbBox.left + numbersbBox.right) / 2;
+                var translateX = numbersX - scaleRatio * ref;
+                translateX = cache(trace, "numbersTranslate", 0, translateX, key, Math.max);
+                return strTranslate(translateX, translateY) + strScale(scaleRatio);
+              });
+            }
+          }
+          function styleShape(p2) {
+            p2.each(function(d2) {
+              Color2.stroke(d3.select(this), d2.line.color);
+            }).each(function(d2) {
+              Color2.fill(d3.select(this), d2.color);
+            }).style("stroke-width", function(d2) {
+              return d2.line.width;
+            });
+          }
+          function arcTween(arc, endAngle, newAngle) {
+            return function() {
+              var interp = interpolate(endAngle, newAngle);
+              return function(t4) {
+                return arc.endAngle(interp(t4))();
+              };
+            };
+          }
+          function mockAxis(gd2, opts, zrange) {
+            var fullLayout = gd2._fullLayout;
+            var axisIn = Lib.extendFlat({
+              type: "linear",
+              ticks: "outside",
+              range: zrange,
+              showline: true
+            }, opts);
+            var axisOut = {
+              type: "linear",
+              _id: "x" + opts._id
+            };
+            var axisOptions = {
+              letter: "x",
+              font: fullLayout.font,
+              noAutotickangles: true,
+              noHover: true,
+              noTickson: true
+            };
+            function coerce(attr, dflt) {
+              return Lib.coerce(axisIn, axisOut, axisLayoutAttrs, attr, dflt);
+            }
+            handleAxisDefaults(axisIn, axisOut, coerce, axisOptions, fullLayout);
+            handleAxisPositionDefaults(axisIn, axisOut, coerce, axisOptions);
+            return axisOut;
+          }
+          function fitTextInsideBox(textBB, width, height) {
+            var ratio = Math.min(width / textBB.width, height / textBB.height);
+            return [ratio, textBB, width + "x" + height];
+          }
+          function fitTextInsideCircle(textBB, radius) {
+            var elRadius = Math.sqrt(textBB.width / 2 * (textBB.width / 2) + textBB.height * textBB.height);
+            var ratio = radius / elRadius;
+            return [ratio, textBB, radius];
+          }
+          function measureText(txt, font, textAnchor, gd2) {
+            var element = document.createElementNS("http://www.w3.org/2000/svg", "text");
+            var sel = d3.select(element);
+            sel.text(txt).attr("x", 0).attr("y", 0).attr("text-anchor", textAnchor).attr("data-unformatted", txt).call(svgTextUtils.convertToTspans, gd2).call(Drawing.font, font);
+            return Drawing.bBox(sel.node());
+          }
+          function cache(trace, name2, initialValue, value, key, fn) {
+            var objName = "_cache" + name2;
+            if (!(trace[objName] && trace[objName].key === key)) {
+              trace[objName] = { key, value: initialValue };
+            }
+            var v2 = Lib.aggNums(fn, null, [trace[objName].value, value], 2);
+            trace[objName].value = v2;
+            return v2;
+          }
+        }
+      });
+      var require_indicator = __commonJS({
+        "src/traces/indicator/index.js"(exports, module2) {
+          module2.exports = {
+            moduleType: "trace",
+            name: "indicator",
+            basePlotModule: require_base_plot10(),
+            categories: ["svg", "noOpacity", "noHover"],
+            animatable: true,
+            attributes: require_attributes61(),
+            supplyDefaults: require_defaults57().supplyDefaults,
+            calc: require_calc36().calc,
+            plot: require_plot30(),
+            meta: {}
+          };
+        }
+      });
+      var require_indicator2 = __commonJS({
+        "lib/indicator.js"(exports, module2) {
+          module2.exports = require_indicator();
+        }
+      });
+      var require_attributes62 = __commonJS({
+        "src/traces/table/attributes.js"(exports, module2) {
+          var annAttrs = require_attributes11();
+          var extendFlat = require_extend().extendFlat;
+          var overrideAll = require_edit_types().overrideAll;
+          var fontAttrs = require_font_attributes();
+          var domainAttrs = require_domain().attributes;
+          var descriptionOnlyNumbers = require_axis_format_attributes().descriptionOnlyNumbers;
+          module2.exports = overrideAll({
+            domain: domainAttrs({ name: "table", trace: true }),
+            columnwidth: {
+              valType: "number",
+              arrayOk: true,
+              dflt: null
+            },
+            columnorder: {
+              valType: "data_array"
+            },
+            header: {
+              values: {
+                valType: "data_array",
+                dflt: []
+              },
+              format: {
+                valType: "data_array",
+                dflt: [],
+                description: descriptionOnlyNumbers("cell value")
+              },
+              prefix: {
+                valType: "string",
+                arrayOk: true,
+                dflt: null
+              },
+              suffix: {
+                valType: "string",
+                arrayOk: true,
+                dflt: null
+              },
+              height: {
+                valType: "number",
+                dflt: 28
+              },
+              align: extendFlat({}, annAttrs.align, { arrayOk: true }),
+              line: {
+                width: {
+                  valType: "number",
+                  arrayOk: true,
+                  dflt: 1
+                },
+                color: {
+                  valType: "color",
+                  arrayOk: true,
+                  dflt: "grey"
+                }
+              },
+              fill: {
+                color: {
+                  valType: "color",
+                  arrayOk: true,
+                  dflt: "white"
+                }
+              },
+              font: extendFlat({}, fontAttrs({ arrayOk: true }))
+            },
+            cells: {
+              values: {
+                valType: "data_array",
+                dflt: []
+              },
+              format: {
+                valType: "data_array",
+                dflt: [],
+                description: descriptionOnlyNumbers("cell value")
+              },
+              prefix: {
+                valType: "string",
+                arrayOk: true,
+                dflt: null
+              },
+              suffix: {
+                valType: "string",
+                arrayOk: true,
+                dflt: null
+              },
+              height: {
+                valType: "number",
+                dflt: 20
+              },
+              align: extendFlat({}, annAttrs.align, { arrayOk: true }),
+              line: {
+                width: {
+                  valType: "number",
+                  arrayOk: true,
+                  dflt: 1
+                },
+                color: {
+                  valType: "color",
+                  arrayOk: true,
+                  dflt: "grey"
+                }
+              },
+              fill: {
+                color: {
+                  valType: "color",
+                  arrayOk: true,
+                  dflt: "white"
+                }
+              },
+              font: extendFlat({}, fontAttrs({ arrayOk: true }))
+            }
+          }, "calc", "from-root");
+        }
+      });
+      var require_defaults58 = __commonJS({
+        "src/traces/table/defaults.js"(exports, module2) {
+          var Lib = require_lib();
+          var attributes = require_attributes62();
+          var handleDomainDefaults = require_domain().defaults;
+          function defaultColumnOrder(traceOut, coerce) {
+            var specifiedColumnOrder = traceOut.columnorder || [];
+            var commonLength = traceOut.header.values.length;
+            var truncated = specifiedColumnOrder.slice(0, commonLength);
+            var sorted = truncated.slice().sort(function(a2, b2) {
+              return a2 - b2;
+            });
+            var oneStepped = truncated.map(function(d2) {
+              return sorted.indexOf(d2);
+            });
+            for (var i2 = oneStepped.length; i2 < commonLength; i2++) {
+              oneStepped.push(i2);
+            }
+            coerce("columnorder", oneStepped);
+          }
+          module2.exports = function supplyDefaults(traceIn, traceOut, defaultColor, layout) {
+            function coerce(attr, dflt) {
+              return Lib.coerce(traceIn, traceOut, attributes, attr, dflt);
+            }
+            handleDomainDefaults(traceOut, layout, coerce);
+            coerce("columnwidth");
+            coerce("header.values");
+            coerce("header.format");
+            coerce("header.align");
+            coerce("header.prefix");
+            coerce("header.suffix");
+            coerce("header.height");
+            coerce("header.line.width");
+            coerce("header.line.color");
+            coerce("header.fill.color");
+            Lib.coerceFont(coerce, "header.font", layout.font);
+            defaultColumnOrder(traceOut, coerce);
+            coerce("cells.values");
+            coerce("cells.format");
+            coerce("cells.align");
+            coerce("cells.prefix");
+            coerce("cells.suffix");
+            coerce("cells.height");
+            coerce("cells.line.width");
+            coerce("cells.line.color");
+            coerce("cells.fill.color");
+            Lib.coerceFont(coerce, "cells.font", layout.font);
+            traceOut._length = null;
+          };
+        }
+      });
+      var require_calc37 = __commonJS({
+        "src/traces/table/calc.js"(exports, module2) {
+          var wrap = require_gup().wrap;
+          module2.exports = function calc() {
+            return wrap({});
+          };
+        }
+      });
+      var require_constants31 = __commonJS({
+        "src/traces/table/constants.js"(exports, module2) {
+          module2.exports = {
+            cellPad: 8,
+            columnExtentOffset: 10,
+            columnTitleOffset: 28,
+            emptyHeaderHeight: 16,
+            latexCheck: /^\$.*\$$/,
+            goldenRatio: 1.618,
+            lineBreaker: "<br>",
+            maxDimensionCount: 60,
+            overdrag: 45,
+            releaseTransitionDuration: 120,
+            releaseTransitionEase: "cubic-out",
+            scrollbarCaptureWidth: 18,
+            scrollbarHideDelay: 1e3,
+            scrollbarHideDuration: 1e3,
+            scrollbarOffset: 5,
+            scrollbarWidth: 8,
+            transitionDuration: 100,
+            transitionEase: "cubic-out",
+            uplift: 5,
+            wrapSpacer: " ",
+            wrapSplitCharacter: " ",
+            cn: {
+              // general class names
+              table: "table",
+              tableControlView: "table-control-view",
+              scrollBackground: "scroll-background",
+              yColumn: "y-column",
+              columnBlock: "column-block",
+              scrollAreaClip: "scroll-area-clip",
+              scrollAreaClipRect: "scroll-area-clip-rect",
+              columnBoundary: "column-boundary",
+              columnBoundaryClippath: "column-boundary-clippath",
+              columnBoundaryRect: "column-boundary-rect",
+              columnCells: "column-cells",
+              columnCell: "column-cell",
+              cellRect: "cell-rect",
+              cellText: "cell-text",
+              cellTextHolder: "cell-text-holder",
+              // scroll related class names
+              scrollbarKit: "scrollbar-kit",
+              scrollbar: "scrollbar",
+              scrollbarSlider: "scrollbar-slider",
+              scrollbarGlyph: "scrollbar-glyph",
+              scrollbarCaptureZone: "scrollbar-capture-zone"
+            }
+          };
+        }
+      });
+      var require_data_preparation_helper = __commonJS({
+        "src/traces/table/data_preparation_helper.js"(exports, module2) {
+          var c2 = require_constants31();
+          var extendFlat = require_extend().extendFlat;
+          var isNumeric = require_fast_isnumeric();
+          var isTypedArray2 = require_array().isTypedArray;
+          var isArrayOrTypedArray = require_array().isArrayOrTypedArray;
+          module2.exports = function calc(gd2, trace) {
+            var cellsValues = squareStringMatrix(trace.cells.values);
+            var slicer = function(a2) {
+              return a2.slice(trace.header.values.length, a2.length);
+            };
+            var headerValuesIn = squareStringMatrix(trace.header.values);
+            if (headerValuesIn.length && !headerValuesIn[0].length) {
+              headerValuesIn[0] = [""];
+              headerValuesIn = squareStringMatrix(headerValuesIn);
+            }
+            var headerValues = headerValuesIn.concat(slicer(cellsValues).map(function() {
+              return emptyStrings((headerValuesIn[0] || [""]).length);
+            }));
+            var domain = trace.domain;
+            var groupWidth = Math.floor(gd2._fullLayout._size.w * (domain.x[1] - domain.x[0]));
+            var groupHeight = Math.floor(gd2._fullLayout._size.h * (domain.y[1] - domain.y[0]));
+            var headerRowHeights = trace.header.values.length ? headerValues[0].map(function() {
+              return trace.header.height;
+            }) : [c2.emptyHeaderHeight];
+            var rowHeights = cellsValues.length ? cellsValues[0].map(function() {
+              return trace.cells.height;
+            }) : [];
+            var headerHeight = headerRowHeights.reduce(sum, 0);
+            var scrollHeight = groupHeight - headerHeight;
+            var minimumFillHeight = scrollHeight + c2.uplift;
+            var anchorToRowBlock = makeAnchorToRowBlock(rowHeights, minimumFillHeight);
+            var anchorToHeaderRowBlock = makeAnchorToRowBlock(headerRowHeights, headerHeight);
+            var headerRowBlocks = makeRowBlock(anchorToHeaderRowBlock, []);
+            var rowBlocks = makeRowBlock(anchorToRowBlock, headerRowBlocks);
+            var uniqueKeys = {};
+            var columnOrder = trace._fullInput.columnorder;
+            if (isArrayOrTypedArray(columnOrder)) columnOrder = Array.from(columnOrder);
+            columnOrder = columnOrder.concat(slicer(cellsValues.map(function(d2, i2) {
+              return i2;
+            })));
+            var columnWidths = headerValues.map(function(d2, i2) {
+              var value = isArrayOrTypedArray(trace.columnwidth) ? trace.columnwidth[Math.min(i2, trace.columnwidth.length - 1)] : trace.columnwidth;
+              return isNumeric(value) ? Number(value) : 1;
+            });
+            var totalColumnWidths = columnWidths.reduce(sum, 0);
+            columnWidths = columnWidths.map(function(d2) {
+              return d2 / totalColumnWidths * groupWidth;
+            });
+            var maxLineWidth = Math.max(arrayMax(trace.header.line.width), arrayMax(trace.cells.line.width));
+            var calcdata = {
+              // include staticPlot in the key so if it changes we delete and redraw
+              key: trace.uid + gd2._context.staticPlot,
+              translateX: domain.x[0] * gd2._fullLayout._size.w,
+              translateY: gd2._fullLayout._size.h * (1 - domain.y[1]),
+              size: gd2._fullLayout._size,
+              width: groupWidth,
+              maxLineWidth,
+              height: groupHeight,
+              columnOrder,
+              // will be mutated on column move, todo use in callback
+              groupHeight,
+              rowBlocks,
+              headerRowBlocks,
+              scrollY: 0,
+              // will be mutated on scroll
+              cells: extendFlat({}, trace.cells, { values: cellsValues }),
+              headerCells: extendFlat({}, trace.header, { values: headerValues }),
+              gdColumns: headerValues.map(function(d2) {
+                return d2[0];
+              }),
+              gdColumnsOriginalOrder: headerValues.map(function(d2) {
+                return d2[0];
+              }),
+              prevPages: [0, 0],
+              scrollbarState: { scrollbarScrollInProgress: false },
+              columns: headerValues.map(function(label, i2) {
+                var foundKey = uniqueKeys[label];
+                uniqueKeys[label] = (foundKey || 0) + 1;
+                var key = label + "__" + uniqueKeys[label];
+                return {
+                  key,
+                  label,
+                  specIndex: i2,
+                  xIndex: columnOrder[i2],
+                  xScale,
+                  x: void 0,
+                  // initialized below
+                  calcdata: void 0,
+                  // initialized below
+                  columnWidth: columnWidths[i2]
+                };
+              })
+            };
+            calcdata.columns.forEach(function(col) {
+              col.calcdata = calcdata;
+              col.x = xScale(col);
+            });
+            return calcdata;
+          };
+          function arrayMax(maybeArray) {
+            if (isArrayOrTypedArray(maybeArray)) {
+              var max = 0;
+              for (var i2 = 0; i2 < maybeArray.length; i2++) {
+                max = Math.max(max, arrayMax(maybeArray[i2]));
+              }
+              return max;
+            }
+            return maybeArray;
+          }
+          function sum(a2, b2) {
+            return a2 + b2;
+          }
+          function squareStringMatrix(matrixIn) {
+            var matrix = matrixIn.slice();
+            var minLen = Infinity;
+            var maxLen = 0;
+            var i2;
+            for (i2 = 0; i2 < matrix.length; i2++) {
+              if (isTypedArray2(matrix[i2])) matrix[i2] = Array.from(matrix[i2]);
+              else if (!isArrayOrTypedArray(matrix[i2])) matrix[i2] = [matrix[i2]];
+              minLen = Math.min(minLen, matrix[i2].length);
+              maxLen = Math.max(maxLen, matrix[i2].length);
+            }
+            if (minLen !== maxLen) {
+              for (i2 = 0; i2 < matrix.length; i2++) {
+                var padLen = maxLen - matrix[i2].length;
+                if (padLen) matrix[i2] = matrix[i2].concat(emptyStrings(padLen));
+              }
+            }
+            return matrix;
+          }
+          function emptyStrings(len2) {
+            var padArray2 = new Array(len2);
+            for (var j2 = 0; j2 < len2; j2++) padArray2[j2] = "";
+            return padArray2;
+          }
+          function xScale(d2) {
+            return d2.calcdata.columns.reduce(function(prev, next) {
+              return next.xIndex < d2.xIndex ? prev + next.columnWidth : prev;
+            }, 0);
+          }
+          function makeRowBlock(anchorToRowBlock, auxiliary) {
+            var blockAnchorKeys = Object.keys(anchorToRowBlock);
+            return blockAnchorKeys.map(function(k2) {
+              return extendFlat({}, anchorToRowBlock[k2], { auxiliaryBlocks: auxiliary });
+            });
+          }
+          function makeAnchorToRowBlock(rowHeights, minimumFillHeight) {
+            var anchorToRowBlock = {};
+            var currentRowHeight;
+            var currentAnchor = 0;
+            var currentBlockHeight = 0;
+            var currentBlock = makeIdentity();
+            var currentFirstRowIndex = 0;
+            var blockCounter = 0;
+            for (var i2 = 0; i2 < rowHeights.length; i2++) {
+              currentRowHeight = rowHeights[i2];
+              currentBlock.rows.push({
+                rowIndex: i2,
+                rowHeight: currentRowHeight
+              });
+              currentBlockHeight += currentRowHeight;
+              if (currentBlockHeight >= minimumFillHeight || i2 === rowHeights.length - 1) {
+                anchorToRowBlock[currentAnchor] = currentBlock;
+                currentBlock.key = blockCounter++;
+                currentBlock.firstRowIndex = currentFirstRowIndex;
+                currentBlock.lastRowIndex = i2;
+                currentBlock = makeIdentity();
+                currentAnchor += currentBlockHeight;
+                currentFirstRowIndex = i2 + 1;
+                currentBlockHeight = 0;
+              }
+            }
+            return anchorToRowBlock;
+          }
+          function makeIdentity() {
+            return {
+              firstRowIndex: null,
+              lastRowIndex: null,
+              rows: []
+            };
+          }
+        }
+      });
+      var require_data_split_helpers = __commonJS({
+        "src/traces/table/data_split_helpers.js"(exports) {
+          var extendFlat = require_extend().extendFlat;
+          exports.splitToPanels = function(d2) {
+            var prevPages = [0, 0];
+            var headerPanel = extendFlat({}, d2, {
+              key: "header",
+              type: "header",
+              page: 0,
+              prevPages,
+              currentRepaint: [null, null],
+              dragHandle: true,
+              values: d2.calcdata.headerCells.values[d2.specIndex],
+              rowBlocks: d2.calcdata.headerRowBlocks,
+              calcdata: extendFlat({}, d2.calcdata, { cells: d2.calcdata.headerCells })
+            });
+            var revolverPanel1 = extendFlat({}, d2, {
+              key: "cells1",
+              type: "cells",
+              page: 0,
+              prevPages,
+              currentRepaint: [null, null],
+              dragHandle: false,
+              values: d2.calcdata.cells.values[d2.specIndex],
+              rowBlocks: d2.calcdata.rowBlocks
+            });
+            var revolverPanel2 = extendFlat({}, d2, {
+              key: "cells2",
+              type: "cells",
+              page: 1,
+              prevPages,
+              currentRepaint: [null, null],
+              dragHandle: false,
+              values: d2.calcdata.cells.values[d2.specIndex],
+              rowBlocks: d2.calcdata.rowBlocks
+            });
+            return [revolverPanel1, revolverPanel2, headerPanel];
+          };
+          exports.splitToCells = function(d2) {
+            var fromTo = rowFromTo(d2);
+            return (d2.values || []).slice(fromTo[0], fromTo[1]).map(function(v2, i2) {
+              var buster = typeof v2 === "string" && v2.match(/[<$&> ]/) ? "_keybuster_" + Math.random() : "";
+              return {
+                // keyWithinBlock: /*fromTo[0] + */i, // optimized future version - no busting
+                // keyWithinBlock: fromTo[0] + i, // initial always-unoptimized version - janky scrolling with 5+ columns
+                keyWithinBlock: i2 + buster,
+                // current compromise: regular content is very fast; async content is possible
+                key: fromTo[0] + i2,
+                column: d2,
+                calcdata: d2.calcdata,
+                page: d2.page,
+                rowBlocks: d2.rowBlocks,
+                value: v2
+              };
+            });
+          };
+          function rowFromTo(d2) {
+            var rowBlock = d2.rowBlocks[d2.page];
+            var rowFrom = rowBlock ? rowBlock.rows[0].rowIndex : 0;
+            var rowTo = rowBlock ? rowFrom + rowBlock.rows.length : 0;
+            return [rowFrom, rowTo];
+          }
+        }
+      });
+      var require_plot31 = __commonJS({
+        "src/traces/table/plot.js"(exports, module2) {
+          var c2 = require_constants31();
+          var d3 = require_d3();
+          var Lib = require_lib();
+          var numberFormat = Lib.numberFormat;
+          var gup = require_gup();
+          var Drawing = require_drawing();
+          var svgUtil = require_svg_text_utils();
+          var raiseToTop = require_lib().raiseToTop;
+          var strTranslate = require_lib().strTranslate;
+          var cancelEeaseColumn = require_lib().cancelTransition;
+          var prepareData = require_data_preparation_helper();
+          var splitData = require_data_split_helpers();
+          var Color2 = require_color();
+          module2.exports = function plot(gd2, wrappedTraceHolders) {
+            var dynamic = !gd2._context.staticPlot;
+            var table = gd2._fullLayout._paper.selectAll("." + c2.cn.table).data(wrappedTraceHolders.map(function(wrappedTraceHolder) {
+              var traceHolder = gup.unwrap(wrappedTraceHolder);
+              var trace = traceHolder.trace;
+              return prepareData(gd2, trace);
+            }), gup.keyFun);
+            table.exit().remove();
+            table.enter().append("g").classed(c2.cn.table, true).attr("overflow", "visible").style("box-sizing", "content-box").style("position", "absolute").style("left", 0).style("overflow", "visible").style("shape-rendering", "crispEdges").style("pointer-events", "all");
+            table.attr("width", function(d2) {
+              return d2.width + d2.size.l + d2.size.r;
+            }).attr("height", function(d2) {
+              return d2.height + d2.size.t + d2.size.b;
+            }).attr("transform", function(d2) {
+              return strTranslate(d2.translateX, d2.translateY);
+            });
+            var tableControlView = table.selectAll("." + c2.cn.tableControlView).data(gup.repeat, gup.keyFun);
+            var cvEnter = tableControlView.enter().append("g").classed(c2.cn.tableControlView, true).style("box-sizing", "content-box");
+            if (dynamic) {
+              var wheelEvent = "onwheel" in document ? "wheel" : "mousewheel";
+              cvEnter.on("mousemove", function(d2) {
+                tableControlView.filter(function(dd2) {
+                  return d2 === dd2;
+                }).call(renderScrollbarKit, gd2);
+              }).on(wheelEvent, function(d2) {
+                if (d2.scrollbarState.wheeling) return;
+                d2.scrollbarState.wheeling = true;
+                var newY = d2.scrollY + d3.event.deltaY;
+                var noChange = makeDragRow(gd2, tableControlView, null, newY)(d2);
+                if (!noChange) {
+                  d3.event.stopPropagation();
+                  d3.event.preventDefault();
+                }
+                d2.scrollbarState.wheeling = false;
+              }).call(renderScrollbarKit, gd2, true);
+            }
+            tableControlView.attr("transform", function(d2) {
+              return strTranslate(d2.size.l, d2.size.t);
+            });
+            var scrollBackground = tableControlView.selectAll("." + c2.cn.scrollBackground).data(gup.repeat, gup.keyFun);
+            scrollBackground.enter().append("rect").classed(c2.cn.scrollBackground, true).attr("fill", "none");
+            scrollBackground.attr("width", function(d2) {
+              return d2.width;
+            }).attr("height", function(d2) {
+              return d2.height;
+            });
+            tableControlView.each(function(d2) {
+              Drawing.setClipUrl(d3.select(this), scrollAreaBottomClipKey(gd2, d2), gd2);
+            });
+            var yColumn = tableControlView.selectAll("." + c2.cn.yColumn).data(function(vm) {
+              return vm.columns;
+            }, gup.keyFun);
+            yColumn.enter().append("g").classed(c2.cn.yColumn, true);
+            yColumn.exit().remove();
+            yColumn.attr("transform", function(d2) {
+              return strTranslate(d2.x, 0);
+            });
+            if (dynamic) {
+              yColumn.call(
+                d3.behavior.drag().origin(function(d2) {
+                  var movedColumn = d3.select(this);
+                  easeColumn(movedColumn, d2, -c2.uplift);
+                  raiseToTop(this);
+                  d2.calcdata.columnDragInProgress = true;
+                  renderScrollbarKit(tableControlView.filter(function(dd2) {
+                    return d2.calcdata.key === dd2.key;
+                  }), gd2);
+                  return d2;
+                }).on("drag", function(d2) {
+                  var movedColumn = d3.select(this);
+                  var getter = function(dd2) {
+                    return (d2 === dd2 ? d3.event.x : dd2.x) + dd2.columnWidth / 2;
+                  };
+                  d2.x = Math.max(-c2.overdrag, Math.min(d2.calcdata.width + c2.overdrag - d2.columnWidth, d3.event.x));
+                  var sortableColumns = flatData(yColumn).filter(function(dd2) {
+                    return dd2.calcdata.key === d2.calcdata.key;
+                  });
+                  var newOrder = sortableColumns.sort(function(a2, b2) {
+                    return getter(a2) - getter(b2);
+                  });
+                  newOrder.forEach(function(dd2, i2) {
+                    dd2.xIndex = i2;
+                    dd2.x = d2 === dd2 ? dd2.x : dd2.xScale(dd2);
+                  });
+                  yColumn.filter(function(dd2) {
+                    return d2 !== dd2;
+                  }).transition().ease(c2.transitionEase).duration(c2.transitionDuration).attr("transform", function(d22) {
+                    return strTranslate(d22.x, 0);
+                  });
+                  movedColumn.call(cancelEeaseColumn).attr("transform", strTranslate(d2.x, -c2.uplift));
+                }).on("dragend", function(d2) {
+                  var movedColumn = d3.select(this);
+                  var p2 = d2.calcdata;
+                  d2.x = d2.xScale(d2);
+                  d2.calcdata.columnDragInProgress = false;
+                  easeColumn(movedColumn, d2, 0);
+                  columnMoved(gd2, p2, p2.columns.map(function(dd2) {
+                    return dd2.xIndex;
+                  }));
+                })
+              );
+            }
+            yColumn.each(function(d2) {
+              Drawing.setClipUrl(d3.select(this), columnBoundaryClipKey(gd2, d2), gd2);
+            });
+            var columnBlock = yColumn.selectAll("." + c2.cn.columnBlock).data(splitData.splitToPanels, gup.keyFun);
+            columnBlock.enter().append("g").classed(c2.cn.columnBlock, true).attr("id", function(d2) {
+              return d2.key;
+            });
+            columnBlock.style("cursor", function(d2) {
+              return d2.dragHandle ? "ew-resize" : d2.calcdata.scrollbarState.barWiggleRoom ? "ns-resize" : "default";
+            });
+            var headerColumnBlock = columnBlock.filter(headerBlock);
+            var cellsColumnBlock = columnBlock.filter(cellsBlock);
+            if (dynamic) {
+              cellsColumnBlock.call(
+                d3.behavior.drag().origin(function(d2) {
+                  d3.event.stopPropagation();
+                  return d2;
+                }).on("drag", makeDragRow(gd2, tableControlView, -1)).on("dragend", function() {
+                })
+              );
+            }
+            renderColumnCellTree(gd2, tableControlView, headerColumnBlock, columnBlock);
+            renderColumnCellTree(gd2, tableControlView, cellsColumnBlock, columnBlock);
+            var scrollAreaClip = tableControlView.selectAll("." + c2.cn.scrollAreaClip).data(gup.repeat, gup.keyFun);
+            scrollAreaClip.enter().append("clipPath").classed(c2.cn.scrollAreaClip, true).attr("id", function(d2) {
+              return scrollAreaBottomClipKey(gd2, d2);
+            });
+            var scrollAreaClipRect = scrollAreaClip.selectAll("." + c2.cn.scrollAreaClipRect).data(gup.repeat, gup.keyFun);
+            scrollAreaClipRect.enter().append("rect").classed(c2.cn.scrollAreaClipRect, true).attr("x", -c2.overdrag).attr("y", -c2.uplift).attr("fill", "none");
+            scrollAreaClipRect.attr("width", function(d2) {
+              return d2.width + 2 * c2.overdrag;
+            }).attr("height", function(d2) {
+              return d2.height + c2.uplift;
+            });
+            var columnBoundary = yColumn.selectAll("." + c2.cn.columnBoundary).data(gup.repeat, gup.keyFun);
+            columnBoundary.enter().append("g").classed(c2.cn.columnBoundary, true);
+            var columnBoundaryClippath = yColumn.selectAll("." + c2.cn.columnBoundaryClippath).data(gup.repeat, gup.keyFun);
+            columnBoundaryClippath.enter().append("clipPath").classed(c2.cn.columnBoundaryClippath, true);
+            columnBoundaryClippath.attr("id", function(d2) {
+              return columnBoundaryClipKey(gd2, d2);
+            });
+            var columnBoundaryRect = columnBoundaryClippath.selectAll("." + c2.cn.columnBoundaryRect).data(gup.repeat, gup.keyFun);
+            columnBoundaryRect.enter().append("rect").classed(c2.cn.columnBoundaryRect, true).attr("fill", "none");
+            columnBoundaryRect.attr("width", function(d2) {
+              return d2.columnWidth + 2 * roundHalfWidth(d2);
+            }).attr("height", function(d2) {
+              return d2.calcdata.height + 2 * roundHalfWidth(d2) + c2.uplift;
+            }).attr("x", function(d2) {
+              return -roundHalfWidth(d2);
+            }).attr("y", function(d2) {
+              return -roundHalfWidth(d2);
+            });
+            updateBlockYPosition(null, cellsColumnBlock, tableControlView);
+          };
+          function roundHalfWidth(d2) {
+            return Math.ceil(d2.calcdata.maxLineWidth / 2);
+          }
+          function scrollAreaBottomClipKey(gd2, d2) {
+            return "clip" + gd2._fullLayout._uid + "_scrollAreaBottomClip_" + d2.key;
+          }
+          function columnBoundaryClipKey(gd2, d2) {
+            return "clip" + gd2._fullLayout._uid + "_columnBoundaryClippath_" + d2.calcdata.key + "_" + d2.specIndex;
+          }
+          function flatData(selection) {
+            return [].concat.apply([], selection.map(function(g2) {
+              return g2;
+            })).map(function(g2) {
+              return g2.__data__;
+            });
+          }
+          function renderScrollbarKit(tableControlView, gd2, bypassVisibleBar) {
+            function calcTotalHeight(d2) {
+              var blocks = d2.rowBlocks;
+              return firstRowAnchor(blocks, blocks.length - 1) + (blocks.length ? rowsHeight(blocks[blocks.length - 1], Infinity) : 1);
+            }
+            var scrollbarKit = tableControlView.selectAll("." + c2.cn.scrollbarKit).data(gup.repeat, gup.keyFun);
+            scrollbarKit.enter().append("g").classed(c2.cn.scrollbarKit, true).style("shape-rendering", "geometricPrecision");
+            scrollbarKit.each(function(d2) {
+              var s2 = d2.scrollbarState;
+              s2.totalHeight = calcTotalHeight(d2);
+              s2.scrollableAreaHeight = d2.groupHeight - headerHeight(d2);
+              s2.currentlyVisibleHeight = Math.min(s2.totalHeight, s2.scrollableAreaHeight);
+              s2.ratio = s2.currentlyVisibleHeight / s2.totalHeight;
+              s2.barLength = Math.max(s2.ratio * s2.currentlyVisibleHeight, c2.goldenRatio * c2.scrollbarWidth);
+              s2.barWiggleRoom = s2.currentlyVisibleHeight - s2.barLength;
+              s2.wiggleRoom = Math.max(0, s2.totalHeight - s2.scrollableAreaHeight);
+              s2.topY = s2.barWiggleRoom === 0 ? 0 : d2.scrollY / s2.wiggleRoom * s2.barWiggleRoom;
+              s2.bottomY = s2.topY + s2.barLength;
+              s2.dragMultiplier = s2.wiggleRoom / s2.barWiggleRoom;
+            }).attr("transform", function(d2) {
+              var xPosition2 = d2.width + c2.scrollbarWidth / 2 + c2.scrollbarOffset;
+              return strTranslate(xPosition2, headerHeight(d2));
+            });
+            var scrollbar = scrollbarKit.selectAll("." + c2.cn.scrollbar).data(gup.repeat, gup.keyFun);
+            scrollbar.enter().append("g").classed(c2.cn.scrollbar, true);
+            var scrollbarSlider = scrollbar.selectAll("." + c2.cn.scrollbarSlider).data(gup.repeat, gup.keyFun);
+            scrollbarSlider.enter().append("g").classed(c2.cn.scrollbarSlider, true);
+            scrollbarSlider.attr("transform", function(d2) {
+              return strTranslate(0, d2.scrollbarState.topY || 0);
+            });
+            var scrollbarGlyph = scrollbarSlider.selectAll("." + c2.cn.scrollbarGlyph).data(gup.repeat, gup.keyFun);
+            scrollbarGlyph.enter().append("line").classed(c2.cn.scrollbarGlyph, true).attr("stroke", "black").attr("stroke-width", c2.scrollbarWidth).attr("stroke-linecap", "round").attr("y1", c2.scrollbarWidth / 2);
+            scrollbarGlyph.attr("y2", function(d2) {
+              return d2.scrollbarState.barLength - c2.scrollbarWidth / 2;
+            }).attr("stroke-opacity", function(d2) {
+              return d2.columnDragInProgress || !d2.scrollbarState.barWiggleRoom || bypassVisibleBar ? 0 : 0.4;
+            });
+            scrollbarGlyph.transition().delay(0).duration(0);
+            scrollbarGlyph.transition().delay(c2.scrollbarHideDelay).duration(c2.scrollbarHideDuration).attr("stroke-opacity", 0);
+            var scrollbarCaptureZone = scrollbar.selectAll("." + c2.cn.scrollbarCaptureZone).data(gup.repeat, gup.keyFun);
+            scrollbarCaptureZone.enter().append("line").classed(c2.cn.scrollbarCaptureZone, true).attr("stroke", "white").attr("stroke-opacity", 0.01).attr("stroke-width", c2.scrollbarCaptureWidth).attr("stroke-linecap", "butt").attr("y1", 0).on("mousedown", function(d2) {
+              var y2 = d3.event.y;
+              var bbox = this.getBoundingClientRect();
+              var s2 = d2.scrollbarState;
+              var pixelVal = y2 - bbox.top;
+              var inverseScale = d3.scale.linear().domain([0, s2.scrollableAreaHeight]).range([0, s2.totalHeight]).clamp(true);
+              if (!(s2.topY <= pixelVal && pixelVal <= s2.bottomY)) {
+                makeDragRow(gd2, tableControlView, null, inverseScale(pixelVal - s2.barLength / 2))(d2);
+              }
+            }).call(
+              d3.behavior.drag().origin(function(d2) {
+                d3.event.stopPropagation();
+                d2.scrollbarState.scrollbarScrollInProgress = true;
+                return d2;
+              }).on("drag", makeDragRow(gd2, tableControlView)).on("dragend", function() {
+              })
+            );
+            scrollbarCaptureZone.attr("y2", function(d2) {
+              return d2.scrollbarState.scrollableAreaHeight;
+            });
+            if (gd2._context.staticPlot) {
+              scrollbarGlyph.remove();
+              scrollbarCaptureZone.remove();
+            }
+          }
+          function renderColumnCellTree(gd2, tableControlView, columnBlock, allColumnBlock) {
+            var columnCells = renderColumnCells(columnBlock);
+            var columnCell = renderColumnCell(columnCells);
+            supplyStylingValues(columnCell);
+            var cellRect = renderCellRect(columnCell);
+            sizeAndStyleRect(cellRect);
+            var cellTextHolder = renderCellTextHolder(columnCell);
+            var cellText = renderCellText(cellTextHolder);
+            setFont(cellText);
+            populateCellText(cellText, tableControlView, allColumnBlock, gd2);
+            setCellHeightAndPositionY(columnCell);
+          }
+          function renderColumnCells(columnBlock) {
+            var columnCells = columnBlock.selectAll("." + c2.cn.columnCells).data(gup.repeat, gup.keyFun);
+            columnCells.enter().append("g").classed(c2.cn.columnCells, true);
+            columnCells.exit().remove();
+            return columnCells;
+          }
+          function renderColumnCell(columnCells) {
+            var columnCell = columnCells.selectAll("." + c2.cn.columnCell).data(splitData.splitToCells, function(d2) {
+              return d2.keyWithinBlock;
+            });
+            columnCell.enter().append("g").classed(c2.cn.columnCell, true);
+            columnCell.exit().remove();
+            return columnCell;
+          }
+          function renderCellRect(columnCell) {
+            var cellRect = columnCell.selectAll("." + c2.cn.cellRect).data(gup.repeat, function(d2) {
+              return d2.keyWithinBlock;
+            });
+            cellRect.enter().append("rect").classed(c2.cn.cellRect, true);
+            return cellRect;
+          }
+          function renderCellText(cellTextHolder) {
+            var cellText = cellTextHolder.selectAll("." + c2.cn.cellText).data(gup.repeat, function(d2) {
+              return d2.keyWithinBlock;
+            });
+            cellText.enter().append("text").classed(c2.cn.cellText, true).style("cursor", function() {
+              return "auto";
+            }).on("mousedown", function() {
+              d3.event.stopPropagation();
+            });
+            return cellText;
+          }
+          function renderCellTextHolder(columnCell) {
+            var cellTextHolder = columnCell.selectAll("." + c2.cn.cellTextHolder).data(gup.repeat, function(d2) {
+              return d2.keyWithinBlock;
+            });
+            cellTextHolder.enter().append("g").classed(c2.cn.cellTextHolder, true).style("shape-rendering", "geometricPrecision");
+            return cellTextHolder;
+          }
+          function supplyStylingValues(columnCell) {
+            columnCell.each(function(d2, i2) {
+              var spec = d2.calcdata.cells.font;
+              var col = d2.column.specIndex;
+              var font = {
+                size: gridPick(spec.size, col, i2),
+                color: gridPick(spec.color, col, i2),
+                family: gridPick(spec.family, col, i2),
+                weight: gridPick(spec.weight, col, i2),
+                style: gridPick(spec.style, col, i2),
+                variant: gridPick(spec.variant, col, i2),
+                textcase: gridPick(spec.textcase, col, i2),
+                lineposition: gridPick(spec.lineposition, col, i2),
+                shadow: gridPick(spec.shadow, col, i2)
+              };
+              d2.rowNumber = d2.key;
+              d2.align = gridPick(d2.calcdata.cells.align, col, i2);
+              d2.cellBorderWidth = gridPick(d2.calcdata.cells.line.width, col, i2);
+              d2.font = font;
+            });
+          }
+          function setFont(cellText) {
+            cellText.each(function(d2) {
+              Drawing.font(d3.select(this), d2.font);
+            });
+          }
+          function sizeAndStyleRect(cellRect) {
+            cellRect.attr("width", function(d2) {
+              return d2.column.columnWidth;
+            }).attr("stroke-width", function(d2) {
+              return d2.cellBorderWidth;
+            }).each(function(d2) {
+              var atomicSelection = d3.select(this);
+              Color2.stroke(atomicSelection, gridPick(d2.calcdata.cells.line.color, d2.column.specIndex, d2.rowNumber));
+              Color2.fill(atomicSelection, gridPick(d2.calcdata.cells.fill.color, d2.column.specIndex, d2.rowNumber));
+            });
+          }
+          function populateCellText(cellText, tableControlView, allColumnBlock, gd2) {
+            cellText.text(function(d2) {
+              var col = d2.column.specIndex;
+              var row = d2.rowNumber;
+              var userSuppliedContent = d2.value;
+              var stringSupplied = typeof userSuppliedContent === "string";
+              var hasBreaks = stringSupplied && userSuppliedContent.match(/<br>/i);
+              var userBrokenText = !stringSupplied || hasBreaks;
+              d2.mayHaveMarkup = stringSupplied && userSuppliedContent.match(/[<&>]/);
+              var latex = isLatex(userSuppliedContent);
+              d2.latex = latex;
+              var prefix = latex ? "" : gridPick(d2.calcdata.cells.prefix, col, row) || "";
+              var suffix = latex ? "" : gridPick(d2.calcdata.cells.suffix, col, row) || "";
+              var format = latex ? null : gridPick(d2.calcdata.cells.format, col, row) || null;
+              var prefixSuffixedText = prefix + (format ? numberFormat(format)(d2.value) : d2.value) + suffix;
+              var hasWrapSplitCharacter;
+              d2.wrappingNeeded = !d2.wrapped && !userBrokenText && !latex && (hasWrapSplitCharacter = hasWrapCharacter(prefixSuffixedText));
+              d2.cellHeightMayIncrease = hasBreaks || latex || d2.mayHaveMarkup || (hasWrapSplitCharacter === void 0 ? hasWrapCharacter(prefixSuffixedText) : hasWrapSplitCharacter);
+              d2.needsConvertToTspans = d2.mayHaveMarkup || d2.wrappingNeeded || d2.latex;
+              var textToRender;
+              if (d2.wrappingNeeded) {
+                var hrefPreservedText = c2.wrapSplitCharacter === " " ? prefixSuffixedText.replace(/<a href=/ig, "<a_href=") : prefixSuffixedText;
+                var fragments2 = hrefPreservedText.split(c2.wrapSplitCharacter);
+                var hrefRestoredFragments = c2.wrapSplitCharacter === " " ? fragments2.map(function(frag) {
+                  return frag.replace(/<a_href=/ig, "<a href=");
+                }) : fragments2;
+                d2.fragments = hrefRestoredFragments.map(function(f2) {
+                  return { text: f2, width: null };
+                });
+                d2.fragments.push({ fragment: c2.wrapSpacer, width: null });
+                textToRender = hrefRestoredFragments.join(c2.lineBreaker) + c2.lineBreaker + c2.wrapSpacer;
+              } else {
+                delete d2.fragments;
+                textToRender = prefixSuffixedText;
+              }
+              return textToRender;
+            }).attr("dy", function(d2) {
+              return d2.needsConvertToTspans ? 0 : "0.75em";
+            }).each(function(d2) {
+              var element = this;
+              var selection = d3.select(element);
+              var renderCallback = d2.wrappingNeeded ? wrapTextMaker : updateYPositionMaker;
+              if (d2.needsConvertToTspans) {
+                svgUtil.convertToTspans(selection, gd2, renderCallback(allColumnBlock, element, tableControlView, gd2, d2));
+              } else {
+                d3.select(element.parentNode).attr("transform", function(d22) {
+                  return strTranslate(xPosition(d22), c2.cellPad);
+                }).attr("text-anchor", function(d22) {
+                  return {
+                    left: "start",
+                    center: "middle",
+                    right: "end"
+                  }[d22.align];
+                });
+              }
+            });
+          }
+          function isLatex(content) {
+            return typeof content === "string" && content.match(c2.latexCheck);
+          }
+          function hasWrapCharacter(text) {
+            return text.indexOf(c2.wrapSplitCharacter) !== -1;
+          }
+          function columnMoved(gd2, calcdata, indices) {
+            var o2 = calcdata.gdColumnsOriginalOrder;
+            calcdata.gdColumns.sort(function(a2, b2) {
+              return indices[o2.indexOf(a2)] - indices[o2.indexOf(b2)];
+            });
+            calcdata.columnorder = indices;
+            gd2.emit("plotly_restyle");
+          }
+          function gridPick(spec, col, row) {
+            if (Lib.isArrayOrTypedArray(spec)) {
+              var column = spec[Math.min(col, spec.length - 1)];
+              if (Lib.isArrayOrTypedArray(column)) {
+                return column[Math.min(row, column.length - 1)];
+              } else {
+                return column;
+              }
+            } else {
+              return spec;
+            }
+          }
+          function easeColumn(selection, d2, y2) {
+            selection.transition().ease(c2.releaseTransitionEase).duration(c2.releaseTransitionDuration).attr("transform", strTranslate(d2.x, y2));
+          }
+          function cellsBlock(d2) {
+            return d2.type === "cells";
+          }
+          function headerBlock(d2) {
+            return d2.type === "header";
+          }
+          function headerHeight(d2) {
+            var headerBlocks = d2.rowBlocks.length ? d2.rowBlocks[0].auxiliaryBlocks : [];
+            return headerBlocks.reduce(function(p2, n2) {
+              return p2 + rowsHeight(n2, Infinity);
+            }, 0);
+          }
+          function findPagesAndCacheHeights(blocks, scrollY, scrollHeight) {
+            var pages = [];
+            var pTop = 0;
+            for (var blockIndex = 0; blockIndex < blocks.length; blockIndex++) {
+              var block = blocks[blockIndex];
+              var blockRows = block.rows;
+              var rowsHeight2 = 0;
+              for (var i2 = 0; i2 < blockRows.length; i2++) {
+                rowsHeight2 += blockRows[i2].rowHeight;
+              }
+              block.allRowsHeight = rowsHeight2;
+              var pBottom = pTop + rowsHeight2;
+              var windowTop = scrollY;
+              var windowBottom = windowTop + scrollHeight;
+              if (windowTop < pBottom && windowBottom > pTop) {
+                pages.push(blockIndex);
+              }
+              pTop += rowsHeight2;
+            }
+            return pages;
+          }
+          function updateBlockYPosition(gd2, cellsColumnBlock, tableControlView) {
+            var d2 = flatData(cellsColumnBlock)[0];
+            if (d2 === void 0) return;
+            var blocks = d2.rowBlocks;
+            var calcdata = d2.calcdata;
+            var bottom = firstRowAnchor(blocks, blocks.length);
+            var scrollHeight = d2.calcdata.groupHeight - headerHeight(d2);
+            var scrollY = calcdata.scrollY = Math.max(0, Math.min(bottom - scrollHeight, calcdata.scrollY));
+            var pages = findPagesAndCacheHeights(blocks, scrollY, scrollHeight);
+            if (pages.length === 1) {
+              if (pages[0] === blocks.length - 1) {
+                pages.unshift(pages[0] - 1);
+              } else {
+                pages.push(pages[0] + 1);
+              }
+            }
+            if (pages[0] % 2) {
+              pages.reverse();
+            }
+            cellsColumnBlock.each(function(d22, i2) {
+              d22.page = pages[i2];
+              d22.scrollY = scrollY;
+            });
+            cellsColumnBlock.attr("transform", function(d22) {
+              var yTranslate = firstRowAnchor(d22.rowBlocks, d22.page) - d22.scrollY;
+              return strTranslate(0, yTranslate);
+            });
+            if (gd2) {
+              conditionalPanelRerender(gd2, tableControlView, cellsColumnBlock, pages, d2.prevPages, d2, 0);
+              conditionalPanelRerender(gd2, tableControlView, cellsColumnBlock, pages, d2.prevPages, d2, 1);
+              renderScrollbarKit(tableControlView, gd2);
+            }
+          }
+          function makeDragRow(gd2, allTableControlView, optionalMultiplier, optionalPosition) {
+            return function dragRow(eventD) {
+              var d2 = eventD.calcdata ? eventD.calcdata : eventD;
+              var tableControlView = allTableControlView.filter(function(dd2) {
+                return d2.key === dd2.key;
+              });
+              var multiplier = optionalMultiplier || d2.scrollbarState.dragMultiplier;
+              var initialScrollY = d2.scrollY;
+              d2.scrollY = optionalPosition === void 0 ? d2.scrollY + multiplier * d3.event.dy : optionalPosition;
+              var cellsColumnBlock = tableControlView.selectAll("." + c2.cn.yColumn).selectAll("." + c2.cn.columnBlock).filter(cellsBlock);
+              updateBlockYPosition(gd2, cellsColumnBlock, tableControlView);
+              return d2.scrollY === initialScrollY;
+            };
+          }
+          function conditionalPanelRerender(gd2, tableControlView, cellsColumnBlock, pages, prevPages, d2, revolverIndex) {
+            var shouldComponentUpdate = pages[revolverIndex] !== prevPages[revolverIndex];
+            if (shouldComponentUpdate) {
+              clearTimeout(d2.currentRepaint[revolverIndex]);
+              d2.currentRepaint[revolverIndex] = setTimeout(function() {
+                var toRerender = cellsColumnBlock.filter(function(d22, i2) {
+                  return i2 === revolverIndex && pages[i2] !== prevPages[i2];
+                });
+                renderColumnCellTree(gd2, tableControlView, toRerender, cellsColumnBlock);
+                prevPages[revolverIndex] = pages[revolverIndex];
+              });
+            }
+          }
+          function wrapTextMaker(columnBlock, element, tableControlView, gd2) {
+            return function wrapText() {
+              var cellTextHolder = d3.select(element.parentNode);
+              cellTextHolder.each(function(d2) {
+                var fragments2 = d2.fragments;
+                cellTextHolder.selectAll("tspan.line").each(function(dd2, i2) {
+                  fragments2[i2].width = this.getComputedTextLength();
+                });
+                var separatorLength = fragments2[fragments2.length - 1].width;
+                var rest = fragments2.slice(0, -1);
+                var currentRow = [];
+                var currentAddition, currentAdditionLength;
+                var currentRowLength = 0;
+                var rowLengthLimit = d2.column.columnWidth - 2 * c2.cellPad;
+                d2.value = "";
+                while (rest.length) {
+                  currentAddition = rest.shift();
+                  currentAdditionLength = currentAddition.width + separatorLength;
+                  if (currentRowLength + currentAdditionLength > rowLengthLimit) {
+                    d2.value += currentRow.join(c2.wrapSpacer) + c2.lineBreaker;
+                    currentRow = [];
+                    currentRowLength = 0;
+                  }
+                  currentRow.push(currentAddition.text);
+                  currentRowLength += currentAdditionLength;
+                }
+                if (currentRowLength) {
+                  d2.value += currentRow.join(c2.wrapSpacer);
+                }
+                d2.wrapped = true;
+              });
+              cellTextHolder.selectAll("tspan.line").remove();
+              populateCellText(cellTextHolder.select("." + c2.cn.cellText), tableControlView, columnBlock, gd2);
+              d3.select(element.parentNode.parentNode).call(setCellHeightAndPositionY);
+            };
+          }
+          function updateYPositionMaker(columnBlock, element, tableControlView, gd2, d2) {
+            return function updateYPosition() {
+              if (d2.settledY) return;
+              var cellTextHolder = d3.select(element.parentNode);
+              var l2 = getBlock(d2);
+              var rowIndex = d2.key - l2.firstRowIndex;
+              var declaredRowHeight = l2.rows[rowIndex].rowHeight;
+              var requiredHeight = d2.cellHeightMayIncrease ? element.parentNode.getBoundingClientRect().height + 2 * c2.cellPad : declaredRowHeight;
+              var finalHeight = Math.max(requiredHeight, declaredRowHeight);
+              var increase = finalHeight - l2.rows[rowIndex].rowHeight;
+              if (increase) {
+                l2.rows[rowIndex].rowHeight = finalHeight;
+                columnBlock.selectAll("." + c2.cn.columnCell).call(setCellHeightAndPositionY);
+                updateBlockYPosition(null, columnBlock.filter(cellsBlock), 0);
+                renderScrollbarKit(tableControlView, gd2, true);
+              }
+              cellTextHolder.attr("transform", function() {
+                var element2 = this;
+                var columnCellElement = element2.parentNode;
+                var box = columnCellElement.getBoundingClientRect();
+                var rectBox = d3.select(element2.parentNode).select("." + c2.cn.cellRect).node().getBoundingClientRect();
+                var currentTransform = element2.transform.baseVal.consolidate();
+                var yPosition = rectBox.top - box.top + (currentTransform ? currentTransform.matrix.f : c2.cellPad);
+                return strTranslate(xPosition(d2, d3.select(element2.parentNode).select("." + c2.cn.cellTextHolder).node().getBoundingClientRect().width), yPosition);
+              });
+              d2.settledY = true;
+            };
+          }
+          function xPosition(d2, optionalWidth) {
+            switch (d2.align) {
+              case "left":
+                return c2.cellPad;
+              case "right":
+                return d2.column.columnWidth - (optionalWidth || 0) - c2.cellPad;
+              case "center":
+                return (d2.column.columnWidth - (optionalWidth || 0)) / 2;
+              default:
+                return c2.cellPad;
+            }
+          }
+          function setCellHeightAndPositionY(columnCell) {
+            columnCell.attr("transform", function(d2) {
+              var headerHeight2 = d2.rowBlocks[0].auxiliaryBlocks.reduce(function(p2, n2) {
+                return p2 + rowsHeight(n2, Infinity);
+              }, 0);
+              var l2 = getBlock(d2);
+              var rowAnchor = rowsHeight(l2, d2.key);
+              var yOffset = rowAnchor + headerHeight2;
+              return strTranslate(0, yOffset);
+            }).selectAll("." + c2.cn.cellRect).attr("height", function(d2) {
+              return getRow(getBlock(d2), d2.key).rowHeight;
+            });
+          }
+          function firstRowAnchor(blocks, page) {
+            var total = 0;
+            for (var i2 = page - 1; i2 >= 0; i2--) {
+              total += allRowsHeight(blocks[i2]);
+            }
+            return total;
+          }
+          function rowsHeight(rowBlock, key) {
+            var total = 0;
+            for (var i2 = 0; i2 < rowBlock.rows.length && rowBlock.rows[i2].rowIndex < key; i2++) {
+              total += rowBlock.rows[i2].rowHeight;
+            }
+            return total;
+          }
+          function allRowsHeight(rowBlock) {
+            var cached = rowBlock.allRowsHeight;
+            if (cached !== void 0) {
+              return cached;
+            }
+            var total = 0;
+            for (var i2 = 0; i2 < rowBlock.rows.length; i2++) {
+              total += rowBlock.rows[i2].rowHeight;
+            }
+            rowBlock.allRowsHeight = total;
+            return total;
+          }
+          function getBlock(d2) {
+            return d2.rowBlocks[d2.page];
+          }
+          function getRow(l2, i2) {
+            return l2.rows[i2 - l2.firstRowIndex];
+          }
+        }
+      });
+      var require_base_plot11 = __commonJS({
+        "src/traces/table/base_plot.js"(exports) {
+          var getModuleCalcData = require_get_data().getModuleCalcData;
+          var tablePlot = require_plot31();
+          var TABLE = "table";
+          exports.name = TABLE;
+          exports.plot = function(gd2) {
+            var calcData = getModuleCalcData(gd2.calcdata, TABLE)[0];
+            if (calcData.length) tablePlot(gd2, calcData);
+          };
+          exports.clean = function(newFullData, newFullLayout, oldFullData, oldFullLayout) {
+            var hadTable = oldFullLayout._has && oldFullLayout._has(TABLE);
+            var hasTable = newFullLayout._has && newFullLayout._has(TABLE);
+            if (hadTable && !hasTable) {
+              oldFullLayout._paperdiv.selectAll(".table").remove();
+            }
+          };
+        }
+      });
+      var require_table = __commonJS({
+        "src/traces/table/index.js"(exports, module2) {
+          module2.exports = {
+            attributes: require_attributes62(),
+            supplyDefaults: require_defaults58(),
+            calc: require_calc37(),
+            plot: require_plot31(),
+            moduleType: "trace",
+            name: "table",
+            basePlotModule: require_base_plot11(),
+            categories: ["noOpacity"],
+            meta: {}
+          };
+        }
+      });
+      var require_table2 = __commonJS({
+        "lib/table.js"(exports, module2) {
+          module2.exports = require_table();
+        }
+      });
+      var require_axis_attributes2 = __commonJS({
+        "src/traces/carpet/axis_attributes.js"(exports, module2) {
+          var fontAttrs = require_font_attributes();
+          var colorAttrs = require_attributes3();
+          var axesAttrs = require_layout_attributes4();
+          var descriptionWithDates = require_axis_format_attributes().descriptionWithDates;
+          var overrideAll = require_edit_types().overrideAll;
+          var dash = require_attributes4().dash;
+          var extendFlat = require_extend().extendFlat;
+          module2.exports = {
+            color: {
+              valType: "color",
+              editType: "calc"
+            },
+            smoothing: {
+              valType: "number",
+              dflt: 1,
+              min: 0,
+              max: 1.3,
+              editType: "calc"
+            },
+            title: {
+              text: {
+                valType: "string",
+                dflt: "",
+                editType: "calc"
+              },
+              font: fontAttrs({
+                editType: "calc"
+              }),
+              // TODO how is this different than `title.standoff`
+              offset: {
+                valType: "number",
+                dflt: 10,
+                editType: "calc"
+              },
+              editType: "calc"
+            },
+            type: {
+              valType: "enumerated",
+              // '-' means we haven't yet run autotype or couldn't find any data
+              // it gets turned into linear in gd._fullLayout but not copied back
+              // to gd.data like the others are.
+              values: ["-", "linear", "date", "category"],
+              dflt: "-",
+              editType: "calc"
+            },
+            autotypenumbers: axesAttrs.autotypenumbers,
+            autorange: {
+              valType: "enumerated",
+              values: [true, false, "reversed"],
+              dflt: true,
+              editType: "calc"
+            },
+            rangemode: {
+              valType: "enumerated",
+              values: ["normal", "tozero", "nonnegative"],
+              dflt: "normal",
+              editType: "calc"
+            },
+            range: {
+              valType: "info_array",
+              editType: "calc",
+              items: [
+                { valType: "any", editType: "calc" },
+                { valType: "any", editType: "calc" }
+              ]
+            },
+            fixedrange: {
+              valType: "boolean",
+              dflt: false,
+              editType: "calc"
+            },
+            cheatertype: {
+              valType: "enumerated",
+              values: ["index", "value"],
+              dflt: "value",
+              editType: "calc"
+            },
+            tickmode: {
+              valType: "enumerated",
+              values: ["linear", "array"],
+              dflt: "array",
+              editType: "calc"
+            },
+            nticks: {
+              valType: "integer",
+              min: 0,
+              dflt: 0,
+              editType: "calc"
+            },
+            tickvals: {
+              valType: "data_array",
+              editType: "calc"
+            },
+            ticktext: {
+              valType: "data_array",
+              editType: "calc"
+            },
+            showticklabels: {
+              valType: "enumerated",
+              values: ["start", "end", "both", "none"],
+              dflt: "start",
+              editType: "calc"
+            },
+            labelalias: extendFlat({}, axesAttrs.labelalias, { editType: "calc" }),
+            tickfont: fontAttrs({
+              editType: "calc"
+            }),
+            tickangle: {
+              valType: "angle",
+              dflt: "auto",
+              editType: "calc"
+            },
+            tickprefix: {
+              valType: "string",
+              dflt: "",
+              editType: "calc"
+            },
+            showtickprefix: {
+              valType: "enumerated",
+              values: ["all", "first", "last", "none"],
+              dflt: "all",
+              editType: "calc"
+            },
+            ticksuffix: {
+              valType: "string",
+              dflt: "",
+              editType: "calc"
+            },
+            showticksuffix: {
+              valType: "enumerated",
+              values: ["all", "first", "last", "none"],
+              dflt: "all",
+              editType: "calc"
+            },
+            showexponent: {
+              valType: "enumerated",
+              values: ["all", "first", "last", "none"],
+              dflt: "all",
+              editType: "calc"
+            },
+            exponentformat: {
+              valType: "enumerated",
+              values: ["none", "e", "E", "power", "SI", "B", "SI extended"],
+              dflt: "B",
+              editType: "calc"
+            },
+            minexponent: {
+              valType: "number",
+              dflt: 3,
+              min: 0,
+              editType: "calc"
+            },
+            separatethousands: {
+              valType: "boolean",
+              dflt: false,
+              editType: "calc"
+            },
+            tickformat: {
+              valType: "string",
+              dflt: "",
+              editType: "calc",
+              description: descriptionWithDates("tick label")
+            },
+            tickformatstops: overrideAll(axesAttrs.tickformatstops, "calc", "from-root"),
+            categoryorder: {
+              valType: "enumerated",
+              values: [
+                "trace",
+                "category ascending",
+                "category descending",
+                "array"
+                /* , 'value ascending', 'value descending'*/
+                // value ascending / descending to be implemented later
+              ],
+              dflt: "trace",
+              editType: "calc"
+            },
+            categoryarray: {
+              valType: "data_array",
+              editType: "calc"
+            },
+            labelpadding: {
+              valType: "integer",
+              dflt: 10,
+              editType: "calc"
+            },
+            labelprefix: {
+              valType: "string",
+              editType: "calc"
+            },
+            labelsuffix: {
+              valType: "string",
+              dflt: "",
+              editType: "calc"
+            },
+            // lines and grids
+            showline: {
+              valType: "boolean",
+              dflt: false,
+              editType: "calc"
+            },
+            linecolor: {
+              valType: "color",
+              dflt: colorAttrs.defaultLine,
+              editType: "calc"
+            },
+            linewidth: {
+              valType: "number",
+              min: 0,
+              dflt: 1,
+              editType: "calc"
+            },
+            gridcolor: {
+              valType: "color",
+              editType: "calc"
+            },
+            gridwidth: {
+              valType: "number",
+              min: 0,
+              dflt: 1,
+              editType: "calc"
+            },
+            griddash: extendFlat({}, dash, { editType: "calc" }),
+            showgrid: {
+              valType: "boolean",
+              dflt: true,
+              editType: "calc"
+            },
+            minorgridcount: {
+              valType: "integer",
+              min: 0,
+              dflt: 0,
+              editType: "calc"
+            },
+            minorgridwidth: {
+              valType: "number",
+              min: 0,
+              dflt: 1,
+              editType: "calc"
+            },
+            minorgriddash: extendFlat({}, dash, { editType: "calc" }),
+            minorgridcolor: {
+              valType: "color",
+              dflt: colorAttrs.lightLine,
+              editType: "calc"
+            },
+            startline: {
+              valType: "boolean",
+              editType: "calc"
+            },
+            startlinecolor: {
+              valType: "color",
+              editType: "calc"
+            },
+            startlinewidth: {
+              valType: "number",
+              dflt: 1,
+              editType: "calc"
+            },
+            endline: {
+              valType: "boolean",
+              editType: "calc"
+            },
+            endlinewidth: {
+              valType: "number",
+              dflt: 1,
+              editType: "calc"
+            },
+            endlinecolor: {
+              valType: "color",
+              editType: "calc"
+            },
+            tick0: {
+              valType: "number",
+              min: 0,
+              dflt: 0,
+              editType: "calc"
+            },
+            dtick: {
+              valType: "number",
+              min: 0,
+              dflt: 1,
+              editType: "calc"
+            },
+            arraytick0: {
+              valType: "integer",
+              min: 0,
+              dflt: 0,
+              editType: "calc"
+            },
+            arraydtick: {
+              valType: "integer",
+              min: 1,
+              dflt: 1,
+              editType: "calc"
+            },
+            editType: "calc"
+          };
+        }
+      });
+      var require_attributes63 = __commonJS({
+        "src/traces/carpet/attributes.js"(exports, module2) {
+          var fontAttrs = require_font_attributes();
+          var axisAttrs = require_axis_attributes2();
+          var colorAttrs = require_attributes3();
+          var carpetFont = fontAttrs({
+            editType: "calc"
+          });
+          var zorder = require_attributes12().zorder;
+          carpetFont.family.dflt = '"Open Sans", verdana, arial, sans-serif';
+          carpetFont.size.dflt = 12;
+          carpetFont.color.dflt = colorAttrs.defaultLine;
+          module2.exports = {
+            carpet: {
+              valType: "string",
+              editType: "calc"
+            },
+            x: {
+              valType: "data_array",
+              editType: "calc+clearAxisTypes"
+            },
+            y: {
+              valType: "data_array",
+              editType: "calc+clearAxisTypes"
+            },
+            a: {
+              valType: "data_array",
+              editType: "calc"
+            },
+            a0: {
+              valType: "number",
+              dflt: 0,
+              editType: "calc"
+            },
+            da: {
+              valType: "number",
+              dflt: 1,
+              editType: "calc"
+            },
+            b: {
+              valType: "data_array",
+              editType: "calc"
+            },
+            b0: {
+              valType: "number",
+              dflt: 0,
+              editType: "calc"
+            },
+            db: {
+              valType: "number",
+              dflt: 1,
+              editType: "calc"
+            },
+            cheaterslope: {
+              valType: "number",
+              dflt: 1,
+              editType: "calc"
+            },
+            aaxis: axisAttrs,
+            baxis: axisAttrs,
+            font: carpetFont,
+            color: {
+              valType: "color",
+              dflt: colorAttrs.defaultLine,
+              editType: "plot"
+            },
+            zorder
+          };
+        }
+      });
+      var require_xy_defaults2 = __commonJS({
+        "src/traces/carpet/xy_defaults.js"(exports, module2) {
+          var isArray1D = require_lib().isArray1D;
+          module2.exports = function handleXYDefaults(traceIn, traceOut, coerce) {
+            var x2 = coerce("x");
+            var hasX = x2 && x2.length;
+            var y2 = coerce("y");
+            var hasY = y2 && y2.length;
+            if (!hasX && !hasY) return false;
+            traceOut._cheater = !x2;
+            if ((!hasX || isArray1D(x2)) && (!hasY || isArray1D(y2))) {
+              var len2 = hasX ? x2.length : Infinity;
+              if (hasY) len2 = Math.min(len2, y2.length);
+              if (traceOut.a && traceOut.a.length) len2 = Math.min(len2, traceOut.a.length);
+              if (traceOut.b && traceOut.b.length) len2 = Math.min(len2, traceOut.b.length);
+              traceOut._length = len2;
+            } else traceOut._length = null;
+            return true;
+          };
+        }
+      });
+      var require_axis_defaults3 = __commonJS({
+        "src/traces/carpet/axis_defaults.js"(exports, module2) {
+          var carpetAttrs = require_attributes63();
+          var addOpacity = require_color().addOpacity;
+          var Registry = require_registry();
+          var Lib = require_lib();
+          var handleTickValueDefaults = require_tick_value_defaults();
+          var handleTickLabelDefaults = require_tick_label_defaults();
+          var handlePrefixSuffixDefaults = require_prefix_suffix_defaults();
+          var handleCategoryOrderDefaults = require_category_order_defaults();
+          var setConvert = require_set_convert();
+          var autoType = require_axis_autotype();
+          module2.exports = function handleAxisDefaults(containerIn, containerOut, options) {
+            var letter = options.letter;
+            var font = options.font || {};
+            var attributes = carpetAttrs[letter + "axis"];
+            function coerce(attr, dflt) {
+              return Lib.coerce(containerIn, containerOut, attributes, attr, dflt);
+            }
+            function coerce2(attr, dflt) {
+              return Lib.coerce2(containerIn, containerOut, attributes, attr, dflt);
+            }
+            if (options.name) {
+              containerOut._name = options.name;
+              containerOut._id = options.name;
+            }
+            coerce("autotypenumbers", options.autotypenumbersDflt);
+            var axType = coerce("type");
+            if (axType === "-") {
+              if (options.data) setAutoType(containerOut, options.data);
+              if (containerOut.type === "-") {
+                containerOut.type = "linear";
+              } else {
+                axType = containerIn.type = containerOut.type;
+              }
+            }
+            coerce("smoothing");
+            coerce("cheatertype");
+            coerce("showticklabels");
+            coerce("labelprefix", letter + " = ");
+            coerce("labelsuffix");
+            coerce("showtickprefix");
+            coerce("showticksuffix");
+            coerce("separatethousands");
+            coerce("tickformat");
+            coerce("exponentformat");
+            coerce("minexponent");
+            coerce("showexponent");
+            coerce("categoryorder");
+            coerce("tickmode");
+            coerce("tickvals");
+            coerce("ticktext");
+            coerce("tick0");
+            coerce("dtick");
+            if (containerOut.tickmode === "array") {
+              coerce("arraytick0");
+              coerce("arraydtick");
+            }
+            coerce("labelpadding");
+            containerOut._hovertitle = letter;
+            if (axType === "date") {
+              var handleCalendarDefaults = Registry.getComponentMethod("calendars", "handleDefaults");
+              handleCalendarDefaults(containerIn, containerOut, "calendar", options.calendar);
+            }
+            setConvert(containerOut, options.fullLayout);
+            containerOut.c2p = Lib.identity;
+            var dfltColor = coerce("color", options.dfltColor);
+            var dfltFontColor = dfltColor === containerIn.color ? dfltColor : font.color;
+            var title = coerce("title.text");
+            if (title) {
+              Lib.coerceFont(coerce, "title.font", font, { overrideDflt: {
+                size: Lib.bigFont(font.size),
+                color: dfltFontColor
+              } });
+              coerce("title.offset");
+            }
+            coerce("tickangle");
+            var autoRange = coerce("autorange", !containerOut.isValidRange(containerIn.range));
+            if (autoRange) coerce("rangemode");
+            coerce("range");
+            containerOut.cleanRange();
+            coerce("fixedrange");
+            handleTickValueDefaults(containerIn, containerOut, coerce, axType);
+            handlePrefixSuffixDefaults(containerIn, containerOut, coerce, axType, options);
+            handleTickLabelDefaults(containerIn, containerOut, coerce, axType, options);
+            handleCategoryOrderDefaults(containerIn, containerOut, coerce, {
+              data: options.data,
+              dataAttr: letter
+            });
+            var gridColor = coerce2("gridcolor", addOpacity(dfltColor, 0.3));
+            var gridWidth = coerce2("gridwidth");
+            var gridDash = coerce2("griddash");
+            var showGrid = coerce("showgrid");
+            if (!showGrid) {
+              delete containerOut.gridcolor;
+              delete containerOut.gridwidth;
+              delete containerOut.griddash;
+            }
+            var startLineColor = coerce2("startlinecolor", dfltColor);
+            var startLineWidth = coerce2("startlinewidth", gridWidth);
+            var showStartLine = coerce("startline", containerOut.showgrid || !!startLineColor || !!startLineWidth);
+            if (!showStartLine) {
+              delete containerOut.startlinecolor;
+              delete containerOut.startlinewidth;
+            }
+            var endLineColor = coerce2("endlinecolor", dfltColor);
+            var endLineWidth = coerce2("endlinewidth", gridWidth);
+            var showEndLine = coerce("endline", containerOut.showgrid || !!endLineColor || !!endLineWidth);
+            if (!showEndLine) {
+              delete containerOut.endlinecolor;
+              delete containerOut.endlinewidth;
+            }
+            if (!showGrid) {
+              delete containerOut.gridcolor;
+              delete containerOut.gridwidth;
+              delete containerOut.griddash;
+            } else {
+              coerce("minorgridcount");
+              coerce("minorgridwidth", gridWidth);
+              coerce("minorgriddash", gridDash);
+              coerce("minorgridcolor", addOpacity(gridColor, 0.06));
+              if (!containerOut.minorgridcount) {
+                delete containerOut.minorgridwidth;
+                delete containerOut.minorgriddash;
+                delete containerOut.minorgridcolor;
+              }
+            }
+            if (containerOut.showticklabels === "none") {
+              delete containerOut.tickfont;
+              delete containerOut.tickangle;
+              delete containerOut.showexponent;
+              delete containerOut.exponentformat;
+              delete containerOut.minexponent;
+              delete containerOut.tickformat;
+              delete containerOut.showticksuffix;
+              delete containerOut.showtickprefix;
+            }
+            if (!containerOut.showticksuffix) {
+              delete containerOut.ticksuffix;
+            }
+            if (!containerOut.showtickprefix) {
+              delete containerOut.tickprefix;
+            }
+            coerce("tickmode");
+            return containerOut;
+          };
+          function setAutoType(ax, data) {
+            if (ax.type !== "-") return;
+            var id2 = ax._id;
+            var axLetter = id2.charAt(0);
+            var calAttr = axLetter + "calendar";
+            var calendar = ax[calAttr];
+            ax.type = autoType(data, calendar, {
+              autotypenumbers: ax.autotypenumbers
+            });
+          }
+        }
+      });
+      var require_ab_defaults = __commonJS({
+        "src/traces/carpet/ab_defaults.js"(exports, module2) {
+          var handleAxisDefaults = require_axis_defaults3();
+          var Template = require_plot_template();
+          module2.exports = function handleABDefaults(traceIn, traceOut, fullLayout, coerce, dfltColor) {
+            var a2 = coerce("a");
+            if (!a2) {
+              coerce("da");
+              coerce("a0");
+            }
+            var b2 = coerce("b");
+            if (!b2) {
+              coerce("db");
+              coerce("b0");
+            }
+            mimickAxisDefaults(traceIn, traceOut, fullLayout, dfltColor);
+          };
+          function mimickAxisDefaults(traceIn, traceOut, fullLayout, dfltColor) {
+            var axesList = ["aaxis", "baxis"];
+            axesList.forEach(function(axName) {
+              var axLetter = axName.charAt(0);
+              var axIn = traceIn[axName] || {};
+              var axOut = Template.newContainer(traceOut, axName);
+              var defaultOptions2 = {
+                noAutotickangles: true,
+                noTicklabelshift: true,
+                noTicklabelstandoff: true,
+                noTicklabelstep: true,
+                tickfont: "x",
+                id: axLetter + "axis",
+                letter: axLetter,
+                font: traceOut.font,
+                name: axName,
+                data: traceIn[axLetter],
+                calendar: traceOut.calendar,
+                dfltColor,
+                bgColor: fullLayout.paper_bgcolor,
+                autotypenumbersDflt: fullLayout.autotypenumbers,
+                fullLayout
+              };
+              handleAxisDefaults(axIn, axOut, defaultOptions2);
+              axOut._categories = axOut._categories || [];
+              if (!traceIn[axName] && axIn.type !== "-") {
+                traceIn[axName] = { type: axIn.type };
+              }
+            });
+          }
+        }
+      });
+      var require_defaults59 = __commonJS({
+        "src/traces/carpet/defaults.js"(exports, module2) {
+          var Lib = require_lib();
+          var handleXYDefaults = require_xy_defaults2();
+          var handleABDefaults = require_ab_defaults();
+          var attributes = require_attributes63();
+          var colorAttrs = require_attributes3();
+          module2.exports = function supplyDefaults(traceIn, traceOut, dfltColor, fullLayout) {
+            function coerce(attr, dflt) {
+              return Lib.coerce(traceIn, traceOut, attributes, attr, dflt);
+            }
+            traceOut._clipPathId = "clip" + traceOut.uid + "carpet";
+            var defaultColor = coerce("color", colorAttrs.defaultLine);
+            Lib.coerceFont(coerce, "font", fullLayout.font);
+            coerce("carpet");
+            handleABDefaults(traceIn, traceOut, fullLayout, coerce, defaultColor);
+            if (!traceOut.a || !traceOut.b) {
+              traceOut.visible = false;
+              return;
+            }
+            if (traceOut.a.length < 3) {
+              traceOut.aaxis.smoothing = 0;
+            }
+            if (traceOut.b.length < 3) {
+              traceOut.baxis.smoothing = 0;
+            }
+            var validData = handleXYDefaults(traceIn, traceOut, coerce);
+            if (!validData) {
+              traceOut.visible = false;
+            }
+            if (traceOut._cheater) {
+              coerce("cheaterslope");
+            }
+            coerce("zorder");
+          };
+        }
+      });
+      var require_map_1d_array = __commonJS({
+        "src/traces/carpet/map_1d_array.js"(exports, module2) {
+          var isArrayOrTypedArray = require_lib().isArrayOrTypedArray;
+          module2.exports = function mapArray(out, data, func) {
+            var i2;
+            if (!isArrayOrTypedArray(out)) {
+              out = [];
+            } else if (out.length > data.length) {
+              out = out.slice(0, data.length);
+            }
+            for (i2 = 0; i2 < data.length; i2++) {
+              out[i2] = func(data[i2]);
+            }
+            return out;
+          };
+        }
+      });
+      var require_makepath = __commonJS({
+        "src/traces/carpet/makepath.js"(exports, module2) {
+          module2.exports = function makePath(xp, yp, isBicubic) {
+            if (xp.length === 0) return "";
+            var i2;
+            var path = [];
+            var stride = isBicubic ? 3 : 1;
+            for (i2 = 0; i2 < xp.length; i2 += stride) {
+              path.push(xp[i2] + "," + yp[i2]);
+              if (isBicubic && i2 < xp.length - stride) {
+                path.push("C");
+                path.push([
+                  xp[i2 + 1] + "," + yp[i2 + 1],
+                  xp[i2 + 2] + "," + yp[i2 + 2] + " "
+                ].join(" "));
+              }
+            }
+            return path.join(isBicubic ? "" : "L");
+          };
+        }
+      });
+      var require_orient_text = __commonJS({
+        "src/traces/carpet/orient_text.js"(exports, module2) {
+          module2.exports = function orientText(trace, xaxis, yaxis, xy, dxy, refDxy) {
+            var dx = dxy[0] * trace.dpdx(xaxis);
+            var dy = dxy[1] * trace.dpdy(yaxis);
+            var flip = 1;
+            var offsetMultiplier = 1;
+            if (refDxy) {
+              var l1 = Math.sqrt(dxy[0] * dxy[0] + dxy[1] * dxy[1]);
+              var l2 = Math.sqrt(refDxy[0] * refDxy[0] + refDxy[1] * refDxy[1]);
+              var dot2 = (dxy[0] * refDxy[0] + dxy[1] * refDxy[1]) / l1 / l2;
+              offsetMultiplier = Math.max(0, dot2);
+            }
+            var angle2 = Math.atan2(dy, dx) * 180 / Math.PI;
+            if (angle2 < -90) {
+              angle2 += 180;
+              flip = -flip;
+            } else if (angle2 > 90) {
+              angle2 -= 180;
+              flip = -flip;
+            }
+            return {
+              angle: angle2,
+              flip,
+              p: trace.c2p(xy, xaxis, yaxis),
+              offsetMultplier: offsetMultiplier
+            };
+          };
+        }
+      });
+      var require_plot32 = __commonJS({
+        "src/traces/carpet/plot.js"(exports, module2) {
+          var d3 = require_d3();
+          var Drawing = require_drawing();
+          var map1dArray = require_map_1d_array();
+          var makepath = require_makepath();
+          var orientText = require_orient_text();
+          var svgTextUtils = require_svg_text_utils();
+          var Lib = require_lib();
+          var strRotate = Lib.strRotate;
+          var strTranslate = Lib.strTranslate;
+          var alignmentConstants = require_alignment();
+          module2.exports = function plot(gd2, plotinfo, cdcarpet, carpetLayer) {
+            var isStatic = gd2._context.staticPlot;
+            var xa = plotinfo.xaxis;
+            var ya2 = plotinfo.yaxis;
+            var fullLayout = gd2._fullLayout;
+            var clipLayer = fullLayout._clips;
+            Lib.makeTraceGroups(carpetLayer, cdcarpet, "trace").each(function(cd2) {
+              var axisLayer = d3.select(this);
+              var cd0 = cd2[0];
+              var trace = cd0.trace;
+              var aax = trace.aaxis;
+              var bax = trace.baxis;
+              var minorLayer = Lib.ensureSingle(axisLayer, "g", "minorlayer");
+              var majorLayer = Lib.ensureSingle(axisLayer, "g", "majorlayer");
+              var boundaryLayer = Lib.ensureSingle(axisLayer, "g", "boundarylayer");
+              var labelLayer = Lib.ensureSingle(axisLayer, "g", "labellayer");
+              axisLayer.style("opacity", trace.opacity);
+              drawGridLines(xa, ya2, majorLayer, aax, "a", aax._gridlines, true);
+              drawGridLines(xa, ya2, majorLayer, bax, "b", bax._gridlines, true);
+              drawGridLines(xa, ya2, minorLayer, aax, "a", aax._minorgridlines, true);
+              drawGridLines(xa, ya2, minorLayer, bax, "b", bax._minorgridlines, true);
+              drawGridLines(xa, ya2, boundaryLayer, aax, "a-boundary", aax._boundarylines, isStatic);
+              drawGridLines(xa, ya2, boundaryLayer, bax, "b-boundary", bax._boundarylines, isStatic);
+              var labelOrientationA = drawAxisLabels(gd2, xa, ya2, trace, cd0, labelLayer, aax._labels, "a-label");
+              var labelOrientationB = drawAxisLabels(gd2, xa, ya2, trace, cd0, labelLayer, bax._labels, "b-label");
+              drawAxisTitles(gd2, labelLayer, trace, cd0, xa, ya2, labelOrientationA, labelOrientationB);
+              drawClipPath(trace, cd0, clipLayer, xa, ya2);
+            });
+          };
+          function drawClipPath(trace, t4, layer, xaxis, yaxis) {
+            var seg, xp, yp, i2;
+            var clip = layer.select("#" + trace._clipPathId);
+            if (!clip.size()) {
+              clip = layer.append("clipPath").classed("carpetclip", true);
+            }
+            var path = Lib.ensureSingle(clip, "path", "carpetboundary");
+            var segments = t4.clipsegments;
+            var segs = [];
+            for (i2 = 0; i2 < segments.length; i2++) {
+              seg = segments[i2];
+              xp = map1dArray([], seg.x, xaxis.c2p);
+              yp = map1dArray([], seg.y, yaxis.c2p);
+              segs.push(makepath(xp, yp, seg.bicubic));
+            }
+            var clipPathData = "M" + segs.join("L") + "Z";
+            clip.attr("id", trace._clipPathId);
+            path.attr("d", clipPathData);
+          }
+          function drawGridLines(xaxis, yaxis, layer, axis, axisLetter, gridlines, isStatic) {
+            var lineClass = "const-" + axisLetter + "-lines";
+            var gridJoin = layer.selectAll("." + lineClass).data(gridlines);
+            gridJoin.enter().append("path").classed(lineClass, true).style("vector-effect", isStatic ? "none" : "non-scaling-stroke");
+            gridJoin.each(function(d2) {
+              var gridline = d2;
+              var x2 = gridline.x;
+              var y2 = gridline.y;
+              var xp = map1dArray([], x2, xaxis.c2p);
+              var yp = map1dArray([], y2, yaxis.c2p);
+              var path = "M" + makepath(xp, yp, gridline.smoothing);
+              var el2 = d3.select(this);
+              el2.attr("d", path).style("stroke-width", gridline.width).style("stroke", gridline.color).style("stroke-dasharray", Drawing.dashStyle(gridline.dash, gridline.width)).style("fill", "none");
+            });
+            gridJoin.exit().remove();
+          }
+          function drawAxisLabels(gd2, xaxis, yaxis, trace, t4, layer, labels, labelClass) {
+            var labelJoin = layer.selectAll("text." + labelClass).data(labels);
+            labelJoin.enter().append("text").classed(labelClass, true);
+            var maxExtent = 0;
+            var labelOrientation = {};
+            labelJoin.each(function(label, i2) {
+              var orientation;
+              if (label.axis.tickangle === "auto") {
+                orientation = orientText(trace, xaxis, yaxis, label.xy, label.dxy);
+              } else {
+                var angle2 = (label.axis.tickangle + 180) * Math.PI / 180;
+                orientation = orientText(trace, xaxis, yaxis, label.xy, [Math.cos(angle2), Math.sin(angle2)]);
+              }
+              if (!i2) {
+                labelOrientation = { angle: orientation.angle, flip: orientation.flip };
+              }
+              var direction = (label.endAnchor ? -1 : 1) * orientation.flip;
+              var labelEl = d3.select(this).attr({
+                "text-anchor": direction > 0 ? "start" : "end",
+                "data-notex": 1
+              }).call(Drawing.font, label.font).text(label.text).call(svgTextUtils.convertToTspans, gd2);
+              var bbox = Drawing.bBox(this);
+              labelEl.attr(
+                "transform",
+                // Translate to the correct point:
+                strTranslate(orientation.p[0], orientation.p[1]) + // Rotate to line up with grid line tangent:
+                strRotate(orientation.angle) + // Adjust the baseline and indentation:
+                strTranslate(label.axis.labelpadding * direction, bbox.height * 0.3)
+              );
+              maxExtent = Math.max(maxExtent, bbox.width + label.axis.labelpadding);
+            });
+            labelJoin.exit().remove();
+            labelOrientation.maxExtent = maxExtent;
+            return labelOrientation;
+          }
+          function drawAxisTitles(gd2, layer, trace, t4, xa, ya2, labelOrientationA, labelOrientationB) {
+            var a2, b2, xy, dxy;
+            var aMin = Lib.aggNums(Math.min, null, trace.a);
+            var aMax = Lib.aggNums(Math.max, null, trace.a);
+            var bMin = Lib.aggNums(Math.min, null, trace.b);
+            var bMax = Lib.aggNums(Math.max, null, trace.b);
+            a2 = 0.5 * (aMin + aMax);
+            b2 = bMin;
+            xy = trace.ab2xy(a2, b2, true);
+            dxy = trace.dxyda_rough(a2, b2);
+            if (labelOrientationA.angle === void 0) {
+              Lib.extendFlat(labelOrientationA, orientText(trace, xa, ya2, xy, trace.dxydb_rough(a2, b2)));
+            }
+            drawAxisTitle(gd2, layer, trace, t4, xy, dxy, trace.aaxis, xa, ya2, labelOrientationA, "a-title");
+            a2 = aMin;
+            b2 = 0.5 * (bMin + bMax);
+            xy = trace.ab2xy(a2, b2, true);
+            dxy = trace.dxydb_rough(a2, b2);
+            if (labelOrientationB.angle === void 0) {
+              Lib.extendFlat(labelOrientationB, orientText(trace, xa, ya2, xy, trace.dxyda_rough(a2, b2)));
+            }
+            drawAxisTitle(gd2, layer, trace, t4, xy, dxy, trace.baxis, xa, ya2, labelOrientationB, "b-title");
+          }
+          var lineSpacing = alignmentConstants.LINE_SPACING;
+          var midShift = (1 - alignmentConstants.MID_SHIFT) / lineSpacing + 1;
+          function drawAxisTitle(gd2, layer, trace, t4, xy, dxy, axis, xa, ya2, labelOrientation, labelClass) {
+            var data = [];
+            if (axis.title.text) data.push(axis.title.text);
+            var titleJoin = layer.selectAll("text." + labelClass).data(data);
+            var offset = labelOrientation.maxExtent;
+            titleJoin.enter().append("text").classed(labelClass, true);
+            titleJoin.each(function() {
+              var orientation = orientText(trace, xa, ya2, xy, dxy);
+              if (["start", "both"].indexOf(axis.showticklabels) === -1) {
+                offset = 0;
+              }
+              var titleSize = axis.title.font.size;
+              offset += titleSize + axis.title.offset;
+              var labelNorm = labelOrientation.angle + (labelOrientation.flip < 0 ? 180 : 0);
+              var angleDiff = (labelNorm - orientation.angle + 450) % 360;
+              var reverseTitle = angleDiff > 90 && angleDiff < 270;
+              var el2 = d3.select(this);
+              el2.text(axis.title.text).call(svgTextUtils.convertToTspans, gd2);
+              if (reverseTitle) {
+                offset = (-svgTextUtils.lineCount(el2) + midShift) * lineSpacing * titleSize - offset;
+              }
+              el2.attr(
+                "transform",
+                strTranslate(orientation.p[0], orientation.p[1]) + strRotate(orientation.angle) + strTranslate(0, offset)
+              ).attr("text-anchor", "middle").call(Drawing.font, axis.title.font);
+            });
+            titleJoin.exit().remove();
+          }
+        }
+      });
+      var require_cheater_basis = __commonJS({
+        "src/traces/carpet/cheater_basis.js"(exports, module2) {
+          var isArrayOrTypedArray = require_lib().isArrayOrTypedArray;
+          module2.exports = function(a2, b2, cheaterslope) {
+            var i2, j2, ascal, bscal, aval, bval;
+            var data = [];
+            var na = isArrayOrTypedArray(a2) ? a2.length : a2;
+            var nb2 = isArrayOrTypedArray(b2) ? b2.length : b2;
+            var adata = isArrayOrTypedArray(a2) ? a2 : null;
+            var bdata = isArrayOrTypedArray(b2) ? b2 : null;
+            if (adata) {
+              ascal = (adata.length - 1) / (adata[adata.length - 1] - adata[0]) / (na - 1);
+            }
+            if (bdata) {
+              bscal = (bdata.length - 1) / (bdata[bdata.length - 1] - bdata[0]) / (nb2 - 1);
+            }
+            var xval;
+            var xmin = Infinity;
+            var xmax = -Infinity;
+            for (j2 = 0; j2 < nb2; j2++) {
+              data[j2] = [];
+              bval = bdata ? (bdata[j2] - bdata[0]) * bscal : j2 / (nb2 - 1);
+              for (i2 = 0; i2 < na; i2++) {
+                aval = adata ? (adata[i2] - adata[0]) * ascal : i2 / (na - 1);
+                xval = aval - bval * cheaterslope;
+                xmin = Math.min(xval, xmin);
+                xmax = Math.max(xval, xmax);
+                data[j2][i2] = xval;
+              }
+            }
+            var slope = 1 / (xmax - xmin);
+            var offset = -xmin * slope;
+            for (j2 = 0; j2 < nb2; j2++) {
+              for (i2 = 0; i2 < na; i2++) {
+                data[j2][i2] = slope * data[j2][i2] + offset;
+              }
+            }
+            return data;
+          };
+        }
+      });
+      var require_array_minmax = __commonJS({
+        "src/traces/carpet/array_minmax.js"(exports, module2) {
+          var isArrayOrTypedArray = require_lib().isArrayOrTypedArray;
+          module2.exports = function(a2) {
+            return minMax(a2, 0);
+          };
+          function minMax(a2, depth) {
+            if (!isArrayOrTypedArray(a2) || depth >= 10) {
+              return null;
+            }
+            var min = Infinity;
+            var max = -Infinity;
+            var n2 = a2.length;
+            for (var i2 = 0; i2 < n2; i2++) {
+              var datum = a2[i2];
+              if (isArrayOrTypedArray(datum)) {
+                var result = minMax(datum, depth + 1);
+                if (result) {
+                  min = Math.min(result[0], min);
+                  max = Math.max(result[1], max);
+                }
+              } else {
+                min = Math.min(datum, min);
+                max = Math.max(datum, max);
+              }
+            }
+            return [min, max];
+          }
+        }
+      });
+      var require_calc_gridlines = __commonJS({
+        "src/traces/carpet/calc_gridlines.js"(exports, module2) {
+          var Axes = require_axes();
+          var extendFlat = require_extend().extendFlat;
+          module2.exports = function calcGridlines(trace, axisLetter, crossAxisLetter) {
+            var i2, j2, j0;
+            var eps, bounds, n1, n2, n3, value, v2;
+            var j1, v0, v1, d2;
+            var data = trace["_" + axisLetter];
+            var axis = trace[axisLetter + "axis"];
+            var gridlines = axis._gridlines = [];
+            var minorgridlines = axis._minorgridlines = [];
+            var boundarylines = axis._boundarylines = [];
+            var crossData = trace["_" + crossAxisLetter];
+            var crossAxis = trace[crossAxisLetter + "axis"];
+            if (axis.tickmode === "array") {
+              axis.tickvals = data.slice();
+            }
+            var xcp = trace._xctrl;
+            var ycp = trace._yctrl;
+            var nea = xcp[0].length;
+            var neb = xcp.length;
+            var na = trace._a.length;
+            var nb2 = trace._b.length;
+            Axes.prepTicks(axis);
+            if (axis.tickmode === "array") delete axis.tickvals;
+            var stride = axis.smoothing ? 3 : 1;
+            function constructValueGridline(value2) {
+              var i22, j22, j02, tj2, pxy, i0, ti2, xy, dxydi0, dxydi1, dxydj0, dxydj1;
+              var xpoints = [];
+              var ypoints = [];
+              var ret = {};
+              if (axisLetter === "b") {
+                j22 = trace.b2j(value2);
+                j02 = Math.floor(Math.max(0, Math.min(nb2 - 2, j22)));
+                tj2 = j22 - j02;
+                ret.length = nb2;
+                ret.crossLength = na;
+                ret.xy = function(i3) {
+                  return trace.evalxy([], i3, j22);
+                };
+                ret.dxy = function(i02, ti22) {
+                  return trace.dxydi([], i02, j02, ti22, tj2);
+                };
+                for (i22 = 0; i22 < na; i22++) {
+                  i0 = Math.min(na - 2, i22);
+                  ti2 = i22 - i0;
+                  xy = trace.evalxy([], i22, j22);
+                  if (crossAxis.smoothing && i22 > 0) {
+                    dxydi0 = trace.dxydi([], i22 - 1, j02, 0, tj2);
+                    xpoints.push(pxy[0] + dxydi0[0] / 3);
+                    ypoints.push(pxy[1] + dxydi0[1] / 3);
+                    dxydi1 = trace.dxydi([], i22 - 1, j02, 1, tj2);
+                    xpoints.push(xy[0] - dxydi1[0] / 3);
+                    ypoints.push(xy[1] - dxydi1[1] / 3);
+                  }
+                  xpoints.push(xy[0]);
+                  ypoints.push(xy[1]);
+                  pxy = xy;
+                }
+              } else {
+                i22 = trace.a2i(value2);
+                i0 = Math.floor(Math.max(0, Math.min(na - 2, i22)));
+                ti2 = i22 - i0;
+                ret.length = na;
+                ret.crossLength = nb2;
+                ret.xy = function(j3) {
+                  return trace.evalxy([], i22, j3);
+                };
+                ret.dxy = function(j03, tj22) {
+                  return trace.dxydj([], i0, j03, ti2, tj22);
+                };
+                for (j22 = 0; j22 < nb2; j22++) {
+                  j02 = Math.min(nb2 - 2, j22);
+                  tj2 = j22 - j02;
+                  xy = trace.evalxy([], i22, j22);
+                  if (crossAxis.smoothing && j22 > 0) {
+                    dxydj0 = trace.dxydj([], i0, j22 - 1, ti2, 0);
+                    xpoints.push(pxy[0] + dxydj0[0] / 3);
+                    ypoints.push(pxy[1] + dxydj0[1] / 3);
+                    dxydj1 = trace.dxydj([], i0, j22 - 1, ti2, 1);
+                    xpoints.push(xy[0] - dxydj1[0] / 3);
+                    ypoints.push(xy[1] - dxydj1[1] / 3);
+                  }
+                  xpoints.push(xy[0]);
+                  ypoints.push(xy[1]);
+                  pxy = xy;
+                }
+              }
+              ret.axisLetter = axisLetter;
+              ret.axis = axis;
+              ret.crossAxis = crossAxis;
+              ret.value = value2;
+              ret.constvar = crossAxisLetter;
+              ret.index = n3;
+              ret.x = xpoints;
+              ret.y = ypoints;
+              ret.smoothing = crossAxis.smoothing;
+              return ret;
+            }
+            function constructArrayGridline(idx) {
+              var j22, i0, j02, ti2, tj2;
+              var xpoints = [];
+              var ypoints = [];
+              var ret = {};
+              ret.length = data.length;
+              ret.crossLength = crossData.length;
+              if (axisLetter === "b") {
+                j02 = Math.max(0, Math.min(nb2 - 2, idx));
+                tj2 = Math.min(1, Math.max(0, idx - j02));
+                ret.xy = function(i22) {
+                  return trace.evalxy([], i22, idx);
+                };
+                ret.dxy = function(i02, ti22) {
+                  return trace.dxydi([], i02, j02, ti22, tj2);
+                };
+                for (j22 = 0; j22 < nea; j22++) {
+                  xpoints[j22] = xcp[idx * stride][j22];
+                  ypoints[j22] = ycp[idx * stride][j22];
+                }
+              } else {
+                i0 = Math.max(0, Math.min(na - 2, idx));
+                ti2 = Math.min(1, Math.max(0, idx - i0));
+                ret.xy = function(j3) {
+                  return trace.evalxy([], idx, j3);
+                };
+                ret.dxy = function(j03, tj22) {
+                  return trace.dxydj([], i0, j03, ti2, tj22);
+                };
+                for (j22 = 0; j22 < neb; j22++) {
+                  xpoints[j22] = xcp[j22][idx * stride];
+                  ypoints[j22] = ycp[j22][idx * stride];
+                }
+              }
+              ret.axisLetter = axisLetter;
+              ret.axis = axis;
+              ret.crossAxis = crossAxis;
+              ret.value = data[idx];
+              ret.constvar = crossAxisLetter;
+              ret.index = idx;
+              ret.x = xpoints;
+              ret.y = ypoints;
+              ret.smoothing = crossAxis.smoothing;
+              return ret;
+            }
+            if (axis.tickmode === "array") {
+              eps = 5e-15;
+              bounds = [
+                Math.floor((data.length - 1 - axis.arraytick0) / axis.arraydtick * (1 + eps)),
+                Math.ceil(-axis.arraytick0 / axis.arraydtick / (1 + eps))
+              ].sort(function(a2, b2) {
+                return a2 - b2;
+              });
+              n1 = bounds[0] - 1;
+              n2 = bounds[1] + 1;
+              for (n3 = n1; n3 < n2; n3++) {
+                j2 = axis.arraytick0 + axis.arraydtick * n3;
+                if (j2 < 0 || j2 > data.length - 1) continue;
+                gridlines.push(extendFlat(constructArrayGridline(j2), {
+                  color: axis.gridcolor,
+                  width: axis.gridwidth,
+                  dash: axis.griddash
+                }));
+              }
+              for (n3 = n1; n3 < n2; n3++) {
+                j0 = axis.arraytick0 + axis.arraydtick * n3;
+                j1 = Math.min(j0 + axis.arraydtick, data.length - 1);
+                if (j0 < 0 || j0 > data.length - 1) continue;
+                if (j1 < 0 || j1 > data.length - 1) continue;
+                v0 = data[j0];
+                v1 = data[j1];
+                for (i2 = 0; i2 < axis.minorgridcount; i2++) {
+                  d2 = j1 - j0;
+                  if (d2 <= 0) continue;
+                  v2 = v0 + (v1 - v0) * (i2 + 1) / (axis.minorgridcount + 1) * (axis.arraydtick / d2);
+                  if (v2 < data[0] || v2 > data[data.length - 1]) continue;
+                  minorgridlines.push(extendFlat(constructValueGridline(v2), {
+                    color: axis.minorgridcolor,
+                    width: axis.minorgridwidth,
+                    dash: axis.minorgriddash
+                  }));
+                }
+              }
+              if (axis.startline) {
+                boundarylines.push(extendFlat(constructArrayGridline(0), {
+                  color: axis.startlinecolor,
+                  width: axis.startlinewidth
+                }));
+              }
+              if (axis.endline) {
+                boundarylines.push(extendFlat(constructArrayGridline(data.length - 1), {
+                  color: axis.endlinecolor,
+                  width: axis.endlinewidth
+                }));
+              }
+            } else {
+              eps = 5e-15;
+              bounds = [
+                Math.floor((data[data.length - 1] - axis.tick0) / axis.dtick * (1 + eps)),
+                Math.ceil((data[0] - axis.tick0) / axis.dtick / (1 + eps))
+              ].sort(function(a2, b2) {
+                return a2 - b2;
+              });
+              n1 = bounds[0];
+              n2 = bounds[1];
+              for (n3 = n1; n3 <= n2; n3++) {
+                value = axis.tick0 + axis.dtick * n3;
+                gridlines.push(extendFlat(constructValueGridline(value), {
+                  color: axis.gridcolor,
+                  width: axis.gridwidth,
+                  dash: axis.griddash
+                }));
+              }
+              for (n3 = n1 - 1; n3 < n2 + 1; n3++) {
+                value = axis.tick0 + axis.dtick * n3;
+                for (i2 = 0; i2 < axis.minorgridcount; i2++) {
+                  v2 = value + axis.dtick * (i2 + 1) / (axis.minorgridcount + 1);
+                  if (v2 < data[0] || v2 > data[data.length - 1]) continue;
+                  minorgridlines.push(extendFlat(constructValueGridline(v2), {
+                    color: axis.minorgridcolor,
+                    width: axis.minorgridwidth,
+                    dash: axis.minorgriddash
+                  }));
+                }
+              }
+              if (axis.startline) {
+                boundarylines.push(extendFlat(constructValueGridline(data[0]), {
+                  color: axis.startlinecolor,
+                  width: axis.startlinewidth
+                }));
+              }
+              if (axis.endline) {
+                boundarylines.push(extendFlat(constructValueGridline(data[data.length - 1]), {
+                  color: axis.endlinecolor,
+                  width: axis.endlinewidth
+                }));
+              }
+            }
+          };
+        }
+      });
+      var require_calc_labels = __commonJS({
+        "src/traces/carpet/calc_labels.js"(exports, module2) {
+          var Axes = require_axes();
+          var extendFlat = require_extend().extendFlat;
+          module2.exports = function calcLabels(trace, axis) {
+            var i2, tobj, prefix, suffix, gridline;
+            var labels = axis._labels = [];
+            var gridlines = axis._gridlines;
+            for (i2 = 0; i2 < gridlines.length; i2++) {
+              gridline = gridlines[i2];
+              if (["start", "both"].indexOf(axis.showticklabels) !== -1) {
+                tobj = Axes.tickText(axis, gridline.value);
+                extendFlat(tobj, {
+                  prefix,
+                  suffix,
+                  endAnchor: true,
+                  xy: gridline.xy(0),
+                  dxy: gridline.dxy(0, 0),
+                  axis: gridline.axis,
+                  length: gridline.crossAxis.length,
+                  font: gridline.axis.tickfont,
+                  isFirst: i2 === 0,
+                  isLast: i2 === gridlines.length - 1
+                });
+                labels.push(tobj);
+              }
+              if (["end", "both"].indexOf(axis.showticklabels) !== -1) {
+                tobj = Axes.tickText(axis, gridline.value);
+                extendFlat(tobj, {
+                  endAnchor: false,
+                  xy: gridline.xy(gridline.crossLength - 1),
+                  dxy: gridline.dxy(gridline.crossLength - 2, 1),
+                  axis: gridline.axis,
+                  length: gridline.crossAxis.length,
+                  font: gridline.axis.tickfont,
+                  isFirst: i2 === 0,
+                  isLast: i2 === gridlines.length - 1
+                });
+                labels.push(tobj);
+              }
+            }
+          };
+        }
+      });
+      var require_calc_clippath = __commonJS({
+        "src/traces/carpet/calc_clippath.js"(exports, module2) {
+          module2.exports = function makeClipPath(xctrl, yctrl, aax, bax) {
+            var i2, x2, y2;
+            var segments = [];
+            var asmoothing = !!aax.smoothing;
+            var bsmoothing = !!bax.smoothing;
+            var nea1 = xctrl[0].length - 1;
+            var neb1 = xctrl.length - 1;
+            for (i2 = 0, x2 = [], y2 = []; i2 <= nea1; i2++) {
+              x2[i2] = xctrl[0][i2];
+              y2[i2] = yctrl[0][i2];
+            }
+            segments.push({ x: x2, y: y2, bicubic: asmoothing });
+            for (i2 = 0, x2 = [], y2 = []; i2 <= neb1; i2++) {
+              x2[i2] = xctrl[i2][nea1];
+              y2[i2] = yctrl[i2][nea1];
+            }
+            segments.push({ x: x2, y: y2, bicubic: bsmoothing });
+            for (i2 = nea1, x2 = [], y2 = []; i2 >= 0; i2--) {
+              x2[nea1 - i2] = xctrl[neb1][i2];
+              y2[nea1 - i2] = yctrl[neb1][i2];
+            }
+            segments.push({ x: x2, y: y2, bicubic: asmoothing });
+            for (i2 = neb1, x2 = [], y2 = []; i2 >= 0; i2--) {
+              x2[neb1 - i2] = xctrl[i2][0];
+              y2[neb1 - i2] = yctrl[i2][0];
+            }
+            segments.push({ x: x2, y: y2, bicubic: bsmoothing });
+            return segments;
+          };
+        }
+      });
+      var require_smooth_fill_2d_array = __commonJS({
+        "src/traces/carpet/smooth_fill_2d_array.js"(exports, module2) {
+          var Lib = require_lib();
+          module2.exports = function smoothFill2dArray(data, a2, b2) {
+            var i2, j2, k2;
+            var ip = [];
+            var jp = [];
+            var ni2 = data[0].length;
+            var nj2 = data.length;
+            function avgSurrounding(i22, j22) {
+              var sum = 0;
+              var val;
+              var cnt = 0;
+              if (i22 > 0 && (val = data[j22][i22 - 1]) !== void 0) {
+                cnt++;
+                sum += val;
+              }
+              if (i22 < ni2 - 1 && (val = data[j22][i22 + 1]) !== void 0) {
+                cnt++;
+                sum += val;
+              }
+              if (j22 > 0 && (val = data[j22 - 1][i22]) !== void 0) {
+                cnt++;
+                sum += val;
+              }
+              if (j22 < nj2 - 1 && (val = data[j22 + 1][i22]) !== void 0) {
+                cnt++;
+                sum += val;
+              }
+              return sum / Math.max(1, cnt);
+            }
+            var dmax = 0;
+            for (i2 = 0; i2 < ni2; i2++) {
+              for (j2 = 0; j2 < nj2; j2++) {
+                if (data[j2][i2] === void 0) {
+                  ip.push(i2);
+                  jp.push(j2);
+                  data[j2][i2] = avgSurrounding(i2, j2);
+                }
+                dmax = Math.max(dmax, Math.abs(data[j2][i2]));
+              }
+            }
+            if (!ip.length) return data;
+            var dxp, dxm, dap, dam, dbp, dbm, c2, d2, diff, reldiff, overrelaxation;
+            var tol = 1e-5;
+            var resid = 0;
+            var itermax = 100;
+            var iter = 0;
+            var n2 = ip.length;
+            do {
+              resid = 0;
+              for (k2 = 0; k2 < n2; k2++) {
+                i2 = ip[k2];
+                j2 = jp[k2];
+                var boundaryCnt = 0;
+                var newVal = 0;
+                var d0, d1, x0, x1, i0, j0;
+                if (i2 === 0) {
+                  i0 = Math.min(ni2 - 1, 2);
+                  x0 = a2[i0];
+                  x1 = a2[1];
+                  d0 = data[j2][i0];
+                  d1 = data[j2][1];
+                  newVal += d1 + (d1 - d0) * (a2[0] - x1) / (x1 - x0);
+                  boundaryCnt++;
+                } else if (i2 === ni2 - 1) {
+                  i0 = Math.max(0, ni2 - 3);
+                  x0 = a2[i0];
+                  x1 = a2[ni2 - 2];
+                  d0 = data[j2][i0];
+                  d1 = data[j2][ni2 - 2];
+                  newVal += d1 + (d1 - d0) * (a2[ni2 - 1] - x1) / (x1 - x0);
+                  boundaryCnt++;
+                }
+                if ((i2 === 0 || i2 === ni2 - 1) && (j2 > 0 && j2 < nj2 - 1)) {
+                  dxp = b2[j2 + 1] - b2[j2];
+                  dxm = b2[j2] - b2[j2 - 1];
+                  newVal += (dxm * data[j2 + 1][i2] + dxp * data[j2 - 1][i2]) / (dxm + dxp);
+                  boundaryCnt++;
+                }
+                if (j2 === 0) {
+                  j0 = Math.min(nj2 - 1, 2);
+                  x0 = b2[j0];
+                  x1 = b2[1];
+                  d0 = data[j0][i2];
+                  d1 = data[1][i2];
+                  newVal += d1 + (d1 - d0) * (b2[0] - x1) / (x1 - x0);
+                  boundaryCnt++;
+                } else if (j2 === nj2 - 1) {
+                  j0 = Math.max(0, nj2 - 3);
+                  x0 = b2[j0];
+                  x1 = b2[nj2 - 2];
+                  d0 = data[j0][i2];
+                  d1 = data[nj2 - 2][i2];
+                  newVal += d1 + (d1 - d0) * (b2[nj2 - 1] - x1) / (x1 - x0);
+                  boundaryCnt++;
+                }
+                if ((j2 === 0 || j2 === nj2 - 1) && (i2 > 0 && i2 < ni2 - 1)) {
+                  dxp = a2[i2 + 1] - a2[i2];
+                  dxm = a2[i2] - a2[i2 - 1];
+                  newVal += (dxm * data[j2][i2 + 1] + dxp * data[j2][i2 - 1]) / (dxm + dxp);
+                  boundaryCnt++;
+                }
+                if (!boundaryCnt) {
+                  dap = a2[i2 + 1] - a2[i2];
+                  dam = a2[i2] - a2[i2 - 1];
+                  dbp = b2[j2 + 1] - b2[j2];
+                  dbm = b2[j2] - b2[j2 - 1];
+                  c2 = dap * dam * (dap + dam);
+                  d2 = dbp * dbm * (dbp + dbm);
+                  newVal = (c2 * (dbm * data[j2 + 1][i2] + dbp * data[j2 - 1][i2]) + d2 * (dam * data[j2][i2 + 1] + dap * data[j2][i2 - 1])) / (d2 * (dam + dap) + c2 * (dbm + dbp));
+                } else {
+                  newVal /= boundaryCnt;
+                }
+                diff = newVal - data[j2][i2];
+                reldiff = diff / dmax;
+                resid += reldiff * reldiff;
+                overrelaxation = boundaryCnt ? 0 : 0.85;
+                data[j2][i2] += diff * (1 + overrelaxation);
+              }
+              resid = Math.sqrt(resid);
+            } while (iter++ < itermax && resid > tol);
+            Lib.log("Smoother converged to", resid, "after", iter, "iterations");
+            return data;
+          };
+        }
+      });
+      var require_constants32 = __commonJS({
+        "src/traces/carpet/constants.js"(exports, module2) {
+          module2.exports = {
+            RELATIVE_CULL_TOLERANCE: 1e-6
+          };
+        }
+      });
+      var require_catmull_rom = __commonJS({
+        "src/traces/carpet/catmull_rom.js"(exports, module2) {
+          var CatmullRomExp = 0.5;
+          module2.exports = function makeControlPoints(p0, p1, p2, smoothness) {
+            var d1x = p0[0] - p1[0];
+            var d1y = p0[1] - p1[1];
+            var d2x = p2[0] - p1[0];
+            var d2y = p2[1] - p1[1];
+            var d1a = Math.pow(d1x * d1x + d1y * d1y, CatmullRomExp / 2);
+            var d2a = Math.pow(d2x * d2x + d2y * d2y, CatmullRomExp / 2);
+            var numx = (d2a * d2a * d1x - d1a * d1a * d2x) * smoothness;
+            var numy = (d2a * d2a * d1y - d1a * d1a * d2y) * smoothness;
+            var denom1 = d2a * (d1a + d2a) * 3;
+            var denom2 = d1a * (d1a + d2a) * 3;
+            return [[
+              p1[0] + (denom1 && numx / denom1),
+              p1[1] + (denom1 && numy / denom1)
+            ], [
+              p1[0] - (denom2 && numx / denom2),
+              p1[1] - (denom2 && numy / denom2)
+            ]];
+          };
+        }
+      });
+      var require_compute_control_points = __commonJS({
+        "src/traces/carpet/compute_control_points.js"(exports, module2) {
+          var makeControlPoints = require_catmull_rom();
+          var ensureArray = require_lib().ensureArray;
+          function inferCubicControlPoint(p0, p2, p3) {
+            var p2e0 = -0.5 * p3[0] + 1.5 * p2[0];
+            var p2e1 = -0.5 * p3[1] + 1.5 * p2[1];
+            return [
+              (2 * p2e0 + p0[0]) / 3,
+              (2 * p2e1 + p0[1]) / 3
+            ];
+          }
+          module2.exports = function computeControlPoints(xe2, ye2, x2, y2, asmoothing, bsmoothing) {
+            var i2, j2, ie2, je2, xej, yej, xj2, yj2, cp, p1;
+            var na = x2[0].length;
+            var nb2 = x2.length;
+            var nea = asmoothing ? 3 * na - 2 : na;
+            var neb = bsmoothing ? 3 * nb2 - 2 : nb2;
+            xe2 = ensureArray(xe2, neb);
+            ye2 = ensureArray(ye2, neb);
+            for (ie2 = 0; ie2 < neb; ie2++) {
+              xe2[ie2] = ensureArray(xe2[ie2], nea);
+              ye2[ie2] = ensureArray(ye2[ie2], nea);
+            }
+            for (j2 = 0, je2 = 0; j2 < nb2; j2++, je2 += bsmoothing ? 3 : 1) {
+              xej = xe2[je2];
+              yej = ye2[je2];
+              xj2 = x2[j2];
+              yj2 = y2[j2];
+              for (i2 = 0, ie2 = 0; i2 < na; i2++, ie2 += asmoothing ? 3 : 1) {
+                xej[ie2] = xj2[i2];
+                yej[ie2] = yj2[i2];
+              }
+            }
+            if (asmoothing) {
+              for (j2 = 0, je2 = 0; j2 < nb2; j2++, je2 += bsmoothing ? 3 : 1) {
+                for (i2 = 1, ie2 = 3; i2 < na - 1; i2++, ie2 += 3) {
+                  cp = makeControlPoints(
+                    [x2[j2][i2 - 1], y2[j2][i2 - 1]],
+                    [x2[j2][i2], y2[j2][i2]],
+                    [x2[j2][i2 + 1], y2[j2][i2 + 1]],
+                    asmoothing
+                  );
+                  xe2[je2][ie2 - 1] = cp[0][0];
+                  ye2[je2][ie2 - 1] = cp[0][1];
+                  xe2[je2][ie2 + 1] = cp[1][0];
+                  ye2[je2][ie2 + 1] = cp[1][1];
+                }
+                p1 = inferCubicControlPoint(
+                  [xe2[je2][0], ye2[je2][0]],
+                  [xe2[je2][2], ye2[je2][2]],
+                  [xe2[je2][3], ye2[je2][3]]
+                );
+                xe2[je2][1] = p1[0];
+                ye2[je2][1] = p1[1];
+                p1 = inferCubicControlPoint(
+                  [xe2[je2][nea - 1], ye2[je2][nea - 1]],
+                  [xe2[je2][nea - 3], ye2[je2][nea - 3]],
+                  [xe2[je2][nea - 4], ye2[je2][nea - 4]]
+                );
+                xe2[je2][nea - 2] = p1[0];
+                ye2[je2][nea - 2] = p1[1];
+              }
+            }
+            if (bsmoothing) {
+              for (ie2 = 0; ie2 < nea; ie2++) {
+                for (je2 = 3; je2 < neb - 3; je2 += 3) {
+                  cp = makeControlPoints(
+                    [xe2[je2 - 3][ie2], ye2[je2 - 3][ie2]],
+                    [xe2[je2][ie2], ye2[je2][ie2]],
+                    [xe2[je2 + 3][ie2], ye2[je2 + 3][ie2]],
+                    bsmoothing
+                  );
+                  xe2[je2 - 1][ie2] = cp[0][0];
+                  ye2[je2 - 1][ie2] = cp[0][1];
+                  xe2[je2 + 1][ie2] = cp[1][0];
+                  ye2[je2 + 1][ie2] = cp[1][1];
+                }
+                p1 = inferCubicControlPoint(
+                  [xe2[0][ie2], ye2[0][ie2]],
+                  [xe2[2][ie2], ye2[2][ie2]],
+                  [xe2[3][ie2], ye2[3][ie2]]
+                );
+                xe2[1][ie2] = p1[0];
+                ye2[1][ie2] = p1[1];
+                p1 = inferCubicControlPoint(
+                  [xe2[neb - 1][ie2], ye2[neb - 1][ie2]],
+                  [xe2[neb - 3][ie2], ye2[neb - 3][ie2]],
+                  [xe2[neb - 4][ie2], ye2[neb - 4][ie2]]
+                );
+                xe2[neb - 2][ie2] = p1[0];
+                ye2[neb - 2][ie2] = p1[1];
+              }
+            }
+            if (asmoothing && bsmoothing) {
+              for (je2 = 1; je2 < neb; je2 += (je2 + 1) % 3 === 0 ? 2 : 1) {
+                for (ie2 = 3; ie2 < nea - 3; ie2 += 3) {
+                  cp = makeControlPoints(
+                    [xe2[je2][ie2 - 3], ye2[je2][ie2 - 3]],
+                    [xe2[je2][ie2], ye2[je2][ie2]],
+                    [xe2[je2][ie2 + 3], ye2[je2][ie2 + 3]],
+                    asmoothing
+                  );
+                  xe2[je2][ie2 - 1] = 0.5 * (xe2[je2][ie2 - 1] + cp[0][0]);
+                  ye2[je2][ie2 - 1] = 0.5 * (ye2[je2][ie2 - 1] + cp[0][1]);
+                  xe2[je2][ie2 + 1] = 0.5 * (xe2[je2][ie2 + 1] + cp[1][0]);
+                  ye2[je2][ie2 + 1] = 0.5 * (ye2[je2][ie2 + 1] + cp[1][1]);
+                }
+                p1 = inferCubicControlPoint(
+                  [xe2[je2][0], ye2[je2][0]],
+                  [xe2[je2][2], ye2[je2][2]],
+                  [xe2[je2][3], ye2[je2][3]]
+                );
+                xe2[je2][1] = 0.5 * (xe2[je2][1] + p1[0]);
+                ye2[je2][1] = 0.5 * (ye2[je2][1] + p1[1]);
+                p1 = inferCubicControlPoint(
+                  [xe2[je2][nea - 1], ye2[je2][nea - 1]],
+                  [xe2[je2][nea - 3], ye2[je2][nea - 3]],
+                  [xe2[je2][nea - 4], ye2[je2][nea - 4]]
+                );
+                xe2[je2][nea - 2] = 0.5 * (xe2[je2][nea - 2] + p1[0]);
+                ye2[je2][nea - 2] = 0.5 * (ye2[je2][nea - 2] + p1[1]);
+              }
+            }
+            return [xe2, ye2];
+          };
+        }
+      });
+      var require_create_spline_evaluator = __commonJS({
+        "src/traces/carpet/create_spline_evaluator.js"(exports, module2) {
+          module2.exports = function(arrays, na, nb2, asmoothing, bsmoothing) {
+            var imax = na - 2;
+            var jmax = nb2 - 2;
+            if (asmoothing && bsmoothing) {
+              return function(out, i2, j2) {
+                if (!out) out = [];
+                var f0, f1, f2, f3, ak2, k2;
+                var i0 = Math.max(0, Math.min(Math.floor(i2), imax));
+                var j0 = Math.max(0, Math.min(Math.floor(j2), jmax));
+                var u2 = Math.max(0, Math.min(1, i2 - i0));
+                var v2 = Math.max(0, Math.min(1, j2 - j0));
+                i0 *= 3;
+                j0 *= 3;
+                var u22 = u2 * u2;
+                var u3 = u22 * u2;
+                var ou = 1 - u2;
+                var ou2 = ou * ou;
+                var ou3 = ou2 * ou;
+                var v22 = v2 * v2;
+                var v3 = v22 * v2;
+                var ov = 1 - v2;
+                var ov2 = ov * ov;
+                var ov3 = ov2 * ov;
+                for (k2 = 0; k2 < arrays.length; k2++) {
+                  ak2 = arrays[k2];
+                  f0 = ou3 * ak2[j0][i0] + 3 * (ou2 * u2 * ak2[j0][i0 + 1] + ou * u22 * ak2[j0][i0 + 2]) + u3 * ak2[j0][i0 + 3];
+                  f1 = ou3 * ak2[j0 + 1][i0] + 3 * (ou2 * u2 * ak2[j0 + 1][i0 + 1] + ou * u22 * ak2[j0 + 1][i0 + 2]) + u3 * ak2[j0 + 1][i0 + 3];
+                  f2 = ou3 * ak2[j0 + 2][i0] + 3 * (ou2 * u2 * ak2[j0 + 2][i0 + 1] + ou * u22 * ak2[j0 + 2][i0 + 2]) + u3 * ak2[j0 + 2][i0 + 3];
+                  f3 = ou3 * ak2[j0 + 3][i0] + 3 * (ou2 * u2 * ak2[j0 + 3][i0 + 1] + ou * u22 * ak2[j0 + 3][i0 + 2]) + u3 * ak2[j0 + 3][i0 + 3];
+                  out[k2] = ov3 * f0 + 3 * (ov2 * v2 * f1 + ov * v22 * f2) + v3 * f3;
+                }
+                return out;
+              };
+            } else if (asmoothing) {
+              return function(out, i2, j2) {
+                if (!out) out = [];
+                var i0 = Math.max(0, Math.min(Math.floor(i2), imax));
+                var j0 = Math.max(0, Math.min(Math.floor(j2), jmax));
+                var u2 = Math.max(0, Math.min(1, i2 - i0));
+                var v2 = Math.max(0, Math.min(1, j2 - j0));
+                var f0, f1, f2, f3, k2, ak2;
+                i0 *= 3;
+                var u22 = u2 * u2;
+                var u3 = u22 * u2;
+                var ou = 1 - u2;
+                var ou2 = ou * ou;
+                var ou3 = ou2 * ou;
+                var ov = 1 - v2;
+                for (k2 = 0; k2 < arrays.length; k2++) {
+                  ak2 = arrays[k2];
+                  f0 = ov * ak2[j0][i0] + v2 * ak2[j0 + 1][i0];
+                  f1 = ov * ak2[j0][i0 + 1] + v2 * ak2[j0 + 1][i0 + 1];
+                  f2 = ov * ak2[j0][i0 + 2] + v2 * ak2[j0 + 1][i0 + 1];
+                  f3 = ov * ak2[j0][i0 + 3] + v2 * ak2[j0 + 1][i0 + 1];
+                  out[k2] = ou3 * f0 + 3 * (ou2 * u2 * f1 + ou * u22 * f2) + u3 * f3;
+                }
+                return out;
+              };
+            } else if (bsmoothing) {
+              return function(out, i2, j2) {
+                if (!out) out = [];
+                var i0 = Math.max(0, Math.min(Math.floor(i2), imax));
+                var j0 = Math.max(0, Math.min(Math.floor(j2), jmax));
+                var u2 = Math.max(0, Math.min(1, i2 - i0));
+                var v2 = Math.max(0, Math.min(1, j2 - j0));
+                var f0, f1, f2, f3, k2, ak2;
+                j0 *= 3;
+                var v22 = v2 * v2;
+                var v3 = v22 * v2;
+                var ov = 1 - v2;
+                var ov2 = ov * ov;
+                var ov3 = ov2 * ov;
+                var ou = 1 - u2;
+                for (k2 = 0; k2 < arrays.length; k2++) {
+                  ak2 = arrays[k2];
+                  f0 = ou * ak2[j0][i0] + u2 * ak2[j0][i0 + 1];
+                  f1 = ou * ak2[j0 + 1][i0] + u2 * ak2[j0 + 1][i0 + 1];
+                  f2 = ou * ak2[j0 + 2][i0] + u2 * ak2[j0 + 2][i0 + 1];
+                  f3 = ou * ak2[j0 + 3][i0] + u2 * ak2[j0 + 3][i0 + 1];
+                  out[k2] = ov3 * f0 + 3 * (ov2 * v2 * f1 + ov * v22 * f2) + v3 * f3;
+                }
+                return out;
+              };
+            } else {
+              return function(out, i2, j2) {
+                if (!out) out = [];
+                var i0 = Math.max(0, Math.min(Math.floor(i2), imax));
+                var j0 = Math.max(0, Math.min(Math.floor(j2), jmax));
+                var u2 = Math.max(0, Math.min(1, i2 - i0));
+                var v2 = Math.max(0, Math.min(1, j2 - j0));
+                var f0, f1, k2, ak2;
+                var ov = 1 - v2;
+                var ou = 1 - u2;
+                for (k2 = 0; k2 < arrays.length; k2++) {
+                  ak2 = arrays[k2];
+                  f0 = ou * ak2[j0][i0] + u2 * ak2[j0][i0 + 1];
+                  f1 = ou * ak2[j0 + 1][i0] + u2 * ak2[j0 + 1][i0 + 1];
+                  out[k2] = ov * f0 + v2 * f1;
+                }
+                return out;
+              };
+            }
+          };
+        }
+      });
+      var require_create_i_derivative_evaluator = __commonJS({
+        "src/traces/carpet/create_i_derivative_evaluator.js"(exports, module2) {
+          module2.exports = function(arrays, asmoothing, bsmoothing) {
+            if (asmoothing && bsmoothing) {
+              return function(out, i0, j0, u2, v2) {
+                if (!out) out = [];
+                var f0, f1, f2, f3, ak2, k2;
+                i0 *= 3;
+                j0 *= 3;
+                var u22 = u2 * u2;
+                var ou = 1 - u2;
+                var ou2 = ou * ou;
+                var ouu2 = ou * u2 * 2;
+                var a2 = -3 * ou2;
+                var b2 = 3 * (ou2 - ouu2);
+                var c2 = 3 * (ouu2 - u22);
+                var d2 = 3 * u22;
+                var v22 = v2 * v2;
+                var v3 = v22 * v2;
+                var ov = 1 - v2;
+                var ov2 = ov * ov;
+                var ov3 = ov2 * ov;
+                for (k2 = 0; k2 < arrays.length; k2++) {
+                  ak2 = arrays[k2];
+                  f0 = a2 * ak2[j0][i0] + b2 * ak2[j0][i0 + 1] + c2 * ak2[j0][i0 + 2] + d2 * ak2[j0][i0 + 3];
+                  f1 = a2 * ak2[j0 + 1][i0] + b2 * ak2[j0 + 1][i0 + 1] + c2 * ak2[j0 + 1][i0 + 2] + d2 * ak2[j0 + 1][i0 + 3];
+                  f2 = a2 * ak2[j0 + 2][i0] + b2 * ak2[j0 + 2][i0 + 1] + c2 * ak2[j0 + 2][i0 + 2] + d2 * ak2[j0 + 2][i0 + 3];
+                  f3 = a2 * ak2[j0 + 3][i0] + b2 * ak2[j0 + 3][i0 + 1] + c2 * ak2[j0 + 3][i0 + 2] + d2 * ak2[j0 + 3][i0 + 3];
+                  out[k2] = ov3 * f0 + 3 * (ov2 * v2 * f1 + ov * v22 * f2) + v3 * f3;
+                }
+                return out;
+              };
+            } else if (asmoothing) {
+              return function(out, i0, j0, u2, v2) {
+                if (!out) out = [];
+                var f0, f1, k2, ak2;
+                i0 *= 3;
+                var u22 = u2 * u2;
+                var ou = 1 - u2;
+                var ou2 = ou * ou;
+                var ouu2 = ou * u2 * 2;
+                var a2 = -3 * ou2;
+                var b2 = 3 * (ou2 - ouu2);
+                var c2 = 3 * (ouu2 - u22);
+                var d2 = 3 * u22;
+                var ov = 1 - v2;
+                for (k2 = 0; k2 < arrays.length; k2++) {
+                  ak2 = arrays[k2];
+                  f0 = a2 * ak2[j0][i0] + b2 * ak2[j0][i0 + 1] + c2 * ak2[j0][i0 + 2] + d2 * ak2[j0][i0 + 3];
+                  f1 = a2 * ak2[j0 + 1][i0] + b2 * ak2[j0 + 1][i0 + 1] + c2 * ak2[j0 + 1][i0 + 2] + d2 * ak2[j0 + 1][i0 + 3];
+                  out[k2] = ov * f0 + v2 * f1;
+                }
+                return out;
+              };
+            } else if (bsmoothing) {
+              return function(out, i0, j0, u2, v2) {
+                if (!out) out = [];
+                var f0, f1, f2, f3, k2, ak2;
+                j0 *= 3;
+                var v22 = v2 * v2;
+                var v3 = v22 * v2;
+                var ov = 1 - v2;
+                var ov2 = ov * ov;
+                var ov3 = ov2 * ov;
+                for (k2 = 0; k2 < arrays.length; k2++) {
+                  ak2 = arrays[k2];
+                  f0 = ak2[j0][i0 + 1] - ak2[j0][i0];
+                  f1 = ak2[j0 + 1][i0 + 1] - ak2[j0 + 1][i0];
+                  f2 = ak2[j0 + 2][i0 + 1] - ak2[j0 + 2][i0];
+                  f3 = ak2[j0 + 3][i0 + 1] - ak2[j0 + 3][i0];
+                  out[k2] = ov3 * f0 + 3 * (ov2 * v2 * f1 + ov * v22 * f2) + v3 * f3;
+                }
+                return out;
+              };
+            } else {
+              return function(out, i0, j0, u2, v2) {
+                if (!out) out = [];
+                var f0, f1, k2, ak2;
+                var ov = 1 - v2;
+                for (k2 = 0; k2 < arrays.length; k2++) {
+                  ak2 = arrays[k2];
+                  f0 = ak2[j0][i0 + 1] - ak2[j0][i0];
+                  f1 = ak2[j0 + 1][i0 + 1] - ak2[j0 + 1][i0];
+                  out[k2] = ov * f0 + v2 * f1;
+                }
+                return out;
+              };
+            }
+          };
+        }
+      });
+      var require_create_j_derivative_evaluator = __commonJS({
+        "src/traces/carpet/create_j_derivative_evaluator.js"(exports, module2) {
+          module2.exports = function(arrays, asmoothing, bsmoothing) {
+            if (asmoothing && bsmoothing) {
+              return function(out, i0, j0, u2, v2) {
+                if (!out) out = [];
+                var f0, f1, f2, f3, ak2, k2;
+                i0 *= 3;
+                j0 *= 3;
+                var u22 = u2 * u2;
+                var u3 = u22 * u2;
+                var ou = 1 - u2;
+                var ou2 = ou * ou;
+                var ou3 = ou2 * ou;
+                var v22 = v2 * v2;
+                var ov = 1 - v2;
+                var ov2 = ov * ov;
+                var ovv2 = ov * v2 * 2;
+                var a2 = -3 * ov2;
+                var b2 = 3 * (ov2 - ovv2);
+                var c2 = 3 * (ovv2 - v22);
+                var d2 = 3 * v22;
+                for (k2 = 0; k2 < arrays.length; k2++) {
+                  ak2 = arrays[k2];
+                  f0 = a2 * ak2[j0][i0] + b2 * ak2[j0 + 1][i0] + c2 * ak2[j0 + 2][i0] + d2 * ak2[j0 + 3][i0];
+                  f1 = a2 * ak2[j0][i0 + 1] + b2 * ak2[j0 + 1][i0 + 1] + c2 * ak2[j0 + 2][i0 + 1] + d2 * ak2[j0 + 3][i0 + 1];
+                  f2 = a2 * ak2[j0][i0 + 2] + b2 * ak2[j0 + 1][i0 + 2] + c2 * ak2[j0 + 2][i0 + 2] + d2 * ak2[j0 + 3][i0 + 2];
+                  f3 = a2 * ak2[j0][i0 + 3] + b2 * ak2[j0 + 1][i0 + 3] + c2 * ak2[j0 + 2][i0 + 3] + d2 * ak2[j0 + 3][i0 + 3];
+                  out[k2] = ou3 * f0 + 3 * (ou2 * u2 * f1 + ou * u22 * f2) + u3 * f3;
+                }
+                return out;
+              };
+            } else if (asmoothing) {
+              return function(out, i0, j0, v2, u2) {
+                if (!out) out = [];
+                var f0, f1, f2, f3, k2, ak2;
+                i0 *= 3;
+                var u22 = u2 * u2;
+                var u3 = u22 * u2;
+                var ou = 1 - u2;
+                var ou2 = ou * ou;
+                var ou3 = ou2 * ou;
+                for (k2 = 0; k2 < arrays.length; k2++) {
+                  ak2 = arrays[k2];
+                  f0 = ak2[j0 + 1][i0] - ak2[j0][i0];
+                  f1 = ak2[j0 + 1][i0 + 1] - ak2[j0][i0 + 1];
+                  f2 = ak2[j0 + 1][i0 + 2] - ak2[j0][i0 + 2];
+                  f3 = ak2[j0 + 1][i0 + 3] - ak2[j0][i0 + 3];
+                  out[k2] = ou3 * f0 + 3 * (ou2 * u2 * f1 + ou * u22 * f2) + u3 * f3;
+                }
+                return out;
+              };
+            } else if (bsmoothing) {
+              return function(out, i0, j0, u2, v2) {
+                if (!out) out = [];
+                var f0, f1, k2, ak2;
+                j0 *= 3;
+                var ou = 1 - u2;
+                var v22 = v2 * v2;
+                var ov = 1 - v2;
+                var ov2 = ov * ov;
+                var ovv2 = ov * v2 * 2;
+                var a2 = -3 * ov2;
+                var b2 = 3 * (ov2 - ovv2);
+                var c2 = 3 * (ovv2 - v22);
+                var d2 = 3 * v22;
+                for (k2 = 0; k2 < arrays.length; k2++) {
+                  ak2 = arrays[k2];
+                  f0 = a2 * ak2[j0][i0] + b2 * ak2[j0 + 1][i0] + c2 * ak2[j0 + 2][i0] + d2 * ak2[j0 + 3][i0];
+                  f1 = a2 * ak2[j0][i0 + 1] + b2 * ak2[j0 + 1][i0 + 1] + c2 * ak2[j0 + 2][i0 + 1] + d2 * ak2[j0 + 3][i0 + 1];
+                  out[k2] = ou * f0 + u2 * f1;
+                }
+                return out;
+              };
+            } else {
+              return function(out, i0, j0, v2, u2) {
+                if (!out) out = [];
+                var f0, f1, k2, ak2;
+                var ov = 1 - v2;
+                for (k2 = 0; k2 < arrays.length; k2++) {
+                  ak2 = arrays[k2];
+                  f0 = ak2[j0 + 1][i0] - ak2[j0][i0];
+                  f1 = ak2[j0 + 1][i0 + 1] - ak2[j0][i0 + 1];
+                  out[k2] = ov * f0 + v2 * f1;
+                }
+                return out;
+              };
+            }
+          };
+        }
+      });
+      var require_set_convert2 = __commonJS({
+        "src/traces/carpet/set_convert.js"(exports, module2) {
+          var constants = require_constants32();
+          var search = require_search().findBin;
+          var computeControlPoints = require_compute_control_points();
+          var createSplineEvaluator = require_create_spline_evaluator();
+          var createIDerivativeEvaluator = require_create_i_derivative_evaluator();
+          var createJDerivativeEvaluator = require_create_j_derivative_evaluator();
+          module2.exports = function setConvert(trace) {
+            var a2 = trace._a;
+            var b2 = trace._b;
+            var na = a2.length;
+            var nb2 = b2.length;
+            var aax = trace.aaxis;
+            var bax = trace.baxis;
+            var amin = a2[0];
+            var amax = a2[na - 1];
+            var bmin = b2[0];
+            var bmax = b2[nb2 - 1];
+            var arange = a2[a2.length - 1] - a2[0];
+            var brange = b2[b2.length - 1] - b2[0];
+            var atol = arange * constants.RELATIVE_CULL_TOLERANCE;
+            var btol = brange * constants.RELATIVE_CULL_TOLERANCE;
+            amin -= atol;
+            amax += atol;
+            bmin -= btol;
+            bmax += btol;
+            trace.isVisible = function(a22, b22) {
+              return a22 > amin && a22 < amax && b22 > bmin && b22 < bmax;
+            };
+            trace.isOccluded = function(a22, b22) {
+              return a22 < amin || a22 > amax || b22 < bmin || b22 > bmax;
+            };
+            trace.setScale = function() {
+              var x2 = trace._x;
+              var y2 = trace._y;
+              var result = computeControlPoints(trace._xctrl, trace._yctrl, x2, y2, aax.smoothing, bax.smoothing);
+              trace._xctrl = result[0];
+              trace._yctrl = result[1];
+              trace.evalxy = createSplineEvaluator([trace._xctrl, trace._yctrl], na, nb2, aax.smoothing, bax.smoothing);
+              trace.dxydi = createIDerivativeEvaluator([trace._xctrl, trace._yctrl], aax.smoothing, bax.smoothing);
+              trace.dxydj = createJDerivativeEvaluator([trace._xctrl, trace._yctrl], aax.smoothing, bax.smoothing);
+            };
+            trace.i2a = function(i2) {
+              var i0 = Math.max(0, Math.floor(i2[0]), na - 2);
+              var ti2 = i2[0] - i0;
+              return (1 - ti2) * a2[i0] + ti2 * a2[i0 + 1];
+            };
+            trace.j2b = function(j2) {
+              var j0 = Math.max(0, Math.floor(j2[1]), na - 2);
+              var tj2 = j2[1] - j0;
+              return (1 - tj2) * b2[j0] + tj2 * b2[j0 + 1];
+            };
+            trace.ij2ab = function(ij2) {
+              return [trace.i2a(ij2[0]), trace.j2b(ij2[1])];
+            };
+            trace.a2i = function(aval) {
+              var i0 = Math.max(0, Math.min(search(aval, a2), na - 2));
+              var a0 = a2[i0];
+              var a1 = a2[i0 + 1];
+              return Math.max(0, Math.min(na - 1, i0 + (aval - a0) / (a1 - a0)));
+            };
+            trace.b2j = function(bval) {
+              var j0 = Math.max(0, Math.min(search(bval, b2), nb2 - 2));
+              var b0 = b2[j0];
+              var b1 = b2[j0 + 1];
+              return Math.max(0, Math.min(nb2 - 1, j0 + (bval - b0) / (b1 - b0)));
+            };
+            trace.ab2ij = function(ab2) {
+              return [trace.a2i(ab2[0]), trace.b2j(ab2[1])];
+            };
+            trace.i2c = function(i2, j2) {
+              return trace.evalxy([], i2, j2);
+            };
+            trace.ab2xy = function(aval, bval, extrapolate) {
+              if (!extrapolate && (aval < a2[0] || aval > a2[na - 1] | bval < b2[0] || bval > b2[nb2 - 1])) {
+                return [false, false];
+              }
+              var i2 = trace.a2i(aval);
+              var j2 = trace.b2j(bval);
+              var pt2 = trace.evalxy([], i2, j2);
+              if (extrapolate) {
+                var iex = 0;
+                var jex = 0;
+                var der = [];
+                var i0, ti2, j0, tj2;
+                if (aval < a2[0]) {
+                  i0 = 0;
+                  ti2 = 0;
+                  iex = (aval - a2[0]) / (a2[1] - a2[0]);
+                } else if (aval > a2[na - 1]) {
+                  i0 = na - 2;
+                  ti2 = 1;
+                  iex = (aval - a2[na - 1]) / (a2[na - 1] - a2[na - 2]);
+                } else {
+                  i0 = Math.max(0, Math.min(na - 2, Math.floor(i2)));
+                  ti2 = i2 - i0;
+                }
+                if (bval < b2[0]) {
+                  j0 = 0;
+                  tj2 = 0;
+                  jex = (bval - b2[0]) / (b2[1] - b2[0]);
+                } else if (bval > b2[nb2 - 1]) {
+                  j0 = nb2 - 2;
+                  tj2 = 1;
+                  jex = (bval - b2[nb2 - 1]) / (b2[nb2 - 1] - b2[nb2 - 2]);
+                } else {
+                  j0 = Math.max(0, Math.min(nb2 - 2, Math.floor(j2)));
+                  tj2 = j2 - j0;
+                }
+                if (iex) {
+                  trace.dxydi(der, i0, j0, ti2, tj2);
+                  pt2[0] += der[0] * iex;
+                  pt2[1] += der[1] * iex;
+                }
+                if (jex) {
+                  trace.dxydj(der, i0, j0, ti2, tj2);
+                  pt2[0] += der[0] * jex;
+                  pt2[1] += der[1] * jex;
+                }
+              }
+              return pt2;
+            };
+            trace.c2p = function(xy, xa, ya2) {
+              return [xa.c2p(xy[0]), ya2.c2p(xy[1])];
+            };
+            trace.p2x = function(p2, xa, ya2) {
+              return [xa.p2c(p2[0]), ya2.p2c(p2[1])];
+            };
+            trace.dadi = function(i2) {
+              var i0 = Math.max(0, Math.min(a2.length - 2, i2));
+              return a2[i0 + 1] - a2[i0];
+            };
+            trace.dbdj = function(j2) {
+              var j0 = Math.max(0, Math.min(b2.length - 2, j2));
+              return b2[j0 + 1] - b2[j0];
+            };
+            trace.dxyda = function(i0, j0, u2, v2) {
+              var dxydi = trace.dxydi(null, i0, j0, u2, v2);
+              var dadi = trace.dadi(i0, u2);
+              return [dxydi[0] / dadi, dxydi[1] / dadi];
+            };
+            trace.dxydb = function(i0, j0, u2, v2) {
+              var dxydj = trace.dxydj(null, i0, j0, u2, v2);
+              var dbdj = trace.dbdj(j0, v2);
+              return [dxydj[0] / dbdj, dxydj[1] / dbdj];
+            };
+            trace.dxyda_rough = function(a22, b22, reldiff) {
+              var h2 = arange * (reldiff || 0.1);
+              var plus = trace.ab2xy(a22 + h2, b22, true);
+              var minus = trace.ab2xy(a22 - h2, b22, true);
+              return [
+                (plus[0] - minus[0]) * 0.5 / h2,
+                (plus[1] - minus[1]) * 0.5 / h2
+              ];
+            };
+            trace.dxydb_rough = function(a22, b22, reldiff) {
+              var h2 = brange * (reldiff || 0.1);
+              var plus = trace.ab2xy(a22, b22 + h2, true);
+              var minus = trace.ab2xy(a22, b22 - h2, true);
+              return [
+                (plus[0] - minus[0]) * 0.5 / h2,
+                (plus[1] - minus[1]) * 0.5 / h2
+              ];
+            };
+            trace.dpdx = function(xa) {
+              return xa._m;
+            };
+            trace.dpdy = function(ya2) {
+              return ya2._m;
+            };
+          };
+        }
+      });
+      var require_calc38 = __commonJS({
+        "src/traces/carpet/calc.js"(exports, module2) {
+          var Axes = require_axes();
+          var isArray1D = require_lib().isArray1D;
+          var cheaterBasis = require_cheater_basis();
+          var arrayMinmax = require_array_minmax();
+          var calcGridlines = require_calc_gridlines();
+          var calcLabels = require_calc_labels();
+          var calcClipPath = require_calc_clippath();
+          var clean2dArray = require_clean_2d_array();
+          var smoothFill2dArray = require_smooth_fill_2d_array();
+          var convertColumnData = require_convert_column_xyz();
+          var setConvert = require_set_convert2();
+          module2.exports = function calc(gd2, trace) {
+            var xa = Axes.getFromId(gd2, trace.xaxis);
+            var ya2 = Axes.getFromId(gd2, trace.yaxis);
+            var aax = trace.aaxis;
+            var bax = trace.baxis;
+            var x2 = trace.x;
+            var y2 = trace.y;
+            var cols = [];
+            if (x2 && isArray1D(x2)) cols.push("x");
+            if (y2 && isArray1D(y2)) cols.push("y");
+            if (cols.length) {
+              convertColumnData(trace, aax, bax, "a", "b", cols);
+            }
+            var a2 = trace._a = trace._a || trace.a;
+            var b2 = trace._b = trace._b || trace.b;
+            x2 = trace._x || trace.x;
+            y2 = trace._y || trace.y;
+            var t4 = {};
+            if (trace._cheater) {
+              var avals = aax.cheatertype === "index" ? a2.length : a2;
+              var bvals = bax.cheatertype === "index" ? b2.length : b2;
+              x2 = cheaterBasis(avals, bvals, trace.cheaterslope);
+            }
+            trace._x = x2 = clean2dArray(x2);
+            trace._y = y2 = clean2dArray(y2);
+            smoothFill2dArray(x2, a2, b2);
+            smoothFill2dArray(y2, a2, b2);
+            setConvert(trace);
+            trace.setScale();
+            var xrange = arrayMinmax(x2);
+            var yrange = arrayMinmax(y2);
+            var dx = 0.5 * (xrange[1] - xrange[0]);
+            var xc2 = 0.5 * (xrange[1] + xrange[0]);
+            var dy = 0.5 * (yrange[1] - yrange[0]);
+            var yc2 = 0.5 * (yrange[1] + yrange[0]);
+            var grow = 1.3;
+            xrange = [xc2 - dx * grow, xc2 + dx * grow];
+            yrange = [yc2 - dy * grow, yc2 + dy * grow];
+            trace._extremes[xa._id] = Axes.findExtremes(xa, xrange, { padded: true });
+            trace._extremes[ya2._id] = Axes.findExtremes(ya2, yrange, { padded: true });
+            calcGridlines(trace, "a", "b");
+            calcGridlines(trace, "b", "a");
+            calcLabels(trace, aax);
+            calcLabels(trace, bax);
+            t4.clipsegments = calcClipPath(trace._xctrl, trace._yctrl, aax, bax);
+            t4.x = x2;
+            t4.y = y2;
+            t4.a = a2;
+            t4.b = b2;
+            return [t4];
+          };
+        }
+      });
+      var require_carpet = __commonJS({
+        "src/traces/carpet/index.js"(exports, module2) {
+          module2.exports = {
+            attributes: require_attributes63(),
+            supplyDefaults: require_defaults59(),
+            plot: require_plot32(),
+            calc: require_calc38(),
+            animatable: true,
+            isContainer: true,
+            // so carpet traces get `calc` before other traces
+            moduleType: "trace",
+            name: "carpet",
+            basePlotModule: require_cartesian(),
+            categories: ["cartesian", "svg", "carpet", "carpetAxis", "notLegendIsolatable", "noMultiCategory", "noHover", "noSortingByValue"],
+            meta: {}
+          };
+        }
+      });
+      var require_carpet2 = __commonJS({
+        "lib/carpet.js"(exports, module2) {
+          module2.exports = require_carpet();
+        }
+      });
+      var require_attributes64 = __commonJS({
+        "src/traces/scattercarpet/attributes.js"(exports, module2) {
+          var makeFillcolorAttr = require_fillcolor_attribute();
+          var scatterAttrs = require_attributes12();
+          var baseAttrs = require_attributes2();
+          var { hovertemplateAttrs, texttemplateAttrs, templatefallbackAttrs } = require_template_attributes();
+          var colorScaleAttrs = require_attributes8();
+          var extendFlat = require_extend().extendFlat;
+          var scatterMarkerAttrs = scatterAttrs.marker;
+          var scatterLineAttrs = scatterAttrs.line;
+          var scatterMarkerLineAttrs = scatterMarkerAttrs.line;
+          module2.exports = {
+            carpet: {
+              valType: "string",
+              editType: "calc"
+            },
+            a: {
+              valType: "data_array",
+              editType: "calc"
+            },
+            b: {
+              valType: "data_array",
+              editType: "calc"
+            },
+            mode: extendFlat({}, scatterAttrs.mode, { dflt: "markers" }),
+            text: extendFlat({}, scatterAttrs.text, {}),
+            texttemplate: texttemplateAttrs({ editType: "plot" }, { keys: ["a", "b", "text"] }),
+            texttemplatefallback: templatefallbackAttrs({ editType: "plot" }),
+            hovertext: extendFlat({}, scatterAttrs.hovertext, {}),
+            line: {
+              color: scatterLineAttrs.color,
+              width: scatterLineAttrs.width,
+              dash: scatterLineAttrs.dash,
+              backoff: scatterLineAttrs.backoff,
+              shape: extendFlat({}, scatterLineAttrs.shape, { values: ["linear", "spline"] }),
+              smoothing: scatterLineAttrs.smoothing,
+              editType: "calc"
+            },
+            connectgaps: scatterAttrs.connectgaps,
+            fill: extendFlat({}, scatterAttrs.fill, {
+              values: ["none", "toself", "tonext"],
+              dflt: "none"
+            }),
+            fillcolor: makeFillcolorAttr(),
+            marker: extendFlat(
+              {
+                symbol: scatterMarkerAttrs.symbol,
+                opacity: scatterMarkerAttrs.opacity,
+                maxdisplayed: scatterMarkerAttrs.maxdisplayed,
+                angle: scatterMarkerAttrs.angle,
+                angleref: scatterMarkerAttrs.angleref,
+                standoff: scatterMarkerAttrs.standoff,
+                size: scatterMarkerAttrs.size,
+                sizeref: scatterMarkerAttrs.sizeref,
+                sizemin: scatterMarkerAttrs.sizemin,
+                sizemode: scatterMarkerAttrs.sizemode,
+                line: extendFlat(
+                  {
+                    width: scatterMarkerLineAttrs.width,
+                    dash: scatterMarkerLineAttrs.dash,
+                    editType: "calc"
+                  },
+                  colorScaleAttrs("marker.line")
+                ),
+                gradient: scatterMarkerAttrs.gradient,
+                editType: "calc"
+              },
+              colorScaleAttrs("marker")
+            ),
+            textfont: scatterAttrs.textfont,
+            textposition: scatterAttrs.textposition,
+            selected: scatterAttrs.selected,
+            unselected: scatterAttrs.unselected,
+            hoverinfo: extendFlat({}, baseAttrs.hoverinfo, {
+              flags: ["a", "b", "text", "name"]
+            }),
+            hoveron: scatterAttrs.hoveron,
+            hovertemplate: hovertemplateAttrs(),
+            hovertemplatefallback: templatefallbackAttrs(),
+            zorder: scatterAttrs.zorder
+          };
+        }
+      });
+      var require_defaults60 = __commonJS({
+        "src/traces/scattercarpet/defaults.js"(exports, module2) {
+          var Lib = require_lib();
+          var constants = require_constants8();
+          var subTypes = require_subtypes();
+          var handleMarkerDefaults = require_marker_defaults();
+          var handleLineDefaults = require_line_defaults();
+          var handleLineShapeDefaults = require_line_shape_defaults();
+          var handleTextDefaults = require_text_defaults();
+          var handleFillColorDefaults = require_fillcolor_defaults();
+          var attributes = require_attributes64();
+          module2.exports = function supplyDefaults(traceIn, traceOut, defaultColor, layout) {
+            function coerce(attr, dflt) {
+              return Lib.coerce(traceIn, traceOut, attributes, attr, dflt);
+            }
+            coerce("carpet");
+            traceOut.xaxis = "x";
+            traceOut.yaxis = "y";
+            var a2 = coerce("a");
+            var b2 = coerce("b");
+            var len2 = Math.min(a2.length, b2.length);
+            if (!len2) {
+              traceOut.visible = false;
+              return;
+            }
+            traceOut._length = len2;
+            coerce("text");
+            coerce("texttemplate");
+            coerce("texttemplatefallback");
+            coerce("hovertext");
+            var defaultMode = len2 < constants.PTS_LINESONLY ? "lines+markers" : "lines";
+            coerce("mode", defaultMode);
+            if (subTypes.hasMarkers(traceOut)) {
+              handleMarkerDefaults(traceIn, traceOut, defaultColor, layout, coerce, { gradient: true });
+            }
+            if (subTypes.hasLines(traceOut)) {
+              handleLineDefaults(traceIn, traceOut, defaultColor, layout, coerce, { backoff: true });
+              handleLineShapeDefaults(traceIn, traceOut, coerce);
+              coerce("connectgaps");
+            }
+            if (subTypes.hasText(traceOut)) {
+              handleTextDefaults(traceIn, traceOut, layout, coerce);
+            }
+            var dfltHoverOn = [];
+            if (subTypes.hasMarkers(traceOut) || subTypes.hasText(traceOut)) {
+              coerce("marker.maxdisplayed");
+              dfltHoverOn.push("points");
+            }
+            coerce("fill");
+            if (traceOut.fill !== "none") {
+              handleFillColorDefaults(traceIn, traceOut, defaultColor, coerce);
+              if (!subTypes.hasLines(traceOut)) handleLineShapeDefaults(traceIn, traceOut, coerce);
+            }
+            if (traceOut.fill === "tonext" || traceOut.fill === "toself") {
+              dfltHoverOn.push("fills");
+            }
+            var hoverOn = coerce("hoveron", dfltHoverOn.join("+") || "points");
+            if (hoverOn !== "fills") {
+              coerce("hovertemplate");
+              coerce("hovertemplatefallback");
+            }
+            coerce("zorder");
+            Lib.coerceSelectionMarkerOpacity(traceOut, coerce);
+          };
+        }
+      });
+      var require_format_labels7 = __commonJS({
+        "src/traces/scattercarpet/format_labels.js"(exports, module2) {
+          module2.exports = function formatLabels(cdi, trace) {
+            var labels = {};
+            var carpet = trace._carpet;
+            var ij2 = carpet.ab2ij([cdi.a, cdi.b]);
+            var i0 = Math.floor(ij2[0]);
+            var ti2 = ij2[0] - i0;
+            var j0 = Math.floor(ij2[1]);
+            var tj2 = ij2[1] - j0;
+            var xy = carpet.evalxy([], i0, j0, ti2, tj2);
+            labels.yLabel = xy[1].toFixed(3);
+            return labels;
+          };
+        }
+      });
+      var require_lookup_carpetid = __commonJS({
+        "src/traces/carpet/lookup_carpetid.js"(exports, module2) {
+          module2.exports = function(gd2, trace) {
+            var n2 = gd2._fullData.length;
+            var firstAxis;
+            for (var i2 = 0; i2 < n2; i2++) {
+              var maybeCarpet = gd2._fullData[i2];
+              if (maybeCarpet.index === trace.index) continue;
+              if (maybeCarpet.type === "carpet") {
+                if (!firstAxis) {
+                  firstAxis = maybeCarpet;
+                }
+                if (maybeCarpet.carpet === trace.carpet) {
+                  return maybeCarpet;
+                }
+              }
+            }
+            return firstAxis;
+          };
+        }
+      });
+      var require_calc39 = __commonJS({
+        "src/traces/scattercarpet/calc.js"(exports, module2) {
+          var isNumeric = require_fast_isnumeric();
+          var calcColorscale = require_colorscale_calc();
+          var arraysToCalcdata = require_arrays_to_calcdata();
+          var calcSelection = require_calc_selection();
+          var calcMarkerSize = require_calc3().calcMarkerSize;
+          var lookupCarpet = require_lookup_carpetid();
+          module2.exports = function calc(gd2, trace) {
+            var carpet = trace._carpetTrace = lookupCarpet(gd2, trace);
+            if (!carpet || !carpet.visible || carpet.visible === "legendonly") return;
+            var i2;
+            trace.xaxis = carpet.xaxis;
+            trace.yaxis = carpet.yaxis;
+            var serieslen = trace._length;
+            var cd2 = new Array(serieslen);
+            var a2, b2;
+            var needsCull = false;
+            for (i2 = 0; i2 < serieslen; i2++) {
+              a2 = trace.a[i2];
+              b2 = trace.b[i2];
+              if (isNumeric(a2) && isNumeric(b2)) {
+                var xy = carpet.ab2xy(+a2, +b2, true);
+                var visible = carpet.isVisible(+a2, +b2);
+                if (!visible) needsCull = true;
+                cd2[i2] = { x: xy[0], y: xy[1], a: a2, b: b2, vis: visible };
+              } else cd2[i2] = { x: false, y: false };
+            }
+            trace._needsCull = needsCull;
+            cd2[0].carpet = carpet;
+            cd2[0].trace = trace;
+            calcMarkerSize(trace, serieslen);
+            calcColorscale(gd2, trace);
+            arraysToCalcdata(cd2, trace);
+            calcSelection(cd2, trace);
+            return cd2;
+          };
+        }
+      });
+      var require_plot33 = __commonJS({
+        "src/traces/scattercarpet/plot.js"(exports, module2) {
+          var scatterPlot = require_plot();
+          var Axes = require_axes();
+          var Drawing = require_drawing();
+          module2.exports = function plot(gd2, plotinfoproxy, data, layer) {
+            var i2, trace, node;
+            var carpet = data[0][0].carpet;
+            var xaxis = Axes.getFromId(gd2, carpet.xaxis || "x");
+            var yaxis = Axes.getFromId(gd2, carpet.yaxis || "y");
+            var plotinfo = {
+              xaxis,
+              yaxis,
+              plot: plotinfoproxy.plot
+            };
+            for (i2 = 0; i2 < data.length; i2++) {
+              trace = data[i2][0].trace;
+              trace._xA = xaxis;
+              trace._yA = yaxis;
+            }
+            scatterPlot(gd2, plotinfo, data, layer);
+            for (i2 = 0; i2 < data.length; i2++) {
+              trace = data[i2][0].trace;
+              node = layer.selectAll("g.trace" + trace.uid + " .js-line");
+              Drawing.setClipUrl(node, data[i2][0].carpet._clipPathId, gd2);
+            }
+          };
+        }
+      });
+      var require_hover22 = __commonJS({
+        "src/traces/scattercarpet/hover.js"(exports, module2) {
+          var scatterHover = require_hover2();
+          var fillText = require_lib().fillText;
+          module2.exports = function hoverPoints(pointData, xval, yval, hovermode) {
+            var scatterPointData = scatterHover(pointData, xval, yval, hovermode);
+            if (!scatterPointData || scatterPointData[0].index === false) return;
+            var newPointData = scatterPointData[0];
+            if (newPointData.index === void 0) {
+              var yFracUp = 1 - newPointData.y0 / pointData.ya._length;
+              var xLen = pointData.xa._length;
+              var xMin = xLen * yFracUp / 2;
+              var xMax = xLen - xMin;
+              newPointData.x0 = Math.max(Math.min(newPointData.x0, xMax), xMin);
+              newPointData.x1 = Math.max(Math.min(newPointData.x1, xMax), xMin);
+              return scatterPointData;
+            }
+            var cdi = newPointData.cd[newPointData.index];
+            newPointData.a = cdi.a;
+            newPointData.b = cdi.b;
+            newPointData.xLabelVal = void 0;
+            newPointData.yLabelVal = void 0;
+            var trace = newPointData.trace;
+            var carpet = trace._carpet;
+            var labels = trace._module.formatLabels(cdi, trace);
+            newPointData.yLabel = labels.yLabel;
+            delete newPointData.text;
+            var text = [];
+            function textPart(ax, val) {
+              var prefix;
+              if (ax.labelprefix && ax.labelprefix.length > 0) {
+                prefix = ax.labelprefix.replace(/ = $/, "");
+              } else {
+                prefix = ax._hovertitle;
+              }
+              text.push(prefix + ": " + val.toFixed(3) + ax.labelsuffix);
+            }
+            if (!trace.hovertemplate) {
+              var hoverinfo = cdi.hi || trace.hoverinfo;
+              var parts = hoverinfo.split("+");
+              if (parts.indexOf("all") !== -1) parts = ["a", "b", "text"];
+              if (parts.indexOf("a") !== -1) textPart(carpet.aaxis, cdi.a);
+              if (parts.indexOf("b") !== -1) textPart(carpet.baxis, cdi.b);
+              text.push("y: " + newPointData.yLabel);
+              if (parts.indexOf("text") !== -1) {
+                fillText(cdi, trace, text);
+              }
+              newPointData.extraText = text.join("<br>");
+            }
+            return scatterPointData;
+          };
+        }
+      });
+      var require_event_data15 = __commonJS({
+        "src/traces/scattercarpet/event_data.js"(exports, module2) {
+          module2.exports = function eventData(out, pt2, trace, cd2, pointNumber) {
+            var cdi = cd2[pointNumber];
+            out.a = cdi.a;
+            out.b = cdi.b;
+            out.y = cdi.y;
+            return out;
+          };
+        }
+      });
+      var require_scattercarpet = __commonJS({
+        "src/traces/scattercarpet/index.js"(exports, module2) {
+          module2.exports = {
+            attributes: require_attributes64(),
+            supplyDefaults: require_defaults60(),
+            colorbar: require_marker_colorbar(),
+            formatLabels: require_format_labels7(),
+            calc: require_calc39(),
+            plot: require_plot33(),
+            style: require_style2().style,
+            styleOnSelect: require_style2().styleOnSelect,
+            hoverPoints: require_hover22(),
+            selectPoints: require_select2(),
+            eventData: require_event_data15(),
+            moduleType: "trace",
+            name: "scattercarpet",
+            basePlotModule: require_cartesian(),
+            categories: ["svg", "carpet", "symbols", "showLegend", "carpetDependent", "zoomScale"],
+            meta: {}
+          };
+        }
+      });
+      var require_scattercarpet2 = __commonJS({
+        "lib/scattercarpet.js"(exports, module2) {
+          module2.exports = require_scattercarpet();
+        }
+      });
+      var require_attributes65 = __commonJS({
+        "src/traces/contourcarpet/attributes.js"(exports, module2) {
+          var heatmapAttrs = require_attributes25();
+          var contourAttrs = require_attributes28();
+          var colorScaleAttrs = require_attributes8();
+          var extendFlat = require_extend().extendFlat;
+          var contourContourAttrs = contourAttrs.contours;
+          module2.exports = extendFlat(
+            {
+              carpet: {
+                valType: "string",
+                editType: "calc"
+              },
+              z: heatmapAttrs.z,
+              a: heatmapAttrs.x,
+              a0: heatmapAttrs.x0,
+              da: heatmapAttrs.dx,
+              b: heatmapAttrs.y,
+              b0: heatmapAttrs.y0,
+              db: heatmapAttrs.dy,
+              text: heatmapAttrs.text,
+              hovertext: heatmapAttrs.hovertext,
+              transpose: heatmapAttrs.transpose,
+              atype: heatmapAttrs.xtype,
+              btype: heatmapAttrs.ytype,
+              fillcolor: contourAttrs.fillcolor,
+              autocontour: contourAttrs.autocontour,
+              ncontours: contourAttrs.ncontours,
+              contours: {
+                type: contourContourAttrs.type,
+                start: contourContourAttrs.start,
+                end: contourContourAttrs.end,
+                size: contourContourAttrs.size,
+                coloring: {
+                  // from contourAttrs.contours.coloring but no 'heatmap' option
+                  valType: "enumerated",
+                  values: ["fill", "lines", "none"],
+                  dflt: "fill",
+                  editType: "calc"
+                },
+                showlines: contourContourAttrs.showlines,
+                showlabels: contourContourAttrs.showlabels,
+                labelfont: contourContourAttrs.labelfont,
+                labelformat: contourContourAttrs.labelformat,
+                operation: contourContourAttrs.operation,
+                value: contourContourAttrs.value,
+                editType: "calc",
+                impliedEdits: { autocontour: false }
+              },
+              line: {
+                color: contourAttrs.line.color,
+                width: contourAttrs.line.width,
+                dash: contourAttrs.line.dash,
+                smoothing: contourAttrs.line.smoothing,
+                editType: "plot"
+              },
+              zorder: contourAttrs.zorder
+            },
+            colorScaleAttrs("", {
+              cLetter: "z",
+              autoColorDflt: false
+            })
+          );
+        }
+      });
+      var require_defaults61 = __commonJS({
+        "src/traces/contourcarpet/defaults.js"(exports, module2) {
+          var Lib = require_lib();
+          var handleXYZDefaults = require_xyz_defaults();
+          var attributes = require_attributes65();
+          var handleConstraintDefaults = require_constraint_defaults();
+          var handleContoursDefaults = require_contours_defaults();
+          var handleStyleDefaults = require_style_defaults3();
+          module2.exports = function supplyDefaults(traceIn, traceOut, defaultColor, layout) {
+            function coerce(attr, dflt) {
+              return Lib.coerce(traceIn, traceOut, attributes, attr, dflt);
+            }
+            function coerce2(attr) {
+              return Lib.coerce2(traceIn, traceOut, attributes, attr);
+            }
+            coerce("carpet");
+            if (traceIn.a && traceIn.b) {
+              var len2 = handleXYZDefaults(traceIn, traceOut, coerce, layout, "a", "b");
+              if (!len2) {
+                traceOut.visible = false;
+                return;
+              }
+              coerce("text");
+              var isConstraint = coerce("contours.type") === "constraint";
+              if (isConstraint) {
+                handleConstraintDefaults(traceIn, traceOut, coerce, layout, defaultColor, { hasHover: false });
+              } else {
+                handleContoursDefaults(traceIn, traceOut, coerce, coerce2);
+                handleStyleDefaults(traceIn, traceOut, coerce, layout, { hasHover: false });
+              }
+            } else {
+              traceOut._defaultColor = defaultColor;
+              traceOut._length = null;
+            }
+            coerce("zorder");
+          };
+        }
+      });
+      var require_calc40 = __commonJS({
+        "src/traces/contourcarpet/calc.js"(exports, module2) {
+          var colorscaleCalc = require_calc();
+          var Lib = require_lib();
+          var convertColumnData = require_convert_column_xyz();
+          var clean2dArray = require_clean_2d_array();
+          var interp2d = require_interp2d();
+          var findEmpties = require_find_empties();
+          var makeBoundArray = require_make_bound_array();
+          var supplyDefaults = require_defaults61();
+          var lookupCarpet = require_lookup_carpetid();
+          var setContours = require_set_contours();
+          module2.exports = function calc(gd2, trace) {
+            var carpet = trace._carpetTrace = lookupCarpet(gd2, trace);
+            if (!carpet || !carpet.visible || carpet.visible === "legendonly") return;
+            if (!trace.a || !trace.b) {
+              var carpetdata = gd2.data[carpet.index];
+              var tracedata = gd2.data[trace.index];
+              if (!tracedata.a) tracedata.a = carpetdata.a;
+              if (!tracedata.b) tracedata.b = carpetdata.b;
+              supplyDefaults(tracedata, trace, trace._defaultColor, gd2._fullLayout);
+            }
+            var cd2 = heatmappishCalc(gd2, trace);
+            setContours(trace, trace._z);
+            return cd2;
+          };
+          function heatmappishCalc(gd2, trace) {
+            var carpet = trace._carpetTrace;
+            var aax = carpet.aaxis;
+            var bax = carpet.baxis;
+            var a2, a0, da2, b2, b0, db2, z2;
+            aax._minDtick = 0;
+            bax._minDtick = 0;
+            if (Lib.isArray1D(trace.z)) convertColumnData(trace, aax, bax, "a", "b", ["z"]);
+            a2 = trace._a = trace._a || trace.a;
+            b2 = trace._b = trace._b || trace.b;
+            a2 = a2 ? aax.makeCalcdata(trace, "_a") : [];
+            b2 = b2 ? bax.makeCalcdata(trace, "_b") : [];
+            a0 = trace.a0 || 0;
+            da2 = trace.da || 1;
+            b0 = trace.b0 || 0;
+            db2 = trace.db || 1;
+            z2 = trace._z = clean2dArray(trace._z || trace.z, trace.transpose);
+            trace._emptypoints = findEmpties(z2);
+            interp2d(z2, trace._emptypoints);
+            var xlen = Lib.maxRowLength(z2);
+            var xIn = trace.xtype === "scaled" ? "" : a2;
+            var xArray = makeBoundArray(trace, xIn, a0, da2, xlen, aax);
+            var yIn = trace.ytype === "scaled" ? "" : b2;
+            var yArray = makeBoundArray(trace, yIn, b0, db2, z2.length, bax);
+            var cd0 = {
+              a: xArray,
+              b: yArray,
+              z: z2
+            };
+            if (trace.contours.type === "levels" && trace.contours.coloring !== "none") {
+              colorscaleCalc(gd2, trace, {
+                vals: z2,
+                containerStr: "",
+                cLetter: "z"
+              });
+            }
+            return [cd0];
+          }
+        }
+      });
+      var require_axis_aligned_line = __commonJS({
+        "src/traces/carpet/axis_aligned_line.js"(exports, module2) {
+          var isArrayOrTypedArray = require_lib().isArrayOrTypedArray;
+          module2.exports = function(carpet, carpetcd, a2, b2) {
+            var idx, tangent, tanIsoIdx, tanIsoPar, segment, refidx;
+            var p0, p1, v0, v1, start, end, range;
+            var axis = isArrayOrTypedArray(a2) ? "a" : "b";
+            var ax = axis === "a" ? carpet.aaxis : carpet.baxis;
+            var smoothing = ax.smoothing;
+            var toIdx = axis === "a" ? carpet.a2i : carpet.b2j;
+            var pt2 = axis === "a" ? a2 : b2;
+            var iso = axis === "a" ? b2 : a2;
+            var n2 = axis === "a" ? carpetcd.a.length : carpetcd.b.length;
+            var m2 = axis === "a" ? carpetcd.b.length : carpetcd.a.length;
+            var isoIdx = Math.floor(axis === "a" ? carpet.b2j(iso) : carpet.a2i(iso));
+            var xy = axis === "a" ? function(value) {
+              return carpet.evalxy([], value, isoIdx);
+            } : function(value) {
+              return carpet.evalxy([], isoIdx, value);
+            };
+            if (smoothing) {
+              tanIsoIdx = Math.max(0, Math.min(m2 - 2, isoIdx));
+              tanIsoPar = isoIdx - tanIsoIdx;
+              tangent = axis === "a" ? function(i2, ti2) {
+                return carpet.dxydi([], i2, tanIsoIdx, ti2, tanIsoPar);
+              } : function(j2, tj2) {
+                return carpet.dxydj([], tanIsoIdx, j2, tanIsoPar, tj2);
+              };
+            }
+            var vstart = toIdx(pt2[0]);
+            var vend = toIdx(pt2[1]);
+            var dir = vstart < vend ? 1 : -1;
+            var tol = (vend - vstart) * 1e-8;
+            var dirfloor = dir > 0 ? Math.floor : Math.ceil;
+            var dirceil = dir > 0 ? Math.ceil : Math.floor;
+            var dirmin = dir > 0 ? Math.min : Math.max;
+            var dirmax = dir > 0 ? Math.max : Math.min;
+            var idx0 = dirfloor(vstart + tol);
+            var idx1 = dirceil(vend - tol);
+            p0 = xy(vstart);
+            var segments = [[p0]];
+            for (idx = idx0; idx * dir < idx1 * dir; idx += dir) {
+              segment = [];
+              start = dirmax(vstart, idx);
+              end = dirmin(vend, idx + dir);
+              range = end - start;
+              refidx = Math.max(0, Math.min(n2 - 2, Math.floor(0.5 * (start + end))));
+              p1 = xy(end);
+              if (smoothing) {
+                v0 = tangent(refidx, start - refidx);
+                v1 = tangent(refidx, end - refidx);
+                segment.push([
+                  p0[0] + v0[0] / 3 * range,
+                  p0[1] + v0[1] / 3 * range
+                ]);
+                segment.push([
+                  p1[0] - v1[0] / 3 * range,
+                  p1[1] - v1[1] / 3 * range
+                ]);
+              }
+              segment.push(p1);
+              segments.push(segment);
+              p0 = p1;
+            }
+            return segments;
+          };
+        }
+      });
+      var require_plot34 = __commonJS({
+        "src/traces/contourcarpet/plot.js"(exports, module2) {
+          var d3 = require_d3();
+          var map1dArray = require_map_1d_array();
+          var makepath = require_makepath();
+          var Drawing = require_drawing();
+          var Lib = require_lib();
+          var makeCrossings = require_make_crossings();
+          var findAllPaths = require_find_all_paths();
+          var contourPlot = require_plot6();
+          var constants = require_constants16();
+          var convertToConstraints = require_convert_to_constraints();
+          var emptyPathinfo = require_empty_pathinfo();
+          var closeBoundaries = require_close_boundaries();
+          var lookupCarpet = require_lookup_carpetid();
+          var axisAlignedLine = require_axis_aligned_line();
+          module2.exports = function plot(gd2, plotinfo, cdcontours, contourcarpetLayer) {
+            var xa = plotinfo.xaxis;
+            var ya2 = plotinfo.yaxis;
+            Lib.makeTraceGroups(contourcarpetLayer, cdcontours, "contour").each(function(cd2) {
+              var plotGroup = d3.select(this);
+              var cd0 = cd2[0];
+              var trace = cd0.trace;
+              var carpet = trace._carpetTrace = lookupCarpet(gd2, trace);
+              var carpetcd = gd2.calcdata[carpet.index][0];
+              if (!carpet.visible || carpet.visible === "legendonly") return;
+              var a2 = cd0.a;
+              var b2 = cd0.b;
+              var contours = trace.contours;
+              var pathinfo = emptyPathinfo(contours, plotinfo, cd0);
+              var isConstraint = contours.type === "constraint";
+              var operation = contours._operation;
+              var coloring = isConstraint ? operation === "=" ? "lines" : "fill" : contours.coloring;
+              function ab2p(ab2) {
+                var pt2 = carpet.ab2xy(ab2[0], ab2[1], true);
+                return [xa.c2p(pt2[0]), ya2.c2p(pt2[1])];
+              }
+              var perimeter = [
+                [a2[0], b2[b2.length - 1]],
+                [a2[a2.length - 1], b2[b2.length - 1]],
+                [a2[a2.length - 1], b2[0]],
+                [a2[0], b2[0]]
+              ];
+              makeCrossings(pathinfo);
+              var atol = (a2[a2.length - 1] - a2[0]) * 1e-8;
+              var btol = (b2[b2.length - 1] - b2[0]) * 1e-8;
+              findAllPaths(pathinfo, atol, btol);
+              var fillPathinfo = pathinfo;
+              if (contours.type === "constraint") {
+                fillPathinfo = convertToConstraints(pathinfo, operation);
+              }
+              mapPathinfo(pathinfo, ab2p);
+              var seg, xp, yp, i2;
+              var segs = [];
+              for (i2 = carpetcd.clipsegments.length - 1; i2 >= 0; i2--) {
+                seg = carpetcd.clipsegments[i2];
+                xp = map1dArray([], seg.x, xa.c2p);
+                yp = map1dArray([], seg.y, ya2.c2p);
+                xp.reverse();
+                yp.reverse();
+                segs.push(makepath(xp, yp, seg.bicubic));
+              }
+              var boundaryPath = "M" + segs.join("L") + "Z";
+              makeBackground(plotGroup, carpetcd.clipsegments, xa, ya2, isConstraint, coloring);
+              makeFills(trace, plotGroup, xa, ya2, fillPathinfo, perimeter, ab2p, carpet, carpetcd, coloring, boundaryPath);
+              makeLinesAndLabels(plotGroup, pathinfo, gd2, cd0, contours, plotinfo, carpet);
+              Drawing.setClipUrl(plotGroup, carpet._clipPathId, gd2);
+            });
+          };
+          function mapPathinfo(pathinfo, map2) {
+            var i2, j2, k2, pi2, pedgepaths, ppaths, pedgepath, ppath, path;
+            for (i2 = 0; i2 < pathinfo.length; i2++) {
+              pi2 = pathinfo[i2];
+              pedgepaths = pi2.pedgepaths = [];
+              ppaths = pi2.ppaths = [];
+              for (j2 = 0; j2 < pi2.edgepaths.length; j2++) {
+                path = pi2.edgepaths[j2];
+                pedgepath = [];
+                for (k2 = 0; k2 < path.length; k2++) {
+                  pedgepath[k2] = map2(path[k2]);
+                }
+                pedgepaths.push(pedgepath);
+              }
+              for (j2 = 0; j2 < pi2.paths.length; j2++) {
+                path = pi2.paths[j2];
+                ppath = [];
+                for (k2 = 0; k2 < path.length; k2++) {
+                  ppath[k2] = map2(path[k2]);
+                }
+                ppaths.push(ppath);
+              }
+            }
+          }
+          function makeLinesAndLabels(plotgroup, pathinfo, gd2, cd0, contours, plotinfo, carpet) {
+            var isStatic = gd2._context.staticPlot;
+            var lineContainer = Lib.ensureSingle(plotgroup, "g", "contourlines");
+            var showLines = contours.showlines !== false;
+            var showLabels = contours.showlabels;
+            var clipLinesForLabels = showLines && showLabels;
+            var linegroup = contourPlot.createLines(lineContainer, showLines || showLabels, pathinfo, isStatic);
+            var lineClip = contourPlot.createLineClip(lineContainer, clipLinesForLabels, gd2, cd0.trace.uid);
+            var labelGroup = plotgroup.selectAll("g.contourlabels").data(showLabels ? [0] : []);
+            labelGroup.exit().remove();
+            labelGroup.enter().append("g").classed("contourlabels", true);
+            if (showLabels) {
+              var xa = plotinfo.xaxis;
+              var ya2 = plotinfo.yaxis;
+              var xLen = xa._length;
+              var yLen = ya2._length;
+              var labelClipPathData = [[
+                [0, 0],
+                [xLen, 0],
+                [xLen, yLen],
+                [0, yLen]
+              ]];
+              var labelData = [];
+              Lib.clearLocationCache();
+              var contourFormat = contourPlot.labelFormatter(gd2, cd0);
+              var dummyText = Drawing.tester.append("text").attr("data-notex", 1).call(Drawing.font, contours.labelfont);
+              var bounds = {
+                left: 0,
+                right: xLen,
+                center: xLen / 2,
+                top: 0,
+                bottom: yLen,
+                middle: yLen / 2
+              };
+              var plotDiagonal = Math.sqrt(xLen * xLen + yLen * yLen);
+              var normLength = constants.LABELDISTANCE * plotDiagonal / Math.max(1, pathinfo.length / constants.LABELINCREASE);
+              linegroup.each(function(d2) {
+                var textOpts = contourPlot.calcTextOpts(d2.level, contourFormat, dummyText, gd2);
+                d3.select(this).selectAll("path").each(function(pathData) {
+                  var path = this;
+                  var pathBounds = Lib.getVisibleSegment(path, bounds, textOpts.height / 2);
+                  if (!pathBounds) return;
+                  constrainToCarpet(path, pathData, d2, pathBounds, carpet, textOpts.height);
+                  if (pathBounds.len < (textOpts.width + textOpts.height) * constants.LABELMIN) return;
+                  var maxLabels = Math.min(
+                    Math.ceil(pathBounds.len / normLength),
+                    constants.LABELMAX
+                  );
+                  for (var i2 = 0; i2 < maxLabels; i2++) {
+                    var loc = contourPlot.findBestTextLocation(
+                      path,
+                      pathBounds,
+                      textOpts,
+                      labelData,
+                      bounds
+                    );
+                    if (!loc) break;
+                    contourPlot.addLabelData(loc, textOpts, labelData, labelClipPathData);
+                  }
+                });
+              });
+              dummyText.remove();
+              contourPlot.drawLabels(
+                labelGroup,
+                labelData,
+                gd2,
+                lineClip,
+                clipLinesForLabels ? labelClipPathData : null
+              );
+            }
+            if (showLabels && !showLines) linegroup.remove();
+          }
+          function constrainToCarpet(path, pathData, levelData, pathBounds, carpet, textHeight) {
+            var pathABData;
+            for (var i2 = 0; i2 < levelData.pedgepaths.length; i2++) {
+              if (pathData === levelData.pedgepaths[i2]) {
+                pathABData = levelData.edgepaths[i2];
+              }
+            }
+            if (!pathABData) return;
+            var aMin = carpet.a[0];
+            var aMax = carpet.a[carpet.a.length - 1];
+            var bMin = carpet.b[0];
+            var bMax = carpet.b[carpet.b.length - 1];
+            function getOffset(abPt, pathVector) {
+              var offset = 0;
+              var edgeVector;
+              var dAB = 0.1;
+              if (Math.abs(abPt[0] - aMin) < dAB || Math.abs(abPt[0] - aMax) < dAB) {
+                edgeVector = normalizeVector(carpet.dxydb_rough(abPt[0], abPt[1], dAB));
+                offset = Math.max(offset, textHeight * vectorTan(pathVector, edgeVector) / 2);
+              }
+              if (Math.abs(abPt[1] - bMin) < dAB || Math.abs(abPt[1] - bMax) < dAB) {
+                edgeVector = normalizeVector(carpet.dxyda_rough(abPt[0], abPt[1], dAB));
+                offset = Math.max(offset, textHeight * vectorTan(pathVector, edgeVector) / 2);
+              }
+              return offset;
+            }
+            var startVector = getUnitVector(path, 0, 1);
+            var endVector = getUnitVector(path, pathBounds.total, pathBounds.total - 1);
+            var minStart = getOffset(pathABData[0], startVector);
+            var maxEnd = pathBounds.total - getOffset(pathABData[pathABData.length - 1], endVector);
+            if (pathBounds.min < minStart) pathBounds.min = minStart;
+            if (pathBounds.max > maxEnd) pathBounds.max = maxEnd;
+            pathBounds.len = pathBounds.max - pathBounds.min;
+          }
+          function getUnitVector(path, p0, p1) {
+            var pt0 = path.getPointAtLength(p0);
+            var pt1 = path.getPointAtLength(p1);
+            var dx = pt1.x - pt0.x;
+            var dy = pt1.y - pt0.y;
+            var len2 = Math.sqrt(dx * dx + dy * dy);
+            return [dx / len2, dy / len2];
+          }
+          function normalizeVector(v2) {
+            var len2 = Math.sqrt(v2[0] * v2[0] + v2[1] * v2[1]);
+            return [v2[0] / len2, v2[1] / len2];
+          }
+          function vectorTan(v0, v1) {
+            var cos = Math.abs(v0[0] * v1[0] + v0[1] * v1[1]);
+            var sin = Math.sqrt(1 - cos * cos);
+            return sin / cos;
+          }
+          function makeBackground(plotgroup, clipsegments, xaxis, yaxis, isConstraint, coloring) {
+            var seg, xp, yp, i2;
+            var bggroup = Lib.ensureSingle(plotgroup, "g", "contourbg");
+            var bgfill = bggroup.selectAll("path").data(coloring === "fill" && !isConstraint ? [0] : []);
+            bgfill.enter().append("path");
+            bgfill.exit().remove();
+            var segs = [];
+            for (i2 = 0; i2 < clipsegments.length; i2++) {
+              seg = clipsegments[i2];
+              xp = map1dArray([], seg.x, xaxis.c2p);
+              yp = map1dArray([], seg.y, yaxis.c2p);
+              segs.push(makepath(xp, yp, seg.bicubic));
+            }
+            bgfill.attr("d", "M" + segs.join("L") + "Z").style("stroke", "none");
+          }
+          function makeFills(trace, plotgroup, xa, ya2, pathinfo, perimeter, ab2p, carpet, carpetcd, coloring, boundaryPath) {
+            var hasFills = coloring === "fill";
+            if (hasFills) {
+              closeBoundaries(pathinfo, trace.contours);
+            }
+            var fillgroup = Lib.ensureSingle(plotgroup, "g", "contourfill");
+            var fillitems = fillgroup.selectAll("path").data(hasFills ? pathinfo : []);
+            fillitems.enter().append("path");
+            fillitems.exit().remove();
+            fillitems.each(function(pi2) {
+              var fullpath = (pi2.prefixBoundary ? boundaryPath : "") + joinAllPaths(trace, pi2, perimeter, ab2p, carpet, carpetcd, xa, ya2);
+              if (!fullpath) {
+                d3.select(this).remove();
+              } else {
+                d3.select(this).attr("d", fullpath).style("stroke", "none");
+              }
+            });
+          }
+          function joinAllPaths(trace, pi2, perimeter, ab2p, carpet, carpetcd, xa, ya2) {
+            var i2;
+            var fullpath = "";
+            var startsleft = pi2.edgepaths.map(function(v2, i22) {
+              return i22;
+            });
+            var newloop = true;
+            var endpt, newendpt, cnt, nexti, possiblei, addpath;
+            var atol = Math.abs(perimeter[0][0] - perimeter[2][0]) * 1e-4;
+            var btol = Math.abs(perimeter[0][1] - perimeter[2][1]) * 1e-4;
+            function istop(pt2) {
+              return Math.abs(pt2[1] - perimeter[0][1]) < btol;
+            }
+            function isbottom(pt2) {
+              return Math.abs(pt2[1] - perimeter[2][1]) < btol;
+            }
+            function isleft(pt2) {
+              return Math.abs(pt2[0] - perimeter[0][0]) < atol;
+            }
+            function isright(pt2) {
+              return Math.abs(pt2[0] - perimeter[2][0]) < atol;
+            }
+            function pathto(pt0, pt1) {
+              var i22, j2, segments, axis;
+              var path = "";
+              if (istop(pt0) && !isright(pt0) || isbottom(pt0) && !isleft(pt0)) {
+                axis = carpet.aaxis;
+                segments = axisAlignedLine(carpet, carpetcd, [pt0[0], pt1[0]], 0.5 * (pt0[1] + pt1[1]));
+              } else {
+                axis = carpet.baxis;
+                segments = axisAlignedLine(carpet, carpetcd, 0.5 * (pt0[0] + pt1[0]), [pt0[1], pt1[1]]);
+              }
+              for (i22 = 1; i22 < segments.length; i22++) {
+                path += axis.smoothing ? "C" : "L";
+                for (j2 = 0; j2 < segments[i22].length; j2++) {
+                  var pt2 = segments[i22][j2];
+                  path += [xa.c2p(pt2[0]), ya2.c2p(pt2[1])] + " ";
+                }
+              }
+              return path;
+            }
+            i2 = 0;
+            endpt = null;
+            while (startsleft.length) {
+              var startpt = pi2.edgepaths[i2][0];
+              if (endpt) {
+                fullpath += pathto(endpt, startpt);
+              }
+              addpath = Drawing.smoothopen(pi2.edgepaths[i2].map(ab2p), pi2.smoothing);
+              fullpath += newloop ? addpath : addpath.replace(/^M/, "L");
+              startsleft.splice(startsleft.indexOf(i2), 1);
+              endpt = pi2.edgepaths[i2][pi2.edgepaths[i2].length - 1];
+              nexti = -1;
+              for (cnt = 0; cnt < 4; cnt++) {
+                if (!endpt) {
+                  Lib.log("Missing end?", i2, pi2);
+                  break;
+                }
+                if (istop(endpt) && !isright(endpt)) {
+                  newendpt = perimeter[1];
+                } else if (isleft(endpt)) {
+                  newendpt = perimeter[0];
+                } else if (isbottom(endpt)) {
+                  newendpt = perimeter[3];
+                } else if (isright(endpt)) {
+                  newendpt = perimeter[2];
+                }
+                for (possiblei = 0; possiblei < pi2.edgepaths.length; possiblei++) {
+                  var ptNew = pi2.edgepaths[possiblei][0];
+                  if (Math.abs(endpt[0] - newendpt[0]) < atol) {
+                    if (Math.abs(endpt[0] - ptNew[0]) < atol && (ptNew[1] - endpt[1]) * (newendpt[1] - ptNew[1]) >= 0) {
+                      newendpt = ptNew;
+                      nexti = possiblei;
+                    }
+                  } else if (Math.abs(endpt[1] - newendpt[1]) < btol) {
+                    if (Math.abs(endpt[1] - ptNew[1]) < btol && (ptNew[0] - endpt[0]) * (newendpt[0] - ptNew[0]) >= 0) {
+                      newendpt = ptNew;
+                      nexti = possiblei;
+                    }
+                  } else {
+                    Lib.log("endpt to newendpt is not vert. or horz.", endpt, newendpt, ptNew);
+                  }
+                }
+                if (nexti >= 0) break;
+                fullpath += pathto(endpt, newendpt);
+                endpt = newendpt;
+              }
+              if (nexti === pi2.edgepaths.length) {
+                Lib.log("unclosed perimeter path");
+                break;
+              }
+              i2 = nexti;
+              newloop = startsleft.indexOf(i2) === -1;
+              if (newloop) {
+                i2 = startsleft[0];
+                fullpath += pathto(endpt, newendpt) + "Z";
+                endpt = null;
+              }
+            }
+            for (i2 = 0; i2 < pi2.paths.length; i2++) {
+              fullpath += Drawing.smoothclosed(pi2.paths[i2].map(ab2p), pi2.smoothing);
+            }
+            return fullpath;
+          }
+        }
+      });
+      var require_contourcarpet = __commonJS({
+        "src/traces/contourcarpet/index.js"(exports, module2) {
+          module2.exports = {
+            attributes: require_attributes65(),
+            supplyDefaults: require_defaults61(),
+            colorbar: require_colorbar3(),
+            calc: require_calc40(),
+            plot: require_plot34(),
+            style: require_style7(),
+            moduleType: "trace",
+            name: "contourcarpet",
+            basePlotModule: require_cartesian(),
+            categories: ["cartesian", "svg", "carpet", "contour", "symbols", "showLegend", "hasLines", "carpetDependent", "noHover", "noSortingByValue"],
+            meta: {}
+          };
+        }
+      });
+      var require_contourcarpet2 = __commonJS({
+        "lib/contourcarpet.js"(exports, module2) {
+          module2.exports = require_contourcarpet();
+        }
+      });
+      var require_attributes66 = __commonJS({
+        "src/traces/ohlc/attributes.js"(exports, module2) {
+          var extendFlat = require_lib().extendFlat;
+          var scatterAttrs = require_attributes12();
+          var axisHoverFormat = require_axis_format_attributes().axisHoverFormat;
+          var { hovertemplateAttrs, templatefallbackAttrs } = require_template_attributes();
+          var dash = require_attributes4().dash;
+          var fxAttrs = require_attributes();
+          var delta = require_delta();
+          var INCREASING_COLOR = delta.INCREASING.COLOR;
+          var DECREASING_COLOR = delta.DECREASING.COLOR;
+          var lineAttrs = scatterAttrs.line;
+          function directionAttrs(lineColorDefault) {
+            return {
+              line: {
+                color: extendFlat({}, lineAttrs.color, { dflt: lineColorDefault }),
+                width: lineAttrs.width,
+                dash,
+                editType: "style"
+              },
+              editType: "style"
+            };
+          }
+          module2.exports = {
+            xperiod: scatterAttrs.xperiod,
+            xperiod0: scatterAttrs.xperiod0,
+            xperiodalignment: scatterAttrs.xperiodalignment,
+            xhoverformat: axisHoverFormat("x"),
+            yhoverformat: axisHoverFormat("y"),
+            x: {
+              valType: "data_array",
+              editType: "calc+clearAxisTypes"
+            },
+            open: {
+              valType: "data_array",
+              editType: "calc"
+            },
+            high: {
+              valType: "data_array",
+              editType: "calc"
+            },
+            low: {
+              valType: "data_array",
+              editType: "calc"
+            },
+            close: {
+              valType: "data_array",
+              editType: "calc"
+            },
+            line: {
+              width: extendFlat({}, lineAttrs.width, {}),
+              dash: extendFlat({}, dash, {}),
+              editType: "style"
+            },
+            increasing: directionAttrs(INCREASING_COLOR),
+            decreasing: directionAttrs(DECREASING_COLOR),
+            text: {
+              valType: "string",
+              dflt: "",
+              arrayOk: true,
+              editType: "calc"
+            },
+            hovertext: {
+              valType: "string",
+              dflt: "",
+              arrayOk: true,
+              editType: "calc"
+            },
+            hovertemplate: hovertemplateAttrs(
+              {},
+              {
+                keys: ["open", "high", "low", "close"]
+              }
+            ),
+            hovertemplatefallback: templatefallbackAttrs(),
+            tickwidth: {
+              valType: "number",
+              min: 0,
+              max: 0.5,
+              dflt: 0.3,
+              editType: "calc"
+            },
+            hoverlabel: extendFlat({}, fxAttrs.hoverlabel, {
+              split: {
+                valType: "boolean",
+                dflt: false,
+                editType: "style"
+              }
+            }),
+            zorder: scatterAttrs.zorder
+          };
+        }
+      });
+      var require_ohlc_defaults = __commonJS({
+        "src/traces/ohlc/ohlc_defaults.js"(exports, module2) {
+          var Registry = require_registry();
+          var Lib = require_lib();
+          module2.exports = function handleOHLC(traceIn, traceOut, coerce, layout) {
+            var x2 = coerce("x");
+            var open = coerce("open");
+            var high = coerce("high");
+            var low = coerce("low");
+            var close = coerce("close");
+            coerce("hoverlabel.split");
+            var handleCalendarDefaults = Registry.getComponentMethod("calendars", "handleTraceDefaults");
+            handleCalendarDefaults(traceIn, traceOut, ["x"], layout);
+            if (!(open && high && low && close)) return;
+            var len2 = Math.min(open.length, high.length, low.length, close.length);
+            if (x2) len2 = Math.min(len2, Lib.minRowLength(x2));
+            traceOut._length = len2;
+            return len2;
+          };
+        }
+      });
+      var require_defaults62 = __commonJS({
+        "src/traces/ohlc/defaults.js"(exports, module2) {
+          var Lib = require_lib();
+          var handleOHLC = require_ohlc_defaults();
+          var handlePeriodDefaults = require_period_defaults();
+          var attributes = require_attributes66();
+          module2.exports = function supplyDefaults(traceIn, traceOut, defaultColor, layout) {
+            function coerce(attr, dflt) {
+              return Lib.coerce(traceIn, traceOut, attributes, attr, dflt);
+            }
+            var len2 = handleOHLC(traceIn, traceOut, coerce, layout);
+            if (!len2) {
+              traceOut.visible = false;
+              return;
+            }
+            handlePeriodDefaults(traceIn, traceOut, layout, coerce, { x: true });
+            coerce("xhoverformat");
+            coerce("yhoverformat");
+            coerce("line.width");
+            coerce("line.dash");
+            handleDirection(traceIn, traceOut, coerce, "increasing");
+            handleDirection(traceIn, traceOut, coerce, "decreasing");
+            coerce("text");
+            coerce("hovertext");
+            coerce("hovertemplate");
+            coerce("hovertemplatefallback");
+            coerce("tickwidth");
+            layout._requestRangeslider[traceOut.xaxis] = true;
+            coerce("zorder");
+          };
+          function handleDirection(traceIn, traceOut, coerce, direction) {
+            coerce(direction + ".line.color");
+            coerce(direction + ".line.width", traceOut.line.width);
+            coerce(direction + ".line.dash", traceOut.line.dash);
+          }
+        }
+      });
+      var require_calc41 = __commonJS({
+        "src/traces/ohlc/calc.js"(exports, module2) {
+          var Lib = require_lib();
+          var _2 = Lib._;
+          var Axes = require_axes();
+          var alignPeriod = require_align_period();
+          var BADNUM = require_numerical().BADNUM;
+          function calc(gd2, trace) {
+            var xa = Axes.getFromId(gd2, trace.xaxis);
+            var ya2 = Axes.getFromId(gd2, trace.yaxis);
+            var tickLen = convertTickWidth(gd2, xa, trace);
+            var minDiff = trace._minDiff;
+            trace._minDiff = null;
+            var origX = trace._origX;
+            trace._origX = null;
+            var x2 = trace._xcalc;
+            trace._xcalc = null;
+            var cd2 = calcCommon(gd2, trace, origX, x2, ya2, ptFunc);
+            trace._extremes[xa._id] = Axes.findExtremes(xa, x2, { vpad: minDiff / 2 });
+            if (cd2.length) {
+              Lib.extendFlat(cd2[0].t, {
+                wHover: minDiff / 2,
+                tickLen
+              });
+              return cd2;
+            } else {
+              return [{ t: { empty: true } }];
+            }
+          }
+          function ptFunc(o2, h2, l2, c2) {
+            return {
+              o: o2,
+              h: h2,
+              l: l2,
+              c: c2
+            };
+          }
+          function calcCommon(gd2, trace, origX, x2, ya2, ptFunc2) {
+            var o2 = ya2.makeCalcdata(trace, "open");
+            var h2 = ya2.makeCalcdata(trace, "high");
+            var l2 = ya2.makeCalcdata(trace, "low");
+            var c2 = ya2.makeCalcdata(trace, "close");
+            var hasTextArray = Lib.isArrayOrTypedArray(trace.text);
+            var hasHovertextArray = Lib.isArrayOrTypedArray(trace.hovertext);
+            var increasing = true;
+            var cPrev = null;
+            var hasPeriod = !!trace.xperiodalignment;
+            var cd2 = [];
+            for (var i2 = 0; i2 < x2.length; i2++) {
+              var xi2 = x2[i2];
+              var oi2 = o2[i2];
+              var hi2 = h2[i2];
+              var li2 = l2[i2];
+              var ci2 = c2[i2];
+              if (xi2 !== BADNUM && oi2 !== BADNUM && hi2 !== BADNUM && li2 !== BADNUM && ci2 !== BADNUM) {
+                if (ci2 === oi2) {
+                  if (cPrev !== null && ci2 !== cPrev) increasing = ci2 > cPrev;
+                } else increasing = ci2 > oi2;
+                cPrev = ci2;
+                var pt2 = ptFunc2(oi2, hi2, li2, ci2);
+                pt2.pos = xi2;
+                pt2.yc = (oi2 + ci2) / 2;
+                pt2.i = i2;
+                pt2.dir = increasing ? "increasing" : "decreasing";
+                pt2.x = pt2.pos;
+                pt2.y = [li2, hi2];
+                if (hasPeriod) pt2.orig_p = origX[i2];
+                if (hasTextArray) pt2.tx = trace.text[i2];
+                if (hasHovertextArray) pt2.htx = trace.hovertext[i2];
+                cd2.push(pt2);
+              } else {
+                cd2.push({ pos: xi2, empty: true });
+              }
+            }
+            trace._extremes[ya2._id] = Axes.findExtremes(ya2, Lib.concat(l2, h2), { padded: true });
+            if (cd2.length) {
+              cd2[0].t = {
+                labels: {
+                  open: _2(gd2, "open:") + " ",
+                  high: _2(gd2, "high:") + " ",
+                  low: _2(gd2, "low:") + " ",
+                  close: _2(gd2, "close:") + " "
+                }
+              };
+            }
+            return cd2;
+          }
+          function convertTickWidth(gd2, xa, trace) {
+            var minDiff = trace._minDiff;
+            if (!minDiff) {
+              var fullData = gd2._fullData;
+              var ohlcTracesOnThisXaxis = [];
+              minDiff = Infinity;
+              var i2;
+              for (i2 = 0; i2 < fullData.length; i2++) {
+                var tracei = fullData[i2];
+                if (tracei.type === "ohlc" && tracei.visible === true && tracei.xaxis === xa._id) {
+                  ohlcTracesOnThisXaxis.push(tracei);
+                  var origX = xa.makeCalcdata(tracei, "x");
+                  tracei._origX = origX;
+                  var xcalc = alignPeriod(trace, xa, "x", origX).vals;
+                  tracei._xcalc = xcalc;
+                  var _minDiff = Lib.distinctVals(xcalc).minDiff;
+                  if (_minDiff && isFinite(_minDiff)) {
+                    minDiff = Math.min(minDiff, _minDiff);
+                  }
+                }
+              }
+              if (minDiff === Infinity) minDiff = 1;
+              for (i2 = 0; i2 < ohlcTracesOnThisXaxis.length; i2++) {
+                ohlcTracesOnThisXaxis[i2]._minDiff = minDiff;
+              }
+            }
+            return minDiff * trace.tickwidth;
+          }
+          module2.exports = {
+            calc,
+            calcCommon
+          };
+        }
+      });
+      var require_plot35 = __commonJS({
+        "src/traces/ohlc/plot.js"(exports, module2) {
+          var d3 = require_d3();
+          var Lib = require_lib();
+          module2.exports = function plot(gd2, plotinfo, cdOHLC, ohlcLayer) {
+            var ya2 = plotinfo.yaxis;
+            var xa = plotinfo.xaxis;
+            var posHasRangeBreaks = !!xa.rangebreaks;
+            Lib.makeTraceGroups(ohlcLayer, cdOHLC, "trace ohlc").each(function(cd2) {
+              var plotGroup = d3.select(this);
+              var cd0 = cd2[0];
+              var t4 = cd0.t;
+              var trace = cd0.trace;
+              if (trace.visible !== true || t4.empty) {
+                plotGroup.remove();
+                return;
+              }
+              var tickLen = t4.tickLen;
+              var paths = plotGroup.selectAll("path").data(Lib.identity);
+              paths.enter().append("path");
+              paths.exit().remove();
+              paths.attr("d", function(d2) {
+                if (d2.empty) return "M0,0Z";
+                var xo = xa.c2p(d2.pos - tickLen, true);
+                var xc2 = xa.c2p(d2.pos + tickLen, true);
+                var x2 = posHasRangeBreaks ? (xo + xc2) / 2 : xa.c2p(d2.pos, true);
+                var yo = ya2.c2p(d2.o, true);
+                var yh2 = ya2.c2p(d2.h, true);
+                var yl = ya2.c2p(d2.l, true);
+                var yc2 = ya2.c2p(d2.c, true);
+                return "M" + xo + "," + yo + "H" + x2 + "M" + x2 + "," + yh2 + "V" + yl + "M" + xc2 + "," + yc2 + "H" + x2;
+              });
+            });
+          };
+        }
+      });
+      var require_style19 = __commonJS({
+        "src/traces/ohlc/style.js"(exports, module2) {
+          var d3 = require_d3();
+          var Drawing = require_drawing();
+          var Color2 = require_color();
+          module2.exports = function style(gd2, cd2, sel) {
+            var s2 = sel ? sel : d3.select(gd2).selectAll("g.ohlclayer").selectAll("g.trace");
+            s2.style("opacity", function(d2) {
+              return d2[0].trace.opacity;
+            });
+            s2.each(function(d2) {
+              var trace = d2[0].trace;
+              d3.select(this).selectAll("path").each(function(di2) {
+                if (di2.empty) return;
+                var dirLine = trace[di2.dir].line;
+                d3.select(this).style("fill", "none").call(Color2.stroke, dirLine.color).call(Drawing.dashLine, dirLine.dash, dirLine.width).style("opacity", trace.selectedpoints && !di2.selected ? 0.3 : 1);
+              });
+            });
+          };
+        }
+      });
+      var require_hover23 = __commonJS({
+        "src/traces/ohlc/hover.js"(exports, module2) {
+          var Axes = require_axes();
+          var Lib = require_lib();
+          var Fx = require_fx();
+          var Color2 = require_color();
+          var fillText = require_lib().fillText;
+          var delta = require_delta();
+          var DIRSYMBOL = {
+            increasing: delta.INCREASING.SYMBOL,
+            decreasing: delta.DECREASING.SYMBOL
+          };
+          function hoverPoints(pointData, xval, yval, hovermode) {
+            var cd2 = pointData.cd;
+            var trace = cd2[0].trace;
+            if (trace.hoverlabel.split) {
+              return hoverSplit(pointData, xval, yval, hovermode);
+            }
+            return hoverOnPoints(pointData, xval, yval, hovermode);
+          }
+          function _getClosestPoint(pointData, xval, yval, hovermode) {
+            var cd2 = pointData.cd;
+            var xa = pointData.xa;
+            var trace = cd2[0].trace;
+            var t4 = cd2[0].t;
+            var type = trace.type;
+            var minAttr = type === "ohlc" ? "l" : "min";
+            var maxAttr = type === "ohlc" ? "h" : "max";
+            var hoverPseudoDistance, spikePseudoDistance;
+            var centerShift = t4.bPos || 0;
+            var shiftPos = function(di22) {
+              return di22.pos + centerShift - xval;
+            };
+            var displayHalfWidth = t4.bdPos || t4.tickLen;
+            var hoverHalfWidth = t4.wHover;
+            var pseudoDistance = Math.min(1, displayHalfWidth / Math.abs(xa.r2c(xa.range[1]) - xa.r2c(xa.range[0])));
+            hoverPseudoDistance = pointData.maxHoverDistance - pseudoDistance;
+            spikePseudoDistance = pointData.maxSpikeDistance - pseudoDistance;
+            function dx(di22) {
+              var pos = shiftPos(di22);
+              return Fx.inbox(pos - hoverHalfWidth, pos + hoverHalfWidth, hoverPseudoDistance);
+            }
+            function dy(di22) {
+              var min = di22[minAttr];
+              var max = di22[maxAttr];
+              return min === max || Fx.inbox(min - yval, max - yval, hoverPseudoDistance);
+            }
+            function dxy(di22) {
+              return (dx(di22) + dy(di22)) / 2;
+            }
+            var distfn = Fx.getDistanceFunction(hovermode, dx, dy, dxy);
+            Fx.getClosest(cd2, distfn, pointData);
+            if (pointData.index === false) return null;
+            var di2 = cd2[pointData.index];
+            if (di2.empty) return null;
+            var dir = di2.dir;
+            var container = trace[dir];
+            var lc2 = container.line.color;
+            if (Color2.opacity(lc2) && container.line.width) pointData.color = lc2;
+            else pointData.color = container.fillcolor;
+            pointData.x0 = xa.c2p(di2.pos + centerShift - displayHalfWidth, true);
+            pointData.x1 = xa.c2p(di2.pos + centerShift + displayHalfWidth, true);
+            pointData.xLabelVal = di2.orig_p !== void 0 ? di2.orig_p : di2.pos;
+            pointData.spikeDistance = dxy(di2) * spikePseudoDistance / hoverPseudoDistance;
+            pointData.xSpike = xa.c2p(di2.pos, true);
+            return pointData;
+          }
+          function hoverSplit(pointData, xval, yval, hovermode) {
+            var cd2 = pointData.cd;
+            var ya2 = pointData.ya;
+            var trace = cd2[0].trace;
+            var t4 = cd2[0].t;
+            var closeBoxData = [];
+            var closestPoint = _getClosestPoint(pointData, xval, yval, hovermode);
+            if (!closestPoint) return [];
+            var di2 = cd2[closestPoint.index];
+            var hoverinfo = di2.hi || trace.hoverinfo || "";
+            if (hoverinfo === "none" || hoverinfo === "skip") return [];
+            var attrs = ["high", "open", "close", "low"];
+            var usedVals = {};
+            for (var i2 = 0; i2 < attrs.length; i2++) {
+              var attr = attrs[i2];
+              var val = trace[attr][closestPoint.index];
+              var valPx = ya2.c2p(val, true);
+              var pointData2;
+              if (val in usedVals) {
+                pointData2 = usedVals[val];
+                pointData2.yLabel += "<br>" + t4.labels[attr] + Axes.hoverLabelText(ya2, val, trace.yhoverformat);
+              } else {
+                pointData2 = Lib.extendFlat({}, closestPoint);
+                pointData2.y0 = pointData2.y1 = valPx;
+                pointData2.yLabelVal = val;
+                pointData2.yLabel = t4.labels[attr] + Axes.hoverLabelText(ya2, val, trace.yhoverformat);
+                pointData2.name = "";
+                closeBoxData.push(pointData2);
+                usedVals[val] = pointData2;
+              }
+            }
+            return closeBoxData;
+          }
+          function hoverOnPoints(pointData, xval, yval, hovermode) {
+            var cd2 = pointData.cd;
+            var ya2 = pointData.ya;
+            var trace = cd2[0].trace;
+            var t4 = cd2[0].t;
+            var closestPoint = _getClosestPoint(pointData, xval, yval, hovermode);
+            if (!closestPoint) return [];
+            var cdIndex = closestPoint.index;
+            var di2 = cd2[cdIndex];
+            var i2 = closestPoint.index = di2.i;
+            var dir = di2.dir;
+            function getLabelLine(attr) {
+              return t4.labels[attr] + Axes.hoverLabelText(ya2, trace[attr][i2], trace.yhoverformat);
+            }
+            var hoverinfo = di2.hi || trace.hoverinfo || "";
+            var hoverParts = hoverinfo.split("+");
+            var isAll = hoverinfo === "all";
+            var hasY = isAll || hoverParts.indexOf("y") !== -1;
+            var hasText = isAll || hoverParts.indexOf("text") !== -1;
+            var textParts = hasY ? [
+              getLabelLine("open"),
+              getLabelLine("high"),
+              getLabelLine("low"),
+              getLabelLine("close") + "  " + DIRSYMBOL[dir]
+            ] : [];
+            if (hasText) fillText(di2, trace, textParts);
+            closestPoint.extraText = textParts.join("<br>");
+            closestPoint.y0 = closestPoint.y1 = ya2.c2p(di2.yc, true);
+            return [closestPoint];
+          }
+          module2.exports = {
+            hoverPoints,
+            hoverSplit,
+            hoverOnPoints
+          };
+        }
+      });
+      var require_select12 = __commonJS({
+        "src/traces/ohlc/select.js"(exports, module2) {
+          module2.exports = function selectPoints(searchInfo, selectionTester) {
+            var cd2 = searchInfo.cd;
+            var xa = searchInfo.xaxis;
+            var ya2 = searchInfo.yaxis;
+            var selection = [];
+            var i2;
+            var posOffset = cd2[0].t.bPos || 0;
+            if (selectionTester === false) {
+              for (i2 = 0; i2 < cd2.length; i2++) {
+                cd2[i2].selected = 0;
+              }
+            } else {
+              for (i2 = 0; i2 < cd2.length; i2++) {
+                var di2 = cd2[i2];
+                if (selectionTester.contains([xa.c2p(di2.pos + posOffset), ya2.c2p(di2.yc)], null, di2.i, searchInfo)) {
+                  selection.push({
+                    pointNumber: di2.i,
+                    x: xa.c2d(di2.pos),
+                    y: ya2.c2d(di2.yc)
+                  });
+                  di2.selected = 1;
+                } else {
+                  di2.selected = 0;
+                }
+              }
+            }
+            return selection;
+          };
+        }
+      });
+      var require_ohlc = __commonJS({
+        "src/traces/ohlc/index.js"(exports, module2) {
+          module2.exports = {
+            moduleType: "trace",
+            name: "ohlc",
+            basePlotModule: require_cartesian(),
+            categories: ["cartesian", "svg", "showLegend"],
+            meta: {},
+            attributes: require_attributes66(),
+            supplyDefaults: require_defaults62(),
+            calc: require_calc41().calc,
+            plot: require_plot35(),
+            style: require_style19(),
+            hoverPoints: require_hover23().hoverPoints,
+            selectPoints: require_select12()
+          };
+        }
+      });
+      var require_ohlc2 = __commonJS({
+        "lib/ohlc.js"(exports, module2) {
+          module2.exports = require_ohlc();
+        }
+      });
+      var require_attributes67 = __commonJS({
+        "src/traces/candlestick/attributes.js"(exports, module2) {
+          var extendFlat = require_lib().extendFlat;
+          var axisHoverFormat = require_axis_format_attributes().axisHoverFormat;
+          var OHLCattrs = require_attributes66();
+          var boxAttrs = require_attributes24();
+          function directionAttrs(lineColorDefault) {
+            return {
+              line: {
+                color: extendFlat({}, boxAttrs.line.color, { dflt: lineColorDefault }),
+                width: boxAttrs.line.width,
+                editType: "style"
+              },
+              fillcolor: boxAttrs.fillcolor,
+              editType: "style"
+            };
+          }
+          module2.exports = {
+            xperiod: OHLCattrs.xperiod,
+            xperiod0: OHLCattrs.xperiod0,
+            xperiodalignment: OHLCattrs.xperiodalignment,
+            xhoverformat: axisHoverFormat("x"),
+            yhoverformat: axisHoverFormat("y"),
+            x: OHLCattrs.x,
+            open: OHLCattrs.open,
+            high: OHLCattrs.high,
+            low: OHLCattrs.low,
+            close: OHLCattrs.close,
+            line: {
+              width: extendFlat({}, boxAttrs.line.width, {}),
+              editType: "style"
+            },
+            increasing: directionAttrs(OHLCattrs.increasing.line.color.dflt),
+            decreasing: directionAttrs(OHLCattrs.decreasing.line.color.dflt),
+            text: OHLCattrs.text,
+            hovertext: OHLCattrs.hovertext,
+            hovertemplate: OHLCattrs.hovertemplate,
+            hovertemplatefallback: OHLCattrs.hovertemplatefallback,
+            whiskerwidth: extendFlat({}, boxAttrs.whiskerwidth, { dflt: 0 }),
+            hoverlabel: OHLCattrs.hoverlabel,
+            zorder: boxAttrs.zorder
+          };
+        }
+      });
+      var require_defaults63 = __commonJS({
+        "src/traces/candlestick/defaults.js"(exports, module2) {
+          var Lib = require_lib();
+          var Color2 = require_color();
+          var handleOHLC = require_ohlc_defaults();
+          var handlePeriodDefaults = require_period_defaults();
+          var attributes = require_attributes67();
+          module2.exports = function supplyDefaults(traceIn, traceOut, defaultColor, layout) {
+            function coerce(attr, dflt) {
+              return Lib.coerce(traceIn, traceOut, attributes, attr, dflt);
+            }
+            var len2 = handleOHLC(traceIn, traceOut, coerce, layout);
+            if (!len2) {
+              traceOut.visible = false;
+              return;
+            }
+            handlePeriodDefaults(traceIn, traceOut, layout, coerce, { x: true });
+            coerce("xhoverformat");
+            coerce("yhoverformat");
+            coerce("line.width");
+            handleDirection(traceIn, traceOut, coerce, "increasing");
+            handleDirection(traceIn, traceOut, coerce, "decreasing");
+            coerce("text");
+            coerce("hovertext");
+            coerce("hovertemplate");
+            coerce("hovertemplatefallback");
+            coerce("whiskerwidth");
+            layout._requestRangeslider[traceOut.xaxis] = true;
+            coerce("zorder");
+          };
+          function handleDirection(traceIn, traceOut, coerce, direction) {
+            var lineColor = coerce(direction + ".line.color");
+            coerce(direction + ".line.width", traceOut.line.width);
+            coerce(direction + ".fillcolor", Color2.addOpacity(lineColor, 0.5));
+          }
+        }
+      });
+      var require_calc42 = __commonJS({
+        "src/traces/candlestick/calc.js"(exports, module2) {
+          var Lib = require_lib();
+          var Axes = require_axes();
+          var alignPeriod = require_align_period();
+          var calcCommon = require_calc41().calcCommon;
+          module2.exports = function(gd2, trace) {
+            var fullLayout = gd2._fullLayout;
+            var xa = Axes.getFromId(gd2, trace.xaxis);
+            var ya2 = Axes.getFromId(gd2, trace.yaxis);
+            var origX = xa.makeCalcdata(trace, "x");
+            var x2 = alignPeriod(trace, xa, "x", origX).vals;
+            var cd2 = calcCommon(gd2, trace, origX, x2, ya2, ptFunc);
+            if (cd2.length) {
+              Lib.extendFlat(cd2[0].t, {
+                num: fullLayout._numBoxes,
+                dPos: Lib.distinctVals(x2).minDiff / 2,
+                posLetter: "x",
+                valLetter: "y"
+              });
+              fullLayout._numBoxes++;
+              return cd2;
+            } else {
+              return [{ t: { empty: true } }];
+            }
+          };
+          function ptFunc(o2, h2, l2, c2) {
+            return {
+              min: l2,
+              q1: Math.min(o2, c2),
+              med: c2,
+              q3: Math.max(o2, c2),
+              max: h2
+            };
+          }
+        }
+      });
+      var require_candlestick = __commonJS({
+        "src/traces/candlestick/index.js"(exports, module2) {
+          module2.exports = {
+            moduleType: "trace",
+            name: "candlestick",
+            basePlotModule: require_cartesian(),
+            categories: ["cartesian", "svg", "showLegend", "candlestick", "boxLayout"],
+            meta: {},
+            attributes: require_attributes67(),
+            layoutAttributes: require_layout_attributes7(),
+            supplyLayoutDefaults: require_layout_defaults6().supplyLayoutDefaults,
+            crossTraceCalc: require_cross_trace_calc3().crossTraceCalc,
+            supplyDefaults: require_defaults63(),
+            calc: require_calc42(),
+            plot: require_plot4().plot,
+            layerName: "boxlayer",
+            style: require_style5().style,
+            hoverPoints: require_hover23().hoverPoints,
+            selectPoints: require_select12()
+          };
+        }
+      });
+      var require_candlestick2 = __commonJS({
+        "lib/candlestick.js"(exports, module2) {
+          module2.exports = require_candlestick();
+        }
+      });
+      var require_set_convert3 = __commonJS({
+        "src/plots/polar/set_convert.js"(exports, module2) {
+          var Lib = require_lib();
+          var setConvertCartesian = require_set_convert();
+          var deg2rad = Lib.deg2rad;
+          var rad2deg = Lib.rad2deg;
+          module2.exports = function setConvert(ax, polarLayout, fullLayout) {
+            setConvertCartesian(ax, fullLayout);
+            switch (ax._id) {
+              case "x":
+              case "radialaxis":
+                setConvertRadial(ax, polarLayout);
+                break;
+              case "angularaxis":
+                setConvertAngular(ax, polarLayout);
+                break;
+            }
+          };
+          function setConvertRadial(ax, polarLayout) {
+            var subplot = polarLayout._subplot;
+            ax.setGeometry = function() {
+              var rl0 = ax._rl[0];
+              var rl1 = ax._rl[1];
+              var b2 = subplot.innerRadius;
+              var m2 = (subplot.radius - b2) / (rl1 - rl0);
+              var b22 = b2 / m2;
+              var rFilter = rl0 > rl1 ? function(v2) {
+                return v2 <= 0;
+              } : function(v2) {
+                return v2 >= 0;
+              };
+              ax.c2g = function(v2) {
+                var r2 = ax.c2l(v2) - rl0;
+                return (rFilter(r2) ? r2 : 0) + b22;
+              };
+              ax.g2c = function(v2) {
+                return ax.l2c(v2 + rl0 - b22);
+              };
+              ax.g2p = function(v2) {
+                return v2 * m2;
+              };
+              ax.c2p = function(v2) {
+                return ax.g2p(ax.c2g(v2));
+              };
+            };
+          }
+          function toRadians(v2, unit) {
+            return unit === "degrees" ? deg2rad(v2) : v2;
+          }
+          function fromRadians(v2, unit) {
+            return unit === "degrees" ? rad2deg(v2) : v2;
+          }
+          function setConvertAngular(ax, polarLayout) {
+            var axType = ax.type;
+            if (axType === "linear") {
+              var _d2c = ax.d2c;
+              var _c2d = ax.c2d;
+              ax.d2c = function(v2, unit) {
+                return toRadians(_d2c(v2), unit);
+              };
+              ax.c2d = function(v2, unit) {
+                return _c2d(fromRadians(v2, unit));
+              };
+            }
+            ax.makeCalcdata = function(trace, coord) {
+              var arrayIn = trace[coord];
+              var len2 = trace._length;
+              var arrayOut, i2;
+              var _d2c2 = function(v2) {
+                return ax.d2c(v2, trace.thetaunit);
+              };
+              if (arrayIn) {
+                arrayOut = new Array(len2);
+                for (i2 = 0; i2 < len2; i2++) {
+                  arrayOut[i2] = _d2c2(arrayIn[i2]);
+                }
+              } else {
+                var coord0 = coord + "0";
+                var dcoord = "d" + coord;
+                var v0 = coord0 in trace ? _d2c2(trace[coord0]) : 0;
+                var dv = trace[dcoord] ? _d2c2(trace[dcoord]) : (ax.period || 2 * Math.PI) / len2;
+                arrayOut = new Array(len2);
+                for (i2 = 0; i2 < len2; i2++) {
+                  arrayOut[i2] = v0 + i2 * dv;
+                }
+              }
+              return arrayOut;
+            };
+            ax.setGeometry = function() {
+              var sector = polarLayout.sector;
+              var sectorInRad = sector.map(deg2rad);
+              var dir = { clockwise: -1, counterclockwise: 1 }[ax.direction];
+              var rot = deg2rad(ax.rotation);
+              var rad2g = function(v2) {
+                return dir * v2 + rot;
+              };
+              var g2rad = function(v2) {
+                return (v2 - rot) / dir;
+              };
+              var rad2c, c2rad;
+              var rad2t, t2rad;
+              switch (axType) {
+                case "linear":
+                  c2rad = rad2c = Lib.identity;
+                  t2rad = deg2rad;
+                  rad2t = rad2deg;
+                  ax.range = Lib.isFullCircle(sectorInRad) ? [sector[0], sector[0] + 360] : sectorInRad.map(g2rad).map(rad2deg);
+                  break;
+                case "category":
+                  var catLen = ax._categories.length;
+                  var _period = ax.period ? Math.max(ax.period, catLen) : catLen;
+                  if (_period === 0) _period = 1;
+                  c2rad = t2rad = function(v2) {
+                    return v2 * 2 * Math.PI / _period;
+                  };
+                  rad2c = rad2t = function(v2) {
+                    return v2 * _period / Math.PI / 2;
+                  };
+                  ax.range = [0, _period];
+                  break;
+              }
+              ax.c2g = function(v2) {
+                return rad2g(c2rad(v2));
+              };
+              ax.g2c = function(v2) {
+                return rad2c(g2rad(v2));
+              };
+              ax.t2g = function(v2) {
+                return rad2g(t2rad(v2));
+              };
+              ax.g2t = function(v2) {
+                return rad2t(g2rad(v2));
+              };
+            };
+          }
+        }
+      });
+      var require_constants33 = __commonJS({
+        "src/plots/polar/constants.js"(exports, module2) {
+          module2.exports = {
+            attr: "subplot",
+            name: "polar",
+            axisNames: ["angularaxis", "radialaxis"],
+            axisName2dataArray: { angularaxis: "theta", radialaxis: "r" },
+            layerNames: [
+              "draglayer",
+              "plotbg",
+              "backplot",
+              "angular-grid",
+              "radial-grid",
+              "frontplot",
+              "angular-line",
+              "radial-line",
+              "angular-axis",
+              "radial-axis"
+            ],
+            radialDragBoxSize: 50,
+            angularDragBoxSize: 30,
+            cornerLen: 25,
+            cornerHalfWidth: 2,
+            // pixels to move mouse before you stop clamping to starting point
+            MINDRAG: 8,
+            // smallest radial distance [px] allowed for a zoombox
+            MINZOOM: 20,
+            // distance [px] off (r=0) or (r=radius) where we transition
+            // from single-sided to two-sided radial zoom
+            OFFEDGE: 20
+          };
+        }
+      });
+      var require_helpers19 = __commonJS({
+        "src/plots/polar/helpers.js"(exports, module2) {
+          var Lib = require_lib();
+          var polygonTester = require_polygon().tester;
+          var findIndexOfMin = Lib.findIndexOfMin;
+          var isAngleInsideSector = Lib.isAngleInsideSector;
+          var angleDelta = Lib.angleDelta;
+          var angleDist = Lib.angleDist;
+          function isPtInsidePolygon(r2, a2, rBnds, aBnds, vangles) {
+            if (!isAngleInsideSector(a2, aBnds)) return false;
+            var r0, r1;
+            if (rBnds[0] < rBnds[1]) {
+              r0 = rBnds[0];
+              r1 = rBnds[1];
+            } else {
+              r0 = rBnds[1];
+              r1 = rBnds[0];
+            }
+            var polygonIn = polygonTester(makePolygon(r0, aBnds[0], aBnds[1], vangles));
+            var polygonOut = polygonTester(makePolygon(r1, aBnds[0], aBnds[1], vangles));
+            var xy = [r2 * Math.cos(a2), r2 * Math.sin(a2)];
+            return polygonOut.contains(xy) && !polygonIn.contains(xy);
+          }
+          function findIntersectionXY(v0, v1, a2, xpyp) {
+            var xstar, ystar;
+            var xp = xpyp[0];
+            var yp = xpyp[1];
+            var dsin = clampTiny(Math.sin(v1) - Math.sin(v0));
+            var dcos = clampTiny(Math.cos(v1) - Math.cos(v0));
+            var tanA = Math.tan(a2);
+            var cotanA = clampTiny(1 / tanA);
+            var m2 = dsin / dcos;
+            var b2 = yp - m2 * xp;
+            if (cotanA) {
+              if (dsin && dcos) {
+                xstar = b2 / (tanA - m2);
+                ystar = tanA * xstar;
+              } else if (dcos) {
+                xstar = yp * cotanA;
+                ystar = yp;
+              } else {
+                xstar = xp;
+                ystar = xp * tanA;
+              }
+            } else {
+              if (dsin && dcos) {
+                xstar = 0;
+                ystar = b2;
+              } else if (dcos) {
+                xstar = 0;
+                ystar = yp;
+              } else {
+                xstar = ystar = NaN;
+              }
+            }
+            return [xstar, ystar];
+          }
+          function findXYatLength(l2, m2, xp, yp) {
+            var t4 = -m2 * xp;
+            var a2 = m2 * m2 + 1;
+            var b2 = 2 * (m2 * t4 - xp);
+            var c2 = t4 * t4 + xp * xp - l2 * l2;
+            var del = Math.sqrt(b2 * b2 - 4 * a2 * c2);
+            var x0 = (-b2 + del) / (2 * a2);
+            var x1 = (-b2 - del) / (2 * a2);
+            return [
+              [x0, m2 * x0 + t4 + yp],
+              [x1, m2 * x1 + t4 + yp]
+            ];
+          }
+          function makeRegularPolygon(r2, vangles) {
+            var len2 = vangles.length;
+            var vertices = new Array(len2 + 1);
+            var i2;
+            for (i2 = 0; i2 < len2; i2++) {
+              var va2 = vangles[i2];
+              vertices[i2] = [r2 * Math.cos(va2), r2 * Math.sin(va2)];
+            }
+            vertices[i2] = vertices[0].slice();
+            return vertices;
+          }
+          function makeClippedPolygon(r2, a0, a1, vangles) {
+            var len2 = vangles.length;
+            var vertices = [];
+            var i2, j2;
+            function a2xy(a2) {
+              return [r2 * Math.cos(a2), r2 * Math.sin(a2)];
+            }
+            function findXY(va0, va1, s2) {
+              return findIntersectionXY(va0, va1, s2, a2xy(va0));
+            }
+            function cycleIndex(ind) {
+              return Lib.mod(ind, len2);
+            }
+            function isInside(v2) {
+              return isAngleInsideSector(v2, [a0, a1]);
+            }
+            var i0 = findIndexOfMin(vangles, function(v2) {
+              return isInside(v2) ? angleDist(v2, a0) : Infinity;
+            });
+            var xy0 = findXY(vangles[i0], vangles[cycleIndex(i0 - 1)], a0);
+            vertices.push(xy0);
+            for (i2 = i0, j2 = 0; j2 < len2; i2++, j2++) {
+              var va2 = vangles[cycleIndex(i2)];
+              if (!isInside(va2)) break;
+              vertices.push(a2xy(va2));
+            }
+            var iN = findIndexOfMin(vangles, function(v2) {
+              return isInside(v2) ? angleDist(v2, a1) : Infinity;
+            });
+            var xyN = findXY(vangles[iN], vangles[cycleIndex(iN + 1)], a1);
+            vertices.push(xyN);
+            vertices.push([0, 0]);
+            vertices.push(vertices[0].slice());
+            return vertices;
+          }
+          function makePolygon(r2, a0, a1, vangles) {
+            return Lib.isFullCircle([a0, a1]) ? makeRegularPolygon(r2, vangles) : makeClippedPolygon(r2, a0, a1, vangles);
+          }
+          function findPolygonOffset(r2, a0, a1, vangles) {
+            var minX = Infinity;
+            var minY = Infinity;
+            var vertices = makePolygon(r2, a0, a1, vangles);
+            for (var i2 = 0; i2 < vertices.length; i2++) {
+              var v2 = vertices[i2];
+              minX = Math.min(minX, v2[0]);
+              minY = Math.min(minY, -v2[1]);
+            }
+            return [minX, minY];
+          }
+          function findEnclosingVertexAngles(a2, vangles) {
+            var minFn = function(v2) {
+              var adelta = angleDelta(v2, a2);
+              return adelta > 0 ? adelta : Infinity;
+            };
+            var i0 = findIndexOfMin(vangles, minFn);
+            var i1 = Lib.mod(i0 + 1, vangles.length);
+            return [vangles[i0], vangles[i1]];
+          }
+          function clampTiny(v2) {
+            return Math.abs(v2) > 1e-10 ? v2 : 0;
+          }
+          function transformForSVG(pts0, cx, cy) {
+            cx = cx || 0;
+            cy = cy || 0;
+            var len2 = pts0.length;
+            var pts1 = new Array(len2);
+            for (var i2 = 0; i2 < len2; i2++) {
+              var pt2 = pts0[i2];
+              pts1[i2] = [cx + pt2[0], cy - pt2[1]];
+            }
+            return pts1;
+          }
+          function pathPolygon(r2, a0, a1, vangles, cx, cy) {
+            var poly = makePolygon(r2, a0, a1, vangles);
+            return "M" + transformForSVG(poly, cx, cy).join("L");
+          }
+          function pathPolygonAnnulus(r0, r1, a0, a1, vangles, cx, cy) {
+            var rStart, rEnd;
+            if (r0 < r1) {
+              rStart = r0;
+              rEnd = r1;
+            } else {
+              rStart = r1;
+              rEnd = r0;
+            }
+            var inner = transformForSVG(makePolygon(rStart, a0, a1, vangles), cx, cy);
+            var outer = transformForSVG(makePolygon(rEnd, a0, a1, vangles), cx, cy);
+            return "M" + outer.reverse().join("L") + "M" + inner.join("L");
+          }
+          module2.exports = {
+            isPtInsidePolygon,
+            findPolygonOffset,
+            findEnclosingVertexAngles,
+            findIntersectionXY,
+            findXYatLength,
+            clampTiny,
+            pathPolygon,
+            pathPolygonAnnulus
+          };
+        }
+      });
+      var require_helpers20 = __commonJS({
+        "src/plots/smith/helpers.js"(exports, module2) {
+          function sign(x2) {
+            return x2 < 0 ? -1 : x2 > 0 ? 1 : 0;
+          }
+          function smith(a2) {
+            var R2 = a2[0];
+            var X2 = a2[1];
+            if (!isFinite(R2) || !isFinite(X2)) return [1, 0];
+            var D22 = (R2 + 1) * (R2 + 1) + X2 * X2;
+            return [(R2 * R2 + X2 * X2 - 1) / D22, 2 * X2 / D22];
+          }
+          function transform(subplot, a2) {
+            var x2 = a2[0];
+            var y2 = a2[1];
+            return [
+              x2 * subplot.radius + subplot.cx,
+              -y2 * subplot.radius + subplot.cy
+            ];
+          }
+          function scale2(subplot, r2) {
+            return r2 * subplot.radius;
+          }
+          function reactanceArc(subplot, X2, R1, R2) {
+            var t12 = transform(subplot, smith([R1, X2]));
+            var x1 = t12[0];
+            var y1 = t12[1];
+            var t22 = transform(subplot, smith([R2, X2]));
+            var x2 = t22[0];
+            var y2 = t22[1];
+            if (X2 === 0) {
+              return [
+                "M" + x1 + "," + y1,
+                "L" + x2 + "," + y2
+              ].join(" ");
+            }
+            var r2 = scale2(subplot, 1 / Math.abs(X2));
+            return [
+              "M" + x1 + "," + y1,
+              "A" + r2 + "," + r2 + " 0 0," + (X2 < 0 ? 1 : 0) + " " + x2 + "," + y2
+            ].join(" ");
+          }
+          function resistanceArc(subplot, R2, X1, X2) {
+            var r2 = scale2(subplot, 1 / (R2 + 1));
+            var t12 = transform(subplot, smith([R2, X1]));
+            var x1 = t12[0];
+            var y1 = t12[1];
+            var t22 = transform(subplot, smith([R2, X2]));
+            var x2 = t22[0];
+            var y2 = t22[1];
+            if (sign(X1) !== sign(X2)) {
+              var t02 = transform(subplot, smith([R2, 0]));
+              var x0 = t02[0];
+              var y0 = t02[1];
+              return [
+                "M" + x1 + "," + y1,
+                "A" + r2 + "," + r2 + " 0 0," + (0 < X1 ? 0 : 1) + " " + x0 + "," + y0,
+                "A" + r2 + "," + r2 + " 0 0," + (X2 < 0 ? 0 : 1) + x2 + "," + y2
+              ].join(" ");
+            }
+            return [
+              "M" + x1 + "," + y1,
+              "A" + r2 + "," + r2 + " 0 0," + (X2 < X1 ? 0 : 1) + " " + x2 + "," + y2
+            ].join(" ");
+          }
+          module2.exports = {
+            smith,
+            reactanceArc,
+            resistanceArc,
+            smithTransform: transform
+          };
+        }
+      });
+      var require_polar = __commonJS({
+        "src/plots/polar/polar.js"(exports, module2) {
+          var d3 = require_d3();
+          var tinycolor = require_tinycolor();
+          var Registry = require_registry();
+          var Lib = require_lib();
+          var strRotate = Lib.strRotate;
+          var strTranslate = Lib.strTranslate;
+          var Color2 = require_color();
+          var Drawing = require_drawing();
+          var Plots = require_plots();
+          var Axes = require_axes();
+          var setConvertCartesian = require_set_convert();
+          var setConvertPolar = require_set_convert3();
+          var doAutoRange = require_autorange().doAutoRange;
+          var dragBox = require_dragbox();
+          var dragElement = require_dragelement();
+          var Fx = require_fx();
+          var Titles = require_titles();
+          var prepSelect = require_selections().prepSelect;
+          var selectOnClick = require_selections().selectOnClick;
+          var clearOutline = require_selections().clearOutline;
+          var setCursor = require_setcursor();
+          var clearGlCanvases = require_clear_gl_canvases();
+          var redrawReglTraces = require_subroutines().redrawReglTraces;
+          var MID_SHIFT = require_alignment().MID_SHIFT;
+          var constants = require_constants33();
+          var helpers = require_helpers19();
+          var smithHelpers = require_helpers20();
+          var smith = smithHelpers.smith;
+          var reactanceArc = smithHelpers.reactanceArc;
+          var resistanceArc = smithHelpers.resistanceArc;
+          var smithTransform = smithHelpers.smithTransform;
+          var _2 = Lib._;
+          var mod2 = Lib.mod;
+          var deg2rad = Lib.deg2rad;
+          var rad2deg = Lib.rad2deg;
+          function Polar(gd2, id2, isSmith) {
+            this.isSmith = isSmith || false;
+            this.id = id2;
+            this.gd = gd2;
+            this._hasClipOnAxisFalse = null;
+            this.vangles = null;
+            this.radialAxisAngle = null;
+            this.traceHash = {};
+            this.layers = {};
+            this.clipPaths = {};
+            this.clipIds = {};
+            this.viewInitial = {};
+            var fullLayout = gd2._fullLayout;
+            var clipIdBase = "clip" + fullLayout._uid + id2;
+            this.clipIds.forTraces = clipIdBase + "-for-traces";
+            this.clipPaths.forTraces = fullLayout._clips.append("clipPath").attr("id", this.clipIds.forTraces);
+            this.clipPaths.forTraces.append("path");
+            this.framework = fullLayout["_" + (isSmith ? "smith" : "polar") + "layer"].append("g").attr("class", id2);
+            this.getHole = function(s2) {
+              return this.isSmith ? 0 : s2.hole;
+            };
+            this.getSector = function(s2) {
+              return this.isSmith ? [0, 360] : s2.sector;
+            };
+            this.getRadial = function(s2) {
+              return this.isSmith ? s2.realaxis : s2.radialaxis;
+            };
+            this.getAngular = function(s2) {
+              return this.isSmith ? s2.imaginaryaxis : s2.angularaxis;
+            };
+            if (!isSmith) {
+              this.radialTickLayout = null;
+              this.angularTickLayout = null;
+            }
+          }
+          var proto = Polar.prototype;
+          module2.exports = function createPolar(gd2, id2, isSmith) {
+            return new Polar(gd2, id2, isSmith);
+          };
+          proto.plot = function(polarCalcData, fullLayout) {
+            var _this = this;
+            var polarLayout = fullLayout[_this.id];
+            var found = false;
+            for (var i2 = 0; i2 < polarCalcData.length; i2++) {
+              var trace = polarCalcData[i2][0].trace;
+              if (trace.cliponaxis === false) {
+                found = true;
+                break;
+              }
+            }
+            _this._hasClipOnAxisFalse = found;
+            _this.updateLayers(fullLayout, polarLayout);
+            _this.updateLayout(fullLayout, polarLayout);
+            Plots.generalUpdatePerTraceModule(_this.gd, _this, polarCalcData, polarLayout);
+            _this.updateFx(fullLayout, polarLayout);
+            if (_this.isSmith) {
+              delete polarLayout.realaxis.range;
+              delete polarLayout.imaginaryaxis.range;
+            }
+          };
+          proto.updateLayers = function(fullLayout, polarLayout) {
+            var _this = this;
+            var isSmith = _this.isSmith;
+            var layers = _this.layers;
+            var radialLayout = _this.getRadial(polarLayout);
+            var angularLayout = _this.getAngular(polarLayout);
+            var layerNames = constants.layerNames;
+            var frontPlotIndex = layerNames.indexOf("frontplot");
+            var layerData = layerNames.slice(0, frontPlotIndex);
+            var isAngularAxisBelowTraces = angularLayout.layer === "below traces";
+            var isRadialAxisBelowTraces = radialLayout.layer === "below traces";
+            if (isAngularAxisBelowTraces) layerData.push("angular-line");
+            if (isRadialAxisBelowTraces) layerData.push("radial-line");
+            if (isAngularAxisBelowTraces) layerData.push("angular-axis");
+            if (isRadialAxisBelowTraces) layerData.push("radial-axis");
+            layerData.push("frontplot");
+            if (!isAngularAxisBelowTraces) layerData.push("angular-line");
+            if (!isRadialAxisBelowTraces) layerData.push("radial-line");
+            if (!isAngularAxisBelowTraces) layerData.push("angular-axis");
+            if (!isRadialAxisBelowTraces) layerData.push("radial-axis");
+            var subLayer = (isSmith ? "smith" : "polar") + "sublayer";
+            var join = _this.framework.selectAll("." + subLayer).data(layerData, String);
+            join.enter().append("g").attr("class", function(d2) {
+              return subLayer + " " + d2;
+            }).each(function(d2) {
+              var sel = layers[d2] = d3.select(this);
+              switch (d2) {
+                case "frontplot":
+                  if (!isSmith) {
+                    sel.append("g").classed("barlayer", true);
+                  }
+                  sel.append("g").classed("scatterlayer", true);
+                  break;
+                case "backplot":
+                  sel.append("g").classed("maplayer", true);
+                  break;
+                case "plotbg":
+                  layers.bg = sel.append("path");
+                  break;
+                case "radial-grid":
+                  sel.style("fill", "none");
+                  break;
+                case "angular-grid":
+                  sel.style("fill", "none");
+                  break;
+                case "radial-line":
+                  sel.append("line").style("fill", "none");
+                  break;
+                case "angular-line":
+                  sel.append("path").style("fill", "none");
+                  break;
+              }
+            });
+            join.order();
+          };
+          proto.updateLayout = function(fullLayout, polarLayout) {
+            var _this = this;
+            var layers = _this.layers;
+            var gs = fullLayout._size;
+            var radialLayout = _this.getRadial(polarLayout);
+            var angularLayout = _this.getAngular(polarLayout);
+            var xDomain = polarLayout.domain.x;
+            var yDomain = polarLayout.domain.y;
+            _this.xOffset = gs.l + gs.w * xDomain[0];
+            _this.yOffset = gs.t + gs.h * (1 - yDomain[1]);
+            var xLength = _this.xLength = gs.w * (xDomain[1] - xDomain[0]);
+            var yLength = _this.yLength = gs.h * (yDomain[1] - yDomain[0]);
+            var sector = _this.getSector(polarLayout);
+            _this.sectorInRad = sector.map(deg2rad);
+            var sectorBBox = _this.sectorBBox = computeSectorBBox(sector);
+            var dxSectorBBox = sectorBBox[2] - sectorBBox[0];
+            var dySectorBBox = sectorBBox[3] - sectorBBox[1];
+            var arDomain = yLength / xLength;
+            var arSector = Math.abs(dySectorBBox / dxSectorBBox);
+            var xLength2, yLength2;
+            var xDomain2, yDomain2;
+            var gap;
+            if (arDomain > arSector) {
+              xLength2 = xLength;
+              yLength2 = xLength * arSector;
+              gap = (yLength - yLength2) / gs.h / 2;
+              xDomain2 = [xDomain[0], xDomain[1]];
+              yDomain2 = [yDomain[0] + gap, yDomain[1] - gap];
+            } else {
+              xLength2 = yLength / arSector;
+              yLength2 = yLength;
+              gap = (xLength - xLength2) / gs.w / 2;
+              xDomain2 = [xDomain[0] + gap, xDomain[1] - gap];
+              yDomain2 = [yDomain[0], yDomain[1]];
+            }
+            _this.xLength2 = xLength2;
+            _this.yLength2 = yLength2;
+            _this.xDomain2 = xDomain2;
+            _this.yDomain2 = yDomain2;
+            var xOffset2 = _this.xOffset2 = gs.l + gs.w * xDomain2[0];
+            var yOffset2 = _this.yOffset2 = gs.t + gs.h * (1 - yDomain2[1]);
+            var radius = _this.radius = xLength2 / dxSectorBBox;
+            var innerRadius = _this.innerRadius = _this.getHole(polarLayout) * radius;
+            var cx = _this.cx = xOffset2 - radius * sectorBBox[0];
+            var cy = _this.cy = yOffset2 + radius * sectorBBox[3];
+            var cxx = _this.cxx = cx - xOffset2;
+            var cyy = _this.cyy = cy - yOffset2;
+            var side = radialLayout.side;
+            var trueSide;
+            if (side === "counterclockwise") {
+              trueSide = side;
+              side = "top";
+            } else if (side === "clockwise") {
+              trueSide = side;
+              side = "bottom";
+            }
+            _this.radialAxis = _this.mockAxis(fullLayout, polarLayout, radialLayout, {
+              // make this an 'x' axis to make positioning (especially rotation) easier
+              _id: "x",
+              // convert to 'x' axis equivalent
+              side,
+              // keep track of real side
+              _trueSide: trueSide,
+              // spans length 1 radius
+              domain: [innerRadius / gs.w, radius / gs.w]
+            });
+            _this.angularAxis = _this.mockAxis(fullLayout, polarLayout, angularLayout, {
+              side: "right",
+              // to get auto nticks right
+              domain: [0, Math.PI],
+              // don't pass through autorange logic
+              autorange: false
+            });
+            _this.doAutoRange(fullLayout, polarLayout);
+            _this.updateAngularAxis(fullLayout, polarLayout);
+            _this.updateRadialAxis(fullLayout, polarLayout);
+            _this.updateRadialAxisTitle(fullLayout, polarLayout);
+            _this.xaxis = _this.mockCartesianAxis(fullLayout, polarLayout, {
+              _id: "x",
+              domain: xDomain2
+            });
+            _this.yaxis = _this.mockCartesianAxis(fullLayout, polarLayout, {
+              _id: "y",
+              domain: yDomain2
+            });
+            var dPath = _this.pathSubplot();
+            _this.clipPaths.forTraces.select("path").attr("d", dPath).attr("transform", strTranslate(cxx, cyy));
+            layers.frontplot.attr("transform", strTranslate(xOffset2, yOffset2)).call(Drawing.setClipUrl, _this._hasClipOnAxisFalse ? null : _this.clipIds.forTraces, _this.gd);
+            layers.bg.attr("d", dPath).attr("transform", strTranslate(cx, cy)).call(Color2.fill, polarLayout.bgcolor);
+          };
+          proto.mockAxis = function(fullLayout, polarLayout, axLayout, opts) {
+            var ax = Lib.extendFlat({}, axLayout, opts);
+            setConvertPolar(ax, polarLayout, fullLayout);
+            return ax;
+          };
+          proto.mockCartesianAxis = function(fullLayout, polarLayout, opts) {
+            var _this = this;
+            var isSmith = _this.isSmith;
+            var axId = opts._id;
+            var ax = Lib.extendFlat({ type: "linear" }, opts);
+            setConvertCartesian(ax, fullLayout);
+            var bboxIndices = {
+              x: [0, 2],
+              y: [1, 3]
+            };
+            ax.setRange = function() {
+              var sectorBBox = _this.sectorBBox;
+              var ind = bboxIndices[axId];
+              var rl2 = _this.radialAxis._rl;
+              var drl = (rl2[1] - rl2[0]) / (1 - _this.getHole(polarLayout));
+              ax.range = [sectorBBox[ind[0]] * drl, sectorBBox[ind[1]] * drl];
+            };
+            ax.isPtWithinRange = axId === "x" && !isSmith ? function(d2) {
+              return _this.isPtInside(d2);
+            } : function() {
+              return true;
+            };
+            ax.setRange();
+            ax.setScale();
+            return ax;
+          };
+          proto.doAutoRange = function(fullLayout, polarLayout) {
+            var _this = this;
+            var gd2 = _this.gd;
+            var radialAxis = _this.radialAxis;
+            var radialLayout = _this.getRadial(polarLayout);
+            doAutoRange(gd2, radialAxis);
+            var rng = radialAxis.range;
+            radialLayout.range = rng.slice();
+            radialLayout._input.range = rng.slice();
+            radialAxis._rl = [
+              radialAxis.r2l(rng[0], null, "gregorian"),
+              radialAxis.r2l(rng[1], null, "gregorian")
+            ];
+            if (radialAxis.minallowed !== void 0) {
+              var minallowed = radialAxis.r2l(radialAxis.minallowed);
+              if (radialAxis._rl[0] > radialAxis._rl[1]) {
+                radialAxis._rl[1] = Math.max(radialAxis._rl[1], minallowed);
+              } else {
+                radialAxis._rl[0] = Math.max(radialAxis._rl[0], minallowed);
+              }
+            }
+            if (radialAxis.maxallowed !== void 0) {
+              var maxallowed = radialAxis.r2l(radialAxis.maxallowed);
+              if (radialAxis._rl[0] < radialAxis._rl[1]) {
+                radialAxis._rl[1] = Math.min(radialAxis._rl[1], maxallowed);
+              } else {
+                radialAxis._rl[0] = Math.min(radialAxis._rl[0], maxallowed);
+              }
+            }
+          };
+          proto.updateRadialAxis = function(fullLayout, polarLayout) {
+            var _this = this;
+            var gd2 = _this.gd;
+            var layers = _this.layers;
+            var radius = _this.radius;
+            var innerRadius = _this.innerRadius;
+            var cx = _this.cx;
+            var cy = _this.cy;
+            var radialLayout = _this.getRadial(polarLayout);
+            var a0 = mod2(_this.getSector(polarLayout)[0], 360);
+            var ax = _this.radialAxis;
+            var hasRoomForIt = innerRadius < radius;
+            var isSmith = _this.isSmith;
+            if (!isSmith) {
+              _this.fillViewInitialKey("radialaxis.angle", radialLayout.angle);
+              _this.fillViewInitialKey("radialaxis.range", ax.range.slice());
+              ax.setGeometry();
+            }
+            if (ax.tickangle === "auto" && (a0 > 90 && a0 <= 270)) {
+              ax.tickangle = 180;
+            }
+            var transFn = isSmith ? function(d2) {
+              var t4 = smithTransform(_this, smith([d2.x, 0]));
+              return strTranslate(t4[0] - cx, t4[1] - cy);
+            } : function(d2) {
+              return strTranslate(ax.l2p(d2.x) + innerRadius, 0);
+            };
+            var gridPathFn = isSmith ? function(d2) {
+              return resistanceArc(_this, d2.x, -Infinity, Infinity);
+            } : function(d2) {
+              return _this.pathArc(ax.r2p(d2.x) + innerRadius);
+            };
+            var newTickLayout = strTickLayout(radialLayout);
+            if (_this.radialTickLayout !== newTickLayout) {
+              layers["radial-axis"].selectAll(".xtick").remove();
+              _this.radialTickLayout = newTickLayout;
+            }
+            if (hasRoomForIt) {
+              ax.setScale();
+              var labelShift = 0;
+              var vals = isSmith ? (ax.tickvals || []).filter(function(x2) {
+                return x2 >= 0;
+              }).map(function(x2) {
+                return Axes.tickText(ax, x2, true, false);
+              }) : Axes.calcTicks(ax);
+              var valsClipped = isSmith ? vals : Axes.clipEnds(ax, vals);
+              var tickSign = Axes.getTickSigns(ax)[2];
+              if (isSmith) {
+                if (ax.ticks === "top" && ax.side === "bottom" || ax.ticks === "bottom" && ax.side === "top") {
+                  tickSign = -tickSign;
+                }
+                if (ax.ticks === "top" && ax.side === "top") labelShift = -ax.ticklen;
+                if (ax.ticks === "bottom" && ax.side === "bottom") labelShift = ax.ticklen;
+              }
+              Axes.drawTicks(gd2, ax, {
+                vals,
+                layer: layers["radial-axis"],
+                path: Axes.makeTickPath(ax, 0, tickSign),
+                transFn,
+                crisp: false
+              });
+              Axes.drawGrid(gd2, ax, {
+                vals: valsClipped,
+                layer: layers["radial-grid"],
+                path: gridPathFn,
+                transFn: Lib.noop,
+                crisp: false
+              });
+              Axes.drawLabels(gd2, ax, {
+                vals,
+                layer: layers["radial-axis"],
+                transFn,
+                labelFns: Axes.makeLabelFns(ax, labelShift)
+              });
+            }
+            var angle2 = _this.radialAxisAngle = _this.vangles ? rad2deg(snapToVertexAngle(deg2rad(radialLayout.angle), _this.vangles)) : radialLayout.angle;
+            var tLayer = strTranslate(cx, cy);
+            var tLayer2 = tLayer + strRotate(-angle2);
+            updateElement(
+              layers["radial-axis"],
+              hasRoomForIt && (radialLayout.showticklabels || radialLayout.ticks),
+              { transform: tLayer2 }
+            );
+            updateElement(
+              layers["radial-grid"],
+              hasRoomForIt && radialLayout.showgrid,
+              { transform: isSmith ? "" : tLayer }
+            );
+            updateElement(
+              layers["radial-line"].select("line"),
+              hasRoomForIt && radialLayout.showline,
+              {
+                x1: isSmith ? -radius : innerRadius,
+                y1: 0,
+                x2: radius,
+                y2: 0,
+                transform: tLayer2
+              }
+            ).attr("stroke-width", radialLayout.linewidth).call(Color2.stroke, radialLayout.linecolor);
+          };
+          proto.updateRadialAxisTitle = function(fullLayout, polarLayout, _angle) {
+            if (this.isSmith) return;
+            var _this = this;
+            var gd2 = _this.gd;
+            var radius = _this.radius;
+            var cx = _this.cx;
+            var cy = _this.cy;
+            var radialLayout = _this.getRadial(polarLayout);
+            var titleClass = _this.id + "title";
+            var pad = 0;
+            if (radialLayout.title) {
+              var h2 = Drawing.bBox(_this.layers["radial-axis"].node()).height;
+              var ts = radialLayout.title.font.size;
+              var side = radialLayout.side;
+              pad = side === "top" ? ts : side === "counterclockwise" ? -(h2 + ts * 0.4) : h2 + ts * 0.8;
+            }
+            var angle2 = _angle !== void 0 ? _angle : _this.radialAxisAngle;
+            var angleRad = deg2rad(angle2);
+            var cosa = Math.cos(angleRad);
+            var sina = Math.sin(angleRad);
+            var x2 = cx + radius / 2 * cosa + pad * sina;
+            var y2 = cy - radius / 2 * sina + pad * cosa;
+            _this.layers["radial-axis-title"] = Titles.draw(gd2, titleClass, {
+              propContainer: radialLayout,
+              propName: _this.id + ".radialaxis.title.text",
+              placeholder: _2(gd2, "Click to enter radial axis title"),
+              attributes: {
+                x: x2,
+                y: y2,
+                "text-anchor": "middle"
+              },
+              transform: { rotate: -angle2 }
+            });
+          };
+          proto.updateAngularAxis = function(fullLayout, polarLayout) {
+            var _this = this;
+            var gd2 = _this.gd;
+            var layers = _this.layers;
+            var radius = _this.radius;
+            var innerRadius = _this.innerRadius;
+            var cx = _this.cx;
+            var cy = _this.cy;
+            var angularLayout = _this.getAngular(polarLayout);
+            var ax = _this.angularAxis;
+            var isSmith = _this.isSmith;
+            if (!isSmith) {
+              _this.fillViewInitialKey("angularaxis.rotation", angularLayout.rotation);
+              ax.setGeometry();
+              ax.setScale();
+            }
+            var t2g = isSmith ? function(d2) {
+              var t4 = smithTransform(_this, smith([0, d2.x]));
+              return Math.atan2(t4[0] - cx, t4[1] - cy) - Math.PI / 2;
+            } : function(d2) {
+              return ax.t2g(d2.x);
+            };
+            if (ax.type === "linear" && ax.thetaunit === "radians") {
+              ax.tick0 = rad2deg(ax.tick0);
+              ax.dtick = rad2deg(ax.dtick);
+            }
+            var _transFn = function(rad) {
+              return strTranslate(cx + radius * Math.cos(rad), cy - radius * Math.sin(rad));
+            };
+            var transFn = isSmith ? function(d2) {
+              var t4 = smithTransform(_this, smith([0, d2.x]));
+              return strTranslate(t4[0], t4[1]);
+            } : function(d2) {
+              return _transFn(t2g(d2));
+            };
+            var transFn2 = isSmith ? function(d2) {
+              var t4 = smithTransform(_this, smith([0, d2.x]));
+              var rad = Math.atan2(t4[0] - cx, t4[1] - cy) - Math.PI / 2;
+              return strTranslate(t4[0], t4[1]) + strRotate(-rad2deg(rad));
+            } : function(d2) {
+              var rad = t2g(d2);
+              return _transFn(rad) + strRotate(-rad2deg(rad));
+            };
+            var gridPathFn = isSmith ? function(d2) {
+              return reactanceArc(_this, d2.x, 0, Infinity);
+            } : function(d2) {
+              var rad = t2g(d2);
+              var cosRad = Math.cos(rad);
+              var sinRad = Math.sin(rad);
+              return "M" + [cx + innerRadius * cosRad, cy - innerRadius * sinRad] + "L" + [cx + radius * cosRad, cy - radius * sinRad];
+            };
+            var out = Axes.makeLabelFns(ax, 0);
+            var labelStandoff = out.labelStandoff;
+            var labelFns = {};
+            labelFns.xFn = function(d2) {
+              var rad = t2g(d2);
+              return Math.cos(rad) * labelStandoff;
+            };
+            labelFns.yFn = function(d2) {
+              var rad = t2g(d2);
+              var ff2 = Math.sin(rad) > 0 ? 0.2 : 1;
+              return -Math.sin(rad) * (labelStandoff + d2.fontSize * ff2) + Math.abs(Math.cos(rad)) * (d2.fontSize * MID_SHIFT);
+            };
+            labelFns.anchorFn = function(d2) {
+              var rad = t2g(d2);
+              var cos = Math.cos(rad);
+              return Math.abs(cos) < 0.1 ? "middle" : cos > 0 ? "start" : "end";
+            };
+            labelFns.heightFn = function(d2, a2, h2) {
+              var rad = t2g(d2);
+              return -0.5 * (1 + Math.sin(rad)) * h2;
+            };
+            var newTickLayout = strTickLayout(angularLayout);
+            if (_this.angularTickLayout !== newTickLayout) {
+              layers["angular-axis"].selectAll("." + ax._id + "tick").remove();
+              _this.angularTickLayout = newTickLayout;
+            }
+            var vals = isSmith ? [Infinity].concat(ax.tickvals || []).map(function(x2) {
+              return Axes.tickText(ax, x2, true, false);
+            }) : Axes.calcTicks(ax);
+            if (isSmith) {
+              vals[0].text = "∞";
+              vals[0].fontSize *= 1.75;
+            }
+            var vangles;
+            if (polarLayout.gridshape === "linear") {
+              vangles = vals.map(t2g);
+              if (Lib.angleDelta(vangles[0], vangles[1]) < 0) {
+                vangles = vangles.slice().reverse();
+              }
+            } else {
+              vangles = null;
+            }
+            _this.vangles = vangles;
+            if (ax.type === "category") {
+              vals = vals.filter(function(d2) {
+                return Lib.isAngleInsideSector(t2g(d2), _this.sectorInRad);
+              });
+            }
+            if (ax.visible) {
+              var tickSign = ax.ticks === "inside" ? -1 : 1;
+              var pad = (ax.linewidth || 1) / 2;
+              Axes.drawTicks(gd2, ax, {
+                vals,
+                layer: layers["angular-axis"],
+                path: "M" + tickSign * pad + ",0h" + tickSign * ax.ticklen,
+                transFn: transFn2,
+                crisp: false
+              });
+              Axes.drawGrid(gd2, ax, {
+                vals,
+                layer: layers["angular-grid"],
+                path: gridPathFn,
+                transFn: Lib.noop,
+                crisp: false
+              });
+              Axes.drawLabels(gd2, ax, {
+                vals,
+                layer: layers["angular-axis"],
+                repositionOnUpdate: true,
+                transFn,
+                labelFns
+              });
+            }
+            updateElement(layers["angular-line"].select("path"), angularLayout.showline, {
+              d: _this.pathSubplot(),
+              transform: strTranslate(cx, cy)
+            }).attr("stroke-width", angularLayout.linewidth).call(Color2.stroke, angularLayout.linecolor);
+          };
+          proto.updateFx = function(fullLayout, polarLayout) {
+            if (!this.gd._context.staticPlot) {
+              var hasDrag = !this.isSmith;
+              if (hasDrag) {
+                this.updateAngularDrag(fullLayout);
+                this.updateRadialDrag(fullLayout, polarLayout, 0);
+                this.updateRadialDrag(fullLayout, polarLayout, 1);
+              }
+              this.updateHoverAndMainDrag(fullLayout);
+            }
+          };
+          proto.updateHoverAndMainDrag = function(fullLayout) {
+            var _this = this;
+            var isSmith = _this.isSmith;
+            var gd2 = _this.gd;
+            var layers = _this.layers;
+            var zoomlayer = fullLayout._zoomlayer;
+            var MINZOOM = constants.MINZOOM;
+            var OFFEDGE = constants.OFFEDGE;
+            var radius = _this.radius;
+            var innerRadius = _this.innerRadius;
+            var cx = _this.cx;
+            var cy = _this.cy;
+            var cxx = _this.cxx;
+            var cyy = _this.cyy;
+            var sectorInRad = _this.sectorInRad;
+            var vangles = _this.vangles;
+            var radialAxis = _this.radialAxis;
+            var clampTiny = helpers.clampTiny;
+            var findXYatLength = helpers.findXYatLength;
+            var findEnclosingVertexAngles = helpers.findEnclosingVertexAngles;
+            var chw = constants.cornerHalfWidth;
+            var chl = constants.cornerLen / 2;
+            var scaleX2;
+            var scaleY2;
+            var mainDrag = dragBox.makeDragger(layers, "path", "maindrag", fullLayout.dragmode === false ? "none" : "crosshair");
+            d3.select(mainDrag).attr("d", _this.pathSubplot()).attr("transform", strTranslate(cx, cy));
+            mainDrag.onmousemove = function(evt) {
+              Fx.hover(gd2, evt, _this.id);
+              gd2._fullLayout._lasthover = mainDrag;
+              gd2._fullLayout._hoversubplot = _this.id;
+            };
+            mainDrag.onmouseout = function(evt) {
+              if (gd2._dragging) return;
+              dragElement.unhover(gd2, evt);
+            };
+            var dragOpts = {
+              element: mainDrag,
+              gd: gd2,
+              subplot: _this.id,
+              plotinfo: {
+                id: _this.id,
+                xaxis: _this.xaxis,
+                yaxis: _this.yaxis
+              },
+              xaxes: [_this.xaxis],
+              yaxes: [_this.yaxis]
+            };
+            var x0, y0;
+            var r0, r1;
+            var path0, dimmed, lum;
+            var zb2, corners;
+            function norm(x2, y2) {
+              return Math.sqrt(x2 * x2 + y2 * y2);
+            }
+            function xy2r(x2, y2) {
+              return norm(x2 - cxx, y2 - cyy);
+            }
+            function xy2a(x2, y2) {
+              return Math.atan2(cyy - y2, x2 - cxx);
+            }
+            function ra2xy(r2, a2) {
+              return [r2 * Math.cos(a2), r2 * Math.sin(-a2)];
+            }
+            function pathCorner(r2, a2) {
+              if (r2 === 0) return _this.pathSector(2 * chw);
+              var da2 = chl / r2;
+              var am = a2 - da2;
+              var ap = a2 + da2;
+              var rb2 = Math.max(0, Math.min(r2, radius));
+              var rm = rb2 - chw;
+              var rp = rb2 + chw;
+              return "M" + ra2xy(rm, am) + "A" + [rm, rm] + " 0,0,0 " + ra2xy(rm, ap) + "L" + ra2xy(rp, ap) + "A" + [rp, rp] + " 0,0,1 " + ra2xy(rp, am) + "Z";
+            }
+            function pathCornerForPolygons(r2, va0, va1) {
+              if (r2 === 0) return _this.pathSector(2 * chw);
+              var xy0 = ra2xy(r2, va0);
+              var xy1 = ra2xy(r2, va1);
+              var x2 = clampTiny((xy0[0] + xy1[0]) / 2);
+              var y2 = clampTiny((xy0[1] + xy1[1]) / 2);
+              var innerPts, outerPts;
+              if (x2 && y2) {
+                var m2 = y2 / x2;
+                var mperp = -1 / m2;
+                var midPts = findXYatLength(chw, m2, x2, y2);
+                innerPts = findXYatLength(chl, mperp, midPts[0][0], midPts[0][1]);
+                outerPts = findXYatLength(chl, mperp, midPts[1][0], midPts[1][1]);
+              } else {
+                var dx, dy;
+                if (y2) {
+                  dx = chl;
+                  dy = chw;
+                } else {
+                  dx = chw;
+                  dy = chl;
+                }
+                innerPts = [[x2 - dx, y2 - dy], [x2 + dx, y2 - dy]];
+                outerPts = [[x2 - dx, y2 + dy], [x2 + dx, y2 + dy]];
+              }
+              return "M" + innerPts.join("L") + "L" + outerPts.reverse().join("L") + "Z";
+            }
+            function zoomPrep() {
+              r0 = null;
+              r1 = null;
+              path0 = _this.pathSubplot();
+              dimmed = false;
+              var polarLayoutNow = gd2._fullLayout[_this.id];
+              lum = tinycolor(polarLayoutNow.bgcolor).getLuminance();
+              zb2 = dragBox.makeZoombox(zoomlayer, lum, cx, cy, path0);
+              zb2.attr("fill-rule", "evenodd");
+              corners = dragBox.makeCorners(zoomlayer, cx, cy);
+              clearOutline(gd2);
+            }
+            function clampAndSetR0R1(rr0, rr1) {
+              rr1 = Math.max(Math.min(rr1, radius), innerRadius);
+              if (rr0 < OFFEDGE) rr0 = 0;
+              else if (radius - rr0 < OFFEDGE) rr0 = radius;
+              else if (rr1 < OFFEDGE) rr1 = 0;
+              else if (radius - rr1 < OFFEDGE) rr1 = radius;
+              if (Math.abs(rr1 - rr0) > MINZOOM) {
+                if (rr0 < rr1) {
+                  r0 = rr0;
+                  r1 = rr1;
+                } else {
+                  r0 = rr1;
+                  r1 = rr0;
+                }
+                return true;
+              } else {
+                r0 = null;
+                r1 = null;
+                return false;
+              }
+            }
+            function applyZoomMove(path1, cpath) {
+              path1 = path1 || path0;
+              cpath = cpath || "M0,0Z";
+              zb2.attr("d", path1);
+              corners.attr("d", cpath);
+              dragBox.transitionZoombox(zb2, corners, dimmed, lum);
+              dimmed = true;
+              var updateObj = {};
+              computeZoomUpdates(updateObj);
+              gd2.emit("plotly_relayouting", updateObj);
+            }
+            function zoomMove(dx, dy) {
+              dx = dx * scaleX2;
+              dy = dy * scaleY2;
+              var x1 = x0 + dx;
+              var y1 = y0 + dy;
+              var rr0 = xy2r(x0, y0);
+              var rr1 = Math.min(xy2r(x1, y1), radius);
+              var a0 = xy2a(x0, y0);
+              var path1;
+              var cpath;
+              if (clampAndSetR0R1(rr0, rr1)) {
+                path1 = path0 + _this.pathSector(r1);
+                if (r0) path1 += _this.pathSector(r0);
+                cpath = pathCorner(r0, a0) + pathCorner(r1, a0);
+              }
+              applyZoomMove(path1, cpath);
+            }
+            function findPolygonRadius(x2, y2, va0, va1) {
+              var xy = helpers.findIntersectionXY(va0, va1, va0, [x2 - cxx, cyy - y2]);
+              return norm(xy[0], xy[1]);
+            }
+            function zoomMoveForPolygons(dx, dy) {
+              var x1 = x0 + dx;
+              var y1 = y0 + dy;
+              var a0 = xy2a(x0, y0);
+              var a1 = xy2a(x1, y1);
+              var vangles0 = findEnclosingVertexAngles(a0, vangles);
+              var vangles1 = findEnclosingVertexAngles(a1, vangles);
+              var rr0 = findPolygonRadius(x0, y0, vangles0[0], vangles0[1]);
+              var rr1 = Math.min(findPolygonRadius(x1, y1, vangles1[0], vangles1[1]), radius);
+              var path1;
+              var cpath;
+              if (clampAndSetR0R1(rr0, rr1)) {
+                path1 = path0 + _this.pathSector(r1);
+                if (r0) path1 += _this.pathSector(r0);
+                cpath = [
+                  pathCornerForPolygons(r0, vangles0[0], vangles0[1]),
+                  pathCornerForPolygons(r1, vangles0[0], vangles0[1])
+                ].join(" ");
+              }
+              applyZoomMove(path1, cpath);
+            }
+            function zoomDone() {
+              dragBox.removeZoombox(gd2);
+              if (r0 === null || r1 === null) return;
+              var updateObj = {};
+              computeZoomUpdates(updateObj);
+              dragBox.showDoubleClickNotifier(gd2);
+              Registry.call("_guiRelayout", gd2, updateObj);
+            }
+            function computeZoomUpdates(update) {
+              var rl2 = radialAxis._rl;
+              var m2 = (rl2[1] - rl2[0]) / (1 - innerRadius / radius) / radius;
+              var newRng = [
+                rl2[0] + (r0 - innerRadius) * m2,
+                rl2[0] + (r1 - innerRadius) * m2
+              ];
+              update[_this.id + ".radialaxis.range"] = newRng;
+            }
+            function zoomClick(numClicks, evt) {
+              var clickMode = gd2._fullLayout.clickmode;
+              dragBox.removeZoombox(gd2);
+              if (numClicks === 2) {
+                var updateObj = {};
+                for (var k2 in _this.viewInitial) {
+                  updateObj[_this.id + "." + k2] = _this.viewInitial[k2];
+                }
+                gd2.emit("plotly_doubleclick", null);
+                Registry.call("_guiRelayout", gd2, updateObj);
+              }
+              if (clickMode.indexOf("select") > -1 && numClicks === 1) {
+                selectOnClick(evt, gd2, [_this.xaxis], [_this.yaxis], _this.id, dragOpts);
+              }
+              if (clickMode.indexOf("event") > -1) {
+                Fx.click(gd2, evt, _this.id);
+              }
+            }
+            dragOpts.prepFn = function(evt, startX, startY) {
+              var dragModeNow = gd2._fullLayout.dragmode;
+              var bbox = mainDrag.getBoundingClientRect();
+              gd2._fullLayout._calcInverseTransform(gd2);
+              var inverse = gd2._fullLayout._invTransform;
+              scaleX2 = gd2._fullLayout._invScaleX;
+              scaleY2 = gd2._fullLayout._invScaleY;
+              var transformedCoords = Lib.apply3DTransform(inverse)(startX - bbox.left, startY - bbox.top);
+              x0 = transformedCoords[0];
+              y0 = transformedCoords[1];
+              if (vangles) {
+                var offset = helpers.findPolygonOffset(radius, sectorInRad[0], sectorInRad[1], vangles);
+                x0 += cxx + offset[0];
+                y0 += cyy + offset[1];
+              }
+              switch (dragModeNow) {
+                case "zoom":
+                  dragOpts.clickFn = zoomClick;
+                  if (!isSmith) {
+                    if (vangles) {
+                      dragOpts.moveFn = zoomMoveForPolygons;
+                    } else {
+                      dragOpts.moveFn = zoomMove;
+                    }
+                    dragOpts.doneFn = zoomDone;
+                    zoomPrep();
+                  }
+                  break;
+                case "select":
+                case "lasso":
+                  prepSelect(evt, startX, startY, dragOpts, dragModeNow);
+                  break;
+              }
+            };
+            dragElement.init(dragOpts);
+          };
+          proto.updateRadialDrag = function(fullLayout, polarLayout, rngIndex) {
+            var _this = this;
+            var gd2 = _this.gd;
+            var layers = _this.layers;
+            var radius = _this.radius;
+            var innerRadius = _this.innerRadius;
+            var cx = _this.cx;
+            var cy = _this.cy;
+            var radialAxis = _this.radialAxis;
+            var bl2 = constants.radialDragBoxSize;
+            var bl22 = bl2 / 2;
+            if (!radialAxis.visible) return;
+            var angle0 = deg2rad(_this.radialAxisAngle);
+            var rl2 = radialAxis._rl;
+            var rl0 = rl2[0];
+            var rl1 = rl2[1];
+            var rbase = rl2[rngIndex];
+            var m2 = 0.75 * (rl2[1] - rl2[0]) / (1 - _this.getHole(polarLayout)) / radius;
+            var tx, ty, className;
+            if (rngIndex) {
+              tx = cx + (radius + bl22) * Math.cos(angle0);
+              ty = cy - (radius + bl22) * Math.sin(angle0);
+              className = "radialdrag";
+            } else {
+              tx = cx + (innerRadius - bl22) * Math.cos(angle0);
+              ty = cy - (innerRadius - bl22) * Math.sin(angle0);
+              className = "radialdrag-inner";
+            }
+            var radialDrag = dragBox.makeRectDragger(layers, className, "crosshair", -bl22, -bl22, bl2, bl2);
+            var dragOpts = { element: radialDrag, gd: gd2 };
+            if (fullLayout.dragmode === false) {
+              dragOpts.dragmode = false;
+            }
+            updateElement(d3.select(radialDrag), radialAxis.visible && innerRadius < radius, {
+              transform: strTranslate(tx, ty)
+            });
+            var moveFn2;
+            var angle1;
+            var rprime;
+            function moveFn(dx, dy) {
+              if (moveFn2) {
+                moveFn2(dx, dy);
+              } else {
+                var dvec = [dx, -dy];
+                var rvec = [Math.cos(angle0), Math.sin(angle0)];
+                var comp = Math.abs(Lib.dot(dvec, rvec) / Math.sqrt(Lib.dot(dvec, dvec)));
+                if (!isNaN(comp)) {
+                  moveFn2 = comp < 0.5 ? rotateMove : rerangeMove;
+                }
+              }
+              var update = {};
+              computeRadialAxisUpdates(update);
+              gd2.emit("plotly_relayouting", update);
+            }
+            function computeRadialAxisUpdates(update) {
+              if (angle1 !== null) {
+                update[_this.id + ".radialaxis.angle"] = angle1;
+              } else if (rprime !== null) {
+                update[_this.id + ".radialaxis.range[" + rngIndex + "]"] = rprime;
+              }
+            }
+            function doneFn() {
+              if (angle1 !== null) {
+                Registry.call("_guiRelayout", gd2, _this.id + ".radialaxis.angle", angle1);
+              } else if (rprime !== null) {
+                Registry.call("_guiRelayout", gd2, _this.id + ".radialaxis.range[" + rngIndex + "]", rprime);
+              }
+            }
+            function rotateMove(dx, dy) {
+              if (rngIndex === 0) return;
+              var x1 = tx + dx;
+              var y1 = ty + dy;
+              angle1 = Math.atan2(cy - y1, x1 - cx);
+              if (_this.vangles) angle1 = snapToVertexAngle(angle1, _this.vangles);
+              angle1 = rad2deg(angle1);
+              var transform = strTranslate(cx, cy) + strRotate(-angle1);
+              layers["radial-axis"].attr("transform", transform);
+              layers["radial-line"].select("line").attr("transform", transform);
+              var fullLayoutNow = _this.gd._fullLayout;
+              var polarLayoutNow = fullLayoutNow[_this.id];
+              _this.updateRadialAxisTitle(fullLayoutNow, polarLayoutNow, angle1);
+            }
+            function rerangeMove(dx, dy) {
+              var dr = Lib.dot([dx, -dy], [Math.cos(angle0), Math.sin(angle0)]);
+              rprime = rbase - m2 * dr;
+              if (m2 > 0 !== (rngIndex ? rprime > rl0 : rprime < rl1)) {
+                rprime = null;
+                return;
+              }
+              var fullLayoutNow = gd2._fullLayout;
+              var polarLayoutNow = fullLayoutNow[_this.id];
+              radialAxis.range[rngIndex] = rprime;
+              radialAxis._rl[rngIndex] = rprime;
+              _this.updateRadialAxis(fullLayoutNow, polarLayoutNow);
+              _this.xaxis.setRange();
+              _this.xaxis.setScale();
+              _this.yaxis.setRange();
+              _this.yaxis.setScale();
+              var hasRegl = false;
+              for (var traceType in _this.traceHash) {
+                var moduleCalcData = _this.traceHash[traceType];
+                var moduleCalcDataVisible = Lib.filterVisible(moduleCalcData);
+                var _module = moduleCalcData[0][0].trace._module;
+                _module.plot(gd2, _this, moduleCalcDataVisible, polarLayoutNow);
+                if (Registry.traceIs(traceType, "gl") && moduleCalcDataVisible.length) hasRegl = true;
+              }
+              if (hasRegl) {
+                clearGlCanvases(gd2);
+                redrawReglTraces(gd2);
+              }
+            }
+            dragOpts.prepFn = function() {
+              moveFn2 = null;
+              angle1 = null;
+              rprime = null;
+              dragOpts.moveFn = moveFn;
+              dragOpts.doneFn = doneFn;
+              clearOutline(gd2);
+            };
+            dragOpts.clampFn = function(dx, dy) {
+              if (Math.sqrt(dx * dx + dy * dy) < constants.MINDRAG) {
+                dx = 0;
+                dy = 0;
+              }
+              return [dx, dy];
+            };
+            dragElement.init(dragOpts);
+          };
+          proto.updateAngularDrag = function(fullLayout) {
+            var _this = this;
+            var gd2 = _this.gd;
+            var layers = _this.layers;
+            var radius = _this.radius;
+            var angularAxis = _this.angularAxis;
+            var cx = _this.cx;
+            var cy = _this.cy;
+            var cxx = _this.cxx;
+            var cyy = _this.cyy;
+            var dbs = constants.angularDragBoxSize;
+            var angularDrag = dragBox.makeDragger(layers, "path", "angulardrag", fullLayout.dragmode === false ? "none" : "move");
+            var dragOpts = { element: angularDrag, gd: gd2 };
+            if (fullLayout.dragmode === false) {
+              dragOpts.dragmode = false;
+            } else {
+              d3.select(angularDrag).attr("d", _this.pathAnnulus(radius, radius + dbs)).attr("transform", strTranslate(cx, cy)).call(setCursor, "move");
+            }
+            function xy2a(x2, y2) {
+              return Math.atan2(cyy + dbs - y2, x2 - cxx - dbs);
+            }
+            var scatterTraces = layers.frontplot.select(".scatterlayer").selectAll(".trace");
+            var scatterPoints = scatterTraces.selectAll(".point");
+            var scatterTextPoints = scatterTraces.selectAll(".textpoint");
+            var x0, y0;
+            var rot0, rot1;
+            var rrot1;
+            var a0;
+            function moveFn(dx, dy) {
+              var fullLayoutNow = _this.gd._fullLayout;
+              var polarLayoutNow = fullLayoutNow[_this.id];
+              var x1 = x0 + dx * fullLayout._invScaleX;
+              var y1 = y0 + dy * fullLayout._invScaleY;
+              var a1 = xy2a(x1, y1);
+              var da2 = rad2deg(a1 - a0);
+              rot1 = rot0 + da2;
+              layers.frontplot.attr(
+                "transform",
+                strTranslate(_this.xOffset2, _this.yOffset2) + strRotate([-da2, cxx, cyy])
+              );
+              if (_this.vangles) {
+                rrot1 = _this.radialAxisAngle + da2;
+                var trans = strTranslate(cx, cy) + strRotate(-da2);
+                var trans2 = strTranslate(cx, cy) + strRotate(-rrot1);
+                layers.bg.attr("transform", trans);
+                layers["radial-grid"].attr("transform", trans);
+                layers["radial-axis"].attr("transform", trans2);
+                layers["radial-line"].select("line").attr("transform", trans2);
+                _this.updateRadialAxisTitle(fullLayoutNow, polarLayoutNow, rrot1);
+              } else {
+                _this.clipPaths.forTraces.select("path").attr(
+                  "transform",
+                  strTranslate(cxx, cyy) + strRotate(da2)
+                );
+              }
+              scatterPoints.each(function() {
+                var sel = d3.select(this);
+                var xy = Drawing.getTranslate(sel);
+                sel.attr("transform", strTranslate(xy.x, xy.y) + strRotate([da2]));
+              });
+              scatterTextPoints.each(function() {
+                var sel = d3.select(this);
+                var tx = sel.select("text");
+                var xy = Drawing.getTranslate(sel);
+                sel.attr("transform", strRotate([da2, tx.attr("x"), tx.attr("y")]) + strTranslate(xy.x, xy.y));
+              });
+              angularAxis.rotation = Lib.modHalf(rot1, 360);
+              _this.updateAngularAxis(fullLayoutNow, polarLayoutNow);
+              if (_this._hasClipOnAxisFalse && !Lib.isFullCircle(_this.sectorInRad)) {
+                scatterTraces.call(Drawing.hideOutsideRangePoints, _this);
+              }
+              var hasRegl = false;
+              for (var traceType in _this.traceHash) {
+                if (Registry.traceIs(traceType, "gl")) {
+                  var moduleCalcData = _this.traceHash[traceType];
+                  var moduleCalcDataVisible = Lib.filterVisible(moduleCalcData);
+                  var _module = moduleCalcData[0][0].trace._module;
+                  _module.plot(gd2, _this, moduleCalcDataVisible, polarLayoutNow);
+                  if (moduleCalcDataVisible.length) hasRegl = true;
+                }
+              }
+              if (hasRegl) {
+                clearGlCanvases(gd2);
+                redrawReglTraces(gd2);
+              }
+              var update = {};
+              computeRotationUpdates(update);
+              gd2.emit("plotly_relayouting", update);
+            }
+            function computeRotationUpdates(updateObj) {
+              updateObj[_this.id + ".angularaxis.rotation"] = rot1;
+              if (_this.vangles) {
+                updateObj[_this.id + ".radialaxis.angle"] = rrot1;
+              }
+            }
+            function doneFn() {
+              scatterTextPoints.select("text").attr("transform", null);
+              var updateObj = {};
+              computeRotationUpdates(updateObj);
+              Registry.call("_guiRelayout", gd2, updateObj);
+            }
+            dragOpts.prepFn = function(evt, startX, startY) {
+              var polarLayoutNow = fullLayout[_this.id];
+              rot0 = polarLayoutNow.angularaxis.rotation;
+              var bbox = angularDrag.getBoundingClientRect();
+              x0 = startX - bbox.left;
+              y0 = startY - bbox.top;
+              gd2._fullLayout._calcInverseTransform(gd2);
+              var transformedCoords = Lib.apply3DTransform(fullLayout._invTransform)(x0, y0);
+              x0 = transformedCoords[0];
+              y0 = transformedCoords[1];
+              a0 = xy2a(x0, y0);
+              dragOpts.moveFn = moveFn;
+              dragOpts.doneFn = doneFn;
+              clearOutline(gd2);
+            };
+            if (_this.vangles && !Lib.isFullCircle(_this.sectorInRad)) {
+              dragOpts.prepFn = Lib.noop;
+              setCursor(d3.select(angularDrag), null);
+            }
+            dragElement.init(dragOpts);
+          };
+          proto.isPtInside = function(d2) {
+            if (this.isSmith) return true;
+            var sectorInRad = this.sectorInRad;
+            var vangles = this.vangles;
+            var thetag = this.angularAxis.c2g(d2.theta);
+            var radialAxis = this.radialAxis;
+            var r2 = radialAxis.c2l(d2.r);
+            var rl2 = radialAxis._rl;
+            var fn = vangles ? helpers.isPtInsidePolygon : Lib.isPtInsideSector;
+            return fn(r2, thetag, rl2, sectorInRad, vangles);
+          };
+          proto.pathArc = function(r2) {
+            var sectorInRad = this.sectorInRad;
+            var vangles = this.vangles;
+            var fn = vangles ? helpers.pathPolygon : Lib.pathArc;
+            return fn(r2, sectorInRad[0], sectorInRad[1], vangles);
+          };
+          proto.pathSector = function(r2) {
+            var sectorInRad = this.sectorInRad;
+            var vangles = this.vangles;
+            var fn = vangles ? helpers.pathPolygon : Lib.pathSector;
+            return fn(r2, sectorInRad[0], sectorInRad[1], vangles);
+          };
+          proto.pathAnnulus = function(r0, r1) {
+            var sectorInRad = this.sectorInRad;
+            var vangles = this.vangles;
+            var fn = vangles ? helpers.pathPolygonAnnulus : Lib.pathAnnulus;
+            return fn(r0, r1, sectorInRad[0], sectorInRad[1], vangles);
+          };
+          proto.pathSubplot = function() {
+            var r0 = this.innerRadius;
+            var r1 = this.radius;
+            return r0 ? this.pathAnnulus(r0, r1) : this.pathSector(r1);
+          };
+          proto.fillViewInitialKey = function(key, val) {
+            if (!(key in this.viewInitial)) {
+              this.viewInitial[key] = val;
+            }
+          };
+          function strTickLayout(axLayout) {
+            var out = axLayout.ticks + String(axLayout.ticklen) + String(axLayout.showticklabels);
+            if ("side" in axLayout) out += axLayout.side;
+            return out;
+          }
+          function computeSectorBBox(sector) {
+            var s0 = sector[0];
+            var s1 = sector[1];
+            var arc = s1 - s0;
+            var a0 = mod2(s0, 360);
+            var a1 = a0 + arc;
+            var ax0 = Math.cos(deg2rad(a0));
+            var ay0 = Math.sin(deg2rad(a0));
+            var ax1 = Math.cos(deg2rad(a1));
+            var ay1 = Math.sin(deg2rad(a1));
+            var x0, y0, x1, y1;
+            if (a0 <= 90 && a1 >= 90 || a0 > 90 && a1 >= 450) {
+              y1 = 1;
+            } else if (ay0 <= 0 && ay1 <= 0) {
+              y1 = 0;
+            } else {
+              y1 = Math.max(ay0, ay1);
+            }
+            if (a0 <= 180 && a1 >= 180 || a0 > 180 && a1 >= 540) {
+              x0 = -1;
+            } else if (ax0 >= 0 && ax1 >= 0) {
+              x0 = 0;
+            } else {
+              x0 = Math.min(ax0, ax1);
+            }
+            if (a0 <= 270 && a1 >= 270 || a0 > 270 && a1 >= 630) {
+              y0 = -1;
+            } else if (ay0 >= 0 && ay1 >= 0) {
+              y0 = 0;
+            } else {
+              y0 = Math.min(ay0, ay1);
+            }
+            if (a1 >= 360) {
+              x1 = 1;
+            } else if (ax0 <= 0 && ax1 <= 0) {
+              x1 = 0;
+            } else {
+              x1 = Math.max(ax0, ax1);
+            }
+            return [x0, y0, x1, y1];
+          }
+          function snapToVertexAngle(a2, vangles) {
+            var fn = function(v2) {
+              return Lib.angleDist(a2, v2);
+            };
+            var ind = Lib.findIndexOfMin(vangles, fn);
+            return vangles[ind];
+          }
+          function updateElement(sel, showAttr, attrs) {
+            if (showAttr) {
+              sel.attr("display", null);
+              sel.attr(attrs);
+            } else if (sel) {
+              sel.attr("display", "none");
+            }
+            return sel;
+          }
+        }
+      });
+      var require_layout_attributes21 = __commonJS({
+        "src/plots/polar/layout_attributes.js"(exports, module2) {
+          var colorAttrs = require_attributes3();
+          var axesAttrs = require_layout_attributes4();
+          var domainAttrs = require_domain().attributes;
+          var extendFlat = require_lib().extendFlat;
+          var overrideAll = require_edit_types().overrideAll;
+          var axisLineGridAttr = overrideAll({
+            color: axesAttrs.color,
+            showline: extendFlat({}, axesAttrs.showline, { dflt: true }),
+            linecolor: axesAttrs.linecolor,
+            linewidth: axesAttrs.linewidth,
+            showgrid: extendFlat({}, axesAttrs.showgrid, { dflt: true }),
+            gridcolor: axesAttrs.gridcolor,
+            gridwidth: axesAttrs.gridwidth,
+            griddash: axesAttrs.griddash
+            // TODO add spike* attributes down the road
+            // should we add zeroline* attributes?
+          }, "plot", "from-root");
+          var axisTickAttrs = overrideAll({
+            tickmode: axesAttrs.minor.tickmode,
+            nticks: axesAttrs.nticks,
+            tick0: axesAttrs.tick0,
+            dtick: axesAttrs.dtick,
+            tickvals: axesAttrs.tickvals,
+            ticktext: axesAttrs.ticktext,
+            ticks: axesAttrs.ticks,
+            ticklen: axesAttrs.ticklen,
+            tickwidth: axesAttrs.tickwidth,
+            tickcolor: axesAttrs.tickcolor,
+            ticklabelstep: axesAttrs.ticklabelstep,
+            showticklabels: axesAttrs.showticklabels,
+            labelalias: axesAttrs.labelalias,
+            minorloglabels: axesAttrs.minorloglabels,
+            showtickprefix: axesAttrs.showtickprefix,
+            tickprefix: axesAttrs.tickprefix,
+            showticksuffix: axesAttrs.showticksuffix,
+            ticksuffix: axesAttrs.ticksuffix,
+            showexponent: axesAttrs.showexponent,
+            exponentformat: axesAttrs.exponentformat,
+            minexponent: axesAttrs.minexponent,
+            separatethousands: axesAttrs.separatethousands,
+            tickfont: axesAttrs.tickfont,
+            tickangle: axesAttrs.tickangle,
+            tickformat: axesAttrs.tickformat,
+            tickformatstops: axesAttrs.tickformatstops,
+            layer: axesAttrs.layer
+          }, "plot", "from-root");
+          var radialAxisAttrs = {
+            visible: extendFlat({}, axesAttrs.visible, { dflt: true }),
+            type: extendFlat({}, axesAttrs.type, {
+              values: ["-", "linear", "log", "date", "category"]
+            }),
+            autotypenumbers: axesAttrs.autotypenumbers,
+            autorangeoptions: {
+              minallowed: axesAttrs.autorangeoptions.minallowed,
+              maxallowed: axesAttrs.autorangeoptions.maxallowed,
+              clipmin: axesAttrs.autorangeoptions.clipmin,
+              clipmax: axesAttrs.autorangeoptions.clipmax,
+              include: axesAttrs.autorangeoptions.include,
+              editType: "plot"
+            },
+            autorange: extendFlat({}, axesAttrs.autorange, { editType: "plot" }),
+            rangemode: {
+              valType: "enumerated",
+              values: ["tozero", "nonnegative", "normal"],
+              dflt: "tozero",
+              editType: "calc"
+            },
+            minallowed: extendFlat({}, axesAttrs.minallowed, { editType: "plot" }),
+            maxallowed: extendFlat({}, axesAttrs.maxallowed, { editType: "plot" }),
+            range: extendFlat({}, axesAttrs.range, {
+              items: [
+                { valType: "any", editType: "plot", impliedEdits: { "^autorange": false } },
+                { valType: "any", editType: "plot", impliedEdits: { "^autorange": false } }
+              ],
+              editType: "plot"
+            }),
+            categoryorder: axesAttrs.categoryorder,
+            categoryarray: axesAttrs.categoryarray,
+            angle: {
+              valType: "angle",
+              editType: "plot"
+            },
+            autotickangles: axesAttrs.autotickangles,
+            side: {
+              valType: "enumerated",
+              // TODO add 'center' for `showline: false` radial axes
+              values: ["clockwise", "counterclockwise"],
+              dflt: "clockwise",
+              editType: "plot"
+            },
+            title: {
+              // radial title is not gui-editable at the moment,
+              // so it needs dflt: '', similar to carpet axes.
+              text: extendFlat({}, axesAttrs.title.text, { editType: "plot", dflt: "" }),
+              font: extendFlat({}, axesAttrs.title.font, { editType: "plot" }),
+              // TODO
+              // - might need a 'titleside' and even 'titledirection' down the road
+              // - what about standoff ??
+              editType: "plot"
+            },
+            hoverformat: axesAttrs.hoverformat,
+            uirevision: {
+              valType: "any",
+              editType: "none"
+            },
+            editType: "calc"
+          };
+          extendFlat(
+            radialAxisAttrs,
+            // N.B. radialaxis grid lines are circular,
+            // but radialaxis lines are straight from circle center to outer bound
+            axisLineGridAttr,
+            axisTickAttrs
+          );
+          var angularAxisAttrs = {
+            visible: extendFlat({}, axesAttrs.visible, { dflt: true }),
+            type: {
+              valType: "enumerated",
+              // 'linear' should maybe be called 'angle' or 'angular' here
+              // to make clear that axis here is periodic and more tightly match
+              // `thetaunit`?
+              //
+              // skip 'date' for first push
+              // no 'log' for now
+              values: ["-", "linear", "category"],
+              dflt: "-",
+              editType: "calc",
+              _noTemplating: true
+            },
+            autotypenumbers: axesAttrs.autotypenumbers,
+            categoryorder: axesAttrs.categoryorder,
+            categoryarray: axesAttrs.categoryarray,
+            thetaunit: {
+              valType: "enumerated",
+              values: ["radians", "degrees"],
+              dflt: "degrees",
+              editType: "calc"
+            },
+            period: {
+              valType: "number",
+              editType: "calc",
+              min: 0
+              // Examples for date axes:
+              //
+              // - period that equals the timeseries length
+              //  http://flowingdata.com/2017/01/24/one-dataset-visualized-25-ways/18-polar-coordinates/
+              // - and 1-year periods (focusing on seasonal change0
+              //  http://otexts.org/fpp2/seasonal-plots.html
+              //  https://blogs.scientificamerican.com/sa-visual/why-are-so-many-babies-born-around-8-00-a-m/
+              //  http://www.seasonaladjustment.com/2012/09/05/clock-plot-visualising-seasonality-using-r-and-ggplot2-part-3/
+              //  https://i.pinimg.com/736x/49/b9/72/49b972ccb3206a1a6d6f870dac543280.jpg
+              //  https://www.climate-lab-book.ac.uk/spirals/
+            },
+            direction: {
+              valType: "enumerated",
+              values: ["counterclockwise", "clockwise"],
+              dflt: "counterclockwise",
+              editType: "calc"
+            },
+            rotation: {
+              valType: "angle",
+              editType: "calc"
+            },
+            hoverformat: axesAttrs.hoverformat,
+            uirevision: {
+              valType: "any",
+              editType: "none"
+            },
+            editType: "calc"
+          };
+          extendFlat(
+            angularAxisAttrs,
+            // N.B. angular grid lines are straight lines from circle center to outer bound
+            // the angular line is circular bounding the polar plot area.
+            axisLineGridAttr,
+            // N.B. ticksuffix defaults to '°' for angular axes with `thetaunit: 'degrees'`
+            axisTickAttrs
+          );
+          module2.exports = {
+            // TODO for x/y/zoom system for paper-based zooming:
+            // x: {},
+            // y: {},
+            // zoom: {},
+            domain: domainAttrs({ name: "polar", editType: "plot" }),
+            sector: {
+              valType: "info_array",
+              items: [
+                { valType: "number", editType: "plot" },
+                { valType: "number", editType: "plot" }
+              ],
+              dflt: [0, 360],
+              editType: "plot"
+            },
+            hole: {
+              valType: "number",
+              min: 0,
+              max: 1,
+              dflt: 0,
+              editType: "plot"
+            },
+            bgcolor: {
+              valType: "color",
+              editType: "plot",
+              dflt: colorAttrs.background
+            },
+            radialaxis: radialAxisAttrs,
+            angularaxis: angularAxisAttrs,
+            gridshape: {
+              valType: "enumerated",
+              values: ["circular", "linear"],
+              dflt: "circular",
+              editType: "plot"
+            },
+            // TODO maybe?
+            // annotations:
+            uirevision: {
+              valType: "any",
+              editType: "none"
+            },
+            editType: "calc"
+          };
+        }
+      });
+      var require_layout_defaults19 = __commonJS({
+        "src/plots/polar/layout_defaults.js"(exports, module2) {
+          var Lib = require_lib();
+          var Color2 = require_color();
+          var Template = require_plot_template();
+          var handleSubplotDefaults = require_subplot_defaults();
+          var getSubplotData = require_get_data().getSubplotData;
+          var handleTickValueDefaults = require_tick_value_defaults();
+          var handleTickMarkDefaults = require_tick_mark_defaults();
+          var handleTickLabelDefaults = require_tick_label_defaults();
+          var handlePrefixSuffixDefaults = require_prefix_suffix_defaults();
+          var handleCategoryOrderDefaults = require_category_order_defaults();
+          var handleLineGridDefaults = require_line_grid_defaults();
+          var handleAutorangeOptionsDefaults = require_autorange_options_defaults();
+          var autoType = require_axis_autotype();
+          var layoutAttributes = require_layout_attributes21();
+          var setConvert = require_set_convert3();
+          var constants = require_constants33();
+          var axisNames = constants.axisNames;
+          function handleDefaults(contIn, contOut, coerce, opts) {
+            var bgColor = coerce("bgcolor");
+            opts.bgColor = Color2.combine(bgColor, opts.paper_bgcolor);
+            var sector = coerce("sector");
+            coerce("hole");
+            var subplotData = getSubplotData(opts.fullData, constants.name, opts.id);
+            var layoutOut = opts.layoutOut;
+            var axName;
+            function coerceAxis(attr, dflt) {
+              return coerce(axName + "." + attr, dflt);
+            }
+            for (var i2 = 0; i2 < axisNames.length; i2++) {
+              axName = axisNames[i2];
+              if (!Lib.isPlainObject(contIn[axName])) {
+                contIn[axName] = {};
+              }
+              var axIn = contIn[axName];
+              var axOut = Template.newContainer(contOut, axName);
+              axOut._id = axOut._name = axName;
+              axOut._attr = opts.id + "." + axName;
+              axOut._traceIndices = subplotData.map(function(t4) {
+                return t4.index;
+              });
+              var dataAttr = constants.axisName2dataArray[axName];
+              var axType = handleAxisTypeDefaults(axIn, axOut, coerceAxis, subplotData, dataAttr, opts);
+              handleCategoryOrderDefaults(axIn, axOut, coerceAxis, {
+                axData: subplotData,
+                dataAttr
+              });
+              var visible = coerceAxis("visible");
+              setConvert(axOut, contOut, layoutOut);
+              coerceAxis("uirevision", contOut.uirevision);
+              axOut._m = 1;
+              switch (axName) {
+                case "radialaxis":
+                  coerceAxis("minallowed");
+                  coerceAxis("maxallowed");
+                  var range = coerceAxis("range");
+                  var autorangeDflt = axOut.getAutorangeDflt(range);
+                  var autorange = coerceAxis("autorange", autorangeDflt);
+                  var shouldAutorange;
+                  if (range && (range[0] === null && range[1] === null || (range[0] === null || range[1] === null) && (autorange === "reversed" || autorange === true) || range[0] !== null && (autorange === "min" || autorange === "max reversed") || range[1] !== null && (autorange === "max" || autorange === "min reversed"))) {
+                    range = void 0;
+                    delete axOut.range;
+                    axOut.autorange = true;
+                    shouldAutorange = true;
+                  }
+                  if (!shouldAutorange) {
+                    autorangeDflt = axOut.getAutorangeDflt(range);
+                    autorange = coerceAxis("autorange", autorangeDflt);
+                  }
+                  axIn.autorange = autorange;
+                  if (autorange) {
+                    handleAutorangeOptionsDefaults(coerceAxis, autorange, range);
+                    if (axType === "linear" || axType === "-") coerceAxis("rangemode");
+                    if (axOut.isReversed()) axOut._m = -1;
+                  }
+                  axOut.cleanRange("range", { dfltRange: [0, 1] });
+                  break;
+                case "angularaxis":
+                  if (axType === "date") {
+                    Lib.log("Polar plots do not support date angular axes yet.");
+                    for (var j2 = 0; j2 < subplotData.length; j2++) {
+                      subplotData[j2].visible = false;
+                    }
+                    axType = axIn.type = axOut.type = "linear";
+                  }
+                  if (axType === "linear") {
+                    coerceAxis("thetaunit");
+                  } else {
+                    coerceAxis("period");
+                  }
+                  var direction = coerceAxis("direction");
+                  coerceAxis("rotation", { counterclockwise: 0, clockwise: 90 }[direction]);
+                  break;
+              }
+              handlePrefixSuffixDefaults(axIn, axOut, coerceAxis, axOut.type, {
+                tickSuffixDflt: axOut.thetaunit === "degrees" ? "°" : void 0
+              });
+              if (visible) {
+                var dfltColor;
+                var dfltFontColor;
+                var dfltFontSize;
+                var dfltFontFamily;
+                var dfltFontWeight;
+                var dfltFontStyle;
+                var dfltFontVariant;
+                var dfltFontTextcase;
+                var dfltFontLineposition;
+                var dfltFontShadow;
+                var font = opts.font || {};
+                dfltColor = coerceAxis("color");
+                dfltFontColor = dfltColor === axIn.color ? dfltColor : font.color;
+                dfltFontSize = font.size;
+                dfltFontFamily = font.family;
+                dfltFontWeight = font.weight;
+                dfltFontStyle = font.style;
+                dfltFontVariant = font.variant;
+                dfltFontTextcase = font.textcase;
+                dfltFontLineposition = font.lineposition;
+                dfltFontShadow = font.shadow;
+                handleTickValueDefaults(axIn, axOut, coerceAxis, axOut.type);
+                handleTickLabelDefaults(axIn, axOut, coerceAxis, axOut.type, {
+                  font: {
+                    weight: dfltFontWeight,
+                    style: dfltFontStyle,
+                    variant: dfltFontVariant,
+                    textcase: dfltFontTextcase,
+                    lineposition: dfltFontLineposition,
+                    shadow: dfltFontShadow,
+                    color: dfltFontColor,
+                    size: dfltFontSize,
+                    family: dfltFontFamily
+                  },
+                  noAutotickangles: axName === "angularaxis",
+                  noTicklabelshift: true,
+                  noTicklabelstandoff: true
+                });
+                handleTickMarkDefaults(axIn, axOut, coerceAxis, { outerTicks: true });
+                handleLineGridDefaults(axIn, axOut, coerceAxis, {
+                  dfltColor,
+                  bgColor: opts.bgColor,
+                  // default grid color is darker here (60%, vs cartesian default ~91%)
+                  // because the grid is not square so the eye needs heavier cues to follow
+                  blend: 60,
+                  showLine: true,
+                  showGrid: true,
+                  noZeroLine: true,
+                  attributes: layoutAttributes[axName]
+                });
+                coerceAxis("layer");
+                if (axName === "radialaxis") {
+                  coerceAxis("side");
+                  coerceAxis("angle", sector[0]);
+                  coerceAxis("title.text");
+                  Lib.coerceFont(coerceAxis, "title.font", {
+                    weight: dfltFontWeight,
+                    style: dfltFontStyle,
+                    variant: dfltFontVariant,
+                    textcase: dfltFontTextcase,
+                    lineposition: dfltFontLineposition,
+                    shadow: dfltFontShadow,
+                    color: dfltFontColor,
+                    size: Lib.bigFont(dfltFontSize),
+                    family: dfltFontFamily
+                  });
+                }
+              }
+              if (axType !== "category") coerceAxis("hoverformat");
+              axOut._input = axIn;
+            }
+            if (contOut.angularaxis.type === "category") {
+              coerce("gridshape");
+            }
+          }
+          function handleAxisTypeDefaults(axIn, axOut, coerce, subplotData, dataAttr, options) {
+            var autotypenumbers = coerce("autotypenumbers", options.autotypenumbersDflt);
+            var axType = coerce("type");
+            if (axType === "-") {
+              var trace;
+              for (var i2 = 0; i2 < subplotData.length; i2++) {
+                if (subplotData[i2].visible) {
+                  trace = subplotData[i2];
+                  break;
+                }
+              }
+              if (trace && trace[dataAttr]) {
+                axOut.type = autoType(trace[dataAttr], "gregorian", {
+                  noMultiCategory: true,
+                  autotypenumbers
+                });
+              }
+              if (axOut.type === "-") {
+                axOut.type = "linear";
+              } else {
+                axIn.type = axOut.type;
+              }
+            }
+            return axOut.type;
+          }
+          module2.exports = function supplyLayoutDefaults(layoutIn, layoutOut, fullData) {
+            handleSubplotDefaults(layoutIn, layoutOut, fullData, {
+              type: constants.name,
+              attributes: layoutAttributes,
+              handleDefaults,
+              font: layoutOut.font,
+              autotypenumbersDflt: layoutOut.autotypenumbers,
+              paper_bgcolor: layoutOut.paper_bgcolor,
+              fullData,
+              layoutOut
+            });
+          };
+        }
+      });
+      var require_polar2 = __commonJS({
+        "src/plots/polar/index.js"(exports, module2) {
+          var getSubplotCalcData = require_get_data().getSubplotCalcData;
+          var counterRegex = require_lib().counterRegex;
+          var createPolar = require_polar();
+          var constants = require_constants33();
+          var attr = constants.attr;
+          var name2 = constants.name;
+          var counter2 = counterRegex(name2);
+          var attributes = {};
+          attributes[attr] = {
+            valType: "subplotid",
+            dflt: name2,
+            editType: "calc"
+          };
+          function plot(gd2) {
+            var fullLayout = gd2._fullLayout;
+            var calcData = gd2.calcdata;
+            var subplotIds = fullLayout._subplots[name2];
+            for (var i2 = 0; i2 < subplotIds.length; i2++) {
+              var id2 = subplotIds[i2];
+              var subplotCalcData = getSubplotCalcData(calcData, name2, id2);
+              var subplot = fullLayout[id2]._subplot;
+              if (!subplot) {
+                subplot = createPolar(gd2, id2);
+                fullLayout[id2]._subplot = subplot;
+              }
+              subplot.plot(subplotCalcData, fullLayout, gd2._promises);
+            }
+          }
+          function clean(newFullData, newFullLayout, oldFullData, oldFullLayout) {
+            var oldIds = oldFullLayout._subplots[name2] || [];
+            var hadGl = oldFullLayout._has && oldFullLayout._has("gl");
+            var hasGl = newFullLayout._has && newFullLayout._has("gl");
+            var mustCleanScene = hadGl && !hasGl;
+            for (var i2 = 0; i2 < oldIds.length; i2++) {
+              var id2 = oldIds[i2];
+              var oldSubplot = oldFullLayout[id2]._subplot;
+              if (!newFullLayout[id2] && !!oldSubplot) {
+                oldSubplot.framework.remove();
+                oldSubplot.layers["radial-axis-title"].remove();
+                for (var k2 in oldSubplot.clipPaths) {
+                  oldSubplot.clipPaths[k2].remove();
+                }
+              }
+              if (mustCleanScene && oldSubplot._scene) {
+                oldSubplot._scene.destroy();
+                oldSubplot._scene = null;
+              }
+            }
+          }
+          module2.exports = {
+            attr,
+            name: name2,
+            idRoot: name2,
+            idRegex: counter2,
+            attrRegex: counter2,
+            attributes,
+            layoutAttributes: require_layout_attributes21(),
+            supplyLayoutDefaults: require_layout_defaults19(),
+            plot,
+            clean,
+            toSVG: require_cartesian().toSVG
+          };
+        }
+      });
+      var require_attributes68 = __commonJS({
+        "src/traces/scatterpolar/attributes.js"(exports, module2) {
+          var { hovertemplateAttrs, texttemplateAttrs, templatefallbackAttrs } = require_template_attributes();
+          var extendFlat = require_extend().extendFlat;
+          var makeFillcolorAttr = require_fillcolor_attribute();
+          var scatterAttrs = require_attributes12();
+          var baseAttrs = require_attributes2();
+          var lineAttrs = scatterAttrs.line;
+          module2.exports = {
+            mode: scatterAttrs.mode,
+            r: {
+              valType: "data_array",
+              editType: "calc+clearAxisTypes"
+            },
+            theta: {
+              valType: "data_array",
+              editType: "calc+clearAxisTypes"
+            },
+            r0: {
+              valType: "any",
+              dflt: 0,
+              editType: "calc+clearAxisTypes"
+            },
+            dr: {
+              valType: "number",
+              dflt: 1,
+              editType: "calc"
+            },
+            theta0: {
+              valType: "any",
+              dflt: 0,
+              editType: "calc+clearAxisTypes"
+            },
+            dtheta: {
+              valType: "number",
+              editType: "calc"
+            },
+            thetaunit: {
+              valType: "enumerated",
+              values: ["radians", "degrees", "gradians"],
+              dflt: "degrees",
+              editType: "calc+clearAxisTypes"
+            },
+            text: scatterAttrs.text,
+            texttemplate: texttemplateAttrs({ editType: "plot" }, { keys: ["r", "theta", "text"] }),
+            texttemplatefallback: templatefallbackAttrs({ editType: "plot" }),
+            hovertext: scatterAttrs.hovertext,
+            line: {
+              color: lineAttrs.color,
+              width: lineAttrs.width,
+              dash: lineAttrs.dash,
+              backoff: lineAttrs.backoff,
+              shape: extendFlat({}, lineAttrs.shape, {
+                values: ["linear", "spline"]
+              }),
+              smoothing: lineAttrs.smoothing,
+              editType: "calc"
+            },
+            connectgaps: scatterAttrs.connectgaps,
+            marker: scatterAttrs.marker,
+            cliponaxis: extendFlat({}, scatterAttrs.cliponaxis, { dflt: false }),
+            textposition: scatterAttrs.textposition,
+            textfont: scatterAttrs.textfont,
+            fill: extendFlat({}, scatterAttrs.fill, {
+              values: ["none", "toself", "tonext"],
+              dflt: "none"
+            }),
+            fillcolor: makeFillcolorAttr(),
+            // TODO error bars
+            // https://stackoverflow.com/a/26597487/4068492
+            // error_x (error_r, error_theta)
+            // error_y
+            hoverinfo: extendFlat({}, baseAttrs.hoverinfo, {
+              flags: ["r", "theta", "text", "name"]
+            }),
+            hoveron: scatterAttrs.hoveron,
+            hovertemplate: hovertemplateAttrs(),
+            hovertemplatefallback: templatefallbackAttrs(),
+            selected: scatterAttrs.selected,
+            unselected: scatterAttrs.unselected
+          };
+        }
+      });
+      var require_defaults64 = __commonJS({
+        "src/traces/scatterpolar/defaults.js"(exports, module2) {
+          var Lib = require_lib();
+          var subTypes = require_subtypes();
+          var handleMarkerDefaults = require_marker_defaults();
+          var handleLineDefaults = require_line_defaults();
+          var handleLineShapeDefaults = require_line_shape_defaults();
+          var handleTextDefaults = require_text_defaults();
+          var handleFillColorDefaults = require_fillcolor_defaults();
+          var PTS_LINESONLY = require_constants8().PTS_LINESONLY;
+          var attributes = require_attributes68();
+          function supplyDefaults(traceIn, traceOut, defaultColor, layout) {
+            function coerce(attr, dflt) {
+              return Lib.coerce(traceIn, traceOut, attributes, attr, dflt);
+            }
+            var len2 = handleRThetaDefaults(traceIn, traceOut, layout, coerce);
+            if (!len2) {
+              traceOut.visible = false;
+              return;
+            }
+            coerce("thetaunit");
+            coerce("mode", len2 < PTS_LINESONLY ? "lines+markers" : "lines");
+            coerce("text");
+            coerce("hovertext");
+            if (traceOut.hoveron !== "fills") {
+              coerce("hovertemplate");
+              coerce("hovertemplatefallback");
+            }
+            if (subTypes.hasMarkers(traceOut)) {
+              handleMarkerDefaults(traceIn, traceOut, defaultColor, layout, coerce, { gradient: true });
+            }
+            if (subTypes.hasLines(traceOut)) {
+              handleLineDefaults(traceIn, traceOut, defaultColor, layout, coerce, { backoff: true });
+              handleLineShapeDefaults(traceIn, traceOut, coerce);
+              coerce("connectgaps");
+            }
+            if (subTypes.hasText(traceOut)) {
+              coerce("texttemplate");
+              coerce("texttemplatefallback");
+              handleTextDefaults(traceIn, traceOut, layout, coerce);
+            }
+            var dfltHoverOn = [];
+            if (subTypes.hasMarkers(traceOut) || subTypes.hasText(traceOut)) {
+              coerce("cliponaxis");
+              coerce("marker.maxdisplayed");
+              dfltHoverOn.push("points");
+            }
+            coerce("fill");
+            if (traceOut.fill !== "none") {
+              handleFillColorDefaults(traceIn, traceOut, defaultColor, coerce);
+              if (!subTypes.hasLines(traceOut)) handleLineShapeDefaults(traceIn, traceOut, coerce);
+            }
+            if (traceOut.fill === "tonext" || traceOut.fill === "toself") {
+              dfltHoverOn.push("fills");
+            }
+            coerce("hoveron", dfltHoverOn.join("+") || "points");
+            Lib.coerceSelectionMarkerOpacity(traceOut, coerce);
+          }
+          function handleRThetaDefaults(traceIn, traceOut, layout, coerce) {
+            var r2 = coerce("r");
+            var theta = coerce("theta");
+            if (Lib.isTypedArray(r2)) {
+              traceOut.r = r2 = Array.from(r2);
+            }
+            if (Lib.isTypedArray(theta)) {
+              traceOut.theta = theta = Array.from(theta);
+            }
+            var len2;
+            if (r2) {
+              if (theta) {
+                len2 = Math.min(r2.length, theta.length);
+              } else {
+                len2 = r2.length;
+                coerce("theta0");
+                coerce("dtheta");
+              }
+            } else {
+              if (!theta) return 0;
+              len2 = traceOut.theta.length;
+              coerce("r0");
+              coerce("dr");
+            }
+            traceOut._length = len2;
+            return len2;
+          }
+          module2.exports = {
+            handleRThetaDefaults,
+            supplyDefaults
+          };
+        }
+      });
+      var require_format_labels8 = __commonJS({
+        "src/traces/scatterpolar/format_labels.js"(exports, module2) {
+          var Lib = require_lib();
+          var Axes = require_axes();
+          module2.exports = function formatLabels(cdi, trace, fullLayout) {
+            var labels = {};
+            var subplot = fullLayout[trace.subplot]._subplot;
+            var radialAxis;
+            var angularAxis;
+            if (!subplot) {
+              subplot = fullLayout[trace.subplot];
+              radialAxis = subplot.radialaxis;
+              angularAxis = subplot.angularaxis;
+            } else {
+              radialAxis = subplot.radialAxis;
+              angularAxis = subplot.angularAxis;
+            }
+            var rVal = radialAxis.c2l(cdi.r);
+            labels.rLabel = Axes.tickText(radialAxis, rVal, true).text;
+            var thetaVal = angularAxis.thetaunit === "degrees" ? Lib.rad2deg(cdi.theta) : cdi.theta;
+            labels.thetaLabel = Axes.tickText(angularAxis, thetaVal, true).text;
+            return labels;
+          };
+        }
+      });
+      var require_calc43 = __commonJS({
+        "src/traces/scatterpolar/calc.js"(exports, module2) {
+          var isNumeric = require_fast_isnumeric();
+          var BADNUM = require_numerical().BADNUM;
+          var Axes = require_axes();
+          var calcColorscale = require_colorscale_calc();
+          var arraysToCalcdata = require_arrays_to_calcdata();
+          var calcSelection = require_calc_selection();
+          var calcMarkerSize = require_calc3().calcMarkerSize;
+          module2.exports = function calc(gd2, trace) {
+            var fullLayout = gd2._fullLayout;
+            var subplotId = trace.subplot;
+            var radialAxis = fullLayout[subplotId].radialaxis;
+            var angularAxis = fullLayout[subplotId].angularaxis;
+            var rArray = radialAxis.makeCalcdata(trace, "r");
+            var thetaArray = angularAxis.makeCalcdata(trace, "theta");
+            var len2 = trace._length;
+            var cd2 = new Array(len2);
+            for (var i2 = 0; i2 < len2; i2++) {
+              var r2 = rArray[i2];
+              var theta = thetaArray[i2];
+              var cdi = cd2[i2] = {};
+              if (isNumeric(r2) && isNumeric(theta)) {
+                cdi.r = r2;
+                cdi.theta = theta;
+              } else {
+                cdi.r = BADNUM;
+              }
+            }
+            var ppad = calcMarkerSize(trace, len2);
+            trace._extremes.x = Axes.findExtremes(radialAxis, rArray, { ppad });
+            calcColorscale(gd2, trace);
+            arraysToCalcdata(cd2, trace);
+            calcSelection(cd2, trace);
+            return cd2;
+          };
+        }
+      });
+      var require_plot36 = __commonJS({
+        "src/traces/scatterpolar/plot.js"(exports, module2) {
+          var scatterPlot = require_plot();
+          var BADNUM = require_numerical().BADNUM;
+          module2.exports = function plot(gd2, subplot, moduleCalcData) {
+            var mlayer = subplot.layers.frontplot.select("g.scatterlayer");
+            var xa = subplot.xaxis;
+            var ya2 = subplot.yaxis;
+            var plotinfo = {
+              xaxis: xa,
+              yaxis: ya2,
+              plot: subplot.framework,
+              layerClipId: subplot._hasClipOnAxisFalse ? subplot.clipIds.forTraces : null
+            };
+            var radialAxis = subplot.radialAxis;
+            var angularAxis = subplot.angularAxis;
+            for (var i2 = 0; i2 < moduleCalcData.length; i2++) {
+              var cdi = moduleCalcData[i2];
+              for (var j2 = 0; j2 < cdi.length; j2++) {
+                if (j2 === 0) {
+                  cdi[0].trace._xA = xa;
+                  cdi[0].trace._yA = ya2;
+                }
+                var cd2 = cdi[j2];
+                var r2 = cd2.r;
+                if (r2 === BADNUM) {
+                  cd2.x = cd2.y = BADNUM;
+                } else {
+                  var rg2 = radialAxis.c2g(r2);
+                  var thetag = angularAxis.c2g(cd2.theta);
+                  cd2.x = rg2 * Math.cos(thetag);
+                  cd2.y = rg2 * Math.sin(thetag);
+                }
+              }
+            }
+            scatterPlot(gd2, plotinfo, moduleCalcData, mlayer);
+          };
+        }
+      });
+      var require_hover24 = __commonJS({
+        "src/traces/scatterpolar/hover.js"(exports, module2) {
+          var scatterHover = require_hover2();
+          function hoverPoints(pointData, xval, yval, hovermode) {
+            var scatterPointData = scatterHover(pointData, xval, yval, hovermode);
+            if (!scatterPointData || scatterPointData[0].index === false) return;
+            var newPointData = scatterPointData[0];
+            if (newPointData.index === void 0) {
+              return scatterPointData;
+            }
+            var subplot = pointData.subplot;
+            var cdi = newPointData.cd[newPointData.index];
+            var trace = newPointData.trace;
+            if (!subplot.isPtInside(cdi)) return;
+            newPointData.xLabelVal = void 0;
+            newPointData.yLabelVal = void 0;
+            makeHoverPointText(cdi, trace, subplot, newPointData);
+            newPointData.hovertemplate = trace.hovertemplate;
+            return scatterPointData;
+          }
+          function makeHoverPointText(cdi, trace, subplot, pointData) {
+            var radialAxis = subplot.radialAxis;
+            var angularAxis = subplot.angularAxis;
+            radialAxis._hovertitle = "r";
+            angularAxis._hovertitle = "θ";
+            var fullLayout = {};
+            fullLayout[trace.subplot] = { _subplot: subplot };
+            var labels = trace._module.formatLabels(cdi, trace, fullLayout);
+            pointData.rLabel = labels.rLabel;
+            pointData.thetaLabel = labels.thetaLabel;
+            var hoverinfo = cdi.hi || trace.hoverinfo;
+            var text = [];
+            function textPart(ax, val) {
+              text.push(ax._hovertitle + ": " + val);
+            }
+            if (!trace.hovertemplate) {
+              var parts = hoverinfo.split("+");
+              if (parts.indexOf("all") !== -1) parts = ["r", "theta", "text"];
+              if (parts.indexOf("r") !== -1) textPart(radialAxis, pointData.rLabel);
+              if (parts.indexOf("theta") !== -1) textPart(angularAxis, pointData.thetaLabel);
+              if (parts.indexOf("text") !== -1 && pointData.text) {
+                text.push(pointData.text);
+                delete pointData.text;
+              }
+              pointData.extraText = text.join("<br>");
+            }
+          }
+          module2.exports = {
+            hoverPoints,
+            makeHoverPointText
+          };
+        }
+      });
+      var require_scatterpolar = __commonJS({
+        "src/traces/scatterpolar/index.js"(exports, module2) {
+          module2.exports = {
+            moduleType: "trace",
+            name: "scatterpolar",
+            basePlotModule: require_polar2(),
+            categories: ["polar", "symbols", "showLegend", "scatter-like"],
+            attributes: require_attributes68(),
+            supplyDefaults: require_defaults64().supplyDefaults,
+            colorbar: require_marker_colorbar(),
+            formatLabels: require_format_labels8(),
+            calc: require_calc43(),
+            plot: require_plot36(),
+            style: require_style2().style,
+            styleOnSelect: require_style2().styleOnSelect,
+            hoverPoints: require_hover24().hoverPoints,
+            selectPoints: require_select2(),
+            meta: {}
+          };
+        }
+      });
+      var require_scatterpolar2 = __commonJS({
+        "lib/scatterpolar.js"(exports, module2) {
+          module2.exports = require_scatterpolar();
+        }
+      });
+      var require_attributes69 = __commonJS({
+        "src/traces/scatterpolargl/attributes.js"(exports, module2) {
+          var _a3 = require_attributes68(), { cliponaxis, hoveron } = _a3, scatterPolarAttrs = __objRest(_a3, ["cliponaxis", "hoveron"]);
+          var {
+            connectgaps,
+            line: { color: color22, dash, width },
+            fill,
+            fillcolor,
+            marker,
+            textfont,
+            textposition
+          } = require_attributes50();
+          module2.exports = __spreadProps(__spreadValues({}, scatterPolarAttrs), {
+            connectgaps,
+            fill,
+            fillcolor,
+            line: { color: color22, dash, editType: "calc", width },
+            marker,
+            textfont,
+            textposition
+          });
+        }
+      });
+      var require_defaults65 = __commonJS({
+        "src/traces/scatterpolargl/defaults.js"(exports, module2) {
+          var Lib = require_lib();
+          var subTypes = require_subtypes();
+          var handleRThetaDefaults = require_defaults64().handleRThetaDefaults;
+          var handleMarkerDefaults = require_marker_defaults();
+          var handleLineDefaults = require_line_defaults();
+          var handleTextDefaults = require_text_defaults();
+          var handleFillColorDefaults = require_fillcolor_defaults();
+          var PTS_LINESONLY = require_constants8().PTS_LINESONLY;
+          var attributes = require_attributes69();
+          module2.exports = function supplyDefaults(traceIn, traceOut, defaultColor, layout) {
+            function coerce(attr, dflt) {
+              return Lib.coerce(traceIn, traceOut, attributes, attr, dflt);
+            }
+            var len2 = handleRThetaDefaults(traceIn, traceOut, layout, coerce);
+            if (!len2) {
+              traceOut.visible = false;
+              return;
+            }
+            coerce("thetaunit");
+            coerce("mode", len2 < PTS_LINESONLY ? "lines+markers" : "lines");
+            coerce("text");
+            coerce("hovertext");
+            if (traceOut.hoveron !== "fills") {
+              coerce("hovertemplate");
+              coerce("hovertemplatefallback");
+            }
+            if (subTypes.hasMarkers(traceOut)) {
+              handleMarkerDefaults(traceIn, traceOut, defaultColor, layout, coerce, {
+                noAngleRef: true,
+                noLineDash: true,
+                noStandOff: true
+              });
+            }
+            if (subTypes.hasLines(traceOut)) {
+              handleLineDefaults(traceIn, traceOut, defaultColor, layout, coerce);
+              coerce("connectgaps");
+            }
+            if (subTypes.hasText(traceOut)) {
+              coerce("texttemplate");
+              coerce("texttemplatefallback");
+              handleTextDefaults(traceIn, traceOut, layout, coerce, {
+                noFontShadow: true,
+                noFontLineposition: true,
+                noFontTextcase: true
+              });
+            }
+            coerce("fill");
+            if (traceOut.fill !== "none") {
+              handleFillColorDefaults(traceIn, traceOut, defaultColor, coerce);
+            }
+            Lib.coerceSelectionMarkerOpacity(traceOut, coerce);
+          };
+        }
+      });
+      var require_format_labels9 = __commonJS({
+        "src/traces/scatterpolargl/format_labels.js"(exports, module2) {
+          var scatterPolarFormatLabels = require_format_labels8();
+          module2.exports = function formatLabels(cdi, trace, fullLayout) {
+            var i2 = cdi.i;
+            if (!("r" in cdi)) cdi.r = trace._r[i2];
+            if (!("theta" in cdi)) cdi.theta = trace._theta[i2];
+            return scatterPolarFormatLabels(cdi, trace, fullLayout);
+          };
+        }
+      });
+      var require_calc44 = __commonJS({
+        "src/traces/scatterpolargl/calc.js"(exports, module2) {
+          var calcColorscale = require_colorscale_calc();
+          var calcMarkerSize = require_calc3().calcMarkerSize;
+          var convert = require_convert10();
+          var Axes = require_axes();
+          var TOO_MANY_POINTS = require_constants23().TOO_MANY_POINTS;
+          module2.exports = function calc(gd2, trace) {
+            var fullLayout = gd2._fullLayout;
+            var subplotId = trace.subplot;
+            var radialAxis = fullLayout[subplotId].radialaxis;
+            var angularAxis = fullLayout[subplotId].angularaxis;
+            var rArray = trace._r = radialAxis.makeCalcdata(trace, "r");
+            var thetaArray = trace._theta = angularAxis.makeCalcdata(trace, "theta");
+            var len2 = trace._length;
+            var stash = {};
+            if (len2 < rArray.length) rArray = rArray.slice(0, len2);
+            if (len2 < thetaArray.length) thetaArray = thetaArray.slice(0, len2);
+            stash.r = rArray;
+            stash.theta = thetaArray;
+            calcColorscale(gd2, trace);
+            var opts = stash.opts = convert.style(gd2, trace);
+            var ppad;
+            if (len2 < TOO_MANY_POINTS) {
+              ppad = calcMarkerSize(trace, len2);
+            } else if (opts.marker) {
+              ppad = 2 * (opts.marker.sizeAvg || Math.max(opts.marker.size, 3));
+            }
+            trace._extremes.x = Axes.findExtremes(radialAxis, rArray, { ppad });
+            return [{ x: false, y: false, t: stash, trace }];
+          };
+        }
+      });
+      var require_hover25 = __commonJS({
+        "src/traces/scatterpolargl/hover.js"(exports, module2) {
+          var hover = require_hover16();
+          var makeHoverPointText = require_hover24().makeHoverPointText;
+          function hoverPoints(pointData, xval, yval, hovermode) {
+            var cd2 = pointData.cd;
+            var stash = cd2[0].t;
+            var rArray = stash.r;
+            var thetaArray = stash.theta;
+            var scatterPointData = hover.hoverPoints(pointData, xval, yval, hovermode);
+            if (!scatterPointData || scatterPointData[0].index === false) return;
+            var newPointData = scatterPointData[0];
+            if (newPointData.index === void 0) {
+              return scatterPointData;
+            }
+            var subplot = pointData.subplot;
+            var cdi = newPointData.cd[newPointData.index];
+            var trace = newPointData.trace;
+            cdi.r = rArray[newPointData.index];
+            cdi.theta = thetaArray[newPointData.index];
+            if (!subplot.isPtInside(cdi)) return;
+            newPointData.xLabelVal = void 0;
+            newPointData.yLabelVal = void 0;
+            makeHoverPointText(cdi, trace, subplot, newPointData);
+            return scatterPointData;
+          }
+          module2.exports = {
+            hoverPoints
+          };
+        }
+      });
+      var require_base_index4 = __commonJS({
+        "src/traces/scatterpolargl/base_index.js"(exports, module2) {
+          module2.exports = {
+            moduleType: "trace",
+            name: "scatterpolargl",
+            basePlotModule: require_polar2(),
+            categories: ["gl", "regl", "polar", "symbols", "showLegend", "scatter-like"],
+            attributes: require_attributes69(),
+            supplyDefaults: require_defaults65(),
+            colorbar: require_marker_colorbar(),
+            formatLabels: require_format_labels9(),
+            calc: require_calc44(),
+            hoverPoints: require_hover25().hoverPoints,
+            selectPoints: require_select7(),
+            meta: {}
+          };
+        }
+      });
+      var require_plot37 = __commonJS({
+        "src/traces/scatterpolargl/plot.js"(exports, module2) {
+          var cluster = require_point_cluster();
+          var isNumeric = require_fast_isnumeric();
+          var scatterglPlot = require_plot19();
+          var sceneUpdate = require_scene_update();
+          var convert = require_convert10();
+          var Lib = require_lib();
+          var TOO_MANY_POINTS = require_constants23().TOO_MANY_POINTS;
+          var reglPrecompiled = {};
+          module2.exports = function plot(gd2, subplot, cdata) {
+            if (!cdata.length) return;
+            var radialAxis = subplot.radialAxis;
+            var angularAxis = subplot.angularAxis;
+            var scene = sceneUpdate(gd2, subplot);
+            cdata.forEach(function(cdscatter) {
+              if (!cdscatter || !cdscatter[0] || !cdscatter[0].trace) return;
+              var cd2 = cdscatter[0];
+              var trace = cd2.trace;
+              var stash = cd2.t;
+              var len2 = trace._length;
+              var rArray = stash.r;
+              var thetaArray = stash.theta;
+              var opts = stash.opts;
+              var i2;
+              var subRArray = rArray.slice();
+              var subThetaArray = thetaArray.slice();
+              for (i2 = 0; i2 < rArray.length; i2++) {
+                if (!subplot.isPtInside({ r: rArray[i2], theta: thetaArray[i2] })) {
+                  subRArray[i2] = NaN;
+                  subThetaArray[i2] = NaN;
+                }
+              }
+              var positions = new Array(len2 * 2);
+              var x2 = Array(len2);
+              var y2 = Array(len2);
+              for (i2 = 0; i2 < len2; i2++) {
+                var r2 = subRArray[i2];
+                var xx, yy;
+                if (isNumeric(r2)) {
+                  var rg2 = radialAxis.c2g(r2);
+                  var thetag = angularAxis.c2g(subThetaArray[i2], trace.thetaunit);
+                  xx = rg2 * Math.cos(thetag);
+                  yy = rg2 * Math.sin(thetag);
+                } else {
+                  xx = yy = NaN;
+                }
+                x2[i2] = positions[i2 * 2] = xx;
+                y2[i2] = positions[i2 * 2 + 1] = yy;
+              }
+              stash.tree = cluster(positions);
+              if (opts.marker && len2 >= TOO_MANY_POINTS) {
+                opts.marker.cluster = stash.tree;
+              }
+              if (opts.marker) {
+                opts.markerSel.positions = opts.markerUnsel.positions = opts.marker.positions = positions;
+              }
+              if (opts.line && positions.length > 1) {
+                Lib.extendFlat(
+                  opts.line,
+                  convert.linePositions(gd2, trace, positions)
+                );
+              }
+              if (opts.text) {
+                Lib.extendFlat(
+                  opts.text,
+                  { positions },
+                  convert.textPosition(gd2, trace, opts.text, opts.marker)
+                );
+                Lib.extendFlat(
+                  opts.textSel,
+                  { positions },
+                  convert.textPosition(gd2, trace, opts.text, opts.markerSel)
+                );
+                Lib.extendFlat(
+                  opts.textUnsel,
+                  { positions },
+                  convert.textPosition(gd2, trace, opts.text, opts.markerUnsel)
+                );
+              }
+              if (opts.fill && !scene.fill2d) scene.fill2d = true;
+              if (opts.marker && !scene.scatter2d) scene.scatter2d = true;
+              if (opts.line && !scene.line2d) scene.line2d = true;
+              if (opts.text && !scene.glText) scene.glText = true;
+              scene.lineOptions.push(opts.line);
+              scene.fillOptions.push(opts.fill);
+              scene.markerOptions.push(opts.marker);
+              scene.markerSelectedOptions.push(opts.markerSel);
+              scene.markerUnselectedOptions.push(opts.markerUnsel);
+              scene.textOptions.push(opts.text);
+              scene.textSelectedOptions.push(opts.textSel);
+              scene.textUnselectedOptions.push(opts.textUnsel);
+              scene.selectBatch.push([]);
+              scene.unselectBatch.push([]);
+              stash.x = x2;
+              stash.y = y2;
+              stash.rawx = x2;
+              stash.rawy = y2;
+              stash.r = rArray;
+              stash.theta = thetaArray;
+              stash.positions = positions;
+              stash._scene = scene;
+              stash.index = scene.count;
+              scene.count++;
+            });
+            return scatterglPlot(gd2, subplot, cdata);
+          };
+          module2.exports.reglPrecompiled = reglPrecompiled;
+        }
+      });
+      var require_scatterpolargl = __commonJS({
+        "src/traces/scatterpolargl/index.js"(exports, module2) {
+          var index = require_base_index4();
+          index.plot = require_plot37();
+          module2.exports = index;
+        }
+      });
+      var require_scatterpolargl2 = __commonJS({
+        "lib/scatterpolargl.js"(exports, module2) {
+          module2.exports = require_scatterpolargl();
+        }
+      });
+      var require_attributes70 = __commonJS({
+        "src/traces/barpolar/attributes.js"(exports, module2) {
+          var { hovertemplateAttrs, templatefallbackAttrs } = require_template_attributes();
+          var extendFlat = require_extend().extendFlat;
+          var scatterPolarAttrs = require_attributes68();
+          var barAttrs = require_attributes23();
+          module2.exports = {
+            r: scatterPolarAttrs.r,
+            theta: scatterPolarAttrs.theta,
+            r0: scatterPolarAttrs.r0,
+            dr: scatterPolarAttrs.dr,
+            theta0: scatterPolarAttrs.theta0,
+            dtheta: scatterPolarAttrs.dtheta,
+            thetaunit: scatterPolarAttrs.thetaunit,
+            // orientation: {
+            //     valType: 'enumerated',
+            //     values: ['radial', 'angular'],
+            //     editType: 'calc+clearAxisTypes',
+            //
+            // },
+            base: extendFlat({}, barAttrs.base, {}),
+            offset: extendFlat({}, barAttrs.offset, {}),
+            width: extendFlat({}, barAttrs.width, {}),
+            text: extendFlat({}, barAttrs.text, {}),
+            hovertext: extendFlat({}, barAttrs.hovertext, {}),
+            // textposition: {},
+            // textfont: {},
+            // insidetextfont: {},
+            // outsidetextfont: {},
+            // constraintext: {},
+            // cliponaxis: extendFlat({}, barAttrs.cliponaxis, {dflt: false}),
+            marker: barPolarMarker(),
+            hoverinfo: scatterPolarAttrs.hoverinfo,
+            hovertemplate: hovertemplateAttrs(),
+            hovertemplatefallback: templatefallbackAttrs(),
+            selected: barAttrs.selected,
+            unselected: barAttrs.unselected
+            // error_x (error_r, error_theta)
+            // error_y
+          };
+          function barPolarMarker() {
+            var marker = extendFlat({}, barAttrs.marker);
+            delete marker.cornerradius;
+            return marker;
+          }
+        }
+      });
+      var require_layout_attributes22 = __commonJS({
+        "src/traces/barpolar/layout_attributes.js"(exports, module2) {
+          module2.exports = {
+            barmode: {
+              valType: "enumerated",
+              values: ["stack", "overlay"],
+              dflt: "stack",
+              editType: "calc"
+            },
+            bargap: {
+              valType: "number",
+              dflt: 0.1,
+              min: 0,
+              max: 1,
+              editType: "calc"
+            }
+          };
+        }
+      });
+      var require_defaults66 = __commonJS({
+        "src/traces/barpolar/defaults.js"(exports, module2) {
+          var Lib = require_lib();
+          var handleRThetaDefaults = require_defaults64().handleRThetaDefaults;
+          var handleStyleDefaults = require_style_defaults();
+          var attributes = require_attributes70();
+          module2.exports = function supplyDefaults(traceIn, traceOut, defaultColor, layout) {
+            function coerce(attr, dflt) {
+              return Lib.coerce(traceIn, traceOut, attributes, attr, dflt);
+            }
+            var len2 = handleRThetaDefaults(traceIn, traceOut, layout, coerce);
+            if (!len2) {
+              traceOut.visible = false;
+              return;
+            }
+            coerce("thetaunit");
+            coerce("base");
+            coerce("offset");
+            coerce("width");
+            coerce("text");
+            coerce("hovertext");
+            coerce("hovertemplate");
+            coerce("hovertemplatefallback");
+            handleStyleDefaults(traceIn, traceOut, coerce, defaultColor, layout);
+            Lib.coerceSelectionMarkerOpacity(traceOut, coerce);
+          };
+        }
+      });
+      var require_layout_defaults20 = __commonJS({
+        "src/traces/barpolar/layout_defaults.js"(exports, module2) {
+          var Lib = require_lib();
+          var attrs = require_layout_attributes22();
+          module2.exports = function(layoutIn, layoutOut, fullData) {
+            var subplotsDone = {};
+            var sp;
+            function coerce(attr, dflt) {
+              return Lib.coerce(layoutIn[sp] || {}, layoutOut[sp], attrs, attr, dflt);
+            }
+            for (var i2 = 0; i2 < fullData.length; i2++) {
+              var trace = fullData[i2];
+              if (trace.type === "barpolar" && trace.visible === true) {
+                sp = trace.subplot;
+                if (!subplotsDone[sp]) {
+                  coerce("barmode");
+                  coerce("bargap");
+                  subplotsDone[sp] = 1;
+                }
+              }
+            }
+          };
+        }
+      });
+      var require_calc45 = __commonJS({
+        "src/traces/barpolar/calc.js"(exports, module2) {
+          var hasColorscale = require_helpers().hasColorscale;
+          var colorscaleCalc = require_calc();
+          var isArrayOrTypedArray = require_lib().isArrayOrTypedArray;
+          var arraysToCalcdata = require_arrays_to_calcdata2();
+          var setGroupPositions = require_cross_trace_calc().setGroupPositions;
+          var calcSelection = require_calc_selection();
+          var traceIs = require_registry().traceIs;
+          var extendFlat = require_lib().extendFlat;
+          function calc(gd2, trace) {
+            var fullLayout = gd2._fullLayout;
+            var subplotId = trace.subplot;
+            var radialAxis = fullLayout[subplotId].radialaxis;
+            var angularAxis = fullLayout[subplotId].angularaxis;
+            var rArray = radialAxis.makeCalcdata(trace, "r");
+            var thetaArray = angularAxis.makeCalcdata(trace, "theta");
+            var len2 = trace._length;
+            var cd2 = new Array(len2);
+            var sArray = rArray;
+            var pArray = thetaArray;
+            for (var i2 = 0; i2 < len2; i2++) {
+              cd2[i2] = { p: pArray[i2], s: sArray[i2] };
+            }
+            function d2c(attr) {
+              var val = trace[attr];
+              if (val !== void 0) {
+                trace["_" + attr] = isArrayOrTypedArray(val) ? angularAxis.makeCalcdata(trace, attr) : angularAxis.d2c(val, trace.thetaunit);
+              }
+            }
+            if (angularAxis.type === "linear") {
+              d2c("width");
+              d2c("offset");
+            }
+            if (hasColorscale(trace, "marker")) {
+              colorscaleCalc(gd2, trace, {
+                vals: trace.marker.color,
+                containerStr: "marker",
+                cLetter: "c"
+              });
+            }
+            if (hasColorscale(trace, "marker.line")) {
+              colorscaleCalc(gd2, trace, {
+                vals: trace.marker.line.color,
+                containerStr: "marker.line",
+                cLetter: "c"
+              });
+            }
+            arraysToCalcdata(cd2, trace);
+            calcSelection(cd2, trace);
+            return cd2;
+          }
+          function crossTraceCalc(gd2, polarLayout, subplotId) {
+            var calcdata = gd2.calcdata;
+            var barPolarCd = [];
+            for (var i2 = 0; i2 < calcdata.length; i2++) {
+              var cdi = calcdata[i2];
+              var trace = cdi[0].trace;
+              if (trace.visible === true && traceIs(trace, "bar") && trace.subplot === subplotId) {
+                barPolarCd.push(cdi);
+              }
+            }
+            var rAxis = extendFlat({}, polarLayout.radialaxis, { _id: "x" });
+            var aAxis = polarLayout.angularaxis;
+            setGroupPositions(gd2, aAxis, rAxis, barPolarCd, {
+              mode: polarLayout.barmode,
+              norm: polarLayout.barnorm,
+              gap: polarLayout.bargap,
+              groupgap: polarLayout.bargroupgap
+            });
+          }
+          module2.exports = {
+            calc,
+            crossTraceCalc
+          };
+        }
+      });
+      var require_plot38 = __commonJS({
+        "src/traces/barpolar/plot.js"(exports, module2) {
+          var d3 = require_d3();
+          var isNumeric = require_fast_isnumeric();
+          var Lib = require_lib();
+          var Drawing = require_drawing();
+          var helpers = require_helpers19();
+          module2.exports = function plot(gd2, subplot, cdbar) {
+            var isStatic = gd2._context.staticPlot;
+            var xa = subplot.xaxis;
+            var ya2 = subplot.yaxis;
+            var radialAxis = subplot.radialAxis;
+            var angularAxis = subplot.angularAxis;
+            var pathFn = makePathFn(subplot);
+            var barLayer = subplot.layers.frontplot.select("g.barlayer");
+            Lib.makeTraceGroups(barLayer, cdbar, "trace bars").each(function() {
+              var plotGroup = d3.select(this);
+              var pointGroup = Lib.ensureSingle(plotGroup, "g", "points");
+              var bars = pointGroup.selectAll("g.point").data(Lib.identity);
+              bars.enter().append("g").style("vector-effect", isStatic ? "none" : "non-scaling-stroke").style("stroke-miterlimit", 2).classed("point", true);
+              bars.exit().remove();
+              bars.each(function(di2) {
+                var bar = d3.select(this);
+                var rp0 = di2.rp0 = radialAxis.c2p(di2.s0);
+                var rp1 = di2.rp1 = radialAxis.c2p(di2.s1);
+                var thetag0 = di2.thetag0 = angularAxis.c2g(di2.p0);
+                var thetag1 = di2.thetag1 = angularAxis.c2g(di2.p1);
+                var dPath;
+                if (!isNumeric(rp0) || !isNumeric(rp1) || !isNumeric(thetag0) || !isNumeric(thetag1) || rp0 === rp1 || thetag0 === thetag1) {
+                  dPath = "M0,0Z";
+                } else {
+                  var rg1 = radialAxis.c2g(di2.s1);
+                  var thetagMid = (thetag0 + thetag1) / 2;
+                  di2.ct = [
+                    xa.c2p(rg1 * Math.cos(thetagMid)),
+                    ya2.c2p(rg1 * Math.sin(thetagMid))
+                  ];
+                  dPath = pathFn(rp0, rp1, thetag0, thetag1);
+                }
+                Lib.ensureSingle(bar, "path").attr("d", dPath);
+              });
+              Drawing.setClipUrl(
+                plotGroup,
+                subplot._hasClipOnAxisFalse ? subplot.clipIds.forTraces : null,
+                gd2
+              );
+            });
+          };
+          function makePathFn(subplot) {
+            var cxx = subplot.cxx;
+            var cyy = subplot.cyy;
+            if (subplot.vangles) {
+              return function(r0, r1, _a0, _a1) {
+                var a0, a1;
+                if (Lib.angleDelta(_a0, _a1) > 0) {
+                  a0 = _a0;
+                  a1 = _a1;
+                } else {
+                  a0 = _a1;
+                  a1 = _a0;
+                }
+                var va0 = helpers.findEnclosingVertexAngles(a0, subplot.vangles)[0];
+                var va1 = helpers.findEnclosingVertexAngles(a1, subplot.vangles)[1];
+                var vaBar = [va0, (a0 + a1) / 2, va1];
+                return helpers.pathPolygonAnnulus(r0, r1, a0, a1, vaBar, cxx, cyy);
+              };
+            }
+            return function(r0, r1, a0, a1) {
+              return Lib.pathAnnulus(r0, r1, a0, a1, cxx, cyy);
+            };
+          }
+        }
+      });
+      var require_hover26 = __commonJS({
+        "src/traces/barpolar/hover.js"(exports, module2) {
+          var Fx = require_fx();
+          var Lib = require_lib();
+          var getTraceColor = require_hover3().getTraceColor;
+          var fillText = Lib.fillText;
+          var makeHoverPointText = require_hover24().makeHoverPointText;
+          var isPtInsidePolygon = require_helpers19().isPtInsidePolygon;
+          module2.exports = function hoverPoints(pointData, xval, yval) {
+            var cd2 = pointData.cd;
+            var trace = cd2[0].trace;
+            var subplot = pointData.subplot;
+            var radialAxis = subplot.radialAxis;
+            var angularAxis = subplot.angularAxis;
+            var vangles = subplot.vangles;
+            var inboxFn = vangles ? isPtInsidePolygon : Lib.isPtInsideSector;
+            var maxHoverDistance = pointData.maxHoverDistance;
+            var period = angularAxis._period || 2 * Math.PI;
+            var rVal = Math.abs(radialAxis.g2p(Math.sqrt(xval * xval + yval * yval)));
+            var thetaVal = Math.atan2(yval, xval);
+            if (radialAxis.range[0] > radialAxis.range[1]) {
+              thetaVal += Math.PI;
+            }
+            var distFn = function(di2) {
+              if (inboxFn(rVal, thetaVal, [di2.rp0, di2.rp1], [di2.thetag0, di2.thetag1], vangles)) {
+                return maxHoverDistance + // add a little to the pseudo-distance for wider bars, so that like scatter,
+                // if you are over two overlapping bars, the narrower one wins.
+                Math.min(1, Math.abs(di2.thetag1 - di2.thetag0) / period) - 1 + // add a gradient so hovering near the end of a
+                // bar makes it a little closer match
+                (di2.rp1 - rVal) / (di2.rp1 - di2.rp0) - 1;
+              } else {
+                return Infinity;
+              }
+            };
+            Fx.getClosest(cd2, distFn, pointData);
+            if (pointData.index === false) return;
+            var index = pointData.index;
+            var cdi = cd2[index];
+            pointData.x0 = pointData.x1 = cdi.ct[0];
+            pointData.y0 = pointData.y1 = cdi.ct[1];
+            var _cdi = Lib.extendFlat({}, cdi, { r: cdi.s, theta: cdi.p });
+            fillText(cdi, trace, pointData);
+            makeHoverPointText(_cdi, trace, subplot, pointData);
+            pointData.hovertemplate = trace.hovertemplate;
+            pointData.color = getTraceColor(trace, cdi);
+            pointData.xLabelVal = pointData.yLabelVal = void 0;
+            if (cdi.s < 0) {
+              pointData.idealAlign = "left";
+            }
+            return [pointData];
+          };
+        }
+      });
+      var require_barpolar = __commonJS({
+        "src/traces/barpolar/index.js"(exports, module2) {
+          module2.exports = {
+            moduleType: "trace",
+            name: "barpolar",
+            basePlotModule: require_polar2(),
+            categories: ["polar", "bar", "showLegend"],
+            attributes: require_attributes70(),
+            layoutAttributes: require_layout_attributes22(),
+            supplyDefaults: require_defaults66(),
+            supplyLayoutDefaults: require_layout_defaults20(),
+            calc: require_calc45().calc,
+            crossTraceCalc: require_calc45().crossTraceCalc,
+            plot: require_plot38(),
+            colorbar: require_marker_colorbar(),
+            formatLabels: require_format_labels8(),
+            style: require_style4().style,
+            styleOnSelect: require_style4().styleOnSelect,
+            hoverPoints: require_hover26(),
+            selectPoints: require_select3(),
+            meta: {}
+          };
+        }
+      });
+      var require_barpolar2 = __commonJS({
+        "lib/barpolar.js"(exports, module2) {
+          module2.exports = require_barpolar();
+        }
+      });
+      var require_constants34 = __commonJS({
+        "src/plots/smith/constants.js"(exports, module2) {
+          module2.exports = {
+            attr: "subplot",
+            name: "smith",
+            axisNames: [
+              "realaxis",
+              "imaginaryaxis"
+              // imaginary axis should be second here so that the `tickvals` defaults could be inherited from realaxis
+            ],
+            axisName2dataArray: { imaginaryaxis: "imag", realaxis: "real" }
+          };
+        }
+      });
+      var require_layout_attributes23 = __commonJS({
+        "src/plots/smith/layout_attributes.js"(exports, module2) {
+          var colorAttrs = require_attributes3();
+          var axesAttrs = require_layout_attributes4();
+          var domainAttrs = require_domain().attributes;
+          var extendFlat = require_lib().extendFlat;
+          var overrideAll = require_edit_types().overrideAll;
+          var axisLineGridAttr = overrideAll({
+            color: axesAttrs.color,
+            showline: extendFlat({}, axesAttrs.showline, { dflt: true }),
+            linecolor: axesAttrs.linecolor,
+            linewidth: axesAttrs.linewidth,
+            showgrid: extendFlat({}, axesAttrs.showgrid, { dflt: true }),
+            gridcolor: axesAttrs.gridcolor,
+            gridwidth: axesAttrs.gridwidth,
+            griddash: axesAttrs.griddash
+          }, "plot", "from-root");
+          var axisTickAttrs = overrideAll({
+            ticklen: axesAttrs.ticklen,
+            tickwidth: extendFlat({}, axesAttrs.tickwidth, { dflt: 2 }),
+            tickcolor: axesAttrs.tickcolor,
+            showticklabels: axesAttrs.showticklabels,
+            labelalias: axesAttrs.labelalias,
+            showtickprefix: axesAttrs.showtickprefix,
+            tickprefix: axesAttrs.tickprefix,
+            showticksuffix: axesAttrs.showticksuffix,
+            ticksuffix: axesAttrs.ticksuffix,
+            tickfont: axesAttrs.tickfont,
+            tickformat: axesAttrs.tickformat,
+            hoverformat: axesAttrs.hoverformat,
+            layer: axesAttrs.layer
+          }, "plot", "from-root");
+          var realAxisAttrs = extendFlat({
+            visible: extendFlat({}, axesAttrs.visible, { dflt: true }),
+            tickvals: {
+              dflt: [0.2, 0.5, 1, 2, 5],
+              valType: "data_array",
+              editType: "plot"
+            },
+            tickangle: extendFlat({}, axesAttrs.tickangle, { dflt: 90 }),
+            ticks: {
+              valType: "enumerated",
+              values: ["top", "bottom", ""],
+              editType: "ticks"
+            },
+            side: {
+              valType: "enumerated",
+              values: ["top", "bottom"],
+              dflt: "top",
+              editType: "plot"
+            },
+            editType: "calc"
+          }, axisLineGridAttr, axisTickAttrs);
+          var imaginaryAxisAttrs = extendFlat({
+            visible: extendFlat({}, axesAttrs.visible, { dflt: true }),
+            tickvals: {
+              valType: "data_array",
+              editType: "plot"
+            },
+            ticks: axesAttrs.ticks,
+            editType: "calc"
+          }, axisLineGridAttr, axisTickAttrs);
+          module2.exports = {
+            domain: domainAttrs({ name: "smith", editType: "plot" }),
+            bgcolor: {
+              valType: "color",
+              editType: "plot",
+              dflt: colorAttrs.background
+            },
+            realaxis: realAxisAttrs,
+            imaginaryaxis: imaginaryAxisAttrs,
+            editType: "calc"
+          };
+        }
+      });
+      var require_layout_defaults21 = __commonJS({
+        "src/plots/smith/layout_defaults.js"(exports, module2) {
+          var Lib = require_lib();
+          var Color2 = require_color();
+          var Template = require_plot_template();
+          var handleSubplotDefaults = require_subplot_defaults();
+          var getSubplotData = require_get_data().getSubplotData;
+          var handlePrefixSuffixDefaults = require_prefix_suffix_defaults();
+          var handleTickLabelDefaults = require_tick_label_defaults();
+          var handleLineGridDefaults = require_line_grid_defaults();
+          var setConvertCartesian = require_set_convert();
+          var layoutAttributes = require_layout_attributes23();
+          var constants = require_constants34();
+          var axisNames = constants.axisNames;
+          var makeImagDflt = memoize2(function(realTickvals) {
+            if (Lib.isTypedArray(realTickvals)) realTickvals = Array.from(realTickvals);
+            return realTickvals.slice().reverse().map(function(x2) {
+              return -x2;
+            }).concat([0]).concat(realTickvals);
+          }, String);
+          function handleDefaults(contIn, contOut, coerce, opts) {
+            var bgColor = coerce("bgcolor");
+            opts.bgColor = Color2.combine(bgColor, opts.paper_bgcolor);
+            var subplotData = getSubplotData(opts.fullData, constants.name, opts.id);
+            var layoutOut = opts.layoutOut;
+            var axName;
+            function coerceAxis(attr, dflt) {
+              return coerce(axName + "." + attr, dflt);
+            }
+            for (var i2 = 0; i2 < axisNames.length; i2++) {
+              axName = axisNames[i2];
+              if (!Lib.isPlainObject(contIn[axName])) {
+                contIn[axName] = {};
+              }
+              var axIn = contIn[axName];
+              var axOut = Template.newContainer(contOut, axName);
+              axOut._id = axOut._name = axName;
+              axOut._attr = opts.id + "." + axName;
+              axOut._traceIndices = subplotData.map(function(t4) {
+                return t4.index;
+              });
+              var visible = coerceAxis("visible");
+              axOut.type = "linear";
+              setConvertCartesian(axOut, layoutOut);
+              handlePrefixSuffixDefaults(axIn, axOut, coerceAxis, axOut.type);
+              if (visible) {
+                var isRealAxis = axName === "realaxis";
+                if (isRealAxis) coerceAxis("side");
+                if (isRealAxis) {
+                  coerceAxis("tickvals");
+                } else {
+                  var imagTickvalsDflt = makeImagDflt(
+                    contOut.realaxis.tickvals || layoutAttributes.realaxis.tickvals.dflt
+                  );
+                  coerceAxis("tickvals", imagTickvalsDflt);
+                }
+                if (Lib.isTypedArray(axOut.tickvals)) axOut.tickvals = Array.from(axOut.tickvals);
+                var dfltColor;
+                var dfltFontColor;
+                var dfltFontSize;
+                var dfltFontFamily;
+                var font = opts.font || {};
+                if (visible) {
+                  dfltColor = coerceAxis("color");
+                  dfltFontColor = dfltColor === axIn.color ? dfltColor : font.color;
+                  dfltFontSize = font.size;
+                  dfltFontFamily = font.family;
+                }
+                handleTickLabelDefaults(axIn, axOut, coerceAxis, axOut.type, {
+                  noAutotickangles: true,
+                  noTicklabelshift: true,
+                  noTicklabelstandoff: true,
+                  noTicklabelstep: true,
+                  noAng: !isRealAxis,
+                  noExp: true,
+                  font: {
+                    color: dfltFontColor,
+                    size: dfltFontSize,
+                    family: dfltFontFamily
+                  }
+                });
+                Lib.coerce2(contIn, contOut, layoutAttributes, axName + ".ticklen");
+                Lib.coerce2(contIn, contOut, layoutAttributes, axName + ".tickwidth");
+                Lib.coerce2(contIn, contOut, layoutAttributes, axName + ".tickcolor", contOut.color);
+                var showTicks = coerceAxis("ticks");
+                if (!showTicks) {
+                  delete contOut[axName].ticklen;
+                  delete contOut[axName].tickwidth;
+                  delete contOut[axName].tickcolor;
+                }
+                handleLineGridDefaults(axIn, axOut, coerceAxis, {
+                  dfltColor,
+                  bgColor: opts.bgColor,
+                  // default grid color is darker here (60%, vs cartesian default ~91%)
+                  // because the grid is not square so the eye needs heavier cues to follow
+                  blend: 60,
+                  showLine: true,
+                  showGrid: true,
+                  noZeroLine: true,
+                  attributes: layoutAttributes[axName]
+                });
+                coerceAxis("layer");
+              }
+              coerceAxis("hoverformat");
+              delete axOut.type;
+              axOut._input = axIn;
+            }
+          }
+          module2.exports = function supplyLayoutDefaults(layoutIn, layoutOut, fullData) {
+            handleSubplotDefaults(layoutIn, layoutOut, fullData, {
+              noUirevision: true,
+              type: constants.name,
+              attributes: layoutAttributes,
+              handleDefaults,
+              font: layoutOut.font,
+              paper_bgcolor: layoutOut.paper_bgcolor,
+              fullData,
+              layoutOut
+            });
+          };
+          function memoize2(fn, keyFn) {
+            var cache = {};
+            return function(val) {
+              var newKey = keyFn ? keyFn(val) : val;
+              if (newKey in cache) {
+                return cache[newKey];
+              }
+              var out = fn(val);
+              cache[newKey] = out;
+              return out;
+            };
+          }
+        }
+      });
+      var require_smith = __commonJS({
+        "src/plots/smith/index.js"(exports, module2) {
+          var getSubplotCalcData = require_get_data().getSubplotCalcData;
+          var counterRegex = require_lib().counterRegex;
+          var createPolar = require_polar();
+          var constants = require_constants34();
+          var attr = constants.attr;
+          var name2 = constants.name;
+          var counter2 = counterRegex(name2);
+          var attributes = {};
+          attributes[attr] = {
+            valType: "subplotid",
+            dflt: name2,
+            editType: "calc"
+          };
+          function plot(gd2) {
+            var fullLayout = gd2._fullLayout;
+            var calcData = gd2.calcdata;
+            var subplotIds = fullLayout._subplots[name2];
+            for (var i2 = 0; i2 < subplotIds.length; i2++) {
+              var id2 = subplotIds[i2];
+              var subplotCalcData = getSubplotCalcData(calcData, name2, id2);
+              var subplot = fullLayout[id2]._subplot;
+              if (!subplot) {
+                subplot = createPolar(gd2, id2, true);
+                fullLayout[id2]._subplot = subplot;
+              }
+              subplot.plot(subplotCalcData, fullLayout, gd2._promises);
+            }
+          }
+          function clean(newFullData, newFullLayout, oldFullData, oldFullLayout) {
+            var oldIds = oldFullLayout._subplots[name2] || [];
+            for (var i2 = 0; i2 < oldIds.length; i2++) {
+              var id2 = oldIds[i2];
+              var oldSubplot = oldFullLayout[id2]._subplot;
+              if (!newFullLayout[id2] && !!oldSubplot) {
+                oldSubplot.framework.remove();
+                for (var k2 in oldSubplot.clipPaths) {
+                  oldSubplot.clipPaths[k2].remove();
+                }
+              }
+            }
+          }
+          module2.exports = {
+            attr,
+            name: name2,
+            idRoot: name2,
+            idRegex: counter2,
+            attrRegex: counter2,
+            attributes,
+            layoutAttributes: require_layout_attributes23(),
+            supplyLayoutDefaults: require_layout_defaults21(),
+            plot,
+            clean,
+            toSVG: require_cartesian().toSVG
+          };
+        }
+      });
+      var require_attributes71 = __commonJS({
+        "src/traces/scattersmith/attributes.js"(exports, module2) {
+          var { hovertemplateAttrs, texttemplateAttrs, templatefallbackAttrs } = require_template_attributes();
+          var extendFlat = require_extend().extendFlat;
+          var makeFillcolorAttr = require_fillcolor_attribute();
+          var scatterAttrs = require_attributes12();
+          var baseAttrs = require_attributes2();
+          var lineAttrs = scatterAttrs.line;
+          module2.exports = {
+            mode: scatterAttrs.mode,
+            real: {
+              valType: "data_array",
+              editType: "calc+clearAxisTypes"
+            },
+            imag: {
+              valType: "data_array",
+              editType: "calc+clearAxisTypes"
+            },
+            text: scatterAttrs.text,
+            texttemplate: texttemplateAttrs({ editType: "plot" }, { keys: ["real", "imag", "text"] }),
+            texttemplatefallback: templatefallbackAttrs({ editType: "plot" }),
+            hovertext: scatterAttrs.hovertext,
+            line: {
+              color: lineAttrs.color,
+              width: lineAttrs.width,
+              dash: lineAttrs.dash,
+              backoff: lineAttrs.backoff,
+              shape: extendFlat({}, lineAttrs.shape, {
+                values: ["linear", "spline"]
+              }),
+              smoothing: lineAttrs.smoothing,
+              editType: "calc"
+            },
+            connectgaps: scatterAttrs.connectgaps,
+            marker: scatterAttrs.marker,
+            cliponaxis: extendFlat({}, scatterAttrs.cliponaxis, { dflt: false }),
+            textposition: scatterAttrs.textposition,
+            textfont: scatterAttrs.textfont,
+            fill: extendFlat({}, scatterAttrs.fill, {
+              values: ["none", "toself", "tonext"],
+              dflt: "none"
+            }),
+            fillcolor: makeFillcolorAttr(),
+            hoverinfo: extendFlat({}, baseAttrs.hoverinfo, {
+              flags: ["real", "imag", "text", "name"]
+            }),
+            hoveron: scatterAttrs.hoveron,
+            hovertemplate: hovertemplateAttrs(),
+            hovertemplatefallback: templatefallbackAttrs(),
+            selected: scatterAttrs.selected,
+            unselected: scatterAttrs.unselected
+          };
+        }
+      });
+      var require_defaults67 = __commonJS({
+        "src/traces/scattersmith/defaults.js"(exports, module2) {
+          var Lib = require_lib();
+          var subTypes = require_subtypes();
+          var handleMarkerDefaults = require_marker_defaults();
+          var handleLineDefaults = require_line_defaults();
+          var handleLineShapeDefaults = require_line_shape_defaults();
+          var handleTextDefaults = require_text_defaults();
+          var handleFillColorDefaults = require_fillcolor_defaults();
+          var PTS_LINESONLY = require_constants8().PTS_LINESONLY;
+          var attributes = require_attributes71();
+          module2.exports = function supplyDefaults(traceIn, traceOut, defaultColor, layout) {
+            function coerce(attr, dflt) {
+              return Lib.coerce(traceIn, traceOut, attributes, attr, dflt);
+            }
+            var len2 = handleRealImagDefaults(traceIn, traceOut, layout, coerce);
+            if (!len2) {
+              traceOut.visible = false;
+              return;
+            }
+            coerce("mode", len2 < PTS_LINESONLY ? "lines+markers" : "lines");
+            coerce("text");
+            coerce("hovertext");
+            if (traceOut.hoveron !== "fills") {
+              coerce("hovertemplate");
+              coerce("hovertemplatefallback");
+            }
+            if (subTypes.hasMarkers(traceOut)) {
+              handleMarkerDefaults(traceIn, traceOut, defaultColor, layout, coerce, { gradient: true });
+            }
+            if (subTypes.hasLines(traceOut)) {
+              handleLineDefaults(traceIn, traceOut, defaultColor, layout, coerce, { backoff: true });
+              handleLineShapeDefaults(traceIn, traceOut, coerce);
+              coerce("connectgaps");
+            }
+            if (subTypes.hasText(traceOut)) {
+              coerce("texttemplate");
+              coerce("texttemplatefallback");
+              handleTextDefaults(traceIn, traceOut, layout, coerce);
+            }
+            var dfltHoverOn = [];
+            if (subTypes.hasMarkers(traceOut) || subTypes.hasText(traceOut)) {
+              coerce("cliponaxis");
+              coerce("marker.maxdisplayed");
+              dfltHoverOn.push("points");
+            }
+            coerce("fill");
+            if (traceOut.fill !== "none") {
+              handleFillColorDefaults(traceIn, traceOut, defaultColor, coerce);
+              if (!subTypes.hasLines(traceOut)) handleLineShapeDefaults(traceIn, traceOut, coerce);
+            }
+            if (traceOut.fill === "tonext" || traceOut.fill === "toself") {
+              dfltHoverOn.push("fills");
+            }
+            coerce("hoveron", dfltHoverOn.join("+") || "points");
+            Lib.coerceSelectionMarkerOpacity(traceOut, coerce);
+          };
+          function handleRealImagDefaults(traceIn, traceOut, layout, coerce) {
+            var real = coerce("real");
+            var imag = coerce("imag");
+            var len2;
+            if (real && imag) {
+              len2 = Math.min(real.length, imag.length);
+            }
+            if (Lib.isTypedArray(real)) {
+              traceOut.real = real = Array.from(real);
+            }
+            if (Lib.isTypedArray(imag)) {
+              traceOut.imag = imag = Array.from(imag);
+            }
+            traceOut._length = len2;
+            return len2;
+          }
+        }
+      });
+      var require_format_labels10 = __commonJS({
+        "src/traces/scattersmith/format_labels.js"(exports, module2) {
+          var Axes = require_axes();
+          module2.exports = function formatLabels(cdi, trace, fullLayout) {
+            var labels = {};
+            var subplot = fullLayout[trace.subplot]._subplot;
+            labels.realLabel = Axes.tickText(subplot.radialAxis, cdi.real, true).text;
+            labels.imagLabel = Axes.tickText(subplot.angularAxis, cdi.imag, true).text;
+            return labels;
+          };
+        }
+      });
+      var require_calc46 = __commonJS({
+        "src/traces/scattersmith/calc.js"(exports, module2) {
+          var isNumeric = require_fast_isnumeric();
+          var BADNUM = require_numerical().BADNUM;
+          var calcColorscale = require_colorscale_calc();
+          var arraysToCalcdata = require_arrays_to_calcdata();
+          var calcSelection = require_calc_selection();
+          var calcMarkerSize = require_calc3().calcMarkerSize;
+          module2.exports = function calc(gd2, trace) {
+            var fullLayout = gd2._fullLayout;
+            var subplotId = trace.subplot;
+            var realAxis = fullLayout[subplotId].realaxis;
+            var imaginaryAxis = fullLayout[subplotId].imaginaryaxis;
+            var realArray = realAxis.makeCalcdata(trace, "real");
+            var imagArray = imaginaryAxis.makeCalcdata(trace, "imag");
+            var len2 = trace._length;
+            var cd2 = new Array(len2);
+            for (var i2 = 0; i2 < len2; i2++) {
+              var real = realArray[i2];
+              var imag = imagArray[i2];
+              var cdi = cd2[i2] = {};
+              if (isNumeric(real) && isNumeric(imag)) {
+                cdi.real = real;
+                cdi.imag = imag;
+              } else {
+                cdi.real = BADNUM;
+              }
+            }
+            calcMarkerSize(trace, len2);
+            calcColorscale(gd2, trace);
+            arraysToCalcdata(cd2, trace);
+            calcSelection(cd2, trace);
+            return cd2;
+          };
+        }
+      });
+      var require_plot39 = __commonJS({
+        "src/traces/scattersmith/plot.js"(exports, module2) {
+          var scatterPlot = require_plot();
+          var BADNUM = require_numerical().BADNUM;
+          var helpers = require_helpers20();
+          var smith = helpers.smith;
+          module2.exports = function plot(gd2, subplot, moduleCalcData) {
+            var mlayer = subplot.layers.frontplot.select("g.scatterlayer");
+            var xa = subplot.xaxis;
+            var ya2 = subplot.yaxis;
+            var plotinfo = {
+              xaxis: xa,
+              yaxis: ya2,
+              plot: subplot.framework,
+              layerClipId: subplot._hasClipOnAxisFalse ? subplot.clipIds.forTraces : null
+            };
+            for (var i2 = 0; i2 < moduleCalcData.length; i2++) {
+              var cdi = moduleCalcData[i2];
+              for (var j2 = 0; j2 < cdi.length; j2++) {
+                if (j2 === 0) {
+                  cdi[0].trace._xA = xa;
+                  cdi[0].trace._yA = ya2;
+                }
+                var cd2 = cdi[j2];
+                var real = cd2.real;
+                if (real === BADNUM) {
+                  cd2.x = cd2.y = BADNUM;
+                } else {
+                  var t4 = smith([real, cd2.imag]);
+                  cd2.x = t4[0];
+                  cd2.y = t4[1];
+                }
+              }
+            }
+            scatterPlot(gd2, plotinfo, moduleCalcData, mlayer);
+          };
+        }
+      });
+      var require_hover27 = __commonJS({
+        "src/traces/scattersmith/hover.js"(exports, module2) {
+          var scatterHover = require_hover2();
+          function hoverPoints(pointData, xval, yval, hovermode) {
+            var scatterPointData = scatterHover(pointData, xval, yval, hovermode);
+            if (!scatterPointData || scatterPointData[0].index === false) return;
+            var newPointData = scatterPointData[0];
+            if (newPointData.index === void 0) {
+              return scatterPointData;
+            }
+            var subplot = pointData.subplot;
+            var cdi = newPointData.cd[newPointData.index];
+            var trace = newPointData.trace;
+            if (!subplot.isPtInside(cdi)) return;
+            newPointData.xLabelVal = void 0;
+            newPointData.yLabelVal = void 0;
+            makeHoverPointText(cdi, trace, subplot, newPointData);
+            newPointData.hovertemplate = trace.hovertemplate;
+            return scatterPointData;
+          }
+          function makeHoverPointText(cdi, trace, subplot, pointData) {
+            var realAxis = subplot.radialAxis;
+            var imaginaryAxis = subplot.angularAxis;
+            realAxis._hovertitle = "real";
+            imaginaryAxis._hovertitle = "imag";
+            var fullLayout = {};
+            fullLayout[trace.subplot] = { _subplot: subplot };
+            var labels = trace._module.formatLabels(cdi, trace, fullLayout);
+            pointData.realLabel = labels.realLabel;
+            pointData.imagLabel = labels.imagLabel;
+            var hoverinfo = cdi.hi || trace.hoverinfo;
+            var text = [];
+            function textPart(ax, val) {
+              text.push(ax._hovertitle + ": " + val);
+            }
+            if (!trace.hovertemplate) {
+              var parts = hoverinfo.split("+");
+              if (parts.indexOf("all") !== -1) parts = ["real", "imag", "text"];
+              if (parts.indexOf("real") !== -1) textPart(realAxis, pointData.realLabel);
+              if (parts.indexOf("imag") !== -1) textPart(imaginaryAxis, pointData.imagLabel);
+              if (parts.indexOf("text") !== -1 && pointData.text) {
+                text.push(pointData.text);
+                delete pointData.text;
+              }
+              pointData.extraText = text.join("<br>");
+            }
+          }
+          module2.exports = {
+            hoverPoints,
+            makeHoverPointText
+          };
+        }
+      });
+      var require_scattersmith = __commonJS({
+        "src/traces/scattersmith/index.js"(exports, module2) {
+          module2.exports = {
+            moduleType: "trace",
+            name: "scattersmith",
+            basePlotModule: require_smith(),
+            categories: ["smith", "symbols", "showLegend", "scatter-like"],
+            attributes: require_attributes71(),
+            supplyDefaults: require_defaults67(),
+            colorbar: require_marker_colorbar(),
+            formatLabels: require_format_labels10(),
+            calc: require_calc46(),
+            plot: require_plot39(),
+            style: require_style2().style,
+            styleOnSelect: require_style2().styleOnSelect,
+            hoverPoints: require_hover27().hoverPoints,
+            selectPoints: require_select2(),
+            meta: {}
+          };
+        }
+      });
+      var require_scattersmith2 = __commonJS({
+        "lib/scattersmith.js"(exports, module2) {
+          module2.exports = require_scattersmith();
+        }
+      });
+      var require_main = __commonJS({
+        "node_modules/world-calendars/dist/main.js"(exports, module2) {
+          var assign = require_object_assign();
+          function Calendars() {
+            this.regionalOptions = [];
+            this.regionalOptions[""] = {
+              invalidCalendar: "Calendar {0} not found",
+              invalidDate: "Invalid {0} date",
+              invalidMonth: "Invalid {0} month",
+              invalidYear: "Invalid {0} year",
+              differentCalendars: "Cannot mix {0} and {1} dates"
+            };
+            this.local = this.regionalOptions[""];
+            this.calendars = {};
+            this._localCals = {};
+          }
+          assign(Calendars.prototype, {
+            /** Obtain a calendar implementation and localisation.
+                @memberof Calendars
+                @param [name='gregorian'] {string} The name of the calendar, e.g. 'gregorian', 'persian', 'islamic'.
+                @param [language=''] {string} The language code to use for localisation (default is English).
+                @return {Calendar} The calendar and localisation.
+                @throws Error if calendar not found. */
+            instance: function(name2, language) {
+              name2 = (name2 || "gregorian").toLowerCase();
+              language = language || "";
+              var cal = this._localCals[name2 + "-" + language];
+              if (!cal && this.calendars[name2]) {
+                cal = new this.calendars[name2](language);
+                this._localCals[name2 + "-" + language] = cal;
+              }
+              if (!cal) {
+                throw (this.local.invalidCalendar || this.regionalOptions[""].invalidCalendar).replace(/\{0\}/, name2);
+              }
+              return cal;
+            },
+            /** Create a new date - for today if no other parameters given.
+                @memberof Calendars
+                @param year {CDate|number} The date to copy or the year for the date.
+                @param [month] {number} The month for the date.
+                @param [day] {number} The day for the date.
+                @param [calendar='gregorian'] {BaseCalendar|string} The underlying calendar or the name of the calendar.
+                @param [language=''] {string} The language to use for localisation (default English).
+                @return {CDate} The new date.
+                @throws Error if an invalid date. */
+            newDate: function(year, month, day, calendar, language) {
+              calendar = (year != null && year.year ? year.calendar() : typeof calendar === "string" ? this.instance(calendar, language) : calendar) || this.instance();
+              return calendar.newDate(year, month, day);
+            },
+            /** A simple digit substitution function for localising numbers via the Calendar digits option.
+                @member Calendars
+                @param digits {string[]} The substitute digits, for 0 through 9.
+                @return {function} The substitution function. */
+            substituteDigits: function(digits) {
+              return function(value) {
+                return (value + "").replace(/[0-9]/g, function(digit) {
+                  return digits[digit];
+                });
+              };
+            },
+            /** Digit substitution function for localising Chinese style numbers via the Calendar digits option.
+                @member Calendars
+                @param digits {string[]} The substitute digits, for 0 through 9.
+                @param powers {string[]} The characters denoting powers of 10, i.e. 1, 10, 100, 1000.
+                @return {function} The substitution function. */
+            substituteChineseDigits: function(digits, powers) {
+              return function(value) {
+                var localNumber = "";
+                var power = 0;
+                while (value > 0) {
+                  var units = value % 10;
+                  localNumber = (units === 0 ? "" : digits[units] + powers[power]) + localNumber;
+                  power++;
+                  value = Math.floor(value / 10);
+                }
+                if (localNumber.indexOf(digits[1] + powers[1]) === 0) {
+                  localNumber = localNumber.substr(1);
+                }
+                return localNumber || digits[0];
+              };
+            }
+          });
+          function CDate(calendar, year, month, day) {
+            this._calendar = calendar;
+            this._year = year;
+            this._month = month;
+            this._day = day;
+            if (this._calendar._validateLevel === 0 && !this._calendar.isValid(this._year, this._month, this._day)) {
+              throw (_exports.local.invalidDate || _exports.regionalOptions[""].invalidDate).replace(/\{0\}/, this._calendar.local.name);
+            }
+          }
+          function pad(value, length2) {
+            value = "" + value;
+            return "000000".substring(0, length2 - value.length) + value;
+          }
+          assign(CDate.prototype, {
+            /** Create a new date.
+                @memberof CDate
+                @param [year] {CDate|number} The date to copy or the year for the date (default this date).
+                @param [month] {number} The month for the date.
+                @param [day] {number} The day for the date.
+                @return {CDate} The new date.
+                @throws Error if an invalid date. */
+            newDate: function(year, month, day) {
+              return this._calendar.newDate(year == null ? this : year, month, day);
+            },
+            /** Set or retrieve the year for this date.
+                @memberof CDate
+                @param [year] {number} The year for the date.
+                @return {number|CDate} The date's year (if no parameter) or the updated date.
+                @throws Error if an invalid date. */
+            year: function(year) {
+              return arguments.length === 0 ? this._year : this.set(year, "y");
+            },
+            /** Set or retrieve the month for this date.
+                @memberof CDate
+                @param [month] {number} The month for the date.
+                @return {number|CDate} The date's month (if no parameter) or the updated date.
+                @throws Error if an invalid date. */
+            month: function(month) {
+              return arguments.length === 0 ? this._month : this.set(month, "m");
+            },
+            /** Set or retrieve the day for this date.
+                @memberof CDate
+                @param [day] {number} The day for the date.
+                @return {number|CData} The date's day (if no parameter) or the updated date.
+                @throws Error if an invalid date. */
+            day: function(day) {
+              return arguments.length === 0 ? this._day : this.set(day, "d");
+            },
+            /** Set new values for this date.
+                @memberof CDate
+                @param year {number} The year for the date.
+                @param month {number} The month for the date.
+                @param day {number} The day for the date.
+                @return {CDate} The updated date.
+                @throws Error if an invalid date. */
+            date: function(year, month, day) {
+              if (!this._calendar.isValid(year, month, day)) {
+                throw (_exports.local.invalidDate || _exports.regionalOptions[""].invalidDate).replace(/\{0\}/, this._calendar.local.name);
+              }
+              this._year = year;
+              this._month = month;
+              this._day = day;
+              return this;
+            },
+            /** Determine whether this date is in a leap year.
+                @memberof CDate
+                @return {boolean} <code>true</code> if this is a leap year, <code>false</code> if not. */
+            leapYear: function() {
+              return this._calendar.leapYear(this);
+            },
+            /** Retrieve the epoch designator for this date, e.g. BCE or CE.
+                @memberof CDate
+                @return {string} The current epoch. */
+            epoch: function() {
+              return this._calendar.epoch(this);
+            },
+            /** Format the year, if not a simple sequential number.
+                @memberof CDate
+                @return {string} The formatted year. */
+            formatYear: function() {
+              return this._calendar.formatYear(this);
+            },
+            /** Retrieve the month of the year for this date,
+                i.e. the month's position within a numbered year.
+                @memberof CDate
+                @return {number} The month of the year: <code>minMonth</code> to months per year. */
+            monthOfYear: function() {
+              return this._calendar.monthOfYear(this);
+            },
+            /** Retrieve the week of the year for this date.
+                @memberof CDate
+                @return {number} The week of the year: 1 to weeks per year. */
+            weekOfYear: function() {
+              return this._calendar.weekOfYear(this);
+            },
+            /** Retrieve the number of days in the year for this date.
+                @memberof CDate
+                @return {number} The number of days in this year. */
+            daysInYear: function() {
+              return this._calendar.daysInYear(this);
+            },
+            /** Retrieve the day of the year for this date.
+                @memberof CDate
+                @return {number} The day of the year: 1 to days per year. */
+            dayOfYear: function() {
+              return this._calendar.dayOfYear(this);
+            },
+            /** Retrieve the number of days in the month for this date.
+                @memberof CDate
+                @return {number} The number of days. */
+            daysInMonth: function() {
+              return this._calendar.daysInMonth(this);
+            },
+            /** Retrieve the day of the week for this date.
+                @memberof CDate
+                @return {number} The day of the week: 0 to number of days - 1. */
+            dayOfWeek: function() {
+              return this._calendar.dayOfWeek(this);
+            },
+            /** Determine whether this date is a week day.
+                @memberof CDate
+                @return {boolean} <code>true</code> if a week day, <code>false</code> if not. */
+            weekDay: function() {
+              return this._calendar.weekDay(this);
+            },
+            /** Retrieve additional information about this date.
+                @memberof CDate
+                @return {object} Additional information - contents depends on calendar. */
+            extraInfo: function() {
+              return this._calendar.extraInfo(this);
+            },
+            /** Add period(s) to a date.
+                @memberof CDate
+                @param offset {number} The number of periods to adjust by.
+                @param period {string} One of 'y' for year, 'm' for month, 'w' for week, 'd' for day.
+                @return {CDate} The updated date. */
+            add: function(offset, period) {
+              return this._calendar.add(this, offset, period);
+            },
+            /** Set a portion of the date.
+                @memberof CDate
+                @param value {number} The new value for the period.
+                @param period {string} One of 'y' for year, 'm' for month, 'd' for day.
+                @return {CDate} The updated date.
+                @throws Error if not a valid date. */
+            set: function(value, period) {
+              return this._calendar.set(this, value, period);
+            },
+            /** Compare this date to another date.
+                @memberof CDate
+                @param date {CDate} The other date.
+                @return {number} -1 if this date is before the other date,
+                        0 if they are equal, or +1 if this date is after the other date. */
+            compareTo: function(date) {
+              if (this._calendar.name !== date._calendar.name) {
+                throw (_exports.local.differentCalendars || _exports.regionalOptions[""].differentCalendars).replace(/\{0\}/, this._calendar.local.name).replace(/\{1\}/, date._calendar.local.name);
+              }
+              var c2 = this._year !== date._year ? this._year - date._year : this._month !== date._month ? this.monthOfYear() - date.monthOfYear() : this._day - date._day;
+              return c2 === 0 ? 0 : c2 < 0 ? -1 : 1;
+            },
+            /** Retrieve the calendar backing this date.
+                @memberof CDate
+                @return {BaseCalendar} The calendar implementation. */
+            calendar: function() {
+              return this._calendar;
+            },
+            /** Retrieve the Julian date equivalent for this date,
+                i.e. days since January 1, 4713 BCE Greenwich noon.
+                @memberof CDate
+                @return {number} The equivalent Julian date. */
+            toJD: function() {
+              return this._calendar.toJD(this);
+            },
+            /** Create a new date from a Julian date.
+                @memberof CDate
+                @param jd {number} The Julian date to convert.
+                @return {CDate} The equivalent date. */
+            fromJD: function(jd2) {
+              return this._calendar.fromJD(jd2);
+            },
+            /** Convert this date to a standard (Gregorian) JavaScript Date.
+                @memberof CDate
+                @return {Date} The equivalent JavaScript date. */
+            toJSDate: function() {
+              return this._calendar.toJSDate(this);
+            },
+            /** Create a new date from a standard (Gregorian) JavaScript Date.
+                @memberof CDate
+                @param jsd {Date} The JavaScript date to convert.
+                @return {CDate} The equivalent date. */
+            fromJSDate: function(jsd) {
+              return this._calendar.fromJSDate(jsd);
+            },
+            /** Convert to a string for display.
+                @memberof CDate
+                @return {string} This date as a string. */
+            toString: function() {
+              return (this.year() < 0 ? "-" : "") + pad(Math.abs(this.year()), 4) + "-" + pad(this.month(), 2) + "-" + pad(this.day(), 2);
+            }
+          });
+          function BaseCalendar() {
+            this.shortYearCutoff = "+10";
+          }
+          assign(BaseCalendar.prototype, {
+            _validateLevel: 0,
+            // "Stack" to turn validation on/off
+            /** Create a new date within this calendar - today if no parameters given.
+                @memberof BaseCalendar
+                @param year {CDate|number} The date to duplicate or the year for the date.
+                @param [month] {number} The month for the date.
+                @param [day] {number} The day for the date.
+                @return {CDate} The new date.
+                @throws Error if not a valid date or a different calendar used. */
+            newDate: function(year, month, day) {
+              if (year == null) {
+                return this.today();
+              }
+              if (year.year) {
+                this._validate(
+                  year,
+                  month,
+                  day,
+                  _exports.local.invalidDate || _exports.regionalOptions[""].invalidDate
+                );
+                day = year.day();
+                month = year.month();
+                year = year.year();
+              }
+              return new CDate(this, year, month, day);
+            },
+            /** Create a new date for today.
+                @memberof BaseCalendar
+                @return {CDate} Today's date. */
+            today: function() {
+              return this.fromJSDate(/* @__PURE__ */ new Date());
+            },
+            /** Retrieve the epoch designator for this date.
+                @memberof BaseCalendar
+                @param year {CDate|number} The date to examine or the year to examine.
+                @return {string} The current epoch.
+                @throws Error if an invalid year or a different calendar used. */
+            epoch: function(year) {
+              var date = this._validate(
+                year,
+                this.minMonth,
+                this.minDay,
+                _exports.local.invalidYear || _exports.regionalOptions[""].invalidYear
+              );
+              return date.year() < 0 ? this.local.epochs[0] : this.local.epochs[1];
+            },
+            /** Format the year, if not a simple sequential number
+                @memberof BaseCalendar
+                @param year {CDate|number} The date to format or the year to format.
+                @return {string} The formatted year.
+                @throws Error if an invalid year or a different calendar used. */
+            formatYear: function(year) {
+              var date = this._validate(
+                year,
+                this.minMonth,
+                this.minDay,
+                _exports.local.invalidYear || _exports.regionalOptions[""].invalidYear
+              );
+              return (date.year() < 0 ? "-" : "") + pad(Math.abs(date.year()), 4);
+            },
+            /** Retrieve the number of months in a year.
+                @memberof BaseCalendar
+                @param year {CDate|number} The date to examine or the year to examine.
+                @return {number} The number of months.
+                @throws Error if an invalid year or a different calendar used. */
+            monthsInYear: function(year) {
+              this._validate(
+                year,
+                this.minMonth,
+                this.minDay,
+                _exports.local.invalidYear || _exports.regionalOptions[""].invalidYear
+              );
+              return 12;
+            },
+            /** Calculate the month's ordinal position within the year -
+                for those calendars that don't start at month 1!
+                @memberof BaseCalendar
+                @param year {CDate|number} The date to examine or the year to examine.
+                @param month {number} The month to examine.
+                @return {number} The ordinal position, starting from <code>minMonth</code>.
+                @throws Error if an invalid year/month or a different calendar used. */
+            monthOfYear: function(year, month) {
+              var date = this._validate(
+                year,
+                month,
+                this.minDay,
+                _exports.local.invalidMonth || _exports.regionalOptions[""].invalidMonth
+              );
+              return (date.month() + this.monthsInYear(date) - this.firstMonth) % this.monthsInYear(date) + this.minMonth;
+            },
+            /** Calculate actual month from ordinal position, starting from minMonth.
+                @memberof BaseCalendar
+                @param year {number} The year to examine.
+                @param ord {number} The month's ordinal position.
+                @return {number} The month's number.
+                @throws Error if an invalid year/month. */
+            fromMonthOfYear: function(year, ord) {
+              var m2 = (ord + this.firstMonth - 2 * this.minMonth) % this.monthsInYear(year) + this.minMonth;
+              this._validate(
+                year,
+                m2,
+                this.minDay,
+                _exports.local.invalidMonth || _exports.regionalOptions[""].invalidMonth
+              );
+              return m2;
+            },
+            /** Retrieve the number of days in a year.
+                @memberof BaseCalendar
+                @param year {CDate|number} The date to examine or the year to examine.
+                @return {number} The number of days.
+                @throws Error if an invalid year or a different calendar used. */
+            daysInYear: function(year) {
+              var date = this._validate(
+                year,
+                this.minMonth,
+                this.minDay,
+                _exports.local.invalidYear || _exports.regionalOptions[""].invalidYear
+              );
+              return this.leapYear(date) ? 366 : 365;
+            },
+            /** Retrieve the day of the year for a date.
+                @memberof BaseCalendar
+                @param year {CDate|number} The date to convert or the year to convert.
+                @param [month] {number} The month to convert.
+                @param [day] {number} The day to convert.
+                @return {number} The day of the year.
+                @throws Error if an invalid date or a different calendar used. */
+            dayOfYear: function(year, month, day) {
+              var date = this._validate(
+                year,
+                month,
+                day,
+                _exports.local.invalidDate || _exports.regionalOptions[""].invalidDate
+              );
+              return date.toJD() - this.newDate(
+                date.year(),
+                this.fromMonthOfYear(date.year(), this.minMonth),
+                this.minDay
+              ).toJD() + 1;
+            },
+            /** Retrieve the number of days in a week.
+                @memberof BaseCalendar
+                @return {number} The number of days. */
+            daysInWeek: function() {
+              return 7;
+            },
+            /** Retrieve the day of the week for a date.
+                @memberof BaseCalendar
+                @param year {CDate|number} The date to examine or the year to examine.
+                @param [month] {number} The month to examine.
+                @param [day] {number} The day to examine.
+                @return {number} The day of the week: 0 to number of days - 1.
+                @throws Error if an invalid date or a different calendar used. */
+            dayOfWeek: function(year, month, day) {
+              var date = this._validate(
+                year,
+                month,
+                day,
+                _exports.local.invalidDate || _exports.regionalOptions[""].invalidDate
+              );
+              return (Math.floor(this.toJD(date)) + 2) % this.daysInWeek();
+            },
+            /** Retrieve additional information about a date.
+                @memberof BaseCalendar
+                @param year {CDate|number} The date to examine or the year to examine.
+                @param [month] {number} The month to examine.
+                @param [day] {number} The day to examine.
+                @return {object} Additional information - contents depends on calendar.
+                @throws Error if an invalid date or a different calendar used. */
+            extraInfo: function(year, month, day) {
+              this._validate(
+                year,
+                month,
+                day,
+                _exports.local.invalidDate || _exports.regionalOptions[""].invalidDate
+              );
+              return {};
+            },
+            /** Add period(s) to a date.
+                Cater for no year zero.
+                @memberof BaseCalendar
+                @param date {CDate} The starting date.
+                @param offset {number} The number of periods to adjust by.
+                @param period {string} One of 'y' for year, 'm' for month, 'w' for week, 'd' for day.
+                @return {CDate} The updated date.
+                @throws Error if a different calendar used. */
+            add: function(date, offset, period) {
+              this._validate(
+                date,
+                this.minMonth,
+                this.minDay,
+                _exports.local.invalidDate || _exports.regionalOptions[""].invalidDate
+              );
+              return this._correctAdd(date, this._add(date, offset, period), offset, period);
+            },
+            /** Add period(s) to a date.
+                @memberof BaseCalendar
+                @private
+                @param date {CDate} The starting date.
+                @param offset {number} The number of periods to adjust by.
+                @param period {string} One of 'y' for year, 'm' for month, 'w' for week, 'd' for day.
+                @return {CDate} The updated date. */
+            _add: function(date, offset, period) {
+              this._validateLevel++;
+              if (period === "d" || period === "w") {
+                var jd2 = date.toJD() + offset * (period === "w" ? this.daysInWeek() : 1);
+                var d2 = date.calendar().fromJD(jd2);
+                this._validateLevel--;
+                return [d2.year(), d2.month(), d2.day()];
+              }
+              try {
+                var y2 = date.year() + (period === "y" ? offset : 0);
+                var m2 = date.monthOfYear() + (period === "m" ? offset : 0);
+                var d2 = date.day();
+                var resyncYearMonth = function(calendar) {
+                  while (m2 < calendar.minMonth) {
+                    y2--;
+                    m2 += calendar.monthsInYear(y2);
+                  }
+                  var yearMonths = calendar.monthsInYear(y2);
+                  while (m2 > yearMonths - 1 + calendar.minMonth) {
+                    y2++;
+                    m2 -= yearMonths;
+                    yearMonths = calendar.monthsInYear(y2);
+                  }
+                };
+                if (period === "y") {
+                  if (date.month() !== this.fromMonthOfYear(y2, m2)) {
+                    m2 = this.newDate(y2, date.month(), this.minDay).monthOfYear();
+                  }
+                  m2 = Math.min(m2, this.monthsInYear(y2));
+                  d2 = Math.min(d2, this.daysInMonth(y2, this.fromMonthOfYear(y2, m2)));
+                } else if (period === "m") {
+                  resyncYearMonth(this);
+                  d2 = Math.min(d2, this.daysInMonth(y2, this.fromMonthOfYear(y2, m2)));
+                }
+                var ymd = [y2, this.fromMonthOfYear(y2, m2), d2];
+                this._validateLevel--;
+                return ymd;
+              } catch (e2) {
+                this._validateLevel--;
+                throw e2;
+              }
+            },
+            /** Correct a candidate date after adding period(s) to a date.
+                Handle no year zero if necessary.
+                @memberof BaseCalendar
+                @private
+                @param date {CDate} The starting date.
+                @param ymd {number[]} The added date.
+                @param offset {number} The number of periods to adjust by.
+                @param period {string} One of 'y' for year, 'm' for month, 'w' for week, 'd' for day.
+                @return {CDate} The updated date. */
+            _correctAdd: function(date, ymd, offset, period) {
+              if (!this.hasYearZero && (period === "y" || period === "m")) {
+                if (ymd[0] === 0 || // In year zero
+                date.year() > 0 !== ymd[0] > 0) {
+                  var adj = {
+                    y: [1, 1, "y"],
+                    m: [1, this.monthsInYear(-1), "m"],
+                    w: [this.daysInWeek(), this.daysInYear(-1), "d"],
+                    d: [1, this.daysInYear(-1), "d"]
+                  }[period];
+                  var dir = offset < 0 ? -1 : 1;
+                  ymd = this._add(date, offset * adj[0] + dir * adj[1], adj[2]);
+                }
+              }
+              return date.date(ymd[0], ymd[1], ymd[2]);
+            },
+            /** Set a portion of the date.
+                @memberof BaseCalendar
+                @param date {CDate} The starting date.
+                @param value {number} The new value for the period.
+                @param period {string} One of 'y' for year, 'm' for month, 'd' for day.
+                @return {CDate} The updated date.
+                @throws Error if an invalid date or a different calendar used. */
+            set: function(date, value, period) {
+              this._validate(
+                date,
+                this.minMonth,
+                this.minDay,
+                _exports.local.invalidDate || _exports.regionalOptions[""].invalidDate
+              );
+              var y2 = period === "y" ? value : date.year();
+              var m2 = period === "m" ? value : date.month();
+              var d2 = period === "d" ? value : date.day();
+              if (period === "y" || period === "m") {
+                d2 = Math.min(d2, this.daysInMonth(y2, m2));
+              }
+              return date.date(y2, m2, d2);
+            },
+            /** Determine whether a date is valid for this calendar.
+                @memberof BaseCalendar
+                @param year {number} The year to examine.
+                @param month {number} The month to examine.
+                @param day {number} The day to examine.
+                @return {boolean} <code>true</code> if a valid date, <code>false</code> if not. */
+            isValid: function(year, month, day) {
+              this._validateLevel++;
+              var valid = this.hasYearZero || year !== 0;
+              if (valid) {
+                var date = this.newDate(year, month, this.minDay);
+                valid = month >= this.minMonth && month - this.minMonth < this.monthsInYear(date) && (day >= this.minDay && day - this.minDay < this.daysInMonth(date));
+              }
+              this._validateLevel--;
+              return valid;
+            },
+            /** Convert the date to a standard (Gregorian) JavaScript Date.
+                @memberof BaseCalendar
+                @param year {CDate|number} The date to convert or the year to convert.
+                @param [month] {number} The month to convert.
+                @param [day] {number} The day to convert.
+                @return {Date} The equivalent JavaScript date.
+                @throws Error if an invalid date or a different calendar used. */
+            toJSDate: function(year, month, day) {
+              var date = this._validate(
+                year,
+                month,
+                day,
+                _exports.local.invalidDate || _exports.regionalOptions[""].invalidDate
+              );
+              return _exports.instance().fromJD(this.toJD(date)).toJSDate();
+            },
+            /** Convert the date from a standard (Gregorian) JavaScript Date.
+                @memberof BaseCalendar
+                @param jsd {Date} The JavaScript date.
+                @return {CDate} The equivalent calendar date. */
+            fromJSDate: function(jsd) {
+              return this.fromJD(_exports.instance().fromJSDate(jsd).toJD());
+            },
+            /** Check that a candidate date is from the same calendar and is valid.
+                @memberof BaseCalendar
+                @private
+                @param year {CDate|number} The date to validate or the year to validate.
+                @param [month] {number} The month to validate.
+                @param [day] {number} The day to validate.
+                @param error {string} Rrror message if invalid.
+                @throws Error if different calendars used or invalid date. */
+            _validate: function(year, month, day, error) {
+              if (year.year) {
+                if (this._validateLevel === 0 && this.name !== year.calendar().name) {
+                  throw (_exports.local.differentCalendars || _exports.regionalOptions[""].differentCalendars).replace(/\{0\}/, this.local.name).replace(/\{1\}/, year.calendar().local.name);
+                }
+                return year;
+              }
+              try {
+                this._validateLevel++;
+                if (this._validateLevel === 1 && !this.isValid(year, month, day)) {
+                  throw error.replace(/\{0\}/, this.local.name);
+                }
+                var date = this.newDate(year, month, day);
+                this._validateLevel--;
+                return date;
+              } catch (e2) {
+                this._validateLevel--;
+                throw e2;
+              }
+            }
+          });
+          function GregorianCalendar(language) {
+            this.local = this.regionalOptions[language] || this.regionalOptions[""];
+          }
+          GregorianCalendar.prototype = new BaseCalendar();
+          assign(GregorianCalendar.prototype, {
+            /** The calendar name.
+                @memberof GregorianCalendar */
+            name: "Gregorian",
+            /** Julian date of start of Gregorian epoch: 1 January 0001 CE.
+               @memberof GregorianCalendar */
+            jdEpoch: 17214255e-1,
+            /** Days per month in a common year.
+               @memberof GregorianCalendar */
+            daysPerMonth: [31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31],
+            /** <code>true</code> if has a year zero, <code>false</code> if not.
+               @memberof GregorianCalendar */
+            hasYearZero: false,
+            /** The minimum month number.
+                @memberof GregorianCalendar */
+            minMonth: 1,
+            /** The first month in the year.
+                @memberof GregorianCalendar */
+            firstMonth: 1,
+            /** The minimum day number.
+               @memberof GregorianCalendar */
+            minDay: 1,
+            /** Localisations for the plugin.
+                Entries are objects indexed by the language code ('' being the default US/English).
+                Each object has the following attributes.
+                @memberof GregorianCalendar
+                @property name {string} The calendar name.
+                @property epochs {string[]} The epoch names.
+                @property monthNames {string[]} The long names of the months of the year.
+                @property monthNamesShort {string[]} The short names of the months of the year.
+                @property dayNames {string[]} The long names of the days of the week.
+                @property dayNamesShort {string[]} The short names of the days of the week.
+                @property dayNamesMin {string[]} The minimal names of the days of the week.
+                @property dateFormat {string} The date format for this calendar.
+                        See the options on <a href="BaseCalendar.html#formatDate"><code>formatDate</code></a> for details.
+                @property firstDay {number} The number of the first day of the week, starting at 0.
+                @property isRTL {number} <code>true</code> if this localisation reads right-to-left. */
+            regionalOptions: {
+              // Localisations
+              "": {
+                name: "Gregorian",
+                epochs: ["BCE", "CE"],
+                monthNames: [
+                  "January",
+                  "February",
+                  "March",
+                  "April",
+                  "May",
+                  "June",
+                  "July",
+                  "August",
+                  "September",
+                  "October",
+                  "November",
+                  "December"
+                ],
+                monthNamesShort: ["Jan", "Feb", "Mar", "Apr", "May", "Jun", "Jul", "Aug", "Sep", "Oct", "Nov", "Dec"],
+                dayNames: ["Sunday", "Monday", "Tuesday", "Wednesday", "Thursday", "Friday", "Saturday"],
+                dayNamesShort: ["Sun", "Mon", "Tue", "Wed", "Thu", "Fri", "Sat"],
+                dayNamesMin: ["Su", "Mo", "Tu", "We", "Th", "Fr", "Sa"],
+                digits: null,
+                dateFormat: "mm/dd/yyyy",
+                firstDay: 0,
+                isRTL: false
+              }
+            },
+            /** Determine whether this date is in a leap year.
+                @memberof GregorianCalendar
+                @param year {CDate|number} The date to examine or the year to examine.
+                @return {boolean} <code>true</code> if this is a leap year, <code>false</code> if not.
+                @throws Error if an invalid year or a different calendar used. */
+            leapYear: function(year) {
+              var date = this._validate(
+                year,
+                this.minMonth,
+                this.minDay,
+                _exports.local.invalidYear || _exports.regionalOptions[""].invalidYear
+              );
+              var year = date.year() + (date.year() < 0 ? 1 : 0);
+              return year % 4 === 0 && (year % 100 !== 0 || year % 400 === 0);
+            },
+            /** Determine the week of the year for a date - ISO 8601.
+                @memberof GregorianCalendar
+                @param year {CDate|number} The date to examine or the year to examine.
+                @param [month] {number} The month to examine.
+                @param [day] {number} The day to examine.
+                @return {number} The week of the year, starting from 1.
+                @throws Error if an invalid date or a different calendar used. */
+            weekOfYear: function(year, month, day) {
+              var checkDate = this.newDate(year, month, day);
+              checkDate.add(4 - (checkDate.dayOfWeek() || 7), "d");
+              return Math.floor((checkDate.dayOfYear() - 1) / 7) + 1;
+            },
+            /** Retrieve the number of days in a month.
+                @memberof GregorianCalendar
+                @param year {CDate|number} The date to examine or the year of the month.
+                @param [month] {number} The month.
+                @return {number} The number of days in this month.
+                @throws Error if an invalid month/year or a different calendar used. */
+            daysInMonth: function(year, month) {
+              var date = this._validate(
+                year,
+                month,
+                this.minDay,
+                _exports.local.invalidMonth || _exports.regionalOptions[""].invalidMonth
+              );
+              return this.daysPerMonth[date.month() - 1] + (date.month() === 2 && this.leapYear(date.year()) ? 1 : 0);
+            },
+            /** Determine whether this date is a week day.
+                @memberof GregorianCalendar
+                @param year {CDate|number} The date to examine or the year to examine.
+                @param [month] {number} The month to examine.
+                @param [day] {number} The day to examine.
+                @return {boolean} <code>true</code> if a week day, <code>false</code> if not.
+                @throws Error if an invalid date or a different calendar used. */
+            weekDay: function(year, month, day) {
+              return (this.dayOfWeek(year, month, day) || 7) < 6;
+            },
+            /** Retrieve the Julian date equivalent for this date,
+                i.e. days since January 1, 4713 BCE Greenwich noon.
+                @memberof GregorianCalendar
+                @param year {CDate|number} The date to convert or the year to convert.
+                @param [month] {number} The month to convert.
+                @param [day] {number} The day to convert.
+                @return {number} The equivalent Julian date.
+                @throws Error if an invalid date or a different calendar used. */
+            toJD: function(year, month, day) {
+              var date = this._validate(
+                year,
+                month,
+                day,
+                _exports.local.invalidDate || _exports.regionalOptions[""].invalidDate
+              );
+              year = date.year();
+              month = date.month();
+              day = date.day();
+              if (year < 0) {
+                year++;
+              }
+              if (month < 3) {
+                month += 12;
+                year--;
+              }
+              var a2 = Math.floor(year / 100);
+              var b2 = 2 - a2 + Math.floor(a2 / 4);
+              return Math.floor(365.25 * (year + 4716)) + Math.floor(30.6001 * (month + 1)) + day + b2 - 1524.5;
+            },
+            /** Create a new date from a Julian date.
+                @memberof GregorianCalendar
+                @param jd {number} The Julian date to convert.
+                @return {CDate} The equivalent date. */
+            fromJD: function(jd2) {
+              var z2 = Math.floor(jd2 + 0.5);
+              var a2 = Math.floor((z2 - 186721625e-2) / 36524.25);
+              a2 = z2 + 1 + a2 - Math.floor(a2 / 4);
+              var b2 = a2 + 1524;
+              var c2 = Math.floor((b2 - 122.1) / 365.25);
+              var d2 = Math.floor(365.25 * c2);
+              var e2 = Math.floor((b2 - d2) / 30.6001);
+              var day = b2 - d2 - Math.floor(e2 * 30.6001);
+              var month = e2 - (e2 > 13.5 ? 13 : 1);
+              var year = c2 - (month > 2.5 ? 4716 : 4715);
+              if (year <= 0) {
+                year--;
+              }
+              return this.newDate(year, month, day);
+            },
+            /** Convert this date to a standard (Gregorian) JavaScript Date.
+                @memberof GregorianCalendar
+                @param year {CDate|number} The date to convert or the year to convert.
+                @param [month] {number} The month to convert.
+                @param [day] {number} The day to convert.
+                @return {Date} The equivalent JavaScript date.
+                @throws Error if an invalid date or a different calendar used. */
+            toJSDate: function(year, month, day) {
+              var date = this._validate(
+                year,
+                month,
+                day,
+                _exports.local.invalidDate || _exports.regionalOptions[""].invalidDate
+              );
+              var jsd = new Date(date.year(), date.month() - 1, date.day());
+              jsd.setHours(0);
+              jsd.setMinutes(0);
+              jsd.setSeconds(0);
+              jsd.setMilliseconds(0);
+              jsd.setHours(jsd.getHours() > 12 ? jsd.getHours() + 2 : 0);
+              return jsd;
+            },
+            /** Create a new date from a standard (Gregorian) JavaScript Date.
+                @memberof GregorianCalendar
+                @param jsd {Date} The JavaScript date to convert.
+                @return {CDate} The equivalent date. */
+            fromJSDate: function(jsd) {
+              return this.newDate(jsd.getFullYear(), jsd.getMonth() + 1, jsd.getDate());
+            }
+          });
+          var _exports = module2.exports = new Calendars();
+          _exports.cdate = CDate;
+          _exports.baseCalendar = BaseCalendar;
+          _exports.calendars.gregorian = GregorianCalendar;
+        }
+      });
+      var require_plus = __commonJS({
+        "node_modules/world-calendars/dist/plus.js"() {
+          var assign = require_object_assign();
+          var main = require_main();
+          assign(main.regionalOptions[""], {
+            invalidArguments: "Invalid arguments",
+            invalidFormat: "Cannot format a date from another calendar",
+            missingNumberAt: "Missing number at position {0}",
+            unknownNameAt: "Unknown name at position {0}",
+            unexpectedLiteralAt: "Unexpected literal at position {0}",
+            unexpectedText: "Additional text found at end"
+          });
+          main.local = main.regionalOptions[""];
+          assign(main.cdate.prototype, {
+            /** Format this date.
+                Found in the <code>jquery.calendars.plus.js</code> module.
+                @memberof CDate
+                @param [format] {string} The date format to use (see <a href="BaseCalendar.html#formatDate"><code>formatDate</code></a>).
+                @param [settings] {object} Options for the <code>formatDate</code> function.
+                @return {string} The formatted date. */
+            formatDate: function(format, settings) {
+              if (typeof format !== "string") {
+                settings = format;
+                format = "";
+              }
+              return this._calendar.formatDate(format || "", this, settings);
+            }
+          });
+          assign(main.baseCalendar.prototype, {
+            UNIX_EPOCH: main.instance().newDate(1970, 1, 1).toJD(),
+            SECS_PER_DAY: 24 * 60 * 60,
+            TICKS_EPOCH: main.instance().jdEpoch,
+            // 1 January 0001 CE
+            TICKS_PER_DAY: 24 * 60 * 60 * 1e7,
+            /** Date form for ATOM (RFC 3339/ISO 8601).
+                Found in the <code>jquery.calendars.plus.js</code> module.
+                @memberof BaseCalendar */
+            ATOM: "yyyy-mm-dd",
+            /** Date form for cookies.
+                Found in the <code>jquery.calendars.plus.js</code> module.
+                @memberof BaseCalendar */
+            COOKIE: "D, dd M yyyy",
+            /** Date form for full date.
+                Found in the <code>jquery.calendars.plus.js</code> module.
+                @memberof BaseCalendar */
+            FULL: "DD, MM d, yyyy",
+            /** Date form for ISO 8601.
+                Found in the <code>jquery.calendars.plus.js</code> module.
+                @memberof BaseCalendar */
+            ISO_8601: "yyyy-mm-dd",
+            /** Date form for Julian date.
+                Found in the <code>jquery.calendars.plus.js</code> module.
+                @memberof BaseCalendar */
+            JULIAN: "J",
+            /** Date form for RFC 822.
+                Found in the <code>jquery.calendars.plus.js</code> module.
+                @memberof BaseCalendar */
+            RFC_822: "D, d M yy",
+            /** Date form for RFC 850.
+                Found in the <code>jquery.calendars.plus.js</code> module.
+                @memberof BaseCalendar */
+            RFC_850: "DD, dd-M-yy",
+            /** Date form for RFC 1036.
+                Found in the <code>jquery.calendars.plus.js</code> module.
+                @memberof BaseCalendar */
+            RFC_1036: "D, d M yy",
+            /** Date form for RFC 1123.
+                Found in the <code>jquery.calendars.plus.js</code> module.
+                @memberof BaseCalendar */
+            RFC_1123: "D, d M yyyy",
+            /** Date form for RFC 2822.
+                Found in the <code>jquery.calendars.plus.js</code> module.
+                @memberof BaseCalendar */
+            RFC_2822: "D, d M yyyy",
+            /** Date form for RSS (RFC 822).
+                Found in the <code>jquery.calendars.plus.js</code> module.
+                @memberof BaseCalendar */
+            RSS: "D, d M yy",
+            /** Date form for Windows ticks.
+                Found in the <code>jquery.calendars.plus.js</code> module.
+                @memberof BaseCalendar */
+            TICKS: "!",
+            /** Date form for Unix timestamp.
+                Found in the <code>jquery.calendars.plus.js</code> module.
+                @memberof BaseCalendar */
+            TIMESTAMP: "@",
+            /** Date form for W3c (ISO 8601).
+                Found in the <code>jquery.calendars.plus.js</code> module.
+                @memberof BaseCalendar */
+            W3C: "yyyy-mm-dd",
+            /** Format a date object into a string value.
+                The format can be combinations of the following:
+                <ul>
+                <li>d  - day of month (no leading zero)</li>
+                <li>dd - day of month (two digit)</li>
+                <li>o  - day of year (no leading zeros)</li>
+                <li>oo - day of year (three digit)</li>
+                <li>D  - day name short</li>
+                <li>DD - day name long</li>
+                <li>w  - week of year (no leading zero)</li>
+                <li>ww - week of year (two digit)</li>
+                <li>m  - month of year (no leading zero)</li>
+                <li>mm - month of year (two digit)</li>
+                <li>M  - month name short</li>
+                <li>MM - month name long</li>
+                <li>yy - year (two digit)</li>
+                <li>yyyy - year (four digit)</li>
+                <li>YYYY - formatted year</li>
+                <li>J  - Julian date (days since January 1, 4713 BCE Greenwich noon)</li>
+                <li>@  - Unix timestamp (s since 01/01/1970)</li>
+                <li>!  - Windows ticks (100ns since 01/01/0001)</li>
+                <li>'...' - literal text</li>
+                <li>'' - single quote</li>
+                </ul>
+                Found in the <code>jquery.calendars.plus.js</code> module.
+                @memberof BaseCalendar
+                @param [format] {string} The desired format of the date (defaults to calendar format).
+                @param date {CDate} The date value to format.
+                @param [settings] {object} Addition options, whose attributes include:
+                @property [dayNamesShort] {string[]} Abbreviated names of the days from Sunday.
+                @property [dayNames] {string[]} Names of the days from Sunday.
+                @property [monthNamesShort] {string[]} Abbreviated names of the months.
+                @property [monthNames] {string[]} Names of the months.
+                @property [calculateWeek] {CalendarsPickerCalculateWeek} Function that determines week of the year.
+                @property [localNumbers=false] {boolean} <code>true</code> to localise numbers (if available),
+                          <code>false</code> to use normal Arabic numerals.
+                @return {string} The date in the above format.
+                @throws Errors if the date is from a different calendar. */
+            formatDate: function(format, date, settings) {
+              if (typeof format !== "string") {
+                settings = date;
+                date = format;
+                format = "";
+              }
+              if (!date) {
+                return "";
+              }
+              if (date.calendar() !== this) {
+                throw main.local.invalidFormat || main.regionalOptions[""].invalidFormat;
+              }
+              format = format || this.local.dateFormat;
+              settings = settings || {};
+              var dayNamesShort = settings.dayNamesShort || this.local.dayNamesShort;
+              var dayNames = settings.dayNames || this.local.dayNames;
+              var monthNumbers = settings.monthNumbers || this.local.monthNumbers;
+              var monthNamesShort = settings.monthNamesShort || this.local.monthNamesShort;
+              var monthNames = settings.monthNames || this.local.monthNames;
+              settings.calculateWeek || this.local.calculateWeek;
+              var doubled = function(match, step) {
+                var matches2 = 1;
+                while (iFormat + matches2 < format.length && format.charAt(iFormat + matches2) === match) {
+                  matches2++;
+                }
+                iFormat += matches2 - 1;
+                return Math.floor(matches2 / (step || 1)) > 1;
+              };
+              var formatNumber = function(match, value, len2, step) {
+                var num = "" + value;
+                if (doubled(match, step)) {
+                  while (num.length < len2) {
+                    num = "0" + num;
+                  }
+                }
+                return num;
+              };
+              var formatName = function(match, value, shortNames, longNames) {
+                return doubled(match) ? longNames[value] : shortNames[value];
+              };
+              var calendar = this;
+              var formatMonth = function(date2) {
+                return typeof monthNumbers === "function" ? monthNumbers.call(calendar, date2, doubled("m")) : localiseNumbers(formatNumber("m", date2.month(), 2));
+              };
+              var formatMonthName = function(date2, useLongName) {
+                if (useLongName) {
+                  return typeof monthNames === "function" ? monthNames.call(calendar, date2) : monthNames[date2.month() - calendar.minMonth];
+                } else {
+                  return typeof monthNamesShort === "function" ? monthNamesShort.call(calendar, date2) : monthNamesShort[date2.month() - calendar.minMonth];
+                }
+              };
+              var digits = this.local.digits;
+              var localiseNumbers = function(value) {
+                return settings.localNumbers && digits ? digits(value) : value;
+              };
+              var output = "";
+              var literal = false;
+              for (var iFormat = 0; iFormat < format.length; iFormat++) {
+                if (literal) {
+                  if (format.charAt(iFormat) === "'" && !doubled("'")) {
+                    literal = false;
+                  } else {
+                    output += format.charAt(iFormat);
+                  }
+                } else {
+                  switch (format.charAt(iFormat)) {
+                    case "d":
+                      output += localiseNumbers(formatNumber("d", date.day(), 2));
+                      break;
+                    case "D":
+                      output += formatName(
+                        "D",
+                        date.dayOfWeek(),
+                        dayNamesShort,
+                        dayNames
+                      );
+                      break;
+                    case "o":
+                      output += formatNumber("o", date.dayOfYear(), 3);
+                      break;
+                    case "w":
+                      output += formatNumber("w", date.weekOfYear(), 2);
+                      break;
+                    case "m":
+                      output += formatMonth(date);
+                      break;
+                    case "M":
+                      output += formatMonthName(date, doubled("M"));
+                      break;
+                    case "y":
+                      output += doubled("y", 2) ? date.year() : (date.year() % 100 < 10 ? "0" : "") + date.year() % 100;
+                      break;
+                    case "Y":
+                      doubled("Y", 2);
+                      output += date.formatYear();
+                      break;
+                    case "J":
+                      output += date.toJD();
+                      break;
+                    case "@":
+                      output += (date.toJD() - this.UNIX_EPOCH) * this.SECS_PER_DAY;
+                      break;
+                    case "!":
+                      output += (date.toJD() - this.TICKS_EPOCH) * this.TICKS_PER_DAY;
+                      break;
+                    case "'":
+                      if (doubled("'")) {
+                        output += "'";
+                      } else {
+                        literal = true;
+                      }
+                      break;
+                    default:
+                      output += format.charAt(iFormat);
+                  }
+                }
+              }
+              return output;
+            },
+            /** Parse a string value into a date object.
+                See <a href="#formatDate"><code>formatDate</code></a> for the possible formats, plus:
+                <ul>
+                <li>* - ignore rest of string</li>
+                </ul>
+                Found in the <code>jquery.calendars.plus.js</code> module.
+                @memberof BaseCalendar
+                @param format {string} The expected format of the date ('' for default calendar format).
+                @param value {string} The date in the above format.
+                @param [settings] {object} Additional options whose attributes include:
+                @property [shortYearCutoff] {number} The cutoff year for determining the century.
+                @property [dayNamesShort] {string[]} Abbreviated names of the days from Sunday.
+                @property [dayNames] {string[]} Names of the days from Sunday.
+                @property [monthNamesShort] {string[]} Abbreviated names of the months.
+                @property [monthNames] {string[]} Names of the months.
+                @return {CDate} The extracted date value or <code>null</code> if value is blank.
+                @throws Errors if the format and/or value are missing,
+                        if the value doesn't match the format, or if the date is invalid. */
+            parseDate: function(format, value, settings) {
+              if (value == null) {
+                throw main.local.invalidArguments || main.regionalOptions[""].invalidArguments;
+              }
+              value = typeof value === "object" ? value.toString() : value + "";
+              if (value === "") {
+                return null;
+              }
+              format = format || this.local.dateFormat;
+              settings = settings || {};
+              var shortYearCutoff = settings.shortYearCutoff || this.shortYearCutoff;
+              shortYearCutoff = typeof shortYearCutoff !== "string" ? shortYearCutoff : this.today().year() % 100 + parseInt(shortYearCutoff, 10);
+              var dayNamesShort = settings.dayNamesShort || this.local.dayNamesShort;
+              var dayNames = settings.dayNames || this.local.dayNames;
+              var parseMonth = settings.parseMonth || this.local.parseMonth;
+              var monthNumbers = settings.monthNumbers || this.local.monthNumbers;
+              var monthNamesShort = settings.monthNamesShort || this.local.monthNamesShort;
+              var monthNames = settings.monthNames || this.local.monthNames;
+              var jd2 = -1;
+              var year = -1;
+              var month = -1;
+              var day = -1;
+              var doy = -1;
+              var shortYear = false;
+              var literal = false;
+              var doubled = function(match, step) {
+                var matches2 = 1;
+                while (iFormat + matches2 < format.length && format.charAt(iFormat + matches2) === match) {
+                  matches2++;
+                }
+                iFormat += matches2 - 1;
+                return Math.floor(matches2 / (step || 1)) > 1;
+              };
+              var getNumber = function(match, step) {
+                var isDoubled = doubled(match, step);
+                var size = [2, 3, isDoubled ? 4 : 2, isDoubled ? 4 : 2, 10, 11, 20]["oyYJ@!".indexOf(match) + 1];
+                var digits = new RegExp("^-?\\d{1," + size + "}");
+                var num = value.substring(iValue).match(digits);
+                if (!num) {
+                  throw (main.local.missingNumberAt || main.regionalOptions[""].missingNumberAt).replace(/\{0\}/, iValue);
+                }
+                iValue += num[0].length;
+                return parseInt(num[0], 10);
+              };
+              var calendar = this;
+              var getMonthNumber = function() {
+                if (typeof monthNumbers === "function") {
+                  doubled("m");
+                  var month2 = monthNumbers.call(calendar, value.substring(iValue));
+                  iValue += month2.length;
+                  return month2;
+                }
+                return getNumber("m");
+              };
+              var getName = function(match, shortNames, longNames, step) {
+                var names2 = doubled(match, step) ? longNames : shortNames;
+                for (var i2 = 0; i2 < names2.length; i2++) {
+                  if (value.substr(iValue, names2[i2].length).toLowerCase() === names2[i2].toLowerCase()) {
+                    iValue += names2[i2].length;
+                    return i2 + calendar.minMonth;
+                  }
+                }
+                throw (main.local.unknownNameAt || main.regionalOptions[""].unknownNameAt).replace(/\{0\}/, iValue);
+              };
+              var getMonthName = function() {
+                if (typeof monthNames === "function") {
+                  var month2 = doubled("M") ? monthNames.call(calendar, value.substring(iValue)) : monthNamesShort.call(calendar, value.substring(iValue));
+                  iValue += month2.length;
+                  return month2;
+                }
+                return getName("M", monthNamesShort, monthNames);
+              };
+              var checkLiteral = function() {
+                if (value.charAt(iValue) !== format.charAt(iFormat)) {
+                  throw (main.local.unexpectedLiteralAt || main.regionalOptions[""].unexpectedLiteralAt).replace(/\{0\}/, iValue);
+                }
+                iValue++;
+              };
+              var iValue = 0;
+              for (var iFormat = 0; iFormat < format.length; iFormat++) {
+                if (literal) {
+                  if (format.charAt(iFormat) === "'" && !doubled("'")) {
+                    literal = false;
+                  } else {
+                    checkLiteral();
+                  }
+                } else {
+                  switch (format.charAt(iFormat)) {
+                    case "d":
+                      day = getNumber("d");
+                      break;
+                    case "D":
+                      getName("D", dayNamesShort, dayNames);
+                      break;
+                    case "o":
+                      doy = getNumber("o");
+                      break;
+                    case "w":
+                      getNumber("w");
+                      break;
+                    case "m":
+                      month = getMonthNumber();
+                      break;
+                    case "M":
+                      month = getMonthName();
+                      break;
+                    case "y":
+                      var iSave = iFormat;
+                      shortYear = !doubled("y", 2);
+                      iFormat = iSave;
+                      year = getNumber("y", 2);
+                      break;
+                    case "Y":
+                      year = getNumber("Y", 2);
+                      break;
+                    case "J":
+                      jd2 = getNumber("J") + 0.5;
+                      if (value.charAt(iValue) === ".") {
+                        iValue++;
+                        getNumber("J");
+                      }
+                      break;
+                    case "@":
+                      jd2 = getNumber("@") / this.SECS_PER_DAY + this.UNIX_EPOCH;
+                      break;
+                    case "!":
+                      jd2 = getNumber("!") / this.TICKS_PER_DAY + this.TICKS_EPOCH;
+                      break;
+                    case "*":
+                      iValue = value.length;
+                      break;
+                    case "'":
+                      if (doubled("'")) {
+                        checkLiteral();
+                      } else {
+                        literal = true;
+                      }
+                      break;
+                    default:
+                      checkLiteral();
+                  }
+                }
+              }
+              if (iValue < value.length) {
+                throw main.local.unexpectedText || main.regionalOptions[""].unexpectedText;
+              }
+              if (year === -1) {
+                year = this.today().year();
+              } else if (year < 100 && shortYear) {
+                year += shortYearCutoff === -1 ? 1900 : this.today().year() - this.today().year() % 100 - (year <= shortYearCutoff ? 0 : 100);
+              }
+              if (typeof month === "string") {
+                month = parseMonth.call(this, year, month);
+              }
+              if (doy > -1) {
+                month = 1;
+                day = doy;
+                for (var dim = this.daysInMonth(year, month); day > dim; dim = this.daysInMonth(year, month)) {
+                  month++;
+                  day -= dim;
+                }
+              }
+              return jd2 > -1 ? this.fromJD(jd2) : this.newDate(year, month, day);
+            },
+            /** A date may be specified as an exact value or a relative one.
+                Found in the <code>jquery.calendars.plus.js</code> module.
+                @memberof BaseCalendar
+                @param dateSpec {CDate|number|string} The date as an object or string in the given format or
+                        an offset - numeric days from today, or string amounts and periods, e.g. '+1m +2w'.
+                @param defaultDate {CDate} The date to use if no other supplied, may be <code>null</code>.
+                @param currentDate {CDate} The current date as a possible basis for relative dates,
+                        if <code>null</code> today is used (optional)
+                @param [dateFormat] {string} The expected date format - see <a href="#formatDate"><code>formatDate</code></a>.
+                @param [settings] {object} Additional options whose attributes include:
+                @property [shortYearCutoff] {number} The cutoff year for determining the century.
+                @property [dayNamesShort] {string[]} Abbreviated names of the days from Sunday.
+                @property [dayNames] {string[]} Names of the days from Sunday.
+                @property [monthNamesShort] {string[]} Abbreviated names of the months.
+                @property [monthNames] {string[]} Names of the months.
+                @return {CDate} The decoded date. */
+            determineDate: function(dateSpec, defaultDate, currentDate, dateFormat, settings) {
+              if (currentDate && typeof currentDate !== "object") {
+                settings = dateFormat;
+                dateFormat = currentDate;
+                currentDate = null;
+              }
+              if (typeof dateFormat !== "string") {
+                settings = dateFormat;
+                dateFormat = "";
+              }
+              var calendar = this;
+              var offsetString = function(offset) {
+                try {
+                  return calendar.parseDate(dateFormat, offset, settings);
+                } catch (e2) {
+                }
+                offset = offset.toLowerCase();
+                var date = (offset.match(/^c/) && currentDate ? currentDate.newDate() : null) || calendar.today();
+                var pattern = /([+-]?[0-9]+)\s*(d|w|m|y)?/g;
+                var matches2 = pattern.exec(offset);
+                while (matches2) {
+                  date.add(parseInt(matches2[1], 10), matches2[2] || "d");
+                  matches2 = pattern.exec(offset);
+                }
+                return date;
+              };
+              defaultDate = defaultDate ? defaultDate.newDate() : null;
+              dateSpec = dateSpec == null ? defaultDate : typeof dateSpec === "string" ? offsetString(dateSpec) : typeof dateSpec === "number" ? isNaN(dateSpec) || dateSpec === Infinity || dateSpec === -Infinity ? defaultDate : calendar.today().add(dateSpec, "d") : calendar.newDate(dateSpec);
+              return dateSpec;
+            }
+          });
+        }
+      });
+      var require_chinese = __commonJS({
+        "node_modules/world-calendars/dist/calendars/chinese.js"() {
+          var main = require_main();
+          var assign = require_object_assign();
+          var gregorianCalendar = main.instance();
+          function ChineseCalendar(language) {
+            this.local = this.regionalOptions[language || ""] || this.regionalOptions[""];
+          }
+          ChineseCalendar.prototype = new main.baseCalendar();
+          assign(ChineseCalendar.prototype, {
+            /** The calendar name.
+                @memberof ChineseCalendar */
+            name: "Chinese",
+            /** Julian date of start of Gregorian epoch: 1 January 0001 CE.
+               @memberof GregorianCalendar */
+            jdEpoch: 17214255e-1,
+            /** <code>true</code> if has a year zero, <code>false</code> if not.
+                @memberof ChineseCalendar */
+            hasYearZero: false,
+            /** The minimum month number.
+                This calendar uses month indices to account for intercalary months.
+                @memberof ChineseCalendar */
+            minMonth: 0,
+            /** The first month in the year.
+                This calendar uses month indices to account for intercalary months.
+                @memberof ChineseCalendar */
+            firstMonth: 0,
+            /** The minimum day number.
+                @memberof ChineseCalendar */
+            minDay: 1,
+            /** Localisations for the plugin.
+                Entries are objects indexed by the language code ('' being the default US/English).
+                Each object has the following attributes.
+                @memberof ChineseCalendar
+                @property name {string} The calendar name.
+                @property epochs {string[]} The epoch names.
+                @property monthNames {string[]} The long names of the months of the year.
+                @property monthNamesShort {string[]} The short names of the months of the year.
+                @property dayNames {string[]} The long names of the days of the week.
+                @property dayNamesShort {string[]} The short names of the days of the week.
+                @property dayNamesMin {string[]} The minimal names of the days of the week.
+                @property dateFormat {string} The date format for this calendar.
+                        See the options on <a href="BaseCalendar.html#formatDate"><code>formatDate</code></a> for details.
+                @property firstDay {number} The number of the first day of the week, starting at 0.
+                @property isRTL {number} <code>true</code> if this localisation reads right-to-left. */
+            regionalOptions: {
+              // Localisations
+              "": {
+                name: "Chinese",
+                epochs: ["BEC", "EC"],
+                monthNumbers: function(date, padded) {
+                  if (typeof date === "string") {
+                    var match = date.match(MONTH_NUMBER_REGEXP);
+                    return match ? match[0] : "";
+                  }
+                  var year = this._validateYear(date);
+                  var monthIndex = date.month();
+                  var month = "" + this.toChineseMonth(year, monthIndex);
+                  if (padded && month.length < 2) {
+                    month = "0" + month;
+                  }
+                  if (this.isIntercalaryMonth(year, monthIndex)) {
+                    month += "i";
+                  }
+                  return month;
+                },
+                monthNames: function(date) {
+                  if (typeof date === "string") {
+                    var match = date.match(MONTH_NAME_REGEXP);
+                    return match ? match[0] : "";
+                  }
+                  var year = this._validateYear(date);
+                  var monthIndex = date.month();
+                  var month = this.toChineseMonth(year, monthIndex);
+                  var monthName = [
+                    "一月",
+                    "二月",
+                    "三月",
+                    "四月",
+                    "五月",
+                    "六月",
+                    "七月",
+                    "八月",
+                    "九月",
+                    "十月",
+                    "十一月",
+                    "十二月"
+                  ][month - 1];
+                  if (this.isIntercalaryMonth(year, monthIndex)) {
+                    monthName = "闰" + monthName;
+                  }
+                  return monthName;
+                },
+                monthNamesShort: function(date) {
+                  if (typeof date === "string") {
+                    var match = date.match(MONTH_SHORT_NAME_REGEXP);
+                    return match ? match[0] : "";
+                  }
+                  var year = this._validateYear(date);
+                  var monthIndex = date.month();
+                  var month = this.toChineseMonth(year, monthIndex);
+                  var monthName = [
+                    "一",
+                    "二",
+                    "三",
+                    "四",
+                    "五",
+                    "六",
+                    "七",
+                    "八",
+                    "九",
+                    "十",
+                    "十一",
+                    "十二"
+                  ][month - 1];
+                  if (this.isIntercalaryMonth(year, monthIndex)) {
+                    monthName = "闰" + monthName;
+                  }
+                  return monthName;
+                },
+                parseMonth: function(year, monthString) {
+                  year = this._validateYear(year);
+                  var month = parseInt(monthString);
+                  var isIntercalary;
+                  if (!isNaN(month)) {
+                    var i2 = monthString[monthString.length - 1];
+                    isIntercalary = i2 === "i" || i2 === "I";
+                  } else {
+                    if (monthString[0] === "闰") {
+                      isIntercalary = true;
+                      monthString = monthString.substring(1);
+                    }
+                    if (monthString[monthString.length - 1] === "月") {
+                      monthString = monthString.substring(0, monthString.length - 1);
+                    }
+                    month = 1 + [
+                      "一",
+                      "二",
+                      "三",
+                      "四",
+                      "五",
+                      "六",
+                      "七",
+                      "八",
+                      "九",
+                      "十",
+                      "十一",
+                      "十二"
+                    ].indexOf(monthString);
+                  }
+                  var monthIndex = this.toMonthIndex(year, month, isIntercalary);
+                  return monthIndex;
+                },
+                dayNames: ["Sunday", "Monday", "Tuesday", "Wednesday", "Thursday", "Friday", "Saturday"],
+                dayNamesShort: ["Sun", "Mon", "Tue", "Wed", "Thu", "Fri", "Sat"],
+                dayNamesMin: ["Su", "Mo", "Tu", "We", "Th", "Fr", "Sa"],
+                digits: null,
+                dateFormat: "yyyy/mm/dd",
+                firstDay: 1,
+                isRTL: false
+              }
+            },
+            /** Check that a candidate date is from the same calendar and is valid.
+                @memberof BaseCalendar
+                @private
+                @param year {CDate|number} The date or the year to validate.
+                @param error {string} Error message if invalid.
+                @return {number} The year.
+                @throws Error if year out of range. */
+            _validateYear: function(year, error) {
+              if (year.year) {
+                year = year.year();
+              }
+              if (typeof year !== "number" || year < 1888 || year > 2111) {
+                throw error.replace(/\{0\}/, this.local.name);
+              }
+              return year;
+            },
+            /** Retrieve the month index (i.e. accounting for intercalary months).
+                @memberof ChineseCalendar
+                @param year {number} The year.
+                @param month {number} The month (1 for first month).
+                @param [isIntercalary=false] {boolean} If month is intercalary.
+                @return {number} The month index (0 for first month).
+                @throws Error if an invalid month/year or a different calendar used. */
+            toMonthIndex: function(year, month, isIntercalary) {
+              var intercalaryMonth = this.intercalaryMonth(year);
+              var invalidIntercalaryMonth = isIntercalary && month !== intercalaryMonth;
+              if (invalidIntercalaryMonth || month < 1 || month > 12) {
+                throw main.local.invalidMonth.replace(/\{0\}/, this.local.name);
+              }
+              var monthIndex;
+              if (!intercalaryMonth) {
+                monthIndex = month - 1;
+              } else if (!isIntercalary && month <= intercalaryMonth) {
+                monthIndex = month - 1;
+              } else {
+                monthIndex = month;
+              }
+              return monthIndex;
+            },
+            /** Retrieve the month (i.e. accounting for intercalary months).
+                @memberof ChineseCalendar
+                @param year {CDate|number} The date or the year to examine.
+                @param monthIndex {number} The month index (0 for first month).
+                @return {number} The month (1 for first month).
+                @throws Error if an invalid month/year or a different calendar used. */
+            toChineseMonth: function(year, monthIndex) {
+              if (year.year) {
+                year = year.year();
+                monthIndex = year.month();
+              }
+              var intercalaryMonth = this.intercalaryMonth(year);
+              var maxMonthIndex = intercalaryMonth ? 12 : 11;
+              if (monthIndex < 0 || monthIndex > maxMonthIndex) {
+                throw main.local.invalidMonth.replace(/\{0\}/, this.local.name);
+              }
+              var month;
+              if (!intercalaryMonth) {
+                month = monthIndex + 1;
+              } else if (monthIndex < intercalaryMonth) {
+                month = monthIndex + 1;
+              } else {
+                month = monthIndex;
+              }
+              return month;
+            },
+            /** Determine the intercalary month of a year (if any).
+                @memberof ChineseCalendar
+                @param year {CDate|number} The date to examine or the year to examine.
+                @return {number} The intercalary month number, or 0 if none.
+                @throws Error if an invalid year or a different calendar used. */
+            intercalaryMonth: function(year) {
+              year = this._validateYear(year);
+              var monthDaysTable = LUNAR_MONTH_DAYS[year - LUNAR_MONTH_DAYS[0]];
+              var intercalaryMonth = monthDaysTable >> 13;
+              return intercalaryMonth;
+            },
+            /** Determine whether this date is an intercalary month.
+                @memberof ChineseCalendar
+                @param year {CDate|number} The date to examine or the year to examine.
+                @param [monthIndex] {number} The month index to examine.
+                @return {boolean} <code>true</code> if this is an intercalary month, <code>false</code> if not.
+                @throws Error if an invalid year or a different calendar used. */
+            isIntercalaryMonth: function(year, monthIndex) {
+              if (year.year) {
+                year = year.year();
+                monthIndex = year.month();
+              }
+              var intercalaryMonth = this.intercalaryMonth(year);
+              return !!intercalaryMonth && intercalaryMonth === monthIndex;
+            },
+            /** Determine whether this date is in a leap year.
+                @memberof ChineseCalendar
+                @param year {CDate|number} The date to examine or the year to examine.
+                @return {boolean} <code>true</code> if this is a leap year, <code>false</code> if not.
+                @throws Error if an invalid year or a different calendar used. */
+            leapYear: function(year) {
+              return this.intercalaryMonth(year) !== 0;
+            },
+            /** Determine the week of the year for a date - ISO 8601.
+                @memberof ChineseCalendar
+                @param year {CDate|number} The date to examine or the year to examine.
+                @param [monthIndex] {number} The month index to examine.
+                @param [day] {number} The day to examine.
+                @return {number} The week of the year.
+                @throws Error if an invalid date or a different calendar used. */
+            weekOfYear: function(year, monthIndex, day) {
+              var validatedYear = this._validateYear(year, main.local.invalidyear);
+              var packedDate = CHINESE_NEW_YEAR[validatedYear - CHINESE_NEW_YEAR[0]];
+              var y2 = packedDate >> 9 & 4095;
+              var m2 = packedDate >> 5 & 15;
+              var d2 = packedDate & 31;
+              var firstThursday;
+              firstThursday = gregorianCalendar.newDate(y2, m2, d2);
+              firstThursday.add(4 - (firstThursday.dayOfWeek() || 7), "d");
+              var offset = this.toJD(year, monthIndex, day) - firstThursday.toJD();
+              return 1 + Math.floor(offset / 7);
+            },
+            /** Retrieve the number of months in a year.
+                @memberof ChineseCalendar
+                @param year {CDate|number} The date to examine or the year to examine.
+                @return {number} The number of months.
+                @throws Error if an invalid year or a different calendar used. */
+            monthsInYear: function(year) {
+              return this.leapYear(year) ? 13 : 12;
+            },
+            /** Retrieve the number of days in a month.
+                @memberof ChineseCalendar
+                @param year {CDate|number} The date to examine or the year of the month.
+                @param [monthIndex] {number} The month index.
+                @return {number} The number of days in this month.
+                @throws Error if an invalid month/year or a different calendar used. */
+            daysInMonth: function(year, monthIndex) {
+              if (year.year) {
+                monthIndex = year.month();
+                year = year.year();
+              }
+              year = this._validateYear(year);
+              var monthDaysTable = LUNAR_MONTH_DAYS[year - LUNAR_MONTH_DAYS[0]];
+              var intercalaryMonth = monthDaysTable >> 13;
+              var maxMonthIndex = intercalaryMonth ? 12 : 11;
+              if (monthIndex > maxMonthIndex) {
+                throw main.local.invalidMonth.replace(/\{0\}/, this.local.name);
+              }
+              var daysInMonth = monthDaysTable & 1 << 12 - monthIndex ? 30 : 29;
+              return daysInMonth;
+            },
+            /** Determine whether this date is a week day.
+                @memberof ChineseCalendar
+                @param year {CDate|number} The date to examine or the year to examine.
+                @param [monthIndex] {number} The month index to examine.
+                @param [day] {number} The day to examine.
+                @return {boolean} <code>true</code> if a week day, <code>false</code> if not.
+                @throws Error if an invalid date or a different calendar used. */
+            weekDay: function(year, monthIndex, day) {
+              return (this.dayOfWeek(year, monthIndex, day) || 7) < 6;
+            },
+            /** Retrieve the Julian date equivalent for this date,
+                i.e. days since January 1, 4713 BCE Greenwich noon.
+                @memberof ChineseCalendar
+                @param year {CDate|number} The date to convert or the year to convert.
+                @param [monthIndex] {number} The month index to convert.
+                @param [day] {number} The day to convert.
+                @return {number} The equivalent Julian date.
+                @throws Error if an invalid date or a different calendar used. */
+            toJD: function(year, monthIndex, day) {
+              var date = this._validate(year, month, day, main.local.invalidDate);
+              year = this._validateYear(date.year());
+              monthIndex = date.month();
+              day = date.day();
+              var isIntercalary = this.isIntercalaryMonth(year, monthIndex);
+              var month = this.toChineseMonth(year, monthIndex);
+              var solar = toSolar(year, month, day, isIntercalary);
+              return gregorianCalendar.toJD(solar.year, solar.month, solar.day);
+            },
+            /** Create a new date from a Julian date.
+                @memberof ChineseCalendar
+                @param jd {number} The Julian date to convert.
+                @return {CDate} The equivalent date. */
+            fromJD: function(jd2) {
+              var date = gregorianCalendar.fromJD(jd2);
+              var lunar = toLunar(date.year(), date.month(), date.day());
+              var monthIndex = this.toMonthIndex(
+                lunar.year,
+                lunar.month,
+                lunar.isIntercalary
+              );
+              return this.newDate(lunar.year, monthIndex, lunar.day);
+            },
+            /** Create a new date from a string.
+                @memberof ChineseCalendar
+                @param dateString {string} String representing a Chinese date
+                @return {CDate} The new date.
+                @throws Error if an invalid date. */
+            fromString: function(dateString) {
+              var match = dateString.match(DATE_REGEXP);
+              var year = this._validateYear(+match[1]);
+              var month = +match[2];
+              var isIntercalary = !!match[3];
+              var monthIndex = this.toMonthIndex(year, month, isIntercalary);
+              var day = +match[4];
+              return this.newDate(year, monthIndex, day);
+            },
+            /** Add period(s) to a date.
+                Cater for no year zero.
+                @memberof ChineseCalendar
+                @param date {CDate} The starting date.
+                @param offset {number} The number of periods to adjust by.
+                @param period {string} One of 'y' for year, 'm' for month, 'w' for week, 'd' for day.
+                @return {CDate} The updated date.
+                @throws Error if a different calendar used. */
+            add: function(date, offset, period) {
+              var year = date.year();
+              var monthIndex = date.month();
+              var isIntercalary = this.isIntercalaryMonth(year, monthIndex);
+              var month = this.toChineseMonth(year, monthIndex);
+              var cdate = Object.getPrototypeOf(ChineseCalendar.prototype).add.call(this, date, offset, period);
+              if (period === "y") {
+                var resultYear = cdate.year();
+                var resultMonthIndex = cdate.month();
+                var resultCanBeIntercalaryMonth = this.isIntercalaryMonth(resultYear, month);
+                var correctedMonthIndex = isIntercalary && resultCanBeIntercalaryMonth ? this.toMonthIndex(resultYear, month, true) : this.toMonthIndex(resultYear, month, false);
+                if (correctedMonthIndex !== resultMonthIndex) {
+                  cdate.month(correctedMonthIndex);
+                }
+              }
+              return cdate;
+            }
+          });
+          var DATE_REGEXP = /^\s*(-?\d\d\d\d|\d\d)[-/](\d?\d)([iI]?)[-/](\d?\d)/m;
+          var MONTH_NUMBER_REGEXP = /^\d?\d[iI]?/m;
+          var MONTH_NAME_REGEXP = /^闰?十?[一二三四五六七八九]?月/m;
+          var MONTH_SHORT_NAME_REGEXP = /^闰?十?[一二三四五六七八九]?/m;
+          main.calendars.chinese = ChineseCalendar;
+          var LUNAR_MONTH_DAYS = [
+            1887,
+            5780,
+            5802,
+            19157,
+            2742,
+            50359,
+            1198,
+            2646,
+            46378,
+            7466,
+            3412,
+            30122,
+            5482,
+            67949,
+            2396,
+            5294,
+            43597,
+            6732,
+            6954,
+            36181,
+            2772,
+            4954,
+            18781,
+            2396,
+            54427,
+            5274,
+            6730,
+            47781,
+            5800,
+            6868,
+            21210,
+            4790,
+            59703,
+            2350,
+            5270,
+            46667,
+            3402,
+            3496,
+            38325,
+            1388,
+            4782,
+            18735,
+            2350,
+            52374,
+            6804,
+            7498,
+            44457,
+            2906,
+            1388,
+            29294,
+            4700,
+            63789,
+            6442,
+            6804,
+            56138,
+            5802,
+            2772,
+            38235,
+            1210,
+            4698,
+            22827,
+            5418,
+            63125,
+            3476,
+            5802,
+            43701,
+            2484,
+            5302,
+            27223,
+            2646,
+            70954,
+            7466,
+            3412,
+            54698,
+            5482,
+            2412,
+            38062,
+            5294,
+            2636,
+            32038,
+            6954,
+            60245,
+            2772,
+            4826,
+            43357,
+            2394,
+            5274,
+            39501,
+            6730,
+            72357,
+            5800,
+            5844,
+            53978,
+            4790,
+            2358,
+            38039,
+            5270,
+            87627,
+            3402,
+            3496,
+            54708,
+            5484,
+            4782,
+            43311,
+            2350,
+            3222,
+            27978,
+            7498,
+            68965,
+            2904,
+            5484,
+            45677,
+            4700,
+            6444,
+            39573,
+            6804,
+            6986,
+            19285,
+            2772,
+            62811,
+            1210,
+            4698,
+            47403,
+            5418,
+            5780,
+            38570,
+            5546,
+            76469,
+            2420,
+            5302,
+            51799,
+            2646,
+            5414,
+            36501,
+            3412,
+            5546,
+            18869,
+            2412,
+            54446,
+            5276,
+            6732,
+            48422,
+            6822,
+            2900,
+            28010,
+            4826,
+            92509,
+            2394,
+            5274,
+            55883,
+            6730,
+            6820,
+            47956,
+            5812,
+            2778,
+            18779,
+            2358,
+            62615,
+            5270,
+            5450,
+            46757,
+            3492,
+            5556,
+            27318,
+            4718,
+            67887,
+            2350,
+            3222,
+            52554,
+            7498,
+            3428,
+            38252,
+            5468,
+            4700,
+            31022,
+            6444,
+            64149,
+            6804,
+            6986,
+            43861,
+            2772,
+            5338,
+            35421,
+            2650,
+            70955,
+            5418,
+            5780,
+            54954,
+            5546,
+            2740,
+            38074,
+            5302,
+            2646,
+            29991,
+            3366,
+            61011,
+            3412,
+            5546,
+            43445,
+            2412,
+            5294,
+            35406,
+            6732,
+            72998,
+            6820,
+            6996,
+            52586,
+            2778,
+            2396,
+            38045,
+            5274,
+            6698,
+            23333,
+            6820,
+            64338,
+            5812,
+            2746,
+            43355,
+            2358,
+            5270,
+            39499,
+            5450,
+            79525,
+            3492,
+            5548
+          ];
+          var CHINESE_NEW_YEAR = [
+            1887,
+            966732,
+            967231,
+            967733,
+            968265,
+            968766,
+            969297,
+            969798,
+            970298,
+            970829,
+            971330,
+            971830,
+            972362,
+            972863,
+            973395,
+            973896,
+            974397,
+            974928,
+            975428,
+            975929,
+            976461,
+            976962,
+            977462,
+            977994,
+            978494,
+            979026,
+            979526,
+            980026,
+            980558,
+            981059,
+            981559,
+            982091,
+            982593,
+            983124,
+            983624,
+            984124,
+            984656,
+            985157,
+            985656,
+            986189,
+            986690,
+            987191,
+            987722,
+            988222,
+            988753,
+            989254,
+            989754,
+            990286,
+            990788,
+            991288,
+            991819,
+            992319,
+            992851,
+            993352,
+            993851,
+            994383,
+            994885,
+            995385,
+            995917,
+            996418,
+            996918,
+            997450,
+            997949,
+            998481,
+            998982,
+            999483,
+            1000014,
+            1000515,
+            1001016,
+            1001548,
+            1002047,
+            1002578,
+            1003080,
+            1003580,
+            1004111,
+            1004613,
+            1005113,
+            1005645,
+            1006146,
+            1006645,
+            1007177,
+            1007678,
+            1008209,
+            1008710,
+            1009211,
+            1009743,
+            1010243,
+            1010743,
+            1011275,
+            1011775,
+            1012306,
+            1012807,
+            1013308,
+            1013840,
+            1014341,
+            1014841,
+            1015373,
+            1015874,
+            1016404,
+            1016905,
+            1017405,
+            1017937,
+            1018438,
+            1018939,
+            1019471,
+            1019972,
+            1020471,
+            1021002,
+            1021503,
+            1022035,
+            1022535,
+            1023036,
+            1023568,
+            1024069,
+            1024568,
+            1025100,
+            1025601,
+            1026102,
+            1026633,
+            1027133,
+            1027666,
+            1028167,
+            1028666,
+            1029198,
+            1029699,
+            1030199,
+            1030730,
+            1031231,
+            1031763,
+            1032264,
+            1032764,
+            1033296,
+            1033797,
+            1034297,
+            1034828,
+            1035329,
+            1035830,
+            1036362,
+            1036861,
+            1037393,
+            1037894,
+            1038394,
+            1038925,
+            1039427,
+            1039927,
+            1040459,
+            1040959,
+            1041491,
+            1041992,
+            1042492,
+            1043023,
+            1043524,
+            1044024,
+            1044556,
+            1045057,
+            1045558,
+            1046090,
+            1046590,
+            1047121,
+            1047622,
+            1048122,
+            1048654,
+            1049154,
+            1049655,
+            1050187,
+            1050689,
+            1051219,
+            1051720,
+            1052220,
+            1052751,
+            1053252,
+            1053752,
+            1054284,
+            1054786,
+            1055285,
+            1055817,
+            1056317,
+            1056849,
+            1057349,
+            1057850,
+            1058382,
+            1058883,
+            1059383,
+            1059915,
+            1060415,
+            1060947,
+            1061447,
+            1061947,
+            1062479,
+            1062981,
+            1063480,
+            1064012,
+            1064514,
+            1065014,
+            1065545,
+            1066045,
+            1066577,
+            1067078,
+            1067578,
+            1068110,
+            1068611,
+            1069112,
+            1069642,
+            1070142,
+            1070674,
+            1071175,
+            1071675,
+            1072207,
+            1072709,
+            1073209,
+            1073740,
+            1074241,
+            1074741,
+            1075273,
+            1075773,
+            1076305,
+            1076807,
+            1077308,
+            1077839,
+            1078340,
+            1078840,
+            1079372,
+            1079871,
+            1080403,
+            1080904
+          ];
+          function toLunar(yearOrDate, monthOrResult, day, result) {
+            var solarDate;
+            var lunarDate;
+            if (typeof yearOrDate === "object") {
+              solarDate = yearOrDate;
+              lunarDate = monthOrResult || {};
+            } else {
+              var isValidYear = typeof yearOrDate === "number" && yearOrDate >= 1888 && yearOrDate <= 2111;
+              if (!isValidYear)
+                throw new Error("Solar year outside range 1888-2111");
+              var isValidMonth = typeof monthOrResult === "number" && monthOrResult >= 1 && monthOrResult <= 12;
+              if (!isValidMonth)
+                throw new Error("Solar month outside range 1 - 12");
+              var isValidDay = typeof day === "number" && day >= 1 && day <= 31;
+              if (!isValidDay)
+                throw new Error("Solar day outside range 1 - 31");
+              solarDate = {
+                year: yearOrDate,
+                month: monthOrResult,
+                day
+              };
+              lunarDate = {};
+            }
+            var chineseNewYearPackedDate = CHINESE_NEW_YEAR[solarDate.year - CHINESE_NEW_YEAR[0]];
+            var packedDate = solarDate.year << 9 | solarDate.month << 5 | solarDate.day;
+            lunarDate.year = packedDate >= chineseNewYearPackedDate ? solarDate.year : solarDate.year - 1;
+            chineseNewYearPackedDate = CHINESE_NEW_YEAR[lunarDate.year - CHINESE_NEW_YEAR[0]];
+            var y2 = chineseNewYearPackedDate >> 9 & 4095;
+            var m2 = chineseNewYearPackedDate >> 5 & 15;
+            var d2 = chineseNewYearPackedDate & 31;
+            var daysFromNewYear;
+            var chineseNewYearJSDate = new Date(y2, m2 - 1, d2);
+            var jsDate = new Date(solarDate.year, solarDate.month - 1, solarDate.day);
+            daysFromNewYear = Math.round(
+              (jsDate - chineseNewYearJSDate) / (24 * 3600 * 1e3)
+            );
+            var monthDaysTable = LUNAR_MONTH_DAYS[lunarDate.year - LUNAR_MONTH_DAYS[0]];
+            var i2;
+            for (i2 = 0; i2 < 13; i2++) {
+              var daysInMonth = monthDaysTable & 1 << 12 - i2 ? 30 : 29;
+              if (daysFromNewYear < daysInMonth) {
+                break;
+              }
+              daysFromNewYear -= daysInMonth;
+            }
+            var intercalaryMonth = monthDaysTable >> 13;
+            if (!intercalaryMonth || i2 < intercalaryMonth) {
+              lunarDate.isIntercalary = false;
+              lunarDate.month = 1 + i2;
+            } else if (i2 === intercalaryMonth) {
+              lunarDate.isIntercalary = true;
+              lunarDate.month = i2;
+            } else {
+              lunarDate.isIntercalary = false;
+              lunarDate.month = i2;
+            }
+            lunarDate.day = 1 + daysFromNewYear;
+            return lunarDate;
+          }
+          function toSolar(yearOrDate, monthOrResult, day, isIntercalaryOrResult, result) {
+            var solarDate;
+            var lunarDate;
+            if (typeof yearOrDate === "object") {
+              lunarDate = yearOrDate;
+              solarDate = monthOrResult || {};
+            } else {
+              var isValidYear = typeof yearOrDate === "number" && yearOrDate >= 1888 && yearOrDate <= 2111;
+              if (!isValidYear)
+                throw new Error("Lunar year outside range 1888-2111");
+              var isValidMonth = typeof monthOrResult === "number" && monthOrResult >= 1 && monthOrResult <= 12;
+              if (!isValidMonth)
+                throw new Error("Lunar month outside range 1 - 12");
+              var isValidDay = typeof day === "number" && day >= 1 && day <= 30;
+              if (!isValidDay)
+                throw new Error("Lunar day outside range 1 - 30");
+              var isIntercalary;
+              if (typeof isIntercalaryOrResult === "object") {
+                isIntercalary = false;
+                solarDate = isIntercalaryOrResult;
+              } else {
+                isIntercalary = !!isIntercalaryOrResult;
+                solarDate = {};
+              }
+              lunarDate = {
+                year: yearOrDate,
+                month: monthOrResult,
+                day,
+                isIntercalary
+              };
+            }
+            var daysFromNewYear;
+            daysFromNewYear = lunarDate.day - 1;
+            var monthDaysTable = LUNAR_MONTH_DAYS[lunarDate.year - LUNAR_MONTH_DAYS[0]];
+            var intercalaryMonth = monthDaysTable >> 13;
+            var monthsFromNewYear;
+            if (!intercalaryMonth) {
+              monthsFromNewYear = lunarDate.month - 1;
+            } else if (lunarDate.month > intercalaryMonth) {
+              monthsFromNewYear = lunarDate.month;
+            } else if (lunarDate.isIntercalary) {
+              monthsFromNewYear = lunarDate.month;
+            } else {
+              monthsFromNewYear = lunarDate.month - 1;
+            }
+            for (var i2 = 0; i2 < monthsFromNewYear; i2++) {
+              var daysInMonth = monthDaysTable & 1 << 12 - i2 ? 30 : 29;
+              daysFromNewYear += daysInMonth;
+            }
+            var packedDate = CHINESE_NEW_YEAR[lunarDate.year - CHINESE_NEW_YEAR[0]];
+            var y2 = packedDate >> 9 & 4095;
+            var m2 = packedDate >> 5 & 15;
+            var d2 = packedDate & 31;
+            var jsDate = new Date(y2, m2 - 1, d2 + daysFromNewYear);
+            solarDate.year = jsDate.getFullYear();
+            solarDate.month = 1 + jsDate.getMonth();
+            solarDate.day = jsDate.getDate();
+            return solarDate;
+          }
+        }
+      });
+      var require_coptic = __commonJS({
+        "node_modules/world-calendars/dist/calendars/coptic.js"() {
+          var main = require_main();
+          var assign = require_object_assign();
+          function CopticCalendar(language) {
+            this.local = this.regionalOptions[language || ""] || this.regionalOptions[""];
+          }
+          CopticCalendar.prototype = new main.baseCalendar();
+          assign(CopticCalendar.prototype, {
+            /** The calendar name.
+                @memberof CopticCalendar */
+            name: "Coptic",
+            /** Julian date of start of Coptic epoch: 29 August 284 CE (Gregorian).
+                @memberof CopticCalendar */
+            jdEpoch: 18250295e-1,
+            /** Days per month in a common year.
+                @memberof CopticCalendar */
+            daysPerMonth: [30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 5],
+            /** <code>true</code> if has a year zero, <code>false</code> if not.
+                @memberof CopticCalendar */
+            hasYearZero: false,
+            /** The minimum month number.
+                @memberof CopticCalendar */
+            minMonth: 1,
+            /** The first month in the year.
+                @memberof CopticCalendar */
+            firstMonth: 1,
+            /** The minimum day number.
+                @memberof CopticCalendar */
+            minDay: 1,
+            /** Localisations for the plugin.
+                Entries are objects indexed by the language code ('' being the default US/English).
+                Each object has the following attributes.
+                @memberof CopticCalendar
+                @property name {string} The calendar name.
+                @property epochs {string[]} The epoch names.
+                @property monthNames {string[]} The long names of the months of the year.
+                @property monthNamesShort {string[]} The short names of the months of the year.
+                @property dayNames {string[]} The long names of the days of the week.
+                @property dayNamesShort {string[]} The short names of the days of the week.
+                @property dayNamesMin {string[]} The minimal names of the days of the week.
+                @property dateFormat {string} The date format for this calendar.
+                        See the options on <a href="BaseCalendar.html#formatDate"><code>formatDate</code></a> for details.
+                @property firstDay {number} The number of the first day of the week, starting at 0.
+                @property isRTL {number} <code>true</code> if this localisation reads right-to-left. */
+            regionalOptions: {
+              // Localisations
+              "": {
+                name: "Coptic",
+                epochs: ["BAM", "AM"],
+                monthNames: [
+                  "Thout",
+                  "Paopi",
+                  "Hathor",
+                  "Koiak",
+                  "Tobi",
+                  "Meshir",
+                  "Paremhat",
+                  "Paremoude",
+                  "Pashons",
+                  "Paoni",
+                  "Epip",
+                  "Mesori",
+                  "Pi Kogi Enavot"
+                ],
+                monthNamesShort: [
+                  "Tho",
+                  "Pao",
+                  "Hath",
+                  "Koi",
+                  "Tob",
+                  "Mesh",
+                  "Pat",
+                  "Pad",
+                  "Pash",
+                  "Pao",
+                  "Epi",
+                  "Meso",
+                  "PiK"
+                ],
+                dayNames: ["Tkyriaka", "Pesnau", "Pshoment", "Peftoou", "Ptiou", "Psoou", "Psabbaton"],
+                dayNamesShort: ["Tky", "Pes", "Psh", "Pef", "Pti", "Pso", "Psa"],
+                dayNamesMin: ["Tk", "Pes", "Psh", "Pef", "Pt", "Pso", "Psa"],
+                digits: null,
+                dateFormat: "dd/mm/yyyy",
+                firstDay: 0,
+                isRTL: false
+              }
+            },
+            /** Determine whether this date is in a leap year.
+                @memberof CopticCalendar
+                @param year {CDate|number} The date to examine or the year to examine.
+                @return {boolean} <code>true</code> if this is a leap year, <code>false</code> if not.
+                @throws Error if an invalid year or a different calendar used. */
+            leapYear: function(year) {
+              var date = this._validate(year, this.minMonth, this.minDay, main.local.invalidYear);
+              var year = date.year() + (date.year() < 0 ? 1 : 0);
+              return year % 4 === 3 || year % 4 === -1;
+            },
+            /** Retrieve the number of months in a year.
+                @memberof CopticCalendar
+                @param year {CDate|number} The date to examine or the year to examine.
+                @return {number} The number of months.
+                @throws Error if an invalid year or a different calendar used. */
+            monthsInYear: function(year) {
+              this._validate(
+                year,
+                this.minMonth,
+                this.minDay,
+                main.local.invalidYear || main.regionalOptions[""].invalidYear
+              );
+              return 13;
+            },
+            /** Determine the week of the year for a date.
+                @memberof CopticCalendar
+                @param year {CDate|number} The date to examine or the year to examine.
+                @param [month] {number) the month to examine.
+                @param [day] {number} The day to examine.
+                @return {number} The week of the year.
+                @throws Error if an invalid date or a different calendar used. */
+            weekOfYear: function(year, month, day) {
+              var checkDate = this.newDate(year, month, day);
+              checkDate.add(-checkDate.dayOfWeek(), "d");
+              return Math.floor((checkDate.dayOfYear() - 1) / 7) + 1;
+            },
+            /** Retrieve the number of days in a month.
+                @memberof CopticCalendar
+                @param year {CDate|number} The date to examine or the year of the month.
+                @param [month] {number} The month.
+                @return {number} The number of days in this month.
+                @throws Error if an invalid month/year or a different calendar used. */
+            daysInMonth: function(year, month) {
+              var date = this._validate(year, month, this.minDay, main.local.invalidMonth);
+              return this.daysPerMonth[date.month() - 1] + (date.month() === 13 && this.leapYear(date.year()) ? 1 : 0);
+            },
+            /** Determine whether this date is a week day.
+                @memberof CopticCalendar
+                @param year {CDate|number} The date to examine or the year to examine.
+                @param month {number} The month to examine.
+                @param day {number} The day to examine.
+                @return {boolean} <code>true</code> if a week day, <code>false</code> if not.
+                @throws Error if an invalid date or a different calendar used. */
+            weekDay: function(year, month, day) {
+              return (this.dayOfWeek(year, month, day) || 7) < 6;
+            },
+            /** Retrieve the Julian date equivalent for this date,
+                i.e. days since January 1, 4713 BCE Greenwich noon.
+                @memberof CopticCalendar
+                @param year {CDate|number} The date to convert or the year to convert.
+                @param [month] {number) the month to convert.
+                @param [day] {number} The day to convert.
+                @return {number} The equivalent Julian date.
+                @throws Error if an invalid date or a different calendar used. */
+            toJD: function(year, month, day) {
+              var date = this._validate(year, month, day, main.local.invalidDate);
+              year = date.year();
+              if (year < 0) {
+                year++;
+              }
+              return date.day() + (date.month() - 1) * 30 + (year - 1) * 365 + Math.floor(year / 4) + this.jdEpoch - 1;
+            },
+            /** Create a new date from a Julian date.
+                @memberof CopticCalendar
+                @param jd {number} The Julian date to convert.
+                @return {CDate} The equivalent date. */
+            fromJD: function(jd2) {
+              var c2 = Math.floor(jd2) + 0.5 - this.jdEpoch;
+              var year = Math.floor((c2 - Math.floor((c2 + 366) / 1461)) / 365) + 1;
+              if (year <= 0) {
+                year--;
+              }
+              c2 = Math.floor(jd2) + 0.5 - this.newDate(year, 1, 1).toJD();
+              var month = Math.floor(c2 / 30) + 1;
+              var day = c2 - (month - 1) * 30 + 1;
+              return this.newDate(year, month, day);
+            }
+          });
+          main.calendars.coptic = CopticCalendar;
+        }
+      });
+      var require_discworld = __commonJS({
+        "node_modules/world-calendars/dist/calendars/discworld.js"() {
+          var main = require_main();
+          var assign = require_object_assign();
+          function DiscworldCalendar(language) {
+            this.local = this.regionalOptions[language || ""] || this.regionalOptions[""];
+          }
+          DiscworldCalendar.prototype = new main.baseCalendar();
+          assign(DiscworldCalendar.prototype, {
+            /** The calendar name.
+                @memberof DiscworldCalendar */
+            name: "Discworld",
+            /** Julian date of start of Discworld epoch: 1 January 0001 CE.
+                @memberof DiscworldCalendar */
+            jdEpoch: 17214255e-1,
+            /** Days per month in a common year.
+                @memberof DiscworldCalendar */
+            daysPerMonth: [16, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32],
+            /** <code>true</code> if has a year zero, <code>false</code> if not.
+                @memberof DiscworldCalendar */
+            hasYearZero: false,
+            /** The minimum month number.
+                @memberof DiscworldCalendar */
+            minMonth: 1,
+            /** The first month in the year.
+                @memberof DiscworldCalendar */
+            firstMonth: 1,
+            /** The minimum day number.
+                @memberof DiscworldCalendar */
+            minDay: 1,
+            /** Localisations for the plugin.
+                Entries are objects indexed by the language code ('' being the default US/English).
+                Each object has the following attributes.
+                @memberof DiscworldCalendar
+                @property name {string} The calendar name.
+                @property epochs {string[]} The epoch names.
+                @property monthNames {string[]} The long names of the months of the year.
+                @property monthNamesShort {string[]} The short names of the months of the year.
+                @property dayNames {string[]} The long names of the days of the week.
+                @property dayNamesShort {string[]} The short names of the days of the week.
+                @property dayNamesMin {string[]} The minimal names of the days of the week.
+                @property dateFormat {string} The date format for this calendar.
+                        See the options on <a href="BaseCalendar.html#formatDate"><code>formatDate</code></a> for details.
+                @property firstDay {number} The number of the first day of the week, starting at 0.
+                @property isRTL {number} <code>true</code> if this localisation reads right-to-left. */
+            regionalOptions: {
+              // Localisations
+              "": {
+                name: "Discworld",
+                epochs: ["BUC", "UC"],
+                monthNames: [
+                  "Ick",
+                  "Offle",
+                  "February",
+                  "March",
+                  "April",
+                  "May",
+                  "June",
+                  "Grune",
+                  "August",
+                  "Spune",
+                  "Sektober",
+                  "Ember",
+                  "December"
+                ],
+                monthNamesShort: ["Ick", "Off", "Feb", "Mar", "Apr", "May", "Jun", "Gru", "Aug", "Spu", "Sek", "Emb", "Dec"],
+                dayNames: ["Sunday", "Octeday", "Monday", "Tuesday", "Wednesday", "Thursday", "Friday", "Saturday"],
+                dayNamesShort: ["Sun", "Oct", "Mon", "Tue", "Wed", "Thu", "Fri", "Sat"],
+                dayNamesMin: ["Su", "Oc", "Mo", "Tu", "We", "Th", "Fr", "Sa"],
+                digits: null,
+                dateFormat: "yyyy/mm/dd",
+                firstDay: 2,
+                isRTL: false
+              }
+            },
+            /** Determine whether this date is in a leap year.
+                @memberof DiscworldCalendar
+                @param year {CDate|number} The date to examine or the year to examine.
+                @return {boolean} <code>true</code> if this is a leap year, <code>false</code> if not.
+                @throws Error if an invalid year or a different calendar used. */
+            leapYear: function(year) {
+              this._validate(year, this.minMonth, this.minDay, main.local.invalidYear);
+              return false;
+            },
+            /** Retrieve the number of months in a year.
+                @memberof DiscworldCalendar
+                @param year {CDate|number} The date to examine or the year to examine.
+                @return {number} The number of months.
+                @throws Error if an invalid year or a different calendar used. */
+            monthsInYear: function(year) {
+              this._validate(year, this.minMonth, this.minDay, main.local.invalidYear);
+              return 13;
+            },
+            /** Retrieve the number of days in a year.
+                @memberof DiscworldCalendar
+                @param year {CDate|number} The date to examine or the year to examine.
+                @return {number} The number of days.
+                @throws Error if an invalid year or a different calendar used. */
+            daysInYear: function(year) {
+              this._validate(year, this.minMonth, this.minDay, main.local.invalidYear);
+              return 400;
+            },
+            /** Determine the week of the year for a date.
+                @memberof DiscworldCalendar
+                @param year {CDate|number} The date to examine or the year to examine.
+                @param [month] {number} The month to examine.
+                @param [day] {number} The day to examine.
+                @return {number} The week of the year.
+                @throws Error if an invalid date or a different calendar used. */
+            weekOfYear: function(year, month, day) {
+              var checkDate = this.newDate(year, month, day);
+              checkDate.add(-checkDate.dayOfWeek(), "d");
+              return Math.floor((checkDate.dayOfYear() - 1) / 8) + 1;
+            },
+            /** Retrieve the number of days in a month.
+                @memberof DiscworldCalendar
+                @param year {CDate|number} The date to examine or the year of the month.
+                @param [month] {number} The month.
+                @return {number} The number of days in this month.
+                @throws Error if an invalid month/year or a different calendar used. */
+            daysInMonth: function(year, month) {
+              var date = this._validate(year, month, this.minDay, main.local.invalidMonth);
+              return this.daysPerMonth[date.month() - 1];
+            },
+            /** Retrieve the number of days in a week.
+                @memberof DiscworldCalendar
+                @return {number} The number of days. */
+            daysInWeek: function() {
+              return 8;
+            },
+            /** Retrieve the day of the week for a date.
+                @memberof DiscworldCalendar
+                @param year {CDate|number} The date to examine or the year to examine.
+                @param [month] {number} The month to examine.
+                @param [day] {number} The day to examine.
+                @return {number} The day of the week: 0 to number of days - 1.
+                @throws Error if an invalid date or a different calendar used. */
+            dayOfWeek: function(year, month, day) {
+              var date = this._validate(year, month, day, main.local.invalidDate);
+              return (date.day() + 1) % 8;
+            },
+            /** Determine whether this date is a week day.
+                @memberof DiscworldCalendar
+                @param year {CDate|number} The date to examine or the year to examine.
+                @param [month] {number} The month to examine.
+                @param [day] {number} The day to examine.
+                @return {boolean} <code>true</code> if a week day, <code>false</code> if not.
+                @throws Error if an invalid date or a different calendar used. */
+            weekDay: function(year, month, day) {
+              var dow = this.dayOfWeek(year, month, day);
+              return dow >= 2 && dow <= 6;
+            },
+            /** Retrieve additional information about a date.
+                @memberof DiscworldCalendar
+                @param year {CDate|number} The date to examine or the year to examine.
+                @param [month] {number} The month to examine.
+                @param [day] {number} The day to examine.
+                @return {object} Additional information - contents depends on calendar.
+                @throws Error if an invalid date or a different calendar used. */
+            extraInfo: function(year, month, day) {
+              var date = this._validate(year, month, day, main.local.invalidDate);
+              return { century: centuries[Math.floor((date.year() - 1) / 100) + 1] || "" };
+            },
+            /** Retrieve the Julian date equivalent for this date,
+                i.e. days since January 1, 4713 BCE Greenwich noon.
+                @memberof DiscworldCalendar
+                @param year {CDate|number} The date to convert or the year to convert.
+                @param [month] {number} The month to convert.
+                @param [day] {number} The day to convert.
+                @return {number} The equivalent Julian date.
+                @throws Error if an invalid date or a different calendar used. */
+            toJD: function(year, month, day) {
+              var date = this._validate(year, month, day, main.local.invalidDate);
+              year = date.year() + (date.year() < 0 ? 1 : 0);
+              month = date.month();
+              day = date.day();
+              return day + (month > 1 ? 16 : 0) + (month > 2 ? (month - 2) * 32 : 0) + (year - 1) * 400 + this.jdEpoch - 1;
+            },
+            /** Create a new date from a Julian date.
+                @memberof DiscworldCalendar
+                @param jd {number} The Julian date to convert.
+                @return {CDate} The equivalent date. */
+            fromJD: function(jd2) {
+              jd2 = Math.floor(jd2 + 0.5) - Math.floor(this.jdEpoch) - 1;
+              var year = Math.floor(jd2 / 400) + 1;
+              jd2 -= (year - 1) * 400;
+              jd2 += jd2 > 15 ? 16 : 0;
+              var month = Math.floor(jd2 / 32) + 1;
+              var day = jd2 - (month - 1) * 32 + 1;
+              return this.newDate(year <= 0 ? year - 1 : year, month, day);
+            }
+          });
+          var centuries = {
+            20: "Fruitbat",
+            21: "Anchovy"
+          };
+          main.calendars.discworld = DiscworldCalendar;
+        }
+      });
+      var require_ethiopian = __commonJS({
+        "node_modules/world-calendars/dist/calendars/ethiopian.js"() {
+          var main = require_main();
+          var assign = require_object_assign();
+          function EthiopianCalendar(language) {
+            this.local = this.regionalOptions[language || ""] || this.regionalOptions[""];
+          }
+          EthiopianCalendar.prototype = new main.baseCalendar();
+          assign(EthiopianCalendar.prototype, {
+            /** The calendar name.
+                @memberof EthiopianCalendar */
+            name: "Ethiopian",
+            /** Julian date of start of Ethiopian epoch: 27 August 8 CE (Gregorian).
+                @memberof EthiopianCalendar */
+            jdEpoch: 17242205e-1,
+            /** Days per month in a common year.
+                @memberof EthiopianCalendar */
+            daysPerMonth: [30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 5],
+            /** <code>true</code> if has a year zero, <code>false</code> if not.
+                @memberof EthiopianCalendar */
+            hasYearZero: false,
+            /** The minimum month number.
+                @memberof EthiopianCalendar */
+            minMonth: 1,
+            /** The first month in the year.
+                @memberof EthiopianCalendar */
+            firstMonth: 1,
+            /** The minimum day number.
+                @memberof EthiopianCalendar */
+            minDay: 1,
+            /** Localisations for the plugin.
+                Entries are objects indexed by the language code ('' being the default US/English).
+                Each object has the following attributes.
+                @memberof EthiopianCalendar
+                @property name {string} The calendar name.
+                @property epochs {string[]} The epoch names.
+                @property monthNames {string[]} The long names of the months of the year.
+                @property monthNamesShort {string[]} The short names of the months of the year.
+                @property dayNames {string[]} The long names of the days of the week.
+                @property dayNamesShort {string[]} The short names of the days of the week.
+                @property dayNamesMin {string[]} The minimal names of the days of the week.
+                @property dateFormat {string} The date format for this calendar.
+                        See the options on <a href="BaseCalendar.html#formatDate"><code>formatDate</code></a> for details.
+                @property firstDay {number} The number of the first day of the week, starting at 0.
+                @property isRTL {number} <code>true</code> if this localisation reads right-to-left. */
+            regionalOptions: {
+              // Localisations
+              "": {
+                name: "Ethiopian",
+                epochs: ["BEE", "EE"],
+                monthNames: [
+                  "Meskerem",
+                  "Tikemet",
+                  "Hidar",
+                  "Tahesas",
+                  "Tir",
+                  "Yekatit",
+                  "Megabit",
+                  "Miazia",
+                  "Genbot",
+                  "Sene",
+                  "Hamle",
+                  "Nehase",
+                  "Pagume"
+                ],
+                monthNamesShort: [
+                  "Mes",
+                  "Tik",
+                  "Hid",
+                  "Tah",
+                  "Tir",
+                  "Yek",
+                  "Meg",
+                  "Mia",
+                  "Gen",
+                  "Sen",
+                  "Ham",
+                  "Neh",
+                  "Pag"
+                ],
+                dayNames: ["Ehud", "Segno", "Maksegno", "Irob", "Hamus", "Arb", "Kidame"],
+                dayNamesShort: ["Ehu", "Seg", "Mak", "Iro", "Ham", "Arb", "Kid"],
+                dayNamesMin: ["Eh", "Se", "Ma", "Ir", "Ha", "Ar", "Ki"],
+                digits: null,
+                dateFormat: "dd/mm/yyyy",
+                firstDay: 0,
+                isRTL: false
+              }
+            },
+            /** Determine whether this date is in a leap year.
+                @memberof EthiopianCalendar
+                @param year {CDate|number} The date to examine or the year to examine.
+                @return {boolean} <code>true</code> if this is a leap year, <code>false</code> if not.
+                @throws Error if an invalid year or a different calendar used. */
+            leapYear: function(year) {
+              var date = this._validate(year, this.minMonth, this.minDay, main.local.invalidYear);
+              var year = date.year() + (date.year() < 0 ? 1 : 0);
+              return year % 4 === 3 || year % 4 === -1;
+            },
+            /** Retrieve the number of months in a year.
+                @memberof EthiopianCalendar
+                @param year {CDate|number} The date to examine or the year to examine.
+                @return {number} The number of months.
+                @throws Error if an invalid year or a different calendar used. */
+            monthsInYear: function(year) {
+              this._validate(
+                year,
+                this.minMonth,
+                this.minDay,
+                main.local.invalidYear || main.regionalOptions[""].invalidYear
+              );
+              return 13;
+            },
+            /** Determine the week of the year for a date.
+                @memberof EthiopianCalendar
+                @param year {CDate|number} The date to examine or the year to examine.
+                @param [month] {number} The month to examine.
+                @param [day] {number} The day to examine.
+                @return {number} The week of the year.
+                @throws Error if an invalid date or a different calendar used. */
+            weekOfYear: function(year, month, day) {
+              var checkDate = this.newDate(year, month, day);
+              checkDate.add(-checkDate.dayOfWeek(), "d");
+              return Math.floor((checkDate.dayOfYear() - 1) / 7) + 1;
+            },
+            /** Retrieve the number of days in a month.
+                @memberof EthiopianCalendar
+                @param year {CDate|number} The date to examine or the year of the month.
+                @param [month] {number} The month.
+                @return {number} The number of days in this month.
+                @throws Error if an invalid month/year or a different calendar used. */
+            daysInMonth: function(year, month) {
+              var date = this._validate(year, month, this.minDay, main.local.invalidMonth);
+              return this.daysPerMonth[date.month() - 1] + (date.month() === 13 && this.leapYear(date.year()) ? 1 : 0);
+            },
+            /** Determine whether this date is a week day.
+                @memberof EthiopianCalendar
+                @param year {CDate|number} The date to examine or the year to examine.
+                @param [month] {number} The month to examine.
+                @param [day] {number} The day to examine.
+                @return {boolean} <code>true</code> if a week day, <code>false</code> if not.
+                @throws Error if an invalid date or a different calendar used. */
+            weekDay: function(year, month, day) {
+              return (this.dayOfWeek(year, month, day) || 7) < 6;
+            },
+            /** Retrieve the Julian date equivalent for this date,
+                i.e. days since January 1, 4713 BCE Greenwich noon.
+                @memberof EthiopianCalendar
+                @param year {CDate|number} The date to convert or the year to convert.
+                @param [month] {number} The month to convert.
+                @param [day] {number} The day to convert.
+                @return {number} The equivalent Julian date.
+                @throws Error if an invalid date or a different calendar used. */
+            toJD: function(year, month, day) {
+              var date = this._validate(year, month, day, main.local.invalidDate);
+              year = date.year();
+              if (year < 0) {
+                year++;
+              }
+              return date.day() + (date.month() - 1) * 30 + (year - 1) * 365 + Math.floor(year / 4) + this.jdEpoch - 1;
+            },
+            /** Create a new date from a Julian date.
+                @memberof EthiopianCalendar
+                @param jd {number} the Julian date to convert.
+                @return {CDate} the equivalent date. */
+            fromJD: function(jd2) {
+              var c2 = Math.floor(jd2) + 0.5 - this.jdEpoch;
+              var year = Math.floor((c2 - Math.floor((c2 + 366) / 1461)) / 365) + 1;
+              if (year <= 0) {
+                year--;
+              }
+              c2 = Math.floor(jd2) + 0.5 - this.newDate(year, 1, 1).toJD();
+              var month = Math.floor(c2 / 30) + 1;
+              var day = c2 - (month - 1) * 30 + 1;
+              return this.newDate(year, month, day);
+            }
+          });
+          main.calendars.ethiopian = EthiopianCalendar;
+        }
+      });
+      var require_hebrew = __commonJS({
+        "node_modules/world-calendars/dist/calendars/hebrew.js"() {
+          var main = require_main();
+          var assign = require_object_assign();
+          function HebrewCalendar(language) {
+            this.local = this.regionalOptions[language || ""] || this.regionalOptions[""];
+          }
+          HebrewCalendar.prototype = new main.baseCalendar();
+          assign(HebrewCalendar.prototype, {
+            /** The calendar name.
+                @memberof HebrewCalendar */
+            name: "Hebrew",
+            /** Julian date of start of Hebrew epoch: 7 October 3761 BCE.
+                @memberof HebrewCalendar */
+            jdEpoch: 347995.5,
+            /** Days per month in a common year.
+                @memberof HebrewCalendar */
+            daysPerMonth: [30, 29, 30, 29, 30, 29, 30, 29, 30, 29, 30, 29, 29],
+            /** <code>true</code> if has a year zero, <code>false</code> if not.
+                @memberof HebrewCalendar */
+            hasYearZero: false,
+            /** The minimum month number.
+                @memberof HebrewCalendar */
+            minMonth: 1,
+            /** The first month in the year.
+                @memberof HebrewCalendar */
+            firstMonth: 7,
+            /** The minimum day number.
+                @memberof HebrewCalendar */
+            minDay: 1,
+            /** Localisations for the plugin.
+                Entries are objects indexed by the language code ('' being the default US/English).
+                Each object has the following attributes.
+                @memberof HebrewCalendar
+                @property name {string} The calendar name.
+                @property epochs {string[]} The epoch names.
+                @property monthNames {string[]} The long names of the months of the year.
+                @property monthNamesShort {string[]} The short names of the months of the year.
+                @property dayNames {string[]} The long names of the days of the week.
+                @property dayNamesShort {string[]} The short names of the days of the week.
+                @property dayNamesMin {string[]} The minimal names of the days of the week.
+                @property dateFormat {string} The date format for this calendar.
+                        See the options on <a href="BaseCalendar.html#formatDate"><code>formatDate</code></a> for details.
+                @property firstDay {number} The number of the first day of the week, starting at 0.
+                @property isRTL {number} <code>true</code> if this localisation reads right-to-left. */
+            regionalOptions: {
+              // Localisations
+              "": {
+                name: "Hebrew",
+                epochs: ["BAM", "AM"],
+                monthNames: [
+                  "Nisan",
+                  "Iyar",
+                  "Sivan",
+                  "Tammuz",
+                  "Av",
+                  "Elul",
+                  "Tishrei",
+                  "Cheshvan",
+                  "Kislev",
+                  "Tevet",
+                  "Shevat",
+                  "Adar",
+                  "Adar II"
+                ],
+                monthNamesShort: ["Nis", "Iya", "Siv", "Tam", "Av", "Elu", "Tis", "Che", "Kis", "Tev", "She", "Ada", "Ad2"],
+                dayNames: ["Yom Rishon", "Yom Sheni", "Yom Shlishi", "Yom Revi'i", "Yom Chamishi", "Yom Shishi", "Yom Shabbat"],
+                dayNamesShort: ["Ris", "She", "Shl", "Rev", "Cha", "Shi", "Sha"],
+                dayNamesMin: ["Ri", "She", "Shl", "Re", "Ch", "Shi", "Sha"],
+                digits: null,
+                dateFormat: "dd/mm/yyyy",
+                firstDay: 0,
+                isRTL: false
+              }
+            },
+            /** Determine whether this date is in a leap year.
+                @memberof HebrewCalendar
+                @param year {CDate|number} The date to examine or the year to examine.
+                @return {boolean} <code>true</code> if this is a leap year, <code>false</code> if not.
+                @throws Error if an invalid year or a different calendar used. */
+            leapYear: function(year) {
+              var date = this._validate(year, this.minMonth, this.minDay, main.local.invalidYear);
+              return this._leapYear(date.year());
+            },
+            /** Determine whether this date is in a leap year.
+                @memberof HebrewCalendar
+                @private
+                @param year {number} The year to examine.
+                @return {boolean} <code>true</code> if this is a leap year, <code>false</code> if not.
+                @throws Error if an invalid year or a different calendar used. */
+            _leapYear: function(year) {
+              year = year < 0 ? year + 1 : year;
+              return mod2(year * 7 + 1, 19) < 7;
+            },
+            /** Retrieve the number of months in a year.
+                @memberof HebrewCalendar
+                @param year {CDate|number} The date to examine or the year to examine.
+                @return {number} The number of months.
+                @throws Error if an invalid year or a different calendar used. */
+            monthsInYear: function(year) {
+              this._validate(year, this.minMonth, this.minDay, main.local.invalidYear);
+              return this._leapYear(year.year ? year.year() : year) ? 13 : 12;
+            },
+            /** Determine the week of the year for a date.
+                @memberof HebrewCalendar
+                @param year {CDate|number} The date to examine or the year to examine.
+                @param [month] {number} The month to examine.
+                @param [day] {number} The day to examine.
+                @return {number} The week of the year.
+                @throws Error if an invalid date or a different calendar used. */
+            weekOfYear: function(year, month, day) {
+              var checkDate = this.newDate(year, month, day);
+              checkDate.add(-checkDate.dayOfWeek(), "d");
+              return Math.floor((checkDate.dayOfYear() - 1) / 7) + 1;
+            },
+            /** Retrieve the number of days in a year.
+                @memberof HebrewCalendar
+                @param year {CDate|number} The date to examine or the year to examine.
+                @return {number} The number of days.
+                @throws Error if an invalid year or a different calendar used. */
+            daysInYear: function(year) {
+              var date = this._validate(year, this.minMonth, this.minDay, main.local.invalidYear);
+              year = date.year();
+              return this.toJD(year === -1 ? 1 : year + 1, 7, 1) - this.toJD(year, 7, 1);
+            },
+            /** Retrieve the number of days in a month.
+                @memberof HebrewCalendar
+                @param year {CDate|number} The date to examine or the year of the month.
+                @param [month] {number} The month.
+                @return {number} The number of days in this month.
+                @throws Error if an invalid month/year or a different calendar used. */
+            daysInMonth: function(year, month) {
+              if (year.year) {
+                month = year.month();
+                year = year.year();
+              }
+              this._validate(year, month, this.minDay, main.local.invalidMonth);
+              return month === 12 && this.leapYear(year) ? 30 : (
+                // Adar I
+                month === 8 && mod2(this.daysInYear(year), 10) === 5 ? 30 : (
+                  // Cheshvan in shlemah year
+                  month === 9 && mod2(this.daysInYear(year), 10) === 3 ? 29 : (
+                    // Kislev in chaserah year
+                    this.daysPerMonth[month - 1]
+                  )
+                )
+              );
+            },
+            /** Determine whether this date is a week day.
+                @memberof HebrewCalendar
+                @param year {CDate|number} The date to examine or the year to examine.
+                @param [month] {number} The month to examine.
+                @param [day] {number} The day to examine.
+                @return {boolean} <code>true</code> if a week day, <code>false</code> if not.
+                @throws Error if an invalid date or a different calendar used. */
+            weekDay: function(year, month, day) {
+              return this.dayOfWeek(year, month, day) !== 6;
+            },
+            /** Retrieve additional information about a date - year type.
+                @memberof HebrewCalendar
+                @param year {CDate|number} The date to examine or the year to examine.
+                @param [month] {number} The month to examine.
+                @param [day] {number} The day to examine.
+                @return {object} Additional information - contents depends on calendar.
+                @throws Error if an invalid date or a different calendar used. */
+            extraInfo: function(year, month, day) {
+              var date = this._validate(year, month, day, main.local.invalidDate);
+              return { yearType: (this.leapYear(date) ? "embolismic" : "common") + " " + ["deficient", "regular", "complete"][this.daysInYear(date) % 10 - 3] };
+            },
+            /** Retrieve the Julian date equivalent for this date,
+                i.e. days since January 1, 4713 BCE Greenwich noon.
+                @memberof HebrewCalendar
+                @param year {CDate)|number} The date to convert or the year to convert.
+                @param [month] {number} The month to convert.
+                @param [day] {number} The day to convert.
+                @return {number} The equivalent Julian date.
+                @throws Error if an invalid date or a different calendar used. */
+            toJD: function(year, month, day) {
+              var date = this._validate(year, month, day, main.local.invalidDate);
+              year = date.year();
+              month = date.month();
+              day = date.day();
+              var adjYear = year <= 0 ? year + 1 : year;
+              var jd2 = this.jdEpoch + this._delay1(adjYear) + this._delay2(adjYear) + day + 1;
+              if (month < 7) {
+                for (var m2 = 7; m2 <= this.monthsInYear(year); m2++) {
+                  jd2 += this.daysInMonth(year, m2);
+                }
+                for (var m2 = 1; m2 < month; m2++) {
+                  jd2 += this.daysInMonth(year, m2);
+                }
+              } else {
+                for (var m2 = 7; m2 < month; m2++) {
+                  jd2 += this.daysInMonth(year, m2);
+                }
+              }
+              return jd2;
+            },
+            /** Test for delay of start of new year and to avoid
+                Sunday, Wednesday, or Friday as start of the new year.
+                @memberof HebrewCalendar
+                @private
+                @param year {number} The year to examine.
+                @return {number} The days to offset by. */
+            _delay1: function(year) {
+              var months = Math.floor((235 * year - 234) / 19);
+              var parts = 12084 + 13753 * months;
+              var day = months * 29 + Math.floor(parts / 25920);
+              if (mod2(3 * (day + 1), 7) < 3) {
+                day++;
+              }
+              return day;
+            },
+            /** Check for delay in start of new year due to length of adjacent years.
+                @memberof HebrewCalendar
+                @private
+                @param year {number} The year to examine.
+                @return {number} The days to offset by. */
+            _delay2: function(year) {
+              var last = this._delay1(year - 1);
+              var present = this._delay1(year);
+              var next = this._delay1(year + 1);
+              return next - present === 356 ? 2 : present - last === 382 ? 1 : 0;
+            },
+            /** Create a new date from a Julian date.
+                @memberof HebrewCalendar
+                @param jd {number} The Julian date to convert.
+                @return {CDate} The equivalent date. */
+            fromJD: function(jd2) {
+              jd2 = Math.floor(jd2) + 0.5;
+              var year = Math.floor((jd2 - this.jdEpoch) * 98496 / 35975351) - 1;
+              while (jd2 >= this.toJD(year === -1 ? 1 : year + 1, 7, 1)) {
+                year++;
+              }
+              var month = jd2 < this.toJD(year, 1, 1) ? 7 : 1;
+              while (jd2 > this.toJD(year, month, this.daysInMonth(year, month))) {
+                month++;
+              }
+              var day = jd2 - this.toJD(year, month, 1) + 1;
+              return this.newDate(year, month, day);
+            }
+          });
+          function mod2(a2, b2) {
+            return a2 - b2 * Math.floor(a2 / b2);
+          }
+          main.calendars.hebrew = HebrewCalendar;
+        }
+      });
+      var require_islamic = __commonJS({
+        "node_modules/world-calendars/dist/calendars/islamic.js"() {
+          var main = require_main();
+          var assign = require_object_assign();
+          function IslamicCalendar(language) {
+            this.local = this.regionalOptions[language || ""] || this.regionalOptions[""];
+          }
+          IslamicCalendar.prototype = new main.baseCalendar();
+          assign(IslamicCalendar.prototype, {
+            /** The calendar name.
+                @memberof IslamicCalendar */
+            name: "Islamic",
+            /** Julian date of start of Islamic epoch: 16 July 622 CE.
+                @memberof IslamicCalendar */
+            jdEpoch: 19484395e-1,
+            /** Days per month in a common year.
+                @memberof IslamicCalendar */
+            daysPerMonth: [30, 29, 30, 29, 30, 29, 30, 29, 30, 29, 30, 29],
+            /** <code>true</code> if has a year zero, <code>false</code> if not.
+                @memberof IslamicCalendar */
+            hasYearZero: false,
+            /** The minimum month number.
+                @memberof IslamicCalendar */
+            minMonth: 1,
+            /** The first month in the year.
+                @memberof IslamicCalendar */
+            firstMonth: 1,
+            /** The minimum day number.
+                @memberof IslamicCalendar */
+            minDay: 1,
+            /** Localisations for the plugin.
+                Entries are objects indexed by the language code ('' being the default US/English).
+                Each object has the following attributes.
+                @memberof IslamicCalendar
+                @property name {string} The calendar name.
+                @property epochs {string[]} The epoch names.
+                @property monthNames {string[]} The long names of the months of the year.
+                @property monthNamesShort {string[]} The short names of the months of the year.
+                @property dayNames {string[]} The long names of the days of the week.
+                @property dayNamesShort {string[]} The short names of the days of the week.
+                @property dayNamesMin {string[]} The minimal names of the days of the week.
+                @property dateFormat {string} The date format for this calendar.
+                        See the options on <a href="BaseCalendar.html#formatDate"><code>formatDate</code></a> for details.
+                @property firstDay {number} The number of the first day of the week, starting at 0.
+                @property isRTL {number} <code>true</code> if this localisation reads right-to-left. */
+            regionalOptions: {
+              // Localisations
+              "": {
+                name: "Islamic",
+                epochs: ["BH", "AH"],
+                monthNames: [
+                  "Muharram",
+                  "Safar",
+                  "Rabi' al-awwal",
+                  "Rabi' al-thani",
+                  "Jumada al-awwal",
+                  "Jumada al-thani",
+                  "Rajab",
+                  "Sha'aban",
+                  "Ramadan",
+                  "Shawwal",
+                  "Dhu al-Qi'dah",
+                  "Dhu al-Hijjah"
+                ],
+                monthNamesShort: ["Muh", "Saf", "Rab1", "Rab2", "Jum1", "Jum2", "Raj", "Sha'", "Ram", "Shaw", "DhuQ", "DhuH"],
+                dayNames: [
+                  "Yawm al-ahad",
+                  "Yawm al-ithnayn",
+                  "Yawm ath-thulaathaa'",
+                  "Yawm al-arbi'aa'",
+                  "Yawm al-khamīs",
+                  "Yawm al-jum'a",
+                  "Yawm as-sabt"
+                ],
+                dayNamesShort: ["Aha", "Ith", "Thu", "Arb", "Kha", "Jum", "Sab"],
+                dayNamesMin: ["Ah", "It", "Th", "Ar", "Kh", "Ju", "Sa"],
+                digits: null,
+                dateFormat: "yyyy/mm/dd",
+                firstDay: 6,
+                isRTL: false
+              }
+            },
+            /** Determine whether this date is in a leap year.
+                @memberof IslamicCalendar
+                @param year {CDate|number} The date to examine or the year to examine.
+                @return {boolean} <code>true</code> if this is a leap year, <code>false</code> if not.
+                @throws Error if an invalid year or a different calendar used. */
+            leapYear: function(year) {
+              var date = this._validate(year, this.minMonth, this.minDay, main.local.invalidYear);
+              return (date.year() * 11 + 14) % 30 < 11;
+            },
+            /** Determine the week of the year for a date.
+                @memberof IslamicCalendar
+                @param year {CDate|number} The date to examine or the year to examine.
+                @param [month] {number} The month to examine.
+                @param [day] {number} The day to examine.
+                @return {number} The week of the year.
+                @throws Error if an invalid date or a different calendar used. */
+            weekOfYear: function(year, month, day) {
+              var checkDate = this.newDate(year, month, day);
+              checkDate.add(-checkDate.dayOfWeek(), "d");
+              return Math.floor((checkDate.dayOfYear() - 1) / 7) + 1;
+            },
+            /** Retrieve the number of days in a year.
+                @memberof IslamicCalendar
+                @param year {CDate|number} The date to examine or the year to examine.
+                @return {number} The number of days.
+                @throws Error if an invalid year or a different calendar used. */
+            daysInYear: function(year) {
+              return this.leapYear(year) ? 355 : 354;
+            },
+            /** Retrieve the number of days in a month.
+                @memberof IslamicCalendar
+                @param year {CDate|number} The date to examine or the year of the month.
+                @param [month] {number} The month.
+                @return {number} The number of days in this month.
+                @throws Error if an invalid month/year or a different calendar used. */
+            daysInMonth: function(year, month) {
+              var date = this._validate(year, month, this.minDay, main.local.invalidMonth);
+              return this.daysPerMonth[date.month() - 1] + (date.month() === 12 && this.leapYear(date.year()) ? 1 : 0);
+            },
+            /** Determine whether this date is a week day.
+                @memberof IslamicCalendar
+                @param year {CDate|number} The date to examine or the year to examine.
+                @param [month] {number} The month to examine.
+                @param [day] {number} The day to examine.
+                @return {boolean} <code>true</code> if a week day, <code>false</code> if not.
+                @throws Error if an invalid date or a different calendar used. */
+            weekDay: function(year, month, day) {
+              return this.dayOfWeek(year, month, day) !== 5;
+            },
+            /** Retrieve the Julian date equivalent for this date,
+                i.e. days since January 1, 4713 BCE Greenwich noon.
+                @memberof IslamicCalendar
+                @param year {CDate|number} The date to convert or the year to convert.
+                @param [month] {number} The month to convert.
+                @param [day] {number} The day to convert.
+                @return {number} The equivalent Julian date.
+                @throws Error if an invalid date or a different calendar used. */
+            toJD: function(year, month, day) {
+              var date = this._validate(year, month, day, main.local.invalidDate);
+              year = date.year();
+              month = date.month();
+              day = date.day();
+              year = year <= 0 ? year + 1 : year;
+              return day + Math.ceil(29.5 * (month - 1)) + (year - 1) * 354 + Math.floor((3 + 11 * year) / 30) + this.jdEpoch - 1;
+            },
+            /** Create a new date from a Julian date.
+                @memberof IslamicCalendar
+                @param jd {number} The Julian date to convert.
+                @return {CDate} The equivalent date. */
+            fromJD: function(jd2) {
+              jd2 = Math.floor(jd2) + 0.5;
+              var year = Math.floor((30 * (jd2 - this.jdEpoch) + 10646) / 10631);
+              year = year <= 0 ? year - 1 : year;
+              var month = Math.min(12, Math.ceil((jd2 - 29 - this.toJD(year, 1, 1)) / 29.5) + 1);
+              var day = jd2 - this.toJD(year, month, 1) + 1;
+              return this.newDate(year, month, day);
+            }
+          });
+          main.calendars.islamic = IslamicCalendar;
+        }
+      });
+      var require_julian = __commonJS({
+        "node_modules/world-calendars/dist/calendars/julian.js"() {
+          var main = require_main();
+          var assign = require_object_assign();
+          function JulianCalendar(language) {
+            this.local = this.regionalOptions[language || ""] || this.regionalOptions[""];
+          }
+          JulianCalendar.prototype = new main.baseCalendar();
+          assign(JulianCalendar.prototype, {
+            /** The calendar name.
+                @memberof JulianCalendar */
+            name: "Julian",
+            /** Julian date of start of Julian epoch: 1 January 0001 AD = 30 December 0001 BCE.
+                @memberof JulianCalendar */
+            jdEpoch: 17214235e-1,
+            /** Days per month in a common year.
+                @memberof JulianCalendar */
+            daysPerMonth: [31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31],
+            /** <code>true</code> if has a year zero, <code>false</code> if not.
+                @memberof JulianCalendar */
+            hasYearZero: false,
+            /** The minimum month number.
+                @memberof JulianCalendar */
+            minMonth: 1,
+            /** The first month in the year.
+                @memberof JulianCalendar */
+            firstMonth: 1,
+            /** The minimum day number.
+                @memberof JulianCalendar */
+            minDay: 1,
+            /** Localisations for the plugin.
+                Entries are objects indexed by the language code ('' being the default US/English).
+                Each object has the following attributes.
+                @memberof JulianCalendar
+                @property name {string} The calendar name.
+                @property epochs {string[]} The epoch names.
+                @property monthNames {string[]} The long names of the months of the year.
+                @property monthNamesShort {string[]} The short names of the months of the year.
+                @property dayNames {string[]} The long names of the days of the week.
+                @property dayNamesShort {string[]} The short names of the days of the week.
+                @property dayNamesMin {string[]} The minimal names of the days of the week.
+                @property dateFormat {string} The date format for this calendar.
+                        See the options on <a href="BaseCalendar.html#formatDate"><code>formatDate</code></a> for details.
+                @property firstDay {number} The number of the first day of the week, starting at 0.
+                @property isRTL {number} <code>true</code> if this localisation reads right-to-left. */
+            regionalOptions: {
+              // Localisations
+              "": {
+                name: "Julian",
+                epochs: ["BC", "AD"],
+                monthNames: [
+                  "January",
+                  "February",
+                  "March",
+                  "April",
+                  "May",
+                  "June",
+                  "July",
+                  "August",
+                  "September",
+                  "October",
+                  "November",
+                  "December"
+                ],
+                monthNamesShort: ["Jan", "Feb", "Mar", "Apr", "May", "Jun", "Jul", "Aug", "Sep", "Oct", "Nov", "Dec"],
+                dayNames: ["Sunday", "Monday", "Tuesday", "Wednesday", "Thursday", "Friday", "Saturday"],
+                dayNamesShort: ["Sun", "Mon", "Tue", "Wed", "Thu", "Fri", "Sat"],
+                dayNamesMin: ["Su", "Mo", "Tu", "We", "Th", "Fr", "Sa"],
+                digits: null,
+                dateFormat: "mm/dd/yyyy",
+                firstDay: 0,
+                isRTL: false
+              }
+            },
+            /** Determine whether this date is in a leap year.
+                @memberof JulianCalendar
+                @param year {CDate|number} The date to examine or the year to examine.
+                @return {boolean} <code>true</code> if this is a leap year, <code>false</code> if not.
+                @throws Error if an invalid year or a different calendar used. */
+            leapYear: function(year) {
+              var date = this._validate(year, this.minMonth, this.minDay, main.local.invalidYear);
+              var year = date.year() < 0 ? date.year() + 1 : date.year();
+              return year % 4 === 0;
+            },
+            /** Determine the week of the year for a date - ISO 8601.
+                @memberof JulianCalendar
+                @param year {CDate|number} The date to examine or the year to examine.
+                @param [month] {number} The month to examine.
+                @param [day] {number} The day to examine.
+                @return {number} The week of the year.
+                @throws Error if an invalid date or a different calendar used. */
+            weekOfYear: function(year, month, day) {
+              var checkDate = this.newDate(year, month, day);
+              checkDate.add(4 - (checkDate.dayOfWeek() || 7), "d");
+              return Math.floor((checkDate.dayOfYear() - 1) / 7) + 1;
+            },
+            /** Retrieve the number of days in a month.
+                @memberof JulianCalendar
+                @param year {CDate|number} The date to examine or the year of the month.
+                @param [month] {number} The month.
+                @return {number} The number of days in this month.
+                @throws Error if an invalid month/year or a different calendar used. */
+            daysInMonth: function(year, month) {
+              var date = this._validate(year, month, this.minDay, main.local.invalidMonth);
+              return this.daysPerMonth[date.month() - 1] + (date.month() === 2 && this.leapYear(date.year()) ? 1 : 0);
+            },
+            /** Determine whether this date is a week day.
+                @memberof JulianCalendar
+                @param year {CDate|number} The date to examine or the year to examine.
+                @param [month] {number} The month to examine.
+                @param [day] {number} The day to examine.
+                @return {boolean} True if a week day, false if not.
+                @throws Error if an invalid date or a different calendar used. */
+            weekDay: function(year, month, day) {
+              return (this.dayOfWeek(year, month, day) || 7) < 6;
+            },
+            /** Retrieve the Julian date equivalent for this date,
+                i.e. days since January 1, 4713 BCE Greenwich noon.
+                @memberof JulianCalendar
+                @param year {CDate|number} The date to convert or the year to convert.
+                @param [month] {number} The month to convert.
+                @param [day] {number} The day to convert.
+                @return {number} The equivalent Julian date.
+                @throws Error if an invalid date or a different calendar used. */
+            toJD: function(year, month, day) {
+              var date = this._validate(year, month, day, main.local.invalidDate);
+              year = date.year();
+              month = date.month();
+              day = date.day();
+              if (year < 0) {
+                year++;
+              }
+              if (month <= 2) {
+                year--;
+                month += 12;
+              }
+              return Math.floor(365.25 * (year + 4716)) + Math.floor(30.6001 * (month + 1)) + day - 1524.5;
+            },
+            /** Create a new date from a Julian date.
+                @memberof JulianCalendar
+                @param jd {number} The Julian date to convert.
+                @return {CDate} The equivalent date. */
+            fromJD: function(jd2) {
+              var a2 = Math.floor(jd2 + 0.5);
+              var b2 = a2 + 1524;
+              var c2 = Math.floor((b2 - 122.1) / 365.25);
+              var d2 = Math.floor(365.25 * c2);
+              var e2 = Math.floor((b2 - d2) / 30.6001);
+              var month = e2 - Math.floor(e2 < 14 ? 1 : 13);
+              var year = c2 - Math.floor(month > 2 ? 4716 : 4715);
+              var day = b2 - d2 - Math.floor(30.6001 * e2);
+              if (year <= 0) {
+                year--;
+              }
+              return this.newDate(year, month, day);
+            }
+          });
+          main.calendars.julian = JulianCalendar;
+        }
+      });
+      var require_mayan = __commonJS({
+        "node_modules/world-calendars/dist/calendars/mayan.js"() {
+          var main = require_main();
+          var assign = require_object_assign();
+          function MayanCalendar(language) {
+            this.local = this.regionalOptions[language || ""] || this.regionalOptions[""];
+          }
+          MayanCalendar.prototype = new main.baseCalendar();
+          assign(MayanCalendar.prototype, {
+            /** The calendar name.
+                @memberof MayanCalendar */
+            name: "Mayan",
+            /** Julian date of start of Mayan epoch: 11 August 3114 BCE.
+                @memberof MayanCalendar */
+            jdEpoch: 584282.5,
+            /** <code>true</code> if has a year zero, <code>false</code> if not.
+                @memberof MayanCalendar */
+            hasYearZero: true,
+            /** The minimum month number.
+                @memberof MayanCalendar */
+            minMonth: 0,
+            /** The first month in the year.
+                @memberof MayanCalendar */
+            firstMonth: 0,
+            /** The minimum day number.
+                @memberof MayanCalendar */
+            minDay: 0,
+            /** Localisations for the plugin.
+                Entries are objects indexed by the language code ('' being the default US/English).
+                Each object has the following attributes.
+                @memberof MayanCalendar
+                @property name {string} The calendar name.
+                @property epochs {string[]} The epoch names.
+                @property monthNames {string[]} The long names of the months of the year.
+                @property monthNamesShort {string[]} The short names of the months of the year.
+                @property dayNames {string[]} The long names of the days of the week.
+                @property dayNamesShort {string[]} The short names of the days of the week.
+                @property dayNamesMin {string[]} The minimal names of the days of the week.
+                @property dateFormat {string} The date format for this calendar.
+                        See the options on <a href="BaseCalendar.html#formatDate"><code>formatDate</code></a> for details.
+                @property firstDay {number} The number of the first day of the week, starting at 0.
+                @property isRTL {number} <code>true</code> if this localisation reads right-to-left.
+                @property haabMonths {string[]} The names of the Haab months.
+                @property tzolkinMonths {string[]} The names of the Tzolkin months. */
+            regionalOptions: {
+              // Localisations
+              "": {
+                name: "Mayan",
+                epochs: ["", ""],
+                monthNames: [
+                  "0",
+                  "1",
+                  "2",
+                  "3",
+                  "4",
+                  "5",
+                  "6",
+                  "7",
+                  "8",
+                  "9",
+                  "10",
+                  "11",
+                  "12",
+                  "13",
+                  "14",
+                  "15",
+                  "16",
+                  "17"
+                ],
+                monthNamesShort: [
+                  "0",
+                  "1",
+                  "2",
+                  "3",
+                  "4",
+                  "5",
+                  "6",
+                  "7",
+                  "8",
+                  "9",
+                  "10",
+                  "11",
+                  "12",
+                  "13",
+                  "14",
+                  "15",
+                  "16",
+                  "17"
+                ],
+                dayNames: [
+                  "0",
+                  "1",
+                  "2",
+                  "3",
+                  "4",
+                  "5",
+                  "6",
+                  "7",
+                  "8",
+                  "9",
+                  "10",
+                  "11",
+                  "12",
+                  "13",
+                  "14",
+                  "15",
+                  "16",
+                  "17",
+                  "18",
+                  "19"
+                ],
+                dayNamesShort: [
+                  "0",
+                  "1",
+                  "2",
+                  "3",
+                  "4",
+                  "5",
+                  "6",
+                  "7",
+                  "8",
+                  "9",
+                  "10",
+                  "11",
+                  "12",
+                  "13",
+                  "14",
+                  "15",
+                  "16",
+                  "17",
+                  "18",
+                  "19"
+                ],
+                dayNamesMin: [
+                  "0",
+                  "1",
+                  "2",
+                  "3",
+                  "4",
+                  "5",
+                  "6",
+                  "7",
+                  "8",
+                  "9",
+                  "10",
+                  "11",
+                  "12",
+                  "13",
+                  "14",
+                  "15",
+                  "16",
+                  "17",
+                  "18",
+                  "19"
+                ],
+                digits: null,
+                dateFormat: "YYYY.m.d",
+                firstDay: 0,
+                isRTL: false,
+                haabMonths: [
+                  "Pop",
+                  "Uo",
+                  "Zip",
+                  "Zotz",
+                  "Tzec",
+                  "Xul",
+                  "Yaxkin",
+                  "Mol",
+                  "Chen",
+                  "Yax",
+                  "Zac",
+                  "Ceh",
+                  "Mac",
+                  "Kankin",
+                  "Muan",
+                  "Pax",
+                  "Kayab",
+                  "Cumku",
+                  "Uayeb"
+                ],
+                tzolkinMonths: [
+                  "Imix",
+                  "Ik",
+                  "Akbal",
+                  "Kan",
+                  "Chicchan",
+                  "Cimi",
+                  "Manik",
+                  "Lamat",
+                  "Muluc",
+                  "Oc",
+                  "Chuen",
+                  "Eb",
+                  "Ben",
+                  "Ix",
+                  "Men",
+                  "Cib",
+                  "Caban",
+                  "Etznab",
+                  "Cauac",
+                  "Ahau"
+                ]
+              }
+            },
+            /** Determine whether this date is in a leap year.
+                @memberof MayanCalendar
+                @param year {CDate|number} The date to examine or the year to examine.
+                @return {boolean} <code>true</code> if this is a leap year, <code>false</code> if not.
+                @throws Error if an invalid year or a different calendar used. */
+            leapYear: function(year) {
+              this._validate(year, this.minMonth, this.minDay, main.local.invalidYear);
+              return false;
+            },
+            /** Format the year, if not a simple sequential number.
+                @memberof MayanCalendar
+                @param year {CDate|number} The date to format or the year to format.
+                @return {string} The formatted year.
+                @throws Error if an invalid year or a different calendar used. */
+            formatYear: function(year) {
+              var date = this._validate(year, this.minMonth, this.minDay, main.local.invalidYear);
+              year = date.year();
+              var baktun = Math.floor(year / 400);
+              year = year % 400;
+              year += year < 0 ? 400 : 0;
+              var katun = Math.floor(year / 20);
+              return baktun + "." + katun + "." + year % 20;
+            },
+            /** Convert from the formatted year back to a single number.
+                @memberof MayanCalendar
+                @param years {string} The year as n.n.n.
+                @return {number} The sequential year.
+                @throws Error if an invalid value is supplied. */
+            forYear: function(years) {
+              years = years.split(".");
+              if (years.length < 3) {
+                throw "Invalid Mayan year";
+              }
+              var year = 0;
+              for (var i2 = 0; i2 < years.length; i2++) {
+                var y2 = parseInt(years[i2], 10);
+                if (Math.abs(y2) > 19 || i2 > 0 && y2 < 0) {
+                  throw "Invalid Mayan year";
+                }
+                year = year * 20 + y2;
+              }
+              return year;
+            },
+            /** Retrieve the number of months in a year.
+                @memberof MayanCalendar
+                @param year {CDate|number} The date to examine or the year to examine.
+                @return {number} The number of months.
+                @throws Error if an invalid year or a different calendar used. */
+            monthsInYear: function(year) {
+              this._validate(year, this.minMonth, this.minDay, main.local.invalidYear);
+              return 18;
+            },
+            /** Determine the week of the year for a date.
+                @memberof MayanCalendar
+                @param year {CDate|number} The date to examine or the year to examine.
+                @param [month] {number} The month to examine.
+                @param [day] {number} The day to examine.
+                @return {number} The week of the year.
+                @throws Error if an invalid date or a different calendar used. */
+            weekOfYear: function(year, month, day) {
+              this._validate(year, month, day, main.local.invalidDate);
+              return 0;
+            },
+            /** Retrieve the number of days in a year.
+                @memberof MayanCalendar
+                @param year {CDate|number} The date to examine or the year to examine.
+                @return {number} The number of days.
+                @throws Error if an invalid year or a different calendar used. */
+            daysInYear: function(year) {
+              this._validate(year, this.minMonth, this.minDay, main.local.invalidYear);
+              return 360;
+            },
+            /** Retrieve the number of days in a month.
+                @memberof MayanCalendar
+                @param year {CDate|number} The date to examine or the year of the month.
+                @param [month] {number} The month.
+                @return {number} The number of days in this month.
+                @throws Error if an invalid month/year or a different calendar used. */
+            daysInMonth: function(year, month) {
+              this._validate(year, month, this.minDay, main.local.invalidMonth);
+              return 20;
+            },
+            /** Retrieve the number of days in a week.
+                @memberof MayanCalendar
+                @return {number} The number of days. */
+            daysInWeek: function() {
+              return 5;
+            },
+            /** Retrieve the day of the week for a date.
+                @memberof MayanCalendar
+                @param year {CDate|number} The date to examine or the year to examine.
+                @param [month] {number} The month to examine.
+                @param [day] {number} The day to examine.
+                @return {number} The day of the week: 0 to number of days - 1.
+                @throws Error if an invalid date or a different calendar used. */
+            dayOfWeek: function(year, month, day) {
+              var date = this._validate(year, month, day, main.local.invalidDate);
+              return date.day();
+            },
+            /** Determine whether this date is a week day.
+                @memberof MayanCalendar
+                @param year {CDate|number} The date to examine or the year to examine.
+                @param [month] {number} The month to examine.
+                @param [day] {number} The day to examine.
+                @return {boolean} <code>true</code> if a week day, <code>false</code> if not.
+                @throws Error if an invalid date or a different calendar used. */
+            weekDay: function(year, month, day) {
+              this._validate(year, month, day, main.local.invalidDate);
+              return true;
+            },
+            /** Retrieve additional information about a date - Haab and Tzolkin equivalents.
+                @memberof MayanCalendar
+                @param year {CDate|number} The date to examine or the year to examine.
+                @param [month] {number} The month to examine.
+                @param [day] {number} The day to examine.
+                @return {object} Additional information - contents depends on calendar.
+                @throws Error if an invalid date or a different calendar used. */
+            extraInfo: function(year, month, day) {
+              var date = this._validate(year, month, day, main.local.invalidDate);
+              var jd2 = date.toJD();
+              var haab = this._toHaab(jd2);
+              var tzolkin = this._toTzolkin(jd2);
+              return {
+                haabMonthName: this.local.haabMonths[haab[0] - 1],
+                haabMonth: haab[0],
+                haabDay: haab[1],
+                tzolkinDayName: this.local.tzolkinMonths[tzolkin[0] - 1],
+                tzolkinDay: tzolkin[0],
+                tzolkinTrecena: tzolkin[1]
+              };
+            },
+            /** Retrieve Haab date from a Julian date.
+                @memberof MayanCalendar
+                @private
+                @param jd  {number} The Julian date.
+                @return {number[]} Corresponding Haab month and day. */
+            _toHaab: function(jd2) {
+              jd2 -= this.jdEpoch;
+              var day = mod2(jd2 + 8 + (18 - 1) * 20, 365);
+              return [Math.floor(day / 20) + 1, mod2(day, 20)];
+            },
+            /** Retrieve Tzolkin date from a Julian date.
+                @memberof MayanCalendar
+                @private
+                @param jd {number} The Julian date.
+                @return {number[]} Corresponding Tzolkin day and trecena. */
+            _toTzolkin: function(jd2) {
+              jd2 -= this.jdEpoch;
+              return [amod(jd2 + 20, 20), amod(jd2 + 4, 13)];
+            },
+            /** Retrieve the Julian date equivalent for this date,
+                i.e. days since January 1, 4713 BCE Greenwich noon.
+                @memberof MayanCalendar
+                @param year {CDate|number} The date to convert or the year to convert.
+                @param [month] {number} The month to convert.
+                @param [day] {number} The day to convert.
+                @return {number} The equivalent Julian date.
+                @throws Error if an invalid date or a different calendar used. */
+            toJD: function(year, month, day) {
+              var date = this._validate(year, month, day, main.local.invalidDate);
+              return date.day() + date.month() * 20 + date.year() * 360 + this.jdEpoch;
+            },
+            /** Create a new date from a Julian date.
+                @memberof MayanCalendar
+                @param jd {number} The Julian date to convert.
+                @return {CDate} The equivalent date. */
+            fromJD: function(jd2) {
+              jd2 = Math.floor(jd2) + 0.5 - this.jdEpoch;
+              var year = Math.floor(jd2 / 360);
+              jd2 = jd2 % 360;
+              jd2 += jd2 < 0 ? 360 : 0;
+              var month = Math.floor(jd2 / 20);
+              var day = jd2 % 20;
+              return this.newDate(year, month, day);
+            }
+          });
+          function mod2(a2, b2) {
+            return a2 - b2 * Math.floor(a2 / b2);
+          }
+          function amod(a2, b2) {
+            return mod2(a2 - 1, b2) + 1;
+          }
+          main.calendars.mayan = MayanCalendar;
+        }
+      });
+      var require_nanakshahi = __commonJS({
+        "node_modules/world-calendars/dist/calendars/nanakshahi.js"() {
+          var main = require_main();
+          var assign = require_object_assign();
+          function NanakshahiCalendar(language) {
+            this.local = this.regionalOptions[language || ""] || this.regionalOptions[""];
+          }
+          NanakshahiCalendar.prototype = new main.baseCalendar();
+          var gregorian = main.instance("gregorian");
+          assign(NanakshahiCalendar.prototype, {
+            /** The calendar name.
+                @memberof NanakshahiCalendar */
+            name: "Nanakshahi",
+            /** Julian date of start of Nanakshahi epoch: 14 March 1469 CE.
+                @memberof NanakshahiCalendar */
+            jdEpoch: 22576735e-1,
+            /** Days per month in a common year.
+                @memberof NanakshahiCalendar */
+            daysPerMonth: [31, 31, 31, 31, 31, 30, 30, 30, 30, 30, 30, 30],
+            /** <code>true</code> if has a year zero, <code>false</code> if not.
+                @memberof NanakshahiCalendar */
+            hasYearZero: false,
+            /** The minimum month number.
+                @memberof NanakshahiCalendar */
+            minMonth: 1,
+            /** The first month in the year.
+                @memberof NanakshahiCalendar */
+            firstMonth: 1,
+            /** The minimum day number.
+                @memberof NanakshahiCalendar */
+            minDay: 1,
+            /** Localisations for the plugin.
+                Entries are objects indexed by the language code ('' being the default US/English).
+                Each object has the following attributes.
+                @memberof NanakshahiCalendar
+                @property name {string} The calendar name.
+                @property epochs {string[]} The epoch names.
+                @property monthNames {string[]} The long names of the months of the year.
+                @property monthNamesShort {string[]} The short names of the months of the year.
+                @property dayNames {string[]} The long names of the days of the week.
+                @property dayNamesShort {string[]} The short names of the days of the week.
+                @property dayNamesMin {string[]} The minimal names of the days of the week.
+                @property dateFormat {string} The date format for this calendar.
+                        See the options on <a href="BaseCalendar.html#formatDate"><code>formatDate</code></a> for details.
+                @property firstDay {number} The number of the first day of the week, starting at 0.
+                @property isRTL {number} <code>true</code> if this localisation reads right-to-left. */
+            regionalOptions: {
+              // Localisations
+              "": {
+                name: "Nanakshahi",
+                epochs: ["BN", "AN"],
+                monthNames: [
+                  "Chet",
+                  "Vaisakh",
+                  "Jeth",
+                  "Harh",
+                  "Sawan",
+                  "Bhadon",
+                  "Assu",
+                  "Katak",
+                  "Maghar",
+                  "Poh",
+                  "Magh",
+                  "Phagun"
+                ],
+                monthNamesShort: ["Che", "Vai", "Jet", "Har", "Saw", "Bha", "Ass", "Kat", "Mgr", "Poh", "Mgh", "Pha"],
+                dayNames: ["Somvaar", "Mangalvar", "Budhvaar", "Veervaar", "Shukarvaar", "Sanicharvaar", "Etvaar"],
+                dayNamesShort: ["Som", "Mangal", "Budh", "Veer", "Shukar", "Sanichar", "Et"],
+                dayNamesMin: ["So", "Ma", "Bu", "Ve", "Sh", "Sa", "Et"],
+                digits: null,
+                dateFormat: "dd-mm-yyyy",
+                firstDay: 0,
+                isRTL: false
+              }
+            },
+            /** Determine whether this date is in a leap year.
+                @memberof NanakshahiCalendar
+                @param year {CDate|number} The date to examine or the year to examine.
+                @return {boolean} <code>true</code> if this is a leap year, <code>false</code> if not.
+                @throws Error if an invalid year or a different calendar used. */
+            leapYear: function(year) {
+              var date = this._validate(
+                year,
+                this.minMonth,
+                this.minDay,
+                main.local.invalidYear || main.regionalOptions[""].invalidYear
+              );
+              return gregorian.leapYear(date.year() + (date.year() < 1 ? 1 : 0) + 1469);
+            },
+            /** Determine the week of the year for a date.
+                @memberof NanakshahiCalendar
+                @param year {CDate|number} The date to examine or the year to examine.
+                @param [month] {number} The month to examine.
+                @param [day] {number} The day to examine.
+                @return {number} The week of the year.
+                @throws Error if an invalid date or a different calendar used. */
+            weekOfYear: function(year, month, day) {
+              var checkDate = this.newDate(year, month, day);
+              checkDate.add(1 - (checkDate.dayOfWeek() || 7), "d");
+              return Math.floor((checkDate.dayOfYear() - 1) / 7) + 1;
+            },
+            /** Retrieve the number of days in a month.
+                @memberof NanakshahiCalendar
+                @param year {CDate|number} The date to examine or the year of the month.
+                @param [month] {number} The month.
+                @return {number} The number of days in this month.
+                @throws Error if an invalid month/year or a different calendar used. */
+            daysInMonth: function(year, month) {
+              var date = this._validate(year, month, this.minDay, main.local.invalidMonth);
+              return this.daysPerMonth[date.month() - 1] + (date.month() === 12 && this.leapYear(date.year()) ? 1 : 0);
+            },
+            /** Determine whether this date is a week day.
+                @memberof NanakshahiCalendar
+                @param year {CDate|number} The date to examine or the year to examine.
+                @param [month] {number} The month to examine.
+                @param [day] {number} The day to examine.
+                @return {boolean} <code>true</code> if a week day, <code>false</code> if not.
+                @throws Error if an invalid date or a different calendar used. */
+            weekDay: function(year, month, day) {
+              return (this.dayOfWeek(year, month, day) || 7) < 6;
+            },
+            /** Retrieve the Julian date equivalent for this date,
+                i.e. days since January 1, 4713 BCE Greenwich noon.
+                @memberof NanakshahiCalendar
+                @param year {CDate|number} The date to convert or the year to convert.
+                @param [month] {number} The month to convert.
+                @param [day] {number} The day to convert.
+                @return {number} The equivalent Julian date.
+                @throws Error if an invalid date or a different calendar used. */
+            toJD: function(year, month, day) {
+              var date = this._validate(year, month, day, main.local.invalidMonth);
+              var year = date.year();
+              if (year < 0) {
+                year++;
+              }
+              var doy = date.day();
+              for (var m2 = 1; m2 < date.month(); m2++) {
+                doy += this.daysPerMonth[m2 - 1];
+              }
+              return doy + gregorian.toJD(year + 1468, 3, 13);
+            },
+            /** Create a new date from a Julian date.
+                @memberof NanakshahiCalendar
+                @param jd {number} The Julian date to convert.
+                @return {CDate} The equivalent date. */
+            fromJD: function(jd2) {
+              jd2 = Math.floor(jd2 + 0.5);
+              var year = Math.floor((jd2 - (this.jdEpoch - 1)) / 366);
+              while (jd2 >= this.toJD(year + 1, 1, 1)) {
+                year++;
+              }
+              var day = jd2 - Math.floor(this.toJD(year, 1, 1) + 0.5) + 1;
+              var month = 1;
+              while (day > this.daysInMonth(year, month)) {
+                day -= this.daysInMonth(year, month);
+                month++;
+              }
+              return this.newDate(year, month, day);
+            }
+          });
+          main.calendars.nanakshahi = NanakshahiCalendar;
+        }
+      });
+      var require_nepali = __commonJS({
+        "node_modules/world-calendars/dist/calendars/nepali.js"() {
+          var main = require_main();
+          var assign = require_object_assign();
+          function NepaliCalendar(language) {
+            this.local = this.regionalOptions[language || ""] || this.regionalOptions[""];
+          }
+          NepaliCalendar.prototype = new main.baseCalendar();
+          assign(NepaliCalendar.prototype, {
+            /** The calendar name.
+                @memberof NepaliCalendar */
+            name: "Nepali",
+            /** Julian date of start of Nepali epoch: 14 April 57 BCE.
+                @memberof NepaliCalendar */
+            jdEpoch: 17007095e-1,
+            /** Days per month in a common year.
+                @memberof NepaliCalendar */
+            daysPerMonth: [31, 31, 32, 32, 31, 30, 30, 29, 30, 29, 30, 30],
+            /** <code>true</code> if has a year zero, <code>false</code> if not.
+                @memberof NepaliCalendar */
+            hasYearZero: false,
+            /** The minimum month number.
+                @memberof NepaliCalendar */
+            minMonth: 1,
+            /** The first month in the year.
+                @memberof NepaliCalendar */
+            firstMonth: 1,
+            /** The minimum day number.
+                @memberof NepaliCalendar */
+            minDay: 1,
+            /** The number of days in the year.
+                @memberof NepaliCalendar */
+            daysPerYear: 365,
+            /** Localisations for the plugin.
+                Entries are objects indexed by the language code ('' being the default US/English).
+                Each object has the following attributes.
+                @memberof NepaliCalendar
+                @property name {string} The calendar name.
+                @property epochs {string[]} The epoch names.
+                @property monthNames {string[]} The long names of the months of the year.
+                @property monthNamesShort {string[]} The short names of the months of the year.
+                @property dayNames {string[]} The long names of the days of the week.
+                @property dayNamesShort {string[]} The short names of the days of the week.
+                @property dayNamesMin {string[]} The minimal names of the days of the week.
+                @property dateFormat {string} The date format for this calendar.
+                        See the options on <a href="BaseCalendar.html#formatDate"><code>formatDate</code></a> for details.
+                @property firstDay {number} The number of the first day of the week, starting at 0.
+                @property isRTL {number} <code>true</code> if this localisation reads right-to-left. */
+            regionalOptions: {
+              // Localisations
+              "": {
+                name: "Nepali",
+                epochs: ["BBS", "ABS"],
+                monthNames: [
+                  "Baisakh",
+                  "Jestha",
+                  "Ashadh",
+                  "Shrawan",
+                  "Bhadra",
+                  "Ashwin",
+                  "Kartik",
+                  "Mangsir",
+                  "Paush",
+                  "Mangh",
+                  "Falgun",
+                  "Chaitra"
+                ],
+                monthNamesShort: ["Bai", "Je", "As", "Shra", "Bha", "Ash", "Kar", "Mang", "Pau", "Ma", "Fal", "Chai"],
+                dayNames: ["Aaitabaar", "Sombaar", "Manglbaar", "Budhabaar", "Bihibaar", "Shukrabaar", "Shanibaar"],
+                dayNamesShort: ["Aaita", "Som", "Mangl", "Budha", "Bihi", "Shukra", "Shani"],
+                dayNamesMin: ["Aai", "So", "Man", "Bu", "Bi", "Shu", "Sha"],
+                digits: null,
+                dateFormat: "dd/mm/yyyy",
+                firstDay: 1,
+                isRTL: false
+              }
+            },
+            /** Determine whether this date is in a leap year.
+                @memberof NepaliCalendar
+                @param year {CDate|number} The date to examine or the year to examine.
+                @return {boolean} <code>true</code> if this is a leap year, <code>false</code> if not.
+                @throws Error if an invalid year or a different calendar used. */
+            leapYear: function(year) {
+              return this.daysInYear(year) !== this.daysPerYear;
+            },
+            /** Determine the week of the year for a date.
+                @memberof NepaliCalendar
+                @param year {CDate|number} The date to examine or the year to examine.
+                @param [month] {number} The month to examine.
+                @param [day] {number} The day to examine.
+                @return {number} The week of the year.
+                @throws Error if an invalid date or a different calendar used. */
+            weekOfYear: function(year, month, day) {
+              var checkDate = this.newDate(year, month, day);
+              checkDate.add(-checkDate.dayOfWeek(), "d");
+              return Math.floor((checkDate.dayOfYear() - 1) / 7) + 1;
+            },
+            /** Retrieve the number of days in a year.
+                @memberof NepaliCalendar
+                @param year {CDate|number} The date to examine or the year to examine.
+                @return {number} The number of days.
+                @throws Error if an invalid year or a different calendar used. */
+            daysInYear: function(year) {
+              var date = this._validate(year, this.minMonth, this.minDay, main.local.invalidYear);
+              year = date.year();
+              if (typeof this.NEPALI_CALENDAR_DATA[year] === "undefined") {
+                return this.daysPerYear;
+              }
+              var daysPerYear = 0;
+              for (var month_number = this.minMonth; month_number <= 12; month_number++) {
+                daysPerYear += this.NEPALI_CALENDAR_DATA[year][month_number];
+              }
+              return daysPerYear;
+            },
+            /** Retrieve the number of days in a month.
+                @memberof NepaliCalendar
+                @param year {CDate|number| The date to examine or the year of the month.
+                @param [month] {number} The month.
+                @return {number} The number of days in this month.
+                @throws Error if an invalid month/year or a different calendar used. */
+            daysInMonth: function(year, month) {
+              if (year.year) {
+                month = year.month();
+                year = year.year();
+              }
+              this._validate(year, month, this.minDay, main.local.invalidMonth);
+              return typeof this.NEPALI_CALENDAR_DATA[year] === "undefined" ? this.daysPerMonth[month - 1] : this.NEPALI_CALENDAR_DATA[year][month];
+            },
+            /** Determine whether this date is a week day.
+                @memberof NepaliCalendar
+                @param year {CDate|number} The date to examine or the year to examine.
+                @param [month] {number} The month to examine.
+                @param [day] {number} The day to examine.
+                @return {boolean} <code>true</code> if a week day, <code>false</code> if not.
+                @throws Error if an invalid date or a different calendar used. */
+            weekDay: function(year, month, day) {
+              return this.dayOfWeek(year, month, day) !== 6;
+            },
+            /** Retrieve the Julian date equivalent for this date,
+                i.e. days since January 1, 4713 BCE Greenwich noon.
+                @memberof NepaliCalendar
+                @param year {CDate|number} The date to convert or the year to convert.
+                @param [month] {number} The month to convert.
+                @param [day] {number} The day to convert.
+                @return {number} The equivalent Julian date.
+                @throws Error if an invalid date or a different calendar used. */
+            toJD: function(nepaliYear, nepaliMonth, nepaliDay) {
+              var date = this._validate(nepaliYear, nepaliMonth, nepaliDay, main.local.invalidDate);
+              nepaliYear = date.year();
+              nepaliMonth = date.month();
+              nepaliDay = date.day();
+              var gregorianCalendar = main.instance();
+              var gregorianDayOfYear = 0;
+              var nepaliMonthToCheck = nepaliMonth;
+              var nepaliYearToCheck = nepaliYear;
+              this._createMissingCalendarData(nepaliYear);
+              var gregorianYear = nepaliYear - (nepaliMonthToCheck > 9 || nepaliMonthToCheck === 9 && nepaliDay >= this.NEPALI_CALENDAR_DATA[nepaliYearToCheck][0] ? 56 : 57);
+              if (nepaliMonth !== 9) {
+                gregorianDayOfYear = nepaliDay;
+                nepaliMonthToCheck--;
+              }
+              while (nepaliMonthToCheck !== 9) {
+                if (nepaliMonthToCheck <= 0) {
+                  nepaliMonthToCheck = 12;
+                  nepaliYearToCheck--;
+                }
+                gregorianDayOfYear += this.NEPALI_CALENDAR_DATA[nepaliYearToCheck][nepaliMonthToCheck];
+                nepaliMonthToCheck--;
+              }
+              if (nepaliMonth === 9) {
+                gregorianDayOfYear += nepaliDay - this.NEPALI_CALENDAR_DATA[nepaliYearToCheck][0];
+                if (gregorianDayOfYear < 0) {
+                  gregorianDayOfYear += gregorianCalendar.daysInYear(gregorianYear);
+                }
+              } else {
+                gregorianDayOfYear += this.NEPALI_CALENDAR_DATA[nepaliYearToCheck][9] - this.NEPALI_CALENDAR_DATA[nepaliYearToCheck][0];
+              }
+              return gregorianCalendar.newDate(gregorianYear, 1, 1).add(gregorianDayOfYear, "d").toJD();
+            },
+            /** Create a new date from a Julian date.
+                @memberof NepaliCalendar
+                @param jd {number} The Julian date to convert.
+                @return {CDate} The equivalent date. */
+            fromJD: function(jd2) {
+              var gregorianCalendar = main.instance();
+              var gregorianDate = gregorianCalendar.fromJD(jd2);
+              var gregorianYear = gregorianDate.year();
+              var gregorianDayOfYear = gregorianDate.dayOfYear();
+              var nepaliYear = gregorianYear + 56;
+              this._createMissingCalendarData(nepaliYear);
+              var nepaliMonth = 9;
+              var dayOfFirstJanInPaush = this.NEPALI_CALENDAR_DATA[nepaliYear][0];
+              var daysSinceJanFirstToEndOfNepaliMonth = this.NEPALI_CALENDAR_DATA[nepaliYear][nepaliMonth] - dayOfFirstJanInPaush + 1;
+              while (gregorianDayOfYear > daysSinceJanFirstToEndOfNepaliMonth) {
+                nepaliMonth++;
+                if (nepaliMonth > 12) {
+                  nepaliMonth = 1;
+                  nepaliYear++;
+                }
+                daysSinceJanFirstToEndOfNepaliMonth += this.NEPALI_CALENDAR_DATA[nepaliYear][nepaliMonth];
+              }
+              var nepaliDayOfMonth = this.NEPALI_CALENDAR_DATA[nepaliYear][nepaliMonth] - (daysSinceJanFirstToEndOfNepaliMonth - gregorianDayOfYear);
+              return this.newDate(nepaliYear, nepaliMonth, nepaliDayOfMonth);
+            },
+            /** Creates missing data in the NEPALI_CALENDAR_DATA table.
+                This data will not be correct but just give an estimated result. Mostly -/+ 1 day
+                @private
+                @param nepaliYear {number} The missing year number. */
+            _createMissingCalendarData: function(nepaliYear) {
+              var tmp_calendar_data = this.daysPerMonth.slice(0);
+              tmp_calendar_data.unshift(17);
+              for (var nepaliYearToCreate = nepaliYear - 1; nepaliYearToCreate < nepaliYear + 2; nepaliYearToCreate++) {
+                if (typeof this.NEPALI_CALENDAR_DATA[nepaliYearToCreate] === "undefined") {
+                  this.NEPALI_CALENDAR_DATA[nepaliYearToCreate] = tmp_calendar_data;
+                }
+              }
+            },
+            NEPALI_CALENDAR_DATA: {
+              // These data are from http://www.ashesh.com.np
+              1970: [18, 31, 31, 32, 31, 31, 31, 30, 29, 30, 29, 30, 30],
+              1971: [18, 31, 31, 32, 31, 32, 30, 30, 29, 30, 29, 30, 30],
+              1972: [17, 31, 32, 31, 32, 31, 30, 30, 30, 29, 29, 30, 30],
+              1973: [19, 30, 32, 31, 32, 31, 30, 30, 30, 29, 30, 29, 31],
+              1974: [19, 31, 31, 32, 30, 31, 31, 30, 29, 30, 29, 30, 30],
+              1975: [18, 31, 31, 32, 32, 30, 31, 30, 29, 30, 29, 30, 30],
+              1976: [17, 31, 32, 31, 32, 31, 30, 30, 30, 29, 29, 30, 31],
+              1977: [18, 31, 32, 31, 32, 31, 31, 29, 30, 29, 30, 29, 31],
+              1978: [18, 31, 31, 32, 31, 31, 31, 30, 29, 30, 29, 30, 30],
+              1979: [18, 31, 31, 32, 32, 31, 30, 30, 29, 30, 29, 30, 30],
+              1980: [17, 31, 32, 31, 32, 31, 30, 30, 30, 29, 29, 30, 31],
+              1981: [18, 31, 31, 31, 32, 31, 31, 29, 30, 30, 29, 30, 30],
+              1982: [18, 31, 31, 32, 31, 31, 31, 30, 29, 30, 29, 30, 30],
+              1983: [18, 31, 31, 32, 32, 31, 30, 30, 29, 30, 29, 30, 30],
+              1984: [17, 31, 32, 31, 32, 31, 30, 30, 30, 29, 29, 30, 31],
+              1985: [18, 31, 31, 31, 32, 31, 31, 29, 30, 30, 29, 30, 30],
+              1986: [18, 31, 31, 32, 31, 31, 31, 30, 29, 30, 29, 30, 30],
+              1987: [18, 31, 32, 31, 32, 31, 30, 30, 29, 30, 29, 30, 30],
+              1988: [17, 31, 32, 31, 32, 31, 30, 30, 30, 29, 29, 30, 31],
+              1989: [18, 31, 31, 31, 32, 31, 31, 30, 29, 30, 29, 30, 30],
+              1990: [18, 31, 31, 32, 31, 31, 31, 30, 29, 30, 29, 30, 30],
+              1991: [18, 31, 32, 31, 32, 31, 30, 30, 29, 30, 29, 30, 30],
+              // These data are from http://nepalicalendar.rat32.com/index.php
+              1992: [17, 31, 32, 31, 32, 31, 30, 30, 30, 29, 30, 29, 31],
+              1993: [18, 31, 31, 31, 32, 31, 31, 30, 29, 30, 29, 30, 30],
+              1994: [18, 31, 31, 32, 31, 31, 31, 30, 29, 30, 29, 30, 30],
+              1995: [17, 31, 32, 31, 32, 31, 30, 30, 30, 29, 29, 30, 30],
+              1996: [17, 31, 32, 31, 32, 31, 30, 30, 30, 29, 30, 29, 31],
+              1997: [18, 31, 31, 32, 31, 31, 31, 30, 29, 30, 29, 30, 30],
+              1998: [18, 31, 31, 32, 31, 31, 31, 30, 29, 30, 29, 30, 30],
+              1999: [17, 31, 32, 31, 32, 31, 30, 30, 30, 29, 29, 30, 31],
+              2e3: [17, 30, 32, 31, 32, 31, 30, 30, 30, 29, 30, 29, 31],
+              2001: [18, 31, 31, 32, 31, 31, 31, 30, 29, 30, 29, 30, 30],
+              2002: [18, 31, 31, 32, 32, 31, 30, 30, 29, 30, 29, 30, 30],
+              2003: [17, 31, 32, 31, 32, 31, 30, 30, 30, 29, 29, 30, 31],
+              2004: [17, 30, 32, 31, 32, 31, 30, 30, 30, 29, 30, 29, 31],
+              2005: [18, 31, 31, 32, 31, 31, 31, 30, 29, 30, 29, 30, 30],
+              2006: [18, 31, 31, 32, 32, 31, 30, 30, 29, 30, 29, 30, 30],
+              2007: [17, 31, 32, 31, 32, 31, 30, 30, 30, 29, 29, 30, 31],
+              2008: [17, 31, 31, 31, 32, 31, 31, 29, 30, 30, 29, 29, 31],
+              2009: [18, 31, 31, 32, 31, 31, 31, 30, 29, 30, 29, 30, 30],
+              2010: [18, 31, 31, 32, 32, 31, 30, 30, 29, 30, 29, 30, 30],
+              2011: [17, 31, 32, 31, 32, 31, 30, 30, 30, 29, 29, 30, 31],
+              2012: [17, 31, 31, 31, 32, 31, 31, 29, 30, 30, 29, 30, 30],
+              2013: [18, 31, 31, 32, 31, 31, 31, 30, 29, 30, 29, 30, 30],
+              2014: [18, 31, 31, 32, 32, 31, 30, 30, 29, 30, 29, 30, 30],
+              2015: [17, 31, 32, 31, 32, 31, 30, 30, 30, 29, 29, 30, 31],
+              2016: [17, 31, 31, 31, 32, 31, 31, 29, 30, 30, 29, 30, 30],
+              2017: [18, 31, 31, 32, 31, 31, 31, 30, 29, 30, 29, 30, 30],
+              2018: [18, 31, 32, 31, 32, 31, 30, 30, 29, 30, 29, 30, 30],
+              2019: [17, 31, 32, 31, 32, 31, 30, 30, 30, 29, 30, 29, 31],
+              2020: [17, 31, 31, 31, 32, 31, 31, 30, 29, 30, 29, 30, 30],
+              2021: [18, 31, 31, 32, 31, 31, 31, 30, 29, 30, 29, 30, 30],
+              2022: [17, 31, 32, 31, 32, 31, 30, 30, 30, 29, 29, 30, 30],
+              2023: [17, 31, 32, 31, 32, 31, 30, 30, 30, 29, 30, 29, 31],
+              2024: [17, 31, 31, 31, 32, 31, 31, 30, 29, 30, 29, 30, 30],
+              2025: [18, 31, 31, 32, 31, 31, 31, 30, 29, 30, 29, 30, 30],
+              2026: [17, 31, 32, 31, 32, 31, 30, 30, 30, 29, 29, 30, 31],
+              2027: [17, 30, 32, 31, 32, 31, 30, 30, 30, 29, 30, 29, 31],
+              2028: [17, 31, 31, 32, 31, 31, 31, 30, 29, 30, 29, 30, 30],
+              2029: [18, 31, 31, 32, 31, 32, 30, 30, 29, 30, 29, 30, 30],
+              2030: [17, 31, 32, 31, 32, 31, 30, 30, 30, 30, 30, 30, 31],
+              2031: [17, 31, 32, 31, 32, 31, 31, 31, 31, 31, 31, 31, 31],
+              2032: [17, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32],
+              2033: [18, 31, 31, 32, 32, 31, 30, 30, 29, 30, 29, 30, 30],
+              2034: [17, 31, 32, 31, 32, 31, 30, 30, 30, 29, 29, 30, 31],
+              2035: [17, 30, 32, 31, 32, 31, 31, 29, 30, 30, 29, 29, 31],
+              2036: [17, 31, 31, 32, 31, 31, 31, 30, 29, 30, 29, 30, 30],
+              2037: [18, 31, 31, 32, 32, 31, 30, 30, 29, 30, 29, 30, 30],
+              2038: [17, 31, 32, 31, 32, 31, 30, 30, 30, 29, 29, 30, 31],
+              2039: [17, 31, 31, 31, 32, 31, 31, 29, 30, 30, 29, 30, 30],
+              2040: [17, 31, 31, 32, 31, 31, 31, 30, 29, 30, 29, 30, 30],
+              2041: [18, 31, 31, 32, 32, 31, 30, 30, 29, 30, 29, 30, 30],
+              2042: [17, 31, 32, 31, 32, 31, 30, 30, 30, 29, 29, 30, 31],
+              2043: [17, 31, 31, 31, 32, 31, 31, 29, 30, 30, 29, 30, 30],
+              2044: [17, 31, 31, 32, 31, 31, 31, 30, 29, 30, 29, 30, 30],
+              2045: [18, 31, 32, 31, 32, 31, 30, 30, 29, 30, 29, 30, 30],
+              2046: [17, 31, 32, 31, 32, 31, 30, 30, 30, 29, 29, 30, 31],
+              2047: [17, 31, 31, 31, 32, 31, 31, 30, 29, 30, 29, 30, 30],
+              2048: [17, 31, 31, 32, 31, 31, 31, 30, 29, 30, 29, 30, 30],
+              2049: [17, 31, 32, 31, 32, 31, 30, 30, 30, 29, 29, 30, 30],
+              2050: [17, 31, 32, 31, 32, 31, 30, 30, 30, 29, 30, 29, 31],
+              2051: [17, 31, 31, 31, 32, 31, 31, 30, 29, 30, 29, 30, 30],
+              2052: [17, 31, 31, 32, 31, 31, 31, 30, 29, 30, 29, 30, 30],
+              2053: [17, 31, 32, 31, 32, 31, 30, 30, 30, 29, 29, 30, 30],
+              2054: [17, 31, 32, 31, 32, 31, 30, 30, 30, 29, 30, 29, 31],
+              2055: [17, 31, 31, 32, 31, 31, 31, 30, 29, 30, 30, 29, 30],
+              2056: [17, 31, 31, 32, 31, 32, 30, 30, 29, 30, 29, 30, 30],
+              2057: [17, 31, 32, 31, 32, 31, 30, 30, 30, 29, 29, 30, 31],
+              2058: [17, 30, 32, 31, 32, 31, 30, 30, 30, 29, 30, 29, 31],
+              2059: [17, 31, 31, 32, 31, 31, 31, 30, 29, 30, 29, 30, 30],
+              2060: [17, 31, 31, 32, 32, 31, 30, 30, 29, 30, 29, 30, 30],
+              2061: [17, 31, 32, 31, 32, 31, 30, 30, 30, 29, 29, 30, 31],
+              2062: [17, 30, 32, 31, 32, 31, 31, 29, 30, 29, 30, 29, 31],
+              2063: [17, 31, 31, 32, 31, 31, 31, 30, 29, 30, 29, 30, 30],
+              2064: [17, 31, 31, 32, 32, 31, 30, 30, 29, 30, 29, 30, 30],
+              2065: [17, 31, 32, 31, 32, 31, 30, 30, 30, 29, 29, 30, 31],
+              2066: [17, 31, 31, 31, 32, 31, 31, 29, 30, 30, 29, 29, 31],
+              2067: [17, 31, 31, 32, 31, 31, 31, 30, 29, 30, 29, 30, 30],
+              2068: [17, 31, 31, 32, 32, 31, 30, 30, 29, 30, 29, 30, 30],
+              2069: [17, 31, 32, 31, 32, 31, 30, 30, 30, 29, 29, 30, 31],
+              2070: [17, 31, 31, 31, 32, 31, 31, 29, 30, 30, 29, 30, 30],
+              2071: [17, 31, 31, 32, 31, 31, 31, 30, 29, 30, 29, 30, 30],
+              2072: [17, 31, 32, 31, 32, 31, 30, 30, 29, 30, 29, 30, 30],
+              2073: [17, 31, 32, 31, 32, 31, 30, 30, 30, 29, 29, 30, 31],
+              2074: [17, 31, 31, 31, 32, 31, 31, 30, 29, 30, 29, 30, 30],
+              2075: [17, 31, 31, 32, 31, 31, 31, 30, 29, 30, 29, 30, 30],
+              2076: [16, 31, 32, 31, 32, 31, 30, 30, 30, 29, 29, 30, 30],
+              2077: [17, 31, 32, 31, 32, 31, 30, 30, 30, 29, 30, 29, 31],
+              2078: [17, 31, 31, 31, 32, 31, 31, 30, 29, 30, 29, 30, 30],
+              2079: [17, 31, 31, 32, 31, 31, 31, 30, 29, 30, 29, 30, 30],
+              2080: [16, 31, 32, 31, 32, 31, 30, 30, 30, 29, 29, 30, 30],
+              // These data are from http://www.ashesh.com.np/nepali-calendar/
+              2081: [17, 31, 31, 32, 32, 31, 30, 30, 30, 29, 30, 30, 30],
+              2082: [17, 31, 32, 31, 32, 31, 30, 30, 30, 29, 30, 30, 30],
+              2083: [17, 31, 31, 32, 31, 31, 30, 30, 30, 29, 30, 30, 30],
+              2084: [17, 31, 31, 32, 31, 31, 30, 30, 30, 29, 30, 30, 30],
+              2085: [17, 31, 32, 31, 32, 31, 31, 30, 30, 29, 30, 30, 30],
+              2086: [17, 31, 32, 31, 32, 31, 30, 30, 30, 29, 30, 30, 30],
+              2087: [16, 31, 31, 32, 31, 31, 31, 30, 30, 29, 30, 30, 30],
+              2088: [16, 30, 31, 32, 32, 30, 31, 30, 30, 29, 30, 30, 30],
+              2089: [17, 31, 32, 31, 32, 31, 30, 30, 30, 29, 30, 30, 30],
+              2090: [17, 31, 32, 31, 32, 31, 30, 30, 30, 29, 30, 30, 30],
+              2091: [16, 31, 31, 32, 31, 31, 31, 30, 30, 29, 30, 30, 30],
+              2092: [16, 31, 31, 32, 32, 31, 30, 30, 30, 29, 30, 30, 30],
+              2093: [17, 31, 32, 31, 32, 31, 30, 30, 30, 29, 30, 30, 30],
+              2094: [17, 31, 31, 32, 31, 31, 30, 30, 30, 29, 30, 30, 30],
+              2095: [17, 31, 31, 32, 31, 31, 31, 30, 29, 30, 30, 30, 30],
+              2096: [17, 30, 31, 32, 32, 31, 30, 30, 29, 30, 29, 30, 30],
+              2097: [17, 31, 32, 31, 32, 31, 30, 30, 30, 29, 30, 30, 30],
+              2098: [17, 31, 31, 32, 31, 31, 31, 29, 30, 29, 30, 30, 31],
+              2099: [17, 31, 31, 32, 31, 31, 31, 30, 29, 29, 30, 30, 30],
+              2100: [17, 31, 32, 31, 32, 30, 31, 30, 29, 30, 29, 30, 30]
+            }
+          });
+          main.calendars.nepali = NepaliCalendar;
+        }
+      });
+      var require_persian = __commonJS({
+        "node_modules/world-calendars/dist/calendars/persian.js"() {
+          var main = require_main();
+          var assign = require_object_assign();
+          function PersianCalendar(language) {
+            this.local = this.regionalOptions[language || ""] || this.regionalOptions[""];
+          }
+          function _leapYear(year) {
+            var x2 = year - 475;
+            if (year < 0) x2++;
+            var c2 = 0.242197;
+            var v0 = c2 * x2;
+            var v1 = c2 * (x2 + 1);
+            var r0 = v0 - Math.floor(v0);
+            var r1 = v1 - Math.floor(v1);
+            return r0 > r1;
+          }
+          PersianCalendar.prototype = new main.baseCalendar();
+          assign(PersianCalendar.prototype, {
+            /** The calendar name.
+                @memberof PersianCalendar */
+            name: "Persian",
+            /** Julian date of start of Persian epoch: 19 March 622 CE.
+                @memberof PersianCalendar */
+            jdEpoch: 19483205e-1,
+            /** Days per month in a common year.
+                @memberof PersianCalendar */
+            daysPerMonth: [31, 31, 31, 31, 31, 31, 30, 30, 30, 30, 30, 29],
+            /** <code>true</code> if has a year zero, <code>false</code> if not.
+                @memberof PersianCalendar */
+            hasYearZero: false,
+            /** The minimum month number.
+                @memberof PersianCalendar */
+            minMonth: 1,
+            /** The first month in the year.
+                @memberof PersianCalendar */
+            firstMonth: 1,
+            /** The minimum day number.
+                @memberof PersianCalendar */
+            minDay: 1,
+            /** Localisations for the plugin.
+                Entries are objects indexed by the language code ('' being the default US/English).
+                Each object has the following attributes.
+                @memberof PersianCalendar
+                @property name {string} The calendar name.
+                @property epochs {string[]} The epoch names.
+                @property monthNames {string[]} The long names of the months of the year.
+                @property monthNamesShort {string[]} The short names of the months of the year.
+                @property dayNames {string[]} The long names of the days of the week.
+                @property dayNamesShort {string[]} The short names of the days of the week.
+                @property dayNamesMin {string[]} The minimal names of the days of the week.
+                @property dateFormat {string} The date format for this calendar.
+                        See the options on <a href="BaseCalendar.html#formatDate"><code>formatDate</code></a> for details.
+                @property firstDay {number} The number of the first day of the week, starting at 0.
+                @property isRTL {number} <code>true</code> if this localisation reads right-to-left. */
+            regionalOptions: {
+              // Localisations
+              "": {
+                name: "Persian",
+                epochs: ["BP", "AP"],
+                monthNames: [
+                  "Farvardin",
+                  "Ordibehesht",
+                  "Khordad",
+                  "Tir",
+                  "Mordad",
+                  "Shahrivar",
+                  "Mehr",
+                  "Aban",
+                  "Azar",
+                  "Dey",
+                  "Bahman",
+                  "Esfand"
+                ],
+                monthNamesShort: ["Far", "Ord", "Kho", "Tir", "Mor", "Sha", "Meh", "Aba", "Aza", "Dey", "Bah", "Esf"],
+                dayNames: ["Yekshanbeh", "Doshanbeh", "Seshanbeh", "Chahārshanbeh", "Panjshanbeh", "Jom'eh", "Shanbeh"],
+                dayNamesShort: ["Yek", "Do", "Se", "Cha", "Panj", "Jom", "Sha"],
+                dayNamesMin: ["Ye", "Do", "Se", "Ch", "Pa", "Jo", "Sh"],
+                digits: null,
+                dateFormat: "yyyy/mm/dd",
+                firstDay: 6,
+                isRTL: false
+              }
+            },
+            /** Determine whether this date is in a leap year.
+                @memberof PersianCalendar
+                @param year {CDate|number} The date to examine or the year to examine.
+                @return {boolean} <code>true</code> if this is a leap year, <code>false</code> if not.
+                @throws Error if an invalid year or a different calendar used. */
+            leapYear: function(year) {
+              var date = this._validate(year, this.minMonth, this.minDay, main.local.invalidYear);
+              return _leapYear(date.year());
+            },
+            /** Determine the week of the year for a date.
+                @memberof PersianCalendar
+                @param year {CDate|number} The date to examine or the year to examine.
+                @param [month] {number} The month to examine.
+                @param [day] {number} The day to examine.
+                @return {number} The week of the year.
+                @throws Error if an invalid date or a different calendar used. */
+            weekOfYear: function(year, month, day) {
+              var checkDate = this.newDate(year, month, day);
+              checkDate.add(-((checkDate.dayOfWeek() + 1) % 7), "d");
+              return Math.floor((checkDate.dayOfYear() - 1) / 7) + 1;
+            },
+            /** Retrieve the number of days in a month.
+                @memberof PersianCalendar
+                @param year {CDate|number} The date to examine or the year of the month.
+                @param [month] {number} The month.
+                @return {number} The number of days in this month.
+                @throws Error if an invalid month/year or a different calendar used. */
+            daysInMonth: function(year, month) {
+              var date = this._validate(year, month, this.minDay, main.local.invalidMonth);
+              return this.daysPerMonth[date.month() - 1] + (date.month() === 12 && this.leapYear(date.year()) ? 1 : 0);
+            },
+            /** Determine whether this date is a week day.
+                @memberof PersianCalendar
+                @param year {CDate|number} The date to examine or the year to examine.
+                @param [month] {number} The month to examine.
+                @param [day] {number} The day to examine.
+                @return {boolean} <code>true</code> if a week day, <code>false</code> if not.
+                @throws Error if an invalid date or a different calendar used. */
+            weekDay: function(year, month, day) {
+              return this.dayOfWeek(year, month, day) !== 5;
+            },
+            /** Retrieve the Julian date equivalent for this date,
+                i.e. days since January 1, 4713 BCE Greenwich noon.
+                @memberof PersianCalendar
+                @param year {CDate|number} The date to convert or the year to convert.
+                @param [month] {number} The month to convert.
+                @param [day] {number} The day to convert.
+                @return {number} The equivalent Julian date.
+                @throws Error if an invalid date or a different calendar used. */
+            toJD: function(year, month, day) {
+              var date = this._validate(year, month, day, main.local.invalidDate);
+              year = date.year();
+              month = date.month();
+              day = date.day();
+              var nLeapYearsSince = 0;
+              if (year > 0) {
+                for (var i2 = 1; i2 < year; i2++) {
+                  if (_leapYear(i2)) nLeapYearsSince++;
+                }
+              } else if (year < 0) {
+                for (var i2 = year; i2 < 0; i2++) {
+                  if (_leapYear(i2)) nLeapYearsSince--;
+                }
+              }
+              return day + (month <= 7 ? (month - 1) * 31 : (month - 1) * 30 + 6) + (year > 0 ? year - 1 : year) * 365 + nLeapYearsSince + this.jdEpoch - 1;
+            },
+            /** Create a new date from a Julian date.
+                @memberof PersianCalendar
+                @param jd {number} The Julian date to convert.
+                @return {CDate} The equivalent date. */
+            fromJD: function(jd2) {
+              jd2 = Math.floor(jd2) + 0.5;
+              var y2 = 475 + (jd2 - this.toJD(475, 1, 1)) / 365.242197;
+              var year = Math.floor(y2);
+              if (year <= 0) year--;
+              if (jd2 > this.toJD(year, 12, _leapYear(year) ? 30 : 29)) {
+                year++;
+                if (year === 0) year++;
+              }
+              var yday = jd2 - this.toJD(year, 1, 1) + 1;
+              var month = yday <= 186 ? Math.ceil(yday / 31) : Math.ceil((yday - 6) / 30);
+              var day = jd2 - this.toJD(year, month, 1) + 1;
+              return this.newDate(year, month, day);
+            }
+          });
+          main.calendars.persian = PersianCalendar;
+          main.calendars.jalali = PersianCalendar;
+        }
+      });
+      var require_taiwan = __commonJS({
+        "node_modules/world-calendars/dist/calendars/taiwan.js"() {
+          var main = require_main();
+          var assign = require_object_assign();
+          var gregorianCalendar = main.instance();
+          function TaiwanCalendar(language) {
+            this.local = this.regionalOptions[language || ""] || this.regionalOptions[""];
+          }
+          TaiwanCalendar.prototype = new main.baseCalendar();
+          assign(TaiwanCalendar.prototype, {
+            /** The calendar name.
+                @memberof TaiwanCalendar */
+            name: "Taiwan",
+            /** Julian date of start of Taiwan epoch: 1 January 1912 CE (Gregorian).
+                @memberof TaiwanCalendar */
+            jdEpoch: 24194025e-1,
+            /** Difference in years between Taiwan and Gregorian calendars.
+                @memberof TaiwanCalendar */
+            yearsOffset: 1911,
+            /** Days per month in a common year.
+                @memberof TaiwanCalendar */
+            daysPerMonth: [31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31],
+            /** <code>true</code> if has a year zero, <code>false</code> if not.
+                @memberof TaiwanCalendar */
+            hasYearZero: false,
+            /** The minimum month number.
+                @memberof TaiwanCalendar */
+            minMonth: 1,
+            /** The first month in the year.
+                @memberof TaiwanCalendar */
+            firstMonth: 1,
+            /** The minimum day number.
+                @memberof TaiwanCalendar */
+            minDay: 1,
+            /** Localisations for the plugin.
+                Entries are objects indexed by the language code ('' being the default US/English).
+                Each object has the following attributes.
+                @memberof TaiwanCalendar
+                @property name {string} The calendar name.
+                @property epochs {string[]} The epoch names.
+                @property monthNames {string[]} The long names of the months of the year.
+                @property monthNamesShort {string[]} The short names of the months of the year.
+                @property dayNames {string[]} The long names of the days of the week.
+                @property dayNamesShort {string[]} The short names of the days of the week.
+                @property dayNamesMin {string[]} The minimal names of the days of the week.
+                @property dateFormat {string} The date format for this calendar.
+                        See the options on <a href="BaseCalendar.html#formatDate"><code>formatDate</code></a> for details.
+                @property firstDay {number} The number of the first day of the week, starting at 0.
+                @property isRTL {number} <code>true</code> if this localisation reads right-to-left. */
+            regionalOptions: {
+              // Localisations
+              "": {
+                name: "Taiwan",
+                epochs: ["BROC", "ROC"],
+                monthNames: [
+                  "January",
+                  "February",
+                  "March",
+                  "April",
+                  "May",
+                  "June",
+                  "July",
+                  "August",
+                  "September",
+                  "October",
+                  "November",
+                  "December"
+                ],
+                monthNamesShort: ["Jan", "Feb", "Mar", "Apr", "May", "Jun", "Jul", "Aug", "Sep", "Oct", "Nov", "Dec"],
+                dayNames: ["Sunday", "Monday", "Tuesday", "Wednesday", "Thursday", "Friday", "Saturday"],
+                dayNamesShort: ["Sun", "Mon", "Tue", "Wed", "Thu", "Fri", "Sat"],
+                dayNamesMin: ["Su", "Mo", "Tu", "We", "Th", "Fr", "Sa"],
+                digits: null,
+                dateFormat: "yyyy/mm/dd",
+                firstDay: 1,
+                isRTL: false
+              }
+            },
+            /** Determine whether this date is in a leap year.
+                @memberof TaiwanCalendar
+                @param year {CDate|number} The date to examine or the year to examine.
+                @return {boolean} <code>true</code> if this is a leap year, <code>false</code> if not.
+                @throws Error if an invalid year or a different calendar used. */
+            leapYear: function(year) {
+              var date = this._validate(year, this.minMonth, this.minDay, main.local.invalidYear);
+              var year = this._t2gYear(date.year());
+              return gregorianCalendar.leapYear(year);
+            },
+            /** Determine the week of the year for a date - ISO 8601.
+                @memberof TaiwanCalendar
+                @param year {CDate|number} The date to examine or the year to examine.
+                @param [month] {number} The month to examine.
+                @param [day] {number} The day to examine.
+                @return {number} The week of the year.
+                @throws Error if an invalid date or a different calendar used. */
+            weekOfYear: function(year, month, day) {
+              var date = this._validate(year, this.minMonth, this.minDay, main.local.invalidYear);
+              var year = this._t2gYear(date.year());
+              return gregorianCalendar.weekOfYear(year, date.month(), date.day());
+            },
+            /** Retrieve the number of days in a month.
+                @memberof TaiwanCalendar
+                @param year {CDate|number} The date to examine or the year of the month.
+                @param [month] {number} The month.
+                @return {number} The number of days in this month.
+                @throws Error if an invalid month/year or a different calendar used. */
+            daysInMonth: function(year, month) {
+              var date = this._validate(year, month, this.minDay, main.local.invalidMonth);
+              return this.daysPerMonth[date.month() - 1] + (date.month() === 2 && this.leapYear(date.year()) ? 1 : 0);
+            },
+            /** Determine whether this date is a week day.
+                @memberof TaiwanCalendar
+                @param year {CDate|number} The date to examine or the year to examine.
+                @param [month] {number} The month to examine.
+                @param [day] {number} The day to examine.
+                @return {boolean} <code>true</code> if a week day, <code>false</code> if not.
+                @throws Error if an invalid date or a different calendar used. */
+            weekDay: function(year, month, day) {
+              return (this.dayOfWeek(year, month, day) || 7) < 6;
+            },
+            /** Retrieve the Julian date equivalent for this date,
+                i.e. days since January 1, 4713 BCE Greenwich noon.
+                @memberof TaiwanCalendar
+                @param year {CDate|number} The date to convert or the year to convert.
+                @param [month] {number} The month to convert.
+                @param [day] {number} The day to convert.
+                @return {number} The equivalent Julian date.
+                @throws Error if an invalid date or a different calendar used. */
+            toJD: function(year, month, day) {
+              var date = this._validate(year, month, day, main.local.invalidDate);
+              var year = this._t2gYear(date.year());
+              return gregorianCalendar.toJD(year, date.month(), date.day());
+            },
+            /** Create a new date from a Julian date.
+                @memberof TaiwanCalendar
+                @param jd {number} The Julian date to convert.
+                @return {CDate} The equivalent date. */
+            fromJD: function(jd2) {
+              var date = gregorianCalendar.fromJD(jd2);
+              var year = this._g2tYear(date.year());
+              return this.newDate(year, date.month(), date.day());
+            },
+            /** Convert Taiwanese to Gregorian year.
+                @memberof TaiwanCalendar
+                @private
+                @param year {number} The Taiwanese year.
+                @return {number} The corresponding Gregorian year. */
+            _t2gYear: function(year) {
+              return year + this.yearsOffset + (year >= -this.yearsOffset && year <= -1 ? 1 : 0);
+            },
+            /** Convert Gregorian to Taiwanese year.
+                @memberof TaiwanCalendar
+                @private
+                @param year {number} The Gregorian year.
+                @return {number} The corresponding Taiwanese year. */
+            _g2tYear: function(year) {
+              return year - this.yearsOffset - (year >= 1 && year <= this.yearsOffset ? 1 : 0);
+            }
+          });
+          main.calendars.taiwan = TaiwanCalendar;
+        }
+      });
+      var require_thai = __commonJS({
+        "node_modules/world-calendars/dist/calendars/thai.js"() {
+          var main = require_main();
+          var assign = require_object_assign();
+          var gregorianCalendar = main.instance();
+          function ThaiCalendar(language) {
+            this.local = this.regionalOptions[language || ""] || this.regionalOptions[""];
+          }
+          ThaiCalendar.prototype = new main.baseCalendar();
+          assign(ThaiCalendar.prototype, {
+            /** The calendar name.
+                @memberof ThaiCalendar */
+            name: "Thai",
+            /** Julian date of start of Thai epoch: 1 January 543 BCE (Gregorian).
+                @memberof ThaiCalendar */
+            jdEpoch: 15230985e-1,
+            /** Difference in years between Thai and Gregorian calendars.
+                @memberof ThaiCalendar */
+            yearsOffset: 543,
+            /** Days per month in a common year.
+                @memberof ThaiCalendar */
+            daysPerMonth: [31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31],
+            /** <code>true</code> if has a year zero, <code>false</code> if not.
+                @memberof ThaiCalendar */
+            hasYearZero: false,
+            /** The minimum month number.
+                @memberof ThaiCalendar */
+            minMonth: 1,
+            /** The first month in the year.
+                @memberof ThaiCalendar */
+            firstMonth: 1,
+            /** The minimum day number.
+                @memberof ThaiCalendar */
+            minDay: 1,
+            /** Localisations for the plugin.
+                Entries are objects indexed by the language code ('' being the default US/English).
+                Each object has the following attributes.
+                @memberof ThaiCalendar
+                @property name {string} The calendar name.
+                @property epochs {string[]} The epoch names.
+                @property monthNames {string[]} The long names of the months of the year.
+                @property monthNamesShort {string[]} The short names of the months of the year.
+                @property dayNames {string[]} The long names of the days of the week.
+                @property dayNamesShort {string[]} The short names of the days of the week.
+                @property dayNamesMin {string[]} The minimal names of the days of the week.
+                @property dateFormat {string} The date format for this calendar.
+                        See the options on <a href="BaseCalendar.html#formatDate"><code>formatDate</code></a> for details.
+                @property firstDay {number} The number of the first day of the week, starting at 0.
+                @property isRTL {number} <code>true</code> if this localisation reads right-to-left. */
+            regionalOptions: {
+              // Localisations
+              "": {
+                name: "Thai",
+                epochs: ["BBE", "BE"],
+                monthNames: [
+                  "January",
+                  "February",
+                  "March",
+                  "April",
+                  "May",
+                  "June",
+                  "July",
+                  "August",
+                  "September",
+                  "October",
+                  "November",
+                  "December"
+                ],
+                monthNamesShort: ["Jan", "Feb", "Mar", "Apr", "May", "Jun", "Jul", "Aug", "Sep", "Oct", "Nov", "Dec"],
+                dayNames: ["Sunday", "Monday", "Tuesday", "Wednesday", "Thursday", "Friday", "Saturday"],
+                dayNamesShort: ["Sun", "Mon", "Tue", "Wed", "Thu", "Fri", "Sat"],
+                dayNamesMin: ["Su", "Mo", "Tu", "We", "Th", "Fr", "Sa"],
+                digits: null,
+                dateFormat: "dd/mm/yyyy",
+                firstDay: 0,
+                isRTL: false
+              }
+            },
+            /** Determine whether this date is in a leap year.
+                @memberof ThaiCalendar
+                @param year {CDate|number} The date to examine or the year to examine.
+                @return {boolean} <code>true</code> if this is a leap year, <code>false</code> if not.
+                @throws Error if an invalid year or a different calendar used. */
+            leapYear: function(year) {
+              var date = this._validate(year, this.minMonth, this.minDay, main.local.invalidYear);
+              var year = this._t2gYear(date.year());
+              return gregorianCalendar.leapYear(year);
+            },
+            /** Determine the week of the year for a date - ISO 8601.
+                @memberof ThaiCalendar
+                @param year {CDate|number} The date to examine or the year to examine.
+                @param [month] {number} The month to examine.
+                @param [day] {number} The day to examine.
+                @return {number} The week of the year.
+                @throws Error if an invalid date or a different calendar used. */
+            weekOfYear: function(year, month, day) {
+              var date = this._validate(year, this.minMonth, this.minDay, main.local.invalidYear);
+              var year = this._t2gYear(date.year());
+              return gregorianCalendar.weekOfYear(year, date.month(), date.day());
+            },
+            /** Retrieve the number of days in a month.
+                @memberof ThaiCalendar
+                @param year {CDate|number} The date to examine or the year of the month.
+                @param [month] {number} The month.
+                @return {number} The number of days in this month.
+                @throws Error if an invalid month/year or a different calendar used. */
+            daysInMonth: function(year, month) {
+              var date = this._validate(year, month, this.minDay, main.local.invalidMonth);
+              return this.daysPerMonth[date.month() - 1] + (date.month() === 2 && this.leapYear(date.year()) ? 1 : 0);
+            },
+            /** Determine whether this date is a week day.
+                @memberof ThaiCalendar
+                @param year {CDate|number} The date to examine or the year to examine.
+                @param [month] {number} The month to examine.
+                @param [day] {number} The day to examine.
+                @return {boolean} <code>true</code> if a week day, <code>false</code> if not.
+                @throws Error if an invalid date or a different calendar used. */
+            weekDay: function(year, month, day) {
+              return (this.dayOfWeek(year, month, day) || 7) < 6;
+            },
+            /** Retrieve the Julian date equivalent for this date,
+                i.e. days since January 1, 4713 BCE Greenwich noon.
+                @memberof ThaiCalendar
+                @param year {CDate|number} The date to convert or the year to convert.
+                @param [month] {number} The month to convert.
+                @param [day] {number} The day to convert.
+                @return {number} The equivalent Julian date.
+                @throws Error if an invalid date or a different calendar used. */
+            toJD: function(year, month, day) {
+              var date = this._validate(year, month, day, main.local.invalidDate);
+              var year = this._t2gYear(date.year());
+              return gregorianCalendar.toJD(year, date.month(), date.day());
+            },
+            /** Create a new date from a Julian date.
+                @memberof ThaiCalendar
+                @param jd {number} The Julian date to convert.
+                @return {CDate} The equivalent date. */
+            fromJD: function(jd2) {
+              var date = gregorianCalendar.fromJD(jd2);
+              var year = this._g2tYear(date.year());
+              return this.newDate(year, date.month(), date.day());
+            },
+            /** Convert Thai to Gregorian year.
+                @memberof ThaiCalendar
+                @private
+                @param year {number} The Thai year.
+                @return {number} The corresponding Gregorian year. */
+            _t2gYear: function(year) {
+              return year - this.yearsOffset - (year >= 1 && year <= this.yearsOffset ? 1 : 0);
+            },
+            /** Convert Gregorian to Thai year.
+                @memberof ThaiCalendar
+                @private
+                @param year {number} The Gregorian year.
+                @return {number} The corresponding Thai year. */
+            _g2tYear: function(year) {
+              return year + this.yearsOffset + (year >= -this.yearsOffset && year <= -1 ? 1 : 0);
+            }
+          });
+          main.calendars.thai = ThaiCalendar;
+        }
+      });
+      var require_ummalqura = __commonJS({
+        "node_modules/world-calendars/dist/calendars/ummalqura.js"() {
+          var main = require_main();
+          var assign = require_object_assign();
+          function UmmAlQuraCalendar(language) {
+            this.local = this.regionalOptions[language || ""] || this.regionalOptions[""];
+          }
+          UmmAlQuraCalendar.prototype = new main.baseCalendar();
+          assign(UmmAlQuraCalendar.prototype, {
+            /** The calendar name.
+                @memberof UmmAlQuraCalendar */
+            name: "UmmAlQura",
+            //jdEpoch: 1948440, // Julian date of start of UmmAlQura epoch: 14 March 1937 CE
+            //daysPerMonth: // Days per month in a common year, replaced by a method.
+            /** <code>true</code> if has a year zero, <code>false</code> if not.
+                @memberof UmmAlQuraCalendar */
+            hasYearZero: false,
+            /** The minimum month number.
+                @memberof UmmAlQuraCalendar */
+            minMonth: 1,
+            /** The first month in the year.
+                @memberof UmmAlQuraCalendar */
+            firstMonth: 1,
+            /** The minimum day number.
+                @memberof UmmAlQuraCalendar */
+            minDay: 1,
+            /** Localisations for the plugin.
+                Entries are objects indexed by the language code ('' being the default US/English).
+                Each object has the following attributes.
+                @memberof UmmAlQuraCalendar
+                @property name {string} The calendar name.
+                @property epochs {string[]} The epoch names.
+                @property monthNames {string[]} The long names of the months of the year.
+                @property monthNamesShort {string[]} The short names of the months of the year.
+                @property dayNames {string[]} The long names of the days of the week.
+                @property dayNamesShort {string[]} The short names of the days of the week.
+                @property dayNamesMin {string[]} The minimal names of the days of the week.
+                @property dateFormat {string} The date format for this calendar.
+                        See the options on <a href="BaseCalendar.html#formatDate"><code>formatDate</code></a> for details.
+                @property firstDay {number} The number of the first day of the week, starting at 0.
+                @property isRTL {number} <code>true</code> if this localisation reads right-to-left. */
+            regionalOptions: {
+              // Localisations
+              "": {
+                name: "Umm al-Qura",
+                epochs: ["BH", "AH"],
+                monthNames: [
+                  "Al-Muharram",
+                  "Safar",
+                  "Rabi' al-awwal",
+                  "Rabi' Al-Thani",
+                  "Jumada Al-Awwal",
+                  "Jumada Al-Thani",
+                  "Rajab",
+                  "Sha'aban",
+                  "Ramadan",
+                  "Shawwal",
+                  "Dhu al-Qi'dah",
+                  "Dhu al-Hijjah"
+                ],
+                monthNamesShort: ["Muh", "Saf", "Rab1", "Rab2", "Jum1", "Jum2", "Raj", "Sha'", "Ram", "Shaw", "DhuQ", "DhuH"],
+                dayNames: ["Yawm al-Ahad", "Yawm al-Ithnain", "Yawm al-Thalāthā’", "Yawm al-Arba‘ā’", "Yawm al-Khamīs", "Yawm al-Jum‘a", "Yawm al-Sabt"],
+                dayNamesMin: ["Ah", "Ith", "Th", "Ar", "Kh", "Ju", "Sa"],
+                digits: null,
+                dateFormat: "yyyy/mm/dd",
+                firstDay: 6,
+                isRTL: true
+              }
+            },
+            /** Determine whether this date is in a leap year.
+                @memberof UmmAlQuraCalendar
+                @param year {CDate|number} The date to examine or the year to examine.
+                @return {boolean} <code>true</code> if this is a leap year, <code>false</code> if not.
+                @throws Error if an invalid year or a different calendar used. */
+            leapYear: function(year) {
+              var date = this._validate(year, this.minMonth, this.minDay, main.local.invalidYear);
+              return this.daysInYear(date.year()) === 355;
+            },
+            /** Determine the week of the year for a date.
+                @memberof UmmAlQuraCalendar
+                @param year {CDate|number} The date to examine or the year to examine.
+                @param [month] {number} The month to examine.
+                @param [day] {number} The day to examine.
+                @return {number} The week of the year.
+                @throws Error if an invalid date or a different calendar used. */
+            weekOfYear: function(year, month, day) {
+              var checkDate = this.newDate(year, month, day);
+              checkDate.add(-checkDate.dayOfWeek(), "d");
+              return Math.floor((checkDate.dayOfYear() - 1) / 7) + 1;
+            },
+            /** Retrieve the number of days in a year.
+                @memberof UmmAlQuraCalendar
+                @param year {CDate|number} The date to examine or the year to examine.
+                @return {number} The number of days.
+                @throws Error if an invalid year or a different calendar used. */
+            daysInYear: function(year) {
+              var daysCount = 0;
+              for (var i2 = 1; i2 <= 12; i2++) {
+                daysCount += this.daysInMonth(year, i2);
+              }
+              return daysCount;
+            },
+            /** Retrieve the number of days in a month.
+                @memberof UmmAlQuraCalendar
+                @param year {CDate|number} The date to examine or the year of the month.
+                @param [month] {number} The month.
+                @return {number} The number of days in this month.
+                @throws Error if an invalid month/year or a different calendar used. */
+            daysInMonth: function(year, month) {
+              var date = this._validate(year, month, this.minDay, main.local.invalidMonth);
+              var mcjdn = date.toJD() - 24e5 + 0.5;
+              var index = 0;
+              for (var i2 = 0; i2 < ummalqura_dat.length; i2++) {
+                if (ummalqura_dat[i2] > mcjdn) {
+                  return ummalqura_dat[index] - ummalqura_dat[index - 1];
+                }
+                index++;
+              }
+              return 30;
+            },
+            /** Determine whether this date is a week day.
+                @memberof UmmAlQuraCalendar
+                @param year {CDate|number} The date to examine or the year to examine.
+                @param [month] {number} The month to examine.
+                @param [day] {number} The day to examine.
+                @return {boolean} <code>true</code> if a week day, <code>false</code> if not.
+                @throws Error if an invalid date or a different calendar used. */
+            weekDay: function(year, month, day) {
+              return this.dayOfWeek(year, month, day) !== 5;
+            },
+            /** Retrieve the Julian date equivalent for this date,
+                i.e. days since January 1, 4713 BCE Greenwich noon.
+                @memberof UmmAlQuraCalendar
+                @param year {CDate|number} The date to convert or the year to convert.
+                @param [month] {number} The month to convert.
+                @param [day] {number} The day to convert.
+                @return {number} The equivalent Julian date.
+                @throws Error if an invalid date or a different calendar used. */
+            toJD: function(year, month, day) {
+              var date = this._validate(year, month, day, main.local.invalidDate);
+              var index = 12 * (date.year() - 1) + date.month() - 15292;
+              var mcjdn = date.day() + ummalqura_dat[index - 1] - 1;
+              return mcjdn + 24e5 - 0.5;
+            },
+            /** Create a new date from a Julian date.
+                @memberof UmmAlQuraCalendar
+                @param jd {number} The Julian date to convert.
+                @return {CDate} The equivalent date. */
+            fromJD: function(jd2) {
+              var mcjdn = jd2 - 24e5 + 0.5;
+              var index = 0;
+              for (var i2 = 0; i2 < ummalqura_dat.length; i2++) {
+                if (ummalqura_dat[i2] > mcjdn) break;
+                index++;
+              }
+              var lunation = index + 15292;
+              var ii2 = Math.floor((lunation - 1) / 12);
+              var year = ii2 + 1;
+              var month = lunation - 12 * ii2;
+              var day = mcjdn - ummalqura_dat[index - 1] + 1;
+              return this.newDate(year, month, day);
+            },
+            /** Determine whether a date is valid for this calendar.
+                @memberof UmmAlQuraCalendar
+                @param year {number} The year to examine.
+                @param month {number} The month to examine.
+                @param day {number} The day to examine.
+                @return {boolean} <code>true</code> if a valid date, <code>false</code> if not. */
+            isValid: function(year, month, day) {
+              var valid = main.baseCalendar.prototype.isValid.apply(this, arguments);
+              if (valid) {
+                year = year.year != null ? year.year : year;
+                valid = year >= 1276 && year <= 1500;
+              }
+              return valid;
+            },
+            /** Check that a candidate date is from the same calendar and is valid.
+                @memberof UmmAlQuraCalendar
+                @private
+                @param year {CDate|number} The date to validate or the year to validate.
+                @param month {number} The month to validate.
+                @param day {number} The day to validate.
+                @param error {string} Error message if invalid.
+                @throws Error if different calendars used or invalid date. */
+            _validate: function(year, month, day, error) {
+              var date = main.baseCalendar.prototype._validate.apply(this, arguments);
+              if (date.year < 1276 || date.year > 1500) {
+                throw error.replace(/\{0\}/, this.local.name);
+              }
+              return date;
+            }
+          });
+          main.calendars.ummalqura = UmmAlQuraCalendar;
+          var ummalqura_dat = [
+            20,
+            50,
+            79,
+            109,
+            138,
+            168,
+            197,
+            227,
+            256,
+            286,
+            315,
+            345,
+            374,
+            404,
+            433,
+            463,
+            492,
+            522,
+            551,
+            581,
+            611,
+            641,
+            670,
+            700,
+            729,
+            759,
+            788,
+            818,
+            847,
+            877,
+            906,
+            936,
+            965,
+            995,
+            1024,
+            1054,
+            1083,
+            1113,
+            1142,
+            1172,
+            1201,
+            1231,
+            1260,
+            1290,
+            1320,
+            1350,
+            1379,
+            1409,
+            1438,
+            1468,
+            1497,
+            1527,
+            1556,
+            1586,
+            1615,
+            1645,
+            1674,
+            1704,
+            1733,
+            1763,
+            1792,
+            1822,
+            1851,
+            1881,
+            1910,
+            1940,
+            1969,
+            1999,
+            2028,
+            2058,
+            2087,
+            2117,
+            2146,
+            2176,
+            2205,
+            2235,
+            2264,
+            2294,
+            2323,
+            2353,
+            2383,
+            2413,
+            2442,
+            2472,
+            2501,
+            2531,
+            2560,
+            2590,
+            2619,
+            2649,
+            2678,
+            2708,
+            2737,
+            2767,
+            2796,
+            2826,
+            2855,
+            2885,
+            2914,
+            2944,
+            2973,
+            3003,
+            3032,
+            3062,
+            3091,
+            3121,
+            3150,
+            3180,
+            3209,
+            3239,
+            3268,
+            3298,
+            3327,
+            3357,
+            3386,
+            3416,
+            3446,
+            3476,
+            3505,
+            3535,
+            3564,
+            3594,
+            3623,
+            3653,
+            3682,
+            3712,
+            3741,
+            3771,
+            3800,
+            3830,
+            3859,
+            3889,
+            3918,
+            3948,
+            3977,
+            4007,
+            4036,
+            4066,
+            4095,
+            4125,
+            4155,
+            4185,
+            4214,
+            4244,
+            4273,
+            4303,
+            4332,
+            4362,
+            4391,
+            4421,
+            4450,
+            4480,
+            4509,
+            4539,
+            4568,
+            4598,
+            4627,
+            4657,
+            4686,
+            4716,
+            4745,
+            4775,
+            4804,
+            4834,
+            4863,
+            4893,
+            4922,
+            4952,
+            4981,
+            5011,
+            5040,
+            5070,
+            5099,
+            5129,
+            5158,
+            5188,
+            5218,
+            5248,
+            5277,
+            5307,
+            5336,
+            5366,
+            5395,
+            5425,
+            5454,
+            5484,
+            5513,
+            5543,
+            5572,
+            5602,
+            5631,
+            5661,
+            5690,
+            5720,
+            5749,
+            5779,
+            5808,
+            5838,
+            5867,
+            5897,
+            5926,
+            5956,
+            5985,
+            6015,
+            6044,
+            6074,
+            6103,
+            6133,
+            6162,
+            6192,
+            6221,
+            6251,
+            6281,
+            6311,
+            6340,
+            6370,
+            6399,
+            6429,
+            6458,
+            6488,
+            6517,
+            6547,
+            6576,
+            6606,
+            6635,
+            6665,
+            6694,
+            6724,
+            6753,
+            6783,
+            6812,
+            6842,
+            6871,
+            6901,
+            6930,
+            6960,
+            6989,
+            7019,
+            7048,
+            7078,
+            7107,
+            7137,
+            7166,
+            7196,
+            7225,
+            7255,
+            7284,
+            7314,
+            7344,
+            7374,
+            7403,
+            7433,
+            7462,
+            7492,
+            7521,
+            7551,
+            7580,
+            7610,
+            7639,
+            7669,
+            7698,
+            7728,
+            7757,
+            7787,
+            7816,
+            7846,
+            7875,
+            7905,
+            7934,
+            7964,
+            7993,
+            8023,
+            8053,
+            8083,
+            8112,
+            8142,
+            8171,
+            8201,
+            8230,
+            8260,
+            8289,
+            8319,
+            8348,
+            8378,
+            8407,
+            8437,
+            8466,
+            8496,
+            8525,
+            8555,
+            8584,
+            8614,
+            8643,
+            8673,
+            8702,
+            8732,
+            8761,
+            8791,
+            8821,
+            8850,
+            8880,
+            8909,
+            8938,
+            8968,
+            8997,
+            9027,
+            9056,
+            9086,
+            9115,
+            9145,
+            9175,
+            9205,
+            9234,
+            9264,
+            9293,
+            9322,
+            9352,
+            9381,
+            9410,
+            9440,
+            9470,
+            9499,
+            9529,
+            9559,
+            9589,
+            9618,
+            9648,
+            9677,
+            9706,
+            9736,
+            9765,
+            9794,
+            9824,
+            9853,
+            9883,
+            9913,
+            9943,
+            9972,
+            10002,
+            10032,
+            10061,
+            10090,
+            10120,
+            10149,
+            10178,
+            10208,
+            10237,
+            10267,
+            10297,
+            10326,
+            10356,
+            10386,
+            10415,
+            10445,
+            10474,
+            10504,
+            10533,
+            10562,
+            10592,
+            10621,
+            10651,
+            10680,
+            10710,
+            10740,
+            10770,
+            10799,
+            10829,
+            10858,
+            10888,
+            10917,
+            10947,
+            10976,
+            11005,
+            11035,
+            11064,
+            11094,
+            11124,
+            11153,
+            11183,
+            11213,
+            11242,
+            11272,
+            11301,
+            11331,
+            11360,
+            11389,
+            11419,
+            11448,
+            11478,
+            11507,
+            11537,
+            11567,
+            11596,
+            11626,
+            11655,
+            11685,
+            11715,
+            11744,
+            11774,
+            11803,
+            11832,
+            11862,
+            11891,
+            11921,
+            11950,
+            11980,
+            12010,
+            12039,
+            12069,
+            12099,
+            12128,
+            12158,
+            12187,
+            12216,
+            12246,
+            12275,
+            12304,
+            12334,
+            12364,
+            12393,
+            12423,
+            12453,
+            12483,
+            12512,
+            12542,
+            12571,
+            12600,
+            12630,
+            12659,
+            12688,
+            12718,
+            12747,
+            12777,
+            12807,
+            12837,
+            12866,
+            12896,
+            12926,
+            12955,
+            12984,
+            13014,
+            13043,
+            13072,
+            13102,
+            13131,
+            13161,
+            13191,
+            13220,
+            13250,
+            13280,
+            13310,
+            13339,
+            13368,
+            13398,
+            13427,
+            13456,
+            13486,
+            13515,
+            13545,
+            13574,
+            13604,
+            13634,
+            13664,
+            13693,
+            13723,
+            13752,
+            13782,
+            13811,
+            13840,
+            13870,
+            13899,
+            13929,
+            13958,
+            13988,
+            14018,
+            14047,
+            14077,
+            14107,
+            14136,
+            14166,
+            14195,
+            14224,
+            14254,
+            14283,
+            14313,
+            14342,
+            14372,
+            14401,
+            14431,
+            14461,
+            14490,
+            14520,
+            14550,
+            14579,
+            14609,
+            14638,
+            14667,
+            14697,
+            14726,
+            14756,
+            14785,
+            14815,
+            14844,
+            14874,
+            14904,
+            14933,
+            14963,
+            14993,
+            15021,
+            15051,
+            15081,
+            15110,
+            15140,
+            15169,
+            15199,
+            15228,
+            15258,
+            15287,
+            15317,
+            15347,
+            15377,
+            15406,
+            15436,
+            15465,
+            15494,
+            15524,
+            15553,
+            15582,
+            15612,
+            15641,
+            15671,
+            15701,
+            15731,
+            15760,
+            15790,
+            15820,
+            15849,
+            15878,
+            15908,
+            15937,
+            15966,
+            15996,
+            16025,
+            16055,
+            16085,
+            16114,
+            16144,
+            16174,
+            16204,
+            16233,
+            16262,
+            16292,
+            16321,
+            16350,
+            16380,
+            16409,
+            16439,
+            16468,
+            16498,
+            16528,
+            16558,
+            16587,
+            16617,
+            16646,
+            16676,
+            16705,
+            16734,
+            16764,
+            16793,
+            16823,
+            16852,
+            16882,
+            16912,
+            16941,
+            16971,
+            17001,
+            17030,
+            17060,
+            17089,
+            17118,
+            17148,
+            17177,
+            17207,
+            17236,
+            17266,
+            17295,
+            17325,
+            17355,
+            17384,
+            17414,
+            17444,
+            17473,
+            17502,
+            17532,
+            17561,
+            17591,
+            17620,
+            17650,
+            17679,
+            17709,
+            17738,
+            17768,
+            17798,
+            17827,
+            17857,
+            17886,
+            17916,
+            17945,
+            17975,
+            18004,
+            18034,
+            18063,
+            18093,
+            18122,
+            18152,
+            18181,
+            18211,
+            18241,
+            18270,
+            18300,
+            18330,
+            18359,
+            18388,
+            18418,
+            18447,
+            18476,
+            18506,
+            18535,
+            18565,
+            18595,
+            18625,
+            18654,
+            18684,
+            18714,
+            18743,
+            18772,
+            18802,
+            18831,
+            18860,
+            18890,
+            18919,
+            18949,
+            18979,
+            19008,
+            19038,
+            19068,
+            19098,
+            19127,
+            19156,
+            19186,
+            19215,
+            19244,
+            19274,
+            19303,
+            19333,
+            19362,
+            19392,
+            19422,
+            19452,
+            19481,
+            19511,
+            19540,
+            19570,
+            19599,
+            19628,
+            19658,
+            19687,
+            19717,
+            19746,
+            19776,
+            19806,
+            19836,
+            19865,
+            19895,
+            19924,
+            19954,
+            19983,
+            20012,
+            20042,
+            20071,
+            20101,
+            20130,
+            20160,
+            20190,
+            20219,
+            20249,
+            20279,
+            20308,
+            20338,
+            20367,
+            20396,
+            20426,
+            20455,
+            20485,
+            20514,
+            20544,
+            20573,
+            20603,
+            20633,
+            20662,
+            20692,
+            20721,
+            20751,
+            20780,
+            20810,
+            20839,
+            20869,
+            20898,
+            20928,
+            20957,
+            20987,
+            21016,
+            21046,
+            21076,
+            21105,
+            21135,
+            21164,
+            21194,
+            21223,
+            21253,
+            21282,
+            21312,
+            21341,
+            21371,
+            21400,
+            21430,
+            21459,
+            21489,
+            21519,
+            21548,
+            21578,
+            21607,
+            21637,
+            21666,
+            21696,
+            21725,
+            21754,
+            21784,
+            21813,
+            21843,
+            21873,
+            21902,
+            21932,
+            21962,
+            21991,
+            22021,
+            22050,
+            22080,
+            22109,
+            22138,
+            22168,
+            22197,
+            22227,
+            22256,
+            22286,
+            22316,
+            22346,
+            22375,
+            22405,
+            22434,
+            22464,
+            22493,
+            22522,
+            22552,
+            22581,
+            22611,
+            22640,
+            22670,
+            22700,
+            22730,
+            22759,
+            22789,
+            22818,
+            22848,
+            22877,
+            22906,
+            22936,
+            22965,
+            22994,
+            23024,
+            23054,
+            23083,
+            23113,
+            23143,
+            23173,
+            23202,
+            23232,
+            23261,
+            23290,
+            23320,
+            23349,
+            23379,
+            23408,
+            23438,
+            23467,
+            23497,
+            23527,
+            23556,
+            23586,
+            23616,
+            23645,
+            23674,
+            23704,
+            23733,
+            23763,
+            23792,
+            23822,
+            23851,
+            23881,
+            23910,
+            23940,
+            23970,
+            23999,
+            24029,
+            24058,
+            24088,
+            24117,
+            24147,
+            24176,
+            24206,
+            24235,
+            24265,
+            24294,
+            24324,
+            24353,
+            24383,
+            24413,
+            24442,
+            24472,
+            24501,
+            24531,
+            24560,
+            24590,
+            24619,
+            24648,
+            24678,
+            24707,
+            24737,
+            24767,
+            24796,
+            24826,
+            24856,
+            24885,
+            24915,
+            24944,
+            24974,
+            25003,
+            25032,
+            25062,
+            25091,
+            25121,
+            25150,
+            25180,
+            25210,
+            25240,
+            25269,
+            25299,
+            25328,
+            25358,
+            25387,
+            25416,
+            25446,
+            25475,
+            25505,
+            25534,
+            25564,
+            25594,
+            25624,
+            25653,
+            25683,
+            25712,
+            25742,
+            25771,
+            25800,
+            25830,
+            25859,
+            25888,
+            25918,
+            25948,
+            25977,
+            26007,
+            26037,
+            26067,
+            26096,
+            26126,
+            26155,
+            26184,
+            26214,
+            26243,
+            26272,
+            26302,
+            26332,
+            26361,
+            26391,
+            26421,
+            26451,
+            26480,
+            26510,
+            26539,
+            26568,
+            26598,
+            26627,
+            26656,
+            26686,
+            26715,
+            26745,
+            26775,
+            26805,
+            26834,
+            26864,
+            26893,
+            26923,
+            26952,
+            26982,
+            27011,
+            27041,
+            27070,
+            27099,
+            27129,
+            27159,
+            27188,
+            27218,
+            27248,
+            27277,
+            27307,
+            27336,
+            27366,
+            27395,
+            27425,
+            27454,
+            27484,
+            27513,
+            27542,
+            27572,
+            27602,
+            27631,
+            27661,
+            27691,
+            27720,
+            27750,
+            27779,
+            27809,
+            27838,
+            27868,
+            27897,
+            27926,
+            27956,
+            27985,
+            28015,
+            28045,
+            28074,
+            28104,
+            28134,
+            28163,
+            28193,
+            28222,
+            28252,
+            28281,
+            28310,
+            28340,
+            28369,
+            28399,
+            28428,
+            28458,
+            28488,
+            28517,
+            28547,
+            28577,
+            // From 1356
+            28607,
+            28636,
+            28665,
+            28695,
+            28724,
+            28754,
+            28783,
+            28813,
+            28843,
+            28872,
+            28901,
+            28931,
+            28960,
+            28990,
+            29019,
+            29049,
+            29078,
+            29108,
+            29137,
+            29167,
+            29196,
+            29226,
+            29255,
+            29285,
+            29315,
+            29345,
+            29375,
+            29404,
+            29434,
+            29463,
+            29492,
+            29522,
+            29551,
+            29580,
+            29610,
+            29640,
+            29669,
+            29699,
+            29729,
+            29759,
+            29788,
+            29818,
+            29847,
+            29876,
+            29906,
+            29935,
+            29964,
+            29994,
+            30023,
+            30053,
+            30082,
+            30112,
+            30141,
+            30171,
+            30200,
+            30230,
+            30259,
+            30289,
+            30318,
+            30348,
+            30378,
+            30408,
+            30437,
+            30467,
+            30496,
+            30526,
+            30555,
+            30585,
+            30614,
+            30644,
+            30673,
+            30703,
+            30732,
+            30762,
+            30791,
+            30821,
+            30850,
+            30880,
+            30909,
+            30939,
+            30968,
+            30998,
+            31027,
+            31057,
+            31086,
+            31116,
+            31145,
+            31175,
+            31204,
+            31234,
+            31263,
+            31293,
+            31322,
+            31352,
+            31381,
+            31411,
+            31441,
+            31471,
+            31500,
+            31530,
+            31559,
+            31589,
+            31618,
+            31648,
+            31676,
+            31706,
+            31736,
+            31766,
+            31795,
+            31825,
+            31854,
+            31884,
+            31913,
+            31943,
+            31972,
+            32002,
+            32031,
+            32061,
+            32090,
+            32120,
+            32150,
+            32180,
+            32209,
+            32239,
+            32268,
+            32298,
+            32327,
+            32357,
+            32386,
+            32416,
+            32445,
+            32475,
+            32504,
+            32534,
+            32563,
+            32593,
+            32622,
+            32652,
+            32681,
+            32711,
+            32740,
+            32770,
+            32799,
+            32829,
+            32858,
+            32888,
+            32917,
+            32947,
+            32976,
+            33006,
+            33035,
+            33065,
+            33094,
+            33124,
+            33153,
+            33183,
+            33213,
+            33243,
+            33272,
+            33302,
+            33331,
+            33361,
+            33390,
+            33420,
+            33450,
+            33479,
+            33509,
+            33539,
+            33568,
+            33598,
+            33627,
+            33657,
+            33686,
+            33716,
+            33745,
+            33775,
+            33804,
+            33834,
+            33863,
+            33893,
+            33922,
+            33952,
+            33981,
+            34011,
+            34040,
+            34069,
+            34099,
+            34128,
+            34158,
+            34187,
+            34217,
+            34247,
+            34277,
+            34306,
+            34336,
+            34365,
+            34395,
+            34424,
+            34454,
+            34483,
+            34512,
+            34542,
+            34571,
+            34601,
+            34631,
+            34660,
+            34690,
+            34719,
+            34749,
+            34778,
+            34808,
+            34837,
+            34867,
+            34896,
+            34926,
+            34955,
+            34985,
+            35015,
+            35044,
+            35074,
+            35103,
+            35133,
+            35162,
+            35192,
+            35222,
+            35251,
+            35280,
+            35310,
+            35340,
+            35370,
+            35399,
+            35429,
+            35458,
+            35488,
+            35517,
+            35547,
+            35576,
+            35605,
+            35635,
+            35665,
+            35694,
+            35723,
+            35753,
+            35782,
+            35811,
+            35841,
+            35871,
+            35901,
+            35930,
+            35960,
+            35989,
+            36019,
+            36048,
+            36078,
+            36107,
+            36136,
+            36166,
+            36195,
+            36225,
+            36254,
+            36284,
+            36314,
+            36343,
+            36373,
+            36403,
+            36433,
+            36462,
+            36492,
+            36521,
+            36551,
+            36580,
+            36610,
+            36639,
+            36669,
+            36698,
+            36728,
+            36757,
+            36786,
+            36816,
+            36845,
+            36875,
+            36904,
+            36934,
+            36963,
+            36993,
+            37022,
+            37052,
+            37081,
+            37111,
+            37141,
+            37170,
+            37200,
+            37229,
+            37259,
+            37288,
+            37318,
+            37347,
+            37377,
+            37406,
+            37436,
+            37465,
+            37495,
+            37524,
+            37554,
+            37584,
+            37613,
+            37643,
+            37672,
+            37701,
+            37731,
+            37760,
+            37790,
+            37819,
+            37849,
+            37878,
+            37908,
+            37938,
+            37967,
+            37997,
+            38027,
+            38056,
+            38085,
+            38115,
+            38144,
+            38174,
+            38203,
+            38233,
+            38262,
+            38292,
+            38322,
+            38351,
+            38381,
+            38410,
+            38440,
+            38469,
+            38499,
+            38528,
+            38558,
+            38587,
+            38617,
+            38646,
+            38676,
+            38705,
+            38735,
+            38764,
+            38794,
+            38823,
+            38853,
+            38882,
+            38912,
+            38941,
+            38971,
+            39001,
+            39030,
+            39059,
+            39089,
+            39118,
+            39148,
+            39178,
+            39208,
+            39237,
+            39267,
+            39297,
+            39326,
+            39355,
+            39385,
+            39414,
+            39444,
+            39473,
+            39503,
+            39532,
+            39562,
+            39592,
+            39621,
+            39650,
+            39680,
+            39709,
+            39739,
+            39768,
+            39798,
+            39827,
+            39857,
+            39886,
+            39916,
+            39946,
+            39975,
+            40005,
+            40035,
+            40064,
+            40094,
+            40123,
+            40153,
+            40182,
+            40212,
+            40241,
+            40271,
+            40300,
+            40330,
+            40359,
+            40389,
+            40418,
+            40448,
+            40477,
+            40507,
+            40536,
+            40566,
+            40595,
+            40625,
+            40655,
+            40685,
+            40714,
+            40744,
+            40773,
+            40803,
+            40832,
+            40862,
+            40892,
+            40921,
+            40951,
+            40980,
+            41009,
+            41039,
+            41068,
+            41098,
+            41127,
+            41157,
+            41186,
+            41216,
+            41245,
+            41275,
+            41304,
+            41334,
+            41364,
+            41393,
+            41422,
+            41452,
+            41481,
+            41511,
+            41540,
+            41570,
+            41599,
+            41629,
+            41658,
+            41688,
+            41718,
+            41748,
+            41777,
+            41807,
+            41836,
+            41865,
+            41894,
+            41924,
+            41953,
+            41983,
+            42012,
+            42042,
+            42072,
+            42102,
+            42131,
+            42161,
+            42190,
+            42220,
+            42249,
+            42279,
+            42308,
+            42337,
+            42367,
+            42397,
+            42426,
+            42456,
+            42485,
+            42515,
+            42545,
+            42574,
+            42604,
+            42633,
+            42662,
+            42692,
+            42721,
+            42751,
+            42780,
+            42810,
+            42839,
+            42869,
+            42899,
+            42929,
+            42958,
+            42988,
+            43017,
+            43046,
+            43076,
+            43105,
+            43135,
+            43164,
+            43194,
+            43223,
+            43253,
+            43283,
+            43312,
+            43342,
+            43371,
+            43401,
+            43430,
+            43460,
+            43489,
+            43519,
+            43548,
+            43578,
+            43607,
+            43637,
+            43666,
+            43696,
+            43726,
+            43755,
+            43785,
+            43814,
+            43844,
+            43873,
+            43903,
+            43932,
+            43962,
+            43991,
+            44021,
+            44050,
+            44080,
+            44109,
+            44139,
+            44169,
+            44198,
+            44228,
+            44258,
+            44287,
+            44317,
+            44346,
+            44375,
+            44405,
+            44434,
+            44464,
+            44493,
+            44523,
+            44553,
+            44582,
+            44612,
+            44641,
+            44671,
+            44700,
+            44730,
+            44759,
+            44788,
+            44818,
+            44847,
+            44877,
+            44906,
+            44936,
+            44966,
+            44996,
+            45025,
+            45055,
+            45084,
+            45114,
+            45143,
+            45172,
+            45202,
+            45231,
+            45261,
+            45290,
+            45320,
+            45350,
+            45380,
+            45409,
+            45439,
+            45468,
+            45498,
+            45527,
+            45556,
+            45586,
+            45615,
+            45644,
+            45674,
+            45704,
+            45733,
+            45763,
+            45793,
+            45823,
+            45852,
+            45882,
+            45911,
+            45940,
+            45970,
+            45999,
+            46028,
+            46058,
+            46088,
+            46117,
+            46147,
+            46177,
+            46206,
+            46236,
+            46265,
+            46295,
+            46324,
+            46354,
+            46383,
+            46413,
+            46442,
+            46472,
+            46501,
+            46531,
+            46560,
+            46590,
+            46620,
+            46649,
+            46679,
+            46708,
+            46738,
+            46767,
+            46797,
+            46826,
+            46856,
+            46885,
+            46915,
+            46944,
+            46974,
+            47003,
+            47033,
+            47063,
+            47092,
+            47122,
+            47151,
+            47181,
+            47210,
+            47240,
+            47269,
+            47298,
+            47328,
+            47357,
+            47387,
+            47417,
+            47446,
+            47476,
+            47506,
+            47535,
+            47565,
+            47594,
+            47624,
+            47653,
+            47682,
+            47712,
+            47741,
+            47771,
+            47800,
+            47830,
+            47860,
+            47890,
+            47919,
+            47949,
+            47978,
+            48008,
+            48037,
+            48066,
+            48096,
+            48125,
+            48155,
+            48184,
+            48214,
+            48244,
+            48273,
+            48303,
+            48333,
+            48362,
+            48392,
+            48421,
+            48450,
+            48480,
+            48509,
+            48538,
+            48568,
+            48598,
+            48627,
+            48657,
+            48687,
+            48717,
+            48746,
+            48776,
+            48805,
+            48834,
+            48864,
+            48893,
+            48922,
+            48952,
+            48982,
+            49011,
+            49041,
+            49071,
+            49100,
+            49130,
+            49160,
+            49189,
+            49218,
+            49248,
+            49277,
+            49306,
+            49336,
+            49365,
+            49395,
+            49425,
+            49455,
+            49484,
+            49514,
+            49543,
+            49573,
+            49602,
+            49632,
+            49661,
+            49690,
+            49720,
+            49749,
+            49779,
+            49809,
+            49838,
+            49868,
+            49898,
+            49927,
+            49957,
+            49986,
+            50016,
+            50045,
+            50075,
+            50104,
+            50133,
+            50163,
+            50192,
+            50222,
+            50252,
+            50281,
+            50311,
+            50340,
+            50370,
+            50400,
+            50429,
+            50459,
+            50488,
+            50518,
+            50547,
+            50576,
+            50606,
+            50635,
+            50665,
+            50694,
+            50724,
+            50754,
+            50784,
+            50813,
+            50843,
+            50872,
+            50902,
+            50931,
+            50960,
+            50990,
+            51019,
+            51049,
+            51078,
+            51108,
+            51138,
+            51167,
+            51197,
+            51227,
+            51256,
+            51286,
+            51315,
+            51345,
+            51374,
+            51403,
+            51433,
+            51462,
+            51492,
+            51522,
+            51552,
+            51582,
+            51611,
+            51641,
+            51670,
+            51699,
+            51729,
+            51758,
+            51787,
+            51816,
+            51846,
+            51876,
+            51906,
+            51936,
+            51965,
+            51995,
+            52025,
+            52054,
+            52083,
+            52113,
+            52142,
+            52171,
+            52200,
+            52230,
+            52260,
+            52290,
+            52319,
+            52349,
+            52379,
+            52408,
+            52438,
+            52467,
+            52497,
+            52526,
+            52555,
+            52585,
+            52614,
+            52644,
+            52673,
+            52703,
+            52733,
+            52762,
+            52792,
+            52822,
+            52851,
+            52881,
+            52910,
+            52939,
+            52969,
+            52998,
+            53028,
+            53057,
+            53087,
+            53116,
+            53146,
+            53176,
+            53205,
+            53235,
+            53264,
+            53294,
+            53324,
+            53353,
+            53383,
+            53412,
+            53441,
+            53471,
+            53500,
+            53530,
+            53559,
+            53589,
+            53619,
+            53648,
+            53678,
+            53708,
+            53737,
+            53767,
+            53796,
+            53825,
+            53855,
+            53884,
+            53913,
+            53943,
+            53973,
+            54003,
+            54032,
+            54062,
+            54092,
+            54121,
+            54151,
+            54180,
+            54209,
+            54239,
+            54268,
+            54297,
+            54327,
+            54357,
+            54387,
+            54416,
+            54446,
+            54476,
+            54505,
+            54535,
+            54564,
+            54593,
+            54623,
+            54652,
+            54681,
+            54711,
+            54741,
+            54770,
+            54800,
+            54830,
+            54859,
+            54889,
+            54919,
+            54948,
+            54977,
+            55007,
+            55036,
+            55066,
+            55095,
+            55125,
+            55154,
+            55184,
+            55213,
+            55243,
+            55273,
+            55302,
+            55332,
+            55361,
+            55391,
+            55420,
+            55450,
+            55479,
+            55508,
+            55538,
+            55567,
+            55597,
+            55627,
+            55657,
+            55686,
+            55716,
+            55745,
+            55775,
+            55804,
+            55834,
+            55863,
+            55892,
+            55922,
+            55951,
+            55981,
+            56011,
+            56040,
+            56070,
+            56100,
+            56129,
+            56159,
+            56188,
+            56218,
+            56247,
+            56276,
+            56306,
+            56335,
+            56365,
+            56394,
+            56424,
+            56454,
+            56483,
+            56513,
+            56543,
+            56572,
+            56601,
+            56631,
+            56660,
+            56690,
+            56719,
+            56749,
+            56778,
+            56808,
+            56837,
+            56867,
+            56897,
+            56926,
+            56956,
+            56985,
+            57015,
+            57044,
+            57074,
+            57103,
+            57133,
+            57162,
+            57192,
+            57221,
+            57251,
+            57280,
+            57310,
+            57340,
+            57369,
+            57399,
+            57429,
+            57458,
+            57487,
+            57517,
+            57546,
+            57576,
+            57605,
+            57634,
+            57664,
+            57694,
+            57723,
+            57753,
+            57783,
+            57813,
+            57842,
+            57871,
+            57901,
+            57930,
+            57959,
+            57989,
+            58018,
+            58048,
+            58077,
+            58107,
+            58137,
+            58167,
+            58196,
+            58226,
+            58255,
+            58285,
+            58314,
+            58343,
+            58373,
+            58402,
+            58432,
+            58461,
+            58491,
+            58521,
+            58551,
+            58580,
+            58610,
+            58639,
+            58669,
+            58698,
+            58727,
+            58757,
+            58786,
+            58816,
+            58845,
+            58875,
+            58905,
+            58934,
+            58964,
+            58994,
+            59023,
+            59053,
+            59082,
+            59111,
+            59141,
+            59170,
+            59200,
+            59229,
+            59259,
+            59288,
+            59318,
+            59348,
+            59377,
+            59407,
+            59436,
+            59466,
+            59495,
+            59525,
+            59554,
+            59584,
+            59613,
+            59643,
+            59672,
+            59702,
+            59731,
+            59761,
+            59791,
+            59820,
+            59850,
+            59879,
+            59909,
+            59939,
+            59968,
+            59997,
+            60027,
+            60056,
+            60086,
+            60115,
+            60145,
+            60174,
+            60204,
+            60234,
+            60264,
+            60293,
+            60323,
+            60352,
+            60381,
+            60411,
+            60440,
+            60469,
+            60499,
+            60528,
+            60558,
+            60588,
+            60618,
+            60648,
+            60677,
+            60707,
+            60736,
+            60765,
+            60795,
+            60824,
+            60853,
+            60883,
+            60912,
+            60942,
+            60972,
+            61002,
+            61031,
+            61061,
+            61090,
+            61120,
+            61149,
+            61179,
+            61208,
+            61237,
+            61267,
+            61296,
+            61326,
+            61356,
+            61385,
+            61415,
+            61445,
+            61474,
+            61504,
+            61533,
+            61563,
+            61592,
+            61621,
+            61651,
+            61680,
+            61710,
+            61739,
+            61769,
+            61799,
+            61828,
+            61858,
+            61888,
+            61917,
+            61947,
+            61976,
+            62006,
+            62035,
+            62064,
+            62094,
+            62123,
+            62153,
+            62182,
+            62212,
+            62242,
+            62271,
+            62301,
+            62331,
+            62360,
+            62390,
+            62419,
+            62448,
+            62478,
+            62507,
+            62537,
+            62566,
+            62596,
+            62625,
+            62655,
+            62685,
+            62715,
+            62744,
+            62774,
+            62803,
+            62832,
+            62862,
+            62891,
+            62921,
+            62950,
+            62980,
+            63009,
+            63039,
+            63069,
+            63099,
+            63128,
+            63157,
+            63187,
+            63216,
+            63246,
+            63275,
+            63305,
+            63334,
+            63363,
+            63393,
+            63423,
+            63453,
+            63482,
+            63512,
+            63541,
+            63571,
+            63600,
+            63630,
+            63659,
+            63689,
+            63718,
+            63747,
+            63777,
+            63807,
+            63836,
+            63866,
+            63895,
+            63925,
+            63955,
+            63984,
+            64014,
+            64043,
+            64073,
+            64102,
+            64131,
+            64161,
+            64190,
+            64220,
+            64249,
+            64279,
+            64309,
+            64339,
+            64368,
+            64398,
+            64427,
+            64457,
+            64486,
+            64515,
+            64545,
+            64574,
+            64603,
+            64633,
+            64663,
+            64692,
+            64722,
+            64752,
+            64782,
+            64811,
+            64841,
+            64870,
+            64899,
+            64929,
+            64958,
+            64987,
+            65017,
+            65047,
+            65076,
+            65106,
+            65136,
+            65166,
+            65195,
+            65225,
+            65254,
+            65283,
+            65313,
+            65342,
+            65371,
+            65401,
+            65431,
+            65460,
+            65490,
+            65520,
+            65549,
+            65579,
+            65608,
+            65638,
+            65667,
+            65697,
+            65726,
+            65755,
+            65785,
+            65815,
+            65844,
+            65874,
+            65903,
+            65933,
+            65963,
+            65992,
+            66022,
+            66051,
+            66081,
+            66110,
+            66140,
+            66169,
+            66199,
+            66228,
+            66258,
+            66287,
+            66317,
+            66346,
+            66376,
+            66405,
+            66435,
+            66465,
+            66494,
+            66524,
+            66553,
+            66583,
+            66612,
+            66641,
+            66671,
+            66700,
+            66730,
+            66760,
+            66789,
+            66819,
+            66849,
+            66878,
+            66908,
+            66937,
+            66967,
+            66996,
+            67025,
+            67055,
+            67084,
+            67114,
+            67143,
+            67173,
+            67203,
+            67233,
+            67262,
+            67292,
+            67321,
+            67351,
+            67380,
+            67409,
+            67439,
+            67468,
+            67497,
+            67527,
+            67557,
+            67587,
+            67617,
+            67646,
+            67676,
+            67705,
+            67735,
+            67764,
+            67793,
+            67823,
+            67852,
+            67882,
+            67911,
+            67941,
+            67971,
+            68e3,
+            68030,
+            68060,
+            68089,
+            68119,
+            68148,
+            68177,
+            68207,
+            68236,
+            68266,
+            68295,
+            68325,
+            68354,
+            68384,
+            68414,
+            68443,
+            68473,
+            68502,
+            68532,
+            68561,
+            68591,
+            68620,
+            68650,
+            68679,
+            68708,
+            68738,
+            68768,
+            68797,
+            68827,
+            68857,
+            68886,
+            68916,
+            68946,
+            68975,
+            69004,
+            69034,
+            69063,
+            69092,
+            69122,
+            69152,
+            69181,
+            69211,
+            69240,
+            69270,
+            69300,
+            69330,
+            69359,
+            69388,
+            69418,
+            69447,
+            69476,
+            69506,
+            69535,
+            69565,
+            69595,
+            69624,
+            69654,
+            69684,
+            69713,
+            69743,
+            69772,
+            69802,
+            69831,
+            69861,
+            69890,
+            69919,
+            69949,
+            69978,
+            70008,
+            70038,
+            70067,
+            70097,
+            70126,
+            70156,
+            70186,
+            70215,
+            70245,
+            70274,
+            70303,
+            70333,
+            70362,
+            70392,
+            70421,
+            70451,
+            70481,
+            70510,
+            70540,
+            70570,
+            70599,
+            70629,
+            70658,
+            70687,
+            70717,
+            70746,
+            70776,
+            70805,
+            70835,
+            70864,
+            70894,
+            70924,
+            70954,
+            70983,
+            71013,
+            71042,
+            71071,
+            71101,
+            71130,
+            71159,
+            71189,
+            71218,
+            71248,
+            71278,
+            71308,
+            71337,
+            71367,
+            71397,
+            71426,
+            71455,
+            71485,
+            71514,
+            71543,
+            71573,
+            71602,
+            71632,
+            71662,
+            71691,
+            71721,
+            71751,
+            71781,
+            71810,
+            71839,
+            71869,
+            71898,
+            71927,
+            71957,
+            71986,
+            72016,
+            72046,
+            72075,
+            72105,
+            72135,
+            72164,
+            72194,
+            72223,
+            72253,
+            72282,
+            72311,
+            72341,
+            72370,
+            72400,
+            72429,
+            72459,
+            72489,
+            72518,
+            72548,
+            72577,
+            72607,
+            72637,
+            72666,
+            72695,
+            72725,
+            72754,
+            72784,
+            72813,
+            72843,
+            72872,
+            72902,
+            72931,
+            72961,
+            72991,
+            73020,
+            73050,
+            73080,
+            73109,
+            73139,
+            73168,
+            73197,
+            73227,
+            73256,
+            73286,
+            73315,
+            73345,
+            73375,
+            73404,
+            73434,
+            73464,
+            73493,
+            73523,
+            73552,
+            73581,
+            73611,
+            73640,
+            73669,
+            73699,
+            73729,
+            73758,
+            73788,
+            73818,
+            73848,
+            73877,
+            73907,
+            73936,
+            73965,
+            73995,
+            74024,
+            74053,
+            74083,
+            74113,
+            74142,
+            74172,
+            74202,
+            74231,
+            74261,
+            74291,
+            74320,
+            74349,
+            74379,
+            74408,
+            74437,
+            74467,
+            74497,
+            74526,
+            74556,
+            74586,
+            74615,
+            74645,
+            74675,
+            74704,
+            74733,
+            74763,
+            74792,
+            74822,
+            74851,
+            74881,
+            74910,
+            74940,
+            74969,
+            74999,
+            75029,
+            75058,
+            75088,
+            75117,
+            75147,
+            75176,
+            75206,
+            75235,
+            75264,
+            75294,
+            75323,
+            75353,
+            75383,
+            75412,
+            75442,
+            75472,
+            75501,
+            75531,
+            75560,
+            75590,
+            75619,
+            75648,
+            75678,
+            75707,
+            75737,
+            75766,
+            75796,
+            75826,
+            75856,
+            75885,
+            75915,
+            75944,
+            75974,
+            76003,
+            76032,
+            76062,
+            76091,
+            76121,
+            76150,
+            76180,
+            76210,
+            76239,
+            76269,
+            76299,
+            76328,
+            76358,
+            76387,
+            76416,
+            76446,
+            76475,
+            76505,
+            76534,
+            76564,
+            76593,
+            76623,
+            76653,
+            76682,
+            76712,
+            76741,
+            76771,
+            76801,
+            76830,
+            76859,
+            76889,
+            76918,
+            76948,
+            76977,
+            77007,
+            77036,
+            77066,
+            77096,
+            77125,
+            77155,
+            77185,
+            77214,
+            77243,
+            77273,
+            77302,
+            77332,
+            77361,
+            77390,
+            77420,
+            77450,
+            77479,
+            77509,
+            77539,
+            77569,
+            77598,
+            77627,
+            77657,
+            77686,
+            77715,
+            77745,
+            77774,
+            77804,
+            77833,
+            77863,
+            77893,
+            77923,
+            77952,
+            77982,
+            78011,
+            78041,
+            78070,
+            78099,
+            78129,
+            78158,
+            78188,
+            78217,
+            78247,
+            78277,
+            78307,
+            78336,
+            78366,
+            78395,
+            78425,
+            78454,
+            78483,
+            78513,
+            78542,
+            78572,
+            78601,
+            78631,
+            78661,
+            78690,
+            78720,
+            78750,
+            78779,
+            78808,
+            78838,
+            78867,
+            78897,
+            78926,
+            78956,
+            78985,
+            79015,
+            79044,
+            79074,
+            79104,
+            79133,
+            79163,
+            79192,
+            79222,
+            79251,
+            79281,
+            79310,
+            79340,
+            79369,
+            79399,
+            79428,
+            79458,
+            79487,
+            79517,
+            79546,
+            79576,
+            79606,
+            79635,
+            79665,
+            79695,
+            79724,
+            79753,
+            79783,
+            79812,
+            79841,
+            79871,
+            79900,
+            79930,
+            79960,
+            79990
+          ];
+        }
+      });
+      var require_calendars = __commonJS({
+        "src/components/calendars/calendars.js"(exports, module2) {
+          module2.exports = require_main();
+          require_plus();
+          require_chinese();
+          require_coptic();
+          require_discworld();
+          require_ethiopian();
+          require_hebrew();
+          require_islamic();
+          require_julian();
+          require_mayan();
+          require_nanakshahi();
+          require_nepali();
+          require_persian();
+          require_taiwan();
+          require_thai();
+          require_ummalqura();
+        }
+      });
+      var require_calendars2 = __commonJS({
+        "src/components/calendars/index.js"(exports, module2) {
+          var calendars = require_calendars();
+          var Lib = require_lib();
+          var constants = require_numerical();
+          var EPOCHJD = constants.EPOCHJD;
+          var ONEDAY = constants.ONEDAY;
+          var attributes = {
+            valType: "enumerated",
+            values: Lib.sortObjectKeys(calendars.calendars),
+            editType: "calc",
+            dflt: "gregorian"
+          };
+          var handleDefaults = function(contIn, contOut, attr, dflt) {
+            var attrs = {};
+            attrs[attr] = attributes;
+            return Lib.coerce(contIn, contOut, attrs, attr, dflt);
+          };
+          var handleTraceDefaults = function(traceIn, traceOut, coords, layout) {
+            for (var i2 = 0; i2 < coords.length; i2++) {
+              handleDefaults(traceIn, traceOut, coords[i2] + "calendar", layout.calendar);
+            }
+          };
+          var CANONICAL_TICK = {
+            chinese: "2000-01-01",
+            coptic: "2000-01-01",
+            discworld: "2000-01-01",
+            ethiopian: "2000-01-01",
+            hebrew: "5000-01-01",
+            islamic: "1000-01-01",
+            julian: "2000-01-01",
+            mayan: "5000-01-01",
+            nanakshahi: "1000-01-01",
+            nepali: "2000-01-01",
+            persian: "1000-01-01",
+            jalali: "1000-01-01",
+            taiwan: "1000-01-01",
+            thai: "2000-01-01",
+            ummalqura: "1400-01-01"
+          };
+          var CANONICAL_SUNDAY = {
+            chinese: "2000-01-02",
+            coptic: "2000-01-03",
+            discworld: "2000-01-03",
+            ethiopian: "2000-01-05",
+            hebrew: "5000-01-01",
+            islamic: "1000-01-02",
+            julian: "2000-01-03",
+            mayan: "5000-01-01",
+            nanakshahi: "1000-01-05",
+            nepali: "2000-01-05",
+            persian: "1000-01-01",
+            jalali: "1000-01-01",
+            taiwan: "1000-01-04",
+            thai: "2000-01-04",
+            ummalqura: "1400-01-06"
+          };
+          var DFLTRANGE = {
+            chinese: ["2000-01-01", "2001-01-01"],
+            coptic: ["1700-01-01", "1701-01-01"],
+            discworld: ["1800-01-01", "1801-01-01"],
+            ethiopian: ["2000-01-01", "2001-01-01"],
+            hebrew: ["5700-01-01", "5701-01-01"],
+            islamic: ["1400-01-01", "1401-01-01"],
+            julian: ["2000-01-01", "2001-01-01"],
+            mayan: ["5200-01-01", "5201-01-01"],
+            nanakshahi: ["0500-01-01", "0501-01-01"],
+            nepali: ["2000-01-01", "2001-01-01"],
+            persian: ["1400-01-01", "1401-01-01"],
+            jalali: ["1400-01-01", "1401-01-01"],
+            taiwan: ["0100-01-01", "0101-01-01"],
+            thai: ["2500-01-01", "2501-01-01"],
+            ummalqura: ["1400-01-01", "1401-01-01"]
+          };
+          var UNKNOWN = "##";
+          var d3ToWorldCalendars = {
+            d: { 0: "dd", "-": "d" },
+            // 2-digit or unpadded day of month
+            e: { 0: "d", "-": "d" },
+            // alternate, always unpadded day of month
+            a: { 0: "D", "-": "D" },
+            // short weekday name
+            A: { 0: "DD", "-": "DD" },
+            // full weekday name
+            j: { 0: "oo", "-": "o" },
+            // 3-digit or unpadded day of the year
+            W: { 0: "ww", "-": "w" },
+            // 2-digit or unpadded week of the year (Monday first)
+            m: { 0: "mm", "-": "m" },
+            // 2-digit or unpadded month number
+            b: { 0: "M", "-": "M" },
+            // short month name
+            B: { 0: "MM", "-": "MM" },
+            // full month name
+            y: { 0: "yy", "-": "yy" },
+            // 2-digit year (map unpadded to zero-padded)
+            Y: { 0: "yyyy", "-": "yyyy" },
+            // 4-digit year (map unpadded to zero-padded)
+            U: UNKNOWN,
+            // Sunday-first week of the year
+            w: UNKNOWN,
+            // day of the week [0(sunday),6]
+            // combined format, we replace the date part with the world-calendar version
+            // and the %X stays there for d3 to handle with time parts
+            c: { 0: "D M d %X yyyy", "-": "D M d %X yyyy" },
+            x: { 0: "mm/dd/yyyy", "-": "mm/dd/yyyy" }
+          };
+          function worldCalFmt(fmt, x2, calendar) {
+            var dateJD = Math.floor((x2 + 0.05) / ONEDAY) + EPOCHJD;
+            var cDate = getCal(calendar).fromJD(dateJD);
+            var i2 = 0;
+            var modifier, directive, directiveLen, directiveObj, replacementPart;
+            while ((i2 = fmt.indexOf("%", i2)) !== -1) {
+              modifier = fmt.charAt(i2 + 1);
+              if (modifier === "0" || modifier === "-" || modifier === "_") {
+                directiveLen = 3;
+                directive = fmt.charAt(i2 + 2);
+                if (modifier === "_") modifier = "-";
+              } else {
+                directive = modifier;
+                modifier = "0";
+                directiveLen = 2;
+              }
+              directiveObj = d3ToWorldCalendars[directive];
+              if (!directiveObj) {
+                i2 += directiveLen;
+              } else {
+                if (directiveObj === UNKNOWN) replacementPart = UNKNOWN;
+                else replacementPart = cDate.formatDate(directiveObj[modifier]);
+                fmt = fmt.slice(0, i2) + replacementPart + fmt.slice(i2 + directiveLen);
+                i2 += replacementPart.length;
+              }
+            }
+            return fmt;
+          }
+          var allCals = {};
+          function getCal(calendar) {
+            var calendarObj = allCals[calendar];
+            if (calendarObj) return calendarObj;
+            calendarObj = allCals[calendar] = calendars.instance(calendar);
+            return calendarObj;
+          }
+          function makeAttrs(description) {
+            return Lib.extendFlat({}, attributes, { description });
+          }
+          function makeTraceAttrsDescription(coord) {
+            return "Sets the calendar system to use with `" + coord + "` date data.";
+          }
+          var xAttrs = {
+            xcalendar: makeAttrs(makeTraceAttrsDescription("x"))
+          };
+          var xyAttrs = Lib.extendFlat({}, xAttrs, {
+            ycalendar: makeAttrs(makeTraceAttrsDescription("y"))
+          });
+          var xyzAttrs = Lib.extendFlat({}, xyAttrs, {
+            zcalendar: makeAttrs(makeTraceAttrsDescription("z"))
+          });
+          var axisAttrs = makeAttrs([
+            "Sets the calendar system to use for `range` and `tick0`",
+            "if this is a date axis. This does not set the calendar for",
+            "interpreting data on this axis, that's specified in the trace",
+            "or via the global `layout.calendar`"
+          ].join(" "));
+          module2.exports = {
+            moduleType: "component",
+            name: "calendars",
+            schema: {
+              traces: {
+                scatter: xyAttrs,
+                bar: xyAttrs,
+                box: xyAttrs,
+                heatmap: xyAttrs,
+                contour: xyAttrs,
+                histogram: xyAttrs,
+                histogram2d: xyAttrs,
+                histogram2dcontour: xyAttrs,
+                scatter3d: xyzAttrs,
+                surface: xyzAttrs,
+                mesh3d: xyzAttrs,
+                scattergl: xyAttrs,
+                ohlc: xAttrs,
+                candlestick: xAttrs
+              },
+              layout: {
+                calendar: makeAttrs([
+                  "Sets the default calendar system to use for interpreting and",
+                  "displaying dates throughout the plot."
+                ].join(" "))
+              },
+              subplots: {
+                xaxis: { calendar: axisAttrs },
+                yaxis: { calendar: axisAttrs },
+                scene: {
+                  xaxis: { calendar: axisAttrs },
+                  // TODO: it's actually redundant to include yaxis and zaxis here
+                  // because in the scene attributes these are the same object so merging
+                  // into one merges into them all. However, I left them in for parity with
+                  // cartesian, where yaxis is unused until we Plotschema.get() when we
+                  // use its presence or absence to determine whether to delete attributes
+                  // from yaxis if they only apply to x (rangeselector/rangeslider)
+                  yaxis: { calendar: axisAttrs },
+                  zaxis: { calendar: axisAttrs }
+                },
+                polar: {
+                  radialaxis: { calendar: axisAttrs }
+                }
+              }
+            },
+            layoutAttributes: attributes,
+            handleDefaults,
+            handleTraceDefaults,
+            CANONICAL_SUNDAY,
+            CANONICAL_TICK,
+            DFLTRANGE,
+            getCal,
+            worldCalFmt
+          };
+        }
+      });
+      var require_calendars3 = __commonJS({
+        "lib/calendars.js"(exports, module2) {
+          module2.exports = require_calendars2();
+        }
+      });
+      var require_index = __commonJS({
+        "lib/index.js"(exports, module2) {
+          var Plotly2 = require_core2();
+          Plotly2.register([
+            // traces
+            require_bar2(),
+            require_box2(),
+            require_heatmap2(),
+            require_histogram2(),
+            require_histogram2d2(),
+            require_histogram2dcontour2(),
+            require_contour2(),
+            require_scatterternary2(),
+            require_violin2(),
+            require_funnel2(),
+            require_waterfall2(),
+            require_image2(),
+            require_pie2(),
+            require_sunburst2(),
+            require_treemap2(),
+            require_icicle2(),
+            require_funnelarea2(),
+            require_scatter3d2(),
+            require_surface2(),
+            require_isosurface2(),
+            require_volume2(),
+            require_mesh3d2(),
+            require_cone2(),
+            require_streamtube2(),
+            require_scattergeo2(),
+            require_choropleth2(),
+            require_scattergl2(),
+            require_splom2(),
+            require_parcoords3(),
+            require_parcats3(),
+            require_scattermapbox2(),
+            require_choroplethmapbox2(),
+            require_densitymapbox2(),
+            require_scattermap2(),
+            require_choroplethmap2(),
+            require_densitymap2(),
+            require_sankey2(),
+            require_indicator2(),
+            require_table2(),
+            require_carpet2(),
+            require_scattercarpet2(),
+            require_contourcarpet2(),
+            require_ohlc2(),
+            require_candlestick2(),
+            require_scatterpolar2(),
+            require_scatterpolargl2(),
+            require_barpolar2(),
+            require_scattersmith2(),
+            // components
+            require_calendars3()
+          ]);
+          module2.exports = Plotly2;
+        }
+      });
+      return require_index();
+    })();
+    /*!
+     * pad-left <https://github.com/jonschlinkert/pad-left>
+     *
+     * Copyright (c) 2014-2015, Jon Schlinkert.
+     * Licensed under the MIT license.
+     */
+    /*!
+     * repeat-string <https://github.com/jonschlinkert/repeat-string>
+     *
+     * Copyright (c) 2014-2015, Jon Schlinkert.
+     * Licensed under the MIT License.
+     */
+    /*! ieee754. BSD-3-Clause License. Feross Aboukhadijeh <https://feross.org/opensource> */
+    /*!
+     * The buffer module from node.js, for the browser.
+     *
+     * @author   Feross Aboukhadijeh <https://feross.org>
+     * @license  MIT
+     */
+    /*!
+     * Determine if an object is a Buffer
+     *
+     * @author   Feross Aboukhadijeh <https://feross.org>
+     * @license  MIT
+     */
+    /*! Bundled license information:
+
+    native-promise-only/lib/npo.src.js:
+      (*! Native Promise Only
+          v0.8.1 (c) Kyle Simpson
+          MIT License: http://getify.mit-license.org
+      *)
+
+    polybooljs/index.js:
+      (*
+       * @copyright 2016 Sean Connelly (@voidqk), http://syntheti.cc
+       * @license MIT
+       * @preserve Project Home: https://github.com/voidqk/polybooljs
+       *)
+
+    ieee754/index.js:
+      (*! ieee754. BSD-3-Clause License. Feross Aboukhadijeh <https://feross.org/opensource> *)
+
+    buffer/index.js:
+      (*!
+       * The buffer module from node.js, for the browser.
+       *
+       * @author   Feross Aboukhadijeh <https://feross.org>
+       * @license  MIT
+       *)
+
+    safe-buffer/index.js:
+      (*! safe-buffer. MIT License. Feross Aboukhadijeh <https://feross.org/opensource> *)
+
+    assert/build/internal/util/comparisons.js:
+      (*!
+       * The buffer module from node.js, for the browser.
+       *
+       * @author   Feross Aboukhadijeh <feross@feross.org> <http://feross.org>
+       * @license  MIT
+       *)
+
+    object-assign/index.js:
+      (*
+      object-assign
+      (c) Sindre Sorhus
+      @license MIT
+      *)
+
+    maplibre-gl/dist/maplibre-gl.js:
+      (**
+       * MapLibre GL JS
+       * @license 3-Clause BSD. Full text of license: https://github.com/maplibre/maplibre-gl-js/blob/v4.7.1/LICENSE.txt
+       *)
+    */
+    window.Plotly = Plotly;
+    return Plotly;
+  });
+})(plotly);
+var plotlyExports = plotly.exports;
+(function(exports) {
+  Object.defineProperty(exports, "__esModule", {
+    value: true
+  });
+  exports["default"] = void 0;
+  var _factory = _interopRequireDefault(factory);
+  var _plotly = _interopRequireDefault(plotlyExports);
+  function _interopRequireDefault(obj) {
+    return obj && obj.__esModule ? obj : { "default": obj };
+  }
+  var PlotComponent = (0, _factory["default"])(_plotly["default"]);
+  var _default = PlotComponent;
+  exports["default"] = _default;
+})(reactPlotly);
+const Plot = /* @__PURE__ */ getDefaultExportFromCjs(reactPlotly);
+const COLORS = [
+  "#1f77b4",
+  "#ff7f0e",
+  "#2ca02c",
+  "#d62728",
+  "#9467bd",
+  "#8c564b",
+  "#e377c2",
+  "#7f7f7f",
+  "#bcbd22",
+  "#17becf"
+];
+function linearFit(dates, values) {
+  if (dates.length < 2) return null;
+  const t0 = new Date(dates[0]).getTime();
+  const x2 = dates.map((d2) => (new Date(d2).getTime() - t0) / 864e5);
+  const y2 = values;
+  const n2 = x2.length;
+  const sumX = x2.reduce((a2, b2) => a2 + b2, 0);
+  const sumY = y2.reduce((a2, b2) => a2 + b2, 0);
+  const sumXY = x2.reduce((a2, xi2, i2) => a2 + xi2 * y2[i2], 0);
+  const sumXX = x2.reduce((a2, xi2) => a2 + xi2 * xi2, 0);
+  const denom = n2 * sumXX - sumX * sumX;
+  if (Math.abs(denom) < 1e-12) return null;
+  const slope = (n2 * sumXY - sumX * sumY) / denom;
+  const intercept = (sumY - slope * sumX) / n2;
+  const meanY = sumY / n2;
+  const ssRes = y2.reduce((a2, yi2, i2) => a2 + (yi2 - (slope * x2[i2] + intercept)) ** 2, 0);
+  const ssTot = y2.reduce((a2, yi2) => a2 + (yi2 - meanY) ** 2, 0);
+  const r2 = ssTot > 0 ? 1 - ssRes / ssTot : 0;
+  const mmPerYear = slope * 365.25;
+  return { slope, intercept, r2, mmPerYear };
 }
-class SecondParser extends Parser {
-  constructor() {
-    super(...arguments);
-    __publicField(this, "priority", 50);
-    __publicField(this, "incompatibleTokens", ["t", "T"]);
-  }
-  parse(dateString, token, match2) {
-    switch (token) {
-      case "s":
-        return parseNumericPattern(numericPatterns.second, dateString);
-      case "so":
-        return match2.ordinalNumber(dateString, { unit: "second" });
-      default:
-        return parseNDigits(token.length, dateString);
+function TimeSeriesChart() {
+  const { state, dispatch } = useAppContext();
+  const hasMultipleClicked = state.clickedPoints.length > 1;
+  const [showTrends, setShowTrends] = reactExports.useState(false);
+  const [dateStart, setDateStart] = reactExports.useState("");
+  const [dateEnd, setDateEnd] = reactExports.useState("");
+  const isLight = state.chartTheme === "light";
+  const exportImage = reactExports.useCallback(async (format = "png") => {
+    const plotDiv = document.querySelector(".js-plotly-plot");
+    if (!plotDiv) return;
+    const PlotlyLib = window.Plotly || (await __vitePreload(async () => {
+      const { default: __vite_default__ } = await import("./assets/plotly.min-Dxb8YwAJ.js").then((n2) => n2.p);
+      return { default: __vite_default__ };
+    }, true ? [] : void 0, import.meta.url)).default;
+    if (format === "svg") {
+      const svgData = await PlotlyLib.toImage(plotDiv, {
+        format: "svg",
+        width: 900,
+        height: 400
+      });
+      const link2 = document.createElement("a");
+      link2.download = `bowser_chart_${(/* @__PURE__ */ new Date()).toISOString().slice(0, 10)}.svg`;
+      link2.href = svgData;
+      link2.click();
+      return;
     }
-  }
-  validate(_date, value) {
-    return value >= 0 && value <= 59;
-  }
-  set(date, _flags, value) {
-    date.setSeconds(value, 0);
-    return date;
-  }
-}
-class FractionOfSecondParser extends Parser {
-  constructor() {
-    super(...arguments);
-    __publicField(this, "priority", 30);
-    __publicField(this, "incompatibleTokens", ["t", "T"]);
-  }
-  parse(dateString, token) {
-    const valueCallback = (value) => Math.trunc(value * Math.pow(10, -token.length + 3));
-    return mapValue(parseNDigits(token.length, dateString), valueCallback);
-  }
-  set(date, _flags, value) {
-    date.setMilliseconds(value);
-    return date;
-  }
-}
-class ISOTimezoneWithZParser extends Parser {
-  constructor() {
-    super(...arguments);
-    __publicField(this, "priority", 10);
-    __publicField(this, "incompatibleTokens", ["t", "T", "x"]);
-  }
-  parse(dateString, token) {
-    switch (token) {
-      case "X":
-        return parseTimezonePattern(
-          timezonePatterns.basicOptionalMinutes,
-          dateString
-        );
-      case "XX":
-        return parseTimezonePattern(timezonePatterns.basic, dateString);
-      case "XXXX":
-        return parseTimezonePattern(
-          timezonePatterns.basicOptionalSeconds,
-          dateString
-        );
-      case "XXXXX":
-        return parseTimezonePattern(
-          timezonePatterns.extendedOptionalSeconds,
-          dateString
-        );
-      case "XXX":
-      default:
-        return parseTimezonePattern(timezonePatterns.extended, dateString);
+    const mapCanvas = document.querySelector(".map-container canvas");
+    const scale2 = 2;
+    const exportW = 1600;
+    const mapH = mapCanvas ? Math.round(exportW * mapCanvas.height / mapCanvas.width) : 500;
+    const chartH = 400;
+    const combinedCanvas = document.createElement("canvas");
+    combinedCanvas.width = exportW * scale2;
+    combinedCanvas.height = (mapH + chartH) * scale2;
+    const ctx2 = combinedCanvas.getContext("2d");
+    if (!ctx2) return;
+    ctx2.scale(scale2, scale2);
+    ctx2.fillStyle = isLight ? "#ffffff" : "#1a1a2e";
+    ctx2.fillRect(0, 0, exportW, mapH + chartH);
+    if (mapCanvas) {
+      ctx2.drawImage(mapCanvas, 0, 0, exportW, mapH);
     }
-  }
-  set(date, flags, value) {
-    if (flags.timestampIsSet) return date;
-    return constructFrom(
-      date,
-      date.getTime() - getTimezoneOffsetInMilliseconds(date) - value
-    );
-  }
-}
-class ISOTimezoneParser extends Parser {
-  constructor() {
-    super(...arguments);
-    __publicField(this, "priority", 10);
-    __publicField(this, "incompatibleTokens", ["t", "T", "X"]);
-  }
-  parse(dateString, token) {
-    switch (token) {
-      case "x":
-        return parseTimezonePattern(
-          timezonePatterns.basicOptionalMinutes,
-          dateString
-        );
-      case "xx":
-        return parseTimezonePattern(timezonePatterns.basic, dateString);
-      case "xxxx":
-        return parseTimezonePattern(
-          timezonePatterns.basicOptionalSeconds,
-          dateString
-        );
-      case "xxxxx":
-        return parseTimezonePattern(
-          timezonePatterns.extendedOptionalSeconds,
-          dateString
-        );
-      case "xxx":
-      default:
-        return parseTimezonePattern(timezonePatterns.extended, dateString);
+    const chartImg = await PlotlyLib.toImage(plotDiv, {
+      format: "png",
+      width: exportW,
+      height: chartH,
+      scale: scale2
+    });
+    const img = new Image();
+    await new Promise((resolve) => {
+      img.onload = () => {
+        ctx2.drawImage(img, 0, mapH, exportW, chartH);
+        resolve();
+      };
+      img.src = chartImg;
+    });
+    const link = document.createElement("a");
+    link.download = `bowser_export_${(/* @__PURE__ */ new Date()).toISOString().slice(0, 10)}.png`;
+    link.href = combinedCanvas.toDataURL("image/png");
+    link.click();
+  }, [isLight]);
+  const refLookup = reactExports.useMemo(() => {
+    if (state.referenceTimeseries.length === 0) return null;
+    const map2 = /* @__PURE__ */ new Map();
+    for (const entry of state.referenceTimeseries) {
+      map2.set(entry.date, entry.displacement);
     }
-  }
-  set(date, flags, value) {
-    if (flags.timestampIsSet) return date;
-    return constructFrom(
-      date,
-      date.getTime() - getTimezoneOffsetInMilliseconds(date) - value
-    );
-  }
-}
-class TimestampSecondsParser extends Parser {
-  constructor() {
-    super(...arguments);
-    __publicField(this, "priority", 40);
-    __publicField(this, "incompatibleTokens", "*");
-  }
-  parse(dateString) {
-    return parseAnyDigitsSigned(dateString);
-  }
-  set(date, _flags, value) {
-    return [constructFrom(date, value * 1e3), { timestampIsSet: true }];
-  }
-}
-class TimestampMillisecondsParser extends Parser {
-  constructor() {
-    super(...arguments);
-    __publicField(this, "priority", 20);
-    __publicField(this, "incompatibleTokens", "*");
-  }
-  parse(dateString) {
-    return parseAnyDigitsSigned(dateString);
-  }
-  set(date, _flags, value) {
-    return [constructFrom(date, value), { timestampIsSet: true }];
-  }
-}
-const parsers = {
-  G: new EraParser(),
-  y: new YearParser(),
-  Y: new LocalWeekYearParser(),
-  R: new ISOWeekYearParser(),
-  u: new ExtendedYearParser(),
-  Q: new QuarterParser(),
-  q: new StandAloneQuarterParser(),
-  M: new MonthParser(),
-  L: new StandAloneMonthParser(),
-  w: new LocalWeekParser(),
-  I: new ISOWeekParser(),
-  d: new DateParser(),
-  D: new DayOfYearParser(),
-  E: new DayParser(),
-  e: new LocalDayParser(),
-  c: new StandAloneLocalDayParser(),
-  i: new ISODayParser(),
-  a: new AMPMParser(),
-  b: new AMPMMidnightParser(),
-  B: new DayPeriodParser(),
-  h: new Hour1to12Parser(),
-  H: new Hour0to23Parser(),
-  K: new Hour0To11Parser(),
-  k: new Hour1To24Parser(),
-  m: new MinuteParser(),
-  s: new SecondParser(),
-  S: new FractionOfSecondParser(),
-  X: new ISOTimezoneWithZParser(),
-  x: new ISOTimezoneParser(),
-  t: new TimestampSecondsParser(),
-  T: new TimestampMillisecondsParser()
-};
-const formattingTokensRegExp = /[yYQqMLwIdDecihHKkms]o|(\w)\1*|''|'(''|[^'])+('|$)|./g;
-const longFormattingTokensRegExp = /P+p+|P+|p+|''|'(''|[^'])+('|$)|./g;
-const escapedStringRegExp = /^'([^]*?)'?$/;
-const doubleQuoteRegExp = /''/g;
-const notWhitespaceRegExp = /\S/;
-const unescapedLatinCharacterRegExp = /[a-zA-Z]/;
-function parse(dateStr, formatStr, referenceDate, options) {
-  var _a2, _b2, _c, _d, _e, _f, _g, _h;
-  const invalidDate = () => constructFrom((options == null ? void 0 : options.in) || referenceDate, NaN);
-  const defaultOptions2 = getDefaultOptions();
-  const locale = (options == null ? void 0 : options.locale) ?? defaultOptions2.locale ?? enUS;
-  const firstWeekContainsDate = (options == null ? void 0 : options.firstWeekContainsDate) ?? ((_b2 = (_a2 = options == null ? void 0 : options.locale) == null ? void 0 : _a2.options) == null ? void 0 : _b2.firstWeekContainsDate) ?? defaultOptions2.firstWeekContainsDate ?? ((_d = (_c = defaultOptions2.locale) == null ? void 0 : _c.options) == null ? void 0 : _d.firstWeekContainsDate) ?? 1;
-  const weekStartsOn = (options == null ? void 0 : options.weekStartsOn) ?? ((_f = (_e = options == null ? void 0 : options.locale) == null ? void 0 : _e.options) == null ? void 0 : _f.weekStartsOn) ?? defaultOptions2.weekStartsOn ?? ((_h = (_g = defaultOptions2.locale) == null ? void 0 : _g.options) == null ? void 0 : _h.weekStartsOn) ?? 0;
-  if (!formatStr)
-    return dateStr ? invalidDate() : toDate(referenceDate, options == null ? void 0 : options.in);
-  const subFnOptions = {
-    firstWeekContainsDate,
-    weekStartsOn,
-    locale
-  };
-  const setters = [new DateTimezoneSetter(options == null ? void 0 : options.in, referenceDate)];
-  const tokens = formatStr.match(longFormattingTokensRegExp).map((substring) => {
-    const firstCharacter = substring[0];
-    if (firstCharacter in longFormatters) {
-      const longFormatter = longFormatters[firstCharacter];
-      return longFormatter(substring, locale.formatLong);
-    }
-    return substring;
-  }).join("").match(formattingTokensRegExp);
-  const usedTokens = [];
-  for (let token of tokens) {
-    if (!(options == null ? void 0 : options.useAdditionalWeekYearTokens) && isProtectedWeekYearToken(token)) {
-      warnOrThrowProtectedError(token, formatStr, dateStr);
-    }
-    if (!(options == null ? void 0 : options.useAdditionalDayOfYearTokens) && isProtectedDayOfYearToken(token)) {
-      warnOrThrowProtectedError(token, formatStr, dateStr);
-    }
-    const firstCharacter = token[0];
-    const parser = parsers[firstCharacter];
-    if (parser) {
-      const { incompatibleTokens } = parser;
-      if (Array.isArray(incompatibleTokens)) {
-        const incompatibleToken = usedTokens.find(
-          (usedToken) => incompatibleTokens.includes(usedToken.token) || usedToken.token === firstCharacter
-        );
-        if (incompatibleToken) {
-          throw new RangeError(
-            `The format string mustn't contain \`${incompatibleToken.fullToken}\` and \`${token}\` at the same time`
-          );
+    return map2;
+  }, [state.referenceTimeseries]);
+  const traces = reactExports.useMemo(() => {
+    var _a3;
+    const result = [];
+    if (state.clickedPoints.length > 0) {
+      for (let i2 = 0; i2 < state.clickedPoints.length; i2++) {
+        const cp = state.clickedPoints[i2];
+        const filtered = cp.timeseries.filter((t2) => {
+          if (dateStart && t2.date < dateStart) return false;
+          if (dateEnd && t2.date > dateEnd) return false;
+          return true;
+        });
+        const x2 = filtered.map((t2) => t2.date);
+        const y2 = filtered.map((t2) => {
+          if (refLookup) {
+            const refVal = refLookup.get(t2.date) ?? 0;
+            return t2.displacement - refVal;
+          }
+          return t2.displacement;
+        });
+        const color2 = COLORS[i2 % COLORS.length];
+        result.push({
+          x: x2,
+          y: y2,
+          type: "scattergl",
+          mode: "lines+markers",
+          name: `Point ${cp.pointId}`,
+          marker: { color: color2, size: 5 },
+          line: { color: color2, width: 1.5 }
+        });
+        if (showTrends) {
+          const fit = linearFit(x2, y2);
+          if (fit) {
+            const t0 = new Date(x2[0]).getTime();
+            const trendY = x2.map((d2) => {
+              const days = (new Date(d2).getTime() - t0) / 864e5;
+              return fit.slope * days + fit.intercept;
+            });
+            result.push({
+              x: x2,
+              y: trendY,
+              type: "scattergl",
+              mode: "lines",
+              name: `${fit.mmPerYear >= 0 ? "+" : ""}${fit.mmPerYear.toFixed(1)} mm/yr (R²=${fit.r2.toFixed(2)})`,
+              line: { color: color2, width: 1, dash: "dash" },
+              showlegend: true
+            });
+          }
         }
-      } else if (parser.incompatibleTokens === "*" && usedTokens.length > 0) {
-        throw new RangeError(
-          `The format string mustn't contain \`${token}\` and any other token at the same time`
-        );
-      }
-      usedTokens.push({ token: firstCharacter, fullToken: token });
-      const parseResult = parser.run(
-        dateStr,
-        token,
-        locale.match,
-        subFnOptions
-      );
-      if (!parseResult) {
-        return invalidDate();
       }
-      setters.push(parseResult.setter);
-      dateStr = parseResult.rest;
-    } else {
-      if (firstCharacter.match(unescapedLatinCharacterRegExp)) {
-        throw new RangeError(
-          "Format string contains an unescaped latin alphabet character `" + firstCharacter + "`"
-        );
-      }
-      if (token === "''") {
-        token = "'";
-      } else if (firstCharacter === "'") {
-        token = cleanEscapedString(token);
-      }
-      if (dateStr.indexOf(token) === 0) {
-        dateStr = dateStr.slice(token.length);
-      } else {
-        return invalidDate();
-      }
-    }
-  }
-  if (dateStr.length > 0 && notWhitespaceRegExp.test(dateStr)) {
-    return invalidDate();
-  }
-  const uniquePrioritySetters = setters.map((setter) => setter.priority).sort((a, b) => b - a).filter((priority, index, array) => array.indexOf(priority) === index).map(
-    (priority) => setters.filter((setter) => setter.priority === priority).sort((a, b) => b.subPriority - a.subPriority)
-  ).map((setterArray) => setterArray[0]);
-  let date = toDate(referenceDate, options == null ? void 0 : options.in);
-  if (isNaN(+date)) return invalidDate();
-  const flags = {};
-  for (const setter of uniquePrioritySetters) {
-    if (!setter.validate(date, subFnOptions)) {
-      return invalidDate();
-    }
-    const result = setter.set(date, flags, subFnOptions);
-    if (Array.isArray(result)) {
-      date = result[0];
-      Object.assign(flags, result[1]);
-    } else {
-      date = result;
-    }
-  }
-  return date;
-}
-function cleanEscapedString(input) {
-  return input.match(escapedStringRegExp)[1].replace(doubleQuoteRegExp, "'");
-}
-function startOfHour(date, options) {
-  const _date = toDate(date, options == null ? void 0 : options.in);
-  _date.setMinutes(0, 0, 0);
-  return _date;
-}
-function startOfMinute(date, options) {
-  const date_ = toDate(date, options == null ? void 0 : options.in);
-  date_.setSeconds(0, 0);
-  return date_;
-}
-function startOfSecond(date, options) {
-  const date_ = toDate(date, options == null ? void 0 : options.in);
-  date_.setMilliseconds(0);
-  return date_;
-}
-function parseISO(argument, options) {
-  const invalidDate = () => constructFrom(options == null ? void 0 : options.in, NaN);
-  const additionalDigits = (options == null ? void 0 : options.additionalDigits) ?? 2;
-  const dateStrings = splitDateString(argument);
-  let date;
-  if (dateStrings.date) {
-    const parseYearResult = parseYear(dateStrings.date, additionalDigits);
-    date = parseDate(parseYearResult.restDateString, parseYearResult.year);
-  }
-  if (!date || isNaN(+date)) return invalidDate();
-  const timestamp = +date;
-  let time = 0;
-  let offset;
-  if (dateStrings.time) {
-    time = parseTime(dateStrings.time);
-    if (isNaN(time)) return invalidDate();
-  }
-  if (dateStrings.timezone) {
-    offset = parseTimezone(dateStrings.timezone);
-    if (isNaN(offset)) return invalidDate();
-  } else {
-    const tmpDate = new Date(timestamp + time);
-    const result = toDate(0, options == null ? void 0 : options.in);
-    result.setFullYear(
-      tmpDate.getUTCFullYear(),
-      tmpDate.getUTCMonth(),
-      tmpDate.getUTCDate()
-    );
-    result.setHours(
-      tmpDate.getUTCHours(),
-      tmpDate.getUTCMinutes(),
-      tmpDate.getUTCSeconds(),
-      tmpDate.getUTCMilliseconds()
-    );
-    return result;
-  }
-  return toDate(timestamp + time + offset, options == null ? void 0 : options.in);
-}
-const patterns = {
-  dateTimeDelimiter: /[T ]/,
-  timeZoneDelimiter: /[Z ]/i,
-  timezone: /([Z+-].*)$/
-};
-const dateRegex = /^-?(?:(\d{3})|(\d{2})(?:-?(\d{2}))?|W(\d{2})(?:-?(\d{1}))?|)$/;
-const timeRegex = /^(\d{2}(?:[.,]\d*)?)(?::?(\d{2}(?:[.,]\d*)?))?(?::?(\d{2}(?:[.,]\d*)?))?$/;
-const timezoneRegex = /^([+-])(\d{2})(?::?(\d{2}))?$/;
-function splitDateString(dateString) {
-  const dateStrings = {};
-  const array = dateString.split(patterns.dateTimeDelimiter);
-  let timeString;
-  if (array.length > 2) {
-    return dateStrings;
-  }
-  if (/:/.test(array[0])) {
-    timeString = array[0];
-  } else {
-    dateStrings.date = array[0];
-    timeString = array[1];
-    if (patterns.timeZoneDelimiter.test(dateStrings.date)) {
-      dateStrings.date = dateString.split(patterns.timeZoneDelimiter)[0];
-      timeString = dateString.substr(
-        dateStrings.date.length,
-        dateString.length
-      );
-    }
-  }
-  if (timeString) {
-    const token = patterns.timezone.exec(timeString);
-    if (token) {
-      dateStrings.time = timeString.replace(token[1], "");
-      dateStrings.timezone = token[1];
-    } else {
-      dateStrings.time = timeString;
-    }
-  }
-  return dateStrings;
-}
-function parseYear(dateString, additionalDigits) {
-  const regex = new RegExp(
-    "^(?:(\\d{4}|[+-]\\d{" + (4 + additionalDigits) + "})|(\\d{2}|[+-]\\d{" + (2 + additionalDigits) + "})$)"
-  );
-  const captures = dateString.match(regex);
-  if (!captures) return { year: NaN, restDateString: "" };
-  const year = captures[1] ? parseInt(captures[1]) : null;
-  const century = captures[2] ? parseInt(captures[2]) : null;
-  return {
-    year: century === null ? year : century * 100,
-    restDateString: dateString.slice((captures[1] || captures[2]).length)
-  };
-}
-function parseDate(dateString, year) {
-  if (year === null) return /* @__PURE__ */ new Date(NaN);
-  const captures = dateString.match(dateRegex);
-  if (!captures) return /* @__PURE__ */ new Date(NaN);
-  const isWeekDate = !!captures[4];
-  const dayOfYear = parseDateUnit(captures[1]);
-  const month = parseDateUnit(captures[2]) - 1;
-  const day = parseDateUnit(captures[3]);
-  const week = parseDateUnit(captures[4]);
-  const dayOfWeek = parseDateUnit(captures[5]) - 1;
-  if (isWeekDate) {
-    if (!validateWeekDate(year, week, dayOfWeek)) {
-      return /* @__PURE__ */ new Date(NaN);
-    }
-    return dayOfISOWeekYear(year, week, dayOfWeek);
-  } else {
-    const date = /* @__PURE__ */ new Date(0);
-    if (!validateDate(year, month, day) || !validateDayOfYearDate(year, dayOfYear)) {
-      return /* @__PURE__ */ new Date(NaN);
-    }
-    date.setUTCFullYear(year, month, Math.max(dayOfYear, day));
-    return date;
-  }
-}
-function parseDateUnit(value) {
-  return value ? parseInt(value) : 1;
-}
-function parseTime(timeString) {
-  const captures = timeString.match(timeRegex);
-  if (!captures) return NaN;
-  const hours = parseTimeUnit(captures[1]);
-  const minutes = parseTimeUnit(captures[2]);
-  const seconds = parseTimeUnit(captures[3]);
-  if (!validateTime(hours, minutes, seconds)) {
-    return NaN;
-  }
-  return hours * millisecondsInHour + minutes * millisecondsInMinute + seconds * 1e3;
-}
-function parseTimeUnit(value) {
-  return value && parseFloat(value.replace(",", ".")) || 0;
-}
-function parseTimezone(timezoneString) {
-  if (timezoneString === "Z") return 0;
-  const captures = timezoneString.match(timezoneRegex);
-  if (!captures) return 0;
-  const sign2 = captures[1] === "+" ? -1 : 1;
-  const hours = parseInt(captures[2]);
-  const minutes = captures[3] && parseInt(captures[3]) || 0;
-  if (!validateTimezone(hours, minutes)) {
-    return NaN;
-  }
-  return sign2 * (hours * millisecondsInHour + minutes * millisecondsInMinute);
-}
-function dayOfISOWeekYear(isoWeekYear, week, day) {
-  const date = /* @__PURE__ */ new Date(0);
-  date.setUTCFullYear(isoWeekYear, 0, 4);
-  const fourthOfJanuaryDay = date.getUTCDay() || 7;
-  const diff = (week - 1) * 7 + day + 1 - fourthOfJanuaryDay;
-  date.setUTCDate(date.getUTCDate() + diff);
-  return date;
-}
-const daysInMonths = [31, null, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31];
-function isLeapYearIndex(year) {
-  return year % 400 === 0 || year % 4 === 0 && year % 100 !== 0;
-}
-function validateDate(year, month, date) {
-  return month >= 0 && month <= 11 && date >= 1 && date <= (daysInMonths[month] || (isLeapYearIndex(year) ? 29 : 28));
-}
-function validateDayOfYearDate(year, dayOfYear) {
-  return dayOfYear >= 1 && dayOfYear <= (isLeapYearIndex(year) ? 366 : 365);
-}
-function validateWeekDate(_year, week, day) {
-  return week >= 1 && week <= 53 && day >= 0 && day <= 6;
-}
-function validateTime(hours, minutes, seconds) {
-  if (hours === 24) {
-    return minutes === 0 && seconds === 0;
-  }
-  return seconds >= 0 && seconds < 60 && minutes >= 0 && minutes < 60 && hours >= 0 && hours < 25;
-}
-function validateTimezone(_hours, minutes) {
-  return minutes >= 0 && minutes <= 59;
-}
-/*!
- * chartjs-adapter-date-fns v3.0.0
- * https://www.chartjs.org
- * (c) 2022 chartjs-adapter-date-fns Contributors
- * Released under the MIT license
- */
-const FORMATS = {
-  datetime: "MMM d, yyyy, h:mm:ss aaaa",
-  millisecond: "h:mm:ss.SSS aaaa",
-  second: "h:mm:ss aaaa",
-  minute: "h:mm aaaa",
-  hour: "ha",
-  day: "MMM d",
-  week: "PP",
-  month: "MMM yyyy",
-  quarter: "qqq - yyyy",
-  year: "yyyy"
-};
-adapters._date.override({
-  _id: "date-fns",
-  // DEBUG
-  formats: function() {
-    return FORMATS;
-  },
-  parse: function(value, fmt) {
-    if (value === null || typeof value === "undefined") {
-      return null;
+      return result;
     }
-    const type = typeof value;
-    if (type === "number" || value instanceof Date) {
-      value = toDate(value);
-    } else if (type === "string") {
-      if (typeof fmt === "string") {
-        value = parse(value, fmt, /* @__PURE__ */ new Date(), this.options);
-      } else {
-        value = parseISO(value, this.options);
+    if (state.timeSeriesPoints.length > 0 && state.currentDataset) {
+      const refVals = state.refValues[state.currentDataset];
+      for (const p2 of state.timeSeriesPoints) {
+        if (!p2.visible || !((_a3 = p2.data) == null ? void 0 : _a3[state.currentDataset])) continue;
+        const rawData = p2.data[state.currentDataset];
+        const data = refVals ? rawData.map((v2, i2) => v2 - (refVals[i2] ?? 0)) : rawData;
+        const info = state.datasetInfo[state.currentDataset];
+        const xValues = (info == null ? void 0 : info.x_values) || data.map((_2, i2) => i2);
+        result.push({
+          x: xValues,
+          y: data,
+          type: "scattergl",
+          mode: "lines+markers",
+          name: p2.name,
+          marker: { color: p2.color, size: 5 },
+          line: { color: p2.color, width: 1.5 }
+        });
       }
     }
-    return isValid(value) ? value.getTime() : null;
-  },
-  format: function(time, fmt) {
-    return format(time, fmt, this.options);
-  },
-  add: function(time, amount, unit) {
-    switch (unit) {
-      case "millisecond":
-        return addMilliseconds(time, amount);
-      case "second":
-        return addSeconds(time, amount);
-      case "minute":
-        return addMinutes(time, amount);
-      case "hour":
-        return addHours(time, amount);
-      case "day":
-        return addDays(time, amount);
-      case "week":
-        return addWeeks(time, amount);
-      case "month":
-        return addMonths(time, amount);
-      case "quarter":
-        return addQuarters(time, amount);
-      case "year":
-        return addYears(time, amount);
-      default:
-        return time;
-    }
-  },
-  diff: function(max, min, unit) {
-    switch (unit) {
-      case "millisecond":
-        return differenceInMilliseconds(max, min);
-      case "second":
-        return differenceInSeconds(max, min);
-      case "minute":
-        return differenceInMinutes(max, min);
-      case "hour":
-        return differenceInHours(max, min);
-      case "day":
-        return differenceInDays(max, min);
-      case "week":
-        return differenceInWeeks(max, min);
-      case "month":
-        return differenceInMonths(max, min);
-      case "quarter":
-        return differenceInQuarters(max, min);
-      case "year":
-        return differenceInYears(max, min);
-      default:
-        return 0;
-    }
-  },
-  startOf: function(time, unit, weekday) {
-    switch (unit) {
-      case "second":
-        return startOfSecond(time);
-      case "minute":
-        return startOfMinute(time);
-      case "hour":
-        return startOfHour(time);
-      case "day":
-        return startOfDay(time);
-      case "week":
-        return startOfWeek(time);
-      case "isoWeek":
-        return startOfWeek(time, { weekStartsOn: +weekday });
-      case "month":
-        return startOfMonth(time);
-      case "quarter":
-        return startOfQuarter(time);
-      case "year":
-        return startOfYear(time);
-      default:
-        return time;
-    }
-  },
-  endOf: function(time, unit) {
-    switch (unit) {
-      case "second":
-        return endOfSecond(time);
-      case "minute":
-        return endOfMinute(time);
-      case "hour":
-        return endOfHour(time);
-      case "day":
-        return endOfDay(time);
-      case "week":
-        return endOfWeek(time);
-      case "month":
-        return endOfMonth(time);
-      case "quarter":
-        return endOfQuarter(time);
-      case "year":
-        return endOfYear(time);
-      default:
-        return time;
-    }
-  }
-});
-Chart$1.register(TimeScale, LinearScale, PointElement, LineElement, plugin_title, plugin_tooltip, plugin_legend);
-function TimeSeriesChart() {
-  const { state, dispatch } = useAppContext();
-  const { fetchMultiPointTimeSeries } = useApi();
-  const [chartData, setChartData] = reactExports.useState(null);
-  const [isLoading, setIsLoading] = reactExports.useState(false);
-  const updateChart = reactExports.useCallback(async () => {
-    if (!state.showChart || !state.currentDataset || state.timeSeriesPoints.length === 0) {
-      setChartData(null);
-      return;
-    }
-    setIsLoading(true);
-    const currentDatasetInfo = state.datasetInfo[state.currentDataset];
-    const visiblePoints = state.timeSeriesPoints.filter((p2) => p2.visible);
-    if (visiblePoints.length === 0) {
-      setChartData(null);
-      setIsLoading(false);
-      return;
-    }
-    try {
-      const apiPoints = visiblePoints.map((point) => ({
-        id: point.id,
-        lat: point.position[0],
-        lon: point.position[1],
-        color: point.color,
-        name: point.name
-      }));
-      let refLon, refLat;
-      if (currentDatasetInfo == null ? void 0 : currentDatasetInfo.uses_spatial_ref) {
-        [refLat, refLon] = state.refMarkerPosition;
-      }
-      const tsData = await fetchMultiPointTimeSeries(
-        apiPoints,
-        state.currentDataset,
-        refLon,
-        refLat,
-        state.showTrends
+    if (state.gpsTimeseries.length > 0 && state.gpsSelectedStationId) {
+      const gpsFiltered = state.gpsTimeseries.filter((t2) => {
+        if (dateStart && t2.date < dateStart) return false;
+        if (dateEnd && t2.date > dateEnd) return false;
+        return true;
+      });
+      const componentKey = state.gpsComponent;
+      const x2 = gpsFiltered.map((t2) => t2.date);
+      const y2 = gpsFiltered.map(
+        (t2) => componentKey === "los" ? t2.displacement : t2[componentKey]
       );
-      if (tsData) {
-        setChartData(tsData);
-        if (state.showTrends && tsData.datasets) {
-          setTimeout(() => {
-            tsData.datasets.forEach((dataset) => {
-              if (dataset.trend) {
-                dispatch({
-                  type: "SET_POINT_TREND_DATA",
-                  payload: {
-                    pointId: dataset.pointId,
-                    dataset: state.currentDataset,
-                    trend: {
-                      slope: dataset.trend.slope,
-                      intercept: dataset.trend.intercept,
-                      rSquared: dataset.trend.rSquared,
-                      mmPerYear: dataset.trend.mmPerYear
-                    }
-                  }
-                });
-              }
-            });
-          }, 0);
+      const componentLabel = componentKey === "los" ? "LOS" : componentKey.toUpperCase();
+      result.push({
+        x: x2,
+        y: y2,
+        type: "scattergl",
+        mode: "lines+markers",
+        name: `GPS: ${state.gpsSelectedStationId} (${componentLabel})`,
+        marker: { color: "#22aa66", size: 7, symbol: "diamond" },
+        line: { color: "#22aa66", width: 2, dash: "dash" }
+      });
+      if (showTrends) {
+        const fit = linearFit(x2, y2);
+        if (fit) {
+          const t0 = new Date(x2[0]).getTime();
+          const trendY = x2.map((d2) => {
+            const days = (new Date(d2).getTime() - t0) / 864e5;
+            return fit.slope * days + fit.intercept;
+          });
+          result.push({
+            x: x2,
+            y: trendY,
+            type: "scattergl",
+            mode: "lines",
+            name: `GPS trend: ${fit.mmPerYear >= 0 ? "+" : ""}${fit.mmPerYear.toFixed(1)} mm/yr (R²=${fit.r2.toFixed(2)})`,
+            line: { color: "#22aa66", width: 1, dash: "dot" },
+            showlegend: true
+          });
         }
       }
-    } catch (error) {
-      console.error("Error updating chart:", error);
-    } finally {
-      setIsLoading(false);
     }
+    return result;
   }, [
-    state.showChart,
+    state.clickedPoints,
+    state.timeSeriesPoints,
     state.currentDataset,
-    JSON.stringify(state.timeSeriesPoints.map((p2) => ({ id: p2.id, position: p2.position, visible: p2.visible }))),
-    // Only track relevant point changes
-    state.refMarkerPosition,
     state.datasetInfo,
-    state.showTrends,
-    fetchMultiPointTimeSeries
-  ]);
-  reactExports.useEffect(() => {
-    updateChart();
-  }, [
-    updateChart
+    state.refValues,
+    state.gpsTimeseries,
+    state.gpsSelectedStationId,
+    state.gpsComponent,
+    refLookup,
+    showTrends,
+    dateStart,
+    dateEnd
   ]);
-  const handleChartClick = reactExports.useCallback((_event, elements) => {
-    if (elements.length === 0 || !chartData) return;
-    const element = elements[0];
-    const dataIndex = element.index;
-    if (dataIndex !== void 0 && dataIndex < chartData.labels.length) {
-      dispatch({ type: "SET_TIME_INDEX", payload: dataIndex });
-    }
-  }, [chartData, dispatch]);
-  const handleExportToCSV = reactExports.useCallback(() => {
-    if (!chartData || !chartData.datasets || chartData.datasets.length === 0) return;
-    const headers = ["Time", ...chartData.datasets.map((d) => d.label)];
-    const rows = [];
-    chartData.labels.forEach((label, idx) => {
-      const row = [label];
-      chartData.datasets.forEach((dataset) => {
-        const dataPoint = dataset.data[idx];
-        row.push(dataPoint ? dataPoint.y.toString() : "");
-      });
-      rows.push(row);
-    });
-    const trendRows = [];
-    if (state.showTrends && chartData.datasets.some((d) => d.trend)) {
-      trendRows.push([""]);
-      trendRows.push(["Point", "Rate (mm/year)", "R²", "Slope", "Intercept"]);
-      chartData.datasets.forEach((dataset) => {
-        if (dataset.trend) {
-          trendRows.push([
-            dataset.label,
-            dataset.trend.mmPerYear.toFixed(6),
-            dataset.trend.rSquared.toFixed(6),
-            dataset.trend.slope.toFixed(6),
-            dataset.trend.intercept.toFixed(6)
-          ]);
-        }
-      });
-    }
-    const allRows = [headers, ...rows, ...trendRows];
-    const csvContent = allRows.map((row) => row.join(",")).join("\n");
-    const blob = new Blob([csvContent], { type: "text/csv;charset=utf-8;" });
-    const link = document.createElement("a");
-    const url = URL.createObjectURL(blob);
-    const timestamp = (/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-").slice(0, -5);
-    link.setAttribute("href", url);
-    link.setAttribute("download", `time-series-${state.currentDataset}-${timestamp}.csv`);
-    link.style.visibility = "hidden";
-    document.body.appendChild(link);
-    link.click();
-    document.body.removeChild(link);
-  }, [chartData, state.showTrends, state.currentDataset]);
-  const chartOptions = {
-    responsive: true,
-    maintainAspectRatio: false,
-    animation: {
-      duration: 300
-    },
-    interaction: {
-      mode: "index",
-      intersect: false
-    },
-    plugins: {
-      legend: {
-        display: true,
-        position: "top",
-        labels: {
-          usePointStyle: true,
-          padding: 20,
-          generateLabels: (_chart) => {
-            if (!(chartData == null ? void 0 : chartData.datasets)) return [];
-            return chartData.datasets.map((dataset, index) => ({
-              text: `${dataset.label}${dataset.trend && dataset.trend.mmPerYear !== void 0 ? ` (${dataset.trend.mmPerYear.toFixed(1)} mm/yr)` : ""}`,
-              pointStyle: "circle",
-              fillStyle: dataset.borderColor,
-              strokeStyle: dataset.borderColor,
-              lineWidth: 2,
-              datasetIndex: index
-            }));
+  if (traces.length === 0) return null;
+  return /* @__PURE__ */ jsxRuntimeExports.jsxs("div", { style: {
+    position: "absolute",
+    bottom: 0,
+    left: 0,
+    right: 0,
+    height: "250px",
+    zIndex: 1e3,
+    background: isLight ? "#ffffff" : "#1a1a2e",
+    borderTop: isLight ? "1px solid #ccc" : "1px solid #333",
+    display: "flex",
+    flexDirection: "column"
+  }, children: [
+    (hasMultipleClicked || state.referencePointId != null || state.gpsSelectedStationId) && /* @__PURE__ */ jsxRuntimeExports.jsxs("div", { style: {
+      display: "flex",
+      alignItems: "center",
+      gap: 8,
+      padding: "3px 10px",
+      background: isLight ? "#f0f0f0" : "#12122a",
+      borderBottom: isLight ? "1px solid #ddd" : "1px solid #2a2a4a",
+      fontSize: 11,
+      flexShrink: 0
+    }, children: [
+      state.referencePointId != null && /* @__PURE__ */ jsxRuntimeExports.jsxs("span", { style: {
+        display: "inline-flex",
+        alignItems: "center",
+        gap: 3,
+        background: "#1a3a2a",
+        padding: "1px 6px",
+        borderRadius: 3,
+        color: "#0f8",
+        fontSize: 11
+      }, children: [
+        "ref: ",
+        state.referencePointId,
+        /* @__PURE__ */ jsxRuntimeExports.jsx(
+          "button",
+          {
+            onClick: () => dispatch({ type: "CLEAR_REFERENCE_POINT" }),
+            style: {
+              background: "none",
+              border: "none",
+              color: "#888",
+              cursor: "pointer",
+              fontSize: 11,
+              padding: 0,
+              lineHeight: 1
+            },
+            children: "x"
           }
-        }
-      },
-      tooltip: {
-        callbacks: {
-          title: (context) => {
-            var _a2;
-            return `Time: ${((_a2 = context[0]) == null ? void 0 : _a2.label) || ""}`;
+        )
+      ] }),
+      hasMultipleClicked && /* @__PURE__ */ jsxRuntimeExports.jsxs("span", { style: { color: "#999" }, children: [
+        state.clickedPoints.length,
+        " pts"
+      ] }),
+      state.clickedPoints.map((cp, i2) => /* @__PURE__ */ jsxRuntimeExports.jsxs(
+        "span",
+        {
+          style: {
+            display: "inline-flex",
+            alignItems: "center",
+            gap: 3,
+            background: "#1a2a3a",
+            padding: "1px 6px",
+            borderRadius: 3,
+            color: COLORS[i2 % COLORS.length]
           },
-          label: (context) => {
-            var _a2;
-            const dataset = (_a2 = chartData == null ? void 0 : chartData.datasets) == null ? void 0 : _a2[context.datasetIndex];
-            if (!dataset) return "";
-            let label = `${dataset.label}: ${context.parsed.y.toFixed(3)}`;
-            if (dataset.trend && dataset.trend.mmPerYear !== void 0 && state.showTrends) {
-              label += ` (${dataset.trend.mmPerYear.toFixed(1)} mm/yr)`;
-            }
-            return label;
+          children: [
+            cp.pointId,
+            /* @__PURE__ */ jsxRuntimeExports.jsx(
+              "button",
+              {
+                onClick: () => dispatch({ type: "REMOVE_CLICKED_POINT", payload: cp.pointId }),
+                style: {
+                  background: "none",
+                  border: "none",
+                  color: "#888",
+                  cursor: "pointer",
+                  fontSize: 11,
+                  padding: 0,
+                  lineHeight: 1
+                },
+                children: "x"
+              }
+            )
+          ]
+        },
+        cp.pointId
+      )),
+      state.gpsSelectedStationId && /* @__PURE__ */ jsxRuntimeExports.jsxs("span", { style: {
+        display: "inline-flex",
+        alignItems: "center",
+        gap: 3,
+        background: isLight ? "#e0f5e0" : "#1a3a2a",
+        padding: "1px 6px",
+        borderRadius: 3,
+        color: "#22aa66",
+        fontSize: 11
+      }, children: [
+        "GPS: ",
+        state.gpsSelectedStationId,
+        /* @__PURE__ */ jsxRuntimeExports.jsx(
+          "button",
+          {
+            onClick: () => {
+              dispatch({ type: "SET_GPS_SELECTED_STATION", payload: null });
+              dispatch({ type: "SET_GPS_TIMESERIES", payload: [] });
+            },
+            style: {
+              background: "none",
+              border: "none",
+              color: "#888",
+              cursor: "pointer",
+              fontSize: 11,
+              padding: 0,
+              lineHeight: 1
+            },
+            children: "x"
           }
+        )
+      ] }),
+      /* @__PURE__ */ jsxRuntimeExports.jsx(
+        "button",
+        {
+          onClick: () => dispatch({ type: "CLEAR_CLICKED_POINTS" }),
+          style: {
+            marginLeft: "auto",
+            background: "none",
+            border: "none",
+            color: "#888",
+            cursor: "pointer",
+            fontSize: 10
+          },
+          children: "Clear all"
         }
-      }
-    },
-    scales: {
-      x: {
-        type: "time",
-        time: {
-          displayFormats: {
-            month: "MMM yyyy",
-            year: "yyyy"
+      )
+    ] }),
+    /* @__PURE__ */ jsxRuntimeExports.jsxs("div", { style: {
+      display: "flex",
+      alignItems: "center",
+      gap: 6,
+      padding: "3px 10px",
+      background: isLight ? "#f0f0f0" : "#12122a",
+      borderBottom: isLight ? "1px solid #ddd" : "1px solid #2a2a4a",
+      fontSize: 11,
+      flexShrink: 0
+    }, children: [
+      state.clickedPoints.length > 0 && /* @__PURE__ */ jsxRuntimeExports.jsxs(jsxRuntimeExports.Fragment, { children: [
+        /* @__PURE__ */ jsxRuntimeExports.jsx("span", { style: { color: "#888", fontSize: 10 }, children: "Date range:" }),
+        /* @__PURE__ */ jsxRuntimeExports.jsx(
+          "input",
+          {
+            type: "date",
+            value: dateStart,
+            onChange: (e2) => setDateStart(e2.target.value),
+            style: {
+              background: "#2a2a4a",
+              color: "#ccc",
+              border: "1px solid #444",
+              borderRadius: 3,
+              fontSize: 10,
+              padding: "1px 4px",
+              width: 110
+            }
           }
-        },
-        title: {
-          display: true,
-          text: "Time"
-        }
-      },
-      y: {
-        title: {
-          display: true,
-          text: "Displacement (m)"
-        },
-        suggestedMin: state.vmin,
-        suggestedMax: state.vmax
-      }
-    },
-    onClick: handleChartClick
-  };
-  if (!state.showChart) {
-    return null;
-  }
-  if (state.timeSeriesPoints.length === 0) {
-    return /* @__PURE__ */ jsxRuntimeExports.jsx("div", { id: "chart-container", children: /* @__PURE__ */ jsxRuntimeExports.jsxs("div", { className: "chart-placeholder", children: [
-      /* @__PURE__ */ jsxRuntimeExports.jsx("p", { children: "No time series points selected." }),
-      /* @__PURE__ */ jsxRuntimeExports.jsx("p", { children: /* @__PURE__ */ jsxRuntimeExports.jsx("small", { children: "Click on the map to add points." }) })
-    ] }) });
-  }
-  if (isLoading) {
-    return /* @__PURE__ */ jsxRuntimeExports.jsx("div", { id: "chart-container", children: /* @__PURE__ */ jsxRuntimeExports.jsx("div", { className: "chart-placeholder", children: /* @__PURE__ */ jsxRuntimeExports.jsx("p", { children: "Loading time series data..." }) }) });
-  }
-  if (!chartData || !chartData.datasets || chartData.datasets.length === 0) {
-    return /* @__PURE__ */ jsxRuntimeExports.jsx("div", { id: "chart-container", children: /* @__PURE__ */ jsxRuntimeExports.jsx("div", { className: "chart-placeholder", children: /* @__PURE__ */ jsxRuntimeExports.jsx("p", { children: "No data available for selected points." }) }) });
-  }
-  const formattedChartData = {
-    labels: chartData.labels,
-    datasets: chartData.datasets.map((dataset) => ({
-      label: dataset.label,
-      data: dataset.data,
-      borderColor: dataset.borderColor,
-      backgroundColor: dataset.backgroundColor,
-      borderWidth: 2,
-      pointRadius: 3,
-      pointHoverRadius: 5,
-      tension: 0.1,
-      fill: false
-    }))
-  };
-  return /* @__PURE__ */ jsxRuntimeExports.jsxs("div", { id: "chart-container", children: [
-    /* @__PURE__ */ jsxRuntimeExports.jsxs("div", { className: "chart-header", children: [
-      /* @__PURE__ */ jsxRuntimeExports.jsx("h4", { children: "Time Series Analysis" }),
-      /* @__PURE__ */ jsxRuntimeExports.jsxs("div", { className: "chart-controls", children: [
-        /* @__PURE__ */ jsxRuntimeExports.jsxs(
+        ),
+        /* @__PURE__ */ jsxRuntimeExports.jsx("span", { style: { color: "#666" }, children: "to" }),
+        /* @__PURE__ */ jsxRuntimeExports.jsx(
+          "input",
+          {
+            type: "date",
+            value: dateEnd,
+            onChange: (e2) => setDateEnd(e2.target.value),
+            style: {
+              background: "#2a2a4a",
+              color: "#ccc",
+              border: "1px solid #444",
+              borderRadius: 3,
+              fontSize: 10,
+              padding: "1px 4px",
+              width: 110
+            }
+          }
+        ),
+        (dateStart || dateEnd) && /* @__PURE__ */ jsxRuntimeExports.jsx(
           "button",
           {
-            className: "pure-button",
-            onClick: () => dispatch({ type: "TOGGLE_TRENDS" }),
-            title: "Toggle trend analysis",
-            children: [
-              /* @__PURE__ */ jsxRuntimeExports.jsx("i", { className: `fa-solid ${state.showTrends ? "fa-chart-line" : "fa-chart-simple"}` }),
-              state.showTrends ? "Hide" : "Show",
-              " Trends"
-            ]
+            onClick: () => {
+              setDateStart("");
+              setDateEnd("");
+            },
+            style: {
+              background: "none",
+              border: "none",
+              color: "#888",
+              cursor: "pointer",
+              fontSize: 10,
+              padding: 0
+            },
+            children: "reset"
           }
         ),
-        /* @__PURE__ */ jsxRuntimeExports.jsxs(
+        /* @__PURE__ */ jsxRuntimeExports.jsx(
           "button",
           {
-            className: "pure-button",
-            onClick: handleExportToCSV,
-            title: "Export data to CSV",
-            children: [
-              /* @__PURE__ */ jsxRuntimeExports.jsx("i", { className: "fa-solid fa-download" }),
-              "Export CSV"
-            ]
+            onClick: () => setShowTrends(!showTrends),
+            style: {
+              background: showTrends ? "#3a4a6a" : "#2a2a4a",
+              border: showTrends ? "1px solid #5566cc" : "1px solid #444",
+              color: showTrends ? "#aaf" : "#ccc",
+              cursor: "pointer",
+              fontSize: 11,
+              padding: "2px 6px",
+              borderRadius: 3
+            },
+            children: "Trend"
           }
         )
-      ] })
-    ] }),
-    /* @__PURE__ */ jsxRuntimeExports.jsx("div", { className: "chart-content", children: /* @__PURE__ */ jsxRuntimeExports.jsx(Line, { data: formattedChartData, options: chartOptions }) }),
-    /* @__PURE__ */ jsxRuntimeExports.jsx("div", { className: "chart-help", children: /* @__PURE__ */ jsxRuntimeExports.jsx("small", { children: "Click on chart points to sync map time • Trends show mm/year rates" }) })
-  ] });
-}
-function PointManagerPanel() {
-  const { state, dispatch } = useAppContext();
-  const [showPanel, setShowPanel] = reactExports.useState(false);
-  const handleTogglePointVisibility = (pointId) => {
-    const point = state.timeSeriesPoints.find((p2) => p2.id === pointId);
-    if (point) {
-      dispatch({
-        type: "UPDATE_TIME_SERIES_POINT",
-        payload: {
-          id: pointId,
-          updates: { visible: !point.visible }
-        }
-      });
-    }
-  };
-  const handlePointNameChange = (pointId, newName) => {
-    dispatch({
-      type: "UPDATE_TIME_SERIES_POINT",
-      payload: {
-        id: pointId,
-        updates: { name: newName }
-      }
-    });
-  };
-  const handleRemovePoint = (pointId) => {
-    dispatch({ type: "REMOVE_TIME_SERIES_POINT", payload: pointId });
-  };
-  const handleSelectPoint = (pointId) => {
-    dispatch({ type: "SET_SELECTED_POINT", payload: pointId });
-  };
-  const handleClearAllPoints = () => {
-    if (confirm("Remove all time series points?")) {
-      state.timeSeriesPoints.forEach((point) => {
-        dispatch({ type: "REMOVE_TIME_SERIES_POINT", payload: point.id });
-      });
-    }
-  };
-  const handleToggleTrends = () => {
-    dispatch({ type: "TOGGLE_TRENDS" });
-  };
-  if (!showPanel) {
-    return /* @__PURE__ */ jsxRuntimeExports.jsx("div", { className: "point-manager-toggle", children: /* @__PURE__ */ jsxRuntimeExports.jsxs(
-      "button",
-      {
-        className: "pure-button",
-        onClick: () => setShowPanel(true),
-        title: "Manage Time Series Points",
-        children: [
-          /* @__PURE__ */ jsxRuntimeExports.jsx("i", { className: "fa-solid fa-list" }),
-          " Points (",
-          state.timeSeriesPoints.length,
-          ")"
-        ]
-      }
-    ) });
-  }
-  return /* @__PURE__ */ jsxRuntimeExports.jsxs("div", { className: "point-manager-panel", children: [
-    /* @__PURE__ */ jsxRuntimeExports.jsxs("div", { className: "point-manager-header", children: [
-      /* @__PURE__ */ jsxRuntimeExports.jsxs("h3", { children: [
-        /* @__PURE__ */ jsxRuntimeExports.jsx("i", { className: "fa-solid fa-map-pin" }),
-        " Time Series Points"
       ] }),
       /* @__PURE__ */ jsxRuntimeExports.jsx(
         "button",
         {
-          className: "pure-button",
-          onClick: () => setShowPanel(false),
-          title: "Close Panel",
-          children: /* @__PURE__ */ jsxRuntimeExports.jsx("i", { className: "fa-solid fa-times" })
+          onClick: () => exportImage("png"),
+          style: {
+            background: isLight ? "#e8e8e8" : "#2a2a4a",
+            border: isLight ? "1px solid #ccc" : "1px solid #444",
+            color: isLight ? "#333" : "#ccc",
+            cursor: "pointer",
+            fontSize: 11,
+            padding: "2px 6px",
+            borderRadius: 3
+          },
+          title: "Export map + chart as PNG",
+          children: "PNG"
         }
-      )
-    ] }),
-    /* @__PURE__ */ jsxRuntimeExports.jsxs("div", { className: "point-manager-controls", children: [
-      /* @__PURE__ */ jsxRuntimeExports.jsxs(
+      ),
+      /* @__PURE__ */ jsxRuntimeExports.jsx(
         "button",
         {
-          className: "pure-button pure-button-primary",
-          onClick: handleToggleTrends,
-          title: "Toggle trend display",
-          children: [
-            /* @__PURE__ */ jsxRuntimeExports.jsx("i", { className: `fa-solid ${state.showTrends ? "fa-eye-slash" : "fa-eye"}` }),
-            state.showTrends ? "Hide" : "Show",
-            " Trends"
-          ]
+          onClick: () => exportImage("svg"),
+          style: {
+            background: isLight ? "#e8e8e8" : "#2a2a4a",
+            border: isLight ? "1px solid #ccc" : "1px solid #444",
+            color: isLight ? "#333" : "#ccc",
+            cursor: "pointer",
+            fontSize: 11,
+            padding: "2px 6px",
+            borderRadius: 3
+          },
+          title: "Export chart as SVG (vector, for publication)",
+          children: "SVG"
         }
       ),
-      state.timeSeriesPoints.length > 0 && /* @__PURE__ */ jsxRuntimeExports.jsxs(
+      /* @__PURE__ */ jsxRuntimeExports.jsx(
         "button",
         {
-          className: "pure-button button-warning",
-          onClick: handleClearAllPoints,
-          title: "Remove all points",
-          children: [
-            /* @__PURE__ */ jsxRuntimeExports.jsx("i", { className: "fa-solid fa-trash" }),
-            " Clear All"
-          ]
+          onClick: () => dispatch({ type: "SET_CHART_THEME", payload: isLight ? "dark" : "light" }),
+          style: {
+            background: isLight ? "#e8e8e8" : "#2a2a4a",
+            border: isLight ? "1px solid #ccc" : "1px solid #444",
+            color: isLight ? "#333" : "#ccc",
+            cursor: "pointer",
+            fontSize: 11,
+            padding: "2px 6px",
+            borderRadius: 3
+          },
+          title: "Toggle dark/light theme for publication",
+          children: isLight ? "Dark" : "Light"
+        }
+      ),
+      /* @__PURE__ */ jsxRuntimeExports.jsx(
+        "button",
+        {
+          onClick: () => {
+            dispatch({ type: "TOGGLE_CHART" });
+            dispatch({ type: "CLEAR_CLICKED_POINTS" });
+          },
+          style: {
+            marginLeft: "auto",
+            background: "transparent",
+            border: "none",
+            color: "#888",
+            cursor: "pointer",
+            fontSize: 14
+          },
+          children: "x"
         }
       )
     ] }),
-    /* @__PURE__ */ jsxRuntimeExports.jsx("div", { className: "point-list", children: state.timeSeriesPoints.length === 0 ? /* @__PURE__ */ jsxRuntimeExports.jsxs("div", { className: "no-points", children: [
-      /* @__PURE__ */ jsxRuntimeExports.jsx("p", { children: "No time series points selected." }),
-      /* @__PURE__ */ jsxRuntimeExports.jsx("p", { children: /* @__PURE__ */ jsxRuntimeExports.jsx("small", { children: "Click on the map to add points." }) })
-    ] }) : state.timeSeriesPoints.map((point) => {
-      var _a2;
-      return /* @__PURE__ */ jsxRuntimeExports.jsxs(
-        "div",
-        {
-          className: `point-item ${state.selectedPointId === point.id ? "selected" : ""}`,
-          onClick: () => handleSelectPoint(point.id),
-          children: [
-            /* @__PURE__ */ jsxRuntimeExports.jsxs("div", { className: "point-item-header", children: [
-              /* @__PURE__ */ jsxRuntimeExports.jsx(
-                "div",
-                {
-                  className: "point-color-indicator",
-                  style: { backgroundColor: point.color }
-                }
-              ),
+    /* @__PURE__ */ jsxRuntimeExports.jsx("div", { style: { flex: 1, minHeight: 0 }, children: /* @__PURE__ */ jsxRuntimeExports.jsx(
+      Plot,
+      {
+        data: traces,
+        layout: {
+          autosize: true,
+          margin: { l: 55, r: 15, t: 10, b: 40 },
+          paper_bgcolor: isLight ? "#ffffff" : "#1a1a2e",
+          plot_bgcolor: isLight ? "#f8f8f8" : "#16213e",
+          font: {
+            color: isLight ? "#333" : "#ccc",
+            size: isLight ? 13 : 11,
+            family: isLight ? '"Palatino Linotype", Palatino, "Book Antiqua", Georgia, serif' : "system-ui, sans-serif"
+          },
+          xaxis: {
+            gridcolor: isLight ? "#ddd" : "#2a3a5e",
+            linecolor: isLight ? "#999" : void 0,
+            title: { text: "Date" }
+          },
+          yaxis: {
+            gridcolor: isLight ? "#ddd" : "#2a3a5e",
+            linecolor: isLight ? "#999" : void 0,
+            title: { text: refLookup ? "Relative Displacement (mm)" : "Displacement (mm)" }
+          },
+          legend: {
+            bgcolor: isLight ? "rgba(255,255,255,0.8)" : "rgba(0,0,0,0.3)",
+            font: { size: 10 }
+          },
+          showlegend: traces.length > 1
+        },
+        config: {
+          displayModeBar: true,
+          modeBarButtonsToRemove: ["lasso2d", "select2d"],
+          displaylogo: false,
+          responsive: true
+        },
+        style: { width: "100%", height: "100%" },
+        useResizeHandler: true
+      }
+    ) })
+  ] });
+}
+const FILTER_OPERATORS = [">", "<", ">=", "<=", "="];
+const RASTER_COLORMAPS = [
+  { value: "rdbu_r", label: "Blue-Red" },
+  { value: "viridis", label: "Viridis" },
+  { value: "magma", label: "Magma" },
+  { value: "twilight", label: "Twilight (cyclic)" },
+  { value: "cfastie", label: "CFastie" },
+  { value: "rplumbo", label: "RPlumbo" },
+  { value: "schwarzwald", label: "Schwarzwald" },
+  { value: "bugn", label: "Blue-Green" },
+  { value: "ylgn", label: "Yellow-Green" },
+  { value: "gist_earth", label: "Earth" },
+  { value: "terrain", label: "Terrain" }
+];
+const inputStyle = {
+  width: "100%",
+  padding: "3px 5px",
+  background: "#2a2a4a",
+  color: "#ddd",
+  border: "1px solid #444",
+  borderRadius: 3,
+  fontSize: 12,
+  boxSizing: "border-box"
+};
+const selectStyle = {
+  ...inputStyle,
+  padding: "4px 6px"
+};
+const labelStyle = { fontSize: 11, color: "#aaa", display: "block", marginBottom: 2 };
+const sectionGap = { marginBottom: 10 };
+const basemapLabels = {
+  satellite: "Satellite",
+  osm: "OpenStreetMap",
+  dark: "Dark"
+};
+function MiniHistogram({ histogram, vmin, vmax, colormap }) {
+  const { edges, counts } = histogram;
+  const maxCount = Math.max(...counts, 1);
+  const nBins = counts.length;
+  const svgW = 220;
+  const svgH = 36;
+  const barW = svgW / nBins;
+  const bars = reactExports.useMemo(() => counts.map((count2, i2) => {
+    const midVal = (edges[i2] + edges[i2 + 1]) / 2;
+    const [r2, g2, b2] = valueToColor(midVal, vmin, vmax, colormap);
+    const h2 = count2 / maxCount * svgH;
+    return { x: i2 * barW, h: h2, fill: `rgb(${r2},${g2},${b2})` };
+  }), [counts, edges, vmin, vmax, colormap, maxCount, barW]);
+  return /* @__PURE__ */ jsxRuntimeExports.jsx("div", { style: { marginBottom: 6 }, children: /* @__PURE__ */ jsxRuntimeExports.jsx("svg", { width: svgW, height: svgH, style: { display: "block" }, children: bars.map((bar, i2) => /* @__PURE__ */ jsxRuntimeExports.jsx(
+    "rect",
+    {
+      x: bar.x,
+      y: svgH - bar.h,
+      width: Math.max(barW - 0.5, 1),
+      height: bar.h,
+      fill: bar.fill,
+      opacity: 0.8
+    },
+    i2
+  )) }) });
+}
+function PointControlsPanel() {
+  const { state, dispatch } = useAppContext();
+  const [draftVmin, setDraftVmin] = reactExports.useState(String(state.pointVmin));
+  const [draftVmax, setDraftVmax] = reactExports.useState(String(state.pointVmax));
+  const [exportWithTs, setExportWithTs] = reactExports.useState(false);
+  const [draftRasterVmin, setDraftRasterVmin] = reactExports.useState(String(state.vmin));
+  const [draftRasterVmax, setDraftRasterVmax] = reactExports.useState(String(state.vmax));
+  reactExports.useEffect(() => {
+    const ds = state.currentDataset;
+    if (!ds) return;
+    localStorage.setItem(`${ds}-colormap_name`, state.colormap);
+    localStorage.setItem(`${ds}-vmin`, String(state.vmin));
+    localStorage.setItem(`${ds}-vmax`, String(state.vmax));
+  }, [state.colormap, state.vmin, state.vmax, state.currentDataset]);
+  reactExports.useEffect(() => {
+    const ds = state.currentDataset;
+    if (!ds) return;
+    const cmap = localStorage.getItem(`${ds}-colormap_name`);
+    const vminStr = localStorage.getItem(`${ds}-vmin`);
+    const vmaxStr = localStorage.getItem(`${ds}-vmax`);
+    if (cmap) dispatch({ type: "SET_COLORMAP", payload: cmap });
+    if (vminStr) {
+      const v2 = Number(vminStr);
+      if (!isNaN(v2)) {
+        dispatch({ type: "SET_VMIN", payload: v2 });
+        setDraftRasterVmin(vminStr);
+      }
+    }
+    if (vmaxStr) {
+      const v2 = Number(vmaxStr);
+      if (!isNaN(v2)) {
+        dispatch({ type: "SET_VMAX", payload: v2 });
+        setDraftRasterVmax(vmaxStr);
+      }
+    }
+  }, [state.currentDataset, dispatch]);
+  const [filterAttr, setFilterAttr] = reactExports.useState("");
+  const [filterOp, setFilterOp] = reactExports.useState(">");
+  const [filterVal, setFilterVal] = reactExports.useState("");
+  const [activeFilters, setActiveFilters] = reactExports.useState([]);
+  const filterInputRef = reactExports.useRef(null);
+  const numericAttrs = Object.entries(state.pointAttributes).filter(
+    ([name2, info]) => name2 !== "geometry" && name2 !== "point_id" && name2 !== "longitude" && name2 !== "latitude" && (info.type.includes("FLOAT") || info.type.includes("DOUBLE") || info.type.includes("INT"))
+  );
+  const handleColorByChange = (value) => {
+    dispatch({ type: "SET_POINT_COLOR_BY", payload: value });
+    const attr = state.pointAttributes[value];
+    if ((attr == null ? void 0 : attr.min) != null && (attr == null ? void 0 : attr.max) != null) {
+      if (value.includes("velocity")) {
+        const absMax = Math.max(Math.abs(attr.min), Math.abs(attr.max));
+        dispatch({ type: "SET_POINT_VMIN", payload: -absMax });
+        dispatch({ type: "SET_POINT_VMAX", payload: absMax });
+        setDraftVmin((-absMax).toFixed(2));
+        setDraftVmax(absMax.toFixed(2));
+      } else {
+        dispatch({ type: "SET_POINT_VMIN", payload: attr.min });
+        dispatch({ type: "SET_POINT_VMAX", payload: attr.max });
+        setDraftVmin(attr.min.toFixed(2));
+        setDraftVmax(attr.max.toFixed(2));
+      }
+    }
+  };
+  const commitVmin = () => {
+    const v2 = parseFloat(draftVmin);
+    if (!isNaN(v2)) dispatch({ type: "SET_POINT_VMIN", payload: v2 });
+  };
+  const commitVmax = () => {
+    const v2 = parseFloat(draftVmax);
+    if (!isNaN(v2)) dispatch({ type: "SET_POINT_VMAX", payload: v2 });
+  };
+  const addFilter = () => {
+    var _a3;
+    if (!effectiveFilterAttr || !filterVal) return;
+    const v2 = parseFloat(filterVal);
+    if (isNaN(v2)) return;
+    const expr = `${effectiveFilterAttr}${filterOp}${v2}`;
+    const next = [...activeFilters, expr];
+    setActiveFilters(next);
+    dispatch({ type: "SET_POINT_FILTER", payload: next.join(" AND ") });
+    setFilterVal("");
+    (_a3 = filterInputRef.current) == null ? void 0 : _a3.focus();
+  };
+  const removeFilter = (index) => {
+    const next = activeFilters.filter((_2, i2) => i2 !== index);
+    setActiveFilters(next);
+    dispatch({ type: "SET_POINT_FILTER", payload: next.join(" AND ") });
+  };
+  const clearFilters = () => {
+    setActiveFilters([]);
+    dispatch({ type: "SET_POINT_FILTER", payload: "" });
+  };
+  const currentAttr = state.pointAttributes[state.pointColorBy];
+  const pointCount = currentAttr == null ? void 0 : currentAttr.count;
+  const hasPoints = state.activePointLayer != null;
+  const hasRasters = Object.keys(state.datasetInfo).length > 0;
+  const effectiveFilterAttr = filterAttr || (numericAttrs.length > 0 ? numericAttrs[0][0] : "");
+  return /* @__PURE__ */ jsxRuntimeExports.jsxs("div", { style: {
+    position: "absolute",
+    top: 10,
+    left: 10,
+    zIndex: 100,
+    background: "rgba(20, 20, 40, 0.92)",
+    color: "#ddd",
+    borderRadius: 6,
+    padding: "10px 14px",
+    fontSize: 13,
+    fontFamily: "system-ui, sans-serif",
+    minWidth: 240,
+    maxWidth: 280,
+    backdropFilter: "blur(8px)",
+    border: "1px solid rgba(255,255,255,0.1)",
+    maxHeight: "calc(100vh - 40px)",
+    overflowY: "auto"
+  }, children: [
+    /* @__PURE__ */ jsxRuntimeExports.jsx("div", { style: { fontWeight: 600, marginBottom: 8, fontSize: 14 }, children: "Layers" }),
+    /* @__PURE__ */ jsxRuntimeExports.jsxs("div", { style: sectionGap, children: [
+      hasPoints && /* @__PURE__ */ jsxRuntimeExports.jsxs("label", { style: { display: "flex", alignItems: "center", gap: 6, fontSize: 12, cursor: "pointer", marginBottom: 4 }, children: [
+        /* @__PURE__ */ jsxRuntimeExports.jsx(
+          "input",
+          {
+            type: "checkbox",
+            checked: state.pointLayerVisible,
+            onChange: (e2) => dispatch({ type: "SET_POINT_LAYER_VISIBLE", payload: e2.target.checked }),
+            style: { accentColor: "#5566cc" }
+          }
+        ),
+        /* @__PURE__ */ jsxRuntimeExports.jsx("span", { children: "Points" }),
+        pointCount != null && /* @__PURE__ */ jsxRuntimeExports.jsxs("span", { style: { color: "#999", fontSize: 11 }, children: [
+          "(",
+          pointCount.toLocaleString(),
+          ")"
+        ] })
+      ] }),
+      hasRasters && /* @__PURE__ */ jsxRuntimeExports.jsxs(jsxRuntimeExports.Fragment, { children: [
+        /* @__PURE__ */ jsxRuntimeExports.jsxs("label", { style: { display: "flex", alignItems: "center", gap: 6, fontSize: 12, cursor: "pointer", marginBottom: 4 }, children: [
+          /* @__PURE__ */ jsxRuntimeExports.jsx(
+            "input",
+            {
+              type: "checkbox",
+              checked: state.rasterLayerVisible,
+              onChange: (e2) => dispatch({ type: "SET_RASTER_LAYER_VISIBLE", payload: e2.target.checked }),
+              style: { accentColor: "#5566cc" }
+            }
+          ),
+          /* @__PURE__ */ jsxRuntimeExports.jsx("span", { children: "Raster" })
+        ] }),
+        state.rasterLayerVisible && /* @__PURE__ */ jsxRuntimeExports.jsxs("div", { style: { paddingLeft: 20, marginBottom: 4 }, children: [
+          /* @__PURE__ */ jsxRuntimeExports.jsx(
+            "select",
+            {
+              value: state.currentDataset,
+              onChange: (e2) => dispatch({ type: "SET_CURRENT_DATASET", payload: e2.target.value }),
+              style: { ...selectStyle, marginBottom: 4 },
+              children: Object.keys(state.datasetInfo).map((name2) => /* @__PURE__ */ jsxRuntimeExports.jsx("option", { value: name2, children: name2 }, name2))
+            }
+          ),
+          state.datasetInfo[state.currentDataset] && /* @__PURE__ */ jsxRuntimeExports.jsxs("div", { style: { marginBottom: 4 }, children: [
+            /* @__PURE__ */ jsxRuntimeExports.jsxs("label", { style: { ...labelStyle, display: "flex", justifyContent: "space-between" }, children: [
+              /* @__PURE__ */ jsxRuntimeExports.jsx("span", { children: "Time" }),
+              /* @__PURE__ */ jsxRuntimeExports.jsx("span", { style: { fontSize: 10 }, children: state.datasetInfo[state.currentDataset].x_values[state.currentTimeIndex] })
+            ] }),
+            /* @__PURE__ */ jsxRuntimeExports.jsx(
+              "input",
+              {
+                type: "range",
+                min: "0",
+                max: state.datasetInfo[state.currentDataset].x_values.length - 1,
+                step: "1",
+                value: state.currentTimeIndex,
+                onChange: (e2) => dispatch({ type: "SET_TIME_INDEX", payload: parseInt(e2.target.value) }),
+                style: { width: "100%" }
+              }
+            )
+          ] }),
+          /* @__PURE__ */ jsxRuntimeExports.jsxs("div", { style: { marginBottom: 4 }, children: [
+            /* @__PURE__ */ jsxRuntimeExports.jsx("label", { style: labelStyle, children: "Colormap" }),
+            /* @__PURE__ */ jsxRuntimeExports.jsx(
+              "select",
+              {
+                value: state.colormap,
+                onChange: (e2) => dispatch({ type: "SET_COLORMAP", payload: e2.target.value }),
+                style: selectStyle,
+                children: RASTER_COLORMAPS.map((opt) => /* @__PURE__ */ jsxRuntimeExports.jsx("option", { value: opt.value, children: opt.label }, opt.value))
+              }
+            ),
+            /* @__PURE__ */ jsxRuntimeExports.jsx(
+              "img",
+              {
+                src: `/colorbar/${state.colormap}`,
+                style: { width: "100%", height: 12, borderRadius: 2, marginTop: 2 },
+                alt: "Raster colorbar"
+              }
+            )
+          ] }),
+          /* @__PURE__ */ jsxRuntimeExports.jsxs("div", { style: { display: "flex", gap: 6, marginBottom: 4 }, children: [
+            /* @__PURE__ */ jsxRuntimeExports.jsxs("div", { style: { flex: 1 }, children: [
+              /* @__PURE__ */ jsxRuntimeExports.jsx("label", { style: labelStyle, children: "Min" }),
               /* @__PURE__ */ jsxRuntimeExports.jsx(
                 "input",
                 {
-                  type: "text",
-                  value: point.name,
-                  onChange: (e) => handlePointNameChange(point.id, e.target.value),
-                  className: "point-name-input",
-                  onClick: (e) => e.stopPropagation()
+                  type: "number",
+                  step: "any",
+                  value: draftRasterVmin,
+                  onChange: (e2) => setDraftRasterVmin(e2.target.value),
+                  onBlur: () => {
+                    const v2 = parseFloat(draftRasterVmin);
+                    if (!isNaN(v2)) dispatch({ type: "SET_VMIN", payload: v2 });
+                  },
+                  onKeyDown: (e2) => {
+                    if (e2.key === "Enter") {
+                      const v2 = parseFloat(draftRasterVmin);
+                      if (!isNaN(v2)) dispatch({ type: "SET_VMIN", payload: v2 });
+                    }
+                  },
+                  style: inputStyle
                 }
               )
             ] }),
-            /* @__PURE__ */ jsxRuntimeExports.jsxs("div", { className: "point-item-info", children: [
-              /* @__PURE__ */ jsxRuntimeExports.jsx("div", { className: "point-coordinates", children: /* @__PURE__ */ jsxRuntimeExports.jsxs("small", { children: [
-                "Lat: ",
-                point.position[0].toFixed(6),
-                ", Lon: ",
-                point.position[1].toFixed(6)
-              ] }) }),
-              state.showTrends && point.trendData && point.trendData[state.currentDataset] && /* @__PURE__ */ jsxRuntimeExports.jsx("div", { className: "point-trend-info", children: /* @__PURE__ */ jsxRuntimeExports.jsxs("small", { children: [
-                "Rate: ",
-                ((_a2 = point.trendData[state.currentDataset].mmPerYear) == null ? void 0 : _a2.toFixed(2)) || "N/A",
-                " mm/year (R²: ",
-                point.trendData[state.currentDataset].rSquared.toFixed(3),
-                ")"
-              ] }) })
-            ] }),
-            /* @__PURE__ */ jsxRuntimeExports.jsxs("div", { className: "point-item-controls", children: [
+            /* @__PURE__ */ jsxRuntimeExports.jsxs("div", { style: { flex: 1 }, children: [
+              /* @__PURE__ */ jsxRuntimeExports.jsx("label", { style: labelStyle, children: "Max" }),
               /* @__PURE__ */ jsxRuntimeExports.jsx(
-                "button",
+                "input",
                 {
-                  onClick: (e) => {
-                    e.stopPropagation();
-                    handleTogglePointVisibility(point.id);
+                  type: "number",
+                  step: "any",
+                  value: draftRasterVmax,
+                  onChange: (e2) => setDraftRasterVmax(e2.target.value),
+                  onBlur: () => {
+                    const v2 = parseFloat(draftRasterVmax);
+                    if (!isNaN(v2)) dispatch({ type: "SET_VMAX", payload: v2 });
                   },
-                  className: "pure-button",
-                  title: point.visible ? "Hide point" : "Show point",
-                  children: /* @__PURE__ */ jsxRuntimeExports.jsx("i", { className: `fa-solid ${point.visible ? "fa-eye" : "fa-eye-slash"}` })
-                }
-              ),
-              /* @__PURE__ */ jsxRuntimeExports.jsx(
-                "button",
-                {
-                  onClick: (e) => {
-                    e.stopPropagation();
-                    handleRemovePoint(point.id);
+                  onKeyDown: (e2) => {
+                    if (e2.key === "Enter") {
+                      const v2 = parseFloat(draftRasterVmax);
+                      if (!isNaN(v2)) dispatch({ type: "SET_VMAX", payload: v2 });
+                    }
                   },
-                  className: "pure-button button-error",
-                  title: "Remove point",
-                  children: /* @__PURE__ */ jsxRuntimeExports.jsx("i", { className: "fa-solid fa-trash" })
+                  style: inputStyle
                 }
               )
             ] })
-          ]
+          ] }),
+          /* @__PURE__ */ jsxRuntimeExports.jsxs("div", { style: { marginBottom: 4 }, children: [
+            /* @__PURE__ */ jsxRuntimeExports.jsxs("label", { style: { ...labelStyle, display: "flex", justifyContent: "space-between" }, children: [
+              /* @__PURE__ */ jsxRuntimeExports.jsx("span", { children: "Opacity" }),
+              /* @__PURE__ */ jsxRuntimeExports.jsx("span", { children: state.opacity.toFixed(2) })
+            ] }),
+            /* @__PURE__ */ jsxRuntimeExports.jsx(
+              "input",
+              {
+                type: "range",
+                min: "0",
+                max: "1",
+                step: "0.05",
+                value: state.opacity,
+                onChange: (e2) => dispatch({ type: "SET_OPACITY", payload: parseFloat(e2.target.value) }),
+                style: { width: "100%" }
+              }
+            )
+          ] }),
+          /* @__PURE__ */ jsxRuntimeExports.jsx(
+            "button",
+            {
+              onClick: () => dispatch({ type: "TOGGLE_CHART" }),
+              style: {
+                width: "100%",
+                padding: "4px 8px",
+                fontSize: 11,
+                cursor: "pointer",
+                background: state.showChart ? "#5566cc" : "#2a2a4a",
+                color: state.showChart ? "#fff" : "#ccc",
+                border: "1px solid #444",
+                borderRadius: 3
+              },
+              children: state.showChart ? "Hide time series" : "Show time series"
+            }
+          )
+        ] })
+      ] }),
+      hasPoints && state.pointLayerVisible && /* @__PURE__ */ jsxRuntimeExports.jsxs("div", { style: { marginTop: 4 }, children: [
+        /* @__PURE__ */ jsxRuntimeExports.jsxs("label", { style: { ...labelStyle, display: "flex", justifyContent: "space-between" }, children: [
+          /* @__PURE__ */ jsxRuntimeExports.jsx("span", { children: "Point opacity" }),
+          /* @__PURE__ */ jsxRuntimeExports.jsx("span", { children: state.pointOpacity.toFixed(2) })
+        ] }),
+        /* @__PURE__ */ jsxRuntimeExports.jsx(
+          "input",
+          {
+            type: "range",
+            min: "0",
+            max: "1",
+            step: "0.05",
+            value: state.pointOpacity,
+            onChange: (e2) => dispatch({ type: "SET_POINT_OPACITY", payload: parseFloat(e2.target.value) }),
+            style: { width: "100%" }
+          }
+        )
+      ] }),
+      state.gpsLosInfo && /* @__PURE__ */ jsxRuntimeExports.jsxs(jsxRuntimeExports.Fragment, { children: [
+        /* @__PURE__ */ jsxRuntimeExports.jsxs("label", { style: { display: "flex", alignItems: "center", gap: 6, fontSize: 12, cursor: "pointer", marginBottom: 4 }, children: [
+          /* @__PURE__ */ jsxRuntimeExports.jsx(
+            "input",
+            {
+              type: "checkbox",
+              checked: state.gpsVisible,
+              onChange: (e2) => dispatch({ type: "SET_GPS_VISIBLE", payload: e2.target.checked }),
+              style: { accentColor: "#22aa66" }
+            }
+          ),
+          /* @__PURE__ */ jsxRuntimeExports.jsx("span", { children: "GPS stations" }),
+          state.gpsLoading && /* @__PURE__ */ jsxRuntimeExports.jsx("span", { style: { color: "#888", fontSize: 10 }, children: "loading..." }),
+          !state.gpsLoading && state.gpsStations.length > 0 && /* @__PURE__ */ jsxRuntimeExports.jsxs("span", { style: { color: "#999", fontSize: 11 }, children: [
+            "(",
+            state.gpsStations.length,
+            ")"
+          ] })
+        ] }),
+        state.gpsVisible && state.gpsTimeseries.length > 0 && /* @__PURE__ */ jsxRuntimeExports.jsxs("div", { style: { paddingLeft: 20, marginBottom: 4 }, children: [
+          /* @__PURE__ */ jsxRuntimeExports.jsx("label", { style: labelStyle, children: "Component" }),
+          /* @__PURE__ */ jsxRuntimeExports.jsx("div", { style: { display: "flex", gap: 3 }, children: ["los", "east", "north", "up"].map((comp) => /* @__PURE__ */ jsxRuntimeExports.jsx(
+            "button",
+            {
+              onClick: () => dispatch({ type: "SET_GPS_COMPONENT", payload: comp }),
+              style: {
+                flex: 1,
+                padding: "2px 4px",
+                fontSize: 10,
+                cursor: "pointer",
+                background: state.gpsComponent === comp ? "#2a6a4a" : "#2a2a4a",
+                color: state.gpsComponent === comp ? "#afa" : "#aaa",
+                border: state.gpsComponent === comp ? "1px solid #4a8a6a" : "1px solid #444",
+                borderRadius: 3,
+                textTransform: "uppercase"
+              },
+              children: comp
+            },
+            comp
+          )) })
+        ] })
+      ] })
+    ] }),
+    /* @__PURE__ */ jsxRuntimeExports.jsx("div", { style: { borderTop: "1px solid rgba(255,255,255,0.08)", margin: "8px 0" } }),
+    /* @__PURE__ */ jsxRuntimeExports.jsxs("div", { style: sectionGap, children: [
+      /* @__PURE__ */ jsxRuntimeExports.jsx("label", { style: labelStyle, children: "Basemap" }),
+      /* @__PURE__ */ jsxRuntimeExports.jsx("div", { style: { display: "flex", gap: 4 }, children: ["satellite", "osm", "dark"].map((key) => /* @__PURE__ */ jsxRuntimeExports.jsx(
+        "button",
+        {
+          onClick: () => dispatch({ type: "SET_POINT_BASEMAP", payload: key }),
+          style: {
+            flex: 1,
+            padding: "3px 6px",
+            fontSize: 11,
+            background: state.pointBasemap === key ? "#5566cc" : "#2a2a4a",
+            color: state.pointBasemap === key ? "#fff" : "#aaa",
+            border: state.pointBasemap === key ? "1px solid #7788ee" : "1px solid #444",
+            borderRadius: 3,
+            cursor: "pointer"
+          },
+          children: basemapLabels[key]
         },
-        point.id
-      );
-    }) }),
-    /* @__PURE__ */ jsxRuntimeExports.jsx("div", { className: "point-manager-help", children: /* @__PURE__ */ jsxRuntimeExports.jsxs("small", { children: [
-      "• Click map to add points",
-      /* @__PURE__ */ jsxRuntimeExports.jsx("br", {}),
-      "• Double-click markers to remove",
-      /* @__PURE__ */ jsxRuntimeExports.jsx("br", {}),
-      "• Drag markers to move"
-    ] }) })
+        key
+      )) })
+    ] }),
+    hasPoints && /* @__PURE__ */ jsxRuntimeExports.jsxs(jsxRuntimeExports.Fragment, { children: [
+      /* @__PURE__ */ jsxRuntimeExports.jsx("div", { style: { borderTop: "1px solid rgba(255,255,255,0.08)", margin: "8px 0" } }),
+      /* @__PURE__ */ jsxRuntimeExports.jsxs("div", { style: sectionGap, children: [
+        /* @__PURE__ */ jsxRuntimeExports.jsx("label", { style: labelStyle, children: "Color by" }),
+        /* @__PURE__ */ jsxRuntimeExports.jsx(
+          "select",
+          {
+            value: state.pointColorBy,
+            onChange: (e2) => handleColorByChange(e2.target.value),
+            style: selectStyle,
+            children: numericAttrs.map(([name2, info]) => /* @__PURE__ */ jsxRuntimeExports.jsxs("option", { value: name2, children: [
+              name2,
+              info.min != null ? ` [${info.min.toFixed(2)}, ${info.max.toFixed(2)}]` : ""
+            ] }, name2))
+          }
+        )
+      ] }),
+      /* @__PURE__ */ jsxRuntimeExports.jsxs("div", { style: sectionGap, children: [
+        /* @__PURE__ */ jsxRuntimeExports.jsx("label", { style: labelStyle, children: "Colormap" }),
+        /* @__PURE__ */ jsxRuntimeExports.jsx(
+          "select",
+          {
+            value: state.pointColormap,
+            onChange: (e2) => dispatch({ type: "SET_POINT_COLORMAP", payload: e2.target.value }),
+            style: selectStyle,
+            children: COLORMAP_NAMES.map((name2) => /* @__PURE__ */ jsxRuntimeExports.jsx("option", { value: name2, children: name2 }, name2))
+          }
+        )
+      ] }),
+      /* @__PURE__ */ jsxRuntimeExports.jsxs("div", { style: { marginBottom: 8 }, children: [
+        /* @__PURE__ */ jsxRuntimeExports.jsx("div", { style: {
+          height: 12,
+          borderRadius: 2,
+          background: colormapGradientCSS(state.pointColormap)
+        } }),
+        /* @__PURE__ */ jsxRuntimeExports.jsxs("div", { style: { display: "flex", justifyContent: "space-between", fontSize: 10, color: "#999", marginTop: 2 }, children: [
+          /* @__PURE__ */ jsxRuntimeExports.jsx("span", { children: state.pointVmin.toFixed(1) }),
+          /* @__PURE__ */ jsxRuntimeExports.jsx("span", { children: ((state.pointVmin + state.pointVmax) / 2).toFixed(1) }),
+          /* @__PURE__ */ jsxRuntimeExports.jsx("span", { children: state.pointVmax.toFixed(1) })
+        ] })
+      ] }),
+      state.pointHistogram && /* @__PURE__ */ jsxRuntimeExports.jsx(
+        MiniHistogram,
+        {
+          histogram: state.pointHistogram,
+          vmin: state.pointVmin,
+          vmax: state.pointVmax,
+          colormap: state.pointColormap
+        }
+      ),
+      /* @__PURE__ */ jsxRuntimeExports.jsxs("div", { style: { display: "flex", gap: 8, ...sectionGap }, children: [
+        /* @__PURE__ */ jsxRuntimeExports.jsxs("div", { style: { flex: 1 }, children: [
+          /* @__PURE__ */ jsxRuntimeExports.jsx("label", { style: labelStyle, children: "Min" }),
+          /* @__PURE__ */ jsxRuntimeExports.jsx(
+            "input",
+            {
+              type: "number",
+              step: "any",
+              value: draftVmin,
+              onChange: (e2) => setDraftVmin(e2.target.value),
+              onBlur: commitVmin,
+              onKeyDown: (e2) => e2.key === "Enter" && commitVmin(),
+              style: inputStyle
+            }
+          )
+        ] }),
+        /* @__PURE__ */ jsxRuntimeExports.jsxs("div", { style: { flex: 1 }, children: [
+          /* @__PURE__ */ jsxRuntimeExports.jsx("label", { style: labelStyle, children: "Max" }),
+          /* @__PURE__ */ jsxRuntimeExports.jsx(
+            "input",
+            {
+              type: "number",
+              step: "any",
+              value: draftVmax,
+              onChange: (e2) => setDraftVmax(e2.target.value),
+              onBlur: commitVmax,
+              onKeyDown: (e2) => e2.key === "Enter" && commitVmax(),
+              style: inputStyle
+            }
+          )
+        ] })
+      ] }),
+      (currentAttr == null ? void 0 : currentAttr.mean) != null && /* @__PURE__ */ jsxRuntimeExports.jsxs("div", { style: { fontSize: 11, color: "#888", marginBottom: 6 }, children: [
+        "mean: ",
+        currentAttr.mean.toFixed(3)
+      ] }),
+      /* @__PURE__ */ jsxRuntimeExports.jsx("div", { style: { borderTop: "1px solid rgba(255,255,255,0.08)", margin: "8px 0" } }),
+      /* @__PURE__ */ jsxRuntimeExports.jsxs("div", { children: [
+        /* @__PURE__ */ jsxRuntimeExports.jsx("label", { style: labelStyle, children: "Filter" }),
+        /* @__PURE__ */ jsxRuntimeExports.jsxs("div", { style: { display: "flex", gap: 4, marginBottom: 6 }, children: [
+          /* @__PURE__ */ jsxRuntimeExports.jsx(
+            "select",
+            {
+              value: effectiveFilterAttr,
+              onChange: (e2) => setFilterAttr(e2.target.value),
+              style: { ...selectStyle, flex: 3 },
+              children: numericAttrs.map(([name2]) => /* @__PURE__ */ jsxRuntimeExports.jsx("option", { value: name2, children: name2 }, name2))
+            }
+          ),
+          /* @__PURE__ */ jsxRuntimeExports.jsx(
+            "select",
+            {
+              value: filterOp,
+              onChange: (e2) => setFilterOp(e2.target.value),
+              style: { ...selectStyle, flex: 1, textAlign: "center" },
+              children: FILTER_OPERATORS.map((op) => /* @__PURE__ */ jsxRuntimeExports.jsx("option", { value: op, children: op }, op))
+            }
+          ),
+          /* @__PURE__ */ jsxRuntimeExports.jsx(
+            "input",
+            {
+              ref: filterInputRef,
+              type: "number",
+              step: "any",
+              placeholder: "val",
+              value: filterVal,
+              onChange: (e2) => setFilterVal(e2.target.value),
+              onKeyDown: (e2) => e2.key === "Enter" && addFilter(),
+              style: { ...inputStyle, flex: 2 }
+            }
+          ),
+          /* @__PURE__ */ jsxRuntimeExports.jsx(
+            "button",
+            {
+              onClick: addFilter,
+              style: {
+                padding: "3px 8px",
+                fontSize: 12,
+                cursor: "pointer",
+                background: "#3a5a3a",
+                color: "#cfc",
+                border: "1px solid #4a7a4a",
+                borderRadius: 3
+              },
+              children: "+"
+            }
+          )
+        ] }),
+        activeFilters.length > 0 && /* @__PURE__ */ jsxRuntimeExports.jsxs("div", { style: { marginBottom: 4 }, children: [
+          activeFilters.map((f2, i2) => /* @__PURE__ */ jsxRuntimeExports.jsxs(
+            "div",
+            {
+              style: {
+                display: "flex",
+                justifyContent: "space-between",
+                alignItems: "center",
+                background: "#1a2a3a",
+                padding: "2px 6px",
+                borderRadius: 3,
+                marginBottom: 2,
+                fontSize: 11,
+                fontFamily: "monospace"
+              },
+              children: [
+                /* @__PURE__ */ jsxRuntimeExports.jsx("span", { style: { color: "#8cf" }, children: f2 }),
+                /* @__PURE__ */ jsxRuntimeExports.jsx(
+                  "button",
+                  {
+                    onClick: () => removeFilter(i2),
+                    style: {
+                      background: "none",
+                      border: "none",
+                      color: "#f88",
+                      cursor: "pointer",
+                      fontSize: 12,
+                      padding: "0 2px"
+                    },
+                    children: "x"
+                  }
+                )
+              ]
+            },
+            i2
+          )),
+          /* @__PURE__ */ jsxRuntimeExports.jsx(
+            "button",
+            {
+              onClick: clearFilters,
+              style: {
+                background: "none",
+                border: "none",
+                color: "#888",
+                cursor: "pointer",
+                fontSize: 10,
+                padding: "2px 0"
+              },
+              children: "Clear all filters"
+            }
+          )
+        ] })
+      ] }),
+      /* @__PURE__ */ jsxRuntimeExports.jsx("div", { style: { borderTop: "1px solid rgba(255,255,255,0.08)", margin: "8px 0" } }),
+      /* @__PURE__ */ jsxRuntimeExports.jsxs("div", { children: [
+        /* @__PURE__ */ jsxRuntimeExports.jsx("label", { style: labelStyle, children: "Export" }),
+        /* @__PURE__ */ jsxRuntimeExports.jsxs("label", { style: { display: "flex", alignItems: "center", gap: 6, fontSize: 11, cursor: "pointer", marginBottom: 4 }, children: [
+          /* @__PURE__ */ jsxRuntimeExports.jsx(
+            "input",
+            {
+              type: "checkbox",
+              checked: exportWithTs,
+              onChange: (e2) => setExportWithTs(e2.target.checked),
+              style: { accentColor: "#5566cc" }
+            }
+          ),
+          /* @__PURE__ */ jsxRuntimeExports.jsx("span", { style: { color: "#aaa" }, children: "Include timeseries" })
+        ] }),
+        /* @__PURE__ */ jsxRuntimeExports.jsx("div", { style: { display: "flex", gap: 4 }, children: ["csv", "geojson", "parquet"].map((fmt) => /* @__PURE__ */ jsxRuntimeExports.jsx(
+          "button",
+          {
+            onClick: () => {
+              const params = new URLSearchParams();
+              params.set("format", fmt);
+              if (state.pointFilter) params.set("filter", state.pointFilter);
+              if (exportWithTs) params.set("include_timeseries", "true");
+              window.open(`/points/${state.activePointLayer}/export?${params}`, "_blank");
+            },
+            style: {
+              flex: 1,
+              padding: "4px 6px",
+              fontSize: 11,
+              cursor: "pointer",
+              background: "#2a2a4a",
+              color: "#ccc",
+              border: "1px solid #444",
+              borderRadius: 3
+            },
+            children: fmt.toUpperCase()
+          },
+          fmt
+        )) })
+      ] })
+    ] })
   ] });
 }
 function AppContent() {
   const { state, dispatch } = useAppContext();
   const { fetchDatasets, fetchDataMode } = useApi();
+  const { fetchPointLayers, fetchPointAttributes } = usePointsApi();
+  const { fetchLosInfo } = useGpsApi();
+  const urlStateRef = reactExports.useRef(parseUrlState());
+  useUrlStateSync();
   reactExports.useEffect(() => {
     const initializeApp = async () => {
       try {
-        const mode = await fetchDataMode();
-        dispatch({ type: "SET_DATA_MODE", payload: mode });
-        const datasets = await fetchDatasets();
-        dispatch({ type: "SET_DATASETS", payload: datasets });
-        const firstDataset = Object.keys(datasets)[0];
-        if (firstDataset) {
-          dispatch({ type: "SET_CURRENT_DATASET", payload: firstDataset });
-          const bounds = datasets[firstDataset].latlon_bounds;
-          const centerLat = (bounds[1] + bounds[3]) / 2;
-          const centerLng = (bounds[0] + bounds[2]) / 2;
-          dispatch({ type: "SET_REF_MARKER_POSITION", payload: [centerLat, centerLng] });
+        let hasPointLayers = false;
+        try {
+          const pointLayers = await fetchPointLayers();
+          const layerNames = Object.keys(pointLayers);
+          if (layerNames.length > 0) {
+            hasPointLayers = true;
+            const firstLayer = layerNames[0];
+            dispatch({ type: "SET_ACTIVE_POINT_LAYER", payload: firstLayer });
+            const attrs = await fetchPointAttributes(firstLayer);
+            dispatch({ type: "SET_POINT_ATTRIBUTES", payload: attrs.attributes });
+            const lonAttr = attrs.attributes.longitude;
+            const latAttr = attrs.attributes.latitude;
+            if ((lonAttr == null ? void 0 : lonAttr.min) != null && (lonAttr == null ? void 0 : lonAttr.max) != null && (latAttr == null ? void 0 : latAttr.min) != null && (latAttr == null ? void 0 : latAttr.max) != null) {
+              dispatch({
+                type: "SET_POINT_LAYER_BOUNDS",
+                payload: [lonAttr.min, latAttr.min, lonAttr.max, latAttr.max]
+              });
+            }
+            const defaultColorBy = pointLayers[firstLayer].default_color_by || "velocity";
+            dispatch({ type: "SET_POINT_COLOR_BY", payload: defaultColorBy });
+            const colorAttr = attrs.attributes[defaultColorBy];
+            if ((colorAttr == null ? void 0 : colorAttr.min) != null && (colorAttr == null ? void 0 : colorAttr.max) != null) {
+              if (defaultColorBy.includes("velocity")) {
+                const absMax = Math.max(Math.abs(colorAttr.min), Math.abs(colorAttr.max));
+                dispatch({ type: "SET_POINT_VMIN", payload: -absMax });
+                dispatch({ type: "SET_POINT_VMAX", payload: absMax });
+              } else {
+                dispatch({ type: "SET_POINT_VMIN", payload: colorAttr.min });
+                dispatch({ type: "SET_POINT_VMAX", payload: colorAttr.max });
+              }
+            }
+          }
+        } catch {
+        }
+        let hasRasterLayers = false;
+        try {
+          const mode = await fetchDataMode();
+          const datasets = await fetchDatasets();
+          const datasetNames = Object.keys(datasets);
+          if (datasetNames.length > 0) {
+            hasRasterLayers = true;
+            dispatch({ type: "SET_DATA_MODE", payload: mode });
+            dispatch({ type: "SET_DATASETS", payload: datasets });
+            const firstDataset = datasetNames[0];
+            dispatch({ type: "SET_CURRENT_DATASET", payload: firstDataset });
+            const bounds = datasets[firstDataset].latlon_bounds;
+            const centerLat = (bounds[1] + bounds[3]) / 2;
+            const centerLng = (bounds[0] + bounds[2]) / 2;
+            dispatch({ type: "SET_REF_MARKER_POSITION", payload: [centerLat, centerLng] });
+          }
+        } catch {
+        }
+        if (hasPointLayers && !hasRasterLayers) {
+          dispatch({ type: "SET_DATA_MODE", payload: "points" });
+        }
+        try {
+          const losInfo = await fetchLosInfo();
+          if (losInfo) {
+            dispatch({ type: "SET_GPS_LOS_INFO", payload: losInfo });
+          }
+        } catch {
         }
+        applyUrlState(dispatch, urlStateRef.current);
       } catch (error) {
         console.error("Error initializing app:", error);
       }
     };
     initializeApp();
-  }, [fetchDatasets, fetchDataMode, dispatch]);
-  return /* @__PURE__ */ jsxRuntimeExports.jsxs("div", { className: "app-container", children: [
-    /* @__PURE__ */ jsxRuntimeExports.jsx(ControlPanel, {}),
-    /* @__PURE__ */ jsxRuntimeExports.jsxs("div", { className: "map-container", children: [
-      /* @__PURE__ */ jsxRuntimeExports.jsx(MapContainer, {}),
-      /* @__PURE__ */ jsxRuntimeExports.jsx(PointManagerPanel, {}),
-      state.showChart && /* @__PURE__ */ jsxRuntimeExports.jsx(TimeSeriesChart, {})
-    ] })
-  ] });
+  }, [fetchDatasets, fetchDataMode, fetchPointLayers, fetchPointAttributes, fetchLosInfo, dispatch]);
+  return /* @__PURE__ */ jsxRuntimeExports.jsx("div", { className: "app-container", children: /* @__PURE__ */ jsxRuntimeExports.jsxs("div", { className: "map-container", style: { gridColumn: "1 / -1" }, children: [
+    /* @__PURE__ */ jsxRuntimeExports.jsx(MapContainer, {}),
+    /* @__PURE__ */ jsxRuntimeExports.jsx(PointControlsPanel, {}),
+    state.showChart && /* @__PURE__ */ jsxRuntimeExports.jsx(TimeSeriesChart, {})
+  ] }) });
 }
 function App() {
   return /* @__PURE__ */ jsxRuntimeExports.jsx(AppProvider, { children: /* @__PURE__ */ jsxRuntimeExports.jsx(AppContent, {}) });
@@ -32768,3 +341682,7 @@ function App() {
 client.createRoot(document.getElementById("root")).render(
   /* @__PURE__ */ jsxRuntimeExports.jsx(React.StrictMode, { children: /* @__PURE__ */ jsxRuntimeExports.jsx(App, {}) })
 );
+export {
+  commonjsGlobal as c,
+  getDefaultExportFromCjs as g
+};
diff --git a/src/bowser/gps.py b/src/bowser/gps.py
new file mode 100644
index 0000000..cbb4000
--- /dev/null
+++ b/src/bowser/gps.py
@@ -0,0 +1,208 @@
+"""FastAPI router for GPS station overlay with LOS projection.
+
+Fetches GPS/GNSS station data via `geepers` and projects ENU
+displacements into the radar Line-of-Sight direction.
+"""
+
+from __future__ import annotations
+
+import logging
+from typing import TYPE_CHECKING
+
+import numpy as np
+import pandas as pd
+from fastapi import APIRouter, HTTPException, Query
+
+if TYPE_CHECKING:
+    from .manifest import LosConfig
+
+logger = logging.getLogger("bowser.gps")
+
+router = APIRouter(prefix="/gps", tags=["GPS Stations"])
+
+_los_config: LosConfig | None = None
+_gps_source = None  # geepers.gps_sources.UnrSource instance
+_los_raster = None  # rioxarray DataArray for geotiff mode
+
+
+def init_gps(los_config: LosConfig) -> None:
+    """Initialize GPS data source and LOS configuration.
+
+    Parameters
+    ----------
+    los_config
+        LOS vector config from the manifest.
+    """
+    global _los_config, _gps_source, _los_raster
+
+    from geepers.gps_sources import UnrSource
+
+    _los_config = los_config
+    _gps_source = UnrSource()
+
+    if los_config.type == "geotiff" and los_config.source:
+        import rioxarray  # noqa: F401
+        import xarray as xr
+
+        _los_raster = xr.open_dataarray(los_config.source)
+        logger.info(f"Loaded LOS GeoTIFF: {los_config.source}")
+
+    logger.info(f"GPS initialized with LOS type={los_config.type}")
+
+
+def _get_los_vector(lon: float, lat: float) -> tuple[float, float, float]:
+    """Get the LOS unit vector at a given location.
+
+    Returns
+    -------
+    tuple[float, float, float]
+        (east, north, up) components of ground-to-satellite unit vector.
+    """
+    assert _los_config is not None
+
+    if _los_config.type == "constant":
+        assert _los_config.los_enu is not None
+        v = _los_config.los_enu
+        return (v.east, v.north, v.up)
+    else:
+        assert _los_raster is not None
+        enu = _los_raster.sel(x=lon, y=lat, method="nearest").values
+        return (float(enu[0]), float(enu[1]), float(enu[2]))
+
+
+def _project_enu_to_los(
+    east: np.ndarray,
+    north: np.ndarray,
+    up: np.ndarray,
+    los_e: float,
+    los_n: float,
+    los_u: float,
+) -> np.ndarray:
+    """Project ENU displacements to LOS via dot product.
+
+    Parameters
+    ----------
+    east, north, up
+        Displacement components in mm.
+    los_e, los_n, los_u
+        LOS unit vector components (ground-to-satellite).
+
+    Returns
+    -------
+    np.ndarray
+        LOS displacement in mm.
+    """
+    return east * los_e + north * los_n + up * los_u
+
+
+@router.get("/los_info")
+async def get_los_info() -> dict:
+    """Return the current LOS configuration."""
+    if _los_config is None:
+        raise HTTPException(status_code=404, detail="No LOS config available")
+
+    result: dict = {"type": _los_config.type}
+    if _los_config.los_enu:
+        result["east"] = _los_config.los_enu.east
+        result["north"] = _los_config.los_enu.north
+        result["up"] = _los_config.los_enu.up
+    if _los_config.source:
+        result["source"] = _los_config.source
+    return result
+
+
+@router.get("/stations")
+async def get_stations(
+    bbox: str = Query(..., description="Bounding box: west,south,east,north"),
+) -> list[dict]:
+    """List GPS stations within the bounding box."""
+    if _gps_source is None:
+        raise HTTPException(status_code=503, detail="GPS source not initialized")
+
+    parts = [float(x) for x in bbox.split(",")]
+    assert len(parts) == 4
+    west, south, east, north = parts
+
+    gdf = _gps_source.stations(bbox=(west, south, east, north))
+    if gdf is None or len(gdf) == 0:
+        return []
+
+    stations = []
+    for _, row in gdf.iterrows():
+        geom = row.geometry
+        station_id = str(row.get("id", row.name))
+        stations.append(
+            {
+                "id": station_id,
+                "name": station_id,
+                "lon": float(geom.x),
+                "lat": float(geom.y),
+            }
+        )
+
+    return stations
+
+
+@router.get("/stations/{station_id}/timeseries")
+async def get_station_timeseries(
+    station_id: str,
+    start_date: str | None = Query(None),
+    end_date: str | None = Query(None),
+) -> dict:
+    """Get GPS timeseries for a station, projected to LOS.
+
+    Returns both LOS-projected and raw ENU components.
+    """
+    if _gps_source is None:
+        raise HTTPException(status_code=503, detail="GPS source not initialized")
+    if _los_config is None:
+        raise HTTPException(status_code=503, detail="No LOS config")
+
+    try:
+        df = _gps_source.timeseries(
+            station_id,
+            frame="ENU",
+            start_date=start_date,
+            end_date=end_date,
+            zero_by="mean",
+        )
+    except Exception as e:
+        raise HTTPException(status_code=404, detail=f"Station {station_id}: {e}")
+
+    if df is None or len(df) == 0:
+        return {"station_id": station_id, "timeseries": []}
+
+    # Get LOS vector at station location
+    lon, lat = _gps_source.station_lonlat(station_id)
+    los_e, los_n, los_u = _get_los_vector(lon, lat)
+
+    # Convert ENU columns to mm (geepers returns meters)
+    east_mm = df["east"].values * 1000.0
+    north_mm = df["north"].values * 1000.0
+    up_mm = df["up"].values * 1000.0
+
+    los_mm = _project_enu_to_los(east_mm, north_mm, up_mm, los_e, los_n, los_u)
+
+    # Build response with dates and all components
+    # geepers returns dates in a 'date' column, not the index
+    dates = pd.to_datetime(df["date"]).dt.strftime("%Y-%m-%d").tolist()
+    timeseries = []
+    for i, date in enumerate(dates):
+        if np.isnan(los_mm[i]):
+            continue
+        timeseries.append(
+            {
+                "date": date,
+                "displacement": float(los_mm[i]),
+                "east": float(east_mm[i]),
+                "north": float(north_mm[i]),
+                "up": float(up_mm[i]),
+            }
+        )
+
+    return {
+        "station_id": station_id,
+        "station_name": station_id,
+        "los_vector": {"east": los_e, "north": los_n, "up": los_u},
+        "timeseries": timeseries,
+    }
diff --git a/src/bowser/main.py b/src/bowser/main.py
index e773677..8981164 100644
--- a/src/bowser/main.py
+++ b/src/bowser/main.py
@@ -23,6 +23,7 @@
 from titiler.core.factory import TilerFactory
 
 from .config import settings
+from .manifest import DatasetManifest
 from .readers import CustomReader
 from .titiler import Amplitude, JSONResponse, Phase, RasterGroup, Rewrap, Shift
 from .utils import calculate_trend, desensitize_mpl_case, generate_colorbar
@@ -61,47 +62,93 @@
 
 
 def load_data_sources():
-    """Load data sources and determine which mode to use (MD or COG)."""
-    # Check for xarray stack file first (MD mode)
-    if settings.BOWSER_STACK_DATA_FILE:
-        stack_file = os.environ["BOWSER_STACK_DATA_FILE"]
-        logger.info(f"Loading xarray dataset from {stack_file} (MD mode)")
-        ds = (
-            xr.open_zarr(stack_file)
-            if stack_file.endswith(".zarr")
-            else xr.open_dataset(stack_file)
-        )
-        crs = CRS.from_wkt(ds.spatial_ref.crs_wkt)
-        ds.rio.write_crs(crs, inplace=True)
-        transformer = Transformer.from_crs(4326, ds.rio.crs, always_xy=True)
-        return "md", ds, None, transformer
-
-    # Check for RasterGroup JSON config (COG mode)
-    elif Path(settings.BOWSER_DATASET_CONFIG_FILE).exists():
-        logger.info(
-            f"Loading RasterGroups from {settings.BOWSER_DATASET_CONFIG_FILE} (COG)"
-        )
-        data_js_list = json.loads(Path(settings.BOWSER_DATASET_CONFIG_FILE).read_text())
-        raster_groups = {}
-        for d in data_js_list:
-            rg = RasterGroup.model_validate(d)
-            raster_groups[rg.name] = rg
-        logger.info(
-            (
+    """Load data sources and determine which mode to use (MD or COG).
+
+    When a manifest is provided, point layers are loaded from it. Raster
+    sources are loaded from the manifest's raster layers OR from the
+    traditional BOWSER_STACK_DATA_FILE / BOWSER_DATASET_CONFIG_FILE env
+    vars, enabling both raster and point layers to coexist.
+    """
+    manifest = None
+    data_mode = "points"
+    xarray_dataset = None
+    raster_groups = None
+    transformer = None
+
+    # 1) Load manifest (point layers + optional raster layers)
+    manifest_file = os.environ.get("BOWSER_MANIFEST_FILE", "")
+    if manifest_file and Path(manifest_file).exists():
+        logger.info(f"Loading V2 manifest from {manifest_file}")
+        manifest = DatasetManifest.load(manifest_file)
+
+        # Initialize point layers if any
+        point_layers = manifest.get_point_layers()
+        if point_layers:
+            from .points import init_point_layers
+
+            init_point_layers(point_layers)
+            logger.info(f"Loaded {len(point_layers)} point layer(s)")
+
+        # Load raster layers from manifest if any
+        raster_layer_configs = manifest.get_raster_layers()
+        if raster_layer_configs:
+            raster_groups = {}
+            for name, rl in raster_layer_configs.items():
+                rg = RasterGroup(name=name, file_list=[rl.source])
+                raster_groups[name] = rg
+            data_mode = "cog"
+
+    # 2) Load traditional raster sources (if no rasters loaded yet)
+    if raster_groups is None:
+        if settings.BOWSER_STACK_DATA_FILE:
+            stack_file = os.environ["BOWSER_STACK_DATA_FILE"]
+            logger.info(f"Loading xarray dataset from {stack_file} (MD mode)")
+            ds = (
+                xr.open_zarr(stack_file)
+                if stack_file.endswith(".zarr")
+                else xr.open_dataset(stack_file)
+            )
+            crs = CRS.from_wkt(ds.spatial_ref.crs_wkt)
+            ds.rio.write_crs(crs, inplace=True)
+            transformer = Transformer.from_crs(4326, ds.rio.crs, always_xy=True)
+            xarray_dataset = ds
+            data_mode = "md"
+
+        elif Path(settings.BOWSER_DATASET_CONFIG_FILE).exists():
+            logger.info(
+                f"Loading RasterGroups from"
+                f" {settings.BOWSER_DATASET_CONFIG_FILE} (COG)"
+            )
+            data_js_list = json.loads(
+                Path(settings.BOWSER_DATASET_CONFIG_FILE).read_text()
+            )
+            raster_groups = {}
+            for d in data_js_list:
+                rg = RasterGroup.model_validate(d)
+                raster_groups[rg.name] = rg
+            logger.info(
                 f"Found {len(raster_groups)} RasterGroup configs:"
-                " {list(raster_groups.keys())}"
+                f" {list(raster_groups.keys())}"
             )
-        )
-        return "cog", None, raster_groups, None
+            data_mode = "cog"
 
-    else:
+    if not manifest and not xarray_dataset and not raster_groups:
         raise ValueError(
-            "No data files specified - need either stack file or JSON config"
+            "No data files specified - need either manifest, stack file,"
+            " or JSON config"
         )
 
+    return data_mode, xarray_dataset, raster_groups, transformer, manifest
+
 
 # Global data sources - load once at startup
-DATA_MODE, XARRAY_DATASET, RASTER_GROUPS, transformer_from_lonlat = load_data_sources()
+(
+    DATA_MODE,
+    XARRAY_DATASET,
+    RASTER_GROUPS,
+    transformer_from_lonlat,
+    MANIFEST,
+) = load_data_sources()
 print(f"Data loading complete in {time.time() - t0:.1f} sec. Mode: {DATA_MODE}")
 
 
@@ -169,6 +216,7 @@ def create_rastergroup_dataset_info(raster_groups: dict) -> dict:
             "bounds": list(rg.bounds),
             "latlon_bounds": list(rg.latlon_bounds),
             "x_values": rg.x_values,
+            "reference_date": rg.reference_date,
         }
     return dataset_info
 
@@ -178,8 +226,10 @@ async def datasets():
     """Return the JSON describing all available datasets."""
     if DATA_MODE == "md":
         return create_xarray_dataset_info(XARRAY_DATASET)
-    else:  # cog mode
+    elif RASTER_GROUPS:
         return create_rastergroup_dataset_info(RASTER_GROUPS)
+    else:
+        return {}
 
 
 @app.get("/mode")
@@ -215,13 +265,20 @@ async def _get_point_values(dataset_name: str, lon: float, lat: float) -> np.nda
             )
         x, y = transformer_from_lonlat.transform(lon, lat)
         point_data = XARRAY_DATASET[dataset_name].sel(x=x, y=y, method="nearest")
-        return np.atleast_1d(point_data.values)
+        values = np.atleast_1d(point_data.values)
     else:  # cog mode
         if dataset_name not in RASTER_GROUPS:
             raise HTTPException(
                 status_code=404, detail=f"Dataset {dataset_name} not found"
             )
-        return np.atleast_1d(RASTER_GROUPS[dataset_name]._reader.read_lonlat(lon, lat))
+        values = np.atleast_1d(
+            RASTER_GROUPS[dataset_name]._reader.read_lonlat(lon, lat)
+        )
+
+    # Complex-valued data (e.g. interferograms) can't be JSON serialized
+    if np.iscomplexobj(values):
+        values = values.real.astype(np.float64)
+    return values
 
 
 @app.get(
@@ -345,7 +402,9 @@ async def multi_point(
 
         try:
             # Get values at the point
-            values = await _get_point_values(dataset_name, float(lon), float(lat))
+            _lon: float = float(lon)  # type: ignore[arg-type]
+            _lat: float = float(lat)  # type: ignore[arg-type]
+            values = await _get_point_values(dataset_name, _lon, _lat)
 
             # Apply reference subtraction if provided
             if ref_values is not None:
@@ -577,6 +636,41 @@ def XarrayPathDependency(
 app.include_router(md_endpoints.router, prefix="/md", tags=["Xarray Multi Dimensional"])
 logger.info("Configured MD endpoints at /md/*")
 
+# Add point layer endpoints if available
+if MANIFEST and MANIFEST.get_point_layers():
+    from .points import router as points_router
+
+    app.include_router(points_router)
+    logger.info("Configured point layer endpoints at /points/*")
+
+# Add GPS overlay endpoints if LOS config is available
+_los_config = None
+if MANIFEST and MANIFEST.los:
+    _los_config = MANIFEST.los
+elif os.environ.get("BOWSER_LOS_CONFIG"):
+    # Parse LOS from env var: either a JSON file path or inline JSON
+    import json as _json
+
+    from .manifest import LosConfig, LosVectorConstant
+
+    los_str = os.environ["BOWSER_LOS_CONFIG"]
+    if Path(los_str).exists():
+        los_data = _json.loads(Path(los_str).read_text())
+        if "los_enu_ground_to_satellite" in los_data:
+            los_data = los_data["los_enu_ground_to_satellite"]
+        _los_config = LosConfig(type="constant", los_enu=LosVectorConstant(**los_data))
+    else:
+        los_data = _json.loads(los_str)
+        _los_config = LosConfig(type="constant", los_enu=LosVectorConstant(**los_data))
+
+if _los_config:
+    from .gps import init_gps
+    from .gps import router as gps_router
+
+    init_gps(_los_config)
+    app.include_router(gps_router)
+    logger.info("Configured GPS overlay endpoints at /gps/*")
+
 # Add exception handlers
 add_exception_handlers(app, DEFAULT_STATUS_CODES)
 
diff --git a/src/bowser/manifest.py b/src/bowser/manifest.py
new file mode 100644
index 0000000..932903c
--- /dev/null
+++ b/src/bowser/manifest.py
@@ -0,0 +1,138 @@
+"""Pydantic models for the Bowser V2 dataset manifest.
+
+A manifest describes a collection of raster and point layers for a single
+InSAR analysis area. It is the entry point for Bowser V2's unified
+raster + vector viewing.
+"""
+
+from __future__ import annotations
+
+from pathlib import Path
+from typing import Literal, Union
+
+from pydantic import BaseModel, Field
+
+
+class RasterLayerConfig(BaseModel):
+    """Configuration for a raster tile layer (COG or Zarr)."""
+
+    type: Literal["raster"] = "raster"
+    source: str = Field(description="Path or URI to raster file/stack (COG, Zarr, VRT)")
+    colormap: str = "RdBu_r"
+    units: str = ""
+    vmin: float | None = None
+    vmax: float | None = None
+
+
+class PointLayerConfig(BaseModel):
+    """Configuration for a vector point layer backed by GeoParquet."""
+
+    type: Literal["points"] = "points"
+    points_source: str = Field(description="Path or URI to points GeoParquet file")
+    timeseries_source: str = Field(
+        description="Path or URI to timeseries GeoParquet file"
+    )
+    default_color_by: str = "velocity"
+    default_colormap: str = "RdBu_r"
+    default_vmin: float | None = None
+    default_vmax: float | None = None
+
+
+LayerConfig = Union[RasterLayerConfig, PointLayerConfig]
+
+
+class LosVectorConstant(BaseModel):
+    """A constant LOS unit vector in ENU coordinates (ground-to-satellite)."""
+
+    east: float
+    north: float
+    up: float
+
+
+class LosConfig(BaseModel):
+    """Line-of-Sight vector for projecting GPS ENU displacements to radar LOS.
+
+    Parameters
+    ----------
+    type : str
+        "constant" for a single ENU vector, "geotiff" for a spatially-varying
+        3-band (E, N, U) GeoTIFF.
+    los_enu : LosVectorConstant or None
+        Inline ENU vector for type="constant".
+    source : str or None
+        Path to 3-band GeoTIFF for type="geotiff".
+    """
+
+    type: Literal["constant", "geotiff"]
+    los_enu: LosVectorConstant | None = None
+    source: str | None = None
+
+
+class DatasetManifest(BaseModel):
+    """Top-level manifest describing a Bowser V2 dataset.
+
+    Parameters
+    ----------
+    name : str
+        Human-readable dataset name.
+    layers : dict[str, LayerConfig]
+        Named layers, each either a raster or point layer.
+    description : str
+        Optional description of the dataset.
+    satellite : str
+        Satellite name (e.g., "Sentinel-1").
+    orbit : str
+        Orbit direction (e.g., "descending").
+    track : int
+        Relative orbit / track number.
+    reference_date : str
+        Reference date for displacement time series.
+    bounds : list[float]
+        Spatial bounds [west, south, east, north] in EPSG:4326.
+    """
+
+    name: str
+    layers: dict[str, LayerConfig] = Field(
+        description="Named layers (raster or points)"
+    )
+    description: str = ""
+    satellite: str = ""
+    orbit: str = ""
+    track: int | None = None
+    reference_date: str | None = None
+    bounds: list[float] | None = None
+    los: LosConfig | None = Field(
+        None,
+        description="LOS vector for GPS ENU→LOS projection",
+    )
+
+    def get_point_layers(self) -> dict[str, PointLayerConfig]:
+        """Return only the point layers from the manifest."""
+        return {
+            name: layer
+            for name, layer in self.layers.items()
+            if isinstance(layer, PointLayerConfig)
+        }
+
+    def get_raster_layers(self) -> dict[str, RasterLayerConfig]:
+        """Return only the raster layers from the manifest."""
+        return {
+            name: layer
+            for name, layer in self.layers.items()
+            if isinstance(layer, RasterLayerConfig)
+        }
+
+    @classmethod
+    def load(cls, path: str | Path) -> DatasetManifest:
+        """Load a manifest from a JSON file."""
+        import json
+
+        with open(path) as f:
+            return cls.model_validate(json.load(f))
+
+    def save(self, path: str | Path) -> None:
+        """Write the manifest to a JSON file."""
+        import json
+
+        with open(path, "w") as f:
+            json.dump(self.model_dump(), f, indent=2)
diff --git a/src/bowser/points.py b/src/bowser/points.py
new file mode 100644
index 0000000..1bfc53d
--- /dev/null
+++ b/src/bowser/points.py
@@ -0,0 +1,585 @@
+"""FastAPI router for vector point data, backed by DuckDB + GeoParquet.
+
+Provides endpoints for querying, filtering, and retrieving time series
+from GeoParquet point cloud datasets.
+"""
+
+from __future__ import annotations
+
+import io
+import logging
+from typing import TYPE_CHECKING
+
+import duckdb
+import numpy as np
+import pyarrow as pa
+import pyarrow.ipc as ipc
+from fastapi import APIRouter, HTTPException, Query, Response
+from fastapi.responses import StreamingResponse
+from pydantic import BaseModel
+
+if TYPE_CHECKING:
+    from .manifest import PointLayerConfig
+
+logger = logging.getLogger("bowser.points")
+
+router = APIRouter(prefix="/points", tags=["Vector Points"])
+
+# Module-level DuckDB connection, initialized by `init_point_layers`
+_conn: duckdb.DuckDBPyConnection | None = None
+_layers: dict[str, PointLayerConfig] = {}
+
+
+def init_point_layers(layers: dict[str, PointLayerConfig]) -> None:
+    """Initialize DuckDB connection and register GeoParquet files as views.
+
+    Parameters
+    ----------
+    layers : dict[str, PointLayerConfig]
+        Mapping of layer name to point layer config from the manifest.
+    """
+    global _conn, _layers
+    _conn = duckdb.connect()
+    _conn.install_extension("spatial")
+    _conn.load_extension("spatial")
+    _layers = layers
+
+    for name, layer in layers.items():
+        safe_name = _safe_identifier(name)
+        _conn.execute(
+            f"""
+            CREATE VIEW {safe_name}_points AS
+            SELECT * FROM read_parquet('{layer.points_source}')
+        """
+        )
+        _conn.execute(
+            f"""
+            CREATE VIEW {safe_name}_timeseries AS
+            SELECT * FROM read_parquet('{layer.timeseries_source}')
+        """
+        )
+        logger.info(f"Registered point layer '{name}' from {layer.points_source}")
+
+
+def _safe_identifier(name: str) -> str:
+    """Convert a layer name to a safe SQL identifier."""
+    return name.replace(" ", "_").replace("-", "_").lower()
+
+
+def _get_conn() -> duckdb.DuckDBPyConnection:
+    assert (
+        _conn is not None
+    ), "Point layers not initialized. Call init_point_layers first."
+    return _conn
+
+
+def _require_layer(layer_name: str) -> PointLayerConfig:
+    if layer_name not in _layers:
+        raise HTTPException(
+            status_code=404, detail=f"Point layer '{layer_name}' not found"
+        )
+    return _layers[layer_name]
+
+
+# --- Request/Response Models ---
+
+
+class TimeseriesRequest(BaseModel):
+    """Request body for multi-point time series."""
+
+    point_ids: list[int]
+
+
+class CrossSectionRequest(BaseModel):
+    """Request body for cross-section profile."""
+
+    line: list[list[float]]  # [[lon1, lat1], [lon2, lat2]]
+    width_m: float = 200.0
+    attribute: str = "velocity"
+
+
+class AreaAverageRequest(BaseModel):
+    """Request body for area averaging."""
+
+    polygon: list[list[float]]  # [[lon1, lat1], [lon2, lat2], ...]
+    max_points: int = 10000
+
+
+# --- Endpoints ---
+
+
+@router.get("/layers")
+async def list_layers() -> dict:
+    """List available point layers and their configuration."""
+    return {
+        name: {
+            "default_color_by": layer.default_color_by,
+            "default_colormap": layer.default_colormap,
+            "default_vmin": layer.default_vmin,
+            "default_vmax": layer.default_vmax,
+        }
+        for name, layer in _layers.items()
+    }
+
+
+@router.get("/{layer_name}/attributes")
+async def get_attributes(layer_name: str) -> dict:
+    """Get available columns with types and value ranges for a point layer.
+
+    Used by the frontend to dynamically build filter UI and color-by dropdown.
+    """
+    _require_layer(layer_name)
+    conn = _get_conn()
+    safe = _safe_identifier(layer_name)
+
+    # Get column info
+    cols = conn.execute(f"DESCRIBE {safe}_points").fetchall()
+
+    attributes = {}
+    for col_name, col_type, *_ in cols:
+        if col_name == "geometry":
+            continue
+
+        attr_info: dict = {"type": col_type}
+
+        # Get value range for numeric columns
+        if (
+            "FLOAT" in col_type.upper()
+            or "INT" in col_type.upper()
+            or "DOUBLE" in col_type.upper()
+        ):
+            try:
+                stats = conn.execute(
+                    f"""
+                    SELECT
+                        MIN({col_name}) as min_val,
+                        MAX({col_name}) as max_val,
+                        AVG({col_name}) as mean_val,
+                        COUNT({col_name}) as count
+                    FROM {safe}_points
+                """
+                ).fetchone()
+                attr_info["min"] = stats[0]
+                attr_info["max"] = stats[1]
+                attr_info["mean"] = stats[2]
+                attr_info["count"] = stats[3]
+            except duckdb.Error:
+                pass
+
+        attributes[col_name] = attr_info
+
+    return {"layer": layer_name, "attributes": attributes}
+
+
+@router.get("/{layer_name}")
+async def get_points(
+    layer_name: str,
+    bbox: str | None = Query(None, description="Bounding box: west,south,east,north"),
+    color_by: str = Query("velocity", description="Attribute to include for coloring"),
+    point_filter: str | None = Query(
+        None, alias="filter", description="Filter expression, e.g. 'velocity<-10'"
+    ),
+    max_points: int = Query(100_000, description="Maximum number of points to return"),
+) -> Response:
+    """Get points within a bounding box, returned as Arrow IPC.
+
+    The response contains columns: point_id, lon, lat, and the color_by attribute.
+    """
+    _require_layer(layer_name)
+    conn = _get_conn()
+    safe = _safe_identifier(layer_name)
+
+    # Build WHERE clause
+    where_parts: list[str] = []
+
+    if bbox:
+        parts = [float(x) for x in bbox.split(",")]
+        assert len(parts) == 4, f"bbox must have 4 values, got {len(parts)}"
+        west, south, east, north = parts
+        where_parts.append(
+            f"ST_X(geometry) BETWEEN {west} AND {east} "
+            f"AND ST_Y(geometry) BETWEEN {south} AND {north}"
+        )
+
+    if point_filter:
+        # Sanitize: only allow simple expressions on known columns
+        sanitized = _sanitize_filter(point_filter, safe, conn)
+        where_parts.append(sanitized)
+
+    where_clause = " AND ".join(where_parts) if where_parts else "TRUE"
+
+    # Validate color_by column exists
+    valid_cols = {
+        row[0]
+        for row in conn.execute(f"DESCRIBE {safe}_points").fetchall()
+        if row[0] != "geometry"
+    }
+    if color_by not in valid_cols:
+        color_by = "point_id"  # fallback
+
+    sql = f"""
+        SELECT
+            point_id,
+            ST_X(geometry) as lon,
+            ST_Y(geometry) as lat,
+            {color_by}
+        FROM {safe}_points
+        WHERE {where_clause}
+        LIMIT {max_points}
+    """
+
+    try:
+        arrow_table = conn.execute(sql).arrow().read_all()
+    except duckdb.Error as e:
+        raise HTTPException(status_code=400, detail=f"Query error: {e}")
+
+    # Serialize as Arrow IPC
+    sink = pa.BufferOutputStream()
+    writer = ipc.new_stream(sink, arrow_table.schema)
+    writer.write_table(arrow_table)
+    writer.close()
+
+    return Response(
+        content=sink.getvalue().to_pybytes(),
+        media_type="application/vnd.apache.arrow.stream",
+        headers={"X-Point-Count": str(len(arrow_table))},
+    )
+
+
+@router.get("/{layer_name}/{point_id}/timeseries")
+async def get_point_timeseries(
+    layer_name: str,
+    point_id: int,
+    start_date: str | None = Query(None, description="Start date filter (YYYY-MM-DD)"),
+    end_date: str | None = Query(None, description="End date filter (YYYY-MM-DD)"),
+) -> list[dict]:
+    """Get time series for a single point."""
+    _require_layer(layer_name)
+    conn = _get_conn()
+    safe = _safe_identifier(layer_name)
+
+    where_parts = [f"point_id = {int(point_id)}"]
+    if start_date:
+        where_parts.append(f"date >= '{start_date}'")
+    if end_date:
+        where_parts.append(f"date <= '{end_date}'")
+
+    sql = f"""
+        SELECT date, displacement
+        FROM {safe}_timeseries
+        WHERE {' AND '.join(where_parts)}
+        ORDER BY date
+    """
+
+    try:
+        result = conn.execute(sql).fetchall()
+    except duckdb.Error as e:
+        raise HTTPException(status_code=400, detail=f"Query error: {e}")
+
+    return [
+        {"date": str(row[0]), "displacement": float(row[1])}
+        for row in result
+        if not np.isnan(row[1])
+    ]
+
+
+@router.post("/{layer_name}/timeseries")
+async def get_multi_point_timeseries(
+    layer_name: str,
+    request: TimeseriesRequest,
+) -> dict:
+    """Get time series for multiple points at once."""
+    _require_layer(layer_name)
+    conn = _get_conn()
+    safe = _safe_identifier(layer_name)
+
+    point_ids = [int(p) for p in request.point_ids]
+    ids_str = ",".join(str(p) for p in point_ids)
+
+    sql = f"""
+        SELECT point_id, date, displacement
+        FROM {safe}_timeseries
+        WHERE point_id IN ({ids_str})
+        ORDER BY point_id, date
+    """
+
+    try:
+        result = conn.execute(sql).fetchall()
+    except duckdb.Error as e:
+        raise HTTPException(status_code=400, detail=f"Query error: {e}")
+
+    # Group by point_id
+    series: dict[int, list[dict]] = {pid: [] for pid in point_ids}
+    for point_id, date, displacement in result:
+        if np.isnan(displacement):
+            continue
+        series[point_id].append(
+            {
+                "date": str(date),
+                "displacement": float(displacement),
+            }
+        )
+
+    return {"series": series}
+
+
+@router.get("/{layer_name}/stats")
+async def get_stats(
+    layer_name: str,
+    bbox: str | None = Query(None, description="Bounding box: west,south,east,north"),
+    point_filter: str | None = Query(
+        None, alias="filter", description="Filter expression"
+    ),
+) -> dict:
+    """Get summary statistics for points in the current view."""
+    _require_layer(layer_name)
+    conn = _get_conn()
+    safe = _safe_identifier(layer_name)
+
+    where_parts: list[str] = []
+    if bbox:
+        parts = [float(x) for x in bbox.split(",")]
+        west, south, east, north = parts
+        where_parts.append(
+            f"ST_X(geometry) BETWEEN {west} AND {east} "
+            f"AND ST_Y(geometry) BETWEEN {south} AND {north}"
+        )
+    if point_filter:
+        sanitized = _sanitize_filter(point_filter, safe, conn)
+        where_parts.append(sanitized)
+
+    where_clause = " AND ".join(where_parts) if where_parts else "TRUE"
+
+    # Build dynamic stats query for all numeric columns
+    cols = conn.execute(f"DESCRIBE {safe}_points").fetchall()
+    numeric_cols = [
+        row[0]
+        for row in cols
+        if row[0] != "geometry"
+        and ("FLOAT" in row[1].upper() or "DOUBLE" in row[1].upper())
+    ]
+
+    agg_parts = ["COUNT(*) as count"]
+    for col in numeric_cols:
+        agg_parts.extend(
+            [
+                f"AVG({col}) as {col}_mean",
+                f"STDDEV({col}) as {col}_std",
+                f"MIN({col}) as {col}_min",
+                f"MAX({col}) as {col}_max",
+            ]
+        )
+
+    sql = f"""
+        SELECT {', '.join(agg_parts)}
+        FROM {safe}_points
+        WHERE {where_clause}
+    """
+
+    try:
+        result = conn.execute(sql).fetchone()
+        col_names = [desc[0] for desc in conn.execute(sql).description]
+    except duckdb.Error as e:
+        raise HTTPException(status_code=400, detail=f"Query error: {e}")
+
+    stats = {}
+    for name, val in zip(col_names, result):
+        if val is not None and not (isinstance(val, float) and np.isnan(val)):
+            stats[name] = val
+
+    return stats
+
+
+@router.get("/{layer_name}/export")
+async def export_points(
+    layer_name: str,
+    export_format: str = Query(
+        "csv", alias="format", description="Export format: csv, geojson, parquet"
+    ),
+    bbox: str | None = Query(None, description="Bounding box: west,south,east,north"),
+    point_filter: str | None = Query(
+        None, alias="filter", description="Filter expression"
+    ),
+    max_points: int = Query(500_000, description="Maximum points to export"),
+    include_timeseries: bool = Query(
+        False, description="Include displacement time series in export"
+    ),
+) -> StreamingResponse:
+    """Export filtered points as CSV, GeoJSON, or GeoParquet."""
+    _require_layer(layer_name)
+    conn = _get_conn()
+    safe = _safe_identifier(layer_name)
+
+    where_parts: list[str] = []
+    if bbox:
+        parts = [float(x) for x in bbox.split(",")]
+        assert len(parts) == 4
+        west, south, east, north = parts
+        where_parts.append(
+            f"ST_X(geometry) BETWEEN {west} AND {east} "
+            f"AND ST_Y(geometry) BETWEEN {south} AND {north}"
+        )
+    if point_filter:
+        sanitized = _sanitize_filter(point_filter, safe, conn)
+        where_parts.append(sanitized)
+
+    where_clause = " AND ".join(where_parts) if where_parts else "TRUE"
+
+    # Get all non-geometry columns
+    cols = conn.execute(f"DESCRIBE {safe}_points").fetchall()
+    select_cols = [
+        row[0]
+        if row[0] != "geometry"
+        else "ST_X(geometry) as longitude, ST_Y(geometry) as latitude"
+        for row in cols
+    ]
+
+    sql = f"""
+        SELECT {', '.join(select_cols)}
+        FROM {safe}_points
+        WHERE {where_clause}
+        LIMIT {max_points}
+    """
+
+    try:
+        result = conn.execute(sql).arrow().read_all()
+    except duckdb.Error as e:
+        raise HTTPException(status_code=400, detail=f"Query error: {e}")
+
+    if include_timeseries:
+        point_ids = result.column("point_id").to_pylist()
+        if point_ids:
+            ids_str = ",".join(str(int(p)) for p in point_ids)
+            ts_sql = f"""
+                SELECT point_id, date, displacement
+                FROM {safe}_timeseries
+                WHERE point_id IN ({ids_str})
+                ORDER BY point_id, date
+            """
+            ts_result = conn.execute(ts_sql).arrow().read_all()
+        else:
+            ts_result = None
+    else:
+        ts_result = None
+
+    if export_format == "csv":
+        import pyarrow.csv as csv_writer
+
+        buf = io.BytesIO()
+        csv_writer.write_csv(result, buf)
+        if ts_result is not None:
+            buf.write(b"\n\n# Timeseries\n")
+            csv_writer.write_csv(ts_result, buf)
+        buf.seek(0)
+        return StreamingResponse(
+            buf,
+            media_type="text/csv",
+            headers={
+                "Content-Disposition": f'attachment; filename="{layer_name}_points.csv"'
+            },
+        )
+
+    elif export_format == "geojson":
+        import json
+
+        df = result.to_pandas()
+        features = []
+        for _, row in df.iterrows():
+            props = {
+                k: (float(v) if isinstance(v, (np.floating, float)) else v)
+                for k, v in row.items()
+                if k not in ("longitude", "latitude")
+            }
+            features.append(
+                {
+                    "type": "Feature",
+                    "geometry": {
+                        "type": "Point",
+                        "coordinates": [
+                            float(row["longitude"]),
+                            float(row["latitude"]),
+                        ],
+                    },
+                    "properties": props,
+                }
+            )
+
+        geojson = {"type": "FeatureCollection", "features": features}
+        content = json.dumps(geojson).encode()
+        return StreamingResponse(
+            io.BytesIO(content),
+            media_type="application/geo+json",
+            headers={
+                "Content-Disposition": (
+                    f'attachment; filename="{layer_name}_points.geojson"'
+                )
+            },
+        )
+
+    elif export_format == "parquet":
+        import pyarrow.parquet as pq
+
+        buf = io.BytesIO()
+        pq.write_table(result, buf)
+        buf.seek(0)
+        return StreamingResponse(
+            buf,
+            media_type="application/octet-stream",
+            headers={
+                "Content-Disposition": (
+                    f'attachment; filename="{layer_name}_points.parquet"'
+                )
+            },
+        )
+
+    else:
+        raise HTTPException(status_code=400, detail=f"Unknown format: {export_format}")
+
+
+# --- Filter Sanitization ---
+
+# Allowed operators in filter expressions
+_ALLOWED_OPS = {"<", ">", "<=", ">=", "=", "!=", "<>"}
+
+
+def _sanitize_filter(
+    filter_expr: str,
+    safe_layer: str,
+    conn: duckdb.DuckDBPyConnection,
+) -> str:
+    """Sanitize a user-provided filter expression.
+
+    Only allows simple `column op value` expressions joined by AND.
+    Validates that column names exist in the table.
+    """
+    valid_cols = {
+        row[0]
+        for row in conn.execute(f"DESCRIBE {safe_layer}_points").fetchall()
+        if row[0] != "geometry"
+    }
+
+    parts = []
+    for clause in filter_expr.split(","):
+        clause = clause.strip()
+        if not clause:
+            continue
+
+        # Parse: column_name operator value
+        found = False
+        for op in sorted(_ALLOWED_OPS, key=len, reverse=True):
+            if op in clause:
+                col, val = clause.split(op, 1)
+                col = col.strip()
+                val = val.strip()
+
+                assert col in valid_cols, f"Unknown column: {col}"
+                # Validate value is numeric
+                float(val)  # raises ValueError if not numeric
+
+                parts.append(f"{col} {op} {val}")
+                found = True
+                break
+
+        assert found, f"Invalid filter clause: {clause}"
+
+    return " AND ".join(parts)
diff --git a/src/bowser/readers.py b/src/bowser/readers.py
index 4a498a2..f0f9dad 100644
--- a/src/bowser/readers.py
+++ b/src/bowser/readers.py
@@ -26,6 +26,7 @@
 from opera_utils import get_dates
 from pyproj import Transformer
 from rasterio.crs import CRS
+from rasterio.dtypes import dtype_fwd
 from rio_tiler.constants import WEB_MERCATOR_TMS, WGS84_CRS
 from rio_tiler.io import BaseReader, Reader
 from rio_tiler.models import BandStatistics, ImageData, Info, PointData
@@ -34,6 +35,26 @@
 
 PathOrStr = Path | str
 
+# GDAL 3.11+ interprets NBITS=16 on float32 GeoTIFFs as native Float16
+# (datatype code 15). Rasterio builds that lack a mapping for code 15
+# raise KeyError on open. Patch the mapping so these files can be read.
+_GDAL_FLOAT16_CODE = 15
+if _GDAL_FLOAT16_CODE not in dtype_fwd:
+    dtype_fwd[_GDAL_FLOAT16_CODE] = "float32"
+
+
+def _can_use_nbits16() -> bool:
+    """Check whether NBITS=16 can be used safely with the current GDAL/rasterio.
+
+    Returns False when GDAL >= 3.11 would reinterpret NBITS=16 float32 as
+    Float16 but rasterio has no native Float16 support.  Callers that create
+    GeoTIFFs should skip the NBITS=16 creation option when this returns False.
+    """
+    return (
+        _GDAL_FLOAT16_CODE in dtype_fwd and dtype_fwd[_GDAL_FLOAT16_CODE] != "float32"
+    )
+
+
 __all__ = [
     "DatasetReader",
     "StackReader",
diff --git a/src/bowser/titiler.py b/src/bowser/titiler.py
index ef39d45..25a5b42 100644
--- a/src/bowser/titiler.py
+++ b/src/bowser/titiler.py
@@ -144,16 +144,39 @@ def latlon_bounds(self) -> tuple[float, float, float, float]:
     @computed_field
     def x_values(self) -> list[str | int]:
         """Vales to use for the x axis of a time series plot."""
-        # if len(self.file_list) == 1:
         dates = self._reader.dates
-        if not dates or any(d is None for d in dates):
-            # otherwise, use indexes
-            x_values = np.arange(len(self.file_list)).tolist()
-        else:
-            x_values = [_format_dates(*k) for k in dates]  # type: ignore[misc]
+        # Check if all dates are valid and non-empty
+        if not dates or any((d is None or not d) for d in dates):
+            return np.arange(len(self.file_list)).tolist()
+
+        # For time series plotting, use the last date (secondary/end date)
+        x_values = [k[-1].strftime("%Y-%m-%d") for k in dates]  # type: ignore[index]
+
+        # If secondary dates have duplicates (e.g., interferograms with varying
+        # reference dates), use full "ref_secondary" date pair labels instead.
+        # The frontend renders these with a category scale.
+        if len(set(x_values)) != len(x_values):
+            return [
+                "_".join(d.strftime("%Y-%m-%d") for d in k)  # type: ignore[union-attr]
+                for k in dates
+            ]
 
         return x_values
 
+    @computed_field
+    def reference_date(self) -> str | None:
+        """Common reference date if all files share the same first date."""  # noqa: D401
+        dates = self._reader.dates
+        if not dates or any(not d for d in dates):
+            return None
+        # Check for multi-date filenames (e.g., interferograms)
+        if not all(len(d) > 1 for d in dates):  # type: ignore[arg-type]
+            return None
+        first_dates = {d[0] for d in dates}  # type: ignore[index]
+        if len(first_dates) == 1:
+            return first_dates.pop().strftime("%Y-%m-%d")
+        return None
+
     @classmethod
     def from_glob(
         cls,
@@ -190,10 +213,6 @@ def _find_files(glob_str: str) -> list[str]:
     return file_list
 
 
-def _format_dates(*dates, fmt="%Y%m%d") -> str:
-    return "_".join(f"{d.strftime(fmt)}" for d in dates)
-
-
 # https://github.com/developmentseed/titiler/blob/0fddd7ed268557e82a5e1520cdd7fdf084afa1b8/src/titiler/core/titiler/core/resources/responses.py#L15
 class JSONResponse(responses.JSONResponse):
     """Custom JSON Response."""
diff --git a/src/bowser/utils.py b/src/bowser/utils.py
index 5c66f13..e1482b7 100644
--- a/src/bowser/utils.py
+++ b/src/bowser/utils.py
@@ -5,8 +5,7 @@
 from typing import Sequence, TypeVar
 
 import numpy as np
-from dateutil import parser
-from scipy import stats
+from dateutil import parser  # type: ignore[import-untyped]
 
 
 class CredentialsError(Exception):
@@ -16,7 +15,7 @@ class CredentialsError(Exception):
 DateOrDatetimeT = TypeVar("DateOrDatetimeT", datetime, np.datetime64)
 
 
-def _parse_x_values(x_values: list[str | int]) -> np.ndarray:
+def _parse_x_values(x_values: list[str | int | DateOrDatetimeT]) -> np.ndarray:
     """Parse x_values to get numeric time values in days.
 
     Parameters
@@ -24,8 +23,7 @@ def _parse_x_values(x_values: list[str | int]) -> np.ndarray:
     x_values : list[str | int]
         List of x values which can be:
         - integers (no time information)
-        - datetime strings in "%Y-%m-%d" format (xarray mode)
-        - datetime strings in "%Y%m%d" or "%Y%m%d_%Y%m%d" format (COG mode)
+        - datetime strings in "%Y-%m-%d" format (both xarray and COG modes)
 
     Returns
     -------
@@ -51,7 +49,7 @@ def _parse_x_values(x_values: list[str | int]) -> np.ndarray:
         elif isinstance(x, int):
             date_str = str(x)
         else:
-            date_str = x
+            date_str = str(x)
 
         try:
             date = parser.parse(date_str)
@@ -96,19 +94,35 @@ def calculate_trend(
     time_days = _parse_x_values(x_values)
     valid_time = time_days[valid_mask]
 
-    # Calculate linear regression using actual time values
-    slope, intercept, r_value, p_value, std_err = stats.linregress(
-        valid_time, valid_values
-    )
-
-    # Convert slope to mm/year
-    # slope is in meters/day, so convert to mm/year
+    # Linear regression with numpy (no scipy dependency needed)
+    x = valid_time
+    y = valid_values
+    n = len(x)
+    sum_x = x.sum()
+    sum_y = y.sum()
+    sum_xy = (x * y).sum()
+    sum_xx = (x * x).sum()
+
+    denom = n * sum_xx - sum_x * sum_x
+    if abs(denom) < 1e-12:
+        return {"slope": 0.0, "intercept": 0.0, "r_squared": 0.0, "mm_per_year": 0.0}
+
+    slope = (n * sum_xy - sum_x * sum_y) / denom
+    intercept = (sum_y - slope * sum_x) / n
+
+    # R²
+    mean_y = sum_y / n
+    ss_res = ((y - (slope * x + intercept)) ** 2).sum()
+    ss_tot = ((y - mean_y) ** 2).sum()
+    r_squared = 1 - ss_res / ss_tot if ss_tot > 0 else 0.0
+
+    # slope is in meters/day → mm/year
     mm_per_year = slope * 1000 * 365.25
 
     return {
         "slope": float(slope),
         "intercept": float(intercept),
-        "r_squared": float(r_value**2),
+        "r_squared": float(r_squared),
         "mm_per_year": float(mm_per_year),
     }
 
diff --git a/src/colorscales.ts b/src/colorscales.ts
new file mode 100644
index 0000000..b33af3b
--- /dev/null
+++ b/src/colorscales.ts
@@ -0,0 +1,83 @@
+// Color scale functions for point cloud visualization.
+// Each function maps a normalized t in [0, 1] to [R, G, B, A].
+
+type RGBA = [number, number, number, number];
+
+// Interpolate between color stops
+function interpolateStops(
+  t: number,
+  stops: Array<[number, number, number]>,
+): RGBA {
+  const n = stops.length - 1;
+  const idx = Math.min(Math.floor(t * n), n - 1);
+  const local = (t * n) - idx;
+  const a = stops[idx];
+  const b = stops[idx + 1];
+  return [
+    Math.round(a[0] + (b[0] - a[0]) * local),
+    Math.round(a[1] + (b[1] - a[1]) * local),
+    Math.round(a[2] + (b[2] - a[2]) * local),
+    220,
+  ];
+}
+
+const COLORMAP_STOPS: Record<string, Array<[number, number, number]>> = {
+  rdbu_r: [
+    [33, 102, 172],   // blue (low)
+    [146, 197, 222],
+    [247, 247, 247],  // white (mid)
+    [214, 96, 77],
+    [178, 24, 43],    // red (high)
+  ],
+  viridis: [
+    [68, 1, 84],
+    [59, 82, 139],
+    [33, 145, 140],
+    [94, 201, 98],
+    [253, 231, 37],
+  ],
+  plasma: [
+    [13, 8, 135],
+    [126, 3, 168],
+    [204, 71, 120],
+    [248, 149, 64],
+    [240, 249, 33],
+  ],
+  inferno: [
+    [0, 0, 4],
+    [87, 16, 110],
+    [188, 55, 84],
+    [249, 142, 9],
+    [252, 255, 164],
+  ],
+  coolwarm: [
+    [59, 76, 192],
+    [141, 176, 254],
+    [221, 221, 221],
+    [245, 152, 105],
+    [180, 4, 38],
+  ],
+};
+
+export const COLORMAP_NAMES = Object.keys(COLORMAP_STOPS);
+
+export function valueToColor(
+  value: number,
+  vmin: number,
+  vmax: number,
+  colormap: string = 'rdbu_r',
+): RGBA {
+  const t = Math.max(0, Math.min(1, (value - vmin) / (vmax - vmin || 1)));
+  const stops = COLORMAP_STOPS[colormap] || COLORMAP_STOPS.rdbu_r;
+  return interpolateStops(t, stops);
+}
+
+// Generate CSS gradient string for the colorbar
+export function colormapGradientCSS(colormap: string = 'rdbu_r'): string {
+  const stops = COLORMAP_STOPS[colormap] || COLORMAP_STOPS.rdbu_r;
+  const cssStops = stops.map((s, i) => {
+    const pct = (i / (stops.length - 1)) * 100;
+    return `rgb(${s[0]},${s[1]},${s[2]}) ${pct}%`;
+  });
+  return `linear-gradient(to right, ${cssStops.join(', ')})`;
+}
diff --git a/src/components/App.tsx b/src/components/App.tsx
index c3c9731..e8795a9 100644
--- a/src/components/App.tsx
+++ b/src/components/App.tsx
@@ -1,54 +1,124 @@
-import { useEffect } from 'react';
+import { useEffect, useRef } from 'react';
 import { AppProvider, useAppContext } from '../context/AppContext';
 import { useApi } from '../hooks/useApi';
+import { usePointsApi } from '../hooks/usePointsApi';
+import { useGpsApi } from '../hooks/useGpsApi';
+import { parseUrlState, applyUrlState, useUrlStateSync } from '../hooks/useUrlState';
 import MapContainer from './MapContainer';
-import ControlPanel from './ControlPanel';
 import TimeSeriesChart from './TimeSeriesChart';
-import PointManagerPanel from './PointManagerPanel';
+import PointControlsPanel from './PointControlsPanel';
 import '../style.css';
 
 function AppContent() {
   const { state, dispatch } = useAppContext();
   const { fetchDatasets, fetchDataMode } = useApi();
+  const { fetchPointLayers, fetchPointAttributes } = usePointsApi();
+  const { fetchLosInfo } = useGpsApi();
+  const urlStateRef = useRef(parseUrlState());
+
+  // Sync state → URL params
+  useUrlStateSync();
 
   useEffect(() => {
     const initializeApp = async () => {
       try {
-        // Fetch data mode first
-        const mode = await fetchDataMode();
-        dispatch({ type: 'SET_DATA_MODE', payload: mode });
-
-        // Then fetch datasets
-        const datasets = await fetchDatasets();
-        dispatch({ type: 'SET_DATASETS', payload: datasets });
-
-        // Set initial dataset and position
-        const firstDataset = Object.keys(datasets)[0];
-        if (firstDataset) {
-          dispatch({ type: 'SET_CURRENT_DATASET', payload: firstDataset });
-
-          // Compute center from bounds
-          const bounds = datasets[firstDataset].latlon_bounds;
-          const centerLat = (bounds[1] + bounds[3]) / 2;
-          const centerLng = (bounds[0] + bounds[2]) / 2;
-
-          // Set reference marker position
-          dispatch({ type: 'SET_REF_MARKER_POSITION', payload: [centerLat, centerLng] });
+        // Try to load BOTH raster datasets and point layers.
+        // They can coexist — the manifest may define both.
+
+        // 1) Try point layers
+        let hasPointLayers = false;
+        try {
+          const pointLayers = await fetchPointLayers();
+          const layerNames = Object.keys(pointLayers);
+          if (layerNames.length > 0) {
+            hasPointLayers = true;
+            const firstLayer = layerNames[0];
+            dispatch({ type: 'SET_ACTIVE_POINT_LAYER', payload: firstLayer });
+
+            const attrs = await fetchPointAttributes(firstLayer);
+            dispatch({ type: 'SET_POINT_ATTRIBUTES', payload: attrs.attributes });
+
+            // Set bounds from lon/lat ranges
+            const lonAttr = attrs.attributes.longitude;
+            const latAttr = attrs.attributes.latitude;
+            if (lonAttr?.min != null && lonAttr?.max != null &&
+                latAttr?.min != null && latAttr?.max != null) {
+              dispatch({
+                type: 'SET_POINT_LAYER_BOUNDS',
+                payload: [lonAttr.min, latAttr.min, lonAttr.max, latAttr.max],
+              });
+            }
+
+            // Auto-set vmin/vmax from default color-by attribute
+            const defaultColorBy = pointLayers[firstLayer].default_color_by || 'velocity';
+            dispatch({ type: 'SET_POINT_COLOR_BY', payload: defaultColorBy });
+            const colorAttr = attrs.attributes[defaultColorBy];
+            if (colorAttr?.min != null && colorAttr?.max != null) {
+              if (defaultColorBy.includes('velocity')) {
+                const absMax = Math.max(Math.abs(colorAttr.min), Math.abs(colorAttr.max));
+                dispatch({ type: 'SET_POINT_VMIN', payload: -absMax });
+                dispatch({ type: 'SET_POINT_VMAX', payload: absMax });
+              } else {
+                dispatch({ type: 'SET_POINT_VMIN', payload: colorAttr.min });
+                dispatch({ type: 'SET_POINT_VMAX', payload: colorAttr.max });
+              }
+            }
+          }
+        } catch {
+          // No point layers endpoint — that's fine
         }
+
+        // 2) Try raster datasets (always, regardless of point layers)
+        let hasRasterLayers = false;
+        try {
+          const mode = await fetchDataMode();
+          const datasets = await fetchDatasets();
+          const datasetNames = Object.keys(datasets);
+          if (datasetNames.length > 0) {
+            hasRasterLayers = true;
+            dispatch({ type: 'SET_DATA_MODE', payload: mode });
+            dispatch({ type: 'SET_DATASETS', payload: datasets });
+
+            const firstDataset = datasetNames[0];
+            dispatch({ type: 'SET_CURRENT_DATASET', payload: firstDataset });
+
+            const bounds = datasets[firstDataset].latlon_bounds;
+            const centerLat = (bounds[1] + bounds[3]) / 2;
+            const centerLng = (bounds[0] + bounds[2]) / 2;
+            dispatch({ type: 'SET_REF_MARKER_POSITION', payload: [centerLat, centerLng] });
+          }
+        } catch {
+          // No raster datasets — that's fine if we have points
+        }
+
+        // Set data mode based on what's available
+        if (hasPointLayers && !hasRasterLayers) {
+          dispatch({ type: 'SET_DATA_MODE', payload: 'points' });
+        }
+
+        // Check for GPS/LOS availability
+        try {
+          const losInfo = await fetchLosInfo();
+          if (losInfo) {
+            dispatch({ type: 'SET_GPS_LOS_INFO', payload: losInfo });
+          }
+        } catch { /* No GPS endpoint */ }
+
+        // Apply URL state overrides (shareable links)
+        applyUrlState(dispatch, urlStateRef.current);
       } catch (error) {
         console.error('Error initializing app:', error);
       }
     };
 
     initializeApp();
-  }, [fetchDatasets, fetchDataMode, dispatch]);
+  }, [fetchDatasets, fetchDataMode, fetchPointLayers, fetchPointAttributes, fetchLosInfo, dispatch]);
 
   return (
     <div className="app-container">
-      <ControlPanel />
-      <div className="map-container">
+      <div className="map-container" style={{ gridColumn: '1 / -1' }}>
         <MapContainer />
-        <PointManagerPanel />
+        <PointControlsPanel />
         {state.showChart && <TimeSeriesChart />}
       </div>
     </div>
diff --git a/src/components/ControlPanel.test.tsx b/src/components/ControlPanel.test.tsx
new file mode 100644
index 0000000..e1739b9
--- /dev/null
+++ b/src/components/ControlPanel.test.tsx
@@ -0,0 +1,115 @@
+import { describe, it, expect, beforeEach, vi } from 'vitest';
+import { render, screen, waitFor } from '@testing-library/react';
+import userEvent from '@testing-library/user-event';
+import ControlPanel from './ControlPanel';
+import { AppProvider } from '../context/AppContext';
+
+// Mock the useApi hook since we don't need actual API calls
+vi.mock('../hooks/useApi', () => ({
+  useApi: () => ({
+    fetchPointTimeSeries: vi.fn(),
+  }),
+}));
+
+describe('ControlPanel localStorage', () => {
+  beforeEach(() => {
+    // Clear localStorage before each test
+    localStorage.clear();
+    vi.clearAllMocks();
+  });
+
+  it('saves colormap settings to localStorage when changed', async () => {
+    const user = userEvent.setup();
+
+    render(
+      <AppProvider>
+        <ControlPanel />
+      </AppProvider>
+    );
+
+    // Find and change the colormap selector
+    const colormapSelect = screen.getByDisplayValue('Blue-Red');
+    await user.selectOptions(colormapSelect, 'viridis');
+
+    // Wait for the effect to save to localStorage
+    await waitFor(() => {
+      expect(localStorage.getItem('dataset-a-colormap_name')).toBe('viridis');
+    });
+  });
+
+  it('does not overwrite new dataset settings when switching datasets', async () => {
+    const user = userEvent.setup();
+
+    // Pre-populate localStorage with saved settings for both datasets
+    localStorage.setItem('dataset-a-colormap_name', 'viridis');
+    localStorage.setItem('dataset-b-colormap_name', 'magma');
+
+    render(
+      <AppProvider>
+        <ControlPanel />
+      </AppProvider>
+    );
+
+    // Initially on dataset-a, should load viridis
+    await waitFor(() => {
+      const colormapSelect = screen.getByRole('combobox', { name: /color map/i });
+      expect(colormapSelect).toHaveValue('viridis');
+    });
+
+    // Switch to dataset-b
+    const datasetSelect = screen.getByRole('combobox', { name: /layers/i });
+    await user.selectOptions(datasetSelect, 'dataset-b');
+
+    // Should load magma (dataset-b's saved colormap)
+    await waitFor(() => {
+      const colormapSelect = screen.getByRole('combobox', { name: /color map/i });
+      expect(colormapSelect).toHaveValue('magma');
+    });
+
+    // Verify that dataset-b's localStorage was NOT overwritten with dataset-a's value
+    expect(localStorage.getItem('dataset-b-colormap_name')).toBe('magma');
+  });
+
+  it('preserves color limits when switching between datasets', async () => {
+    const user = userEvent.setup();
+
+    localStorage.setItem('dataset-a-vmin', '-10');
+    localStorage.setItem('dataset-a-vmax', '10');
+    localStorage.setItem('dataset-b-vmin', '-5');
+    localStorage.setItem('dataset-b-vmax', '5');
+
+    render(
+      <AppProvider>
+        <ControlPanel />
+      </AppProvider>
+    );
+
+    // On dataset-a, should load -10/10
+    await waitFor(() => {
+      const vminInputs = screen.getAllByRole('textbox', { name: '' });
+      expect(vminInputs[0]).toHaveValue('-10');
+      expect(vminInputs[1]).toHaveValue('10');
+    });
+
+    // Switch to dataset-b
+    const datasetSelect = screen.getByRole('combobox', { name: /layers/i });
+    await user.selectOptions(datasetSelect, 'dataset-b');
+
+    // Should load -5/5 (dataset-b's saved limits)
+    await waitFor(() => {
+      const vminInputs = screen.getAllByRole('textbox', { name: '' });
+      expect(vminInputs[0]).toHaveValue('-5');
+      expect(vminInputs[1]).toHaveValue('5');
+    });
+
+    // Switch back to dataset-a
+    await user.selectOptions(datasetSelect, 'dataset-a');
+
+    // Should load -10/10 again (dataset-a's saved limits)
+    await waitFor(() => {
+      const vminInputs = screen.getAllByRole('textbox', { name: '' });
+      expect(vminInputs[0]).toHaveValue('-10');
+      expect(vminInputs[1]).toHaveValue('10');
+    });
+  });
+});
diff --git a/src/components/ControlPanel.tsx b/src/components/ControlPanel.tsx
index 9bffd7d..68788a6 100644
--- a/src/components/ControlPanel.tsx
+++ b/src/components/ControlPanel.tsx
@@ -40,7 +40,7 @@ export default function ControlPanel() {
     localStorage.setItem(`${datasetName}-colormap_name`, state.colormap);
     localStorage.setItem(`${datasetName}-vmin`, safeNumToString(state.vmin));
     localStorage.setItem(`${datasetName}-vmax`, safeNumToString(state.vmax));
-  }, [state.currentDataset, state.colormap, state.vmin, state.vmax]);
+  }, [state.colormap, state.vmin, state.vmax]);
 
   // On first load / dataset change, read preferences and push into state once
   useEffect(() => {
diff --git a/src/components/MapContainer.tsx b/src/components/MapContainer.tsx
index 3c0b08c..a7d4e98 100644
--- a/src/components/MapContainer.tsx
+++ b/src/components/MapContainer.tsx
@@ -1,318 +1,639 @@
-import { useEffect, useState } from 'react';
-import { MapContainer as LeafletMapContainer, TileLayer, Marker, useMapEvents, useMap } from 'react-leaflet';
-import L from 'leaflet';
-import 'leaflet/dist/leaflet.css';
-import { useApi } from '../hooks/useApi';
+import { useEffect, useState, useRef, useCallback } from 'react';
+import maplibregl from 'maplibre-gl';
+import 'maplibre-gl/dist/maplibre-gl.css';
+import { MapboxOverlay } from '@deck.gl/mapbox';
+import { ScatterplotLayer } from '@deck.gl/layers';
 import { useAppContext } from '../context/AppContext';
-import { baseMaps } from '../basemap';
-import { MousePositionControl } from '../mouse';
-
-// Fix for default markers in React Leaflet
-delete (L.Icon.Default.prototype as any)._getIconUrl;
-L.Icon.Default.mergeOptions({
-  iconRetinaUrl: 'https://cdnjs.cloudflare.com/ajax/libs/leaflet/1.7.1/images/marker-icon-2x.png',
-  iconUrl: 'https://cdnjs.cloudflare.com/ajax/libs/leaflet/1.7.1/images/marker-icon.png',
-  shadowUrl: 'https://cdnjs.cloudflare.com/ajax/libs/leaflet/1.7.1/images/marker-shadow.png',
-});
-
-const fontAwesomeIcon = L.divIcon({
-  html: '<i class="fa-solid fa-location-dot fa-3x"></i>',
-  iconSize: [20, 20],
-  className: 'myDivIcon'
-});
-
-function MapEvents() {
-  const { dispatch } = useAppContext();
-
-  useMapEvents({
-    click: (e) => {
-      // Add new time series point on map click
+import { useApi } from '../hooks/useApi';
+import { usePointsApi, PointData } from '../hooks/usePointsApi';
+import { useGpsApi } from '../hooks/useGpsApi';
+import { valueToColor } from '../colorscales';
+import { parseUrlState } from '../hooks/useUrlState';
+
+const BASEMAPS: Record<string, { url: string; maxZoom: number }> = {
+  satellite: {
+    url: 'https://mt1.google.com/vt/lyrs=s&x={x}&y={y}&z={z}',
+    maxZoom: 21,
+  },
+  osm: {
+    url: 'https://tile.openstreetmap.org/{z}/{x}/{y}.png',
+    maxZoom: 19,
+  },
+  dark: {
+    url: 'https://basemaps.cartocdn.com/dark_all/{z}/{x}/{y}@2x.png',
+    maxZoom: 20,
+  },
+};
+
+export default function MapContainer() {
+  const { state, dispatch } = useAppContext();
+  const { fetchPoints, fetchPointTimeseries } = usePointsApi();
+  const { fetchPointTimeSeries: fetchRasterPixelTS } = useApi();
+  const { fetchGpsStations, fetchGpsTimeseries } = useGpsApi();
+  const mapContainerRef = useRef<HTMLDivElement>(null);
+  const mapRef = useRef<maplibregl.Map | null>(null);
+  const deckOverlayRef = useRef<MapboxOverlay | null>(null);
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  const deckLayersRef = useRef<any[]>([]);
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  const setDeckLayers = useCallback((layers: any[]) => {
+    deckLayersRef.current = layers;
+    deckOverlayRef.current?.setProps({ layers });
+  }, []);
+  const refMarkerRef = useRef<maplibregl.Marker | null>(null);
+  const deckClickedRef = useRef(false); // Suppress raster click when deck.gl handled it
+  const tsMarkersRef = useRef<maplibregl.Marker[]>([]);
+
+  const [pointData, setPointData] = useState<PointData | null>(null);
+  const [selectedPointId, setSelectedPointId] = useState<number | null>(null);
+  const [pointCount, setPointCount] = useState<number>(0);
+
+  // Read point viz state from global state (controlled by PointControlsPanel)
+  const colorBy = state.pointColorBy;
+  const pointVmin = state.pointVmin;
+  const pointVmax = state.pointVmax;
+  const pointFilter = state.pointFilter;
+  const pointBasemap = state.pointBasemap;
+  const pointColormap = state.pointColormap;
+
+  // Initialize map
+  useEffect(() => {
+    if (!mapContainerRef.current || mapRef.current) return;
+
+    const map = new maplibregl.Map({
+      container: mapContainerRef.current,
+      style: {
+        version: 8,
+        sources: {
+          'basemap': {
+            type: 'raster',
+            tiles: [BASEMAPS.satellite.url],
+            tileSize: 256,
+            maxzoom: BASEMAPS.satellite.maxZoom,
+          }
+        },
+        layers: [{
+          id: 'basemap',
+          type: 'raster',
+          source: 'basemap',
+        }],
+      },
+      center: (() => {
+        const url = parseUrlState();
+        if (url.lon && url.lat) return [parseFloat(url.lon), parseFloat(url.lat)] as [number, number];
+        return [0, 0] as [number, number];
+      })(),
+      zoom: (() => {
+        const url = parseUrlState();
+        return url.zoom ? parseFloat(url.zoom) : 12;
+      })(),
+      maxZoom: 22,
+      // @ts-expect-error preserveDrawingBuffer is a valid WebGL option, not in MapLibre types
+      preserveDrawingBuffer: true, // Needed for map canvas export to PNG
+      attributionControl: false,
+    });
+
+    map.addControl(new maplibregl.NavigationControl(), 'top-right');
+    map.addControl(new maplibregl.AttributionControl({ compact: true }), 'bottom-right');
+
+    // Sync viewport to URL (debounced to avoid writing during fitBounds)
+    let urlSyncEnabled = false;
+    setTimeout(() => { urlSyncEnabled = true; }, 2000);
+    map.on('moveend', () => {
+      if (!urlSyncEnabled) return;
+      const center = map.getCenter();
+      const z = map.getZoom();
+      const params = new URLSearchParams(window.location.search);
+      params.set('lat', center.lat.toFixed(4));
+      params.set('lon', center.lng.toFixed(4));
+      params.set('zoom', z.toFixed(1));
+      window.history.replaceState(null, '', `?${params}`);
+    });
+
+    // Add deck.gl overlay
+    const deckOverlay = new MapboxOverlay({
+      interleaved: false,
+      layers: [],
+    });
+    map.addControl(deckOverlay as unknown as maplibregl.IControl);
+    deckOverlayRef.current = deckOverlay;
+    mapRef.current = map;
+
+    return () => {
+      map.remove();
+      mapRef.current = null;
+      deckOverlayRef.current = null;
+    };
+  }, []);
+
+  // Raster mode: click on map → add time series point → fetch pixel values
+  const hasRasters = Object.keys(state.datasetInfo).length > 0;
+  const hasPointLayer = state.activePointLayer != null;
+
+  useEffect(() => {
+    const map = mapRef.current;
+    if (!map || !hasRasters) return;
+
+    const handleClick = (e: maplibregl.MapMouseEvent) => {
+      // In point layer mode, deck.gl handles clicks — skip raster click
+      if (hasPointLayer) return;
+      // Skip if deck.gl already handled this click (e.g. GPS station)
+      if (deckClickedRef.current) { deckClickedRef.current = false; return; }
+
+      const { lng, lat } = e.lngLat;
       dispatch({
         type: 'ADD_TIME_SERIES_POINT',
-        payload: {
-          position: [e.latlng.lat, e.latlng.lng],
-          name: `Point ${Date.now().toString().slice(-4)}` // Short unique name
-        }
+        payload: { position: [lat, lng] },
       });
-    },
-  });
+      if (!state.showChart) {
+        dispatch({ type: 'TOGGLE_CHART' });
+      }
+    };
 
-  return null;
-}
+    map.on('click', handleClick);
+    return () => { map.off('click', handleClick); };
+  }, [hasRasters, hasPointLayer, state.showChart, dispatch]);
 
-function MousePosition() {
-  const map = useMap();
+  // Raster mode: fetch pixel timeseries for points that don't have data yet
+  useEffect(() => {
+    if (!hasRasters || !state.currentDataset) return;
+
+    for (const point of state.timeSeriesPoints) {
+      if (!point.data?.[state.currentDataset]) {
+        // Fetch pixel values for this point
+        fetchRasterPixelTS(point.position[1], point.position[0], state.currentDataset)
+          .then(values => {
+            if (values) {
+              dispatch({
+                type: 'SET_POINT_DATA',
+                payload: { pointId: point.id, dataset: state.currentDataset, data: values },
+              });
+            }
+          });
+      }
+    }
+  }, [state.timeSeriesPoints, state.currentDataset, hasRasters, fetchRasterPixelTS, dispatch]);
 
+  // Raster mode: draggable reference marker
   useEffect(() => {
-    const mousePositionControl = new MousePositionControl();
-    mousePositionControl.addTo(map);
+    const map = mapRef.current;
+    if (!map || !hasRasters) return;
+
+    // Create or update reference marker
+    if (!refMarkerRef.current) {
+      const el = document.createElement('div');
+      el.style.width = '20px';
+      el.style.height = '20px';
+      el.style.borderRadius = '50%';
+      el.style.background = '#ff4444';
+      el.style.border = '3px solid white';
+      el.style.cursor = 'grab';
+      el.title = 'Reference point (drag to move)';
+
+      const marker = new maplibregl.Marker({ element: el, draggable: true })
+        .setLngLat([state.refMarkerPosition[1], state.refMarkerPosition[0]])
+        .addTo(map);
+
+      marker.on('dragend', async () => {
+        const lngLat = marker.getLngLat();
+        dispatch({
+          type: 'SET_REF_MARKER_POSITION',
+          payload: [lngLat.lat, lngLat.lng],
+        });
+
+        // Fetch reference pixel values for all raster datasets
+        for (const [dsName] of Object.entries(state.datasetInfo)) {
+          const values = await fetchRasterPixelTS(lngLat.lng, lngLat.lat, dsName);
+          if (values) {
+            dispatch({
+              type: 'SET_REF_VALUES',
+              payload: { dataset: dsName, values },
+            });
+          }
+        }
+      });
+
+      refMarkerRef.current = marker;
+
+      // Initial ref value fetch for all datasets
+      for (const [dsName] of Object.entries(state.datasetInfo)) {
+        if (!state.refValues[dsName]) {
+          fetchRasterPixelTS(
+            state.refMarkerPosition[1], state.refMarkerPosition[0], dsName,
+          ).then(values => {
+            if (values) {
+              dispatch({ type: 'SET_REF_VALUES', payload: { dataset: dsName, values } });
+            }
+          });
+        }
+      }
+    } else {
+      refMarkerRef.current.setLngLat([state.refMarkerPosition[1], state.refMarkerPosition[0]]);
+    }
 
     return () => {
-      mousePositionControl.remove();
+      // Don't remove on re-render, only on unmount
     };
-  }, [map]);
+  }, [hasRasters, state.refMarkerPosition, state.datasetInfo, state.refValues, dispatch, fetchRasterPixelTS]);
 
-  return null;
-}
+  // Raster mode: show markers for time series points
+  useEffect(() => {
+    const map = mapRef.current;
+    if (!map) return;
+
+    // Remove old markers
+    tsMarkersRef.current.forEach(m => m.remove());
+    tsMarkersRef.current = [];
+
+    // Add draggable markers for each time series point
+    for (const point of state.timeSeriesPoints) {
+      if (!point.visible) continue;
+      const el = document.createElement('div');
+      el.style.width = '12px';
+      el.style.height = '12px';
+      el.style.borderRadius = '50%';
+      el.style.background = point.color;
+      el.style.border = '2px solid white';
+      el.style.cursor = 'grab';
+
+      const pointId = point.id;
+      const marker = new maplibregl.Marker({ element: el, draggable: true })
+        .setLngLat([point.position[1], point.position[0]])
+        .addTo(map);
+
+      marker.on('dragend', () => {
+        const lngLat = marker.getLngLat();
+        dispatch({
+          type: 'UPDATE_TIME_SERIES_POINT',
+          payload: {
+            id: pointId,
+            updates: { position: [lngLat.lat, lngLat.lng], data: {} },
+          },
+        });
+      });
 
-function RasterTileLayer() {
-  const { state } = useAppContext();
-  const [tileUrl, setTileUrl] = useState<string | null>(null);
+      tsMarkersRef.current.push(marker);
+    }
+  }, [state.timeSeriesPoints, dispatch]);
 
+  // Switch basemap tiles
   useEffect(() => {
-    if (!state.currentDataset || !state.datasetInfo[state.currentDataset]) {
+    const map = mapRef.current;
+    if (!map) return;
+    const basemap = BASEMAPS[pointBasemap];
+    const source = map.getSource('basemap') as maplibregl.RasterTileSource | undefined;
+    if (source) {
+      source.setTiles([basemap.url]);
+    }
+  }, [pointBasemap]);
+
+  // Fit map to data bounds from point layer or raster dataset
+  // Skip if URL already specifies a viewport (shared link)
+  useEffect(() => {
+    const map = mapRef.current;
+    if (!map) return;
+
+    const url = parseUrlState();
+    if (url.lat && url.lon && url.zoom) return; // URL has viewport, skip fitBounds
+
+    // Try point layers first (from manifest loaded via state)
+    if (state.pointLayerBounds) {
+      const [west, south, east, north] = state.pointLayerBounds;
+      map.fitBounds([[west, south], [east, north]], { padding: 50 });
       return;
     }
 
-    const controller = new AbortController();
-    const signal = controller.signal;
+    // Fallback to raster dataset bounds
+    if (state.currentDataset && state.datasetInfo[state.currentDataset]) {
+      const bounds = state.datasetInfo[state.currentDataset].latlon_bounds;
+      map.fitBounds([[bounds[0], bounds[1]], [bounds[2], bounds[3]]], { padding: 50 });
+    }
+  }, [state.pointLayerBounds, state.currentDataset, state.datasetInfo]);
+
+  // Load points when point layer is available
+  useEffect(() => {
+    if (!state.activePointLayer) return;
+
+    const loadPoints = async () => {
+      try {
+        const data = await fetchPoints(state.activePointLayer!, {
+          colorBy,
+          filter: pointFilter || undefined,
+          maxPoints: 200000,
+        });
+        setPointData(data);
+        setPointCount(data.count);
+
+        // Compute histogram for controls panel
+        if (data.count > 0) {
+          const vals = data.colorValues;
+          const min = vals.reduce((a, b) => Math.min(a, b), Infinity);
+          const max = vals.reduce((a, b) => Math.max(a, b), -Infinity);
+          const nBins = 40;
+          const binWidth = (max - min) / nBins || 1;
+          const counts = new Array(nBins).fill(0);
+          const edges = Array.from({ length: nBins + 1 }, (_, i) => min + i * binWidth);
+          for (const v of vals) {
+            const idx = Math.min(Math.floor((v - min) / binWidth), nBins - 1);
+            counts[idx]++;
+          }
+          dispatch({ type: 'SET_POINT_HISTOGRAM', payload: { edges, counts } });
+        }
+      } catch (err) {
+        console.error('Error loading points:', err);
+      }
+    };
 
-    const updateTileLayer = async () => {
-      const currentDatasetInfo = state.datasetInfo[state.currentDataset];
+    loadPoints();
+  }, [state.activePointLayer, colorBy, pointFilter, fetchPoints]);
 
-      // Use ONLY state — DO NOT read localStorage here
-      const colormap = state.colormap;
-      const vmin = state.vmin;
-      const vmax = state.vmax;
+  // Track which point IDs are currently displayed in the chart
+  const clickedPointIds = new Set(state.clickedPoints.map(p => p.pointId));
 
-      // Ensure time index is within bounds
-      const maxIdx = currentDatasetInfo.x_values.length - 1;
-      const timeIdx = Math.max(0, Math.min(state.currentTimeIndex, maxIdx));
+  // Handle point click → fetch timeseries
+  // shiftKey=true adds to selection, ctrlKey=true sets reference point
+  const onPointClick = useCallback(async (pointId: number, shiftKey: boolean, ctrlKey: boolean) => {
+    if (!state.activePointLayer) return;
+    setSelectedPointId(pointId);
 
-      // Build parameters
-      const params: Record<string, string> = {
-        variable: state.currentDataset,
-        time_idx: timeIdx.toString(),
-        rescale: `${vmin},${vmax}`,
-        colormap_name: colormap,
-      };
+    try {
+      const ts = await fetchPointTimeseries(state.activePointLayer, pointId);
 
-      // Add algorithm if needed
-      if (currentDatasetInfo.algorithm) {
-        params.algorithm = currentDatasetInfo.algorithm;
+      if (ctrlKey) {
+        // Ctrl+click → set as reference point
+        dispatch({ type: 'SET_REFERENCE_POINT', payload: { pointId, timeseries: ts } });
+        return;
       }
 
-      // Add shift for reference point if available
-      if (state.refValues[state.currentDataset] && currentDatasetInfo.algorithm === 'shift') {
-        const shift = state.refValues[state.currentDataset][timeIdx];
-        if (shift !== undefined) {
-          params.algorithm_params = JSON.stringify({ shift });
-        }
+      // If not shift-clicking, clear previous selections first
+      if (!shiftKey) {
+        dispatch({ type: 'CLEAR_CLICKED_POINTS' });
       }
 
-      // Add URL parameter for COG mode
-      if (state.dataMode === 'cog') {
-        const url = currentDatasetInfo.file_list[timeIdx];
-        const maskUrl = currentDatasetInfo.mask_file_list[timeIdx];
-        const maskMinValue = currentDatasetInfo.mask_min_value;
+      dispatch({
+        type: 'SET_CLICKED_POINT_TIMESERIES',
+        payload: { pointId, timeseries: ts },
+      });
+    } catch (err) {
+      console.error('Error fetching timeseries:', err);
+    }
+  }, [state.activePointLayer, fetchPointTimeseries, dispatch]);
 
-        params.url = url;
-        if (maskUrl) params.mask = encodeURIComponent(maskUrl);
-        if (maskMinValue !== undefined) params.mask_min_value = maskMinValue.toString();
-      }
+  // Update deck.gl layers whenever point data changes
+  useEffect(() => {
+    const overlay = deckOverlayRef.current;
+    if (!overlay) return;
+
+    // If no point data or points layer hidden, remove point cloud but keep others
+    if (!pointData || !state.pointLayerVisible) {
+      const existing = deckLayersRef.current;
+      const otherLayers = (existing as Array<{ id?: string }>).filter(l => l.id !== 'point-cloud');
+      setDeckLayers(otherLayers);
+      return;
+    }
 
-      const urlParams = new URLSearchParams(params).toString();
-      const endpoint = state.dataMode === 'md'
-        ? `/md/WebMercatorQuad/tilejson.json?${urlParams}`
-        : `/cog/WebMercatorQuad/tilejson.json?${urlParams}`;
+    const positions = new Float64Array(pointData.count * 2);
+    for (let i = 0; i < pointData.count; i++) {
+      positions[i * 2] = pointData.lon[i];
+      positions[i * 2 + 1] = pointData.lat[i];
+    }
 
-      try {
-        const response = await fetch(endpoint, { signal });
-        if (!response.ok) throw new Error(`HTTP ${response.status}`);
-        const tileInfo = await response.json();
-        // Only set if not aborted
-        if (!signal.aborted) setTileUrl(tileInfo.tiles[0]);
-      } catch (err) {
-        if ((err as any).name !== 'AbortError') {
-          console.error('Error fetching tile info:', err);
+    const layer = new ScatterplotLayer({
+      id: 'point-cloud',
+      data: {
+        length: pointData.count,
+        attributes: {
+          getPosition: { value: positions, size: 2 },
+        },
+      },
+      getPosition: (_, { index }) => [pointData.lon[index], pointData.lat[index]],
+      opacity: state.pointOpacity,
+      getFillColor: (_, { index }) => {
+        const pid = pointData.point_id[index];
+        if (pid === state.referencePointId) {
+          return [0, 255, 128, 255]; // Green for reference point
         }
-      }
+        if (clickedPointIds.has(pid)) {
+          return [255, 255, 0, 255]; // Yellow for selected/clicked
+        }
+        const v = pointData.colorValues[index];
+        return valueToColor(v, pointVmin, pointVmax, pointColormap);
+      },
+      getRadius: (_, { index }) => {
+        const pid = pointData.point_id[index];
+        if (pid === state.referencePointId) return 7;
+        if (clickedPointIds.has(pid)) return 5;
+        return 3;
+      },
+      radiusMinPixels: 2,
+      radiusMaxPixels: 14,
+      pickable: true,
+      onClick: (info, event) => {
+        if (info.index >= 0) {
+          const srcEvent = (event as unknown as { srcEvent?: MouseEvent }).srcEvent;
+          const shiftKey = srcEvent?.shiftKey ?? false;
+          const ctrlKey = srcEvent?.ctrlKey ?? srcEvent?.metaKey ?? false;
+          onPointClick(pointData.point_id[info.index], shiftKey, ctrlKey);
+        }
+      },
+      updateTriggers: {
+        getFillColor: [pointVmin, pointVmax, pointColormap, state.referencePointId, ...clickedPointIds],
+        getRadius: [state.referencePointId, ...clickedPointIds],
+      },
+    });
+
+    // Preserve GPS layer when updating point cloud layer
+    const existing = deckLayersRef.current;
+    const otherLayers = (existing as Array<{ id?: string }>).filter(l => l.id !== 'point-cloud');
+    setDeckLayers([layer, ...otherLayers]);
+  }, [pointData, pointVmin, pointVmax, pointColormap, selectedPointId, onPointClick,
+      state.pointLayerVisible, state.pointOpacity]);
+
+  // GPS: fetch stations on moveend when GPS is visible (debounced)
+  useEffect(() => {
+    const map = mapRef.current;
+    if (!map || !state.gpsVisible) return;
+
+    let debounceTimer: ReturnType<typeof setTimeout>;
+    const fetchStations = () => {
+      clearTimeout(debounceTimer);
+      debounceTimer = setTimeout(async () => {
+        const bounds = map.getBounds();
+        dispatch({ type: 'SET_GPS_LOADING', payload: true });
+        const stations = await fetchGpsStations([
+          bounds.getWest(), bounds.getSouth(),
+          bounds.getEast(), bounds.getNorth(),
+        ]);
+        dispatch({ type: 'SET_GPS_STATIONS', payload: stations });
+      }, 500);
     };
 
-    updateTileLayer();
-    return () => controller.abort();
-  }, [
-    state.currentDataset,
-    state.currentTimeIndex,
-    state.datasetInfo,
-    state.dataMode,
-    state.refValues,
-    state.refMarkerPosition,
-    state.colormap,
-    state.vmin,
-    state.vmax
-  ]);
-
-  if (!tileUrl) return null;
+    // Fetch immediately + on subsequent moves
+    fetchStations();
+    map.on('moveend', fetchStations);
+    return () => {
+      clearTimeout(debounceTimer);
+      map.off('moveend', fetchStations);
+    };
+  }, [state.gpsVisible, fetchGpsStations, dispatch]);
+
+  // GPS: click handler for stations
+  const onGpsStationClick = useCallback(async (stationId: string) => {
+    deckClickedRef.current = true; // Suppress raster click handler
+    dispatch({ type: 'SET_GPS_SELECTED_STATION', payload: stationId });
+    const data = await fetchGpsTimeseries(stationId);
+    if (data) {
+      dispatch({ type: 'SET_GPS_TIMESERIES', payload: data.timeseries });
+    }
+  }, [fetchGpsTimeseries, dispatch]);
 
-  return (
-    <TileLayer
-      key={tileUrl}  // force refresh if URL changes
-      url={tileUrl}
-      opacity={state.opacity}
-      maxZoom={19}
-    />
-  );
-}
+  // GPS: render station markers as a separate deck.gl layer
+  useEffect(() => {
+    const overlay = deckOverlayRef.current;
+    if (!overlay) return;
 
-function MarkerEventHandlers() {
-  const { state, dispatch } = useAppContext();
-  const { fetchPointTimeSeries } = useApi();
-  const map = useMap();
-
-  const handleMarkerClick = (position: [number, number], pointName?: string) => {
-    const [lat, lng] = position;
-    const content = pointName
-      ? `${pointName} (lon, lat):\n(${lng.toFixed(6)}, ${lat.toFixed(6)})`
-      : `Reference (lon, lat):\n(${lng.toFixed(6)}, ${lat.toFixed(6)})`;
-    L.popup()
-      .setLatLng([lat, lng])
-      .setContent(content)
-      .openOn(map);
-  };
-
-  const handleTsMarkerDragEnd = (pointId: string) => (e: L.DragEndEvent) => {
-    const marker = e.target;
-    const position = marker.getLatLng();
-    dispatch({
-      type: 'UPDATE_TIME_SERIES_POINT',
-      payload: {
-        id: pointId,
-        updates: { position: [position.lat, position.lng] }
-      }
-    });
-  };
-
-  const handleRefMarkerDragEnd = async (e: L.DragEndEvent) => {
-    const marker = e.target;
-    const position = marker.getLatLng();
-    const lat = position.lat;
-    const lng = position.lng;
-    // 1) update position in state
-    dispatch({ type: 'SET_REF_MARKER_POSITION', payload: [lat, lng] });
-
-    // 2) if current dataset uses the "shift" algo, recompute ref values
-    const ds = state.currentDataset;
-    const info = ds ? state.datasetInfo[ds] : null;
-    if (ds && info?.algorithm === 'shift') {
-      try {
-        const values = await fetchPointTimeSeries(lng, lat, ds);
-        if (values) {
-          dispatch({
-            type: 'SET_REF_VALUES',
-            payload: { dataset: ds, values },
-          });
-        }
-      } catch (err) {
-        console.error('Error updating reference values after drag:', err);
-      }
+    // Get existing layers (point cloud)
+    const existingLayers = deckLayersRef.current;
+    const nonGpsLayers = (existingLayers as Array<{ id?: string }>).filter(l => l.id !== 'gps-stations');
+
+    if (!state.gpsVisible || state.gpsStations.length === 0) {
+      setDeckLayers(nonGpsLayers);
+      return;
     }
-  };
-
-  const handleTsMarkerDoubleClick = (pointId: string) => () => {
-    // Double-click to remove point
-    dispatch({ type: 'REMOVE_TIME_SERIES_POINT', payload: pointId });
-  };
-
-  // Create custom colored icons for each point
-  const createColoredIcon = (color: string, isSelected: boolean = false) => {
-    const iconSize = isSelected ? 25 : 20;
-    return L.divIcon({
-      html: `<div style="
-        width: ${iconSize}px;
-        height: ${iconSize}px;
-        background-color: ${color};
-        border: ${isSelected ? '3px solid white' : '2px solid white'};
-        border-radius: 50%;
-        box-shadow: 0 2px 4px rgba(0,0,0,0.3);
-      "></div>`,
-      iconSize: [iconSize, iconSize],
-      className: 'custom-colored-marker'
+
+    const gpsLayer = new ScatterplotLayer({
+      id: 'gps-stations',
+      data: state.gpsStations,
+      getPosition: (d) => [d.lon, d.lat],
+      getFillColor: (d) =>
+        d.id === state.gpsSelectedStationId
+          ? [255, 255, 0, 255]   // Selected: yellow
+          : [34, 170, 102, 230], // Default: green
+      getRadius: 8,
+      radiusMinPixels: 6,
+      radiusMaxPixels: 16,
+      stroked: true,
+      getLineColor: [255, 255, 255, 200],
+      getLineWidth: 2,
+      lineWidthMinPixels: 2,
+      pickable: true,
+      onClick: (info) => {
+        if (info.object) {
+          onGpsStationClick(info.object.id);
+        }
+      },
+      updateTriggers: {
+        getFillColor: [state.gpsSelectedStationId],
+      },
     });
-  };
 
-  return (
-    <>
-      {/* Time Series Points */}
-      {state.timeSeriesPoints.filter(p => p.visible).map((point) => (
-        <Marker
-          key={point.id}
-          position={point.position}
-          icon={createColoredIcon(point.color, state.selectedPointId === point.id)}
-          draggable
-          title={`${point.name} - Double-click to remove`}
-          eventHandlers={{
-            click: () => {
-              handleMarkerClick(point.position, point.name);
-              dispatch({ type: 'SET_SELECTED_POINT', payload: point.id });
-            },
-            dragend: handleTsMarkerDragEnd(point.id),
-            dblclick: handleTsMarkerDoubleClick(point.id),
-          }}
-        />
-      ))}
-
-      {/* Reference Marker */}
-      <Marker
-        position={state.refMarkerPosition}
-        icon={fontAwesomeIcon}
-        draggable
-        title="Reference Location"
-        eventHandlers={{
-          click: () => handleMarkerClick(state.refMarkerPosition),
-          dragend: handleRefMarkerDragEnd,
-        }}
-      />
-    </>
-  );
-}
+    setDeckLayers([...nonGpsLayers, gpsLayer]);
+  }, [state.gpsVisible, state.gpsStations, state.gpsSelectedStationId, onGpsStationClick]);
 
-export default function MapContainer() {
-  const { state } = useAppContext();
+  // Raster tile layer visibility toggle
+  useEffect(() => {
+    const map = mapRef.current;
+    if (!map) return;
+    const layer = map.getLayer('raster-layer');
+    if (layer) {
+      map.setLayoutProperty('raster-layer', 'visibility',
+        state.rasterLayerVisible ? 'visible' : 'none');
+    }
+  }, [state.rasterLayerVisible]);
 
-  // Calculate initial center from first dataset bounds
-  const getInitialCenter = (): [number, number] => {
-    if (state.currentDataset && state.datasetInfo[state.currentDataset]) {
-      const bounds = state.datasetInfo[state.currentDataset].latlon_bounds;
-      const centerLat = (bounds[1] + bounds[3]) / 2;
-      const centerLng = (bounds[0] + bounds[2]) / 2;
-      return [centerLat, centerLng];
+  // Raster tile layer for V1 datasets
+  useEffect(() => {
+    const map = mapRef.current;
+    if (!map || !state.currentDataset || !state.datasetInfo[state.currentDataset]) return;
+
+    // Ensure map style is loaded before adding sources
+    const addRasterLayer = () => {
+
+    const currentDatasetInfo = state.datasetInfo[state.currentDataset];
+    const maxIdx = currentDatasetInfo.x_values.length - 1;
+    const timeIdx = Math.max(0, Math.min(state.currentTimeIndex, maxIdx));
+
+    const params: Record<string, string> = {
+      variable: state.currentDataset,
+      time_idx: timeIdx.toString(),
+      rescale: `${state.vmin},${state.vmax}`,
+      colormap_name: state.colormap,
+    };
+
+    if (currentDatasetInfo.algorithm) {
+      params.algorithm = currentDatasetInfo.algorithm;
+    }
+
+    if (state.refValues[state.currentDataset] && currentDatasetInfo.algorithm === 'shift') {
+      const shift = state.refValues[state.currentDataset][timeIdx];
+      if (shift !== undefined) {
+        params.algorithm_params = JSON.stringify({ shift });
+      }
     }
 
-    // If no current dataset, try to get bounds from any available dataset
-    const datasets = Object.values(state.datasetInfo);
-    if (datasets.length > 0) {
-      const bounds = datasets[0].latlon_bounds;
-      const centerLat = (bounds[1] + bounds[3]) / 2;
-      const centerLng = (bounds[0] + bounds[2]) / 2;
-      return [centerLat, centerLng];
+    if (state.dataMode === 'cog') {
+      params.url = currentDatasetInfo.file_list[timeIdx];
+      const maskUrl = currentDatasetInfo.mask_file_list[timeIdx];
+      if (maskUrl) params.mask = encodeURIComponent(maskUrl);
+      if (currentDatasetInfo.mask_min_value !== undefined) {
+        params.mask_min_value = currentDatasetInfo.mask_min_value.toString();
+      }
     }
 
-    return [0, 0];
-  };
+    const urlParams = new URLSearchParams(params).toString();
+    const endpoint = state.dataMode === 'md' ? 'md' : 'cog';
+    const tileUrl = `/${endpoint}/tiles/WebMercatorQuad/{z}/{x}/{y}.png?${urlParams}`;
+
+    // Add or update raster source
+    if (map.getSource('raster-tiles')) {
+      (map.getSource('raster-tiles') as maplibregl.RasterTileSource).setTiles([tileUrl]);
+    } else {
+      map.addSource('raster-tiles', {
+        type: 'raster',
+        tiles: [tileUrl],
+        tileSize: 256,
+      });
+      map.addLayer({
+        id: 'raster-layer',
+        type: 'raster',
+        source: 'raster-tiles',
+        paint: { 'raster-opacity': state.opacity },
+      }, map.getLayer('basemap') ? undefined : undefined);
+    }
 
-  const selectedBasemap = baseMaps[state.selectedBasemap] || baseMaps.esriSatellite;
+      // Update opacity
+      if (map.getLayer('raster-layer')) {
+        map.setPaintProperty('raster-layer', 'raster-opacity', state.opacity);
+      }
+    };
 
-  const center = getInitialCenter();
-  const hasDatasets = Object.keys(state.datasetInfo).length > 0;
+    if (map.isStyleLoaded()) {
+      addRasterLayer();
+    } else {
+      map.once('load', addRasterLayer);
+    }
+  }, [state.currentDataset, state.currentTimeIndex, state.datasetInfo, state.dataMode,
+      state.refValues, state.colormap, state.vmin, state.vmax, state.opacity]);
 
   return (
-    <LeafletMapContainer
-      key={hasDatasets ? 'with-data' : 'no-data'} // Force re-render when data loads
-      center={center}
-      zoom={9}
-      style={{ height: '100%', width: '100%' }}
-      doubleClickZoom={false}
-    >
-      <TileLayer
-        url={selectedBasemap.url}
-        attribution={selectedBasemap.attribution}
-        maxZoom={19}
-      />
-      <RasterTileLayer />
-      <MarkerEventHandlers />
-      <MapEvents />
-      <MousePosition />
-    </LeafletMapContainer>
+    <div style={{ position: 'relative', width: '100%', height: '100%' }}>
+      <div ref={mapContainerRef} style={{ width: '100%', height: '100%' }} />
+
+      {/* Stats overlay */}
+      {pointCount > 0 && (
+        <div style={{
+          position: 'absolute', bottom: 30, left: 10,
+          background: 'rgba(0,0,0,0.7)', color: '#fff',
+          padding: '6px 10px', borderRadius: 4, fontSize: 12,
+          zIndex: 10, fontFamily: 'monospace',
+        }}>
+          {pointCount.toLocaleString()} points | color: {colorBy}
+          | [{pointVmin.toFixed(1)}, {pointVmax.toFixed(1)}]
+          {state.clickedPoints.length > 0 && ` | ${state.clickedPoints.length} selected`}
+          {state.referencePointId != null && ` | ref: ${state.referencePointId}`}
+          {state.clickedPoints.length === 0 && ' | click: TS, shift: compare, ctrl: ref'}
+        </div>
+      )}
+    </div>
   );
 }
diff --git a/src/components/PointControlsPanel.tsx b/src/components/PointControlsPanel.tsx
new file mode 100644
index 0000000..6962124
--- /dev/null
+++ b/src/components/PointControlsPanel.tsx
@@ -0,0 +1,666 @@
+import { useState, useRef, useMemo, useEffect } from 'react';
+import { useAppContext } from '../context/AppContext';
+import { COLORMAP_NAMES, colormapGradientCSS, valueToColor } from '../colorscales';
+
+const FILTER_OPERATORS = ['>', '<', '>=', '<=', '='] as const;
+
+const RASTER_COLORMAPS = [
+  { value: 'rdbu_r', label: 'Blue-Red' },
+  { value: 'viridis', label: 'Viridis' },
+  { value: 'magma', label: 'Magma' },
+  { value: 'twilight', label: 'Twilight (cyclic)' },
+  { value: 'cfastie', label: 'CFastie' },
+  { value: 'rplumbo', label: 'RPlumbo' },
+  { value: 'schwarzwald', label: 'Schwarzwald' },
+  { value: 'bugn', label: 'Blue-Green' },
+  { value: 'ylgn', label: 'Yellow-Green' },
+  { value: 'gist_earth', label: 'Earth' },
+  { value: 'terrain', label: 'Terrain' },
+];
+
+const inputStyle = {
+  width: '100%',
+  padding: '3px 5px',
+  background: '#2a2a4a',
+  color: '#ddd',
+  border: '1px solid #444',
+  borderRadius: 3,
+  fontSize: 12,
+  boxSizing: 'border-box' as const,
+};
+
+const selectStyle = {
+  ...inputStyle,
+  padding: '4px 6px',
+};
+
+const labelStyle = { fontSize: 11, color: '#aaa', display: 'block' as const, marginBottom: 2 };
+
+const sectionGap = { marginBottom: 10 };
+
+const basemapLabels: Record<string, string> = {
+  satellite: 'Satellite',
+  osm: 'OpenStreetMap',
+  dark: 'Dark',
+};
+
+function MiniHistogram({ histogram, vmin, vmax, colormap }: {
+  histogram: { edges: number[]; counts: number[] };
+  vmin: number; vmax: number; colormap: string;
+}) {
+  const { edges, counts } = histogram;
+  const maxCount = Math.max(...counts, 1);
+  const nBins = counts.length;
+  const svgW = 220;
+  const svgH = 36;
+  const barW = svgW / nBins;
+
+  const bars = useMemo(() => counts.map((count, i) => {
+    const midVal = (edges[i] + edges[i + 1]) / 2;
+    const [r, g, b] = valueToColor(midVal, vmin, vmax, colormap);
+    const h = (count / maxCount) * svgH;
+    return { x: i * barW, h, fill: `rgb(${r},${g},${b})` };
+  }), [counts, edges, vmin, vmax, colormap, maxCount, barW]);
+
+  return (
+    <div style={{ marginBottom: 6 }}>
+      <svg width={svgW} height={svgH} style={{ display: 'block' }}>
+        {bars.map((bar, i) => (
+          <rect
+            key={i}
+            x={bar.x}
+            y={svgH - bar.h}
+            width={Math.max(barW - 0.5, 1)}
+            height={bar.h}
+            fill={bar.fill}
+            opacity={0.8}
+          />
+        ))}
+      </svg>
+    </div>
+  );
+}
+
+export default function PointControlsPanel() {
+  const { state, dispatch } = useAppContext();
+  const [draftVmin, setDraftVmin] = useState(String(state.pointVmin));
+  const [draftVmax, setDraftVmax] = useState(String(state.pointVmax));
+  const [exportWithTs, setExportWithTs] = useState(false);
+
+  // Raster vmin/vmax drafts
+  const [draftRasterVmin, setDraftRasterVmin] = useState(String(state.vmin));
+  const [draftRasterVmax, setDraftRasterVmax] = useState(String(state.vmax));
+
+  // Persist raster colormap/vmin/vmax to localStorage per dataset
+  useEffect(() => {
+    const ds = state.currentDataset;
+    if (!ds) return;
+    localStorage.setItem(`${ds}-colormap_name`, state.colormap);
+    localStorage.setItem(`${ds}-vmin`, String(state.vmin));
+    localStorage.setItem(`${ds}-vmax`, String(state.vmax));
+  }, [state.colormap, state.vmin, state.vmax, state.currentDataset]);
+
+  // Restore raster prefs from localStorage on dataset change
+  useEffect(() => {
+    const ds = state.currentDataset;
+    if (!ds) return;
+    const cmap = localStorage.getItem(`${ds}-colormap_name`);
+    const vminStr = localStorage.getItem(`${ds}-vmin`);
+    const vmaxStr = localStorage.getItem(`${ds}-vmax`);
+    if (cmap) dispatch({ type: 'SET_COLORMAP', payload: cmap });
+    if (vminStr) {
+      const v = Number(vminStr);
+      if (!isNaN(v)) { dispatch({ type: 'SET_VMIN', payload: v }); setDraftRasterVmin(vminStr); }
+    }
+    if (vmaxStr) {
+      const v = Number(vmaxStr);
+      if (!isNaN(v)) { dispatch({ type: 'SET_VMAX', payload: v }); setDraftRasterVmax(vmaxStr); }
+    }
+  }, [state.currentDataset, dispatch]);
+
+  // Filter draft state
+  const [filterAttr, setFilterAttr] = useState('');
+  const [filterOp, setFilterOp] = useState<string>('>');
+  const [filterVal, setFilterVal] = useState('');
+  const [activeFilters, setActiveFilters] = useState<string[]>([]);
+  const filterInputRef = useRef<HTMLInputElement>(null);
+
+  // Only show numeric (non-geometry, non-id) attributes in dropdowns
+  const numericAttrs = Object.entries(state.pointAttributes).filter(
+    ([name, info]) =>
+      name !== 'geometry' &&
+      name !== 'point_id' &&
+      name !== 'longitude' &&
+      name !== 'latitude' &&
+      (info.type.includes('FLOAT') || info.type.includes('DOUBLE') || info.type.includes('INT'))
+  );
+
+  const handleColorByChange = (value: string) => {
+    dispatch({ type: 'SET_POINT_COLOR_BY', payload: value });
+    const attr = state.pointAttributes[value];
+    if (attr?.min != null && attr?.max != null) {
+      if (value.includes('velocity')) {
+        const absMax = Math.max(Math.abs(attr.min), Math.abs(attr.max));
+        dispatch({ type: 'SET_POINT_VMIN', payload: -absMax });
+        dispatch({ type: 'SET_POINT_VMAX', payload: absMax });
+        setDraftVmin((-absMax).toFixed(2));
+        setDraftVmax(absMax.toFixed(2));
+      } else {
+        dispatch({ type: 'SET_POINT_VMIN', payload: attr.min });
+        dispatch({ type: 'SET_POINT_VMAX', payload: attr.max });
+        setDraftVmin(attr.min.toFixed(2));
+        setDraftVmax(attr.max.toFixed(2));
+      }
+    }
+  };
+
+  const commitVmin = () => {
+    const v = parseFloat(draftVmin);
+    if (!isNaN(v)) dispatch({ type: 'SET_POINT_VMIN', payload: v });
+  };
+
+  const commitVmax = () => {
+    const v = parseFloat(draftVmax);
+    if (!isNaN(v)) dispatch({ type: 'SET_POINT_VMAX', payload: v });
+  };
+
+  const addFilter = () => {
+    if (!effectiveFilterAttr || !filterVal) return;
+    const v = parseFloat(filterVal);
+    if (isNaN(v)) return;
+    const expr = `${effectiveFilterAttr}${filterOp}${v}`;
+    const next = [...activeFilters, expr];
+    setActiveFilters(next);
+    dispatch({ type: 'SET_POINT_FILTER', payload: next.join(' AND ') });
+    setFilterVal('');
+    filterInputRef.current?.focus();
+  };
+
+  const removeFilter = (index: number) => {
+    const next = activeFilters.filter((_, i) => i !== index);
+    setActiveFilters(next);
+    dispatch({ type: 'SET_POINT_FILTER', payload: next.join(' AND ') });
+  };
+
+  const clearFilters = () => {
+    setActiveFilters([]);
+    dispatch({ type: 'SET_POINT_FILTER', payload: '' });
+  };
+
+  const currentAttr = state.pointAttributes[state.pointColorBy];
+  const pointCount = currentAttr?.count;
+  const hasPoints = state.activePointLayer != null;
+  const hasRasters = Object.keys(state.datasetInfo).length > 0;
+
+  // Set default filter attribute (only when point data is available)
+  const effectiveFilterAttr = filterAttr || (numericAttrs.length > 0 ? numericAttrs[0][0] : '');
+
+  return (
+    <div style={{
+      position: 'absolute', top: 10, left: 10, zIndex: 100,
+      background: 'rgba(20, 20, 40, 0.92)', color: '#ddd',
+      borderRadius: 6, padding: '10px 14px',
+      fontSize: 13, fontFamily: 'system-ui, sans-serif',
+      minWidth: 240, maxWidth: 280, backdropFilter: 'blur(8px)',
+      border: '1px solid rgba(255,255,255,0.1)',
+      maxHeight: 'calc(100vh - 40px)', overflowY: 'auto',
+    }}>
+      {/* Header */}
+      <div style={{ fontWeight: 600, marginBottom: 8, fontSize: 14 }}>
+        Layers
+      </div>
+
+      {/* Layer toggles */}
+      <div style={sectionGap}>
+        {/* Point layer toggle */}
+        {hasPoints && (
+          <label style={{ display: 'flex', alignItems: 'center', gap: 6, fontSize: 12, cursor: 'pointer', marginBottom: 4 }}>
+            <input
+              type="checkbox"
+              checked={state.pointLayerVisible}
+              onChange={e => dispatch({ type: 'SET_POINT_LAYER_VISIBLE', payload: e.target.checked })}
+              style={{ accentColor: '#5566cc' }}
+            />
+            <span>Points</span>
+            {pointCount != null && (
+              <span style={{ color: '#999', fontSize: 11 }}>
+                ({pointCount.toLocaleString()})
+              </span>
+            )}
+          </label>
+        )}
+
+        {/* Raster layer toggle + controls */}
+        {hasRasters && (
+          <>
+            <label style={{ display: 'flex', alignItems: 'center', gap: 6, fontSize: 12, cursor: 'pointer', marginBottom: 4 }}>
+              <input
+                type="checkbox"
+                checked={state.rasterLayerVisible}
+                onChange={e => dispatch({ type: 'SET_RASTER_LAYER_VISIBLE', payload: e.target.checked })}
+                style={{ accentColor: '#5566cc' }}
+              />
+              <span>Raster</span>
+            </label>
+
+            {/* Raster controls (collapsed when hidden) */}
+            {state.rasterLayerVisible && (
+              <div style={{ paddingLeft: 20, marginBottom: 4 }}>
+                {/* Dataset selector */}
+                <select
+                  value={state.currentDataset}
+                  onChange={e => dispatch({ type: 'SET_CURRENT_DATASET', payload: e.target.value })}
+                  style={{ ...selectStyle, marginBottom: 4 }}
+                >
+                  {Object.keys(state.datasetInfo).map(name => (
+                    <option key={name} value={name}>{name}</option>
+                  ))}
+                </select>
+
+                {/* Time slider */}
+                {state.datasetInfo[state.currentDataset] && (
+                  <div style={{ marginBottom: 4 }}>
+                    <label style={{ ...labelStyle, display: 'flex', justifyContent: 'space-between' }}>
+                      <span>Time</span>
+                      <span style={{ fontSize: 10 }}>
+                        {state.datasetInfo[state.currentDataset].x_values[state.currentTimeIndex]}
+                      </span>
+                    </label>
+                    <input
+                      type="range"
+                      min="0"
+                      max={state.datasetInfo[state.currentDataset].x_values.length - 1}
+                      step="1"
+                      value={state.currentTimeIndex}
+                      onChange={e => dispatch({ type: 'SET_TIME_INDEX', payload: parseInt(e.target.value) })}
+                      style={{ width: '100%' }}
+                    />
+                  </div>
+                )}
+
+                {/* Raster colormap */}
+                <div style={{ marginBottom: 4 }}>
+                  <label style={labelStyle}>Colormap</label>
+                  <select
+                    value={state.colormap}
+                    onChange={e => dispatch({ type: 'SET_COLORMAP', payload: e.target.value })}
+                    style={selectStyle}
+                  >
+                    {RASTER_COLORMAPS.map(opt => (
+                      <option key={opt.value} value={opt.value}>{opt.label}</option>
+                    ))}
+                  </select>
+                  <img
+                    src={`/colorbar/${state.colormap}`}
+                    style={{ width: '100%', height: 12, borderRadius: 2, marginTop: 2 }}
+                    alt="Raster colorbar"
+                  />
+                </div>
+
+                {/* Raster vmin/vmax */}
+                <div style={{ display: 'flex', gap: 6, marginBottom: 4 }}>
+                  <div style={{ flex: 1 }}>
+                    <label style={labelStyle}>Min</label>
+                    <input
+                      type="number" step="any"
+                      value={draftRasterVmin}
+                      onChange={e => setDraftRasterVmin(e.target.value)}
+                      onBlur={() => { const v = parseFloat(draftRasterVmin); if (!isNaN(v)) dispatch({ type: 'SET_VMIN', payload: v }); }}
+                      onKeyDown={e => { if (e.key === 'Enter') { const v = parseFloat(draftRasterVmin); if (!isNaN(v)) dispatch({ type: 'SET_VMIN', payload: v }); } }}
+                      style={inputStyle}
+                    />
+                  </div>
+                  <div style={{ flex: 1 }}>
+                    <label style={labelStyle}>Max</label>
+                    <input
+                      type="number" step="any"
+                      value={draftRasterVmax}
+                      onChange={e => setDraftRasterVmax(e.target.value)}
+                      onBlur={() => { const v = parseFloat(draftRasterVmax); if (!isNaN(v)) dispatch({ type: 'SET_VMAX', payload: v }); }}
+                      onKeyDown={e => { if (e.key === 'Enter') { const v = parseFloat(draftRasterVmax); if (!isNaN(v)) dispatch({ type: 'SET_VMAX', payload: v }); } }}
+                      style={inputStyle}
+                    />
+                  </div>
+                </div>
+
+                {/* Raster opacity */}
+                <div style={{ marginBottom: 4 }}>
+                  <label style={{ ...labelStyle, display: 'flex', justifyContent: 'space-between' }}>
+                    <span>Opacity</span>
+                    <span>{state.opacity.toFixed(2)}</span>
+                  </label>
+                  <input
+                    type="range"
+                    min="0" max="1" step="0.05"
+                    value={state.opacity}
+                    onChange={e => dispatch({ type: 'SET_OPACITY', payload: parseFloat(e.target.value) })}
+                    style={{ width: '100%' }}
+                  />
+                </div>
+
+                {/* Show timeseries button (raster click mode) */}
+                <button
+                  onClick={() => dispatch({ type: 'TOGGLE_CHART' })}
+                  style={{
+                    width: '100%', padding: '4px 8px', fontSize: 11, cursor: 'pointer',
+                    background: state.showChart ? '#5566cc' : '#2a2a4a',
+                    color: state.showChart ? '#fff' : '#ccc',
+                    border: '1px solid #444', borderRadius: 3,
+                  }}
+                >
+                  {state.showChart ? 'Hide time series' : 'Show time series'}
+                </button>
+              </div>
+            )}
+          </>
+        )}
+
+        {/* Point opacity slider */}
+        {hasPoints && state.pointLayerVisible && (
+          <div style={{ marginTop: 4 }}>
+            <label style={{ ...labelStyle, display: 'flex', justifyContent: 'space-between' }}>
+              <span>Point opacity</span>
+              <span>{state.pointOpacity.toFixed(2)}</span>
+            </label>
+            <input
+              type="range"
+              min="0" max="1" step="0.05"
+              value={state.pointOpacity}
+              onChange={e => dispatch({ type: 'SET_POINT_OPACITY', payload: parseFloat(e.target.value) })}
+              style={{ width: '100%' }}
+            />
+          </div>
+        )}
+
+        {/* GPS station toggle — only show when LOS config is available */}
+        {state.gpsLosInfo && (
+          <>
+            <label style={{ display: 'flex', alignItems: 'center', gap: 6, fontSize: 12, cursor: 'pointer', marginBottom: 4 }}>
+              <input
+                type="checkbox"
+                checked={state.gpsVisible}
+                onChange={e => dispatch({ type: 'SET_GPS_VISIBLE', payload: e.target.checked })}
+                style={{ accentColor: '#22aa66' }}
+              />
+              <span>GPS stations</span>
+              {state.gpsLoading && (
+                <span style={{ color: '#888', fontSize: 10 }}>loading...</span>
+              )}
+              {!state.gpsLoading && state.gpsStations.length > 0 && (
+                <span style={{ color: '#999', fontSize: 11 }}>
+                  ({state.gpsStations.length})
+                </span>
+              )}
+            </label>
+
+            {/* GPS component selector */}
+            {state.gpsVisible && state.gpsTimeseries.length > 0 && (
+              <div style={{ paddingLeft: 20, marginBottom: 4 }}>
+                <label style={labelStyle}>Component</label>
+                <div style={{ display: 'flex', gap: 3 }}>
+                  {(['los', 'east', 'north', 'up'] as const).map(comp => (
+                    <button
+                      key={comp}
+                      onClick={() => dispatch({ type: 'SET_GPS_COMPONENT', payload: comp })}
+                      style={{
+                        flex: 1, padding: '2px 4px', fontSize: 10, cursor: 'pointer',
+                        background: state.gpsComponent === comp ? '#2a6a4a' : '#2a2a4a',
+                        color: state.gpsComponent === comp ? '#afa' : '#aaa',
+                        border: state.gpsComponent === comp ? '1px solid #4a8a6a' : '1px solid #444',
+                        borderRadius: 3, textTransform: 'uppercase',
+                      }}
+                    >
+                      {comp}
+                    </button>
+                  ))}
+                </div>
+              </div>
+            )}
+          </>
+        )}
+      </div>
+
+      {/* Separator */}
+      <div style={{ borderTop: '1px solid rgba(255,255,255,0.08)', margin: '8px 0' }} />
+
+      {/* Basemap switcher */}
+      <div style={sectionGap}>
+        <label style={labelStyle}>Basemap</label>
+        <div style={{ display: 'flex', gap: 4 }}>
+          {(['satellite', 'osm', 'dark'] as const).map(key => (
+            <button
+              key={key}
+              onClick={() => dispatch({ type: 'SET_POINT_BASEMAP', payload: key })}
+              style={{
+                flex: 1, padding: '3px 6px', fontSize: 11,
+                background: state.pointBasemap === key ? '#5566cc' : '#2a2a4a',
+                color: state.pointBasemap === key ? '#fff' : '#aaa',
+                border: state.pointBasemap === key ? '1px solid #7788ee' : '1px solid #444',
+                borderRadius: 3, cursor: 'pointer',
+              }}
+            >
+              {basemapLabels[key]}
+            </button>
+          ))}
+        </div>
+      </div>
+
+      {/* Point-specific controls */}
+      {hasPoints && (<>
+      {/* Separator */}
+      <div style={{ borderTop: '1px solid rgba(255,255,255,0.08)', margin: '8px 0' }} />
+
+      {/* Color by dropdown */}
+      <div style={sectionGap}>
+        <label style={labelStyle}>Color by</label>
+        <select
+          value={state.pointColorBy}
+          onChange={e => handleColorByChange(e.target.value)}
+          style={selectStyle}
+        >
+          {numericAttrs.map(([name, info]) => (
+            <option key={name} value={name}>
+              {name}
+              {info.min != null ? ` [${info.min.toFixed(2)}, ${info.max!.toFixed(2)}]` : ''}
+            </option>
+          ))}
+        </select>
+      </div>
+
+      {/* Colormap selector */}
+      <div style={sectionGap}>
+        <label style={labelStyle}>Colormap</label>
+        <select
+          value={state.pointColormap}
+          onChange={e => dispatch({ type: 'SET_POINT_COLORMAP', payload: e.target.value })}
+          style={selectStyle}
+        >
+          {COLORMAP_NAMES.map(name => (
+            <option key={name} value={name}>{name}</option>
+          ))}
+        </select>
+      </div>
+
+      {/* Colorbar */}
+      <div style={{ marginBottom: 8 }}>
+        <div style={{
+          height: 12, borderRadius: 2,
+          background: colormapGradientCSS(state.pointColormap),
+        }} />
+        <div style={{ display: 'flex', justifyContent: 'space-between', fontSize: 10, color: '#999', marginTop: 2 }}>
+          <span>{state.pointVmin.toFixed(1)}</span>
+          <span>{((state.pointVmin + state.pointVmax) / 2).toFixed(1)}</span>
+          <span>{state.pointVmax.toFixed(1)}</span>
+        </div>
+      </div>
+
+      {/* Histogram */}
+      {state.pointHistogram && (
+        <MiniHistogram
+          histogram={state.pointHistogram}
+          vmin={state.pointVmin}
+          vmax={state.pointVmax}
+          colormap={state.pointColormap}
+        />
+      )}
+
+      {/* Vmin / Vmax */}
+      <div style={{ display: 'flex', gap: 8, ...sectionGap }}>
+        <div style={{ flex: 1 }}>
+          <label style={labelStyle}>Min</label>
+          <input
+            type="number"
+            step="any"
+            value={draftVmin}
+            onChange={e => setDraftVmin(e.target.value)}
+            onBlur={commitVmin}
+            onKeyDown={e => e.key === 'Enter' && commitVmin()}
+            style={inputStyle}
+          />
+        </div>
+        <div style={{ flex: 1 }}>
+          <label style={labelStyle}>Max</label>
+          <input
+            type="number"
+            step="any"
+            value={draftVmax}
+            onChange={e => setDraftVmax(e.target.value)}
+            onBlur={commitVmax}
+            onKeyDown={e => e.key === 'Enter' && commitVmax()}
+            style={inputStyle}
+          />
+        </div>
+      </div>
+
+      {/* Current attribute stats */}
+      {currentAttr?.mean != null && (
+        <div style={{ fontSize: 11, color: '#888', marginBottom: 6 }}>
+          mean: {currentAttr.mean.toFixed(3)}
+        </div>
+      )}
+
+      {/* Separator */}
+      <div style={{ borderTop: '1px solid rgba(255,255,255,0.08)', margin: '8px 0' }} />
+
+      {/* Filter section */}
+      <div>
+        <label style={labelStyle}>Filter</label>
+        <div style={{ display: 'flex', gap: 4, marginBottom: 6 }}>
+          <select
+            value={effectiveFilterAttr}
+            onChange={e => setFilterAttr(e.target.value)}
+            style={{ ...selectStyle, flex: 3 }}
+          >
+            {numericAttrs.map(([name]) => (
+              <option key={name} value={name}>{name}</option>
+            ))}
+          </select>
+          <select
+            value={filterOp}
+            onChange={e => setFilterOp(e.target.value)}
+            style={{ ...selectStyle, flex: 1, textAlign: 'center' }}
+          >
+            {FILTER_OPERATORS.map(op => (
+              <option key={op} value={op}>{op}</option>
+            ))}
+          </select>
+          <input
+            ref={filterInputRef}
+            type="number"
+            step="any"
+            placeholder="val"
+            value={filterVal}
+            onChange={e => setFilterVal(e.target.value)}
+            onKeyDown={e => e.key === 'Enter' && addFilter()}
+            style={{ ...inputStyle, flex: 2 }}
+          />
+          <button
+            onClick={addFilter}
+            style={{
+              padding: '3px 8px', fontSize: 12, cursor: 'pointer',
+              background: '#3a5a3a', color: '#cfc', border: '1px solid #4a7a4a',
+              borderRadius: 3,
+            }}
+          >
+            +
+          </button>
+        </div>
+
+        {/* Active filters */}
+        {activeFilters.length > 0 && (
+          <div style={{ marginBottom: 4 }}>
+            {activeFilters.map((f, i) => (
+              <div
+                key={i}
+                style={{
+                  display: 'flex', justifyContent: 'space-between', alignItems: 'center',
+                  background: '#1a2a3a', padding: '2px 6px', borderRadius: 3,
+                  marginBottom: 2, fontSize: 11, fontFamily: 'monospace',
+                }}
+              >
+                <span style={{ color: '#8cf' }}>{f}</span>
+                <button
+                  onClick={() => removeFilter(i)}
+                  style={{
+                    background: 'none', border: 'none', color: '#f88',
+                    cursor: 'pointer', fontSize: 12, padding: '0 2px',
+                  }}
+                >
+                  x
+                </button>
+              </div>
+            ))}
+            <button
+              onClick={clearFilters}
+              style={{
+                background: 'none', border: 'none', color: '#888',
+                cursor: 'pointer', fontSize: 10, padding: '2px 0',
+              }}
+            >
+              Clear all filters
+            </button>
+          </div>
+        )}
+      </div>
+
+      {/* Separator */}
+      <div style={{ borderTop: '1px solid rgba(255,255,255,0.08)', margin: '8px 0' }} />
+
+      {/* Export */}
+      <div>
+        <label style={labelStyle}>Export</label>
+        <label style={{ display: 'flex', alignItems: 'center', gap: 6, fontSize: 11, cursor: 'pointer', marginBottom: 4 }}>
+          <input
+            type="checkbox"
+            checked={exportWithTs}
+            onChange={e => setExportWithTs(e.target.checked)}
+            style={{ accentColor: '#5566cc' }}
+          />
+          <span style={{ color: '#aaa' }}>Include timeseries</span>
+        </label>
+        <div style={{ display: 'flex', gap: 4 }}>
+          {(['csv', 'geojson', 'parquet'] as const).map(fmt => (
+            <button
+              key={fmt}
+              onClick={() => {
+                const params = new URLSearchParams();
+                params.set('format', fmt);
+                if (state.pointFilter) params.set('filter', state.pointFilter);
+                if (exportWithTs) params.set('include_timeseries', 'true');
+                window.open(`/points/${state.activePointLayer}/export?${params}`, '_blank');
+              }}
+              style={{
+                flex: 1, padding: '4px 6px', fontSize: 11, cursor: 'pointer',
+                background: '#2a2a4a', color: '#ccc', border: '1px solid #444',
+                borderRadius: 3,
+              }}
+            >
+              {fmt.toUpperCase()}
+            </button>
+          ))}
+        </div>
+      </div>
+      </>)}
+    </div>
+  );
+}
diff --git a/src/components/TimeSeriesChart.tsx b/src/components/TimeSeriesChart.tsx
index bef519d..2c8c4d3 100644
--- a/src/components/TimeSeriesChart.tsx
+++ b/src/components/TimeSeriesChart.tsx
@@ -1,331 +1,497 @@
-import { useEffect, useState, useCallback } from 'react';
-import { Chart as ChartJS, TimeScale, LinearScale, PointElement, LineElement, Title, Tooltip, Legend, InteractionItem } from 'chart.js';
-import { Line } from 'react-chartjs-2';
-import 'chartjs-adapter-date-fns';
+import { useMemo, useState, useCallback } from 'react';
+import Plot from 'react-plotly.js';
 import { useAppContext } from '../context/AppContext';
-import { useApi } from '../hooks/useApi';
-import { MultiPointTimeSeriesData } from '../types';
 
-// Register Chart.js components
-ChartJS.register(TimeScale, LinearScale, PointElement, LineElement, Title, Tooltip, Legend);
+const COLORS = [
+  '#1f77b4', '#ff7f0e', '#2ca02c', '#d62728', '#9467bd',
+  '#8c564b', '#e377c2', '#7f7f7f', '#bcbd22', '#17becf'
+];
 
-export default function TimeSeriesChart() {
-  const { state, dispatch } = useAppContext();
-  const { fetchMultiPointTimeSeries } = useApi();
-  const [chartData, setChartData] = useState<MultiPointTimeSeriesData | null>(null);
-  const [isLoading, setIsLoading] = useState(false);
+// Client-side linear regression on date strings → displacement values
+function linearFit(dates: string[], values: number[]): { slope: number; intercept: number; r2: number; mmPerYear: number } | null {
+  if (dates.length < 2) return null;
 
-  const updateChart = useCallback(async () => {
-    if (!state.showChart || !state.currentDataset || state.timeSeriesPoints.length === 0) {
-      setChartData(null);
-      return;
-    }
+  // Convert dates to days since first date
+  const t0 = new Date(dates[0]).getTime();
+  const x = dates.map(d => (new Date(d).getTime() - t0) / 86_400_000); // days
+  const y = values;
+  const n = x.length;
+
+  const sumX = x.reduce((a, b) => a + b, 0);
+  const sumY = y.reduce((a, b) => a + b, 0);
+  const sumXY = x.reduce((a, xi, i) => a + xi * y[i], 0);
+  const sumXX = x.reduce((a, xi) => a + xi * xi, 0);
+
+  const denom = n * sumXX - sumX * sumX;
+  if (Math.abs(denom) < 1e-12) return null;
 
-    setIsLoading(true);
-    const currentDatasetInfo = state.datasetInfo[state.currentDataset];
+  const slope = (n * sumXY - sumX * sumY) / denom;
+  const intercept = (sumY - slope * sumX) / n;
 
-    // Filter visible points
-    const visiblePoints = state.timeSeriesPoints.filter(p => p.visible);
+  // R²
+  const meanY = sumY / n;
+  const ssRes = y.reduce((a, yi, i) => a + (yi - (slope * x[i] + intercept)) ** 2, 0);
+  const ssTot = y.reduce((a, yi) => a + (yi - meanY) ** 2, 0);
+  const r2 = ssTot > 0 ? 1 - ssRes / ssTot : 0;
 
-    if (visiblePoints.length === 0) {
-      setChartData(null);
-      setIsLoading(false);
+  // mm/year: slope is mm/day
+  const mmPerYear = slope * 365.25;
+
+  return { slope, intercept, r2, mmPerYear };
+}
+
+export default function TimeSeriesChart() {
+  const { state, dispatch } = useAppContext();
+  const hasMultipleClicked = state.clickedPoints.length > 1;
+  const [showTrends, setShowTrends] = useState(false);
+  const [dateStart, setDateStart] = useState('');
+  const [dateEnd, setDateEnd] = useState('');
+  const isLight = state.chartTheme === 'light';
+
+  const exportImage = useCallback(async (format: 'png' | 'svg' = 'png') => {
+    const plotDiv = document.querySelector('.js-plotly-plot') as HTMLElement | null;
+    if (!plotDiv) return;
+
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    const PlotlyLib = (window as any).Plotly || (await import('plotly.js-dist-min')).default;
+
+    if (format === 'svg') {
+      // SVG export — chart only, vector format for publication
+      const svgData = await PlotlyLib.toImage(plotDiv, {
+        format: 'svg', width: 900, height: 400,
+      });
+      const link = document.createElement('a');
+      link.download = `bowser_chart_${new Date().toISOString().slice(0, 10)}.svg`;
+      link.href = svgData;
+      link.click();
       return;
     }
 
-    try {
-      // Format points for API
-      const apiPoints = visiblePoints.map(point => ({
-        id: point.id,
-        lat: point.position[0],
-        lon: point.position[1],
-        color: point.color,
-        name: point.name,
-      }));
-
-      // Fetch multi-point data
-      let refLon, refLat;
-      if (currentDatasetInfo?.uses_spatial_ref) {
-        [refLat, refLon] = state.refMarkerPosition;
-      }
+    // PNG export — map + chart combined
+    const mapCanvas = document.querySelector('.map-container canvas') as HTMLCanvasElement | null;
+    const scale = 2;
+    const exportW = 1600;
+    const mapH = mapCanvas ? Math.round(exportW * mapCanvas.height / mapCanvas.width) : 500;
+    const chartH = 400;
+
+    const combinedCanvas = document.createElement('canvas');
+    combinedCanvas.width = exportW * scale;
+    combinedCanvas.height = (mapH + chartH) * scale;
+    const ctx = combinedCanvas.getContext('2d');
+    if (!ctx) return;
+
+    ctx.scale(scale, scale);
+    ctx.fillStyle = isLight ? '#ffffff' : '#1a1a2e';
+    ctx.fillRect(0, 0, exportW, mapH + chartH);
+
+    // Draw map (preserveDrawingBuffer must be true on the MapLibre map)
+    if (mapCanvas) {
+      ctx.drawImage(mapCanvas, 0, 0, exportW, mapH);
+    }
 
-      const tsData = await fetchMultiPointTimeSeries(
-        apiPoints,
-        state.currentDataset,
-        refLon,
-        refLat,
-        state.showTrends
-      );
+    // Draw chart as PNG at high resolution
+    const chartImg = await PlotlyLib.toImage(plotDiv, {
+      format: 'png', width: exportW, height: chartH, scale,
+    });
+    const img = new Image();
+    await new Promise<void>((resolve) => {
+      img.onload = () => {
+        ctx.drawImage(img, 0, mapH, exportW, chartH);
+        resolve();
+      };
+      img.src = chartImg;
+    });
 
-      if (tsData) {
-        setChartData(tsData);
-
-        // Update trend data in state only if trends are being calculated
-        if (state.showTrends && tsData.datasets) {
-          // Use setTimeout to avoid re-render loop during state updates
-          setTimeout(() => {
-            tsData.datasets.forEach(dataset => {
-              if (dataset.trend) {
-                dispatch({
-                  type: 'SET_POINT_TREND_DATA',
-                  payload: {
-                    pointId: dataset.pointId,
-                    dataset: state.currentDataset,
-                    trend: {
-                      slope: dataset.trend.slope,
-                      intercept: dataset.trend.intercept,
-                      rSquared: dataset.trend.rSquared,
-                      mmPerYear: dataset.trend.mmPerYear,
-                    },
-                  },
-                });
-              }
+    const link = document.createElement('a');
+    link.download = `bowser_export_${new Date().toISOString().slice(0, 10)}.png`;
+    link.href = combinedCanvas.toDataURL('image/png');
+    link.click();
+  }, [isLight]);
+
+  // Build a lookup from date → displacement for the reference point
+  const refLookup = useMemo(() => {
+    if (state.referenceTimeseries.length === 0) return null;
+    const map = new Map<string, number>();
+    for (const entry of state.referenceTimeseries) {
+      map.set(entry.date, entry.displacement);
+    }
+    return map;
+  }, [state.referenceTimeseries]);
+
+  const traces = useMemo(() => {
+    const result: Array<Record<string, unknown>> = [];
+
+    // V2 point layer mode: show clicked points
+    if (state.clickedPoints.length > 0) {
+      for (let i = 0; i < state.clickedPoints.length; i++) {
+        const cp = state.clickedPoints[i];
+        // Apply client-side date range filter
+        const filtered = cp.timeseries.filter(t => {
+          if (dateStart && t.date < dateStart) return false;
+          if (dateEnd && t.date > dateEnd) return false;
+          return true;
+        });
+        const x = filtered.map(t => t.date);
+        const y = filtered.map(t => {
+          if (refLookup) {
+            const refVal = refLookup.get(t.date) ?? 0;
+            return t.displacement - refVal;
+          }
+          return t.displacement;
+        });
+        const color = COLORS[i % COLORS.length];
+
+        // Data trace
+        result.push({
+          x, y,
+          type: 'scattergl',
+          mode: 'lines+markers',
+          name: `Point ${cp.pointId}`,
+          marker: { color, size: 5 },
+          line: { color, width: 1.5 },
+        });
+
+        // Trend line trace
+        if (showTrends) {
+          const fit = linearFit(x, y);
+          if (fit) {
+            const t0 = new Date(x[0]).getTime();
+            const trendY = x.map(d => {
+              const days = (new Date(d).getTime() - t0) / 86_400_000;
+              return fit.slope * days + fit.intercept;
             });
-          }, 0);
+            result.push({
+              x, y: trendY,
+              type: 'scattergl',
+              mode: 'lines',
+              name: `${fit.mmPerYear >= 0 ? '+' : ''}${fit.mmPerYear.toFixed(1)} mm/yr (R²=${fit.r2.toFixed(2)})`,
+              line: { color, width: 1, dash: 'dash' },
+              showlegend: true,
+            });
+          }
         }
       }
-    } catch (error) {
-      console.error('Error updating chart:', error);
-    } finally {
-      setIsLoading(false);
-    }
-  }, [
-    state.showChart,
-    state.currentDataset,
-    JSON.stringify(state.timeSeriesPoints.map(p => ({ id: p.id, position: p.position, visible: p.visible }))), // Only track relevant point changes
-    state.refMarkerPosition,
-    state.datasetInfo,
-    state.showTrends,
-    fetchMultiPointTimeSeries,
-  ]);
-
-  useEffect(() => {
-    updateChart();
-  }, [
-    updateChart,
-  ]);
-
-  const handleChartClick = useCallback((_event: any, elements: InteractionItem[]) => {
-    if (elements.length === 0 || !chartData) return;
-
-    const element = elements[0];
-    const dataIndex = element.index;
-
-    // Update the current time index to sync with the clicked point
-    if (dataIndex !== undefined && dataIndex < chartData.labels.length) {
-      dispatch({ type: 'SET_TIME_INDEX', payload: dataIndex });
+      return result;
     }
-  }, [chartData, dispatch]);
 
-  const handleExportToCSV = useCallback(() => {
-    if (!chartData || !chartData.datasets || chartData.datasets.length === 0) return;
+    // V1 raster mode: show time series points (existing behavior)
+    if (state.timeSeriesPoints.length > 0 && state.currentDataset) {
+      const refVals = state.refValues[state.currentDataset];
+
+      for (const p of state.timeSeriesPoints) {
+        if (!p.visible || !p.data?.[state.currentDataset]) continue;
+        const rawData = p.data![state.currentDataset];
+        const data = refVals
+          ? rawData.map((v, i) => v - (refVals[i] ?? 0))
+          : rawData;
+        const info = state.datasetInfo[state.currentDataset];
+        const xValues = info?.x_values || data.map((_, i) => i);
+        result.push({
+          x: xValues,
+          y: data,
+          type: 'scattergl',
+          mode: 'lines+markers',
+          name: p.name,
+          marker: { color: p.color, size: 5 },
+          line: { color: p.color, width: 1.5 },
+        });
+      }
+    }
 
-    // Build CSV header
-    const headers = ['Time', ...chartData.datasets.map(d => d.label)];
+    // GPS station timeseries (dashed green, visually distinct)
+    if (state.gpsTimeseries.length > 0 && state.gpsSelectedStationId) {
+      const gpsFiltered = state.gpsTimeseries.filter(t => {
+        if (dateStart && t.date < dateStart) return false;
+        if (dateEnd && t.date > dateEnd) return false;
+        return true;
+      });
 
-    // Build data rows
-    const rows: string[][] = [];
-    chartData.labels.forEach((label, idx) => {
-      const row = [label];
-      chartData.datasets.forEach(dataset => {
-        const dataPoint = dataset.data[idx];
-        row.push(dataPoint ? dataPoint.y.toString() : '');
+      const componentKey = state.gpsComponent;
+      const x = gpsFiltered.map(t => t.date);
+      const y = gpsFiltered.map(t =>
+        componentKey === 'los' ? t.displacement : t[componentKey]
+      );
+      const componentLabel = componentKey === 'los' ? 'LOS' : componentKey.toUpperCase();
+
+      result.push({
+        x, y,
+        type: 'scattergl',
+        mode: 'lines+markers',
+        name: `GPS: ${state.gpsSelectedStationId} (${componentLabel})`,
+        marker: { color: '#22aa66', size: 7, symbol: 'diamond' },
+        line: { color: '#22aa66', width: 2, dash: 'dash' },
       });
-      rows.push(row);
-    });
 
-    // Add trend information if available
-    const trendRows: string[][] = [];
-    if (state.showTrends && chartData.datasets.some(d => d.trend)) {
-      trendRows.push(['']); // Empty row separator
-      trendRows.push(['Point', 'Rate (mm/year)', 'R²', 'Slope', 'Intercept']);
-      chartData.datasets.forEach(dataset => {
-        if (dataset.trend) {
-          trendRows.push([
-            dataset.label,
-            dataset.trend.mmPerYear.toFixed(6),
-            dataset.trend.rSquared.toFixed(6),
-            dataset.trend.slope.toFixed(6),
-            dataset.trend.intercept.toFixed(6),
-          ]);
+      // GPS trend line
+      if (showTrends) {
+        const fit = linearFit(x, y);
+        if (fit) {
+          const t0 = new Date(x[0]).getTime();
+          const trendY = x.map(d => {
+            const days = (new Date(d).getTime() - t0) / 86_400_000;
+            return fit.slope * days + fit.intercept;
+          });
+          result.push({
+            x, y: trendY,
+            type: 'scattergl',
+            mode: 'lines',
+            name: `GPS trend: ${fit.mmPerYear >= 0 ? '+' : ''}${fit.mmPerYear.toFixed(1)} mm/yr (R²=${fit.r2.toFixed(2)})`,
+            line: { color: '#22aa66', width: 1, dash: 'dot' },
+            showlegend: true,
+          });
         }
-      });
+      }
     }
 
-    // Combine all rows and convert to CSV
-    const allRows = [headers, ...rows, ...trendRows];
-    const csvContent = allRows.map(row => row.join(',')).join('\n');
+    return result;
+  }, [state.clickedPoints, state.timeSeriesPoints, state.currentDataset, state.datasetInfo, state.refValues,
+      state.gpsTimeseries, state.gpsSelectedStationId, state.gpsComponent,
+      refLookup, showTrends, dateStart, dateEnd]);
 
-    // Create and trigger download
-    const blob = new Blob([csvContent], { type: 'text/csv;charset=utf-8;' });
-    const link = document.createElement('a');
-    const url = URL.createObjectURL(blob);
-
-    const timestamp = new Date().toISOString().replace(/[:.]/g, '-').slice(0, -5);
-    link.setAttribute('href', url);
-    link.setAttribute('download', `time-series-${state.currentDataset}-${timestamp}.csv`);
-    link.style.visibility = 'hidden';
-    document.body.appendChild(link);
-    link.click();
-    document.body.removeChild(link);
-  }, [chartData, state.showTrends, state.currentDataset]);
-
-  const chartOptions = {
-    responsive: true,
-    maintainAspectRatio: false,
-    animation: {
-      duration: 300,
-    },
-    interaction: {
-      mode: 'index' as const,
-      intersect: false,
-    },
-    plugins: {
-      legend: {
-        display: true,
-        position: 'top' as const,
-        labels: {
-          usePointStyle: true,
-          padding: 20,
-          generateLabels: (_chart: any) => {
-            if (!chartData?.datasets) return [];
-
-            return chartData.datasets.map((dataset, index) => ({
-              text: `${dataset.label}${dataset.trend && dataset.trend.mmPerYear !== undefined ? ` (${dataset.trend.mmPerYear.toFixed(1)} mm/yr)` : ''}`,
-              pointStyle: 'circle' as const,
-              fillStyle: dataset.borderColor,
-              strokeStyle: dataset.borderColor,
-              lineWidth: 2,
-              datasetIndex: index,
-            }));
-          },
-        },
-      },
-      tooltip: {
-        callbacks: {
-          title: (context: any) => {
-            return `Time: ${context[0]?.label || ''}`;
-          },
-          label: (context: any) => {
-            const dataset = chartData?.datasets?.[context.datasetIndex];
-            if (!dataset) return '';
-
-            let label = `${dataset.label}: ${context.parsed.y.toFixed(3)}`;
-
-            if (dataset.trend && dataset.trend.mmPerYear !== undefined && state.showTrends) {
-              label += ` (${dataset.trend.mmPerYear.toFixed(1)} mm/yr)`;
-            }
-
-            return label;
-          },
-        },
-      },
-    },
-    scales: {
-      x: {
-        type: 'time' as const,
-        time: {
-          displayFormats: {
-            month: 'MMM yyyy',
-            year: 'yyyy',
-          },
-        },
-        title: {
-          display: true,
-          text: 'Time',
-        },
-      },
-      y: {
-        title: {
-          display: true,
-          text: 'Displacement (m)',
-        },
-        suggestedMin: state.vmin,
-        suggestedMax: state.vmax,
-      },
-    },
-    onClick: handleChartClick,
-  };
-
-  if (!state.showChart) {
-    return null;
-  }
-
-  if (state.timeSeriesPoints.length === 0) {
-    return (
-      <div id="chart-container">
-        <div className="chart-placeholder">
-          <p>No time series points selected.</p>
-          <p><small>Click on the map to add points.</small></p>
-        </div>
-      </div>
-    );
-  }
-
-  if (isLoading) {
-    return (
-      <div id="chart-container">
-        <div className="chart-placeholder">
-          <p>Loading time series data...</p>
-        </div>
-      </div>
-    );
-  }
-
-  if (!chartData || !chartData.datasets || chartData.datasets.length === 0) {
-    return (
-      <div id="chart-container">
-        <div className="chart-placeholder">
-          <p>No data available for selected points.</p>
-        </div>
-      </div>
-    );
-  }
-
-  // Format data for Chart.js
-  const formattedChartData = {
-    labels: chartData.labels,
-    datasets: chartData.datasets.map(dataset => ({
-      label: dataset.label,
-      data: dataset.data,
-      borderColor: dataset.borderColor,
-      backgroundColor: dataset.backgroundColor,
-      borderWidth: 2,
-      pointRadius: 3,
-      pointHoverRadius: 5,
-      tension: 0.1,
-      fill: false,
-    })),
-  };
+  if (traces.length === 0) return null;
 
   return (
-    <div id="chart-container">
-      <div className="chart-header">
-        <h4>Time Series Analysis</h4>
-        <div className="chart-controls">
+    <div style={{
+      position: 'absolute',
+      bottom: 0,
+      left: 0,
+      right: 0,
+      height: '250px',
+      zIndex: 1000,
+      background: isLight ? '#ffffff' : '#1a1a2e',
+      borderTop: isLight ? '1px solid #ccc' : '1px solid #333',
+      display: 'flex',
+      flexDirection: 'column',
+    }}>
+      {/* Reference indicator + Selection bar */}
+      {(hasMultipleClicked || state.referencePointId != null || state.gpsSelectedStationId) && (
+        <div style={{
+          display: 'flex', alignItems: 'center', gap: 8,
+          padding: '3px 10px', background: isLight ? '#f0f0f0' : '#12122a',
+          borderBottom: isLight ? '1px solid #ddd' : '1px solid #2a2a4a', fontSize: 11,
+          flexShrink: 0,
+        }}>
+          {state.referencePointId != null && (
+            <span style={{
+              display: 'inline-flex', alignItems: 'center', gap: 3,
+              background: '#1a3a2a', padding: '1px 6px', borderRadius: 3,
+              color: '#0f8', fontSize: 11,
+            }}>
+              ref: {state.referencePointId}
+              <button
+                onClick={() => dispatch({ type: 'CLEAR_REFERENCE_POINT' })}
+                style={{
+                  background: 'none', border: 'none', color: '#888',
+                  cursor: 'pointer', fontSize: 11, padding: 0, lineHeight: 1,
+                }}
+              >
+                x
+              </button>
+            </span>
+          )}
+          {hasMultipleClicked && (
+            <span style={{ color: '#999' }}>
+              {state.clickedPoints.length} pts
+            </span>
+          )}
+          {state.clickedPoints.map((cp, i) => (
+            <span
+              key={cp.pointId}
+              style={{
+                display: 'inline-flex', alignItems: 'center', gap: 3,
+                background: '#1a2a3a', padding: '1px 6px', borderRadius: 3,
+                color: COLORS[i % COLORS.length],
+              }}
+            >
+              {cp.pointId}
+              <button
+                onClick={() => dispatch({ type: 'REMOVE_CLICKED_POINT', payload: cp.pointId })}
+                style={{
+                  background: 'none', border: 'none', color: '#888',
+                  cursor: 'pointer', fontSize: 11, padding: 0, lineHeight: 1,
+                }}
+              >
+                x
+              </button>
+            </span>
+          ))}
+          {state.gpsSelectedStationId && (
+            <span style={{
+              display: 'inline-flex', alignItems: 'center', gap: 3,
+              background: isLight ? '#e0f5e0' : '#1a3a2a', padding: '1px 6px', borderRadius: 3,
+              color: '#22aa66', fontSize: 11,
+            }}>
+              GPS: {state.gpsSelectedStationId}
+              <button
+                onClick={() => {
+                  dispatch({ type: 'SET_GPS_SELECTED_STATION', payload: null });
+                  dispatch({ type: 'SET_GPS_TIMESERIES', payload: [] });
+                }}
+                style={{
+                  background: 'none', border: 'none', color: '#888',
+                  cursor: 'pointer', fontSize: 11, padding: 0, lineHeight: 1,
+                }}
+              >
+                x
+              </button>
+            </span>
+          )}
           <button
-            className="pure-button"
-            onClick={() => dispatch({ type: 'TOGGLE_TRENDS' })}
-            title="Toggle trend analysis"
+            onClick={() => dispatch({ type: 'CLEAR_CLICKED_POINTS' })}
+            style={{
+              marginLeft: 'auto', background: 'none', border: 'none',
+              color: '#888', cursor: 'pointer', fontSize: 10,
+            }}
           >
-            <i className={`fa-solid ${state.showTrends ? 'fa-chart-line' : 'fa-chart-simple'}`}></i>
-            {state.showTrends ? 'Hide' : 'Show'} Trends
-          </button>
-          <button
-            className="pure-button"
-            onClick={handleExportToCSV}
-            title="Export data to CSV"
-          >
-            <i className="fa-solid fa-download"></i>
-            Export CSV
+            Clear all
           </button>
         </div>
+      )}
+
+      {/* Toolbar row: date range + trend toggle + close */}
+      <div style={{
+        display: 'flex', alignItems: 'center', gap: 6,
+        padding: '3px 10px', background: isLight ? '#f0f0f0' : '#12122a',
+        borderBottom: isLight ? '1px solid #ddd' : '1px solid #2a2a4a', fontSize: 11,
+        flexShrink: 0,
+      }}>
+        {state.clickedPoints.length > 0 && (
+          <>
+            <span style={{ color: '#888', fontSize: 10 }}>Date range:</span>
+            <input
+              type="date"
+              value={dateStart}
+              onChange={e => setDateStart(e.target.value)}
+              style={{
+                background: '#2a2a4a', color: '#ccc', border: '1px solid #444',
+                borderRadius: 3, fontSize: 10, padding: '1px 4px', width: 110,
+              }}
+            />
+            <span style={{ color: '#666' }}>to</span>
+            <input
+              type="date"
+              value={dateEnd}
+              onChange={e => setDateEnd(e.target.value)}
+              style={{
+                background: '#2a2a4a', color: '#ccc', border: '1px solid #444',
+                borderRadius: 3, fontSize: 10, padding: '1px 4px', width: 110,
+              }}
+            />
+            {(dateStart || dateEnd) && (
+              <button
+                onClick={() => { setDateStart(''); setDateEnd(''); }}
+                style={{
+                  background: 'none', border: 'none', color: '#888',
+                  cursor: 'pointer', fontSize: 10, padding: 0,
+                }}
+              >
+                reset
+              </button>
+            )}
+            <button
+              onClick={() => setShowTrends(!showTrends)}
+              style={{
+                background: showTrends ? '#3a4a6a' : '#2a2a4a',
+                border: showTrends ? '1px solid #5566cc' : '1px solid #444',
+                color: showTrends ? '#aaf' : '#ccc',
+                cursor: 'pointer', fontSize: 11, padding: '2px 6px', borderRadius: 3,
+              }}
+            >
+              Trend
+            </button>
+          </>
+        )}
+        <button
+          onClick={() => exportImage('png')}
+          style={{
+            background: isLight ? '#e8e8e8' : '#2a2a4a',
+            border: isLight ? '1px solid #ccc' : '1px solid #444',
+            color: isLight ? '#333' : '#ccc',
+            cursor: 'pointer', fontSize: 11, padding: '2px 6px', borderRadius: 3,
+          }}
+          title="Export map + chart as PNG"
+        >
+          PNG
+        </button>
+        <button
+          onClick={() => exportImage('svg')}
+          style={{
+            background: isLight ? '#e8e8e8' : '#2a2a4a',
+            border: isLight ? '1px solid #ccc' : '1px solid #444',
+            color: isLight ? '#333' : '#ccc',
+            cursor: 'pointer', fontSize: 11, padding: '2px 6px', borderRadius: 3,
+          }}
+          title="Export chart as SVG (vector, for publication)"
+        >
+          SVG
+        </button>
+        <button
+          onClick={() => dispatch({ type: 'SET_CHART_THEME', payload: isLight ? 'dark' : 'light' })}
+          style={{
+            background: isLight ? '#e8e8e8' : '#2a2a4a',
+            border: isLight ? '1px solid #ccc' : '1px solid #444',
+            color: isLight ? '#333' : '#ccc',
+            cursor: 'pointer', fontSize: 11, padding: '2px 6px', borderRadius: 3,
+          }}
+          title="Toggle dark/light theme for publication"
+        >
+          {isLight ? 'Dark' : 'Light'}
+        </button>
+        <button
+          onClick={() => {
+            dispatch({ type: 'TOGGLE_CHART' });
+            dispatch({ type: 'CLEAR_CLICKED_POINTS' });
+          }}
+          style={{
+            marginLeft: 'auto',
+            background: 'transparent', border: 'none', color: '#888',
+            cursor: 'pointer', fontSize: 14,
+          }}
+        >
+          x
+        </button>
       </div>
-      <div className="chart-content">
-        <Line data={formattedChartData} options={chartOptions} />
-      </div>
-      <div className="chart-help">
-        <small>Click on chart points to sync map time • Trends show mm/year rates</small>
+
+      <div style={{ flex: 1, minHeight: 0 }}>
+        <Plot
+          data={traces}
+          layout={{
+            autosize: true,
+            margin: { l: 55, r: 15, t: 10, b: 40 },
+            paper_bgcolor: isLight ? '#ffffff' : '#1a1a2e',
+            plot_bgcolor: isLight ? '#f8f8f8' : '#16213e',
+            font: {
+              color: isLight ? '#333' : '#ccc',
+              size: isLight ? 13 : 11,
+              family: isLight
+                ? '"Palatino Linotype", Palatino, "Book Antiqua", Georgia, serif'
+                : 'system-ui, sans-serif',
+            },
+            xaxis: {
+              gridcolor: isLight ? '#ddd' : '#2a3a5e',
+              linecolor: isLight ? '#999' : undefined,
+              title: { text: 'Date' },
+            },
+            yaxis: {
+              gridcolor: isLight ? '#ddd' : '#2a3a5e',
+              linecolor: isLight ? '#999' : undefined,
+              title: { text: refLookup ? 'Relative Displacement (mm)' : 'Displacement (mm)' },
+            },
+            legend: {
+              bgcolor: isLight ? 'rgba(255,255,255,0.8)' : 'rgba(0,0,0,0.3)',
+              font: { size: 10 },
+            },
+            showlegend: traces.length > 1,
+          }}
+          config={{
+            displayModeBar: true,
+            modeBarButtonsToRemove: ['lasso2d', 'select2d'],
+            displaylogo: false,
+            responsive: true,
+          }}
+          style={{ width: '100%', height: '100%' }}
+          useResizeHandler
+        />
       </div>
     </div>
   );
diff --git a/src/context/AppContext.tsx b/src/context/AppContext.tsx
index c004116..4422a52 100644
--- a/src/context/AppContext.tsx
+++ b/src/context/AppContext.tsx
@@ -34,6 +34,30 @@ const initialState: AppState = {
   showChart: false,
   selectedPointId: null,
   showTrends: false,
+  activePointLayer: null,
+  pointLayerBounds: null,
+  clickedPoints: [],
+  pointColorBy: 'velocity',
+  pointVmin: -10,
+  pointVmax: 10,
+  pointAttributes: {},
+  pointFilter: '',
+  pointBasemap: 'satellite',
+  pointColormap: 'rdbu_r',
+  referencePointId: null,
+  referenceTimeseries: [],
+  chartTheme: 'dark',
+  pointHistogram: null,
+  rasterLayerVisible: true,
+  pointLayerVisible: true,
+  pointOpacity: 1,
+  gpsVisible: false,
+  gpsLoading: false,
+  gpsStations: [],
+  gpsSelectedStationId: null,
+  gpsTimeseries: [],
+  gpsComponent: 'los',
+  gpsLosInfo: null,
 };
 
 function appReducer(state: AppState, action: AppAction | LegacyAppAction): AppState {
@@ -175,6 +199,77 @@ function appReducer(state: AppState, action: AppAction | LegacyAppAction): AppSt
       return { ...state, opacity: action.payload };
     case 'TOGGLE_CHART':
       return { ...state, showChart: !state.showChart };
+
+    // V2 point layer actions
+    case 'SET_ACTIVE_POINT_LAYER':
+      return { ...state, activePointLayer: action.payload };
+    case 'SET_POINT_LAYER_BOUNDS':
+      return { ...state, pointLayerBounds: action.payload };
+    case 'SET_CLICKED_POINT_TIMESERIES':
+      return {
+        ...state,
+        showChart: true,
+        clickedPoints: [
+          ...state.clickedPoints.filter(p => p.pointId !== action.payload.pointId),
+          action.payload,
+        ],
+      };
+    case 'CLEAR_CLICKED_POINTS':
+      return { ...state, clickedPoints: [] };
+    case 'REMOVE_CLICKED_POINT':
+      return {
+        ...state,
+        clickedPoints: state.clickedPoints.filter(p => p.pointId !== action.payload),
+      };
+    case 'SET_POINT_COLOR_BY':
+      return { ...state, pointColorBy: action.payload };
+    case 'SET_POINT_VMIN':
+      return { ...state, pointVmin: action.payload };
+    case 'SET_POINT_VMAX':
+      return { ...state, pointVmax: action.payload };
+    case 'SET_POINT_ATTRIBUTES':
+      return { ...state, pointAttributes: action.payload };
+    case 'SET_POINT_FILTER':
+      return { ...state, pointFilter: action.payload };
+    case 'SET_POINT_BASEMAP':
+      return { ...state, pointBasemap: action.payload };
+    case 'SET_POINT_COLORMAP':
+      return { ...state, pointColormap: action.payload };
+    case 'SET_REFERENCE_POINT':
+      return {
+        ...state,
+        referencePointId: action.payload.pointId,
+        referenceTimeseries: action.payload.timeseries,
+      };
+    case 'CLEAR_REFERENCE_POINT':
+      return { ...state, referencePointId: null, referenceTimeseries: [] };
+    case 'SET_CHART_THEME':
+      return { ...state, chartTheme: action.payload };
+    case 'SET_POINT_HISTOGRAM':
+      return { ...state, pointHistogram: action.payload };
+    case 'SET_RASTER_LAYER_VISIBLE':
+      return { ...state, rasterLayerVisible: action.payload };
+    case 'SET_POINT_LAYER_VISIBLE':
+      return { ...state, pointLayerVisible: action.payload };
+    case 'SET_POINT_OPACITY':
+      return { ...state, pointOpacity: action.payload };
+
+    // GPS actions
+    case 'SET_GPS_VISIBLE':
+      return { ...state, gpsVisible: action.payload };
+    case 'SET_GPS_LOADING':
+      return { ...state, gpsLoading: action.payload };
+    case 'SET_GPS_STATIONS':
+      return { ...state, gpsStations: action.payload, gpsLoading: false };
+    case 'SET_GPS_SELECTED_STATION':
+      return { ...state, gpsSelectedStationId: action.payload };
+    case 'SET_GPS_TIMESERIES':
+      return { ...state, gpsTimeseries: action.payload, showChart: true };
+    case 'SET_GPS_COMPONENT':
+      return { ...state, gpsComponent: action.payload };
+    case 'SET_GPS_LOS_INFO':
+      return { ...state, gpsLosInfo: action.payload };
+
     default:
       return state;
   }
diff --git a/src/hooks/useGpsApi.ts b/src/hooks/useGpsApi.ts
new file mode 100644
index 0000000..cc2ee35
--- /dev/null
+++ b/src/hooks/useGpsApi.ts
@@ -0,0 +1,30 @@
+import { useCallback } from 'react';
+import { GpsStation, GpsTimeseriesEntry } from '../types';
+
+export function useGpsApi() {
+  const fetchLosInfo = useCallback(async (): Promise<{ type: string; east?: number; north?: number; up?: number } | null> => {
+    const response = await fetch('/gps/los_info');
+    if (!response.ok) return null;
+    return await response.json();
+  }, []);
+
+  const fetchGpsStations = useCallback(async (bbox: [number, number, number, number]): Promise<GpsStation[]> => {
+    const [west, south, east, north] = bbox;
+    const response = await fetch(`/gps/stations?bbox=${west},${south},${east},${north}`);
+    if (!response.ok) return [];
+    return await response.json();
+  }, []);
+
+  const fetchGpsTimeseries = useCallback(async (stationId: string): Promise<{
+    station_id: string;
+    station_name: string;
+    los_vector: { east: number; north: number; up: number };
+    timeseries: GpsTimeseriesEntry[];
+  } | null> => {
+    const response = await fetch(`/gps/stations/${stationId}/timeseries`);
+    if (!response.ok) return null;
+    return await response.json();
+  }, []);
+
+  return { fetchLosInfo, fetchGpsStations, fetchGpsTimeseries };
+}
diff --git a/src/hooks/usePointsApi.ts b/src/hooks/usePointsApi.ts
new file mode 100644
index 0000000..3fa7d76
--- /dev/null
+++ b/src/hooks/usePointsApi.ts
@@ -0,0 +1,133 @@
+import { useCallback } from 'react';
+import { tableFromIPC } from 'apache-arrow';
+
+export interface PointLayerInfo {
+  default_color_by: string;
+  default_colormap: string;
+  default_vmin: number | null;
+  default_vmax: number | null;
+}
+
+export interface PointAttributes {
+  layer: string;
+  attributes: Record<string, {
+    type: string;
+    min?: number;
+    max?: number;
+    mean?: number;
+    count?: number;
+  }>;
+}
+
+export interface PointTimeSeriesEntry {
+  date: string;
+  displacement: number;
+}
+
+export interface PointData {
+  point_id: number[];
+  lon: number[];
+  lat: number[];
+  colorValues: number[];
+  count: number;
+}
+
+export function usePointsApi() {
+  const fetchPointLayers = useCallback(async (): Promise<Record<string, PointLayerInfo>> => {
+    const response = await fetch('/points/layers');
+    if (!response.ok) throw new Error(`${response.status}`);
+    return await response.json();
+  }, []);
+
+  const fetchPointAttributes = useCallback(async (layerName: string): Promise<PointAttributes> => {
+    const response = await fetch(`/points/${layerName}/attributes`);
+    if (!response.ok) throw new Error(`${response.status}`);
+    return await response.json();
+  }, []);
+
+  const fetchPoints = useCallback(async (
+    layerName: string,
+    opts: {
+      bbox?: [number, number, number, number];
+      colorBy?: string;
+      filter?: string;
+      maxPoints?: number;
+    } = {}
+  ): Promise<PointData> => {
+    const params = new URLSearchParams();
+    if (opts.bbox) {
+      params.set('bbox', opts.bbox.join(','));
+    }
+    if (opts.colorBy) {
+      params.set('color_by', opts.colorBy);
+    }
+    if (opts.filter) {
+      params.set('filter', opts.filter);
+    }
+    if (opts.maxPoints) {
+      params.set('max_points', opts.maxPoints.toString());
+    }
+
+    const response = await fetch(`/points/${layerName}?${params}`);
+    if (!response.ok) throw new Error(`${response.status}`);
+    const buffer = await response.arrayBuffer();
+    const table = tableFromIPC(new Uint8Array(buffer));
+
+    const pointIds = table.getChild('point_id')!;
+    const lons = table.getChild('lon')!;
+    const lats = table.getChild('lat')!;
+    // The 4th column is the color_by attribute
+    const colorCol = table.schema.fields[3];
+    const colorValues = table.getChild(colorCol.name)!;
+
+    return {
+      point_id: Array.from(pointIds),
+      lon: Array.from(lons),
+      lat: Array.from(lats),
+      colorValues: Array.from(colorValues),
+      count: table.numRows,
+    };
+  }, []);
+
+  const fetchPointTimeseries = useCallback(async (
+    layerName: string,
+    pointId: number,
+  ): Promise<PointTimeSeriesEntry[]> => {
+    const response = await fetch(`/points/${layerName}/${pointId}/timeseries`);
+    return await response.json();
+  }, []);
+
+  const fetchMultiPointTimeseries = useCallback(async (
+    layerName: string,
+    pointIds: number[],
+  ): Promise<Record<string, PointTimeSeriesEntry[]>> => {
+    const response = await fetch(`/points/${layerName}/timeseries`, {
+      method: 'POST',
+      headers: { 'Content-Type': 'application/json' },
+      body: JSON.stringify({ point_ids: pointIds }),
+    });
+    const data = await response.json();
+    return data.series;
+  }, []);
+
+  const fetchPointStats = useCallback(async (
+    layerName: string,
+    bbox?: [number, number, number, number],
+  ): Promise<Record<string, number>> => {
+    const params = new URLSearchParams();
+    if (bbox) {
+      params.set('bbox', bbox.join(','));
+    }
+    const response = await fetch(`/points/${layerName}/stats?${params}`);
+    return await response.json();
+  }, []);
+
+  return {
+    fetchPointLayers,
+    fetchPointAttributes,
+    fetchPoints,
+    fetchPointTimeseries,
+    fetchMultiPointTimeseries,
+    fetchPointStats,
+  };
+}
diff --git a/src/hooks/useUrlState.ts b/src/hooks/useUrlState.ts
new file mode 100644
index 0000000..972a28a
--- /dev/null
+++ b/src/hooks/useUrlState.ts
@@ -0,0 +1,96 @@
+import { useEffect, useRef } from 'react';
+import { useAppContext } from '../context/AppContext';
+import { AppAction } from '../types';
+
+// Keys we serialize to URL
+const URL_KEYS = [
+  'colorBy', 'vmin', 'vmax', 'colormap', 'basemap', 'filter',
+  'lat', 'lon', 'zoom', 'theme',
+] as const;
+
+/**
+ * Parse URL search params into partial state overrides.
+ * Called once on mount to restore a shared view.
+ */
+export function parseUrlState(): Record<string, string> {
+  const params = new URLSearchParams(window.location.search);
+  const result: Record<string, string> = {};
+  for (const key of URL_KEYS) {
+    const val = params.get(key);
+    if (val !== null) result[key] = val;
+  }
+  return result;
+}
+
+/**
+ * Hook that syncs relevant app state to the URL search params.
+ * Updates URL with history.replaceState (no page reload, no history spam).
+ */
+export function useUrlStateSync() {
+  const { state } = useAppContext();
+  const isFirstRender = useRef(true);
+
+  useEffect(() => {
+    // Skip the first render — let parseUrlState handle initial load
+    if (isFirstRender.current) {
+      isFirstRender.current = false;
+      return;
+    }
+
+    // Read existing params (preserves lat/lon/zoom written by moveend)
+    const params = new URLSearchParams(window.location.search);
+
+    // Helper: set if non-default, delete if default
+    const setOrDelete = (key: string, value: string, isDefault: boolean) => {
+      if (isDefault) { params.delete(key); } else { params.set(key, value); }
+    };
+
+    // Point viz state
+    setOrDelete('colorBy', state.pointColorBy, !state.pointColorBy || state.pointColorBy === 'velocity');
+    setOrDelete('vmin', state.pointVmin.toFixed(2), state.pointVmin === -10);
+    setOrDelete('vmax', state.pointVmax.toFixed(2), state.pointVmax === 10);
+    setOrDelete('colormap', state.pointColormap, state.pointColormap === 'rdbu_r');
+    setOrDelete('basemap', state.pointBasemap, state.pointBasemap === 'satellite');
+    setOrDelete('filter', state.pointFilter, !state.pointFilter);
+    setOrDelete('theme', state.chartTheme, state.chartTheme === 'dark');
+
+    const search = params.toString();
+    const url = search ? `?${search}` : window.location.pathname;
+    window.history.replaceState(null, '', url);
+  }, [
+    state.pointColorBy, state.pointVmin, state.pointVmax,
+    state.pointColormap, state.pointBasemap, state.pointFilter,
+    state.chartTheme,
+  ]);
+}
+
+/**
+ * Apply URL params to the app state during initialization.
+ * Call this after the default init in App.tsx.
+ */
+export function applyUrlState(
+  dispatch: React.Dispatch<AppAction>,
+  urlState: Record<string, string>,
+) {
+  if (urlState.colorBy) {
+    dispatch({ type: 'SET_POINT_COLOR_BY', payload: urlState.colorBy });
+  }
+  if (urlState.vmin) {
+    dispatch({ type: 'SET_POINT_VMIN', payload: parseFloat(urlState.vmin) });
+  }
+  if (urlState.vmax) {
+    dispatch({ type: 'SET_POINT_VMAX', payload: parseFloat(urlState.vmax) });
+  }
+  if (urlState.colormap) {
+    dispatch({ type: 'SET_POINT_COLORMAP', payload: urlState.colormap });
+  }
+  if (urlState.basemap) {
+    dispatch({ type: 'SET_POINT_BASEMAP', payload: urlState.basemap as 'satellite' | 'osm' | 'dark' });
+  }
+  if (urlState.filter) {
+    dispatch({ type: 'SET_POINT_FILTER', payload: urlState.filter });
+  }
+  if (urlState.theme === 'light') {
+    dispatch({ type: 'SET_CHART_THEME', payload: 'light' });
+  }
+}
diff --git a/src/plotly.d.ts b/src/plotly.d.ts
new file mode 100644
index 0000000..4edb34c
--- /dev/null
+++ b/src/plotly.d.ts
@@ -0,0 +1,20 @@
+declare module 'react-plotly.js' {
+  import { Component } from 'react';
+  import Plotly from 'plotly.js-dist-min';
+
+  interface PlotParams {
+    data: Plotly.Data[];
+    layout?: Partial<Plotly.Layout>;
+    config?: Partial<Plotly.Config>;
+    style?: React.CSSProperties;
+    useResizeHandler?: boolean;
+    onInitialized?: (figure: Plotly.Figure, graphDiv: HTMLElement) => void;
+    onUpdate?: (figure: Plotly.Figure, graphDiv: HTMLElement) => void;
+  }
+
+  export default class Plot extends Component<PlotParams> {}
+}
+
+declare module 'plotly.js-dist-min' {
+  export * from 'plotly.js';
+}
diff --git a/src/test/setup.ts b/src/test/setup.ts
new file mode 100644
index 0000000..7b0828b
--- /dev/null
+++ b/src/test/setup.ts
@@ -0,0 +1 @@
+import '@testing-library/jest-dom';
diff --git a/src/types.ts b/src/types.ts
index 6ff72ae..dd7a026 100644
--- a/src/types.ts
+++ b/src/types.ts
@@ -8,6 +8,7 @@ export interface RasterGroup {
   algorithm: string | null;
   latlon_bounds: [number, number, number, number];
   x_values: Array<number | string>;
+  reference_date?: string | null;
 }
 
 export interface TimeSeriesPoint {
@@ -42,6 +43,28 @@ export interface BaseMapItem {
   attribution: string;
 }
 
+export interface GpsStation {
+  id: string;
+  name: string;
+  lon: number;
+  lat: number;
+}
+
+export interface GpsTimeseriesEntry {
+  date: string;
+  displacement: number;
+  east: number;
+  north: number;
+  up: number;
+}
+
+export type GpsComponent = 'los' | 'east' | 'north' | 'up';
+
+export interface ClickedPointTimeseries {
+  pointId: number;
+  timeseries: Array<{ date: string; displacement: number }>;
+}
+
 export interface AppState {
   datasetInfo: { [key: string]: RasterGroup };
   timeSeriesPoints: TimeSeriesPoint[];
@@ -58,6 +81,35 @@ export interface AppState {
   showChart: boolean;
   selectedPointId: string | null;
   showTrends: boolean;
+  // V2 point layer state
+  activePointLayer: string | null;
+  pointLayerBounds: [number, number, number, number] | null;
+  clickedPoints: ClickedPointTimeseries[];
+  pointColorBy: string;
+  pointVmin: number;
+  pointVmax: number;
+  pointAttributes: Record<string, { type: string; min?: number; max?: number; mean?: number; count?: number }>;
+  pointFilter: string;
+  pointBasemap: 'satellite' | 'osm' | 'dark';
+  pointColormap: string;
+  referencePointId: number | null;
+  referenceTimeseries: Array<{ date: string; displacement: number }>;
+  // Histogram bins for current color-by attribute
+  pointHistogram: { edges: number[]; counts: number[] } | null;
+  // Chart theme
+  chartTheme: 'dark' | 'light';
+  // Layer visibility
+  rasterLayerVisible: boolean;
+  pointLayerVisible: boolean;
+  pointOpacity: number;
+  // GPS overlay state
+  gpsVisible: boolean;
+  gpsLoading: boolean;
+  gpsStations: GpsStation[];
+  gpsSelectedStationId: string | null;
+  gpsTimeseries: GpsTimeseriesEntry[];
+  gpsComponent: GpsComponent;
+  gpsLosInfo: { type: string; east?: number; north?: number; up?: number } | null;
 }
 
 export type AppAction =
@@ -79,7 +131,35 @@ export type AppAction =
   | { type: 'SET_OPACITY'; payload: number }
   | { type: 'TOGGLE_CHART' }
   | { type: 'SET_SELECTED_POINT'; payload: string | null }
-  | { type: 'TOGGLE_TRENDS' };
+  | { type: 'TOGGLE_TRENDS' }
+  // V2 point layer actions
+  | { type: 'SET_ACTIVE_POINT_LAYER'; payload: string }
+  | { type: 'SET_POINT_LAYER_BOUNDS'; payload: [number, number, number, number] }
+  | { type: 'SET_CLICKED_POINT_TIMESERIES'; payload: ClickedPointTimeseries }
+  | { type: 'CLEAR_CLICKED_POINTS' }
+  | { type: 'REMOVE_CLICKED_POINT'; payload: number }
+  | { type: 'SET_POINT_COLOR_BY'; payload: string }
+  | { type: 'SET_POINT_VMIN'; payload: number }
+  | { type: 'SET_POINT_VMAX'; payload: number }
+  | { type: 'SET_POINT_ATTRIBUTES'; payload: Record<string, { type: string; min?: number; max?: number; mean?: number; count?: number }> }
+  | { type: 'SET_POINT_FILTER'; payload: string }
+  | { type: 'SET_POINT_BASEMAP'; payload: 'satellite' | 'osm' | 'dark' }
+  | { type: 'SET_POINT_COLORMAP'; payload: string }
+  | { type: 'SET_REFERENCE_POINT'; payload: { pointId: number; timeseries: Array<{ date: string; displacement: number }> } }
+  | { type: 'CLEAR_REFERENCE_POINT' }
+  | { type: 'SET_CHART_THEME'; payload: 'dark' | 'light' }
+  | { type: 'SET_POINT_HISTOGRAM'; payload: { edges: number[]; counts: number[] } | null }
+  | { type: 'SET_RASTER_LAYER_VISIBLE'; payload: boolean }
+  | { type: 'SET_POINT_LAYER_VISIBLE'; payload: boolean }
+  | { type: 'SET_POINT_OPACITY'; payload: number }
+  // GPS actions
+  | { type: 'SET_GPS_VISIBLE'; payload: boolean }
+  | { type: 'SET_GPS_LOADING'; payload: boolean }
+  | { type: 'SET_GPS_STATIONS'; payload: GpsStation[] }
+  | { type: 'SET_GPS_SELECTED_STATION'; payload: string | null }
+  | { type: 'SET_GPS_TIMESERIES'; payload: GpsTimeseriesEntry[] }
+  | { type: 'SET_GPS_COMPONENT'; payload: GpsComponent }
+  | { type: 'SET_GPS_LOS_INFO'; payload: { type: string; east?: number; north?: number; up?: number } | null };
 
 // Backward compatibility
 export type LegacyAppAction = { type: 'SET_TS_MARKER_POSITION'; payload: [number, number] };
diff --git a/tests/test_convert_dolphin.py b/tests/test_convert_dolphin.py
new file mode 100644
index 0000000..cc50898
--- /dev/null
+++ b/tests/test_convert_dolphin.py
@@ -0,0 +1,142 @@
+"""Tests for the dolphin-to-GeoParquet converter."""
+
+import json
+from pathlib import Path
+
+import geopandas as gpd
+import numpy as np
+import pyarrow.parquet as pq
+import rasterio as rio
+from rasterio.transform import from_bounds
+
+from bowser._convert_dolphin import convert_dolphin
+
+
+def _make_synthetic_dolphin_dir(tmp_path: Path, n_dates: int = 5) -> Path:
+    """Create a minimal synthetic dolphin workflow directory for testing."""
+    work_dir = tmp_path / "dolphin_work"
+    ts_dir = work_dir / "timeseries"
+    ifg_dir = work_dir / "interferograms"
+    ts_dir.mkdir(parents=True)
+    ifg_dir.mkdir(parents=True)
+
+    # Small 10x10 raster, EPSG:4326 for simplicity
+    nrows, ncols = 10, 10
+    west, south, east, north = -118.5, 33.8, -118.4, 33.9
+    transform = from_bounds(west, south, east, north, ncols, nrows)
+    crs = rio.crs.CRS.from_epsg(4326)
+    profile = {
+        "driver": "GTiff",
+        "height": nrows,
+        "width": ncols,
+        "count": 1,
+        "dtype": "float32",
+        "crs": crs,
+        "transform": transform,
+        "nodata": 0.0,
+    }
+
+    # Temporal coherence: top half > 0.7, bottom half < 0.3
+    coh = np.zeros((nrows, ncols), dtype=np.float32)
+    coh[:5, :] = 0.8
+    coh[5:, :] = 0.2
+    coh_path = ifg_dir / "temporal_coherence_average_20200101_20201231.tif"
+    with rio.open(coh_path, "w", **profile) as dst:
+        dst.write(coh, 1)
+
+    # Velocity: linear gradient
+    vel = np.linspace(-20, 20, nrows * ncols).reshape(nrows, ncols).astype(np.float32)
+    vel_path = ts_dir / "velocity.tif"
+    with rio.open(vel_path, "w", **profile) as dst:
+        dst.write(vel, 1)
+
+    # Amplitude dispersion
+    amp = np.full((nrows, ncols), 0.3, dtype=np.float32)
+    amp_path = ifg_dir / "amp_dispersion_looked.tif"
+    with rio.open(amp_path, "w", **profile) as dst:
+        dst.write(amp, 1)
+
+    # Time series: n_dates rasters with linear trend
+    from datetime import date, timedelta
+
+    start = date(2020, 1, 1)
+    for i in range(n_dates):
+        d = start + timedelta(days=i * 12)
+        date_str = d.strftime("%Y%m%d")
+        ts_data = (vel * (i + 1) / 365.25).astype(np.float32)
+        ts_path = ts_dir / f"{date_str}.tif"
+        with rio.open(ts_path, "w", **profile) as dst:
+            dst.write(ts_data, 1)
+
+    return work_dir
+
+
+def test_convert_dolphin_basic(tmp_path):
+    """Test that converter produces valid GeoParquet files and manifest."""
+    n_dates = 5
+    work_dir = _make_synthetic_dolphin_dir(tmp_path, n_dates=n_dates)
+    output_dir = tmp_path / "output"
+
+    manifest_path = convert_dolphin(
+        work_dir=str(work_dir),
+        output_dir=str(output_dir),
+        coherence_threshold=0.5,
+    )
+
+    # Check output files exist
+    assert manifest_path.exists()
+    assert (output_dir / "points.parquet").exists()
+    assert (output_dir / "timeseries.parquet").exists()
+
+    # Check manifest
+    with open(manifest_path) as f:
+        manifest = json.load(f)
+    assert "ps_points" in manifest["layers"]
+    assert manifest["layers"]["ps_points"]["type"] == "points"
+    assert manifest["bounds"] is not None
+
+    # Check points table
+    points_gdf = gpd.read_parquet(output_dir / "points.parquet")
+    # Only top 5 rows (coherence > 0.5) should survive: 5 rows * 10 cols = 50 points
+    assert len(points_gdf) == 50
+    assert "point_id" in points_gdf.columns
+    assert "velocity" in points_gdf.columns
+    assert "temporal_coherence" in points_gdf.columns
+    assert "amplitude_dispersion" in points_gdf.columns
+    assert points_gdf.crs.to_epsg() == 4326
+
+    # Check all temporal coherence values are > threshold
+    assert (points_gdf["temporal_coherence"] > 0.5).all()
+
+    # Check timeseries table
+    ts_table = pq.read_table(output_dir / "timeseries.parquet")
+    ts_df = ts_table.to_pandas()
+    assert len(ts_df) == 50 * n_dates  # 50 points * 5 dates
+    assert set(ts_df.columns) == {"point_id", "date", "displacement"}
+
+    # Check that each point has exactly n_dates entries
+    counts = ts_df.groupby("point_id").size()
+    assert (counts == n_dates).all()
+
+    # Check column metadata for units
+    displacement_field = ts_table.schema.field("displacement")
+    assert displacement_field.metadata is not None
+    assert displacement_field.metadata[b"units"] == b"mm"
+
+
+def test_convert_dolphin_amplitude_filter(tmp_path):
+    """Test that amplitude dispersion filter works."""
+    work_dir = _make_synthetic_dolphin_dir(tmp_path)
+    output_dir = tmp_path / "output"
+
+    # Use amplitude threshold that should reject all points (threshold < 0.3)
+    convert_dolphin(
+        work_dir=str(work_dir),
+        output_dir=str(output_dir),
+        coherence_threshold=0.5,
+        amplitude_dispersion_threshold=0.1,
+    )
+
+    points_gdf = gpd.read_parquet(output_dir / "points.parquet")
+    # All points have amp_disp=0.3, threshold is 0.1 → none pass
+    assert len(points_gdf) == 0
diff --git a/tests/test_e2e.py b/tests/test_e2e.py
new file mode 100644
index 0000000..d44d4eb
--- /dev/null
+++ b/tests/test_e2e.py
@@ -0,0 +1,223 @@
+"""End-to-end browser tests for Bowser V2 using Playwright.
+
+These tests start a real Bowser server with synthetic data, then drive
+a headless Chromium browser to verify the UI works end-to-end.
+
+Run with:
+    pixi run pytest tests/test_e2e.py -x -v --headed  # visible browser
+    pixi run pytest tests/test_e2e.py -x -v            # headless
+"""
+
+from __future__ import annotations
+
+import os
+import socket
+import subprocess
+import sys
+import time
+from pathlib import Path
+
+import pytest
+
+
+def _find_free_port() -> int:
+    with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as s:
+        s.bind(("127.0.0.1", 0))
+        return s.getsockname()[1]
+
+
+@pytest.fixture(scope="session")
+def testdata_dir(tmp_path_factory):
+    """Generate synthetic test data once per session."""
+    out = tmp_path_factory.mktemp("bowser_e2e")
+    from bowser._generate_testdata import generate_testdata
+
+    generate_testdata(
+        output_dir=out,
+        n_points=5_000,
+        n_dates=10,
+        seed=42,
+    )
+    return out
+
+
+@pytest.fixture(scope="session")
+def bowser_server(testdata_dir):
+    """Start a Bowser server with synthetic data, yield its URL, then shut down."""
+    port = _find_free_port()
+    manifest = testdata_dir / "bowser_manifest.json"
+
+    env = os.environ.copy()
+    env["BOWSER_MANIFEST_FILE"] = str(manifest)
+
+    # Use pixi to run the server so it gets the full default environment
+    # (sys.executable might point to a stripped-down test env).
+    repo_root = Path(__file__).parent.parent
+    pixi_python = repo_root / ".pixi" / "envs" / "default" / "bin" / "python"
+    python_exe = str(pixi_python) if pixi_python.exists() else sys.executable
+
+    proc = subprocess.Popen(
+        [
+            python_exe,
+            "-m",
+            "uvicorn",
+            "bowser.main:app",
+            "--port",
+            str(port),
+            "--log-level",
+            "warning",
+        ],
+        env=env,
+        stdout=subprocess.PIPE,
+        stderr=subprocess.PIPE,
+        cwd=str(repo_root),
+    )
+
+    base_url = f"http://localhost:{port}"
+
+    # Wait for server to be ready
+    import urllib.request
+
+    for _ in range(60):
+        try:
+            urllib.request.urlopen(f"{base_url}/points/layers", timeout=1)
+            break
+        except Exception:
+            time.sleep(0.5)
+    else:
+        proc.kill()
+        stdout, stderr = proc.communicate()
+        raise RuntimeError(
+            f"Bowser server failed to start.\n"
+            f"stdout: {stdout.decode()}\n"
+            f"stderr: {stderr.decode()}"
+        )
+
+    yield base_url
+
+    proc.terminate()
+    proc.wait(timeout=5)
+    proc.stdout.close()
+    proc.stderr.close()
+
+
+# ---------------------------------------------------------------------------
+# Tests
+# ---------------------------------------------------------------------------
+
+
+def test_app_loads(bowser_server, page):
+    """App loads and the map container is visible."""
+    page.goto(bowser_server)
+    # Wait for the map canvas to appear (MapLibre GL renders to a canvas)
+    page.wait_for_selector("canvas", timeout=15_000)
+    assert page.locator("canvas").count() >= 1
+
+
+def test_point_controls_panel_visible(bowser_server, page):
+    """The point controls panel renders with layer toggles."""
+    page.goto(bowser_server)
+    page.wait_for_selector("canvas", timeout=15_000)
+
+    # The panel should contain "Layers" header
+    panel = page.locator("text=Layers")
+    assert panel.count() >= 1
+
+    # Should have the Points checkbox
+    points_checkbox = page.locator("text=Points")
+    assert points_checkbox.count() >= 1
+
+
+def test_colormap_selector(bowser_server, page):
+    """Colormap dropdown has multiple options."""
+    page.goto(bowser_server)
+    page.wait_for_selector("canvas", timeout=15_000)
+
+    # Find colormap select
+    colormap_select = page.locator("select").filter(has_text="rdbu_r")
+    assert colormap_select.count() >= 1
+
+    # Change to viridis
+    colormap_select.first.select_option("viridis")
+    # Verify it changed
+    assert colormap_select.first.input_value() == "viridis"
+
+
+def test_basemap_switcher(bowser_server, page):
+    """Basemap buttons switch between satellite/OSM/dark."""
+    page.goto(bowser_server)
+    page.wait_for_selector("canvas", timeout=15_000)
+
+    # Click the OSM button
+    osm_button = page.locator("button", has_text="OpenStreetMap")
+    assert osm_button.count() >= 1
+    osm_button.click()
+
+    # Click the Dark button
+    dark_button = page.locator("button", has_text="Dark")
+    assert dark_button.count() >= 1
+    dark_button.click()
+
+
+def test_stats_overlay_shows_point_count(bowser_server, page):
+    """The stats overlay at the bottom shows point count."""
+    page.goto(bowser_server)
+    page.wait_for_selector("canvas", timeout=15_000)
+
+    # Wait for points to load (the status bar appears after fetch)
+    stats = page.locator("text=points")
+    stats.first.wait_for(timeout=20_000)
+    text = stats.first.text_content()
+    assert text is not None
+    assert "points" in text
+
+
+def test_filter_panel(bowser_server, page):
+    """Can add and remove an attribute filter."""
+    page.goto(bowser_server)
+    page.wait_for_selector("canvas", timeout=15_000)
+
+    # Wait for the filter section
+    page.locator("text=Filter").first.wait_for(timeout=10_000)
+
+    # Fill in filter value and click +
+    filter_input = page.locator("input[placeholder='val']")
+    filter_input.fill("0.7")
+
+    add_button = page.locator("button", has_text="+")
+    add_button.click()
+
+    # Should see the filter expression
+    page.wait_for_selector("text=velocity>0.7", timeout=5_000)
+
+    # Clear filters
+    clear_button = page.locator("text=Clear all filters")
+    clear_button.click()
+
+
+def test_click_point_shows_timeseries(bowser_server, page):
+    """Clicking on the map in the point area shows a time series chart."""
+    page.goto(bowser_server)
+    page.wait_for_selector("canvas", timeout=15_000)
+
+    # Wait for points to be loaded
+    page.locator("text=points").first.wait_for(timeout=20_000)
+
+    # Give deck.gl a moment to render the points
+    page.wait_for_timeout(2_000)
+
+    # Click in the center of the map (where points should be clustered)
+    map_div = page.locator("canvas").first
+    box = map_div.bounding_box()
+    assert box is not None
+    page.mouse.click(box["x"] + box["width"] / 2, box["y"] + box["height"] / 2)
+
+    # Wait for chart to appear (it's a plotly chart in a div)
+    # The chart panel has a "Date" axis label
+    try:
+        page.wait_for_selector("text=Displacement", timeout=8_000)
+    except Exception:
+        # Point may not have been hit — that's OK for this test,
+        # as deck.gl hit testing depends on exact pixel coordinates.
+        # Just verify the click didn't crash the app.
+        assert page.locator("canvas").count() >= 1
diff --git a/tests/test_gps.py b/tests/test_gps.py
new file mode 100644
index 0000000..34db3cb
--- /dev/null
+++ b/tests/test_gps.py
@@ -0,0 +1,144 @@
+"""Tests for GPS overlay endpoints with mocked geepers."""
+
+from unittest.mock import MagicMock, patch
+
+import geopandas as gpd
+import numpy as np
+import pandas as pd
+import pytest
+from fastapi import FastAPI
+from fastapi.testclient import TestClient
+from shapely.geometry import Point
+
+from bowser.gps import _project_enu_to_los, init_gps, router
+from bowser.manifest import LosConfig, LosVectorConstant
+
+
+@pytest.fixture
+def mock_gps_source():
+    """Create a mock geepers UnrSource with synthetic station data."""
+    source = MagicMock()
+
+    # stations() returns a GeoDataFrame (matches real geepers format)
+    stations_gdf = gpd.GeoDataFrame(
+        {
+            "id": ["TEST", "ABC1", "XYZ2"],
+            "lat": [19.4, 19.5, 19.3],
+            "lon": [-99.1, -99.2, -99.0],
+            "alt": [2200.0, 2300.0, 2100.0],
+        },
+        geometry=[Point(-99.1, 19.4), Point(-99.2, 19.5), Point(-99.0, 19.3)],
+        crs="EPSG:4326",
+    )
+    source.stations.return_value = stations_gdf
+
+    # station_lonlat() returns (lon, lat)
+    source.station_lonlat.return_value = (-99.1, 19.4)
+
+    # timeseries() returns a DataFrame with 'date' column and ENU in meters
+    dates = pd.date_range("2020-01-01", periods=50, freq="7D")
+    rng = np.random.default_rng(42)
+    ts_df = pd.DataFrame(
+        {
+            "date": dates,
+            "east": rng.normal(0, 0.002, 50),  # meters
+            "north": rng.normal(0, 0.003, 50),
+            "up": np.linspace(0, -0.05, 50)
+            + rng.normal(0, 0.001, 50),  # 50mm subsidence
+        },
+    )
+    source.timeseries.return_value = ts_df
+
+    return source
+
+
+@pytest.fixture
+def constant_los_config():
+    """Typical Sentinel-1 descending LOS vector."""
+    return LosConfig(
+        type="constant",
+        los_enu=LosVectorConstant(east=0.477, north=-0.449, up=0.755),
+    )
+
+
+@pytest.fixture
+def test_app(mock_gps_source, constant_los_config):
+    """Create a test FastAPI app with GPS endpoints."""
+    app = FastAPI()
+    app.include_router(router)
+
+    with patch("geepers.gps_sources.UnrSource", return_value=mock_gps_source):
+        init_gps(constant_los_config)
+
+    # Ensure module-level source is our mock
+    import bowser.gps as gps_module
+
+    gps_module._gps_source = mock_gps_source
+
+    return TestClient(app)
+
+
+def test_los_info(test_app):
+    """Test GET /gps/los_info returns LOS config."""
+    response = test_app.get("/gps/los_info")
+    assert response.status_code == 200
+    data = response.json()
+    assert data["type"] == "constant"
+    assert abs(data["east"] - 0.477) < 1e-6
+    assert abs(data["north"] - (-0.449)) < 1e-6
+    assert abs(data["up"] - 0.755) < 1e-6
+
+
+def test_get_stations(test_app):
+    """Test GET /gps/stations returns station list."""
+    response = test_app.get("/gps/stations?bbox=-99.5,19.0,-98.5,20.0")
+    assert response.status_code == 200
+    data = response.json()
+    assert len(data) == 3
+    assert data[0]["id"] == "TEST"
+    assert abs(data[0]["lon"] - (-99.1)) < 1e-6
+
+
+def test_get_station_timeseries(test_app):
+    """Test GET /gps/stations/{id}/timeseries returns LOS + ENU."""
+    response = test_app.get("/gps/stations/TEST/timeseries")
+    assert response.status_code == 200
+    data = response.json()
+    assert data["station_id"] == "TEST"
+    assert "los_vector" in data
+    assert len(data["timeseries"]) > 0
+
+    entry = data["timeseries"][0]
+    assert "date" in entry
+    assert "displacement" in entry
+    assert "east" in entry
+    assert "north" in entry
+    assert "up" in entry
+
+
+def test_enu_to_los_projection():
+    """Verify dot product: pure subsidence with typical S1 descending geometry."""
+    los_e, los_n, los_u = 0.477, -0.449, 0.755
+
+    # Pure 10mm subsidence (up = -10mm)
+    east = np.array([0.0])
+    north = np.array([0.0])
+    up = np.array([-10.0])
+
+    result = _project_enu_to_los(east, north, up, los_e, los_n, los_u)
+    # -10 * 0.755 = -7.55 (motion away from satellite)
+    assert result[0] == pytest.approx(-7.55, abs=0.01)
+
+
+def test_enu_to_los_pure_east():
+    """Pure eastward motion."""
+    los_e, los_n, los_u = 0.477, -0.449, 0.755
+    result = _project_enu_to_los(
+        np.array([10.0]),
+        np.array([0.0]),
+        np.array([0.0]),
+        los_e,
+        los_n,
+        los_u,
+    )
+    assert result[0] == pytest.approx(4.77, abs=0.01)
diff --git a/tests/test_points.py b/tests/test_points.py
new file mode 100644
index 0000000..ed79007
--- /dev/null
+++ b/tests/test_points.py
@@ -0,0 +1,222 @@
+"""Tests for the DuckDB-backed point query endpoints."""
+
+
+import geopandas as gpd
+import numpy as np
+import pyarrow as pa
+import pyarrow.ipc as ipc
+import pyarrow.parquet as pq
+import pytest
+
+# Use httpx for testing FastAPI
+from fastapi import FastAPI
+from fastapi.testclient import TestClient
+from shapely.geometry import Point
+
+from bowser.manifest import PointLayerConfig
+from bowser.points import init_point_layers, router
+
+
+@pytest.fixture
+def synthetic_point_data(tmp_path):
+    """Create synthetic point + timeseries GeoParquet files."""
+    n_points = 100
+    n_dates = 10
+
+    # Points table
+    lons = np.random.uniform(-118.5, -118.0, n_points)
+    lats = np.random.uniform(33.5, 34.0, n_points)
+    gdf = gpd.GeoDataFrame(
+        {
+            "point_id": np.arange(n_points, dtype=np.uint64),
+            "velocity": np.random.normal(-5, 10, n_points).astype(np.float32),
+            "temporal_coherence": np.random.uniform(0.3, 1.0, n_points).astype(
+                np.float32
+            ),
+        },
+        geometry=[Point(lon, lat) for lon, lat in zip(lons, lats)],
+        crs="EPSG:4326",
+    )
+
+    points_path = tmp_path / "points.parquet"
+    gdf.to_parquet(points_path)
+
+    # Timeseries table
+    from datetime import date, timedelta
+
+    dates = [date(2020, 1, 1) + timedelta(days=i * 12) for i in range(n_dates)]
+    rows = []
+    for pid in range(n_points):
+        vel = gdf.loc[pid, "velocity"]
+        for i, d in enumerate(dates):
+            disp = float(vel) / 365.25 * (i * 12) + np.random.normal(0, 1)
+            rows.append((np.uint64(pid), d, np.float32(disp)))
+
+    ts_table = pa.table(
+        {
+            "point_id": pa.array([r[0] for r in rows], type=pa.uint64()),
+            "date": pa.array([r[1] for r in rows], type=pa.date32()),
+            "displacement": pa.array([r[2] for r in rows], type=pa.float32()),
+        }
+    )
+    ts_path = tmp_path / "timeseries.parquet"
+    pq.write_table(ts_table, ts_path)
+
+    return {
+        "points_path": str(points_path),
+        "ts_path": str(ts_path),
+        "n_points": n_points,
+        "n_dates": n_dates,
+        "gdf": gdf,
+    }
+
+
+@pytest.fixture
+def test_app(synthetic_point_data):
+    """Create a test FastAPI app with point endpoints."""
+    app = FastAPI()
+    app.include_router(router)
+
+    layers = {
+        "test_layer": PointLayerConfig(
+            points_source=synthetic_point_data["points_path"],
+            timeseries_source=synthetic_point_data["ts_path"],
+        )
+    }
+    init_point_layers(layers)
+
+    return TestClient(app)
+
+
+def test_list_layers(test_app):
+    """Test listing available point layers."""
+    response = test_app.get("/points/layers")
+    assert response.status_code == 200
+    data = response.json()
+    assert "test_layer" in data
+
+
+def test_get_attributes(test_app):
+    """Test getting attribute metadata for a layer."""
+    response = test_app.get("/points/test_layer/attributes")
+    assert response.status_code == 200
+    data = response.json()
+    attrs = data["attributes"]
+    assert "velocity" in attrs
+    assert "temporal_coherence" in attrs
+    assert "point_id" in attrs
+    assert "min" in attrs["velocity"]
+    assert "max" in attrs["velocity"]
+
+
+def test_get_points_no_filter(test_app, synthetic_point_data):
+    """Test fetching all points without filters."""
+    response = test_app.get("/points/test_layer")
+    assert response.status_code == 200
+    assert response.headers["content-type"] == "application/vnd.apache.arrow.stream"
+
+    # Decode Arrow IPC
+    reader = ipc.open_stream(response.content)
+    table = reader.read_all()
+    assert len(table) == synthetic_point_data["n_points"]
+    assert "point_id" in table.column_names
+    assert "lon" in table.column_names
+    assert "lat" in table.column_names
+    assert "velocity" in table.column_names
+
+
+def test_get_points_with_bbox(test_app):
+    """Test fetching points within a bounding box."""
+    # Very small bbox that should contain fewer points
+    response = test_app.get("/points/test_layer?bbox=-118.3,-118.2,33.7,33.8")
+    assert response.status_code == 200
+    reader = ipc.open_stream(response.content)
+    table = reader.read_all()
+    # Should have fewer points than total (or possibly zero, that's ok)
+    assert len(table) <= 100
+
+
+def test_get_points_with_filter(test_app):
+    """Test fetching points with an attribute filter."""
+    response = test_app.get("/points/test_layer?filter=velocity<-10")
+    assert response.status_code == 200
+    reader = ipc.open_stream(response.content)
+    table = reader.read_all()
+    # All returned velocities should be < -10
+    velocities = table.column("velocity").to_pylist()
+    for v in velocities:
+        assert v < -10
+
+
+def test_get_point_timeseries(test_app, synthetic_point_data):
+    """Test fetching time series for a single point."""
+    response = test_app.get("/points/test_layer/0/timeseries")
+    assert response.status_code == 200
+    data = response.json()
+    assert len(data) == synthetic_point_data["n_dates"]
+    assert "date" in data[0]
+    assert "displacement" in data[0]
+
+
+def test_get_multi_point_timeseries(test_app):
+    """Test fetching time series for multiple points."""
+    response = test_app.post(
+        "/points/test_layer/timeseries",
+        json={"point_ids": [0, 1, 2]},
+    )
+    assert response.status_code == 200
+    data = response.json()
+    assert "series" in data
+    assert "0" in data["series"] or 0 in data["series"]
+
+
+def test_get_stats(test_app, synthetic_point_data):
+    """Test getting summary statistics."""
+    response = test_app.get("/points/test_layer/stats")
+    assert response.status_code == 200
+    data = response.json()
+    assert "count" in data
+    assert data["count"] == synthetic_point_data["n_points"]
+    assert "velocity_mean" in data
+
+
+def test_export_csv(test_app, synthetic_point_data):
+    """Test exporting points as CSV."""
+    response = test_app.get("/points/test_layer/export?format=csv")
+    assert response.status_code == 200
+    assert "text/csv" in response.headers["content-type"]
+    text = response.content.decode()
+    assert "point_id" in text
+    assert "longitude" in text
+    lines = [
+        line for line in text.strip().split("\n") if line and not line.startswith("#")
+    ]
+    # header + data rows
+    assert len(lines) == synthetic_point_data["n_points"] + 1
+
+
+def test_export_geojson(test_app):
+    """Test exporting points as GeoJSON."""
+    response = test_app.get("/points/test_layer/export?format=geojson")
+    assert response.status_code == 200
+    data = response.json()
+    assert data["type"] == "FeatureCollection"
+    assert len(data["features"]) > 0
+    assert data["features"][0]["geometry"]["type"] == "Point"
+
+
+def test_export_parquet(test_app):
+    """Test exporting points as Parquet."""
+    import pyarrow.parquet as pq
+
+    response = test_app.get("/points/test_layer/export?format=parquet")
+    assert response.status_code == 200
+    table = pq.read_table(pa.BufferReader(response.content))
+    assert "point_id" in table.column_names
+    assert "longitude" in table.column_names
+
+
+def test_unknown_layer_404(test_app):
+    """Test that requesting an unknown layer returns 404."""
+    response = test_app.get("/points/nonexistent/attributes")
+    assert response.status_code == 404
diff --git a/tests/test_titiler.py b/tests/test_titiler.py
new file mode 100644
index 0000000..c6fe31e
--- /dev/null
+++ b/tests/test_titiler.py
@@ -0,0 +1,146 @@
+"""Tests for bowser.titiler date formatting and reference date detection."""
+
+from datetime import datetime
+
+import pytest
+
+
+class TestRasterGroupReferenceDate:
+    """Test reference_date via the integration test data.
+
+    Uses the displacement COG files in tests/data/geotiffs/ which have
+    filenames like displacement_20160708_20160801.tif (shared ref date).
+    """
+
+    @pytest.fixture()
+    def raster_group_shared_ref(self):
+        """RasterGroup with a shared reference date across all files."""
+        from pathlib import Path
+
+        from bowser.titiler import RasterGroup
+
+        data_dir = Path(__file__).parent / "data/geotiffs"
+        disp_files = sorted(data_dir.glob("displacement_*.tif"))
+        assert len(disp_files) > 1, "Need displacement test files"
+
+        rg = RasterGroup(
+            name="test_displacement",
+            file_list=[str(f) for f in disp_files],
+            file_date_fmt="%Y%m%d",
+        )
+        return rg
+
+    @pytest.fixture()
+    def raster_group_no_dates(self):
+        """RasterGroup with date parsing disabled."""
+        from pathlib import Path
+
+        from bowser.titiler import RasterGroup
+
+        data_dir = Path(__file__).parent / "data/geotiffs"
+        disp_file = sorted(data_dir.glob("displacement_*.tif"))[0]
+
+        rg = RasterGroup(
+            name="test_no_dates",
+            file_list=[str(disp_file)],
+            file_date_fmt=None,
+        )
+        return rg
+
+    def test_x_values_are_iso_dates(self, raster_group_shared_ref):
+        x = raster_group_shared_ref.x_values
+        assert all(isinstance(v, str) for v in x)
+        # Should be ISO format like "2016-08-01"
+        assert all("-" in v for v in x)
+        assert x[0] == "2016-08-01"
+
+    def test_reference_date_detected(self, raster_group_shared_ref):
+        assert raster_group_shared_ref.reference_date == "2016-07-08"
+
+    def test_no_dates_falls_back_to_indexes(self, raster_group_no_dates):
+        x = raster_group_no_dates.x_values
+        assert x == [0]
+
+    def test_no_dates_reference_date_is_none(self, raster_group_no_dates):
+        assert raster_group_no_dates.reference_date is None
+
+
+class TestDuplicateSecondaryDates:
+    """Test that varying reference dates with duplicate secondary dates fall back."""
+
+    def test_duplicate_secondary_dates_fall_back_to_indices(self):
+        """Interferograms with different reference dates can share secondary dates.
+
+        E.g., unwrapped_20160101_20160201.tif and unwrapped_20160115_20160201.tif
+        both have secondary date 2016-02-01. Using only the secondary date as
+        x_value produces duplicates, so we should fall back to integer indices.
+        """
+        from unittest.mock import PropertyMock, patch
+
+        from bowser.titiler import RasterGroup
+
+        # Simulate 4 interferograms: 2 reference dates x 2 secondary dates
+        # ref1_sec1, ref2_sec1, ref1_sec2, ref2_sec2
+        fake_dates = [
+            (datetime(2016, 1, 1), datetime(2016, 2, 1)),
+            (datetime(2016, 1, 15), datetime(2016, 2, 1)),  # dup secondary
+            (datetime(2016, 1, 1), datetime(2016, 2, 15)),
+            (datetime(2016, 1, 15), datetime(2016, 2, 15)),  # dup secondary
+        ]
+        from pathlib import Path
+
+        data_dir = Path(__file__).parent / "data/geotiffs"
+        disp_files = sorted(data_dir.glob("displacement_*.tif"))[:4]
+
+        rg = RasterGroup(
+            name="test_varying_ref",
+            file_list=[str(f) for f in disp_files],
+            file_date_fmt="%Y%m%d",
+        )
+        # Patch the reader's dates to simulate varying reference dates
+        with patch.object(
+            type(rg._reader),
+            "dates",
+            new_callable=PropertyMock,
+            return_value=fake_dates,
+        ):
+            x = rg.x_values
+            # Should use full "ref_secondary" date pair labels
+            assert x == [
+                "2016-01-01_2016-02-01",
+                "2016-01-15_2016-02-01",
+                "2016-01-01_2016-02-15",
+                "2016-01-15_2016-02-15",
+            ]
+            # reference_date should be None (varying first dates)
+            assert rg.reference_date is None
+
+    def test_unique_secondary_dates_use_dates(self):
+        """When secondary dates are all unique, they should be used as x_values."""
+        from unittest.mock import PropertyMock, patch
+
+        from bowser.titiler import RasterGroup
+
+        fake_dates = [
+            (datetime(2016, 1, 1), datetime(2016, 2, 1)),
+            (datetime(2016, 1, 1), datetime(2016, 2, 15)),
+            (datetime(2016, 1, 1), datetime(2016, 3, 1)),
+        ]
+        from pathlib import Path
+
+        data_dir = Path(__file__).parent / "data/geotiffs"
+        disp_files = sorted(data_dir.glob("displacement_*.tif"))[:3]
+
+        rg = RasterGroup(
+            name="test_unique_sec",
+            file_list=[str(f) for f in disp_files],
+            file_date_fmt="%Y%m%d",
+        )
+        with patch.object(
+            type(rg._reader),
+            "dates",
+            new_callable=PropertyMock,
+            return_value=fake_dates,
+        ):
+            x = rg.x_values
+            assert x == ["2016-02-01", "2016-02-15", "2016-03-01"]
diff --git a/tests/visual_test.py b/tests/visual_test.py
new file mode 100755
index 0000000..81ebb51
--- /dev/null
+++ b/tests/visual_test.py
@@ -0,0 +1,229 @@
+#!/usr/bin/env python
+"""Visual screenshot test for Bowser UI.
+
+Starts a Bowser server with synthetic data, drives Playwright through
+key UI states, and saves screenshots to a timestamped directory.
+
+Usage:
+    # Default: headless, 5k points
+    pixi run python tests/visual_test.py
+
+    # With visible browser
+    pixi run python tests/visual_test.py --headed
+
+    # More points for realistic density
+    pixi run python tests/visual_test.py --n-points 50000
+
+    # Custom output directory
+    pixi run python tests/visual_test.py --output-dir screenshots/
+
+Screenshots are saved as numbered PNGs with descriptive names, making it
+easy to review the UI state at each step. Share the directory for review.
+"""
+
+from __future__ import annotations
+
+import argparse
+import os
+import socket
+import subprocess
+import sys
+import time
+from pathlib import Path
+
+
+def _find_free_port() -> int:
+    with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as s:
+        s.bind(("127.0.0.1", 0))
+        return s.getsockname()[1]
+
+
+def main():
+    parser = argparse.ArgumentParser(description="Visual screenshot test for Bowser")
+    parser.add_argument("--headed", action="store_true", help="Show browser window")
+    parser.add_argument("--n-points", type=int, default=5000)
+    parser.add_argument("--n-dates", type=int, default=10)
+    parser.add_argument(
+        "--output-dir",
+        default=None,
+        help="Directory for screenshots (default: screenshots/<timestamp>)",
+    )
+    args = parser.parse_args()
+
+    # Output directory
+    if args.output_dir:
+        out_dir = Path(args.output_dir)
+    else:
+        ts = time.strftime("%Y%m%d_%H%M%S")
+        out_dir = Path("screenshots") / ts
+    out_dir.mkdir(parents=True, exist_ok=True)
+
+    # Generate test data
+    import tempfile
+
+    tmpdir = Path(tempfile.mkdtemp(prefix="bowser_visual_"))
+    print(f"Generating {args.n_points:,} points x {args.n_dates} dates...")
+    from bowser._generate_testdata import generate_testdata
+
+    manifest_path = generate_testdata(
+        output_dir=tmpdir,
+        n_points=args.n_points,
+        n_dates=args.n_dates,
+        seed=42,
+    )
+
+    # Start server
+    port = _find_free_port()
+    env = os.environ.copy()
+    env["BOWSER_MANIFEST_FILE"] = str(manifest_path)
+
+    repo_root = Path(__file__).parent.parent
+    pixi_python = repo_root / ".pixi" / "envs" / "default" / "bin" / "python"
+    python_exe = str(pixi_python) if pixi_python.exists() else sys.executable
+
+    print(f"Starting server on port {port}...")
+    proc = subprocess.Popen(
+        [
+            python_exe,
+            "-m",
+            "uvicorn",
+            "bowser.main:app",
+            "--port",
+            str(port),
+            "--log-level",
+            "warning",
+        ],
+        env=env,
+        stdout=subprocess.PIPE,
+        stderr=subprocess.PIPE,
+        cwd=str(repo_root),
+    )
+
+    base_url = f"http://localhost:{port}"
+
+    # Wait for server
+    import urllib.request
+
+    for _ in range(60):
+        try:
+            urllib.request.urlopen(f"{base_url}/points/layers", timeout=1)
+            break
+        except Exception:
+            time.sleep(0.5)
+    else:
+        proc.kill()
+        stdout, stderr = proc.communicate()
+        print(f"Server failed to start!\nstderr: {stderr.decode()}")
+        sys.exit(1)
+
+    print(f"Server ready at {base_url}")
+
+    step = 0
+
+    def screenshot(page, name: str):
+        nonlocal step
+        step += 1
+        filename = f"{step:02d}_{name}.png"
+        filepath = out_dir / filename
+        page.screenshot(path=str(filepath))
+        print(f"  [{step:02d}] {name}")
+
+    try:
+        from playwright.sync_api import sync_playwright
+
+        with sync_playwright() as p:
+            browser = p.chromium.launch(headless=not args.headed)
+            page = browser.new_page(viewport={"width": 1400, "height": 900})
+
+            # 1. Initial load
+            page.goto(base_url)
+            page.wait_for_selector("canvas", timeout=15_000)
+            # Wait for points to load
+            page.locator("text=points").first.wait_for(timeout=20_000)
+            page.wait_for_timeout(2_000)  # let deck.gl render
+            screenshot(page, "initial_load")
+
+            # 2. Switch basemap to OSM
+            page.locator("button", has_text="OpenStreetMap").click()
+            page.wait_for_timeout(1_500)
+            screenshot(page, "basemap_osm")
+
+            # 3. Switch basemap to Dark
+            page.locator("button", has_text="Dark").click()
+            page.wait_for_timeout(1_500)
+            screenshot(page, "basemap_dark")
+
+            # 4. Switch back to Satellite
+            page.locator("button", has_text="Satellite").click()
+            page.wait_for_timeout(1_000)
+
+            # 5. Change colormap to viridis
+            colormap_selects = page.locator("select").all()
+            for sel in colormap_selects:
+                options = sel.locator("option").all()
+                for opt in options:
+                    if opt.get_attribute("value") == "viridis":
+                        sel.select_option("viridis")
+                        break
+            page.wait_for_timeout(1_000)
+            screenshot(page, "colormap_viridis")
+
+            # 6. Add a filter
+            filter_input = page.locator("input[placeholder='val']")
+            if filter_input.count() > 0:
+                filter_input.fill("0.6")
+                page.locator("button", has_text="+").click()
+                page.wait_for_timeout(2_000)
+                screenshot(page, "filter_applied")
+                # Clear
+                clear_btn = page.locator("text=Clear all filters")
+                if clear_btn.count() > 0:
+                    clear_btn.click()
+                    page.wait_for_timeout(1_500)
+
+            # 7. Click center of map (try to hit a point)
+            canvas = page.locator("canvas").first
+            box = canvas.bounding_box()
+            assert box is not None
+            cx, cy = box["x"] + box["width"] / 2, box["y"] + box["height"] / 2
+            page.mouse.click(cx, cy)
+            page.wait_for_timeout(3_000)
+            screenshot(page, "after_click")
+
+            # 8. Check if chart appeared, take screenshot
+            chart_visible = page.locator("text=Displacement").count() > 0
+            if chart_visible:
+                screenshot(page, "timeseries_chart")
+
+                # 9. Click trend button
+                trend_btn = page.locator("button", has_text="Trend")
+                if trend_btn.count() > 0:
+                    trend_btn.click()
+                    page.wait_for_timeout(1_000)
+                    screenshot(page, "trend_enabled")
+
+                # 10. Shift+click another point for multi-select
+                page.mouse.click(cx + 50, cy + 30, modifiers=["Shift"])
+                page.wait_for_timeout(2_000)
+                screenshot(page, "multi_select")
+            else:
+                print("  (no point was hit — clicking empty area)")
+                screenshot(page, "no_point_hit")
+
+            # 11. Full page at final state
+            screenshot(page, "final_state")
+
+            browser.close()
+
+    finally:
+        proc.terminate()
+        proc.wait(timeout=5)
+        proc.stdout.close()
+        proc.stderr.close()
+
+    print(f"\nScreenshots saved to {out_dir}/")
+    print(f"  {step} screenshots captured")
+
+
+if __name__ == "__main__":
+    main()
diff --git a/vitest.config.ts b/vitest.config.ts
new file mode 100644
index 0000000..73a02f3
--- /dev/null
+++ b/vitest.config.ts
@@ -0,0 +1,11 @@
+import { defineConfig } from 'vitest/config';
+import react from '@vitejs/plugin-react';
+
+export default defineConfig({
+  plugins: [react()],
+  test: {
+    environment: 'jsdom',
+    globals: true,
+    setupFiles: './src/test/setup.ts',
+  },
+});